CellTypes_modelling.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "cA5iWM72QqJ7"
      },
      "source": [
        "# Optimising the parameters of a simple neuron model\n",
        "\n",
        "____________\n",
        "## Introduction\n",
        "\n",
        "Building biologically-realistic models of neurons requires knowing values for many different parameters. When those are not known or hard to measure experimentally, we can use an optimisation library such as [BluePyOpt](https://github.com/BlueBrain/BluePyOpt) to constrain them with experimental data.\n",
        "\n",
        "\n",
        "### Overview:\n",
        "In this tutorial you will learn how to:\n",
        "\n",
        "* Create a **cell model**\n",
        "* Extract **electrical features** using eFEL and set up a **cell evaluator**\n",
        "* Run a **parameter optimization**\n",
        "* **Analyse** the results of an optimisation\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zI-wEMQcQqKA"
      },
      "source": [
        "## Load and visualise some electrophysiological data\n",
        "\n",
        "To model the electrical behaviour of neurons we can use electrophysiological data, recorded during a in vitro [patch clamp experiment](https://en.wikipedia.org/wiki/Patch_clamp). In these types of experiments we inject a current in the neuron and record the voltage response of its membrane.\n",
        "\n",
        "We are now going to visualise the response of a neuron to a depolarising (positive) current injection and to a hyperpolarising (negative) current."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "EyJuHCknQqKB",
        "outputId": "fd25e822-270e-4764-ab27-5677121eb928"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Download some experimental data and save to file\n",
        "import numpy\n",
        "from urllib.request import urlopen\n",
        "import matplotlib.pyplot as plt\n",
        "%matplotlib inline\n",
        "\n",
        "fig, ax = plt.subplots(2, sharey = True)\n",
        "\n",
        "for i, filename in enumerate({'dep_trace.txt', 'hyp_trace.txt'}):\n",
        "    response = urlopen('https://bbpteam.epfl.ch/public/mooc-hbp/{}'.format(filename))\n",
        "    data = response.read()\n",
        "    with open(filename, \"wb\") as f:\n",
        "        f.write(data)\n",
        "        \n",
        "    trace = numpy.loadtxt(filename)    \n",
        "    ax[i].plot(trace[:,0], trace[:,1], color = 'k')\n",
        "    ax[i].set_ylabel('Voltage (mV)')\n",
        "    ax[i].set_xlabel('Time (ms)')"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WVMimIrUQqKE"
      },
      "source": [
        "We can also create two variables pointing to the experimental recordings for later use. As you can see, each trace is a 2D-array, with the first column representing the time points and the second column the voltage."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9-KE6bcOQqKF",
        "outputId": "dc014045-c918-415c-e5de-a59e023e1f6e"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[ 0.00000000e+00 -6.50644052e+01]\n",
            " [ 3.65780296e-02 -6.45500889e+01]\n",
            " [ 7.31560593e-02 -6.58116431e+01]\n",
            " ...\n",
            " [ 6.62454270e+02 -6.80285806e+01]\n",
            " [ 6.85217951e+02 -6.77730746e+01]\n",
            " [ 7.00000000e+02 -6.74465859e+01]]\n"
          ]
        }
      ],
      "source": [
        "exp_pos_trace = numpy.loadtxt(\"dep_trace.txt\")\n",
        "exp_neg_trace = numpy.loadtxt(\"hyp_trace.txt\")\n",
        "print(exp_pos_trace)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iG5xw4N7QqKF"
      },
      "source": [
        "## Define the cell model\n",
        "\n",
        "In this first part, we will define the model **template**. It consists of:\n",
        "* The neuron **morphology** (the shape of the cell). It can be farly complicated, but in this example we are approximating it with a single compartment representing the soma of the cell.\n",
        "* The **ion channel** models (or mechanisms): they contain the equations describing the electrical properties of the cell. \n",
        "* The **model parameters**.\n",
        "\n",
        "BluePyOpt contains a module to create biophysically-detailed neuron models. Let's import it."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install bluepyopt"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZXsIx7ysQ5Lg",
        "outputId": "565d5658-ad64-42ea-ed6d-2eb5c13e494b"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting bluepyopt\n",
            "  Downloading bluepyopt-1.13.12-py3-none-any.whl (133 kB)\n",
            "\u001b[K     |████████████████████████████████| 133 kB 5.0 MB/s \n",
            "\u001b[?25hCollecting ipyparallel\n",
            "  Downloading ipyparallel-8.4.1-py3-none-any.whl (298 kB)\n",
            "\u001b[K     |████████████████████████████████| 298 kB 36.9 MB/s \n",
            "\u001b[?25hRequirement already satisfied: pickleshare>=0.7.3 in /usr/local/lib/python3.8/dist-packages (from bluepyopt) (0.7.5)\n",
            "Requirement already satisfied: pandas>=0.18 in /usr/local/lib/python3.8/dist-packages (from bluepyopt) (1.3.5)\n",
            "Collecting efel>=2.13\n",
            "  Downloading efel-4.1.47-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (4.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 4.3 MB 62.4 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.6 in /usr/local/lib/python3.8/dist-packages (from bluepyopt) (1.21.6)\n",
            "Requirement already satisfied: Jinja2>=2.8 in /usr/local/lib/python3.8/dist-packages (from bluepyopt) (2.11.3)\n",
            "Requirement already satisfied: future in /usr/local/lib/python3.8/dist-packages (from bluepyopt) (0.16.0)\n",
            "Collecting deap>=1.3.3\n",
            "  Downloading deap-1.3.3-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl (139 kB)\n",
            "\u001b[K     |████████████████████████████████| 139 kB 58.7 MB/s \n",
            "\u001b[?25hCollecting Pebble>=4.3.10\n",
            "  Downloading Pebble-5.0.3-py3-none-any.whl (30 kB)\n",
            "Requirement already satisfied: six in /usr/local/lib/python3.8/dist-packages (from efel>=2.13->bluepyopt) (1.15.0)\n",
            "Requirement already satisfied: MarkupSafe>=0.23 in /usr/local/lib/python3.8/dist-packages (from Jinja2>=2.8->bluepyopt) (2.0.1)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas>=0.18->bluepyopt) (2022.6)\n",
            "Requirement already satisfied: python-dateutil>=2.7.3 in /usr/local/lib/python3.8/dist-packages (from pandas>=0.18->bluepyopt) (2.8.2)\n",
            "Requirement already satisfied: traitlets>=4.3 in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (5.6.0)\n",
            "Requirement already satisfied: psutil in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (5.4.8)\n",
            "Requirement already satisfied: entrypoints in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (0.4)\n",
            "Requirement already satisfied: tqdm in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (4.64.1)\n",
            "Requirement already satisfied: pyzmq>=18 in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (23.2.1)\n",
            "Requirement already satisfied: tornado>=5.1 in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (6.0.4)\n",
            "Requirement already satisfied: decorator in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (4.4.2)\n",
            "Requirement already satisfied: ipython>=4 in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (7.9.0)\n",
            "Requirement already satisfied: ipykernel>=4.4 in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (5.3.4)\n",
            "Requirement already satisfied: jupyter-client in /usr/local/lib/python3.8/dist-packages (from ipyparallel->bluepyopt) (6.1.12)\n",
            "Collecting jedi>=0.10\n",
            "  Downloading jedi-0.18.2-py2.py3-none-any.whl (1.6 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.6 MB 58.8 MB/s \n",
            "\u001b[?25hRequirement already satisfied: setuptools>=18.5 in /usr/local/lib/python3.8/dist-packages (from ipython>=4->ipyparallel->bluepyopt) (57.4.0)\n",
            "Requirement already satisfied: pygments in /usr/local/lib/python3.8/dist-packages (from ipython>=4->ipyparallel->bluepyopt) (2.6.1)\n",
            "Requirement already satisfied: prompt-toolkit<2.1.0,>=2.0.0 in /usr/local/lib/python3.8/dist-packages (from ipython>=4->ipyparallel->bluepyopt) (2.0.10)\n",
            "Requirement already satisfied: backcall in /usr/local/lib/python3.8/dist-packages (from ipython>=4->ipyparallel->bluepyopt) (0.2.0)\n",
            "Requirement already satisfied: pexpect in /usr/local/lib/python3.8/dist-packages (from ipython>=4->ipyparallel->bluepyopt) (4.8.0)\n",
            "Requirement already satisfied: parso<0.9.0,>=0.8.0 in /usr/local/lib/python3.8/dist-packages (from jedi>=0.10->ipython>=4->ipyparallel->bluepyopt) (0.8.3)\n",
            "Requirement already satisfied: wcwidth in /usr/local/lib/python3.8/dist-packages (from prompt-toolkit<2.1.0,>=2.0.0->ipython>=4->ipyparallel->bluepyopt) (0.2.5)\n",
            "Requirement already satisfied: jupyter-core>=4.6.0 in /usr/local/lib/python3.8/dist-packages (from jupyter-client->ipyparallel->bluepyopt) (5.1.0)\n",
            "Requirement already satisfied: platformdirs>=2.5 in /usr/local/lib/python3.8/dist-packages (from jupyter-core>=4.6.0->jupyter-client->ipyparallel->bluepyopt) (2.5.4)\n",
            "Requirement already satisfied: ptyprocess>=0.5 in /usr/local/lib/python3.8/dist-packages (from pexpect->ipython>=4->ipyparallel->bluepyopt) (0.7.0)\n",
            "Installing collected packages: jedi, Pebble, ipyparallel, efel, deap, bluepyopt\n",
            "Successfully installed Pebble-5.0.3 bluepyopt-1.13.12 deap-1.3.3 efel-4.1.47 ipyparallel-8.4.1 jedi-0.18.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "FW7ZqLhSQqKG"
      },
      "outputs": [],
      "source": [
        "import bluepyopt as bpopt\n",
        "import bluepyopt.ephys as ephys"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USLWMl_sQqKH"
      },
      "source": [
        "### Load a morphology"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0G1ma2fiQqKH"
      },
      "source": [
        "Reconstruction of neuron morphologies can be stored in different file formats ([.swc](http://www.neuronland.org/NLMorphologyConverter/MorphologyFormats/SWC/Spec.html), .asc). We're now going to load a .swc morphology and visualise it by using the Neuronal Morphology Analysis Tool [NeuroM](https://github.com/BlueBrain/NeuroM). In this example the morphology represents a soma with a radius of 5 micron."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install neurom"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LVm6Mb5IRBTp",
        "outputId": "179cba72-e028-4458-a9b1-60fd8d4f6f36"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting neurom\n",
            "  Downloading neurom-3.2.2.tar.gz (489 kB)\n",
            "\u001b[K     |████████████████████████████████| 489 kB 5.2 MB/s \n",
            "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "    Preparing wheel metadata ... \u001b[?25l\u001b[?25hdone\n",
            "Requirement already satisfied: matplotlib>=3.2.1 in /usr/local/lib/python3.8/dist-packages (from neurom) (3.2.2)\n",
            "Collecting morphio>=3.1.1\n",
            "  Downloading MorphIO-3.3.3-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (1.9 MB)\n",
            "\u001b[K     |████████████████████████████████| 1.9 MB 48.7 MB/s \n",
            "\u001b[?25hRequirement already satisfied: pandas>=1.0.5 in /usr/local/lib/python3.8/dist-packages (from neurom) (1.3.5)\n",
            "Requirement already satisfied: numpy>=1.8.0 in /usr/local/lib/python3.8/dist-packages (from neurom) (1.21.6)\n",
            "Requirement already satisfied: tqdm>=4.8.4 in /usr/local/lib/python3.8/dist-packages (from neurom) (4.64.1)\n",
            "Requirement already satisfied: pyyaml>=3.10 in /usr/local/lib/python3.8/dist-packages (from neurom) (6.0)\n",
            "Requirement already satisfied: click>=7.0 in /usr/local/lib/python3.8/dist-packages (from neurom) (7.1.2)\n",
            "Requirement already satisfied: scipy>=1.2.0 in /usr/local/lib/python3.8/dist-packages (from neurom) (1.7.3)\n",
            "Requirement already satisfied: kiwisolver>=1.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.2.1->neurom) (1.4.4)\n",
            "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.2.1->neurom) (3.0.9)\n",
            "Requirement already satisfied: cycler>=0.10 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.2.1->neurom) (0.11.0)\n",
            "Requirement already satisfied: python-dateutil>=2.1 in /usr/local/lib/python3.8/dist-packages (from matplotlib>=3.2.1->neurom) (2.8.2)\n",
            "Requirement already satisfied: pytz>=2017.3 in /usr/local/lib/python3.8/dist-packages (from pandas>=1.0.5->neurom) (2022.6)\n",
            "Requirement already satisfied: six>=1.5 in /usr/local/lib/python3.8/dist-packages (from python-dateutil>=2.1->matplotlib>=3.2.1->neurom) (1.15.0)\n",
            "Building wheels for collected packages: neurom\n",
            "  Building wheel for neurom (PEP 517) ... \u001b[?25l\u001b[?25hdone\n",
            "  Created wheel for neurom: filename=neurom-3.2.2-py3-none-any.whl size=105792 sha256=33676e7f6af8b4c1c60ce3f165bdbb92d1e27c04caf4c192da2256ec906d0623\n",
            "  Stored in directory: /root/.cache/pip/wheels/2a/ab/45/d2198929cfe3f08cfc388dac0e5be76ed66e9d6e7954dc933d\n",
            "Successfully built neurom\n",
            "Installing collected packages: morphio, neurom\n",
            "Successfully installed morphio-3.3.3 neurom-3.2.2\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 355
        },
        "id": "v1LyQlLqQqKI",
        "outputId": "e126d202-85d4-4ef9-9f94-67b95d740ea6"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "<ipython-input-8-17a9d1712b7e>:13: NeuroMDeprecationWarning: `neurom.io.utils.load_neuron` is deprecated in favor of `neurom.io.utils.load_morphology`\n",
            "  fig, ax = neurom.viewer.draw(neurom.load_neuron('simple.swc'))\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "import neurom\n",
        "import neurom.viewer\n",
        "\n",
        "# Get the morpholoy file\n",
        "response = urlopen('https://bbpteam.epfl.ch/public/mooc-hbp/simple.swc')\n",
        "data = response.read()\n",
        "\n",
        "# Save the morphology file   \n",
        "with open(\"simple.swc\", \"wb\") as f:\n",
        "    f.write(data)\n",
        "    \n",
        "# Visualise the morphology\n",
        "fig, ax = neurom.viewer.draw(neurom.load_neuron('simple.swc'))\n",
        "\n",
        "# Load the morphology in BluePyOpt\n",
        "morph = ephys.morphologies.NrnFileMorphology('simple.swc')\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "DFoGltIbQqKJ"
      },
      "source": [
        "### Add ion channels\n",
        "\n",
        "In this example we will use the [**Hodgkin-Huxley** (HH) model](https://en.wikipedia.org/wiki/Hodgkin–Huxley_model) to insert sodium (Na), potassium (K) and leak ionic currents in the cell soma. \n",
        "\n",
        "We will use the built-in HH mechanism of the [NEURON](https://www.neuron.yale.edu/neuron/) simulator. NEURON can be easily extended with other mechanisms (.mod files) by using the [NMODL](https://www.neuron.yale.edu/neuron/static/new_doc/modelspec/programmatic/mechanisms/nmodl.html) language. In this way we can model other types of ion channels, synapses, extracellular mechanisms... \n",
        "\n",
        "To insert a NEURON mechanim into BluePyOpt we need to assign it a **name**, specify the **suffix** pointing to the same field in the .mod file and in which **locations** of the morphology we want to insert it."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "id": "Nw_fxM8jQqKJ"
      },
      "outputs": [],
      "source": [
        "# Create a section object pointing to the soma\n",
        "somatic_loc = ephys.locations.NrnSeclistLocation('somatic', seclist_name='somatic')\n",
        "\n",
        "# Insert the HH mechanism in the soma\n",
        "hh_mech = ephys.mechanisms.NrnMODMechanism(                                         \n",
        "        name='hh',                                                                  \n",
        "        suffix='hh',                                                                \n",
        "        locations=[somatic_loc])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hkU8olbZQqKK"
      },
      "source": [
        "### Specify the parameters\n",
        "We can now specify the parameters of our model. Parameters can be distinguished in two types: **frozen** parameters (i.e. they have an exact value and they are not going to be searched by the optimisation algorithm), **free** parameters (i.e. they have initial bounds for their value and they are going to be searched). \n",
        "\n",
        "In a typical biophysically-detailed model the free parameters can be the **maximal conductances** of the ionic currents ($\\overline{g}_{ion}$). These parameters are part of the HH equations governing the membrane potential of our neuron soma:\n",
        "\n",
        "$$C_{m}\\frac{dV}{dt} = I_{l} + I_{Na} + I_{K} $$\n",
        "\n",
        "$$C_{m}\\frac{dV}{dt} = \\overline{g}_{l}(V-E_{l}) + \\overline{g}_{Na}m^{3}h(V-E_{Na}) + \\overline{g}_{K}n^{4}(V-E_{K}) $$\n",
        "\n",
        "We are now going to set the sodium (*gna_par*) and potassium (*gk_par*) conductance as free parameters and the leak conductance (*gl_par*) and the membrane capacitance (*Cm*) as frozen."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "id": "eJiRFOe3QqKK"
      },
      "outputs": [],
      "source": [
        "# Sodium conductance\n",
        "gna_par = ephys.parameters.NrnSectionParameter(                                    \n",
        "        name='gna_soma',\n",
        "        param_name='gnabar_hh',\n",
        "        locations=[somatic_loc],\n",
        "        bounds=[0, 1], # S/cm^2\n",
        "        frozen=False) \n",
        "\n",
        "# Potassium conductance\n",
        "gk_par = ephys.parameters.NrnSectionParameter(\n",
        "        name='gk_soma',\n",
        "        param_name='gkbar_hh',\n",
        "        bounds=[0, 1], # S/cm^2\n",
        "        locations=[somatic_loc],\n",
        "        frozen=False)\n",
        "\n",
        "# Leak conductance\n",
        "gl_par = ephys.parameters.NrnSectionParameter(\n",
        "        name='gl_soma',\n",
        "        param_name='gl_hh',\n",
        "        value=0.0003, # S/cm^2\n",
        "        locations=[somatic_loc],\n",
        "        frozen=True)\n",
        "\n",
        "# Membrane capacitance\n",
        "cm = ephys.parameters.NrnSectionParameter(\n",
        "        name='cm',\n",
        "        param_name='cm',\n",
        "        value=1.0, # in microfarad/cm2\n",
        "        locations=[somatic_loc],\n",
        "        frozen=True)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Xd7hEUilQqKL"
      },
      "source": [
        "### Create the cell model\n",
        "We can now create the cell model, by combining the morphology, the mechanisms and the parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "id": "lLzE5tz9QqKL"
      },
      "outputs": [],
      "source": [
        "simple_cell = ephys.models.CellModel(\n",
        "        name='simple_cell',\n",
        "        morph=morph,\n",
        "        mechs=[hh_mech],\n",
        "        params=[gna_par, gk_par, gl_par, cm])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "s5JbAk2MQqKL"
      },
      "source": [
        "We can print a descrition of the neuron."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ka7yjkdhQqKL",
        "outputId": "cd8826cf-805f-41f3-ddd7-21544ff83926"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "simple_cell:\n",
            "  morphology:\n",
            "    simple.swc\n",
            "  mechanisms:\n",
            "    hh: hh at ['somatic']\n",
            "  params:\n",
            "    gna_soma: ['somatic'] gnabar_hh = [0, 1]\n",
            "    gk_soma: ['somatic'] gkbar_hh = [0, 1]\n",
            "    gl_soma: ['somatic'] gl_hh = 0.0003\n",
            "    cm: ['somatic'] cm = 1.0\n",
            "\n"
          ]
        }
      ],
      "source": [
        "print(simple_cell)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "G4XrA_IBQqKM"
      },
      "source": [
        "## Set-up a cell evaluator\n",
        "\n",
        "A cell **evaluator** is an object that maps the model parameters into fitness scores, which measure how well our model approximates the experimental data.\n",
        "To define a cell evaluator we need:\n",
        "* current **protocols** to stimulate the cell \n",
        "* a **simulation** to record the voltage **response**\n",
        "* **eFeatures** and **objectives**: they are extracted from the responses and used to score our model, by comparing it with the experimental data.\n",
        "\n",
        "### Define protocols\n",
        "\n",
        "Protocols consist of a sequence of stimuli and the associated responses. \n",
        "\n",
        "We first need to create a location to inject the stimuli, for example the center of the soma."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "aB_tfEwZQqKM"
      },
      "outputs": [],
      "source": [
        "soma_loc = ephys.locations.NrnSeclistCompLocation(\n",
        "        name='soma',\n",
        "        seclist_name='somatic',\n",
        "        sec_index=0,\n",
        "        comp_x=0.5)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LL67y1_uQqKN"
      },
      "source": [
        "Then we can define the stimuli, recordings and combine them in the protocol (a BluePyOpt [SequenceProtocol](https://github.com/BlueBrain/BluePyOpt/blob/master/bluepyopt/ephys/protocols.py#L48) object). We are going to create two stimuli (a negative and a positive current step) and record the responses. For each stimulus we specify the amplitude (in nA), the starting time (step_delay), its duration and the total duration of the simulation in ms. "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "2UIGiJkZQqKN"
      },
      "outputs": [],
      "source": [
        "sweep_protocols = []\n",
        "\n",
        "for protocol_name, amp, dur in [('neg_step', -0.01, 3000), ('pos_step', 0.015, 200)]:\n",
        "    \n",
        "    stim = ephys.stimuli.NrnSquarePulse(\n",
        "                step_amplitude=amp,\n",
        "                step_delay=250,\n",
        "                step_duration=dur,\n",
        "                location=soma_loc,\n",
        "                total_duration=500+dur)\n",
        "    \n",
        "    rec = ephys.recordings.CompRecording(\n",
        "            name='%s.soma.v' % protocol_name,\n",
        "            location=soma_loc,\n",
        "            variable='v')\n",
        "    \n",
        "    protocol = ephys.protocols.SweepProtocol(protocol_name, [stim], [rec])\n",
        "    sweep_protocols.append(protocol)\n",
        "\n",
        "twostep_protocol = ephys.protocols.SequenceProtocol('twostep', protocols=sweep_protocols)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nXsBZuj0QqKN"
      },
      "source": [
        "### Running a simulation, record and plot the responses\n",
        "\n",
        "We can now run a simulation on our cell model. We just need to instantiate the simulator (an abstraction of the NEURON simulator). To run the simulation, we can use the run() function of the protocol we have just created. The run function takes as arguments a cell model, values for the free parameters and a simulator."
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install neuron\n",
        "import neuron"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ZUqfznbYRUO_",
        "outputId": "21ee8e55-be94-490b-bdaa-05960bbcc9c1"
      },
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting neuron\n",
            "  Downloading NEURON-8.2.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl (15.2 MB)\n",
            "\u001b[K     |████████████████████████████████| 15.2 MB 4.8 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy>=1.9.3 in /usr/local/lib/python3.8/dist-packages (from neuron) (1.21.6)\n",
            "Installing collected packages: neuron\n",
            "Successfully installed neuron-8.2.1\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "id": "iifzTBiyQqKN"
      },
      "outputs": [],
      "source": [
        "# Instantiate the simulator\n",
        "nrn = ephys.simulators.NrnSimulator()\n",
        "\n",
        "# Set values for the free parameters (they have to be within bounds)\n",
        "default_params = {'gna_soma': 0.07, 'gk_soma': 0.03}\n",
        "\n",
        "# Run the simulation\n",
        "responses = twostep_protocol.run(cell_model=simple_cell, param_values=default_params, sim=nrn)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "M1m3tQk8QqKO"
      },
      "source": [
        "We can plot the model responses side by side with the experimental recordings."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "OEBnNtIqQqKO",
        "outputId": "a02a62da-fb60-418d-db6d-f09903725935"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def plot_responses(responses):\n",
        "    fig1, ax = plt.subplots(len(responses), 2, sharey = True, sharex = 'row')\n",
        "    \n",
        "    ax[0,0].plot(exp_neg_trace[:, 0], exp_neg_trace[:,1], color = 'k')            \n",
        "    ax[0,1].plot(responses['neg_step.soma.v']['time'], responses['neg_step.soma.v']['voltage'])\n",
        "    ax[0,0].set_title(\"Experiment\")\n",
        "    ax[0,1].set_title(\"Model\")\n",
        "    ax[1,0].plot(exp_pos_trace[:, 0], exp_pos_trace[:,1], color = 'k')            \n",
        "    ax[1,1].plot(responses['pos_step.soma.v']['time'], responses['pos_step.soma.v']['voltage'])\n",
        "\n",
        "    \n",
        "    fig1.tight_layout()\n",
        "\n",
        "plot_responses(responses)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6UOtE80WQqKO"
      },
      "source": [
        "If we change the model parameters, for example big making the sodium conductance bigger, the model behaves differently."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 20,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "8W3BTVBqQqKP",
        "outputId": "7658bd31-73de-448d-d2d8-c78d1f8831cc"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXwc1Zno/d+jluR9kWzZeJNsMzbGJoBthS0QIAmBsIxDCBkgIXkTJmRmApNl3smYgWyTy/sCSUjunWSSOHdIbhiIWTIExxicmCSAY2KQ8YodQDZeZLzIiyxZkmWp+7l/1NLVq1qWWl0tPd/Ppz/qOlV16nSrTz99Tp06JaqKMcYYEzYlhS6AMcYYk44FKGOMMaFkAcoYY0woWYAyxhgTShagjDHGhJIFKGOMMaFkAcr4ROQSEXmj0OUwJmxEZLqIqIiU5rDt/yMiq/ujXAOdBaiQEJGdItIuIscDjx/0ZxlU9SVVPaM/jwk9q/zG5MKtTydFZHxS+nr3sza9MCUzPWEBKlyuU9WRgccd/XVgCw5mAHobuNlbEJF3AcMLVxzTUxagQk5EfiQivwos3y8iz4vjMhFpEJF/FZFD7q/Gjwe2HSIi3xGR3SJyQER+LCLD3HXevv8iIvuBn3lpgf13isg/i8gmEWkVkf8UkYki8qyItIjIKhGpCGx/gYisEZEmEdkoIpcF1v1RRL4lIn9y9/1t4Nfti+7fJrfleGF+3k0zyDwMfDKw/CngF96CiIwRkV+ISKOI7BKRe0SkxF0XcevOIRHZAVwTzNjd9z9FZJ+I7BWR/yEikf54UYOJBajw+yfgXW6/9iXAbcCnND5H1WnAeGAKTgVcIiJeN919wGzgXOCv3G2+Fsj7NKASqAFuz3D8G4Ar3HyuA54F/hWowvn8/COAiEwBngH+h5vn/wv8SkSqAnndAnwamACUu9sAvNf9O9ZtOb6c0ztjTHZ/BkaLyJlu8LgJ+K/A+n8HxgAzgUtxgtmn3XWfBa4F5gO1wEeT8v450IVTr+YDHwT+Ni+vYhCzABUuv3ZbH97js6raBtwKPIhTue5U1Yak/b6qqh2q+gJOkPiYiAhO0PmSqh5R1Rbg/8OppJ4Y8HV33/YMZfp3VT2gqnuBl4C1qrpeVU8AT+FUToBPACtUdYWqxlT1d0AdcHUgr5+p6pvusR7HCZzG5JPXiroC2AbsddO9gHWXqrao6k7guzh1DeBjwPdVdY+qHgH+fy9DEZmI87n+oqq2qupB4Hsk1i3TB+y8Q7h8WFVXJSeq6lq3m2ECzhd70FFVbQ0s7wIm47RwhgPrnFgFgOBUTE+jG2iyORB43p5meaT7vAa4UUSuC6wvA/4QWN4feN4W2NeYfHkYpwt5BoHuPZxehzKc+uLZhdPLAE4d2pO0zlPj7rsvULdKkrY3fcACVBEQkc8DQ4B3gK8Q+DUHVIjIiECQqga2AIdwAsg8t/WTTl9OZb8HeFhVP3sK+9qU+iYvVHWXiLyN0+K5LbDqENCJE2y2umnVxFtY+4Bpge2rA8/3AB3AeFXtyke5jcO6+EJORGbjnNf5BE73w1dEJLlr7JsiUu6eo7oWeEJVY8BPge+JyAQ3rykicmWeivpfwHUicqV7gnmoO+hiag77NuJ0N87MU9nM4HYb8L6knoYoTm/EvSIySkRqgC8TP0f1OPCPIjLVHQi02NtRVfcBvwW+KyKjRaRERE4XkUv75dUMIhagwuU3SddBPYVTYe5X1Y2q+hbOAIWHRWSIu89+4ChO6+oR4O9U9S/uun8B6oE/i0gzsArIy3VOqroHWOSWrxHnV+Y/k8NnzD3Pdi/wJ/fc2wX5KKMZnFR1u6rWpVl1J9AK7ABWA48CD7nrfgqsBDYCrwH/nbTvJ3EG+mzFqX9PApP6vPCDnNgNC4uXO4z7v1Q1l1aKMcYUFWtBGWOMCSULUMYYY0LJuviMMcaEUt6HmYvITqAFZ9RMl6rWikgl8BgwHdgJfExVj+a7LMYYY4pH3ltQboCqVdVDgbQHgCOqep+ILAYqVPVfMuUxfvx4nT59el7LaUx/Wrdu3SFVrep+y1RWH8xAk6k+FOpC3UXAZe7z/wP8EWdIdFrTp0+nri7dKFFjipOI7Op+q/SsPpiBJlN96I9BEgr8VkTWiYg3IelE92I3cK7jmZi8k4jcLiJ1IlLX2NjYD8U0JrysPpjBqD8C1MWqugD4EPB5EXlvcKU7K3dKP6OqLlHVWlWtrao6pZ4QYwYMqw9mMMp7gPLmgXNn/H0KOA84ICKTANy/B/NdDmOMMb334xe2s2b7oe437AN5DVAiMkJERnnPce6ZsgVYhnPvIty/T+ezHMYYY/rGfc/+hVt+urZfjpXvQRITgafcKelLgUdV9TkReRV4XERuw5nG/mN5Locxxpgik9cApao7gHPSpB8G3p/PYxtjjCluNtWRMcaYULIAZYwxJpQsQBljjAklC1DGGGNCyQKUMcaYULIAZYwxJpQsQBljjAklC1DGGGNCyQKUMcaYULIAZYwxJpQsQBljjAklC1DGGGNCyQKUMcaYULIAZYwxJpQsQBljjAklC1DGGGNCyQKUMcaYULIAZYwxJpQsQBljjAmlggUoEblKRN4QkXoRWVyochhjjAmnggQoEYkAPwQ+BMwFbhaRuYUoizHGmHAqVAvqPKBeVXeo6klgKbCoQGUxxhgTQoUKUFOAPYHlBjfNJyK3i0idiNQ1Njb2a+GMCRurD2YwCu0gCVVdoqq1qlpbVVVV6OIYU1BWH8xgVKgAtReYFlie6qYZY4wxQOEC1KvALBGZISLlwE3AsgKVxRhjTAiVFuKgqtolIncAK4EI8JCqvl6IshhjjAmnggQoAFVdAawo1PGNMcaEW2gHSRhjjBncLEAZY4wJJQtQxhhjQskClDHGmFCyAGWMMSaULEAZY4wJJQtQxhhjQskClDHGmFCyAGWMMSaULEAZY4wJJQtQxhhjQskClDHGmFCyAGWMMSaULEAZY4wJJQtQxhhjQskClDHGmFCyAGWMMSaULEAZY4wJJQtQxhhjQskClDHGmFDKW4ASkW+IyF4R2eA+rg6su0tE6kXkDRG5Ml9lMMYYU7xK85z/91T1O8EEEZkL3ATMAyYDq0RktqpG81wWY4wxRaQQXXyLgKWq2qGqbwP1wHkFKIcxxpgQy3eAukNENonIQyJS4aZNAfYEtmlw0xKIyO0iUicidY2NjXkupjHhZvXBDEa9ClAiskpEtqR5LAJ+BJwOnAvsA77bk7xVdYmq1qpqbVVVVW+KaUzRs/pgBqNenYNS1Q/ksp2I/BRY7i7uBaYFVk9104wxxhhfPkfxTQosXg9scZ8vA24SkSEiMgOYBbySr3IYY4zpG7GY9uvx8jmK7wERORdQYCfwOQBVfV1EHge2Al3A520EnzHGhF9nLNavx8tbgFLVW7Osuxe4N1/HNmawem7LPh7+8y5+8ZnziZRIoYtjBphooAXVGY1RFsnvODubScKYAeTv/us1/lR/mA17mgpdFDMAdQUC1OceXodqfrv88n2hrjGmAG740RrOnDSaSAmUSLwlJUCkRCgtKaE0Igwri/Cv15zJ6VUjC1dYUzSi0XhA+v1fDjLr7meZO3l0t/v99JO1TBw9tMfHswBlzABVIjBh1FBiqnghKqYQU6UzGqO9M8qa7Ye5eNZ4C1AmJ8nnoE4bM5SK4eV015sc/JHUExagjBlAvvXhs/jqr7fw6N+ez0V/NT7rtp3RGLPufpYHf/cmLSe6uv2SyZd0vUTJSem3SU1M3i5tB1SazPJ5vJzyyuE9cPLSpOVc9+vm+BnyStba0eU//+wlM7j7mrnd79QLFqCMGUBuvaCGT5xfjeTwi9U7wd1yoosHf/dmvosWKunennTvWPL7mH6bdHlJckKOx+smn4zHS5dX92XPpVyZPks3n1edNr0vWYAyZoDJJTh53ju7ihnjhvPVa+emb230kz4NDqfYnWRyM33xMwCMHzUk78eyAGXMIPaLz9g8zebUjBqS//Bhw8yNMcb0WH+0VC1AGWOMCSULUMbk6Pjx41x66aWICCLC4cOHC10kY/rd9/7mHL73N+f0y7EGXYB65plnEBHeeuutQhfFFJn77ruPF1980V8eP348IsI555zD2rVrifXzPGXGFML186dy/fyp/XKsQRegHnvsMQDWrl1b4JKYYhKNRlmyZAmzZ89GVVm/fr2/btOmTVxwwQVEIhG/dVVbW8vJkycLWGJjil/Rj+JramqioqIiJX327NmMHj0aVfUvbgt+sdivXdMT9fX1NDY28sADDwBw7rnnoqq0trbyzW9+k/Xr17N69WpOO+00du7cybp16ygrKytwqY0pbkUfoEpK0jcCKyoqqKys9H/Reo+NGzcSi8WYOXNmP5fUFLMtW5zbmb3rXe9KSB8xYoQftIJOnDhh1+MY00tFH6C8VlKunn32Wa6++mr7dWt6ZMuWLYgIZ555Zk7bDx3a84kxjTGJBt05KK/FFY3aPRJN7rZs2cLMmTMZPnx4oYtizKAx6AJUJBIB7ByU6Zm33nqLOXPmFLoYxgwqgy5AeS2orq6ubrY0Ju7AgQOcdtpphS6GMYPKoAtQXhdNe3t7gUtiikUsFqOxsZEJEyYUuijGDCq9ClAicqOIvC4iMRGpTVp3l4jUi8gbInJlIP0qN61eRBb35vinYtSoUYAzK4AxuWhqaiIajVJVVVXoohgzqPS2BbUF+AjwYjBRROYCNwHzgKuA/xCRiIhEgB8CHwLmAje72/abkSOdO4e2tLT052FNEfM+K6NHd39ra2NM3+nVMHNV3QZpZ7VdBCxV1Q7gbRGpB7x5/etVdYe731J32629KUdPeAHKWlAmV62trYBzzZMxpv/k6xzUFGBPYLnBTcuU3m+8Lr7m5ub+PKwpYl6A8n7cGGP6R7ctKBFZBaQbvnS3qj7d90Xyj3s7cDtAdXXf3Vq4vLyckSNH2kzUJmdhaEHlqz4YE2bdBihV/cAp5LsXmBZYnuqmkSU9+bhLgCUAtbW1fXo36qqqKhobG/sySzOAdXR0ADBkSP5vcZ1JPuuDMWGVry6+ZcBNIjJERGYAs4BXgFeBWSIyQ0TKcQZSLMtTGTKyAGV6wruo27vI2xjTP3o7zPx6EWkALgSeEZGVAKr6OvA4zuCH54DPq2pUVbuAO4CVwDbgcXfbfjVhwgQOHDjQ34c1RcoLUJkmJjbG5EdvR/E9BTyVYd29wL1p0lcAK3pz3N6aNm0aa9asKWQRTBGxAGVMYRT9bOanorq6miNHjnDs2DHGjBmT9+OpatpbL2RKTxaLxYhGowkzsCfP4N7R0cGQIUNob29n2LBheb/VQzQaRUQSvrQPHjzItGnTWLJkCdOmTWP79u1cccUVVFRU8LOf/YyqqipOP/10amtrufnmm/nc5z7HqFGj2LlzJ+eeey4vv/wyXV1dvP/970dE2LdvH9OnT2f06NFEIhGampqYOHFiwms7ePAgra2tdHR0UF1dzdGjR6mqqqK8vJyuri5KS7v/iK9atYpt27Zx++23M2TIEFSVJ554grq6Om699VZ/1hELUMb0M++GfmF+LFy4UPvSqlWrFNAVK1YkpLe0tOiFF16oF110kQI5PxYsWNCj7dM9JkyYoICOHz++13nl+pgyZUrGdf1Zjv56jBo1qlf7v/jii332GQTqNCT1wZhCy1QfBuVPwosuugiA5cuXo6pcd911iAijRo3i5Zdf7nH3X19MgVNTUwPE5wrMtQV0ySWXcPnll3e7XW1tLVOnTk1ohXV0dFBZWZl2+2nTpmWdHPX8889n/vz5adfNmzcv437jxo3jfe97n788d258IpExY8ZQVVXFN77xDa688kpuvPFG7r//fr7+9a/725SVlfG5z33OX77llltYuHAhADfffDMQ//8m6+3sIfv27evV/saYnhHtwc3+CqW2tlbr6ur6NM9sAWDr1q3MmTOnz7vJNMcuPRMuN954I08++SSPP/44N954Y5/kKSLrVLW2+y1T5aM+GFNImerDoGxBAdx5553+80WLFtHc3Ow3K88888y8BBILTsXpO9/5DosWLeKaa64pdFGMGVQGbQvKmEKyFpQxcdaCMsYYU1QsQBljjAklC1DGGGNCqSjOQYlII7Crm83GA4f6oTj5YGUvjEKWvUZVT+n6hBzqg/1PCsPKfurS1oeiCFC5EJG6Uz3pXGhW9sIo5rJnU8yvy8peGGEtu3XxGWOMCSULUMYYY0JpIAWoJYUuQC9Y2QujmMueTTG/Lit7YYSy7APmHJQxxpiBZSC1oIwxxgwgFqCMMcaEUtEHKBG5SkTeEJF6EVlc6PIAiMhDInJQRLYE0ipF5Hci8pb7t8JNFxH5X275N4nIgsA+n3K3f0tEPtVPZZ8mIn8Qka0i8rqIfKFYyi8iQ0XkFRHZ6Jb9m276DBFZ65bxMREpd9OHuMv17vrpgbzuctPfEJEr8132vmB1oc/LbnWBAteFdDeJKpYHEAG2AzOBcmAjMDcE5XovsADYEkh7AFjsPl8M3O8+vxp4FhDgAmCtm14J7HD/VrjPK/qh7JOABe7zUcCbwNxiKL9bhpHu8zJgrVumx4Gb3PQfA3/vPv8H4Mfu85uAx9znc93P0hBghvsZixT6c9XNa7e60Pdlt7pQ4LpQ0A9vH/wTLgRWBpbvAu4qdLncskxPqpRvAJPc55OAN9znPwFuTt4OuBn4SSA9Ybt+fB1PA1cUW/mB4cBrwPk4V8iXJn9mgJXAhe7zUnc7Sf4cBbcL68PqQr+8DqsL/VwXir2LbwqwJ7Dc4KaF0URV9W7Juh+Y6D7P9BoK/trcZv58nF9fRVF+EYmIyAbgIPA7nF98TaralaYcfhnd9ceAcYUqey8VU5mL4rMUZHWhf8vuKfYAVZTU+SkS6vH9IjIS+BXwRVVtDq4Lc/lVNaqq5wJTgfOAOQUukskizJ8lj9WFwin2ALUXmBZYnuqmhdEBEZkE4P496KZneg0Fe20iUoZTIR9R1f92k4um/ACq2gT8AacbY6yIlKYph19Gd/0Y4DDF9bnyFFOZi+azZHWhsGUv9gD1KjDLHZlSjnNyb1mBy5TJMsAbvfMpnP5sL/2T7gigC4BjbvfBSuCDIlLhjhL6oJuWVyIiwH8C21T1wWIqv4hUichY9/kwnPMF23Aq50czlN17TR8Ffu/+Il4G3OSObJoBzAJeyWfZ+4DVhT5mdSEEdaG/TzTm4QTg1Tija7YDdxe6PG6ZfgnsAzpx+mxvw+nPfR54C1gFVLrbCvBDt/ybgdpAPp8B6t3Hp/up7BfjdFlsAja4j6uLofzA2cB6t+xbgK+56TNxKlU98AQwxE0f6i7Xu+tnBvK6231NbwAfKvRnKsfXb3Whb8tudUELWxdsqiNjjDGhVOxdfMYYYwYoC1DGGGNCyQKUMcaYULIAZYwxJpQsQBljjAklC1DGGGNCyQKUMcaYULIAZYwxJpQsQBljjAklC1DGGGNCyQKUMcaYULIAZYwxJpRKu9+kd0RkJ9ACRIEuVa0VkUrgMZxbQe8EPqaqR/NdFmOMMcUj77OZuwGqVlUPBdIeAI6o6n0ishioUNV/yZTH+PHjdfr06XktpzH9ad26dYdUtepU9rX6YAaaTPUh7y2oDBYBl7nP/w/wRyBjgJo+fTp1dXX5L5Ux/UREdp3qvlYfzECTqT70xzkoBX4rIutE5HY3baI6d5oE2A9MTN5JRG4XkToRqWtsbOyHYhoTXlYfzGDUHwHqYlVdAHwI+LyIvDe4Up0+xpR+RlVdoqq1qlpbVXVKPSHGDBhWH8xglPcApap73b8HgaeA84ADIjIJwP17MN/lMMYYU1zyGqBEZISIjPKeAx8EtgDLgE+5m30KeDqf5TDGDDz7jrXz9Ia9hS6GyaN8t6AmAqtFZCPwCvCMqj4H3AdcISJvAR9wl00Ovv3tbyMi5Hv0pTFhd9OSP/OFpRs42RUD4ERnlM5ozF9/ojPqP++KxvztvHVeHYrFlI6u+LYdXVGiMc2YT/IxsuUTc/NR1YR8TG7yGqBUdYeqnuM+5qnqvW76YVV9v6rOUtUPqOqRfJZjIFm8eDEAsVismy2NGdj2HzsB4AeTOV99juv/408A/PGNg8z56nOs2+V8tXzw+y8y+55nATh8vIM5X32On7y4A4CvPr2FM+55zs/3jHue4zM/fxWAZzbtY85Xn+ON/S0AXHjf75n39ZUA7DnSxpyvPsejr+wG4AuPbUjJ5wuPbQBg6at7mPPV59hzpA2AV3ce4Tcb3+nrt2TAsZkkikwkEgGgq6urwCUxprBKSwSArsCPtS17mwFYs/0wAK/udK7/39HY6m9zsKUDgF+vd7oHH1nrBJhYoNX0wpvOSMnn/3IAgM17jwHQ2NLht8R2HnbyXLHZGZCcLuB4ac9u2Q/A9sbjANz445e585fre/aCByELUEXGC1DRqHUXmMEt4gaoYHecp0ScdbE0XeHJ+7mLdKXJxwuCsTTrIt4xcujMiLjHSFdWk5kFqCJjLShjHKUR5+srfYBy/qYLLF7wirrBK1ugi/ittNR1kpRPNtmOYTKzAFVkrAVljMMPNFkCSzRN6yaS1CqKpOkq9GQLQsn5eNK2tkoyt+hMZhagiky6FtTOnTvZunVroYpkTEH4raQ03/lZu/iSW1DZAp1k6eIr8Y6fuC5daytbS8xkZgGqyKRrQc2YMYN58+Z1u+/WrVvZvXt3Qtrzzz9PfX193xbSmH4gfoDq2TmoEvdbLxrVhG2zdRWmu6wj3rpKTE+Xj/jlSVllsrAAVWRyPQd1ySWXMH/+/IS0efPmUVNTk5D2gQ98gFmzZiWk/fKXv2Tt2rUJaVdccQXf/va3E9LGjh3Lvffem5D20EMPJbTmotEoIsK3vvWtrOU1pqeyd/GRcV3yOSgv0KXrxssWWDK1rrIFTLt+sWcsQBWZEvfnX3fnoFavXs2GDRtO6Ri33HILF1xwQULaqlWr+MpXvpKQduzYMe65556EtNtuuy2hNdfZ2QmQEsiM6a34l36adSXdt1i8/bxt0+bTg9GAnnSBLt4Sy1wek8oCVJHxAlSxXKjr/wItkvKa4tPTLj4vxYsruXXxpR7Xa3klr9I0H/VsxzCZWYAqMrm2oMLC69Kwrg3T10oyDFKA7IMbPN5+XhBKf+4o8zEyddul7yrMnI/JzAJUkSm2FlR8nrLiKK8pHtlaSfGAkLqf/5n0z0F138WXLqwkt4qyBbps3ZEmMwtQRcZaUMY4SrIMYMgWvDyx5MCSbaReDq2rbAMhSqwFdUosQBWZYm1BWYAyfc39zs/agkr3ufOS/EESpzjMPGM+2boDU/KwepGNBagiU6wtKGP6XA5datnGJOTW8um+a87PJ8vQ9kwtMRszkZ0FqCJTrC0oY/pabsPMsw2ScP5mvw4qcdsgRRPWZS1PhpaYjerLzgJUkbEWlDGObOd14t1/iemq6geQ5BZU9hkgchkNmMvs6un3NelZgCoy1oIyxpHLIIlsLZb4uaPE5cR8vHXdn4PK1hLLNFmsBajsLEAVGWtBGePINsIu00SuUdVA19ypt3wS8owl5pPtM5+cj3XxZWcBqsiEpQWVa+CxAGXyJZeJXFO7+OLPvZaOd74q2xRFaWekSOkqdPONpZYpU/Aqko6QgilYgBKRq0TkDRGpF5HFhSpHsQlLCyp9l0duacb0hWwDGDJdBxWNaWrXHN5ymgCVYU4/DbTEvFW5DFe3Lr6eKUiAEpEI8EPgQ8Bc4GYRmVuIshSbMLegLECZ/iRkmUnC/Zu8Kts1SulubugdI6XlE1j0LvgNDqhIPkymQJfL3XgHs0K1oM4D6lV1h6qeBJYCiwpUlqJiLShjHFlv657hHJTGUi+WLckwK3nCMdK0fDJ18cVUU4+RoUWXba5AU7gANQXYE1hucNN8InK7iNSJSF1jY2O/Fi7MsrWg+jMY2Dmo/mX1IVW2ezVlGtyQ9lon92+6z2okU8snkJDLrOjxmS0S0y0+ZRfaQRKqukRVa1W1tqqqqtDFCY1sLahCByhrQeWP1YdUp3JHXeccVNIABm8GiByudUq3nNqCSjdIwl2Xw72jTFyhAtReYFpgeaqbZrqRrQVVLN1+xvSFbHPfZZqLT9N0v0VyGGaeruWTeh1UlpsbZrpQ15pQWRUqQL0KzBKRGSJSDtwELCtQWYpKthZUfwYoa0GZQsvlItrk33FpWyw5TFGUriXm8dYF77CbnFWm4GXXQWVXWoiDqmqXiNwBrAQiwEOq+nohylJsst2htj9H9lmAMoXmj+LL8rHPNszck/U+ThluBx+LpbvgN37M1GPYTBKnoiABCkBVVwArCnX8YhXmFlRvtjOmp7Kdg/JSsl2o64lk7SpMvy7xHJTz1w9CaW/5nv74FqCyC+0gCZNeWM5BWQvKFFq2mxJmug+Z00pKTMt276iMs5Br8ILfxCt+g9MpJR8jtUWXckgTYAGqyGQLUGHs4iv0BcVm4Mo2k4Qn3Vx8qflkvlDXzyeWupzcSivJcqGuf1v5bspnElmAKjJh7uKzFpTpTznd1j2liy81eGTr4ku+GDeeb5pBEn4XX+ZRhTZIomcsQBUZ6+IzxnFKLah00xllGw3o55OYHryeKj7MPHN5Mg9Xt/qRjQWoIpOtBVXoLr7ebGdMT0mGFkuwlZQuICR/IrPNABHMMzmfZDlNFpt8oa61oLKyAFVketqCyleAsBaUKbTM8+SRMgTck3aYeZa5+LyN0x8jOZ94eTJ97FPvqJt+O+OwAFVkenoOKl+tqlwHRFiAMvmS6bbu6S6izbQczCfdRzV7F19yPoFBEknhy2/R0X15TJwFqCLT01F8PQ1QvWkZFXpkoRlcMnXxJc40TtK61CBREhgenknKrOhZpldK1xLzUpLPV1kXX3YWoIpMvltQubaCrIvPFFouNwHM5ZxPwhRFKYEo8a+fj6a7nirzMPPk0YC5jEA0FqCKTk/PQWULUH0djKyLz/SnTLfbCHa/ZbuPUyAnIHUIevCzm8vwcL/LMc09p/y77/rXTMW3NZlZgCoyPR3F19MA1ZsgYy0o05/i56CSglAgQKRcGNvNXHzBVfYbTtYAABrUSURBVMHbZqR28aW2qrJ1FSYHzExTKJlEFqCKTE9bUNlG9lkLyhSzXCZgTXfDwuTt47ftSNw3GLDSttIylSdNV2FyeTIFV5PIAlSR6s05KC8t1xZUb1prNkjC5Is/rDvNTQAzzcUXi6Vp+bj5JHfxBYNHtrn4PNku1I3vn1weC1DZWIAqMl6w6E0gyZZHMM2rVD1tmXWXZkxfyHQOKviln3yuKN0QcAlcYBtcl200oKZpiXnDzKNJFwOrppYnl4uDjQWoouMFkL5o1XTXJdfTlpZ18Zn+lPEcVOD8ULrRd8kxIXhn3uD2iV18yYMkUtP8FlQsuSVGSqDLdqsQE2cBqsj0ZQuqu+1z3c5jLSjTnzKdg0p3nskTi6U7B+X8TR74EPyI53ShbsINC9Ofy/Kvg8qQr0lkAarIZGtB9UUXX0LF6mGAshaU6U8lGc75xGKacXRcTNONvot3tyXPUp7pXFa6Lr5gPsmzWcRbdEmj+CxCZWUBqsjkev4ol7TutrcAZcJMsoziy/S9n+5iXMkwzDyaFKxIWpepqzD5+MHzXl6yjeLLjQWoIpMtaGQLJMF1uQa5dMfq6RD1zs7ONK/CmN6LXxib2qXmDZRIuQ4qS/DSpK65YHdgyrmsLIEulm64etJ1UNg5qJxYgCoyXV1dQM/PQZ08eTIl7VS6+Lz1wfw8HR0dKWknTpxI8yqM6b3gNUrJw8MzDmDQ1MDidbMlt4piGr9/lNc68o+dpqtQMnbxpU466+Vmt3zPLm8BSkS+ISJ7RWSD+7g6sO4uEakXkTdE5Mp8lWEg8lokPW0tBYNHrl132fJrb29P2TddWrqgZUxfCM7ykHxxbnIrKR4QUltQXV6AipHQ5IqqEnXrQFJ8SjlfBYn3fEoIULF4Pl7LLtNEtyZRaZ7z/56qfieYICJzgZuAecBkYJWIzFbV/rsdbBHzAlS2FlSw1dLTFlS6Lj6v1eallZWVpQ1G6VpL1oIy+RINDN3uCnzRB7v4PMFRdCktqGh8IETyRLNdGQJITNW/7imeFv+rSYGuM+oFQS9AxdeZzArRxbcIWKqqHar6NlAPnFeAchSlUw1Q6VpQx44dS8mjqakpZbvm5uaU/KwFZQot2Co5GegrS9e68RajaYJOvAWVmE9MNeMou3Trutx9o6opAyw63XVeubygaOegsst3gLpDRDaJyEMiUuGmTQH2BLZpcNMSiMjtIlInInWNjY15LmbxyKWLLxgovLR0QWv//v0peQTf63SBrKddfNaC6htWH1J1Bb7kO7uCM6CQseUTVaWjK/HHnRfooqqc7EoMdMHglbgPCcEMiAehlC6+xLICdCZ1+Zn0ehWgRGSViGxJ81gE/Ag4HTgX2Ad8tyd5q+oSVa1V1dqqqqreFHNASW5BBbvuvOBx/PhxP83b7uDBgynbHThwwE/zuj02bdqUst2RI0dS8tu+fXtK2f7whz+kpG3cuBGASCTSzSsz2Vh9SOUFgZQuPlVOdDqf3dKS5MENiUEI4vuqQkdX/IdfTAOtojRTJnnH8Hj5xlQT8omq0hVLzKcrmj7wmUS9Ogelqh/IZTsR+Smw3F3cC0wLrJ7qppkcJLeggoHCS1u6dKmf5gWUT37ykylpzz//vJ+mqogId9xxR0p+H/vYx1LSvvSlL6WU7bvfTf0N0tDQAMCECRO6f3HG9IDXElJVOjoTWz5tJ53PafK8e9FYYhACaDnR5e8XbF3FVDne4eajia2dmCodSQHK2zeqSmtHINDF4uXzbuHRFQiuJrN8juKbFFi8HtjiPl8G3CQiQ0RkBjALeCVf5RhokltQf/nLX/x1Xto3v/nNlLQdO3b4aV6Qeeihh1K2C8o0ii+XC3e95UcffRSAsrKy7C/MmB5qand6D6Ix9Z+DEwDaTnpBh8RuO1U/IHnbNp9w61TSumhMaXHXJe8XjSktHc6yN+DhWLtXN5XWk/FtY6ocbTvpP29q60xYZzLL5yi+B0TkXJwBNDuBzwGo6usi8jiwFegCPm8j+HLnndPxgsS2bdv8dZkCR/I5i1gsljJ4Id120WiUXbt2pWz3m9/8JuU4wa5Bb989e/YkLBvTl7wv+pjC4eOBru6YcrDZ+XyrKkdaE4PXwZbA+VjFXx9T5WBLR2Cd+vnGVDnU2pGw34FjTj7lkRI0YVtoDOQTjWnCMfYcbUtYZzLLWwtKVW9V1Xep6tmq+tequi+w7l5VPV1Vz1DVZ/NVhoFo3z7nbfRaKCtWrGDIkCFAYlCYN2+ev90999yTkEc0GuXll18G4KKLLvK3+8Y3vgHApZde6m/3yCOPAPEuvWg0yvXXX5+wnar63YWf+MQn/PyWLVsGwPnnn28Bqh+t23WE99z3e37yQup5woHkWFu85fP6O4GBPKrsPNzqPI8p2/bFR6FGY8r2g63+cmNLhx/oojFl9+H4ulgMdrnLsZjyxv6WwDpl95E2//gNR9v9QRPRmPr7AXRGlTcPHI8f40ggQAVaUI0tHQnB09hMEkUlOG1QNBqlsbGRNWvW+OeIYrEYd999NwCXXHKJn/b2228D8PWvf91Pu/zyywH8v7FYjBdeeIFIJMKdd97pH+Ohhx7irLPOYu7cuf52nve///3+do8++ihnn302Z511lp+2dOlS5s2bx/z58y1A9ZP2k1G+/PhG9ja187M/7URVeftQK798ZXfCl1+x/3LvjMb8LraYKhv2xC+PaGrrZHujG6BUWR9YF40pr+0+6i9v3RcPbDGF13bHtz3QfIJ33FZSVJXXdsX364rF840pCcePqbI+kM9f9jfT3ulNLwYbAuu8+LRtXzPv+84fueLBF9nb1E4spmzZe4zDxwf3ZRr5vlC3Xzz11FNcdtllVFRUdL9xEUseTffMM8+gqnz4wx/m4YcfJhqN8vDDDwNwzTXX8OMf/5gTJ05QV1cHwLnnngskXng7duxYwBnRt23bNhYvXuyPuDtw4ADbt2/n/vvv9281/8477yAifO1rX/PT9u/fz2uvvcZ9992XsO/LL7/M1772NY4cOZJwTJM/j6zdxa7DbVxz9iSe2bSPZRvf4Z5fb6HlRBcjh5Ry4enj2PpOM/ubTzBl7DDGDCvz56fz5p7z7ovkXU+UaSi0JE+vkCfqlskb9h2NqT8KDpxybthzjOnjhrPzcBt1O51AUjVqCOoGj6kVw2g42k7D0XYOtnQwZeww9ja1+9uOGlrqB6/TRg9lf/MJXt3p1LdxI8qJxWD9niaqK4ez+0gb2xuP09TWycTRQzjQ3MHGPU2Ul5YwtLSEzmiMDXua/HVeYJsydhgxVdbtPsr86rGs393kX1S8+Feb6OiKcTIa458e30CJCGu2H6YsItTWVNJ8opNdh9tQVYaVRxhSGkl4f9Lpr/9PLp74uwuZPHZYj/cr+gDV0NDARz7yEaDnM2erKsePH2fUqFH5KFra4508edLvkuupDRs2+M+97repU6eycOFCAL+lNHXqVEpLnX/t+vXrOXr0KA899JAfPH7/+98D8I//+I9+kPnzn/9MLBbjqquu8i/WXblyJQAXXnihP8hixYoVflB87rnnAHjhhRcAp8tvzZo1ACxfvhxV5brrruORRx7JKUB1dXX55TY91xWN8b9fepuLTh/HP3/wDJ7ZtI8vLN3A1Iph/OCWBTz88k627D3GudPGct24yTQcbaO1o4tIiSAiREQoKSH+XKCkRCiR5DkTUidhzee5fhFnuHgk8CgtEYaWRfjBH+ppONrOoeMdvHfWFHYebuPVnUeIlAjzp41l2/5mNu5p4rIzqmg42k7dLifo1E6vYO+Gdta+fYQzJo7iRFeU+oNO0Ln27PEs37SPV3Yeoby0hLOnjmHXkTbqG49zzbsmsftIG3Vu8Hr39EqWb9rH+j1NnDV5NLuPtPP6O820nYzyvjkTWL5pH+t2H6VieBkzxo/gSOtJ3jrYwmfeM8MPUL/dup+NDcd48GPnsG1fMz996W2Gl0f416vncKC5g1d3HmHcyCG8e3olpSVCe2eUE4FRiyLk9P8pZLwaWnZql5kU/bfB+PHj/ecrV66koaGBdevWsXr1ajZv3kxtbS2XXnopNTU1HDx4kLa2NkSE/fv309DQwOrVq/n0pz/N6aefzsaNG6mqqmLYsGFUVFQwatQoWltbaWpqoqqqiosuuoj58+dTXl6eUo5oNMrBgwdpaGhg7969NDQ0pDxvaGjgxIkTDBs2jMrKSsaNG+c/uluuqKhg7dq1/vEOHTrEqlWr+Pu//3v/S907D7R8+XL/GqdVq1YBcOWVV7J+/XogHui+/OUv8+tf/xqA3/72twCcc845vPTSS4ATjCZMmMB73vMef7DEK6+8wogRIzj77LP9ff7t3/4NgIULF/plXL58OZMnT2bBggUsXbo0IUCdPHmSJ598ko9//OMsWLCAkydP0trayttvv82ZZ57JP/zDP7B582Y2b97MtGnTmDt3LqNGjWL37t1UVFTQ0dHBkiVLqKyspLq6murqaiZMmEBZWRmlpaWUlpYycuRIKisrqaysZMyYMezfv5+Ojg7efPNNdu/ejYhQUlLS7SMSiaSkqSrt7e20tbXR1taW8NxbHjNmDH/84x9P7UN9ikojJfzitvOIxpSaccP56MKpvHWghR/csoBplcO5dPbAu37qyXUNrHNbKPNrKvjv9XvZvPcYZ00Zzcihpew54lw8vrCmgqc3vMOWvc0MLSth7qTRPL3hHdbtOsrHz6/m5e2H2bzX6e7zg87uJt49vYKhZRF2uF2GC2sqeGr9XjY2HGP00FJmTRgF7GP97qP87SUz2du0l00NTj7nzXDy2bK3mcvOqEIVtrrnwxbWVCDi/Gj9xcu7mDJ2GIvOncI1Z09i7uTRnD9j3Cm1OAaaog9QQ4cOZdSoUbS0tHDVVVelrK+rq/O7uDxDhgxh8uTJlJaWUl1dzeOPP+5P5yMilJWVJVwAG4lEEs6hBL+4IpEIkUiE9vb2lFZCWVkZU6ZMYcqUKSxcuJBFixYxduxYmpqaOHz4MIcPH+bIkSNs2bLFf57LuZqysjKeeeYZAC644AK/FbR27VpGjBjBWWed5Y/IW716NbNnz2by5Mn+SLtly5ZRU1NDTU2Nv+/Pf/5zAEaPHu23tLZt28ZVV13lfzEDPPvsswnvAcCbb77JjBkzKCsr89P+9Kc/ce211yIilJaW0tXVxc6dO6murub6669nxYoVALz22msJr23btm3ceeedjBw5kgULFlBXV8cTTzyBqjJ8+HDa29tRVa688krGjh3L7t27WblyJYcOHaKrqyvtcPmgkpISJk+ejIgQi8W6fUSj0ZQ0gOHDhzNs2DCGDx+e8HzEiBGMHz+eiRMndvt/zIfZE+O9Ad+58ZyClKE/lUVKON7RRXlpCfMmj/bTF1ZX+NdCASyojnf/nz11LOWl8dPv755eyZ93HAZwg87IeD41lQmj7mqnx/NZUFNBacS7B5STz282vgPAaaOHMrUiHmDmT6tgY0P83NPCmgpKRNje2Mqa7Yf55yvPcFuHEa6fP/XU35ABpugDFDjXAk2ZEp8tacOGDZxzzjl0dHRw7NgxVJV33nE+OGVlZcybNy+hf1ZVaWxsZPTo0ZSVlVFSUsKJEydobm5m5MiRDB8+nP3797NmzRq2bNlCZ2en/+XlfYENHTqUqVOn+o8pU6ZQVVXlf7HnQlVpbm72g5cXtILLV199NV/84hd58803AbjhhhtobXV+3XV1dXH55Zf7wRPg8OHDXHHFFQB+WktLC5/97GcT0oKCsz54562CaXPmzEnZ98EHH0xIa21tpba2FoDS0lI6OzuZMWNGwnFWrVrFZZddxvbt23nppZcYOXIk48ePZ8KECdTU1DB6tPOF47VKKisraWtrY//+/cycOTNtH3ssFqOrq4vW1lb/vWtqamLChAkMHTqUmpoahg3r3S9T76JmU3hlboA4d+pYhgSCzoKaCtbUO0Fn7PAyzjgtHrjnV48lEphh4t0zKv3lBTUVCetqayrY2+S0wk4bPTShVbOwuiLhNhy1NfHlhTWJ686bUcnmvU6Amjl+BONGDiEiwjOb9yECH11oQSmdARGgJk+eTEtLC6WlpQwdOtRPHzJkiD+DQbZftCKSMtPBsGHDEr7IJk2axA033MANN9zQx6VPLMeYMWMYM2YMM2fOzLjdjTfe6D8fMWJEwnx3ycEI4LLLLgMSg4w3yi/4Rbt69eqU7bx9g/l5IwXTbRdMu/jiiwHSnlc6fPgwlZWVAMyePZvZs2enf7Hgt1K813v66adn3LakpITy8nLKy8upqKjIuu2psuAUHt65mAtOH5cQWM6fMY4/73DOE53nnrvxXDhzHA1HnaBTFhGmjB3GIfcapvMCwQqcQLPMbRWdN6OSSOB/f/7McWzYEx8AUTGi3A9myfnMrx7rzxpx3gznc+9lddHp45g4Ov69ZeIGzDDzkSNHJgSngcxrMVVXVwOJQeHaa68FSBiI4Q0lDwYZL5B556gA3vOe96Tk98EPfhBInJXcuw4q2B3pjQYMHuO885xJ6tva4l0kAOvWrfODkzG94QWES2aNT2ixnDZmKHvc640unjU+4UfF+TPG+fPoeeflvAtpL51dlbBtxYhy/9zUe2dXJRxjQfVYfyqkS89IPL932RlV/u04yiMlDC2L+KMCvWN6UyP99TmTT/0NGOAGTIAajLzJWYOBwut+C84sPmvWLCBxYtkRI0YA8Qt1g+rr6/3nXmW99dZbU/b98pe/nLKvdy4L4sHqgQce8NO+9KUvsWDBgqyvy5hcXfxXziCphdUVjBrqtNT/ptaZ6vNdU8cAcM274rOuzRw/gmHlEapGOT/gPnFBjZ8OMHfSaEa7+fzdpU7re3618+PrqrNO87sUz5k2ltJICZPGOD+Kb3S76Ca7yzXjRjB2uDO915eucHoHLjp9HACXz0nsrfnrc1Ju5mA86t4COcyPhQsXqonDGUXqL3d0dKSkNTY2KqDf//73/bTdu3croC+99JKfduzYMb311lv16NGjftq+ffu0trZWd+zY4afV19croBs3bvTTfvCDHyigr776qp+2efNmBRL2/dGPfqSAbtu2rQ9e/cAA1KnVh147cKxdDzaf8Jff3N+s0WhMVVVbOzq14Wibv27noePafrJLVVU7u6L65v7mhHyOHO9QVdVYLKZvBPJpbj+ZkM/2gy16otPJp6MzMZ93mtq0qe2kv/zWgRaNxZx8mtpO6r6mdn/dr9bt0bU7DvfyHRgYMtUH0SKYrLC2tlaTR+IZU8xEZJ2q1p7KvlYfzECTqT5YF58xxphQsgBljDEmlCxAGWOMCSULUMYYY0LJApQxxphQsgBljDEmlCxAGWOMCSULUMYYY0KpVwFKRG4UkddFJCYitUnr7hKRehF5Q0SuDKRf5abVi8ji3hzfGGPMwNXbFtQW4CPAi8FEEZkL3ATMA64C/kNEIiISAX4IfAiYC9zsbmuMMcYk6NXtNlR1G6S9/cAiYKmqdgBvi0g9cJ67rl5Vd7j7LXW33dqbchhjjBl48nUOagqwJ7Dc4KZlSjfGGGMSdNuCEpFVwGlpVt2tqk/3fZH8494O3A7x+x4ZM1hZfTCDUbcBSlU/cAr57gWmBZanumlkSU8+7hJgCTizN59CGYwZMKw+mMEoX118y4CbRGSIiMwAZgGvAK8Cs0RkhoiU4wykWJanMhhjjClivRokISLXA/8OVAHPiMgGVb1SVV8XkcdxBj90AZ9X1ai7zx3ASiACPKSqr/fqFRhjjBmQejuK7yngqQzr7gXuTZO+AljRm+MaY4wZ+GwmCWOMMaFkAcoYY0woWYAyxhgTShagjDHGhJIFKGOMMaFkAcoYY0woWYAyxhgTShagjDHGhJIFKGOMMaEkquGfd1JEGoFd3Ww2HjjUD8XJByt7YRSy7DWqWnUqO+ZQH+x/UhhW9lOXtj4URYDKhYjUqWpt91uGj5W9MIq57NkU8+uyshdGWMtuXXzGGGNCyQKUMcaYUBpIAWpJoQvQC1b2wijmsmdTzK/Lyl4YoSz7gDkHZYwxZmAZSC0oY4wxA4gFKGOMMaFU9AFKRK4SkTdEpF5EFhe6PMlEZJqI/EFEtorI6yLyBTe9UkR+JyJvuX8r3HQRkf/lvp5NIrKgsK8ARCQiIutFZLm7PENE1rplfExEyt30Ie5yvbt+eoHLPVZEnhSRv4jINhG5sJje956yupB/Vhf6V1EHKBGJAD8EPgTMBW4WkbmFLVWKLuCfVHUucAHwebeMi4HnVXUW8Ly7DM5rmeU+bgd+1P9FTvEFYFtg+X7ge6r6V8BR4DY3/TbgqJv+PXe7QvqfwHOqOgc4B+c1FNP7njOrC/3G6kJ/UtWifQAXAisDy3cBdxW6XN2U+WngCuANYJKbNgl4w33+E+DmwPb+dgUq71ScD+/7gOWA4FxxXpr8PwBWAhe6z0vd7aRA5R4DvJ18/GJ530/h9VpdyH95rS7086OoW1DAFGBPYLnBTQslt5k/H1gLTFTVfe6q/cBE93nYXtP3ga8AMXd5HNCkql3ucrB8ftnd9cfc7QthBtAI/MztkvnfIjKC4nnfe6qoym91oV8VbV0o9gBVNERkJPAr4Iuq2hxcp87PlNCN9xeRa4GDqrqu0GU5BaXAAuBHqjofaCXehQGE930f6Kwu9LuirQvFHqD2AtMCy1PdtFARkTKcCvmIqv63m3xARCa56ycBB930ML2m9wB/LSI7gaU4XRv/ExgrIqXuNsHy+WV3148BDvdngQMagAZVXesuP4lTSYvhfT8VRVF+qwsFUbR1odgD1KvALHckTTlwE7CswGVKICIC/CewTVUfDKxaBnzKff4pnP54L/2T7kiaC4BjgWZ4v1LVu1R1qqpOx3lvf6+qHwf+AHzU3Sy57N5r+qi7fUF+lanqfmCPiJzhJr0f2EoRvO+nyOpCHlldKFBdKMSJr758AFcDbwLbgbsLXZ405bsYp+m8CdjgPq7G6Y9+HngLWAVUutsLzmis7cBmoLbQr8Et12XAcvf5TOAVoB54Ahjipg91l+vd9TMLXOZzgTr3vf81UFFs73sPX6/Vhf55HVYX+ulhUx0ZY4wJpWLv4jPGGDNAWYAyxhgTShagjDHGhJIFKGOMMaFkAcoYY0woWYAyxhgTShagjDHGhNL/BRK5Vvkn5VpAAAAAAElFTkSuQmCC\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "# Set values for the free parameters\n",
        "default_params = {'gna_soma': 0.15, 'gk_soma': 0.03}\n",
        "\n",
        "# Run the simulation\n",
        "responses = twostep_protocol.run(cell_model=simple_cell, param_values=default_params, sim=nrn)\n",
        "\n",
        "# Run the simulation and plot the responses\n",
        "plot_responses(responses)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qnSOujQ4QqKP"
      },
      "source": [
        "We can observe that after changing the parameters our model starts to approximate the number of spikes in response to the positive current injection, but we also obtained an undesired spike at the end of the negative injection."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jDiBF9qiQqKP"
      },
      "source": [
        "### Define eFeatures and objectives"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jmhC8KTBQqKP"
      },
      "source": [
        "We can now use the experimental data to constrain the model parameters. For example we can use number of spikes in the response to the two steps as the optimisation targets.\n",
        "\n",
        "We can use the eFeature Extraction Library ([eFEL](https://github.com/BlueBrain/eFEL)) to extract some electrical features (eFeatures) from experimental and model traces. eFeatures are metrics that define for instance the shape of the action potential or the passive properties of a neuron (for examples, see [here](http://bluebrain.github.io/eFEL/eFeatures.html)).\n",
        "\n",
        "We can now extract the number of spikes from one of the experimental recordings. To extract features with eFEL we need to define the traces we want to analyse as Python dictionaries, containing the time array **T**, the voltage **V**, the **stimulus start** and **end time** (they have to be Python lists) and the **name of the features** we want to extract."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "pnZhGuX5QqKP",
        "outputId": "f4139e53-55ff-4bfd-d31c-868f5869db8d"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Number of spikes in the experimental trace: [10]\n"
          ]
        }
      ],
      "source": [
        "import efel\n",
        "\n",
        "# Get the time and voltage array from the experimental data\n",
        "time = exp_pos_trace[:,0]\n",
        "voltage = exp_pos_trace[:,1]\n",
        "\n",
        "# Define the trace dictionary for efel\n",
        "trace = {'T': time, 'V': voltage, 'stim_start': [250], 'stim_end': [450]}\n",
        "\n",
        "# Extract features\n",
        "feature_values = efel.getFeatureValues([trace], ['Spikecount'])[0]\n",
        "\n",
        "print(f\"Number of spikes in the experimental trace: {feature_values['Spikecount']}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "GasK_Ml2QqKQ"
      },
      "source": [
        "We can now use these experimental eFeatures to calculate the fitness of our model. Each eFeature (or a combination of them) can be set as an optimisation target.\n",
        "\n",
        "In the code below we associate an eFeature to each voltage response and create the eFELFeature and Objective objects.\n",
        "\n",
        "The eFELFeture ojects takes as arguments the name of the feature in the eFEL, the name of the recordings containg the traces to evaluate, the start and end time of the stimulus and the experimental **feature mean** and **standard deviation** (std). \n",
        "In this example we use the feature means extracted from the experimental traces (and stored in the *feat_means* dictionary) and *0.05abs(mean)* as standard deviation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {
        "id": "xpHuopS9QqKQ"
      },
      "outputs": [],
      "source": [
        "feat_means = {'neg_step': {'Spikecount': 0}, 'pos_step': {'Spikecount': 10}}\n",
        "\n",
        "features = []\n",
        "objectives = []\n",
        "\n",
        "for protocol in sweep_protocols:   \n",
        "    stim_start = protocol.stimuli[0].step_delay\n",
        "    stim_end = stim_start + protocol.stimuli[0].step_duration\n",
        "\n",
        "    for efel_feature_name, mean in feat_means[protocol.name].items():\n",
        "        feature_name = '%s.%s' % (protocol.name, efel_feature_name)\n",
        "        \n",
        "        feature = ephys.efeatures.eFELFeature(\n",
        "                    feature_name,\n",
        "                    efel_feature_name=efel_feature_name,\n",
        "                    recording_names={'': '%s.soma.v' % protocol.name},\n",
        "                    stim_start=stim_start,\n",
        "                    stim_end=stim_end,\n",
        "                    exp_mean=mean,\n",
        "                    exp_std=0.05 * abs(mean) if mean != 0 else 1)\n",
        "        \n",
        "        features.append(feature)\n",
        "        objective = ephys.objectives.SingletonObjective(\n",
        "            feature_name,\n",
        "            feature)\n",
        "        objectives.append(objective)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jx3G8_sAQqKQ"
      },
      "source": [
        "Now that we have defined the objectives, we need to use them to score the model responses by creating a score (or fitness) calculator object."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 23,
      "metadata": {
        "id": "RXv3TjooQqKR"
      },
      "outputs": [],
      "source": [
        "score_calc = ephys.objectivescalculators.ObjectivesCalculator(objectives)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3iEGX-XvQqKR"
      },
      "source": [
        "We can now define our cell evaluator by combining the cell model, the protocol and the score calculator. We also need to specify a ordered list of the names of the free parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 24,
      "metadata": {
        "id": "2lGdNRFqQqKR"
      },
      "outputs": [],
      "source": [
        "cell_evaluator = ephys.evaluators.CellEvaluator(\n",
        "        cell_model = simple_cell,\n",
        "        param_names = ['gna_soma', 'gk_soma'],\n",
        "        fitness_protocols = {twostep_protocol.name: twostep_protocol},\n",
        "        fitness_calculator = score_calc,\n",
        "        sim = nrn)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FXhoQ1yJQqKR"
      },
      "source": [
        "Now we can ask the evaluator to calculate the scores for a set of parameters. (The lower the score the better the model).\n",
        "The score for each feature is calculated according to the formula:\n",
        "\n",
        "$$ score_{feat} = \\frac{|mean_{exp}-feat_{model}|}{std_{exp}}$$\n",
        "\n",
        "We can now the default_params set. From the responses above, we see that there is a spike during the negative stimulus. In response to the positive stimulus, our model fires more than 10 spikes. Thus, none of the two scores will be perfect (= 0)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 25,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JrmZxOnNQqKS",
        "outputId": "9e1c2a2a-2689-4274-80aa-c3ba53f28fb9"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Scores:\n",
            "{'neg_step.Spikecount': 1.0, 'pos_step.Spikecount': 8.0}\n"
          ]
        }
      ],
      "source": [
        "objectives = cell_evaluator.evaluate_with_dicts(default_params)\n",
        "print(\"Scores:\")\n",
        "print(objectives)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2PvJ3vv1QqKS"
      },
      "source": [
        "We can also plot scores as error bars."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 26,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 189
        },
        "id": "sGNV0k_qQqKS",
        "outputId": "2b4c00b3-d82e-4822-d8e6-79807d5eb081"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x180 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "def plot_objectives(objectives):\n",
        "    ytick_pos = [x + 0.5 for x in range(len(objectives))]\n",
        "    obj_val = objectives.values()\n",
        "    obj_keys = objectives.keys()\n",
        "    fig, ax = plt.subplots(figsize = (6,2.5))\n",
        "    ax.barh(ytick_pos,\n",
        "              obj_val,\n",
        "              height=0.5,\n",
        "              align='center',\n",
        "              color='blue',\n",
        "              alpha=0.5)\n",
        "    ax.axvline(3, color = \"gray\", ls = \"--\")\n",
        "    ax.set_yticks(ytick_pos)\n",
        "    ax.set_ylabel(\"Score name\")\n",
        "    ax.set_xlabel(\"Score value (# STD)\")\n",
        "    ax.set_yticklabels(obj_keys)\n",
        "    fig.tight_layout()\n",
        "plot_objectives(objectives)  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HT--W2vuQqKS"
      },
      "source": [
        "# Set up and run an optimisation\n",
        "\n",
        "As we have seen above, finding parameter values that match the experimental features may not be trivial.\n",
        "Let's now use the BluePyOpt parameter optimisation algorithm to find a set of parameter values that generates a perfect score of 0 on the 'pos_step' trace.\n",
        "\n",
        "BluePyOpt uses an [evolutionary algorithm](https://en.wikipedia.org/wiki/Evolutionary_algorithm) to generate parameter sets (or individual) with increasing fitness. At each iteration (generation) a set of parents from the previous generation is selected to generate an offspring. \n",
        "\n",
        "Let us specify that we want to have an offspring size of 15 **individuals**. This means every population will have 30 individuals (15 parents, 15 offspring)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 27,
      "metadata": {
        "id": "qARMWUttQqKT"
      },
      "outputs": [],
      "source": [
        "optimisation = bpopt.deapext.optimisations.IBEADEAPOptimisation(                              \n",
        "        evaluator=cell_evaluator,                                                \n",
        "        offspring_size = 10)    "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "--RWdJZHQqKT"
      },
      "source": [
        "Now the optimisation algorithm can be run for a certain **number of generations**.\n",
        "\n",
        "**Executing the next cell will take some time (a couple of minutes). There will be a ['*'] shown next to line while it is running.**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 28,
      "metadata": {
        "scrolled": true,
        "id": "oPQTvoORQqKT"
      },
      "outputs": [],
      "source": [
        "final_pop, hall_of_fame, logs, hist = optimisation.run(max_ngen=13)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b6x3ll2ZQqKT"
      },
      "source": [
        "## Optimisation results"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fQ824wC4QqKU"
      },
      "source": [
        "The optimisation has return us 4 objects: final population of parameter sets, hall of fame (the ten best individuals), statistical logs and history.\n",
        "\n",
        "After running an optimisation, we can inspect the hall of fame and other individuals from the history. In our case it contains values for the parameter *gna_soma* and *gk_soma*."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 29,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "6L2I6BzIQqKU",
        "outputId": "7bb29c8b-1149-47ef-c763-e85c38064cfb"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 360x288 with 4 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAAEYCAYAAABiECzgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO2de5hcVZW33186nU4I0AlEJAaEICDiNJdJcGQEVFokEoMOIAbQiKMyjoh+KnwTPkduDkN0mAEUVCIqRLmIXJNJELABZRQcEhJoA3IxCZAQhABpIJcm3VnfH2dX53Slqvuc1KlLV633eepJ1Trn7L0rvWqdfdZeey2ZGY7jOE7lGVbtATiO4zQqboAdx3GqhBtgx3GcKuEG2HEcp0q4AXYcx6kSboAdx3GqhBvgQZB0uKQnSrjeJO0d3v9I0rcSXPN2SW9Iaipy/DxJv9jWMRUbn1O7SLpP0ufL2P5SSR/YxmuvlvRv4X3i34ukOyR9psixPYNuDt+WMRUbX60xZAywpBWSNgTD9Kqk+ZJ2z6jdDxU7bmb3m9k7S+0ntPVFM/t2gvOeNbPtzaw3i36d2kLSqZI6Ja2X9IKkH0oaEzue2Q02KWb2bjO7L4N2Ev9ezOwjZnZNqX0OZYaMAQ5MM7PtgfHAX4HvV3k8jpMKSd8AvgOcBbQC7wX2AO6WNKIC/UvSUPvd1y1D8g9hZhuBm4D9czJJLZIulvSspL+Gx/1R4dg4Sf8taa2kVyTdL2mYpJ8DbwfmhZn1/83vS9IHJK2MfV4h6UxJj0rqkvRLSSNjx8+StFrS85L+Ma+t+KPa45I+Gjs2XNJLkv42//FL0kRJv5X0uqS7gXHFxhcb44fC+/dIeiB899WSLi/2Q5d0jKTHQj+rJJ2Z4M/hJETSjsD5wBlm9msz22RmK4ATgT2BT0maAvw/4JNBJx+JNbGHpN+Hv89dkuJ68F5Jfwh/50fi7oTgvrhQ0u+B9cBeBcYW15nzJN0oaU7oa6mkybFzD5b0cDj2SyCu/336KOlfJN2U189lkr4XG9fnw/um8PtdI2kZMLXY+GJj/EXs86/C00SXpN9JeneRv0FBW1Do3EowJA2wpO2ATwIPxsSzgH2Bg4C9gQnAOeHYN4CVwFuAtxIpuJnZp4FnCTNrM/tuwiGcCEwBJgIHAKeGcU0BzgSOAvYBiro2gOuBk2KfjwbWmNnDBc69DlhEZHi/DRT0mxWhF/hauPZQoB34UpFzfwL8k5ntAPwNcE+KfpzB+XsiY3VLXGhmbwALgKPM7NfAvwO/DDp5YOzUk4HPArsAI4h0DUkTgPnAvwE7BfnNkt4Su/bTwGnADsAzCcZ6LHADMAaYC1we+hoB3Ab8PPT1K+D4Im3cABwjaYdwbRPRb+e6Aud+AfgocDAwGTghwRjj3EH0m9sFeBi4tsh5BW1Byr4yY6gZ4NskrQW6iIzcf0D0WEWkXF8zs1fM7HUiJZ4erttE5LbYI8w67rfSkmB8z8yeN7NXgHlERh8i5fqZmf3JzNYB5w3QxnXAseFmAtGP6/r8kyS9HTgE+JaZdZvZ70KfiTCzRWb2oJn1hNnWlcD7i5y+Cdhf0o5m9mqRm4Gz7Ywjusn2FDi2mtiTTRF+ZmZPmtkG4Ea26N2ngAVmtsDMNpvZ3cBC4JjYtVeb2dKgB5sSjPV/Qnu9RMY2dyN4L9AMXBp+SzcBDxVqwMyeITKG/xBERwLrzezBAqefGNp8LvyuLkowxnhfPzWz182sm+h3d6Ck1gKnZm0LSmKoGeCPm9kYolnEl4HfStqV6G62HbAoPFqsBX4d5BAZ6qeBuyQtkzSzxHG8EHu/Htg+vH8b8FzsWNGZhpk9DTwOTAtG+FgKzwzeBrwaDPqg7eYjad/wyPWCpNeIbkzFfujHE/1onwkuj0OT9uMkYg0wToVX9seH4wNRTO/2AD6R0/2g/4eFNnPE9TIJ+X2NDON+G7Aqz2gNpI/XseVJ72QK6zik+O3kE9wXsyT9Jej4inCokJ5nbQtKYqgZYADMrNfMbiF6vD6MSHE3AO82szHh1RoW7Ah3xm+Y2V5Ehu7rktpzzWU4tNVAPDLj7YOcn3NDfAx4LBjlQm2OlTS6SLvriG4+QN9jXvzR84fAn4F9zGxHokcuFRqMmT1kZh8jeoy7jWiW5WTHA0A3cFxcKGl74CNARxCl1cnngJ/HdH+MmY02s1mxc7LS89XAhPDUmWMgPf8V8AFJuxHNhIsZ4MF+O/30HNg19v5kot/Qh4gWNvcM8q30fBBbUHGGpAFWxMeAscDjZrYZ+DFwiaRdwjkTJB0d3n9U0t5BabqIDPfm0NxfKbAosY3cCJwqaf8wqz13kPNvAD4M/DNFFDM8xi0Ezpc0QtJhwLTYKU8SzU6mSmoG/hVoiR3fAXgNeEPSfqGvrQhtnyKpNTyivsaW/yMnA8ysi2gR7vuSpkhqlrQnkd6sJHrUh0gn90yxOPQLoiepo8NscGRYDNst468A0U2kB/hKGP9xwHuKnWxmLwH3AT8DlpvZ40VOvTG0uZuksUD+zHQJMD30me8j3oHoxvYykZH+92LjGcQWVJyhZoDnSXqDyDhcCHzGzJaGY/9C9GjxYHgM+Q2Qi0fcJ3x+g0iBfmBm94ZjFwH/Gh7dSlr1N7M7gEuJFq+eZpBFLDNbHcbz98AvBzj1ZODvgFeIjPqcWBtdRItqVwGriGYK8aiIM8P1rxPdpAbq59PAivD/90XglIHG76QnLPT+P+BiIj3+I9EMtj34LyGaNQK8LGlQP7yZPUc0A/x/wEuhvbMow+/bzN4kmsGfSqSPnyRvUbEA1xHNTovNfiHSzTuBR4j8xvltfgt4B/Aq0U0s3tYcIpfFKuAx+i/O5zOQLag48oTsjuM41WGozYAdx3HqBjfAjuM4VcINsOM4TpVwA+w4jlMlSk71tq2EbbuXAU3AVXkxi7kdYNcQbYVsAmaa2QJJRxFtOx4BvAmcZWYDRhsMGzbMRo0aVYZvMTRYv369mZnfbOsI1+n60OmqREGEzQJPEm0nXkm0lfEkM3ssds5sYLGZ/VDS/kRbLfeUdDDwVzN7XtLfAHea2YSB+hs9erStW7duoFPqGknrzWz04Gc6QwXX6frQ6WrdQd4DPG1my0Jc4Q1EcYxxDNgxvG8Fngcws8Vm9nyQLwVGSWrBcRxniFEtF8QE+u/7Xkm00SDOeUT7tc8ARlM4s9jxwMOxAPY+JJ1GlKCHESPKnmbVcRwnNbXsQzmJKIPTbkQJYn4e35oZ8n1+B/inQheb2Wwzm2xmk4cPr5qr23EcpyjVMsCr6J94Y7cgi/M5QjIYM3uAKAPaOICwx/1WYIaZ/aXso3UcxykD1TLADwH7KKr0MIIob+/cvHOeJUoejqR3ERnglxTVzppPFBXx+wqO2XEcJ1OqYoBDQuovEyXfeBy40cyWSrpA0rHhtG8AX1BUkuV64NSQg/TLRBUvzpG0JLx2qcLXcBzHKYmGSMbjITv1EbLjbMF1uj502lenUnLzC69w0bLVrOrexISWZs7eazzH77pTye2uW/wir925gt613TSNaWHHo/dk9ME+sXfKz/z581m0aBFmhiQmTZrE1KlTB79wEGbNmkV395YApZaWFmbOrGoBipqjlqMgao6bX3iFM594jpXdmzBgZfcmznziOW5+4ZWS2l23+EXW3vIUvWsjZe1d283aW55i3eIXMxi14xRn/vz5LFy4kNyTsJmxcOFC5s+fX1K7+cYXoLu7m1mzZhW5ojFxA5yCi5atZsPm/i6bDZuNi5atLqnd1+5cgW3qn5TfNm3mtTtXlNSu4wzGokWLUsmTkm98B5M3Km6AU7Cqu3Ax2WLypORmvknl5SCUyHlC0tOFChVKOkLSw5J6JJ2Qd6w3tiA6Nya/PyZ/XtJtQf4BSV2xY+eU/xs6hSi2BtQIa0O1gPuAUzChpZmVBYzthJbmktptGtNS0Ng2janMDuuQm+MKYrk5JM2N5+YgCgs8lajEUT4bzOygfKGZHR7r42bg9tjh+83soxkM3ykBSQWNbf+am0658BlwCs7eazyjhvVXzFHDxNl7jS9yRTJ2PHpP1Nz/T6HmYex49J4ltZuCQXNzmNkKM3uUbShgKGlH4EiiSstODTFp0qRU8qS0tBSePBSTNypugFNw/K47cfE7d2e3lmYE7NbSzMXv3L3kKIjRB+/CmOP26ZvxNo1pYcxx+2QZBTFc0sLY67S844VycwyYYS6PkaHdByV9vMDxjwMdZvZaTHaopEck3RG2lTtVYOrUqUyePLlvxiuJyZMnlxwFMXPmzK2MrUdBbI27IFJy/K47ZRJ2ls/og3cpZ9hZj5lNLlfjwB5mtkrSXsA9kjrztoifRFS1OcfD4Zo3JB1DNDPep4zjcwZg6tSpmYSdFWq3o6ODrq4uWltbaW9vz7yPoY4bYAeS5eYoipmtCv8uk3QfcDDwFwBJ44hcHP8QO/+12PsFkn4gaZyZrSnlSzjbRmdn51aGsq2treQ2582bx6ZN0ZpJV1cX8+bNAyi57XrCXRAOJMvNURBJY3P5mIOxfR8QX7w7AfhvM9sYu2ZXhWdeSe8h0sOXM/kmTio6Ozu5/fbb6erqAiJDefvtt9PZ2VlSux0dHX3GN8emTZvo6Ogoqd16ww2wkyg3h6RDJK0EPgFcKWlpuPxdwMKQs+NeYFZe9MR0olwecU4A/hSu+R4w3TzuqSrccccd9Pb29pP19vZyxx13lNRuzqAnlTcq7oJIyeoXbmfZXy5mY/dqRraMZ693nMn4XfOLeQw9zGwBsCBPdk7s/UNEron86/4AFH2mNLMPFJBdDlxewnCdjNiwYUMqeVJaW1sLGtvW1taS2q03fAacgtUv3M6f//xNNnY/Dxgbu5/nz3/+JqtfuH3Qax2nkWhvb6e5uX98fHNzsy/E5eEGOAXL/nIxmzf3nxls3ryBZX+5uEojcpzSKFZZudSKy21tbUybNq1vxtva2sq0adN8AS4PN8Ap2NhdOOdDMbnj1Dq77rprKrmTLW6AUzCypfCOt2Jyx6l1VqxYkUqelFwYWjy6Yt68eSVHV9QbboBTsNc7zmTYsP6PZsOGjWKvdxRKj+A4tU+5kvF4GFoyPAoiBbloh3qMgnCcLPEwtGS4AU7J+F0/5gbXqRtGjBjBm2++WVBeCh6Glgx3QThOA1PI+A4kT4qHoSXDZ8CO08CUa6aaCzfLOsdEveEG2HEamPb29n5JcyC7mWpbW5sb3EFwA+w4DYzPVKuLGiEHyujRo23dunXVHkbVkLTezEZXexxOdgwFnb7iiitYs2ZLhtFx48Zx+umnZ9J2vei0L8I5jpM5+cYXYM2aNVxxxRVVGlFt4gbYcZzMyTe+g8kbFTfAjuM4VcINsOM4TpVwA+w4TuaMGzculbxRqZoBljRF0hOSnpa0Va1qSW+XdK+kxZIeDdVzc8fODtc9Ienoyo7ccZzBOP3007cytllGQdQLVQlDk9QEPAkcBawkKgp5UryWmKTZwGIz+6Gk/YEFZrZneH89UaXdtwG/AfY1s978fnIMhZCdcpIkZEfSFOAyoAm4ysxm5R0/ArgUOICohttNsWO9QC7P4LNmlqsjdzXwfiC31epUM1sSCnJeBhwDrA/yh0v7lo1FljpdznCxcuFhaKXxHuBpM1tmZm8CNwD5GW4M2DG8bwWeD+8/BtxgZt1mthx4OrTnbCPhhngF8BFgf+CkcKOL8yxwKnBdgSY2mNlB4XVs3rGzYseWBNlHgH3C6zTghxl9FSclHi5WXaplgCcAz8U+rwyyOOcBnwqVeBcAZ6S4FkmnSVooaWFPT09W465XBr0hmtkKM3sU2JxBfx8D5ljEg8AYSZ7Vvgp4uFh1qeVFuJOAq81sN6JH1Z9LSjxeM5ttZpPNbPLw4Q2/43p47mYUXqflHU90UxuAkaHdByV9PO/YhcGHf4mkloz6c5y6oFoGeBWwe+zzbkEW53PAjQBm9gAwEhiX8FqnPz25m1F4zc64/T3MbDJwMnCppHcE+dnAfsAhwE7Av2Tcr+MUpZSF/kpRranhQ8A+kiYSGc/pRD/eOM8C7cDVkt5FZIBfAuYC10n6L6JFuH2A/63UwHn0Rui4ALpWQutu0H4OHHBixbovEyXd1MxsVfh3maT7gIOBv5hZrlppt6SfAbnaTX4TbQCqubgXW9foW+iXNDe+0A/8K3BjfKEf2LMiAwxUZQZsZj3Al4E7gceJ/hOWSrpAUm4R5xvAFyQ9QhT1cGrwGS4lmhk/BvwaOH2gCIhMefRGmPcV6HoOsOjfeV+J5EObvhuipBFEN8S5SS6UNDbnWpA0Dngf0d+GnF83RD18HPhTuGwuMEMR7wW6YsbaqSDF8v6Wmg+4Bhb3SlnorxhVc46a2QKiO05cdk7s/WNEP+ZC114IXFjWARai4wLYtKG/bNOGSD6EZ8Fm1iMpd0NsAn6auyECC81srqRDgFuBscA0Seeb2buBdwFXStpMdEOfFZtlXCvpLYCAJcAXg3wBkV//aaIwtM9W5ps6+bS3t3P77bfT27tlDtPU1FRyPuAKLO4Nl7Qw9nl2nmut0DrD3+W1cR5wl6QzgNHAh7IaXFIafnUqFV0r08mHEAluiA8RuQryr/sDUDB5rJkdWURuQG0HmjYQceNb6HON0hPWHUoht9D/n5IOJVro/xszyyLSJxFugNPQuhuPdm1HB4fRxQ608jrt/A8HtK6v9sicGibBJpe3A9cAY8I5M8MNsezccccdReVDPCl70oX+KRAt9EvKLfS/WJERUtthaDXHo/t8hXkcRRc7AqKLHZnHUTy6z1eqPTSnRkm4ySW3GHQwkf/9B5Ua34YNG1LJhxBJ1jVyC/3kLfRXDDfAKeh4ah2b6F/pdRPNdDzVuNucnUEZEotB9UYpC/2VHKe7IFJQqHrsQHLHIcPFoLCB5jSAESNGZD7QeqOUhf5K4TPgFJQrZMdpeBLt+hxKuzuPO+64VPJGxQ1wCtrb22lu7u+CyKqEt1O3lLLrc8jS1tbGcccd1zc5aW1t5bjjjhvqC3uZU9u30RrjgAMOALYu4Z2TO04BStn1OaRpa2tzgzsIboBTcsABB7jBdRKTZJML0WLQjyV9jWhBruKLQU51qEpC9krjCdnrI3m1s4Usdfr888/fSnbuuedm0na5qBeddgPcANSLsjpbcJ2uD512F4TjNDhDcQZcL3gUhOM0MIWM70ByJ1vcADuO41QJN8CO4zhVwn3AjuOUhfnz57No0SLMDElMmjSJqVOnVntYNYUbYMdxMmf+/PksXLglX7qZ9X12I7wFd0E4jpM5ixYtSiVvVNwAO04DU66kOcX2FzTCvoM0uAF2gEQlvI+Q9LCkHkkn5B3rlbQkvObG5NeGNv8k6aeSmoP8A5K6Yteck9+fUxkWL16cSp6UqA5rcnmj4gbYSVq14VngVOC6Ak1sMLODwuvYmPxaYD+imnGjgM/Hjt0fu+aCjL6Kk5Lly5enkidl0qRJqeSNii/CORCr2gAgKVe1IVfdGDNbEY4lLlgYr2sm6X8pUNTTqU9yC20eBTEwboAdSFa1YSBGhhLhPURl6W+LHwyuh08DX42JDw2lYJ4HzjSzpds0cqdmmTp1qhvcQXAD3BgMDwYyx2wzm51h+3uY2SpJewH3SOo0s7/Ejv8A+J2Z3R8+PxyueUPSMcBtwD4ZjsdxhgRugBuDHjObPMDxJFUbimJmq8K/yyTdBxwM/AVA0rnAW4B/ip3/Wuz9Akk/kDTOzNYk7dNx6gFfhHMgWQnvgkgaK6klvB9HVOTwsfD588DRwElmtjl2za4Ky+GS3kOkhy9n+H2chBTLeubZ0CqD5wNuAJLkTg2ugEvZUrXhwnjVBkmHALcCY4GNwAtm9m5Jfw9cCWwmMqSXmtlPQps9wDPA66GbW8zsglAh4p+JfMYbgK+b2R8y/tp1jet0feQDdgPcANSLsjpbcJ2uD512F4TjOE6VcAPsOI5TJapmgBNsfb0ktlX1SUlrY8e+K2mppMclfS+3oOM4jjOUqEoYWmzr61FEQf8PSZprZvGdV1+LnX8GUWgTYdHnfUCuNvz/AO8H7qvI4B3HcTKiWjPgvq2vZvYmkNv6WoyTgOvDewNGAiOAFqAZ+GsZx+o4jlMWtskASxodZrHbSqGtrxOK9LUHMBG4B8DMHgDuBVaH151m9niB606TtFDSwp6enhKG6jQyGei64xQlkQGWNEzSyZLmS3oR+DOwWtJjkv5D0t5lHON04CYz6w1j2Rt4F9FurQnAkZIOz7/IzGab2WQzmzx8uG/4c5JRZV13GoykM+B7gXcAZwO7mtnuZrYLcBjwIPAdSZ9K0W+ara/T2eJ+APgH4EEze8PM3gDuAA5N0bfjDETWuu44RUm0EUNSs5ltKvWc2LnDgSeBdiLD+xBwcn5GLEn7Ab8GJloYqKRPAl8ApgAKxy81s3nF+vOg9foIWs8haTSwMfdUlHHbmep6uchSpzs7O+no6KCrq4vW1lba29tpa2vLpO1yUQs6nYUeDjoDlnQU8ANJB4bPpxU6L41CmlkP8GXgTuBx4EYzWyrpAknxhN7TgRus/13iJqJEL53AI8AjAxlfZ+hTKbdAOXS91uns7GTevHl0dXUB0NXVxbx58+js7KzyyGqPcuhhEufoPxLt2/9XSTsDB6XtpBAhWfeCPNk5eZ/PK3BdL7HMWk5DcC/wGyK3wJ9yiX0k7QR8kMgtcKuZ/aLEfsqi67VMR0cHmzb1v59s2rSJjo6Omp8FV4HM9TCJAX7dzNYCZ0qaBRySftyOUxIfKjTrNLNXgJuBm0PS91JpOF3PzXyTyhuczPUwySLc/FhHM4E5aTpwnFJJ8sifkVug4XS9tbU1lbyRKYceDmqAzez2vM/fT9OB45SCpKMk/VjSQeFzQb9sFjSirr/xxhup5I1KufQwVYCspMnAN4E9wrUCzMwOGPBCx9l24n7ZnaiQX7ZRdL23t/ACfjF5A1MWPUy7Q+Fa4CyiCITE1XEdpwSq5Zd1XR/iSJoCXEZUZOAqM5tV4JwTgfOIUhw8YmYnF2muLHqY1gC/ZGaJStU4Tkb088uGxEyVwHV9CJMk4ZekfYgiGt5nZq9K2mWAJsuih2kN8LmSrgI6gO7YgG7JYjCOk08V/bINoestLS10d3cXlA9x+hJ+AUjKJfx6LHbOF4ArzOxVADN7sVhj5dLDtAb4s8B+RBnIco9lBtSVUjq1SYX9sg2h6zNnzmTWrFn9jHBLSwszZ26VonuoUSjh19/lnbMvgKTfE7kpzjOzXw/WcJZ6mNYAH2Jm70zbiVP7DOYvk3QEUdHOA4DpZnZT7Fgvka8U4FkzOzbIJxKlGt0ZWAR82szeVFRFeQ4wiaga8ifNbEWCYVbSL9swuj5Eje1wSQtjn2eb2ey0bQD7AB8gykfzO0ltwdc7EJnpYVoD/AdJ+8f9KM7QJ4m/DHgWOBU4s0ATG8ys0Krwd4BLzOwGST8CPgf8MPz7qpntLWl6OO+TCYZaSb+s63pt02Nmkwc4niTh10rgjyF2d7mkJ4kM8kOD9J2ZHqY1wO8FlkhaTuQXq8vQnAZkUH9ZboYqKdEdP5SJOhLIrSpfQ7Ta/MPQ9nlBfhNwuSTl5fwoRCX9sq7rQ5uHgH3CU9gqorwy+REOtxEVe/iZpHFELollCdrOTA/TGuApaTtwaoLBHteS+MsGYmRovweYZWa3Ebkd1obES7k2c0n3+/ozsx5JXeH8NYP0U0m/rOv6ECboVS7hVxPw01zCL2BhmMHeCXxY0mNAL3CWmb2coPnM9DCVATazZ9J24NQEgz2ulcoeZrZK0l7APZI6gXIkE6iYX9Z1fegzWMKv8MT19fBKQ2Z6mKokkaRrJI2JfR4r6adZDMSpKmkS5G+Fma0K/y4jKo56MNHi2piQ+zm/zb7+wvHWcP5g/EHS/knHVQqu684AZKaHaWvCHRBfIQzxcwdnMRCnqvT5yySNIPKXJVpkCIapJbwfR1Sx+rEwu7gXOCGc+hkgF0s5N3wmHL8ngf8Xtvhln5D0qKROSY8mGec2kJmuS5oSxvy0pIIhB5JODHlll0q6bhvH7FSGzPQwrQ94mKSxucDlsCfaC65lwM0vvMJFy1azqnsTE1qaOXuv8Ry/604V6TuJv0zSIcCtwFhgmqTzzezdRPX5rgyLc8OIfMC5xbt/AW6Q9G/AYuAnQf4T4OeSngZeITL4SaikXzYTXS/Djiyn+mSmh4lKEvWdLM0gCkC+MYg+AVxoZj/PakDloNZLEt38wiuc+cRzbNi85W8xapi4+J27Z2KEVQPlW7JA0jXAV3MzU0ljgf80s38sQ1+Z6LqkQ4kC/I8On88GMLOLYud8F3jSzK5K2m6t63S5qaZOZ6mHSasiHxrChOYQFcX8a3gdV+vGdyhw0bLV/YwvwIbNxkXLVldpRDVL2V1gZdD1QhEmE/LO2RfYV9LvJT0YNsU4tUtmepj0kWoGcEUIVP41UZn4F7alQ2drVnUXzuFcTN7AVMIFVg1dT7QjS1EO2tMARowYUeYhOQOQmR4musjM/jl0tB/wEeBqSa1Eiyy/Bn5vZahQ2yhMGLaJlZu3rmQyYZgb4Dz+E3hA0q/C508AF2bZQRl0PbMdWSF2ezZELogUY3CyJTM9TBUFYWZ/NrNLzGwK0S6n/wmd/3FbOncizl42m1G9G/vJRvVu5Oxlabe21zfBLXAcFXCBZajrSSJMbiOa/eYiSZLuyHKqQJZ6mGgGHFbAn8s9ioUFiuOBZ4BzLSpK52wjxz/zK1j/MhftdRqrWnZhQveLnL1sNse/dA/w42oPr+qEhawHLeIx+qcUzLqvTHW9zDuyMqGzs5OOjg66urpobW2lvb3dKyIXoBx6mCgKQtLDRBVBX1GUFesG4AyishzvMrMTBmygytT8ivElfwNdz20tb90dvvankpsf6lEQkn5ItDU655f9dbn8skNF17PS6c7OTubNm9evNH1zczPTpk2raSNcDZ0uhx4mdUE0xe78nyTKJXCzmX0L2LuUAThA+znQPKq/rHlUJHcws382s78lSuAzlsgv+4Ckf5d0RIi1zYqG0vWOjo5+xhdg06ZNdHR0VGlEtZDQyIAAAB8CSURBVEs59DCxAY5tKW0H7okd840YpXLAiTDte9GMF0X/TvteJHf6qNAaREPpeldX4ZQdxeROtnqYVKGuB34raQ2wAbgfQNLelCfpSuNxwIlucItQ4TWIhtL11tbWgsa2tbW1CqOpbcqhh4lmwGZ2IfAN4GrgsNi+/WFE/jHHKSdXAm9CX2WOWUQVNboIYVlZ0Wi63t7eTnNz/xDI5uZm2tvbqzSimiZzPUwaBSEzezBfbmZP5p3jsYlOOSjolwVulrQky44aTddzC20eBZGIzPUwqQviXkk3A7eb2bM5YYhrPIwos9W9RLMGx8maJknDLUru3k7YDRbI2i/bcLre1tbmBjcZmeth0oumAP8IXK+oxMdaYCRRXONdwKVmtjhppxq8AOQlwAfDx+2AXcxsTDj2duAqot1FBhxjyQo6OkOXSvplM9V1p67IXA9TZUMLnTUD44gKMQ5WPbTQ9U1EcXR96fmAk6xI8UNJZwAH5zINSbqPKCvV3ZK2Bzab2fqB+qz5OOAyM9TjgAEkvRcYD9xlZuuCbF9gezN7uEx9lqTr5cR1ujo6nbUepp42h/3qpaTpGrQAZB4nAeeGc/cHhpvZ3WEsb5QwDmeIUC2/bAa63tDU2w67cuhh2ooYWZAkPR8AkvYAJrIlFnNfYK2kWyQtlvQfxYKfJZ0maaGkhT09PYVOcYYO90o6I7if+pA0QtKRivKzfqbItU4VyO2wy4W4dXV1MW/ePDo7O6s8spLIXA+rYYDTMJ0oHWAu+9Rw4HDgTOAQYC/g1EIXmtlsM5tsZpOHD6+7+PlGYwpRjoTrJT2vqHTPMuApoiekS83s6moO0OlPne6wy1wPq2GZ0hSAnA6cHvu8ElgSc1/cRlSf6ScFrnXqBDPbCPwA+EEt+2WdLdTjDrty6GHqGbCiIozvCXufjwgByWlIVABSUT7WscADedeOkfSW8PlIypgZq5HQIIUjw9/6YUk9krZKSCNpR0krJV0ePu8gaUnstUbSpeHYqZJeih37fNJxmtkmM1tdCeObga43LJJSyYcaWelhqhlw+KF8lWjWuoRo9vkAkSFMRML0fBAZ5hviDm0z65V0JtCh6C+5CM/XWDJKUDgSeJbI3XNmkWa+Dfwu98HMXifKIJbrYxFwS+z8X5rZlzP5AmUgC11vZIqtQ9XJ/pXMSOuC+CqR7/VBM/tgmKX+e9pOzWwBsCBPdk7e5/OKXHs3cEDaPp0BGTQyJRdrraj6cT8kTQLeSpSib3KB4/sCuxDiJocImeh6o+I5JpKR1gWxMfhBkNRiZn8G3pn9sJwKkzgyJR9Jw4hKtBSbGUP0NPPLvPCc4yU9KukmSbsXu7BAf5VyC7iul0C955jISg/TzoBXShpDVELlbkmvEmUCcmqb4ZIWxj7Ptqi+WBZ8CVhgZisH8O9NBz4d+zwPuN7MuiX9E3ANCR7tK+wWcF0vgXrOMZGlHqYywGb2D+HteZLuBXYkeux0apseM9vKNRAjTWRKPocCh0v6ErA9MELSG2Y2E0DSgUSbZxblLrD+5XauAr6bsK+KuQVc10tn8eLF/eKAFy9eXBcGmAz1MJULQtJkSbcqKtvy/dDpokEuc2qfRJEphTCzU8zs7Wa2J5EbYk7O+AZOItpD34ek8bGPxwKPJxxnxdwCruulMWfOHJYvX95Ptnz5cubMmVOlEWVKZnqY1gVxLXAW0AlstRjjbDs3/uZMtnvzTka2rGdj93asH3E0J37o4or0nSQyRVEy6luJQgOnSTrfzN6doPkTgWPyZF+RdCzQA7xCkc00BaikW6BhdD3fWE6cOJEZM2aU1Ga+8R1MPsTITA9TJeOR9D9mdti2dFRNaj1xyY2/OZMxNpempt4+WW9vE2t1bCZGWHWQjCcfSe8HWokKI75ZhvZrWtez0ulCM1Uo3Qiff/75RY+de+6529xujlrR6VL1MO0M+FxJVwEdQHdOaGa3FL/EGYzt3ryTppG9/WRNTb1st/FOoDKz4KGGmf22zF00hK7X+Uy17JSqh2kN8GeB/YBmtjyWGf0D7J2UjGwpnE2zmLxRkTQZ+CawBzHdNbNyxIW7rpdAU1MTvb29BeVDnSz1MK0BPsTMPBYyY7q7t2PkyK2NbXf3dlUYTU1TSb+s63oJFDK+A8mHGJnpYdqNGH9QlJPXyZBh9+9Mb2//mUFvbxPD7t+5SiOqWV4ys7lmttzMnsm9ytRXQ+j6xIkTU8kdIEM9TDsDfi+wRNJyIr+YACvTI2DDsOdtL/Ls+p3p/vDrjBi5gTc3jqLprh3Y864X4aJqj66mqKRftiF0fcaMGWWJgqhzMtPDtAZ4StoOnMEZPn48b7/z+SgIjBFEKUfXMvxtb6vuwGqPSvplG0bXy2Fsx40bx5o1awrK64DM9HBbasIdSJQUHeB+M3skbaeVptbD0LrmzWP1t87BNm7sk2nkSMZ/+wJap00ruf1aCdkpFUlPVNIvW8u6Xus6DXDFFVf0M8Ljxo3j9NNPH+CK5FRTp7PUw7TpKL8KfIEtlv4Xkmab2fezGEyjkjOyL15yKT2rVzN8/Hh2+dr/ycT41hl/kLS/FSngmiWNpOvlqt2WlbGtQTLTw7QbMR4FDo1VAx0NPFDrfrGhMFsoJ3U0A34ceAdQdr9sret6Vjqdq90WLx/U3NzMtGnTajpvQxKdljQFuIxod+dVZjaryHnHAzcRRb4sLHRO3vmZ6WFaH7CIHJQ5eoPMcSpBJf2yDaHrA9Vuq2UDPBgJiwwgaQei5Dp/TNF8ZnqY1gD/DPijpFvD54/j9dicCmFmz1TQL9sQul6PtdsCgxYZCHwb+A5RXG8istTDVHHAZvZfRCuAr4TXZ83s0m3p2HHSEvyy1xJV19iFyC97Rjn6ahRdH8K124ZLWhh7nZZ3fNAiA5L+FtjdzOan6ThLPUxdFdnMHgYe3pbOHKdEPgf8Xcwv+x2iRNhlWRhrBF0vZ+22ci3uBQbLcT0goZLLf5E8E1+czPQwbT7gTwSfCZL+VdIt4S7iOJWgYn5Z1/XSyC3uxROyz5s3j87OzkoNYbAiAzsAfwPcJ2kF0cabuSHPw2BkpodptyJ/y8xel3QY8CEin9gPt6Vjx9kGcn7Z8ySdDzxI+fyyruslMNDiXoUYsMiAmXWZ2Tgz2zMUE3gQODZJFAQZ6mFaA5yz+lOJ6orNJ9q65ThlJ88vuwY4tYx+Wdf1Eqj24p6Z9QC5IgOPAzfmigyEYgCltJ2ZHqY1wKskXQl8ElggqWUb2nCcbULSJ4CnzOx7wBjgHEkHl6m7htD1ciXjKVZ+vpJl6c1sgZnta2bvMLMLg+wcM9uq3JaZfSDh7DdTPUyrUCcS3VGONrO1wE7Ewjckjd2WQThOQuJugSOJHvt+VKa+GkLXZ8yYsZWxzSIZT35J+sHkQ4zM9DBtVeT1xBJOmNlqYHXslA7AFyqcchF3C/zYzOZL+rdydNRIul6OZDyFEvEMJB9iZKaHWT9S1XzwoFMYSVMkPSHpaUkzCxw/QtLDknoknVDg+I6SVkq6PCa7L7S5JLx2CfIWSb8Mff1R0p4Jh1lLbgHX9cYlMz3MWnlLDx50Kk5s2+ZHgP2BkwokI3+WKGbyuiLNfBv4XQH5KWZ2UHi9GGSfA141s72BS4h2IiWhltwCruuNS2Z6WHeLCs420bdtM1R2zW3b7MPMVpjZoxQowSJpEvBW4K6E/X0MuCa8vwloV4KtV2a23sxuMbOnwufVZhbvs2IxTk7jkqUeuguiMSh522Yxwo6i/wTOLHLKz4L74VsxI9vXXwgX6gKyqL9USf1zXR+AWoiCqCKJdSO1AZY0VtJ7gk/wCElHxA63p23PqQg9ZjY59pqdYdtfAhaY2coCx04xszaipCWHA5/OsN9CZOoWyErXB/Ovx847XpIl3I1V07S3t28V8dDc3Ex7e0OYiMR6mDYh++eJUrftBiwh2r73AFEoBmb2Soq2BszVKekS4IPh43bALmY2JnZ8R6LMRreZ2ZfTfA9nKwbbtjkQhwKHS/oSsD0wQtIbZjbTzFYBhJCd64hcHXNi/a2UNBxoBV7O5qtkQ1a6Xua0iDVLLudDGXNB1AVpk/F8FTgEeNDMPihpP+Df03aaRCnN7Gux888A8gOdiy36OOnp27ZJZBynAycnudDMTsm9l3QqMNnMZgbDOsbM1khqBj4K/CacOhf4DJFBOwG4x7LI/pKtWyATXaeMaRFrnba2tkY1uGVzQWw0s40QhRKZ2Z+BbamNNOiiTx4nAdfnPmzDoo8zAEm2bUo6RNJK4BPAlZKWDtJsC3CnosoSS4gM+4/DsZ8AO0t6Gvg6UPSxPE74u+fLPhr7mOXzbVa6nllaREmn5fz4PT092zAUJwuy1MO0M+CVksYAtwF3S3oVeCZlG1BYKf+u0ImS9gAmAveEz7lFn08RJUkpSFhoOg1gxAjfwj8YZrYAWJAnOyf2/iGix/GB2rgauDq8Xwdspajh2EYiQ56WH0uaYWZ/ApB0EvB/gP8O7SZ2gSUgK10fEKVIixh897MhKkmU9VicxGSmh2l3wv1DeHuepHuJfHd3pGljG5gO3GRmud0nfYs+A0UuubLWJScAN0k6mWhRbwbw4XJ0lKGup0mLCLArUVrEpJm5nMqTmR6mXYRrAY4H9oxdexBwQcp+0yz6TAfi5VWLLvqkHMM2sW7xi7x25wp613bTNKaFHY/ek9EH71KJrhseM1smaTrRrPRZ4MNmtqEcfWWo6wP6182sCxgX6/c+4Ew3vrVLlnqY1gVxO1HM5iKiaqDbSqJFn7DwMZZosQYovuhTwlgSs27xi6y95SlsU7QXoXdtN2tveQrAjXAZkdRJ/9CenYiiZ/4oCStPpeJMdN3MeiTl/OtNwE9z/nVgYaHMXE5tUg49TGuAdzOzkiuCplDK6cANGa2Ql8xrd67oM745bNNmXrtzhRvg8vLRwU/JnEx0HQb3r+fJP5BFn05ZyFwP0xrgP0hqM7OS64okUUozO2+QNq4mLPpUgt61hSdCxeRONpjZMwCSvl7gcJekRWa2JONuM9N1pz4ohx6mNcCHAZ+VtIzosUzRuMryCFhzNI1pKWhsm8a0VGE0Dcnk8JoXPn8UeBT4oqRfmdl3M+yroXU9C8pclLOaZKaHSvN0H0LCtiJ3Z6hVRo8ebevWrSu5nXwfMICahzHmuH1q2gUhab2Zja72OEpF0u+AY8zsjfB5e2A+MAVYZGb5GdxK6aumdT0rnS4XuaKc8bpwzc3NTJs2LRMjXE2dzlIP086Ajy8gK9cjYM2RM7IeBVE1dqH/gtgm4K1mtkFS1n6ghtH1csxUByrKWQez4Mz0MK0BruQjYE0y+uBd3OBWj2uJVpxvD5+nAddJGs3WW3tLpSF0PX+mmisfD5RkKKtdlLPMZKaHqaMggL+NTb3PJZp6H0EUrlMXSjkQS360gEUPbWTj8FZG9nQx6ZCRHPTFY6o9rIbAzL4t6Q7gfUH0xVi87ClFLttWGkLXyzVTbW1tLWhs6yEdZZZ6mNYAV/IRsOZY8qMFPLBoGJubo6RsG5vH8MCiN+FHC9wIV4ig6JXYpNAQul6umWp7e3tBH3C9pKPMSg/TGuBKPgLWHAv/dwObR/SvNrK5aQQL//dVDvpilQbllIuG0PVyzVQ9HWUyUkVBAIRk0bmp9++HwpbJrFaMr/inDiiUf8KM06+s3Tt7vURBVJpa1vWsdLrc0Qrlol50Ou0MuJKPgDVH85uvsKll68o5zW9mmYTLqRUaQdfLOVM9//zzt5Kde+65JbdbT3hRzhS8sPM9DOvt7/4b1tvNCzvfU6UROU5tUsj4DiRvVNwAp2DSlz7Kyu1/RXP3y2BGc/fLrNz+V0z6UjVSFThO6eRcEDk/cC4MrbPTd2BXgtQuiEZm6l5T4Qy47OHLeGHdC+w6ele++rdfjeSOMwSp8w0TNY8b4JRM3WuqG1ynbqjzDRM1j7sgHGDw0umKyrI/LKlH0gkFju8oaaWky8Pn7STNl/RnSUslzYqde6qklyQtCa/Pl/fbOcUoFm5WDxsmhgJugJ14leqPAPsDJ0nKTyjyLFHdsuuKNFOoSvXFZrYfUUXr90n6SOzYL83soPC6qtTv4Gwb7e3tNDc395PV04aJWsddEA4kKJ1uZivCsc35F8eqVP+aKH8CZrYeuDe8f1PSwwxS1NOpPL5horq4AXYgRZXqfJJUqQ7VhacBl8XEx0s6AngS+JqZPVfoWqf8tLW1ZW5wjzvuOG655ZaCcmcL7oJoDIZLWhh7nZZh231VqgsdlDQcuB74Xm6GTZRhbM+Q3Pxu4JoMx+PUAB0dHankjYrPgBuDHjObPMDxNFWq8xmsSvVs4CkzuzR3gZm9HLv+Kuoks5izBY+uSIYbYAcSVqkuxEBVqiX9G9AK9ItykDTezFaHj8cCj5f6BZzaYtSoUWzYsHWl9lGjRlVhNLWLuyAczKwHyFWpfhy4MVelWtKxAJIOkbQS+ARwpaSlA7UpaTfgm0RRFQ/nhZt9JYSmPQJ8hSi6wnEaDp8BO8DgVarN7CEGiWKIV6kOPuECqePAzM4Gzi5pwE5NU2j2O5C8UfEZsOM4mVMLGzwSbC76uqTHJD0qqaNYIdZy4gbYcZzMqfYGj4SbixYTrVkcANxEFRaD3QA7jpM5bW1tTJs2rW/G29raWukk732bi8zsTSC3uagPM7s3bBgCeJAqbBRyH7DjOGWhHBs8UpB2c9HngDvKOqICuAF2HGcoMlxSvFrJbDObvS0NSfoU0Rb692cyshS4AXYcZyiSyeYiSR8iCpd8v5lVvNq1G+CU3LZ4Ff9x5xM8v3YDbxszirOOficfP3hCtYflOE5/Bt1cJOlg4Epgipm9WPkhVmkRLkF4yCWxXLFPSlob5AdJeiAE8T8q6ZOVHPdti1dx9i2drFq7AQNWrd3A2bd0ctvipLt2HcepBEk2FwH/QbR9/lfB1syt9DhTl6UvucMoPORJ4Cgix/hDwElm9liR888ADjazf5S0L2Bm9pSktwGLgHeZ2dqB+syqhPf7Zt3DqrVbB5JPGDOK3888suT2y0W9lPB2tpCVTg9V6kWnqzEDHjQ8JI+TiLJpYWZPmtlT4f3zwIvAW8o83j6eL2B8B5I7juMMRDUMcKHwkIJO1LAzZSKwVd13Se8BRgB/KXLtabn0iz09PSUPGuBtYwonEikmdxzHGYha34gxHbjJzHrjQknjgZ8DnzWzrSo0AJjZbDObbGaThw/PZq3xrKPfyajmpn6yUc1NnHX0OzNp33GcxqIaURBpcs9OB06PCyTtCMwHvmlmD5ZlhEXIRTt4FIRTT8yZM4fly5f3fZ44cSIzZsyo4ogah2oswg0nWoRrJzK8DwEnm9nSvPP2I6oxNtHCICWNINqtMi+e4HswfMGiPhYsnC1kpdP5xjdHFka4nIa9XnS64i6IhOEhEM1+b7D+d4gTgSOAU2NhagdVbPCOU2cUMr4DyZNSyLAvX76cOXPmlNRuvVGVjRiD5Z4Nn88rcN0vgF+UdXCO45RMuQx7vVHri3CO4zh1ixtgx2lgJk6cmEruZIsbYMdpYHbeeedUcidb3AA7QKL8HEdIelhSj6QTChzfUdJKSZfHZJMkdYY2vydJQb6TpLslPRX+HVveb+cUY9GiRankTra4AXaSlm95lqh68XVFmvk28Ls82Q+BLwD7hNeUIJ8JdJjZPkBH+Fy31HJtsmJhqJUOT21U3AA7kKx8ywozexTYauehpEnAW4G7YrLxwI5m9mAIJZwDfDwc/hhwTXh/TUxed9R6bbLwUJJYnpRzzz03lbxR8XzAjcFg1QPSlm/pQ9Iw4D+BTwEfymtzZV6buS2DbzWz1eH9C0TGu17pu7kBSMrd3Pqy/5nZvbHzHyT6v6wIkyZNYuHChQXlpeLGdnDcADcGg1UPKIUvAQvMbOW2zJrMzCTV8/NuZrXJJJ0GnAYwYsSITAY3depUIPL5mhmSmDRpUp/cKS9ugB1Il58jn0OBwyV9iSi59QhJbwCX0b/KbLzNv0oab2arg6uiKtUIao3BapOFp5bZEG1FzqrfqVOnusGtEm6Aa4Rrb3yMVb99ge16jfVNYsL7d+WUE/NdhWVj0PItxTCzU3LvJZ1K5MucGT6/Jum9wB+BGcD3w6lzgc8As8K/t2fzNWqSIVGbzKkOvghXA1x742O8dM9qRveCEKN74aV7VnPtjQWLhGROkvwckg6RtBL4BHClpKXFW+zjS8BVwNNEeZtzj9azgKMkPUXkN56V6ReqLfpubiGZ1HSiG1Afsdpkx1arNplTHSqeDa0a1Ho2tO+efg+je7eWr2uC/3tF6aWO6iVz1FBF0jHApUAT8FMzu1DSBcBCM5sr6TdAG5BbmHzWzI4t0hxQ+zpdbupFp90FUQNs12vA1gtYkdwZ6gyWfMrMPrTVRU5D4Aa4BljfpIIz4PVNpcViOk4SOjs76ejooKuri9bWVtrb22lra6vZdusJ9wHXABPevyub6D/b3YQx4f27VmlETqPQ2dnJvHnz6OrqAqCrq4t58+bR2dlZk+3WG26Aa4BTTtyftxw5nnVNYBjrmuAtR46vZBSE06B0dHSwadOmfrJNmzbR0dFRk+3WG+6CqBFOOXF/cIPrVJjcDDWpvNrt1hs+A3acBqa1tTWVvNrt1htugB2ngWlvb6e5ubmfrLm5mfb29pLbHTasv3kZNmxYye3WG+6CcJwGJheVUI5ohfzcIKVmWKtH3AA7ToPT1taWeXhYR0cHvb39Yyt7e3vp6OjwULQYboAdp8GZNWsW3d1b0k+0tLQwc2ZpOfJ9ES4Z7gN2nAYm3/gCdHd3M2tWaek5fBEuGW6AHaeByTe+g8mTUq7FvXrDDbDjOJnT1tbGgQce2LfwJokDDzzQ/b95uAF2HCdzOjs7WbhwYV9xTzNj4cKFvhU5DzfAjuNkzq233ppK3qi4AXYcJ3O83H0y3AA7TgPj0QrVxQ2w4zQwHq1QXapmgCVNkfSEpKclbRX1LekSSUvC60lJa2PHPiPpqfD6TGVHXp8k+HscIelhST2STojJ9wjyJZKWSvpikO8Q+/stkbRG0qXh2KmSXood+3zlvqkTp62tjWnTpvXNeFtbW5k2bVrJ0QpNTU2p5I1KVXbCSWoCrgCOAlYCD0maa2Z9VSjN7Gux888ADg7vdwLOJSrfbcCicO2rFfwKdUWSvwfwLHAqcGbe5auBQ82sW9L2wJ/Ctc8DB8X6WATcErvul2b25ey/jZOWcmxF3rx5cyp5o1KtrcjvAZ42s2UAkm4APgYUKwN8EpHRBTgauNvMXgnX3g1MAa4v64gDj99/L/ffMIfXX17DDjuP4/DpM3jX4R+s2XYTMujfw8xWhGP9fkFm9mbsYwsFnqok7QvsAtyf9cCd0pkzZw7Lly/v+zxx4kRmzJhRUpu1sAgnaQpwGVEx1KvMbFbe8RZgDjAJeBn4ZE7PK0W1XBATgOdin1cG2VZI2gOYCNyT5lpJp0laKGlhT09PJoN+/P57uWv25by+5iUw4/U1L3HX7Mt5/P57a7LdGMNz/xfhdVre8cR/j0JI2l3So6GN74TZb5zpRDPe+K/veEmPSrpJ0u4pvouTIfnGF2D58uXMmTOnSiPKhthT3UeA/YGTJOVXPPgc8KqZ7Q1cAnynsqMcGotw04GbzKxA2crimNlsM5tsZpOHD89mon//DXPoebP/Fs2eN7u5/4bSlLVc7caby/1fhNfsrBoGMLPnzOwAYG/gM5LemnfKdPo/ocwD9gzX3A1ck+V4nOTkG9/B5EOIvqe68JSWe6qL8zG26N5NQLsqnDOzWgZ4FRCf9ewWZIXI//GmuTZTXn95TSp5tdtNQSb/p2Hm+yfg8JxM0oHAcDNbFDvvZTPL3XGuInoEdJw0ZPFU13eOmfUAXcDO5RpwIaplgB8C9pE0UdIIIiM7N/8kSfsBY4EHYuI7gQ9LGitpLPDhICs7O+w8LpW82u2mINHfoxCSdpM0KrwfCxwGPBE75STy/POSxsc+Hgs8XsLYncakrE91laIqBjjcbb5MZDgfB240s6WSLpB0bOzU6cANcd9hWHz7NpHReAi4ILcgV24Onz6D4SNa+smGj2jh8OmlLViUq92kJPl7SDpE0krgE8CVkpaGy98F/FHSI8BvgYvNLL7h/0S2XiD9SghZewT4ClF0hVMFJk6cmEqelHHjCk8eisnLQJKnur5zJA0HWokW4yqGGmFr4OjRo23dunWZtDUUoyAkrTez0Zk05tQEWep0OaIgAK644grWrNniRhs3bhynn356ye3C4DodDOqTQDuRoX0IONnMlsbOOR1oM7MvSpoOHGdmJ2YywIS4AW4A3ADXH67Tg+u0pGOAS4nC0H5qZhdKugBYaGZzJY0Efk60x+AVYHouFLNSuAFuANwA1x+u0/Wh00MhDM1xHKcucQPsOI5TJdwAO47jVAk3wI7jOFXCDbDjOE6VaIgoiJDBa0O1x1FFRpmZ32zrCNfp+tDphjDAjuM4tciQv4M4juMMVdwAO47jVAk3wI7jOFXCDbDjOE6VcAPsOI5TJdwAO47jVAk3wI7jOFXCDbDjOE6VcAPsOI5TJf4//YUOx46/UUIAAAAASUVORK5CYII=\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "fig, axs = plt.subplots(1,2, figsize = (5,4))\n",
        "      \n",
        "ax0 = axs[0].twinx()\n",
        "ax0.set_ylabel(\"gk_soma (S/cm$^2$)\")\n",
        "for param_set in hall_of_fame:\n",
        "    axs[0].plot(0, param_set[0], \"o\") \n",
        "    axs[0].set_ylabel(\"gna_soma (S/cm$^2$)\")\n",
        "    ax0.plot(1, param_set[1], \"o\")\n",
        "    axs[0].set_title(\"Best individuals\")\n",
        "\n",
        "ax1 = axs[1].twinx()\n",
        "axs[1].set_ylabel(\"gna_soma (S/cm$^2$)\")\n",
        "ax1.set_ylabel(\"gk_soma (S/cm$^2$)\")\n",
        "for param_set in list(hist.genealogy_history.values())[:100]:\n",
        "        axs[1].plot(0,param_set[0], \"o\", color = \"gray\")\n",
        "        ax1.plot(1,param_set[1], \"o\", color = \"gray\")\n",
        "        axs[1].set_title(\"Other individuals\")\n",
        "      \n",
        "for ax in axs:\n",
        "    ax.set_xlim([-1,2])\n",
        "    ax.set_xticks([])\n",
        "    \n",
        "    \n",
        "fig.tight_layout()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gH4yHJ7bQqKU"
      },
      "source": [
        "The best individual found during the optimisation is the first individual of the hall of fame."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 30,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "X7e6bbdnQqKU",
        "outputId": "5da2101f-a1ce-477d-fb3d-549231dcbdf4"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Best individual: [0.7208269195525907, 0.13947171574556189]\n"
          ]
        }
      ],
      "source": [
        "best_ind = hall_of_fame[0]\n",
        "\n",
        "print(f'Best individual: {best_ind}' )"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gowwLF8VQqKV"
      },
      "source": [
        "We can make use of a convenience function of the cell evaluator to return us a dictionary of parameters."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 31,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "LugrKRuuQqKV",
        "outputId": "4778304f-507e-4574-e5c8-22f17120888f"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "{'gna_soma': 0.7208269195525907, 'gk_soma': 0.13947171574556189}\n"
          ]
        }
      ],
      "source": [
        "best_ind_dict = cell_evaluator.param_dict(best_ind)\n",
        "print(best_ind_dict)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rJwGc5jFQqKV"
      },
      "source": [
        "We can now use this dictionary of parameters to run a simulation and give scores to the model, as we did previously."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 32,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 486
        },
        "id": "xgEVvu2pQqKV",
        "outputId": "035d4503-2e4d-47aa-976b-22a03006be0b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Score: {objectives}\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 4 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x180 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "responses = twostep_protocol.run(cell_model=simple_cell, param_values=best_ind_dict, sim=nrn)\n",
        "plot_responses(responses)\n",
        "\n",
        "objectives = score_calc.calculate_scores(responses)\n",
        "print(\"Score: {objectives}\")\n",
        "\n",
        "plot_objectives(objectives)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tfspmfR9QqKV"
      },
      "source": [
        "\n",
        "Let's have a look at the optimisation algorithm statistics. We can plot the minimal score (sum of all the scores) found in every generation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 33,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 279
        },
        "id": "6B4giUhLQqKW",
        "outputId": "aaaa84f6-df6d-4449-dad4-1987494bd2ec"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ],
      "source": [
        "gen_numbers = logs.select('gen')\n",
        "min_fitness = logs.select('min')\n",
        "max_fitness = logs.select('max')\n",
        "\n",
        "plt.plot(gen_numbers, min_fitness, label='min fitness', color = 'k')\n",
        "plt.xlabel('generation #')\n",
        "plt.ylabel('score (# std)')\n",
        "plt.legend()\n",
        "plt.xlim(min(gen_numbers) - 1, max(gen_numbers) + 1) \n",
        "plt.ylim(0.9*min(min_fitness), 1.1 * max(min_fitness));"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ka3O4YQDQqKW"
      },
      "source": [
        "We can observe a progressive convergence of the model scores towards smaller values. This means that the model features approximating the experimental ones."
      ]
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "file_extension": ".py",
      "mimetype": "text/x-python",
      "name": "python",
      "nbconvert_exporter": "python",
      "pygments_lexer": "ipython3",
      "version": "3.8.10"
    },
    "colab": {
      "provenance": []
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}