From 9d360328f983619bc5d09ff80d438831906ca8fe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Fabian=20Fr=C3=B6hlich?= <fabian_froehlich@hms.harvard.edu>
Date: Sun, 14 Mar 2021 20:16:57 -0400
Subject: [PATCH] overhaul experimental conditions notebook (#1460)

* overhaul experimental conditions notebook

* fix kernel

* Apply suggestions from code review

Co-authored-by: Daniel Weindl <dweindl@users.noreply.github.com>

* update and rerun notebook

* fix kernel

Co-authored-by: Daniel Weindl <dweindl@users.noreply.github.com>
---
 .../ExampleExperimentalConditions.ipynb       |   1 +
 documentation/GettingStarted.ipynb            |   2 +-
 documentation/model_presimulation.ipynb       |   1 -
 documentation/python_interface.rst            |   2 +-
 .../ExampleExperimentalConditions.ipynb       | 462 ++++++++++++++++++
 .../model_presimulation.ipynb                 | 416 ----------------
 6 files changed, 465 insertions(+), 419 deletions(-)
 create mode 120000 documentation/ExampleExperimentalConditions.ipynb
 delete mode 120000 documentation/model_presimulation.ipynb
 create mode 100644 python/examples/example_presimulation/ExampleExperimentalConditions.ipynb
 delete mode 100644 python/examples/example_presimulation/model_presimulation.ipynb

diff --git a/documentation/ExampleExperimentalConditions.ipynb b/documentation/ExampleExperimentalConditions.ipynb
new file mode 120000
index 0000000000..269610ab48
--- /dev/null
+++ b/documentation/ExampleExperimentalConditions.ipynb
@@ -0,0 +1 @@
+../python/examples/example_presimulation/ExampleExperimentalConditions.ipynb
\ No newline at end of file
diff --git a/documentation/GettingStarted.ipynb b/documentation/GettingStarted.ipynb
index a4036aba89..c1bc4df6bf 100644
--- a/documentation/GettingStarted.ipynb
+++ b/documentation/GettingStarted.ipynb
@@ -185,7 +185,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "This notebook only explains the basics of AMICI simulations. In general, AMICI simulations are highly customizable and can also be used to simulate sensitivities. The [ExampleSteadystate](https://amici.readthedocs.io/en/latest/ExampleSteadystate.html) notebook in this folder gives more detail about the model employed here and goes into the basics of sensitivity analysis. The [ExampleEquilibrationLogic](https://amici.readthedocs.io/en/latest/ExampleEquilibrationLogic.html) notebook, builds on this by using a modified version of this model to give detailed insights into the methods and options to compute steady states before and after simulations, as well as respective sensitivities. The [Presimulation example](https://amici.readthedocs.io/en/latest/model_presimulation.html) notebook, goes into the details of how even more complex experimental setups, such as addition of drugs at predefined timepoints, can be simulated in AMICI. Finally, the [petab](https://amici.readthedocs.io/en/latest/petab.html) notebook explains how standardized definitions of experimental data and conditions in the [PEtab](https://github.com/PEtab-dev/PEtab) format can be imported in AMICI."
+    "This notebook only explains the basics of AMICI simulations. In general, AMICI simulations are highly customizable and can also be used to simulate sensitivities. The [ExampleSteadystate](https://amici.readthedocs.io/en/latest/ExampleSteadystate.html) notebook in this folder gives more detail about the model employed here and goes into the basics of sensitivity analysis. The [ExampleEquilibrationLogic](https://amici.readthedocs.io/en/latest/ExampleEquilibrationLogic.html) notebook, builds on this by using a modified version of this model to give detailed insights into the methods and options to compute steady states before and after simulations, as well as respective sensitivities. The [ExampleExperimentalConditions example](https://amici.readthedocs.io/en/latest/ExampleExperimentalConditions.html) notebook, goes into the details of how even more complex experimental setups, such as addition of drugs at predefined timepoints, can be simulated in AMICI. Finally, the [petab](https://amici.readthedocs.io/en/latest/petab.html) notebook explains how standardized definitions of experimental data and conditions in the [PEtab](https://github.com/PEtab-dev/PEtab) format can be imported in AMICI."
    ]
   }
  ],
diff --git a/documentation/model_presimulation.ipynb b/documentation/model_presimulation.ipynb
deleted file mode 120000
index 7b73d05c74..0000000000
--- a/documentation/model_presimulation.ipynb
+++ /dev/null
@@ -1 +0,0 @@
-../python/examples/example_presimulation/model_presimulation.ipynb
\ No newline at end of file
diff --git a/documentation/python_interface.rst b/documentation/python_interface.rst
index c605c71d66..bdcb17e520 100644
--- a/documentation/python_interface.rst
+++ b/documentation/python_interface.rst
@@ -125,7 +125,7 @@ Examples
    GettingStarted.ipynb
    ExampleSteadystate.ipynb
    petab.ipynb
-   model_presimulation.ipynb
+   ExampleExperimentalConditions.ipynb
    ExampleEquilibrationLogic.ipynb
 
 
