From a24c82f3966ce5b8000be07cb6523060394eb563 Mon Sep 17 00:00:00 2001
From: lisandrojim <lisandro11991@gmail.com>
Date: Mon, 13 May 2024 10:16:16 +0200
Subject: [PATCH] Commit May 13 2024

---
 .DS_Store                                     |  Bin 0 -> 6148 bytes
 ...toy_data_and_msdm_from_markov_chains.ipynb |  608 ++++++++
 requirements.txt                              |  489 ++++++
 scripts/.DS_Store                             |  Bin 0 -> 8196 bytes
 scripts/DataHandlingManager.py                |  120 ++
 scripts/LoadMSDM.py                           |  151 ++
 .../aux_MarkovChainCalibrationAlgorithms.py   |  266 ++++
 scripts/aux_common_functions_ihtmc_dtmc.py    |  119 ++
 scripts/aux_functions.py                      | 1312 +++++++++++++++++
 scripts/dtmc.py                               |  279 ++++
 scripts/generateToyMCExamples.py              |   58 +
 scripts/ihtmc.py                              |  486 ++++++
 scripts/markov_chain_calibration.py           |  151 ++
 scripts/markov_chain_structures.py            |   57 +
 scripts/markov_chain_types/.DS_Store          |  Bin 0 -> 6148 bytes
 ...nctions_markov_chain_types.cpython-311.pyc |  Bin 0 -> 6966 bytes
 ...unctions_markov_chain_types.cpython-39.pyc |  Bin 0 -> 4502 bytes
 .../__pycache__/ihtmc_s2_typeA.cpython-39.pyc |  Bin 0 -> 4450 bytes
 .../__pycache__/s5_typeA.cpython-39.pyc       |  Bin 0 -> 10091 bytes
 .../__pycache__/s6_typeA.cpython-311.pyc      |  Bin 0 -> 14858 bytes
 .../__pycache__/s6_typeA.cpython-39.pyc       |  Bin 0 -> 10507 bytes
 ...aux_common_functions_markov_chain_types.py |    1 +
 scripts/markov_chain_types/ihtmc_s2_typeA.py  |  118 ++
 scripts/markov_chain_types/ihtmc_s6_typeA.py  |  109 ++
 scripts/markov_chain_types/ihtmc_s6_typeB.py  |   98 ++
 scripts/markov_chain_types/s5_typeA.py        |  217 +++
 scripts/markov_chain_types/s6_typeA.py        |  250 ++++
 scripts/msdmodeler.py                         |  151 ++
 scripts/probability_density_functions.py      |   87 ++
 scripts/sample_markov_chain.py                |   34 +
 scripts/turnbull.py                           |  178 +++
 scripts/turnbull_estimator.py                 |  123 ++
 32 files changed, 5462 insertions(+)
 create mode 100644 .DS_Store
 create mode 100755 examples/toy_data_and_msdm_from_markov_chains.ipynb
 create mode 100644 requirements.txt
 create mode 100644 scripts/.DS_Store
 create mode 100644 scripts/DataHandlingManager.py
 create mode 100755 scripts/LoadMSDM.py
 create mode 100644 scripts/aux_MarkovChainCalibrationAlgorithms.py
 create mode 100644 scripts/aux_common_functions_ihtmc_dtmc.py
 create mode 100755 scripts/aux_functions.py
 create mode 100644 scripts/dtmc.py
 create mode 100644 scripts/generateToyMCExamples.py
 create mode 100644 scripts/ihtmc.py
 create mode 100644 scripts/markov_chain_calibration.py
 create mode 100644 scripts/markov_chain_structures.py
 create mode 100644 scripts/markov_chain_types/.DS_Store
 create mode 100644 scripts/markov_chain_types/__pycache__/aux_common_functions_markov_chain_types.cpython-311.pyc
 create mode 100644 scripts/markov_chain_types/__pycache__/aux_common_functions_markov_chain_types.cpython-39.pyc
 create mode 100644 scripts/markov_chain_types/__pycache__/ihtmc_s2_typeA.cpython-39.pyc
 create mode 100644 scripts/markov_chain_types/__pycache__/s5_typeA.cpython-39.pyc
 create mode 100644 scripts/markov_chain_types/__pycache__/s6_typeA.cpython-311.pyc
 create mode 100644 scripts/markov_chain_types/__pycache__/s6_typeA.cpython-39.pyc
 create mode 100644 scripts/markov_chain_types/aux_common_functions_markov_chain_types.py
 create mode 100755 scripts/markov_chain_types/ihtmc_s2_typeA.py
 create mode 100755 scripts/markov_chain_types/ihtmc_s6_typeA.py
 create mode 100755 scripts/markov_chain_types/ihtmc_s6_typeB.py
 create mode 100755 scripts/markov_chain_types/s5_typeA.py
 create mode 100755 scripts/markov_chain_types/s6_typeA.py
 create mode 100644 scripts/msdmodeler.py
 create mode 100644 scripts/probability_density_functions.py
 create mode 100644 scripts/sample_markov_chain.py
 create mode 100644 scripts/turnbull.py
 create mode 100644 scripts/turnbull_estimator.py

diff --git a/.DS_Store b/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..450a83ae4fa86b1897ab43f7beeb7ef0ea2761ff
GIT binary patch
literal 6148
zcmZQzU|@7AO)+F(5MW?n;9!8zEL;p&0Z1N%F(jFwB0M1Tz-AOM<S?W%6epDz7eM7k
zsnHM^4S~TM0-(Ih!H~*O!H~$1%Yc-BlXCKt7#J9KB^Bgk7MB<pTw`QnW?^MxXXj++
zW{(Zd$S)5rNh~QXc1kRY2Ju4j^K+75?8Kz7%+&ID0TJi?ypqJsywoC)lHkmg)TG3s
znDETJl>Bn1{L;LXVz6GQ1Scm4XS{$^b+xX!v5}5~uAzZxt&T#qsiC2cf~kRNZ7nB<
zsItCwP<(byZeD&5Bv2U{Av6Ool!j5g;Gzx9XF2JH!O8i#$fXm8?{o8AT%f+^5MC~K
z<=>B^j@Zn~%}*gpT|ow6JIjKL@^bR?(jg@&13N=8Lo!1VLncE3LkXljg}P{H#|N6f
zu*3$M3go!>vD(rN8W$L<5HW#U6_$8FGY2geU@2+1($Jj4!983(IO?y_5Eu;svO@q=
zJ}5wIBnK$n0HHxr42%p6;4T0o0|N`p5=L-8fB_^2(h8zMT0t~OD+42l1vUe$m4Oke
zl@Z(x0qFyENkBAMI|CyFSUUqF16Vr)th#4}XlG!A+RO;;p)f+UGcZE5GcZE5!<;ut
zkA}c#2tY%C8A1zy>VH=T23-Arh^kR?Gz3ONU|5C#Ba2J0ixap~#_m5*T??vD6QI(d
z+8<OMGlJ@Ah(3@Kuq+c~Kv4qBfyjZhf~tLRRm{i$smVth0<aJorAI@6{viMW$b`~`

literal 0
HcmV?d00001

diff --git a/examples/toy_data_and_msdm_from_markov_chains.ipynb b/examples/toy_data_and_msdm_from_markov_chains.ipynb
new file mode 100755
index 0000000..eaae43e
--- /dev/null
+++ b/examples/toy_data_and_msdm_from_markov_chains.ipynb
@@ -0,0 +1,608 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "2e15f1f9",
+   "metadata": {},
+   "source": [
+    "# Generating toy data and multi-state degradation models from Markov chains: Toy example *ihtmc_s2_typeA*"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "903a6015",
+   "metadata": {},
+   "source": [
+    "## Overview\n",
+    "This notebook describes how to generate toy data using continuous-time Markov chains with homogeneous and inhomogeneous time hazard rates. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "86998d16",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Add to the path\n",
+    "import sys\n",
+    "import os\n",
+    "# Add the indicated folder, and all its subfolders to the path\n",
+    "folder_path = os.path.join(os.path.dirname(os.getcwd()), 'code', 'files', 'scripts')\n",
+    "sys.path.append(folder_path)\n",
+    "for root, dirs, files in os.walk(folder_path):\n",
+    "    for dir in dirs:\n",
+    "        sys.path.append(os.path.join(root, dir))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8356e547",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load necessary libraries\n",
+    "from ihtmc import InhomogeneousTimeMarkovChain as IHTMC\n",
+    "from markov_chain_calibration import MarkovChainCalibration as MCCal\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import os\n",
+    "from mpl_toolkits.mplot3d import Axes3D\n",
+    "import random"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "814a4cac",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define auxiliary functions\n",
+    "def random_color():\n",
+    "    return \"#{:06x}\".format(random.randint(0, 0xFFFFFF))\n",
+    "def generate_random_samples(n, bounds):\n",
+    "    return np.random.uniform(low=[b[0] for b in bounds], high=[b[1] for b in bounds], size=(n, len(bounds)))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cf6648a1",
+   "metadata": {},
+   "source": [
+    "## Input parameters\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "27996dfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#%% Input parameters:\n",
+    "t_from = 0\n",
+    "t_to   = 50\n",
+    "MCStructureID = 'ihtmc_s2_typeA'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "f372d797",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#%% Ground-truth Markov chain\n",
+    "ground_hazard_function = 'gompertz'\n",
+    "ground_truth_MC = IHTMC(MCStructureID=MCStructureID,hazard_function=ground_hazard_function)\n",
+    "ground_truth_MC.MCObj.x  = np.array([0.05,0.1])\n",
+    "ground_truth_MC.MCObj.s0 = np.array([0.9,0.1])\n",
+    "g = ground_truth_MC.predict(t=np.linspace(t_from,t_to,1000),atol=1e-4, rtol=1e-4)  # Removed colon at the end"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "9a0502b5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'State Probability')"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot Ground-truth Markov chain\n",
+    "t = np.linspace(t_from,t_to,1000)\n",
+    "plt.plot(t,ground_truth_MC.predict(t=t)[ground_truth_MC.MCObj.states[0]],color='red',linestyle='--',label='state: '+str(ground_truth_MC.MCObj.states[0]))\n",
+    "plt.plot(t,ground_truth_MC.predict(t=t)[ground_truth_MC.MCObj.states[1]],color='blue',linestyle='--',label='state: '+str(ground_truth_MC.MCObj.states[1]))\n",
+    "plt.xlabel('Time')\n",
+    "plt.legend()\n",
+    "plt.grid()\n",
+    "plt.title('Hazard function: '+ground_hazard_function)\n",
+    "plt.ylabel('State Probability')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b4630c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      state  count\n",
+      "time              \n",
+      "0         1    167\n",
+      "0         2     20\n",
+      "1         1    193\n",
+      "1         2     22\n",
+      "2         1    177\n",
+      "...     ...    ...\n",
+      "47        2    212\n",
+      "48        1      1\n",
+      "48        2    216\n",
+      "49        2    229\n",
+      "50        2    197\n",
+      "\n",
+      "[98 rows x 2 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "#%% Randomly sample from Markov chain --> Generate synthetic dataset.\n",
+    "num_inspections = 10000\n",
+    "ti = np.array(g.index)\n",
+    "s = g.columns\n",
+    "times = np.random.randint(t_from, t_to + 1, num_inspections)#np.random.uniform(t_from, t_to, num_inspections)\n",
+    "choices = [np.random.choice(s, p=g.iloc[np.argmin(np.abs(t - ti))].values) for t in times]\n",
+    "obs = np.column_stack((times, choices))\n",
+    "system_inspections = pd.DataFrame(obs, columns=['time', 'state']).sort_values(by='time', ascending=True).reset_index(drop=True)\n",
+    "system_inspections = system_inspections.groupby(['time', 'state']).size().reset_index(name='count')\n",
+    "system_inspections.set_index('time', inplace=True)\n",
+    "print(system_inspections)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "c936e0b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Counts')"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure()\n",
+    "t = np.linspace(t_from,t_to,1000)\n",
+    "for s in ground_truth_MC.MCObj.states:\n",
+    "    plt.bar(system_inspections[system_inspections['state'] == s].index,\n",
+    "            system_inspections[system_inspections['state'] == s]['count'],\n",
+    "            alpha=0.5,label='State '+str(s))\n",
+    "plt.xlabel('Time')\n",
+    "plt.legend(loc='best')\n",
+    "plt.grid()\n",
+    "plt.ylabel('Counts')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "337b5932",
+   "metadata": {},
+   "source": [
+    "## Train Markov chain models"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "4f7ccdfe",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define the hazard function for the Markov models\n",
+    "functions = ['lognormal','loglogistic','gompertz','exponential','weibull']\n",
+    "# Path where models will be stored\n",
+    "path = '../code/files/toy_degradation_models/toy_models_ihtmc_s2_typeA'"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "ea830f31",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#%% Markov chains models:\n",
+    "models = {}\n",
+    "for pdf in functions:\n",
+    "    models[pdf] = IHTMC(df=system_inspections,MCStructureID=MCStructureID,hazard_function=pdf)\n",
+    "    if os.path.exists(path+'/'+pdf+'.dill'):\n",
+    "        models[pdf] = models[pdf].load(filename=pdf,path=path)\n",
+    "    else:\n",
+    "        models[pdf].fit(opt_method='differential_evolution',args={'maxiter':1000,'popsize':50,'polish':True})\n",
+    "        models[pdf].save(filename=pdf,path=path)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cededd82",
+   "metadata": {},
+   "source": [
+    "## Display Markov chain predictions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "1b5e307c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/p06b_CMDP/code/files/scripts/aux_files/probability_density_functions.py:45: RuntimeWarning: divide by zero encountered in log\n",
+      "  log_transform = np.log(t / alpha) * beta\n",
+      "/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/p06b_CMDP/code/files/scripts/aux_files/probability_density_functions.py:45: RuntimeWarning: divide by zero encountered in log\n",
+      "  log_transform = np.log(t / alpha) * beta\n",
+      "/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/p06b_CMDP/code/files/scripts/aux_files/probability_density_functions.py:85: RuntimeWarning: divide by zero encountered in double_scalars\n",
+      "  return (alpha / beta) * (t / beta)**(alpha - 1)\n",
+      "/Applications/anaconda3/lib/python3.9/site-packages/scipy/integrate/_odepack_py.py:247: ODEintWarning: Illegal input detected (internal error). Run with full_output = 1 to get quantitative information.\n",
+      "  warnings.warn(warning_msg, ODEintWarning)\n",
+      "/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/p06b_CMDP/code/files/scripts/aux_files/probability_density_functions.py:85: RuntimeWarning: divide by zero encountered in double_scalars\n",
+      "  return (alpha / beta) * (t / beta)**(alpha - 1)\n",
+      "/Applications/anaconda3/lib/python3.9/site-packages/scipy/integrate/_odepack_py.py:247: ODEintWarning: Illegal input detected (internal error). Run with full_output = 1 to get quantitative information.\n",
+      "  warnings.warn(warning_msg, ODEintWarning)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      " lsoda--  warning..internal t (=r1) and h (=r2) are\u0000\u0000\n",
+      "       such that in the machine, t + h = t on the next step  \n",
+      "       (h = step size). solver will continue anyway\u0000\u0000\n",
+      "      in above,  r1 =  0.0000000000000D+00   r2 =  0.0000000000000D+00\n",
+      " intdy--  t (=r1) illegal      \u0000\u0000\n",
+      "      in above message,  r1 =  0.5005005005005D-01\n",
+      "      t not in interval tcur - hu (= r1) to tcur (=r2)       \n",
+      "      in above,  r1 =  0.0000000000000D+00   r2 =  0.0000000000000D+00\n",
+      " intdy--  t (=r1) illegal      \u0000\u0000\n",
+      "      in above message,  r1 =  0.1001001001001D+00\n",
+      "      t not in interval tcur - hu (= r1) to tcur (=r2)       \n",
+      "      in above,  r1 =  0.0000000000000D+00   r2 =  0.0000000000000D+00\n",
+      " lsoda--  trouble from intdy. itask = i1, tout = r1\u0000\u0000\n",
+      "      in above message,  i1 =         1\n",
+      "      in above message,  r1 =  0.1001001001001D+00\n",
+      " lsoda--  warning..internal t (=r1) and h (=r2) are\u0000\u0000\n",
+      "       such that in the machine, t + h = t on the next step  \n",
+      "       (h = step size). solver will continue anyway\u0000\u0000\n",
+      "      in above,  r1 =  0.0000000000000D+00   r2 =  0.0000000000000D+00\n",
+      " intdy--  t (=r1) illegal      \u0000\u0000\n",
+      "      in above message,  r1 =  0.5005005005005D-01\n",
+      "      t not in interval tcur - hu (= r1) to tcur (=r2)       \n",
+      "      in above,  r1 =  0.0000000000000D+00   r2 =  0.0000000000000D+00\n",
+      " intdy--  t (=r1) illegal      \u0000\u0000\n",
+      "      in above message,  r1 =  0.1001001001001D+00\n",
+      "      t not in interval tcur - hu (= r1) to tcur (=r2)       \n",
+      "      in above,  r1 =  0.0000000000000D+00   r2 =  0.0000000000000D+00\n",
+      " lsoda--  trouble from intdy. itask = i1, tout = r1\u0000\u0000\n",
+      "      in above message,  i1 =         1\n",
+      "      in above message,  r1 =  0.1001001001001D+00\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#%% Plot multi-state degradation models:\n",
+    "t = np.linspace(t_from, t_to, 1000)\n",
+    "plt.figure(figsize=(10,5))\n",
+    "for pdf, model in models.items():\n",
+    "    color = random_color()\n",
+    "    for state in model.MCObj.states:\n",
+    "        plt.plot(t, model.predict(t=t)[state], linestyle='-', label=f'state: {state}, {pdf} error: {models[pdf].MCObj.convergence_info[\"fun\"]}', color=color)\n",
+    "for state in ground_truth_MC.MCObj.states:\n",
+    "    plt.plot(t, ground_truth_MC.predict(t=t)[state], linestyle='--', label=f'state: {state}, ground truth', color='red' if state == ground_truth_MC.MCObj.states[0] else 'blue')\n",
+    "plt.xlabel('Time')\n",
+    "plt.ylabel('State Probability')\n",
+    "plt.grid(True)\n",
+    "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
+    "plt.tight_layout()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dc719dea",
+   "metadata": {},
+   "source": [
+    "## Visualization of transition probability matrix for inhomogeneous-time Markov chains"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba5b859b",
+   "metadata": {},
+   "source": [
+    "### Background\n",
+    "\n",
+    "Now that we have trained the multi-state degradation models using inhomogeneous/homogeneous-time Markov chains, we can also plot the value of the transition probability $P_{i,j}(t,\\tau)$, between time $t$ and $\\tau$. For this, we need to solve the differential equation:\n",
+    "\n",
+    "\\begin{equation}\n",
+    "\\frac{\\partial P_{ij}(t,\\tau)}{\\partial t} = \\sum_{k \\in S} P_{ik}(t,\\tau)Q_{kj}(t)\n",
+    "\\end{equation}\n",
+    "\n",
+    "Where $P_{ij}(t, \\tau): \\Omega \\times \\Omega \\to [0,1]$ is a continuous and differentiable function known as the *transition probability matrix*, indicating the probability of transitioning from state $i$ to state $j$ in the time interval $t$ to $\\tau$, where $\\tau > t$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6c7c3fc8",
+   "metadata": {},
+   "source": [
+    "### Example\n",
+    "We now demonstrate the computation of the transision probability matrix $P_{i,j}(t,\\tau)$ for the **gompertz** (*inhomogeneous*) and **exponential** (*homogeneous*) distributions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "8c74a172",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnUAAAHWCAYAAAARl3+JAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC2l0lEQVR4nOzdd3hTZfvA8W+6W+hitVBGQbZgWYLAKxvKFByIi1EQZb2CFRRe2SpFZAoIKC9QFH8ggrwqQ0oZBURGGYosgSKrZQi0dKfJ+f1xbGxIWtLS9rTp/bmuXE1Onpxz52n69M45z9ApiqIghBBCCCGKNQetAxBCCCGEEI9OkjohhBBCCDsgSZ0QQgghhB2QpE4IIYQQwg5IUieEEEIIYQckqRNCCCGEsAOS1AkhhBBC2AFJ6oQQQggh7ICT1gHYA6PRyPXr1/H09ESn02kdjhDib4qicP/+fSpVqoSDg3yHzYm0Y0IUXba2ZZLU5YPr169TpUoVrcMQQmTjypUrVK5cWeswijRpx4Qo+h7WlklSlw88PT0BtbK9vLysltHr9Wzfvp0uXbrg7OxcmOEVaVIvlqROLOW1ThISEqhSpYrpb1Rkz5Z2DOTzaY3UiXVSL5YKui2TpC4fZF6q8PLyyjGp8/DwwMvLSz7cWUi9WJI6sfSodSKXEx/OlnYM5PNpjdSJdVIvlgq6LZNOJkIIIYQQdsDukrqoqCh69epFpUqV0Ol0bNq06aGv2b17N02aNMHV1ZWaNWuyatWqAo9TCCGEECI/2V1Sl5SURFBQEIsXL7apfExMDD169KB9+/YcP36cMWPG8Prrr/PTTz8VcKRCCCGEEPnH7vrUdevWjW7dutlcfunSpVSvXp05c+YAUK9ePfbt28e8efMIDg4uqDCFEKJYMhgMODk5kZqaisFg0DqcIkGv15eYOnF2dsbR0VHrMEQ27C6py60DBw7QqVMns23BwcGMGTMm29ekpaWRlpZmepyQkACof9h6vd7qa/R6PefO+VC6tAEPDx0uLgquruDigsVPFxcoKf26M+sru3oriaROLOW1TqQO84+iKMTFxXH37l38/f25cuWKDED5m6IoJapOfHx88Pf3LxHvtSD98QdcugT/+he4u+fPPkt8UhcXF4efn5/ZNj8/PxISEkhJScHdSk2HhYUxbdo0i+3bt2/Hw8Mj22MtWNCBa9fcbIrLycmAk5OCs7PlT2dnI05ORpydjbi6GnB1NeDmloGrqwEXl8zHBtNzrq4ZWcoZcHHJwN3dgIeHHg+PDBwdFZtiKkgRERFah1DkSJ1Yym2dJCcnF1AkJU9cXBz37t2jfPnyGI1GPD09ZULnvxmNRhITEyldurRd14miKCQnJ3Pz5k0AKlasqHFExdvKlRAWBgMHQn515S/xSV1eTJgwgdDQUNPjzPljunTpkuOUJuXLJ+LqWgq9XkdaGqSnY/ppMJh/48nIcCQjA1JTC/5XVKqUgpcXeHmBt7eCt3fmffDyUp/z9YWyZRXKlfvnZ7lyj/7tQq/XExERQefOnWXI+9+kTizltU4yz6KLR2MwGLh37x4VKlTA19eXhIQE3Nzc7DqByQ2j0Uh6enqJqJPMEx03b96kQoUKcin2EezYof7s0CH/9lkkkrrLly/z559/kpycTPny5Xn88cdxdXUtlGP7+/tz48YNs203btzAy8vL6lk6AFdXV6vxOTs75/gPZ+rUA3Tv3t1qGYPBPMnL+tPatvR0SE2F5GT1lpRk+/2kJEhMhJQU9dhJSTqSkiA2FiB3p9NLlcKU4GXeKlaEgACoVEm9BQSo29xyOEn5sLoriaROLOW2Tgq7/vR6PXFxcaa2rEyZMoV6/IKSeRk7pysRouTI/Bzo9XpJ6vLozh04ckS937Fj/u1Xs6Tu0qVLLFmyhLVr13L16lUU5Z9LgC4uLjz99NO88cYbPP/88wX6zadly5Zs2bLFbFtERAQtW7bM3wMpCo6pqWpGZeUfjSPgDrg7A85Aqfw9vDXp6ZCQAPEJOuITdGb34+PV+wn3IT5ex527Ov66o+P2Xzpu/wW3/9Kh16vJYFIS/Pnnw49XpoxCJX+FgEpGKgcoVK+mUKWynptxpbhRL5mASk4lpi9hjvT6HD8rJVJ2deLhoXkH1Pv37/PVV1+xdu1aDh06RHp6OoqioNPpqFy5Ml26dOGNN97gySef1DTO/CB9qATI5yA/7N6tQ1Ggfn31xEd+0SSpe+uttwgPDyc4OJgPP/yQ5s2bU6lSJdzd3blz5w4nT55k7969TJ48mWnTprFy5UqbG8TExETOnz9vehwTE8Px48cpU6YMVatWZcKECVy7do3Vq1cDMGzYMBYtWsS7777L4MGD2blzJ9988w2bN2/O3zednEzPl17K330+Iheg3N+33FKA+3hym3Km2y3Kc4vyXKeS6XaNAK5TiVTcuXNHx507Ok6eypqkuwCdGDcZPEgikEtUJ4Za/EFdzlCP09TlDOW5lctziMWXM9BT6yCKmGzrJDFRPV2skblz5/LRRx/x2GOP0atXL/7zn/9Ybcu6dOlCixYtWLhwIbVq1dIsXlEyrVq1ijFjxnDv3j2bXxMYGMiYMWNyHDQo8m7nTvU/2gPjNB+ZJkldqVKluHjxImXLlrV4rkKFCnTo0IEOHTowZcoUtm3bxpUrV2xO6o4cOUL79u1NjzP7vg0cOJBVq1YRGxvL5cuXTc9Xr16dzZs38/bbb7NgwQIqV67M8uXLZTqTh9ABXtzHi/vUICbHsgpwDx9TgneNAC5TlRiqm25XqUwypTjF45zicYt9lOEv6nKGupyhIb/RmGM04jjeSJ8poZ3Dhw8TFRXF449bfmYBmjdvzuDBg1myZAmrVq1i7969ktSJAmUtGevXrx/du3fXLihhITJSPblhF0ldWFiYzWW7du2aq323a9fO7FLug6ytFtGuXTuOHTuWq+PkmocHP65dS3BwcInrJ6UDfP++NXjgOb1ez08//UT79sHExrkQ86eOizEOnDvvwOmzOs6cc+DSnzruKGX5mdb8TGuz11cPNNL4CSONnjDSOMjIk00MPDCYudjJrJOS+FnJTrZ1onEfr//7v/+zqZybmxvDhg0r4GiEsM7d3T3bPuKi8N244cGFCzocHaFdu3zeuaKx9u3bK3fv3rXYHh8fr7Rv377wA8qD+Ph4BVDi4+OzLZOenq5s2rRJSU9PL8TIij5b6iU5WVFOnFCUtWsVZfJkRenTR1GqVVMUsH577DFF6d9fUT77TFGOH1eUjIzCez/5QT4rlvJaJ7b8beaXkJAQJSEhwWJ7YmKiEhISUuDHf1Q51VVKSopy6tQpJSUlRTEYDMrdu3cVg8GgQZR5YzAYlBkzZiiBgYGKm5ub8sQTTyjr169XjEaj0rFjR6VLly6K0WhUFEVR/vrrLyUgIECZNGmSoiiKsmvXLgVQfvzxR6Vhw4aKq6ur0qJFC+W3334z2394eLhSv359xcXFRalWrZoye/ZssxiqVaumfPTRR0pISIhSunRppUqVKsqyZcvMyly+fFnp27ev4u3trfj6+irPPPOMEhMTY3p+4MCBSu/evZVPPvlE8ff3V8qUKaOMGDHC9HfRtm1bBfXiiOmmKIqycuVKxdvb27Sf8+fPK88884xSoUIFpVSpUkqzZs2UiIgIi3jnzZtntT6zfh5yIm2ZpfT0dGX48GMKKEqrVra/zta2TPOx17t37yY9Pd1ie2pqKnv37tUgIlHUuLvDE09Av34wbRp89506YeOdO7BzJ8yZA/37qx1OdTq4cAG+/BJGjIBGjcDHB7p1U8udOAFGo8ZvSNil8PBwUjKHlGeRkpJi6sMrtBEWFsbq1atZunQpv//+O2+//TavvfYaUVFRhIeHc/jwYT799FNA7WcdEBDA5MmTzfYxbtw45syZw+HDhylfvjy9evUyjQqOjo4mJCSEfv368dtvvzF16lQmTZpkcWVozpw5NGvWjGPHjjFixAiGDx/O2bNnAfVsdHBwMJ6enuzdu5f9+/dTunRpunbtavY/cteuXVy4cIFdu3YRHh7OqlWrTMfZuHEjlStXZvr06cTGxhKrTmlgITExke7duxMZGcmxY8fo2rUrvXr1MuuaJArOsWMVAMjlhUibaDb69ddffzXdP3XqFHFxcabHBoOBbdu2EZCfQ0KE3fH1hfbt1Vum+Hg4eBB+/lm9/fIL3L8P27apN4Dy5dUh5J06QXAwVK6sTfzCPiQkJKAoCoqicP/+fdyyzN1jMBjYsmULFSpU0DDCAqIo6mhkLeRi1HNaWhozZsxgx44dplkNatSowb59+1i2bBlff/01y5YtY8CAAcTFxbFlyxaOHTuGk5P5v8cpU6bQuXNnQE3gK1euzHfffceLL77IvHnzaNu2LRMnTsTBwYHatWtz6tQpPvnkEwYNGmTaR/fu3RkxYgQA7733HvPmzWPXrl3UqVOHdevWYTQaWb58uWl06cqVK/Hx8WH37t106dIFAF9fXxYtWoSjoyN169alR48eREZGMnToUMqUKYOjoyOenp74+/tnWydBQUEEBQWZHn/wwQd89913fP/994waNcqmehV5o9fDr7+WB9T/P/lNs6SuUaNG6HQ6dDodHazMvOfu7s7ChQs1iEwUZ97e0KWLegN1/r+TJ9Uzejt2wJ49cOsWrF2r3gCaNoXeveGZZ9QzgjJaX+SGj4+PqS2rXbu2xfM6nc7qCjTFXnKyOku5FnIx6vn8+fMkJyebErJM6enpNG7cGIC+ffvy3XffMXPmTJYsWWJ1MEvWaa7KlClDnTp1OH36NABnzpyxGFzXunVr5s+fj8FgMM3l9sQTT5ie1+l0+Pv7m1ZnOHHiBOfPn8fT09NsP6mpqVy4cMH0+PHHHzebG65ixYr89ttvNtVFpsTERKZOncrmzZuJjY0lIyODlJQUOVNXCA4d0pGc7ESZMgpNm+b/PxvNkrqYmBgURaFGjRocOnSI8uXLm55zcXGRmapFvnB0hKAg9fb22+rcfAcPqgne9u3q/eho9TZ5MgQGwrPPwiuvqMmeJHjiYXbt2oWiKHTo0IENGzaYTTjs4uJCtWrVqFSpkoYRlmyJiYkAbN682eLqT+Yk8snJyURHR+Po6Mgff/xRYLE8OPBJp9Nh/Ls/SGJiIk2bNmXNmjUWr8v6/zGnfdhq7NixREREMHv2bGrWrIm7uzsvvPCC1a5QIn9t367+U+nYUcHR0Y6SumrVqgHY/GHs0aMHy5cvl7XmxCNxcYGnn1Zv06bBjRvw44/wv/9BRITaV2/ePPVWu7aa3L36KtSsqXXkoqhq27YtoH5RrVq16kMnZh0xYgTTp0+nXLm8zBBZhHh4qGfMtDq2jerXr4+rqyuXL182/a4e9M477+Dg4MDWrVvp3r07PXr0sLiC9Msvv1C1alUA7t69y7lz56hXrx4AdevW5eDBg2bl9+/fT+3atW0+OdGkSRPWrVtHhQoVsl1u0hYuLi4YDIYcy+zfv59Bgwbx7LPPAmpCeenSpTwfU9guIkJtH7p0MQL5P6xB84EStoqKirLaCVmIR+HnB0OGwPffw+3bsHGjOiDD3R3OnYOpU6FWLXjqKVixQrsuRKLoq1atmk0z7X/11Vf2sSatTqdeAtXilotT6J6enowdO5a3336b8PBwLly4wNGjR1m4cCHh4eFs3ryZFStWsGbNGjp37sy4ceMYOHAgd+/eNdvP9OnTiYyM5OTJkwwaNIhy5crRp08fQJ0Pdc+ePXz44YecO3eO8PBwFi1axNixY22O89VXX6VcuXL07t2bvXv3EhMTw+7du3nrrbe4evWqzfsJDAwkKiqKa9eucfv2batlatWqxcaNGzl+/DgnTpzglVdeyfXZPpF7t29DdLT62e3cOfup1x5FsUnqhChopUqpl17XrlXP4K1erXZkdXRUL9MOGaIu5/LWW/D771pHK4orJYd5NEXB+OCDD5g0aRJhYWHUq1ePrl27snnzZgIDAxkyZAhTp06lSZMmAEybNg0/Pz+LeQVnzpzJ6NGjadq0KXFxcfzwww+4uLgA6lm2lStXsm7dOho0aMDkyZOZPn262SCJh/Hw8CAqKoqqVavy3HPPUa9ePYYMGUJqamquztxNnz6dS5cu8dhjj5ldts1q7ty5+Pr60qpVK3r16kVwcLDp/YuCs2MHKIqOatXiKbAeGXmfbaVwlS5dWrlw4YLWYVgl89TlXXGol7g4RZk1S53/Lut8eE8/rSgbNuT/PHjFoU4KW3GYp85WRbUts+d56h5F5jx11uZTzVTS6kTmqcubgQPV/x19+pwrsLZMztQJ8RB+fjBunHo5dvt2eO459ezd3r3w/PNQrx58/jmkpmodqRBCiKJIUdT/HwCNG98qsONIUieEjRwcoHNn2LABLl+GiRPVufL++APefBOqVYOPP5Z+d0IIIcz99hvExoK7u0K9en8V2HEkqRMiDypVgg8+UJO7+fOhalW4eRPGj4fHHoNPP5Uzd0LYg8z1xH18fLQORRRjP/2k/mzXTsHFpeAGpRSbpO4///mP2fxPQhQFpUvD6NFw/jysWgXVq6uDLEaPVkfNfvGFOgGyEJlee+21R5qyQghR/GSuaFRQo14zaTZP3YNOnTrF5cuXLSY/fOaZZwCYMGGCFmEJYRNnZxg4UJ3XbuVK9Sze1avwxhuwaJF6Ni/rcmbCfiUnJ1ttyzJXE1iyZIkWYQkhNJKQAFFR6v3gYCMFOL+19kndxYsXefbZZ/ntt9/Q6XSm4f6Z8z09bBJFIYoSZ2c1kRswAJYtUyc4/vVX6NBBHWDxySdQo4bWUYqCcOvWLUJCQti6davV56UtE6JkioiAjAz16k2tWhRoUqf55dfRo0dTvXp1bt68iYeHB7///jtRUVE0a9aM3bt3ax2eEHni5qZegv3jDxg1Sh0tu3Ej1K+vnsWT1Xjsz5gxY7h37x4HDx7E3d2dbdu2ER4eTq1atfj++++1Dk8IoZEff1R/9uxZ8MfSPKk7cOCAackcBwcHHBwc+Ne//kVYWBhvvfWW1uEJ8UjKloWFC+HECXXkbFqausZss2Zw6JDW0Yn8tHPnTubOnUuzZs1wcHCgWrVqvPbaa8yaNYuwsDCtwxNCaMBohC1b1Ps9ehT88TRP6gwGA56engCUK1eO69evA+qSO2fPntUyNCHyzeOPq6Of1qyBcuXU4e0tW0JoqEyBYi+SkpKoUKECAL6+vty6pc5F1bBhQ44ePaplaEIIjURHqzMjeHqqa44XNM2TugYNGnDixAkAWrRowaxZs9i/fz/Tp0+nhnQ+EnZEp1MHUpw+Da++qn6DmzcPGjeGI0e0jk48qjp16pi+iAYFBbFs2TKuXbvG0qVLqVixosbRCSG0kHnptUsX+HtVuQKleVI3ceJE00LC06dPJyYmhqeffpotW7awYMECjaMTIv+VKwdffaWekg8IUPvdtWwJM2fK9CfF2ejRo4mNjQVgypQpbN26lapVq/Lpp58yY8YMjaMT9qZdu3aMGTNG6zDEQ2zerP4sjEuvUARGvwYHB5vu16xZkzNnznDnzh18fX1NI2CFsEfduqkjY998E779FiZMUC/RhodrHZnIi9dee810v2nTpvz555+cOXOGqlWrUq5cOQ0jE/YkPT0dl8I45SMeWWysevkV1Pa+MGh+pm7w4MHcv3/fbFuZMmVITk5m8ODBGkUlROEoUwa++QZWrIBSpWD3bmjRwonff5eJtoub6dOnk5ycbHrs4eFBkyZNKFWqFNOnT9cwMnH//n1effVVSpUqRcWKFZk3b57Zma67d+8yYMAAfH198fDwoFu3bvyRZd6JVatW4ePjw48//kidOnXw8PDghRdeIDk5mfDwcGrUqEFgYCCjR482m7omMDCQDz74gJdffplSpUoREBDA4sWLzWK7d+8er7/+OuXLl8fLy4sOHTqYuiQBTJ06lUaNGrF8+XKqV6+Om5sbgwYNYs+ePSxYsACdTodOp+PSpUsMGjTI9DjrTWaS0EbmAIlmzcDfv3COqXlSFx4eTkpKisX2lJQUVq9erUFEQhQunQ5CQuDoUWjQAOLidEya1JpPP3VAKdjJx0U+mjZtGomJiRbbk5OTmTZtWp72uXjxYgIDA3Fzc6NFixYcymHI9MaNG2nWrBk+Pj6UKlWKRo0a8eWXX+bpuPYmNDSU/fv38/333xMREcHevXvNBq8MGjSII0eO8P3333PgwAEURaF79+7o9XpTmeTkZD799FPWrl3Ltm3b2L17N88++yxbtmzhxx9/ZOnSpXz++ed8++23Zsf+5JNPCAoK4tixY4wfP57Ro0cTERFher5v377cvHmTrVu3Eh0dTZMmTejYsSN37twxlTl//jwbNmxg48aNHD9+nAULFtCyZUuGDh1KbGwssbGxVKlShQULFpgex8bGMnr0aCpUqEDdunULsHZFdjIvvRbGVCaZNLv8mpCQgKIoKIrC/fv3cXNzMz1nMBjYsmWLaSSZECVB7drwyy/w+utG1q51YOxYOHYMli9X570TRZuiKFa7jJw4cSJPSxyuW7eO0NBQli5dSosWLZg/fz7BwcGcPXvWattYpkwZ3n//ferWrYuLiws//vgjISEhVKhQwaybS35RFO1Gbnt4qF+GbHH//n3Cw8P5+uuv6dixIwArV66kUqVKAPzxxx98//337N+/n1atWgGwZs0aqlSpwqZNm+jbty8Aer2eJUuW8NhjjwHwwgsv8OWXX3Ljxg08PDyoXLky7dq1Y9euXfTr1890/NatWzN+/HgAateuzf79+5k3bx6dO3dm3759HDp0iJs3b+Lq6grA7Nmz2bRpE99++y1vvPEGoF5yXb16NeXLlzft18XFBQ8PD/yznALy9vbG29sbUJP8ZcuWsWPHDrMyonCkpamTDkPh9acDDZM6Hx8f06nh2rVrWzyv0+ny/O1WiOKqVCkIDzdQuvRJVq1qyJo1Oi5dgu++gyztuShCMvv/ZrZlWRM7g8FAYmIiw4YNy/V+586dy9ChQwkJCQFg6dKlbN68mRUrVpiShKzatWtn9nj06NGEh4ezb9++AknqkpNBqyVsExPVvxVbXLx4Eb1eT/PmzU3bvL29qVOnDgCnT5/GycmJFi1amJ4vW7YsderU4fTp06ZtHh4epoQOwM/Pj8DAQEqXLm0a7Ofn58fNmzfNjt+yZUuLx/PnzwfUhD8xMZGyZcualUlJSeHChQumx9WqVTNL6B7m2LFj9O/fn0WLFtG6dWubXyfyz5496ufUzw+aNCm842qW1O3atQtFUejQoQMbNmww+ybr4uJCtWrVTN+khChJdDro2TOGF16oT79+TuzfD089pZ7Kl6soRc/8+fNRFIXBgwczbdo005kSUNuywMBAi3/sD5Oenk50dLTZmtcODg506tSJAwcOPPT1iqKwc+dOzp49y8cff5yrYwvrnJ2dzR7rdDqr2zITPFskJiZSsWJFq33efHx8TPdL2ZrBAnFxcTzzzDO8/vrrDBkyxObXify1aZP685lnwKEQO7ppltS1bdsWgJiYGKpWrSojXYV4QIcOCr/8op66v3hRnfbkxx9BvngXLQMHDgSgevXqtGrVyuIffV7cvn0bg8GAn5+f2XY/Pz/OnDmT7evi4+MJCAggLS0NR0dHPvvsMzp37my1bFpaGmlpaabHCQkJgHqZMWtfssxtiqJgNBpN63O7uyskJNiewOQnNzd1nkdbBAYG4uzszMGDB6lcuTKg1tO5c+d4+umnqVOnDhkZGRw4cMB0+fWvv/7i7Nmz1K1bF6PRaErUsiZsmfWQtU4yt2ctd+DAAYvHmftt1KgRcXFxODg4EBgYaBF71n0/mCw6OzuTkZFhtj01NZXevXtTp04dZs+enasEMzcy49Lr9Tg6OmZbLvNz9ODnyd4ZjfC//zkBOnr2zECv/+fzkdc6sbW8Jkndr7/+avb4t99+y7bsE088UdDhCFFk1a0LBw9C797w88/qUmMbN0LXrlpHJuCfRAigcePGpKSkWB34BeBVCNcqPT09OX78OImJiURGRhIaGkqNGjUsLs0ChIWFWe3isn37djw8PMy2OTk54e/vT2JiIul/L1ycmHjf4rWF5X4uD/3yyy8zbtw43NzcKFeuHDNnzsTBwQG9Xo+fnx/du3dn6NChzJ07l9KlSzNt2jQqVqxI+/btSUhIIDU1FUVRzH7faWlpGAwGs216vZ6MjAzTNqPRyP79+/nggw/o0aMHu3bt4ttvv2XdunUkJCTQvHlznnzySXr37s20adOoWbMmsbGxbN++nZ49e9K4cWOrxwEICAjgwIEDnDx5klKlSuHr68vIkSO5fPkymzZt4uLFi6ayvr6++ToNSnp6OikpKURFRZGRkfHQ8lkHhpQE5875cP16W9zcMkhL28qWLZbJdW7rJOvI+pxoktQ1atQInU5n9u3GGp1OZzY8XIiSqFw5tcNt377qEPleveDLL+Gll7SOTGT2Dc5J5gCK3LRl5cqVw9HRkRs3bphtv3HjRo6d3h0cHKhZsyagtrOnT58mLCzMalI3YcIEQkNDTY8TEhKoUqUKXbp0sUhAU1NTuXLlCqVLl8bV1ZX79+/j6elZbK6wfPrppwwfPpyXXnoJLy8vxo0bR1xcHF5eXnh5ebF69WrGjBnDyy+/THp6umkC/My+bm5ubuh0OrN6cXV1xdHRES8vL9OAP2dnZ5ycnEzlHBwceOeddzh58iSzZs3Cy8uLOXPm8Oyzz5r2s23bNiZOnMi///1vbt26hb+/P08//TQ1atTAy8vL7DhZjR8/npCQEJ566ilTH7wDBw4QFxfHU089ZVY2MjLS6mcgr1JTU3F3d6dNmzZmgxwfpNfriYiIoHPnzvlyBru4OHBAvd7ao4cDffqYfwPPa508mNRnR5OkLiYmRovDClFseXiofTQGDYKvv1aXG7t/H4YO1Tqykm3Xrl0Fsl8XFxeaNm1KZGQkffr0AdSzPpGRkYwaNcrm/RiNRrNLrFm5urqaRlxm5ezsbPHPxmAwoNPpcHBwMCVymY+LA29vb77++mvT46SkJKZPn84bb7yBg4MDZcuWzXH6l8GDB1vMmzpt2jTTmc7My5wrV660qBNvb2/Wr1+fY2wLFy5k4cKFVp/Pepys6tata9G/8tKlS9keJz9lfg6sfVassbWcvfjhB/Xnc8854Oxs/W8kt3Via1lNkrpq1appcVghijVnZ/UMna8vLF4Mb7yhdsCVvtDayewbXBBCQ0MZOHAgzZo1o3nz5syfP5+kpCTTaNgBAwYQEBBAWFgYoF5ObdasGY899hhpaWls2bKFL7/8kiVLlhRYjMXFsWPHOHPmDM2bNyc+Pt40GXTv3r01jkzYm3Pn4NQpcHKC7t0L//iaLxMG8OWXX7J06VJiYmI4cOAA1apVY/78+VSvXl3+6ITIwsEBFi5UG4wFC9QzdY6O6hk8ob29e/eybNkyLl68yPr16wkICODLL7+kevXq/Otf/8rVvvr168etW7eYPHkycXFxNGrUiG3btpkGT1y+fNnsrFBSUhIjRozg6tWruLu7U7duXb766iuzOdNKstmzZ3P27FnTWdC9e/fK8m0i3/3vf+rP9u0hywDmQqN5UrdkyRImT57MmDFj+Oijj0z9Tnx8fJg/f74kdUI8QKeDefPAYIBFi2DwYDWx699f68hKtg0bNtC/f39effVVjh49arrsGR8fz4wZM9iSuWZQLowaNSrby60PToPx4Ycf8uGHH+b6GCVB48aNic5chLMQFdblUFF0ZE5l8neviUKneYeIhQsX8sUXX/D++++bDY1u1qxZjqNihSjJdDr49FMYPlyd2X/QoH++IQptfPjhhyxdupQvvvjCrP9L69atzZakEkLYp7g4yOzm+Mwz2sSgeVIXExND48aNLba7urqSpNUaNEIUAzqdeqZuyBB1XqSXXoK9e7WOquQ6e/Ysbdq0sdju7e3NvXv3Cj8gIUSh+uEH9Uv2k0/C31MiFjrNk7rq1atz/Phxi+3btm2jXr16hR+QEMWIgwMsXap+K0xNVac7kRPc2vD39+f8+fMW2/ft20eNGjU0iCj/PWwaKlEyyOfAuo0b1Z9a9hrTvE9daGgoI0eONE3ueOjQIf7v//6PsLAwli9frnV4QhR5Tk6wdi106QL79kFwsDpRsZUJ6kUBGjp0KKNHj2bFihXodDquX7/OgQMHGDt2LJMmTdI6vEeSeTk5OTnZ6jQoomTJnAi3JE1T8jB37sCOHer955/XLg7Nk7rXX38dd3d3Jk6cSHJyMq+88gqVKlViwYIFvJTH2VUXL17MJ598QlxcHEFBQSxcuNBsMees9Ho9YWFhhIeHc+3aNerUqcPHH39MV5myXxQj7u7w/ffw9NPw++/qGbuffwZPT60jKznGjx+P0WikY8eOJCcn06ZNG1xdXRk7diz//ve/tQ7vkTg6OuLj48PNmzdNy2alpqYWm3nqCprRaCQ9Pd3u60RRFJKTk7l58yY+Pj45LhFW0vzvf5CRAQ0bartGt+ZJHcCrr77Kq6++SnJyMomJiVSoUCHP+1q3bh2hoaEsXbqUFi1aMH/+fIKDgzl79qzV/U6cOJGvvvqKL774grp16/LTTz/x7LPP8vPPP1vt6ydEUeXrC9u2QfPmcPKkOkHxpk3qyFhR8HQ6He+//z7jxo3j/PnzJCYmUr9+fUqXLq11aPkicyWLW7dukZKSgru7e7FZUaKgKYpSourEx8cnx5VNSqLM+aX79tU2jiKR1GXy8PCwWHMwt+bOncvQoUNNE3QuXbqUzZs3s2LFCsaPH29R/ssvv+T999+n+9+zBA4fPpwdO3YwZ84cvvrqq0eKRYjCVrmymsi1bQs//gjjx8Mnn2gdVcni4uJC/fr1tQ4j3+l0OipWrIivry+RkZG0adNGLr/9Ta/XExUVVSLqxNnZWc7QPeDu3X8uvZbIpK5x48Y2f5vJzVQA6enpREdHM2HCBNM2BwcHOnXqZLGcSqa0tDSLtevc3d3Zt29ftsdJS0szW3onc002vV6PXq+3+prM7dk9X1JJvVh61Dpp3Bi++EJH//5OzJ4NdepkMHBg8e7YnNc6KejP1XPPPWdz2Y2ZvaiLOUdHRzIyMnBzc7P7BMZWUicl2//+B3q99pdeQaOkrk+WWflSU1P57LPPqF+/Pi1btgTgl19+4ffff2fEiBG52u/t27cxGAymGdcz+fn5cebMGauvCQ4OZu7cubRp04bHHnuMyMhINm7cmOPi22FhYVbX4tu+fftDzzRGRETY8E5KHqkXS49SJ56e8OKLdfnmmzoMH64jPn4/NWvey7/gNJLbOsns0F1QvL29TfcVReG7777D29ubZs2aARAdHc29e/dylfwJIYqXb75Rf2p9lg40SuqmTJliuv/666/z1ltv8cEHH1iUuXLlSoHHsmDBAoYOHUrdunXR6XQ89thjhISEsGLFimxfM2HCBEJDQ02PExISqFKlCl26dMHLy8vqa/R6PREREXTu3Fm+yWUh9WIpv+qka1dISTHyww+OLFzYhoMHMyhTJh8DLUR5rZPMs+gFZeXKlab77733Hi+++CJLly41XZ4yGAyMGDEi23ZBCFG8FaVLr1AE+tStX7+eI0eOWGx/7bXXaNasWY7J1YPKlSuHo6MjN27cMNt+48aNbDt1li9fnk2bNpGamspff/1FpUqVGD9+fI7zSrm6ulod1u/s7PzQfzi2lCmJpF4s5UedrF4NzZrBhQs6Xn/dmf/9T53brrjKbZ0U5mdqxYoV7Nu3z6y/kaOjI6GhobRq1YpPpHOjEHYn89JrgwbaX3qFIjD5sLu7O/v377fYvn//fou+bg+TuVBzZGSkaZvRaCQyMtJ0aTc7bm5uBAQEkJGRwYYNG2TNWWEXfHzg22/B1VUdODFrltYR2a+MjAyr3TzOnDmD0WjUICIhREHLHPX64ovaxpFJ8zN1Y8aMYfjw4Rw9etQ0l9zBgwdZsWJFnibsDA0NZeDAgTRr1ozmzZszf/58kpKSTKNhBwwYQEBAAGFhYaZjXbt2jUaNGnHt2jWmTp2K0Wjk3Xffzb83KYSGGjWCxYvh9dfh/fehZUt1dKzIXyEhIQwZMoQLFy6YtWUzZ840tT9CCPtx9y5kdvMtCpdeoQgkdZmXOhcsWGCaQqRevXqsXLmSF/OQ+vbr149bt24xefJk4uLiaNSoEdu2bTMNnrh8+bLZ5JCpqalMnDiRixcvUrp0abp3786XX36Jj49Pvrw/IYqCwYPVdWHDw6F/f/j1V/Usnsg/s2fPxt/fnzlz5hAbGwtAxYoVGTduHO+8847G0Qkh8tuGDUVn1GsmzZM6gBdffDFPCVx2Ro0axahRo6w+t3v3brPHbdu25dSpU/l2bCGKIp0OFi2C/fvh/HkYORLWrNE6Kvvi4ODAu+++y7vvvmsaoCEDJISwX5lt6KuvahtHVpr3qRNCFI7SpeGrr9QVJr7+Wr2JguHl5SUJnRB27OpV2LNHvf/yy9rGklWRSup69OhhumwhhMh/LVrA5Mnq/REj4M8/tY3HXo0YMYLbt29rHYYQooD83/+BokCbNlC1qtbR/KNIJXVRUVGkpKRoHYYQdu0//4GnnoL4eBg4EGRgZv776quvCnyOPCGEdoripVcoYkmdEKLgOTmpl2FLlVIvH3z+udYR2R9FKd7Lsgkhsvf773DiBDg7wwsvaB2NuSKX1Nm6JqwQIu8eewz+ntWHd9+FQli8pcSRtkwI+5R5lq57d4rcKj2ajn51cHCwaPhq1qwJqN90dTpdjmuwCiHybsQIWLsWfv4Zhg1TJyeWPCRvqlevbtaWpaSk0LZtW5yc/mliL168qEVoQoh8ZDT+M8isqF16BY2TupiYGNN9RVFo0KABW7ZsoVq1ahpGJUTJ4OgIy5erkxNv2aI2VEWxkSoOVq1aZbqvKArdu3dn5syZBAQEaBeUECLf/fyzOsDM0xN69tQ6GkuaJnUPJm86nY7KlStLUidEIalXTx0NO3EijB4NnTtDhQpaR1X8tH1giQ5HR0eeeuqpHNeQFkIUP3+vkcDzz4O7u7axWFPk+tQJIQrXu+9CUBD89Re8957W0dgH6U8nhP1JTlanMgF1ZZ6iqEglddWqVcPZ2VnrMIQoUZydYelS9f6qVerlBfFoZPSrEPbnu+8gIQECA6FdO62jsa5IJXUnT56kSpUqWochRInz1FPq+rCgLiEm45Mezf379+XSqxB2ZuVK9WdICDgUqezpH5qHFRUVRUZGhsX2jIwMoqKiNIhIiJJp5kzw8YHjx/85cydsd/nyZatn6BRF4fLlyxpEJITIL5cuQWSkOkPAwIFaR5M9zZO69u3bc+fOHYvt8fHxtG/fXoOIhCiZypeHjz5S70+cCLduaRtPcVO9enVuWam0O3fuUL16dQ0iEkLkl/Bw9WeHDlCUx3JqntRlzkf3oL/++otSpUppEJEQJdebb0LjxnDvHowfr3U0xUt2bVliYiJubm4aRCSEyA9G4z+XXjO7qRRVmk1p8txzzwHqKLFBgwbh6upqes5gMPDrr7/SqlUrrcITokRydITFi6FVK7UR+/e/1XnsRPZCQ0MBtS2bNGkSHh4epucMBgMHDx6kkVSiEMXW7t3q3HTe3vDss1pHkzPNkjpvb29A/Xbr6emJe5YJX1xcXHjqqacYOnSoVuEJUWK1bAkvvaSuNjFuHGzfLitN5OTYsWOA2pb99ttvuLi4mJ5zcXEhKCiIsWPHahWeEOIRrVih/nz55aI5N11WmiV1K/8+lxkYGMjYsWPlUqsQRciMGbBxI+zYAT/9BF27ah1R0bVr1y4AQkJCWLBgAV5eXhpHJITIL/fuwYYN6v2QEE1DsYnmfeqmTJkiCZ0QRUz16uqlV4CxY8HKAHXxgJUrV0pCJ4SdWb0aUlOhQQN48kmto3k4zZM6IUTR9P774OsLv/+uTkoshBAliaL8M73T8OHFoxuKJHVCCKt8fdV1YQEmTYLERG3jEUKIwrRnD5w+DaVKwWuvaR2NbSSpE0Jka8QIqFED4uJg4UKtoxFCiMKTeZbu1VehuPSskKROCJEtFxeYPl29/8knEB+vbTxCCFEYbtxQB4sBDBumbSy5UaSTutWrV3PhwgWtwxCiRHvpJahXD+7ehfnztY6meIqKiiI+Dxnx4sWLCQwMxM3NjRYtWnDo0KFsy37xxRc8/fTT+Pr64uvrS6dOnXIsL4TI3n//C3o9tGihTsheXBTppG7QoEHUr1+ff2cOwxNCFDpHR5g6Vb0/dy5YWdVPPES7du2oUaMGc+bMsfk169atIzQ0lClTpnD06FGCgoIIDg7m5s2bVsvv3r2bl19+mV27dnHgwAGqVKlCly5duHbtWn69DSFKBIMBPv9cvT98uLax5FaRTuqMRiNnzpyhXr16WociRIn2wgvwxBOQkAC5yEvE32JiYvj222+5ceOGza+ZO3cuQ4cOJSQkhPr167N06VI8PDxYkTkT6gPWrFnDiBEjaNSoEXXr1mX58uUYjUYiIyPz620IUSJs26auIOHrCy++qHU0uVOkkzpQF8keMWKE1mEIUaI5OMC0aer9BQvAyrr1IgfVqlWjffv2zJo1y6by6enpREdH06lTJ9M2BwcHOnXqxIEDB2zaR3JyMnq9njJlyuQpZiFKqsxBYYMGFf0VJB6k2YoSmRwdHYmNjaVChQpm2//66y8qVKiAwWDQKDIhRFa9e0PTphAdDbNmqQMnxD9q1KjB4cOHKVu2rNn2e/fu0aRJEy5evGjzvm7fvo3BYMDPz89su5+fH2fOnLFpH++99x6VKlUySwyzSktLIy0tzfQ4ISEBAL1ej16vz3a/mc/lVKakkTqxrjjWy6lT8NNPzuh0Cm+8kUF+h57XOrG1vOZJnaIoVrenpaWZraEohNCWTqeOhO3RA5YsgfHj4YH8pUS7dOmS1S+haWlphd6vbebMmaxdu5bdu3fj5uZmtUxYWBjTMk+/ZrF9+3Y8PDweeoyIiIhHjtPeSJ1YV5zq5bPPgoBAmjeP4+zZQ5w9WzDHyW2dJCcn21ROs6Tu008/BUCn07F8+XJKly5tes5gMBAVFUXdunW1Ck8IYUW3bupIsGPH1EsUmQMoSrLvv//edP+nn37C29vb9NhgMBAZGUlgYGCu9lmuXDkcHR0t+uDduHEDf3//HF87e/ZsZs6cyY4dO3jiiSeyLTdhwgRCQ0NNjxMSEkyDK3Ja7kyv1xMREUHnzp1xdna28R3ZN6kT64pbvdy+DS+9pKZFH31UnjZtuuf7MfJaJ5ln0h9Gs6Ru3rx5gHqmbunSpTg6Opqec3FxITAwkKWZM/8JIYoEnU49Q9evH3z6KbzzDnh6ah2Vtvr06QOoX1AHDhxo9pyzszOBgYG5GvUKahvYtGlTIiMjTfvPHPQwatSobF83a9YsPvroI3766SeaNWuW4zFcXV1xdXW12O7s7GzTPxtby5UkUifWFZd6WblSXee1cWPo0MGpQJcFy22d2FpWs6QuJiYGgPbt27Nx40Z8fX21CkUIkQvPPw+1asEff6jD/t95R+uItGU0GgF1UNfhw4cpV65cvuw3NDSUgQMH0qxZM5o3b878+fNJSkoiJCQEgAEDBhAQEEBYWBgAH3/8MZMnT+brr78mMDCQuLg4AEqXLm12JUQIYSk9HRYtUu+PGVM81nm1RvPRr7t27ZKETohixNER3ntPvT93LmTpa1+ixcTE5FtCB9CvXz9mz57N5MmTadSoEcePH2fbtm2mwROXL18mNjbWVH7JkiWkp6fzwgsvULFiRdNt9uzZ+RaTEPZq/XqIjQV/f3XC9eJKk6Ru5syZNnf6O3jwIJs3by7giIQQudG/PwQEwPXrsHq11tFoZ+3atTaXvXLlCvv378/V/keNGsWff/5JWloaBw8epEWLFqbndu/ezapVq0yPL126hKIoFrep0vFRiBwpCvzdI4yRI9XlEYsrTZK6U6dOUa1aNUaMGMHWrVu5lWXSq4yMDH799Vc+++wzWrVqRb9+/fAs6Z12hChiXFz+uez68ceQkaFtPFpZsmQJ9erVY9asWZw+fdri+fj4eLZs2cIrr7xCkyZN+OuvvzSIUgiRk5071ama3NzgzTe1jubRaJLUrV69mh07dqDX63nllVfw9/fHxcUFT09PXF1dady4MStWrGDAgAGcOXOGNm3aaBGmECIHQ4eqU5pcuADffad1NNrYs2cPH3/8MRERETRo0AAvLy9q1apFw4YNqVy5MmXLlmXw4MFUrVqVkydP8swzz2gdshDiAX93S2XIEChfXttYHpVmAyWCgoL44osvWLZsGb/++it//vknKSkplCtXjkaNGuVr3xQhRP4rXVpdF/HDD2H+fOjbV+uItPHMM8/wzDPPcPv2bfbt22fWljVu3JjGjRvj4KB592UhhBWHD0NkJDg5wbhxWkfz6DSffNjBwYFGjRrRqFEjrUMRQuTSiBHq5deff4ZDh6B5c60j0k65cuVM048IIYqHzLN0r7wC1appG0t+sMuvj4sXLyYwMBA3NzdatGjBoUOHciw/f/586tSpg7u7O1WqVOHtt98mNTW1kKIVoviqWPGfkWKZHY2FEKI4OHXqn64jmSP6i7sildQNHz7cbNBEXqxbt47Q0FCmTJnC0aNHCQoKIjg4mJs3b1ot//XXXzN+/HimTJnC6dOn+e9//8u6dev4z3/+80hxCFFSjBmj/ly/Hq5e1TSUImPmzJncu3dP6zCEEDn4+GP157PPQv362saSX4pMUnfr1i0+//xzfvvtt0faz9y5cxk6dCghISHUr1+fpUuX4uHhwYoVK6yW//nnn2ndujWvvPIKgYGBdOnShZdffvmhZ/eEEKomTaBNGzAY/pm8syS7f/8+EydOtDoaVghRNPz5J3z9tXp/wgRtY8lPmvSpu3PnDqtXr+batWsYDAbS0tLYuXMnjz/+OK+99ho9e/akdOnSODo6UrFiRdMI2YdJT08nOjqaCVl+Qw4ODnTq1IkDBw5YfU2rVq346quvOHToEM2bN+fixYts2bKF/v37Z3uctLQ00rLMuJq5Jpter0ev11t9Teb27J4vqaReLBXHOvn3v3VERTnx+ecK48dnUKpU/u4/r3VS0HWYnp7Oli1bzNqyzZs3ExAQwNChQ3nllVfM2rLu3bvj5uZWoDEJIR5u5kx1KqaOHeHJJ7WOJv9oktS98sorHDx4kMcff9y0/lnHjh2ZPn06n376Kb/88gtpaWkYDAbOnTvHZ599xvnz5x+639u3b2MwGEwzrmfy8/PjzJkz2cZy+/Zt/vWvf6EoChkZGQwbNizHy69hYWFMmzbNYvv27dvx8PDIMcaIiIiHvo+SSOrFUnGqEwcH8PPrxI0bpRg//hTdul0qkOPktk5sneQ8rwYMGMC3336Lv7+/qS2rXbs2u3btYvr06axevdrUlt24cYOGDRty5MiRAo1JCJGzS5fgv/9V70+erGko+U6TpO7AgQNERETQ3MpQuQdnP799+zYVKlTg5s2bVKhQId9j2b17NzNmzOCzzz6jRYsWnD9/ntGjR/PBBx8wadIkq6+ZMGECoaGhpscJCQlUqVKFLl264OXlZfU1er2eiIgIOnfuXCwWNi4sUi+WimudXLrkwDvvwJ49T/Dpp/Xzde3EvNZJ5ln0grJ9+3a2bt1K586dLZ7LutoDwIULF6hduzZ37tyhTJkyBRqXECJ7H3wAej106qR2HbEnmiR1TZs2pXbt2jaVLVeuHF27djUtmv2wso6Ojty4ccNs+40bN7K9fDtp0iT69+/P66+/DkDDhg1JSkrijTfe4P3337c6v5Srqyuurq4W2zO/qefEljIlkdSLpeJWJ0OGwKRJcOaMjl9+cS6QxjK3dVLQ9efr62vzdEyPPfYYderUITk5WZI6ITRy/jyEh6v3P/hA21gKgiYDJXbu3ImPj4/N5bds2WJTnzoXFxeaNm1KZGSkaZvRaCQyMpKWLVtafU1ycrJF4ubo6AiAoig2xyhESeftrc71BLBkibaxFJYLFy5QPhdT0J86dYrKlSsXYERCiJxMm6YO6ureHZ56Suto8l+RGf2aX0JDQ/niiy8IDw/n9OnTDB8+nKSkJEJCQgC1D0zWgRS9evViyZIlrF27lpiYGCIiIpg0aRK9evUyJXdCCNsMG6b+3LABsplFSAghNHH6NKxZo96fPl3bWAqK5itKZCcpKYno6Ohcr/var18/bt26xeTJk4mLi6NRo0Zs27bNNHji8uXLZmfmJk6ciE6nY+LEiVy7do3y5cvTq1cvPvroo3x9P0KUBE2bqiPJDh+GFStg/HitIxJCCNXUqaAo0Lu32lbZoyJ7pu78+fO0b98+T68dNWoUf/75J2lpaRw8eJAWLVqYntu9e7dZB2YnJyemTJnC+fPnSUlJ4fLlyyxevDhXl4eFEP8YPlz9uWwZ2NAVttjT6/W8++671KxZk+bNm1vMiXnjxg056y+Exo4cgW++Ue9bmbzCbhTZpE4IUTz16wc+Puq0AT/9pHU0Be+jjz5i9erVDBs2jC5duhAaGsqbb75pVkb65wqhHUWBsWPV+/37Q1CQtvEUJM0uvz5s9JfBYCikSIQQ+cnDAwYOhAULYOlS6NZN64gK1po1a1i+fDk9e/YEYNCgQXTr1o2QkBDTWTtdfs7vIoTIlR9+gD17wM0NPvxQ62gKlmZJXVpaGsOHD6dhw4ZWn//zzz+tTvArhCj6hg1Tk7off4QrV6BKFa0jKjjXrl2jQYMGpsc1a9Zk9+7ddOjQgf79+zNr1iwNoxOiZNPr4d131ftjxkDVqpqGU+A0S+oaNWpElSpVGDhwoNXnT5w4IUmdEMVU3brQtq367Tg8HCZO1DqiguPv78+FCxcIDAw0bQsICGDXrl20b9+eQYMGaRabECXd8uVw9iyUK1cyBm5p1qeuR48e3Lt3L9vny5Qpw4ABAwovICFEvho8WP25apXap8VedejQga8zVwbPolKlSuzcuZOYmBgNohJCJCTAlCnq/alT1bk07Z1mZ+pyWlsVoEqVKqxcubKQohFC5Lfnn4dRo+DCBdi71/6W48k0adKkbNeWDggIYM+ePcVqHV8h7MWHH8KtW1C7NrzxhtbRFA4Z/SqEKBClSqkjYUGds85eVatWjeDg4Gyfr1SpUrbdTIQQBeP0aZg3T70/dy4UoxUXH0mRSOquXr1qWts1630hRPH290IurF8P9+9rG0thkLZMCO0pCvz735CRAb16QY8eWkdUeIpEUle/fn0uXbpkcV8IUby1bAl16kBy8j8Tf9ozacuE0N6330JkJLi6wvz5WkdTuIpEUpd1Yk6ZpFMI+6HT/XO2riR0kZW2TAhtJSbC22+r98ePhxo1tI2nsBWJpE4IYb8GDABHR9i/X51aQAghCsqHH8K1a1C9Orz3ntbRFD5J6oQQBapiRejaVb2fZdllIYTIV8ePw5w56v3588HdXctotCFJnRCiwGVegl2zBmTsgBAiv2VkwJAh6s/nnoNnntE6Im1IUieEKHA9eqgTf165Avv2aR2NEMLezJ0LR4+Cjw8sXqx1NNqRpE4IUeDc3NTJiEE9WyeEEPnl3Ll/Vo6YNw/8/bWNR0uS1AkhCsWrr6o/16+H9HRtYxFC2AejEYYOhdRU6NIFSvo830UiqfvPf/5DmTJlLO4LIexH27ZQqRLcvQtbt2odTcGQtkyIwrVoEURFqSvYLFumTqNUkhWJpG7ChAn4+PhY3BdC2A9HR3j5ZfW+vV6ClbZMiMLz++/w7rvq/VmzIDBQ03CKhCKR1AkhSobMS7A//AAJCdrGIoQovtLS1PYkLQ26d4fhw7WOqGhw0uKgzz33HKtWrcLLy4vnnnsux7KlS5fm8ccfZ9iwYXh7exdShEKIgtCoEdSrpy62vXEjDBqkdUSPRtoyIbQxcSKcOAHly8OKFXLZNZMmZ+q8vb3R/f0b8Pb2zvGWkZHB0qVL6d+/vxahCiHykU73z9k6e7gEK22ZEIVv585/Jhlevhz8/LSNpyjR5EzdyiyLQK60YUHIU6dO8eSTTxZkSEKIQvLKK+q37J07ITZWXXGiuJK2TIjCdfMm9O8PigJvvFFyJxnOTrHoU1enTh1+/vlnrcMQQuSD6tXhqafUqQg2btQ6msKV27Zs8eLFBAYG4ubmRosWLTh06FC2ZX///Xeef/55AgMD0el0zJ8/Px8iFqLoMBjUwVbXr6vdOObO1TqioqdIJ3WDBw/myy+/xNHRkaCgIK3DEULkk7591Z/r12sbR2HJS1u2bt06QkNDmTJlCkePHiUoKIjg4GBu3rxptXxycjI1atRg5syZ+Jfk2VeF3Zo6VT3DX6oUbNig/hTminRSd/HiRSZNmkSjRo20DkUIkY9eeEH9GRWlXoK1d3lpy+bOncvQoUMJCQmhfv36LF26FA8PD1asWGG1/JNPPsknn3zCSy+9hKuraz5FLkTRsHUrfPihen/5cvVMnbBUpJO63bt3c+nSJb7++mutQxFC5KOqVaFFC7VfTEm4BJvbtiw9PZ3o6Gg6depk2ubg4ECnTp04cOBAQYUpRJEUEwOvvabeHzECXnpJ23iKMk0GSuRW/fr1tQ5BCJHP+vaFgwfVS7AjR2odTeGwtS27ffs2BoMBvweG9fn5+XHmzJl8iSUtLY20tDTT44S/Jw7U6/Xo9fpsX5f5XE5lShqpE+vyo14SEqBnTyfu3NHRrJmRjz82UJyrOa91Ymv5IpvU3b17lx9++IEBAwZoHYoQogC88AKMHatego2Ls99FuItqWxYWFsa0adMstm/fvh0PD4+Hvj4iIqIgwirWpE6sy2u9GAwwY0YLTp3yx9c3leHD9xAZmZrP0Wkjt3WSnJxsU7kim9RdvnyZkJCQItcQCiHyR7Vq6iXYgwfVTs/2erYuL21ZuXLlcHR05MaNG2bbb9y4kW+DICZMmEBoaKjpcUJCAlWqVKFLly54eXll+zq9Xk9ERASdO3fG2dk5X2Ip7qROrHvUennvPQeiox1xc1PYvNmJZs06FECUhSuvdZJg4xI8miV1Dwvw/v37hRRJ4TAajTg5OZGamorBYNA6nCJDr9eXmHpxcXHBwaFId2MtdPZwCbYg2jIXFxeaNm1KZGQkffr0AdQ2JDIyklGjRuUlTAuurq5WB1Q4Ozvb9M/G1nIlidSJdXmpl+XLYd489f6qVTpatiyy56DyJLd1YmtZzWrJx8fHNBO7NYqi5Ph8cZKenk5MTAz+/v5cuXLFbt5XflAUpcTUi4ODA9WrV8fFxUXrUIoMe7gEW1BtWWhoKAMHDqRZs2Y0b96c+fPnk5SUREhICAADBgwgICCAsLAwQG1nTp06Zbp/7do1jh8/TunSpalZs2Ye3pkQ2vjxRxg2TL0/eTL066dtPMWJZkmdp6cn77//Pi1atLD6/B9//MGbb75ZyFHlP0VRiI2NxdHRkcqVK+Pp6Slna7IwGo0kJiZSunRpu64Xo9HI9evXiY2NpWrVqnafwNqqWjVo3hwOHVJHwY4YoXVEuVdQbVm/fv24desWkydPJi4ujkaNGrFt2zbT4InLly+b/c1cv36dxo0bmx7Pnj2b2bNn07ZtW3bv3p3r4wuhhZ9/hhdfVPvTDRyozk0nbKdZUtekSRMA2rZta/V5Hx8fFEUpzJAKREZGBsnJyVT8ey0kNzc3u05ecstoNJKenl4i6qV8+fJcv36djIwMuUSTRd++xTupK8i2bNSoUdlebn0wUQsMDLSLNlOUXKdOQc+ekJIC3bvDF1+o60UL22n2X/SVV17Bzc0t2+f9/f2ZMmVKIUZUMDL7ick/cZF52dXe+w7m1t9dxti9G+7e1TKSvCkpbZkQBSkmBoKD1Tbgqafgm29A/m3mnmZn6oYOHZrj835+fnbVEMrlNiGfAetq1oQGDeDkSdi8+Z9JRouLktaWCZHfLl2C9u3h6lV1pYgff5QlwPLKvq93CfEIVq1ahY+PT65eExgYKAup50Hm2bpNm7SMQghR2C5fVhO6P/+EWrVgxw4oW1brqIqvIpHU7d+/3zSzedb7QhQWa8lYv379OHfunDYBlTC9e6s/t22D1GI8t6i0ZULY7soVNaG7dEk9Y79rF1SqpHVUxVuRSOq6devGtWvXLO7n1eLFiwkMDMTNzY0WLVpw6NChbMu2a9cOnU5ncevRo8cjxSCKP3d3dypUqKB1GCVC06YQEABJSRAZqXU0eZffbZkQ9uqPP+Dpp+HiRXjsMTWhCwjQOqrir0gkdVlHbD3q6K1169YRGhrKlClTOHr0KEFBQQQHB3Pz5k2r5Tdu3EhsbKzpdvLkSRwdHenbt+8jxWEPjEYjYWFhVK9eHXd3d4KCgvj2229RFIVOnToRHBxs+n3duXOHypUrM3nyZEAdmafT6di8eTNPPPEEbm5uPPXUU5w8edLsGBs2bKBly5a4u7sTGBjInDlzzJ4PDAxkxowZDB48GE9PT6pWrcrnn39uVubKlSu8+OKL+Pj4UKZMGXr37s2lS5dMzw8aNIg+ffowe/ZsKlasSNmyZRk5cqRpLb127drx559/8vbbb5uSerC8/HrhwgV69+6Nn58fpUuX5sknn2THjh35UtclnU5nH5dg87MtE8JeHT8O//rXP5dcd+6EypW1jso+FImkLj/NnTuXoUOHEhISQv369Vm6dCkeHh6sWLHCavkyZcrg7+9vukVERODh4VFwSZ2iqKcjtLjl8p9MWFgYq1evZunSpfz++++8/fbbvPbaa0RFRREeHs7hw4f59NNPARg2bBgBAQGmpC7TuHHjmDNnDocPH6Z8+fL06tXLlExFR0fz0ksv8dxzz3HixAmmTp3KpEmTWLVqldk+5syZQ7NmzTh27BgjRoxg+PDhnD17FlBXpAgODsbT05O9e/eyf/9+SpcuTdeuXUlPTzftY9euXVy4cIFdu3YRHh7OqlWrTMfZuHEjlStXZvr06abk3prExES6d+9OZGQkx44do2vXrvTq1YvLly/nql6FdZlJ3fffq3NUCSHsz7590K4d3LwJjRqpj6tW1Toq+2FX626kp6cTHR3NhAkTTNscHBzo1KkTBw4csGkf//3vf3nppZcolcPQm7S0NLO+MpnLBOn1elPCkkmv16Moiulbu5KUBN7eNr+n/GRMSLB5SFFaWhozZsxg+/bttGzZElDPmu3du5elS5eyZs0alixZwqBBg4iNjWXLli1ER0fj4OCA0WjEaDQCMGnSJDp27AjAypUrqVq1Khs2bODFF19kzpw5dOjQgXHjxuHp6Unt2rX5/fff+eSTT8zWyezWrRvD/p5efNy4ccybN4/IyEhq1arF//3f/2E0Gvn8889NZ9j++9//UqZMGXbu3EmXLl1QFAVfX18+/fRTHB0dqV27Nt27d2fHjh0MGTIEHx8fHB0dKV26tOlya9b3kPmzYcOGNGzY0BTXtGnT+O677/jf//7HyCxrXCmKYnqNWf0bjSiKgl6vx9HRMdu6z/wMPfhZsnetWoG3txM3b+rYty+DVq3++RKS1zopaXUoRFH27bfQv7/ab/bpp+GHHzT7d2i37Cqpu337NgaDwTTjeiY/Pz/OnDnz0NcfOnSIkydP8t///jfHcmFhYUybNs1i+/bt2/Hw8DDb5uTkhL+/P0lJSbi4uHD//n18Hv5WCkRCQoLNp0BOnz5NcnIywcHBZtvT09N54oknSEhIIDg4mB49evDxxx8zZ84c/Pz8TAlucnIyAA0aNDBtc3JyombNmpw4cYKuXbvy+++/0717d+Cf9TEbN27MggULuHv3Lo6OjhiNRmrXrm22vmb58uW5evUqCQkJHD58mPPnz+P9QMuQmprK77//zlNPPYVer6d27dokJSWZni9btiynTp0y7ddoNJKammp2nNTUVBRFMW1LTEzk448/Zvv27cTFxWEwGEhJSeGPP/7IcT9Z6y4lJYWoqCgyMjIe+juIiIh4aBl706hRE/bsqcL8+THcu3fK4vnc1knm51AIoR1FgbAw+M9/1Mc9e8K6dfDAv0uRD+wqqXtU//3vf2nYsCHNmzfPsdyECRMIDQ01PU5ISKBKlSp06dIFLy8vs7KpqalcuXKFUqVKodfr8fTzU8+YacDLwyPX03P/8MMPBDzQe9XV1RUvLy+Sk5P57bffcHR05OrVq2bvPTO59fT0NNvu6Ohoer2jo6NpQl5PT090Oh3u7u5qrH8/7+DgYLEPJycnnJ2d8fLyQq/X07RpU7788kuL2MuXL4+XlxfOzs64u7ub7cPV1RUHBwfTNgcHB9zc3MzKuLm5odPpTNvee+89duzYwaxZs6hZsybu7u68+OKLZmWs7SdTamoq7u7utGnTJsfJavV6PREREXTu3LnETVqdkqJjzx747beadOsWaPq45rVOrCXXQojCo9freP11RzKb6DFjYPZsyOFihXgEdpXUlStXDkdHR27cuGG2/caNG/g/ZKXwpKQk1q5dy/Tp0x96HFdXV1xdXS22Ozs7W/zDMRgMZp3vdQ4OOHh6PvQYWmvQoAGurq5cvXqV9u3bWy0zbtw4HBwc2Lp1K927d6dnz5506NABwLTk16FDhwgMDATg7t27nDt3jvr16+Pg4EC9evX4+eefTQMUHBwcOHDgALVr1zarx8znssrc1rRpU7755hv8/f2tJlKZZR/cR+bvI3Obi4sLRqPRrEzm/cyfP//8M4MGDeL5558H1DN3ly5dol27dhb7trbkmYODAzqdzurnxBpby9mTnj3BxQUuXNBx4YIz9eqZP5/bOilp9SdEUXL1Kkyc+C/OnnXA0REWLoThw7WOyr7Z1UAJFxcXmjZtSmSWORGMRiORkZGmfmHZWb9+PWlpabxW3KazLyCenp6MHTuWt99+m/DwcC5cuMDRo0dZuHAh4eHhbN68mRUrVrBmzRo6d+7MuHHjGDhwIHcfWOdp+vTpREZGcvLkSQYNGkS5cuXo83eP+HfeeYedO3fyySefcO7cOcLDw1m0aBFjx461Oc5XX32VcuXK0bt3b/bu3UtMTAy7d+/mrbfe4urVqzbvJzAwkKioKK5du8bt27etlqlVqxYbN27k+PHjnDhxgldeecVq3zmRd6VLq52oQV1dQghRPO3aBU895cTZs2Xw8VHYvFkSusJQJJK6ZcuWmfrBZb2fF6GhoXzxxReEh4dz+vRphg8fTlJSEiEhIQAMGDDAbCBFpv/+97/06dOHsjKVtckHH3zApEmTCAsLo169enTt2pXNmzcTGBjIkCFDmDp1qmkx82nTpuHn52ca0JBp5syZjB49mqZNmxIXF8cPP/xguuTapEkT1q5dy8aNG3niiSeYPHky06dPZ9CgQTbH6OHhQVRUFFWrVuW5556jXr16DBkyhNTU1GzP3Fkzffp0Ll26xGOPPUb58uWtlpk7dy6+vr60atWKXr16ERwcbHr/Iv/07Kn+/PFHbePIi/xsy4QojoxG+Phj6NQJbt7UERgYzy+/ZPBA92xRUBQ7tHDhQqVq1aqKi4uL0rx5c+WXX34xPde2bVtl4MCBZuXPnDmjAMr27dvzdLz4+HgFUOLj4y2eS0lJUU6dOqUkJSUpd+/eVQwGQ56OUdzs2rVLAZS7d+/mWM5gMJSYesn8LKSkpORYLj09Xdm0aZOSnp5eSJEVLRcuKAooiqOjomR+fPJaJzn9bQpzttZVSf98WiN1orp6VVE6dlT/fkFR+vc3KOvW/VDi6yWrgm7L7KpPXaZRo0YxatQoq8/t3r3bYludOnVkolAhiogaNaBuXThzBrZvhxdf1DoiIcTDfPcdvP463LkD7u6wYAEMHGhg61aZdLIwaZLUNWnShMjISHx9fWncuLGp07o1R48eLcTIhBBFQc+ealL3449FO6mTtkyUdH/9BW+/jWl0a5MmsGaN+sVMpoksfJokdb179zaNHs3sNC/sS7t27eTsp8izHj3UaQ+2bi3aq0tIWyZKKkWBb76Bf/8bbt1SZ8saOxY+/FAdwS60oUlSN2XKFKv3hRACoHVrdab527fh8GFo2lTriKyTtkyURFevwogR6ooQAI8/DsuXw1NPaRuXKCKjX4UQIitnZ0yj5YrjKFgh7FFKCnzwAdSpoyZ0zs4wdSocPSoJXVGhSVL3wQcf5Gr5npkzZ3Lv3r2CC0gIUeT06KH+LMrz1UlbJkoCRYH166FePZg8GZKT1bPpx47BlClyubUo0SSpmzlzJleuXLGpbFpaGpMmTTJbt1MIYf+6dVP76Rw/rl7uKYqkLRP2bu9eaNtWHbD0559QpQqsXatuf/xxraMTD9KkT13dunV56aWXePrpp03reNarV4+BAweyZcsW9u/fT2pqKkajkWPHjuHl5UWlSpW0CFUIoZHy5aFFC/jlF9i2TUdRbAKkLRP26vBhmDQJfvpJfezuDuPHq4Mh/l7aWxRBmiR1K1asYPbs2fz+++8YjUZSU1NZtGgR//vf//jxxx8JCgrC09MTR0dHqlSpwocffpjjVAFCCPvUvbua1P30kwN/LwpTpEhbJuzN4cPqCNbvv1cfOznBkCEwcSJUrqxtbOLhNEnqgoKC+DJzUpu//fbbbwQFBbFmzRpefvllLcISQhQxXbuqfXh27dLRv3/RS4akLRP2QFFg2zaYNQsy5+d3cID+/dW/vxo1NA1P5EKRGf3asGFD6tSpQ8uWLbUORdixdu3aMWbMGK3DEDZq0gTKloWEBB1nz/pqHY5NpC0TxUVSEqxYAU88oZ4V371bPTM3YAD8/jusWiUJXXFTpJYJO336tNYhCDuVnp6OiwzRKnYcHaFzZ7Vj9vHjFbQOx2bSlomi7PffYdkyWL0a4uPVbZ6e8MYbMHq0OhhCFE9F5kzdw8hUAIXv/v37vPrqq5QqVYqKFSsyb948szNdd+/eZcCAAfj6+uLh4UG3bt34448/TK9ftWoVPj4+/Pjjj9SpUwcPDw9eeOEFkpOTCQ8PJzAwkLJly/Lee+9hyLJsQGBgIB988AEvv/wypUqVIiAggMWLF5vFdu/ePV5//XXKly+Pl5cXHTp04MSJE6bnp06dSqNGjVi+fDnVq1fHzc2NQYMGsWfPHhYsWIBOp0On03Hp0iUGDRpkepz1Zm2dYFH4MuerO3as+CR1OZG2TGjh/n01iXv6aWjQABYuVBO6xx5TL7tevqyu4iIJXfFWbJK6GTNmcOfOHa3DeGSKop7y1uKW21W7QkND2b9/P99//z0RERHs3bvXbP3KQYMGceTIEb7//nsOHDiAoih0794dfZYF/5KTk/n0009Zu3Yt27ZtY/fu3Tz77LNs2bKFLVu2EB4ezqpVq/j222/Njv3JJ58QFBTEsWPHGD9+PKNHjyYiIsL0fN++fbl58yZbt24lOjqaJk2a0LFjR7PPyPnz59mwYQMbN27k+PHjLFiwgJYtWzJ06FBiY2OJjY2lSpUqLFiwwPQ4NjaW0aNHU6FCBerWrZvL364oCF26qD8vXPDh9m1tY8kP9tKWiaIvPV2dJPill8DPDwYOhH371DPgzz0H27fDuXMwbhz4+GgdrcgPRerya07sZR3R5GTw8tLm2ImJUKqUbWXv379PeHg4X3/9NR07dgRg5cqVpukY/vjjD77//nv2799Pq1atAFizZg1VqlRh06ZN9O3bFwC9Xs+SJUt47LHHAHjhhRf48ssvuXHjBqVLl6Zu3bo8/fTT7N6926xTeevWrRk/fjwAtWvXZv/+/cybN4/OnTuzb98+Dh06xM2bN03rbs6ePZtNmzbx7bff8sYbbwDqJdfVq1dTvnx5035dXFzw8PDA39/ftM3b2xtvb28ANm7cyLJly9ixY4dZGaGdSpWgYUOF337TsWOHjv79tY7o0dhLWyaKptRU2LkTNm2CDRsg6/eHWrXUwQ9DhlAkpwgSj67YJHWicF28eBG9Xk/z5s1N27y9valTpw6g9hlycnKiRYsWpufLli1LnTp1zPoTeXh4mBI6AD8/PwIDAyldurRpW/ny5bl586bZ8R/sZN6yZUvmz58PwIkTJ0hMTKRs2bJmZVJSUrhw4YLpcbVq1cwSuoc5duwY/fv3Z9GiRbRu3drm14mC17mzkd9+c2T7dodin9QJkd/u3FFXXvnf/9R55RIT/3muYkX1TN0rr6hrKMuMOvZNkrpC5uFh/gdX2McubM7OzmaPdTqd1W1Go9HmfSYmJlKxYkWrfd58slxDKGXraUkgLi6OZ555htdff50hQ4bY/DpROLp0UZg7F3bs0KEo8o9JlGxpaXDgAOzYod4OH4asTWilSvDMM/D889C+vXq5VZQMktQVMp3O9kugWqpRowbOzs4cPnyYqlWrAhAfH8+5c+do06YN9erVIyMjg4MHD5ouv/7111+cPXuW+vXrP/Lxf/nlF4vH9erVA6BJkybExcXh5OREYGBgrvbr4uJiNigDIDU1ld69e1O3bl3mzp37SHGLgtG6tYKrawZxcU78+isEBWkdkRCFJy0Njh5V+8NFRkJUFKSkmJdp2BB691aTuaZN1XnmRMkjSZ2wytPTk4EDBzJu3DjKlClDhQoVmDJlCg4ODuh0OmrVqkXv3r0ZOnQoy5Ytw9PTk/HjxxMQEEDv3r0f+fj79+9n1qxZ9OnTh4iICNavX8/mv1d279SpEy1btqRPnz7MmjWL2rVrc/36dTZv3syzzz5Ls2bNst1vYGAgBw8e5NKlS5QuXZoyZcrw5ptvcuXKFSIjI7l165apbJkyZWQalCLC1RUaNLhNdLQ/P/0kSZ2wb3Fx6pm4n39Wb0eOqIMesvLzg06d1FvHjjJqVaiKTVL39NNP4+7urnUYJcrcuXMZNmwYPXv2xMvLi3fffZcrV67g5uYGqAMnRo8eTc+ePUlPT6dNmzZs2bLF4vJqXrzzzjscOXKEadOm4eXlxdy5cwn+e24LnU7Hli1beP/99wkJCeHWrVv4+/vTpk0b/Pz8ctzv2LFjGThwIPXr1yclJYWYmBj27NlDbGysxRnGXbt20a5du0d+LyJ/NG5805TUvfuu1tHknbRlIpPRCDExcOwYHD/+z8/r1y3Lli8PLVuql1M7dYLHH5duCMIKRSMGg0GZOXOm0qpVK6VZs2bKe++9pyQnJ2sVziOJj49XACU+Pt7iuZSUFOXUqVNKUlKScvfuXcVgMGgQYf5ITExUvL29leXLl+fbPg0Gg0W9VKtWTZk3b16+HaOoyPwspKSk5FguPT1d2bRpk5Kenl5IkRV96enpyuLFEQooirOzoiQm2va6nP4284u9tGW21pV8Pi09rE4MBkW5dElRtm5VlHnzFOXNNxXl6acVxctLUdTJpsxvOp2iPPGEWi48XFH++ENRjMbCfU/5QT4rlvJaJ7b+fWp2pu6jjz5i6tSpdOrUCXd3dxYsWMDNmzdZsWKFViGJBxw7dowzZ87QvHlz4uPjmT59OkC+XF4VIrcqVUqialWFy5d17N2rrgtbFJS4tkxRcExNVSe/zIez8nZBr0dJTOPi7ylcuZpBzCUHYv7UcTHGgbN/6Dj7hwMpKdZPq7m4KDR83EjjICONGqo/n2hgJMsEAarkgn8b+U6vl8/Kg6zViYdHvp121SypW716NZ999hlvvvkmADt27KBHjx4sX74cB+nhWWTMnj2bs2fP4uLiQtOmTdm7dy/lypXTOixRAul00KGDwqpVOnbsKDpJXYlry5KT6fnSS1pHUagycCQOf65TyXS7RgDXCOBPqhFDda7wPEayH2bqTDq1+IN6nKYuZ6jLGZ7gV+qln8b5WAYcK8Q3VEicgZ5aB1HEWK2T3Ewi+xCaJXWXL1+me/fupsedOnVCp9Nx/fp1KleurFVYIovGjRsTHR1d6Me9dOlSoR9TFA8dOxpZtcqBHTu0juQfBdmWLV68mE8++YS4uDiCgoJYuHCh2dyRD1q/fj2TJk3i0qVL1KpVi48//tgsNqFSgHi8uU25bG83qcA1ArhOJW7gh2LDAkxupBDIJaoTY7rV4Sx1OUN1YnDC8NB9CPEoNEvqMjIyTB3uMzk7O5stMSWEEFm1b6+uxnDiBNy4oY4A1FpBtWXr1q0jNDSUpUuX0qJFC+bPn09wcDBnz56lQgXLdXB//vlnXn75ZcLCwujZsydff/01ffr04ejRozRo0OCRYjHj4cGPa9cSHBycL4OickNRQK9Xr1wlp+hIToaE+zri4yE+QUd8go6EhH/uxydAfLyOhPt/b4vXcecu/HVHR0ZG7i53OTkpVPRXqFRRoVLmz4oKVasYqRKg589LO+n3YltcXasCVYG2BVIHxYler+enn37S5LNSVFmtk3ycRFazpE5RFAYNGmRa5gnU+cKGDRtmNmnsxo0btQhPCFEEVagAjRqpIwR37oQsK8tppqDasrlz5zJ06FBCQkIAWLp0KZs3b2bFihWmJfSyWrBgAV27dmXcuHEAfPDBB0RERLBo0SKWLl2al7dmlYKO+IzS3EgshaI4k5amzqOWnp73nykp6hKKycl/J2w53Dfk48mu0qWhXDnrt/Ll1Ul8AwLUn+XL63BwsJ4I6vWO3NsCDp6lpO9YVno9Bjc39dKi1IuqgOtEs6Ru4MCBFttee+01DSIpHIqs91jiyWcgf3TqpCZ1O3YUjaSuINqy9PR0oqOjmTBhgmmbg4MDnTp14sCBA1Zfc+DAAUJDQ822BQcHs2nTpkeK5UGJifDaaz3ydZ954eionuDw8gJvb/WW9X7WW9btZcqoSVvZsvDACVYhij3NkrqVK1dqdehC5fj3+ixyWVmk/z17qKOs2fNIOnWC2bOtz+WlhYJoy27fvo3BYLCYd9HPz48zZ85YfU1cXJzV8nFxcVbLp6WlkZaWZnqckJAAqG1VTu2VTqdH7e6tjtx0cVEnh876U72vWGzLfKxuU3B1VU9WZJ648PAADw/l75/qrVQpcHdXTPczt+fHvOD51Sxn1pe08+akXizltU5sLV9sJh8urpycnPDw8ODWrVt4eXmRmppqnyPi8shoNJKenm739WI0Grl16xYeHh44Ocmf3aNo105N6CpW1DqS4i0sLIxp06ZZbN++fTseOfTxURRYv16Hk5NS4JPfZl7aLS4iIiK0DqFIknqxlNs6SU62bU4b+e9SwHQ6HRUrVuTixYtcvXoVd3d3dDINuImiKKSkpJSIenFwcKBq1ap2/z4Lmqur/Sd05cqVw9HRkRs3bphtv3HjBv7+/lZf4+/vn6vyEyZMMLtcm5CQQJUqVejSpQteXl7ZxqbX64mIiKBz587S+f1vUifWSb1YymudZJ5JfxhJ6gqBi4sL1atXJyIigrZt28qHOwu9Xk9UVBRt2rSx+3pxcXGx67ORIv9kzgsZGRlJnz59APVsb2RkJKNGjbL6mpYtWxIZGcmYMWNM2yIiImjZsqXV8q6urmaDOzI5Ozvb9Ldoa7mSROrEOqkXS7mtE1vLSlJXSBwcHDAYDLi5ucmHOwtHR0fTlBBSL0L8IzQ0lIEDB9KsWTOaN2/O/PnzSUpKMo2GHTBgAAEBAYSFhQEwevRo2rZty5w5c+jRowdr167lyJEjfP7551q+DSFEIZKkTgghiqB+/fpx69YtJk+eTFxcHI0aNWLbtm2mwRCXL182O/PbqlUrvv76ayZOnMh//vMfatWqxaZNm/J3jjohRJEmSZ0QQhRRo0aNyvZy6+7duy229e3bl759+xZwVEKIoko6+AghhBBC2AE5U5cPMieVzWl0il6vJzk5mYSEBOk7loXUiyWpE0t5rZPMv0mZ+PnhbGnHQD6f1kidWCf1Yqmg2zJJ6vLB/fv3AahSpYrGkQghrLl//z7e3t5ah1GkSTsmRNH3sLZMp8hX2EdmNBq5fv06np6e2c5BljkH1JUrV3KcA6qkkXqxJHViKa91oigK9+/fp1KlSjKdzEPY0o6BfD6tkTqxTurFUkG3ZXKmLh84ODhQuXJlm8p6eXnJh9sKqRdLUieW8lIncobONrlpx0A+n9ZInVgn9WKpoNoy+eoqhBBCCGEHJKkTQgghhLADktQVEldXV6ZMmWJ1WZ6STOrFktSJJamTokN+F5akTqyTerFU0HUiAyWEEEIIIeyAnKkTQgghhLADktQJIYQQQtgBSeqEEEIIIeyAJHWFZPHixQQGBuLm5kaLFi04dOiQ1iEVmrCwMJ588kk8PT2pUKECffr04ezZs2ZlUlNTGTlyJGXLlqV06dI8//zz3LhxQ6OIC9/MmTPR6XSMGTPGtK0k1sm1a9d47bXXKFu2LO7u7jRs2JAjR46YnlcUhcmTJ1OxYkXc3d3p1KkTf/zxh4YRlzzSlklblhNpy1RatWWS1BWCdevWERoaypQpUzh69ChBQUEEBwdz8+ZNrUMrFHv27GHkyJH88ssvREREoNfr6dKlC0lJSaYyb7/9Nj/88APr169nz549XL9+neeee07DqAvP4cOHWbZsGU888YTZ9pJWJ3fv3qV169Y4OzuzdetWTp06xZw5c/D19TWVmTVrFp9++ilLly7l4MGDlCpViuDgYFJTUzWMvOSQtkzaspxIW6bStC1TRIFr3ry5MnLkSNNjg8GgVKpUSQkLC9MwKu3cvHlTAZQ9e/YoiqIo9+7dU5ydnZX169ebypw+fVoBlAMHDmgVZqG4f/++UqtWLSUiIkJp27atMnr0aEVRSmadvPfee8q//vWvbJ83Go2Kv7+/8sknn5i23bt3T3F1dVX+7//+rzBCLPGkLTMnbdk/pC37h5ZtmZypK2Dp6elER0fTqVMn0zYHBwc6derEgQMHNIxMO/Hx8QCUKVMGgOjoaPR6vVkd1a1bl6pVq9p9HY0cOZIePXqYvXcomXXy/fff06xZM/r27UuFChVo3LgxX3zxhen5mJgY4uLizOrE29ubFi1a2G2dFCXSllmStuwf0pb9Q8u2TJK6Anb79m0MBgN+fn5m2/38/IiLi9MoKu0YjUbGjBlD69atadCgAQBxcXG4uLjg4+NjVtbe62jt2rUcPXqUsLAwi+dKYp1cvHiRJUuWUKtWLX766SeGDx/OW2+9RXh4OIDpfcvfkjakLTMnbdk/pC0zp2Vb5vRIrxYil0aOHMnJkyfZt2+f1qFo6sqVK4wePZqIiAjc3Ny0DqdIMBqNNGvWjBkzZgDQuHFjTp48ydKlSxk4cKDG0QlhTtoylbRllrRsy+RMXQErV64cjo6OFiN9bty4gb+/v0ZRaWPUqFH8+OOP7Nq1i8qVK5u2+/v7k56ezr1798zK23MdRUdHc/PmTZo0aYKTkxNOTk7s2bOHTz/9FCcnJ/z8/EpcnVSsWJH69eubbatXrx6XL18GML1v+VvShrRl/5C27B/SllnSsi2TpK6Aubi40LRpUyIjI03bjEYjkZGRtGzZUsPICo+iKIwaNYrvvvuOnTt3Ur16dbPnmzZtirOzs1kdnT17lsuXL9ttHXXs2JHffvuN48ePm27NmjXj1VdfNd0vaXXSunVri+khzp07R7Vq1QCoXr06/v7+ZnWSkJDAwYMH7bZOihJpy6Qts0baMkuatmWPNMxC2GTt2rWKq6ursmrVKuXUqVPKG2+8ofj4+ChxcXFah1Yohg8frnh7eyu7d+9WYmNjTbfk5GRTmWHDhilVq1ZVdu7cqRw5ckRp2bKl0rJlSw2jLnxZR4wpSsmrk0OHDilOTk7KRx99pPzxxx/KmjVrFA8PD+Wrr74ylZk5c6bi4+Oj/O9//1N+/fVXpXfv3kr16tWVlJQUDSMvOaQtk7bMFtKWadeWSVJXSBYuXKhUrVpVcXFxUZo3b6788ssvWodUaACrt5UrV5rKpKSkKCNGjFB8fX0VDw8P5dlnn1ViY2O1C1oDDzaEJbFOfvjhB6VBgwaKq6urUrduXeXzzz83e95oNCqTJk1S/Pz8FFdXV6Vjx47K2bNnNYq2ZJK2TNqyh5G2TLu2TKcoivJo5/qEEEIIIYTWpE+dEEIIIYQdkKROCCGEEMIOSFInhBBCCGEHJKkTQgghhLADktQJIYQQQtgBSeqEEEIIIeyAJHVCCCGEEHZAkjohhBBCCDsgSZ0QQgghhB2QpE4IIYQQwg5IUieEEEIIYQckqRNCCCGEsAOS1AkhhBBC2AFJ6oQQQggh7IAkdUIIIYQQdkCSOiGEEEIIOyBJnRBCCCGEHXDSOgB7YDQauX79Op6enuh0Oq3DEUL8TVEU7t+/T6VKlXBwkO+wOZF2TIiiy9a2TJK6fHD9+nWqVKmidRhCiGxcuXKFypUrax1GkSbtmBBF38PaMknq8oGnpyegVraXl5fVMnq9nu3bt9OlSxecnZ0LM7wiTerFktSJpbzWSUJCAlWqVDH9jYrs2dKOgXw+rZE6sU7qxVJBt2WS1OWDzEsVXl5eOSZ1Hh4eeHl5yYc7C6kXS1Inlh61TuRy4sPZ0o6BfD6tkTqxTurFUkG3ZdLJRAghhBDCDkhSJ4QQQghhB+TyqyjWDAYDer1e6zDylV6vx8nJidTUVAwGg9bhFAnZ1YmzszOOjo4aRiZE/pC2rGQo6LZMkjpRLCmKQlxcHPfu3dM6lHynKAr+/v5cuXJF+oL9Lac68fHxwd/fX+pKFEvSlpUsBd2WSVIniqXMRrBChQp4eHjYVYNhNBpJTEykdOnSMrfa36zViaIoJCcnc/PmTQAqVqyoZYhC5Im0ZSVLQbdlktSJYsdgMJgawbJly2odTr4zGo2kp6fj5uYmDeHfsqsTd3d3AG7evEmFChXkUqwoVqQtK3kKui2TWhbFTma/Ew8PD40jEUVB5ufA3vojCfsnbZnIKj/asjydqdPr9cTFxZGcnEz58uUpU6ZMngMQIq/s6TKFyLvC/hykpaXh6upaqMcU9k3aMgH58zmw+Uzd/fv3WbJkCW3btsXLy4vAwEDq1atH+fLlqVatGkOHDuXw4cOPHJAQQhQlW7duZeDAgdSoUQNnZ2fTxKFt27blo48+4vr161qHKIQQgI1J3dy5cwkMDGTlypV06tSJTZs2cfz4cc6dO8eBAweYMmUKGRkZdOnSha5du/LHH38UdNxCiGJq1apV+Pj45Oo1NWrUYMmSJQUTUDa+++47ateuzeDBg3FycuK9995j48aN/PTTTyxfvpy2bduyY8cOatSowbBhw7h161ahxieE0E5e2rHAwEAWLFhQMAH9zabLr4cPHyYqKorHH3/c6vPNmzdn8ODBLFmyhFWrVrF3715q1aqVr4EKIYqfwMBAxowZw5gxY0zb+vXrR/fu3bULykazZs1i3rx5dOvWzWon7xdffBGAa9eusXDhQr766ivefvvtwg5TCFHAilM7ZlNS93//93827czNzY1hw4Y9UkBCCPvm7u5uGulVlB04cMCmcgEBAcycObOAoxFCFCVFtR3L9ejXwYMHc//+fYvtSUlJDB48OF+CEsKeGY1GwsLCqF69Ou7u7gQFBfHtt9+iKAqdOnWia9euKIoCwJ07d6hcuTKTJ08GYPfu3eh0OjZv3swTTzyBm5sbTz31FCdPnjQ7xoYNG3j88cdxdXUlMDCQOXPmmD0fGBjIjBkzGDx4MJ6enlStWpXPP//crMyVK1d48cUX8fHxoUyZMvTu3ZtLly6Znh80aBB9+vRh9uzZVKxYkbJlyzJy5EjTyK127drx559/8vbbb6PT6UydgB+8bHHhwgV69+6Nn58fpUuX5sknn2THjh35Utf5Zfr06SQnJ1tsT0lJYfr06RpEJIS2HtaOBQcHSzumQTuW66QuPDyclJQUi+0pKSmsXr06X4ISItcUBZKStLn93XDZKiwsjNWrV7N06VJ+//133n77bV577TWioqIIDw/nyJEjLFu2DIBhw4YREBBgagwzjRs3jjlz5nD48GHKly9Pr169TI1QdHQ0L774Ii+99BK//fYbU6dOZdKkSaxatcpsH3PmzKFZs2YcO3aMESNGMHz4cM6ePQuoI9yDg4Px9PRk79697N+/n9KlS9O1a1fS09NN+9i1axcXLlxg165dhIeHs2rVKtNxNm7cSOXKlZk+fTqxsbHExsZarY/ExES6d+9OZGQkx44do2vXrvTq1YvLly/nql4L0rRp00hMTLTYnpyczLRp0zSISNitYtKWPawdO3z4MAsXLgRg+PDh0o4VFsVG8fHxyr179xSdTqecP39eiY+PN93u3LmjhIeHKxUrVrR1d3YlPj5eAZT4+Phsy6SnpyubNm1S0tPTCzGyoi8v9ZKSkqKcOnVKSUlJ+WdjYqKiqE1S4d8SE22OPTU1VfHw8FB+/vlns+1DhgxRXn75ZUVRFGXt2rWKm5ub8t577ymlSpVSzp07Zyq3a9cuBVDWrl1r2vbXX38p7u7uyrp16xRFUZRXXnlF6dy5s9n+x40bp9SvX9/0uFq1asprr71memw0GpUKFSooS5YsURRFUb788kulTp06itFoNJVJS0tT3N3dlZ9++klRFEUZOHCgUq1aNSUjI8NUpm/fvkq/fv3MjjNv3jyzWFauXKl4e3vnWE+PP/64snDhQrP9zJgxQzEYDBZlrX4e/mbL36YtdDqdcvPmTYvtkZGRSrly5R5p30WFrXUlbZmlvNZJcW3LbGnHvvnmG8XNzU0ZM2aMtGNZ9jN37lzl7t27BdaW2TxPnY+Pj+nUY+3atS2e1+l08o1ViIc4f/48ycnJdO7c2Wx7eno6jRs3BqBv376sX7+ejz/+mCVLllgddNSyZUvT/TJlylCnTh1Onz4NwOnTp+ndu7dZ+datWzN//nwMBoNppvInnnjC9LxOp8Pf39+0TM2JEyc4f/48np6eZvtJTU3lwoULpsePP/642cznFStW5LfffrO9QlC/4U6dOpXNmzcTGxtLRkYGKSkpReJMna+vr1m7l3UeKYPBQGJiovQjFiWOre3Yxo0bmT9/PosXL5Z2rJDYnNTt2rULRVHo0KEDGzZsMJtw2MXFhWrVqlGpUqUCCVKIh/LwACuXxwrt2DbKvIS3efNmAgICzJ7LnNA2OTmZEydO4OjoWKDTAzk7O5s91ul0GI1GU5xNmzZlzZo1Fq8rX768Tfuw1dixY4mIiGD27NnUrFkTd3d3XnjhBbPLI1qZP38+iqIwePBgpk2bhre3t+k5FxcXAgMDzf4xCfHIikFbZms7dvToURwdHTl//nz+xpmFtGPmbE7q2rZtC0BMTAxVq1Z96MzHI0aMYPr06ZQrV+7RIhTCFjodlCqldRQPVb9+fVxdXbl8+bLpb+pBY8eOxcHBgc2bN9OzZ0969OhBhw4dzMr88ssvVK1aFYC7d+9y7tw56tWrB0C9evXYv3+/Wfn9+/dTu3Ztm9cTbNKkCevWraNChQp4eXnl9m2auLi4YDAYciyzf/9+Bg0axLPPPguoDXHWjsxaGjhwIADVq1endevWODnl3GTOnDmTYcOG5Xr+KiFMikFbZks79s477+Dg4MD69et58cUX6dmzp7RjhSDXAyWqVatm01IWX331FQkJCXkKKieLFy8mMDAQNzc3WrRowaFDh3Isv379eurWrYubmxsNGzZky5Yt2ZYdNmwYOp2O+fPn53PUQqg8PT0ZO3Ysb7/9NuHh4Vy4cIGjR4+ycOFCwsPD2bx5MytXruTzzz+nc+fOjBs3joEDB3L37l2z/UyfPp3IyEhOnjzJoEGDKFeuHH369AHUxjQyMpIPPviAc+fOER4ezqJFixg7dqzNcb766quUK1eO3r17s3fvXmJiYti9ezdvvfUWV69etXk/gYGBREVFce3aNW7fvm21TK1atdi4cSPHjx/nxIkTvPLKK7n+llzQ2rZt+9CEDmDGjBncuXPnoeWioqLo1asXlSpVQqfTsWnTpoe+Zvfu3TRp0gRXV1dq1qxp0WE8q5kzZ6LT6czm1RIiv9jSjq1YsYIvv/yS9u3bM3bsWGnHCkmukzpbKbkcEWiLdevWERoaypQpUzh69ChBQUEEBwebrp8/6Oeff+bll19myJAhHDt2jD59+tCnTx+LYdOgzh7/yy+/yCVkUeA++OADJk2aRFhYGPXq1aNr165s3ryZwMBAhgwZwpQpUwgKCgLUUZd+fn4W/bZmzpzJ6NGjadq0KXFxcfzwww+4uLgA6rfTb775hrVr19KgQQMmT57M9OnTGTRokM0xenh4EBUVRdWqVXnuueeoV68eQ4YMITU1NVffeKdPn86lS5d47LHHzC53ZDV37lx8fX1p1aoVvXr1Ijg4mCZNmth8jKLE1nYvKSmJoKAgFi9ebFP5mJgYevToQfv27Tl+/Dhjxozh9ddf56effrIoe/jwYZYtW2bW10iI/Pawdmzq1Kmmv+OpU6dKO1ZYchxG8QhKly6tXLhwIV/32bx5c2XkyJGmxwaDQalUqZISFhZmtfyLL76o9OjRw2xbixYtlDfffNNs29WrV5WAgADl5MmTVke5PIyMfs27fBv9akcMBkO2o6MyR43dvXu38APTUE51UhijX22Vl3YPUL777rscy7z77rvK448/bratX79+SnBwsNm2+/fvK7Vq1VIiIiKUtm3bKqNHj7Y5Dhn9mnf5OvrVjmT3d1tS2zFFKfi2rMDO1OW39PR0oqOj6dSpk2mbg4MDnTp1ynbm9wMHDpiVBwgODjYrbzQa6d+/P+PGjct2GTQhhNCSLW0ZwMiRI+nRo4dFWSFEyWDzQAmt3b59G4PBgJ+fn9l2Pz8/zpw5Y/U1cXFxVsvHxcWZHn/88cc4OTnx1ltv2RxLWloaaWlppseZfQf1er1p4sQHZW7P7vmSKi/1otfrURQFo9FY5Ppe5Qfl70t4me8xq8zH9vres/OwOlEUBb1eb9GB2l7+3rJryxISEkhJScHd3Z21a9dy9OhRDh8+bNM+89KOZT6f9afIe52U1LaspLZjUPBtWbFJ6gpCdHQ0CxYs4OjRozYN/sgUFhZmdU6+7du34/GQIeERERG5jrMkyE29ODk54e/vT2JiYpGY9qKgWFuOr0mTJqbOxgUxEKmos1Yn6enppKSkEBUVRUZGhtlz1pb2skdXrlxh9OjRRERE4ObmZtNrHqUdA2nLrMltnZTUtqykt2NQcG1ZgSV1r7322iMNIX5QuXLlcHR05MaNG2bbb9y4gb+/v9XX+Pv751h+79693Lx50zSkGtQJRd955x3mz5+f7XDkCRMmEBoaanqckJBAlSpV6NKlS7bvWa/XExERQefOnS3mxCnJ8lIvqampXLlyhdKlS9v8D6w4URSF+/fv4+npmasvG/YspzpJTU3F3d2dNm3aWHweCvsfxtNPP10gi3xn15Z5eXnh7u5OdHQ0N2/eNOuYbTAYiIqKYtGiRaSlpVl8889LOwbSllmT1zqRtqzkKei2LM9JXXJyMpcvX7b4dpE54mrJkiV53bVVLi4uNG3alMjISNOQZ6PRSGRkJKNGjbL6mpYtWxIZGWk2rD8iIsI0WWj//v2t9lPp378/ISEh2cbi6upqmmAxK2dn54f+QdtSpiTKTb0YDAZ0Oh0ODg44OBSbbqE2yzwln/keRc514uDggE6ns/oZKoi/tdTUVIt2LzMJymnKpEfRsmVLi31nbcs6duxoMQN+SEgIdevW5b333rM6r9ejtGO5KVeS5LZOpC0reQq6Lct1Unfr1i1CQkLYunWr1ecfNkHfowgNDWXgwIE0a9aM5s2bM3/+fJKSkkwJ2IABAwgICCAsLAyA0aNH07ZtW+bMmUOPHj1Yu3YtR44c4fPPPwegbNmylC1b1uwYzs7O+Pv7U6dOnQJ7H0KI4iU5OZl3332Xb775hr/++svi+dy2e4mJiWaz7MfExHD8+HHKlClD1apVmTBhAteuXWP16tWAOofmokWLePfddxk8eDA7d+7km2++YfPmzYA6b1iDBg3MjlGqVCnKli1rsV0IYb9ynTqPGTOGe/fucfDgQdzd3dm2bRvh4eHUqlWL77//viBiNOnXrx+zZ89m8uTJNGrUiOPHj7Nt2zZTB+LLly8TGxtrKt+qVSu+/vprPv/8c4KCgvj222/ZtGmTNHJCiFwZN24cO3fuZMmSJbi6urJ8+XKmTZtGpUqVTIlXbhw5coTGjRub1skMDQ2lcePGTJ48GYDY2FizNSOrV6/O5s2biYiIICgoiDlz5rB8+XKCg4Pz5w0KIexCrs/U7dy5k//97380a9YMBwcHqlWrRufOnfHy8iIsLIwePXoURJwmo0aNyvZy6+7duy229e3bl759+9q8/6KyPJEQouj44YcfWL16Ne3atSMkJISnn36amjVrUq1aNdasWcOrr76aq/21a9cux4mKra0W0a5dO44dO2bzMay1h0II+5brM3VJSUlUqFABAF9fX27dugVAw4YNOXr0aP5GJ4QQRcCdO3eoUaMGoPafy1wK7F//+hdRUVFahiaEECa5Turq1KnD2bNnAQgKCmLZsmVcu3aNpUuXUrFixXwPUAghtFajRg1iYmIAqFu3Lt988w2gnsHz8fHRMDIhhPhHrpO60aNHm/qtTZkyha1bt1K1alU+/fRTZsyYke8BCiGKvnbt2tn14vEhISGcOHECgPHjx7N48WLc3Nx4++23GTdunMbRCSHygz20Y7nuU/faa6+Z7jdt2pQ///yTM2fOULVqVcqVK5evwQkhirb09HTTAtz27O233zbd79SpE2fOnCE6OpqaNWuapnESQhRP9tSO5fpM3fTp081mNvbw8KBJkyaUKlWK6dOn52twQtij+/fv8+qrr1KqVCkqVqzIvHnzzL4h3r17l2HDhlG2bFk8PDzo1q0bf/zxh+n1q1atwsfHhx9//JE6derg4eHBCy+8QHJyMuHh4QQGBuLr68tbb71lNtVGYGAgH3zwAS+//DKlSpUiICCAxYsXm8V27949Xn/9dcqXL4+XlxcdOnQwnaECmDp1Ko0aNWL58uVUr14dNzc3Bg0axJ49e1iwYAE6nQ6dTselS5cYNGiQ6XHWW3HswL969WqzJbWqVavGc889R926dfM0+lWI4s6WdmzgwIEEBgZSunRpaccKSa6TumnTppGYmGixPTk52eqSM0IUBkWBpCRtbjkMYrQqNDSU/fv38/333xMREcHevXvNBhmFhIRw/PhxNm3axIEDB1AUhe7du5ut/ZecnMynn37K2rVr2bZtG7t37+bZZ59ly5YtbNmyhS+//JJly5bx7bffmh37k08+ISgoiGPHjjF+/HjT0lKZ+vbty82bN9m6dSvR0dE0adKEjh07mgYGAJw/f54NGzawceNGjh8/zoIFC2jZsiVDhw4lNjaW2NhYqlSpwoIFC0yPY2NjGT16NBUqVKBu3bq5/O1qLyQkhPj4eIvt9+/fz3GiciFyq7i0ZQ9rxwYNGkR0dDRff/01+/fvl3assCi5pNPplJs3b1psj4yMVMqVK5fb3dmF+Ph4BVDi4+OzLZOenq5s2rRJSU9PL8TIir681EtKSopy6tQpJSUlxbQtMVFR1Cap8G+Jiba/34SEBMXZ2VlZv369adu9e/cUDw8PZfTo0cq5c+cUQNm2bZtiMBgURVGU27dvK+7u7so333yjKIqirFy5UgGU8+fPm/bx5ptvKh4eHsr9+/dN24KDg5U333zT9LhatWpK165dzeLp16+f0q1bN0VRFGXv3r2Kl5eXkpqaalbmscceU5YtW6YoiqJMmTJFcXZ2tmgD2rZtq4wePTrb971hwwbFzc1N2bdv30PryBqDwaDcvXvXVCdZWfs8ZLLlb9MW2bV7x48fV3x9fR9p30WFrXUlbZmlvNZJcW3LbG3H9u7da/q7lXZMVdBtmc196nx9fU2nHWvXrm22ZpnBYCAxMZFhw4bla8IphL25ePEier2e5s2bm7Z5e3ubVjA5ffo0Tk5ONGvWzPR82bJlqVOnDqdPnzZt8/Dw4LHHHjM99vPzM13myLrt5s2bZsfPXFYq6+P58+cDcOLECRITEy1WWUlJSeHChQumx9WqVaN8+fI2v+djx47Rv39/Fi1aROvWrW1+XVHQuHFjU7vXsWNHnJz+aTINBgMxMTF07dpVwwiFKHy2tmMtWrQgKSkJkHassNic1M2fPx9FURg8eDDTpk3D29vb9JyLiwuBgYEWFS1EYfHwACu9Agrt2IXtwXUAM9cLfHBb5jqDtkhMTKRixYpW+4pknbajVKlSNu8zLi6OZ555htdff50hQ4bY/LqiInOd6ePHjxMcHGz2zyaz3Xv++ec1ik7Yo5LUlkk7lv9sTuoGDhwIqMvVtGrVShZyFkWKTge5+BvVTI0aNXB2dubw4cNUrVoVgPj4eM6dO0ebNm2oV68eGRkZHDlyhM6dOwPw119/cfbsWerXr//Ix//ll18sHterVw+AJk2aEBcXh5OTE4GBgbnar4uLi8X6p6mpqfTu3Zu6desyd+7cR4pbK1OmTAHUztn9+vXDzc1N44iEvSsObZmt7djBgwdNy3JKO1Y4bErqEhISTPcbN25MSkoKKSkpVst6eXnlT2RC2CFPT08GDhzIuHHjKFOmDBUqVGDKlCk4ODig0+moVasWzzzzDGPGjGHZsmV4e3szfvx4AgIC6N279yMff//+/cyaNYs+ffoQERHB+vXrTYvCd+rUiZYtW9KnTx9mzZpF7dq1uX79Ops3b+bZZ581uyT8oMDAQA4ePMilS5coXbo0ZcqU4c033+TKlStERkaaVp4BKFOmTLGbPiDzS60QwrZ2rHfv3rz55pvMnj0bf39//vOf/0g7VghsGv3q4+ODr69vjrfMMkKInM2dO5eWLVvSs2dPOnXqROvWralXr57pLNCKFSsICgrimWeeoWXLliiKwpYtW/Ll7Pg777xjWkz+ww8/ZO7cuaZF4XU6HVu2bKFNmzaEhIRQu3ZtXnrpJf7880/8/Pxy3O/YsWNxdHSkfv36lC9fnsuXL7Nnzx5iY2OpX78+FStWNN1+/vnnR34fhcHX15cyZcrYdBOipHlYO7Zy5UqaNGnCSy+9ROvWraUdKyQ6RXn4IOY9e/bYvMO2bds+UkDFUUJCAt7e3sTHx2d7plKv17Nlyxa6d+8ul66zyEu9pKamEhMTY5pfqLhLSkoiICCAOXPmMGTIEIxGIwkJCXh5eeHgkOtZh7IVGBjImDFjiuWM6TnVSU6fB1v+NrMTHh5uc1l7OJNna11JW2Ypr3ViT23Zg+0Y5Px3m1fFuR2Dgm/LbLr8WhITNSEKyrFjxzhz5gzNmzcnPj7eNGl3flyWEPnHHhI1IQqKtGNFU55S57179/Laa6/RqlUrrl27BsCXX37Jvn378jU4IezV7NmzCQoKolOnTiQlJbF3715ZZq+Iu3DhAhMnTuTll182TbGwdetWfv/9d40jE0Ib0o4VPble+3XDhg3079+fV199laNHj5qWzomPj2fGjBls2bIl34MUwp40btyY6OjoQj/upUuXCv2Y9mLPnj1069aN1q1bExUVxUcffUSFChU4ceIE//3vfy1mvBfC3kk7VjTl+kzdhx9+yNKlS/niiy/M+g60bt3abIkQIYSwF+PHj+fDDz8kIiLCbMRbhw4dLKZXEEIIreQ6qTt79ixt2rSx2O7t7c29e/fyIyYhhChSfvvtN5599lmL7RUqVOD27dsaRCSEEJZyndT5+/tz/vx5i+379u2jRo0a+RKUELawYeC2KAEK43Pg4+NDbGysxfZjx44REBBQ4McX9k3aMgH58znIdVI3dOhQRo8ezcGDB9HpdFy/fp01a9YwduxYhg8f/sgBCfEwmZf9k5OTNY5EFAWZn4OCnF7jpZde4r333iMuLs60bNH+/fsZO3YsAwYMKLDjCvsmbZnIKj/aslwPlBg/fjxGo5GOHTuSnJxMmzZtcHV1ZezYsfz73//OcyBC2MrR0REfHx/TCEQPDw90Op3GUeUfo9FIeno6qamp+TpPXXFmrU4URSE5OZmbN2/i4+ODo6NjgR1/xowZjBw5kipVqmAwGKhfvz4Gg4FXXnmFiRMnFthxhX2TtqzkKei2LNdJnU6n4/3332fcuHGcP3+exMRE6tevb7bQtRAFzd/fH8DUGNoTRVFISUnB3d3drhr4R5FTnfj4+Jg+DwXFxcWFL774gkmTJnHy5EkSExNp3LgxtWrVKtDjCvsnbVnJUtBtWa6TukwuLi75sjCvEHmh0+moWLEiFSpUQK/Xax1OvtLr9URFRdGmTRuZsf9v2dWJs7NzgZ6he1DVqlVNC5gLkR+kLStZCrotsympe+6552ze4caNG/McjBC55ejoWKj/1AuDo6MjGRkZuLm5SUP4Ny3qJDQ01Oayc+fOLcBIREkgbVnJUNB1YlNS5+3tbbqvKArfffcd3t7eNGvWDIDo6Gju3buXq+RPCCGKsmPHjpk9Pnr0KBkZGdSpUweAc+fO4ejoSNOmTbUITwghLNjUc3HlypWmm5+fHy+++CIxMTFs3LiRjRs3cvHiRV566aVCWR5k8eLFBAYG4ubmRosWLTh06FCO5devX0/dunVxc3OjYcOGZite6PV63nvvPRo2bEipUqWoVKkSAwYM4Pr16wX9NoQQRdyuXbtMt169etG2bVuuXr3K0aNHOXr0KFeuXKF9+/b06NEj1/uOioqiV69eVKpUCZ1Ox6ZNmx76mt27d9OkSRNcXV2pWbMmq1atMns+LCyMJ598Ek9PTypUqECfPn04e/ZsrmMTQhRfuR6OsmLFCsaOHWt2mtjR0ZHQ0FBWrFiRr8E9aN26dYSGhjJlyhSOHj1KUFAQwcHB2XYw/fnnn3n55ZcZMmQIx44do0+fPvTp04eTJ08C6vDho0ePMmnSJI4ePcrGjRs5e/YszzzzTIG+DyFE8TJnzhzCwsLw9fU1bfP19eXDDz9kzpw5ud5fUlISQUFBLF682KbyMTEx9OjRg/bt23P8+HHGjBnD66+/zk8//WQqs2fPHkaOHMkvv/xCREQEer2eLl26kJSUlOv4hBDFU64HSmRkZHDmzBnTJYhMZ86cwWg05ltg1sydO5ehQ4cSEhICwNKlS9m8eTMrVqxg/PjxFuUXLFhA165dGTduHAAffPABERERLFq0iKVLl+Lt7U1ERITZaxYtWkTz5s25fPmydIgWQgCQkJDArVu3LLbfunWL+/fv53p/3bp1o1u3bjaXX7p0KdWrVzclkPXq1WPfvn3MmzeP4OBgALZt22b2mlWrVlGhQgWio6OtrgIkhLA/uU7qQkJCGDJkCBcuXKB58+YAHDx4kJkzZ5qSrYKQnp5OdHQ0EyZMMG1zcHCgU6dOHDhwwOprDhw4YNHZOTg4OMdLHfHx8eh0Onx8fLItk5aWRlpamulxQkICoF7OzW70UuZ2exvd9KikXixJnVjKa53kVx0+++yzhISEMGfOHLN2b9y4cYXSl/jAgQN06tTJbFtwcDBjxozJ9jXx8fEAlClTxurzeWnHMp/P+lNInWRH6sVSQbdluU7qZs+ejb+/P3PmzDEtm1OxYkXGjRvHO++8k9vd2ez27dsYDAb8/PzMtvv5+XHmzBmrr4mLi7NaPi4uzmr51NRU3nvvPV5++WW8vLyyjSUsLIxp06ZZbN++fTseHh45vo8HzwwKldSLJakTS7mtk/yaqX/p0qWMHTuWV155xdS4Ojk5MWTIED755JN8OUZOsmvLEhISTHNeZWU0GhkzZgytW7emQYMGVvf5KO0YyOfTGqkT66ReLBVUW5brpM7BwYF3332Xd9991/TNLqcEqLjQ6/W8+OKLKIrCkiVLciw7YcIEszOACQkJVKlShS5dumRbF3q9noiICDp37ixDu7OQerEkdWIpr3WS2UY9Kg8PDz777DM++eQTLly4AMBjjz1GqVKl8mX/+W3kyJGcPHmSffv2ZVsmL+0YyOfTGqkT66ReLBV0W5bnyYehcJO5cuXK4ejoyI0bN8y237hxI9sZmP39/W0qn5nQ/fnnn+zcufOh78vV1RVXV1eL7c7Ozg/9JdlSpiSSerEkdWIpt3WS3/VXqlQpnnjiiXzdpy2ya8u8vLwsztKNGjWKH3/8kaioKCpXrpztPh+lHctNuZJE6sQ6qRdLBdWWPdJibCNGjOD27duPsgububi40LRpUyIjI03bjEYjkZGRtGzZ0uprWrZsaVYe1FOeWctnJnR//PEHO3bsoGzZsgXzBoQQdmHmzJncu3evUI9pS1umKAqjRo3iu+++Y+fOnVSvXr1QYxRCaO+Rkrqvvvoq3y5v2CI0NJQvvviC8PBwTp8+zfDhw0lKSjIN0BgwYIDZQIrRo0ezbds25syZw5kzZ5g6dSpHjhxh1KhRgJrQvfDCCxw5coQ1a9ZgMBiIi4sjLi6O9PT0QntfQojiY8aMGdy5c+eR9pGYmMjx48c5fvw4oE5Zcvz4cS5fvgyol0YHDBhgKj9s2DAuXrzIu+++y5kzZ/jss8/45ptvePvtt01lRo4cyVdffcXXX3+Np6enqS1LSUl5pFiFEMXHI11+VRQlv+KwSb9+/bh16xaTJ08mLi6ORo0asW3bNlMH4suXL+Pg8E+e2qpVK77++msmTpzIf/7zH2rVqsWmTZtMHYevXbvG999/D0CjRo3MjrVr1y7atWtXKO9LCFF85Ee7d+TIEdq3b296nNm3beDAgaxatYrY2FhTggfw/+3de1xU9bo/8M8AA4MioKLcBLmcChRFgiTSRJTEKPO2LROPiKZHg2PKPhV2ULeaoXvvTEwUtZNparlNYlde2YNaGoGgtjOU2kHRRgFvgBcu08z6/eHPleMacIAZZhg+79eLlzPf9V1rnnkcntfDmnXx9fXF/v37sWjRIqSnp6Nfv3547733xMuZABCPBb6/bm3btg0zZ85sd8xEZP7a1dQBd25G3JGSkpLEPW33O3bsmGRsypQpmDJlis75Pj4+Hd6YElHn1966N3LkyBZrz/13i7i7zv23LrsXaxkRtaqp8/X11Spm9fX1iIyMhI3N75spLS01XHRERCYWFRUlqXvTpk3TOkEhNzfXFKEREWlpVVN371+PgiAgNjYWq1evhqenp6HjIiIyC/d+dSkIAvLy8jBp0iT07dvXdEEREenQqqYuMjJS67m1tTUef/xx+Pn5GTQoIiJzER8fr/X8v//7vzF58mTWPSIyO+06+7Wjj6cjIjI11j0iMlftaup4YC4RdTWse0Rkrtp19uuNGzcMFQcRUadQXFwMDw8PU4dBRCTR6j115eXlOv9SFQRB67pKRESWyMvLC9bW1qYOg4hIotVNna+vLy5fviwZv3btGm9LQ0QWydraGtXV1ZLxq1evssEjIrPR6qZOEASdBwrfvHkTCoXCIEEREZmT5o6ja2xshK2tbQdHQ0Skm97H1N29jY1MJsOSJUvQrVs3cZlarUZ+fr7kVltERJ3Z+vXrAdype++99x4cHBzEZWq1Gl9++SUCAgJMFR4RkRa9m7q7t6cRBAHfffed1l+ntra2CA4Oxv/8z/8YPkIiIhN55513ANype5mZmVpftdra2sLHxweZmZmmCo+ISIveTd3Ro0cBAAkJCUhPT4ejo6PRgiIiMgdlZWUA7twqLCsrCz179jRxREREzWv1JU22bdtmjDiIiMzW3T9qiYjMWbsuPkxERERE5oFNHREREZEFYFNHREREZAHY1BERERFZAIM2dV9++SVqa2sNuUkiIrNWXl4OtVpt6jCIiAzb1I0cORJ+fn54++23DblZIiKz5ePjgwEDBiArK8vUoRBRF9fqS5q0pKysDKWlpTh48KAhN0tEZLZyc3NRVlaGPXv2YNKkSaYOh4i6MIM2df3790f//v0RFRVlyM0SEZmtkSNHYuTIkUhISDB1KETUxbX661c/Pz9cvXpVMl5TUwM/Pz+DBEVEZE5GjRqFmpoayXhdXR1GjRrV8QEREenQ6qbu559/1nlQcGNjIyoqKgwSFBGROTl27Biampok4w0NDfjqq69MEBERkZTeX79+9tln4uPDhw/DyclJfK5Wq6FUKuHj42PQ4IiITOmf//yn+Li4uBiVlZXic7VajUOHDsHT09MUoRERSei9p27ChAmYMGECZDIZ4uPjxecTJkzA1KlTkZOT0yFnvWZkZMDHxwcKhQLh4eEoKChocf7evXsREBAAhUKBQYMG4cCBA1rLBUHA0qVL4e7uDnt7e0RHR+PHH3805lsgok5iyJAhCAkJgUwmw6hRozBkyBDxJzQ0FG+++SaWLl3a6u1++eWXGDduHDw8PCCTyZCdnf3AdY4dO4ZHH30UdnZ2+I//+A988MEHkjmtrY9EZFn0buo0Gg00Gg28vb1RXV0tPtdoNGhsbERJSQmeffZZY8aKPXv2IDk5GcuWLcPp06cRHByMmJgYVFdX65z/9ddf48UXX8Ts2bNx5swZsQk9d+6cOOfPf/4z1q9fj8zMTOTn56N79+6IiYlBQ0ODUd8LEZm/srIy/PTTTxAEAQUFBSgrKxN/KioqUFdXh1mzZrV6u7du3UJwcDAyMjL0juOZZ55BVFQUzp49i4ULF+Kll17C4cOHxTmtrY9EZHlaffZrWVmZMeLQy9q1azFnzhzxLLPMzEzs378f77//PlJSUiTz09PTMXbsWLz66qsAgJUrVyInJwcbNmxAZmYmBEHAunXrkJqaivHjxwMAduzYAVdXV2RnZ2Pq1KkGi13QCFDVqHCr+hbkcrnBttvZqVQq5uU+zIlUcznp5tINMiuZ0V63f//+AO78UWtITz/9NJ5++mm952dmZsLX11f8NiQwMBAnTpzAO++8g5iYGACtr49txVomxd9Z3ZgXKV05MWQd06up+/jjj/VucH799VeUl5dj2LBh7Qrsfk1NTSgqKsLixYvFMSsrK0RHRyMvL0/nOnl5eUhOTtYai4mJEb/qKCsrQ2VlJaKjo8XlTk5OCA8PR15eXrPvubGxEY2NjeLzuro6AP//P0ul0rlO7aVaTJn5hwe/0S6JeZFiTqSkObn+7xp079u92TWa+33UxzfffIPHH39cr7m3b99GWVkZBg4c2ObXa0leXp5WnQLu1LKFCxcCaFt9bEsdA1jLmsec6Ma8SGnn5EF1DNC/lunV1G3atAnLly9HQkICxo0bh8DAQK3ltbW1OHnyJHbu3ImcnBz83//9n14v3hpXrlyBWq2Gq6ur1rirqysuXLigc53Kykqd8+8e7Hz335bm6JKWlobly5dLxo8cOYJu3brpXEdVowI/3ESG9Y9//ANy5+b3ANy+fbvN2/7P//xP+Pn54aWXXkJsbCy6d5cW3eLiYuzcuRPbtm3DmjVrjNbUNVfL6urqUF9fj+vXr7e6PraljgGsZUSG9qA6Buhfy/Rq6o4fP47PPvsM7777LhYvXozu3bvD1dUVCoUC169fR2VlJVxcXDBz5kycO3dOUlgszeLFi7X2ANbV1cHLywtjxoyBo6OjznWaGpuwF58gMjKSu6HvoVKpcPz4ceblHsyJVHM56ebyXItfW9zd+9QWxcXF2LRpE1JTUzFt2jQ8/PDD8PDwEOvehQsXcPPmTUycOBFHjhzBoEGD2vxaptCWOgawlunC31ndmBcpXTl5UB0D9K9leh9T99xzz+G5557DlStXcOLECfzyyy+or6+Hi4sLQkJCEBISAisrg95KVouLiwusra1RVVWlNV5VVQU3Nzed67i5ubU4/+6/VVVVcHd315ozZMiQZmOxs7ODnZ2dZFwul7f4wZU7y+Hs6cwP9z1UKhXzch/mRKqtOWlP/uRyORYsWIAFCxagsLBQq+4FBwdj0aJFiIqKQq9evdr8GvpqrpY5OjrC3t4e1tbWra6Pba1jAGvZ/fg7qxvzImXsWtbqEyVcXFwwYcKE1q7Wbra2tggNDYVSqRRfX6PRQKlUIikpSec6ERERUCqV4nEnAJCTk4OIiAgAgK+vL9zc3KBUKsUmrq6uDvn5+Zg/f74x3w4RdSJhYWEICwsz2etHRERILsd0by1rS30kIstj0Hu/GltycjLi4+MRFhaGoUOHYt26dbh165Z4tteMGTPg6emJtLQ0AMArr7yCyMhIvP3223jmmWfw8ccfo7CwEFu2bAEAyGQyLFy4EG+++SYeeugh+Pr6YsmSJfDw8DBJ40pEXcPNmzfxr3/9S3xeVlaGs2fPolevXvD29sbixYtRUVGBHTt2AADmzZuHDRs24LXXXsOsWbOQm5uLv/3tb9i/f7+4jQfVRyKyfO1q6lavXo158+bB2dnZQOG07IUXXsDly5exdOlSVFZWYsiQITh06JB4DF95ebnWV8BPPPEEdu/ejdTUVLzxxht46KGHkJ2djaCgIHHOa6+9hlu3bmHu3LmoqanB8OHDcejQISgUig55T0TUuXz00Ud47rnndJ44oa/CwkJERUWJz+8e2xYfH48PPvgAly5dQnl5ubjc19cX+/fvx6JFi5Ceno5+/frhvffeEy9nAjy4PhKR5WtzU3fjxg2kpqYiMjJS/AqgIyQlJTX7dcKxY8ckY1OmTMGUKVOa3Z5MJsOKFSuwYsUKQ4VIRBaqqakJM2bMQEFBAUJCQtq8nZEjR0IQhGaX67pbxMiRI3HmzJkWt9tSfSQiy6dXU9fU1IQDBw6goqICarUajY2N2L9/Pzw9PTFnzhxMmzYNDg4OsLa2hru7O2JjY7mni4g6vbNnz2rVvU8//RSOjo5YtGgR5s6dq1X3Hn30UVOHS0RdnF5N3YwZM/DJJ5/Azc1NPDPq4YcfxtGjR7FixQrs2LEDjY2NUKvVqKqqwqBBg1BYWGjs2ImIjCYpKQkbN24Un9vY2OCRRx7BgQMH8Prrr2PWrFloamoCcGeP/9ixY7WOcSMi6mh6NXVHjhzBwYMH8dRTT0mW3f81wU8//YSHH34Y165d65BT/YmIjGHv3r3Ytm0b4uLiYGOjXSrvPdRDo9HgxIkTiIqKQm1tLZycnDo4UiKiO/S6sFzPnj1bvG7bvfz9/fHII4+060ruRESmduXKFYwZM0bS0N3PysoKI0aMgJ2dHa5fv95B0RERSem1p+6nn35q1UaLi4vbFAwRkblQq9Wtms8/ZInI1Ix3CwgiIiIi6jAGa+p+++03resqEREREVHHMVhT9/3338PX19dQmyMiMgsbN25EdHQ0nn/+eSiVSq1lV65cgZ+fn4kiIyLSxq9fiYiasX79erz66qsICAiAnZ0dYmNjxdsQAneOu/vll19MGCER0e/0vqPEgy6sWV9f3+5giIjMyebNm7F161ZMmzYNADB//nxMmDAB9fX1vAsNEZkdvZu64uJiTJ06tdmvWC9duoQffvjBYIEREZlaWVkZnnjiCfH5E088gdzcXERHR0OlUmHhwoWmC46I6D56N3VBQUEIDw/H/PnzdS4/e/Ystm7darDAiIhMzcXFBb/++it8fHzEsaCgIOTm5mLUqFG4ePGi6YIjIrqP3sfUDRs2DCUlJc0u79GjB0aMGGGQoIiIzMHw4cORlZUlGR8wYACUSiUOHjxogqiIiHTTe09denp6i8v9/f1x9OjRdgdERGQuUlJSUFRUpHPZwIEDkZubi3379nVwVEREuund1BERdTWDBw/G4MGDm10eFBSEoKCgDoyIiKh5vKQJERERkQVoU1Pn6OiI0tJSyWMiIkvFukdE5q5NTZ0gCDofExFZKtY9IjJ3/PqViIiIyAKwqSMiIiKyAGzqiIiIiCwAmzoiIiIiC8CmjoiIiMgCsKkjIiIisgBtauqmT58OR0dHyWNjunbtGuLi4uDo6AhnZ2fMnj0bN2/ebHGdhoYGJCYmonfv3nBwcMDkyZNRVVUlLv/222/x4osvwsvLC/b29ggMDHzg7dCIqGsydN3LyMiAj48PFAoFwsPDUVBQ0OxclUqFFStWwN/fHwqFAsHBwTh06JDWHLVajSVLlsDX1xf29vbw9/fHypUrefkVoi6kTbcJ27Rpk87HxhQXF4dLly4hJycHKpUKCQkJmDt3Lnbv3t3sOosWLcL+/fuxd+9eODk5ISkpCZMmTcLJkycBAEVFRejbty927twJLy8vfP3115g7dy6sra2RlJTUIe+LiDoHQ9a9PXv2IDk5GZmZmQgPD8e6desQExODkpIS9O3bVzI/NTUVO3fuxNatWxEQEIDDhw9j4sSJ+PrrrxESEgIAWLNmDTZt2oTt27dj4MCBKCwsREJCApycnLBgwYJ2xUtEnYTQCRQXFwsAhFOnToljBw8eFGQymVBRUaFznZqaGkEulwt79+4Vx86fPy8AEPLy8pp9rZdfflmIiopqVXy1tbUCAKG2trbZOU1NTUJ2drbQ1NTUqm1bOuZFijmRamtO9PndNIWhQ4cKiYmJ4nO1Wi14eHgIaWlpOue7u7sLGzZs0BqbNGmSEBcXJz5/5plnhFmzZrU4pyX65oqfTynmRDfmRcrYtUyvPXXJyclYuXIlunfvjuTk5BbnOjg4YODAgfjDH/4Aa2vrdracd+Tl5cHZ2RlhYWHiWHR0NKysrJCfn4+JEydK1ikqKoJKpUJ0dLQ4FhAQAG9vb+Tl5eHxxx/X+Vq1tbXo1auXQeImos7LWHWvqakJRUVFWLx4sThmZWWF6Oho5OXl6VynsbERCoVCa8ze3h4nTpwQnz/xxBPYsmULfvjhBzz88MP49ttvceLECaxdu/ZBb5WILIReTd2ZM2egUqnExy1pbGxEeno6Dhw4gO3bt7c/QgCVlZWSryRsbGzQq1cvVFZWNruOra0tnJ2dtcZdXV2bXefrr7/Gnj17sH///hbjaWxsRGNjo/i8rq4OwJ3jXu7m6X53x5tb3lUxL1LMiVRbc9KeHBqr7l25cgVqtRqurq5a466urrhw4YLOdWJiYrB27VqMGDEC/v7+UCqVyMrKglqtFuekpKSgrq4OAQEBsLa2hlqtxqpVqxAXF9dszK2tY3eX3/svMSfNYV6kjF3L9Grqjh49qvNxcwoLCzF69OgHzktJScGaNWtanHP+/PkHB2gA586dw/jx47Fs2TKMGTOmxblpaWlYvny5ZPzIkSPo1q1bi+vm5OS0K05LxbxIMSdSrc3J7du32/xaxqp7bZGeno45c+YgICAAMpkM/v7+SEhIwPvvvy/O+dvf/oZdu3Zh9+7dGDhwIM6ePYuFCxfCw8MD8fHxkm22p44B/HzqwpzoxrxIGauWtelEiQcZPHgwduzY8cB5f/zjHzFz5swW5/j5+cHNzQ3V1dVa47/99huuXbsGNzc3neu5ubmhqakJNTU1WnvrqqqqJOsUFxdj9OjRmDt3LlJTUx8Y9+LFi7W+jqmrq4OXlxfGjBnT7BlxKpUKOTk5eOqppyCXyx/4Gl0F8yLFnEi1NSd39z51BH3rnouLC6ytrbXOxAd016a7+vTpg+zsbDQ0NODq1avw8PBASkoK/Pz8xDmvvvoqUlJSMHXqVADAoEGD8MsvvyAtLU1nU9eWOgbw86kLc6Ib8yJl7Fpm0KZuxYoViIqKwpNPPonx48c/cH6fPn3Qp0+fB86LiIhATU0NioqKEBoaCgDIzc2FRqNBeHi4znVCQ0Mhl8uhVCoxefJkAEBJSQnKy8sREREhzvv+++8xatQoxMfHY9WqVfq8TdjZ2cHOzk4yLpfLH/ifpM+croh5kWJOpFqbk47IX2vrnq2tLUJDQ6FUKjFhwgQAgEajgVKpfOBZ9wqFAp6enlCpVNi3bx+ef/55cdnt27dhZaV9lSpra2toNBqd22pPHWvNvK6EOdGNeZEyVi0z6MWHt23bhpiYGIwbN86Qm0VgYCDGjh2LOXPmoKCgACdPnkRSUhKmTp0KDw8PAEBFRQUCAgLEaz05OTlh9uzZSE5OxtGjR1FUVISEhARERESIJ0mcO3cOUVFRGDNmDJKTk1FZWYnKykpcvnzZoPETkeVqS91LTk7G1q1bsX37dpw/fx7z58/HrVu3kJCQAACYMWOG1okU+fn5yMrKQmlpKb766iuMHTsWGo0Gr732mjhn3LhxWLVqFfbv34+ff/4Zn376KdauXavzRDIiskwG3VNXVlaG+vp6vY4/aa1du3YhKSkJo0ePhpWVFSZPnoz169eLy1UqFUpKSrS+d37nnXfEuY2NjYiJicHGjRvF5Z988gkuX76MnTt3YufOneJ4//798fPPPxv8PRCR5WlL3XvhhRdw+fJlLF26FJWVlRgyZAgOHToknjxRXl6utdetoaEBqampKC0thYODA2JjY/Hhhx9qHVry7rvvYsmSJXj55ZdRXV0NDw8P/Nd//ReWLl1qsPdKRObN4MfU2dvbIzY21tCbRa9evVq80LCPj4/kyukKhQIZGRnIyMjQuc6f/vQn/OlPfzJkmETUBbWl7iUlJTX7deuxY8e0nkdGRqK4uLjF7fXo0QPr1q3DunXrWhUHEVmOVn/92tzxGRqNBuXl5e0OiIjI3LDuEVFnoHdTV1dXh+effx7du3eHq6srli5dqnWNpMuXL8PX19coQRIRmQLrHhF1Jnp//bpkyRJ8++23+PDDD1FTU4M333wTp0+fRlZWFmxtbQGAN44mIovCukdEnYnee+qys7OxefNm/OEPf8BLL72EwsJCXL58GePGjROvSi6TyYwWKBFRR2PdI6LORO+m7vLly+jfv7/43MXFBf/4xz9w48YNxMbGtuvK7URE5oh1j4g6E72bOm9vb8ktu3r06IEjR46gvr6e10IiIovDukdEnYneTd2YMWOwbds2ybiDgwMOHz4MhUJh0MCIiEyNdY+IOhO9T5RYvnw5Ll68qHNZjx49kJOTg9OnTxssMCIiU2PdI6LORO+mrmfPnujZs2ezy3v06IHIyEiDBEVEZA5Y94ioM2nTvV9Pnjwpnvl172MiIkvFukdE5q5NTd3TTz+NiooKyWMiIkvFukdE5q5NTd29F9vkhTeJqCtg3SMic9empo6IiIiIzAubOiIiIiILwKaOiIiIyAKwqSMiIiKyAGzqiIiIiCwAmzoiIiIiC9Cmpm7z5s1wdXWVPCYislSse0Rk7vS+Tdi9pk2bpvMxEZGlYt0jInPHr1+JiIiILIBee+oeffRRKJVK9OzZEyEhIZDJZM3OPX36tMGCIyIyFdY9Iups9Grqxo8fDzs7OwDAhAkTjBkPEZFZYN0jos5Gr6Zu2bJlOh8TEVkq1j0i6mw6zTF1165dQ1xcHBwdHeHs7IzZs2fj5s2bLa7T0NCAxMRE9O7dGw4ODpg8eTKqqqp0zr169Sr69esHmUyGmpoaI7wDIqLfZWRkwMfHBwqFAuHh4SgoKGh2rkqlwooVK+Dv7w+FQoHg4GAcOnRIMq+iogLTp09H7969YW9vj0GDBqGwsNCYb4OIzIheTd3KlStx+/ZtvTe6evVqgzdGcXFx+P7775GTk4MvvvgCX375JebOndviOosWLcLnn3+OvXv34vjx47h48SImTZqkc+7s2bMxePBgg8ZMRJ2XMevenj17kJycjGXLluH06dMIDg5GTEwMqqurdc5PTU3F5s2b8e6776K4uBjz5s3DxIkTcebMGXHO9evXMWzYMMjlchw8eBDFxcV4++230bNnT73fAxF1coIeunXrJly4cEGfqUJDQ4NgY2Mj/Pvf/9Zrvj6Ki4sFAMKpU6fEsYMHDwoymUyoqKjQuU5NTY0gl8uFvXv3imPnz58XAAh5eXlaczdu3ChERkYKSqVSACBcv369VfHV1tYKAITa2tpm5zQ1NQnZ2dlCU1NTq7Zt6ZgXKeZEqq050ed3sznGrHtDhw4VEhMTxedqtVrw8PAQ0tLSdM53d3cXNmzYoDU2adIkIS4uTnz++uuvC8OHD9fr9XXRN1f8fEoxJ7oxL1LGrmV6HVMXEBCAqVOn4sknn4SNjQ3kcjkCAwMRHx+PAwcO4OTJk2hoaIBGo8GZM2fg6OgIDw8PgzWeeXl5cHZ2RlhYmDgWHR0NKysr5OfnY+LEiZJ1ioqKoFKpEB0drfU+vL29kZeXh8cffxwAUFxcjBUrViA/Px+lpaUGi5mIOjdj1b2mpiYUFRVh8eLF4piVlRWio6ORl5enc53GxkYoFAqtMXt7e5w4cUJ8/tlnnyEmJgZTpkzB8ePH4enpiZdffhlz5sxpYwaIqLPRq6l7//338de//hXff/89NBoNGhoasGHDBvz973/HF198geDgYPTo0QPW1tbw8vLCm2++2eLp/61VWVmJvn37agduY4NevXqhsrKy2XVsbW3h7OysNe7q6iqu09jYiBdffBF/+ctf4O3trXdT19jYiMbGRvF5XV0dgDvHvahUKp3r3B1vbnlXxbxIMSdSbc1Je3JorLp35coVqNVqyR0pXF1dceHCBZ3rxMTEYO3atRgxYgT8/f2hVCqRlZUFtVotziktLcWmTZuQnJyMN954A6dOncKCBQtga2uL+Ph4yTbbUsfuLr/3X2JOmsO8SBm7lunV1AUHB+PDDz/UGvvuu+8QHByMXbt24cUXX2xVcHelpKRgzZo1Lc45f/58m7atj8WLFyMwMBDTp09v1XppaWlYvny5ZPzIkSPo1q1bi+vm5OS06rW6CuZFijmRam1OWnNM3P2MVffaIj09HXPmzEFAQABkMhn8/f2RkJCA999/X5yj0WgQFhaGt956CwAQEhKCc+fOITMzU2dT1546BvDzqQtzohvzImWsWtam24QBwKBBg/DII48gIiKirZvAH//4R8ycObPFOX5+fnBzc5McQPzbb7/h2rVrcHNz07mem5sbmpqaUFNTo7W3rqqqSlwnNzcX3333HT755BMAgCAIAAAXFxf87//+r86CB9xpBpOTk8XndXV18PLywpgxY+Do6KhzHZVKhZycHDz11FOQy+UtvueuhHmRYk6k2pqTu3ufDMUQdc/FxQXW1taSM/HvrU3369OnD7Kzs9HQ0ICrV6/Cw8MDKSkp8PPzE+e4u7tjwIABWusFBgZi3759OrfZljoG8POpC3OiG/MiZexa1uamDmj/XrQ+ffqgT58+D5wXERGBmpoaFBUVITQ0FMCdhkyj0SA8PFznOqGhoZDL5VAqlZg8eTIAoKSkBOXl5WJB3rdvH+rr68V1Tp06hVmzZuGrr76Cv79/s/HY2dmJFyW9l1wuf+B/kj5zuiLmRYo5kWptToyRv/bWPVtbW4SGhkKpVIoXNdZoNFAqlUhKSmpxXYVCAU9PT6hUKuzbtw/PP/+8uGzYsGEoKSnRmv/DDz+gf//+OrfVnjrWmnldCXOiG/MiZaxaZrTr1BnysiaBgYEYO3Ys5syZg4KCApw8eRJJSUmYOnWqeGByRUUFAgICxGs9OTk5Yfbs2UhOTsbRo0dRVFSEhIQEREREiCdJ+Pv7IygoSPzx9fUVX+/+Y/iIiB5E37qXnJyMrVu3Yvv27Th//jzmz5+PW7duISEhAQAwY8YMrRMp8vPzkZWVhdLSUnz11VcYO3YsNBoNXnvtNXHOokWL8M033+Ctt97Cv/71L+zevRtbtmxBYmKiwd8nEZknozV1b731Fq5du2aw7e3atQsBAQEYPXo0YmNjMXz4cGzZskVcrlKpUFJSovW98zvvvINnn30WkydPxogRI+Dm5oasrCyDxUREdC99694LL7yAv/71r1i6dCmGDBmCs2fP4tChQ+LJE+Xl5bh06ZI4v6GhAampqRgwYAAmTpwIT09PnDhxQuvQksceewyffvopPvroIwQFBWHlypVYt24d4uLiDP4+icg8tevr15bcPT7NUHr16oXdu3c3u9zHx0fymgqFAhkZGcjIyNDrNUaOHGnwuImo62hN/UhKSmr269Zjx45pPY+MjERxcfEDt/nss8/i2Wef1TsGIrIsneY2YURERETUPDZ1RERERBaATR0RERGRBWBTR0RERGQBjNbUPfnkk7C3tzfW5omIzA7rHhGZkt5NnUajwZo1azBs2DA89thjSElJ0bpw7/0OHDgAd3d3gwRJRGQKrHtE1Jno3dStWrUKb7zxBhwcHODp6Yn09HRe1JKILBrrHhF1Jno3dTt27MDGjRtx+PBhZGdn4/PPP8euXbug0WiMGR8Rkcmw7hFRZ6J3U1deXo7Y2FjxeXR0NGQyGS5evGiUwIiITI11j4g6E72but9++w0KhUJrTC6XQ6VSGTwoIiJzwLpHRJ2J3rcJEwQBM2fOhJ2dnTjW0NCAefPmoXv37uIY761KRJaCdY+IOhO9m7r4+HjJ2PTp0w0aDBGROWHdI6LORO+mbtu2bcaMg4jI7LDuEVFnwjtKEBEREVkANnVEREREFoBNHREREZEFYFNHREREZAHY1BERERFZADZ1RERERBZA70uaUPMEQQAA1NXVNTtHpVLh9u3bqKurg1wu76jQzB7zIsWcSLU1J3d/J+/+jlLz9KljAD+fujAnujEvUsauZWzqDODGjRsAAC8vLxNHQkS63LhxA05OTqYOw6yxjhGZvwfVMpnAP2HbTaPR4OLFi+jRowdkMpnOOXV1dfDy8sKvv/4KR0fHDo7QfDEvUsyJVFtzIggCbty4AQ8PD1hZ8WiTluhTxwB+PnVhTnRjXqSMXcu4p84ArKys0K9fP73mOjo68sOtA/MixZxItSUn3EOnn9bUMYCfT12YE92YFylj1TL+6UpERERkAdjUEREREVkANnUdxM7ODsuWLYOdnZ2pQzErzIsUcyLFnJgP/l9IMSe6MS9Sxs4JT5QgIiIisgDcU0dERERkAdjUEREREVkANnVEREREFoBNHREREZEFYFPXQTIyMuDj4wOFQoHw8HAUFBSYOqQOk5aWhsceeww9evRA3759MWHCBJSUlGjNaWhoQGJiInr37g0HBwdMnjwZVVVVJoq4461evRoymQwLFy4Ux7piTioqKjB9+nT07t0b9vb2GDRoEAoLC8XlgiBg6dKlcHd3h729PaKjo/Hjjz+aMOKuh7WMtawlrGV3mKqWsanrAHv27EFycjKWLVuG06dPIzg4GDExMaiurjZ1aB3i+PHjSExMxDfffIOcnByoVCqMGTMGt27dEucsWrQIn3/+Ofbu3Yvjx4/j4sWLmDRpkgmj7jinTp3C5s2bMXjwYK3xrpaT69evY9iwYZDL5Th48CCKi4vx9ttvo2fPnuKcP//5z1i/fj0yMzORn5+P7t27IyYmBg0NDSaMvOtgLWMtawlr2R0mrWUCGd3QoUOFxMRE8blarRY8PDyEtLQ0E0ZlOtXV1QIA4fjx44IgCEJNTY0gl8uFvXv3inPOnz8vABDy8vJMFWaHuHHjhvDQQw8JOTk5QmRkpPDKK68IgtA1c/L6668Lw4cPb3a5RqMR3NzchL/85S/iWE1NjWBnZyd89NFHHRFil8dapo217HesZb8zZS3jnjoja2pqQlFREaKjo8UxKysrREdHIy8vz4SRmU5tbS0AoFevXgCAoqIiqFQqrRwFBATA29vb4nOUmJiIZ555Ruu9A10zJ5999hnCwsIwZcoU9O3bFyEhIdi6dau4vKysDJWVlVo5cXJyQnh4uMXmxJywlkmxlv2Otex3pqxlbOqM7MqVK1Cr1XB1ddUad3V1RWVlpYmiMh2NRoOFCxdi2LBhCAoKAgBUVlbC1tYWzs7OWnMtPUcff/wxTp8+jbS0NMmyrpiT0tJSbNq0CQ899BAOHz6M+fPnY8GCBdi+fTsAiO+bv0umwVqmjbXsd6xl2kxZy2zatTZRKyUmJuLcuXM4ceKEqUMxqV9//RWvvPIKcnJyoFAoTB2OWdBoNAgLC8Nbb70FAAgJCcG5c+eQmZmJ+Ph4E0dHpI217A7WMilT1jLuqTMyFxcXWFtbS870qaqqgpubm4miMo2kpCR88cUXOHr0KPr16yeOu7m5oampCTU1NVrzLTlHRUVFqK6uxqOPPgobGxvY2Njg+PHjWL9+PWxsbODq6trlcuLu7o4BAwZojQUGBqK8vBwAxPfN3yXTYC37HWvZ71jLpExZy9jUGZmtrS1CQ0OhVCrFMY1GA6VSiYiICBNG1nEEQUBSUhI+/fRT5ObmwtfXV2t5aGgo5HK5Vo5KSkpQXl5usTkaPXo0vvvuO5w9e1b8CQsLQ1xcnPi4q+Vk2LBhkstD/PDDD+jfvz8AwNfXF25ublo5qaurQ35+vsXmxJywlrGW6cJaJmXSWtau0yxILx9//LFgZ2cnfPDBB0JxcbEwd+5cwdnZWaisrDR1aB1i/vz5gpOTk3Ds2DHh0qVL4s/t27fFOfPmzRO8vb2F3NxcobCwUIiIiBAiIiJMGHXHu/eMMUHoejkpKCgQbGxshFWrVgk//vijsGvXLqFbt27Czp07xTmrV68WnJ2dhb///e/CP//5T2H8+PGCr6+vUF9fb8LIuw7WMtYyfbCWma6WsanrIO+++67g7e0t2NraCkOHDhW++eYbU4fUYQDo/Nm2bZs4p76+Xnj55ZeFnj17Ct26dRMmTpwoXLp0yXRBm8D9hbAr5uTzzz8XgoKCBDs7OyEgIEDYsmWL1nKNRiMsWbJEcHV1Fezs7ITRo0cLJSUlJoq2a2ItYy17ENYy09UymSAIQvv29RERERGRqfGYOiIiIiILwKaOiIiIyAKwqSMiIiKyAGzqiIiIiCwAmzoiIiIiC8CmjoiIiMgCsKkjIiIisgBs6oiIiIgsAJs6IiIiIgvApo6IiIjIArCpIyIiIrIAbOqIiIiILMD/AwPilHm1VBTfAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 640x480 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Get the transition probability matrix per density function.\n",
+    "delta_t = .25 # --> small time step\n",
+    "t       = np.arange(0,61+delta_t,delta_t)\n",
+    "Pij     = {'exponential': models['exponential'].getTransitionProbabilityMatrix(t=t),\n",
+    "           'gompertz': models['gompertz'].getTransitionProbabilityMatrix(t=t)}\n",
+    "\n",
+    "fig, axs = plt.subplots(2, 2)  # Create a 2x2 grid of subplots\n",
+    "\n",
+    "# From state 1 to state 1\n",
+    "axs[0, 0].plot(Pij['exponential'].index, Pij['exponential'][(1,1)], color='red', label='exponential')\n",
+    "axs[0, 0].plot(Pij['gompertz'].index, Pij['gompertz'][(1,1)], color='blue', label='gompertz')\n",
+    "axs[0, 0].legend()\n",
+    "axs[0, 0].grid()\n",
+    "axs[0, 0].set_ylabel('P_{i=1,j=1}(t, t+delta_t)')\n",
+    "\n",
+    "# From state 1 to state 2\n",
+    "axs[0, 1].plot(Pij['exponential'].index, Pij['exponential'][(1,2)], color='red', label='exponential')\n",
+    "axs[0, 1].plot(Pij['gompertz'].index, Pij['gompertz'][(1,2)], color='blue', label='gompertz')\n",
+    "axs[0, 1].legend()\n",
+    "axs[0, 1].grid()\n",
+    "axs[0, 1].set_ylabel('P_{i=1,j=2}(t, t+delta_t)')\n",
+    "\n",
+    "# From state 2 to state 1\n",
+    "axs[1, 0].plot(Pij['exponential'].index, Pij['exponential'][(2,1)], color='red', label='exponential')\n",
+    "axs[1, 0].plot(Pij['gompertz'].index, Pij['gompertz'][(2,1)], color='blue', label='gompertz')\n",
+    "axs[1, 0].legend()\n",
+    "axs[1, 0].grid()\n",
+    "axs[1, 0].set_ylabel('P_{i=2,j=1}(t, t+delta_t)')\n",
+    "\n",
+    "# From state 2 to state 2\n",
+    "axs[1, 1].plot(Pij['exponential'].index, Pij['exponential'][(2,2)], color='red', label='exponential')\n",
+    "axs[1, 1].plot(Pij['gompertz'].index, Pij['gompertz'][(2,2)], color='blue', label='gompertz')\n",
+    "axs[1, 1].legend()\n",
+    "axs[1, 1].grid()\n",
+    "axs[1, 1].set_ylabel('P_{i=2,j=2}(t, t+delta_t)')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "c93388c5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         (1, 1)    (1, 2)  (2, 1)  (2, 2)\n",
+      "0.25   0.990315  0.009685     0.0     1.0\n",
+      "0.50   0.990315  0.009685     0.0     1.0\n",
+      "0.75   0.990315  0.009685     0.0     1.0\n",
+      "1.00   0.990315  0.009685     0.0     1.0\n",
+      "1.25   0.990315  0.009685     0.0     1.0\n",
+      "...         ...       ...     ...     ...\n",
+      "60.00  0.990324  0.009676     0.0     1.0\n",
+      "60.25  0.990324  0.009676     0.0     1.0\n",
+      "60.50  0.990324  0.009676     0.0     1.0\n",
+      "60.75  0.990324  0.009676     0.0     1.0\n",
+      "61.00  0.990324  0.009676     0.0     1.0\n",
+      "\n",
+      "[244 rows x 4 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Exponential distribution\n",
+    "print(Pij['exponential'])\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "eb200745",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "         (1, 1)    (1, 2)  (2, 1)  (2, 2)\n",
+      "0.25   0.998504  0.001496     0.0     1.0\n",
+      "0.50   0.998468  0.001532     0.0     1.0\n",
+      "0.75   0.998432  0.001568     0.0     1.0\n",
+      "1.00   0.998394  0.001606     0.0     1.0\n",
+      "1.25   0.998356  0.001644     0.0     1.0\n",
+      "...         ...       ...     ...     ...\n",
+      "60.00  0.658354  0.341646     0.0     1.0\n",
+      "60.25  0.651825  0.348175     0.0     1.0\n",
+      "60.50  0.645206  0.354794     0.0     1.0\n",
+      "60.75  0.638498  0.361502     0.0     1.0\n",
+      "61.00  0.631703  0.368297     0.0     1.0\n",
+      "\n",
+      "[244 rows x 4 columns]\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Exponential distribution\n",
+    "print(Pij['gompertz'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "95d1966a",
+   "metadata": {},
+   "source": [
+    "### State probability over time"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "3b9626a8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the transition probability matrix in their matrix form, for this with set output_format='dictionary'\n",
+    "Pmij = {'exponential': models['exponential'].getTransitionProbabilityMatrix(t=t,output_format='dictionary'),\n",
+    "        'gompertz': models['gompertz'].getTransitionProbabilityMatrix(t=t,output_format='dictionary')}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "f09ac5bd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#%% Plot multi-state degradation models:\n",
+    "models = {key: models[key] for key in ['exponential','gompertz']} #--> We use only 'exponential','gompertz'\n",
+    "plt.figure(figsize=(10,5))\n",
+    "for pdf, model in models.items():\n",
+    "    color = random_color()\n",
+    "    for state in model.MCObj.states:\n",
+    "        plt.plot(t, model.predict(t=t)[state], linestyle='-', label=f'state: {state}, {pdf} error: {models[pdf].MCObj.convergence_info[\"fun\"]}', color=color)\n",
+    "for state in ground_truth_MC.MCObj.states:\n",
+    "    plt.plot(t, ground_truth_MC.predict(t=t)[state], linestyle='--', label=f'state: {state}, ground truth', color='red' if state == ground_truth_MC.MCObj.states[0] else 'blue')\n",
+    "    \n",
+    "S = [models['exponential'].MCObj.s0]\n",
+    "for _ in list(Pij['exponential'].index):\n",
+    "    S.append(S[-1].dot(Pmij['exponential'][_]))\n",
+    "S_exponential = np.array(S)\n",
+    "plt.plot(t,S_exponential,color='gray',linestyle=':',linewidth=3)\n",
+    "\n",
+    "S = [models['gompertz'].MCObj.s0]\n",
+    "for _ in list(Pij['gompertz'].index):\n",
+    "    S.append(S[-1].dot(Pmij['gompertz'][_]))\n",
+    "S_gompertz = np.array(S)\n",
+    "plt.plot(t,S_gompertz,color='gray',linestyle=':',linewidth=3)\n",
+    "    \n",
+    "    \n",
+    "plt.xlabel('Time')\n",
+    "plt.ylabel('State Probability')\n",
+    "plt.grid(True)\n",
+    "plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))\n",
+    "plt.tight_layout()\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.13"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..ca37cd2
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,489 @@
+absl-py==1.4.0
+adjustText==1.0.4
+aiohttp==3.8.4
+aiosignal==1.3.1
+alabaster @ file:///home/ktietz/src/ci/alabaster_1611921544520/work
+alembic==1.13.1
+anaconda-client @ file:///tmp/build/80754af9/anaconda-client_1635342557008/work
+anaconda-navigator==2.1.4
+anaconda-project @ file:///tmp/build/80754af9/anaconda-project_1637161053845/work
+annotated-types==0.6.0
+anyio @ file:///tmp/build/80754af9/anyio_1644463572971/work/dist
+appdirs==1.4.4
+argon2-cffi @ file:///opt/conda/conda-bld/argon2-cffi_1645000214183/work
+argon2-cffi-bindings @ file:///tmp/build/80754af9/argon2-cffi-bindings_1644569679365/work
+arrow @ file:///opt/conda/conda-bld/arrow_1649166651673/work
+astor==0.8.1
+astroid @ file:///tmp/build/80754af9/astroid_1628063140030/work
+astropy @ file:///opt/conda/conda-bld/astropy_1650891077797/work
+asttokens @ file:///opt/conda/conda-bld/asttokens_1646925590279/work
+astunparse==1.6.3
+async-timeout==4.0.2
+atomicwrites==1.4.0
+attrs==23.2.0
+autograd==1.5
+autograd-gamma==0.5.0
+Automat @ file:///tmp/build/80754af9/automat_1600298431173/work
+autopep8 @ file:///opt/conda/conda-bld/autopep8_1639166893812/work
+Babel @ file:///tmp/build/80754af9/babel_1620871417480/work
+backcall @ file:///home/ktietz/src/ci/backcall_1611930011877/work
+backports.functools-lru-cache @ file:///tmp/build/80754af9/backports.functools_lru_cache_1618170165463/work
+backports.tempfile @ file:///home/linux1/recipes/ci/backports.tempfile_1610991236607/work
+backports.weakref==1.0.post1
+bcrypt==4.1.2
+beautifulsoup4 @ file:///opt/conda/conda-bld/beautifulsoup4_1650462163268/work
+bibtexparser==1.4.0
+binaryornot @ file:///tmp/build/80754af9/binaryornot_1617751525010/work
+bitarray @ file:///tmp/build/80754af9/bitarray_1648739490228/work
+bkcharts==0.2
+black==19.10b0
+bleach @ file:///opt/conda/conda-bld/bleach_1641577558959/work
+bokeh @ file:///tmp/build/80754af9/bokeh_1638362822154/work
+boto3 @ file:///opt/conda/conda-bld/boto3_1649078879353/work
+botocore @ file:///opt/conda/conda-bld/botocore_1649076662316/work
+Bottleneck @ file:///tmp/build/80754af9/bottleneck_1648028898966/work
+box2d-py==2.3.5
+brotlipy==0.7.0
+cachetools==5.3.0
+certifi==2023.7.22
+cffi @ file:///opt/conda/conda-bld/cffi_1642701102775/work
+chardet @ file:///tmp/build/80754af9/chardet_1607706775000/work
+charset-normalizer==2.0.12
+chatGPT @ git+https://github.com/mmabrouk/chatgpt-wrapper@d5329d615227d74700dfa21376a19f843465ec46
+click==8.1.7
+cloudpickle==2.2.1
+clyent==1.2.2
+cmake==3.26.4
+colorama @ file:///tmp/build/80754af9/colorama_1607707115595/work
+colorcet @ file:///tmp/build/80754af9/colorcet_1611168489822/work
+colorlog==6.8.2
+colourmap==1.1.16
+conda==4.12.0
+conda-build==3.21.8
+conda-content-trust @ file:///tmp/build/80754af9/conda-content-trust_1617045594566/work
+conda-pack @ file:///tmp/build/80754af9/conda-pack_1611163042455/work
+conda-package-handling @ file:///tmp/build/80754af9/conda-package-handling_1649105784853/work
+conda-repo-cli @ file:///tmp/build/80754af9/conda-repo-cli_1620168426516/work
+conda-token @ file:///tmp/build/80754af9/conda-token_1620076980546/work
+conda-verify==3.4.2
+constantly==15.1.0
+contourpy==1.0.6
+cookiecutter @ file:///opt/conda/conda-bld/cookiecutter_1649151442564/work
+copulas==0.9.1
+cryptography @ file:///tmp/build/80754af9/cryptography_1633520369886/work
+cssselect==1.1.0
+cycler==0.11.0
+Cython @ file:///tmp/build/80754af9/cython_1647850345254/work
+cytoolz==0.11.0
+daal4py==2021.5.0
+dask @ file:///opt/conda/conda-bld/dask-core_1647268715755/work
+dataclasses-json==0.5.7
+datashader @ file:///tmp/build/80754af9/datashader_1623782308369/work
+datashape==0.5.4
+datazets==0.1.9
+deap==1.4.1
+debugpy @ file:///tmp/build/80754af9/debugpy_1637091799509/work
+decorator @ file:///opt/conda/conda-bld/decorator_1643638310831/work
+defusedxml @ file:///tmp/build/80754af9/defusedxml_1615228127516/work
+diff-match-patch @ file:///Users/ktietz/demo/mc3/conda-bld/diff-match-patch_1630511840874/work
+dill==0.3.8
+distributed @ file:///opt/conda/conda-bld/distributed_1647271944416/work
+distro==1.9.0
+dm-tree==0.1.8
+dnspython==2.3.0
+docker-pycreds==0.4.0
+docopt==0.6.2
+docutils @ file:///tmp/build/80754af9/docutils_1620827980776/work
+email-validator==1.3.1
+entrypoints @ file:///tmp/build/80754af9/entrypoints_1649926439650/work
+et-xmlfile==1.1.0
+exceptiongroup==1.1.3
+executing @ file:///opt/conda/conda-bld/executing_1646925071911/work
+Farama-Notifications==0.0.4
+fastjsonschema @ file:///tmp/build/80754af9/python-fastjsonschema_1620414857593/work/dist
+filelock==3.12.4
+flake8 @ file:///tmp/build/80754af9/flake8_1620776156532/work
+Flask==2.2.3
+flatbuffers==23.5.26
+fonttools==4.38.0
+formulaic==0.5.2
+frozendict==2.3.8
+frozenlist==1.3.3
+fsspec==2023.9.2
+future==0.18.3
+gast==0.4.0
+gensim==4.3.1
+gitdb==4.0.11
+GitPython==3.1.43
+glob2 @ file:///home/linux1/recipes/ci/glob2_1610991677669/work
+gmpy2 @ file:///tmp/build/80754af9/gmpy2_1645438755360/work
+google-api-core @ file:///C:/ci/google-api-core-split_1613980333946/work
+google-auth==2.16.0
+google-auth-oauthlib==1.0.0
+google-cloud-core @ file:///tmp/build/80754af9/google-cloud-core_1625077425256/work
+google-cloud-storage @ file:///tmp/build/80754af9/google-cloud-storage_1601307969662/work
+google-crc32c @ file:///tmp/build/80754af9/google-crc32c_1612242928148/work
+google-pasta==0.2.0
+google-resumable-media @ file:///tmp/build/80754af9/google-resumable-media_1624367812531/work
+googleapis-common-protos @ file:///tmp/build/80754af9/googleapis-common-protos-feedstock_1617957652138/work
+graphviz==0.20.1
+greenlet==2.0.1
+grpcio==1.51.1
+gym==0.26.2
+gym-notices==0.0.8
+gymnasium==0.29.1
+h11==0.14.0
+h5py==3.8.0
+HeapDict @ file:///Users/ktietz/demo/mc3/conda-bld/heapdict_1630598515714/work
+holoviews @ file:///opt/conda/conda-bld/holoviews_1645454331194/work
+html5lib==1.1
+httpcore==1.0.5
+httpx==0.27.0
+hvplot @ file:///tmp/build/80754af9/hvplot_1627305124151/work
+hyperlink @ file:///tmp/build/80754af9/hyperlink_1610130746837/work
+idna==3.4
+imagecodecs @ file:///tmp/build/80754af9/imagecodecs_1635529108216/work
+imageio @ file:///tmp/build/80754af9/imageio_1617700267927/work
+imagesize @ file:///tmp/build/80754af9/imagesize_1637939814114/work
+importlib-metadata==6.8.0
+importlib-resources==6.1.0
+incremental @ file:///tmp/build/80754af9/incremental_1636629750599/work
+inflection==0.5.1
+iniconfig @ file:///home/linux1/recipes/ci/iniconfig_1610983019677/work
+intake @ file:///opt/conda/conda-bld/intake_1647436631684/work
+interface-meta==1.3.0
+intervaltree @ file:///Users/ktietz/demo/mc3/conda-bld/intervaltree_1630511889664/work
+ipykernel @ file:///tmp/build/80754af9/ipykernel_1647000773790/work/dist/ipykernel-6.9.1-py3-none-any.whl
+ipython==8.12.3
+ipython-genutils @ file:///tmp/build/80754af9/ipython_genutils_1606773439826/work
+ipython-tikzmagic @ git+https://github.com/mkrphys/ipython-tikzmagic.git@f9357cc86ea5848947f3d189ee736031bb64890d
+ipywidgets @ file:///tmp/build/80754af9/ipywidgets_1634143127070/work
+isort @ file:///tmp/build/80754af9/isort_1628603791788/work
+itemadapter @ file:///tmp/build/80754af9/itemadapter_1626442940632/work
+itemloaders @ file:///opt/conda/conda-bld/itemloaders_1646805235997/work
+itsdangerous==2.1.2
+jdcal @ file:///Users/ktietz/demo/mc3/conda-bld/jdcal_1630584345063/work
+jedi @ file:///tmp/build/80754af9/jedi_1644297102865/work
+jeepney @ file:///tmp/build/80754af9/jeepney_1627537048313/work
+Jinja2==3.1.2
+jinja2-time @ file:///opt/conda/conda-bld/jinja2-time_1649251842261/work
+jmespath @ file:///Users/ktietz/demo/mc3/conda-bld/jmespath_1630583964805/work
+joblib==1.2.0
+json5 @ file:///tmp/build/80754af9/json5_1624432770122/work
+jsonpatch==1.33
+jsonpointer==2.4
+jsonschema @ file:///tmp/build/80754af9/jsonschema_1650025953207/work
+jupyter @ file:///tmp/build/80754af9/jupyter_1607700846274/work
+jupyter-client @ file:///tmp/build/80754af9/jupyter_client_1616770841739/work
+jupyter-console @ file:///tmp/build/80754af9/jupyter_console_1616615302928/work
+jupyter-server @ file:///opt/conda/conda-bld/jupyter_server_1644494914632/work
+jupyter_core==5.7.2
+jupyterlab @ file:///opt/conda/conda-bld/jupyterlab_1647445413472/work
+jupyterlab-pygments @ file:///tmp/build/80754af9/jupyterlab_pygments_1601490720602/work
+jupyterlab-server @ file:///opt/conda/conda-bld/jupyterlab_server_1644500396812/work
+jupyterlab-widgets @ file:///tmp/build/80754af9/jupyterlab_widgets_1609884341231/work
+keras==2.14.0
+keyring @ file:///tmp/build/80754af9/keyring_1638531355686/work
+kiwisolver==1.4.4
+langchain==0.0.128
+langchain-community==0.0.33
+langchain-core==0.1.43
+langchain-text-splitters==0.0.1
+langsmith==0.1.48
+lazy-object-proxy @ file:///tmp/build/80754af9/lazy-object-proxy_1616529027849/work
+libarchive-c @ file:///tmp/build/80754af9/python-libarchive-c_1617780486945/work
+libclang==15.0.6.1
+lifelines==0.27.4
+lit==16.0.6
+llvmlite==0.39.1
+locket @ file:///tmp/build/80754af9/locket_1647006009810/work
+lxml==4.9.2
+Mako==1.3.2
+Markdown==3.4.1
+markdown-it-py==2.2.0
+MarkupSafe==2.1.2
+marshmallow==3.19.0
+marshmallow-enum==1.5.1
+matplotlib==3.6.2
+matplotlib-inline @ file:///tmp/build/80754af9/matplotlib-inline_1628242447089/work
+mccabe==0.6.1
+mdurl==0.1.2
+mistune==3.0.2
+mkl-fft==1.3.1
+mkl-random @ file:///tmp/build/80754af9/mkl_random_1626186066731/work
+mkl-service==2.4.0
+ml-dtypes==0.2.0
+mock @ file:///tmp/build/80754af9/mock_1607622725907/work
+mplfinance==0.12.10b0
+mpmath==1.3.0
+msgpack @ file:///tmp/build/80754af9/msgpack-python_1612287166301/work
+multidict==6.0.4
+multipledispatch @ file:///tmp/build/80754af9/multipledispatch_1607574243360/work
+multiprocess==0.70.15
+multitasking==0.0.11
+munkres==1.1.4
+mypy-extensions==0.4.3
+names==0.3.0
+navigator-updater==0.2.1
+nbclassic @ file:///opt/conda/conda-bld/nbclassic_1644943264176/work
+nbclient @ file:///tmp/build/80754af9/nbclient_1650290509967/work
+nbconvert==7.16.3
+nbformat==5.10.4
+nest-asyncio @ file:///tmp/build/80754af9/nest-asyncio_1649847906199/work
+networkx==3.1
+nltk==3.8.1
+nose @ file:///opt/conda/conda-bld/nose_1642704612149/work
+notebook @ file:///tmp/build/80754af9/notebook_1645002532094/work
+numba==0.56.4
+numexpr @ file:///tmp/build/80754af9/numexpr_1640689833592/work
+numpy==1.23.5
+numpy-indexed==0.3.5
+numpydoc @ file:///opt/conda/conda-bld/numpydoc_1643788541039/work
+nvidia-cublas-cu11==11.11.3.6
+nvidia-cublas-cu12==12.1.3.1
+nvidia-cuda-cupti-cu11==11.8.87
+nvidia-cuda-cupti-cu12==12.1.105
+nvidia-cuda-nvcc-cu11==11.8.89
+nvidia-cuda-nvrtc-cu11==11.7.99
+nvidia-cuda-nvrtc-cu12==12.1.105
+nvidia-cuda-runtime-cu11==11.8.89
+nvidia-cuda-runtime-cu12==12.1.105
+nvidia-cudnn-cu11==8.7.0.84
+nvidia-cudnn-cu12==8.9.2.26
+nvidia-cufft-cu11==10.9.0.58
+nvidia-cufft-cu12==11.0.2.54
+nvidia-curand-cu11==10.3.0.86
+nvidia-curand-cu12==10.3.2.106
+nvidia-cusolver-cu11==11.4.1.48
+nvidia-cusolver-cu12==11.4.5.107
+nvidia-cusparse-cu11==11.7.5.86
+nvidia-cusparse-cu12==12.1.0.106
+nvidia-nccl-cu11==2.16.5
+nvidia-nccl-cu12==2.20.5
+nvidia-nvjitlink-cu12==12.2.140
+nvidia-nvtx-cu11==11.7.91
+nvidia-nvtx-cu12==12.1.105
+nvidia-pyindex==1.0.9
+nvidia-tensorrt==99.0.0
+oauthlib==3.2.2
+olefile @ file:///Users/ktietz/demo/mc3/conda-bld/olefile_1629805411829/work
+openai==0.27.2
+opencv-python==4.8.0.76
+openpyxl==3.0.10
+opt-einsum==3.3.0
+optuna==3.6.0
+orjson==3.10.1
+outcome==1.2.0
+packaging==23.2
+pandas==1.5.2
+pandas-datareader==0.10.0
+pandocfilters @ file:///opt/conda/conda-bld/pandocfilters_1643405455980/work
+panel @ file:///opt/conda/conda-bld/panel_1650637168846/work
+param @ file:///tmp/build/80754af9/param_1636647414893/work
+paramiko==3.4.0
+parsel @ file:///tmp/build/80754af9/parsel_1646722533460/work
+parso @ file:///opt/conda/conda-bld/parso_1641458642106/work
+partd @ file:///opt/conda/conda-bld/partd_1647245470509/work
+pathos==0.3.1
+pathspec==0.7.0
+patsy==0.5.3
+pca==2.0.5
+pep8==1.7.1
+pexpect @ file:///tmp/build/80754af9/pexpect_1605563209008/work
+pickleshare @ file:///tmp/build/80754af9/pickleshare_1606932040724/work
+Pillow==9.3.0
+pipreqs==0.5.0
+pkginfo @ file:///tmp/build/80754af9/pkginfo_1643162084911/work
+platformdirs==4.2.0
+playwright==1.32.1
+plotly @ file:///opt/conda/conda-bld/plotly_1646671701182/work
+pluggy @ file:///tmp/build/80754af9/pluggy_1648024445381/work
+ply==3.11
+pox==0.3.3
+poyo @ file:///tmp/build/80754af9/poyo_1617751526755/work
+ppft==1.7.6.7
+prettytable==3.10.0
+progressbar==2.5
+prometheus-client @ file:///opt/conda/conda-bld/prometheus_client_1643788673601/work
+prompt-toolkit==3.0.43
+Protego @ file:///tmp/build/80754af9/protego_1598657180827/work
+protobuf==4.24.4
+psutil==5.9.6
+ptyprocess @ file:///tmp/build/80754af9/ptyprocess_1609355006118/work/dist/ptyprocess-0.7.0-py2.py3-none-any.whl
+pure-eval @ file:///opt/conda/conda-bld/pure_eval_1646925070566/work
+py @ file:///opt/conda/conda-bld/py_1644396412707/work
+pyarrow==10.0.1
+pyasn1==0.4.8
+pyasn1-modules==0.2.8
+pycodestyle @ file:///tmp/build/80754af9/pycodestyle_1615748559966/work
+pycosat==0.6.3
+pycparser @ file:///tmp/build/80754af9/pycparser_1636541352034/work
+pyct @ file:///tmp/build/80754af9/pyct_1613411549454/work
+pycurl==7.44.1
+pydantic==1.10.7
+pydantic_core==2.18.1
+PyDispatcher==2.0.5
+pydocstyle @ file:///tmp/build/80754af9/pydocstyle_1621600989141/work
+pyee==9.0.4
+pyerfa @ file:///tmp/build/80754af9/pyerfa_1621556109336/work
+pyflakes @ file:///tmp/build/80754af9/pyflakes_1617200973297/work
+pygame==2.5.2
+Pygments==2.14.0
+PyHamcrest @ file:///tmp/build/80754af9/pyhamcrest_1615748656804/work
+PyJWT @ file:///tmp/build/80754af9/pyjwt_1619682484438/work
+pylint @ file:///tmp/build/80754af9/pylint_1627536788603/work
+pyls-spyder==0.4.0
+pymdptoolbox==4.0b3
+PyNaCl==1.5.0
+pyodbc @ file:///tmp/build/80754af9/pyodbc_1647425888968/work
+pyOpenSSL @ file:///tmp/build/80754af9/pyopenssl_1635333100036/work
+pyparsing==3.1.1
+PyPDF2==3.0.1
+pyperclip==1.8.2
+PyQt5-sip==12.11.0
+pyrsistent @ file:///tmp/build/80754af9/pyrsistent_1636110951836/work
+PySocks @ file:///tmp/build/80754af9/pysocks_1605305812635/work
+pyswarms==1.3.0
+pytest==7.1.1
+python-dateutil @ file:///tmp/build/80754af9/python-dateutil_1626374649649/work
+python-frontmatter==1.0.0
+python-lsp-black @ file:///tmp/build/80754af9/python-lsp-black_1634232156041/work
+python-lsp-jsonrpc==1.0.0
+python-lsp-server==1.2.4
+python-slugify @ file:///tmp/build/80754af9/python-slugify_1620405669636/work
+python-snappy @ file:///tmp/build/80754af9/python-snappy_1610133040135/work
+pytz==2023.3.post1
+pyviz-comms @ file:///tmp/build/80754af9/pyviz_comms_1623747165329/work
+PyWavelets @ file:///tmp/build/80754af9/pywavelets_1648710015787/work
+pyxdg @ file:///tmp/build/80754af9/pyxdg_1603822279816/work
+PyYAML==6.0.1
+pyzmq @ file:///tmp/build/80754af9/pyzmq_1638434985866/work
+QDarkStyle @ file:///tmp/build/80754af9/qdarkstyle_1617386714626/work
+qstylizer @ file:///tmp/build/80754af9/qstylizer_1617713584600/work/dist/qstylizer-0.1.10-py2.py3-none-any.whl
+QtAwesome @ file:///tmp/build/80754af9/qtawesome_1637160816833/work
+qtconsole @ file:///opt/conda/conda-bld/qtconsole_1649078897110/work
+QtPy @ file:///opt/conda/conda-bld/qtpy_1649073884068/work
+queuelib==1.5.0
+regex==2023.3.23
+reportlab==4.0.5
+requests==2.31.0
+requests-file @ file:///Users/ktietz/demo/mc3/conda-bld/requests-file_1629455781986/work
+requests-oauthlib==1.3.1
+rich==13.3.3
+rope @ file:///opt/conda/conda-bld/rope_1643788605236/work
+rsa==4.9
+Rtree @ file:///tmp/build/80754af9/rtree_1618420843093/work
+ruamel-yaml-conda @ file:///tmp/build/80754af9/ruamel_yaml_1616016711199/work
+s3transfer @ file:///tmp/build/80754af9/s3transfer_1626435152308/work
+scatterd==1.3.7
+scikit-image @ file:///tmp/build/80754af9/scikit-image_1648214171611/work
+scikit-learn==1.3.1
+scikit-learn-intelex==2021.20220215.212715
+scipy==1.9.3
+Scrapy @ file:///tmp/build/80754af9/scrapy_1646837771788/work
+seaborn==0.12.2
+SecretStorage @ file:///tmp/build/80754af9/secretstorage_1614022780358/work
+selenium==4.11.2
+seleniumprocessor==0.1.5
+Send2Trash @ file:///tmp/build/80754af9/send2trash_1632406701022/work
+sentry-sdk==1.45.0
+service-identity @ file:///Users/ktietz/demo/mc3/conda-bld/service_identity_1629460757137/work
+setproctitle==1.3.3
+Shimmy==1.2.1
+sip==4.19.13
+six @ file:///tmp/build/80754af9/six_1644875935023/work
+smart-open==6.3.0
+smmap==5.0.1
+sniffio==1.3.1
+snowballstemmer @ file:///tmp/build/80754af9/snowballstemmer_1637937080595/work
+sortedcollections @ file:///tmp/build/80754af9/sortedcollections_1611172717284/work
+sortedcontainers @ file:///tmp/build/80754af9/sortedcontainers_1623949099177/work
+soupsieve @ file:///tmp/build/80754af9/soupsieve_1636706018808/work
+spatialite==0.0.3
+Sphinx @ file:///opt/conda/conda-bld/sphinx_1643644169832/work
+sphinxcontrib-applehelp @ file:///home/ktietz/src/ci/sphinxcontrib-applehelp_1611920841464/work
+sphinxcontrib-devhelp @ file:///home/ktietz/src/ci/sphinxcontrib-devhelp_1611920923094/work
+sphinxcontrib-htmlhelp @ file:///tmp/build/80754af9/sphinxcontrib-htmlhelp_1623945626792/work
+sphinxcontrib-jsmath @ file:///home/ktietz/src/ci/sphinxcontrib-jsmath_1611920942228/work
+sphinxcontrib-qthelp @ file:///home/ktietz/src/ci/sphinxcontrib-qthelp_1611921055322/work
+sphinxcontrib-serializinghtml @ file:///tmp/build/80754af9/sphinxcontrib-serializinghtml_1624451540180/work
+spyder @ file:///tmp/build/80754af9/spyder_1636479868270/work
+spyder-kernels @ file:///tmp/build/80754af9/spyder-kernels_1634236920897/work
+SQLAlchemy==1.4.47
+stable-baselines3==2.1.0
+stack-data @ file:///opt/conda/conda-bld/stack_data_1646927590127/work
+statsmodels==0.14.0
+surpyval==0.10.9
+swig==4.1.1
+sympy==1.12
+tables @ file:///tmp/build/80754af9/pytables_1607975397488/work
+tabulate==0.8.9
+TBB==0.2
+tblib @ file:///Users/ktietz/demo/mc3/conda-bld/tblib_1629402031467/work
+tenacity==8.2.2
+tensorboard==2.14.1
+tensorboard-data-server==0.7.1
+tensorboard-plugin-wit==1.8.1
+tensorflow==2.14.0
+tensorflow-estimator==2.14.0
+tensorflow-io-gcs-filesystem==0.30.0
+tensorflow-probability==0.22.0
+tensorrt==8.5.3.1
+tensorrt-cu12==10.0.1
+tensorrt-cu12-bindings==10.0.1
+tensorrt-cu12-libs==10.0.1
+termcolor==2.2.0
+terminado @ file:///tmp/build/80754af9/terminado_1644322582718/work
+testpath @ file:///tmp/build/80754af9/testpath_1624638946665/work
+text-unidecode @ file:///Users/ktietz/demo/mc3/conda-bld/text-unidecode_1629401354553/work
+textdistance @ file:///tmp/build/80754af9/textdistance_1612461398012/work
+threadpoolctl==3.1.0
+three-merge @ file:///tmp/build/80754af9/three-merge_1607553261110/work
+tifffile @ file:///tmp/build/80754af9/tifffile_1627275862826/work
+tiktoken==0.3.3
+tinycss @ file:///tmp/build/80754af9/tinycss_1617713798712/work
+tinycss2==1.2.1
+tldextract @ file:///opt/conda/conda-bld/tldextract_1646638314385/work
+tls-client==0.2
+toml @ file:///tmp/build/80754af9/toml_1616166611790/work
+tomli @ file:///tmp/build/80754af9/tomli_1637314251069/work
+toolz @ file:///tmp/build/80754af9/toolz_1636545406491/work
+torch==1.8.1+cu111
+torchaudio==0.8.1
+torchvision==0.9.1+cu111
+tornado @ file:///tmp/build/80754af9/tornado_1606942317143/work
+tqdm==4.66.1
+trading212api==0.1.1
+traitlets==5.14.2
+trio==0.22.2
+trio-websocket==0.10.3
+triton==2.3.0
+Twisted @ file:///tmp/build/80754af9/twisted_1646835200521/work
+typed-ast @ file:///tmp/build/80754af9/typed-ast_1624953673314/work
+typing-inspect==0.8.0
+typing_extensions==4.11.0
+tzdata==2023.3
+ujson @ file:///tmp/build/80754af9/ujson_1648025916270/work
+Unidecode @ file:///tmp/build/80754af9/unidecode_1614712377438/work
+urllib3==2.0.6
+w3lib @ file:///Users/ktietz/demo/mc3/conda-bld/w3lib_1629359764703/work
+wandb==0.16.6
+watchdog @ file:///tmp/build/80754af9/watchdog_1638367282716/work
+wcwidth @ file:///Users/ktietz/demo/mc3/conda-bld/wcwidth_1629357192024/work
+webencodings==0.5.1
+websocket-client @ file:///tmp/build/80754af9/websocket-client_1614803975924/work
+Werkzeug==2.2.2
+widgetsnbextension @ file:///tmp/build/80754af9/widgetsnbextension_1644992802045/work
+wrapt==1.14.1
+wsproto==1.2.0
+wurlitzer @ file:///tmp/build/80754af9/wurlitzer_1638368168359/work
+xarray @ file:///opt/conda/conda-bld/xarray_1639166117697/work
+xlrd @ file:///tmp/build/80754af9/xlrd_1608072521494/work
+XlsxWriter @ file:///opt/conda/conda-bld/xlsxwriter_1649073856329/work
+yapf @ file:///tmp/build/80754af9/yapf_1615749224965/work
+yarg==0.1.9
+yarl==1.8.2
+yfinance==0.2.28
+zict==2.0.0
+zipp==3.17.0
+zope.interface @ file:///tmp/build/80754af9/zope.interface_1625036153595/work
diff --git a/scripts/.DS_Store b/scripts/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..78a97ba160430f42981d3e88827e5222d36811d1
GIT binary patch
literal 8196
zcmZQzU|@7AO)+F(kYHe7;9!8z0^AH(0Z1N%F(jFwA}k>D7#IW?81fm)7~&a{88R3W
zp>m_tXb6mkz-S1JhQMeDjE2DA3IRrlb2xC+`w-btax?@+LtsRP0H}OWfVAxy9H4Xq
zga%15FfuTJy8w&~44^ImIE)y<{Qw4#97rpO25AM+Agv6HAQspRuvP{}s8&XBHw2_l
z0BR0cI|C!wW{@~oI|C!wW(EdEh;{}>sLhPf9ttBwI|Cy`I|C!wcCeA7#ApbNh5%X!
zfU=JeLoP!iLlHwZO8-5RA&()Rp@gB5p@1Qkp*X3$xF9JfKZ${XVMkIyPG)h5fx$IK
zCT12^Hg<MSc5e3A;Eeq8;F83W(qgB?qG%8=BtJhV3C2!L3d>9_j~5Ve&d)1J%*;zI
z0x1d3Oi4{jEQ$%w%uC5Hcgio#ODP8Hg-UR8a&X2ANK{u_7+B~in3!1B>L^rO8X4#)
zm>8SY)^c))D(hPZ#b@W_=H+)m{01u`7<eIkIN8m>z(AB=bBfEHA%10MgZcFa)UO<z
zoZJ#&;SrJX0s^JQsX?hZi6xn3sV<2nsm1XE{KXmh<(|p;c>zVKWtpkv;mP?qrMY><
z@dAR$i8;xoIf*5yjyXBOnN_L95hbY=B_LK*aeh&WGgx6nW^#TWNGx7J2&CV?pd>Rt
zuQ)8Vs5mn}kCSs9kEoQqvWBjaxs9W%Z{QVPK7Ii~Ax_Sy%#_r;lFYQs)S}Sx%#@Oh
z$i(90)V!3;y!7z0%;L<XoYauK#N1SY6P%o2O=98_5)q|InT4g9C6xlo92{2!`1pA_
zWhCS{1-5d;q$HN4`sSyA3`_y5SCEn5j0TB17o{eaq^59iLNusKsB;P=a)cCTR;5Bj
zv^aG*1&TRCvNQ8iz#<a*oQ50%DV(7>iAkwB5FryzGY$c7&hRpb#~^~1oYowIj5?eV
z$@#gtsd**E5MetB2M&Qf9C0AqeG-dH{0ma^QX#H#l97;z1c^JQq@<>Ba9rVabNBG{
zl90d^2vNluiAAaY<$0+^0+*ob{k$Y3z%iFtlnOH6H6^nozX&QB1eO%Y%qz<*Nd(0O
zB!zQua40)yKvEVsV3i#VAUpw3O(w~p!(hkY#t_Aj%#g=W&d|fq%h1O#mth&hMuzPS
z2N_N>oMX7aaFO8>!)=Bq49^&zGrVB<$nc5b3&U4NCPr>XaYhM7Nk%0`Wkyv-HAZbl
z6Gl@;b4CkBTShlVcScV}FUA1INX96}7{*w}RK`5Ue8wWiV#XTAR>n5Q4#rN#8H@`V
zS2M0*T+6tPaS!7$#&e7}8E-S*VZ6)ujPVEKPsU$N%uHfT;!F}ul1xfW>P!X@w=+R2
zSB5AEA4W16k&ttsr36zfwwxpD=I&uUAUWqI4<xS$i-^jBGLV_I13aBUQYI`hA}4cj
zx<<(j;B*a+a`Xf#CN3c<CCw=tnwgi9T7fGC3b2EcIL8%`YIy}tSpimo6ix_NMU_)l
zfK9-gljDk{xP%y|maGmaGYT+)73=BCatbgDByw<qxyD+uoC1tcj=2RVrvQsUF()TP
zr!A*Fr@#qL0S2&AM<-cX0Z<mgnP?d}7_cYVg$%10HZbg9IKps};Tpqjh6fDq8GbPQ
zV`O3EV-#bQV3cN*VU%T5W7J^OV$^2T0Vh*SMk_{ZMi)j`Mt4RJMlZ%-#!$v^#t6np
z#w5lR##F{M#(c&?#$v`2#!|*Q#(Ks^#wNxV#$LvL#)*uR7$-AMVVujj2$J;R3DOh7
zhmnk{iA|7Y!9{sF`FZK!CMQh$C=Ct)W-!Sh0qXy|GBDs8|A(j=B}YSGGz5la2r#m^
z1iLulDIr09ZBTzY0qT8FGXc~cX9V@jA^Jc{KwW!Ke*#29yW?O5Agv%Va95m>fdQm-
Z;06Ll>wi!zf?F`~M(b$(4+@hJg#lLUMp*y=

literal 0
HcmV?d00001

diff --git a/scripts/DataHandlingManager.py b/scripts/DataHandlingManager.py
new file mode 100644
index 0000000..f8afa6d
--- /dev/null
+++ b/scripts/DataHandlingManager.py
@@ -0,0 +1,120 @@
+from aux_functions import load_network_data, load_inspection_data, getFrequencyTable
+import pandas as pd
+from copy import copy
+
+class DataHandlingManager:
+    def __init__(self,**kwargs):
+        self.system = self.getSystemData(path=kwargs.get('system_database',''))
+        self.inspections = self.getInspectionData(path=kwargs.get('inspection_database',''))
+
+    def getSystemData(self, path):
+        """
+        Loads system network data from a specified database path.
+    
+        Args:
+        - path (str): The file path to the database.
+    
+        Returns:
+        - DataFrame: A DataFrame containing the loaded system network data.
+        """
+        return load_network_data(db_path=path)
+    
+    def getInspectionData(self, path):
+        """
+        Loads inspection data from a specified database path, filtering by the system network.
+    
+        Args:
+        - path (str): The file path to the database.
+    
+        Returns:
+        - DataFrame: A DataFrame containing the loaded inspection data filtered by the system network.
+        """
+        return load_inspection_data(db_path=path, network=self.system)
+    
+    def get_lifetime_data(self, code, cohort, flag='most_critical', add_collapse=False, cut_max_age=None, cut_max_age_flag='low', location=None):
+        """
+        Retrieves lifetime data for pipes within a specified cohort, filtering and processing the data based on various criteria.
+    
+        Args:
+        - code (str): The code used to identify specific data.
+        - cohort (int): The cohort number to filter pipes by.
+        - severities (list, optional): A list of severities to consider. Defaults to [1,2,3,4,5,6].
+        - flag (str, optional): Criteria to filter the data ('most_critical' or 'over_length'). Defaults to 'most_critical'.
+        - add_collapse (bool, optional): Whether to add collapse data. Defaults to False.
+        - cut_max_age (float, optional): The maximum age to filter pipes by. None if not filtering by age.
+        - cut_max_age_flag (str, optional): Specifies whether to filter by ages lower than or higher than `cut_max_age` ('low' or 'up'). Defaults to 'low'.
+        - location (str, optional): The location to filter pipes by. None if not filtering by location.
+    
+        Returns:
+        - DataFrame: A DataFrame containing processed pipe data, filtered and sorted according to the specified parameters.
+        """
+        # Selecting the relevant pipes within the cohort from the system
+        cohort_pipes = self.system[self.system['cohort'] == cohort]['pipe_id']
+        df = self.inspections[self.inspections['pipe_id'].isin(cohort_pipes)]
+        
+        # Merging with system DataFrame to get additional attributes
+        df = df.merge(self.system[['pipe_id', 'construction_year', 'cohort', 'length', 'width']], on='pipe_id')
+        
+        # Converting dates to datetime objects and calculating pipe_age
+        df['inspection_date'] = pd.to_datetime(df['inspection_date'])
+        df['construction_year'] = pd.to_datetime(df['construction_year'].astype(int).astype(str) + '-01-01')
+        df['pipe_age'] = (df['inspection_date'] - df['construction_year']).dt.total_seconds() / (365.25 * 24 * 60 * 60)
+        
+        # Keeping only non-negative pipe ages
+        df = df[df['pipe_age'] >= 0]
+        
+        # Filter by cut max age
+        if cut_max_age:
+            if cut_max_age_flag == 'low':
+                df = df[df['pipe_age'] <= cut_max_age]
+            elif cut_max_age_flag == 'up':
+                df = df[df['pipe_age'] > cut_max_age]
+    
+        df2 = pd.DataFrame()
+        if len(df) > 0:
+            # Filter by location
+            if location:
+                df = df[df['location'] == location]
+            # Converting codes not matching the input code to level 1
+            non_matching_codes = df['code'] != code
+            df.loc[non_matching_codes, 'code'] = code
+            df.loc[non_matching_codes, 'damage_class'] = 1
+            # Add failure data
+            if add_collapse:
+                df.loc[self.inspections['code'] == 'BAC', 'damage_class'] = 6
+            if flag == 'most_critical':
+                # Identifying the most critical severity for each inspection
+                grouped_inspection = df.groupby('inspection_id')
+                df2 = grouped_inspection.agg({
+                    'pipe_id': 'first',
+                    'pipe_age': 'first',
+                    'damage_class': 'max'
+                }).reset_index()
+                df2.rename(columns={'damage_class': 'severity'}, inplace=True)
+            elif flag == 'over_length':
+                df2 = df[['pipe_id', 'pipe_age', 'damage_class']]
+                df2.rename(columns={'damage_class': 'severity'}, inplace=True)
+            df2 = df2.sort_values(by='pipe_age', ascending=True).reset_index(drop=True)
+            
+        # Change format for higher compatibility:
+        df2.rename(columns={'pipe_age': 'time', 'severity': 'state'}, inplace=True)
+        df2.drop(['inspection_id', 'pipe_id'], axis=1, inplace=True)
+        df2 = df2.sort_values(by='time', ascending=True).reset_index(drop=True)
+        df2 = df2.groupby(['time', 'state']).size().reset_index(name='count')
+        df2.set_index('time', inplace=True)
+        
+        # Change state 6 for "F"
+        df2.loc[df2['state'] == 6, 'state'] = 'F'
+
+        return df2
+
+
+if __name__ == "__main__":
+    args = {
+        'system_database':'/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/datasets/raw/breda.db',
+        'inspection_database':'/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/datasets/raw/breda.db',
+        } 
+    dh = DataHandlingManager(**args)
+    df = dh.get_lifetime_data(code='BAF',cohort='CMW',add_collapse=True)
+    ft = getFrequencyTable(y=copy(df),states=[1,2,3,4,5,'F'],delta=3)
+    
\ No newline at end of file
diff --git a/scripts/LoadMSDM.py b/scripts/LoadMSDM.py
new file mode 100755
index 0000000..355459d
--- /dev/null
+++ b/scripts/LoadMSDM.py
@@ -0,0 +1,151 @@
+import sys
+import os
+
+# Add the 'scripts' directory and its subdirectories to sys.path
+folder_path = os.path.join(os.path.dirname(os.path.dirname(os.getcwd())), 'code', 'files', 'scripts')
+sys.path.append(folder_path)
+for root, dirs, files in os.walk(folder_path):
+    for dir in dirs:
+        sys.path.append(os.path.join(root, dir))
+
+from ihtmc import InhomogeneousTimeMarkovChain as IHTMC
+import numpy as np
+
+class mapMSDM:
+    def __init__(self):
+        """Initialize the mapMSDM object by loading the Markov State-Dependent Models (MSDM)."""
+        self.msdm = self.load_msdm()
+    
+    def get(self, cov, function='gompertz', damage='BAF'):
+        """
+        Retrieve a specific value from the MSDM based on the provided parameters.
+        
+        Parameters:
+        - cov (pd.Series): A pandas Series containing the covariates for the query.
+        - function (str, optional): The hazard function to use. Defaults to 'gompertz'.
+        - damage (str, optional): The damage model to use. Defaults to 'BAF'.
+        
+        Returns:
+        - The value from the MSDM matching the specified parameters.
+        """
+        _vars = list(set(self.all_var_msdm) & set(list(cov[cov.values==1].index)))
+        f = _vars + [function] + [damage]
+        return self.get_value_from_msdm(self.msdm, f)
+    
+    def load_msdm(self, MCStructureID='s6_typeA'):
+        """
+        Load the MSDM based on the specified MCStructureID and calibrate the degradation models.
+        
+        Parameters:
+        - MCStructureID (str, optional): The ID of the Markov Chain structure to use. Defaults to 's6_typeA'.
+        
+        Returns:
+        - A dictionary containing the calibrated MSDM models.
+        """
+        if MCStructureID == 's5_typeA':
+            out = {}
+            
+            # Inhomogeneous
+            msdm          =  IHTMC(MCStructureID=MCStructureID,hazard_function='gompertz')
+            msdm.MCObj.s0 = np.array([0.9,0.05,0.025,0.025,0.0])
+            msdm.MCObj.x  = np.array([0.1,0.1,0.1,0.1,0.045,0.05,0.05,0.03])
+            out[('ground_truth_inhomogeneous','ground_truth_gompertz')] = msdm 
+            
+            msdm          =  IHTMC(MCStructureID=MCStructureID,hazard_function='gompertz')
+            msdm.MCObj.s0 = np.array([0.9,0.05,0.025,0.025,0.0])
+            msdm.MCObj.x  = np.array([0.1,0.1,0.1,0.1,0.045,0.05,0.05,0.03])
+            out[('ground_truth_inhomogeneous','gompertz')] = msdm 
+            
+            msdm          =  IHTMC(MCStructureID=MCStructureID,hazard_function='exponential')
+            msdm.MCObj.s0 = np.array([9.99142301e-01, 2.79993267e-05, 2.89711487e-04, 1.72198238e-04,3.67790408e-04])
+            msdm.MCObj.x  = np.array([0.02270134, 0.05275196, 0.07244865, 0.01719452])
+            out[('ground_truth_inhomogeneous','exponential')] = msdm 
+            
+            
+            # Homogeneous
+            
+            msdm          =  IHTMC(MCStructureID=MCStructureID,hazard_function='exponential')
+            msdm.MCObj.s0 = np.array([9.99142301e-01, 2.79993267e-05, 2.89711487e-04, 1.72198238e-04,3.67790408e-04])
+            msdm.MCObj.x  = np.array([0.02270134, 0.05275196, 0.07244865, 0.01719452])
+            out[('ground_truth_homogeneous','ground_truth_exponential')] = msdm 
+            
+            msdm          =  IHTMC(MCStructureID=MCStructureID,hazard_function='exponential')
+            msdm.MCObj.s0 = np.array([9.99142301e-01, 2.79993267e-05, 2.89711487e-04, 1.72198238e-04,3.67790408e-04])
+            msdm.MCObj.x  = np.array([0.02270134, 0.05275196, 0.07244865, 0.01719452])
+            out[('ground_truth_homogeneous','exponential')] = msdm 
+            
+            msdm          =  IHTMC(MCStructureID=MCStructureID,hazard_function='gompertz')
+            msdm.MCObj.s0 = np.array([0.73079851, 0.09996795, 0.08183643, 0.07216788, 0.01522922])
+            msdm.MCObj.x  = np.array([0.19999992, 0.19999994, 0.19999994, 0.19999748, 0.02755406,0.0356125 , 0.03996462, 0.02231694])
+            out[('ground_truth_homogeneous','gompertz')] = msdm 
+            
+        elif MCStructureID == 's6_typeA':
+            out = {}
+    
+            #%% Cohort: CMW, Damage: BAF 
+            # Assign parameters for: cohort: CMW, damage: BAF
+            msdm  =  IHTMC(MCStructureID=MCStructureID,hazard_function='gompertz')
+            # Assign parameters for: function: gompertz, metric: RMSE
+            msdm.MCObj.x  = np.array([2.29871662e+00, 2.09331310e-02, 3.28824979e+00, 2.43903545e+00, 1.44257128e-01, 8.75057330e-01, 2.16499018e-03, 9.78052040e-05, 7.00000000e-19, 8.36645098e-03, 5.47218847e-02, 2.75333617e-03, 8.71054881e-03, 3.05224181e-04, 7.00000000e-19, 4.53206876e-02, 8.56625756e-03, 3.80129954e-01])
+            msdm.MCObj.s0 = np.array([9.58238193e-01, 0.00000000e+00, 3.99999361e-02, 1.60545379e-03, 1.99950027e-15, 1.56417474e-04])
+            out[('pipe_material_concrete','pipe_content_mixed','BAF','gompertz')] = msdm 
+            
+            msdm  =  IHTMC(MCStructureID=MCStructureID,hazard_function='weibull')
+            # Assign parameters for: function: gompertz, metric: RMSE
+            msdm.MCObj.x  = np.array([1.26687091e+00, 2.87201477e+00, 3.46465084e+00, 6.95539086e+00, 4.08067348e-06, 2.71502543e-04, 3.04655849e-05, 1.09879096e-03, 1.66215483e+00, 4.41776330e+01, 7.72776870e+01, 8.08004780e+01, 5.53672251e+01, 4.61327918e+01, 4.57428363e+01, 4.71166290e+01, 4.50557449e+01, 5.91222452e+01])
+            msdm.MCObj.s0 = np.array([0.92330697, 0.02593101, 0.03103027, 0.01126157, 0.0020724, 0.00639777])
+            out[('pipe_material_concrete','pipe_content_mixed','BAF','weibull')] = msdm 
+    
+            msdm  =  IHTMC(MCStructureID=MCStructureID,hazard_function='exponential')
+            # Assign parameters for: function: exponential, metric: RMSE
+            msdm.MCObj.x  = np.array([2.44222779e-02, 9.38162130e-03, 5.67550494e-03, 1.83371198e-02, 3.04589829e-18, 6.02589204e-04, 1.00003674e-18, 1.00000824e-18, 1.00003081e-18])
+            msdm.MCObj.s0 = np.array([9.88862546e-01, 1.25750483e-17, 3.70336428e-23, 1.11374538e-02, 2.10613586e-22, 3.86513331e-22])
+            out[('pipe_material_concrete','pipe_content_mixed','BAF','exponential')] = msdm
+            #%% Cohort: CR, Damage: BAF 
+            msdm  =  IHTMC(MCStructureID=MCStructureID,hazard_function='gompertz')
+            # Assign parameters for: function: gompertz, metric: RMSE
+            msdm.MCObj.x  = np.array([8.12782198e-02, 6.92950891e-02, 2.18411264e-01, 1.45444996e-01, 2.24537010e-01, 5.95783710e-03, 4.02231256e-02, 1.58318744e-01, 1.43633161e-01, 5.26089404e-02, 3.96397124e-02, 4.13113049e-02, 2.12217527e-01, 1.73123461e-05, 9.64901834e-03, 3.35072421e-02, 2.06496818e-02, 4.72360452e-04])
+            msdm.MCObj.s0 = np.array([9.76625745e-01, 1.67209289e-02, 1.25483346e-05, 3.99253580e-04, 2.41880831e-03, 3.82271566e-03])
+            out[('pipe_material_concrete','pipe_content_stormwater','BAF','gompertz')] = msdm 
+            
+            msdm  =  IHTMC(MCStructureID=MCStructureID,hazard_function='weibull')
+            # Assign parameters for: function: gompertz, metric: RMSE
+            msdm.MCObj.x  = np.array([  3.24692391,   2.78633401,   2.46314674,   1.03437623, 13.68242486,   6.73305894,  22.01786267, 0.7748914, 0.19312462,  47.03892339,  66.17257989,  33.21624627, 1.92669482, 149.72616303, 148.96230302, 122.91538727, 75.53001786,  72.52928181])
+            msdm.MCObj.s0 = np.array([9.40918405e-01, 5.28612383e-02, 1.53416143e-04, 5.06635619e-06, 3.82136563e-03, 2.24050812e-03])
+            out[('pipe_material_concrete','pipe_content_stormwater','BAF','weibull')] = msdm 
+            
+            msdm  =  IHTMC(MCStructureID=MCStructureID,hazard_function='exponential')
+            # Assign parameters for: function: exponential, metric: RMSE
+            msdm.MCObj.x  = np.array([1.36977365e-02, 8.72342669e-03, 1.82167553e-01, 9.71701775e-02, 1.00000000e-12, 1.00000000e-12, 1.00000000e-12, 1.28705786e-01, 0.00000000e+00])
+            msdm.MCObj.s0 = np.array([9.96508429e-01, 1.57138494e-04, 1.28980458e-03, 1.00002629e-04, 1.84462217e-03, 1.00002629e-04])
+            out[('pipe_material_concrete','pipe_content_stormwater','BAF','exponential')] = msdm 
+            #%% Cohort: PMW, Damage: BAF 
+            
+            # All variables in the MSDM
+            keys = list(out.keys())
+            self.all_var_msdm = list(set(value for tuple_ in keys for value in tuple_))
+        return out
+    
+    def get_value_from_msdm(self, msdm, query):
+        """
+        Retrieve a value from the MSDM based on a query.
+        
+        Parameters:
+        - msdm (dict): The MSDM dictionary.
+        - query (list): The query list containing parameters for the MSDM lookup.
+        
+        Returns:
+        - The value associated with the query in the MSDM.
+        
+        Raises:
+        - KeyError: If no matching key is found for the query.
+        """
+        query_set = set(query)
+        for key in msdm.keys():
+            key_set = set(key)
+            if key_set == query_set:
+                return msdm[key]
+        raise KeyError(f"No matching key found for query: {query}")
+
+    
+    
\ No newline at end of file
diff --git a/scripts/aux_MarkovChainCalibrationAlgorithms.py b/scripts/aux_MarkovChainCalibrationAlgorithms.py
new file mode 100644
index 0000000..b9af678
--- /dev/null
+++ b/scripts/aux_MarkovChainCalibrationAlgorithms.py
@@ -0,0 +1,266 @@
+import numpy as np
+
+def sum_constraint(x, N):
+    """
+    Constraint function to ensure the sum of the last N elements of x is 1.
+
+    Parameters:
+    - x: np.ndarray, the array of optimization variables.
+    - N: int, the number of elements from the end of x to sum.
+
+    Returns:
+    - float, the difference between the sum of the last N elements and 1.
+    """
+    return np.sum(x[-N:]) - 1
+
+
+def SLSQP(obj, **args):
+    """
+    Optimizes an objective function using the Sequential Least Squares Programming (SLSQP) method.
+
+    Parameters:
+    obj (object): An object containing the cost function and additional optimization settings.
+    args (dict): A dictionary containing the optimization parameters. Expected keys are:
+                 'metric' (str): The metric for measuring errors. Default is 'LogL'.
+                 'maxiter' (int): The maximum number of iterations. Default is 1000.
+                 'verbose' (int): The verbosity level. Default is 0.
+                 'tol' (float): The tolerance for termination. Default is 1e-10.
+
+    Returns:
+    result: The result of the optimization process.
+    """
+    # Extracting optimization parameters with defaults
+    metric = args.get('metric', 'LogL')
+    maxiter = args.get('maxiter', 1000)
+    verbose = args.get('verbose', 0)
+    tol = args.get('tol', 1e-10)  # Corrected key from 'verbose' to 'tol'
+
+    from scipy.optimize import minimize
+
+    # Performing the optimization
+    result = minimize(obj.cost_function,
+                      obj._.MCObj.getXFromMCParameters(),
+                      args=(metric,),
+                      method='SLSQP',
+                      bounds=obj._.MCObj.bounds,
+                      tol=tol,
+                      options={'disp': verbose > 0, 'maxiter': maxiter}
+                      )
+    return result
+
+
+def trust_constr(obj,**args):
+    """
+    Optimizes an objective function using the Trust Region Constrained (trust-constr) optimization method.
+
+    Parameters:
+    obj (object): An object containing the cost function and additional optimization settings.
+    args (dict): A dictionary containing the optimization parameters. Expected keys are:
+                 'metric' (str): The metric for measuring errors. Default is 'LogL'.
+                 'maxiter' (int): The maximum number of iterations. Default is 1000.
+                 'verbose' (int): The verbosity level. Default is 0.
+
+    Returns:
+    result: The result of the optimization process.
+    """
+    # Extracting optimization parameters with defaults
+    metric = args.get('metric', 'LogL')
+    gtol = args.get('gtol', 1e-10)
+    maxiter = args.get('maxiter', 1000)
+    verbose = args.get('verbose', 0)
+    xtol = args.get('xtol', 1e-10)
+    finite_diff_rel_step = args.get('finite_diff_rel_step', 0.001)
+    
+    from scipy.optimize import minimize
+
+    # Performing the optimization
+    result = minimize(obj.cost_function,  
+                      obj._.MCObj.getXFromMCParameters(),
+                      args=(metric,),
+                      method='trust-constr', 
+                      bounds=obj._.MCObj.bounds,
+                      options={'finite_diff_rel_step': finite_diff_rel_step,
+                               'maxiter': maxiter,
+                               'verbose': verbose,
+                               'xtol': xtol,
+                               'gtol': gtol,
+                               }
+                      )
+    return result
+
+
+def Nelder_Mead(obj, **args):
+    """
+    Optimizes an objective function using the Nelder-Mead simplex algorithm.
+
+    Parameters:
+    obj (object): An object containing the cost function and additional optimization settings.
+    args (dict): A dictionary containing the optimization parameters. Expected keys are:
+                 'metric' (str): The metric for measuring errors. Default is 'LogL'.
+                 'maxiter' (int): The maximum number of iterations. Default is 1000.
+
+    Returns:
+    result: The result of the optimization process.
+    """
+    metric = args.get('metric', 'LogL')
+    maxiter = args.get('maxiter', 1000)
+    
+    from scipy.optimize import minimize
+
+    result = minimize(obj.cost_function, 
+                      obj._.MCObj.getXFromMCParameters(),
+                      args=(metric,),
+                      method='Nelder-Mead', 
+                      options={'xatol': 1e-8,  # Tolerance for termination in the x direction
+                               'fatol': 1e-8,  # Tolerance for termination in the function direction
+                               'disp': True,  # Display the convergence messages
+                               'maxiter': maxiter})  # Maximum number of iterations
+    return result
+
+def differential_evolution(obj, **args):
+    """
+    Optimizes an objective function using the differential evolution global optimization algorithm.
+
+    Parameters:
+    obj (object): An object containing the cost function and additional optimization settings.
+    args (dict): A dictionary containing the optimization parameters. Expected keys are:
+                 'disp' (bool): Display status messages. Default is True.
+                 'popsize' (int): Population size. Default is 20.
+                 'polish' (bool): Whether to perform a local minimization at the end. Default is False.
+                 'workers' (int): Number of workers for parallel computation. Default is 1.
+                 'updating' (str): Whether to update candidates immediately or after all evaluations. Default is 'immediate'.
+                 Other keys like 'metric' and 'maxiter' should be defined outside this function or passed explicitly if needed.
+
+    Returns:
+    result: The result of the optimization process.
+    """
+    from scipy.optimize import differential_evolution#, NonlinearConstraint
+
+    # Retrieving optimization parameters from args with defaults
+    disp = args.get('disp', True)
+    popsize = args.get('popsize', 20)
+    polish = args.get('polish', False)
+    workers = args.get('workers', 1)
+    maxiter = args.get('maxiter', 1000)  # Assuming 'maxiter' is intended to be part of args with a default value
+    metric = args.get('metric', 'LogL')  # Assuming 'metric' needs to be included
+    tol = args.get('tol', 0.001)
+    
+    # Setting 'updating' strategy based on the number of workers
+    updating = 'immediate' if workers == 1 else 'deferred'
+
+    result = differential_evolution(obj.cost_function, 
+                                    obj._.MCObj.bounds, 
+                                    args=(metric,),
+                                    strategy='best1bin',  # Strategy for generating trial candidates
+                                    maxiter=maxiter,  # Maximum number of generations over which to evolve population
+                                    popsize=popsize,  # Population size
+                                    tol=tol,  # Relative tolerance for convergence
+                                    mutation=(0.5, 1),  # Mutation constant or a tuple specifying mutation range
+                                    recombination=0.7,  # Recombination constant
+                                    seed=None,  # Seed for random number generator
+                                    disp=disp,  # Display status messages
+                                    callback=None,  # A callback function for additional functionality at each iteration
+                                    polish=polish,  # Whether to perform a local minimization at the end
+                                    init='latinhypercube',  # Initialization method ('latinhypercube', 'random', or an array)
+                                    atol=0,  # Absolute tolerance for convergence
+                                    updating=updating,  # Whether to update candidates immediately or after all evaluations
+                                    #constraints=(NonlinearConstraint(lambda x: sum_constraint(x, len(obj._.MCObj.states)), 0, 0),)  # Constraints definition.
+                                    workers=workers)
+    return result
+
+# TODO: Baum-Welch / Expectation Maximmization algorithms
+# TODO: MEtropoli-Hastings algorithm
+
+# def metropolis_hastings(self,pt,x0,model_type,function,func_obj,iterations=1000, burn_in=500,output_convergence=False,norm_std_deviation=0.1):
+#     """
+#     Metropolis-Hastings algorithm to estimate the transition probabilities of an inhomogeneous Markov chain.
+#     :param pt: dataframe with two columns [time, state]
+#     :param x0: Markov chain initial parameters
+#     :param iterations: Number of iterations for the MCMC
+#     :param burn_in: Number of iterations to discard for burn-in
+#     :return: Estimated transition matrix
+#     """
+    
+#     def calculate_likelihood(data,params,P0,model_type,function):
+#         if model_type == 'dtmc':
+#             transition_matrix = func_obj.Q_matrix(params)
+#             initial_vector = list(P0)
+#             steps = data['pipe_age']
+#             p = func_obj.unroll(transition_matrix,np.array(initial_vector),list(steps))
+#             return self.log_likelihood(p,data)
+#         elif model_type == 'nhtmc':
+#             p,s = func_obj.unroll(t=data['pipe_age'],params=params,P0=P0,function=function)
+#             if s:
+#                 # The solver succeeded
+#                 return self.log_likelihood(p,data)
+#             else:
+#                 # The solver failed
+#                 return -1E100
+#             #return self.log_likelihood(p,data)
+        
+    
+#     # Perform Metropolis-Hastings sampling
+#     current_x0 = x0[0:-6]
+#     current_P0 = x0[-6:]
+    
+#     all_log_likelihoods = [calculate_likelihood(data=pt,
+#                                               params=current_x0,
+#                                               P0=current_P0,
+#                                               model_type = model_type,
+#                                               function = function,
+#                                               )]
+    
+#     all_x0 = [current_x0]
+#     all_P0 = [current_P0]
+
+#     for _ in range(iterations):
+#         # Propose a new sample by perturbing the current sample
+#         proposed_x0 = current_x0 + norm.rvs(scale=norm_std_deviation,size=current_x0.shape)
+        
+#         if model_type == 'dtmc':
+#             proposed_x0[proposed_x0>1] = 1
+#             proposed_x0[proposed_x0<0] = 0
+#         else:
+#             proposed_x0[proposed_x0<0] = 1E-12 # Ensure non-negative coefficients
+        
+#         proposed_P0 = self.add_noise_to_pmf(current_P0,noise_scale=0.001)#0.001 --> We are not modifying this vector with the M-H algorithm
+
+#         # Calculate the acceptance ratio
+#         current_log_pdf    = calculate_likelihood(data=pt,
+#                                                   params=current_x0,
+#                                                   P0=current_P0,
+#                                                   model_type=model_type,
+#                                                   function=function,
+#                                                   )
+#         candidate_log_pdf = calculate_likelihood(data=pt,
+#                                                  params=proposed_x0,
+#                                                  P0=proposed_P0,
+#                                                  model_type=model_type,
+#                                                  function=function,
+#                                                  )
+#         log_acceptance_prob = candidate_log_pdf - current_log_pdf
+
+#         # Accept or reject the candidate sample based on the log of the acceptance probability
+#         if np.log(np.random.rand()) < log_acceptance_prob:
+#             print([_, candidate_log_pdf])
+#             current_x0 = proposed_x0
+#             current_P0 = proposed_P0
+#             all_log_likelihoods.append(candidate_log_pdf)
+#         else:
+#             all_log_likelihoods.append(current_log_pdf)
+#         all_x0.append(current_x0)
+#         all_P0.append(current_P0)
+
+#     convergence_df = pd.DataFrame()
+#     if output_convergence:
+#         convergence_df = pd.DataFrame({'x0': all_x0,
+#                                        'P0': all_P0,
+#                                        'log-likelihood': all_log_likelihoods}
+#                                       )
+
+#     # Output parameters:
+#     results = {'x':list(np.array(all_x0[burn_in:]).mean(axis=0))+list(np.array(all_P0[burn_in:]).mean(axis=0)),
+#                'convergence':convergence_df}
+
+#     return results
+
diff --git a/scripts/aux_common_functions_ihtmc_dtmc.py b/scripts/aux_common_functions_ihtmc_dtmc.py
new file mode 100644
index 0000000..308b43e
--- /dev/null
+++ b/scripts/aux_common_functions_ihtmc_dtmc.py
@@ -0,0 +1,119 @@
+import pandas as pd
+import numpy as np
+from aux_functions import renormalize_mass_function, comp_error, getFrequencyTable
+from markov_chain_calibration import MarkovChainCalibration
+
+def compute_error(_self, y=pd.DataFrame(), yp=pd.DataFrame(), metric='RMSE'):
+    """
+    Compare the error between actual and predicted dataframes based on a specified metric.
+
+    Parameters:
+    - self: Instance of the class containing this function, the original dataframe (self.df), and the Markov Chain object (self.MCObj).
+    - y (pd.DataFrame, optional): Actual data. If not provided, the instance's dataframe (self.df) is used.
+    - yp (pd.DataFrame, optional): Predicted data. If not provided, predictions are made using the instance's predict method on the actual data's index.
+    - metric (str, optional): The metric to use for comparison. Default is 'LogL' (Log Likelihood).
+
+    Returns:
+    - The result of the comparison using the specified metric, computed by the comp_error function.
+    """            
+
+    if yp.empty:
+        yp, success = _self.predict(t=_self.df.index.unique(),ConverenceDetails=True)
+    
+    if success:
+        if metric == 'LogL':
+            if y.empty:
+                y = _self.df
+        elif metric in ['RMSE','SE','MSE']:
+            if _self.df_freq.empty:
+                _self.df_freq = getFrequencyTable(y=_self.df,states=_self.MCObj.states)
+            y = _self.df_freq 
+                
+        return comp_error(y=y, yp=yp, metric=metric, states=_self.MCObj.states)
+    else:
+        return None
+    
+
+def renormalize_rows(dataframe, tolerance=0.01):
+    """
+    Renormalizes the rows of a dataframe. Rows containing any negative value are set to 0 and then normalized 
+    so that each row sums exactly to 1. Rows are adjusted to sum to 1 within a specified tolerance.
+
+    Parameters:
+    - dataframe (pd.DataFrame): The dataframe to be renormalized.
+    - tolerance (float): The tolerance within which the sum of rows must be to 1.
+
+    Returns:
+    - pd.DataFrame: The renormalized dataframe.
+    """
+    # Set negative values to 0 and normalize rows
+    dataframe[dataframe < 0] = 0
+    row_sums = dataframe.sum(axis=1)
+    dataframe = dataframe.div(row_sums, axis=0).fillna(0)
+    
+    # Adjust rows to ensure sum is within tolerance to 1
+    row_sums_after = dataframe.sum(axis=1)
+    adjust_mask = np.abs(row_sums_after - 1) > tolerance
+    dataframe.loc[adjust_mask] = dataframe.loc[adjust_mask].div(row_sums_after[adjust_mask], axis=0)
+    
+    return dataframe
+
+
+def sample(_self, t=np.linspace(0, 50), n=1000, states=[], exact_t_spacing=False):
+    """
+    Samples state observations from a Markov Chain model over a specified time interval.
+
+    Parameters:
+    - _self: The object instance.
+    - t (array-like, optional): The time points for prediction. Defaults to a linear space between 0 and 50.
+    - n (int, optional): The number of observations to sample. Defaults to 1000.
+    - states (list, optional): The states to sample from. Defaults to all states in the Markov Chain model.
+    - exact_t_spacing (bool, optional): If True, samples are taken at exact times from t. If False, samples are
+      taken at uniform random times between min(t) and max(t). Defaults to False.
+
+    Returns:
+    - A DataFrame containing the sampled observations, with columns for time, state, and count of each state
+      at each sampled time point. The DataFrame is indexed by time and sorted in ascending order.
+    """
+    g = _self.predict(t=t)
+    if states == []:
+        states = _self.MCObj.states
+    if exact_t_spacing:
+        times = np.random.choice(t, n)
+    else:
+        times = np.random.uniform(min(t), max(t), n)
+    choices = [np.random.choice(states, p=g.iloc[np.argmin(np.abs(ti - t))].values) for ti in times]
+    obs = np.column_stack((times, choices))
+    df = pd.DataFrame(obs, columns=['time', 'state']).sort_values(by='time', ascending=True).reset_index(drop=True)
+    df = df.groupby(['time', 'state']).size().reset_index(name='count')
+    df.set_index('time', inplace=True)
+    return df
+
+def fit(_self,args):
+    """
+    Fits the Markov Chain model to the provided data, calibrating its parameters.
+    
+    Parameters:
+    - df (pd.DataFrame, optional): DataFrame containing the data for calibration. Default is an empty DataFrame.
+    - metric (str, optional): The metric to optimize during calibration. Default is 'LogL'.
+    - severities (list of int, optional): List of severity states to consider in the model. Default is [1,2,3,4,5,6].
+    - markov_chain_type (str, optional): Name of the Markov Chain type. Default is 'Type A'.
+    
+    Returns:
+    - MarkovChainStructure: The calibrated Markov Chain Structure object with updated parameters.
+    """
+    # Get args
+    df = args.get('df',pd.DataFrame())
+    metric = args.get('metric','RMSE')
+
+    # Get data:
+    df = _self.fetch_data(df)
+    # Obtain model parameters:
+    model = MarkovChainCalibration(df,_self,metric=metric)
+    result = model.fit(**args)
+    # Update model parameters
+    _self.MCObj.calibrated = True
+    param = _self.MCObj.getMCParametersFromX(result.x)
+    _self.MCObj.x, _self.MCObj.s0 = param['x'], param['s0']
+    _self.MCObj.convergence_info = result
+    return _self.MCObj
\ No newline at end of file
diff --git a/scripts/aux_functions.py b/scripts/aux_functions.py
new file mode 100755
index 0000000..445eb78
--- /dev/null
+++ b/scripts/aux_functions.py
@@ -0,0 +1,1312 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Feb 19 21:01:20 2024
+
+@author: lisandro
+"""
+import os
+import numpy as np
+import pandas as pd
+import pickle
+import sqlite3
+import re
+from datetime import datetime
+from sklearn.preprocessing import MinMaxScaler, OneHotEncoder
+from sklearn.compose import ColumnTransformer
+from sklearn.pipeline import Pipeline
+from sklearn.base import BaseEstimator, TransformerMixin
+import gymnasium
+from gymnasium import spaces
+import string
+import random
+from collections import Counter
+import datetime
+from copy import deepcopy
+from scipy.stats import mode
+from typing import Callable, Dict, Optional
+import dill
+import matplotlib.pyplot as plt
+import importlib
+from scipy.interpolate import interp1d
+import logging
+
+
+def extract_wkt_coords(df, wkt_column):
+    pattern = r'(\d+(?:\.\d+)?)\s+(\d+(?:\.\d+)?)'
+    coords_array = []
+    for wkt in df[wkt_column].astype(str):
+        matches = re.findall(pattern, wkt)
+        row_coords = [float(num) for coords in matches for num in coords] if matches else [np.nan] * 4
+        coords_array.append(row_coords)
+    return coords_array
+
+def normalize_coordinates(df):
+    x_min = min(df['x_i'].min(), df['x_f'].min())
+    x_max = max(df['x_i'].max(), df['x_f'].max())
+    y_min = min(df['y_i'].min(), df['y_f'].min())
+    y_max = max(df['y_i'].max(), df['y_f'].max())
+
+    # Normalized to [-1, 1]
+    df['x_i'] = (df['x_i'] - x_min) / (x_max - x_min)
+    df['x_f'] = (df['x_f'] - x_min) / (x_max - x_min)
+    df['y_i'] = (df['y_i'] - y_min) / (y_max - y_min)
+    df['y_f'] = (df['y_f'] - y_min) / (y_max - y_min)
+    return df
+
+def fetch_table_contents(db_path,table_name):
+    with sqlite3.connect(db_path) as conn:
+        df = pd.read_sql_query(f"SELECT * FROM {table_name}", conn)
+    return df 
+
+def load_network_data(db_path=None,df_path=None,table_name='sewer_pipes', apply_filters=True, sub_network=True, build_cohorts=True,norm_coordinates=False,system_features_var_blacklist=None):
+            
+    if db_path:
+        df = fetch_table_contents(db_path,table_name)
+        df = df.drop(columns=['start_node_id', 'end_node_id', 'material_org', 'start_floorlevel', 'end_floorlevel', 'pipeshape', 'height', 'customer_connections', 'effective_customer_connections', 'geometry'])
+    elif df_path:
+        '''
+        Read dataframe.
+        '''
+        with open(df_path, 'rb') as file:
+            # Return the loaded object
+            df = pickle.load(file)
+        df['community'] = df['community'].str.lower()
+        df.rename(columns={'pipe_construction_year':'construction_year',
+                           'pipe_length':'length',
+                           'contentstype':'content',
+                           'width_mm':'width',
+                           'community':'location',
+                           'sewer_inspection_id':'inspection_id',
+                           }, inplace=True)
+                
+        # Delete unnecessary columns:
+        df = df.drop(columns=['kar1', 'kar2', 'kwan1','kwan2', 'klok1', 'klok2','height_mm','material_org','position','end_position','systemtype'])
+        # change material names:
+        df.loc[df['material'] == 'CONCRETE', 'material'] = 'Concrete'
+        df.loc[df['material'] == 'PLASTIC', 'material'] = 'PVC'
+        # Change content names:
+        df.loc[df['content'] == 'mixed', 'content'] = 'MixedSewer'
+        df.loc[df['content'] == 'wastewater', 'content'] = 'WasteSewer'
+        df.loc[df['content'] == 'rainwater', 'content'] = 'RainSewer'
+        df.loc[df['content'] == 'unknown', 'content'] = 'Unknown'
+        
+    df.rename(columns={'id': 'pipe_id','contentstype': 'content'}, inplace=True)
+    
+    if apply_filters:
+        df = df[df['construction_year'].notna() & (df['length'] <= 100) & (df['width'] <= 1000) & (df['construction_year'] >= 1940)].reset_index(drop=True)
+        df = df[df['width']>=50].reset_index(drop=True) #--> Minimal diameter allowed of 5 cm
+        df = df[df['length']>=1].reset_index(drop=True) #--> Minimal length allowed of 1 meter
+        df.loc[:, 'width'] = df['width'] / 1000  # Convert to meters where appropriate
+        df.loc[:, 'age_today'] = datetime.datetime.now().year - df['construction_year']
+        df.loc[:, 'material'] = df['material'].where(df['material'].isin(['Concrete', 'PVC']), 'Other')
+        df.loc[:, 'content'] = df['content'].replace('Unknown', 'Other')
+
+    if sub_network:
+        coords = pd.DataFrame(extract_wkt_coords(df, 'wkt'), columns=['x_i', 'y_i', 'x_f', 'y_f'])
+        bounds = (1.0616E5, 1.1879E5, 3.9330E5, 4.0519E5)
+        mask = (coords[['x_i', 'x_f']].ge(bounds[0]) & coords[['x_i', 'x_f']].le(bounds[1])).all(axis=1) & \
+               (coords[['y_i', 'y_f']].ge(bounds[2]) & coords[['y_i', 'y_f']].le(bounds[3])).all(axis=1)
+        df = df[mask]
+        coords = coords[mask]
+        df = pd.concat([df, coords], axis=1)
+        # Normalize network coordinates:
+        if norm_coordinates:
+            '''
+            Normalize coordinates
+            '''
+            df = normalize_coordinates(df)
+        df = df.drop(columns=['wkt'])
+    
+    if build_cohorts:
+        # conditions = [
+        #     (df['content'] == 'WasteSewer') & (df['material'] == 'Concrete'),
+        #     (df['content'] == 'MixedSewer') & (df['material'] == 'Concrete'),
+        #     (df['content'] == 'RainSewer') & (df['material'] == 'Concrete'),
+        #     (df['content'] == 'WasteSewer') & (df['material'] == 'PVC'),
+        #     (df['content'] == 'MixedSewer') & (df['material'] == 'PVC'),
+        #     (df['content'] == 'RainSewer') & (df['material'] == 'PVC'),
+        # ]
+        # cohorts = ['ConWaste', 'ConMix', 'ConRain', 'PVCWaste', 'PVCMix', 'PVCRain']
+        conditions = [
+            ((df['content'] == 'WasteSewer') | (df['content'] == 'MixedSewer')) & (df['material'] == 'Concrete'),
+            (df['content'] == 'RainSewer') & (df['material'] == 'Concrete'),
+            ((df['content'] == 'WasteSewer') | (df['content'] == 'MixedSewer')) & (df['material'] == 'PVC'),
+            (df['content'] == 'RainSewer') & (df['material'] == 'PVC'),
+        ]            
+        cohorts = ['CMW', 'CS', 'PMW', 'PS']
+        df['cohort'] = np.select(conditions, cohorts, default=np.nan)
+        # Replace 'nan' string with actual np.nan
+        df['cohort'].replace('nan', np.nan, inplace=True)
+        
+    df = df[~df['cohort'].isna()]
+    df = df.reset_index(drop=True) 
+    
+    if 'location' not in df.columns:
+        df['location'] = 'breda' # --> assume as default location: breda
+        
+    if system_features_var_blacklist:
+        for var, values in system_features_var_blacklist.items():
+            df = df[~df[var].isin(values)]
+        
+    #df = df.sample(n=100) #--> Remove this later
+    
+    return df
+
+
+
+def gen_comparative_table_policies(AllPolicies,path_name=''):
+     results = {
+         'Environment':[],
+         'Prognostic model':[],
+         'RL algorithm':[],
+         'Mean Cum. Reward':[],
+         'Std. Cum. Reward':[],
+         }
+     
+     for k in list(AllPolicies.keys()):
+         R = [AllPolicies[k][_]['Reward'].cumsum().iloc[-1] for _ in list(AllPolicies[k].keys())]
+         results['Environment'].append(k[0][0])
+         results['Prognostic model'].append(k[0][1])
+         results['RL algorithm'].append(k[1])
+         results['Mean Cum. Reward'].append(np.mean(R))
+         results['Std. Cum. Reward'].append(np.std(R))
+         
+     results = pd.DataFrame(results)
+     with open(path_name+generate_experiment_name_from_model()+'_results.tex', 'w') as f:
+         f.write(results.to_latex(index=False,float_format="%.3f"))
+
+
+def load_inspection_data(db_path=None,df_path=None,network=pd.DataFrame(),table='sewer_inspection_observations'):
+    if len(network) == 0:
+        network = load_network_data(db_path)
+    if db_path:
+        df = fetch_table_contents(db_path,table)
+        # Rename columns:
+        df.rename(columns={'sewer_inspection_id': 'inspection_id', 'sewer_pipe_id': 'pipe_id'}, inplace=True)
+        # Drop unnecessary columns:
+        df = df.drop(columns=['kar1', 'kar2', 'kwan1', 'kwan2', 'klok1', 'klok2', 'remark','id'])
+        # Filter pipes:
+        df = df[df['pipe_id'].isin(network['pipe_id'])]
+        # Update self.network given the available amount of inspected pipes.
+        network = network[network['pipe_id'].isin(df['pipe_id'])]
+        network = network.reset_index(drop=True)
+        # Reset index after filtering:
+        df = df.reset_index(drop=True)
+        # Correct pristine label using .loc for proper assignment:
+        df.loc[df['damage_class'] == 0, 'damage_class'] = 1
+        
+        if 'location' not in df.columns:
+            df['location'] = 'breda' # --> assume as default location: breda
+        
+    elif df_path:
+        df = network
+        df = df.drop(columns=['construction_year', 'cohort', 'length', 'width']) 
+        df.loc[df['damage_class'] == 0, 'damage_class'] = 1
+    return df
+
+
+
+def discretize_dataframe(df, delta):
+    """
+    Discretizes the time index of the DataFrame based on the delta value(s).
+    Delta can be a single value or a list/numpy array indicating the intervals.
+
+    Parameters:
+    - df: DataFrame with a time index, a 'state' column, and a 'count' column.
+    - delta: Single value (int/float) for uniform discretization or list/numpy array for variable intervals.
+
+    Returns:
+    - DataFrame with discretized time index and adjusted counts per state.
+    """
+
+    # Function to map time values to discretized intervals
+    def map_to_interval(time_val, intervals):
+        # Find the interval that the time_val belongs to, return the start of this interval
+        index = np.searchsorted(intervals, time_val, side='right') - 1
+        return intervals[max(0, index)]
+
+    # Check if delta is a list or numpy array, and handle accordingly
+    if isinstance(delta, (list, np.ndarray)):
+        # Calculate the unique sorted intervals including the max time to ensure coverage
+        unique_intervals = np.unique(delta + [df.index.max() + (delta[-1] - delta[-2])])
+        # Map each time value to its discretized interval
+        df.index = df.index.map(lambda x: map_to_interval(x, unique_intervals))
+    else:
+        # Discretize time index by rounding to nearest multiple of delta
+        df.index = (df.index // delta) * delta
+
+    # Group by the new time index and state, then sum the counts
+    df_discretized = df.groupby([df.index, 'state']).sum().reset_index().set_index('time')
+
+    return df_discretized
+
+def getFrequencyTable(y, states, delta=None):
+    """
+    Generates a frequency table for given data.
+
+    Parameters:
+    - y (DataFrame): Input data frame with 'count' and 'state' columns, indexed by 'time'.
+    - states (list): A list of unique states to be included as columns in the output table.
+    - delta (float, optional): The delta value for discretization. If provided, discretizes the 'time' index.
+
+    Returns:
+    - DataFrame: A pivot table with 'time' as rows, states as columns, normalized counts of each state per 'time', 
+      and an additional column for the total count per 'time'. If delta is provided, the 'time' index is adjusted accordingly.
+    """
+    
+    if delta:
+        # Perform discretization based on a provided delta.
+        y  = discretize_dataframe(y,delta)
+    
+    # Normalize counts within each 'time' group and pivot
+    def normalize_counts(group):
+        count_sum = group['count'].sum()
+        group['normalized_count'] = group['count'] / count_sum
+        return group
+
+    # Apply normalization
+    normalized = y.groupby(y.index, group_keys=False).apply(normalize_counts)
+
+    # Pivot the table to get states as columns and times as rows, ensuring columns are in the order of 'states'
+    pivot_table = normalized.pivot_table(index=normalized.index, columns='state', values='normalized_count', fill_value=0)
+
+    # Ensure the pivot_table columns are ordered according to 'states'
+    pivot_table = pivot_table.reindex(columns=states, fill_value=0)
+
+    # Add the total counts per 'time' as an additional column
+    pivot_table['total_count'] = y.groupby(y.index)['count'].sum()
+    
+    if delta:
+        # Adjust the index
+        pivot_table.index = pivot_table.index + delta/2
+    
+    return pivot_table
+
+def print_analysis_results(results):
+    """
+    Nicely prints the analysis results of DataFrame columns obtained from the analyze_features function.
+
+    Parameters:
+    - results (dict): The analysis results where keys are column names and values are dictionaries with analysis details.
+    """
+    from prettytable import PrettyTable
+
+    # Create a table with headers
+    table = PrettyTable()
+    table.field_names = ["Column Name", "Type", "Nature", "Additional Info"]
+
+    for column, details in results.items():
+        additional_info = "; ".join([f"{key}: {value}" for key, value in details.items() if key not in ['type', 'nature']])
+        table.add_row([column, details.get('type', 'N/A'), details.get('nature', 'N/A'), additional_info])
+
+    print(table)    
+    
+    
+def transition_rate(i, t, param, function='gompertz'):
+    """
+    Calculates the transition rate for a given state, time, and function.
+    
+    Parameters:
+        i (int): Index of the transition rate to calculate.
+        t (float): Time at which the rate is evaluated.
+        function (str, optional): The probability density function to use. Defaults to 'gompertz'.
+    
+    Returns:
+        float: The calculated transition rate.
+    
+    Raises:
+        NotImplementedError: If the function is not implemented.
+    """
+    if function == 'gompertz':
+        from probability_density_functions import  gompertz
+        return gompertz.hazard_rate(t, param['a'][i], param['b'][i])
+    elif function == 'weibull':
+        from probability_density_functions import  weibull
+        return weibull.hazard_rate(t, param['a'][i], param['b'][i])
+    elif function == 'gamma':
+        from probability_density_functions import  gamma
+        return gamma.hazard_rate(t, param['a'][i], param['b'][i])
+    elif function == 'loglogistic':
+        from probability_density_functions import  loglogistic
+        return loglogistic.hazard_rate(t, param['a'][i], param['b'][i])
+    elif function == 'lognormal':
+        from probability_density_functions import  lognormal
+        return lognormal.hazard_rate(t, param['a'][i], param['b'][i])
+    elif function == 'exponential':
+        from probability_density_functions import  exponential
+        return exponential.hazard_rate(t, param['a'][i])
+    else:
+        raise NotImplementedError(f"Distribution '{function}' not implemented.")
+
+
+def random_mass_function(N):
+    """
+    Generate an N-dimensional numpy array (vector) with elements that sum to 1.0.
+
+    Parameters:
+    N (int): The dimension of the vector to be generated.
+
+    Returns:
+    numpy.ndarray: An N-dimensional vector with elements that sum to exactly 1.0.
+    """
+    vector = np.random.rand(N)
+    vector /= vector.sum()
+    return vector
+
+def compare_dataframes(df1, df2, atol=1e-5):
+    """
+    Compares two DataFrames to check if they are equal within a specified absolute tolerance.
+    
+    Parameters:
+    - df1: First DataFrame to compare.
+    - df2: Second DataFrame to compare.
+    - atol: Absolute tolerance parameter for numerical comparison. Defaults to 1e-5.
+    
+    Returns:
+    - True if DataFrames are equal within the specified absolute tolerance, else False.
+    """
+    # Ensure the same order of columns for comparison
+    df1, df2 = df1.sort_index(axis=1), df2.sort_index(axis=1)
+
+    # Compare categorical columns
+    categorical_columns = df1.select_dtypes(exclude=[np.number]).columns
+    if not df1[categorical_columns].equals(df2[categorical_columns]):
+        return False
+
+    # Prepare numerical columns for comparison
+    df1_numerical = df1.apply(pd.to_numeric, errors='coerce')
+    df2_numerical = df2.apply(pd.to_numeric, errors='coerce')
+
+    # Compare numerical columns using np.allclose
+    return np.allclose(df1_numerical, df2_numerical, atol=atol, equal_nan=True)
+
+
+def generate_random_string(N):
+    """
+    Generate a random string of specified length.
+
+    Parameters:
+    N (int): The length of the string to be generated.
+
+    Returns:
+    str: A string consisting of randomly chosen letters and digits.
+    """
+    characters = string.ascii_letters + string.digits
+    return ''.join(random.choice(characters) for _ in range(N))
+
+
+def get_script_path():
+    """
+    Returns the absolute path of the currently executing script.
+    
+    :return: Absolute path of the script
+    :rtype: str
+    """
+    return os.path.realpath(__file__)
+
+def count_damage_points(arr: list, states=[]) -> pd.DataFrame:
+    """
+    Calculates the count and frequency of elements in a given list, optionally ensuring specific states are included.
+    
+    Parameters:
+    - arr (list): The input list containing elements to count.
+    - states (list, optional): A list of states to ensure are included in the output. Defaults to an empty list.
+    
+    Returns:
+    - pd.DataFrame: A DataFrame with two columns ('count' and 'frequency') representing the count and frequency of each element in the input list. Ensures that all specified states are included, setting missing states' counts to 0 if they do not appear in the input list.
+    """
+    # Convert the input list to a pandas Series and count occurrences
+    counts = pd.Series(arr).value_counts().sort_index(key=lambda x: x.astype(str))
+    # Ensure all specified states are included, setting missing states' counts to 0
+    counts = counts.reindex(counts.index.union(states), fill_value=0)
+    # Calculate the frequency of each element
+    total = counts.sum()
+    frequencies = counts / total if total > 0 else 0
+    # Create the DataFrame
+    return  pd.DataFrame({'count': counts, 'frequency': frequencies})
+
+def generate_vector_exact_step(start, stop, step):
+    """
+    Generates a vector with an exact step size, avoiding floating-point precision issues.
+    
+    Parameters:
+    - start: The starting value of the vector.
+    - stop: The end value of the vector (inclusive).
+    - step: The step size between each element in the vector.
+    
+    Returns:
+    - A list containing the generated vector with exact step sizes.
+    """
+    # Scale factors to avoid floating-point issues
+    scale_factor = 1 / step
+    
+    # Calculate the number of steps including the stop value
+    num_steps = int((stop - start) * scale_factor) + 1
+    
+    # Generate the vector using list comprehension
+    vector = [(start + i * step) for i in range(num_steps)]
+    
+    return vector
+
+def renormalize_mass_function(mass_function, error_threshold=1E-5):
+    """
+    Renormalize the given mass function, ensuring no negative values and that the sum of each row equals 1.
+    
+    Parameters:
+    - mass_function: numpy.ndarray, the mass function to be renormalized.
+    - error_threshold: float, the maximum allowed error for renormalization.
+    
+    Returns:
+    - numpy.ndarray, the renormalized mass function.
+    
+    Raises:
+    - ValueError: If the error after renormalization exceeds the error_threshold.
+    """
+    corrected_mass_function = np.where(mass_function < 0, 0, mass_function)
+    sum_per_row = corrected_mass_function.sum(axis=1).reshape(-1, 1)
+    error = np.abs(sum_per_row - 1)
+    if np.any(error > error_threshold):
+        raise ValueError(f"Renormalization error exceeds threshold: {error_threshold}")
+    renormalized_mass_function = corrected_mass_function / sum_per_row
+    return renormalized_mass_function
+
+def generate_experiment_name_from_model(prefix: str = "exp"):
+    """Generate a unique experiment name based on the model's hyperparameters, date, and time."""
+    now = datetime.datetime.now()
+    date_time_str = now.strftime("%Y%m%d_%H%M%S")
+    experiment_name = f"{prefix}_{date_time_str}"
+    return experiment_name
+
+
+def compute_policy_single_run(args):
+    """
+    Computes the policy for a single run in a reinforcement learning setup.
+
+    This function is designed to be executed in parallel, allowing for multiple
+    simulations to be run concurrently. It takes a tuple of arguments to facilitate
+    easy use with concurrent.futures.ProcessPoolExecutor.
+
+    Parameters:
+    - args: A tuple containing the following elements:
+        - env: A copy of the environment object, which should contain observation_space_vars
+               with 'group_id' attributes for 'state' and 'context', and support for 'reset',
+               'step', and state normalization methods.
+        - model: A copy of the model object used to predict the action given the current state.
+                 It should support a 'predict' method.
+        - run: The run number (integer).
+        - verbose: Verbosity level (integer). If set to 2, the function prints the run number.
+        - heuristics: A boolean flag indicating whether to use heuristics instead of the model
+                      for action prediction.
+
+    Returns:
+    - A dictionary with a single key-value pair. The key is a string identifying the run,
+      and the value is a Pandas DataFrame containing columns for time steps, context,
+      current state, action taken, new state after the action, and the reward received.
+    """
+    env, model, run, verbose, heuristics = args
+    state_space_index = env.observation_space_vars.loc[env.observation_space_vars['group_id'] == 'state', 'global_index'].values
+    if env.EnvironmentParameters['add_context']:
+        context_space_index = env.observation_space_vars.loc[env.observation_space_vars['group_id'] == 'context', 'global_index'].values
+
+    if verbose == 2:
+        print(f'Run No: {run}')
+        
+    env.reset()
+    norm_state = env.state
+
+    state = env.StateObj.setup.NormalizationManager.inverse_transform([norm_state[i] for i in state_space_index])
+    if env.EnvironmentParameters['add_context']:
+        context = env.ContextObj.NormalizationManager.inverse_transform([norm_state[i] for i in context_space_index])
+
+    done = False
+    t = 0
+    df_time, df_context, df_state, df_action, df_new_state, df_reward, df_costs = [], [], [], [], [], [], []
+
+    while not done:
+        if not heuristics:
+            action = model.predict(np.array(norm_state), deterministic=True)[0].item()
+        else:
+            action = model.predict(env)
+            
+        # if env.TempVars['damage_points']['current_state'].at['F', 'count'] > 0:
+        #     action
+        
+        norm_new_state, reward, done, truncation, costs = env.step(action)
+        
+        new_state = env.StateObj.setup.NormalizationManager.inverse_transform([norm_new_state[i] for i in state_space_index])
+        df_time.append(t)
+        if env.EnvironmentParameters['add_context']:
+            df_context.append(context)
+        df_state.append(state)
+        df_action.append(action)
+        df_new_state.append(new_state)
+        df_reward.append(reward)
+        df_costs.append(costs)
+        state = deepcopy(new_state)
+        norm_state = deepcopy(norm_new_state)
+        t += env.EnvironmentParameters['step_size']
+
+    current_state_space = pd.concat(df_state, axis=0).reset_index(drop=True).rename(columns=lambda x: f'Current_State_{x}')
+    new_state_space = pd.concat(df_new_state, axis=0).reset_index(drop=True).rename(columns=lambda x: f'New_State_{x}')
+    flattened_data = [{'Maintenance_cost': item['costs']['maintenance_cost'], 'Inspection_cost': item['costs']['inspection_costs'], 'Replacement_cost': item['costs']['replacement_cost'], 'Failure_cost': item['costs']['failure_cost']} for item in df_costs]
+    df_time_step = pd.DataFrame({'Time Step': df_time})
+    df_action = pd.DataFrame({'Action': df_action})
+    df_reward = pd.DataFrame({'Reward': df_reward})
+    flattened_df = pd.DataFrame(flattened_data)
+    dfs = [df_time_step, pd.concat(df_context, axis=0).reset_index(drop=True), current_state_space] if env.EnvironmentParameters['add_context'] else [df_time_step, current_state_space]
+    dfs += [df_action, new_state_space, df_reward, flattened_df]
+    result = pd.concat(dfs, axis=1)
+    
+    return result
+
+
+def compute_policy_serialized(args):
+    """
+    Wrapper function to deserialize env and model and then compute the policy.
+    Args are serialized versions of env, model, and any other arguments needed.
+    """
+    env_path, model_path, rl_alg, run_id, verbose, heuristics = args
+    with open(env_path, 'rb') as f:
+         env = dill.load(f)
+    
+    from stable_baselines3 import PPO, A2C, DQN
+    alg_classes = {'PPO': PPO, 'A2C': A2C, 'DQN': DQN}
+    model = alg_classes[rl_alg].load(model_path, custom_objects={"action_space": env.action_space, "observation_space": env.observation_space})
+    
+    return compute_policy_single_run((env, model, run_id, verbose, heuristics))
+
+def compute_policy(env, model, rl_alg='PPO', runs=1, verbose=0, heuristics=False, max_workers=None):
+    """
+    Executes compute_policy in parallel by serializing env and model using dill.
+    """
+    
+    results = []
+    temp_dir = None
+    
+    try:
+        if max_workers:
+            from multiprocessing import Pool
+            
+            # Prepare temporary directory for serialized objects
+            if not isinstance(env, str) or not isinstance(model, str):
+                temp_dir = './temp_' + ''.join(random.choices(string.ascii_letters + string.digits, k=10))
+                os.makedirs(temp_dir, exist_ok=True)
+                env_path = os.path.join(temp_dir, 'env.dill')
+                model_path = os.path.join(temp_dir, 'model.zip')
+                
+                with open(env_path, 'wb') as env_file:
+                    dill.dump(env, env_file)
+                model.save(model_path)
+                
+                env = env_path
+                model = model_path
+
+            args_list = [(env, model, rl_alg, run_id, verbose, heuristics) for run_id in range(runs)]
+            
+            # Execute the parallel computation
+            with Pool(processes=max_workers) as pool:
+                results = pool.map(compute_policy_serialized, args_list)
+        
+        else:
+            # Fallback to single-threaded execution if no workers are specified
+            for run_id in range(runs):
+                results.append(compute_policy_single_run((env, model, run_id, verbose, heuristics)))
+    
+    except Exception as e:
+        logging.error("An error occurred during policy computation: %s", e)
+        raise
+    finally:
+        if temp_dir:
+            # Clean up temporary files
+            try:
+                os.remove(env_path)
+                os.remove(model_path)
+                os.rmdir(temp_dir)
+            except Exception as cleanup_error:
+                logging.error("Error cleaning up temporary files: %s", cleanup_error)
+    
+    return results
+
+
+# def compute_policy(env, model, rl_alg='PPO', runs=1, verbose=0, heuristics=False, max_workers=None):
+#     """
+#     Executes compute_policy in parallel by serializing env and model using dill.
+#     """
+    
+#     if max_workers:
+#         from multiprocessing import Pool
+        
+#         temp_dir = None
+#         if not isinstance(env, str) or not isinstance(model, str):
+#             temp_dir = './temp_'+''.join(random.choices(string.ascii_letters + string.digits, k=10))
+#             if not os.path.exists(temp_dir):
+#                 os.makedirs(temp_dir)
+#             env_path = os.path.join(temp_dir, 'env.dill')
+#             model_path = os.path.join(temp_dir, 'model.zip')
+#             with open(env_path, 'wb') as env_file:
+#                 dill.dump(env, env_file)
+#             model.save(model_path)
+#             env = env_path
+#             model = model_path
+            
+#         # Prepare arguments for each parallel execution
+#         args_list = [(env, model, rl_alg, run_id, verbose, heuristics) for run_id in range(runs)]
+#         # Use multiprocessing Pool to execute in parallel
+#         with Pool(processes=max_workers) as pool:
+#             results = pool.map(compute_policy_serialized, args_list)
+            
+#         if temp_dir:
+#             os.remove(env_path)
+#             os.remove(model_path)
+#             os.rmdir(temp_dir)
+#     else:
+#         results = []
+#         for _ in range(runs):
+#             results.append(compute_policy_single_run((env, model, _, verbose, heuristics)))
+    
+#     return results
+
+
+def count_decimals(number):
+    """
+    Counts the number of decimal places in a given floating-point number.
+
+    Args:
+    - number (float): The floating-point number whose decimal places are to be counted.
+
+    Returns:
+    - int: The number of decimal places in the given number.
+    """
+    count = 0
+    while number != int(number):
+        number *= 10
+        count += 1
+    return count
+
+
+def identify_step_size(vector):
+    """
+    Identifies the most common step size between consecutive elements in a given vector.
+
+    Parameters:
+    vector (array-like): The input vector from which to calculate step sizes.
+
+    Returns:
+    int/float/None: The most common step size found in the vector. Returns None if the vector has 1 or 0 elements.
+    """
+    if len(vector) > 1:
+        step_sizes = np.diff(vector)
+        return mode(step_sizes, keepdims=False)[0]
+    else:
+        return None
+
+#%%
+def fetchActionsRewards(policy: dict) -> pd.DataFrame:
+    """
+    Extracts and analyzes actions and rewards from a given policy, structuring the data into pandas DataFrames.
+
+    This function processes a policy dictionary to identify all unique actions and time steps across the policy's
+    components. It then calculates the occurrence of each action at every time step and aggregates rewards associated
+    with these actions. The output includes two DataFrames: one for action occurrences over time and another for rewards
+    received for each action over time.
+
+    Parameters:
+    - policy (dict): A policy dictionary containing 'Time Step', 'Action', and 'Reward' information for different keys.
+
+    Returns:
+    - Tuple[pd.DataFrame, pd.DataFrame]: A tuple of two pandas DataFrames. The first DataFrame contains counts of each
+      action over the different time steps, and the second DataFrame contains the sum of rewards received for each
+      action at each time step. The 'time_step' column serves as the index for both DataFrames.
+
+    Note:
+    - This function assumes that the input policy dictionary is structured with keys representing different
+      scenarios or entities, each containing a dictionary with 'Time Step', 'Action', and 'Reward' as keys.
+    - Actions are considered unique globally across all scenarios or entities in the policy.
+    - The function internally converts lists or dictionaries within the 'Action' entries to strings for consistency.
+    """
+    # Concatenate time steps across all keys and find unique values
+    time_step = pd.concat([pd.Series(policy[key]['Time Step']) for key in policy], axis=1).stack().unique()
+    
+    # Concatenate actions across all keys
+    actions = pd.concat([pd.Series(policy[key]['Action']) for key in policy], axis=1)
+    # Convert lists or dicts within actions to string, otherwise keep them unchanged
+    actions = actions.applymap(lambda x: str(x) if isinstance(x, list) or isinstance(x, dict) else x)
+    # Find unique actions
+    unique_actions = pd.unique(actions.values.ravel('K'))
+
+    # Prepare dictionary to hold counts of each action over time steps
+    actions_over_time = {'action_' + str(action): [] for action in unique_actions}
+    actions_over_time['time_step'] = list(time_step)
+
+    # Count occurrences of each action for each time step
+    for row in actions.index:
+        row_data = actions.loc[row]
+        for action in unique_actions:
+            actions_over_time['action_' + str(action)].append((row_data == action).sum())
+
+    # Convert the dictionary to DataFrame and set 'time_step' as index
+    actions_over_time = pd.DataFrame(actions_over_time).set_index('time_step')
+    
+    # Rewards:
+    rewards = pd.concat([pd.Series(policy[key]['Reward']) for key in policy], axis=1)
+    rewards.columns = range(rewards.shape[1])
+    actions.columns = range(actions.shape[1])
+        
+    reward_over_time = {'reward_action_' + str(action): [] for action in unique_actions}
+    reward_over_time['time_step'] = list(time_step)
+    
+    for _ in rewards.index:
+        for a in unique_actions:
+            idx = actions.loc[_] == a
+            reward_over_time['reward_action_' + str(a)].append(rewards.loc[_][idx].sum())
+            
+    reward_over_time  = pd.DataFrame(reward_over_time).set_index('time_step')
+
+    # Validate if action counts across all time steps are consistent
+    if len(actions_over_time.sum(axis=1).unique()) != 1:
+        raise ValueError('The actions counts is inconsistent.')
+    return actions_over_time, reward_over_time
+
+
+#%% Compute error metrics:
+def comp_error(y, yp, states, metric='RMSE', num_params=None):
+    """
+    Compute the error between ground truth and predicted values based on a specified metric.
+    
+    Parameters:
+    - y (DataFrame): The ground truth data, containing at least 'state' and 'count' columns.
+    - yp (DataFrame): The predicted probabilities for each state.
+    - states (list): A list of the unique states to consider in the computation.
+    - metric (str, optional): The metric to use for computing the error. Defaults to 'LogL' for log likelihood.
+      Currently, only 'LogL' is supported.
+    
+    Returns:
+    - float: The computed error based on the specified metric.
+    
+    Raises:
+    - ValueError: If an unsupported error metric is specified.
+    """
+    metric = metric.lower()
+    if metric == 'logl':
+        return -log_likelihood(y, yp, states)
+    elif metric == 'aic':
+        return aic(y,yp,states,num_params)
+    elif metric == 'bic':
+        return bic(y,yp,states,num_params)
+    elif metric == 'rmse':
+        return root_mean_squared_error(y, yp, states)
+    elif metric.lower() == 'mse':
+        return mean_squared_error(y, yp, states)
+    elif metric == 'se':
+        return squared_error(y, yp, states)
+    else:
+        raise ValueError('The error_metric is not defined.')
+        
+def aic(y, yp, states, num_params):
+    """
+    Calculate the Akaike Information Criterion for a set of observations and predictions.
+
+    Args:
+    y (array-like): Observed values.
+    yp (array-like): Predicted values, typically from a model.
+    states (array-like): State information associated with each observation.
+    num_params (int): Number of parameters in the model.
+
+    Returns:
+    float: The AIC score.
+    """
+    logl = log_likelihood(y, yp, states)
+    return 2 * num_params - 2 * logl
+    
+def bic(y, yp, states, num_params):
+    """
+    Calculate the Bayesian Information Criterion for a set of observations and predictions.
+
+    Args:
+    y (array-like): Observed values.
+    yp (array-like): Predicted values, typically from a model.
+    states (array-like): State information associated with each observation.
+    num_params (int): Number of parameters in the model.
+
+    Returns:
+    float: The BIC score.
+    """
+    logl = log_likelihood(y, yp, states)
+    num_obs = y['count'].sum()  # Assuming 'count' is a column in y that sums to the total number of observations
+    return np.log(num_obs) * num_params - 2 * logl
+
+
+def differentiate_and_resample(x, y, num_points=100):
+    """
+    Differentiates the function y with respect to x by resampling to create
+    a more evenly spaced x array, and then calculating the numerical derivative.
+    
+    Args:
+    - x (np.array): The original x values.
+    - y (np.array): The y values corresponding to x.
+    - num_points (int): Number of points for resampling.
+
+    Returns:
+    - x_mid (np.array): The midpoints of the resampled x values.
+    - dy_dx (np.array): The derivative of y with respect to the resampled x.
+    """
+    # Resample x and y to be more evenly spaced
+    x_even = np.linspace(np.min(x), np.max(x), num_points)
+    interpolate_y = interp1d(x, y, kind='cubic', fill_value="extrapolate")
+    y_even = interpolate_y(x_even)
+    
+    # Calculate numerical derivative of the resampled data
+    dx = np.diff(x_even)
+    dy = np.diff(y_even)
+    dy_dx = dy / dx
+    x_mid = x_even[:-1] + dx / 2
+    
+    return x_mid, dy_dx
+
+def log_likelihood(y, yp, states):
+    """
+
+    """
+    yp = yp.cumsum(axis=1) # --> To obtain the survival curves
+    ft = {s: differentiate_and_resample(x=np.array(yp.index), y=np.array(yp[s]), num_points=1000) for s in states}
+    df = pd.DataFrame({s: -ft[s][1].T for s in states})
+    df = df.set_index(ft[states[0]][0])
+    t = np.array(yp.index)
+    interp_values = {column: np.interp(t, df.index, df[column]) for column in df.columns}
+    log = pd.DataFrame(interp_values, index=t)
+    
+    n = pd.DataFrame(0, columns=states, index=y.index)
+    for s in states:
+        n[s] = np.where(y['state'] == s, y['count'], 0)
+        
+    #n = n / n.sum()
+        
+    #y_grouped = y.groupby('state')['count'].sum()
+    #W = y_grouped.max() / y_grouped
+    #sum(W[s] * np.sum(np.log(yp.loc[y[y['state'] == s].index, s] + 1E-100) * y[y['state'] == s]['count']) for s in states)
+    # sum(np.sum(np.log(yp.loc[y[y['state'] == s].index, s] + 1E-100) * y[y['state'] == s]['count']) for s in states)
+
+    # Evaluate the data points:
+    transitions = [(1,2),(1,'F'),(2,3),(2,'F'),(3,4),(4,'F'),(4,5),(5,'F')]
+    log_likelihood = 0
+    for s in states:
+        for t in transitions:
+            if s == t[0]:
+                log_likelihood += (np.log(log[s]+1E-323) * n[t[1]]).sum()
+    return log_likelihood
+
+
+def squared_error(y, yp, states):
+    """
+    Calculate the squared error between actual and predicted values,
+    adjusted by the 'total_count' from the predictions.
+    
+    Parameters:
+    - y (pd.DataFrame): Actual values with states as indexes and categories as columns.
+    - yp (pd.DataFrame): Predicted values with states as indexes, categories as columns, 
+      and a 'total_count' column for weighting the error.
+    - states (list): List of states to consider in the error calculation.
+    
+    Returns:
+    - float: The weighted squared error.
+    """
+    if 'total_count' not in y.columns.tolist():
+        y['total_count'] = 1
+    
+    return sum([((y[s]-yp[s])**2).multiply(y['total_count'],axis=0).sum() for s in states]) 
+
+def mean_squared_error(y, yp, states):
+    """
+    Calculate the mean squared error between actual and predicted values,
+    considering only specified states and adjusting for total counts in predictions.
+    
+    Parameters:
+    - y (pd.DataFrame): Actual values with states as indexes and categories as columns.
+    - yp (pd.DataFrame): Predicted values with states as indexes, categories as columns,
+      and a 'total_count' column for normalization.
+    - states (list): List of states to consider in the error calculation.
+    
+    Returns:
+    - float: The calculated mean squared error.
+    """
+    return squared_error(y, yp, states) / (y['total_count'].sum() * len(states))
+
+def root_mean_squared_error(y, yp, states):
+    """
+    Calculate the root mean squared error (RMSE) between actual and predicted values, 
+    considering only specified states and adjusting for total counts in predictions.
+    
+    Parameters:
+    - y (pd.DataFrame): Actual values with states as rows and categories as columns.
+    - yp (pd.DataFrame): Predicted values with states as rows, categories as columns, 
+      and a 'total_count' column for normalization.
+    - states (list): List of states to consider in the error calculation.
+    
+    Returns:
+    - float: The calculated RMSE value.
+    """
+    return np.sqrt(mean_squared_error(y, yp, states))
+
+#%%
+def capture_function_call(function, kwargs={}, output_path="."):
+    """
+    Captures a function call by generating a script that includes the function call with specified keyword arguments.
+
+    Parameters:
+    - function: The function to capture the call of.
+    - kwargs (dict, optional): A dictionary of keyword arguments to pass to the function. Defaults to an empty dictionary.
+    - output_path (str, optional): The output directory where the generated script should be saved. Defaults to the current directory.
+
+    This function assumes that `generate_script_with_params` is correctly defined to handle these parameters.
+    It creates the necessary directories if they do not exist and calls `generate_script_with_params` to generate the script.
+    """
+    os.makedirs(os.path.dirname(output_path), exist_ok=True)
+    generate_script_with_params(function, kwargs, output_path)
+
+def generate_script_with_params(function, params, output_path="."):
+    """
+    Generates a script from an existing Python script file, replacing the main function call with specified parameters.
+
+    Parameters:
+    - function: The function object whose call is to be captured in the generated script. The function's file location is used to read the original script.
+    - params (dict): A dictionary of parameters to be passed to the function in the generated script.
+    - output_path (str, optional): The directory where the generated script should be saved. Defaults to the current directory.
+    """
+    filename = function.__code__.co_filename
+    with open(filename, 'r') as file:
+        script_content = file.read()
+
+    # Convert params dictionary to a string suitable for insertion into the script
+    args_dict_str = ', '.join(f"{k}={repr(v)}" for k, v in params.items())
+    new_args_call = f"args = vars(parse_args())\n    main({args_dict_str})"
+
+    # Define the regex pattern to replace the main function call in the original script
+    main_call_regex = re.compile(
+        r"if __name__ == '__main__':.*?main\(.*?\)",
+        re.DOTALL
+    )
+
+    # Replace the original main call with the new one
+    modified_script = main_call_regex.sub(f"if __name__ == '__main__':\n    from multiprocessing import freeze_support\n    freeze_support()\n    {new_args_call}", script_content)
+
+    # Ensure the output directory exists
+    os.makedirs(output_path, exist_ok=True)
+    new_filename = os.path.join(output_path, "TrainAgents.py")
+
+    # Save the modified script
+    with open(new_filename, 'w') as new_file:
+        new_file.write(modified_script)
+    
+    print(f"Modified script saved as {new_filename}")
+#%%
+def eval_policy_kwargs(value, activation_function_name='ReLU'):
+    """Evaluate and update policy kwargs with the specified activation function."""
+    # Instantiate ActivationFunctions class
+    activations = ActivationFunctions()
+    # Dynamically get the activation function based on the name
+    activation_fn = getattr(activations, activation_function_name.lower(), activations.relu)()
+    # Evaluate the policy kwargs string to dict
+    policy_kwargs = dict(activation_fn=activation_fn,
+                         net_arch=eval(value))
+    return policy_kwargs
+#%% Activation functions
+import torch.nn as nn
+
+class ActivationFunctions:
+    def relu(self):
+        """ReLU (Rectified Linear Unit)
+        f(x) = max(0, x)
+        """
+        return nn.ReLU
+
+    def leaky_relu(self):
+        """LeakyReLU
+        f(x) = x if x > 0 else alpha * x
+        """
+        return nn.LeakyReLU
+
+    def elu(self):
+        """ELU (Exponential Linear Unit)
+        f(x) = x if x >= 0 else alpha * (exp(x) - 1)
+        """
+        return nn.ELU
+
+    def selu(self):
+        """SELU (Scaled Exponential Linear Unit)
+        Self-normalizing activation function
+        """
+        return nn.SELU
+
+    def gelu(self):
+        """GELU (Gaussian Error Linear Unit)
+        f(x) = 0.5 * x * (1 + tanh(sqrt(2 / pi) * (x + 0.044715 * x^3)))
+        """
+        return nn.GELU
+
+    def sigmoid(self):
+        """Sigmoid
+        f(x) = 1 / (1 + exp(-x))
+        """
+        return nn.Sigmoid
+
+    def softmax(self):
+        """Softmax
+        Softmax is applied to the last dimension
+        """
+        return nn.Softmax #--> You need to add the dim argument.
+
+    def softplus(self):
+        """Softplus
+        f(x) = log(1 + exp(x))
+        """
+        return nn.Softplus
+
+    def prelu(self):
+        """PReLU (Parametric ReLU)
+        f(x) = x if x > 0 else alpha * x; alpha is a learnable parameter
+        """
+        return nn.PReLU
+
+    def tanh(self):
+        """Tanh
+        f(x) = (exp(x) - exp(-x)) / (exp(x) + exp(-x))
+        """
+        return nn.Tanh
+    
+#%% Learning rate schedulers:
+class Scheduler:
+    def __init__(self):
+        """
+        Initializes a Scheduler object with a dictionary mapping schedule names to their corresponding methods.
+        """
+        self.schedules = {
+            'linear': self.linear_schedule,
+            'polynomial': self.polynomial_schedule,
+            'exponential': self.exponential_schedule,
+            'step': self.step_schedule,
+            'constant': self.constant_schedule
+        }
+
+    def constant_schedule(self, initial_value: float) -> Callable[[float], float]:
+        """
+        Returns a constant schedule function that always returns the initial_value.
+
+        Parameters:
+        - initial_value (float): The value to be returned by the schedule function.
+
+        Returns:
+        - Callable[[float], float]: A function that takes progress_remaining as input and returns initial_value.
+        """
+        def func(_progress_remaining: float) -> float:
+            return initial_value
+        return func
+
+    def linear_schedule(self, initial_value: float) -> Callable[[float], float]:
+        """
+        Returns a linear schedule function that linearly decreases the value based on the progress remaining.
+
+        Parameters:
+        - initial_value (float): The starting value at the beginning of the schedule.
+
+        Returns:
+        - Callable[[float], float]: A function that takes progress_remaining as input and returns a value that linearly interpolates to 0 based on initial_value.
+        """
+        def func(progress_remaining: float) -> float:
+            return progress_remaining * initial_value
+        return func
+
+    def polynomial_schedule(self, initial_value: float, power=2) -> Callable[[float], float]:
+        """
+        Returns a polynomial schedule function that decreases the value based on the progress remaining raised to a given power.
+
+        Parameters:
+        - initial_value (float): The starting value at the beginning of the schedule.
+        - power (int, optional): The power to which the progress_remaining is raised. Defaults to 2.
+
+        Returns:
+        - Callable[[float], float]: A function that takes progress_remaining as input and returns a value that decreases polynomially based on initial_value.
+        """
+        def func(progress_remaining: float) -> float:
+            return (progress_remaining ** power) * initial_value
+        return func
+
+    def exponential_schedule(self, initial_value: float, decay_rate=0.5) -> Callable[[float], float]:
+        """
+        Returns an exponential schedule function that decreases the value based on an exponential decay function of the progress remaining.
+
+        Parameters:
+        - initial_value (float): The starting value at the beginning of the schedule.
+        - decay_rate (float, optional): The rate of exponential decay. Defaults to 0.5.
+
+        Returns:
+        - Callable[[float], float]: A function that takes progress_remaining as input and returns a value that decreases exponentially based on initial_value.
+        """
+        def func(progress_remaining: float) -> float:
+            return (decay_rate ** (1 - progress_remaining)) * initial_value
+        return func
+
+    def step_schedule(self, initial_value: float, drop_rate=0.5, step_size=0.25) -> Callable[[float], float]:
+        """
+        Returns a step schedule function that decreases the value in steps based on the progress remaining.
+
+        Parameters:
+        - initial_value (float): The starting value at the beginning of the schedule.
+        - drop_rate (float, optional): The factor by which the value is reduced at each step. Defaults to 0.5.
+        - step_size (float, optional): The size of each step as a proportion of the total progress. Defaults to 0.25.
+
+        Returns:
+        - Callable[[float], float]: A function that takes progress_remaining as input and returns a value that decreases in steps based on initial_value.
+        """
+        def func(progress_remaining: float) -> float:
+            step = int((1 - progress_remaining) / step_size)
+            return (drop_rate ** step) * initial_value
+        return func
+
+    def get(self, name: str, initial_value: float, **kwargs) -> Callable[[float], float]:
+        """
+        Returns a schedule function specified by name, initialized with the given initial value and any additional keyword arguments.
+
+        Parameters:
+        - name (str): The name of the schedule function to return.
+        - initial_value (float): The initial value for the schedule function.
+        - **kwargs: Additional keyword arguments specific to the schedule function.
+
+        Returns:
+        - Callable[[float], float]: The specified schedule function.
+
+        Raises:
+        - ValueError: If the specified schedule name does not exist.
+        """
+        if name not in self.schedules:
+            raise ValueError(f"Invalid schedule name: {name}")
+            
+        self.name = name
+        self.initial_value = initial_value
+        
+        return self.schedules[name](initial_value, **kwargs)
+    
+    def plot(self,**kwargs):
+        """
+        Plots the learning rate behavior of a schedule given its name, initial value, and any additional arguments.
+
+        Parameters:
+        - name (str): The name of the schedule.
+        - initial_value (float): The initial value for the schedule, often representing the learning rate at the start.
+        - **kwargs: Additional keyword arguments specific to the schedule function.
+        """
+        name = kwargs.get('name',self.name) 
+        initial_value = kwargs.get('initial_value',self.initial_value) 
+        if name not in self.schedules:
+            raise ValueError(f"Invalid schedule name: {name}")
+        schedule_func = self.get(name, initial_value, **kwargs)
+        progress_remaining = [i * 0.01 for i in range(100)]
+        values = [schedule_func(1 - i) for i in progress_remaining]
+        plt.plot(progress_remaining, values)
+        plt.xlabel('Progress Remaining')
+        plt.ylabel('Learning Rate')
+        plt.title(f'{name.capitalize()} Schedule')
+        plt.show()
+        
+        
+#%%
+def load_wandb_callback(Obj):
+    """
+    Initializes and configures the Weights and Biases (WandB) callback for training monitoring.
+    
+    Args:
+    Obj (object): An object that contains configuration settings and paths required for WandB setup.
+    
+    Returns:
+    WandBCallback: A configured WandB callback object if logging is enabled in Obj configuration.
+    None: Returns None if logging is disabled or WandB login fails.
+    
+    This function handles the login process to WandB with a specified API key, switches to offline mode if the login fails, 
+    and configures a WandB callback object using settings from Obj if logging is enabled.
+    """
+    if Obj.config['log_wandb']:
+        
+        from WandBCallback import WandBCallback
+        import wandb
+        import warnings
+        from copy import deepcopy
+    
+        success = wandb.login(key='82cc2d8c7bd3728badcb4372ebdf7ff2c4be9c9f', relogin=True)
+        if not success:
+            warnings.warn(f"Not possible to connect with Web and Biases, storing results locally in {Obj.save_path_dir}/wandb")
+            wandb.offline()
+            
+        Obj.params = deepcopy(Obj.config)
+        Obj.params = {k: v for k, v in Obj.params.items() if k not in ['current_script_path','tensorboard_log','experiment_setup','policy','policy_evaluation','policy_kwargs','progress_bar','save_path_dir','verbose']}
+        Obj.project_id
+        return WandBCallback(Obj, wandb)
+    else:
+        return None
+
+
+def load_check_point(Obj):
+    """
+    Loads the checkpoint for the given object if it has any.
+
+    Args:
+    Obj (object): An object that must have a `check_point` attribute which indicates
+                  whether to load a checkpoint. The object should also contain `save_path_dir`,
+                  `config`, and `algorithm` attributes used to configure the checkpoint.
+
+    Returns:
+    SaveCheckPoint|None: Returns a configured SaveCheckPoint callback if `check_point` is True.
+                         Returns None if `check_point` is False.
+    """
+    from SaveCheckPoint import SaveCheckPoint
+
+    if Obj.check_point:
+        save_path = os.path.join(Obj.save_path_dir, 'check_point')
+        os.makedirs(save_path, exist_ok=True)
+        checkpoint_callback = SaveCheckPoint(
+            check_freq=Obj.config['n_steps'], 
+            save_path=save_path,
+            log_dir=Obj.config['tensorboard_log'],
+            alg=Obj.algorithm, 
+            verbose=Obj.config['verbose']
+        )
+        return checkpoint_callback
+    else:
+        return None
+    
+    
+        
+# def save_csv_file_hyperaparam_opt(Obj):
+#     """
+
+#     """
+#     from SaveCheckPoint import SaveCheckPoint
+#     save_path = os.path.join(Obj.save_path_dir, 'check_point')
+#     os.makedirs(save_path, exist_ok=True)
+#     checkpoint_callback = SaveCheckPoint(
+#         check_freq=Obj.config['n_steps'], 
+#         save_path=save_path,
+#         log_dir=Obj.config['tensorboard_log'],
+#         alg=Obj.algorithm, 
+#         verbose=Obj.config['verbose']
+#     )
+#     return checkpoint_callback
+
+
+def id_model_type(job):
+    if not job.config.get('fully_observable') and job.config.get('fix_context') == {}:
+        model_type = 'CPOMDP'
+    elif job.config.get('fully_observable') and job.config.get('fix_context') == {}:
+        model_type = 'CMDP'
+    elif not job.config.get('fully_observable') and job.config.get('fix_context') != '{}':
+        if job.config.get('fix_context') == {"pipe_material":"concrete","pipe_content":"stormwater","pipe_length":40,"pipe_diameter":0.2}:
+            _var = 'CS'
+        elif job.config.get('fix_context') == {"pipe_material":"concrete","pipe_content":"mixed","pipe_length":40,"pipe_diameter":0.2}:
+            _var = 'CMW'
+        model_type = 'POMDP_'+_var
+    elif job.config.get('fully_observable') and job.config.get('fix_context') != '{}':
+        if job.config.get('fix_context') == {"pipe_material":"concrete","pipe_content":"stormwater","pipe_length":40,"pipe_diameter":0.2}:
+            _var = 'CS'
+        elif job.config.get('fix_context') == {"pipe_material":"concrete","pipe_content":"mixed","pipe_length":40,"pipe_diameter":0.2}:
+            _var = 'CMW'
+        model_type = 'MDP_'+_var
+    return model_type
\ No newline at end of file
diff --git a/scripts/dtmc.py b/scripts/dtmc.py
new file mode 100644
index 0000000..035d5a4
--- /dev/null
+++ b/scripts/dtmc.py
@@ -0,0 +1,279 @@
+import pandas as pd
+from lifelines import KaplanMeierFitter as KM
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib.pyplot as plt
+import dill
+import os
+from markov_chain_structures import MarkovChainStructure
+from markov_chain_calibration import MarkovChainCalibration
+from scipy.integrate import odeint
+from aux_functions import renormalize_mass_function, comp_error, getFrequencyTable, identify_step_size
+from aux_common_functions_ihtmc_dtmc import compute_error, renormalize_rows, sample, fit
+from scipy.linalg import fractional_matrix_power as multMat
+
+class HomogeneousDiscreteTimeMarkovChain:
+    """
+    Represents an inhomogeneous time Markov chain model for simulating and analyzing
+    state transitions over time with time-varying transition rates.
+    
+    This class integrates functionalities for loading data, fitting the model using
+    various statistical methods, predicting future states, and handling input and
+    output operations for model variables.
+    """
+    
+    def __init__(self, df=pd.DataFrame(), hazard_function = None, MCStructureID ='ihtmc_s2_typeA',  verbose=1):
+        """
+        Initializes the InhomogeneousTimeMarkovChain with optional data and verbosity level.
+        
+        Parameters:
+        - df (pd.DataFrame, optional): A pandas DataFrame to initialize the model. Default is an empty DataFrame.
+        - verbose (int, optional): Verbosity level where 1 indicates verbose output and 0 silent operation. Default is 1.
+        """
+        self.df = df
+        self.df_freq = pd.DataFrame()
+        self.verbose = verbose
+        self.list_models = pd.DataFrame()
+        self.MCObj = self.load_MCObj(MCStructureID=MCStructureID,MCType='dtmc')
+        
+    def error(self, y=pd.DataFrame(), yp=pd.DataFrame(), metric='RMSE'):
+        """
+        Computes the error between actual and predicted values using a specified metric.
+    
+        Parameters:
+        - self: The object instance.
+        - y (pd.DataFrame, optional): The actual values. Defaults to an empty DataFrame.
+        - yp (pd.DataFrame, optional): The predicted values. Defaults to an empty DataFrame.
+        - metric (str, optional): The metric to use for computing error. Defaults to 'RMSE'.
+    
+        Returns:
+        - The error computed using the specified metric between the actual and predicted values.
+        """
+        return compute_error(self, y=y, yp=yp, metric=metric)
+        
+    def load_MCObj(self,MCStructureID='ihtmc_s6_typeA',function=None,MCType='dtmc'):
+        """
+        Loads a Markov Chain Structure object with specified states, name, and function.
+        
+        Parameters:
+        - states (list of int, optional): List of states in the Markov Chain. Default is [1,2,3,4,5,6].
+        - name (str, optional): Name of the Markov Chain. Default is 'Type A'.
+        - function (str, optional): The function used for calculating transition probabilities. Default is 'gompertz'.
+        
+        Returns:
+        - MarkovChainStructure: An initialized Markov Chain Structure object.
+        """
+        return MarkovChainStructure(MCStructureID=MCStructureID,function=function,MCType=MCType)
+
+    def fit(self, **kwargs):
+        """
+        Fits a model to the data.
+    
+        This function assigns the result of a fitting operation to the attribute `MCObj`. The fitting operation is performed by calling the `fit` function with `self` and a dictionary of arguments `kwargs`.
+    
+        Parameters:
+        **kwargs: Variable keyword arguments passed to the `fit` function.
+    
+        Returns:
+        None
+        """
+        self.MCObj = fit(self, args=kwargs)
+
+    def fetch_data(self,df):
+        """
+
+        """
+        if df.empty and not self.df.empty:
+            return self.df
+        else:
+            raise ValueError('There is not data to use to fit the model.')
+    
+    def renormalize_rows(self, dataframe, tolerance=0.01):
+        """
+        Renormalizes the rows of a dataframe to ensure that the sum of values in each row is 1.0,
+        within a specified tolerance.
+    
+        Parameters:
+        - self: The object instance.
+        - dataframe: The DataFrame to be renormalized.
+        - tolerance (float, optional): The tolerance within which the sum of row values must be to 1.0. Defaults to 0.01.
+    
+        Returns:
+        - A DataFrame with rows renormalized to sum to 1.0, within the specified tolerance.
+        """
+        return renormalize_rows(dataframe=dataframe, tolerance=tolerance)
+    
+    def predict(self, params=dict(), t=np.linspace(0, 50), complete_NaN=True, ConverenceDetails=False):
+        """
+        Predicts the state probabilities over time for a discrete-time Markov chain (DTMC).
+    
+        This method calculates the probability distribution of states over a specified time
+        range, using either matrix power method or interpolation, based on the step size
+        of the time vector.
+    
+        Parameters:
+        - params (dict, optional): A dictionary containing 's0' (initial state distribution)
+          and 'x' (external inputs). If not provided, these values are taken from the
+          Markov chain object associated with this instance.
+        - t (array_like, optional): A time vector over which the state probabilities are
+          to be calculated. Defaults to a linearly spaced vector from 0 to 50.
+        - complete_NaN (bool, optional): If True, any NaN values in the resulting probability
+          distributions will be forward-filled. Defaults to True.
+    
+        Returns:
+        - p (DataFrame): A pandas DataFrame containing the state probabilities over time,
+          with each row corresponding to a time point specified in 't' and each column
+          representing a state.
+    
+        Note:
+        - The method used for prediction ('matrix_power' or 'interpolation_method') is
+          determined based on whether the step size in 't' is an integer.
+        """
+        # Determine initial state and external inputs
+        s0, x = (self.MCObj.s0, self.MCObj.x) if not params else (params['s0'], params['x'])
+        
+        # Adjust initial state if the first time point is not zero
+        step_size = identify_step_size(t)
+        steps = t
+        method = 'interpolation_method' if step_size % 1 == 0 else 'matrix_power'
+        s0 = pd.DataFrame(
+            self.solve_dtmc(s0=s0, P=self.MCObj.P(), steps=[0, max(steps[0])], step_size=step_size, method=method),
+            columns=self.MCObj.states
+        ).iloc[-1].to_numpy() if t[0] != 0.0 else s0
+        
+        # Solve DTMC and organize results in a DataFrame
+        p = pd.DataFrame(
+            self.solve_dtmc(s0=s0, P=self.MCObj.P(), steps=steps, method=method),
+            columns=self.MCObj.states
+        )
+        p = self.renormalize_rows(p)
+        p.index = steps
+        
+        # Forward-fill NaN values if requested
+        if complete_NaN and p.isnull().any().any():
+            p.fillna(method='ffill', inplace=True)
+        
+        if ConverenceDetails:
+            return p, True
+        else:
+            return p
+    
+    def solve_dtmc(self, s0, P, steps, method='matrix_power'):
+        """
+        Solves the discrete-time Markov chain (DTMC) for given steps and method.
+    
+        Parameters:
+        - s0 (array-like): The initial state distribution.
+        - P (matrix): Transition matrix of the DTMC.
+        - steps (list): The time steps at which the DTMC is solved.
+        - method (str): The method used to solve the DTMC. Can be 'matrix_power' or 'interpolation_method'. Defaults to 'matrix_power'.
+    
+        Returns:
+        - s (ndarray): An array containing the state distributions at each step.
+        """
+        if not isinstance(s0, np.ndarray):
+            s0 = np.array(s0)
+        if method == 'interpolation_method':
+            s = np.array([s0.dot(multMat(P, step)).T for step in list(steps)])
+        elif method == 'matrix_power':
+            s = np.array([s0.dot(np.linalg.matrix_power(P, step)).T for step in list(steps.astype(int))])
+        return s
+
+
+    def getTransitionProbabilityMatrix(self, params=dict(), t=np.linspace(0, 50), atol=1e-5, rtol=1e-5,output_format='dataframe'):
+        """
+        Computes and returns a pandas DataFrame of transition probabilities for a Markov chain. The DataFrame's index are the time steps,
+        and the columns are named as tuples representing (from, to) state transitions. Each cell contains the transition probability
+        for its corresponding (from, to) state pair at the given time step.
+    
+        Parameters:
+        - params (dict): Dictionary with 's0' and 'x' to override self.MCObj's initial state and control parameter if provided.
+        - t (np.ndarray): Time points array for which the transition probabilities are calculated.
+        - atol (float): Absolute tolerance for the ODE solver.
+        - rtol (float): Relative tolerance for the ODE solver.
+    
+        Returns:
+        - DataFrame: Transition probabilities with times as index and (from, to) tuples as columns.
+        """
+        s0, x = (self.MCObj.s0, self.MCObj.x) if not params else (params['s0'], params['x'])
+        state_len = len(self.MCObj.states)
+        idMatrix = np.identity(state_len).flatten()
+        P = {}
+        for t_i, t_j in zip(t[0:-1],t[1:]):
+            sol = odeint(self.dPdt, idMatrix, t=[t_i, t_j], args=(x, True), atol=atol, rtol=rtol)
+            P[t_j] = renormalize_mass_function(sol[-1].reshape(-1,state_len))
+        
+        if output_format == 'dataframe':
+            columns = [(from_state, to_state) for from_state in self.MCObj.states for to_state in self.MCObj.states]
+            data = {i: P[i].reshape(state_len, state_len).flatten() for i in list(P.keys())}
+            df = pd.DataFrame(data, index=columns).T
+            return df
+        elif output_format == 'dictionary':
+            return P
+    
+    def sample(self, t=np.linspace(0, 50), n=1000, states=[], exact_t_spacing=False):
+        """
+        Samples observations based on the defined parameters and configurations of the model.
+    
+        Parameters:
+        - self: The object instance.
+        - t (array-like, optional): The time points for which to sample. Defaults to a linear space between 0 and 50.
+        - n (int, optional): The number of observations to sample. Defaults to 1000.
+        - states (list, optional): The specific states from which to sample. If empty, samples from all states. Defaults to an empty list.
+        - exact_t_spacing (bool, optional): Determines if the sampling should occur at exact time points specified in `t` or at random times within the range defined by `t`. Defaults to False.
+    
+        Returns:
+        - A DataFrame containing the sampled observations, structured to include the sampled times, states, and their frequencies.
+        """
+        return sample(self, t=t, n=n, states=states, exact_t_spacing=exact_t_spacing)
+
+
+    def plot(self, t=np.arange(0, 50),atol=1e-4,rtol=1e-4):
+        
+        p = self.predict(t=t,atol=atol,rtol=rtol)
+        plt.plot(p.index,p,label=self.MCObj.states)
+        plt.xlabel('Time')
+        plt.ylabel('State probability')
+        plt.grid()
+    
+    def save(self, var=None, filename='variable', path=''):
+        """
+        Saves 'var' to a file using dill in the specified path.
+
+        Args:
+            var: The variable (typically a DataFrame) to save.
+            filename (str, optional): The name of the file to save the variable to. Defaults to 'dataframe.dill'.
+            path (str, optional): The directory path where the file will be saved. Defaults to the current directory.
+        """
+        if not var:
+            var = self # --> save the whole object
+            
+        filename = filename + '.dill'
+        full_path = os.path.join(path, filename)
+        if not os.path.exists(path):
+            os.makedirs(path)
+        with open(full_path, 'wb') as file:
+            dill.dump(var, file)
+        print(f"Variable saved to {full_path}.")
+
+    def load(self, filename='variable', path=''):
+        """
+        Loads a DataFrame from a file using dill from the specified path.
+
+        Args:
+            filename (str, optional): The name of the file to load the DataFrame from. Defaults to 'dataframe.dill'.
+            path (str, optional): The directory path from where the file will be loaded. Defaults to the current directory.
+        """
+        filename = filename + '.dill'
+        full_path = os.path.join(path, filename)
+        try:
+            with open(full_path, 'rb') as file:
+                return dill.load(file)
+            print(f"DataFrame loaded from {full_path}.")
+        except FileNotFoundError:
+            print(f"No file found with the name {full_path}.")
+            
+
+    
+if __name__ == "__main__":
+    model = HomogeneousDiscreteTimeMarkovChain()
\ No newline at end of file
diff --git a/scripts/generateToyMCExamples.py b/scripts/generateToyMCExamples.py
new file mode 100644
index 0000000..2727894
--- /dev/null
+++ b/scripts/generateToyMCExamples.py
@@ -0,0 +1,58 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 15:22:52 2024
+
+@author: lisandro
+"""
+from ihtmc import InhomogeneousTimeMarkovChain as IHTMC
+from markov_chain_calibration import MarkovChainCalibration as MCCal
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+import os
+from mpl_toolkits.mplot3d import Axes3D
+import random
+
+plt.close('all')
+#%% Functions
+def random_color():
+    return "#{:06x}".format(random.randint(0, 0xFFFFFF))
+def generate_random_samples(n, bounds):
+    return np.random.uniform(low=[b[0] for b in bounds], high=[b[1] for b in bounds], size=(n, len(bounds)))
+#%% Input parameters:
+t_from = 0
+t_to   = 50
+functions = ['lognormal','loglogistic','gompertz','exponential','weibull']
+path='../../degradation_models/toy_models_ihtmc_s2_typeA'
+MCStructureID = 'ihtmc_s2_typeA'
+#%% Ground-truth Markov chain
+ground_truth_MC = IHTMC(MCStructureID=MCStructureID)
+ground_truth_MC.MCObj.x  = np.array([0.05,0.1])
+ground_truth_MC.MCObj.s0 = np.array([0.9,0.1])
+g = ground_truth_MC.predict(t=np.linspace(t_from,t_to,1000),atol=1e-4, rtol=1e-4)  # Removed colon at the end
+#%% Randomly sample from Markov chain --> Generate synthetic dataset.
+num_inspections = 10000
+ti = np.array(g.index)
+s = np.array([int(i[2:]) for i in g.columns])
+times = np.random.uniform(t_from, t_to, num_inspections)
+choices = [np.random.choice(s, p=g.iloc[np.argmin(np.abs(t - ti))].values) for t in times]
+obs = np.column_stack((times, choices))
+system_inspections = pd.DataFrame(obs, columns=['time', 'state']).sort_values(by='time', ascending=True).reset_index(drop=True)
+system_inspections['state'] = system_inspections['state'].astype(int)
+system_inspections.set_index('time', inplace=True)
+#%% Markov chains models:
+models = {}
+for pdf in functions:
+    models[pdf] = IHTMC(df=system_inspections,MCStructureID=MCStructureID,hazard_function=pdf)
+    if os.path.exists(path+'/'+pdf+'.dill'):
+        models[pdf] = models[pdf].load(filename=pdf,path=path)
+    else:
+        models[pdf].fit()
+        models[pdf].save(filename=pdf,path=path)
+#%% Plot multi-state degradation models:
+t=np.linspace(t_from,t_to,1000)
+plt.figure()
+for pdf in functions:
+    plt.plot(t,models[pdf].predict(t=t),color=random_color())
+plt.plot(t,ground_truth_MC.predict(t=t),color='gray',linestyle='--')
diff --git a/scripts/ihtmc.py b/scripts/ihtmc.py
new file mode 100644
index 0000000..5dbca71
--- /dev/null
+++ b/scripts/ihtmc.py
@@ -0,0 +1,486 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 10:03:49 2024
+
+@author: lisandro
+"""
+import pandas as pd
+from lifelines import KaplanMeierFitter as KM
+import matplotlib.pyplot as plt
+import numpy as np
+import matplotlib.pyplot as plt
+import dill
+import os
+from markov_chain_structures import MarkovChainStructure
+from copy import deepcopy
+from aux_functions import renormalize_mass_function, comp_error
+from aux_common_functions_ihtmc_dtmc import compute_error, sample, renormalize_rows, fit
+import time
+
+
+def solve_diff_equations_with_solve_ivp(dPdt, t, s0, x, atol, rtol, reshape=False):
+    """
+    Solves differential equations using the `solve_ivp` function from the SciPy library.
+
+    Parameters:
+    - dPdt (function): The derivative of y with respect to t, i.e., dy/dt.
+    - t (array): An array of time points at which to solve for y.
+    - s0 (array): Initial state.
+    - x (float): Parameter to be passed to the differential equation.
+    - atol (float): Absolute tolerance for the solver.
+    - rtol (float): Relative tolerance for the solver.
+    - reshape (bool, optional): If True, additional dimensions are added to the output shape. Default is False.
+
+    Returns:
+    - (array, bool): A tuple containing the solution as an array and a boolean indicating success.
+    """
+    from scipy.integrate import solve_ivp
+
+    t = deepcopy(t)
+    t[0] = 1E-6 if t[0] == 0.0 else t[0]
+    sol = solve_ivp(fun=dPdt, y0=s0, t_span=(min(t), max(t)), method='LSODA', args=(x, reshape), atol=atol, rtol=rtol, t_eval=t)
+    if sol.success and not np.all(np.isnan(sol.y)):
+        return np.array(sol.y.T), True
+    else:
+        return np.array([]), False
+
+def solve_diff_equations_with_odeint(dPdt, t, s0, x, atol, rtol, reshape=False):
+    """
+    Solves differential equations using the `odeint` function from the SciPy library.
+
+    Parameters:
+    - dPdt (function): The derivative of y with respect to t, i.e., dy/dt.
+    - t (array): An array of time points at which to solve for y.
+    - s0 (array): Initial state.
+    - x (float): Parameter to be passed to the differential equation.
+    - atol (float): Absolute tolerance for the solver.
+    - rtol (float): Relative tolerance for the solver.
+    - reshape (bool, optional): If True, additional dimensions are added to the output shape. Default is False.
+
+    Returns:
+    - (array, bool): A tuple containing the solution as an array and a boolean indicating success.
+    """
+    from scipy.integrate import odeint
+    sol, info = odeint(dPdt, s0, t, args=(x,reshape), atol=atol, rtol=rtol, full_output=True)
+    success = info['message'] == 'Integration successful.'
+    return sol, success
+
+
+class InhomogeneousTimeMarkovChain:
+    """
+    Represents an inhomogeneous time Markov chain model for simulating and analyzing
+    state transitions over time with time-varying transition rates.
+    
+    This class integrates functionalities for loading data, fitting the model using
+    various statistical methods, predicting future states, and handling input and
+    output operations for model variables.
+    """
+    
+    def __init__(self, df=pd.DataFrame(), hazard_function ='gompertz', MCStructureID ='ihtmc_s2_typeA', verbose=1, DiffSolver='solve_ivp'):
+        """
+        Initializes the InhomogeneousTimeMarkovChain with optional data and verbosity level.
+        
+        Parameters:
+        - df (pd.DataFrame, optional): A pandas DataFrame to initialize the model. Default is an empty DataFrame.
+        - verbose (int, optional): Verbosity level where 1 indicates verbose output and 0 silent operation. Default is 1.
+        - DiffSolver: it can be solve_ivp or odeint
+        """
+        self.df = df
+        self.simple_time_vector = False 
+        self.delta_t = 1
+        self.df_freq = pd.DataFrame()
+        self.verbose = verbose
+        self.DiffSolver = DiffSolver
+        self.list_models = pd.DataFrame()
+        self.MCObj = self.load_MCObj(MCStructureID=MCStructureID,function=hazard_function,MCType='ihtmc')
+        self.load_DiffEqsSolver()
+        
+        
+    def load_MCObj(self,MCStructureID='ihtmc_s6_typeA',function='gompertz',MCType='ihtmc'):
+        """
+        Loads a Markov Chain Structure object with specified states, name, and function.
+        
+        Parameters:
+        - states (list of int, optional): List of states in the Markov Chain. Default is [1,2,3,4,5,6].
+        - name (str, optional): Name of the Markov Chain. Default is 'Type A'.
+        - function (str, optional): The function used for calculating transition probabilities. Default is 'gompertz'.
+        
+        Returns:
+        - MarkovChainStructure: An initialized Markov Chain Structure object.
+        """
+        return MarkovChainStructure(MCStructureID=MCStructureID,function=function,MCType=MCType)
+        
+    def solve_diff_equations_solve_ivp(self, t, s0, x, atol, rtol, reshape=False):
+        """
+        Solves differential equations using the solve_ivp method.
+    
+        Parameters:
+        - t: Time points at which to solve the differential equations.
+        - s0: Initial state.
+        - x: Additional parameters passed to the differential equation.
+        - atol: Absolute tolerance for the solver.
+        - rtol: Relative tolerance for the solver.
+        - reshape: Whether to reshape the output (default: False).
+    
+        Returns:
+        - The solution of the differential equation using solve_ivp.
+        """
+        return solve_diff_equations_with_solve_ivp(self.dPdt, t, s0, x, atol, rtol, reshape)
+    
+    def solve_diff_equations_odeint(self, t, s0, x, atol, rtol, reshape=False):
+        """
+        Solves differential equations using the odeint method.
+    
+        Parameters:
+        - t: Time points at which to solve the differential equations.
+        - s0: Initial state.
+        - x: Additional parameters passed to the differential equation.
+        - atol: Absolute tolerance for the solver.
+        - rtol: Relative tolerance for the solver.
+        - reshape: Whether to reshape the output (default: False).
+    
+        Returns:
+        - The solution of the differential equation using odeint.
+        """
+        return solve_diff_equations_with_odeint(self.dPdt, t, s0, x, atol, rtol, reshape)
+        
+    def load_DiffEqsSolver(self):
+        """
+        Loads the appropriate differential equations solver based on the DiffSolver attribute.
+        
+        Raises:
+        - ValueError: If an unknown differential equations solver is specified.
+        """
+        if self.DiffSolver == 'solve_ivp':
+            self.solve_diff_equations = self.solve_diff_equations_solve_ivp
+        elif self.DiffSolver == 'odeint':
+            self.solve_diff_equations = self.solve_diff_equations_odeint
+        else:
+            raise ValueError('Unknown differential equations solver.')
+
+    def fit(self, **kwargs):
+        """
+        Fits a model to the data.
+    
+        This function assigns the result of a fitting operation to the attribute `MCObj`. The fitting operation is performed by calling the `fit` function with `self` and a dictionary of arguments `kwargs`.
+    
+        Parameters:
+        **kwargs: Variable keyword arguments passed to the `fit` function.
+    
+        Returns:
+        None
+        """
+        self.MCObj = fit(self, args=kwargs)
+
+    def fetch_data(self,df,function):
+        """
+        Fetches data for analysis, validating its presence and suitability based on the specified function.
+        
+        This method ensures that data is available for modeling by either using the provided dataframe `df` or
+        falling back to the instance's dataframe `self.df` if `df` is empty. It raises a ValueError if no data
+        is available or if the specified modeling function is not supported.
+        
+        Args:
+            df (DataFrame): The dataframe to be used for modeling. If empty, the instance's dataframe `self.df` is used.
+            function (str): The type of modeling function to be applied. Currently supports 'exponential' for
+                            Homogeneous-Time Markov Chains and other values for Inhomogeneous-Time Markov Chains.
+        
+        Raises:
+            ValueError: If no data is provided and `self.df` is also empty, or if an unsupported function is specified.
+        
+        Returns:
+            DataFrame: The dataframe to be used for further analysis and modeling.
+        """
+        if df.empty and not self.df.empty:
+            return self.df
+        else:
+            if function == 'exponential':
+                raise ValueError("You most provide data over which carry out the modelling via Homogeneous-Time Markov Chains")
+            else:
+                raise ValueError("You most provide data over which carry out the modelling via Inhomogeneous-Time Markov Chains")
+    
+    def compute_error(self, y=pd.DataFrame(), yp=pd.DataFrame(), metric='RMSE'):
+        """
+        Computes the error between actual and predicted values using a specified metric.
+    
+        Parameters:
+        - self: The object instance.
+        - y (pd.DataFrame, optional): The actual values. Defaults to an empty DataFrame.
+        - yp (pd.DataFrame, optional): The predicted values. Defaults to an empty DataFrame.
+        - metric (str, optional): The metric to use for computing error. Defaults to 'RMSE'.
+    
+        Returns:
+        - The error computed using the specified metric between the actual and predicted values.
+        """
+        return compute_error(self, y=y, yp=yp, metric=metric)
+
+    def renormalize_rows(self, dataframe, tolerance=0.01):
+        """
+        Renormalizes the rows of a dataframe to ensure that the sum of values in each row is 1.0,
+        within a specified tolerance.
+    
+        Parameters:
+        - self: The object instance.
+        - dataframe: The DataFrame to be renormalized.
+        - tolerance (float, optional): The tolerance within which the sum of row values must be to 1.0. Defaults to 0.01.
+    
+        Returns:
+        - A DataFrame with rows renormalized to sum to 1.0, within the specified tolerance.
+        """
+        return renormalize_rows(dataframe=dataframe, tolerance=tolerance)
+    
+    def prepare_time_vector(self, t):
+        """
+        Convert the input time data into a numpy array of float32 type and adjust its range and interval if needed.
+        
+        Args:
+        t (list or np.ndarray): Time data to be processed.
+        
+        Returns:
+        np.ndarray: Processed numpy array of time data.
+        """
+        if isinstance(t, list):
+            t = np.array(t)
+            t = t.astype(np.float32)
+        elif not isinstance(t, np.ndarray):
+            t = np.array(t)
+        if self.simple_time_vector:
+            step = round((max(t) - min(t)) / self.delta_t)
+            t = np.linspace(min(t), max(t), step)
+        return t
+    
+    def interpolate_dataframe(self, df, t):
+        """
+        Interpolate a pandas DataFrame along a new time vector if simple_time_vector is True,
+        otherwise return the DataFrame as is.
+        
+        Args:
+        df (pd.DataFrame): DataFrame containing the data to interpolate.
+        t (np.ndarray): New time vector for interpolation.
+        
+        Returns:
+        pd.DataFrame: Interpolated DataFrame or original DataFrame based on simple_time_vector.
+        """
+        if self.simple_time_vector:
+            interp_values = {column: np.interp(t, df.index, df[column]) for column in df.columns}
+            return pd.DataFrame(interp_values, index=t)
+        else:
+            return df
+
+    def predict(self, params=dict(), t=np.linspace(0, 50), atol=1e-5, rtol=1e-5, complete_NaN=True, ConverenceDetails=False, TryAllSolvers = True):
+        """
+        Predicts system dynamics over time using differential equations within a Markov Chain model.
+
+        Parameters:
+        - params (dict, optional): Parameters for the prediction. Should include 's0' for initial conditions and 'x' for other parameters.
+          Defaults to an empty dict, in which case the method uses MCObj attributes.
+        - t (array_like, optional): Time points at which to solve the differential equations. Defaults to numpy.linspace(0, 50).
+        - atol (float, optional): Absolute tolerance for the ODE solver. Defaults to 1e-5.
+        - rtol (float, optional): Relative tolerance for the ODE solver. Defaults to 1e-5.
+        - complete_NaN (bool, optional): If True, fills NaN values in the output DataFrame with the last valid value. Defaults to True.
+        - ConverenceDetails (bool, optional): If True, the function returns a tuple containing the prediction DataFrame and a success flag.
+          Otherwise, it returns only the prediction DataFrame. Defaults to False.
+
+        Returns:
+        - pandas.DataFrame or tuple: The prediction as a pandas DataFrame with columns 's_i' for each state, indexed by time points.
+          If ConverenceDetails is True, also returns a boolean indicating the success of the prediction.
+          If complete_NaN is True and there are NaN values, fills NaN values with the last valid observation.
+        """
+        t_ = self.prepare_time_vector(t)
+        s0, x = (self.MCObj.s0, self.MCObj.x) if not params else (params['s0'], params['x'])
+        # Correct initial state if t[0] != 0
+        s0 = pd.DataFrame(self.solve_diff_equations(t=[0,t_[0]],s0=s0,x=x,atol=atol,rtol=rtol)[0], columns=self.MCObj.states).iloc[-1].to_numpy() if t_[0] != 0.0 else s0   
+        # Solve system of differential equations:
+        sol, success = self.solve_diff_equations(t_,s0,x,atol,rtol)
+        if TryAllSolvers and not success:
+            self.DiffSolver = 'solve_ivp' if self.DiffSolver == 'odeint' else 'odeint'
+            self.load_DiffEqsSolver()
+            sol, success = self.solve_diff_equations(t_, s0, x, atol, rtol)
+        if success:
+            p = pd.DataFrame(sol, columns=self.MCObj.states)
+            p = self.renormalize_rows(p)
+            p.index = t_[0:p.shape[0]]
+            p = self.interpolate_dataframe(p,t)    
+            if complete_NaN and p.isnull().any().any():
+                p.fillna(method='ffill', inplace=True)   
+            if ConverenceDetails:
+                return p, success
+            else:
+                return p
+        else:
+            if ConverenceDetails:
+                return pd.DataFrame(), success
+            else:
+                return pd.DataFrame()
+        
+    def dPdt(self, a, b, x, reshape=False):
+        """
+        Computes the derivative of the probability matrix P with respect to time (t), 
+        for use in an ODE solver within the context of a Markov Chain model.
+    
+        Parameters:
+        - a (numpy.ndarray or float): Depending on the differential equation solver, 
+          this could be the initial state probability vector/matrix or the current time point.
+        - b (numpy.ndarray or float): Depending on the differential equation solver, 
+          this could be the initial state probability vector/matrix or the current time point.
+        - x: Additional parameters required by the Markov Chain's transition rate matrix method .Q.
+        - reshape (bool, optional): If True, reshapes the initial state probability vector/matrix 
+          from a vector to a square matrix corresponding to the number of states in the Markov Chain. Defaults to False.
+    
+        Returns:
+        numpy.ndarray: The derivative of the probability matrix P at time `t`, as a flattened array.
+        
+        Note:
+        - `self.MCObj` must be an instance of a Markov Chain class with a `.Q` method that computes
+          the transition rate matrix Q given time `t` and additional parameters `x`.
+        """
+        if self.DiffSolver == 'solve_ivp':
+            t, s0 = a, b
+        elif self.DiffSolver == 'odeint':
+            t, s0 = b, a
+        else: 
+            raise ValueError('Unknown differential equations solver')
+        s0 = s0.reshape(-1, len(self.MCObj.states)) if reshape else s0
+        Q = self.MCObj.Q(t, x)
+        if np.isnan(Q).any() or np.isinf(Q).any():
+            raise ValueError("Q contains NaN or infinite numbers.")
+        return (s0 @ Q).flatten()
+
+    def getTransitionProbabilityMatrix(self, params=dict(), t=np.linspace(0, 50), atol=1e-5, rtol=1e-5,output_format='dataframe'):
+        """
+        Computes and returns a pandas DataFrame of transition probabilities for a Markov chain. The DataFrame's index are the time steps,
+        and the columns are named as tuples representing (from, to) state transitions. Each cell contains the transition probability
+        for its corresponding (from, to) state pair at the given time step.
+    
+        Parameters:
+        - params (dict): Dictionary with 's0' and 'x' to override self.MCObj's initial state and control parameter if provided.
+        - t (np.ndarray): Time points array for which the transition probabilities are calculated.
+        - atol (float): Absolute tolerance for the ODE solver.
+        - rtol (float): Relative tolerance for the ODE solver.
+    
+        Returns:
+        - DataFrame: Transition probabilities with times as index and (from, to) tuples as columns.
+        """
+        s0, x = (self.MCObj.s0, self.MCObj.x) if not params else (params['s0'], params['x'])
+        state_len = len(self.MCObj.states)
+        idMatrix = np.identity(state_len).flatten()
+        P = {}
+        for t_i, t_j in zip(t[0:-1],t[1:]):
+            sol = self.solve_diff_equations(t=[t_i,t_j],s0=idMatrix,x=x,atol=atol,rtol=rtol,reshape=True)[0]
+            P[t_j] = renormalize_mass_function(sol[-1].reshape(-1,state_len))
+        
+        if output_format == 'dataframe':
+            columns = [(from_state, to_state) for from_state in self.MCObj.states for to_state in self.MCObj.states]
+            data = {i: P[i].reshape(state_len, state_len).flatten() for i in list(P.keys())}
+            df = pd.DataFrame(data, index=columns).T
+            return df
+        elif output_format == 'dictionary':
+            return P
+            
+    def getTransitionRateMatrix(self, params=dict(), t=np.linspace(0, 50, 51), atol=1e-5, rtol=1e-5, output_format='dataframe'):
+        """
+        Computes the transition rate matrix for a Markov Chain (MC) over a specified time interval.
+    
+        Parameters:
+        - params (dict, optional): A dictionary containing the initial state 's0' and any other parameters 'x' required for the calculation.
+                                   If empty, the default values from MCObj will be used.
+        - t (numpy.ndarray, optional): A numpy array specifying the time points at which the transition rates are calculated. Default is a linearly spaced array from 0 to 50 with 51 points.
+        - atol (float, optional): Absolute tolerance for the calculation. Default is 1e-5.
+        - rtol (float, optional): Relative tolerance for the calculation. Default is 1e-5.
+        - output_format (str, optional): Format of the output. Default is 'dataframe'.
+    
+        Returns:
+        - A transition rate matrix in the specified output format. The computation uses parameters from either the 'params' dictionary or the MCObj's default values.
+        """
+        s0, x = (self.MCObj.s0, self.MCObj.x) if not params else (params['s0'], params['x'])
+        return self.MCObj.Q(t, x, output_format='dataframe')
+    
+    def getHazardRates(self, params=dict(), t=np.linspace(0, 50, 51), atol=1e-5, rtol=1e-5, output_format='dataframe'):
+        """
+        To be done.
+        """
+        pass
+
+    def sample(self, t=np.linspace(0, 50), n=1000, states=[], exact_t_spacing=False):
+        """
+        Samples observations based on the defined parameters and configurations of the model.
+    
+        Parameters:
+        - self: The object instance.
+        - t (array-like, optional): The time points for which to sample. Defaults to a linear space between 0 and 50.
+        - n (int, optional): The number of observations to sample. Defaults to 1000.
+        - states (list, optional): The specific states from which to sample. If empty, samples from all states. Defaults to an empty list.
+        - exact_t_spacing (bool, optional): Determines if the sampling should occur at exact time points specified in `t` or at random times within the range defined by `t`. Defaults to False.
+    
+        Returns:
+        - A DataFrame containing the sampled observations, structured to include the sampled times, states, and their frequencies.
+        """
+        return sample(self, t=t, n=n, states=states, exact_t_spacing=exact_t_spacing)
+    
+    def plot(self, t=np.arange(0, 50), atol=1e-4, rtol=1e-4):
+        """
+        Plots the state probabilities over time.
+    
+        Parameters:
+        - t (array-like): Times at which to predict state probabilities, defaulting to a range from 0 to 50.
+        - atol (float): Absolute tolerance for the numerical solver, default is 1e-4.
+        - rtol (float): Relative tolerance for the numerical solver, default is 1e-4.
+    
+        Returns:
+        - None: This method generates a plot but does not return any value.
+        """
+        p = self.predict(t=t, atol=atol, rtol=rtol)
+        plt.plot(p.index, p, label=self.MCObj.states)
+        plt.xlabel('Time')
+        plt.ylabel('State probability')
+        plt.grid()
+
+    def save(self, var=None, filename='variable', path=''):
+        """
+        Saves 'var' to a file using dill in the specified path.
+
+        Args:
+            var: The variable (typically a DataFrame) to save.
+            filename (str, optional): The name of the file to save the variable to. Defaults to 'dataframe.dill'.
+            path (str, optional): The directory path where the file will be saved. Defaults to the current directory.
+        """
+        if not var:
+            var = self # --> save the whole object
+            
+        filename = filename + '.dill'
+        full_path = os.path.join(path, filename)
+        if not os.path.exists(path):
+            os.makedirs(path)
+        with open(full_path, 'wb') as file:
+            dill.dump(var, file)
+        print(f"Variable saved to {full_path}.")
+
+    def load(self, filename='variable', path=''):
+        """
+        Loads a DataFrame from a file using dill from the specified path.
+
+        Args:
+            filename (str, optional): The name of the file to load the DataFrame from. Defaults to 'dataframe.dill'.
+            path (str, optional): The directory path from where the file will be loaded. Defaults to the current directory.
+        """
+        filename = filename + '.dill'
+        full_path = os.path.join(path, filename)
+        try:
+            with open(full_path, 'rb') as file:
+                model = dill.load(file)
+            
+            # Update relevant parameters by preserving the latest object properties:
+            self.MCObj.x  = model.MCObj.x
+            self.MCObj.s0 = model.MCObj.s0
+            self.df       = model.df
+            
+            print(f"DataFrame loaded from {full_path}.")
+        except FileNotFoundError:
+            print(f"No file found with the name {full_path}.")
+            
+
+    
+if __name__ == "__main__":
+    model = InhomogeneousTimeMarkovChain()
+    
\ No newline at end of file
diff --git a/scripts/markov_chain_calibration.py b/scripts/markov_chain_calibration.py
new file mode 100644
index 0000000..5c40d28
--- /dev/null
+++ b/scripts/markov_chain_calibration.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 12:06:27 2024
+
+@author: lisandro
+"""
+import numpy as np
+import pandas as pd
+from aux_MarkovChainCalibrationAlgorithms import SLSQP, Nelder_Mead, trust_constr, differential_evolution
+from aux_functions import comp_error, getFrequencyTable
+
+class MarkovChainCalibration:
+    """
+    Calibrate parameters for a Markov Chain model.
+    
+    This class implements methods for calibrating the parameters of a Markov Chain model
+    using optimization techniques. It includes a cost function based on an error metric,
+    a method to fit the model parameters to given data, and a method to compute the log likelihood
+    for a given set of predictions.
+    
+    Attributes:
+    - df: DataFrame containing the data to calibrate the Markov Chain.
+    - MCObj: An object representing the Markov Chain, which must provide methods for prediction,
+             parameter retrieval, and contain attributes for initial parameters, bounds, and constraints.
+    """
+    
+    def __init__(self, df, MCObj,**kwargs):
+        """
+        Initialize the MarkovChainCalibration class with data and a Markov Chain object.
+        
+        Parameters:
+        - df: A pandas DataFrame containing the data for calibration.
+        - MCObj: An object representing the Markov Chain to be calibrated.
+        """
+        self._ = MCObj
+        self.metric = kwargs.get('metric','LogL')
+        self.load_ref_data(df)
+        
+    def load_ref_data(self, df):
+        """
+        Load reference data into the object's dataframe based on the specified metric.
+    
+        If the metric is set to 'RMSE', the object's dataframe is set to the dataframe
+        stored in the object's `_` attribute's `df_freq` attribute. Otherwise, the 
+        object's dataframe is set to the input `df`.
+    
+        Parameters:
+        - df (pd.DataFrame): The dataframe to be loaded if the metric is not 'RMSE'.
+        """
+        if self.metric in ['RMSE','SE','MSE']:
+            if self._.df_freq.empty:
+                self.df = getFrequencyTable(y=df,states=self._.MCObj.states)
+            else:
+                self.df = self._.df_freq
+                
+        elif self.metric == 'LogL':
+            self.df = df
+        
+    def cost_function(self,x,metric):
+        """
+        Define the cost function for optimization.
+        
+        This function calculates the cost based on the difference between predicted and observed
+        values using a specified error metric. Currently supports log likelihood ('LogL') for
+        'ihtmc' (inhomogeneous time Markov chain) type only.
+        
+        Parameters:
+        - x: The parameter vector for which the cost is calculated.
+        - df: A pandas DataFrame containing the data.
+        - MCObj: The Markov Chain object.
+        - error_metric: A string specifying the error metric to be used ('LogL').
+        
+        Returns:
+        - The calculated cost.
+        
+        Raises:
+        - ValueError: If the error metric is 'LogL' and the MC type is 'dtmc', or if an unsupported
+                      error metric is provided.
+        """
+        yp, success = self._.predict(params=self._.MCObj.getMCParametersFromX(x), 
+                                     t=self.df.index.unique(), 
+                                     ConverenceDetails=True)
+        if success:
+            return self.compute_error(yp=yp,metric=metric)
+        else:
+            return 1E100 #--> Penalty due to bad set of parameters.
+        
+    def fit(self, **kwargs):
+        """
+        Calibrates a Markov Chain model using the specified parameters.
+    
+        This function takes any number of keyword arguments which are used
+        for the calibration of the Markov Chain. It then applies the 
+        MarkovChainCalibrationAlgorithm with these parameters to calibrate
+        the model.
+    
+        Parameters:
+        **kwargs: Various keyword arguments that are passed to the 
+                  MarkovChainCalibrationAlgorithm for the calibration process.
+    
+        Returns:
+        The result of the MarkovChainCalibrationAlgorithm after applying 
+        the calibration process with the given parameters.
+        """
+        return self.MarkovChainCalibrationAlgorithm(**kwargs)
+    
+    def compute_error(self, yp, metric='LogL'):
+        """
+        Computes the error between model predictions and actual data using a specified metric.
+    
+        Parameters:
+        yp (array-like): Predicted values.
+        metric (str): The metric to use for error computation. Defaults to 'LogL' for log-likelihood.
+    
+        Returns:
+        float: The computed error value.
+        """
+        return comp_error(y=self.df, yp=yp, metric=metric, states=self._.MCObj.states)
+    
+    def MarkovChainCalibrationAlgorithm(self,**kwargs):
+        """
+        Implements various optimization algorithms for model calibration.
+    
+        Parameters:
+        opt_method (str): The optimization method to use.
+        args (dict): Additional arguments specific to the optimization method.
+    
+        Returns:
+        object: The result of the optimization process.
+    
+        Raises:
+        ValueError: If an unsupported optimization method is specified.
+        """
+        opt_method =  kwargs.get('opt_method', 'differential_evolution')
+        if opt_method == 'SLSQP':
+            return SLSQP(self, **kwargs)
+        elif opt_method == 'trust-constr':
+            return trust_constr(self, **kwargs) 
+        elif opt_method == 'Nelder-Mead':
+            return Nelder_Mead(self, **kwargs) 
+        elif opt_method == 'differential_evolution':
+            return differential_evolution(self, **kwargs) 
+        else:
+            raise ValueError(f"Unsupported optimization method: {opt_method}")
+    
+            
+            
+
+
+    
\ No newline at end of file
diff --git a/scripts/markov_chain_structures.py b/scripts/markov_chain_structures.py
new file mode 100644
index 0000000..a081adc
--- /dev/null
+++ b/scripts/markov_chain_structures.py
@@ -0,0 +1,57 @@
+class MarkovChainStructure:
+    """
+    A class to define the structure of a Markov Chain.
+
+    Attributes:
+    -----------
+    MCType : str
+        The type of Markov Chain.
+    states : list
+        A list of states in the Markov Chain.
+    name : str
+        The name of the specific Markov Chain structure.
+    function : function
+        A function associated with the Markov Chain.
+    calibration_info : dict
+        A dictionary to store calibration information.
+
+    Methods:
+    --------
+    __init__(self, MCType, states, name, function):
+        Initializes the MarkovChainStructure with the given parameters.
+    """
+
+    def __init__(self,MCStructureID,function,MCType):
+        """
+        Initialize the MarkovChainStructure with the specified type, states, name, and function.
+
+        Parameters:
+        -----------
+        MCType : str
+            The type of Markov Chain.
+        states : list
+            A list of states in the Markov Chain.
+        name : str
+            The name of the specific Markov Chain structure.
+        function : function
+            A function associated with the Markov Chain.
+        """
+        
+        # Dynamic class assignment based on specified Markov Chain structure.
+        if MCStructureID == 'ihtmc_s6_typeA':
+            from markov_chain_types.ihtmc_s6_typeA import MC
+        elif MCStructureID == 'ihtmc_s6_typeB':
+            from markov_chain_types.ihtmc_s6_typeB import MC
+        elif MCStructureID == 'ihtmc_s2_typeA':
+            from markov_chain_types.ihtmc_s2_typeA import MC
+        elif MCStructureID == 's5_typeA':
+            from markov_chain_types.s5_typeA import MC
+        elif MCStructureID == 's6_typeA':
+            from markov_chain_types.s6_typeA import MC
+        else:
+            raise ValueError("Specified Markov Chain structure does not match predefined structures.")
+            
+        # Dynamically assign this instance's class to the specified MC class
+        self.__class__ = MC
+        # Initialize the new class with the function
+        self.__init__(function,MCType)
\ No newline at end of file
diff --git a/scripts/markov_chain_types/.DS_Store b/scripts/markov_chain_types/.DS_Store
new file mode 100644
index 0000000000000000000000000000000000000000..5008ddfcf53c02e82d7eee2e57c38e5672ef89f6
GIT binary patch
literal 6148
zcmZQzU|@7AO)+F(5MW?n;9!8z45|!R0Z1N%F(jFgL>QrFAPJ2!M?+vV1V%$(Gz3ON
zU^D~<VF)ln+{D2Rp-0Kl5Eu=C(GY-#0H}OW0QD6Z7#JL&bOVG2Nii@oFo3%Nj0_Ac
zFio(203!nfNGnJUNGpg2X=PvpvA|}4wK6b5wK9UcAq)(R;4TS>25V<v1ltVagS9g-
zf^BACV1#IAV1(Mt2<@RTf_gL{^C8+97{Ru~TsKOOhQMeDz(Rl-!Vmz}|E>%SxcdJP
zRior+2#kinunYl47MEZbCs3t{!+W4QHvuXKVuPw;Mo^s$(F3lEVT}ML$bg~*R5_@+
b2Uo?6kTwK}57Iu`5P${HC_Nei0}uiLNUI8I

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/__pycache__/aux_common_functions_markov_chain_types.cpython-311.pyc b/scripts/markov_chain_types/__pycache__/aux_common_functions_markov_chain_types.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..80aae425634d87d8f4ea758075f9dfde32347a55
GIT binary patch
literal 6966
zcmZ3^%ge>Uz`(#={xQ`?kb&Vbhy%k+P{!vN1_p-d3@HpLj5!QZj42E$OgT)s%u&pY
z3@O|xEG>*tEGew1j9IKu^$clDDQqn)QEVx!sqAS?DeNsQQ5;Y<M+-|7X9{NvLljpE
zR|`WFcM4-LgC@^QkXAoU##`*g`DrD&i51V~cU<wRde>{3408oY1q%ZM12Y2y!{-RF
zi%J+lf)JbqXV);)FfL<aU|0>;S<8T;5-wiDu#Ay`VKrQ5EmI9sFoPyzVgMrp1DAq=
zf`Vg7NosCEi9$)fLS|lBYEg+oq5{-~3i+ia1*H(Fl46DYqRjNnyu=)Zoc#36l43ou
z_K=LsVuj3Ng+zsn)Y78N;*!i{g~Wn_qWr|<428tJ6or)h)Z#q#5{2~A#G=H!lGId%
zl8jV^)QZI966_{|jSWaFO3Y0yNi8b20`qkhDy<ZPApr+-R$@_6VkN{Cx(cZU#hE$z
zc~%OJ3dOmJIXMbti8-aIAYT=w7UU!*rz%vX7UdU%1QN^gGgCmG&@j-1Xa`#nlv+|+
zln1xZ5#))A%-qD1)D(1wDkOqDoL8D#P^p0A3Qgu)OnC*j*mDyrGIL9FZ!zcOr)x6b
zVywKy4t3rwUP#!*gM+A|7!=bA3JSkw=!X`k78UE~WELmpr4;4s`(!2+B^FicJLlw=
zrUaMd7bT{r>ig%Vx)f!WrRs*}WtOED6=#-I=BI^}r{<NU>IY=F=m#VgfD9=xFi(ni
z_H_x+PtH$C)z3{V%FZu~PtHip%!@CnEJ!WZPb{s7PtMQH&CiQZE6qzT$;{6yj>lA|
zS5SG250WV2p-G~Mmw|x+ltzoS7#J8D7`{p|aB}x>O)#90evw1&3Wr>S<5xBYQSm8m
zGYltsPVsE;eZVbofkomoC<)(UD*}gcGCVmlFfg#e5_}XRC=1pwWPy}|aSCHLI3XA5
zlz;*XEXKf)1r`HwQkYs8O4vax2u4rrE)2^U7#LPVBpDdcvjStD8;Whr1Z-oW&^G=O
zPPkJTQdm(lW)mZdAK?W}2`Ip!+G-fG;J!uGjmoQKN@1&EN@2HQU|^_WtYJz6WqFRO
ztv>mQDGDj6X^EvdB?_5&nI)NtISK`^oTgBgnp~1!q>z+Y3`+5N3b3Sslt<9BC8z*_
zDYH`WOUzAG$WH@jaF{44!<81NBAJ1b&p-xv;&2H>&n=delH6pJBm)WrVNe;F0WKrc
z8EP0}^=lbRpuq&95M|{8cya-W!*C5_3WFq!!%)MR!ieClVL~liCo=UI1T(B;E&`eK
z5|nl|nLv5F{1!__W_pGua}g*F-(o9D%uC77y~SRdmzkDdl)IAY7L%UAEyko`kUj;4
zA|3_?hF@GZIhn;J$@#ejc2(->sU;xKC*~l+RnI0TKRGd{*iH|jP?>>&q1Y6h-!6!T
zLC^ugsYz2ZuZyW)5>sE{xFT_l%Z9=of?G;1h^b!`v$-N>15tKCG^~h^fq~%`Yi0&|
zFoIGeI2d~n!RT1ah*FV&d<zaHl)wdf2rRk)DPMvGzyv9Qi<)vLGW9qGGZcYbrO5&b
zR_4@-f+BGS28JRD5CMuN<Nz&_VPIe&IwVy=A!!c{$+!!mAanv0l4)~;=0skX)w?9C
zx502j;1-h|i3b?>q+F2IyC~~?Mb`PEn9CJ07l?)nqH*9b{iPj}k*WYHQ9+5`7hKFL
zfQwmBg_xILqEM8YoS&YTS(TcimktgYh7b1ORHVsqi_O<Lq_Q9t;z?F;Epm$^DZex?
zr8vIg7FQUk`f@EQ$}hUb3a+_sG3TV_-C`>)Ni0b%UdeomHNH4CC+!wv#Vw{{16V}@
zPGh%(v81aa9R>z)iZ5Oc_WlPU1`ghqnh9l>*kv!U%iiVT>+ygjnWGseN)P5A$-f{P
zc2P9!ifGtHp71L?;T?<}j5j#>dSqsZU*c4_z^MS$0t&*j85hE1PUfG<zaScSQ8ey~
zXxv4f_$xf|AU#j{BrZt0UF37W!smX0!~H880~b$^#8l-8sZ(+;3MpR^QohKka)nc+
z!RZDMe}hv)VWaB<Zk~>y4wD9Na4@4}eNfc{N^_rEaMu<SYZwsOKZOZes%w_O%Txx2
zERY%C7)fD9O@TO6v7o9-W2$A$%R;e-l`8hIVX?;yhnv_@)#6Zv%|u?5dXEF@a;6l{
zTE-g2bjBKn1)y*ShYvD=TANm}GB5-)XmTaaf;A;wKn=Fs%)HcMa1{Va%nE7wMPM$X
zqNzaCF`%|!aY1TwW?E)y3Q~;&Zjphq7u1l%qEv+xnDHs7`qg1|jk-c&Nl8&=QfUdi
z8cNPdEQUAfJku1A)MgedsHf-W7Ni!HRH-ZE7b&QxRutstrRIUEMRgspn~`iUP6aoF
zHFEOPH4I&KjSMt(z->rV15IcvQdhw(zepi5uTmkuBqOy5*)DKnl#r2z7AQu7g8-wl
z1l1m(Ms7)IK~AbdQEEX^YB9*kdFjXw28DSAr2Z_D1r`4sFrTI?J5AzQIOn+aOHi-q
z7B`ZgUm7tmFr=?>zH~9R$jGKhkb!|glL=g06^Ve@tVN1oqhP@eF1m_1Kw^S<rMXF|
zMe*=BF4kl!(gew{L4pva$OhGCMIgceR2;8@lt&Vf@~He0yW9nKxf|R9J$5sqE^(`0
z;8wpYCNU*#M(D)cDY;9Xmbk4jTIjXJ>w>6$hg*l+4PK$1xEZyVcy%uD>flrO6rUmB
za!u?Kr~Cy@`5S^_9c&MHggPuHq+S=(y(Ff4QB41enEpj>{R=Gmc#5P+;A#}P`a~`u
zP%~>SBXV}FVMLWhY1E?0r7@*5A~z&!7!bWuR8ycCl(FhJI4QZO=A{;aDi3hCtO(o^
z2X$jWDGF49K_UvCU19A*aD@ZuO%*F>6oa}<VB?T7Cn&Y0g8F+9wV8Pe>R?u}x&kQQ
z!g7v*j)I|q0o(wbNgL)Ma1t-Zo5qU`bQH=nOEMJl^HLSS>J<u7ixj}NLz2HH8@S6-
zqzy`p%(<C)x0rJiD~i-WZ3%Tys)nXhmYmGoV&qhMixUzc@x=y3mJAFG9-y=eYEd^Z
zd=+Bgk(!}8N8=*5@)d672A8|M0uw|!BYPsJ7SAx5SUIKg0*~SaZl$HcD@51GTvRo?
zqH1=L+w20186@?<n@<c344}3ws51Jj!GyE>Ba6~Cfa|VdOkn~whag2XYTSe5K#oOC
zNh!>D)H8$CgWLi!kRc0R3Dhv+*0}(wT7_x^b+u4BUd1gaJ^(eB!AdDMHv+|6WcT6>
z8KT^a+TlcYFGc1SDVFeqJq{*PSU|Cah>_V0DXgd=GMiy8TEnA>u?94n#Fn@mR_Qtx
z6y#)rYTTm4ykbzlBN5!42lcx^m1|}mXaomQE~8eR&_=5>Xlwx7lGWn^XKqA)1Ty>r
zZfja8_$OthCYLCbWF(d-B<JUqBxdFnD?r+@NL6o1KBB4yS4yxZatVqPA^8*RGAjj_
zOz<c~Vo@c`;LN;q1@#JbaABohY@n`?omyE8$?V|T6g-rZl&SzXG&Ke4_@Knh;#6p*
zk7!0)DS)c~3P?>4G7s(nzeGP!_3xRN1}o+g(@Ii{5GI2|6lOT2+=K*6N@jA2l>(?F
zL~;e9M-3e!1J}Sspz#uLDO9Bsl95`J3hE;yDj?YncB(>Vo<fC=La_mtuCARzg_S}T
zCzw@iV5OkR0j_`{)vi3K00U*#TdbMId5L+qm=p6VLF~-Dv?3Lxf{hg%!l)%%2rMFs
zKz*SQP|5ZmQVYwW)WUZ~#ixYLa9yB0$Lpe~`V~?24%Uw3POh(P48l?~R2Q(!(Y`38
zc11|7!L>uB(fcbK0|!@2#RS#~DO0#Fvddgym$}ZaaEV>vBD>NRcBKytjI4Q#OOuvl
ztSH?OvZnf?n)MYm>+5Rvm(=VpsySX!bA+fk8gwM$MCyf*@H1H#T_dl!MqYP~z2q8u
z(KY^xYdl2B)#TJG$=Mfj3NI9uUdbuDm|T7(x%_%^^`+$Mi^;WDl4~K#?t;1=IVVI<
z6rYj0AejR~@hKNlGq1#Ff!LBc7x{9p@a10M$bG;q(BK0poIzm<&Ys9)Q-8o!J4&k=
zHa2C7QUt*ZXB1JmnHUv4s1FXct%eD;2v0-f2Q#4959`+`qu2zuzXr9DfMyn^*(Kai
zXD~1@p!bQI7&TcEucH?@;DNznqznkoCg5y|l5gSTNuc7$7t%|nQ-OosiI9S)!b-sr
zG=Qv|lbM~W1Izg(`3gy?kb!VyuYt-I&`=d98zSpMZ6p;G<tHU3W#(j-fD2^YMuE#%
zJjE2WNX;x(KpRDXl+GwEr@R8aycF>80i+~K&d*CuEJ@7+k6U8|Kxzs~p$Z8KNC5?E
z?-wb6N)9$eIdh8}$vkjdAJUuxl`usbpn?OGwiTeGTek!}K~o6DsfYr`iGhJ3AEXXM
zG%$QnKrLYS1$*k|7R@PJkT|n)PUTv?9YPniY_4e8T#&Q9$ZvOr-|hm39c0u2+B&}r
z(lMiOson;mi%KR}luRzjnO@{KyTWgFfx`@KtO1;%H5rRQ?E+1nTdd##dvNi2i?=vA
zv!GHB-1SV%DFS%{?6F(y(7*(bm)v3jwMD^Q6>u96TwE4`ytI-5Y&dwl<rjxdZhlH>
zPO4oIsF4U7GArKBz`*c<nURt427}NA7`nlrcmWlCU=d=J{J?-pXo)ZiEKpja^?^Zz
zQ2?FL6Js=(Q1XF6jL`s{FyLY|pTY8hfs4@`osf`Z6#T#dC(J|{Js3YQU?;&I0{|>$
Bp`ZW&

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/__pycache__/aux_common_functions_markov_chain_types.cpython-39.pyc b/scripts/markov_chain_types/__pycache__/aux_common_functions_markov_chain_types.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b3d609a6b99be3596fa8ab0d40f68cb821fe7a9d
GIT binary patch
literal 4502
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

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/__pycache__/ihtmc_s2_typeA.cpython-39.pyc b/scripts/markov_chain_types/__pycache__/ihtmc_s2_typeA.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..b1d2a5137062d94fdedf3673cdc790fca24fce39
GIT binary patch
literal 4450
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
E06Csr6#xJL

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/__pycache__/s5_typeA.cpython-39.pyc b/scripts/markov_chain_types/__pycache__/s5_typeA.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..97939e4293dcac818de4d60ca84f314d558cee2a
GIT binary patch
literal 10091
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

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/__pycache__/s6_typeA.cpython-311.pyc b/scripts/markov_chain_types/__pycache__/s6_typeA.cpython-311.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..1379d45272c18fbdaab786278148b4188ad30b12
GIT binary patch
literal 14858
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

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/__pycache__/s6_typeA.cpython-39.pyc b/scripts/markov_chain_types/__pycache__/s6_typeA.cpython-39.pyc
new file mode 100644
index 0000000000000000000000000000000000000000..6c6212c5eab248006ec8934fd17785e958befa4b
GIT binary patch
literal 10507
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
O{gePB52Fkt2NMAGbJ)}X

literal 0
HcmV?d00001

diff --git a/scripts/markov_chain_types/aux_common_functions_markov_chain_types.py b/scripts/markov_chain_types/aux_common_functions_markov_chain_types.py
new file mode 100644
index 0000000..1341546
--- /dev/null
+++ b/scripts/markov_chain_types/aux_common_functions_markov_chain_types.py
@@ -0,0 +1 @@
+import numpy as np
from scipy.special import softmax

def invert_softmax(y, epsilon=1e-50):
    """
    Attempt to invert a softmax output to its original logits.
    This is a heuristic approach and doesn't guarantee the exact original logits.
    
    Parameters:
    - y: Softmax output array.
    - epsilon: A small value to replace zeros to avoid log(0).
    
    Returns:
    - Approximated original logits as a numpy array.
    """
    # Replace 0s with epsilon to avoid log(0)
    y = np.maximum(y, epsilon)
    
    # Apply the logarithm to approximate the original logits
    logits_approx = np.log(y)
    
    return logits_approx

        
def getInitalParameters(_self) -> np.ndarray:
    """Load default initial parameter vector based on function.
    
    Parameters:
        function: Name of the function to use.
    
    Returns:
        Initial parameter vector.
    """
    if _self.MCType == 'dtmc':
        x = np.array([np.random.uniform(low=b[0], high=b[1]) for b in bounds_x(_self)])
    elif _self.MCType == 'ihtmc':
        x = np.array([np.exp(np.random.uniform(low=b[0], high=b[1])) for b in bounds_x(_self)])
    else:
        raise ValueError('The type of Markov chain is not recognized.')
        
    # Initial state vector
    s0 = np.zeros(len(_self.states))
    s0[0] = 1.0
    
    return x,s0


def bounds_x(_self) -> list:
    """
    Determines the bounds for the parameter x based on the specified function.

    The bounds are determined based on the 'function' attribute of the class:
    - If 'function' is 'gompertz' or 'exponential', the bounds are set to (log(1E-20), log(50)).
    - For any other 'function' value, the bounds are set to (log(1E-18), log(50)).

    Returns:
        list: A tuple representing the bounds for x.
    """
    
    if _self.MCType == 'ihtmc':
        if _self.function == 'gompertz':
            bounds = (np.log(1E-20),np.log(10))
        elif _self.function == 'exponential':
            bounds = (np.log(1E-20),np.log(50)) 
        else:
            bounds = (np.log(1E-18),np.log(50))
    elif _self.MCType == 'dtmc':
        bounds = (0,1)
        
    return [bounds] * _self.number_parameters()

def bounds_s0(_self) -> list:
    """
    Generates and returns a list of bounds for the initial state values (s0).

    The bounds for each state in 'states' are set to (0, 1000).

    Returns:
        list: A list of tuples representing the bounds for s0, with one tuple per state.
    """
    lims = invert_softmax(_self.s0)
    return [(min(lims),max(lims))] * len(_self.states)

def Transform(_self, param):
    """
    Applies transformations to the input parameters based on the Markov Chain type.

    Parameters:
    _self: Object that contains MCType attribute to determine the type of transformation.
    param: Dictionary containing 'x' and 's0' keys with values to be transformed.

    Raises:
    ValueError: If 'x' or 's0' contains NaN or Inf values after transformation.

    Returns:
    dict: The transformed parameters.
    """
    # Apply exponential transformation to 'x' if MCType is 'ihtmc'
    if _self.MCType == 'ihtmc':
        param['x'] = np.exp(param['x'])
    
    # Apply softmax transformation to 's0'
    param['s0'] = softmax(param['s0'])
    
    # Check for NaN or Inf values in 'x' and 's0'
    if np.isnan(param['s0']).any() or np.isinf(param['s0']).any() or np.isnan(param['x']).any() or np.isinf(param['x']).any():
        raise ValueError(f'There is a NaN or Inf Value in x, s0\n--> x: {param["x"]}\n--> s0: {param["s0"]}')
    
    return param

def InverseTransform(_self, x, s0):
    """
    Applies inverse transformations to 'x' and 's0' based on the Markov Chain type.

    Parameters:
    _self: Object that contains MCType attribute to determine the type of inverse transformation.
    x: Array-like, values to be inverse transformed.
    s0: Array-like, initial state probabilities to be inverse transformed.

    Raises:
    ValueError: If MCType is not recognized.

    Returns:
    np.ndarray: The concatenated inverse transformed 'x' and 's0'.
    """
    # Apply inverse transformation based on MCType
    if _self.MCType == 'ihtmc':
        return np.concatenate((np.log(x), invert_softmax(s0)))
    elif _self.MCType == 'dtmc':
        return np.concatenate((x, invert_softmax(s0)))
    else:
        raise ValueError('The type of Markov chain is not recognized.')

    
    
\ No newline at end of file
diff --git a/scripts/markov_chain_types/ihtmc_s2_typeA.py b/scripts/markov_chain_types/ihtmc_s2_typeA.py
new file mode 100755
index 0000000..f7f3f38
--- /dev/null
+++ b/scripts/markov_chain_types/ihtmc_s2_typeA.py
@@ -0,0 +1,118 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 16:02:21 2024
+
+@author: lisandro
+"""
+import numpy as np
+import pandas as pd
+from aux_functions import transition_rate, random_mass_function
+
+class MC:
+    """Markov Chain model for managing transitions and rates."""
+    
+    def __init__(self,function):
+        
+        self.MCType = 'ihtmc'
+        self.MCid = 'ihtmc_s2_typeA'
+        self.function = function
+        self.states = [1,2]
+        self.calibrated = False
+        self.convergence_info = dict()
+        self.genInitalGuessParameters()
+    
+    def number_parameters(self,function):
+        if function == 'exponential':
+            return 1
+        else:
+            return 2
+            
+    def transitions(self) -> pd.DataFrame:
+        """Fetches the transition matrix for the Markov chain.
+        
+        Markov Chain Diagram:
+        ```
+        1 --> 2 
+        ```
+        
+        Returns:
+            Transition matrix as a pandas DataFrame.
+        """
+        data = np.array([[1, 1],
+                         [0, 1]])
+        return pd.DataFrame(data, index=np.array(self.states), columns=np.array(self.states))
+    
+    def Q(self, t: float, x: float) -> np.ndarray:
+        """Computes the transition rate matrix Q for a given time.
+        
+        Parameters:
+            t: Time to evaluate rates.
+            function: Probability density function, defaults to 'gompertz'.
+        
+        Returns:
+            Transition rate matrix Q.
+        """        
+        if self.function != 'exponential':
+            param = {'a': [x[0]], 'b': [x[1]]}
+        else:
+            param = {'a': x}
+
+        Q = np.array([
+            [-transition_rate(0, t, param, self.function), transition_rate(0, t, param, self.function)],
+            [0, 0]
+        ])
+
+        return Q
+
+    def genInitalGuessParameters(self) -> np.ndarray:
+        """Load default initial parameter vector based on function.
+        
+        Parameters:
+            function: Name of the function to use.
+        
+        Returns:
+            Initial parameter vector.
+        """
+        
+        self.x = np.random.uniform(1E-18,50, self.number_parameters(self.function))
+        self.s0 = np.array([1.0,0.0])#random_mass_function(len(self.states))
+
+    def bounds(self) -> list:
+        """Defines bounds for optimization based on function and state.
+        
+        Parameters:
+            function: Name of the function to use.
+            state: Current state of the system.
+        
+        Returns:
+            Bounds for optimization parameters.
+        """
+        return [(1E-18, 50)]*self.number_parameters(self.function) + [(0, 1)] * len(self.states)
+                    
+    def getData(self, x=None):
+        """
+        Prepare data for optimization process.
+    
+        If 'x' is not provided, returns a dictionary with 's0' and 'x' from the instance.
+        If 'x' is provided, 's0' is set to the last two elements of 'x', and 'x' to the rest.
+    
+        Parameters:
+        - x (list, optional): The input data to process. Defaults to None.
+    
+        Returns:
+        dict: A dictionary with keys 's0' and 'x'. 's0' is either the instance's s0 or the last two elements of 'x'. 'x' is either the instance's x or 'x' without its last two elements.
+        """
+        return {'s0': self.s0 if x is None else x[-2:], 'x': self.x if x is None else x[:-2]}
+
+    
+    def constraints(self) -> list:
+        """Defines constraints for optimization ensuring the last N numbers of the array sum to 1.0.
+        
+        Args:
+            N: The number of last elements in the array to sum to 1.0.
+            
+        Returns:
+            A list containing the constraint.
+        """
+        return [{'type': 'eq', 'fun': lambda x: 1.0 - sum(x[-self.number_parameters(self.function):])}]
\ No newline at end of file
diff --git a/scripts/markov_chain_types/ihtmc_s6_typeA.py b/scripts/markov_chain_types/ihtmc_s6_typeA.py
new file mode 100755
index 0000000..a50202e
--- /dev/null
+++ b/scripts/markov_chain_types/ihtmc_s6_typeA.py
@@ -0,0 +1,109 @@
+import numpy as np
+import pandas as pd
+from aux_functions import transition_rate
+
+class MC:
+    """Markov Chain model for managing transitions and rates."""
+    
+    def __init__(self):
+        pass
+    
+    def transitions(self) -> pd.DataFrame:
+        """Fetches the transition matrix for the Markov chain.
+        
+        Markov Chain Diagram:
+        ```
+        1 --> 2 --> 3 --> 4 --> 5 --> 6
+        |                              ^
+        |                              |
+        +------------------------------+
+               |                       |
+               v                       |
+               2 ----------------------+
+                       |               |
+                       v               |
+                       3 --------------+
+                               |       |
+                               v       |
+                               4 ------+
+        ```
+        
+        Returns:
+            Transition matrix as a pandas DataFrame.
+        """
+        data = np.array([[1, 1, 0, 0, 0, 1],
+                         [0, 1, 1, 0, 0, 1],
+                         [0, 0, 1, 1, 0, 1],
+                         [0, 0, 0, 1, 1, 1],
+                         [0, 0, 0, 0, 1, 1],
+                         [0, 0, 0, 0, 0, 1]])
+        return pd.DataFrame(data, index=np.array([1,2,3,4,5,6]), columns=np.array([1,2,3,4,5,6]))
+    
+    def Q(self, t: float, x: float, function: str = 'gompertz') -> np.ndarray:
+        """Computes the transition rate matrix Q for a given time.
+        
+        Parameters:
+            t: Time to evaluate rates.
+            function: Probability density function, defaults to 'gompertz'.
+        
+        Returns:
+            Transition rate matrix Q.
+        """        
+        if function != 'exponential':
+            param = {'a': x[0:9], 'b': x[9:]}
+        else:
+            param = {'a': x}
+
+        Q = np.array([
+            [-transition_rate(0, t, param, function) - transition_rate(4, t, param, function), transition_rate(0, t, param, function), 0, 0, 0, transition_rate(4, t, param, function)],
+            [0, -transition_rate(1, t, param, function) - transition_rate(5, t, param, function), transition_rate(1, t, param, function), 0, 0, transition_rate(5, t, param, function)],
+            [0, 0, -transition_rate(2, t, param, function) - transition_rate(6, t, param, function), transition_rate(2, t, param, function), 0, transition_rate(6, t, param, function)],
+            [0, 0, 0, -transition_rate(3, t, param, function) - transition_rate(7, t, param, function), transition_rate(3, t, param, function), transition_rate(7, t, param, function)],
+            [0, 0, 0, 0, -transition_rate(8, t, param, function), transition_rate(8, t, param, function)],
+            [0, 0, 0, 0, 0, 0]
+        ])
+
+        return Q
+
+    def parameters(self, function: str) -> np.ndarray:
+        """Load default initial parameter vector based on function.
+        
+        Parameters:
+            function: Name of the function to use.
+        
+        Returns:
+            Initial parameter vector.
+        """
+        if function == 'exponential':
+            return np.concatenate((0.05*np.ones(9), np.array([1, 0, 0, 0, 0, 0])))
+        return np.ones(18), np.array([1, 0, 0, 0, 0, 0])
+
+    def bounds(self, function: str) -> list:
+        """Defines bounds for optimization based on function and state.
+        
+        Parameters:
+            function: Name of the function to use.
+            state: Current state of the system.
+        
+        Returns:
+            Bounds for optimization parameters.
+        """
+        state = [1,2,3,4,5,6]
+        if function == 'exponential':
+            return [(1E-18, 2)] * 9 + [(0, 1)] * len(state)
+        return [(1E-18, 100)] * 18 + [(0, 1)] * len(state)
+                
+    def constraints(self) -> list:
+        """Defines constraints for optimization.
+        
+        Returns:
+            Constraints for optimization.
+        """
+        return [{'type': 'eq', 'fun': lambda x: 1 - sum(x[-6:])}]
+    
+    def getData(self,x):
+        '''
+        Prepare data for optimization process
+        '''
+        return {'s0':x[-6:],
+                'x':x[0:-6]}
\ No newline at end of file
diff --git a/scripts/markov_chain_types/ihtmc_s6_typeB.py b/scripts/markov_chain_types/ihtmc_s6_typeB.py
new file mode 100755
index 0000000..dd03c15
--- /dev/null
+++ b/scripts/markov_chain_types/ihtmc_s6_typeB.py
@@ -0,0 +1,98 @@
+import numpy as np
+import pandas as pd
+from aux_functions import transition_rate
+
+class MC:
+    """Markov Chain model for managing transitions and rates."""
+    
+    def __init__(self):
+        pass
+    
+    def transitions(self) -> pd.DataFrame:
+        """Fetches the transition matrix for the Markov chain.
+        
+        Markov Chain Diagram:
+        ```
+        1 --> 2 --> 3 --> 4 --> 5 --> 6
+
+        ```
+        
+        Returns:
+            Transition matrix as a pandas DataFrame.
+        """
+        data = np.array([[1, 1, 0, 0, 0, 0],
+                         [0, 1, 1, 0, 0, 0],
+                         [0, 0, 1, 1, 0, 0],
+                         [0, 0, 0, 1, 1, 0],
+                         [0, 0, 0, 0, 1, 1],
+                         [0, 0, 0, 0, 0, 1]])
+        return pd.DataFrame(data, index=np.array([1,2,3,4,5,6]), columns=np.array([1,2,3,4,5,6]))
+    
+    def Q(self, t: float, x: float, function: str = 'gompertz') -> np.ndarray:
+        """Computes the transition rate matrix Q for a given time.
+        
+        Parameters:
+            t: Time to evaluate rates.
+            function: Probability density function, defaults to 'gompertz'.
+        
+        Returns:
+            Transition rate matrix Q.
+        """        
+        if function != 'exponential':
+            param = {'a': x[0:5], 'b': x[5:]}
+        else:
+            param = {'a': x}
+
+        Q = np.array([
+            [-transition_rate(0, t, param, function), transition_rate(0, t, param, function), 0, 0, 0,0],
+            [0, -transition_rate(1, t, param, function), transition_rate(1, t, param, function), 0, 0, 0],
+            [0, 0, -transition_rate(2, t, param, function), transition_rate(2, t, param, function), 0, 0],
+            [0, 0, 0, -transition_rate(3, t, param, function), transition_rate(3, t, param, function), 0],
+            [0, 0, 0, 0, -transition_rate(4, t, param, function), transition_rate(4, t, param, function)],
+            [0, 0, 0, 0, 0, 0]
+        ])
+        return Q
+
+
+    def parameters(self, function: str) -> np.ndarray:
+        """Load default initial parameter vector based on function.
+        
+        Parameters:
+            function: Name of the function to use.
+        
+        Returns:
+            Initial parameter vector.
+        """
+        if function == 'exponential':
+            return np.concatenate((0.05*np.ones(5), np.array([1, 0, 0, 0, 0, 0])))
+        return np.ones(10), np.array([1, 0, 0, 0, 0, 0])
+
+    def bounds(self, function: str) -> list:
+        """Defines bounds for optimization based on function and state.
+        
+        Parameters:
+            function: Name of the function to use.
+            state: Current state of the system.
+        
+        Returns:
+            Bounds for optimization parameters.
+        """
+        state = [1,2,3,4,5,6]
+        if function == 'exponential':
+            return [(1E-18, 2)] * 5 + [(0, 1)] * len(state)
+        return [(1E-18, 100)] * 10 + [(0, 1)] * len(state)
+                
+    def constraints(self) -> list:
+        """Defines constraints for optimization.
+        
+        Returns:
+            Constraints for optimization.
+        """
+        return [{'type': 'eq', 'fun': lambda x: 1 - sum(x[-6:])}]
+    
+    def getData(self,x):
+        '''
+        Prepare data for optimization process
+        '''
+        return {'s0':x[-6:],
+                'x':x[0:-6]}
\ No newline at end of file
diff --git a/scripts/markov_chain_types/s5_typeA.py b/scripts/markov_chain_types/s5_typeA.py
new file mode 100755
index 0000000..dd20196
--- /dev/null
+++ b/scripts/markov_chain_types/s5_typeA.py
@@ -0,0 +1,217 @@
+import numpy as np
+import pandas as pd
+from aux_functions import transition_rate, random_mass_function
+from scipy.special import softmax
+from aux_common_functions_markov_chain_types import getInitalParameters, bounds_x, bounds_s0, Transform, InverseTransform
+
+class MC:
+    """Markov Chain model for managing transitions and rates."""
+    
+    def __init__(self,function,MCType='ihtmc'):
+        
+        self.MCType = MCType
+        self.MCid = 's5_typeA'
+        self.function = function
+        self.states = [1,2,3,4,5]
+        self.calibrated = False
+        self.convergence_info = dict()
+        self.getInitalParameters()
+        self.bounds = self.getBounds()
+    
+    def number_parameters(self):
+        if self.function == 'exponential' or self.MCType == 'dtmc':
+            return 4
+        else:
+            return 2*4
+            
+    def transitions(self) -> pd.DataFrame:
+        """Fetches the transition matrix for the Markov chain.
+        
+        Markov Chain Diagram:
+        ```
+        1 --> 2 --> 3 --> 4 --> 5
+        ```
+        
+        Returns:
+            Transition matrix as a pandas DataFrame.
+        """
+        data = np.array([[1, 1, 0, 0, 0],
+                         [0, 1, 1, 0, 0],
+                         [0, 0, 1, 1, 0],
+                         [0, 0, 0, 1, 1],
+                         [0, 0, 0, 0, 1],
+                         ])
+        return pd.DataFrame(data, index=np.array(self.states), columns=np.array(self.states))
+        
+    def P(self, x=None, output_format='array'):
+        """
+        Computes a transition probability matrix based on given probabilities.
+    
+        The function creates a square matrix of zeros with dimensions equal to the number of states.
+        Each element x[i] in the input 'x' is used to set the transition probability from state i to state i (P[i, i]),
+        and the transition probability from state i to state i+1 (P[i, i+1]) is set to 1 - x[i].
+        The last state's transition probability to itself is set to 1, indicating a terminal state.
+    
+        Parameters:
+        - x (list, optional): A list of probabilities for transitioning from one state to the next. 
+                              If None, uses the instance's x attribute.
+        - output_format (str, optional): The format of the output. Defaults to 'array'.
+    
+        Returns:
+        - numpy.ndarray: A 2D numpy array representing the transition probability matrix.
+        """
+        if not x:
+            x = self.x
+        P = np.zeros((len(self.states), len(self.states)))        
+        for i in range(4):
+            P[i, i] = x[i]
+            P[i, i+1] = 1 - x[i]
+        P[4, 4] = 1
+        return P
+        
+    def Q(self, t: np.ndarray, x: float, output_format='array') -> np.ndarray:
+        """
+        Computes the transition rate matrix (Q) for a given time and parameters.
+    
+        Parameters:
+        - t (np.ndarray): An array of time points at which the transition rates are to be computed.
+        - x (float): The parameter(s) for the transition rate function. If the function is exponential, 'x' is a single float.
+          Otherwise, 'x' is expected to be an array where the last 4 elements are treated as 'b' parameters and the rest as 'a' parameters.
+        - output_format (str, optional): The format of the output. If 'array', the function returns a numpy array. If 'dataframe',
+          the function returns a pandas DataFrame. Defaults to 'array'.
+    
+        Returns:
+        - np.ndarray or pd.DataFrame: The transition rate matrix (Q) as a numpy array or pandas DataFrame, depending on the output_format.
+          The matrix dimensions are (len(t), len(self.states), len(self.states)) for 'array' format, and the DataFrame is reshaped 
+          accordingly with multi-index columns for each state transition and indexed by time points.
+    
+        Note:
+        - The function is designed to work with specific transition rate functions and expects the class instance to have 'states' 
+          and 'function' attributes, with 'function' determining the calculation method.
+        - The diagonal elements of Q represent the negative transition rates out of each state, and the off-diagonal elements represent
+          the transition rates into each state from each other state.
+        """
+        if self.function != 'exponential':
+            param = {'a': x[:-4], 'b': x[-4:]}
+        else:
+            param = {'a': x}
+    
+        if isinstance(t, float):
+            t = np.array([t])
+    
+        Q = np.zeros((len(t), len(self.states), len(self.states)))
+    
+        for i in range(len(self.states)):
+            Q[:, i, i] = -transition_rate(i, t, param, self.function)
+    
+        # Setting off-diagonal transition rates
+        Q[:, 0, 1] = -Q[:, 0, 0]
+        Q[:, 1, 2] = -Q[:, 1, 1]
+        Q[:, 2, 3] = -Q[:, 2, 2]
+        
+        if (np.sum(Q,axis=2)>1E-6).any(): 
+            raise ValueError('The sum of rows is larger than 1E-6.')
+
+        if output_format == 'array':
+            return Q
+        elif output_format == 'dataframe':
+            return pd.DataFrame(Q.reshape(len(t), Q.shape[1]**2),
+                                columns=[(from_state, to_state) for from_state in self.states for to_state in self.states],
+                                index=t)
+    
+    def getInitalParameters(self) -> np.ndarray:
+        """
+        Retrieves initial parameters for the current instance.
+    
+        This method calls the global function `getInitalParameters`, passing `self` as an argument,
+        to obtain initial parameters. It updates the instance with these parameters.
+    
+        Returns:
+            np.ndarray: The `x` parameter obtained from `getInitalParameters` function, intended to be used as initial parameters.
+    
+        Note:
+            This method also updates `self.x` and `self.s0` with the values obtained from the `getInitalParameters` function.
+        """
+        x, s0 = getInitalParameters(self)
+        self.x = x
+        self.s0 = s0
+
+    def getBounds(self) -> list:
+        """
+        Combines and returns the bounds for x and s0 as a single list.
+    
+        Returns:
+            list: A list containing the bounds for x and s0.
+        """
+        return bounds_x(self) + bounds_s0(self)
+    
+
+    def getMCParametersFromX(self, x):
+        """
+        Reparametrizes the Markov Chain with a new set of parameters based on the input `x`.
+    
+        This method constructs a new parameter dictionary with 's0' being the last five elements of `x`
+        and 'x' being all other elements before the last five. It then applies these parameters
+        to the current instance using the `Transform` method.
+    
+        Args:
+            x (iterable): An array-like object containing parameters for reparametrization. The last five elements
+                          are assigned to 's0', and the rest to 'x'.
+    
+        Returns:
+            The result of the `Transform` method called with the current instance and the new parameters.
+    
+        Note:
+            The `Transform` method is assumed to be a method of the current class or a globally accessible function
+            that accepts the instance and a parameter dictionary to perform some transformation or update.
+        """
+        return Transform(self, param = {'s0':x[-5:],'x':x[:-5]})
+    
+    def getXFromMCParameters(self, x=None, s0=None):
+        """
+        Calculates and returns the inverse transform based on Monte Carlo parameters.
+    
+        This method computes the inverse transform using the provided `x` and `s0` values. If `x` or `s0` are not provided,
+        it defaults to using the object's `x` and `s0` attributes, respectively.
+    
+        Parameters:
+        - x (Optional): The value to be used in the inverse transform calculation. Defaults to the object's `x` attribute if not provided.
+        - s0 (Optional): The starting value to be used in the inverse transform calculation. Defaults to the object's `s0` attribute if not provided.
+    
+        Returns:
+        - The result of the InverseTransform function, utilizing the provided or default `x` and `s0` values.
+        """
+        if not x:
+            x = self.x
+        if not s0:
+            s0 = self.s0
+        return InverseTransform(self, x, s0)
+
+    def getMCParameters(self, x=None):
+        """
+        Retrieves parameters 's0' and 'x' based on the provided input.
+    
+        If 'x' is not provided, 's0' and 'x' are retrieved from the object's attributes.
+        If 'x' is provided, 's0' is set to the last 5 elements of 'x', and 'x' is set to the rest.
+    
+        Parameters:
+        x (optional): Array-like or None. If provided, it is used to determine 's0' and 'x'.
+    
+        Returns:
+        dict: A dictionary containing 's0' and 'x' parameters.
+        """
+        return {'s0': self.s0 if x is None else x[-5:], 'x': self.x if x is None else x[:-5]}
+
+    def constraints(self) -> list:
+        """Defines constraints for optimization ensuring the last N numbers of the array sum to 1.0.
+        
+        Args:
+            N: The number of last elements in the array to sum to 1.0.
+            
+        Returns:
+            A list containing the constraint.
+        """
+        return [{'type': 'eq', 'fun': lambda x: 1.0 - sum(x[-self.number_parameters(self.function):])}]
+    
+    
+    
\ No newline at end of file
diff --git a/scripts/markov_chain_types/s6_typeA.py b/scripts/markov_chain_types/s6_typeA.py
new file mode 100755
index 0000000..d49f5e4
--- /dev/null
+++ b/scripts/markov_chain_types/s6_typeA.py
@@ -0,0 +1,250 @@
+import numpy as np
+import pandas as pd
+from aux_functions import transition_rate, random_mass_function
+from scipy.special import softmax
+from aux_common_functions_markov_chain_types import getInitalParameters, bounds_x, bounds_s0, Transform, InverseTransform
+import warnings
+
+class MC:
+    """Markov Chain model for managing transitions and rates."""
+    
+    def __init__(self,function,MCType='ihtmc'):
+        
+        self.MCType = MCType
+        self.MCid = 's6_typeA'
+        self.function = function
+        self.states = [1,2,3,4,5,'F']
+        self.calibrated = False
+        self.convergence_info = dict()
+        self.getInitalParameters()
+        self.bounds = self.getBounds()
+    
+    def params(self):
+        """
+        Generates a DataFrame based on the object's configuration, combining transition information with parameters specific to the function or Markov Chain type.
+
+        Returns:
+            pd.DataFrame: A DataFrame combining transition labels with either exponential parameters or 'a' and 'b' parameters, depending on the function or MCType attribute of the object.
+        """
+        if self.function == 'exponential' or self.MCType == 'dtmc':
+            df = pd.DataFrame({'\lambda': self.x})
+        else:
+            a, b = self.x[0:-9], self.x[-9:]
+            df = pd.DataFrame({'a': a, 'b': b})
+        # Add transitions:
+        f = ['$1 \to 2$', '$2 \to 3$', '$3 \to 4$', '$4 \to 5$', '$1 \to F$', '$2 \to F$', '$3 \to F$', '$4 \to F$', '$5 \to F$']
+        x = pd.concat([pd.DataFrame({'i \\to j': f}), df], axis=1).set_index('i \\to j')
+        # Initial state vector:
+        f = ['$k=1$','$k=2$','$k=3$','$k=4$','$k=5$','$k=F$']
+        s0 = pd.DataFrame({'$S_k^0$':f,'s0':self.s0}).set_index('$S_k^0$')
+        return x, s0
+    
+    def __str__(self):
+        """
+        Generates a LaTeX string representation of the object's parameters DataFrame.
+
+        Returns:
+            str: A string containing the LaTeX representation of the parameters DataFrame.
+        """
+        return self.params()[0].to_latex(float_format="%.1E", index=True, escape=False), self.params()[1].to_latex(float_format="%.1E", index=True, escape=False)
+        
+    def number_parameters(self):
+        if self.function == 'exponential' or self.MCType == 'dtmc':
+            return 9
+        else:
+            return 2*9
+            
+    def transitions(self) -> pd.DataFrame:
+        """Fetches the transition matrix for the Markov chain.
+        
+        Markov Chain Diagram:
+        ```
+        1 --> 2 --> 3 --> 4 --> 5 --> F 
+        1 --------------------------> F
+              2 --------------------> F
+                    3 --------------> F
+                          4 --------> F
+        ```
+        
+        Returns:
+            Transition matrix as a pandas DataFrame.
+        """
+        data = np.array([[1, 1, 0, 0, 1],
+                         [0, 1, 1, 0, 1],
+                         [0, 0, 1, 1, 1],
+                         [0, 0, 0, 1, 1],
+                         [0, 0, 0, 0, 1],
+                         ])
+        return pd.DataFrame(data, index=np.array(self.states), columns=np.array(self.states))
+        
+    def P(self, x=None, output_format='array'):
+        """
+        Computes a transition probability matrix based on given probabilities.
+    
+        The function creates a square matrix of zeros with dimensions equal to the number of states.
+        Each element x[i] in the input 'x' is used to set the transition probability from state i to state i (P[i, i]),
+        and the transition probability from state i to state i+1 (P[i, i+1]) is set to 1 - x[i].
+        The last state's transition probability to itself is set to 1, indicating a terminal state.
+    
+        Parameters:
+        - x (list, optional): A list of probabilities for transitioning from one state to the next. 
+                              If None, uses the instance's x attribute.
+        - output_format (str, optional): The format of the output. Defaults to 'array'.
+    
+        Returns:
+        - numpy.ndarray: A 2D numpy array representing the transition probability matrix.
+        """
+        if not x:
+            x = self.x
+        P = np.zeros((len(self.states), len(self.states)))
+        # for i in range(4):
+        #     P[i, i] = x[i]
+        #     P[i, i+1] = 1 - x[i]
+        # P[4, 4] = 1
+        # TODO:
+        raise ValueError('Fix this.')
+        return P
+        
+    def Q(self, t: np.ndarray, x: float, output_format='array') -> np.ndarray:
+        """
+
+        """
+        if self.function != 'exponential':
+            param = {'a': x[:-9], 'b': x[-9:]}
+        else:
+            param = {'a': x}
+    
+        if isinstance(t, float):
+            t = np.array([t])
+    
+        Q = np.zeros((len(t), len(self.states), len(self.states)))
+        
+        Q[:, 0, 0] =  -transition_rate(0, t, param, self.function) - transition_rate(4, t, param, self.function)
+        Q[:, 0, 1] =   transition_rate(0, t, param, self.function)
+        Q[:, 0, 5] =   transition_rate(4, t, param, self.function)
+        
+        Q[:, 1, 1] =  -transition_rate(1, t, param, self.function) - transition_rate(5, t, param, self.function)
+        Q[:, 1, 2] =   transition_rate(1, t, param, self.function)
+        Q[:, 1, 5] =   transition_rate(5, t, param, self.function)
+        
+        Q[:, 2, 2] =  -transition_rate(2, t, param, self.function) - transition_rate(6, t, param, self.function)
+        Q[:, 2, 3] =   transition_rate(2, t, param, self.function)
+        Q[:, 2, 5] =   transition_rate(6, t, param, self.function)
+        
+        Q[:, 3, 3] =  -transition_rate(3, t, param, self.function) - transition_rate(7, t, param, self.function)
+        Q[:, 3, 4] =   transition_rate(3, t, param, self.function)
+        Q[:, 3, 5] =   transition_rate(7, t, param, self.function)
+        
+        Q[:, 4, 4] =  -transition_rate(8, t, param, self.function)
+        Q[:, 4, 5] =   transition_rate(8, t, param, self.function)
+
+        _lim = 1E-6
+        error = np.sum(Q, axis=2)
+        if (error > _lim).any():
+            warnings.warn('The sum of rows is larger than ' + str(_lim) + '. Errors: ' + str(error[error > _lim]))
+
+        if output_format == 'array':
+            return Q
+        elif output_format == 'dataframe':
+            return pd.DataFrame(Q.reshape(len(t), Q.shape[1]**2),
+                                columns=[(from_state, to_state) for from_state in self.states for to_state in self.states],
+                                index=t)
+    
+    def getInitalParameters(self) -> np.ndarray:
+        """
+        Retrieves initial parameters for the current instance.
+    
+        This method calls the global function `getInitalParameters`, passing `self` as an argument,
+        to obtain initial parameters. It updates the instance with these parameters.
+    
+        Returns:
+            np.ndarray: The `x` parameter obtained from `getInitalParameters` function, intended to be used as initial parameters.
+    
+        Note:
+            This method also updates `self.x` and `self.s0` with the values obtained from the `getInitalParameters` function.
+        """
+        x, s0 = getInitalParameters(self)
+        self.x = x
+        self.s0 = s0
+
+    def getBounds(self) -> list:
+        """
+        Combines and returns the bounds for x and s0 as a single list.
+    
+        Returns:
+            list: A list containing the bounds for x and s0.
+        """
+        return bounds_x(self) + bounds_s0(self)
+    
+
+    def getMCParametersFromX(self, x):
+        """
+        Reparametrizes the Markov Chain with a new set of parameters based on the input `x`.
+    
+        This method constructs a new parameter dictionary with 's0' being the last five elements of `x`
+        and 'x' being all other elements before the last five. It then applies these parameters
+        to the current instance using the `Transform` method.
+    
+        Args:
+            x (iterable): An array-like object containing parameters for reparametrization. The last five elements
+                          are assigned to 's0', and the rest to 'x'.
+    
+        Returns:
+            The result of the `Transform` method called with the current instance and the new parameters.
+    
+        Note:
+            The `Transform` method is assumed to be a method of the current class or a globally accessible function
+            that accepts the instance and a parameter dictionary to perform some transformation or update.
+        """
+        return Transform(self, param = {'s0':x[-6:],'x':x[:-6]})
+    
+    def getXFromMCParameters(self, x=None, s0=None):
+        """
+        Calculates and returns the inverse transform based on Monte Carlo parameters.
+    
+        This method computes the inverse transform using the provided `x` and `s0` values. If `x` or `s0` are not provided,
+        it defaults to using the object's `x` and `s0` attributes, respectively.
+    
+        Parameters:
+        - x (Optional): The value to be used in the inverse transform calculation. Defaults to the object's `x` attribute if not provided.
+        - s0 (Optional): The starting value to be used in the inverse transform calculation. Defaults to the object's `s0` attribute if not provided.
+    
+        Returns:
+        - The result of the InverseTransform function, utilizing the provided or default `x` and `s0` values.
+        """
+        if not x:
+            x = self.x
+        if not s0:
+            s0 = self.s0
+        return InverseTransform(self, x, s0)
+
+    def getMCParameters(self, x=None):
+        """
+        Retrieves parameters 's0' and 'x' based on the provided input.
+    
+        If 'x' is not provided, 's0' and 'x' are retrieved from the object's attributes.
+        If 'x' is provided, 's0' is set to the last 5 elements of 'x', and 'x' is set to the rest.
+    
+        Parameters:
+        x (optional): Array-like or None. If provided, it is used to determine 's0' and 'x'.
+    
+        Returns:
+        dict: A dictionary containing 's0' and 'x' parameters.
+        """
+        return {'s0': self.s0 if x is None else x[-6:], 'x': self.x if x is None else x[:-6]}
+
+    def constraints(self) -> list:
+        """Defines constraints for optimization ensuring the last N numbers of the array sum to 1.0.
+        
+        Args:
+            N: The number of last elements in the array to sum to 1.0.
+            
+        Returns:
+            A list containing the constraint.
+        """
+        return [{'type': 'eq', 'fun': lambda x: 1.0 - sum(x[-self.number_parameters(self.function):])}]
+    
+
+    
+    
+    
\ No newline at end of file
diff --git a/scripts/msdmodeler.py b/scripts/msdmodeler.py
new file mode 100644
index 0000000..270bfcd
--- /dev/null
+++ b/scripts/msdmodeler.py
@@ -0,0 +1,151 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Mon Feb 19 16:14:09 2024
+@author: Lisandro A. Jimenez-Roa
+"""
+
+import dill
+import pandas as pd
+import numpy as np
+import random
+import string
+from turnbull_estimator import TurnbullEstimator
+from ihtmc import InhomogeneousTimeMarkovChain as IHTMC
+
+class MultiStateDegradationModeler:
+    
+    """
+    Main degradation modeller for multi-state degradation.
+    
+    This section can include a more detailed description of the class, explaining its purpose and how it should be used. You can also mention any important notes or warnings regarding the class.
+    
+    Attributes:
+        system_features (pd.DataFrame): Contains a dataframe with all the properties of the system, each row represents a system component. Each column is a property e.g., location, length, pipe_id.
+    
+    Args:
+        case_name (str): Name of the case study to load from [file_name].
+        db_path (str): Path of the db. file.
+        context_var_blacklist (Boolean): If True, removes predefined variables from the context. If False, it loads all the variables as context.
+        verbose(int): If 2: Prints all the information when building the object.
+    
+    Examples:
+        >>> instance = MyClass(param1, param2)
+        >>> instance.method1()
+        Expected result from method1.
+    
+    
+    """
+    def __init__(self,system_features,system_inspections,verbose=2):
+        
+        # load default parameters:
+        self.default_parameters = self.get_default_parameters({k: v for k, v in locals().items() if k != 'self'})
+        
+        # Load data:
+        self.system_features = system_features
+        self.system_inspections = system_inspections
+        self.df_msdm = pd.DataFrame()
+        
+        
+    def check_msdm_avail(self,df,feat):
+        """
+        Check whether all components have associated at least one degradation model.
+    
+        Parameters:
+        - df (pd.DataFrame): contains all the components features.
+        - feat (pd.DataFrame): contains the features associated to a degradation model
+    
+        Returns:
+        - pd.DataFrame: DataFrame with Boolean values indicating whether exists (1) or not(0) a degradation model.
+        """
+        
+        isThereMSDM = pd.DataFrame()
+        
+        if not self.df_msdm.empty:
+            raise ValueError('Program this part')
+        else:
+            isThereMSDM = pd.DataFrame({'isThereMSDM':list(np.zeros(df.shape[0]).astype(bool))})
+        
+        return isThereMSDM
+        
+    def fit(self,case_to_train,context_var_for_msdm,save_path=None,verbose=1):
+        """
+        Main manager to fit Multi-State Degradation Models (MSDM)
+    
+        Parameters:
+        - case_to_train (df): DataFrame that containts the contextual values and additional parameters to train the MSDM.
+        - context_var_for_msdm (list): Indicates the contextual variables used to build the degradation model.
+        - save_path (str): path where the degradation model is saved.
+    
+        Returns:
+        - object: object associated to the degradation model.
+        """
+        for index,row in case_to_train.iterrows():
+            # Fetch sub-set from self.system_features:
+            subset_system_features = self.system_features[self.system_features[context_var_for_msdm].eq(pd.Series(row[context_var_for_msdm])).all(axis=1)]
+            # Fetch sub-set from self.system_inspections:
+            subset_system_inspections = self.get_lifetime_data(subset_system_features=subset_system_features,damage_code=row.code,add_collapse=True,flag='over_length')
+            # Train Turnbull estimator:
+            if False:
+                TE = TurnbullEstimator(df=subset_system_inspections)
+                TE.fit(verbose=verbose)
+            if row.markov_chain_type == 'IHCTMC':
+                # Train Inhomogeneous-continuous time Markov chain
+                ihtmc = IHTMC(df=subset_system_inspections)
+                ihtmc.fit()
+            
+            # Generate an unique identifier to the model:
+            unique_id = self.generate_random_string()
+        
+        if save_path:
+            # Save model externally
+            pass 
+        
+    def get_lifetime_data(self, subset_system_features, damage_code, severities=[1,2,3,4,5,6], flag='most_critical', add_collapse=False, cut_max_age=None, cut_max_age_flag='low', location=None):
+        df = self.system_inspections[self.system_inspections['pipe_id'].isin(subset_system_features['pipe_id'])]
+        df = df.merge(self.system_features[['pipe_id', 'construction_year', 'cohort', 'length', 'width']], on='pipe_id')
+        df['inspection_date'] = pd.to_datetime(df['inspection_date'])
+        df['construction_year'] = pd.to_datetime(df['construction_year'].astype(int).astype(str) + '-01-01')
+        df['pipe_age_during_inspection'] = (df['inspection_date'] - df['construction_year']).dt.total_seconds() / (365.25 * 24 * 3600)
+        df = df[df['pipe_age_during_inspection'] >= 0]
+        if cut_max_age:
+            df = df[df['pipe_age_during_inspection'] <= cut_max_age] if cut_max_age_flag == 'low' else df[df['pipe_age_during_inspection'] > cut_max_age]
+        if location:
+            df = df[df['location'] == location]
+        non_matching_codes = df['code'] != damage_code
+        df.loc[non_matching_codes, ['code', 'damage_class']] = [damage_code, 1]
+        if add_collapse:
+            collapse_indices =  self.system_inspections['code'] == 'BAC'
+            df.loc[collapse_indices, 'damage_class'] = 6
+        if flag == 'most_critical':
+            df = df.groupby('inspection_id').agg({'pipe_id': 'first', 'pipe_age_during_inspection': 'first', 'damage_class': 'max'}).reset_index()
+        elif flag ==  'over_length':
+            df = df[['pipe_id', 'pipe_age_during_inspection', 'damage_class']]
+        else:
+            raise ValueError('Unknown flag')
+        df.rename(columns={'damage_class': 'severity'}, inplace=True)
+        return df.sort_values(by='pipe_age_during_inspection').reset_index(drop=True)
+
+    def generate_random_string(self,N=30):
+        return ''.join(random.choices(string.ascii_letters + string.digits, k=N))
+    
+    def get_default_parameters(self,param):
+        """
+        Fetch default parameters:
+    
+        Parameters:
+        - 
+    
+        Returns:
+        - dict: With default parameters.
+        """
+        
+        del param['system_features']
+        del param['system_inspections']
+
+        return param
+        
+if __name__ == "__main__":
+    #system_structure = MultiStateDegradationModeler()
+    pass
+    
\ No newline at end of file
diff --git a/scripts/probability_density_functions.py b/scripts/probability_density_functions.py
new file mode 100644
index 0000000..997c27d
--- /dev/null
+++ b/scripts/probability_density_functions.py
@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 11:53:51 2024
+
+@author: lisandro
+"""
+import numpy as np
+import scipy.stats as stats
+
+# Gompertz distribution:
+class gompertz:
+    def __init__(self):
+        pass
+    def hazard_rate(t, alpha, beta):
+        return alpha * beta * np.exp(beta * t) #stats.gompertz.pdf(t, alpha, scale=beta)/(1-stats.gompertz.cdf(t, alpha, scale=beta))#
+    def pdf(t, alpha, beta):
+        return alpha * beta * np.exp(alpha) * np.exp(beta * t) * np.exp(-alpha * np.exp(beta * t))
+    def cdf(t, alpha, beta):
+        return 1 - np.exp(-alpha * np.exp(beta * t) + alpha)
+    
+# Gamma distribution:
+class gamma:
+    def __init__(self):
+        pass
+    def hazard_rate(t, alpha, beta):
+        pdf = stats.gamma.pdf(t, alpha, scale=1/beta)
+        survival_function = 1 - stats.gamma.cdf(t, alpha, scale=1/beta)
+        hazard_rate = pdf / survival_function
+        return hazard_rate
+    def pdf(t, alpha, beta):
+        return stats.gamma.pdf(t, alpha, scale=1/beta)
+    def cdf(t, alpha, beta):
+        return 1 - stats.gamma.cdf(t, alpha, scale=1/beta)
+    
+# Log-logistic distribution:
+class loglogistic:
+    def __init__(self):
+        pass
+    def hazard_rate(t, alpha, beta):
+        #numerator = (beta / alpha) * ((t / alpha)**(beta - 1))
+        #denominator = (1 + (t / alpha)**beta)**2
+        #pdf =  numerator / denominator
+        #log_transform = np.log(t / alpha) * beta
+        #cdf = stats.logistic.cdf(log_transform)
+        return ((beta / alpha) * (t / alpha)**(beta - 1)) / (1 + (t / alpha)**beta) #pdf / (1 - cdf)
+    def pdf(t, alpha, beta):
+        numerator = (beta / alpha) * ((t / alpha)**(beta - 1))
+        denominator = (1 + (t / alpha)**beta)**2
+        return numerator / denominator
+    def cdf(t, alpha, beta):
+        # Applying the log transformation to t and then using the logistic CDF
+        log_transform = np.log(t / alpha) * beta
+        return stats.logistic.cdf(log_transform)
+    
+class lognormal:
+    def __init__(self):
+        pass
+    def hazard_rate(t, alpha, beta):
+        pdf = stats.lognorm.pdf(t, alpha, scale=np.exp(beta))
+        sf = 1 - stats.lognorm.cdf(t, alpha, scale=np.exp(beta))
+        return pdf / sf
+    def pdf(t, alpha, beta):
+        return stats.lognorm.pdf(t, alpha, scale=np.exp(beta))
+    def cdf(t, alpha, beta):
+        return stats.lognorm.cdf(t, alpha, scale=np.exp(beta))
+    
+# Exponential distribution:
+class exponential:
+    def __init__(self):
+        pass
+    def hazard_rate(t,lambda_):
+        if isinstance(t,float):
+            return lambda_
+        elif isinstance(t,np.ndarray) or isinstance(t,list):
+            return lambda_*np.ones(len(t))
+        
+# Weibul distribution:
+class weibull:
+    def __init__(self):
+        pass
+    def hazard_rate(t, alpha, beta):
+        return  (alpha / beta) * (t / beta)**(alpha - 1)#(beta / alpha) * (t / alpha)**(beta - 1) # 
+    def pdf(t, alpha, beta):
+        return (beta/alpha)*((t/alpha)**(beta-1))*np.exp(-(t/alpha)**beta)
+    def cdf(t, alpha, beta):
+        return 1 - np.exp(-(t/alpha)**beta)
\ No newline at end of file
diff --git a/scripts/sample_markov_chain.py b/scripts/sample_markov_chain.py
new file mode 100644
index 0000000..ad965d5
--- /dev/null
+++ b/scripts/sample_markov_chain.py
@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 15:22:52 2024
+
+@author: lisandro
+"""
+from ihtmc import InhomogeneousTimeMarkovChain as IHTMC
+import numpy as np
+import matplotlib.pyplot as plt
+import pandas as pd
+
+ihtmc = IHTMC(MCStructureID='ihtmc_s2_typeA')
+params = {'s0': np.array([0.9, 0.1]),
+          'x': np.array([1,
+                         0.1])}
+p = ihtmc.predict(params=params,t=np.linspace(0, 50,1000),atol=1e-4, rtol=1e-4)  # Removed colon at the end
+#%% Randomly sample from Markov chain --> Generate synthetic dataset.
+num_inspections = 1000
+ti = np.array(p.index)
+s = np.array([int(i[2:]) for i in p.columns])
+times = np.random.uniform(0, 50, num_inspections)
+choices = [np.random.choice(s, p=p.iloc[np.argmin(np.abs(t - ti))].values) for t in times]
+obs = np.column_stack((times, choices))
+subset_system_inspections = pd.DataFrame(obs, columns=['time', 'state']).sort_values(by='time', ascending=True).reset_index(drop=True)
+subset_system_inspections['state'] = subset_system_inspections['state'].astype(int)
+subset_system_inspections.set_index('time', inplace=True)
+#%% Let's now infer the parameters of the dataset.
+gompertz = IHTMC(df=subset_system_inspections,MCStructureID='ihtmc_s2_typeA')
+gompertz.fit()
+#%% 
+plt.close('all')
+plt.plot(p.index,p)
+gompertz.plot()
diff --git a/scripts/turnbull.py b/scripts/turnbull.py
new file mode 100644
index 0000000..33602b8
--- /dev/null
+++ b/scripts/turnbull.py
@@ -0,0 +1,178 @@
+import pandas as pd
+import numpy as np
+from lifelines import KaplanMeierFitter as KM
+import time
+from datetime import datetime
+import dill
+
+class TurnbullEstimator:
+    '''
+    Doubly-Censored Kaplan Meier estimator.
+    
+    Attributes:
+        df (pandas.DataFrame): Dataframe containing the data to fit the model.
+        states (list, optional): List of states to consider for the estimation. Defaults to None, in which case it uses unique states from the dataframe.
+    '''
+    def __init__(self, df, states=None):
+        '''
+        Initializes the TurnbullEstimator with a dataframe and optionally a list of states.
+        
+        Parameters:
+            df (pandas.DataFrame): Dataframe containing the data.
+            states (list, optional): Specific states to use for the estimation.
+        '''
+        self.df = df
+        self.states = states
+        self.fit()
+
+    def fit(self):
+        '''
+        Fits the model using the data provided during initialization.
+        
+        This method processes the dataframe to handle doubly-censored data and fits a Kaplan Meier model to each state.
+
+        Returns:
+            pandas.DataFrame: A dataframe summarizing the model parameters for each state.
+        '''
+        if not self.states:
+            self.states = list(self.df['state'].unique())
+            
+        # Prepare df table to be handled by the turnbull estimator:
+        df = self.df.reset_index()  # Move 'time' from index to a column
+        df = df.loc[df.index.repeat(df['count'])].drop(columns=['count']).reset_index(drop=True)
+
+        models_summary = []
+        for s in self.states:
+            print("Binarization threshold: "+str(s))
+            dfp = pd.DataFrame({
+                'left': np.nan,
+                'right': np.nan
+                }, index=df.index)
+            
+            # The transition did not occur:
+            dfp.loc[df['state'] <= s, 'right'] = np.inf
+            dfp.loc[df['state'] <= s, 'left'] = df.loc[df['state'] <= s]['time']
+            
+            # If the transition occurred:
+            dfp.loc[df['state'] > s, 'right'] = df.loc[df['state'] > s]['time']
+            dfp.loc[df['state'] > s, 'left'] = 0
+            
+            start_time = time.time()
+            km_model = KM().fit_interval_censoring(dfp['left'], dfp['right'])
+            end_time = time.time()
+            
+            # Saving model parameters:
+            model_summary = {
+                'date_time': datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+                'convergence_time_sec': end_time - start_time,
+                'binary_threshold': s,
+                'model': km_model,
+            }
+            models_summary.append(model_summary)
+        
+        self.model = pd.DataFrame(models_summary)
+        return self.model
+    
+    def predict(self, t=np.arange(0, 50), km_mean=True):
+        """
+        Predicts the non-parametric maximum likelihood estimate (NPMLE) for a given range of time points and binary states.
+        
+        This function iterates through pairs of consecutive states to calculate the upper and lower NPMLE estimates.
+        For the first state, it directly uses the model's predictions. For subsequent states, it calculates the difference
+        in predictions between the current state and the previous state. Optionally, it can compute the mean of the upper
+        and lower estimates to simplify the output to a single value per state.
+    
+        Parameters:
+        - t (np.ndarray, optional): An array of time points for which predictions are to be made. Defaults to np.arange(0, 50).
+        - km_mean (bool, optional): A flag to determine if the mean of the upper and lower NPMLE estimates should be computed.
+                                    If True, the output is simplified to a single value per state. Defaults to True.
+    
+        Returns:
+        - pd.DataFrame: A DataFrame containing the NPMLE estimates. If km_mean is True, each state is represented by a single
+                        column with the mean value. Otherwise, each state has two columns representing the upper and lower
+                        NPMLE estimates.
+        """
+        # Initialize an empty dictionary to store predictions
+        p = dict()  # Assuming this initialization is done if not already
+        for index, s in enumerate(self.states):
+            # Handle the first state separately
+            if s == self.states[0]:
+                predictions = self.model[self.model['binary_threshold'] == s].iloc[0].model.predict(t)
+                p['s_' + str(s) + '_up'] = np.array(predictions['NPMLE_estimate_upper'])
+                p['s_' + str(s) + '_down'] = np.array(predictions['NPMLE_estimate_lower'])
+            else:
+                # For subsequent states, calculate the difference in predictions
+                previous_s = self.states[index - 1]  # Get the previous state
+                predictions_diff = self.model[self.model['binary_threshold'] == s].iloc[0].model.predict(t) - \
+                                   self.model[self.model['binary_threshold'] == previous_s].iloc[0].model.predict(t)
+                p['s_' + str(s) + '_up'] = predictions_diff['NPMLE_estimate_upper']
+                p['s_' + str(s) + '_down'] = predictions_diff['NPMLE_estimate_lower']
+        
+        # Convert to DataFrame if needed outside this snippet
+        p = pd.DataFrame(p)
+            
+        if km_mean:
+            # If km_mean is True, compute the mean of the upper and lower estimates
+            for i in self.states:
+                prefix = f's_{i}'
+                up_col = f'{prefix}_up'
+                down_col = f'{prefix}_down'
+                p[prefix] = p[[up_col, down_col]].mean(axis=1)
+                p.drop(columns=[up_col, down_col], inplace=True)
+            # Rename columns to match states
+            p.columns = self.states
+            
+        # Replace NaN values by zerp
+        p.iloc[0] = p.iloc[0].fillna(0) #--> only applicable to the first row.
+    
+        return p
+                
+    def save(self, file_name, file_location):
+        with open(f"{file_location}/{file_name}.dill", "wb") as file:
+            dill.dump(self, file)
+     
+if __name__ == "__main__":
+    
+    from copy import copy
+    import matplotlib.pyplot as plt
+    from aux_functions import getFrequencyTable
+    from DataHandlingManager import DataHandlingManager
+    args = {'system_database':'/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/datasets/raw/breda.db',
+        'inspection_database':'/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/datasets/raw/breda.db'} 
+    
+    dh = DataHandlingManager(**args)
+    df = dh.get_lifetime_data(code='BAF',cohort='CS',add_collapse=True)
+    ft = getFrequencyTable(y=copy(df),states=[1,2,3,4,5,'F'],delta=3)
+    df.loc[df['state'] == 'F','state'] = 6
+    tb = TurnbullEstimator(df=df,states=[1,2,3,4,5,6])
+    tb.model.loc[tb.model['binary_threshold'] == 6, 'binary_threshold'] = 'F'
+    tb.states = [1,2,3,4,5,'F']
+
+    fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(6, 4.5))
+    axs = axs.flatten()
+    t = np.arange(0,100)
+    y = tb.predict(t=t)
+    for cont, s in enumerate(tb.states):
+        axs[cont].plot(t,y[s])
+        axs[cont].scatter(ft.index, ft[s], s = ft['total_count']/20)
+
+    tb.save(file_name='turbull_estimator_CS_BAF',
+            file_location='/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/p06b_RL_ihtmc/paper/figures/')
+    
+    df = dh.get_lifetime_data(code='BAF',cohort='CMW',add_collapse=True)
+    ft = getFrequencyTable(y=copy(df),states=[1,2,3,4,5,'F'],delta=3)
+    df.loc[df['state'] == 'F','state'] = 6
+    tb = TurnbullEstimator(df=df,states=[1,2,3,4,5,6])
+    tb.model.loc[tb.model['binary_threshold'] == 6, 'binary_threshold'] = 'F'
+    tb.states = [1,2,3,4,5,'F']
+    
+    fig, axs = plt.subplots(2, 3, sharex=True, sharey=True, figsize=(6, 4.5))
+    axs = axs.flatten()
+    t = np.arange(0,100)
+    y = tb.predict(t=t)
+    for cont, s in enumerate(tb.states):
+        axs[cont].plot(t,y[s])
+        axs[cont].scatter(ft.index, ft[s], s = ft['total_count']/20)
+
+    tb.save(file_name='turbull_estimator_CMW_BAF',
+            file_location='/Users/lisandro/Library/CloudStorage/OneDrive-UniversiteitTwente/PhD/Papers/p06b_RL_ihtmc/paper/figures/')
\ No newline at end of file
diff --git a/scripts/turnbull_estimator.py b/scripts/turnbull_estimator.py
new file mode 100644
index 0000000..2cac9cf
--- /dev/null
+++ b/scripts/turnbull_estimator.py
@@ -0,0 +1,123 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Wed Feb 21 10:03:49 2024
+
+@author: lisandro
+"""
+import pandas as pd
+from lifelines import KaplanMeierFitter as KM
+import numpy as np
+import matplotlib.pyplot as plt
+
+
+class TurnbullEstimator:
+    """
+    A class to implement the Turnbull Estimator for interval-censored data analysis.
+    
+    This estimator is particularly useful for analyzing data where the exact value of the
+    event time is not known, but it is known to occur within a certain interval. It is widely
+    used in survival analysis, reliability engineering, and various fields of medical research.
+
+    Attributes:
+        df (pandas.DataFrame): The dataset containing the interval-censored data. Each row represents
+            an observation, and it should include columns that define the lower and upper bounds of the
+            censoring intervals for the event of interest.
+        verbose (int): Controls the verbosity of the output during model fitting and prediction. A higher
+            value means more detailed output. Default is 1.
+        list_models (pandas.DataFrame): Stores the fitted model objects for each severity level. Each row
+            corresponds to a severity level, and the columns include the model details and estimations.
+
+    Args:
+        df (pandas.DataFrame): The data frame with the data to be analyzed. It should include at least
+            two columns indicating the lower and upper bounds of the censoring intervals.
+        verbose (int, optional): Verbosity level. Higher values produce more detailed output during the
+            model fitting process. Defaults to 1.
+
+    Examples:
+        Initialize a TurnbullEstimator object with a DataFrame containing interval-censored data:
+        >>> estimator = TurnbullEstimator(df, verbose=1)
+        Fit the estimator for specified severity levels:
+        >>> estimator.fit(severities=[1, 2, 3, 4, 5, 6])
+        Generate predictions and plot them:
+        >>> estimator.predict(t=np.arange(0, 50), severities=[1, 2, 3, 4, 5, 6])
+        >>> estimator.plot(t=np.arange(0, 50))
+    """
+    
+    def __init__(self, df, verbose=1):
+        """Constructor for TurnbullEstimator."""
+        self.df = df
+        self.verbose = verbose
+        self.list_models = pd.DataFrame()
+
+    def fit(self,severities=[1,2,3,4,5,6], verbose=1):
+        """Fit the Turnbull estimator for each severity level in the given list.
+
+        Args:
+            severities (list, optional): List of severity levels to fit models for. Defaults to [1,2,3,4,5,6].
+            verbose (int, optional): Verbosity level. Defaults to 1.
+        """
+        models = {'s>': [], 'turnbull_estimator': []}
+        for s in severities:
+            if verbose == 2:
+                print(f'Current binarization threshold: s>{s}')
+            
+            dfp = pd.DataFrame({
+                'left': np.where(self.df['severity'] <= s, self.df['pipe_age_during_inspection'], 0),
+                'right': np.where(self.df['severity'] > s, self.df['pipe_age_during_inspection'], np.inf)
+            })
+            
+            km_model = KM().fit_interval_censoring(dfp['left'], dfp['right'])
+            models['s>'].append(s)
+            models['turnbull_estimator'].append(km_model)
+        
+        self.list_models = pd.DataFrame(models)
+        
+    def predict(self, t=np.arange(0, 50), severities=[1, 2, 3, 4, 5, 6], km_mean=True):
+        """
+        Generates predictions for given time points and severities.
+
+        Parameters:
+        - t: numpy array of time points for which to predict. Default is np.arange(0, 50).
+        - severities: list of severity levels to predict for. Default is [1, 2, 3, 4, 5, 6].
+        - km_mean: boolean indicating whether to calculate the mean of the upper and lower estimates. Default is True.
+
+        Returns:
+        - A pandas DataFrame with predictions for each severity level at each time point in `t`.
+        """
+        p = {}
+        for s in severities:
+            if s == severities[0]:
+                predictions = self.list_models[self.list_models['s>'] == s].iloc[0].turnbull_estimator.predict(t)
+                p[f's_{s}_up'], p[f's_{s}_down'] = predictions['NPMLE_estimate_upper'], predictions['NPMLE_estimate_lower']
+            else:
+                current_predictions = self.list_models[self.list_models['s>'] == s].iloc[0].turnbull_estimator.predict(t)
+                previous_predictions = self.list_models[self.list_models['s>'] == s-1].iloc[0].turnbull_estimator.predict(t)
+                difference = current_predictions - previous_predictions
+                p[f's_{s}_up'], p[f's_{s}_down'] = difference['NPMLE_estimate_upper'], difference['NPMLE_estimate_lower']
+        p = pd.DataFrame(p)
+        p.index = t
+        
+        if km_mean:
+            # Calculate the mean of the upper and lower estimates for each severity level
+            for i in severities:
+                prefix = f's_{i}'
+                up_col = f'{prefix}_up'
+                down_col = f'{prefix}_down'
+                p[prefix] = p[[up_col, down_col]].mean(axis=1)
+                p.drop(columns=[up_col, down_col], inplace=True)
+
+        return p
+
+    def plot(self, t=np.arange(0, 50)):
+        """
+        Plots the predictions for given time points.
+
+        Parameters:
+        - t: numpy array of time points for which to plot predictions. Default is np.arange(0, 50).
+        """
+        predictions = self.predict(t)
+        for column in predictions.columns:
+            plt.plot(t, predictions[column], label=column)
+        plt.legend()
+        plt.show()
-- 
GitLab