diff --git a/.gitignore b/.gitignore
index 3428315..88a5086 100644
--- a/.gitignore
+++ b/.gitignore
@@ -128,4 +128,5 @@ dmypy.json
 # Pyre type checker
 .pyre/
 
-.*
\ No newline at end of file
+.*
+*.data
\ No newline at end of file
diff --git a/README.md b/README.md
index 0e32342..fb435cd 100644
--- a/README.md
+++ b/README.md
@@ -27,20 +27,52 @@ limitations under the License. -->
 compartmental
 </h1>
 <h2 align="center">
-.
-</h2><br></br>
-<h3 align="center">
-.
-</h3><br></br>
-
-
+Utility tools for Approximate Bayesian computation on compartmental models 
+</h2>
 
+<br>
 <div align="center">
 
 <a href="https://quanticpony.github.io/compartmental/">
 <img src=https://img.shields.io/github/deployments/QuanticPony/compartmental/github-pages?label=documentation>
 </a>
-<br></br>
+<br></br></br>
+<h3 align="center">
+
+</h3>
+
+
+
+
 
 </div>
-<br></br>
+
+# Instalation
+**compartmental** releases are available as wheel packages on [PyPI](https://pypi.org/project/compartmental/). You can install the last version using `pip`:
+```
+pip install compartmental
+```
+
+
+# Documentation
+Documentations is automatically generated from code on main push and hosted in github-pages [here](https://quanticpony.github.io/compartmental/).
+
+# Help
+Just open an issue with the `question` tag ([or clic here](https://github.com/QuanticPony/compartmental/issues/new?assignees=QuanticPony&labels=question&template=question.md&title=)), I would love to help!
+
+# Contributing
+You can contribute with:
+
+* Examples
+* Documentation
+* [Bug report/fix](https://github.com/QuanticPony/compartmental/issues/new?assignees=QuanticPony&labels=bug&template=bug_report.md&title=)
+* [Features](https://github.com/QuanticPony/compartmental/issues/new?assignees=QuanticPony&labels=new-feature&template=feature_request.md&title=)
+* Code
+
+Even only feedback is greatly apreciated. 
+
+Just create an issue and let me know you want to help! 
+
+
+# Licensing
+**compartmental** is released under the **Apache License Version 2.0**.
\ No newline at end of file
diff --git a/compartmental/__init__.py b/compartmental/__init__.py
index 6b5ec43..55c5164 100644
--- a/compartmental/__init__.py
+++ b/compartmental/__init__.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
  
-__version__ = "0.0.3"
+__version__ = "0.1.0"
 _CUPY_MODE_: bool
 
 from . import generic_model
@@ -38,4 +38,4 @@ def update_packages(CNP):
 
 use_numpy()
 
-GenericModel = generic_model.GenericModel
\ No newline at end of file
+from .generic_model import GenericModel
\ No newline at end of file
diff --git a/compartmental/generic_model.py b/compartmental/generic_model.py
index e3d1efe..8de0f94 100644
--- a/compartmental/generic_model.py
+++ b/compartmental/generic_model.py
@@ -12,19 +12,20 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
  
-import __future__
-from io import TextIOWrapper
+from __future__ import annotations
 from typing import TYPE_CHECKING, Any
 
 if TYPE_CHECKING:
     import numpy as CNP
 
-from .parameters import ParametersManager
+
 from .util import *
+from .parameters import ParametersManager
+
 import copy
 
 class GenericModel:
-    """Creates a compartimental model from a dictionary and setting an `evolve` method.
+    """Creates a compartmental model from a dictionary and setting an `evolve` method.
     """
 
     def get_all_params_names(self):
@@ -46,7 +47,7 @@ def __init__(self, configuration: dict[str, Any]):
         
         self.param_to_index: dict[str, int] = { k:i for i,k in enumerate(self.configuration["params"].keys()) }
         self.fixed_param_to_index: dict[str, int] = { k:i for i,k in enumerate(self.configuration["fixed_params"].keys()) }
-        self.compartiment_name_to_index: dict[str, int] = { k:i for i,k in enumerate(self.configuration["compartiments"].keys()) }
+        self.compartment_name_to_index: dict[str, int] = { k:i for i,k in enumerate(self.configuration["compartments"].keys()) }
 
 
     def populate_model_parameters(self, **kargs):
@@ -58,60 +59,54 @@ def populate_model_parameters(self, **kargs):
         # Set offset value if it is a str reference
         if isinstance(REFERENCE_OFFSET, str):
             self.configuration["params"][REFERENCE_OFFSET].update({"type":"int"})
-        
-        N_SIMULATIONS = self.configuration["simulation"]["n_simulations"]
-        self.params = CNP.zeros(
-            (len(self.configuration["params"]), N_SIMULATIONS), dtype=CNP.float64
-        )
-        self.fixed_params = CNP.zeros(
-            (len(self.configuration["fixed_params"]), 1), dtype=CNP.float64
-        )
+
+        parameter_manager.populate_params(**kargs)
+        parameter_manager.populate_fixed_params()
         
         for param in self.configuration["params"].keys():
-            setattr(self, param, self.params[self.param_to_index[param]])
+            setattr(self, param, self.params[param])
             
         for fparam in self.configuration["fixed_params"].keys():
             setattr(self, fparam, self.fixed_params[self.fixed_param_to_index[fparam]])
             
         if isinstance(REFERENCE_OFFSET, str):
-            self.reference_offset = self.params[self.param_to_index[REFERENCE_OFFSET]]
+            self.reference_offset = self.params[REFERENCE_OFFSET]
         else:
             self.reference_offset = 0
             
-        parameter_manager.populate_params(self.params, **kargs)
-        parameter_manager.populate_fixed_params(self.fixed_params)
+
         
         
-    def populate_model_compartiments(self, **kargs):
-        """Populates compartiments array. Assigns shortcuts to call them by their name as an attribute.
+    def populate_model_compartments(self, **kargs):
+        """Populates compartments array. Assigns shortcuts to call them by their name as an attribute.
         """
         N_SIMULATIONS = self.configuration["simulation"]["n_simulations"]
         self.state = CNP.zeros(
-            (len(self.configuration["compartiments"]), N_SIMULATIONS), dtype=CNP.float64
+            (len(self.configuration["compartments"]), N_SIMULATIONS), dtype=CNP.float64
         )
         self.log_diff = CNP.zeros((N_SIMULATIONS, 1), dtype=CNP.float64)
         
-        for c,i in self.compartiment_name_to_index.items():
-            C = self.configuration["compartiments"][c]
+        for c,i in self.compartment_name_to_index.items():
+            C = self.configuration["compartments"][c]
             initial_value = C["initial_value"]
             if isinstance(initial_value, str):
                 if initial_value in self.param_to_index.keys():
-                    self.state[i,:] = self.params[self.param_to_index[initial_value]]
+                    self.state[i,:] = self.params[initial_value]
                 continue
             self.state[i,:] = initial_value
            
-        for c,i in self.compartiment_name_to_index.items():
-            C = self.configuration["compartiments"][c]
-            minus = C.get("minus_compartiments", False)
+        for c,i in self.compartment_name_to_index.items():
+            C = self.configuration["compartments"][c]
+            minus = C.get("minus_compartments", False)
             if not minus:
                 continue
             if not isinstance(minus, list):
                 minus = [minus]
             for m in minus:
-                self.state[i,:] -= self.state[self.compartiment_name_to_index[m],:]
+                self.state[i,:] -= self.state[self.compartment_name_to_index[m],:]
                 
-        for comp in self.configuration["compartiments"].keys():
-            setattr(self, comp, self.state[self.compartiment_name_to_index[comp]])
+        for comp in self.configuration["compartments"].keys():
+            setattr(self, comp, self.state[self.compartment_name_to_index[comp]])
                 
 
     def evolve(self, step, *args, **kargs):
@@ -135,12 +130,15 @@ def get_diff(self, step, reference, reference_mask):
         Returns:
             (list[float]): Distance from simulations to reference(s).
         """
-        index = CNP.clip(step + CNP.int64(self.reference_offset), 0, self.N_STEPS-1)
-        diff = CNP.absolute(CNP.take(self.state, reference_mask, 0)[0].T-reference[index])
+        index = step + self.reference_offset
+        # To only take the diff on the same range for all simulations
+        diff = CNP.absolute(CNP.take(self.state, reference_mask, 0)[0].T-reference[CNP.clip(index, 0, self.N_STEPS-1)]) * \
+               ((self.reference_offset.max()<=index) * (index<=self.N_STEPS))
+               
         return CNP.log(diff + 1)
 
 
-    def _internal_run_(self, inner, inner_args: list, outer, outer_args:list,  reference, save_file:str, *args, **kargs):
+    def _internal_run_(self, inner, inner_args: list, outer, outer_args:list,  reference, save_file:str, *args, exclude_pupulate:bool=False, **kargs):
         """Internal function that executes the model.
 
         Args:
@@ -150,19 +148,26 @@ def _internal_run_(self, inner, inner_args: list, outer, outer_args:list,  refer
             outer_args (list): Args given to `outer`.
             reference (list[list[float]]): Reference values used to compare with the simulation.
             save_file (str): Filename of path to file.
+            exclude_populate (bool, optional): If `False` params and compartments are populated with random values. Defaults to False.
         """
         N_EXECUTIONS = self.configuration["simulation"]["n_executions"]
-        REFERENCE_OFFSET = self.configuration["reference"].get("offset", 0)
         self.N_STEPS = self.configuration["simulation"]["n_steps"]
-        
+
         for execution in range(N_EXECUTIONS):
             progress_bar(f"Model running: ", execution, N_EXECUTIONS, len=min(20, max(N_EXECUTIONS,5)))
-            self.log_diff[:] = 0
-            self.populate_model_parameters(**kargs)
-            self.populate_model_compartiments(**kargs)
             
-            for step in range(self.N_STEPS):
+            if not exclude_pupulate:
+                self.populate_model_parameters(**kargs)
+                self.populate_model_compartments(**kargs)
+
+            self._min_offset_: int = self.reference_offset.min()
+            self.log_diff[:] = 0
+
+            # for step in range(self.N_STEPS):
+            step = CNP.int64(0)
+            while (self.reference_offset + step < self.N_STEPS).any():
                 inner(self, step, reference, *inner_args, **kargs)
+                step += 1
             outer(self, *outer_args, execution_number=execution, **kargs)
             
         progress_bar(f"Model running: ", N_EXECUTIONS, N_EXECUTIONS, len=min(20, max(N_EXECUTIONS,5)), end='\n')
@@ -177,7 +182,7 @@ def run_no_diff(self, save_file: str, *args, **kargs):
         self._internal_run_(
             self.evolve, args, 
             save_parameters_no_diff, (save_file, self.param_to_index.keys(),  self.params), 
-            None, save_file, 
+            None, save_file,
             *args, **kargs
         )
 
@@ -190,18 +195,18 @@ def run(self, reference, save_file: str, *args, **kargs):
             save_file (str): Filename of path to file.
         """
         
-        reference_mask = CNP.array([self.compartiment_name_to_index[c] for c in self.configuration["reference"]["compartiments"]])
+        reference_mask = CNP.array([self.compartment_name_to_index[c] for c in self.configuration["reference"]["compartments"]])
         
         def inner(model, step, reference, reference_mask, *args, **kargs):
             model.evolve(model, step, *args, **kargs)
             self.log_diff[:,0] += model.get_diff(step, reference, reference_mask)
         
-        def outer(model, save_file, *args, **kargs):
+        def outer(model, save_file, *args, execution_number, **kargs):
             best_params, best_log_diff = get_best_parameters(model.params, model.log_diff, model.configuration["results"]["save_percentage"])
-            save_parameters(save_file, model.param_to_index.keys(), best_params, best_log_diff)
+            save_parameters(save_file, model.param_to_index.keys(), best_params, best_log_diff, execution_number=execution_number)
             
         self._internal_run_(
-            inner, (reference_mask,), 
+            inner, (reference_mask, *args), 
             outer, (save_file,), 
             reference, save_file, 
             *args, **kargs
diff --git a/compartmental/parameters/parameters_manager.py b/compartmental/parameters/parameters_manager.py
index 2f15117..d5a3a54 100644
--- a/compartmental/parameters/parameters_manager.py
+++ b/compartmental/parameters/parameters_manager.py
@@ -25,58 +25,77 @@ def __init__(self, configuration: dict[str, Any], model):
         self.configuration = configuration
         self.model = model
         
-    def populate_params(self, params, **kargs):
+    def populate_params(self, **kargs):
         """Populates GenericModel.params array. If specific values are given in `kargs` those are used.
 
-        Args:
-            params (ndarray): Params array.
-
         Raises:
             Exception: If the model configuration could not fill all the array.
         """
         counter = 0
+        dtype = []
+
+        dtype = [[]]*len(self.model.param_to_index)
+        N_SIMULATIONS = self.model.configuration["simulation"]["n_simulations"]
+
         for param_name, param_config in self.configuration["params"].items():
             param_index = self.model.param_to_index.get(param_name)
             if param_index is not None:
-                counter += 1
                 TYPE = param_config.get("type", "float64")
-
-                if value := kargs.get(param_name, False):
-                    params[param_index] = value
-                    continue
-                
                 if TYPE == 'int':
-                    params[param_index] = CNP.random.randint(
-                        param_config["min"], 
-                        param_config["max"]+1, 
-                        self.configuration["simulation"]["n_simulations"])
-                    
+                    dtype[param_index] = (param_name, CNP.int64)
                 if TYPE == 'float64':
-                    params[param_index] = CNP.random.random(
-                        self.configuration["simulation"]["n_simulations"]) \
-                            * (param_config["max"] - param_config["min"]) \
-                            + param_config["min"]
+                    dtype[param_index] = (param_name, CNP.float64)
+
+
+        # setattr(self.model, "params", CNP.zeros(
+        #     (len(self.configuration["params"]), N_SIMULATIONS), dtype=dtype
+        # ))
+        setattr(self.model, "params", CNP.zeros(
+            (N_SIMULATIONS), dtype=dtype
+        ))
+
+        for param_name, param_config in self.configuration["params"].items():
+            counter += 1
+            TYPE = param_config.get("type", "float64")
+
+            if value := kargs.get(param_name, False):
+                self.model.params[param_name] = value
+                
+                continue
+            
+            if TYPE == 'int':
+                self.model.params[param_name] = CNP.random.randint(
+                    param_config["min"], 
+                    param_config["max"]+1, 
+                    self.configuration["simulation"]["n_simulations"])
+                
+            if TYPE == 'float64':
+                self.model.params[param_name] = CNP.random.random(
+                    self.configuration["simulation"]["n_simulations"]) \
+                        * (param_config["max"] - param_config["min"]) \
+                        + param_config["min"]
 
         if counter < len(self.model.param_to_index.keys()):
             raise Exception("Parameters array could not be correctly created with current options.")
 
 
-    def populate_fixed_params(self, fixed_params, **kargs):
+    def populate_fixed_params(self, **kargs):
         """Populates GenericModel.fixed_params with the configuration values.
         If specific values are given in `kargs` those are used.
 
-        Args:
-            fixed_params (ndarray): Fixed parameters.
-
         Raises:
             Exception: If the model configuration could not fill all the array.
         """
+        setattr(self.model, "fixed_params", CNP.zeros(
+            (len(self.configuration["fixed_params"]), 1), dtype=CNP.float64
+        ))
+
         counter = 0
         for fparam_name, value in self.configuration["fixed_params"].items():
             fparam_index = self.model.fixed_param_to_index.get(fparam_name)
             if fparam_index is not None:
                 counter += 1 
-                fixed_params[fparam_index] = kargs.get(fparam_name, value)
+                self.model.fixed_params[fparam_index] = kargs.get(fparam_name, value)
 
         if counter < len(self.model.fixed_param_to_index.keys()):
             raise Exception("Fixed parameters array could not be correctly created with current options.")
diff --git a/compartmental/util.py b/compartmental/util.py
index 3b1f3e6..a0b05b7 100644
--- a/compartmental/util.py
+++ b/compartmental/util.py
@@ -12,28 +12,47 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-import __future__
+from __future__ import annotations
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    import numpy as CNP
+    from .generic_model import GenericModel
+
 from io import TextIOWrapper
 import matplotlib.pyplot as plt
 
-from typing import TYPE_CHECKING
 
 from math import ceil
 import copy
 
-if TYPE_CHECKING:
-    import numpy as CNP
 
 
+def offset_array(array, offset):
+    """Offsets an array by the given amount.
+
+    Args:
+        array (list): array to be changed.
+        offset (int): offset to apply to the given array.
+    """
+    if (offset > 0):
+        array[offset:] = array[:-offset]
+        array[:offset] = array[0]
+    elif (offset < 0):
+        array[:offset] = array[-offset:]
+        array[offset:] = array[offset-1]
+
 def get_best_parameters(params, log_diff, save_percentage):
     "Retuns the best `save_percentage`% `params` of the simulations given their `log_diff` with real data." 
     save_count: int = ceil(log_diff.size*save_percentage*0.01)
-    saved_params = CNP.zeros((save_count, params.shape[0]), dtype=CNP.float64)
+    saved_params = CNP.zeros((save_count, 1), dtype=params.dtype)
     saved_log_diff = CNP.zeros((save_count, 1), dtype=CNP.float64)
 
-    log_diff_index_sorted = CNP.argpartition(log_diff, save_count, 0)[0:save_count]
+    if save_count == log_diff.size:
+        log_diff_index_sorted = CNP.argsort(log_diff, 0)
+    else:
+        log_diff_index_sorted = CNP.argpartition(log_diff, save_count, 0)[0:save_count]
     
-    saved_params[:,:] = CNP.take(params, log_diff_index_sorted, 1)[:,:,0].T
+    saved_params[:] = CNP.take(params, log_diff_index_sorted)
     saved_log_diff[:] = CNP.take(log_diff, log_diff_index_sorted)
     return saved_params, saved_log_diff
 
@@ -63,12 +82,17 @@ def save_parameters_no_diff(file: str, params_names: list[str], params: list[lis
         execution_number (int, optional): Number of the execution. If `0` the header is printed. Defaults to 0.
     """
     with open(file, 'a' if execution_number!=0 else 'w') as file_out:
-        import numpy as np
-        if np != CNP:
-            _params = CNP.asnumpy(params)
-        else:
-            _params = params
-        np.savetxt(file_out, params.T, delimiter=',', comments='', header=",".join(params_names) if execution_number==0 else "")
+        # import numpy as np
+        # if np != CNP:
+        #     _params = CNP.asnumpy(params)
+        # else:
+        #     _params = params
+        # np.savetxt(file_out, params.T, delimiter=',', comments='', header=",".join(params_names) if execution_number==0 else "")
+        import regex as re
+
+        _merged = params
+        file_out.write(",".join(_merged.dtype.names)+"\n")
+        file_out.write(re.sub(r"\[|\]|\(|\)| ", "", CNP.array_str(_merged)))
 
 
 def save_parameters(file: str, params_names: list[str], params: list[list[float]], log_diff: list[float], *, execution_number=0):
@@ -82,15 +106,27 @@ def save_parameters(file: str, params_names: list[str], params: list[list[float]
         execution_number (int, optional): Number of the execution. If `0` the header is printed. Defaults to 0.
     """
     with open(file, 'a' if execution_number!=0 else 'w') as file_out:
-        import numpy as np
-        if np != CNP:
-            np.savetxt(file_out, CNP.asnumpy(CNP.concatenate((log_diff, params), 1)) , delimiter=',', comments='', header=",".join(["log_diff", *params_names]) if execution_number==0 else "")
+        # TODO: check for cupy
+        # import numpy as np
+        import regex as re
+        # if np != CNP:
+        #     np.savetxt(file_out, CNP.asnumpy(CNP.concatenate((log_diff, params), 1)) , delimiter=',', comments='', header=",".join(["log_diff", *params_names]) if execution_number==0 else "")
+        # else:
+        _log_diff = log_diff
+        _params = params
+        _log_diff = CNP.asarray(log_diff, dtype=[("log_diff", CNP.float64)])
+        _merged = CNP.zeros((_params.size,1), dtype=[*_log_diff.dtype.descr, *_params.dtype.descr])
+        _merged["log_diff"] = _log_diff
+        for k in _params.dtype.names:
+            _merged[k] = _params[k]
+
+        if execution_number==0:
+            file_out.write(",".join(_merged.dtype.names)+"\n")
         else:
-            _log_diff = log_diff
-            _params = params
-            np.savetxt(file_out, np.concatenate((_log_diff, _params), 1) , delimiter=',', comments='', header=",".join(["log_diff", *params_names]) if execution_number==0 else "")
+            file_out.write("\n")
+        file_out.write(re.sub(r"\[|\]|\(|\)| ", "", CNP.array_str(_merged)))
+            
 
-        
 def load_parameters(file: str):
     """Loads parameters from file with the same format as `save_parameters` and `save_parameters_no_diff`.
 
@@ -106,7 +142,7 @@ def load_parameters(file: str):
     return CNP.asarray(results)
 
 
-def get_model_sample_trajectory(model, *args, **kargs):
+def get_model_sample_trajectory(model: GenericModel, *args, **kargs):
     """Executes the model with `n_simulations = 1` and `n_executions = 1`.
     Returns all the intermediate states and the parameters.
 
@@ -116,20 +152,82 @@ def get_model_sample_trajectory(model, *args, **kargs):
     Returns:
         (list[list[float]], list[list[float]]): Tuple of all states history and corresponding params.
     """
-    prev_config = copy.deepcopy(model.configuration)
+    reference_mask = CNP.array([model.compartment_name_to_index[c] for c in model.configuration["reference"]["compartments"]])
+    configuration = copy.deepcopy(model.configuration)
+
+    from . import GenericModel
+    inner_model = GenericModel(configuration)
+    inner_model.evolve = model.evolve
 
-    model.configuration["simulation"]["n_simulations"] = 1
-    model.configuration["simulation"]["n_executions"] = 1
+    inner_model.configuration["simulation"]["n_simulations"] = 1
+    inner_model.configuration["simulation"]["n_executions"] = 1
     
-    model.populate_model_parameters(*args, **kargs)
-    model.populate_model_compartiments(*args, **kargs)
-    saved_state = CNP.zeros((model.configuration["simulation"]["n_steps"], model.state.shape[0]))
-    for step in range(model.configuration["simulation"]["n_steps"]):
-        model.evolve(model, step, *args, **kargs)
-        saved_state[step] = model.state[:, 0]
+    inner_model.populate_model_parameters(**kargs)
+    inner_model.populate_model_compartments(**kargs)
+    saved_state = CNP.zeros((inner_model.configuration["simulation"]["n_steps"], inner_model.state.shape[0]))
+
+    def inner(_model_, step, reference, reference_mask, *args, **kargs):
+        _model_.evolve(_model_, step, *args, **kargs)
+        saved_state[step] = _model_.state[:, 0]
+
+    def outer(_model_, *args, **kargs):
+        ...
         
-    model.configuration.update(prev_config)
-    return saved_state.T, model.params[:, 0]
+    inner_model._internal_run_(
+        inner, (reference_mask, *args), 
+        outer, (), 
+        None, None,
+        *args, exclude_pupulate=True, **kargs
+    )
+        
+    offset_array(saved_state, inner_model.reference_offset[0])
+    return saved_state.T, inner_model.params[0]
+
+def get_model_sample_trajectory_with_diff_to_reference(model: GenericModel, reference, *args, **kargs):
+    """Executes the model with `n_simulations = 1` and `n_executions = 1`.
+    Returns all the intermediate states and the parameters.
+
+    Args:
+        model (GenericModel): Model to execute.
+        reference (list): Reference to compare with.
+
+    Returns:
+        (list[list[float]], list[list[float]], float): Tuple of all states history and corresponding params and the difference.
+    """
+    reference_mask = CNP.array([model.compartment_name_to_index[c] for c in model.configuration["reference"]["compartments"]])
+    configuration = copy.deepcopy(model.configuration)
+    
+    from . import GenericModel
+    inner_model = GenericModel(configuration)
+    inner_model.evolve = model.evolve
+    reference_mask = CNP.array([inner_model.compartment_name_to_index[c] for c in inner_model.configuration["reference"]["compartments"]])
+
+    inner_model.configuration["simulation"]["n_simulations"] = 1
+    inner_model.configuration["simulation"]["n_executions"] = 1
+    inner_model.N_STEPS = inner_model.configuration["simulation"]["n_steps"]
+    
+    inner_model.populate_model_parameters(**kargs)
+    inner_model.populate_model_compartments(**kargs)
+    saved_state = CNP.zeros((inner_model.configuration["simulation"]["n_steps"], inner_model.state.shape[0]))
+    log_diff = CNP.zeros((1))
+
+    def inner(_model_, step, reference, reference_mask, *args, **kargs):
+        _model_.evolve(_model_, step, *args, **kargs)
+        log_diff[0] += inner_model.get_diff(step, reference, reference_mask)[0]
+        saved_state[step] = _model_.state[:, 0]
+
+    def outer(_model_, *args, **kargs):
+        ...
+        
+    inner_model._internal_run_(
+        inner, (reference_mask, *args), 
+        outer, (), 
+        reference, None,
+        *args, exclude_pupulate=True, **kargs
+    )
+        
+    offset_array(saved_state, inner_model.reference_offset[0])
+    return saved_state.T, inner_model.params[0], log_diff
 
 
 def weighted_quantile(values, quantiles, sample_weight=None, values_sorted=False, old_style=False):
@@ -157,7 +255,7 @@ def weighted_quantile(values, quantiles, sample_weight=None, values_sorted=False
 
     if not values_sorted:
         sorter = CNP.argsort(values)
-        values = values[sorter]
+        values = CNP.copy(values[sorter])
         sample_weight = sample_weight[sorter]
 
     weighted_quantiles = CNP.cumsum(sample_weight) - 0.5 * sample_weight
@@ -170,7 +268,7 @@ def weighted_quantile(values, quantiles, sample_weight=None, values_sorted=False
     return CNP.interp(quantiles, weighted_quantiles, values)
 
 
-def get_percentiles_from_results(model, results, p_minor=5, p_max=95, weights=None, *args, **kargs):
+def get_percentiles_from_results(model: GenericModel, results, p_minor=5, p_max=95, weights=None, *args, **kargs):
     """Returns an array of percentils `p_minor=5`, median and `p_max=95` of the given model and results.
 
     Args:
@@ -181,53 +279,70 @@ def get_percentiles_from_results(model, results, p_minor=5, p_max=95, weights=No
         weights (list[float]|None): Results weights. Defaults to None.
 
     Returns:
-        (list[int, int, list[float]]): First index represents the reference defined in `reference.compartiments`. \
+        (list[int, int, list[float]]): First index represents the reference defined in `reference.compartments`. \
             Second index represents  `p_minor`, median or `p_max=`. Final represents the step in the simulation.
     """
-    reference_mask = CNP.array([model.compartiment_name_to_index[c] for c in model.configuration["reference"]["compartiments"]])
+    reference_mask = CNP.array([model.compartment_name_to_index[c] for c in model.configuration["reference"]["compartments"]])
     
     results_no_diff = results[1:]
     results_percentiles = CNP.zeros((reference_mask.shape[0], 3, model.configuration["simulation"]["n_steps"]))
     
     prev_config = copy.deepcopy(model.configuration)
-
-    model.configuration["simulation"]["n_simulations"] = results.shape[1]
-    model.configuration["simulation"]["n_executions"] = 1
+    configuration = copy.deepcopy(model.configuration)
+    configuration["simulation"]["n_simulations"] = results.shape[1]
+    configuration["simulation"]["n_executions"] = 1
     
-    model.populate_model_parameters(*args, **kargs)
-    model.params[:] = results_no_diff[:]
-    model.populate_model_compartiments(*args, **kargs)
+    from . import GenericModel
+    inner_model = GenericModel(configuration)
+    inner_model.evolve = model.evolve
+
+    inner_model.populate_model_parameters(**kargs)
+    for k in inner_model.params.dtype.names:
+        inner_model.params[k][:] = results_no_diff[inner_model.param_to_index[k]]
+
+    inner_model.populate_model_compartments(**kargs)
+
+    storage = CNP.zeros((configuration["simulation"]["n_steps"], configuration["simulation"]["n_simulations"]))
+    _range = CNP.arange(configuration["simulation"]["n_simulations"])
     
-    def inner(model, step, reference, reference_mask, *args, **kargs):
-        model.evolve(model, step, *args, **kargs)
-        aux = CNP.take(model.state, reference_mask, 0)
-        aux_sorted = CNP.sort(aux)
+    def inner(_model_, step, reference, reference_mask, *args, **kargs):
+        _model_.evolve(_model_, step, *args, **kargs)
+        aux = CNP.take(_model_.state, reference_mask, 0)
         
-        if weights is not None:
-            percentile = lambda x,p: weighted_quantile(x[0], p, weights, True, False)
-        else:
-            percentile = lambda x,p: CNP.percentile(x, p)
 
-        results_percentiles[:, 0, step] += percentile(aux_sorted[0], p_minor)
-        results_percentiles[:, 1, step] += percentile(aux_sorted[0], 50)
-        results_percentiles[:, 2, step] += percentile(aux_sorted[0], p_max)
+        # TODO: improve this so that storage is not bigger than (offset.max - offset.min, n_simulations) 
+        # This line is a bit complex, what it does:
+        # Save in the storage at the correct time for each simulation the values of the aux (=values of state to compare with reference) 
+        # in the same order so that each simulation is treated independently until all simulations stop
+        storage[CNP.clip(_model_.reference_offset + step, 0, _model_.configuration["simulation"]["n_steps"]-1),
+             _range] += aux[0][_range] * (_model_.reference_offset + step < _model_.configuration["simulation"]["n_steps"])
 
         
-    def outer(model, *args, **kargs):
+    def outer(_model_, *args, **kargs):
         ...
         
-    model._internal_run_(
-        inner, (reference_mask,), 
+    inner_model._internal_run_(
+        inner, (reference_mask, *args), 
         outer, (), 
         None, None,
-        *args, **kargs
+        *args, exclude_pupulate=True, **kargs
     )
-    model.configuration.update(prev_config)
-    
+
+    if weights is not None:
+        percentile = lambda x,p: weighted_quantile(x, p, weights, False, False)
+    else:
+        percentile = lambda x,p: CNP.percentile(x, p)
+
+    for step in range(model.configuration["simulation"]["n_steps"]):
+        sort = CNP.sort(storage[step])
+        results_percentiles[:, 0, step] += percentile(sort, p_minor)
+        results_percentiles[:, 1, step] += percentile(sort, 50)
+        results_percentiles[:, 2, step] += percentile(sort, p_max)
+
     return results_percentiles
 
 
-def auto_adjust_model_params(model, results, weights=None, params=None):
+def auto_adjust_model_params(model: GenericModel, results, weights=None, params=None):
     """Adjusts limits of model params. If `params` is specified only those are adjusted.
 
     Args:
@@ -237,7 +352,7 @@ def auto_adjust_model_params(model, results, weights=None, params=None):
         params (list[str], optional): Names of params to optimice. Defaults to None.
     """
     if weights is not None:
-        percentile = lambda x,p: weighted_quantile(x, p, weights, True, False)
+        percentile = lambda x,p: weighted_quantile(x, p, weights, False, False)
     else:
         percentile = lambda x,p: CNP.percentile(x, p)
          
@@ -255,19 +370,42 @@ def auto_adjust_model_params(model, results, weights=None, params=None):
         
         distm = _50 - _5
         distM = _95 - _50
-        # dist = distm + distM
+
+        TYPE = M.get("type", "float64")
+        if "int" in TYPE:
+            MIN = _5 - 1 
+            MAX = _95 + 1
+        else :
+            MIN = _5 * 0.5
+            MAX = _95 * 2
         
-        model.configuration["params"][c].update({
-            # "min" : CNP.clip(_50 - dist*(distm/distM), M.get("min_limit", None), M.get("max_limit", None)), # min(_5, (M["min"]+_5)/2),
-            # "max" : CNP.clip(_50 + dist*(distM/distm), M.get("min_limit", None), M.get("max_limit", None)) # max(_95, (M["max"]+_95)/2)
-            "min" : CNP.clip(min(_50 - distm*(distm/distM), (M["min"]+_5)/2), M.get("min_limit", M["min"]), M.get("max_limit", M["max"])),
-            "max" : CNP.clip(max(_50 + distM*(distM/distm), (M["max"]+_95)/2), M.get("min_limit", M["min"]), M.get("max_limit", M["max"]))
+
+
+        min_probable_value = _5 - distM if distM != 0 else MAX
+        max_probable_value = _95 + distm if distm != 0 else MIN
+
+        # print(f"""{c}:
+        #     min: {min_probable_value},\t {0.9 * (M["min"]*4+_5)/5},\t {M.get("min_limit", None)}
+        #     max: {max_probable_value},\t {1.1 * (M["max"]*4+_95)/5},\t {M.get("max_limit", None)}
+        #     """)
         
-        })
+        # TODO: make a gaussian kernel to infer when probability is 0 and assing as min or max
+        MAX = M.get("max_limit", None)
+        MIN = M.get("min_limit", None)
+        if (MAX is not None) or (MIN is not None):
+            model.configuration["params"][c].update({
+                "min" : CNP.clip(min(min_probable_value, 0.9 * (M["min"]*2+_5)/3), MIN, MAX),
+                "max" : CNP.clip(max(max_probable_value, 1.1 * (M["max"]*2+_95)/3), MIN, MAX)
+            })
+        else:
+            model.configuration["params"][c].update({
+                "min" :min(min_probable_value, 0.9 * (M["min"]*2+_5)/3),
+                "max" :max(max_probable_value, 1.1 * (M["max"]*2+_95)/3)
+            })
         
 
-def get_trajecty_selector(model, results, weights, reference=None):
-    """Creates an interactive ploy and histograms of results. When a histogram is cliced the value of
+def get_trajecty_selector(model: GenericModel, results, weights, reference=None, *args, show_only_reference=False):
+    """Creates an interactive plot and histograms of results. When a histogram is clicked the value of
     that parameter changes to the selected value.
 
     Args:
@@ -275,9 +413,10 @@ def get_trajecty_selector(model, results, weights, reference=None):
         results (list[list[float]]): Results from running the model.
         weights (list[float], optional): Results weights. Defaults to None.
         reference (list[list[float]], optional): If give, is printed to the trajectory. Defaults to None.
+        show_only_reference (boolean, optional): If `True` only the values used to compare with the reference are ploted. Defaults to False.
 
     Returns:
-        (dict[str, float]): Dictionary with the manualy selected params.
+        (dict[str, float]): Dictionary with the manually selected params.
     """
     prev_config = copy.deepcopy(model.configuration)
     fig_sample, ax_sample = plt.subplots()
@@ -285,7 +424,8 @@ def get_trajecty_selector(model, results, weights, reference=None):
     _range = CNP.arange(model.configuration["simulation"]["n_steps"])
     
     # Params used for the trajectory are saved here. This is returned
-    values = {p:v["min"] for p,v in model.configuration["params"].items()}
+    values = {}
+    compartments_ploted = []
     
     fig, *axes = plt.subplots(1, len(results)-1)
     for (p, i), ax in zip(model.param_to_index.items(), axes[0]):
@@ -297,7 +437,8 @@ def get_trajecty_selector(model, results, weights, reference=None):
         ax.vlines(_50, *ax.get_ylim(), 'black')
         ax.vlines(_95, *ax.get_ylim(), 'purple')
         line, _ = ax.plot([(_5+_50)/2,(_5+_50)/2 ],  ax.get_ylim(), 'red', ':')
-        
+        values.update({p:(_5+_50)/2})
+
         # Define a picker por the param ax
         def picker_builder(param, vline):
             def picker(self, event):
@@ -306,8 +447,13 @@ def picker(self, event):
                 values.update({param:x})
                 vline.set_xdata([x,x])
                 # Update trajectory
-                for data, line in zip(update(), sample_lines):
-                    line.set_ydata(data)
+                data, diff = update()
+                ax.set_title(f"diff={diff}")
+                for compartment, line in zip(compartments_ploted, sample_lines):
+                    if show_only_reference and reference is None:
+                        continue
+                    else:
+                        line.set_ydata(data[model.compartment_name_to_index[compartment]])
                 
                 fig_sample.canvas.draw_idle()
                 fig.canvas.draw_idle()
@@ -315,19 +461,32 @@ def picker(self, event):
             return picker
             
         line.set_picker(picker_builder(p, line))
-        values.update({p:(_5+_50)/2})
         ax.set_xlim(xlim)
 
     def update():
-        sample, _ = get_model_sample_trajectory(model, **values)
-        return sample
+        sample, _, diff = get_model_sample_trajectory_with_diff_to_reference(model, reference, *args, **values)
+        return sample, diff
 
-    sample = update()
+    sample, diff = update()
     list_of_sample_lines = []
-    for s in sample:
-        list_of_sample_lines.append(_range)
-        list_of_sample_lines.append(s)
-        list_of_sample_lines.append('-')
+
+    try:
+        if show_only_reference and reference is not None:
+            for k,i in model.compartment_name_to_index.items():
+                if k in model.configuration["reference"]["compartments"]:
+                    compartments_ploted.append(k)
+                    list_of_sample_lines.append(_range)
+                    list_of_sample_lines.append(sample[i])
+                    list_of_sample_lines.append('-')
+
+        else: 
+            raise KeyError
+    except KeyError:
+        compartments_ploted = list(model.compartment_name_to_index.keys())
+        for s in sample:
+            list_of_sample_lines.append(_range)
+            list_of_sample_lines.append(s)
+            list_of_sample_lines.append('-')
         
     sample_lines = ax_sample.plot(*list_of_sample_lines)
     if reference is not None:
diff --git a/docs/README.md b/docs/README.md
new file mode 100644
index 0000000..fb435cd
--- /dev/null
+++ b/docs/README.md
@@ -0,0 +1,78 @@
+<!-- Copyright 2023 Unai Lería Fortea & Pablo Vizcaíno García
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. -->
+
+[![PyPI Downloads](https://img.shields.io/pypi/dm/compartmental.svg?label=downloads)](https://pypi.org/project/compartmental/)
+[![PyPI Version](https://img.shields.io/pypi/v/compartmental?)](https://pypi.org/project/compartmental/)
+
+![Commit activity](https://img.shields.io/github/commit-activity/m/QuanticPony/compartmental)
+[![License](https://img.shields.io/pypi/l/compartmental)](LICENSE)
+[![Build](https://img.shields.io/github/actions/workflow/status/QuanticPony/compartmental/ci-master.yml)](https://github.com/QuanticPony/compartmental/actions)
+
+[![Python Version](https://img.shields.io/pypi/pyversions/compartmental)](https://pypi.org/project/compartmental/)
+[![Wheel](https://img.shields.io/pypi/wheel/compartmental)](https://pypi.org/project/compartmental/)
+
+<br></br>
+<h1 align="center">
+compartmental
+</h1>
+<h2 align="center">
+Utility tools for Approximate Bayesian computation on compartmental models 
+</h2>
+
+<br>
+<div align="center">
+
+<a href="https://quanticpony.github.io/compartmental/">
+<img src=https://img.shields.io/github/deployments/QuanticPony/compartmental/github-pages?label=documentation>
+</a>
+<br></br></br>
+<h3 align="center">
+
+</h3>
+
+
+
+
+
+</div>
+
+# Instalation
+**compartmental** releases are available as wheel packages on [PyPI](https://pypi.org/project/compartmental/). You can install the last version using `pip`:
+```
+pip install compartmental
+```
+
+
+# Documentation
+Documentations is automatically generated from code on main push and hosted in github-pages [here](https://quanticpony.github.io/compartmental/).
+
+# Help
+Just open an issue with the `question` tag ([or clic here](https://github.com/QuanticPony/compartmental/issues/new?assignees=QuanticPony&labels=question&template=question.md&title=)), I would love to help!
+
+# Contributing
+You can contribute with:
+
+* Examples
+* Documentation
+* [Bug report/fix](https://github.com/QuanticPony/compartmental/issues/new?assignees=QuanticPony&labels=bug&template=bug_report.md&title=)
+* [Features](https://github.com/QuanticPony/compartmental/issues/new?assignees=QuanticPony&labels=new-feature&template=feature_request.md&title=)
+* Code
+
+Even only feedback is greatly apreciated. 
+
+Just create an issue and let me know you want to help! 
+
+
+# Licensing
+**compartmental** is released under the **Apache License Version 2.0**.
\ No newline at end of file
diff --git a/docs/SUMMARY.md b/docs/SUMMARY.md
index 22b7f17..4e6055e 100644
--- a/docs/SUMMARY.md
+++ b/docs/SUMMARY.md
@@ -6,5 +6,6 @@
         * [util](reference/compartmental/util.md)
 * examples
     * examples
+        * [MY_MODEL](examples/MY_MODEL.md)
         * [SEIR](examples/SEIR.md)
         * [SIR](examples/SIR.md)
diff --git a/docs/examples/MY_MODEL.md b/docs/examples/MY_MODEL.md
new file mode 100644
index 0000000..44cf3cb
--- /dev/null
+++ b/docs/examples/MY_MODEL.md
@@ -0,0 +1,292 @@
+<!-- Copyright 2023 Unai Lería Fortea
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. -->
+
+This examples follows the model exposed in my [Physics Undergraduate Thesis Project (2021-2022)](https://deposita.unizar.es/record/69350?ln=es) whose code can be found 
+[GitHub repository](https://github.com/QuanticPony/Analysis-of-effectiveness-of-lockdown-policies-for-desease-containment).
+
+
+The main equations of the model are the following:
+$$
+\begin{align}
+    \tag{4.5} S_h[t+1]    &= S_T[t] \cdot (1-p(t))sh (1-\phi)\\
+    \tag{4.6} S[t+1]      &= (S_T[t] - S_h[t]) \cdot (1- P_{infection})\\
+    \tag{4.7} E[t+1]      &= (S_T[t]-S_h[t]) \cdot P_{infection} + (1-\eta)\cdot E[t]\\
+    \tag{4.8} I[t+1]      &= \eta \cdot E[t]  + (1- \mu)\cdot I[t]\\
+    \tag{4.9} R[t+1]      &=  \mu (1-IFR) \cdot I[t]  + R[t] \\
+    \tag{4.10} P_d[t+1]    &=  \mu IFR \cdot I[t] + (1-\xi)\cdot P_d[t] \\
+    \tag{4.11} D[t+1]      &= \xi\cdot P_d[t] + D[t] 
+\end{align}
+$$
+
+Where:
+$$
+\begin{equation} \tag{4.3}
+    P_{infection} = p(t)\cdot P_{infection}^{active} + (1-p(t))(1-sh(1-\phi))\cdot P_{infection}^{lockdown},
+\end{equation}
+$$
+
+$$
+\begin{equation*}
+    P_{infection}^{j} = 1- \left(1-\lambda\frac{I}{N}\right)^{\left<k_j\right>}; \quad \textrm{with} \quad j=active, lockdown.
+\end{equation*}
+$$
+
+The configuration could be:
+
+```json
+model = {
+    "simulation": {
+        "n_simulations": 100000,
+        "n_executions": 1,
+        "n_steps": 100
+    },
+    "compartments": {
+        "Sh": { "initial_value": 0 },
+        "S": { 
+            "initial_value": 1,
+            "minus_compartments": "I"
+        },
+        "E": { "initial_value": 0 },
+        "I": { 
+            "initial_value": "Io",
+        },
+        "R": { "initial_value": 0 },
+        "Pd": { "initial_value": 0 },
+        "D": { "initial_value": 0 },
+    },
+    "params": {
+        "betta": {
+            "min": 0.01,
+            "max": 0.3,
+            "min_limit": 0.01, // (1)
+            "max_limit": 0.3
+        },
+        "Io": {
+            "min": 1e-8,
+            "max": 1e-5,
+            "min_limit": 0,
+            "max_limit": 1e-4
+        },
+        "phi": {
+            "min": 0,
+            "max": 0.5,
+            "min_limit": 0,
+            "max_limit": 1
+        },
+        "IFR": {
+            "min":0.006,
+            "max":0.014,
+            "min_limit": 0.006,
+            "max_limit": 0.014
+        },
+        "offset": {
+            "type": "int", // (2)
+            "min":5,
+            "max":10,
+            "min_limit": 0,
+            "max_limit": 10
+        }
+    },
+    "fixed_params": {
+        "K_active": 12.4,
+        "K_lockdown": 2.4,
+        "sigma": 3.4,
+        "mu": 1/4.2,
+        "eta":1/5.2,
+        "xi":1/10,
+    },
+    "reference": {
+        "compartments" : ["D"],
+        "offset": "offset" // (3)
+    },
+    "results": { 
+        "save_percentage": 0.5
+    }
+}
+```
+
+1. `min_limit` and `max_limit` are the absolute limits in the automatic adjustment
+2. This `offset` parameter will be used as an offset between the simulated data and the reference data
+3. An offset can be applied to the reference while comparing it with the simulation data. Can be an interger or a parameter name defined in `params` 
+
+Now we need to define the evolution function of the system and assign it to the model. In this case the evolution function is a lot more complicated than in previous examples. 
+
+> **Note:** In case of complex problems like this it may be needed to write `[:]` on values assignation. 
+
+
+```py
+import compartmental
+compartmental.use_numpy()
+# compartmental.use_cupy() # For GPU usage
+
+MyModel = compartmental.GenericModel(model)
+
+def evolve(m, time, p_active, *args, **kargs):
+    ST = m.S + m.Sh
+    sh = (1 - m.I) ** (m.sigma - 1)
+
+    P_infection_active = 1- (1- m.betta * m.I) ** m.K_active
+    P_infection_lockdown = 1- (1- m.betta * m.I) ** m.K_lockdown
+
+    P_infection = p_active[time] * P_infection_active + (1-p_active[time]) * (1-sh*(1-m.phi)) * P_infection_lockdown
+
+
+    m.Sh[:]    = ST * (1-p_active[time])*sh*(1-m.phi)
+    delta_S = ST * P_infection
+    m.S[:]     = (ST - m.Sh)  - delta_S
+   
+    m.D[:]     = m.xi * m.Pd
+    m.R[:]     = m.mu * (1-m.IFR)  * m.I + m.R
+    m.Pd[:]    = m.mu * m.IFR  * m.I + (1-m.xi) * m.Pd
+    m.I[:]     = m.eta  * m.E + (1- m.mu) * m.I
+    m.E[:]     = delta_S + (1-m.eta) * m.E
+    
+MyModel.evolve = evolve
+```
+
+For this example we will use a `p_active` defined as follows:
+```py
+p_active = [1 if t<35 else 0.1 for t in range(model["simulation"]["n_steps"])]
+```
+
+Once the model is defined and the evolution function is set we can create a trajectory of the model. We can set specific values for the random parameters as follows:
+
+```py
+sample, sample_params = compartmental.util.get_model_sample_trajectory(
+    MyModel, p_active,
+    **{"betta": 0.13,
+        "Io": 1e-6,
+        "phi": 0.1,
+        "IFR": 0.01,
+        "offset": 8} # (1)
+)
+
+reference = numpy.copy(sample[MyModel.compartment_name_to_index["D"]])
+```
+1. Here the offset will be used to automatically offset the values because the parameter `offset` is defined as the reference's offset in the model configuration.
+
+Plotting the `sample` yields:
+
+```py
+import matplotlib.pyplot as plt
+list_of_sample_lines = []
+_range = numpy.arange(model["simulation"]["n_steps"])
+
+for s in sample:
+    list_of_sample_lines.append(_range)
+    list_of_sample_lines.append(s)
+    list_of_sample_lines.append('-')
+    
+sample_lines = plt.plot(*list_of_sample_lines)
+for line, compartment in zip(sample_lines, model["compartments"]):
+    line.set_label(compartment)
+
+plt.title("Compartments population evolution")
+plt.xlabel("Time")
+plt.ylabel("Population / Total")
+plt.legend()
+plt.show()
+```
+![](../images/my_model_1.png)
+
+
+________
+Now we can use the `sample` and try to infer the values of $\beta$, $Io$, $\phi$, $IFR$ and the `offset`:
+
+```py
+ITERS = 15
+
+# Main loop of adjustments:
+# 1. Run
+# 2. Read results
+# 3. Compute weights
+# 4. Adjuts configuration
+for i in range(ITERS):
+    MyModel.run(reference, f"my_model{i}.data", p_active)
+    
+    results = compartmental.util.load_parameters(f"my_model{i}.data")
+    
+    weights = numpy.exp(-2*results[0]/numpy.min(results[0]))
+
+    compartmental.util.auto_adjust_model_params(MyModel, results, weights)
+
+
+# Update for final photo with more simulations
+MyModel.configuration.update({
+    "simulation": {
+        "n_simulations": 1000000,
+        "n_executions": 4,
+        "n_steps": 100
+    },
+    "results": {
+        "save_percentage": 0.01
+    }
+})
+
+MyModel.run(reference, "my_model.data", p_active)
+```
+
+
+Finnally we can plot the results:
+
+```py
+results = compartmental.util.load_parameters("my_model.data")
+weights = numpy.exp(-2*results[0]/numpy.min(results[0]))
+weights /= numpy.min(weights)
+
+percentiles = compartmental.util.get_percentiles_from_results(MyModel, results, 30, 70, weights, p_active, weights)
+try:
+    # In case cupy is used
+    percentiles = percentiles.get()
+    sample = sample.get()
+    weights = weights.get()
+    results = results.get()
+    sample_params = sample_params.get()
+except AttributeError:
+    pass
+
+# Plot sample with a shadow of the results.
+plt.figure()
+plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
+plt.xlabel("Simulation time")
+plt.ylabel("Daily Deaths / Total population")
+plt.plot(reference, 'black')
+plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
+tax = plt.twinx()
+tax.plot(p_active, ':', color='green')
+tax.set_ylabel(r"$p(t)$")
+
+# Histograms with infered likelihood of the parameters
+fig, *axes = plt.subplots(1, len(results)-1)
+fig.set_figheight(3.5)
+fig.set_figwidth(16)
+for i, ax in enumerate(axes[0], 1):
+    _5, _50, _95 = compartmental.util.weighted_quantile(results[i], [5, 50, 95], weights)
+    for k, index in MyModel.param_to_index.items():
+        if index == i-1:
+            ax.set_title(k)
+    ax.hist(results[i], weights=weights)
+    
+    ax.vlines(_5, *ax.get_ylim(), 'green')
+    ax.vlines(_50, *ax.get_ylim(), 'black')
+    ax.vlines(_95, *ax.get_ylim(), 'purple')
+
+    ax.vlines(sample_params[i-1], ax.get_ylim()[0], ax.get_ylim()[1]*3/4, 'red')
+    
+
+plt.show()
+```
+
+![](../images/my_model_2.png)
+![](../images/my_model_3.png)
diff --git a/docs/examples/SEIR.md b/docs/examples/SEIR.md
index d58ae41..468ec78 100644
--- a/docs/examples/SEIR.md
+++ b/docs/examples/SEIR.md
@@ -30,10 +30,10 @@ seir_model = {
         "n_executions": 1, // (3)
         "n_steps": 230 // (4)
     },
-    "compartiments": { // (5)
+    "compartments": { // (5)
         "S": { 
             "initial_value": 1, // (6)
-            "minus_compartiments": "I" // (7)
+            "minus_compartments": "I" // (7)
         },
         "E": { "initial_value": 0 },
         "I": { 
@@ -57,7 +57,7 @@ seir_model = {
         "eta":0.08
     },
     "reference": { // (12)
-        "compartiments" : ["R"]
+        "compartments" : ["R"]
     },
     "results": { 
         "save_percentage": 0.01 // (13)
@@ -70,17 +70,17 @@ seir_model = {
 3.  Number of times the simulation runs
 4.  Number of times the evolution function is executed each simulation
 
-5.  Here we define the compartiments of the model. Each field must be unique
+5.  Here we define the compartments of the model. Each field must be unique
 6.  Initial value set to a fixed number
-7.  You subtract the value of other compartiments after all of them are initialized
-8.  You can set the initial value of compartiments as parameters
+7.  You subtract the value of other compartments after all of them are initialized
+8.  You can set the initial value of compartments as parameters
 
 9.  Here we define parameters that will be randomly generated for each simulation. Each field must be unique
 10. A min value and max value must be set for each parameter
 
 11. Definition of constant for all the simulations
 
-12. Definition of which compartiments the results should be compared with
+12. Definition of which compartments the results should be compared with
 
 13. Percentage of simulations that will be saved. The best of course
 
@@ -115,10 +115,10 @@ Plotting the `sample` yields:
 
 ```py
 import matplotlib.pyplot as plt
-plt.plot(sample[SeirModel.compartiment_name_to_index["S"]], 'green')
-plt.plot(sample[SeirModel.compartiment_name_to_index["E"]], 'red')
-plt.plot(sample[SeirModel.compartiment_name_to_index["I"]], 'orange')
-plt.plot(sample[SeirModel.compartiment_name_to_index["R"]], 'brown')
+plt.plot(sample[SeirModel.compartment_name_to_index["S"]], 'green')
+plt.plot(sample[SeirModel.compartment_name_to_index["E"]], 'red')
+plt.plot(sample[SeirModel.compartment_name_to_index["I"]], 'orange')
+plt.plot(sample[SeirModel.compartment_name_to_index["R"]], 'brown')
 plt.show()
 ```
 ![](../images/seir_1.png)
@@ -128,7 +128,7 @@ ________
 Now we can use the `sample` and try to infer the values of $\beta$ and $Io$. 
 
 ```py
-SeirModel.run(sample[SeirModel.compartiment_name_to_index["R"]], "seir.data")
+SeirModel.run(sample[SeirModel.compartment_name_to_index["R"]], "seir.data")
 ```
 The results are save in the `seir.data` file. We load them, compute the weights and the percentiles `30` and `70` with:
 ```py
@@ -142,7 +142,7 @@ Finally plot the reference values with the percentiles and histograms for the pa
 ```py
 plt.figure()
 plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
-plt.plot(sample[SeirModel.compartiment_name_to_index["R"]], 'black')
+plt.plot(sample[SeirModel.compartment_name_to_index["R"]], 'black')
 plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
 
 fig, *axes = plt.subplots(1, len(results)-1)
diff --git a/docs/examples/SIR.md b/docs/examples/SIR.md
index 06ce99c..9a9f230 100644
--- a/docs/examples/SIR.md
+++ b/docs/examples/SIR.md
@@ -30,10 +30,10 @@ sir_model = {
         "n_executions": 1,
         "n_steps": 130
     },
-    "compartiments": {
+    "compartments": {
         "S": { 
             "initial_value": 1,
-            "minus_compartiments": "I"
+            "minus_compartments": "I"
         },
         "I": { 
             "initial_value": "Io",
@@ -58,7 +58,7 @@ sir_model = {
         "K_mean": 1
     },
     "reference": {
-        "compartiments" : ["R"]
+        "compartments" : ["R"]
     },
     "results": {
         "save_percentage": 0.1
@@ -95,7 +95,7 @@ sample, sample_params = gcm.util.get_model_sample_trajectory(SirModel, **{"betta
 Now we apply the automatic adjustment of the model. Keep in mind it will only work if the initial ranges of the `params` are set close to the optimal values.
 ```py
 for i in range(7):
-    SirModel.run(sample[SirModel.compartiment_name_to_index["R"]], f"sir_temp{i}.data")
+    SirModel.run(sample[SirModel.compartment_name_to_index["R"]], f"sir_temp{i}.data")
     
     results = gcm.util.load_parameters(f"sir_temp{i}.data")
     
@@ -104,7 +104,7 @@ for i in range(7):
 
 Finally we run the model once again to get the final photo:
 ```py
-SirModel.run(sample[SirModel.compartiment_name_to_index["R"]], "sir.data")
+SirModel.run(sample[SirModel.compartment_name_to_index["R"]], "sir.data")
 results = gcm.util.load_parameters("sir.data")
 ```
 
@@ -147,9 +147,9 @@ except AttributeError:
 
 plt.figure()
 plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
-plt.plot(sample[SirModel.compartiment_name_to_index["S"]], 'green')
-plt.plot(sample[SirModel.compartiment_name_to_index["I"]], 'orange')
-plt.plot(sample[SirModel.compartiment_name_to_index["R"]], 'brown')
+plt.plot(sample[SirModel.compartment_name_to_index["S"]], 'green')
+plt.plot(sample[SirModel.compartment_name_to_index["I"]], 'orange')
+plt.plot(sample[SirModel.compartment_name_to_index["R"]], 'brown')
 plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
 
 
diff --git a/docs/images/my_model_1.png b/docs/images/my_model_1.png
new file mode 100644
index 0000000..596f4c0
Binary files /dev/null and b/docs/images/my_model_1.png differ
diff --git a/docs/images/my_model_2.png b/docs/images/my_model_2.png
new file mode 100644
index 0000000..ab8d50c
Binary files /dev/null and b/docs/images/my_model_2.png differ
diff --git a/docs/images/my_model_3.png b/docs/images/my_model_3.png
new file mode 100644
index 0000000..8a21562
Binary files /dev/null and b/docs/images/my_model_3.png differ
diff --git a/docs/index.md b/docs/index.md
deleted file mode 100644
index e69de29..0000000
diff --git a/docs/javascripts/mathjax.js b/docs/javascripts/mathjax.js
new file mode 100644
index 0000000..0f4b6e6
--- /dev/null
+++ b/docs/javascripts/mathjax.js
@@ -0,0 +1,16 @@
+window.MathJax = {
+    tex: {
+      inlineMath: [["\\(", "\\)"]],
+      displayMath: [["\\[", "\\]"]],
+      processEscapes: true,
+      processEnvironments: true
+    },
+    options: {
+      ignoreHtmlClass: ".*|",
+      processHtmlClass: "arithmatex"
+    }
+  };
+  
+  document$.subscribe(() => {
+    MathJax.typesetPromise()
+  })
\ No newline at end of file
diff --git a/examples/MY_MODEL.md b/examples/MY_MODEL.md
new file mode 100644
index 0000000..fbc8915
--- /dev/null
+++ b/examples/MY_MODEL.md
@@ -0,0 +1,293 @@
+<!-- Copyright 2023 Unai Lería Fortea
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License. -->
+
+This examples follows the model exposed in my [Physics Undergraduate Thesis Project (2021-2022)](https://deposita.unizar.es/record/69350?ln=es) whose code can be found 
+[GitHub repository](https://github.com/QuanticPony/Analysis-of-effectiveness-of-lockdown-policies-for-desease-containment).
+
+
+The main equations of the model are the following:
+
+
+$$
+\begin{align}
+    \tag{4.5} S_h[t+1]    &= S_T[t] \cdot (1-p(t))sh (1-\phi)\\
+    \tag{4.6} S[t+1]      &= (S_T[t] - S_h[t]) \cdot (1- P_{infection})\\
+    \tag{4.7} E[t+1]      &= (S_T[t]-S_h[t]) \cdot P_{infection} + (1-\eta)\cdot E[t]\\
+    \tag{4.8} I[t+1]      &= \eta \cdot E[t]  + (1- \mu)\cdot I[t]\\
+    \tag{4.9} R[t+1]      &=  \mu (1-IFR) \cdot I[t]  + R[t] \\
+    \tag{4.10} P_d[t+1]    &=  \mu IFR \cdot I[t] + (1-\xi)\cdot P_d[t] \\
+    \tag{4.11} D[t+1]      &= \xi\cdot P_d[t] + D[t] 
+\end{align}
+$$
+
+Where 
+
+
+$$
+\begin{align} 
+    \tag{4.3} P_{infection} &= p(t)\cdot P_{infection}^{active} + (1-p(t))(1-sh(1-\phi))\cdot P_{infection}^{lockdown}, \\
+    P_{infection}^{j} &= 1- \left(1-\lambda\frac{I}{N}\right)^{\left<k_j\right>}; \quad \textrm{with} \quad j=active, lockdown.\\
+    sh &= (1-\frac{I}{N})^{\sigma-1}
+\end{align}
+$$
+
+
+The configuration could be:
+
+```json
+model = {
+    "simulation": {
+        "n_simulations": 100000,
+        "n_executions": 1,
+        "n_steps": 100
+    },
+    "compartments": {
+        "Sh": { "initial_value": 0 },
+        "S": { 
+            "initial_value": 1,
+            "minus_compartments": "I"
+        },
+        "E": { "initial_value": 0 },
+        "I": { 
+            "initial_value": "Io",
+        },
+        "R": { "initial_value": 0 },
+        "Pd": { "initial_value": 0 },
+        "D": { "initial_value": 0 },
+    },
+    "params": {
+        "betta": {
+            "min": 0.01,
+            "max": 0.3,
+            "min_limit": 0.01, // (1)
+            "max_limit": 0.3
+        },
+        "Io": {
+            "min": 1e-8,
+            "max": 1e-5,
+            "min_limit": 0,
+            "max_limit": 1e-4
+        },
+        "phi": {
+            "min": 0,
+            "max": 0.5,
+            "min_limit": 0,
+            "max_limit": 1
+        },
+        "IFR": {
+            "min":0.006,
+            "max":0.014,
+            "min_limit": 0.006,
+            "max_limit": 0.014
+        },
+        "offset": {
+            "type": "int", // (2)
+            "min":5,
+            "max":10,
+            "min_limit": 0,
+            "max_limit": 10
+        }
+    },
+    "fixed_params": {
+        "K_active": 12.4,
+        "K_lockdown": 2.4,
+        "sigma": 3.4,
+        "mu": 1/4.2,
+        "eta":1/5.2,
+        "xi":1/10,
+    },
+    "reference": {
+        "compartments" : ["D"],
+        "offset": "offset" // (3)
+    },
+    "results": { 
+        "save_percentage": 0.5
+    }
+}
+```
+
+1. `min_limit` and `max_limit` are the absolute limits in the automatic adjustment
+2. This `offset` parameter will be used as an offset between the simulated data and the reference data
+3. An offset can be applied to the reference while comparing it with the simulation data. Can be an interger or a parameter name defined in `params` 
+
+Now we need to define the evolution function of the system and assign it to the model. In this case the evolution function is a lot more complicated than in previous examples. 
+
+> **Note:** In case of complex problems like this it may be needed to write `[:]` on values assignation. 
+
+
+```py
+import compartmental
+compartmental.use_numpy()
+# compartmental.use_cupy() # For GPU usage
+
+MyModel = compartmental.GenericModel(model)
+
+def evolve(m, time, p_active, *args, **kargs):
+    ST = m.S + m.Sh
+    sh = (1 - m.I) ** (m.sigma - 1)
+
+    P_infection_active = 1- (1- m.betta * m.I) ** m.K_active
+    P_infection_lockdown = 1- (1- m.betta * m.I) ** m.K_lockdown
+
+    P_infection = p_active[time] * P_infection_active + (1-p_active[time]) * (1-sh*(1-m.phi)) * P_infection_lockdown
+
+
+    m.Sh[:]    = ST * (1-p_active[time])*sh*(1-m.phi)
+    delta_S = ST * P_infection
+    m.S[:]     = (ST - m.Sh)  - delta_S
+   
+    m.D[:]     = m.xi * m.Pd
+    m.R[:]     = m.mu * (1-m.IFR)  * m.I + m.R
+    m.Pd[:]    = m.mu * m.IFR  * m.I + (1-m.xi) * m.Pd
+    m.I[:]     = m.eta  * m.E + (1- m.mu) * m.I
+    m.E[:]     = delta_S + (1-m.eta) * m.E
+    
+MyModel.evolve = evolve
+```
+
+For this example we will use a `p_active` defined as follows:
+```py
+p_active = [1 if t<35 else 0.1 for t in range(model["simulation"]["n_steps"])]
+```
+
+Once the model is defined and the evolution function is set we can create a trajectory of the model. We can set specific values for the random parameters as follows:
+
+```py
+sample, sample_params = compartmental.util.get_model_sample_trajectory(
+    MyModel, p_active,
+    **{"betta": 0.13,
+        "Io": 1e-6,
+        "phi": 0.1,
+        "IFR": 0.01,
+        "offset": 8} # (1)
+)
+
+reference = numpy.copy(sample[MyModel.compartment_name_to_index["D"]])
+```
+1. Here the offset will be used to automatically offset the values because the parameter `offset` is defined as the reference's offset in the model configuration.
+
+Plotting the `sample` yields:
+
+```py
+import matplotlib.pyplot as plt
+list_of_sample_lines = []
+_range = numpy.arange(model["simulation"]["n_steps"])
+
+for s in sample:
+    list_of_sample_lines.append(_range)
+    list_of_sample_lines.append(s)
+    list_of_sample_lines.append('-')
+    
+sample_lines = plt.plot(*list_of_sample_lines)
+for line, compartment in zip(sample_lines, model["compartments"]):
+    line.set_label(compartment)
+
+plt.title("Compartments population evolution")
+plt.xlabel("Time")
+plt.ylabel("Population / Total")
+plt.legend()
+plt.show()
+```
+![](../images/my_model_1.png)
+
+
+________
+Now we can use the `sample` and try to infer the values of $\beta$, $Io$, $\phi$, $IFR$ and the `offset`:
+
+```py
+ITERS = 15
+
+# Main loop of adjustments:
+# 1. Run
+# 2. Read results
+# 3. Compute weights
+# 4. Adjuts configuration
+for i in range(ITERS):
+    MyModel.run(reference, f"my_model{i}.data", p_active)
+    
+    results = compartmental.util.load_parameters(f"my_model{i}.data")
+    
+    weights = numpy.exp(-2*results[0]/numpy.min(results[0]))
+
+    compartmental.util.auto_adjust_model_params(MyModel, results, weights)
+
+
+# Update for final photo with more simulations
+MyModel.configuration.update({
+    "simulation": {
+        "n_simulations": 1000000,
+        "n_executions": 4,
+        "n_steps": 100
+    },
+    "results": {
+        "save_percentage": 0.01
+    }
+})
+
+MyModel.run(reference, "my_model.data", p_active)
+```
+
+
+Finnally we can plot the results:
+
+```py
+results = compartmental.util.load_parameters("my_model.data")
+weights = numpy.exp(-2*results[0]/numpy.min(results[0]))
+weights /= numpy.min(weights)
+
+percentiles = compartmental.util.get_percentiles_from_results(MyModel, results, 30, 70, weights, p_active, weights)
+try:
+    # In case cupy is used
+    percentiles = percentiles.get()
+    sample = sample.get()
+    weights = weights.get()
+    results = results.get()
+    sample_params = sample_params.get()
+except AttributeError:
+    pass
+
+# Plot sample with a shadow of the results.
+plt.figure()
+plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
+plt.xlabel("Simulation time")
+plt.ylabel("Daily Deaths / Total population")
+plt.plot(reference, 'black')
+plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
+tax = plt.twinx()
+tax.plot(p_active, ':', color='green')
+tax.set_ylabel(r"$p(t)$")
+
+# Histograms with infered likelihood of the parameters
+fig, *axes = plt.subplots(1, len(results)-1)
+fig.set_figheight(3.5)
+fig.set_figwidth(16)
+for i, ax in enumerate(axes[0], 1):
+    _5, _50, _95 = compartmental.util.weighted_quantile(results[i], [5, 50, 95], weights)
+    for k, index in MyModel.param_to_index.items():
+        if index == i-1:
+            ax.set_title(k)
+    ax.hist(results[i], weights=weights)
+    
+    ax.vlines(_5, *ax.get_ylim(), 'green')
+    ax.vlines(_50, *ax.get_ylim(), 'black')
+    ax.vlines(_95, *ax.get_ylim(), 'purple')
+
+    ax.vlines(sample_params[i-1], ax.get_ylim()[0], ax.get_ylim()[1]*3/4, 'red')
+    
+
+plt.show()
+```
+
+![](../images/my_model_2.png)
+![](../images/my_model_3.png)
diff --git a/examples/SEIR.md b/examples/SEIR.md
index d58ae41..468ec78 100644
--- a/examples/SEIR.md
+++ b/examples/SEIR.md
@@ -30,10 +30,10 @@ seir_model = {
         "n_executions": 1, // (3)
         "n_steps": 230 // (4)
     },
-    "compartiments": { // (5)
+    "compartments": { // (5)
         "S": { 
             "initial_value": 1, // (6)
-            "minus_compartiments": "I" // (7)
+            "minus_compartments": "I" // (7)
         },
         "E": { "initial_value": 0 },
         "I": { 
@@ -57,7 +57,7 @@ seir_model = {
         "eta":0.08
     },
     "reference": { // (12)
-        "compartiments" : ["R"]
+        "compartments" : ["R"]
     },
     "results": { 
         "save_percentage": 0.01 // (13)
@@ -70,17 +70,17 @@ seir_model = {
 3.  Number of times the simulation runs
 4.  Number of times the evolution function is executed each simulation
 
-5.  Here we define the compartiments of the model. Each field must be unique
+5.  Here we define the compartments of the model. Each field must be unique
 6.  Initial value set to a fixed number
-7.  You subtract the value of other compartiments after all of them are initialized
-8.  You can set the initial value of compartiments as parameters
+7.  You subtract the value of other compartments after all of them are initialized
+8.  You can set the initial value of compartments as parameters
 
 9.  Here we define parameters that will be randomly generated for each simulation. Each field must be unique
 10. A min value and max value must be set for each parameter
 
 11. Definition of constant for all the simulations
 
-12. Definition of which compartiments the results should be compared with
+12. Definition of which compartments the results should be compared with
 
 13. Percentage of simulations that will be saved. The best of course
 
@@ -115,10 +115,10 @@ Plotting the `sample` yields:
 
 ```py
 import matplotlib.pyplot as plt
-plt.plot(sample[SeirModel.compartiment_name_to_index["S"]], 'green')
-plt.plot(sample[SeirModel.compartiment_name_to_index["E"]], 'red')
-plt.plot(sample[SeirModel.compartiment_name_to_index["I"]], 'orange')
-plt.plot(sample[SeirModel.compartiment_name_to_index["R"]], 'brown')
+plt.plot(sample[SeirModel.compartment_name_to_index["S"]], 'green')
+plt.plot(sample[SeirModel.compartment_name_to_index["E"]], 'red')
+plt.plot(sample[SeirModel.compartment_name_to_index["I"]], 'orange')
+plt.plot(sample[SeirModel.compartment_name_to_index["R"]], 'brown')
 plt.show()
 ```
 ![](../images/seir_1.png)
@@ -128,7 +128,7 @@ ________
 Now we can use the `sample` and try to infer the values of $\beta$ and $Io$. 
 
 ```py
-SeirModel.run(sample[SeirModel.compartiment_name_to_index["R"]], "seir.data")
+SeirModel.run(sample[SeirModel.compartment_name_to_index["R"]], "seir.data")
 ```
 The results are save in the `seir.data` file. We load them, compute the weights and the percentiles `30` and `70` with:
 ```py
@@ -142,7 +142,7 @@ Finally plot the reference values with the percentiles and histograms for the pa
 ```py
 plt.figure()
 plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
-plt.plot(sample[SeirModel.compartiment_name_to_index["R"]], 'black')
+plt.plot(sample[SeirModel.compartment_name_to_index["R"]], 'black')
 plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
 
 fig, *axes = plt.subplots(1, len(results)-1)
diff --git a/examples/SIR.md b/examples/SIR.md
index 06ce99c..9a9f230 100644
--- a/examples/SIR.md
+++ b/examples/SIR.md
@@ -30,10 +30,10 @@ sir_model = {
         "n_executions": 1,
         "n_steps": 130
     },
-    "compartiments": {
+    "compartments": {
         "S": { 
             "initial_value": 1,
-            "minus_compartiments": "I"
+            "minus_compartments": "I"
         },
         "I": { 
             "initial_value": "Io",
@@ -58,7 +58,7 @@ sir_model = {
         "K_mean": 1
     },
     "reference": {
-        "compartiments" : ["R"]
+        "compartments" : ["R"]
     },
     "results": {
         "save_percentage": 0.1
@@ -95,7 +95,7 @@ sample, sample_params = gcm.util.get_model_sample_trajectory(SirModel, **{"betta
 Now we apply the automatic adjustment of the model. Keep in mind it will only work if the initial ranges of the `params` are set close to the optimal values.
 ```py
 for i in range(7):
-    SirModel.run(sample[SirModel.compartiment_name_to_index["R"]], f"sir_temp{i}.data")
+    SirModel.run(sample[SirModel.compartment_name_to_index["R"]], f"sir_temp{i}.data")
     
     results = gcm.util.load_parameters(f"sir_temp{i}.data")
     
@@ -104,7 +104,7 @@ for i in range(7):
 
 Finally we run the model once again to get the final photo:
 ```py
-SirModel.run(sample[SirModel.compartiment_name_to_index["R"]], "sir.data")
+SirModel.run(sample[SirModel.compartment_name_to_index["R"]], "sir.data")
 results = gcm.util.load_parameters("sir.data")
 ```
 
@@ -147,9 +147,9 @@ except AttributeError:
 
 plt.figure()
 plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
-plt.plot(sample[SirModel.compartiment_name_to_index["S"]], 'green')
-plt.plot(sample[SirModel.compartiment_name_to_index["I"]], 'orange')
-plt.plot(sample[SirModel.compartiment_name_to_index["R"]], 'brown')
+plt.plot(sample[SirModel.compartment_name_to_index["S"]], 'green')
+plt.plot(sample[SirModel.compartment_name_to_index["I"]], 'orange')
+plt.plot(sample[SirModel.compartment_name_to_index["R"]], 'brown')
 plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
 
 
diff --git a/examples/my_model.ipynb b/examples/my_model.ipynb
new file mode 100644
index 0000000..b28f7c9
--- /dev/null
+++ b/examples/my_model.ipynb
@@ -0,0 +1,570 @@
+{
+ "cells": [
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "<!-- Copyright 2023 Unai Lería Fortea\n",
+    "\n",
+    "Licensed under the Apache License, Version 2.0 (the \"License\");\n",
+    "you may not use this file except in compliance with the License.\n",
+    "You may obtain a copy of the License at\n",
+    "\n",
+    "    http://www.apache.org/licenses/LICENSE-2.0\n",
+    "\n",
+    "Unless required by applicable law or agreed to in writing, software\n",
+    "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
+    "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
+    "See the License for the specific language governing permissions and\n",
+    "limitations under the License. -->\n",
+    "\n",
+    "How to use the **compartmental** package with a more complex model:\n",
+    "\n",
+    "$$\n",
+    "\\begin{equation} \\tag{4.3}\n",
+    "    P_{infection} = p(t)\\cdot P_{infection}^{active} + (1-p(t))(1-sh(1-\\phi))\\cdot P_{infection}^{lockdown},\n",
+    "\\end{equation}\n",
+    "$$\n",
+    "$$\n",
+    "\\begin{equation*}\n",
+    "    P_{infection}^{j} = 1- \\left(1-\\lambda\\frac{I}{N}\\right)^{\\left<k_j\\right>}; \\quad \\textrm{with} \\quad j=active, lockdown.\n",
+    "\\end{equation*}\n",
+    "$$\n",
+    "\n",
+    "$$\n",
+    "\\begin{align}\n",
+    "    \\tag{4.5} S_h[t+1]    &= S_T[t] \\cdot (1-p(t))sh (1-\\phi)\\\\\n",
+    "    \\tag{4.6} S[t+1]      &= (S_T[t] - S_h[t]) \\cdot (1- P_{infection})\\\\\n",
+    "    \\tag{4.7} E[t+1]      &= (S_T[t]-S_h[t]) \\cdot P_{infection} + (1-\\eta)\\cdot E[t]\\\\\n",
+    "    \\tag{4.8} I[t+1]      &= \\eta \\cdot E[t]  + (1- \\mu)\\cdot I[t]\\\\\n",
+    "    \\tag{4.9} R[t+1]      &=  \\mu (1-IFR) \\cdot I[t]  + R[t] \\\\\n",
+    "    \\tag{4.10} P_d[t+1]    &=  \\mu IFR \\cdot I[t] + (1-\\xi)\\cdot P_d[t] \\\\\n",
+    "    \\tag{4.11} D[t+1]      &= \\xi\\cdot P_d[t] + D[t] \n",
+    "\\end{align}\n",
+    "$$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import compartmental \n",
+    "# compartmental.use_cupy()\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "First we must create the model configuration:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = {\n",
+    "    \"simulation\": {\n",
+    "        \"n_simulations\": 100000,\n",
+    "        \"n_executions\": 1,\n",
+    "        \"n_steps\": 100\n",
+    "    },\n",
+    "    \"compartments\": {\n",
+    "        \"Sh\": { \"initial_value\": 0 },\n",
+    "        \"S\": { \n",
+    "            \"initial_value\": 1,\n",
+    "            \"minus_compartments\": \"I\"\n",
+    "        },\n",
+    "        \"E\": { \"initial_value\": 0 },\n",
+    "        \"I\": { \n",
+    "            \"initial_value\": \"Io\",\n",
+    "        },\n",
+    "        \"R\": { \"initial_value\": 0 },\n",
+    "        \"Pd\": { \"initial_value\": 0 },\n",
+    "        \"D\": { \"initial_value\": 0 },\n",
+    "    },\n",
+    "    \"params\": {\n",
+    "        \"betta\": {\n",
+    "            \"min\": 0.01,\n",
+    "            \"max\": 0.3,\n",
+    "            \"min_limit\": 0.01,\n",
+    "            \"max_limit\": 0.3\n",
+    "        },\n",
+    "        \"Io\": {\n",
+    "            \"min\": 1e-8,\n",
+    "            \"max\": 1e-5,\n",
+    "            \"min_limit\": 0,\n",
+    "            \"max_limit\": 1e-4\n",
+    "        },\n",
+    "        \"phi\": {\n",
+    "            \"min\": 0,\n",
+    "            \"max\": 0.5,\n",
+    "            \"min_limit\": 0,\n",
+    "            \"max_limit\": 1\n",
+    "        },\n",
+    "        \"IFR\": {\n",
+    "            \"min\":0.006,\n",
+    "            \"max\":0.014,\n",
+    "            \"min_limit\": 0.006,\n",
+    "            \"max_limit\": 0.014\n",
+    "        },\n",
+    "        \"offset\": {\n",
+    "            \"type\": \"int\",\n",
+    "            \"min\":5,\n",
+    "            \"max\":10,\n",
+    "            \"min_limit\": 0,\n",
+    "            \"max_limit\": 10\n",
+    "        }\n",
+    "    },\n",
+    "    \"fixed_params\": {\n",
+    "        \"K_active\": 12.4,\n",
+    "        \"K_lockdown\": 2.4,\n",
+    "        \"sigma\": 3.4,\n",
+    "        \"mu\": 1/4.2,\n",
+    "        \"eta\":1/5.2,\n",
+    "        \"xi\":1/10,\n",
+    "    },\n",
+    "    \"reference\": {\n",
+    "        \"compartments\" : [\"D\"],\n",
+    "        \"offset\": \"offset\" \n",
+    "    },\n",
+    "    \"results\": { \n",
+    "        \"save_percentage\": 0.5\n",
+    "    }\n",
+    "}"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we define the evolution function, following the master differential equations shown before:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "MyModel = compartmental.GenericModel(model)\n",
+    "\n",
+    "def evolve(m, time, p_active, *args, **kargs):\n",
+    "    ST = m.S + m.Sh\n",
+    "    sh = (1 - m.I) ** (m.sigma - 1)\n",
+    "\n",
+    "    P_infection_active = 1- (1- m.betta * m.I) ** m.K_active\n",
+    "    P_infection_lockdown = 1- (1- m.betta * m.I) ** m.K_lockdown\n",
+    "\n",
+    "    P_infection = p_active[time] * P_infection_active + (1-p_active[time]) * (1-sh*(1-m.phi)) * P_infection_lockdown\n",
+    "\n",
+    "\n",
+    "    m.Sh[:]    = ST * (1-p_active[time])*sh*(1-m.phi)\n",
+    "    delta_S = ST * P_infection\n",
+    "    m.S[:]     = (ST - m.Sh)  - delta_S\n",
+    "   \n",
+    "    m.D[:]     = m.xi * m.Pd\n",
+    "    m.R[:]     = m.mu * (1-m.IFR)  * m.I + m.R\n",
+    "    m.Pd[:]    = m.mu * m.IFR  * m.I + (1-m.xi) * m.Pd\n",
+    "    m.I[:]     = m.eta  * m.E + (1- m.mu) * m.I\n",
+    "    m.E[:]     = delta_S + (1-m.eta) * m.E\n",
+    "    \n",
+    "MyModel.evolve = evolve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "p_active = [1 if t<35 else 0.1 for t in range(model[\"simulation\"][\"n_steps\"])]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once the model is defined and the evolution function is set we can create a trajectory of the model. We can set specific values for the random parameters as follows:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n"
+     ]
+    }
+   ],
+   "source": [
+    "sample, sample_params = compartmental.util.get_model_sample_trajectory(\n",
+    "    MyModel, p_active,\n",
+    "    **{\"betta\": 0.13,\n",
+    "        \"Io\": 1e-6,\n",
+    "        \"phi\": 0.1,\n",
+    "        \"IFR\": 0.01,\n",
+    "        \"offset\": 8}\n",
+    ")\n",
+    "# OFFSET = 8\n",
+    "\n",
+    "reference = numpy.copy(sample[MyModel.compartment_name_to_index[\"D\"]])\n",
+    "\n",
+    "# This reference will be used in the comparision while compartmental is running. The correct value of the param offset is then thi OFFSET\n",
+    "# reference_no_offset = numpy.copy(reference)\n",
+    "# compartmental.util.offset_array(reference, -OFFSET)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x219be7da450>"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "list_of_sample_lines = []\n",
+    "_range = numpy.arange(model[\"simulation\"][\"n_steps\"])\n",
+    "\n",
+    "for s in sample:\n",
+    "    list_of_sample_lines.append(_range)\n",
+    "    list_of_sample_lines.append(s)\n",
+    "    list_of_sample_lines.append('-')\n",
+    "    \n",
+    "sample_lines = plt.plot(*list_of_sample_lines)\n",
+    "for line, compartment in zip(sample_lines, model[\"compartments\"]):\n",
+    "    line.set_label(compartment)\n",
+    "\n",
+    "plt.title(\"Compartments population evolution\")\n",
+    "plt.xlabel(\"Time\")\n",
+    "plt.ylabel(\"Population / Total\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We will treat this sample as data to which we will fit the model parameters. In particular, we will only use for the fitting the *recuperated* compartment (`\"R\"`).\n",
+    "\n",
+    "We will also use the automatic adjustment of the model. Keep in mind it will only work if the initial ranges of the `params` are set close to optimal values. To see this adjustment in action we save the range `min` and `max` of each parameter to represent them later."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n",
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n"
+     ]
+    }
+   ],
+   "source": [
+    "ITERS = 15\n",
+    "# This array is created to store min and max of params configuration in order to see the adjustment in action.\n",
+    "saved_params_lims = numpy.zeros((len(MyModel.configuration[\"params\"]), 2, ITERS))\n",
+    "\n",
+    "# Main loop of adjustments:\n",
+    "# 1. Run\n",
+    "# 2. Read results\n",
+    "# 3. Compute weights\n",
+    "# 4. Adjuts configuration\n",
+    "for i in range(ITERS):\n",
+    "    MyModel.run(reference, f\"my_model{i}.data\", p_active)\n",
+    "    \n",
+    "    results = compartmental.util.load_parameters(f\"my_model{i}.data\")\n",
+    "    \n",
+    "    weights = numpy.exp(-2*results[0]/numpy.min(results[0]))\n",
+    "    weights /= numpy.min(weights)\n",
+    "\n",
+    "    compartmental.util.auto_adjust_model_params(MyModel, results, weights)\n",
+    "    \n",
+    "    # Needed to see the max and min evolution in the adjustment\n",
+    "    for p, v in MyModel.configuration[\"params\"].items():\n",
+    "        saved_params_lims[MyModel.param_to_index[p], 0, i] = v[\"min\"]\n",
+    "        saved_params_lims[MyModel.param_to_index[p], 1, i] = v[\"max\"]"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we can plot how the parameters limits have been modified in those iterations."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjcAAAHHCAYAAABDUnkqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABlM0lEQVR4nO3dd1hT1/8H8HfYeygCgmxRQVCcVK0bS611dDmriF3+3GJtta27dbZqa91b66xbW3FQR7UoyqoLREVBZKqAgMyc3x+WfI2gEggEwvv1PDyak5tzP7kJ5J1zz71XIoQQICIiIlITGqougIiIiEiZGG6IiIhIrTDcEBERkVphuCEiIiK1wnBDREREaoXhhoiIiNQKww0RERGpFYYbIiIiUisMN0RERKRWGG6oWpJIJBgzZsxrl9u0aRMkEgnu3r1b+UURvcTp06chkUhw+vRpWdvw4cPh6Oio1PV06dIFXbp0UWqf1UVl/S6r8zajl2O4IarFtm/fjqVLl6q6DCqnBw8eYObMmYiIiFB1KSp1/fp1zJw5k19ySIbhhmq0oUOH4unTp3BwcFB1KTUSw03lWbt2LaKjo5Xa5/Hjx3H8+HHZ7QcPHmDWrFkMN9evY9asWaWGmxe3GdUOWqougKgiNDU1oampqeoyXik3Nxc6OjrQ0Kgd3yWkUiny8/Ohp6dXpuWFEMjNzYW+vn4lV1a1tLW1ld6njo6O0vtUd9xmtVPt+GtL1cLMmTMhkUgQFRWF/v37w8TEBHXr1sX48eORm5tb6mMOHDgADw8P6OrqomnTpggMDJS7v7T99BkZGYiKikJGRsZra3J0dMS7776L48ePw8vLC3p6enB3d8e+ffvklnv06BG+/PJLeHp6wsjICCYmJujZsyciIyPlliuee7Fz50589913sLW1hYGBATIzMxXuY/fu3Zg1axZsbW1hbGyMDz/8EBkZGcjLy8OECRNgaWkJIyMj+Pv7Iy8vr8Rz++2339CqVSvo6+ujTp06GDhwIOLj42X3d+nSBX/88Qfu3bsHiUQCiUQiN0ckLy8PM2bMQMOGDaGrqws7Ozt89dVXJdZVPD9q27ZtaNq0KXR1dUu8TqVt82PHjqF169bQ19fH6tWrAQAbN25Et27dYGlpCV1dXbi7u2PlypUv7ePcuXNo27Yt9PT04OzsjC1btpRY9t9//0Xnzp2hr6+PBg0a4Pvvv8fGjRtLnd9x9OhRdOzYEYaGhjA2NkavXr1w7dq1lz6XV3lxzs3du3chkUjw448/Yvny5XB2doaBgQHeeustxMfHQwiBOXPmoEGDBtDX10ffvn3x6NEjuT6fnz9y+vRptGnTBgDg7+8vew03bdoEAIiJicEHH3wAa2tr6OnpoUGDBhg4cGCZfi8uXryIt99+G6ampjAwMEDnzp1x/vx52f179uyBRCLBmTNnSjx29erVkEgkuHr1qqztr7/+km1XMzMz9O3bFzdu3HhtHRKJBDNnzizR7ujoiOHDhwN49jfgo48+AgB07dpVth2K5z+VNucmJSUFn3zyCaysrKCnp4fmzZtj8+bNcss8/3qtWbMGLi4u0NXVRZs2bXDp0qXX1k6qxZEbqnL9+/eHo6Mj5s2bhwsXLuCXX37B48ePS3wwnTt3Dvv27cOoUaNgbGyMX375BR988AHi4uJQt27dl/a/f/9++Pv7Y+PGjbI/gK8SExODAQMGYOTIkfDz88PGjRvx0UcfITAwED169AAA3LlzBwcOHMBHH30EJycnJCcnY/Xq1ejcuTOuX78OGxsbuT7nzJkDHR0dfPnll8jLy4OOjg6uX7+uUB/z5s2Dvr4+pkyZglu3bmHZsmXQ1taGhoYGHj9+jJkzZ+LChQvYtGkTnJycMH36dNljf/jhB0ybNg39+/fHp59+itTUVCxbtgydOnVCeHg4zMzM8O233yIjIwP379/HkiVLAABGRkYAno2+9OnTB+fOncPnn38ONzc3XLlyBUuWLMHNmzdx4MABuVr/+usv7N69G2PGjIGFhcVrJ9JGR0dj0KBB+OKLL/DZZ5+hcePGAICVK1eiadOm6NOnD7S0tHD48GGMGjUKUqkUo0ePluvj1q1b+PDDD/HJJ5/Az88PGzZswPDhw9GqVSs0bdoUAJCQkCD7wJs6dSoMDQ2xbt066Orqlqhp69at8PPzg6+vLxYsWICcnBysXLkSb775JsLDw5U2OXjbtm3Iz8/H2LFj8ejRIyxcuBD9+/dHt27dcPr0aXz99dey1/vLL7/Ehg0bSu3Hzc0Ns2fPxvTp0/H555+jY8eOAID27dsjPz8fvr6+yMvLw9ixY2FtbY2EhAQcOXIE6enpMDU1fWl9f/31F3r27IlWrVphxowZ0NDQkIXOv//+G23btkWvXr1gZGSE3bt3o3PnznKP37VrF5o2bQoPDw8AwMmTJ9GzZ084Oztj5syZePr0KZYtW4YOHTogLCyswtu1U6dOGDduHH755Rd88803cHNzk22f0jx9+hRdunTBrVu3MGbMGDg5OeH333/H8OHDkZ6ejvHjx8stv337djx58gRffPEFJBIJFi5ciPfffx937typlNE5UhJBVEVmzJghAIg+ffrItY8aNUoAEJGRkbI2AEJHR0fcunVL1hYZGSkAiGXLlsnaNm7cKACI2NjYEm0bN258bU0ODg4CgNi7d6+sLSMjQ9SvX1+0aNFC1pabmyuKiorkHhsbGyt0dXXF7NmzZW2nTp0SAISzs7PIycmRW17RPjw8PER+fr6sfdCgQUIikYiePXvK9dGuXTvh4OAgu3337l2hqakpfvjhB7nlrly5IrS0tOTae/XqJffYYlu3bhUaGhri77//lmtftWqVACDOnz8vawMgNDQ0xLVr10r0U5ribR4YGFjivhe3mRBC+Pr6Cmdn51L7OHv2rKwtJSVF6OrqikmTJsnaxo4dKyQSiQgPD5e1PXz4UNSpU0fuffPkyRNhZmYmPvvsM7n1JCUlCVNT0xLtLyp+zU6dOiVr8/Pzk9u2sbGxAoCoV6+eSE9Pl7VPnTpVABDNmzcXBQUFsvZBgwYJHR0dkZubK2vr3Lmz6Ny5s+z2pUuXSn2vh4eHCwDi999/f2XdL5JKpcLV1VX4+voKqVQqa8/JyRFOTk6iR48ecvVZWlqKwsJCWVtiYqLQ0NCQez97eXkJS0tL8fDhQ1lbZGSk0NDQEMOGDZO1lfa7DEDMmDGjRJ0ODg7Cz89Pdvv3338vsf2LvbjNli5dKgCI3377TdaWn58v2rVrJ4yMjERmZqYQ4n+vV926dcWjR49kyx48eFAAEIcPHy6xLqo+uFuKqtyL38DHjh0LAPjzzz/l2n18fODi4iK73axZM5iYmODOnTuv7H/48OEQQpRp1AYAbGxs8N5778lum5iYYNiwYQgPD0dSUhIAQFdXVzZnpqioCA8fPoSRkREaN26MsLCwEn36+fmVmEOiaB/Dhg2T+2bo7e0NIQRGjBght5y3tzfi4+NRWFgIANi3bx+kUin69++PtLQ02Y+1tTVcXV1x6tSp126T33//HW5ubmjSpIlcH926dQOAEn107twZ7u7ur+23mJOTE3x9fUu0P7/NMjIykJaWhs6dO+POnTsldqe4u7vLRisAoF69emjcuLHc+yMwMBDt2rWDl5eXrK1OnToYMmSIXF8nTpxAeno6Bg0aJPd8NTU14e3tXaZtVlYfffSR3MiJt7c3AODjjz+GlpaWXHt+fj4SEhIUXkdx/8eOHUNOTk6ZHxcREYGYmBgMHjwYDx8+lG2H7OxsdO/eHWfPnoVUKgUADBgwACkpKXKHv+/ZswdSqRQDBgwAACQmJiIiIgLDhw9HnTp1ZMs1a9YMPXr0KPE7XxX+/PNPWFtbY9CgQbI2bW1tjBs3DllZWSV2tQ0YMADm5uay28Xvudf9HSLV4m4pqnKurq5yt11cXKChoVFi/oO9vX2Jx5qbm+Px48dKradhw4aQSCRybY0aNQLwbL+7tbU1pFIpfv75Z6xYsQKxsbEoKiqSLVvaLjInJ6cSbYr28eLzL/7AsrOzK9EulUqRkZGBunXrIiYmBkKIEtu5WFmG0mNiYnDjxg3Uq1ev1PtTUlLkbpf2fF/lZcufP38eM2bMQHBwcIkP5YyMDLlQUJb3x71799CuXbsSyzVs2FDudkxMDADIwtuLTExMXvJMFKfI6wqgXO93JycnBAQEYPHixdi2bRs6duyIPn364OOPP37lLqni7eDn5/fSZTIyMmBubi6bk7Nr1y50794dwLNdUl5eXrLfn3v37gGAbLfj89zc3HDs2DFkZ2fD0NBQ4edYXvfu3YOrq2uJCf7Fu7GKay724utVHHSU/XeIlIvhhlTuxWBR7GVHQQkhKrOcUs2dOxfTpk3DiBEjMGfOHNSpUwcaGhqYMGGC7Jvs80o78kfRPl72/F+3XaRSKSQSCY4ePVrqssXzal5FKpXC09MTixcvLvX+Fz+IFT3SqbTlb9++je7du6NJkyZYvHgx7OzsoKOjgz///BNLliwpsY2U+f4o7nvr1q2wtrYucf/zIyoVVd7XVVE//fQThg8fjoMHD+L48eMYN26cbJ5bgwYNSn1M8XZYtGiR3GjX84rfP7q6uujXrx/279+PFStWIDk5GefPn8fcuXPLVa8inv9iUNmq098hKjuGG6pyMTExct/cb926BalUqvSzuZbVrVu3IISQC1k3b94EAFlNe/bsQdeuXbF+/Xq5x6anp8PCwqJM61FGH2Xh4uICIQScnJxk36Bf5mXB0sXFBZGRkejevftLl1G2w4cPIy8vD4cOHZL7tlyRXUIODg64detWifYX24p3f1paWsLHx6fc66tqr3ttPD094enpie+++w7//PMPOnTogFWrVuH7778vdfni7WBiYlKm7TBgwABs3rwZQUFBuHHjBoQQsl1SAGTnnyrtfD9RUVGwsLB45aiNubk50tPT5dry8/ORmJgo16bIe9TBwQH//vsvpFKp3OhNVFSUXM1Us3HODVW55cuXy91etmwZAKBnz55K6V+RQ8GBZydC279/v+x2ZmYmtmzZAi8vL9m3eE1NzRLf1H7//XeF5kMoo4+yeP/996GpqYlZs2aVWJ8QAg8fPpTdNjQ0LHU79e/fHwkJCVi7dm2J+54+fYrs7Gyl1gz87xvy8zVnZGRg48aN5e7T19cXwcHBcie5e/ToEbZt21ZiORMTE8ydOxcFBQUl+klNTS13DZWpOBi8GAAyMzNlc7CKeXp6QkNDo9TTBhRr1aoVXFxc8OOPPyIrK6vE/S9uBx8fH9SpUwe7du3Crl270LZtW7kvLvXr14eXlxc2b94sV+PVq1dx/PhxvPPOO698fi4uLjh79qxc25o1a0qM3LxsO5TmnXfeQVJSEnbt2iVrKywsxLJly2BkZFTi6C+qmThyQ1UuNjYWffr0wdtvv43g4GD89ttvGDx4MJo3b66U/hU9FLxRo0b45JNPcOnSJVhZWWHDhg1ITk6W+1B99913MXv2bPj7+6N9+/a4cuUKtm3bBmdn5zLXpYw+ysLFxQXff/89pk6dirt376Jfv34wNjZGbGws9u/fj88//xxffvklgGcfZrt27UJAQADatGkDIyMj9O7dG0OHDsXu3bsxcuRInDp1Ch06dEBRURGioqKwe/du2TlqlOmtt96Cjo4OevfujS+++AJZWVlYu3YtLC0tS3xTL6uvvvoKv/32G3r06IGxY8fKDgW3t7fHo0ePZN/4TUxMsHLlSgwdOhQtW7bEwIEDUa9ePcTFxeGPP/5Ahw4d8Ouvvyrz6SqFi4sLzMzMsGrVKhgbG8PQ0BDe3t6IjIzEmDFj8NFHH6FRo0YoLCzE1q1boampiQ8++OCl/WloaGDdunXo2bMnmjZtCn9/f9ja2iIhIQGnTp2CiYkJDh8+LFteW1sb77//Pnbu3Ins7Gz8+OOPJfpctGgRevbsiXbt2uGTTz6RHQpuampa6jlsnvfpp59i5MiR+OCDD9CjRw9ERkbi2LFjJUY6vby8oKmpiQULFiAjIwO6urqy8yW96PPPP8fq1asxfPhwhIaGwtHREXv27MH58+exdOlSGBsbv2arU41Q9QdoUW1VfCj49evXxYcffiiMjY2Fubm5GDNmjHj69KncsgDE6NGjS/Tx4iGgyjgUvFevXuLYsWOiWbNmQldXVzRp0qTEIbS5ubli0qRJon79+kJfX1906NBBBAcHlzjMtPiQ4NIOwa1oH8XP69KlS3Ltxds1NTVVrn3v3r3izTffFIaGhsLQ0FA0adJEjB49WkRHR8uWycrKEoMHDxZmZmYCgNyhy/n5+WLBggWiadOmQldXV5ibm4tWrVqJWbNmiYyMDNlyL3utXqZ4m5fm0KFDolmzZkJPT084OjqKBQsWiA0bNpR4jV/Wx4vbUohnh0V37NhR6OrqigYNGoh58+aJX375RQAQSUlJcsueOnVK+Pr6ClNTU6GnpydcXFzE8OHDxeXLl1/5nBQ5FHzRokWlPrYsr3dpz+/gwYPC3d1daGlpyd73d+7cESNGjBAuLi5CT09P1KlTR3Tt2lWcPHnylc+jWHh4uHj//fdF3bp1ha6urnBwcBD9+/cXQUFBJZY9ceKEACAkEomIj48vtb+TJ0+KDh06CH19fWFiYiJ69+4trl+/Xurzff51LioqEl9//bWwsLAQBgYGwtfXV9y6davE3wEhhFi7dq1wdnYWmpqacq9FadssOTlZ+Pv7CwsLC6GjoyM8PT1L/L142eslxMsPUafqQyIEZ0VR1Zg5cyZmzZqF1NRUpc4xqQhHR0d4eHjgyJEjqi6FqtCECROwevVqZGVlVfvLdxCR4jjnhojU2tOnT+VuP3z4EFu3bsWbb77JYEOkpjjnhojUWrt27dClSxe4ubkhOTkZ69evR2ZmJqZNm6bq0oiokjDcEJFae+edd7Bnzx6sWbMGEokELVu2xPr169GpUydVl0ZElYRzboiIiEitcM4NERERqRWGGyIiIlIrtW7OjVQqxYMHD2BsbFxlp5UnIiKiihFC4MmTJ7CxsSlx4dMX1bpw8+DBgxIX/SMiIqKaIT4+/qUXfy1W68JN8am14+PjYWJiouJqiIiIqCwyMzNhZ2dXpktk1Lpw8/y1ZBhuiIiIapayTCnhhGIiIiJSKww3REREpFYYboiIiEitMNwQERGRWmG4ISIiIrXCcENERERqheGGiIiI1ArDDREREakVhhsiIiJSKww3REREpFYYboiIiEitMNwQERGRWmG4ISIiIrXCcENEpERCCFWXQFTrMdwQESlJRk4B+q8ORlJGrqpLIarVGG6IiJTkq72RuHT3MYZvDMGT3AJVl0NUazHcEBEpwZbguzh2LRkAEJX0BP/3WxgKiqQqroqodmK4ISKqoGsPMvD9Hzfk2s7dSsPXe/9VUUVEtRvDDRFRBWTnFWLs9nDkF5YcpdkXloAfj0WroCqi2o3hhoioAqYduIo7adkvvf/XU7ewIySuCisiIoYbNVFYJMXOkDgcjEhQdSlEtcae0PvYF/7637nvDlzFX1HJVVAREQGAlqoLoIopLJJiX1gClp2KQfyjpwCAP68k4vt+nqhnrKvi6ojU162ULEw/eLVMyxZJBcZsD8fOz99AswZmlVsYEXHkpqYqkgrsCb2P7ovP4Ku9/8qCDQAcu5aMt5ac4SgOUSXJLSjC2B3hyMkvKvNjcvKLMGLTZcQ/yqnEyogIYLipcaRSgf3h9+Gz+Ay+/D0S9x6W/ofycU4Bxu+MwOdbLiP1SV4VV0mk3n744wZuJGYq/Li0rDz4bQxBek5+JVRFRMUYbmoIqVTgYEQCeiw5g4m7IhH7igmMzzt+PRk9lpzBgTLMCyCi1wu8moitF+6V+/F3UrPx6ebLyC0o+6gPESlGImrZhVAyMzNhamqKjIwMmJiYqLqc1xJC4I8rifj5ZAxiUrIq1FcPdyv88J4HLI31lFQdUe0S/ygHvX75G5m5hRXuq6eHNZYPbgkNDYkSKiNSf4p8fnPkppoSQuDPK4l4e+nfGLM9vMLBBgBOXE/GW0vOchSHqBwKi6QYtzNcKcEGAI5eTcKcP64rpS8iksejpaoZIQSOXUvGz0Ex5dqn/zrpOQWYsCsCf1xJ5CgOkQIWHY9GeFy6UvvceP4ubM308WlHZ6X2S1TbMdxUIyeuJ2PpyZu49kD5oaa0dYXEPsLMPu54r0WDSl8fUU12OjoFa87eqZS+f/jzBuqb6qNXs/qV0j9RbcRwUw38FZWMpSdj8O/9jCpdb8bTAkzcFYk//k3C3Pc8YGnCURyiF6Vk5mLS7khU1uxEIYCJuyNgaaKLNo51KmclRLUM59yo0KnoFPRdfh4jNl2u8mDzvJM3ktFjyVnsC7uvshqIqiOpVGDCrgg8zK7cQ7fzC6X4bMtl3FLC3DoiYrhRibM3U/HeivPw33gJkfHpqi4HwLNRnIDdkfh08yWkZOaquhyiauHXU7fwz+2HVbKu9JwCDN8YgpQn/P0jqiiGmyp0/lYaPlz5D4ZtCFH6xERlOXkjBT2WnMXeUI7iUO128c5D/BwUU6XrvP/4KT7ZdBnZeco5IouotmK4qQIX7jxE/9XBGLLuIi7fe6zqcl4r42kBJv0eiU82cRSHaqfH2fkYvzMCRdKqPw3YlYQMjN4ehsIiaZWvm0hdMNxUopDYRxi05gIGrrmAkNhHqi5HYUFRz0Zx9nAUh2qZL3+PRJIKg/3p6FR8d6BsF+UkopIYbipB6L1HGLLuAvqvDkbwnarZX19ZMp4W4Mv/RnGSOYpDtcD6c7EIikpRdRnYeSkev1TxbjGq+bLzCrHqzG3kFdbuy3sw3CjR4+x8DF1/ER+sDMb5WzU71LwoKCoFPRaf4SgOqbUr9zOw4GiUqsuQWXziJn/nqMxup2ah3/LzmH80CiM2XarVc7cYbpQo+Uku/o5JU3UZlSYztxBf/h6JEZsuISmDozikXp7kFmDMjjDkV7O5LlP3/Yu/Y1JVXQZVc0evJKLvr+dll+o5f+shBq+7WGuvQM9wQwr7KyoFby05g98vx6u6FCKl+Wb/Vdx7mKPqMkooKBL4v9/CcL0KzlxONU+RVGDunzfwf9vCkPXCSE1kfDr6rw6ulVMKGG6oXDJzCzF5z7/w3xjCURyq8XaGxOFw5ANVl/FSWXmF8N8UggfpT1VdClUjqU/yMGTdhVdeGuRmchY+XPUP7j3MrsLKVI/hhirkVHQqeiw5g90cxSEA8Y9ycCA8AVIVHEJdXjeTn2Dm4WuqLuO1kjPzMHxjCDKeFqi6FKoGQu89wrvL/saFO68/Ejf+0VN8uCoYUUm1Z/RPIkRlXTGlesrMzISpqSkyMjJgYmKi1L6jkjLx9tK/ldpnTdKlcT38X2cXaGlKIAQg8Oz09QL47/azxudvC9ntZ8vh+fbn7pP+d6d4xeMBwMZMn9fnUZEH6U/Rf3Uw7j9+iibWxpjs2xjd3axUXdYr5RYUoc+v53AzueZc9uAN5zrYMsIbOlr8blpbbTwfi7l/3kBBkWIf36b62tgwvA1aOZhXUmWVS5HPb4YbJart4aY6kEiAcd1cMcHHFRKJRNXl1BopmbnovzoYd1+Ys9LG0Rxfv90Eratp4Jyy91/svFTzRh37NLfBzwO9+B6vZXLyCzF13xUcjCj/LlQDHU2s+rgVOjWqp8TKqoYin9+M/qRWhAB+DorBF1tDS0yuo8qRlpWHwesulgg2AHDp7mN8uCoYn2y6hOikJyqo7uUORT6okcEGeFb7/MDqc8g6Vb7YtGy8t/yfCgUbAMjJL8Knmy/jzyuJSqqsemK4IbV0/Hoy3lt+HnfTatckuqr2ODsfH6+7+NqrWQdFpaDnz2cRsCsC8Y9Uf0TSvYfZ+GbfFVWXUSGrz9zBluC7qi6DqsCxa0nos+wcopOV8wUhv0iKsTvCsetSnFL6q44YbkhtxaRkoe/y8zhzk+cIqQwZTwswdMNFRJVxREYqgH3hCej+0xnMPHQND7PyKrnC0uUXSjFme7hajOzNPHQNx68lqboMqiRFUoH5R6Mw8rdQPFHy+7VIKvD13itYc/a2UvutLhhuSK1lPC3AiE2XsPqMev4Cq0pWXiH8NoTgaoLiR1/kF0mx6Z+76LTwFJacuFnlIWNBYBSuJGRU6Tori1QA43aGIyyu+l+QlxTzMCsPQ9dfxKozt1GZM2Pn/hmFhWq4i5PhhtRekVRg3tEojN8ZjtyC2n29FWXIyS+E/8YQRMSnV6if7Pwi/BwUg84LT2H9uVjkF1b+mYGDbiRj/bnYSl9PVcotkOLTzZe5C1aNhMU9xrvLzuGf21VzGZ8Vp2/j2/1XatQpHF6H4YZqjYMRD/Dhqn94IrQKyC14Nhnx0l3ljRQ8zM7HnCPX0fXH09gTer/S/sAmZjzFl79HVkrfqvYoOx9+G0NUtquPlGdL8F0MXH0BiVV8ctRtF+MwflcECqrZ5UfKi+GGapWrCZno8+s5hMS+/sRXJC+vsAifbw2ttG+TCenPwsfbP5/FievJSu27SCowfkcEHueo7wnw7j3MwSebL+NpPkcna6Kn+UWYuCsC0w9eU9n1zQ5HPsDnWy6rxQg3ww3VOmlZ+Riy7gK28kiTMisokmL0tnCcrYLJ2TeTs/DZlsv4YOU/SguhP5+8iZC76h9oI+LT8emWS9gXdh9RSZkoVJNv4erublo23ltxHvvDE1RdCk5Fp2LY+hBk5tbsLwI8iZ8S8SR+Nc+gtnaY1ceDZ3t9hSKpwNgdYfjzimqOyunauB6+ersJ3OqX7/f1n1tp+Hj9RajRdIIy09HSQCMrI7jXN4FbfRO41zeBu40JjPW0VV0a/efE9WQE7I7Ak9zqdfReUxsTbB7RFhZGuqouRYZnKH4Fhht6UWsHc6z4uCUsjfVUXUq1I5UKBOyOwIEKnjisojQkz87KO+mtxrCrY1Dmx6Vl5eGdn/9GyhPORSkmkQANzPWfBZ36pnCrbwx3GxM0MC/7dqWKk0oFfjoRjRWnK/doqIpwtjDE1k+9YWumr+pSADDcvBLDDZXG2kQPq4e2QnM7M1WXUm0IIfDVnn/xe+h9VZcio60pwaC29hjbzRX1jF/9jVIIAb+Nl6pkV5o6MNXXfhZ06pvC3cYEbvWN0cjKGNqaHNVUtkfZ+Ri3IxznbqWpupTXsjHVw9ZPveFSz0jVpTDcvArDDb2MrpYG5r7niQ9aNVB1KdXCt/uvYNvF6nkGUwMdTXzyphM+7+T80l0sq87cxvyj6nf+jqqko6kBF0sj2e6s4n9N9blbq7wi49Pxf7+F4kEVHw1VEXUNdbB5RFt42JqqtA6Gm1dguKHXGdHBCd/2coOmRu29KOHsw9ex4Xz1Px+MuYE2RndtiKHtHKCrpSlrD4t7jP6rglFYGyfaVAFbM/1nc3j+CzxNbUwU2l1YW/124R5mH76usqOhKsJYVwtr/VrjDee6KquB4eYVGG6oLDo0rIvlg1vCzEBH1aVUuflHo7Cqhp3R2cZUDxN6NMIHLRsgK68QvX75G/cf83xGVclYT0s2aXloO4dqsRujusgtKMK3+69ib1j12cVbHrpaGlgxpCW6u1mpZP0MN6/AcENlZV/HAGuGtUITa+W+T6qzJSdu4uegGFWXUW6ulkawMNJF8J2qObMrlU5HUwOfdnTCuO6u0NPWfP0D1Fjcwxx88VsobiQqfqmS6khLQ4IfP2qOfi1sq3zdinx+c6YY0UvEPcrB+yv+wdEriaoupUqsOH2rRgcb4NnFUhlsVC+/SIoVp2/DZ/EZpZ+QsSb5KyoZ7y77W22CDQAUSgUm7o6o9lekZ7gheoWc/CKM2h6Gn45HQ50HOdf9fQcLA6NVXQapmfuPn+KzLZfx6eZLiH+Uo+pyqoxUKvDT8Wh8svkyMqvZ+WuUQQhg+sFr+KUafxmqFuFm+fLlcHR0hJ6eHry9vRESElKmx+3cuRMSiQT9+vWr3AKpVhMCWPbXLXy25TKe1PCzdpZma/BdfP/HDVWXQWrs5I0U9FhyBr/+FVMlF0hVpasJGRi64SKW/XWr2p6/RlkWn7iJOUeuV8svfioPN7t27UJAQABmzJiBsLAwNG/eHL6+vkhJSXnl4+7evYsvv/wSHTt2rKJKqbY7eSMF7634B3dSs1RditLsvhSP6YeuqboMqgVyC6T48fhNvP3zWZyLqf7nd1FUeNxjjNh0Ce8uO4fzt2rPrtH152Lx1Z5/UVTNjkxUebhZvHgxPvvsM/j7+8Pd3R2rVq2CgYEBNmzY8NLHFBUVYciQIZg1axacnZ2rsFqq7W6lZKHv8vM4Ff3q8F0THAhPwJR9/6r9t0uqXu6kZuPj9RcxZnsYUjJrzrleXubinYf4eN1FvLfiH/wVVfP/LpTH76H3MWpbKPIKq88FN1UabvLz8xEaGgofHx9Zm4aGBnx8fBAcHPzSx82ePRuWlpb45JNPXruOvLw8ZGZmyv0QVcST3EJ8sukSVpy+pepSyu2PfxMx6ffIWnm9JaoejvybiO4/ncH6c7HV7lt/Wfwdk4r+q4MxYM2FGnGm4cp27FoyRmy6hOy86jHHSKXhJi0tDUVFRbCykj9m3srKCklJpV+k79y5c1i/fj3Wrl1bpnXMmzcPpqamsh87O7sK100kFcDCwGiM3RGOp/nV59tKWRy/loTxO8Nr5AcKqZcneYWYc+Q63l12DqH3asZV24NuJOO9FecxdH2I0q5ary7O33qIwesuIj0nX9WlqH63lCKePHmCoUOHYu3atbCwsCjTY6ZOnYqMjAzZT3x8fCVXSbXJ4cgH+GDlP7j/uGYcCXIqOgVjtofzzL1UrdxIzMSHq4Lx1Z5IPMpW/Qfji4QQCLyaiF6//I1PNl9GeFy6qkuqtiLj0zFl7xVVlwEtVa7cwsICmpqaSE6WPw9CcnIyrK2tSyx/+/Zt3L17F71795a1SaXPZt5raWkhOjoaLi4uco/R1dWFrm71uWQ7qZ/riZno8+t5rBjSUqWnJn+df26lYeTW0Bp56ndSf0IAuy/fx/HryfjKtwkGtbWDRKLaS6BIpQKH/32A5adu4Way+hxIUNmyqsGuKZWO3Ojo6KBVq1YICgqStUmlUgQFBaFdu3Yllm/SpAmuXLmCiIgI2U+fPn3QtWtXREREcJcTqcyj7Hx8vO4iVp+5jbtp2dXu0MiQ2Ef4ZPNl5Kn5YbhU86XnFOCb/Vfw3op/cDUhQyU1FBZJ8fvlePgsPoPxOyMYbGoglY7cAEBAQAD8/PzQunVrtG3bFkuXLkV2djb8/f0BAMOGDYOtrS3mzZsHPT09eHh4yD3ezMwMAEq0E1W1QqnAvKNRmHc0CoY6mmhsbQy3+ibP/RjDQKfqf+XC/jtE9WlBzZobRLVbRHw6+i4/j4+97THJtzFMXnL1d2XKL5RiT+h9rDxzC/GPeG2ymkzl4WbAgAFITU3F9OnTkZSUBC8vLwQGBsomGcfFxUFDo0ZNDSJCdn4RwuLSEfbcvnmJBHCoYwB3GxO4Wf8XeGxMYGumX2l1XLmfAb8NIdVimJhIUUVSgc3B9/Dn1SR8804TvNeiQaWsJ7egCDtD4rD67B0kZtT8w9OJF85Uat+8cCaVh6m+Npr8N8rj/t8oj6uVUYUvOHgjMROD1l5Aeo76nVWZaqc3nOvg+34eaGhprJT+cvIL8duFe1j7dyxSn+QppU8C3mxogd8+9VZ6v4p8fqt85Iaotst4WoCLsY9w8bnDSrU0JHCuZ1hit5alsV6Z+ryV8gRD119ksCG1cuHOI/T8+W+MeNMJ47u7lns375PcAmz+5y42nL9bLY/OoopjuCGqhgqlAjeTs3AzOQsHIx7I2i2MdOTCjnt9U7jUM4SW5v923d5Ny8bgtReRlsU/2qR+CooEVp+5gyORiZj2rjve9ih5ZO3LpOfkY8O5WGz6565aXtCS/ofhhqgGScvKx98xafj7uWvz6GhpwNXSCG71TdDYyhgbz8cihUPspOYS0p9i5G+h6Nq4Hmb18YB9XYOXLvswKw9r/47Fbxfucf5ZLcFwQ1TD5RdKce1BJq494KVFqPY5FZ2Kf5acwaguDTGyizN0tf43Vy05Mxerz9zBjpA4Hi1YyzDcEBFRjZZXKMWSkzexP/w+ZvX1QENLI6w8fQu7L99HPs/tVCsx3BARkVq4+zAHfhtCoKkh4bXTajmeQIaIiNQKgw0x3BAREZFaYbghIiIitcJwQ0RERGqF4YaIiIjUCsMNERERqRWGGyIiIlIrDDdERESkVhhuiIiISK0w3BAREZFaYbghIiIitcJwQ0RERGqF4YaIiIjUCsMNERERqRWlhJv09HRldENERERUYQqHmwULFmDXrl2y2/3790fdunVha2uLyMhIpRZHREREpCiFw82qVatgZ2cHADhx4gROnDiBo0ePomfPnpg8ebLSCyQiIiJShJaiD0hKSpKFmyNHjqB///5466234OjoCG9vb6UXSERERKQIhUduzM3NER8fDwAIDAyEj48PAEAIgaKiIuVWR0RERKQghUdu3n//fQwePBiurq54+PAhevbsCQAIDw9Hw4YNlV4gERERkSIUDjdLliyBo6Mj4uPjsXDhQhgZGQEAEhMTMWrUKKUXSERERKQIhcONtrY2vvzyyxLtEydOVEpBRERERBVRrvPcbN26FW+++SZsbGxw7949AMDSpUtx8OBBpRZHREREpCiFw83KlSsREBCAnj17Ij09XTaJ2MzMDEuXLlV2fUREREQKUTjcLFu2DGvXrsW3334LTU1NWXvr1q1x5coVpRZHREREpCiFw01sbCxatGhRol1XVxfZ2dlKKYqIiIiovBQON05OToiIiCjRHhgYCDc3N2XURERERFRuCh8tFRAQgNGjRyM3NxdCCISEhGDHjh2YN28e1q1bVxk1EhEREZWZwuHm008/hb6+Pr777jvk5ORg8ODBsLGxwc8//4yBAwdWRo1EREREZaZwuAGAIUOGYMiQIcjJyUFWVhYsLS2VXRcRERFRuZQr3BQzMDCAgYGBsmohIiIiqjCFw42TkxMkEslL779z506FCiIiIiKqCIXDzYQJE+RuFxQUIDw8HIGBgZg8ebKy6iIiIiIqF4XDzfjx40ttX758OS5fvlzhgoiIiIgqolzXlipNz549sXfvXmV1R0RERFQuSgs3e/bsQZ06dZTVHREREVG5KLxbqkWLFnITioUQSEpKQmpqKlasWKHU4oiIiIgUpXC46devn9xtDQ0N1KtXD126dEGTJk2UVRcRERFRuSgcbmbMmFEZdRAREREpRZnCTWZmZpk7NDExKXcxRERERBVVpnBjZmb2yhP3Ac/m3kgkEhQVFSmlMCIiIqLyKFO4OXXqVGXXQURERKQUZQo3nTt3ruw6iIiIiJSi3BfOzMnJQVxcHPLz8+XamzVrVuGiiIiIiMpL4XCTmpoKf39/HD16tNT7OeeGiIiIVEnhMxRPmDAB6enpuHjxIvT19REYGIjNmzfD1dUVhw4dqowaiYiIiMpM4ZGbv/76CwcPHkTr1q2hoaEBBwcH9OjRAyYmJpg3bx569epVGXUSERERlYnCIzfZ2dmwtLQEAJibmyM1NRUA4OnpibCwMOVWR0RERKQghcNN48aNER0dDQBo3rw5Vq9ejYSEBKxatQr169dXeoFEREREilB4t9T48eORmJgI4NmlGN5++21s27YNOjo62LRpk7LrIyIiIlKIwuHm448/lv2/VatWuHfvHqKiomBvbw8LCwulFkdERESkKIV3S507d07utoGBAVq2bMlgQ0RERNWCwuGmW7ducHJywjfffIPr169XRk1ERERE5aZwuHnw4AEmTZqEM2fOwMPDA15eXli0aBHu379fGfURERERKUThcGNhYYExY8bg/PnzuH37Nj766CNs3rwZjo6O6NatW7mKWL58ORwdHaGnpwdvb2+EhIS8dNl9+/ahdevWMDMzg6GhIby8vLB169ZyrZeIiIjUj8Lh5nlOTk6YMmUK5s+fD09PT5w5c0bhPnbt2oWAgADMmDEDYWFhaN68OXx9fZGSklLq8nXq1MG3336L4OBg/Pvvv/D394e/vz+OHTtWkadCREREaqLc4eb8+fMYNWoU6tevj8GDB8PDwwN//PGHwv0sXrwYn332Gfz9/eHu7o5Vq1bBwMAAGzZsKHX5Ll264L333oObmxtcXFwwfvx4NGvWrMREZyIiIqqdFA43U6dOhZOTE7p164a4uDj8/PPPSEpKwtatW/H2228r1Fd+fj5CQ0Ph4+Pzv4I0NODj44Pg4ODXPl4IgaCgIERHR6NTp06KPhUiIiJSQwqf5+bs2bOYPHky+vfvX+HDv9PS0lBUVAQrKyu5disrK0RFRb30cRkZGbC1tUVeXh40NTWxYsUK9OjRo9Rl8/LykJeXJ7udmZlZoZqJiIioelM43Jw/f74y6lCIsbExIiIikJWVhaCgIAQEBMDZ2RldunQpsey8efMwa9asqi+SiIiIVELhcKNMFhYW0NTURHJyslx7cnIyrK2tX/o4DQ0NNGzYEADg5eWFGzduYN68eaWGm6lTpyIgIEB2OzMzE3Z2dsp5AkRERFTtVOhoqYrS0dFBq1atEBQUJGuTSqUICgpCu3btytyPVCqV2/X0PF1dXZiYmMj9EBERkfpS6cgNAAQEBMDPzw+tW7dG27ZtsXTpUmRnZ8Pf3x8AMGzYMNja2mLevHkAnu1mat26NVxcXJCXl4c///wTW7duxcqVK1X5NIiIiKiaKFO4+eWXX/D5559DT08PcXFxsLOzg0QiUUoBAwYMQGpqKqZPn46kpCR4eXkhMDBQNsk4Li4OGhr/G2DKzs7GqFGjcP/+fejr66NJkyb47bffMGDAAKXUQ0RERDWbRAghXreQlpYWHjx4AEtLS2hqaiIxMRGWlpZVUZ/SZWZmwtTUFBkZGUrfRRWVlIm3l/6t1D6JiIhqkjcbWuC3T72V3q8in99lGrmxsbHB3r178c4770AIgfv37yM3N7fUZe3t7RWvmIiIiEhJyhRuvvvuO4wdOxZjxoyBRCJBmzZtSiwjhIBEIkFRUZHSiyQiIiIqqzKFm88//xyDBg3CvXv30KxZM5w8eRJ169at7NqIiIiIFFbmo6WMjY3h4eGBjRs3okOHDtDV1a3MuoiIiIjKReFDwf38/AAAoaGhuHHjBgDA3d0dLVu2VG5lREREROWgcLhJSUnBwIEDcfr0aZiZmQEA0tPT0bVrV+zcuRP16tVTdo1EREREZabwGYrHjh2LJ0+e4Nq1a3j06BEePXqEq1evIjMzE+PGjauMGomIiIjKTOGRm8DAQJw8eRJubm6yNnd3dyxfvhxvvfWWUosjIiIiUpTCIzdSqRTa2tol2rW1tSGVSpVSFBEREVF5KRxuunXrhvHjx+PBgweytoSEBEycOBHdu3dXanFEREREilI43Pz666/IzMyEo6MjXFxc4OLiAicnJ2RmZmLZsmWVUSMRERFRmSk858bOzg5hYWE4efIkoqKiAABubm7w8fFRenFEREREilI43ACARCJBjx490KNHD2XXQ0RERFQhCu+WIiIiIqrOGG6IiIhIrTDcEBERkVphuCEiIiK1Uq5wc/v2bXz33XcYNGgQUlJSAABHjx7FtWvXlFocERERkaIUDjdnzpyBp6cnLl68iH379iErKwsAEBkZiRkzZii9QCIiIiJFKBxupkyZgu+//x4nTpyAjo6OrL1bt264cOGCUosjIiIiUpTC4ebKlSt47733SrRbWloiLS1NKUURERERlZfC4cbMzAyJiYkl2sPDw2Fra6uUooiIiIjKS+FwM3DgQHz99ddISkqCRCKBVCrF+fPn8eWXX2LYsGGVUSMRERFRmSkcbubOnYsmTZrAzs4OWVlZcHd3R6dOndC+fXt89913lVEjERERUZkpfG0pHR0drF27FtOmTcPVq1eRlZWFFi1awNXVtTLqIyIiIlJIuS6cCQD29vawt7dXZi1EREREFaZwuAkICCi1XSKRQE9PDw0bNkTfvn1Rp06dChdHREREpCiFw014eDjCwsJQVFSExo0bAwBu3rwJTU1NNGnSBCtWrMCkSZNw7tw5uLu7K71gIiIioldReEJx37594ePjgwcPHiA0NBShoaG4f/8+evTogUGDBiEhIQGdOnXCxIkTK6NeIiIioldSONwsWrQIc+bMgYmJiazN1NQUM2fOxMKFC2FgYIDp06cjNDRUqYUSERERlYXC4SYjI0N2scznpaamIjMzE8CzE/3l5+dXvDoiIiIiBZVrt9SIESOwf/9+3L9/H/fv38f+/fvxySefoF+/fgCAkJAQNGrUSNm1EhEREb2WwhOKV69ejYkTJ2LgwIEoLCx81omWFvz8/LBkyRIAQJMmTbBu3TrlVkpERERUBgqHGyMjI6xduxZLlizBnTt3AADOzs4wMjKSLePl5aW0AomIiIgUUe6T+BkZGaFZs2bKrIWIiIiowhQON9nZ2Zg/fz6CgoKQkpICqVQqd3/xaA4RERGRKigcbj799FOcOXMGQ4cORf369SGRSCqjLiIiIqJyUTjcHD16FH/88Qc6dOhQGfUQERERVYjCh4Kbm5vzulFERERUbSkcbubMmYPp06cjJyenMuohIiIiqhCFd0v99NNPuH37NqysrODo6AhtbW25+8PCwpRWHBEREZGiFA43xWchJiIiIqqOFA43M2bMqIw6iIiIiJRC4Tk3RERERNWZwiM3RUVFWLJkCXbv3o24uLgSV/9+9OiR0oojIiIiUpTCIzezZs3C4sWLMWDAAGRkZCAgIADvv/8+NDQ0MHPmzEookYiIiKjsFA4327Ztw9q1azFp0iRoaWlh0KBBWLduHaZPn44LFy5URo1EREREZaZwuElKSoKnpyeAZxfPzMjIAAC8++67+OOPP5RbHREREZGCFA43DRo0QGJiIgDAxcUFx48fBwBcunQJurq6yq2OiIiISEEKh5v33nsPQUFBAICxY8di2rRpcHV1xbBhwzBixAilF0hERESkCIWPlpo/f77s/wMGDICDgwP++ecfuLq6onfv3kotjoiIiEhRCoWbgoICfPHFF5g2bRqcnJwAAG+88QbeeOONSimOiIiISFEK7ZbS1tbG3r17K6sWIiIiogpTeM5Nv379cODAgUoohYiIiKjiFJ5z4+rqitmzZ+P8+fNo1aoVDA0N5e4fN26c0oojIiIiUpTC4Wb9+vUwMzNDaGgoQkND5e6TSCQMN0RERKRSCoeb2NjYyqiDiIiISCl4VXAiIiJSKww3REREpFYYboiIiEitMNwQERGRWlEo3BQWFmL27Nm4f/++UotYvnw5HB0doaenB29vb4SEhLx02bVr16Jjx44wNzeHubk5fHx8Xrk8ERER1S4KhRstLS0sWrQIhYWFSitg165dCAgIwIwZMxAWFobmzZvD19cXKSkppS5/+vRpDBo0CKdOnUJwcDDs7Ozw1ltvISEhQWk1ERERUc2l8G6pbt264cyZM0orYPHixfjss8/g7+8Pd3d3rFq1CgYGBtiwYUOpy2/btg2jRo2Cl5cXmjRpgnXr1kEqlcquVE5ERES1m8LnuenZsyemTJmCK1eulHqG4j59+pS5r/z8fISGhmLq1KmyNg0NDfj4+CA4OLhMfeTk5KCgoAB16tQp9f68vDzk5eXJbmdmZpa5PiIiIqp5FA43o0aNAvBsxOVFEokERUVFZe4rLS0NRUVFsLKykmu3srJCVFRUmfr4+uuvYWNjAx8fn1LvnzdvHmbNmlXmmoiIiKhmU3i3lFQqfemPIsFGGebPn4+dO3di//790NPTK3WZqVOnIiMjQ/YTHx9fpTUSERFR1VJ45OZ5ubm5Lw0VZWFhYQFNTU0kJyfLtScnJ8Pa2vqVj/3xxx8xf/58nDx5Es2aNXvpcrq6utDV1S13jURERFSzKDxyU1RUhDlz5sDW1hZGRka4c+cOAGDatGlYv369Qn3p6OigVatWcpOBiycHt2vX7qWPW7hwIebMmYPAwEC0bt1a0adAREREakzhcPPDDz9g06ZNWLhwIXR0dGTtHh4eWLduncIFBAQEYO3atdi8eTNu3LiB//u//0N2djb8/f0BAMOGDZObcLxgwQJMmzYNGzZsgKOjI5KSkpCUlISsrCyF101ERETqR+HdUlu2bMGaNWvQvXt3jBw5UtbevHnzMk8Cft6AAQOQmpqK6dOnIykpCV5eXggMDJRNMo6Li4OGxv8y2MqVK5Gfn48PP/xQrp8ZM2Zg5syZCq+fiIiI1IvC4SYhIQENGzYs0S6VSlFQUFCuIsaMGYMxY8aUet/p06flbt+9e7dc6yAiIqLaQeHdUu7u7vj7779LtO/ZswctWrRQSlFERERE5aXwyM306dPh5+eHhIQESKVS7Nu3D9HR0diyZQuOHDlSGTUSERERlZnCIzd9+/bF4cOHcfLkSRgaGmL69Om4ceMGDh8+jB49elRGjURERERlVq7z3HTs2BEnTpxQdi1EREREFabwyI2zszMePnxYoj09PR3Ozs5KKYqIiIiovBQON3fv3i31Mgt5eXlISEhQSlFERERE5VXm3VKHDh2S/f/YsWMwNTWV3S4qKkJQUBAcHR2VWhwRERGRosocbvr16wfg2ZW//fz85O7T1taGo6MjfvrpJ6UWR0RERKSoMocbqVQKAHBycsKlS5dgYWFRaUURERERlZfCR0vFxsbK/l/Rq4ITERERKZvCE4qlUqnSrgpOREREpGwKh5vvv/9eqVcFJyIiIlImhcNN8VXBhwwZAk1NTVl7ea8KTkRERKRMCoebyrgqOBEREZGy8KrgREREpFZ4VXAiIiJSK7wqOBEREakVXhWciIiI1Eq5wk2xrKws2ZmLi5mYmFSoICIiIqKKUHi3VGxsLHr16gVDQ0OYmprC3Nwc5ubmMDMzg7m5eWXUSERERFRmCo/cfPzxxxBCYMOGDbCysoJEIqmMuoiIiIjKReFwExkZidDQUDRu3Lgy6iEiIiKqEIV3S7Vp0wbx8fGVUQsRERFRhSk8crNu3TqMHDkSCQkJ8PDwgLa2ttz9zZo1U1pxRERERIpSONykpqbi9u3b8Pf3l7VJJBIIISCRSFBUVKTUAomIiIgUoXC4GTFiBFq0aIEdO3ZwQjERERFVOwqHm3v37uHQoUOlXjyTiIiISNUUnlDcrVs3REZGVkYtRERERBWm8MhN7969MXHiRFy5cgWenp4lJhT36dNHacURERERKUrhcDNy5EgAwOzZs0vcxwnFREREpGoKh5sXryVFREREVJ0oPOeGiIiIqDor11XBs7OzcebMGcTFxSE/P1/uvnHjximlMCIiIqLyUDjchIeH45133kFOTg6ys7NRp04dpKWlwcDAAJaWlgw3REREpFIK75aaOHEievfujcePH0NfXx8XLlzAvXv30KpVK/z444+VUSMRERFRmSkcbiIiIjBp0iRoaGhAU1MTeXl5sLOzw8KFC/HNN99URo1EREREZaZwuNHW1oaGxrOHWVpaIi4uDgBgamrKq4UTERGRyik856ZFixa4dOkSXF1d0blzZ0yfPh1paWnYunUrPDw8KqNGIiIiojJTeORm7ty5qF+/PgDghx9+gLm5Of7v//4PqampWLNmjdILJCIiIlKEQiM3QghYWlrKRmgsLS0RGBhYKYURERERlYdCIzdCCDRs2JBza4iIiKjaUijcaGhowNXVFQ8fPqyseoiIiIgqROE5N/Pnz8fkyZNx9erVyqiHiIiIqEIUPlpq2LBhyMnJQfPmzaGjowN9fX25+x89eqS04oiIiIgUpXC4Wbp0aSWUQURERKQcCocbPz+/yqiDiIiISCnKdVXwYrm5uSWuCm5iYlKhgoiIiIgqQuEJxdnZ2RgzZgwsLS1haGgIc3NzuR8iIiIiVVI43Hz11Vf466+/sHLlSujq6mLdunWYNWsWbGxssGXLlsqokYiIiKjMFN4tdfjwYWzZsgVdunSBv78/OnbsiIYNG8LBwQHbtm3DkCFDKqNOIiIiojJReOTm0aNHcHZ2BvBsfk3xod9vvvkmzp49q9zqiIiIiBSkcLhxdnZGbGwsAKBJkybYvXs3gGcjOmZmZkotjoiIiEhRCocbf39/REZGAgCmTJmC5cuXQ09PDxMnTsTkyZOVXiARERGRIhSeczNx4kTZ/318fBAVFYXQ0FA0bNgQzZo1U2pxRERERIoqc7iRSqVYtGgRDh06hPz8fHTv3h0zZsyAg4MDHBwcKrNGIiIiojIr826pH374Ad988w2MjIxga2uLn3/+GaNHj67M2oiIiIgUVuZws2XLFqxYsQLHjh3DgQMHcPjwYWzbtg1SqbQy6yMiIiJSSJnDTVxcHN555x3ZbR8fH0gkEjx48KBSCiMiIiIqjzKHm8LCQujp6cm1aWtro6CgQOlFEREREZVXmScUCyEwfPhw6Orqytpyc3MxcuRIGBoaytr27dun3AqJiIiIFFDmkRs/Pz9YWlrC1NRU9vPxxx/DxsZGrk1Ry5cvh6OjI/T09ODt7Y2QkJCXLnvt2jV88MEHcHR0hEQiwdKlSxVeHxEREam3Mo/cbNy4Uekr37VrFwICArBq1Sp4e3tj6dKl8PX1RXR0NCwtLUssn5OTA2dnZ3z00Udy59shIiIiKqbwGYqVafHixfjss8/g7+8Pd3d3rFq1CgYGBtiwYUOpy7dp0waLFi3CwIED5XaPERERERVTWbjJz89HaGgofHx8/leMhgZ8fHwQHBystPXk5eUhMzNT7oeIiIjUl8rCTVpaGoqKimBlZSXXbmVlhaSkJKWtZ968eXJzguzs7JTWNxEREVU/Kt0tVRWmTp2KjIwM2U98fLyqSyIiIqJKpPCFM5XFwsICmpqaSE5OlmtPTk6GtbW10tajq6vL+TlERES1iMpGbnR0dNCqVSsEBQXJ2qRSKYKCgtCuXTtVlUVEREQ1nMpGbgAgICAAfn5+aN26Ndq2bYulS5ciOzsb/v7+AIBhw4bB1tYW8+bNA/BsEvL169dl/09ISEBERASMjIzQsGFDlT0PIiIiqj5UGm4GDBiA1NRUTJ8+HUlJSfDy8kJgYKBsknFcXBw0NP43uPTgwQO0aNFCdvvHH3/Ejz/+iM6dO+P06dNVXT4RERFVQyoNNwAwZswYjBkzptT7Xgwsjo6OEEJUQVVERERUU6n90VJERERUuzDcEBERkVphuCEiIiK1wnBDREREaoXhhoiIiNQKww0RERGpFYYbIiIiUisMN0RERKRWGG6IiIhIrTDcEBERkVphuCEiIiK1wnBDREREaoXhhoiIiNQKww0RERGpFYYbIiIiUisMN0RERKRWGG6IiIhIrTDcEBERkVphuCEiIiK1wnBDREREaoXhhoiIiNQKww0RERGpFYYbIiIiUisMN0RERKRWGG6IiIhIrTDcEBERkVphuCEiIiK1wnBDREREaoXhhoiIiNQKww0RERGpFYYbIiIiUisMN0RERKRWGG6IiIhIrTDcEBERkVphuCEiIiK1wnBDREREaoXhhohIDUgkwNtNrbH7i3Zo42iu6nKIVEpL1QUQEVH5SSSAr7s1xvu4wq2+CQBg6yfeGL8zHMeuJau4OiLVYLghIqqBJBLgLXcrjO/eCO42JnL36WlrYuWQVph+6Cp+uxCnogqJVIfhhoiohnnL3QrjfVzR1Mb0pctoaEjwfT9PWJvo4cfjN6uwOiLVY7ghIqoherhbYXx3V3jYvjzUvGhMN1dYGuvhm/1XUCgVlVgdUfXBcENEVM35uFlhgo9ioeZ5/dvYwcJYB6O3heNpQZGSqyOqfhhuiIiqKR83S0zwaVTuUPO8bk2ssP0zb3yy+TIeZecroTqiklwtjfDJm06qLoPhhoiouune5Fmo8WxQ8VDzvBb25tgzsh38NoYg/tFTpfZNtZuzhSHG+7iidzMbaGhIVF0Oww0RUXXRrYklJvi4olkDs0pbh3M9I+z9v/bw33gJ1x5kVtp6qHawr2OAsd0a4v2WDaBZDUJNMYYbIiIV69q4Hib4NEJzO7MqWZ+lsR52fdEOI7eG4tyttCpZJ6kXWzN9jOnWEB+2agBtzep3PmCGGyIiFenyX6jxqqJQ8zwjXS1s9G+Dyb9H4kDEgypfP9VMVia6GN21IQa2sYeOVvULNcUYboiIqljnRvUwwccVLexVe5kEbU0NLBnghXrGulj7d6xKa6HqzcJIByM7u+DjNxygp62p6nJei+GGiKiKdPov1LRUcah5nkQiwbe93GFloocf/rwBwVPh0HPMDbTxeScX+LV3gIFOzYkMNadSIqIaqqOrBSb4NEIrh+oTal70aUdnWJro4cvdkcgvkqq6HFIxEz0tfNbRGf5vOsFIt+ZFhZpXMRFRDfEs1LiilUMdVZdSJn2a28DCUAdfbA3Fk7xCVZdDKmCkq4URHRzxSUdnmOprq7qccmO4ISJSsjcbPgs1rR1rRqh5XvuGFtj1RTsM3xiClCd5qi6HqoiBjiaGtXPEF52cYW6oo+pyKozhRg0Y62nhvRa2GOxtD21NDWy/GIe9YfeRnlOg6tKIag09bQ2841kfQ7wdqvXup7JwtzHBvlHt4bchBLdTs1VdDlUiXS0NDH3DASO7uMDCSFfV5SiNRIjaNX0sMzMTpqamyMjIgImJiVL7jkrKxNtL/1Zqn6/iZWeGwW3t0bu5DfR15Gev5xUW4eiVJGy/GIeQu4+qrCai2sa9vgkGtrVDXy/bGj2MX5rH2fkYsfkSwuPSVV0KKZmOpgYGtbXD6K4NYWmip+pyykSRz2+O3NQwRrpa6NfCBoPbOsDd5uUvrq6WJvq1sEW/FraISX6C7SFx2BeWgIynHM0hqigjXS30bm6DQW3tKvVswqpmbqiD7Z++gbE7wnDyRoqqyyEl0NaU4MNWdhjbrSFszPRVXU6l4ciNElXmyI2nrSmGeNujj5dNuQ/Hyy0owh//JmJ7SBxC7z1WcoVE6q+FvRkGtbHHu83r16jDYiuqSCrw7f4r2HkpXtWlUDlpakjwXgtbjO/uCrs6Bqoup1w4cqMmDHU00cfLFoPb2ivlAnp62pr4oFUDfNCqAaKSMrHjYhz2hSfgSS6PiiB6GTMDbfTzssWgtvZobG2s6nJUQlNDgvkfNIOViR5+DopRdTmkAA3Js6Pgxvs0gpOFoarLqTIMN9VQUxsTDPa2R18v20o7v0ATaxPM6uuBKT3dcPjfB9h+MQ4R8emVsi6imugN5zoY1NYevk2ta8QZWavCxB6NYGWih2kHr6JIWqsG/WsciQR4x6M+Jvi4wtWq9oVyhptqQl9bE32a22Cwt32VXTwPAPR1NNG/tR36t7bD9QeZ2B5yDwfCHyCL57igWsjCSBcftmqAAW3satW3XEUM9rZHPWNdjN0RhtwCnuyvurE100drR3N80cnllfMy1R3n3ChReebcNLE2xhBve/RrYQtjvepxpEVOfiEORTzA9pA4/Hs/Q9XlEFUqDQnQ0bUeBrW1Q3c3q2p5hePqKPTeY3y6+RIe85QTKqEhARwtDNHUxhQeNibwsDVFUxsTmBnU/HPUvAzn3FRzetoaeLfZs1Ga6nSNmWIGOloY2NYeA9va42pCBrZdjMOhiARk5xepujQipbEx1cNHre3Qv40dbNX4qJHK0srBHL+PfHYunIT0p6ouR61pa0rQ0NIYTW1MZEHGrb4JDGvgZRGqSrUYuVm+fDkWLVqEpKQkNG/eHMuWLUPbtm1fuvzvv/+OadOm4e7du3B1dcWCBQvwzjvvlGldqhy5aWRlhMFt7fFeywY17nwYWXmFOBiRgO0X43DtQaaqyyEqFy0NCbq7WWJgG3t0blQPGhoSVZdU4yVn5sJvQwiikp6ouhS1oKetgSbWJs+CjK0pPGxM0cjaCLpanPdVo0Zudu3ahYCAAKxatQre3t5YunQpfH19ER0dDUtLyxLL//PPPxg0aBDmzZuHd999F9u3b0e/fv0QFhYGDw8PFTyDV9PV0kAvz/oY7G1fI0/FXsxIVwtDvB0wxNsBkfHp2H4xDof/fYAcjuZQDeBQ1wAD2tjhw1YNYGlcM05YVlNYmehh98h2+GJLKILvPFR1OTWKsZ4W3OubPNu1ZPsszLjUM4ImQ3eFqXzkxtvbG23atMGvv/4KAJBKpbCzs8PYsWMxZcqUEssPGDAA2dnZOHLkiKztjTfegJeXF1atWvXa9VXVyI1LPUMM9nbABy1t1XYf6JPcAhwIT8C2i3H81kbVjo6WBt5uao2BbezQzqUuJBJ+YFSm/EIpAnZH4Mi/iaoupVqqa6iDpv/Ni/GwefavQ10Dvi8VUGNGbvLz8xEaGoqpU6fK2jQ0NODj44Pg4OBSHxMcHIyAgAC5Nl9fXxw4cKDU5fPy8pCX97+Lv2VmVt4uFW1NDfT1ssHgtvbwdq5baeupLoz1tDG0nSOGtnNEWNxjbL8Yh9PRKTxElFTKyuTZXJr3W9iqxQUAawodLQ0sG9QCViZ62Bd2X9XlqJSBjhbc6ps8G42xMUVTWxPUN+W8rqqk0nCTlpaGoqIiWFlZybVbWVkhKiqq1MckJSWVunxSUlKpy8+bNw+zZs1STsGv4VLPCD8PbFEl66puWtqbV8vJ0URUdSQSCaa9645p77qruhSq5dT+mMepU6ciIyND9hMfz9OHExERqTOVjtxYWFhAU1MTycnJcu3JycmwtrYu9THW1tYKLa+rqwtdXfW5jDsRERG9mkpHbnR0dNCqVSsEBQXJ2qRSKYKCgtCuXbtSH9OuXTu55QHgxIkTL12eiIiIaheVHwoeEBAAPz8/tG7dGm3btsXSpUuRnZ0Nf39/AMCwYcNga2uLefPmAQDGjx+Pzp0746effkKvXr2wc+dOXL58GWvWrFHl0yAiIqJqQuXhZsCAAUhNTcX06dORlJQELy8vBAYGyiYNx8XFQUPjfwNM7du3x/bt2/Hdd9/hm2++gaurKw4cOFAtz3FDREREVU/l57mpapV5nhsiIiKqHIp8fqv90VJERERUuzDcEBERkVphuCEiIiK1wnBDREREaoXhhoiIiNQKww0RERGpFYYbIiIiUisMN0RERKRWGG6IiIhIraj88gtVrfiEzJmZmSquhIiIiMqq+HO7LBdWqHXh5smTJwAAOzs7FVdCREREinry5AlMTU1fuUytu7aUVCrFgwcPYGxsDIlEotS+MzMzYWdnh/j4+Fp53ara/vwBbgM+/9r9/AFug9r+/IHK2wZCCDx58gQ2NjZyF9QuTa0budHQ0ECDBg0qdR0mJia19k0N8PkD3AZ8/rX7+QPcBrX9+QOVsw1eN2JTjBOKiYiISK0w3BAREZFaYbhRIl1dXcyYMQO6urqqLkUlavvzB7gN+Pxr9/MHuA1q+/MHqsc2qHUTiomIiEi9ceSGiIiI1ArDDREREakVhhsiIiJSKww3REREpFYYbpRk+fLlcHR0hJ6eHry9vRESEqLqkqrMvHnz0KZNGxgbG8PS0hL9+vVDdHS0qstSmfnz50MikWDChAmqLqVKJSQk4OOPP0bdunWhr68PT09PXL58WdVlVYmioiJMmzYNTk5O0NfXh4uLC+bMmVOma+DUVGfPnkXv3r1hY2MDiUSCAwcOyN0vhMD06dNRv3596Ovrw8fHBzExMaopthK86vkXFBTg66+/hqenJwwNDWFjY4Nhw4bhwYMHqitYyV73+j9v5MiRkEgkWLp0aZXVx3CjBLt27UJAQABmzJiBsLAwNG/eHL6+vkhJSVF1aVXizJkzGD16NC5cuIATJ06goKAAb731FrKzs1VdWpW7dOkSVq9ejWbNmqm6lCr1+PFjdOjQAdra2jh69CiuX7+On376Cebm5qourUosWLAAK1euxK+//oobN25gwYIFWLhwIZYtW6bq0ipNdnY2mjdvjuXLl5d6/8KFC/HLL79g1apVuHjxIgwNDeHr64vc3NwqrrRyvOr55+TkICwsDNOmTUNYWBj27duH6Oho9OnTRwWVVo7Xvf7F9u/fjwsXLsDGxqaKKvuPoApr27atGD16tOx2UVGRsLGxEfPmzVNhVaqTkpIiAIgzZ86oupQq9eTJE+Hq6ipOnDghOnfuLMaPH6/qkqrM119/Ld58801Vl6EyvXr1EiNGjJBre//998WQIUNUVFHVAiD2798vuy2VSoW1tbVYtGiRrC09PV3o6uqKHTt2qKDCyvXi8y9NSEiIACDu3btXNUVVoZc9//v37wtbW1tx9epV4eDgIJYsWVJlNXHkpoLy8/MRGhoKHx8fWZuGhgZ8fHwQHByswspUJyMjAwBQp04dFVdStUaPHo1evXrJvRdqi0OHDqF169b46KOPYGlpiRYtWmDt2rWqLqvKtG/fHkFBQbh58yYAIDIyEufOnUPPnj1VXJlqxMbGIikpSe53wdTUFN7e3rX676JEIoGZmZmqS6kSUqkUQ4cOxeTJk9G0adMqX3+tu3CmsqWlpaGoqAhWVlZy7VZWVoiKilJRVaojlUoxYcIEdOjQAR4eHqoup8rs3LkTYWFhuHTpkqpLUYk7d+5g5cqVCAgIwDfffINLly5h3Lhx0NHRgZ+fn6rLq3RTpkxBZmYmmjRpAk1NTRQVFeGHH37AkCFDVF2aSiQlJQFAqX8Xi++rTXJzc/H1119j0KBBteZimgsWLICWlhbGjRunkvUz3JBSjR49GlevXsW5c+dUXUqViY+Px/jx43HixAno6empuhyVkEqlaN26NebOnQsAaNGiBa5evYpVq1bVinCze/dubNu2Ddu3b0fTpk0RERGBCRMmwMbGplY8f3q5goIC9O/fH0IIrFy5UtXlVInQ0FD8/PPPCAsLg0QiUUkN3C1VQRYWFtDU1ERycrJce3JyMqytrVVUlWqMGTMGR44cwalTp9CgQQNVl1NlQkNDkZKSgpYtW0JLSwtaWlo4c+YMfvnlF2hpaaGoqEjVJVa6+vXrw93dXa7Nzc0NcXFxKqqoak2ePBlTpkzBwIED4enpiaFDh2LixImYN2+eqktTieK/fbX972JxsLl37x5OnDhRa0Zt/v77b6SkpMDe3l72N/HevXuYNGkSHB0dq6QGhpsK0tHRQatWrRAUFCRrk0qlCAoKQrt27VRYWdURQmDMmDHYv38//vrrLzg5Oam6pCrVvXt3XLlyBREREbKf1q1bY8iQIYiIiICmpqaqS6x0HTp0KHH4/82bN+Hg4KCiiqpWTk4ONDTk/5xqampCKpWqqCLVcnJygrW1tdzfxczMTFy8eLHW/F0sDjYxMTE4efIk6tatq+qSqszQoUPx77//yv1NtLGxweTJk3Hs2LEqqYG7pZQgICAAfn5+aN26Ndq2bYulS5ciOzsb/v7+qi6tSowePRrbt2/HwYMHYWxsLNunbmpqCn19fRVXV/mMjY1LzC8yNDRE3bp1a828o4kTJ6J9+/aYO3cu+vfvj5CQEKxZswZr1qxRdWlVonfv3vjhhx9gb2+Ppk2bIjw8HIsXL8aIESNUXVqlycrKwq1bt2S3Y2NjERERgTp16sDe3h4TJkzA999/D1dXVzg5OWHatGmwsbFBv379VFe0Er3q+devXx8ffvghwsLCcOTIERQVFcn+LtapUwc6OjqqKltpXvf6vxjmtLW1YW1tjcaNG1dNgVV2XJaaW7ZsmbC3txc6Ojqibdu24sKFC6ouqcoAKPVn48aNqi5NZWrboeBCCHH48GHh4eEhdHV1RZMmTcSaNWtUXVKVyczMFOPHjxf29vZCT09PODs7i2+//Vbk5eWpurRKc+rUqVJ/7/38/IQQzw4HnzZtmrCyshK6urqie/fuIjo6WrVFK9Grnn9sbOxL/y6eOnVK1aUrxete/xdV9aHgEiHU+BSaREREVOtwzg0RERGpFYYbIiIiUisMN0RERKRWGG6IiIhIrTDcEBERkVphuCEiIiK1wnBDREREaoXhhkhF7t69C4lEgoiICFWXIhMVFYU33ngDenp68PLyUnU5KtelSxdMmDChStd5+vRpSCQSpKenl3qbiF6P4YZqreHDh0MikWD+/Ply7QcOHFDZlWxVbcaMGTA0NER0dLTcdYGUbdOmTTAzM6u0/hX1sgCxb98+zJkzRzVF/ad9+/ZITEyEqampUvqbOXNmjQmu1fELANUMDDdUq+np6WHBggV4/PixqktRmvz8/HI/9vbt23jzzTfh4OBQqy709zJ16tSBsbGxSmvQ0dGBtbV1rQ3cROXBcEO1mo+PD6ytrTFv3ryXLlPaN92lS5fC0dFRdnv48OHo168f5s6dCysrK5iZmWH27NkoLCzE5MmTUadOHTRo0AAbN24s0X9UVBTat28PPT09eHh44MyZM3L3X716FT179oSRkRGsrKwwdOhQpKWlye7v0qULxowZgwkTJsDCwgK+vr6lPg+pVIrZs2ejQYMG0NXVhZeXFwIDA2X3SyQShIaGYvbs2ZBIJJg5c2ap/QQGBuLNN9+EmZkZ6tati3fffRe3b9+W3V/aKEhERAQkEgnu3r2L06dPw9/fHxkZGZBIJHLrevz4MYYNGwZzc3MYGBigZ8+eiImJkfVTPOJz5MgRNG7cGAYGBvjwww+Rk5ODzZs3w9HREebm5hg3bhyKiopkj9u6dStat24NY2NjWFtbY/DgwUhJSQHwbHSga9euAABzc3NIJBIMHz5ctm2f3y2Vl5eHr7/+GnZ2dtDV1UXDhg2xfv36UrfT69Zb7M8//0SjRo2gr6+Prl274u7du3L3v7g9y/J+PH36NNq2bQtDQ0OYmZmhQ4cOuHfvHjZt2oRZs2YhMjJStu03bdoE4Nnrv3r1arz77rswMDCAm5sbgoODcevWLXTp0gWGhoZo37693GsNAAcPHkTLli2hp6cHZ2dnzJo1C4WFhbL7JRIJ1q1bh/feew8GBgZwdXXFoUOHZPc/fvwYQ4YMQb169aCvrw9XV1fZ74mTkxMAoEWLFpBIJOjSpctLtzWRnCq7ihVRNePn5yf69u0r9u3bJ/T09ER8fLwQQoj9+/eL5381ZsyYIZo3by732CVLlggHBwe5voyNjcXo0aNFVFSUWL9+vQAgfH19xQ8//CBu3rwp5syZI7S1tWXrKb64XoMGDcSePXvE9evXxaeffiqMjY1FWlqaEEKIx48fi3r16ompU6eKGzduiLCwMNGjRw/RtWtX2bo7d+4sjIyMxOTJk0VUVJSIiooq9fkuXrxYmJiYiB07doioqCjx1VdfCW1tbXHz5k0hhBCJiYmiadOmYtKkSSIxMVE8efKk1H727Nkj9u7dK2JiYkR4eLjo3bu38PT0FEVFRUKI/11Q7/Hjx7LHhIeHCwAiNjZW5OXliaVLlwoTExORmJgot64+ffoINzc3cfbsWRERESF8fX1Fw4YNRX5+vhBCiI0bNwptbW3Ro0cPERYWJs6cOSPq1q0r3nrrLdG/f39x7do1cfjwYaGjoyN27twpW//69evFn3/+KW7fvi2Cg4NFu3btRM+ePYUQQhQWFoq9e/cKACI6OlokJiaK9PR02bZ9/gKo/fv3F3Z2dmLfvn3i9u3b4uTJk3LredGr1iuEEHFxcUJXV1cEBASIqKgo8dtvvwkrKyu57ffi9nzd+7GgoECYmpqKL7/8Uty6dUtcv35dbNq0Sdy7d0/k5OSISZMmiaZNm8q2fU5OjhDi2QVwbW1txa5du0R0dLTo16+fcHR0FN26dROBgYHi+vXr4o033hBvv/22bL1nz54VJiYmYtOmTeL27dvi+PHjwtHRUcycOVO2TPF7fPv27SImJkaMGzdOGBkZiYcPHwohhBg9erTw8vISly5dErGxseLEiRPi0KFDQgghQkJCBABx8uRJkZiYKHsM0esw3FCtVRxuhBDijTfeECNGjBBClD/cODg4yD7ghRCicePGomPHjrLbhYWFwtDQUOzYsUMI8b9wM3/+fNkyBQUFokGDBmLBggVCCCHmzJkj3nrrLbl1x8fHyz6IhXj2AdyiRYvXPl8bGxvxww8/yLW1adNGjBo1Sna7efPmYsaMGa/t63mpqakCgLhy5YoQ4vXhRohnIcXU1FSun5s3bwoA4vz587K2tLQ0oa+vL3bv3i17HABx69Yt2TJffPGFMDAwkAtjvr6+4osvvnhpzZcuXRIAZI8prWYh5MNNdHS0ACBOnDhRpu1SlvVOnTpVuLu7yy3z9ddfVyjcPHz4UAAQp0+fLrWG0h4vxLMQ8t1338luBwcHCwBi/fr1srYdO3YIPT092e3u3buLuXPnyvWzdetWUb9+/Zf2m5WVJQCIo0ePCiGE6N27t/D39y+11uLfkfDw8FLvJ3oZ7pYiArBgwQJs3rwZN27cKHcfTZs2hYbG/36lrKys4OnpKbutqamJunXrltgt0a5dO9n/tbS00Lp1a1kdkZGROHXqFIyMjGQ/TZo0AQC53QOtWrV6ZW2ZmZl48OABOnToINfeoUMHhZ9zTEwMBg0aBGdnZ5iYmMh2h8TFxSnUz4tu3LgBLS0teHt7y9rq1q2Lxo0by9VoYGAAFxcX2W0rKys4OjrCyMhIru357RwaGorevXvD3t4exsbG6Ny5s8I1R0REQFNTU/bYsnjdem/cuCH3fAH590N51KlTB8OHD4evry969+6Nn3/+GYmJiWV6bLNmzWT/t7KyAgC597CVlRVyc3ORmZkJ4Nn7c/bs2XLvz88++wyJiYnIyckptV9DQ0OYmJjIXp//+7//w86dO+Hl5YWvvvoK//zzT/mfPNF/GG6IAHTq1Am+vr6YOnVqifs0NDQghJBrKygoKLGctra23G2JRFJqm1QqLXNdWVlZ6N27NyIiIuR+YmJi0KlTJ9lyhoaGZe6zonr37o1Hjx5h7dq1uHjxIi5evAjgfxOZiwPe89ustO1VXopu5+zsbPj6+sLExATbtm3DpUuXsH//frmay0JfX1+hOpW13heV5f24ceNGBAcHo3379ti1axcaNWqECxcuvLbv57dj8QTm0tqKt21WVhZmzZol9968cuUKYmJioKenV2q/xf0U99GzZ0/cu3cPEydOxIMHD9C9e3d8+eWXr62V6FUYboj+M3/+fBw+fBjBwcFy7fXq1UNSUpLcB4oyD019/kOnsLAQoaGhcHNzAwC0bNkS165dg6OjIxo2bCj3o0igMTExgY2NDc6fPy/Xfv78ebi7u5e5n4cPHyI6OhrfffcdunfvDjc3txJHmtWrVw8A5EYLXtxeOjo6chN+AcDNzQ2FhYWysPT8+hSp8UVRUVF4+PAh5s+fj44dO6JJkyYlRs90dHQAoERNz/P09IRUKi0x4bsi63Vzc0NISIhc2+tCSFnfjy1atMDUqVPxzz//wMPDA9u3bwdQ+rYvr5YtWyI6OrrEe7Nhw4Zyo5ivU69ePfj5+eG3337D0qVLsWbNGlmtwKtfF6LSMNwQ/cfT0xNDhgzBL7/8ItfepUsXpKamYuHChbh9+zaWL1+Oo0ePKm29y5cvx/79+xEVFYXRo0fj8ePHGDFiBABg9OjRePToEQYNGoRLly7h9u3bOHbsGPz9/RX+gz958mQsWLAAu3btQnR0NKZMmYKIiAiMHz++zH2Ym5ujbt26WLNmDW7duoW//voLAQEBcss0bNgQdnZ2mDlzJmJiYvDHH3/gp59+klvG0dERWVlZCAoKQlpaGnJycuDq6oq+ffvis88+w7lz5xAZGYmPP/4Ytra26Nu3r0LP9Xn29vbQ0dHBsmXLcOfOHRw6dKjEuWscHBwgkUhw5MgRpKamIisrq0Q/jo6O8PPzw4gRI3DgwAHExsbi9OnT2L17d7nXO3LkSMTExGDy5MmIjo7G9u3bZUcvvczr3o+xsbGYOnUqgoODce/ePRw/fhwxMTGywOzo6IjY2FhEREQgLS0NeXl5ZdmMpZo+fTq2bNmCWbNm4dq1a7hx4wZ27tyJ7777TqE+Dh48iFu3buHatWs4cuSIrFZLS0vo6+sjMDAQycnJyMjIKHetVLsw3BA9Z/bs2SV2G7m5uWHFihVYvnw5mjdvjpCQEKUOm8+fPx/z589H8+bNce7cORw6dAgWFhYAIBttKSoqwltvvQVPT09MmDABZmZmCn0zBoBx48YhICAAkyZNgqenJwIDA3Ho0CG4urqWuQ8NDQ3s3LkToaGh8PDwwMSJE7Fo0SK5ZbS1tbFjxw5ERUWhWbNmWLBgAb7//nu5Zdq3b4+RI0diwIABqFevHhYuXAjg2e6UVq1a4d1330W7du0ghMCff/5ZYreGIurVq4dNmzbh999/h7u7O+bPn48ff/xRbhlbW1vMmjULU6ZMgZWVFcaMGVNqXytXrsSHH36IUaNGoUmTJvjss8+QnZ1d7vXa29tj7969OHDgAJo3b45Vq1Zh7ty5r3w+r3s/GhgYICoqCh988AEaNWqEzz//HKNHj8YXX3wBAPjggw/w9ttvo2vXrqhXrx527Njx2m34Mr6+vjhy5AiOHz+ONm3a4I033sCSJUvg4OBQ5j50dHQwdepUNGvWDJ06dYKmpiZ27twJ4NkctF9++QWrV6+GjY1NhUIu1S4S8eLOWyIiqjaOHTuGnj17Ijc3V7abhohejSM3RETVVHJyMg4ePAhXV1cGGyIFaKm6ACIiKt0777yDJ0+eYMWKFaouhahG4W4pIiIiUivcLUVERERqheGGiIiI1ArDDREREakVhhsiIiJSKww3REREpFYYboiIiEitMNwQERGRWmG4ISIiIrXCcENERERq5f8BArxKLtzWxWkAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot evolution of the parameters adjustment\n",
+    "for i, (k,v) in enumerate(MyModel.configuration[\"params\"].items()):\n",
+    "    plt.figure()\n",
+    "    plt.title(f\"{k}: parameter range limits evolution\")\n",
+    "    plt.ylabel(\"Parameter range of values\")\n",
+    "    plt.xlabel(\"Number of automatic adjustmenst\")\n",
+    "    plt.fill_between(range(ITERS), saved_params_lims[i, 0, :], saved_params_lims[i, 1, :])"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now we should be close to the optimal configuration. We should make a big simulation to obtain good results:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n"
+     ]
+    }
+   ],
+   "source": [
+    "# Update for final photo with more samples\n",
+    "MyModel.configuration.update({\n",
+    "    \"simulation\": {\n",
+    "        \"n_simulations\": 200000,\n",
+    "        \"n_executions\": 4,\n",
+    "        \"n_steps\": 100\n",
+    "    },\n",
+    "    \"results\": {\n",
+    "        \"save_percentage\": 0.01\n",
+    "    }\n",
+    "})\n",
+    "\n",
+    "MyModel.run(reference, \"my_model.data\", p_active)"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Once the results are written in the `sir.data` file we can load them and plot some results. For example the reference with a shadow of the results or histograms with infered likelihood of the parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Model running:  -> ||▮▮▮▮▮ ||100.00%  \n"
+     ]
+    }
+   ],
+   "source": [
+    "results = compartmental.util.load_parameters(\"my_model.data\")\n",
+    "weights = numpy.exp(-2*results[0]/numpy.min(results[0]))\n",
+    "weights /= numpy.min(weights)\n",
+    "\n",
+    "percentiles = compartmental.util.get_percentiles_from_results(MyModel, results, 30, 70, weights, p_active, weights)\n",
+    "try:\n",
+    "    # In case cupy is used\n",
+    "    percentiles = percentiles.get()\n",
+    "    sample = sample.get()\n",
+    "    weights = weights.get()\n",
+    "    results = results.get()\n",
+    "    sample_params = sample_params.get()\n",
+    "except AttributeError:\n",
+    "    pass\n",
+    "\n",
+    "# Plot sample with a shadow of the results.\n",
+    "plt.figure()\n",
+    "plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)\n",
+    "plt.xlabel(\"Simulation time\")\n",
+    "plt.ylabel(\"Daily Deaths / Total population\")\n",
+    "plt.plot(reference, 'black')\n",
+    "plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')\n",
+    "tax = plt.twinx()\n",
+    "tax.plot(p_active, ':', color='green')\n",
+    "tax.set_ylabel(r\"$p(t)$\")\n",
+    "\n",
+    "# Histograms with infered likelihood of the parameters\n",
+    "fig, *axes = plt.subplots(1, len(results)-1)\n",
+    "fig.set_figheight(3.5)\n",
+    "fig.set_figwidth(16)\n",
+    "for i, ax in enumerate(axes[0], 1):\n",
+    "    _5, _50, _95 = compartmental.util.weighted_quantile(results[i], [5, 50, 95], weights)\n",
+    "    for k, index in MyModel.param_to_index.items():\n",
+    "        if index == i-1:\n",
+    "            ax.set_title(k)\n",
+    "    ax.hist(results[i], weights=weights)\n",
+    "    \n",
+    "    ax.vlines(_5, *ax.get_ylim(), 'green')\n",
+    "    ax.vlines(_50, *ax.get_ylim(), 'black')\n",
+    "    ax.vlines(_95, *ax.get_ylim(), 'purple')\n",
+    "\n",
+    "    ax.vlines(sample_params[i-1], ax.get_ylim()[0], ax.get_ylim()[1]*3/4, 'red')\n",
+    "    \n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "attachments": {},
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As you can see, we are close. The red line shows the reference value, and the black one the median.\n",
+    "\n",
+    "Now we can use a manual trajectory visualizer. Keep in mind that in the trajectory selector the selected value is the red line."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib\n",
+    "plt.ion()\n",
+    "\n",
+    "values = compartmental.util.get_trajecty_selector(\n",
+    "    MyModel, results, weights, reference, p_active, show_only_reference=True\n",
+    ")\n",
+    "print(values)\n",
+    "plt.ioff()\n"
+   ]
+  }
+ ],
+ "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.11.2"
+  },
+  "orig_nbformat": 4
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/my_model.py b/examples/my_model.py
new file mode 100644
index 0000000..9fedd53
--- /dev/null
+++ b/examples/my_model.py
@@ -0,0 +1,138 @@
+# Copyright 2023 Unai Lería Fortea
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import compartmental 
+compartmental.use_numpy()
+
+import matplotlib.pyplot as plt
+import numpy
+model = {
+    "simulation": {
+        "n_simulations": 100000,
+        "n_executions": 1,
+        "n_steps": 100
+    },
+    "compartments": {
+        "Sh": { "initial_value": 0 },
+        "S": { 
+            "initial_value": 1,
+            "minus_compartments": "I"
+        },
+        "E": { "initial_value": 0 },
+        "I": { 
+            "initial_value": "Io",
+        },
+        "R": { "initial_value": 0 },
+        "Pd": { "initial_value": 0 },
+        "D": { "initial_value": 0 },
+    },
+    "params": {
+        "betta": {
+            "min": 0.01,
+            "max": 0.3
+        },
+        "Io": {
+            "min": 1e-8,
+            "max": 1e-5
+        },
+        "phi": {
+            "min": 0,
+            "max": 1
+        },
+        "IFR": {
+            "min":0.006,
+            "max":0.014
+        },
+        "xi": {
+            "min":1/16,
+            "max":1/6
+        },
+        "offset": {
+            "min":4,
+            "max":12
+        }
+    },
+    "fixed_params": {
+        "K_active": 12.4,
+        "K_lockdown": 2.4,
+        "sigma": 3.4,
+        "mu": 1/4.2,
+        "eta":1/5.2
+    },
+    "reference": {
+        "compartments" : ["D"],
+        "offset": "offset" 
+    },
+    "results": { 
+        "save_percentage": 1
+    }
+}
+
+MyModel = compartmental.GenericModel(model)
+
+def evolve(m, time, p_active, *args, **kargs):
+    ST = m.S + m.Sh
+    sh = (1 - m.I) ** (m.sigma - 1)
+
+    P_infection_active = 1- (1- m.betta * m.I) ** m.K_active
+    P_infection_lockdown = 1- (1- m.betta * m.I) ** m.K_lockdown
+
+    P_infection = p_active[time] * P_infection_active + (1-p_active[time]) * (1-sh*(1-m.phi)) * P_infection_lockdown
+
+
+    m.Sh[:]    = ST * (1-p_active[time])*sh*(1-m.phi)
+    delta_S = ST * P_infection
+    m.S[:]     = (ST - m.Sh)  - delta_S
+   
+    m.D[:]     = m.xi * m.Pd
+    m.R[:]     = m.mu * (1-m.IFR)  * m.I + m.R
+    m.Pd[:]    = m.mu * m.IFR  * m.I + (1-m.xi) * m.Pd
+    m.I[:]     = m.eta  * m.E + (1- m.mu) * m.I
+    m.E[:]     = delta_S + (1-m.eta) * m.E
+    
+MyModel.evolve = evolve
+
+p_active = [1 if t<70 else 0.1 for t in range(model["simulation"]["n_steps"])]
+
+sample, sample_params = compartmental.util.get_model_sample_trajectory(
+    MyModel, p_active,
+    **{"betta": 0.13,
+        "Io": 1e-6,
+        "phi": 0.1,
+        "IFR": 0.01,
+        "xi": 1/10,
+        "offset": 8}
+)
+
+
+ITERS = 2
+# This array is created to store min and max of params configuration in order to see the adjustment in action.
+saved_params_lims = numpy.zeros((len(MyModel.configuration["params"]), 2, ITERS))
+
+# Main loop of adjustments:
+# 1. Run
+# 2. Read results
+# 3. Compute weights
+# 4. Adjuts configuration
+for i in range(ITERS):
+    MyModel.run(sample[MyModel.compartment_name_to_index["D"]], f"my_model{i}.data", p_active)
+    
+    results = compartmental.util.load_parameters(f"my_model{i}.data")
+    
+    compartmental.util.auto_adjust_model_params(MyModel, results)
+    
+    # Needed to see the max and min evolution in the adjustment
+    for p, v in MyModel.configuration["params"].items():
+        saved_params_lims[MyModel.param_to_index[p], 0, i] = v["min"]
+        saved_params_lims[MyModel.param_to_index[p], 1, i] = v["max"]
\ No newline at end of file
diff --git a/examples/seir.py b/examples/seir.py
index d098524..26e0ed0 100644
--- a/examples/seir.py
+++ b/examples/seir.py
@@ -20,14 +20,14 @@
 
 seir_model = {
     "simulation": {
-        "n_simulations": 100000,
+        "n_simulations": 1000000,
         "n_executions": 1,
         "n_steps": 230
     },
-    "compartiments": {
+    "compartments": {
         "S": { 
             "initial_value": 1,
-            "minus_compartiments": "I"
+            "minus_compartments": "I"
         },
         "E": { "initial_value": 0 },
         "I": { 
@@ -43,6 +43,11 @@
         "Io": {
             "min": 1e-6,
             "max": 1e-4
+        },
+        "off": {
+            "type": int,
+            "min": -3,
+            "max": 3
         }
     },
     "fixed_params": {
@@ -51,7 +56,8 @@
         "eta":0.08
     },
     "reference": {
-        "compartiments" : ["R"]
+        "compartments" : ["R"],
+        "offset": "off"
     },
     "results": {
         "save_percentage": 0.1
@@ -70,10 +76,10 @@ def evolve(m, *args, **kargs):
     
 SeirModel.evolve = evolve
 
-sample, sample_params = gcm.util.get_model_sample_trajectory(SeirModel, **{"betta": 0.2, "Io":6e-5})
+sample, sample_params = gcm.util.get_model_sample_trajectory(SeirModel, **{"off": -2, "betta": 0.2, "Io":6e-5})
 
 
-SeirModel.run(sample[SeirModel.compartiment_name_to_index["R"]], "seir.data")
+SeirModel.run(sample[SeirModel.compartment_name_to_index["R"]], "seir.data")
 
 results = gcm.util.load_parameters("seir.data")
 weights = numpy.exp(-results[0]/numpy.min(results[0]))
@@ -89,12 +95,12 @@ def evolve(m, *args, **kargs):
 except AttributeError:
     pass
 
-plt.figure()
+plt.subplots()
 plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
-plt.plot(sample[SeirModel.compartiment_name_to_index["S"]], 'green')
-plt.plot(sample[SeirModel.compartiment_name_to_index["E"]], 'red')
-plt.plot(sample[SeirModel.compartiment_name_to_index["I"]], 'orange')
-plt.plot(sample[SeirModel.compartiment_name_to_index["R"]], 'brown')
+plt.plot(sample[SeirModel.compartment_name_to_index["S"]], 'green')
+plt.plot(sample[SeirModel.compartment_name_to_index["E"]], 'red')
+plt.plot(sample[SeirModel.compartment_name_to_index["I"]], 'orange')
+plt.plot(sample[SeirModel.compartment_name_to_index["R"]], 'brown')
 plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
 
 
diff --git a/examples/sir.ipynb b/examples/sir.ipynb
index de7eb31..4683f72 100644
--- a/examples/sir.ipynb
+++ b/examples/sir.ipynb
@@ -64,10 +64,10 @@
     "        \"n_executions\": 1,\n",
     "        \"n_steps\": 130\n",
     "    },\n",
-    "    \"compartiments\": {\n",
+    "    \"compartments\": {\n",
     "        \"S\": { \n",
     "            \"initial_value\": 1,\n",
-    "            \"minus_compartiments\": \"I\"\n",
+    "            \"minus_compartments\": \"I\"\n",
     "        },\n",
     "        \"I\": { \n",
     "            \"initial_value\": \"Io\",\n",
@@ -98,7 +98,7 @@
     "        \"K_mean\": 1\n",
     "    },\n",
     "    \"reference\": {\n",
-    "        \"compartiments\" : [\"R\"]\n",
+    "        \"compartments\" : [\"R\"]\n",
     "    },\n",
     "    \"results\": {\n",
     "        \"save_percentage\": 0.1\n",
@@ -191,7 +191,7 @@
     "# 3. Compute weights\n",
     "# 4. Adjuts configuration\n",
     "for i in range(7):\n",
-    "    SirModel.run(sample[SirModel.compartiment_name_to_index[\"R\"]], f\"sir_temp{i}.data\")\n",
+    "    SirModel.run(sample[SirModel.compartment_name_to_index[\"R\"]], f\"sir_temp{i}.data\")\n",
     "    \n",
     "    results = compartmental.util.load_parameters(f\"sir_temp{i}.data\")\n",
     "    \n",
@@ -289,7 +289,7 @@
     "    }\n",
     "})\n",
     "\n",
-    "SirModel.run(sample[SirModel.compartiment_name_to_index[\"R\"]], \"sir.data\")"
+    "SirModel.run(sample[SirModel.compartment_name_to_index[\"R\"]], \"sir.data\")"
    ]
   },
   {
@@ -351,9 +351,9 @@
     "# Plot sample with a shadow of the results.\n",
     "plt.figure()\n",
     "plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)\n",
-    "plt.plot(sample[SirModel.compartiment_name_to_index[\"S\"]], 'green')\n",
-    "plt.plot(sample[SirModel.compartiment_name_to_index[\"I\"]], 'orange')\n",
-    "plt.plot(sample[SirModel.compartiment_name_to_index[\"R\"]], 'brown')\n",
+    "plt.plot(sample[SirModel.compartment_name_to_index[\"S\"]], 'green')\n",
+    "plt.plot(sample[SirModel.compartment_name_to_index[\"I\"]], 'orange')\n",
+    "plt.plot(sample[SirModel.compartment_name_to_index[\"R\"]], 'brown')\n",
     "plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')\n",
     "\n",
     "# Histograms with infered likelihood of the parameters\n",
@@ -400,7 +400,7 @@
     "plt.ion()\n",
     "\n",
     "values = compartmental.util.get_trajecty_selector(\n",
-    "    SirModel, results, weights, sample[SirModel.compartiment_name_to_index[\"R\"]]\n",
+    "    SirModel, results, weights, sample[SirModel.compartment_name_to_index[\"R\"]]\n",
     ")\n",
     "print(values)\n"
    ]
diff --git a/examples/sir.py b/examples/sir.py
index 4533168..a29bc95 100644
--- a/examples/sir.py
+++ b/examples/sir.py
@@ -24,10 +24,10 @@
         "n_executions": 1,
         "n_steps": 130
     },
-    "compartiments": {
+    "compartments": {
         "S": { 
             "initial_value": 1,
-            "minus_compartiments": "I"
+            "minus_compartments": "I"
         },
         "I": { 
             "initial_value": "Io",
@@ -41,12 +41,6 @@
             "min_limit": 0.1,
             "max_limit": 0.4
         },
-        "mu": {
-            "min": 0.01,
-            "max": 0.2,
-            "min_limit": 0.01,
-            "max_limit": 0.2
-        },
         "Io": {
             "min": 1e-6,
             "max": 1e-4,
@@ -55,15 +49,17 @@
         },
         "To": {
             "type": "int",
-            "min": -5,
-            "max": 5
+            "min": 0,
+            "min_limit": 0,
+            "max": 8
         }
     },
     "fixed_params": {
-        "K_mean": 1
+        "K_mean": 1,
+        "mu": 0.08
     },
     "reference": {
-        "compartiments" : ["R"],
+        "compartments" : ["R"],
         "offset": "To"
     },
     "results": {
@@ -82,7 +78,12 @@ def evolve(m, *args, **kargs):
     
 SirModel.evolve = evolve
 
-sample, sample_params = gcm.util.get_model_sample_trajectory(SirModel, **{"To":-2, "betta":0.2, "mu":0.08, "Io": 1e-5})
+OFFSET = 3
+
+sample, sample_params = gcm.util.get_model_sample_trajectory(SirModel, **{"betta":0.2, "Io": 1e-5, "To": OFFSET})
+
+reference = numpy.copy(sample[SirModel.compartment_name_to_index["R"]])
+gcm.util.offset_array(reference, OFFSET)
 
 
 ITERS = 7
@@ -95,12 +96,12 @@ def evolve(m, *args, **kargs):
 # 3. Compute weights
 # 4. Adjuts configuration
 for i in range(ITERS):
-    SirModel.run(sample[SirModel.compartiment_name_to_index["R"]], "sir_temp.data")
+    SirModel.run(reference, "sir_temp.data")
     
     results = gcm.util.load_parameters("sir_temp.data")
     weights = numpy.exp(-results[0]/numpy.min(results[0]))
     
-    gcm.util.auto_adjust_model_params(SirModel, results, weights, adjust=[""])
+    gcm.util.auto_adjust_model_params(SirModel, results, weights)
     
     # Needed to see the max and min evolution in the adjustment
     for p, v in SirModel.configuration["params"].items():
@@ -116,8 +117,8 @@ def evolve(m, *args, **kargs):
 # Update for final photo with 3M samples
 SirModel.configuration.update({
     "simulation": {
-        "n_simulations": 1000000,
-        "n_executions": 3,
+        "n_simulations": 100000,
+        "n_executions": 10,
         "n_steps": 130
     },
     "results": {
@@ -125,12 +126,12 @@ def evolve(m, *args, **kargs):
     }
 })
 
-SirModel.run(sample[SirModel.compartiment_name_to_index["R"]], "sir.data")
+SirModel.run(reference, "sir.data")
 
 results = gcm.util.load_parameters("sir.data")
 weights = numpy.exp(-results[0]/numpy.min(results[0]))
 
-percentiles = gcm.util.get_percentiles_from_results(SirModel, results, 30, 70)#, weights)
+percentiles = gcm.util.get_percentiles_from_results(SirModel, results, 30, 70, weights)
 try:
     # In case cupy is used
     percentiles = percentiles.get()
@@ -143,9 +144,10 @@ def evolve(m, *args, **kargs):
 
 plt.figure()
 plt.fill_between(numpy.arange(percentiles.shape[2]), percentiles[0,0], percentiles[0,2], alpha=0.3)
-plt.plot(sample[SirModel.compartiment_name_to_index["S"]], 'green')
-plt.plot(sample[SirModel.compartiment_name_to_index["I"]], 'orange')
-plt.plot(sample[SirModel.compartiment_name_to_index["R"]], 'brown')
+plt.plot(sample[SirModel.compartment_name_to_index["S"]], 'green')
+plt.plot(sample[SirModel.compartment_name_to_index["I"]], 'orange')
+plt.plot(sample[SirModel.compartment_name_to_index["R"]], 'black')
+plt.plot(reference, 'brown')
 plt.plot(numpy.arange(percentiles.shape[2]), percentiles[0,1], '--', color='purple')
 
 
@@ -161,5 +163,5 @@ def evolve(m, *args, **kargs):
 plt.show()
 
 
-values = gcm.util.get_trajecty_selector(SirModel, results, weights, sample[SirModel.compartiment_name_to_index["R"]])
+values = gcm.util.get_trajecty_selector(SirModel, results, weights, reference)
 print(values)
\ No newline at end of file
diff --git a/mkdocs.yml b/mkdocs.yml
index 8233db8..05e9de2 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -23,7 +23,7 @@ watch: [README.md, compartmental, examples]
 
 nav:
 - Home:
-  - Overview: index.md
+  - Overview: README.md
   - License: LICENSE.md
 - Code Reference: reference/
 - Examples: examples/
@@ -34,16 +34,16 @@ theme:
     # Palette toggle for dark mode
     - media: "(prefers-color-scheme: light)"
       scheme: slate
-      primary: cyan
-      accent: light-blue
+      primary: black
+      accent: grey
       toggle:
         icon: material/brightness-7
         name: Switch to light mode
     # Palette toggle for light mode
     - media: "(prefers-color-scheme: dark)"
       scheme: default
-      primary: cyan
-      accent: light-blue
+      primary: black
+      accent: grey
       toggle:
         icon: material/brightness-3 
         name: Switch to dark mode
diff --git a/pyproject.toml b/pyproject.toml
index 0c46c41..03d10ca 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -5,10 +5,10 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "compartmental"
-version = "0.0.3"
+version = "0.1.0"
 requires-python = ">=3.8"
 
-description = ""
+description = "Compartmental models with ABC inference optimized for GPU use"
 
 authors = [
     {name =  "Unai Lería Fortea"   , email =  "unaileria@gmail.com"}]
@@ -20,18 +20,26 @@ maintainers = [
 readme = "README.md"
 license = { text="Apache License 2.0"}
 
-keywords = []
+keywords = ["compartmental models", "fit", "analysis", "ABC", "computation"]
 
-classifiers = []
+classifiers = [
+    "Intended Audience :: Education",
+    "Intended Audience :: Science/Research",
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Topic :: Education",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Visualization"]
 
 dependencies = ['numpy']
 
 [project.urls]
-"GitHub" = "https://github.com/${USERNAME}/compartmental"
-"Documentation" = "https://${USERNAME}/.github.io/compartmental/"
+"GitHub" = "https://github.com/QuanticPony/compartmental"
+"Documentation" = "https://QuanticPony/.github.io/compartmental/"
 
 [tool.bumpver]
-current_version = "0.0.3"
+current_version = "0.1.0"
 version_pattern = "MAJOR.MINOR.PATCH"
 commit_message = "Update version: {old_version} -> {new_version}"
 commit = true
diff --git a/setup.py b/setup.py
index 932926a..2e5db24 100644
--- a/setup.py
+++ b/setup.py
@@ -1,4 +1,4 @@
 from setuptools import setup
 
 if __name__=='__main__':
-	setup(packages=["compartmental"])
\ No newline at end of file
+	setup(name="compartmental", packages=["compartmental"])
\ No newline at end of file