From a84e0a94f3043e933b5129d0055af7af564ad6f5 Mon Sep 17 00:00:00 2001 From: chaoming Date: Mon, 11 Dec 2023 18:15:28 +0800 Subject: [PATCH 1/3] update doc --- brainpy/__init__.py | 2 +- brainpy/_src/running/pathos_multiprocessing.py | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/brainpy/__init__.py b/brainpy/__init__.py index 1342eb9a0..272a7a0a7 100644 --- a/brainpy/__init__.py +++ b/brainpy/__init__.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- -__version__ = "2.4.6.post2" +__version__ = "2.4.6.post4" # fundamental supporting modules from brainpy import errors, check, tools diff --git a/brainpy/_src/running/pathos_multiprocessing.py b/brainpy/_src/running/pathos_multiprocessing.py index f652217d9..e3eebe510 100644 --- a/brainpy/_src/running/pathos_multiprocessing.py +++ b/brainpy/_src/running/pathos_multiprocessing.py @@ -136,7 +136,7 @@ def cpu_ordered_parallel( >>> >>> def simulate(inp): >>> inp = bm.as_jax(inp) - >>> hh = bp.neurons.HH(1) + >>> hh = bp.dyn.HH(1) >>> runner = bp.DSRunner(hh, inputs=['input', inp], >>> monitors=['V', 'spike'], >>> progress_bar=False) @@ -194,7 +194,7 @@ def cpu_unordered_parallel( >>> >>> def simulate(inp): >>> inp = bm.as_jax(inp) - >>> hh = bp.neurons.HH(1) + >>> hh = bp.dyn.HH(1) >>> runner = bp.DSRunner(hh, inputs=['input', inp], >>> monitors=['V', 'spike'], >>> progress_bar=False) From d2d03f8184e200e88ac7d20a0d570309ccfb8843 Mon Sep 17 00:00:00 2001 From: chaoming Date: Mon, 11 Dec 2023 18:15:57 +0800 Subject: [PATCH 2/3] =?UTF-8?q?add=20=E7=AC=AC=E4=BA=8C=E5=B1=8A=E7=A5=9E?= =?UTF-8?q?=E7=BB=8F=E8=AE=A1=E7=AE=97=E5=BB=BA=E6=A8=A1=E4=B8=8E=E7=BC=96?= =?UTF-8?q?=E7=A8=8B=E5=9F=B9=E8=AE=AD=E7=8F=AD?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 9c74b82d1..5373a33b9 100644 --- a/README.md +++ b/README.md @@ -79,6 +79,7 @@ We provide a Binder environment for BrainPy. You can use the following button to - **[brainpy-datasets](https://github.com/brainpy/datasets)**: Neuromorphic and Cognitive Datasets for Brain Dynamics Modeling. - [《神经计算建模实战》 (Neural Modeling in Action)](https://github.com/c-xy17/NeuralModeling) - [第一届神经计算建模与编程培训班 (First Training Course on Neural Modeling and Programming)](https://github.com/brainpy/1st-neural-modeling-and-programming-course) +- [第二届神经计算建模与编程培训班 (Second Training Course on Neural Modeling and Programming)](https://github.com/brainpy/2st-neural-modeling-and-programming-course) ## Citing From 58396682f3b56eb140dfdf0ba4a322aa167ba5c9 Mon Sep 17 00:00:00 2001 From: chaoming Date: Tue, 12 Dec 2023 15:45:42 +0800 Subject: [PATCH 3/3] [doc] add conductance neuron model tutorial --- README.md | 2 +- docs/quickstart/installation.rst | 2 +- .../build_conductance_neurons.ipynb | 4 +- .../build_conductance_neurons_v2.ipynb | 1120 +++++++++++++++++ docs/tutorial_building/index.rst | 2 +- 5 files changed, 1125 insertions(+), 5 deletions(-) create mode 100644 docs/tutorial_building/build_conductance_neurons_v2.ipynb diff --git a/README.md b/README.md index 5373a33b9..9578bbd42 100644 --- a/README.md +++ b/README.md @@ -79,7 +79,7 @@ We provide a Binder environment for BrainPy. You can use the following button to - **[brainpy-datasets](https://github.com/brainpy/datasets)**: Neuromorphic and Cognitive Datasets for Brain Dynamics Modeling. - [《神经计算建模实战》 (Neural Modeling in Action)](https://github.com/c-xy17/NeuralModeling) - [第一届神经计算建模与编程培训班 (First Training Course on Neural Modeling and Programming)](https://github.com/brainpy/1st-neural-modeling-and-programming-course) -- [第二届神经计算建模与编程培训班 (Second Training Course on Neural Modeling and Programming)](https://github.com/brainpy/2st-neural-modeling-and-programming-course) +- [第二届神经计算建模与编程培训班 (Second Training Course on Neural Modeling and Programming)](https://github.com/brainpy/2nd-neural-modeling-and-programming-course) ## Citing diff --git a/docs/quickstart/installation.rst b/docs/quickstart/installation.rst index 41c6341fa..2e0bb1905 100644 --- a/docs/quickstart/installation.rst +++ b/docs/quickstart/installation.rst @@ -96,7 +96,7 @@ If you want to install a CPU-only version of `jax` and `jaxlib`, you can run pip install --upgrade "jax[cpu]" If you want to install JAX with both CPU and NVidia GPU support, you must first install -`CUDA`_ and `CuDNN`_, if they have not already been installed. Next, run +`CUDA`_ and `CuDNN`_, if they have already been installed. Next, run .. code-block:: bash diff --git a/docs/tutorial_building/build_conductance_neurons.ipynb b/docs/tutorial_building/build_conductance_neurons.ipynb index d3c289bb4..3656cd245 100644 --- a/docs/tutorial_building/build_conductance_neurons.ipynb +++ b/docs/tutorial_building/build_conductance_neurons.ipynb @@ -70,7 +70,7 @@ "source": [ "On the other hand, simplified models do not care about the physiological features of neurons but mainly focus on how to reproduce the exact spike timing. Therefore, they are more simplified and maybe not biologically explicable.\n", "\n", - "BrainPy provides a large volume of [predefined neuron models](../apis/brainpy.dyn.neurons.rst) including conductance-based and simplified models for ease of use. In this section, we will only talk about how to build conductance-based models by ion channels. Users please refer to [Customizing Your Neuron Models](customize_neuron_models.ipynb) for more information." + "BrainPy provides a large volume of predefined neuron models including conductance-based and simplified models for ease of use. In this section, we will only talk about how to build conductance-based models by ion channels. Users please refer to [Customizing Your Neuron Models](customize_neuron_models.ipynb) for more information." ], "metadata": { "collapsed": false @@ -234,7 +234,7 @@ "source": [ "Here the `HH` class should inherit the superclass **`brainpy.dyn.CondNeuGroup`**, which will automatically integrate the current flows by calling the `current()` function of each channel model to compute the neuronal activity when running a simulation.\n", "\n", - "Surprisingly, the model contruction is finished! Users do not need to implement the update function of the neuron model as `brainpy.dyn.CondNeuGroup` has its own way to update variables (like the membrane potential `V` and spiking sequence `spike`) implicitly." + "Surprisingly, the model construction is finished! Users do not need to implement the update function of the neuron model as `brainpy.dyn.CondNeuGroup` has its own way to update variables (like the membrane potential `V` and spiking sequence `spike`) implicitly." ] }, { diff --git a/docs/tutorial_building/build_conductance_neurons_v2.ipynb b/docs/tutorial_building/build_conductance_neurons_v2.ipynb new file mode 100644 index 000000000..6ba02c79a --- /dev/null +++ b/docs/tutorial_building/build_conductance_neurons_v2.ipynb @@ -0,0 +1,1120 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "5E26ADFB269D45FABC0223BD1463282B", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [] + }, + "source": [ + "# Building Conductance-based Neuron Models\n", + "\n", + "@[Xiaoyu Chen](mailto:c-xy17@tsinghua.org.cn) @chaoming0625\n", + "\n", + "\n", + "In this section, we try to understand how to build conductance-based biophysical neuron models. \n" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "id": "0E2419D0D67748C4A403D86E8FF46E9F", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.608344400Z", + "start_time": "2023-12-12T07:45:24.516805500Z" + } + }, + "source": [ + "import numpy as np\n", + "\n", + "import brainpy as bp\n", + "import brainpy.math as bm" + ], + "outputs": [], + "execution_count": 16 + }, + { + "cell_type": "markdown", + "source": [ + "There are basically two types of neuron models: **conductance-based models** and **simplified models**. In conductance-based models, a single neuron can be regarded as a electric circuit, where the membrane is a capacitor, ion channels are conductors, and ion gradients are batteries. The neuronal activity is captured by the current flows through those ion channels. Sometimes there is an external input to this neuron, which can also be included in the equivalent circuit (see the figure below which shows potassium channels, sodium channels and leaky channels).\n", + "\n", + "\n", + "\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "On the other hand, simplified models do not care about the physiological features of neurons but mainly focus on how to reproduce the exact spike timing. Therefore, they are more simplified and maybe not biologically explicable.\n", + "\n", + "BrainPy provides a large volume of predefined neuron models including conductance-based and simplified models for ease of use. In this section, we will only talk about how to build conductance-based models by ion channels. Users please refer to [Customizing Your Neuron Models](customize_neuron_models.ipynb) for more information." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "0E98C95518804B04A68B30517417C2F9", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "## ``master_type`` organizes structures between neurons and ion channels " + ] + }, + { + "cell_type": "markdown", + "source": [ + "When defining a conductance neuron model, one additional thing need to be pay attention to is ``master_type``. " + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "5D85B950EA9C45A3B0E7864B8EE0002E", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "``master_type`` determines what information will be passed into ``.reset_state()`` and ``update()`` function in a model." + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "4EC7D64F4413453E8A2AAA255A3E26FA", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.627266300Z", + "start_time": "2023-12-12T07:45:24.610675600Z" + } + }, + "source": [ + "class IK(bp.dyn.IonChannel):\n", + " master_type = bp.dyn.CondNeuGroup\n", + "\n", + " def update(self, V, *args, **kwargs):\n", + " pass\n", + "\n", + " def reset_state(self, V, *args, **kwargs):\n", + " pass" + ], + "outputs": [], + "execution_count": 17 + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "21423718EEF74EBE8339E18D2DD981AD", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "For the above ``IK`` model, its ``master_type: bp.dyn.CondNeuGroup`` will give ``V`` variable into this node. Therefore, ``IK`` model can utilize ``V`` to update or reset its states. " + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "E3BB82A89B20456983C0CCE92515A5D4", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.656512800Z", + "start_time": "2023-12-12T07:45:24.631018600Z" + } + }, + "source": [ + "class ICa(bp.dyn.IonChannel):\n", + " master_type = bp.dyn.Calcium\n", + "\n", + " def update(self, V, C, E, *args, **kwargs):\n", + " pass\n", + "\n", + " def reset_state(self, V, C, E, *args, **kwargs):\n", + " pass" + ], + "outputs": [], + "execution_count": 18 + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "1A0AF692B85A4CC7BBA24AB8329A5E34", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "For ``ICa`` class, its ``master_type (bp.dyn.Calcium)`` will deliver the concentration of Calcium ``C`` and the reversal potential of Calcium ion ``E`` into this node. Moreover, since the ``master_type`` of ``bp.dyn.Calcium`` is ``bp.dyn.CondNeuGroup``, it will inherit the passing of ``bp.dyn.CondNeuGroup`` and deliver ``V`` into ``ICa`` class too. " + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "56388C240BE1479DA52C262FEE97DF97", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.656606800Z", + "start_time": "2023-12-12T07:45:24.633194500Z" + } + }, + "source": [ + "class ICaNa(bp.dyn.IonChannel):\n", + " master_type = bp.mixin.JointType[bp.dyn.Calcium, bp.dyn.Sodium]\n", + "\n", + " def update(self, V, Ca_info, Na_info, *args, **kwargs):\n", + " pass\n", + "\n", + " def reset_state(self, V, Ca_info, Na_info, *args, **kwargs):\n", + " pass" + ], + "outputs": [], + "execution_count": 19 + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "4147B3FC5B0A43D4B419827E3C79443A", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "If an ion channel depends on more than two ion types, it can define ``master_type`` as a joint type by using ``brainpy.mixin.JointType``. For example, the above ``ICaNa`` class depends on ``bp.dyn.Calcium`` and ``bp.dyn.Sodium``, so the ``update()`` and ``reset_state()`` function depends on information of both subclasses and their parents. " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "5CC1AB8DF1064F2EBAD74D044B419287", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "For an existing ion channel, users can check the ``master_type`` using:" + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "8B15300C84414E49AB3A165006637822", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.682922Z", + "start_time": "2023-12-12T07:45:24.661277800Z" + } + }, + "source": [ + "bp.dyn.INa_Ba2002v2.master_type" + ], + "outputs": [ + { + "data": { + "text/plain": "brainpy._src.dyn.ions.sodium.Sodium" + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 20 + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "C1A21D323CCB49FBA383DACBA78B47B4", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.714434800Z", + "start_time": "2023-12-12T07:45:24.687290100Z" + } + }, + "source": [ + "bp.dyn.INa_Ba2002.master_type" + ], + "outputs": [ + { + "data": { + "text/plain": "brainpy._src.dyn.neurons.hh.HHTypedNeuron" + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "execution_count": 21 + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "F322DE431E574DE3AA842923B5D973C2", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "## Build a HH model by composing existing ion channels" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "C54B6D88EBFD4F13855F3A286A5B32E6", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "Instead of building a conductance-based model from scratch, we can utilize ion channel models as building blocks to assemble a neuron model in a modular and convenient way. Now let's try to construct a **Hodgkin-Huxley (HH) model** (jump to [here](customize_neuron_models.ipynb) for the complete mathematical expression of the HH model).\n", + "\n", + "\n", + "The HH neuron models the current flows of potassium, sodium, and leaky channels. We can import the other channel models from ``brainpy.dyn.ions`` and ``brainpy.dyn.channels`` modules. Then we wrap these three channels into a single neuron model:\n", + "\n", + "Here is an example by building a HH neuron model by composing existing ion channels. " + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "65FBA0F61EB545F3B25800C317844898", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.771312300Z", + "start_time": "2023-12-12T07:45:24.718304700Z" + } + }, + "source": [ + "class HH(bp.dyn.CondNeuGroupLTC):\n", + " def __init__(self, size):\n", + " super().__init__(size)\n", + "\n", + " self.INa = bp.dyn.INa_HH1952(size)\n", + " self.IK = bp.dyn.IK_HH1952(size)\n", + " self.IL = bp.dyn.IL(size, E=-54.387, g_max=0.03)" + ], + "outputs": [], + "execution_count": 22 + }, + { + "cell_type": "markdown", + "source": [ + "Here the `HH` class should inherit the superclass **`brainpy.dyn.CondNeuGroup`**, which will automatically integrate the current flows by calling the `current()` function of each channel model to compute the neuronal activity when running a simulation.\n", + "\n", + "Surprisingly, the model construction is finished! Users do not need to implement the update function of the neuron model as `brainpy.dyn.CondNeuGroupLTC` has its own way to update variables (like the membrane potential `V` and spiking sequence `spike`) implicitly.\n", + "\n", + "Now let's run a simulation of this HH model to examine the changes of the inner variables.\n" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "E51BBF72FA484236A4F1E4D3D7E7A466", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:24.983869Z", + "start_time": "2023-12-12T07:45:24.724898100Z" + } + }, + "source": [ + "hh = HH(1)\n", + "\n", + "runner = bp.DSRunner(hh, monitors={'na-p': hh.INa.p, 'na-q': hh.INa.q, 'k-p': hh.IK.p, 'v': hh.V})\n", + "\n", + "inputs = np.ones(1000) * 4.\n", + "_ = runner.run(inputs=inputs)\n" + ], + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/1000 [00:00", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 24 + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "295C0E829D87444B90898633AD1EA4D4", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.169872Z", + "start_time": "2023-12-12T07:45:25.092543900Z" + } + }, + "source": [ + "bp.visualize.line_plot(runner.mon.ts, runner.mon['v'], show=True)" + ], + "outputs": [ + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 25 + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "FB94957B4BB9418AB1D4E9BFD69DFE38", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "## Customizing ion channels" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "ECAE729288DB4CBB9AB85A360875D39A", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "To customize an ion channel that can be composed using the above interface, users should define a normal ``DynamicalSystem`` with the specification of ``master_type``. Below we will show several examples. " + ] + }, + { + "cell_type": "markdown", + "source": [ + "As we have known, ion channels are crucial for conductance-based neuron models. So how do we model an ion channel? Let's take a look at the potassium channel for instance.\n", + "\n", + "\n", + "\n", + "The diagram above shows how a potassium channel is changed to an electric circuit. By this, we have the differential equation:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "c_\\mathrm{M} \\frac{\\mathrm{d}V_\\mathrm{M}}{\\mathrm{d}t} &= \\frac{E_\\mathrm{K} - V_\\mathrm{M}}{R_\\mathrm{K}} \\\\\n", + "&= g_\\mathrm{K}(E_\\mathrm{K} - V_\\mathrm{M}),\n", + "\\end{align}\n", + "$$\n", + "\n", + "in which $c_\\mathrm{M}$ is the membrane capacitance, $\\mathrm{d}V_\\mathrm{M}$ is the membrane potential, $E_\\mathrm{K}$ is the equilibrium potential of potassium ions, and $R_\\mathrm{K}$ ($g_\\mathrm{K}$) refers to the resistance (conductance) of the potassium channel. We define currents from inside to outside as the positive direction.\n", + "\n", + "In the equation above, the conductance of potassium channels $g_\\mathrm{K}$ does not remain a constant, but changes according to the membrane potential, by which the channel is categorized as **voltage-gated ion channels**. If we want to build an ion channel model, we should figure out how the conductance of the ion channel changes with membrane potential.\n", + "\n", + "Fortunately, there has been a lot of work addressing this issue to formulate analytical expressions. For example, the conductance of one typical potassium channel can be written as:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "g_\\mathrm{K} &= \\bar{g}_\\mathrm{K} n^4, \\\\\n", + "\\frac{\\mathrm{d}n}{\\mathrm{d}t} &= \\phi [\\alpha_n(V)(1-n) - \\beta_n(V)n],\n", + "\\end{align}\n", + "$$\n", + "\n", + "in which $\\bar{g}_\\mathrm{K}$ refers to the maximal conductance and $n$, also named the gating variable, refers to the probability (proportion) of potassium channels to open. $\\phi$ is a parameter showing the effects of temperature. In the differential equation of $n$, there are two parameters, $\\alpha_n(V)$ and $\\beta_n(V)$, that change with membrane potential:\n", + "\n", + "$$\n", + "\\begin{align}\n", + "\\alpha_n(V) &= \\frac{0.01(V+55)}{1 - \\exp(-\\frac{V+55}{10})}, \\\\\n", + "\\beta_n(V) &= 0.125 \\exp\\left(-\\frac{V+65}{80}\\right).\n", + "\\end{align}\n", + "$$" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "04C8609AA85847E49BFDB6C3C55884F9", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "Now we have learned the mathematical expression of the potassium channel. Next, we try to build this channel in BrainPy." + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "id": "047B9FBC9B104717AC74970D1659E72F", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.170965Z", + "start_time": "2023-12-12T07:45:25.167563600Z" + } + }, + "source": [ + "class IK(bp.dyn.IonChannel):\n", + " master_type = bp.dyn.HHTypedNeuron\n", + "\n", + " def __init__(self, size, E=-77., g_max=36., phi=1., method='exp_auto'):\n", + " super().__init__(size)\n", + " self.g_max = g_max\n", + " self.E = E\n", + " self.phi = phi\n", + "\n", + " self.integral = bp.odeint(self.dn, method=method)\n", + "\n", + " def dn(self, n, t, V):\n", + " alpha_n = 0.01 * (V + 55) / (1 - bm.exp(-(V + 55) / 10))\n", + " beta_n = 0.125 * bm.exp(-(V + 65) / 80)\n", + " return self.phi * (alpha_n * (1. - n) - beta_n * n)\n", + "\n", + " def reset_state(self, V, batch_or_mode=None, **kwargs):\n", + " self.n = bp.init.variable_(bm.zeros, self.num, batch_or_mode)\n", + "\n", + " def update(self, V):\n", + " t = bp.share.load('t')\n", + " dt = bp.share.load('dt')\n", + " self.n.value = self.integral(self.n, t, V, dt=dt)\n", + "\n", + " def current(self, V):\n", + " return self.g_max * self.n ** 4 * (self.E - V)" + ], + "outputs": [], + "execution_count": 26 + }, + { + "cell_type": "markdown", + "source": [ + "Note that besides the initialzation and update function, **another function named ``current()`` that computes the current flow through this channel must be implemented**. Then this potassium channel model can be used as a building block for assembling a conductance-based neuron model." + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "A63315E65828401AB9BA6032D79B4ECB", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "For a sodium ion channel, \n", + "\n", + "$$ \n", + "\\begin{split}\\begin{split} \n", + "\\begin{aligned} \n", + " I_{\\mathrm{Na}} &= g_{\\mathrm{max}} m^3 h \\\\ \n", + " \\frac {dm} {dt} &= \\phi (\\alpha_m (1-x) - \\beta_m) \\\\ \n", + " &\\alpha_m(V) = \\frac {0.1(V-V_{sh}-5)}{1-\\exp(\\frac{-(V -V_{sh} -5)} {10})} \\\\ \n", + " &\\beta_m(V) = 4.0 \\exp(\\frac{-(V -V_{sh}+ 20)} {18}) \\\\ \n", + " \\frac {dh} {dt} &= \\phi (\\alpha_h (1-x) - \\beta_h) \\\\ \n", + " &\\alpha_h(V) = 0.07 \\exp(\\frac{-(V-V_{sh}+20)}{20}) \\\\ \n", + " &\\beta_h(V) = \\frac 1 {1 + \\exp(\\frac{-(V -V_{sh}-10)} {10})} \\\\ \n", + "\\end{aligned} \n", + "\\end{split}\\end{split} \n", + "$$ \n", + "\n", + "where $V_{sh}$ is the membrane shift (default -45 mV), and $\\phi$ is the temperature-dependent factor (default 1.)." + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "id": "92F8054041EF4EE685C8BFB3E3008F27", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.187168900Z", + "start_time": "2023-12-12T07:45:25.170965Z" + } + }, + "source": [ + "class INa(bp.dyn.IonChannel):\n", + " master_type = bp.dyn.HHTypedNeuron\n", + "\n", + " def __init__(self, size, E=50., g_max=120., phi=1., method='exp_auto'):\n", + " super(INa, self).__init__(size)\n", + " self.g_max = g_max\n", + " self.E = E\n", + " self.phi = phi\n", + " self.integral = bp.odeint(bp.JointEq(self.dm, self.dh), method=method)\n", + "\n", + " def dm(self, m, t, V):\n", + " alpha_m = 0.11 * (V + 40) / (1 - bm.exp(-(V + 40) / 10))\n", + " beta_m = 4 * bm.exp(-(V + 65) / 18)\n", + " return self.phi * (alpha_m * (1. - m) - beta_m * m)\n", + "\n", + " def dh(self, h, t, V):\n", + " alpha_h = 0.07 * bm.exp(-(V + 65) / 20)\n", + " beta_h = 1. / (1 + bm.exp(-(V + 35) / 10))\n", + " return self.phi * (alpha_h * (1. - h) - beta_h * h)\n", + "\n", + " def reset_state(self, V, batch_or_mode=None, **kwargs):\n", + " self.m = bp.init.variable_(bm.zeros, self.num, batch_or_mode)\n", + " self.h = bp.init.variable_(bm.zeros, self.num, batch_or_mode)\n", + "\n", + " def update(self, V):\n", + " t = bp.share.load('t')\n", + " dt = bp.share.load('dt')\n", + " self.m.value, self.h.value = self.integral(self.m, self.h, t, V, dt=dt)\n", + "\n", + " def current(self, V):\n", + " return self.g_max * self.m ** 3 * self.h * (self.E - V)" + ], + "outputs": [], + "execution_count": 27 + }, + { + "cell_type": "markdown", + "metadata": { + "scrolled": false, + "tags": [], + "slideshow": { + "slide_type": "slide" + }, + "id": "5662C78D46C64EF48208609018A9EB00", + "runtime": { + "status": "default", + "execution_status": null, + "is_visible": false + }, + "notebookId": "654731a4b4c12f15a7a5fc1f" + }, + "source": [ + "The leakage channel current." + ] + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "id": "E9F47A5EF3EF4CAABF4DC4D0CBF98B6B", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.188239600Z", + "start_time": "2023-12-12T07:45:25.182244900Z" + } + }, + "source": [ + "class IL(bp.dyn.IonChannel):\n", + " master_type = bp.dyn.HHTypedNeuron\n", + "\n", + " def __init__(self, size, E=-54.39, g_max=0.03):\n", + " super(IL, self).__init__(size)\n", + " self.g_max = g_max\n", + " self.E = E\n", + "\n", + " def reset_state(self, *args, **kwargs):\n", + " pass\n", + "\n", + " def update(self, V):\n", + " pass\n", + "\n", + " def current(self, V):\n", + " return self.g_max * (self.E - V)" + ], + "outputs": [], + "execution_count": 28 + }, + { + "cell_type": "markdown", + "source": [ + "We can compose a HH model by using three channels we defined in the above. " + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "id": "B00168826F8046C59FCED99795EDD38C", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.198377700Z", + "start_time": "2023-12-12T07:45:25.187168900Z" + } + }, + "source": [ + "class HH(bp.dyn.CondNeuGroup):\n", + " def __init__(self, size):\n", + " super().__init__(size, V_initializer=bp.init.Uniform(-80, -60.))\n", + " self.IK = IK(size, E=-77., g_max=36.)\n", + " self.INa = INa(size, E=50., g_max=120.)\n", + " self.IL = IL(size, E=-54.39, g_max=0.03)" + ], + "outputs": [], + "execution_count": 29 + }, + { + "cell_type": "code", + "metadata": { + "collapsed": false, + "id": "5A6DD4DECE3B44EF931B876B4F05AC03", + "notebookId": "654731a4b4c12f15a7a5fc1f", + "scrolled": false, + "slideshow": { + "slide_type": "slide" + }, + "tags": [], + "trusted": true, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.641071600Z", + "start_time": "2023-12-12T07:45:25.193714700Z" + } + }, + "source": [ + "neu = HH(1)\n", + "neu.reset()\n", + "\n", + "inputs = np.ones(int(200 / bm.dt)) * 1.698 # 200 ms\n", + "runner = bp.DSRunner(neu, monitors=['V', 'IK.n', 'INa.m', 'INa.h'])\n", + "runner.run(inputs=inputs) # the running time is 200 ms\n", + "\n", + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(runner.mon['ts'], runner.mon['V'])\n", + "plt.xlabel('t (ms)')\n", + "plt.ylabel('V (mV)')\n", + "plt.savefig(\"HH.jpg\")\n", + "plt.show()\n", + "\n", + "plt.figure(figsize=(6, 2))\n", + "plt.plot(runner.mon['ts'], runner.mon['IK.n'], label='n')\n", + "plt.plot(runner.mon['ts'], runner.mon['INa.m'], label='m')\n", + "plt.plot(runner.mon['ts'], runner.mon['INa.h'], label='h')\n", + "plt.xlabel('t (ms)')\n", + "plt.legend()\n", + "\n", + "plt.show()" + ], + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/2000 [00:00", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj4AAAGwCAYAAACpYG+ZAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACIBklEQVR4nO2dd3wUdf7/X7MlmxCSUAIpEAhdMYqQgAc2sGABy6HYEIkonqdYTj2Vn+eJBbmv7Tz1xHJSbKCeWA4s4IGUQymhF+mBUEIICenZbHbn98fuzM7Mzmza7O5nPp/P8/HIY5PNGubtZ+bzeX3e7SOIoiiCw+FwOBwOhwFssb4ADofD4XA4nGjBhQ+Hw+FwOBxm4MKHw+FwOBwOM3Dhw+FwOBwOhxm48OFwOBwOh8MMXPhwOBwOh8NhBi58OBwOh8PhMIMj1hdAGj6fD8eOHUNSUhIEQYj15XA4HA6Hw2kGoiiiqqoKmZmZsNmM/Tpc+Gg4duwYsrKyYn0ZHA6Hw+FwWkFRURG6d+9u+HsufDQkJSUB8P+PS05OjvHVcDgcDofDaQ6VlZXIysqS13EjuPDRIIW3kpOTufDhcDgcDsdiNJWmwpObORwOh8PhMAMXPhwOh8PhcJiBCx8Oh8PhcDjMwIUPh8PhcDgcZuDCh8PhcDgcDjNw4cPhcDgcDocZuPDhcDgcDofDDFz4cDgcDofDYQYufDgcDofD4TCDZYXPzJkzIQgCHn74Yfk9URQxffp0ZGZmIiEhASNHjsSOHTtid5EcDofD4XCIwpLCZ/369XjvvfdwzjnnqN5/6aWX8Nprr+Gtt97C+vXrkZ6ejssvvxxVVVUxulIOh8PhcDgkYTnhU11djQkTJuD9999Hx44d5fdFUcTrr7+Op556CuPGjUNOTg7mzZuH2tpafPrppzG8Yg6Hw+FwOKRgOeFz//33Y8yYMbjssstU7x88eBDFxcUYPXq0/J7L5cLFF1+MNWvWGP49t9uNyspK1ReHw4kujV4fGhp9sb6MqNLQ6IPXJ8b6Mjgc5rCU8FmwYAE2btyImTNnhvyuuLgYAJCWlqZ6Py0tTf6dHjNnzkRKSor8lZWVZe5Fm4goivjo10PYeuR0rC+FE0E+WH0QD8zfhEYvO0Lgmrf+h+Ez/wt3ozfWlxIVGhp9uPClZbjqHytjfSlRw+P14c456/Dmf/fG+lKihiiK+GH7cRSV1cb6UjgKLCN8ioqK8NBDD+Hjjz9GfHy84ee0x9GLohj2iPpp06ahoqJC/ioqKjLtms3m++3FePrr7bj2rf/F+lI4EeT5RTvxny3HsHjb8VhfSlTw+kTsOl6JUzUN+O04G/l4B0trcKLSjT0nqpnxdP24oxjLd5/Eq0v3xPpSosZ324px78cbMeqVn2N9KVFjX0k1bv/XWvy4w9jhEGssI3wKCgpQUlKC3NxcOBwOOBwOrFixAm+88QYcDofs6dF6d0pKSkK8QEpcLheSk5NVX6Sy8xh7Ybh9JVV44t9bmdwxHSmvi/UlRAWPwrNV52HD42NXzLy1DY2xu5AoUl3Php1Kftp1AgDQyFBI848fF2D1vlK8+N2uWF+KIY5YX0BzufTSS7Ft2zbVe3feeSfOOOMMPPHEE+jduzfS09OxdOlSDB48GADQ0NCAFStW4P/+7/9iccmmI4Kdh0fi8r+vhCgC1e5G/HPCkFhfTlQpr2mI9SVEBeWiwIrwUUYxaxq86NAudtcSLbxicJyb8sTTQkWdJ9aXEHWOnvZv2A6dInezahnhk5SUhJycHNV7iYmJ6Ny5s/z+ww8/jBdffBH9+vVDv3798OKLL6Jdu3a47bbbYnHJpsPQpkFGmit/K2bP28XKLtGjCPW4GRE+ylymWjcbnhBlIre70Yd4pz2GV8OJFE67DQDZz7FlhE9zePzxx1FXV4f77rsP5eXlOO+887BkyRIkJSXF+tJMwSeysRDqwYgGUCEyMt7KUBcrYq/eE7S5mhHho7yd6z1eJoRPnN0y2SSm4bSAzZYWPj///LPqZ0EQMH36dEyfPj0m1xNpGFkHdfEwVOEkwcpwexRip9HLhtVKj4+HEZuVka1aRsJ7Tgf5IsBsXBawmfwr5OjCUqkzwM6CKKryIGJ4IVFEGepqYOS+dis8Pqw8y8r7mZWNjNLj42PEmxnHhQ/HTBy24JbJzUgJrAQrE6Uy1MNKaFMV6mJE4Db6gjZ7GFkQlfczK16uOEdwzmZF1Dvt5Cetc+FjIZTCh5UFQoIV4aNMAGVlhJWLoFIQ0IzK+8HIJkZpMyvjrKxcYyV/jXt8OKaifIi8jHgDJFiZNJR2spjczEozP+XIsiICVDYzsnGzK4UPI5s3u418WUH+FXJ0YWWylGAl7ONVLAisDLFS7LEicNX5LqzYrAx1MXJzK2BlnC0Q6eLCx0ooJw7WDjdkRwQEDWWnYaViQWTE46MU8qxsYtShLjbubeUzzMo4223kKx8ufCwEi65iCVY8Po0MlnarvB/MLIhBWPEEKEUAKx4f5e3MyvNsU4T3SA3Xc+FjIZT3ECtCQIIVa5XCh0URwEoehHJBYGVBZFEE+BgM4zrs5Cd0c+FjIdTucTJvqEjBitBTTpSshH1Y7O+ihJUQCItVXao5m5F72yaQX33MhY+FUN5CrOX4MKJ7mBQBIoP9XZhMbgbbXi5WxlnVdoVQgcuFj4XwMZzczAqqPAhGxlid70LmRGk2PgYrnFhMbmYxid1ugX5zXPhYCcU9xIUPnbDY2M7HYL6LSgQwI3zYE3uq0DUj9zYQFD4eQsUeFz4WQt30jJWHiC1Y9H4ojSZ1ojQbJqu6WExuZnKzSn5kggsfC6HcPZB6Q3HahmpXzMgYsykC2AuBsNitmsXkZisIXC58LATLyc2soBIBjIS62Az7BL8ndXEwGxYPKWWxR5UV8te48LEQLJaDsgaTVV1gcEFk0WYGBa7Xx6DHR/E9qRt0LnwshFJJs6B7SO36GVnY69XEpNhjcBPDYo4i814uQm3mwseisDBZMjI3qlBOGqycVM5iyS/reU2s2MxicrMVnmcufCwEa318tDb6GLBZaSIr3arVeU2M2Mxg2IdNm8kXAZGEVM8eFz4WQmRs96Bd+El9iMxEZDDUxWI5uxUSQM2GxeacXga9XFZI3OfCx0KIFuiPEElYsFl1EC0D9gLq+5odm4OwIgJ8DHp8WLRZfTQJmTZz4WMhVA8RA5OlNtLDgjeAxbb+LNqsNJrUxcFsWBxnFvtyKadpUseZCx8LwVqoS4TaRlLdpmbColePtfsa0Jb8xuwyogqbh5QyKHBV4XoybebCx1KwtShqPT6kPkRmwkUAGzaru7DTf18DUA00C88ywOjzzMvZOWainCtYeIi0FrKyS5RgYYwB9qoVAd7ThhWbrSACzMYKYo8LHwvBWsWPtoEhqQ+RmTDZ2E45UbJSwm+BxcFsVDazIgIskOhrNuqu5GTazIWPhfAxtkBoLST1ITITVYWTyEr3avZyP1j0+DBpM2NzNsDL2Tkmo94xMSACNM8MCztj1m1mwV5ALWhZsVkd0qR//gLYvLd552aOqbAe6mIhRh6S18TCOCu+Z8FegNXS7uD3zNjM2JwNWKNikQsfC6FqbseA25RN7wfbeU0s3NcAm7kfSli4rwE2PT5qm8m8t7nwsRDqc1/of4hCvR9kPkRmoh1WFvICWBQBLC6ITFZ1Kb4nNd/FbKzgweXCx0KoXIgMPEQsej+0co+FcWbxBGsrLA5mw6LYE5nMayI/f40LHwvBelUXCwtEaNNGFmxWTJQM3NcAq72LGPf4sGKzBXK5uPCxEFZQ0maiXQNZOMBSayEL46yEFXtZ7Nek9uyxYTOTXi4LnDDAhY+FYO0hCjmriwWbWczxscAOMZKwEM4ErNHfxWxY9PioDikldJy58LEQVlDSpsKruphYFJX3tSgy4tljMNGXtbMGAajUHis2q8vZyfTsceFjIdjz+KhhYYFgsZKNdS8XC88ywKZnj0WPjxVEPRc+FsLHWBKotqcLqbsHMwnJa2JinNU/syAEfAyKACYTunleU+wuJAxc+FgIVaM3Qm8oM2GywonJvCYGbWYw7MOmx0fZo4pBmwkdZy58LIQqdsqAJ4DJCiet2GNgsmRxnFms6rJC7ofZWMH7YTZWsJkLHwuhLmeP4YVEiRBPABcBdMJgqEstAui3F2C0czODXi4rhDS58LEQrMWLWTyrKySviQnPnjbUxcK9zZ4IgAU8AWbDosC1QkI3Fz4WwseYx0cLqQ+RmbAo9li3mZkSfsX3LHhvAa3AZWTStsAGnQsfC6GcKlio9mGyzFnzMwsLBIvhPRaT2K0QAokkrNjMPT4cU7FC0piZaBcHLwNuLm1eEwsCN7RtAf02s+7lInVBNBsWbbaCwOXCx0Kw1seHzXJ2NUzYzOA4a01kIQzCZFWXwmoWwpmANcQeFz4WhYWHiEVPQGiFE/0LhHZUWbi3Q0JdDIQ0eVUXIzYre1QRel9bRvjMnDkTQ4cORVJSErp27Yrrr78eu3fvVn1GFEVMnz4dmZmZSEhIwMiRI7Fjx44YXbH5WMGFaCZMej8YXBC1Lh8WxjmkXxNjNrMwfwHszdmA5pBSQm22jPBZsWIF7r//fvz6669YunQpGhsbMXr0aNTU1Mifeemll/Daa6/hrbfewvr165Geno7LL78cVVVVMbxy82Aux4fxPAiAjRwfNpOb1bBhM4MeH8X3rNishFSPtSPWF9BcfvjhB9XPc+bMQdeuXVFQUICLLroIoiji9ddfx1NPPYVx48YBAObNm4e0tDR8+umn+MMf/hCLyzYVlfBhYEHULg8sTBws5ruwKXBZ7F0U/J6FMQbApJfLCj2qLOPx0VJRUQEA6NSpEwDg4MGDKC4uxujRo+XPuFwuXHzxxVizZo3h33G73aisrFR9kQprbtPQBZGBxUHzMwvjrPVqkTpZmgmbB7Oq5y+t+KMRtceH/vkLUN/bpN7XlhQ+oijikUcewQUXXICcnBwAQHFxMQAgLS1N9dm0tDT5d3rMnDkTKSkp8ldWVlbkLryNMNfHR/MzCwuidjEgdeIwEzY9Puqf2bi31T+zMc7kJ/qajRVCmpYUPlOnTsXWrVsxf/78kN8JgqD6WRTFkPeUTJs2DRUVFfJXUVGR6ddrGhZQ0mYSMlEyMHGEljnTb3OowKV/ZxzSo4rJcWbLZhbsBawR0rRMjo/EAw88gG+//RYrV65E9+7d5ffT09MB+D0/GRkZ8vslJSUhXiAlLpcLLpcrchdsIkovDwNrQ+jiwICXS7s8kDpxmElI00YW7m2twGVA1LPuzWTBXsAaYs8yHh9RFDF16lQsXLgQy5YtQ69evVS/79WrF9LT07F06VL5vYaGBqxYsQIjRoyI9uVGBFUDMAZEAJuucfXPpE4ckYQJjw/jIgBg4962QtjHbFThPUKfZct4fO6//358+umn+Oabb5CUlCTn7aSkpCAhIQGCIODhhx/Giy++iH79+qFfv3548cUX0a5dO9x2220xvnpzYK0BGItJr1oLmWjmx6LA1fzMhNjT/MzEOLPo8VGYSaon0zLCZ9asWQCAkSNHqt6fM2cO8vPzAQCPP/446urqcN9996G8vBznnXcelixZgqSkpChfbWRQ3lBMLoiEPkRmwvquGGBjgWBR7IVuZBgQe0oRwIC9gPZoEjLva8sIn+aUPgqCgOnTp2P69OmRv6AYYIUbKpKwKQLonyxZLO1m8XR2FsWeElbstULbFcvk+HDU4o+JcnYW+/iE2Byb64gmTHq5GBQBIeE9Jjy4bKUnANY4n4wLHwvBWryYyV2x5mcmxB6DoS4m2xawmNCt/F5kJUWBe3w4JqI69ZZJjw8LNjMo9hgc59C2BQwIXCbFnvpn1mwmNa+JCx8LobyHWFgcWGx4poWFHaIWJu5tFvv4MOjZY9PmIKTay4WPhbDCDWUmTLrGmdwhci8Xm/c2md4AM2HTZvLzmrjwsRCq5GZCbygzYbHaR5u0zobN6p9ZCONqx9nDxDizd28z2btI8T2pLUi48LEQquRmBhYHNo9vUP9M6o7JTEL7NTGwK9b8zHN86IRFm63QaJcLHwuhSm6mf55k002s+ZkJscdi9R6TOT5qWLi3Wd+8kWovFz4WQnkPMdHHR/MzqQ+RmfC8JkZsZnJB1AhcFsQegx4fpYWkbla58LEQVuiPYCasTxoAmzYzEcZl8d5mUuCqITXnxUzUjXabd+pCtOHCx0Lwqi76bdbOlCwksWtXRBYWB57oS643wExCxplAEWA2VhC4XPhYCCvETs0kZKJkYEFkMt9F8zO3mU6YFHshIoB+sWeFe5sLHwuhCnXxnQOVsDhRahdEJvLXGBxnJkPXDPaosoLA5cLHQqiSmwm8mcwm1PvBwOKg+ZmFiZLJBVHzM4s2k7ggmg2TXmsLPM9c+FgIflYXezYz4f3Q/MzCOIfsihlYELU3N4kLoukwOIdpIdFmLnwshHLeEAnNljcTK+wczCbEy8XAgshiTxsWq7pCO7FzDy5t6K1JJHrqufCxEKx5QLQigIXwHovHdISMM+WCHgjabBP8P7M0zkLAZhYEriQE7IGBpn2c9cwj0WYufCwEa4lyLHp8Qkq7GRABod4P8naIZiMNq9Pun4JZuLe1NpO4IJqNZKEjIHxov7d1PT4EClwufCyE9vahfWesnTRYmiglWLDZClUgZhMqAuheEIGgN8ApiwAWx5lum/WsI9FmLnwsBGsLhLR7cNjZmyglSNwtmQ1rIVwg+CyzdW9LNrMhAoBgeI+VcVauUXJIk0CbufCxECEVP5RvEiVznTaGJkqRxdwPP3aWPAGBVwdD97YEi+E9eZwp38go1yiS520ufCxESOIr5aEuaXUI7pYoV3pQLIjSrpj2MYZycWAopBkwMS5wb3soXxCBoDfAaZfGmZ3n2cmIx0eJk+B5mwsfS8FWqMvHomucxTwIKRzAkPABtPc2eYuD2YghGxkGxlljM+33tjLURfK8zYWPhWAtF4JNEeAnWP7K0oJI7kRpNj4GRUDQ+8FG2AdQermk8B7dz7Mq1EXwvc2Fj4Vg7aRfbdhHFOnv5SNqJkov3fOkCrZyP/w2xjEl9gL3to2hcQ68kpzvYiZK60jOX+PCx0KElLMTeEOZibaqC2BjsgSUrnH6lU9o7gf9YxwU9eTuik2HsbAPwF5lqnJz7nQEbCbQs8eFj4XQCh3aJw7tbglgoHeRpgqE9okSCNrMSndbQKe/C4GLg9loPbhM3NuBV1bCuLyqi2M6Ic3tWBEBDHl8tH0/SJw0zEaymZUmb0CoqKf9vgaU4T12vJnM5SkqzCO5GpcLHysR0seH8odIsyAC9O+M5aRXBr0frLT1B0JDICyIgOC9zY7Yk5DHmfKkPeW5eyRvZLjwsRCsenycKo8P5ROHNgRC4KRhNtpKNsqHGEBoJRsLIoA1b6by3CpWEvd9Ko8PuTZz4WMhtPktJCaNmYlknQCBmU7G2rAPiZOG2cjN/BxslPwCinFm0LPHyr2tEgGMjLNK7BFsMxc+FiLkyArKPT6yfQI77nFtoi/94UxF2IfgidJsWBMBQKgHl/awtVIEkOz9MBNVOTvBlWxc+FgIURPson2BUOgepip+ALKbf5kNi5Vs2kNKWbivtYeU0j7OSutYadXg0wnvkZi/xoWPhfBpdky0e3zkUJegTHyl3GbZ+8FSjg+LIsD/ypTHJ/DqZKQruXJ6ZuZ5ljarguLQYQI9e1z4WAnNzpjyAgFZBAgQYGek+iX0PCO67QXYPLJC7u/CiAgA2EvoVnroWRH1knU2QSA6dM2Fj4Vg8zBHxjw+gVcHSxVOgVeSkyFNR/L4SAndBO6KzSaYuM/GOOs186N9/vLJm1WFx4dAm7nwsRBy4isroa6AeTZBYCbHR7sr9jCgfEI6N1N+XwPKc6vYuK8B9sJ7KuHjYMOzJ+dlCmSH97jwsRA+Tf4H9RNHYIdI+kNkJtpdMRMHs0o2M+X98MNSeE/bwJB2m1WhLmbmbD8CBO7x4ZhDaBiEvBvKTJQ7JpIfIjPRVjgB9HtAtG39aV8QgdDOzSx49qAR9aw8ywBL4T3lZpXcdYoLHwvB2mGOknkCU6Eu9YIIsGOznZFdMRB6VhftPW2A0MR96sM+iu+ZSejWq+oi0GYufCyCuv05G7kQol6iHOULhGRdnOJ8MhInDjORRQAjuWsAe/kugNJjzUZIU7eLMfU2+18FCEQLXC58LIKqJ0RgsiTRhWgmen186Pd++F9VHh9GJku5hJ/2Pg0ILorBpFe6xxhQnM7uYCXHJwgzHp+A1Tbu8eGYgeohYqX6Rd49KB8iuhfFYMsCpceHdpv9sJL0CoSGukhcHMwmmNxM7oJoJurNKrneDzNRpieQ/Dxz4WMRlO5/ZvJd5KouspthmYlejJx+mzX9qWgX9NA5t4ryMQZCj6yg3WZlqCuOFY8P7+PDMRO9UBf9E4f/lXS3qZlYpRzUTGQRwEgIBFAe08HSifR+WKzqYmbjFnglPT2BCx+LoO4JQe4NZSZB68h2m5qJugEYK+McyHdhROgBwY7cLHl8Qo/coVvsMZnjI5ezC0QXpHDhYxH0etrQXv3CZNhHCu+BIS+X3KbBJv/MSuI+K43tAEW3amY8PjqVuNTb7H9Vb9zIE7hUCp+3334bvXr1Qnx8PHJzc7Fq1apYX1Kb0W+GFaOLiRLKc19YOeQPFpk4zES3ko16US9VdbEn9pyshOoV37MicIOhesBG8MaNOuHz2Wef4eGHH8ZTTz2FTZs24cILL8RVV12Fw4cPx/rS2oRe+3PqF4fAK+nNsMwkaLPATEM/6d5W9i6ifVGUkMJ7AAPjHNK2gA17AXaqupTnK5IcqqdO+Lz22mu46667cPfdd+PMM8/E66+/jqysLMyaNUv38263G5WVlaovEtFLlKN9hwjZ4yPALrAycSi8XATHyM3Ep+PxoV0E+DQVTgCZC4SZaFs10J7QrTy+geR8FzPxqWwmd+NGlfBpaGhAQUEBRo8erXp/9OjRWLNmje5/M3PmTKSkpMhfWVlZ0bjUFqNXzk7iDWUmLHp89I7poN3m4PlkLB3T4X9Viz3ahYD/NY6Rpo2SdaR7P8wkuEyRbTNVwqe0tBRerxdpaWmq99PS0lBcXKz730ybNg0VFRXyV1FRUTQutcUobx0nK52blW5TRnJ8VMmBjLjHARa9H35YCu9pD+BlRdD7CxUYsdkinZsdsb6ASCAIgupnURRD3pNwuVxwuVzRuKw2oVfVRX2Oj2LmsAuMnO+jqOpiLdRlFwQIgv9ep9/74TfazlKOjyxwGTm3Sm7ACkj6lhVxS/rGjSqPT2pqKux2e4h3p6SkJMQLZDl0E+Uof4gCr0oRQL3NqqouRqpfFAKXuXEGezazcjCr8sBOZjw+KpvJ3bhRJXzi4uKQm5uLpUuXqt5funQpRowYEaOrMgdljg8ryc1BEcBOvosEU52bA682wpuemYm6es9vs4fy/hTB3kWMCD3pG5ZaUyhCXSSPM3WhrkceeQQTJ05EXl4ehg8fjvfeew+HDx/GvffeG+tLaxOqnhB2NsrZfToVTtRPHIqqCFY8ez6V98MGwEe9zdI4SwuEG/SPs9y7iJFjOqxybpWZqIszyPVyUSd8br75Zpw6dQrPPfccjh8/jpycHHz33Xfo2bNnrC+tTYgMenwk1J2bY3wxEUbPE0DixGEmumW/tNsceGXJZsk8uThD9M9hNkWeE03odTGmfc7WW6dIFPTUCR8AuO+++3DffffF+jJMRXnv2AQ2Jkr9PAi6lQ+LXi4JQWCntX8wdC0wc+iwhLZDtw10Cx8bS5uYwKta0JM3f1GV40Mz6goBRqq6ZJsFotufm4ne+WSs2KxeIMibLM1EzxtAc16T6twqGxsl/OoKTTbELe/czDEXHe8H/W5T/ytbJ5X78U8cbEyW6sR9RtoWWGSBMAu94xsAukU9i8UZVglbc+FjEZRJYzbW8l2YKgfVSYhkRASwtEBICADsdvq9XMrRdCqbNlJ8b6vacTASwrWKzVz4WARVR8xAjo+P9lAXix4fyRNgY8MTAGhKYAmeLM1EeaYRC5495VzlZOSYDlUDVnkTQ6+9gDZsTa73lgsfi6BsDGVjbEFUl4PSPXGweCabT3FvOxgZZ91GbxSPs3KPJggCpEIumucwdZsGNuZsn0LskWwzFz4WQdkMy85aVRfhD5GZWKXlu6moErrJ3SWaibJYgYV7W1QEu/z3Nguh62BxBgviFtCeT0buJoYLH4sgJTLbFOe+0J/cLHl8hGAeBPULoh+Vq5j2cbZIt1czYa16T+XxARvjHAz7sBHOBJTPMtmhei58LIYy0Zf6cnYGPT76fXxot1n6TpC9XDSLAEA/vEe9Zy8AK31tgj1t1PaKFM/bVhH0XPhYBPUN5f+eeo9P4FXZ/px2sQd5l8jG4gBojulgRgQEdsY2Nqr3lLlrrIyzXgNWQN2MljZElaAPdOgm0GAufCyC0hMgdW6mXQToNnkj8CEyE5+OCKC+EiTwqhR7HopFAKC/QNDs2VOHutgI46qazrJSyabTaJfEMebCxyLoLQ40T5SAuqpLrmSjfUFUfE/yxGEmoYeUsnBv+yF9gTALpWXsdKuWvhNUHh+a721lvzmSW1Nw4WMR9HpCsNjHh+bFAWCvoy8A2WhlJRvt46zK5SJ4gTALbV4LC5s3pffWblN6fOi12Son0nPhYxHkHSIUh5RSvFsCtJ2b6c8JADShLiZKfrXHdLAxzqx1q1ZaZhPYSGJX5/gw1q2a8IIULnwsgqSklR196ff46OS7EPgQmYlS4JI8cZiJT8ebSX+OD1u5XKLCNNVBy5Tf24Bf6CkcPnTPYbrFGeTd11z4WATl7oGZzs06zbDotzkocFmo9gH0d8bUj3PglfSQgFmoGhgCTHToVobqBUZC11Y5ioULH4ugKu2Wq7pidz3RIFghEKx8oXlxAPRLYFkJ+7ASAgHUoS6SFwiz0B5ZYWfBZkVxBkB2J2Oz0O/cTN4Yc+FjEXw6SWMk9kcwE71mWDRPlIA294MNsaeXBEq/2At49hhJ6FZVdYGN0LXyWQbYCF0rN+iSvaJI3lrFhY9FUD5EzIS6Aq/qwyvpttmnU+FE+zhLKMeZ+hyfwCsrifvKqi6VwKV4nLU5mDYG5jDVJkbVu4gsm7nwsQgq7weDDQztjBzYqbcgkjZpmI3as0d/CARgr1WD0jSlN4Bmm5UVTgAjHh+dUD1Ans1c+FgEvVAXaTeT2Shj5LLYo1v3qEMgrI2zADgZCPsAam+ALPYo9n4oxxhgYw5TilsgOM50FytI85eg6V1E1sTNhY/FYKlzM3R2xdR7fHTymugXAf5XVsI+gKJ3kY0N7wcUngBAmddE8zgHRQDAxkbGp5qzFb2LCLOZCx+LoHtIKe2hrsArK03eAP3kQOpFgG5PG7rHWSkEWNjIKO9rgI2QpqgRe/I4UzxvK8+gI7l3ERc+FkF1bpVA/0QJBCsBWGnrD2hDmiy4xrXn0LFRyaYM/bDg8Qm2LPC/MmFz4FWu6mIgT1FUKHqSexdx4WMRlIe/sbBDBLQeH0ZEgKq/CyPjrPBmOpkRuP5XAQITiftBQS95fOgfZyOPD81zmFbgklrJxoWPRVCGA6REX+pDXbo5PnTb7FMkNzMT3tM92JBeEQDoJ7HTPM6yZQx5fHwa5cPCHKYVuLLNhIk9R2v+o8LCQqxatQqFhYWora1Fly5dMHjwYAwfPhzx8fFmXyMH6tJIUlW02aiquhixWYKppo2BV1WZM2ETpdkohQAb+S7BZxlQ9vGhV+CGenzYCOMCodV7pG1kWiR8Pv30U7zxxhtYt24dunbtim7duiEhIQFlZWXYv38/4uPjMWHCBDzxxBPo2bNnpK6ZSUSFkpYPKaX8AdL3+JD1AJlN0OND9iF/ZqLu3MzG4qBMAmXB+6Et7WbCZsWROwAbHh/l8TMAuTY3W/gMGTIENpsN+fn5+Pzzz9GjRw/V791uN3755RcsWLAAeXl5ePvttzF+/HjTL5hVlBOH3LmZ8lCXBIvN/AB2KpyUO2MWcnxY7GIsYWOoqit4Urn/lYU5TLmJAcjdyDRb+Dz//PMYM2aM4e9dLhdGjhyJkSNH4oUXXsDBgwdNuUCOH1Xli5TjQ7cjQFPmzMBECTbP6lLuEllYHJTi1sZIF2OfJtTFgs1yCFeb70LxxK3di1ve4zNmzBicPHkSXbp0afKzqampSE1NbdOFcdTonXpL2s1kNsGJA5B6YdFus08n6ZV2m/X7+FC8OCi+ZyWhW3tgp50Jz57/NTTfhWKbA69Bzx6ZNreoqqtbt2648cYb8f3336vctZzIo6wQkPv4UD4GPsXMwYzHJ/AqQGDi1G5Aez4Z/V4ubaiLLe+HHxZs1lbdstCLTBvqIrV3UYuEz7x581BZWYlrrrkGWVlZePrpp7F///5IXRtHgV44gJXkZm1pN82iW9W2gAHXOKBJYmdicQh+LwgC7HYGzurSlDixcG8rqxUBRhqSWqR3UYuEz6233oolS5bg4MGDmDJlCj755BP0798fo0aNwieffIL6+vpIXSfzsFjarfJ+KPqf02y2Uuw5GPB+AOpdIgueABHseny01T5U22yQ10SzqLdKJVurGhhmZWXhmWeewYEDB7BkyRJ069YN99xzDzIyMnDfffeZfY0c6B9eyYrHRxCCOQEA5bkQ8ncMduhWVu/RnOOj9PiAlaRX/Wofqr1cgVemcnxCKtnI3Ly1uXPzpZdeio8//hgffvghbDYb3n33XTOui6NB2ffDzkiODxReLqXHh2YhoJfcTJqb2GzkydLGjpdLQhDYyOXSNvNjweMTLGdnp6orOJxke3xa1blZorCwEHPmzMG8efNw5MgRjBo1CnfddZdZ18ZRoDzUkJUKJz0vF0D3ZKkuZydz0jAbVXNOJnJ8grbZWOncHHgVNNU+dNus9XLRL/asYnOLhU99fT2++OILzJkzBytXrkS3bt2Qn5+PO++8E9nZ2RG4RA6gf0gpO2d1Bau6AMrd44q8ABY8AYA6JMCCJ0Ad6mKjjw+LHh8jm6kWe5pQF6lerhYJn3vuuQeff/456uvrcd1112Hx4sUYPXq0rOI5kUN1kKNA/wMEqJNAFQ4fuifLwKs/7EPmpGE2eoeU0myzqo+PwJr3Q9vHh95x9ikVPcjNdzETpfcWUN7bMbskXVokfH799Vc8++yzmDhxIjp16hSpa+LooFwQgx4f/41Gq/AMermCni6vT6R7gVDmcjEwUQLaQ0rpL/nVtmNgwfsh6RumzupisqrLj7aPD2kFKS0SPlu3bo3UdXCaQrUgqhN9HXY6hY/2wDtZ+FAc4tMr7aZ5ogSC1YnKPj40L4hK02yqXC6yFgczUbbjAFjLa/K/Sl4uukW9/5X0M9laldwsiiL+/e9/Y/ny5SgpKYFP88AuXLjQlIvjBFEuiDal8BHFtmWoE4x2snTYBDSA9hwf/6syl4tmEQCou/oyIfZUDQzBiJfL/8qWx8f/Kos9gX6B69MYTeo4t2rNfOihh/Dee+9h1KhRSEtLozbUQhKqs7oU/78pfoaCXq6QCgF6jVYe5siECABUZb8sjLGqgSHYyPGRCMn9oFjsSTc26edWmUmI2CP03m6V8Pn444+xcOFCXH311WZfD8cAZR6EXePxoRVlYzuAISEAbQhEpDyXSxneY8f7Aaj7+NB8XxtV+zAhAkIqnCi2OfCq7dxM2ji3qoFhSkoKevfubfa1cMKgCnUpFkCqHyKDbq+kPURmojq3SlnCT7PNgVdWDmYN7ePDjs2hfXzo9ezJxRmSl4uBe1uas4OdmyXPHlnj3CrhM336dDz77LOoq6sz+3o4BqhCXcpzq2h+iDQ/s7BjUgpc9TEd9NqsFnv0j7G6nF1gzmaAjSR2EYpJG4zc2xbp19SqUNf48eMxf/58dO3aFdnZ2XA6narfb9y40ZSL4ygJxouZ6WmjSPQF2NgZq7wfjHSrVok9xs7qAtjIXTM8q4vi+zo034UBm7X9mgi1uVXCJz8/HwUFBbj99tt5cnOUUO6KpV1iI+U9bXwat6mDiaZnoSIAoDsJVLePD8X3tbatPxN5TYFXpqq6Aq9M2WyR6r1WCZ/Fixfjxx9/xAUXXGD29ehSWFiI559/HsuWLUNxcTEyMzNx++2346mnnkJcXJz8ucOHD+P+++/HsmXLkJCQgNtuuw2vvPKK6jNWJSReHBA+VO8SA6/aCgGaFwhlhZPa40PvOAdtBgQWQiA6/akANm2meeNm3MWY3mfZKK+JtHFulfDJyspCcnKy2ddiyG+//Qafz4d3330Xffv2xfbt2zFlyhTU1NTglVdeAQB4vV6MGTMGXbp0werVq3Hq1ClMmjQJoijizTffjNq1RgptvNhpt8Hd6CPuhjIVbaiLgaM6lLtEVrpV+xQLhJ2BA3jZPMMptCcXQLfYk5BqFFiwOdSbSabNrRI+r776Kh5//HG88847UTmY9Morr8SVV14p/9y7d2/s3r0bs2bNkoXPkiVLsHPnThQVFSEzM1O+zvz8fMyYMcNQqLndbrjdbvnnysrKCFrSerTloNLuwUOx98PopF+aS/i14T1J+HgImzjMRCn2WCjhD1kcCG3rbybaMmcWvB+i1vvBhMD1v4ZUdRE2zq2q6rr99tuxfPly9OnTB0lJSejUqZPqKxpUVFSo/q1ffvkFOTk5sugBgCuuuAJutxsFBQWGf2fmzJlISUmRv7KysiJ63a3Fp3GbOgl1IZpJyM6YoTAItL2LaBa4On18AHrHWbsgOghNADWTUC8X/XlNPtEa3g8z0Yb3SLW5VR6f119/3eTLaBn79+/Hm2++iVdffVV+r7i4GGlpaarPdezYEXFxcSguLjb8W9OmTcMjjzwi/1xZWUms+AFCvR8eFqpftBUCDE2WLFT8KPMClOfOeX0inPYYXVQEMR5jeu9rUaN8WPJ+SNjt9M9f2uRmUufsVgmfSZMmmfKPS/2AwrF+/Xrk5eXJPx87dgxXXnklxo8fj7vvvlv1WT23eFPucpfLBZfL1cIrjz7a5EAmdok6Z3UBtC8Q/ldpnJ12+qucJLSVbLTabFT5Ior+vlzKs/howaedv1jwWAdeSe9ibCZWsbnZwqempgaJiYnN/sPN+fzUqVNxyy23hP2MMofo2LFjGDVqFIYPH4733ntP9bn09HSsXbtW9V55eTk8Hk+IJ8iKhLhNWcgLCNk90D9ZSmjFHq2ePVGxLdZWspG2SzQbbeUL4F8g4igUPqGns5O5IJqJNqGb1HwXMzHyZpI2Zzdb+PTt2xcPPPAA8vPzVXk0SkRRxE8//YTXXnsNF110EaZNmxb2b6ampiI1NbVZ//7Ro0cxatQo5ObmYs6cObDZ1OlJw4cPx4wZM3D8+HFkZGQA8Cc8u1wu5ObmNuvfIBnDpmcULw4hu0Qmwj7qiUPy+JA2cZiF0iwBao+Ph9JxNjq3CqB3nLUHDjNRyRZ4ZSvHx/9Kupe+2cLn559/xl/+8hc8++yzOPfcc5GXl4fMzEzEx8ejvLwcO3fuxC+//AKn04lp06bhnnvuMe0ijx07hpEjR6JHjx545ZVXcPLkSfl36enpAIDRo0dj4MCBmDhxIl5++WWUlZXhsccew5QpU6Jaeh8ptC5EJwOhLhjsEmm22ajfCa3Ve0qPDyvNOY3OrQIkUU9fYlOwJ5e2dxGd4haAqicXwMj8FXiVPT6ENp1ttvAZMGAAvvjiCxw5cgRffPEFVq5ciTVr1qCurg6pqakYPHgw3n//fVx99dUh3pi2smTJEuzbtw/79u1D9+7dVb+TJk673Y7Fixfjvvvuw/nnn69qYEgDRoe/UV3mbJEuoGbi07j25JAmraEuxfehzTnpHGdtY04WDqMNfZbp37j5NKEuFrqSg9aqru7du+NPf/oT/vSnP0XienTJz89Hfn5+k5/r0aMHFi1aFPkLigFaF6KTUCVtJka7RJonS8kym8azR9rEYRZKnScoGr25QW+Oj7bCiYWz94y8XLTaC+h4PxiYvyTTJFtJPavLXNcMJ2IEG9uxEQIB9A42ZGCyNEjoptVmpYdLG9KkNscn8Co9yyyc0B7q5WKhP5X0HdneDzMJSW4OvJJmMxc+FkHqViyVurLhKva/akv4fRTbrBV7TspDXUrk/DXKE7q1YwzQL3CZ3MRoO88z4KXXztmk9i7iwsciyC5ETR8MWsucAYWXK3CXMtG0MfAa7HfiN55Wz54y1KXNX6O1YlEbtgbo94CEVDix0MfHqMKJ0jEGQnNRSfVyceFjESQvh1YEsDBxaMvZabY5NCGS7uoXdaiLjXHWVmgCDFQ5GVQ4UWsv2Mzx0W7cSO1d1CLhs3nz5ghdBqcptDk+LHT01SZEsnRWl9ZmWidLVVWXJiRAbY6Ppo8PEPTs0XpvG1U4+USKQ9chFU50h3ABxVjS5PEZMmQIcnNzMWvWLFRUVETqmjg6SA9LyI6JYrdp6Enl9B9sqM2FkCZLekNd6j4+AP09qoJeLh2PD7XjHPhGp3eRV6TT5tAKJ//PpIkAMwnJ8SHUy9Ui4fO///0PQ4YMwZNPPomMjAz5lHZO5BE1DxEL5ezah4gFm43aFtCa3Kzu3KytWKTTZm3lHsBQeC/wykK3anmzSnhpt5loN6uk9i5qkfAZPnw43n//fRQXF2PWrFk4cuQILrvsMvTp0wczZszAkSNHInWdzOMVtR4fuj0BAKNNGwOv2ko20iYO01AKH0ZyIbTnVgH057wYVXUB9N7boSKA7jEGlHO2ehNDWjizVcnNCQkJmDRpEn7++Wfs2bMHt956K95991306tULV199tdnXyIEy1OX/mfYdIhD0BrBS5gzo9MGg3OMjKpQPK/lr2qR9gP57O6zHh9LNm9HxM7SOMRA6Z1OR46NHnz598OSTT+Kpp55CcnIyfvzxRzOui6NBPprDpr6haE0ABcI1baTXZu1k6SR04jAL7SGlADv5Liz28Qnmuyg9PnQ+z9pNDBubVY2XntDijBYfWaFkxYoVmD17Nr788kvY7XbcdNNNuOuuu8y6No4Caa0PqfahdHEAlDk+/lcnAxOHCLVt9Pfx0UluZsTLpdvHh9J7W+sJEAQBdpsAL9WH0fpfQ0v46bQX0Gs6S6bNLRY+RUVFmDt3LubOnYuDBw9ixIgRePPNN3HTTTchMTExEtfIQVBJS5UBcrUPYTeUmYTGi+kWAYBygfC/BhdEWkVAEFbOcdK2LADot1nrCQAgCx9WbHYwVJWqzcskbf5qkfC5/PLLsXz5cnTp0gV33HEHJk+ejAEDBkTq2jgKZOFDeGMoMwlxFTNQ1aVt9Bbs0E3nZKkdY0CZ40PnOGsb2wH0C1ytJwDw29wAer1cIRs3QsM+ZhLSe43Q4owWCZ+EhAR8+eWXGDt2LOx2e6SuiaND6A1F9w4RAHza8B7luR+AXl4A3SJAUgG6FU6UjrOe2KPeZk0fMoAFL5f/VdDk69Gdl+l/Jb3fXIuEz7fffhup6+A0gZTuICc32+l3m4a4iimv9gGU1S/q3kW0jrO2fB8gd5doFlpPAEB/V189sUe/l0t//hJFvxC0KeN+lKDtSk5q7ho/q8siGPWEIO2GMhOjs7qo9X5AL0ZOtwjQD3Wx4QmwM+j9UFZz0X9v+1+13g+AXq+PVtSTepg2Fz4WIXhIKdk3lJmE9LQh1G1qJr6gywcAAxVOcqhLRwRQarP0LKu8H5Tnf2hbUwD0h661mxjpWQboH2dtqJ40e7nwsQjazs0seHxCD2al22Zlabe2czOt1XuyVTrJzbSOs/ZZBuj3+GhFAEB/Qz9tXqbK40Op2AspZyd0g86Fj0WQz+piqLQ7tPMp5SJAp5kf7f2agkmvwfeCjSrptFl77h5Af76Ltg8ZELy3aRV7IWcN2oLLLbXeTK2Xi3t8OG1Be+AdCwd2hjxElNus19OG9g7dWkEP0D/OWk8AQL/Hx6iPD0DeomgWWpttNkEOAdFqs7xZlTp0Sx4fwuzlwscihLQCp3yiBELLQen3BChDXf5X2qv3woV9aB1n7bl7ALm5EGahX8lGd7GCVgQAQQ8IaULALGRRH/iZ1G77XPhYBG0DQ9oXRMC48ylpD5FZqM+t0pSzU7o4yGOsCvvQPc56oS7axZ5PRwTYKR/nsEns1I6zfl6T1yeqNnaxhgsfiyCte3JVFwMeH8Nydsrj4wAgBJ5M2ivZ9HJ8aA/veX3qxQGgP8eHxaqucG0LaL23Q5ObgxKDJFHPhY9FMKrqotUTAIROlrQnQyo3RHZNQiStNuv1d5EmS9p3xXr5LrSOs254j9CKH7PQE3u0Vyxqq/ccigEnyWYufCyCtDOWDymlvLQbCHN8A6ULoleV40N2OahZhPN+0CoC9DwBtIs9rfcWoL8lR7gSflqf5xAvvaJ3EUleLi58LIJ29xAsZyfnZjIbo54QtHq5lKEumyxw6RZ72tw1gH6xFzbsQ6kI0D+ygvZEX/+rUtQ7qQ/v6W9WAbJEPRc+FsGrEQGkZsubibxjkkQA7YuDwi67JqRJ6zjrhX1YsVnvkFJ6bfa/2nQELlN5TZSfN6h3TIdkPvf4cFoMy+Xs2kQ5WndLykVPm8tF0qRhJnrVPtI4k5QMaSa6eU2UP8/hBC7t46xnM+0FGgpHD5FNDLnwsQjBHB+pzJluEQCE9oSgPaFbOS/YGBnnYNIrQxVOOjbbafd+aOYvQJHXRNCCaCaiXqsGynMzw5+9R47NXPhYBKP+CLTuEIHQbtW0TxpyvovOREnrOIt6NsteLjpt1u9dRPc46+W7sOL9UIc06c5r0s7ZAJlzGBc+FkGaG6QFgvZJAwjuEh0am2l1jeuV/NJ+Unmwqiv4np3yCie9EAj1zfz0Ql2MhDTV5ex0e/a8esUKBM5hXPhYBKPOzbROlEBwh6A9qZxWm8P1/SBpt2QmeqXdTtpDmmHCe7SOc7gjK+h/noPv0b5507ZdAcgUuFz4WASt25T2DqBA0GbJVUp7DwyfxqsHKCdKSm1msvJFJ8eHwF2xmehWdVE+h+kLXMpz9iwicLnwsQheTXKgk/IzX4Dgwid3Mabcy6Xf34URm/XyXSi9t8NW+1A6zl69Pj6Uz2HaFiQAA73IdJPYyRO4XPhYBG1HTNqTm30+MeQwR6XNJB14ZxZe3TwIul3j4Y4yoHVx0N0VU169p9uokvJEXz0RQGKFk5l4dTYyvJyd02q02fK0534oj2+QJkinov05SQ+RWfh8OpMG5SJA76Ry2j0+epVsTtorFsOdVE7pvS09s+pxJk8EmIlchKN3MCtBYVwufCyCdsdEe06Aqpmf5qRygE7Bp3uGE+05AbpnddEt6vVEAImLg5kEq1KDSw7tAldbiav8nqSwj5lYpV8TFz4WQVshQH1OgE/P4xO8XWm0W68HRjC8R+lEKQv64Ht2yr1cerkfJIYDzCTYoyr4HonVPmaiF96TPbiU2hwuuZkkm7nwsQihzfzo3hU3NuHxoTEhUq/8lfbOzbol/JR7ucKe2k3p8xwszgj1+NAa6tJt5seIN5P0Jqxc+FiEkHOrKA91+XQ8Pg7Fw0SjqzjcSeW0JnTrndVFe+J+o54IoD7fhcHkZj0vF+XzttciNnPhYxG0D5F0M/lEtUigBZXHJzBXCoJA9SnWejtEp2JxpNpmlZeLvInSTCSbHTqeAGrDPrqN7SgvZ9fr40Og98NM9M/eI0/gcuFjEbRndTmUCyKVnoCgy1QgvELALPSavNkVyS80TpZ655PR7vEJe54Rhfc1oPQEhIa6aPTeAqG91/zf0x3GDRfqIsmbyYWPRdCWCaoWRAofokadBwgIHmdAo/dD95BSZXiPwkVRL/eD9rwmr573g+L7GtD3+NDsvQX0PXusnNWl26GboOeZCx+LoO39oXyYaKx+8enkBABKjw85D5FZ+HTDPopKNgptbtRZHFjx+DhUOT50h7q05+4BDAjcMJ3YSQr7mIleCT8vZ+e0Gu0p1irhQ+HEobcgAnQ3ANNzjSvNp1EI6OUE0N600SrnGZmJZLNDJwRCoycTaKLCiVabw3itSbKZCx+LIC160sJPezM/vTwIgO4cH4+OJ0AQBKqFgL7HJyBuKRT0gMLjY9cJB1A4xoCBCGBE7OmeQ0erzboJ3eSV8FtO+Ljdbpx77rkQBAGbN29W/e7w4cO45pprkJiYiNTUVDz44INoaGiIzYWajLTQSw+OIAiKh4i+yVIvPg7Q7fGRdkTKozkAurs3ywsiQyIgXLUPjfc1EL6nDfVhH8Kb+ZlJOIFLks2OWF9AS3n88ceRmZmJLVu2qN73er0YM2YMunTpgtWrV+PUqVOYNGkSRFHEm2++GaOrNQ+PvCgGtardJqDRJxJ1Q5lFUx4fGsWeUUK3wy4AHjq9XHoeH5rFLRC+nJ3GZxkwsJnyRN9wxzeQ5P0wE92Dlgn0clnK4/P9999jyZIleOWVV0J+t2TJEuzcuRMff/wxBg8ejMsuuwyvvvoq3n//fVRWVsbgas1FmhCVwofmBcLI4+OguOW7ZJPDrn4saQ4JSIue/qGGdDZtlEQ7S0eThE30pfBZBgxspjzHRy9PkUSbLSN8Tpw4gSlTpuCjjz5Cu3btQn7/yy+/ICcnB5mZmfJ7V1xxBdxuNwoKCgz/rtvtRmVlpeqLRORQl52NyVLvZGOAbhEg2RwS6qK44kfPy6W0n8JhlkMgel4uGgU9YNTTht5nGQify0WrzdpcVIDMkKYlhI8oisjPz8e9996LvLw83c8UFxcjLS1N9V7Hjh0RFxeH4uJiw789c+ZMpKSkyF9ZWVmmXrtZyDeUqt8JeS5Es9CrDgDIfIjMQlr0lD1tgGDvIhoFrk9ncVCOOY3hPa+OqGelhF9P4JLkCTATq3QxNgtRFHU99UGBS844x1T4TJ8+HYIghP3asGED3nzzTVRWVmLatGlh/56g6fkC+AdD732JadOmoaKiQv4qKipqs12RIBgG0ZksKdwlBkWAfqiLpIfILGSPT4jNrHl8aD+mw//KogjQy3eh8b4G9IsVSAz7mIVyHB12nQ06QeMc0+TmqVOn4pZbbgn7mezsbLzwwgv49ddf4XK5VL/Ly8vDhAkTMG/ePKSnp2Pt2rWq35eXl8Pj8YR4gpS4XK6Qv0saoijKFS5qt6k0cdD3EHl1DuwEyOwCahYeHXEL0O0elxdEnRwfgKzJ0iz08ppkEUDhGAMGB/BSfF8D+u0paD6dXemRVos98myOqfBJTU1Fampqk59744038MILL8g/Hzt2DFdccQU+++wznHfeeQCA4cOHY8aMGTh+/DgyMjIA+BOeXS4XcnNzI2NAlPD6REg5nnHK2CnFJbB6O0QgOHHQbLNDE+qieZeoe1I55V3JJS3HUk8bj05xBu1tC6QNaZyDQY+PzvNMks2WKGfv0aOH6uf27dsDAPr06YPu3bsDAEaPHo2BAwdi4sSJePnll1FWVobHHnsMU6ZMQXJyctSv2UyUStmhN3FQuSsOH+qi0cull8AO0J0XoJfjIwgC7DYBXp9I1C7RLPRyfJTCp6nwvBXRu7dp3rgBivQEPRFAoc1KYePUiUyQZLMlkpubg91ux+LFixEfH4/zzz8fN910E66//nrd0neroVzkdStBKNwxGZWz01wJ0tiEx4fOvCYjzx69C4S+90NxJhuFNksiIE7HZhrDmYCR2KPXZo8iL1PQLeEnx2ZLeHy0ZGdn6/b36NGjBxYtWhSDK4osyhvGqRPqonGiNPL40Fz2K9kc2rmZAc+eTi6XG2S5x83CEybpFfDf20571C8rosg2O9QNWJW/ow051KXjpadxs6p3XwNkhjSp8fjQjHTDCIK2BJZ+EaAVPjSX/UoTR2h4j95x1utIDtBd8RPM/QgVAQCdi2KD5sgdgP4GrJJZeukJNM5fei1XADK99Fz4WAC5a7NRfxcKd0xegz4+VB/YqRMC8f9Mr80NjZIngJ1KNk+jcRd2gB2BS7PHR5WeoFvOTt8YNxrkKJLopefCxwIYuhClRF8KFwdjjw95D5FZ6J1bBdBts144AKA7ib1BRwQoh5xKb4CU4+NQij16xa1yDHXzmii0OdiOQ9/jQ9LGjQsfC2B0QwWVNDk3lFmw2MVYGke7dsdEsc0enQURoLttgV7SqyAIdHv2dEJdNPcuajQoSKG5nN2oASuJDQy58LEAhmc4Udy5uamqLhp3TEYx8qD3gz6b9bwfgDJxn8IFQqfCCaC7E7teqIvmcGaDQtio2xbQLOj1N+gkerm48LEAev0gAEUIhKAbyizcTYRAaF4cjPr40LhLlHN8DE6kp3mcQ3K5KH6e9UJd2t5FNKEUt3ql3SRVOJmFUY4PiZsYLnwsgNGCSLVrvDG08gUgc/dgFkZeLprbFhiXwNI7zg0GNtspDYP4FI0oHTreD4A+b6bxJoZeQW/osSYwR5ELHwsg31AMlfwaCR87xZVsVnIVm4W0QLi0ApcJscfGOCu9G8o+PkpRQFvoR69JJUDvGAPGYo/E9AQufCyApzE0MRCgu5zd3egFELog0l0JYjDOlHoCAKDBcIGg12bjhG46vQFKe+J0ytkB+kI/Rp5Mmp9l4yIc8mzmwscCyKf8GiaA0jVRAuE8PvTumIzL2ekfZyNvJo02ewxtpjN03dSROwDgpVTsheZl0vssS8JGW9VFos1c+FgAt8fv/Yh3GoW66JooAWPhQ+LuwSyCyYFGbQvImTjMwijsQ3OFk1GOD61dfSV7QzvPC5Dyfqnz+EiVuA6tx4fiZ9kgJYNEm7nwsQD1AREQ71Af4MNCOajLsBkWfTYHd4nkn3VjFnrHNwB0J+4bN20kb4EwA2W+i/bUeVrnMNmrZ4HjG8zCqKqLNzDktIp6I4+Pjd7kZrcnIHw0pzWSuHswC3ejZDMbCyIQXCBCe9rQabPyDCfDvCaCFggzaDQQegCZFT9mIIetDbvt0zXGQHOO3CFnjLnwsQBB4aMVAfSGfRoMJkuaPT7yODPo2QsJCVBqszIs7WSkks2o2gdQeDMpm8OMGnNKHiBRpPDeNijOIFHccuFjAYyED60TJRCujw+du2Ig6PExGmfaFgfAOLnZTml4T9nR17B3EUELhBk06BzKKuGgtEqz0aDCSXkcDW1zmJGXnoe6OK2i3iMtiEahLnJuKLNwNyl86JoogaDA1Ya6aA7veRQdbpXQarMU2gP0Gr1JIoCu51la8PRCXXZKw/WSoNfmKCrHnLZ7u75R8ljrP8skiVsufCyAvCA69ENdJN1QZiH18TFOAKVrcQAUE4fBjok27wdgnNxMa0jTo0hgtxl06KZNBLhlr15oqIvWOawuMGcnxOk/ywB993Z9Q3ibSbqvufCxAJLHJ/SGonO3BCh2TCFeLjonSkDh2WMkx0d5lIFhTxvKBK4s6B06YR+5RxVdNtfJC6Ij5He0ivq6hkYAQIJBXiZA370tiz0L5KJy4WMBgi5EgxuKskkDME5upvmYDqPqPVrDPm5F2IeVkGZtQAS002xiAHoP4A1nM4lhEDMw8vgIgkCtN7NODtUb5fiQYy8XPhbAuJydzokSCCbKGS2ItE2UQNBmVpKbawO7YiB0l0hrCX+tQTgAoFfs1Rt4AgB6q7rqGvSfZYBMIWAGcmTCqAUJQfZy4WMBjKu6aE5u1s9rolUEeH1isGkjI2JPEgHxTpsq9wFQlrPTNc5S2KedMzTsQ+sBluHEHq0duo3CPgC9ZywGbTaev0SRjHHmwscCGFV1kdgYyiykyTLRxUa+iyT0AB2BK+VyUWazPMa6uR902mwUAgGCpc70LojshLpkL1ecXiUbnfN2fYPBBl1ZyUaIzVz4WIC6Jm4oUm4mM6l2+8MgiS71okirCJDELRCmXxNlC6IU6tITAbRW+0g26+a7UCrqjRJ9AWXFD133tpzQHUbs0eblknJRtc+zsnElKfc2Fz4WoCYwcSTFa0QApQuiKIqoCQif9hrhY7fTGQKRdohOuxAa9qF0ogyX9Er7gqhvM52J++G8XLQK3DqD9ASAzIZ+ZmC0QVfOZ6Q8z1z4WIDqekkEOFXv09rp1d3ok88z0i4QTkptNjquAqB3ogwKH518F0pDILVhSrudlIr65uT40ObBDS/26JzD6ppIbgbIeZ658LEAVQbeD1oPvJPCXEDookhrfFyyuX288YJIm83hwj4OApuemYG0ILYLG/ahy+b6MDY7KW1IKtscrm0BZfO228DLpXRgk3Jvc+FjASSPjzbU5aS074cU5kpw2nXCPnS6xqsMxhhQHk1Cl83hwj4Oar0f4fKa6PRy1TFYwl8bJseH1ko2ow26IAjE9ZzjwodwPF6fvEsM8fhQelZXjVuq6ArT6ZUym6vqPQCApHhnyO8clJa/1oQLdVG6ODQrr4mQxcEsJG+m3jjbKQ1dV9YZP89OSotSJJuTE4znbVLGmQsfwqlRhH20YRBaTzaWkrnbu9jZFVeG8/hQanONXLmn5wmgdXGQxllH4ErPMyGLg1lUBBbElAQdEUCpZ6+y3thmGsP19R6v3Ik9WW+cCXueufAhHCkEEu+0hZ5nRNjNZBZSaE9/h0hnHkS4HSKtuVzBBTEu5He05kFINndoF8azR9nzHE740Po8SzYn63l8KKzGldYpQQDa6xYrkCVwufAhnCqDii6A3i7G5bUNAIBOiToLIqUdfcPl+NBaySaNs74IoDOvqaLOb7OeCKA1dB3e40OfN9Pd6JX7cumOM4FHOLQVycOV5HLApsnLBMhr1cCFD+GcDkyUHXUWB1oXxLKagM16wofSUtBwwodG1zgAVNQGvB+6IoDOMO7pMDbTmrjfLI8PRRsZKZwpCE08zxTNYcH8ntAxBsi7t7nwIZzyGv8NpS8C6AwHyB4fBsMBrLjGAeC0HPYxvrep9X7o3Nuk7YrNoCnvB42VqZL3o72B94O0CiczkHIU9eYvgLyiFC58CKdMFgGhiwOt/V3KAmKvU6Ir5He0ir3SajcAoEt7PZvp9HKdDhPqstPq8WEs0VcSek16PygaZ8mrpzfGAJ2VbOU1xs8yQN4J7Vz4EE65HPYxzgmg6QECgjZ30rGZxokSCAqf1CTjvCaawgGAIuyjF8alUOzVuBvREKh86aizkaGxi3FplRSqj9P1fgTnMHru7ZNVgWdZZxMDKE5np+h5lmzukqRvM2nhPS58CEfOdwk3UVI0aQBBEaDn8ZHymkSRLm+ALHx0PT70eT8aGn04Fbi39bxcNB7TcaKyHoA/BKLXo0puW0DI4mAGJVV+m7saLIik5X6YwckmbHZQ6Kk/GcZjDShTFMh4nrnwIZxTNcYVTqS5D83ieIV/4khPiQ/5nXRIKUDOQ9RWfD4Rp6r946wrfBS5H6JIx1hLC2Kc3WZwb9O3OJyo9C8OXZOtsTiYQUnAE5CWHPosA3TmNUneD+Nxps+b2ZTHhzSxx4UP4RRX1AHQFwFKTwAtC6LXJ6I4sDPO7BBqs+TxAeiZOMprG+QJoXN7YxEA0LMzlrwfXZNdEIRwIRA67AWCYi8tSV8E0Ji4X1LZXI8PfWKvq9E4U5i436TwIex55sKHcCQRkK6zY1KKAFp2TCer3PD6RNhtgu7EoTy7i5YF4ki5X9ymJbvgCnM6O0CPzcUV/olS774G6PR+FFcExZ4eDgornCTvrbHHh768pqOnA5vVJmymZRMDKGzW2aAD5AlcLnwIRhRFnJAWiDAeH4Ceh6iovBaAf9LQHlAKBBdEgJ6ESMnm7h3b6f5e2bGbFuFzuMxvc7eOCbq/p7HJW+GpGgBAj0764xzsxE7HfQ0Ebc5OTdT9PY2nszdpM2Ud970+EUcCc1jPzvo2k9ahmwsfgimraUCD1wdB0HebKoUPLRU/+0uqAQB9urbX/b3NJkDSPtSIvTL/binLSARQKPb2n/SPc+9U/XEmrQrEDPaf9C+IvbvoLw40Nm0sLPUviL1S9cUebePc0OjD0YAHN9vIZso8e8WV9fB4RTjtgqGXi7QO3Vz4EIzkJu6c6EKcI3SoHBTmuxwo9S8OfQwWByDoDaDFPb63pAqA8Q5R6fkiZcfUVg6clASukSeAPhFwMHBvNyn2KLG53uOVQyC9DGyWxR4lOYqHy2rhE4HEOLthhRNt5ezSs5zVsZ2ulx4grwKZCx+CkYRPhkHc1G4TIOWF0uIJ2HmsEgDQr2uS4WfkyZISEfDbcb/wOTMjWff3giBQ5Q0QRTHo/WhCBJAyUbaVqnqPnADay8jjQ5nYk0I+KQlO3SN3APoSuiVxm52aqJu0D9AXxt113D9nG81fAHkHanPhQzCHpJyAzvouUyAYL6bB++HzidhSdBoAMCgrxfBzNCW+erw+7AuE9waGmzgoqgQ5UelGRZ0HNgHo1UTuBy0iYFdA3KYlu8K09Ser8qWt7DgqbWLaG4oAO2U5PtuOVgAABqQ3vXGjxWZps3pmRjNsJuR55sKHYKSwTy+DhDFAWQli/YfoQGk1qtyNSHDaMSAtzENE0Y5pX0k1Grw+tHc50K2Dfo4PQFdC5MbD5QCAAenJSIgLrWID6PP4bArYfG5WB8PP0OTVA4BNRX6bB/foYPgZJ2U2bw5s3AaHG2fCetq0lZ0Bj8/AzKY3bqSsU1z4EEyhJHwMdsUAeUq6LfxyoAwAcHb3FFnc6OGgKCFy7YFTAPyLg15LfwnSJo62sPGQf0HM7dnB8DM0CT0gKPaG9Oho+BnaTirfdPg0AGBwM2ymYZzVHusOhp+TPHs0iL2ymgbsOeH3WJ/TvYPh50ibs7nwIZjC0vBlkQBdZxot/60EADByQJewn6Mp1PVLQPgM79M57OfsFAkByebcnmEWRIp2xY1eH9Ye9Iv6cDbTlNB9qtotewLC2UxTXtOOY5WoqPMgMc6OM9LD5bvQc2//st//LJ+RnmR4NhmgOI6FkCR2SwmfxYsX47zzzkNCQgJSU1Mxbtw41e8PHz6Ma665BomJiUhNTcWDDz6IhoaGGF1t26iq9+BYILm5dxjhQ0tIoLLeg//tKwUAXHJG17CfpSXUVe/x4n/7/BPHiD6pYT/rpKQE9nhFHXYcq4QgABf2Mxa4ToryIDYVncbpWg9SEpxhQ1005fis2HMSoujPWzNqXgjQZfOywMbtgn6pulW4EnaK7u3lu/02N7VxIy2vKfSkPEL58ssvMWXKFLz44ou45JJLIIoitm3bJv/e6/VizJgx6NKlC1avXo1Tp05h0qRJEEURb775ZgyvvHX8VuxPhsxIiUdHnbOMJGg5r+vbzcfgbvShf1r7sPk9AHlu09ay/LcSVLsb0a1DAs7pZpzMDSiSmy3u5fphezEAfw5EuB2itDj4RH8IIVwYkHS+23YcgN+T2ZwQLg3eD8nmJjcxlNgsimKLbbb6nF3v8eLHwPN8VU5G2M+SFtK0hPBpbGzEQw89hJdffhl33XWX/P6AAQPk75csWYKdO3eiqKgImZmZAIBXX30V+fn5mDFjBpKTjV2PJCJlyoer9AHoyP0QRRGfrD0MALh5aA/DChCJYHKgdW0GgK83HwUAjB2U0eTCTtpZN61BFEUsWFcEALju3G5hP+vQdKuOs6jwcTd68dUm/zhf34TNpC0OraWksh7Ld58EAFw/uHk2W13QbzlSgd0nquBy2HBlEyLAQUnF4n93laDK3YjMlHjkhQlnAuRVaVoi1LVx40YcPXoUNpsNgwcPRkZGBq666irs2LFD/swvv/yCnJwcWfQAwBVXXAG3242CggLDv+12u1FZWan6IgFZ+ITJlAfo2D0s2XkCu45Xol2cHeOamCgBOtzjh0/VYunOEwCAcYO7N/l5GvKaCg6Vy4tDUwuisls1KZNla1i89ThO13qQkRKPi/o3L3eNlPOMWsv8dUXw+kTk9eyIvgYd2CVoyWv66JdDAICrz85ASoJ+uwIJGuZsAJi75iAA4PdDujW5ceNHVrSCAwcOAACmT5+Ov/zlL1i0aBE6duyIiy++GGVl/qTB4uJipKWlqf67jh07Ii4uDsXFxYZ/e+bMmUhJSZG/srKyImdIC5BLBJvw+Fg9ubnR68Pfl+4BANx5fnbYsJ4EDZPle6v2wycCF/XvErbnh4TD4uMMAK//tBeA3/PR5OJAwXEsjV4f3lq2DwBw++96Gna1laDB41NR58EHq/3z9R0jspv8PA2bmMLSGtl7e8fwnk1+noYcn/WFZVhfWA6nXcAdw7Ob/Dxpoj6mwmf69OkQBCHs14YNG+AL/M966qmncMMNNyA3Nxdz5syBIAj44osv5L+nFyIRRTFs6GTatGmoqKiQv4qKisw3tIXUNXjxW7Ff+ORQnvsx+38H8VtxFZLjHZhyYe9m/TdWT+jeV1KN+YGQzx8v7tOs/8Zp8fDeL/tPYfW+UjjtAqZe0rfJzzsVx7FYtUP3wk1HcaC0Bh3bOTGpGSLAQUGZ879WHUBlfSP6dm2PMWeHD/kAdOT4vP7THnh9IkYO6BK2dF/C6jaLoogZi3cBAG4Y0j1s8roEab2LYprjM3XqVNxyyy1hP5OdnY2qKn+i78CBA+X3XS4XevfujcOH/bkh6enpWLt2req/LS8vh8fjCfEEKXG5XHC5jJMsY8GWI6fh8YpIS3ahu8HBlRJW3jEdLK3BawFvz1/GDESHdk17ewBrTxyiKOLZ/+yA1yfisjPTmqyGkLDyYY7uRi+e/mY7AODmoVnIMjidXIktcByLKFpT1JfVNOBv3/8GAPjjyD5o72p6qiVtcWgp+09W490Vfm/PI5f3b9LDBSi9XNYbYwBYs68UX28+BkHw29wcrF6V+tWmo9hcdBrt4uzNtpm0dSqmwic1NRWpqeHLeAEgNzcXLpcLu3fvxgUXXAAA8Hg8KCwsRM+eftfi8OHDMWPGDBw/fhwZGf6dxpIlS+ByuZCbmxs5IyLAhkJ/+C4vu1OTib5WLfuta/Dijx8XoN7jw/l9O2N8XtN5LhIOCx/TMX9dEVbtLUWcw4b/d/UZzf7vrNzQb9bP+7GvpBqp7ePw2OgBTf8HAZw2Gxq8PmImy5bwwuKdKKtpwIC0JNx5fq9m/Teklfy2BK9PxP9buA0NXh8u7t8FV+WkN+u/s/ImprahEU997Rf0t5/XM2wDPyVWtrm4oh7Tv/Xn1t4/qi+6NsPbA5CX12SJqq7k5GTce++9eOaZZ5CVlYWePXvi5ZdfBgCMHz8eADB69GgMHDgQEydOxMsvv4yysjI89thjmDJliuUqutYX+ru8Dm0iUx5QhrrIuKGagyiKeOrrbfituAqp7ePw2k3nNinwlASbnllrgThYWoMXFu8EADx+xQD07hI+8VOJVc/qWnvgFN4M5Lk8c81ZzfbqAQFvgNd6C8RXm45g4cajEATgxXFny3l4TWHlEv5/Lt+HtQfLkOC044Xrc5r9PEveD1KSXlvCX7/ZgYOlNUhLduHPVzZf0Fs1VO/1ifjzv7egsr4Rg7qn4J6LmpeaAJA3Z1tC+ADAyy+/DIfDgYkTJ6Kurg7nnXceli1bho4d/eLAbrdj8eLFuO+++3D++ecjISEBt912G1555ZUYX3nLaPT65Jb+edmdmvx8sEyQjBuqOXyw+iAWbjwKmwC8eeuQZsWIlTgIqxBoDmU1DbhzzjrUNngxrFcnTG6mF0DCisnNpdVuPDB/E7w+EeMGd8PYc5rO+VDisAuAx1oLxL6Sajz1ld8L8OAl/cJ2LdbiUOY1iSJssIbwWbO/FK//5A9Zv3B9TrNCmRJW9X78u+AI/l1wBDYBeP3mwYYHz+phVZtnfrcLq/aWwuWw4dWbzm22oAfI671mGeHjdDrxyiuvhBUyPXr0wKJFi6J4Veaz5UgFqtyNSI534IzmVPtYTAR8s/koXggkxk276sxm57gosdpZN/UeL+75cAMKT9WiW4cEvHXb4Bbv5q02WTY0+vDg/E0oqXKjb9f2eOH3zfcCSFitOWdlvQd//LgAtQ1enN+3Mx68tF+L/nu7opLN6xPh1D+/lSiOlNfiwfmb4ROB8bndcUNu80PWgDUr2bYfrcDTgRDXw5f1b/EcZsUcn3lrCvGv1f7y9ZfHD2qyTYEW0o7csUQ5O0us3ONv/HVBv9SwXV4lrOQJWLX3JB77YgsAIH9ENu6+sGVeDwmnhZo2+nwiHv1iCzYcKkdSvANz7xyKrkkt83ABCoFrAc+eKIp46qttWLP/FBLj7Hh7whC0i2v5HstKCd0erw/3fbwRe0uqkZbswus3D25Wcq8SZe8iUhaIcFTWe3DX3A0orXbjjPQkPHddTov/Bmllzk1x7HQdJs9djzqPFxf174L7RzVdoajFapuYpTtP4Nn/+PN6Hr9yAK4dlNnEfxEKaS1IuPAhjJV7/cLnojDnGCmxSmO77UcrcO9HBfB4RYw9JwN/HTuwxR4ACSvtEl/6cTcWbz0Op13Au7fnol8Tx3EYYaV+Tf9cvg9fBMIAb902BP1ba7NF7m1RFPGXr7Zj9b5StIuz44NJQ9ElqeWVokqhRHoJv8frw/2fbMTuE1XomuTC7PyhSIhruYvKSs9yVb0Hk+euR0mVGwPSkvDWbS0Xt4C1BP3WI6fx4PxN8InArcOymt1+Qwtp1Xtc+BDE6doGbCk6DQBNdnmVsEJy4KFTNcifsw41DV6M6NMZr940qE2Jm6S1Pzfik7WH8M6K/QCAv407ByP6Nl3BaIRVEiK/2XwUryzx53s8e10ORjVxblE4rBISeGfFAXy2oSiQsza4yd5bRqg9PuSOsyiKeObbHVi1txQJTr/Qy+wQvu2GEVZ5lhu9Pkz9dBN+K65ClyQXZt85tEV5PUqsslk9Ul6LyXM3yN6t565rebhagrQcHy58CGLl3lL4RKBf1/bNnkhIL2c/WeXGHbPXobS6AQMzkvHuxFy4HG1LXiCt/bkey3eX4K/f+N3DD1/Wr8W5D1ochLmK9VhfWIY/f7EVADDlwl6Y+Lumu9iGg7TJUo9FW4/h/37w9+t55pqzcOmZxj3DmkIQBPneJnmc31t5AJ+uPQxBAN64dTDO7t46oQdYw/shCb0Ve04i3mnDB5Py0K2VQg+whqCvqPPgzjnr5TDmP28b3KJkZi0OnuPDMeK7rf7TfVsyeZLc9Kza3Yg7567DoVO1yOqUgLmThyKplbskJaTn+Ow4VoGpn2z0VzMN6YaHWpjkqgfpfXz2lVTh7nkb0OD14Yqz0jDtqjPb/DdJP4D31wOn8Mhn/py1O8/PblZ35qYgPfTzzeajmBlozPj0mIG4fGDrhR5gDe/H2z/vxycBoff6zYOb3a/HCNLFbUOjD3/8uEDOV5tzZ9vnbdI2blz4EEJVvQfLd5cAAK4Z1PyyX1KTm6WHZ/vRSnRKjMO8O4e1KqlXD9J2D0qOV/iTH2savBjeuzP+Nu6cVruHlZDcx+dEZT0mzV6PijoPzs3qgNdvbnnVmh6kVYIo2XOiCvd86Bd6owem4S9jBjb9HzUDkr1ca/aVqooT7jw/u81/U9u7iDS+LDiCl3/cDQD469iBuLKZjRnDQfIYi6KIaQuDhQmz84ciI6X13i0J0kL1XPgQwk+7TsDd6EPv1MQmDyZVQmICqC/Q6GrVXn+y55z8oS1q1tcUpCXKSVTV+93DJyrd6Ne1Pd6ZmIs4hzmPGKmVIFX1HuTPWY+jp+vQKzURH0zKa1WSqx6knk92vKIOk2avQ2V9I3J7dsQbt7YuyVUPUu/tXccr8YdAccKYs9tWnKBE27uIJFbuOYknvvSHbv9wUe9md+BuClLHGADe+O8+fLnxCOw2AW9NGIKzMlsfxlRC2jl0XPgQwqIt/jDX2HMyWjShSLtikvJdZn6/C99sPgaHTcDbE4ZgUFYHU/9+MNRFjs0erw/3B5IfU9v7q1yaOoG8JZCYxO736m3EruOVSG3v9+p1bm/euXck7owr6jzIn70exyvq0adLIv51Rx7iTWy4Q6LAPXq6Dvlz1qHK3YhhvTq1uThBiUPTu4gUth+twB8/LkCjT8R152biiSubf7xMU5AW9pH4suAI/h5oRPn8dTkYNaD1hQlaSDuyggsfAqio9chl7Ne0sEcCafku7688gPdX+RtdvXTjORhp4sMjQZoIEEURT3+9HSv3nESC047Z+Xkt6l7bHEjLd/H5RDz+7y1yCfec/GHo0dlkmwkLdbkbvfjDRxvkEu55k4ehY2Lzj+BoDqSF907XNmDS7HU4UelG/7T2eH+iuULPrqpkI8PmorJa5M/xh6vP79sZL99ontADyLuvAX/37ScX+r1b917cB7ed18PUv28nzHvLhQ8B/LijGB6viAFpSS3u80JScvPXm45ixnf+rsxPXnUGxg1pWyWTEU55V0zGQzRrxX4sWF8kV7m0NflRD9KSm1/6cTe+3nwM9oBXry2VPUaQlNfk84l49PMt+PVAGdq7HJhz51B072iu0API8vjUe7yY8uEG7CupRnpyPObeOQwp7czzYgKaEn4Cxrmsxi/0SqvdODMjGe/cbl64WkIeY0I2bntPVAXDmOdk4PErmn/uWHMhzXvLhQ8B/GfrMQBo8VlGgHL3ENtJY+WeYFfmyef3wh9acIBdS7ETdDr7t1uO4aUf/MmPz4xte5WLESTlBcxbU6joT3R2RLx6QNCzR4IIePG7XVgkNaKcmGta7oMWUjYyXp+IP322GesLAx3HJ7e+V084SPL41DV4cfe89ThQWoNuHRIw14RqJj3kRF8CnuWTVW7kz1mPqkC+2qvjzfVuSfAcH46KU9VurNl/CgAwtg2twGOppLceOY17A/HwawZl4i9jzjQl8dEIUsI+GwrL8NjnQbGXb1Lyox4kjDMA/LD9OKYH2tc/Nro/xudlRezfImWX+MHqg8Fzim4chPPb0IiyKUg4wkEURTy/aCe+316MOLsN703MwxnpzS+4aAmk9C7y+kQ8uGATNh4+jZQEJ+ZNHtriw5ObCyk5PnUNXtz94QYcPV2H7M7t8L7J+WpKSBH0Elz4xJgfdhTD6xOR0y0ZvVITW/zfxzrfpaisFpPnrpcPZnxl/DkR2TEoIUEEHD5Vi3s+KpDLmZ8a0/a+NeGI9TgDwOai03howWaIIjDhvB6tOqeoJZBwPtmSHcV4YfFOAP7w7fWDu0X03yOhod+8NYWYu6YQAPDqTYNadZBwSyChd9GMxbuwdOcJxDls+NekPPTt2rpjVpoDCTk+Pp+IRz7fjC1Fp9GhnRNz7hyGTibnqykhyWMNcOETc/6zRQpztdzbA8S2AVhl4Oya0uoGOR7e1q7MzSHWCaCV9R5MnrceZTUNyOmWjNdvOde0cmYjYt3o7ejpOtw9bwPcjT6MGtAFz157VkS9ekDsd8bbj1bIQu/23/WIaPhWItYhgeW7S/DcoqDQa2mxRWtwxjjn5eNfD2H2//wevb/fdC6GZneK6L8nPctiDHsXvfTjbny/vRhOu4D3Jua1atPdEqQcRVLymrjwiSEllfVYe7AMADDm7Jbn9wCxCwc0Bg4p3FtSHTikMC8i8XA9YtnfRbJ7X6Cr6b/uGNqqk8dbSizLQavdjbhrbrB9/Zu3DZE9UJHEEcNWDScq63H3PP85RRf2S8X0ayIv9ABl/kf0bd5dXIUHPvUfSHlTXveoCD0gtjkvq/aexDPfBkO3Y1qRZ9lS7IoS/ljY/Nn6w3KO3ks3noNhvSIr9IDY3td6cOETQ77bdhyiCAzu0aHV5c/Bc1+i9wDpHVJoRnfP5hLLBfG5RTtVdqenRCYPQEuwQ3d0J0qvT8TDC6T+RHH416Q8tHdFXugBSo9PdG2ua/BXMxVX1qNv1/Z4K0pCD4idzSer3Jg8dz2q3Y34Xe9OeOH6s6Mi9IDYJbHvK6nCfYqjZSIdupVQVrJF2+b/7SvFU19tBwA8eGk//H5wZCpvtcTae6uFC58Y8p+tUtPC1ruTY5HvMvt/hcGza245NyKlzOGIVXLzvDWF+PCXQxAE4O83n9vqU7hbQ6zymv72/S78tKsEcQ4b3rsjLyIl3EbIOT5RtNnnE/HoF5ux9UgFOrZzYvYkcxtRNkUscnzqPV7c89EGuft2JEq4wxELm09Vu3HnXH8109Dsjpg5LopCT9GtOpoe3H0lVXIRyrWDMvGny9p+hmBzCUYmeI4P0xw7XYeCQ+UQhNaHuQCF9yNKD9BPO0/IyZ7/76ozccVZbT+7pqXEIuzz8+4SPBuoZnriyjNMObOnJcQir2n+usNyM8pXxg/CkB4do/ZvA7E5h+61pXvw3bZANdMdeaY3ZWyKaPfxEUURf/73VmwKVDN9MCkPHdpFLslVj2jb7G9EWYCisjr06NQO707Mi0puooTK4xOle1sp9HJ7dsRLN5pzhmBzISGhWwkXPjFiccDbMzS7U5vCJdH0fuw4VoEHF2yCKAK3DsvC3RdGrnw7HNFeEHcXV2FqIPdhfG70ch+URDuvac2+Ujz9td8l/vBl/XBtFJJctUS7tPvLgiN4a/k+AMDMcWdHPMlVj2gvEK//tBf/2eI/XmbW7UNMPVOvuTiieG+Loognv9yGDYf8/Ylm5w+NaDWTHjabAElzRGOc3Y1e3KMQeu9NzI1Y2boRdl7OzgGARYGmhde0MZlOnigjLAKkZE+pbP2563KiumNQEs2DWUur3bhrnj/3YVivTpjx++i5xJVEM6/pwMlqlUv8oUuj5xJXEk1v5rqDZXLL/vtH9cENudHJfdASzVyIbzYfxT/+uxcA8ML1ORjRJ3L9icIRzUq2t5btw1ebjsJuEzBrQi76do2+0AOiV6UpiiKmfbkNBQqhZ+Z5es3FSUCvJiVc+MSAQ6dqsOVIBWwCcGVOG4WP1NY/gg9QbUMj7p63QT6Y8e0JuXBGKdlTj2j1tKn3+F3iR8rr0LNzO7wb5dwHJdHy7JXXNGDy3PWorG/E4B4dou4SVxKtc+gOnarBHz7aAI9XxFU56Xj0cvNb9jeXaPW0KThUjj//2y/07rmoN24ZZu7ZTC3BHqVcrsVbj+PVpcFDOC/oFxuhB0Qvr2nWiv1YGBB6b08YEjOhp2xSKYqxFz9c+MSARYEw14g+qeiS1Db17YzwDtHnE/HIZ1uw7WgFOiXGYU7+sKgme+oRjZwAv0t8KwoOlSM5sFMy+0DKlhANmxsaffjjJwUoPFWLbh0S8J7JB1K2lGiIgIo6D+6atwHltR6c3S0Fr910bsQbcIYjGuG9orJa/OGjDWho9OHygWmmnjzeGqJxb28pOo1HPt8MALjrgl6mH8LZUpxR8HL9sL1YPk5n+jUDcWG/LhH7t5oiVgndRnDhEwMWydVcbe8ZEekQyKtLd+OHHf5kz3cn5kY92VOPaBxe+dayffh6s5T7kIs+Mch9UBJpL5coivjL19vw64EyJMbZ8UF+XptFeVuJdC5Xo9eHqZ/6ezJlpMTjX5PykBAXO6EHRN77UVXvwd3zNqC0ugEDM5Lx+s2Rb77ZFJHu6nu8og5TPvQ337zkjK74f1dHtst6c4h0zsv2oxX402ebAQB3DO+JicOzI/LvNBeHoncRCeEuLnyizL6Sauw6XgmHTTClMiiSIZAvC47gn8sDh1HeEJtkTz0inQD6ny3Hgi7x63MiejZTc4l0XtP7qw7g8w1HYBOAt24bErGzmVqCM4IeH1EUMf0/wV5U79+RF7GzmVpCXKC6qKHR/HH2+kQ8OH8Tdp+oQpckFz7Iz0NilHoyhSOSfXykMH1JlRsD0pLwjyh0WW8OkczxKamqx5QP/c03L+ibir+OHWj6v9FSSDqMFuDCJ+pISc0X9Es1pWzUaY+MCFhfWIZpC7cB8Cd7jhsSm2RPPSKZ+1FwqByPBk6Zv/uCXrg1hrkPSiKZE7BkRzFmfv8bAODpsQMx6ozInLbeUuwRHOd5awrx8a/+XlT/uCW6PZnC4QrkkLkjIHxmLN6F5btPwuWw4V935EW16Wg4nLbIeHB9PhEPL9iMHccq0TnR33wzWt3lmyJSz3O9x4t7PizA8Yp69O6SiH9OiF7zzXAoS/hJ6OUT+/8jDCGKohzmuqYNTQuV2CMwaRw+VYs/BA7gjHWypx6Ryv0oKqvFPR/6cx8uOzMN0whwiUs4IiRwtedR5Y/INvXvtwVnhDx7yvOopl11BkbHoBeVEUHh4zX173669rB8HtVrN52LQVkdTP37bcHljIzYe3nJbizZeSLQkym31d3xI0EkvNaiKOLxf2/F5iJ/T6ZoN98MB/f4MMzuE1XYV1KNOLsNl5+VZsrfNDtJrrLeg7sCB3Ce3S0Fr940KKbJnno4I5D7IR24eqqmAWdlJhPjEpeIhJdLex7VM1E6j6q5RELgKs+jujkvC1MujH5PpnBIjfTMFAH/21eKv37j78n0yOXROY+qJcQHbK73mCf2/l1wBLN+Dp5HlduTjDC9hCRwzQxp/v2nvfhW0ZMpO8IHj7YEQRCi3qgyHFz4RBHpJPaLB3RBskku12Cib9tvJnejF3/4sAB7Awdwvn9HXlQO4GwpZjc88ygOXE1LduGDSUOJyH1QYnZPm2q3P/dBeR5VLFsU6GG22DtRWa86j+r562PXi8oI2fvhMcfm34or5Z5M152biQcuic55VC1BsrneJJtX7jmJJ7/0l+pPHdUX1w/uZsrfNROpWrLOJLE3f91hvBHoyfR8DHsyhUOaXyKRv9ZSyJrpKEYV5jKxC65ZHX19PhGPfL4Fvxw45a/qieIBnC3FzAfI5xPxxJdbY3LwaEswM4m9odGHez8qkFsUkOQSV2JmJVtFnQeTZq+L2XlUzcXMUNeR8lpMmr0OVfWNyOvZEf93Q+x6MoUjXvZytd3m7Ucr8EdF881HLu/f5r8ZCeJlsdd2m5f9dgJ/CXRZf+CSvsTkJWqRKibNEnttgbwnn1K2H63EoVO1iHfacKmJyaNmdG4WRRHPLdqJxVuPw2kX8O7EPGKSPfWQ3cRtFAGiKGLm97uwcKO/wddbtw0m1m6zzifzH8K5Bav3laJdnB1z8ocS0aJAD7tJPW3qPV5MmbcBvxVXoWuSCx9OHhb186iai1mhrvKaBtwxex1OVLrRP609Ppg0NKY9mcLhckqhrrbZfPhULfLnrEdNgxcj+nTGy+PPIS5MLyGJgLYKny1Fp3H/J5vg9Ym4Mbc7sUIPABIkL1cDFz7M8J9ANdelZ6SZGkYxI7n5rWX7MHdNIQD/YZSx7GjaHFyO4ETZli6g76w4IB/C+dIN5+DSM83Ju4oEZuQ1SQJXOpvpndtziUpy1eI0oddJo9eHB+dvwrrCMiS5HJg3eRhRSa5a4k1I9K12N2LyvPU4cLIGmSnxmDd5GFLakefRkzDD+1FcUY87Zq9FabUbZ2Yk492JuVE9eLSlmJHXtOt4JSbNWYc6jxcX9e8S1RPmW4Mk9mq58GEDURTlQ0nNaFqopK3l7P9cvk/uWfOXMWfiunPJi4drkSZKoPVenw9WH8T//eAv4f7LmDNjdjZTc2lrXpMoipixeJcscF+9aRAu6h+7Tq7Noa2Lg8frw0MLNvsrexw2vD8pD2dmxL4/UThkj08rba52NyJ/9jr5tPV5k4cRU7ZuRHwbPT4llfW47f1fUXiqFt07JmDunUOJKVs3Ij6ubd6PPSeqMOFfa3G61oNBWR3w9gTycvS0JDjNT2JvLWT/n6IEj1fEXRf0wog+nU3vkaI81LCl3o9ZP+/Hyz/6W5r/+YoBuJuwChcjlDu51kyW76zYj+cD5cxTR/W1hN1tqXASRRHPL9qFf632e7eevz7HGgK3DTkBnoCnZ/E2f/j27duG4He9O5t9iaYjhXHrW+HxkUTPhsAxKx/dNQz90pLMvkTTCdrc8nEuqazHre//igOlNejWIQHzp/yOiEaUTSGLgFaM876SKtz2/lq58vbDycPQnrBiDD1I8viQ/3+LAuIcNky+oBcmX9DL9L+tVPker4g4R9OuTp9PxN9++A3vrTwAAHj08v64fxR51R5GOO0CbALgE6WEyObt7kRRxN+X7sEby/YBAB68tB/+dFlsTh5vKVLbAlH0i9zmltp7vD789ZvtmL+uCAAw4/c5mHBez4hdp5m0Niegxt2IB+ZvwrLfShBnt+GdiUNwyRnkhjGVBKu6WmZzSZW/Ym370Uokxzvw8d3n4ZzuHSJwheYjeXxaWsm2/2Q1Js1ehyPldchMicf8Kb8jOoypRPJat/TeLjhUhslzN6CizoMzM5Lx0V2xPzuxuSSYXMnWFrjwsTjtFGcL1bgbEecIn7RZ7/Hi8X9vxbeB0vonrjwDfxzZJ6LXaDaCIMDlsKPO4232ZFnv8eKJL7fim81+ux+9vD8euNQaogdQn3Xj8fpgtzWdv1BV78F9n2zEqr2lEATgxd+fTWzFhx4JrQiBSCXrO45VwuWw4Z3bc4npRN0cWpPcvK+kGvlz/AKgU2Ic5t451DKiBwDiW+Hx2VBYhikf+g+Xze7cDh9OPo/YJH09WhP2+WF7MR5asAnuRh/OzeqA2flDiU3S16OdHN5rjPGVcOFjeZx2G9rF2VHb4EVVfWPYE8QPnarBHz/eiJ2Bs8JeuvEcoo6iaAmJLr/wqWnGQ1RUVosH5m/C5qLTcNgEPH99jqUEANDy0413Ha/E1E83Yv/JGiQ47Xjj1sG4fKA1vB4SQdd48ybKNftL8fCCzSipcstHFAzu0TGSl2g6LT2y4j9bjuHJL7eipsGL7M7tMPfOYUQ1rmsOQY9P0yJAFEXM/l8hZn63C40+EYO6p2B2/lB0bh/bA3VbSnwLhE+j14eXl+zGuyv8HvpLz+iKN28bTGSPtXBwjw/HVJLiHaht8KKy3qP7e59PxGcbivDi4l2ocjeiU2Ic3rx1MBGHb7aW5HgnSqsbUFGrbzPgnyS/2nQUz3yzA1XuRiTFOzBrQi7xVWt6xDttcNgENPpEVNV7DGP6jV4fPvzlEP72w29oaPSha5IL/5qUZykPgIS0Q6xxeyGKomHFSr3HizeX7cXbP++HKAJ9u7bH7EnklumHQxY+TSwOp2sbMPO73/DZBn8Ic1ivTpg1YYjlBADQ/OTmY6fr8PTX2/Hf30oAAGPOycBLN5xDXLPR5tDcBoZ7TlThiS+3YtPh0wCAyef3wv+7+gwizt9qKTzHh2MqHRLicKLSjfLahpDfbTxcjr999xvWFZYBAHJ7dsRbtw0mvtKjKZICce2KOn3hs/1oBZ77z06V3a/ffK5lcgC0CIKADu38Yu90rUd3/H49cArP/Wcndh6vBACMGtAFr4wfZMnFEAA6Btz4DV4fahq8IWLP5xOxZOcJzPhuJ4rK6gAAN+V1x/Rrz7LcblhCqkYy2sR4vD4s3HgEL/2wG6dq/M/71FF98fBl/Sy5GALBBdHIe1vb0IgPfzmEN/+7FzUNXjjtAp66+kxMGpFNdPl2OILCR1/sldc04N2VB/DB6gPweEW0dznwfzecQ9xxIy2Be3w4ppLRIR67T1ThaLl/8vd4fVix+yQ+/PUQVu45CcC/e37k8v7IH5Ft2QlSSYeA8FGKvUavD6v3lWL2/wplu+OdNkwd1Rf3XtzH8nZ3aBeH0uoGlNcEbXY3erFsVwk+WH0QGw6VAwBSEpz48xUDMOG8HpZdGAD/Pety2OBu9KGsukEWPtXuRny/7Tj+teogdp+oAgBkpMTjr2MH4qqzrbswAECXJL9IPVXTgEavT75ny2oa8M3mo/hg9UEcCTznfbu2x4zrc3CeBarVwpEaEOYllW7V+8cr6vDvDUcw75dClFb77/ncnh0xc9zZ6G+BarVwdEr0z1+lVWqbD5ysxmfri/DJ2sOodvuF4GVndsVz1+Ugs4PFN6sBUX+6xthLHy248KGAXqmJ+Hn3ScxfdxjrC8uxYk+JPFHYbQLGDe6Ghy/vj24Wf3CU9Ah4bn7efRJxDhvWHijD0p0n5F2wTfAfDfL4lWdQY3e3DgnYV1KNH3cU40h5HX45cAo/7TqBqnr/BBlnt+Gmod3xp8v6W9bLo0QQBHTrkIADpTVYtO0YklwOrNl/Cst3l8hhkfYuByaN6In7Rva1ZMhDS6fEOMTZbWjw+vCfrcdQWtWA1ftKsWZ/qXx0R2r7OPzhoj6YNCKbyGM3WkpmB3/5+dHTdVix5yS2Fp3Gqr2l2HCoDFI6W1anBDx4ST/cMKQ7sd2YW0L3jv75a/uxCqzeW4pfD5zCyr0nsfVIhfyZMzOS8cjl/XHZmV0tvYGRyOrkn4c3F53G+sIyDOnRMWYHQQtiW1rfUkhlZSVSUlJQUVGB5GSym51JrNlXitv+tVb1XufEOPx+cDdMHN4TPTtbK9mxOfy74Age+2JLyPsd2zlx7aBM3HVBb0vmeITj70v34B+BgwiVpCfH4/dDuiF/RLYlepi0hEc+24yFm46GvN8rNRE35nbH7b/raZly3uYy/p01WF9YHvJ+Trdk3JSXhfG5WXJ4iAZEUcTwmctQXFkf8rthvTrh1mFZGHtOJvEN+lpCtbsRQ55bGtKA1SYAowZ0xS3DeuDSM7pSIfIk9p+sxqWvrpB/XvPkJaZ7sZq7flt/i8TBiL6peGX8ICzfXYLuHRNwYd8uOK93J6omCi3XDsrEqr0nsWpvKbI6JmBYr064oF8XjOjTmVq77zw/GxsPl2PnsUpkpybid7074cJ+XTA0u1PMdk6R5uHL+mPfyWocO12H/mlJGN67My4e0AVnd0uhYhesx1NjBuKRzzejur4RZ2Um4/y+qbi4fxdLNCNsDYLgr7R85pvtEAQBOd2ScWG/Lri4fxfL5uQ1RXuXA3+9ZiBe/2kv2rvsOKd7B1zUvwsu6p+Krkl0bV4k+nRpj6mj+uLjtYeQFO9AZb0HmYiNN557fDRY0ePD4XA4HA7rNHf9pnNrzOFwOBwOh6MDFz4cDofD4XCYgQsfDofD4XA4zMCFD4fD4XA4HGawjPDZs2cPrrvuOqSmpiI5ORnnn38+li9frvrM4cOHcc011yAxMRGpqal48MEH0dAQ2s2Yw+FwOBwOm1hG+IwZMwaNjY1YtmwZCgoKcO6552Ls2LEoLi4GAHi9XowZMwY1NTVYvXo1FixYgC+//BKPPvpojK+cw+FwOBwOKViinL20tBRdunTBypUrceGFFwIAqqqqkJycjJ9++gmXXnopvv/+e4wdOxZFRUXIzMwEACxYsAD5+fkoKSkxLG1zu91wu4NtwysrK5GVlcXL2TkcDofDsRBUlbN37twZZ555Jj788EPU1NSgsbER7777LtLS0pCbmwsA+OWXX5CTkyOLHgC44oor4Ha7UVBQYPi3Z86ciZSUFPkrKysr4vZwOBwOh8OJDZYQPoIgYOnSpdi0aROSkpIQHx+Pv//97/jhhx/QoUMHAEBxcTHS0tJU/13Hjh0RFxcnh8P0mDZtGioqKuSvoqKiSJrC4XA4HA4nhsRU+EyfPh2CIIT92rBhA0RRxH333YeuXbti1apVWLduHa677jqMHTsWx48fl/+eXgt7URTDtrZ3uVxITk5WfXE4HA6Hw6GTmJ7VNXXqVNxyyy1hP5OdnY1ly5Zh0aJFKC8vl4XJ22+/jaVLl2LevHl48sknkZ6ejrVr1Qd1lpeXw+PxhHiCOBwOh8PhsElMhU9qaipSU1Ob/FxtbS0AwGZTO6hsNht8Pv/ptsOHD8eMGTNw/PhxZGRkAACWLFkCl8sl5wFxOBwOh8NhG0vk+AwfPhwdO3bEpEmTsGXLFuzZswd//vOfcfDgQYwZMwYAMHr0aAwcOBATJ07Epk2b8N///hePPfYYpkyZwsNXHA6Hw+FwAFhE+KSmpuKHH35AdXU1LrnkEuTl5WH16tX45ptvMGjQIACA3W7H4sWLER8fj/PPPx833XQTrr/+erzyyisxvnoOh8PhcDikYIk+PtGkoqICHTp0QFFREfcUcTgcDodjEaQ+fKdPn0ZKSorh52Ka40MiVVVVAMD7+XA4HA6HY0GqqqrCCh/u8dHg8/lw7NgxJCUlhS2DbymSEqXZk0S7jdw+60O7jbTbB9BvI7ev9YiiiKqqKmRmZoYUQynhHh8NNpsN3bt3j9jfZ6FXEO02cvusD+020m4fQL+N3L7WEc7TI2GJ5GYOh8PhcDgcM+DCh8PhcDgcDjNw4RMlXC4XnnnmGbhcrlhfSsSg3UZun/Wh3Uba7QPot5HbF3l4cjOHw+FwOBxm4B4fDofD4XA4zMCFD4fD4XA4HGbgwofD4XA4HA4zcOHD4XA4HA6HGbjwiRJvv/02evXqhfj4eOTm5mLVqlWxvqRWMXPmTAwdOhRJSUno2rUrrr/+euzevVv1mfz8fAiCoPr63e9+F6MrbhnTp08Pufb09HT596IoYvr06cjMzERCQgJGjhyJHTt2xPCKW052dnaIjYIg4P777wdgvfFbuXIlrrnmGmRmZkIQBHz99deq3zdnzNxuNx544AGkpqYiMTER1157LY4cORJFK4wJZ5/H48ETTzyBs88+G4mJicjMzMQdd9yBY8eOqf7GyJEjQ8b0lltuibIlxjQ1hs25J606hgB0n0dBEPDyyy/LnyF5DJuzLpD0HHLhEwU+++wzPPzww3jqqaewadMmXHjhhbjqqqtw+PDhWF9ai1mxYgXuv/9+/Prrr1i6dCkaGxsxevRo1NTUqD535ZVX4vjx4/LXd999F6MrbjlnnXWW6tq3bdsm/+6ll17Ca6+9hrfeegvr169Heno6Lr/8cvmMNyuwfv16lX1Lly4FAIwfP17+jJXGr6amBoMGDcJbb72l+/vmjNnDDz+Mr776CgsWLMDq1atRXV2NsWPHwuv1RssMQ8LZV1tbi40bN+Lpp5/Gxo0bsXDhQuzZswfXXnttyGenTJmiGtN33303GpffLJoaQ6Dpe9KqYwhAZdfx48cxe/ZsCIKAG264QfU5UsewOesCUc+hyIk4w4YNE++9917Ve2eccYb45JNPxuiKzKOkpEQEIK5YsUJ+b9KkSeJ1110Xu4tqA88884w4aNAg3d/5fD4xPT1d/Nvf/ia/V19fL6akpIjvvPNOlK7QfB566CGxT58+os/nE0XR2uMHQPzqq6/kn5szZqdPnxadTqe4YMEC+TNHjx4VbTab+MMPP0Tt2puD1j491q1bJwIQDx06JL938cUXiw899FBkL84k9Gxs6p6kbQyvu+468ZJLLlG9Z6Ux1K4LpD2H3OMTYRoaGlBQUIDRo0er3h89ejTWrFkTo6syj4qKCgBAp06dVO///PPP6Nq1K/r3748pU6agpKQkFpfXKvbu3YvMzEz06tULt9xyCw4cOAAAOHjwIIqLi1Vj6XK5cPHFF1t2LBsaGvDxxx9j8uTJqkN5rTx+SpozZgUFBfB4PKrPZGZmIicnx5LjWlFRAUEQ0KFDB9X7n3zyCVJTU3HWWWfhscces5SXEgh/T9I0hidOnMDixYtx1113hfzOKmOoXRdIew75IaURprS0FF6vF2lpaar309LSUFxcHKOrMgdRFPHII4/gggsuQE5Ojvz+VVddhfHjx6Nnz544ePAgnn76aVxyySUoKCggvhvpeeedhw8//BD9+/fHiRMn8MILL2DEiBHYsWOHPF56Y3no0KFYXG6b+frrr3H69Gnk5+fL71l5/LQ0Z8yKi4sRFxeHjh07hnzGas9ofX09nnzySdx2222qAyAnTJiAXr16IT09Hdu3b8e0adOwZcsWOcxJOk3dkzSN4bx585CUlIRx48ap3rfKGOqtC6Q9h1z4RAnlbhrw3xza96zG1KlTsXXrVqxevVr1/s033yx/n5OTg7y8PPTs2ROLFy8OeZhJ46qrrpK/P/vsszF8+HD06dMH8+bNk5MpaRrLDz74AFdddRUyMzPl96w8fka0ZsysNq4ejwe33HILfD4f3n77bdXvpkyZIn+fk5ODfv36IS8vDxs3bsSQIUOifaktprX3pNXGEABmz56NCRMmID4+XvW+VcbQaF0AyHkOeagrwqSmpsJut4co1pKSkhD1ayUeeOABfPvtt1i+fDm6d+8e9rMZGRno2bMn9u7dG6WrM4/ExEScffbZ2Lt3r1zdRctYHjp0CD/99BPuvvvusJ+z8vg1Z8zS09PR0NCA8vJyw8+QjsfjwU033YSDBw9i6dKlKm+PHkOGDIHT6bTkmAKh9yQNYwgAq1atwu7du5t8JgEyx9BoXSDtOeTCJ8LExcUhNzc3xB25dOlSjBgxIkZX1XpEUcTUqVOxcOFCLFu2DL169Wryvzl16hSKioqQkZERhSs0F7fbjV27diEjI0N2MyvHsqGhAStWrLDkWM6ZMwddu3bFmDFjwn7OyuPXnDHLzc2F0+lUfeb48ePYvn27JcZVEj179+7FTz/9hM6dOzf53+zYsQMej8eSYwqE3pNWH0OJDz74ALm5uRg0aFCTnyVpDJtaF4h7Dk1NlebosmDBAtHpdIoffPCBuHPnTvHhhx8WExMTxcLCwlhfWov54x//KKakpIg///yzePz4cfmrtrZWFEVRrKqqEh999FFxzZo14sGDB8Xly5eLw4cPF7t16yZWVlbG+Oqb5tFHHxV//vln8cCBA+Kvv/4qjh07VkxKSpLH6m9/+5uYkpIiLly4UNy2bZt46623ihkZGZawTYnX6xV79OghPvHEE6r3rTh+VVVV4qZNm8RNmzaJAMTXXntN3LRpk1zV1Jwxu/fee8Xu3buLP/30k7hx40bxkksuEQcNGiQ2NjbGyiyZcPZ5PB7x2muvFbt37y5u3rxZ9Uy63W5RFEVx37594rPPPiuuX79ePHjwoLh48WLxjDPOEAcPHkyEfaIY3sbm3pNWHUOJiooKsV27duKsWbNC/nvSx7CpdUEUyXoOufCJEv/85z/Fnj17inFxceKQIUNU5d9WAoDu15w5c0RRFMXa2lpx9OjRYpcuXUSn0yn26NFDnDRpknj48OHYXngzufnmm8WMjAzR6XSKmZmZ4rhx48QdO3bIv/f5fOIzzzwjpqeniy6XS7zooovEbdu2xfCKW8ePP/4oAhB3796tet+K47d8+XLde3LSpEmiKDZvzOrq6sSpU6eKnTp1EhMSEsSxY8cSY3M4+w4ePGj4TC5fvlwURVE8fPiweNFFF4mdOnUS4+LixD59+ogPPvigeOrUqdgapiCcjc29J606hhLvvvuumJCQIJ4+fTrkvyd9DJtaF0SRrOdQCFw0h8PhcDgcDvXwHB8Oh8PhcDjMwIUPh8PhcDgcZuDCh8PhcDgcDjNw4cPhcDgcDocZuPDhcDgcDofDDFz4cDgcDofDYQYufDgcDofD4TADFz4cDofD4XCYgQsfDodDDbt370Z6ejqqqqoi9m/ceOONeO211yL29zkcTmThnZs5HA7RjBw5Eueeey5ef/31Jj974403YtCgQXj66acjdj1bt27FqFGjcPDgwSZPQedwOOTBPT4cDocKjhw5gm+//RZ33nlnRP+dc845B9nZ2fjkk08i+u9wOJzIwIUPh8Mhlvz8fKxYsQL/+Mc/IAgCBEFAYWGh7mc///xzDBo0CN27d5ffmzt3Ljp06IBFixZhwIABaNeuHW688UbU1NRg3rx5yM7ORseOHfHAAw/A6/XK/93bb7+Nfv36IT4+HmlpabjxxhtV/9a1116L+fPnR8RmDocTWRyxvgAOh8Mx4h//+Af27NmDnJwcPPfccwCALl266H525cqVyMvLC3m/trYWb7zxBhYsWICqqiqMGzcO48aNQ4cOHfDdd9/hwIEDuOGGG3DBBRfg5ptvxoYNG/Dggw/io48+wogRI1BWVoZVq1ap/uawYcMwc+ZMuN1uuFwu8w3ncDgRgwsfDodDLCkpKYiLi0O7du2Qnp4e9rOFhYXIzc0Ned/j8WDWrFno06cPAH8e0EcffYQTJ06gffv2GDhwIEaNGoXly5fj5ptvxuHDh5GYmIixY8ciKSkJPXv2xODBg1V/s1u3bnC73SguLkbPnj3NM5jD4UQcHuricDhUUFdXh/j4+JD327VrJ4seAEhLS0N2djbat2+veq+kpAQAcPnll6Nnz57o3bs3Jk6ciE8++QS1tbWqv5mQkAAAIe9zOBzy4cKHw+FQQWpqKsrLy0Pedzqdqp8FQdB9z+fzAQCSkpKwceNGzJ8/HxkZGfjrX/+KQYMG4fTp0/Lny8rKABiH3TgcDrlw4cPhcIgmLi5OlXhsxODBg7Fz505T/k2Hw4HLLrsML730ErZu3YrCwkIsW7ZM/v327dvRvXt3pKammvLvcTic6MFzfDgcDtFkZ2dj7dq1KCwsRPv27dGpUyfYbKF7tiuuuAJ33303vF4v7HZ7q/+9RYsW4cCBA7jooovQsWNHfPfdd/D5fBgwYID8mVWrVmH06NGt/jc4HE7s4B4fDodDNI899hjsdjsGDhyILl264PDhw7qfu/rqq+F0OvHTTz+16d/r0KEDFi5ciEsuuQRnnnkm3nnnHcyfPx9nnXUWAKC+vh5fffUVpkyZ0qZ/h8PhxAbeuZnD4VDD22+/jW+++QY//vhjxP6Nf/7zn/jmm2+wZMmSiP0bHA4ncvBQF4fDoYZ77rkH5eXlqKqqQlJSUkT+DafTiTfffDMif5vD4UQe7vHhcDgcDofDDDzHh8PhcDgcDjNw4cPhcDgcDocZuPDhcDgcDofDDFz4cDgcDofDYQYufDgcDofD4TADFz4cDofD4XCYgQsfDofD4XA4zMCFD4fD4XA4HGbgwofD4XA4HA4z/H/5iXKt+vNLdwAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": "
", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 30 + }, + { + "cell_type": "markdown", + "source": [ + "## Building a complex thalamus neuron model" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "Li, et. al [1] proposed a point model of thalamic cells, all single cell models in the thalamic network contained one single compartment and multiple ionic currents described by the Hodgkin-Huxley formulism. The current balance equation was given by: \n", + "\n", + "$$ \n", + "C_m \\frac{d V}{d t}=-g_L\\left(V-E_L\\right)-g_{K L}\\left(V-E_{K L}\\right)-\\sum I^{i n t}-10^{-3} \\sum \\frac{I^{s n}}{A}+10^{-3} \\frac{I_{a p p}}{A} \n", + "$$ \n", + "\n", + "\n", + "where $Cm = 1μF/cm^2$ is the membrane capacitance for all four types of neurons, $g_L$ is the leakage conductance (nominal value: $gL = 0.01 mS/cm^2$ for all four types of cells) and $g_{KL}$ is the potassium leak conductance modulated by both ACh and NE. $E_L$ is the leakage reversal potential ($E_L$ = −70 mV for both HTC cells), and $E_{KL}$ is the reversal potential for the potassium leak current ($E_{KL}$ = −90 mV for all neurons). $I_{int}$ and $I_{syn}$ are the intrinsic ionic currents (in $μA/cm^2$) and synaptic currents (in $nA$) respectively and $I_{app}$ is the externally applied current injection (in $nA$). The following total membrane area (A) was used to normalize the synaptic and externally applied currents in Eq: HTC cells: 2.9×10−4 $cm^2$.\n", + "\n", + "\n", + "HTC cells contained the following six active ionic currents: \n", + "\n", + "- a spike generating fast sodium current (INa), ``bp.dyn.INa_Ba2002`` \n", + "- a delayed rectifier potassium current (IDR), ``bp.dyn.IKDR_Ba2002`` \n", + "- a hyperpolarization-activated cation current (IH), ``bp.dyn.Ih_HM1992`` \n", + "- a high-threshold L-type Ca2+ current (ICa/L), ``bp.dyn.ICaL_IS2008`` \n", + "- a Ca2+- dependent potassium current (IAHP), ``bp.dyn.IAHP_De1994`` \n", + "- a Ca2+- activated nonselective cation current (ICAN). ``bp.dyn.ICaN_IS2008`` \n", + "\n", + "In addition, both TC cells included \n", + "- a regular low-threshold T-type Ca2+ current (ICa/T), ``bp.dyn.ICaT_HM1992`` \n", + "- and a high-threshold T-type Ca2+ current (ICa/HT); ``bp.dyn.ICaHT_HM1992`` \n", + "\n", + "To obtain the high-threshold T-type current ICa/HT, both the activation and inactivation of the ICa/T current was shifted by 28 mV, similar to a previous TC modeling study. \n", + "\n", + "\n", + "[1] Li G, Henriquez CS, Fröhlich F (2017) Unified thalamic model generates multiple distinct oscillations with state-dependent entrainment by stimulation. PLoS Comput Biol 13(10): e1005797. https://doi.org/10.1371/journal.pcbi.1005797" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "markdown", + "source": [ + "In BrainPy, this model can be modeled as:" + ], + "metadata": { + "collapsed": false + } + }, + { + "cell_type": "code", + "execution_count": 31, + "outputs": [], + "source": [ + "class HTC(bp.dyn.CondNeuGroupLTC):\n", + " def __init__(self, size, gKL=0.01, V_initializer=bp.init.OneInit(-65.)):\n", + " super().__init__(size, A=2.9e-4, V_initializer=V_initializer, V_th=20.)\n", + " self.IL = bp.dyn.IL(size, g_max=0.01, E=-70.)\n", + " self.INa = bp.dyn.INa_Ba2002(size, V_sh=-30)\n", + " self.Ih = bp.dyn.Ih_HM1992(size, g_max=0.01, E=-43)\n", + "\n", + " self.Ca = bp.dyn.CalciumDetailed(size, C_rest=5e-5, tau=10., d=0.5)\n", + " self.Ca.add_elem(bp.dyn.ICaL_IS2008(size, g_max=0.5))\n", + " self.Ca.add_elem(bp.dyn.ICaN_IS2008(size, g_max=0.5))\n", + " self.Ca.add_elem(bp.dyn.ICaT_HM1992(size, g_max=2.1))\n", + " self.Ca.add_elem(bp.dyn.ICaHT_HM1992(size, g_max=3.0))\n", + "\n", + " self.K = bp.dyn.PotassiumFixed(size, E=-90.)\n", + " self.K.add_elem(bp.dyn.IKDR_Ba2002v2(size, V_sh=-30., phi=0.25))\n", + " self.K.add_elem(bp.dyn.IK_Leak(size, g_max=gKL))\n", + "\n", + " self.KCa = bp.dyn.MixIons(self.K, self.Ca)\n", + " self.KCa.add_elem(bp.dyn.IAHP_De1994v2(size))" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:25.649093300Z", + "start_time": "2023-12-12T07:45:25.645446500Z" + } + } + }, + { + "cell_type": "code", + "execution_count": 32, + "outputs": [ + { + "data": { + "text/plain": " 0%| | 0/20000 [00:00", + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "htc = HTC(1)\n", + "runner = bp.DSRunner(htc, monitors={'v': htc.V})\n", + "I = -30 / 1e3 / 2.9e-4 * 1e-3 # input current = -30pA\n", + "inputs = np.ones(20000) * I\n", + "runner.run(inputs=inputs)\n", + "bp.visualize.line_plot(runner.mon.ts, runner.mon['v'], legend='v', show=True)" + ], + "metadata": { + "collapsed": false, + "ExecuteTime": { + "end_time": "2023-12-12T07:45:26.777538400Z", + "start_time": "2023-12-12T07:45:25.648511800Z" + } + } + } + ], + "metadata": { + "kernelspec": { + "language": "python", + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "name": "python", + "mimetype": "text/x-python", + "nbconvert_exporter": "python", + "file_extension": ".py", + "version": "3.5.2", + "pygments_lexer": "ipython3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/docs/tutorial_building/index.rst b/docs/tutorial_building/index.rst index f3802effa..4426021ed 100644 --- a/docs/tutorial_building/index.rst +++ b/docs/tutorial_building/index.rst @@ -10,7 +10,7 @@ Using existing modules :maxdepth: 1 overview_of_dynamic_model - build_conductance_neurons + build_conductance_neurons_v2.ipynb phenon_synapse_models.ipynb kinetic_synapse_models.ipynb build_network_models