diff --git a/.gitignore b/.gitignore
index f253f6ea..2e738752 100644
--- a/.gitignore
+++ b/.gitignore
@@ -7,4 +7,4 @@ dingo.egg-info
 volestipy.cpp
 volestipy.egg-info
 *.npy
-
+.ipynb_checkpoints/
diff --git a/dingo/CommunityMetabolicNetwork.py b/dingo/CommunityMetabolicNetwork.py
new file mode 100644
index 00000000..9738b0c7
--- /dev/null
+++ b/dingo/CommunityMetabolicNetwork.py
@@ -0,0 +1,219 @@
+# dingo : a python library for metabolic networks sampling and analysis
+# dingo is part of GeomScale project
+
+# Copyright (c) 2021 Apostolos Chalkis
+# Copyright (c) 2021 Haris Zafeiropoulos
+
+# Licensed under GNU LGPL.3, see LICENCE file
+
+import numpy as np
+import sys, os
+from dingo.loading_models import read_json_file, read_mat_file, get_model_list
+from dingo.fva import slow_fva
+from dingo.fba import slow_fba
+
+try:
+    import gurobipy
+    from dingo.gurobi_based_implementations import fast_fba, fast_fva, fast_inner_ball
+except ImportError as e:
+    pass
+
+class CommunityMetabolicNetwork():
+
+    # This implementation works only for communities of 2 models 
+    # Once our method is validated, we will move on to implement it for more 
+
+    def __init__(self, comm_tuple_args):
+
+        self._comm_parameters = {}
+        self._comm_parameters["opt_percentage"]   = 100
+        self._comm_parameters["distribution"]     = "uniform"
+        self._comm_parameters["nullspace_method"] = "sparseQR"
+
+        try:
+            import gurobipy
+
+            self._comm_parameters["fast_computations"] = True
+        except ImportError as e:
+            self._comm_parameters["fast_computations"] = False
+
+        if len(comm_tuple_args) != 8:
+            raise Exception(
+                "An unknown input format given to initialize a metabolic network object."
+            )
+
+        self._comm_lb               = comm_tuple_args[0]
+        self._comm_ub               = comm_tuple_args[1]
+        self._comm_S                = comm_tuple_args[2]
+        self._comm_metabolites      = comm_tuple_args[3]
+        self._comm_reactions        = comm_tuple_args[4]
+        self._comm_biomass_index    = comm_tuple_args[5]
+        self._comm_biomass_function = comm_tuple_args[6]
+        self._modelList        = comm_tuple_args[7]
+
+        try:
+            if (
+                self._comm_lb.size                  != self._comm_ub.size
+                or self._comm_lb.size               != self._comm_S.shape[1]
+                or len(self._comm_metabolites)      != self._comm_S.shape[0]
+                or len(self._comm_reactions)        != self._comm_S.shape[1]
+                or self._comm_biomass_function.size != self._comm_S.shape[1]
+                or (self._comm_biomass_index < 0)
+                or (self._comm_biomass_index > self._comm_biomass_function.size)
+            ):
+                raise Exception(
+                    "Wrong tuple format given to initialize a metabolic network object."
+                )
+        except LookupError as error:
+            raise error.with_traceback(sys.exc_info()[2])
+
+
+    @classmethod
+    def buildModelList(cls, directory, format_type):
+        comm_tuple_args = get_model_list(directory, format_type)
+        return cls(comm_tuple_args)
+
+    def fva(self):
+        """A member function to apply the FVA method on the community metabolic network."""
+
+        if self._comm_parameters["fast_computations"]:
+            return fast_fva(
+                self._comm_lb,
+                self._comm_ub,
+                self._comm_S,
+                self._comm_biomass_function,
+                self._comm_parameters["opt_percentage"],
+            )
+        else:
+            return slow_fva(
+                self._comm_lb,
+                self._comm_ub,
+                self._comm_S,
+                self._comm_biomass_function,
+                self._comm_parameters["opt_percentage"],
+            )
+
+    def max_community_growth_rate(self):
+        """A member function to apply the FBA method on the growth rate of the community metabolic network.
+        Based on the micom concept for modeling a microbial community."""
+
+        if self._comm_parameters["fast_computations"]:
+            return fast_fba(self._comm_lb, self._comm_ub, self._S, self._comm_biomass_function)
+        else:
+            return slow_fba(self._comm_lb, self._comm_ub, self._S, self._comm_biomass_function)
+
+    @property
+    def modelList(self):
+        return self._modelList
+
+    @property
+    def lb(self):
+        return self._comm_lb
+
+    @property
+    def ub(self):
+        return self._comm_ub
+
+    @property
+    def S(self):
+        return self._comm_S
+
+    @property
+    def metabolites(self):
+        return self._comm_metabolites
+
+    @property
+    def reactions(self):
+        return self._comm_reactions
+
+    @property
+    def biomass_index(self):
+        return self._comm_biomass_index
+
+    @property
+    def biomass_function(self):
+        return self._comm_biomass_function
+
+    @property
+    def parameters(self):
+        return self._comm_parameters
+
+    @property
+    def get_as_tuple(self):
+        return (
+            self._comm_lb,
+            self._comm_ub,
+            self._comm_S,
+            self._comm_metabolites,
+            self._comm_reactions,
+            self._comm_biomass_index,
+            self._comm_biomass_function,
+        )
+
+    def num_of_reactions(self):
+        return len(self._comm_reactions)
+
+    def num_of_metabolites(self):
+        return len(self._comm_metabolites)
+
+    @lb.setter
+    def lb(self, value):
+        self._comm_lb = value
+
+    @ub.setter
+    def ub(self, value):
+        self._comm_ub = value
+
+    @S.setter
+    def S(self, value):
+        self._comm_S = value
+
+    @metabolites.setter
+    def metabolites(self, value):
+        self._comm_metabolites = value
+
+    @reactions.setter
+    def reactions(self, value):
+        self._comm_reactions = value
+
+    @biomass_index.setter
+    def biomass_index(self, value):
+        self._comm_biomass_index = value
+
+    @biomass_function.setter
+    def biomass_function(self, value):
+        self._comm_biomass_function = value
+
+    def set_fast_mode(self):
+
+        try:
+            import gurobipy
+
+            self._comm_parameters["fast_computations"] = True
+        except ImportError as e:
+            print("You have to install gurobi to use the fast computations.")
+            self._comm_parameters["fast_computations"] = False
+
+    def set_slow_mode(self):
+
+        self._comm_parameters["fast_computations"] = False
+
+    def set_nullspace_method(self, value):
+
+        self._comm_parameters["nullspace_method"] = value
+
+    def set_opt_percentage(self, value):
+
+        self._comm_parameters["opt_percentage"] = value
+
+    def shut_down_reaction(self, index_val):
+
+        if (
+            (not isinstance(index_val, int))
+            or index_val < 0
+            or index_val >= self._comm_S.shape[1]
+        ):
+            raise Exception("The input does not correspond to a proper reaction index.")
+
+        self._comm_lb[index_val] = 0
+        self._comm_ub[index_val] = 0 
diff --git a/dingo/CommunityPolytopeSampler.py b/dingo/CommunityPolytopeSampler.py
new file mode 100644
index 00000000..d85941c0
--- /dev/null
+++ b/dingo/CommunityPolytopeSampler.py
@@ -0,0 +1,250 @@
+# dingo : a python library for metabolic networks sampling and analysis
+# dingo is part of GeomScale project
+
+# Copyright (c) 2021 Apostolos Chalkis
+# Copyright (c) 2021 Haris Zafeiropoulos
+
+# Licensed under GNU LGPL.3, see LICENCE file
+
+
+import numpy as np
+import math
+from dingo.fva import slow_fva
+from dingo.utils import (
+    map_samples_to_steady_states,
+    get_matrices_of_low_dim_polytope,
+    get_matrices_of_full_dim_polytope,
+    build_conq_matrix
+)
+
+try:
+    import gurobipy
+    from dingo.gurobi_based_implementations import fast_fba, fast_fva, fast_inner_ball
+except ImportError as e:
+    pass
+
+from volestipy import HPolytope
+
+
+
+class CommunityPolytopeSampler:
+
+    def __init__(self, metabol_net):
+
+        self._metabolic_network = metabol_net
+        self._modelList          = metabol_net.modelList
+        self.list_of_model_elements = []
+        self._comm_A       = []
+        self._comm_b       = []
+        self._comm_N       = []
+        self._comm_N_shift = []
+        self._comm_T       = []
+        self._comm_T_shift = []
+
+        self._parameters = {}
+        self._parameters["nullspace_method"] = "sparseQR"
+        self._parameters["opt_percentage"] = self.metabolic_network.parameters[
+            "opt_percentage"
+        ]
+        self._parameters["distribution"] = "uniform"
+        self._parameters["first_run_of_mmcs"] = True
+
+        try:
+            import gurobipy
+
+            self._parameters["fast_computations"] = True
+            self._parameters["tol"] = 1e-06
+        except ImportError as e:
+            self._parameters["fast_computations"] = False
+            self._parameters["tol"] = 1e-03
+
+
+    def getIndividualMatrices(self):
+        """
+        A Python function to derive the matrices A, Aeq and the vectors b, beq for each model. 
+        Here is what each of these variables stand for:
+
+        A   -- Linear inequality constraints, specified as a real matrix. A is an M-by-N matrix, where M is the number of inequalities, and N is the number of variables 
+        b   -- Linear inequality constraints, specified as a real vector. b is an M-element vector related to the A matrix. I
+        Aeq -- Linear equality constraints, specified as a real matrix. Aeq is an Me-by-N matrix, where Me is the number of equalities, and N is the number of variables
+        beq -- Linear equality constraints, specified as a real vector. beq is an Me-element vector related to the Aeq matrix.
+        min_fluxes
+        max_fluxes
+        """
+        list_of_model_elements = []
+        for model in self._modelList:
+
+            polytope_cl = PolytopeSampler(model)
+
+            if (
+                polytope_cl.A == []
+                or polytope_cl.b == []
+                or polytope_cl.N == []
+                or polytope_cl.N_shift == []
+                or polytope_cl.T == []
+                or polytope_cl.T_shift == []
+            ):
+
+                (
+                    min_fluxes,
+                    max_fluxes,
+                    max_biomass_flux_vector,
+                    max_biomass_objective,
+                ) = polytope_cl.metabolic_network.fva()
+
+                A, b, Aeq, beq = get_matrices_of_low_dim_polytope(
+                    polytope_cl.metabolic_network.S,
+                    polytope_cl.metabolic_network.lb,
+                    polytope_cl.metabolic_network.ub,
+                    min_fluxes,
+                    max_fluxes,
+                )
+
+            # Make a tupple with all needed for each model
+            model_elements = (A, b, Aeq, beq, min_fluxes, max_fluxes)
+            list_of_model_elements.append(model_elements)
+
+        self.list_of_model_elements = list_of_model_elements
+
+    def matrices_for_community_level(self):
+        """A Python function to derive the matrices A, Aeq and the vectors b, beq of the low dimensional polytope at the community level,
+        such that A*x <= b and Aeq*x = beq.
+
+        Keyword arguments:
+        self.list_of_model_elements -- output of the getIndividualMatrices function, including
+        A, b, Aeq, beq, min_fluxes, max_fluxes for each model 
+        """
+
+        list_of_A   = []
+        list_of_b   = []
+        list_of_Aeq = []
+        list_of_beq = []
+
+        for model in self.list_of_model_elements:
+
+            list_of_A.append(model[0])
+            list_of_b.append(model[1])
+            list_of_Aeq.append(model[2])
+            list_of_beq.append (model[3])
+
+        tmp_A   = build_conq_matrix(list_of_A)
+        tmp_b   = np.concatenate(list_of_b, axis=0)
+
+        tmp_Aeq = build_conq_matrix(list_of_Aeq)
+        tmp_beq = np.concatenate(list_of_beq, axis=0)
+
+
+        # By making use of the matrices just built, get full polytope  
+        (
+            self._comm_A, 
+            self._comm_b, 
+            self._comm_N, 
+            self._comm_N_shift, 
+        ) = get_matrices_of_full_dim_polytope(tmp_A, tmp_b, tmp_Aeq, tmp_beq)
+
+        n = self._comm_A.shape[1]
+        self._T = np.eye(n)
+        self._T_shift = np.zeros(n)
+
+        return self._comm_A, self._comm_b, self._comm_N, self._comm_N_shift
+
+
+    def generate_steady_states(
+        self, ess=1000, psrf=False, parallel_mmcs=False, num_threads=1
+    ):
+        """A member function to sample steady states.
+
+        Keyword arguments:
+        ess -- the target effective sample size
+        psrf -- a boolean flag to request PSRF smaller than 1.1 for all marginal fluxes
+        parallel_mmcs -- a boolean flag to request the parallel mmcs
+        num_threads -- the number of threads to use for parallel mmcs
+        """
+
+        self.getIndividualMatrices()
+        self.matrices_for_community_level()
+
+        P = HPolytope(self._comm_A, self._comm_b)
+
+        if self._parameters["fast_computations"]:
+            self._comm_A, self._comm_b, Tr, Tr_shift, samples = P.fast_mmcs(
+                ess, psrf, parallel_mmcs, num_threads
+            )
+        else:
+            self._comm_A, self._comm_b, Tr, Tr_shift, samples = P.slow_mmcs(
+                ess, psrf, parallel_mmcs, num_threads
+            )
+
+        if self._parameters["first_run_of_mmcs"]:
+            steady_states = map_samples_to_steady_states(
+                samples, self._comm_N, self._comm_N_shift
+            )
+            self._parameters["first_run_of_mmcs"] = False
+        else:
+            steady_states = map_samples_to_steady_states(
+                samples, self._comm_N, self._comm_N_shift, self._T, self._T_shift
+            )
+
+        self._T = np.dot(self._T, Tr)
+        self._T_shift = np.add(self._T_shift, Tr_shift)
+
+        return steady_states
+
+
+
+
+
+
+    @property
+    def A(self):
+        return self._A
+
+    @property
+    def b(self):
+        return self._b
+
+    @property
+    def T(self):
+        return self._T
+
+    @property
+    def T_shift(self):
+        return self._T_shift
+
+    @property
+    def N(self):
+        return self._N
+
+    @property
+    def N_shift(self):
+        return self._N_shift
+
+    @property
+    def metabolic_network(self):
+        return self._metabolic_network
+
+    def set_fast_mode(self):
+
+        self._parameters["fast_computations"] = True
+        self._parameters["tol"] = 1e-06
+
+    def set_slow_mode(self):
+
+        self._parameters["fast_computations"] = False
+        self._parameters["tol"] = 1e-03
+
+    def set_distribution(self, value):
+
+        self._parameters["distribution"] = value
+
+    def set_nullspace_method(self, value):
+
+        self._parameters["nullspace_method"] = value
+
+    def set_tol(self, value):
+
+        self._parameters["tol"] = value
+
+    def set_opt_percentage(self, value):
+
+        self._parameters["opt_percentage"] = value 
diff --git a/dingo/MetabolicNetwork.py b/dingo/MetabolicNetwork.py
index dac0537b..059d9c70 100644
--- a/dingo/MetabolicNetwork.py
+++ b/dingo/MetabolicNetwork.py
@@ -22,8 +22,8 @@ class MetabolicNetwork:
     def __init__(self, tuple_args):
 
         self._parameters = {}
-        self._parameters["opt_percentage"] = 100
-        self._parameters["distribution"] = "uniform"
+        self._parameters["opt_percentage"]   = 100
+        self._parameters["distribution"]     = "uniform"
         self._parameters["nullspace_method"] = "sparseQR"
 
         try:
@@ -38,20 +38,20 @@ def __init__(self, tuple_args):
                 "An unknown input format given to initialize a metabolic network object."
             )
 
