From cfe80dc70c58d5a639df9c6311d41c47c1d7b1fe Mon Sep 17 00:00:00 2001 From: mcnaughtonadm Date: Wed, 29 Nov 2023 22:11:41 -0800 Subject: [PATCH 1/8] Adding new class for wrapping typical ADVI workflow --- src/emll/bmca.py | 255 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 255 insertions(+) create mode 100644 src/emll/bmca.py diff --git a/src/emll/bmca.py b/src/emll/bmca.py new file mode 100644 index 0000000..85b0e86 --- /dev/null +++ b/src/emll/bmca.py @@ -0,0 +1,255 @@ +"""Code to actually implement the BMCA workflow in emll.""" + +import gzip +import os + +import cloudpickle +import cobra +import numpy as np +import pandas as pd +import pymc as pm +import pytensor.tensor as pt + +import emll + +os.environ["MKL_THREADING_LAYER"] = "GNU" + + +class BMCA: + """Class to build out BMCA experiment.""" + + def __init__( + self, + model_path, + v_star_path, + metabolite_concentrations_path, + boundary_fluxes_path, + enzyme_measurements_path, + reference_state, + ): + """Initialize the BMCA (Biochemical Model Calibration and Analysis) instance. + + Parameters + ---------- + model_path : str + The path to the YAML file containing the biochemical model. + + v_star_path : str + The path to the CSV file containing v_star data. + + metabolite_concentrations_path : str + The path to the CSV file containing metabolite concentrations data. + + boundary_fluxes_path : str + The path to the CSV file containing boundary fluxes data. + + enzyme_measurements_path : str + The path to the CSV file containing enzyme measurements data. + + reference_state : str + The reference state identifier for the experiment. + + pt.ributes + ---------- + model : cobra.Model + The biochemical model loaded from the provided YAML file. + + v_star : pandas.DataFrame + DataFrame containing v_star data loaded from the CSV file. + + x : pandas.DataFrame + DataFrame containing metabolite concentrations data loaded from the CSV file. + + v : pandas.DataFrame + DataFrame containing boundary fluxes data loaded from the CSV file. + + e : pandas.DataFrame + DataFrame containing enzyme measurements data loaded from the CSV file. + + ref_state : str + The reference state identifier used in the experiment. + """ + self.model = cobra.io.load_yaml_model(model_path) + self.v_star = pd.read_csv(v_star_path, header=None, index_col=0)[1] + self.x = pd.read_csv(metabolite_concentrations_path, index_col=0) + self.v = pd.read_csv(boundary_fluxes_path, index_col=0) + self.e = pd.read_csv(enzyme_measurements_path, index_col=0) + + self.ref_state = reference_state + + def preprocess_data(self): + """Read in cobra model as components.""" + # Establish compartments for reactions and metabolites + self.r_compartments = [ + r.compartments if "e" not in r.compartments else "t" for r in self.model.reactions + ] + + self.r_compartments[self.model.reactions.index("SUCCt2r")] = "c" + self.r_compartments[self.model.reactions.index("ACt2r")] = "c" + + for rxn in self.model.exchanges: + self.r_compartments[self.model.reactions.index(rxn)] = "t" + + self.m_compartments = [m.compartment for m in self.model.metabolites] + # Reindex arrays to have the same column ordering + to_consider = self.v.columns + self.v = self.v.loc[:, to_consider] + self.x = self.x.loc[:, to_consider] + self.e = self.e.loc[:, to_consider] + + self.n_exp = len(to_consider) - 1 + + # Drop reference state + self.vn = ( + self.v.drop(self.ref_state) + .divide(self.v.drop(self.ref_state)["flux"], axis=0) + .drop("flux", axis=1) + .T + ) + self.xn = (self.x.subtract(self.x[self.ref_state], 0) * np.log(2)).T + self.en = (2 ** self.e.subtract(self.e[self.ref_state], 0)).T + + # Get indexes for measured values + self.x_inds = np.array([self.model.metabolites.index(met) for met in self.xn.columns]) + self.e_inds = np.array([self.model.reactions.index(rxn) for rxn in self.en.columns]) + self.v_inds = np.array([self.model.reactions.index(rxn) for rxn in self.vn.columns]) + + self.e_laplace_inds = [] + self.e_zero_inds = [] + + for i, rxn in enumerate(self.model.reactions): + if rxn.id not in self.en.columns: + if ("e" not in rxn.compartments) and (len(rxn.compartments) == 1): + self.e_laplace_inds += [i] + else: + self.e_zero_inds += [i] + + self.e_laplace_inds = np.array(self.e_laplace_inds) + self.e_zero_inds = np.array(self.e_zero_inds) + self.e_indexer = np.hstack([self.e_inds, self.e_laplace_inds, self.e_zero_inds]).argsort() + + self.N = cobra.util.create_stoichiometric_matrix(self.model) + self.Ex = emll.util.create_elasticity_matrix(self.model) + self.Ey = emll.util.create_Ey_matrix(self.model) + + self.Ex *= 0.1 + 0.8 * np.random.rand(*self.Ex.shape) + + self.ll = emll.LinLogLeastNorm(self.N, self.Ex, self.Ey, self.v_star.values, driver="gelsy") + + def build_pymc_model(self): + """Build the PyMC probabilistic model.""" + with pm.Model() as pymc_model: + # Priors on elasticity values + self.Ex_t = pm.Deterministic( + "Ex", + emll.initialize_elasticity( + self.ll.N, + b=0.01, + sigma=1, + alpha=None, + m_compartments=self.m_compartments, + r_compartments=self.r_compartments, + ), + ) + + self.Ey_t = T.as_tensor_variable(self.Ey) + + e_measured = pm.Normal( + "log_e_measured", + mu=np.log(self.en), + sigma=0.2, + shape=(self.n_exp, len(self.e_inds)), + ) + e_unmeasured = pm.Laplace( + "log_e_unmeasured", mu=0, b=0.1, shape=(self.n_exp, len(self.e_laplace_inds)) + ) + log_en_t = pt.concatenate( + [e_measured, e_unmeasured, pt.zeros((self.n_exp, len(self.e_zero_inds)))], axis=1 + )[:, self.e_indexer] + + pm.Deterministic("log_en_t", log_en_t) + + # Priors on external concentrations + yn_t = pm.Normal( + "yn_t", + mu=0, + sigma=10, + shape=(self.n_exp, self.ll.ny), + initval=0.1 * np.random.randn(self.n_exp, self.ll.ny), + ) + + chi_ss, vn_ss = self.ll.steady_state_pytensor( + self.Ex_t, self.Ey_t, pt.exp(log_en_t), yn_t + ) + pm.Deterministic("chi_ss", chi_ss) + pm.Deterministic("vn_ss", vn_ss) + + log_vn_ss = pt.log(pt.clip(vn_ss[:, self.v_inds], 1e-8, 1e8)) + log_vn_ss = pt.clip(log_vn_ss, -1.5, 1.5) + + chi_clip = pt.clip(chi_ss[:, self.x_inds], -1.5, 1.5) + + chi_obs = pm.Normal( + "chi_obs", mu=chi_clip, sigma=0.2, observed=self.xn.clip(lower=-1.5, upper=1.5) + ) + log_vn_obs = pm.Normal( + "vn_obs", + mu=log_vn_ss, + sigma=0.1, + observed=np.log(self.vn).clip(lower=-1.5, upper=1.5), + ) + + self.pymc_model = pymc_model + + def run_emll(self): + """Build linlog model and run inference.""" + with self.pymc_model: + approx = pm.ADVI() + hist = approx.fit( + n=40000, + obj_optimizer=pm.adagrad_window(learning_rate=0.005), + total_grad_norm_constraint=100, + ) + + # trace = hist.sample(500) + # ppc = pm.sample_ppc(trace) + + return approx, hist + + def save_results(self, approx, hist): + """Save ADVI results in cloudpickle.""" + with gzip.open("data/{self.model.name}.pgz", "wb") as f: + cloudpickle.dump( + { + "approx": approx, + "hist": hist, + }, + f, + ) + + +def main( + model_path, + v_star_path, + metabolite_concentrations_path, + boundary_fluxes_path, + enzyme_measurements_path, + reference_state, +): + """Run BMCA for the provided model.""" + emll_model = BMCA( + model_path, + v_star_path, + metabolite_concentrations_path, + boundary_fluxes_path, + enzyme_measurements_path, + reference_state, + ) + emll_model.preprocess_data() + emll_model.build_pymc_model() + approx, hist = emll_model.run_emll() + emll_model.save_results(approx, hist) + + +if __name__ == "__main__": + pass From 20330bee3ced3bff7834facc4f831730c7777af2 Mon Sep 17 00:00:00 2001 From: "andrew.mcnaughton@pnnl.gov" Date: Thu, 1 Feb 2024 15:30:04 -0800 Subject: [PATCH 2/8] Minor linting --- pyproject.toml | 75 +++++++++++++++++++++++++++++++++++++++++++++++- src/emll/bmca.py | 26 ++++++++--------- 2 files changed, 87 insertions(+), 14 deletions(-) diff --git a/pyproject.toml b/pyproject.toml index d95d496..35ddaba 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,4 +11,77 @@ profile = "black" multi_line_output = 3 line_length = 100 include_trailing_comma = true -reverse_relative = true \ No newline at end of file +reverse_relative = true + +[tool.ruff] +line-length = 100 +select = [ + # mccabe + "C90", + # flake-8 comprehensions + "C4", + # pycodestyle + "E", # Error + "W", # Warning + # PyFlakes + "F", + # flake8-bugbear + "B", + # flake8-simplify + "SIM", + # isort + "I", + # type checking + "TCH", + # flake8-print + "T2", + # pep8-naming + "N", + # pydocstyle + "D", + # flake8-bandit + "S", + +] +show-fixes = true +exclude = [ + ".tox", + ".git", + "__pycache__", + "build", + "dist", + "tests/fixtures/*", + "*.pyc", + "*.egg-info", + ".cache", + ".eggs", + "data", +] + +[tool.ruff.lint] +# 1. Enable flake8-bugbear (`B`) rules, in addition to the defaults. +# select = ["E4", "E7", "E9", "F", "B"] + +# 2. Avoid enforcing line-length violations (`E501`) +ignore = ["E501","D203", "D213"] + +# 3. Avoid trying to fix flake8-bugbear (`B`) violations. +unfixable = ["B"] + +# 4. Ignore `E402` (import violations) in all `__init__.py` files, and in select subdirectories. +[tool.ruff.lint.per-file-ignores] +"__init__.py" = ["E402"] +"**/{tests,docs,tools}/*" = ["E402"] + +[tool.ruff.format] +# Like Black, use double quotes for non-triple-quoted strings. +quote-style = "double" +# Like Black, indent with spaces, rather than tabs. +indent-style = "space" +# Like Black, respect magic trailing commas. +skip-magic-trailing-comma = false +# Like Black, automatically detect the appropriate line ending. +line-ending = "auto" + +[tool.ruff.mccabe] +max-complexity = 20 diff --git a/src/emll/bmca.py b/src/emll/bmca.py index 85b0e86..b7f92c5 100644 --- a/src/emll/bmca.py +++ b/src/emll/bmca.py @@ -20,22 +20,22 @@ class BMCA: def __init__( self, - model_path, - v_star_path, - metabolite_concentrations_path, - boundary_fluxes_path, - enzyme_measurements_path, - reference_state, + model_path: str, + v_star_path: str, + metabolite_concentrations_path: str, + boundary_fluxes_path: str, + enzyme_measurements_path: str, + reference_state: str, ): - """Initialize the BMCA (Biochemical Model Calibration and Analysis) instance. + """Initialize the BMCA (Bayesian Metabolic Control Analysis) instance. Parameters ---------- model_path : str - The path to the YAML file containing the biochemical model. + The path to the SBML file containing the model. v_star_path : str - The path to the CSV file containing v_star data. + The path to the CSV file containing reference flux data. metabolite_concentrations_path : str The path to the CSV file containing metabolite concentrations data. @@ -49,10 +49,10 @@ def __init__( reference_state : str The reference state identifier for the experiment. - pt.ributes + attributes ---------- model : cobra.Model - The biochemical model loaded from the provided YAML file. + The biochemical model loaded from the provided SBML file. v_star : pandas.DataFrame DataFrame containing v_star data loaded from the CSV file. @@ -152,7 +152,7 @@ def build_pymc_model(self): ), ) - self.Ey_t = T.as_tensor_variable(self.Ey) + self.Ey_t = pt.as_tensor_variable(self.Ey) e_measured = pm.Normal( "log_e_measured", @@ -218,7 +218,7 @@ def run_emll(self): def save_results(self, approx, hist): """Save ADVI results in cloudpickle.""" - with gzip.open("data/{self.model.name}.pgz", "wb") as f: + with gzip.open(f"data/{self.model.name}.pgz", "wb") as f: cloudpickle.dump( { "approx": approx, From ee2d5b76a4cb3b7323da0c8b60f5e2905c39b893 Mon Sep 17 00:00:00 2001 From: ShantMahserejian Date: Tue, 6 Feb 2024 15:05:31 -0800 Subject: [PATCH 3/8] Adding and accomodating code for testing functions in bmca.py --- src/emll/bmca.py | 31 ++++++----- tests/test_bmca.py | 132 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 147 insertions(+), 16 deletions(-) create mode 100644 tests/test_bmca.py diff --git a/src/emll/bmca.py b/src/emll/bmca.py index b7f92c5..ce4cb43 100644 --- a/src/emll/bmca.py +++ b/src/emll/bmca.py @@ -20,22 +20,22 @@ class BMCA: def __init__( self, - model_path: str, - v_star_path: str, - metabolite_concentrations_path: str, - boundary_fluxes_path: str, - enzyme_measurements_path: str, - reference_state: str, + model_path, + v_star_path, + metabolite_concentrations_path, + boundary_fluxes_path, + enzyme_measurements_path, + reference_state, ): - """Initialize the BMCA (Bayesian Metabolic Control Analysis) instance. + """Initialize the BMCA (Biochemical Model Calibration and Analysis) instance. Parameters ---------- model_path : str - The path to the SBML file containing the model. + The path to the YAML file containing the biochemical model. v_star_path : str - The path to the CSV file containing reference flux data. + The path to the CSV file containing v_star data. metabolite_concentrations_path : str The path to the CSV file containing metabolite concentrations data. @@ -49,10 +49,10 @@ def __init__( reference_state : str The reference state identifier for the experiment. - attributes + pt.ributes ---------- model : cobra.Model - The biochemical model loaded from the provided SBML file. + The biochemical model loaded from the provided YAML file. v_star : pandas.DataFrame DataFrame containing v_star data loaded from the CSV file. @@ -69,6 +69,7 @@ def __init__( ref_state : str The reference state identifier used in the experiment. """ + # TODO: create a load model function for different files types (yaml, sbml) self.model = cobra.io.load_yaml_model(model_path) self.v_star = pd.read_csv(v_star_path, header=None, index_col=0)[1] self.x = pd.read_csv(metabolite_concentrations_path, index_col=0) @@ -83,14 +84,12 @@ def preprocess_data(self): self.r_compartments = [ r.compartments if "e" not in r.compartments else "t" for r in self.model.reactions ] - self.r_compartments[self.model.reactions.index("SUCCt2r")] = "c" self.r_compartments[self.model.reactions.index("ACt2r")] = "c" - for rxn in self.model.exchanges: self.r_compartments[self.model.reactions.index(rxn)] = "t" - self.m_compartments = [m.compartment for m in self.model.metabolites] + # Reindex arrays to have the same column ordering to_consider = self.v.columns self.v = self.v.loc[:, to_consider] @@ -152,7 +151,7 @@ def build_pymc_model(self): ), ) - self.Ey_t = pt.as_tensor_variable(self.Ey) + self.Ey_t = T.as_tensor_variable(self.Ey) e_measured = pm.Normal( "log_e_measured", @@ -218,7 +217,7 @@ def run_emll(self): def save_results(self, approx, hist): """Save ADVI results in cloudpickle.""" - with gzip.open(f"data/{self.model.name}.pgz", "wb") as f: + with gzip.open("data/{self.model.name}.pgz", "wb") as f: cloudpickle.dump( { "approx": approx, diff --git a/tests/test_bmca.py b/tests/test_bmca.py new file mode 100644 index 0000000..6c050b9 --- /dev/null +++ b/tests/test_bmca.py @@ -0,0 +1,132 @@ +import pytest +from src.emll import bmca +import cobra +import pandas as pd + + +# Get hackett data and initialize BMCA object +@pytest.fixture(scope="module") +def hackett_bmca_obj(): + hackett_paths = { + "model_path": "notebooks/data/data/jol2012.yaml", + "v_star_path": "notebooks/data/v_star.csv", + "metabolite_concentrations_path": "notebooks/data/metabolite_concentrations.csv", + "boundary_fluxes_path": "notebooks/data/boundary_fluxes.csv", + "enzyme_measurements_path": "notebooks/data/enzyme_measurements.csv", + "reference_state": "P0.11", + } + bmca_obj = bmca.BMCA( + model_path = hackett_paths["model_path"], + metabolite_concentrations_path = hackett_paths["metabolite_concentrations_path"], + enzyme_measurements_path = hackett_paths["enzyme_measurements_path"], + reference_state = hackett_paths["reference_state"], + boundary_fluxes_path = hackett_paths["boundary_fluxes_path"], + v_star_path = hackett_paths["v_star_path"], + ) + return bmca_obj + + +# Test types of initialized BMCA object +def test_init_type(hackett_bmca_obj): + bmca_obj = hackett_bmca_obj() + + assert isinstance(bmca_obj.model, cobra.core.model.Model) + assert isinstance(bmca_obj.x, pd.DataFrame) + assert isinstance(bmca_obj.e, pd.DataFrame) + assert (bmca_obj.reference_state in bmca_obj.x.columns) and (bmca_obj.reference_state in bmca_obj.e.columns) and (bmca_obj.reference_state in bmca_obj.v.columns) + assert isinstance(bmca_obj.v, pd.DataFrame) + + # Future will remove v_star from initialized object + assert isinstance(bmca_obj.v_star, pd.DataFrame) + + +# Test BMCA object initial structure +def test_initial_structure(hackett_bmca_obj): + bmca_obj = hackett_bmca_obj() + + # Check if metabolomics & enzyme measurement AND flux data rows are in the model + with bmca_obj.model as model: + metabs = [m.id[:-2] for m in model.metabolites] + rxns = [r.id for r in model.reactions] + assert all([m in metabs for m in bmca_obj.x.index.values]) + assert all([r in rxns for r in bmca_obj.e.index.values]) + assert all([r in rxns for r in bmca_obj.v.index.values]) + + # Check if metabolomics & enzyme measurements have same # of columns & same column names + assert bmca_obj.x.columns.is_unique + assert bmca_obj.e.columns.is_unique + assert bmca_obj.x.shape[1] == bmca_obj.e.shape[1] + assert all(bmca_obj.x.columns.values == bmca_obj.e.columns.values) + + # Check if flux dataframes have same # of columns & same column names as metabolomics measurements + assert bmca_obj.v.columns.is_unique + assert bmca_obj.v.shape[1] == bmca_obj.x.shape[1] + assert all(bmca_obj.v.columns.values == bmca_obj.x.columns.values) + + # Check that v_star is the referenced column of the flux data + # assert bmca_obj.v_star.equals(bmca_obj.v[bmca_obj.v[reference_state]) + + + +# Run preprocess of BMCA data to test each sub-routine +@pytest.fixture(scope="module") +def preprocessed_bmca_obj(hackett_bmca_obj): + bmca_obj = hackett_bmca_obj() + return bmca_obj.preprocess_data() + + +# Test establishing compartments +def test_establish_compartments(preprocessed_bmca_obj): + bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) + + # TODO: check r_compartments and m_compartments + + pass + +def test_reindexing_bmca_slots(preprocessed_bmca_obj): + bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) + + # TODO: check x, v, and e slots in bmca_obj for changes + pass + +def test_normalizing_bmca_slots(preprocessed_bmca_obj): + bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) + + # TODO: check normalization of x, v, and e as xn, vn, and en slots in bmca_obj + pass + +def test_index_measured_bmca_slots(preprocessed_bmca_obj): + bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) + + # TODO: check x_inds, e_inds, v_inds, e_laplace_inds, e_zero_inds, slots in bmca_obj + pass + +def test_new_matrices(preprocessed_bmca_obj): + bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) + + # TODO: check N, Ex, Ey, ll slots in bmca_obj + pass + + +# Build pymc model +def pymc_model_bmca_obj(preprocessed_bmca_obj): + bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) + bmca_obj.build_pymc_model() + + return bmca_obj + + +# Test building pymc model +def test_build_pymc_model(pymc_model_bmca_obj, preprocessed_bmca_obj, hackett_bmca_obj): # ** Do I need to pass hackett_bmca_obj here? + bmca_obj = pymc_model_bmca_obj(preprocessed_bmca_obj(hackett_bmca_obj)) + + # TODO: check Ex_t, Ey_t, pymc_model slots in bmca_obj + pass + +# Test running ADVI +def test_run_advi(pymc_model_bmca_obj, preprocessed_bmca_obj, hackett_bmca_obj): + bmca_obj = pymc_model_bmca_obj(preprocessed_bmca_obj(hackett_bmca_obj)) + approx, hist = emll_model.run_emll() + + # TODO: check approx, hist + pass From 3fa4185b2522d1a18a3ba6ffc0534413bb58cf33 Mon Sep 17 00:00:00 2001 From: ShantMahserejian Date: Tue, 6 Feb 2024 15:41:16 -0800 Subject: [PATCH 4/8] Moving testing files to /tests directory --- {src/emll => tests}/test_linlog_model.py | 0 {src/emll => tests}/test_pytensor_utils.py | 0 2 files changed, 0 insertions(+), 0 deletions(-) rename {src/emll => tests}/test_linlog_model.py (100%) rename {src/emll => tests}/test_pytensor_utils.py (100%) diff --git a/src/emll/test_linlog_model.py b/tests/test_linlog_model.py similarity index 100% rename from src/emll/test_linlog_model.py rename to tests/test_linlog_model.py diff --git a/src/emll/test_pytensor_utils.py b/tests/test_pytensor_utils.py similarity index 100% rename from src/emll/test_pytensor_utils.py rename to tests/test_pytensor_utils.py From 91c573f66229faabb6cb5aa33a6691e1b9a5ecbc Mon Sep 17 00:00:00 2001 From: ShantMahserejian Date: Fri, 1 Mar 2024 15:18:50 -0800 Subject: [PATCH 5/8] Catching up on moving/cleaning up files, creating new tests, and modifying notebooks for BMCA unit tests --- notebooks/contador.ipynb | 2 +- notebooks/wu2004.ipynb | 5250 +++++++++++++---- src/emll/__init__.py | 3 +- src/emll/bmca.py | 86 +- src/emll/preprocess.py | 49 + src/emll/pymc_utils.py | 60 + src/emll/util.py | 53 +- tests/test_bmca.py | 147 +- .../expected_wu2004_FCC_posterior_ADVI.csv | 3001 ++++++++++ .../expected_wu2004_FCC_posterior_NUTS.csv | 1501 +++++ tests/test_data/expected_wu2004_FCCpriors.csv | 4 + tests/test_data/metab_colnames.csv | 25 + tests/test_data/metab_rownames.csv | 75 + tests/test_data/metab_rownames.xlsx | Bin 0 -> 9690 bytes .../metabolite_concentrations_clean.csv | 76 + .../test_models/BIOMD0000000064.xml | 0 {src/emll => tests}/test_models/__init__.py | 0 .../test_models/common_utils.py | 0 {src/emll => tests}/test_models/contador.json | 0 tests/test_models/contador_updatedbounds.json | 766 +++ .../test_models/jol2012_trimmed.json | 0 .../test_models/jol2012_vstar.p | Bin .../test_models/mendes_model.py | 0 .../test_models/textbook_reduced.json | 0 tests/test_models/wu2004_model.json | 71 + tests/test_models/wu2004_model.sbml | 24 + tests/test_preprocess.py | 54 + tests/test_priorpredictive.py | 42 + 28 files changed, 10179 insertions(+), 1110 deletions(-) create mode 100644 src/emll/preprocess.py create mode 100644 src/emll/pymc_utils.py create mode 100644 tests/test_data/expected_wu2004_FCC_posterior_ADVI.csv create mode 100644 tests/test_data/expected_wu2004_FCC_posterior_NUTS.csv create mode 100644 tests/test_data/expected_wu2004_FCCpriors.csv create mode 100644 tests/test_data/metab_colnames.csv create mode 100644 tests/test_data/metab_rownames.csv create mode 100644 tests/test_data/metab_rownames.xlsx create mode 100644 tests/test_data/metabolite_concentrations_clean.csv rename {src/emll => tests}/test_models/BIOMD0000000064.xml (100%) rename {src/emll => tests}/test_models/__init__.py (100%) rename {src/emll => tests}/test_models/common_utils.py (100%) rename {src/emll => tests}/test_models/contador.json (100%) create mode 100644 tests/test_models/contador_updatedbounds.json rename {src/emll => tests}/test_models/jol2012_trimmed.json (100%) rename {src/emll => tests}/test_models/jol2012_vstar.p (100%) rename {src/emll => tests}/test_models/mendes_model.py (100%) rename {src/emll => tests}/test_models/textbook_reduced.json (100%) create mode 100644 tests/test_models/wu2004_model.json create mode 100644 tests/test_models/wu2004_model.sbml create mode 100644 tests/test_preprocess.py create mode 100644 tests/test_priorpredictive.py diff --git a/notebooks/contador.ipynb b/notebooks/contador.ipynb index ba7b0ea..082177b 100644 --- a/notebooks/contador.ipynb +++ b/notebooks/contador.ipynb @@ -426,7 +426,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWEAAAEYCAYAAACN0kfeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", + "image/png": "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", "text/plain": [ "" ] diff --git a/notebooks/wu2004.ipynb b/notebooks/wu2004.ipynb index 588fcf1..90f6ece 100644 --- a/notebooks/wu2004.ipynb +++ b/notebooks/wu2004.ipynb @@ -38,6 +38,14 @@ "name": "stderr", "output_type": "stream", "text": [ + "/var/folders/k9/b8pxky2572sdtgy2vnxhcljw0000gn/T/ipykernel_61804/3008229323.py:4: DeprecationWarning: \n", + "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", + "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", + "but was not found to be installed on your system.\n", + "If this would cause problems for you,\n", + "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", + " \n", + " import pandas as pd\n", "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" ] } @@ -80,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 88, "metadata": {}, "outputs": [], "source": [ @@ -89,8 +97,10 @@ "model = cobra.Model()\n", "\n", "model.add_metabolites([\n", - " cobra.Metabolite('2pg'),\n", - " cobra.Metabolite('pep'),\n", + " cobra.Metabolite('bpg_e', compartment='e'),\n", + " cobra.Metabolite('2pg_c', compartment='c'),\n", + " cobra.Metabolite('pep_c', compartment='c'),\n", + " cobra.Metabolite('adp_e', compartment='e'),\n", " ])\n", "\n", "model.add_reactions([\n", @@ -99,13 +109,26 @@ " cobra.Reaction('PK'),\n", " ])\n", "\n", - "model.reactions.PGM.reaction = '<=> 2pg'\n", - "model.reactions.ENO.reaction = '2pg <=> pep'\n", - "model.reactions.PK.reaction = 'pep <=>'\n", + "# model.reactions.EX_PGM.reaction = '<=> 2pg_e'\n", + "model.reactions.PGM.reaction = '<=> 2pg_c'\n", + "model.reactions.ENO.reaction = '2pg_c <=> pep_c'\n", + "model.reactions.PK.reaction = 'pep_c + adp_e <=> pep_e'\n", + "# model.reactions.EX_PK.reaction = 'pep_e <=>'\n", "\n", "N = cobra.util.create_stoichiometric_matrix(model, dtype='int')" ] }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [], + "source": [ + "# Save model to file\n", + "model_fname = \"../tests/test_models/wu2004_model.sbml\"\n", + "cobra.io.write_sbml_model(model, model_fname)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -115,7 +138,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -218,7 +241,7 @@ "4 25.0 12.0 30.0 54.0 76.0 13.2 130.0 136.0" ] }, - "execution_count": 5, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -238,7 +261,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 85, "metadata": {}, "outputs": [], "source": [ @@ -263,7 +286,27 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 86, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([87., 87., 87.])" + ] + }, + "execution_count": 86, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "v_star" + ] + }, + { + "cell_type": "code", + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -272,7 +315,7 @@ "19" ] }, - "execution_count": 7, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -290,7 +333,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -304,6 +347,28 @@ "ll = emll.LinLogSymbolic2x2(N, Ex, Ey, v_star)" ] }, + { + "cell_type": "code", + "execution_count": 87, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[1., 0.],\n", + " [0., 0.],\n", + " [0., 1.]])" + ] + }, + "execution_count": 87, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Ey" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -315,7 +380,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -324,7 +389,7 @@ "(2, 3)" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -335,7 +400,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -344,13 +409,13 @@ "Text(0, 0.5, 'Probability density')" ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -384,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -438,7 +503,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -462,295 +527,43 @@ }, { "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "with pymc_model:\n", - " \n", - " # Error priors. \n", - " v_err = pm.HalfNormal('v_error', sigma=0.05, initval=.1)\n", - " x_err = pm.HalfNormal('x_error', sigma=0.05, initval=.1)\n", - "\n", - " # Calculate steady-state concentrations and fluxes from elasticities\n", - " chi_ss, v_hat_ss = ll.steady_state_pytensor(Ex_t, Ey_t, en, yn)\n", - "\n", - " # Error distributions for observed steady-state concentrations and fluxes\n", - " chi_obs = pm.Normal('chi_obs', mu=chi_ss, sigma=x_err, observed=xn)\n", - " v_hat_obs = pm.Normal('v_hat_obs', mu=v_hat_ss[:, 0].squeeze(),\n", - " sigma=v_err, observed=vn.squeeze())\n", - "\n", - "#print(pymc_model.logpt.tag.test_value)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "This is the actual computationally intensive portion, where we sample the posterior distribution using hamiltonian monte carlo." - ] - }, - { - "cell_type": "code", - "execution_count": 18, + "execution_count": 14, "metadata": {}, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Multiprocess sampling (4 chains in 4 jobs)\n", - "NUTS: [ex_kinetic_entries, ex_capacity_entries, ey_kinetic_entries, ey_capacity_entries, v_error, x_error]\n" - ] - }, { "data": { "text/html": [ "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "\n", - "
\n", - " \n", - " 100.00% [6000/6000 00:37<00:00 Sampling 4 chains, 0 divergences]\n", - "
\n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Sampling 4 chains for 1_000 tune and 500 draw iterations (4_000 + 2_000 draws total) took 37 seconds.\n", - "The rhat statistic is larger than 1.01 for some parameters. This indicates problems during sampling. See https://arxiv.org/abs/1903.08008 for details\n" - ] - } - ], - "source": [ - "with pymc_model:\n", - " trace = pm.sample(500, random_seed=123, tune=1000,step=pm.NUTS(), n_init=1000, nuts_sampler_kwargs=dict(njobs=4))\n", - "\n", - " #trace = pm.sample(500, random_seed=123, tune=1000,\n", - " # init='nuts', n_init=1000)" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "collapsed": true, - "jupyter": { - "outputs_hidden": true - } - }, - "source": [ - "If desired, the trace object can be pickled for later use" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# import gzip\n", - "# import pickle\n", - "\n", - "# with gzip.open('data/wu_trace.pgz', 'wb') as f:\n", - "# pickle.dump(trace, f)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# Values for wu 'optimized elasticity' from the same reference state\n", - "e_wu = np.array([-0.55 , -1.30 , 1.53 , 0 , 0.76 , -3.10 ,\n", - " 1.86 , 0 , -0.25 , 0 , 0.54 , 0.70]).reshape((3, -1))\n", - "\n", - "ex_wu = e_wu[:, :2]\n", - "ey_wu = e_wu[:, 2:]" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/mcna892/mambaforge/envs/emll_dev/lib/python3.11/site-packages/arviz/plots/backends/matplotlib/traceplot.py:217: UserWarning: A valid var_name should be provided, found {'E'} expected from {'x_error', 'Ex', 'Ey', 'v_error'}\n", - " warnings.warn(\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "tp = pm.plot_trace(trace, var_names=['Ex', 'Ey', 'v_error', 'x_error'], combined=True,\n", - " lines={'Ex': ex_wu.T.flatten(), 'Ey': ey_wu.T.flatten()})\n", - "sns.despine()\n", - "\n", - "for ax in tp.flatten():\n", - " ax.set_rasterized(True)\n", - "\n", - "# plt.savefig('wu_trace.svg', dpi=100, transparent=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "ex = trace.posterior['Ex'].to_numpy().reshape((2000, -1))\n", - "ey = trace.posterior['Ey'].to_numpy().reshape((2000, -1))\n", - "e_all = np.hstack([ex, ey])" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [], - "source": [ - "m_labels = [m.id for m in model.metabolites]\n", - "r_labels = [r.id for r in model.reactions]\n", - "y_labels = ['BPG', 'ADP']\n", - "\n", - "ex_labels = np.array([['$\\epsilon_{' + '{0},{1}'.format(rlabel, mlabel) + '}$'\n", - " for mlabel in m_labels] for rlabel in r_labels]).flatten()\n", - "ey_labels = np.array([['$\\epsilon_{' + '{0},{1}'.format(rlabel, mlabel) + '}$'\n", - " for mlabel in y_labels] for rlabel in r_labels]).flatten()\n", - "\n", - "e_labels = np.hstack((ex_labels, ey_labels))" - ] - }, - { - "cell_type": "code", - "execution_count": 108, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 108, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "fig = plt.figure(figsize=(6,3))\n", - "\n", - "ax = plt.subplot2grid((1, 4), (0, 0), colspan=3)\n", - "\n", - "ax.plot(ex, '.', ms=4, alpha=.25, rasterized=True)\n", - "ax.axvspan(500, 1000, zorder=0, color='.85')\n", - "ax.axvspan(1500, 2000, zorder=0, color='.85')\n", - "ax.set_xlim([0, 2000])\n", - "\n", - "\n", - "sns.despine(trim=True, offset=10, ax=ax)\n", - "ax.set_ylabel('Elasticity')\n", - "ax.set_xlabel('Sample')\n", - "\n", - "ax2 = plt.subplot2grid((1, 4), (0, 3), colspan=1, fig=fig, sharey=ax)\n", - "ax2.xaxis.set_visible(False)\n", - "sns.despine(trim=True, offset=10, ax=ax2, bottom=True)\n", - "\n", - "colors = sns.color_palette()\n", - "for i in ex.mean(0).argsort()[::-1]:\n", - " x, y = pm.kde(ex[:, i])\n", - " ax2.plot(y, x, label=e_labels[i], color=colors[i])\n", - "\n", - "plt.setp(ax2.get_yticklabels(), visible=False)\n", - "plt.tight_layout()\n", - " \n", - "ax2.legend(loc='center left', fontsize=12, bbox_to_anchor=(1.2, .5), labelspacing=0)\n", - " \n", - "# plt.savefig('wu_trace_subset.svg', dpi=200)" - ] - }, - { - "cell_type": "code", - "execution_count": 110, - "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:                   (ey_kinetic_entries_dim_0: 2, hdi: 2)\n",
-       "Coordinates:\n",
-       "  * ey_kinetic_entries_dim_0  (ey_kinetic_entries_dim_0) int64 0 1\n",
-       "  * hdi                       (hdi) <U6 'lower' 'higher'\n",
-       "Data variables:\n",
-       "    ey_kinetic_entries        (ey_kinetic_entries_dim_0, hdi) float64 0.481 ....
" - ], - "text/plain": [ - "\n", - "Dimensions: (ey_kinetic_entries_dim_0: 2, hdi: 2)\n", + "Dimensions: (chain: 1, draw: 500,\n", + " ey_capacity_entries_dim_0: 4, Ex_dim_0: 3,\n", + " Ex_dim_1: 2, Ey_dim_0: 3, Ey_dim_1: 2,\n", + " ey_kinetic_entries_dim_0: 2,\n", + " ex_kinetic_entries_dim_0: 4,\n", + " ex_capacity_entries_dim_0: 2)\n", "Coordinates:\n", - " * ey_kinetic_entries_dim_0 (ey_kinetic_entries_dim_0) int64 0 1\n", - " * hdi (hdi) \n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
<xarray.Dataset>\n",
-       "Dimensions:                    (ey_capacity_entries_dim_0: 4, hdi: 2)\n",
-       "Coordinates:\n",
-       "  * ey_capacity_entries_dim_0  (ey_capacity_entries_dim_0) int64 0 1 2 3\n",
-       "  * hdi                        (hdi) <U6 'lower' 'higher'\n",
-       "Data variables:\n",
-       "    ey_capacity_entries        (ey_capacity_entries_dim_0, hdi) float64 0.095...
" + ".xr-wrap{width:700px!important;} " ], "text/plain": [ - "\n", - "Dimensions: (ey_capacity_entries_dim_0: 4, hdi: 2)\n", - "Coordinates:\n", - " * ey_capacity_entries_dim_0 (ey_capacity_entries_dim_0) int64 0 1 2 3\n", - " * hdi (hdi) prior" ] }, - "execution_count": 111, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "pm.hdi(trace.posterior['ey_capacity_entries'])" + "trace_prior" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "e_df = pd.DataFrame(e_all, columns=e_labels)\n", - "e_df.apply(pm.hdi)" + "with pymc_model:\n", + " \n", + " # Error priors. \n", + " v_err = pm.HalfNormal('v_error', sigma=0.05, initval=.1)\n", + " x_err = pm.HalfNormal('x_error', sigma=0.05, initval=.1)\n", + "\n", + " # Calculate steady-state concentrations and fluxes from elasticities\n", + " chi_ss, v_hat_ss = ll.steady_state_pytensor(Ex_t, Ey_t, en, yn)\n", + "\n", + " # Error distributions for observed steady-state concentrations and fluxes\n", + " chi_obs = pm.Normal('chi_obs', mu=chi_ss, sigma=x_err, observed=xn)\n", + " v_hat_obs = pm.Normal('v_hat_obs', mu=v_hat_ss[:, 0].squeeze(),\n", + " sigma=v_err, observed=vn.squeeze())\n", + "\n", + "#print(pymc_model.logpt.tag.test_value)" ] }, { - "cell_type": "code", - "execution_count": 115, + "cell_type": "markdown", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(0.1, 11.9)" - ] - }, - "execution_count": 115, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ - "fig, axmatrix = plt.subplots(nrows=12, ncols=12, figsize=(6, 6))\n", - "\n", - "for ax in axmatrix.flatten():\n", - " ax.get_xaxis().set_ticks([])\n", - " ax.get_yaxis().set_ticks([])\n", - "\n", - "for i in range(12):\n", - " for j in range(12):\n", - " if i is not j:\n", - " axmatrix[i,j].plot(e_all[:, i], e_all[:, j],\n", - " 'k.', alpha=0.1, ms=1, rasterized=True)\n", - " else:\n", - " axmatrix[i,j].hist(e_all[:, i], bins=5, color='k', edgecolor='w', lw=1)\n", - " \n", - "_ = ax_all = fig.add_subplot(111, frameon=False)\n", - "_ = ax_all.set_xticks(np.arange(12) + 0.5)\n", - "_ = ax_all.set_xticklabels(e_labels, rotation=90)\n", - "_ = ax_all.set_yticks(np.arange(12) + 0.5)\n", - "_ = ax_all.set_yticklabels(e_labels[::-1])\n", - "\n", - "ax_all.set_xlim([0.1, 11.9])\n", - "ax_all.set_ylim([0.1, 11.9])\n", - "\n", - "# fig.savefig('elasticity_pairplot.svg', dpi=400, transparent=True)" + "This is the actual computationally intensive portion, where we sample the posterior distribution using hamiltonian monte carlo." ] }, { "cell_type": "code", - "execution_count": 117, + "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "Sampling: [chi_obs, v_hat_obs]\n" + "Multiprocess sampling (4 chains in 4 jobs)\n", + "NUTS: [ex_kinetic_entries, ex_capacity_entries, ey_kinetic_entries, ey_capacity_entries, v_error, x_error]\n" ] }, { @@ -1632,8 +1518,8 @@ "text/html": [ "\n", "
\n", - " \n", - " 100.00% [2000/2000 00:00<00:00]\n", + " \n", + " 100.00% [6000/6000 00:37<00:00 Sampling 4 chains, 0 divergences]\n", "
\n", " " ], @@ -1643,152 +1529,81 @@ }, "metadata": {}, "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling 4 chains for 1_000 tune and 500 draw iterations (4_000 + 2_000 draws total) took 37 seconds.\n", + "The rhat statistic is larger than 1.01 for some parameters. This indicates problems during sampling. See https://arxiv.org/abs/1903.08008 for details\n" + ] } ], "source": [ "with pymc_model:\n", - " ppc = pm.sample_posterior_predictive(trace)" + " trace = pm.sample(500, random_seed=123, tune=1000,step=pm.NUTS(), n_init=1000, nuts_sampler_kwargs=dict(njobs=4))\n", + "\n", + " #trace = pm.sample(500, random_seed=123, tune=1000,\n", + " # init='nuts', n_init=1000)" ] }, { "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Equivalent approach using variational inference\n", - "\n", - "Here we approximate the posterior distribution using ADVI to compare the two methods." + "metadata": { + "collapsed": true, + "jupyter": { + "outputs_hidden": true + } + }, + "source": [ + "If desired, the trace object can be pickled for later use" ] }, { "cell_type": "code", - "execution_count": 118, + "execution_count": 17, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "\n", - "
\n", - " \n", - " 100.00% [25000/25000 00:24<00:00 Average Loss = -25.184]\n", - "
\n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "Finished [100%]: Average Loss = -25.172\n", - "Sampling: [chi_obs, v_hat_obs]\n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "\n", - "
\n", - " \n", - " 100.00% [1000/1000 00:00<00:00]\n", - "
\n", - " " - ], - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "with pymc_model:\n", - " approx = pm.ADVI()\n", - " hist = approx.fit(n=25000, obj_optimizer=pm.adagrad_window(learning_rate=5E-3),\n", - " obj_n_mc=1)\n", - " \n", - "with pymc_model:\n", - " trace_vi = hist.sample(1000)\n", - " ppc_vi = pm.sample_posterior_predictive(trace_vi)" + "# import gzip\n", + "# import pickle\n", + "\n", + "# with gzip.open('data/wu_trace.pgz', 'wb') as f:\n", + "# pickle.dump(trace, f)" ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 18, "metadata": {}, + "outputs": [], "source": [ - "ADVI is an optimization-based method, so we monitor the evidence lower bound to check convergence" + "# Values for wu 'optimized elasticity' from the same reference state\n", + "e_wu = np.array([-0.55 , -1.30 , 1.53 , 0 , 0.76 , -3.10 ,\n", + " 1.86 , 0 , -0.25 , 0 , 0.54 , 0.70]).reshape((3, -1))\n", + "\n", + "ex_wu = e_wu[:, :2]\n", + "ey_wu = e_wu[:, 2:]" ] }, { "cell_type": "code", - "execution_count": 119, + "execution_count": 19, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/mahs128/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/arviz/plots/backends/matplotlib/traceplot.py:217: UserWarning: A valid var_name should be provided, found {'E'} expected from {'v_error', 'x_error', 'Ex', 'Ey'}\n", + " warnings.warn(\n" + ] + }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -1796,40 +1611,65 @@ } ], "source": [ - "with sns.plotting_context('notebook', font_scale=1.2):\n", + "tp = pm.plot_trace(trace, var_names=['Ex', 'Ey', 'v_error', 'x_error'], combined=True,\n", + " lines={'Ex': ex_wu.T.flatten(), 'Ey': ey_wu.T.flatten()})\n", + "sns.despine()\n", "\n", - " fig = plt.figure(figsize=(5,4))\n", - " plt.plot(approx.hist + 30, '.', rasterized=True, ms=1)\n", - " plt.ylim([-1E1, 1E3])\n", - " plt.xlim([0, 25000])\n", - " sns.despine(trim=True, offset=10)\n", + "for ax in tp.flatten():\n", + " ax.set_rasterized(True)\n", "\n", - " plt.ylabel('-ELBO')\n", - " plt.xlabel('Iteration')\n", - " plt.title('in vitro ADVI convergence')\n", - " plt.tight_layout()\n", - " # plt.savefig('wu_elbo.svg', transparent=True, dpi=200)" + "# plt.savefig('wu_trace.svg', dpi=100, transparent=True)" ] }, { "cell_type": "code", - "execution_count": 404, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "x = giersch.loc[:, ['2PG', 'PEP']]" + "ex = trace.posterior['Ex'].to_numpy().reshape((2000, -1))\n", + "ey = trace.posterior['Ey'].to_numpy().reshape((2000, -1))\n", + "e_all = np.hstack([ex, ey])" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "m_labels = [m.id for m in model.metabolites]\n", + "r_labels = [r.id for r in model.reactions]\n", + "y_labels = ['BPG', 'ADP']\n", + "\n", + "ex_labels = np.array([['$\\epsilon_{' + '{0},{1}'.format(rlabel, mlabel) + '}$'\n", + " for mlabel in m_labels] for rlabel in r_labels]).flatten()\n", + "ey_labels = np.array([['$\\epsilon_{' + '{0},{1}'.format(rlabel, mlabel) + '}$'\n", + " for mlabel in y_labels] for rlabel in r_labels]).flatten()\n", + "\n", + "e_labels = np.hstack((ex_labels, ey_labels))" ] }, { "cell_type": "code", - "execution_count": 405, + "execution_count": 22, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", "text/plain": [ - "
" + "" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsYAAAEJCAYAAACXPuFJAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9eZRtyV3fiX5iz/vMJ+e8eeeapVKVJjCDEaNtbAsMEmDsNt39bC1jG/vRbT+PC4zthy0Lm/Vs7EfbFr1QsxqM4ZmhG5BAg8GABAJJJZVu1a268805z3zOnveOiPfHPnkq8w5Vt0olbkk6n1q1bmbuKc7esU984xff+IXQWmvmzJkzZ86cOXPmzPkSx7jfBZgzZ86cOXPmzJkz57XAXBjPmTNnzpw5c+bMmcNcGM+ZM2fOnDlz5syZA8yF8Zw5c+bMmTNnzpw5wFwYz5kzZ86cOXPmzJkDzIXxnDlz5syZM2fOnDnAXBjPmTNnzpw5c+bMmQPMhfGcOXPmzJkzZ86cOQBY97sAc+a8UpRSXL58+X4X44uKBx98EMOY95dfLvO6+Orx8MMP3+8izJkz50uYeQs4Z86cOXPmzJkzZw5zYTxnzpw5c+bMmTNnDjAXxnPmzJkzZ86cOXPmAHNhPGfOnDlz5syZM2cO8CUkjK9fv84b3/hG/vk//+f3uyhz5syZM2fOnDlzXoN8SWSl6Ha7/I2/8TeI4/h+F2XOnDmfZ8ZpQJRFVJwKDbd238oRFjGJTPFMl6rlf8lc+wuhPF/MDOIR/+p3/gNRHvO/fOW7ONs+eb+LNGfOFxRf9ML42Wef5fu///u5cePG/S7KnC8Q/iga8deyUHi1hOXLOc+rec0/3P40w2RMy2vw1o0n73q+z6eADouYa5NNYpnimy7n6qf+yJ7z/bz2Ky3P0fdhzufG721+ksv96wB84PJv8te+7C/d3wLNmfMFxhetMB6NRvyn//Sf+Kmf+imyLOPkyZNsbW3d72K9Yv6oomCf7+vcev7t8T79qM9CZYGNxuqrWrZXIj7DIubZ4RWCPKJmV3is9cCrLipea8LlKOM04Nnu5dl9fv3Kw7fd63EacBB00AhWa0t3fBbjNODCwfMvep5Xsu9LsR90udy7gW+5dMMBp5obn3P5XgmJTIllStXy2Y97tJzGH9kzPrz2otuilw5JpuW4Ey/3HXkl79RLlefW9+GB9IH7Gun/Qscx7dnPn9x5mkzmx/42Z86cF+eLVhj/1E/9FD/xEz/B2toaP/RDP8SFCxf49//+39/vYr0ibm3ETzc3MIV41SNxr7ZYuPXaZTTvMwzjES2/yUZjjd/b/CSTNKDu1vimB77mruL4TmVTSrEV7qGBBbdJ1fJnDbfSikuj6wyyMW2nwUPNsxjCeMkGvZ+O2I72cAybUT5m1V+64/6fS8Q3kSmjfELVqjDKJy8qXF4NXk5ZD4Iu1wc3WfAX6EUDoiw6VgcOn+Hl3jVA8ODimTtGZaMsIsoi1uor7E0ObjvPUfZf4pq3crc6PU4D+lGfTOUYUhDlEVEW3vEcL6d8rwTPdMllzmfGN7EMk3pcpT2to59vPNPFN1166RDfdI9FYW+NzL6cDtor7dB5pouB4EawQ8Ou3hYVvlU4v9rP4kuNt2w8gf3J/0KuCobJmH/+Wz/Gn3v0T/HGtdfNF++ZM+ce+KIVxmtra/z9v//3+Yt/8S/ieR4XLly430V6UV5MwO4HXXYn+5xsnOAg6LA/OUBpTctv8taNJ+7aiGyP93l67xkKrVistDnd3CDOo7tG+u5VLNyprHcTwfuTAzzb48tPvok4j7jcu4ZneXSjPlmRMkkDzrVPcW2wST/q31UY31q2g6DDjcE2v7P/h+Qq51TlBI8vPMR+3CWWKcN0xI1wG1NY7MT77MQHGAgW3BZftvzEXRt0AWSqQGqJ1Bpxy/awiNmJDtiO9rENk6ZdZ9VfwhAGSquZ+AZuE6OdpM84D5BKMk4DdqIONdNHaXXHsrwYRzsARwX/rSI4LGI+3XuWUT6hadd5cvGxWXnutO92r8OF/eeI84xTrXXetP74sed+Y7DJXtDBszwEMEzGd6wnFadCxamwNzmY/Xx4jiiLkFpjCoHUmue7V/ns/vOkRcpqbRnf8rg+3OZU88Sx+nAYqb452kFrfazzdthx6oV9BHAQ9LBNi63xHucWztxWPqk1ucy5NtikYvtMsohKGtwmtF9Op7KXDmfPfpCOGKZjJnlI06kzyQMG6YhBOiKaCkvPdO747G59pi+XquVzrn7qjvXv8vgmCknTrtN0GvccWYZ7i/weFd2DdIQGPNNBAwKBvsO+SiuiImY73ENgcHWwyVp95WV/7jklLa/Bn3rwa/mV5z8MwLOdyzzbucyi3+YbH/hqvuH8V7Pgt+5vIefMeQ3zRSuMv/M7v/NzOv5nf/Zn+bmf+7l72ndra4tKpcJb3vIWfvRHf/RlX+tWAXu0sb/Wv8GzncvsBh1uDndoeQ0GyQjfctkJDjjdXL9jYy615jN7z3Clf4OV2hLJOOX56Xlc0+HJ9dfdFum7m5g5aneou9XbotfdsMvVwSa2ac/KfxB0eObgeYIsIs5jQHOufYayeQQQNLwGdbfGtcEmruUgtWZ8RJwcFSYVp0JSpPzh9qepOVWqUZVL/et0kx6ZKgjymIZbQ2nFottiO9wnyhN8y2eUTxgkIyzT4nqwQ82q8NblNxx7BkdFiWNYTLKQulPFNZ1j+1wcXuHZ0VUm+YSTlXUymdNLhiQqY5IH+JaLIxyqlo9t2hgIVvwl4iLms4NLRDLGwKDpVHmofoagiDDEy4viHEbuhtmESRbgWWVUsBQsIxKZ4JkuDzbOMMzGPDe6BgL2oi7L/gIPNc7eMfrXT0c8H11jkEzIiowbA8XN4SYbjdVjwjPMQlKZ4xg2G821WT259Zm9fuXh2c8Al3vXuDnaIcpievGQqlMhyiL2gi6TNCTMQnrhkO3xHk2vzsnmOm87+xU03RpSa26Ottkd79ONBrxx/fVM0slMlB92nM4tnKYT9pkYAW2/yfZ4j4Ogc9s7cnO0TZBFRHlM6mREWcRn9y9yrn2a8wunAY55lR9ZevCOozSHYv3GcIe9yR7GVPz10iHb401klrMbTcgbOUILOtmAIA/wTQ/f8ljy2niGS92pM87K0YNJVr4DRztdR8XzTnRAKjNW/UWWvYXbBOnh9oZdnZUzKmI+3b9IN+2z7C4CE1zTpVCS3fiApl1H6buPwHjTyPPdIr+HojuRSXkPNGxGe6QyZdlbYMlvc7q2Ti8dlp2GbEwsUwwE4yzk6mSTfjbAEAbBpYivOv2Wl/VOvNb5o2xPwsmI83uKLzdO8nH1gn2wFw/4uc/+Cv/1wq/xlhNP8Lazf4zHlh+kPo/Oz5lzjC9aYfy50ul0XlaUeTQace3atZd9nXEa8Jm9Z3j24DItv0FSpJxrnWSShvzB1qd4pnOZbtjHMixs00KgGMZjQtNGa02QlZk2tsf7/P7mJ7nav4FrezTdGoWSVGyfrdEuDbfK891rRHmCZzlUnArLlQUWKgvHGvyjYubQA/yhK7/NJA1wLYcHFs7Sj4esVpe42rvBpc5V9qMew3jEam2ZTthnudJGIyiUpJAFvu0zTALSImGjscY4HbPsLuBZLo5hIZXEMix6UZ/t8R6LlTZtv0k/Hs7KsuC32Jkc0Al6pCqjGw3YHO0wygJc0yWRCZM0QBiCQTrCEiYKTT8dotCgNZaCSEY8P7rGamX5WON/6CsG8E0X13MZZiNuhrsAGMIgKhK66ZCkSIjyhCuTm5ysrgMapSVbwT41p0qhJFXLZ6O6yl7cZTPcZZiNGaZjHNOlUDkCaLnRdMh7RFQkswjinSKGYRHPInAAsUyxDYv9uIcpDA7SPloranaFpt2g1NoCx7ApKKibVSZFSKZy4Pbo3yAdsRnscHO0zSAaYhgGuZL8/tanWaouAdCLBjS9OonMONVYY6GywGqt3LY3OZiJ117YxzRMzi+coenWmKQhN0fbXOvfpBP2ONs+RT8aMIonbI13CLOQURKgtSanoIgLqo7P7mSf37/5SWpuFSEEUisaTo2dyT5X+tdoeU1GaQCUEWAhDJ7rXMGzPWrTTk1cpNwa998PujzXucwoCelHfTzbZbm6xOZom5vDbfrxgAW/zTMHlzANkxuDLQ6CLlprhBA8uvwQy9VF4jzi5miHYTymE/ZYtRbYj3sIBA1cnGGCkebUDQPbzhhZE4bphKAIkLZGKsWav8zVYAtTCDJZsOIvMComrFdXGGaTWafLMxzO1U9ydbzJM6MrKC1ZqyzzRPsRduMOqcyoWhWG2YjrwRZag2c5rPsrtJwmuSrYDPaIZcQgGXGmvoFruEgtMYVBw67x/Og61ydbFFqyXlnh0eY5xnkw6zw17BpBEZGrnERm9NPR7J5eHt/gerBNIjPiIkHpgkimSC0Z5RMAcimp2RUG6YitaA9bWGxHHRIVl98VqsC3/PJ9/SLjj6o9AfjNX3wf1559Cg/4X77n/8FHB8/yie3PIKcjU1IrPr79FB/ffgqAE/VVHl48z8NL53ho8RwbjXUsw3xF154z54uBuTC+C8vLy7z+9a+/p32vXLlCkiSv6Dr7QZf9oENcxOx2DjjZWGNncsCF/YtcOLjEJAsJs4hCFbT9Jq7l4FoeC36TQhUINB+7+Yd86PLvcLV/g0imWMKk6nhUnSp1t0bDraM1RHmM0opePMQb7fCHpkOhctp+C1MYrNaWWa4uHrNZ9KM+vWhAzfG51L1KmEYMkjGfUgWZLNBopCyI84Td8QE1t4IAnlh7jLXaIlezmHEyIchC0IqV2jKe5RHlMb/wzK+xP+kgtcQybXrhgP2gg2s7tLwm6/UVliuLXOvfZN8+YG+yR5Ln7AT7ZHlOmE0wRCnADQO2oj1ylWMIk5bToOU2qJkV9pIuqUyIZIxt2AzzCZ/pP0vNqnCiWg7VH/qK96MekUoYpwEaSTcZcL2yzFplGc9w6cQ9dqMDFOUklzAPsQwLIQRaaKSWOKbFOA8ZDS6TqQzbsImKGK0hkDFNp45vuZiY7MUdLgwvYWLiWg65ygmLmEW3zZq/NBOu29E+hZL4lsuSuwDATnzAuJjQTQczMTEuQoI84mR1jX464HRtg7bTpJv0cU0XqSS9dIjSCoHgZrCL1por+SadtMdipc0oHZfiRmku7D9LLgs2GquEecT1aXT/RL28b4eiN8oiMpnTj4ekRU4n6HF9sMmp1gamMOjHQ3rhkJujHfrxAM/y6CcHaK3xbZ8gj8mKHANIZcbWcJeFSgtLWJxsnqAX9ZFKogHbtABBmMf83uYnWay0qdg+cZ4wTidEeYxjOpimxYPNtZl4P4zufmbvWZ7ee5Z+PKLmVvGlR1Kk2KaNEIKbw23GyYRO2MM2bMbpmG40QAhBL+rxqZ2nWW+ssVJbZn/SoeHW2Q86jNWYJXcB13SIxgPqyiItMuwsRTFkW03oyACFIi5SztROsBsd0E162MKmmw45SLpULI/9uEtapPTSIRJFLFO2oz2GWcAwG2EIk5vBDpks64sQZWcnKhIKlaMUqFRNI/sdDGGU1o4ixDJMrKDsWM9GCsbXeGZ4uexoC00vGdBN+yy5LR5snOX6ZJvnx9cYpmNqVo1+OiJXBSOvRdNpILXCFCa70R6WYZMVGZKyI1OoglE2IVUp3dhEUnCQ9hmlwTTCrqlYFeTUUlEr0lf0Xfpa5o+qPQHoH+zMfj5pL/L/+urvZRiP+Mi1j/KhK79DN+of239nss/OZJ/fvP4xAGzD4mRznbOtU5xtneRs+yRnmiepOK+NCcJz5ny+mQvju/Dd3/3dfPd3f/c97fuOd7zjFXuYf/Pa73Cxc40wC1muLhJkMb9+6be4OdomzhOyIi9FF5o4T5Gq4EzzBEEWIYTBhYNLXOnf4MrgJolM0WhyXTBMA+IsAQ1KKyzDQAgDoTWWYRBmIdvjXfpRGR3bD7tlFNNvcKp5gred/QoAPrnzWbbHe4ySMVJJlNJMshDHspkkIYZhEOcJEomBIFc5f7D9Ga4Pb1KxqoR5RCfsl4IvCzmdTlirLdFw6/SjEYXWSKkI8jF/uPMZAJYqLfrRiEkW8ontp0mLFMewGSRjIllGyDdHWziWgyksUpkhleRGsIVlWLjTyKupDXrZgKrps+S0GBcBjmEzzgMOkgGbco/rwQ6e6VDogkIqtsJdFBqFxMBkkI7JVU7VqvB8dJ2tcI+UMupqyHLI3Lc8NBrfdDEEaA1Vy8MSJrtxh3E2wMBEo2lYVWxhEBUpl8fX2Y4OQAhMBIWUZORkOmc3OmAr3C07NDKmUAWe6dJyG+RKsuS2UVpStSp00hcaOoUiKEJ2ogMqlk+hJEmREhYxUZ7w8e6nORV3kKpgkI6JZEJSJCAMcplT9StYpo0qYhQFo6zgUu8K/XjAufZJTjc3eGr3AnvBAW2vxUZjDakVq9VFbgxLq8M4C2l6NSZZSNOtsR902RyW0ehCFUglabdatN1pedOQZb9NPxmXfmsNda+KZVqM0jGtrEmhJLmSLPgNJlnEJJ1QdapsjXap2B474z1A0wnLUQfHcDi3eJrTzRNEWcTu5IBr/Rv0kzEXDy4zTgMyWRDmMRXbxzM9BsmIUTzGMi3afmvaEfFIioxhMiHNUzKVM4ljutGQR5cLrg5uEGcpQgjaTh1LWJyurSPdCo4yMeMCqhVGMiGOQTsKFwetys8ZFDGDZFzWPyRiWn+6yYBU5vTSAbmSaBRBFlKoghwJgNQOvXSEEBDkEZnMyKZ185C9pIuFwMCiIMfAxDVsJkXAtUnG1ck2poAojxjK6URFDYnKiEcpe3aHfjoim0aIE5Wzr3vU7Spnaxt0kgEaMIU563grrSiQ2MIkkRmOYdJJe2RRQaZybMOialXJdU7dqhAUCUEeYGJhmyY154tvaP+Pqj0BKPIX6oBlldkoWn6Td7zuT/Ntj/4pPr3/DL91/fe5sP8co3Ry2/G5Krg22OTaYPPY31erS5xpn+Rs6xTn26c43z5Ny2++4nLOmfNaZS6M7zMf3/wMmcqRStH2JdvjXYI0JFc5EoWFiYHAMEySLOHmcIdJGk0nbAmklmitKAp52xCkFhDnCZZlca59lihPiPIYz/TYGu+yPdolzGL2Jx0UIJH0oj474z1uDLbIZE437BMXMQIDhODmZAeBoKaqFLrA0hYGBpLy+qnKGMUjJsmEmlMhkRlaKwwM9oMuUikKWeBaDgJBmicU04ZeUQ71DeMJpmFSjHKiIkEphUZjHvHiZrrAFz4IjWs6SCWJdIopc0IZk6mcFW8JrWHJbyNEOYTYTXuEecI4CzGEiWMGWMJCak2Qh+QUR+5gWZ4sz/hU7xkylZNTIAAN5BQEeTm0XCgJGjyrtD84U29zLGM0GkWBRkyjoga5HpIW6dRzLGZi55BU5+ynPUyMWVRtWGSERcRB1OOaUZYZKEX1kWdfoIjymDCP2Y07QLnEpYVFLGOiPGWUjckoywJQNX0UUAEW/NbUFy7IVEZWSIbxiJ5T5/pgh73JPpZhMvEj4izGsRyu9m4wTMaYhknFLiOwDcfmqb1nCdOQQTQmKTIyWV5znE6wDRulNE2vQdtvcGO4xSQNy8+lQWAQ5TG7k31Wq8sgE5Ii42DS4frgJoWSZEXBXtDBN10QglE6mlqMIrJOxt7kgJXqEkmRlNFmw2ZztE1YlF7vLM8Ipp78KA8xMEiTsqOVFTmjZFKO2MicVJeCQ5KR5zlP7z9HIcu/aTRDBJm8wVa4QxwFVNKAqsrRYUpYMykMjwJFQRkNvDq5ARjk5Kip4UMWijETcpXjmS4CSFU6nbimKN+EcpKoIyxylVHoglhGdzQgaDQ5GoMChUZSMCkiXGwCopmQNm6xmygUCSlZnpFNcizDotAFqcywMEllylP9Z8i1xBE2DbvCuAhQuoz4CwQNp0kmEzKpCNUL2UFyVRBl5T0YFsG0zoKJBGVjiFunvM55OSj5wneYYR63RBiGwZvWH+dN64+jteYg7PJ89xrP967yfPcqN0fbM8vFreyHXfbDLh/femr2t3OtU/yPb/oOXr/y8Ofls8yZcz+YC+P7TCZzBAKpCnbH+2QynwlFgAJZptjRAknZWIeTGBOBZ3qzCGopnwQGBnr6n21aYAgW/Ra5yjnfPk03HrA93kWqAqU1SqljoizXEpnFXB9sIfU0MoUGSuEHZWM7yQMEoJQ6Vl6AQueYWKQyL4e/tUJOhX6QhVwb3KRie1iGSdWpMMqORy0ynYPMieUtw4m3tPx5UWBjEKkYORWxcrrTpAgpAoUSilE2KQU5EqmLqbxgGhkzaFgVwiK5RRQzu6+gyFWBnH7Ow2IodBnhlfkLYrnISWWGkU1IVEoxLVcpZjS5zpF5galscpljYt4W5TuKRB27uxJJriXIUhDb2FSNKrFKyXihHAnZLeehfM4a4qx37PwA42m00MpMTtRX8CyXICs915GMyFXGlcF1kiwhm96nMIuIi5iW18Q2yuhu3akyTjIMAeM4IMxD4iw99hn7acakE2KaZb22TYv1xir9aEQm8+nN0oySCaYwyWVOIcvORycckMmMAomFSYEkLRIqto8QglwWZVRVF5iFQTAKGMQj0iKj4viM4wmpzqbPT2Fglh3GNC47OLpAIEhkiiEMpFQUOr+t02kgkLLAFAaFLruFURGhlSYSMUUWYhmauCGoxprQVkysbCpwy3Olt9Q3DUSU73Na5IhigomJRE2Fq0YgXvjcMkNIUXbsXsKXq1HHfk7IZuUo78Xx403Kd0kgyFVBosrRKIlCoSiKgnERIRAUFDhxaUMxpiUVCMbpBDXtMt8LEkWsUg6C3kvvPOeuiCMp2fSLZLwRQrBaW2a1tszXnP1yAHKZszXe4/pgk+vDren/m8T5na0d14ab/Mhv/2/82z/zT+bR4zlfNMyF8X0ml/m04dDEMuU29QcUMp9Ge174kpNoQhkf+V3hGA4tt4Zn+/TiIXWnQttvslJZ5sZgE6kUg2REkMUYhkWax7Mo7VEUiuweUohpwBAm6Bekm4NNQSmGozzCszwc2yVMIgwEUZ4Q5wndeIAtLLTWGBh3LMft19NYlBGQAkmk7r7E90xkaFBSzsTcnT7rYdTqbtuB28SriTgmRg5/KlAUOpn9wZrG6sqfTbJpxNmQijs965fi6F2SaCQZBoInFx7l0ugawTRCfTcxYmFR3OVeAIzSCaZhcap5gl7Q5yDulXVPK4IsoBynmGpXo7RfXO/fRGqNYQjGSekbFYZBUiR3nUiVU5BPq02iUia9q1hYmIaBVKUQlEhSUlJZnhe4rdN4+O84DzCn9WiWEiwv64dKJmTIUrjeUo5E5xh5Mb23h1s1UmZTgccd76SavrOGtmb3WqEJVdmZsEyBFopGqBECnBysQlO8jG/csjt6OJryQtn0dHxg1vnRd/bk3qn8Jsbs++ZOHL5fanZvFcUtnSw1+/Qv5JjJyLF0OeHVnHbSJRLf8FEqndWZl8LE4MHFM/ew55y7YRyZOKekfJE9b8c2bc61T3GufWr2N601nbDHteEmn9h5mt+89rFjx8RFwq9f/u/8+Td8y+dW8DlzXiPMhfF9pupUGU8jpvquTYeBaRgUL6EdM5UxTAIaKCq2R5CGpEXGtf4mUsvppCWDulsjyWMKWdwW7X25ZPqFRtNATM+nkIcNpswwDWPamKrZMDBQzojHxMTAxiKnmIrH2yOoh6LHtVwymU2H2u+tsb2bKH4xjkb27lSWUmC89HkLVCmEjwjkQ8Fzr+V/KTJVMEzHLLht0jg/9kyOIuBFRTGAKQRKFeVw9zSdlpoO4t92PgXDZPLCNvXCdQwlXnZ2gYICpUo5d9QYVByOWLwEd+oMCCC7JdJ/K3crp77LMQYGFiYSiWVZpMXt9bWwBKFnYOeayDOwC40lNYV1d5tAOTZxexnuVK4XwwQs4YDWMz/84TEvFr2ddXiAqlkhkgkmFtktwljwwrM9+o68MKJSRrVzCmQWUVUmpl1hIvIXHR2xMHANh1EyfolPOOfFOCaM1cvPkQ7lSOb2eI+bw21ujLa5MY0eT9I7BxF68eAVXWfOnNcic2F8n6nYPkEWzhqVQwQCG4uMvBSU08hqORB656bRwKDQGeNEYxpmaUU4ooPyoij9qCpDaANDmAitXkSQl1hYM2F7axk1GpsyauaaNqnMp4KiPKfUspwESOkZ1TNxfNi4FriGw6nWSXpxHwODXjy47TNqys+/XlumE/cZpZM7lvpuYvPo3+8kQI5iYkwjq/K251JuF8c8mUcFxdFrC8DDoWpXQUBURCgFCen0Mx3HACpGBddwmRSTexb0BZKd5ICq6U9LVpbk8HNWhE+s43uSqYY2qTgVTjRW2Z8clF7vWxpXE5O6W0VpTZrdPnmnlLF3v9phCY/uc+ijtoSFYzkkR7znL5cXnsfdOzcOFloIcn13oXYr1rQTJ0QZaYYyjd7dSFxBmpeiWFqCwhRTUX272LTKmQSoF3nmAjHrIN7pO8BEYAuHplOl6TTKNG5HRLuBwJwK1qMc1pPDDpuJQTD1LEtu72S9WEei7HyVT7YubWqBxFIKbWWIuk9qOcjpCI5J2Wkxp/YvAxNLWIyS2+vUnHvnqK/4pSLGWms6UZ+bw21uTtMV3hhtszs5uOeFh1arS7zjdX/6cyrznDmvJebC+D7TcKsM0zFaSRL1QiPkmg62aWMpC9swCLMEz3ZRUlL3qoyTkFQdb7Q0Ct/0Sw+mvHODr9AIpSkoh4otYWEIgVBgWjZSFyTy1vOWE99808O1bGpWlcE0h2mUR9imTdW0kFqRyuxYs3kofg2Mac5iTUGOQCMwcAybqldjkgbYwqbQBbawyHU5WcgVDoYBhVLYZjkBqO2XeVnTPMUVNpZhUbEq03yoZRkUCkfYWKZFJjNswykjzdPrptPPX36+F3CxqdkVKpZHmMWMZXhMoBkIHNPFEia2dkhkOUx8mHc4LlLSqZiwsTANE8swaVg1cpmTcudhbxMT13CoWD5vWHiUbtJnL+owyibkUz+oOX1dHcMCbRDraCbwIxkj5aEnvJzsaGOVwlCA0HcW4sbUr2phYGLSqrao2j574w4gsE2HTBUzgSkAy7RxTJe0uHtKKRMDQxhofRhZLPPqnqiv0osHBFmEbzoURYGkwDZdPMui4daRScYwS0gNyI58Q4nD+2Q55HK6OuEdOmue4eDYDnmek6j0NiHnmg4b9TWEMNgabs8m1b3UZ3EtlwW/xSgZowtmOaE1zCLrL9xbgedU8JYqGIViIENMU1K1PKRSCPVCNNfGwjNd2m6dTjwsPcA6m53TODJ3QBSSmjRRlkFk5rNP72FP77GLY9qz7BMBLzx3E4OW02CclZ0uPT23K1wynU07uAUGJtkdo++CqukTy+SukecXItMSXYClFKlrUMlAFzmrtRWEUXb6O9mQOI/RgrJTXWS4plv6zOe8Yo4JY/XCd5fWmu3JHs91rnBjuM314SY3ptmPXg6LlTbnWqc42z7FAwtneHL1MSxzLiXmfPHwJVOb/9bf+lv8rb/1t+53MW7jzzzy9Xzo8u+wF3Yx0pBMFpiGoOZUqTk+UkniIsM0cmp2hUSkGMJi0W8TFeXKXaYwsS0b3/Qp07oZhHnEnWKnZXYJ8A2PTKZUbI/FyiJr9SU0EKTl5Lggj2YWgLpbLSdYmTZ1p8IjS+d5au9Z4jzGzVzW6ys8tHiOj25+gqRIMfSh53Iq4hDTNF0Ky7IwlQkGWMKg6lQwhEHTrdP0GoRZSFwkmMoiVzl1r0rLq6O04JGl82yNd/FMB9d02R7vIZTgTO0Eb1p8HZcnN7g4uEpChomJwMQTNsIsY4gr/iJoTYFilEwoc0zI6X0BS9icrZ1kxV/kZHWNTjLk6f6zjLOAWJcC2BU2S26LtttiL+qW3m5hkkuJbdhYjoUrbQIZlRFnpdC5oNAKUxi4locq9HRSncLFLqW6AS2ngWEImnaVZa/FottiUgQM0zF7cQ9jquTrdpUlr81+1KOT9mfTskzDwjFtVF76zaWW5dLNQiCKMpY8USEG4Amfml0hLGJMlWMIg6pdYb2+Qi4zclnQ8Gp4lsfmYAeNopjacQwhGKcB6dTjbk5tBUexDJuaWy1HOoTANAwW/BaPLj/EH2x+ikwWZEVK1a1ytnWKKBhxqrKEJRyu7l3ASCAR0K+BskwUClvYLFaaLFQW6IZd0iIjyhMKXcxGUxzLZaOxRttr8vT+s3eYVGZOJ+rBE2uPsl5b5lLvKkmRUagCQxhUbB+ly8mr4yTAs12qdgUhBFXHRys9FW/lxFnf8lnwGgzjEVJqUspV59a9ZVYqiyitWSgigjzEN3xynbPkLbIT7pKqMt+vlIqoSMpnksdHRDGYWLiGTVvaOKOARbdFLgw6jmJIUq42Z1iYQvBQ4wxRkXCudpIn7Ef5TP8i+9EBGkHF9jhb3SCVOTfDXXKZIQyB0FA1fBp2jaiIMYVBJ+mTH8l1IgB7GjE3Zj7l2ylHA8pIvbAtCiPDjHNy28Z0bM7UT2IgZgt8eG4DYZRpJB3hoJBsNNfu/Qt0zm0YRybfKVnQj4f8xuXf4reu/z696N4tD5ZhcbKxxunWBqebG9Ocxqdecnn0OXO+0PmSEcavVZari7xu9RHW42UmaUw3HhCmIb7t8obVx8hkzrXBDVarSyhUuaJY6wydqIttWuwFXZpundetPMx6fYVP7TzN9dEWwXhEFE7ITIm0TKTWNLwaQRKikBRSAgLTtFiqtnnb2a9gmIz5zN4z+HaFQkpM08ISgtetPFSma1KShxbP8sb1x4mLlEvdqzS9Jiu1BRSak/U1PNOdls3GETaZyimUwjDMWRYLjcTGmS0y8djygzimQ1qkSCVZ9NtoDb7ts1JbwLMc4jylG/VZqLRY8NvsTfZZqiwQBgFPLjzGQ40z+JZPVKR0kx6FLr29nunxaGWVm9EuC06TTOX00iENt4ZrWPSzCa5pYwkTx3RY9Zc4UVkpBbK3yEF0QCxThBQg4HTtBBuVVU5W1xHpZ0knQwpLgWXSdBoIDT09xJBllNFE4JoWqUyoWTUynVOxKyRFgqEVnuWx5LQwzTLPcctpcKq2TsXyWa+soLRimE14fnSdYVbmk13yFkhUxrn6SZSGYT7CNAxOV9Y5W9/gerBNkIcoFK9vPsS4CBllE6I8wZUOG5VVKpbLgttmJzygnw1LMaM1NwabFFpRsX3WayukRUqr0sSzHAbxCNdySGVOXmQYwsIWJhXHxTXdaZaKFM9yabl1TjRWiYqUIA1o+S2eXHuMtt/kwv5zZKqgYns0vTpLVoWK4XDGXGMUDulrl17dxA8CGsIisgxQkopbpek3WK4uIISgHw5AGMRZTK5zKraPY9k4psUkC6i7dezCLj/3kaW9/WnUdq22zNef+0qk1nTDLtvjAzzbpeU1eHr/Iv1oQFJkLFRanG2d4sL+czy0dJYbwx3skYVSik40YK2+xILfJkxDqpZDPytY91dwTIdFtz1bPtsSJr7pseC2OFM7QcOusBXtU7Mq7MddCl2gVNmBOuducCPYwTYtFt0WSRyyMMohUmizoGXWEZZDpjUNu0Yi43KlP5nQsus80DjNsrfAur90bCloz3I4U93gy5bfQCRTRtmEbtzDMAw8wyFVOZ24T6YKwiymoMDExLPsclW6aYfBNmwGyWiWplGjsLCxzTLbims6aBOGtQJTCpQt2Kgu8nj7IRKZkaqcul1jP+lQMX02KmssuA06SZ/lhZX79XX8RcFRj/FHb/whv37xp14yCr9cWZgJ4DPTf9fqK/MV8OZ8STIXxveZz+xdpBcNeHjpAW4MNmn7DU7UV+nGQ7584wl8u8LTe88Q5GUk51BAVosqb1x/PQdBhzOtDc5Me/KrtWWeuv5JDuKrFP4C9WqL6vo6nx1epRP2aLebhGnMJJ2ghE3dqU2tBiZv3XiCRb9J22vybOcKhco42TzBn374GzBFaX44XEXMtz0qToW1+gq+7XGqscZabYl+NGSYjFjw2yRFynOdK+xHXWxR2jQWKwsMkzGuaZNLyXKtxVJ1kartE+Yxj68+ws3RDlJKxnmIY9hsNFZJiozJpE/LqPJA6zxtr06uJLmZcKJSNqQLbpNztY2ymdaStt1kUgR0kwENu8qC26Ri+aRFRtOtk8gU1/BQSHzL51R1ndO1E7OloquWz1esvIn6sEaQl7mjV/xFlr0Flo06Z2WdIq2QF5px3eKx1nmG2QTPcvAzl2E2wTEsGnadTBUsuU1GRQAafNPBNzzWKis83n4I3/IY5wENu8aytzCrH9cmm8Qype3UywhmNiFVGcvuAq9vP8jj7Ye5PikXNnmoeZZlb4GHm+c4SHqM0gm2abPgtWjYNSZFyCidoNBMsnIFtiWvTd2pcrK6xqe6zxAWMeeaZxgmI1638iDr9RW2xvtM0gndsI9pWuyO9wjzBBlP8GyHs61TfM3ZP8aV3g0+tXuBmltBqoJMFZyorzCwXN6y8QRv3XgCgN3JPpd61zAwqLoVvMLC1ZqVlZOYu7DSWEHHParLyxQLNbaTHsN0RM2pYBk2YR5xor6CAM5MV3d8avezAJxqnWC5sjgdQhZEWUTdrVF3qpiGyeawHDpueg1ONNZYq5d1Z6OxypPrL6xMtlpbph/1cSx3umpfn8VqGyEMzrVPIQQcTLqs1Zf42nNfQTfssz84ICoifMOj0AULZpO6XUXqCWf8DXaiA9Yry6z5y7OlvkEwKQLaboNT1XV2ogPCIsIQJg81ztJwq1jCopNtk6oDhGsiggnSrdCuLJBri1wVrJmLPNg4Q9WuHKtDy94CTy48yuXxTRQSz3DR03flpOXTS4eAnq2wuGR6OIbDY+0H2IkOylGGIiSXBYtem6AIy1XvtGTRa7PktfFMl246oG5XaTkNnh1eRWtJoQtwPU5V1thP+5ytbbDsLRAWMScqywyzCU27yonqKicqq7Pl2ddPrX++vm6/JDhqpfj9m58kWzgubs80N3hg8WwZAW6Vi/bMV7WbM+cF5sL4PnOqeYKdyT6f3r2AaVi4lk2mCs61T7FSW6bh1qi7VaIsouJUADgIOtwc7TBJJyxWF2aiGGDBrPCAtULdi1h78Dz5eMzGxqNsLJ/iv135XSSKulMFNEmRMkpGrFQXWags0HBrPLn+es4tnOGN/RvERcap5gk2GqvHyrw3OcA2LM62T7IfdFmutHlsmuD9sJxRFnHh4Hk2Gmt8fOsp7OmyyUvVBbpRnzCLOdU8gW97PLJ4joXKwmxp4fMLZzjd3CDOI/TUCXx17zL1yKHf3yJIbN78+rdQWLCv9mcio2r5PNp6gFW/tIV4psOl0XUG2Ziq6VOzqyQyZdVfxLNcDBpoyqwOjmHz8FRYHuV07QSLXptEpiitZl5iEcU08Ti9co7RsEPd8Sl0wZJbWiCWs4BEJay4izTcBp24R6ZyNopFWmYNw7apVZozEQ7cdu1EpsQyZdFtcSPYwRE25+un2I06bFRXZ/ufrp04dtyytzATIIlM8Ux3do2wiNmLOwgB6/4KO9EBdbNc4vcwar4z2WO5tshjKw/zyNJ5HksDbgw2uTHaYbW6xO9vfYqkSJhUQl6/8jAV2+fBhTOs1paZZAGmYdIJy8VcAJpenTW7iZqEZIbmybXHeGDhLElRjgJseItciz5D92Cb5aU12mfP8XzvCtq2cPwKi/GQSRrSjwas1BZJZI5jOrT9JhuNVRpunbbfJMwiKo7PRmON080NumGXuMhwTJuDoMNu0MUxbU5O613zRYaENxqrs3o/TgOi6SIgphDThVU0jmmRyYJCyXIVsLxaWlOmtpSGXSs7YjKjlw5pOfVjonjZW6Bi+QzSEXtxF6kVZ2sbNOwauS5mxycy5aq2uT6OqEqDgTPBXVjCFTZPVh/E9vzbOlS31oej19mLO4yyMefqp/BMFwPBjWCHhl1lxV8s7Vgy5Wxtg6bT4EawTSoz+tmIttOkYdeomj5BUS5vbhkmJyors0m3b1l8Ha7pksiE58fXGMmQRafJ2frJ2Xt6rn7qtrp5uO2wszLnlWE6L4yOWLI0wzS9Bt/yyDfytjN/bJ5veM6cl2AujO8z43TCRmONuEh5cOFsGQFunjgmdhtu7Zivq+HWWKktz0To4bY4nLB19SLxsI9IcsLuAbXmAq5f4YS7wiPLD9D0GlzuXccySq9oVKT88TNvPSZ+DwXyUeJwQhpHuH6FilNhsbpAL+zzwMIZ3rD2umNlPeRQIL9l4wlONU9QsX1MIRilAdf6Nyi0oik82spjwaxQX3n4ts9U3qOAG/Ez7N68jOdVGe/vos9GrG2cJbCOp3Y6jPRCuVyzbdo81nqAXjpkzV/Ct7yZwI2KhL24w+lptMw4srLe3c55SOZoqpU6RLC4cJ7a6hqOV8UzXYDbGv2NygpBOCTuHmDKAtsxWag3cKy7R2o808U33dL6YVdJZMaVySZKSzpxjxOVldvK9VLlrlo+a/4ycZHMxNqqv8Q4D9BhwGOVFfaKEW85/+U8snR+9kzPtE8R5DHjdMLrVh5mwW+xPd6dLpxRmf3/upWH2A86KK3IZE6QRZyvrlF0+lxOttnPBljLizQaC5xultH9fhawfOaBshPSXMKv1jlx4uxMjN4cbdML+5xpbXB+4Qzb4z2G8YiTzXUeWXoAU4hZp/Fo/Tlap8dpMOtQaq1n5b0Xbn3/9iYHeJbLV53+Mq71b3KmeYJTzQ0O0r07Hn83EXj0GbXd5ovuoxbO0Y0HjJMRujDJowgvlniFz4n6KRzvxT9LdSqw9ZHo8OH1XsjgAZVbRCvAKBszzCacrKyyUVllnAfEMqXlNlj1l2adRbi93p+qrtNLhyy6rWMduDvVzTmvDoNpLm0o82e//eFv5Dse/7NU7Pn9/lIjCALe+9738oEPfIDd3V08z+PcuXP8g3/wD3jTm950v4v3mmUujO8zr195eNb43ykCfDdubawB0jgiiyOWN8oE+fXmAvXWIlCK1KbhE/S7bPhLrNQWSYuMlt/k9auPvui1Bp1dbl66gFKSWnOBk+cf5fV3EbFHy3frPofiuukvs35mhcGww2h7i9HwJnGvy9LaSTxhYBsa3OPnWq0uM7J9qm4NR5voe8g9dlRY+qZL+0h0ttweM8rGs+2HjTtAlkQUWYLleHcUHY5XYWHtDI277HMncSNETCY11XqbcDKgyJIXFTRVy+ekvUQoJ1S9Oh01Zivaxbc8Ommffjp6ReLijhG7MGb3xi4TJVms1zn5WPvYMbc+T4B+PCCdZvo43OetG09yY7DJc71rNJwa3ajPmeoaZj/AadSJb9zkzIkzjLMIU4jZOfPRBB1GJHaAX60fq99HR0wabo31+spd697d3pvD892pQ/lyORTVe5OD2ftasyscvMj9fqnn9FL7LHsLvHXjzdMOTITs9ak3l5BR9JL16JBb3wfPdGdi+XRtfSaWF93WsbLcWlfuNBJx9HMc5XTtxG0jGnM+vwSO4LCLf5YG/+ObvuO+lmfO/UFrzV/5K3+FS5cu8Rf+wl/g3LlzjMdjPvvZz1KtVu938V7TzIXxfeZw2PDWxv+V4PoVMAx2r19CCxj29pmM+oyHPZbWTtIMFGagqGGzdvYhlG3cFnE+jAr71frsb5c/+wkONq/SXCojcGkc0Vpafcly2oXGSzUymbAXH9A72AalcPwKJ88/ipdpDoZDFlc3GPU7RJMRlmXPth+WYZwGDM0M1aoRZTnL66doLi4DLy5gX2zI9sW2Z0lEf+8GeZZiOy619gqGEFiOB3DsevciSA6xHA/bcQknA2zHnZ3vbmRJRNLdR2UpiRNhN3xc08UWFqnOj2RSvvOxLybsbxViajLBCFOai4tkk4h00IeTDxw75qhY3ZscoLXmXHWdvd4Og2qHxmq5faGyQLh7gb3JQenvrbWRsWI0HuBX6/TzgIa/MKt7cjzh2T/4XaLJkEq9xRv/+J+gvbx+x+ve6fd74WjdXquvEIcThpP9Y3X9XrlTp++VLqQAL/2sDjm0yASqR09MyIZDvFr9JevRIXeq73kSY8c5nfSAaqV+rHN49Lhb7Q7zaO9rF39thfTidQBUp084HlJttO5rmb7QSKdZau43lmHhWs5L73gHLly4wFNPPcW/+3f/jj/5J//kq1yyL27mwvg1witp7O+I1mWj3zvANARLJ84Q0MfzKsgoYqG+QBxOcJSgdcTLd2jDyOLomDAd9Tp09zZJ05idG5c4/+gbSwH+EhyeLxj2CUYDTNuiv79Do7WA6bjUm4v09rcIhn0moz719hKWgObSSUbdfdI4mgmWKIvITM2Dj7+Vvd4OSxsP4lfrhJMRO1c+SxKM8WoNTjzwOFkak4Zj3GqDWnPxJRvxO20vsoQ8S6nW24z6+6RRgGHZUyE6XdTEcVlYO/OyhPFhlPleRNCt5QgnA2q0OFVZY5yHrHiLtN07ewVvFfb3Uk7DdrAtG5FLHNvFcV9c+FScCo4UXLv6GWwlGLFFXCttEKYQLFbanG+fYpQGVKo1mvVlluOI04ZG2QZGrlCTkLjQ9Pa26e9vU2k06e9v09vbPiaMP1durdtLayfp7m3dVtfv9VxHBfbnyst9VlkSEQwOUNMluGvtlZdVB4/W98OOVz0qqFomy82lV1XwHhX8wD3X+zmfG1//1m/mlz/6B7hZmbz8uac+xpvfNl+A41553yd/jvdf/s1ZDvb7iRCCP/3g1/E/v/m7XvaxjUYDwzD47//9v/Poo49Sq9Wo1+vYtv15KOkXF3c2Vc55TRCHE4bdfeLw9pWg7rQtjSOyJCbPEyaDDmma0j/YwTBMLNclGA64+fwFguEAfcuqRoc2jObSKlkckcalTy1LIqLxkDxN0VLSXFzBr9ZftGyH5wuGfbTWBOM+sijobF/n8mc/yebzF+jtb4HWnH70DdSbC6ysn6HWXKCzfYO8yI+V73Doul8EtJbXaLfKaPH2lYvsXX2WcW+fzuYVDm48x40LH+fGs5/gxoWPE4x6r+i+W46HzHMObl4iT2K0Ku0PaRwSTwaYhkUcTiiyuyfGL+9bnyyJjv3d8SpUGgt3FQdHj1Nao4qccW8f23FpVJo82nqAJxYe4dHWA3cVMUcFdZ6lL1rOQ/xak+byCRoLy5x77MmZHeduNNwa52onWHMXeOTM45iFmtWZilNhsdImkzmLlTYVp4zKtpZWWVlYo2n4jLY32b56kavPfIpgPAABaRxiWBaOe28R0Hvl1rodDPt3rOsvxaHA3r56sfTy36Xuvxxe6lndWo+KLCEY9hFakWcZhnixcYPj3OlceZbSbq/iYeK88qD3bec/FPy9vZsc3Hyeg5uX6O3dpL9347Z3Ys6ry4OL5/iyr/hTs9+f+p1fJw7my2zfKx+4/FuvCVEMpR3iA5d/6xUde/r0af7ZP/tn/PIv/zJ/4k/8Cb7yK7+SmzdvzrZvbW3xyCOP8KY3venY/5/61KeObf/+7//+Y+d9+9vfzn/7b/9t9vtoNOKHf/iHedvb3sZb3vIWvuu7vovf//3ff9GyZVnGP/yH/5Cv+7qv481vfjPf9V3fNbvua4F5xPg1wq02hqO+Xsf1WVo7SWNheSZK7xTddf0KwbjP5uVn0UVBliTYjluK2Uq5vdpoUeQZQhjHrun6FRy/wqi7jzP9HZh5eU2rzCrhuJW7Xv8oWiuC0YBg1KfIMib9DhiCxeUTRJMhRZ5h2Q79vW0q9SYrJ8+QRAHRZIRSku7eFl6lNvObvn7lYfZ2b6AmCdKbEFc0+9tXSOMA2/HQwiAY9QmGPVyvSjDsMdrfmlkg7iVKdRjhSpOYcNglTUIs28XxKoSTAaZlkwQT4vAapmURtpbueO67RQFfKoJ29DgBFHlOloRYlj2LDDpwLOJ3p3NEkwFZHCGzDK9WR2lNNO7f9T4cRiFtr8LCygpnHn7Di0ZQ43DCqNdBJRHNSpN8PD5WZ+5kNTjKoVD1anVuXnwat1Kl0V7Gsh1aK+svKcpfjMM6rbVCCONY3e5s30CYZSfxTnX9pTgqsG8d1bgbL2WTsBwPAQwOtnD96jFbxK31odZeIUtjRp1tsiTG8XwWT5yl0njx6wLEkwGTQZc8TzGEYHHjPI7rYzsuo/4+hhCoz0EM3FrnvWpzJvgHB1sIoLVy8p689XM+d974Fd/IZ3/3QyhZEE1GfPgXfpI/+z3/T8TL6Eh9qfLND37tayZibAiDb37wa1/RsT/90z/Nj/7oj/Kud72LN7zhDXiex9mzZ2fbL168yIMPPsiv/uqv3vH4ixcvcurUKT760Y+S5zm2bZNlGdeuXeOxxx4DoNfr8Rf/4l/kj//xP84v/uIv0mw2ef/7389f/at/lV/6pV/i3Llzdzx3URRsbGzwMz/zM6ytrfH+97+fv/bX/hof+chHXhP+57kwvs8ciozdzSsUaUKl3sR2XK5d/BTRZEyjvUSWJkSTEa3lNU6ef5Rxv8Ows8fi6sZMCPjVOkkU0N3dIpqMUUUOQmDsG1x79inOPfZG0jhi2C2jj52dG2RZeszze/L8o4x6ZSqvQ4QAr1LDcmyEMBECujs3CUZ9lk+cobN9g+7OTZZOnD4mEoQwqLXaLG+cZjzoIhAMewcMO3u4fhW/WicKRiRRgO26s2Msy76jnUKOJ+x/9mnicEKneokzDz+OEBa255ciq1LHclxQiiwJAU04GaLu0fZwtGFPghF5mrCweppxfx+/Wqe+sEKWJqDBsExGBztMurvIPL3t3IeROMf1CYZd/GqpXG4VvarIcPwaK6cfwvEqx6KH3Z1rhIMutueTKoU8EkkMRj3CQYc4nGDa9uzzARzcfJ5hZxclC2rNRdxKg2Bw8KJD9YfXbS6soqQkGPZnnZI71derz3yKg81raAHtlROcOP0AjYUyij/slr7dxrRDcycOhWp/bxstYO3UeUb9DktrJ2+rRy+Hww7b4GCX0aBDa2GZ1vI6J88/ytLayVmnKxgNWFo7ORPO93q9ox7+SqP1koL6sE7F4WQmRmvNxTvsKWY2naMcrUedratkcYiUBQLB4voZoskAVWSzax0VwjtXLpAEI2zXx7QdkmBENBlgWi55FiPzjJOPvAm30mDS7yAMk2BwMLPQvFzbw622H7+qkXlO5+YlLNfHsB2GB1s4fu2ePdFzXjmN9hJf/ae/k9/+lf8MwPVnn+Lpj32YJ77qm+5zyV77/M9v/i7+whPf9gXtMd7b2+Pd7343P/RDP8R3fud33nGfixcvcv78+bue4+LFi3z5l385V69e5Q/+4A/4qq/6Ki5dukStVmNtrVyd8p/8k3/CE088wQ/+4A/OjvuWb/kWfvVXf5Vf+IVf4O/8nb9zx3NXKhX+5t/8m7Pf/+yf/bO8+93v5tq1azz++OP89E//NB/+8IexbZunnnqKlZUV/s2/+Tc88MADFEXBj/7oj/LzP//ztNtt/vJf/su8733v49d//ddf9n26G3NhfJ+58PHfYtDZY9jdo7mwzM6154nDcSlutWIy6FOp1zn36JNkccSo1znmzV09dX7WQAfD0rLguC6JlAg0wjCZDLrEwZhaq01zaYW9zavs3bxCnmecffgNx6Js+1tXUUrOJuxNRn1s10fJgoW1NfqdHcb9LlE4IQ7GyEKCgCSJOHm+zG5xeK5ac4Fg2C+9tUtrxOGYcDxEKUk0GdPv7OI4Lv2DXcb9Do2F5VkkDyFK60I4wa/WCYZ94nDC8kYpxrM0ptZs4VXq1KaRWyEEbrWOzDOqzUUc1z8mTo9GVW9t+I827GkUIAxBf/8mrl+l2l6m0ljASiKScEQ46mOYFtXWMll6e1aAwyhgZ+sqApgMumRZyqS7h1ttEo56pEmIW62Xz6W9jONVjk3OA8jThELmoHXZiaEUxTc++3GiyQCZZ6ycfZQiz2ZD8GkcYtsO2nEAjSqyY4LlsKyH90BpTdDfJxx2icZDWo0awhC3Pc9DAZnGEdFkhO155fLaaYLrlz38q88+RTQeUmm0OP/YG+8qOP1qnZPnH8VxfIQhGA061FoLn5MoPixnWU/G9HY20bJcELreXCRPY5SSLJ84w6i7jxAGraXVFz3fnSajzoZQ7iGaVGQJcThBpgmTYARQ1skjdWXU2yMcdPAabdI4IJ4MZtsP61F3+yp5EuKunmTU3UWpgmDYLcV5tXGsUyfzjDyJ6e1cx3QcsjjCclxcv86kt4+SEqdSYdzv0Nu9QTA4IBz28esNxt19LNuhyLOX5U8/WtbBwRYyz4gnI8JBB12+AFiOj+16OP79jwZ9qfDEV/0Jbjz/WW4+/zQAv/NrP0tzcZUzj7zhPpfstY9rObi8sklvrwUuXrxInuecPn36rvs899xzLyqMn3vuOb7sy76MM2fO8JGPfISv+qqv4uLFizzyyCMAXLt2jQ996EP8xm/8xm3Hnjp1iq2trXsu7/Xr1xmNRpw5UwZ4Ll26xGc+8xl+/Md/nDe/+c384A/+ID/2Yz/Gv/23/5Yf+ZEf4ebNm3zwgx8kSRL+/J//8zz55JP3fK17YS6M7zM3nnsaWeSMRz20UmRZgpISv95g0NnFq9bxKnUmwz6t5TWEgCyN8esNht09bNudNdq11gLNhWXGgy6GaWCaJkrmuH6F1vIawWjAsLOHZdksr59m98ZlevvbtJbX0Fpx49IFDjav0Vxcnk3Yy5KYtdMPEAx7VGsttq5dJB6PCMMxoKlU62ilGRzsUm8uMhn1ZhaLWrM9i9L1DnYIgzGdnU2kzImCMX61QeY4DPZ2SJOYBx9/M0trp0jjmN7BNt3dTcbDHifPP4pUkiJP2bn6LI2FVRbXTtJeOUGn00ErjTAEWmnWz7+OUXeXar1FnufHxKlfL1OQ3WpzAMjTGIEgnAzwKjWEEBRJjOX6FFlKlkSzyXOW7SCLglFnh0qjjeV4t4ltt9rAHnSpLa6SpTHR3oDBwTaquI7jVRGGQZEkSK2mGWSPT84Lqw2ScIIhDJRWOE4ZVQ8HBwTDLpZlEwRjujcvUW0vEbaW8GtNXL9KHIwRgNNcwq02yLPkWCaMQyEVDHtMenukURlht90qjVoFJRWbl5+Z3dejlhnXr1CpN0v/uID26gauXwqt/c2rOI7LZNRnaXXjpW0GWYxp2gjDZGnt5F0j1LeJ07tsc/0KwjSZDHooJdm7eYU0CnBcD600wajscNSaC2itZtHtu133VrtQGkegNetnH7onK4XleBhCMAlGVOpNijRlsHcTt9qgUm+RpTEHN55j3D9A7Vyj2lrG9Wv49fYLHbY8J4tCsixh//pz5FkCWiOEycKJc9Sai0TjPnmWYgiDvc0rFFlCEo7xak3SOEDmKVIWSKUQAoosI48jRgfbBMMueR4TjvvUWouMuw6GadFYXL3N9vBStpAizwn6B4y7+ygly870xjkGe5sIw6DeWsJ2/Vkn7ui5bo14z/ncEULwTd/xV/jZf/dD5fewlPzf/8f/hye/6k/wlX/qnVj2F67wm/PinD9/Htu2+Xt/7+/xXd/1XayurtLv9/nDP/xD/vbf/ts8+uijXLx4kd/+7d/mp3/6p2fH/cAP/ADf9m3fBpTi+i/9pb9Eu93mr//1v84P/MAPcPHiRR59tAyY/O7v/i4PPfQQp06duu36+/v7LC8v31NZkyTh7/7dv8v3fu/3Uq+X36eXL1/m+77v+/jyL/9yoPQ1/8iP/Aj7+/v81//6X/nABz5Au122508++SQPPfTQK75Xd2IujO8zru8TBhmWaZcNu22TxyHjQRcUZHEEAqqNFktr5cpR3Z1Ndm9cRmuJBpZPnKK9vE57eZ23fv2fZfnEaTq7N0FrvGqDUw8+hl+p4/nVWZQujgNaK+s0WgssrG4ghEE2FRn9gx1OnH0Yy3UZdvdnabRs1yVPYoLxgKIoGOztMDAESha4XulfRuuZB7PwKiglyxRdBzuoIkdP17ILBn1UIQlGfZI4ZNDd5WDzCq/7srexunGOaDycWUU2Lz/LzUtPl2LWdjn10OvwKjWSKGBx4zyGEKRJzLi7w+hghywJMUwbQ5QRuubyCSaDA3avPoNp2xRpOmv448mAOBzPLA719gp5lpDFIbWFVQYHW/R3rpE0F1hYO1N6PLt7xOPSO51nCU6lRhYFZHGA49dorZ4kHHYJgxFRMMSvlSJIK4XWmiJPsWyXcNzH8XzUkeDjYQo4y/EYd3YJhh1cv4Y5FbRxNEFKiZIS03aoLayQJxH9ratU28u0Vk9Rby+jEViOiyHEsXRzjlchGpfR9zwOCYY9kBKnWidNJnR3N9m89Ew5atA/YGXjLKunH6C/t029ucja6fOcf92bWFw9iRDgeD7pdAKb0IAQCP3SAdVxv0Nn+wb11gJxGNzRvnE3L3scTjjYukFn9zqmZc9yawO0F9fobF8n29/CNC2C8ZDJoMuJ848ShxPqzUUW1zbo7m1xsHWdLEs49+iTnH3kiWPX7e7cZNjZpd5eIhj1ZwL8pbzJt4rHxY0yIlOkKUk8IRh2QAiayxt41TqyKGgvnaC3d5N6a5E8f0E8A8gio9JoY6YxyWREnsRUGy3iMCCPJmRJNOvUDTrbZEmEYdkUWU447iMwMG2PIinFqNYCmWcoNGkSkcVBmXXFtKgtrCJMEyHEbb7jl7KFjHp79LavEgcj4nCE41fI84zB3iaqKDvnpY/dJ01i+ns3SeMQ16/SWj11zO4TP/DA5zRyMOcFKvUmf/p/+Jv80k+8B1kUoDWf/t3f4ObzT/NN3/kuVk/dPWI45wuX06dP82M/9mP8x//4H3nve9+LlJK1tTWefPJJzp07RxiGbG5u8oEPfOCY7/iQw+2PPPIIrVYLgOeff56LFy/y7d/+7QAMh8M7it84jvnoRz/Ke97znpcsZ57nfP/3fz+nT5/m+77v+2Z/v3TpEu9+97tnv3e7XdrtNh/72Md47LHHjl13OBzOhfEXG6bl4LgVvEoDy7LwGy1U0QIElu2QphGTfpe9zWtorVlaO1mKS0NgWx7j7gG96US1Ua9DlkQsrJyg2mhhGAaVRov+/g47156nyHMc18WwLLIwwBCCXpYwGQ+pVOuMBx2SKMDza6ycPIshDPIiK0VoEhJNRpi2TZrGSFmQRgEYAr9WYzLssXv9edbPPTKzQoyHXQ62rqGUwvNr+LUm6M3S7uFXMC0LjcKybJRWFHnGwdY1kjAgjkMmoz7tlRMc7NwoRdTCEkWREY2HXH32KUbdPcaTkPb6GdJoTBIFTPp7IAS25xNGIaZh0Nu9QTjskqcxCEF1Gjn2anU04nhqtnBMHE6IgnHpvTximYgnA4adHQb7W+RpRJ6mxMGQeNTH8ip4tfps9vfgYJs8DsmzlCxJKPKULJpgexWUKpAyxzAskiiiv3uDaqOMEgajHmk4RirFZHBQWhwmL3hFhwfbaCXBELiVGlEwokgSbLdCd/sqsshZ3CgnPPS2r6KVxqvVjw2JH0Yy0yTC9asEgx75oIvleuRuimEYCFMwGfZBC/qdPRzXp9Jo0VwsJ4DeOgkUIWitniCejKi1F3F9n0Fnl2DYp9ZamKVfO/TU37xygYOta2xdvYgAxv0DdreucubB18/8yttXn6O7c5PVk+dm0eEkCrjy2U+wc+MScTBm9VSZa3nU6zAZ9Uo7kSxwbBe/1iAcDwgmI64+/QmkKrBcFyHg5qXPcrB1rfSsb10DYPXkuZnff9Lv0N/fwa1sUWssEEcTkigs7SN5Rp5ndLZvsLxxZibi7jTpsja19Ez6++xeu0gSTdBKoWTB2vnX43g+0biM5qdpjI4Dgt7+1KqzhGk5ZecxGKGVQhY54TTyPR500dP0gTLPQEORxqTDThlVljaGbWLZFqZlYkkbJRVCCCzDJJkMSeMIx6uCYZBOhlTbS9helXDYRRgmw/1NiiwlDkYMdq6DYcyyTqw/8DiO6xNPBuxff45xb588iQFFFoWAwDAMtGGQphECA60U/d3rBP0DEAYHW1cZ7G/h+FWWN84TTgb3NKlxzr2zfuZB3vG9/4gP/fxPMDjYAcpFm/5//+Gf87Xf+pd4/I99/X0u4ZzPB9/wDd/AN3zDN9xx24ULF6hUKjPrwq0899xzrK6uzkTx13/91/ORj3yE5557bhYx3tjY4Fd+5VduO/Z973sf6+vrfP3Xv3i9Ukrx9/7e30MIwXve857ZxNBOp8NwOJxFhAE+9KEP8ba3vY3hcMjS0tLs7/1+n6effpqHH374Ra/1cpkL4/vM8onTxMGEXBbYlsnGuUfZvXmFcDxk3O+QZQlgIMQVRv19tNbUmgscbF5FaXBcB601V5/5FDtXn2M07KKlxDBN6gvL1JoLjHr7xJMRo94BrlfhxAPlBL4sjbFtlzxPQWmEYdBaXqPRWsSv1EmiENu0EaZB1NvnyjNPkadxOfCvNVqAyjLiSYBpmvT2t1k78xD15iI7N56jt79DNBnRXFzBtC3WTj1IkWfsb17BMAwwDAzDJs1jtFYo2yaJQrTW2I6HpPTZDjv7ZFnK3o1L1OoL7Fy/RBoHKKkZDXtkSYztuORxRBKWk/m6W9co8hShBabjIIwyEpanCbExpLV6ssz04Pok4Yj+/ibJZEg47CHzlNrCKslkWE7uSyNsx52JaEMI4ukER8evEk2GODLHsmykVhRFSjpN56aKgjhLMCy7FGxCgAaV52hD4lZqqLxM05WlMVvPfapMuZfGJMEIw7RQRUYw6GCYBnkSIwyBTDOK9HDVOUE46hGM+sSTIaPuLl61QTTu4/oViiKnsbA6E8ZHI5nxeAiAYVrYro8lFIPuPlka404zkNh5Sq3RJkuiY6Kls32DvRuXaS6ulCsaLq6WUUYluf7c03R3b5LGEaZlc+bhx2mvrM/sPP39LerNBUaDDv3OLnEcsH3tOYYHe7RX1smzhM72JtFkSHfnBqcefhytFRc/9VGuP/tp0iTCtCx2rz+PZVlkScTgYJfJsMe430HKgmF3D9O2ScIAyzQxLZsrT/8h3cVVers3mYwGOJ5HMBpw+emPE05G9HY32d+6Rq3eJE8T1s88iDAMLn/6DzjYuU4wGSLTtFw+udbkwSfeyoOPvxUoo6bRqE+1tUwUDJn093GrDQwhMCyHPAmJxkMQIPOcNApYOHEO03JQSqFlUQpIIRCWQZ6ENBbLSS55EmOZJkWWIBB4jRayyInHfartZeLxEMuy8aoN8izFtC1kXuD4NYSwcFyHIksJkz4IAxBoVY46FEVOrbmIsGwm/Q5pdA1hGFSbbQZ7fYJBp8xokUTIPMOt1imyrFxau156o5PxAC00cJjzTSNME60KtNDINMcwTQzTJBz2CQY9irzMABOP+7jTutlcWrvnLCFz7p3Vk+f483/zh/i9D/4CT/3Ob5Tf30rxm7/0U4wHXb7yT74TYcyzt36pcPHiRR577LG7Zik56iWGUmT/wA/8AGEY8uCDDwLwTd/0Tfyrf/WveO9738v/9D/9T2RZxs/8zM/wf/6f/yfve9/7yjYe+Af/4B8A8C//5b88do1//I//MZ1Oh//9f//fsawXpOilS5cwTZP3v//9fNu3fRu/9Eu/xDPPPMO73/1uPvGJT/ATP/ET7O/vY9s2/+gf/SOklHcV+K+UuTC+z5iWjeP7BPs7KNelu79FlsQYpgnCwLIcpMzLRn7kYBkWGw8+Rq25iJQ5jfYS3b0tRr19iixFFRlKKYQhMIVBEk4IBj0moz4yzzAsm91rz4MG07bpHFzHtByyPMGxPaJgjPnA69Ba0VxcZuXUOfr722ggHvfI8xyZZWAI6q0FwtEQpSVFXjAedLj8mY+zuH6Sg83rSJkjDIPhwS5FawHL8fCrtanHEwwBzcUl6guLDDq7mKZNFIwQhkF/fwfH9ejvbxNNRmgEAgPH89jbukqeJFTqDUzHBS1Jogmj3h7CKMWvlJI8z0ApdFpOQFJFAUIgi5zezvWpXWKlFAzDLkk4wbQssiQmDkZ41WZpa7DL9FOH1oTDTAGxzCnSBAyBmdll6jivArq0MaA1SZ4jlUQoE600WZrgOB7V9hJxMMawbPxGeW/6ezeZ9A7wqvUy16sWKFWglcacCv84GGMYUBQphmFie5Vyclf/gKJIEVpRZCmylaDR9Pe2cBwfrQpq7RUW18svEEMIGksn8Cp1bK9CHJa+5GazSRyMKbKMJJ5Q5CnNxWV2rz9PnqYsrpSe4iQKuHLhk3R3b3L9+c/QbC+TFzl+pcryiTNc+vTv092+ie17MztOtdGmWm+wvH6G7u4mk1G5+EuWJhRZhpQFe5tXGPX2y4lkRU6elv+2Bj2e/eTvcuXpPyCOAoosw/PrCM8gCiZsXXuOg62r9HfLTBfCEJiWzcnzj9I/2CPPUvI0JgomKFmQRBNAk0YhzYVliizj+rNPIbOMaDIshapWZGmEabtsXrnAZDQgT0uPr2FZyKLg6oVPIfMcx6twcOM5VFEw7OyglSaeDDEMA6/SQBhlqsPDZ5ulMTtXPku9vYzj17Adl+72LnkcIGWOabn4jRbCtFGyzGBSKBMMA9BkYVA+Z79GHAWYloVXaWDYDqZpg9Y4fpXG0jpepYpSmjwJiaMJtu1guz5JHFCrttEIWisbhOM+0WRANB7gun5pE3I9LMelyBKqC8uM9rZIwoBaa6GMKmtNY/kEw84OyKkonnb+LMfFcnxkNMH2fQwMgkEHhEFeJKg8QwiB59fRSpYjIQiSKJhHjD8PWLbDH/8z3835x97Mr//s/0Y47RR/8rd+jcmgyzd+x7uw5os/fElw8eJFnnrqKd70pjfN/nbixIlZ6rZbhfGXfdmXMRqNOH/+PI5TetPr9To/+ZM/ybvf/W7e+973YhgGX/3VX81/+S//hZMnT86O3dvb48/8mT9z7Prb29v8/M//PK7r8hVf8RWzv7/3ve/l+eef553vfCe/+qu/yr/4F/+CJ554gp/8yZ+kVqvxtre9ja/5mq/hm7/5mzl58iTf8i3fQqfTOSasXw2E/hyT9f3Tf/pPeec738njjz/+apXpC453vOMdXLhwgde//vX8wi/8wss69mO/8V/Zu3mFemsRJRWO56GUxDBMujs3mQx6SFWQxBG+X07acj2fLE3J8wTTsBBGOURZRmFNPK+C4/vUF5apNlrcePYpxv0uwjCwbBu/1sA0LSq1Bt3dTQzTJomDWcqo5Y3TPPzGr+T8Y28E4GDrBn/4W79CZ/smaDWdDOZRbbRQUhKOS3Fj2Ta241GpNSlkRhqH+H6darNFe3mdyWiAEAK/UqW7t01zcZVx/4BwMiKaDLEdB5kXVBptbNcjT2KSOEALsAwb0zZRhSzFeVHgeh5OtUG1tUQSjgmHPWzPw7J98jQiHPYAjWFaOJ6P1hJZSIosxXJ9EGAaFoZpoqZRdiUl1WabIkupNNplzmfDoL6whlepMuzs0Nu+hipypJRYjotp2Fiuw+L6adI4wnY9JsMuqijIpwuuyLyMmLl+DSHAr7eotZaxXJ8kLO0XWRox2L2BlhLLdqkvrWGYFl61QXvtFIOdGwSjLtF4gFYawzLKToowymF+VQAay/bx6s2p95Qyd61lYRoWzeV1au1lDMsmDcelhcdxMG0XmWdYOuf6xc8QTYYYpoFWUG22yLMUv1JlYf00G+cewfN8rlz4FJbjcPO5p1lcP4nnVfEqNRAQR0GZ+SRNyLOE9TMPMewf4HkVqo12OREMTTgaEoz7pEkMWmFaDtV6uaKf0hKZ5fi1Bo5fIRqPCMeDMrKlNIZjU6nUaC2vkWcpo37ZudFKlX76io9lOgjTBKVI4rCcKDjsoqTCrVTJ4phao0VR5KRxhFIS16tgmCbVRrP02tsOn/29jxBHYZkGEUAILKt8l9pLJ1g5dZbrl57BdisMDzYRWuA1mhiGxdLJc4SjPloWxEFZT/M8K983Q+A4HkpKsjQuI/e2Awi8WoNqa4EkCpBZhl9vEo4HKClpLW8QDPZx/Crt1dPlqIbtEgx7JNEYw7BYPHmOpfUzpElMd+syk94BCE0SBmit0ErjeD6t1ZNU6m32r18s83fHEcIw8PwaldYSoIgnI7TSKJljmBbNlQ20VnjVBqZlIYucSf+AYNAhT1OEaVCttzFMizgYobREIHD8avleZDF5mpU+ddfDqdapVJsI02R1bYOveft3f47fyl+4fC7tyb0yGfb4lf/j39DbeyFzwMrGWb75f/g+Gu2lFzlyzpx7pygKvvVbv5Vf/uVfvucV937gB36Axx9/nO/+7pf+DnjPe96D4zj8r//r//q5FvUYn7PM/s//+T/zsz/7szz44IO8853v5Fu/9VtZWFh4Ncr2JUEwHBAHAaNemUnCMM0yB3CzTbXZRhgG4WRUCivbJo1ClJLUGm2SzgQlCkzLQRgaYbrYjsPSidOcffQJGu0l+vvbbJk29YVFwtEIy3ZZXN0gGA3wqzWWT55l3O+SpxGmaWO5Lq5Xob+3xeLKBs3FZfIsKSNoKGRepg1LlcT2XKq1UlRIWSCEQMqcJA4xTAPXr1JvL1GpN4nCCa2lVaJwguV41BeX0bqcRCaLDCUL8lygNRT5YbSyQKMwhIE0wa/VSFSMaRaYpgNCUOQp/Z0bFFmMRqDyDG+tTq19GrQinoxxvAp+rYmUOfE0bVaRRICmMAwMw8KezYbXpEmM0JrJoIvjeqRRiNaKaOyRhGO01gjTQEuJLAqkztBIxoMejlcpJztlKY5fRRY5Fa9JkeUURYZSknp7Cdvx0Vqx/dxT5TmnIt12PAzHp8jLlQZrCyusnH2UPE0Ixz3CQR9hlP5oIQwyI6bIspkoBhC2QZaEFFmCBrSU2LZbemB3bxKNB6yee6wU2FIhlZx2tmLIEwzTQCkJhoHtuBiGgeN4pGnCuHuA51VZO/0AWkk629fQuhSdaRITToYUMkdJhWmZgEeeZezduILUBUVS5uS2HI96q/yecLwKpmmRJjH11iJaSzy/hpIFYT6c1j+JZVs4jkuSxGUnUJf2n2FnD8O0iYMxSsppwFKxuHoSyyrv6bB7AEaZL9h1q5imSZ7nVKpVsjQiCsoUfUpJRKwwHRfbWWXUO6BSa6KkLkccZohyGNIwGHZ3iIIRcRwRDHtlCrtqnXg4wK5UObhxhSwNsGwf2/MwbYc0icpyKkGUjQEFSqGKDK0K3EoDw7TobF3FMm0szwdKER1HAb3dG+X1hVF6y/OcLCsXdXEr1bJ+yQKlNWk0nr6/GsO0cfwqWRxiOiZ5mjI62CEJJ6RRSJ5nGKYxFbwOtuNSqTfI0qS09ghBNrX5LKyfwbSdMh+3V2XxxDmEEGRJhO14uJU6WmvcWp0iDglHA/I4RBgWwjCpNRdwfZ9aexlh2kSjPrV6m1H/4PP+vfulTr21yDu+9x/ygZ/+cTYvXwDgYPs6/+Xf/RO+6TvfxblpUGTOnM8Fy7L4tV/7tZd1zKVLl/jWb/3WO2775Cc/ycbGBouLi3zwgx/kl3/5l/mlX/qlV6Gkx/mchfF3fMd38IEPfIBLly7xnve8h3/9r/81X/u1X8s73vEOvu7rvg7TNF+Ncn7RorVm7cwD3Lj4aQoFKi3THDmOx/qZB4mCMVIWFEpSjEcgKDMGDDpTe4EgTWNMYVAUEkSNKBjjuJVyJa3pKl+WdAFBpdbA9aukUUS1sUiloUiigDRxERggoHewXdoKbJvm4iq93U3iYIwpDORhuZUmS2IsywEDhGmhhcBxfQzTLDMwKI0QAq0URZZhGAYbZx/GcT16e1sEwwGFzNCyHEJVssDzq+R5iswyDNNCK4Vp21TrDRrtZbQ+YDQI0ErhuC4CByVzijzHEIICSMIAv9qiUm8hhIlXb9BcXCeJxmRRiLQcVD5dMEMplMpRto1QBqqQJNkQr9FCS0kShyiVM+7sYtsumDaqKK+HITAdr/RnY6CKFJkJ9q/ukKUh0bBfRqUdF9t2sVwPnecEwz6m46CVJommS7XqMo0WQqDTGI0iDIZIqTAtm1HvgEnvAClzLNMmGY8QlomSCsMUGLY9s4roQqF0UWYnmC6/m4QjQGA5DnmaMtzfJJ6Myty2aGzTwXQciiRG6gLLdkufaaOFENA72EXlKcGwRxSOAE0ShURBQJam9He2EIaBaVlU6k3CYIRtO1SqDZIoLC0IKOJwDMKg2iifd7XRYrlWJ01CgvEQxylTq7WWV+l39xCGgdJQRBFKS7RS2I6DO408xsEIqTWqkGWnzTCwbY96e4kHXv8WwmDMweY1FtdPEk3G5HmCkoooCrEso4wmTwWvnOaKzjSIImd/8yqW7VCpNUGI6eqPpTdeyQKFIOh3EaaJJwu0MLFdF60kaRRgWVY5ohJ1AY1MErLIBMPEsMwy2o8B+vhCAkpKDMssI9iywKm1ysVIKjWUUlQsi0lnH6klKEWRJWU6w6JcsCcJJ9SaC4TjIV7lgOHeJuFkWPrUp+U/tEMZwmQShyTBmCQJAAOhdfkuVsqUgePuLkkcIbOYchESRTjuU2m2MQyLanMRJQv8Wp3W8gksx6e/dwPTskjjkCJJCMblXICyAycwbQe73mbx5IPIPGMyOCAY9giHXRrteWDljwLXq/D2//l/4bf/75/hs79fLvGbxiG/+lP/lq/4k+/krV//9vtcwjlfily+fPmu+ZUvXLjA937v96KU4tFHH+U//If/wMrKyqtehs9ZGP/wD/8wP/iDP8gHP/hBfvEXf5Hf+73f48Mf/jAf+chHaLfb/Lk/9+f49m//9ld91uAXC0pLOlvX0UKQhBNUkWPZDkkcMDjYZdzrgAA9HcK1bJeiyDFdn0qtSZZneIYgjaKZWB329rh56WlqBwvEUUBrcYU0CWksLOF6FYadPaJoUuY8zTOyJEIXilwm2DhkUUIWxYxHfZbXTtFaWsOyHNxKrYwqAmCQ5xlZmiAMcypoyqixaVqkeQCGQzAeoLQkTcr8zAurJ9i6+hwH29dL0VNIEAa1haUy1ZRhkqYJlmWR5xmm7ZS5dJOEOAqwXQ/X8cnzDFlIZFH6K6HsMNiuRxZPOLj5XLlSH5BEIYI9bNen0lpCTAbkhlF6rqeTCxsLa8STIZmKUHlGNChtGQJzOuGohiokhiExLBvPdkuRledoLciLhDSLyxwBWmMYJlooDGFiGeVy2oZhkGmNysrJdX6tibAsZFIKDtP2aCytEw67yDwji0LSMCCe9MmmmUAMDdrWKKUwlVWmmRMCIUws2yuzlTjlhEEp5S21rVyNzKp401zMZWRXypxCp1i5XQonDbbr41eq5UTDIxYCrRSTYZ/rFz+NadmlQJyuEKVlQZYmpFNLwKGNw6/Vymh5PhWAuuyM1ZsLLJ05VS417lWot1bK6GQSoZRm0i+H9Yt8OslQmHiVynSERCBsE0PYqDTDcT0KYQAK169y6oHXsbR+Cr2zieOWFoNCFsTBBI3CcWy8Sp3xoEsShbMV5ACQBRpIo4DCsonDAGEayKLAME1MAbbjoKVGaoVlOETjsuNhOg6mYWCaFnalhspz8ixBS4kwBGBgOTayyEEfTlQryw1lB9NyXFyvRhIHoGAyOMCr1MtlrtFYpo1UeVlH0hg9tV6VwwMa0KRxwOhgkzxLmPR2iSdjhAAhTAzDQBYSJfNygpxWCC3RUuJVqqRJiGFYyGLqt5YFSimmFwBKH39v6xoIg97ODbxag9UzD+P4NfI8RSCIxgNq7WUSLaYdCxOZSRDmrKOh0XR3rpEE43IJdsuh1nzwc/9inXNPmKbF133b/8j6mYf4b7/4vum7Br/3G/+VxdUNzr3uTS9xhjlzXl0+8YlP3HXb93zP9/A93/M9n/cyvCqOZdd1efvb387b3/52Op3OLLx9+fJlfvInf5L3ve99vO51r+Od73wnb3/722k0Gq/GZb8oqFQb5ElCa3mNm88/TQ4oqUiiCb29bZI4KFMxTSnytIzMOXYpDpRGa8izFLTGEi6yKAjGQ8R0+VoNKK2o15tkSUyaRqgiZ9g7oMhTijTFNC0KmaOVLFdSKzJ0qMiThGFvr/Tpuj5+tYlGl0PtgOv6jIbdclibMgKuUdRbSziuz3jQIQ4mOF4FpRSD/V22Lj/DsLdPFgVYtoPlONQabcz2MuGoV0aMpcIwzdJUrzWFzBl2dpCynFx2KJQMwygn9dUa05RvKeQFShblxEU0JCHhsINtOSyffRivUkMrybi3T5ElmJZTTtbLYlReena1KsjiGNN2kEWKDCSuV0ULgWlYFCrHcTykUsgiKz2bhQIlEaZdRu8AYQnyNMbGx7BskmACWsJUQPvVJsqtlgsf5ClZEkzvb1GK/CQpn9c0mqkAAwdjel+QBZgWhmVQby7hVOtlvljLQU2tFBgWqALLrYBSGFa5GmISDI/URIG2bLTQNBeWpnaIAqXL6OgLIq4UwOF4gGFY5QiGVGhVTLMdKFShUEpORw0kUmrUYbJmISiXQ9NgGETjEZNRD9sun8GwtzdbIbEUrC9YRNCSLInxKiam6ZKFY7KsAFUKWcM2qVQXOP3w6znz6BPsXL/EztXnGA+7SCXx/RrDzi5ZnmKKMppr2TZ+tUIwTLgdUY6QFBlIUQ7/txcxhUkSBSQyAUQ5yXMqGmWWYFXqGMIgmQxRUqK0KsuoynNmMsewLJRUIChtOUogDAvHcbDcsmOjspRCZhgIsixhsLeJV6mDMb1WkVP2muX0/upp9hUDf+qPT0b96YiMRohywqBElcehy6w0WYxUuuywhENAkCQB4WRY1tXpNBRhWOVzxkDLnCQKAIEwmVqxDBqL67iVGk6lSjaIGXf38BttqrU2g4Ot8j7porSQTEaom5eJRwOyLAYlKbTmYJo+b84fHY+86StZ3jjDz/9//9/lIjLAs5/8nbkwnvMlyauelWJ5eZl3vetdvOtd7+LZZ5/lgx/8IB/+8Ie5cOECzzzzDO95z3v4xm/8Rr7zO7+Tr/zKr3y1L/8Fx8YDjzIedGc+SaYePy01WRrRXFhhPOgii7xcGkNJTMtGZgWOWyUrhuRJOhMuRZ5i206Z7mrnBnIa0cuShBOnH6S3t1Xmgw0D0qTM1oAAObUxpHGZLq1sSAUITZ4XGIVEa01zaZksSRECgtGAQf8AoTTCAGG5IASVahPTNKcrsAnicILW5YIC+1tXGfc75HGM0pQLh3geJ88/Sp4lxMG49NlOI5SyKMoUVcKYRoYFhu2g8nQqCCDPErxKFQOrnNgjE9CQZ/Gxe50VOd2bl2mvn6W9egoFjPe3SONJ6fM9TFd0KAK1nIpCjS5ykmiC61cxLAcThe3XkNEEJfVUQAAItMzL4XLDRGmFME0KVSCyZOp/nQpIJfH8Ck61US5wkETIIsewrak411i2g5YKhQBDYNkeXr2JylLiaAKUubDRYLoehiHQWmN6PqbMAAeVT+9lnmG75dLZhxP+DhGmSaXRwjZNGouruJUaaTghT+Py/vrTCGa5N0opaq0maRRimva0jkWHJwOt0AiSKIbpBCtpmNNOngIshp0dRp3dqbiW2G6VNAnIs+yIED8+N1hJOZtsWt4fE5mDaZqsbJzngcffzImzDxEM+/T2tkrvbzgmjWMm+oCiKDCEgWGZ5QTPNCWOwru8nRqhFFqUUXilcjyvUq52OOzj5ilFURBNBqjihY5DmkS4lRq245WTCo90bEthqMsOGJSiU5s4nk9jaZ1o1CNLygh9ORm3QppGkKek0aRcHGRpnUp9EXPqqzZMp7TV5DmmbWOYJkWRIzQYlkM2Hk57VBq/Wpt22kpBnxfJLJWh5fgUWZnrW6a3dhQMTMcB7aC0LB0RiFLwFwJJTpZEDA+2sWyHcNxH6/I7TGtVTlK1bGQuZ88xz8uOaJaXorjcoGZRyzl/dESTEU9/7MMzUQyUoxBz5nwJ8nlN1/bAAw+wt7fH7u4um5ubRFFEmqb82q/9Gu9///t55JFH+Mf/+B/z5je/+fNZjNc0vd0tknBCUeRU600Mo1zYQwuQWUaepdRbCxRFQZGXk9QETGeCp2WDdySaZ1o27ZV1/EqNOAxKH7BtY5gWo+4efq2BlGV2BqUktuPheH6ZY9f1SrEQR0RxKRYMYZJEIa7tIHWBknX8eh1DmOXwLBqFwnXLFds8rzJd/GFEnqfYrlcu/jDNT1rkOZV6gzyNKWROHE7waw0W1zbYuXZpOltelUP9SmGiUaY1nQxmopWcZs8o/dCWbYMA23ExHa8U0nk2nUgFh433IUorgsEBaTgijUMUGiEMlM7LeznN+SpMmzyNAIEWRnmPlSSNA1y3iuX52I5HNB6iteTocDiIaRYIA6XKyYNlWqsNpCxIwknpVaXMJiFlQRaH5WfOM5Aaz69huWX+5SwIysjhNBev61aQholSmjQu8yUbpkM+tVvkSYymzDlrmjbYYFk2tlcDrUjDoBRAhxgmjlfFrzZotReoNtvkWVbmvw5DQFFttMsVE8MA0GglmQx6WI6DMYuaTtFT8TP1cQvDIksSXN/HtH10UdoKkjCcRpAVwjCR08wgh+JRGBalujPQ08ixadtlBhTLRiqJzMtRDllk9PY3AU0UjLAshygYE0yG5HnZuUmSpOy0UOYRTtwAv1LDl3UKyyZLMxzPRUqF51coColt22gUWRLh19usn30YrcrJjHs3L5WpEcXx/K+GKHMEF9Py3SruMcxSEE/tNYcTW6NxnzwuvdS245U5zAXlsuBKkSYRWmu8WgOv1iDLIizHKTsLWmNaDpbrlpH86fuSJgGO7eAvrZElIX61wWTQpUhjLNPGdFxqrUVGnZ3SLmGYHFuK8bBGGwauW51ZL4osLpfInkaeVZETDHrYrotfa5ME4xcm40YTjHj6rE2rHOXQiiJNEY6HbTnkKivrjRD4tfmI4h8VSRTwyf/+fj7z0Q8d65AYhskTX/VN97Fkc+bcPz4vwvhjH/sY/9f/9X/xG7/xG0RR+WVuWRbf+I3fyLd/+7ezt7fHz/3cz3Hx4kW+53u+hx//8R/na7/2az8fRXnNU28tYLvl8rG9gx1cr4JplytUrWycxTBMFpZPkKZRuYLd9efLTAGmiev6yDyfTmwqG1qvUiujs2k8zUebkqcJ1dYC/3/2/jvKsrO880c/787h5HMqV1fnoAwSCBiiwcSxAY9+9uDB/OYOxmDAnsBasBg8YF95xrK5g8eAh2UvDT97fA3LNuO5GAzGgTDkJBCSWmp1DpXPqZN3TvePXVVd1V2d1C0hif6uVavO2Xu/Ye/97rO/7/M+z/dpTO+gWK5x/OAPcYVA1U00Q8cqlCmUKhQqdYbdNotnjmEJiSTJfygVRUJSVVTVQlEUxqd30eu0SLKUYrlOFPhM7tqPoqg058/QWjyNyEAoMv5wgFWq4g57FEpVCpUaKwtn8mVjXdAYn6Y+OYOmWTi9DqHvYxcreL6TLyWvypxphkm5MUYSRyiqnuszd9tk5D7NoeeRukMkWUU3beIoxCxVSaMIz+mtWqRyDeI4DHOqsuaDK1glZ3lwmqpbSKqGZtrEUYDv9smiLPepTZOcmNjFVQk2CUXoxIGPUHSyNQtzkuTuIIqKoupkuYME9cmddJbniSNvNXNejzBQcitpkhOkDCDOfYeNgklx2y46S2cwCyUkWUNVNTIKxFFIho3IBEIWRIGLJqzcF1aSVvWPJUgEKZBEAVmWEa1akNdOXtVyrVoQaKZFrTHBwe9/lV5nBUVRiOMQ0ypSGZsiOH0815wl95zQDRtJlggCH0lWkBSFOIxy62CSQBrlQZiSwCpVCIMQlGjVSpurRAhZXl25ELnPeZqtumVkuY6unqfDTuMUWZbyxBSKgmkX8J0haSrnqgxBQGv+NEkSc9vzXka/00JRVJx+N3c12njWkkQc+hiNCZIkRTcsrCxZ1ewN0UyLSn0UZ9Bft5hrhkmWJvRaTYLAJVnVqE7TFFk1SaJ8siGrWn5v0hQhCyTJWp3EJnmqclVFkXN9cshQZRVF09ANmyT0idyAJB6i6CalkUncTit3qQoDMi3DH/ZpTO5EkWU8d0B78QxxmLt1ZFmCWaySZYLaxAy91iKplPs5K5qOatpUdQNv0CVNc3UX3xmQZSmymgcXSpJEkiZ5co44D5aTZIko8rHNGkahTHs+1z/PspQ0jfMwYEmsThQyZFWDLCOKAuIwd9VSNY3Uj0FSkFalm8Igl+lDSAiR+1cn8eZgxOu49ggDjx99/R/54de+sCFuJEex2uBld/0bJndcjwt6qmM4HHLvvffyhS98gYWFBQzDYOfOnbz3ve/dpGF8HZtxzYjx0aNH+Zu/+Rs++9nPsrS0xJo88u7du7nrrrt43eteR71eXz/+l37pl/jABz7AX/3VX/Hf/tt/+4klxrKSZ57qNZfWl7GULMWyi0iSwtSu/dRGJ1iePbmaBENGN3LyY5eqRFGEqnkoqoZdqbJ97y1AhizLHGkuoRomvjvA6a4we/Th3BLq5dnh5ETBLJSJw4DW4izesE8UR2RZmr+4VhUliqU6KSl2ocrErn3suel2eu0mw06L0Pcojk+z++Y7OHP0EWRFRlUNPKdP0aqRZClJ5EOm4/sOtfEpitU6kqKsJ+IolKoYlkV5ZIwoDuh3mpClaIaJomgopkGxVEPTcoUNw7JZPHkMdVTHdT3EqlUt8j1K9VFC38sVD8r5eOt3lol8n8h38hdvGOUJMlaDxxC59FdGhqKoSJqGquRycEkUIZDJSEhWLex2tUFlZJI4ivC9IYE/zMmdLBNnGSLL1jPJSYpCEoWkaYTba1NuTFKujzHoLBEHefrlyPcRiowka8iKjEDOLX9rUf1hSBLlgWOaZuWprbMM3Sxg10YZriwQ+B66ZpLEybpIvyLl1k9V1UCRSeOIMAjJVv2fEQJFtzAKJYQQOIM23aZCb2WZKApzv984Vw3RTAsQaLpOFAarSWQUkiQiiTOM1UmEkCRUXUOWFZRUIc20fF/ooekmpBlZKpPqCZESEwe5WolllyjVRlBUjdbCadIsQ9cNzELu0x4HAZIs0VyYQ9PMfOI4uRNn2KM1fxrIXUUMy0KRZRbPHGfYaxP6/mrgY55gJZOU9bGFyJeQJSEo1OqQZZh2iWGvnbsjhAFidcJZqtYZdNv4rouQBaVKndbSHLGfq22kZMiqjqSqiCz3u1aU/PpJqqAysh1F1UGWUWQFRTMYdJrEgYdm2iiaQRL5SKqOamaQ5v6/sqzmCg6JThpFqKq+SoKzVS3qAbKskGb5aogs57EHqqzjdFZQZAWtUKZUHyXwc63xfnuZKPCQFB2xpvGdJrnrhqUwsm0PYeDRa87lgblJgqIa63rgbr9NmkTIkkSSpuiauTo5UFfHsEapNkoYeqRpgl2qkqYptYnteMMuvpsnJ/FdByFkMvKVrlznuIB8PcnE44Y4Cnnw21/mvv/zt/jOcNM+0y7yrJ/6GW5+zk8hK9fvwVMdWZbxy7/8yxw5coRf/MVfZOfOnfT7fR566CFs2/5xd+9Jjasmxn/6p3/KZz7zGR555BEgvxm2bfOa17yGu+66i2c84xkXLPuWt7yFv/qrv+L48eNX242nLHorS0iSjFkoIlyBqq4uO9dH84QZqs6wl4v667qNVSihqBqGZTO1+waK1QaeMyTwhkzu2Mfum++gtThLZ3kBzbBykkn+0hy0V0jSCEXWgIw0S/FdJ48Wj6Lc51hW0K0Cw06LOIrQDJM0S5jYvpddN97OyNR2TLtIdWQC3cwVLioj4ximzdEH78NdTbBQrDaoj08TBQHusMvUzv30Vpq0l+aIw5D+yvJ6koRyfZRSbYTRqR2oqo5drNBrLee+lrrALpaoj00xMrUDzxmg6xZOr4tuWcydOo436CGElLt6pClmsUy2qqygmRaGXaK9cAoJEEruv5umcZ5EDAlZVskyJbdYrlq/zFItbz8JMewCSRgQRwG6XUQzbOzKCEnko5u58oBRLpFlKfqqlUwiXxJe85FOk4zY9xh2WljFMqXaxKpPbobIVNIoIM1Ckij3fc0yDU0ziKVcPUDRdZIwwAlX8nO0S7mlv1xluLKEomjESUy1PEFldBK318mDKKMAWVEJ3QFRtIEUk1s2ddPOFRPknDialo3vOth27u4SBl4+mQp9Jnfso1If5dSjD+G5/XxVQJLzRCu6iVko56mwkyh3XXAd7FIld+NpN3F6ndWg0QxVN0mcIeV6g1JtlO17byGMfOaPHUIz7FwpQUi5i1GpglKqMuy2MS0b07aJwjzgsVwbIVz1i3eHfQzTpjwyQeA5dJpzeG7uTiSrOrqhYFhFUnJViTRJMOwCvjPAtIp47hDfGTA+s5vAzy3CQpLorizjD3pURsbxnD6qbuQkVFFAyy3jiqKg2aXc7SFLc7eELMMq11BUnel9t2FXR3A6TXqtRXqtBZIoQDeLjO++kWJtFH/YZenkEXrNOdIkRjVMsjjKdYkNkziKCAMXRdHpLM+ThAG+N8yzL5JbaRXdoDq6DatSo3X6CFEYEHgOgZ/74Zcak6iqRhqFVEanGXSWkRWbJIqQTQXNsKhNbGPYXck1h2WFwB0QxyEiifE9J78uci4VmCYJmaKhW8X1lS/NtInDIM8CiUCSc7nFyb235AG5Kwu0Zk+wfPooURqTJmI1XbSKpMhM777hif4ZftojSWIeue/rfO+Ln8Hpdzbt0w2LZ77o1dz6z34aTTcuUMNPFqIwID1P1eeJhyTLqJr+mMoePHiQ+++/n49+9KO84hWvuMY9e3rjqonxxvzXz372s7nrrrt41atehWFc+gHz/dxCOjk5ebXd2BInTpzgv//3/859993HysoK4+PjvPrVr+atb33rk2bGJMlKnso5yX1+o8DHsIo4/TwJQq+Tpzss1UdozZ+mUK4hhMT49t1UGmP4zgBFVRmb2cX2vTdRHZnAsAqMTMxQaYzx4Le/RL/dymXVRK5zG4U+QpIo1UYZdltkmYQQkIQRpbERhIBiuZ678QoJ3bDZecPtzOzbnN1wYmYPEzO5tNLi6ePIikp9dArfc5jZdwuyJLE4exzfczh5+CHK1QaGZaMZ2+m1m4xO7yCOQmRJxrSLNManMQyLbXtvZPHMCc4cfpAkTRmd3kG5PkYSRRTKNRrj02RkOP0udqlGHAbopr3quysIPYfI91BHpyAD3bZXCXKZOPQojUzgDft4/Q5Ov00ShqtpeBVUo4RuWKRxnq5WNW3C1cQHpBmx79KczSdysqIgqyqV8W2EnoOQBEmcolkFzEIZRTOIPAdv2EUSrLsH5C4QGbpdQpLySYk/7OXJTCR1NQmDhW4VKRgWw06TwBsSR2Hur5xmq9q1eZIPVdMxi2UCZ0htfIbRmb14gw5hGOB0V3B7LYaSRDboEmxwKVBUg9r4DP6wl7tySDFB4DE2swvfcwjjfFxWGhMIARPb96DpJu2lOciS3I1l1SdeNy1kSVCo1kmSmMAZ5gFltVEEAkM3cZweqqrjDLooipxrHhfK7Nh/K/tuew7zJx5l8eQRpnbupbU4i2kXmdq5H88ZUihVEELQWpqlNX+GOEpYmj0BQqz7+FrF/N6tLJ6h21rCd4cIpDyZuBBURye45Xkvo1Cu0Vma58ShHzHorCBJCoNOk/rYNsxiMU/TblisLJxm4fQxsgzSLE+OoVsF7EIJhMSY7+V9SUIa49uQjCKkMcNul8zKYDW7XqHSQLNytRCn12bQXs6z8xXKZGmCphsUynUK5TpGocLJh1J6y3NEQYAkaRSqdYQQpHGMrKhksKooIiAFWdOQVv3E65PbmT7wjHzM+B6youIP+yiqhgCcbotiYxJ32MPptzHsIrXJnXSXzhD5HnaljqKZeeCsJNBUg1j2UU09zxgpycRZTojjKMhXdGSN6sQMxdoIcRCgGRat+RPUJ2YwCiVMu0R5dIpCuU7o5/J7kqLk/umSRBB6KLKGahVWg02vu1JcS8yfOMyX/39/Sqe5sGm7qunc9vyX88wXvhrdtH5MvXvy4Wuf/SQPfOufuMqkwNcEQghufd5P88Kf/VdXXLZUKiFJEl/96lc5cOAAhUKBYrF42RnofpJx1cR4dHSUn/u5n+Ouu+5iZmbmispu27aNr33ta4yMjFxtN87DAw88wL/+1/8a13W57bbbuOWWW/jBD37AH/3RH/GlL32JT37ykxSLxWve7pVi4dQRJFlmzy3Pptdurme/C32fHftvwXOGSJJMe3EOWdPYt+c5DHptyrUxzhx5mGGvjarp7LzxmVRHJoB8Scy0iwSeQ7E2gmkXaS3O5r6ZqpaTvCQljnx0q4BhF3IyZpiUylWEJOMNB/RWllBVnW37bmZ0evtFz0MIyINwYqIwoDV/Ct0wMQ2b0C6RpimlSgOrVMXpdShVGsRRSKFUo1Cp4TkDWouzhJ6LZlqMb9tJEgaEoU+5Nsrk9j05STfz4D7DKuC7QzK9CCIXpi9UG2hmYTXjVx7MZNhFdKuErOq5pYyUQrnG2I4D9JbnWDr5KJpp02nOYhhFJvfeTBh4WHYJSdWIw4BBe5mVhZP4g17uo+sPCZwBo9v34g37+XmupTFeldAq1EZJohBfydMwx1GEoqrYlREkOU+C4fW7FKoNPGfA/LEHCT2HJIqRFCVPGJImFKojRL5HEoVoukVGirJKBguVOtXx7XiDPqE/pNSYwK40iEMfs1ilbFiU6+N4gw5Lp48S+i5idbVA0Qym991GfWonneVZdN1i0G0y0hhBrLp3KLKKVSjhDDpU6mN5JkYk7FKVMPAZ9rvIspT7wssyAsHUzv3MHj9E7PsUa3XCYDV4NAyQAw3NstGsPDmHpCg0JmaY2XsTpl3EKlUQSCycOoamm9THp4mjaDXNtk6hXGPPLc8miWPcE4cwrAJxGGDa+XM8PrOX5vzJXPJtOMwDVYWEahhU6qM0JnYwMrGdSmMM0yoy7HcxrALN+dPIikaxVmf7vlsIPI+V5TniKCIKvDyZSJpSqtSxyxVGJrfTay0xtWM/neY83dWg1iAVREFAf2UZTTNJ0pja+DZGtx9AEoJht0mh0lh3ZQjdIXZlBN0+G2ym6SZWoYKzmkEvDBxC32B0+35U3cxTLkcBkqqRrWoLa4aJpOjUx2eYPvAMCuU6w/YSSeivpnKOcLqgmwV6zXkK1RGm9z+TwOmj2yU03SR0h4Sr/vBh4DHsNPEGvdWxoufa3LJMJsnYlQZ2uUpnaRazUCL0A9zuCmkcYRRKBIGLZpiEnkuhUqc2vh3NyIlXHPpEYYBdqtFRZ1FUFc00EZKCbpVwh508ec51XDWyLOMHX/083/r7v16X3IPcGHPLc36KO37qZ7CuBzqehwe+/cUnBSmG/B4+8O0vPiZiPDMzw913383dd9/Npz71KQA+//nPs3v3bgBmZ2d52ctehmXlUqpjY2P8xm/8xrpb6+zsLC9/+cv5wQ9+gGma+L7Pe97zHnq9Hh/96Eef1rK7V02Mv/rVr172sb1ej7m5OW688UYATNPENM2r7cJ5iKKIf//v/z2u6/K7v/u7/NzP/RyQW6j/w3/4D3zpS1/iQx/6EL/1W791zdu+Uszsu5nFM8eRZJmdNz6Dxvj0+os5iWMKldrmbUlMZWQ8T7zgDBjfvofm3CniIDiv7iwDVVaxasX1oBrP6aNbedDS2PROEDA6tYNipU6apSzPnqS7skRr4TRRHKDHJnahtE4+LoRSbQRV01hoL4OA5sIZdM1AUmSELDM6tQNZUykUq0zt2Me2vTcSBwGFSo3qyATd1hKh51JujNFrLRGvqluMb99Dr7WEEBKVxth6e6ZdRDdtqqMDVN0gcPpIiobTbdJtLqBqJoVynfrULjTdJHD6uIMuJDGtuZN4zpDyyCRWuUroe9TGtmGXG6RpgmkXsasjDDu5zrNVLJPGUzS9XHpMVjV0u0gYeFRGJihU88w73aVZVN2gtzyPrChopk1jahfjO28gCX0yBIqm59JsYYBdrVMdn6Ga3y36K0tEgUeWpTQmd9JvLxH7LrIsUx3fRhj4q0F1KbppMbrjAIVy/Zzzb9HxhmhmgdGZvfnStmEhawaCjO7SPEISVMdn2HYgD77wnR5RGFBujLP3tmfh9rsAFKt1Fk8dQzMsKo0xhr0OjfFpxrfvQVFVqqOTq0Gbtdx/eHVMmoUSvu/mQYdJxuT2/egHLELfRTctNMMk8HLf8NLqxA3AtIqMbd9FtqrAMDq5E0kSIFgno+bEDPuf+Tx8z6HXXEJaDcKzSlU008jTZAc+kixAqOi6Tqk2SrkxTn1iet0yppsW1dEJ4iik0hhjx/5bSOKcSBuWDWlKZWSC2ROHSOIYVdWpjOTKKr3WEpppMTq9ne37b8ZzBvjukLmFJdqLp1d9ZhWSIMYq1dctpaqWk86RqZ3Iqo4QgkJ1hEL5bOyFO+iSxCG6mbt4lOqjZGmGJESe+S7JJ16SrBAGLr5dyhPXFCuM7ti/XpdRqKBZxVUtakGcxMShh6TqCLJ1CzWA22+TkVEZncYZ5GmbVd2gUGng9NuMTO3CsIukWU6SA2dAv72EZhVJkhSyBG/Ywxm0KVZGmL7hdkamdyMJgaIZ66QYQNEMVE3H6bUxC2UqI1O4vRUC30FIIGUZjYltl/nreR0XwwPf/Ee+9YX/dXaDENx4xwt49steR7FSv3DBn3Dc+tyXPXksxpLErc992WMq+4lPfIIPfehDvOUtb+GWW27BMAx27Nixvv/QoUPs27ePz372swB87GMf47d+67f48pe/vL5/+/btmKZJs9nk7W9/O/v37+dDH/rQ097qfNXE+IYbbuCOO+7gz//8zy957Jvf/GaWlpb4+te/frXNXhSf+9znmJub4/nPf/46KQYwDIPf+Z3f4aUvfSn/63/9L971rnf92Gc9SRRRbYwzNrVj3X8XoFwfIfDcdQvpudt8d8j8yaM0505h2kUKlfPTqOqmSbFaJwx9ZvbdjF2qcPTB7+G7w9wnNQ5RDQu7XGVs2y66rSUURUVRNALPxS6VGfa6nD7yENv23HhRcuy7Q9xBnySKSLME3bAoVmqIVfWMYbe9ms5XZ3R6+yaSm/fVQttAOgqVGr7vrn+/2FLfxpe8XapSrI6QIbCKlfWX8ujMPpbPHKa7OEsY+riDDnalfp7lLA59FM04a9kqVnEGHRrTO/OAQd/DrjRoTO/a9OIf9lbw3Zx8J1FIbXIH6eoyuVXafG/W2kmzDG/QIUPQmN7N6LY9BL7H/NEHaC+dztU33CGDbossibErI4ztuhHdMDcRjrXz7zbnaS+eQZIEw16edWzjMdtvupPRmc5516Y2vn29P5Ik5ZMV32XYbTM6swtFlpnYsY9ea4nA89AMk0pjHKtU2WTJBwi8XLd2/uQR3EGP6sgEo9PbLzmxWhsDdrHC8pkTZAKGgw6T2/ecNw4qjTEM02ZlcZYsyyhVG2iGiRBSrmjiDAj8XG5w+75b2H3THeimtZmE20Wmdx2gWK6vT0I3jjPNtEjbTUrVEcxCAUXRGJnYRql2/nO5NklrdgboVhFF1QjcIaqRu8MAue/u6nU+lyyuIfTdXErQ93I9cs0gSWIKlUpuIQ596pM7cQYdStURVN3M79kWBNQqVqiMTrESBUiKlitQqDrlkQnMYjV3aVjtyzpZHXRQNR3dKmF0lgl9j0KlTn161yby3lmeo7t0Bl23SFflE6M4RNV00jTJgxnLWxOvtetg2iV0s0BGRqE2ghFViHwHSeQazNdxdRh0V/jG331q/Xu5NsrL/+VbGZ/Z/WPs1VMDL/zZf8VzX3nXU9rHeHFxkXvuuYff/M3f5Od//ue3PObQoUPcfPNZ98hbbrmFT37yk5v2HzhwgEcffZS3v/3tvOENb+Ctb33rRdv9xCc+wRe/+EVUVeX+++9ndHSUP/iDP2D37t2kacr//J//k7/4i7+g0+nwspe9jLvvvnudZF+s7BONqybGWZZd1szKdV2Wl5fp9/uXPPZqsTbj2crhvFqt8pznPIcvf/nLfP3rX+c1r3nN496fi0GSZRQBwTmSOWvuEBfaZtpFbn7Oixl22+tW141Yc02QFRVLN5jcsRchJOrj05h2kaXZEwx7HcSgx9EgwDBtDKuwqj4AiqrRbS+jayaB69BvNy9KbobdNpIkM7ptJ83ZkyAJgsCjWBtBUlQGiyvIsszpww8xNrXzPH/lNR/jjedjWIXzSMilsGYh3Wq7qhpkAjTVIPAd0ijcRKrXjlvDRrJQqk9Qqk9ckNhIQqDbJaxilW5znsDp54FX2vm+9mtll08fpttcIE1iCuU6ozv2Y5eq2OUGiqwiFBWyDLtUJUkTZEUmjUMUrbrlOUahv5oEgtUEJ/557V7o2gC0F08xlwbolk1jfJqRiRmyLKW1OLtOTIUA0pSJHXsvaMkHHtO9WxsD7qBHfWwKb1XveXrXgfPqqo5MnDfmISfXUejTWV7AsAsceOY/2/K4tfZMu7jlJHSNNOea2wFWqbJOrC92PrphUh3fhiyrJEmEbpxdEbvQ9V9DvJqpsDo6RSsMMO0SmmXTmN6Tj4EoWB+PZnHrMbCxrck9NwMZke9h2CXqUzuxihUgv9dRGCCAQnWUQnV0E8FeW4XQ7dJ5JDeNQ9IsozG9i/biKXK/+YAkDNEqo5tcQy7UN82wMIvV9edp7fzTLGPnzl0XLX8dl8Z9X/lcrrhDPkm661ffh7Xq7nUdl8ZjDXh7suDQoUNEUXRR99ZHH32U5z73uQAsLS1x77338vKXv3zT/n6/z5vf/Gbe//7386pXveqS7R45coQHHniAj33sY9x+++28//3v5yMf+Qgf/vCH+fCHP8wPf/hD/uzP/gzbtnn729/OX//1X/OGN7zhkmWfaFwRMT569Ci/8iu/ch4RfvDBB3nJS15ywXJZltHr9QiCYJMp//HC4cOHAdi/f/+W+/fu3cuXv/xlHn300R87MVYUlXJjetUa5142iYALkwPILXeh5zIytX2dwOimRaFcy/14DQt30GN8JnfFGHbbVEcmmN51gJGJGaximRMH78MuV9E0k0vNfQqVGoVyjWGvzcTOfdTHp4jDkLHpnRw9eF++jG7ZhMMBw17nvPIbfYx938WwCpckIVcKuzpCoVLP/ZErdezqhX3bL2ThuxAZUTQD0y4ShQG18W0UqqObrLLnIg59As9BEoIg9Oi15pFVlfLIFLKqMjKzl157aVVizSNLU5I4YdBuEoX+Jr/N9T5rOppVQBYSSZaiXcGP+5qFvFwfpd9ubiK8G0kuQL+7cklL/mO9d6XayKr6w2C9/iupy7SL7H/G866IlF9sEroVab4YFM2gUKkThQGmVtpyYnSxsmtuBkKWKdbH89TQca4nfimL87nQVl0sAiXX9l4bj26/TRQGaLpJc/Y4oedglWubxtS5E8aN0O0SmmHSby+h6ma+gqLvxut3Gdux74LlzuvfOROFtc/nriZdx5Vh0F3h4e+fdXG882WvvU6Kf8Kwa9cuVFXlPe95D7/wC7/A2NgY7Xab73//+7zrXe/iwIEDHDp0iK9//et8+MMfplqt8spXvpJ3vOMd63UcOnSIXq/HK1/5yssixZBzxHe+853ceeedAPzMz/wMH/zgB1leXubP/uzP+Id/+If1mLLXvOY1HDx48JJlfxy4ImK8Z88ebr/9dj73uc9t2h6GIYuLi5csL0kSb3/726+sh48BS0tLAIyNbf0Du3ZjlpeXL1jHX/zFX/BXf/VXl9XesWPHrrCHZ7HRfeBaRgaf65qw9mJfs77V3AFHg+A8V4w1QnDgmc9D0w3cQQ+rWKZcv3iAZHVkYpMF27AKzB4/hOcMKJRrWIVynna2oFMoV88rv0bk13yMr3SScDlYcye4kCXsXFzKwnfusVdCXBTNQDdtBu0mSRBQGJ3KE2GQrVuqTbtIoTqaB1E5A/xhn1J9DGfQIQ7989owi1Xq49sIPAfdtDGL51/ni/VH1XR6K8volr1pLJ5LHLey4F4rbByjj7X+azmhutK6rnQcbFVWUTX84YD24imS1WDOtcnQuW45F8NZC/T0pjGzdq+H3RYCsCsjhIG75ZjaCoXyWRckSdEI3D5RGGBNVSjVt56o/6TjiXqfADz8va+uuwEUyjVuuOOFV1XfdTz1MDMzw0c+8hH++I//mHvvvZckSRgfH+e2225j586dOI7D3Nwc3//+97Gs8595x3E4c+YMn/jEJ3jHO97BS17yEl72skv7Oh85coR77rln/Xur1aJarfLNb36TMAx59atfvb4vSZJ1a/HFyv44cMWuFO9973t5wQteAOSW4Pe9733s2LGDt73tbRcsI4TAtm32799/xcoVjwWel7slXEgybm2767oXrKPZbG6azTxeeLxIxoUIxtqLvkLup3khVwzTLrLrxmdeUd/OtWCvtT+ZpSiaRr+1TKkxysjU+QoXWxH5xwMXs4RdLa6USI/O7MOwi/RaS8iyglEoYharm5aY1+oziy7txVPrS+kXctEYndl3VaRsamJs3Vp/IVxrS/4TXf/jjSsZB1uVtYpV7HKNjIze8jxWsbyasfHyiCtA4CX4vgSo542ZjX6+g06LMHAvOKYuhI3PUeifP16vYzOeqPcJwNzxQySZjSDllue9NNfbvo6fOLz0pS/lpS996Zb7Dh48yPj4+JakGHI3ikqlwh133MEHP/hB3v3ud/OpT32K7dsvrE7VbDbpdrubyOw//dM/8aIXvYher8frX/96/st/+S9XXPbHgSt+YkZGRjYFtL3vfe+jXq9v2vbjhizLucD+JXAx3+iRkRFuuummy2rv2LFj65rMV4rHkwScW7c7DPH9CMNQsQraRV0xrkXf1sp7zgC7WEFkrPs4bnXs42mJfDJCMywaU7u39F0+z03iMi2RV0vKyvUxpDzzyXX8mKBoBkYhf26MQpHQczEKxcsmroGXsDzvEoYgiRGqNQmrdL7bwrl+vlczbi5VNvASwjBB02R0U35M7TyV8US9TwBaLY1e9CogJRXXXgr1Op76OHTo0EWD2g4dOrTuivriF7+YN77xjfzar/0af/mXf4llWbz3ve8FNuexOHLkCLIs83d/93e8/vWv59Of/jQPP/ww99xzDw8//DAf//jHOXbsGLt376bT6fDQQw/xwhe+8JJlfxy46qnkoUOHrkU/rils26bb7RJsIWEGZxOLXGi2BPCGN7xhk5n/YvgX/+JfXJU14FzC+njAHYacPNbC9yIMU2XH7sbj1ta5CDx3U8DWRjeJzed+cSJ+pdfpqfIyvhix2HwOj530XgncYUin7UAmqNatxzxOnohx/WRsew39TojrRFi2Sql6+X3YOAm6kOrExTDsR/R7IeWqTuCDrFtoxtbtX81E6lxc6Hk7S9TzfaOT1pP6eXw88ES+Twbe6OoniR9+b8izXpghcqH567gOIOdte/bsuej+jTFav/7rv84DDzzAf/pP/4nf//3fZ3Fx8bz4rMOHD3PXXXfxuc99jt/5nd/h1ltv5U/+5E8oFArceeed/NIv/RJvfvOb6ff71Ot1/tW/+lfrxPhiZX8ceFqusYyOjtLtdmk2m0xMnG8RXfMtHh0dPW/fE43LJayX+6K/EKnx/Yh+18Mq6PS7Hr4fXXY7V0My3GGI6wJCO89Nwh2GPHpwkeHAp1A02H/T+AXr3+o6GZbytH4ZX+k5BF7CcBBCJiiU1PVjL3aNzt3uOiEP/XCeU8dWANi+u86tt09jFbQrGgfn3q/R8RJBEF0W2d7YDnBFbfp+RJpkLC/2fyyTwDX0OyFHH+niOhGKIrHnhgqN8cvXbH+shDXwEnrtAHcY4Q4jaiMmmvb4j/utxmrgJ7hORJaC40TopoLjRIRh8pR7Fp9KmNkzzSMP5nKFi/Mun/wf3+UZz95GY7RArWGjPgHj4Tqe3Lj77ruvaL8kSXz84x8HII5jlpeXz/MSOHr0KDfffDO//du/vWWdb33rWy8o93apsk80rogYv/GNb0QIwX/9r/+V8fHx9W1XAiHEZWkeXw3279/P4cOHOXLkCLfeeut5+48ePbp+3I8bWxHWte1rZOBKyPOjBxeZO90BBFMzlXWymSYZK02Hk8dXKBYN0uR8N5Kt2gHWtwkh0HSFxbkeSZyyc2+Dat3mzMk2YRDTGC0wMV1Z71tracgjD80T+inFYoWZHUXK9fK6Vbiz4nLs0WWyDJKki2GojIwXkWRxHhHy/YiFM13WtMjGp8o4Q5+jj3SJo5RCSWN6R2H9hRuGOekrlDWGvfCqXsYbCWTgJzSXXOIwo1TRqI0YW9a7Fensd0K6HR9VkS9YbiPOPYfhICQM5fV+rJEuIYHTj+isBHhOhKxI1EZMpnfks+2tyHW/E7I4NyRNwC6o69sXZ3s88tA8w26ALEtkwLYd1U3j4NwxuBWR9ZyI1tIARVNotxxWmg69jkscpTRGCxy4JZ+w9nseqirTXB6wsjikWDEQCMIoRtUUdF0hy7JLEty1sdvvevS7HlkG23c3cJ1gy0mgOww5cayJ2w8Zny6zbefZoLbW0pB+z6NUNmmMnW+xuNR+ANeJ6LZ8kjQjDFKswpBiWbvgPb+S1Y2LHRuGCZ4bo2gSgZtgFfL9g15I4CW4bnTZ4+9KEIYJzjDCMGWcYcTS/JAzJ4ZEQYqqSYAgTVIMSyHbIn/HxnO6jqvDP//559Ne+TZL87k06rFDTY4daq7vL1UM6iMF6iM2tRGb+ohNfaRApWoiydfdqK7j4lAUhc9//vPnbT9y5Aivfe1rH1OdV1P28cAVEeP77rsPIcR6cNvativBE7Gk85KXvITPfvaz/MM//AN33XXXpn2dTofvfOc76LrO8573vMe9L5dCmmT0ux4Lc31sW8UZBJw6tkJ7xUHXFLbvrrPSHHLs0DLlqoWmy5Sr5nlWYXcYcup4i9PH27hOQBjGNJcGNJcG3HDLRJ71zg2Jw5TF+R7HHl3GsrVNJPbQgwusNIdMbKuw0hxSrpqQCVaaQ0plk0cenGdpfsCg5yOE4KH752iMFOm0HcIgplA02HfjGAdumSBNUx5+YIHZU20UWUaSBWmmU+oM0HWPiekK3a7D0sKAKEqIw5gojDEtjVrdptqwN1mQV5aHHHl4iX5/NftblqEbKvOnBmQZNBc9VFUwNmUThgmBlxD4McN+RLGkkaWwcGZIHGaUazq6IW8iF2sv5iyFKEoI/RRNl8myjHbLI03ysTt/xqGz4pJEYFgKMzuL7NxfRkhsqmvu5BDPizBNlakdBQI/4cHvN+l1QlRVMDlTYHy6sG7ZXbP2rrVbKKlkKSRJSqeZX+/FWRdZFggh6HcDXDcm8BMUSTAYhMRhhqZLVOsGw34+GQDOmyAALM46LC96mIZCHKVUGrm02/Jsm/aSi++HyLKMZWuQCXw/wvciag2bdstZJ5sbJ1NCCIIgxhkGeE7IyvKQOMlQFEG9UcBxArptl27HJQhjfDei3/fptob0BwFRmCAJKBQNtu9uEEUJ1ZrN7v2N89o8d/z7fk7Eux2fuTNt0jhjYa7Hrn0j64R9Da2lId/62jGOHWqSpRm1usVLX3MD23bWaC0N+c7XjjHoh6gK7N4/xvSOGpat0Wk7HDvU5OTRFrIsMTJe4Pbn7tiSHDcXXNotnzgCVYV+O9h0P9bGGZkg8GMW5x1IBXZRpTFmbrL4b+r7osfpE31IBZWavj621lw2hv2Q08d7OMMYWcmzJLabAZ4b0Vr2icMUVZWY3lGg2jDorAT5/Rk1ERKQCbIsI47TLV1ALkTKsxRcJ6azEiDIaC5mdFo+uiEz6IUYpoxhKQx7Ed2VfPva6oaqSZw5nt8701SZGB9ecMJxHZeGZWv8329/Ln/9//0hxw83z9vf7/r0uz4njrQ2bZdkQbliYtoalqWu/tcwbRXTOuezrWFaKqomX3fTuA4gNzju2vXYNMivpuzjgSsixu985zsRQmyKHPy1X/u1a96pq8VP//RPMzU1xVe+8hX+4i/+Yt23y/d9fuM3fgPXdXnTm95ErXb50kePF5pLfdJUML29muvU9n2OPbpEt+3heTFHH13CdUJ6HR9FkanUDNotB2fVWliqmJSKOsuLAxbnu/R6PlGYkq3GHi4v9lk402X/TeN0ux7dFZcoTLgvOE3ox+zaP4rrBHz3mydZON0ljhOOHlqmPlLE6YdEScLK8hDfi3AGAZ4XkaYgSVlO5KIuIoU4TujEQx78QcjiQo8syRj0fVw3IklSJKC5PECWJGRZYs/+UeyiRhTFREFu5Zo92UHIEtt3JrhuiGbIDHoB7jBg0PMZ9D3CMCVNEr7/rVOMTZRwhzGel5+sM1imUtMplDSiMMH3E2RJoCiC44+GLMwOSGOBVVSoNQx0Q8YuqJRrOq1Fj6X5Ie2VgDhIVtM3CxRZRtMkaiMG3U7AypLHWmIupx9z/HCHlaaPZStUGwbFskpryWN53iUjJ7aeFxJ4GcuLHmTgeSnx8T6DfoRhKqiqxKAXEIYZgRshq7lFz7RkhoMI341J04woSNEMGd+L8ZyciPpeAhLEq+70UZgQhS5ChmEvQtUkeh2f+VMOqioQCBRVsLLs4vRCeq2AYk2nPhoBEe2VmDRNSGJIk4Rez2f2VJvJbRWEEJw52UbVFDwnwjXC9RUPWZGZP9Vm6IRIArodj4yMXXtHaC0Paa+4LM73iMIkJ6pZBkJAJuisuMQxICDN8hd3c2lAoaiRJDGLcz1KFRPDUGktDfnRfWdYmu0hqzI7dtW55Y5p0iSj23Y5eWyFYNWdwnVCkjSj3rAZmyzT67oMugFL8z2OHFzCGYQoisRC0ONLnz/E+FSZKIo5eayNIgv6g4Bux+fhB+bJEPQ7Du0VlzTJJ0W+HzG9o7aJxAVewuzJPicO99fHSRRBpxVw6kgfIQk8N6LXCgmjGCFJBF5MFKYIKZ981UZ0ZnaWaYybOMMQb5hg2rnl/OH7V+i1A1Q9HxsZKc1FjzjKJyDDQUSvnSd2iMOUU8cdzAUXWZEZ9mMkCSQZTp0YcPrEAM9JyEgxTAVNU0jTlDTJMC0Fu6iyc18Z3ZTXifzs8SGeF2OaCqOT1vokTkig6RKeG7Gy5JOREUcpvpcgpPw58N2EOEl48AcRJ4/2Cf2YJMnXgIZORBpnpCm4/R/y5n93XWLsamBaGm98650cfniZB++bpbk4oN1y8xTeF0CaZHRWXDorF1ZrOheyIq2T6Jww58R5nVxv/LxKtA1LzVO9X8fTCldqJL1WZR8PiOzJkBD8ccD3vvc93vKWt+D7PjfddBPT09P88Ic/ZHl5mZtvvnk9+8q1wFqwxE033cT//t//+4rK/sX/8x16HZ9CUWdiukwYxDz6UE6GM1IEAiEk0iwlI0ORJVRdRUKAyAlplmV4Trxl/ZomoVsq+28aY2G2x0rTIcsyFEXGMFUMQ6Hb8XAG4aZypiUTx2nOXyRBFFxa5QMAAaomkSUpCEEcZwjAMBU8L0YSkKYgK1CqWLhDj8DfPARlGXRDRVIkfDckTTMUOScYG0erpEC6xWkLGRQZdF1BVgW6nlunPCclW/09tkyJQkUnSzI0Q9Bp+bjDrR8FWVk9pyzlnASF6zAsCSHyQKkoTtmYdE4IQIYsBknKz1+S82sc+AlpBlmSb0uznChIMui6RJYKPC8hA0TGJROtrN0DuyBjFVR8P8YdxKwmwUI38jrCCEjzYzUNdFMljVIykZObLANW27JLOo2GSa1RJAhC+l0fq6AzOlaiXDX40ffPMOgHyEIgFAlVk0mihDhK0S2FLM3wvZh+N78oWQaqLpBlCd89P+2qkMAuGlSqBqWSTqliMbmtTBSlHH90mbkzXTw/RlUkRsaK3PSMKVrLA+ZOdeh1fPoDH9L8WgsBhbKBXdRJogQQ+F5IvxesTx7Pa1/kfcjdTDRcLyTbIjusYUhMba9RrlrIsqDX65LEKe1WQKe1+XmS5Lw/WZZf1q3G7fqxEpgFCVWXCN2EMM4QGSBBtGFcSQoUSypRmAIZrpOu37NLQUj5M4IMUUBebjVjIoCug5AFIxMW5apOvxMSBgmdZoCQyd0ibBVdk6k2DEoVleOP9mk3tw54viII+MB//Zmrr+cpiqt5n1wMaZrR63isNIe0m7l700rTod0a0u14lz12rhqC3FXuXBJt55boQlHHLuqUqyaN0QLydfeO63iCcc2IcZZlfPOb3+T5z3/+pu2f/vSngTzLiaY9sQEwhw8f5g//8A/57ne/i+u6TE9P8+pXv5p/82/+zTWNdryaH7I/+M//iO+GxFGGpsskydoS64XLSFJOVoXIcquUDFwirfvIqI1QBMOeT5ZlOSG7TK77WCEEIFaJkJIT258IbCAYTzcoKsTRKtFTBDIQhtk6YZdkIANJlpBlcgaWZYRBcnmkfgMkOb+QkgSCfHKYbEEoZRmSNL/sSHn7W5FeWREYpppPOq/B2JdVSM4Z00LKn8+t+vlUhapDkgBZPlmQ5Pw/AKuTCEW6ts/3Bz50nRhfa2J8McRRQrvl0O/5eG6E54S4bojnRHhurq7iueH65zB4YgZ4oajzr9/5POoj111rruOJwzVRpXjkkUd45zvfyeLiIl/72teo188mUPjbv/1bvvGNb/CHf/iHfPSjH+WGG264Fk1eFvbt28dHPvKRJ6y9x4J+56yFxfcuwW5XkabkpsU1XEax5nIepayqAkT2uJNiYJPVMX4aEYVL4mlKioF194A0yZdez72ta4QpTdPVYx/7QFsLEM3rvHA9q0m+8st+kWchibPzVkauBueSYsgJ+UVWq5+SiM4xAqcbr/Hqakd0eT9d1/EkhaLKjE6UGJ0obbk/SzPCMCbw8z/XCem2XTptl+6KS6ft0W27DHqPXX95KwwHAfd96zSveO2N17Te67iOi+GqifGpU6d44xvfiOu6lEqldY26Ndx6660cOXKE2dlZ3vzmN/OZz3xmPSXzdTzxiKIfD2t7ujnsbLKaXcdPHBTlyT3ZE1Lex+jazQOeMFxXpnj8kKW57/1gkMdueG60+hfie2c/e26E7+YBt0EQEwTxj2XCL0mCvTf8+GVVn6oYDofce++9fOELX2BhYQHDMNi5cyfvfe97eeYzn/nj7t6TFldNjP/4j/8Y13V5+ctfzgc/+EFMc7NW57/9t/+Wt73tbbz73e/mH/7hH7j33nt53/ved7XNPm1wrQnWWn1C2no5+WIwTIkoSUm2epkKUGSBbqnouky/ezYI7WohK1CuWGRphqxItFat21tBkvLf503nJq1awrPsmhABzcjdVATgb+FTrGhQLmt02uGTihyrKiBWl7Qv4yV2oTGiqAJNk5FkCdd5/M9RksHQVTIy0jR383kiIAQYpkwUpsTxpS+YquZyhbIi0e9eni+tEJc3KRRi1QXjGpy6qkOhqBEnGXESnfWPlkC+HDePa+QKtOVv24a6ZTXfv3Z9ZAUKRZXnvODCiQeu4/Ix6PsceXiZ+TNdmktDum0XZxCQpk8OK4WiSui6gm4o6IaKtvZZVyiWDWoNix17GtQa1yYW6CcNWZbxy7/8yxw5coRf/MVfZOfOnfT7fR566KFrFl/1dMVVE+Nvf/vb2LbNPffccx4pXoOu6/zn//yf+epXv8qXv/zl68R4A6a3V2kurkqWbbDmaoaEYajIah7IFIUxcZytBtqcD8OUGRkrYtkaQydARsJ1c1mrS70ILVuhPlpE1xWGA58wTOh3PQxDZTjM5cVUVaExXuDWZ04jSRIHfzRPe2XIoJczxyTJX+6XIlGynC/bGZaGLKBQMjhwyzjFssnJoy1Wmg5+EJPGKa4b5RJSgCJLaJqKYcrYBZ1O2yWJE1JSRsYMCiUddxjS70UEXkQQ5FFOG89dXh3tF7sehaKCYclYBQUhRB7xHyaEYU4kVU2wbUcRRO764joX9p2VVSiWVSoVDVWX6bYC2u1g0xK8kME0JRRVRpHzwL04Tgnc3Gk2TXLLHyLnE0mUl5El0AyZ0E9WfXoF5ZpOkqZ4w3hV9k0gyRK6IZOkOdF33QhVllE0gaxIuMMYTZeIwhTTUiBTMAyFTIChK+imSmtpQJJkhGGC74VbXz+xSgIvNBkTebBXfTT3Fez1AmQEhq1SLOropkISZ/R6LsNugOfHOYlb9R0Wq77DsiJI0/x7HGab6hfi7BjUdBlJyjN+hUGyJeEcmywiKzKDXp5hLolTNE3GXpWlSjNBr5NP0gxTQ9NlShVzVU/7LDEWEpimguvHZ105BFiWQNVlBr14fbJqFSSyRCCUPDi0WFLRDYVu20fVcmkz34ny4EhA0wWyJEiyXGkmy3JXKsPIL0iaZEiyhGkpRFEu11eu6kxtL+B5Mc05l143IPASVF1CVmQCNyYMEuIkH8+aJpEmGYap4PsJaZKSZNnZoLwrQLWhUapodNsBcZTiugmKkp9DbVSnMWqRphmeG5PEGXGSUS5r9HsB1YbO9I4Sz3rOhVPVXsfl4Wv/dIT/8/eHHxcSLCsShnGW0K6RWd1UNxDdDftW/4xV8muYSj7BfBIH1UVhclEFjycKsiw95oQsBw8e5P777+ejH/0or3jFK65xz57euGpivLy8zP79+y8ZzFYqldi5c+d6co3ryLF7/wi79o2g6yqPPLBAe2WILAvKZYvdN4xywy0T9Lq5DNWg49HreqRpRr/nrT+8lZrNjbdMcMNtk7lecJIRBLnM14ljLZbme/Q7HrIqY+gqruPT6fqoUm4BfsazZ9bbmT/TY9j3OXNihThOkVUp1xadqlCumuzY28Awcutee8UhDhMUVaa74uI6AZ22S+AnxHGMkCV0TSEIIsIwl2xTNJmR0QLPePYMY5PlTVnQxiZKnDnZ5vijy7RWHCRZULB1RsaLeH5I5KdU6iY33jbJ4nwfZxDgBwOmdxbXdYnbyx4nj/SJwgxJFiRRgufmkUOlqk6xomEYCu4wYtCLyLKU4SBEkiUKBZXaiIlpK9RGDKIoQVEl+t08uYZpqlQbOjv3lVlZ9um3A5IkIY7XlDZy/23DkCmVDcpVnR37SutasK1Fj4d/tEK/HZJlGZWaweSMjVVQcZ2YKEqQhEA3JE4fH+C5MZqu0Bg1CMMUdxDSbvmQgWkrTO8ssjjv4fRDdF1mekeBYlmjteTjexEj4xb9brAq/aayvOCysuRRquoszbuUa1ouAafJGJbKngNlCnaVXjdXdfD8AFVT8P2Yat0iTVICP6a1Kt/nOiGSJNB1hb03jlGv2yRJytyZHksLfSRJEAYxiiajqjJTMxXueO52JFnQbXtIQlAo6XmQXSZI05STx1ZYWRowGAYUCzqmrRFFCQKJUllHM1SOHlpG1ST6PQ/dUKlWLWRVZnm+TxDGCKBWtygUTaZ3Vhj0Ak4fX6Hbdun3A4TImNxW5QUv3cOJoy2OHlomjlPKFZObnzHJzr25q5fv5xKF87M9Ai/EMFU0TWE4CAijhGHPxzBVnv38HezY0+Ar//Ag3XZIFCSUawaVUR3Vkuks5AlhshSKZQ2rqFKuaOtSZwCzJ4f4XszkTAFFgdlTQ/qdkCTJya5hKfirZNK0FLbtLGIVVDRdRtXyJC+Bl5ynP1ypGizOOVi2QmfFJ1udRLWXAwolmW07SwgJ2s0AWRYkcUa34zPshSgVmTRJsUsKWSah6RLOMCbyI9JVgp4kKXGUIoTAKmgcuLVCuWowf8Zh0A3wvBhNlVB0mZEZm3rDoGAq67rd3ZUQyKjU9adkdsonI4492uTzf3eIDLDYWhZN1WTsQi6xZloqhqme8zn/bphnCa5hqGiGjKI8ve/R33/6IN/9+oknhfufEHDnC3byytffdMVlS6USkiTx1a9+lQMHDlAoFCgWi6iqeunCP+G4amJcqVTodDqXdazruhe0Kv+k4qZnTK1neZvcVubooWWSJKNU1tm1b5TGWIHGWIGJqcp6ultJFqwsD+m0XRRZOo9gbsTEdHlTOcPIo/J/9IMzeMOIxlhhPeXvxnb2HBjFdUJkWeA4EVmarmvJWgWN/TeNn5edr9N2OH6oyelTbdIkY3K6wvh0mWE/IAxWU8HqedKSjZnG1rB2rtt21Fhe7OfksZov+Zw5uYJV0HGHAfXRAlMzVVw3YGFhdv1lqpsyziBCMxTGpnU6rYDRyWKeeSsFu6htSqixPO/irOqnVhsGdlHdlKgDVuW6nLPXb410FMsapaqKN8zl8rqdgChIMG2Nqe02uimflwShMW7yDH10y+x35yZOqDbM9aQNpapG4CV0VnyWZl10QyKOM6Z3FpnaXjyvvvqoydzJIa2l3JofBhmjEzkR872EwSqRNnSF+piJLAtKFY2xEZgeU4hFA6HlGQ2XF/uUygbjk2VmT3U4cMsE3RWHctXCHQYMhyETUyVuvn16/TzPnGjz3a+fYHmpjySpVGsW23fXOXDLxLrm79TMWS30jaiPFM4br8CmzHqaLjMc+Oy9YYxtO2qbxvVaJj27qG/KnnjTjWVWFttEqYpVqaw/L/WRAlMzFUI/YWS8uEmT2Cpo1Br2ep/W2lhezDOKNRo2tz17GzffPk2aptz4zMZ6NsJEwMJym4HjkRU0to3XqBe188bXGqZ3FDbd//HpAu2Wt65hbBdVnGG4nqDm3MQbAMXy+dezUFIpDTXCMKFSNcjIVW+27VQZn7bX66k1zE3ZHWdP5pPLYkmjMW7SW01QMj4lY9oKcZyiKBKtZZ/lBRcyGJ20GJ3Ix/7aRDVLwQsTji05HGl6LA5DbtpRomAq6KZJoahddsa/67g8fPPvv8I/L32BZlriu+6LecFzdjM2WaI+YlMsGRTLOpquXE/McQF89xsnnxSkGPIVou9+4+RjIsYzMzPcfffd3H333XzqU58C4POf/zy7d+crMrOzs7zsZS/DsizSNGVsbIzf+I3f4MUvfvH6/pe//OX84Ac/wDRNfN/nPe95D71ej49+9KOUSpsDNcMw5Dd/8zf51re+Rb/fZ8+ePfzH//gfn5K+zFdNjPfu3cu3v/1tvv3tb/Pc5z73gsfdf//9nDp1imc961lX2+TTChv9p7btrG16CW8kulZB2/T9Yn5XvWGA40fYhkq5oK+Xm10acHq+S6Ns8rwX7r5oOxvr35jyd+3Yc/uz9r1as9l1YGRTVrIrxRpB3th+r+vie9Emcm5YCu3u5pepZavohkynFaAbMiNj1pYkQjfz9MiXeimXqtoFy09s25zY4XJe8Berb2O5c4/TTZlq3SAKUsIwwS6eJd7n1qebMuWajufFlKs6gR8ThgmlqsaeGyrr5G0tcYOQQMPH6J9CkjuYZoGosYfyRAGrbOD2fAI/wrZV3GFAY6x4wfTMvWGAXNS46Y5ptIeXcN2Qet3eRIovhnPH1cbtazh3UrbxmLU2esOArh8SkVGQAkTrMLV4iGQUMEdqyJa2/pw0psqUC/pl9ckqaNz+3B1bpoTeeM9Wmh20/im0wKMdyCxpEiMj4xTMrX9yz73/546vtfovB0Mvpj2IyLKMeknbNM6BLcfpxvZ1U2a3Ud103LmZItdQLGuMjBuQiU3Z+jbW1132mOuG6KpEZxgxUTfXr8O5530dV4+J/reZVLpM0uW4tsxPv+5n0dXr1/hycefzdzx5LMaS4M7n73hMZT/xiU/woQ99iLe85S3ccsstGIbBjh1n6zp06BD79u3js5/9LAAf+9jH+K3f+i2+/OUvr+/fvn07pmnSbDZ5+9vfzv79+/nQhz60pdU5jmOmpqb45Cc/yfj4OH/3d3/Hr/7qr/KlL33pKefTfNXE+PWvfz3f+ta3eNe73sUHP/hBXvCCF5x3zHe+8x3e/e53I4Tgda973dU2+bTGhYjB5aI3DHjwWAvHixACto+XGK/bDJyQL3z7JH0noGTrvOq5O5geKz6mPs0uDWj1PBplk6KtcWwuT7iwfbzE9Fhx07G9YcBS2yHLYLyePxwbSftaXYYqUyrq69vPbX/H7gYHHzrB8dl5un6fm27aSdE6/+HcSP62Smm7EY/lpTz0YuZaPt1hSNnWmB4xVq1fj88LfujF+GGKoeX+eHJRoZApqJrEIExy4rcF2VqzFAZ+jKbJ66RoI3kbejHBat16EpJFHkp1H3NHj/HAoYTYbjA9VmTPjiqaLNEfBHhRTLVsXpAUr429YBiw2POJFIGz4rDXj1DPmbCdW/ZC+87FhZ6RtTr6g7wfXhAz3rB51pRA8YeotQmi9gKp7zBMdb7ygzM0Ox4jVZOX3L7tku2u4dyJ21YwRUjiuRwbmExoQyLfxQ9TClssmG28xxcizgAEDu5giJdp6IXilscOvZiDJ/scX/SI44yZMZM79pYpljdPsi6Gjf3ZiuhuRL49Pymn18PtumiWhV0+a74+Vyp/K+n8c8f5dTx2lIx03QXeGw54w298nv3bq9yyu8Ge6TLbxoqM1W3k69nntsQrX38TL33Ngae0j/Hi4iL33HMPv/mbv8nP//zPb3nMoUOHuPnmm9e/33LLLXzyk5/ctP/AgQM8+uijvP3tb+cNb3gDb33rWy/YpmVZmzIh//N//s+55557OHHixHo7n/jEJ/jiF7+Iqqrcf//9jI6O8gd/8Afs3r2bOI750Ic+xKc+9Smq1SpvfvOb+dM//VP+/u///orP/2px1cT4da97HZ/5zGf4xje+wa/8yq8wMTHB/v37sSwLx3E4cuQI8/PzZFnGnXfeyV133XUt+v20wrmkoNNs4vT72KUSklnC8SMWlod0nYCpRoEDO+sXrGPghPTnT2PGAx5eSjm9OMX28SKWobKwMqRoaJyY73Jqsc9EMSP1HSTDRrZKW/YFWO9Pppg0fZmv/mCOoR9RMBRsXeWR0ysEYcLUSJF/8ZI96/2bXRrwrQfnOdMcoisy28YKmLpCmoFtqjS0iC998zAn2xFeZnBgR43p8SIHttfOI9ELZxb43je+RjgckCgmCy2Hl73oRpY6ASeX8qXcHeMWtiETSlCo531v9UIMTcLxExY7AboiMT1iAGwiI+e+mLfal6QZ3zjY5vCZIWGSUS+q3LyzxB17y5es41xciAwtdQJ6TkzZzrcdnnPywChN0HMTvCDB1PMfyrXPMyMGfpjQd/O8yqMVnekR46IW8aVOsF53paCwp6EiZxqPPPgw959wOehIWBUIwoRdU2VkQ2F2rovjRax4EaatnUckHT/C8SLKts43Di+ztNTDkGUySfDgyRW8o8u4fsxkw+bOmyYYOCGnFvukWcbx2S4nFvposswLnjHJnpnqZZHkjeP/wWMtZpcGHD7dodP3qZYMWn2fHdUGk0aBqL2AZBSQDJtjZ7p87+ElhICjs10sQ+XOG8c3tbfVs7BxUnixiWXTk5nvCYTX5rSrEUkw5cU0ymcnJWsTrJ6bIAkomgo37dia8BI4+LNHWFrs4kUZaXGUnXumNxFQyMfc/ErIUifE92NW+gG6ItgzVSBJM7rDCD9MGK/lz8DaWLMNeX2ML7Z9vDDF1CR2T9qb+nOhcev0erQOHyIJPVJZJxvZxUqgEiW51bpsq7T7IbWSRr20eVIz9GKOzTt0nTwz5uj44LIn7ddxPiamRoiOnwagKg+Jw5SDx1c4eHxl/RhVkZgaKVAvG9imim2qFEwV21ApWPl321jdbp39rDyJA+auJVRNRuWpa2U/dOgQURQxMzNzwWMeffTR9VX+paUl7r33Xl7+8pdv2t/v93nzm9/M+9//fl71qlddUR9OnjxJr9dj+/bt69uOHDnCAw88wMc+9jFuv/123v/+9/ORj3yED3/4w3zwgx/k9OnT/OM//iO+7/Mv/+W/5LbbbrvCM782uCYJPj760Y/yu7/7u3zqU59ifn6e+fn5TfslSeK1r30tH/jAB5Ckn4wH63IxuzTgyz84Q9KeZ5sds2fXGLMnTzPodgGBVJvheF/h+8cdJElirG7xxlccYGKkgLPqi+kGEYdOtukMAwbzp5hqfhspdRjBZEW8gMPhOFOjBXrNFRaGfYJM57v3JUy7KVUjwUfnSDzKI3MhjhcxVreZHivSKBkcOz5L98gDpIHDIJY5lU5ypgfVkoEXxMiSWO9Hq+fRdXx++lnbqZcMvv7dR1leXiGRDMqNOrPLGQVLY9tYiU6zxcr8Izin5rESmTPBOPdHCScW+8wtD5gaLSIywVLHQRICadjE7ffpUKLs9zh5ZokHj47ymW8tstT2EUDB0pClDF2VqZc1kiTFj1IKhkJnGLLciVAVwf5tBUbKGhlgahLjNYPFtk/XiXG8GNdPcMNcemGiZqKpEroqcWbZ5YHjfbwwl9ZSZUGzG3BswUVXBD0nxo9SojjFD1P8MEGRBQe2FakW1XVSUrJVzix7dIYRli6zbZ2oJzxwckC3HyFLgpGqTpykFE2Fo/MBrV6Erkr4UYJAoMgCJ4i5/4hgGCZEEaiKoFHSuG13ed1SeGLRZe6oj23KTNYNgijlwRN95ls+JVshiDUMzWR2qcJS2+VEUzBMM+i3CeOEW/Y0sE0Vx4uYbBQ4NtflxHyPnZO5C8IagUyTDD+M+dGRJu1BwCDLKJR0+l7II2c6zC0PAThyWsHxYx4+3mK2OcQPYjRnmSIOZxKbh0+u8JybJ3jm/lEaJQM/SjYR0dmlAY+cXMELEqZHC+yeruD4EbNLA46c6XLsTBdW0y8rsiDTi5gjN9Frd/Ayje5A8INDyyw0hxRtjZ4T8NUfzHJqrs/+nVVcP6Y/DHBX3TUMTaZWMuj0fX54aJmVvo+mybzizu085+aJ88j70Iv54kMOs50ahigQCA1jKHHfkS5H53KVi1Y3YKkbECUZcZzRqOjrumUbyfFSJ2CxE1CMu6jtPkdXMibDMzjNJU62zzB2w80MlBqtXkijrOEFCY/O9mn2cnkMeQhf/VGbU8sey22fYZChaxKNkkJBCtGDDkoaUDRUUtVgPjDxhcVISeOkm4/X3ZM5qQ6ilEfPDHGDhGpB4fa9lfV+djsDBu0VhqmON1zk8AmNucBGkSWKloxtKPhBwkovn5zuGDcxNBlZErR6IQdPDVjp5+0F2VHe8X899fwSnywobNtH5/h9ADxHP84/eLeShz6fRRSnnFzoc3Khf0V1G5p8lkRv+CtcilybKpahIl23Uj8h2LVrF6qq8p73vIdf+IVfYGxsjHa7zfe//33e9a53ceDAAQ4dOsTXv/51PvzhD1OtVnnlK1/JO97xjvU6Dh06RK/X45WvfOUVk2Lf93n3u9/N2972NorFs5Pco0eP8s53vpM777wTgJ/5mZ/hgx/8IEtLS/z1X/81X/jCF6hW8/iT2267jb17916Dq3HluCbE2LIs7r77bn7913+dr3zlK5w+fZput4tpmuzYsYMXvvCFbNu27Vo09bTDZ/7PUY4depTb5UO4UsDpWYvlxGYpqTLmHcNdWKQb2LiDBplRwJuL+MK3TzI5UsD1I04t9OkOQnqOT5rCLu9hbtLn8dCo06e5cJAVT8bIXLZl86TKkH6ksnTa4Tt+gCiN0Z49xI/6VebDfABXbJ1GzSBOM8LOArviWZxMxxIBy5HBIC0x8HKSoym5VNtqkjKOnOqysOxQ1SMawWmKiY+bapwaBBSqVaIk5TsPLjBtetTcZdqhyrjUpSrZzLYNugOPIIyZm11CTTxWfJlOoFDWImbSjPF0gU5qcmrW4VjvEIsrLvGqjFXbOZt1Scy6CEDTBLKUZ/pLs7yvA7fDSEVn/0yRxbbPqWWf7iBg6KXMtT38DVrIB0862KbEznGLE4suIvKpSyFeptHqG0hiyEI7JMvyyHxNlej0Q7wgAZG3t7jQQU19mr7AzUwsXUKRJHRVpjXwUSQJWZZJkpTUc7DlECfRGHRgvJRxZF6hE6mEMeiaQI489CxkkGkMMoPehvEUxxkrIuTw7JBqQWXoxfyfH60wcGNkBeolHV0RLHX9XEMWqJc0lhZaiM4CJAFyXCVMdSDj1EKP//2Vo4zXLXRN5vDpDu2ex0PHWhQMlT0jCr12BydTMYplhl6M40U0SgauH9FyPIQkcXq+R7OfSwEqsqDVDxg6IXGSYoVtnqs/Qkly6acWX/Vu4P7DMp2+z9DL0zdPjhZ40W1TtAc+3z24yLG5Lq4fUy0a/NTt27h1b4Njcz0ePrmCH8QkCXh+RJplHDrZZrljcGJ+SBAknFw4xon5LgMvYbnrIwvwgphHT7X56v1nCJKELMmTC4zVLAZurl4ycELWMuFKQKfvc+R0l23jRTRVMOj2GK8ZHDo94Ni8i58Y9MgnPUU/4kdHe4TR2aSVsgKqBH4EjheTAiv9gIdPD7hhW5GSrfDNg23m2z5m5rNH8bGjDi4BLgI9PMPBfsTBdBftQCVJU6Ikw9swfpMMmv2IYRjh+Ln0nWUI5MilwUlmpEXsaAA96FJAhGMcjbbxYGagq3Bq2eOR0zkZjuKU9iDGUGVkKWN+xWeybrJt1OTU6QHGygpq4hFkBp0gwkkzDDVB9BwYhripRjs0OLG0jG0KTEXGNBQ6Q5/BBr3wr9w3d50YXwWKt76Eztf+CtKEmjTk//M6ix9FOzl0ssOZpQGLq65tjwV+mOCHCSuPIcOdEGDpyipR1ijaKgVLo2hpFC110/9yQadWMqiWDFTlujHtSjEzM8NHPvIR/viP/5h7772XJEkYHx/ntttuY+fOnTiOw9zcHN///vexLOu88o7jcObMGT7xiU/wjne8g5e85CW87GUvu6y2oyji3/27f8fMzAzvfOc7N+07cuQI99xzz/r3VqtFtVrlW9/6FjfccMOm5G/dbvepTYzXMDIyckF/luvYGt87tEzD7SCpQw4ndXYGLVppQpo5OFnMI7FJQbjohLTc/K1834+O8qgcEUkGLV9dT0FrC58xrUNBeJSFSwZUggWWF1TO9GuMRl06sUqZIW3f5MiZHgWxSC8zaUfqOrldGQasDHMntREppqw7TIkVhpmBOEfYNNxC03bgRxhhH00JaKUl6qKPlHqcWpBQUh+LkKNk7FBCblGWkEVCkCm00yJOZNBcbFHTFrGVmDRSaEbjdDyYUjNS8pe746cse+4Fr+taNmp/Vet2Y86CgZ/hLPqcbvooq5bF4ALaxnEKPSfl/mNDbOGzW1nEEiFupnEsHme5ZyD1vLOJHMTmbN228DH7eRkl01hIqmShoJ9pZKqBG0Ke7jjdVH+iCAwi9EGMkZl0o23EmYEeeOw4pw+Q+7R6mYaTGQy9jCOzLmeaLoHP2bTNCbjN8xNTiJU+29Xj3KzOIispi1KFrwY30EzLeGHGwWMtHj0p0DWZMEry7IkiP7eevoyZhYSyzolkAnQbXZU5E6ZIEvhhTBjHeBuajZKMuWUHOe8Su9QO41KXAQbjUpdxucODnTLNjk8GGJrg1GKXHz26RJIJXD9cn+T4gcPffuM43zu0yMCLkER+OTPACzNOLAz4088fRJUkZEnC0mXag4B4g/tgkoGzmo7dO0cn/Pj8YMtxkQLdgc9Xf3iaJM3IBOiqwFBkXD/Gj1fv/ep9GbjG+XXEsCZp7a3epGY/odl3OHjSQVXOPl89NAZihJpkcJMSM6F0aSYlhoOQXjSkk5awhU9DGoBM/ixlxnpf1+aMGeD4GXbooKldhBKgExILmSgRFISHKUKczMCLwOtGdAbRppTPQz+/Rsu9AaoyoGBI1CWXbbFFL6kyJrpsl5uYIiBLBfvkeWxCOtj8QOxaH6OZGJI5IWmmAWevjxc+ibLmPAWhlBoUbvhnDA9+DQD76Jf4v/7N766rUARRwtzykLnlIX0nYOhHDN3cDWrNHWrorX5f/bsWcshZBo4f4/gxy50tMiddAON1i//Xz9zE82+dvPpO/AThpS99KS996Uu33Hfw4EHGx8e3JMWQu1FUKhXuuOMOPvjBD/Lud7+bT33qU5vcIrZCmqa85z3vQQjB7/3e721SPmk2m3S73XWLMMA//dM/8aIXvYhut0uj0Vjf3m63efDBB9m3b9+VnPI1wzUlxtdx5Wj1fIRkM1QMJuUVVmKTB8IpMgQTcpeC8HEzDS/L/fJs4TPDIpXUIUklUiZpkvsZmiLEEDFBJmMTIoRAyjIKmUN7oGCqferCp58ZxGmDdNWF6mKLWxmCbmLRokRZDDFEuN4PU4QIMjLEOilbIxyDVGOASlX0cVKNTigzKi1zozZHnEksp2UyMizJx8lMxuUetWSAkxiYIkTLQhaDEjWpj7nappqFdLIC9oaX9+Vi4+/6OmFJNZzk8uswRYglQlppicZqv5zMIAVsfMxVS7Kz+pK3hc+k3KYiucwnNSalFUqKR4yck9ponI2EYGP9++R5avKQfmZSxWExqaxfm4pwcDKTinCoSQOqkrM1UQ40Yi59fqYIqUkOGTDAoCS5jMuds/c1zVcP/GjD7CEDVQqxkiFOpmOnA9KoTMvLf1IkQFMFwUVSkK/RnyDLgyhLuGRI69/XSq5Nbrzw/FSLSQadYUhneHZcVkSIh7Y+PuIY4tXJx9C/dnmcwxjCDSNLjT0yEUKmYQvYrSxSEQ4JEofjSZrpFnpqF0DGWVK8kWC30yLDzCDKFArCZzkr42UatvC5UT3DDrlFBiwlZU4mI5sI8sZ6MjJKkseo1Ml/M1IVTcT0M3P9t2YN0QV46lof28OUQEiYisWo6DGhdBijh0SKk+hMK23cTGdC7rCUljkcT205ybyS5/k6Lo7yc167ToyDhaP4px7C3HELALoqs2uqzK6pyxuPWZbhBfF5ZHnoRbR6Hsttj+W2y1LHZbntklzjpCKLKy4f+18/uk6MryEOHTq0Ltt2of379+8H4MUvfjFvfOMb+bVf+zX+8i//EsuyeO973wvA7/7u724q94EPfIBms8nHP/5xFGUzvTxy5AiyLPN3f/d3vP71r+fTn/40Dz/8MPfccw/33Xcf/+N//A+WlpZQVZX3ve99JElySSL+eOGKiPHaTODd7373Ort/z3vec0UNrs0kruMsmmmZ+8PtjEp9ltMSp5M8N7yfaVQkh25qr7801oiRKUXUpUGezSzScTIDS/iMyD2KUoAmYgJUtikrtKMCJ+IRWsLGy2oUpABdxEhknExG10neWv1rJBfAyzQ8tPUX7oTcRZAxI69QEi5VyWGIwUJS5WC0bb2ckxkci8fX67NEwAv0Q0zJbfqphR37pEiUcSlLHr1MxxQhDalPXepTkRwKwmM5La+Xr8gu06KdW64vI4XvVriaF7KXabiZRkPq42YagoyG1EeQMSF3NtVpiYD9yjyGCLGk/NommYQsMlrJZmK9Vf0eCoIMkxBJnD1XS/hMyF00qUUvtTDTzWR9K6J8qfPLCZfNpNyhiE8rLVIRLrZy8ToEGRXJYXrDasJG8qVkUJA2j6eN92HtuE5aoJUWqEgu3dSik15a1m0rXOzebmzv8SBg57bdSW0qwqEke4xIfXQR8Z1w3xW3fW69fqZSk4Z0EgtZpCwkFZzMoCH1KQuPAAWVmO1KC1OOWYyd9cnSuf3rZxZnkhFkEsJU5WAyzfGLjJeLXcO1572oeqikdDODCblLmCoYUoSXaphZSEnKV3nWJoHDLF8l6Ej2+iT1aZ4/4gmBPrELY/vN+KceAqD19/+DyX/9O8jGZtmsKE4YujnJHbghQy9i6IYbLMjxJkvy+v/VfU9Ueult14MxrykOHTrEnj0XTr2+kRgD/Pqv/zoPPPAA/+k//Sd+//d/n8XFRV7zmtdsKjM3N8enPvUpdF3fJN1777338qxnPYvDhw9z11138bnPfY7f+Z3f4dZbb+VP/uRPKBQKvOhFL+KFL3whr3rVq5ienuZnf/ZnaTab55HrJwpX1OpnPvMZhBD86q/+6joxXtu2lQTPRqwdc50Yb4YsgZH5VCQXRaRUJJeVNF/3XCNbpghxs5z8eplGgsSo1GOQGRir+53MQBcxESrtpMiI3EMSKToRKjGWCLBEgEbEclKmm9rrRDRBrBIqF0G2iVQ4mUEvtQhkhfmkxog8ZK/WpJr1UERCQfJZSYtYIsxf0hsssBvJ/A55mRHRRyFlWm6jEdJJbCwpwBIhFjq7lSVm0hbb1SYpEmGmsJzmahkZAjfV6GOikGCs9n3NYr3Rcr3W5rkv8HMtuFuR0zUoq2b0ONtMCBaSKqOKQywpTJDfH5kEWWTrddakATNyixmlRSst4qYandQiyFQqkrt+zU0RYAt/y8mEJXyqkktNGuBm+upkZJlnaccpSS691EJafeY2knVgS6v2xeBkBj+MdrGcltFFRCbpNFSXlcSmlF64jrXVhLmsji08DBGuj9k8PBBkKcPZgqSeS9IW0xonswmKckh20TWMC8MUIRXJxcl0KpK73u8Rqcd+ZR5JZHRTa50oNqQBCGgnRQaXuEZrY0AVGYoq0QtV+unW1v6G1KeDjSwSdiot3FRlTM7HxVYrFBcjnBvrnZRWaIgeB9RFZJGwkhS5P9oB5JOb3urqgiFCZFWhn1SxEo+aNMAQERXJpZ0WGJe6+JnKMDWoS0MiVI6nY+ukWF1NxZ2e08fLmVCWcGlIAyZEGz9TsSSVJBXUpQH9xKIgRxSEv/o7JrhBmSMDpuUumVlFLxaZGqtc1v2+jouj9pJfZP5//gYAUWuWB/7o/Xy59gs0hzHtnk+77+M/SdxWZEmcDeYzcj9kTZUpmCq37hnh+bddtxZfS9x9991XtF+SJD7+8Y8DuV7x8vIyP/dzP7fpmKmpKR599NEL1nn06FFuvvlmfvu3f/u8fUII7rnnnnX/49/7vd/bUvr3icIVEePXv/71CCE2RRmubbuOx4aRigGDPmUlZCHKX6pT8gplyaMmOzSpMSX18FWHo66BmxksUmc6a1OUcqurIENXQC3VscwqlcBFSnNikqaCsnB5hnoKS/ikQuZMUKeZlnEznZo0YLve5zZjhUmatCKbXqIyn9RwV63QE0qPES1gSllktCBhRh0Sf4AUJ4RCQSVBFedrPm58mZbFcNVnIyPMJEBQk11MKSFRC5TkhBtKCXOBScV3ORU3GJN73KDMMSF1WUzL2FJIUQpQDRMz65OkMXYyANVAJ6Ify0SpIEEhilPSTOLhKF/CtoXPTeoZGmKAuWrB7abWpmVjAZQswUQhY281IElSHp6LqKdt1CxEIaamhli6IEMw9GJOxQ1qYkCaSZvIqUJKOy0yrg5YySpsUwOUdMgwlJiPyqtkbYEga3IyGaFPEVcYSJpJkBmoMTiZicgEReFzozzLpNJmTO4RZzIV1aOXWXQp8Eg0hSQJZMPEFgGq32JSbtNNrdyarfZR8+R/DCKNUDUQGRQknzQM169BOy0SSRp77Ihq0qQke8yFhfOW1teulZdpdDN73V1gIzEdlXpEmcKpZJQRuU9RCcmESaloYPou9dhlkOnUFRdJMrFUjZmySj+roLVtFDf3774SS68gY1JqU5ZcepnFkWyaESlmXzq/PkmpSFCTBuyV57mtsIJQFB5wR/lRspump66S+fz8JCn3PS8InwP6EqNGwE7bY9kTLKQKpza4Kpy7mtDNirSlmFDt4YQqSZqhSFA3ZYQkMFIPEXsIMkZFh2LmoCoyD4cTdCjjhfn98jONTNUYS/soScKk2sUQIQkSluRTltzcdzwzOME2YmOEvSMyE6bPjrZPsy8z4XUxCBmR+uyQm7n/fZYRotJJCoSSwjyjjFRUJhOXRDFYciScDX7hawR9JS1Rv8CEa0peYae6jCpiZAEy4GGwmOmM04Fyg+eOVahnNkd6BpoXMhx4dOQ6o8WIZ9xYojI+wU03/HgCbp5OGHoRXzmp4Sp38Kw4V6goO6fY2/kkXxu+hPgaS5HlJFbBMjYoVRgq1gaiu1GlIv9/druuytd5xFMEiqLw+c9//orLHTlyhNe+9rVb7vvBD37A1NQU9Xqdf/zHf+Rv/uZv+PSnP32VPX3suCJifK4/yYW2Xcfl4xn7x4gHBvWBx/hgCcKQ3VkTQ05pmCnlmsDJVMYRjIsinUClJhTiwYDlWMOMPabLBe6480Zu32GTHpNJTmREy8fJ0gRbipiUOqRC0M8KWJLLLrVJRx2nn5hUygrPmRJMEiLmV5gSLXpZgTNikpg6e8wBNxsRllykInoU1AhCn5iIRAEZCVtVcKUiE6ZBx5FxvQQh8pdpQcpfoHVpyGxcY1rrUlJiMm2EghQihQGmqSIrBnXToDDsQJKyS7QIEomq7LPNHLKbIV2pQmDv5KZRj5kwoR1Z2P0maqOB7jZxUPFXmgRhRFstY4hc3uyBxKCUDXlmuYuqm6R+QDet0HIbBImGIoEmg2mo3D4WcECcYEJ0QEqZLkksejrzcZlblGPUFA9JVlGJWTFVikHAHCOspGUUEZEJjQJgKQoNPWFibIaKZGJ1juMmMrHnUpACijhkQjCh9dmBT1qfoSMbSJLALNhIUpHC6dNUwiE9UWEmcRhLumQICpmLJwxCyWZa6jPPKB19gjsmI240WngDlaYnEYdVnqv66HGfUd0jVEvMuQYdc5rOMOK2Yp9ed0AQZpAJFBkKSsgobRQ5JlYsnOpe5FaBRpy770iGTaraOF5EdwgrokZZeFiqYI/qMp6sYGQe/VjnVDrCqNLHTTUqBY0dJcH2MYXdlkVwzEXKhvRijchKkCST3TM1ktEbsRZ8WmfOEHtDyrh4Qcggkumqo4zWLOZ6GZJZZH7FRcrANhV6bsho6jCiOthKwqTSQ9OanJFmqAUaIi4xE3Y4EdZoyC63F+aoSz6yJJMaEJg7MMMK28eL7Jwo0x0GRO151KCHEFAVFtVimfHOj5ACwZjmUIz9fAJZ2YUwRmi1JeTUx4k1rFIRvWLhyxlSt4WfSpQzmelKyISdsE1q5WopcUTmdBi6EVriMVPJUHePc6RnstDxiSITq1wmch2i/gJWegpFztBJSSSNqmFzQLdoVDR2jllUiyr1koYIHTonWmSiTSlbopU2mFQ8apKDi8nuuIOn10hGb8CMupRkizpN5HDIiiN4NK3TMwssDhV0VcLWLQpKgXLqEGBRoUjgCcIwI07BwGePvERNddGllEQyEKmCrGgYJHjqKKMlGaNqYo2OYbeg2waWXW4yUyKpRLVWol4+Xx/7Oq4MR2e7fOCPv8nAjYAbie0ez9WPAnCTNsevFv+JPxu+kH52NvAql9XLZdYKprYut1ZYJbLWJtk1ZZNEm2Wo15UjruOSOHr0KLt27dpy38GDB3nb295GmqYcOHCAP/qjP2J0dPQJ7uFZXLUDx/e+9z2KxSIHDhy45LFf//rXOXXqFG984xuvttmnDX7uJXtInD7+I0v0Ty2SuD7EAcn4TYxFs1glndHtz2TSD3jJzt24ao2V5SbGmSHxoEWgTTJy+3PZtn2SqL2AY2tEU9sZDOYBFREHVIOILI2oZS7zWR3d0LnZHGIZOs+5dTs7DJPhwaPEmoFiFpD9kNfsLdCe2M8eo4N1ukk86IIbgO9B6KMAQlZRrCpFq0hDzrjRbtMcP8BnH/RxvZAdSsCB1EP25gjRSFWbWkGnmPUpxj1iFITWQFYTVKtI1bKJ0gFxeRem5+KjoEdDjPp25NTDs8exS2VMz8OPe9TSIaGeIqddMDXMcMDQgigLKIs2S8oUU4aObBnUdYVd2TKqaUIkMzm5m91Jg0ePLtLvDsk0k20jGrcps5R6SyhOH4jZo8o0zDp7NI1iZKDFKVo0QMoSpNI2TGEyXa6SZRm9XoiVtMkUg6IIMAsF7EqRwOkjC5dK5pNIPnXbgyTKsxplIWpRolwLQGsRhwmyKqNXR4mcFHopdTEgs4qwojKMJeIkxclMFNOiJjm8ZMynJQ24sdCnGjcRY3UmYxgPYpJh7oc+wRAmt2G0A05nKUUloyqnFCYb1P1ZZEnQkyqUumcw4gGpViBNBySVjKxoMUMXQpepyQKzUpWmL3PfoWUKWYiRmczs282N0mlEK2NlKKN4Po8GBU7HFTRZ4lZzyIHKgJLbRe4MKEsDjGKZsh8yVF3SqdsYqUZUJk3G/RMM+ofJTB/TNHBHb6a30qFcEhgm3H/K4Uwos9sIqBUNrNEx3Eyn0HQZX5IpiBTCIXfoJ7lxso6iTSF1TjN0BbFfoxhKWBHIioYupdRNle31Egcmd/LiO6Yxgxbto6fw4kMoEgjVICmMIXVO4UdD6pIg0UJsSWKPmVA+UKOxbTsrrSWC4QAtCzDsAoVKCdmx6R1PKfs+O9PT2JpMKXGQMxlhNWC4AlKbRHJJFI3MaKPL80wcuAmPKkma5RnKBsukCy3MVhUpM1FFSG18Hz+96zY8zDzhhhRA5IKUgQjZXxwypQi8ajGXEnQt1HYTUxakIqExZlOfiBHqCF6mIM60CfWUurNIRe+wEJXYM1JnerJCqNcIogpaFlCxFW6WZUKhcbwtWGh7jGcOt4oUM7ZR/BBFk0i0GoW0iK0mRHFGalhk1TwpyW4tpl3UaBoyadjDVMX1rHfXCF/41slVUgwg+EvnuVT1lP0cB2CvusT/e+RvkfY+H/u2l1PetvO6xfY6Hnfcd999F9z3pje9iTe96U1PYG8ujqsmxm9605t41rOexZ//+Z9f8tg/+IM/uE6Mz8Fko0AkDRgWJMyJUcIuCDdCiU6QpQmRk8FDX0Ixi2R4lEo1CoGL0z9K6g+Qsy5F5ySJWyDLUuL+CnG/iazbCElCiiVUUoZSCdnrUjJMbh+zMf1jaFKK1VpA3vds1JEdRIMOeH10s8iBSYPy7SPACF3nMF53gVTViQdtcpFXFVnV0EolsshH1zTS/ilu3n8T0z+9je4j36LQehSCHhEBsV7FTJeRkhjJKKBqMqnvI9kWuB3SQYSi5JZYu1JEGh1Fm9xNcOYQaRSgFLcxccPzSAZtho+cRlNVQidALtTJyMAqIwIHGw/HNCGVGTFT7ApMjSjodhm1VSOLQ0RtG2Z9hP2By86xBZxSTKLH2MUUs+8jNB16A0Cg6Cb1igFTuxH9Mpy+f5V8yJTcWUp2nSwBkSY06jVE14GSheo4CLtG5rTR0hhRKpM1uyBJGIQoUoAsJFK9QE0LUJSMjAhdBGSdJsJZQiVBbL+ZrDMLxQa+78HAoSXXWJHq7LQcLLdLyfEYV89gKRZCU8k68+iGxZhQkZI5pCREloDOSSYbuynVRskCB2t5Ad07hWImEHnU0h6KmUKYIQeLhJJGEs5SnRlnh15i2auSduaYnmjw3GfdQr1k0FpusUcW3LpdRmorBF2oNxqIVpuaZeJHBs8b9yiJkMmZ7egLy8SakZsL2ycpygZFNUYND6Mn4wTLp0hO34/udkkCj8SVKKQRjam9yKaBPr6DW90fsad3GDN20AybVE8pHrgTW3o+rX86SrBwFGGVUKwCRTvFnJ4hMGNGS3UmXI++0kCcdFH7c8iKyujOZzKy9xkUqjXMoEX3u58jXjqJ5PbQd99O0m9iFEv4Thc5i7FISaSMW6pDCqMVzGkJe0qjpUiI5RUyr4vwY7JBHYRE2Y5IFA+jM4+INfAd0G2y0EEoKpg15DBESgKEKpOFPrYcYRdWVQP6TUTrfrK4h1B8MlmH0jTZ7udil8rYAIGDWD6etx24MGxj+n1MgOIomVUhTmICVRAKgaTZWCOjYFZySTyvj1BT5DAmzTzqsspYtoJmt7Gp4Et1vPo0mmVjD+fI/D5C1tletwjLoMky5rIMAwHxqq972GY87UKQEWtF1DBFnLyPbPk4hdFdFMp1RuKIpNNDlQVGPyYztrYoXcflY6x21hJcMFV+950vYGb0Z2l+7mMMH/w/AEixD498EeeRL5Jsu4HiM1+OfcPzkJTz3aau4zp+0nBFxHg4HNLpdM7b7vs+Z86cuWC5LMuYm5vj+PHjlwzS+0lD4vZJvGHu97dyEsnpgyyT+g5plpD1W+C7RCLDP/0wQjfJ0gTCAKHrRMkCWRKTDNsopTqSYVO48Z8RLJ9GKTZIhm2Gj36HYpqRKWUKIw2Ec5q4vYSk6/jDJpJuo49MkQYOSb+FPrWP1BvgnnwISc9/ZIVhkw06uXiskmfpknQLSTMIuktkwzYig+Gh76Fm36awdBJ8B6Hb6KqKGvcQWUqaxaQ9H8kuo5UqRL0WWehBmpIMe8ilWp6m2q6glhpoz3w5WRSglOpo9Sk63/ksQfMUIJE4Peh3EbIKWpMsTZHIsEVAZBaQRQ+516HgzIFRIhMgrApZY0d+TktH0Ibz6LJB5jYRgQqRB1EAqpULzSYJIvDIwoBMLyBkJVeqTwJIQkhiROiBEOj95dw5tdnNJw+Bi1A00AsQRwizgJyAEgxBLyIZJiJLEYZJVhxFNI/D0jGEZkAcIiSZrD2LkBTwB6i6ipyWaFs3Y+mCcve7yEkfDRUp6iASA4SCUDUyWUFXBVkaIFQd7BqZWUAvV9DlASJaJkv7iLAHpVGy0EUpVjB8QRQNQDPQZJUJzaEwZaI5A6Tlg8Qk6OFRSm14cT0kLIFRO0DR0nFjh7BlYkYOI9tneHZlO+L0/RhuEyVLMLoJqmEguX3iNARVQyk3SAIH0V8kSDzSyCdcmScLHIgCMlknjEOEZmBM7MY9/iMMZw5luARphiQlmEmXghwjGUXsfXeSBh6pNwBZRi2PIhdrZLOP4hz+LmSCidt+CuWFP0OwcJwsjVHLDTQrhaDF4KGvEcwfRbYKRN1FvGM/QNJtEt8h8fqgaOhhDxSFYr2MriXo7jxyM4WhnxNTdwArJ/PwQ9VAczr5uIpDSI1c0NXvI1QThAxhD9IIoahk/hAReWS+C7RyUeylI2T9JkIzwemArOZjr3kSdAt0GyJvve2seSwnx0YRQhe8PgKBSoakm2hCQjI05OESonsKkjj/S2OUJCSTUqqyh0yAUArg9TDcLroUIxwBw1ZO6FtnMJMQU1agOAoIsiRCGBY4XaQswdBLZEmEqpdRgg60jiCEDLMPwNh+TClDDDswsZ8s8vLrdB1Xhde/eDd9JySIEv7v19xIwczlD0d+9tcxtt1A+4t/Rhqc1YD3zzyCf+YRVv7x/6F420spPevVqOUf3zL2dVzHjxtXRIwdx+Fnf/ZnCYKzURlCCA4ePMgrXvGKy6rjGc94xhV18OkO5/D3SIZdEm+ApKgIs8j/n70/D7Msq8v80c/a45lPnJgjY8h5qImiCgqcqrRRHAAVFG2wQa+I2K0+t33ohktr0yp2Ww3Pz0bQK62ljaKAt4EGbGWwBLoZLIaqyoKqzIrMyDHm6czDnte6f6wTJyMyI7MyK7MGqHifp57KOGfvtdfee+2z3/Wu9/v9KiSJ38a0XOJ6GV2xQEAcoAwDohBkjEpCsFxkFNA58whmpogKPBKviTu8m+yhuwBIooB4fV5vG7QIG1WIfGQSgJPCXzyB9FvkDtxJ+9RDBPMnAIU3PwMqRiUJMo6QflPnUlIG2CbCzaCSGKUkSAmmQ7h6DiVj/bcwUX4L5WQwHBtiiZUfJvYbWJk8WBYgIPQ12UQhbIfYaxEvnUZ6TdJTN2MPThCuztE5/TDNR/8vSb2sL55KdF8E0PYQhglxiJHK4cQ+YqO/fhsME5HKasLrZiFdRHkNhFTdl7XQfSju0lFX6TwqaCGUgNYanH8I4WRAWGBYIBM2CnPg16E4oomPlQa/AeluNo04RPT3oWSCsBzM2gqYAoQEJRFKocIAMfdNaKyCV4egCakc5AbBToGSqMDDGjtAYeUch4o+bljHjJsIKTGTzoXrYVhaPYw8wNR9liEkEcJ0oLKIaq5BdQkhY01EmqsIw4agTWLbup04xHBc3LSDGzXwV84jOjVswyA++zDrp74KUYRw00TFYVpDkyR+h9SuQySdOqVb7mawVaZ8dgllCejUoToPpTFUGCKVgCgiqq1ipnLYfSOoOCRuVDFthzjsVqSIfZQM8eceR4UeRiZPVF1FJTEkEbTrGHZaV6Z77IsEy2cRpoVdGsPMl3B3HcDKFJAyJmnVSbwW9W98isyBO5Ghhzd7HMNyMdw0IIibFb0qgkC42e64FITVVQxLT1AQAmHZiMYqOBNYhQG8+RPgRwi/g6ovaVJsmJDo51SkCxC0IQy6SZ6z4KS799vT90iBsDtQthFJhLJTiE4Ngg60axDO6wmW7UK7ijj3IIRt1NA+iD1EswzlOUQU6H2ijn6+hKUneUpimj5mKg8qBVEbyovgdMtR+3oyYcgAQ5l6bDe6z5ppIvonUZGHkBGEie67TPQYrS9DfkCTXr/d/XUzEH4NYaUxIg86FU3oMaDuQdhBDO6B1jqcbSJGDqLs9FPyO/tcgm2Z/NJP3HrJ50IICne8lNzN30fr2JdoPPyPhCtne99Lr0X9q39H/Wt/T+EFP0r/D/xc97nYwQ6eW7gmYjwyMsIv/uIv8r73va/32dWkatvArl27+I//8T9eWw+/w9GZeRCEQdxpAArhpkjadVQiib2yJilAL3lS0H3pCEMTOCRxbZVISQwnBXGEHfrYfSMAJF4T4ggMQdKsEHfqEHVJh1Tg+8TxkiYErQrCzYAAZ2gP3vlHQUqEm0Z6jQu1n0UChouKPILaqm4fhTJiPRYcG4JAq2EISCJkGGOYLgqFaWc04YgiUrv2451t6fNRiritU7AZtkOkJDIOSb71f4lbZWTo6XatzS9fLlSKMCxddSAKEK6pX8Kx0tdOSk0WQh+x8JgmsFEHFUeaIOYGobkGYRsMA5XKIZSCxrJWhWUCnRqk+7rXvTvm4xgMCxWFiKRb7zcJoL6ir50BLCeIbL/2k3p1vW+sJw6YFqI4BLPfRPlt/TwlESKOUEmiVeNmRf+9dBLLEOSSBqKzpicFaqMWoOgq2CEYNkhHT54sG+HmIFtCBW1EeRYRtjUJAjAc3Z90GoSBigOMdB7sCCOVw3BztKe/RlRdIvE9PXaE0b3n+pom9XX8lfOQhBhOBiOVxcz3I72WPk4YgGkSN6pIv0PiNbUKbrmY6TRWYRDptQgqS6igjVJiU6lCpe9d5BOszmJmciSNiibFjovh5jAyBcLV87Snv0bcriK9NtbgOMKyCJdOYe57vm4m7OAMjhM3K4RrcyiZEFeXMLN9BGvnEcJApDKoJCDxmpi5InGjStKsQhwiTRsMA8NOIRwXYadQAprHvkxYX0GEMQhDq6lR2O27QiQxNKv6XslIj9co1OMR2Z1k0V2JkOA3UeUIkS6gmqsIOwVuGuKOVou9FliOJt2rpxBr5/SYiyN9XUwLnJQeB0mgJ2xJoh8UpcDX5dwJ25ocRx29T+QjcHU7IgBhoRwLURiD2qJWou0MpHKaIBuGHm9RR9+jTgOy/ZqEgz6mkvp57a6ubPkt8xqwPNO1lfiIlRno2wXslIN+KmG4aQp3/jD5O15KsHSa5sP/SOv4l1FRV/BSksaDn8I7c5TR1/xH7NLoM9vhHTxptFot7rvvPj7zmc+wtLREKpVi7969vO1tb+OOO3aes8vhmj3Gv/qrv8qrX/1qQFskfuiHfojbbruNP/zDP7zsPoZhkMlkKBavvvLTcwXeynlU5AMKM1vEyvZhOBmSoEtehdklCF11EjSZcbqR2zLRVoTI18vHhlaHVOgj/Tbh2iyyXcPpn6DTfBTDTpOIllarZHcJVRjgtQlXZzHSORAGcv4ESpioOEDILrFUEki0ApVEyE6kX9AoiCL9AkaBcsBNY/eNEFUX9QtSmuAY2KVhpNfGGZrCmzuGGYdYpV3IsKVVW9NGxQmJry0moraKCjqagKruizU2AUMrcjJBs6iN/6O3jWpsKoaskSRgGeB3IKnpc3Ny+vPqoiYV9WXIDepz7tT1REB11TE00VepvFZYw3b3fBXCa3QVbPQ9iAPdH6X7pOIQkkBbK8K2/s60QCjU6hlEHGmVUUYIw0IpiYjaUGnrMtxRoElycRRR2gWVOZQQiExB9z8Ou/co0tcpCSFRPSVcoRBhR5P7OLxwTWTSVUUTPVEQAsOwkMLAzBSRfht/+axWNL321uspDH2thcJ0XJJqDZkkyE6V5qMNrWxigAwglCjb1XYEFMq0EaaJM3AQhSBuljUxExZGOo0MLFTcPS8STdZkm8Rvgd1VOKUiaVVoHv8KppMmblURpgmGQdIo42T7CKsruH6H9OQR/NnjBOuLmGltiYkqSyhhEDcqEAYoYaDaNRAWUjYxHAfLTRN5TX2u0L2Wpu6b8Inr6yReu1vfOdIKfGFY91slekxtEES18fza+prE29gGhA1+S6u+HW0/wmvqsS4sbcuRoR4/gbZd4HcD7jB1PwXdsSj1GLPSekIdd/RncQCe0vfddiH29e+AYeq2uuMNI0EIBdUFSEKEZ+jx03Q0WTe7tpAk0WPOa+jxlClBEqA6DURigOmiIl/vE20u426AjPSE0HVRzTXEsfupF9MU7/ihS6/NDm4ohBCkdh0gtesAAz/0CzS/9QXqX/8H4voqAFFliaUP/x6Tv/KH2q62g28rKKX4pV/6JWZmZnjta1/L3r17aTQaPPbYY2Sz2Sdu4DmMaybGtm0zPj7e+/uuu+7i8OHDWz7bwbVAaeXINFFxhN0/TrA0o19WoF9sccDWosaJ9iPKGHyfHmFWEpKYuFlFOCniTgNvdpqoWSasrYIwMNIuZm6/tlyEPrJZueDrCwOkYWJkCiDASGVQpoH0Pd121O2H6pI6KwVdfzBIME29ne1gu1nMdI6oKrrEOAEjj7BTyOoa7ZkHtTKLrtKkIg8VBATleWSnoY/lplGB11Xf5Jbzh42PNpPirsxooJU3YV0g0xs7JAm09A+/gK56blxoN2jrUzQthAx0UtuNJixbWxIKI6AqWv3rSZsCbEcTrCTSFgyUvh5+U5OCDdsIShMpvwGlSe0FVUqTk+aqXlKXEuKuXSMO9PWIA4RMdEGTdBGRLXXtHmhCn/j6GGYKgu5xmuvaz9qpa/U2vvhadq+E1wHTwEjnsbIFlGFg9Y0Q15e1QikvzVON6l4TFEl1WX/QHUsqDlF+S48VaQJd24ZpgyEwc30oJenMz2yaYHTtLFEHYae199qXIBxNMA1DX4tYdFXkECkl4do8wrK0sp/oc1BK4S2ewUwtIWwXw3ZRSqJCD2kI4kYZGXkQRt1xnfQmMagYIqUtFamcvlcy1sMsscHNoeJQk/R8HzJodicnXYLYrGy6zt3rJqwL/5abEgRvhpVGCUOPS7M78VJSk1wZg2vq9vt26efOq+nJG5urcYjuSoTT/behx6VQ4MV6rCd6koZhgtPfJcGG3ieO9HVQsW5HJt3VmQSC1oVjYOjn3bD15DgOwbF0nwsjqMwkojoP6+c1wTcMPRmPHVAbEzOpJ2+mgE6AsFxolWk8+JkdYvw0w0hlKb7oFRTu/BEWP/AfCZZ0ere4uow/f4L07kutGd/J8MOYOHnm46EsU5BynlyOhGPHjvHII4/wR3/0R1dtdd2BxnVnpfjrv/7rG9GP5yxUHANCv9vCgGDxlPajuhlUq6oJk2VvVflMC6swQFRZ4hKSY5o4g+PYA+P4548RLJ/WCmQU4QxNIGwXM9sHwiBpVeicfRQVdVU5AUQhKmhj9I0g/TZ2vh/pBISVQAf6JDoNkJnvR0UBijQilULWy/rlKhNMy8UqjWLmSjihT1RdQSUBpptDBm29HO7VsQtDmNkisllGKaUDEMMAI1NA1te73siLJwWgX8oWF0i6q1/ycXeZfzPB0b3VnztdhSvc8AfTbXtz9ScFYQuB0SUVrt5/g/walibN+UEdhOjXtKosY4h0m8K0QG5SxsI21JW+vqapt7cdcPKobJ/2J7fXtY/UTulDyQQST3cz6k5MlEIFTUTia5LRKmv7RhKhDBORyl1Yrt84p1in/8Nvb7LloM/FcvV1iKX2kiuBlAlJ6GP3DRNV5gmXzulrtuUe6OuA7SKcFEIIZDPubif1tl6X7BpWtz9dJDHYWYxUjqhR0f7SLePX1RYBBTgpjFQO3AyytnKhC0ppEpcEXYLsoVJ5zFwfZqaAlSsRrJxFxj5Rq4M88XU9yet62aXfIliLMBxHryBEvYa3DANNtLXSTdwllCitKpsWxCFJZVV75U2z6ynuTsYMoW01vfY2jUU9SDYRxO55W9aFlQhhddvrjrve5CuFKowi2uvai86GrWfzsRJ936UJqTzKdBFRuGklQ3Wvc6R9v4guuY31b41haRIsTE3AL5lIdY+1YXkJ/Qv32EmhBsYR6T6UV9UBg9l+lN+E4qgOLOw0dXBg0vVAO93gwSRGWBYy7LCDpx8yCqh87gM9UqwhsPqeW4F4933iUf7+y2d4mqpdXxGGgFd83z5++ZW3XfO+hUIBwzD44he/yJEjR8jlcuTzeWx7R/1/ItywQtRhGFKr1bYkZf6nf/onPvnJT5IkCT/wAz/Aq1/9agxjJ1flZrj9o0T1NWR3uTX2GphuBmGYiMKQJhKWhayudokHWhGLuy86w+kurXZh2jo4SIAMPQw3i/SbCMPAGZxAxhFWfgCUxLAs7MIAYdwlGDLByJewMn2Yboa4XSNqrCHDqKtAaeuElclhpHPIjkDZChUFiFQWp3+UxG9hZvpI73se0muigjbSbyHsfm2tra1j2DYyibRqF/qY6TyYJtHanFZbRVqfR9QB2+7aE0R32R5NVpMYkStpZVQmmiRhgJ3WS9ROuqtmZbqKW9cGcsmLvmdmvQjdpe/I0GRBdAmNm0WYDso0dUDVite1Z7RQlqMDk+K4u1y+4f+N9T0yLN0vlCY9htD2iZXT2v+rpF4qb5X1NkHSJfrov1Ws/aqNdd2/sKPPOQwQhtCfORlQll7W30z4LzpFhdA+37DTux5CaUtNnETEnab2jG6o4sLoZj8INeGzLMx8H7LT0i8Q0+5Omrq+crWhpm9A++GxXB3UlkRdpfgiOG5PVTctCyvXj3Bc/E69a0/YyArSXVHZOEe/RRK0dbBn5JP4XbXV90jCkKTt6HEiu/YGFSDDLvm8hPh1T9lyEKaF2vyTZdhaVd2wDfW6oABLK8xJ3CWmXYXW6P7MpjLd43ctN1LoyaRAT4hkoomrYet/pwqa/Ebdc4wC7YUf3K2Ja+B1D7755m4m+ZZeUfDquk9OqmuzQT9PytKZVqyuN1/5+vuNwMco6F4bY5tr1FXYk+7EPRF6cpDth4E9KDulPfuNNb1ioRS0yvoZEYotNqegDY6LCAMIPZIkYgdPL4LlM6z+3XuJ1jZllzJMBn7o//Wcy1Dx9185+6wgxaB/av/+K2efFDGempriHe94B+94xzv4yEc+AsCnPvUp9u/fD8D8/Dw/+IM/SCaTQUrJyMgIv/Vbv8X3f//399poNpu8973v5f7776derzM0NMTdd9/NL//yLzM6Otpr48477+TDH/5wb7/777+fX//1X+dVr3rVZYvAhWHIb//2b/PAAw/QaDQ4cOAA/+E//Idnhff5hhDjj370o7zrXe/ih3/4h/nP//k/A/CRj3yE//Sf/hOgvS5f+MIX+OIXv8gf//Ef34hDfscge+TFdE4+iL8+D4GPCjrErRrCccke+W5U16saZ4vEnYaOxldgprIYqSxheVlbMWSsA32cFGF1lWB9ATNbxExnEUqSCItg+SxKSr0M3KriDE5iD04g7BRxYw1hWDije5GhT9Jd/jcsGxVWsQfGMJ007vgh7NIo4cpZovoa/vwJhJPGQGr/LIK4sUb9oc9iF4cx0rnu5wrpt7TSlsoihImRKSIMAzNXQnoN7OIQkaHzJBvZAir0sYqDxI0KwnGwsiWkjDFtl6i6qkmFneou1yeQhF1iDbglTUQKQ1rh7TRRXl0ng4hCHT2P0v2R8aYsE5tgdEm5MC/wZ0e/8AUJRLEm2koH3Akno60ZCi7s0FX6pNI+UNPV5M9O6aCj5jqitqCDmuIA5Rg6XVt4QSXuZcEQliZV7bJuc8NDanaXtYUJ+dEL5GbDjnOJKm5oQr6JFGsIcNN64uJ3LgSFoYmwlenD7BvS6dTiGOl1UMLQExjLQuRLqDjSlo1IB2QiI30dUd0JjoGQMVZplKi+svV6byz/O64mpEpPAlEKqzBEXFvuBoAmXArt9ZZeCym62U6SWE+KhPZyY7sXrivdSyIunqgLTfRMG6wUMuzaQTa84zLW91EZFxR4KfXnIkZZFsJwNKlNFzSJzpa0T9irdfmqA4UBMGyUYehzTWJEHEF9qTcBxjWgMKIJpqUVXpXKI1pr0KlqwdZyN91nfW9B6KwqUahHYRzpKUrodYN2u302Tf1sJt17lc5B4mp7Rqw23f+LxoiwtEpeHNPWnw1/MgJy/WCnEOvntB/ZzlyYVLbXdSBo2H1GNiYA3SBFpAJhItL5be7vDm40VBLTPvl1Gg9+Bn/22JbvnJG9DP34r+OO7HlmOvcM4hXfu/fZoxgbgld8794nte8HP/hB/uAP/oA3vvGN3HbbbaRSKfbs2dP7fnp6mkOHDvG///f/BuBP/uRP+J3f+R2+8IUvAFCv13nd617HTTfdxN/8zd8wMTFBuVzmf/yP/8HJkycZHR1lenqaPXv2cObMmV67cRzz7ne/m8nJySsWfovjmPHxcT70oQ8xOjrKpz/9af71v/7XfP7zn3/GPdDXTYwffvhh3v72t6OUYnl5GYAkSXrBeLfccgvPf/7z+eQnP8nnPvc5/uEf/oGXv/zl13vY7xjkb72HpNMkbKwhZaz9nMJAxRHBwgzZm76bzL7noaSkPf0AnXPHMd00hpvGyJYQhkXSaaDCgKTTwHBclFcnXD5DeupmMgdfSNKuETcqWJk8/uIMCJNg+SzByjnMXInMnueR+E3svlG8c99Cek0MyyHyWyRRAEoQV5axp46QO/JizLSupCUjHyOVx3DTyKBDVFsl8er65RsGqKBDet/tCNslrq0gbAcZRwi/jTBtVOghHBfDzWg/cmUJp3+cuLaMVRwmrMyjwg5GtoBh2pjpHE6uRGr8IP7yWaTfIlya1XYCw9Up20CrWJ2KJoztKmL4ADTLiLbOCqFJsdTqXuRtCuKz2Bqw110qllIvo9uuVtE21Dwr1Op0FOlt2mVNGkwbHEcTAqPru448yAygJm/ThKlVRiw9jmiVNWFJpFaQ0326rdDX7SjVzUhgd73a4Va/r2Hp700LBrtKXRzqJezyLCqOEeEmb6iwIKXT7AkSCENNGq0UWDZGKq2j03tqYReWi0IQbWQhiSNU7F/IBGKnMVAIN00cBbrfcTdDgpvGSueRsVYCZezjz03rSYJrgIwxCwOY6QJJ6CG7WVkMV1+/uLmOMA1djtrsquEy6tl6LkHoYRX6ieMuEY58HbCZ2VCIYSMLCm4a4WR0AGzY1hYXN4shBFbfAEmrhnAyyHbXyysM5IYvfSOzxyaPv1AGSiVajS/tgsBD9U9CfQkhuqsPoa8ns3GIcNMwuE8HSa6d7pLsSF9XvwnpIpTGdcq3JEEUhlGVOZCxXrGor9KbhG14i01TBzeqBKJQZ1RBdsdKSt/rqOtHlxFk+rpxDpZegbHcC8GjZldpT+W7gYQRpLorB52qVu+V0GNImHoFK/JRG7764qD2ubdrur3Q0+kKUyU9UaDrK1ddgqziC9kRdvCUIGnXaTz0WRpH/5GkVb3k++KLf5z+H/hXOrvKcxC//MrbeP3Lbvq29hgvLy9z77338tu//dv8zM/8zLbbTE9Pc+utF7zjt912Gx/60Id6f997771MTEzwrne9q/fZwMAAb3nLW7a08YIXvIAHHniA9fV1BgcH+ehHP8ott9zC0aNHr0iMM5kMv/7rv977++Uvfzn33nsvZ8+e5dZbb+WDH/wgn/vc57Btm0ceeYTh4WH+8A//kP379xPHMX/wB3/ARz7yEUqlEm94wxv4y7/8Sz772c9e87XaDtdNjD/4wQ+ilOJ1r3sdb33rWwFdJrpcLlMsFvnrv/5r0uk0P/qjP8rrXvc6PvGJTzztxHgjOvNb3/oWDz744NN67CdC4jWJqkvIMOgGTGnPoHCzYFkYbga7bwQzU0CFHnGjgpnO6SIYjq2j7RdOYvWN4Z09qkmf7eIMTRI3y8g1D0WC9Ds6ICpO8M8/igx9rFwR5bdI/Dbu0BRRdYm4VUVGAWH9vCZ0wkDYLlaupBVeYWBmCqR334JVGMRw0kRrs5DJ0Tk/rdOpyQiEiYwjwqUzWH0jqLCDXRgirK9i5UuQKxJVl7GHd2MXBzHzA0ivSVRfBwwMN4WV6QPTwhma0tXHpm7WpW0HJ5Ghj784g+ifBK+urQ1Kojp1RG4E1a7oSOqwA8snuoFG2W66O21jUFYKEYdaeU4irQYLgVIgCoP69MOmJnDNdf19HHZJQqCJ6kbAku1qwpbOaiLhZmH4oFYHV0/pF79KEPUlCNqoynzXU5zRZCH2tQ3CcrUdxOku1zspvXyO0ETJq20iLSlUcQRGDiCEoZVxgNDTRMpJI4z4gmXBtLUHtG9Mq5O1Rd0/y9YFGnL9pHJpDCeDd/abJJ0m2v8SY2a1um8oA5nJQSJJat0UXLYDfhNp2VjFEaxiP3G7oVPjpbKgIIkCVDd7hnBTqDDAyvdjpnMopXAGJxC2Q7AwA46LTKKu48RERXolwMgU9P20EhBKE9SkS+5V1A3ss/QxhQGt2oUHTcmuBcTt2kEisNOkR/cTtyokXhNp2zqnsWUjujYOMJGhD5aN6aYwsyVkHCIDT5dwjn2dycG0QCpU3EFk+8DO6Mwilt1Ng6Z02jIBZAvdTBNdVdurogqjWmnNlroBmNryofy6HuNuTqcAXDutia5hohKlyTboVQKz63VOFfSkr1XpBjOix3husJvRQ+rnIVvS24QehC09eTBNcAuaRHs1vb/l6viCsH1hEumkUIatzyupd4P5DB3YWl/RKxKdmu5TYfSCUh6HkOlDuRk9eUgifZyom/7PTmur1w5uOFQSU/3i31L/2t+jtplUOiN76f8X/4rM/md+KfuZxpMNeHu2YHp6miiKmJqauuw2J06c4Lu+67sAWFlZ4b777uOlL31p7+9PfvKTfPzjH7/icU6cOMELX/hCyuUyp06dIpvN8md/9me8733v4yd/8ievSIwvxrlz56jX6+zevRuAmZkZvvWtb/Enf/In3Hnnnbz97W/nve99L+95z3t417vexezsLPfffz++7/Mv/+W/5Pbbb7/qYz0RrvvuHz16lGKxyFvf+lYcR5eT/NKXvgTA3XffTTqtE4S/8IUvZNeuXRw/fvx6D3nNeOc738lXvvIV8vln3xJduDZL0qzgDu4iWJ0D08Gw7W58k4P0W3jnj5HefQvu6D4y+8pE1WUwbaTXJmlWQJgYborUxE0gFIkXEaxViBtLKK+ilbbQx8wWiJtVEr8DShE1Kzh9I6jQw8wPAALOHSPxWvplaTk9pdTMl3CHd2Ok9BKHmSlgZgoYqQzemUfw5k5o4cdxwY80qXfSmJkiqd03ES5YJEEHZ2AcEISVJUCrb4abwUxlEG4Gd2wfwdp5kk4TGcfITh3pNTDSBVQUYA9OYJdGdPnrdg1VbWjrgZ1GFcYQS4/r9E+Wg1IKUZrUAWtxpAlRN3cwfbv0f3Pf1OroBgHI9uvAx/ywtmRUF1Gdml5yNhxNqPsnQSgdYFSeRVQXu5OIDmQHdSBRYQSRymlXheloq4SbRdWXEbWuehgHF3JKmxbYtu5rt8Q1QqDygzC8D5RArJ3VtoVuYBi2ibBSeoVhaJ9WggMPUIjiKCwcQyUNRHYQvKq2cBRGEPkRlAwRmQIqNwi5AU3KmmsYIkCFHu7oXsLyMkmnAVaCCjrYw7t1wRKliOtrWqlOIoSbQ/ktzEweGbRITRwhk+8nXDqNjEJth6mvo+KIqLqk7RYonVlFSdKTN5PafTOdU0eJOzVUGKJkiFEcJm7VMGwH5bhE5SWEYWFmi2QO3IFhp/DnjuOvLUDsIywXM5PHyvbp8VFepOePNW1dGdJNEZXBcBycgQms/jGMXF9XzbWQtTWUQFuMDO2RtgduRgZt3OE9OMNT2o4UBUS1Vby5xwlWzunnMEl0Huo4QdgJQgmUlNo7DqjCsC6yspFLWCq9qpEkiLib91spTUIlOkVaHEJtGfKDmnw6WW2TEN0c1qtdb29zTft7lUQ5KUSq0J0EukBLT7ryg9C3S9sxass6XaGSqLCjbUCgC9+kstoTvI4eo+kiamifzqUtQ0QUaguI7cLaWXoBdELolG3rZwCBcvO6YFFxDCEjVNvQk9XcsLajxJGumOlmtZ9dCLBSGG7qqf7Zfc4hqq+y+vF3Eyyc3PqFaZG76XsovPDHcHcd1CsXO/i2x759+7Btm7e+9a387M/+LCMjI1QqFR588EHe/OY3c+TIEaanp/nyl7/Me97zHkqlEj/yIz/Cr/7qrwLwwAMPMDEx0SO2YRhyzz33EEURSim++tWv4jgO09PTvO51r2NtbY3Tp0/z8MMP89KXvpR2u83IyAh9fX1X1V/f93nLW97Cr/zKr/R42qlTp/i1X/s1XvSiFwHwile8gne9612srKzwsY99jM985jOUSiUAbr/9dg4ePHjDrt91E+P19XUOHTrUI8WgL6oQghe/+MVbtu3v72d6evp6D3nV6HQ6/O7v/i6f+MQnnrZjXiv8pXO9IDm7NII7ug/DzSBDH8NJkZ66iWD5DMHKOdyRPdiDE0S1NTb8q+ndt5J0mqQmDmMVBohbHdYf+Dre9HkSbxm3GGO06wDIxCBcq2Dm0l1VVyBDn6i2QlRewBkcx8r1EbdqKNG1ALhpnNE95G+9h/TuWzAzhS39dwbGtbXCThNVl0nCNlJKjFQGM53H2bUf08lgFocQYYA7soe4towwBCqKUEaa2Bf4q8cIF2a0EJorYWQymE6GoOwhTBvDdnAGJ0jvvgWApFnBTOUQsqxfxkiEk0VNPh/RWNIFA5JY50/1m/pvFULfmCaSE7foQLjKXNdOYaHyA7DrJq1wxR7UV3X+XyfV9TJrz6wQQG5QK4JDeyE/pMvxhr6uViZjxPA+WDmlCY/X0KnZwo72hALkS3qZvevWQMYQx4hisestjnWgX5+eSCgk5Ae0DzlsI6REpYuIbB+quaInAiMHNWHvVoITQ3sR1UVU7CMyea3UWS7Cq2oFsm8MBnZrX2i3pHB6903E5Xms/l241WXC8gKYDt6Zh4mqK9ilUXKH7iIqL2rPe+ihFESV+e6kSeCM7iGpl3V1uCTBSOdxTJuwuqQtHt2sEnbfCO7IHrJHXowQBr5t4/SN6iI0icQujiC9BtJvdnMFS1JTB0laFZyBcbIH7sTMlUB+mcRvIQwTM9enyZdQkErrdGwK7MExsodf1C2kIzBsB+GkSJrrOIMTGG6G1IR+CSRBm2DxFJ0zjyA7deJ2jdzh7yJ76K4t4z8sL+iJW9BGmA5Jq4GSMSLX382AobT1ob6IMGzE+C2o+oomvEP7YO2MVnZL41pBLY2j1s8jZKwnUH5bk8UugSX0dMCdMBBjh1CGDZ0KKgz1vpkSQka67HmnisgUUcJCFEdQA3ugb1Tfa+hmKmmCZesKkbVlPQk2bd1nFGJgUgfPJRGiXYGBKb1aUl/WAX1RoMdPq6wtYCRasVdKW5imbteVOk0DlR9EDO5BNVb0MQf26ImrjDU5tlP6niXhTkGJ60Rz5hQn3vX/YOXz3Pz23yRaO8Xa//5jHePRhZnto3DXyyg8/4cws8VnsLc7eCowNTXFe9/7Xv70T/+U++67jyRJGB0d5fbbb2fv3r20220WFhZ48MEHyWQyl+xfLpe3JFJwHIevfvWrfP7zn+fd7343juPQbreZm5vj8OHDrKys8IUvfIGjR4/y8Y9/nE9/+tNXrRZHUcS//bf/lqmpKX7t136t9/nMzAz33ntv7+/19XVKpRIPPPAANE/DBAAAuXRJREFUN910E0NDQ73varXas4sYm6aJ511IVF+pVHj88ccBejL9BlZXV58WU7VSis985jP8t//235idnWVycpK5ubkn3vEZgHfumySBj3AzZA++kPSe23SWB9slaVYIls/oAgQI4voaSbtO3FjBzOqZkvTaOIMTuCN7MDMF2rOPUD9+ChV0CKtNRAJuLkImBl6tQtL0MWoeqbE+zJSJ3TeCVRhAhT6Gm8Ud209UWSI2dfS/kcriDOxDuIPIuJdsagvMTIHU5GG8ueNE5QWUkyW1+xZkp47hpImbFQzLIVxfQcXzCMcmbtdJOj5RkCFoniSuzmLnwXIdjEwBpziEN/c4JAlGNoOZKWIVBzEzBaLKEtJv4YzsRZ0/BZGHGNqHqi2AZaJy/Ygw0IQx0mRC2OluMJC2KohWDSUq2vJguzr12NA+rby6WWita3I5uFdH0ttpVKuMyI+j3CwUh8HJoKTSJFoJ7e/tVKC6pIPqpOx6kbtZLPonUEogwhbKb2niKKX2DQvVDVQSMLQPlR/qZrBA+1Nzg1p93n+XJvami6jOo6pzCCev+xYHum8IKI6hBlOaiHeqYDraauG3UO2yJo+1JU3SOkO6cIidRnpNzFxJ+78tC2E5JO0aZrqA3T+C1TdKZs+tGEdejPTbKCWRfofOWe1Nt4qDWIUB7XHffSv+wglSY/ux+8doTz+AikLtj3cy5G767t5kK+k0sEtjeqykcjjDuzHzJTonv4Fw05hdH21cXcHMD2D3j2FmCrhDk3jpLInXJPEaWLkSVmkE2aqRGtmHM7ybuFUhtesgZrZPF/4YHCdplBFOBjvfR1RbJjV2ALs00htf7emvgpRYxWH9//zAFlKcdBqEq7PI0EMogVMaxm93/euNFU30kkQrq/2T+voHbUQqr1cCIg+Rvh3VNw7ZEqK+rD8bOYAynW5ZZ69XZlx5LYRbQMlIE143j1idQWHoFY6J5+nJVn1Vt+Oktb+4rTOcCEOgcv0Xxnbsa5W4ta79yNkiFMb0BGxoN6LT0IRXJnoS5Wb0akbY0WnYMFEqhv49mkg3V3XGlDjSk0jD1JPFvnFUuk9PGiMPkR3Q599aR5QmUIP7ELMPw/pcN8g1uTB53MGTwvJnPkuwukawusbcX78P0Xxoy/f523+QgR/5JQx75zp/J+MlL3kJL3nJS7b97tixY4yOjm5LigHGxsZYXFzUk9dNqwgnTpzg0KFDvX9vqMKHDh3iLW95C29+85splUpMT09fFTGWUvLWt74VIQTvfOc7e8daW1ujVqv1FGHQWc7uuecearUag4ODvc8rlQqPPvpor183AtdNjPft28eJEydYWVlhZGSEz372syil2L17N5OTk73tvvSlL7G6usqdd955vYd8QiwsLPAbv/EbWJbFG97wBl796lfzspe97Ck/7pOBmc4hhNDq2dgBkmYF6be65GCqp8K5o3vx56aRUYDdN0pUW8YZmCC993k9DzJA7PnIKMLM5FDlVZQ0cMf34i0uohohzkAfcbWFmRnAzuiy0rJrJVBKYub6sQoDyCTSy/LKJmwoklPnMJfW6bvtFuxC4ZLzEMLAHd5NauwA3uwxksoysd9Cdpra9hFJwo6FqpRx+gewS1PYw1ni0/OkBvtprJ4HHJRKcIrDmliH2ktrmDbu6D4wMnhLSwihvc/B/LRehpUxqragFePckCaMnbK2DPhNhNUEkYCTRjkZRLqog/DcjH6BjxzUuYQ3iANo8myn9Qs83Yfq363bVRKRLqKy2gcpFo7rY6TyqME9epnZNBE4UBzVpBQD0bcLle3X+5oOYv5b3cIJQttATBsxeTMqkTA4Cf1db1jQRnRquh92GlWa6PVROWmtSDfXNSmJfE1Sgra2OYAuCb3rZn19Ql+Tm1Qfymsg7BSiMKK3NwRqeB+psWFU2CFcOYc7uk8HdgLp/jGSdhU7X9Iln7tWmg3YJZ332khpkurPnSBYOYOVHyQ1frC7spDDTOeRoY9dGt2yAmFmCmQP3YUzNKUvSd8IUXUF//xjKCmRCtJjB3FHJnFH95OeONw7rjuyFxV2MPN7MdIF7W81LcxsH4aTwupW8IvqayR+W08E0zmcviGEZeGOHSS97/ZeX5SSyKBD3K4hOnVSEzfhDF/4LQOQvk5D6AyME66cJ251ELkhbbtB6lUHQ+isKEP79E6Rh7LTW/+9cS/dzIXPWhVtZygM6xUCAcIwdKXDwT0oJwVhS68cDO/XE8JUBvqn9LiMPP3srswgMn2AQvkNvTLiZnX2mua6nkzJBDHxPO1nTgJEcRRVmkCVgEwBsXZeV32UEmGl9PjHhPUzXQIrtO1o8nY9xhJdFl7kBmBgd4+Mbzm/i85fCYGIu171JCGz/8Z5BZ+LkMGF4MX2iYfI7dL/FrbL4I++ifzzfuCZ6dgOnjWYnp7upW3bDvfccw/33nsv7373u3nTm95EOp1mZmaGz3/+871iIdPT0xw+rH+HDxw4wPvf//4evzt58iQ///M/32vvbW97G8Alqdv+03/6T6ytrfEXf/EXWNYFOjozM4Npmnz605/mla98JZ/4xCc4fvw49957Lw899BB//ud/zsrKCrZt85u/+ZskSdLzJt8IXDcx/pEf+RGOHTvGL/7iL3L33Xfz0Y9+FCEEP/7jPw5AtVrlE5/4BH/8x3+MEIIf+7Efu+5OPxFs2+anfuqneNOb3sTevXuZn59/yo/5ZBFVlhCmi10axUxnCRtr2P1j+nNh4I7s0S/1yhJmroQJ2u84dpDMvtu7nt0LyO6eJD0yQmd2DitfRDgGKjFIjU4iVRWEg1WySQ2PYvWPgZlGBXWUTGh+6/8g/RZJuw5xjDu2n7gdkfghuUNjeEtLxO12jxgnnUaPDBmpLFZhEOm3cEf2ElYWtIIpdeEH4ZRQDZ/MxARxaGDlswgR4/QPEIeC1PhenJzEyqRJ7b4FK1PA7hsitWs/4docVnGc5ulZknYLwzKwXA8QkMqhhvfrErTpPk1EnLTWF5VEZIraQhC2EcNZGDmg1dCFx/T+pgV9w9C/lfjgZlHD+7a+wJ00eDV9HDcLlVmozGl1sFPTAUmRp1Wy1rpeugYdtW+nNPm0072CFCKT10FYAu3FDANEtr9Hui/Xjx4KQ6joAKA02V8/j6rMIVIFrWS7mYvIfRHhZrW9RIgLKqad7rVt94+h/BZxfZ2osoRdGsMu6TFnFQZJ77u9N243CDKwhSibmQKFO19K3ChjFQZ6Y9QZGMe846W9MXOxLedisg2QnrqFqLqM4aTJHnnxJePdzBTIHnmxzsYiJTKOiMoLWoWOg54nHiVJGmsIodOjpaduITV5BCGMS/oigw7CtEmN7CEJPDIH77zkuEY3wM+bP4FwUlhOGpVYOvCuVdbpzJSCjbHSvZeb7+vF4w1XB4eK+rJWirtVBMXAHk0eDUP7h9NFbaOpLV2YEKb7trZjtxH1vC6gkiT6/m+Q0tjTecDdnA5cba3rFYSNLCgb7Ywe1hOxdrk3hsX6Oe0rjmNduCPsIFR8YYwVRy+M84vP93Ln3z8O/k0ov4FIFUhP3cIOnjyEeeG1vnE77f4xRl79/8EZmrzMXjt4LmF6epoDBw5c9vtcLsdf/uVfcu+99/KSl7wEy7KYnJzk5S9/Oa9+9at7bWwQY8uy+J7v+R5Ar9ifOHFii2K8vLx8iTi5sLDARz7yEVzX3eIuuO+++zh58iQ//dM/zT/8wz/w+7//+zzvec/j/e9/P7lcjnvuuYe7776bH/3RH2ViYoIf//EfZ21tbQuxvl5cd0u/8Au/wOc//3keeeQRzp49i1KKgwcP8oY3vAGA06dP8853vhOA7//+7+e1r33t9R7yCTEyMrLFm/Jk8Ld/+7f8z//5P69q29OnTz/p4+RvuYckaJPZezt230iPkBipXO+Fnd59S49MAJclFgCZ8XFKd70AlUQ4fS7Sb2AWhijceieZlUWiyjpmPkdq1wE682Wiao2k3SB/cA9J+zRmOo89MKYbUwpnaAycYbylJcxsDqtrhUk6Dbzzx3rqdnr3Lb1+KiVR018jqq5guFmMdA5n7DDKXCcODdyRCbL7pzAdg8wBiVIGMmgQr51CSan9w+kcCINwbR4zV0LYWZL2GumxMVqnTiDyisz+w6gT39RqWW5T9G1h6IoKFUFbEwK/icgPQfYyUfCbX+ZdwqIiTyuvbkaThc1VyUwXYXNB3c0OXEqAuhC5Aa3EGY7ODuBmuymvtga/yHYb5XmIdFoXrm6t66wVG+3m+hGNgs7RnCnpACmviSifR+266VJynx+4onIJXHHMAbRPfoOkVcXMlS7x3W7AGRi/hExutL3d9tthQ0W+0njfOJaZzusJZG2FpK49+IblYg/sIiovEizN4AxOgjBITRzuWY+2hQJh2Tq4NPSwC0OXbGJmCjjDUyStGs7+OwmryxCZ2uJy7iGU30SJFLLpIVJtjKu1kEWe9vdO3IZaOY0wBSqd12S4SzqTUKGkQIw+TwdLdieEW+Bm9QpG0NIBk9aFGBCU6KZuy+jsHblBnWKub5ee0G0oy912No8NFfl6Mhh2tOKcKaH6d0Nh4FIyfLVws6hdN/XG4tWOj28nPF3vEwBhbTK8KZ1tYuznfhsz8+wLPt/BM4N3vOMdT7jN/v37+fM///NrbkMIwdGjR3t/x3HM6uoqr3rVq7ZsNz4+zokTJ7Zt4xOf+AS33norv/d7v7dt+/fee2+P473zne/k+77v+57wfK4F102MXdflAx/4AP/rf/2vXrLnV7/61T3vyr59+7jpppv4yZ/8SX7+53/+mivfvf71r+frX//6VW37jW98g8I2y/xPBmtraxw7duyJN7xOWIV+nNRUz9+4mZBsp8Zt/H05RI0GScdDxhGt08vkDx/AHRzG6R8jtetAr+2w3kbGa6QnJ2kcWyesrGNmS6g4xHRzOEe+CytfwsoPYGSGUMrAymZ7avHGUvKGui39ds/3CZA78mIdMhb6mNkihi1ID2VQyiK7f4rUqCZNG5kyowokVQen195GWVjVPWf9Em88Po2VTWH3pYmryxfUzotxJYXKzaLGb95ehb3shfU0Kc4NXiAPuX4YmNRKV2EE+sd1b5+o3Y3j943QK1+94SPeRExku0146gzK9xCWgZtXCKsbXDe870L7UTdlGIDXQNiODvYrjMDA5NUrd5twuTHnL8zgL87oNH2NdYz0AGZhZMvYuJG4WiJ9IUtKlrhRJmnVMAcnSY3uwy4OIVAoKbEKg1cmxWh7RmrXQZJWFaswAEJPBC/ex+4bIR7YRdKp66wusjsZyxRQdp5gYVV76usBzoF9V0eOpdJ2hHYFMbTnEgVWttsEpx5HNhsY+QLuLTddvl1DoNwsYmD3VsJ78bgd2K0nfRsTuu2epw3k+rXdwmvp1Q07o4Mcc4N6EleeQ1gKo3j5SeG2uHhcfofh6XqfAN2KixpKwfBP/r93SPEOnjFYlsWnPvWpa9pnZmaGn/iJn9j2u4cffpjx8XEGBga4//77+eQnP3nDEyzcEO3ZcRxe85rXbPtdf3//E+bCuxJKpRIjIyNXte2NLDc9NDTELbdc3ZLe6dOn8X3/iTfcBundt15CgmUMYb2NFXPNZMNfWcFfXsbO5YiqFeJaFSO1/xJfqBUDhkH77BzO4AT5mw9h5TKakAow3Azh6ixxfQ0j8C7JSKHtE7kt6vZmbF42T/wW4co57NII/tIcMuhwMS5uTwuxktTkEU2UA90vhEC4aVITRxAWKHv1SatU17Sfnda5gsvntFVhQ4HdpHRtu2R+Nce/2EfcJSbK81C+hzk4SDJ/DmmANb5nK8lpl6Gxqu0c9eVukYqMfiOG3hU68CQh0B5eFNKLaMycwXDWMLO5S/znUaNB3G4/ZaR5O2ynMpuZQk9RvpLyfHEbUXWFcG2WcOUccX39kmdg80QWJw2LqxB0EKFHUqlAJ8Sc6CPxPJTnwRMR441VCZUghKlJ8UVKcFKuEJ4+gzAN4tV1rNGRyxPjzT75zYR3m3G7ZYXlSuPXzaJGDl7wtgugvkpCmvDseVidA0vh7p5E7L75O5rsXguervcJ6EncBoSd1r79Hezg2winTp1i375923537NgxfuVXfgUpJUeOHOG///f/viWDxo3A057F2vd9Uqmrz1P53ve+9ynszeXxmte85rJk/2L81E/91JNWA+z+sS1/R40GtUePkbRb25KNKyFqNGifm8Wbm8cvV8jt243TX8Tun9qeDChAKQwnhV0a2UpqupkfNivClyMFlyMbPRWv08BfnKVx9CgyEShj9pLjbbd8v9lWohJASgpHDuMtLaGUgdM/ApX2VV2b64Fst1H1CkbH10Rgw7gHlxBcIm+r1eFqcBkfsUinEZZBMn8O4boYWedSkrPZzmHY4OR0ZT0Z6ypnNxh23wjurgMkrRpKFJCeTXrsUv/59Yzj68V2KvO1WDg2tpd+G5S87DOwuV0pJbCqVdpMH0ZqEMI5kmoN0TeESF9Bhd3AxqpE3zhq/az2sMMWciy9DrKpU87pycmlk8weruRP327l4GrH7GZvezd4U7VqqFYDM+cgfYFsNzE3WzKe43i63icAKtyUli3T96Tb2cEOnik89NBDl/3u9a9/Pa9//euf0uPfEGKslOKLX/wiJ0+exPf97kviApIkwfM8VlZW+NrXvsbXvva1G3HY70jE7TZJu7Ut2biqfTtt7P4SQblMVG+RP3wYZ1Ar7psVvLitX/qFm45se5wnUoTh2pa57f4pzGyN3OQkYaW+7XnJWKdXtSytlG8myjIGTs/SeHwau1TqeZ2favTsDLU1RFjDPXgEZGurDxO02rd6RhObi60OV4PtiEnQwZRNcEKs/jxidM+lgU2bl8WH9QxbxYFOC3Y57/QT4EpK72ZFNgklzdOzl/jP4frG8VOBJ6NeX80zcAnstA6EjDzcfXuQuVFEsf/qbBQbCu/6WUR5FlVb0QF2+17cI8dGOoORL3QLg0iM9PbplrZ403OD225zXcj16zR/3eBNke1D5OrI1TpYCiM7pCeI2/XnaXp2n6sQYtP7V3x7V3DbwQ6eCVz3UxMEAW984xuvqtTyxTnxdnAprGwWM5vblmxczb6YFonnUbjtVgzTJLt7CrtQuETBy+6ZuuJxrkYRvhY4gyM4w7sIK/Vtj3c5hXHjuLLR6FkpeBqHUM/OMDyCPFcnXprFyBUQoWKLcWc7D/J1qGWakM+gVlcxigM6k4QhuuWhN+HiZfGNvjzJQKio0aBx7PErKr0bEyIbMDP5bQnn9YzjG40nq14/qWdgs0obKmTLg3IF4IkJ4ca+SahJ8eCUTsXm1XrE2Bzox9m/r+cxNgf6L2lmizc9lb56f/O14CI12nCzOG4GNTaiffCbPMZPS3920INw7N6/ldx53+5gB9eK6ybGH/rQh/jGN74BwOTkJMVikccee4yJiQmGhoZYWVlhcXERIQR33HEHv/Ebv3G9h/yOhl0o0HfbLU/Km2kXCuQP7ieqNzAsk/TEBKmuP/tiBU8YxhMe51qXn6/nvDb6ZxcKdGbn8IcHt2wTt9tbrBRxu42Zy92Qvl0JIp1GpNIkjTaqOIxst1CNJoZ3HveWzIUX/OX8nE8SyvNIWj6mmyZeX8Xq27NFgduCqwyouxpcq9JrFwrbfn894/hG43rU6yf1DLh6hcOfOU48PwdKYE9NXjlQbtO+9E9tn4oNTa7dW266ovq6xZu+vn51/uYng4vGnZHNQlYHCCZNDxHrz562/uwAgMzeW+ABHe0v3O+8DB872MFTjesmxp/97GcRQvDv/t2/441vfCNhGHLXXXdx88039/zBX/nKV3jzm9/MyZMnmZiYuO5Of6fjcmTjiRA1GgTrFexcBkyL7J4LanHcapEEIY3pE9ilvh5ZeToJy5WOZ2V1XtjyV79GEiUY6RSpkQs+5MspkE/1Eq2RzeIc2IfyPOJyhWBxFeE6JLNzWwOfruTnfBJQUiFbHeJGCyPtoEoTyBhdUe8pXI6+kUrv0z2+LodnQr1WnodqNXU5cRSy2bh6QlgY0vaJjZzZFwXgbRDQyx5bKlQUEy0sYhaLW/zNV/O8XM8zJdtt/MeO63PP5UndevOFyeX6OiKVvjq/9Q6eNNyRC+/YpPMUBODu4NsGrVaL++67j8985jMsLS2RSqXYu3cvb3vb27jjjjue6e49a3HdxPjs2bPk83l+8Rd/EdAZKg4fPrzFWvG93/u9vP3tb+ff//t/z1/91V/xm7/5m9d72Oc8OgsLBOtl3MEBMuM69dmGMpbbt4/WmTO0z88RrK0RrJdJ2m28hSWsfA5bPUHjzwDsQgF3aAAZxzj5vA4gXFnpEavtFMigVntalmh7Slino3MNI7r/v+hC3sCUU8IQmH1FrIlxVKuFkjwt5/psUnpvFJ6JcxLpNCKXR9VqoATGyMi1EcLC0KW5ia8Cst0mXloGmSAME2tstDdOrsbScL22h2h+gXBmBiOTgVqNZGwEe2qqN7nc8Rg/9XCHLoybYG3tGezJDp5JKKX4pV/6JWZmZnjta1/L3r17aTQaPPbYY2R3nsEr4rqJcbvd5tChQ5jmhaTiBw4c4NFHH2V1dbWXRuPHfuzH+L3f+z3++Z//+XoP+ZxHZ2GB5c/cT9SoYxeKjP7oS8mMj/eUsdaZM3gLS7TOnkdGMYZjUTh0iCTwKdx8BBmG17Sc/HSl3bKyWcxMFsO1iT15yfcXK5Bxu/20LtGaAwNYE5NaDRsewhy4fHDb5VS3J1LjNr5XUmEU+1C+h1HsAwRJvY6wLeLFRcxS8SkjGM+00vtUjLftzumpHNdGNkvq1ptJxkYAgTlwlQF414kN24I1Pq4VWkP0xlRcrpCsr2GNjFz4rN1B1msYxT6s4aHrsj3IdptofkHHA4QROA5JrYE50H5ClXsHNw6pTamronqDxPcxryET1A6+M3Ds2DEeeeQR/uiP/qhXxnkHV4frJsbZbJYoirZ8Njmpy06ePn26R4xN02RiYoKzZ89e7yGvGRMTE5etsPLtiM7sLP7KCrkD+/G6ynFmfLynjLXOnsNfW8dIYoRhI8OQYH0du1AkqjdwBge3XU7ejig8nWm3UiMj5A8dIKrWSE9O9vzRl4OVzV52ifapsFhskJ2NdgF97G3I73aq2xOpcRd/b42NIgyBSKeR7Q7h7BxyeQVSLmYuhzkwcEVy/WxW5y5HSp+u8fZ0HGfj2ivvysvZN/J+iXQahSA6d04r1lIRPHYcWSkT13Wat6Rax56aJJhbIHz0UYgl5mA/6e96MUY286RtD0m5AmHQJdVlDNMg6a7q7ATcPX1w+ksI20Z138ve4iK5y+SE3cH2kFGASuIn3vAphjAtDNt9UvsWCgUMw+CLX/wiR44cIZfLkc/nsW37iXd+juO6ifHU1BQzMzM0m03y+Xzvs4162d/93d/d27bVal2Sym0H14ao0SBYK5P4HrWjj5CZmsIdvKBc2oUC7uAAKozoLC5h2DbF226l9PznYWYyCMPYViG7HFF4KtNuRY0G/soKQM9PPPCiuy6r4l1MpuxCYdsl2isR0+slIJsDjC5Hci+nuj2RGnfx98IQmIM6C0U0P4+slFFRiDAgrlS2VfOuZSn8StfjqVRTr0RKn640b3G7Tbi+jl0sEK6vPyXHeSqsC1czhoUQuki5ECTVKvH8HCpRJGtrOHv3IEwTXJvwkW8RLyxi9PXBegVZr2ENDz0p24Nst4mWlknqdZJKDWFaCNPE6i/pYLxy+Vk/WftOgTBNMhMTtLsiVOfc7A4xvgas/+P/oPHgp0E9C7iKMCi88McY/OE3XPOuU1NTvOMd7+Ad73gHH/nIRwD41Kc+xf79+wGYn5/nB3/wB8lkMkgpGRkZ4bd+67f4/u///l4bzWaT9773vdx///3U63WGhoa4++67+eVf/mVGR0d7bdx55518+MMf7u13//338+u//uu86lWv4r/+1/96nRfh6cd1l4r7nu/5Hnzf57d+67eo1+sA3HzzzQB87GMfIwgCQCdsPn/+PGNjY5dtawdPjLjdxky5DP/A95M7sJ+B735Rz2O8AWEYpMfHGL7n+8gf3E/+4H6sXA47nyc9NnaJQuctLeGvrPQISdJu6SwQXBq4pKTEW1qis7CAt7RE1GjwZBA1GpS/9g1W7v8cy/d/nvLXv0HUaOj8xRf1cWP72qPHqD/6GLVHj/WOa2SzmIODPeKbrK+TlCs9gql8XXVsg4CEp88QnjqDbF9fYZDNJHbjGBu4XLDREwUhiXQaGYQEx44jg3DL9yqIQBiIXA4VxgjD2FbNu1K/NuNK1+Ny13o7bIyfaxkHm8nvxljbaEdJ2bMDJWGEepIT6Sfql5KSYL1M9egjBOvlJ32cK+Fq7sXGNiKbI1lfIymXL9ve5nvmP3acaHbuknGsPE8XJdmzB5REBYEuAqMkBBHJ8ioqiiGIkGGEyGVJqjWwjK5lZ+szdU3nGgTaXmQaWONjKMsmXllBIYiXV2/Ys7eDJ0Zmz+7ev9vnzz+DPfn2w7OGFAMoqfvzJPDBD36Qe++9lze+8Y28733v4/3vfz979uzpfT89Pc2hQ4c4evQo3/zmN3nlK1/J7/zO7/S+r9fr/NzP/Rz1ep2/+Zu/4ejRo3z4wx8mlUpx8uTJXht79uzhzJkzvf3iOObd7343k5OTHDly5En1/ZnGdSvGr3vd6/jwhz/M/fffzxe/+EW+/vWvs3fvXm666Samp6f5qZ/6Kfbv38+Xv/xlhBBbFOQdbI8rqXUbRDVpt8gfOXKJErCRgcLMZkFKUqNjBOtlgtVLy/ZuVu4QBkkQXFJAY3PgkpKS9rlZwvU1gvUK7uAAzuDgk1qGjttt/OVlVJIgbJuoWruiaredkrg5XdvmaHgl9eRABhei8m90yqgrkdzNmSw2K2SX+/zCOXRI1tZ1BoMoRrY7vW2s0RHsXbtIqhWM/n7c227blrhcbQaAi69HUi6TlMs0lcIwjKtSbTfGT7i+BqZF6Y7bsfPb5zXejO0mW5sVZHewn7BagSShfW4WO5+/pvF1NTaJYHWNJAjI7NmNYRiITeXkr/T8XYuSfjX3omd9ODENShPIy1lkknKFeHEBI5UmWllBtZqY1aEtKvPFx7RGR1F+QLy8jDU6jL1vHyqOwbUxDEEcxZj5LM5tt2ENX3uw3waUVCRr68Rra6h2m2R1HaOYx+pmIYrn57d4m3f8xk8tsnt2sxF21z577pnsyrcdCi/8sWcPOe4qxteK5eVl7r33Xn77t3+bn/mZn9l2m+npaW699dbe37fddhsf+tCHen/fe++9TExM8K53vav32cDAAG95y1u2tPGCF7yABx54gPX1dQYHB/noRz/KLbfcwtGjR5+QGH/wgx/kc5/7HLZt88gjjzA8PMwf/uEfsn//fqSU/NVf/RV/+7d/S7Va5Qd/8Ad5xzvegW3bV9zvRuC6ifHQ0BB/9md/xlve8hYajQaO4wDwO7/zO/zCL/wCp0+f5syZMyil6O/v51d/9Vevu9PfydjupQ5seRlfLsL+YqKb3bsH0D+M25GczWSzdeYMMoqvWEAj6XQI19dQShGW18nt34s3P0dUq5HeNUZu/76rJjBKSuJmi87iEgiBlctfotptJiFPlK4tLld0zlhh9gKMzIGBXlS+hB5hkEFItLiMkuqaycDmpewnIrmyXsOQast3VwpCkvUaKgxw9u0jWlhA1mvQ7Z81PETm7u/dEih1OZilItB3xYCvzQRKIYjOzxGvrrB64hSZqQnMdPoJ05tpO8IaScfDW14m8T1MN4X0fexSHwMvuuuqchxfPOlJcllMx3nSdortJlFAz7ajpKT8wNfozM3hLy/Tf9cLe+d4JVK93UTg4tWazXiiidDGNvbYKKrVvCJxlO024bnzRHPzJK02hmliT05eUKKvMPkyshms0WHi5VVQEiNbxCz1EY+OYY2NopTAnbz8eVwNlO+jwhAjkyZqtrDSKUQqjZFOES2tkNRqPW/zTrq2px7ZfXt7/26eOImMYwxrpwre1WDwh99A/7/4V9/WHuPp6WmiKGJqauqy25w4cYLv+q7vAmBlZYX77ruPl770pb2/P/nJT/Lxj3/8isc5ceIEL3zhCymXy5w6dYpsNsuf/dmf8b73vY+f/MmffEJiPDMzw7e+9S3+5E/+hDvvvJO3v/3tvPe97+U973kP73nPezh69Cgf+MAHyGaz/Jt/82/42Mc+xmte85or7ncjcEOelOc///l89rOfZXp6uvfZ7bffzsc+9jE+8IEPMD8/z759+3jDG97A4OBTUJ70OwgXv9T9lRX81fVLXtTbEYWL97VymtT4q+vbkpzNZBPTwkCQ27d3CxnZTBQSP8BbXO4S1g7Vo9/EX1uHKMJIp+i/64UMf//dV6Wybdg9UqMjNE5Mg5Jb1MHtCErfbbf0yM1GuxsqsQwjVJSAIVFxgjk0hDANXS2OC4Qhmp8neuxx4oUFonPnSH/Xi6+aHG/nB91QoyUXgq3i1TW8r34N2dbR+Fd7DKPYh5HNEi0saELTXdru3a/hoR5Rvpr+bVcVrXesTQRKdjzCmRkQJipJiGp1CkcO98bP5dTiuNVCRjHe8jKp0VGiWp1O7TzuQD/+2nqv6uKWfS4aBxsrEQiDxuPTGKmUVmoM40nnHd5OkS5/7Ru0ZmZQCMxUirjVovT822mdOo0zMHBVHueLJwKgrlnN3g7mQD9mdQjZbl9WWU7KFWSthshkMaIIFUZEZ8/hHDp4yfYbE8HN49LIZjEHBnqEWbY7KN8n6VbQS1od4HpyZCuEYyGDEDodork5rIF+4vFxZKOJWSgQ15uI1JMLJNrBtaFw5HAvAE/6Pq2ZUxRu+vZc1n4mYNguPMmgt2cD9u3bh23bvPWtb+Vnf/ZnGRkZoVKp8OCDD/LmN7+ZI0eOMD09zZe//GXe8573UCqV+JEf+ZGecPnAAw8wMTHRI7ZhGHLPPfcQRRFKKb761a/iOA7T09O87nWvY21tjdOnT/Pwww/z0pe+lHa7zcjICH19fVfs56lTp/i1X/s1XvSiFwHwile8gne9612srq7ygQ98gH/8x39kqJt+8GUvexnHjh274n43CjdsCmkYRs9bvIH9+/fzu7/7uzfqEM8JbE65hmkRt7Z/UW9HMrZTVa+kMF9sk2g8Pk31kW9iptM99XYzUWg8Po2Vy5IaGab22DHidouk0yY1PETiB/irq5eoe52FBapHH4FE4gwO4g72k/gBZsrFGRzCX1jALpbIHzpIVK/39t+OoGyQ/KTdwl9dR6qEcPpxhOWglNT+xjBEFYuodgdjeOgSi4MwDFQYYI+PX6LKbsZ2QU5b/KAry0QpB+WHWrVDYI+NYg70I+s1ZLv9hMe4+DjW8BDp73rxE6rClwvAuha7yOY2zHQazjkk62v4loNh21f03G6etBiOQ2ZyEsO2EbZN3GqDEoiLcjxvV5K8fW72go3H90mCgKBcAaUwMxmye/dsKfKyua2LgzY3YztFOqpWMVNpEAqZJIiUi7e4iFMqYaVTPX/7lYqBbJRc78zNYfWVSNqdK6rZGxMVWa+BYeIcOrjtPTWyWayx0d593y5AL1paRnbayGoNBNh79iBSLkYxf8nE7HLHNbJZ4naHZHGRpK0VXpHJEFcqeF/7BlZ/CXN46EllkDAHBjCHholXj4Fl6mdRGMhWnejMGZJmE4HASKdBsSUgVvuqn76Uds8FGI5D4chh6o8+BkDlGw/uEOPnEKampnjve9/Ln/7pn3LfffeRJAmjo6Pcfvvt7N27l3a7zcLCAg8++CCZTOaS/cvlci+jGOj6FF/96lf5/Oc/z7vf/W4cx6HdbjM3N8fhw4dZWVnhC1/4AkePHuXjH/84n/70p6/KXzwzM8O9997b+3t9fZ1SqcQ///M/E4YhP/ZjF2wkSZLwmte85or73SjsrK08y2AXCmT3TPU8lsF6+RL17HLLvRcT3Y0l5Cvlpd34rrOwgLe8jDc/j5nOYD8+jZ3PbyEKdqmE4XvUHz1GVKngDA5iGCbe0jKGaWG4zhYiETUaVI9+k9bMKVKjo3jHjhNW9HlZuTyDd383fXfcTvv8LFG9voWIbEdQNhQ7u1jEm58jqFRJVtfAMBHpDM7BgxBFiEwWkU5tKW4AXTLYVSfD02cwCvlLVNmN7YJjjyO7atpGKV+RTqPCiGDmEYRlgzDAsjD7+4lOTPc8n0axuK3yezGh3a5K2GZVeDsCvFkVlkGI2deHNTqC1Z0EXI2/eLvzc/bsRrVbDBw8SLhWpvLgUexcdlsP+cWTlsJNWl1WUlJ96CjB2tqWcuTb7aOLzlyYcCEEmckJqkcfwS4W9CRpm6pdG0GbG+pv/tCBLZaNzRPG9KZAXyOdIpidRdg2xVtuJjM5QVCuEpbLBGtrxB2P7J4phGH0/r/dRDJ/cD+tM2cI19aQnk/UaPSOc/H9Up6nJ0l+0AuqM7KZbYlvvLSM8j3iSg3l+1tIovI8BAr31tuITp8GQ2AU+xCui6w3CWv1LRktlOeRrK6StNuoZqt3XNnu9FYyVCJBKYThICsVVL2OCnx9vPGxa/YAG9kszp7dyGoVw00h2y1EaQDV6iA7HsJNIWtVQF4IiAX8xy4tm72DG4P+F9/VI8blr/wzu1//rxDiMj65HXzH4SUveQkveclLtv3u2LFjjI6ObkuKAcbGxlhcXEQptWXMnDhxgkOHDvX+vaEKHzp0iLe85S28+c1vplQqMT09/YTEeG1tjVqttoXQ/tM//RP33HMP9XqdV77ylfyX//Jfrmm/G4VrIsZvfetbr/uAQgje+c53Xnc738lIOh2k55OZmiSq18luiiSFKy/3bvz/WnK0dhYWWP0/X6Rz+iyYJmbK7QXDpcfGehaGuN2mM79A7PlIpfDm5rEG+rG6y9/B0qom0JuWnkli0qOjtGfniDsdonIZI+USrK7iDA4w/uMvIzUycomivUHyN1sndCaBCq0zZxGGRSI1CSaJEa4FUYT0fMyBErKs00/JLhHZrKIpwMgXuirahR+GzX7laHZOl36u1reUfpZhiPJ9SBvElSpWqY9kZRmU6HlEzfGxS5Tf7WwYSblMPD+HcFKobpWwJ0o5t6EKK9MinP4WwnEw+3UOWgAMMPr6sCfGt7S1mbAl25yfOdCP0T+At7BEsLysCeK+vbBNKrOLJy0bqm3UaGBm0tiFAmZmKym/eB93cIC41daZKICk1STueNiFIu3zc4T1GokfELfal6Rz26z+bg7avJI/2EylSQ2PYKbTFG46QmZ8HG9piXqr2fPYh9UKpuNc8ZmxCwXSI8NEqRRRrUZz5hTpsTGklJfcLyUVsuMTr61hDQ+jpNxWxd+8ErF5guUc0IG1uuKigWq3sPfswSgWIQp0+7XapWkBpSKuVEhWV3WRGM+/QNK7Kxnh+fOYfcUuaXUxBweQ1SpqZOhJe4BFKoWRyyGjCLNYxCwWUe0WKg5RYQBKES+tYA0NXwiI3a5s9g5uCAa+57s5++fvB8BfXqE5fWJHNd4BoD3IVwpUu+eee7j33nt597vfzZve9CbS6TQzMzN8/vOf7xULmZ6e5vDhw4Au6vb+97+fO++8E4CTJ0/y8z//87323va2twFsSd02MzODaZp8+tOf5pWvfCWf+MQnOH78OPfeey/Hjx/nL/7iLzh9+jT79++nWq3y2GOPcffdd19xvxuFayLGf/d3f6dzZKprrym8sd8OMd4eG0rXRuYHb2GBxsxpslMTZHZPEaxXehaC7J6pS9TUzUrZBnG2CwU6s3P4w4OXJcYbqq43vwCWSVxrYKZccgf299r1V1ZoTJ/Am5snqDW0L9EwMEp92PkcMoy0iruwQOXBo710a0pKME0wDNITE4TVKnGtjr+8ij0wAEncI9/AFoV7A+3zs0TVGnapj+xunbM5t38v7fNz2qbg+zp4z00TLS4TLy8jHAfDNgGB7Pg9L63yPUQuh1ASZ99uVBT1yMQWJbbVRnoehpRIKZFeRwftdTzwfVQsSc7PYhQKWH19WJMTGPnCFo+ogF5xjnh1jWh2FlmtY+/bc4HEIFBhDElHK3iboh4vZ4vYUIXj8+dRQYg1MkpSbxCeP0eytNLzNZul0mWLioACoVBRjAo8pNfBpB/CkM7sLHGtjj3Qjzc3T/7mI1sC0zbG2MWTlt79k5LCkcPbTtg272Pn87oYzZkztE6f1aQ6labvBbfTOT+H8gOUlJfkGLayWexSiaAbNJienOz173K5ieN2m6TTITM1QVRvIAyjN66jRpPE88G0IEmeMOCvR/AXl0hPTkKiV2aklFvuVzQ/T7JW1llXHAdhGL0MKRejd0/nZlFegLFbVzxMymWSan2TVWeMpN0hPDGNMCxEIY8QxpYVAtluI+s1hJPSaeK8AJFO6UmRVOA4hGfOIPJ53Nuehwo8AstGdtqYw8M4h488KTuDbLcJz54jWlyCMMQYHEI4NtbofuK1dZTvY+3dg8jnsUaHLwTEXk/Z7B1cEe7AAIVbb6HxmPZlLv7d3+8Q4x0AmtQeOHDgst/ncjn+8i//knvvvZeXvOQlWJbF5OQkL3/5y3n1q1/da2ODGFuWxfd8z/cA9GpYbFaMl5eXednLXrblGCdPnuSnf/qn+Yd/+Ad+//d/n+c973m8//3vJ5fL8aIXvYjXve51vOENb6DRaDAwMMDP/dzPcffdd19xvxuFayLGr3zlK3eWYp4CbPbhYpok7TZGKkU0N08HMFMpDNvuBcYJw9jioQQu8W8mQUDty19B2DZ2f+kSL+YGyYlbLUhislOTtGfnyN10mP47nk9u/75eu/7CAq3zczj5HHYuTbCcIKMEw7JJT0wQrKziLSzgDg5iWGaP4LbPzUKSYGaz9B3cT/1bx/AWFkg5Y1jZDHa/Tgt3sQ95IxNH/dgx6seO4xTy+GvrvfRw4foaMklASazBQeJaHel7iFarG6CUhlwOc6DUW7ZVUmnC22ohHJek1d5CVDardnJ5BZUkxJUKwhCEp8+RrKwi2x3i9XVkq4mwbV0YQSiMdAojnUJ6PsZGlbqz55CVsg4K7EbsK88j6XSwx0Y1GZIK4Tg9S4PYVLa1Z9s4dhyzVOr1c8OPmjTrsLBANHten896jaTewNk9tcXXnGxTBlik0hiZLPHqKsLRy/FJuoJsNTGFgRIQ1Wpkp6bIHzygVdpms+cJ3hhjm/3efbfdckV/7gYu3kf7iz1So6O0Tp0iWF7FzmUxJidoz86RnhhHSbmFlA+8+C6ye3S09eZxraTEW1ii+sgjWJkc+SOHSI+N9XIWt86c0dUfGw3qjx2nNTNDEkZkJsYpHjlEsF65bN83H790x+2A6o1XK5tFSrkly0e8sES8soLZP4DZ34+9ZxJr1y7g0mqJ2m5TRM2eRylFdO489tQkIDTJzeVQ5QqRAdHJ08RrqxjZHPauXbi33YyRyfTGR3DsceKlJZK1VbBtjGwaa2Kidyx7eJjEtjEyWVTgY6QzpF5wJ0TBJb72aymIozxPF6DxPD3W11Yxc1lUu4Vz6CCq3UGhMPv7e6XULy6bLVIplOf1/N47uH7s+olX9Ihx+atfw+8Gyu7guY13vOMdT7jN/v37+fM///NrbkMIwdGjR3t/x3HM6uoqr3rVq7Zsd+rUKW699VZ+7/d+b9t23vSmN/GmN73pks+faL8bgWsixt+OFUye7djsw7VLJVQcIwyTsFzBzOUwXJuwVsPp66MxfQK71Lel8hugU1x1rRX148eJajX8Na2Yud3l8dpjx0kNDfR8n5szTcgoBsOgcMvNW1JQbbSbmZqkMXOK1ly160u0SO8axjBN+m67BfNFL6Ty4FEMyyQ9MUHUaNB4/ATB2hrFm2/qkXkj5eAO9JOEIenRMfIHD9A8dYqV+z9HuF4hMzVFWKvjLS7iLy9BIgkrVSw31QvmsrJp2mdbXW/oulbqvA6J70EYguvol7AhCM/PYw0NkLQ6xCsrxGurEEus0VGcPbu3+Dg355NVXtAlsxHS85BegD01gazVUUmMNTZGvLYGgd/LPat8j6RWR6QzXTtGGaEUcbWCEAbOvr0Eq2sY2SZK6XsgDIE1NIDYuxvVaiEM0SMjSatDtLqKajaRUYS1VsbsEvx4aRnVbCFsB3N0jGR9nXh1GdlsEZycwSj1YRT7LlQj25Qqa2N/UAjTwjl4AJIY6XVQUULcamI4DqbtkJkcpzM3T1StgRC9yVnrzBnCWo2oUtkSNJkeGyO7Z4pgvdyrxugtLemVh2aT5omZLWMibrdxBwcQwqD8ta8BgtbZcxSOHNY+2nQKw7KoPnQUGYYYtt2bOOUPHrzkWQrW1vDXV0k8n6TVof7oMdJjYwjDwB3sJ7d/L1G9TuIHPTuGmU6BUr3CMpdLg1j+2jeIqlXsUomBF9/F8D13b9lWSrkly0d07hzmwABJuYw9eYEUb+ddj1fXCKdPkNQamH19YJlYo8MoqYiWVpCdswiZIMo5orU1hGWRrK0hXIdUVylWnkc4v0R4ckYHvQUB7p7dGCkXM6ftQkm5ggoDrF1jhKdOES0vYaTSPW/v1ZQ1vxx6tpFKVQdvGgbGYAlnfFyfx7nzJOV1VLuNbHf0Pl3SbU9NbTleTQmGvncn3/2NQP8LX0BqbBR/aRmkZP5/fZIDv/orz3S3dvAcgmVZfOpTn7rk85mZGX7iJ37imtt7svtdC3aC755hbPhwnVKJ+rHj2IU8mT17cEdHaJ0+Q7hexrBsYtfVeULdS1PIbCh19ePHaZ48BVIStduYmTSts2cRtk2wsopwbNzBAdKjo8TtNqmRYVqnjmLl89ilEvmD+3vLzJsj9Nvnz5O0O0jf0wTFMjVRymawsllSIyMMvEgXSFBSsv7lBwjW14nbHaJmk9TwMMH6OkhF6c47qD50FMO2qH3zUSpf+wbtxUWIY7yVZcxMWpPROMEdHMLp70MpiXBc6o8dJ6o3aJ85A5ZN1GiQxIkmE6mUVsmSBCOf08E+jQYqlyWenydpNjGyeTZsBEbmQgBc7wU9NoqslMFxCRfmIYgwSn0oPyBZW8Ma20XSbmsyFUcIN9VLh2TkciTnZzGl1Kpys41IuXobzyOYPqnTkNkOKgguKHFFvWxuFPs0Gf7mo1pxi2NUx8PZt4/w/HnCE9OYfX268IfnoxKJCkLipWWtgmfSyFYLM5fDHh7GyGZ6QVvO4SMkK7rAgzAEyvewJqeQnU5Xkcwj602EaYAQyCDAtG3ac/PEzSZOIU9Yb5KZGKd15gzewhJRq0XcahFUKhRvublnu9lQlYPVNe0MkZLED2idPaftD2GIDAKy+/f3VNn05Dj+2gqpXeMEy9pqkT9yRPuCR4ZZ+9JXiDsd0mOjJL5Pbt+ebTNV1B87TrCyigwjzEya5swpcgf2kdu3D2dwqJd/2Ey529oxNiabG1XzNj7zV1ZozcxgptIE69rKlD948JI+bOSoFu22riZHDWNyEufQQYxsluDESYLjx8EwQC5gFAuYpRL+w48QLS3pidTKii7bnEoTPPoYqtlEOA7ECWY+S7gooRV0lVddUS9cWkbWa4Sz8yTVqv6NME1IYoziSM9isTFJipdWUHGMUcjr36Bu8Y/NnvR4cZGkXsce33VJhpPtgkjjpWWEZWKkUnqFw7GxSv0XCsjUG3q8rld0NT5ET0FO3XrzVutQu3VDflt3oMtDj//UKzn9//3vAKx+7vNM/uyrexPXHezgmcKpU6fY9yRKlT/Z/a4FTysx/tKXvkS5XOaVr3zl03nYZzWsbBZncIjWmbPErTZmJkNULlO87VZMR2d5aJ4+TXDqFJmxXXjz8/grK9umXZNBQOf8HJndU5S//g1UEJKenCSqVBCmIKpW8ebm6AwO4PSViBoNTQwmxqk98i1q33wEt9RP7uBBBl58Vy9DRvPEScJaDTPtEjWapMfHIInJjI9jZjJbbBzCgKhRJ7tnN5UHHyZYWyeq1wmrNVQcay9pNkv+0EHWvvRlgkoF07JIwhCZJMh6U7+0Ha2UZ6YmEI6jva/NNoZjE5QrCNPEsCzNvUIfwxA6d3EcgWljDg6Q1GoIx0J5HobjkHSqW7yMF6e1MgYGtNo3twBRjHBdlB9gFPKYI6MYxQJGsUBSrSPbHlYqTVKrYTmOVnwdh6RS00FHcYJKIgSgUmkdZJRKEc3PI0yTpNXBBKyxUU1WpcJ/6CjBiZM6INC2EZZNtLDQ9ahamIODxAsLkCTIZhN7apJ4dQXRUlqlA6xdYwjH7hEXkUqj2i3MwaHeEvbGZ9bEpJ4MeB7x/DxmqYTZaGCmdQCdCgJUFIESmI5N7sA+EAZRo4mZShGlHMAApWidPUfcauEvLpGZmqRzfhaEoHDkMGtf/jLts2cxbYegou0K/S++C9ArFyqOkVFC7eFHMCyL1pmz5A8dwBkcpDM7h1IKwzR1oNvkRC+V3GZ7g7+ygr+4hEokYa0K9TqJ57H6f7+MOzR0UaaXCpmpCRACgSbmG3aRpNOhMX1ST3ZSLoUjh4lbbRRC+7K7PvArVcDbrshGvLpG8NhxoqVlSCTCsgimT2Lmc0RLi6ggImm1sEp9ehxVq3qiZxjElTLCslGr6zotXiqFkctiDQ0CouedR0msgX5ks4Uzvgv3llt6qyLJ+npvkhTPzQKCpF5D1psYxWKv4h5oVTspryM7OkuFWSzqynbr6yipCE+cJF5dxchkSb3gjt5ky96/X3vzsxnMPh0xLtttvWKzuEhS1Tan8NRp/Yxns8Qrq5h9BeyJCb1ic+4cHLh0NWAHTx7D/+IHmPvbjxCWy6g4ZuETn2TfG9/wTHdrB89xPPTQQ0/rfteCayLGL3rRi7jjjjv40z/9022//8Y3vkE+n79smo73ve99HD16dIcYb4JdKOAO9uOtrxM1GkjfI2m2yB3Yj5FK0ThxAn91laQbZOZcJlefXSiQP3yQ9tlzeIuLZCcncQYHMGyb0HUJazXiVgsrl9O5W7NZsvv3E5bXKf/zV2mcOIEMQqxcjrBW63k4G8enaZ09S1itolYjSBI6swnZPVNk9+1BGEYvhVq4voYzOAimSXP6BMLWKdz8pWWsfB7TTeH092OkUjRPzCCDCIQg8TwwTR2gKbSnOvE8nFye9NQk3rlZEi/QwYlNiZlOk3Q6KGXoJWrDwEilcI8c0jYDmaBiCWFIMHMas9RH6gUvwDFgc77UaHaOeHEBlUhks4lYWUE2W4hMCtO2tTruOLqKXqkPhCBeWSWcnYVmC+V5mMNDWBNjWAMDkC8QPvqoVsWSGCObR4WBLrFcr6P8AGRCvLaO99WvacWwvx9n7x7i5WWihQVta2g0MQf7cW+7CTOTAdtF1usk6+s6z+2Qg+y0SOp1HTSWySBbbYxiASGMXiDWhnc1bjXZSCt8MWkDiB47rpXE1XUKxSKgiXqmWw1Nej7pyYle+fFgdY3q0UcIy+uYmSxrX/pnTNchCUJM16F56hTu8Aip4SHt2c0XEKZFWK/r7CXrZSoPPkzx5ptI2i3coSGd7SOOtQe2pS0+2T1TenyEEf7iArmDB3GKhd6qxuYJmZVJo4SBlcuS+B5Kaf9x0m4TrJdJDQ9BIrGLBbz5ebylRcLVNZIwojlzCqe/pAmwknRm53AHBwjWy0S1OnaxiOm6JEGAlc/Rnp2lMX0S072QwWKjPPl2eXllu014coakUtEp/gyFyGchjvS4U4K4pi0IzpHDCMtEBQHCchB9LpZSiGIRa2iAeHYe+8A+VKeDUdxYATFQrRZGJoPseDr4sr//EqtQb0K0axxrbJR4eZl4YRF7cqLX73h5heD4NEahgAovpAO8kE6uSnjqtLYtJQkKSL/gDkQqjayUsYaGMAYHIAiJzp0jnDlF0uogPQ9lGKhKFdW18cTVKoZlEZ45j1nq18+/fkR3cANh2Dbjr/pJzv75/wBg5bP3M/Hqn8bpKz7DPdvBDp6duCZi3Gg0aLUuv8z1+te/nhe+8IX8zd/8zXV37LmEoFxFttpYqRRx4JMEPu3zcwSVMuEGyTIt4mab/MEDW/LDbkTX+6trCEOQO3wAFcakx8d6nkklJcHaGvXHjuMvLhO3WqTHx+m79WadceLY4xiWjTAMZBgSd7QHcCM1llMsYqZc4iAAKZGdDp35RRrHp7Gy2V4KNdNNgWHqdFa5PCAJ18q4Q4OEa+sYKQcZhcTtDqZjg4DM5ATt8+eRUaxTcBkGVjqFigsUbj6CgUHUaRPVa0Stts6tWywihocJK2WSMMQo9WEND+usEIUCVl+RpN4gqVQwXBcZxQgD7G55zHh1jfDMGZKVdZJKhaTexBwcJFxc0rlcOz64WrEVjoMwTcLZOQh87SOOE8hmNOnNprEnJnQJ6JVVZNC1QbRa4DjIZhPiGCyd9UCktA0jmp3FHh/X6eNaLVQYoMIQUq7OY9vXh3vgwIUiCAZAHyKVIpg+Qby8imy2wNT+ZZTCPrAPq1Rig1nEq2v4Dz1EvLyqyVazQerO528pS71ZSUxWlhl88Ys0kfc8MlNT2Pn8Jcpo4eYjtOfmtDqYSuGvrJAeO0Dj8ROoYp6k0QIFqeFBsnv3ULjlZhLfp/qNh7Tam+hiMmG5gpFN0z5zlqBShTimc+4c6YldqCSmfW6WcH2NOPCx8gWcYoH0xMS2ZaRTw4MUjhyk6rWRYUDih0TNJu7gIO7gwJYAPGFYCMsEmaCSmGC1jpnNEJbLpKcmkFFE4nnErRZRo0Fndh4MSMKYpHOe5vFpQDHywz9E0m4Rt9uYuVwvL/VGXl5rZBh7d7ckq0x00GSrjQDMbjU6FUQkjQaGmwIBstHA2rULa3QU5QfIZgNraKi7euFhFAuoKO7ZX2Strqv5jYzo4L9yeQvR3Qg8FYborU5sLhUtPZ94ZQVsh/DkaYLTp0nW1jFyeuXD7Cto73u9BrZNsqL99KJbFUy12722w2YTbIFqtpCeD0rqbCxtD+E6qHpdT2L7ishWC6IYo1hA1us9D7JR7CPpepB3cOMw8sM/xPxHPkZUryPDkOVPfZqpn3vNM92tHezgWYkbbqV4MqncnsvoLCzgLy4iTAuRcjFRWMUiSeDjzy0QdTo6JZlh4A4OkgT6hQ/gr6xQfeSb1L71GMHKajeHbJHiLTdhuC7psbFeKrTM+Dju0BArX/g/JM0WdO9TamSE7L69tOdmiRstzEyG/JHDPfJtl0oYi4uY6YyuatZdxlZRiL+0jDe/QBIGZHfvJqhU8FdX6bv1FqJ6HXd4iNYpHail4pi42UJ6HsHyMsXbbqV97hwyCHH7+wkrVdJj2vucP3wYp69I8eabqB8/rsl6s6WJe5wQdToI38OwbYz9+8A0sXdPAmjCWKshW22EbSPSKYwgBHRgWzQ/T/DY48hGA+l52JOTqDiGKMQAjIEhos4cZiaLklJbJ9bXEVLq7ABhSFKpQgSkUqgwIZydR5bLOrgvSZDVqlaXl5dBGDrjQBiAYaA8Xyu9KKKlZYxsBpHO4uzfR1wuozoeoqv4wTZlnkt9yFpN58QVQL1BdPYs1vgEyg8JZ86AbWF2A+aSag3DdUh8n3B2FqNYwNl/oerYRo5cWSkj3BRmOo2/sNjND9xh4EV3bSmUETUaBOtlDNMiNTaKt7iIkU7jr6yiZEJUrmC4KaxcFukHvbLSbrEPu78P2fEJ6nWMVouoUgbTRoYBKImKY8xMBjOdQQYB3vw87XPn6cyexxkYxMprZVhnyDiPt7BAWK3hdK9V/tBBZBDSmZsnWF/HKfXpXMxAsF7GymXJ7d9L4+QM/soqSaOpq+AZBu0zZxGmiQwi0iOjxJ0WSRhSP3YcGQSkRkeRQUCwtkZq1y6iep3G9An6nve8C+kSFxdJKhWdlzoKCc+fR4UBIpfX9w5IHTmEsB1kFIFpkTTXUYGPcFwwdMW4jfzF1ugwjI7obA2+Tu/npFI6U8r8EvHceayxXdBpk6xFIBNkp0Nw+gzCcVBhBEqS1PTKgjBNnCOH9apOFxsqrep0iJZX9G9NFCFrdbAsonIVVlb0GK83UDIBx9Xk3LYw+vr0yoPnIWxLZ4lZWOgVGUEBUYQyDFASI5MDKbEGBvQ5OQ5xrY46eZK4WkNISbtbQGAHNw6m67LrJ17B+b/+IAAr93+OyX/5MwjTfIZ7toMdPPuwE3z3DGP5M/cTrK9jmCZm/wB2UVeba585qz23nqcJnmFg2BbB8gorX/g/WKk0Ya1G4/ETRJUKSaejX4yej7r5SE/J2lwRrH1+jnC9gum61B87hpXN0H/XCxn70R/GKfXRWVggMzHOwItetEUdNLNZUmNjrH7xSwTLy2hFUhA2m1QefoSwUqEzN49TKmHYNpWHjvaW4Q3XwXRc4ijWq76WjbAt/LU1zGwWd3SUYHVVpy3rKpC5vXsIG3VdnjqVxunrI8qVSaKIuNUi6XQwM2kEAlEu4x48iDkwoAOElNT5W4MAMTQIKIyREZRUeF/9OvHyMkm1hj0xTry6Rry02C1nO6TTsZXXNUkTQqtbroPo5mpOmk2MdAZzdwEZxyjfJ5qfI6lWsEbHsEZGCM+e1YqcbSOTGOIYs1jATCKUMFHttl5STxJUvY4EndGiUtEkJwyxJyeIl5YJHp8Gy0GWL6Rbg6LOfNFuQ6sNtgVumrhcQVYrqDjB3qvJoFHMQ5IQlctatY5jguPTyHoDc3iIZHUNFQZIP9TkzLSoPfiw9n27Dq1zs7iDA5Se//zeykT7/CzewiKNkzOYto1TGqDvBbejwpjmqdOoUPvcZRhil/rwlpZon5ulMz+HlUrhlaskXodESqxsDhl7WCkXw7RIzAS7WOhW0VM0T5ykMX0ClEJGCTJJdOnoVhuvW9nNSKXIHzqg1cl6k7Bew7AtZBhiFQoknU43FWBC3Grjs4r0tL3FGhslWF5GCYVdyGO4KdITY5iZFO1TZyCRmJk0QbVGfPacDp4EolodK5+jcPCgTlu3skL9+OOE586R1Bv6+fB8kDEY2hZh75nSdoL5JWQYIGt1RMolml/Qtpx0jCgWuvYItlQ3JIr1ZKdYxDmwD9nuEJ0+RTg7TzhzBntqEnN4CJHJktRmkG0fYQiSbBb38CGdISWWSL9DUq9jZHT58Y3nxd6zh/DkST1GkgSU0uPNEISP6mDQpNbA7C9hZrOoKAQMzHwOI68tJJurLuKmQNaIKlXodMAQEIb62U+nwLIw+orEyx7J0jIIgWo0wBAI2yHutJ+On97nHIZ/6AeZ/fD/DxXHhJUKjekTFG+5+Znu1g528KzDDjF+hhGW13EG+vEXlzAcG6TSUfXpNFY2IGo29axeoFO5mQaN49MYpomVzxG3WsgoQsYxYbWmPZBnzuAO3rWlMEPt0WO0z5zGX13Vama1ShlddKVw0xHMTJbMrl2gBK0zZ3RGikymt5ztLy1jWDZmKo1CUbj5JgzHJWo2KNx0E62ZGQzHpnDoIJ2FBZ2G7uFHCMplUkNDRI0GmNoDWrz1VmQY9nyvuQMHsAurxJ6HnS/grazgzc8jw5j0xLhWrTc8npk0SZcsSMAMgl7pZwk6OOzcOYx8AefI7guBbY8+RnjihFZHOx3ixSWMfA7n4EFUnCBMA7NfF8UIz57Vns1CAXOku/xcryObTYxSCau/pIOpFhcRhtm1bDgYuSncAweQQaiD4praToFSmP0633Li+1p1t22wLKyhQcxCHntsBBlL4tnzBMdPEJfXEaaFiiMMxyFaXMYe34WSYI0MYe3ahWw0SWo1VKejA+UcG0xBsryM2VfESKV1Vbv+EtHcPEYqBXFCeP48xuoq8coqwnWJ19cQCMz+flqdDggIY0ncblE/dhx3aIj2uVn8hQU6i0sYlonseKSmBkiNDmPncsQdn/TYKMgEd3SU/P59KCVZ+MT/JlheIe5OegzLQpgWZsokaumVCxXrdIF2XxEjk0HFCf6iznwhDIGU6OfAsogGGjogzw+QUhLV6qgw1JaKhXmiZpOo0cQpFolrdT2OE9nzR1v5AokfYKZdOnPzJGGIEFB/7DjO0AAqSZB+oFOieR2SVgvTthGmibAsncrOscnu3YORTrH6hf9LWC7jLa8giwWII6yBQRLLIl5dJXnsGFZ/PyKfR66sEq+tIRyHaG1VT27anh4PcYxhO4AgPH2GeHERo5AnnJlBKLAmJ0mgV8EuaTQQloms1kgqZcy+PoKT3yReWdME17H1RCqVgigmabYwh4eRzSbxyvKWEuLxwgIgEJalM2ZkUmDbmI6F8kNEJo3yV0jWI1Qni5HLI1I2zv69JJUK8eIi1q5dvWqO0fIq0fIK+H43haKLMAXG0BD4AWY6hWE7WKUB4igBJEpqW4bqs5/23+DnCpy+IoWbb6L+rUcBaJ2c2SHG3+FotVrcd999fOYzn2FpaYlUKsXevXt529vexh133PFMd+9Zix1i/AwjCUI6jz6GDCPc/AgqDIg8D8OxsItFrHxeV5brL6KiBH9xmajT0dkrGg0Mx9Gk2RC6HLLjouIEd3BgSxndpN0if/AgnbkFwnoNd0inQouqNYL1cq9SXvmrX0PGMWYmS2p4CMO2sYtFgnIZK+3iHNxPUKli5XI6vVitTu2b3yQ9OgoIGtMnULEkqtYxXFun9mo2Kd50E8IwyB85DFJSf+wY2alJnf921xim4+AODtBZWKRz7pxWBj0fFUeY2TSpsRGMTFqnGAsqJL6PMzCAlIqkWkH5HtHSCvHCgral5PIY3XLQyfo6hAFGKq2j4ftL2OPjKAQqTpCNOuHCAqpe15YHYWANDYEwEJahU8AN9CPW13Emx5GtFkY2jXBdTWiyWUinMUtF7KkpjGxGk5uFRcyhQZK1NVSUYJgGzq4xkmpdJ3OItDpn5PJgu0SPf4u4XCZeLyMSiVHq057mwQFUo0acTmlvpmlBGIBlYuSyGH19xGfPoTqxJpr9AxgDAyS1OiqOSFptPXlaW4e1NYxCEfokSaWsi8r4Aco0SaREplPYhSKds+ew0mm8xSU6szoFmzM4QGP6BDKKSI2NkHQ8nWXi/34ZZILpphj47heT278Pu1Bg7mP/C29+HmFaekXDEHpChEJJcEol7c9Np5AdD9N1SQ8N4i+tUHv0MVSSYPf1ETd0Ro/0+Bje+TldmMbrQBTjjgyTBAGVh45i5/OUXnAnjWOPY5f6SI2Okt41ire4ROvMWZzBIdzBftpnzxFWa/r+AnGzTdRs6Gel1cZMp0kNDmBkstjZDEG5QhIEGLEOFnUH+olbbVb+6fN4S8uYjkPieShTW2VkuoNqtjC6WU2SWh35jYd0qroo0uqoTCAI9PW3bZ0hI5chOnNOV82rNwCFsG3MfIFocRF7bAwlFUaxT6votRpGqQ8wSBq6wAtJom0N6ZS2L3Q6KNtGdVPBGSmXaG4Rs9iHOdDf8wYnrQ5JrY6ZL6BSaZz9ezHHxggePqqDQk0LpQyUAmtsjKRaIZqbQ0UxSbNNePoc1u4pCEOSpSWSyromxVICCkxbj7Mg1BUkTQuppPYeJ4n232cykEgMa4ccP1XYnKYt2Sm//R0NpRS/9Eu/xMzMDK997WvZu3cvjUaDxx57jOyTqG75XMIOMX6GkT90kNzB/bRPn0NFEUnHI7VrDOn7Oo9vSS9fZsZ3UX/sGEE20yvekZ6YAARho07c8UAInb+4WtlyjI18xFGjQfHWW/DX1/DmFwkrNZyBgW6QUVP7LqMEy3UhifFXVrH7+kh8H3dgAG9VB5fl9+/HKZWozc5j2DZISXbPbu3JdR3aZ88TVKsYLYEwBKbtIrplod3BAaoPHaU5M0Pi+Vj5PHFT+zmDsrZ5CMNCYJC0O9iFAsHyKpnJSZyiwBofI3foEI3jx3BHhvCkIjpznri8Rjy/pFNWjYxiZDK94KOk1dHFOgIfw3Fwdu/BKOT1UnXHRwYRwvd1sRApdXBQp41RGtD5glsd/Xk2S1yuorwOIp3BGhnueXSRClmtEybnsMdGsUZHQWmbhJEv6Kp4hiBZW8fZtwdz1xjx4nKvcEk8v0BSb2D1DxAvLKEsi2R1TS87uy5JHGMWCjq4atcYiePgjJaI19e1X9xx9JJ1p4PyQ+Jz2t9q9Q/ojBWmhUxbsL6ODAJkuaxJi0BbBKTuq4wTZBhqZRuFWlsnLFdQSuGdOg2miSEMDNsmkYqk1SasVOi74/kXCCd6lSKs1ZFRjOxoOxCAO9CPmcvqSVwuh7+4iAwChG2j4ohgrYxVLGAX8jovru1g7NE/U3GrDUKQO7CvO15XdM5nw9AZV9IpVBSTP3wId2gAw3XxFpdI2h3MbJbsnimEYWDlMjgDB/EWFvFRqDhCtCxkGGi/rZQESuGUdDaK/397Zx4gV1Wm/d9da6/q6n3fknR2QtiigLK4IOOGIzIoguMyjILjMjjziaJ+6jA6LvMpiuiAyqDooIiMCiogoiCyEyAJnT3pTqe36u6qrr3u9v1xuird6e5shCxwfv+kU/feqlOnbnU/5z3v+7yqYaAYBk42i2c7hBd0kd+1W6REFAoitUDTwfVQYzG0eBWlXbugJFxctEgEe2xMCMWyWPT7AQWmPIfV2mq0SIxS306csQlxjuuid9bjFgsoKKIb4+AQelMjRmMTbmpSvIbPh5sT41CiEWGxp6oopoGdTKGoqhij56HEq7D7+ykqoDc3o8WrpjyEc7hTRaAYBl6xiF5TjRUKiaLQQnGqdXoOu78fNV6FVlOLPZrAGRvDTSWxh4cxmptRo1HxndB1cF3Roj0SAUekhAifbgtfzyK0WAw3NSmcPFSV0tZt+KZ135McZhS18mPZ9lAyG6dYxLPsoz0MFENHm6N3wYGwfv161q5dy7e+9S1e//rXH+aRvbSRwvgoY1ZXY01MEFu5HLOmmsnejWS2bkPxPFTTR6ClBX9DHVowiL+xkeLYGFowgBYM4eQLlCYmsLMZ3GIBbBvP83BK1ozXKPsclx0qJp58muLQCHY+x/jTa1HWrsUIhgl2tOFvrCf9/PNY6SyazySyuAejqYnG81+Pk88LG7Xqakbu/xNWKokRjYFu4Cke+eFhrPEJ7LzIcbRKFpHFPZhVVUSWLCbc1YmdzQrRX1NLfnCQ4tAwpfFx0byhWEJvbsKMV+FVxdDCIZycaCpSHB8XoramBlXXKY7Wi/bkiif+0JaFgenDSU6gVkUobd6GWyhgDQ7ijI2jeB5KXS1qbS0U86jVNTgTW3HT6UqxkWqaqD7hE6tGo1jbtwthGQ5jdHaiBoV3sdHSjOozIODH6hvAm5jAyWRwx8bwMmm02jr0pkYhNvMFvP4Bkb88lUepKKrwe62uprSxF0U3oFQUBXl+vxhjqYBaUy0s2yZ9wmLN9OGWbNRgEDudBVVHMQ20qhhuKoUSiaIGg5S2b8ct5sUiwx/AUxVIJkVEUVFEGksgAGVR5zigm1jJJG4+i+b3oZomXkkUs+mRCB4Kqq5RGB7FzqYxIlH0eBXFiQmSz60D1yO/axdjjoMeDqLqBpHFPWR37ETRVVTDxLMsvEIRX30dgaYmzKoYma1bMaJRtEAQX00cp1DCcz2MWBW+6rgoIiwUCDS3kN6yaarJjI6/vl64PPhNNJ8P17LQwkGcXJ7UuucpDA2hqCqh7q6KbZvm92Fncli7B9F8fsKLFpLZAlahCJ6HncmgFA0826b+5LPAdnGsEpmtW7HTaTxVJbN1O6rfj53N4zkOWjCIWV+L09aKl8lR6tuFomqoDdXCcUSobZFa4PdXrM5QEV3umpvxrToBigXcySTO4JAo9LQdcb+oOtiWaJaSSqEG/SiGga9nIfbomOh0GIlg9fejFIooDXWYCxbhZTOiK+KEcPzA8/ByOVzXxdBU0dzFb2KPjwthahh4+QKqz09pYDeAcKxwXbH4si3UQAC9vR3F70ONRfB2DeCMT4ic5EIez7WhUEKLxcTnNjYuFok+P24ugzeRxE2lcCcnUcMRjMZGtHgcz/Mobd6El8uTWr/hSP8aftmgqHuEMbJQfk623fQDBu/6baXQ/KiiqjS98fxD8p2ORqOoqsqf//xnlixZQjgcJhKJYBhyR2Z/SGF8lCkMD2On0wRaW6hauQJFVSgOjxBeuIDs9h1kd/bh5LJooTBmTRw9GkMPh0FRmNzwvGhxWyoJsaNpYuvVMCv5u2XKXb3yg4O4hQJmPE5xdIT84DCqrmPXVONrrMeMRqe2u11RaZ/OYPknUFSV+IknApDevJni+DjKVMMGf0sz1mQaJ53GKZZwsxn0mhpUVeQtliPFZWFuxONkd/bhWRZaJIxTKJDr60cLhwgv6MaenCTY2QmuS+LhR1A0heLYOIGmpinf5xpAwVdfx+4Nz4uc4YkJKJbwHBclUifa045sEcVlowlR7DaVT2sP7RYR9F2i/TOaKqJjqSSeDapt42YzwrUhn5+qsB/FKxSEo4PfX/EUVvw+rNJ2PNehtG0beiyGvmKZ6A42ld7hDA1hDY2g4KHV1WElEuL5C0XciSReycZoahY5rFUxMSbFQwlHMLs6xfPs7J+K5pmYnR24+TzWtm24hSJOYgwAJRjCsy3siXFRWIWCEtBQdEW8v2xW/DEslUSkWFXAH5j6v4heeqWSENZWXjRRMQwURaWwe5DC2Bj5gQFUVdxn/oYGrGQKf0M9bi5PcXJSpC3s2ImvpobS+LgQpu3t6NEwWiAgRLJhUH3KyXiWRWzFMgItzbj5Av7GRqLLluDkchQTCYojCfRImLFHHsO1LTzbQY+EMSIRPMfDc21S6zbgptNorX4UTcdKpshs3Y6dmiQ/NIQRi2FlMvhqq9H8fhGdNXRCXV24xSLxk06kauVyUus3kFr/PLlcHiMew06lKQwOUvOKV+LksxR2D0KtilcsiHQLRcGMVwknlUwGf0MDWRQ8XBTAaG0RtntdnVPWgWNT3egciERQTAM1EEQNhwmcdhJGayulLdvQqzM4qUlU3UCtimK0tFDYug0sD2vndswFC7HHkyIPfsrNQjFMrO3bxGKrpgatthajtRE3OYmTmZwSQAr4/bglC8XzKG7cjBaNYPrEnGjVtXhj4j7yADeRoDCZxstlwfVE7rGmo9XVTnV09OGMJERKiCGa6Oi11ZiLl6CooBg+Clu2gG1jDQygxmLotbU4o4mpnZQixXXrxRzV1Ig8c9tFa2wkVCe7sr1oqDJivD+OGVEM4LoM3vXbQxLG7e3tfOELX+ALX/gCP//5zwG4++67WbBgAQC7du3iNa95DcFgcMZ1P/jBD1i9enXl+Bve8Aa++c1vVo6/6U1v4qqrruKcc84BIJVK8a1vfYt77rmHbDbLggULuOqqq1izZs2hvuujjhTGR5nU+g3ooRBOsUR0yWKC7e3ij+x2YWVWHB1BD4j2trgu1mRaNCkYGqE4Oiq2f10PRTdQTR++hjoCdQ3o4T2Fd9N9aPVQCCMeJ7NlK6WJFAAeHk46g5PNkB4ZpZRM4Tkumt9Pdtt27GwGoyqGv6EBIxrFzmRxi0VU08QtFtBNk1JCCGU7PYSHQmFwEGOqqYfnOYw88CCqrhFobSW6bAm+uhpS6zaQ6+un5HoEOjpw8gXSvRvRwxFwXTzPpTQ+TnFsHM+2iSzpmXpcwaypFn/ko1GRA+zzi851mSxqKIgzPiHycTOZSqU9jgOOjbWjH6++FnQTo6sR59nnhGic6vTlxeM4w1MtjYtFsSWs66J6vlTE6GhDDQZRAsI3FkU0WcDzcKwSxd5NopX07mGKvVPWcKk0anUcxscBD1dVcSYnp7brPFEQFwphLlpUaedc9p/1UESL3eYmIciDARS/n5LlYO0aQFEUnEwWo7kRNyMi8rge5HN4moaixYSdm6dgDw9BvoBaHUdRVGGvOLVdrvp9mD4/gYb6inWaa9s4pSKFZAorNYmCWIChKHiOLQrAShb54WHsTFbkJoeC6OEwiqoSXb6UwsgodiZDKTFGZHEPpZEEmW3bCXW0E+4WLZv39kr2NzQwlnmc8Uceozg2jr++FtcrUrViOW6pRH73EJPPbxafKYgoss9HaSJJaWxMuIYoYI2Powb8wkosGqE4MkIxmaQ4NoYRjQl7wkWLCHd3o/l8FAcHsVJpFAX89Q34aqsZ+cOzlCYmRAtpV3QZZGIC1e/DV1sr8vpd8Vlo1XFQRGROq69Hb21BHRnFHh5C8flxJtMY7S1geyK9QQE3XwJEF0RUUGtrRWS2sQFrcBAyGbHOtT2cXA5nchI3l8Ps6hT3kF3CmZgURbUjQ7ilghDekTBGeweKL4Diutijo3iui5vNQamEmxaLM6/sfuOBEpxqJa4oYm5dR3TVw8NobcFcugQ9HsfN5yk8tRY0FTUYxFy0CLNnIXolDULca1YqhaKJiLcSDKAGfMJpQ1GgVMSZmMDq759KR3JRg37cmrmbGEleOIq6p3uKFMZz0/TG848dcTwVMT4Ubr31Vr7+9a/zgQ98gJUrV+L3++ns7Kwc7+3tZeHChdx1111zXt/b20tbWxsPP/wwlmVhGAalUont27ezdOlSAMbGxnjXu97FmWeeyS9/+UtisRi//e1vufzyy7nzzjvpmnJIOt44aGE8NjbGnXfeeUjHx6YiEpI9GKEQVi4Hnis8fBctovbMVzL6l0fI9/WT3ryF5LoNYFmgq2imH2fzZhEldj1htO84hLo6xB9308Tf2CiieVNuFKXEKGg68dWrCLa0ULPmVNxigWIqiT2Zwc7nxNZ2czOZrdsJdXWR3bpVFATpGkasinz/nlbUejiEHg5jZ9KiVaxlURqfEIJAUdH8fpRwGKMqhpVKkXion9LYuPBhLhTRwyF8dXXUrDmVUFcnhcEhPMehMDhMYXQUZ9cuiuNjGBHR5axq1QlkNm6mMDQylW+liO3ruhrYtQtrVz9uKiWaDUTCQmxObf2KaqE9t7kSCqF4rnCSiERxJtOo/qDoxOUCto0zPIyiahgLF1Datm0q39PDSaYwWlpQ/IHK8wmrt3rczHaRA5xOY/XvQsukAQV7bByyOSEk83khQjMZrIk+0bTBcVH8JkZ3j3AdmfrDZY+NiZxpY2rslo1b3F1pz2sPDoHniihhwI+by4miQ58B2awQNZomvJMdBycxihYOYdSvFALJEi2IFcPAKxTR4lX4li+nNhahMDCIFghiVsfJ7dpNbmBA5B2XiqApgEewo43I4iVktm0TImlkVDTM8DzQVIqjohtiYSRBcXhEiC/LxrMsVNPAmxK3qfXrCba3E2wR9n7lhZznuqKphm1hhEOie11jg9iZsCxKExM42Qye64nUokAA1dAJtjRTHB7FymXQS0FUQ0O0P04z9sij+BsaMWNV+OtryQ0MkOvrA8DJ5UTBXksrdjqN8BZURF7/6CjB9nZK4+Ooho6Tz+Ob6irp5PNouo6bFz7R7OybKvoUFn/28AgAekMjbjqNXhVFC4RwJidBVXFGRymufRpvqvjPGtgFtisagzQ24CTGREqFJ8bjTiSn8nUd0YgjXoU7mcHL50RKTK6Ap6axh4dRxsfRohEUVUXRDbSqKjzLwk4mxT2lKni5LFp1jfBbLohmObZdgmwRxaeC6RfOJjXVKIaJs3s37tg4SiiEMzEBrofnuSimLlqZV74X1ajV1TCwW4hg3QAU1Koq3HwRUFAUH6qm4ZQs9NoaPNdBjUapOe2Uw/o7VrIHz5XpE/uj+wPvo+PSS47rHOOhoSG+9KUv8bnPfY53vOMdc57T29tL95Rbz3zHTzvtNLZt28bjjz/O6aefzubNmwmHwzQ2NgLwf//v/+WEE07gM5/5TOW6N7/5zdx1113ccccdXHXVVfM+/6233sof/vAHDMNg7dq11NfX841vfIMFCxbgui7//d//zf/8z/8wMTHBa17zGr7whS9gGMY+rztcHLQw3rlzJ1dfffWcxxRF2edxyWwU04T0JJo/QDExRm5gQNhJGTq+6jil1LgoTivkRQ6km0LRDeGz6zp4RRc9FMKsilN35ul7osJTaRP5XbuwUimspGgqYUSET6rq8xNsaiJvTuBTFSILulFNnyh2GxvDrKvHCAYoTQqR4E3r0+pvaCDQ3ESuvx9F08j19eF5Hr54HNdx0AMBvHweO5USOaWOQ6ClpXKe5vcxkcniq63BrK2l5pVrKCbGcEslkUoylgDbwU5Povp92Ok0oa5OIj2LsLNZwt1d5AcHURQVN5OGQkkIwHJUN5vBmxSdtSrb134fSigsqvnTafSWFjzPRQuHUNtaya9fJzxXNRU1HkcLh/EKefTaWvEZaSrupGjDXNq4SeSMqhpmzyL8K1fgZXPYu6Ys0VS10kVQr45jFwrCecLnE5G6omhoQbGI1tSAWyhiDw2iVcVxMjns5zdS3LQJL19Aq6/Hy+dEp7JwBLW9XUSRC3mMBQtEpM80MEIh0RK6FMZOpiuflaco2GMTMOV0YSzowmhuxvMcnOfW4+ULKKGg8GeOR4n09KCHQ1iZDMXxpGi97fjQggFURcXxwIxGqFlzGuGuTrJbt4ouZ64LKKiaKET0bBsjEhaLN1Wl6oSVTPZuRAuFsLM53JJFat0jpDc+T7C1nea3vBEjEmHsscfJ7thJcTSBohvYmSy+6mrQVEId7TiFIvm+foojI6h+P65t41oWdi5PZvNWsVMRraJ25WkURhNMbujFyWQwa2txLRsnn6c4PkZqwwYUz5sqFvwrTj4nosyugx6NEGxpIb97ECuTpjSagJER4dTSWE9u127xjdB1zFgM1WeSfHYdZNIiT9c0cMbHUDJplKZmPNtGr6+FqbbUSrwKa2hINIIBnMk01sCAWKTkCsJndudO1FhU5CUbOu74hFjgeS5aJIJWX4/Z1YUSDpN//PGpHYKMyFmurcNJJlHDIbxwCHdyEq26Gr2hAWtoEMIRSKfBNPFUDXtCdF/EMLGndiSYup8818PsaMNTFEq9m0SesmWJBjSuK9qvF4qU+nbhlSzMnkXo9XWooRCBk09CAdxcDjUYQgkF0WprABU1EgIU0RI7GBCtrIMBzPZ2YsuXH5lfvi9D7Mye3w26dCaYF83nE7+vj1N6e3uxLIv2qW6vc7Fx48Z9CuONGzdy6qmn0tHRwf3338/pp59Ob28vixcvBmD79u3cd9993HPPPbOubWtrY9euXfsc4+bNm3n22Wf5zne+w0knncRnPvMZrrvuOr75zW/yzW9+k6effppbbrmFUCjEhz70IX7xi19w8cUX7/O6w8VBC+MX2tlOUZT9n/Qyou5Vp5Pa0EuwuYnS2PieZgTpjBBUqhB7YqvRAcfFc4rCt9d1MUIhas54xZR4LhJdvKdLmee65Pp2kR/ox1dbj5PNYWez5YPUvGINqfUbUE2T+ImryA8OUvPK0yiNJ8ls3YpbLGKlJrFSKapOPHFPN7xolNiKZaQ3b8bWdexcXhQA2rawBgsG0CNRYicsx55MU0qlRA5pXT1mTTVOPk9640YUXXhohrs7CXd1UhwZpTQ2hmPZ2CPDmFVVmHV1+Kast0KdHWR39JEfHEQLhVH9ohrfSafFHNm2aJRSX4cbmBSFQ7YDugaGid7ShF5TTXHTZqzBIRRFoVQsojW3iPsyEEAJiAiZ3liPO5FCUTXs5ATeZAbVNHEmJkROa22NaPcM6K2tU01BwLMsFEMIDi1eLVpAK5poQayAl86i19ZgjyRQq6KowZCIpqYzeEULr1jCHh4WLhqFIu7OnYCCGimiTmZQwyFobcWzbNzxcYyuLrSqGABqIICbz+OMjorGIaqC57ginURR8DQVZ3wcLRrDGU+I7XlNw5tMY3tQWPssacdDD4XQI2HSmzaJlOSxMZSENxXtNXEKJSaeelqIZdOPncuh6Dqaz8SxbBRNFx0ORxOYtbWofh+p9Rsw43H89bUUdu+mODFBKTmJ6hdpQslnniHQ1Czalg8NURgcxKyuwS7khcWeblAcGcXK5tFMU+R5l0ro4RCKYaJqKoVEEmeqUQmqSvVJq3ELRaxkEiuVBNPAKeTJbt2Oa9sYVTH0QoH84DDYNq7joPlM/E3NooW2baMqKnokAgqEOzrx1dUSXboEszoOjkdhZITkU2unGux4Is89mcQ1DPSqOKW+PtFsRjdQAz60unq8nTtE2/BCUXwVi0XcUAg1FsOeSKL6fSgERSFtJjNl0acKe0A83ExGLMhWn0Bh3QbcZHLKfzgAhomneKjV1cL3edcAqs+HPTGBLxbFbO9ADUdxx8fQm5uwx8ZERztFQ/GZKK6Hr6dHdHEslkDTKG7aImwS02kxtwE/SiaD4vejmSbWxAReqUhpyxa8YhH1FaehhkLo9XUEX31mJS2o2LuR0vr1om16Po+i62KnQ9fRolHMJYvxr1hWSaeRHH5yO/sqP/vq64/iSCQvJt3d3RiGwb/+679y0UUX0dDQwPj4OE888QT//M//zJIlS+jt7eXBBx/k1ltvrVx3zTXXcMEFFwBCXL/73e8mHo/zoQ99iGuuuYbe3l6WLFkCwF/+8hcWLVpEW1vbrNcfHh6mrm7f7jJbtmzhyiuv5LTTTgNE7vJXvvIVRkZGuOWWW7jnnnsqz/E3f/M3rF+/fp/XHU4OShj39vYe1hd/Mdm0aRM33XQTjz32GIlEAr/fz9KlS3nnO9/J3/zN3xzt4VUItreTfPpZJp5ai6Io6LEqwt2dmDVxYieuAs8l+cxzJJ95BnsyjVYVw0qn0YIBTH81/vo67HRG5Ev6feQHBysR4+LoKHY+i+oPUBofx842ieK3SARUlVz/Lnz1dWiBQEVshru7serSTDz5NLmdO9DCYczqGqJLemb8wfLV1eGLV2MnhSerZvpwsjnUcAg9FkPVNbAdwgsXogV8WMlJFFMn+cTTjK1fj5PNUUomiS5fTvyUkzCiUZFa0dlOeuMmks+twwiJZiWlSIRc/wCFwSFiK5djdHdiTU6S3rRF5HwGgmJ72XPR6urALonmBdEoXiqFEgrjea7w0U2nUVQNN5+HQABr+06s3UMi7UIRllheNoebzuIVS+id7dgTY+A5oqiwtRUnlcJJJNBqarGGhiht3Sq62RkmiuHDXLwI36KFeK6Hm06J6vzxMdx8UUSzs1m0cBBzxUpUQwgwV1HwslmR66yIaCSug6droonI6ChUV+OMTqUjuQ6Kqgk3gFQKr5DHKxRRYzHUcEhYb9m2EGumAbk8SiAimjNEgij5AGZTE9bu3aixKFo0iptO43kuTi4r7NI0FVUzsHM5kR7j92Hl8qg+H8WRUSbX9WLWxIlXr4bHnsSorhJtvz3hRZsf2A2aRqizAyedQTEN8oPD2NkcxZEErm2JxjGGQXZHH3augJVKCbGkqniOjarrmLEopdSkaOiRSlFKTojvSiBAsK2V0niSYmIUMxrFymQwYjHhD6yIhXhxbExsixoGhc1DuI4tOhPm8liZLKrPwLFEJF8PhzCr40SXLWNS6SW9YQN6OIwRjxNbtRI9HBYe4ZEIyefW4xTyWNmp1ItyTqKiCqGdzYp/c3lUw8IaHxcFluGwaO09Pg6KIhrJxKIgnLWFaKytEe4k4Qh6rEqkv2SzaA0NKNEYRkcbbjYnCtiyoimLGo5gLlyA1tQomr8MDeIVCjiuB8UClq5jLujGaG/F1hTcbA7FU9AbG0QefKGIFgmK+6qpGS+Twc3mKG3fUXEz8HIiP9lxPbRIGCUYRHNdnPEJ4a0+OIS2dTvmgi6xyxEKwVRk0h4aRjFNzIYGSlu3oQSDIh/ecUXb6EzmCP7mffkhdhAHKv+PLF50FEcjeTFpb2/nuuuu43vf+x433ngjjuPQ2NjIqlWr6OrqIpvN0t/fz+9+97sZecdlyscXL15MVVUVIDRVb28vb3vb2wBIJpNzit98Ps/DDz/Mf/zHf+xzjJs3b+ZLX/pS5f+JRIJ4PM7DDz9MqVTi/PP35FY7jsPFF1+8z+sOJy/J4rv777+fj3zkI1iWRWdnJ2eddRaJRIInnniCxx57jEceeYQvfOELR3uYgMhttDIZPM+lMDIGIyNktm3D39hApKeH8IJuqlauYGzRAhIPPYyVTKHoOr7qaqpWn0jVCStE6oXfRzExTm5nH1ooTKiznczmbcLSy3NxrRJWOs3khl6C7a2UkkncQgGjqoroUuEEAKLD2GRvL4WJcVzHxRkbx1dXKyzDpqGoKqGuDmHvtnETgfZ20pu3iC3pXA6zsRF/UxPgkd22QxQsaRqeAmYkjK3rQvzhVf7olp0zALJ9u8Cx8YollKiKk0mT3rQZ1e8jvvpE0pu3ktmyBdXvQ6upRquKojc0YnR2iOYD23aCrmE5Dlg2mt+HohmgG+hNjThj46LRgmUJVwbTRA2HhQ1VVQyjrY3Sxl7RIc8fRO/qorR9B6rfRKvpwsvmsMbGcIZH8DJpUcqvKOA3cZNJIYpTKZzEKO74uCjWM01c20GrieMWSzijI3iGjj0xgT00BMWSeP2aGiF8A0GwRRRZ5IPmcCZTYBoYTQ04mSxYRWG7FQ7jppKoQT9GcxNadZxi70bhc1tVhWf60OprUaMRnLEkbkm0/9XicZFe4nngemQ2b8FXU0uwvRWzphavVMQpBYXDm+2imSaebeNvaUYL+NFCQXAcwgsXoEfCqD4f2a3byA0M4K+vx19TjT2ZxrWKFPr7wXUw4yI1wghHpro5agQaG3GtkrDAU1WR1lNVJaKKloWvuprcrgHhqWxZ4n5UNYLt7VjZHOgajlXCjFfhq6nGrK0FD7HQALRgQIhjxUMzdBzLJtjeRu2aU8ls38Hk+g2iCUY2K/KcM2lR0BcKofp8BFqahF1hNoudyeKvr6WUGEXVDVzLFrsEjivSaKIRPFXFaGnCSYzjTCRxCzkU3cR1XRTXwSuW0BoahNiNRlAMH/aQKNBTdG0qj90THfdMsdthDw3jTqZQNAXPBXvHTpHDrCriHq+tJvDKNXiFArmt23AyGbxcHkoWenUcNRrFHh4WxXuTYpdFjcVEOrVfWECqhomTTqN3deKUStjbxffIAyjYU/7IJoquV/ySze4urL4+FMPATaWwB3aB52Eu7BbCeArRhbFaeDqbhnC/yedB1cAzcTLZKTcVyYvByH33V34Otrfhn8oTlbw0Offcczn33HPnPLZ+/XqCwSAdHR1zHt+4cSMNDQ0VUXzOOedw//33s3HjxkrEuKWlhd/85jezrr355ptpamqquFbMxejoKMlkcoagve+++3j1q19NKpXiggsu4Nprrz2o6w4nLzlhnE6nufrqq7Esi6uvvpr3vOc9lfSNZ555hve///3cdtttnHHGGZx33nlHebSiK52dyeDkcpRSSfRgEM0HxaFhxp98itzAbuKrV9H4utfiq61l/KmnhedvJkvViScQWSRW/fnBQXI7+0Rr3MFBiokxPNdGCwXI7ezHcx186UmST68ls3XrlHdwM6XxcbI7+3FyWZxslvzAILnBQUpDwwBooSCe41JMjGFEIhXhqodCmLV1lBKjBFrb0INBwgsXYqdSBJoacIoW+aFBctt3UhofJ7K4By0QwKypJj8wIBpe+EUh3d7V0f6GBiI9CykMDhFsF2LFzuaILO6BqbHg2PgaGpjcvBmjuQlz0UJR8BMKTTXuyKCFI7ihSbAc9Lpa3HweN5MV3r0+Q3i7ahr4TbBdIThbW1HDEZzxcfTWtil/4EncVAotGkNrasG3qBtnbBz38SdwTV24YZUr+H2mSNN49jnUqhhKrAq3fxdK2kIx/SjhENZoQjQG6etDb2jEKxZQTR9qPC7EhuuA7aCFgtjJCfTqOO5kGm2q4t8ZHhQpEbEobl2d6Kw2sFtsX7d3gM+PM1Xpr4TDolFEdyeqYWINDOAVChitLRCNiM6JeLiWg6JpxE88AWcyTaizg9pXrqE4msDDw80X8dVUU0gkUA0Ds6qKQGsroc52nFyOYEc7djaHU8hTStdi5vOoug6mSW6zuN9Uvx/w0CKi5bln2GihMIrjYGezGPE44a5u4qtWkRvYTairg9J4ktzOnVjZLHYqJQrjFKa8u2OMPf4kKAqB5hacXJZgZwc1r1yDFgxO+XUPUZq6d7WpXHxMEyyL+rNfLbzAx4StnFklPLmL4+Ps/vXdeKUSepXoEOerrsaeikaXEqPooYBYiPb3oxkGZlWM3EQKVVdFoV02A46L1lCPPuXdTclCUTRA7AJodXG0BWHU2hrsHX042TQKCk4JlHQGq383iqaihILC1zwSwWxvE4V7VlHkqk/tdKAqqFXVwpGlkMcrFvCyeZFbr6iVph1ePo8znkT1+UDX0KJhzEULwVOw+nftadYxPoFniQYmeK4oFLVtsB28yUm8YgGjqQk3m0WLRTE7OirFeEZbm7ArnCo2LaPX1+E74QSUjb14uSJuLoutKGJh7Hlo4TBKIIDk8GNNpoXTwhR155wt0xpfxvT29rJ06dJ574HpucQgRPY111xDNptl4cKFALz2ta/lq1/9KjfeeCPvec97KJVK/OQnP+HHP/4xN998M+pUwOuTn/wkAF/+8pcrz7d582Y0TeO3v/0tF1xwAXfeeScbNmzgS1/6Ehs2bOD73/8+W7duZcGCBUxMTLBu3Tpe9apX7fO6w8lLThjfe++9JJNJ1qxZw9///d/POLZq1So++MEP8tWvfpVf/epXx4QwLudzOrkcrmVhJVN44TCaaeAWCmQ2b6ZcNBde0E0xMYY1MYERj1ecJ8pV/FooXEmJ8NXWkCrZWGPjeK6Lk82R2ym8grXkBKqqkXxuHYGWJtxSCSudIdzVSWFkZCoSpGBNpvEcm9yuAVLPPIudyVK1cnklsltuGiLcL9bh5vOUJpIiF9Xnx7VK6OEwbrFAfvcgsRNWULv6dIJNTaTWryfQ1oY6Vag2HSMapea0Uyvvqzg6SmbLNiHIamuFJ3Imi+eNYrS1obe2ioKhCgp4wj1B9fnBL2yoKORE3qRhiO1unyns2DxQYhG02jpcx0ZxXVRVxezqRA0FKRbyWMOjomCubydGc+NUlLpKNHMIBPAcW7h4BIKouo5XKorUiL4+FE1Hi0XRGxtFfuX6DaCLgiqHIbxgEC0UxMlmwHZRy9Fhz0VxAb8fVdXwCgW8QlHMa10dnuPhjo/heWB0dAiLtXAQRW0U3cl8PuxkCj0WFaI4kcDN5vCKBaxdA5gLF6KEQiKK19+HYvpEAVVtLf6GBrRgUCyaMhnRftwwiK9eja+2es8uxdRnY2dzwuHBdbGLReHvO5nGyeXRAn5C3Z3kB3ajGAaK4xJsasaoiaOZJkYsRnTpYjzXJb15C9ZkGn9jI5o/gEKSUFcXqWefAxQ0vx87m0E1DczaGqxJ0fa6lBglumQJRigsfL4Bt1Ag1NEuUllyeRSfCa6Lpqr4WtvQAkGSa5/Fsx1UXcPK5ES0ljClsTFU08Tq2wm4Uy4s2Urra1QND4+qE1aSDgbRQyFc2xI7B46F3tiA2bNQ5OFGIjhjCTxbpL9g6NiJEZScjrakBy0UpLShFy0cxk6mUDUNN5mkMDKM2dUpCkTra/FsG3toGDUWRY1VoebyEA6B44nFFK7wQm5qRGtowEml0IJRMAyM5iZQNRxNRwOckRGRplFXjzlVgGPvHhS7DlXVwh2jVEQJhkVUPxAQKRuWJRaTmo7rOpj19eL5O9owOtqwh0Zws1kUf2BOkauFgyIXXlHxMpOokQiq34caCKK3Nh/2368SwcAv76y0gNbDYRrPe91RHpHkaNLb28vatWtZvXp15bHm5uaKddvewvjUU08llUrR3d2NaZoARCIRfvjDH/KlL32JG2+8EVVVOeOMM7jttttobW2tXDs0NDQrfXXTpk28/e1v56677uLf//3fOeGEE/jhD39IOBzmtNNO493vfjfve9/7mJycpKamhne961286lWv2ud1h5OXnDC2LIvly5dz1llnzXm8XIU5MjJyJIc1L1owiBGJUBweJlBfj53NAR4YOlZqklB3FzhuxecVhaliPBElTm/eUml5G1m0AKO7c0+1sQKu4+K5Noqh4bmuyK8tWbhuSRTiOS6BlmYKTz5NbmAAPRTGnmrFjO0Q6GgTuZGmiZPNiMjeVNS4LJDtTIbSyKiwkMrniC1bLBp9OC5OMYsWjhBsbSG++kSCLS0YkQiqP4CTzaCFwnNWR09Pqwi2tMzyujUiEUrpNJPbd2APDuEMD6H4A8ILFg+9oR6vVESr6sYrlkSL51BE+Cznc1AootXVCvuiUgGtqgpfZzulnTvRa+JTHdrylAaHsHf2406mpjqNJYR4CAVRwiG0cBDPMoWzQzCEPTwkCqtsR6Qr2DZqrAonl0dNT+K54NnWnoIp3UAPh4Qjha7j2TZmZyelTZuE/VvYRa+Kiq7NiYRoDjExIey4Uimc5ASURDGT2d0lBEwmhzM2jj0yAo6D0tIstsKLoh2xYhgogQBaPAYolDb2gqeghyOYdTWYkQhWWuSZp9atpzSRRA+HCbS2YNbUkN60GWsiRWl8AjuXxU6nMeJVlCYmiC5byuTzvRRGR4ktXYpbsgAPN18g2NKKWVtNZNFCrFSK6LKl6OE9n3/yufVi12J4BDNWJdwnJiYoDA8Lu7xCAddxUE0fZnUcRdNEWkXAT2F4lOyOHSISPZVHb8TjFBMJzOpqqFaILO1h/ImnxCJKV1E0BcUw0IN+7KxITzKrqymMjoh21D6fcBYJBikODYOiEF2ymPSWrZTWrcNKZ8j7/KI5z+oTsHJ5Stt34GXSKOEwit+PoioYnR2Y3Z14rkdp02aKmzfj5YvY2Tw8+xzmkh4UU0errQPXwbFskTozNk4xk0VvbMDX3Ixi6GK9pyi4OZFTbtTX4U5MopgmRksLXiGPoioVRwh7ZAS3ZFHcvgPVMFE0Bb26Fi0WE84WixdV0h3MJYtxUilRVKrpoFiiwYeui2h/LIo7Po7i86HGq6fEtljYKv4Aen2daNaRz6MEAjPSKMoogYAQ6GNj4p5PJlFM0WnQHh7BKxSxFiyQBXiHkVIyOSNa3PK2t0pHipc55cYf+zo+HcMwePLJJ2edt3jxYm6++eZ5n8e2bUZGRip5yWW2bNnCihUr+OIXvzjndZdffjmXX375rMf3d93h4iUnjP/u7/6Ov/u7v5v3+DPPPANAU1PTvOccSRJ/fUQ0sHARESVdeLEaVTGMqjh6MIhZW4seCmFnRbqDr66WwvAwheERUUyhIBov4FH/6ldVrNqMSJjwgi4m129ACYbRA35CHW1TxUoJPNumMDLMxBNPi7bCfj+hVe3k+ndRmhhDMQycdBZPUcn378JXWzPvL1TRhEJHCwSwMlm8ko1i6uiRMOGODiJLF1e8aqdHm6c3ddgX04XyjNctFPAKebTaWuyBAUrpNIohtvDNjnbRCGP7DlTFw/GygIfnIkR8MiUixpqGVxKelWokipPJipa2CFs0rbkZe2hoqoFDNRg+Cus2YG3Zglcoojc2olVVoTXUiYitP4A9Po6Ci97cjD0VKdUbGrCHh9Fqqis5yIqho1ZV49oWWjyOkxgVVl/BEASCmNVVopthdTXFfBYvK6Kaem0N7tSCiFgURdfRG+uFGNm9G0XThANCehIvm0GtjqNGI7iFHKCKqF0mCyiowRBGWyvO+DiFgUEs3xilyTSZTZspjY1jJSdwiwWs5Lgo4kynMWMxcn39GFUxFNPESmdQAwGs8QlCbW2ihbRtE2hpouYVp87Ig3eyGczaukrDGBCLPCcrOsjldw+C55IfGsSMx1FVhdCCbtKbtuBvaUYPBIidsJzSxATD9/2RUkI0gPE8DyuTFp7EkQihznZ8U13UiokxMtu2iwYfQ8MY0QjRZUuIrVhGYXAIX1OTaFxTKOBvaMSorcHNF0TetC6i06XxcQrDw+K1HAc3nxMRXkOnlBjDU1UUPPTOTnEvbtqMYoiW3ObCbvFZAfbIKG4qjd7QgDdlUai3tglB7fPhbd8uii1VBSUSEQV8IyPguviWLMEaGMBJjKLgYS5ZSnHdOhQFrB07MdrbxKInFMK3fBngYSfGsEdHxQLJ9dDqa1AMU3inDw6hhoKi6YdVxHfCSrBLWNv6KGzZjKooEAxhNDZiG7pIeQiFMBf3oLe1YW0VLdVLGzdNdbGrRqutnfd7rIZCmD0i/ctJp1EDAYzGJko7d6KFRRrU9MW35IUz8ItfirQbwIjFaHrTsVN8Lnlpo+s6d99996zHN2/ezFve8paDfr5Dve5geckJ430xPDzMj370IwDe8IY37PPc//mf/+FnP/vZAT3v1q1bD3lMqWefQ1FUAs2NFEZG8YoFSqkUZnU11aesnuVLnNnZJ9wHfH6MqhhmvIr05i2EFy2sRJbL12jBEEY0RnjRIoxoDH9DHaHuTkb++CcKQ4OEF3ThTOX6xlYuJ/18LwXPwy0WhTiIV+NZJXx19VjJpKjGn+MPVjknOLtjJ4GmJiGadu/Gy6XJ7RrELRaF9VQuVxFD8wnd6ezdtW/648nn1mNnMlgjIyiKipNIiO1t1xWtZ8t+rFARK96mTSjhMLqq4WiIFIKBQbR4lYimBwP4VixFr6mpbAOXduzETY6gt7RitLWiNzagqArW1jRKIITiz4t83+o4ajSGMpqgNLAbxbZxA37xGbS3icK7bBYlHEFXVLAdlKYGFNOH3tSA1beLsmh30xmR7uHa6M3NuJOTOMND6M0tU614R1BUTfi/WjaqqwpxXiNEoBqrEo0fhkZQQiH0BnFM0Q3MBV1YO/vEgsK2cTNZ9Pp64aCgasJzuqlJRGkVQAErX8B1XBRNw1dbwskXcINBHNuCZAo1FCS8YAGhtlb0SAizuppc3y6siQmRwqCqhLs6MaJRrKa5P1M9FEILhSklRvEsW7iw5IvYmRxqKExpIolqGiiehxGNEl0iCkYn1/dSUIZQ8sIIX1EU7GyW5HPrye/qx7Vdokt7CHW0i6YjwSDB9nZyAwN4JbuSsmNnMkxueF60kE6lCHa0gyKcMTLbtpPftRstIAooPSDX34+dywvLt3BI+CHXxFH8gTnvxXK+rV5fh/+k1WJHolQSKTYNjZVuh24ujwJYoSD2wCDk83g+n/A/Nn2ivXIohFZbhzMygrN7N6o/gNHWgjM2jhqLVCK1Wk01aiSKNzSMEo7gTKREmkVtLW4yiTY1NmvXLkobN+Nms8J/+BVrQDdxxkZwLQe9thZz6RJ8KqI2IBBAq6nGGROFhagKVl8/biaD3tw8q+hub9RQEKO9FS1fEFZxhTxqKISTyaL4fNgvQXeKI/X3ZG9K4xMM/W6Pz2zL2y8QrdElkqPIli1b9umhfLivO1iOeWF86aWX8thjjx3QuY8//jjRecRWOp3miiuuIJvNcsopp8ywApmL0dHRim/ei4mC6BLmeWDGqzBCYVBADwvhEJiKbFuTk6Q3b8UrFNCr4mg+H2ZNHCebJdDWihmLVSLL1uQkheFhnEIBsyqGv7GeYJvI+Uk+t5788AiubVMYGRVCNV5Fdtt2nJJFqLaWYiJBdNkSCsPDWFlh66aapshvnpycJWiNaJRgWyupDc/jpDPkB4dwCjnsTBZ7Mk0u4MOaSJLt6yPU0U7NaafuVxTnBgZI/PUR4X/c2EjNmj3XiMh5Bn9TI8rIMHpjA2owWOkI5yQSlRxHN5vDs2ysgd2o1TX4whHcTFqkPvgDeLmCcB8wTYymZlF8Ny2y54wmcNOTqJGo8Deur6sIXG90FLdQRNF0nIkUSr8QB+7Y2FSXsRJ6Qx3mAvFFLm8xu9mcEFiuixaLoTc14hVLlHbuRFEUvFIJX3cn9mhCWM8piqjgt2wURRHWXqqGuXwZiiruonLhIYgip+CrzhRpHWVv3UIeN59D9ZnodXVYowmYivLrrU3oNTV4rocPEb31Nzah+gMk88+h+Xx4joMRi+FaFv7GOvRgiJDWQWTBQorjCcwpuzHPZaqYyiXY3kbikUcpjI7O+NyNaBRrcnKGtWB5F6EwPCx8hXfvJtTehmdZVJ20Gj0UIte/i1BHm2gzrKr4GxqIn3SiSPdIJtFDIVFp70F+Vz+5nX3kh4ZJPvsMkUU94r3HqsgPDWHG4wRammaMpzCSqESzw93de1KGIhEUT1Ty53b2ifbZajfFxCie5eCWhBuG4g+gxQGqUPz+WfdiGbOzHTUYECk5sao9bZRDIbyRUdRYFMM00aJRPMvGXLgAHBujqhNFVcXCJxQU6TSGjodHqX8AVddxU+mKwJ0RnU1Nomga5pLF6HU1osX3jh3C93h0HCc1idnRjjUwgD08hJtKoxg+jOowaiiMFg7OigRbuwZwC3m8YglnMoVaqEVNJWcV3U3HzWYpbdmGm0qCqqG3tqKFg1ijY7jjY7jpDNntOypFxS8VjtTfk70Zuude8bsDMKqqaHzD0a+rkUjmSst4Ma87WI55YRyPx2mYaiyxP9S9irjKjI2N8Q//8A+sX7+etrY2vvGNb+y3Ireuro7lB9iBadeuXQSDwUPqC+5vbkDx+4mfsBzP88j378JDwd/UOCNtQeQD2wTb2sgPDRFobiS++kQUVcWanMQpFPHViohh8rn1FAYGKCTGqD55NYWhIXK7BigMDTHx5FrAE/ZpgKprlMYn0ENBNJ8Pa3ISzecntf550e42EMCzLaKrVop2svNsczqFIm6+gGIY5HfuRPE8XMvG31CPlZrEzubR/H5SmQ2EOtorYmS+iHDir48y/ujjqD4f+cEhQp3tMxwxUFUmn+8FRUWrqamIwnLkrSxE7MGhiudvuZiu3HBAURWs7i7c8TGUUATfopmRLntoGDc9iV5fhz08ij08VOnq5V+xTORwZ3PgulgD/biZSfSmJtGwIZ0ReaJTTRym+7kK0TJzHEpEeNmqzc2UtmyppG0opg97aFQ0/kiMoegaZk9PpdBub7FSdgNQQ0H8K1fiJBKUtm5Dn0pj0ZsaUGNVKOVc2Pq6GYuBaH09bj6PHgpRGB7GTqfxRWOUkklQFMKLFhJduhinUKI0NobmM1HMJpiKNOcHB7GzAZxSiey69ZTGJ9D8ftKbtsz43EU+cQYUlVBne2Unwc5mMeMxAs1NFEYTBNpaiZ90oshL9/kqwrV8z9Sf9WqiSxZTGBmteCIXE2PY2TyF0QRGLEZ+1wDFsQRGJErdq05H0XQCLU1EpxWX7Cu9x9/QgL+5GSuVwojHUQN+0aJZVdF8PvwtTajBANaOnaLRCwpaVQzF70OLV81YtJTR6+tEJ7y9Prvy/aoG/JiLFlY8qhV/YMbn5CQSeMWi8LEu2Sgq6E1NwiJwbGzGImn6d0INhcTCbmqx5SYnRROaUpHSzj60WBTF9IGbRGuoF7nAtbWzCunskVHsXaJLpzs8DMUS1oaNeB3tmFN2TnPh5fO4qSRuoYgzNuXJ3dqKtXmzsFAslVCWLp73+uOVI/X3ZDqe5zH6wJ8q/296098cUnthieTlxjEvjK+77roXdP2mTZv40Ic+xK5du+ju7uaHP/zhfjuyAFx88cUVQ+kXE19NLeGFC6k57VQAsYUNM/IvYaY9WnjRIuKrVxFsacGanCSzbYcojJvyV3WyGRHd2r2b5Lr1om0tinCIcGyMQJDS5CSqYYKqUhwaIvrqM0Xkq64eVJV0b69wqljQjaIblBJj+Jub580x9tXWoPkDZLZtxQiFMeIxrIkkWjCIFgrjZDPCQcBjmpPF+koBXtVK8UejvK1tJSfAcSiNT+BZpT0d+8p4onnD3p0YpwtQJ5EQbZ1bWkTkTlVmHHezWSiVUHSdvddJbjaLk0zi5vMU1m1ADUdwk5MzonFGYyPWVFcwNRAURVGZDGo4PNVkI4szNkZpy7ZZ28tqKIQLWFPRM3s0gWvZeEULs3sBWn0deqNYEBbWPoMzMgI+P246LwrzqkWecnmsZZFt7dhZiXD7li8VjU6mtvfVWJUQxaqC2dUpBPleRVJGNIo65V0JEGxrY3JyEjUYItTeSvUpJ1XyhPE89EiYYHU1xcQ4+cFBUNQpOz1H+Pvq+lT++x5LvnLE34hGmXjqaaxkEn9zM1Url6OHQgRaRSclf0sr1aesruSmzyVcp6fkFHYP4m9swEqliCxeVGnnrAb86IEgCh6hzo55o5FzpfeUF2+hznYUVa3c/5lt20it20B+9yATT61F1TRKiihgKz63XuSmRyKYPT1oNdVzvt7eePl85X61BwbAKqI3Nc75OXmuh5tMYg8MoJgmaqwKa+dO8BTsoZG9FouhGRFcL58XzXAaGnA2bsLs6kA1DdR4FUZ7uxDShSKQRG1rw+xZNOO13WyWwpNPY/X3oZQs0V3S7xdmMLksXqEw73ucUXxXXSMccxKjuNksRmsrhed7ST67joZzzj6gOTteOFJ/T6aT2bSZwuBQ5f/1Z89dkC6RSGZyzAvjF8Kf/vQnPv7xj5PNZjn55JO5/vrrD3uHlBdKuGfRjNzd+VIM5opoWZOTZLbvoJRIEO7uEsKEWrRQmMLwMJrpE+1zTRMtGMAp5Ak0NoHnosdiaH4TPRjCMlIUE2OEurvx19VQ2LULX22daJk8Nk64ZyFVq06YJdanE2xpofENr2X0L2GKg4OoPpNQVxeRhd14jsfEE0+IDm6FAk4+L1I9splKlLEwPEx2Zx/WVEtczR8ATcdXHcSIxWZHzz2XyJLFTDzzzKyt2+lCsSwK57KPKgsRba880PIx1WdiLlmKtWmTsN4yjRnnaDXVGB3CyULRDYyWZiFo6+txJiZQTB9GW+ucnq7TXx/dwE2nMTrawXUxFy3AmOpx7yQS6NXVKD4fbmIMIhF8PYvwbAtFVSpb014hjz0+gTM8ghqN4kykUGNR9Jrqirgqp5qUI5D7ywU1olGiy5ZgpVKY+Tz+xgYUVa2I2syWp0X+uEtFONoZsRXub2ggu32HKExLZ4guWVRpKV7OJ8719eOhEGwX6RF2NkugqYmqlcsJT7mrlO+36baE5UXS9GPZHX0UR0cpjCYItrUQ6uqk6bzXURybID8wIHKTpywOD4RyOlJ2p7CgKy/eyq/pb2ggs2kL6tR8uLqBbZWgd6No1OF5eLkCnqaDquwRnPtxbFD8AeyBAeF1nc2h1dTgW7501vmKKqLSemsLXiYjFjOKJyLI0+638s/TX7P8OsJdReT2avX1M+4Hc2H3vGO1dg1Q2r5dtGJPpQAFikWUeFw0pWHmYnU609M7yqlEaiyGunsQa2gQ1W9Kx4TDxMi0aHF0xXJ8dfMXRUokkj28ZIXxbbfdxuc//3kcx+HNb34z//7v/17x3zuWKA4PY2eyM5pn7M30lIPpOcfJ59ZTSoxSTIwDVPxn/Q0NZLbvABT8DfXk+voJtrcS6mgn0NoqIobTCqQCLc1Ely4WvsjpNJ6q4BSLFZu1mleuqUTt9kV08WL0cHhGbnCwXTSACC3oxppIoWSyFEcS2JkcqGrFd9nOZElv2oIe8GGPJqhatRLN78fJ5/E3Nc4QNGVhVRgcmiV43WyWwroNU5ZZkXkjo8CMaOrez1M+phZF1A5Nn3WOGgrhP+lEjI42puf5uq0tOGNj+/V0VQIBnMkMpS2b8QpFFF2fijDWzDhHq69HSSVxfT7ckoWdSok0i0CgIq6VUBintxcnlQLXxTNN7F0DuMlkRQSzj4XAfCiqKhwcFvdMLbwARSW1fgNOyaqIWkVVCTQ1VXJ1y6I3ungJdjZNdMniGYu/qpXLKdTXisVQKjXDtm/vyO3e97qvtgaztrYiVMsLpfhJq0lv2iLOX/ssqt9HdMliQh1tosX0HKJ6LsqvVxgYILd7kOjiHkqJ0RlpRHoohBGP427Zims5+GJVaIRgquDTQ8GbTOHhgW1j7exDr69HMY15FyVqKIS5sJvi+g146QyuouL29Vd2DqYLVSUQQI1VicK1WBX6VG719Ptt+qJp+muWX2dGKs9e34+9o8zT8UpF4aCjTTW3iUehUEStrsLsWTTj/p2LudI71GCA0ubN2Inxyu6R5NDxHIfEQw9X/l9/jowWSyQHyktSGN9555187nOfw/M8rrzySj7ykY8c7SHNy568zLlzd+dKOSiLASebITxVoRns7KhU/gOEuzopjowy8dTTeCioAT9aIFCJfgWamgg0Nc2KQGd39KEZBoHWFiILugkv6N6niNgbRVUxo1ECixeT2baNiafXopkmeGDWxlF9ZiW6HersrPjYFoaHUfDAU1Dw8NfXUbVyxZw5n2VhVUqnSY2MzPiD7oyNYe/qRzH9eMkkRlMDenu7SI1IJGYIgOkCYS5hsD/xUD5vvsf25+nqZnPYAwM44yK67BWLonnDXudqcZGvysgozsAAXtpBmzI0r4j74SEU04/RHsNNptCjorHDdBG8r4XAfJQXIeUFjBYMgoLYhfD5KAwNV4o+p382mVCA4tg42Z07MKKxWS3Fy+LX39CwX9u+SupFLEZm23bhpjLNU7s8RmtyEi0QILd7AM1nkt89hJVMEeruJtTZTnZH36zv0b5ez6ytIbluHRNPr8Xf0DCjQ6MRjVKz5lS0YADjuXUomoYbCIDPxBkexitZuJoqcoU72ilt3YZjGviWLdvvosRNZ3DTabxCASUUws3ncLYkZwncve/dvcVmOZVoroXQvoTvrPHsFXV2bRccBy8nWnFrPj9EIvhXrsC3fNk+dyHK7P36aigIugF2ifEnn6ZmzWkHNDbJ3Ez29mJPTgKg6Do1r3zFUR6RRHL88JITxtu2bauI4n/6p3/iwx/+8NEe0j4pC475tg/Lf6T3FtDTBYtZWzdDFIP4wx3qbMdKJivV9G6hSHTJ4srzBJqaZlwzXWxntm0TDSgOkunjQtPBcTCiUVIbHkU1hZ1WZtv2SnR7+uuHFy0SEey21v1ueRvRKFo4jLp37vG0rndT3RDmjZzBvgXC3sfmEtf7Yn/iw02JLoFaNCpSKhREYde01yuP27Ns7PEJUDXUoCmidnkhesyF3TjxmLDmKuShrg69tVUUYk0TwftaCJRfLz84iDlt92LvFB47mwXXJX7iKjLbts1akJWv0UMh9HCIUGc7bsma1d1w+rn7W3hNt3IzojGs1OScYtzOZikMD1McHcEr2XiWha+2BieboZgYm/U9AvZpHVcYGMCsriG6eNE+3oNCoKlR5OrH48ITODUpGrhoOl6hICzWohHUQAhrxw6UcGTWoqQsPt1cXjRhCYWEpVo4QsVPey+BO1tczvz/oSyE9h7P3uk3aiyGtWkTuC5qVQw0Ha22Gr2paYYoniuFY194+bzwZV68BL9tH/A4JXMz/ujjlZ9jK5bL9BSJ5CB4yQnj66+/nkKhgGEYbN++nU984hNzntfS0sLHP/7xIzy62cRWrthntGzviN1cYmC+6/eupi93y5tPiJdfK7Nt21R6hjKjDfSBMH1cnuuS3dFHct068oODBFtacF0PX30twfb2Gdva5XzWYmJshrvGgUT4pqPVVGO0t4kCtIYG0UzjEFII9mbvFA3/igOLjO0LNVaFVh3HGhhE8Qcx2jtnbENPH7e1bbuIJKZSuLqGr65uZlpHMIjR2TEjsj2XOJlPrJdF+ORIAj08c773Fq/7WpDBnpxfO53GSmeI9Cw84D/MczmV7H1PlYvg9hbjZUFeHB0TaTa6gVuyMGtjlTbi5fvfc91576/pqR5GdVzkfdfGZr2H6QvJ3O7BSnFn4OTVM6z53FQSDOE/7aYnZznizFgAoYCmoRg6RleXKOQM+PEKBy9w97cQmo+9F2Se62K0NOMkEjhWCa9UQm9pxhkdwWhvwb9q1QznjX0tROejLOK9bAZ/94IDGqdkfsYf32NrVS2j7xLJQfGSE8YPPPAAIFpD/+Y3v5n3vCVLlhwTwjiwnw58+xLA+4u27X2tlU5XhOdc11W2wafyk8spDwfbiWrvcU1u3IjigjWZRg+H0QKBWdvaQOWx6e4a+0s12Rs1FMK3fOnMrV845MhZGWdsTHTQU1Xc0TGMpoYXLIyn+w0rpg+jtWXGc86I+AUCGA31KAs6cZIpjI62ivg9lGj43pRFuH9xD8WhoXnn+0AWZHY2K/LKuzpFUWdH+wF9dvOlDZVf90A7JNasOXVOEW1EIjMi3/u6vw4k1WP6olUPBSv31d7WfNTXCVE57GJ0ds5Z6Dl94aa1NM3wudZqavabljMfB3MPlJk+HntgQBTNTn131FgMLTaIk0qh1dfjW3lCZfHpTr3eoS5ERYvyKplj/AKxUikKu3dX/h8/efVRHI1EcvzxkhPGR8oA+khyoKJgX9eWo3hl4TlfsZ8RjRLu6pwRXXsh23CKquKvqUZdvpT8wG4CrcLyrTgyOmtbe7pQgVrhVdy7ESNedVBjmGuL+VAiZ9Nx8wW8VApnKkvDzc9vSXUw6PV1exo87MXeec7lLW2jubkSWT4c0XDYI8ILg0OVvO/52N/96LnuVDOY1Jz5xfOxP7F6oEwfXzkCPde459qJ2ddzzXWsvEhQAwEmRkbmHdOBFHqWjxmtrRitrbPv1yO0Hb63xd/elnHTm5OooeCshdnBpnDYI6OUNm2uLAQkL4z0ps2Vn414Fb76+qM4Gonk+OMlJ4wlc3MwouNAooIHStl/GYRrRnz1KoxIhMJIYpYomVXk5SEaKczv/nTAHErkbMb1AT/qVMe5cgOGI8HM6ONsu68Xkke69+uYC7uJ1tfPyDGej/mas4BYDPlqqwkv6Ko4VhwI86UNHSp7R6CnexEfrnu8LJxd14V9COMDLfQ8GkL4YMYKM5uTzFXgV857P5CFqJvNUtq0Gau/H626BgcOeUEkEWS2bqv8HOnp2W8zK4lEMhMpjF8mHKzoeCFR6r2fZy4Bsr/HyhZc0aVLXlD08HCh1dRgdHVVcoz3Z0n1YjCXuD8c0fDpzxVoapq3g2SZfaU8wJ7F0PQudQfC4VyQwczFYGbbNkoT42imOWPMR/KeOthCz8PxmR4qB7qQnG9hdqDXe/k8uA5aTQ3O2BhGW5ssFHuBFKeaRAEEWvdvsymRSGYihfHLhMMtOg72tfd+vQN57HBGD18o5TbQR1OszMcLjYYfLAeSn3uo99rhFKtzOaS80DSNI8GhFK8dLV7owqzsxzy9y96x+rkcLxRGRis/+2UahURy0Ehh/DLiSEfIXghHU8jPx5EWoMcqB7L7cCzca3M5pBwrC619cbjyxo8UL+R7cTh3PCQCO5Op/GzInG2J5KCRwlhyzHIsiCvJbI7FRct8TL+HprtSHMtjPlx548cLcsF5eHFLVuVn1XfsdXuVSI51pDCWSF5CHKnc1ONx0XK8jFlGUSUvBM8qVX5WDeMojkQiOT6RwlgieYlwPOWmSvaNjKJKDhllT/Gs9hLfbZBIXgwOvuevRCI5Jpmem+oV8iI3VSKRvKxoeN1rAIgsXkyoq/PoDkYiOQ6REWOJ5CXCyy03VSKRzKbtogtpeuP5aH4/iqYd7eFIJMcdUhhLJC8RZG6qRCIBjmnXFYnkWEcKY4nkJYTMTZVIJBKJ5NCROcYSiUQikUgkEglSGEskEolEIpFIJIAUxhKJRCKRSCQSCQCK53ne0R6ERCKRSCQSiURytJERY4lEIpFIJBKJBCmMJRKJRCKRSCQSQApjiUQikUgkEokEkMJYIpFIJBKJRCIBpDCWSCQSiUQikUgAKYwlEolEIpFIJBJACmOJRCKRSCQSiQSQwlgikUgkEolEIgGkMJZIJBKJRCKRSAApjCUSiUQikUgkEkAKY4lEIpFIJBKJBJDCWCKRSCQSiUQiAUA/2gN4OXPVVVexffv2oz0MiUQiOabo6uri61//+tEehkQieRkihfFR5Mknn2RwcPBoD0MikUiOKcbHx4/2ECQSycsUKYyPIrlcDgC/38+CBQuO8miOT7Zu3UqhUJBz+AKR8/jCkXP4winPYfl3o0QikRxppDA+irS2tpJKpViwYAF33HHH0R7Occnf/u3fsn79ejmHLxA5jy8cOYcvnPIctra2Hu2hSCSSlymy+E4ikUgkEolEIkEKY4lEIpFIJBKJBJDCWCKRSCQSiUQiAaQwlkgkEolEIpFIACmMJRKJRCKRSCQSQApjiUQikUgkEokEkMJYIpFIJBKJRCIBpDCWSCQSiUQikUgAKYwlEolEIpFIJBJACmOJRCKRSCQSiQSQLaGPKhdddBGjo6PU1dUd7aEct8g5PDzIeXzhyDl84cg5lEgkRxvF8zzvaA9CIpFIJBKJRCI52shUColEIpFIJBKJBCmMJRKJRCKRSCQSQApjiUQikUgkEokEkMV3R4Xt27dz/fXX8+STTzI2NkZjYyPnn38+l19+OaFQ6GgP74jzyCOP8J73vGfe48FgkKeffnrGY3fffTe33HIL27Ztw3EclixZwmWXXcZ5550353MUCgVuueUWfv3rX9Pf308gEODUU0/lQx/6EEuXLj2s7+dIsmPHDi644ALe8Y538OlPf3rOcx5++GFuvPFGent7KRQKdHd3c/HFF3PhhReiKMqs823b5he/+AW33XYbO3bsQNd1Vq5cyT/8wz/wile8Ys7XSKVS3HTTTdx7773s3r2baDTKmWeeyZVXXklbW9thfc+Hm/3N4XXXXcf1118/7/Vnn3023/ve92Y8dij32/DwMN/5znd4+OGHGRoaora2lnPPPZcrr7yS6urqF/YmXwT+93//l9tvv53e3l7y+Tw1NTW88pWv5PLLL6e7u3vW+UfiO3u8zaFEIjn2kMV3R5hnn32W97znPeRyOVatWkVjYyNPPfUUo6Oj9PT08JOf/IRIJHK0h3lE+f73v89XvvIVVq5cSWdn56zjPp+Pa6+9tvL/r3zlK3z/+98nGAyyZs0aSqUSjz32GJZlccUVV/DRj350xvWFQoEPfOADPP7449TX17N69WoGBwd59tlnMQyDG264gVe96lUv9ts87CQSCS677DK2bt3KZZddNqeou/XWW/nCF76AYRisWbMGwzB45JFHyOfzXHDBBfzHf/zHjPNd1+UTn/gEd911F7FYjNNOO41kMsmTTz6J53l88Ytf5B3veMeMayYmJrjkkkvYunUr7e3tLF26lO3bt7Np0ybC4TA//vGPj9nFx4HM4T/+4z/ywAMPcM455xAOh2cdX7ZsGe973/sq/z+U+62vr493vetdld8DXV1dbNiwgf7+fhoaGrjttttoamo6/BNwCHiexyc+8Ql+85vfYBgGK1asoLq6mt7eXgYGBggEAtxwww288pWvrFxzJL6zx9McSiSSYxhPcsQolUreOeec4/X09Hh33HFH5fF8Pu998IMf9Hp6erzPfe5zR2+AR4mPf/zjXk9Pj/fnP/95v+f+5S9/8Xp6erxzzjnHGxgYqDz+/PPPe2vWrPF6enq8tWvXzrjmP//zP72enh7vAx/4gJfP5yuP33nnnd7ixYu9V77ylV46nT58b+gIsGHDBu91r3ud19PT4/X09Hj/9m//NuucrVu3ekuWLPFOOeUU7/nnn688PjAw4L32ta/1enp6vLvuumvGNT/72c+8np4e721ve5uXTCYrjz/88MPeypUrvZUrV86Yd8/zvKuuusrr6enxPv3pT3u2bVcev+GGG7yenh7vTW96k+c4zuF664eNA5lDz/O8M844w1u6dKmXy+UO6HkP5X67+OKLvZ6eHu9b3/pW5THbtr3Pfvazlec6Vrjzzju9np4e78wzz/Q2btxYedy27cp7P/30071sNut53pH7zh5PcyiRSI5dpDA+gvzyl7/0enp6vPe+972zjo2Pj3snnniit3z5ci+VSh2F0R09Xv/613s9PT3e+Pj4fs+99NJLvZ6eHu9Xv/rVrGM//elPvZ6eHu8jH/lI5bFMJuOtXr3aW7p0qbd79+5Z15RF+Y9//OMX9iaOEMlk0vvKV77irVixwuvp6fHOPffceUXdJz/5Sa+np8e74YYbZh3785//7PX09Hhvf/vbZzz+mte8xuvp6fGefPLJWdd87Wtf83p6erz/+I//qDzW19fnLVmyxDv11FO9TCYz65qLLrrI6+np8R544IFDebsvCgczh8PDwxVxfyAcyv322GOPeT09Pd4b3vCGWQuIUqnknX322V5PT4+3efPmg3ynLw7vfve7vZ6eHu+Xv/zlrGOu63pvfOMbvZ6eHu/ee+/1PO/IfGePtzmUSCTHLrL47gjyxz/+EYDXv/71s47F43HWrFmDZVk89NBDR3poR41MJsPOnTtpaWkhHo/v99wnnngCwzA499xzZx1//etfj6Io/PnPf8Z1XQCeeOIJstksK1eunHMb9Q1veAOw57M51rnlllu46aabqK6u5oYbbuCCCy6Y99wHHngAmPt+O/3004lGozz33HMkEgkAtmzZQn9/P3V1dZx00kmzrplrrspzfeaZZ86ZH1++5v777z/g9/hiczBzuH79egBWrFhxQM99KPdb+efXvva1qOrMX8mGYfCa17wGOHbmMBqNsmDBAk4++eRZxxRFoaurC4CRkZEj9p093uZQIpEcu0hhfATZtGkTAIsXL57z+KJFiwDYuHHjERvT0eb555/H8zw6Ojr4zne+w5vf/GZWrVrFGWecwb/8y7+wffv2yrlbt27FcRxaWlrmFGHV1dXU1taSy+Xo6+sD9szlfHO+cOHCGecd6zQ2NvJ//s//4fe///2cQqNMIpFgfHwcn89XESrT0TStUiBVfu/7uz8XLlyIoijs3LmTYrF4wNdMf41jgQOdQ9gjjKPRKJ/5zGd43etex8qVK3nd617H1772NdLp9IzzD+V+O97m8Prrr+fuu++es6jScZzKnDU1NR2x7+zxNocSieTYRQrjI8jw8DAADQ0Ncx4vt0EdGRk5YmM62pT/iD788MN897vfpb6+njVr1gDwq1/9ir/927/l0UcfBfY/f7BnDkdHR4E9c1lfXz/n+eXHy1HTY513vOMdvO9978Pv9+/zvPJc1dXVzek8UT4Ge+aqfM18c+Xz+YhGoziOw9jY2Ixr9ndPl1/jWOBA5xD23J8333wz9913H4sWLeLEE08kkUhw4403cuGFF874vh7K/XY8zuF8/OQnP2FgYIB4PM4rXvGKI/adfSnNoUQiObpIu7YjSD6fB5j3D3L58Vwud8TGdLQpC4+TTjqJ6667rvIHrFQq8eUvf5lbb72Vj33sY9x7772VeQkEAvM+n8/nA/bM4f6uKZ/vui75fH6fz308Ub7XDmSustkssP+5mn5N+dyX+j29YcMGAN75znfyqU99CtM0ASHE/vmf/5knnniCq6++mu9///vAod1vL5U5/Otf/8pXvvIVAK666ioCgcAR+86+VOZQIpEcfaQwPoJomlbJo9sX3svIQe/aa6/liiuuoK6uboYVlmmafPrTn+app57i+eef51e/+tVB2diV51nTtIO+5qXA3nmW+6J8vx3KXB3oNcfr3N51110MDAzQ09MzI/Le0NDA1772Nc4//3weeughtm7dyoIFC162c/jHP/6Rj33sY5RKJd71rndVLP1ezPk4lGuO5TmUSCTHBjKV4ghSzrEr52fuTaFQAERDi5cLpmnS1dU1pz+spmmcffbZADz33HOV+SvP01yU57Y8h/u7pny+qqovmWgx7P99w8HP1aFcU378eG1cEw6HWbx48ZzpKE1NTSxbtgwQ9ycc2v12oL8XjtU5/NGPfsSVV15JoVDg0ksv5bOf/Wzl2JH6zh7vcyiRSI4dpDA+gpRz4+bLc9tfbt3LkXJVej6fr+QP7itPcO853N815dzEmpqag4qyHuuU3/e+cqcPdq4KhQKpVApVVSspL/u75qV+T5fvz/IW/aHcb+W5ma+24FidQ9u2+exnP8u//du/4bouV111Fddcc82syDq8+N/Z43UOJRLJscdLRwkcB5Qrpjdv3jzn8S1btsw476VOqVTis5/9LFdeeWWlmGtvBgcHASFAFi5ciK7r9Pf3zxkZGh8fZ2xsjEAgQHt7O7BnLstzuzcv1TmvqqqioaGBfD5Pf3//rOOO47Bt2zYAenp6gAOfq46Ojkqe54FeU36N44ktW7Zw9dVXz9tqG2ben3Bo99vxeI8WCgX+8R//kdtuuw2/3883vvENLr/88lnnHanv7PE4hxKJ5NhECuMjSDkt4J577pl1bGJigkcffRSfzzejlepLGdM0eeihh7jvvvv4wx/+MOt4qVTi7rvvBuDVr341Pp+PV7ziFZRKpTl9h3//+9/jeR6vfvWrKzmHJ598MuFwmLVr11YiTdP53e9+B8A555xzON/aMcG+7re//OUvpNNpli9fXomidXR00NXVxe7duyupAdOZa65e/epXo6oqf/7zn+fc+v79738/65rjBb/fzx133MHtt9/Ojh07Zh3fsWMHa9euJRgMcuqppwKHdr+VP6d77713Vn2BZVmV70b5vKON4zhceeWVPPTQQ1RXV/OjH/2o4i28N0fqO3u8zaFEIjl2kcL4CPLa176WlpYWHnjgAf7nf/6n8nihUODTn/40uVyOiy66iOrq6qM4yiPLu971LgC+/vWv09vbW3m8UCjwqU99ip07d3LaaadVFguXXXYZAF/+8pfZuXNn5fze3l6++c1vAsyIXPl8Pi6++GIsy+Lqq6+uODCAsIP73e9+R01NDRdeeOGL9yaPEu9617vQdZ0bbriBZ599tvL47t27+eIXvwjABz/4wRnXlOf3mmuumRHF/+tf/8ott9yCaZr8/d//feXxhoYGzjvvPMbHx/nc5z6HZVmVY9/73vdYu3YtixcvPi4FSWtrK2eddRYAn/zkJxkfH68cGxoa4iMf+QiO4/De9763kiN/KPfb6tWrOeGEE9i0aRPf+MY3KsLOcRyuvfZaBgcHOeecc46ZqPsNN9zAQw89RDAY5JZbbuGEE07Y5/lH4jt7vM2hRCI5dlG8l5MFwjHA448/zgc+8AEKhQLLly+ntbWVp59+mpGREVasWMEtt9zysioQsW2bj370o9x3333ous7q1auJx+M89dRTJBIJuru7ueWWWyo5rQCf//zn+clPflKJRjmOw6OPPoplWVx11VWztnTz+TyXXnopzz33HDU1NZxyyikMDQ3xzDPP4PP5uPHGGyveyccb3/rWt/j2t7/NZZddNueW/0033cRXv/pVdF3ntNNOw+fz8eijj5LL5bj44ov5/Oc/P+N813W54oor+OMf/0g4HGbNmjWk02meeOIJPM/jq1/9Km9+85tnXDM6Oso73/lO+vv7aWlpYcWKFWzfvp1NmzZRVVXFrbfeWmmwcCyyrzkcGRnh0ksvZceOHUQiEVavXg3AY489RqFQ4LzzzuM///M/0fU9Bj+Hcr9t3bqVSy65hImJCbq7u1m0aBHPP/88fX19tLa28tOf/vSYyI9NpVKcffbZ5HI5Ojs7Wbly5bznvvWtb+VVr3oVcGS+s8fLHEokkmMbKYyPAps2beLb3/42jz32GLlcjtbWVs4///wZkaeXE57ncfvtt3P77bezadMmHMehra2N888/n/e9732zXDo8z+OOO+7gpz/9KVu2bMHn87Fo0SLe+973Vlq/7k0ul+PGG2/k7rvvZvfu3cTjcU488USuuOIKlixZciTe5ovC/oQxwB/+8Aduvvlm1q9fX2nZe8kll/DWt751zoJDy7L48Y9/zB133MHOnTsJh8MsW7aMD37wg5xyyilzvsb4+Djf+c53uP/++xkZGak0arniiivm7JB2LLG/OcxkMtx0003cc8899Pf3YxgGixcv5h3veAdve9vb5nSsOJT7bWBggG9/+9s8+OCDpFIpmpqaOOuss/jgBz9ITU3NYX/fh8K9997Lhz/84QM69+qrr67sLhyp7+zxMIcSieTYRgpjiUQikUgkEokEmWMskUgkEolEIpEAUhhLJBKJRCKRSCSAFMYSiUQikUgkEgkghbFEIpFIJBKJRAJIYSyRSCQSiUQikQBSGEskEolEIpFIJIAUxhKJRCKRSCQSCSCFsUQikUgkEolEAkhhLJFIJBKJRCKRAKAf7QFIJC8nent7uf322/nrX//K8PAwxWKR6upqFi1axNlnn82FF16I3+8/2sM87CxevBiAH/7wh5x++ulHeTQSiUQikcyNFMYSyRHiuuuu44YbbsB1XcLhMO3t7RiGwejoKA8++CAPPvggN910E9dffz3Lly8/2sOVSCQSieRlhxTGEskR4Be/+AXXX389wWCQL33pS7zuda9D07TK8a1bt/KpT32KtWvX8v73v5+7776b6urqozhiiUQikUhefsgcY4nkCPDd734XgH/913/lDW94wwxRDLBgwQJuuOEGampqmJiY4JZbbjkaw5RIJBKJ5GWNFMYSyYtMKpWir68PgFWrVs17XnV1Na997WsBePbZZ4/I2CQSiUQikexBplJIJC8yur7na/bHP/6RZcuWzXvuP/3TP3HZZZdRU1Mz43HbtvnNb37D7373O9avX08ymUTXderr61mzZg3vfe976erqmnHNpZdeymOPPcYPf/hDwuEwN9xwA0899RTFYpGuri7e8573cMEFF+B5Hrfffjs//elP2bZtG5qmsWrVKj7ykY9w4oknznjOc889l4GBAe68806Gh4f57ne/y8aNGzFNk8WLF3PZZZdVxP2Bkkgk+MEPfsADDzzAwMAAqqrS3d3NG9/4Ri655BJ8Pt9BPZ9EIpFIJIeK4nmed7QHIZG81HnnO9/JU089haIoXHDBBbz97W/npJNOmpVSMReFQoHLL7+cRx99FICWlhbi8ThjY2MMDg4CEAwGufXWW2eI7rIw/ru/+zt+8YtfYJomnZ2d7N69m2QyCcDnPvc5nnrqKX79619TU1NDQ0MDmzdvxrIsTNPk5z//OUuWLKk8Z1kYX3rppfzoRz/CNE0WLVpEIpFgeHi48rrXXHPNjPcwnyvFk08+yRVXXEEymcQwDDo7O/E8j61bt+J5HkuWLOGmm26irq7uEGZdIpFIJJKDQwpjieQIsGHDBi655BJyuVzlsXA4zMknn8wpp5zCmjVrWLlyJao6O7vpW9/6Ft/+9reJx+P813/9FyeccELl2LPPPssVV1zB6Ogo5513Htddd13lWFkYA5x33nlce+21RCIRisUiV1xxBQ899BCqqmIYBl/84hd561vfCsDAwACXXHIJg4OD/O3f/i1f+tKXKs9ZFsYAp59+Ol/72teoqanB8zx+/vOf8/nPfx7btvn617/Om970psp1cwnj4eFh3vKWt5BMJrnooov4l3/5F6LRKAB9fX184hOf4JlnnuGUU07h1ltvfWEfgEQikUgkB4DMMZZIjgDLli3j5z//OSeffHLlsUwmw5/+9Ce+/vWvc9FFF3HmmWfy//7f/yOfz8+49uGHH0ZVVT784Q/PEMUAJ5xwAu985zsB2LRp05yvXVVVxZe//GUikQgAPp+P9773vQC4rssHPvCBiigGEZG+8MILAVi/fv2cz9nc3My3v/3tSsqHoihcdNFFvP/97wfg29/+9n7n5Pvf/z7JZJJzzz2XL37xixVRDNDe3s53vvMdwuEwTzzxBH/605/2+3wSiUQikbxQpDCWSI4QCxcu5Cc/+Ql33nknH/7wh1m9ejWGYVSOj42N8d3vfpe3vOUtDA0NVR7/6U9/yrPPPsvFF1885/MGAgFApFzMxZo1awgGgzMea2lpqfx81llnzbqmvr4eEOJ9Li666CJCodCsx8tj3L59O9u2bZvz2jL33XcfAG95y1vmPF5bW8sZZ5wBiNxsiUQikUhebGTxnURyhFm6dClLly7ln/7pn8jn8zz11FM89NBD/O///i9jY2P09fXx0Y9+lNtuu61yjWEYpFIp1q5dy44dO+jv72fHjh08//zzJBIJQER/56KxsXHWY9MF+Vx+ydMLBudi78h1mebmZiKRCOl0mh07dtDd3T3nedlstpKS8Z3vfGdee7ryOfsT2RKJRCKRHA6kMJZIjiKBQIAzzjiDM844g49+9KN86lOf4q677mLt2rWsX7+e5cuXk8lkuPbaa/n1r3+NZVmVaw3DYPny5SxdupQHH3xwn6+xLxRFOehxx2KxeY8Fg0HS6TSTk5PznjM9Ej1fCsh00un0wQ1QIpFIJJJDQApjieRF5rOf/SyPPPIIb3vb2/jQhz4073l+v58vfOEL3HPPPViWxfbt21m+fDlXXHEFjz76KH6/n3e/+92sWrWKRYsW0dHRgWEY/OxnP9unMH4x2DsPejpl0bu35dx0pov1X//61/T09By+wUkkEolEcojIHGOJ5EWmWCyyc+fOSk7tvgiHw5Xc3erqatauXVuxafve977HJz/5Sc4//3wWLlxYSYeYno98pJgvytvX10c2mwVETvV8RKNRamtrAdiyZcu8523cuJHnn3+eVCr1AkYrkUgkEsmBIYWxRPIiUy4uW7duHXfcccc+z33ooYdIJpNUVVWxatUqdu3aVTm2YsWKWefn83nuuusuABzHOYyj3jd33HHHnDnNP/3pTwE48cQTaWpq2udznH322QD8+Mc/nvO50uk0l112GRdccAH//d///cIHLZFIJBLJfpDCWCJ5kTnjjDM477zzALjmmmu49tprZwheEFHlX/ziF3zsYx8D4GMf+xihUGhG8dr1118/I8d4y5Yt/MM//AM7duwA9p3ecLhZt24dn/nMZyqv6bouP/7xj7n55psB+PjHP77f57j88ssJBoM8+eST/Mu//Avj4+OVYwMDA1x++eUkk0kikQiXXHLJi/I+JBKJRCKZjswxlkiOAF/72tcIBoPceeed3HLLLdxyyy00NzdTU1NDsVhkx44dlEolDMPgqquuqngTL1u2jPPPP5/f/va3/OAHP+COO+6gtbWVZDJZEddnnHEGf/nLX8hms2QyGcLh8Iv+fnp6erj99tv57W9/S3d3N0NDQ4yOjqKqKldffTWveMUr9vscHR0dfOMb3+DjH/84v/nNb/j973/PwoULsSyLHTt2YNs2wWCQ//qv/9pnvrJEIpFIJIcLKYwlkiOAaZp8+ctf5pJLLuHuu+/m0UcfZXh4mN7eXgKBAF1dXZx55plceOGFsyzOvv71r3P66afzs5/9jL6+PjZu3Eg8Huecc87h4osv5uyzz+acc85h9+7d3H///fP6Ah9OLrvsMoLBID/4wQ/YtGkT0WiU8847j/e///2sWrXqgJ/nrLPO4q677uLmm2/mwQcfZPv27TiOQ0tLC2eccQbve9/7aGtrexHfiUQikUgke5AtoSUSyQFTbgn9b//2b7zjHe842sORSCQSieSwInOMJRKJRCKRSCQSpDCWSCQSiUQikUgAKYwlEolEIpFIJBJACmOJRCKRSCQSiQSQxXcSiUQikUgkEgkgI8YSiUQikUgkEgkghbFEIpFIJBKJRAJIYSyRSCQSiUQikQBSGEskEolEIpFIJIAUxhKJRCKRSCQSCSCFsUQikUgkEolEAkhhLJFIJBKJRCKRAFIYSyQSiUQikUgkAPx/RYbouoJZHr0AAAAASUVORK5CYII=", + "text/plain": [ + "
" ] }, "metadata": {}, @@ -1837,526 +1677,3840 @@ } ], "source": [ - "with sns.plotting_context('notebook', font_scale=1.2):\n", - "\n", - " fig, axmatrix = plt.subplots(ncols=3, figsize=(8,3.5))\n", - "\n", - " for ax in axmatrix.flatten():\n", - " ax.set_aspect('equal')\n", - "\n", - " def plot_hpd_err(truth, ppc, ax, color=None):\n", - " median = ppc.median(dim=['chain','draw'])\n", - " hpd = pm.hdi(ppc)\n", - " err = np.abs(hpd - median).to_array()[0]#median[:, np.newaxis])\n", + "fig = plt.figure(figsize=(6,3))\n", "\n", - " return ax.errorbar(truth, median, yerr=err.T, ls='',\n", - " marker='.', elinewidth=1., color=color)\n", + "ax = plt.subplot2grid((1, 4), (0, 0), colspan=3)\n", "\n", - " plot_hpd_err(vn * v_star[0] - 2, ppc.posterior_predictive['v_hat_obs'] * v_star[0], axmatrix[0])\n", - " plot_hpd_err(x['2PG'].values - 3, x_star[0] * np.exp(ppc.posterior_predictive['chi_obs'][:,:,:,0]),\n", - " axmatrix[1])\n", - " l0 = plot_hpd_err(x['PEP'].values - 1.25, x_star[1] * np.exp(ppc.posterior_predictive['chi_obs'][:,:,:,1]),\n", - " axmatrix[2])\n", + "ax.plot(ex, '.', ms=4, alpha=.25, rasterized=True)\n", + "ax.axvspan(500, 1000, zorder=0, color='.85')\n", + "ax.axvspan(1500, 2000, zorder=0, color='.85')\n", + "ax.set_xlim([0, 2000])\n", "\n", - " plot_hpd_err(vn * v_star[0] + 2, ppc_vi.posterior_predictive['v_hat_obs'] * v_star[0], axmatrix[0], 'g')\n", - " plot_hpd_err(x['2PG'].values + 3, x_star[0] * np.exp(ppc_vi.posterior_predictive['chi_obs'][:,:,:,0]),\n", - " axmatrix[1], 'g')\n", - " l1 = plot_hpd_err(x['PEP'].values + 1.25, x_star[1] * np.exp(ppc_vi.posterior_predictive['chi_obs'][:,:,:,1]),\n", - " axmatrix[2], 'g')\n", "\n", - " axmatrix[0].set_title('Flux')\n", - " axmatrix[1].set_title('2PG')\n", - " axmatrix[2].set_title('PEP')\n", - " # axmatrix[3].set_title('Enzymes')\n", + "sns.despine(trim=True, offset=10, ax=ax)\n", + "ax.set_ylabel('Elasticity')\n", + "ax.set_xlabel('Sample')\n", "\n", - " axmatrix[1].set_xlabel('Measured')\n", - " axmatrix[0].set_ylabel('Predicted')\n", + "ax2 = plt.subplot2grid((1, 4), (0, 3), colspan=1, fig=fig, sharey=ax)\n", + "ax2.xaxis.set_visible(False)\n", + "sns.despine(trim=True, offset=10, ax=ax2, bottom=True)\n", "\n", - " fig.tight_layout()\n", + "colors = sns.color_palette()\n", + "for i in ex.mean(0).argsort()[::-1]:\n", + " x, y = pm.kde(ex[:, i])\n", + " ax2.plot(y, x, label=e_labels[i], color=colors[i])\n", "\n", - " ax0 = [75, 175]\n", - " ax2 = [40, 125]\n", + "plt.setp(ax2.get_yticklabels(), visible=False)\n", + "plt.tight_layout()\n", " \n", - " axmatrix[0].set_xlim(*ax0)\n", - " axmatrix[0].set_ylim(ax0)\n", - " axmatrix[0].plot(ax0, ax0, '--', color='.7', zorder=0)\n", - "\n", - " axmatrix[1].set_xlim([0, 300])\n", - " axmatrix[1].set_ylim([0, 300])\n", - " axmatrix[1].plot([0, 300], [0, 300], '--', color='.7', zorder=0)\n", - "\n", - " axmatrix[2].set_xlim(*ax2)\n", - " axmatrix[2].set_ylim(*ax2)\n", - " axmatrix[2].plot(ax2, ax2, '--', color='.7', zorder=0)\n", - "\n", - " # axmatrix[3].plot([0, 60], [0, 60], '--', color='.7', zorder=0)\n", - "\n", - " axmatrix[0].set_yticks(np.arange(75, 200, 25))\n", - " axmatrix[0].set_xticks(np.arange(75, 200, 25))\n", - "\n", - " axmatrix[1].set_yticks(np.arange(0, 350, 100))\n", - " axmatrix[1].set_xticks(np.arange(0, 350, 100))\n", - "\n", - " axmatrix[2].set_yticks(np.arange(50, 150, 25))\n", - " axmatrix[2].set_xticks(np.arange(50, 150, 25))\n", - "\n", - " leg = plt.legend([l0, l1], ['NUTS', 'ADVI'],\n", - " loc='lower right', borderpad=0, borderaxespad=0)\n", - "\n", - " sns.despine(trim=False, offset=10)\n", - " # fig.savefig('ppc_predictions.svg')" - ] - }, - { - "cell_type": "code", - "execution_count": 425, - "metadata": {}, - "outputs": [], - "source": [ - "ex = trace.posterior['Ex'].to_numpy().reshape((2000, -1))\n", - "ey = trace.posterior['Ey'].to_numpy().reshape((2000, -1))\n", - "e_all = np.hstack([ex, ey])" + "ax2.legend(loc='center left', fontsize=12, bbox_to_anchor=(1.2, .5), labelspacing=0)\n", + " \n", + "# plt.savefig('wu_trace_subset.svg', dpi=200)" ] }, { "cell_type": "code", - "execution_count": 649, + "execution_count": 23, "metadata": {}, "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", - "
$\\epsilon_{PGM,2pg}$$\\epsilon_{PGM,pep}$$\\epsilon_{ENO,2pg}$$\\epsilon_{ENO,pep}$$\\epsilon_{PK,2pg}$$\\epsilon_{PK,pep}$$\\epsilon_{PGM,BPG}$$\\epsilon_{PGM,ADP}$$\\epsilon_{ENO,BPG}$$\\epsilon_{ENO,ADP}$$\\epsilon_{PK,BPG}$$\\epsilon_{PK,ADP}$
0-0.564027-0.9432040.734475-2.135916-0.2803690.1052150.4809870.095886-0.062107-0.109226-0.1294010.627063
1-0.428349-0.5282180.981039-1.284189-0.1423460.5440190.8523300.3394210.3228370.1630740.1606230.896983
\n", - "
" - ], - "text/plain": [ - " $\\epsilon_{PGM,2pg}$ $\\epsilon_{PGM,pep}$ $\\epsilon_{ENO,2pg}$ \\\n", - "0 -0.564027 -0.943204 0.734475 \n", - "1 -0.428349 -0.528218 0.981039 \n", + "html[theme=dark],\n", + "body[data-theme=dark],\n", + "body.vscode-dark {\n", + " --xr-font-color0: rgba(255, 255, 255, 1);\n", + " --xr-font-color2: rgba(255, 255, 255, 0.54);\n", + " --xr-font-color3: rgba(255, 255, 255, 0.38);\n", + " --xr-border-color: #1F1F1F;\n", + " --xr-disabled-color: #515151;\n", + " --xr-background-color: #111111;\n", + " --xr-background-color-row-even: #111111;\n", + " --xr-background-color-row-odd: #313131;\n", + "}\n", "\n", - " $\\epsilon_{ENO,pep}$ $\\epsilon_{PK,2pg}$ $\\epsilon_{PK,pep}$ \\\n", - "0 -2.135916 -0.280369 0.105215 \n", - "1 -1.284189 -0.142346 0.544019 \n", + ".xr-wrap {\n", + " display: block !important;\n", + " min-width: 300px;\n", + " max-width: 700px;\n", + "}\n", "\n", - " $\\epsilon_{PGM,BPG}$ $\\epsilon_{PGM,ADP}$ $\\epsilon_{ENO,BPG}$ \\\n", - "0 0.480987 0.095886 -0.062107 \n", - "1 0.852330 0.339421 0.322837 \n", + ".xr-text-repr-fallback {\n", + " /* fallback to plain text repr when CSS is not injected (untrusted notebook) */\n", + " display: none;\n", + "}\n", "\n", - " $\\epsilon_{ENO,ADP}$ $\\epsilon_{PK,BPG}$ $\\epsilon_{PK,ADP}$ \n", - "0 -0.109226 -0.129401 0.627063 \n", - "1 0.163074 0.160623 0.896983 " - ] - }, - "execution_count": 649, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "e_df = pd.DataFrame(e_all, columns=e_labels)\n", - "\n", - "# Create an empty DataFrame to store HDI results in wide format\n", - "hdi_results = pd.DataFrame(columns=e_df.columns)\n", - "\n", - "# Iterate through each column and calculate HDI separately\n", - "for column in e_df.columns:\n", - " hdi = pm.hdi(e_df[column].values)\n", - " hdi_results[column] = hdi\n", - "\n", - "# Display or use the DataFrame with HDI results in wide format\n", - "hdi_results\n", - "\n", - "e_df = hdi_results\n", - "e_df" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Here we calculate the flux control coefficients for both the ADVI and NUTS posteriors" - ] - }, - { - "cell_type": "code", - "execution_count": 443, - "metadata": {}, - "outputs": [], - "source": [ - "fcc = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace.posterior['Ex'][0].to_numpy()])\n", - "fcc_mb = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_vi.posterior['Ex'][0].to_numpy()])\n", - "fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()])" - ] - }, - { - "cell_type": "code", - "execution_count": 560, - "metadata": {}, - "outputs": [], - "source": [ - "# Control coefficients estimated from elasticities\n", - "# Wu table 7\n", - "\n", - "wu_ccs = np.array([-0.34 , 0.14 , 1.20])" - ] - }, - { - "cell_type": "code", - "execution_count": 445, - "metadata": {}, - "outputs": [], - "source": [ - "df1 = pd.DataFrame(fcc[:, 0], columns=[r.id for r in model.reactions]\n", - " ).stack().reset_index(level=1)\n", - "df2 = pd.DataFrame(fcc_mb[:, 0], columns=[r.id for r in model.reactions]\n", - " ).stack().reset_index(level=1)\n", - "df3 = pd.DataFrame(fcc_prior[:, 0], columns=[r.id for r in model.reactions]\n", - " ).stack().reset_index(level=1)\n", - "\n", - "df1['type'] = 'NUTS'\n", - "df2['type'] = 'ADVI'\n", - "df3['type'] = 'Prior'\n", - "\n", - "\n", - "fcc_df = pd.concat([df1, df2, df3])\n", - "fcc_df.columns = ['Reaction', 'FCC', 'Type']\n", - "\n", - "fcc_df.loc[fcc_df.FCC < -.5, 'FCC'] = np.nan\n", - "fcc_df.loc[fcc_df.FCC > 1.5, 'FCC'] = np.nan" - ] - }, - { - "cell_type": "code", - "execution_count": 446, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 446, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ax.patches" - ] - }, - { - "cell_type": "code", - "execution_count": 573, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import seaborn as sns\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Reset index to avoid duplicate labels\n", - "fcc_df_reset = fcc_df.reset_index()\n", - "\n", - "# Create a figure and axes\n", - "fig = plt.figure(figsize=(8, 4))\n", - "ax = fig.add_subplot(111)\n", - "ax2 = fig.add_subplot(111, frameon=False, sharex=ax, sharey=ax)\n", - "\n", - "# Define palette colors for different types\n", - "my_pal = {\"Prior\": \".8\", \"NUTS\": \"g\", \"ADVI\": \"b\"}\n", - "\n", - "# Filter data for specific type 'Prior'\n", - "data_prior = fcc_df_reset[fcc_df_reset.Type == 'Prior']\n", - "\n", - "# Create violin plot for 'Prior' type on ax\n", - "sns.violinplot(\n", - " x='Reaction', y='FCC', hue='Type', data=data_prior,\n", - " density_norm='width', width=0.5, palette=my_pal, saturation=1., alpha=0.1, ax=ax\n", - ")\n", - "\n", - "# Create violin plot for all types ('NUTS' and 'ADVI') on ax2 (twin axes)\n", - "sns.violinplot(\n", - " x='Reaction', y='FCC', hue='Type', data=fcc_df_reset,\n", + ".xr-header {\n", + " padding-top: 6px;\n", + " padding-bottom: 6px;\n", + " margin-bottom: 4px;\n", + " border-bottom: solid 1px var(--xr-border-color);\n", + "}\n", + "\n", + ".xr-header > div,\n", + ".xr-header > ul {\n", + " display: inline;\n", + " margin-top: 0;\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-obj-type,\n", + ".xr-array-name {\n", + " margin-left: 2px;\n", + " margin-right: 10px;\n", + "}\n", + "\n", + ".xr-obj-type {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-sections {\n", + " padding-left: 0 !important;\n", + " display: grid;\n", + " grid-template-columns: 150px auto auto 1fr 20px 20px;\n", + "}\n", + "\n", + ".xr-section-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-section-item input {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-item input + label {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label {\n", + " cursor: pointer;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-item input:enabled + label:hover {\n", + " color: var(--xr-font-color0);\n", + "}\n", + "\n", + ".xr-section-summary {\n", + " grid-column: 1;\n", + " color: var(--xr-font-color2);\n", + " font-weight: 500;\n", + "}\n", + "\n", + ".xr-section-summary > span {\n", + " display: inline-block;\n", + " padding-left: 0.5em;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label {\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-section-summary-in + label:before {\n", + " display: inline-block;\n", + " content: 'â–º';\n", + " font-size: 11px;\n", + " width: 15px;\n", + " text-align: center;\n", + "}\n", + "\n", + ".xr-section-summary-in:disabled + label:before {\n", + " color: var(--xr-disabled-color);\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label:before {\n", + " content: 'â–¼';\n", + "}\n", + "\n", + ".xr-section-summary-in:checked + label > span {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-section-summary,\n", + ".xr-section-inline-details {\n", + " padding-top: 4px;\n", + " padding-bottom: 4px;\n", + "}\n", + "\n", + ".xr-section-inline-details {\n", + " grid-column: 2 / -1;\n", + "}\n", + "\n", + ".xr-section-details {\n", + " display: none;\n", + " grid-column: 1 / -1;\n", + " margin-bottom: 5px;\n", + "}\n", + "\n", + ".xr-section-summary-in:checked ~ .xr-section-details {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-array-wrap {\n", + " grid-column: 1 / -1;\n", + " display: grid;\n", + " grid-template-columns: 20px auto;\n", + "}\n", + "\n", + ".xr-array-wrap > label {\n", + " grid-column: 1;\n", + " vertical-align: top;\n", + "}\n", + "\n", + ".xr-preview {\n", + " color: var(--xr-font-color3);\n", + "}\n", + "\n", + ".xr-array-preview,\n", + ".xr-array-data {\n", + " padding: 0 5px !important;\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-array-data,\n", + ".xr-array-in:checked ~ .xr-array-preview {\n", + " display: none;\n", + "}\n", + "\n", + ".xr-array-in:checked ~ .xr-array-data,\n", + ".xr-array-preview {\n", + " display: inline-block;\n", + "}\n", + "\n", + ".xr-dim-list {\n", + " display: inline-block !important;\n", + " list-style: none;\n", + " padding: 0 !important;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list li {\n", + " display: inline-block;\n", + " padding: 0;\n", + " margin: 0;\n", + "}\n", + "\n", + ".xr-dim-list:before {\n", + " content: '(';\n", + "}\n", + "\n", + ".xr-dim-list:after {\n", + " content: ')';\n", + "}\n", + "\n", + ".xr-dim-list li:not(:last-child):after {\n", + " content: ',';\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-has-index {\n", + " font-weight: bold;\n", + "}\n", + "\n", + ".xr-var-list,\n", + ".xr-var-item {\n", + " display: contents;\n", + "}\n", + "\n", + ".xr-var-item > div,\n", + ".xr-var-item label,\n", + ".xr-var-item > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-even);\n", + " margin-bottom: 0;\n", + "}\n", + "\n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", + "\n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", + "\n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                   (ey_kinetic_entries_dim_0: 2, hdi: 2)\n",
+       "Coordinates:\n",
+       "  * ey_kinetic_entries_dim_0  (ey_kinetic_entries_dim_0) int64 0 1\n",
+       "  * hdi                       (hdi) <U6 'lower' 'higher'\n",
+       "Data variables:\n",
+       "    ey_kinetic_entries        (ey_kinetic_entries_dim_0, hdi) float64 0.4723 ...
" + ], + "text/plain": [ + "\n", + "Dimensions: (ey_kinetic_entries_dim_0: 2, hdi: 2)\n", + "Coordinates:\n", + " * ey_kinetic_entries_dim_0 (ey_kinetic_entries_dim_0) int64 0 1\n", + " * hdi (hdi) \n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
<xarray.Dataset>\n",
+       "Dimensions:                    (ey_capacity_entries_dim_0: 4, hdi: 2)\n",
+       "Coordinates:\n",
+       "  * ey_capacity_entries_dim_0  (ey_capacity_entries_dim_0) int64 0 1 2 3\n",
+       "  * hdi                        (hdi) <U6 'lower' 'higher'\n",
+       "Data variables:\n",
+       "    ey_capacity_entries        (ey_capacity_entries_dim_0, hdi) float64 0.097...
" + ], + "text/plain": [ + "\n", + "Dimensions: (ey_capacity_entries_dim_0: 4, hdi: 2)\n", + "Coordinates:\n", + " * ey_capacity_entries_dim_0 (ey_capacity_entries_dim_0) int64 0 1 2 3\n", + " * hdi (hdi) " + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axmatrix = plt.subplots(nrows=12, ncols=12, figsize=(6, 6))\n", + "\n", + "for ax in axmatrix.flatten():\n", + " ax.get_xaxis().set_ticks([])\n", + " ax.get_yaxis().set_ticks([])\n", + "\n", + "for i in range(12):\n", + " for j in range(12):\n", + " if i is not j:\n", + " axmatrix[i,j].plot(e_all[:, i], e_all[:, j],\n", + " 'k.', alpha=0.1, ms=1, rasterized=True)\n", + " else:\n", + " axmatrix[i,j].hist(e_all[:, i], bins=5, color='k', edgecolor='w', lw=1)\n", + " \n", + "_ = ax_all = fig.add_subplot(111, frameon=False)\n", + "_ = ax_all.set_xticks(np.arange(12) + 0.5)\n", + "_ = ax_all.set_xticklabels(e_labels, rotation=90)\n", + "_ = ax_all.set_yticks(np.arange(12) + 0.5)\n", + "_ = ax_all.set_yticklabels(e_labels[::-1])\n", + "\n", + "ax_all.set_xlim([0.1, 11.9])\n", + "ax_all.set_ylim([0.1, 11.9])\n", + "\n", + "# fig.savefig('elasticity_pairplot.svg', dpi=400, transparent=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Sampling: [chi_obs, v_hat_obs]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [2000/2000 00:00<00:00]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with pymc_model:\n", + " ppc = pm.sample_posterior_predictive(trace)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Equivalent approach using variational inference\n", + "\n", + "Here we approximate the posterior distribution using ADVI to compare the two methods." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [25000/25000 00:26<00:00 Average Loss = -25.087]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "Finished [100%]: Average Loss = -25.087\n", + "Sampling: [chi_obs, v_hat_obs]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "\n", + "
\n", + " \n", + " 100.00% [1000/1000 00:00<00:00]\n", + "
\n", + " " + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with pymc_model:\n", + " approx = pm.ADVI()\n", + " hist = approx.fit(n=25000, obj_optimizer=pm.adagrad_window(learning_rate=5E-3),\n", + " obj_n_mc=1)\n", + " \n", + "with pymc_model:\n", + " trace_vi = hist.sample(1000)\n", + " ppc_vi = pm.sample_posterior_predictive(trace_vi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "ADVI is an optimization-based method, so we monitor the evidence lower bound to check convergence" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with sns.plotting_context('notebook', font_scale=1.2):\n", + "\n", + " fig = plt.figure(figsize=(5,4))\n", + " plt.plot(approx.hist + 30, '.', rasterized=True, ms=1)\n", + " plt.ylim([-1E1, 1E3])\n", + " plt.xlim([0, 25000])\n", + " sns.despine(trim=True, offset=10)\n", + "\n", + " plt.ylabel('-ELBO')\n", + " plt.xlabel('Iteration')\n", + " plt.title('in vitro ADVI convergence')\n", + " plt.tight_layout()\n", + " # plt.savefig('wu_elbo.svg', transparent=True, dpi=200)" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "x = giersch.loc[:, ['2PG', 'PEP']]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "with sns.plotting_context('notebook', font_scale=1.2):\n", + "\n", + " fig, axmatrix = plt.subplots(ncols=3, figsize=(8,3.5))\n", + "\n", + " for ax in axmatrix.flatten():\n", + " ax.set_aspect('equal')\n", + "\n", + " def plot_hpd_err(truth, ppc, ax, color=None):\n", + " median = ppc.median(dim=['chain','draw'])\n", + " hpd = pm.hdi(ppc)\n", + " err = np.abs(hpd - median).to_array()[0]#median[:, np.newaxis])\n", + "\n", + " return ax.errorbar(truth, median, yerr=err.T, ls='',\n", + " marker='.', elinewidth=1., color=color)\n", + "\n", + " plot_hpd_err(vn * v_star[0] - 2, ppc.posterior_predictive['v_hat_obs'] * v_star[0], axmatrix[0])\n", + " plot_hpd_err(x['2PG'].values - 3, x_star[0] * np.exp(ppc.posterior_predictive['chi_obs'][:,:,:,0]),\n", + " axmatrix[1])\n", + " l0 = plot_hpd_err(x['PEP'].values - 1.25, x_star[1] * np.exp(ppc.posterior_predictive['chi_obs'][:,:,:,1]),\n", + " axmatrix[2])\n", + "\n", + " plot_hpd_err(vn * v_star[0] + 2, ppc_vi.posterior_predictive['v_hat_obs'] * v_star[0], axmatrix[0], 'g')\n", + " plot_hpd_err(x['2PG'].values + 3, x_star[0] * np.exp(ppc_vi.posterior_predictive['chi_obs'][:,:,:,0]),\n", + " axmatrix[1], 'g')\n", + " l1 = plot_hpd_err(x['PEP'].values + 1.25, x_star[1] * np.exp(ppc_vi.posterior_predictive['chi_obs'][:,:,:,1]),\n", + " axmatrix[2], 'g')\n", + "\n", + " axmatrix[0].set_title('Flux')\n", + " axmatrix[1].set_title('2PG')\n", + " axmatrix[2].set_title('PEP')\n", + " # axmatrix[3].set_title('Enzymes')\n", + "\n", + " axmatrix[1].set_xlabel('Measured')\n", + " axmatrix[0].set_ylabel('Predicted')\n", + "\n", + " fig.tight_layout()\n", + "\n", + " ax0 = [75, 175]\n", + " ax2 = [40, 125]\n", + " \n", + " axmatrix[0].set_xlim(*ax0)\n", + " axmatrix[0].set_ylim(ax0)\n", + " axmatrix[0].plot(ax0, ax0, '--', color='.7', zorder=0)\n", + "\n", + " axmatrix[1].set_xlim([0, 300])\n", + " axmatrix[1].set_ylim([0, 300])\n", + " axmatrix[1].plot([0, 300], [0, 300], '--', color='.7', zorder=0)\n", + "\n", + " axmatrix[2].set_xlim(*ax2)\n", + " axmatrix[2].set_ylim(*ax2)\n", + " axmatrix[2].plot(ax2, ax2, '--', color='.7', zorder=0)\n", + "\n", + " # axmatrix[3].plot([0, 60], [0, 60], '--', color='.7', zorder=0)\n", + "\n", + " axmatrix[0].set_yticks(np.arange(75, 200, 25))\n", + " axmatrix[0].set_xticks(np.arange(75, 200, 25))\n", + "\n", + " axmatrix[1].set_yticks(np.arange(0, 350, 100))\n", + " axmatrix[1].set_xticks(np.arange(0, 350, 100))\n", + "\n", + " axmatrix[2].set_yticks(np.arange(50, 150, 25))\n", + " axmatrix[2].set_xticks(np.arange(50, 150, 25))\n", + "\n", + " leg = plt.legend([l0, l1], ['NUTS', 'ADVI'],\n", + " loc='lower right', borderpad=0, borderaxespad=0)\n", + "\n", + " sns.despine(trim=False, offset=10)\n", + " # fig.savefig('ppc_predictions.svg')" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "ex = trace.posterior['Ex'].to_numpy().reshape((2000, -1))\n", + "ey = trace.posterior['Ey'].to_numpy().reshape((2000, -1))\n", + "e_all = np.hstack([ex, ey])" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "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", + "
$\\epsilon_{PGM,2pg}$$\\epsilon_{PGM,pep}$$\\epsilon_{ENO,2pg}$$\\epsilon_{ENO,pep}$$\\epsilon_{PK,2pg}$$\\epsilon_{PK,pep}$$\\epsilon_{PGM,BPG}$$\\epsilon_{PGM,ADP}$$\\epsilon_{ENO,BPG}$$\\epsilon_{ENO,ADP}$$\\epsilon_{PK,BPG}$$\\epsilon_{PK,ADP}$
0-0.565769-0.9668390.748056-2.143378-0.2810240.0892170.4722630.097616-0.086974-0.092187-0.1287480.628726
1-0.426731-0.5212071.004549-1.267993-0.1354570.5505570.8478380.3516180.3015580.1768120.1464930.895259
\n", + "
" + ], + "text/plain": [ + " $\\epsilon_{PGM,2pg}$ $\\epsilon_{PGM,pep}$ $\\epsilon_{ENO,2pg}$ \\\n", + "0 -0.565769 -0.966839 0.748056 \n", + "1 -0.426731 -0.521207 1.004549 \n", + "\n", + " $\\epsilon_{ENO,pep}$ $\\epsilon_{PK,2pg}$ $\\epsilon_{PK,pep}$ \\\n", + "0 -2.143378 -0.281024 0.089217 \n", + "1 -1.267993 -0.135457 0.550557 \n", + "\n", + " $\\epsilon_{PGM,BPG}$ $\\epsilon_{PGM,ADP}$ $\\epsilon_{ENO,BPG}$ \\\n", + "0 0.472263 0.097616 -0.086974 \n", + "1 0.847838 0.351618 0.301558 \n", + "\n", + " $\\epsilon_{ENO,ADP}$ $\\epsilon_{PK,BPG}$ $\\epsilon_{PK,ADP}$ \n", + "0 -0.092187 -0.128748 0.628726 \n", + "1 0.176812 0.146493 0.895259 " + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "e_df = pd.DataFrame(e_all, columns=e_labels)\n", + "\n", + "# Create an empty DataFrame to store HDI results in wide format\n", + "hdi_results = pd.DataFrame(columns=e_df.columns)\n", + "\n", + "# Iterate through each column and calculate HDI separately\n", + "for column in e_df.columns:\n", + " hdi = pm.hdi(e_df[column].values)\n", + " hdi_results[column] = hdi\n", + "\n", + "# Display or use the DataFrame with HDI results in wide format\n", + "hdi_results\n", + "\n", + "e_df = hdi_results\n", + "e_df" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we calculate the flux control coefficients for both the ADVI and NUTS posteriors" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "fcc = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace.posterior['Ex'][0].to_numpy()])\n", + "fcc_mb = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_vi.posterior['Ex'][0].to_numpy()])\n", + "fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()])" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "# Control coefficients estimated from elasticities\n", + "# Wu table 7\n", + "\n", + "wu_ccs = np.array([-0.34 , 0.14 , 1.20])" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [], + "source": [ + "df1 = pd.DataFrame(fcc[:, 0], columns=[r.id for r in model.reactions]\n", + " ).stack().reset_index(level=1)\n", + "df2 = pd.DataFrame(fcc_mb[:, 0], columns=[r.id for r in model.reactions]\n", + " ).stack().reset_index(level=1)\n", + "df3 = pd.DataFrame(fcc_prior[:, 0], columns=[r.id for r in model.reactions]\n", + " ).stack().reset_index(level=1)\n", + "\n", + "df1['type'] = 'NUTS'\n", + "df2['type'] = 'ADVI'\n", + "df3['type'] = 'Prior'\n", + "\n", + "\n", + "fcc_df = pd.concat([df1, df2, df3])\n", + "fcc_df.columns = ['Reaction', 'FCC', 'Type']\n", + "\n", + "fcc_df.loc[fcc_df.FCC < -.5, 'FCC'] = np.nan\n", + "fcc_df.loc[fcc_df.FCC > 1.5, 'FCC'] = np.nan" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ax.patches" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Reset index to avoid duplicate labels\n", + "fcc_df_reset = fcc_df.reset_index()\n", + "\n", + "# Create a figure and axes\n", + "fig = plt.figure(figsize=(8, 4))\n", + "ax = fig.add_subplot(111)\n", + "ax2 = fig.add_subplot(111, frameon=False, sharex=ax, sharey=ax)\n", + "\n", + "# Define palette colors for different types\n", + "my_pal = {\"Prior\": \".8\", \"NUTS\": \"g\", \"ADVI\": \"b\"}\n", + "\n", + "# Filter data for specific type 'Prior'\n", + "data_prior = fcc_df_reset[fcc_df_reset.Type == 'Prior']\n", + "\n", + "# Create violin plot for 'Prior' type on ax\n", + "sns.violinplot(\n", + " x='Reaction', y='FCC', hue='Type', data=data_prior,\n", + " density_norm='width', width=0.5, palette=my_pal, saturation=1., alpha=0.1, ax=ax\n", + ")\n", + "\n", + "# Create violin plot for all types ('NUTS' and 'ADVI') on ax2 (twin axes)\n", + "sns.violinplot(\n", + " x='Reaction', y='FCC', hue='Type', data=fcc_df_reset,\n", " density_norm='width', width=0.8, hue_order=['NUTS', 'ADVI'],\n", " palette=my_pal, ax=ax2\n", ")\n", "\n", - "# Additional plot elements or customizations\n", - "for i, cc in enumerate(wu_ccs):\n", - " ax2.plot([i - .4, i + .4], [cc, cc], '-', color=sns.color_palette('muted')[3])\n", + "# Additional plot elements or customizations\n", + "for i, cc in enumerate(wu_ccs):\n", + " ax2.plot([i - .4, i + .4], [cc, cc], '-', color=sns.color_palette('muted')[3])\n", + "\n", + "# Get legend handles and labels for both axes\n", + "phandles, plabels = ax.get_legend_handles_labels()\n", + "handles, labels = ax2.get_legend_handles_labels()\n", + "\n", + "# Remove individual legends\n", + "ax.legend().remove()\n", + "ax2.legend().remove()\n", + "\n", + "# Combine legends for both axes and Wu 2004 into a single legend\n", + "legend = ax2.legend(phandles + handles + [plt.Line2D([0], [0], color=sns.color_palette('muted')[3])],\n", + " plabels + labels + ['Wu 2004'], loc='upper center', ncol=4, fontsize=13)\n", + "\n", + "# Set y-axis limit for ax\n", + "ax.set_ylim([-1, 2])\n", + "\n", + "# Add horizontal line at y=0 to ax\n", + "ax.axhline(0, ls='--', color='.7', zorder=0)\n", + "\n", + "# Remove spines for aesthetics\n", + "sns.despine(trim=True)\n", + "# Save the figure\n", + "#fig.savefig('wu_fccs.svg', transparent=True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "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", + "
$\\epsilon_{PGM,2pg}$$\\epsilon_{PGM,pep}$$\\epsilon_{ENO,2pg}$$\\epsilon_{ENO,pep}$$\\epsilon_{PK,2pg}$$\\epsilon_{PK,pep}$$\\epsilon_{PGM,BPG}$$\\epsilon_{PGM,ADP}$$\\epsilon_{ENO,BPG}$$\\epsilon_{ENO,ADP}$$\\epsilon_{PK,BPG}$$\\epsilon_{PK,ADP}$
0-0.521636-0.8425700.795357-1.938392-0.2475850.1895270.4915190.180916-0.109114-0.061945-0.0805000.713496
1-0.467871-0.6969590.935365-1.594867-0.1788400.3569360.7834790.2557110.1907210.0678230.0928680.816520
\n", + "
" + ], + "text/plain": [ + " $\\epsilon_{PGM,2pg}$ $\\epsilon_{PGM,pep}$ $\\epsilon_{ENO,2pg}$ \\\n", + "0 -0.521636 -0.842570 0.795357 \n", + "1 -0.467871 -0.696959 0.935365 \n", + "\n", + " $\\epsilon_{ENO,pep}$ $\\epsilon_{PK,2pg}$ $\\epsilon_{PK,pep}$ \\\n", + "0 -1.938392 -0.247585 0.189527 \n", + "1 -1.594867 -0.178840 0.356936 \n", + "\n", + " $\\epsilon_{PGM,BPG}$ $\\epsilon_{PGM,ADP}$ $\\epsilon_{ENO,BPG}$ \\\n", + "0 0.491519 0.180916 -0.109114 \n", + "1 0.783479 0.255711 0.190721 \n", + "\n", + " $\\epsilon_{ENO,ADP}$ $\\epsilon_{PK,BPG}$ $\\epsilon_{PK,ADP}$ \n", + "0 -0.061945 -0.080500 0.713496 \n", + "1 0.067823 0.092868 0.816520 " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ex_vi = trace_vi.posterior['Ex'].to_numpy().reshape((len(trace_vi.posterior['Ex'][0]), -1))\n", + "ey_vi = trace_vi.posterior['Ey'].to_numpy().reshape((len(trace_vi.posterior['Ey'][0]), -1))\n", + "e_all_vi = np.hstack([ex_vi, ey_vi])\n", + "\n", + "e_df_vi = pd.DataFrame(e_all_vi, columns=e_labels)\n", "\n", - "# Get legend handles and labels for both axes\n", - "phandles, plabels = ax.get_legend_handles_labels()\n", - "handles, labels = ax2.get_legend_handles_labels()\n", + "# Create an empty DataFrame to store HDI results in wide format\n", + "hdi_results = pd.DataFrame(columns=e_df_vi.columns)\n", "\n", - "# Remove individual legends\n", - "ax.legend().remove()\n", - "ax2.legend().remove()\n", + "# Iterate through each column and calculate HDI separately\n", + "for column in e_df_vi.columns:\n", + " hdi = pm.hdi(e_df_vi[column].values)\n", + " hdi_results[column] = hdi\n", "\n", - "# Combine legends for both axes and Wu 2004 into a single legend\n", - "legend = ax2.legend(phandles + handles + [plt.Line2D([0], [0], color=sns.color_palette('muted')[3])],\n", - " plabels + labels + ['Wu 2004'], loc='upper center', ncol=4, fontsize=13)\n", + "# Display or use the DataFrame with HDI results in wide format\n", + "e_df_vi = hdi_results\n", + "e_df_vi" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import arviz as az\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import numpy as np\n", "\n", - "# Set y-axis limit for ax\n", - "ax.set_ylim([-1, 2])\n", + "# Assuming you have the data arrays ex, ex_vi, ey, ey_vi\n", + "# Modify as needed based on your data setup\n", "\n", - "# Add horizontal line at y=0 to ax\n", - "ax.axhline(0, ls='--', color='.7', zorder=0)\n", + "colors = sns.color_palette('husl', n_colors=12) # Assuming a total of 12 colors needed\n", + "\n", + "fig, axmatrix = plt.subplots(nrows=2, sharex=False, figsize=(6, 5))\n", + "\n", + "for i, color in enumerate(colors[:6]):\n", + " az.plot_kde(np.array(ex[:, i]), plot_kwargs={'color': color}, fill_kwargs={'color': color, 'alpha': 0.1}, ax=axmatrix[0])\n", + " az.plot_kde(np.array(ex_vi[:, i]), plot_kwargs={'color': color}, ax=axmatrix[0])\n", + " lines = axmatrix[0].get_lines() # Get the lines from the plot\n", + " lines[-1].set_linestyle('--') # Set linestyle for the last line\n", + "\n", + "for i, color in enumerate(colors[6:]):\n", + " az.plot_kde(np.array(ey[:, i]), plot_kwargs={'color': color}, fill_kwargs={'color': color, 'alpha': 0.1}, ax=axmatrix[1])\n", + " az.plot_kde(np.array(ey_vi[:, i]), plot_kwargs={'color': color}, ax=axmatrix[1])\n", + " lines = axmatrix[1].get_lines() # Get the lines from the plot\n", + " lines[-1].set_linestyle('--') # Set linestyle for the last line\n", + "\n", + "hmc_line = plt.Line2D([], [], color='.6', ls='-', label='NUTS') # Create Line2D for legend\n", + "vi_line = plt.Line2D([], [], color='.6', ls='--', label='ADVI') # Create Line2D for legend\n", + "\n", + "axmatrix[0].set_ylabel('Frequency')\n", + "axmatrix[1].set_ylabel('Frequency')\n", + "\n", + "axmatrix[0].set_title('$\\epsilon_x^*$')\n", + "axmatrix[1].set_title('$\\epsilon_y^*$')\n", + "\n", + "axmatrix[0].legend(handles=[hmc_line, vi_line], loc='upper left')\n", + "plt.tight_layout()\n", + "sns.despine(trim=True)\n", + "plt.show() # Display the plot\n", + "# fig.savefig('advi_nuts_elasticity.svg', transparent=True)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Save results to file for testing/comparison" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1',\n", + " '2',\n", + " '3',\n", + " '4',\n", + " '5',\n", + " '6',\n", + " '7',\n", + " '8',\n", + " '9',\n", + " '10',\n", + " '11',\n", + " '12',\n", + " '13',\n", + " '14',\n", + " '15',\n", + " '16',\n", + " '17',\n", + " '18',\n", + " '19',\n", + " '20',\n", + " '21',\n", + " '22',\n", + " '23',\n", + " '24',\n", + " '25',\n", + " '26',\n", + " '27',\n", + " '28',\n", + " '29',\n", + " '30',\n", + " '31',\n", + " '32',\n", + " '33',\n", + " '34',\n", + " '35',\n", + " '36',\n", + " '37',\n", + " '38',\n", + " '39',\n", + " '40',\n", + " '41',\n", + " '42',\n", + " '43',\n", + " '44',\n", + " '45',\n", + " '46',\n", + " '47',\n", + " '48',\n", + " '49',\n", + " '50',\n", + " '51',\n", + " '52',\n", + " '53',\n", + " '54',\n", + " '55',\n", + " '56',\n", + " '57',\n", + " '58',\n", + " '59',\n", + " '60',\n", + " '61',\n", + " '62',\n", + " '63',\n", + " '64',\n", + " '65',\n", + " '66',\n", + " '67',\n", + " '68',\n", + " '69',\n", + " '70',\n", + " '71',\n", + " '72',\n", + " '73',\n", + " '74',\n", + " '75',\n", + " '76',\n", + " '77',\n", + " '78',\n", + " '79',\n", + " '80',\n", + " '81',\n", + " '82',\n", + " '83',\n", + " '84',\n", + " '85',\n", + " '86',\n", + " '87',\n", + " '88',\n", + " '89',\n", + " '90',\n", + " '91',\n", + " '92',\n", + " '93',\n", + " '94',\n", + " '95',\n", + " '96',\n", + " '97',\n", + " '98',\n", + " '99',\n", + " '100',\n", + " '101',\n", + " '102',\n", + " '103',\n", + " '104',\n", + " '105',\n", + " '106',\n", + " '107',\n", + " '108',\n", + " '109',\n", + " '110',\n", + " '111',\n", + " '112',\n", + " '113',\n", + " '114',\n", + " '115',\n", + " '116',\n", + " '117',\n", + " '118',\n", + " '119',\n", + " '120',\n", + " '121',\n", + " '122',\n", + " '123',\n", + " '124',\n", + " '125',\n", + " '126',\n", + " '127',\n", + " '128',\n", + " '129',\n", + " '130',\n", + " '131',\n", + " '132',\n", + " '133',\n", + " '134',\n", + " '135',\n", + " '136',\n", + " '137',\n", + " '138',\n", + " '139',\n", + " '140',\n", + " '141',\n", + " '142',\n", + " '143',\n", + " '144',\n", + " '145',\n", + " '146',\n", + " '147',\n", + " '148',\n", + " '149',\n", + " '150',\n", + " '151',\n", + " '152',\n", + " '153',\n", + " '154',\n", + " '155',\n", + " '156',\n", + " '157',\n", + " '158',\n", + " '159',\n", + " '160',\n", + " '161',\n", + " '162',\n", + " '163',\n", + " '164',\n", + " '165',\n", + " '166',\n", + " '167',\n", + " '168',\n", + " '169',\n", + " '170',\n", + " '171',\n", + " '172',\n", + " '173',\n", + " '174',\n", + " '175',\n", + " '176',\n", + " '177',\n", + " '178',\n", + " '179',\n", + " '180',\n", + " '181',\n", + " '182',\n", + " '183',\n", + " '184',\n", + " '185',\n", + " '186',\n", + " '187',\n", + " '188',\n", + " '189',\n", + " '190',\n", + " '191',\n", + " '192',\n", + " '193',\n", + " '194',\n", + " '195',\n", + " '196',\n", + " '197',\n", + " '198',\n", + " '199',\n", + " '200',\n", + " '201',\n", + " '202',\n", + " '203',\n", + " '204',\n", + " '205',\n", + " '206',\n", + " '207',\n", + " '208',\n", + " '209',\n", + " '210',\n", + " '211',\n", + " '212',\n", + " '213',\n", + " '214',\n", + " '215',\n", + " '216',\n", + " '217',\n", + " '218',\n", + " '219',\n", + " '220',\n", + " '221',\n", + " '222',\n", + " '223',\n", + " '224',\n", + " '225',\n", + " '226',\n", + " '227',\n", + " '228',\n", + " '229',\n", + " '230',\n", + " '231',\n", + " '232',\n", + " '233',\n", + " '234',\n", + " '235',\n", + " '236',\n", + " '237',\n", + " '238',\n", + " '239',\n", + " '240',\n", + " '241',\n", + " '242',\n", + " '243',\n", + " '244',\n", + " '245',\n", + " '246',\n", + " '247',\n", + " '248',\n", + " '249',\n", + " '250',\n", + " '251',\n", + " '252',\n", + " '253',\n", + " '254',\n", + " '255',\n", + " '256',\n", + " '257',\n", + " '258',\n", + " '259',\n", + " '260',\n", + " '261',\n", + " '262',\n", + " '263',\n", + " '264',\n", + " '265',\n", + " '266',\n", + " '267',\n", + " '268',\n", + " '269',\n", + " '270',\n", + " '271',\n", + " '272',\n", + " '273',\n", + " '274',\n", + " '275',\n", + " '276',\n", + " '277',\n", + " '278',\n", + " '279',\n", + " '280',\n", + " '281',\n", + " '282',\n", + " '283',\n", + " '284',\n", + " '285',\n", + " '286',\n", + " '287',\n", + " '288',\n", + " '289',\n", + " '290',\n", + " '291',\n", + " '292',\n", + " '293',\n", + " '294',\n", + " '295',\n", + " '296',\n", + " '297',\n", + " '298',\n", + " '299',\n", + " '300',\n", + " '301',\n", + " '302',\n", + " '303',\n", + " '304',\n", + " '305',\n", + " '306',\n", + " '307',\n", + " '308',\n", + " '309',\n", + " '310',\n", + " '311',\n", + " '312',\n", + " '313',\n", + " '314',\n", + " '315',\n", + " '316',\n", + " '317',\n", + " '318',\n", + " '319',\n", + " '320',\n", + " '321',\n", + " '322',\n", + " '323',\n", + " '324',\n", + " '325',\n", + " '326',\n", + " '327',\n", + " '328',\n", + " '329',\n", + " '330',\n", + " '331',\n", + " '332',\n", + " '333',\n", + " '334',\n", + " '335',\n", + " '336',\n", + " '337',\n", + " '338',\n", + " '339',\n", + " '340',\n", + " '341',\n", + " '342',\n", + " '343',\n", + " '344',\n", + " '345',\n", + " '346',\n", + " '347',\n", + " '348',\n", + " '349',\n", + " '350',\n", + " '351',\n", + " '352',\n", + " '353',\n", + " '354',\n", + " '355',\n", + " '356',\n", + " '357',\n", + " '358',\n", + " '359',\n", + " '360',\n", + " '361',\n", + " '362',\n", + " '363',\n", + " '364',\n", + " '365',\n", + " '366',\n", + " '367',\n", + " '368',\n", + " '369',\n", + " '370',\n", + " '371',\n", + " '372',\n", + " '373',\n", + " '374',\n", + " '375',\n", + " '376',\n", + " '377',\n", + " '378',\n", + " '379',\n", + " '380',\n", + " '381',\n", + " '382',\n", + " '383',\n", + " '384',\n", + " '385',\n", + " '386',\n", + " '387',\n", + " '388',\n", + " '389',\n", + " '390',\n", + " '391',\n", + " '392',\n", + " '393',\n", + " '394',\n", + " '395',\n", + " '396',\n", + " '397',\n", + " '398',\n", + " '399',\n", + " '400',\n", + " '401',\n", + " '402',\n", + " '403',\n", + " '404',\n", + " '405',\n", + " '406',\n", + " '407',\n", + " '408',\n", + " '409',\n", + " '410',\n", + " '411',\n", + " '412',\n", + " '413',\n", + " '414',\n", + " '415',\n", + " '416',\n", + " '417',\n", + " '418',\n", + " '419',\n", + " '420',\n", + " '421',\n", + " '422',\n", + " '423',\n", + " '424',\n", + " '425',\n", + " '426',\n", + " '427',\n", + " '428',\n", + " '429',\n", + " '430',\n", + " '431',\n", + " '432',\n", + " '433',\n", + " '434',\n", + " '435',\n", + " '436',\n", + " '437',\n", + " '438',\n", + " '439',\n", + " '440',\n", + " '441',\n", + " '442',\n", + " '443',\n", + " '444',\n", + " '445',\n", + " '446',\n", + " '447',\n", + " '448',\n", + " '449',\n", + " '450',\n", + " '451',\n", + " '452',\n", + " '453',\n", + " '454',\n", + " '455',\n", + " '456',\n", + " '457',\n", + " '458',\n", + " '459',\n", + " '460',\n", + " '461',\n", + " '462',\n", + " '463',\n", + " '464',\n", + " '465',\n", + " '466',\n", + " '467',\n", + " '468',\n", + " '469',\n", + " '470',\n", + " '471',\n", + " '472',\n", + " '473',\n", + " '474',\n", + " '475',\n", + " '476',\n", + " '477',\n", + " '478',\n", + " '479',\n", + " '480',\n", + " '481',\n", + " '482',\n", + " '483',\n", + " '484',\n", + " '485',\n", + " '486',\n", + " '487',\n", + " '488',\n", + " '489',\n", + " '490',\n", + " '491',\n", + " '492',\n", + " '493',\n", + " '494',\n", + " '495',\n", + " '496',\n", + " '497',\n", + " '498',\n", + " '499',\n", + " '500']" + ] + }, + "execution_count": 78, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[str(int(i+1)) for i in np.arange(len(priors_df.index)/3)]" + ] + }, + { + "cell_type": "code", + "execution_count": 90, + "metadata": {}, + "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", + "
level_10type
0PGM0.084288Prior
0ENO0.816874Prior
0PK0.098838Prior
1PGM0.310687Prior
1ENO0.173424Prior
............
498ENO0.339782Prior
498PK0.876267Prior
499PGM1.124280Prior
499ENO-0.160071Prior
499PK0.035792Prior
\n", + "

1500 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " level_1 0 type\n", + "0 PGM 0.084288 Prior\n", + "0 ENO 0.816874 Prior\n", + "0 PK 0.098838 Prior\n", + "1 PGM 0.310687 Prior\n", + "1 ENO 0.173424 Prior\n", + ".. ... ... ...\n", + "498 ENO 0.339782 Prior\n", + "498 PK 0.876267 Prior\n", + "499 PGM 1.124280 Prior\n", + "499 ENO -0.160071 Prior\n", + "499 PK 0.035792 Prior\n", + "\n", + "[1500 rows x 3 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
FCC_ref0123456789...490491492493494495496497498499
Reaction
ENO0.8168740.1734240.0119880.5852870.3235440.0522890.3485690.4806460.1405670.278206...0.5792990.2421900.4700050.0000750.1338190.1124030.2927820.4913060.339782-0.160071
PGM0.0842880.3106870.0214410.2061440.370449-0.0830650.5857790.4667150.0284050.382373...0.1951980.7036260.4534080.9536040.6206370.2724310.7616610.216657-0.2160491.124280
PK0.0988380.5158880.9665710.2085700.3060071.0307760.0656520.0526390.8310280.339420...0.2255030.0541850.0765880.0463210.2455440.615165-0.0544430.2920370.8762670.035792
\n", + "

3 rows × 500 columns

\n", + "
" + ], + "text/plain": [ + "FCC_ref 0 1 2 3 4 5 \\\n", + "Reaction \n", + "ENO 0.816874 0.173424 0.011988 0.585287 0.323544 0.052289 \n", + "PGM 0.084288 0.310687 0.021441 0.206144 0.370449 -0.083065 \n", + "PK 0.098838 0.515888 0.966571 0.208570 0.306007 1.030776 \n", + "\n", + "FCC_ref 6 7 8 9 ... 490 491 \\\n", + "Reaction ... \n", + "ENO 0.348569 0.480646 0.140567 0.278206 ... 0.579299 0.242190 \n", + "PGM 0.585779 0.466715 0.028405 0.382373 ... 0.195198 0.703626 \n", + "PK 0.065652 0.052639 0.831028 0.339420 ... 0.225503 0.054185 \n", + "\n", + "FCC_ref 492 493 494 495 496 497 \\\n", + "Reaction \n", + "ENO 0.470005 0.000075 0.133819 0.112403 0.292782 0.491306 \n", + "PGM 0.453408 0.953604 0.620637 0.272431 0.761661 0.216657 \n", + "PK 0.076588 0.046321 0.245544 0.615165 -0.054443 0.292037 \n", + "\n", + "FCC_ref 498 499 \n", + "Reaction \n", + "ENO 0.339782 -0.160071 \n", + "PGM -0.216049 1.124280 \n", + "PK 0.876267 0.035792 \n", + "\n", + "[3 rows x 500 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Save FCC prior predictives\n", + "display(df3)\n", + "priors_df = df3.copy()\n", + "priors_df['FCC_ref'] = [x for x in priors_df.index]\n", + "priors_df = priors_df.rename(columns={'level_1': 'Reaction', 0: 'FCC'}).reset_index()\n", + "priors_df = priors_df.pivot(index='Reaction', values='FCC', columns='FCC_ref')\n", "\n", - "# Remove spines for aesthetics\n", - "sns.despine(trim=True)\n", - "# Save the figure\n", - "#fig.savefig('wu_fccs.svg', transparent=True)\n" + "display(priors_df)\n", + "priors_df.to_csv('../tests/test_data/expected_wu2004_FCCpriors.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create violin plot for 'Prior' type on ax\n", + "sns.violinplot(\n", + " x='Reaction', y='FCC', hue='Type', data=data_prior,\n", + " density_norm='width', width=0.5, palette=my_pal, saturation=1.\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "metadata": {}, + "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", + "
level_10type
0PGM-0.171714NUTS
0ENO0.166104NUTS
0PK1.005611NUTS
1PGM-0.184127NUTS
1ENO0.212176NUTS
............
498ENO0.209799NUTS
498PK0.611608NUTS
499PGM0.080888NUTS
499ENO0.121807NUTS
499PK0.797305NUTS
\n", + "

1500 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " level_1 0 type\n", + "0 PGM -0.171714 NUTS\n", + "0 ENO 0.166104 NUTS\n", + "0 PK 1.005611 NUTS\n", + "1 PGM -0.184127 NUTS\n", + "1 ENO 0.212176 NUTS\n", + ".. ... ... ...\n", + "498 ENO 0.209799 NUTS\n", + "498 PK 0.611608 NUTS\n", + "499 PGM 0.080888 NUTS\n", + "499 ENO 0.121807 NUTS\n", + "499 PK 0.797305 NUTS\n", + "\n", + "[1500 rows x 3 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
level_10type
0PGM-0.100514ADVI
0ENO0.163578ADVI
0PK0.936936ADVI
1PGM-0.071819ADVI
1ENO0.183474ADVI
............
998ENO0.175839ADVI
998PK0.929507ADVI
999PGM-0.066807ADVI
999ENO0.191240ADVI
999PK0.875567ADVI
\n", + "

3000 rows × 3 columns

\n", + "
" + ], + "text/plain": [ + " level_1 0 type\n", + "0 PGM -0.100514 ADVI\n", + "0 ENO 0.163578 ADVI\n", + "0 PK 0.936936 ADVI\n", + "1 PGM -0.071819 ADVI\n", + "1 ENO 0.183474 ADVI\n", + ".. ... ... ...\n", + "998 ENO 0.175839 ADVI\n", + "998 PK 0.929507 ADVI\n", + "999 PGM -0.066807 ADVI\n", + "999 ENO 0.191240 ADVI\n", + "999 PK 0.875567 ADVI\n", + "\n", + "[3000 rows x 3 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Save FCC posterior predictives\n", + "display(df1)\n", + "df1.to_csv('../tests/test_data/expected_wu2004_FCC_posterior_NUTS.csv')\n", + "display(df2)\n", + "df2.to_csv('../tests/test_data/expected_wu2004_FCC_posterior_ADVI.csv')" ] }, { "cell_type": "code", - "execution_count": 648, + "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/html": [ - "
\n", - "
<xarray.DataArray 'chi_obs' (chain: 4, draw: 500, chi_obs_dim_2: 19,\n",
+       "                             chi_obs_dim_3: 2)>\n",
+       "array([[[[ 1.08420613e+00, -8.07719287e-01],\n",
+       "         [ 7.35360805e-02, -3.06056760e-02],\n",
+       "         [-1.18030661e-01, -1.37121157e-01],\n",
+       "         ...,\n",
+       "         [ 1.11215661e+00, -1.26434397e-01],\n",
+       "         [ 1.15180463e+00, -2.72844106e-01],\n",
+       "         [ 1.18923111e+00, -3.49354518e-01]],\n",
+       "\n",
+       "        [[ 1.04999001e+00, -6.57435729e-01],\n",
+       "         [ 1.36917320e-02, -6.22320543e-03],\n",
+       "         [-1.13213430e-01, -1.04112815e-01],\n",
+       "         ...,\n",
+       "         [ 1.08567625e+00, -1.59886166e-01],\n",
+       "         [ 1.13859952e+00, -1.93933010e-01],\n",
+       "         [ 1.20127199e+00, -2.71993922e-01]],\n",
+       "\n",
+       "        [[ 1.06515806e+00, -7.54618115e-01],\n",
+       "         [ 2.70038056e-02, -9.18481254e-02],\n",
+       "         [ 9.35520715e-02, -1.16780075e-01],\n",
+       "         ...,\n",
+       "...\n",
+       "         ...,\n",
+       "         [ 1.14988002e+00, -4.24038671e-02],\n",
+       "         [ 1.21429250e+00, -1.10204684e-01],\n",
+       "         [ 1.19243406e+00, -2.15155971e-01]],\n",
+       "\n",
+       "        [[ 9.91807437e-01, -8.41521484e-01],\n",
+       "         [-9.92430560e-02, -1.67719436e-03],\n",
+       "         [-1.11928581e-01, -1.15755575e-01],\n",
+       "         ...,\n",
+       "         [ 1.13773320e+00, -1.31338060e-01],\n",
+       "         [ 1.02025489e+00, -1.77837753e-01],\n",
+       "         [ 1.22301211e+00, -1.82545837e-01]],\n",
+       "\n",
+       "        [[ 1.11181026e+00, -7.60978129e-01],\n",
+       "         [-8.58045566e-02, -1.25540070e-02],\n",
+       "         [-9.35895517e-02, -1.61416335e-02],\n",
+       "         ...,\n",
+       "         [ 1.26514783e+00, -1.18158503e-01],\n",
+       "         [ 1.14207715e+00, -2.40341760e-01],\n",
+       "         [ 1.21979536e+00, -3.57870158e-01]]]])\n",
+       "Coordinates:\n",
+       "  * chain          (chain) int64 0 1 2 3\n",
+       "  * draw           (draw) int64 0 1 2 3 4 5 6 7 ... 493 494 495 496 497 498 499\n",
+       "  * chi_obs_dim_2  (chi_obs_dim_2) int64 0 1 2 3 4 5 6 ... 12 13 14 15 16 17 18\n",
+       "  * chi_obs_dim_3  (chi_obs_dim_3) int64 0 1
" + ], + "text/plain": [ + "\n", + "array([[[[ 1.08420613e+00, -8.07719287e-01],\n", + " [ 7.35360805e-02, -3.06056760e-02],\n", + " [-1.18030661e-01, -1.37121157e-01],\n", + " ...,\n", + " [ 1.11215661e+00, -1.26434397e-01],\n", + " [ 1.15180463e+00, -2.72844106e-01],\n", + " [ 1.18923111e+00, -3.49354518e-01]],\n", + "\n", + " [[ 1.04999001e+00, -6.57435729e-01],\n", + " [ 1.36917320e-02, -6.22320543e-03],\n", + " [-1.13213430e-01, -1.04112815e-01],\n", + " ...,\n", + " [ 1.08567625e+00, -1.59886166e-01],\n", + " [ 1.13859952e+00, -1.93933010e-01],\n", + " [ 1.20127199e+00, -2.71993922e-01]],\n", + "\n", + " [[ 1.06515806e+00, -7.54618115e-01],\n", + " [ 2.70038056e-02, -9.18481254e-02],\n", + " [ 9.35520715e-02, -1.16780075e-01],\n", + " ...,\n", + "...\n", + " ...,\n", + " [ 1.14988002e+00, -4.24038671e-02],\n", + " [ 1.21429250e+00, -1.10204684e-01],\n", + " [ 1.19243406e+00, -2.15155971e-01]],\n", + "\n", + " [[ 9.91807437e-01, -8.41521484e-01],\n", + " [-9.92430560e-02, -1.67719436e-03],\n", + " [-1.11928581e-01, -1.15755575e-01],\n", + " ...,\n", + " [ 1.13773320e+00, -1.31338060e-01],\n", + " [ 1.02025489e+00, -1.77837753e-01],\n", + " [ 1.22301211e+00, -1.82545837e-01]],\n", + "\n", + " [[ 1.11181026e+00, -7.60978129e-01],\n", + " [-8.58045566e-02, -1.25540070e-02],\n", + " [-9.35895517e-02, -1.61416335e-02],\n", + " ...,\n", + " [ 1.26514783e+00, -1.18158503e-01],\n", + " [ 1.14207715e+00, -2.40341760e-01],\n", + " [ 1.21979536e+00, -3.57870158e-01]]]])\n", + "Coordinates:\n", + " * chain (chain) int64 0 1 2 3\n", + " * draw (draw) int64 0 1 2 3 4 5 6 7 ... 493 494 495 496 497 498 499\n", + " * chi_obs_dim_2 (chi_obs_dim_2) int64 0 1 2 3 4 5 6 ... 12 13 14 15 16 17 18\n", + " * chi_obs_dim_3 (chi_obs_dim_3) int64 0 1" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", - "
$\\epsilon_{PGM,2pg}$$\\epsilon_{PGM,pep}$$\\epsilon_{ENO,2pg}$$\\epsilon_{ENO,pep}$$\\epsilon_{PK,2pg}$$\\epsilon_{PK,pep}$$\\epsilon_{PGM,BPG}$$\\epsilon_{PGM,ADP}$$\\epsilon_{ENO,BPG}$$\\epsilon_{ENO,ADP}$$\\epsilon_{PK,BPG}$$\\epsilon_{PK,ADP}$
0-0.531711-0.8373260.819539-1.953974-0.2479130.1975750.5159360.176649-0.092677-0.068973-0.0852140.707098
1-0.480945-0.7092040.952264-1.603973-0.1773680.3554360.8156310.2540990.1907630.0620910.0802960.797434
\n", - "
" - ], - "text/plain": [ - " $\\epsilon_{PGM,2pg}$ $\\epsilon_{PGM,pep}$ $\\epsilon_{ENO,2pg}$ \\\n", - "0 -0.531711 -0.837326 0.819539 \n", - "1 -0.480945 -0.709204 0.952264 \n", + ".xr-var-item > .xr-var-name:hover span {\n", + " padding-right: 5px;\n", + "}\n", "\n", - " $\\epsilon_{ENO,pep}$ $\\epsilon_{PK,2pg}$ $\\epsilon_{PK,pep}$ \\\n", - "0 -1.953974 -0.247913 0.197575 \n", - "1 -1.603973 -0.177368 0.355436 \n", + ".xr-var-list > li:nth-child(odd) > div,\n", + ".xr-var-list > li:nth-child(odd) > label,\n", + ".xr-var-list > li:nth-child(odd) > .xr-var-name span {\n", + " background-color: var(--xr-background-color-row-odd);\n", + "}\n", "\n", - " $\\epsilon_{PGM,BPG}$ $\\epsilon_{PGM,ADP}$ $\\epsilon_{ENO,BPG}$ \\\n", - "0 0.515936 0.176649 -0.092677 \n", - "1 0.815631 0.254099 0.190763 \n", + ".xr-var-name {\n", + " grid-column: 1;\n", + "}\n", "\n", - " $\\epsilon_{ENO,ADP}$ $\\epsilon_{PK,BPG}$ $\\epsilon_{PK,ADP}$ \n", - "0 -0.068973 -0.085214 0.707098 \n", - "1 0.062091 0.080296 0.797434 " + ".xr-var-dims {\n", + " grid-column: 2;\n", + "}\n", + "\n", + ".xr-var-dtype {\n", + " grid-column: 3;\n", + " text-align: right;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-preview {\n", + " grid-column: 4;\n", + "}\n", + "\n", + ".xr-index-preview {\n", + " grid-column: 2 / 5;\n", + " color: var(--xr-font-color2);\n", + "}\n", + "\n", + ".xr-var-name,\n", + ".xr-var-dims,\n", + ".xr-var-dtype,\n", + ".xr-preview,\n", + ".xr-attrs dt {\n", + " white-space: nowrap;\n", + " overflow: hidden;\n", + " text-overflow: ellipsis;\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-var-name:hover,\n", + ".xr-var-dims:hover,\n", + ".xr-var-dtype:hover,\n", + ".xr-attrs dt:hover {\n", + " overflow: visible;\n", + " width: auto;\n", + " z-index: 1;\n", + "}\n", + "\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " display: none;\n", + " background-color: var(--xr-background-color) !important;\n", + " padding-bottom: 5px !important;\n", + "}\n", + "\n", + ".xr-var-attrs-in:checked ~ .xr-var-attrs,\n", + ".xr-var-data-in:checked ~ .xr-var-data,\n", + ".xr-index-data-in:checked ~ .xr-index-data {\n", + " display: block;\n", + "}\n", + "\n", + ".xr-var-data > table {\n", + " float: right;\n", + "}\n", + "\n", + ".xr-var-name span,\n", + ".xr-var-data,\n", + ".xr-index-name div,\n", + ".xr-index-data,\n", + ".xr-attrs {\n", + " padding-left: 25px !important;\n", + "}\n", + "\n", + ".xr-attrs,\n", + ".xr-var-attrs,\n", + ".xr-var-data,\n", + ".xr-index-data {\n", + " grid-column: 1 / -1;\n", + "}\n", + "\n", + "dl.xr-attrs {\n", + " padding: 0;\n", + " margin: 0;\n", + " display: grid;\n", + " grid-template-columns: 125px auto;\n", + "}\n", + "\n", + ".xr-attrs dt,\n", + ".xr-attrs dd {\n", + " padding: 0;\n", + " margin: 0;\n", + " float: left;\n", + " padding-right: 10px;\n", + " width: auto;\n", + "}\n", + "\n", + ".xr-attrs dt {\n", + " font-weight: normal;\n", + " grid-column: 1;\n", + "}\n", + "\n", + ".xr-attrs dt:hover span {\n", + " display: inline-block;\n", + " background: var(--xr-background-color);\n", + " padding-right: 10px;\n", + "}\n", + "\n", + ".xr-attrs dd {\n", + " grid-column: 2;\n", + " white-space: pre-wrap;\n", + " word-break: break-all;\n", + "}\n", + "\n", + ".xr-icon-database,\n", + ".xr-icon-file-text2,\n", + ".xr-no-icon {\n", + " display: inline-block;\n", + " vertical-align: middle;\n", + " width: 1em;\n", + " height: 1.5em !important;\n", + " stroke-width: 0;\n", + " stroke: currentColor;\n", + " fill: currentColor;\n", + "}\n", + "
<xarray.DataArray 'v_hat_obs' (chain: 4, draw: 500, v_hat_obs_dim_2: 19)>\n",
+       "array([[[1.69768278, 0.99376089, 1.2767478 , ..., 0.90188943,\n",
+       "         1.28227255, 1.22493165],\n",
+       "        [1.56799328, 1.04490174, 1.14768703, ..., 1.29021779,\n",
+       "         1.22944455, 1.20851924],\n",
+       "        [1.6977591 , 1.07290336, 1.24404556, ..., 0.918095  ,\n",
+       "         1.49787697, 1.32933201],\n",
+       "        ...,\n",
+       "        [1.36251961, 0.80201166, 0.9486992 , ..., 1.07376563,\n",
+       "         1.27770902, 1.23402146],\n",
+       "        [1.46067967, 0.90192143, 1.15464488, ..., 1.15441905,\n",
+       "         1.50493512, 1.4396041 ],\n",
+       "        [1.47167905, 0.80745768, 1.34008044, ..., 1.4784615 ,\n",
+       "         1.4113527 , 1.35524938]],\n",
+       "\n",
+       "       [[1.41905101, 1.09542224, 1.34703896, ..., 1.03687519,\n",
+       "         1.46838517, 1.21498952],\n",
+       "        [1.59239476, 1.00622513, 1.26755882, ..., 1.14073426,\n",
+       "         1.05404483, 1.36100385],\n",
+       "        [1.54710579, 1.05015655, 1.05812809, ..., 1.30528503,\n",
+       "         1.26563775, 1.33613206],\n",
+       "...\n",
+       "        [1.49326145, 1.12234262, 1.17799427, ..., 1.2539081 ,\n",
+       "         1.26372935, 1.37668773],\n",
+       "        [1.11964101, 0.79194359, 1.14036018, ..., 1.20448184,\n",
+       "         1.18114027, 1.27345658],\n",
+       "        [1.55098782, 0.96075463, 1.20857819, ..., 1.0708805 ,\n",
+       "         1.2356893 , 1.31167358]],\n",
+       "\n",
+       "       [[1.36370587, 1.04765251, 1.08297795, ..., 1.13041075,\n",
+       "         1.16425415, 1.22968432],\n",
+       "        [1.55915904, 0.97840826, 1.29375005, ..., 1.17316644,\n",
+       "         1.24272337, 1.48634125],\n",
+       "        [1.47903775, 0.95449468, 1.04704289, ..., 1.20328266,\n",
+       "         1.20125987, 1.30738218],\n",
+       "        ...,\n",
+       "        [1.58234085, 1.10543187, 1.27663654, ..., 1.00098612,\n",
+       "         1.23591532, 1.36478136],\n",
+       "        [1.55378756, 0.96667523, 1.08794305, ..., 1.39327833,\n",
+       "         1.34070785, 1.39817524],\n",
+       "        [1.56707797, 1.10963923, 1.04984453, ..., 1.22311131,\n",
+       "         1.23017492, 1.49471898]]])\n",
+       "Coordinates:\n",
+       "  * chain            (chain) int64 0 1 2 3\n",
+       "  * draw             (draw) int64 0 1 2 3 4 5 6 ... 493 494 495 496 497 498 499\n",
+       "  * v_hat_obs_dim_2  (v_hat_obs_dim_2) int64 0 1 2 3 4 5 6 ... 13 14 15 16 17 18
" + ], + "text/plain": [ + "\n", + "array([[[1.69768278, 0.99376089, 1.2767478 , ..., 0.90188943,\n", + " 1.28227255, 1.22493165],\n", + " [1.56799328, 1.04490174, 1.14768703, ..., 1.29021779,\n", + " 1.22944455, 1.20851924],\n", + " [1.6977591 , 1.07290336, 1.24404556, ..., 0.918095 ,\n", + " 1.49787697, 1.32933201],\n", + " ...,\n", + " [1.36251961, 0.80201166, 0.9486992 , ..., 1.07376563,\n", + " 1.27770902, 1.23402146],\n", + " [1.46067967, 0.90192143, 1.15464488, ..., 1.15441905,\n", + " 1.50493512, 1.4396041 ],\n", + " [1.47167905, 0.80745768, 1.34008044, ..., 1.4784615 ,\n", + " 1.4113527 , 1.35524938]],\n", + "\n", + " [[1.41905101, 1.09542224, 1.34703896, ..., 1.03687519,\n", + " 1.46838517, 1.21498952],\n", + " [1.59239476, 1.00622513, 1.26755882, ..., 1.14073426,\n", + " 1.05404483, 1.36100385],\n", + " [1.54710579, 1.05015655, 1.05812809, ..., 1.30528503,\n", + " 1.26563775, 1.33613206],\n", + "...\n", + " [1.49326145, 1.12234262, 1.17799427, ..., 1.2539081 ,\n", + " 1.26372935, 1.37668773],\n", + " [1.11964101, 0.79194359, 1.14036018, ..., 1.20448184,\n", + " 1.18114027, 1.27345658],\n", + " [1.55098782, 0.96075463, 1.20857819, ..., 1.0708805 ,\n", + " 1.2356893 , 1.31167358]],\n", + "\n", + " [[1.36370587, 1.04765251, 1.08297795, ..., 1.13041075,\n", + " 1.16425415, 1.22968432],\n", + " [1.55915904, 0.97840826, 1.29375005, ..., 1.17316644,\n", + " 1.24272337, 1.48634125],\n", + " [1.47903775, 0.95449468, 1.04704289, ..., 1.20328266,\n", + " 1.20125987, 1.30738218],\n", + " ...,\n", + " [1.58234085, 1.10543187, 1.27663654, ..., 1.00098612,\n", + " 1.23591532, 1.36478136],\n", + " [1.55378756, 0.96667523, 1.08794305, ..., 1.39327833,\n", + " 1.34070785, 1.39817524],\n", + " [1.56707797, 1.10963923, 1.04984453, ..., 1.22311131,\n", + " 1.23017492, 1.49471898]]])\n", + "Coordinates:\n", + " * chain (chain) int64 0 1 2 3\n", + " * draw (draw) int64 0 1 2 3 4 5 6 ... 493 494 495 496 497 498 499\n", + " * v_hat_obs_dim_2 (v_hat_obs_dim_2) int64 0 1 2 3 4 5 6 ... 13 14 15 16 17 18" ] }, - "execution_count": 648, "metadata": {}, - "output_type": "execute_result" + "output_type": "display_data" } ], "source": [ - "ex_vi = trace_vi.posterior['Ex'].to_numpy().reshape((len(trace_vi.posterior['Ex'][0]), -1))\n", - "ey_vi = trace_vi.posterior['Ey'].to_numpy().reshape((len(trace_vi.posterior['Ey'][0]), -1))\n", - "e_all_vi = np.hstack([ex_vi, ey_vi])\n", - "\n", - "e_df_vi = pd.DataFrame(e_all_vi, columns=e_labels)\n", - "\n", - "# Create an empty DataFrame to store HDI results in wide format\n", - "hdi_results = pd.DataFrame(columns=e_df_vi.columns)\n", - "\n", - "# Iterate through each column and calculate HDI separately\n", - "for column in e_df_vi.columns:\n", - " hdi = pm.hdi(e_df_vi[column].values)\n", - " hdi_results[column] = hdi\n", - "\n", - "# Display or use the DataFrame with HDI results in wide format\n", - "e_df_vi = hdi_results\n", - "e_df_vi" + "display(ppc.posterior_predictive['chi_obs'])\n", + "display(ppc.posterior_predictive['v_hat_obs'])" ] }, { "cell_type": "code", - "execution_count": 682, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "import arviz as az\n", - "import matplotlib.pyplot as plt\n", - "import seaborn as sns\n", - "import numpy as np\n", - "\n", - "# Assuming you have the data arrays ex, ex_vi, ey, ey_vi\n", - "# Modify as needed based on your data setup\n", - "\n", - "colors = sns.color_palette('husl', n_colors=12) # Assuming a total of 12 colors needed\n", - "\n", - "fig, axmatrix = plt.subplots(nrows=2, sharex=False, figsize=(6, 5))\n", - "\n", - "for i, color in enumerate(colors[:6]):\n", - " az.plot_kde(np.array(ex[:, i]), plot_kwargs={'color': color}, fill_kwargs={'color': color, 'alpha': 0.1}, ax=axmatrix[0])\n", - " az.plot_kde(np.array(ex_vi[:, i]), plot_kwargs={'color': color}, ax=axmatrix[0])\n", - " lines = axmatrix[0].get_lines() # Get the lines from the plot\n", - " lines[-1].set_linestyle('--') # Set linestyle for the last line\n", - "\n", - "for i, color in enumerate(colors[6:]):\n", - " az.plot_kde(np.array(ey[:, i]), plot_kwargs={'color': color}, fill_kwargs={'color': color, 'alpha': 0.1}, ax=axmatrix[1])\n", - " az.plot_kde(np.array(ey_vi[:, i]), plot_kwargs={'color': color}, ax=axmatrix[1])\n", - " lines = axmatrix[1].get_lines() # Get the lines from the plot\n", - " lines[-1].set_linestyle('--') # Set linestyle for the last line\n", + "# metabolite concentrations\n", "\n", - "hmc_line = plt.Line2D([], [], color='.6', ls='-', label='NUTS') # Create Line2D for legend\n", - "vi_line = plt.Line2D([], [], color='.6', ls='--', label='ADVI') # Create Line2D for legend\n", "\n", - "axmatrix[0].set_ylabel('Frequency')\n", - "axmatrix[1].set_ylabel('Frequency')\n", + "# enzyme concentrations\n", "\n", - "axmatrix[0].set_title('$\\epsilon_x^*$')\n", - "axmatrix[1].set_title('$\\epsilon_y^*$')\n", "\n", - "axmatrix[0].legend(handles=[hmc_line, vi_line], loc='upper left')\n", - "plt.tight_layout()\n", - "sns.despine(trim=True)\n", - "plt.show() # Display the plot\n", - "# fig.savefig('advi_nuts_elasticity.svg', transparent=True)\n" + "# flux rates\n" ] }, { @@ -2364,7 +5518,27 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "def plot_hpd_err(truth, ppc, ax, color=None):\n", + " median = ppc.median(dim=['chain','draw'])\n", + " hpd = pm.hdi(ppc)\n", + " err = np.abs(hpd - median).to_array()[0]#median[:, np.newaxis])\n", + "\n", + " return ax.errorbar(truth, median, yerr=err.T, ls='',\n", + " marker='.', elinewidth=1., color=color)\n", + "\n", + "plot_hpd_err(vn * v_star[0] - 2, ppc.posterior_predictive['v_hat_obs'] * v_star[0], axmatrix[0])\n", + "plot_hpd_err(x['2PG'].values - 3, x_star[0] * np.exp(ppc.posterior_predictive['chi_obs'][:,:,:,0]),\n", + " axmatrix[1])\n", + "l0 = plot_hpd_err(x['PEP'].values - 1.25, x_star[1] * np.exp(ppc.posterior_predictive['chi_obs'][:,:,:,1]),\n", + " axmatrix[2])\n", + "\n", + "plot_hpd_err(vn * v_star[0] + 2, ppc_vi.posterior_predictive['v_hat_obs'] * v_star[0], axmatrix[0], 'g')\n", + "plot_hpd_err(x['2PG'].values + 3, x_star[0] * np.exp(ppc_vi.posterior_predictive['chi_obs'][:,:,:,0]),\n", + " axmatrix[1], 'g')\n", + "l1 = plot_hpd_err(x['PEP'].values + 1.25, x_star[1] * np.exp(ppc_vi.posterior_predictive['chi_obs'][:,:,:,1]),\n", + " axmatrix[2], 'g')" + ] } ], "metadata": { @@ -2384,7 +5558,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.0" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/src/emll/__init__.py b/src/emll/__init__.py index 8fdfddb..767311c 100644 --- a/src/emll/__init__.py +++ b/src/emll/__init__.py @@ -1,4 +1,3 @@ from emll.linlog_model import * from emll.util import create_elasticity_matrix, create_Ey_matrix - -import emll.test_models +from . import pymc_utils \ No newline at end of file diff --git a/src/emll/bmca.py b/src/emll/bmca.py index ce4cb43..ba8edd8 100644 --- a/src/emll/bmca.py +++ b/src/emll/bmca.py @@ -10,7 +10,7 @@ import pymc as pm import pytensor.tensor as pt -import emll +from . import util os.environ["MKL_THREADING_LAYER"] = "GNU" @@ -21,13 +21,13 @@ class BMCA: def __init__( self, model_path, - v_star_path, - metabolite_concentrations_path, - boundary_fluxes_path, - enzyme_measurements_path, reference_state, + metabolite_concentrations_path=None, + enzyme_measurements_path=None, + boundary_fluxes_path=None, + v_star_path=None, ): - """Initialize the BMCA (Biochemical Model Calibration and Analysis) instance. + """Initialize the BMCA (Biochemical Model Calibration and Analysis) instance. Includes preprocessing to prepare data for pymc inference. Parameters ---------- @@ -49,35 +49,70 @@ def __init__( reference_state : str The reference state identifier for the experiment. - pt.ributes + Attributes ---------- model : cobra.Model The biochemical model loaded from the provided YAML file. - v_star : pandas.DataFrame - DataFrame containing v_star data loaded from the CSV file. - x : pandas.DataFrame DataFrame containing metabolite concentrations data loaded from the CSV file. + e : pandas.DataFrame + DataFrame containing enzyme measurements data loaded from the CSV file. + v : pandas.DataFrame DataFrame containing boundary fluxes data loaded from the CSV file. - e : pandas.DataFrame - DataFrame containing enzyme measurements data loaded from the CSV file. + v_star : pandas.DataFrame + DataFrame containing v_star data loaded from the CSV file. ref_state : str The reference state identifier used in the experiment. + """ - # TODO: create a load model function for different files types (yaml, sbml) - self.model = cobra.io.load_yaml_model(model_path) - self.v_star = pd.read_csv(v_star_path, header=None, index_col=0)[1] - self.x = pd.read_csv(metabolite_concentrations_path, index_col=0) - self.v = pd.read_csv(boundary_fluxes_path, index_col=0) - self.e = pd.read_csv(enzyme_measurements_path, index_col=0) + # TODO: Reduce reading in of data (below) into a single method using a config file + # # Gather input data + # self.gather_inputs(config_file) + # Get required user provided model and reference state + self.model = util.get_model_by_type(model_path) self.ref_state = reference_state + # Get optional user provided data + self.x = util.get_dataframe(metabolite_concentrations_path) + self.e = util.get_dataframe(enzyme_measurements_path) + self.v = util.get_dataframe(boundary_fluxes_path) + self.v_star = util.get_dataframe(v_star_path, header=None, index_col=0) + if not(self.v_star is None): + self.v_star = self.v_star[1] + + + + # TODO: move need for flux calculation outside __init__ + # # Determine if fluxes need to be calculated + # need_fluxes = False + # if not(self.v is None): + # flux_df_rows = self.v.index + # else: + # need_fluxes = True + # + # + # + # Are fluxes provided: + # Yes: which fluxes are provided? + # All fluxes: do not calculate fluxes + # Some fluxes: calculate fluxes for missing fluxes + # Use provided reference state (required) + # No: calculate fluxes (use default reference state) + # + # If need to calculate fluxes + # Are metabolomics data provided? + # Yes: calculate fluxes using metaboliomics data as constrainsts + # Are transcriptomics data provided? + # Yes: + + + def preprocess_data(self): """Read in cobra model as components.""" # Establish compartments for reactions and metabolites @@ -89,7 +124,7 @@ def preprocess_data(self): for rxn in self.model.exchanges: self.r_compartments[self.model.reactions.index(rxn)] = "t" self.m_compartments = [m.compartment for m in self.model.metabolites] - + # Reindex arrays to have the same column ordering to_consider = self.v.columns self.v = self.v.loc[:, to_consider] @@ -200,6 +235,19 @@ def build_pymc_model(self): self.pymc_model = pymc_model + + + def sample_prior_predictive(self, num_samples=500): + """Sample from prior predictive distribution.""" + with self.pymc_model: + prior_predictive = pm.sample_prior_predictive(num_samples) + + # Generate dataframe from prior predictive results + # prior_predictive_df = pd.DataFrame(prior_predictive) + + return prior_predictive_df + + def run_emll(self): """Build linlog model and run inference.""" with self.pymc_model: diff --git a/src/emll/preprocess.py b/src/emll/preprocess.py new file mode 100644 index 0000000..f876530 --- /dev/null +++ b/src/emll/preprocess.py @@ -0,0 +1,49 @@ +"""Code to create preprocessed dataframes for BMCA. + +Preprocessing tasks include generating required data from models when experimental data from the user is not provided (i.e. no data cases). +""" + +import cobra +import pandas as pd + + +def get_model(model_path): + # Load model by type + if model_path.endswith('.json'): + model = cobra.io.load_json_model(model_path) + elif model_path.endswith('.xml') or model_path.endswith('.sbml'): + model = cobra.io.read_sbml_model(model_path) + else: + raise ValueError('Model must be in .json or .xml format') + + return model + + +# TODO: Create fixtures to run each test for bad and clean versions of input data filenames + +def get_metabolomics_data(metab_data_path=None, index_col=0, header=0, model_path=None): + if metab_data_path is not None: + if metab_data_path.endswith('.csv'): + metab_data = pd.read_csv(metab_data_path, index_col=index_col, header=header) + elif metab_data_path.endswith('.xls') or metab_data_path.endswith('.xlsx'): + metab_data = pd.read_excel(metab_data_path, index_col=index_col, header=header) + else: + raise ValueError('Metabolomics data must be in .csv, .xls, or .xlsx format') + return metab_data + else: + return None + + +def get_transcriptomics_data(transcript_data_path=None, index_col=0, header=0, model_path=None): + if transcript_data_path is not None: + if transcript_data_path.endswith('.csv'): + transcript_data = pd.read_csv(transcript_data_path, index_col=index_col, header=header) + elif transcript_data_path.endswith('.xls') or transcript_data_path.endswith('.xlsx'): + transcript_data = pd.read_excel(transcript_data_path, index_col=index_col, header=header) + else: + raise ValueError('Transcriptomics data must be in .csv, .xls, or .xlsx format') + return transcript_data + else: + return None + + diff --git a/src/emll/pymc_utils.py b/src/emll/pymc_utils.py new file mode 100644 index 0000000..8fa46a9 --- /dev/null +++ b/src/emll/pymc_utils.py @@ -0,0 +1,60 @@ +import numpy as np +import pymc as pm +from . import util, linlog_model +from cobra.util import create_stoichiometric_matrix + + +def build_unconditional_pymc_model(cobra_model): + """Build unconditional pymc model from cobra model only. This relies on elasticity matrices + and stoichiometric matrices only, and is helpful for sampling prior predictives.""" + + # Get full elasticity matrix + Ex = util.create_elasticity_matrix(cobra_model) + + # Get external elasticity matrix + Ey = util.create_Ey_matrix(cobra_model) + + # Get stoichiometric matrix + N = create_stoichiometric_matrix(cobra_model, dtype='int') + + with pm.Model() as pymc_model: + # Initialize elasticities + Ex_t = pm.Deterministic('Ex', util.initialize_elasticity(N, 'ex', b=0.05, sigma=1, alpha=5)) + Ey_t = pm.Deterministic('Ey', util.initialize_elasticity(-Ey.T, 'ey', b=0.05, sigma=1, alpha=5)) + + return pymc_model + + +def sample_prior_predictive(pymc_model): + """Sample prior predictive distribution.""" + with pymc_model: + trace_prior = pm.sample_prior_predictive() + + return trace_prior + + +def sample_prior_fccs(cobra_model): + """Extract flux control coefficients from prior predictive distribution.""" + + # Get prior traces froim unconditional pymc model + pymc_model = build_unconditional_pymc_model(cobra_model) + trace_prior = sample_prior_predictive(pymc_model) + + # Get flux star + v_star = util.calculate_v_star(cobra_model) + + # Get full elasticity matrix + Ex = util.create_elasticity_matrix(cobra_model) + + # Get external elasticity matrix + Ey = util.create_Ey_matrix(cobra_model) + + # Get stoichiometric matrix + N = create_stoichiometric_matrix(cobra_model, dtype='int') + + # Creaet linlog model + ll = linlog_model.LinLogLeastNorm(N, Ex, Ey, v_star, driver='gelsy') + + fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()]) + + return fcc_prior diff --git a/src/emll/util.py b/src/emll/util.py index b729de9..10b4cc2 100644 --- a/src/emll/util.py +++ b/src/emll/util.py @@ -1,7 +1,47 @@ +import cobra import numpy as np -import scipy as sp -import pytensor.tensor as at +import pandas as pd import pymc as pm +import pytensor.tensor as at +import scipy as sp + + +def get_model_by_type(model_path): + """Get a model from a path.""" + if model_path.endswith('.json'): + return cobra.io.load_json_model(model_path) + elif model_path.endswith('.xml') or model_path.endswith('.sbml'): + return cobra.io.read_sbml_model(model_path) + elif model_path.endswith('.mat'): + return cobra.io.load_matlab_model(model_path) + elif model_path.endswith('.yml') or model_path.endswith('.yaml'): + return cobra.io.load_yaml_model(model_path) + else: + raise ValueError('Model must be in .json, .xml, .mat, or .yml format') + + +def get_dataframe(dataframe_path, header=0, index_col=0): + """Get a dataframe from a path.""" + if dataframe_path is None: + return None + if dataframe_path.endswith('.csv'): + return pd.read_csv(dataframe_path, header, index_col) + elif dataframe_path.endswith('.xls') or dataframe_path.endswith('.xlsx'): + return pd.read_excel(dataframe_path, header, index_col) + else: + raise ValueError('Dataframe must be in .csv, .xls, or .xlsx format') + + +def get_fluxes(model): + """Get fluxes from a model.""" + return model.optimize().fluxes + + +def calculate_v_star(model): + """Calculate reference strain fluxes.""" + fluxes = get_fluxes(model) + v_star = np.abs(fluxes.values) + return v_star def create_elasticity_matrix(model): @@ -36,10 +76,11 @@ def create_elasticity_matrix(model): def create_Ey_matrix(model): - """This function should return a good guess for the Ey matrix. This - essentially requires considering the effects of the reactants / products - for the unbalanced exchange reactions, and is probably best handled - manually for now.""" + """This function should return a good guess for the Ey matrix. + It operates under the assumption that the model is valid with respect to + boundary reactions being identifiable (with an 'EX_' prefix) and metabolites + being identifiable by their respective compartments (e.g. '_e' for external + metabolites, and '_c' for cytoplasmic).""" boundary_indexes = [model.reactions.index(r) for r in model.medium.keys()] boundary_directions = [ diff --git a/tests/test_bmca.py b/tests/test_bmca.py index 6c050b9..475c66b 100644 --- a/tests/test_bmca.py +++ b/tests/test_bmca.py @@ -1,35 +1,92 @@ import pytest -from src.emll import bmca +from emll import bmca, util import cobra import pandas as pd -# Get hackett data and initialize BMCA object +# # Get hackett data and initialize BMCA object +# @pytest.fixture(scope="module") +# def hackett_bmca_obj(): +# hackett_paths = { +# "model_path": "tests/test_models/jol2012.yaml", +# "v_star_path": "notebooks/data/v_star.csv", +# "metabolite_concentrations_path": "notebooks/data/metabolite_concentrations.csv", +# "boundary_fluxes_path": "notebooks/data/boundary_fluxes.csv", +# "enzyme_measurements_path": "notebooks/data/enzyme_measurements.csv", +# "reference_state": "P0.11", +# } +# bmca_obj = bmca.BMCA( +# model_path = hackett_paths["model_path"], +# metabolite_concentrations_path = hackett_paths["metabolite_concentrations_path"], +# enzyme_measurements_path = hackett_paths["enzyme_measurements_path"], +# reference_state = hackett_paths["reference_state"], +# boundary_fluxes_path = hackett_paths["boundary_fluxes_path"], +# v_star_path = hackett_paths["v_star_path"], +# ) +# return bmca_obj + + +# # Get contador data and initialize BMCA object +# @pytest.fixture(scope="module") +# def contador_bmca_obj(): +# contador_paths = { +# "model_path": "tests/test_models/contador_updatedbounds.json", +# "v_star_path": None, +# "metabolite_concentrations_path": None, +# "boundary_fluxes_path": None, +# "enzyme_measurements_path": None, +# "reference_state": None, +# } +# bmca_obj = bmca.BMCA( +# model_path = contador_paths["model_path"], +# metabolite_concentrations_path = contador_paths["metabolite_concentrations_path"], +# enzyme_measurements_path = contador_paths["enzyme_measurements_path"], +# reference_state = contador_paths["reference_state"], +# boundary_fluxes_path = contador_paths["boundary_fluxes_path"], +# v_star_path = contador_paths["v_star_path"], +# ) +# return bmca_obj + +# Get wu2004 data and initialize BMCA object @pytest.fixture(scope="module") -def hackett_bmca_obj(): - hackett_paths = { - "model_path": "notebooks/data/data/jol2012.yaml", - "v_star_path": "notebooks/data/v_star.csv", - "metabolite_concentrations_path": "notebooks/data/metabolite_concentrations.csv", - "boundary_fluxes_path": "notebooks/data/boundary_fluxes.csv", - "enzyme_measurements_path": "notebooks/data/enzyme_measurements.csv", - "reference_state": "P0.11", +def wu2004_bmca_obj(): + wu2004_paths = { + "model_path": "tests/test_models/wu2004_model.sbml", + "v_star_path": None, + "metabolite_concentrations_path": None, + "boundary_fluxes_path": None, + "enzyme_measurements_path": None, + "reference_state": None, } bmca_obj = bmca.BMCA( - model_path = hackett_paths["model_path"], - metabolite_concentrations_path = hackett_paths["metabolite_concentrations_path"], - enzyme_measurements_path = hackett_paths["enzyme_measurements_path"], - reference_state = hackett_paths["reference_state"], - boundary_fluxes_path = hackett_paths["boundary_fluxes_path"], - v_star_path = hackett_paths["v_star_path"], + model_path = wu2004_paths["model_path"], + metabolite_concentrations_path = wu2004_paths["metabolite_concentrations_path"], + enzyme_measurements_path = wu2004_paths["enzyme_measurements_path"], + reference_state = wu2004_paths["reference_state"], + boundary_fluxes_path = wu2004_paths["boundary_fluxes_path"], + v_star_path = wu2004_paths["v_star_path"], ) return bmca_obj +# Get BMCA object +@pytest.fixture( + # params=["hackett", "contador", "wu2004"], + params=["wu2004"], + name="bmca_obj", +) +def get_bmca_obj(request): + # if request.param == "hackett": + # return hackett_bmca_obj() + # elif request.param == "contador": + # return contador_bmca_obj() + # elif request.param == "wu2004": + if request.param == "wu2004": + return wu2004_bmca_obj + + # Test types of initialized BMCA object -def test_init_type(hackett_bmca_obj): - bmca_obj = hackett_bmca_obj() - +def test_init_type(bmca_obj): assert isinstance(bmca_obj.model, cobra.core.model.Model) assert isinstance(bmca_obj.x, pd.DataFrame) assert isinstance(bmca_obj.e, pd.DataFrame) @@ -41,8 +98,7 @@ def test_init_type(hackett_bmca_obj): # Test BMCA object initial structure -def test_initial_structure(hackett_bmca_obj): - bmca_obj = hackett_bmca_obj() +def test_initial_structure(bmca_obj): # Check if metabolomics & enzyme measurement AND flux data rows are in the model with bmca_obj.model as model: @@ -68,41 +124,45 @@ def test_initial_structure(hackett_bmca_obj): + + + +# Test getting fluxes from model +def test_get_fluxes(bmca_obj): + fluxes = bmca_obj.get_fluxes() + assert isinstance(fluxes, pd.DataFrame) + + # Run preprocess of BMCA data to test each sub-routine -@pytest.fixture(scope="module") -def preprocessed_bmca_obj(hackett_bmca_obj): - bmca_obj = hackett_bmca_obj() +@pytest.fixture( + name="preprocessed_bmca_obj", + scope="module") +def preprocessed_bmca_obj(bmca_obj): return bmca_obj.preprocess_data() # Test establishing compartments def test_establish_compartments(preprocessed_bmca_obj): - bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) - # TODO: check r_compartments and m_compartments pass def test_reindexing_bmca_slots(preprocessed_bmca_obj): - bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) # TODO: check x, v, and e slots in bmca_obj for changes pass def test_normalizing_bmca_slots(preprocessed_bmca_obj): - bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) # TODO: check normalization of x, v, and e as xn, vn, and en slots in bmca_obj pass def test_index_measured_bmca_slots(preprocessed_bmca_obj): - bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) # TODO: check x_inds, e_inds, v_inds, e_laplace_inds, e_zero_inds, slots in bmca_obj pass def test_new_matrices(preprocessed_bmca_obj): - bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) # TODO: check N, Ex, Ey, ll slots in bmca_obj pass @@ -110,23 +170,22 @@ def test_new_matrices(preprocessed_bmca_obj): # Build pymc model def pymc_model_bmca_obj(preprocessed_bmca_obj): - bmca_obj = preprocessed_bmca_obj(hackett_bmca_obj) - bmca_obj.build_pymc_model() - + preprocessed_bmca_obj.build_pymc_model() + # TODO: figure out what's happening here return bmca_obj -# Test building pymc model -def test_build_pymc_model(pymc_model_bmca_obj, preprocessed_bmca_obj, hackett_bmca_obj): # ** Do I need to pass hackett_bmca_obj here? - bmca_obj = pymc_model_bmca_obj(preprocessed_bmca_obj(hackett_bmca_obj)) +# # Test building pymc model +# def test_build_pymc_model(pymc_model_bmca_obj, preprocessed_bmca_obj, hackett_bmca_obj): # ** Do I need to pass hackett_bmca_obj here? +# bmca_obj = pymc_model_bmca_obj(preprocessed_bmca_obj(hackett_bmca_obj)) - # TODO: check Ex_t, Ey_t, pymc_model slots in bmca_obj - pass +# # TODO: check Ex_t, Ey_t, pymc_model slots in bmca_obj +# pass -# Test running ADVI -def test_run_advi(pymc_model_bmca_obj, preprocessed_bmca_obj, hackett_bmca_obj): - bmca_obj = pymc_model_bmca_obj(preprocessed_bmca_obj(hackett_bmca_obj)) - approx, hist = emll_model.run_emll() +# # Test running ADVI +# def test_run_advi(pymc_model_bmca_obj, preprocessed_bmca_obj, hackett_bmca_obj): +# bmca_obj = pymc_model_bmca_obj(preprocessed_bmca_obj(hackett_bmca_obj)) +# approx, hist = emll_model.run_emll() - # TODO: check approx, hist - pass +# # TODO: check approx, hist +# pass diff --git a/tests/test_data/expected_wu2004_FCC_posterior_ADVI.csv b/tests/test_data/expected_wu2004_FCC_posterior_ADVI.csv new file mode 100644 index 0000000..09095ee --- /dev/null +++ b/tests/test_data/expected_wu2004_FCC_posterior_ADVI.csv @@ -0,0 +1,3001 @@ +,level_1,0,type +0,PGM,-0.10051370742058996,ADVI +0,ENO,0.16357754200476654,ADVI +0,PK,0.9369361654158234,ADVI +1,PGM,-0.0718192375861042,ADVI +1,ENO,0.1834744257798551,ADVI +1,PK,0.888344811806249,ADVI +2,PGM,-0.11872617626618176,ADVI +2,ENO,0.17524493048382178,ADVI +2,PK,0.94348124578236,ADVI +3,PGM,-0.0614348959950477,ADVI +3,ENO,0.20358089633189966,ADVI +3,PK,0.857853999663148,ADVI +4,PGM,-0.09930656053361275,ADVI +4,ENO,0.165209102537827,ADVI +4,PK,0.9340974579957857,ADVI +5,PGM,-0.06807574431595942,ADVI +5,ENO,0.2064393763975541,ADVI +5,PK,0.8616363679184054,ADVI +6,PGM,-0.09900345973608626,ADVI +6,ENO,0.17957344375707904,ADVI +6,PK,0.9194300159790072,ADVI +7,PGM,-0.07309560285078298,ADVI +7,ENO,0.17292957859892633,ADVI +7,PK,0.9001660242518567,ADVI +8,PGM,-0.07203554032988402,ADVI +8,ENO,0.16332380927814422,ADVI +8,PK,0.9087117310517396,ADVI +9,PGM,-0.09639481623846757,ADVI +9,ENO,0.2002065480562692,ADVI +9,PK,0.8961882681821984,ADVI +10,PGM,-0.011841168171809136,ADVI +10,ENO,0.17832465392141764,ADVI +10,PK,0.8335165142503914,ADVI +11,PGM,-0.0703231841844052,ADVI +11,ENO,0.16575674960055203,ADVI +11,PK,0.9045664345838531,ADVI +12,PGM,-0.03552801543407802,ADVI +12,ENO,0.19885431804265716,ADVI +12,PK,0.8366736973914208,ADVI +13,PGM,-0.0412097380650327,ADVI +13,ENO,0.18183860650781764,ADVI +13,PK,0.8593711315572151,ADVI +14,PGM,-0.02472643501425642,ADVI +14,ENO,0.17110726829958423,ADVI +14,PK,0.8536191667146722,ADVI +15,PGM,-0.13086387035943825,ADVI +15,ENO,0.20281829196231113,ADVI +15,PK,0.9280455783971272,ADVI +16,PGM,-0.07192167379345693,ADVI +16,ENO,0.1861872247585317,ADVI +16,PK,0.8857344490349253,ADVI +17,PGM,-0.0348982965372584,ADVI +17,ENO,0.17897517289314216,ADVI +17,PK,0.8559231236441165,ADVI +18,PGM,-0.044711537989054806,ADVI +18,ENO,0.17706672139990073,ADVI +18,PK,0.867644816589154,ADVI +19,PGM,-0.09207835117226582,ADVI +19,ENO,0.17993978129788496,ADVI +19,PK,0.912138569874381,ADVI +20,PGM,-0.11816596490505393,ADVI +20,ENO,0.15978255924863718,ADVI +20,PK,0.9583834056564168,ADVI +21,PGM,-0.053495949569761336,ADVI +21,ENO,0.16155660443020603,ADVI +21,PK,0.8919393451395553,ADVI +22,PGM,-0.08164006073502339,ADVI +22,ENO,0.17672327201499435,ADVI +22,PK,0.9049167887200289,ADVI +23,PGM,-0.05483912011963166,ADVI +23,ENO,0.18448982290247884,ADVI +23,PK,0.8703492972171528,ADVI +24,PGM,-0.007966709541604722,ADVI +24,ENO,0.17797262800901237,ADVI +24,PK,0.8299940815325922,ADVI +25,PGM,-0.0844896394291268,ADVI +25,ENO,0.1432845165324877,ADVI +25,PK,0.9412051228966392,ADVI +26,PGM,-0.06427187508666155,ADVI +26,ENO,0.1710755920676417,ADVI +26,PK,0.8931962830190198,ADVI +27,PGM,-0.048495361613300814,ADVI +27,ENO,0.17402012510820586,ADVI +27,PK,0.8744752365050951,ADVI +28,PGM,-0.11564588009940069,ADVI +28,ENO,0.17532811697085424,ADVI +28,PK,0.9403177631285465,ADVI +29,PGM,-0.16624323768753935,ADVI +29,ENO,0.19736889626680887,ADVI +29,PK,0.9688743414207305,ADVI +30,PGM,-0.09598634043748255,ADVI +30,ENO,0.16265548865690085,ADVI +30,PK,0.9333308517805817,ADVI +31,PGM,-0.08518405358596426,ADVI +31,ENO,0.1913887895987927,ADVI +31,PK,0.8937952639871717,ADVI +32,PGM,-0.13094838031772982,ADVI +32,ENO,0.19678763323476994,ADVI +32,PK,0.9341607470829599,ADVI +33,PGM,-0.07057600798766783,ADVI +33,ENO,0.15085264326222234,ADVI +33,PK,0.9197233647254454,ADVI +34,PGM,-0.06544108987046737,ADVI +34,ENO,0.18806794687969017,ADVI +34,PK,0.8773731429907773,ADVI +35,PGM,-0.046372767322673036,ADVI +35,ENO,0.1909789644043574,ADVI +35,PK,0.8553938029183157,ADVI +36,PGM,-0.08020107464847648,ADVI +36,ENO,0.15636472080450292,ADVI +36,PK,0.9238363538439737,ADVI +37,PGM,-0.09394514753546512,ADVI +37,ENO,0.18062242403812273,ADVI +37,PK,0.9133227234973423,ADVI +38,PGM,-0.1666876862803326,ADVI +38,ENO,0.1643903336662608,ADVI +38,PK,1.0022973526140717,ADVI +39,PGM,-0.0789219226884117,ADVI +39,ENO,0.18915120388926088,ADVI +39,PK,0.8897707187991508,ADVI +40,PGM,-0.09624103617557744,ADVI +40,ENO,0.15957250008083793,ADVI +40,PK,0.9366685360947394,ADVI +41,PGM,-0.12154878876497333,ADVI +41,ENO,0.1459536113494711,ADVI +41,PK,0.9755951774155023,ADVI +42,PGM,-0.06726290842936988,ADVI +42,ENO,0.18410569191689566,ADVI +42,PK,0.8831572165124744,ADVI +43,PGM,-0.06481023489391746,ADVI +43,ENO,0.18020093901170253,ADVI +43,PK,0.8846092958822149,ADVI +44,PGM,-0.04960477644036998,ADVI +44,ENO,0.18022938712535588,ADVI +44,PK,0.8693753893150141,ADVI +45,PGM,-0.03975467308298941,ADVI +45,ENO,0.17997574846069825,ADVI +45,PK,0.859778924622291,ADVI +46,PGM,-0.11985084437530658,ADVI +46,ENO,0.17279642013606714,ADVI +46,PK,0.9470544242392395,ADVI +47,PGM,-0.05322673699801839,ADVI +47,ENO,0.169662856783908,ADVI +47,PK,0.8835638802141103,ADVI +48,PGM,-0.07806372150621899,ADVI +48,ENO,0.16832534256255707,ADVI +48,PK,0.909738378943662,ADVI +49,PGM,-0.03195469220947378,ADVI +49,ENO,0.1580854747624557,ADVI +49,PK,0.8738692174470181,ADVI +50,PGM,-0.08983035221909619,ADVI +50,ENO,0.16581559099825746,ADVI +50,PK,0.9240147612208388,ADVI +51,PGM,-0.0691045082417121,ADVI +51,ENO,0.18249531451146334,ADVI +51,PK,0.8866091937302487,ADVI +52,PGM,-0.04854851695234963,ADVI +52,ENO,0.17682380599026043,ADVI +52,PK,0.8717247109620894,ADVI +53,PGM,-0.11906320888392297,ADVI +53,ENO,0.1798027916179894,ADVI +53,PK,0.9392604172659336,ADVI +54,PGM,-0.04660041065031595,ADVI +54,ENO,0.1873857872862519,ADVI +54,PK,0.8592146233640642,ADVI +55,PGM,-0.1561306485144922,ADVI +55,ENO,0.16919435671367333,ADVI +55,PK,0.9869362918008189,ADVI +56,PGM,-0.05942580576717793,ADVI +56,ENO,0.18256121406029738,ADVI +56,PK,0.8768645917068805,ADVI +57,PGM,-0.09217907908809786,ADVI +57,ENO,0.14847280553049755,ADVI +57,PK,0.9437062735576003,ADVI +58,PGM,-0.07831209804535821,ADVI +58,ENO,0.18926779730386317,ADVI +58,PK,0.889044300741495,ADVI +59,PGM,-0.13372072397587864,ADVI +59,ENO,0.17872830659026692,ADVI +59,PK,0.9549924173856117,ADVI +60,PGM,-0.05744876774234897,ADVI +60,ENO,0.1772734887309254,ADVI +60,PK,0.8801752790114235,ADVI +61,PGM,-0.06772406060948577,ADVI +61,ENO,0.19254776213480096,ADVI +61,PK,0.8751762984746848,ADVI +62,PGM,-0.07191380391892399,ADVI +62,ENO,0.17412390796277888,ADVI +62,PK,0.8977898959561451,ADVI +63,PGM,-0.07096273791810281,ADVI +63,ENO,0.16660553207311052,ADVI +63,PK,0.9043572058449924,ADVI +64,PGM,-0.05918954849198865,ADVI +64,ENO,0.17288172810183178,ADVI +64,PK,0.8863078203901569,ADVI +65,PGM,-0.12854496751568778,ADVI +65,ENO,0.18908715245963675,ADVI +65,PK,0.9394578150560511,ADVI +66,PGM,-0.10444046265991314,ADVI +66,ENO,0.15609154473621692,ADVI +66,PK,0.948348917923696,ADVI +67,PGM,-0.007525013193683705,ADVI +67,ENO,0.17982200226285597,ADVI +67,PK,0.8277030109308278,ADVI +68,PGM,-0.09839346915087632,ADVI +68,ENO,0.1824998663731178,ADVI +68,PK,0.9158936027777586,ADVI +69,PGM,-0.0022916804807489033,ADVI +69,ENO,0.17932897986834737,ADVI +69,PK,0.8229627006124014,ADVI +70,PGM,-0.059471951573487836,ADVI +70,ENO,0.16211022550344772,ADVI +70,PK,0.8973617260700402,ADVI +71,PGM,-0.05448262349429567,ADVI +71,ENO,0.16513200480110415,ADVI +71,PK,0.8893506186931913,ADVI +72,PGM,-0.13185632555145288,ADVI +72,ENO,0.18624291343029883,ADVI +72,PK,0.9456134121211541,ADVI +73,PGM,-0.057989231324933055,ADVI +73,ENO,0.17062815636739617,ADVI +73,PK,0.8873610749575369,ADVI +74,PGM,-0.02518712209106866,ADVI +74,ENO,0.1823869949995617,ADVI +74,PK,0.842800127091507,ADVI +75,PGM,-0.05839950161729379,ADVI +75,ENO,0.18402292167527998,ADVI +75,PK,0.8743765799420138,ADVI +76,PGM,-0.0736153227445493,ADVI +76,ENO,0.18315127584904517,ADVI +76,PK,0.8904640468955041,ADVI +77,PGM,-0.07870780515784048,ADVI +77,ENO,0.1598672313946986,ADVI +77,PK,0.918840573763142,ADVI +78,PGM,-0.10489384700048765,ADVI +78,ENO,0.16638208963198517,ADVI +78,PK,0.9385117573685025,ADVI +79,PGM,-0.09233014712636134,ADVI +79,ENO,0.1457803462710934,ADVI +79,PK,0.946549800855268,ADVI +80,PGM,-0.1036309674160818,ADVI +80,ENO,0.18857249566381995,ADVI +80,PK,0.915058471752262,ADVI +81,PGM,-0.13398731810796383,ADVI +81,ENO,0.17964846321016129,ADVI +81,PK,0.9543388548978026,ADVI +82,PGM,-0.014475211499245244,ADVI +82,ENO,0.18224921361654026,ADVI +82,PK,0.8322259978827049,ADVI +83,PGM,-0.04201030062305833,ADVI +83,ENO,0.17284477539847776,ADVI +83,PK,0.8691655252245807,ADVI +84,PGM,-0.09900782816768627,ADVI +84,ENO,0.17877129911263204,ADVI +84,PK,0.9202365290550544,ADVI +85,PGM,-0.13046601606567232,ADVI +85,ENO,0.21310683115821935,ADVI +85,PK,0.9173591849074529,ADVI +86,PGM,-0.10186435124120874,ADVI +86,ENO,0.18086224685439864,ADVI +86,PK,0.92100210438681,ADVI +87,PGM,-0.12925002571659117,ADVI +87,ENO,0.17155070224015181,ADVI +87,PK,0.9576993234764394,ADVI +88,PGM,-0.025515542237076527,ADVI +88,ENO,0.1731642735055633,ADVI +88,PK,0.8523512687315131,ADVI +89,PGM,-0.09400653830159156,ADVI +89,ENO,0.1850035232643039,ADVI +89,PK,0.9090030150372875,ADVI +90,PGM,-0.05280807129378595,ADVI +90,ENO,0.16978828339980467,ADVI +90,PK,0.8830197878939813,ADVI +91,PGM,-0.080286340340608,ADVI +91,ENO,0.18968072537810593,ADVI +91,PK,0.8906056149625021,ADVI +92,PGM,-0.08099391244255871,ADVI +92,ENO,0.18497603272366125,ADVI +92,PK,0.8960178797188975,ADVI +93,PGM,-0.09150573766598025,ADVI +93,ENO,0.1916189852815967,ADVI +93,PK,0.8998867523843835,ADVI +94,PGM,-0.07632534115622458,ADVI +94,ENO,0.16856650356862843,ADVI +94,PK,0.9077588375875962,ADVI +95,PGM,-0.057463268990939786,ADVI +95,ENO,0.17107043232504232,ADVI +95,PK,0.8863928366658973,ADVI +96,PGM,-0.07179316597960694,ADVI +96,ENO,0.15111553322847177,ADVI +96,PK,0.9206776327511352,ADVI +97,PGM,-0.1253223372166945,ADVI +97,ENO,0.1886015981786052,ADVI +97,PK,0.9367207390380894,ADVI +98,PGM,-0.07102853705469703,ADVI +98,ENO,0.18020473978032384,ADVI +98,PK,0.890823797274373,ADVI +99,PGM,-0.06262560287739949,ADVI +99,ENO,0.1746782589763328,ADVI +99,PK,0.8879473439010668,ADVI +100,PGM,-0.0333697247514968,ADVI +100,ENO,0.1488557601510673,ADVI +100,PK,0.8845139646004295,ADVI +101,PGM,-0.09787988268116554,ADVI +101,ENO,0.1968080875998542,ADVI +101,PK,0.9010717950813115,ADVI +102,PGM,-0.06128348089757041,ADVI +102,ENO,0.18237119176981795,ADVI +102,PK,0.8789122891277524,ADVI +103,PGM,-0.05002520313496284,ADVI +103,ENO,0.17316500519167355,ADVI +103,PK,0.8768601979432893,ADVI +104,PGM,-0.021349163788041192,ADVI +104,ENO,0.1773700185936296,ADVI +104,PK,0.8439791451944118,ADVI +105,PGM,-0.059668515668368505,ADVI +105,ENO,0.1719554434885094,ADVI +105,PK,0.887713072179859,ADVI +106,PGM,-0.046290870131082906,ADVI +106,ENO,0.14545715014584334,ADVI +106,PK,0.9008337199852395,ADVI +107,PGM,-0.05364736505111822,ADVI +107,ENO,0.17301187206131707,ADVI +107,PK,0.8806354929898013,ADVI +108,PGM,-0.10325336622250259,ADVI +108,ENO,0.1643071790683573,ADVI +108,PK,0.9389461871541452,ADVI +109,PGM,-0.04329150049200314,ADVI +109,ENO,0.18254354094839886,ADVI +109,PK,0.8607479595436044,ADVI +110,PGM,-0.045916646758516366,ADVI +110,ENO,0.18830849950116169,ADVI +110,PK,0.8576081472573547,ADVI +111,PGM,-0.14628767944342513,ADVI +111,ENO,0.17470768041696963,ADVI +111,PK,0.9715799990264555,ADVI +112,PGM,-0.04280847359582496,ADVI +112,ENO,0.1838214962194561,ADVI +112,PK,0.8589869773763688,ADVI +113,PGM,-0.12355354843859856,ADVI +113,ENO,0.16135186512999627,ADVI +113,PK,0.9622016833086023,ADVI +114,PGM,-0.11863676515774113,ADVI +114,ENO,0.1847106308002972,ADVI +114,PK,0.933926134357444,ADVI +115,PGM,-0.08506827098869763,ADVI +115,ENO,0.1714775247596996,ADVI +115,PK,0.9135907462289982,ADVI +116,PGM,-0.08961835490506775,ADVI +116,ENO,0.1801511407517408,ADVI +116,PK,0.909467214153327,ADVI +117,PGM,-0.14219310030257604,ADVI +117,ENO,0.1570868760833651,ADVI +117,PK,0.9851062242192109,ADVI +118,PGM,-0.07579211592539048,ADVI +118,ENO,0.17107254525825072,ADVI +118,PK,0.9047195706671398,ADVI +119,PGM,-0.09393076379121701,ADVI +119,ENO,0.16010058319737205,ADVI +119,PK,0.9338301805938449,ADVI +120,PGM,-0.09832776495933282,ADVI +120,ENO,0.17803518473159663,ADVI +120,PK,0.9202925802277362,ADVI +121,PGM,-0.0694493297240979,ADVI +121,ENO,0.18032237381317437,ADVI +121,PK,0.8891269559109234,ADVI +122,PGM,-0.11225244454550665,ADVI +122,ENO,0.15858027555866075,ADVI +122,PK,0.9536721689868458,ADVI +123,PGM,-0.027800259345086342,ADVI +123,ENO,0.17007502709215136,ADVI +123,PK,0.8577252322529348,ADVI +124,PGM,-0.15147763473942644,ADVI +124,ENO,0.20112059029355167,ADVI +124,PK,0.9503570444458749,ADVI +125,PGM,-0.027525933475544884,ADVI +125,ENO,0.1588849784010757,ADVI +125,PK,0.8686409550744691,ADVI +126,PGM,-0.04814785871390881,ADVI +126,ENO,0.17176213559361303,ADVI +126,PK,0.8763857231202958,ADVI +127,PGM,-0.13193820671920742,ADVI +127,ENO,0.16390801465403912,ADVI +127,PK,0.9680301920651683,ADVI +128,PGM,-0.10800406603068935,ADVI +128,ENO,0.1644636733259494,ADVI +128,PK,0.94354039270474,ADVI +129,PGM,-0.06524783520661215,ADVI +129,ENO,0.1835749838115822,ADVI +129,PK,0.8816728513950299,ADVI +130,PGM,-0.07626397259939832,ADVI +130,ENO,0.1541831714102484,ADVI +130,PK,0.9220808011891498,ADVI +131,PGM,-0.0349176302766212,ADVI +131,ENO,0.1755210822084089,ADVI +131,PK,0.8593965480682122,ADVI +132,PGM,-0.11907836061897381,ADVI +132,ENO,0.17673552463857473,ADVI +132,PK,0.9423428359803993,ADVI +133,PGM,-0.08872479824264445,ADVI +133,ENO,0.1831937265274268,ADVI +133,PK,0.9055310717152176,ADVI +134,PGM,-0.09935361100022999,ADVI +134,ENO,0.16112610974156938,ADVI +134,PK,0.9382275012586606,ADVI +135,PGM,-0.09614588497405596,ADVI +135,ENO,0.18674460769990855,ADVI +135,PK,0.9094012772741474,ADVI +136,PGM,-0.07098259528713835,ADVI +136,ENO,0.1747166497511616,ADVI +136,PK,0.8962659455359768,ADVI +137,PGM,-0.07387818864761897,ADVI +137,ENO,0.1502890639459755,ADVI +137,PK,0.9235891247016434,ADVI +138,PGM,-0.12154819456687482,ADVI +138,ENO,0.177771034278035,ADVI +138,PK,0.9437771602888398,ADVI +139,PGM,-0.11000718757112438,ADVI +139,ENO,0.16635010401138756,ADVI +139,PK,0.9436570835597369,ADVI +140,PGM,-0.02179568093228834,ADVI +140,ENO,0.17733874239904063,ADVI +140,PK,0.8444569385332477,ADVI +141,PGM,-0.03631999574308398,ADVI +141,ENO,0.16915495074874892,ADVI +141,PK,0.8671650449943349,ADVI +142,PGM,-0.09847102555923559,ADVI +142,ENO,0.17847575772677396,ADVI +142,PK,0.9199952678324617,ADVI +143,PGM,-0.10910939077072435,ADVI +143,ENO,0.18601839364769873,ADVI +143,PK,0.9230909971230257,ADVI +144,PGM,-0.08761034482669872,ADVI +144,ENO,0.18581437584374405,ADVI +144,PK,0.9017959689829547,ADVI +145,PGM,-0.10030712715413115,ADVI +145,ENO,0.18777139848880314,ADVI +145,PK,0.9125357286653281,ADVI +146,PGM,-0.061822029506870546,ADVI +146,ENO,0.17388717729835063,ADVI +146,PK,0.8879348522085199,ADVI +147,PGM,-0.0785130284409401,ADVI +147,ENO,0.16745436871573552,ADVI +147,PK,0.9110586597252046,ADVI +148,PGM,-0.08601619331706511,ADVI +148,ENO,0.17191160887480386,ADVI +148,PK,0.9141045844422612,ADVI +149,PGM,-0.04116425871915674,ADVI +149,ENO,0.1791434726206929,ADVI +149,PK,0.8620207860984638,ADVI +150,PGM,-0.06672401877777356,ADVI +150,ENO,0.16782541230500747,ADVI +150,PK,0.8988986064727661,ADVI +151,PGM,-0.07509804765798922,ADVI +151,ENO,0.16514660524986352,ADVI +151,PK,0.9099514424081258,ADVI +152,PGM,-0.1195186015298495,ADVI +152,ENO,0.16951036506475115,ADVI +152,PK,0.9500082364650984,ADVI +153,PGM,-0.0843704572259103,ADVI +153,ENO,0.1581232000865429,ADVI +153,PK,0.9262472571393673,ADVI +154,PGM,-0.10493335605232268,ADVI +154,ENO,0.17796987387077964,ADVI +154,PK,0.926963482181543,ADVI +155,PGM,-0.11704219765895063,ADVI +155,ENO,0.1591153050173511,ADVI +155,PK,0.9579268926415995,ADVI +156,PGM,-0.07955131221374478,ADVI +156,ENO,0.15194736748812165,ADVI +156,PK,0.9276039447256232,ADVI +157,PGM,-0.10147265508021497,ADVI +157,ENO,0.1867255705409576,ADVI +157,PK,0.9147470845392575,ADVI +158,PGM,-0.0689813246484301,ADVI +158,ENO,0.1732497479144463,ADVI +158,PK,0.8957315767339837,ADVI +159,PGM,-0.05147168443688832,ADVI +159,ENO,0.17956072476821697,ADVI +159,PK,0.8719109596686712,ADVI +160,PGM,-0.06348318487861793,ADVI +160,ENO,0.1611235020794656,ADVI +160,PK,0.9023596827991522,ADVI +161,PGM,-0.08309981599303473,ADVI +161,ENO,0.1653752015042929,ADVI +161,PK,0.9177246144887418,ADVI +162,PGM,-0.086147995329793,ADVI +162,ENO,0.1604110728868741,ADVI +162,PK,0.9257369224429188,ADVI +163,PGM,-0.06206876523046079,ADVI +163,ENO,0.15423343795463748,ADVI +163,PK,0.9078353272758234,ADVI +164,PGM,-0.08757227809399004,ADVI +164,ENO,0.16955084415356342,ADVI +164,PK,0.9180214339404267,ADVI +165,PGM,-0.1212302347876979,ADVI +165,ENO,0.15682176291011218,ADVI +165,PK,0.9644084718775857,ADVI +166,PGM,-0.04378355694921354,ADVI +166,ENO,0.18937925027311778,ADVI +166,PK,0.8544043066760957,ADVI +167,PGM,-0.12484498421558543,ADVI +167,ENO,0.19034866656031907,ADVI +167,PK,0.9344963176552662,ADVI +168,PGM,-0.06657621170742756,ADVI +168,ENO,0.1940238707408891,ADVI +168,PK,0.8725523409665383,ADVI +169,PGM,-0.09744044199571533,ADVI +169,ENO,0.190427327649305,ADVI +169,PK,0.9070131143464103,ADVI +170,PGM,-0.05444016228094428,ADVI +170,ENO,0.1820139181943271,ADVI +170,PK,0.8724262440866172,ADVI +171,PGM,-0.11661148862930659,ADVI +171,ENO,0.18655003403222828,ADVI +171,PK,0.9300614545970783,ADVI +172,PGM,-0.08163450578314269,ADVI +172,ENO,0.18662616901642834,ADVI +172,PK,0.8950083367667143,ADVI +173,PGM,-0.09677675854124423,ADVI +173,ENO,0.18388759821989997,ADVI +173,PK,0.9128891603213444,ADVI +174,PGM,-0.08931497701583635,ADVI +174,ENO,0.1993686321766068,ADVI +174,PK,0.8899463448392296,ADVI +175,PGM,-0.013223752254387877,ADVI +175,ENO,0.17507819845460265,ADVI +175,PK,0.8381455537997853,ADVI +176,PGM,-0.13485934956350976,ADVI +176,ENO,0.15305095325434862,ADVI +176,PK,0.9818083963091613,ADVI +177,PGM,-0.09294704653058994,ADVI +177,ENO,0.17155300391254985,ADVI +177,PK,0.9213940426180403,ADVI +178,PGM,-0.13028430201227836,ADVI +178,ENO,0.17328789712227996,ADVI +178,PK,0.9569964048899983,ADVI +179,PGM,-0.08335112142010903,ADVI +179,ENO,0.1762482704016203,ADVI +179,PK,0.9071028510184888,ADVI +180,PGM,-0.14997991742266703,ADVI +180,ENO,0.161056765739465,ADVI +180,PK,0.9889231516832021,ADVI +181,PGM,-0.08001565997286497,ADVI +181,ENO,0.15548212712387077,ADVI +181,PK,0.9245335328489942,ADVI +182,PGM,-0.14162528515781725,ADVI +182,ENO,0.19917235642058406,ADVI +182,PK,0.9424529287372332,ADVI +183,PGM,-0.09050210708641626,ADVI +183,ENO,0.2016996602602139,ADVI +183,PK,0.8888024468262025,ADVI +184,PGM,-0.05330243637262444,ADVI +184,ENO,0.16112800490750973,ADVI +184,PK,0.8921744314651149,ADVI +185,PGM,-0.0937878358358688,ADVI +185,ENO,0.18060219375434172,ADVI +185,PK,0.9131856420815272,ADVI +186,PGM,-0.11920253046001217,ADVI +186,ENO,0.18518454954839322,ADVI +186,PK,0.9340179809116189,ADVI +187,PGM,-0.14173450578514135,ADVI +187,ENO,0.1772786040537812,ADVI +187,PK,0.9644559017313602,ADVI +188,PGM,-0.06528792477982437,ADVI +188,ENO,0.20625750158300618,ADVI +188,PK,0.8590304231968182,ADVI +189,PGM,-0.10429799243510196,ADVI +189,ENO,0.16162983268719788,ADVI +189,PK,0.9426681597479042,ADVI +190,PGM,-0.059936458518565994,ADVI +190,ENO,0.171771778931868,ADVI +190,PK,0.888164679586698,ADVI +191,PGM,-0.09092280443061207,ADVI +191,ENO,0.16916866264622168,ADVI +191,PK,0.9217541417843904,ADVI +192,PGM,-0.049834840519796364,ADVI +192,ENO,0.1723309702043084,ADVI +192,PK,0.8775038703154878,ADVI +193,PGM,-0.11927159355085859,ADVI +193,ENO,0.16402077566029516,ADVI +193,PK,0.9552508178905634,ADVI +194,PGM,-0.10557551881788174,ADVI +194,ENO,0.16061479438604173,ADVI +194,PK,0.94496072443184,ADVI +195,PGM,-0.04550802788055086,ADVI +195,ENO,0.1785993208535443,ADVI +195,PK,0.8669087070270066,ADVI +196,PGM,-0.05404513613894868,ADVI +196,ENO,0.15650791584621343,ADVI +196,PK,0.8975372202927352,ADVI +197,PGM,-0.09099168077391995,ADVI +197,ENO,0.18484524230541702,ADVI +197,PK,0.9061464384685028,ADVI +198,PGM,-0.10025104938134444,ADVI +198,ENO,0.17466213191167765,ADVI +198,PK,0.9255889174696669,ADVI +199,PGM,-0.05631176280876593,ADVI +199,ENO,0.19166347773136025,ADVI +199,PK,0.8646482850774057,ADVI +200,PGM,-0.09723692588394783,ADVI +200,ENO,0.17253407277394492,ADVI +200,PK,0.924702853110003,ADVI +201,PGM,-0.07364213031802236,ADVI +201,ENO,0.17323359289413662,ADVI +201,PK,0.9004085374238856,ADVI +202,PGM,-0.06227803298378176,ADVI +202,ENO,0.18705747098124703,ADVI +202,PK,0.8752205620025347,ADVI +203,PGM,-0.08912118616090914,ADVI +203,ENO,0.18162589681618277,ADVI +203,PK,0.9074952893447265,ADVI +204,PGM,-0.07166958967639281,ADVI +204,ENO,0.18275935705379487,ADVI +204,PK,0.888910232622598,ADVI +205,PGM,-0.051837371267134724,ADVI +205,ENO,0.18054633446423898,ADVI +205,PK,0.8712910368028957,ADVI +206,PGM,-0.08030025909745109,ADVI +206,ENO,0.18572603312479952,ADVI +206,PK,0.8945742259726516,ADVI +207,PGM,-0.05524603120961502,ADVI +207,ENO,0.1721720924805318,ADVI +207,PK,0.8830739387290831,ADVI +208,PGM,-0.08944239174644975,ADVI +208,ENO,0.1861371098940032,ADVI +208,PK,0.9033052818524466,ADVI +209,PGM,-0.07554809475442226,ADVI +209,ENO,0.18775035894302233,ADVI +209,PK,0.8877977358113999,ADVI +210,PGM,-0.16494099526729333,ADVI +210,ENO,0.1788011192433941,ADVI +210,PK,0.9861398760238992,ADVI +211,PGM,-0.13816893980785938,ADVI +211,ENO,0.1599220900898281,ADVI +211,PK,0.9782468497180313,ADVI +212,PGM,-0.057421851621314524,ADVI +212,ENO,0.17980649074428587,ADVI +212,PK,0.8776153608770287,ADVI +213,PGM,-0.11807974297004398,ADVI +213,ENO,0.17800260035710141,ADVI +213,PK,0.9400771426129425,ADVI +214,PGM,-0.07596369826657745,ADVI +214,ENO,0.17777354352117852,ADVI +214,PK,0.898190154745399,ADVI +215,PGM,-0.1136375707708237,ADVI +215,ENO,0.18324446901836774,ADVI +215,PK,0.930393101752456,ADVI +216,PGM,-0.11539049955443548,ADVI +216,ENO,0.17320938900978444,ADVI +216,PK,0.9421811105446509,ADVI +217,PGM,-0.05602859645005043,ADVI +217,ENO,0.2071606904843485,ADVI +217,PK,0.8488679059657019,ADVI +218,PGM,-0.08965579615384356,ADVI +218,ENO,0.19678879395304494,ADVI +218,PK,0.8928670022007987,ADVI +219,PGM,-0.12506877873784616,ADVI +219,ENO,0.17831511982161488,ADVI +219,PK,0.9467536589162314,ADVI +220,PGM,-0.07410331095805289,ADVI +220,ENO,0.1910114376251466,ADVI +220,PK,0.8830918733329063,ADVI +221,PGM,-0.10818581237266867,ADVI +221,ENO,0.1733462766561783,ADVI +221,PK,0.9348395357164904,ADVI +222,PGM,-0.07456478209383843,ADVI +222,ENO,0.19064550455706766,ADVI +222,PK,0.8839192775367709,ADVI +223,PGM,-0.05010573604969526,ADVI +223,ENO,0.15874868208581247,ADVI +223,PK,0.8913570539638827,ADVI +224,PGM,-0.04558835663761762,ADVI +224,ENO,0.18432671515360616,ADVI +224,PK,0.8612616414840114,ADVI +225,PGM,-0.05634380216716406,ADVI +225,ENO,0.1724949888850911,ADVI +225,PK,0.8838488132820729,ADVI +226,PGM,-0.0784176426513894,ADVI +226,ENO,0.19154648638725216,ADVI +226,PK,0.8868711562641373,ADVI +227,PGM,-0.13999076880365213,ADVI +227,ENO,0.16461503743119826,ADVI +227,PK,0.9753757313724539,ADVI +228,PGM,-0.08555176130459197,ADVI +228,ENO,0.16022114909986201,ADVI +228,PK,0.9253306122047299,ADVI +229,PGM,-0.08081720697875805,ADVI +229,ENO,0.15293583702721755,ADVI +229,PK,0.9278813699515406,ADVI +230,PGM,-0.09757685802045235,ADVI +230,ENO,0.19412272641709152,ADVI +230,PK,0.9034541316033609,ADVI +231,PGM,-0.09070529931224858,ADVI +231,ENO,0.177318258196966,ADVI +231,PK,0.9133870411152826,ADVI +232,PGM,-0.08508286749652139,ADVI +232,ENO,0.14612336301141637,ADVI +232,PK,0.9389595044851052,ADVI +233,PGM,-0.06315102990096033,ADVI +233,ENO,0.16456572582287637,ADVI +233,PK,0.8985853040780838,ADVI +234,PGM,-0.10554342713682563,ADVI +234,ENO,0.18958954488077778,ADVI +234,PK,0.9159538822560478,ADVI +235,PGM,-0.14570926453756528,ADVI +235,ENO,0.15118962475883502,ADVI +235,PK,0.9945196397787301,ADVI +236,PGM,-0.07598467560263411,ADVI +236,ENO,0.1755977897218217,ADVI +236,PK,0.9003868858808124,ADVI +237,PGM,-0.09101030344588956,ADVI +237,ENO,0.17544861165734152,ADVI +237,PK,0.9155616917885481,ADVI +238,PGM,-0.04112380108625313,ADVI +238,ENO,0.17274593539629576,ADVI +238,PK,0.8683778656899573,ADVI +239,PGM,-0.10227192603897906,ADVI +239,ENO,0.178862179124767,ADVI +239,PK,0.9234097469142121,ADVI +240,PGM,-0.09131984376280822,ADVI +240,ENO,0.1957221985423627,ADVI +240,PK,0.8955976452204455,ADVI +241,PGM,-0.07241984977261229,ADVI +241,ENO,0.1701585188062574,ADVI +241,PK,0.902261330966355,ADVI +242,PGM,-0.051147286956694904,ADVI +242,ENO,0.1778434267129788,ADVI +242,PK,0.8733038602437161,ADVI +243,PGM,-0.1401128155813336,ADVI +243,ENO,0.18116032155836848,ADVI +243,PK,0.958952494022965,ADVI +244,PGM,-0.0878894763826894,ADVI +244,ENO,0.14651519769880347,ADVI +244,PK,0.9413742786838858,ADVI +245,PGM,-0.07803228267524065,ADVI +245,ENO,0.1787389181443177,ADVI +245,PK,0.899293364530923,ADVI +246,PGM,-0.0988408221157715,ADVI +246,ENO,0.18559856962842688,ADVI +246,PK,0.9132422524873447,ADVI +247,PGM,-0.12417297559860008,ADVI +247,ENO,0.15929273429086988,ADVI +247,PK,0.9648802413077303,ADVI +248,PGM,-0.06853856461509111,ADVI +248,ENO,0.15492712446542858,ADVI +248,PK,0.9136114401496626,ADVI +249,PGM,-0.07818357345317661,ADVI +249,ENO,0.18145209018839328,ADVI +249,PK,0.8967314832647834,ADVI +250,PGM,-0.16280809264318719,ADVI +250,ENO,0.1949218174756724,ADVI +250,PK,0.9678862751675148,ADVI +251,PGM,-0.037643762838586614,ADVI +251,ENO,0.1576730914613837,ADVI +251,PK,0.8799706713772029,ADVI +252,PGM,-0.11698304178779773,ADVI +252,ENO,0.16505133075651587,ADVI +252,PK,0.9519317110312818,ADVI +253,PGM,-0.04968455492049295,ADVI +253,ENO,0.17663942379432387,ADVI +253,PK,0.873045131126169,ADVI +254,PGM,-0.17009358055674473,ADVI +254,ENO,0.17943395373350668,ADVI +254,PK,0.990659626823238,ADVI +255,PGM,-0.07494652197422313,ADVI +255,ENO,0.18912183405173127,ADVI +255,PK,0.8858246879224918,ADVI +256,PGM,-0.0690623224835889,ADVI +256,ENO,0.1809880111711881,ADVI +256,PK,0.8880743113124008,ADVI +257,PGM,-0.07011958901169613,ADVI +257,ENO,0.16957932989054875,ADVI +257,PK,0.9005402591211473,ADVI +258,PGM,-0.0766844813222689,ADVI +258,ENO,0.17734282508512048,ADVI +258,PK,0.8993416562371485,ADVI +259,PGM,-0.09994948004197979,ADVI +259,ENO,0.1782583932381361,ADVI +259,PK,0.9216910868038437,ADVI +260,PGM,-0.06520371392862123,ADVI +260,ENO,0.15803918023604321,ADVI +260,PK,0.9071645336925781,ADVI +261,PGM,-0.08946150545162301,ADVI +261,ENO,0.17964524412702057,ADVI +261,PK,0.9098162613246025,ADVI +262,PGM,-0.0932634143442661,ADVI +262,ENO,0.18185634753218913,ADVI +262,PK,0.9114070668120768,ADVI +263,PGM,-0.11885503179144807,ADVI +263,ENO,0.17539327490568105,ADVI +263,PK,0.9434617568857671,ADVI +264,PGM,-0.05148731476200741,ADVI +264,ENO,0.19460706499759817,ADVI +264,PK,0.8568802497644094,ADVI +265,PGM,-0.05895796745941495,ADVI +265,ENO,0.15365043440915396,ADVI +265,PK,0.9053075330502609,ADVI +266,PGM,-0.08157585283135615,ADVI +266,ENO,0.17629507832019523,ADVI +266,PK,0.905280774511161,ADVI +267,PGM,-0.07680071470942074,ADVI +267,ENO,0.17900663922948287,ADVI +267,PK,0.8977940754799377,ADVI +268,PGM,-0.1278070810369516,ADVI +268,ENO,0.16102777418305217,ADVI +268,PK,0.9667793068538995,ADVI +269,PGM,-0.08062571166680832,ADVI +269,ENO,0.16763322796418667,ADVI +269,PK,0.9129924837026214,ADVI +270,PGM,-0.08223699247581129,ADVI +270,ENO,0.16811672306678954,ADVI +270,PK,0.9141202694090218,ADVI +271,PGM,-0.10679198189568395,ADVI +271,ENO,0.1874953166303282,ADVI +271,PK,0.9192966652653557,ADVI +272,PGM,-0.10232052854136309,ADVI +272,ENO,0.17777948609977068,ADVI +272,PK,0.9245410424415923,ADVI +273,PGM,-0.0821853775967587,ADVI +273,ENO,0.16759096094441428,ADVI +273,PK,0.9145944166523443,ADVI +274,PGM,-0.07588871700909294,ADVI +274,ENO,0.17600643961086818,ADVI +274,PK,0.8998822773982246,ADVI +275,PGM,-0.04929868923568681,ADVI +275,ENO,0.1779326329731559,ADVI +275,PK,0.871366056262531,ADVI +276,PGM,-0.070974407771494,ADVI +276,ENO,0.19205185391964696,ADVI +276,PK,0.878922553851847,ADVI +277,PGM,-0.07469317745058968,ADVI +277,ENO,0.156598649974295,ADVI +277,PK,0.9180945274762946,ADVI +278,PGM,-0.07989637201554389,ADVI +278,ENO,0.16789411795282194,ADVI +278,PK,0.912002254062722,ADVI +279,PGM,-0.07783217270022891,ADVI +279,ENO,0.17479223779279734,ADVI +279,PK,0.9030399349074315,ADVI +280,PGM,-0.11869780255393847,ADVI +280,ENO,0.21274829022975872,ADVI +280,PK,0.9059495123241795,ADVI +281,PGM,-0.07578089968527713,ADVI +281,ENO,0.16604922630983626,ADVI +281,PK,0.9097316733754409,ADVI +282,PGM,-0.09153390288417707,ADVI +282,ENO,0.19439678780348238,ADVI +282,PK,0.8971371150806947,ADVI +283,PGM,-0.08945313970194202,ADVI +283,ENO,0.18568967484137291,ADVI +283,PK,0.9037634648605692,ADVI +284,PGM,-0.052237487689719364,ADVI +284,ENO,0.15595181697340052,ADVI +284,PK,0.8962856707163189,ADVI +285,PGM,-0.15968841722043003,ADVI +285,ENO,0.18732199096345745,ADVI +285,PK,0.9723664262569726,ADVI +286,PGM,-0.12141905010410725,ADVI +286,ENO,0.17513932584735187,ADVI +286,PK,0.9462797242567554,ADVI +287,PGM,-0.16787879912608905,ADVI +287,ENO,0.1508328950295885,ADVI +287,PK,1.0170459040965005,ADVI +288,PGM,-0.11757666872295713,ADVI +288,ENO,0.20806678895938363,ADVI +288,PK,0.9095098797635734,ADVI +289,PGM,-0.06988568596426137,ADVI +289,ENO,0.15707415546941447,ADVI +289,PK,0.912811530494847,ADVI +290,PGM,-0.10547944709286039,ADVI +290,ENO,0.1528055125014287,ADVI +290,PK,0.9526739345914318,ADVI +291,PGM,-0.06293547488636242,ADVI +291,ENO,0.20332027591835528,ADVI +291,PK,0.8596151989680072,ADVI +292,PGM,-0.05055096827365735,ADVI +292,ENO,0.1734816816163976,ADVI +292,PK,0.8770692866572598,ADVI +293,PGM,-0.06372491520803303,ADVI +293,ENO,0.1675311683442999,ADVI +293,PK,0.8961937468637331,ADVI +294,PGM,-0.06575784982752775,ADVI +294,ENO,0.16405821135901383,ADVI +294,PK,0.9016996384685139,ADVI +295,PGM,-0.16670221051521183,ADVI +295,ENO,0.18131487915944788,ADVI +295,PK,0.985387331355764,ADVI +296,PGM,-0.04750468923240381,ADVI +296,ENO,0.18290387755423584,ADVI +296,PK,0.8646008116781678,ADVI +297,PGM,-0.10713220389061728,ADVI +297,ENO,0.18003502779956929,ADVI +297,PK,0.9270971760910479,ADVI +298,PGM,-0.13315865113170555,ADVI +298,ENO,0.15888208407809415,ADVI +298,PK,0.9742765670536114,ADVI +299,PGM,-0.08430957951577533,ADVI +299,ENO,0.1737595617977821,ADVI +299,PK,0.9105500177179933,ADVI +300,PGM,-0.0946220109010496,ADVI +300,ENO,0.1967957909403913,ADVI +300,PK,0.8978262199606584,ADVI +301,PGM,-0.07110272432297227,ADVI +301,ENO,0.1646571545667958,ADVI +301,PK,0.9064455697561763,ADVI +302,PGM,-0.07799891462770292,ADVI +302,ENO,0.17808877680600943,ADVI +302,PK,0.8999101378216934,ADVI +303,PGM,-0.05739070742729968,ADVI +303,ENO,0.1988003855239037,ADVI +303,PK,0.8585903219033959,ADVI +304,PGM,-0.058122821397122104,ADVI +304,ENO,0.19390029484718324,ADVI +304,PK,0.8642225265499389,ADVI +305,PGM,-0.1296672744188252,ADVI +305,ENO,0.1752282858114341,ADVI +305,PK,0.9544389886073912,ADVI +306,PGM,-0.06405268796602726,ADVI +306,ENO,0.18584561925783222,ADVI +306,PK,0.8782070687081949,ADVI +307,PGM,-0.09118181374580425,ADVI +307,ENO,0.17581439814241512,ADVI +307,PK,0.9153674156033892,ADVI +308,PGM,-0.10400210610056582,ADVI +308,ENO,0.1800596745157472,ADVI +308,PK,0.9239424315848187,ADVI +309,PGM,-0.12256198904177729,ADVI +309,ENO,0.17165082113568508,ADVI +309,PK,0.9509111679060921,ADVI +310,PGM,-0.09863696513018128,ADVI +310,ENO,0.17713423804595566,ADVI +310,PK,0.9215027270842255,ADVI +311,PGM,-0.032926165667406915,ADVI +311,ENO,0.17005568596590653,ADVI +311,PK,0.8628704797015005,ADVI +312,PGM,-0.08672205602794025,ADVI +312,ENO,0.16778631870661795,ADVI +312,PK,0.9189357373213224,ADVI +313,PGM,-0.11096658193340359,ADVI +313,ENO,0.1724398139692786,ADVI +313,PK,0.9385267679641249,ADVI +314,PGM,-0.042227941699600535,ADVI +314,ENO,0.1843658673168437,ADVI +314,PK,0.8578620743827569,ADVI +315,PGM,-0.07047887291500454,ADVI +315,ENO,0.15528338121302313,ADVI +315,PK,0.9151954917019816,ADVI +316,PGM,-0.08587813326520966,ADVI +316,ENO,0.1727383256236025,ADVI +316,PK,0.9131398076416072,ADVI +317,PGM,-0.13344975475730747,ADVI +317,ENO,0.1797786729625246,ADVI +317,PK,0.9536710817947829,ADVI +318,PGM,-0.13036038328258504,ADVI +318,ENO,0.1853041371224347,ADVI +318,PK,0.9450562461601503,ADVI +319,PGM,-0.10542177507223349,ADVI +319,ENO,0.2128000915113477,ADVI +319,PK,0.8926216835608858,ADVI +320,PGM,-0.05998730642106831,ADVI +320,ENO,0.17761970571769578,ADVI +320,PK,0.8823676007033724,ADVI +321,PGM,-0.0822611341713042,ADVI +321,ENO,0.17643130340082402,ADVI +321,PK,0.9058298307704801,ADVI +322,PGM,-0.07684600078734882,ADVI +322,ENO,0.15834720510092237,ADVI +322,PK,0.9184987956864265,ADVI +323,PGM,-0.09334582515377354,ADVI +323,ENO,0.14266359616425953,ADVI +323,PK,0.9506822289895142,ADVI +324,PGM,-0.07027915135117047,ADVI +324,ENO,0.17916412421829694,ADVI +324,PK,0.8911150271328736,ADVI +325,PGM,-0.05638513633364495,ADVI +325,ENO,0.17142960961464088,ADVI +325,PK,0.884955526719004,ADVI +326,PGM,-0.16254866140585222,ADVI +326,ENO,0.21636347944162082,ADVI +326,PK,0.9461851819642313,ADVI +327,PGM,-0.03729615170157374,ADVI +327,ENO,0.1695848722429539,ADVI +327,PK,0.8677112794586199,ADVI +328,PGM,-0.07700608951324694,ADVI +328,ENO,0.17760207814728318,ADVI +328,PK,0.8994040113659637,ADVI +329,PGM,-0.103128672489041,ADVI +329,ENO,0.15385325661937466,ADVI +329,PK,0.9492754158696661,ADVI +330,PGM,-0.11258711510117747,ADVI +330,ENO,0.1772315992049601,ADVI +330,PK,0.9353555158962173,ADVI +331,PGM,-0.11582356757839785,ADVI +331,ENO,0.17640612417072124,ADVI +331,PK,0.9394174434076765,ADVI +332,PGM,-0.07760150919034436,ADVI +332,ENO,0.18218849676775786,ADVI +332,PK,0.8954130124225864,ADVI +333,PGM,-0.09651726933669735,ADVI +333,ENO,0.16799079442668632,ADVI +333,PK,0.9285264749100111,ADVI +334,PGM,-0.1033183996008733,ADVI +334,ENO,0.1701386821572028,ADVI +334,PK,0.9331797174436705,ADVI +335,PGM,-0.09136353427627641,ADVI +335,ENO,0.18627131921343346,ADVI +335,PK,0.9050922150628429,ADVI +336,PGM,-0.10996477213596534,ADVI +336,ENO,0.1656547494761297,ADVI +336,PK,0.9443100226598355,ADVI +337,PGM,-0.08419734900255849,ADVI +337,ENO,0.17439068345656214,ADVI +337,PK,0.9098066655459963,ADVI +338,PGM,-0.053863171904318774,ADVI +338,ENO,0.18219741415686738,ADVI +338,PK,0.8716657577474513,ADVI +339,PGM,-0.022455337504887707,ADVI +339,ENO,0.17654705554874045,ADVI +339,PK,0.8459082819561473,ADVI +340,PGM,-0.1164126447544711,ADVI +340,ENO,0.18440778775880018,ADVI +340,PK,0.9320048569956709,ADVI +341,PGM,-0.12283610783381316,ADVI +341,ENO,0.1607840625101787,ADVI +341,PK,0.9620520453236344,ADVI +342,PGM,-0.09146553724249529,ADVI +342,ENO,0.1828086106514492,ADVI +342,PK,0.9086569265910461,ADVI +343,PGM,-0.06431748510947632,ADVI +343,ENO,0.17204840408115507,ADVI +343,PK,0.8922690810283213,ADVI +344,PGM,-0.08662282591681336,ADVI +344,ENO,0.1650346759007885,ADVI +344,PK,0.9215881500160247,ADVI +345,PGM,-0.10511470256062427,ADVI +345,ENO,0.1845807430419249,ADVI +345,PK,0.9205339595186995,ADVI +346,PGM,-0.0604970377918197,ADVI +346,ENO,0.1614251304175044,ADVI +346,PK,0.8990719073743153,ADVI +347,PGM,-0.10599018591716192,ADVI +347,ENO,0.1836055484498803,ADVI +347,PK,0.9223846374672816,ADVI +348,PGM,-0.017403758927537094,ADVI +348,ENO,0.18351306042654647,ADVI +348,PK,0.8338906985009905,ADVI +349,PGM,-0.06093339322155744,ADVI +349,ENO,0.17256705333713285,ADVI +349,PK,0.8883663398844245,ADVI +350,PGM,-0.1128832445697352,ADVI +350,ENO,0.16377237222687416,ADVI +350,PK,0.9491108723428611,ADVI +351,PGM,-0.08557398713240061,ADVI +351,ENO,0.19220704542399883,ADVI +351,PK,0.8933669417084018,ADVI +352,PGM,-0.10186035090714607,ADVI +352,ENO,0.1873260803975292,ADVI +352,PK,0.9145342705096167,ADVI +353,PGM,-0.14722215729773325,ADVI +353,ENO,0.16122427246091342,ADVI +353,PK,0.9859978848368199,ADVI +354,PGM,-0.10006988733255273,ADVI +354,ENO,0.2010752538330344,ADVI +354,PK,0.8989946334995184,ADVI +355,PGM,-0.08017039563500616,ADVI +355,ENO,0.16696589923417415,ADVI +355,PK,0.9132044964008319,ADVI +356,PGM,-0.09070400070697149,ADVI +356,ENO,0.1918223381118929,ADVI +356,PK,0.8988816625950786,ADVI +357,PGM,-0.10562536022746416,ADVI +357,ENO,0.1914628643117064,ADVI +357,PK,0.9141624959157578,ADVI +358,PGM,-0.07550327874539131,ADVI +358,ENO,0.1573416578388961,ADVI +358,PK,0.9181616209064953,ADVI +359,PGM,-0.07467864557317361,ADVI +359,ENO,0.1694439353973467,ADVI +359,PK,0.9052347101758269,ADVI +360,PGM,-0.10277834389791063,ADVI +360,ENO,0.1729471771609218,ADVI +360,PK,0.929831166736989,ADVI +361,PGM,-0.033312087851048,ADVI +361,ENO,0.1525075542875486,ADVI +361,PK,0.8808045335634993,ADVI +362,PGM,-0.07731956734169199,ADVI +362,ENO,0.19050194717037897,ADVI +362,PK,0.8868176201713129,ADVI +363,PGM,-0.06688189777687503,ADVI +363,ENO,0.17785989711035827,ADVI +363,PK,0.8890220006665167,ADVI +364,PGM,-0.12668198665241404,ADVI +364,ENO,0.14618925050512535,ADVI +364,PK,0.9804927361472886,ADVI +365,PGM,-0.08042286616103889,ADVI +365,ENO,0.17956393583669442,ADVI +365,PK,0.9008589303243445,ADVI +366,PGM,-0.10227413278716235,ADVI +366,ENO,0.18686448715318235,ADVI +366,PK,0.91540964563398,ADVI +367,PGM,-0.06807061309034834,ADVI +367,ENO,0.16927325241462415,ADVI +367,PK,0.8987973606757242,ADVI +368,PGM,-0.03293248208912747,ADVI +368,ENO,0.20157568531409803,ADVI +368,PK,0.8313567967750295,ADVI +369,PGM,-0.0718427989928958,ADVI +369,ENO,0.16091445936605178,ADVI +369,PK,0.9109283396268439,ADVI +370,PGM,-0.09781152802401616,ADVI +370,ENO,0.1860278234797701,ADVI +370,PK,0.9117837045442461,ADVI +371,PGM,-0.11310004702715992,ADVI +371,ENO,0.1672380132513446,ADVI +371,PK,0.9458620337758153,ADVI +372,PGM,-0.04585203522711967,ADVI +372,ENO,0.17700625787941568,ADVI +372,PK,0.8688457773477042,ADVI +373,PGM,-0.12404334210308177,ADVI +373,ENO,0.1803207997987656,ADVI +373,PK,0.9437225423043162,ADVI +374,PGM,-0.13672401383243615,ADVI +374,ENO,0.1780187667451259,ADVI +374,PK,0.9587052470873102,ADVI +375,PGM,-0.06202268212019413,ADVI +375,ENO,0.1713098512869819,ADVI +375,PK,0.8907128308332122,ADVI +376,PGM,-0.0953871135550397,ADVI +376,ENO,0.17785169481850108,ADVI +376,PK,0.9175354187365388,ADVI +377,PGM,-0.07506491097963397,ADVI +377,ENO,0.16856301221270056,ADVI +377,PK,0.9065018987669335,ADVI +378,PGM,-0.08578922694981528,ADVI +378,ENO,0.16683334257646823,ADVI +378,PK,0.9189558843733471,ADVI +379,PGM,-0.1227149569369741,ADVI +379,ENO,0.18002344551789562,ADVI +379,PK,0.9426915114190786,ADVI +380,PGM,-0.13740804559570918,ADVI +380,ENO,0.16742503313547033,ADVI +380,PK,0.969983012460239,ADVI +381,PGM,-0.05919348241667555,ADVI +381,ENO,0.17855041474022082,ADVI +381,PK,0.8806430676764548,ADVI +382,PGM,-0.061033747739658306,ADVI +382,ENO,0.2009531009902603,ADVI +382,PK,0.8600806467493981,ADVI +383,PGM,-0.11922545108095406,ADVI +383,ENO,0.20015691314223663,ADVI +383,PK,0.9190685379387173,ADVI +384,PGM,-0.04477309561069043,ADVI +384,ENO,0.18391503330053277,ADVI +384,PK,0.8608580623101577,ADVI +385,PGM,-0.09075715473849533,ADVI +385,ENO,0.15508068996162386,ADVI +385,PK,0.9356764647768714,ADVI +386,PGM,-0.09229758407925659,ADVI +386,ENO,0.18358067054938573,ADVI +386,PK,0.9087169135298709,ADVI +387,PGM,-0.07153887331601072,ADVI +387,ENO,0.17232542948716376,ADVI +387,PK,0.8992134438288468,ADVI +388,PGM,-0.028399924366233176,ADVI +388,ENO,0.1725938665940989,ADVI +388,PK,0.8558060577721343,ADVI +389,PGM,-0.07502242946415083,ADVI +389,ENO,0.1710055396594922,ADVI +389,PK,0.9040168898046586,ADVI +390,PGM,-0.09034839030021513,ADVI +390,ENO,0.16724176197631882,ADVI +390,PK,0.9231066283238964,ADVI +391,PGM,-0.01355804929317106,ADVI +391,ENO,0.15413086243783095,ADVI +391,PK,0.85942718685534,ADVI +392,PGM,-0.07686768359618168,ADVI +392,ENO,0.17662863440504248,ADVI +392,PK,0.9002390491911392,ADVI +393,PGM,-0.07925007471965251,ADVI +393,ENO,0.19950927789073652,ADVI +393,PK,0.8797407968289161,ADVI +394,PGM,-0.11883370645423974,ADVI +394,ENO,0.19239723888610383,ADVI +394,PK,0.9264364675681358,ADVI +395,PGM,-0.08158066863572033,ADVI +395,ENO,0.18758276363028611,ADVI +395,PK,0.8939979050054343,ADVI +396,PGM,-0.11947149052619244,ADVI +396,ENO,0.17604049621005388,ADVI +396,PK,0.9434309943161384,ADVI +397,PGM,-0.04984872396249118,ADVI +397,ENO,0.1702805168196138,ADVI +397,PK,0.8795682071428774,ADVI +398,PGM,-0.0754531010591255,ADVI +398,ENO,0.17760957216486578,ADVI +398,PK,0.8978435288942597,ADVI +399,PGM,-0.03292346314989336,ADVI +399,ENO,0.17927932942751582,ADVI +399,PK,0.8536441337223776,ADVI +400,PGM,-0.09021265296282555,ADVI +400,ENO,0.20159991754156928,ADVI +400,PK,0.8886127354212562,ADVI +401,PGM,-0.13210465640877,ADVI +401,ENO,0.16336790501608647,ADVI +401,PK,0.9687367513926837,ADVI +402,PGM,-0.18855114753645497,ADVI +402,ENO,0.19762274309379874,ADVI +402,PK,0.9909284044426562,ADVI +403,PGM,-0.07478084653513029,ADVI +403,ENO,0.18710667515016216,ADVI +403,PK,0.8876741713849681,ADVI +404,PGM,-0.09321690493520873,ADVI +404,ENO,0.18934918718040503,ADVI +404,PK,0.9038677177548038,ADVI +405,PGM,-0.0921945542662812,ADVI +405,ENO,0.17234335498127554,ADVI +405,PK,0.9198511992850056,ADVI +406,PGM,-0.060212119190917957,ADVI +406,ENO,0.16976254752400863,ADVI +406,PK,0.8904495716669094,ADVI +407,PGM,-0.03956325550171158,ADVI +407,ENO,0.19085600801498556,ADVI +407,PK,0.848707247486726,ADVI +408,PGM,-0.06278886175576459,ADVI +408,ENO,0.17135024760497708,ADVI +408,PK,0.8914386141507875,ADVI +409,PGM,-0.06568691944531402,ADVI +409,ENO,0.19306171056432714,ADVI +409,PK,0.8726252088809868,ADVI +410,PGM,-0.053596230447109594,ADVI +410,ENO,0.16970104678579667,ADVI +410,PK,0.8838951836613128,ADVI +411,PGM,-0.08534976906710123,ADVI +411,ENO,0.18436460207310817,ADVI +411,PK,0.9009851669939931,ADVI +412,PGM,-0.05926964947412139,ADVI +412,ENO,0.16366107320668224,ADVI +412,PK,0.8956085762674393,ADVI +413,PGM,-0.17667218364831783,ADVI +413,ENO,0.19100628617547408,ADVI +413,PK,0.9856658974728436,ADVI +414,PGM,-0.05159320980757509,ADVI +414,ENO,0.18719692339768879,ADVI +414,PK,0.8643962864098863,ADVI +415,PGM,-0.0414758878764927,ADVI +415,ENO,0.17028249489497949,ADVI +415,PK,0.8711933929815133,ADVI +416,PGM,-0.08124760501861439,ADVI +416,ENO,0.16939640229970115,ADVI +416,PK,0.9118512027189133,ADVI +417,PGM,-0.11812422835863501,ADVI +417,ENO,0.19289856316421802,ADVI +417,PK,0.925225665194417,ADVI +418,PGM,-0.01144542529069148,ADVI +418,ENO,0.17226240124974723,ADVI +418,PK,0.8391830240409444,ADVI +419,PGM,-0.18495470444922146,ADVI +419,ENO,0.17994116759737838,ADVI +419,PK,1.005013536851843,ADVI +420,PGM,-0.11051733230797178,ADVI +420,ENO,0.16358994022063472,ADVI +420,PK,0.946927392087337,ADVI +421,PGM,-0.03549362452618188,ADVI +421,ENO,0.16286466760603485,ADVI +421,PK,0.872628956920147,ADVI +422,PGM,-0.07097925356189583,ADVI +422,ENO,0.1844889223111141,ADVI +422,PK,0.8864903312507817,ADVI +423,PGM,-0.09977499942107126,ADVI +423,ENO,0.17207695045922775,ADVI +423,PK,0.9276980489618436,ADVI +424,PGM,-0.07064690065555723,ADVI +424,ENO,0.17624073859596048,ADVI +424,PK,0.8944061620595967,ADVI +425,PGM,-0.11582262688072076,ADVI +425,ENO,0.17691766446670912,ADVI +425,PK,0.9389049624140117,ADVI +426,PGM,-0.0597713448113244,ADVI +426,ENO,0.17243117700915464,ADVI +426,PK,0.8873401678021698,ADVI +427,PGM,-0.08401376855578868,ADVI +427,ENO,0.1908117651717639,ADVI +427,PK,0.8932020033840247,ADVI +428,PGM,-0.053007646975334666,ADVI +428,ENO,0.17605800977342542,ADVI +428,PK,0.8769496372019092,ADVI +429,PGM,-0.014273502251863635,ADVI +429,ENO,0.15075446176870938,ADVI +429,PK,0.8635190404831543,ADVI +430,PGM,-0.07848861912702931,ADVI +430,ENO,0.16176835492132166,ADVI +430,PK,0.9167202642057076,ADVI +431,PGM,-0.06935287855173788,ADVI +431,ENO,0.1960080363925023,ADVI +431,PK,0.8733448421592355,ADVI +432,PGM,-0.057865399406634266,ADVI +432,ENO,0.1631458610360532,ADVI +432,PK,0.894719538370581,ADVI +433,PGM,-0.11038617898818703,ADVI +433,ENO,0.16861143770001946,ADVI +433,PK,0.9417747412881675,ADVI +434,PGM,-0.09082444172782678,ADVI +434,ENO,0.164098064064232,ADVI +434,PK,0.9267263776635947,ADVI +435,PGM,-0.20485097550144316,ADVI +435,ENO,0.2016370189563891,ADVI +435,PK,1.003213956545054,ADVI +436,PGM,-0.033430213212939375,ADVI +436,ENO,0.19974846783466077,ADVI +436,PK,0.8336817453782785,ADVI +437,PGM,0.0016739912660592715,ADVI +437,ENO,0.18932136560221266,ADVI +437,PK,0.809004643131728,ADVI +438,PGM,-0.08176776055747426,ADVI +438,ENO,0.17014569849804168,ADVI +438,PK,0.9116220620594325,ADVI +439,PGM,-0.10977578701098079,ADVI +439,ENO,0.17748853462626848,ADVI +439,PK,0.9322872523847124,ADVI +440,PGM,-0.18138463690491857,ADVI +440,ENO,0.19211749064810693,ADVI +440,PK,0.9892671462568117,ADVI +441,PGM,-0.07156769738486113,ADVI +441,ENO,0.1689200057796537,ADVI +441,PK,0.9026476916052075,ADVI +442,PGM,-0.13161239700098193,ADVI +442,ENO,0.18298987506547618,ADVI +442,PK,0.9486225219355057,ADVI +443,PGM,-0.013404521168307149,ADVI +443,ENO,0.1658064123737996,ADVI +443,PK,0.8475981087945076,ADVI +444,PGM,-0.06438351036692214,ADVI +444,ENO,0.16368029420185268,ADVI +444,PK,0.9007032161650693,ADVI +445,PGM,-0.07863796024959946,ADVI +445,ENO,0.181793872853153,ADVI +445,PK,0.8968440873964465,ADVI +446,PGM,-0.04750076141448467,ADVI +446,ENO,0.15158806342700487,ADVI +446,PK,0.8959126979874799,ADVI +447,PGM,-0.09852653898939212,ADVI +447,ENO,0.18224303499030411,ADVI +447,PK,0.916283503999088,ADVI +448,PGM,-0.10295598053057065,ADVI +448,ENO,0.17362804751551789,ADVI +448,PK,0.9293279330150528,ADVI +449,PGM,-0.06921629913492588,ADVI +449,ENO,0.16273942869348712,ADVI +449,PK,0.9064768704414388,ADVI +450,PGM,-0.019793872983252303,ADVI +450,ENO,0.1690681680730335,ADVI +450,PK,0.8507257049102189,ADVI +451,PGM,-0.11513549677129631,ADVI +451,ENO,0.16329756175749996,ADVI +451,PK,0.9518379350137963,ADVI +452,PGM,-0.12545582487514584,ADVI +452,ENO,0.18665024841806513,ADVI +452,PK,0.9388055764570806,ADVI +453,PGM,-0.09270559505329756,ADVI +453,ENO,0.19586144732441915,ADVI +453,PK,0.8968441477288783,ADVI +454,PGM,-0.09463025369725675,ADVI +454,ENO,0.17906536596886027,ADVI +454,PK,0.9155648877283964,ADVI +455,PGM,-0.09346992778667462,ADVI +455,ENO,0.19182169129827034,ADVI +455,PK,0.9016482364884043,ADVI +456,PGM,-0.07518739454454226,ADVI +456,ENO,0.18720955776095338,ADVI +456,PK,0.8879778367835889,ADVI +457,PGM,-0.056658146524023456,ADVI +457,ENO,0.1902895800984235,ADVI +457,PK,0.8663685664256001,ADVI +458,PGM,-0.06737540497942507,ADVI +458,ENO,0.1961268729975614,ADVI +458,PK,0.8712485319818636,ADVI +459,PGM,-0.05304485923829594,ADVI +459,ENO,0.18134385314399948,ADVI +459,PK,0.8717010060942963,ADVI +460,PGM,-0.11237024890949932,ADVI +460,ENO,0.1658981777850882,ADVI +460,PK,0.9464720711244112,ADVI +461,PGM,-0.048841084668156176,ADVI +461,ENO,0.16202220303463372,ADVI +461,PK,0.8868188816335224,ADVI +462,PGM,-0.08807941853851964,ADVI +462,ENO,0.1607098427634478,ADVI +462,PK,0.927369575775072,ADVI +463,PGM,-0.045567617758376366,ADVI +463,ENO,0.20771055399028754,ADVI +463,PK,0.8378570637680888,ADVI +464,PGM,-0.06890152696271534,ADVI +464,ENO,0.19130889616969682,ADVI +464,PK,0.8775926307930185,ADVI +465,PGM,-0.11552717163370874,ADVI +465,ENO,0.1546224778437131,ADVI +465,PK,0.9609046937899955,ADVI +466,PGM,-0.049825963677152973,ADVI +466,ENO,0.17205741746227565,ADVI +466,PK,0.8777685462148773,ADVI +467,PGM,-0.07101819334637138,ADVI +467,ENO,0.16934742550710935,ADVI +467,PK,0.9016707678392621,ADVI +468,PGM,-0.12456558399884576,ADVI +468,ENO,0.18196990380822292,ADVI +468,PK,0.9425956801906229,ADVI +469,PGM,-0.08021528197763961,ADVI +469,ENO,0.1645585559877785,ADVI +469,PK,0.915656725989861,ADVI +470,PGM,-0.10461049981828241,ADVI +470,ENO,0.17550327071600802,ADVI +470,PK,0.9291072291022744,ADVI +471,PGM,-0.11773622034352504,ADVI +471,ENO,0.1752766432709367,ADVI +471,PK,0.9424595770725883,ADVI +472,PGM,-0.09129250031509084,ADVI +472,ENO,0.1704614085591549,ADVI +472,PK,0.920831091755936,ADVI +473,PGM,-0.10284298547988069,ADVI +473,ENO,0.16289070875542574,ADVI +473,PK,0.939952276724455,ADVI +474,PGM,-0.05306205907103223,ADVI +474,ENO,0.17141279521894232,ADVI +474,PK,0.88164926385209,ADVI +475,PGM,-0.09264177172145249,ADVI +475,ENO,0.18033969556627377,ADVI +475,PK,0.9123020761551787,ADVI +476,PGM,-0.0917613601696794,ADVI +476,ENO,0.18726826331123841,ADVI +476,PK,0.9044930968584409,ADVI +477,PGM,-0.0760074738494867,ADVI +477,ENO,0.2016953803626935,ADVI +477,PK,0.8743120934867932,ADVI +478,PGM,-0.06103535299642293,ADVI +478,ENO,0.18458597364376716,ADVI +478,PK,0.8764493793526558,ADVI +479,PGM,-0.07596112519394693,ADVI +479,ENO,0.18195961980856398,ADVI +479,PK,0.894001505385383,ADVI +480,PGM,-0.04444396633568792,ADVI +480,ENO,0.1678371755992476,ADVI +480,PK,0.8766067907364403,ADVI +481,PGM,-0.12569034780505506,ADVI +481,ENO,0.1681347457469434,ADVI +481,PK,0.9575556020581117,ADVI +482,PGM,-0.08017633916521882,ADVI +482,ENO,0.17345119239452259,ADVI +482,PK,0.9067251467706963,ADVI +483,PGM,-0.11850302614447106,ADVI +483,ENO,0.16618994406804474,ADVI +483,PK,0.9523130820764263,ADVI +484,PGM,-0.07363237617930096,ADVI +484,ENO,0.15412083749924177,ADVI +484,PK,0.9195115386800592,ADVI +485,PGM,-0.09133024214253482,ADVI +485,ENO,0.18082967451549994,ADVI +485,PK,0.9105005676270349,ADVI +486,PGM,-0.07706800731532804,ADVI +486,ENO,0.17006228035618512,ADVI +486,PK,0.9070057269591429,ADVI +487,PGM,-0.0195042056143111,ADVI +487,ENO,0.16918804313698477,ADVI +487,PK,0.8503161624773262,ADVI +488,PGM,-0.12549339488352462,ADVI +488,ENO,0.18644999059554945,ADVI +488,PK,0.9390434042879752,ADVI +489,PGM,-0.05888710285771137,ADVI +489,ENO,0.1714140841031834,ADVI +489,PK,0.8874730187545279,ADVI +490,PGM,-0.036457837324840536,ADVI +490,ENO,0.1581959710602766,ADVI +490,PK,0.8782618662645638,ADVI +491,PGM,-0.07179801909601502,ADVI +491,ENO,0.19278470131720402,ADVI +491,PK,0.8790133177788109,ADVI +492,PGM,-0.10108449985316725,ADVI +492,ENO,0.17609740989921227,ADVI +492,PK,0.9249870899539551,ADVI +493,PGM,-0.11472829226271819,ADVI +493,ENO,0.1731822020869841,ADVI +493,PK,0.9415460901757341,ADVI +494,PGM,-0.06639526432768883,ADVI +494,ENO,0.1731700328780632,ADVI +494,PK,0.8932252314496256,ADVI +495,PGM,-0.11621566682975293,ADVI +495,ENO,0.17269174971327592,ADVI +495,PK,0.943523917116477,ADVI +496,PGM,-0.10406975367609017,ADVI +496,ENO,0.18234567575518976,ADVI +496,PK,0.9217240779209004,ADVI +497,PGM,-0.1381109244228258,ADVI +497,ENO,0.16640654547084274,ADVI +497,PK,0.971704378951983,ADVI +498,PGM,-0.16589524307819725,ADVI +498,ENO,0.1673638444527018,ADVI +498,PK,0.9985313986254954,ADVI +499,PGM,-0.04533951665820446,ADVI +499,ENO,0.1621135867556624,ADVI +499,PK,0.883225929902542,ADVI +500,PGM,-0.07997063597512888,ADVI +500,ENO,0.1789760456308825,ADVI +500,PK,0.9009945903442464,ADVI +501,PGM,-0.10998114181143315,ADVI +501,ENO,0.18641188695656427,ADVI +501,PK,0.923569254854869,ADVI +502,PGM,-0.13579110479831424,ADVI +502,ENO,0.16394444408226977,ADVI +502,PK,0.9718466607160445,ADVI +503,PGM,-0.03349268431304231,ADVI +503,ENO,0.1659825085430411,ADVI +503,PK,0.8675101757700013,ADVI +504,PGM,-0.045153812245082525,ADVI +504,ENO,0.18735347327535676,ADVI +504,PK,0.8578003389697257,ADVI +505,PGM,-0.11686116310800188,ADVI +505,ENO,0.12784741700273922,ADVI +505,PK,0.9890137461052626,ADVI +506,PGM,-0.1199418736525324,ADVI +506,ENO,0.1678657056262065,ADVI +506,PK,0.9520761680263258,ADVI +507,PGM,-0.06572445574175823,ADVI +507,ENO,0.1757147710592018,ADVI +507,PK,0.8900096846825564,ADVI +508,PGM,-0.061192306382066075,ADVI +508,ENO,0.17138852757229722,ADVI +508,PK,0.889803778809769,ADVI +509,PGM,-0.05459708709903488,ADVI +509,ENO,0.1643387998027808,ADVI +509,PK,0.890258287296254,ADVI +510,PGM,-0.052465732950871535,ADVI +510,ENO,0.1748843103641071,ADVI +510,PK,0.8775814225867645,ADVI +511,PGM,-0.07219094873105503,ADVI +511,ENO,0.17819046069828565,ADVI +511,PK,0.8940004880327693,ADVI +512,PGM,-0.11092085811281605,ADVI +512,ENO,0.15713988097402268,ADVI +512,PK,0.9537809771387935,ADVI +513,PGM,-0.08724587066039713,ADVI +513,ENO,0.19204685458258933,ADVI +513,PK,0.8951990160778079,ADVI +514,PGM,-0.06270079519772098,ADVI +514,ENO,0.16606815514465825,ADVI +514,PK,0.8966326400530626,ADVI +515,PGM,-0.14834551996552747,ADVI +515,ENO,0.17640887986676834,ADVI +515,PK,0.9719366400987592,ADVI +516,PGM,-0.13409599764806823,ADVI +516,ENO,0.16591857592577672,ADVI +516,PK,0.9681774217222915,ADVI +517,PGM,-0.02203837688214616,ADVI +517,ENO,0.18685967765478662,ADVI +517,PK,0.8351786992273595,ADVI +518,PGM,-0.06271883362164621,ADVI +518,ENO,0.1659159031158115,ADVI +518,PK,0.8968029305058346,ADVI +519,PGM,-0.05993721355904014,ADVI +519,ENO,0.17738912979110452,ADVI +519,PK,0.8825480837679356,ADVI +520,PGM,-0.07934563264144234,ADVI +520,ENO,0.19586706573146542,ADVI +520,PK,0.883478566909977,ADVI +521,PGM,-0.07118561600391837,ADVI +521,ENO,0.17938935995077274,ADVI +521,PK,0.8917962560531457,ADVI +522,PGM,-0.12327199994793347,ADVI +522,ENO,0.16771584113913443,ADVI +522,PK,0.9555561588087991,ADVI +523,PGM,-0.1322666831370347,ADVI +523,ENO,0.17837296177440187,ADVI +523,PK,0.953893721362633,ADVI +524,PGM,-0.010201053728288167,ADVI +524,ENO,0.15706832299071347,ADVI +524,PK,0.8531327307375747,ADVI +525,PGM,-0.10156007854775817,ADVI +525,ENO,0.1727330688631984,ADVI +525,PK,0.9288270096845597,ADVI +526,PGM,-0.1060278472577234,ADVI +526,ENO,0.18318248132710568,ADVI +526,PK,0.9228453659306177,ADVI +527,PGM,-0.028604244405601165,ADVI +527,ENO,0.1838892864184981,ADVI +527,PK,0.8447149579871029,ADVI +528,PGM,-0.021742943908218848,ADVI +528,ENO,0.16832526430701517,ADVI +528,PK,0.8534176796012036,ADVI +529,PGM,-0.08385056149258929,ADVI +529,ENO,0.18516047119303805,ADVI +529,PK,0.8986900902995513,ADVI +530,PGM,-0.10645504413823592,ADVI +530,ENO,0.20596031757755623,ADVI +530,PK,0.9004947265606796,ADVI +531,PGM,-0.07995919596451428,ADVI +531,ENO,0.1891080528197948,ADVI +531,PK,0.8908511431447196,ADVI +532,PGM,-0.12677634403998872,ADVI +532,ENO,0.1774808944500728,ADVI +532,PK,0.949295449589916,ADVI +533,PGM,-0.06392367721384962,ADVI +533,ENO,0.16617252995470833,ADVI +533,PK,0.8977511472591413,ADVI +534,PGM,-0.05480732527908039,ADVI +534,ENO,0.1716362635920446,ADVI +534,PK,0.883171061687036,ADVI +535,PGM,-0.05303820810229176,ADVI +535,ENO,0.18572468529805305,ADVI +535,PK,0.8673135228042387,ADVI +536,PGM,-0.060563015280173715,ADVI +536,ENO,0.18066832860790305,ADVI +536,PK,0.8798946866722704,ADVI +537,PGM,-0.09609267271841482,ADVI +537,ENO,0.16284521664067036,ADVI +537,PK,0.9332474560777443,ADVI +538,PGM,-0.1683045948978128,ADVI +538,ENO,0.1664759983587597,ADVI +538,PK,1.001828596539053,ADVI +539,PGM,-0.20198029468616063,ADVI +539,ENO,0.18853599292184905,ADVI +539,PK,1.0134443017643116,ADVI +540,PGM,-0.09057856749324689,ADVI +540,ENO,0.18082316757308525,ADVI +540,PK,0.9097553999201616,ADVI +541,PGM,-0.02634250703246055,ADVI +541,ENO,0.1812675159800929,ADVI +541,PK,0.8450749910523676,ADVI +542,PGM,-0.14544991268476704,ADVI +542,ENO,0.1748726353756897,ADVI +542,PK,0.9705772773090774,ADVI +543,PGM,-0.06705696077280354,ADVI +543,ENO,0.1916736255676717,ADVI +543,PK,0.8753833352051317,ADVI +544,PGM,-0.11364949045768502,ADVI +544,ENO,0.20523013727744546,ADVI +544,PK,0.9084193531802396,ADVI +545,PGM,-0.14766839618153904,ADVI +545,ENO,0.1683061263199035,ADVI +545,PK,0.9793622698616355,ADVI +546,PGM,-0.09566265225894566,ADVI +546,ENO,0.17060587448422634,ADVI +546,PK,0.9250567777747193,ADVI +547,PGM,-0.05313990859312767,ADVI +547,ENO,0.1828655866007596,ADVI +547,PK,0.8702743219923682,ADVI +548,PGM,-0.12205988705900617,ADVI +548,ENO,0.16539526222814338,ADVI +548,PK,0.9566646248308628,ADVI +549,PGM,-0.08201116435534761,ADVI +549,ENO,0.19885204724549063,ADVI +549,PK,0.8831591171098568,ADVI +550,PGM,-0.05862672129095148,ADVI +550,ENO,0.2000726844582721,ADVI +550,PK,0.8585540368326794,ADVI +551,PGM,-0.12255329555938865,ADVI +551,ENO,0.17435543598603054,ADVI +551,PK,0.948197859573358,ADVI +552,PGM,-0.03686601610471585,ADVI +552,ENO,0.17852497218297336,ADVI +552,PK,0.8583410439217423,ADVI +553,PGM,-0.09475021394996941,ADVI +553,ENO,0.175301293746599,ADVI +553,PK,0.9194489202033705,ADVI +554,PGM,-0.06770209179776643,ADVI +554,ENO,0.18262550877846548,ADVI +554,PK,0.8850765830193009,ADVI +555,PGM,-0.04593074461416791,ADVI +555,ENO,0.1723473999520821,ADVI +555,PK,0.8735833446620858,ADVI +556,PGM,-0.04807651760830001,ADVI +556,ENO,0.16898439433160856,ADVI +556,PK,0.8790921232766915,ADVI +557,PGM,-0.09509535386332124,ADVI +557,ENO,0.16134212596397118,ADVI +557,PK,0.93375322789935,ADVI +558,PGM,-0.1459537390090886,ADVI +558,ENO,0.17517535764367406,ADVI +558,PK,0.9707783813654144,ADVI +559,PGM,-0.1411517351858047,ADVI +559,ENO,0.18178290656798096,ADVI +559,PK,0.9593688286178238,ADVI +560,PGM,-0.017735430447632927,ADVI +560,ENO,0.19004802168418627,ADVI +560,PK,0.8276874087634467,ADVI +561,PGM,-0.0363218779041401,ADVI +561,ENO,0.15960895326866023,ADVI +561,PK,0.8767129246354798,ADVI +562,PGM,-0.06917048032024398,ADVI +562,ENO,0.16828352858603443,ADVI +562,PK,0.9008869517342096,ADVI +563,PGM,-0.07103892153989744,ADVI +563,ENO,0.21843927829381082,ADVI +563,PK,0.8525996432460866,ADVI +564,PGM,-0.0863204772203856,ADVI +564,ENO,0.17801108513903002,ADVI +564,PK,0.9083093920813555,ADVI +565,PGM,-0.09641511212028697,ADVI +565,ENO,0.1722875431902627,ADVI +565,PK,0.9241275689300242,ADVI +566,PGM,-0.061361869258570234,ADVI +566,ENO,0.18809542436562718,ADVI +566,PK,0.873266444892943,ADVI +567,PGM,-0.058199381766192326,ADVI +567,ENO,0.15551776294659017,ADVI +567,PK,0.9026816188196022,ADVI +568,PGM,-0.02844021994883006,ADVI +568,ENO,0.1828076864257816,ADVI +568,PK,0.8456325335230483,ADVI +569,PGM,-0.10839748775667513,ADVI +569,ENO,0.19568667401617343,ADVI +569,PK,0.9127108137405016,ADVI +570,PGM,-0.09276830491534538,ADVI +570,ENO,0.15782429855611246,ADVI +570,PK,0.934944006359233,ADVI +571,PGM,-0.036539156365322345,ADVI +571,ENO,0.18129161479432152,ADVI +571,PK,0.8552475415710008,ADVI +572,PGM,-0.10445755233175769,ADVI +572,ENO,0.1828560926838072,ADVI +572,PK,0.9216014596479504,ADVI +573,PGM,-0.10656342854225054,ADVI +573,ENO,0.1904076226718398,ADVI +573,PK,0.9161558058704108,ADVI +574,PGM,-0.06016770763991919,ADVI +574,ENO,0.18745701208628662,ADVI +574,PK,0.8727106955536323,ADVI +575,PGM,-0.061766922464167484,ADVI +575,ENO,0.182252761707119,ADVI +575,PK,0.8795141607570486,ADVI +576,PGM,-0.06561876731702032,ADVI +576,ENO,0.17821901092703907,ADVI +576,PK,0.8873997563899813,ADVI +577,PGM,-0.09841091591482853,ADVI +577,ENO,0.19575787698431749,ADVI +577,PK,0.9026530389305111,ADVI +578,PGM,-0.10210221919078033,ADVI +578,ENO,0.1728579052406897,ADVI +578,PK,0.9292443139500906,ADVI +579,PGM,-0.030310452447951608,ADVI +579,ENO,0.1675532104198443,ADVI +579,PK,0.8627572420281072,ADVI +580,PGM,-0.11882002194489671,ADVI +580,ENO,0.16694518644367687,ADVI +580,PK,0.9518748355012199,ADVI +581,PGM,-0.08088016971818979,ADVI +581,ENO,0.179390282915667,ADVI +581,PK,0.9014898868025227,ADVI +582,PGM,-0.09149063768178767,ADVI +582,ENO,0.19492375099283724,ADVI +582,PK,0.8965668866889503,ADVI +583,PGM,-0.05659492365007113,ADVI +583,ENO,0.19502598622884001,ADVI +583,PK,0.8615689374212312,ADVI +584,PGM,-0.07502965155238828,ADVI +584,ENO,0.17412543405825315,ADVI +584,PK,0.900904217494135,ADVI +585,PGM,-0.04762888358567974,ADVI +585,ENO,0.14215486268515015,ADVI +585,PK,0.9054740209005296,ADVI +586,PGM,-0.056530197269405,ADVI +586,ENO,0.17604595450500685,ADVI +586,PK,0.8804842427643981,ADVI +587,PGM,-0.11729105620002822,ADVI +587,ENO,0.18048354753452764,ADVI +587,PK,0.9368075086655006,ADVI +588,PGM,-0.08126798588251183,ADVI +588,ENO,0.18290677909447872,ADVI +588,PK,0.8983612067880331,ADVI +589,PGM,-0.0984252439135398,ADVI +589,ENO,0.16377159537186103,ADVI +589,PK,0.9346536485416788,ADVI +590,PGM,-0.07617873636267358,ADVI +590,ENO,0.1917627068759565,ADVI +590,PK,0.8844160294867172,ADVI +591,PGM,-0.11830655711138016,ADVI +591,ENO,0.17347117398163384,ADVI +591,PK,0.9448353831297462,ADVI +592,PGM,-0.16615857470527162,ADVI +592,ENO,0.17964042125196658,ADVI +592,PK,0.9865181534533052,ADVI +593,PGM,-0.09881223335327616,ADVI +593,ENO,0.18301398125692947,ADVI +593,PK,0.9157982520963467,ADVI +594,PGM,-0.10276432608530728,ADVI +594,ENO,0.18682901852641817,ADVI +594,PK,0.9159353075588891,ADVI +595,PGM,-0.0851421213462138,ADVI +595,ENO,0.1910691110880182,ADVI +595,PK,0.8940730102581956,ADVI +596,PGM,-0.09863541395698427,ADVI +596,ENO,0.14592078995071844,ADVI +596,PK,0.9527146240062659,ADVI +597,PGM,-0.08560670331538867,ADVI +597,ENO,0.18805571932378623,ADVI +597,PK,0.8975509839916024,ADVI +598,PGM,-0.04255657784910594,ADVI +598,ENO,0.17199698898693005,ADVI +598,PK,0.8705595888621761,ADVI +599,PGM,-0.05598499705055526,ADVI +599,ENO,0.17654328480941367,ADVI +599,PK,0.8794417122411415,ADVI +600,PGM,-0.08693931116486708,ADVI +600,ENO,0.17638006657094588,ADVI +600,PK,0.9105592445939212,ADVI +601,PGM,-0.09462251346027184,ADVI +601,ENO,0.18484106823176763,ADVI +601,PK,0.9097814452285042,ADVI +602,PGM,-0.0860522501088965,ADVI +602,ENO,0.18532229566831485,ADVI +602,PK,0.9007299544405816,ADVI +603,PGM,-0.06472324477234914,ADVI +603,ENO,0.15687540106904246,ADVI +603,PK,0.9078478437033067,ADVI +604,PGM,-0.10983602154460614,ADVI +604,ENO,0.15369130385380964,ADVI +604,PK,0.9561447176907967,ADVI +605,PGM,-0.0631924118705458,ADVI +605,ENO,0.16739907538509657,ADVI +605,PK,0.8957933364854491,ADVI +606,PGM,-0.12692469604938883,ADVI +606,ENO,0.17153455043243954,ADVI +606,PK,0.9553901456169492,ADVI +607,PGM,-0.12514570403183134,ADVI +607,ENO,0.1605391004532699,ADVI +607,PK,0.9646066035785614,ADVI +608,PGM,-0.08850704306384283,ADVI +608,ENO,0.18679214270164315,ADVI +608,PK,0.9017149003621997,ADVI +609,PGM,-0.09823822182976993,ADVI +609,ENO,0.1734623389908728,ADVI +609,PK,0.9247758828388971,ADVI +610,PGM,-0.0717168910692696,ADVI +610,ENO,0.19069152459427238,ADVI +610,PK,0.8810253664749972,ADVI +611,PGM,-0.12095079509140128,ADVI +611,ENO,0.17676210171692563,ADVI +611,PK,0.9441886933744755,ADVI +612,PGM,-0.05489963585038571,ADVI +612,ENO,0.17594616551434417,ADVI +612,PK,0.8789534703360417,ADVI +613,PGM,-0.03720958241294947,ADVI +613,ENO,0.192532875503734,ADVI +613,PK,0.8446767069092155,ADVI +614,PGM,-0.0891420832165084,ADVI +614,ENO,0.18542735794335027,ADVI +614,PK,0.9037147252731581,ADVI +615,PGM,-0.059304011034710724,ADVI +615,ENO,0.18615510182962244,ADVI +615,PK,0.8731489092050884,ADVI +616,PGM,-0.07666287539394379,ADVI +616,ENO,0.1697005729972077,ADVI +616,PK,0.906962302396736,ADVI +617,PGM,-0.10523725481797275,ADVI +617,ENO,0.184152353970615,ADVI +617,PK,0.9210849008473576,ADVI +618,PGM,-0.08174587531223065,ADVI +618,ENO,0.17308285645151875,ADVI +618,PK,0.9086630188607118,ADVI +619,PGM,-0.06605136846139548,ADVI +619,ENO,0.16657660412482977,ADVI +619,PK,0.8994747643365657,ADVI +620,PGM,-0.0886821493693104,ADVI +620,ENO,0.17456920037440085,ADVI +620,PK,0.9141129489949095,ADVI +621,PGM,-0.030958850554517747,ADVI +621,ENO,0.17452858557220982,ADVI +621,PK,0.8564302649823079,ADVI +622,PGM,-0.11100338085362904,ADVI +622,ENO,0.17153816181504714,ADVI +622,PK,0.939465219038582,ADVI +623,PGM,-0.0797591185755242,ADVI +623,ENO,0.19075591379471762,ADVI +623,PK,0.8890032047808065,ADVI +624,PGM,-0.034989662142718814,ADVI +624,ENO,0.16326698057571812,ADVI +624,PK,0.8717226815670007,ADVI +625,PGM,-0.10643147647841822,ADVI +625,ENO,0.1634809472518593,ADVI +625,PK,0.9429505292265589,ADVI +626,PGM,-0.12136289150786417,ADVI +626,ENO,0.1707146782210638,ADVI +626,PK,0.9506482132868005,ADVI +627,PGM,-0.09315108398846306,ADVI +627,ENO,0.18347322621193998,ADVI +627,PK,0.909677857776523,ADVI +628,PGM,-0.08998221681151386,ADVI +628,ENO,0.1659459609437572,ADVI +628,PK,0.9240362558677568,ADVI +629,PGM,-0.07113298612579722,ADVI +629,ENO,0.1918066715183255,ADVI +629,PK,0.8793263146074717,ADVI +630,PGM,-0.012969594253922079,ADVI +630,ENO,0.1920253004672078,ADVI +630,PK,0.8209442937867144,ADVI +631,PGM,-0.05107332871028625,ADVI +631,ENO,0.17020653959149254,ADVI +631,PK,0.8808667891187937,ADVI +632,PGM,-0.1216026072497387,ADVI +632,ENO,0.159314943286768,ADVI +632,PK,0.9622876639629706,ADVI +633,PGM,-0.011909799901057339,ADVI +633,ENO,0.18629201734546857,ADVI +633,PK,0.8256177825555887,ADVI +634,PGM,-0.120395446930321,ADVI +634,ENO,0.17307891313466642,ADVI +634,PK,0.9473165337956546,ADVI +635,PGM,-0.11891770340231655,ADVI +635,ENO,0.17841434566345046,ADVI +635,PK,0.9405033577388661,ADVI +636,PGM,-0.09506488780428324,ADVI +636,ENO,0.1661001793255268,ADVI +636,PK,0.9289647084787565,ADVI +637,PGM,-0.10212465536932935,ADVI +637,ENO,0.18128440563907983,ADVI +637,PK,0.9208402497302495,ADVI +638,PGM,-0.044681218031140446,ADVI +638,ENO,0.15944487919982386,ADVI +638,PK,0.8852363388313166,ADVI +639,PGM,-0.14285672817400874,ADVI +639,ENO,0.1845124474366987,ADVI +639,PK,0.9583442807373102,ADVI +640,PGM,-0.12203524315414849,ADVI +640,ENO,0.1660484595168307,ADVI +640,PK,0.9559867836373177,ADVI +641,PGM,-0.09432168740285007,ADVI +641,ENO,0.16227314851737787,ADVI +641,PK,0.9320485388854721,ADVI +642,PGM,-0.08918482486998935,ADVI +642,ENO,0.16704400571249178,ADVI +642,PK,0.9221408191574976,ADVI +643,PGM,-0.07672955257689185,ADVI +643,ENO,0.1614712810031081,ADVI +643,PK,0.9152582715737836,ADVI +644,PGM,-0.08882280141946497,ADVI +644,ENO,0.17630146110968895,ADVI +644,PK,0.912521340309776,ADVI +645,PGM,-0.11573052386970284,ADVI +645,ENO,0.198966161156386,ADVI +645,PK,0.9167643627133168,ADVI +646,PGM,-0.09081823017276314,ADVI +646,ENO,0.16830964662297795,ADVI +646,PK,0.9225085835497852,ADVI +647,PGM,-0.12183198637009074,ADVI +647,ENO,0.16760573228624065,ADVI +647,PK,0.9542262540838503,ADVI +648,PGM,-0.06554087370670092,ADVI +648,ENO,0.167529677817868,ADVI +648,PK,0.8980111958888328,ADVI +649,PGM,-0.059735035754089116,ADVI +649,ENO,0.18103086064271093,ADVI +649,PK,0.878704175111378,ADVI +650,PGM,-0.0683254606463164,ADVI +650,ENO,0.18045563147662033,ADVI +650,PK,0.887869829169696,ADVI +651,PGM,-0.11571062172685842,ADVI +651,ENO,0.1449614647633254,ADVI +651,PK,0.9707491569635331,ADVI +652,PGM,-0.027336262567911218,ADVI +652,ENO,0.16397267797067633,ADVI +652,PK,0.8633635845972351,ADVI +653,PGM,-0.11175086858729011,ADVI +653,ENO,0.1617082064244315,ADVI +653,PK,0.9500426621628586,ADVI +654,PGM,-0.08362358192643549,ADVI +654,ENO,0.178691890142788,ADVI +654,PK,0.9049316917836473,ADVI +655,PGM,-0.09882383833773911,ADVI +655,ENO,0.20783622510072008,ADVI +655,PK,0.8909876132370189,ADVI +656,PGM,-0.07033960985025578,ADVI +656,ENO,0.17061820897891244,ADVI +656,PK,0.8997214008713432,ADVI +657,PGM,-0.15686593067243249,ADVI +657,ENO,0.1596651628500979,ADVI +657,PK,0.9972007678223347,ADVI +658,PGM,-0.09898791095785509,ADVI +658,ENO,0.18822335181273692,ADVI +658,PK,0.9107645591451182,ADVI +659,PGM,-0.05782735498178293,ADVI +659,ENO,0.16094022846711584,ADVI +659,PK,0.8968871265146672,ADVI +660,PGM,-0.10920098348036578,ADVI +660,ENO,0.16832747793058697,ADVI +660,PK,0.9408735055497788,ADVI +661,PGM,-0.08070623243206754,ADVI +661,ENO,0.1808049360251701,ADVI +661,PK,0.8999012964068975,ADVI +662,PGM,-0.05658582315865246,ADVI +662,ENO,0.15847396002115194,ADVI +662,PK,0.8981118631375005,ADVI +663,PGM,-0.05449703587937904,ADVI +663,ENO,0.17246364074608458,ADVI +663,PK,0.8820333951332946,ADVI +664,PGM,-0.09764687435521213,ADVI +664,ENO,0.1758206837756023,ADVI +664,PK,0.9218261905796099,ADVI +665,PGM,-0.058374296063328224,ADVI +665,ENO,0.16683725610788047,ADVI +665,PK,0.8915370399554478,ADVI +666,PGM,-0.08855208825352978,ADVI +666,ENO,0.12682248740728236,ADVI +666,PK,0.9617296008462474,ADVI +667,PGM,-0.07654228328302448,ADVI +667,ENO,0.17814000864403562,ADVI +667,PK,0.8984022746389889,ADVI +668,PGM,-0.025433569529799804,ADVI +668,ENO,0.1679199485617042,ADVI +668,PK,0.8575136209680956,ADVI +669,PGM,-0.11529233857852583,ADVI +669,ENO,0.17013645453798842,ADVI +669,PK,0.9451558840405374,ADVI +670,PGM,-0.11065388495667428,ADVI +670,ENO,0.1716437555187355,ADVI +670,PK,0.9390101294379387,ADVI +671,PGM,-0.08250507075338032,ADVI +671,ENO,0.15228592017427375,ADVI +671,PK,0.9302191505791065,ADVI +672,PGM,-0.08656565016627749,ADVI +672,ENO,0.16810421865868458,ADVI +672,PK,0.918461431507593,ADVI +673,PGM,-0.08758411553262446,ADVI +673,ENO,0.17166208021771776,ADVI +673,PK,0.9159220353149066,ADVI +674,PGM,-0.10321948229822131,ADVI +674,ENO,0.15690222672318296,ADVI +674,PK,0.9463172555750383,ADVI +675,PGM,-0.062239366488825,ADVI +675,ENO,0.14813752533587937,ADVI +675,PK,0.9141018411529456,ADVI +676,PGM,-0.057387391740086224,ADVI +676,ENO,0.18047579489912796,ADVI +676,PK,0.8769115968409583,ADVI +677,PGM,-0.05824170223108327,ADVI +677,ENO,0.1988702467869652,ADVI +677,PK,0.8593714554441181,ADVI +678,PGM,-0.06077529255293235,ADVI +678,ENO,0.1747121632461225,ADVI +678,PK,0.8860631293068099,ADVI +679,PGM,-0.05190443173434289,ADVI +679,ENO,0.17049986624909305,ADVI +679,PK,0.8814045654852497,ADVI +680,PGM,-0.1830566715601687,ADVI +680,ENO,0.17267629730796502,ADVI +680,PK,1.0103803742522035,ADVI +681,PGM,-0.10509692494947309,ADVI +681,ENO,0.1857106053408256,ADVI +681,PK,0.9193863196086476,ADVI +682,PGM,-0.09001226049124855,ADVI +682,ENO,0.17314126728851295,ADVI +682,PK,0.9168709932027356,ADVI +683,PGM,-0.12346609294309352,ADVI +683,ENO,0.16389261432313956,ADVI +683,PK,0.9595734786199541,ADVI +684,PGM,-0.08684906298063177,ADVI +684,ENO,0.1651007159846452,ADVI +684,PK,0.9217483469959866,ADVI +685,PGM,-0.07403390758838535,ADVI +685,ENO,0.18281756412457995,ADVI +685,PK,0.8912163434638053,ADVI +686,PGM,-0.10128906367337098,ADVI +686,ENO,0.17820730509144342,ADVI +686,PK,0.9230817585819276,ADVI +687,PGM,-0.0594336875068282,ADVI +687,ENO,0.15713461183978222,ADVI +687,PK,0.9022990756670461,ADVI +688,PGM,-0.08402022228443862,ADVI +688,ENO,0.18118032609988843,ADVI +688,PK,0.9028398961845502,ADVI +689,PGM,-0.10661343144427504,ADVI +689,ENO,0.1793087249832419,ADVI +689,PK,0.9273047064610331,ADVI +690,PGM,-0.05353323788186759,ADVI +690,ENO,0.1607508765925602,ADVI +690,PK,0.8927823612893073,ADVI +691,PGM,-0.07269757638501484,ADVI +691,ENO,0.17788896304153137,ADVI +691,PK,0.8948086133434836,ADVI +692,PGM,-0.04377736663495169,ADVI +692,ENO,0.1888960784095043,ADVI +692,PK,0.8548812882254474,ADVI +693,PGM,-0.12304413762095767,ADVI +693,ENO,0.19301919144283636,ADVI +693,PK,0.9300249461781214,ADVI +694,PGM,-0.07843387329012508,ADVI +694,ENO,0.20071314592422596,ADVI +694,PK,0.8777207273658991,ADVI +695,PGM,-0.01401935557308831,ADVI +695,ENO,0.1682353643502588,ADVI +695,PK,0.8457839912228295,ADVI +696,PGM,-0.08657767749689382,ADVI +696,ENO,0.16433814456831344,ADVI +696,PK,0.9222395329285804,ADVI +697,PGM,-0.023327228977099157,ADVI +697,ENO,0.17682102362056418,ADVI +697,PK,0.846506205356535,ADVI +698,PGM,-0.11111610055775856,ADVI +698,ENO,0.1777065174231551,ADVI +698,PK,0.9334095831346035,ADVI +699,PGM,-0.016661879249823652,ADVI +699,ENO,0.1543155159742843,ADVI +699,PK,0.8623463632755393,ADVI +700,PGM,-0.07727161818806771,ADVI +700,ENO,0.177688506377426,ADVI +700,PK,0.8995831118106418,ADVI +701,PGM,-0.15229681924278982,ADVI +701,ENO,0.18584246231855883,ADVI +701,PK,0.9664543569242309,ADVI +702,PGM,-0.08554572435436736,ADVI +702,ENO,0.17908697728054532,ADVI +702,PK,0.9064587470738222,ADVI +703,PGM,-0.04791336461306228,ADVI +703,ENO,0.1721638276680024,ADVI +703,PK,0.87574953694506,ADVI +704,PGM,-0.06002534127907144,ADVI +704,ENO,0.16522150264502763,ADVI +704,PK,0.8948038386340439,ADVI +705,PGM,-0.05983274054833143,ADVI +705,ENO,0.16677639675581554,ADVI +705,PK,0.893056343792516,ADVI +706,PGM,-0.12122330407175363,ADVI +706,ENO,0.17391521054967551,ADVI +706,PK,0.9473080935220781,ADVI +707,PGM,-0.025941219811617344,ADVI +707,ENO,0.18245138933086094,ADVI +707,PK,0.8434898304807565,ADVI +708,PGM,-0.06106914476926506,ADVI +708,ENO,0.18642751275286765,ADVI +708,PK,0.8746416320163974,ADVI +709,PGM,-0.0644496718778087,ADVI +709,ENO,0.1834972274422887,ADVI +709,PK,0.88095244443552,ADVI +710,PGM,-0.08185053944711695,ADVI +710,ENO,0.17243127932988328,ADVI +710,PK,0.9094192601172336,ADVI +711,PGM,-0.0943909414508457,ADVI +711,ENO,0.16834461308039755,ADVI +711,PK,0.9260463283704482,ADVI +712,PGM,-0.08279493953612405,ADVI +712,ENO,0.16003381287601348,ADVI +712,PK,0.9227611266601106,ADVI +713,PGM,-0.03089725640002805,ADVI +713,ENO,0.17210890052794625,ADVI +713,PK,0.8587883558720819,ADVI +714,PGM,-0.025070993876000758,ADVI +714,ENO,0.18100307556929465,ADVI +714,PK,0.8440679183067061,ADVI +715,PGM,-0.10920882891159311,ADVI +715,ENO,0.17654842914680344,ADVI +715,PK,0.9326603997647898,ADVI +716,PGM,-0.06420923343221863,ADVI +716,ENO,0.14139965689069328,ADVI +716,PK,0.9228095765415253,ADVI +717,PGM,-0.11767236110729451,ADVI +717,ENO,0.16311859251437003,ADVI +717,PK,0.9545537685929245,ADVI +718,PGM,-0.08185389586653202,ADVI +718,ENO,0.20541003207523809,ADVI +718,PK,0.8764438637912939,ADVI +719,PGM,-0.05385699348488604,ADVI +719,ENO,0.19345432418671965,ADVI +719,PK,0.8604026692981666,ADVI +720,PGM,-0.03285755499934928,ADVI +720,ENO,0.16388726333415152,ADVI +720,PK,0.8689702916651978,ADVI +721,PGM,-0.10693177617586058,ADVI +721,ENO,0.17274524157431556,ADVI +721,PK,0.934186534601545,ADVI +722,PGM,-0.07765306766619973,ADVI +722,ENO,0.17590700753472657,ADVI +722,PK,0.9017460601314731,ADVI +723,PGM,-0.09570168652003552,ADVI +723,ENO,0.18177116300487078,ADVI +723,PK,0.9139305235151648,ADVI +724,PGM,-0.02210814217689383,ADVI +724,ENO,0.174064135662223,ADVI +724,PK,0.8480440065146708,ADVI +725,PGM,-0.11811754233189142,ADVI +725,ENO,0.1896311381772281,ADVI +725,PK,0.9284864041546634,ADVI +726,PGM,-0.10153840610881937,ADVI +726,ENO,0.16480049005492298,ADVI +726,PK,0.9367379160538962,ADVI +727,PGM,-0.1357243476263741,ADVI +727,ENO,0.1850644974755658,ADVI +727,PK,0.9506598501508082,ADVI +728,PGM,-0.08823474314270108,ADVI +728,ENO,0.17374767216773276,ADVI +728,PK,0.9144870709749684,ADVI +729,PGM,-0.08291527110655794,ADVI +729,ENO,0.1916274902246429,ADVI +729,PK,0.8912877808819148,ADVI +730,PGM,-0.07924667281150177,ADVI +730,ENO,0.1942249574263856,ADVI +730,PK,0.8850217153851162,ADVI +731,PGM,-0.05140086324273607,ADVI +731,ENO,0.18190043218292531,ADVI +731,PK,0.8695004310598107,ADVI +732,PGM,-0.08187019126384687,ADVI +732,ENO,0.16041154782867223,ADVI +732,PK,0.9214586434351747,ADVI +733,PGM,-0.07227822241985393,ADVI +733,ENO,0.18389343106888287,ADVI +733,PK,0.888384791350971,ADVI +734,PGM,-0.13606492765920453,ADVI +734,ENO,0.18299105682833766,ADVI +734,PK,0.953073870830867,ADVI +735,PGM,-0.07053649467189826,ADVI +735,ENO,0.1791602463463489,ADVI +735,PK,0.8913762483255493,ADVI +736,PGM,-0.08275877095688022,ADVI +736,ENO,0.18036485410558334,ADVI +736,PK,0.902393916851297,ADVI +737,PGM,-0.07809053492291973,ADVI +737,ENO,0.18781754776480017,ADVI +737,PK,0.8902729871581196,ADVI +738,PGM,-0.1368506709558588,ADVI +738,ENO,0.1894434232195289,ADVI +738,PK,0.94740724773633,ADVI +739,PGM,-0.05404129994739071,ADVI +739,ENO,0.19246759631242283,ADVI +739,PK,0.8615737036349678,ADVI +740,PGM,-0.09440112255751099,ADVI +740,ENO,0.1621037654663931,ADVI +740,PK,0.9322973570911178,ADVI +741,PGM,-0.10437300487401835,ADVI +741,ENO,0.1871455246909676,ADVI +741,PK,0.9172274801830507,ADVI +742,PGM,-0.0740246609689752,ADVI +742,ENO,0.19099665135903438,ADVI +742,PK,0.8830280096099409,ADVI +743,PGM,-0.010971255593191787,ADVI +743,ENO,0.18569464961645668,ADVI +743,PK,0.8252766059767351,ADVI +744,PGM,-0.03847847191081577,ADVI +744,ENO,0.17310600511540544,ADVI +744,PK,0.8653724667954104,ADVI +745,PGM,-0.08094532367167728,ADVI +745,ENO,0.17491328104993395,ADVI +745,PK,0.9060320426217433,ADVI +746,PGM,-0.07412939597111845,ADVI +746,ENO,0.19165630612561285,ADVI +746,PK,0.8824730898455054,ADVI +747,PGM,-0.06456141597730114,ADVI +747,ENO,0.18849344839733975,ADVI +747,PK,0.8760679675799614,ADVI +748,PGM,-0.0668764379396265,ADVI +748,ENO,0.1713656081173186,ADVI +748,PK,0.8955108298223079,ADVI +749,PGM,-0.1206761955593485,ADVI +749,ENO,0.17255617602436787,ADVI +749,PK,0.9481200195349806,ADVI +750,PGM,-0.0839923149974735,ADVI +750,ENO,0.16509828905472046,ADVI +750,PK,0.9188940259427529,ADVI +751,PGM,-0.06477182993862574,ADVI +751,ENO,0.18327416666363755,ADVI +751,PK,0.881497663274988,ADVI +752,PGM,-0.07289608656182822,ADVI +752,ENO,0.17019744993213573,ADVI +752,PK,0.9026986366296925,ADVI +753,PGM,-0.12923377857682183,ADVI +753,ENO,0.18242637021831812,ADVI +753,PK,0.9468074083585037,ADVI +754,PGM,-0.09645933070040313,ADVI +754,ENO,0.14382519116625447,ADVI +754,PK,0.9526341395341487,ADVI +755,PGM,-0.08436475637449559,ADVI +755,ENO,0.19059034620798473,ADVI +755,PK,0.8937744101665109,ADVI +756,PGM,-0.07171171631654571,ADVI +756,ENO,0.17810579632231596,ADVI +756,PK,0.8936059199942296,ADVI +757,PGM,-0.04417311204106977,ADVI +757,ENO,0.19176951813857443,ADVI +757,PK,0.8524035939024953,ADVI +758,PGM,-0.0974056452264005,ADVI +758,ENO,0.17522102435915696,ADVI +758,PK,0.9221846208672435,ADVI +759,PGM,-0.07489227870502146,ADVI +759,ENO,0.17378154902786186,ADVI +759,PK,0.9011107296771597,ADVI +760,PGM,-0.11258762257682231,ADVI +760,ENO,0.20348212946683747,ADVI +760,PK,0.9091054931099848,ADVI +761,PGM,-0.1477594769483248,ADVI +761,ENO,0.19439739302041253,ADVI +761,PK,0.9533620839279122,ADVI +762,PGM,-0.10676266765558573,ADVI +762,ENO,0.16034500980939023,ADVI +762,PK,0.9464176578461955,ADVI +763,PGM,-0.0899218349166786,ADVI +763,ENO,0.16711763127534765,ADVI +763,PK,0.922804203641331,ADVI +764,PGM,-0.05858069438242364,ADVI +764,ENO,0.17043090948849318,ADVI +764,PK,0.8881497848939304,ADVI +765,PGM,-0.07881600808780731,ADVI +765,ENO,0.19000162255974962,ADVI +765,PK,0.8888143855280576,ADVI +766,PGM,-0.09479874328187199,ADVI +766,ENO,0.16974464698282674,ADVI +766,PK,0.9250540962990451,ADVI +767,PGM,-0.04476923067032712,ADVI +767,ENO,0.18995990503106805,ADVI +767,PK,0.8548093256392592,ADVI +768,PGM,-0.027432231400277063,ADVI +768,ENO,0.1841361647400869,ADVI +768,PK,0.8432960666601901,ADVI +769,PGM,-0.05871442693426765,ADVI +769,ENO,0.1827119470900399,ADVI +769,PK,0.8760024798442276,ADVI +770,PGM,-0.049884978165098515,ADVI +770,ENO,0.1812527792054739,ADVI +770,PK,0.8686321989596245,ADVI +771,PGM,-0.1330143361216487,ADVI +771,ENO,0.18953157566451914,ADVI +771,PK,0.9434827604571295,ADVI +772,PGM,-0.06444628472763614,ADVI +772,ENO,0.17263347616091712,ADVI +772,PK,0.891812808566719,ADVI +773,PGM,-0.026450885266463997,ADVI +773,ENO,0.17813361688799817,ADVI +773,PK,0.8483172683784657,ADVI +774,PGM,-0.08728487825682696,ADVI +774,ENO,0.18058881727918308,ADVI +774,PK,0.906696060977644,ADVI +775,PGM,-0.06616027155029958,ADVI +775,ENO,0.17137078833553693,ADVI +775,PK,0.8947894832147626,ADVI +776,PGM,-0.007978551576754755,ADVI +776,ENO,0.1712500793357513,ADVI +776,PK,0.8367284722410036,ADVI +777,PGM,-0.048704227264521505,ADVI +777,ENO,0.14322119614280882,ADVI +777,PK,0.9054830311217127,ADVI +778,PGM,-0.026096124372161356,ADVI +778,ENO,0.15642581187395693,ADVI +778,PK,0.8696703124982045,ADVI +779,PGM,-0.09510076882215235,ADVI +779,ENO,0.1340873824691395,ADVI +779,PK,0.9610133863530128,ADVI +780,PGM,-0.08262945862521653,ADVI +780,ENO,0.187178222085576,ADVI +780,PK,0.8954512365396405,ADVI +781,PGM,-0.013671453995522942,ADVI +781,ENO,0.17786338289283565,ADVI +781,PK,0.8358080711026872,ADVI +782,PGM,-0.0641259606959046,ADVI +782,ENO,0.17778711148416346,ADVI +782,PK,0.8863388492117411,ADVI +783,PGM,-0.08710359397066014,ADVI +783,ENO,0.1655955413311288,ADVI +783,PK,0.9215080526395313,ADVI +784,PGM,-0.09228457723746364,ADVI +784,ENO,0.20275939868635798,ADVI +784,PK,0.8895251785511057,ADVI +785,PGM,-0.0799136907476754,ADVI +785,ENO,0.18435162836139177,ADVI +785,PK,0.8955620623862836,ADVI +786,PGM,-0.06505916257081013,ADVI +786,ENO,0.18717548473713297,ADVI +786,PK,0.8778836778336773,ADVI +787,PGM,-0.11208961575510079,ADVI +787,ENO,0.15799801322759388,ADVI +787,PK,0.9540916025275068,ADVI +788,PGM,-0.10184123114970922,ADVI +788,ENO,0.16968528987006123,ADVI +788,PK,0.932155941279648,ADVI +789,PGM,-0.09365452418405029,ADVI +789,ENO,0.1681039375057457,ADVI +789,PK,0.9255505866783047,ADVI +790,PGM,-0.13367979734757873,ADVI +790,ENO,0.181255575166482,ADVI +790,PK,0.9524242221810968,ADVI +791,PGM,-0.05927222021491518,ADVI +791,ENO,0.17369660136046644,ADVI +791,PK,0.8855756188544487,ADVI +792,PGM,-0.08269864388879089,ADVI +792,ENO,0.1508420849896838,ADVI +792,PK,0.9318565588991071,ADVI +793,PGM,-0.04623004818223708,ADVI +793,ENO,0.16358590808292914,ADVI +793,PK,0.882644140099308,ADVI +794,PGM,-0.09139203055365042,ADVI +794,ENO,0.16352310313772625,ADVI +794,PK,0.9278689274159241,ADVI +795,PGM,-0.08897855909768349,ADVI +795,ENO,0.17293307150125253,ADVI +795,PK,0.9160454875964309,ADVI +796,PGM,-0.06384354042640905,ADVI +796,ENO,0.1690490562194165,ADVI +796,PK,0.8947944842069925,ADVI +797,PGM,-0.08769006420702441,ADVI +797,ENO,0.18075814117363195,ADVI +797,PK,0.9069319230333924,ADVI +798,PGM,-8.256107568760385e-05,ADVI +798,ENO,0.16135091745236205,ADVI +798,PK,0.8387316436233254,ADVI +799,PGM,-0.09192307813046674,ADVI +799,ENO,0.20301415425998176,ADVI +799,PK,0.888908923870485,ADVI +800,PGM,-0.08757035188668927,ADVI +800,ENO,0.18730787457077178,ADVI +800,PK,0.9002624773159174,ADVI +801,PGM,-0.0993588954552167,ADVI +801,ENO,0.1623106937808101,ADVI +801,PK,0.9370482016744066,ADVI +802,PGM,-0.048842535929403796,ADVI +802,ENO,0.15242158420128546,ADVI +802,PK,0.8964209517281184,ADVI +803,PGM,-0.08069028115728782,ADVI +803,ENO,0.1569967782306898,ADVI +803,PK,0.923693502926598,ADVI +804,PGM,-0.08787079427896538,ADVI +804,ENO,0.1697177446564989,ADVI +804,PK,0.9181530496224666,ADVI +805,PGM,-0.10588432268813563,ADVI +805,ENO,0.16717813024068123,ADVI +805,PK,0.9387061924474543,ADVI +806,PGM,-0.16466604185980116,ADVI +806,ENO,0.16846209330010536,ADVI +806,PK,0.9962039485596956,ADVI +807,PGM,-0.11281436534902434,ADVI +807,ENO,0.16428927468762614,ADVI +807,PK,0.9485250906613983,ADVI +808,PGM,-0.04680225204812283,ADVI +808,ENO,0.15920751728137716,ADVI +808,PK,0.8875947347667457,ADVI +809,PGM,-0.08849086315828147,ADVI +809,ENO,0.18946265292644768,ADVI +809,PK,0.8990282102318338,ADVI +810,PGM,-0.05239661014421726,ADVI +810,ENO,0.18720084750564375,ADVI +810,PK,0.8651957626385737,ADVI +811,PGM,-0.018373942296969092,ADVI +811,ENO,0.16102312881548822,ADVI +811,PK,0.857350813481481,ADVI +812,PGM,-0.05961194310478324,ADVI +812,ENO,0.1668375292714814,ADVI +812,PK,0.8927744138333018,ADVI +813,PGM,-0.12300664119352289,ADVI +813,ENO,0.154328127739611,ADVI +813,PK,0.968678513453912,ADVI +814,PGM,-0.09962706969689972,ADVI +814,ENO,0.18405637158231428,ADVI +814,PK,0.9155706981145855,ADVI +815,PGM,-0.08602087039711859,ADVI +815,ENO,0.20484444600065507,ADVI +815,PK,0.8811764243964636,ADVI +816,PGM,-0.08566458245615793,ADVI +816,ENO,0.1831934316479311,ADVI +816,PK,0.9024711508082268,ADVI +817,PGM,-0.09412626501778854,ADVI +817,ENO,0.18836427728393415,ADVI +817,PK,0.9057619877338544,ADVI +818,PGM,-0.055760625317015755,ADVI +818,ENO,0.16825084626714973,ADVI +818,PK,0.887509779049866,ADVI +819,PGM,-0.06948141210149816,ADVI +819,ENO,0.16452936237318583,ADVI +819,PK,0.9049520497283124,ADVI +820,PGM,-0.12445894554680592,ADVI +820,ENO,0.18495428177638745,ADVI +820,PK,0.9395046637704185,ADVI +821,PGM,-0.05767908779978348,ADVI +821,ENO,0.15774218113500263,ADVI +821,PK,0.899936906664781,ADVI +822,PGM,-0.14568534011280954,ADVI +822,ENO,0.15780884286357133,ADVI +822,PK,0.9878764972492381,ADVI +823,PGM,-0.07777136609707913,ADVI +823,ENO,0.1637989623424788,ADVI +823,PK,0.9139724037546004,ADVI +824,PGM,-0.005197664845732142,ADVI +824,ENO,0.18400071733114323,ADVI +824,PK,0.8211969475145889,ADVI +825,PGM,-0.09968249821792408,ADVI +825,ENO,0.20454370636079205,ADVI +825,PK,0.8951387918571321,ADVI +826,PGM,-0.07000196078253351,ADVI +826,ENO,0.18265470202189563,ADVI +826,PK,0.887347258760638,ADVI +827,PGM,-0.016398917972173077,ADVI +827,ENO,0.16061877442223485,ADVI +827,PK,0.8557801435499381,ADVI +828,PGM,-0.07453624981124518,ADVI +828,ENO,0.18853426320420927,ADVI +828,PK,0.8860019866070359,ADVI +829,PGM,-0.056534762781122794,ADVI +829,ENO,0.17392373534957722,ADVI +829,PK,0.8826110274315457,ADVI +830,PGM,-0.20645614076917562,ADVI +830,ENO,0.18633483244884028,ADVI +830,PK,1.0201213083203353,ADVI +831,PGM,-0.11012361126433046,ADVI +831,ENO,0.1560930827765604,ADVI +831,PK,0.9540305284877701,ADVI +832,PGM,-0.1449196129981023,ADVI +832,ENO,0.16956215327540794,ADVI +832,PK,0.9753574597226944,ADVI +833,PGM,-0.11997078048561471,ADVI +833,ENO,0.1832227775856436,ADVI +833,PK,0.9367480028999711,ADVI +834,PGM,-0.06134596380812107,ADVI +834,ENO,0.16828157075746517,ADVI +834,PK,0.8930643930506558,ADVI +835,PGM,-0.044789188591660034,ADVI +835,ENO,0.2003275030732725,ADVI +835,PK,0.8444616855183877,ADVI +836,PGM,-0.07379126548338255,ADVI +836,ENO,0.18169878511149784,ADVI +836,PK,0.8920924803718847,ADVI +837,PGM,-0.03343631534834923,ADVI +837,ENO,0.19111263039780937,ADVI +837,PK,0.8423236849505399,ADVI +838,PGM,-0.07109970814040811,ADVI +838,ENO,0.15628295500026024,ADVI +838,PK,0.9148167531401479,ADVI +839,PGM,-0.06653754757332675,ADVI +839,ENO,0.18392352176668236,ADVI +839,PK,0.8826140258066444,ADVI +840,PGM,-0.054009932599989874,ADVI +840,ENO,0.16848714125275416,ADVI +840,PK,0.8855227913472357,ADVI +841,PGM,-0.10904150770177568,ADVI +841,ENO,0.16677670553370194,ADVI +841,PK,0.9422648021680736,ADVI +842,PGM,-0.10235780045730447,ADVI +842,ENO,0.17024204796472373,ADVI +842,PK,0.9321157524925807,ADVI +843,PGM,-0.09596714989937127,ADVI +843,ENO,0.1780011661608878,ADVI +843,PK,0.9179659837384835,ADVI +844,PGM,-0.0644139960991359,ADVI +844,ENO,0.16598332206990923,ADVI +844,PK,0.8984306740292267,ADVI +845,PGM,-0.062041828901443496,ADVI +845,ENO,0.16288612556815427,ADVI +845,PK,0.8991557033332892,ADVI +846,PGM,-0.06348622215035138,ADVI +846,ENO,0.16096161934035422,ADVI +846,PK,0.9025246028099972,ADVI +847,PGM,-0.03585599851916976,ADVI +847,ENO,0.18183642839138545,ADVI +847,PK,0.8540195701277843,ADVI +848,PGM,-0.1169616159509832,ADVI +848,ENO,0.19043298017281185,ADVI +848,PK,0.9265286357781715,ADVI +849,PGM,-0.14270039939412027,ADVI +849,ENO,0.1819410410353328,ADVI +849,PK,0.9607593583587875,ADVI +850,PGM,-0.11550417345300756,ADVI +850,ENO,0.17811511508001474,ADVI +850,PK,0.9373890583729928,ADVI +851,PGM,-0.0855152543333435,ADVI +851,ENO,0.17346127435453723,ADVI +851,PK,0.9120539799788062,ADVI +852,PGM,-0.12753268383526506,ADVI +852,ENO,0.15045331003873172,ADVI +852,PK,0.9770793737965334,ADVI +853,PGM,-0.08095226527292776,ADVI +853,ENO,0.16135220238142867,ADVI +853,PK,0.919600062891499,ADVI +854,PGM,-0.0762974927065625,ADVI +854,ENO,0.1778786501295386,ADVI +854,PK,0.8984188425770241,ADVI +855,PGM,-0.06607202799535083,ADVI +855,ENO,0.1556849668586306,ADVI +855,PK,0.9103870611367203,ADVI +856,PGM,-0.13560667728752818,ADVI +856,ENO,0.18945493504789676,ADVI +856,PK,0.9461517422396314,ADVI +857,PGM,-0.03241622370355257,ADVI +857,ENO,0.16174090500796068,ADVI +857,PK,0.870675318695592,ADVI +858,PGM,-0.0870805053210626,ADVI +858,ENO,0.19296497862435544,ADVI +858,PK,0.8941155266967072,ADVI +859,PGM,-0.029619042947720553,ADVI +859,ENO,0.17268070411149455,ADVI +859,PK,0.856938338836226,ADVI +860,PGM,-0.039271601923238864,ADVI +860,ENO,0.15504343159651476,ADVI +860,PK,0.8842281703267241,ADVI +861,PGM,-0.12736349900804056,ADVI +861,ENO,0.1802856253551439,ADVI +861,PK,0.9470778736528968,ADVI +862,PGM,-0.07683809124781993,ADVI +862,ENO,0.17206682026303508,ADVI +862,PK,0.9047712709847849,ADVI +863,PGM,-0.0916643854591912,ADVI +863,ENO,0.15327178713204367,ADVI +863,PK,0.9383925983271476,ADVI +864,PGM,-0.12629660537129395,ADVI +864,ENO,0.1643120839939712,ADVI +864,PK,0.9619845213773227,ADVI +865,PGM,-0.05815853477980992,ADVI +865,ENO,0.16538360063103189,ADVI +865,PK,0.8927749341487781,ADVI +866,PGM,-0.03416057948787787,ADVI +866,ENO,0.15318938025590792,ADVI +866,PK,0.8809711992319699,ADVI +867,PGM,-0.076835369809227,ADVI +867,ENO,0.16072311768905786,ADVI +867,PK,0.9161122521201691,ADVI +868,PGM,-0.04128333467151424,ADVI +868,ENO,0.20277895834733128,ADVI +868,PK,0.8385043763241828,ADVI +869,PGM,-0.10475033854642879,ADVI +869,ENO,0.16706415152470447,ADVI +869,PK,0.9376861870217242,ADVI +870,PGM,-0.011250038467957246,ADVI +870,ENO,0.17033893062084582,ADVI +870,PK,0.8409111078471113,ADVI +871,PGM,-0.07338329169328106,ADVI +871,ENO,0.17967395154815863,ADVI +871,PK,0.8937093401451225,ADVI +872,PGM,-0.11448958192220204,ADVI +872,ENO,0.15921840041825125,ADVI +872,PK,0.9552711815039507,ADVI +873,PGM,-0.07721038822943815,ADVI +873,ENO,0.18251265291308305,ADVI +873,PK,0.8946977353163552,ADVI +874,PGM,-0.04849626798148243,ADVI +874,ENO,0.18208877692073183,ADVI +874,PK,0.8664074910607507,ADVI +875,PGM,-0.04895277048354352,ADVI +875,ENO,0.1748121265920727,ADVI +875,PK,0.874140643891471,ADVI +876,PGM,-0.1384396339486058,ADVI +876,ENO,0.20159766503202337,ADVI +876,PK,0.9368419689165824,ADVI +877,PGM,-0.08510986382823904,ADVI +877,ENO,0.16482548215955634,ADVI +877,PK,0.9202843816686829,ADVI +878,PGM,-0.0744365784455181,ADVI +878,ENO,0.15514768441239915,ADVI +878,PK,0.9192888940331189,ADVI +879,PGM,-0.050644197632092824,ADVI +879,ENO,0.1724863615193587,ADVI +879,PK,0.878157836112734,ADVI +880,PGM,-0.02702059117311717,ADVI +880,ENO,0.16703716277175437,ADVI +880,PK,0.8599834284013629,ADVI +881,PGM,-0.11555624127196507,ADVI +881,ENO,0.177375639912108,ADVI +881,PK,0.938180601359857,ADVI +882,PGM,-0.04950621705061797,ADVI +882,ENO,0.16901444711487212,ADVI +882,PK,0.8804917699357458,ADVI +883,PGM,-0.10112937546146683,ADVI +883,ENO,0.17338610229012866,ADVI +883,PK,0.9277432731713381,ADVI +884,PGM,-0.04319545924258961,ADVI +884,ENO,0.17920543688385904,ADVI +884,PK,0.8639900223587306,ADVI +885,PGM,-0.02978278600021622,ADVI +885,ENO,0.1792472818066087,ADVI +885,PK,0.8505355041936076,ADVI +886,PGM,-0.016105820042052965,ADVI +886,ENO,0.16949598706923075,ADVI +886,PK,0.8466098329728221,ADVI +887,PGM,-0.08819637785225498,ADVI +887,ENO,0.1797051639401293,ADVI +887,PK,0.9084912139121255,ADVI +888,PGM,-0.11506243327401844,ADVI +888,ENO,0.1718436356699786,ADVI +888,PK,0.9432187976040399,ADVI +889,PGM,-0.08962628825355234,ADVI +889,ENO,0.1853263318428961,ADVI +889,PK,0.9042999564106563,ADVI +890,PGM,-0.09769677185510228,ADVI +890,ENO,0.1706871233713694,ADVI +890,PK,0.9270096484837329,ADVI +891,PGM,-0.08109431951903723,ADVI +891,ENO,0.17716276959357719,ADVI +891,PK,0.90393154992546,ADVI +892,PGM,-0.12476411147902144,ADVI +892,ENO,0.16860266907201182,ADVI +892,PK,0.9561614424070096,ADVI +893,PGM,-0.06820619838044428,ADVI +893,ENO,0.17366779987198172,ADVI +893,PK,0.8945383985084626,ADVI +894,PGM,-0.08914422286987733,ADVI +894,ENO,0.18743105834500617,ADVI +894,PK,0.9017131645248712,ADVI +895,PGM,-0.09596015380604173,ADVI +895,ENO,0.18396028728980968,ADVI +895,PK,0.911999866516232,ADVI +896,PGM,-0.0963526355789408,ADVI +896,ENO,0.17665434566853275,ADVI +896,PK,0.9196982899104081,ADVI +897,PGM,-0.16602292641248217,ADVI +897,ENO,0.1872111210851911,ADVI +897,PK,0.9788118053272911,ADVI +898,PGM,-0.05157437837330203,ADVI +898,ENO,0.1744457710451189,ADVI +898,PK,0.8771286073281832,ADVI +899,PGM,-0.08965479959389544,ADVI +899,ENO,0.1857370456405675,ADVI +899,PK,0.903917753953328,ADVI +900,PGM,-0.10758990961631887,ADVI +900,ENO,0.20034723092587395,ADVI +900,PK,0.907242678690445,ADVI +901,PGM,-0.06885023544003044,ADVI +901,ENO,0.1786512485909824,ADVI +901,PK,0.890198986849048,ADVI +902,PGM,-0.06847179601684017,ADVI +902,ENO,0.1865536674939259,ADVI +902,PK,0.8819181285229143,ADVI +903,PGM,-0.0770139696184402,ADVI +903,ENO,0.16816155574093639,ADVI +903,PK,0.9088524138775038,ADVI +904,PGM,-0.03720690649606451,ADVI +904,ENO,0.1867863785150932,ADVI +904,PK,0.8504205279809713,ADVI +905,PGM,-0.1127285017956321,ADVI +905,ENO,0.17287937676845813,ADVI +905,PK,0.9398491250271739,ADVI +906,PGM,-0.05656528524787885,ADVI +906,ENO,0.18415553911559515,ADVI +906,PK,0.8724097461322836,ADVI +907,PGM,-0.14982752457921777,ADVI +907,ENO,0.1820512443984143,ADVI +907,PK,0.9677762801808034,ADVI +908,PGM,-0.07017919472720524,ADVI +908,ENO,0.18059106411187759,ADVI +908,PK,0.8895881306153276,ADVI +909,PGM,-0.07520458098689375,ADVI +909,ENO,0.1801620651911256,ADVI +909,PK,0.8950425157957683,ADVI +910,PGM,-0.021238090596473524,ADVI +910,ENO,0.18256863581402644,ADVI +910,PK,0.8386694547824473,ADVI +911,PGM,-0.13367498246134724,ADVI +911,ENO,0.20124750906414313,ADVI +911,PK,0.9324274733972042,ADVI +912,PGM,-0.05411800747887319,ADVI +912,ENO,0.1722156085466015,ADVI +912,PK,0.8819023989322716,ADVI +913,PGM,-0.07308899544596104,ADVI +913,ENO,0.19498863982082876,ADVI +913,PK,0.8781003556251323,ADVI +914,PGM,-0.051981820007725776,ADVI +914,ENO,0.17569817983188354,ADVI +914,PK,0.8762836401758421,ADVI +915,PGM,-0.08181222522088727,ADVI +915,ENO,0.16476485626669307,ADVI +915,PK,0.9170473689541941,ADVI +916,PGM,-0.1321491303523612,ADVI +916,ENO,0.19395464851163383,ADVI +916,PK,0.9381944818407274,ADVI +917,PGM,-0.12472486573171326,ADVI +917,ENO,0.16849444840143524,ADVI +917,PK,0.956230417330278,ADVI +918,PGM,-0.028785346830147995,ADVI +918,ENO,0.15721558334137534,ADVI +918,PK,0.8715697634887726,ADVI +919,PGM,-0.046574225076555065,ADVI +919,ENO,0.18401510347370156,ADVI +919,PK,0.8625591216028536,ADVI +920,PGM,-0.07481587379301002,ADVI +920,ENO,0.18697663475064824,ADVI +920,PK,0.887839239042362,ADVI +921,PGM,-0.08427943343938549,ADVI +921,ENO,0.1795072364190551,ADVI +921,PK,0.9047721970203304,ADVI +922,PGM,-0.03350428839653907,ADVI +922,ENO,0.16060514268241086,ADVI +922,PK,0.8728991457141283,ADVI +923,PGM,-0.0036530006706760876,ADVI +923,ENO,0.18194981955538844,ADVI +923,PK,0.8217031811152877,ADVI +924,PGM,-0.0519809599320884,ADVI +924,ENO,0.17800093292427743,ADVI +924,PK,0.8739800270078111,ADVI +925,PGM,-0.06634409292745214,ADVI +925,ENO,0.172630022866827,ADVI +925,PK,0.8937140700606252,ADVI +926,PGM,-0.054612592522784276,ADVI +926,ENO,0.16737967608844798,ADVI +926,PK,0.8872329164343362,ADVI +927,PGM,-0.09570143512442408,ADVI +927,ENO,0.17172513218147883,ADVI +927,PK,0.9239763029429452,ADVI +928,PGM,-0.0770901646995803,ADVI +928,ENO,0.15872413231482405,ADVI +928,PK,0.9183660323847561,ADVI +929,PGM,-0.05692131300641634,ADVI +929,ENO,0.19381861299008785,ADVI +929,PK,0.8631027000163285,ADVI +930,PGM,-0.0748473231755864,ADVI +930,ENO,0.178161069218028,ADVI +930,PK,0.8966862539575584,ADVI +931,PGM,-0.11288970905109807,ADVI +931,ENO,0.18821768910301698,ADVI +931,PK,0.9246720199480811,ADVI +932,PGM,0.010288013064909785,ADVI +932,ENO,0.17476072344007196,ADVI +932,PK,0.8149512634950182,ADVI +933,PGM,-0.0794588401540357,ADVI +933,ENO,0.18340912867823692,ADVI +933,PK,0.8960497114757988,ADVI +934,PGM,-0.14306023285292713,ADVI +934,ENO,0.16885208565555396,ADVI +934,PK,0.9742081471973731,ADVI +935,PGM,-0.05112402203798094,ADVI +935,ENO,0.18047998597201137,ADVI +935,PK,0.8706440360659696,ADVI +936,PGM,-0.061993185421646446,ADVI +936,ENO,0.15442581995865134,ADVI +936,PK,0.9075673654629951,ADVI +937,PGM,-0.08536576718136102,ADVI +937,ENO,0.17594478241254444,ADVI +937,PK,0.9094209847688166,ADVI +938,PGM,-0.1224716347149406,ADVI +938,ENO,0.1612959813946889,ADVI +938,PK,0.9611756533202518,ADVI +939,PGM,-0.08179951154275744,ADVI +939,ENO,0.17240628386793524,ADVI +939,PK,0.9093932276748223,ADVI +940,PGM,-0.1378393681865886,ADVI +940,ENO,0.16690268191056537,ADVI +940,PK,0.9709366862760231,ADVI +941,PGM,-0.08285397226426805,ADVI +941,ENO,0.15477389030929323,ADVI +941,PK,0.9280800819549747,ADVI +942,PGM,-0.06666414981996094,ADVI +942,ENO,0.16619851315789574,ADVI +942,PK,0.9004656366620651,ADVI +943,PGM,-0.10618768371229415,ADVI +943,ENO,0.1735654154433156,ADVI +943,PK,0.9326222682689785,ADVI +944,PGM,-0.12836732129240036,ADVI +944,ENO,0.1905726063975101,ADVI +944,PK,0.9377947148948903,ADVI +945,PGM,-0.06223981668366796,ADVI +945,ENO,0.17767654405712396,ADVI +945,PK,0.884563272626544,ADVI +946,PGM,-0.06419243705303401,ADVI +946,ENO,0.18008038588947403,ADVI +946,PK,0.88411205116356,ADVI +947,PGM,-0.06124900213705331,ADVI +947,ENO,0.19702284182320356,ADVI +947,PK,0.8642261603138497,ADVI +948,PGM,-0.11949861485373403,ADVI +948,ENO,0.1637245244567767,ADVI +948,PK,0.9557740903969574,ADVI +949,PGM,-0.05474338431205794,ADVI +949,ENO,0.18228299915987642,ADVI +949,PK,0.8724603851521815,ADVI +950,PGM,-0.04481324575421897,ADVI +950,ENO,0.13111092568557892,ADVI +950,PK,0.91370232006864,ADVI +951,PGM,-0.11581697128683954,ADVI +951,ENO,0.1768664728311072,ADVI +951,PK,0.9389504984557322,ADVI +952,PGM,-0.08690710365558885,ADVI +952,ENO,0.19529132174228253,ADVI +952,PK,0.8916157819133063,ADVI +953,PGM,-0.10678664473796418,ADVI +953,ENO,0.21679089335979004,ADVI +953,PK,0.8899957513781742,ADVI +954,PGM,-0.11315219482594507,ADVI +954,ENO,0.21422419723568475,ADVI +954,PK,0.8989279975902603,ADVI +955,PGM,-0.03911338984439516,ADVI +955,ENO,0.1763263449148412,ADVI +955,PK,0.8627870449295538,ADVI +956,PGM,-0.08728587981880209,ADVI +956,ENO,0.203041678785169,ADVI +956,PK,0.8842442010336331,ADVI +957,PGM,-0.07507640240645785,ADVI +957,ENO,0.1799023723939819,ADVI +957,PK,0.8951740300124759,ADVI +958,PGM,-0.10199191460766044,ADVI +958,ENO,0.15969375497487262,ADVI +958,PK,0.9422981596327877,ADVI +959,PGM,-0.041723364243792416,ADVI +959,ENO,0.16853815234223538,ADVI +959,PK,0.8731852119015571,ADVI +960,PGM,-0.0956807069877732,ADVI +960,ENO,0.17981013634074813,ADVI +960,PK,0.9158705706470249,ADVI +961,PGM,-0.07705308059001625,ADVI +961,ENO,0.17172823621414132,ADVI +961,PK,0.9053248443758749,ADVI +962,PGM,-0.08926983528595844,ADVI +962,ENO,0.17607493272029015,ADVI +962,PK,0.9131949025656683,ADVI +963,PGM,-0.028683468366074383,ADVI +963,ENO,0.1575990416583996,ADVI +963,PK,0.8710844267076747,ADVI +964,PGM,-0.06778117196545597,ADVI +964,ENO,0.17076611518294876,ADVI +964,PK,0.8970150567825071,ADVI +965,PGM,-0.11060103631086293,ADVI +965,ENO,0.14107000272992568,ADVI +965,PK,0.9695310335809374,ADVI +966,PGM,-0.0824895104662875,ADVI +966,ENO,0.21673497694638377,ADVI +966,PK,0.8657545335199036,ADVI +967,PGM,-0.051314079467178475,ADVI +967,ENO,0.1658608251068474,ADVI +967,PK,0.885453254360331,ADVI +968,PGM,-0.10267535156347884,ADVI +968,ENO,0.18333929619010836,ADVI +968,PK,0.9193360553733703,ADVI +969,PGM,-0.08968933030073334,ADVI +969,ENO,0.18741188470653367,ADVI +969,PK,0.9022774455941998,ADVI +970,PGM,-0.019637032075906946,ADVI +970,ENO,0.1807562697297449,ADVI +970,PK,0.838880762346162,ADVI +971,PGM,-0.09219562303542816,ADVI +971,ENO,0.18320274208094753,ADVI +971,PK,0.9089928809544806,ADVI +972,PGM,-0.11330884480439551,ADVI +972,ENO,0.17327034963742813,ADVI +972,PK,0.9400384951669671,ADVI +973,PGM,-0.12577594829773586,ADVI +973,ENO,0.17929762943158575,ADVI +973,PK,0.9464783188661501,ADVI +974,PGM,-0.11722861675389207,ADVI +974,ENO,0.17314793462198322,ADVI +974,PK,0.9440806821319089,ADVI +975,PGM,-0.07735802953600546,ADVI +975,ENO,0.20203007317384142,ADVI +975,PK,0.8753279563621641,ADVI +976,PGM,-0.0906253933958654,ADVI +976,ENO,0.16414136537820626,ADVI +976,PK,0.9264840280176591,ADVI +977,PGM,-0.08314547842498854,ADVI +977,ENO,0.18445799912898664,ADVI +977,PK,0.8986874792960019,ADVI +978,PGM,-0.1260441547837663,ADVI +978,ENO,0.1857764515014716,ADVI +978,PK,0.9402677032822948,ADVI +979,PGM,-0.06313107782256622,ADVI +979,ENO,0.170649477202454,ADVI +979,PK,0.8924816006201122,ADVI +980,PGM,-0.08857590438233554,ADVI +980,ENO,0.16470405409470937,ADVI +980,PK,0.9238718502876262,ADVI +981,PGM,-0.05922021232471497,ADVI +981,ENO,0.1936411875063053,ADVI +981,PK,0.8655790248184098,ADVI +982,PGM,-0.07507894546958149,ADVI +982,ENO,0.18125238697516444,ADVI +982,PK,0.8938265584944171,ADVI +983,PGM,-0.09611736891743772,ADVI +983,ENO,0.21392784491161396,ADVI +983,PK,0.8821895240058237,ADVI +984,PGM,-0.009155129711998278,ADVI +984,ENO,0.17309500856799803,ADVI +984,PK,0.8360601211440003,ADVI +985,PGM,-0.10061542744349983,ADVI +985,ENO,0.16019093236851972,ADVI +985,PK,0.94042449507498,ADVI +986,PGM,-0.04649813658168278,ADVI +986,ENO,0.1696328638640959,ADVI +986,PK,0.8768652727175869,ADVI +987,PGM,-0.08166138213170471,ADVI +987,ENO,0.18892953703831508,ADVI +987,PK,0.8927318450933897,ADVI +988,PGM,-0.11078404153396737,ADVI +988,ENO,0.15731394237374083,ADVI +988,PK,0.9534700991602266,ADVI +989,PGM,-0.04190895152209628,ADVI +989,ENO,0.18300911623353594,ADVI +989,PK,0.8588998352885603,ADVI +990,PGM,-0.044514266063755414,ADVI +990,ENO,0.19378411109361796,ADVI +990,PK,0.8507301549701376,ADVI +991,PGM,-0.1331495976342536,ADVI +991,ENO,0.2073782227344284,ADVI +991,PK,0.9257713748998252,ADVI +992,PGM,-0.06431167627320367,ADVI +992,ENO,0.18129052605548554,ADVI +992,PK,0.8830211502177181,ADVI +993,PGM,-0.11387959468817233,ADVI +993,ENO,0.1843835844697531,ADVI +993,PK,0.9294960102184192,ADVI +994,PGM,-0.047499094504814154,ADVI +994,ENO,0.1724784257219974,ADVI +994,PK,0.8750206687828167,ADVI +995,PGM,-0.06865292304461601,ADVI +995,ENO,0.16647338163033742,ADVI +995,PK,0.9021795414142785,ADVI +996,PGM,-0.06727046154902916,ADVI +996,ENO,0.17366269911601556,ADVI +996,PK,0.8936077624330137,ADVI +997,PGM,-0.0728996436408531,ADVI +997,ENO,0.18268483423076387,ADVI +997,PK,0.8902148094100892,ADVI +998,PGM,-0.10534588147396251,ADVI +998,ENO,0.1758386037223577,ADVI +998,PK,0.9295072777516047,ADVI +999,PGM,-0.0668066732731698,ADVI +999,ENO,0.19123985757214584,ADVI +999,PK,0.875566815701024,ADVI diff --git a/tests/test_data/expected_wu2004_FCC_posterior_NUTS.csv b/tests/test_data/expected_wu2004_FCC_posterior_NUTS.csv new file mode 100644 index 0000000..21d2198 --- /dev/null +++ b/tests/test_data/expected_wu2004_FCC_posterior_NUTS.csv @@ -0,0 +1,1501 @@ +,level_1,0,type +0,PGM,-0.17171420278173133,NUTS +0,ENO,0.16610363981601825,NUTS +0,PK,1.005610562965713,NUTS +1,PGM,-0.18412749841279585,NUTS +1,ENO,0.21217571790120449,NUTS +1,PK,0.9719517805115913,NUTS +2,PGM,-0.23663301866537734,NUTS +2,ENO,0.1751322122926237,NUTS +2,PK,1.0615008063727538,NUTS +3,PGM,0.0361940873718648,NUTS +3,ENO,0.19538586296742547,NUTS +3,PK,0.7684200496607096,NUTS +4,PGM,0.06977401424117635,NUTS +4,ENO,0.19242408020714544,NUTS +4,PK,0.7378019055516782,NUTS +5,PGM,-0.040334262989558,NUTS +5,ENO,0.1898628443196634,NUTS +5,PK,0.8504714186698946,NUTS +6,PGM,-0.0446491408774603,NUTS +6,ENO,0.1846781876724167,NUTS +6,PK,0.8599709532050437,NUTS +7,PGM,-0.003967458957565118,NUTS +7,ENO,0.1952458669350262,NUTS +7,PK,0.808721592022539,NUTS +8,PGM,-0.006963948687287669,NUTS +8,ENO,0.20786989626497113,NUTS +8,PK,0.7990940524223165,NUTS +9,PGM,-0.17416478367485055,NUTS +9,ENO,0.134380073412231,NUTS +9,PK,1.0397847102626196,NUTS +10,PGM,0.036769780812309416,NUTS +10,ENO,0.152112275732319,NUTS +10,PK,0.8111179434553717,NUTS +11,PGM,-0.09765026185298042,NUTS +11,ENO,0.18999408027630568,NUTS +11,PK,0.9076561815766747,NUTS +12,PGM,0.057641739261441116,NUTS +12,ENO,0.1018505734066579,NUTS +12,PK,0.8405076873319011,NUTS +13,PGM,-0.18745550962315938,NUTS +13,ENO,0.18868158014589415,NUTS +13,PK,0.9987739294772653,NUTS +14,PGM,-0.21556169863580643,NUTS +14,ENO,0.17723225214478125,NUTS +14,PK,1.038329446491025,NUTS +15,PGM,-0.13950366647316348,NUTS +15,ENO,0.17831875969079544,NUTS +15,PK,0.961184906782368,NUTS +16,PGM,-0.14828756313360025,NUTS +16,ENO,0.18895217603499,NUTS +16,PK,0.9593353870986102,NUTS +17,PGM,0.056028617517903334,NUTS +17,ENO,0.2299463213411696,NUTS +17,PK,0.7140250611409271,NUTS +18,PGM,0.07185137337038139,NUTS +18,ENO,0.20938890942649363,NUTS +18,PK,0.7187597172031249,NUTS +19,PGM,0.01600272741462716,NUTS +19,ENO,0.17844579981139003,NUTS +19,PK,0.8055514727739829,NUTS +20,PGM,-0.019586350983592515,NUTS +20,ENO,0.24761661104794028,NUTS +20,PK,0.7719697399356522,NUTS +21,PGM,-0.12569318713079203,NUTS +21,ENO,0.16275717864314584,NUTS +21,PK,0.9629360084876463,NUTS +22,PGM,-0.06402558459880736,NUTS +22,ENO,0.2061598720723201,NUTS +22,PK,0.8578657125264871,NUTS +23,PGM,-0.14002260899129082,NUTS +23,ENO,0.2084756226938134,NUTS +23,PK,0.9315469862974773,NUTS +24,PGM,-0.15664625488368888,NUTS +24,ENO,0.18561743485870688,NUTS +24,PK,0.9710288200249818,NUTS +25,PGM,-0.09118370009497645,NUTS +25,ENO,0.1974457524080297,NUTS +25,PK,0.8937379476869467,NUTS +26,PGM,-0.04261569129317011,NUTS +26,ENO,0.1946893686633221,NUTS +26,PK,0.8479263226298481,NUTS +27,PGM,-0.032942803549824706,NUTS +27,ENO,0.23566790774005486,NUTS +27,PK,0.79727489580977,NUTS +28,PGM,-0.204117768532869,NUTS +28,ENO,0.18209521252382613,NUTS +28,PK,1.0220225560090428,NUTS +29,PGM,-0.12043609903303953,NUTS +29,ENO,0.2063300088788051,NUTS +29,PK,0.9141060901542344,NUTS +30,PGM,-0.10708324942653702,NUTS +30,ENO,0.19012000669094276,NUTS +30,PK,0.9169632427355943,NUTS +31,PGM,-0.1543780703846307,NUTS +31,ENO,0.20675377523957061,NUTS +31,PK,0.9476242951450601,NUTS +32,PGM,-0.08917846609677116,NUTS +32,ENO,0.19005980875817283,NUTS +32,PK,0.8991186573385983,NUTS +33,PGM,-0.2000430549455534,NUTS +33,ENO,0.16502060878190852,NUTS +33,PK,1.0350224461636448,NUTS +34,PGM,-0.07260790562427766,NUTS +34,ENO,0.17408059688425948,NUTS +34,PK,0.8985273087400181,NUTS +35,PGM,0.1639345258586854,NUTS +35,ENO,0.1752535099874053,NUTS +35,PK,0.6608119641539093,NUTS +36,PGM,0.17500613339237525,NUTS +36,ENO,0.21172886843404295,NUTS +36,PK,0.6132649981735818,NUTS +37,PGM,0.07279675058400403,NUTS +37,ENO,0.21856723104864526,NUTS +37,PK,0.7086360183673507,NUTS +38,PGM,-0.20058907297590722,NUTS +38,ENO,0.20665568121255826,NUTS +38,PK,0.9939333917633489,NUTS +39,PGM,-0.06918595378427517,NUTS +39,ENO,0.22466791886020585,NUTS +39,PK,0.8445180349240694,NUTS +40,PGM,-0.021421409418028947,NUTS +40,ENO,0.15016148764663925,NUTS +40,PK,0.8712599217713897,NUTS +41,PGM,0.055470891381492415,NUTS +41,ENO,0.1903641672475389,NUTS +41,PK,0.7541649413709687,NUTS +42,PGM,0.1032479410325432,NUTS +42,ENO,0.20466443574935284,NUTS +42,PK,0.6920876232181039,NUTS +43,PGM,0.06315560235071704,NUTS +43,ENO,0.1646020787648016,NUTS +43,PK,0.7722423188844814,NUTS +44,PGM,0.07566853323898437,NUTS +44,ENO,0.1943108563638371,NUTS +44,PK,0.7300206103971786,NUTS +45,PGM,-0.21117052524842417,NUTS +45,ENO,0.15849627360059476,NUTS +45,PK,1.0526742516478294,NUTS +46,PGM,-0.13004915204720757,NUTS +46,ENO,0.18021544336636794,NUTS +46,PK,0.9498337086808395,NUTS +47,PGM,-0.09928607431809566,NUTS +47,ENO,0.17695090872527608,NUTS +47,PK,0.9223351655928198,NUTS +48,PGM,0.1026189707224826,NUTS +48,ENO,0.21726141319863315,NUTS +48,PK,0.6801196160788842,NUTS +49,PGM,0.06387543618270564,NUTS +49,ENO,0.2048993783050209,NUTS +49,PK,0.7312251855122734,NUTS +50,PGM,0.011831515294825623,NUTS +50,ENO,0.1953962338798663,NUTS +50,PK,0.7927722508253082,NUTS +51,PGM,0.004958613951119517,NUTS +51,ENO,0.20783041418922152,NUTS +51,PK,0.787210971859659,NUTS +52,PGM,-0.09552726860320737,NUTS +52,ENO,0.19001907826229888,NUTS +52,PK,0.9055081903409085,NUTS +53,PGM,-0.059996349578401276,NUTS +53,ENO,0.19485608745972308,NUTS +53,PK,0.8651402621186782,NUTS +54,PGM,0.04050098051281603,NUTS +54,ENO,0.14644366022765845,NUTS +54,PK,0.8130553592595255,NUTS +55,PGM,-0.021932294695083954,NUTS +55,ENO,0.21589051518944183,NUTS +55,PK,0.8060417795056422,NUTS +56,PGM,-0.0352409161635181,NUTS +56,ENO,0.1955875431321497,NUTS +56,PK,0.8396533730313684,NUTS +57,PGM,-0.01777205554118577,NUTS +57,ENO,0.1918987131734874,NUTS +57,PK,0.8258733423676985,NUTS +58,PGM,-0.1439896528811866,NUTS +58,ENO,0.1966021887792394,NUTS +58,PK,0.9473874641019471,NUTS +59,PGM,-0.12435390576470207,NUTS +59,ENO,0.19758087699463253,NUTS +59,PK,0.9267730287700696,NUTS +60,PGM,-0.09168882467706596,NUTS +60,ENO,0.19111770111016577,NUTS +60,PK,0.9005711235669003,NUTS +61,PGM,-0.20785093255187048,NUTS +61,ENO,0.16777127943769304,NUTS +61,PK,1.0400796531141776,NUTS +62,PGM,0.135021041889394,NUTS +62,ENO,0.18883114208316185,NUTS +62,PK,0.6761478160274441,NUTS +63,PGM,0.08326280065816793,NUTS +63,ENO,0.16976558176988615,NUTS +63,PK,0.7469716175719457,NUTS +64,PGM,0.08118190497863631,NUTS +64,ENO,0.1617393821796435,NUTS +64,PK,0.7570787128417202,NUTS +65,PGM,0.04819632818987574,NUTS +65,ENO,0.16801525921209107,NUTS +65,PK,0.7837884125980332,NUTS +66,PGM,-0.02675075508363034,NUTS +66,ENO,0.15141044328453443,NUTS +66,PK,0.875340311799096,NUTS +67,PGM,0.06849670996154555,NUTS +67,ENO,0.12521595876107575,NUTS +67,PK,0.8062873312773787,NUTS +68,PGM,0.07553203724859969,NUTS +68,ENO,0.15477387275628762,NUTS +68,PK,0.7696940899951127,NUTS +69,PGM,-0.11207913565853733,NUTS +69,ENO,0.22666992648342513,NUTS +69,PK,0.8854092091751122,NUTS +70,PGM,-0.09228484908202761,NUTS +70,ENO,0.22579203477512574,NUTS +70,PK,0.866492814306902,NUTS +71,PGM,-0.07244159391673044,NUTS +71,ENO,0.1692477667084566,NUTS +71,PK,0.9031938272082738,NUTS +72,PGM,-0.10096906829698704,NUTS +72,ENO,0.21760791829262768,NUTS +72,PK,0.8833611500043594,NUTS +73,PGM,-0.09208811456389054,NUTS +73,ENO,0.18794170741320831,NUTS +73,PK,0.9041464071506821,NUTS +74,PGM,-0.04100509631672167,NUTS +74,ENO,0.18129594775518945,NUTS +74,PK,0.8597091485615322,NUTS +75,PGM,-0.09834102160999514,NUTS +75,ENO,0.17242666630475167,NUTS +75,PK,0.9259143553052435,NUTS +76,PGM,-0.08809389007959512,NUTS +76,ENO,0.17357152736284936,NUTS +76,PK,0.9145223627167458,NUTS +77,PGM,-0.23824851666663527,NUTS +77,ENO,0.17251443966375313,NUTS +77,PK,1.0657340770028823,NUTS +78,PGM,-0.207312642432411,NUTS +78,ENO,0.18547091067648636,NUTS +78,PK,1.0218417317559247,NUTS +79,PGM,-0.14133837646332315,NUTS +79,ENO,0.17314062400748498,NUTS +79,PK,0.9681977524558383,NUTS +80,PGM,-0.15511259316431536,NUTS +80,ENO,0.19705067747026048,NUTS +80,PK,0.9580619156940549,NUTS +81,PGM,-0.12046540696245911,NUTS +81,ENO,0.13911404985232206,NUTS +81,PK,0.9813513571101371,NUTS +82,PGM,-0.13961009316539785,NUTS +82,ENO,0.21646380828218828,NUTS +82,PK,0.9231462848832096,NUTS +83,PGM,-0.10298403177883375,NUTS +83,ENO,0.1875574566164944,NUTS +83,PK,0.9154265751623394,NUTS +84,PGM,-0.044378910179224684,NUTS +84,ENO,0.17149365528329474,NUTS +84,PK,0.8728852548959298,NUTS +85,PGM,-0.024820854209775867,NUTS +85,ENO,0.18300178360115707,NUTS +85,PK,0.8418190706086187,NUTS +86,PGM,-0.03594880530537736,NUTS +86,ENO,0.18232542970991256,NUTS +86,PK,0.8536233755954648,NUTS +87,PGM,-0.024152002600366984,NUTS +87,ENO,0.1809482890398762,NUTS +87,PK,0.843203713560491,NUTS +88,PGM,-0.003558035200927012,NUTS +88,ENO,0.22312751217057863,NUTS +88,PK,0.7804305230303482,NUTS +89,PGM,0.1325371441979315,NUTS +89,ENO,0.20873875542569736,NUTS +89,PK,0.6587241003763712,NUTS +90,PGM,0.0910061811490358,NUTS +90,ENO,0.2175656113744109,NUTS +90,PK,0.6914282074765532,NUTS +91,PGM,0.169434396730058,NUTS +91,ENO,0.20376921847295426,NUTS +91,PK,0.6267963847969877,NUTS +92,PGM,0.014025160230324407,NUTS +92,ENO,0.23677525975901753,NUTS +92,PK,0.749199580010658,NUTS +93,PGM,0.041688372633659876,NUTS +93,ENO,0.19336634570785077,NUTS +93,PK,0.7649452816584894,NUTS +94,PGM,-0.1213993735591572,NUTS +94,ENO,0.22742516022185608,NUTS +94,PK,0.8939742133373011,NUTS +95,PGM,-0.17294549269435988,NUTS +95,ENO,0.22639495125418194,NUTS +95,PK,0.946550541440178,NUTS +96,PGM,-0.0607611006424722,NUTS +96,ENO,0.20725855689155268,NUTS +96,PK,0.8535025437509196,NUTS +97,PGM,-0.11203773622207991,NUTS +97,ENO,0.1750067772922131,NUTS +97,PK,0.9370309589298668,NUTS +98,PGM,-0.2712158599230552,NUTS +98,ENO,0.16305477546822808,NUTS +98,PK,1.1081610844548273,NUTS +99,PGM,-0.21645177343138755,NUTS +99,ENO,0.15863907418716094,NUTS +99,PK,1.0578126992442267,NUTS +100,PGM,-0.10528150678213288,NUTS +100,ENO,0.2030802969082614,NUTS +100,PK,0.9022012098738715,NUTS +101,PGM,-0.15340902344296214,NUTS +101,ENO,0.20792749154387274,NUTS +101,PK,0.9454815318990893,NUTS +102,PGM,-0.18315639868133782,NUTS +102,ENO,0.17868235200607369,NUTS +102,PK,1.004474046675264,NUTS +103,PGM,-0.176574440333106,NUTS +103,ENO,0.20938731703195992,NUTS +103,PK,0.9671871233011462,NUTS +104,PGM,-0.18560369246238984,NUTS +104,ENO,0.20213708656779864,NUTS +104,PK,0.9834666058945913,NUTS +105,PGM,0.01471016370035505,NUTS +105,ENO,0.1801760457278848,NUTS +105,PK,0.8051137905717601,NUTS +106,PGM,-0.019416961303483582,NUTS +106,ENO,0.17077679504156534,NUTS +106,PK,0.8486401662619183,NUTS +107,PGM,-0.03818999572502535,NUTS +107,ENO,0.15517802764630148,NUTS +107,PK,0.8830119680787238,NUTS +108,PGM,-0.012737418377720022,NUTS +108,ENO,0.1950819894251884,NUTS +108,PK,0.8176554289525317,NUTS +109,PGM,-0.013566194618873872,NUTS +109,ENO,0.19182258755275614,NUTS +109,PK,0.8217436070661178,NUTS +110,PGM,-0.06283409048137756,NUTS +110,ENO,0.17475124503940354,NUTS +110,PK,0.8880828454419739,NUTS +111,PGM,-0.1263013611238495,NUTS +111,ENO,0.16633044201811306,NUTS +111,PK,0.9599709191057363,NUTS +112,PGM,-0.15396415955065135,NUTS +112,ENO,0.1647516560488051,NUTS +112,PK,0.9892125035018463,NUTS +113,PGM,-0.1061992033501038,NUTS +113,ENO,0.17971012576174616,NUTS +113,PK,0.9264890775883576,NUTS +114,PGM,-0.10877707983564511,NUTS +114,ENO,0.18053239861356982,NUTS +114,PK,0.9282446812220753,NUTS +115,PGM,-0.077659187230805,NUTS +115,ENO,0.20062919535969612,NUTS +115,PK,0.877029991871109,NUTS +116,PGM,0.09566880189094418,NUTS +116,ENO,0.16167608707875714,NUTS +116,PK,0.7426551110302987,NUTS +117,PGM,-0.055690505478168895,NUTS +117,ENO,0.17194731153694717,NUTS +117,PK,0.8837431939412218,NUTS +118,PGM,-0.07262772271354767,NUTS +118,ENO,0.15891071666469303,NUTS +118,PK,0.9137170060488548,NUTS +119,PGM,-0.014932191903185288,NUTS +119,ENO,0.1583738224159792,NUTS +119,PK,0.8565583694872061,NUTS +120,PGM,-0.01692726198840977,NUTS +120,ENO,0.1871766469873092,NUTS +120,PK,0.8297506150011005,NUTS +121,PGM,-0.15165427523568997,NUTS +121,ENO,0.20195600642741718,NUTS +121,PK,0.9496982688082727,NUTS +122,PGM,-0.05853591742127007,NUTS +122,ENO,0.18946827542437789,NUTS +122,PK,0.8690676419968922,NUTS +123,PGM,-0.035628003879561554,NUTS +123,ENO,0.1892591748719608,NUTS +123,PK,0.8463688290076007,NUTS +124,PGM,0.056757768155485944,NUTS +124,ENO,0.16761696723441863,NUTS +124,PK,0.7756252646100954,NUTS +125,PGM,-0.024664250856129,NUTS +125,ENO,0.16158770374676765,NUTS +125,PK,0.8630765471093614,NUTS +126,PGM,-0.04914992113941419,NUTS +126,ENO,0.17000377887479043,NUTS +126,PK,0.8791461422646237,NUTS +127,PGM,-0.10760305909540047,NUTS +127,ENO,0.18932242299850957,NUTS +127,PK,0.9182806360968909,NUTS +128,PGM,0.05986604925338701,NUTS +128,ENO,0.17848276437471763,NUTS +128,PK,0.7616511863718954,NUTS +129,PGM,0.10650084610397448,NUTS +129,ENO,0.20344573911184896,NUTS +129,PK,0.6900534147841766,NUTS +130,PGM,0.12172155017862218,NUTS +130,ENO,0.22185174195026156,NUTS +130,PK,0.6564267078711163,NUTS +131,PGM,0.18923475384862465,NUTS +131,ENO,0.20948124815603178,NUTS +131,PK,0.6012839979953435,NUTS +132,PGM,0.27487447522513087,NUTS +132,ENO,0.19765822780949374,NUTS +132,PK,0.5274672969653754,NUTS +133,PGM,0.2679058267813994,NUTS +133,ENO,0.1733618945492755,NUTS +133,PK,0.5587322786693251,NUTS +134,PGM,0.2051151477567973,NUTS +134,ENO,0.22651656248029162,NUTS +134,PK,0.5683682897629111,NUTS +135,PGM,0.20119991247153535,NUTS +135,ENO,0.22218943351003048,NUTS +135,PK,0.5766106540184343,NUTS +136,PGM,0.21351315492164713,NUTS +136,ENO,0.2361650478726266,NUTS +136,PK,0.5503217972057263,NUTS +137,PGM,-0.18173725454237322,NUTS +137,ENO,0.1808993623605164,NUTS +137,PK,1.0008378921818568,NUTS +138,PGM,0.053176197547882165,NUTS +138,ENO,0.24659934788395524,NUTS +138,PK,0.7002244545681627,NUTS +139,PGM,-0.01867451865254699,NUTS +139,ENO,0.22386195666871533,NUTS +139,PK,0.7948125619838318,NUTS +140,PGM,-0.08249887057217142,NUTS +140,ENO,0.2156877029613576,NUTS +140,PK,0.8668111676108138,NUTS +141,PGM,0.2204218120098833,NUTS +141,ENO,0.21533998281467423,NUTS +141,PK,0.5642382051754425,NUTS +142,PGM,0.13345582641738307,NUTS +142,ENO,0.2286125192599084,NUTS +142,PK,0.6379316543227086,NUTS +143,PGM,0.18130121054468173,NUTS +143,ENO,0.2439463477437591,NUTS +143,PK,0.5747524417115591,NUTS +144,PGM,0.18498623495542155,NUTS +144,ENO,0.20308295517203342,NUTS +144,PK,0.6119308098725451,NUTS +145,PGM,0.20616908974805526,NUTS +145,ENO,0.19676520066279737,NUTS +145,PK,0.5970657095891474,NUTS +146,PGM,0.14008260363144265,NUTS +146,ENO,0.18785838273412744,NUTS +146,PK,0.6720590136344299,NUTS +147,PGM,0.1620527327028617,NUTS +147,ENO,0.1803051788478038,NUTS +147,PK,0.6576420884493345,NUTS +148,PGM,-0.2320686989846461,NUTS +148,ENO,0.14747221711670988,NUTS +148,PK,1.0845964818679363,NUTS +149,PGM,-0.09878338115248475,NUTS +149,ENO,0.17573621399049905,NUTS +149,PK,0.9230471671619858,NUTS +150,PGM,-0.1826979843383154,NUTS +150,ENO,0.17801547212316962,NUTS +150,PK,1.0046825122151457,NUTS +151,PGM,-0.187793475612547,NUTS +151,ENO,0.17811440982166427,NUTS +151,PK,1.0096790657908827,NUTS +152,PGM,-0.15131731450935315,NUTS +152,ENO,0.17474933223574288,NUTS +152,PK,0.9765679822736102,NUTS +153,PGM,-0.15983955907391034,NUTS +153,ENO,0.21954576048194488,NUTS +153,PK,0.9402937985919655,NUTS +154,PGM,-0.13539919683890167,NUTS +154,ENO,0.1905539455256058,NUTS +154,PK,0.944845251313296,NUTS +155,PGM,-0.2790309176200323,NUTS +155,ENO,0.16157738911680958,NUTS +155,PK,1.1174535285032228,NUTS +156,PGM,-0.19142930028464478,NUTS +156,ENO,0.1916803733176908,NUTS +156,PK,0.9997489269669539,NUTS +157,PGM,-0.1654624452177229,NUTS +157,ENO,0.16287024908685044,NUTS +157,PK,1.0025921961308724,NUTS +158,PGM,-0.17886138451315725,NUTS +158,ENO,0.1594621649532844,NUTS +158,PK,1.019399219559873,NUTS +159,PGM,-0.01834410387007357,NUTS +159,ENO,0.20812978762836282,NUTS +159,PK,0.8102143162417107,NUTS +160,PGM,-0.06816162669348413,NUTS +160,ENO,0.189290726797107,NUTS +160,PK,0.8788708998963771,NUTS +161,PGM,-0.04016114949517258,NUTS +161,ENO,0.2132642668606096,NUTS +161,PK,0.826896882634563,NUTS +162,PGM,0.0007956016106615005,NUTS +162,ENO,0.2272389278272598,NUTS +162,PK,0.7719654705620786,NUTS +163,PGM,-2.586184589237206e-05,NUTS +163,ENO,0.23930903220077607,NUTS +163,PK,0.7607168296451162,NUTS +164,PGM,0.006331869273855983,NUTS +164,ENO,0.21650036186935953,NUTS +164,PK,0.7771677688567845,NUTS +165,PGM,-0.16826201195528423,NUTS +165,ENO,0.2003143828414509,NUTS +165,PK,0.9679476291138335,NUTS +166,PGM,-0.054457303151046244,NUTS +166,ENO,0.21600989511861557,NUTS +166,PK,0.8384474080324307,NUTS +167,PGM,-0.1334660418983029,NUTS +167,ENO,0.1925433023299254,NUTS +167,PK,0.9409227395683776,NUTS +168,PGM,-0.22810853753973648,NUTS +168,ENO,0.19803554414367663,NUTS +168,PK,1.03007299339606,NUTS +169,PGM,-0.19641519514634997,NUTS +169,ENO,0.17471085546193693,NUTS +169,PK,1.021704339684413,NUTS +170,PGM,-0.2590507554616528,NUTS +170,ENO,0.18951610109999475,NUTS +170,PK,1.069534654361658,NUTS +171,PGM,-0.2422176657351609,NUTS +171,ENO,0.183352134929162,NUTS +171,PK,1.0588655308059989,NUTS +172,PGM,0.2802306673759839,NUTS +172,ENO,0.1891995768042335,NUTS +172,PK,0.5305697558197826,NUTS +173,PGM,0.26474834740302233,NUTS +173,ENO,0.14564263095771263,NUTS +173,PK,0.5896090216392651,NUTS +174,PGM,0.24928959571663867,NUTS +174,ENO,0.18471596736960247,NUTS +174,PK,0.5659944369137588,NUTS +175,PGM,0.09311579229561562,NUTS +175,ENO,0.15938954468037747,NUTS +175,PK,0.7474946630240069,NUTS +176,PGM,0.0913111660134669,NUTS +176,ENO,0.16095950271431267,NUTS +176,PK,0.7477293312722205,NUTS +177,PGM,0.02092431931059302,NUTS +177,ENO,0.16846630388539427,NUTS +177,PK,0.8106093768040127,NUTS +178,PGM,0.023426615166676656,NUTS +178,ENO,0.17756454173808164,NUTS +178,PK,0.7990088430952418,NUTS +179,PGM,-0.2469861697237139,NUTS +179,ENO,0.16995947664154903,NUTS +179,PK,1.0770266930821648,NUTS +180,PGM,-0.2545014823082159,NUTS +180,ENO,0.1442216905712963,NUTS +180,PK,1.1102797917369196,NUTS +181,PGM,-0.19125999662274684,NUTS +181,ENO,0.18179195487452743,NUTS +181,PK,1.0094680417482196,NUTS +182,PGM,-0.20176113058424172,NUTS +182,ENO,0.1790394625269805,NUTS +182,PK,1.022721668057261,NUTS +183,PGM,-0.13144132053695956,NUTS +183,ENO,0.20613091161530514,NUTS +183,PK,0.9253104089216544,NUTS +184,PGM,-0.14374096017492666,NUTS +184,ENO,0.19517976320985772,NUTS +184,PK,0.9485611969650688,NUTS +185,PGM,-0.17672327564352486,NUTS +185,ENO,0.20955457824214582,NUTS +185,PK,0.9671686974013791,NUTS +186,PGM,-0.0558569530412929,NUTS +186,ENO,0.13264889763451598,NUTS +186,PK,0.923208055406777,NUTS +187,PGM,-0.00407577172231588,NUTS +187,ENO,0.23947389874285088,NUTS +187,PK,0.7646018729794649,NUTS +188,PGM,-0.17157546522376177,NUTS +188,ENO,0.15855651826002573,NUTS +188,PK,1.013018946963736,NUTS +189,PGM,-0.13325391663098696,NUTS +189,ENO,0.1493268819177093,NUTS +189,PK,0.9839270347132777,NUTS +190,PGM,-0.2171544953291531,NUTS +190,ENO,0.15934781002249485,NUTS +190,PK,1.0578066853066581,NUTS +191,PGM,-0.08658559865295024,NUTS +191,ENO,0.241216164358616,NUTS +191,PK,0.8453694342943342,NUTS +192,PGM,-0.23114144493725797,NUTS +192,ENO,0.24035782439170134,NUTS +192,PK,0.9907836205455567,NUTS +193,PGM,-0.14875689825703908,NUTS +193,ENO,0.2436710136106326,NUTS +193,PK,0.9050858846464065,NUTS +194,PGM,-0.02719482037707488,NUTS +194,ENO,0.18943985758473136,NUTS +194,PK,0.8377549627923435,NUTS +195,PGM,0.14247778289018354,NUTS +195,ENO,0.2416341514680786,NUTS +195,PK,0.6158880656417378,NUTS +196,PGM,0.13591803481881537,NUTS +196,ENO,0.211958369756788,NUTS +196,PK,0.6521235954243967,NUTS +197,PGM,-0.3267417510448294,NUTS +197,ENO,0.17498576524829387,NUTS +197,PK,1.1517559857965356,NUTS +198,PGM,-0.3470380743404091,NUTS +198,ENO,0.17025261444367584,NUTS +198,PK,1.1767854598967333,NUTS +199,PGM,-0.10598679853503046,NUTS +199,ENO,0.17593420829127968,NUTS +199,PK,0.9300525902437506,NUTS +200,PGM,-0.07045410513515793,NUTS +200,ENO,0.1659331100086908,NUTS +200,PK,0.9045209951264672,NUTS +201,PGM,-0.03137366673765496,NUTS +201,ENO,0.20356711197951416,NUTS +201,PK,0.8278065547581408,NUTS +202,PGM,0.010056472843016695,NUTS +202,ENO,0.2118599613297602,NUTS +202,PK,0.7780835658272232,NUTS +203,PGM,-0.014949333031240242,NUTS +203,ENO,0.21163818309374882,NUTS +203,PK,0.8033111499374914,NUTS +204,PGM,-0.1525156428577208,NUTS +204,ENO,0.15519260118805167,NUTS +204,PK,0.9973230416696692,NUTS +205,PGM,-0.19316323729051543,NUTS +205,ENO,0.19082231148092169,NUTS +205,PK,1.0023409258095939,NUTS +206,PGM,-0.10038179482746745,NUTS +206,ENO,0.161877553386418,NUTS +206,PK,0.9385042414410494,NUTS +207,PGM,-0.16026392949815738,NUTS +207,ENO,0.1658706683300516,NUTS +207,PK,0.9943932611681059,NUTS +208,PGM,0.006139144394503249,NUTS +208,ENO,0.19591267107084273,NUTS +208,PK,0.7979481845346541,NUTS +209,PGM,-0.03681631456202661,NUTS +209,ENO,0.16635815248667124,NUTS +209,PK,0.8704581620753554,NUTS +210,PGM,-0.03448425413644585,NUTS +210,ENO,0.1919979926819385,NUTS +210,PK,0.8424862614545074,NUTS +211,PGM,-0.12790188360970078,NUTS +211,ENO,0.13557534016976566,NUTS +211,PK,0.9923265434399351,NUTS +212,PGM,-0.04595250133941953,NUTS +212,ENO,0.1722137463645176,NUTS +212,PK,0.8737387549749018,NUTS +213,PGM,0.016370731220112344,NUTS +213,ENO,0.18372991037369935,NUTS +213,PK,0.7998993584061883,NUTS +214,PGM,0.0033110159517975024,NUTS +214,ENO,0.1479830287012242,NUTS +214,PK,0.8487059553469783,NUTS +215,PGM,-0.06215455091736022,NUTS +215,ENO,0.13458247142464014,NUTS +215,PK,0.92757207949272,NUTS +216,PGM,-0.12138837474236008,NUTS +216,ENO,0.19370348136472143,NUTS +216,PK,0.9276848933776386,NUTS +217,PGM,0.02898200692932551,NUTS +217,ENO,0.1995315663848462,NUTS +217,PK,0.7714864266858283,NUTS +218,PGM,0.025565713447869842,NUTS +218,ENO,0.19184499341547182,NUTS +218,PK,0.7825892931366584,NUTS +219,PGM,0.06683912324096197,NUTS +219,ENO,0.20386418732168538,NUTS +219,PK,0.7292966894373526,NUTS +220,PGM,-0.22159851547088372,NUTS +220,ENO,0.1896612456371953,NUTS +220,PK,1.0319372698336884,NUTS +221,PGM,0.06033796876874453,NUTS +221,ENO,0.17326828158635363,NUTS +221,PK,0.7663937496449018,NUTS +222,PGM,-0.028945724508270265,NUTS +222,ENO,0.17716383674867833,NUTS +222,PK,0.851781887759592,NUTS +223,PGM,0.19106828089204886,NUTS +223,ENO,0.20335454921517399,NUTS +223,PK,0.6055771698927772,NUTS +224,PGM,0.09663317656060644,NUTS +224,ENO,0.19045970652399022,NUTS +224,PK,0.7129071169154033,NUTS +225,PGM,-0.06031354139791634,NUTS +225,ENO,0.17997561241459606,NUTS +225,PK,0.8803379289833202,NUTS +226,PGM,-0.18068363569752677,NUTS +226,ENO,0.16793295671227276,NUTS +226,PK,1.0127506789852543,NUTS +227,PGM,-0.2803995065235394,NUTS +227,ENO,0.18192409251198172,NUTS +227,PK,1.0984754140115576,NUTS +228,PGM,0.1952452075532356,NUTS +228,ENO,0.15044810449314297,NUTS +228,PK,0.6543066879536215,NUTS +229,PGM,-0.07866103832483895,NUTS +229,ENO,0.17049888689930637,NUTS +229,PK,0.9081621514255325,NUTS +230,PGM,-0.0006736050284383843,NUTS +230,ENO,0.1795175421584888,NUTS +230,PK,0.8211560628699496,NUTS +231,PGM,-0.014650941339724,NUTS +231,ENO,0.16574191572286012,NUTS +231,PK,0.8489090256168638,NUTS +232,PGM,-0.035826098948662066,NUTS +232,ENO,0.14889241283241028,NUTS +232,PK,0.8869336861162518,NUTS +233,PGM,-0.1274682856373197,NUTS +233,ENO,0.17897649386743297,NUTS +233,PK,0.9484917917698866,NUTS +234,PGM,-0.1654383733931264,NUTS +234,ENO,0.1805429774952048,NUTS +234,PK,0.9848953958979216,NUTS +235,PGM,-0.06009866516664397,NUTS +235,ENO,0.2009392215708698,NUTS +235,PK,0.8591594435957742,NUTS +236,PGM,-0.05588962827362498,NUTS +236,ENO,0.1547317611802247,NUTS +236,PK,0.9011578670934004,NUTS +237,PGM,-0.090409465837888,NUTS +237,ENO,0.1617674083250671,NUTS +237,PK,0.928642057512821,NUTS +238,PGM,-0.26774846966541,NUTS +238,ENO,0.19532761812464686,NUTS +238,PK,1.072420851540763,NUTS +239,PGM,-0.26799613710560477,NUTS +239,ENO,0.19040723579092184,NUTS +239,PK,1.0775889013146829,NUTS +240,PGM,-0.2700380979185797,NUTS +240,ENO,0.18490768011440908,NUTS +240,PK,1.0851304178041705,NUTS +241,PGM,-0.16067755950790397,NUTS +241,ENO,0.1740774322862117,NUTS +241,PK,0.9866001272216922,NUTS +242,PGM,-0.13767626778900355,NUTS +242,ENO,0.17690248984840762,NUTS +242,PK,0.960773777940596,NUTS +243,PGM,-0.1347139216684936,NUTS +243,ENO,0.156574737402806,NUTS +243,PK,0.9781391842656877,NUTS +244,PGM,-0.1307747590511179,NUTS +244,ENO,0.20198239023484157,NUTS +244,PK,0.9287923688162764,NUTS +245,PGM,-0.0662226212559891,NUTS +245,ENO,0.15650686203180775,NUTS +245,PK,0.9097157592241812,NUTS +246,PGM,-0.2000488690290858,NUTS +246,ENO,0.1387616480920128,NUTS +246,PK,1.0612872209370732,NUTS +247,PGM,-0.14537387625956577,NUTS +247,ENO,0.1430825125597034,NUTS +247,PK,1.0022913636998623,NUTS +248,PGM,-0.23055378842443175,NUTS +248,ENO,0.15713274373106398,NUTS +248,PK,1.0734210446933679,NUTS +249,PGM,-0.13950230694516486,NUTS +249,ENO,0.14710234859700053,NUTS +249,PK,0.9923999583481643,NUTS +250,PGM,-0.026790132438243575,NUTS +250,ENO,0.2363107120621626,NUTS +250,PK,0.790479420376081,NUTS +251,PGM,-0.08789708189608936,NUTS +251,ENO,0.20852822635206475,NUTS +251,PK,0.8793688555440247,NUTS +252,PGM,-0.05479180870137679,NUTS +252,ENO,0.1517276872787931,NUTS +252,PK,0.9030641214225835,NUTS +253,PGM,-0.13601906212545578,NUTS +253,ENO,0.17326761056418005,NUTS +253,PK,0.9627514515612758,NUTS +254,PGM,0.0673719316493947,NUTS +254,ENO,0.1806716108324771,NUTS +254,PK,0.7519564575181282,NUTS +255,PGM,0.06946697789415734,NUTS +255,ENO,0.1977046606434145,NUTS +255,PK,0.7328283614624282,NUTS +256,PGM,-0.16192703639231643,NUTS +256,ENO,0.18699542681856005,NUTS +256,PK,0.9749316095737564,NUTS +257,PGM,-0.20074118885225412,NUTS +257,ENO,0.20189579427858842,NUTS +257,PK,0.9988453945736656,NUTS +258,PGM,0.20392798179642002,NUTS +258,ENO,0.18542327712931334,NUTS +258,PK,0.6106487410742667,NUTS +259,PGM,0.17347204475263311,NUTS +259,ENO,0.2210422509115236,NUTS +259,PK,0.6054857043358433,NUTS +260,PGM,0.0894745347891226,NUTS +260,ENO,0.21080363852810094,NUTS +260,PK,0.6997218266827765,NUTS +261,PGM,0.2428261901874733,NUTS +261,ENO,0.22502833729749006,NUTS +261,PK,0.5321454725150366,NUTS +262,PGM,0.12157092190632668,NUTS +262,ENO,0.22949939685345502,NUTS +262,PK,0.6489296812402183,NUTS +263,PGM,-0.10182269954263701,NUTS +263,ENO,0.16915636094118147,NUTS +263,PK,0.9326663386014555,NUTS +264,PGM,0.0036043413206950925,NUTS +264,ENO,0.18368199551665465,NUTS +264,PK,0.8127136631626504,NUTS +265,PGM,0.0024889923470726716,NUTS +265,ENO,0.18454626088030104,NUTS +265,PK,0.8129647467726262,NUTS +266,PGM,0.057313240467741555,NUTS +266,ENO,0.18111019253011276,NUTS +266,PK,0.7615765670021457,NUTS +267,PGM,-0.0360639355514778,NUTS +267,ENO,0.2155582245353121,NUTS +267,PK,0.8205057110161658,NUTS +268,PGM,-0.04060905369695167,NUTS +268,ENO,0.15890386536773463,NUTS +268,PK,0.8817051883292168,NUTS +269,PGM,0.0008782458891836153,NUTS +269,ENO,0.19931752171629152,NUTS +269,PK,0.7998042323945249,NUTS +270,PGM,0.026719190624915123,NUTS +270,ENO,0.16927086614196005,NUTS +270,PK,0.8040099432331248,NUTS +271,PGM,0.04685847345357186,NUTS +271,ENO,0.1722341330129595,NUTS +271,PK,0.7809073935334685,NUTS +272,PGM,0.02437305268992951,NUTS +272,ENO,0.13515852588844834,NUTS +272,PK,0.840468421421622,NUTS +273,PGM,0.0027749449955016825,NUTS +273,ENO,0.21570613463206,NUTS +273,PK,0.7815189203724382,NUTS +274,PGM,0.1330803513570673,NUTS +274,ENO,0.18763626160295185,NUTS +274,PK,0.6792833870399808,NUTS +275,PGM,0.13099513634199045,NUTS +275,ENO,0.19102981179318101,NUTS +275,PK,0.6779750518648285,NUTS +276,PGM,-0.06782561297926804,NUTS +276,ENO,0.19156699937104593,NUTS +276,PK,0.876258613608222,NUTS +277,PGM,-0.010738976649536491,NUTS +277,ENO,0.19399437981540396,NUTS +277,PK,0.8167445968341325,NUTS +278,PGM,-0.01855836484238438,NUTS +278,ENO,0.1878710747478937,NUTS +278,PK,0.8306872900944907,NUTS +279,PGM,0.02773616655832456,NUTS +279,ENO,0.17284857014276805,NUTS +279,PK,0.7994152632989074,NUTS +280,PGM,-0.00040509905179386685,NUTS +280,ENO,0.18094484047392942,NUTS +280,PK,0.8194602585778645,NUTS +281,PGM,0.04596644852233911,NUTS +281,ENO,0.16228994092360635,NUTS +281,PK,0.7917436105540545,NUTS +282,PGM,0.09579388195280758,NUTS +282,ENO,0.15763868576425635,NUTS +282,PK,0.7465674322829361,NUTS +283,PGM,0.05591175511579771,NUTS +283,ENO,0.15388806251507153,NUTS +283,PK,0.7902001823691307,NUTS +284,PGM,0.0496817072238529,NUTS +284,ENO,0.1500770630187147,NUTS +284,PK,0.8002412297574324,NUTS +285,PGM,0.13664036625000409,NUTS +285,ENO,0.1776690471218828,NUTS +285,PK,0.6856905866281132,NUTS +286,PGM,0.1288529163092802,NUTS +286,ENO,0.17262317164073682,NUTS +286,PK,0.6985239120499829,NUTS +287,PGM,0.016354480001357308,NUTS +287,ENO,0.23280997120100144,NUTS +287,PK,0.7508355487976411,NUTS +288,PGM,-0.04064516575889088,NUTS +288,ENO,0.21439246925541738,NUTS +288,PK,0.8262526965034735,NUTS +289,PGM,-0.17936411289018062,NUTS +289,ENO,0.2136396620130839,NUTS +289,PK,0.9657244508770967,NUTS +290,PGM,0.040623776589303384,NUTS +290,ENO,0.21439630405908158,NUTS +290,PK,0.744979919351615,NUTS +291,PGM,0.040740892194054745,NUTS +291,ENO,0.21833350141712898,NUTS +291,PK,0.7409256063888161,NUTS +292,PGM,-0.05586851976192375,NUTS +292,ENO,0.23079618530021268,NUTS +292,PK,0.825072334461711,NUTS +293,PGM,-0.12814010763734385,NUTS +293,ENO,0.19922660222478442,NUTS +293,PK,0.9289135054125593,NUTS +294,PGM,-0.14383054912282,NUTS +294,ENO,0.19836663055479764,NUTS +294,PK,0.9454639185680224,NUTS +295,PGM,-0.12982641837021447,NUTS +295,ENO,0.17230728716176363,NUTS +295,PK,0.9575191312084508,NUTS +296,PGM,-0.08123573048649435,NUTS +296,ENO,0.1763194683380777,NUTS +296,PK,0.9049162621484166,NUTS +297,PGM,-0.05158548785903605,NUTS +297,ENO,0.14934978265135626,NUTS +297,PK,0.9022357052076798,NUTS +298,PGM,-0.08102978579279285,NUTS +298,ENO,0.14727854492909895,NUTS +298,PK,0.9337512408636939,NUTS +299,PGM,-0.1365449868738906,NUTS +299,ENO,0.2044723572250765,NUTS +299,PK,0.9320726296488141,NUTS +300,PGM,0.13997987330596606,NUTS +300,ENO,0.16621389614032683,NUTS +300,PK,0.693806230553707,NUTS +301,PGM,0.11942645176813249,NUTS +301,ENO,0.15379102988845533,NUTS +301,PK,0.7267825183434122,NUTS +302,PGM,0.06367400411954616,NUTS +302,ENO,0.20047024738037006,NUTS +302,PK,0.7358557485000837,NUTS +303,PGM,-0.04348452576268724,NUTS +303,ENO,0.22697130923636646,NUTS +303,PK,0.8165132165263209,NUTS +304,PGM,0.04192317668753853,NUTS +304,ENO,0.1919885687963185,NUTS +304,PK,0.766088254516143,NUTS +305,PGM,0.021647283978449505,NUTS +305,ENO,0.17992252774924974,NUTS +305,PK,0.7984301882723007,NUTS +306,PGM,-0.0972565636007845,NUTS +306,ENO,0.215493758106249,NUTS +306,PK,0.8817628054945355,NUTS +307,PGM,-0.08828244090167137,NUTS +307,ENO,0.19468460011534214,NUTS +307,PK,0.8935978407863292,NUTS +308,PGM,0.10288798599072602,NUTS +308,ENO,0.17474931232544608,NUTS +308,PK,0.7223627016838279,NUTS +309,PGM,0.023478638834157906,NUTS +309,ENO,0.16327678463211032,NUTS +309,PK,0.8132445765337318,NUTS +310,PGM,0.12840263411366193,NUTS +310,ENO,0.15677597100686536,NUTS +310,PK,0.7148213948794727,NUTS +311,PGM,-0.0363541189876595,NUTS +311,ENO,0.19490870471104882,NUTS +311,PK,0.8414454142766108,NUTS +312,PGM,-0.027120859033177735,NUTS +312,ENO,0.19339114105411107,NUTS +312,PK,0.8337297179790668,NUTS +313,PGM,-0.07407512988132248,NUTS +313,ENO,0.19331224695249316,NUTS +313,PK,0.8807628829288293,NUTS +314,PGM,-0.12004612268741588,NUTS +314,ENO,0.18852261528652392,NUTS +314,PK,0.9315235074008918,NUTS +315,PGM,-0.14453976539907987,NUTS +315,ENO,0.1908350651659823,NUTS +315,PK,0.9537047002330976,NUTS +316,PGM,0.04894314123196475,NUTS +316,ENO,0.14259455359494758,NUTS +316,PK,0.8084623051730876,NUTS +317,PGM,0.05636042008162001,NUTS +317,ENO,0.1477152369525997,NUTS +317,PK,0.7959243429657803,NUTS +318,PGM,-0.1273847737401974,NUTS +318,ENO,0.16441412245470843,NUTS +318,PK,0.9629706512854889,NUTS +319,PGM,-0.09372483404278786,NUTS +319,ENO,0.1436926685886637,NUTS +319,PK,0.9500321654541243,NUTS +320,PGM,-0.18851688781535114,NUTS +320,ENO,0.14411126627755608,NUTS +320,PK,1.044405621537795,NUTS +321,PGM,-0.11696354261503039,NUTS +321,ENO,0.13818133548076927,NUTS +321,PK,0.978782207134261,NUTS +322,PGM,-0.06662824207454054,NUTS +322,ENO,0.18252035750160597,NUTS +322,PK,0.8841078845729347,NUTS +323,PGM,-0.3064519333169189,NUTS +323,ENO,0.17072176111927903,NUTS +323,PK,1.1357301721976396,NUTS +324,PGM,-0.19551376471648663,NUTS +324,ENO,0.13999646747798877,NUTS +324,PK,1.0555172972384979,NUTS +325,PGM,-0.1860153309211452,NUTS +325,ENO,0.1242356134660263,NUTS +325,PK,1.061779717455119,NUTS +326,PGM,-0.13007262267063502,NUTS +326,ENO,0.22603109185978656,NUTS +326,PK,0.9040415308108485,NUTS +327,PGM,-0.24627325546199508,NUTS +327,ENO,0.20300489506553215,NUTS +327,PK,1.043268360396463,NUTS +328,PGM,-0.17058726786916956,NUTS +328,ENO,0.17218588836633816,NUTS +328,PK,0.9984013795028315,NUTS +329,PGM,0.10873845348575628,NUTS +329,ENO,0.17364191967671605,NUTS +329,PK,0.7176196268375277,NUTS +330,PGM,0.03102539102420554,NUTS +330,ENO,0.17221064586742127,NUTS +330,PK,0.7967639631083733,NUTS +331,PGM,-0.14727150357586827,NUTS +331,ENO,0.19648796480187938,NUTS +331,PK,0.9507835387739889,NUTS +332,PGM,-0.23942114926773828,NUTS +332,ENO,0.15327812247987416,NUTS +332,PK,1.0861430267878642,NUTS +333,PGM,-0.14696578075783018,NUTS +333,ENO,0.22602148892912977,NUTS +333,PK,0.9209442918287003,NUTS +334,PGM,-0.09148380035903769,NUTS +334,ENO,0.2047287286529461,NUTS +334,PK,0.8867550717060916,NUTS +335,PGM,-0.08774776640421744,NUTS +335,ENO,0.2475950100662612,NUTS +335,PK,0.8401527563379562,NUTS +336,PGM,-0.02386235225533495,NUTS +336,ENO,0.21164799775449808,NUTS +336,PK,0.8122143545008368,NUTS +337,PGM,0.03124494897805241,NUTS +337,ENO,0.15256783492639575,NUTS +337,PK,0.8161872160955518,NUTS +338,PGM,-0.07257667739900198,NUTS +338,ENO,0.15608654124874594,NUTS +338,PK,0.9164901361502562,NUTS +339,PGM,-0.0542670131900338,NUTS +339,ENO,0.17611736417674625,NUTS +339,PK,0.8781496490132876,NUTS +340,PGM,-0.19272526291551295,NUTS +340,ENO,0.18818854320018255,NUTS +340,PK,1.0045367197153303,NUTS +341,PGM,-0.2663188171140898,NUTS +341,ENO,0.16155956023638657,NUTS +341,PK,1.1047592568777032,NUTS +342,PGM,-0.29520419421916744,NUTS +342,ENO,0.2036458108812924,NUTS +342,PK,1.091558383337875,NUTS +343,PGM,-0.13030782893973836,NUTS +343,ENO,0.18154750879203385,NUTS +343,PK,0.9487603201477044,NUTS +344,PGM,-0.24620884831264922,NUTS +344,ENO,0.1449440166867097,NUTS +344,PK,1.1012648316259395,NUTS +345,PGM,0.07392820734163164,NUTS +345,ENO,0.1624407294748912,NUTS +345,PK,0.7636310631834772,NUTS +346,PGM,0.12827246588463093,NUTS +346,ENO,0.22245601373428295,NUTS +346,PK,0.649271520381086,NUTS +347,PGM,0.1703552085501261,NUTS +347,ENO,0.16681289963640397,NUTS +347,PK,0.6628318918134699,NUTS +348,PGM,0.13895980005307362,NUTS +348,ENO,0.15350029025345918,NUTS +348,PK,0.7075399096934671,NUTS +349,PGM,-0.2726348953738673,NUTS +349,ENO,0.18765701538357307,NUTS +349,PK,1.0849778799902943,NUTS +350,PGM,-0.20567288691287144,NUTS +350,ENO,0.19676427549648806,NUTS +350,PK,1.0089086114163834,NUTS +351,PGM,-0.13676032949488492,NUTS +351,ENO,0.1761136324230144,NUTS +351,PK,0.9606466970718706,NUTS +352,PGM,-0.09970178869887203,NUTS +352,ENO,0.22064518988102302,NUTS +352,PK,0.8790565988178489,NUTS +353,PGM,0.154900031523586,NUTS +353,ENO,0.16026633123023162,NUTS +353,PK,0.6848336372461824,NUTS +354,PGM,0.06895727713589195,NUTS +354,ENO,0.1818837203454243,NUTS +354,PK,0.7491590025186837,NUTS +355,PGM,0.159633706802211,NUTS +355,ENO,0.19325825267391697,NUTS +355,PK,0.647108040523872,NUTS +356,PGM,-0.17853680976244046,NUTS +356,ENO,0.21046170635827968,NUTS +356,PK,0.9680751034041608,NUTS +357,PGM,0.009644325324952852,NUTS +357,ENO,0.14837393580953243,NUTS +357,PK,0.8419817388655149,NUTS +358,PGM,-0.13188991081306112,NUTS +358,ENO,0.1514746882049344,NUTS +358,PK,0.9804152226081267,NUTS +359,PGM,-0.20043284991465948,NUTS +359,ENO,0.18764031206996876,NUTS +359,PK,1.0127925378446907,NUTS +360,PGM,-0.3003047749170391,NUTS +360,ENO,0.18416676430304083,NUTS +360,PK,1.1161380106139982,NUTS +361,PGM,-0.28597232157818686,NUTS +361,ENO,0.14205975992130865,NUTS +361,PK,1.1439125616568784,NUTS +362,PGM,-0.3393686262622615,NUTS +362,ENO,0.15665912060263745,NUTS +362,PK,1.182709505659624,NUTS +363,PGM,-0.3757262935146388,NUTS +363,ENO,0.14851734070435288,NUTS +363,PK,1.2272089528102859,NUTS +364,PGM,-0.33890428639143333,NUTS +364,ENO,0.16700798257744764,NUTS +364,PK,1.1718963038139856,NUTS +365,PGM,-0.2775472462967752,NUTS +365,ENO,0.14779052743085389,NUTS +365,PK,1.1297567188659214,NUTS +366,PGM,-0.07634964382631626,NUTS +366,ENO,0.20974694920575115,NUTS +366,PK,0.866602694620565,NUTS +367,PGM,-0.025494159891703116,NUTS +367,ENO,0.2489044615303722,NUTS +367,PK,0.776589698361331,NUTS +368,PGM,0.019589619550335335,NUTS +368,ENO,0.25874850423323725,NUTS +368,PK,0.7216618762164275,NUTS +369,PGM,0.00926253955846712,NUTS +369,ENO,0.2682146229775479,NUTS +369,PK,0.7225228374639849,NUTS +370,PGM,0.16705149663641916,NUTS +370,ENO,0.20706063695378119,NUTS +370,PK,0.6258878664097997,NUTS +371,PGM,0.18912977259380193,NUTS +371,ENO,0.23157960423163543,NUTS +371,PK,0.5792906231745626,NUTS +372,PGM,0.19926267935958897,NUTS +372,ENO,0.21865159163754902,NUTS +372,PK,0.582085729002862,NUTS +373,PGM,-0.21297221818419687,NUTS +373,ENO,0.15689625032742816,NUTS +373,PK,1.0560759678567686,NUTS +374,PGM,0.0886325564455962,NUTS +374,ENO,0.20757534472774422,NUTS +374,PK,0.7037920988266596,NUTS +375,PGM,0.05183389297162588,NUTS +375,ENO,0.1913193014857987,NUTS +375,PK,0.7568468055425754,NUTS +376,PGM,0.10037981923307604,NUTS +376,ENO,0.15819290236144598,NUTS +376,PK,0.741427278405478,NUTS +377,PGM,0.11474997342544291,NUTS +377,ENO,0.17054506156026636,NUTS +377,PK,0.7147049650142908,NUTS +378,PGM,-0.09514119214950423,NUTS +378,ENO,0.17269759289080142,NUTS +378,PK,0.9224435992587027,NUTS +379,PGM,0.009505417958802775,NUTS +379,ENO,0.2089822693835624,NUTS +379,PK,0.7815123126576348,NUTS +380,PGM,-0.014942203467788184,NUTS +380,ENO,0.22695411324323286,NUTS +380,PK,0.7879880902245553,NUTS +381,PGM,-0.09504153857745812,NUTS +381,ENO,0.1902927172094021,NUTS +381,PK,0.9047488213680561,NUTS +382,PGM,-0.05303185812708122,NUTS +382,ENO,0.2032823496172892,NUTS +382,PK,0.849749508509792,NUTS +383,PGM,-0.15720986364663458,NUTS +383,ENO,0.17970777134415106,NUTS +383,PK,0.9775020923024835,NUTS +384,PGM,-0.06891087324567335,NUTS +384,ENO,0.15239932055314392,NUTS +384,PK,0.9165115526925294,NUTS +385,PGM,-0.14282615639727214,NUTS +385,ENO,0.16955897374330592,NUTS +385,PK,0.9732671826539662,NUTS +386,PGM,-0.03589834703277184,NUTS +386,ENO,0.20161235266494779,NUTS +386,PK,0.8342859943678241,NUTS +387,PGM,-0.23789833678735084,NUTS +387,ENO,0.183546481317885,NUTS +387,PK,1.0543518554694657,NUTS +388,PGM,-0.07764667709549822,NUTS +388,ENO,0.16537785655846654,NUTS +388,PK,0.9122688205370317,NUTS +389,PGM,-0.20082131881848242,NUTS +389,ENO,0.17475550421702402,NUTS +389,PK,1.0260658146014583,NUTS +390,PGM,-0.045944359173576865,NUTS +390,ENO,0.18891156038470353,NUTS +390,PK,0.8570327987888732,NUTS +391,PGM,-0.0772858740968918,NUTS +391,ENO,0.1601240280064696,NUTS +391,PK,0.9171618460904223,NUTS +392,PGM,0.10238763235518156,NUTS +392,ENO,0.1858382156885603,NUTS +392,PK,0.711774151956258,NUTS +393,PGM,-0.0832953447318352,NUTS +393,ENO,0.19605237595318598,NUTS +393,PK,0.8872429687786492,NUTS +394,PGM,-0.11861349839559798,NUTS +394,ENO,0.17317134574304122,NUTS +394,PK,0.9454421526525568,NUTS +395,PGM,0.11929364752092375,NUTS +395,ENO,0.2388682303238568,NUTS +395,PK,0.6418381221552194,NUTS +396,PGM,0.12730898686471936,NUTS +396,ENO,0.22512051039704908,NUTS +396,PK,0.6475705027382316,NUTS +397,PGM,0.16770274898219373,NUTS +397,ENO,0.2795891075957956,NUTS +397,PK,0.5527081434220106,NUTS +398,PGM,0.16268647111420453,NUTS +398,ENO,0.14696702244970825,NUTS +398,PK,0.6903465064360872,NUTS +399,PGM,0.14585061349421646,NUTS +399,ENO,0.14884634123366164,NUTS +399,PK,0.7053030452721218,NUTS +400,PGM,0.1549952651261468,NUTS +400,ENO,0.14005767496825855,NUTS +400,PK,0.7049470599055946,NUTS +401,PGM,0.09649933802573374,NUTS +401,ENO,0.17530949520214015,NUTS +401,PK,0.7281911667721261,NUTS +402,PGM,0.11643984996070023,NUTS +402,ENO,0.1540044407095114,NUTS +402,PK,0.7295557093297883,NUTS +403,PGM,-0.028099529265243284,NUTS +403,ENO,0.1980687229034852,NUTS +403,PK,0.8300308063617581,NUTS +404,PGM,0.0682931058310805,NUTS +404,ENO,0.18163300125718665,NUTS +404,PK,0.7500738929117328,NUTS +405,PGM,0.07288171099363039,NUTS +405,ENO,0.19225964676210874,NUTS +405,PK,0.7348586422442609,NUTS +406,PGM,0.07131915365336272,NUTS +406,ENO,0.19127309537123302,NUTS +406,PK,0.7374077509754042,NUTS +407,PGM,-0.03527735180373548,NUTS +407,ENO,0.20517825337436157,NUTS +407,PK,0.8300990984293739,NUTS +408,PGM,-0.023079312590854606,NUTS +408,ENO,0.16694567247443695,NUTS +408,PK,0.8561336401164176,NUTS +409,PGM,0.0011194618066628914,NUTS +409,ENO,0.18639912964434963,NUTS +409,PK,0.8124814085489875,NUTS +410,PGM,0.08132441361251308,NUTS +410,ENO,0.1560030641562163,NUTS +410,PK,0.7626725222312706,NUTS +411,PGM,0.08633248143121108,NUTS +411,ENO,0.1728528632819671,NUTS +411,PK,0.7408146552868219,NUTS +412,PGM,0.025253475725893093,NUTS +412,ENO,0.17325840014778368,NUTS +412,PK,0.8014881241263233,NUTS +413,PGM,0.06424695925978186,NUTS +413,ENO,0.16906842757934143,NUTS +413,PK,0.7666846131608767,NUTS +414,PGM,0.032104818277073566,NUTS +414,ENO,0.17245308000487036,NUTS +414,PK,0.7954421017180561,NUTS +415,PGM,0.018240310940307536,NUTS +415,ENO,0.16854043875095875,NUTS +415,PK,0.8132192503087338,NUTS +416,PGM,-0.0073640333672710945,NUTS +416,ENO,0.17055884666328033,NUTS +416,PK,0.8368051867039908,NUTS +417,PGM,-0.20599294412301306,NUTS +417,ENO,0.13996829015036283,NUTS +417,PK,1.0660246539726501,NUTS +418,PGM,-0.0833183160587101,NUTS +418,ENO,0.17351011414603812,NUTS +418,PK,0.909808201912672,NUTS +419,PGM,-0.32216242986616606,NUTS +419,ENO,0.15515248420513733,NUTS +419,PK,1.167009945661029,NUTS +420,PGM,-0.20943880097210088,NUTS +420,ENO,0.17151919613222108,NUTS +420,PK,1.0379196048398798,NUTS +421,PGM,0.14363362565401172,NUTS +421,ENO,0.26270853611239137,NUTS +421,PK,0.593657838233597,NUTS +422,PGM,0.19090600677931813,NUTS +422,ENO,0.19060842699942954,NUTS +422,PK,0.6184855662212523,NUTS +423,PGM,0.11874510622548107,NUTS +423,ENO,0.18239351926145964,NUTS +423,PK,0.6988613745130593,NUTS +424,PGM,-0.07807483178813146,NUTS +424,ENO,0.1791401114771327,NUTS +424,PK,0.8989347203109987,NUTS +425,PGM,-0.06156370129595001,NUTS +425,ENO,0.16015123923666383,NUTS +425,PK,0.9014124620592863,NUTS +426,PGM,-0.06156370129595001,NUTS +426,ENO,0.16015123923666383,NUTS +426,PK,0.9014124620592863,NUTS +427,PGM,-0.04580221422242681,NUTS +427,ENO,0.17752768042993214,NUTS +427,PK,0.8682745337924945,NUTS +428,PGM,-0.013560816565716394,NUTS +428,ENO,0.23317370815871694,NUTS +428,PK,0.7803871084069994,NUTS +429,PGM,-0.04017520093467719,NUTS +429,ENO,0.20231096300199852,NUTS +429,PK,0.8378642379326785,NUTS +430,PGM,-0.05348485837612449,NUTS +430,ENO,0.18462080755379484,NUTS +430,PK,0.8688640508223296,NUTS +431,PGM,-0.11965925064695049,NUTS +431,ENO,0.22972129866953564,NUTS +431,PK,0.8899379519774149,NUTS +432,PGM,-0.019658566988341786,NUTS +432,ENO,0.19036589111193195,NUTS +432,PK,0.8292926758764098,NUTS +433,PGM,-0.03944060113848136,NUTS +433,ENO,0.19971797174643696,NUTS +433,PK,0.8397226293920442,NUTS +434,PGM,-0.0038434774502043023,NUTS +434,ENO,0.2110010979880599,NUTS +434,PK,0.7928423794621443,NUTS +435,PGM,0.009759198856997053,NUTS +435,ENO,0.22627036460582067,NUTS +435,PK,0.7639704365371823,NUTS +436,PGM,-0.11184718209042765,NUTS +436,ENO,0.16482977430994314,NUTS +436,PK,0.9470174077804844,NUTS +437,PGM,-0.040340622276095806,NUTS +437,ENO,0.18167768540980264,NUTS +437,PK,0.8586629368662931,NUTS +438,PGM,-0.048026695735740255,NUTS +438,ENO,0.1788460477043451,NUTS +438,PK,0.8691806480313952,NUTS +439,PGM,-0.25041488701119907,NUTS +439,ENO,0.20707206114871235,NUTS +439,PK,1.0433428258624866,NUTS +440,PGM,-0.16843292370230212,NUTS +440,ENO,0.190921078515381,NUTS +440,PK,0.9775118451869211,NUTS +441,PGM,-0.1951418601564452,NUTS +441,ENO,0.2008443860160369,NUTS +441,PK,0.9942974741404083,NUTS +442,PGM,-0.04561547842790237,NUTS +442,ENO,0.17406205028298372,NUTS +442,PK,0.8715534281449187,NUTS +443,PGM,-0.15180010440008296,NUTS +443,ENO,0.11955540623755892,NUTS +443,PK,1.032244698162524,NUTS +444,PGM,0.028126290845524538,NUTS +444,ENO,0.19467781103736723,NUTS +444,PK,0.7771958981171083,NUTS +445,PGM,-0.18136354471519156,NUTS +445,ENO,0.1738548208625461,NUTS +445,PK,1.0075087238526452,NUTS +446,PGM,-0.1860871666914934,NUTS +446,ENO,0.16495820717914178,NUTS +446,PK,1.0211289595123518,NUTS +447,PGM,-0.09587341011306605,NUTS +447,ENO,0.18229112613602175,NUTS +447,PK,0.9135822839770442,NUTS +448,PGM,-0.02650642587564156,NUTS +448,ENO,0.18431498506164082,NUTS +448,PK,0.8421914408140009,NUTS +449,PGM,0.054412801455981596,NUTS +449,ENO,0.18538260188816655,NUTS +449,PK,0.7602045966558518,NUTS +450,PGM,0.039896825360790644,NUTS +450,ENO,0.1868289238741985,NUTS +450,PK,0.7732742507650109,NUTS +451,PGM,-0.05093584930533335,NUTS +451,ENO,0.15283474917473053,NUTS +451,PK,0.8981011001306028,NUTS +452,PGM,-0.06562380841627347,NUTS +452,ENO,0.1702353741763022,NUTS +452,PK,0.8953884342399714,NUTS +453,PGM,-0.05863490919529912,NUTS +453,ENO,0.16929671888996453,NUTS +453,PK,0.8893381903053346,NUTS +454,PGM,-0.08240107229164062,NUTS +454,ENO,0.19807045531064807,NUTS +454,PK,0.8843306169809926,NUTS +455,PGM,-0.021468560807155423,NUTS +455,ENO,0.18959971033340928,NUTS +455,PK,0.831868850473746,NUTS +456,PGM,-0.012390724771952355,NUTS +456,ENO,0.20359054469255228,NUTS +456,PK,0.8088001800794001,NUTS +457,PGM,-0.04293830645696661,NUTS +457,ENO,0.21166471095295533,NUTS +457,PK,0.8312735955040115,NUTS +458,PGM,0.005276018093057999,NUTS +458,ENO,0.21115157749206176,NUTS +458,PK,0.7835724044148802,NUTS +459,PGM,-0.11571722006875196,NUTS +459,ENO,0.21279952654991457,NUTS +459,PK,0.9029176935188374,NUTS +460,PGM,-0.1538634596601165,NUTS +460,ENO,0.2055921580300078,NUTS +460,PK,0.9482713016301089,NUTS +461,PGM,-0.14573715339848237,NUTS +461,ENO,0.2918847776231947,NUTS +461,PK,0.8538523757752877,NUTS +462,PGM,-0.09203778622358127,NUTS +462,ENO,0.24427972484031812,NUTS +462,PK,0.8477580613832633,NUTS +463,PGM,-0.09515860032972556,NUTS +463,ENO,0.16088597715470465,NUTS +463,PK,0.9342726231750209,NUTS +464,PGM,-0.050311116317353965,NUTS +464,ENO,0.1754841689376856,NUTS +464,PK,0.8748269473796685,NUTS +465,PGM,-0.0766870061442626,NUTS +465,ENO,0.19960599237996093,NUTS +465,PK,0.8770810137643017,NUTS +466,PGM,0.30239343167262,NUTS +466,ENO,0.20485429147628775,NUTS +466,PK,0.4927522768510922,NUTS +467,PGM,0.281240228768476,NUTS +467,ENO,0.20506924613883204,NUTS +467,PK,0.513690525092692,NUTS +468,PGM,0.2244531446555289,NUTS +468,ENO,0.17683693331153946,NUTS +468,PK,0.5987099220329316,NUTS +469,PGM,0.20773109476041007,NUTS +469,ENO,0.13768558685103868,NUTS +469,PK,0.6545833183885512,NUTS +470,PGM,0.11870081395373722,NUTS +470,ENO,0.16350209764948878,NUTS +470,PK,0.717797088396774,NUTS +471,PGM,0.062944362534609,NUTS +471,ENO,0.1554211535234878,NUTS +471,PK,0.7816344839419032,NUTS +472,PGM,0.05202570113772331,NUTS +472,ENO,0.1784845299467564,NUTS +472,PK,0.7694897689155202,NUTS +473,PGM,-0.003204188433777899,NUTS +473,ENO,0.1474419039574467,NUTS +473,PK,0.8557622844763314,NUTS +474,PGM,-0.0257512281886787,NUTS +474,ENO,0.15445659019137215,NUTS +474,PK,0.8712946379973066,NUTS +475,PGM,-0.011537636604243895,NUTS +475,ENO,0.20522389519429163,NUTS +475,PK,0.8063137414099523,NUTS +476,PGM,0.02673298056794271,NUTS +476,ENO,0.1647784502075114,NUTS +476,PK,0.8084885692245459,NUTS +477,PGM,-0.01887858125053854,NUTS +477,ENO,0.1683178086705041,NUTS +477,PK,0.8505607725800345,NUTS +478,PGM,0.006083027212456238,NUTS +478,ENO,0.18376906889825725,NUTS +478,PK,0.8101479038892866,NUTS +479,PGM,0.039985748890256634,NUTS +479,ENO,0.17877029400142577,NUTS +479,PK,0.7812439571083176,NUTS +480,PGM,-0.11792941625774556,NUTS +480,ENO,0.19458356553442835,NUTS +480,PK,0.9233458507233171,NUTS +481,PGM,-0.11747849101382868,NUTS +481,ENO,0.20114559966080325,NUTS +481,PK,0.9163328913530255,NUTS +482,PGM,-0.07789376842709417,NUTS +482,ENO,0.20786308742274612,NUTS +482,PK,0.870030681004348,NUTS +483,PGM,-0.23298204441225234,NUTS +483,ENO,0.2040626515468265,NUTS +483,PK,1.0289193928654257,NUTS +484,PGM,0.02392318816583827,NUTS +484,ENO,0.2062314616163803,NUTS +484,PK,0.7698453502177814,NUTS +485,PGM,-0.06011233958462059,NUTS +485,ENO,0.18027918984945165,NUTS +485,PK,0.8798331497351689,NUTS +486,PGM,-0.07742106415694106,NUTS +486,ENO,0.19175762085493303,NUTS +486,PK,0.8856634433020081,NUTS +487,PGM,-0.11746862827193483,NUTS +487,ENO,0.17655947587802154,NUTS +487,PK,0.9409091523939132,NUTS +488,PGM,-0.06415531754817594,NUTS +488,ENO,0.1467581592133709,NUTS +488,PK,0.9173971583348052,NUTS +489,PGM,-0.03579432315033637,NUTS +489,ENO,0.2094052502350468,NUTS +489,PK,0.8263890729152895,NUTS +490,PGM,-0.07161462859030188,NUTS +490,ENO,0.1963838544017917,NUTS +490,PK,0.8752307741885104,NUTS +491,PGM,-0.08312382255874207,NUTS +491,ENO,0.19114422800262154,NUTS +491,PK,0.8919795945561205,NUTS +492,PGM,-0.13085696200834973,NUTS +492,ENO,0.19148292685993035,NUTS +492,PK,0.9393740351484194,NUTS +493,PGM,-0.014845001046272621,NUTS +493,ENO,0.21968603281728918,NUTS +493,PK,0.7951589682289837,NUTS +494,PGM,0.004259333180096636,NUTS +494,ENO,0.18132059471758535,NUTS +494,PK,0.814420072102318,NUTS +495,PGM,0.16186050968010945,NUTS +495,ENO,0.16914582855264382,NUTS +495,PK,0.6689936617672467,NUTS +496,PGM,0.19972571937309735,NUTS +496,ENO,0.17552312570155548,NUTS +496,PK,0.6247511549253472,NUTS +497,PGM,0.1578866087597327,NUTS +497,ENO,0.1913272339949495,NUTS +497,PK,0.6507861572453177,NUTS +498,PGM,0.17859321889970514,NUTS +498,ENO,0.20979905371024082,NUTS +498,PK,0.611607727390054,NUTS +499,PGM,0.0808876709348213,NUTS +499,ENO,0.12180727907730882,NUTS +499,PK,0.7973050499878699,NUTS diff --git a/tests/test_data/expected_wu2004_FCCpriors.csv b/tests/test_data/expected_wu2004_FCCpriors.csv new file mode 100644 index 0000000..2dec059 --- /dev/null +++ b/tests/test_data/expected_wu2004_FCCpriors.csv @@ -0,0 +1,4 @@ +Reaction,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499 +ENO,0.8168743512519027,0.17342448270995234,0.011987997095313278,0.5852868587054912,0.3235438288802192,0.05228913708160624,0.34856934221487484,0.48064619103558814,0.14056734502283683,0.2782063370526193,0.5079494480331949,0.08511679681883806,0.2816769940134919,0.28026190364508047,0.19678354967964337,0.14722121716977654,0.3659626027843873,0.4856103049838329,0.17101797183027792,0.3628161560825807,0.4012332959532199,0.3474575142052842,1.1239501124110267,0.16494900434794807,-0.014117762277393834,-0.21734899399396,0.32064064463051917,0.08645890211212609,0.33091084609607796,0.11188341165348206,0.28397670353801885,0.2320562196482901,0.34249298731811284,0.0898404864191226,0.46921983525412986,0.2760205735110777,0.33164309547077847,-0.1352952816918265,0.45023842050381496,0.14868470110500553,0.3933380773190064,-0.23100020522969283,0.6771281185373377,0.049721756380322606,0.18502774185185503,0.2009612995326907,0.2472872936697039,0.12650314128803009,0.2955647211056266,2.40523846794972,0.36169859681538535,0.08983434673794853,0.34316318746496227,0.47670177286215865,0.28732915720358004,0.21369327314309455,0.22517595473418253,0.4362708014088499,0.5757052384626095,0.3510538161084187,0.6364609752281408,0.5227444421052873,0.6432285141032945,-0.10633943684199583,0.547399526859974,0.5432426427607974,0.16699291237336966,-0.008041928635051853,1.0844421240649758,0.7158627277503588,0.58313921353539,-0.20433517571022564,0.2380624005563869,0.8763580681818717,0.10129984669255337,0.25867949912189425,0.09103455625505767,0.4118156590082661,0.5425004142983115,0.5896679161879621,0.3740279191592416,0.046664259698040715,0.5402750331445125,0.17422309651177223,0.2305790603245717,0.25719594730899514,0.4247665470985811,-0.21262809907700048,0.9176643900919471,0.27291150748862836,-4.646448321460471,0.5387765023852775,0.6589523129917582,-0.04122035232002288,0.1965305437463042,0.6994492232472639,0.21824613667392656,0.13093726722180998,38.926557819668666,0.5364911632208373,0.4292600675538023,0.243640295202973,0.4099647401475294,0.3954931795166207,0.33381189600637995,0.35908891036412577,0.08888758694806811,0.6549836716361909,0.5461166428272123,0.43778650739991265,0.38811026394330383,0.32455727364696807,0.6605706978521372,0.43691220405139825,-4.004782380552873,0.38546446518137206,0.17086081525208544,0.5616591455890009,0.15095676222407564,0.4584193937627385,0.30466921636161254,0.6487229270664109,0.02789616054722487,-0.27681588597789625,0.29976729936991664,0.07500639961889873,0.29627964390337136,0.4583750380642593,0.1318061134843105,0.09929063737726494,0.32756970349831566,0.24583814089599296,0.15818139997845132,1.1953548782226162,0.3567737931544168,0.21422383358411168,0.4154846644702258,0.2191777933130947,0.6866164580770835,0.1263254207345258,0.1697648406405254,0.3801579523982392,0.4842182076095656,0.5052389389157848,0.8380536521374303,0.7074654751467835,0.32459359674560906,0.26437525376077575,-0.029068411526059053,0.5729768163573946,0.6750070574421885,0.7030933788730411,0.5645991350330452,0.34243112838554746,0.11088196416437751,0.13734699678010262,0.26391775765872894,-0.07030891806732685,-1.142064019033697,0.37160921422346704,0.31483768908291854,0.7128712177608479,0.4151806765413763,0.5109420197223535,0.8863812986352199,0.1472539160848029,0.13311500423873815,0.1533338323796368,-15.67845269236189,0.3830931156018882,0.12803013526875137,0.43404757999789034,0.4762739882638782,0.22170666275582218,0.6145697906480734,-0.05158516782746875,0.18370119588992617,0.4866968398550775,0.8471867852238394,0.5372933753399493,0.08082889151189651,0.12016978624959077,0.10184157351407183,0.31410888441246254,0.3626780252626159,0.45459927941995026,0.2688219864098038,0.10288747047678627,0.21126369077311277,0.052731399652531326,0.6732202758418275,0.2423312255053848,-0.11012620425711005,0.37706428523154484,0.2484321313769262,0.14938562882727147,0.2986807354568535,0.19776679789385435,1.0082151316406334,0.39136039486000257,0.18190645907632222,0.32039089018195754,0.049918259003643856,0.013717974394252668,0.5486999171663427,0.2529927344931398,0.2561744023714709,0.5265488075917663,0.02499386911116279,0.030514912504892754,0.016598807516844862,0.3519240194749693,0.11745870520208301,0.1205785441083587,0.32114281087372093,0.5001894438090444,0.23137834645140576,0.020328406292665892,-0.6476596279563347,0.35582293634707474,0.281503052450838,0.24504731654807863,0.2487123742158779,-0.06548055542245715,0.0902486802622449,0.38025363981925053,0.16915159751529427,0.44898991924113024,1.0365202376126315,0.5429942538370605,0.3444224174748308,-0.3850375477317179,0.23859063981591366,0.14399065633702435,0.3968025297438015,0.4359573594238321,0.4088083931409335,0.5055288777209047,0.4383208391108283,0.16537113824972421,0.26321886614639034,0.3688498260572822,0.07247960115162906,0.24400810235410544,0.1640094779369039,0.3507544681435931,0.167571457789013,0.5272847181287642,1.508347618771314,0.17693517438637743,0.6440645623014891,0.3648122508901265,0.28201832901957025,-0.023100283719713552,0.44864572035725847,0.06668956669548738,0.22043658391803897,0.17236921958989163,0.2710205851497832,0.2628642430087435,0.675437951001532,0.5195820670547011,0.21405752358849015,1.014404287831427,0.12969324402270588,0.2595949697181407,0.7184060616243714,0.3123815483999192,0.1871631683994529,0.15789257663644302,0.13820504668190353,-0.3571935821481371,0.15408179035474381,0.11813823414914332,0.3602359732216744,0.1348897756244667,0.49073434134368954,0.3620382619126701,0.0700415630515654,0.9786368443707445,0.1672058961805765,-0.02944686014716288,0.13200220663023868,0.2749819047116261,-0.7369122363236462,0.3325089560459627,0.17430896474846605,-0.24056777922255118,0.05567447219336277,-0.2928764465355973,0.450194547624695,0.3302580963701762,0.08976732986509041,-0.017271002600479594,0.7724967289803077,0.3255237812122603,0.13086815557139997,0.5342739128149759,0.15018635422360038,-0.026714410661273818,0.13673962231984424,0.37583248115171575,0.3099077027693326,0.2513088495427531,0.3757206539574509,0.4522163438944629,-0.03894197148837248,-0.010745402100191908,0.1242247203980145,0.21973042031564605,0.09032324990549856,0.49839129726998393,0.4986340866616012,0.27278063369521266,0.13943782366420765,-0.33144047043375324,0.1994169890821258,0.4261068681190978,0.6343457349565991,0.024852382842949355,0.09303920213860901,0.3050972808247095,0.15617042374570544,0.2432245986056281,-0.08585456806586647,0.5593634158959779,-0.28137050698676724,0.18192232296728067,0.7555516711464618,0.2506923173480615,0.26433178983444955,0.8739783869362096,0.009485624366311049,0.28960020176921497,0.24010045574870428,0.22886073191524148,1.030508710198025,-0.013902187277441568,0.34363618090557657,0.38059544832777836,0.7616636395972208,0.6133160228055647,0.03355409964797721,0.5551271068751955,0.2214525150051436,0.05000474342766394,0.5895047625297227,0.3203988479801661,0.7806025630520993,0.3193443728573053,0.10061064042973153,0.010011443604381593,-1.8872698866338877,0.14120380619560682,0.5789229712600547,0.4216558726923961,0.4158798533655113,0.8640533067778792,-0.07169336662623677,-0.00540828304776781,-0.06461353990144933,0.19214196279058565,1.2196977520484036,0.29886337202653895,0.02576750541517889,0.09053504153064906,0.6414013712000113,1.2079421260387524,0.08976374942031765,0.1795017154593352,1.92081925168994,0.2626429297071614,0.5188313094364566,0.28109697105121056,0.26184092542185944,0.1996372370597822,0.060913744736703766,0.000794878074572156,0.28590833762412904,-0.64591402493448,0.35197541378802355,0.12674284010164255,0.14990108963418125,0.36312211844692716,0.46515458415684613,0.16220991111892302,0.24130803721040633,0.3417398203217054,0.19962964703006184,0.06682186973137627,0.9237968073347004,0.01968322274410168,0.5586160380114478,0.34332813802849627,0.3267308123773248,0.09807556409827428,0.6725578955934776,0.08253928493103363,0.35010925566776574,0.3589813875877883,0.29974123903932426,4.313062590016967,-0.9053297257215284,0.30501606230142886,0.47469672668968366,0.24709752868434448,0.181522973936373,0.2780746832142355,0.20000137053522732,0.5201801763892335,0.4702447175682685,-0.06210636438932481,0.3198357107459404,0.36912368439823817,0.03345970596532674,0.2640783667768332,-0.12815877938502923,0.35346006568358224,0.18178910448856653,0.2996310269582655,0.5503926133241414,0.07074232562816479,0.39059371660101033,0.20463154451673682,0.5879500609065743,0.5393518472377551,0.14831214894769373,0.1376256760798638,0.18644757523331282,0.06425127054034967,-0.6318770334958457,0.41919927061933887,0.37204875392976605,-0.2520396905490202,0.5652181031358198,0.1907230474881421,0.26141292192147253,0.26037702691590553,0.2177612157483814,0.3030097536284287,0.33404801902117714,0.21711045523799744,-0.00012461890057404847,0.07715954976883184,0.6962178416396544,0.5941775143344588,0.27913003880170595,0.09032729155400088,0.45808322686147734,0.39418208075324895,0.197894626637265,0.24228885940050202,0.05396261929608575,0.2714391676492295,0.19950107888224988,0.1462050874990397,0.9174914890942089,-0.019310096762816722,0.4906277482754421,0.4614195403127517,-0.02153312162409064,0.512025053807554,0.3542044544789352,0.515565023239631,0.645341976117935,0.3765334148089294,0.5725511273644499,0.3419281208116255,0.39935725551168477,0.18603522929419425,0.10759352477824428,0.4513387417392423,-0.05098093661527958,0.13452681878675382,0.4050107435719411,0.24218615192816528,0.3090573700645091,-0.5830485692904015,0.11876904677523137,0.30812077905180524,0.49944461262375994,0.2789024919128488,0.2027154319499661,-0.2626637590181643,0.4005869352938784,0.41105203246668676,0.28019926907154685,0.37276292663446214,0.37569583785763877,0.3323384347701953,0.5792989753283194,0.24218956283743812,0.47000459238739883,7.51302843521129e-05,0.13381936698776423,0.11240331181304457,0.29278213411364734,0.49130615291199936,0.3397820035486918,-0.16007149986966215 +PGM,0.08428755458709714,0.31068726985786954,0.021441396124249668,0.20614350537938952,0.3704491115838058,-0.08306510509142329,0.5857789704655365,0.466714555076441,0.02840502258897959,0.3823733824499571,0.40188080278239635,0.40023195223496966,-0.13368302281563915,0.041636403961298085,0.47157715034037584,0.7716169926314431,0.6004926142803005,0.7167852189235557,0.7069366475370046,0.09487892947972243,0.010198584440600844,0.36935522417809763,2.8642805699167457,0.44813168737935516,1.0371030132900247,-0.3932267963177436,0.637782779602703,0.9381142568860866,0.13751482195740838,0.8813612781968074,0.5674258158667835,0.7177681396623414,0.36232594839680143,0.730249576283452,0.25736857955628734,0.517520683834825,0.7043240498842818,-0.5323253229267402,0.47633147311554014,0.29369285251004196,0.4725884970332299,1.241878509415769,-0.09099510298117552,0.03482046609832923,0.2723739154746936,0.4345563891365959,0.07338534083169801,0.1852917449075605,0.4962578981788621,0.06214803389652812,0.2976406970331771,0.21738367811662662,0.35226842094364386,0.7023479619360723,0.2610696137816261,0.17368627141629556,0.5602584271500336,0.6932226144021542,-0.022194166550076222,0.4107648753581703,-0.4810935345855698,0.08646600885781341,-0.14671356469518582,1.2869809323873211,-1.569228906867886,0.35629372316827135,0.11723507713977444,1.0178476085188572,1.068785922968173,0.006910883121927336,0.13157062508724238,1.2739587608867922,0.4962222725962949,-0.10196937647256865,0.044242955756868874,0.6936184307423082,0.3068858761780556,0.10003382297465213,0.27890390197150106,0.4284961141171231,0.17700705236404435,0.44111018401875624,0.29907835647900183,0.49448218350988726,0.6733242007876736,0.3039341402514528,0.21848361800859706,1.234224989794165,-0.23997937971510197,0.3777450393839362,47.34061296910018,0.21465151344070954,0.33899409255314705,0.07141253823662741,0.494529810850031,-0.26873869276397166,0.5816476882891071,0.3676027824628517,-81.79609130695206,0.40434939615287624,0.2306987741598504,0.3104421227811148,-0.02930763867541253,0.43363584914437325,0.5732953053807142,0.3514626194375098,0.7459746175474127,0.03022980865227276,0.30146807894684846,0.23894418006855822,0.59811290428859,-0.008578892049246889,0.10686643317324573,0.6068014854649415,52.42940505930684,0.7661024653896109,0.3445118886538767,0.18317866507508362,0.07342306392767961,0.2778245957150165,0.059722613791796,0.616693857185905,0.1505118829064983,1.3212756311225304,0.15695408946993217,-9.13287975099486e-05,0.151314333987968,0.46997990221345576,0.0664051912978727,0.5565154030573889,0.1246719849204978,0.24874149844809157,0.1969806545397067,0.8757567360258666,0.4755110427719853,0.6395624351866185,0.22557471116506866,0.3595222586907181,0.4406986251081566,0.1200721363469277,0.8131652071522534,0.3006734806363828,0.08240665912581169,0.31785507417570313,0.11711303201841972,0.1400124408694916,0.43771198272496226,0.2960000988865993,1.193614530961357,0.025065401159281908,0.22282034045838972,0.08027374735993864,0.194051782757811,0.19508790643752938,0.6651464950593964,0.05108302728884018,0.7382033775446208,1.1086450509486947,2.749465126586358,0.3351416189622216,0.2690341783144261,0.2324411084067387,0.3876650624289498,0.06149257222364235,0.23507144522357704,0.6255118119231425,0.4115062418633437,0.08464379096135233,15.209735510072836,0.24009911727509037,0.765426541079873,0.1162435642012074,0.5095755014431944,0.7471995841677964,-0.02160973648180997,1.2070487706203055,0.15508860457079898,0.22418657187403268,0.1356345894452744,0.23599792306216283,0.1405709873883053,0.5622226456000021,0.7986630314281832,0.2214806229493933,0.542334949090796,0.37137048656869653,0.2716572578130312,0.8908418109350618,0.6010096191668688,0.5669976524339202,0.20270484423488233,-0.026286585831821085,0.08018546758152256,0.5674982084367547,-0.08252132800222611,0.6843923803992172,0.30022798406288764,0.1484039266490308,0.1042864687847761,0.28907302050224326,0.017355186059418326,0.13662180610094332,0.25541486009543546,0.0014360431006738006,-0.15999381416082992,0.555337638763951,0.2034250896784805,0.148226538532494,0.9315161334180514,-0.037460242870617666,1.13340832690511,0.3805929647914782,0.7116352725216204,0.7349028808523689,0.2197887433852892,0.15417210353818644,0.6812498141335384,0.7585433164267622,-0.686187852928626,0.5188411911731977,0.45790544414133716,0.5109336303575505,0.29740137280587564,-0.016720227477763805,0.8073771196146888,0.022783112590386345,-0.03377582043557403,0.2481405529158629,0.07359678437554662,0.09094698804720158,0.619636069182371,0.09446908401358589,-0.2624521128072208,0.7351568104239223,0.1951136198963791,0.4771562713220665,0.202476029293841,0.019481930816675153,0.0805007924210176,0.34656875505609996,0.712234341246138,0.03467022278543974,0.11180283501289301,0.06976299920242857,0.15056367146183436,0.3078678584534946,0.5606338973688407,0.4664727605258603,1.389556679646588,0.35563013779099606,0.2358589243808894,0.1893922787457002,0.22872896251596364,1.0462157034576047,0.05270727728892122,0.10875983975520842,0.04107197509479965,0.03514274598029521,0.17727103834020674,0.2198506306736806,0.2636663976750051,-0.06737799185560256,0.3245424891109424,-0.4396382967893351,-0.21819772463377074,0.4458484880266743,0.04309492155204986,0.5934096830706435,0.021286022485659584,0.2512830294299363,0.06859635420390597,1.5699197184533251,0.17495557056106958,0.31760757149726115,0.6604397087091212,0.8072897896339073,0.3964018243761067,0.18655401245729186,0.8381507531898397,0.32635035071395413,0.1813684381324827,-0.07510458437276779,0.08643862931382995,0.05591514252986651,-1.0051175695854084,0.706515564132684,0.6304856281498554,-0.213889648562001,-0.1050432987401353,-2.42954470054983,-0.19256572788841742,0.5480132246171479,0.4427486117274736,0.14450480290468903,-0.013523162248611609,1.0692571799939867,0.4204905283960453,0.13463263778967205,0.7214858051566495,0.052997463803864164,0.29544378072956856,0.26028447879547056,0.4818934329476332,0.7377088800313418,0.17723860952338932,0.293940731093276,0.04440852466017575,1.0178574045056124,-0.06990833210178815,0.40720499589370407,0.867345675028798,0.6582704363556151,0.1437302518696958,0.7026367020776476,0.5669377280726453,-0.1902580716469151,0.29696026181409196,0.5295344979660322,-0.07642910358150146,0.9824473662343588,0.39354814879098265,0.490981901472874,0.197549650913167,0.4551541978176593,1.211196126480034,0.21975986876562437,1.4084571462626274,0.3873910909951609,0.41895768734281125,0.5720418205099158,-0.04168358882064349,0.14338842681048858,0.9389152015881473,0.4480838934320932,0.32029115436685873,0.17974321913919888,0.15949728227080628,-0.11741332951240979,0.4519999664571621,0.3777990156709117,0.712252283237811,0.3128503378917623,0.3044253146224263,0.18396804026793023,0.7459010092950081,1.0341024173278968,0.27109524927603323,0.3985796182902458,0.19762664586755407,0.25170266626253734,0.7873749465212955,0.9590447398987308,3.291658231825073,0.4956129270162243,0.2916219935210309,0.5207342125356398,2.0104199828577034,-0.26937182805790383,-0.007770861062468271,1.5048358270442383,-1.238900012741952,0.05645894383264971,-3.9698617088131334,0.46031765013081916,0.15005497800053846,0.668365515089969,0.3747356238009135,-0.3095883791729144,0.04186076032331465,0.6553930190884076,1.3607415483711138,0.7584922811690966,0.04006948144646516,0.550103861042061,-0.030075313892068634,-0.05132476875092351,0.7780770918842236,0.012709551022342058,0.2397272349728683,1.8517032034653063,0.3470424290642826,0.8181846228756144,0.6879377710887167,0.5869638320083921,0.22426672506346135,0.17484961391027543,0.5625358569009942,0.19117741458388982,0.15050611278743586,0.009100335799357206,-1.5613310283273387,-0.030788410200308425,0.007437805545853271,0.20860430469662739,0.48707418914256084,0.8467782529717652,0.08066319961915802,0.13626180536730903,0.01318491399020516,0.4934559416872365,0.4725211278710487,4.355614891917936,1.8902936518031825,0.26457331734012923,0.39136141904766264,0.5949682717760432,0.43363024313910004,-0.20772969725913204,0.21015090015348037,0.4133597117014637,0.07891041869081583,-0.12953696070951248,0.24273281220049447,0.20307696664638297,0.10229932380796214,0.763793796382146,-0.042270861199712684,0.05798752091364723,0.5765391409438663,0.4069858929671608,0.18803299503222926,0.8781826034248902,0.31590773537205175,0.5557408943527262,0.20276887938694566,0.3020400420406395,1.0099581819103436,0.3686839740616733,0.01019557798371784,0.37070424403786084,2.095756259807249,0.38142866666381137,0.43635038513925306,-0.2539689650714112,0.20507759325429886,0.6754227269842001,0.24283847586024132,0.6254932429632052,0.2691325000847208,0.381819719166689,0.24092541764089237,0.7688304499778347,0.01430754684309965,0.6102236904710088,0.4510778678813707,-0.0010477189214399552,0.04852085750502555,0.32156064101023174,0.000395991459888112,0.40932426417799295,0.6025130111370643,-0.0006263190487321157,0.0516101295247966,0.2641457628396433,0.6600143781692407,0.4596619141109096,0.11401306617424689,0.966555573753272,0.24990898822253993,0.33894638849504377,0.35965645778944777,0.29379855256756326,0.2031022298707683,0.3258561471499615,0.2454546788401082,1.4824195013678474,0.1660168954825293,0.2042804432881138,0.1876590450569806,0.4033442841327053,-0.0015942502059738128,0.16566961015690362,-0.06702798543142485,0.7196534420906584,-0.0004994605741608371,0.8427186936471109,0.5502403657337984,-0.0767248150590969,0.7223211117498949,0.6004756589934626,0.24731033212160913,0.4837159087480253,0.4291136826865475,-0.10331930673877276,0.10683470594059197,0.11786887561865733,0.34480457235993933,0.26848305315145315,0.44009960104276735,0.6325529449990276,0.19519838755195928,0.7036257050283298,0.4534075511880139,0.9536036965455617,0.6206365116715126,0.27243121835373874,0.7616612635959749,0.2166570225893285,-0.2160487439248393,1.1242799857491963 +PK,0.09883809416100016,0.5158882474321781,0.966570606780437,0.20856963591511932,0.306007059535975,1.030775968009817,0.06565168731958859,0.052639253887970916,0.8310276323881837,0.3394202804974236,0.09016974918440877,0.5146512509461924,0.8520060288021474,0.6781016923936213,0.33163929997998076,0.08116179019878036,0.03354478293531221,-0.20239552390738874,0.12204538063271746,0.5423049144376969,0.5885681196061793,0.28318726161661817,-2.9882306823277722,0.3869193082726967,-0.022985251012630905,1.6105757903117035,0.041576575766777785,-0.024573158998212694,0.5315743319465136,0.006755310149710542,0.14859748059519765,0.05017564068936844,0.2951810642850857,0.17990993729742538,0.27341158518958275,0.20645874265409733,-0.035967145355060175,1.6676206046185669,0.07343010638064489,0.5576224463849525,0.13407342564776364,-0.010878304186075986,0.41386698444383785,0.915457777521348,0.5425983426734514,0.36448231133071346,0.6793273654985982,0.6882051138044094,0.20817738071551117,-1.4673865018462477,0.3406607061514376,0.6927819751454248,0.30456839159139387,-0.17904973479823094,0.4516012290147939,0.6126204554406098,0.2145656181157839,-0.12949341581100401,0.4464889280874667,0.23818130853341102,0.844632559357429,0.3907895490368994,0.5034850505918914,-0.18064149554532527,2.0218293800079117,0.10046363407093128,0.7157720104868559,-0.009805679883805507,-1.1532280470331484,0.2772263891277138,0.2852901613773675,-0.06962358517656642,0.2657153268473182,0.22561130829069692,0.8544571975505778,0.047702070135797414,0.6020795675668867,0.48815051801708176,0.17859568373018733,-0.018164030305085184,0.448965028476714,0.512225556283203,0.1606466103764856,0.33129471997834065,0.09609673888775473,0.43886991243955203,0.35674983489282186,-0.021596890717164665,0.32231498962315475,0.3493434531274354,-41.69416464763971,0.2465719841740129,0.0020535944550948773,0.9698078140833954,0.30893964540366486,0.5692894695167078,0.20010617503696632,0.5014599503153384,43.8695334872834,0.05915944062628652,0.3400411582863474,0.4459175820159122,0.6193428985278828,0.17087097133900603,0.09289279861290582,0.28944847019836445,0.16513779550451924,0.31478651971153637,0.15241527822593934,0.32326931253152913,0.013776831768106162,0.6840216184022787,0.23256286897461717,-0.04371368951633963,-47.42462267875397,-0.15156693057098286,0.48462729609403793,0.25516218933591556,0.7756201738482448,0.263756010522245,0.6356081698465915,-0.2654167842523159,0.8215919565462768,-0.04445974514463421,0.5432786111601512,0.9250849291786111,0.5524060221086606,0.07164505972228505,0.8017886952178168,0.34419395956534615,0.5477583115811866,0.5054203606559153,0.6448379454818419,-1.0711116142484827,0.16771516407359788,0.14621373122926984,0.35894062436470564,0.42129994799618725,-0.12731508318524012,0.7536024429185464,0.01706995220722119,0.3191685669653781,0.4333751332646226,0.17690598690851198,0.04483331584414996,0.15252208398372477,0.23769442052942863,0.43962464735262485,-0.16454611943529798,0.4019577824833235,0.10217260209942186,0.21663287376702023,0.2413490822091439,0.4624809651769232,0.2239715407762261,0.8115699759310573,-0.002121135203349782,-0.03833613288136779,-0.6074011075526611,0.29324916681431135,0.41612813260265535,0.05468767383241334,0.1971542610296738,0.4275654080540043,-0.12145274385879687,0.22723427199205457,0.45537875389791815,0.7620223766590111,1.4687171822890557,0.37680776712302144,0.10654332365137562,0.4497088558009022,0.01415051029292742,0.031093753076381396,0.40703994583373676,-0.15546360279283672,0.6612101995392748,0.2891165882708898,0.017178625330886155,0.22670870159788806,0.7786001210997983,0.31760756815040714,0.09949539505774502,0.46441049263814405,0.09498702564658802,0.1740302340113532,0.4595207557771651,0.00627071858815196,0.18772669006001835,0.3802709479135485,0.12407487992329012,0.7839553603264364,1.0299407366755873,0.0554375063317005,0.8340891966253,0.1662219907735113,0.40109128048025877,0.6538292754571149,-0.11250160042540945,0.3195665846377542,0.8007383548642594,0.542987303717099,0.6946668809009208,0.9848459825050735,0.6112938969944872,0.19166962674290913,0.5404005079500487,0.32522465387573973,0.04348999747078577,1.0069453303657248,-0.15000713442195499,0.26748301573355243,0.1709060222762967,0.14451857503927243,0.4590684457409899,0.3456384526527692,0.08737183941505591,0.22112827728057194,2.3338474808849607,0.12533587247972752,0.2605915034078247,0.24401905309437097,0.4538862529782464,1.082200782900221,0.1023742001230663,0.5969632475903631,0.8646242229202797,0.30286952784300675,-0.11011702198817822,0.36605875811573785,0.03594151334279816,1.290568463718132,1.0238614729913074,0.12085253323905333,0.4080838503598193,0.08688636925410131,0.38871557756522546,0.47498919146242014,0.48117836846815404,0.4880601066941758,0.024546792607471613,0.596479951157278,0.815717563835478,0.686228898443466,0.6854268506012617,0.34137767340291236,0.2717946448421463,0.006242521345375461,-1.8979042984179024,0.4674346878226265,0.12007651331762148,0.44579547036417344,0.4892527084644661,-0.023115419737891222,0.4986470023538203,0.8245505935493043,0.7384914409871612,0.7924880344298132,0.55170837651001,0.5172851263175758,0.060895651323462925,0.5477959248009014,0.46139998730056736,0.4252340089579082,1.0885044806110646,0.2945565422551849,0.23849901682357863,0.09420876852943727,0.7915508091148875,0.5908243939336207,0.7931985991141906,-0.212726136305188,0.6709626390841867,0.5642541943535955,-0.020675681930795515,0.057820434741626035,0.11286383428020369,0.451407725630038,0.0918076837585949,-0.30498719508469857,0.6514256656869408,1.1045514445199305,0.7815591640559314,0.6691029527585074,2.7420298059090547,-0.03902452017864672,0.1952054071016786,1.4544574277845521,1.0493688265467724,3.7224211470854276,0.7423711802637223,0.12172867901267595,0.467484058407436,0.8727661996957907,0.24102643326830392,-0.394780961206247,0.44864131603255475,0.331093449395352,0.12832784061975008,0.9737169468574096,0.5678165969505872,0.3638830400528138,0.20819886428303416,0.010982270425905154,0.44704073651915976,0.2538429250122611,0.9945334468281967,-0.007112002405420386,0.9456836117037736,0.3730645837906499,0.042331075065703466,-0.15666173362559907,0.35763566146870296,0.0245826642271397,0.29362444826314715,1.5216985420806683,0.5036227491037821,0.044358633914869966,0.4420833686249024,-0.00729974907730819,0.5134126490704083,0.20392081770241646,0.6462799253411275,0.3016212035767126,-0.12534155841416755,0.2208767153383977,-0.12708663927586017,0.4306865860375585,-0.17450935848927296,0.17726586214202258,0.7773517989861939,-0.01736681374669812,0.05159917404554162,0.2623159047986918,0.439608389884437,0.5913960489455596,-0.19000599246883135,1.1313155167898512,0.20436385263726126,0.24160553600130996,-0.47391592283503176,0.07383363930267295,0.6620205857295965,0.26090485285687426,0.03264647569984828,-0.08410716075556071,0.13939998819424398,0.28102153372958816,0.021770791080346633,0.4289529608801572,0.11201441304897301,0.030943816496887593,-0.4043883451911856,0.3631832667881688,0.12945503521891444,0.05760991477196416,-1.426299836223215,0.4053185212800246,1.079464227688705,-0.49942754399647066,2.3035135526434014,0.7513990933767646,3.750163956764729,0.24081897784264178,0.8241775165842827,0.24109944337938194,-0.016136995000924838,0.10164625313416197,0.8683754902563678,0.16510526545225718,-2.2815608000610537,-0.021135210876258075,0.44109920911707823,0.16879916790672847,0.7682343884702092,0.8516875316911411,0.16100916337907262,0.9864955709030858,0.47436442740300266,-0.20578917853082618,0.30098215714769394,0.055072537022742965,0.16216113927710205,0.04991404954468082,0.3105786907796924,0.6629404749708017,0.19615610588859955,0.4670827650944047,0.6498642401825022,0.9240777944692666,1.6375342209926382,1.0111051874562067,0.4339461564426991,0.44806755727487646,0.18619499848011437,0.055146182929960486,0.24677890478736456,0.7811989097016574,0.6367058303420291,0.14756267072497511,0.22773763308962705,-7.668677481934903,0.015036073918345747,0.4304106203584419,0.13394185426265365,0.15793419953961238,0.38484678292452695,0.9296550140448964,0.5898477293112923,0.0664601119093028,0.4508448637409156,1.191643325098837,0.4374314770535652,0.42779934895537886,0.864240970226711,-0.02787216315897922,1.1704296405847419,0.5885524134027705,0.2416717545675672,0.29338308007457375,0.2615743916436292,0.05107507094694499,0.293498548026938,0.239627561130537,0.20928105970648012,0.1586081107216053,-0.15827033085803732,0.4936903498584629,0.8033568467829694,0.5650444854217894,-0.46387922631140316,0.19937206271684987,0.19160086093098092,1.5060086556204313,0.22970430360988134,0.13385422552765772,0.49574860221828626,0.11412973012088923,0.5131062841668979,0.31517052720488237,0.4250265633379303,0.014059094784167853,0.9858170720574744,0.31261675976015935,-0.14729570952102508,0.40687020458698125,0.6723491036932686,0.5881120674357674,0.5415207816786344,0.196493655068758,0.1995923622256706,0.7583374596482301,0.8944272511791176,0.46441506951112727,0.14048454294850954,0.3941329983900506,-0.03150455526845559,0.05275452300954483,0.2594632635020179,0.1996340711922045,0.6618766638346428,0.19417639362488262,0.44269331565029646,0.1585788296104073,0.10920334504195685,-0.8589529161767767,0.2614319771530208,0.45379143590026066,0.4129836994313346,0.41062048657310046,0.8940007254277295,0.38299164810385394,1.1180089220467044,0.14581973912258778,0.5954887170022197,-0.0849048455752762,0.1407022642016925,1.6597733843494986,0.1589098414748738,0.0914035619547322,0.25324505525463076,0.23738159933912586,0.3681708853634864,1.365983065756937,0.4925783587655297,0.47107909191465586,0.3749961585685138,0.3587540202140846,0.18420456109959382,0.03510862023077711,0.22550263711972124,0.05418473213423215,0.07658785642458724,0.04632117317008628,0.2455441213407232,0.6151654698332167,-0.054443397709622185,0.2920368244986721,0.8762667403761475,0.035791514120465745 diff --git a/tests/test_data/metab_colnames.csv b/tests/test_data/metab_colnames.csv new file mode 100644 index 0000000..8d033e7 --- /dev/null +++ b/tests/test_data/metab_colnames.csv @@ -0,0 +1,25 @@ +P0.05 +P0.11 +P0.16 +P0.22 +P0.30 +C0.05 +C0.11 +C0.16 +C0.22 +C0.30 +N0.05 +N0.11 +N0.16 +N0.22 +N0.30 +L0.05 +L0.11 +L0.16 +L0.22 +L0.30 +U0.05 +U0.11 +U0.16 +U0.22 +U0.30 \ No newline at end of file diff --git a/tests/test_data/metab_rownames.csv b/tests/test_data/metab_rownames.csv new file mode 100644 index 0000000..a3a4119 --- /dev/null +++ b/tests/test_data/metab_rownames.csv @@ -0,0 +1,75 @@ +34hpp_c +6pgc_c +accoa_c +accoa_m +acglu_m +adp_c +adp_m +akg_c +akg_m +ala__L_c +ala__L_m +amp_c +amp_m +arg__L_c +asn__L_c +asp__L_c +atp_c +atp_m +cbp_c +citr__L_c +cit_c +cit_m +cyst__L_c +dhap_c +e4p_c +f6p_c +fdp_c +fum_c +fum_m +g3p_c +g6p_c +gln__L_c +gln__L_m +glu__L_c +glu__L_m +gly_c +gly_m +his__L_c +histd_c +hom__L_c +icit_c +icit_m +ile__L_c +leu__L_c +lys__L_c +mal__L_c +met__L_c +nadh_c +nadh_m +nadp_c +nadp_m +nad_c +nad_m +orn_c +orn_m +pep_c +phe__L_c +pi_c +pi_e +pi_m +pphn_c +pro__L_c +pyr_e +pyr_m +ru5p__D_c +s7p_c +ser__L_c +succ_c +succ_e +succ_m +thr__L_c +thr__L_m +trp__L_c +tyr__L_c +val__L_c \ No newline at end of file diff --git a/tests/test_data/metab_rownames.xlsx b/tests/test_data/metab_rownames.xlsx new file mode 100644 index 0000000000000000000000000000000000000000..0a3041eff7fab93cac9b052dc3644a7c959c441e GIT binary patch literal 9690 zcmeHNg;!k3(jS}&1b0Yqf_nmlURcM0yngZnqY z+qb*f_x%O$-8tvp(^L0XRoz|H)m?QJWe^bY0LTDT002M<(BDZk)`0^6LJmmE!fglSJlZ1Y@^NUXkkwA1reS;1pp6w|9{ti@d)Hcbj!D}V~L$eUcOppk^WIE zjQVsN+K$7hB-q&cxh)r@m1JUalN4})^)eOTl;;~x{|^_={a)i@ON(--e_M?*dXQH~ zqnZvW58LzwG^YZGm*t}gi!&pm$xFe<}3@$ncODs}|K~ye32<&w-6e(Y;Fz72+ zS)WJC)Z5Tka*e(N!Oyb$h1Oxr^vxmH)bl)+<0dK22|UczYzsAGYH)q)>fAv8Dd-phw3N7sDe!G&FA39D(XF{=F$~cHf)=;XtdrJMlEDKJfA)RS>LWZSE;*B8T zQRjZyH9hkp_-6;@@gjGA5Dp$cb-6=nQQ}`3tSs_M=Cm$FUO9PW1M5 zA&hyI*{L#}bJXI)`=Z~l`dKwdfVdfCegp!sUYc!kZ)WvR3*kmzs%#hd6;<%0{QTS> z?=c>gx$#iQpHFscC>FoNM&D?%(6z&y^5~32O~shcq)0!>`Z<-8u7P>ufoOaK?v*Qx zd_spZ6*tZ)XTL-{ZOV~{W-0f6ccN1(53nV#W3Lk$M4mkhi%|b`5--7s=mXe@RKuKv z1b_^6G+;WKcs5C-G&-+kpP%gMB|W7VNue_(frx5vkxv}L2( zQrpBt?JQ-OrlaI?Kb#|Ftk!-#Cc}mR@pIbkZMQ#pim`}*d(^~~9f*VIjBCEjj|AyG z=tV%)-!6Czl|aJ9+4{Mew~dAoXM5AtAuW?i^ss8kkK445-Hy}L zX5dj5%x1bvmp#vYRJIDBr4m!s*r%htV zsK0724dtBr%$m~9(O1awWFF@}6>#;lrTEYxLGHm2ZnN?wwnlAt!S>}v7emAJFXryU zUBl(h_R%@mO#jnlZn_N@-4OtQe%S5@6ZQtoWd3R_`D#j#G+r!sp^a;V#l$H(VN}L9 zA^`0Sd$o+o-On&bm5_qw zApEIn(*CEicW-P46_I52{SBTFu^4p5n3@`Zwo?7n3#wkBwlWa8))iVu?bSkF=h;(0 zM^)k6-l!*%4aQyKRr&>H)t6Y$+5+|!M9O9cL+u|L zPhSJSc@f5uFT1jQgcg|S=Ha6{`C!VCPUF6CgtC9po z#si+Ht=)PYbP}{fq;JiV2cCi*X1UU7gm%VXAUIGIxXADcLCxY%GOcmd;t!f5TO4&2 z#RmCvhL-A2G4(U5`tY9*{1CWFz<9?5RSF%KCfaiid;3z!a-Ayz)kkrQ{}kSIey+h# zK3vQoN>j=25mPYPcpw3h*0A}rvMdbwC%C)(qLj51Yo!`1^;;xd+>f&N!!`mfCD58g zbnzi;4U1RF8EeUYgU8wuxonlwffmd0!iPf>vuYMiJgI!KQ-VGRoP`#cqWb2@o7!sG zI1yZwvwFLj>H<;1v6Y|FE<`5cG>z*sKhqp33zZP?YQG*HiG3sZo|?(t=*^asC8y1{ z7mjngNu`X}G&|{b$_=So15Rb>QT{MmKh=Pde-IRXg;clOB++~Jh@1Buahhwpsr;vM zt{!rZns5j&Z`@)mNQB{S_r6j23P0|&CT~Du^)R;-NP|$)0}Xn!Bu<7${*j!xw>bS} z0b+0R{BWtkW{h;`5G%#}MUwf}IY$ye>L8g}s*o5CTJ?k7c6vld&MhpC%T@Rx&nkBd1n2*r6^;(EeN(t72ob6NHC z!4ppHnK^LQa|w<2IEg#tEYX9yd58V`sD~jyu~$t;yd8MKoUu3m(N(Jm8Vqt^E4v14 zgY@v;Rc&mY%)vIdt9rVch1oPa*0tb-2iEycm;Dkmuv}(%L~*?<<)chKR@S6~+H?woI z2Li#4?acLELLSlu)4=0O!yZac#b+&MYjMPs11H+pHQ#th zKEU~~5F^=zzk_X9d`XTa)q9W$lx89Qc^ZzkWB-Uiyf|T|AmW)VgQqEJuyMeYvAO<8 z+^g`u3%Zcyj6wDB9eAsNLNlG>3fn9LX=A6C@XIHZVnE_2ZJ&HcO(j0WMWQZ+yPiuBkVkPG)pj_4SNgIuV3`?m9M!I*O*lb$1fm^HHQmGi` z2+`G|gDGRx#F5L)g8VPHqGbxt5UQk}YtRA~;i4qVF>_;BR!S;J9KT4|<-%kffPyq$ z@L^-|8oQ3umhgM$JYWN7bwfG+LE%Xb1Byn{19g51(^J#!26>*nnvuRH{Ep$k;YfAW zQ)TDSG`N)rS$~NeME4P+35(znae|>4HDbT^<#;Rh)X=)gr6aTuA<@lmLg+zL=Vatq zD5d?95eCW2-Zcvn^t4*Y*fZB ze7=fQbERGajqucu7J9?B2lXe?VxVO2vYpxHBPiPxQPP5L#R1#!cMEKk&sKs!@n~jX zW~VDQOvuDw{I6XJD=dUDNjsZ zV0`^dj~>{~{y-e`97wm+O+z0}uk%sjU^-nA`NwC6zQ9mXB_X>PX9la42GBfjbrfGe z9V}p!2LqHWf+EYq=Mw)vg`eYhr6QFm001`C?P>ci{MZ_UEx>GdcaB@j-qP$1A+5k~ zK=t)Lxd9ity9vvl3RWVZwuZur?y&1#dDa<2CC{ABb%1 ziCncD!tst;?#BOxwRqe@U|`*~aJaq$8`sFL!1Zcfdpl2v&B^Dym{c?>niZ*Ww4Kw( zRGlCDO^Uai73h|vr(Y>A7--EgzsT?*M*M8FS=p$Ju2hTCxtQ{E6MV>Dv_ zxbi3|9MN6N3LAt}q5mck%@ybjQh(^y@Fti;?nT5r(TJcX^ZLh>0QHTTX?k*wO1X#; z1TMP1Qd4~?qOHpp1E^I|2y_EThT52`u?OA2D&@!euNhBMH_ul4^JZ(bzN1uOskj)( zSc49tyI0^34hDJ{qK3EAuj$Rly$jqC-kB2em~P$_2qH9=5Wg^K%gE<4=DxCz0m-Cn z4W-r$KQMh(pWaa3!ne+Sp*J%G5stk+-{JbipQhK+OsePy*_wB8pV%E?u7v}iu42>+ z{w!+_^W{nLA6#}NoG~w(?j@`9W#;9#ZRYRIoFiG?gGU-H3T74f4t-*(oB#ckm=FXo zrf3PIlPpjvZshV`)XA+BeZ{EaH~v`qeKRfkg&vmh`skI_1%&w%CMv6xnNFkV4!Vh; zWFMlO+PDiqvkqr@g=enT@%kue?Z#>UJ0V-r4cenYa5|@2)DKGeC~y_|^>zEr)se$` z!_D%-RGqzh)GckxFom% z@*T9!Js?M6(1UoP*uZ!xSt?l;Aeootho51A%=4WjT!e)R=D33Rq2RZT7kNem<0X>$ zcy>LP?13!v9BcXgzQX{_qqnqZ3hJFh0#&ag--mG2TlESw2CU2vGWs4$Ycrx?e=|=AK)83S&+aLlmUQs!&oU?ROl&Fc{RWzJ#<{vpY@cNot8N!*4i zLuNJ1bB%@Xiqfxj)%JoztNocWz4OkHlMf#o^@mGWtOZ^>>r5%tHh0E;N>PsID_uxJ ztH%!pPv%h)w(L$+q?sKW1hHRuA!=l*BKlv0Y02tq6)Ni?H2>Qbt(Y2s5* zCo?DGP+RD`(!lcuRK%J*W2+5Culj~gbIeoTi^ydLrFusf^MzWY8VS4m%GZBZBY2{V zp`wV;VgZ@{W4`l~%+AfgWL##%hD#^YWK8v=O8f?yx)QdpWIB1)#|!ShWxZHm!&Ts? zJ1rNhSu8ANNOy1QOD8L$AZT&Z(ADyk_jORWP-tehUP>*4ra6()iOiy*=Nsl?2NWh1(X*Z52B2qX%VyrsFSewO9GM0z2wW{R}q)HnS+ zqw0VGLk7vs~@v*ZD8&L3FTfu>Qye=dwnH8;!XRlPOnU@xgDc)y4l3~vP5z^vh z8+EZGgm1-jWS3=?Bc>3qUqbSLq~Q3&UYR`AxHW=IS1gov9cRoDHK^|uSAu;V(qZrd zr#z)&y8B79Iq(A;7i}^A&9fX@eC3DVK5_=d=YKwXk{O8FYW(Bq@Bq@{MN1c8u>8Ep z)+1;6W!=2H$#Uand32|~h+*#5$&i1!tvwoppbSBuZt&@}cNvYYS55zyGupV~NXL(q ztt17)E)MdvWaNmkd24umE#KVPsv!^zVpEPD;Ex^V8>HV=P< zm}?X7cv9COS`gFoC6jn}RWGshKq-F8B_CC~M!_azraazf7za{wnE>sW6H``9co`UcOI7p@@`jbXw}WJpIvgcyw8dIR|*EqWzGmZQ#*A`@hO0u!b2OS5Z_tJ&vM zgvdU%2Nw;I0Sb3cNFsF_o@H}Sr@8ZDh##e5&bwYzK`V$7ZEUm}GZyT2CH~{)mElM| zF&LIoA0-609HlHj0ymtGJt2|jE; zu_#SxMbTp%)I=Z_@Xk`$3?WyS*gUR>Lq!C(8I=N4Wrz=o;aDy^?B7{smdgiuCR?_< zt_iEQ(9IOnd@_rre_8Ipd!Y4J#0(l9z{cbjc89Oy(n zbK!y7@}#FJ=qKAAeq`-eTEV(+;TjXCiA9qS$H=2)Fmt=s=U&KLC$T*n%$hX7l_SJ` zyb`4Um{v@AS*AXrKXb{$wk{WM)@nD9H=8T&fIC@%LF=m@;7Zl%5Yk5D|BJMg0wD!8 zE4|;yWV>GX^kW85nEUGi>Z@d?!;|uPfykL6NV`VBHr5i`r-I+5yS&rg3`b1Jn8J$yd=~N$F|oEQ`~tA{ zsPujEWjiDvS162UnxU!$X`;f8(mJQ9T*H_4b+Za<7iYX~^&Ud5f{^A_y=&gN)$6Ss zp&Q_ttCRDUfc9GVk-f+4*5jpBUTt=_jpP%D)$8-k%J_2Kb`zJ45FL^#qTA<{GwW8u?tAi( zc@abwA{k(Oh3U_ztx%&3XmwCF!mWf4a;yCpCZ zJM6rI2YUmSDzh=xvj!We*jk%d8r>bkZ6o<1KiIK+E&$h<@E5Pw#wXcnswC$b!OG-B zff6{YOf+E88$qT?$%RMJ=iEH}GCKu+Sq)7NU#nH47wHRGF~1BeWlV~31?mbVHwgL{ zJ|i~TP#H;kZHKQg{5?8#Y-|t$dgN=tB6RGgrjGK4O=T=>HbDhgJP6`&>lN#+(k#&0 zyEZZ!2T#L2$J#6yx_ZGgXeK;@R3~lJjQ|ul#2BI7q+es4{l; zTb-^`M(%e9ED?`b z4pl1YzU7xiDgke+L{?*;(kHVBR&G@?aa_F*#$NI*MvAqT+A}`T^kflP)r#WRB%gCC za>jg~N3!cvO&&{aLn&^^d(@4og{cW=yWgytNjzL;`rBZ%h;mi7GSB#ZlcYe~W; z*$$Ry!G@*K4Im&zYlxK%8wg?z{#Wt$f0=Wb^+$y3Dzs4GeV>!N#CX_WUYZyuHN~n_ z@+3OOTzrYts|KGX0x-2bEpwAUX3i$q%y-hx$72vwmk))otB){BNa3Xc@ban@Ysl)% zqZY`J#+1IBs4;a6!ZB;&MH3Pa`-~zd$rUv5!adug0RxBm7!!vPLEX}!BjU5EwUq_I z>3!tA7-n698yHq3?G>;kI^lVs*1K#8Dw5EIV96_RE=D7<-vb(YqxU$pr{kNAk}mcs zDs=J;KSVC%U;SW+FVP{JabXe%4Rb4TZR($10^PL)3Tkpw6}JnCQmB?bvLlR)X1*RA zf_h+ z-ei|=ajciZwdQ)Vzg72e->ClKjBW>Imxq7njE^HC9=_SfmdZZf_)?2}&)d z@y`$28doSE9GSGA3MOaM5&V+9gOSMOENkHXwbfcF5WWsrc61^AV)rqtP!N>J^&zWc zek-=rkBuM&)6XwkTM2SH2$C2FIol&63^cbq397bjvVb`VeI`@g1KeZtZtRdp&QTg* zC#LRZ?I;rhOgD2$~Gr!Fi4KOT`~v(!IE ze@?r`8Oc{+JR81}#u}NBWop*A@H}MTA@56Cp$9*)^l_*LrbD;B);2OJ zT_QHa<>Ls@pe1q5Q^bdJ*oX0MkW&3U95+L zXMsh<|NIrrAG7wy^FMr3qbT!t27j;j{{g&xM#Eg=FV+9wfq$=o{uNjY)Aj$ai2ly! z_rlnpoOWTQvfs*Nzk`2I)&B{OL%-iR{5x^~JM{OA=$}wa*pdO0`+I)$cLu+owEkqE zLHKXQ|8eg6oy+f=ojt<8 literal 0 HcmV?d00001 diff --git a/tests/test_data/metabolite_concentrations_clean.csv b/tests/test_data/metabolite_concentrations_clean.csv new file mode 100644 index 0000000..8ff0af5 --- /dev/null +++ b/tests/test_data/metabolite_concentrations_clean.csv @@ -0,0 +1,76 @@ +id,P0.05,P0.11,P0.16,P0.22,P0.30,C0.05,C0.11,C0.16,C0.22,C0.30,N0.05,N0.11,N0.16,N0.22,N0.30,L0.05,L0.11,L0.16,L0.22,L0.30,U0.05,U0.11,U0.16,U0.22,U0.30 +34hpp_c,0.186145072,0.149284006,0.075812942,0.043821173,-0.138799502,0.223705491,0.083799554,0.019563544,0.21251327,-0.563013611,2.754160197,1.419276891,2.291585844,2.298898149,2.056389749,2.014084458,1.609359478,0.613220439,0.002048191,-0.213485156,0.429088936,0.084990064,0.098869852,0.114292473,0.096981331 +6pgc_c,-0.206191559,2.550635323,3.648710342,5.037904508,5.201483535,5.086230115,5.546989627,5.851165575,6.194841802,5.399213594,3.646573394,3.239782106,4.326667841,4.869701438,4.584469909,4.0490329,4.295664446,4.404163441,4.758261139,5.002436584,3.459180907,3.632204235,4.430967866,4.690799756,4.705934898 +accoa_c,-0.059444782,0.607065665,0.815747862,1.011816082,0.772238066,0.611873294,0.732403897,0.846778814,0.869109581,0.681819573,-0.069727052,0.322504687,0.3866966,0.457818795,0.22958456,1.701156389,1.590086455,1.371425343,1.224588307,0.977340882,1.211316977,0.969404929,1.214945492,1.038262743,0.777735442 +accoa_m,-0.059444782,0.607065665,0.815747862,1.011816082,0.772238066,0.611873294,0.732403897,0.846778814,0.869109581,0.681819573,-0.069727052,0.322504687,0.3866966,0.457818795,0.22958456,1.701156389,1.590086455,1.371425343,1.224588307,0.977340882,1.211316977,0.969404929,1.214945492,1.038262743,0.777735442 +acglu_m,-0.141348468,0.479105282,0.533575378,0.314384023,0.115159857,0.718912467,0.90377356,1.057919428,0.753341816,1.025286343,-3.286692938,-1.93034945,-2.45617888,-2.053673042,-2.006540677,-1.570166934,-1.550862945,-0.570209134,-0.141057843,-0.280831428,-3.610209904,-3.340978803,-3.064840607,-2.678400716,-2.209161567 +adp_c,-0.041110167,0.327194988,0.531883554,0.823430585,0.861530161,0.823999221,0.884686789,0.896936631,0.925981034,0.769721462,0.629070862,0.765555941,0.647786744,0.607149966,0.472745448,1.040339687,1.116630779,1.191391346,1.217770927,1.241667524,0.07321361,-0.009768294,0.168438814,0.181719745,0.193201265 +adp_m,-0.041110167,0.327194988,0.531883554,0.823430585,0.861530161,0.823999221,0.884686789,0.896936631,0.925981034,0.769721462,0.629070862,0.765555941,0.647786744,0.607149966,0.472745448,1.040339687,1.116630779,1.191391346,1.217770927,1.241667524,0.07321361,-0.009768294,0.168438814,0.181719745,0.193201265 +akg_c,0.227900586,0.273252615,0.037989342,-0.501219832,-0.989264696,-0.55162106,-0.354515819,-0.305739075,-0.603651622,-1.286118494,1.735367999,1.208440453,1.503187876,0.956688749,0.301646035,1.039643342,0.048264363,-1.212762956,-2.052170004,-2.455911425,-2.678692989,-3.118361686,-2.986801786,-2.894548809,-2.777452245 +akg_m,0.227900586,0.273252615,0.037989342,-0.501219832,-0.989264696,-0.55162106,-0.354515819,-0.305739075,-0.603651622,-1.286118494,1.735367999,1.208440453,1.503187876,0.956688749,0.301646035,1.039643342,0.048264363,-1.212762956,-2.052170004,-2.455911425,-2.678692989,-3.118361686,-2.986801786,-2.894548809,-2.777452245 +ala__L_c,0.035177478,0.001595396,-0.07395381,0.001377907,-0.427690976,-0.918058738,-1.371281182,-1.402011567,-0.823615137,-1.134876626,-1.374922269,-1.732728043,-0.996731317,0.103855174,0.26102448,2.212328732,2.36201275,2.178040063,1.822404367,1.204572385,1.265639494,0.830177482,0.843034055,0.697924139,0.489358648 +ala__L_m,0.035177478,0.001595396,-0.07395381,0.001377907,-0.427690976,-0.918058738,-1.371281182,-1.402011567,-0.823615137,-1.134876626,-1.374922269,-1.732728043,-0.996731317,0.103855174,0.26102448,2.212328732,2.36201275,2.178040063,1.822404367,1.204572385,1.265639494,0.830177482,0.843034055,0.697924139,0.489358648 +amp_c,0.059243786,-0.092046228,-0.221613445,-0.537429213,-0.820293229,0.401123828,0.158512789,0.030457273,0.041640522,-0.79500854,-0.045977239,-0.496955125,-0.308767059,-0.433996448,-0.575187334,0.443735657,0.184781246,-0.115231576,-0.380091561,-0.617375341,-0.020612818,-0.334572005,-0.418703583,-0.643957118,-0.794788432 +amp_m,0.059243786,-0.092046228,-0.221613445,-0.537429213,-0.820293229,0.401123828,0.158512789,0.030457273,0.041640522,-0.79500854,-0.045977239,-0.496955125,-0.308767059,-0.433996448,-0.575187334,0.443735657,0.184781246,-0.115231576,-0.380091561,-0.617375341,-0.020612818,-0.334572005,-0.418703583,-0.643957118,-0.794788432 +arg__L_c,-0.01026546,0.231185812,-0.023717937,-0.230325399,-1.022796115,-3.579402148,-3.690731167,-3.343411479,-2.846205339,-1.743729336,-5.035600275,-4.027535841,-3.258966394,-1.329606406,-1.003661687,1.138677401,1.156867748,1.06356282,0.690478867,-0.364477274,0.108631682,-0.110777885,0.031370097,0.138067325,0.006116633 +asn__L_c,-0.139910651,-0.191947973,-0.388580153,-0.784312497,-1.156454461,-0.458678415,-0.885980526,-0.888771862,-0.675029386,-0.549403223,-5.432525612,-4.609296652,-4.551877591,-3.29303666,-2.7278951,-1.681818368,-1.28286352,-0.123140035,0.309382474,-0.119088086,-1.054905881,-0.92290652,-1.022383172,-0.978252073,-0.865743448 +asp__L_c,0.01813934,0.249743048,0.284719949,0.541776169,0.517781756,-1.335920995,-1.223574463,-1.041968705,-0.76633295,-0.031669948,-0.388820224,-0.304223165,0.144732809,0.914380084,1.063907436,0.61941104,0.751963418,0.686166501,0.620278734,0.473637325,-0.03815547,0.078949977,0.195620435,0.487797849,0.640043324 +atp_c,-0.109196468,0.52859097,0.872684843,1.33822893,1.482567138,2.426492347,2.490793784,2.526931623,2.472949206,2.282999194,1.25743606,1.488295948,1.432960261,1.448543655,1.410530138,1.660133532,1.85767109,2.133597884,2.314669447,2.39827608,0.983379033,0.991382122,1.312781022,1.381330495,1.424876231 +atp_m,-0.109196468,0.52859097,0.872684843,1.33822893,1.482567138,2.426492347,2.490793784,2.526931623,2.472949206,2.282999194,1.25743606,1.488295948,1.432960261,1.448543655,1.410530138,1.660133532,1.85767109,2.133597884,2.314669447,2.39827608,0.983379033,0.991382122,1.312781022,1.381330495,1.424876231 +cbp_c,-0.002569081,-0.017744221,-0.032146373,-0.04423088,-0.037846631,0.087785108,0.072046455,0.080700031,0.07995996,0.127639385,-0.011079037,-0.033628742,0.040344418,0.109234951,0.164714964,-0.010551267,0.004475815,0.016468074,0.029658345,0.02041945,0.199939016,0.23153687,0.228610307,0.247197202,0.254135663 +citr__L_c,-0.227950266,0.70677914,0.658178476,0.77283643,0.51206319,1.227168391,1.330723906,1.991130978,1.92337589,4.34957663,-4.367716822,-2.397126845,-1.303450674,1.674881272,2.839625895,1.082873915,1.594218968,2.850263329,3.307913554,2.465726814,-0.860064777,-0.070771951,0.703929302,1.973296146,2.901205311 +cit_c,0.248173564,0.33492399,0.372946672,0.317880771,0.060937468,-2.736856727,-2.567386822,-2.774041476,-2.505254525,-3.817096925,1.0046576,0.139458627,-0.360595701,-1.271120889,-2.321474277,-0.358183825,-0.943231313,-1.651931568,-2.214237482,-2.124029895,-5.747420375,-6.312358973,-6.421584505,-6.440590864,-6.215741548 +cit_m,0.248173564,0.33492399,0.372946672,0.317880771,0.060937468,-2.736856727,-2.567386822,-2.774041476,-2.505254525,-3.817096925,1.0046576,0.139458627,-0.360595701,-1.271120889,-2.321474277,-0.358183825,-0.943231313,-1.651931568,-2.214237482,-2.124029895,-5.747420375,-6.312358973,-6.421584505,-6.440590864,-6.215741548 +cyst__L_c,0.044197153,-0.481694947,-0.951020697,-1.685027306,-2.435634704,-2.016298922,-2.425946939,-2.435950611,-2.347666265,-2.392740194,-4.386560908,-3.717060074,-3.689994096,-2.805560764,-2.691377244,-0.018621935,-0.231673834,-0.158185068,-0.540054682,-1.426376814,-2.245365048,-2.673265179,-2.727347292,-2.798310046,-2.801805457 +dhap_c,-0.105145736,0.956670912,1.552604595,2.742509029,3.183776681,-0.087923769,0.436335325,0.744095046,1.057895213,2.236548621,1.836980348,2.345324362,2.415844563,2.913792433,2.887956861,2.102534162,2.6061122,2.770494048,3.007841786,3.307389927,1.170055992,1.456645503,1.918092104,2.330153228,2.505352278 +e4p_c,0.041799062,-0.556652257,-0.668356371,-0.754084205,-0.89496886,0.758610986,0.199379402,-0.100189112,0.089510825,-0.887590459,0.286254578,-0.275997421,-0.309659144,-0.33796121,-0.348331265,1.481737476,1.577822309,1.534594194,1.293271579,1.056763076,0.520201785,0.025507885,-0.090643589,-0.415427722,-0.598038849 +f6p_c,-0.174485817,1.055852815,1.639500709,2.450196973,2.763564552,2.440566686,3.076290427,3.381420327,3.032850016,3.759473104,2.155163722,3.303102406,2.856510321,2.581577622,2.341253071,2.13999599,2.258402145,2.425083193,2.666857464,2.900121182,0.897802618,1.101466632,1.74946685,2.023794827,2.138935605 +fdp_c,-0.248382264,1.610515145,2.76840536,5.000400994,5.898780149,1.801480352,2.878394044,3.45200459,3.522891727,5.766163668,5.138633171,6.696890271,6.258137093,6.451696172,6.2359922,5.531255662,6.306460763,6.379899452,6.676592818,7.193860781,3.36223879,3.702495168,4.798706382,5.398196632,5.55421198 +fum_c,0.141186378,0.295801844,0.304349278,0.455530564,0.478429351,-0.12384668,0.141843819,0.284764203,0.220865828,0.465971809,3.025563075,2.478052215,3.008478976,2.931050049,2.697798132,1.746065717,1.364581097,0.457434889,-0.025943407,-0.095267989,-0.182143972,-0.242543042,-0.030871152,0.272792262,0.451150256 +fum_m,0.141186378,0.295801844,0.304349278,0.455530564,0.478429351,-0.12384668,0.141843819,0.284764203,0.220865828,0.465971809,3.025563075,2.478052215,3.008478976,2.931050049,2.697798132,1.746065717,1.364581097,0.457434889,-0.025943407,-0.095267989,-0.182143972,-0.242543042,-0.030871152,0.272792262,0.451150256 +g3p_c,-0.100983943,0.979224171,1.582486203,2.721194436,3.006109086,0.087455121,0.508166181,0.756810459,1.115906148,1.850422169,1.846678794,2.239691781,2.326294327,2.679107666,2.522671658,2.776585231,3.18560589,3.136307872,3.222143245,3.390334151,2.050424091,2.090776522,2.524727006,2.670541021,2.592049924 +g6p_c,-0.174485817,1.055852815,1.639500709,2.450196973,2.763564552,2.440566686,3.076290427,3.381420327,3.032850016,3.759473104,2.155163722,3.303102406,2.856510321,2.581577622,2.341253071,2.13999599,2.258402145,2.425083193,2.666857464,2.900121182,0.897802618,1.101466632,1.74946685,2.023794827,2.138935605 +gln__L_c,0.028440942,0.12778732,-0.165891675,-0.580849246,-1.084082148,-1.638641758,-2.014353953,-1.921140802,-1.423028832,-1.295957411,-4.350646722,-4.484161159,-3.475788761,-1.642795315,-1.119549322,-1.261573069,-1.125978551,-0.547043761,-0.469292013,-1.045788077,-2.428769703,-2.257398558,-2.335669986,-1.882522373,-1.43876824 +gln__L_m,0.028440942,0.12778732,-0.165891675,-0.580849246,-1.084082148,-1.638641758,-2.014353953,-1.921140802,-1.423028832,-1.295957411,-4.350646722,-4.484161159,-3.475788761,-1.642795315,-1.119549322,-1.261573069,-1.125978551,-0.547043761,-0.469292013,-1.045788077,-2.428769703,-2.257398558,-2.335669986,-1.882522373,-1.43876824 +glu__L_c,0.028453531,0.145445726,0.009579117,-0.342180588,-0.609449122,1.061505417,0.914700016,0.922410219,0.819112136,0.393221374,-0.527183435,-0.714354143,-0.287260531,0.07090152,0.139728156,0.058644748,-0.17395567,-0.161476172,-0.26006749,-0.542745525,-1.133188565,-1.15326712,-1.070046228,-0.885676727,-0.664767635 +glu__L_m,0.028453531,0.145445726,0.009579117,-0.342180588,-0.609449122,1.061505417,0.914700016,0.922410219,0.819112136,0.393221374,-0.527183435,-0.714354143,-0.287260531,0.07090152,0.139728156,0.058644748,-0.17395567,-0.161476172,-0.26006749,-0.542745525,-1.133188565,-1.15326712,-1.070046228,-0.885676727,-0.664767635 +gly_c,0.036938262,0.121343489,0.002834791,-0.021244354,-0.177746898,-0.142568233,-0.275650739,-0.144444502,0.053829474,0.460683344,-0.619960889,-0.790995006,0.012575341,1.12253138,1.464675979,0.745997858,0.806899721,0.856596254,0.754573518,0.404479544,-0.571107253,-0.450708489,-0.308037129,0.134650065,0.484238458 +gly_m,0.036938262,0.121343489,0.002834791,-0.021244354,-0.177746898,-0.142568233,-0.275650739,-0.144444502,0.053829474,0.460683344,-0.619960889,-0.790995006,0.012575341,1.12253138,1.464675979,0.745997858,0.806899721,0.856596254,0.754573518,0.404479544,-0.571107253,-0.450708489,-0.308037129,0.134650065,0.484238458 +his__L_c,-0.023498794,0.031512886,-0.247675275,-0.426489931,-1.101993186,-2.783319299,-2.900385851,-2.557504177,-2.25877713,-0.913861516,-4.520785709,-3.220498223,-2.702443117,-0.805487108,-0.411726534,1.549501124,1.623285664,1.707486581,1.361575946,0.307661616,-0.751037783,-0.927766712,-0.648240821,-0.340807672,-0.240398446 +histd_c,-0.024065851,0.080511829,0.201269522,0.853196923,0.978782048,-2.396041173,-2.574343414,-2.471731588,-1.609150541,-0.679478472,-1.621343337,-1.795361839,-1.124086046,0.447990672,0.954258846,0.569697497,1.323052597,1.813512031,2.01721072,1.939049467,0.735169069,0.93214849,0.900020404,1.206842056,1.365492746 +hom__L_c,-0.031497383,0.381146824,0.416494551,0.419806412,0.097580036,-0.185801065,-0.098860084,0.060821286,0.053690588,0.248339079,-1.009439656,-0.415234,-0.306210493,0.086975838,-0.004040153,1.285911622,1.147559253,0.991317588,0.791390064,0.386314593,0.118892587,-0.064805472,0.1720725,0.174616954,0.088725329 +icit_c,0.122927236,-0.047750936,-0.046233061,-0.431255506,-0.537513575,0.303277336,0.233915794,-0.163192627,-0.330618885,-2.285961629,0.916400058,0.162946059,-0.724480099,-2.267988529,-3.100490875,-1.518693179,-2.017788103,-2.188846307,-2.340723697,-2.020485818,-4.099291637,-4.535928878,-4.779902009,-5.119284825,-5.083499359 +icit_m,0.122927236,-0.047750936,-0.046233061,-0.431255506,-0.537513575,0.303277336,0.233915794,-0.163192627,-0.330618885,-2.285961629,0.916400058,0.162946059,-0.724480099,-2.267988529,-3.100490875,-1.518693179,-2.017788103,-2.188846307,-2.340723697,-2.020485818,-4.099291637,-4.535928878,-4.779902009,-5.119284825,-5.083499359 +ile__L_c,0.033184368,-0.047661316,-0.027096334,0.32868893,0.267128237,-1.792382242,-2.277455585,-2.39364705,-1.476688897,-1.630860803,-1.893529436,-2.640986919,-1.96335525,-0.553396341,-0.191512347,0.256077652,0.863735132,1.408680786,1.521346838,1.361938138,-0.802939976,-0.844660787,-1.003451638,-0.806707426,-0.58287211 +leu__L_c,0.033184368,-0.047661316,-0.027096334,0.32868893,0.267128237,-1.792382242,-2.277455585,-2.39364705,-1.476688897,-1.630860803,-1.893529436,-2.640986919,-1.96335525,-0.553396341,-0.191512347,0.256077652,0.863735132,1.408680786,1.521346838,1.361938138,-0.802939976,-0.844660787,-1.003451638,-0.806707426,-0.58287211 +lys__L_c,0.022463434,-0.166381898,-0.48784326,-0.880909629,-1.634387854,-2.500442596,-2.77369716,-2.648651286,-2.393115526,-2.012741579,-4.094742929,-3.234735088,-3.020859682,-1.824282002,-1.723832236,1.214333149,1.09834943,1.003519984,0.541667708,-0.432161313,-1.112282307,-1.571863525,-1.475796192,-1.518054203,-1.619808656 +mal__L_c,0.129968257,0.236639658,0.259777238,0.262761909,0.190917737,-0.083409246,-0.201904397,-0.332816672,-0.044127839,-1.005120582,1.545263796,0.283120805,0.846000178,0.726645175,0.486378733,0.264312037,0.053945816,-0.421253796,-0.661995517,-0.593451858,-0.403638463,-0.572040276,-0.707481607,-0.747951656,-0.73586526 +met__L_c,0.071251735,0.173220659,0.087475311,0.206796191,0.026274235,-2.84920725,-3.153062129,-3.129155927,-2.230403507,-2.072208807,-2.780202974,-3.543506998,-2.53095398,-0.882397109,-0.480666408,-1.029445053,-0.625393854,-0.197878511,-0.085449641,-0.281533445,-1.671084143,-1.493180985,-1.703518336,-1.322169331,-0.972984659 +nadh_c,-0.067511418,0.471531101,0.949427732,2.204598663,2.643238675,-1.502814238,-1.290157011,-1.103668322,-0.42256326,0.826673686,0.886660523,1.165747052,1.267301588,2.231128833,2.388263789,2.216524209,3.017272383,3.367664398,3.563325001,3.757713994,0.801944551,0.961795474,1.261805886,1.657076072,1.859892118 +nadh_m,-0.067511418,0.471531101,0.949427732,2.204598663,2.643238675,-1.502814238,-1.290157011,-1.103668322,-0.42256326,0.826673686,0.886660523,1.165747052,1.267301588,2.231128833,2.388263789,2.216524209,3.017272383,3.367664398,3.563325001,3.757713994,0.801944551,0.961795474,1.261805886,1.657076072,1.859892118 +nadp_c,-0.086370495,0.921742907,1.245317767,1.56232163,1.447820024,2.152871564,2.402662682,2.590347545,2.438544009,2.315769121,1.017593038,1.434169491,1.624539274,1.722363115,1.52724483,2.042854316,1.91222572,1.805448714,1.769186796,1.61838584,0.868107003,0.812439277,1.259629109,1.357817259,1.351030159 +nadp_m,-0.086370495,0.921742907,1.245317767,1.56232163,1.447820024,2.152871564,2.402662682,2.590347545,2.438544009,2.315769121,1.017593038,1.434169491,1.624539274,1.722363115,1.52724483,2.042854316,1.91222572,1.805448714,1.769186796,1.61838584,0.868107003,0.812439277,1.259629109,1.357817259,1.351030159 +nad_c,-0.041612966,0.244031721,0.357947267,0.466637478,0.425725899,1.935239829,1.84012545,1.831874463,1.768682322,1.398345081,0.82433628,0.761984875,0.956262561,1.054294738,1.06945791,1.381523036,1.388235149,1.41526734,1.397651562,1.287538609,0.876920073,0.786164615,0.973687848,0.979111059,0.976612412 +nad_m,-0.041612966,0.244031721,0.357947267,0.466637478,0.425725899,1.935239829,1.84012545,1.831874463,1.768682322,1.398345081,0.82433628,0.761984875,0.956262561,1.054294738,1.06945791,1.381523036,1.388235149,1.41526734,1.397651562,1.287538609,0.876920073,0.786164615,0.973687848,0.979111059,0.976612412 +orn_c,-0.136784336,0.524368843,0.468069324,0.419216548,-0.284283156,-1.373438212,-1.087844174,-0.56285698,-0.728791763,0.899943031,-3.935846643,-1.582671881,-1.590072253,-0.263180471,-0.148769302,2.589854814,2.456422296,2.403570175,2.060189416,0.982434447,0.286190773,0.062106057,0.679199278,0.856983936,0.745100577 +orn_m,-0.136784336,0.524368843,0.468069324,0.419216548,-0.284283156,-1.373438212,-1.087844174,-0.56285698,-0.728791763,0.899943031,-3.935846643,-1.582671881,-1.590072253,-0.263180471,-0.148769302,2.589854814,2.456422296,2.403570175,2.060189416,0.982434447,0.286190773,0.062106057,0.679199278,0.856983936,0.745100577 +pep_c,-0.077738058,0.514019703,0.86989215,1.254360471,1.680240625,5.522300059,5.883549037,5.970136612,5.137711145,5.002749754,5.282186123,5.522651909,5.262345439,4.296727932,4.076474467,2.756700186,2.521110874,2.307357715,2.3216473,2.607897529,1.002237454,1.119485514,1.744792706,2.059856799,2.342209811 +phe__L_c,0.12329297,-0.309012504,-0.567095587,-0.670019932,-1.146723457,-2.108202948,-2.716146362,-2.833732944,-2.107934548,-2.487738696,-2.069743775,-2.735965503,-1.967910689,-0.611380103,-0.414600911,1.417812417,1.569071624,1.498093295,1.072960757,0.402615227,-1.204958322,-1.649252758,-1.756235471,-1.683316898,-1.579503192 +pi_c,0,0.269482283,0.40888759,0.582884646,0.689123278,1.670579427,1.674193296,1.698081293,1.615054473,1.581364032,0.6964515,0.790826308,0.853259818,0.90947999,1.005870991,0.687880146,0.809126612,1.010292839,1.164984821,1.224694858,0.978251724,1.069236717,1.212428508,1.267697052,1.299761267 +pi_e,0,0.269482283,0.40888759,0.582884646,0.689123278,1.670579427,1.674193296,1.698081293,1.615054473,1.581364032,0.6964515,0.790826308,0.853259818,0.90947999,1.005870991,0.687880146,0.809126612,1.010292839,1.164984821,1.224694858,0.978251724,1.069236717,1.212428508,1.267697052,1.299761267 +pi_m,0,0.269482283,0.40888759,0.582884646,0.689123278,1.670579427,1.674193296,1.698081293,1.615054473,1.581364032,0.6964515,0.790826308,0.853259818,0.90947999,1.005870991,0.687880146,0.809126612,1.010292839,1.164984821,1.224694858,0.978251724,1.069236717,1.212428508,1.267697052,1.299761267 +pphn_c,0.024149879,0.06601568,0.068744304,0.178902127,-0.150167401,-0.299521802,-0.514964379,-0.525426931,-0.282246907,-0.536888614,-0.343737097,-0.283754904,-0.098865647,0.360504862,0.25044474,2.387822463,2.36865149,2.093783737,1.70797118,1.221044016,0.361027523,-0.104955791,0.053709395,-0.067113504,-0.215540923 +pro__L_c,0.047262788,0.126579106,0.043772631,-0.204213087,-0.592413142,1.65735205,1.123540919,0.938277242,1.184888998,-0.161097062,-0.355729727,-1.231914886,-0.522162934,0.036098921,0.08165454,1.177641383,1.080160793,1.098185248,0.900691549,0.494720802,-0.36120742,-0.695749807,-0.69285723,-0.738267717,-0.673488131 +pyr_e,0.005873993,0.177271254,0.315752655,0.718787424,0.680401718,-1.1612608,-1.012641162,-0.8986054,-0.709084026,-0.239518577,0.604896194,0.899026671,0.866698213,0.989146576,0.821113009,1.946382478,1.997067127,1.584969212,1.312571603,1.152945725,1.208539348,0.970394379,1.130362366,1.034319217,0.809740105 +pyr_m,0.005873993,0.177271254,0.315752655,0.718787424,0.680401718,-1.1612608,-1.012641162,-0.8986054,-0.709084026,-0.239518577,0.604896194,0.899026671,0.866698213,0.989146576,0.821113009,1.946382478,1.997067127,1.584969212,1.312571603,1.152945725,1.208539348,0.970394379,1.130362366,1.034319217,0.809740105 +ru5p__D_c,-0.176735026,1.630703971,2.504308058,3.903340694,4.391101783,3.055047467,3.553331543,3.854200895,4.113760045,4.52740946,3.333902574,3.425329016,3.928780645,4.429376308,4.393689273,3.102764075,3.612634796,3.908837988,4.32186804,4.721107572,2.483058312,2.839780324,3.504037277,3.949322133,4.15211084 +s7p_c,-0.174477001,1.411720312,2.128485692,2.980526421,3.246016829,5.532257203,5.704662563,5.788806227,5.699017795,4.895246206,3.352454507,3.181097089,3.566397894,3.59491978,3.473796032,2.945238998,3.155493582,3.525618987,3.881746088,4.135425519,1.859782742,1.990648576,2.612029072,2.853361155,3.03801103 +ser__L_c,0.016981629,0.129300224,-0.080131343,-0.293455931,-0.637116396,-1.370889392,-1.552588201,-1.394059445,-1.070837795,-0.541127372,-3.087887194,-2.910524586,-2.171126162,-0.63912782,-0.210313091,-0.474719436,-0.352538553,0.062822822,0.083516201,-0.404964815,-2.058566768,-1.881612972,-1.814794107,-1.313303304,-0.869876498 +succ_c,-0.003938999,-0.619842117,-0.549812714,-0.125860385,0.579098491,-0.548467189,-0.732685751,-0.945727127,-0.576817423,-0.306415418,0.996019444,0.165845437,0.082141736,0.056471327,0.469995545,-1.839255961,-1.136357649,-0.496476172,0.047086809,0.780018369,0.579221632,1.023007288,0.643287928,0.747384758,0.924115464 +succ_e,-0.003938999,-0.619842117,-0.549812714,-0.125860385,0.579098491,-0.548467189,-0.732685751,-0.945727127,-0.576817423,-0.306415418,0.996019444,0.165845437,0.082141736,0.056471327,0.469995545,-1.839255961,-1.136357649,-0.496476172,0.047086809,0.780018369,0.579221632,1.023007288,0.643287928,0.747384758,0.924115464 +succ_m,-0.003938999,-0.619842117,-0.549812714,-0.125860385,0.579098491,-0.548467189,-0.732685751,-0.945727127,-0.576817423,-0.306415418,0.996019444,0.165845437,0.082141736,0.056471327,0.469995545,-1.839255961,-1.136357649,-0.496476172,0.047086809,0.780018369,0.579221632,1.023007288,0.643287928,0.747384758,0.924115464 +thr__L_c,0.011766814,0.276834573,0.246053034,0.384568865,0.095843912,-1.318629089,-1.353019817,-1.155258344,-0.818413799,-0.221267464,-1.318299183,-1.086513542,-0.459678571,0.659973685,0.840115446,1.445090509,1.521695995,1.392078258,1.168950177,0.68563956,0.274000042,0.195146077,0.372282046,0.584410013,0.638609685 +thr__L_m,0.011766814,0.276834573,0.246053034,0.384568865,0.095843912,-1.318629089,-1.353019817,-1.155258344,-0.818413799,-0.221267464,-1.318299183,-1.086513542,-0.459678571,0.659973685,0.840115446,1.445090509,1.521695995,1.392078258,1.168950177,0.68563956,0.274000042,0.195146077,0.372282046,0.584410013,0.638609685 +trp__L_c,0.084144516,-0.312801362,-0.533771297,-0.621369014,-1.131602191,-1.019206021,-1.745094721,-1.90464442,-1.227950408,-1.858846053,-1.936176963,-2.548246671,-1.792663291,-0.440667733,-0.209892432,2.108324464,2.303162795,2.312176232,1.899438408,1.152875193,-0.426674955,-0.965533159,-1.011528167,-1.03779781,-1.018346073 +tyr__L_c,0.119933432,-0.51077632,-0.779589854,-0.891789433,-1.656229996,-1.337825254,-2.349607912,-2.650210879,-1.791185734,-3.002754986,-2.304142241,-3.010049314,-2.376975226,-0.984443986,-0.928642839,3.550360708,3.718783173,3.556311325,2.838248367,1.776070707,-0.586734355,-1.606516242,-1.655140671,-1.935267703,-2.097016297 +val__L_c,0.057115176,0.499409592,0.530647154,0.739294222,0.40329387,-1.481779118,-1.715513434,-1.639822098,-0.912230162,-1.04688642,-1.496214267,-2.098494822,-1.056298276,0.355805416,0.515315722,1.046110289,1.216778299,1.216939931,1.054185556,0.641671995,-0.483749038,-0.589818634,-0.549065583,-0.311107957,-0.157834263 \ No newline at end of file diff --git a/src/emll/test_models/BIOMD0000000064.xml b/tests/test_models/BIOMD0000000064.xml similarity index 100% rename from src/emll/test_models/BIOMD0000000064.xml rename to tests/test_models/BIOMD0000000064.xml diff --git a/src/emll/test_models/__init__.py b/tests/test_models/__init__.py similarity index 100% rename from src/emll/test_models/__init__.py rename to tests/test_models/__init__.py diff --git a/src/emll/test_models/common_utils.py b/tests/test_models/common_utils.py similarity index 100% rename from src/emll/test_models/common_utils.py rename to tests/test_models/common_utils.py diff --git a/src/emll/test_models/contador.json b/tests/test_models/contador.json similarity index 100% rename from src/emll/test_models/contador.json rename to tests/test_models/contador.json diff --git a/tests/test_models/contador_updatedbounds.json b/tests/test_models/contador_updatedbounds.json new file mode 100644 index 0000000..ba58de2 --- /dev/null +++ b/tests/test_models/contador_updatedbounds.json @@ -0,0 +1,766 @@ +{ + "compartments": {}, + "genes": [], + "id": "Contador 2009", + "metabolites": [ + { + "compartment": "", + "id": "2PG", + "name": "2-Phosphoglycerate" + }, + { + "compartment": "", + "id": "3PG", + "name": "3-Phosphoglycerate" + }, + { + "compartment": "", + "id": "A4P", + "name": "l-aspartyl-4-phosphate" + }, + { + "compartment": "", + "id": "ACCOA", + "name": "Acetyl-CoA" + }, + { + "compartment": "", + "id": "ADP", + "name": "Adenosine diphosphate" + }, + { + "compartment": "", + "id": "ASA", + "name": "l-aspartate-semialdehyde" + }, + { + "compartment": "", + "id": "ASP", + "name": "l-aspartate" + }, + { + "compartment": "", + "id": "ATP", + "name": "Adenosine triphosphate" + }, + { + "compartment": "", + "id": "CIT", + "name": "Citrate" + }, + { + "compartment": "", + "id": "DAPM", + "name": "ll-diaminopimelate" + }, + { + "compartment": "", + "id": "DHAP", + "name": "dihydroxyacetone phosphate" + }, + { + "compartment": "", + "id": "DHDP", + "name": "l-23-dihydrodipicolinate" + }, + { + "compartment": "", + "id": "DPG", + "name": "13-Biphosphoglycerate" + }, + { + "compartment": "", + "id": "E4P", + "name": "Erythrose-4-phosphate" + }, + { + "compartment": "", + "id": "F6P", + "name": "Fructose-6-phosphate" + }, + { + "compartment": "", + "id": "FBP", + "name": "Fructose-16-biphosphate" + }, + { + "compartment": "", + "id": "FUM", + "name": "Fumarate" + }, + { + "compartment": "", + "id": "G6P", + "name": "Glucose-6-phosphate" + }, + { + "compartment": "", + "id": "GAP", + "name": "Glyceraldehyde-3-phosphate" + }, + { + "compartment": "", + "id": "GLU", + "name": "l-glutamate" + }, + { + "compartment": "", + "id": "GLUCOSE", + "name": "b-d-glucose" + }, + { + "compartment": "", + "id": "ICT", + "name": "d-isocitrate" + }, + { + "compartment": "", + "id": "KG", + "name": "2-Ketoglutarate" + }, + { + "compartment": "", + "id": "LYS", + "name": "l-lysine" + }, + { + "compartment": "", + "id": "MAL", + "name": "Malate" + }, + { + "compartment": "", + "id": "MDAPM", + "name": "Meso-diaminopimelate" + }, + { + "compartment": "", + "id": "NAD", + "name": "Nicotinamide adenine dinucleotide" + }, + { + "compartment": "", + "id": "NADH", + "name": "Nicotinamide adenine dinucleotide reduce" + }, + { + "compartment": "", + "id": "NADP", + "name": "Nicotinamide adenine dinucleotide phosphate" + }, + { + "compartment": "", + "id": "NADPH", + "name": "Nicotinamide adenine dinucleotide phosphate reduced" + }, + { + "compartment": "", + "id": "OAA", + "name": "Oxaloacetate" + }, + { + "compartment": "", + "id": "PEP", + "name": "Phosphoenolpyruvate" + }, + { + "compartment": "", + "id": "PGL", + "name": "6-Phosphogluconolactone" + }, + { + "compartment": "", + "id": "PGT", + "name": "6-Phosphogluconate" + }, + { + "compartment": "", + "id": "PYR", + "name": "Pyruvate" + }, + { + "compartment": "", + "id": "R5P", + "name": "Ribose-5-phosphate" + }, + { + "compartment": "", + "id": "Ru5P", + "name": "Ribulose-5-phosphate" + }, + { + "compartment": "", + "id": "S7P", + "name": "Sedoheptulose-7-phosphate" + }, + { + "compartment": "", + "id": "SAKP", + "name": "N-succinyl-2-amino-6-ketopimelate" + }, + { + "compartment": "", + "id": "SDAP", + "name": "N-succinyl-ll-26-diaminopimelate" + }, + { + "compartment": "", + "id": "SUC", + "name": "Succinate" + }, + { + "compartment": "", + "id": "SUCCOA", + "name": "Succinyl-CoA" + }, + { + "compartment": "", + "id": "THDP", + "name": "Tetrahydrodipicolinate" + }, + { + "compartment": "", + "id": "X5P", + "name": "Xylose-5-phosphate" + } + ], + "reactions": [ + { + "gene_reaction_rule": "", + "id": "acn", + "lower_bound": -1000, + "metabolites": { + "CIT": -1, + "ICT": 1 + }, + "name": "Aconitase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "argD", + "lower_bound": -1000, + "metabolites": { + "GLU": -1, + "KG": 1, + "SAKP": -1, + "SDAP": 1 + }, + "name": "N-succinyldiaminopimelate-aminotransferase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "asd", + "lower_bound": -1000, + "metabolites": { + "A4P": -1, + "ASA": 1, + "NADP": 1, + "NADPH": -1 + }, + "name": "Aspartate semialdehyde dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "aspC", + "lower_bound": -1000, + "metabolites": { + "ASP": 1, + "GLU": -1, + "KG": 1, + "OAA": -1 + }, + "name": "Aspartate aminotransferase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "dapA", + "lower_bound": 0, + "metabolites": { + "ASA": -1, + "DHDP": 1, + "PYR": -1 + }, + "name": "Dihydrodipicolinate synthase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "dapB", + "lower_bound": 0, + "metabolites": { + "DHDP": -1, + "NAD": 1, + "NADH": -1, + "THDP": 1 + }, + "name": "Dihydrodipicolinate reductase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "dapD", + "lower_bound": -1000, + "metabolites": { + "SAKP": 1, + "SUCCOA": -1, + "THDP": -1 + }, + "name": "Tetrahydrodipicolinate succinylase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "dapE", + "lower_bound": 0, + "metabolites": { + "DAPM": 1, + "SDAP": -1, + "SUC": 1 + }, + "name": "N-succinyl-l-diaminopimelate desuccinylase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "dapF", + "lower_bound": -1000, + "metabolites": { + "DAPM": -1, + "MDAPM": 1 + }, + "name": "Diaminopimelate epimerase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pts", + "lower_bound": 0, + "metabolites": { + "G6P": 1, + "GLUCOSE": -1, + "PEP": -1, + "PYR": 1 + }, + "name": "Phosphotransferase system", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "eno", + "lower_bound": 0, + "metabolites": { + "2PG": -1, + "PEP": 1 + }, + "name": "Enolase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "fba", + "lower_bound": -1000, + "metabolites": { + "DHAP": 1, + "FBP": -1, + "GAP": 1 + }, + "name": "Fructose biphosphate aldolase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "fum", + "lower_bound": 0, + "metabolites": { + "FUM": -1, + "MAL": 1 + }, + "name": "Fumarase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "gap", + "lower_bound": -1000, + "metabolites": { + "DPG": 1, + "GAP": -1, + "NAD": -1, + "NADH": 1 + }, + "name": "Glyceraldehyde 3-phosphate dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "gdhA", + "lower_bound": -1000, + "metabolites": { + "GLU": 1, + "KG": -1, + "NADP": 1, + "NADPH": -1 + }, + "name": "Glutamate dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "gltA", + "lower_bound": 0, + "metabolites": { + "ACCOA": -1, + "CIT": 1, + "OAA": -1 + }, + "name": "Citrate synthase", + "notes": { + "inhibitor": "NADH" + }, + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "gnd", + "lower_bound": 0, + "metabolites": { + "NADP": -1, + "NADPH": 1, + "PGT": -1, + "Ru5P": 1 + }, + "name": "6-Phosphogluconate dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "gpm", + "lower_bound": 0, + "metabolites": { + "2PG": 1, + "3PG": -1 + }, + "name": "Phosphoglycerate mutase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "icd", + "lower_bound": 0, + "metabolites": { + "ICT": -1, + "KG": 1, + "NADP": -1, + "NADPH": 1 + }, + "name": "Isocitrate dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "lysA", + "lower_bound": 0, + "metabolites": { + "LYS": 1, + "MDAPM": -1 + }, + "name": "Diaminopimelate decarboxylase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "lysC", + "lower_bound": -1000, + "metabolites": { + "A4P": 1, + "ADP": 1, + "ASP": -1, + "ATP": -1 + }, + "name": "Aspartate kinase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "EX_lys", + "lower_bound": 0.3729, + "metabolites": { + "LYS": -1 + }, + "name": "", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "EX_glc", + "lower_bound": -1.243, + "metabolites": { + "GLUCOSE": -1 + }, + "name": "", + "upper_bound": 0 + }, + { + "gene_reaction_rule": "", + "id": "mdh", + "lower_bound": -1000, + "metabolites": { + "MAL": -1, + "NAD": -1, + "NADH": 1, + "OAA": 1 + }, + "name": "Malate dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pdh", + "lower_bound": 0, + "metabolites": { + "ACCOA": 1, + "NAD": -1, + "NADH": 1, + "PYR": -1 + }, + "name": "Pyruvate dehydrogenase complex", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pfk", + "lower_bound": 0, + "metabolites": { + "ADP": 1, + "ATP": -1, + "F6P": -1, + "FBP": 1 + }, + "name": "Phosphofructokinase", + "notes": { + "inhibitor": "PEP" + }, + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pgi", + "lower_bound": 0, + "metabolites": { + "F6P": 1, + "G6P": -1 + }, + "name": "Phosphogluco isomerase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pgk", + "lower_bound": -1000, + "metabolites": { + "3PG": 1, + "ADP": -1, + "ATP": 1, + "DPG": -1 + }, + "name": "Phosphoglycerate kinase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pgl", + "lower_bound": 0, + "metabolites": { + "PGL": -1, + "PGT": 1 + }, + "name": "6-Phosphogluconolactonase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "ppc", + "lower_bound": 0, + "metabolites": { + "OAA": 1, + "PEP": -1 + }, + "name": "Phosphoenolpyruvate carboxylase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "pyk", + "lower_bound": 0, + "metabolites": { + "ADP": -1, + "ATP": 1, + "PEP": -1, + "PYR": 1 + }, + "name": "Pyruvate kinase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "recATP", + "lower_bound": -1000, + "metabolites": { + "ADP": 1, + "ATP": -1 + }, + "name": "ATP recycle", + "objective_coefficient": 1, + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "recNADH", + "lower_bound": -1000, + "metabolites": { + "NAD": 1, + "NADH": -1 + }, + "name": "NADH recycle", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "recNADPH", + "lower_bound": -1000, + "metabolites": { + "NADP": 1, + "NADPH": -1 + }, + "name": "NADPH recycle", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "rpe", + "lower_bound": -1000, + "metabolites": { + "Ru5P": -1, + "X5P": 1 + }, + "name": "Ribulose-5-phosphate 3-epimerase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "rpi", + "lower_bound": -1000, + "metabolites": { + "R5P": 1, + "Ru5P": -1 + }, + "name": "Ribulose-5-phosphate isomerase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "sdh", + "lower_bound": -1000, + "metabolites": { + "FUM": 1, + "SUC": -1 + }, + "name": "Succinate dehydrogenase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "sucAB", + "lower_bound": 0, + "metabolites": { + "KG": -1, + "NAD": -1, + "NADH": 1, + "SUCCOA": 1 + }, + "name": "2-Oxoglutarate dehydrogenase complex", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "sucCD", + "lower_bound": -1000, + "metabolites": { + "ADP": -1, + "ATP": 1, + "SUC": 1, + "SUCCOA": -1 + }, + "name": "Succinyl-CoA synthetase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "tal", + "lower_bound": 0, + "metabolites": { + "E4P": 1, + "F6P": 1, + "GAP": -1, + "S7P": -1 + }, + "name": "Transaldolase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "tka1", + "lower_bound": -1000, + "metabolites": { + "GAP": 1, + "R5P": -1, + "S7P": 1, + "X5P": -1 + }, + "name": "", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "tka2", + "lower_bound": 0, + "metabolites": { + "E4P": -1, + "F6P": 1, + "GAP": 1, + "X5P": -1 + }, + "name": "", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "tpi", + "lower_bound": -1000, + "metabolites": { + "DHAP": -1, + "GAP": 1 + }, + "name": "Triose phosphate isomerase", + "upper_bound": 1000 + }, + { + "gene_reaction_rule": "", + "id": "zwf", + "lower_bound": 0.778, + "metabolites": { + "G6P": -1, + "NADP": -1, + "NADPH": 1, + "PGL": 1 + }, + "name": "Glucose-6-phosphate dehydrogenase", + "upper_bound": 0.778 + } + ], + "version": "1" +} diff --git a/src/emll/test_models/jol2012_trimmed.json b/tests/test_models/jol2012_trimmed.json similarity index 100% rename from src/emll/test_models/jol2012_trimmed.json rename to tests/test_models/jol2012_trimmed.json diff --git a/src/emll/test_models/jol2012_vstar.p b/tests/test_models/jol2012_vstar.p similarity index 100% rename from src/emll/test_models/jol2012_vstar.p rename to tests/test_models/jol2012_vstar.p diff --git a/src/emll/test_models/mendes_model.py b/tests/test_models/mendes_model.py similarity index 100% rename from src/emll/test_models/mendes_model.py rename to tests/test_models/mendes_model.py diff --git a/src/emll/test_models/textbook_reduced.json b/tests/test_models/textbook_reduced.json similarity index 100% rename from src/emll/test_models/textbook_reduced.json rename to tests/test_models/textbook_reduced.json diff --git a/tests/test_models/wu2004_model.json b/tests/test_models/wu2004_model.json new file mode 100644 index 0000000..3f37b00 --- /dev/null +++ b/tests/test_models/wu2004_model.json @@ -0,0 +1,71 @@ +{ +"metabolites":[ +{ +"id":"bpg_e", +"name":"", +"compartment":"e" +}, +{ +"id":"2pg_c", +"name":"", +"compartment":"c" +}, +{ +"id":"pep_c", +"name":"", +"compartment":"c" +}, +{ +"id":"adp_e", +"name":"", +"compartment":"e" +}, +{ +"id":"pep_e", +"name":"", +"compartment":"" +} +], +"reactions":[ +{ +"id":"PGM", +"name":"", +"metabolites":{ +"2pg_c":1 +}, +"lower_bound":-1000.0, +"upper_bound":1000.0, +"gene_reaction_rule":"" +}, +{ +"id":"ENO", +"name":"", +"metabolites":{ +"2pg_c":-1, +"pep_c":1 +}, +"lower_bound":-1000.0, +"upper_bound":1000.0, +"gene_reaction_rule":"" +}, +{ +"id":"PK", +"name":"", +"metabolites":{ +"adp_e":-1, +"pep_c":-1, +"pep_e":1 +}, +"lower_bound":-1000.0, +"upper_bound":1000.0, +"gene_reaction_rule":"" +} +], +"genes":[], +"id":null, +"compartments":{ +"c":"the cytosol", +"e":"extracellular" +}, +"version":"1" +} \ No newline at end of file diff --git a/tests/test_models/wu2004_model.sbml b/tests/test_models/wu2004_model.sbml new file mode 100644 index 0000000..cd0c4b4 --- /dev/null +++ b/tests/test_models/wu2004_model.sbml @@ -0,0 +1,24 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/test_preprocess.py b/tests/test_preprocess.py new file mode 100644 index 0000000..db36465 --- /dev/null +++ b/tests/test_preprocess.py @@ -0,0 +1,54 @@ +""" Tests for preprocessing BMCA required data""" + +import pytest +import cobra +import pandas as pd +from emll import preprocess + + +# Define global variables for filenames of testing cases from Hackett example +MODEL = "notebooks/data/jol2012.yaml" +METAB_DATA = "notebooks/data/metabolite_concentrations.csv" +METAB_DATA_CLEAN = "notebooks/data/metabolite_concentrations_clean.csv" +METAB_ROWS = "notebooks/data/metab_rownames.csv" +METAB_COLS = "notebooks/data/metab_colnames.csv" + + +# Test loading model: using Hackett model as example +def test_get_model(): + model = preprocess.get_model(MODEL) + assert isinstance(model, cobra.core.model.Model) + + +# Test loading metabolomics data if no data/pathname is given +def test_get_metabolomics_no_data(): + data = preprocess.get_metabolomics_data() + assert isinstance(data, None) + + +# Test loading metabolomics data from file +def test_get_metabolomics_data(fname): + data = preprocess.get_metabolomics_data(fname) + assert isinstance(data, pd.DataFrame) + + +# Test capturing index/rownames from metabolomics data +def test_get_metabolomics_index(): + data = preprocess.get_metabolomics_data(METAB_DATA) + row_names = pd.read_csv(METAB_ROWS, index_col=0) + assert isinstance(data.index, pd.MultiIndex) + assert [c for c in data.index] == row_names + + +# Test capturing column names from metabolomics data +def test_get_metabolomics_columns(): + data = preprocess.get_metabolomics_data(METAB_DATA) + col_names = pd.read_csv(METAB_COLS, index_col=0) + assert isinstance(data.columns, pd.MultiIndex) + assert [c for c in data.columns] == col_names + + +# Test if data is in the correct format +def test_get_metabolomics_data_format(): + data = preprocess.get_metabolomics_data(METAB_DATA) + assert isinstance(data, pd.DataFrame) \ No newline at end of file diff --git a/tests/test_priorpredictive.py b/tests/test_priorpredictive.py new file mode 100644 index 0000000..95778c6 --- /dev/null +++ b/tests/test_priorpredictive.py @@ -0,0 +1,42 @@ +import pytest +import emll +import pandas as pd +import scipy as sp +from emll import bmca + + +# Get wu2004 data and initialize BMCA object +@pytest.fixture(scope="module") +def wu2004_bmca_obj(): + wu2004_paths = { + "model_path": "tests/test_models/wu2004_model.sbml", + "reference_state": None, + } + bmca_obj = emll.bmca.BMCA( + model_path = wu2004_paths["model_path"], + reference_state = wu2004_paths["reference_state"], + ) + return bmca_obj + + +# def test_elasticity_matrix(wu2004_bmca_obj): + + +def test_priorpredictive(wu2004_bmca_obj): + bmca_obj = wu2004_bmca_obj + + # # Build unconditional probabilistic model + # Sample flux control coefficients from prior predictive distribution of an unconditional prob model + fcc_prior = emll.pymc_utils.sample_prior_fccs(bmca_obj.model) + + # Compare prior predictive distribution to wu2004 prior predictive results + wu_prior_df = pd.read_csv("tests/test_data/expected_wu2004_FCCpriors.csv", index_col=0) + met_names = wu_prior_df.index + for m in met_names: + this_wu_prior = wu_prior_df.loc[m] + test_result = sp.stats.wilcoxon(x=fcc_prior, y=this_wu_prior) + + + + + # assert bmca_obj.prior_predictive.equals(wu_prior_pred) From 43a8c5b19d7f4941ee0f609d7862b49f3ccd919c Mon Sep 17 00:00:00 2001 From: ShantMahserejian Date: Fri, 1 Mar 2024 16:17:11 -0800 Subject: [PATCH 6/8] Correct cobra model from Wu notebook to pass unit test initialization. Progress made with test_priorpredictive --- tests/test_models/wu2004_model.json | 16 +++++++++--- tests/test_models/wu2004_model.sbml | 40 +++++++++++++++++++++++++++++ tests/test_priorpredictive.py | 6 ++--- 3 files changed, 56 insertions(+), 6 deletions(-) diff --git a/tests/test_models/wu2004_model.json b/tests/test_models/wu2004_model.json index 3f37b00..546c669 100644 --- a/tests/test_models/wu2004_model.json +++ b/tests/test_models/wu2004_model.json @@ -16,14 +16,14 @@ "compartment":"c" }, { -"id":"adp_e", +"id":"pep_e", "name":"", "compartment":"e" }, { -"id":"pep_e", +"id":"adp_e", "name":"", -"compartment":"" +"compartment":"e" } ], "reactions":[ @@ -59,6 +59,16 @@ "lower_bound":-1000.0, "upper_bound":1000.0, "gene_reaction_rule":"" +}, +{ +"id":"EX_pep_e", +"name":"", +"metabolites":{ +"pep_e":-1 +}, +"lower_bound":-1000.0, +"upper_bound":1000.0, +"gene_reaction_rule":"" } ], "genes":[], diff --git a/tests/test_models/wu2004_model.sbml b/tests/test_models/wu2004_model.sbml index cd0c4b4..77711ce 100644 --- a/tests/test_models/wu2004_model.sbml +++ b/tests/test_models/wu2004_model.sbml @@ -10,6 +10,17 @@ + + + + + + + + + + + @@ -17,6 +28,35 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/tests/test_priorpredictive.py b/tests/test_priorpredictive.py index 95778c6..6004227 100644 --- a/tests/test_priorpredictive.py +++ b/tests/test_priorpredictive.py @@ -31,12 +31,12 @@ def test_priorpredictive(wu2004_bmca_obj): # Compare prior predictive distribution to wu2004 prior predictive results wu_prior_df = pd.read_csv("tests/test_data/expected_wu2004_FCCpriors.csv", index_col=0) + + # TODO: correct inputs for Wilcoxon test met_names = wu_prior_df.index for m in met_names: this_wu_prior = wu_prior_df.loc[m] test_result = sp.stats.wilcoxon(x=fcc_prior, y=this_wu_prior) - - - # assert bmca_obj.prior_predictive.equals(wu_prior_pred) + # assert bmca_obj.prior_predictive.equals(wu_prior_pred) \ No newline at end of file From 799bae9e3f5c6f0b2678e07ee06fc86572b9f707 Mon Sep 17 00:00:00 2001 From: ShantMahserejian Date: Sat, 9 Mar 2024 13:01:36 -0800 Subject: [PATCH 7/8] Updated the cobra model in the Wu notebook to be functional with model.optimize() to calculate fluxes --- notebooks/wu2004.ipynb | 577 +++++++++++++++++----------- tests/test_models/wu2004_model.json | 42 +- tests/test_models/wu2004_model.sbml | 27 +- 3 files changed, 417 insertions(+), 229 deletions(-) diff --git a/notebooks/wu2004.ipynb b/notebooks/wu2004.ipynb index 90f6ece..b618ad7 100644 --- a/notebooks/wu2004.ipynb +++ b/notebooks/wu2004.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -31,25 +31,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 8, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/var/folders/k9/b8pxky2572sdtgy2vnxhcljw0000gn/T/ipykernel_61804/3008229323.py:4: DeprecationWarning: \n", - "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", - "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", - "but was not found to be installed on your system.\n", - "If this would cause problems for you,\n", - "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", - " \n", - " import pandas as pd\n", - "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" - ] - } - ], + "outputs": [], "source": [ "import numpy as np\n", "np.random.seed(0)\n", @@ -67,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -88,45 +72,158 @@ }, { "cell_type": "code", - "execution_count": 88, + "execution_count": 55, "metadata": {}, "outputs": [], "source": [ "import cobra\n", "\n", + "# Initialize model\n", "model = cobra.Model()\n", "\n", + "# Declare model compartments\n", + "model.compartments = {'c': 'the cytosol', 'e': 'extracellular'}\n", + "\n", + "# Define list of metabolites in model per compartment\n", "model.add_metabolites([\n", - " cobra.Metabolite('bpg_e', compartment='e'),\n", + " # cobra.Metabolite('bpg_e', compartment='e'),\n", + " cobra.Metabolite('2pg_e', compartment='e'),\n", " cobra.Metabolite('2pg_c', compartment='c'),\n", + " cobra.Metabolite('pep_e', compartment='e'),\n", " cobra.Metabolite('pep_c', compartment='c'),\n", - " cobra.Metabolite('adp_e', compartment='e'),\n", + " # cobra.Metabolite('adp_e', compartment='e'),\n", + " cobra.Metabolite('adp_c', compartment='c'),\n", " ])\n", "\n", + "# Define model reactions, including exchange reactions to move metabs out of the system\n", "model.add_reactions([\n", + " cobra.Reaction('EX_2pg_e'),\n", + " cobra.Reaction('SK_adp_c'),\n", " cobra.Reaction('PGM'),\n", " cobra.Reaction('ENO'),\n", " cobra.Reaction('PK'),\n", + " cobra.Reaction('EX_pep_e'),\n", " ])\n", "\n", - "# model.reactions.EX_PGM.reaction = '<=> 2pg_e'\n", - "model.reactions.PGM.reaction = '<=> 2pg_c'\n", + "# Define reaction equations\n", + "model.reactions.EX_2pg_e.reaction = '<=> 2pg_e'\n", + "model.reactions.SK_adp_c.reaction = '<=> adp_c'\n", + "model.reactions.PGM.reaction = '2pg_e <=> 2pg_c'\n", + "# model.reactions.PGM.reaction = '<=> 2pg_c'\n", "model.reactions.ENO.reaction = '2pg_c <=> pep_c'\n", - "model.reactions.PK.reaction = 'pep_c + adp_e <=> pep_e'\n", - "# model.reactions.EX_PK.reaction = 'pep_e <=>'\n", + "model.reactions.PK.reaction = 'pep_c + adp_c <=> pep_e'\n", + "model.reactions.EX_pep_e.reaction = 'pep_e <=>'\n", + "\n", + "# Add objective coefficients\n", + "model.objective = \"EX_pep_e\"\n", "\n", - "N = cobra.util.create_stoichiometric_matrix(model, dtype='int')" + "# Save model to file\n", + "model_fname = \"../tests/test_models/wu2004_model.sbml\"\n", + "cobra.io.write_sbml_model(model, model_fname)\n", + "model_fname = \"../tests/test_models/wu2004_model.json\"\n", + "cobra.io.save_json_model(model, model_fname)\n" ] }, { "cell_type": "code", - "execution_count": 89, + "execution_count": 41, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 1, 0, -1, 0, 0, 0],\n", + " [ 0, 0, 1, -1, 0, 0],\n", + " [ 0, 0, 0, 0, 1, -1],\n", + " [ 0, 0, 0, 1, -1, 0],\n", + " [ 0, 1, 0, 0, -1, 0]])" + ] + }, + "execution_count": 41, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "# Save model to file\n", - "model_fname = \"../tests/test_models/wu2004_model.sbml\"\n", - "cobra.io.write_sbml_model(model, model_fname)" + "# Define stoichiometric matrix\n", + "N = cobra.util.create_stoichiometric_matrix(model, dtype='int')\n", + "N" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "EX_2pg_e 1000.0\n", + "SK_adp_c 1000.0\n", + "PGM 1000.0\n", + "ENO 1000.0\n", + "PK 1000.0\n", + "EX_pep_e 1000.0\n", + "Name: fluxes, dtype: float64" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# For prior predictive purposes ONLY, calculate v_star directly from the model\n", + "v_star_prior = model.optimize().fluxes\n", + "v_star_prior" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[-1., 0., 0., 0., 0.],\n", + " [ 0., 0., 0., 0., -1.],\n", + " [ 1., -1., 0., 0., 0.],\n", + " [ 0., 1., 0., -1., 0.],\n", + " [ 0., 0., -1., 1., 1.],\n", + " [ 0., 0., 1., 0., 0.]])" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "array([[1., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 1.]])" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For prior predictive purposes ONLY, calculate LinLog model using only model attributes\n", + "import emll\n", + "Ex = emll.create_elasticity_matrix(model)\n", + "display(Ex)\n", + "\n", + "Ey = np.zeros((6, 2))\n", + "Ey[0, 0] = 1 # 2pg_e (+) EX_2pg_e\n", + "Ey[5, 1] = 1 # pep_e (+) EX_pep_e\n", + "display(Ey)\n", + "\n", + "ll = emll.LinLogLeastNorm(N, Ex, Ey, v_star_prior)" ] }, { @@ -138,7 +235,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 84, "metadata": {}, "outputs": [ { @@ -241,7 +338,7 @@ "4 25.0 12.0 30.0 54.0 76.0 13.2 130.0 136.0" ] }, - "execution_count": 6, + "execution_count": 84, "metadata": {}, "output_type": "execute_result" } @@ -265,11 +362,17 @@ "metadata": {}, "outputs": [], "source": [ + "# Load Giersch data directly into relevant variables\n", "e = giersch.loc[:, ['PGM', 'ENO', 'PK']]\n", "y = giersch.loc[:, ['BPG', 'ADP']]\n", "v = giersch.loc[:, ['Flux']]\n", "x = giersch.loc[:, ['2PG', 'PEP']]\n", "\n", + "# Accomodate cobra model reactions (exchange/sink) missing from Giersch data\n", + "# e['EX_2pg_e'] = giersch.loc[:, ['PGM']]\n", + "# e['SK_adp_c'] = 0.5*giersch.loc[:, ['PK']]\n", + "# e['EX_pep_e'] = giersch.loc[:, ['PK']]\n", + "\n", "ref_ind = 1\n", "\n", "v_star = v.iloc[ref_ind].values * np.ones(3)\n", @@ -306,7 +409,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 87, "metadata": {}, "outputs": [ { @@ -315,7 +418,7 @@ "19" ] }, - "execution_count": 8, + "execution_count": 87, "metadata": {}, "output_type": "execute_result" } @@ -332,24 +435,28 @@ ] }, { - "cell_type": "code", - "execution_count": 9, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ "import emll\n", "Ex = emll.create_elasticity_matrix(model)\n", + "display(Ex)\n", + "\n", + "# Ey = np.zeros((3, 2))\n", + "# Ey[0, 0] = 1 # bpg (+) PGM\n", + "# Ey[2, 1] = 1 # adp (+) PK\n", + "Ey = np.zeros((6, 2))\n", + "Ey[0, 0] = 1 # 2pg_e (+) EX_2pg_e\n", + "Ey[5, 1] = 1 # pep_e (+) EX_pep_e\n", "\n", - "Ey = np.zeros((3, 2))\n", - "Ey[0, 0] = 1 # bpg (+) PGM\n", - "Ey[2, 1] = 1 # adp (+) PK\n", + "display(Ey)\n", "\n", - "ll = emll.LinLogSymbolic2x2(N, Ex, Ey, v_star)" + "ll = emll.LinLogLeastNorm(N, Ex, Ey, v_star)" ] }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 88, "metadata": {}, "outputs": [ { @@ -357,10 +464,13 @@ "text/plain": [ "array([[1., 0.],\n", " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", + " [0., 0.],\n", " [0., 1.]])" ] }, - "execution_count": 87, + "execution_count": 88, "metadata": {}, "output_type": "execute_result" } @@ -380,16 +490,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 89, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(2, 3)" + "(5, 6)" ] }, - "execution_count": 10, + "execution_count": 89, "metadata": {}, "output_type": "execute_result" } @@ -400,7 +510,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 90, "metadata": {}, "outputs": [ { @@ -409,7 +519,7 @@ "Text(0, 0.5, 'Probability density')" ] }, - "execution_count": 11, + "execution_count": 90, "metadata": {}, "output_type": "execute_result" }, @@ -449,7 +559,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 91, "metadata": {}, "outputs": [ { @@ -503,7 +613,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 92, "metadata": {}, "outputs": [ { @@ -527,7 +637,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 93, "metadata": {}, "outputs": [ { @@ -541,8 +651,8 @@ "
    \n", " \n", "
  • \n", - " \n", - " \n", + " \n", + " \n", "
    \n", "
    \n", "
      \n", @@ -910,178 +1020,194 @@ " fill: currentColor;\n", "}\n", "
      <xarray.Dataset>\n",
-       "Dimensions:                    (chain: 1, draw: 500,\n",
-       "                                ey_capacity_entries_dim_0: 4, Ex_dim_0: 3,\n",
-       "                                Ex_dim_1: 2, Ey_dim_0: 3, Ey_dim_1: 2,\n",
-       "                                ey_kinetic_entries_dim_0: 2,\n",
-       "                                ex_kinetic_entries_dim_0: 4,\n",
-       "                                ex_capacity_entries_dim_0: 2)\n",
+       "Dimensions:                    (chain: 1, draw: 500, Ey_dim_0: 6, Ey_dim_1: 2,\n",
+       "                                ey_kinetic_entries_dim_0: 2, Ex_dim_0: 6,\n",
+       "                                Ex_dim_1: 5, ex_kinetic_entries_dim_0: 10,\n",
+       "                                ey_capacity_entries_dim_0: 10,\n",
+       "                                ex_capacity_entries_dim_0: 20)\n",
        "Coordinates:\n",
        "  * chain                      (chain) int64 0\n",
        "  * draw                       (draw) int64 0 1 2 3 4 5 ... 495 496 497 498 499\n",
-       "  * ey_capacity_entries_dim_0  (ey_capacity_entries_dim_0) int64 0 1 2 3\n",
-       "  * Ex_dim_0                   (Ex_dim_0) int64 0 1 2\n",
-       "  * Ex_dim_1                   (Ex_dim_1) int64 0 1\n",
-       "  * Ey_dim_0                   (Ey_dim_0) int64 0 1 2\n",
+       "  * Ey_dim_0                   (Ey_dim_0) int64 0 1 2 3 4 5\n",
        "  * Ey_dim_1                   (Ey_dim_1) int64 0 1\n",
        "  * ey_kinetic_entries_dim_0   (ey_kinetic_entries_dim_0) int64 0 1\n",
-       "  * ex_kinetic_entries_dim_0   (ex_kinetic_entries_dim_0) int64 0 1 2 3\n",
-       "  * ex_capacity_entries_dim_0  (ex_capacity_entries_dim_0) int64 0 1\n",
+       "  * Ex_dim_0                   (Ex_dim_0) int64 0 1 2 3 4 5\n",
+       "  * Ex_dim_1                   (Ex_dim_1) int64 0 1 2 3 4\n",
+       "  * ex_kinetic_entries_dim_0   (ex_kinetic_entries_dim_0) int64 0 1 2 ... 7 8 9\n",
+       "  * ey_capacity_entries_dim_0  (ey_capacity_entries_dim_0) int64 0 1 2 ... 7 8 9\n",
+       "  * ex_capacity_entries_dim_0  (ex_capacity_entries_dim_0) int64 0 1 2 ... 18 19\n",
        "Data variables:\n",
-       "    ey_capacity_entries        (chain, draw, ey_capacity_entries_dim_0) float64 ...\n",
-       "    Ex                         (chain, draw, Ex_dim_0, Ex_dim_1) float64 -1.5...\n",
-       "    Ey                         (chain, draw, Ey_dim_0, Ey_dim_1) float64 0.82...\n",
+       "    Ey                         (chain, draw, Ey_dim_0, Ey_dim_1) float64 0.98...\n",
        "    ey_kinetic_entries         (chain, draw, ey_kinetic_entries_dim_0) float64 ...\n",
+       "    Ex                         (chain, draw, Ex_dim_0, Ex_dim_1) float64 -0.6...\n",
        "    ex_kinetic_entries         (chain, draw, ex_kinetic_entries_dim_0) float64 ...\n",
+       "    ey_capacity_entries        (chain, draw, ey_capacity_entries_dim_0) float64 ...\n",
        "    ex_capacity_entries        (chain, draw, ex_capacity_entries_dim_0) float64 ...\n",
        "Attributes:\n",
-       "    created_at:                 2024-02-20T23:06:59.021353\n",
+       "    created_at:                 2024-03-08T22:23:39.313824\n",
        "    arviz_version:              0.17.0\n",
        "    inference_library:          pymc\n",
-       "    inference_library_version:  5.10.3
    • Ey_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5], dtype='int64', name='Ey_dim_0'))
    • Ey_dim_1
      PandasIndex
      PandasIndex(Index([0, 1], dtype='int64', name='Ey_dim_1'))
    • ey_kinetic_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1], dtype='int64', name='ey_kinetic_entries_dim_0'))
    • Ex_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5], dtype='int64', name='Ex_dim_0'))
    • Ex_dim_1
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4], dtype='int64', name='Ex_dim_1'))
    • ex_kinetic_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype='int64', name='ex_kinetic_entries_dim_0'))
    • ey_capacity_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype='int64', name='ey_capacity_entries_dim_0'))
    • ex_capacity_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], dtype='int64', name='ex_capacity_entries_dim_0'))
  • created_at :
    2024-03-08T22:23:39.313824
    arviz_version :
    0.17.0
    inference_library :
    pymc
    inference_library_version :
    5.10.3

\n", " \n", " \n", " \n", @@ -1434,7 +1560,7 @@ "\t> prior" ] }, - "execution_count": 14, + "execution_count": 93, "metadata": {}, "output_type": "execute_result" } @@ -1445,9 +1571,32 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 94, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "ValueError", + "evalue": "Incompatible Elemwise input shapes [(19, 3, 1), (1, 6, 6)]", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/elemwise.py:439\u001b[0m, in \u001b[0;36mElemwise.get_output_info\u001b[0;34m(self, dim_shuffle, *inputs)\u001b[0m\n\u001b[1;32m 437\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 438\u001b[0m out_shapes \u001b[38;5;241m=\u001b[39m [\n\u001b[0;32m--> 439\u001b[0m \u001b[43m[\u001b[49m\n\u001b[1;32m 440\u001b[0m \u001b[43m \u001b[49m\u001b[43mbroadcast_static_dim_lengths\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 441\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mshape\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mzip\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m[\u001b[49m\u001b[43minp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtype\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshape\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minp\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43minputs\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 442\u001b[0m \u001b[43m \u001b[49m\u001b[43m]\u001b[49m\n\u001b[1;32m 443\u001b[0m ] \u001b[38;5;241m*\u001b[39m shadow\u001b[38;5;241m.\u001b[39mnout\n\u001b[1;32m 444\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/elemwise.py:440\u001b[0m, in \u001b[0;36m\u001b[0;34m(.0)\u001b[0m\n\u001b[1;32m 437\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m 438\u001b[0m out_shapes \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 439\u001b[0m [\n\u001b[0;32m--> 440\u001b[0m \u001b[43mbroadcast_static_dim_lengths\u001b[49m\u001b[43m(\u001b[49m\u001b[43mshape\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 441\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m shape \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39m[inp\u001b[38;5;241m.\u001b[39mtype\u001b[38;5;241m.\u001b[39mshape \u001b[38;5;28;01mfor\u001b[39;00m inp \u001b[38;5;129;01min\u001b[39;00m inputs])\n\u001b[1;32m 442\u001b[0m ]\n\u001b[1;32m 443\u001b[0m ] \u001b[38;5;241m*\u001b[39m shadow\u001b[38;5;241m.\u001b[39mnout\n\u001b[1;32m 444\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/utils.py:163\u001b[0m, in \u001b[0;36mbroadcast_static_dim_lengths\u001b[0;34m(dim_lengths)\u001b[0m\n\u001b[1;32m 162\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mlen\u001b[39m(dim_lengths_set) \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m1\u001b[39m:\n\u001b[0;32m--> 163\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m\n\u001b[1;32m 164\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mtuple\u001b[39m(dim_lengths_set)[\u001b[38;5;241m0\u001b[39m]\n", + "\u001b[0;31mValueError\u001b[0m: ", + "\nDuring handling of the above exception, another exception occurred:\n", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[94], line 8\u001b[0m\n\u001b[1;32m 5\u001b[0m x_err \u001b[38;5;241m=\u001b[39m pm\u001b[38;5;241m.\u001b[39mHalfNormal(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mx_error\u001b[39m\u001b[38;5;124m'\u001b[39m, sigma\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.05\u001b[39m, initval\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.1\u001b[39m)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# Calculate steady-state concentrations and fluxes from elasticities\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m chi_ss, v_hat_ss \u001b[38;5;241m=\u001b[39m \u001b[43mll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msteady_state_pytensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mEx_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mEy_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43men\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43myn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;66;03m# Error distributions for observed steady-state concentrations and fluxes\u001b[39;00m\n\u001b[1;32m 11\u001b[0m chi_obs \u001b[38;5;241m=\u001b[39m pm\u001b[38;5;241m.\u001b[39mNormal(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mchi_obs\u001b[39m\u001b[38;5;124m'\u001b[39m, mu\u001b[38;5;241m=\u001b[39mchi_ss, sigma\u001b[38;5;241m=\u001b[39mx_err, observed\u001b[38;5;241m=\u001b[39mxn)\n", + "File \u001b[0;32m~/Repos/emll/src/emll/linlog_model.py:146\u001b[0m, in \u001b[0;36mLinLogBase.steady_state_pytensor\u001b[0;34m(self, Ex, Ey, en, yn, method)\u001b[0m\n\u001b[1;32m 143\u001b[0m en \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mas_tensor_variable(en)\n\u001b[1;32m 144\u001b[0m yn \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mas_tensor_variable(yn)\n\u001b[0;32m--> 146\u001b[0m e_diag \u001b[38;5;241m=\u001b[39m \u001b[43men\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdimshuffle\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mx\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdiag\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mv_star\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m N_rep \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mNr\u001b[38;5;241m.\u001b[39mreshape((\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mNr\u001b[38;5;241m.\u001b[39mshape))\u001b[38;5;241m.\u001b[39mrepeat(n_exp, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m 148\u001b[0m N_hat \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mbatched_dot(N_rep, e_diag)\n", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/variable.py:133\u001b[0m, in \u001b[0;36m_tensor_py_operators.__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__mul__\u001b[39m(\u001b[38;5;28mself\u001b[39m, other):\n\u001b[1;32m 130\u001b[0m \u001b[38;5;66;03m# See explanation in __add__ for the error caught\u001b[39;00m\n\u001b[1;32m 131\u001b[0m \u001b[38;5;66;03m# and the return value in that case\u001b[39;00m\n\u001b[1;32m 132\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 133\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mpt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmul\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mother\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mNotImplementedError\u001b[39;00m, \u001b[38;5;167;01mTypeError\u001b[39;00m):\n\u001b[1;32m 135\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mNotImplemented\u001b[39m\n", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/graph/op.py:295\u001b[0m, in \u001b[0;36mOp.__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m 253\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Construct an `Apply` node using :meth:`Op.make_node` and return its outputs.\u001b[39;00m\n\u001b[1;32m 254\u001b[0m \n\u001b[1;32m 255\u001b[0m \u001b[38;5;124;03mThis method is just a wrapper around :meth:`Op.make_node`.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 292\u001b[0m \n\u001b[1;32m 293\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 294\u001b[0m return_list \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreturn_list\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m--> 295\u001b[0m node \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmake_node\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 297\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m config\u001b[38;5;241m.\u001b[39mcompute_test_value \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moff\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 298\u001b[0m compute_test_value(node)\n", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/elemwise.py:483\u001b[0m, in \u001b[0;36mElemwise.make_node\u001b[0;34m(self, *inputs)\u001b[0m\n\u001b[1;32m 477\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 478\u001b[0m \u001b[38;5;124;03mIf the inputs have different number of dimensions, their shape\u001b[39;00m\n\u001b[1;32m 479\u001b[0m \u001b[38;5;124;03mis left-completed to the greatest number of dimensions with 1s\u001b[39;00m\n\u001b[1;32m 480\u001b[0m \u001b[38;5;124;03musing DimShuffle.\u001b[39;00m\n\u001b[1;32m 481\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 482\u001b[0m inputs \u001b[38;5;241m=\u001b[39m [as_tensor_variable(i) \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m inputs]\n\u001b[0;32m--> 483\u001b[0m out_dtypes, out_shapes, inputs \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget_output_info\u001b[49m\u001b[43m(\u001b[49m\u001b[43mDimShuffle\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 484\u001b[0m outputs \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 485\u001b[0m TensorType(dtype\u001b[38;5;241m=\u001b[39mdtype, shape\u001b[38;5;241m=\u001b[39mshape)()\n\u001b[1;32m 486\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m dtype, shape \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(out_dtypes, out_shapes)\n\u001b[1;32m 487\u001b[0m ]\n\u001b[1;32m 488\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m Apply(\u001b[38;5;28mself\u001b[39m, inputs, outputs)\n", + "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/elemwise.py:445\u001b[0m, in \u001b[0;36mElemwise.get_output_info\u001b[0;34m(self, dim_shuffle, *inputs)\u001b[0m\n\u001b[1;32m 438\u001b[0m out_shapes \u001b[38;5;241m=\u001b[39m [\n\u001b[1;32m 439\u001b[0m [\n\u001b[1;32m 440\u001b[0m broadcast_static_dim_lengths(shape)\n\u001b[1;32m 441\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m shape \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mzip\u001b[39m(\u001b[38;5;241m*\u001b[39m[inp\u001b[38;5;241m.\u001b[39mtype\u001b[38;5;241m.\u001b[39mshape \u001b[38;5;28;01mfor\u001b[39;00m inp \u001b[38;5;129;01min\u001b[39;00m inputs])\n\u001b[1;32m 442\u001b[0m ]\n\u001b[1;32m 443\u001b[0m ] \u001b[38;5;241m*\u001b[39m shadow\u001b[38;5;241m.\u001b[39mnout\n\u001b[1;32m 444\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m:\n\u001b[0;32m--> 445\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mValueError\u001b[39;00m(\n\u001b[1;32m 446\u001b[0m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncompatible Elemwise input shapes \u001b[39m\u001b[38;5;132;01m{\u001b[39;00m[inp\u001b[38;5;241m.\u001b[39mtype\u001b[38;5;241m.\u001b[39mshape\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mfor\u001b[39;00m\u001b[38;5;250m \u001b[39minp\u001b[38;5;250m \u001b[39m\u001b[38;5;129;01min\u001b[39;00m\u001b[38;5;250m \u001b[39minputs]\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 447\u001b[0m )\n\u001b[1;32m 449\u001b[0m \u001b[38;5;66;03m# inplace_pattern maps output idx -> input idx\u001b[39;00m\n\u001b[1;32m 450\u001b[0m inplace_pattern \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39minplace_pattern\n", + "\u001b[0;31mValueError\u001b[0m: Incompatible Elemwise input shapes [(19, 3, 1), (1, 6, 6)]" + ] + } + ], "source": [ "with pymc_model:\n", " \n", diff --git a/tests/test_models/wu2004_model.json b/tests/test_models/wu2004_model.json index 546c669..6d5e312 100644 --- a/tests/test_models/wu2004_model.json +++ b/tests/test_models/wu2004_model.json @@ -1,7 +1,7 @@ { "metabolites":[ { -"id":"bpg_e", +"id":"2pg_e", "name":"", "compartment":"e" }, @@ -11,27 +11,48 @@ "compartment":"c" }, { -"id":"pep_c", +"id":"pep_e", "name":"", -"compartment":"c" +"compartment":"e" }, { -"id":"pep_e", +"id":"pep_c", "name":"", -"compartment":"e" +"compartment":"c" }, { -"id":"adp_e", +"id":"adp_c", "name":"", -"compartment":"e" +"compartment":"c" } ], "reactions":[ { +"id":"EX_2pg_e", +"name":"", +"metabolites":{ +"2pg_e":1 +}, +"lower_bound":-1000.0, +"upper_bound":1000.0, +"gene_reaction_rule":"" +}, +{ +"id":"SK_adp_c", +"name":"", +"metabolites":{ +"adp_c":1 +}, +"lower_bound":-1000.0, +"upper_bound":1000.0, +"gene_reaction_rule":"" +}, +{ "id":"PGM", "name":"", "metabolites":{ -"2pg_c":1 +"2pg_c":1, +"2pg_e":-1 }, "lower_bound":-1000.0, "upper_bound":1000.0, @@ -52,7 +73,7 @@ "id":"PK", "name":"", "metabolites":{ -"adp_e":-1, +"adp_c":-1, "pep_c":-1, "pep_e":1 }, @@ -68,7 +89,8 @@ }, "lower_bound":-1000.0, "upper_bound":1000.0, -"gene_reaction_rule":"" +"gene_reaction_rule":"", +"objective_coefficient":1.0 } ], "genes":[], diff --git a/tests/test_models/wu2004_model.sbml b/tests/test_models/wu2004_model.sbml index 77711ce..1dde47a 100644 --- a/tests/test_models/wu2004_model.sbml +++ b/tests/test_models/wu2004_model.sbml @@ -15,11 +15,11 @@ - + - - + + @@ -29,7 +29,20 @@ + + + + + + + + + + + + + @@ -45,7 +58,7 @@ - + @@ -58,7 +71,11 @@ - + + + + + From bf4eca3dfb0f20bb4db3df2e61bbdae6ebcfc32e Mon Sep 17 00:00:00 2001 From: ShantMahserejian Date: Mon, 11 Mar 2024 12:31:53 -0700 Subject: [PATCH 8/8] Added comparison between FCCs from the original Wu notebook and one with the updated cobra model --- notebooks/wu2004.ipynb | 1111 +++++++++++++---- src/emll/pymc_utils.py | 4 +- .../expected_wu2004_FCCpriors_updated.csv | 7 + tests/test_priorpredictive.py | 7 +- 4 files changed, 884 insertions(+), 245 deletions(-) create mode 100644 tests/test_data/expected_wu2004_FCCpriors_updated.csv diff --git a/notebooks/wu2004.ipynb b/notebooks/wu2004.ipynb index b618ad7..d3d97c3 100644 --- a/notebooks/wu2004.ipynb +++ b/notebooks/wu2004.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 7, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -31,9 +31,25 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/k9/b8pxky2572sdtgy2vnxhcljw0000gn/T/ipykernel_86103/3008229323.py:4: DeprecationWarning: \n", + "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", + "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", + "but was not found to be installed on your system.\n", + "If this would cause problems for you,\n", + "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", + " \n", + " import pandas as pd\n", + "WARNING (pytensor.tensor.blas): Using NumPy C-API based implementation for BLAS functions.\n" + ] + } + ], "source": [ "import numpy as np\n", "np.random.seed(0)\n", @@ -51,7 +67,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -72,9 +88,17 @@ }, { "cell_type": "code", - "execution_count": 55, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Set parameter TokenServer to value \"leghorn.emsl.pnl.gov\"\n" + ] + } + ], "source": [ "import cobra\n", "\n", @@ -126,7 +150,7 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 5, "metadata": {}, "outputs": [ { @@ -139,7 +163,7 @@ " [ 0, 1, 0, 0, -1, 0]])" ] }, - "execution_count": 41, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" } @@ -152,7 +176,7 @@ }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 6, "metadata": {}, "outputs": [ { @@ -167,7 +191,7 @@ "Name: fluxes, dtype: float64" ] }, - "execution_count": 67, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" } @@ -180,7 +204,7 @@ }, { "cell_type": "code", - "execution_count": 83, + "execution_count": 7, "metadata": {}, "outputs": [ { @@ -218,6 +242,14 @@ "Ex = emll.create_elasticity_matrix(model)\n", "display(Ex)\n", "\n", + "#### Original code to geneate Ey and ll ####\n", + "# Ey = np.zeros((3, 2))\n", + "# Ey[0, 0] = 1 # bpg (+) PGM\n", + "# Ey[2, 1] = 1 # adp (+) PK\n", + "\n", + "# ll = emll.LinLogSymbolic2x2(N, Ex, Ey, v_star)\n", + "\n", + "# Updated code to generate Ey and ll corresponding to updated cobra model\n", "Ey = np.zeros((6, 2))\n", "Ey[0, 0] = 1 # 2pg_e (+) EX_2pg_e\n", "Ey[5, 1] = 1 # pep_e (+) EX_pep_e\n", @@ -235,7 +267,7 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 8, "metadata": {}, "outputs": [ { @@ -338,7 +370,7 @@ "4 25.0 12.0 30.0 54.0 76.0 13.2 130.0 136.0" ] }, - "execution_count": 84, + "execution_count": 8, "metadata": {}, "output_type": "execute_result" } @@ -358,7 +390,7 @@ }, { "cell_type": "code", - "execution_count": 85, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -389,7 +421,7 @@ }, { "cell_type": "code", - "execution_count": 86, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -398,7 +430,7 @@ "array([87., 87., 87.])" ] }, - "execution_count": 86, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -409,7 +441,7 @@ }, { "cell_type": "code", - "execution_count": 87, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -418,7 +450,7 @@ "19" ] }, - "execution_count": 87, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -454,31 +486,6 @@ "ll = emll.LinLogLeastNorm(N, Ex, Ey, v_star)" ] }, - { - "cell_type": "code", - "execution_count": 88, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([[1., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 0.],\n", - " [0., 1.]])" - ] - }, - "execution_count": 88, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "Ey" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -490,27 +497,7 @@ }, { "cell_type": "code", - "execution_count": 89, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(5, 6)" - ] - }, - "execution_count": 89, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "N.shape" - ] - }, - { - "cell_type": "code", - "execution_count": 90, + "execution_count": 12, "metadata": {}, "outputs": [ { @@ -519,7 +506,7 @@ "Text(0, 0.5, 'Probability density')" ] }, - "execution_count": 90, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, @@ -559,7 +546,7 @@ }, { "cell_type": "code", - "execution_count": 91, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -611,9 +598,16 @@ "print(initialize_elasticity.__doc__)" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sample prior predictive trace" + ] + }, { "cell_type": "code", - "execution_count": 92, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -637,7 +631,7 @@ }, { "cell_type": "code", - "execution_count": 93, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -651,8 +645,8 @@ "
    \n", " \n", "
  • \n", - " \n", - " \n", + " \n", + " \n", "
    \n", "
    \n", "
      \n", @@ -1020,194 +1014,195 @@ " fill: currentColor;\n", "}\n", "
      <xarray.Dataset>\n",
-       "Dimensions:                    (chain: 1, draw: 500, Ey_dim_0: 6, Ey_dim_1: 2,\n",
-       "                                ey_kinetic_entries_dim_0: 2, Ex_dim_0: 6,\n",
-       "                                Ex_dim_1: 5, ex_kinetic_entries_dim_0: 10,\n",
-       "                                ey_capacity_entries_dim_0: 10,\n",
-       "                                ex_capacity_entries_dim_0: 20)\n",
+       "Dimensions:                    (chain: 1, draw: 500,\n",
+       "                                ey_kinetic_entries_dim_0: 2,\n",
+       "                                ex_kinetic_entries_dim_0: 10,\n",
+       "                                ex_capacity_entries_dim_0: 20, Ey_dim_0: 6,\n",
+       "                                Ey_dim_1: 2, Ex_dim_0: 6, Ex_dim_1: 5,\n",
+       "                                ey_capacity_entries_dim_0: 10)\n",
        "Coordinates:\n",
        "  * chain                      (chain) int64 0\n",
        "  * draw                       (draw) int64 0 1 2 3 4 5 ... 495 496 497 498 499\n",
+       "  * ey_kinetic_entries_dim_0   (ey_kinetic_entries_dim_0) int64 0 1\n",
+       "  * ex_kinetic_entries_dim_0   (ex_kinetic_entries_dim_0) int64 0 1 2 ... 7 8 9\n",
+       "  * ex_capacity_entries_dim_0  (ex_capacity_entries_dim_0) int64 0 1 2 ... 18 19\n",
        "  * Ey_dim_0                   (Ey_dim_0) int64 0 1 2 3 4 5\n",
        "  * Ey_dim_1                   (Ey_dim_1) int64 0 1\n",
-       "  * ey_kinetic_entries_dim_0   (ey_kinetic_entries_dim_0) int64 0 1\n",
        "  * Ex_dim_0                   (Ex_dim_0) int64 0 1 2 3 4 5\n",
        "  * Ex_dim_1                   (Ex_dim_1) int64 0 1 2 3 4\n",
-       "  * ex_kinetic_entries_dim_0   (ex_kinetic_entries_dim_0) int64 0 1 2 ... 7 8 9\n",
        "  * ey_capacity_entries_dim_0  (ey_capacity_entries_dim_0) int64 0 1 2 ... 7 8 9\n",
-       "  * ex_capacity_entries_dim_0  (ex_capacity_entries_dim_0) int64 0 1 2 ... 18 19\n",
        "Data variables:\n",
-       "    Ey                         (chain, draw, Ey_dim_0, Ey_dim_1) float64 0.98...\n",
        "    ey_kinetic_entries         (chain, draw, ey_kinetic_entries_dim_0) float64 ...\n",
-       "    Ex                         (chain, draw, Ex_dim_0, Ex_dim_1) float64 -0.6...\n",
        "    ex_kinetic_entries         (chain, draw, ex_kinetic_entries_dim_0) float64 ...\n",
-       "    ey_capacity_entries        (chain, draw, ey_capacity_entries_dim_0) float64 ...\n",
        "    ex_capacity_entries        (chain, draw, ex_capacity_entries_dim_0) float64 ...\n",
+       "    Ey                         (chain, draw, Ey_dim_0, Ey_dim_1) float64 0.09...\n",
+       "    Ex                         (chain, draw, Ex_dim_0, Ex_dim_1) float64 -0.3...\n",
+       "    ey_capacity_entries        (chain, draw, ey_capacity_entries_dim_0) float64 ...\n",
        "Attributes:\n",
-       "    created_at:                 2024-03-08T22:23:39.313824\n",
+       "    created_at:                 2024-03-09T23:44:54.466271\n",
        "    arviz_version:              0.17.0\n",
        "    inference_library:          pymc\n",
-       "    inference_library_version:  5.10.3
    • ey_kinetic_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1], dtype='int64', name='ey_kinetic_entries_dim_0'))
    • ex_kinetic_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype='int64', name='ex_kinetic_entries_dim_0'))
    • ex_capacity_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19], dtype='int64', name='ex_capacity_entries_dim_0'))
    • Ey_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5], dtype='int64', name='Ey_dim_0'))
    • Ey_dim_1
      PandasIndex
      PandasIndex(Index([0, 1], dtype='int64', name='Ey_dim_1'))
    • Ex_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5], dtype='int64', name='Ex_dim_0'))
    • Ex_dim_1
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4], dtype='int64', name='Ex_dim_1'))
    • ey_capacity_entries_dim_0
      PandasIndex
      PandasIndex(Index([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], dtype='int64', name='ey_capacity_entries_dim_0'))
  • created_at :
    2024-03-09T23:44:54.466271
    arviz_version :
    0.17.0
    inference_library :
    pymc
    inference_library_version :
    5.10.3

\n", " \n", " \n", " \n", @@ -1560,7 +1555,7 @@ "\t> prior" ] }, - "execution_count": 93, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -1569,9 +1564,643 @@ "trace_prior" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Sample FCCs from the prior predictive trace, and organize into dataframe\n" + ] + }, { "cell_type": "code", - "execution_count": 94, + "execution_count": 22, + "metadata": {}, + "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", + "
FCC_ref0123456789...490491492493494495496497498499
Reaction
ENO0.0472958.0262060.0630110.1248880.1952120.0166240.1067750.0053810.9183880.152977...0.4413260.3458040.0397610.0184150.0603890.0758321.6438860.0683380.0175550.176262
EX_2pg_e0.261289-12.7885740.6823380.1749290.8496620.370961-0.1375700.1090060.521470-0.052516...0.0326970.076065-0.0736430.0068260.7972950.074228-0.8548800.2930060.9374280.146382
EX_pep_e0.3055141.4535450.0491010.392880-0.0194260.3774810.4219380.072107-1.1538540.145936...0.0103830.3561430.0186490.975294-0.0622710.1959381.9753250.037652-0.0689440.035734
PGM0.1318813.3583880.0743270.0843720.2111940.088608-0.1045770.6809550.4087710.025443...0.2149960.0760710.026660-0.0148420.0963650.085245-3.7182520.2226370.0454730.189378
PK0.0925790.8508610.1063880.064738-0.0698450.1048870.4935020.0454690.0158290.156662...0.1013260.1366580.0378470.0309760.0497410.1609821.3191450.1358410.0335740.124061
SK_adp_c0.1614420.0995750.0248340.158194-0.1667970.0414390.2199320.0870820.2893960.571498...0.1992720.0092590.950725-0.0166680.0584800.4077750.6347750.2425270.0349130.328183
\n", + "

6 rows × 500 columns

\n", + "
" + ], + "text/plain": [ + "FCC_ref 0 1 2 3 4 5 \\\n", + "Reaction \n", + "ENO 0.047295 8.026206 0.063011 0.124888 0.195212 0.016624 \n", + "EX_2pg_e 0.261289 -12.788574 0.682338 0.174929 0.849662 0.370961 \n", + "EX_pep_e 0.305514 1.453545 0.049101 0.392880 -0.019426 0.377481 \n", + "PGM 0.131881 3.358388 0.074327 0.084372 0.211194 0.088608 \n", + "PK 0.092579 0.850861 0.106388 0.064738 -0.069845 0.104887 \n", + "SK_adp_c 0.161442 0.099575 0.024834 0.158194 -0.166797 0.041439 \n", + "\n", + "FCC_ref 6 7 8 9 ... 490 491 \\\n", + "Reaction ... \n", + "ENO 0.106775 0.005381 0.918388 0.152977 ... 0.441326 0.345804 \n", + "EX_2pg_e -0.137570 0.109006 0.521470 -0.052516 ... 0.032697 0.076065 \n", + "EX_pep_e 0.421938 0.072107 -1.153854 0.145936 ... 0.010383 0.356143 \n", + "PGM -0.104577 0.680955 0.408771 0.025443 ... 0.214996 0.076071 \n", + "PK 0.493502 0.045469 0.015829 0.156662 ... 0.101326 0.136658 \n", + "SK_adp_c 0.219932 0.087082 0.289396 0.571498 ... 0.199272 0.009259 \n", + "\n", + "FCC_ref 492 493 494 495 496 497 \\\n", + "Reaction \n", + "ENO 0.039761 0.018415 0.060389 0.075832 1.643886 0.068338 \n", + "EX_2pg_e -0.073643 0.006826 0.797295 0.074228 -0.854880 0.293006 \n", + "EX_pep_e 0.018649 0.975294 -0.062271 0.195938 1.975325 0.037652 \n", + "PGM 0.026660 -0.014842 0.096365 0.085245 -3.718252 0.222637 \n", + "PK 0.037847 0.030976 0.049741 0.160982 1.319145 0.135841 \n", + "SK_adp_c 0.950725 -0.016668 0.058480 0.407775 0.634775 0.242527 \n", + "\n", + "FCC_ref 498 499 \n", + "Reaction \n", + "ENO 0.017555 0.176262 \n", + "EX_2pg_e 0.937428 0.146382 \n", + "EX_pep_e -0.068944 0.035734 \n", + "PGM 0.045473 0.189378 \n", + "PK 0.033574 0.124061 \n", + "SK_adp_c 0.034913 0.328183 \n", + "\n", + "[6 rows x 500 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Sample prior FCCs\n", + "fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()])\n", + "\n", + "# Organize prior FCCs as a dataframe\n", + "priors_df = pd.DataFrame(fcc_prior[:, 0], columns=[r.id for r in model.reactions]\n", + " ).stack().reset_index(level=1)\n", + "priors_df['type'] = 'Prior'\n", + "\n", + "# Copy prior_df now for plotting later\n", + "plot_df = priors_df.copy\n", + "\n", + "# Resphape dataframe to have rows for FCC samples for each reaction\n", + "priors_df['FCC_ref'] = [x for x in priors_df.index]\n", + "priors_df = priors_df.rename(columns={'level_1': 'Reaction', 0: 'FCC'}).reset_index()\n", + "priors_df = priors_df.pivot(index='Reaction', values='FCC', columns='FCC_ref')\n", + "\n", + "display(priors_df)\n", + "\n", + "# Save FCC prior predictives\n", + "priors_df.to_csv('../tests/test_data/expected_wu2004_FCCpriors_updated.csv')" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "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", + "
indexReactionFCCType
20PGM0.131881New
30ENO0.047295New
40PK0.092579New
81PGM3.358388New
91ENO8.026206New
...............
2991498ENO0.017555New
2992498PK0.033574New
2996499PGM0.189378New
2997499ENO0.176262New
2998499PK0.124061New
\n", + "

1500 rows × 4 columns

\n", + "
" + ], + "text/plain": [ + " index Reaction FCC Type\n", + "2 0 PGM 0.131881 New\n", + "3 0 ENO 0.047295 New\n", + "4 0 PK 0.092579 New\n", + "8 1 PGM 3.358388 New\n", + "9 1 ENO 8.026206 New\n", + "... ... ... ... ...\n", + "2991 498 ENO 0.017555 New\n", + "2992 498 PK 0.033574 New\n", + "2996 499 PGM 0.189378 New\n", + "2997 499 ENO 0.176262 New\n", + "2998 499 PK 0.124061 New\n", + "\n", + "[1500 rows x 4 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "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", + "
level_0indexReactionFCCType
020.0PGM0.131881New
130.0ENO0.047295New
240.0PK0.092579New
381.0PGM3.358388New
491.0ENO8.026206New
..................
2995498NaNPGM-0.216049Old
2996498NaNPK0.876267Old
2997499NaNENO-0.160071Old
2998499NaNPGM1.124280Old
2999499NaNPK0.035792Old
\n", + "

3000 rows × 5 columns

\n", + "
" + ], + "text/plain": [ + " level_0 index Reaction FCC Type\n", + "0 2 0.0 PGM 0.131881 New\n", + "1 3 0.0 ENO 0.047295 New\n", + "2 4 0.0 PK 0.092579 New\n", + "3 8 1.0 PGM 3.358388 New\n", + "4 9 1.0 ENO 8.026206 New\n", + "... ... ... ... ... ...\n", + "2995 498 NaN PGM -0.216049 Old\n", + "2996 498 NaN PK 0.876267 Old\n", + "2997 499 NaN ENO -0.160071 Old\n", + "2998 499 NaN PGM 1.124280 Old\n", + "2999 499 NaN PK 0.035792 Old\n", + "\n", + "[3000 rows x 5 columns]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Create violin plot for 'Prior' FCCs to compare results from original wu2004.ipynb vs. one with an updated cobra model & elasticity matrices\n", + "import seaborn as sns\n", + "data_prior = pd.DataFrame(fcc_prior[:, 0], columns=[r.id for r in model.reactions]\n", + " ).stack().reset_index(level=1)\n", + "data_prior['type'] = 'New'\n", + "data_prior.columns = ['Reaction', 'FCC', 'Type']\n", + "data_prior = data_prior.reset_index()\n", + "\n", + "# Filter df to only keep FCCs of reactions of interest\n", + "keep_rxns = ['PGM', 'ENO', 'PK']\n", + "plot_df = data_prior.iloc[[i for i in data_prior.index if data_prior.Reaction[i] in ['PGM', 'ENO', 'PK']]]\n", + "display(plot_df)\n", + "\n", + "# Load original cobra model prior FCC samples\n", + "orig_data_prior = pd.read_csv(\"../tests/test_data/expected_wu2004_FCCpriors.csv\", index_col=0)\n", + "orig_data_prior = orig_data_prior.T.stack().reset_index(level=1)\n", + "orig_data_prior['type'] = 'Old'\n", + "orig_data_prior.columns = ['Reaction', 'FCC', 'Type']\n", + "\n", + "plot_df = pd.concat([plot_df, orig_data_prior]).reset_index()\n", + "display(plot_df)\n", + "\n", + "this_pal = my_pal = {\"New\": \"r\", \"Old\": \"b\"}\n", + "\n", + "sns.violinplot(\n", + " x='Reaction', y='FCC', hue='Type', data=plot_df,\n", + " density_norm='width', width=0.5, palette=this_pal, saturation=1.\n", + ")\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, continue with posterior predictive" + ] + }, + { + "cell_type": "code", + "execution_count": 17, "metadata": {}, "outputs": [ { @@ -1587,7 +2216,7 @@ "\u001b[0;31mValueError\u001b[0m: ", "\nDuring handling of the above exception, another exception occurred:\n", "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[94], line 8\u001b[0m\n\u001b[1;32m 5\u001b[0m x_err \u001b[38;5;241m=\u001b[39m pm\u001b[38;5;241m.\u001b[39mHalfNormal(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mx_error\u001b[39m\u001b[38;5;124m'\u001b[39m, sigma\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.05\u001b[39m, initval\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.1\u001b[39m)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# Calculate steady-state concentrations and fluxes from elasticities\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m chi_ss, v_hat_ss \u001b[38;5;241m=\u001b[39m \u001b[43mll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msteady_state_pytensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mEx_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mEy_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43men\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43myn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;66;03m# Error distributions for observed steady-state concentrations and fluxes\u001b[39;00m\n\u001b[1;32m 11\u001b[0m chi_obs \u001b[38;5;241m=\u001b[39m pm\u001b[38;5;241m.\u001b[39mNormal(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mchi_obs\u001b[39m\u001b[38;5;124m'\u001b[39m, mu\u001b[38;5;241m=\u001b[39mchi_ss, sigma\u001b[38;5;241m=\u001b[39mx_err, observed\u001b[38;5;241m=\u001b[39mxn)\n", + "Cell \u001b[0;32mIn[17], line 8\u001b[0m\n\u001b[1;32m 5\u001b[0m x_err \u001b[38;5;241m=\u001b[39m pm\u001b[38;5;241m.\u001b[39mHalfNormal(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mx_error\u001b[39m\u001b[38;5;124m'\u001b[39m, sigma\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0.05\u001b[39m, initval\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m.1\u001b[39m)\n\u001b[1;32m 7\u001b[0m \u001b[38;5;66;03m# Calculate steady-state concentrations and fluxes from elasticities\u001b[39;00m\n\u001b[0;32m----> 8\u001b[0m chi_ss, v_hat_ss \u001b[38;5;241m=\u001b[39m \u001b[43mll\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msteady_state_pytensor\u001b[49m\u001b[43m(\u001b[49m\u001b[43mEx_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mEy_t\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43men\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43myn\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 10\u001b[0m \u001b[38;5;66;03m# Error distributions for observed steady-state concentrations and fluxes\u001b[39;00m\n\u001b[1;32m 11\u001b[0m chi_obs \u001b[38;5;241m=\u001b[39m pm\u001b[38;5;241m.\u001b[39mNormal(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mchi_obs\u001b[39m\u001b[38;5;124m'\u001b[39m, mu\u001b[38;5;241m=\u001b[39mchi_ss, sigma\u001b[38;5;241m=\u001b[39mx_err, observed\u001b[38;5;241m=\u001b[39mxn)\n", "File \u001b[0;32m~/Repos/emll/src/emll/linlog_model.py:146\u001b[0m, in \u001b[0;36mLinLogBase.steady_state_pytensor\u001b[0;34m(self, Ex, Ey, en, yn, method)\u001b[0m\n\u001b[1;32m 143\u001b[0m en \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mas_tensor_variable(en)\n\u001b[1;32m 144\u001b[0m yn \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mas_tensor_variable(yn)\n\u001b[0;32m--> 146\u001b[0m e_diag \u001b[38;5;241m=\u001b[39m \u001b[43men\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdimshuffle\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m1\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mx\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[43mnp\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdiag\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mv_star\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 147\u001b[0m N_rep \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mNr\u001b[38;5;241m.\u001b[39mreshape((\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m*\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mNr\u001b[38;5;241m.\u001b[39mshape))\u001b[38;5;241m.\u001b[39mrepeat(n_exp, axis\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m0\u001b[39m)\n\u001b[1;32m 148\u001b[0m N_hat \u001b[38;5;241m=\u001b[39m at\u001b[38;5;241m.\u001b[39mbatched_dot(N_rep, e_diag)\n", "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/tensor/variable.py:133\u001b[0m, in \u001b[0;36m_tensor_py_operators.__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m 129\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__mul__\u001b[39m(\u001b[38;5;28mself\u001b[39m, other):\n\u001b[1;32m 130\u001b[0m \u001b[38;5;66;03m# See explanation in __add__ for the error caught\u001b[39;00m\n\u001b[1;32m 131\u001b[0m \u001b[38;5;66;03m# and the return value in that case\u001b[39;00m\n\u001b[1;32m 132\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 133\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mpt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmath\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmul\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mother\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 134\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mNotImplementedError\u001b[39;00m, \u001b[38;5;167;01mTypeError\u001b[39;00m):\n\u001b[1;32m 135\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mNotImplemented\u001b[39m\n", "File \u001b[0;32m~/.pyenv/versions/3.11.5/envs/bmca/lib/python3.11/site-packages/pytensor/graph/op.py:295\u001b[0m, in \u001b[0;36mOp.__call__\u001b[0;34m(self, *inputs, **kwargs)\u001b[0m\n\u001b[1;32m 253\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124;03m\"\"\"Construct an `Apply` node using :meth:`Op.make_node` and return its outputs.\u001b[39;00m\n\u001b[1;32m 254\u001b[0m \n\u001b[1;32m 255\u001b[0m \u001b[38;5;124;03mThis method is just a wrapper around :meth:`Op.make_node`.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 292\u001b[0m \n\u001b[1;32m 293\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m 294\u001b[0m return_list \u001b[38;5;241m=\u001b[39m kwargs\u001b[38;5;241m.\u001b[39mpop(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreturn_list\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;28;01mFalse\u001b[39;00m)\n\u001b[0;32m--> 295\u001b[0m node \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmake_node\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43minputs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 297\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m config\u001b[38;5;241m.\u001b[39mcompute_test_value \u001b[38;5;241m!=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124moff\u001b[39m\u001b[38;5;124m\"\u001b[39m:\n\u001b[1;32m 298\u001b[0m compute_test_value(node)\n", @@ -3181,7 +3810,7 @@ "source": [ "fcc = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace.posterior['Ex'][0].to_numpy()])\n", "fcc_mb = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_vi.posterior['Ex'][0].to_numpy()])\n", - "fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()])" + "# fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()])" ] }, { diff --git a/src/emll/pymc_utils.py b/src/emll/pymc_utils.py index 8fa46a9..34e8888 100644 --- a/src/emll/pymc_utils.py +++ b/src/emll/pymc_utils.py @@ -52,9 +52,9 @@ def sample_prior_fccs(cobra_model): # Get stoichiometric matrix N = create_stoichiometric_matrix(cobra_model, dtype='int') - # Creaet linlog model + # Create linlog model ll = linlog_model.LinLogLeastNorm(N, Ex, Ey, v_star, driver='gelsy') fcc_prior = np.array([ll.flux_control_coefficient(Ex=ex) for ex in trace_prior.prior['Ex'][0].to_numpy()]) - return fcc_prior + return fcc_prior \ No newline at end of file diff --git a/tests/test_data/expected_wu2004_FCCpriors_updated.csv b/tests/test_data/expected_wu2004_FCCpriors_updated.csv new file mode 100644 index 0000000..6df4025 --- /dev/null +++ b/tests/test_data/expected_wu2004_FCCpriors_updated.csv @@ -0,0 +1,7 @@ +Reaction,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,52,53,54,55,56,57,58,59,60,61,62,63,64,65,66,67,68,69,70,71,72,73,74,75,76,77,78,79,80,81,82,83,84,85,86,87,88,89,90,91,92,93,94,95,96,97,98,99,100,101,102,103,104,105,106,107,108,109,110,111,112,113,114,115,116,117,118,119,120,121,122,123,124,125,126,127,128,129,130,131,132,133,134,135,136,137,138,139,140,141,142,143,144,145,146,147,148,149,150,151,152,153,154,155,156,157,158,159,160,161,162,163,164,165,166,167,168,169,170,171,172,173,174,175,176,177,178,179,180,181,182,183,184,185,186,187,188,189,190,191,192,193,194,195,196,197,198,199,200,201,202,203,204,205,206,207,208,209,210,211,212,213,214,215,216,217,218,219,220,221,222,223,224,225,226,227,228,229,230,231,232,233,234,235,236,237,238,239,240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255,256,257,258,259,260,261,262,263,264,265,266,267,268,269,270,271,272,273,274,275,276,277,278,279,280,281,282,283,284,285,286,287,288,289,290,291,292,293,294,295,296,297,298,299,300,301,302,303,304,305,306,307,308,309,310,311,312,313,314,315,316,317,318,319,320,321,322,323,324,325,326,327,328,329,330,331,332,333,334,335,336,337,338,339,340,341,342,343,344,345,346,347,348,349,350,351,352,353,354,355,356,357,358,359,360,361,362,363,364,365,366,367,368,369,370,371,372,373,374,375,376,377,378,379,380,381,382,383,384,385,386,387,388,389,390,391,392,393,394,395,396,397,398,399,400,401,402,403,404,405,406,407,408,409,410,411,412,413,414,415,416,417,418,419,420,421,422,423,424,425,426,427,428,429,430,431,432,433,434,435,436,437,438,439,440,441,442,443,444,445,446,447,448,449,450,451,452,453,454,455,456,457,458,459,460,461,462,463,464,465,466,467,468,469,470,471,472,473,474,475,476,477,478,479,480,481,482,483,484,485,486,487,488,489,490,491,492,493,494,495,496,497,498,499 +ENO,0.022924690247504806,0.1045522810582563,-0.03479476525103959,0.24081172226292835,0.06879244555498734,0.09064966883324023,1.2524952026956362,0.13105055158808168,0.12239706690204058,0.1771540398652053,0.2531360841957956,0.20899984436940108,0.2654477874069424,0.1465548555456665,0.05790490139157538,0.1800669440775864,-0.037737176604804655,0.04514715212119891,0.10763045586986274,0.07462079270141936,-0.017093253971439584,0.027246824641894155,0.03888699013963314,-0.13519780175320925,-0.06029856956780774,0.09874223383867145,0.020460170671766042,0.15062334183578152,0.3094743180164192,0.3896184253970394,0.25168354576515495,-0.029727526874532405,0.3145144426103843,0.09602233048519278,0.11776464442869833,0.5398521596861829,0.15455868632818706,0.07471417141645147,0.08816336484038388,0.3830890313500976,-0.48434720487187394,-0.046859474029268086,0.38324730027967474,0.06839374294641773,0.2850930811586383,0.07730751757526055,-0.0013051671474512243,-0.20000733136679433,0.026384072342231134,0.1995321786761346,0.3589013767622907,-0.025701983451491873,0.2870161354832911,0.09663457776110422,0.14817613727837314,0.30138259629280156,0.0773081145411698,1.135419460171669,0.33046544798440214,0.1027303152973835,0.05273713266394615,0.3872274365243201,-0.00708250002946667,0.02265212632879983,0.07898403870068509,0.03154723072392261,0.308221253924915,0.0418217417196753,-0.01599315550291044,0.29223719610930593,-0.23236936120157567,0.13982526936329753,0.044946811393737046,0.261317497766806,-0.007624778233920396,0.014638475904965644,-0.05728319358822861,0.05890577450401878,-0.03088359727153551,0.2672939339273012,-0.040098352098726586,0.17384730147464475,0.24169225683918147,0.04942009977558475,0.1247549437412781,-0.006060315413306484,0.06809582151171517,0.16164188389265807,-0.02046782586918477,0.028331413397804196,0.04538389271252888,0.3941245151167705,0.20532470219180615,0.20803857547171628,0.01969897236641154,1.3151562488419362,0.2154603758979641,1.0479383347372564,-0.03106046539215777,-0.08972106926385619,0.10998255456409031,0.0653514203150558,0.11621454346896413,0.18258893873496973,0.00753340683923579,0.43301065760333357,0.034517129295115044,0.2015502963279083,0.08333719272253905,0.28857725634046766,0.13811832050128736,-0.18230022600402782,0.0647477985441064,0.14854592206865333,0.12708631474868132,-4.403756708483944,0.0315847197389666,0.05632733097414346,0.1681314195793619,0.03732861302052697,0.3175746754838728,0.08358291520472098,0.5907498913541587,0.17244252472285965,-0.3733533597531652,0.15044724008924226,0.14170424779727062,-0.13312035916820789,-0.04505578833517779,-0.18851850681730326,0.0880621973341746,-0.029976603648355065,0.0910151896822578,0.05121977248782617,0.15509414338421737,0.06730839442358162,0.5420198117185567,0.05295941924003514,0.23798544522039686,0.27063695272075405,-0.05979149588579815,0.05535960999749483,0.06291479415261748,0.1561494695291847,0.4564859197619488,0.1181436126587815,0.1368744608487813,0.13889466990903004,0.1798613572874144,-0.6148288605189665,-0.1869777782079749,0.2633150820565202,0.10641547007739119,0.019244108034219734,0.3784895842216694,0.05729722740023857,-0.24464565848537986,0.9217147571535266,0.009690635945409353,0.10536464944281015,0.20376195745051878,0.1555722404824861,0.07487812371997289,0.07377303933694392,-0.08775165903156601,0.05442250095909777,0.01814086604511406,-0.0500264211279822,0.025347484907319483,0.10981532870048957,-0.09154940560251773,0.15184755773679934,0.6810891620043897,0.35090944712577776,0.23730964989979472,0.07047706032208424,0.07874255760737987,0.09203034183064338,-0.025949159957354688,0.02232794437206563,-0.004370021319533247,0.2025092012296373,0.05625110820189,0.10921266044688226,0.14653579512921897,0.3189299439107048,-0.5314998244669832,-0.02332142191152774,-0.05702491072292876,0.13555041716696414,0.12712117988591148,0.13977975250996894,0.022644611522082893,0.11604280637218843,0.04286121444807824,-0.0864649361962506,0.057349716390609574,0.08130844251308975,1.1795587740505122,0.16224978620199615,-0.00631771986685083,-0.04444666741787431,0.49157530881842626,-0.013702107016620788,0.005266286083840823,0.3204822312324144,0.05350768500997043,0.27315433247948295,-0.004724836219703983,-0.03692315778240626,0.20097681457124117,0.16342911043601255,0.8295012063325875,0.2810964801302618,0.2796585241118119,0.14710157507792934,0.21465677298444383,-0.028396272177646696,0.041070391089602476,-2.2657256757754944,0.07536462211204487,0.06663730367298681,-0.051644397778048995,0.5148768909415594,-22.875009881676196,0.061265434954409274,0.08916776043592231,-0.03316176866964984,-0.20613834260274955,0.026711706947158496,0.06103026874883788,-0.11564439310894012,0.4411689866320884,0.007134434146139581,-0.040808785164187324,-0.04133163883633415,0.4917587746870366,0.17845007373355273,0.017435975951254342,0.09840079789724482,0.30286340789208965,0.028690792243037725,0.23897352148931847,-0.13092816692981052,0.35316129243443395,-0.00034031423127916925,0.0671669792848964,-0.0015752489055289554,0.03481847196327733,0.08334929879505681,1.2002014995161439,-0.03168281338942365,0.18739935437435146,0.031669826284881165,0.3777834822321863,0.140855515580494,0.22698168176168954,0.11437268400678183,0.002056654628590793,0.2923788268025679,0.26701075002990465,0.012785311675986491,0.34204925377462386,0.1612678319009057,-0.5847992672353673,0.14550579187046936,0.08396072273424832,0.07361830806095122,-0.029243349602066544,0.17952502048114974,0.026684303980860177,-0.37866040452187255,0.18806623054659613,0.06948044883984453,0.29920608504713675,0.0623053942993782,0.36915840794585947,0.3239029732253105,0.08542681511346624,0.05340509728818273,-0.22581210917128078,0.1839214423284462,0.23198202200503093,0.03495105749188078,0.3364553944979701,0.7686561065069958,0.11388437165666515,0.17252191585785562,0.8821286631753399,0.161327178529316,0.08057628597380664,0.06944646706886025,0.14077562566429874,0.9439302215647456,0.45764423639312524,0.32412910294125585,0.16243545832265222,0.12767863838797017,0.9795989989160999,0.08701397486007198,0.1656436099751911,0.2203300529840443,0.12411768730443135,0.037911738987555434,0.17333491704232307,0.12919682766763857,0.3893735413765571,-0.02334718394048528,0.23551923763128244,0.04944205886147594,-0.005651321863271877,0.3015760749156684,0.35897506158521797,0.06541720730444478,0.014877590001720464,0.3508444672981307,0.16484495637843338,0.28364237575916806,0.09351311373600506,0.13428243299415912,0.010756834446367939,0.026194275777237,0.2435845310674962,0.02714384282476962,0.08152539272395247,-0.08085457264622876,0.1911841252849241,-0.040251151653092544,0.21083792947076505,0.001093629386228823,0.5137119743846408,0.033757351374927365,0.09463573585968159,0.3518302289849284,0.10360548197532343,0.4555276901954071,-0.07014996755913333,0.039999773226770015,0.025743681998989847,-0.15730436014818006,0.4491138490468282,0.12829627930886095,0.01167626768400398,-0.09107547295549005,0.03399693719487229,0.0038581642965107854,0.6826760834337935,0.2265864481101225,0.09924129826634992,0.08585979009206492,-0.13103587600576344,0.18305248790465684,60.791395896789744,0.06491858964543584,0.3709302792156826,0.22916623421096807,0.05747418983674138,0.020203840015585818,0.8633411015204898,0.14800046728294675,-0.1338693245513082,-0.007779923424582239,0.03494996002808482,0.16572930756286053,0.05072669324524613,-0.007398618755389604,-0.22030405367521852,0.16966360694581883,-0.18704094594153142,0.10969305677565994,0.1850523269313006,0.04650713391554991,0.1578956192660822,0.025354053633691333,0.19342329556334104,0.1318906569936718,0.022902997568613838,0.027147311468424282,0.14462135115836944,0.6277008542308476,1.2786722621212803,-0.18519937469688652,0.02179129761513478,0.034460761781030094,0.17998858731916456,0.5103722419390984,0.21267812758567145,0.045648300371142564,-0.01652899823912614,0.32003037025205133,0.040477275482481694,-0.012914833580238228,0.061136819501084266,0.09228351130613666,0.0985250007387439,0.023545099350609798,0.10477404231293523,0.29985581450883425,0.12270200064433694,-0.0005806250484481504,0.21489769017403992,-0.019361298026047503,-0.02321734248100933,0.6130749628508474,0.12064442140702396,0.21344854549015777,0.02434106760818563,0.08670821914102018,0.13496966493687412,0.15271348018775452,0.25595174093439244,0.24728329342308192,0.30303992770842986,0.736569827828135,0.12457470780799383,0.40471494744331526,0.08791484225910359,0.08684399066714736,0.42210411958183053,0.35290178365037717,-0.00024670019771111444,0.04675339447473226,0.057708733039348946,0.04368377015596754,36.57399670828708,0.19824363689294475,0.017879647931099103,0.04893734173625858,0.5323670037318086,0.07939336398000478,0.038133053698864584,0.15240717226193815,0.4811575788592643,0.046355619358311485,0.07082668818092105,0.3700940706411356,0.3069004337305898,-0.056098707344436886,0.07107606476272745,0.1882717126529245,0.05618707646280768,0.06208971561461104,-0.07112620420747447,0.02943867321959483,0.5085883542909263,0.025938111034431974,0.014772304601136045,0.11383674375051651,0.159215553948829,-0.0954339045137615,0.10294680181238096,0.024582098425558717,0.00549926155189794,0.032319011133780426,-0.296302121068985,-1.1033464938258244,0.1553789471574935,0.5246400330803622,-0.014906108716638593,0.11850667974436481,0.07296446988797216,0.144331498532227,0.1646989594470369,0.04270581727946162,0.2272192566039884,0.1192972015028455,0.0727448567495959,0.07683265302416648,-0.17710898723606083,-0.18834844376117676,0.41100851397250215,-0.07085713030702488,-0.04751747328862185,0.05756790056075437,0.13934701164188656,0.39059593744730875,-0.06737780223936478,0.07159086718235139,0.014106606661231697,0.3029177594677711,0.4219125152972957,0.22521479600552916,0.01319867627960571,0.09860284500025464,0.06182812090217583,-0.10880762035936914,0.2319804851830256,0.021800824751431427,0.1733639962510227,0.0914965559292972,0.07826658070172919,-0.07456957826496957,0.5046070543201964,0.5759494101835034,-0.11021712282123969,0.020989843981905926,0.32424667928852635,23.305716128399425,0.01132127298482701,0.16355653041583113 +EX_2pg_e,0.031517873411745834,0.1648950490221447,2.096389151962028,0.19141399150163063,1.64478805723601,0.309512438655412,0.4315343814869198,-0.017027886240376544,0.12162235048085224,0.1823894557393838,-0.009982464698776283,-0.038644304098961246,-0.03584313134090844,0.027838164343683358,-0.02072530029491504,0.588688227268866,-0.012966958478532575,-0.01268442391504987,0.008703174244462653,0.24378290218139276,0.5003425217379303,0.36868304396008467,0.023037226978452785,0.036187485667208086,-0.06350641110612987,0.09356587612193046,-0.422894979894779,0.1840558318165164,-0.006500681922174456,-3.931756409526992,0.006289784871036153,0.05031693524951997,0.24527180265415494,0.1013714393572881,0.3907987314015122,0.1727499628971445,-0.0600595023399062,0.10566097456939239,0.17186337069268565,0.3514088585750078,4.3805961909851385,0.6344173159983202,-0.05736475450086753,0.13202968912943502,0.09976428447422803,0.4054939224777784,-0.11090275768749458,-0.2414915700849245,0.2777318089207539,0.14598739617265033,0.14251145544422106,-0.09862606429633236,1.7090327962606593,0.193665186416054,0.21021691847149426,0.13325139893312032,0.590373023129644,-0.492745860546278,0.08717321110004572,-0.3996718449240244,-0.08975770637245883,0.1646241378638933,0.2821309534796753,0.6271470911995276,-0.023025608592956992,0.09059242063036321,0.023516071555779727,-0.03221707450217015,0.029882487137439684,-0.04432795722320915,-0.05111187297346875,-0.011572039727836714,0.2897915277276104,-1.6574867757207703,0.12070546105980406,0.058207596625270974,0.049438920797874486,0.5866550295694353,-0.04380486141863038,0.09292857129391363,0.006872703057041907,0.8558577531970493,-0.0030979421829975262,0.44899991087415814,0.399707478566277,0.18681034645731964,3.116012459243107,0.4910519214763045,0.0627347700763663,0.09882534901496165,-0.03411851742478089,0.027156707276140946,0.4993041029272044,0.062173616801413534,0.6980519212763545,-0.5439468507943974,0.08782171353378554,-0.7266447761932548,0.008660415475784666,1.0867707466462049,0.0914246170159414,-0.1493981440589771,0.03988447704554943,-0.004175554725007746,0.05614678641130599,0.16888522953737217,0.0186253477657915,0.27132970300380976,-0.0034296791405628024,0.10238748618449867,-0.18344821500858877,-0.45262495327142305,0.2719915482577624,-1.0755924935389132,0.28646126387975135,-4.2833655483707345,0.046681638146550686,-0.012168178334828417,0.24268324213025372,0.7064946599230935,0.7902674948501801,0.6699149799994367,0.5320217811066725,0.0288698630557499,0.4768521683054411,0.5249065547913008,0.2560534901773185,0.7685965313616316,1.1340615179157982,0.4281905292871453,0.3854059428811568,0.0675297425978838,-0.4772534144130709,0.10956625795592656,0.5509175134937663,0.12365768667462707,-0.7683097629370712,-0.01843181145084949,-0.0071071272177001266,0.09609077138093491,1.3894495362428594,0.7972844830498704,0.002721673499239685,-0.020608932993092743,0.05409955457325766,0.09342472601933294,0.21954919188153887,0.20011265092984576,0.25553449269597794,2.492835176783874,1.915298719140309,-0.017709973792880973,0.0353263971256399,-0.011953066860294737,0.40440323278798085,0.008473180891497734,-0.0344358113247063,-0.26644097358691354,0.31419767480885685,0.3622352829610871,0.5116976720339115,-0.020285480848421855,0.05772052708212816,-0.043963103849604224,-0.24390451926954237,0.01876045276312821,0.1079640064411197,3.1824930615696143,0.10795927214608281,0.40083595066603017,1.083314280105594,0.4197601851059072,-0.3469748788393634,0.055618702889772886,0.10788058170682635,0.305532950701464,-0.12904175022178843,0.1608827543977328,-0.010883352427937254,0.16470076510659803,0.052399292756564075,0.33661167782365164,0.05389227251679396,0.08669514522557031,0.3475519248601596,0.08024064951642418,-0.04359178011477227,0.008639164513657982,-0.3199910311226817,0.5730470570139019,0.1364924519792492,0.1475479979158515,0.1744798950638461,-1.141832441251334,1.254410072659745,0.21113392803520203,0.40510009281928683,0.6669538902638679,-0.08116780636395249,0.04363522839031986,0.1758649798807682,0.01071429381355693,0.1261606205240945,-0.22216123723086856,0.6982666876161717,0.04022566543099326,0.012556971887165425,0.060381818527754594,0.0641651890037801,-0.25557526549840026,0.07028610825088277,0.00628298234723057,0.1136772564820051,0.2594083250064977,0.16238224923373423,0.24324825443650722,0.1671300624647728,0.33382389848960126,0.0298841111914675,5.055922088374493,0.03340301424462466,0.20671852234805976,0.11896215453593229,0.028948381855246175,91.15320453072523,-0.027670274965935437,0.10152873027169951,0.7593717879147847,0.9961502731604219,0.7095380085660151,-0.2810021820889268,0.03678232208963672,0.09918543189235252,0.631890533752316,0.5264721828196246,0.03993447627696667,0.10159989357111388,0.9588506667056229,0.12319071796322623,0.2784871932060107,0.006968448394244042,-0.043460508828802036,0.005378028008948155,0.5234706573974286,0.19897144547020484,-0.3074076032760147,0.37812020575881156,0.9455350045345462,0.4296696768845326,-0.03267891389243194,0.4336077003237919,0.15845124294007573,0.1290849701993384,0.05424129294382518,0.43929129127127087,0.027970545494142462,0.20196174721509053,0.4699266699894168,0.04353151410075806,-0.08919773231548578,0.2478257744379906,0.7275734163706067,0.04963129683286527,0.01942328367822843,-3.619849628848324,0.4040654837784031,0.6512740935443975,0.34916474654235585,0.018315250327365806,0.5551095524660052,0.11561897048413516,-0.3290832124768348,0.04065101114654679,0.01235255335623553,0.04795565073027108,-1.2364511394279596,0.25550979676035823,0.48856103527494044,1.7822368848255783,0.03706314501132957,0.010568307820654876,0.32119627935825446,-0.07192311720619249,-0.004142276848375204,0.08282068548846289,-0.08534794685219782,0.573862940538845,0.1655584310581102,-0.5217310763584102,0.42728354357727794,0.08619079501836713,-0.2950129214018402,0.6234131117576511,0.705778215194049,-0.027765122553881527,-1.1394644661436928,-0.031003250712395403,2.914721764768938,-0.33189288216091284,0.10682147539647469,0.0775368632092619,0.01512635600688661,0.05955251106789583,0.09341227683102749,-0.08997706234834268,0.3548742139763432,0.1088623962862284,0.026618316972832567,0.1630235920962675,0.4739084953845101,-0.5254346671514987,0.03417065270228303,0.5670643494356504,0.013077422886741408,0.033013123742177686,0.6849853157065274,0.13164069686203395,0.15739830726853787,0.5291294628187386,0.26938619912647377,1.4250765508169128,0.15779888631918715,0.031410352669109964,0.5360671253694235,0.0783470321271833,0.6219775064090282,0.19246358920982476,0.07712157953878163,0.054141511874853165,0.8586047002806506,0.0884562380346059,-0.035920748833783156,0.01856572770781062,-0.009316831047034402,-0.03950008800565774,0.19821570047484682,-0.08267643153682291,0.5350437501411069,0.6078476553423063,0.028368327756092437,-0.00023327088845070953,0.054597007779649154,0.05458411238414218,-0.12018481962111593,0.5209624373113639,0.10501976526869816,-2.751352246650198,-0.04656126221922796,0.3101608830743757,0.019013944957639528,0.7545737468025804,-8.616631936630981e-05,87.000349744849,0.030049149278568832,-0.04536748882716157,2.138654899320826,0.7714978989195906,-0.07484802234047194,4.625752123334234,0.0253782252047432,0.10556500195793195,-0.732946359481824,0.0032798083007158363,0.007474914077838957,0.59122363314772,-0.20082312458026674,-0.04465498504686405,0.04206099134546215,0.17260037455117383,0.3231589699914448,0.802976920255235,0.13105236022134004,0.16720833185907402,0.5309694094975255,-0.06808626391451811,0.44339380328434663,0.44357756710062246,0.868445489190068,-0.022175614865656224,0.05843481549244989,-0.2626237199677979,1.0294272295568958,-0.12331199902851187,0.11743754862842581,0.021996246512473783,-0.009669449078597792,-0.019661544679698606,0.18930567943825127,1.079399487993845,0.13327132715734358,0.7060244066283733,0.770430828217383,0.17549060393519567,0.3100283285814923,-0.041010947684580135,-0.17293316041679008,0.41777376196001315,0.20100481859021868,0.07371927150607649,0.33213327812624704,0.342662975480183,-0.14116444759732127,-0.025498241514184006,-0.1184239569252421,0.7981532702084644,-0.0625312381450065,0.40829177620875734,0.24173351931034226,0.383608178762729,0.20637631366584763,0.008942567311880256,0.020491414205660807,0.3238280086082146,0.11564061620972765,0.12588568237747344,0.018342498688364905,0.22006356535896054,0.0253237220174648,0.09595509948015524,0.4492989219120277,0.038950915254244545,0.6757677513978155,0.36095208161688463,0.0292330795507868,-1.4853636697142858,-0.1484384881279608,1.1011868953628414,0.7187890565090445,-0.02135285766522288,0.26447760220107674,0.45343830644957017,0.010641269286726152,-0.3382377842693596,0.1370670203665918,1.3065363707573434,0.014365303126229967,0.08259612865393684,0.00644293435532417,0.3589919779949904,-0.02754042312160454,0.8043418981251422,-0.19620185785572763,0.23878255067060206,0.0203335305670298,-0.0014814520379511364,0.22367128271172032,0.5995312314652967,0.21588532960380424,0.12009215282596764,-0.04487736411937715,0.05770716185888192,0.27698914178630907,0.019852090718698756,0.6044715254010504,-0.2711524848717757,3.713815985436469,0.05378617495278615,0.0345942763713698,1.3186898782103293,0.21329925502416436,-0.06443658127909968,0.012220011882850379,0.03106931005875424,0.332553461544176,0.3877666070520467,0.24558945254238962,-0.030638438812276902,0.15891633157772378,-0.20236451968819824,0.03134387778648662,0.033514139551475974,0.14633223773519766,-0.04068984669276321,0.11703759123076662,0.10319858989558317,0.7175135149034277,-0.03436978264855539,-0.07143975432389849,0.0726597604815068,0.27787154159500194,-0.0012047966337591642,0.2324148221076786,-0.29646910925061154,-0.9134058167048533,0.1746423658858247,-0.2356847348004194,0.073637194906089,0.5664205527304941,-0.039275535614608614,0.3531141096761983,0.7964209972020168,2.164591462301744,-1.212522887503202,0.05731130482579716,-0.09043664313304434,-0.02677107073585705,1.3614062028711618,0.5024136419079603,0.8714374187467192,0.21047535287111008 +EX_pep_e,-0.052736388758013716,-0.03274529796826097,-0.3302915202699556,0.21788730217685304,-0.09109609325748298,0.15593053494072867,0.2883899270180018,0.32426303113260113,0.49936173389308397,-0.017535675639448578,0.12864045880610223,0.6257901406218481,0.007884003240311983,-0.14316657331797375,0.10024529812129597,0.44717526382339984,0.36902143273835203,0.7512663420999878,0.3909914533896416,0.22117606741449122,0.13456325466382318,0.052889776843238305,0.2750762131077818,-0.25622740116577275,1.4050751006067312,0.047951012320693064,0.9785184270002762,0.4050540968550342,0.012316874722740753,-0.3542408042969494,0.25072768165192094,0.43458808843806007,-0.024192506479110528,0.0590893667536121,-1.8151034977660203,-0.009265431157088994,0.383179558923106,0.11770058208363564,0.048069248513975864,-0.11000026254550045,-3.946032485030691,0.07919526235329177,-0.011638261199114765,0.3158789433047397,0.18576053557617028,0.019897608896124467,0.13227387730946247,0.9462806903381725,0.12751183848303743,0.001519894647715292,0.03493042832253229,0.4731281346011463,0.13858973796130997,0.42936469512701053,0.08733410671117295,0.03209386233712738,-0.010987873200585203,0.030397078979092933,-0.022176940215312437,0.5938287035219841,0.07419302295882696,0.058931597839183614,-0.06178185581681496,0.018422712029107162,0.09946963624156659,0.31391186399304183,0.023474050148276686,-0.19354934345439634,0.10965266556953537,-0.4969877496193449,0.9632433680957623,0.08010713306768764,0.48065226475496997,0.03762974173810781,-0.267602664524173,0.03854396024726089,0.03890337547134057,0.10713561011284356,1.021533101215282,-0.003616129723466143,0.7585381733067571,0.02632866051351441,0.20994391188086425,0.010858796518601095,0.10093167512543957,0.07711345221176218,-0.8970497412554819,-0.01616648343450289,0.7053736291744124,0.1524651600591905,0.22797066348059042,0.13178277723301196,0.05202543375180548,-0.02337102538408709,0.009619175653587537,-0.058419694250433994,0.07000713652230292,-0.10948100575506556,0.29823045135139903,0.04137316954268717,0.0036034912026353017,0.8629201507427211,0.1795395997190929,0.4402039246017495,0.8134459337255049,-0.0355053712075786,-0.0366211718064023,-0.008841766756689622,0.004489454414781269,0.07312229333974989,1.3348359947717559,-0.03910295594802876,0.1494400772212953,0.04831363624189568,0.11145937193112478,-1.8813839447298224,0.4404472382597059,0.0349285280961094,0.07882745439160545,0.018696094455809227,-1.1521801584475138,-0.08867557217986667,-1.3822717936256212,0.5145502573983857,0.589448996228118,0.0854007999658451,0.14623190219002313,-0.03576543585583175,-0.49010900679638864,1.858125068231312,0.21870058377606746,1.4236424571633812,-0.15928183828205056,0.33304066706333557,-0.001322891356789041,0.5483849991960386,0.01426829918365467,0.11064518582909055,0.15112153369588055,0.17667751652217462,-0.15777694492316366,-0.008410750151643925,0.18229566233201502,0.4257922211585687,0.14138257388230607,0.15859744250875638,0.12396207806464558,0.2562688185015827,-0.7084922975195909,-3.282811838583757,-0.3236377222774406,0.2423562880996075,0.6094479037478534,0.19996556230302226,-0.020085002510141305,0.26147349055475266,-0.16989375024821618,0.18807892714233274,0.23222885108774638,-0.007826394501979323,0.014669931126491221,0.006592234662505025,0.5133376277711699,0.4575750449233857,0.08419049252665557,0.6298949291081323,0.09854052657298014,-1.2769747095796828,0.03413198338684799,0.028991079997630186,0.014518034113129949,-0.01912461126894798,-0.024051061267015596,0.08518911444935262,0.28519652166774995,0.07751702173609798,0.44792890881878566,0.34543680434582996,0.0851047724444853,0.5354831114331283,0.47574920778978735,0.07119830204678856,0.21616871974316038,0.09742270835617152,0.07375790269541364,0.20963167376053557,4.124245619896015,0.017541019938422164,1.3075739676975637,0.03592654790562655,0.059356027302927,0.3976177042492791,0.6630134541140295,1.517967013915244,-0.25308866949433745,1.1254641694228993,0.06608960925218768,0.09142596622246718,-0.4740889301459541,0.5208788712849904,0.11398164480943596,1.1270267323176748,0.07945718127664951,0.13098916598471028,0.09798165109436663,0.17893371788964235,0.22622580555485475,-0.034768431406157596,-0.16307001568608565,0.45313262755367206,-0.007954984113071155,0.4421414446473268,-0.08577419206976271,0.04998672709242702,0.09187529757504156,0.1819103162062559,0.2719163622279705,0.005870826823836643,0.158579574838003,-9.373379634314398,-0.0984292041216228,0.17543528348463022,0.6615195582040515,0.03274943978793578,-17.956078556153564,0.5316633003347371,0.4545434855925936,0.1959229504112548,-0.12977816663418723,-0.5334988316953904,0.13463637566363995,0.4674244775526324,-0.05812090788199931,-0.02300436295153078,-0.3691933805647021,0.5853692844248103,0.0062439562201592235,-0.6638059935747215,0.42521350600879,0.026729769533669408,0.23701500107950013,0.4732071797347319,-0.0792366016741924,0.39495797637657076,0.026173682868546714,0.42891898305417175,0.02219823975262625,-0.027166296482008072,0.13285814793532544,0.3116115058381108,-0.12051797477126633,0.7483868553639403,-0.35836507911300025,0.31778633099957365,-0.005624913009032377,0.1677128614537103,0.24015793784044331,0.29748672635961676,0.8457529860276758,-0.10650445090207415,0.040946925525305246,-0.09020952509235561,0.11660731510562064,0.30794408254894573,-2.805126919168794,0.22800332732423004,-0.05424563502581453,0.0540746767245412,0.21374976086219696,-0.11546268421090311,0.12650579761985253,-0.022036695492533582,0.2964572037452005,0.34397953244130336,0.08252558304814987,0.17354599973932477,0.04773257543123858,-0.0032039162772925867,-0.018704666618772115,0.05413682446182216,0.5758174182197376,0.12166874874716821,0.14125996529042417,0.74876340947769,0.8702755304536425,0.10318589177839367,0.19955555586404974,0.13792685078873693,0.2940056959142604,0.006363220950958275,0.22236967302253127,-0.4282442989422706,-0.04755943406525756,-0.2929893100554513,0.0053022658963610145,0.6409181538181176,0.41649966363127017,-1.0347012568042675,0.1350428605874817,0.08425510139799146,0.14156097194191797,0.6235488860140193,0.14122459055973804,0.029152608216773828,0.05176862141983261,0.23415147951551313,0.31884260610536536,1.0980358729185136,-0.005837747007486522,0.3089481136663455,1.7749970373479977,0.09406491184606611,-0.16113212546276373,0.8170014436461749,0.5167808161173993,0.25668704150472915,0.6287613309479445,0.05315628131533217,0.021460794213319333,0.0062372059887705784,0.22484386369912512,-0.10390104293436324,-0.04162040719427874,0.12887582776436,0.4203642778250498,-0.1845061190322635,0.23228435697048144,-0.1208416071137636,0.027405640548824453,0.013769220047544103,0.079701102079343,-0.03343336519600872,0.13141372929944595,-0.011342533949054406,0.33352536065426364,0.0021815741236389987,0.4967082902729149,0.017767212823455367,-0.01823681641017742,0.522299544871758,0.07171563662111209,0.07485502950428874,0.6963252897155866,1.1643139122234818,0.04119564784594682,0.8182316975478119,0.3528812078978585,-0.005035139299492989,0.19161061517239217,0.6656330059726291,-0.2999899129590765,0.060788582516354016,-167.50303405521143,0.023757779525194027,0.4542802521891079,-0.054474622391963545,-0.005985866157021535,-0.026184750015869944,-0.9821069825697483,0.05036910603478365,0.2371745817872071,0.9051828273237834,0.008910735340041212,0.06763605372775991,0.05542782907589873,1.6245230795084662,0.3121507233360853,0.4915047803075825,-1.374400438225768,0.34075358107864084,-0.09503759465132863,0.02870101566135374,0.002074430574453687,0.1552815670343441,0.10844015684593936,-0.011072189283002935,-0.014294363174628637,0.04775134661775729,0.21182623258623917,-0.2041400603534943,0.6899251303412778,-0.30646684726378304,1.3638734117461033,0.11174446647174435,0.4293077467784589,0.02328032331686643,0.45138945642441425,0.31600760886951634,-0.10192461400952744,-0.041623821507727844,0.004835485661007967,0.07227791328641309,0.43327766229825765,-0.003533328198193879,-0.08376466242245996,0.07938529852373358,0.014736645622157978,0.21294176364122977,0.17301221483129334,-0.005824581062204091,-0.12762570798340717,-0.2309138094902103,-0.35217421937993937,-0.0024142409331282598,-0.14623561568219084,0.5817504962569375,0.4569657023169381,-0.011009429720301363,0.05505014893987745,0.24786742829887615,0.16028553072628604,0.3160074869611381,-0.08160657617181542,-0.005593200540283513,0.0710543141583063,0.23135599989491662,0.15101119567420593,1.2812838268282738,-0.008195147233637609,0.3007581006814031,0.010474656183749969,-0.15399890036968278,0.05751356901969773,0.2421586483427653,-8.843975893788572,0.5628971579898925,-0.05699572083129141,0.07056142672610304,0.06289077344738346,0.07903120064024165,0.17824130736508237,-0.005422306531638646,0.4462464313415465,0.054988825457212766,-0.7679656190848196,0.3553073637459229,0.296176361485669,0.8096787494959136,-0.03709034712565087,0.35961198989257703,-0.0342454680549034,1.1978403617088251,0.1624841375453142,0.32510788056536666,0.10533688339524543,0.21616997373133925,0.09199692375518975,0.047761533214608465,0.15467801999864697,1.180084689216789,0.6229756944244181,0.20653581531848836,0.03336892822586612,0.03871121229548029,-2.0518482942927068,-0.6212586193544103,0.5457752129726564,0.380112944114114,-0.3280833039849617,0.1332761862122938,0.28434674369955243,0.30152410347804615,-0.0920309902119007,0.07942529258101758,0.05774738831739263,0.0834511748128434,-0.02103400636320164,0.3796096050567808,0.9733037008168124,0.050453753780914386,0.001226635779822993,-0.04272314929353635,0.6676071782552749,0.33089164145252,0.42363998693889654,-0.30064273942703873,-0.20484727558326166,0.48724096008700496,0.5643893470903489,-0.019150855598617685,0.06696028054471459,0.0543258201592727,0.04072414019722307,1.588548049788451,0.46190342058281036,0.6289910518451161,0.006732345938228432,0.20857621963277992,0.03710449196585244,0.21838448064921903,0.030682524005007632,-0.026158598098001275,0.5893546822468958,-0.05654317448754784,-0.13790718792800402,0.9016348936684921,0.33798626868607345,-8.314742995681286,0.08223445150234317,0.12084104148659981 +PGM,0.043937176017445685,0.20365649800872487,0.052653283443622564,0.0721608806640152,0.05253605551154327,0.04127973182521835,0.5029298905319474,0.12743112524184094,0.11132217939329142,0.013728845012736227,-0.10462339600586344,-0.002489852706356543,0.3037283243277244,0.13458200214761185,0.08741260659828853,0.34321344266280407,0.007812779749974177,-0.00073161690543364,0.0241372795930579,0.3265003769681296,0.10592622204793539,0.031912434711514996,-0.10803558278179003,0.06771635353237766,-0.07276965890969293,0.4474157039840013,-0.36857006861112107,0.0021374941929588644,0.09770829789569782,-4.028806936936196,0.10265887382995223,0.05358551587173704,0.5681954980091231,0.04823163371040359,0.37317354137522624,0.11542551705611541,-0.010150149128742014,0.5997200721524815,0.09111542695044271,0.36657195392636355,3.0058529536272887,0.16564105565824555,0.13604571637774382,0.042915328876110985,0.0012144546958406108,0.18239147764911098,-0.2812951732369187,-0.09486869852607642,0.3605533967817515,-0.4666168359882525,0.12669775683109355,0.6286314359728714,0.7405210806545299,0.1831440622447195,0.09388601984360048,0.4205026770556398,0.6967670783203799,-0.2640711905972637,0.5087260872225093,-0.3149361457274595,-0.0489647907306106,0.3405220777043835,0.5808303559056748,0.3403951865273608,0.3664971047023899,0.07000823914450398,0.11023372806290678,0.37864131019528025,0.039767062320967626,-0.7647957214075463,-0.05103439120540689,0.015590572153874556,0.04727830027276464,1.1613391722462252,-0.032034611340276964,0.11733412858306039,-0.026890083631944416,0.1736181582016407,-0.0369200374176414,0.14921974278816366,0.011725430443245179,0.29045514104299924,0.17440052867311948,0.4100473374819076,0.046464017418070436,0.15715436618371165,0.5046748108337406,0.3586783680987936,0.3749929062542841,0.05949223176356048,0.41942536579012,0.008963563374270253,0.16010145136574697,0.05174124360983751,0.08485094821561795,1.321397020962504,0.19649783655366862,9.681547199891664e-05,-0.0656991696124829,0.028873873417475396,0.11393406301152759,-0.01773929921373257,0.13702624013295328,0.19068837741354422,-0.003317906801598044,0.11917686085232025,0.033187129353205974,0.3937853437441153,0.01932344754016263,0.07981461577196024,-0.23179347780058696,-0.19806066500058675,0.38904001523519494,0.09680342428367412,0.12379197937598888,-5.008604705911538,0.057581790935036826,-0.15529228515102791,0.20514685278768194,0.16621772473629204,0.9466233937424197,0.08511617809932229,1.4640324441446921,0.13990669958864388,0.0887462905603546,0.16086417931244598,0.15065053175017257,0.16905758845372534,0.9478450473375462,-0.22083065173064773,0.13146670294209,0.07985415343086541,0.9247469769371252,0.1867593117328489,0.29000395492845904,0.07577370266402063,-0.38967518212316543,-0.012335096385933055,0.1614169954209466,0.1764601788115844,0.05051062936090216,0.1531598317794847,-0.016913516701611963,0.0626542866736976,0.24622005856121956,0.534266434596329,0.37303927106684115,0.11958514268594989,0.5865495169072681,3.6307263676194177,-0.2882066124874938,0.09528301539540765,0.06638301472226266,0.003479457713374507,0.11684453617708768,0.024147183651218616,-0.11194379320428081,1.1315118472039858,0.36481125666566216,0.7077067285166209,0.4117663710687321,0.39518494874617766,-0.020337416314781653,0.04767303185863748,-0.03776781788073563,0.1161631845117397,0.22004889701740016,1.113842288819068,0.26367169838826365,0.04355870654515788,1.1350929994096806,0.4808073876265674,0.6823651779654525,0.4673767328092333,0.023618174170373152,0.5939048500349327,0.0789373760731072,0.281604039614139,0.06141468380126895,0.024168196774418265,0.0703056973126741,0.20806566040027902,0.04730624737779716,0.05959004243527721,0.22521463067029496,0.22410446504061807,-0.03349669324760966,0.02162798657788194,-0.4454319846019835,0.25686945981588205,0.5031511887503874,0.08811283303870364,0.06526651401113663,-0.5791852109879232,-0.17485137699945033,0.3028808807325008,0.35647596793573577,-0.012301572114369313,0.11386929644917565,0.3156636412458583,0.06346214731638354,0.014260976202732643,-0.1111615249782535,-0.11537029793089427,0.05877083331928918,0.0591648943879324,0.01565226790424308,0.3370236936505998,0.0799917556034084,-0.27535081809506384,0.7938611321998413,0.01343701428665807,-0.1638584470515437,0.34056582648674627,0.2221210918394306,0.26757581075255177,0.21633431894720426,0.7274812839128141,0.03478691627559492,11.108983989407411,0.42429803706845903,0.17692545922352548,-0.02079548389308797,0.060592328211532084,-15.328945761795438,0.006765803156003112,0.2081271004912108,-0.11134682137760542,1.0850365017205652,0.0770885899108964,1.031016625310992,0.003225073603318844,0.13492976065389853,0.2168663213000206,0.40706280515245374,0.021388770311426282,0.5497981136613426,0.29538192279496883,0.2885518037379227,0.414454812046523,0.3084280666465287,0.020055201127784153,-0.01205949102240247,0.22235725880683704,0.21927757421333616,-0.08770250154483798,0.4698450049951797,0.2181098046936624,0.3639833700902923,0.00036078189592316266,0.37544338485192563,-0.05152262299607852,0.027127071253544632,0.3341403498666866,0.19475457400915466,0.16712817333286906,0.2475386250021226,0.08563920250743262,0.02197773046088107,0.22973553907959057,0.2768937150635522,0.3879582335771652,0.05890944113183072,0.01753591803484405,-1.4598063393599243,0.2935618446204437,0.14367965315305925,0.36411651949112966,-0.0012320336762137044,1.0266701251043708,0.04618382799470843,-0.27950382840060695,0.09250965582044238,0.018027617693411973,0.09038163025627066,0.13737954484264459,0.14750192805469498,0.12799701159871554,-0.2461385030611325,0.1244682763325239,-0.011324828888189885,0.2746435498906141,-0.01907653585191788,0.04056749110655012,0.24470270557851878,-0.10808332161411907,0.025902432691514408,0.17229256603124068,0.023743295515921956,0.30022269928268347,0.16722688955024784,1.7132410501131872,0.29501018605693485,1.4463704252217027,0.3062984628601941,0.5110803323850002,-0.33174990951582906,1.1654255674686116,0.027928269908696988,0.027643371604277583,0.11727067373955766,0.0371642608009069,0.2528823133253908,0.047732324519187685,-0.007474746225489267,0.13279714278969762,0.16738285509125544,-0.025529717823087588,0.46090486503991834,0.08830967786420851,0.004514921551247208,0.09172451223648768,1.3356604629243114,0.037161822796245296,0.03814790223851346,0.07623864354933654,0.13115143135810986,0.15343469216782968,0.3370564408174213,0.5141575793767821,0.08407178434760443,0.2726895065476322,0.8421488541397661,0.051259971324264485,0.12494697854365147,1.463387005434521,0.005324821298545036,0.015731665041098797,0.1021529063954119,0.18423589102971477,0.27484230005456023,-0.03720851800982301,0.024945744125622275,-0.056728598239626844,0.058182902356009106,-0.018323230174035813,-0.030380842080031552,0.313001174632983,0.35468930302474977,0.048332736912531295,-0.01978073649019987,0.28146732266305474,0.07977271451177508,-0.0025379099835043492,0.47895547673651523,0.04311685941615055,-1.9807330490496298,0.6706683223772284,0.22488493810773577,0.03586267059291814,0.7802764750425367,0.4532269228337708,45.238345760415065,0.031918376628058305,0.008041933157738126,0.416156118209975,0.08892636433303865,-0.08581389410845562,4.644082654732361,0.12851910321307336,-0.33366927672682867,-0.09798201241106079,0.01348418849202119,0.11006186098416292,0.041911831411566465,-0.01952348076244668,-0.03544023664403542,0.04596214864248961,2.3868826080943397,0.028051779232194915,0.40766250828858114,0.7792293829527785,0.3170205528208071,0.2358324601493753,0.1456155747103628,0.4371230559452567,0.5489578235412822,0.1032865951399862,0.048632911198065724,0.07074678406358749,-0.44658088536881746,0.8126584508648196,0.0034513575880454573,0.23743514986062156,0.09389164503353557,-0.04562233537602618,0.15024377775036968,0.37371154127577033,0.08756182346702972,-0.0018143530695877296,0.1893707996116297,0.0053860338968066525,0.0526750884639774,0.018382740767073517,0.1178495909199838,-0.022151796091859025,0.2397460229740223,0.19853637142034317,0.11349333649274752,0.2779732891206513,0.7442035299919495,0.012108096319969465,1.777854241930646,0.21348098213334152,0.27903772537979205,-0.10143359127006213,0.08539248542398303,0.32592219244413895,0.24200985166349293,0.2984328615510839,0.05206480427229552,0.13508959892489192,0.4167506231066192,0.20849929876531495,0.14259045400556886,0.05246801349853556,0.2557805182687829,0.0962032431226631,0.14079569990755694,0.2380752172314626,-0.01495733969968604,0.4051452547675224,0.4659718109134605,-0.03134673268305406,-1.181053080748785,-0.012473187999375083,0.03874324157162774,-0.2948112256756084,0.10017531085292403,0.3500520168241688,0.33056929803830015,0.10394669948616102,-0.10682235883735136,0.14671533678546722,0.09938275871703188,0.1242765631676672,0.08572567245520389,4.4674402208987544e-05,0.026386194383140337,0.08190403180910497,0.18324876242874547,-0.02928693900456511,-0.08130100510619605,0.3601541665083302,0.056084800351226385,0.017230496712417567,0.07353783287676559,0.24341543810943067,0.06329947522657588,-0.02906152215051016,0.1039523786626838,0.3305301112541068,0.009195922116718708,0.19397965138903545,4.768893023365342,0.318254126503703,0.09136496952192272,-0.09625037034549262,0.14802490058943776,0.11604793403854635,-0.09110624882690148,-0.013978245534500175,0.1000076131309507,0.1653351817951499,0.17878190742274525,0.3120933711400384,-0.001605201928420654,0.1707005989618653,-0.33474737014367184,1.1847262606861249,0.09378791356141943,0.03705396117629252,-0.03902546549771773,0.16413911141473556,0.17395453314574583,0.541906055148125,-0.12031959775347734,0.11025042568380942,0.2436119317220172,0.4061688575631666,0.1778459455490078,0.19613938714636792,-0.01753977943222018,-0.43018909401246136,0.1533644498329211,-0.028844017202298268,0.23255795772502535,0.10894616652615924,0.015118807768087003,0.2698587461363624,0.19504966243030689,1.1622119394327868,0.01397307695155391,0.21917780376579044,-0.22015309856654736,-0.09748302256304546,0.07457288473376766,2.8102692140366923,-0.03195307345513604,0.36307639971863925 +PK,-0.002673835645199892,0.21986333243604964,-0.13785291171259073,0.08607174933135339,0.04105337976287943,0.22118321390306733,0.18316979230796032,0.27196874216636524,0.1415442051629718,0.3993471554578024,0.21639806227915476,0.25544390615972185,0.40225521998853775,0.15875824277938763,0.16733965978061957,-0.1663094448082094,0.28729766342348456,0.1633905297137981,0.07059821293213454,0.0396975771821873,0.07517106676971717,0.10379120006499905,0.1451269087220804,-0.014936601554511302,-0.09764776323681959,0.22659031394435966,0.5175650578655355,0.18559204016190178,0.3355830145148792,1.3659875692187275,0.29511119926561064,0.3539623989161244,-0.059344901861750905,0.5066879184808596,1.0506030269375812,0.04866492061668392,0.39610965774020346,0.07123733147521628,0.19611913127178923,-0.01845785157599916,-1.8889423987136782,0.0768922650948473,0.314732117786703,0.28061253457864327,0.23794133947289045,0.04783370032720873,0.12399811288411869,0.4037196387385877,0.08676673486386711,0.04721214499518085,0.042061238122592604,0.023979499788547378,0.15775491980439152,0.043622485642838854,0.06558223878095677,0.09849287177957859,0.06982209124436761,0.36207737708393384,0.089560618604164,0.3098223382032812,0.00653686915332111,0.027651805101635743,0.011291414025650188,-0.010428805005773773,0.12561133917412362,0.1051825868537756,0.16052459175707598,0.13367061492066476,-0.06602882798343607,1.458362185350751,0.026587583343748673,0.20263150672123967,0.11306232177696,0.10301434183467417,-0.001497866531977128,0.015475068252074979,-0.19996185158832977,0.13615091684467998,0.13123500691564352,0.24539165334408036,0.10174691725932868,-0.26071241716216975,0.2899595783886021,0.009968757528240436,0.18299956571236273,0.00011131681475488426,-0.422776959486704,0.03153751693689423,-0.09859750501751242,0.19093441265803787,0.24162936394578025,0.2957884096714975,0.07806858208511638,0.2181134641883804,0.09751266500244903,-0.25749270199435065,0.21356877267837224,0.3062277328858779,0.16659447802679514,-0.017356728081709242,0.13246183086958813,0.2583470606671338,0.4130057299470448,0.13826028289012782,0.01434110520754932,0.1783439070605783,0.056986492233690164,0.045835006423968844,0.48130695831397835,0.16904196142929784,0.052559398347475146,-0.022742255750763125,0.06833970218604539,0.8642104701514706,0.21236027998590865,0.4650897337086781,0.3441444551966058,0.05231740843299999,0.21131888859046333,0.058873460025061365,0.07132289640533182,0.03953474324749515,-0.15735667969864925,0.0604991279707623,0.07721521787215263,0.030326055373139774,0.2212884001588855,-0.07577576101705556,-0.14092940268221027,-0.40294131815208056,0.16651547725996185,-0.5488564495606912,0.0804469874807109,0.13594756930403254,0.00981756129378591,0.07368178532652778,0.3155251355358949,0.5074928215769046,0.2324391063487526,0.16765486589258577,-0.11057527261278939,0.0475722345466732,0.45666483253083806,0.15951928354375872,0.025723557397821343,0.0626251271949777,0.05282908964238827,0.2385949906708038,-0.01152872421075778,-1.2102070436958596,-0.21165827142520777,0.4614596944662387,0.16489513064589528,0.39659839927293733,0.08696927959744388,0.38644667256908166,-0.15913524815933858,-0.1554059321544322,0.03454816583233032,-0.0030815709776807402,0.00862087118875636,0.15918407248622085,0.20838851837901695,0.1755205399845173,0.047797515317228395,0.06935662595794331,-0.009916249134950872,-1.0947933275788377,0.18999669670185793,0.15660991594639945,0.020059162904160183,0.005899125793852462,-0.06766795906048559,0.015982629372823146,0.05392195161147233,-0.05425078243470543,0.35590749086736684,0.04102648556929052,0.22777837905644213,0.036206707466055255,-0.05376697183080631,0.18252140502083464,0.45327817075568994,0.18470464619386712,0.11634069323276147,0.09981314773820345,-0.45962135095099593,0.39906269552958995,0.568246423946782,-0.008103540559966134,0.12037267270207064,0.14762824539635955,0.032455432074408916,0.1717922216670033,-0.017546400304413876,-0.07448695805221464,0.10448869227847936,0.08282799836208651,0.08004930007177688,0.28814594704307944,0.19162773236373604,-0.032642704499486495,0.10850472420650296,0.24203814868965604,0.026788736909498363,0.03475892948955317,0.27018131136783907,0.21506439025568302,-0.029981564244546507,0.058747406167400616,0.19266130447858398,0.14345332849926393,0.2430778239095165,0.047914774327172,0.16749672444947458,0.1423914504418475,0.07416741453628042,-0.004508610195725449,0.10922408531418339,-1.0714388244764952,-0.026710199772679865,0.23750889620240512,0.10607358589030438,0.3129108446994118,-6.617902230168116,0.22517235371415728,0.15441176394789047,0.09817822477157269,-0.34378189762200695,-0.3959198085475382,0.08957064272135229,-0.06920988838419728,0.3186042995982464,0.056909321841498925,-0.11003527042644791,0.23884038955296422,-0.004986238256579422,0.10592677981891228,0.09236263256491628,0.08156329923758113,0.0812012906152935,0.3624410238300142,0.2449936510219928,0.013275770842427714,0.11943506464753663,0.61819026882337,-0.015882431832163223,-0.05106892110765286,0.030678289268724613,0.17247541985440132,-0.3660848137556944,0.14663299814668962,0.9169996500036028,0.10387581627590659,-0.01136170043872436,0.36104741451213307,0.006454117426941907,0.02489259563133261,0.09625672841535052,0.17712498189909293,0.10712750050774618,-0.023814091945357503,0.15351103020670204,0.4330219200683666,-1.1315947178508072,0.050645158116265694,0.118429945692164,0.10691400421988748,0.16850355056938174,-0.212729373947356,0.33836602070606836,-0.032034412822785796,0.27662478561506537,0.12586852829200312,0.19435013117102448,0.760054155470055,0.261058589042296,0.11998277291335455,0.24342642175906637,0.44758744673654294,0.6079333606890523,0.08862147231265198,0.6366277006039545,0.09113171445017959,-0.15346516807544255,0.2437361561948666,0.06357108139434695,0.24390878117576675,0.16385997208729255,0.08847767700535837,0.09398203297689006,0.022516693294760255,0.038010962241133886,0.0424396918008659,0.22484649689561714,0.3446577590899232,0.3644686304044094,-1.4315930118726599,0.26490409310016666,0.1935880220463404,0.15081573554883043,0.21808251357746758,0.33613690691466985,0.09934630690392879,0.29889278929426105,0.055969777805157786,0.011516577972887807,-0.040222470283208626,0.14212789835568312,0.02581001429569767,-0.12974677164613385,0.37875372003030694,0.05060671148945361,0.027897984179766834,0.12258412497627016,0.1591459018161546,-0.02474974083977911,0.08964305176877431,0.005771139032191952,0.05230812916974453,-0.06442971800149777,0.2346683105168621,-0.04552561181153922,0.024860217378401762,0.21524935521100197,-0.11178422258451556,0.3112128198587844,0.4182818908382455,0.38226827897174104,-0.03178115239060185,0.01976530254255075,0.42541520543041905,0.3618233312883523,0.2817303550048404,0.21529712472014836,0.1172094214406052,0.05659890554666111,0.0407450672510724,0.01873450088123919,0.1522922141894523,0.4070576898371995,0.26786362870723773,0.08656274435394735,-0.2830402099401543,0.018471399591655047,0.04075201987991006,1.5238455600500038,0.04611564210446949,0.07945187776212745,0.010049410333032568,-0.069299053323584,0.16249071700054743,-6.604627251218978,0.07898016650906678,0.21549391299589396,0.22282451032013206,0.06858423911128787,-0.1665294708856721,-2.750487428176393,0.04524877844170144,0.07219894059105976,0.3445140834376133,0.04627375838380585,0.08633008252275055,0.12104192109349167,-0.24517171462316895,0.2266972979747183,0.22364339489235008,0.00237473371120904,0.06053818505041949,0.034364717300318696,0.12858352360083727,0.06678482091030374,0.02777377048780976,0.22308447568663858,0.03483324559080984,0.026823651619233856,0.11867421866191316,0.21561967052420203,0.16533499867822052,-0.11312241646864755,-0.13903792653089997,-0.09146697974026934,0.024889500272325043,0.15858980100599288,0.30969627412439177,0.2555021973240066,0.06894298109072561,-0.004697203079507496,0.2656174957326865,0.05935191570842573,0.12301329325917013,0.12497514060837496,0.15018603322212612,0.5143807253100057,0.31338892840342086,0.09236560739874478,0.04182480641935713,0.15850796817204726,0.030230301747844683,-0.017028133848568383,-0.1513210161047888,-0.16212357430557298,0.24211889174410423,-0.16718139372719545,0.18515309808835606,0.023104647202470706,0.0863854911846264,0.09490582484334983,0.02191839700236327,0.13252315621832708,0.1742433060961922,0.04271017387523693,-0.022031970136266996,0.2343367059863846,0.26315572789787356,0.3600641329775312,-0.05870859756480095,0.20094324876898587,0.4608593393805346,0.14646973994438442,0.009929285229192054,0.0485179482681426,0.21823776165309372,-6.823212665634919,0.1472907235898813,-0.02567775354675989,0.030341349742443954,0.15420851564579424,0.13289754053994685,0.027277592531293474,0.3678313629378035,0.3166904836767957,0.11797701006795097,0.19112109944737501,0.1036498790269621,0.1623789180870578,0.03607648722929153,0.05320320247851565,0.38955465017199636,0.018593310391898935,-0.015680365344396645,0.18717706291754382,0.17336095593087136,0.11417663597884482,0.23571884847819474,0.19613217065220812,0.15327129765224945,0.2623091005666787,-0.11737110708784582,0.10216571364883231,0.10044703967003647,0.06140184390115142,-0.009686252430390457,-0.5184555186258639,-0.877965065074082,0.0969224521805165,0.15269499388875868,-0.08377079573549023,0.14471141310223046,0.28423022861932995,0.03852624224310793,-0.20756592890659217,0.10241786340841552,0.10357024594206178,0.14686096069451413,0.06527721667337047,0.06491366453605649,0.34709056756212764,-0.15045379284337687,0.2227331178291099,0.0021503491913703408,0.18221330271969793,0.219922167223084,0.14950371182142727,-0.06230589437163091,-0.0961416766094202,0.24574969239438701,-0.016089437707195942,0.01864006169107477,0.30822180361988843,0.09300098010775495,0.197484136206925,0.05973713080902437,0.07089480953905276,0.8031111307190443,0.13170593378095743,0.030098520330004073,0.09966169441168703,0.04316954439222412,0.046999788414870736,-0.4946975431278107,0.6831362616132621,0.23311240368461864,-0.2846141834510921,-0.019109811415130268,0.43291033797927037,-2.0359407892928756,0.007849612950121612,0.07249164264055695 +SK_adp_c,0.9570304847265171,0.33977813744308566,-0.6461032381720652,0.1916543540632195,-0.7160738448079375,0.1814444118423332,-1.6585191940404655,0.16231443611148752,0.0037524641677596096,0.24491617956432102,0.5164312554235875,-0.04909973434565278,0.05652779637739214,0.6754333085016243,0.6078228344031358,-0.3928344330244471,0.386572259171527,0.053612016885498937,0.3979394239708406,0.09422228355237983,0.20109018875203352,0.41547671977826894,0.6259082438338421,1.3024579652739074,-0.11085269778628105,0.08573485979034409,0.274921392968322,0.07253719513780711,0.25141817677243766,7.5591981561443715,0.09352891461632462,0.13727458839909068,-0.04444433493280138,0.18859731121264373,0.8827635536230021,0.13257287090096262,0.13636174847715207,0.030966868302822827,0.40466945773072255,0.02738827027003082,-0.06712705599618186,0.09071357492456326,0.23497788125586158,0.1601697611646531,0.190226304622232,0.26707577307451696,1.1372311078782835,0.1863672709010348,0.12105214860835904,1.0723652214965715,0.29489774451726997,-0.0014110226147407898,-2.0329146701641814,0.05356899280827299,0.3948045789144022,0.014276593601732312,-0.4232824340349759,0.2289231349088465,0.006251575304191023,0.7082266336288355,1.0052554723269749,0.02104294496658432,0.1946116324352813,0.0018116889209784442,0.3524634897741914,0.3887576586543927,0.37403030455104613,0.6716327511209462,0.9027197684584037,0.5555120467900434,0.3446846739409392,0.5734175584217377,0.024268774073957302,1.094186022134958,1.1880544595705433,0.7558007703873666,1.1957928325392877,-0.06246548923261838,-0.04115961202311782,0.248782228370007,0.16121512803235355,-0.08577643906603809,0.08710166640123042,0.07070509782150823,0.1451423194365721,0.5848708337457571,-1.3689563908463773,-0.02674320697014743,-0.024035974618364753,0.4699514331064451,0.09970923149576147,0.14218402732830923,0.005175727678320759,0.48330412531273925,0.09026631748557934,-0.7766940227652593,0.2166441648139063,0.48186289885318767,0.6232742901506605,-0.04993999226080205,0.5485934433362173,-0.019481188452200808,0.11432940968639584,0.05243403108461645,0.11185067461800226,0.13608871615397397,0.8933050731586002,0.096341417256887,0.4149726261491019,0.28705638693402585,-0.11027202081134291,1.8948310559748303,0.056440858555595476,0.9177190407932189,0.13884079007854494,16.112021173787365,0.07956015772313407,1.0238871959826032,0.09389214252063373,0.012389447839216928,0.026391697965709615,0.2105267556288915,-0.04717564328125318,0.0837315272635987,0.14109068678709868,0.04805517046802615,0.08407142792632968,0.307007436225738,-0.4058123674395674,-0.47402512081842546,0.009849095806549309,0.007806700016916519,0.5403260985950277,0.18346642145603004,-0.0045102817434396255,0.11119343171520439,1.2861716986221294,0.3596694811907527,0.22414404653172315,0.11247971467196599,-0.11181645218201032,-0.044965409221879395,0.31231655418690113,0.2164936720878831,0.07608833582344612,0.03294265702182279,0.09374590849580464,0.046543727302788114,0.6980756548396883,-0.015713801604709376,0.0951816652578084,-0.04470410622489323,0.01753208368095816,0.39266553953674166,0.033378369725959575,0.26216224493321094,1.7200542614219219,-0.8194586257584994,0.04452341565999429,-0.16439869544085756,-0.15051680286840974,0.3037519844710329,0.16601261936249384,0.28942144774612044,1.2374359883379602,0.11140230669995824,0.5652219530583372,-0.8745408921021772,0.378892864469628,0.26018901814429307,-1.1614350709300467,-0.03918964499417813,0.07523955919702276,0.024923373353040106,0.2920731209437836,0.006818899640126407,0.1675254168551492,0.07901957424236451,0.6625346770830954,0.21711327484773496,0.4596827952913141,-0.000906246521190872,0.1731034814046682,0.4623747973422318,0.09059905341215126,0.06728012003351383,-2.0560359711156555,0.5764505553519754,-0.053372465196751345,0.006710058657591553,0.05350647937945434,0.07931346688983743,0.04214009321449617,0.9152156102848213,0.14821515969037838,-0.4785270839421369,0.010495921323700724,0.08978527475285802,0.18177936593844193,-0.33057347416624444,0.4613812154965275,-0.0749126304166037,0.3054636901525801,0.9782063275040178,0.11292580497683317,0.3664345615694643,0.4218759582759279,0.14914419649263727,1.0536194715431475,1.0559692076547973,-0.24983037538747832,0.23125611978350807,0.0633763523971974,0.0210278669568951,0.07646611279050769,0.017772593084908545,0.05579506883932838,-0.034271126852879856,0.6264549212911482,-2.4543619432155204,0.5920737304691743,0.1367745350683926,0.18588458304084887,0.049922114504314774,-27.375268100931933,0.20280338280662852,-0.007778840739316259,0.0910356269496432,-0.40148836802204296,1.1160803348188584,-0.03525173035589533,0.67742240824755,0.06423242910541319,0.11020375191155568,0.5865024481832596,0.15579871827016653,-0.14441449988307306,0.12519655052166484,0.05324536377389078,0.10036412807897095,0.06352378537234418,0.15906631189323348,0.6019508921763358,-0.023133496493453674,0.08298094036594197,0.3483411671745897,0.07855200204064892,-0.08383434273301879,0.007992043857847715,0.46488190750894026,-0.5226497961649014,0.02973433993479618,0.0977540332821631,0.1582863836291273,0.005157265935144891,0.13528548962665057,0.0769058907537121,0.007682121505419368,-0.009575613633255991,0.49646283543630826,0.06019533443550127,-0.01429334458604536,0.2792916629483573,0.06080696376870959,10.601176872463219,-0.12178160570981166,0.056901219901945535,0.05211174496113426,0.6299068215193355,-0.4331126398932666,0.34664107921437554,2.0413185537146337,0.10569111312614882,0.4302913193772017,0.285580919747147,1.1031660450765561,-0.08096129723444735,-0.057239876735028575,-0.846246952018206,0.28333921016959907,0.04281785133002607,0.009948507362865055,0.0811299651587012,0.0887286043220749,-0.38078914794315166,0.07785311398606026,0.02322361785457871,0.10779145508828968,0.1579934496655954,0.016325680654405806,0.349654323458157,-0.08194699013269686,-0.04965045165476117,-1.845529243725912,0.03367366050858435,0.31867911790939607,0.4193494078698926,-0.7415317019485922,-0.0755813403515315,0.500678054694844,0.3471721455852412,-0.11425206938332502,0.0860859908278739,0.6924447445415266,0.5734554808174147,0.09301055824564944,0.004022023167705632,-0.03555481784456483,0.004262153884334706,0.053581639927762506,-0.11867919823834105,0.09971012826918793,-1.1511744599718694,0.039444119186627144,0.2745964429239189,-0.5279013698748785,-0.03164867470674281,0.262725291720358,0.01306904938232374,0.02362845334406993,-0.6803193153085122,0.4125500637734446,-0.029997718870554118,0.23179301533878077,0.07956696356916149,-0.7082195975805412,0.0675302873774401,0.6499576233487298,0.22319373273840448,-0.025922288353536545,0.023523082904299168,0.6473900752342684,0.36861573171908724,0.4438273792459462,0.32888921829991363,0.24518884393953774,0.6299000453564121,0.05344302192461244,0.011221675162892143,0.4060115364183462,0.092126831873511,0.19292073203690882,0.07107887135054505,0.33252450027678276,-0.09358189868035324,-0.010978506409081462,3.172682444318171,0.1082259889269003,0.09465038761701881,0.1835811780517166,-0.03452537955669322,0.14052745606403738,-17.922430095623387,0.7703759384136757,-0.00337888873126117,-1.9523271396699322,0.01950317395636293,1.3331722973348843,-5.400581468840945,0.6024843198227514,1.0526000769419381,0.5890113845560709,0.8931015494553313,0.5627677811246268,0.13966809202607702,-0.151606140787194,0.7615512540553143,0.027165077866297144,-0.0004163321894232009,0.13780442787164085,-0.3350188781241066,-0.11407341635185975,0.28901624456927927,0.02478873919725403,0.3975227611082359,-0.03616857253108214,-0.027967676655123692,-0.16530496107814888,0.4014754493987796,0.2819226078883891,-0.14627037065729565,-0.21138153193014578,-0.17433708818050253,0.4740325729858534,0.1162259733503743,0.2119429450742672,-0.05015201440476379,0.0063838889545936766,-0.04381049613271372,0.3245189814352348,-5.98830919183321e-05,0.04180676492046542,0.1524446851931098,0.43265271432136604,0.394020293138307,0.7787656302308845,0.13060391973212665,0.04583642542001723,0.3585652083534985,0.3660683371159089,-0.15711035381419677,1.5306524748983985,-0.21484086424993992,0.05216336113007723,0.115581592414106,0.18361268957961704,0.0019043212396650999,0.27026000764017355,0.08945633085367628,0.07269151929407415,0.3902322005368193,0.10688490038903475,-0.004722157126685239,-0.03308457212662685,0.3015581356642731,0.02996281257699429,-0.07483425453858383,-0.43094618507074717,0.14839697949510905,-0.8018933628558053,0.8193087285150178,0.016403214500420687,0.009335857142465502,0.4980334729804405,-17.240391398400526,0.2524801576546181,-0.07513631048751682,0.4261820509617585,0.17171125398731327,0.09414827581456123,-0.02765955808311076,0.37059580255901026,0.20096564922910437,0.4968961879644658,0.10009870198214812,0.03230682029208216,0.06622248558754243,0.20385586186169868,0.527432907506277,0.008198038595002191,-0.028125579353690814,-0.01876091511874618,0.5639834581802103,0.09160479320880748,0.21729477802170824,0.28127128733189627,0.024029536649403844,0.22582965766939084,0.24040569743330195,0.10665920865470457,0.010252249592802987,0.060915793545500176,0.8706819534856669,0.14020485221104395,-0.6311346045060107,-0.4294999336858552,0.0567722432146252,0.004208122890887915,-0.039954570362676606,0.27415853187839995,0.5140013878991464,0.5173763893982691,1.0038210364817508,0.2775623833917795,0.044914594661765145,0.09270783930736905,0.9152555736809331,0.14902714684340765,0.3938266086889896,0.0722783443510278,0.2377296793056695,0.9280437314977008,0.27741230450412946,0.11044158811813923,0.010356166556460307,-0.28706687370019185,1.5230561348340799,0.15660780897634566,0.12132179175209075,0.013552635281603102,0.02626425162285281,0.19890419447339655,1.0626019359990784,0.5967068851195853,0.07736683325721491,-0.05876581020207383,0.32338608246667394,0.0641577160291315,0.7140265452179594,0.023976563216698915,-0.1474195527539311,-1.731377682243748,0.42145181237129326,-0.02900774797216171,1.8433282358999281,0.22073916706363436,-1.531122373558799,-15.267715199369926,0.05911031727112501,0.06955903286726269 diff --git a/tests/test_priorpredictive.py b/tests/test_priorpredictive.py index 6004227..47e7ba6 100644 --- a/tests/test_priorpredictive.py +++ b/tests/test_priorpredictive.py @@ -9,7 +9,7 @@ @pytest.fixture(scope="module") def wu2004_bmca_obj(): wu2004_paths = { - "model_path": "tests/test_models/wu2004_model.sbml", + "model_path": "tests/test_models/wu2004_model.json", "reference_state": None, } bmca_obj = emll.bmca.BMCA( @@ -19,7 +19,10 @@ def wu2004_bmca_obj(): return bmca_obj -# def test_elasticity_matrix(wu2004_bmca_obj): +# def test_build_unconditional_pymc_model(wu2004_bmca_obj): + +#def test_sample_prior_predictive(pymc_model) + def test_priorpredictive(wu2004_bmca_obj):