diff --git a/python/examples/example_presimulation/ExampleExperimentalConditions.ipynb b/python/examples/example_presimulation/ExampleExperimentalConditions.ipynb
new file mode 100644
index 0000000000..07da70c02f
--- /dev/null
+++ b/python/examples/example_presimulation/ExampleExperimentalConditions.ipynb
@@ -0,0 +1,462 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# AMICI Python example \"Experimental Conditions\"\n",
+    "In this example we will explore some more options for the initialization of experimental conditions, including how to reset initial conditions based on changing values for `fixedParameters` as well as an additional presimulation phase on top of preequilibration. This notebook is expected to run from the `python/example_presimulation` directory."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# SBML model we want to import\n",
+    "sbml_file = 'model_presimulation.xml'\n",
+    "# Name of the model that will also be the name of the python module\n",
+    "model_name = 'model_presimulation'\n",
+    "# Directory to which the generated model code is written\n",
+    "model_output_dir = model_name\n",
+    "\n",
+    "import libsbml\n",
+    "import amici\n",
+    "import amici.plotting\n",
+    "import os\n",
+    "import sys\n",
+    "import importlib\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "from pprint import pprint"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Model Loading\n",
+    "Here we load a simple model of protein phosphorylation that can be inhibited by a drug. This model was created using PySB (see `createModel.py`)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Species:\n",
+      "[('__s0', \"PROT(kin=None, drug=None, phospho='u')\"),\n",
+      " ('__s1', 'DRUG(bound=None)'),\n",
+      " ('__s2', 'KIN(bound=None)'),\n",
+      " ('__s3', \"DRUG(bound=1) ._br_PROT(kin=None, drug=1, phospho='u')\"),\n",
+      " ('__s4', \"KIN(bound=1) ._br_PROT(kin=1, drug=None, phospho='u')\"),\n",
+      " ('__s5', \"PROT(kin=None, drug=None, phospho='p')\")]\n",
+      "\n",
+      "Reactions:\n",
+      "PROT_DRUG_bind:  __s0 +  __s1 <->      __s3\t\t[-(koff_prot_drug * __s3) + kon_prot_drug * __s0 * __s1]\n",
+      "PROT_KIN_bind:  __s0 +  __s2  ->      __s4\t\t[kon_prot_kin * __s0 * __s2]\n",
+      "PROT_KIN_phospho:       __s4  -> __s2 +  __s5\t\t[kphospho_prot_kin * __s4]\n",
+      "PROT_dephospho:       __s5  ->      __s0\t\t[kdephospho_prot * __s5]\n",
+      "Parameters:\n",
+      "[('initProt', 'initProt'),\n",
+      " ('initDrug', 'initDrug'),\n",
+      " ('initKin', 'initKin'),\n",
+      " ('pPROT_obs', 'pPROT_obs'),\n",
+      " ('PROT_0', 'PROT_0'),\n",
+      " ('DRUG_0', 'DRUG_0'),\n",
+      " ('KIN_0', 'KIN_0'),\n",
+      " ('kon_prot_drug', 'kon_prot_drug'),\n",
+      " ('koff_prot_drug', 'koff_prot_drug'),\n",
+      " ('kon_prot_kin', 'kon_prot_kin'),\n",
+      " ('kphospho_prot_kin', 'kphospho_prot_kin'),\n",
+      " ('kdephospho_prot', 'kdephospho_prot'),\n",
+      " ('__obs0', 'pPROT'),\n",
+      " ('__obs1', 'tPROT')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "sbml_reader = libsbml.SBMLReader()\n",
+    "sbml_doc = sbml_reader.readSBML(sbml_file)\n",
+    "sbml_model = sbml_doc.getModel()\n",
+    "\n",
+    "print('Species:')\n",
+    "pprint([(s.getId(),s.getName()) for s in sbml_model.getListOfSpecies()])\n",
+    "\n",
+    "print('\\nReactions:')\n",
+    "for reaction in sbml_model.getListOfReactions():\n",
+    "    reactants = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfReactants()])\n",
+    "    products  = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfProducts()])\n",
+    "    reversible = '<' if reaction.getReversible() else ''\n",
+    "    print('%3s: %10s %1s->%10s\\t\\t[%s]' % (reaction.getName(), \n",
+    "                        reactants,\n",
+    "                        reversible,\n",
+    "                         products,\n",
+    "                        libsbml.formulaToL3String(reaction.getKineticLaw().getMath())))\n",
+    "    \n",
+    "print('Parameters:')\n",
+    "pprint([(p.getId(),p.getName()) for p in sbml_model.getListOfParameters()])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [],
+   "source": [
+    "# Create an SbmlImporter instance for our SBML model\n",
+    "sbml_importer = amici.SbmlImporter(sbml_file)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For this example we want specify the initial drug and kinase concentrations as experimental conditions. Accordingly we specify them as `fixedParameters`. The meaning of `fixedParameters` is defined in the [Glossary](https://amici.readthedocs.io/en/latest/glossary.html#term-fixed-parameters), which we display here for convenience."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "\n",
+       "        <iframe\n",
+       "            width=\"600\"\n",
+       "            height=\"175\"\n",
+       "            src=\"https://amici.readthedocs.io/en/latest/glossary.html#term-fixed-parameters\"\n",
+       "            frameborder=\"0\"\n",
+       "            allowfullscreen\n",
+       "        ></iframe>\n",
+       "        "
+      ],
+      "text/plain": [
+       "<IPython.lib.display.IFrame at 0x10ce15b50>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from IPython.display import IFrame\n",
+    "IFrame('https://amici.readthedocs.io/en/latest/glossary.html#term-fixed-parameters', width=600, height=175)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fixedParameters = ['DRUG_0','KIN_0']"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The SBML model specifies a single observable named `pPROT` which describes the fraction of phosphorylated Protein. We load this observable using [amici.assignmentRules2observables](https://amici.readthedocs.io/en/latest/generated/amici.sbml_import.html#amici.sbml_import.assignmentRules2observables)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Observables:\n",
+      "{'__obs0': {'formula': '__s5', 'name': 'pPROT'}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Retrieve model output names and formulae from AssignmentRules and remove the respective rules\n",
+    "observables = amici.assignmentRules2observables(\n",
+    "        sbml_importer.sbml, # the libsbml model object\n",
+    "        filter_function=lambda variable: variable.getName() == 'pPROT' \n",
+    "    )\n",
+    "print('Observables:')\n",
+    "pprint(observables)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now the model is ready for compilation using [sbml2amici](https://amici.readthedocs.io/en/latest/generated/amici.sbml_import.SbmlImporter.html#amici.sbml_import.SbmlImporter.sbml2amici). Note that we here pass `fixedParameters` as arguments to `constant_parameters`, which ensures that amici is aware that we want to have them as `fixedParameters`:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sbml_importer.sbml2amici(model_name, \n",
+    "                         model_output_dir, \n",
+    "                         verbose=False,\n",
+    "                         observables=observables,\n",
+    "                         constant_parameters=fixedParameters)\n",
+    "# load the generated module\n",
+    "model_module = amici.import_model_module(model_name, model_output_dir)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To simulate the model we need to create an instance via the `getModel()` method in the generated model module."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create Model instance\n",
+    "model = model_module.getModel()\n",
+    "\n",
+    "# Create solver instance\n",
+    "solver = model.getSolver()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The only thing we need to simulate the model is a timepoint vector, which can be specified using the [setTimepoints](https://amici.readthedocs.io/en/latest/generated/amici.amici.Model.html#amici.amici.Model.setTimepoints) method. If we do not specify any additional options, the default values for `fixedParameters` and `parameters` that were specified in the SBML file will be used."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYYAAAEZCAYAAACTsIJzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAArdElEQVR4nO3deZxU1Z338c+vd/al6WZrdhBEWZQGjTFRVBxUAtGYRJI4KjGMM5onZpvok4mJTiZPTGaS+JrxyRMmMToag0tQiaKYYUxMjCLNvssi2N3Q0NDs9FJd9Xv+qItWt93Q3XRXdVV9369Xvaruuadu/Y4W/at7zr3nmLsjIiJySkaiAxARkc5FiUFERBpQYhARkQaUGEREpAElBhERaUCJQUREGlBikLRiZt8zsycSHcfpnClGM9tlZlfFMyZJL0oMknLM7FYzW29mJ82swsx+bma9Ex2XSLJQYpCUYmZfBx4Evgn0Ai4GhgF/MLOcOMWQFY/PEekoSgySMsysJ3A/8GV3f8XdQ+6+C/gMMBz4QlA1z8yeMrNjZrbKzCbFHONbZlYe7NtqZlcG5Rlmdo+Z7TCzg2b2tJn1DfYNNzM3sy+a2XvA/5jZy2Z2V6P41prZDcHrh8ys1MyOmtlKM/tYo+Y0G2OjY54urjwzeyIoP2xmK8ys/9n9V5Z0oMQgqeQSIA9YFFvo7seBJcCMoGgO8AzQF3gSeN7Mss1sLHAXMNXdewB/A+wK3vNl4JPAZcAg4BDwcKPPvww4N3jfb4G5p3aY2XiiZy4vBUUrgMkxMTxjZnkxx2oyxibafLq4biF61jQEyAfuAKqbOIZIA0oMkkr6AQfcvb6JfXuD/QAr3f1Zdw8BPyGaTC4GwkAuMN7Mst19l7vvCN5zB/Btdy9z91rge8CNjbqNvufuJ9y9GngOmGxmw4J9nwcWBe/F3Z9w94PuXu/u/xZ87tiYYzUXY2OniytENCGMdvewu69096Nn/s8o6U6JQVLJAaBfM338A4P9AKWnCt09ApQBg9x9O3A30T+u+81soZkNCqoOA54LumQOA5uJJpLYrpnY4x4jenZwU1A0F/jNqf1m9g0z22xmR4Lj9eKDxNVsjE2063RxPQ4sBRaa2R4z+1EzZx0iDSgxSCp5E6gFbogtNLPuwDXAsqBoSMy+DKAI2APg7k+6+6VE/+A60YFsiP6hvsbde8c88ty9POajGk9V/Ftgrpl9hOgv/teCz/wY8I9Exz76uHtv4AhgMe9tNsZGmo0rGGO5393HE+1mmwX8bZP/5URiKDFIynD3I0QHn//dzGYG4wbDgaeJ/uJ+PKg6xcxuCM4s7iaaTN4ys7FmdoWZ5QI1RPvjI8F7/h/wL6e6hsyswMzmnCGkJUQTzAPAU8Evf4AeQD1QCWSZ2X1Az0bvbTLGJj6j2bjMbLqZTTCzTOAo0a6lSBPHEGlAiUFSirv/CPjfwL8S/WO4nOiv6itP9e8DLwCfJTpQezNwQ9CXnwv8kGiXUwVQCNwbvOchYDHwqpkdI/pH+qIzxFJLdCD8KqIDyKcsBV4B3gF2E01CpY3e3lyMjZ0urgHAs8F/h83An/ggOYo0y7RQj4iIxNIZg4iINKDEICIiDSgxiIhIA0oMIiLSQNJP9tWvXz8fPnx4osMQEUkqK1euPODuBU3tS/rEMHz4cEpKShIdhohIUjGz3c3tU1eSiIg0oMQgIiINKDGIiEgDST/G0JRQKERZWRk1NTWJDqVd5OXlUVRURHa2JsYUkY4X18RgZjOJzu2SCfzS3X/YaP9PgenBZlegMJh5slXKysro0aMHw4cPx8zO/IZOzN05ePAgZWVljBgxItHhiEgaiFtiCGZ4fJjoKlplwAozW+zum07VcfevxtT/MnBBWz6rpqYmJZICgJmRn59PZWVlokMRkTQRzzGGacB2d9/p7nXAQqLLFzZnLtH57NskFZLCKanUFhHp/OLZlTSYhlMLl9HMtMXB3PIjgP9pZv98YD7A0KFD2zdKEZFAOOLURyLUh536iFMfjgRlHpR9sB0OHrGvwxEn7E4kZl/Eo68/eCa6P9j22HI/VS/62j2mPOJceW5/Jg3p3e7t7qyDzzcBz7p7uKmd7r4AWABQXFysecNFUkQ44tSEwlSHwlTXhakJhakJRaipD1MbilATClNbH6G2Pvp8arsuKIs+R7fr6iPUhSOEwtHXobC/vx0KRwjVO6HIB6/rI9F6p/7ohyIROvuqBIU985I+MZQTs1wh0aUKy5upexNwZ4dH1Ak89thjfP/73wfgn/7pn7jlllsSHJFIy9WEwhyrqedoTYjjNfUcrw0eMa9P1tVzojbMidp6TtaFOV5bT3VdmJOh6PbJ2iARhKJ/2NsqM8PIycwgNzuDnMwMcrI+eM4OnrMyjO65WeRkRsuyszLIzjCyMzPIygyeM4yszAyyM42sjGh5VoaRGVMvup3xfvn7z5lGhkXflxmUZWZAhlnMtpFpRkbwnJlhmPF+udkHdSyDaF0zMoLjRB8d28Ucz8SwAhhjZiOIJoSbgM81rmRm44A+RNfvTWlVVVXcf//9lJSUYGZMmTKF2bNn06dPn0SHJmnE3TlaU8+hE3UcOlnH4ZMhDp2s49DJEIdP1nGkOsThkyGOVEcfR6tDHK0JcbSmvkV/yDMzjG45mXTPzaJrbhbdcjLpkpNJYY88uuRk0jU7uh19nUWXnAy6ZGeSm51JXnYmeVkZ0efsTPKyo69zszLIzYo+52RlkJuVQVambstqL3FLDO5eb2Z3EV3WMBN4xN03mtkDQIm7Lw6q3gQs9HZaWu7+329k056j7XGo940f1JPvfuK8Zvffd9999O3bl7vvvhuAb3/72xQWFvKVr3ylQb2lS5cyY8YM+vbtC8CMGTN45ZVXmDt3brvGK+nH3TlaXc++YzXsP1pL5fEaKo/VcuB4XfAcfV11opaqE3WEwk3/c8sw6Nklm14xj6I+XejZJZseeVn0zMumZ14WPfKi291zs+iel0WP3Gy65WbSPS/661wXUCSXuI4xuPsSogukx5bd12j7e/GMqSPMmzePG264gbvvvptIJMLChQt5++23P1SvvLycIUM+6F0rKiqivLy53jWRKHfn8MkQ5Yer2XO4mr1HathzuJo9R2rYd6SGfcdq2He0hprQh3/N52ZlUNAjl/zuuQzqlceEwT3p2y2X/G459O2WQ59u2fTumkOfrjn06ZpNz7xsMjL0Rz3ddNbB53Zzul/2HWX48OHk5+ezevVq9u3bxwUXXEB+fn7c45DkVVcfofTQSXYdOMGugycprTpJ2aGTlB2qprTqJCfqGl6XkZOZwYBeeQzolcekot7075lL/5559O+ZR2GPXAqCR/fcLP16lzNK+cSQKLfffjuPPvooFRUVzJs3r8k6gwcP5o9//OP722VlZVx++eXxCVASzt2pPFbL9srj7Nh/nB2VJ9hReZxdB09QfqiaSEzvTtecTIb06cqQvl24eGQ+Q/p2ZXDvPAb17sLAXl3I75ajX/bSbqyduvITpri42Buvx7B582bOPffcBEUUVVdXx4QJEwiFQmzbto3MzMwP1amqqmLKlCmsWrUKgAsvvJCVK1e+P+YQqzO0SdruSHWIrRXH2FJxlC0Vx9hacYx39h3jWE39+3W652YxsqAbw/O7MbxfN4bnd2VYfvS5b7cc/dKXdmVmK929uKl9OmPoIDk5OUyfPp3evXs3mRQA+vbty3e+8x2mTp0KfDBoLclt/7EaNpYfZUP5ETbsOcKG8qOUH65+f3/PvCzGDejJnMmDGF3QndGFPRhd2J3+PXP1x186BSWGDhKJRHjrrbd45plnTltv3rx5zXY1SedXEwqzvvwIq987xOr3DrP6vcNUHP1gVt+R/boxZVgfbv7IMMYO6MG4AT0Y0DNPCUA6NSWGDrBp0yZmzZrF9ddfz5gxYxIdjrSjQyfqWLGrirffreLtXVVs2nOU+mAwYGjfrlw0si8Ti3ozYXAvzh3Ygx55mipdko8SQwcYP348O3fufH97/fr13HzzzQ3q5Obmsnz58niHJq10rCbEmzsO8sb2Ayx/t4otFccAyMnKYPKQ3vzdZSO5YEgfJg/tTb/uuQmOVqR9pGxicPdOc7o+YcIE1qxZ0+b3J/sFAskkHHHWlB7mz9sq+cu2A6wuPUw44nTJzqR4eB9mTRzItBH5TCzqRV5202NHIskuJRNDXl4eBw8eJD8/v9Mkh7Y6tVBPXl5eokNJWcdr63n9nUr+e/M+Xtuyn0MnQ5jBxMG9uOOykVw6uoALh/UmN0uJQNJDSiaGoqIiysrKUmZxm1NLe0r7OXi8llc2VvDKhgre2nmQUNjp1SWb6WMLuPLc/lw6uh99uuUkOkyRhEjJxJCdna1lMOVDqk7UsXRjBS+t28ubOw8Sjjgj+nXj1kuGc9W5/ZkyrI8mYhMhRRODyCk1oTDLNu/n2ZWlvL7tAOGIMzy/K39/2SiumziQcQN6JH13o0h7U2KQlOPurCs7wrMry1i8dg9HqkMM7JXHlz42klkTB3LeoJ5KBiKnocQgKeN4bT3PrS7niTd3s3XfMXKzMph5/gBunFLEJaP6kam5hERaRIlBkt62fcd4/K3dLFpVzvHaes4f3JP/c8MErps4kJ66wUyk1ZQYJCm5O396p5IFr+/krzsOkpOVwayJA7n54mFMHtJbXUUiZ0GJQZJKfTjCi+v28v/+tIMtFccY2CuPb80cx2enDqGvLi8VaRdKDJIUakJhnlpRyoLXd1J+uJoxhd35109PYvakQeRk6RJTkfakxCCdWl19hGdWlvLvy7ZTcbSG4mF9uH/2eVwxrlAL04h0ECUG6ZTCEee51eU8tOwdSququXBob37ymUlcMrpfokMTSXlxTQxmNhN4CMgEfunuP2yizmeA7wEOrHX3z8UzRkksd2fZ5v38n5c3s6PyBOcN6smvbz2fy8cWaEBZJE7ilhjMLBN4GJgBlAErzGyxu2+KqTMGuBf4qLsfMrPCeMUniffOvmP884ub+PO2A4ws6MbPP38hM88foIQgEmfxPGOYBmx3950AZrYQmANsiqnzJeBhdz8E4O774xifJMjhk3X89A/v8MTy9+iWk8l9s8Zz80eGka15i0QSIp6JYTBQGrNdBlzUqM45AGb2BtHupu+5+yuND2Rm84H5AEOHDu2QYKXjRSLOwhWlPPjKFo7VhPj8RcP46oxzdNmpSIJ1tsHnLGAMcDlQBLxuZhPc/XBsJXdfACwAKC4u1io2SWhn5XHuXbSe5e9WcdGIvtw/5zzGDeiZ6LBEhPgmhnJgSMx2UVAWqwxY7u4h4F0ze4doolgRnxClo4XCERa8vpOHlm0jLyuDBz81gc8UD9E4gkgnEs/EsAIYY2YjiCaEm4DGVxw9D8wFfm1m/Yh2Le1EUsL6siN889m1bKk4xrUTBvC9T5xHYU+tTCfS2cQtMbh7vZndBSwlOn7wiLtvNLMHgBJ3Xxzsu9rMNgFh4JvufjBeMUrHCEecBa/v5N9e3Up+9xx+cfMU/ua8AYkOS0SaYcm+0HxxcbGXlJQkOgxpxt4j1Xz1qTW8tbOKaycM4AfXT6B3Vw0uiySama109+Km9nW2wWdJIS+v38s9i9YTCkf40Y0T+fSUIo0liCQBJQZpdzWhMPf/fiO/fbuUSUW9+NlNFzCiX7dEhyUiLaTEIO1qz+Fq/v6JlawtO8Idl43i61efoxvVRJKMEoO0m7d2HuTO36yitj6iAWaRJKbEIGfN3Xn0r7v4/kubGZbflQU3FzO6sHuiwxKRNlJikLNSWx/m3kXrWbSqnKvH9+ffPjOJHlpnWSSpKTFImx2pDnHH4yt5c+dBvjbjHO6aPlqL54ikACUGaZM9h6u57dcr2HngOD/77GQ+ecHgRIckIu1EiUFabfPeo9z26xWcqK3nsdumaVU1kRSjxCCt8sb2A9zx+Eq65Wbx9B0f4dyBmhFVJNUoMUiLvbqxgjufXMXIft15dN5UBvbqkuiQRKQDKDFIi7yyYS93Pbma8wf34rF50+jVRVceiaQqJQY5o5fW7eV/LVzN5CG9efS2qbocVSTFKTHIab2wppyvPb2WC4f25te3TaN7rr4yIqlOk9hIs55bXcZXn1pD8bA+PKqkIJI29C9dmvTiuj187em1fGRkPr+8pZiuOfqqiKQL/WuXD/nLtgN89ak1TB3Wl1/dMpUuOZmJDklE4khdSdLA2tLDzH+8hFEF3fnPW4qVFETSkBKDvG9H5XFue3QF+d1z+C9dkiqStuKaGMxsppltNbPtZnZPE/tvNbNKM1sTPG6PZ3zprOJIDX/7q7fJMPiveRdR2DMv0SGJSILEbYzBzDKBh4EZQBmwwswWu/umRlWfcve74hWXwJGTIf72keUcqQ6xcP7FWoZTJM3F84xhGrDd3Xe6ex2wEJgTx8+XJtSHI/zDkyvZdeAkC/52CucP7pXokEQkweKZGAYDpTHbZUFZY58ys3Vm9qyZDWnqQGY238xKzKyksrKyI2JNG99/aTNvbD/ID26YwCWjNEuqiHS+weffA8PdfSLwB+Cxpiq5+wJ3L3b34oKCgrgGmEoWvv0ej/51F7dfOoIbpxQlOhwR6STimRjKgdgzgKKg7H3uftDda4PNXwJT4hRb2lmxq4rvvLCBj59TwD3XjEt0OCLSicQzMawAxpjZCDPLAW4CFsdWMLOBMZuzgc1xjC9tlB+u5o7HVzKkT1f+fe4FZGV2thNHEUmkuF2V5O71ZnYXsBTIBB5x941m9gBQ4u6Lgf9lZrOBeqAKuDVe8aWLk3X1fOmxEurCEf7zlmLdqyAiHxLXKTHcfQmwpFHZfTGv7wXujWdM6cTduXfRerZUHOVXt05lVEH3RIckIp2Q+hDSyDMry3hhzR7uvuocpo8tTHQ4ItJJKTGkie37j/HdFzZyyah87pw+OtHhiEgnpsSQBmpCYe78zWq65mTys89OJjPDEh2SiHRimnY7DTzw4ia27jvGo7dN1RxIInJGOmNIcS+t28uTy9/j7y4byeUaVxCRFlBiSGGlVSe553frmDykN9+4emyiwxGRJKHEkKLCEefup9aAwb/PvYBs3cQmIi2kMYYU9es33mXl7kP89LOTGNK3a6LDEZEkop+RKejdAyf48dKtXHVufz45uakJbEVEmqfEkGLCEeebz6wlNyuDH1x/Pma6NFVEWkeJIcU89tddlOw+xHc/cZ4uTRWRNlFiSCG7DpzgR0u3cMW4Qm64UF1IItI2SgwpIhJx/vF368jOzOAH109QF5KItJkSQ4p4/K3dvP1uFd+ZNZ4BvdSFJCJtp8SQAiqO1PCjV7bw8XMK+LSW6BSRs6TEkAJ+sGQzoYjz/Tm6CklEzl6rE4OZdTOzzI4IRlrvzR0HWbx2D3dcNoqh+bqRTUTO3hkTg5llmNnnzOwlM9sPbAH2mtkmM/uxmWly/wQJhSN8d/EGivp04R8uH5XocEQkRbTkjOE1YBTRJTcHuPsQdy8ELgXeAh40sy90YIzSjP96czfv7DvOd2aNJy9bJ3Ei0j5akhiucvd/dvd17h45VejuVe7+O3f/FPBUSz7MzGaa2VYz225m95ym3qfMzM2suCXHTUf7j9Xwsz+8w2XnFHD1+P6JDkdEUkhLJtH7cqMBTQcOAH9x93cB3D10poME4xIPAzOAMmCFmS12902N6vUAvgIsb1EL0tQPX95CbX2E780+TwPOItKuWnLG0KPRoydQDLxsZje14rOmAdvdfae71wELgTlN1Ptn4EGgphXHTislu6pYtKqcL318BCP6dUt0OCKSYs54xuDu9zdVbmZ9gf8m+ge+JQYDpTHbZcBFjY55ITDE3V8ys282dyAzmw/MBxg6dGgLPz41hCPOfS9sZFCvPO6crnF/EWl/bb6Pwd2rgHbrwzCzDOAnwNdb8NkL3L3Y3YsLCgraK4Sk8NzqcjbtPcq9155L1xwtpyEi7a/NicHMpgOHWvGWcmBIzHZRUHZKD+B84I9mtgu4GFisAegP1ITC/OTVrUws6sWsiQMTHY6IpKgz/uQ0s/VEB5xj9QX2ALe04rNWAGPMbATRhHAT8LlTO939CNAv5nP/CHzD3Uta8Rkp7Ym3drPnSA3/+ulJGnAWkQ7Tkr6IWY22HTjo7ida80HuXm9mdwFLgUzgEXffaGYPACXuvrg1x0s3R2tC/Mdr2/nYmH5cMrrfmd8gItJGLRl83t1UuZldCsx19ztb+mHuvgRY0qjsvmbqXt7S46aDX/xpB4dPhvjWzHGJDkVEUlyrRi/N7AKi3T+fBt4FFnVEUNLQvqM1/Oov7zJ70iDOH9wr0eGISIpryRjDOcDc4HGA6F3O5u7TOzg2CTy0bBvhiPONq8cmOhQRSQMtOWPYAvwZmOXu2wHM7KsdGpW8b0flcZ5aUcoXLhqq2VNFJC5acrnqDcBe4DUz+08zu5J2vH9BTu/fXt1KXlYGX75yTKJDEZE0ccbE4O7Pu/tNwDiiM63eDRSa2c/N7OoOji+trS87wpL1Fdz+sZH0656b6HBEJE20+AY3dz/h7k+6+yeI3py2GvhWh0Um/Mdr2+iZl8XtHxuR6FBEJI20ZKGeD3UbufuhYFqKK5urI2dna8Uxlm7cx60fHUGPvOxEhyMiaaRFC/WY2ZfNrMFsdWaWY2ZXmNljtO4OaGmBh1/bTrecTG67ZHiiQxGRNNOSq5JmAvOA3wbTWRwG8ojevfwq8DN3X91hEaahnZXHeXHdHr708ZH06ZaT6HBEJM205M7nGuD/Av/XzLKJzmdU7e6HOzi2tPXzP+4gOzOD2y8dmehQRCQNterO52Cltr0dFIsApVUneW51OV+4eBgFPXQlkojEX5un3ZaO8YvXd2AGf3eZzhZEJDGUGDqRfUdreHpFGTdOGcLAXl0SHY6IpKlWJwYz62ZmmR0RTLpb8PpOwu78/WWjEh2KiKSxltzHkGFmnzOzl8xsP9G5k/aa2SYz+7GZaeHhdnDweC2/Wb6bOZMHaU4kEUmoFt3HAIwC7gUGuPsQdy8ELgXeAh40sy90YIxp4bE3d1MTivAPlyvPikhiteSqpKvcPWRmw909cqrQ3auA3wG/Cy5jlTaqCYX5zVu7uXJcIaMLuyc6HBFJcy2ZRC8UvPzQojxmdnGjOtIGi9fu4eCJOuZdqjmRRCTxWjLG8Bkz+yHQw8zONbPY9yzouNDSg7vzyF/eZdyAHlwyKj/R4YiItGiM4Q1gE9AH+Amw3cxWmdmLQHVHBpcO3tx5kC0Vx5j30RFoLkIR6QxaMiVGOfBfZrbD3d8AMLN8YDjRK5RazMxmAg8RnWfpl+7+w0b77wDuBMLAcWC+u29qzWckm0f+sou+3XKYPXlQokMREQFaMe32qaQQvD7o7ivd/URsnTMcJxN4GLgGGA/MNbPxjao96e4T3H0y8COiZygpa9eBEyzbso8vXDSUvGzdGiIinUM8p92eBmx3953uXgcsBObEVnD3ozGb3QBvwXGT1qN/3UVWhvGFi4clOhQRkfe1ddrtLkSTSmum3R4MlMZslwEXNa5kZncCXwNygCuaOpCZzQfmAwwdOrSpKp3ekeoQT5eU8omJgyjsmZfocERE3tfppt1294eBh83sc8A/0cTZiLsvILgiqri4OCnPKp4pKeVkXViXqIpIp9PqabfN7O+BLDNbA6xx93da+PZyYEjMdlFQ1pyFwM9bE1+yqA9H+PUbu5g2oi/nD+6V6HBERBpo9SR67n4f0SuLjgDXm9l/tvCtK4AxZjbCzHKAm4DFsRXMbEzM5nXAttbGlwz+e/M+yg9XM++jOlsQkc6nxWcMZvYH4Bvuvtbd9wFLg0eLuHu9md0VvCcTeMTdN5rZA0CJuy8G7jKzq4AQcIgUXUv6ibfeY3DvLswY3z/RoYiIfEhrupK+BfzMzHYB/9vdW72Sm7svAZY0Krsv5vVXWnvMZLP74An+sv0AX59xDpkZuqFNRDqfFnclufsqd58OvAi8YmbfNTOtJtNKC1eUkplhfLp4yJkri4gkQKvGGIIb2bYSHRT+MrDNzG7uiMBSUV19hGdKSrliXCEDeukSVRHpnFqcGMzsDaJXEf2U6D0JtwKXA9PMTJPptcCyzfs4cLyOudN0tiAinVdrxhjmA5vcvfF9A182s83tGFPKevLt9xjYK4/LzilMdCgiIs1qzRjDxiaSwinXtVM8Kau06iR/3naAz04dokFnEenUWn0fQ1PcfWd7HCeVLVzxHhkGn9Ggs4h0cu2SGOT0QuEIT5eUMX1sIYN660IuEenclBjiYNnm/VQeq2XutOSc8E9E0osSQxz89u33GNAzj8vHFiQ6FBGRM1Ji6GClVSd5fVsln5k6hKxM/ecWkc5Pf6k62NMl0SUoPjtVg84ikhyUGDpQJOIsWlXOx8YUMFiDziKSJJQYOtDyd6soP1zNpy4cnOhQRERaTImhAy1aVUb33CyuHj8g0aGIiLSYEkMHqa4L8/KGCq45fwBdcjITHY6ISIspMXSQVzdVcLy2nhsuLEp0KCIiraLE0EGeW13O4N5duGhE30SHIiLSKkoMHWD/sRpef6eST14wiAxNmCciSUaJoQMsXrOHiMP1F6gbSUSST1wTg5nNNLOtZrbdzO5pYv/XzGyTma0zs2VmNiye8bWXRavKmVTUi9GF3RMdiohIq8UtMZhZJvAwcA0wHphrZuMbVVsNFLv7ROBZ4Efxiq+9bKk4yqa9R7n+At27ICLJKZ5nDNOA7e6+093rgIXAnNgK7v6au58MNt8Ckq4v5rlV5WRlGJ+YNCjRoYiItEk8E8NgoDRmuywoa84XgZeb2mFm882sxMxKKisr2zHEsxOOOM+vKefysQXkd89NdDgiIm3SKQefzewLQDHw46b2u/sCdy929+KCgs4zlfVfdxxg39Fa3bsgIkktK46fVQ7ETjFaFJQ1YGZXAd8GLnP32jjF1i4WrSqnZ14WV4wrTHQoIiJtFs8zhhXAGDMbYWY5wE3A4tgKZnYB8Atgtrvvj2NsZ626LszSjRVcO2EgedmaAkNEklfcEoO71wN3AUuBzcDT7r7RzB4ws9lBtR8D3YFnzGyNmS1u5nCdzmtb93OyLsxsDTqLSJKLZ1cS7r4EWNKo7L6Y11fFM5729OK6PfTrnstFI/MTHYqIyFnplIPPyeZ4bT3LNu/n2gkDyNQUGCKS5JQY2sGyzfuorY/o3gURSQlKDO3g92v3MKBnHlOG9kl0KCIiZ02J4SwdqQ7xp3cquW7iQM2kKiIpQYnhLL26sYJQ2NWNJCIpQ4nhLP1+3V6G9O3CpKJeiQ5FRKRdKDGchaoTdbyx/QDXTRiEmbqRRCQ1KDGchVc2VBCOOJ+YNDDRoYiItBslhrPw+7V7GNmvG+MH9kx0KCIi7UaJoY32H6th+bsHmTVxoLqRRCSlKDG00cvrK4g4uhpJRFKOEkMb/X7tHsb278GY/j0SHYqISLtSYmiDvUeqKdl9iFkTNegsIqlHiaENXtlQAcC1SgwikoKUGNpgyfq9jBvQg1EF3RMdiohIu1NiaKV9R2so2X2Ia87X2YKIpCYlhlZ6ZUMF7nDdxAGJDkVEpEMoMbTSkvV7GVPYndGFuhpJRFKTEkMr7D9Ww9u7qrh2grqRRCR1xTUxmNlMM9tqZtvN7J4m9n/czFaZWb2Z3RjP2Fpi6cZ9uKPEICIpLW6JwcwygYeBa4DxwFwzG9+o2nvArcCT8YqrNZas28uogm6c019XI4lI6ornGcM0YLu773T3OmAhMCe2grvvcvd1QCSOcbXIgeO1LH/3INdO0NxIIpLa4pkYBgOlMdtlQVlSWLoxOjeSupFEJNUl5eCzmc03sxIzK6msrIzLZ768voKR/boxboCuRhKR1BbPxFAODInZLgrKWs3dF7h7sbsXFxQUtEtwp1N1oo43dx7kmgkD1I0kIikvnolhBTDGzEaYWQ5wE7A4jp/fZq9ujK7Upm4kEUkHcUsM7l4P3AUsBTYDT7v7RjN7wMxmA5jZVDMrAz4N/MLMNsYrvtN5af1ehuV31UptIpIWsuL5Ye6+BFjSqOy+mNcriHYxdRqHTtTx5o6DfOnjI9WNJCJpISkHn+Pp5Q0V1Eec69SNJCJpQonhDJ5fU87owu6cN0jdSCKSHpQYTmPP4WrefreKOZMGqRtJRNKGEsNp/H7tHgBmTx6U4EhEROJHieE0Xlizh8lDejMsv1uiQxERiRslhmZs23eMTXuPMkdnCyKSZpQYmvHCmj1kGFw3UVcjiUh6UWJogrvzwtpyPjq6H4U98hIdjohIXCkxNGF16WFKq6qZMzlpJn8VEWk3SgxNWLxmDzlZGfzNef0THYqISNwpMTRSH47w4ro9XHVuIT3yshMdjohI3CkxNPLGjoMcOF7H7EnqRhKR9KTE0MgLa8rpkZfF5WM7fp0HEZHOSIkhRk0ozNINFVxz/gDysjMTHY6ISEIoMcR4pqSUE3VhXY0kImlNiSFQeayWHy3dyiWj8rlkVH6iwxERSRglhsC/vLSJ2lCEf/7k+ZpJVUTSmhID8Mb2Azy/Zg93XDaSUQXdEx2OiEhCpX1iqK0P853nNzC0b1f+YfroRIcjIpJwcV3zuTP6xZ92svPACR69baquRBIRIc5nDGY208y2mtl2M7unif25ZvZUsH+5mQ3vyHh2HTjBf7y2nesmDuTysYUd+VEiIkkjbonBzDKBh4FrgPHAXDMb36jaF4FD7j4a+CnwYEfF4+5854UN5GRmcN+sxmGIiKSveJ4xTAO2u/tOd68DFgJzGtWZAzwWvH4WuNI66BKhl9bv5c/bDvD1q8+hf09NrS0icko8E8NgoDRmuywoa7KOu9cDR4AP3VRgZvPNrMTMSiorK9sUTPfcLGaM78/NFw9r0/tFRFJVUg4+u/sCYAFAcXGxt+UYl48t1LiCiEgT4nnGUA4MidkuCsqarGNmWUAv4GBcohMRESC+iWEFMMbMRphZDnATsLhRncXALcHrG4H/cfc2nRGIiEjbxK0ryd3rzewuYCmQCTzi7hvN7AGgxN0XA78CHjez7UAV0eQhIiJxFNcxBndfAixpVHZfzOsa4NPxjElERBpK+ykxRESkISUGERFpQIlBREQaUGIQEZEGLNmvBjWzSmB3G9/eDzjQjuEkktrS+aRKO0Bt6azOpi3D3L2gqR1JnxjOhpmVuHtxouNoD2pL55Mq7QC1pbPqqLaoK0lERBpQYhARkQbSPTEsSHQA7Uht6XxSpR2gtnRWHdKWtB5jEBGRD0v3MwYREWlEiUFERBpI28RgZjPNbKuZbTezexIdT2uY2SNmtt/MNsSU9TWzP5jZtuC5TyJjbAkzG2Jmr5nZJjPbaGZfCcqTsS15Zva2ma0N2nJ/UD7CzJYH37OnginnOz0zyzSz1Wb2YrCdrO3YZWbrzWyNmZUEZUn3/QIws95m9qyZbTGzzWb2kY5qS1omBjPLBB4GrgHGA3PNbHxio2qVR4GZjcruAZa5+xhgWbDd2dUDX3f38cDFwJ3B/4dkbEstcIW7TwImAzPN7GLgQeCn7j4aOAR8MXEhtspXgM0x28naDoDp7j455nr/ZPx+ATwEvOLu44BJRP//dExb3D3tHsBHgKUx2/cC9yY6rla2YTiwIWZ7KzAweD0Q2JroGNvQpheAGcneFqArsAq4iOhdqVlBeYPvXWd9EF1dcRlwBfAiYMnYjiDWXUC/RmVJ9/0iuprluwQXDHV0W9LyjAEYDJTGbJcFZcmsv7vvDV5XAP0TGUxrmdlw4AJgOUnalqD7ZQ2wH/gDsAM47O71QZVk+Z79DPhHIBJs55Oc7QBw4FUzW2lm84OyZPx+jQAqgV8HXXy/NLNudFBb0jUxpDSP/nxImuuQzaw78Dvgbnc/Grsvmdri7mF3n0z0F/c0YFxiI2o9M5sF7Hf3lYmOpZ1c6u4XEu02vtPMPh67M4m+X1nAhcDP3f0C4ASNuo3asy3pmhjKgSEx20VBWTLbZ2YDAYLn/QmOp0XMLJtoUviNuy8KipOyLae4+2HgNaJdLr3N7NRKicnwPfsoMNvMdgELiXYnPUTytQMAdy8PnvcDzxFN2Mn4/SoDytx9ebD9LNFE0SFtSdfEsAIYE1xpkUN0benFCY7pbC0Gbgle30K0v75TMzMjus73Znf/ScyuZGxLgZn1Dl53ITpWsplogrgxqNbp2+Lu97p7kbsPJ/rv4n/c/fMkWTsAzKybmfU49Rq4GthAEn6/3L0CKDWzsUHRlcAmOqotiR5USeBgzrXAO0T7gb+d6HhaGftvgb1AiOgviS8S7QdeBmwD/hvom+g4W9COS4me+q4D1gSPa5O0LROB1UFbNgD3BeUjgbeB7cAzQG6iY21Fmy4HXkzWdgQxrw0eG0/9O0/G71cQ92SgJPiOPQ/06ai2aEoMERFpIF27kkREpBlKDCIi0oASg4iINKDEICIiDSgxiIhIA0oMIiLSgBKDiIg0oMQg0kZmVmRmn21mXxcz+1MwxXtT+3PM7PWYaSZEOg0lBpG2u5LofDVNmQcscvdwUzvdvY7oHatNJhaRRFJiEGkDM7sU+AlwY7A62MhGVT5PMG9NMGfPS8HqbhtizjKeD+qJdCo6jRVpA3f/i5mtAL7h7hti9wUTM450911B0Uxgj7tfF+zvFZRvAKbGKWSRFtMZg0jbjQW2NFHeDzgcs70emGFmD5rZx9z9CETXbwDqTs0AKtJZKDGItIGZ9QOO+AermsWqBvJObbj7O0THItYD3zez+2Lq5gI1HRmrSGupK0mkbYYDe5ra4e6HgmU+89y9xswGAVXu/oSZHQZuBzCzfOCAu4fiFbRIS+iMQaRttgD9gsHkS5rY/yrR9SYAJgBvB+tBfxf4flA+HXipowMVaS2txyDSAczsQuCr7n7zaeosAu4JuppEOg2dMYh0AHdfBbx2uhvcgOeVFKQz0hmDiIg0oDMGERFpQIlBREQaUGIQEZEGlBhERKQBJQYREWlAiUFERBr4/9Iby3HKlUbPAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Run simulation using default model parameters and solver options\n",
+    "model.setTimepoints(np.linspace(0, 60, 60)) \n",
+    "rdata = amici.runAmiciSimulation(model, solver)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Simulation options can be specified either in the [Model](https://amici.readthedocs.io/en/latest/generated/amici.amici.Model.html) or in an [ExpData](https://amici.readthedocs.io/en/latest/generated/amici.amici.ExpData.html) instance. The `ExpData` instance can also carry experimental data. To initialize an `ExpData` instance from simulation results, amici offers some [convenient constructors](https://amici.readthedocs.io/en/latest/generated/amici.amici.ExpData.html#amici.amici.ExpData). In the following we will initialize an `ExpData` object from simulation results, but add noise with standard deviation `0.1` and specify the standard deviation accordingly. Moreover, we will specify custom values for `DRUG_0=0` and `KIN_0=2`. If `fixedParameter` is specified in an `ExpData` instance, [runAmiciSimulation](https://amici.readthedocs.io/en/latest/generated/amici.html#amici.runAmiciSimulation) will use those parameters instead of the ones specified in the `Model` instance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "edata = amici.ExpData(rdata, 0.1, 0.0)\n",
+    "edata.fixedParameters = [0,2]\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For many biological systems, it is reasonable to assume that they start in a\n",
+    " steady state. In this example we want to specify an experiment where a pretreatment with a drug is performed _before_ the kinase is added. We assume that the pretreatment is sufficiently long such that the system reaches steadystate before the kinase is added. To implement this in amici, we can specify `fixedParametersPreequilibration` in the `ExpData` object. This automatically adds a preequilibration phase where the model is run to steadystate, before regular simulation starts. Here we set `DRUG_0=3` and `KIN_0=0` for the preequilibration. This means that there is no kinase available in the preequilibration phase. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "edata.fixedParametersPreequilibration = [3,0]\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The resulting trajectory is definitely not what one may expect. The problem is that the `DRUG_0` and `KIN_0` set initial conditions for species in the model. By default these initial conditions are only applied at the very beginning of the simulation, i.e., before the preequilibration. Accordingly, the `fixedParameters` that we specified do not have any effect. To fix this, we need to set the `reinitializeFixedParameterInitialStates` attribue to `True`, to spefify that AMICI reinitializes all states that have `fixedParameter`-dependent initial states."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "edata.reinitializeFixedParameterInitialStates = True"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "With this option activated, the kinase concentration will be reinitialized after the preequilibration and we will see the expected change in fractional phosphorylation:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "On top of preequilibration, we can also specify presimulation. This option can be used to specify pretreatments where the system is not assumed to reach steadystate. Presimulation can be activated by specifying `t_presim` and `edata.fixedParametersPresimulation`. If both `fixedParametersPresimulation` and `fixedParametersPreequilibration` are specified, preequilibration will be performed first, followed by presimulation, followed by regular simulation. For this example we specify `DRUG_0=10` and `KIN_0=0` for the presimulation and `DRUG_0=10` and `KIN_0=2` for the regular simulation. We do not overwrite the `DRUG_0=3` and `KIN_0=0` that was previously specified for preequilibration."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(3.0, 0.0)\n",
+      "(10.0, 0.0)\n",
+      "(10.0, 2.0)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "edata.t_presim = 10\n",
+    "edata.fixedParametersPresimulation = [10.0, 0.0]\n",
+    "edata.fixedParameters = [10.0, 2.0]\n",
+    "print(edata.fixedParametersPreequilibration)\n",
+    "print(edata.fixedParametersPresimulation)\n",
+    "print(edata.fixedParameters)\n",
+    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
+    "amici.plotting.plotObservableTrajectories(rdata)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python3",
+   "language": "python",
+   "name": "python"
+  },
+  "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.2"
+  },
+  "pycharm": {
+   "stem_cell": {
+    "cell_type": "raw",
+    "metadata": {
+     "collapsed": false
+    },
+    "source": []
+   }
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 1
+}
diff --git a/python/examples/example_presimulation/model_presimulation.ipynb b/python/examples/example_presimulation/model_presimulation.ipynb
deleted file mode 100644
index 882bbaaec1..0000000000
--- a/python/examples/example_presimulation/model_presimulation.ipynb
+++ /dev/null
@@ -1,416 +0,0 @@
-{
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# AMICI Python example \"presimulation\"\n",
-    "In this example we will explore some more options for the initialization of experimental conditions, including how to reset initial conditions based on changing values for fixedParameters as well as an additional presimulation phase on top of preequilibration"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# SBML model we want to import\n",
-    "sbml_file = 'model_presimulation.xml'\n",
-    "# Name of the model that will also be the name of the python module\n",
-    "model_name = 'model_presimulation'\n",
-    "# Directory to which the generated model code is written\n",
-    "model_output_dir = model_name\n",
-    "\n",
-    "import libsbml\n",
-    "import amici\n",
-    "import amici.plotting\n",
-    "import os\n",
-    "import sys\n",
-    "import importlib\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Model Loading\n",
-    "Here we load a simple model of protein phosphorylation that can be inhibited by a drug. This model was created using PySB (see `createModel.py`)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Species:  [('__s0', \"PROT(kin=None, drug=None, phospho='u')\"), ('__s1', 'DRUG(bound=None)'), ('__s2', 'KIN(bound=None)'), ('__s3', \"DRUG(bound=1) ._br_PROT(kin=None, drug=1, phospho='u')\"), ('__s4', \"KIN(bound=1) ._br_PROT(kin=1, drug=None, phospho='u')\"), ('__s5', \"PROT(kin=None, drug=None, phospho='p')\")]\n",
-      "\n",
-      "Reactions:\n",
-      "PROT_DRUG_bind:  __s0 +  __s1 <->      __s3\t\t[__s0 * __s1 * kon_prot_drug - __s3 * koff_prot_drug]\n",
-      "PROT_KIN_bind:  __s0 +  __s2  ->      __s4\t\t[__s0 * __s2 * kon_prot_kin]\n",
-      "PROT_KIN_phospho:       __s4  -> __s2 +  __s5\t\t[__s4 * kphospho_prot_kin]\n",
-      "PROT_dephospho:       __s5  ->      __s0\t\t[__s5 * kdephospho_prot]\n",
-      "Parameters:  [('initProt', 'initProt'), ('initDrug', 'initDrug'), ('initKin', 'initKin'), ('pPROT_obs', 'pPROT_obs'), ('PROT_0', 'PROT_0'), ('DRUG_0', 'DRUG_0'), ('KIN_0', 'KIN_0'), ('kon_prot_drug', 'kon_prot_drug'), ('koff_prot_drug', 'koff_prot_drug'), ('kon_prot_kin', 'kon_prot_kin'), ('kphospho_prot_kin', 'kphospho_prot_kin'), ('kdephospho_prot', 'kdephospho_prot'), ('__obs0', 'pPROT'), ('__obs1', 'tPROT')]\n"
-     ]
-    }
-   ],
-   "source": [
-    "sbml_reader = libsbml.SBMLReader()\n",
-    "sbml_doc = sbml_reader.readSBML(sbml_file)\n",
-    "sbml_model = sbml_doc.getModel()\n",
-    "dir(sbml_doc)\n",
-    "\n",
-    "print('Species: ', [(s.getId(),s.getName()) for s in sbml_model.getListOfSpecies()])\n",
-    "\n",
-    "print('\\nReactions:')\n",
-    "for reaction in sbml_model.getListOfReactions():\n",
-    "    reactants = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfReactants()])\n",
-    "    products  = ' + '.join(['%s %s'%(int(r.getStoichiometry()) if r.getStoichiometry() > 1 else '', r.getSpecies()) for r in reaction.getListOfProducts()])\n",
-    "    reversible = '<' if reaction.getReversible() else ''\n",
-    "    print('%3s: %10s %1s->%10s\\t\\t[%s]' % (reaction.getName(), \n",
-    "                        reactants,\n",
-    "                        reversible,\n",
-    "                         products,\n",
-    "                        libsbml.formulaToL3String(reaction.getKineticLaw().getMath())))\n",
-    "    \n",
-    "print('Parameters: ', [(p.getId(),p.getName()) for p in sbml_model.getListOfParameters()])"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {
-    "scrolled": false
-   },
-   "outputs": [],
-   "source": [
-    "# Create an SbmlImporter instance for our SBML model\n",
-    "sbml_importer = amici.SbmlImporter(sbml_file)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For this example we want specify the initial drug and kinase concentrations as experimental conditions. Accordingly we specify them as fixedParameters."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "fixedParameters = ['DRUG_0','KIN_0']"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The SBML model specifies a single observable named `pPROT` which describes the fraction of phosphorylated Protein. We load this observable using `amici.assignmentRules2observables`."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Observables: {'__obs0': {'name': 'pPROT', 'formula': '__s5'}}\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Retrieve model output names and formulae from AssignmentRules and remove the respective rules\n",
-    "observables = amici.assignmentRules2observables(\n",
-    "        sbml_importer.sbml, # the libsbml model object\n",
-    "        filter_function=lambda variable: variable.getName() == 'pPROT' \n",
-    "    )\n",
-    "print('Observables:', observables)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now the model is ready for compilation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "sbml_importer.sbml2amici(model_name, \n",
-    "                         model_output_dir, \n",
-    "                         verbose=False,\n",
-    "                         observables=observables,\n",
-    "                         constant_parameters=fixedParameters)\n",
-    "sys.path.insert(0, os.path.abspath(model_output_dir))\n",
-    "# load the compiled module\n",
-    "model_module = importlib.import_module(model_name)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "To simulate the model we need to create an instance via the `getModel()` method in the generated model module."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# Create Model instance\n",
-    "model = model_module.getModel()\n",
-    "# set timepoints for which we want to simulate the model\n",
-    "\n",
-    "\n",
-    "# Create solver instance\n",
-    "solver = model.getSolver()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The only thing we need to simulate the model is a timepoint vector, which can be specified using the `setTimepoints()` method. If we do not specify any additional options, the default values for fixedParameters and Parameters that were specified in the SBML file will be used."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# Run simulation using default model parameters and solver options\n",
-    "model.setTimepoints(np.linspace(0, 60, 60)) \n",
-    "rdata = amici.runAmiciSimulation(model, solver)\n",
-    "amici.plotting.plotObservableTrajectories(rdata)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Simulation options can be specified either in the Model or in an ExpData object. The ExpData object can also carry experimental data. To initialize an ExpData object from simulation routines, amici offers some convenient constructors. In the following we will initialize an ExpData object from simulation results, but add noise with standard deviation `0.1` and specify the standard deviation accordingly. Moreover, we will specify custom values for `DRUG_0=0` and `KIN_0=2`. If fixedParameter is specfied in an ExpData object, runAmiciSimulation will use those parameters instead of the ones specified in the Model object."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "edata = amici.ExpData(rdata, 0.1, 0.0)\n",
-    "edata.fixedParameters = [0,2]\n",
-    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
-    "amici.plotting.plotObservableTrajectories(rdata)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "For many biological systems, it is reasonable to assume that they start in a\n",
-    " steady state. In this example we want to specify an experiment where a pretreatment with a drug is performed _before_ the kinase is added. We assume that the pretreatment is sufficiently long such that the system reaches steadystate before the kinase is added. To implement this in amici, we can specify `fixedParametersPreequilibration` in the ExpData object. Here we set `DRUG_0=3` and `KIN_0=0` for the preequilibration."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "edata.fixedParametersPreequilibration = [3,0]\n",
-    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
-    "amici.plotting.plotObservableTrajectories(rdata)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "The resulting trajectory is definitely not what one may expect. The problem is that the `DRUG_0` and `KIN_0` set initial condtions for species in the model. By default these initial conditions are only applied at the very beginning of the simulation, i.e., before the preequilibration. Accordingly, the fixedParameters that we specified do not have any effect. To fix this, we need to activate reinitialization of states that depend on fixedParameters via `ExpData.reinitializeFixedParameterInitialStates`"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "edata.reinitializeFixedParameterInitialStates = True"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "With this option activated, the kinase concentration will be reinitialized after the preequilibration and we will see the expected change in fractional phosphorylation:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {
-    "scrolled": true
-   },
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
-    "amici.plotting.plotObservableTrajectories(rdata)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "On top of preequilibration, we can also specify presimulation. This option can be used to specify pretreatments where the system is not assumed to reach steadystate. Presimulation can be activated by specifying `t_presim` and `edata.fixedParametersPresimulation`. If both `fixedParametersPresimulation` and `fixedParametersPreequilibration` are specified, preequilibration will be performed first, followed by presimulation, followed by regular simulation. For this example we specify `DRUG_0=10` and `KIN_0=0` for the presimulation and `DRUG_0=10` and `KIN_0=2` for the regular simulation. We do not overwrite the `DRUG_0=3` and `KIN_0=0` that was previously specified for preequilibration."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(3.0, 0.0)\n",
-      "(10.0, 0.0)\n",
-      "(10.0, 2.0)\n"
-     ]
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "edata.t_presim = 10\n",
-    "edata.fixedParametersPresimulation = [10.0,0.0]\n",
-    "edata.fixedParameters = [10.0,2.0]\n",
-    "print(edata.fixedParametersPreequilibration)\n",
-    "print(edata.fixedParametersPresimulation)\n",
-    "print(edata.fixedParameters)\n",
-    "rdata = amici.runAmiciSimulation(model, solver, edata)\n",
-    "amici.plotting.plotObservableTrajectories(rdata)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": []
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.7.7"
-  },
-  "pycharm": {
-   "stem_cell": {
-    "cell_type": "raw",
-    "source": [],
-    "metadata": {
-     "collapsed": false
-    }
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 1
-}
\ No newline at end of file