-        self._lb = tuple_args[0]
-        self._ub = tuple_args[1]
-        self._S = tuple_args[2]
-        self._metabolites = tuple_args[3]
-        self._reactions = tuple_args[4]
-        self._biomass_index = tuple_args[5]
+        self._lb               = tuple_args[0]
+        self._ub               = tuple_args[1]
+        self._S                = tuple_args[2]
+        self._metabolites      = tuple_args[3]
+        self._reactions        = tuple_args[4]
+        self._biomass_index    = tuple_args[5]
         self._biomass_function = tuple_args[6]
 
         try:
             if (
-                self._lb.size != self._ub.size
-                or self._lb.size != self._S.shape[1]
-                or len(self._metabolites) != self._S.shape[0]
-                or len(self._reactions) != self._S.shape[1]
+                self._lb.size                  != self._ub.size
+                or self._lb.size               != self._S.shape[1]
+                or len(self._metabolites)      != self._S.shape[0]
+                or len(self._reactions)        != self._S.shape[1]
                 or self._biomass_function.size != self._S.shape[1]
                 or (self._biomass_index < 0)
                 or (self._biomass_index > self._biomass_function.size)
@@ -222,4 +222,4 @@ def shut_down_reaction(self, index_val):
             raise Exception("The input does not correspond to a proper reaction index.")
 
         self._lb[index_val] = 0
-        self._ub[index_val] = 0
+        self._ub[index_val] = 0 
diff --git a/dingo/PolytopeSampler.py b/dingo/PolytopeSampler.py
index 5b9b12cd..63619fa6 100644
--- a/dingo/PolytopeSampler.py
+++ b/dingo/PolytopeSampler.py
@@ -13,7 +13,7 @@
 from dingo.utils import (
     map_samples_to_steady_states,
     get_matrices_of_low_dim_polytope,
-    get_matrices_of_full_dim_polytope,
+    get_matrices_of_full_dim_polytope
 )
 
 try:
@@ -28,9 +28,6 @@
 class PolytopeSampler:
     def __init__(self, metabol_net):
 
-        # print(isinstance(metabol_net, MetabolicNetwork))
-        # print(not isinstance(metabol_net, MetabolicNetwork))
-        # x= not isinstance(metabol_net, MetabolicNetwork)
         if not isinstance(metabol_net, MetabolicNetwork):
             raise Exception("An unknown input object given for initialization.")
 
@@ -43,9 +40,7 @@ def __init__(self, metabol_net):
         self._T_shift = []
         self._parameters = {}
         self._parameters["nullspace_method"] = "sparseQR"
-        self._parameters["opt_percentage"] = self.metabolic_network.parameters[
-            "opt_percentage"
-        ]
+        self._parameters["opt_percentage"] = self.metabolic_network.parameters["opt_percentage"]
         self._parameters["distribution"] = "uniform"
         self._parameters["first_run_of_mmcs"] = True
 
@@ -295,4 +290,4 @@ def set_tol(self, value):
 
     def set_opt_percentage(self, value):
 
-        self._parameters["opt_percentage"] = value
+        self._parameters["opt_percentage"] = value 
diff --git a/dingo/__init__.py b/dingo/__init__.py
index de3719d4..485ed97a 100644
--- a/dingo/__init__.py
+++ b/dingo/__init__.py
@@ -22,10 +22,13 @@
     get_matrices_of_low_dim_polytope,
     get_matrices_of_full_dim_polytope,
     plot_histogram,
+    buildConqMatrix
 )
 from dingo.parser import dingo_args
 from dingo.MetabolicNetwork import MetabolicNetwork
 from dingo.PolytopeSampler import PolytopeSampler
+from dingo.CommunityMetabolicNetwork import CommunityMetabolicNetwork
+from dingo.CommunityPolytopeSampler import CommunityPolytopeSampler
 
 try:
     import gurobipy
@@ -36,6 +39,7 @@
 from volestipy import HPolytope
 
 
+
 def get_name(args_network):
 
     position = [pos for pos, char in enumerate(args_network) if char == "/"]
@@ -61,9 +65,9 @@ def dingo_main():
 
     args = dingo_args()
 
-    if args.metabolic_network is None and args.polytope is None and not args.histogram:
+    if args.metabolic_network is None and args.community_models is None and args.polytope is None and not args.histogram:
         raise Exception(
-            "You have to give as input either a model or a polytope derived from a model."
+            "You have to give as input either a model or a polytope derived from a model, or a set of models from a community."
         )
 
     if args.metabolic_network is None and ((args.fva) or (args.fba)):
@@ -226,6 +230,68 @@ def dingo_main():
             ) as dingo_steadystates_file:
                 pickle.dump(steady_states, dingo_steadystates_file)
 
+# Community oriented case
+    elif args.community_models is not None:
+
+        if args.community_models == None: 
+            raise Exception("You need to provide the path to the directory with the metabolic networks.")
+
+        if args.format == None:
+            raise Exception("Provide the format of the metabolic networks, i.e. json, mat etc.")
+
+        if args.format != "json" and args.format != "mat":
+            raise Exception("dingo supports only .mat and .json models for the time being.")
+
+        com_model = CommunityMetabolicNetwork.buildModelList(args.community_models, args.format)
+
+        sampler = CommunityPolytopeSampler(com_model)
+
+        if args.preprocess_only:
+
+            sampler.getIndividualMatrices()
+            sampler.matrices_for_community_level()
+
+            polytope_info = (
+                sampler,
+                name,
+            )
+
+            with open("dingo_community_model_" + name + ".pckl", "wb") as dingo_model_file:
+                pickle.dump(com_model, dingo_model_file)
+
+            with open(
+                "dingo_community_polytope_sampler_" + name + ".pckl", "wb"
+            ) as dingo_polytope_file:
+                pickle.dump(polytope_info, dingo_polytope_file)
+
+        else:
+
+            steady_states = sampler.generate_steady_states(
+                int(args.effective_sample_size),
+                args.psrf_check,
+                args.parallel_mmcs,
+                int(args.num_threads),
+            )
+
+            polytope_info = (
+                sampler,
+                name,
+            )
+
+            with open("dingo_comunity_model_" + name + ".pckl", "wb") as dingo_model_file:
+                pickle.dump(com_model, dingo_model_file)
+
+            with open(
+                "dingo_community_polytope_sampler_" + name + ".pckl", "wb"
+            ) as dingo_polytope_file:
+                pickle.dump(polytope_info, dingo_polytope_file)
+
+            with open(
+                "dingo_steady_states_" + name + ".pckl", "wb"
+            ) as dingo_steadystates_file:
+                pickle.dump(steady_states, dingo_steadystates_file)
+
+
     else:
 
         file = open(args.polytope, "rb")
diff --git a/dingo/loading_models.py b/dingo/loading_models.py
index 1bdcbb2b..cb3f7bfb 100644
--- a/dingo/loading_models.py
+++ b/dingo/loading_models.py
@@ -6,7 +6,7 @@
 
 # Licensed under GNU LGPL.3, see LICENCE file
 
-import json
+import json, os
 import scipy.io
 import numpy as np
 
@@ -180,3 +180,94 @@ def read_mat_file(input_file):
     biomass_index = biomass_index[0][0]
 
     return lb, ub, S, metabolites, reactions, biomass_index, biomass_function
+
+
+# This implementation works only for communities of 2 models 
+# Once our method is validated, we will move on to implement it for more 
+# by using the buildConqMatrix function
+def get_model_list(directory, format_type):
+
+    """
+    A Python function to get all the metabolic network files under a directory 
+    and build a concatenated model and return:
+    (a) lower/upper flux bounds
+    (b) the stoichiometric matrix S (dense format)
+    (c) the list of the metabolites
+    (d) the list of reactions
+    (e) the index of the biomass pseudoreaction
+    (f) the objective function to maximize the biomass pseudoreaction
+
+    Keyword arguments:
+    directory -- directory where the metabolic network files of interest are located 
+    """
+
+    from dingo.MetabolicNetwork import MetabolicNetwork
+    from dingo.untils import build_conq_matrix
+
+    list_of_models = []
+    amodel = "ERROR"
+    for filename in os.listdir(directory):
+        f = os.path.join(directory, filename)
+        if os.path.isfile(f):
+            if format_type == "mat":
+                amodel = MetabolicNetwork.from_mat(f)
+            elif format_type == "json":
+                amodel = MetabolicNetwork.from_json(f)
+            list_of_models.append(amodel)
+
+
+    
+    model_A = list_of_models[0]
+    model_B = list_of_models[1]
+
+    list_of_stoichiometric_matrices = []
+    for model in list_of_models:
+        list_of_stoichiometric_matrices.append(model.S)
+
+
+
+    # # Build concatenated stoichiometric matrix
+    # compl_1 = np.zeros((model_A.S.shape[0], model_B.S.shape[1]))
+    # compl_2 = np.zeros((model_B.S.shape[0], model_A.S.shape[1]))
+    # part_a  = np.concatenate((model_A.S, compl_1), axis=1)
+    # part_b  = np.concatenate((model_B.S, compl_2), axis=1)
+
+
+    # Get concatenated bounds
+    conc_lb = np.concatenate(([model.lb for model in list_of_models]), axis=0)
+    conc_lb = np.append(conc_lb, 0.0)
+
+    conc_ub = np.concatenate(([model.ub for model in list_of_models]), axis=0)
+    conc_ub = np.append(conc_ub, 1000.0)
+    
+    # Get concatenated reactions.. (including biomass overall ?) and metabolites
+    conc_reactions   = []
+    conc_metabolites = []
+
+    for model in list_of_models: 
+        conc_reactions   = conc_reactions + model.reactions
+        conc_metabolites = conc_metabolites + model.metabolites
+    conc_reactions.append("biomass_overall")
+
+
+    # Build concatenated biomass function 
+    """
+    
+    μ_c = Σ_i ( b_i / B * μ_i)
+    where μ_i is each specific model's biomass function 
+    and b_i is the abundance of each model.. we do not have this info for the time being... 
+
+    """
+
+    pair_biomass_function    = np.concatenate((model_A.S[:,model_A.biomass_index], model_B.S[:,model_B.biomass_index]), axis=0)
+    pair_biomass_function    = pair_biomass_function.reshape((pair_biomass_function.shape[0], 1))
+    conc_S  = np.concatenate((part_a, part_b), axis=0)
+    conc_S  = np.concatenate((conc_S, pair_biomass_function), axis=1)
+
+
+    # Overall biomass function info
+    conc_biomass_function      = np.zeros((1,conc_S.shape[1] -1))
+    conc_biomass_function = np.append(conc_biomass_function, 1.0)
+    conc_biomass_index    = conc_S.shape[1] -1 
+
+    return conc_lb, conc_ub, conc_S, conc_metabolites, conc_reactions, conc_biomass_index, conc_biomass_function, list_of_models
diff --git a/dingo/parser.py b/dingo/parser.py
index 610d9bac..d8780df3 100644
--- a/dingo/parser.py
+++ b/dingo/parser.py
@@ -41,7 +41,7 @@ def dingo_args():
     optional.add_argument(
         "--metabolic_network",
         "-i",
-        help="the path to a metabolic network as a .json or a .mat file.",
+        help="The path to a metabolic network as a .json or a .mat file.",
         required=False,
         default=None,
         metavar="",
@@ -50,7 +50,7 @@ def dingo_args():
     optional.add_argument(
         "--unbiased_analysis",
         "-unbiased",
-        help="a boolean flag to ignore the objective function in preprocessing. Multiphase Monte Carlo Sampling algorithm will sample steady states but not restricted to optimal solutions. The default value is False.",
+        help="A boolean flag to ignore the objective function in preprocessing. Multiphase Monte Carlo Sampling algorithm will sample steady states but not restricted to optimal solutions. The default value is False.",
         required=False,
         default=False,
         metavar="",
@@ -59,7 +59,7 @@ def dingo_args():
     optional.add_argument(
         "--polytope",
         "-poly",
-        help="the path to a pickle file generated by dingo that contains a full dimensional polytope derived from a model. This file could be used to sample more steady states of a preprocessed metabolic network.",
+        help="The path to a pickle file generated by dingo that contains a full dimensional polytope derived from a model. This file could be used to sample more steady states of a preprocessed metabolic network.",
         required=False,
         default=None,
         metavar="",
@@ -218,5 +218,23 @@ def dingo_args():
         metavar="",
     )
 
+    optional.add_argument(
+        "--community_models",
+        "-cmd",
+        help="Path for the directory with the metabolic networks of the community under study. On this directory, you need to make sure that only the metabolic network files are present.",
+        required=False,
+        default=None,
+        metavar="",
+    )
+
+    optional.add_argument(
+        "--format",
+        "-f",
+        help="Format of the metabolic network files. Set as 'json' or 'mat' according to your input models.",
+        required=False,
+        default=None,
+        metavar="",
+    )
+
     args = parser.parse_args()
     return args
diff --git a/dingo/utils.py b/dingo/utils.py
index 466ee800..2e177636 100644
--- a/dingo/utils.py
+++ b/dingo/utils.py
@@ -2,6 +2,7 @@
 # dingo is part of GeomScale project
 
 # Copyright (c) 2021 Apostolos Chalkis
+# Copyright (c) 2021 Haris Zafeiropoulos
 
 # Licensed under GNU LGPL.3, see LICENCE file
 
@@ -196,3 +197,48 @@ def plot_histogram(reaction_fluxes, reaction, n_bins=40):
     plt.axis([np.amin(reaction_fluxes), np.amax(reaction_fluxes), 0, np.amax(n) * 1.2])
 
     plt.show()
+
+
+def build_conq_matrix(list_of_matrices):
+
+    m      = 0
+    n      = 0
+    frames = [] 
+    for matrix in list_of_matrices: 
+        m += matrix.shape[0]
+        n += matrix.shape[1]
+        frames.append(matrix.shape[1])
+
+    counter = 0
+    parts   = []
+    for matrix in list_of_matrices:
+        if counter == 0: 
+            compl = np.zeros((matrix.shape[0], n - matrix.shape[1]))
+            part  = np.concatenate((matrix, compl), axis=1)
+
+        elif counter == len(list_of_matrices) - 1: 
+            compl = np.zeros((matrix.shape[0], n - matrix.shape[1]))
+            part  = np.concatenate((compl, matrix), axis=1)
+
+        else:
+            prev        = sum(frames[:counter])
+            after       = sum(frames[counter+1:])
+            compl_prev  = np.zeros((matrix.shape[0], prev))
+            compl_after = np.zeros((matrix.shape[0], after))
+            part_a      = np.concatenate((compl_prev, matrix), axis=1)
+            part        = np.concatenate((part_a, compl_after), axis=1)
+                        
+        parts.append(part)
+        counter += 1
+
+    part_counter = 0 
+    for part in parts: 
+        if part_counter == 0: 
+            concMatrix = part                
+        else: 
+            concMatrix = np.concatenate((concMatrix, part), axis=0)
+        part_counter += 1
+
+    return concMatrix
+
+ 
\ No newline at end of file
diff --git a/doc/polyround_hopsy_tests.ipynb b/doc/polyround_hopsy_tests.ipynb
new file mode 100644
index 00000000..f8af1c89
--- /dev/null
+++ b/doc/polyround_hopsy_tests.ipynb
@@ -0,0 +1,1945 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing for `hopsy` with random data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import hopsy\n",
+    "import numpy as np"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the polytope is defined as\n",
+    "#          P := {x : Ax <= b}\n",
+    "# thus we need to define A and b. these constraints form the simple box [0,1]^2.\n",
+    "A = np.array([[1, 0], [0, 1], [-1, 0], [0, -1]])\n",
+    "b = np.array([[1], [1], [0], [0]]);\n",
+    "\n",
+    "# next we define our target distribution as an isotropic Gaussian with mean 0 and\n",
+    "# identity covariance.\n",
+    "mu = np.zeros((2,1))\n",
+    "cov = np.identity(2)\n",
+    "\n",
+    "model = hopsy.MultivariateGaussianModel(mu, cov)\n",
+    "\n",
+    "# the complete problem is defined by the target distribution and the constrained domain,\n",
+    "# defined by the above mentioned inequality\n",
+    "problem = hopsy.Problem(A, b, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Academic license - for non-commercial use only - expires 2021-11-23\n",
+      "Using license file /opt/gurobi912/gurobi.lic\n"
+     ]
+    }
+   ],
+   "source": [
+    "# the run object contains and constructs the markov chains. in the default case, the\n",
+    "# Run object will have a single chain using the Hit-and-Run proposal algorithm and is\n",
+    "# set to produce 10,000 samples.\n",
+    "run = hopsy.Run(problem)\n",
+    "\n",
+    "# we finally sample\n",
+    "run.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# from the run, we can now extract the produced data\n",
+    "data = run.data\n",
+    "\n",
+    "# the states is a list of lists of numpy.ndarrays, which can be casted to a numpy.ndarray\n",
+    "# which then has the shape (m,n,d), where m is the number of chains, n the number of samples\n",
+    "# and d the dimenion\n",
+    "states  = data.states"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we neend to plot "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The `states` variable is a **list** of arrays. \n",
+    "Usint the `pandas` library we can make a `DataFrame` out of it. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>0</th>\n",
+       "      <th>1</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.527353</td>\n",
+       "      <td>0.882257</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.983544</td>\n",
+       "      <td>0.895377</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.966116</td>\n",
+       "      <td>0.957163</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.511486</td>\n",
+       "      <td>0.989361</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.868993</td>\n",
+       "      <td>0.870392</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>0.175812</td>\n",
+       "      <td>0.310576</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>0.609898</td>\n",
+       "      <td>0.302661</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>0.280251</td>\n",
+       "      <td>0.934239</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>0.008388</td>\n",
+       "      <td>0.689737</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>0.020761</td>\n",
+       "      <td>0.772523</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            0         1\n",
+       "0    0.527353  0.882257\n",
+       "1    0.983544  0.895377\n",
+       "2    0.966116  0.957163\n",
+       "3    0.511486  0.989361\n",
+       "4    0.868993  0.870392\n",
+       "..        ...       ...\n",
+       "995  0.175812  0.310576\n",
+       "996  0.609898  0.302661\n",
+       "997  0.280251  0.934239\n",
+       "998  0.008388  0.689737\n",
+       "999  0.020761  0.772523\n",
+       "\n",
+       "[1000 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_data = pd.DataFrame(np.concatenate(states))\n",
+    "df_data"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Some visualizations "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<AxesSubplot:ylabel='Count'>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYUAAAD4CAYAAAAD6PrjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAZVUlEQVR4nO3dfXAV5f338c9yDkdAQkLwJBHMVGEqwwQHercCGREkGFAiNalELa2V+hDbUXksIAr8vDsQ+TnlZ3TswJ1fWxRLp0oscQQK1FBAy1MHQUTbilYsRJNASEgASTgne/9B2fIQks05u2dzkvdrhplkz9lrv9eSnE/22t1rDdM0TQEAIKmL1wUAANoPQgEAYCEUAAAWQgEAYCEUAAAWv9cFRKOpqUnhcGQXT/l8RsTrxiv63DnQ584hmj537eq74mtxHQrhsKna2tMRrZuU1CPideMVfe4c6HPnEE2fg8GEK77G8BEAwEIoAAAshAIAwBLX5xQAwCvhcEg1NUcVCjV6sv3KSkOtzVLk9wfUu3dQPp/9j3pCAQAiUFNzVN269dDVV6fJMIyYb9/n66JwuOmKr5umqVOn6lRTc1TXXHOt7XYZPgKACIRCjbr66l6eBIIdhmHo6qt7tflIhlAAgAi110A4L5L6CAUAgIVzCgDggITE7uoWcO4j9UxjSPUnvm7xPTt3bteLL/5CTU1NuuuuXD3wwJSot9tpQ8FvhFu8qy9S4cYGHT/hzdUIALzTLeDXPb98z7H23nx8pOpbeD0cDut//ue/9cILv1RKSqoeeeRHGjlylG64oX9U2+20oWD4A2r83zscbzfw6AZJhAIAd3388QFdd126+vW7TpJ0++3j9N57W6MOBc4pAEAcOnr0qFJSUq3vg8EUHT1aFXW7hAIAwEIoAEAcCgaDqqqqtL4/erRKwWBK1O0SCgAQhwYNytDhw4f15ZflOnv2rN55Z5NuuWVU1O122hPNAOCkM40hvfn4SEfba4nf79fMmbM1c+aTamoKKyfnu+rff0DU2yUUAMAB9Se+bvESUjdkZo5UZqZzQSQxfAQAuAChAACwEAoAAAuhAACwEAoAAAuhAACwuHZJ6rx587Rlyxb16dNHa9eulSTV1tZqxowZKi8vV79+/VRUVKTExESZpqnFixdr69at6tatm5YsWaKMjAy3SgMAxyUnBuQLXOVYe3ZmXC4s/L/avv099e7dW6+99oYj23UtFL73ve/phz/8oebOnWstKy4uVmZmpgoKClRcXKzi4mLNnj1b27Zt06FDh7Rp0yZ98MEHevbZZ7V69Wq3SgMAx/kCVzk687KdGZcnTJioe+65T4sWLXRsu64NH918881KTEy8aFlZWZlyc3MlSbm5uXrnnXcuWm4YhoYOHaq6ujpVVUU/2x8AdGRDh/4f9erVy9E2Y3pHc3V1tVJSzk3YFAwGVV1dLUmqrKxUWlqa9b60tDRVVlZa770Sn89QUlKPiOvx+30Rr9uSaGpyk8/Xpd3W5hb63Dl40efKSkM+38V/Vxty9pnNl7bf3Os+XxcZxuW1WDUZbfuc9GyaC8Mwon7odThsqrb2dETrBoMJCoXCUW2/OQEp4prclpTUo93W5hb63Dl40WfTNBUON128TKaj27i0/Qv5fF0UDjcpHG5qtpYL67x037T01MmYXn3Up08fa1ioqqpKycnJkqTU1FRVVFRY76uoqFBqamqzbQAA3BPTUMjKylJpaakkqbS0VGPHjr1ouWma2rdvnxISElodOgIAOM+14aOZM2dq9+7dqqmp0ahRo/Tkk0+qoKBA06dPV0lJifr27auioiJJ0ujRo7V161ZlZ2ere/fuKiwsdKssAHBFuLHh31cMOddea/7rv57Wvn17VFtbq7y8CXr44QLddVduVNs1TNN0dhAshs6eDUd1TsHJy8fOCzy6QUePxnoCXXsYa+4c6HNsVFR8obS0b8R0mxc6f06hNc3V2W7OKQAA2jdCAQBgIRQAIELtffQ9kvoIBQCIgN8f0KlTde02GEzT1KlTdfL7A21aj2c0A0AEevcOqqbmqE6erPVk+4ZhtBpIfn9AvXsH29QuoQAAEfD5/Lrmmms9275bV1wxfAQAsBAKAAALoQAAsBAKAAALoQAAsHD1ERyXkNhd3QLO/2idaQyp/sTXjrcL4D8IBTiuW8Cve375nuPtvvn4SLXPqQaBjoPhIwCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhTuaEVeCwQTH1wk3Nuj4icZISwI6FEIBcaXxf+9o0/v9fp9CoXCL7wk8ukESoQBIDB8BAC5AKAAALIQCAMBCKAAALJxoBuKI3QcYtfUqLR5ghPM8CYVXXnlFq1evlmEYuvHGG/Xcc8+pqqpKM2fOVG1trTIyMvT8888rEAh4UR7Qbtl5gJGdK64uxQOMcF7MQ6GyslIrV67U+vXr1a1bN02bNk3r1q3T1q1bNWXKFOXk5GjhwoUqKSnR5MmTY11ep+PWozO7dvU53ibcFck9IK3hHpD448mRQjgc1pkzZ+T3+3XmzBkFg0Ht3LlTS5culSTl5eXp5ZdfJhRiwI1HZ775+EiZX+53tM1zMl1oE+e19R4QO7gHJP7EPBRSU1P10EMPacyYMbrqqqt0yy23KCMjQ7169ZLff66ctLQ0VVZWttqWz2coKalHxLX4/e78NRtNTVdiGlLAgXqb+2vQjf1gGIbjbTaGmv79IdM2rQ1CNoaaHP8ruTEUlmE62qSltf8vw8Z7Imk3Um78PlzK5+sSk+20J271OeahcOLECZWVlamsrEwJCQmaNm2a3n333YjaCodN1daejmjdYDChzeOudgSkiGtqSTCYEPVf9M2NNb/5+EhX9oNpOv+JGPB30X3P/r82rWMYRqu1vP7sY64cLR096vwovZ2f20jOKUiKq9+HSyUl9YjJdtqTaPrc0h9BMQ+F7du367rrrlNycrIkady4cXr//fdVV1enUCgkv9+viooKpaamxro0IC7YOV/DOR1EKuah0LdvX33wwQf6+uuv1a1bN+3YsUODBw/W8OHDtXHjRuXk5GjNmjXKysqKdWlAXGjtfI2do6PLcb4G58Q8FIYMGaLx48crLy9Pfr9fgwYN0n333afbbrtNM2bMUFFRkQYNGqT8/PxYlwYAnZ4nVx9NnTpVU6dOvWhZenq6SkpKvCgHAPBvTHMBALAwzYXTQo2u3ASE+MPPAeIRoeA0f8DFm4AQT/g5QDxi+AgAYCEUAAAWho8AF0Q6JQfgNUIBcEEkU3LY8fqzjzneJnAhho8AABZCAQBgIRQAABZCAQBg4URzHHFiOmSmVAbQEkIhjkT7iMvmp1RmymQA/9FpQ8Gt68i5Ph1APOu0oeDmdeRcnw4gXnGiGQBgIRQAAJZOO3yE/+CKJADnEQqI+qqmy3FFExCvCAVAHC25xoUnEYYbG3T8RKOjbeI/CAVAHC25xoUnEZ675JtQcAsnmgEAFkIBAGAhFAAAFs4pAICLEhK7q1vA+Y/axlDY8TYlm6GwZ88effvb3251GQDgYt0Cft3zy/ccb/fNx0c63qZkc/ho0aJFtpYBAOJbi0cKe/fu1d69e3X8+HGtWLHCWn7y5EmFw+4cugAAvNNiKJw9e1anT59WOBzWqVOnrOU9e/bUSy+95HpxAIDYajEUhg0bpmHDhikvL0/9+vVzbKN1dXWaP3++PvnkExmGocLCQt1www2aMWOGysvL1a9fPxUVFSkxMdGxbQIAWmfrRHNjY6MWLFig8vJyhUIha/nKlSsj2ujixYt166236qWXXlJjY6POnDmj5cuXKzMzUwUFBSouLlZxcbFmz54dUfsAgMjYCoVp06bp/vvvV35+vrp0ie7Whvr6ev31r3/VkiVLJEmBQECBQEBlZWV67bXXJEm5ubl64IEHCAUAiDFboeD3+zV58mRHNnjkyBElJydr3rx5+vvf/66MjAw988wzqq6uVkpKiiQpGAyqurq61bZ8PkNJST0irsUwjIjXjdd2m2vDjXrb0z6ws05H2wdt3babj6f1+52fbPDS33ufr0tUnwVuc2MfSJfvByfYCoUxY8Zo1apVys7OViAQuKCgpDZvMBQK6eOPP9aCBQs0ZMgQLVq0SMXFxRe9xzAMWz/U4bCp2trTba5BkoLBhGYeYu+M9tquYRjNtuFGve1lH1ypz9G2a4dX+8Buny/k5uNpnb7JKiBd9nuflNQj4s8CtwWDCQq5dKNZNJ9/V2IrFNasWSNJ+vWvf20tMwxDZWVlbS4mLS1NaWlpGjJkiCTpjjvuUHFxsfr06aOqqiqlpKSoqqpKycnJbW4bABAdW6GwefNmxzYYDAaVlpamf/7zn+rfv7927NihAQMGaMCAASotLVVBQYFKS0s1duxYx7YJALDHViiUlpY2uzw3NzeijS5YsEA/+9nPdPbsWaWnp+u5555TU1OTpk+frpKSEvXt21dFRUURtQ2gY2sMNTU7/BHtw3zONIZUf+LrqNroCGyFwocffmh93dDQoB07digjIyPiUBg0aJD+8Ic/XLb81Vdfjag9AJ1HwN/lsrmE/H5f1OP2bz4+UvVRtdAx2AqFBQsWXPR9XV2dZsyY4UpBAADvRHTTQffu3XXkyBGnawEAeMzWkcJPfvIT6+umpiZ99tlnuvPOO10rCgDgDVuh8NBDD1lf+3w+9evXT2lpaa4VBaBjcOumODdc6QR2Z2MrFIYNG6Zjx45ZJ5yvv/56N2sC0EG4cVPc688+5mh75zV3AtsJbj0Mxy22zimsX79e+fn52rBhg/74xz9aXwOAF7p29V30zzAuX9bWfzjH1pHC8uXLVVJSoj59+kiSjh8/rilTpuiOO+5wtTgAaI755f6Lvo9kao/LZUa5fsdg60jBNE0rEKRzcx65Na8LAMA7to4URo4cqYcfflg5OTmSzg0njRo1ytXCAACx12IofPHFFzp27Jjmzp2rTZs2ac+ePZKkoUOH6rvf/W5MCgQAxE6Lw0eFhYXq2bOnJGncuHGaN2+e5s2bp+zsbBUWFsakQABA7LQYCseOHdPAgQMvWz5w4ECVl5e7VhQAwBsthkJ9/ZWnhzpz5ozjxQAAvNViKAwePFhvvPHGZctXr16tjIwM14oCAHijxRPNTz/9tJ544gm9/fbbVggcOHBAZ8+e1csvvxyTAgEAsdNiKFxzzTX6/e9/r507d+rgwYOSpNGjRyszk5s8AKAjsnWfwogRIzRixAi3awEAeCyi5ykAADomQgEAYLE1fAQAnQGzpRIKAGC5dPZVZ8TXhTkMHwEALIQCAMBCKAAALIQCAMBCKAAALIQCAMBCKAAALIQCAMDiWSiEw2Hl5ubqsccekyQdPnxY+fn5ys7O1vTp09XY2OhVaQDQaXkWCitXrtSAAQOs73/xi19oypQp+tOf/qRevXqppKTEq9IAoNPyJBQqKiq0ZcsWTZo0SZJkmqZ27typ8ePHS5Ly8vJUVlbmRWkA0Kl5MvdRYWGhZs+erVOnTkmSampq1KtXL/n958pJS0tTZWVlq+34fIaSknpEXIdhGBGvG6/tNteGG/W2p31gZ52Otg/c2k+RiNW+dev3wwl+vzsT7UXz+XclMQ+FP//5z0pOTtbgwYO1a9euqNoKh03V1p6OaN1gMEGmaUa1/Stpr+0ahtFsG27U2172wZX6HG27dni1D+z2ua3tRioW+zbSPrfWrlNCobAr7Ubz+XclMQ+F999/X5s3b9a2bdvU0NCgkydPavHixaqrq1MoFJLf71dFRYVSU1NjXRoAuCKepuSOeSjMmjVLs2bNkiTt2rVLv/nNb7R06VJNnTpVGzduVE5OjtasWaOsrKxYlwYAroinKbnbzX0Ks2fP1ooVK5Sdna3a2lrl5+d7XRIAdDqePmRn+PDhGj58uCQpPT2dy1ABwGPt5kgBAOA9QgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWQgEAYCEUAAAWf6w3+NVXX2nOnDmqrq6WYRi699579eCDD6q2tlYzZsxQeXm5+vXrp6KiIiUmJsa6PADo1GJ+pODz+fTUU09p/fr1ev311/W73/1On376qYqLi5WZmalNmzYpMzNTxcXFsS4NADq9mIdCSkqKMjIyJEk9e/ZU//79VVlZqbKyMuXm5kqScnNz9c4778S6NADo9GI+fHShI0eO6G9/+5uGDBmi6upqpaSkSJKCwaCqq6tbXd/nM5SU1CPi7RuGEfG68dpuc224UW972gd21ulo+8Ct/RSJWO1bt34/nOBWu9F8/l2JZ6Fw6tQpTZ06VU8//bR69ux50WuGYdjaieGwqdra0xFtPxhMkGmaEa3bmvbarmEYzbbhRr3tZR9cqc/RtmuHV/vAbp/b2m6kYrFvI+1za+06xa12o/n8uxJPrj46e/aspk6dqokTJ2rcuHGSpD59+qiqqkqSVFVVpeTkZC9KA4BOLeahYJqmnnnmGfXv318//vGPreVZWVkqLS2VJJWWlmrs2LGxLg0AOr2YDx/t2bNHb731lm688UbdfffdkqSZM2eqoKBA06dPV0lJifr27auioqJYlwYAnV7MQ+E73/mO/vGPfzT72quvvhrjagAAF+KOZgCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCAhVAAAFgIBQCApV2FwrZt2zR+/HhlZ2eruLjY63IAoNNpN6EQDof185//XL/61a+0bt06rV27Vp9++qnXZQFAp9JuQmH//v36xje+ofT0dAUCAeXk5KisrMzrsgCgUzFM0zS9LkKSNmzYoHfffVeLFy+WJJWWlmr//v1auHChx5UBQOfRbo4UAADeazehkJqaqoqKCuv7yspKpaamelgRAHQ+7SYUbrrpJh06dEiHDx9WY2Oj1q1bp6ysLK/LAoBOxe91Aef5/X4tXLhQjzzyiMLhsO655x5985vf9LosAOhU2s2JZgCA99rN8BEAwHuEAgDA0uFDobWpMxobGzV9+nRlZ2crPz9fR44c8aBKZ7XW5xUrVmjChAmaOHGiHnzwQZWXl3tQpbPsTpGyceNGDRw4UB9++GEMq3OHnT6vX79eEyZMUE5OjmbNmhXjCp3XWp+//PJLPfDAA8rNzdXEiRO1detWD6p0zrx585SZmam77rqr2ddN09SiRYuUnZ2tiRMn6qOPPop+o2YHFgqFzLFjx5r/+te/zIaGBnPixInmwYMHL3rPb3/7W3PBggWmaZrm2rVrzWnTpnlQqXPs9HnHjh3m6dOnTdM0zVWrVnWKPpumadbX15uTJ0828/Pzzf3793tQqXPs9Pnzzz837777brO2ttY0TdM8duyYF6U6xk6f58+fb65atco0TdM8ePCgOWbMGC9Kdczu3bvNAwcOmDk5Oc2+vmXLFvPhhx82m5qazL1795qTJk2Kepsd+kjBztQZmzdvVl5eniRp/Pjx2rFjh8w4Pvdup88jRoxQ9+7dJUlDhw696P6QeGR3ipQXX3xRjz76qK666ioPqnSWnT6/8cYb+sEPfqDExERJUp8+fbwo1TF2+mwYhk6ePClJqq+vV0pKihelOubmm2+2/v+aU1ZWptzcXBmGoaFDh6qurk5VVVVRbbNDh0JlZaXS0tKs71NTU1VZWXnZe6699lpJ5y6LTUhIUE1NTUzrdJKdPl+opKREo0aNikVprrHT548++kgVFRW67bbbYlydO+z0+dChQ/r88891//33695779W2bdtiXaaj7PT5iSee0Ntvv61Ro0apoKBA8+fPj3WZMXXpPklLS2vx992ODh0KaNlbb72lAwcO6JFHHvG6FFc1NTVpyZIlmjt3rtelxFQ4HNYXX3yh1157TUuXLtWCBQtUV1fndVmuWrdunfLy8rRt2zYVFxdrzpw5ampq8rqsuNKhQ8HO1Bmpqan66quvJEmhUEj19fXq3bt3TOt0kt3pQrZv367ly5dr2bJlCgQCsSzRca31+dSpU/rkk0/0ox/9SFlZWdq3b59++tOfxvXJZrs/21lZWeratavS09N1/fXX69ChQzGu1Dl2+lxSUqI777xTkvStb31LDQ0NcX3k35pL90lFRUXU0wN16FCwM3VGVlaW1qxZI+nclSkjRoyQYRhelOsIO33++OOPtXDhQi1btizux5ml1vuckJCgXbt2afPmzdq8ebOGDh2qZcuW6aabbvKw6ujY+X++/fbbtXv3bknS8ePHdejQIaWnp3tRriPs9Pnaa6/Vjh07JEmfffaZGhoalJyc7EW5MZGVlaXS0lKZpql9+/YpISEh6vMo7WaaCzdcaeqMF198UYMHD9bYsWM1adIkzZ49W9nZ2UpMTNQLL7zgddlRsdPn559/XqdPn9a0adMknftFWr58uceVR85OnzsaO32+9dZb9Ze//EUTJkyQz+fTnDlz4voo2E6fn3rqKc2fP1+vvPKKDMPQkiVL4vqPvJkzZ2r37t2qqanRqFGj9OSTTyoUCkmSvv/972v06NHaunWrsrOz1b17dxUWFka9Taa5AABYOvTwEQCgbQgFAICFUAAAWAgFAICFUAAAWAgFAICFUAAAWP4/KlAfbL1hSx0AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set_style('darkgrid')\n",
+    "sns.histplot(df_data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "A better visualization. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>x</th>\n",
+       "      <th>y</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>0.527353</td>\n",
+       "      <td>0.882257</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>0.983544</td>\n",
+       "      <td>0.895377</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>0.966116</td>\n",
+       "      <td>0.957163</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>0.511486</td>\n",
+       "      <td>0.989361</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>0.868993</td>\n",
+       "      <td>0.870392</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>995</th>\n",
+       "      <td>0.175812</td>\n",
+       "      <td>0.310576</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>996</th>\n",
+       "      <td>0.609898</td>\n",
+       "      <td>0.302661</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>997</th>\n",
+       "      <td>0.280251</td>\n",
+       "      <td>0.934239</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>998</th>\n",
+       "      <td>0.008388</td>\n",
+       "      <td>0.689737</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>999</th>\n",
+       "      <td>0.020761</td>\n",
+       "      <td>0.772523</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>1000 rows × 2 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "            x         y\n",
+       "0    0.527353  0.882257\n",
+       "1    0.983544  0.895377\n",
+       "2    0.966116  0.957163\n",
+       "3    0.511486  0.989361\n",
+       "4    0.868993  0.870392\n",
+       "..        ...       ...\n",
+       "995  0.175812  0.310576\n",
+       "996  0.609898  0.302661\n",
+       "997  0.280251  0.934239\n",
+       "998  0.008388  0.689737\n",
+       "999  0.020761  0.772523\n",
+       "\n",
+       "[1000 rows x 2 columns]"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df_data = pd.DataFrame(np.concatenate(states), columns=['x', 'y'])\n",
+    "df_data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "x = df_data[\"x\"]\n",
+    "y = df_data[\"y\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEGCAYAAABo25JHAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAABFx0lEQVR4nO3dd3hb5dk/8O/RsmRLlmxZlrydxI6zySAkBDIwCSEJKYQCZbRQRhkv5IVSoAvSNi2jlLbQlhJo+gstYRQCJGS8ZSRkL8iy4wzHe0qWNWxrS0fn94fBiWNJVmIdDev+XBfXhc95/OhOYuvWecb9MBzHcSCEEJK0BLEOgBBCSGxRIiCEkCRHiYAQQpIcJQJCCElylAgIISTJiWIdwIXy+/1g2aEtdBIKmSH3ES0UKz8oVn5QrPyIRKxisTDovYRLBCzLwWp1DKkPlSp1yH1EC8XKD4qVHxQrPyIRq0ajCHqPhoYIISTJ8ZYIfv7zn+Pyyy/HddddF/D+J598gqVLl2Lp0qW49dZbcerUKb5CIYQQEgJvieDGG2/E6tWrg97Pz8/H2rVrsXHjRjz00EN45pln+AqFEEJICLzNEUyfPh0tLS1B70+dOrXv/ydPngy9Xs9XKIQQQkKIi8nidevWYc6cOWG1FQoZqFSpQ3o9oVAw5D6ihWLlB8XKD4qVH3zHGvNEsH//fqxbtw7vvPNOWO1p1VD8olj5QbHyI9liDbVqKKaJ4NSpU3j66afxj3/8AxkZGbEMhRBCklbMlo+2tbVh+fLlePHFFzFixIhYhUEIIUmPtyeCxx9/HAcPHoTFYsGcOXOwfPly+Hw+AMBtt92GV199FVarFb/5zW8AAEKhEB999BFf4ZBhhPVzaO92wWT3wOZhIWCA9BQRtOlSqFPFYBgm1iESklCYRDuYxutlaY4gTvEVq5/jUNXeg521JnzVZMUZox3pUhEyUsWQigTgANjdLDrtHggYYGJuOmaNyMRVJWpkyVOiGisfKFZ+JFuscTtHQEgoHT1ufFzRjo1VBggFDCblKrCgLAs/urwQ0gB1UziOg9XpQ02nDTtrTXh1Vz3G6xS4ZUourhyphlBATwqEBEKJgMSdGqMdaw40YW+9GdMLVbh3ZiEKVNJBh3wYhkFGqhjTCzMwvTADHp8fh1u68NruBvx5ex3umVGIxeOyIRJSZRVCzkWJgMSNGqMdq/Y04FhbN64qVeO3i8dAJgleMXEwEpEAM4szMKNIhTNGOz6saMPq/Y148IpifG9mceQCJyTBUSIgMdfe7cLfd9VjX4MF88s0WLmoDBJR5D61MwyD0dlyjM6W44zRhrVft+DfX7fgkSuLccWITJpcJkmPEgGJmR6XD//c34RPjrdjTokav15UBlmImumRUKqR4/F5aai2OPHStlr8S96MR+eOxIScdF5fl5B4RomARJ3Pz+Hjija8sbcRE3LS8fQ1o6GUiaP2+gzDYFphBkpUMuxrMOOJ9VUYq1Pgf64sRqlGHrU4CIkXlAhIVB1otOCP22ogFQvx8JUjUJAhi1ksQgGDK0eqcVlhBnbWmvA/H1RiUq4C98woxHh6QiBJhBIBiYpmixN/+rIW1UYbbrwkB5fkpsfN2LxEJMD8Mg3mjFJjd50ZT2w4gZz0FNw6NQ/zSrIiOl9BSDyiREB4ZXP7sHpfEz45rsf8six8b+poiON0+aZEJED56CzMLVHjaGsX3j7Ugt9/UYN5pWosKNNgar6KkgIZligREF74OQ6bqgx4dVc9xmjlePqa0qjOAwyFUMBgWoEK0wpUMNk9ONTchb/srEer1YXxOQpMK1BivE6BUo0c6jRJrMMlZMgoEZCIq2jrxotbz4D1A/fPKkJxZoxqvnMcxB4rpC4DxN5uAAArlMIlzQbSCsPqQp0mwTVjNLhmjAY2tw81nXbUdjqw/YwJLVYnBAyD/AwpClQyFKhkyFNJka+UoSBDhkyqe0QSBCUCEjEdPS78dvNJHGyy4vqJOlxWqIrqGyHj90JlPgq1cT8yzIeQ3nUagB+eFA18olQADAR+F1LcZgj8XlhV42HUzYM+dyHc0uxB+5eniDA5T4nJeUoAvSUtul0+dNjcMNo8aOty4Xh7DzrtHuh7XGDAYFRWKsbr0nFpoRJT81VIHcIGOUL4QkXn4lwixOpj/XjvcCvePNiMy0dk4toxmoC1gPjA+L3I6tiDnNYt0Bh2wS3VoFs5Fj3ppbCnFcEnUQb8PrnQBXFHFZSWSmSYD8Osno7a0fejO2NiROLiOA49bh9arC7Umxyo6bSjwezAtHwVrp+ow5Wj1BCFWfsoEX4GvkWx8oPvonOUCOJcvMd6tKULz35eDblEhLuuKIZCGJ0nAHl3DfIbP0Buy2a4ZFqY1ZfCop4KryS8A45kMgmcTg8AQMC6epNJ239hVU3E6fFPwSEPb+joQjg8LI61dWFfvQVdLi/unlGI6yfoBq19FO8/A+eiWPlBieA8lAjig83tw8vb67CrzoTvXpKDqflKKBRS2Gxu3l6T8fuQrd+K4rq1SLU1ojP7CnRmXxHWsM75zk0EZ/v3Qtv+OXLaPkP9yDtRX3ovOAE/E9y1nXZsqjLA6WXx8wWlmJqvCto2Xn8GAqFY+UGJ4DyUCGJvX4MZK/9bjfE6BW6YqOsrDCeXp/CSCETeHuQ3fojiun/DLVGjQzcP1swp4AQXP8UVKBF8S+I2oajubQhZB45N+wPsilEX/TqhcByHwy1dWHe0HYvHafHw7OKAS2uD/gxwHOD3AGAAYXysXorHn9dgki1WOo+ARITb58fLO2rx5ZlO/ODSfIzRBv/BigSJqxPFdf9GQeMH6FJOQO3oB2CX83+sqSdFjTNjliOrYxdm7L4TZ8YsR3Px94AIT3wzTO8y1dEaOdZ+3YKH3q/AH64fh4zUwG/qjL0DKY1fQNy8GyJjJYS2NoBjAY4DJ04DqyyGN3cG3CXXwaedGvF4yfBFTwRxLl5ibe1y4on1J6CUiXD7tDykSQZ+hojUE0GKU4+RZ/6J3JaNMGXNgD73GnikmiH3e65QTwTnkjrbMfLMatjlI1A55XfwifkpPeHnOGw8bsDR1i68dssk5Cm/Kb3h9yGjYzv8+1dDZDwKX/YU+LLGw5cxCv40LSCSAhwHxtMDQU8LxMYqiNsPgGOEcEx/FO7SZYAgeiuV4uXnNRzJFisNDZ0n2X4AhurrJit+sekk5pdpUF6qDrokdKiJIMWpx6jqfyCndTOM2bNhyF0Ar0R10f2FEm4iAHrnDvIb10FlPY6j015CV+YlvMQEANtrOvHF6U6surEMZYZPkHr4VTCpGXAWXA1v7mXhDQFxHETGSkhPfwiOEcB21YvwZfMX87ni4ec1XMkWKyWC8yTbD8C5GHsHZFVrIW47AIFdD04kBZtRCm/e5XCPvBacTN2v/f+dMOClL2txz4xCjNGGrsx5sYng/ASgz10In4Tfom8Xkgi+pTIdRnHdWjSMuhN1pfcCTOQ/aTN+LzyH38LMtjWQaUaAG3sjZIWTYLO5LrwzjoO4eSdkJ96BY/L9cE59GGD4LZGRzL9bfKI5AhIZHAfZ4b8h9fDf4cmbBU/+FfCnasCwbgi7m5FSsxFpe34Lb/4sOCffD2/ODHxU0Y439jbi0bkjkaeURjwkqbMdI6tX9yWAysm/4z0BDIVVPRUn5EUYUbMGGsNOVE55LnLLTDkWuS2bUXLqb3CnZGG79i58YcrAz1JH4qLrszIMvIVz4csaj7RDf4VYfwTd17wKiGNX8ZXEJ3oiiHMRiZX1QvH5wxBZamC/9DFwqVmB23mdkDTvQkr9/8HEqfCc4zpMnXMzstPDSwLhPhGk2hox8sxqaNu/gFE7G/qca6KeAC7miaAP54e2/Qvktm5B/ai70DDqh/ALUy6yLxY5rZ+i5PTfwQpT0FpwPXqUYwAAu+vMMNo8WHHdOLhdFxnrt1gvZMf+AYHThK7vvANOGt5+iwuVdL9bUUJDQ+ehRHCBOA7y7T+DyHQS9sseD2uMuaLFiqqvP8ftsoMQiMSoK70P+tyFg66pD5kIOA6Zpq9QVPtvZJgPo0N3FTp05fCJ+V15FMyQEsE3UlwdyG/8EKmOZtSOfhCt+d8BF+YyTpG3G7nNn6C49i34xHK05y1Bl2p8v5U+fg74v5Md0ChScMfUvKEvAuI4SE+8C5HpJKzX/yf4B4IhSKrfrSiiRHAeSgQXRnr8LciOvg7blb8GxIMXf2u2OPHnHXW4foIOOQoJlNZK6No+h9RlQHPhd9FWsBQOeXHA7w2UCFJtTdC1/h/ymtcDADp082DSzLr4T9AREolE8C15dzVyWrcgzd6M9rxF6NBdBWvGJWBF5/x9cxxkjlZkmA8jW78NWR17Yc2YiA5dOWyKkqBLPT0shw+OtuGqEjXmlUbgjZvjID31PkSdVbAu+xBcSuASHBcrmX63ookSwXkoEYRPYGtDxnsLYLvyV/Ar8gdtb/ewePazaswsyhgwMSyztyCrYzfUpoPwiFUwZc+CVTURDnkRPClq+BkRFFIOPnMb5LY6KC2VyDR9BbG3B+bMKTBrZsImHxU3a9sjmQi+leI0QN15AOldJ5Fmq4dPnA6fKBUMx0LiNoMVymBTlKBbNQ6WzClhPw05/cC/9jfif+eMRHFmBMb3OQ7Syn9BaDfAesN/epegRkiy/G5FGyWC81AiCF/65rvBSTPgGnPToG05Dvj7nnqIGQHmlapDNPQjzVYPRddppDqakeLuhNjTBYbzA0IJPCIFnDIdnKl56EkvgyOtgPeVKheDj0TQD+eHxGOFgHX1TtqKlf2fEC6ATCbB0UYz9jdY8PQ1o/t2cg81vtRDf4M/RYmeha9F7N8oWX63oi1hVw39/Oc/x/bt26FWq7Fp06YB9zmOw7PPPosdO3ZAKpXihRdewPjx4/kKJ+mI2g5CZDyOnvKXwmq/r8EMfZcbt03LC92QEcCuGBWw7ALvb66JhBHAk5IZse7KsuVosbrw7uFW3DMzAiuVGAEcUx6EfO+zSD3wEhwznxp6nyRh8fZR7cYbb8Tq1auD3t+5cycaGhrw2Wef4be//S1+/etf8xVKUkr76k9wl34HEA5eNM3i8GLdsXYsHJMddmlkEn2zR6lR02nHoaauyHQolMA+/ceQnnwPkrr/RqZPkpB4SwTTp0+HUhl8Imrr1q244YYbwDAMJk+ejO7ubnR0dPAVTlIR6Q9BaK6Gp3BuWO3XHW3DBJ0C2Yr4KFxGApMIGSwck413D7egy+mNSJ+cVAXH9Meg2PYEhNa6iPRJEk/MNpQZDAbodLq+r3U6HQwGA7KzQ5cUFgoZqFRDO/pQKBQMuY9ouZhYhZ+/Dm78MsjTQ+8EBoATbd2oNTnwo9nFkAiHNvbMMAxkssRIJoka60iZBJO7XHj3SBt+smB0ZE6Ak08A57wNGZ/dD9/dW4e04Wy4/27FCt+xJtzOYpblaLI4BMbegcyGXehZ8FdgkLIEfg54c289rhyZCdbDwgl2SLEm0hxBIsc6LS8d7x5qw9bjeswcEaGNYTnzkNp2HOymp2C76vcX3c1w/t2KJb4ni2O2nEOr1UKv1/d9rdfrodVqYxXOsCE9+R94c2eGtWfgUJMVAFCalcZzVCSShAIGC8Zk4YNjbehy+iLTKcPAccm9kDRupfmCJBSzRFBeXo7169eD4zgcPXoUCoVi0GEhMgjOD1nVWniKrhq0KctyWH9cj1kjMuNlaT+5AFpFCsbrFHjnUEvkOhWnwjHtESi+/CkEdkPk+iVxj7ehoccffxwHDx6ExWLBnDlzsHz5cvh8vZ9ebrvtNsydOxc7duzAggULIJPJ8Nxzz/EVStIQtX8NTigGqxr8RK2vmqxIkwhRmEEFyBLVzOIMvP11Cw43d2FqQWR2CLOZo+EpugrybY+j+7q1cbMBkPCLt0Twpz/9KeR9hmHwq1/9iq+XT0rSMxt6h4UG+eX1c8B/T3Vg1ojIrXMn0ScSMJg/WoN3D7eiTCtHWiQ2mgFwld0I+a4VkJ54B67xd0SkTxLf4m/LJ7k4fhYptZt6E8Egjrd1gwNQRE8DCS9PJcWorFR8cKQ1cp0KRHBMeQhp+56HoDuCQ08kblEiGCbE7QfhT1HCr8gdtO1npzswLV9JT/3DxJUjMnHSYMNJvS1iffrTC+AetRiKbY/31h8hwxolgmEipWYjvDmXDdqurcsFfbcHpRpaKTRcSEQCXFWahbe+aobb549Yv+6SpRA4jJCefC9ifZL4RIlgOOA4SBq+gDfn0kGb7qgxYXyOHEIqJTGsjFSnQpcuxccV7ZHrVCCEY/KPkLb3WQjs+sHbk4RFiWAYEFpqAL8PfkVByHYurx8HmyyYmBO/x0GSize3JBNfN3Wh1miPWJ9+ZTE8xVdDvuOXEeuTxB9KBMOApHErfNrJg64WOtJiRW66FOnShNtQTsIgEwsxtyQTbx5shieCQ0Su0csgMh6HpO7TiPVJ4gslgmFAUv85vNmTB223t94y4MAZMryUZcuRmSbB+soIDuUIJXBech/kO34BxtMTuX5J3KBEkOAYTw/Exkr4NBNCtjPbPWjpcmIUlZMY9spL1TjYaEV1R+RWEfk04+HTTEDq/hcj1ieJH5QIEpy47QB8maWDHjd4oNGK0Ro5nTeQBGRiIeaPzsKaA81weoZWSPBcrnG3QXpmPUTGyoj1SeIDJYIEJ27ZDZ967KDt9jfQsFAyGZmVisIMGd4+1BqxbQBcSjpcY2+D/MunAH/kEgyJPUoECU7SvBu+rNBHfLZ1ueDwsshJj9wh5ST+zR6lRr3ZgX0N5oj16SmcA3B+SKvejlifJPYoESQwxmWBoKcJbEboInOHmq0ozUoDjQolF4mQweJx2Vh3rB1tXaHPpggbI4Bz4t1IO/gHMI7OyPRJYo4SQQITt+4Dqx4LCEIvBz3U3EU7iZOUJk2CK0dk4rXdDRGbL/ArC+HJvxJpe38Xkf5I7FEiSGCSlj2Dzg/ou92wuVnkKGlYKFlNyFEgVynF/zvQBH+Ethe4yr6LlKbtELV/HZkOSUxRIkhg4rb9gyaCY61dKMlKpWGhJDevRI0ulw8fVrRFpkNxKpzjb4dix89o4ngYoESQoBh3N4TdTWBVI0K2O9rajRHqxDigm/BHKGCwZFw2jrR0YVu1MSJ9evOuACcQQ1q1NiL9kdihRJCgRIbD8GWUhJwfsLlZtHW5UEDnDhD07i9YNikH/z1pxP76CKwkYhg4J9yFtIMvgXFGbmUSiT5KBAlK3P4V2IySkG2Ot3ejMENGm8hIH6VUhBsm6bDumB57I5AM/MpCePJmIW3/CxGIjsQKJYIE1bujuCxkm2OtXSjOpGEh0l9WmgQ3XaLD+go9Pj9tHPKGM3fZTUip+y/tOE5glAgSkd8HcUcF2MzRQZuwfuCkwUbzAySgzDQJbpmSi501Jrz9dQu87MVnA06SBteYWyDf8Qs6zSxBUSJIQCLTSfhTs8BJgpeMaDA7kC4VQ54SmQPNyfCTLhXhlsm50Pe48eLWMzD0eC66L0/RPDAeG5iqDyMYIYkWSgQJSGQ4Cl9Gacg2J76ZHyAklBSxAEvHa1GSlYYXvjiDT092XNzTASOAc8IPINy6AvA6Ih8o4RUlggQk0h8adNnocb0NRZmUCMjgGAaYkq/EbVNzUdHWjV9tOYV99Wb4LjAhsOox4DRjkXrorzxFSvhCiSABiQ1HQq4YsntYtHc7kUe7ickFUMnEuH6iDuWjs7C9xoRfbD6J9ZV66LvcYffhn/x9yCr/BUF3C4+RkkijMwsTDOOxQdjTCja9MGib0wYb8lW0bJRcnMIMGQozZDDaPKhq78FL22shEwkwTqfAaI0cxWoZMlMlgU9GTdPAPWoR0vb8Bj2L/hH12MnFoUSQYETGSvhUI0NuJDtpsCFPScNCZGg0cgnmlaoxp0SNjh43mixOfFnTCf1hN3x+P3LSpdClpyAnXYpsuQTZihSMkEngHnUdFNt+AlHbQfhyL4v1H4OEgRJBghEZjg46P3C6w4b5o7OiFBEZ7gQMoEtPgS49pe+a3cPCZPfA7PCi0ezAsbYuWBxedLl8yJSJMV96NWb+96c4Mv9DTMhVIUVEo9DxjNdEsHPnTjz77LPw+/24+eabcf/99/e739bWhp/+9Kfo6ekBy7J44oknMHfuXD5DSnhi/aHeoymD6HL60O3yIlueErQNIUOVJhEiTSIbsDJNkiJCq8kBo00Jb/M+HPv0H3jMcQUm5qZjXkkW5pdlITNVEqOoSTC8JQKWZbFy5UqsWbMGWq0WN910E8rLy1FScnaS87XXXsOiRYtw++23o6amBvfffz+2bdvGV0jDgshYCffIa4Perzb2zg8I6AMYiQGhQACNXAKNXIKutDvwaPXrGLvodhw3+bGr1oRXd9djWr4St03Lw6UFKjABJxpItPGWCCoqKlBUVISCggIAwJIlS7B169Z+iYBhGNhsNgBAT08PsrOz+QpnWGBcFjAuC/xyXdA2p/Q2Wi1E4oJdMQq29FKMbfw3JGMextR8JVxeFgebrPjdZ2eglIqwfM4ITC/MiHWoSY+3RGAwGKDTnX3D0mq1qKio6NfmkUcewb333ou1a9fC6XRizZo1g/YrFDJQqYZWNkEoFAy5j2g5N1am/itAXQK5Injs1Z12XH9JDmSy6D9+MwwTk9e9GBQrP86PtbP0eyj5agUs426HJ1UHOYDFGam4dmIODjSY8ZtPqzE+Jx2/+c546KJ8pnaivg/wIaaTxZs3b8ayZctwzz334MiRI3jqqaewadMmCEKMa7AsB6t1aDsXVarUIfcRLefGKqv/GiJ5AVy2wOfPdjl9sLm8kIsEcDovvlzAxZLJJDF53YtBsfLj/FidSEdH9mzkHnoJx6c826/txGw5xiwoxaenjLjur7vxZHkJFo6N3qhAor4PXCyNRhH0Hm8jyVqtFnq9vu9rg8EArVbbr826deuwaNEiAMCUKVPgdrthsVj4CinhiTqOglUGXzFUY7QjTyWl08hIXGnPW4Rsww4ouk4NuCcWCnDdeC0enj0Cf91Vj+c/PwMfG6HzNEnYeEsEEydORENDA5qbm+HxeLB582aUl5f3a5OTk4N9+/YBAGpra+F2u5GZmclXSAlPbKwMuXS02miL+uM1IYNhRaloy1uCsqo/BG1TmCHDz64uQU2nHY9+dBx2jy+KERLeEoFIJMKKFStw3333YfHixVi0aBFKS0vxyiuvYOvWrQCAn/3sZ3j//ffxne98B48//jheeOEFWkUQBOPpgcBhhF+eG7TNGaMN+TRRTOKQUTsXafYmqDv2BG0jkwjxwKwipIgE+J8PKmFzUzKIFobjEquAuNfLJuUcgbhtP+Q7n4Ft9m8CtnN6WPx04wk8dEUxhDEaG0rksex4NlxizTB9DV3bZ9gz70OACV4eneM4/OdIGzrtHrx28yRIxfyUUk/E94GhiMkcAYkskbEKvvSioPdrTQ7o0qUxSwKEDMaSOQ0cI0Buy+aQ7RiGwS1TcqFIEeEXm06C9SfUZ9WERIkgQQiNlfCnFwS9X9NpR0467SYmcYxh0FJ4I0pP/gUCNnRFUwHD4I5peei0e/CXnXVRCjB5USJIEOLOKrDK4qD3a4x25NJEMYlztvTRcKbmorD+3UHbioQC3DuzEJ+dMuLLM51RiC55USJIBKwXQmtd0NLTrB9osjj6FQUjJF61Fi7DyJp/QuTtGbStPEWEe2cW4tnPqqHvDrx/hgwdJYIEILTWwJ+aDYgCv9G3WZ1Il4oh42lSjZBIcqbmoUs1HsU1g1cSAIAR6lRcVZqF3/z3NBJsbUvCoESQAESDDAvVmh00P0ASSmv+d1DU8C4kblNY7ReUaWB2ePHhsXaeI0tOlAgSgMhYBTbURLHRDp2C5gdI4vBIs9CZNRMjq98Iq71QwOD7l+Zj1Z4GmB2JsZQ2kVAiSAAiYyVYZfClo3WdduQo6YmAJBZ93mLkNX8CqSO8T/m5SikuK8zAX3bQKqJIo0QQ7zgOItMpsEH2EHS7fHB4WTrsgyQcr0SJDt1cjKp+LezvWTw+G3vrLTihH3yimYSPEkG8s3cA4MBJA9dsrzc5kJNOheZIYtLnXANd+xeQ2ZvCai8TC7FobDb+SnsLIiqsRPDII49g+/bt8PupKmC0MR1VvU8DQWow1ZsdyFbQ0wBJTKxYDoPuKpSc/nvY33PFyEy0WF040EiViiMlrERw++23Y+PGjbjmmmvw0ksvoa6OsnG09CaC4BPFdZ00UUwSmyFnATSGnUiz1YfVXihgsGS8Fn/fVU/LSSMkrEQwa9Ys/PGPf8THH3+MvLw83H333bj11lvx4Ycfwuv18h1jUmMMx+FXBE4Efg5osjhp6ShJaKwoFYac+Rh1Ovy5gmn5SlidXnzdbOUvsCQS9hyBxWLBRx99hA8++ABjx47FnXfeiRMnTuCee+7hM76kxxiOg1UG3lHc0e2GVCRAqoQ2kpHE1qErR1bH7rCfCgQCBvPLNFi9L7y5BRJaWIng4Ycfxh133AGXy4VVq1Zh1apVWLx4MZ555hnY7Xa+Y0xerBew1IMN8kRQb7Yjh84fIMPAt08FI0+vCvt7ZhRloMniRBWtIBqysBLBLbfcgi1btuCBBx5AdnbvmaIeT++mjo8++oi/6JKc0FoHpGmClpaoMzmRLadhITI8dOjKoenYhVRbeJ/yhQIGc0ap8c7XLTxHNvyFlQhefvnlAde+973vRToWch6R+RQ4VfCNZA1mO3QKSgRkeGBFqejQXYWRZ14P+3uuGJmBPfVmGG2hy1qT0EShbhqNRhgMBrhcLpw4caJvht5ms8HpdEYlwGQm7DwJBFkx5GU56Hvc0FAiIMOIQXc1Jh35JWrK2uBKDX4s67fSJCJML1Thg6Nt+J8rg5/nTUILmQh2796Njz76CHq9Hs8//3zf9bS0NDz++OO8B5fsRJ1V4IpnBLzX2uWCSiaBREg7ycjwwYrlMGpnY0TN/8PJSU+H9T1zRqnxt131uP/yIoiEtEf2YoRMBMuWLcOyZcvw6aefYuHChdGKiXxDZK4GN/mWgPcazA7oaCMZGYYMOQsw4egzqC17CJ4U9aDtc5VSZKVJsLvOjHmlWVGIcPgJmQg2bNiA66+/Hq2trVizZmDt8Lvvvpu3wJId47FB4OwEK9cBjoF7Neo77cimYSEyDHklSpiyLkNR7b9xZtyPw/qey0dkYN2xdkoEFynkc9S38wAOhwN2u33Af4Q/QnN174lkgsB7BBrNTpooJsOWIfcaFDR+AKHXFlb7afkqVLV30ylmFynkE8Gtt94KoLfWEIkukfkU2PQCBEoDLq8fJqcHWWk0NESGJ7c0G93K8ShoXIeGkh8O2l4iEmBagQpbThhwz8zgK+1IYGHNrLz44ouw2Wzwer246667MHPmTGzYsIHv2JKasPME/PLAqyZarE5o0iQQUslRMozpc69Bce2bYPzhlbGZXqTCpqoOqj90EcJKBHv27IFcLsf27duRl5eHzz//HP/85z/5ji2piUwngx5W32B20EYyMuw55EVwyXKQ07olrPaj1Klw+1ic6ghvOImcFVYiYFkWALB9+3Zce+21UCgUvAZFAJH5TIhE4ISGEgFJAoac+RhRswYI41M+wzC4rEiFTVWGKEQ2vISVCObNm4drr70WVVVVuPzyy2E2m5GSMvgb0c6dO7Fw4UIsWLAAb7wR+GzSLVu2YPHixViyZAl+8pOfXFj0wxTj6AT83qCH0TSaHdBRxVGSBLpUEyBgXVB37g+r/fTCDHx+2gjWT8NDFyLkZPG3nnjiCdx3331QKBQQCoWQyWT4+99DHyTBsixWrlyJNWvWQKvV4qabbkJ5eTlKSkr62jQ0NOCNN97Au+++C6VSCZPJNLQ/zTAhMp8OehiN08Oiy+WloylJcmCYvqcCk+byQZtrFSlQSkU42tqFaQUq/uMbJsJKBABQV1eH1tbWvmEiALjhhhuCtq+oqEBRUREKCnpLJCxZsgRbt27tlwjef/993HHHHVAqlQAAtXrwzSPJQGg+DVaRH/Bes7V3WIg2UJJkYdJcjvym9Uiz1cMuH7yMxOQ8JT471UGJ4AKElQiefPJJNDc3Y8yYMRAKexc0MgwTMhEYDAbodLq+r7VaLSoqKvq1aWhoANC7TNXv9+ORRx7BnDlzQsYiFDJQqVLDCTtEH4Ih98EnQc8ZIKsYIrkUAgEDufxsqWl9vQU5Khlksvh7ImAYJi7jCoRi5Qc/sUpgyZ+HkqZ3UHvZykFbzy7T4HdbTuHZG6UhS07E+/vAufiONaxEcPz4cWzZsgVMkHNzLxbLsmhsbMRbb70FvV6P73//+9i4cSPS09NDfA8Hq9UxpNdVqVKH3AefVG0VcI1eBtbmglwuhc12dpPM6fZuqNMkcDo9MYwwMJksPuMKhGLlB1+xtqlnY8LRX6Oq5BH4JMqQbdMEDFRSMb6sasf0wsDzbED8vw+cKxKxajTBF/mENcBQWloKo9F4QS+q1Wqh1+v7vjYYDNBqtQPalJeXQywWo6CgAMXFxX1PCUmL4yC01MAfpOpok8UJLU0UkyTjlWSgK2Mi8prWh9V+Um46tp3p5DeoYSSsRGCxWLBkyRLce++9ePDBB/v+C2XixIloaGhAc3MzPB4PNm/ejPLy8n5t5s+fj4MHDwIAzGYzGhoa+uYUkpXA1gaIpOAkA7N330RxggwTEBJJHbp5KKp/B+D8g7adnJ+O7WdMtLksTGENDS1fvvzCOxaJsGLFCtx3331gWRbf/e53UVpaildeeQUTJkzA1VdfjdmzZ2PPnj1YvHgxhEIhnnrqKWRkBH+USwYi06mg+wdoopgkM5t8FPzCFGR17EGndnbItjnpUkiEDE4YbBivo31Pg2G4MFNma2srGhsbMWvWLDidTrAsC7lcznd8A3i97LCeI5Ad/jtEHRVwTbwTAPrNEXx+2ohaox3lo+OzwiKNZfODYj0ry7ALiu5qHLp88FPM1lfqoVWk4JHZgVcaxfP7wPniYo7g/fffx//+7/9ixYoVAHrH+x9++OEhBUUCE3WegD898NLRBpODSk+TpGbKmgGVtRIy++DnFF+Sm44vaZ4gLGElgrfffhvvvvtu3xNAcXExzGYzr4Elq97NZIGHhposTmgpEZAkxgkl6My6HPmNHwzatihThi6XFy1WOlZ3MGElAolEAonk7ASlz+fjLaCk5mchtNYF3Ezm9LCw0o5iQmDUzUF+00eDViUVMAwm6tKxu44+tA4mrEQwffp0rFq1Ci6XC3v27MGjjz46YAUQGTphdyP8MjUgkg6412x1IjuNJooJccly4JLlQtu+ddC2E3IV2F5Dw0ODCett5YknnkBmZiZGjx6N//znP5g7dy4ee+wxnkNLPkJT72E0gTRZnNDQGcWEAACM2itR0PD+oO3GZMtxQt8Dm5tGMUIJa/moQCDA/PnzMX/+fGRmZvIdU9ISmU7BL88LeK/B7KQzCAj5hiVzKgrr34XM3gRnWuA5NQCQioUo1aThQKMFV4/WRDHCxBLyiYDjOPz1r3/FjBkzcO211+Laa6/FzJkz8be//S1a8SUVUecJsEFWDDWaHTRRTMg3OIG4txhd44eDth2TraB5gkGETARvvvkmDh8+jHXr1uHgwYM4ePAgPvjgAxw5cgRvvvlmlEJMHr1VRwcODbm8NFFMyPmM2bOR3/QxGH/oYZ/xOQrsqzfTLuMQQiaCDRs24I9//GO/sg8FBQX4wx/+gPXr1/MdW3LxuSC0tcKvGDg01Gx1fXNGcQziIiROuVJz4ZZmIatjd8h2WkUKREIBzhjtUYos8YR8a/H5fAHnBDIzM2kJaYSJLDVg5bmAYOC0TSOdUUxIQCbNLOQ3rhu03TitHHvraXgomJCJQCwWX9Q9cuGE5lPwBxgWAoBGOqOYkIBM6ulQm76CxBV6iei4HAV20TxBUCFXDZ06dQpTp04dcJ3jOHg8iVH7JFGIOk+CDTAsBACNFifKsqNf14mQeOcXyWDJnIrclk1oKPlh0HZlGjn+ub8JNrcP8pSwD2ZMGiH/Rk6ePBmtOJKeqPMEPHkDz2R1eVhYnB6o02iimJBAOr9ZPdQw6q6A53wDgEQkwCh1Gg41d2FuCR2Jez6afowTQnM1/AFqDDWaHciiiWJCgupJHw2xrweK7lMh25Vlp2FfAw0PBUJvL3GAcVkh8HTDnzqwvHS9yU4TxYSEwgi+eSr4KGSzcToF9jVYohRUYqFEEAd6K44WAczAf45aox3ZchoWIiQUk+Zy5LRuCVmILk8phd3jo2qkAVAiiAOhagzVd9qRrRhYhI4QcpZbmg2XTIesjj1B2zAMg3FaBQ400lPB+SgRxAFR54mApafdPj9Mdjey0mipLiGDMWXNQF7z+pBtyrLl2FdPieB8lAjigKizCqyyaMD1ZosT2QophILAKyEIIWeZs6Yjq2MvRN7uoG3GaOU43NIF1k/lJs5FiSDWOD+EljMBVww1mB3QpdNEMSHhYEVp6FKNh67ts6BtVDIxlDIRTnXYohhZ/KNEEGOCnhZw4lRwkoEbxhrMTujSaX6AkHCZsy5DbvMnIduUaeQ4SPME/VAiiDFR50n404sD3ms0O5CrpERASLisGZOg6D6DFKc+aJsxWjn2Ud2hfigRxJjIdCJgaQmnh0WXyws17SEgJGycQAyzehpyWrYEbVOqScNJgw1ODxvFyOIbJYIYExmrwAaYH2i29haao4liQi6MOesy5LUEHx6SioUozJTh6yYaHvoWJYIYE5pOglUGmih2QktPA4RcsJ700ZB4rEjrqQ3aZrQmDXvpUPs+lAhiyeuA0K6HX5474Fa9yY5sOpqSkAvHCGBWX4qcls1Bm4zJVmB3rSmKQcU3XhPBzp07sXDhQixYsABvvPFG0HaffvopysrKUFlZyWc4cUf07Y7igIfROKFTUGkJQi6GKesy5LZsAoIcT1mcKUOT2QGrM3hJimTCWyJgWRYrV67E6tWrsXnzZmzatAk1NTUD2tlsNvz73//GJZdcwlcocav3sPqBG8l6XD7YPSxUdEYxIRfFkdb7e6W0Hg94XyQUYIxOga+brFGMKn7xlggqKipQVFSEgoICSCQSLFmyBFu3bh3Q7pVXXsGPfvQjpKQk3zCIyHg8YI2hRosTuvQU0DwxIReJYWDOmo6clk1Bm4zRUd2hb/F2VI/BYIBOp+v7WqvVoqKiol+bqqoq6PV6zJs3D//85z/D6lcoZKBSpQ4pNqFQMOQ+IkFoOQH/hJsgkfffK9Da04ncjFTIZBIwDAOZLDGeDChWflCsF8eRdwWKj76IlhnPAALhgPsT85R4dXttXLwXDIbv96yYndnm9/vxwgsv4Pnnn7+g72NZDlarY0ivrVKlDrmPIeP8yDKegl2cA87m6nfrdHsPRmalwun0QCaTwOlMjGNBKVZ+UKwXxynIgkekgKRpL8xZlw24n6eSotvhxckmM3LifAd/JN6zNBpF0Hu8DQ1ptVro9Wd39xkMBmi12r6v7XY7qqurceedd6K8vBxHjx7FQw89lDQTxsKuBvhT0sFJ0vpd5zigyeKAjlYMETJk5sxpQVcPCRgGY7RyfNVojW5QcYi3RDBx4kQ0NDSgubkZHo8HmzdvRnl5ed99hUKBAwcOYNu2bdi2bRsmT56M1157DRMnTuQrpLgi7DwBVlk84LrZ4QEHQEEHbBMyZOasy6Bt/yLogTWlmjTsp3kC/hKBSCTCihUrcN9992Hx4sVYtGgRSktL8corrwScNE42IuNx+BUDJ4rrTU7kpEuDncFNCLkAHmkW3NJsqDsPBLw/RivH101WcEGWmSYLXj92zp07F3Pnzu137dFHHw3Y9q233uIzlLgj7jgGT97lA67Xmew0LERIBH27uawz+8oB9zTyFIiFDGpNDpRkpQX47uRAO4tjgeMg6jwOVjVywK26TjqDgJBIMqsvRbZ+Oxg28CT2mGw5vkry/QSUCGJAYG8HAHDSjH7XfSyH1m4nPREQEkHelAw40vKh6dgV8P5oKktNiSAWRMZvngbOmwho6XJBJRVDIqJ/FkIiyaK+FDmtgUtTj8mW41hrN3ysP8pRxQ96x4kBUUdlwNIS9SY7DQsRwgNz5jRoOnZD4HMOuCdPEUEjl6BK3xODyOIDJYIYEHUcDbh0tK6T9g8QwgefJB02+ShoOnYGvF+WLU/qchOUCGJA1FkVcKK41mRHDh1NSQgvzOqpvRVJAxijlWN/AyUCEiUCuwGMzwV/qqbf9S6nDw4Pi0yqOEoILyyZU6E2HoDQaxtwryQrDWc67bB7fDGILPYoEUSZqOMY2IzSARPFdSY7cpVSqjhKCE9YsRzdyjJk678ccE8iEmCkOhWHmrtiEFnsUSKIMpHhCFjViAHXaztpIxkhfLOoL0Vua+DaQ6M1yTs8RIkgysT6w/AFmB84Y+x9IiCE8MeSMRkZpsMQewZ+8h+rlWN/Q3LuJ6BEEE0cB5GxEmxGSb/LXpZDW7cLujgvhUtIovOLZOhSTUB2+xcD7hVkyNDl9EHf7QrwncMbJYIoEnQ1gBNJwUlV/a43mR1Qp0ogEdIEASF8M6svRW6A0tTflqVOxmWklAiiSNxxDGzGqAHXzxjtyKNhIUKiwpoxCcquKoidxgH3xmjl2FOXfMNDlAiiSKQ/BFY5cH7gtNFG8wOERAknlMCSMRlZTf834N44nQJfN3eB9SdXWWpKBFEk1n8NX2Zpv2t+P1BvctATASFRZM6ajuz6DQOuq2RiqGRinEiychOUCKLF54TIfAasqv/QUIvVCXmKCKmSgYdrE0L40a0cB6mtETJH64B7Y7Vy7Euy1UOUCKKkt9BcISDqv1fgTCfNDxASbZxAhK7sy5DTMrAi6TidAruTbJ6AEkGUiPWH4Dtv2SgAVHfYqL4QITHQpZ2J3JZPgPOOqSzJSkWj2QmLI/BBNsMRJYIoEbcfBHv+/ADXu2KoQCmLUVSEJC+HshQinx3y7up+10VCAcZo5diXRLuMKRFEA8f17ijOHN3vcqvVCZlYAIWU5gcIiTpGALN6OnJbNg64NVYrT6rhIUoEUSDoagAYBpwsq9/1Ux02FKjoaYCQWDFpZvaWpubYftcn5ChwoMGSNMtIKRFEgaTtAHxZ4wZUHD2ptyFPRfMDhMSKMzUPPrECmZ1f9buekSqBKlWM4+3dMYosuigRRIG4dQ98mWX9rrEsh9pOOwoz6ImAkFgyZc1AXvPAPQUTchTYXmOKQUTRR4kgCsRtB+DLGtvvWoPZAaVMDJmY5gcIiSVz1mXQ6rdB6HP0uz4xJx07aykRkAgQ9LSC8Tnhl+f1u35C30NPA4TEAa9EhR5FKbLbt/a7XpQpQ7fLh2bLwAPvhxtKBDwTt+2DTz1wfqBS34PiTEoEhMQDk2Ym8ps+6ndNwDCYlKNIiqcCXhPBzp07sXDhQixYsABvvPHGgPtr1qzB4sWLsXTpUtx1111obR243TvRiVv2DFg2anOz0He7qNAcIXHCkjkF6d2nIXW09bs+ITcd2850xiiq6OEtEbAsi5UrV2L16tXYvHkzNm3ahJqamn5txo4diw8//BAbN27EwoUL8Yc//IGvcGKD4yBp3gVf9qR+l08aeoeFRHRAMSFxgROIYVJPHzBpPFYrR02nHSb78N5lzFsiqKioQFFREQoKCiCRSLBkyRJs3dp/DG7mzJmQyXqHRyZPngy9Xs9XODEhtNYBHAu/PLff9ar2bto/QEicMWXP6h0e4vx918RCASboFNgxzIeHeEsEBoMBOp2u72utVguDwRC0/bp16zBnzhy+wokJccsu+DST+s0P+DnguN6GEerUGEZGCDmfPa0YrCAF6s4D/a5fkpeOL04PPMRmOBHFOgAA2LBhA44fP461a9cO2lYoZKBSDe1NVCgUDLmPsF6nbSe4/MmQy8/OBdR02JAqESInMy2sPhiGgUwm4SvEiKJY+UGx8iNQrF15c1Hc8iHcI+b1XZtRkoW3D7WCSRFDKRNHN8hv8P2exVsi0Gq1/YZ6DAYDtFrtgHZ79+7FqlWrsHbtWkgkg/8AsSwHq9UxaLtQVKrUIfcxKL8P6sa9sJXeDM529jDs/TWdKM6QwekMb8xRJpOE3TbWKFZ+UKz8CBSrXjUdl9T9FG6THt6UjL7rY7VybPi6Gd+ZqDu/m6iIxHuWRqMIeo+3oaGJEyeioaEBzc3N8Hg82Lx5M8rLy/u1OXHiBFasWIHXXnsNarWar1BiQqz/Gv40HbgUZb/rR1u7MDKLhoUIiUesKBWWzCnIa/q43/Wp+UpsORl8aDvR8ZYIRCIRVqxYgfvuuw+LFy/GokWLUFpaildeeaVv0vjFF1+Ew+HAo48+iuuvvx4PPvggX+FEnaTuM/h0U/pdM9o86HH7oFPQslFC4lWHdh6KGt7tN2k8MScdJw22Ybt6iNc5grlz52Lu3Ln9rj366KN9///mm2/y+fIxJWn4DM7JD/S7dqSlCyPVqaBVo4TEL7t8BFihDFkde9CpnQ0AkIgEmJSTjq3VRtwyJW+QHhIP7SzmgdBaB4G7G6xqRL/rXzVZMDpbHqOoCCFhYRh0aOeiqK7/4pVphUpsqhqew0OUCHggadgKr24awJz96zXaPDA5vMin08gIiXumrBlQWquQamvouzZOq0B7txsNJp4XmsQAJQIepNRuglc3td+1Q01WlGalQUh/44TEPU4ogVE7G8W1b/VdEwoYXFaowsaq4bXxFaBEEHECWzuE5urejWTnONhkQakmvL0DhJDY69DNQ07rFog8XX3XZhZnYHOVYdidXEaJIMJSarfAmzMdEJ7deNJidcLmYWlYiJAE4pVkwJp5CQob3uu7lquUQiUTY1/D8DrPmBJBhKVUfwxvzmX9ru2tt2CMVg4B/W0TklD0uQtRVLcWAt/ZMwmuGJmJ94+0hfiuxENvTREk6GmF0FrXr9ooy3I42GjBeG3wXX2EkPjkTM2DXTES+edsMLu0QIXj7T1o7Ro+B9ZQIogg6an34cmfBQjObs84ru+GSiZGRmpsapQQQoamPXcRRtasBsP2biaTiASYUaTCh0fbYxxZ5FAiiBTOD+mJ9+AtnNfv8rZqEybkpscmJkLIkNkVI+GU5SK/6cO+a3NGqbHhuB5OLxvDyCKHEkGEiFv3gROmgFWe3USm73KjpcuJ0bRaiJCE1lrwHYyqfh0CtreAZLYiBaWaNGyoHB5PBZQIIkRatRaewjn9zh7YVtOJCTkKOomMkATnkBfDIS9GYd3bfdeuHp2FtV+3wjcMlpJSIogAga0dkqbt8Bacratkc7P4qsmCSTnKEN9JCEkULYXLMLLm/0HstgAARqrToJKJ8dmpjhhHNnSUCCJAVrEGnvzZ4CRnh4C2VhtRkpUGhVQYw8gIIZHikuXAnDUdJadf7bu2eFw2Xt/bmPBPBZQIhsrrgPTEO/CMurbvktPDYkeNCdMLVbGLixAScW35S5HT+l8ouk4BAMqy5VBKRdiS4MXoKBEMkazyX/BljYM/7ezJRV9UG1GcmQpVjI61I4TwwydWoKXwBow/9uu+8wquG6/Fqr0NcCXwCiJKBEPAeGxIPfIaXGXf7bvW5fRi25lOXF6cEeI7CSGJqjP7Sgj8HhTW95aeGJWVhuLMVLx5oDnGkV08SgRDIDv2D3g1E+FPL+i7tr5Sj/G6dChlvJ75QwiJFUaAhlF3ofT035BqawQALJukw/tHW9HW5Rrkm+MTJYKLJLC1QXZsNdznPA3UdTpQ2daDy2hugJBhzSXLQWv+dZh0+Ckwfi8yUyWYX6bB7z6tBscl3sQxJYKLJN+1Ap7iBfDLe+cGvCyHfx1sxtySTEjF9NdKyHDXoSuHXyBBWdVLAID5ozUwOTz4uCLxNpnRO9ZFkDR8AZHhKFyjb+i7tvG4HgqpEKM1dBQlIUmBEaC+5B7o2r9ATstmCAUMvn9pPl7d3YA6kz3W0V0QSgQXSGA3QLHtJ3BMeQgQSgAAlW3d2N9gwdWjNeduLCaEDHOsKA1nyh7G2MrnkNH5FXKVUtwwUYcnN5yA3eOLdXhho0RwIVgvFJ8vh6fwKrBZYwEA+m43/nWwGYvGZiNNQpvHCEk2zrR81JX+CFO++jHSLZWYNSITIzJT8dNPTsDH+mMdXlgoEYSL4yDf/lMwrKdvuajV6cVfdtRh1ohM5KmkMQ6QEBIr3apxaBh1Jy498BCU5mO4ZUouXF4/fvXf0wlxrCUlgnBwHNL2/g5i/SHYL/1fQCBEp82Dl7bVYlyOAhNy6NAZQpKdNXMy6kf9ENMO/A9y9Z/h3pmFaLE48fONJ+DxxfeTASWCwbBeyLf/FJLGbbDP+gUgkqLB5MAfttVgYo6ClooSQvp0ZUxC9djHMLbyBUw6+SIevjwX3W4fHnz/GIw2d6zDC4oSQQiCnlaoPv4uhOZq2Gb9Ej6RAp+fMuIvu+oxZ5QaU/KpsighpD+HvAhVk56BovsU5u6+GU+UGjFCnYo73jqML04b43KfAW1/DcTngqzyTaQe+ivco66Dq2QpTnU4sO5YNYQCBrdOyaU6QoSQoFixHLWjH0KG+RCmHvoJRqkm4MsJ9+CVnXX4uKIdy+eMwJg4Osec10Swc+dOPPvss/D7/bj55ptx//3397vv8Xjw1FNPoaqqCiqVCn/+85+Rn5/PZ0ghCewGpJx8H7LK/wdWOQKmmb/CV9ZUbN9aC7vbhxlFGSjLltMSUULI4BgGFvWlsKomIduwHTecfhzXpOZhm+AaPLNuHDKytLjpkhzMGaWGVBzbFYcMx9NzCsuyWLhwIdasWQOtVoubbroJf/rTn1BSUtLX5u2338bp06excuVKbN68GZ9//jlefvnlkP16vSysVseQYlOpUmG1OsC4LBAZqyBu/wqSpi8hNJ+GMXM6jqTMwL7uDNSb7CjIkGG8ToGRmWkQxGAgTSaTwOn0RP+FLwLFyg+KlR9Rj5VjkWE+ikzTV1BaKmGQFGGffxx2OorBZI9H8cgyjMtVoTRLDoW0/2f0b9+zhkKjCf4EwtsTQUVFBYqKilBQ0FuQbcmSJdi6dWu/RLBt2zY88sgjAICFCxdi5cqV4DgODE8fuZ2nPoV85y/BeDuhQe9mDw9EOO0vQJW/CCe4m8A6xFCndaFU4cbsUSkQC70A2w23kZeQBsVKRPAkyMYUipUfFCs/YhGrEwq0KcshVMxBpqMWVzhqsITdCpmpCzD1tunmUmHklLBAAacwHV5RGiBJg0OUAUx/EDPKRoR+kYvAWyIwGAzQ6c7W6NdqtaioqBjQJicnpzcQkQgKhQIWiwWZmZlB+xWLhSEzWygu8WxIR/WWjvVyQvjQ+zhWAqCUAZZdVK+EEDI0bgAMOIjgQzo4pAdp15GSB4068nMLSTVZLFVpAZUWACD+5j9CCEkU2Tz1y9uot1arhV6v7/vaYDBAq9UOaNPe3lupz+fzoaenBxkZdKALIYREE2+JYOLEiWhoaEBzczM8Hg82b96M8vLyfm3Ky8vx8ccfAwA+/fRTzJw5k7f5AUIIIYHxtmoIAHbs2IHnnnsOLMviu9/9Lh566CG88sormDBhAq6++mq43W48+eSTOHnyJJRKJf785z/3TS4TQgiJDl4TASGEkPhHJSYIISTJUSIghJAklxSJwGq14u6778Y111yDu+++G11dXQPanDx5Et/73vewZMkSLF26FFu2bIlqjDt37sTChQuxYMECvPHGGwPuezwePPbYY1iwYAFuvvlmtLS0RDW+cw0W65o1a7B48WIsXboUd911F1pbW2MQZa/BYv3Wp59+irKyMlRWVkYxuv7CiXXLli1YvHgxlixZgp/85CdRjvCswWJta2vDD37wA9xwww1YunQpduzYEYMogZ///Oe4/PLLcd111wW8z3Ecfve732HBggVYunQpqqqqohzhWYPF+sknn2Dp0qVYunQpbr31Vpw6dSpyL84lgd///vfc66+/znEcx73++uvciy++OKBNXV0dV19fz3Ecx+n1eu6KK67gurq6ohKfz+fjrr76aq6pqYlzu93c0qVLuTNnzvRrs3btWu6ZZ57hOI7jNm3axD366KNRie184cS6b98+zuFwcBzHcW+//XZcx8pxHNfT08Pdfvvt3M0338xVVFTEINLwYq2vr+euv/56zmq1chzHcZ2dnbEINaxYn376ae7tt9/mOI7jzpw5w1111VWxCJU7ePAgd/z4cW7JkiUB72/fvp279957Ob/fzx05coS76aabohzhWYPFeujQob5/++3bt0c01qR4Iti6dStuuOEGAMANN9yAL774YkCbESNGoLi4GEDv/obMzEyYzeaoxHduOQ6JRNJXjuNc27Ztw7JlvXufFy5ciH379sWknG04sc6cORMymQwAMHny5H77SaIpnFgB4JVXXsGPfvQjpKSkxCDKXuHE+v777+OOO+6AUtlb/lytVsci1LBiZRgGNpsNANDT04PsbL62QoU2ffr0vr+vQL59b2AYBpMnT0Z3dzc6OjqiGOFZg8U6derUvvuR/r1KikRgMpn6fhA1Gg1MJlPI9hUVFfB6vSgsLIxGeAHLcRgMhgFtApXjiLZwYj3XunXrMGfOnGiENkA4sVZVVUGv12PevHlRjq6/cGJtaGhAfX09br31Vtxyyy3YuXNntMMEEF6sjzzyCDZu3Ig5c+bg/vvvx9NPPx3tMMNy/p9Fp9OF/HmOF5H+vRo2JSZ++MMforOzc8D1xx57rN/XDMOE3LTW0dGBJ598Er///e8hiEW50WFkw4YNOH78ONauXRvrUALy+/144YUX8Pzzz8c6lLCwLIvGxka89dZb0Ov1+P73v4+NGzciPT1YZZrY2bx5M5YtW4Z77rkHR44cwVNPPYVNmzbR71QE7N+/H+vWrcM777wTsT6HTSJ48803g95Tq9Xo6OhAdnY2Ojo6gha1s9lseOCBB/DjH/8YkydP5ifQAC6kHIdOp4tpOY5wYgWAvXv3YtWqVVi7di0kEkk0Q+wzWKx2ux3V1dW48847AQBGoxEPPfQQXnvtNUycODGuYv22zSWXXAKxWIyCggIUFxejoaEBkyZNirtY161bh9WrVwMApkyZArfbDYvFErPhrGDO/7Po9fqAP8/x4tSpU3j66afxj3/8I6K//0mRnsvLy7F+/XoAwPr163H11VcPaOPxePDwww/j+uuvx7XXXhvV+BKpHEc4sZ44cQIrVqzAa6+9FtNf/MFiVSgUOHDgALZt24Zt27Zh8uTJMUkC4cQKAPPnz8fBgwcBAGazGQ0NDTHZiR9OrDk5Odi3bx8AoLa2Fm63O2RV4Vj59r2B4zgcPXoUCoUiZvMZg2lra8Py5cvx4osvYsSIyJaiToqdxRaLBY899hja29uRm5uLl19+GSqVCpWVlXjvvffw7LPPYsOGDfjFL37R77yEF154AWPHjo1KjIlUjmOwWH/4wx+iuroaGo0GQO+bwqpVq+Iy1nP94Ac/wFNPPRWTRBBOrBzH4YUXXsCuXbsgFArx4IMPYsmSJXEZa01NDZ5++mk4HA4wDIMnn3wSV155ZdTjfPzxx3Hw4MG+p5Hly5fD5+s9g+C2224Dx3FYuXIldu3aBZlMhueeey5m//6DxfrLX/4Sn332GXJzcwEAQqEQH330UUReOykSASGEkOCSYmiIEEJIcJQICCEkyVEiIISQJEeJgBBCkhwlAkIISXKUCAghJMlRIiCEkCRHiYCQIaqoqMDSpUvhdrvhcDiwZMkSVFdXxzosQsJGG8oIiYA///nP8Hg8cLlc0Ol0eOCBB2IdEiFho0RASAR4PB7cdNNNSElJwXvvvQehUBjrkAgJGw0NERIBVqsVDocDdrsdbrc71uEQckHoiYCQCPi2AFxLSwuMRiNWrFgR65AICRs9ERAyROvXr4dYLMbSpUtx//33o7Kysq8EMyGJgJ4ICCEkydETASGEJDlKBIQQkuQoERBCSJKjREAIIUmOEgEhhCQ5SgSEEJLkKBEQQkiS+/9nQEnPwiElOQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for col in 'xy':\n",
+    "    sns.kdeplot(df_data[col], shade=True)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plotting joint and marginal distributions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The first is `jointplot()`, which augments a bivariate relatonal or distribution plot with the marginal distributions of the two variables. \n",
+    "\n",
+    "By default, `jointplot()` represents the bivariate distribution using `scatterplot()` and the marginal distributions using `histplot()`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "with sns.axes_style('white'):\n",
+    "    sns.jointplot(x=x, y=y, kind='kde');"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "with sns.axes_style('white'):\n",
+    "    sns.jointplot(x=x, y=y, kind='hex')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x432 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "with sns.axes_style('white'):\n",
+    "    sns.jointplot(x=x, y=y, kind='reg')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Testing for `PolyRound` using a BIGG model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from PolyRound.api import PolyRoundApi\n",
+    "from PolyRound.static_classes.lp_utils import ChebyshevFinder\n",
+    "from PolyRound.settings import PolyRoundSettings\n",
+    "from pathlib import Path"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_path = \"/home/haris/Desktop/polyround_SI/PolyRound/PolyRound/models/e_coli_core.xml\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create a settings object with the default settings.\n",
+    "settings = PolyRoundSettings()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'gurobi'"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "settings.backend"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "settings.check_lps"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'FeasibilityTol': 1e-09, 'OptimalityTol': 1e-08}"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "settings.hp_flags"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 20,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "settings.presolve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "settings.reduce"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Import model and create Polytope object\n",
+    "polytope = PolyRoundApi.sbml_to_polytope(model_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(190, 95)"
+      ]
+     },
+     "execution_count": 23,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polytope.A.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 78,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ACALD</th>\n",
+       "      <th>ACALDt</th>\n",
+       "      <th>ACKr</th>\n",
+       "      <th>ACONTa</th>\n",
+       "      <th>ACONTb</th>\n",
+       "      <th>ACt2r</th>\n",
+       "      <th>ADK1</th>\n",
+       "      <th>AKGDH</th>\n",
+       "      <th>AKGt2r</th>\n",
+       "      <th>ALCD2x</th>\n",
+       "      <th>...</th>\n",
+       "      <th>RPI</th>\n",
+       "      <th>SUCCt2_2</th>\n",
+       "      <th>SUCCt3</th>\n",
+       "      <th>SUCDi</th>\n",
+       "      <th>SUCOAS</th>\n",
+       "      <th>TALA</th>\n",
+       "      <th>THD2</th>\n",
+       "      <th>TKT1</th>\n",
+       "      <th>TKT2</th>\n",
+       "      <th>TPI</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>13dpg_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2pg_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3pg_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6pgc_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6pgl_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>s7p_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>succ_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>succ_e</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>succoa_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>xu5p__D_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>-1.0</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>72 rows × 95 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           ACALD  ACALDt  ACKr  ACONTa  ACONTb  ACt2r  ADK1  AKGDH  AKGt2r  \\\n",
+       "13dpg_c      0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "2pg_c        0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "3pg_c        0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "6pgc_c       0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "6pgl_c       0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "...          ...     ...   ...     ...     ...    ...   ...    ...     ...   \n",
+       "s7p_c        0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "succ_c       0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "succ_e       0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "succoa_c     0.0     0.0   0.0     0.0     0.0    0.0   0.0    1.0     0.0   \n",
+       "xu5p__D_c    0.0     0.0   0.0     0.0     0.0    0.0   0.0    0.0     0.0   \n",
+       "\n",
+       "           ALCD2x  ...  RPI  SUCCt2_2  SUCCt3  SUCDi  SUCOAS  TALA  THD2  \\\n",
+       "13dpg_c       0.0  ...  0.0       0.0     0.0    0.0     0.0   0.0   0.0   \n",
+       "2pg_c         0.0  ...  0.0       0.0     0.0    0.0     0.0   0.0   0.0   \n",
+       "3pg_c         0.0  ...  0.0       0.0     0.0    0.0     0.0   0.0   0.0   \n",
+       "6pgc_c        0.0  ...  0.0       0.0     0.0    0.0     0.0   0.0   0.0   \n",
+       "6pgl_c        0.0  ...  0.0       0.0     0.0    0.0     0.0   0.0   0.0   \n",
+       "...           ...  ...  ...       ...     ...    ...     ...   ...   ...   \n",
+       "s7p_c         0.0  ...  0.0       0.0     0.0    0.0     0.0  -1.0   0.0   \n",
+       "succ_c        0.0  ...  0.0       1.0    -1.0   -1.0    -1.0   0.0   0.0   \n",
+       "succ_e        0.0  ...  0.0      -1.0     1.0    0.0     0.0   0.0   0.0   \n",
+       "succoa_c      0.0  ...  0.0       0.0     0.0    0.0     1.0   0.0   0.0   \n",
+       "xu5p__D_c     0.0  ...  0.0       0.0     0.0    0.0     0.0   0.0   0.0   \n",
+       "\n",
+       "           TKT1  TKT2  TPI  \n",
+       "13dpg_c     0.0   0.0  0.0  \n",
+       "2pg_c       0.0   0.0  0.0  \n",
+       "3pg_c       0.0   0.0  0.0  \n",
+       "6pgc_c      0.0   0.0  0.0  \n",
+       "6pgl_c      0.0   0.0  0.0  \n",
+       "...         ...   ...  ...  \n",
+       "s7p_c       1.0   0.0  0.0  \n",
+       "succ_c      0.0   0.0  0.0  \n",
+       "succ_e      0.0   0.0  0.0  \n",
+       "succoa_c    0.0   0.0  0.0  \n",
+       "xu5p__D_c  -1.0  -1.0  0.0  \n",
+       "\n",
+       "[72 rows x 95 columns]"
+      ]
+     },
+     "execution_count": 78,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "polytope.S"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 73,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.series.Series'>\n",
+      "(72,)\n",
+      "13dpg_c      0.0\n",
+      "2pg_c        0.0\n",
+      "3pg_c        0.0\n",
+      "6pgc_c       0.0\n",
+      "6pgl_c       0.0\n",
+      "            ... \n",
+      "s7p_c        0.0\n",
+      "succ_c       0.0\n",
+      "succ_e       0.0\n",
+      "succoa_c     0.0\n",
+      "xu5p__D_c    0.0\n",
+      "Length: 72, dtype: float64\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(type(polytope.h))\n",
+    "print(polytope.h.shape)\n",
+    "print(polytope.h)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "From the documentation of the class `Polytope` on `PolyRound`:\n",
+    "    \n",
+    "Polytope class which holds a set of: \n",
+    "\n",
+    "* inequality constraints: $Ax<=b$\n",
+    "* and equality constraints: $Sx=h$\n",
+    "\n",
+    "$A$ and $S$ are Pandas Dataframes and $b$ and $h$ are Pandas Series. \n",
+    "\n",
+    "Column names of $A$ and $S$ are the reaction names (preserved). \n",
+    "\n",
+    "The polytope can be transformed with `apply_shift` and `apply_transformation`. \n",
+    "\n",
+    "Each of these transformations applied are stored in the attributes `shift` and `transformation`, \n",
+    "allowing to back transform points `x` to the original space using the method `back_transform`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(95, 1)\n",
+      "[0.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Remove redundant constraints and refunction inequality constraints that are de-facto equalities.\n",
+    "# Due to these inequalities, the polytope is empty (distance from chebyshev center to boundary is zero)\n",
+    "x, dist = ChebyshevFinder.chebyshev_center(polytope, settings)\n",
+    "\n",
+    "# Is x the point ? ? ?  \n",
+    "print(x.shape)\n",
+    "print(dist)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "simplified_polytope = PolyRoundApi.simplify_polytope(polytope)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 77,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>ACALD</th>\n",
+       "      <th>ACALDt</th>\n",
+       "      <th>ACKr</th>\n",
+       "      <th>ACONTa</th>\n",
+       "      <th>ACONTb</th>\n",
+       "      <th>ACt2r</th>\n",
+       "      <th>ADK1</th>\n",
+       "      <th>AKGDH</th>\n",
+       "      <th>AKGt2r</th>\n",
+       "      <th>ALCD2x</th>\n",
+       "      <th>...</th>\n",
+       "      <th>RPI</th>\n",
+       "      <th>SUCCt2_2</th>\n",
+       "      <th>SUCCt3</th>\n",
+       "      <th>SUCDi</th>\n",
+       "      <th>SUCOAS</th>\n",
+       "      <th>TALA</th>\n",
+       "      <th>THD2</th>\n",
+       "      <th>TKT1</th>\n",
+       "      <th>TKT2</th>\n",
+       "      <th>TPI</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>13dpg_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2pg_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3pg_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6pgc_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6pgl_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>...</th>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "      <td>...</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>s7p_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>-0.707107</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.707107</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>succ_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.408248</td>\n",
+       "      <td>-0.408248</td>\n",
+       "      <td>-0.408248</td>\n",
+       "      <td>-0.408248</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>succ_e</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>-0.577350</td>\n",
+       "      <td>0.577350</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>succoa_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.707107</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.707107</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.00000</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>xu5p__D_c</th>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>...</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.000000</td>\n",
+       "      <td>0.0</td>\n",
+       "      <td>-0.577350</td>\n",
+       "      <td>-0.57735</td>\n",
+       "      <td>0.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "<p>72 rows × 95 columns</p>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "           ACALD  ACALDt  ACKr  ACONTa  ACONTb  ACt2r  ADK1     AKGDH  AKGt2r  \\\n",
+       "13dpg_c      0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "2pg_c        0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "3pg_c        0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "6pgc_c       0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "6pgl_c       0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "...          ...     ...   ...     ...     ...    ...   ...       ...     ...   \n",
+       "s7p_c        0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "succ_c       0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "succ_e       0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "succoa_c     0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.707107     0.0   \n",
+       "xu5p__D_c    0.0     0.0   0.0     0.0     0.0    0.0   0.0  0.000000     0.0   \n",
+       "\n",
+       "           ALCD2x  ...  RPI  SUCCt2_2    SUCCt3     SUCDi    SUCOAS      TALA  \\\n",
+       "13dpg_c       0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
+       "2pg_c         0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
+       "3pg_c         0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
+       "6pgc_c        0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
+       "6pgl_c        0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
+       "...           ...  ...  ...       ...       ...       ...       ...       ...   \n",
+       "s7p_c         0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000 -0.707107   \n",
+       "succ_c        0.0  ...  0.0  0.408248 -0.408248 -0.408248 -0.408248  0.000000   \n",
+       "succ_e        0.0  ...  0.0 -0.577350  0.577350  0.000000  0.000000  0.000000   \n",
+       "succoa_c      0.0  ...  0.0  0.000000  0.000000  0.000000  0.707107  0.000000   \n",
+       "xu5p__D_c     0.0  ...  0.0  0.000000  0.000000  0.000000  0.000000  0.000000   \n",
+       "\n",
+       "           THD2      TKT1     TKT2  TPI  \n",
+       "13dpg_c     0.0  0.000000  0.00000  0.0  \n",
+       "2pg_c       0.0  0.000000  0.00000  0.0  \n",
+       "3pg_c       0.0  0.000000  0.00000  0.0  \n",
+       "6pgc_c      0.0  0.000000  0.00000  0.0  \n",
+       "6pgl_c      0.0  0.000000  0.00000  0.0  \n",
+       "...         ...       ...      ...  ...  \n",
+       "s7p_c       0.0  0.707107  0.00000  0.0  \n",
+       "succ_c      0.0  0.000000  0.00000  0.0  \n",
+       "succ_e      0.0  0.000000  0.00000  0.0  \n",
+       "succoa_c    0.0  0.000000  0.00000  0.0  \n",
+       "xu5p__D_c   0.0 -0.577350 -0.57735  0.0  \n",
+       "\n",
+       "[72 rows x 95 columns]"
+      ]
+     },
+     "execution_count": 77,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simplified_polytope.S"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**Question:** How can it be to add rows in $S$ ? "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(36, 95)"
+      ]
+     },
+     "execution_count": 28,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simplified_polytope.A.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.58198972]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The simplified polytope has non-zero border distance\n",
+    "x, dist = ChebyshevFinder.chebyshev_center(simplified_polytope, settings)\n",
+    "print(dist)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "transformed_polytope = PolyRoundApi.transform_polytope(simplified_polytope)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[2.94777315]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The distance from the chebyshev center to the boundary changes in the new coordinate system\n",
+    "x, dist = ChebyshevFinder.chebyshev_center(transformed_polytope, settings)\n",
+    "print(dist)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[1.00000001]\n",
+      "0.03925295155234657\n"
+     ]
+    }
+   ],
+   "source": [
+    "rounded_polytope = PolyRoundApi.round_polytope(transformed_polytope)\n",
+    "\n",
+    "# After rounding, the distance from the chebyshev center to the boundary is set to be close to 1\n",
+    "x, dist = ChebyshevFinder.chebyshev_center(rounded_polytope, settings)\n",
+    "print(dist)\n",
+    "\n",
+    "# The chebyshev center can be back transformed into an interior point in the simplified space.\n",
+    "print(simplified_polytope.border_distance(rounded_polytope.back_transform(x)))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# simplify, transform and round in one call\n",
+    "one_step_rounded_polytope = PolyRoundApi.simplify_transform_and_round(polytope)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'\\n# Here are the features of the one_step_rounded_polytope object\\n# These features stand for any polytope object of the PolyRound\\n\\none_step_rounded_polytope.A\\n\\none_step_rounded_polytope.apply_shift\\n\\none_step_rounded_polytope.b\\n\\none_step_rounded_polytope.back_transform    ==> Backtransforms x to the original space of the Polytope.\\n                                                :param x: Numpy array\\none_step_rounded_polytope.border_distance   ==>\\n\\none_step_rounded_polytope.copy              ==>\\n\\none_step_rounded_polytope.h                 ==>\\n\\none_step_rounded_polytope.inequality_only   ==>\\n\\none_step_rounded_polytope.normalize         ==>  Normalizes each row sum of self.A to 1. \\n                                                 Does not change feasible space.\\none_step_rounded_polytope.normalize_system  ==>\\n\\none_step_rounded_polytope.remove_zero_rows  ==>\\n\\none_step_rounded_polytope.S                 ==>\\n\\none_step_rounded_polytope.shift             ==>\\n\\none_step_rounded_polytope.transformation    ==>\\n'"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "\"\"\"\n",
+    "# Here are the features of the one_step_rounded_polytope object\n",
+    "# These features stand for any polytope object of the PolyRound\n",
+    "\n",
+    "one_step_rounded_polytope.A                     ==>  The A matrix\n",
+    "\n",
+    "one_step_rounded_polytope.b                     ==>  The b vector\n",
+    "\n",
+    "one_step_rounded_polytope.S                     ==>  The stoichiometric matrix\n",
+    "\n",
+    "one_step_rounded_polytope.apply_shift           ==>  Shifts Polytope region without altering the shape\n",
+    "\n",
+    "one_step_rounded_polytope.apply_transformation  ==>  Applies transformation matrix to Polytope. \n",
+    "                                                     If non-symmetric transformation, assumes reduction to \n",
+    "                                                     system of only inequlity constraints (not checked).\n",
+    "                                                     :param transformation: Numpy Array or Pandas Dataframe\n",
+    "\n",
+    "one_step_rounded_polytope.back_transform        ==>  Backtransforms x to the original space of the Polytope.\n",
+    "                                                     :param x: Numpy array\n",
+    "\n",
+    "one_step_rounded_polytope.border_distance       ==>  Computes shortest distance from x to polytope border\n",
+    "\n",
+    "one_step_rounded_polytope.copy                  ==>  Deep copy of Polytope.\n",
+    "\n",
+    "one_step_rounded_polytope.h                     ==>  a flux vector MAYBE...? \n",
+    "\n",
+    "one_step_rounded_polytope.inequality_only       ==>\n",
+    "\n",
+    "one_step_rounded_polytope.normalize             ==>  Normalizes each row sum of self.A to 1. \n",
+    "                                                     Does not change feasible space.\n",
+    "\n",
+    "one_step_rounded_polytope.normalize_system      ==>  staticmethod: A = (A.T / row_norm).T where\n",
+    "                                                     row_norm = np.linalg.norm(A, axis=1)\n",
+    "\n",
+    "one_step_rounded_polytope.remove_zero_rows      ==>  staticmethod: \n",
+    "\n",
+    "one_step_rounded_polytope.shift                 ==>  attribute: initially the zero vector. \n",
+    "\n",
+    "one_step_rounded_polytope.transformation        ==>  attribute: \n",
+    "\"\"\""
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#save to hdf5\n",
+    "out_hdf5 = \"/home/haris/Desktop/rounded_e_coli_core.hdf5\"\n",
+    "PolyRoundApi.polytope_to_hdf5(one_step_rounded_polytope, out_hdf5)\n",
+    "\n",
+    "#save to csv\n",
+    "out_csv_dir = \"/home/haris/Desktop/testing_polyround_algo\"\n",
+    "Path(out_csv_dir).mkdir(parents=True, exist_ok=True)\n",
+    "PolyRoundApi.polytope_to_csvs(one_step_rounded_polytope, out_csv_dir)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.]\n",
+      "[0.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Special use case: remove redundant constraints without removing zero facettes. \n",
+    "# This will leave th polytope with its original border distance.\n",
+    "x, dist = ChebyshevFinder.chebyshev_center(polytope, settings)\n",
+    "print(dist)\n",
+    "settings.simplify_only = True\n",
+    "simplified_polytope = PolyRoundApi.simplify_polytope(polytope, settings=settings)\n",
+    "\n",
+    "# The simplified polytope still has zero border distance\n",
+    "x, dist = ChebyshevFinder.chebyshev_center(simplified_polytope, settings)\n",
+    "print(dist)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sampling using `hopsy` after rounding with `PolyRound`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(36, 24)"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "one_step_rounded_polytope.A.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(36,)"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "one_step_rounded_polytope.b.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "problem = hopsy.Problem(one_step_rounded_polytope.A, one_step_rounded_polytope.b, model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "run = hopsy.Run(problem)\n",
+    "# we finally sample\n",
+    "run.sample()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data = run.data\n",
+    "\n",
+    "# the states is a list of lists of numpy.ndarrays, which can be casted to a numpy.ndarray\n",
+    "# which then has the shape (m,n,d), where m is the number of chains, n the number of samples\n",
+    "# and d the dimenion\n",
+    "states  = data.states"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'numpy.ndarray'>\n",
+      "(24,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(type(states[0][0]))\n",
+    "print(states[0][0].shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now need to map backwards the samples in the initial polytope... "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "non_mapped_samples = np.concatenate(states)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 44,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1000, 24)"
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "non_mapped_samples.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "mapped_samples = one_step_rounded_polytope.back_transform(non_mapped_samples.T)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "one_step_rounded_polytope."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 52,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(95, 1000)"
+      ]
+     },
+     "execution_count": 52,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "mapped_samples.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 57,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<seaborn.axisgrid.FacetGrid at 0x7fd4a5ce89a0>"
+      ]
+     },
+     "execution_count": 57,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 360x360 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.set_theme(style=\"darkgrid\")\n",
+    "df = mapped_samples[4]\n",
+    "sns.displot(\n",
+    "    df\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**I am really not sure that I am doing this right....**"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/embl_model_convert.m b/embl_model_convert.m
new file mode 100644
index 00000000..803cddaf
--- /dev/null
+++ b/embl_model_convert.m
@@ -0,0 +1,47 @@
+% Script to convert all EMBL models of the Machado collection
+% from .xml format to .mat format 
+
+
+% Function to get all files with a .xml suffix in all subdirectories
+xml_files_path = uigetdir('/home/haris/Documents/coding/github_repos/GeomScale/dingo/embl_gems-master/models/');
+mat_files_output_path = '/home/haris/Documents/coding/github_repos/GeomScale/dingo/embl_gems-master/mat_models/';
+theFiles = dir(fullfile(xml_files_path,'**','*.xml.gz'));
+
+
+for k = 1 : length(theFiles)
+
+    baseFileName = theFiles(k).name;
+    fullFileName = fullfile(theFiles(k).folder, baseFileName);
+    
+    gunzip(fullFileName)
+    
+    unzipBaseFileName = strrep(baseFileName,'.gz','');
+    unzipFullFileName = strrep(fullFileName,'.gz','');
+    
+%   Read xml file and keep data needed
+    model = readCbModel(unzipFullFileName);
+    fldnames = fieldnames(model);
+    dingo_model = struct;
+    dingo_model.S = model.S;
+    dingo_model.lb = model.lb;
+    dingo_model.ub = model.ub;
+    dingo_model.c = model.c;
+    dingo_model.index_obj = find(dingo_model.c == 1);
+    dingo_model.rxns = model.rxns;
+    dingo_model.mets = model.mets;
+ 
+    
+    koo = strrep(unzipBaseFileName,'.xml','.mat');
+    kico = strcat(mat_files_output_path, koo);
+    fprintf(kico + "\n")
+
+    save(kico, 'dingo_model');
+    gzip(kico);
+    
+    delete(unzipFullFileName);
+    delete(kico);
+
+end
+
+
+
diff --git a/ext_data/README.md b/ext_data/README.md
new file mode 100644
index 00000000..4a0a5818
--- /dev/null
+++ b/ext_data/README.md
@@ -0,0 +1,17 @@
+In the `community_models` directory, you will find models in `.json` format (`.mat` are also supported) 
+that will be used as input for the `CommunityMetabolicNetwork` class of `dingo`. 
+
+The class will get all the `.json` files of a directory (or `.mat` accordingly) and build a united model
+from all of them. 
+
+In our example case, we use two BIGG models `e_coli_core` and `` as they are among those with the lowest number of reactions, 
+so not to have long computation time for it. 
+Even in that case, the computational time needed is not negligible, especially if `gurobi` is not available.
+
+Here is how to use `dingo` for a community. 
+
+```python
+model         = dingo.CommunityMetabolicNetwork.buildModelList(dir, "json")
+sampler       = dingo.CommunityPolytopeSampler(model)
+steady_states = sampler.generate_steady_states()
+```
diff --git a/ext_data/community_models/README.md b/ext_data/community_models/README.md
new file mode 100644
index 00000000..dd268e4c
--- /dev/null
+++ b/ext_data/community_models/README.md
@@ -0,0 +1,18 @@
+This is an example directory where you need to add all your `.mat` or `.json` model files 
+your community consists of. 
+
+For example, you may have a community of 2 models, *Escherichia coli* and *Helicobacter pylori*, 
+in that case you could get the [`e_coli_core.json`](http://bigg.ucsd.edu/models/e_coli_core) and 
+[`iIT341.json`](http://bigg.ucsd.edu/models/iIT341) files from the [BIGG database](http://bigg.ucsd.edu/models)
+and then run `dingo`. 
+
+Remember to remove this `README.md` file if you will decide to use this directory. 
+
+Here is an example of how to run `dingo` from your terminal for the case of a community analysis:
+
+```bash=
+python -m dingo -cmd  </path_to_community_models_dir/>  --format json
+```
+
+
+