From 99223f85baaf6dbc4fb99762e848522d7f1612f3 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Wed, 27 May 2026 15:29:09 +0200
Subject: [PATCH 01/17] fix Piecewise printing

---
 src/neat/channels/ionchannels.py | 167 ++++++++++++++++++++++++++++---
 1 file changed, 154 insertions(+), 13 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index d8a6daf..d790b4e 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -169,6 +169,134 @@ def __call__(self, *args):
         return SPDict({str(k): f(*args) for k, f in self.items()})
 
 
+def _safe_simplify(expr):
+    if expr.has(sp.Piecewise):
+        return expr
+    else:
+        return sp.simplify(expr)
+
+
+def _nmodl_ccode(expr):
+    return " ".join(sp.printing.ccode(expr).replace(";", "").split())
+
+
+def _rebuild_sympy_expr(expr, args):
+    try:
+        return expr.func(*args, evaluate=False)
+    except TypeError:
+        return expr.func(*args)
+
+
+def _nmodl_boolean_assignment_lines(lhs, expr, temp_counter=0):
+    expr = sp.sympify(expr)
+
+    if expr == True or expr == sp.true:
+        return [f"{lhs} = 1"], temp_counter, []
+    if expr == False or expr == sp.false:
+        return [f"{lhs} = 0"], temp_counter, []
+
+    lines, expr, temp_counter, locals_ = _hoist_piecewise_for_nmodl(expr, temp_counter)
+    if getattr(expr, "is_Boolean", False):
+        lines += [
+            f"if ({_nmodl_ccode(expr)}) {{",
+            f"    {lhs} = 1",
+            "}",
+            "else {",
+            f"    {lhs} = 0",
+            "}",
+        ]
+    else:
+        lines.append(f"{lhs} = {_nmodl_ccode(expr)}")
+    return lines, temp_counter, locals_
+
+
+def _hoist_piecewise_for_nmodl(expr, temp_counter=0):
+    expr = sp.sympify(expr)
+
+    if expr.func == sp.ITE:
+        temp = sp.symbols(f"pw{temp_counter}")
+        temp_counter += 1
+        test, then_value, else_value = expr.args
+        lines, test_expr, temp_counter, locals_ = _hoist_piecewise_for_nmodl(
+            test, temp_counter
+        )
+        then_lines, temp_counter, then_locals = _nmodl_boolean_assignment_lines(
+            temp, then_value, temp_counter
+        )
+        else_lines, temp_counter, else_locals = _nmodl_boolean_assignment_lines(
+            temp, else_value, temp_counter
+        )
+        locals_ = [str(temp)] + locals_ + then_locals + else_locals
+        lines += [f"if ({_nmodl_ccode(test_expr)}) {{"]
+        lines.extend("    " + line for line in then_lines)
+        lines += ["}", "else {"]
+        lines.extend("    " + line for line in else_lines)
+        lines.append("}")
+        return lines, temp, temp_counter, locals_
+
+    if isinstance(expr, sp.Piecewise):
+        temp = sp.symbols(f"pw{temp_counter}")
+        temp_counter += 1
+        lines = []
+        locals_ = [str(temp)]
+        branch_specs = []
+
+        for value, condition in expr.args:
+            condition_lines, condition_expr, temp_counter, condition_locals = (
+                _hoist_piecewise_for_nmodl(condition, temp_counter)
+            )
+            value_lines, value_expr, temp_counter, value_locals = (
+                _hoist_piecewise_for_nmodl(value, temp_counter)
+            )
+            lines.extend(condition_lines)
+            locals_.extend(condition_locals)
+            branch_specs.append((condition_expr, value_lines, value_expr, value_locals))
+
+        for branch_index, (condition, value_lines, value_expr, value_locals) in enumerate(branch_specs):
+            locals_.extend(value_locals)
+            if condition == True or condition == sp.true:
+                lines.append("else {")
+            else:
+                condition_code = _nmodl_ccode(condition)
+                if branch_index == 0:
+                    lines.append(f"if ({condition_code}) {{")
+                else:
+                    lines.append(f"else if ({condition_code}) {{")
+            lines.extend("    " + line for line in value_lines)
+            lines.append(f"    {temp} = {_nmodl_ccode(value_expr)}")
+            lines.append("}")
+
+        if lines and lines[0] == "else {":
+            lines = [f"{temp} = {_nmodl_ccode(branch_specs[0][2])}"]
+
+        return lines, temp, temp_counter, locals_
+
+    if not expr.args:
+        return [], expr, temp_counter, []
+
+    lines = []
+    locals_ = []
+    new_args = []
+    for arg in expr.args:
+        arg_lines, arg_expr, temp_counter, arg_locals = _hoist_piecewise_for_nmodl(
+            arg, temp_counter
+        )
+        lines.extend(arg_lines)
+        locals_.extend(arg_locals)
+        new_args.append(arg_expr)
+
+    if any(new_arg != old_arg for new_arg, old_arg in zip(new_args, expr.args)):
+        expr = _rebuild_sympy_expr(expr, new_args)
+
+    return lines, expr, temp_counter, locals_
+
+
+def _nmodl_assignment_lines(lhs, expr, temp_counter=0):
+    lines, expr, temp_counter, locals_ = _hoist_piecewise_for_nmodl(expr, temp_counter)
+    lines.append(f"{lhs} = {_nmodl_ccode(expr)}")
+    return lines, temp_counter, locals_
+
+
 class IonChannel(object):
     """
     Base ion channel class that implements linearization and code generation for
@@ -313,8 +441,8 @@ def __init__(self, **kwargs):
             if key in (self.varinf.keys() | self.tauinf.keys()):
                 self.varinf[svar] = sp.sympify(self.varinf[key], evaluate=False)
                 self.tauinf[svar] = sp.sympify(self.tauinf[key], evaluate=False)
-                self.varinf[svar] = sp.simplify(self.varinf[svar])
-                self.tauinf[svar] = sp.simplify(self.tauinf[svar] / self.q10)
+                self.varinf[svar] = _safe_simplify(self.varinf[svar])
+                self.tauinf[svar] = _safe_simplify(self.tauinf[svar] / self.q10)
                 del self.varinf[key]
                 del self.tauinf[key]
 
@@ -877,19 +1005,32 @@ def write_mod_file(self, path, g=0.0, e=None):
         # substitution for common neuron names
         repl_pairs = [(str(c), str(c) + "i") for c in self.conc]
 
-        file.write("PROCEDURE rates(v%s) {\n" % concstring)
-        file.write("    %s = celsius\n" % str(self.sp_t))
+        assignment_lines = []
+        local_vars = []
+        temp_counter = 0
         for var, svar in zip(sv, self.ordered_statevars):
-            vi = sp.printing.ccode(self.varinf[svar], assign_to=f"{var}_inf")
-            ti = sp.printing.ccode(self.tauinf[svar], assign_to=f"tau_{var}")
+            vi_lines, temp_counter, vi_locals = _nmodl_assignment_lines(
+                f"{var}_inf", self.varinf[svar], temp_counter
+            )
+            ti_lines, temp_counter, ti_locals = _nmodl_assignment_lines(
+                f"tau_{var}", self.tauinf[svar], temp_counter
+            )
+            local_vars.extend(vi_locals)
+            local_vars.extend(ti_locals)
+            assignment_lines.extend(vi_lines)
+            assignment_lines.extend(ti_lines)
+
+        for ii, line in enumerate(assignment_lines):
             for repl_pair in repl_pairs:
-                vi = vi.replace(*repl_pair)
-                ti = ti.replace(*repl_pair)
-            # no ";" in mod-file, add indent
-            vi = vi.replace(";", "").replace("\n", "\n    ")
-            ti = ti.replace(";", "").replace("\n", "\n    ")
-            file.write(f"    {vi}\n")
-            file.write(f"    {ti}\n")
+                line = line.replace(*repl_pair)
+            assignment_lines[ii] = line
+
+        file.write("PROCEDURE rates(v%s) {\n" % concstring)
+        if local_vars:
+            file.write("    LOCAL %s\n" % ", ".join(dict.fromkeys(local_vars)))
+        file.write("    %s = celsius\n" % str(self.sp_t))
+        for line in assignment_lines:
+            file.write(f"    {line}\n")
         file.write("}\n\n")
 
         file.close()

From 7ee70f7118d3f86bd4e908fbc354bb93b04a180f Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Thu, 28 May 2026 10:21:25 +0200
Subject: [PATCH 02/17] fix nested piecewise printers for NEST

---
 src/neat/channels/ionchannels.py | 74 ++++++++++++++++++++++++++++----
 1 file changed, 65 insertions(+), 9 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index d790b4e..8eed83b 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -297,6 +297,48 @@ def _nmodl_assignment_lines(lhs, expr, temp_counter=0):
     return lines, temp_counter, locals_
 
 
+def _nestml_ccode(expr):
+    return _nmodl_ccode(expr).replace("fabs(", "abs(").replace("fmax(", "max(").replace("fmin(", "min(")
+
+
+def _piecewise_to_nestml_expr(expr):
+    expr = sp.sympify(expr)
+
+    if isinstance(expr, sp.Piecewise):
+        if len(expr.args) == 2 and (expr.args[1][1] == True or expr.args[1][1] == sp.true):
+            value_if, condition = expr.args[0]
+            value_else, _ = expr.args[1]
+            value_if = _piecewise_to_nestml_expr(value_if)
+            value_else = _piecewise_to_nestml_expr(value_else)
+
+            if getattr(condition, "rel_op", None) == "<":
+                if value_if == condition.rhs and value_else == condition.lhs:
+                    return sp.Max(value_else, value_if, evaluate=False)
+            if getattr(condition, "rel_op", None) == ">":
+                # vtrap-style singularity guards are not representable without
+                # function-local control flow in the current NESTML generator.
+                return value_if
+
+        return _piecewise_to_nestml_expr(expr.args[0][0])
+
+    if not expr.args:
+        return expr
+
+    new_args = [_piecewise_to_nestml_expr(arg) for arg in expr.args]
+    if any(new_arg != old_arg for new_arg, old_arg in zip(new_args, expr.args)):
+        return _rebuild_sympy_expr(expr, new_args)
+    return expr
+
+
+def _nestml_function_assignment(lhs, expr):
+    expr = _piecewise_to_nestml_expr(expr)
+    return f"        {lhs} = {_nestml_ccode(expr)}\n"
+
+
+def _needs_nestml_piecewise_lowering(expr):
+    return sp.sympify(expr).has(sp.Piecewise)
+
+
 class IonChannel(object):
     """
     Base ion channel class that implements linearization and code generation for
@@ -1124,7 +1166,7 @@ def write_nestml_blocks(
             for svar, sv_ in zip(self.ordered_statevars, sv_suff):
                 p_open_ = p_open_.subs(svar, sp.symbols(sv_))
                 p_open_ = p_open_.subs(
-                    self.sp_v, sp.UnevaluatedExpr(sp.symbols("v_comp"))
+                    self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
             eq_str = (
@@ -1158,17 +1200,24 @@ def _customsimplify(expr):
                 #     varinf_func = varinf_func.subs(ckey, cval)
                 # print activation function to nestml file
                 varinf_func = varinf_func.subs(
-                    svar, sp.UnevaluatedExpr(sp.symbols(sv_suff_))
+                    svar, sp.symbols(sv_suff_, real=True)
                 )
                 varinf_func = varinf_func.subs(
-                    self.sp_v, sp.UnevaluatedExpr(sp.symbols("v_comp"))
+                    self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
-                code_str = sp.pycode(varinf_func, fully_qualified_modules=False)
+                if _needs_nestml_piecewise_lowering(varinf_func):
+                    value_str = _nestml_function_assignment('val', varinf_func)
+                else:
+                    code_str = sp.pycode(varinf_func, fully_qualified_modules=False)
+                    value_str = self._create_nestml_funcstr(
+                        code_str, n_spaces=4, indent=8
+                    )
+
                 func_str += (
                     f"    function {sv_}_inf_{cname} ({func_call_args}) real:\n"
                     f"        val real\n"
-                    f"{self._create_nestml_funcstr(code_str, n_spaces=4, indent=8)}"
+                    f"{value_str}"
                     f"        return val\n\n"
                 )
 
@@ -1178,17 +1227,24 @@ def _customsimplify(expr):
                     tauinf_func = tauinf_func.subs(ckey, cval)
 
                 tauinf_func = tauinf_func.subs(
-                    svar, sp.UnevaluatedExpr(sp.symbols(sv_suff_))
+                    svar, sp.symbols(sv_suff_, real=True)
                 )
                 tauinf_func = tauinf_func.subs(
-                    self.sp_v, sp.UnevaluatedExpr(sp.symbols("v_comp"))
+                    self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
-                code_str = sp.pycode(tauinf_func, fully_qualified_modules=False)
+                if _needs_nestml_piecewise_lowering(tauinf_func):
+                    value_str = _nestml_function_assignment('val', tauinf_func)
+                else:
+                    code_str = sp.pycode(tauinf_func, fully_qualified_modules=False)
+                    value_str = self._create_nestml_funcstr(
+                        code_str, n_spaces=4, indent=8
+                    )
+
                 func_str += (
                     f"\n    function tau_{sv_}_{cname} ({func_call_args}) real:\n"
                     f"        val real\n"
-                    f"{self._create_nestml_funcstr(code_str, n_spaces=4, indent=8)}"
+                    f"{value_str}"
                     f"        return val\n\n"
                 )
 

From b9a87f2b6ebe91a70597e3654c9495a89c4229fc Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Thu, 28 May 2026 10:23:04 +0200
Subject: [PATCH 03/17] add channel tests for direct p_open dependence on
 voltage and state variables

---
 tests/channelcollection_for_tests.py | 32 +++++++++++
 tests/test_ionchannels.py            | 85 ++++++++++++++++++++++++++++
 2 files changed, 117 insertions(+)

diff --git a/tests/channelcollection_for_tests.py b/tests/channelcollection_for_tests.py
index 4a34683..66d38b9 100644
--- a/tests/channelcollection_for_tests.py
+++ b/tests/channelcollection_for_tests.py
@@ -280,3 +280,35 @@ def define(self):
             )
         }
         self.tauinf = {"z": "1."}  # ms
+
+
+class ConcDepChan(IonChannel):
+    """
+    Toy channel with a concentration appearing directly in p_open (not only via state-variable
+    kinetics). p_open = m / (1 + ca), where ca is intracellular calcium.
+
+    Used to test first-class support for direct concentration dependencies in p_open.
+    """
+
+    def define(self):
+        self.ion = "ca"
+        self.conc = ["ca"]
+        self.p_open = "m / (1 + ca)"
+        self.varinf = {"m": "1 / (1 + exp(-(v + 30) / 10))"}
+        self.tauinf = {"m": "1."}
+        self.e = 50.0
+
+
+class VoltDepChan(IonChannel):
+    """
+    Toy channel with voltage appearing directly in p_open (not only through state-variable
+    kinetics). p_open = m / (1 + exp(-v / 10)).
+
+    Used to test first-class support for direct voltage dependencies in p_open.
+    """
+
+    def define(self):
+        self.p_open = "m / (1 + exp(-v / 10))"
+        self.varinf = {"m": "1 / (1 + exp(-(v + 30) / 10))"}
+        self.tauinf = {"m": "1."}
+        self.e = -23.0
diff --git a/tests/test_ionchannels.py b/tests/test_ionchannels.py
index 19a08d2..97a1f90 100755
--- a/tests/test_ionchannels.py
+++ b/tests/test_ionchannels.py
@@ -220,6 +220,91 @@ def test_broadcasting():
     assert np.allclose(tauinf["b"], np.array([0.1, 0.1, 50.0]))
 
 
+class TestDirectDependencies:
+    """
+    Tests for first-class direct p_open(v, c, x) dependencies on voltage and concentration.
+
+    xfail-marked tests describe the target behaviour and are expected to fail until
+    IonChannel is updated to support non-state-variable symbols in p_open.
+    """
+
+    # --- concentration in p_open ---
+
+    @pytest.mark.xfail(reason="ca in p_open is mis-classified as a state variable")
+    def test_conc_dep_statevars(self):
+        """ca declared in self.conc must not appear in statevars even when in p_open."""
+        ch = channelcollection.ConcDepChan()
+        assert sp.symbols("m") in ch.statevars
+        assert sp.symbols("ca") not in ch.statevars
+        assert len(ch.statevars) == 1
+
+    @pytest.mark.xfail(reason="direct dp/dc term not yet included in compute_linear_conc")
+    def test_conc_dep_linearization_dc(self):
+        """At DC, compute_lin_conc must match d/d_ca[(e-v)*p_ss] via finite difference."""
+        ch = channelcollection.ConcDepChan()
+        v0, e = -40.0, 50.0
+        ca0 = ch.conc[sp.symbols("ca")]
+
+        def p_ss(ca):
+            minf = 1.0 / (1.0 + np.exp(-(v0 + 30.0) / 10.0))
+            return minf / (1.0 + ca)
+
+        dca = ca0 * 1e-5
+        fd = (e - v0) * (p_ss(ca0 + dca) - p_ss(ca0 - dca)) / (2.0 * dca)
+        neat_val = ch.compute_lin_conc(v0, 0.0, "ca", e=e)
+        assert np.allclose(neat_val, fd, rtol=1e-4)
+
+    @pytest.mark.xfail(reason="USEION deduplication in write_mod_file not yet implemented")
+    def test_conc_dep_mod_file(self, tmp_path):
+        """MOD file must emit exactly one 'USEION ca READ cai WRITE ica' line."""
+        ch = channelcollection.ConcDepChan()
+        ch.write_mod_file(str(tmp_path))
+        text = (tmp_path / "IConcDepChan.mod").read_text()
+        useion_lines = [l.strip() for l in text.splitlines() if "USEION ca" in l]
+        assert len(useion_lines) == 1
+        assert "READ cai" in useion_lines[0]
+        assert "WRITE ica" in useion_lines[0]
+
+    # --- voltage in p_open ---
+
+    def test_volt_dep_statevars(self):
+        """v in p_open must not appear in statevars (existing NEAT behaviour, must not regress)."""
+        ch = channelcollection.VoltDepChan()
+        assert sp.symbols("m") in ch.statevars
+        assert sp.symbols("v") not in ch.statevars
+        assert len(ch.statevars) == 1
+
+    @pytest.mark.xfail(reason="direct dp/dv term not yet included in compute_linear")
+    def test_volt_dep_linearization_dc(self):
+        """At DC, compute_lin_sum must match d/dv[(e-v)*p_ss] via finite difference."""
+        ch = channelcollection.VoltDepChan()
+        v0, e = -40.0, ch.default_params["e"]
+
+        def p_ss(v):
+            minf = 1.0 / (1.0 + np.exp(-(v + 30.0) / 10.0))
+            return minf / (1.0 + np.exp(-v / 10.0))
+
+        dv = 1e-5
+        fd = ((e - (v0 + dv)) * p_ss(v0 + dv) - (e - (v0 - dv)) * p_ss(v0 - dv)) / (2.0 * dv)
+        neat_val = ch.compute_lin_sum(v0, 0.0, e=e)
+        assert np.allclose(neat_val, fd, rtol=1e-4)
+
+    # --- regressions for existing channels ---
+
+    def test_regression_existing_channels(self):
+        """Channels with no direct v/c in p_open must retain their current numerical outputs."""
+        na = channelcollection.Na_Ta()
+        assert np.allclose(na.compute_p_open(-35.0), 0.002009216860105564)
+        assert np.allclose(na.compute_lin_sum(-35.0, 0.0, 50.0), -0.00534261017220376)
+
+    def test_regression_sk_statevars(self):
+        """SK channel: ca appears only in state-variable kinetics, not in p_open itself."""
+        sk = channelcollection.SK()
+        assert sp.symbols("ca") not in sk.statevars
+        assert sp.symbols("z") in sk.statevars
+        assert len(sk.statevars) == 1
+
+
 if __name__ == "__main__":
     tcns = test_channels()
     tcns.test_basic()

From 2d37c08bf2636e77c3ff140cb9e8ac0d575fd7bc Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Thu, 28 May 2026 15:36:20 +0200
Subject: [PATCH 04/17] fix bug where concentration dependence trips
 compartmentfitter expansion points

---
 src/neat/modelreduction/compartmentfitter.py | 26 ++++++++++++++++----
 1 file changed, 21 insertions(+), 5 deletions(-)

diff --git a/src/neat/modelreduction/compartmentfitter.py b/src/neat/modelreduction/compartmentfitter.py
index eeb2461..554ed3f 100755
--- a/src/neat/modelreduction/compartmentfitter.py
+++ b/src/neat/modelreduction/compartmentfitter.py
@@ -38,7 +38,11 @@
 import warnings
 
 
-def _statevar_is_activating(f_statevar):
+def _default_conc_args(channel):
+    return [channel.conc[c] for c in channel.sp_c]
+
+
+def _statevar_is_activating(f_statevar, *args):
     """
     check whether a statevar is activating or inactivating
 
@@ -51,7 +55,7 @@ def _statevar_is_activating(f_statevar):
     # inactivating
     v_test = np.array([-43.22, -32.22])
 
-    sv_test = f_statevar(v_test)
+    sv_test = f_statevar(v_test, *args)
     return sv_test[0] < sv_test[1]
 
 
@@ -94,6 +98,8 @@ def get_expansion_points(e_hs, channel, only_e_h=False):
     sv_hs: dict
         the expansion points at every holding potential
     """
+    conc_args = _default_conc_args(channel)
+
     if len(channel.statevars) == 1 or only_e_h:
         sv_hs = channel.compute_varinf(e_hs)
         sv_hs["v"] = e_hs
@@ -104,10 +110,13 @@ def get_expansion_points(e_hs, channel, only_e_h=False):
         sv_hs = SPDict(v=e_hs_aux_act)
         for svar, f_inf in channel.f_varinf.items():
             # check if variable is activation
-            if _statevar_is_activating(f_inf):  # variable is activation
-                sv_hs[str(svar)] = f_inf(e_hs_aux_act)
+            if _statevar_is_activating(f_inf, *conc_args):  # variable is activation
+                sv_hs[str(svar)] = f_inf(e_hs_aux_act, *conc_args)
             else:  # variable is inactivation
-                sv_hs[str(svar)] = f_inf(e_hs_aux_inact)
+                sv_hs[str(svar)] = f_inf(e_hs_aux_inact, *conc_args)
+
+    for ion, conc in channel.conc.items():
+        sv_hs[str(ion)] = np.full_like(sv_hs["v"], conc, dtype=float)
 
     return sv_hs
 
@@ -457,6 +466,13 @@ def _eval_channel(self, fit_arg, channel_name, pprint=False):
                     if str(svar) != "v"
                 }
             )
+            sv.update(
+                {
+                    str(ion): sv_h[ion][ii]
+                    for ion in channel.conc
+                    if str(ion) in sv_h
+                }
+            )
 
             # compute the fit matrices
             m_f, v_t = ctree.compute_g_single_channel(

From ba129bf161323c114ace29d962365387232785b6 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Thu, 28 May 2026 15:36:41 +0200
Subject: [PATCH 05/17] add ghk ion channel compatibility

---
 src/neat/channels/ionchannels.py     | 166 ++++++++++++++++++++-------
 src/neat/factorydefaults.py          |   4 +
 tests/channelcollection_for_tests.py |  31 +++++
 tests/test_compartmentfitter.py      |  90 +++++++++++++++
 tests/test_ionchannels.py            |  98 +++++++++++++++-
 5 files changed, 344 insertions(+), 45 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index 8eed83b..6f524aa 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -180,6 +180,14 @@ def _nmodl_ccode(expr):
     return " ".join(sp.printing.ccode(expr).replace(";", "").split())
 
 
+def _nmodl_repl(text, repl_pairs):
+    """Apply identifier substitutions using word boundaries to avoid partial matches."""
+    import re
+    for old, new in repl_pairs:
+        text = re.sub(r'\b' + re.escape(old) + r'\b', new, text)
+    return text
+
+
 def _rebuild_sympy_expr(expr, args):
     try:
         return expr.func(*args, evaluate=False)
@@ -468,10 +476,15 @@ def __init__(self, **kwargs):
         # extract the state variables
         self.p_open = sp.sympify(self.p_open)
         self.statevars = self.p_open.free_symbols
-        # if voltage occurs directly in open probability,
-        # remove it from statevars
+        # remove v and any pre-declared concentration symbols from statevars
         if self.sp_v in self.statevars:
             self.statevars.remove(self.sp_v)
+        if hasattr(self, "conc"):
+            if hasattr(self.conc, "keys"):
+                conc_syms = {sp.symbols(str(k)) for k in self.conc.keys()}
+            else:
+                conc_syms = {sp.symbols(str(c)) for c in self.conc}
+            self.statevars -= conc_syms
 
         if not "tauinf" in self.__dict__:
             self.tauinf = {}
@@ -541,6 +554,12 @@ def __init__(self, **kwargs):
         # sympy concentration symbols
         self.sp_c = [ion for ion in self.conc]
 
+        # extracellular concentrations — fixed parameters substituted before lambdifying
+        if not hasattr(self, "conc_ext"):
+            self.conc_ext = {}
+        if not hasattr(self.conc_ext, "values"):
+            self.conc_ext = {str(ion): self.cfg.conc_ext[str(ion)] for ion in self.conc_ext}
+
         # default parameters
         self.default_params = SPDict({})
         self.default_params[str(self.sp_t)] = (
@@ -552,6 +571,12 @@ def __init__(self, **kwargs):
             )
         except KeyError:
             warnings.warn("No default reversal potential defined.")
+        for ion_str, val in self.conc_ext.items():
+            self.default_params[ion_str + "_ext"] = val
+
+        if not hasattr(self, "driving_force"):
+            self.driving_force = self.sp_v - sp.Symbol("e")
+        self.driving_force = sp.sympify(self.driving_force)
 
         # self._lambdify_channel()
         self.set_default_params(**kwargs)
@@ -566,7 +591,8 @@ def __getstate__(self):
         del d["f_varinf"]
         del d["f_tauinf"]
         del d["f_p_open"]
-        del d["dp_dx"], d["df_dv"], d["df_dx"], d["df_dc"]
+        del d["dp_dx"], d["df_dv"], d["df_dx"], d["df_dc"], d["dp_dv"], d["dp_dc"]
+        del d["f_driving_force"], d["dD_dv"], d["dD_dci"]
 
         return d
 
@@ -575,6 +601,9 @@ def __setstate__(self, s):
         since lambdified functions were not pickled we need to restore them
         """
         self.__dict__ = s
+        # backward-compat: states pickled before driving_force was introduced
+        if not hasattr(self, "driving_force"):
+            self.driving_force = self.sp_v - sp.Symbol("e")
         self._lambdify_channel()
 
     def set_default_params(self, **kwargs):
@@ -655,6 +684,26 @@ def _lambdify_channel(self):
                 }
             )
 
+        # direct derivatives of p_open to voltage and concentrations
+        self.dp_dv = _broadcast(sp.lambdify(args, sp.diff(self.p_open, self.sp_v, 1)))
+        self.dp_dc = CallDict(
+            {
+                c: _broadcast(sp.lambdify(args, sp.diff(self.p_open, c, 1)))
+                for c in self.sp_c
+            }
+        )
+
+        # driving force D and its derivatives (temp, e, and <ion>_ext already substituted)
+        df_expr = self._substitute_defaults(self.driving_force)
+        self.f_driving_force = _broadcast(sp.lambdify(args, df_expr))
+        self.dD_dv = _broadcast(sp.lambdify(args, sp.diff(df_expr, self.sp_v, 1)))
+        self.dD_dci = CallDict(
+            {
+                c: _broadcast(sp.lambdify(args, sp.diff(df_expr, c, 1)))
+                for c in self.sp_c
+            }
+        )
+
     def _args_as_list(self, v, w_statevar=True, **kwargs):
         """
         Converts arguments to list for lambdified functions
@@ -841,16 +890,15 @@ def compute_linear(self, v, freqs, **kwargs):
             the dimensions of `v`.
         """
         dp_dx, df_dv, df_dx = self.compute_derivatives(v, **kwargs)
+        args = self._args_as_list(v, **kwargs)
 
-        # determine the output shape according to numpy broadcasting rules
-        args_aux = [freqs] + self._args_as_list(v, **kwargs)
-        out_shape = np.broadcast(*args_aux).shape
-
+        out_shape = np.broadcast(*([freqs] + args)).shape
         lin_f = np.zeros(out_shape, dtype=np.array(freqs).dtype)
+        # direct voltage coupling (frequency-independent)
+        lin_f += self.dp_dv(*args)
         for svar, dp_dx_ in dp_dx.items():
             df_dv_ = df_dv[svar] * 1e3  # convert to 1 / s
             df_dx_ = df_dx[svar] * 1e3  # convert to 1 / s
-            # add to the impedance contribution
             lin_f += dp_dx_ * df_dv_ / (freqs - df_dx_)
         return lin_f
 
@@ -878,16 +926,17 @@ def compute_linear_conc(self, v, freqs, ion, **kwargs):
         """
         dp_dx, df_dv, df_dx = self.compute_derivatives(v, **kwargs)
         df_dc = self.compute_derivativesConc(v, **kwargs)
+        args = self._args_as_list(v, **kwargs)
 
-        # determine the output shape according to numpy broadcasting rules
-        args_aux = [freqs] + self._args_as_list(v, **kwargs)
-        out_shape = np.broadcast(*args_aux).shape
-
+        out_shape = np.broadcast(*([freqs] + args)).shape
         lin_f = np.zeros(out_shape, dtype=np.array(freqs).dtype)
+        # direct concentration coupling (frequency-independent)
+        dp_dc_direct = self.dp_dc(*args)
+        if ion in dp_dc_direct:
+            lin_f += dp_dc_direct[ion]
         for svar, dp_dx_ in dp_dx.items():
             df_dc_ = df_dc[svar][ion] * 1e3  # convert to 1 / s
             df_dx_ = df_dx[svar] * 1e3  # convert to 1 / s
-            # add to the impedance contribution
             lin_f += dp_dx_ * df_dc_ / (freqs - df_dx_)
         return lin_f
 
@@ -911,8 +960,9 @@ def compute_lin_sum(self, v, freqs, e=None, **kwargs):
         freqs: float, complex, or `np.ndarray` of float or complex:
             The frequencies ``[Hz]`` at which to evaluate the linearized contribution
         e: float or `None`
-            The reversal potential of the channel. Defaults to the value stored
-            in `self.default_params['e']` if not provided.
+            Accepted for backward compatibility; ignored. The reversal potential
+            (or full GHK driving force) is embedded in `self.driving_force` and
+            substituted before lambdifying.
         **kwargs: float or `np.ndarray`
             Optional values for the state variables and concentrations.
 
@@ -922,10 +972,10 @@ def compute_lin_sum(self, v, freqs, e=None, **kwargs):
             The linearized current. Shape is dimension of `freqs` followed by
             the dimensions of `v`.
         """
-        e = self._get_reversal(e)
-        return (e - v) * self.compute_linear(v, freqs, **kwargs) - self.compute_p_open(
-            v, **kwargs
-        )
+        args = self._args_as_list(v, **kwargs)
+        D = self.f_driving_force(*args)
+        dD_dv = self.dD_dv(*args)
+        return -D * self.compute_linear(v, freqs, **kwargs) - self.compute_p_open(v, **kwargs) * dD_dv
 
     def compute_lin_conc(self, v, freqs, ion, e=None, **kwargs):
         """
@@ -940,8 +990,7 @@ def compute_lin_conc(self, v, freqs, ion, e=None, **kwargs):
         ion: str
             The ion name for which to compute the linearized contribution
         e: float or `None`
-            The reversal potential of the channel. Defaults to the value stored
-            in `self.default_params['e']` if not provided.
+            Accepted for backward compatibility; ignored. See `compute_lin_sum`.
         **kwargs: float or `np.ndarray`
             Optional values for the state variables and concentrations.
 
@@ -951,8 +1000,11 @@ def compute_lin_conc(self, v, freqs, ion, e=None, **kwargs):
             The linearized current. Shape is dimension of `freqs` followed by
             the dimensions of `v`.
         """
-        e = self._get_reversal(e)
-        return (e - v) * self.compute_linear_conc(v, freqs, ion, **kwargs)
+        args = self._args_as_list(v, **kwargs)
+        D = self.f_driving_force(*args)
+        dD_dci_ion = self.dD_dci(*args).get(ion, 0.0)
+        p = self.compute_p_open(v, **kwargs)
+        return -D * self.compute_linear_conc(v, freqs, ion, **kwargs) - p * dD_dci_ion
 
     def write_mod_file(self, path, g=0.0, e=None):
         """
@@ -976,11 +1028,27 @@ def write_mod_file(self, path, g=0.0, e=None):
         file.write("NEURON {\n")
         file.write("    SUFFIX I%s\n" % cname)
         if self.ion == "":
-            file.write("    NONSPECIFIC_CURRENT i" + "\n")
+            file.write("    NONSPECIFIC_CURRENT i\n")
+        elif self.ion in cs:
+            # ion is both written and read: merge into one USEION line
+            reads = [self.ion + "i"]
+            if self.ion in self.conc_ext:
+                reads.append(self.ion + "o")
+            file.write("    USEION %s READ %s WRITE i%s\n" % (self.ion, ", ".join(reads), self.ion))
         else:
-            file.write("    USEION %s WRITE i%s\n" % (self.ion, self.ion))
+            reads = []
+            if self.ion in self.conc_ext:
+                reads.append(self.ion + "o")
+            if reads:
+                file.write("    USEION %s READ %s WRITE i%s\n" % (self.ion, ", ".join(reads), self.ion))
+            else:
+                file.write("    USEION %s WRITE i%s\n" % (self.ion, self.ion))
         for c in cs:
-            file.write("    USEION %s READ %si\n" % (c, c))
+            if c != self.ion:
+                reads = [c + "i"]
+                if c in self.conc_ext:
+                    reads.append(c + "o")
+                file.write("    USEION %s READ %s\n" % (c, ", ".join(reads)))
         file.write("    RANGE  g, e" + "\n")
 
         taustring = "tau_" + ", tau_".join(sv)
@@ -1008,6 +1076,8 @@ def write_mod_file(self, path, g=0.0, e=None):
             file.write("    tau_%s (ms) \n" % var)
         for ion in cs:
             file.write("    " + ion + "i (mM)" + "\n")
+        for ion_str in self.conc_ext:
+            file.write("    " + ion_str + "o (mM)" + "\n")
         file.write("    v (mV)" + "\n")
         file.write("    %s (degC)\n" % (self.sp_t))
         file.write("}\n\n")
@@ -1017,20 +1087,40 @@ def write_mod_file(self, path, g=0.0, e=None):
             file.write("    %s\n" % var)
         file.write("}\n\n")
 
-        calcstring = "i%s = g * (%s) * (v - e)" % (
-            self.ion,
-            sp.printing.ccode(self.p_open),
-        )
+        # substitution for common neuron names (ca_ext → cao, ca → cai, etc.)
+        # ext replacements must come first so "ca" doesn't partially match "ca_ext"
+        repl_pairs = [(str(ion) + "_ext", str(ion) + "o") for ion in self.conc_ext]
+        repl_pairs += [(str(c), str(c) + "i") for c in self.conc]
+
+        calc_p_open = _nmodl_repl(sp.printing.ccode(self.p_open), repl_pairs)
+
+        # driving force: ohmic uses inline (v-e); non-ohmic gets its own FUNCTION block
+        # (LOCAL declarations are only valid inside FUNCTION/PROCEDURE, not BREAKPOINT)
+        ohmic_df = self.sp_v - sp.Symbol("e")
+        if self.driving_force == ohmic_df:
+            calcstring = "i%s = g * (%s) * (v - e)" % (self.ion, calc_p_open)
+        else:
+            # substitute temp → celsius so the FUNCTION uses the NEURON builtin directly
+            df_expr = self.driving_force.subs(self.sp_t, sp.Symbol("celsius"))
+            df_lines, _, df_locals = _nmodl_assignment_lines("df", df_expr, 0)
+            df_locals = list(dict.fromkeys(df_locals + ["df"]))
+            df_lines = [_nmodl_repl(line, repl_pairs) for line in df_lines]
+            calcstring = "i%s = g * (%s) * nmodl_df()" % (self.ion, calc_p_open)
+
+            file.write("FUNCTION nmodl_df() {\n")
+            file.write("    LOCAL %s\n" % ", ".join(df_locals))
+            for line in df_lines:
+                file.write(f"    {line}\n")
+            file.write("    nmodl_df = df\n")
+            file.write("}\n\n")
 
         file.write("BREAKPOINT {\n")
         file.write("    SOLVE states METHOD cnexp" + "\n")
         file.write("    %s\n" % calcstring)
         file.write("}\n\n")
 
-        concstring = "i, ".join(cs)
-        if len(cs) > 0:
-            concstring = ", " + concstring
-            concstring += "i"
+        conc_args = [str(c) + "i" for c in cs] + [str(ion) + "o" for ion in self.conc_ext]
+        concstring = (", " + ", ".join(conc_args)) if conc_args else ""
 
         file.write("INITIAL {\n")
         file.write("    rates(v%s)\n" % concstring)
@@ -1044,9 +1134,6 @@ def write_mod_file(self, path, g=0.0, e=None):
             file.write("    %s' = (%s_inf - %s) /  tau_%s \n" % (var, var, var, var))
         file.write("}\n\n")
 
-        # substitution for common neuron names
-        repl_pairs = [(str(c), str(c) + "i") for c in self.conc]
-
         assignment_lines = []
         local_vars = []
         temp_counter = 0
@@ -1062,10 +1149,7 @@ def write_mod_file(self, path, g=0.0, e=None):
             assignment_lines.extend(vi_lines)
             assignment_lines.extend(ti_lines)
 
-        for ii, line in enumerate(assignment_lines):
-            for repl_pair in repl_pairs:
-                line = line.replace(*repl_pair)
-            assignment_lines[ii] = line
+        assignment_lines = [_nmodl_repl(line, repl_pairs) for line in assignment_lines]
 
         file.write("PROCEDURE rates(v%s) {\n" % concstring)
         if local_vars:
diff --git a/src/neat/factorydefaults.py b/src/neat/factorydefaults.py
index 793d04d..62a3767 100644
--- a/src/neat/factorydefaults.py
+++ b/src/neat/factorydefaults.py
@@ -32,6 +32,10 @@ class DefaultPhysiology:
     conc: Dict[str, float] = field(
         default_factory=lambda: {"na": 10.0, "k": 54.4, "ca": 1e-4}  # mM
     )
+    # default extracellular concentrations (same as NEURON)
+    conc_ext: Dict[str, float] = field(
+        default_factory=lambda: {"ca": 2.0, "na": 140.0, "k": 5.0}  # mM
+    )
     # default ion channel reversals
     e_rev: Dict[str, float] = field(
         default_factory=lambda: {"na": 50.0, "k": -85.0, "ca": 50.0}  # mV
diff --git a/tests/channelcollection_for_tests.py b/tests/channelcollection_for_tests.py
index 66d38b9..ceb2833 100644
--- a/tests/channelcollection_for_tests.py
+++ b/tests/channelcollection_for_tests.py
@@ -24,6 +24,24 @@
 from neat.channels.ionchannels import IonChannel
 
 
+def ghk_expr(ion: str) -> sp.Expr:
+    """
+    GHK driving force as a sympy expression, for use in IonChannel.driving_force.
+
+    Symbols: v (mV), <ion> (intracellular mM), <ion>_ext (extracellular mM),
+    temp (degC). The _ext and temp symbols are substituted numerically by
+    IonChannel._substitute_defaults before lambdifying.
+    """
+    v, temp = sp.symbols("v temp")
+    ci = sp.symbols(ion)
+    co = sp.symbols(ion + "_ext")
+    KTF = (25 / 293.15) * (temp + 273.15)
+    f = KTF / 2
+    z = v / f
+    efun = sp.Piecewise((1 - z / 2, sp.Abs(z) < 1e-4), (z / (sp.exp(z) - 1), True))
+    return -f * (1 - (ci / co) * sp.exp(z)) * efun
+
+
 def vtrap(x, y):
     """
     Function to stabelize limit cases of 0/0 that occur in certain channel
@@ -312,3 +330,16 @@ def define(self):
         self.varinf = {"m": "1 / (1 + exp(-(v + 30) / 10))"}
         self.tauinf = {"m": "1."}
         self.e = -23.0
+
+
+class GHKChan(IonChannel):
+    """Toy GHK channel: p_open = m, driving force = GHK(ca)."""
+
+    def define(self):
+        self.ion = "ca"
+        self.conc = ["ca"]
+        self.conc_ext = ["ca"]
+        self.p_open = "m"
+        self.driving_force = ghk_expr("ca")
+        self.varinf = {"m": "1 / (1 + exp(-(v + 30) / 10))"}
+        self.tauinf = {"m": "1."}
diff --git a/tests/test_compartmentfitter.py b/tests/test_compartmentfitter.py
index ab52d28..74487e9 100755
--- a/tests/test_compartmentfitter.py
+++ b/tests/test_compartmentfitter.py
@@ -31,6 +31,7 @@
     GreensTree,
     SOVTree,
     NeuronCompartmentTree,
+    IonChannel,
     check_for_coreneuron,
 )
 from neat import CompartmentFitter, CachedGreensTree
@@ -51,6 +52,18 @@
 )
 
 
+class TwoVarConcDepChan(IonChannel):
+    def define(self):
+        self.conc = ["ca"]
+        self.p_open = "m * h"
+        self.varinf = {
+            "m": "1 / (1 + exp(-(v + 30) / (10 + 1000 * ca)))",
+            "h": "1 / (1 + exp((v + 45) / 10))",
+        }
+        self.tauinf = {"m": "1.", "h": "2."}
+        self.e = -23.0
+
+
 class TestCompartmentFitter:
     def load_T_tree(self):
         """
@@ -836,6 +849,8 @@ def test_e_eq_fit(self):
 def test_expansion_points():
     kv3_1 = channelcollection.Kv3_1()
     na_ta = channelcollection.Na_Ta()
+    conc_dep = channelcollection.ConcDepChan()
+    two_var_conc_dep = TwoVarConcDepChan()
 
     e_hs = np.array([-75.0, -15.0])
 
@@ -855,6 +870,81 @@ def test_expansion_points():
     assert not np.allclose(na_ta.f_varinf["h"](v_act), sv_hs["h"])
     assert np.allclose(v_act, sv_hs["v"])
 
+    # test expansion point concentration defaults for channels with direct
+    # concentration dependencies in p_open
+    sv_hs = compartmentfitter.get_expansion_points(e_hs, conc_dep)
+    ca_default = conc_dep.conc["ca"]
+    assert np.allclose(conc_dep.compute_varinf(e_hs)["m"], sv_hs["m"])
+    assert np.allclose(sv_hs["v"], e_hs)
+    assert np.allclose(sv_hs["ca"], np.full_like(e_hs, ca_default, dtype=float))
+
+    # test concentration-aware activation/inactivation classification for
+    # two-state-variable channels
+    sv_hs = compartmentfitter.get_expansion_points(e_hs, two_var_conc_dep)
+    ca_default = two_var_conc_dep.conc["ca"]
+    ca_args = np.full_like(v_act, ca_default, dtype=float)
+    assert np.allclose(two_var_conc_dep.f_varinf["m"](v_act, ca_args), sv_hs["m"])
+    assert np.allclose(
+        two_var_conc_dep.f_varinf["h"](v_inact, ca_args), sv_hs["h"]
+    )
+    assert np.allclose(sv_hs["ca"], np.full_like(v_act, ca_default, dtype=float))
+
+
+def test_eval_channel_passes_concentration_expansion_points():
+    channel = channelcollection.ConcDepChan()
+    seen_p_open_kwargs = []
+    orig_compute_p_open = channel.compute_p_open
+
+    def compute_p_open(v, **kwargs):
+        seen_p_open_kwargs.append(kwargs.copy())
+        assert "ca" in kwargs
+        return orig_compute_p_open(v, **kwargs)
+
+    channel.compute_p_open = compute_p_open
+
+    class FakeFitTree:
+        def __init__(self):
+            self.sv_h = None
+
+        def set_impedances_in_tree(self, freqs=None, sv_h=None, pprint=False):
+            self.sv_h = sv_h
+
+        def calc_impedance_matrix(self, locs):
+            n_exp = len(self.sv_h["ConcDepChan"]["v"])
+            return np.zeros((n_exp, 1, 1), dtype=float)
+
+    class FakeCTree:
+        def __init__(self):
+            self.svs = []
+
+        def compute_g_single_channel(self, *args, sv=None, **kwargs):
+            self.svs.append(dict(sv))
+            assert "ca" in sv
+            return np.zeros((1, 1), dtype=float), np.zeros(1, dtype=float)
+
+        def _fit_res_action(self, action, *args, **kwargs):
+            return None
+
+        def run_fit(self):
+            return None
+
+    cfit = object.__new__(CompartmentFitter)
+    cfit.channel_storage = {"ConcDepChan": channel}
+    cfit.fit_cfg = type(
+        "FitCfg", (), {"e_hs": np.array([-75.0, -15.0]), "freqs": 0.0}
+    )()
+
+    fake_ctree = FakeCTree()
+    fake_fit_tree = FakeFitTree()
+    cfit.convert_fit_arg = lambda fit_arg: (fake_ctree, [])
+    cfit.create_tree_gf = lambda *args, **kwargs: fake_fit_tree
+
+    cfit._eval_channel("test fit", "ConcDepChan")
+
+    assert len(fake_ctree.svs) == len(cfit.fit_cfg.e_hs)
+    assert all("ca" in sv for sv in fake_ctree.svs)
+    assert len(seen_p_open_kwargs) == len(cfit.fit_cfg.e_hs)
+
 
 if __name__ == "__main__":
     tcf = TestCompartmentFitter()
diff --git a/tests/test_ionchannels.py b/tests/test_ionchannels.py
index 97a1f90..881c4a4 100755
--- a/tests/test_ionchannels.py
+++ b/tests/test_ionchannels.py
@@ -230,7 +230,6 @@ class TestDirectDependencies:
 
     # --- concentration in p_open ---
 
-    @pytest.mark.xfail(reason="ca in p_open is mis-classified as a state variable")
     def test_conc_dep_statevars(self):
         """ca declared in self.conc must not appear in statevars even when in p_open."""
         ch = channelcollection.ConcDepChan()
@@ -238,7 +237,6 @@ def test_conc_dep_statevars(self):
         assert sp.symbols("ca") not in ch.statevars
         assert len(ch.statevars) == 1
 
-    @pytest.mark.xfail(reason="direct dp/dc term not yet included in compute_linear_conc")
     def test_conc_dep_linearization_dc(self):
         """At DC, compute_lin_conc must match d/d_ca[(e-v)*p_ss] via finite difference."""
         ch = channelcollection.ConcDepChan()
@@ -254,7 +252,6 @@ def p_ss(ca):
         neat_val = ch.compute_lin_conc(v0, 0.0, "ca", e=e)
         assert np.allclose(neat_val, fd, rtol=1e-4)
 
-    @pytest.mark.xfail(reason="USEION deduplication in write_mod_file not yet implemented")
     def test_conc_dep_mod_file(self, tmp_path):
         """MOD file must emit exactly one 'USEION ca READ cai WRITE ica' line."""
         ch = channelcollection.ConcDepChan()
@@ -274,7 +271,6 @@ def test_volt_dep_statevars(self):
         assert sp.symbols("v") not in ch.statevars
         assert len(ch.statevars) == 1
 
-    @pytest.mark.xfail(reason="direct dp/dv term not yet included in compute_linear")
     def test_volt_dep_linearization_dc(self):
         """At DC, compute_lin_sum must match d/dv[(e-v)*p_ss] via finite difference."""
         ch = channelcollection.VoltDepChan()
@@ -305,6 +301,100 @@ def test_regression_sk_statevars(self):
         assert len(sk.statevars) == 1
 
 
+def _ghk_D(v, cai, cao, temp):
+    """Numerical GHK driving force matching ghk_expr."""
+    KTF = (25 / 293.15) * (temp + 273.15)
+    f = KTF / 2
+    z = v / f
+    efun = 1 - z / 2 if abs(z) < 1e-4 else z / (np.exp(z) - 1)
+    return -f * (1 - (cai / cao) * np.exp(z)) * efun
+
+
+class TestGHKDrivingForce:
+    """
+    Tests for GHK driving-force support (Step 2–5 of IonChannel_ghk_extension_TODO.md).
+
+    Tests marked xfail describe the target behaviour and are expected to fail until
+    IonChannel is updated with driving_force / conc_ext / f_driving_force support.
+    """
+
+    def test_ghk_statevars(self):
+        """ca must not be in statevars; ca_ext must not appear in lambda arg lists."""
+        ch = channelcollection.GHKChan()
+        assert sp.symbols("m") in ch.statevars
+        assert sp.symbols("ca") not in ch.statevars
+        assert sp.symbols("ca_ext") not in ch.statevars
+        # ca_ext is substituted numerically — it must not end up in sp_c
+        assert sp.symbols("ca_ext") not in [sp.symbols(str(c)) for c in ch.sp_c]
+
+    def test_ghk_linearization_voltage_dc(self):
+        """At DC, compute_lin_sum must match -d/dv[p_ss(v)*D(v,cai0,cao0)] via FD."""
+        from neat.factorydefaults import DefaultPhysiology
+
+        ch = channelcollection.GHKChan()
+        cfg = DefaultPhysiology()
+        v0 = -40.0
+        cai0 = ch.conc[sp.symbols("ca")]
+        cao0 = cfg.conc_ext["ca"]
+        temp = cfg.temp
+
+        def p_ss(v):
+            return 1.0 / (1.0 + np.exp(-(v + 30.0) / 10.0))
+
+        dv = 1e-5
+        fd = -(
+            p_ss(v0 + dv) * _ghk_D(v0 + dv, cai0, cao0, temp)
+            - p_ss(v0 - dv) * _ghk_D(v0 - dv, cai0, cao0, temp)
+        ) / (2 * dv)
+        neat_val = ch.compute_lin_sum(v0, 0.0)
+        assert np.allclose(neat_val, fd, rtol=1e-4)
+
+    def test_ghk_linearization_conc_int_dc(self):
+        """At DC, compute_lin_conc('ca') must match -d/d_cai[p_ss*D(v,cai,cao0)] via FD."""
+        from neat.factorydefaults import DefaultPhysiology
+
+        ch = channelcollection.GHKChan()
+        cfg = DefaultPhysiology()
+        v0 = -40.0
+        cai0 = ch.conc[sp.symbols("ca")]
+        cao0 = cfg.conc_ext["ca"]
+        temp = cfg.temp
+
+        def p_ss(v):
+            return 1.0 / (1.0 + np.exp(-(v + 30.0) / 10.0))
+
+        dca = cai0 * 1e-5
+        fd = (
+            -p_ss(v0)
+            * (_ghk_D(v0, cai0 + dca, cao0, temp) - _ghk_D(v0, cai0 - dca, cao0, temp))
+            / (2 * dca)
+        )
+        neat_val = ch.compute_lin_conc(v0, 0.0, "ca")
+        assert np.allclose(neat_val, fd, rtol=1e-4)
+
+    def test_ghk_mod_file(self, tmp_path):
+        """MOD must have 'USEION ca READ cai, cao WRITE ica' and no 'ca_ext' in output."""
+        ch = channelcollection.GHKChan()
+        ch.write_mod_file(str(tmp_path))
+        text = (tmp_path / "IGHKChan.mod").read_text()
+        useion_lines = [l.strip() for l in text.splitlines() if "USEION ca" in l]
+        assert len(useion_lines) == 1
+        assert "cai" in useion_lines[0]
+        assert "cao" in useion_lines[0]
+        assert "WRITE ica" in useion_lines[0]
+        assert "ca_ext" not in text
+
+    def test_ohmic_regression(self):
+        """Na_Ta and SK give identical outputs regardless of GHK driving-force layer."""
+        na = channelcollection.Na_Ta()
+        assert np.allclose(na.compute_p_open(-35.0), 0.002009216860105564)
+        assert np.allclose(na.compute_lin_sum(-35.0, 0.0, 50.0), -0.00534261017220376)
+
+        sk = channelcollection.SK()
+        assert sp.symbols("z") in sk.statevars
+        assert sp.symbols("ca") not in sk.statevars
+
+
 if __name__ == "__main__":
     tcns = test_channels()
     tcns.test_basic()

From 727f09936d6f77fc633acb8ac20fd755d9534405 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Fri, 29 May 2026 11:34:39 +0200
Subject: [PATCH 06/17] fix nestml printing functions directly in channel
 current definition

---
 src/neat/channels/ionchannels.py | 41 ++++++++++++++-
 tests/test_nesttree.py           | 87 +++++++++++++++++++++++++++++++-
 2 files changed, 125 insertions(+), 3 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index 6f524aa..f3d399d 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -338,6 +338,28 @@ def _piecewise_to_nestml_expr(expr):
     return expr
 
 
+def _drop_piecewise_guards(expr):
+    """Replace every Piecewise with its else-branch (the True-condition clause).
+
+    Removes singularity guards (vtrap/efun-style Piecewise) from expressions,
+    leaving the regular analytic branch. The result can be inlined into NESTML
+    ``inline`` equations so NESTML's auto-differentiator can handle it without
+    emitting invalid ``Derivative(...)`` calls.
+    """
+    expr = sp.sympify(expr)
+    if isinstance(expr, sp.Piecewise):
+        for value, cond in expr.args:
+            if cond is sp.true or cond == True:
+                return _drop_piecewise_guards(value)
+        return _drop_piecewise_guards(expr.args[0][0])
+    if not expr.args:
+        return expr
+    new_args = [_drop_piecewise_guards(arg) for arg in expr.args]
+    if any(new_arg != old_arg for new_arg, old_arg in zip(new_args, expr.args)):
+        return _rebuild_sympy_expr(expr, new_args)
+    return expr
+
+
 def _nestml_function_assignment(lhs, expr):
     expr = _piecewise_to_nestml_expr(expr)
     return f"        {lhs} = {_nestml_ccode(expr)}\n"
@@ -1215,6 +1237,9 @@ def write_nestml_blocks(
         e = self._get_reversal(e)
         sv_init = self.compute_varinf(v_comp)
 
+        ohmic_df = self.sp_v - sp.Symbol("e")
+        is_ohmic = (self.driving_force == ohmic_df)
+
         blocks_dict = {block: "" for block in blocks}
 
         func_call_args = ["v_comp real"]
@@ -1253,11 +1278,23 @@ def write_nestml_blocks(
                     self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
+            if is_ohmic:
+                df_str = "(e_%s - v_comp)" % cname
+            else:
+                # inline the regular (else) branch of the driving force, dropping
+                # singularity guards (vtrap/efun Piecewise); NESTML's
+                # auto-differentiator cannot handle function calls in inline equations
+                df_expr = self._substitute_defaults(self.driving_force)
+                df_expr = df_expr.subs(self.sp_v, sp.Symbol("v_comp"))
+                for ckey in self.conc:
+                    df_expr = df_expr.subs(ckey, sp.Symbol(f"c_{ckey}"))
+                df_expr = _drop_piecewise_guards(df_expr)
+                df_str = "(%s)" % _nestml_ccode(df_expr)
             eq_str = (
                 "\n"
                 + "        # equation %s\n" % cname
-                + "        inline i_%s real = gbar_%s * (%s) * (e_%s - v_comp) @mechanism::channel\n"
-                % (cname, cname, str(p_open_), cname)
+                + "        inline i_%s real = gbar_%s * (%s) * %s @mechanism::channel\n"
+                % (cname, cname, str(p_open_), df_str)
             )
 
             for var, var_suff, svar in zip(sv, sv_suff, self.ordered_statevars):
diff --git a/tests/test_nesttree.py b/tests/test_nesttree.py
index cff9a76..c68cf19 100644
--- a/tests/test_nesttree.py
+++ b/tests/test_nesttree.py
@@ -308,6 +308,90 @@ def test_axon_nest_neuron_comparison(self, pplot=False):
             ax.plot(res_nest["times"], res_nest["v_comp2"], "bo--")
             pl.show()
 
+    def load_ghk_ball(self):
+        """Single-compartment ball model with a GHK calcium channel."""
+        self.tree = PhysTree(os.path.join(MORPHOLOGIES_PATH_PREFIX, "ball.swc"))
+        self.tree.set_physiology(0.8, 100.0 / 1e6)
+        self.ghk_chan = channelcollection.GHKChan()
+        # e_rev stored in the node but not used in the GHK computation
+        self.tree.add_channel_current(self.ghk_chan, 0.01 * 1e6, 50.0)
+        self.tree.fit_leak_current(-75.0, 10.0)
+        self.tree.set_v_ep(-75.0)
+        self.tree.set_comp_tree()
+        cfit = CompartmentFitter(self.tree, save_cache=False, recompute_cache=True)
+        self.ctree, _ = cfit.fit_model([(1, 0.5)])
+
+    def test_ghk_nest_neuron_comparison(self, pplot=False):
+        dt = 0.001
+        nest.ResetKernel()
+        channel_installer.load_or_install_nest_test_channels()
+        nest.SetKernelStatus(dict(resolution=dt))
+
+        self.load_ghk_ball()
+
+        # NEURON simulation
+        csimtree_neuron = NeuronCompartmentTree(self.ctree)
+        csimtree_neuron.init_model(dt=dt, t_calibrate=200.0)
+        csimtree_neuron.store_locs([(0, 0.5)], name="rec locs")
+        csimtree_neuron.add_double_exp_synapse((0, 0.5), 0.2, 3.0, 0.0)
+        csimtree_neuron.set_spiketrain(0, 0.01, [20.0, 23.0, 40.0])
+        res_neuron = csimtree_neuron.run(200.0)
+
+        # NEST simulation
+        csimtree_nest = NestCompartmentTree(self.ctree)
+        nestmodel = csimtree_nest.init_model("multichannel_test", 1)
+        nestmodel.receptors = [
+            {
+                "comp_idx": 0,
+                "receptor_type": "i_AMPA",
+                "params": {"e_AMPA": 0.0, "tau_r_AMPA": 0.2, "tau_d_AMPA": 3.0},
+            }
+        ]
+        sg = nest.Create("spike_generator", 1, {"spike_times": [220.0, 223.0, 240.0]})
+        nest.Connect(
+            sg,
+            nestmodel,
+            syn_spec={
+                "synapse_model": "static_synapse",
+                "weight": 0.01,
+                "delay": dt,
+                "receptor_type": 0,
+            },
+        )
+        mm = nest.Create(
+            "multimeter", 1, {"record_from": ["v_comp0"], "interval": dt}
+        )
+        nest.Connect(mm, nestmodel)
+        nest.Simulate(400.0)
+        res_nest = nest.GetStatus(mm, "events")[0]
+
+        idx0 = int(200.0 / dt)
+        res_nest["times"] = res_nest["times"][idx0:] - res_nest["times"][idx0]
+        res_nest["v_comp0"] = res_nest["v_comp0"][idx0:]
+
+        idx1 = min(len(res_neuron["v_m"][0]), len(res_nest["v_comp0"]))
+        assert (
+            np.sqrt(
+                np.mean(
+                    (res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2
+                )
+            )
+            < 0.05
+        )
+        assert np.allclose(
+            res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=1.0
+        )
+
+        if pplot:
+            pl.figure()
+            pl.plot(res_neuron["t"], res_neuron["v_m"][0], "rx-", label="NEURON")
+            pl.plot(res_nest["times"], res_nest["v_comp0"], "bo--", label="NEST")
+            pl.legend()
+            pl.xlabel("t (ms)")
+            pl.ylabel("v (mV)")
+            pl.title("GHK channel: NEURON vs NEST")
+            pl.show()
+
     def load_T_tree(self):
         """
         Parameters taken from a BBP SST model for a subset of ion channels
@@ -498,6 +582,7 @@ def test_dend_nest_neuron_comparison(self, pplot=False):
     tn = TestNest()
     # tn.test_model_construction()
     # tn.test_initialization()
-    tn.test_single_comp_nest_neuron_comparison(pplot=True)
+    # tn.test_single_comp_nest_neuron_comparison(pplot=True)
     # tn.test_axon_nest_neuron_comparison(pplot=True)
     # tn.test_dend_nest_neuron_comparison(pplot=True)
+    tn.test_ghk_nest_neuron_comparison(pplot=True)

From 094d6cf572069ec24bb85de1d7620de84a00d3ca Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Fri, 29 May 2026 12:48:34 +0200
Subject: [PATCH 07/17] fix treatment of reversal potential for ohmic channels,
 nest tests failing

---
 src/neat/channels/ionchannels.py           | 143 +++++++++++++++------
 src/neat/simulations/nest/nestmodel.py     |   4 +-
 src/neat/simulations/neuron/neuronmodel.py |  30 +++--
 src/neat/trees/phystree.py                 |  49 +++++--
 4 files changed, 161 insertions(+), 65 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index f3d399d..db19ce8 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -582,24 +582,27 @@ def __init__(self, **kwargs):
         if not hasattr(self.conc_ext, "values"):
             self.conc_ext = {str(ion): self.cfg.conc_ext[str(ion)] for ion in self.conc_ext}
 
+        if not hasattr(self, "driving_force"):
+            self.driving_force = self.sp_v - sp.Symbol("e")
+        self.driving_force = sp.sympify(self.driving_force)
+
         # default parameters
         self.default_params = SPDict({})
         self.default_params[str(self.sp_t)] = (
             self.temp if "temp" in self.__dict__ else self.cfg.temp
         )
-        try:
-            self.default_params["e"] = (
-                self.e if "e" in self.__dict__ else self.cfg.e_rev[self.ion]
-            )
-        except KeyError:
-            warnings.warn("No default reversal potential defined.")
+        if self._uses_e_rev:
+            try:
+                self.default_params["e"] = (
+                    self.e if "e" in self.__dict__ else self.cfg.e_rev[self.ion]
+                )
+            except KeyError:
+                warnings.warn(
+                    f"{self.__class__.__name__}: no default reversal potential defined."
+                )
         for ion_str, val in self.conc_ext.items():
             self.default_params[ion_str + "_ext"] = val
 
-        if not hasattr(self, "driving_force"):
-            self.driving_force = self.sp_v - sp.Symbol("e")
-        self.driving_force = sp.sympify(self.driving_force)
-
         # self._lambdify_channel()
         self.set_default_params(**kwargs)
 
@@ -653,6 +656,11 @@ def _substitute_defaults(self, expr):
     def ordered_statevars(self):
         return list(sorted(self.statevars, key=str))
 
+    @property
+    def _uses_e_rev(self) -> bool:
+        """True iff the channel's driving force contains the symbol ``e``."""
+        return sp.Symbol("e") in self.driving_force.free_symbols
+
     def _lambdify_channel(self):
         """
         Create lambda functions based on sympy expression for relevant ion
@@ -715,13 +723,25 @@ def _lambdify_channel(self):
             }
         )
 
-        # driving force D and its derivatives (temp, e, and <ion>_ext already substituted)
-        df_expr = self._substitute_defaults(self.driving_force)
-        self.f_driving_force = _broadcast(sp.lambdify(args, df_expr))
-        self.dD_dv = _broadcast(sp.lambdify(args, sp.diff(df_expr, self.sp_v, 1)))
+        # driving force D and its derivatives
+        # Substitute every default EXCEPT 'e', which stays as a runtime arg
+        # so that each call site can supply the node-specific reversal directly.
+        df_expr = self.driving_force
+        for param, val in self.default_params.items():
+            if param != "e":
+                df_expr = df_expr.subs(sp.symbols(param), val)
+
+        # For channels that use 'e', append it as the last positional argument.
+        # For non-ohmic channels (e not in driving_force) the arg list is unchanged.
+        df_lambda_args = args + ([sp.Symbol("e")] if self._uses_e_rev else [])
+
+        self.f_driving_force = _broadcast(sp.lambdify(df_lambda_args, df_expr))
+        self.dD_dv = _broadcast(
+            sp.lambdify(df_lambda_args, sp.diff(df_expr, self.sp_v, 1))
+        )
         self.dD_dci = CallDict(
             {
-                c: _broadcast(sp.lambdify(args, sp.diff(df_expr, c, 1)))
+                c: _broadcast(sp.lambdify(df_lambda_args, sp.diff(df_expr, c, 1)))
                 for c in self.sp_c
             }
         )
@@ -754,6 +774,22 @@ def _args_as_list(self, v, w_statevar=True, **kwargs):
 
         return arg_list
 
+    def _df_call_args(self, v, e=None, **kwargs):
+        """
+        Build the positional argument list for ``f_driving_force``, ``dD_dv``,
+        and ``dD_dci``.
+
+        Identical to ``_args_as_list`` for non-ohmic channels. For ohmic
+        channels (``_uses_e_rev`` is True) the reversal ``e`` is appended as the
+        last element. If ``e`` is ``None`` the channel's default is used.
+        """
+        base = self._args_as_list(v, **kwargs)
+        if self._uses_e_rev:
+            if e is None:
+                e = self.default_params.get("e")
+            return base + [e]
+        return base
+
     def compute_p_open(self, v, **kwargs):
         """
         Compute the open probability of the ion channel
@@ -963,11 +999,17 @@ def compute_linear_conc(self, v, freqs, ion, **kwargs):
         return lin_f
 
     def _get_reversal(self, e):
+        """Return the reversal potential, or ``None`` if the channel does not use one."""
+        if not self._uses_e_rev:
+            return None
         if e is None:
             try:
                 e = self.default_params["e"]
             except KeyError:
-                raise KeyError("No default reversal defined, provide value for `e`.")
+                raise KeyError(
+                    f"{self.__class__.__name__}: no default reversal defined; "
+                    "provide value for `e`."
+                )
         return e
 
     def compute_lin_sum(self, v, freqs, e=None, **kwargs):
@@ -982,9 +1024,8 @@ def compute_lin_sum(self, v, freqs, e=None, **kwargs):
         freqs: float, complex, or `np.ndarray` of float or complex:
             The frequencies ``[Hz]`` at which to evaluate the linearized contribution
         e: float or `None`
-            Accepted for backward compatibility; ignored. The reversal potential
-            (or full GHK driving force) is embedded in `self.driving_force` and
-            substituted before lambdifying.
+            Optional reversal potential override for channels whose driving
+            force uses ``e``.
         **kwargs: float or `np.ndarray`
             Optional values for the state variables and concentrations.
 
@@ -994,10 +1035,13 @@ def compute_lin_sum(self, v, freqs, e=None, **kwargs):
             The linearized current. Shape is dimension of `freqs` followed by
             the dimensions of `v`.
         """
-        args = self._args_as_list(v, **kwargs)
-        D = self.f_driving_force(*args)
-        dD_dv = self.dD_dv(*args)
-        return -D * self.compute_linear(v, freqs, **kwargs) - self.compute_p_open(v, **kwargs) * dD_dv
+        df_args = self._df_call_args(v, e=e, **kwargs)
+        D = self.f_driving_force(*df_args)
+        dD_dv = self.dD_dv(*df_args)
+        return (
+            -D * self.compute_linear(v, freqs, **kwargs)
+            - self.compute_p_open(v, **kwargs) * dD_dv
+        )
 
     def compute_lin_conc(self, v, freqs, ion, e=None, **kwargs):
         """
@@ -1012,7 +1056,8 @@ def compute_lin_conc(self, v, freqs, ion, e=None, **kwargs):
         ion: str
             The ion name for which to compute the linearized contribution
         e: float or `None`
-            Accepted for backward compatibility; ignored. See `compute_lin_sum`.
+            Optional reversal potential override for channels whose driving
+            force uses ``e``. See `compute_lin_sum`.
         **kwargs: float or `np.ndarray`
             Optional values for the state variables and concentrations.
 
@@ -1022,9 +1067,9 @@ def compute_lin_conc(self, v, freqs, ion, e=None, **kwargs):
             The linearized current. Shape is dimension of `freqs` followed by
             the dimensions of `v`.
         """
-        args = self._args_as_list(v, **kwargs)
-        D = self.f_driving_force(*args)
-        dD_dci_ion = self.dD_dci(*args).get(ion, 0.0)
+        df_args = self._df_call_args(v, e=e, **kwargs)
+        D = self.f_driving_force(*df_args)
+        dD_dci_ion = self.dD_dci(*df_args).get(ion, 0.0)
         p = self.compute_p_open(v, **kwargs)
         return -D * self.compute_linear_conc(v, freqs, ion, **kwargs) - p * dD_dci_ion
 
@@ -1071,7 +1116,10 @@ def write_mod_file(self, path, g=0.0, e=None):
                 if c in self.conc_ext:
                     reads.append(c + "o")
                 file.write("    USEION %s READ %s\n" % (c, ", ".join(reads)))
-        file.write("    RANGE  g, e" + "\n")
+        if self._uses_e_rev:
+            file.write("    RANGE  g, e" + "\n")
+        else:
+            file.write("    RANGE  g" + "\n")
 
         taustring = "tau_" + ", tau_".join(sv)
         varstring = "_inf, ".join(sv) + "_inf"
@@ -1081,7 +1129,8 @@ def write_mod_file(self, path, g=0.0, e=None):
 
         file.write("PARAMETER {\n")
         file.write("    g = " + str(g * 1e-6) + " (S/cm2)" + "\n")
-        file.write("    e = " + str(e) + " (mV)" + "\n")
+        if self._uses_e_rev:
+            file.write("    e = " + str(e) + " (mV)" + "\n")
         file.write("    celsius (degC)\n")
         file.write("}\n\n")
 
@@ -1118,8 +1167,7 @@ def write_mod_file(self, path, g=0.0, e=None):
 
         # driving force: ohmic uses inline (v-e); non-ohmic gets its own FUNCTION block
         # (LOCAL declarations are only valid inside FUNCTION/PROCEDURE, not BREAKPOINT)
-        ohmic_df = self.sp_v - sp.Symbol("e")
-        if self.driving_force == ohmic_df:
+        if self._uses_e_rev:
             calcstring = "i%s = g * (%s) * (v - e)" % (self.ion, calc_p_open)
         else:
             # substitute temp → celsius so the FUNCTION uses the NEURON builtin directly
@@ -1237,8 +1285,7 @@ def write_nestml_blocks(
         e = self._get_reversal(e)
         sv_init = self.compute_varinf(v_comp)
 
-        ohmic_df = self.sp_v - sp.Symbol("e")
-        is_ohmic = (self.driving_force == ohmic_df)
+        is_ohmic = self._uses_e_rev
 
         blocks_dict = {block: "" for block in blocks}
 
@@ -1264,8 +1311,9 @@ def write_nestml_blocks(
                 "\n"
                 + "        # parameters %s\n" % cname
                 + "        gbar_%s real = %.2f\n" % (cname, g)
-                + "        e_%s real = %.2f\n" % (cname, e)
             )
+            if self._uses_e_rev:
+                param_str += "        e_%s real = %.2f\n" % (cname, e)
 
             blocks_dict["parameters"] += param_str
 
@@ -1395,6 +1443,20 @@ def _replaceConc(expr_str, prefix="", suffix=""):
                 expr_str = expr_str.replace(str(ion), prefix + str(ion) + suffix)
             return expr_str
 
+        # Non-ohmic C++ backend paths need the full driving-force expression
+        # instead of the legacy hardcoded (m_e_rev - v) form.
+        if self._uses_e_rev:
+            df_ccode = "(m_e_rev - v)"
+            ddf_ccode = "-1."
+        else:
+            df_expr = _drop_piecewise_guards(self._substitute_defaults(self.driving_force))
+            df_ccode = sp.printing.ccode(df_expr).replace(str(self.sp_v), "v")
+            df_ccode = _replaceConc(df_ccode, prefix="m_")
+
+            ddf_expr = sp.diff(df_expr, self.sp_v, 1)
+            ddf_ccode = sp.printing.ccode(ddf_expr).replace(str(self.sp_v), "v")
+            ddf_ccode = _replaceConc(ddf_ccode, prefix="m_")
+
         # open header and cc files
         fcc = open(os.path.join(path, "Ionchannels.cc"), "a")
         fh = open(os.path.join(path, "Ionchannels.h"), "a")
@@ -1481,11 +1543,11 @@ def _replaceConc(expr_str, prefix="", suffix=""):
 
         # function for temporal integration
         fcc.write("double %s::f(double v){\n" % c_name)
-        fcc.write("    return (m_e_rev - v);\n")
+        fcc.write("    return %s;\n" % df_ccode)
         fcc.write("}\n")
 
         fcc.write("double %s::DfDv(double v){\n" % c_name)
-        fcc.write("    return -1.;\n")
+        fcc.write("    return %s;\n" % ddf_ccode)
         fcc.write("}\n")
 
         # set voltage values to evaluate at constant voltage during newton iteration
@@ -1520,10 +1582,7 @@ def _replaceConc(expr_str, prefix="", suffix=""):
             fcc.write("    }" + "\n")
             fcc.write("    double %s = %s;\n" % (str(svar), vi_ccode))
 
-        fcc.write(
-            "    return (m_e_rev - v) * (%s - m_p_open_eq);\n"
-            % sp.printing.ccode(self.p_open)
-        )
+        fcc.write("    return %s * (%s - m_p_open_eq);\n" % (df_ccode, sp.printing.ccode(self.p_open)))
         fcc.write("}\n")
 
         fcc.write("double %s::DfDvNewton(double v){\n" % c_name)
@@ -1566,8 +1625,8 @@ def _replaceConc(expr_str, prefix="", suffix=""):
         )
 
         fcc.write(
-            "    return -1. * (%s - m_p_open_eq) + (%s) * (m_e_rev - v);\n"
-            % (sp.printing.ccode(self.p_open), expr_str)
+            "    return %s * (%s - m_p_open_eq) + (%s) * %s;\n"
+            % (ddf_ccode, sp.printing.ccode(self.p_open), expr_str, df_ccode)
         )
         fcc.write("}\n")
 
diff --git a/src/neat/simulations/nest/nestmodel.py b/src/neat/simulations/nest/nestmodel.py
index f63693e..3a4ff6f 100755
--- a/src/neat/simulations/nest/nestmodel.py
+++ b/src/neat/simulations/nest/nestmodel.py
@@ -118,7 +118,9 @@ def _make_compartment_dict(self, channel_storage=None):
             f"gbar_{key}": self.currents[key][0] for key in self.currents if key != "L"
         }
         e_dict = {
-            f"e_{key}": self.currents[key][1] for key in self.currents if key != "L"
+            f"e_{key}": self.currents[key][1]
+            for key in self.currents
+            if key != "L" and channel_storage[key]._uses_e_rev
         }
 
         # concentration mech parameters
diff --git a/src/neat/simulations/neuron/neuronmodel.py b/src/neat/simulations/neuron/neuronmodel.py
index 34e2e07..d4e79f6 100755
--- a/src/neat/simulations/neuron/neuronmodel.py
+++ b/src/neat/simulations/neuron/neuronmodel.py
@@ -278,7 +278,7 @@ class NeuronSimNode(PhysNode):
     def __init__(self, index, p3d=None):
         super().__init__(index, p3d)
 
-    def _make_section(self, factorlambda=1.0, pprint=False):
+    def _make_section(self, channel_storage, factorlambda=1.0, pprint=False):
         compartment = h.Section(name=str(self.index))
         compartment.push()
         # create the compartment
@@ -306,16 +306,20 @@ def _make_section(self, factorlambda=1.0, pprint=False):
         compartment.Ra = self.r_a * 1e6  # MOhm*cm --> Ohm*cm
         # insert membrane currents
         for key, current in self.currents.items():
+            # check if the current has a reversal potential that needs to be set
+            uses_e_rev = (key == 'L') # True if leak, False otherwise
+            if key != 'L' and channel_storage[key]._uses_e_rev:
+                uses_e_rev = True
+
             if current[0] > 1e-10:
                 try:
                     compartment.insert(mechname[key])
                 except ValueError as e:
                     raise ValueError(str(e) + f" {mechname[key]}")
                 for seg in compartment:
-                    exec(
-                        "seg." + mechname[key] + ".g = " + str(current[0]) + "*1e-6"
-                    )  # uS/cm^2 --> S/cm^2
-                    exec("seg." + mechname[key] + ".e = " + str(current[1]))  # mV
+                    exec("seg." + mechname[key] + ".g = " + str(current[0]) + "*1e-6")  # uS/cm^2 --> S/cm^2
+                    if uses_e_rev:
+                        exec("seg." + mechname[key] + ".e = " + str(current[1]))  # mV
         # insert concentration mechanisms
         for ion, params in self.concmechs.items():
             compartment.insert(mechname[ion])
@@ -506,7 +510,9 @@ def delete_model(self):
     def _create_neuron_tree(self, pprint):
         for node in self:
             # create the NEURON section
-            compartment = node._make_section(self.factor_lambda, pprint=pprint)
+            compartment = node._make_section(
+                self.channel_storage, self.factor_lambda, pprint=pprint
+            )
             # connect with parent section
             if not self.is_root(node):
                 compartment.connect(self.sections[node.parent_node.index], 1, 0)
@@ -1438,7 +1444,7 @@ def __init__(self, index):
     def get_child_nodes(self, skip_inds=[]):
         return super().get_child_nodes(skip_inds=skip_inds)
 
-    def _make_section(self, pprint=False):
+    def _make_section(self, channel_storage, pprint=False):
         compartment = neuron.h.Section(name=str(self.index))
         compartment.push()
         # create the compartment
@@ -1461,13 +1467,19 @@ def _make_section(self, pprint=False):
         compartment.Ra = self.r_a * 1e6  # MOhm*cm --> Ohm*cm
         # insert membrane currents
         for key, current in self.currents.items():
+            # check if the current has a reversal potential that needs to be set
+            uses_e_rev = (key == 'L') # True if leak, False otherwise
+            if key != 'L' and channel_storage[key]._uses_e_rev:
+                uses_e_rev = True
+
             if current[0] > 1e-10:
                 compartment.insert(mechname[key])
                 for seg in compartment:
                     exec(
                         "seg." + mechname[key] + ".g = " + str(current[0]) + "*1e-6"
                     )  # uS/cm^2 --> S/cm^2
-                    exec("seg." + mechname[key] + ".e = " + str(current[1]))  # mV
+                    if uses_e_rev:
+                        exec("seg." + mechname[key] + ".e = " + str(current[1]))  # mV
         # insert concentration mechanisms
         for ion, params in self.concmechs.items():
             compartment.insert(mechname[ion])
@@ -1640,7 +1652,7 @@ def create_corresponding_node(self, node_index):
     def _create_neuron_tree(self, pprint):
         for node in self:
             # create the NEURON section
-            compartment = node._make_section(pprint=pprint)
+            compartment = node._make_section(self.channel_storage, pprint=pprint)
             # connect with parent section
             if not self.is_root(node):
                 compartment.connect(self.sections[node.parent_node.index], 0.5, 0)
diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index f7cdc7d..519e3ab 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -204,13 +204,16 @@ def fit_leak_current(self, channel_storage, e_eq_target=-75.0, tau_m_target=10.0
 
         for channel_name in set(self.currents.keys()) - set("L"):
             g, e = self.currents[channel_name]
+            channel = channel_storage[channel_name]
+            conc = self._construct_conc_args(channel)
 
             # compute channel conductance and current
-            p_open = channel_storage[channel_name].compute_p_open(e_eq_target)
+            p_open = channel.compute_p_open(e_eq_target, **conc)
             g_chan = g * p_open
 
             gsum += g_chan
-            i_eq += g_chan * (e - e_eq_target)
+            df_args = channel._df_call_args(e_eq_target, e=e, **conc)
+            i_eq -= g_chan * channel.f_driving_force(*df_args)
 
         if self.c_m / (tau_m_target * 1e-3) < gsum:
             warnings.warn(
@@ -294,9 +297,11 @@ def calc_i_tot(self, channel_storage, channel_names=None, v=None):
             if channel_name == "L":
                 i_tot += g * (v - e)
             else:
-                conc = self._construct_conc_args(channel_storage[channel_name])
-                p_open = channel_storage[channel_name].compute_p_open(v, **conc)
-                i_tot += g * p_open * (v - e)
+                channel = channel_storage[channel_name]
+                conc = self._construct_conc_args(channel)
+                p_open = channel.compute_p_open(v, **conc)
+                df_args = channel._df_call_args(v, e=e, **conc)
+                i_tot += g * p_open * channel.f_driving_force(*df_args)
 
         return i_tot
 
@@ -629,10 +634,23 @@ def add_channel_current(self, channel, g_max_distr, e_rev_distr, node_arg=None):
         if len(nodes_with_channel) > 0:
             self.channel_storage[channel_name] = channel
 
+        channel = self.channel_storage[channel_name]
         # add the ion channel to the nodes
         for node in self.convert_node_arg_to_nodes(node_arg):
             g_max = self._distr2Float(g_max_distr, node, argname="`g_max_distr`")
-            e_rev = self._distr2Float(e_rev_distr, node, argname="`e_rev_distr`")
+            if channel._uses_e_rev:
+                e_rev = self._distr2Float(e_rev_distr, node, argname="`e_rev_distr`")
+            else:
+                if e_rev_distr is not None:
+                    e_rev = self._distr2Float(
+                        e_rev_distr, node, argname="`e_rev_distr`"
+                    )
+                    warnings.warn(
+                        f"{channel_name}: driving force does not use a reversal "
+                        + f"potential; the provided `e_rev_distr` value ({e_rev}) "
+                        + "is ignored."
+                    )
+                e_rev = None
             assert int(np.sign(g_max)) != -1
             node._add_current(channel_name, g_max, e_rev)
 
@@ -743,11 +761,11 @@ def _evaluate_comp_criteria(self, node, eps=1e-8, rbool=False):
                         [np.abs(channel[0]), np.abs(cnode.currents[chan_name][0])]
                     )
                 if not rbool:
-                    rbool = np.abs(
-                        channel[1] - cnode.currents[chan_name][1]
-                    ) > eps * np.max(
-                        [np.abs(channel[1]), np.abs(cnode.currents[chan_name][1])]
-                    )
+                    child_reversal = cnode.currents[chan_name][1]
+                    if channel[1] is not None and child_reversal is not None:
+                        rbool = np.abs(channel[1] - child_reversal) > eps * np.max(
+                            [np.abs(channel[1]), np.abs(child_reversal)]
+                        )
         if not rbool:
             rbool = node.g_shunt > 0.001 * eps
 
@@ -917,10 +935,15 @@ def create_finite_difference_tree(self, dx_max=15.0, name="dont store"):
                         e_parent = aux_node.currents[chan][1]
 
                     if g_parent + g_node > 1e-10:
+                        if e_node is not None and e_parent is not None:
+                            e_parent = (g_parent * e_parent + g_node * e_node) / (
+                                g_parent + g_node
+                            )
+                        else:
+                            e_parent = None
                         fd_parent.currents[chan] = (
                             g_parent + g_node,
-                            (g_parent * e_parent + g_node * e_node)
-                            / (g_parent + g_node),
+                            e_parent,
                         )
                     else:
                         fd_parent.currents[chan] = (0.0, e_parent)

From ecfc7a9bfdacf59d1179e0ad134b304f941cd4bf Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Tue, 2 Jun 2026 13:51:42 +0200
Subject: [PATCH 08/17] bugfixes in NEST channel generation

---
 src/neat/channels/ionchannels.py             |  22 ++--
 src/neat/modelreduction/compartmentfitter.py |   5 +-
 src/neat/simulations/nest/nestmodel.py       |   2 +
 src/neat/trees/compartmenttree.py            |   6 +-
 src/neat/trees/phystree.py                   |   2 +-
 tests/test_ionchannels.py                    |  25 ++++
 tests/test_nesttree.py                       | 126 ++++++++++---------
 7 files changed, 108 insertions(+), 80 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index db19ce8..ea9b4e4 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -1375,13 +1375,10 @@ def _customsimplify(expr):
                     self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
-                if _needs_nestml_piecewise_lowering(varinf_func):
-                    value_str = _nestml_function_assignment('val', varinf_func)
-                else:
-                    code_str = sp.pycode(varinf_func, fully_qualified_modules=False)
-                    value_str = self._create_nestml_funcstr(
-                        code_str, n_spaces=4, indent=8
-                    )
+                code_str = sp.pycode(varinf_func, fully_qualified_modules=False)
+                value_str = self._create_nestml_funcstr(
+                    code_str, n_spaces=4, indent=8
+                )
 
                 func_str += (
                     f"    function {sv_}_inf_{cname} ({func_call_args}) real:\n"
@@ -1402,13 +1399,10 @@ def _customsimplify(expr):
                     self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
-                if _needs_nestml_piecewise_lowering(tauinf_func):
-                    value_str = _nestml_function_assignment('val', tauinf_func)
-                else:
-                    code_str = sp.pycode(tauinf_func, fully_qualified_modules=False)
-                    value_str = self._create_nestml_funcstr(
-                        code_str, n_spaces=4, indent=8
-                    )
+                code_str = sp.pycode(tauinf_func, fully_qualified_modules=False)
+                value_str = self._create_nestml_funcstr(
+                    code_str, n_spaces=4, indent=8
+                )
 
                 func_str += (
                     f"\n    function tau_{sv_}_{cname} ({func_call_args}) real:\n"
diff --git a/src/neat/modelreduction/compartmentfitter.py b/src/neat/modelreduction/compartmentfitter.py
index 554ed3f..aebaff6 100755
--- a/src/neat/modelreduction/compartmentfitter.py
+++ b/src/neat/modelreduction/compartmentfitter.py
@@ -336,7 +336,10 @@ def set_ctree(self, loc_arg, fit_name="", extend_w_bifurc=True, pprint=False):
                 if c_name in node.currents:
                     e_revs.append(node.currents[c_name][1])
             # reversal potential is the same throughout the reduced model
-            ctree.add_channel_current(copy.deepcopy(channel), np.mean(e_revs))
+            ctree.add_channel_current(
+                copy.deepcopy(channel), 
+                np.mean(e_revs) if None not in e_revs else None
+            )
 
         for node in ctree:
             loc_idx = node.loc_idx
diff --git a/src/neat/simulations/nest/nestmodel.py b/src/neat/simulations/nest/nestmodel.py
index 3a4ff6f..123f1bc 100755
--- a/src/neat/simulations/nest/nestmodel.py
+++ b/src/neat/simulations/nest/nestmodel.py
@@ -165,6 +165,8 @@ def _make_compartment_dict(self, channel_storage=None):
         else:
             parent_idx = self.parent_node.index
 
+        print(self.index, p_dict)
+
         return {"parent_idx": parent_idx, "params": p_dict}
 
 
diff --git a/src/neat/trees/compartmenttree.py b/src/neat/trees/compartmenttree.py
index c5b70fa..e40a659 100755
--- a/src/neat/trees/compartmenttree.py
+++ b/src/neat/trees/compartmenttree.py
@@ -444,10 +444,10 @@ def calc_i_tot(
             v, sv = self._construct_channel_args(channel)
 
             if channel_name not in p_open_channels:
-                i_tot = i_tot + g * channel.compute_p_open(v, **sv) * (v - e)
+                i_tot = i_tot + g * channel.compute_p_open(v, **sv) * channel.f_driving_force(*channel._df_call_args(v, e, **sv))
 
             else:
-                i_tot = i_tot + g * p_open_channels[channel_name] * (v - e)
+                i_tot = i_tot + g * p_open_channels[channel_name] * channel.f_driving_force(*channel._df_call_args(v, e, **sv))
 
         return i_tot
 
@@ -490,7 +490,7 @@ def calc_linear_statevar_terms(self, channel_storage, v=None, channel_names=None
 
             svar_terms[channel_name] = {}
             for svar, dp_dx_ in dp_dx.items():
-                svar_terms[channel_name][svar] = g * dp_dx_ * (e - v)
+                svar_terms[channel_name][svar] = g * dp_dx_ * -channel.f_driving_force(*channel._df_call_args(v, e, **sv))
 
         return svar_terms
 
diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index 519e3ab..681c9bd 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -379,7 +379,7 @@ def _get_repr_dict(self):
         repr_dict.update(
             {
                 "currents": {
-                    c: (f"({g:1.6g}, {e:1.6g})") for c, (g, e) in self.currents.items()
+                    c: (f"({g:1.6g}, {e:1.6g})") if e is not None else (f"({g:1.6g}, )") for c, (g, e) in self.currents.items()
                 },
                 "concmechs": self.concmechs,
                 "c_m": f"{self.c_m:1.6g}",
diff --git a/tests/test_ionchannels.py b/tests/test_ionchannels.py
index 881c4a4..b7034ef 100755
--- a/tests/test_ionchannels.py
+++ b/tests/test_ionchannels.py
@@ -220,6 +220,31 @@ def test_broadcasting():
     assert np.allclose(tauinf["b"], np.array([0.1, 0.1, 50.0]))
 
 
+def test_nestml_piecewise_functions_are_not_collapsed():
+    """
+    NESTML export must preserve branch logic for vtrap/piecewise kinetics.
+
+    If these functions are flattened to the first branch, NaTa_t opens
+    incorrectly near rest and NEST initialization depolarizes immediately.
+    """
+
+    def _extract_function_block(text, name):
+        start = text.index(f"function {name} ")
+        end = text.find("\n    function ", start + 1)
+        return text[start:] if end == -1 else text[start:end]
+
+    na_ta_t = channelcollection.NaTa_t()
+    func_block = na_ta_t.write_nestml_blocks(blocks=["function"])["function"]
+
+    m_block = _extract_function_block(func_block, "m_inf_NaTa_t")
+    h_block = _extract_function_block(func_block, "h_inf_NaTa_t")
+
+    assert "if " in m_block and "else:" in m_block
+    assert "if " in h_block and "else:" in h_block
+    assert "exp(" in m_block
+    assert "exp(" in h_block
+
+
 class TestDirectDependencies:
     """
     Tests for first-class direct p_open(v, c, x) dependencies on voltage and concentration.
diff --git a/tests/test_nesttree.py b/tests/test_nesttree.py
index c68cf19..f0bd2ef 100644
--- a/tests/test_nesttree.py
+++ b/tests/test_nesttree.py
@@ -99,7 +99,7 @@ def test_initialization(self):
         channel_installer.load_or_install_nest_test_channels()
         nest.SetKernelStatus(dict(resolution=dt))
 
-        v_eq = -65.0
+        v_eq = -65.
         self.load_ball()
         self.tree.fit_leak_current(v_eq, 10.0)
         # set computational tree
@@ -125,6 +125,11 @@ def test_initialization(self):
         sv_na = self.na_chan.compute_varinf(v_eq)
         sv_k = self.k_chan.compute_varinf(v_eq)
 
+        # from matplotlib import pyplot as pl
+        # pl.plot(res_nest["times"], res_nest["v_comp0"], "bo--", label="v")
+        # pl.show()
+
+        print("v_eq:", v_eq, " | v_nest:", res_nest["v_comp0"][0])
         assert np.abs(res_nest["v_comp0"][0] - v_eq) < 1e-8
         assert np.abs(res_nest["m_Kv3_10"][0] - sv_k["m"]) < 1e-8
         assert np.abs(res_nest["m_NaTa_t0"][0] - sv_na["m"]) < 1e-8
@@ -136,9 +141,9 @@ def test_initialization(self):
 
     def test_single_comp_nest_neuron_comparison(self, pplot=False):
         dt = 0.001
-        # nest.ResetKernel()
-        # channel_installer.load_or_install_nest_test_channels()
-        # nest.SetKernelStatus(dict(resolution=dt))
+        nest.ResetKernel()
+        channel_installer.load_or_install_nest_test_channels()
+        nest.SetKernelStatus(dict(resolution=dt))
 
         self.load_ball()
         csimtree_neuron = NeuronCompartmentTree(self.ctree)
@@ -148,54 +153,53 @@ def test_single_comp_nest_neuron_comparison(self, pplot=False):
         csimtree_neuron.set_spiketrain(0, 0.001, [20.0, 23.0, 40.0])
         res_neuron = csimtree_neuron.run(200.0)
 
-        # csimtree_nest = NestCompartmentTree(self.ctree)
-        # nestmodel = csimtree_nest.init_model("multichannel_test", 1)
-        # # inputs
-        # nestmodel.receptors = [
-        #     {
-        #         "comp_idx": 0,
-        #         "receptor_type": "i_AMPA",
-        #         "params": {"e_AMPA": 0.0, "tau_r_AMPA": 0.2, "tau_d_AMPA": 3.0},
-        #     }
-        # ]
-        # sg = nest.Create("spike_generator", 1, {"spike_times": [220.0, 223.0, 240.0]})
-        # nest.Connect(
-        #     sg,
-        #     nestmodel,
-        #     syn_spec={
-        #         "synapse_model": "static_synapse",
-        #         "weight": 0.001,
-        #         "delay": 3 * dt,
-        #         "receptor_type": 0,
-        #     },
-        # )
-        # # voltage recording
-        # mm = nest.Create("multimeter", 1, {"record_from": ["v_comp0"], "interval": dt})
-        # nest.Connect(mm, nestmodel)
-        # # simulate
-        # nest.Simulate(400.0)
-        # res_nest = nest.GetStatus(mm, "events")[0]
-
-        # idx0 = int(200.0 / dt)
-        # res_nest["times"] = res_nest["times"][idx0:] - res_nest["times"][idx0]
-        # res_nest["v_comp0"] = res_nest["v_comp0"][idx0:]
-        # v0 = res_nest["v_comp0"][0]
-
-        # idx1 = min(len(res_neuron["v_m"][0]), len(res_nest["v_comp0"]))
-        # assert (
-        #     np.sqrt(
-        #         np.mean((res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2)
-        #     )
-        #     < 0.05
-        # )
-        # assert np.allclose(
-        #     res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=4.0
-        # )
+        csimtree_nest = NestCompartmentTree(self.ctree)
+        nestmodel = csimtree_nest.init_model("multichannel_test", 1)
+        # inputs
+        nestmodel.receptors = [
+            {
+                "comp_idx": 0,
+                "receptor_type": "i_AMPA",
+                "params": {"e_AMPA": 0.0, "tau_r_AMPA": 0.2, "tau_d_AMPA": 3.0},
+            }
+        ]
+        sg = nest.Create("spike_generator", 1, {"spike_times": [220.0, 223.0, 240.0]})
+        nest.Connect(
+            sg,
+            nestmodel,
+            syn_spec={
+                "synapse_model": "static_synapse",
+                "weight": 0.001,
+                "delay": 3 * dt,
+                "receptor_type": 0,
+            },
+        )
+        # voltage recording
+        mm = nest.Create("multimeter", 1, {"record_from": ["v_comp0"], "interval": dt})
+        nest.Connect(mm, nestmodel)
+        # simulate
+        nest.Simulate(400.0)
+        res_nest = nest.GetStatus(mm, "events")[0]
+
+        idx0 = int(200.0 / dt)
+        res_nest["times"] = res_nest["times"][idx0:] - res_nest["times"][idx0]
+        res_nest["v_comp0"] = res_nest["v_comp0"][idx0:]
+        v0 = res_nest["v_comp0"][0]
+
+        idx1 = min(len(res_neuron["v_m"][0]), len(res_nest["v_comp0"]))
+        assert (
+            np.sqrt(
+                np.mean((res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2)
+            )
+            < 0.05
+        )
+        assert np.allclose(
+            res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=4.0
+        )
 
         if pplot:
-            pl.plot(res_neuron["t"][:], res_neuron["v_m"][0][:], "rx-")
-            # pl.plot(res_neuron["t"][:idx1], res_neuron["v_m"][0][:idx1], "rx-")
-            # pl.plot(res_nest["times"][:idx1], res_nest["v_comp0"][:idx1], "bo--")
+            pl.plot(res_neuron["t"][:idx1], res_neuron["v_m"][0][:idx1], "rx-")
+            pl.plot(res_nest["times"][:idx1], res_nest["v_comp0"][:idx1], "bo--")
             pl.show()
 
     def load_axon_tree(self):
@@ -370,17 +374,17 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
         res_nest["v_comp0"] = res_nest["v_comp0"][idx0:]
 
         idx1 = min(len(res_neuron["v_m"][0]), len(res_nest["v_comp0"]))
-        assert (
-            np.sqrt(
-                np.mean(
-                    (res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2
-                )
-            )
-            < 0.05
-        )
-        assert np.allclose(
-            res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=1.0
-        )
+        # assert (
+        #     np.sqrt(
+        #         np.mean(
+        #             (res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2
+        #         )
+        #     )
+        #     < 0.05
+        # )
+        # assert np.allclose(
+        #     res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=1.0
+        # )
 
         if pplot:
             pl.figure()

From 03f7150ea7153d2f6e76899ea762b3f750fca22f Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Tue, 2 Jun 2026 15:28:02 +0200
Subject: [PATCH 09/17] apply NEAT factory defaults to neuron

---
 src/neat/channels/ionchannels.py           | 14 +++--
 src/neat/simulations/neuron/neuronmodel.py | 41 +++++++++++++
 tests/test_ionchannels.py                  | 16 +++++
 tests/test_load_neuronmodel.py             | 68 ++++++++++++++++++++++
 tests/test_nesttree.py                     | 39 +++++++------
 5 files changed, 157 insertions(+), 21 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index ea9b4e4..8a6a917 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -1329,10 +1329,16 @@ def write_nestml_blocks(
             if is_ohmic:
                 df_str = "(e_%s - v_comp)" % cname
             else:
-                # inline the regular (else) branch of the driving force, dropping
-                # singularity guards (vtrap/efun Piecewise); NESTML's
-                # auto-differentiator cannot handle function calls in inline equations
-                df_expr = self._substitute_defaults(self.driving_force)
+                # NEST channel currents are inward-positive, while NEAT stores
+                # driving_force in the NEURON/outward-current convention.
+                # Flip the sign here so non-ohmic exports match the ohmic
+                # (e_rev - v_comp) convention used above.
+                #
+                # Inline the regular (else) branch of the driving force,
+                # dropping singularity guards (vtrap/efun Piecewise);
+                # NESTML's auto-differentiator cannot handle function calls in
+                # inline equations.
+                df_expr = -self._substitute_defaults(self.driving_force)
                 df_expr = df_expr.subs(self.sp_v, sp.Symbol("v_comp"))
                 for ckey in self.conc:
                     df_expr = df_expr.subs(ckey, sp.Symbol(f"c_{ckey}"))
diff --git a/src/neat/simulations/neuron/neuronmodel.py b/src/neat/simulations/neuron/neuronmodel.py
index d4e79f6..2d3a768 100755
--- a/src/neat/simulations/neuron/neuronmodel.py
+++ b/src/neat/simulations/neuron/neuronmodel.py
@@ -134,6 +134,43 @@ def _mark_neuron_model_loaded(model_path):
     _LOADED_NEURON_MODELS.add(_normalize_model_path(model_path))
 
 
+def _apply_neat_neuron_defaults():
+    """
+    Apply NEAT physiology defaults to the global NEURON runtime.
+
+    NEURON stores default ion concentrations in runtime globals such as
+    ``nai0_na_ion`` and ``cai0_ca_ion``. Newly created sections inherit from
+    these values, so setting them once at the runtime level is cleaner than
+    patching each model instance separately.
+    """
+    try:
+        default_phys = DefaultPhysiology()
+    except Exception:
+        return
+
+    temp = getattr(default_phys, "temp", None)
+    if temp is not None:
+        try:
+            h.celsius = temp
+        except (AttributeError, LookupError):
+            pass
+
+    for ion, value in getattr(default_phys, "conc", {}).items():
+        try:
+            setattr(h, f"{ion}i0_{ion}_ion", value)
+        except (AttributeError, LookupError):
+            pass
+
+    for ion, value in getattr(default_phys, "conc_ext", {}).items():
+        try:
+            setattr(h, f"{ion}o0_{ion}_ion", value)
+        except (AttributeError, LookupError):
+            pass
+
+
+_apply_neat_neuron_defaults()
+
+
 def _get_neuron_runtime_metadata():
     return {
         "neuron_version": neuron.__version__,
@@ -210,11 +247,13 @@ def should_wrap_load_exception(err):
         )
         if os.path.exists(path):
             if _is_neuron_model_loaded(model_path):
+                _apply_neat_neuron_defaults()
                 return
             _validate_neuron_build_metadata(model_path)
             try:
                 h.nrn_load_dll(path)  # load all mechanisms
                 _mark_neuron_model_loaded(model_path)
+                _apply_neat_neuron_defaults()
             except Exception as err:
                 if should_wrap_load_exception(err):
                     raise_load_err(path, err)
@@ -231,6 +270,7 @@ def should_wrap_load_exception(err):
             print(f"Found path: {model_path}, loading mechanisms...")
             if _is_neuron_model_loaded(model_path):
                 print("... already loaded.")
+                _apply_neat_neuron_defaults()
                 return
             _validate_neuron_build_metadata(model_path)
             if not USE_CORENEURON:
@@ -246,6 +286,7 @@ def should_wrap_load_exception(err):
                         f"Loading mechanisms from '{model_path}' failed."
                     )
             _mark_neuron_model_loaded(model_path)
+            _apply_neat_neuron_defaults()
             print(f"... done.")
         else:
             print_err()
diff --git a/tests/test_ionchannels.py b/tests/test_ionchannels.py
index b7034ef..4c23c85 100755
--- a/tests/test_ionchannels.py
+++ b/tests/test_ionchannels.py
@@ -409,6 +409,22 @@ def test_ghk_mod_file(self, tmp_path):
         assert "WRITE ica" in useion_lines[0]
         assert "ca_ext" not in text
 
+    def test_ghk_nestml_uses_inward_positive_sign(self):
+        """
+        NEST exports channel currents as inward-positive.
+
+        For non-ohmic channels, this means the stored NEURON-style driving
+        force must be negated when generating the NESTML current equation.
+        """
+        ch = channelcollection.GHKChan()
+        text = ch.write_nestml_blocks(blocks=["equations"])["equations"]
+        line = next(
+            line.strip() for line in text.splitlines() if "inline i_GHKChan real =" in line
+        )
+        assert "inline i_GHKChan real =" in line
+        assert "* (13.182244584683609" in line
+        assert "* (-13.182244584683609" not in line
+
     def test_ohmic_regression(self):
         """Na_Ta and SK give identical outputs regardless of GHK driving-force layer."""
         na = channelcollection.Na_Ta()
diff --git a/tests/test_load_neuronmodel.py b/tests/test_load_neuronmodel.py
index a2ee89d..5a1e26b 100644
--- a/tests/test_load_neuronmodel.py
+++ b/tests/test_load_neuronmodel.py
@@ -182,3 +182,71 @@ def fake_load_mechanisms(path):
         assert calls == [str(model_path)]
     finally:
         shutil.rmtree(model_path)
+
+
+def test_apply_neat_neuron_defaults_sets_runtime_globals(monkeypatch):
+    neuronmodel = _load_neuronmodel(monkeypatch)
+
+    class FakeDefaults:
+        def __init__(self):
+            self.temp = 36.0
+            self.conc = {"na": 11.0, "k": 22.0, "ca": 33.0}
+            self.conc_ext = {"na": 111.0, "k": 222.0, "ca": 333.0}
+
+    monkeypatch.setattr(neuronmodel, "DefaultPhysiology", FakeDefaults)
+
+    neuronmodel.h.celsius = 6.3
+    neuronmodel.h.nai0_na_ion = 10.0
+    neuronmodel.h.ki0_k_ion = 54.4
+    neuronmodel.h.cai0_ca_ion = 5e-05
+    neuronmodel.h.nao0_na_ion = 140.0
+    neuronmodel.h.ko0_k_ion = 2.5
+    neuronmodel.h.cao0_ca_ion = 2.0
+
+    neuronmodel._apply_neat_neuron_defaults()
+
+    assert neuronmodel.h.celsius == 36.0
+    assert neuronmodel.h.nai0_na_ion == 11.0
+    assert neuronmodel.h.ki0_k_ion == 22.0
+    assert neuronmodel.h.cai0_ca_ion == 33.0
+    assert neuronmodel.h.nao0_na_ion == 111.0
+    assert neuronmodel.h.ko0_k_ion == 222.0
+    assert neuronmodel.h.cao0_ca_ion == 333.0
+
+
+def test_load_neuron_model_applies_defaults_after_loading(monkeypatch):
+    neuronmodel = _load_neuronmodel(monkeypatch)
+
+    class FakeDefaults:
+        def __init__(self):
+            self.temp = 36.0
+            self.conc = {"na": 11.0, "k": 22.0, "ca": 33.0}
+            self.conc_ext = {"na": 111.0, "k": 222.0, "ca": 333.0}
+
+    monkeypatch.setattr(neuronmodel, "DefaultPhysiology", FakeDefaults)
+
+    def fake_load_mechanisms(path):
+        return True
+
+    monkeypatch.setattr(neuronmodel.neuron, "load_mechanisms", fake_load_mechanisms)
+
+    model_name = f"test_model_{uuid.uuid4().hex}"
+    model_path = Path(neuronmodel.__file__).resolve().parent / "tmp" / model_name
+    model_path.mkdir(parents=True)
+
+    try:
+        (model_path / "build_info.json").write_text(
+            json.dumps(neuronmodel._get_neuron_runtime_metadata())
+        )
+
+        neuronmodel.load_neuron_model(model_name)
+
+        assert neuronmodel.h.celsius == 36.0
+        assert neuronmodel.h.nai0_na_ion == 11.0
+        assert neuronmodel.h.ki0_k_ion == 22.0
+        assert neuronmodel.h.cai0_ca_ion == 33.0
+        assert neuronmodel.h.nao0_na_ion == 111.0
+        assert neuronmodel.h.ko0_k_ion == 222.0
+        assert neuronmodel.h.cao0_ca_ion == 333.0
+    finally:
+        shutil.rmtree(model_path)
diff --git a/tests/test_nesttree.py b/tests/test_nesttree.py
index f0bd2ef..326d0db 100644
--- a/tests/test_nesttree.py
+++ b/tests/test_nesttree.py
@@ -317,8 +317,10 @@ def load_ghk_ball(self):
         self.tree = PhysTree(os.path.join(MORPHOLOGIES_PATH_PREFIX, "ball.swc"))
         self.tree.set_physiology(0.8, 100.0 / 1e6)
         self.ghk_chan = channelcollection.GHKChan()
+        # self.ghk_chan = channelcollection.SK_E2()
         # e_rev stored in the node but not used in the GHK computation
         self.tree.add_channel_current(self.ghk_chan, 0.01 * 1e6, 50.0)
+        # self.tree.add_conc_mech('ca', params=dict(gamma=0.01, tau=100.0))
         self.tree.fit_leak_current(-75.0, 10.0)
         self.tree.set_v_ep(-75.0)
         self.tree.set_comp_tree()
@@ -333,13 +335,16 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
 
         self.load_ghk_ball()
 
+        t_cal = 500.
+        t_sim = 200.
+        t_spks = np.array([20.0, 23.0, 40.0]) 
         # NEURON simulation
         csimtree_neuron = NeuronCompartmentTree(self.ctree)
-        csimtree_neuron.init_model(dt=dt, t_calibrate=200.0)
+        csimtree_neuron.init_model(dt=dt, t_calibrate=t_cal)
         csimtree_neuron.store_locs([(0, 0.5)], name="rec locs")
         csimtree_neuron.add_double_exp_synapse((0, 0.5), 0.2, 3.0, 0.0)
-        csimtree_neuron.set_spiketrain(0, 0.01, [20.0, 23.0, 40.0])
-        res_neuron = csimtree_neuron.run(200.0)
+        csimtree_neuron.set_spiketrain(0, 0.01, t_spks.tolist())
+        res_neuron = csimtree_neuron.run(t_sim)
 
         # NEST simulation
         csimtree_nest = NestCompartmentTree(self.ctree)
@@ -351,7 +356,7 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
                 "params": {"e_AMPA": 0.0, "tau_r_AMPA": 0.2, "tau_d_AMPA": 3.0},
             }
         ]
-        sg = nest.Create("spike_generator", 1, {"spike_times": [220.0, 223.0, 240.0]})
+        sg = nest.Create("spike_generator", 1, {"spike_times": (t_spks + t_cal).tolist()})
         nest.Connect(
             sg,
             nestmodel,
@@ -366,25 +371,25 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
             "multimeter", 1, {"record_from": ["v_comp0"], "interval": dt}
         )
         nest.Connect(mm, nestmodel)
-        nest.Simulate(400.0)
+        nest.Simulate(t_cal + t_sim)
         res_nest = nest.GetStatus(mm, "events")[0]
 
-        idx0 = int(200.0 / dt)
+        idx0 = int(t_cal / dt)
         res_nest["times"] = res_nest["times"][idx0:] - res_nest["times"][idx0]
         res_nest["v_comp0"] = res_nest["v_comp0"][idx0:]
 
         idx1 = min(len(res_neuron["v_m"][0]), len(res_nest["v_comp0"]))
-        # assert (
-        #     np.sqrt(
-        #         np.mean(
-        #             (res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2
-        #         )
-        #     )
-        #     < 0.05
-        # )
-        # assert np.allclose(
-        #     res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=1.0
-        # )
+        assert (
+            np.sqrt(
+                np.mean(
+                    (res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2
+                )
+            )
+            < 0.05
+        )
+        assert np.allclose(
+            res_nest["v_comp0"][:idx1], res_neuron["v_m"][0][:idx1], atol=1.0
+        )
 
         if pplot:
             pl.figure()

From 135560203db4adf045f32ebae342149ff425054d Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Tue, 2 Jun 2026 15:46:12 +0200
Subject: [PATCH 10/17] fix codestyle

---
 src/neat/channels/ionchannels.py             | 68 +++++++++++++-------
 src/neat/modelreduction/compartmentfitter.py |  9 +--
 src/neat/simulations/neuron/neuronmodel.py   | 12 ++--
 src/neat/trees/compartmenttree.py            | 14 +++-
 src/neat/trees/phystree.py                   |  3 +-
 tests/test_compartmentfitter.py              |  4 +-
 tests/test_ionchannels.py                    |  8 ++-
 tests/test_nesttree.py                       | 20 +++---
 8 files changed, 81 insertions(+), 57 deletions(-)

diff --git a/src/neat/channels/ionchannels.py b/src/neat/channels/ionchannels.py
index 8a6a917..0c5c84a 100755
--- a/src/neat/channels/ionchannels.py
+++ b/src/neat/channels/ionchannels.py
@@ -183,8 +183,9 @@ def _nmodl_ccode(expr):
 def _nmodl_repl(text, repl_pairs):
     """Apply identifier substitutions using word boundaries to avoid partial matches."""
     import re
+
     for old, new in repl_pairs:
-        text = re.sub(r'\b' + re.escape(old) + r'\b', new, text)
+        text = re.sub(r"\b" + re.escape(old) + r"\b", new, text)
     return text
 
 
@@ -260,7 +261,12 @@ def _hoist_piecewise_for_nmodl(expr, temp_counter=0):
             locals_.extend(condition_locals)
             branch_specs.append((condition_expr, value_lines, value_expr, value_locals))
 
-        for branch_index, (condition, value_lines, value_expr, value_locals) in enumerate(branch_specs):
+        for branch_index, (
+            condition,
+            value_lines,
+            value_expr,
+            value_locals,
+        ) in enumerate(branch_specs):
             locals_.extend(value_locals)
             if condition == True or condition == sp.true:
                 lines.append("else {")
@@ -306,14 +312,21 @@ def _nmodl_assignment_lines(lhs, expr, temp_counter=0):
 
 
 def _nestml_ccode(expr):
-    return _nmodl_ccode(expr).replace("fabs(", "abs(").replace("fmax(", "max(").replace("fmin(", "min(")
+    return (
+        _nmodl_ccode(expr)
+        .replace("fabs(", "abs(")
+        .replace("fmax(", "max(")
+        .replace("fmin(", "min(")
+    )
 
 
 def _piecewise_to_nestml_expr(expr):
     expr = sp.sympify(expr)
 
     if isinstance(expr, sp.Piecewise):
-        if len(expr.args) == 2 and (expr.args[1][1] == True or expr.args[1][1] == sp.true):
+        if len(expr.args) == 2 and (
+            expr.args[1][1] == True or expr.args[1][1] == sp.true
+        ):
             value_if, condition = expr.args[0]
             value_else, _ = expr.args[1]
             value_if = _piecewise_to_nestml_expr(value_if)
@@ -580,7 +593,9 @@ def __init__(self, **kwargs):
         if not hasattr(self, "conc_ext"):
             self.conc_ext = {}
         if not hasattr(self.conc_ext, "values"):
-            self.conc_ext = {str(ion): self.cfg.conc_ext[str(ion)] for ion in self.conc_ext}
+            self.conc_ext = {
+                str(ion): self.cfg.conc_ext[str(ion)] for ion in self.conc_ext
+            }
 
         if not hasattr(self, "driving_force"):
             self.driving_force = self.sp_v - sp.Symbol("e")
@@ -1101,13 +1116,19 @@ def write_mod_file(self, path, g=0.0, e=None):
             reads = [self.ion + "i"]
             if self.ion in self.conc_ext:
                 reads.append(self.ion + "o")
-            file.write("    USEION %s READ %s WRITE i%s\n" % (self.ion, ", ".join(reads), self.ion))
+            file.write(
+                "    USEION %s READ %s WRITE i%s\n"
+                % (self.ion, ", ".join(reads), self.ion)
+            )
         else:
             reads = []
             if self.ion in self.conc_ext:
                 reads.append(self.ion + "o")
             if reads:
-                file.write("    USEION %s READ %s WRITE i%s\n" % (self.ion, ", ".join(reads), self.ion))
+                file.write(
+                    "    USEION %s READ %s WRITE i%s\n"
+                    % (self.ion, ", ".join(reads), self.ion)
+                )
             else:
                 file.write("    USEION %s WRITE i%s\n" % (self.ion, self.ion))
         for c in cs:
@@ -1189,7 +1210,9 @@ def write_mod_file(self, path, g=0.0, e=None):
         file.write("    %s\n" % calcstring)
         file.write("}\n\n")
 
-        conc_args = [str(c) + "i" for c in cs] + [str(ion) + "o" for ion in self.conc_ext]
+        conc_args = [str(c) + "i" for c in cs] + [
+            str(ion) + "o" for ion in self.conc_ext
+        ]
         concstring = (", " + ", ".join(conc_args)) if conc_args else ""
 
         file.write("INITIAL {\n")
@@ -1322,9 +1345,7 @@ def write_nestml_blocks(
             p_open_ = self.p_open
             for svar, sv_ in zip(self.ordered_statevars, sv_suff):
                 p_open_ = p_open_.subs(svar, sp.symbols(sv_))
-                p_open_ = p_open_.subs(
-                    self.sp_v, sp.symbols("v_comp", real=True)
-                )
+                p_open_ = p_open_.subs(self.sp_v, sp.symbols("v_comp", real=True))
 
             if is_ohmic:
                 df_str = "(e_%s - v_comp)" % cname
@@ -1374,17 +1395,13 @@ def _customsimplify(expr):
                 func_args = ", ".join(func_args)
                 #     varinf_func = varinf_func.subs(ckey, cval)
                 # print activation function to nestml file
-                varinf_func = varinf_func.subs(
-                    svar, sp.symbols(sv_suff_, real=True)
-                )
+                varinf_func = varinf_func.subs(svar, sp.symbols(sv_suff_, real=True))
                 varinf_func = varinf_func.subs(
                     self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
                 code_str = sp.pycode(varinf_func, fully_qualified_modules=False)
-                value_str = self._create_nestml_funcstr(
-                    code_str, n_spaces=4, indent=8
-                )
+                value_str = self._create_nestml_funcstr(code_str, n_spaces=4, indent=8)
 
                 func_str += (
                     f"    function {sv_}_inf_{cname} ({func_call_args}) real:\n"
@@ -1398,17 +1415,13 @@ def _customsimplify(expr):
                 for ckey, cval in self.conc.items():
                     tauinf_func = tauinf_func.subs(ckey, cval)
 
-                tauinf_func = tauinf_func.subs(
-                    svar, sp.symbols(sv_suff_, real=True)
-                )
+                tauinf_func = tauinf_func.subs(svar, sp.symbols(sv_suff_, real=True))
                 tauinf_func = tauinf_func.subs(
                     self.sp_v, sp.symbols("v_comp", real=True)
                 )
 
                 code_str = sp.pycode(tauinf_func, fully_qualified_modules=False)
-                value_str = self._create_nestml_funcstr(
-                    code_str, n_spaces=4, indent=8
-                )
+                value_str = self._create_nestml_funcstr(code_str, n_spaces=4, indent=8)
 
                 func_str += (
                     f"\n    function tau_{sv_}_{cname} ({func_call_args}) real:\n"
@@ -1449,7 +1462,9 @@ def _replaceConc(expr_str, prefix="", suffix=""):
             df_ccode = "(m_e_rev - v)"
             ddf_ccode = "-1."
         else:
-            df_expr = _drop_piecewise_guards(self._substitute_defaults(self.driving_force))
+            df_expr = _drop_piecewise_guards(
+                self._substitute_defaults(self.driving_force)
+            )
             df_ccode = sp.printing.ccode(df_expr).replace(str(self.sp_v), "v")
             df_ccode = _replaceConc(df_ccode, prefix="m_")
 
@@ -1582,7 +1597,10 @@ def _replaceConc(expr_str, prefix="", suffix=""):
             fcc.write("    }" + "\n")
             fcc.write("    double %s = %s;\n" % (str(svar), vi_ccode))
 
-        fcc.write("    return %s * (%s - m_p_open_eq);\n" % (df_ccode, sp.printing.ccode(self.p_open)))
+        fcc.write(
+            "    return %s * (%s - m_p_open_eq);\n"
+            % (df_ccode, sp.printing.ccode(self.p_open))
+        )
         fcc.write("}\n")
 
         fcc.write("double %s::DfDvNewton(double v){\n" % c_name)
diff --git a/src/neat/modelreduction/compartmentfitter.py b/src/neat/modelreduction/compartmentfitter.py
index aebaff6..eeaa0bd 100755
--- a/src/neat/modelreduction/compartmentfitter.py
+++ b/src/neat/modelreduction/compartmentfitter.py
@@ -337,8 +337,7 @@ def set_ctree(self, loc_arg, fit_name="", extend_w_bifurc=True, pprint=False):
                     e_revs.append(node.currents[c_name][1])
             # reversal potential is the same throughout the reduced model
             ctree.add_channel_current(
-                copy.deepcopy(channel), 
-                np.mean(e_revs) if None not in e_revs else None
+                copy.deepcopy(channel), np.mean(e_revs) if None not in e_revs else None
             )
 
         for node in ctree:
@@ -470,11 +469,7 @@ def _eval_channel(self, fit_arg, channel_name, pprint=False):
                 }
             )
             sv.update(
-                {
-                    str(ion): sv_h[ion][ii]
-                    for ion in channel.conc
-                    if str(ion) in sv_h
-                }
+                {str(ion): sv_h[ion][ii] for ion in channel.conc if str(ion) in sv_h}
             )
 
             # compute the fit matrices
diff --git a/src/neat/simulations/neuron/neuronmodel.py b/src/neat/simulations/neuron/neuronmodel.py
index 2d3a768..5d3a691 100755
--- a/src/neat/simulations/neuron/neuronmodel.py
+++ b/src/neat/simulations/neuron/neuronmodel.py
@@ -348,8 +348,8 @@ def _make_section(self, channel_storage, factorlambda=1.0, pprint=False):
         # insert membrane currents
         for key, current in self.currents.items():
             # check if the current has a reversal potential that needs to be set
-            uses_e_rev = (key == 'L') # True if leak, False otherwise
-            if key != 'L' and channel_storage[key]._uses_e_rev:
+            uses_e_rev = key == "L"  # True if leak, False otherwise
+            if key != "L" and channel_storage[key]._uses_e_rev:
                 uses_e_rev = True
 
             if current[0] > 1e-10:
@@ -358,7 +358,9 @@ def _make_section(self, channel_storage, factorlambda=1.0, pprint=False):
                 except ValueError as e:
                     raise ValueError(str(e) + f" {mechname[key]}")
                 for seg in compartment:
-                    exec("seg." + mechname[key] + ".g = " + str(current[0]) + "*1e-6")  # uS/cm^2 --> S/cm^2
+                    exec(
+                        "seg." + mechname[key] + ".g = " + str(current[0]) + "*1e-6"
+                    )  # uS/cm^2 --> S/cm^2
                     if uses_e_rev:
                         exec("seg." + mechname[key] + ".e = " + str(current[1]))  # mV
         # insert concentration mechanisms
@@ -1509,8 +1511,8 @@ def _make_section(self, channel_storage, pprint=False):
         # insert membrane currents
         for key, current in self.currents.items():
             # check if the current has a reversal potential that needs to be set
-            uses_e_rev = (key == 'L') # True if leak, False otherwise
-            if key != 'L' and channel_storage[key]._uses_e_rev:
+            uses_e_rev = key == "L"  # True if leak, False otherwise
+            if key != "L" and channel_storage[key]._uses_e_rev:
                 uses_e_rev = True
 
             if current[0] > 1e-10:
diff --git a/src/neat/trees/compartmenttree.py b/src/neat/trees/compartmenttree.py
index e40a659..d21afe1 100755
--- a/src/neat/trees/compartmenttree.py
+++ b/src/neat/trees/compartmenttree.py
@@ -444,10 +444,14 @@ def calc_i_tot(
             v, sv = self._construct_channel_args(channel)
 
             if channel_name not in p_open_channels:
-                i_tot = i_tot + g * channel.compute_p_open(v, **sv) * channel.f_driving_force(*channel._df_call_args(v, e, **sv))
+                i_tot = i_tot + g * channel.compute_p_open(
+                    v, **sv
+                ) * channel.f_driving_force(*channel._df_call_args(v, e, **sv))
 
             else:
-                i_tot = i_tot + g * p_open_channels[channel_name] * channel.f_driving_force(*channel._df_call_args(v, e, **sv))
+                i_tot = i_tot + g * p_open_channels[
+                    channel_name
+                ] * channel.f_driving_force(*channel._df_call_args(v, e, **sv))
 
         return i_tot
 
@@ -490,7 +494,11 @@ def calc_linear_statevar_terms(self, channel_storage, v=None, channel_names=None
 
             svar_terms[channel_name] = {}
             for svar, dp_dx_ in dp_dx.items():
-                svar_terms[channel_name][svar] = g * dp_dx_ * -channel.f_driving_force(*channel._df_call_args(v, e, **sv))
+                svar_terms[channel_name][svar] = (
+                    g
+                    * dp_dx_
+                    * -channel.f_driving_force(*channel._df_call_args(v, e, **sv))
+                )
 
         return svar_terms
 
diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index 681c9bd..549beab 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -379,7 +379,8 @@ def _get_repr_dict(self):
         repr_dict.update(
             {
                 "currents": {
-                    c: (f"({g:1.6g}, {e:1.6g})") if e is not None else (f"({g:1.6g}, )") for c, (g, e) in self.currents.items()
+                    c: (f"({g:1.6g}, {e:1.6g})") if e is not None else (f"({g:1.6g}, )")
+                    for c, (g, e) in self.currents.items()
                 },
                 "concmechs": self.concmechs,
                 "c_m": f"{self.c_m:1.6g}",
diff --git a/tests/test_compartmentfitter.py b/tests/test_compartmentfitter.py
index 74487e9..cacf9ac 100755
--- a/tests/test_compartmentfitter.py
+++ b/tests/test_compartmentfitter.py
@@ -884,9 +884,7 @@ def test_expansion_points():
     ca_default = two_var_conc_dep.conc["ca"]
     ca_args = np.full_like(v_act, ca_default, dtype=float)
     assert np.allclose(two_var_conc_dep.f_varinf["m"](v_act, ca_args), sv_hs["m"])
-    assert np.allclose(
-        two_var_conc_dep.f_varinf["h"](v_inact, ca_args), sv_hs["h"]
-    )
+    assert np.allclose(two_var_conc_dep.f_varinf["h"](v_inact, ca_args), sv_hs["h"])
     assert np.allclose(sv_hs["ca"], np.full_like(v_act, ca_default, dtype=float))
 
 
diff --git a/tests/test_ionchannels.py b/tests/test_ionchannels.py
index 4c23c85..3bb279c 100755
--- a/tests/test_ionchannels.py
+++ b/tests/test_ionchannels.py
@@ -306,7 +306,9 @@ def p_ss(v):
             return minf / (1.0 + np.exp(-v / 10.0))
 
         dv = 1e-5
-        fd = ((e - (v0 + dv)) * p_ss(v0 + dv) - (e - (v0 - dv)) * p_ss(v0 - dv)) / (2.0 * dv)
+        fd = ((e - (v0 + dv)) * p_ss(v0 + dv) - (e - (v0 - dv)) * p_ss(v0 - dv)) / (
+            2.0 * dv
+        )
         neat_val = ch.compute_lin_sum(v0, 0.0, e=e)
         assert np.allclose(neat_val, fd, rtol=1e-4)
 
@@ -419,7 +421,9 @@ def test_ghk_nestml_uses_inward_positive_sign(self):
         ch = channelcollection.GHKChan()
         text = ch.write_nestml_blocks(blocks=["equations"])["equations"]
         line = next(
-            line.strip() for line in text.splitlines() if "inline i_GHKChan real =" in line
+            line.strip()
+            for line in text.splitlines()
+            if "inline i_GHKChan real =" in line
         )
         assert "inline i_GHKChan real =" in line
         assert "* (13.182244584683609" in line
diff --git a/tests/test_nesttree.py b/tests/test_nesttree.py
index 326d0db..54bf5e3 100644
--- a/tests/test_nesttree.py
+++ b/tests/test_nesttree.py
@@ -99,7 +99,7 @@ def test_initialization(self):
         channel_installer.load_or_install_nest_test_channels()
         nest.SetKernelStatus(dict(resolution=dt))
 
-        v_eq = -65.
+        v_eq = -65.0
         self.load_ball()
         self.tree.fit_leak_current(v_eq, 10.0)
         # set computational tree
@@ -335,9 +335,9 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
 
         self.load_ghk_ball()
 
-        t_cal = 500.
-        t_sim = 200.
-        t_spks = np.array([20.0, 23.0, 40.0]) 
+        t_cal = 500.0
+        t_sim = 200.0
+        t_spks = np.array([20.0, 23.0, 40.0])
         # NEURON simulation
         csimtree_neuron = NeuronCompartmentTree(self.ctree)
         csimtree_neuron.init_model(dt=dt, t_calibrate=t_cal)
@@ -356,7 +356,9 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
                 "params": {"e_AMPA": 0.0, "tau_r_AMPA": 0.2, "tau_d_AMPA": 3.0},
             }
         ]
-        sg = nest.Create("spike_generator", 1, {"spike_times": (t_spks + t_cal).tolist()})
+        sg = nest.Create(
+            "spike_generator", 1, {"spike_times": (t_spks + t_cal).tolist()}
+        )
         nest.Connect(
             sg,
             nestmodel,
@@ -367,9 +369,7 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
                 "receptor_type": 0,
             },
         )
-        mm = nest.Create(
-            "multimeter", 1, {"record_from": ["v_comp0"], "interval": dt}
-        )
+        mm = nest.Create("multimeter", 1, {"record_from": ["v_comp0"], "interval": dt})
         nest.Connect(mm, nestmodel)
         nest.Simulate(t_cal + t_sim)
         res_nest = nest.GetStatus(mm, "events")[0]
@@ -381,9 +381,7 @@ def test_ghk_nest_neuron_comparison(self, pplot=False):
         idx1 = min(len(res_neuron["v_m"][0]), len(res_nest["v_comp0"]))
         assert (
             np.sqrt(
-                np.mean(
-                    (res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2
-                )
+                np.mean((res_nest["v_comp0"][:idx1] - res_neuron["v_m"][0][:idx1]) ** 2)
             )
             < 0.05
         )

From 0508af9244d74747bf2e01a508199ca276d9191d Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Mon, 22 Jun 2026 14:38:51 +0200
Subject: [PATCH 11/17] fix bug when node argument without nodes was provide to
 PhysTree.add_channel_current

---
 src/neat/trees/phystree.py   |   3 +
 tutorials/models.ipynb       | 209 ++++++++++++++++++++---------------
 tutorials/morphologies.ipynb |  48 ++++++--
 3 files changed, 159 insertions(+), 101 deletions(-)

diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index 549beab..34f85ad 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -634,6 +634,9 @@ def add_channel_current(self, channel, g_max_distr, e_rev_distr, node_arg=None):
         nodes_with_channel = self.convert_node_arg_to_nodes(node_arg)
         if len(nodes_with_channel) > 0:
             self.channel_storage[channel_name] = channel
+        else:
+            warnings.warn("This node argument does not return any nodes in this tree, no channel was added.")
+            return None
 
         channel = self.channel_storage[channel_name]
         # add the ion channel to the nodes
diff --git a/tutorials/models.ipynb b/tutorials/models.ipynb
index 25f2d0e..a6ee975 100755
--- a/tutorials/models.ipynb
+++ b/tutorials/models.ipynb
@@ -10,31 +10,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 52,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\n",
-      "              -- N E S T --\n",
-      "  Copyright (C) 2004 The NEST Initiative\n",
-      "\n",
-      " Version: 3.8.0-post0.dev0\n",
-      " Built: Apr 15 2025 08:54:20\n",
-      "\n",
-      " This program is provided AS IS and comes with\n",
-      " NO WARRANTY. See the file LICENSE for details.\n",
-      "\n",
-      " Problems or suggestions?\n",
-      "   Visit https://www.nest-simulator.org\n",
-      "\n",
-      " Type 'nest.help()' to find out more about NEST.\n",
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from neat import PhysTree\n",
     "ph_tree = PhysTree('morph/L23PyrBranco.swc')"
@@ -56,7 +34,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 53,
    "metadata": {},
    "outputs": [
     {
@@ -98,7 +76,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 54,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -121,7 +99,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 55,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -146,7 +124,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 56,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -172,7 +150,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 57,
    "metadata": {},
    "outputs": [
     {
@@ -190,7 +168,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 58,
    "metadata": {},
    "outputs": [
     {
@@ -215,14 +193,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 59,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'Na_Ta': [1710000.0, 50.0], 'Kv3_1': [450000.0, -85.0], 'L': [31.5408107318479, -48.638804987272735]}\n"
+      "{'Na_Ta': [1710000.0, 50.0], 'Kv3_1': [450000.0, -85.0], 'L': [np.float64(31.5408107318479), np.float64(-48.638804987272735)]}\n"
      ]
     }
    ],
@@ -233,14 +211,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 60,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'Kv3_1': [45000.0, -85.0], 'L': [123.19344287327353, -69.41475491536458]}\n"
+      "{'Kv3_1': [45000.0, -85.0], 'L': [np.float64(123.19344287327353), np.float64(-69.41475491536458)]}\n"
      ]
     }
    ],
@@ -265,7 +243,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 61,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -281,7 +259,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 62,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -300,7 +278,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 63,
    "metadata": {},
    "outputs": [
     {
@@ -318,7 +296,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 64,
    "metadata": {},
    "outputs": [
     {
@@ -343,14 +321,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 65,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'Na_Ta': [1710000.0, 50.0], 'Kv3_1': [450000.0, -85.0], 'L': [31.5408107318479, -48.638804987272735]}\n"
+      "{'Na_Ta': [1710000.0, 50.0], 'Kv3_1': [450000.0, -85.0], 'L': [np.float64(31.5408107318479), np.float64(-48.638804987272735)]}\n"
      ]
     }
    ],
@@ -361,14 +339,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 66,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'L': [128.00000000000003, -70.0]}\n"
+      "{'L': [np.float64(128.00000000000003), np.float64(-70.0)]}\n"
      ]
     }
    ],
@@ -400,7 +378,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 67,
    "metadata": {},
    "outputs": [
     {
@@ -429,7 +407,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 68,
    "metadata": {},
    "outputs": [
     {
@@ -473,9 +451,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 69,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading NEURON model 'TutorialChannels'\n",
+      "Found path: /Users/wybo/Code/NEAT_public/src/neat/simulations/neuron/tmp/TutorialChannels, loading mechanisms...\n",
+      "... already loaded.\n"
+     ]
+    }
+   ],
    "source": [
     "from neat import load_neuron_model\n",
     "load_neuron_model('TutorialChannels')"
@@ -499,7 +487,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 70,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -520,7 +508,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 71,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -537,7 +525,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 72,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -553,7 +541,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 22,
+   "execution_count": 73,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -574,7 +562,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 23,
+   "execution_count": 74,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -590,12 +578,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 24,
+   "execution_count": 75,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -672,7 +660,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 25,
+   "execution_count": 76,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -689,7 +677,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 26,
+   "execution_count": 77,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -712,12 +700,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 27,
+   "execution_count": 78,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -740,17 +728,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "We can also obtain this kernel in the time domain with the `FourierQuadrature` object:"
+    "We can also obtain this kernel in the time domain using the `GreensTreeTime` object:"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 28,
+   "execution_count": 79,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -761,7 +749,10 @@
    ],
    "source": [
     "# time domain kernel\n",
-    "tt, zt = ft.ft_inv(z_trans)\n",
+    "from neat import GreensTreeTime\n",
+    "gtt = GreensTreeTime(ph_tree)\n",
+    "gtt.set_impedance(t_arr)\n",
+    "zt = gtt.calc_zt((1,.5), (115,.8), compute_time_derivative=False)\n",
     "\n",
     "# comparison with NEURON simulation\n",
     "sim_tree.init_model(t_calibrate=300.)\n",
@@ -770,10 +761,10 @@
     "res = sim_tree.run(50.)\n",
     "sim_tree.delete_model()\n",
     "res['v_m'] -= res['v_m'][:,-1]\n",
-    "res['v_m'] /= (i_amp*1e-3*i_dur)\n",
+    "res['v_m'] /= (i_amp*i_dur)\n",
     "\n",
     "# plot the kernel\n",
-    "pl.plot(tt, zt.real, 'b', label='computed')\n",
+    "pl.plot(t_arr, zt, 'b', label='computed')\n",
     "pl.plot(res['t'], res['v_m'][0], 'r--', label='simulated')\n",
     "pl.legend(loc=0)\n",
     "pl.show()"
@@ -790,7 +781,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 80,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -807,7 +798,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 81,
    "metadata": {},
    "outputs": [
     {
@@ -834,7 +825,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 82,
    "metadata": {},
    "outputs": [
     {
@@ -862,7 +853,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 83,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -880,12 +871,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 84,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 400x300 with 3 Axes>"
       ]
@@ -893,9 +891,16 @@
      "metadata": {},
      "output_type": "display_data"
     },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -919,7 +924,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 85,
    "metadata": {},
    "outputs": [
     {
@@ -927,8 +932,8 @@
      "output_type": "stream",
      "text": [
       ">>> CompartmentTree\n",
-      "    CompartmentNode 0, Parent: None --- loc_idx = 0, g_c = 0.0 uS, ca = 9.914229970918551e-05 uF, e_eq = -70.0000000000006 mV, (g_L = 0.009188301476232499 uS, e_L = -68.82253558506142 mV), (g_Na_Ta = 14.378466892350664 uS, e_Na_Ta = 50.0 mV), (g_Kv3_1 = 7.000477231569277 uS, e_Kv3_1 = -85.0 mV)\n",
-      "    CompartmentNode 1, Parent: 0 --- loc_idx = 1, g_c = 0.009224434868094789 uS, ca = 4.2683265272914205e-06 uF, e_eq = -70.0000000000006 mV, (g_L = 0.00041103448332490333 uS, e_L = -69.71819327183215 mV), (g_Na_Ta = 2.580260653895025e-13 uS, e_Na_Ta = 50.0 mV), (g_Kv3_1 = 0.07229641499492892 uS, e_Kv3_1 = -85.0 mV)\n"
+      "    CompartmentNode 0, Parent: None --- loc_idx = 0, g_c = 0.0 uS, ca = 9.914229970918552e-05 uF, e_eq = -70.0000000000006 mV, (g_L = 0.0091883014762325 uS, e_L = -68.82253558506142 mV), (g_Na_Ta = 14.378466892351303 uS, e_Na_Ta = 50.0 mV), (g_Kv3_1 = 7.000477231569277 uS, e_Kv3_1 = -85.0 mV)\n",
+      "    CompartmentNode 1, Parent: 0 --- loc_idx = 1, g_c = 0.009224434868094789 uS, ca = 4.268326527291403e-06 uF, e_eq = -70.0000000000006 mV, (g_L = 0.0004110344833249026 uS, e_L = -69.71819327183258 mV), (g_Na_Ta = 6.712302472717763e-12 uS, e_Na_Ta = 50.0 mV), (g_Kv3_1 = 0.07229641499493164 uS, e_Kv3_1 = -85.0 mV)\n"
      ]
     }
    ],
@@ -945,7 +950,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 86,
    "metadata": {},
    "outputs": [
     {
@@ -973,7 +978,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 87,
    "metadata": {},
    "outputs": [
     {
@@ -1000,7 +1005,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 88,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -1017,7 +1022,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 89,
    "metadata": {},
    "outputs": [
     {
@@ -1066,7 +1071,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 90,
    "metadata": {},
    "outputs": [
     {
@@ -1074,10 +1079,23 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "Jun 16 21:59:47 SimulationManager::set_status [Info]: \n",
-      "    Temporal resolution changed from 0.1 to 0.1 ms.\n",
+      "Jun 16 10:12:50 SimulationManager::set_status [Info]: \n",
+      "    Temporal resolution changed from 0.1 to 0.1 ms.\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Cannot load crlibm extension. The imath functions will not be available.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
       "\n",
-      "Jun 16 21:59:49 Install [Info]: \n",
+      "Jun 16 10:12:52 Install [Info]: \n",
       "    loaded module TutorialChannels_module\n"
      ]
     }
@@ -1101,9 +1119,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 91,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0 {'g_L': np.float64(0.0091883014762325), 'e_L': np.float64(-68.82253558506142), 'C_m': np.float64(0.09914229970918552), 'g_C': 0.0, 'gbar_Na_Ta': np.float64(14.378466892351303), 'gbar_Kv3_1': np.float64(7.000477231569277), 'e_Na_Ta': np.float64(50.0), 'e_Kv3_1': np.float64(-85.0), 'v_comp': np.float64(-70.0000000000006), 'h_Na_Ta': array(0.66075637), 'm_Na_Ta': array(0.00703632), 'm_Kv3_1': array(0.00010681)}\n",
+      "1 {'g_L': np.float64(0.0004110344833249026), 'e_L': np.float64(-69.71819327183258), 'C_m': np.float64(0.004268326527291403), 'g_C': np.float64(0.009224434868094789), 'gbar_Na_Ta': np.float64(6.712302472717763e-12), 'gbar_Kv3_1': np.float64(0.07229641499493164), 'e_Na_Ta': np.float64(50.0), 'e_Kv3_1': np.float64(-85.0), 'v_comp': np.float64(-70.0000000000006), 'h_Na_Ta': array(0.66075637), 'm_Na_Ta': array(0.00703632), 'm_Kv3_1': array(0.00010681)}\n"
+     ]
+    }
+   ],
    "source": [
     "from neat import NestCompartmentTree\n",
     "c_tree_nest = NestCompartmentTree(c_tree)\n",
@@ -1119,7 +1146,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 41,
+   "execution_count": 92,
    "metadata": {},
    "outputs": [
     {
@@ -1127,16 +1154,16 @@
      "output_type": "stream",
      "text": [
       "\n",
-      "Jun 16 21:59:50 NodeManager::prepare_nodes [Info]: \n",
+      "Jun 16 10:12:52 NodeManager::prepare_nodes [Info]: \n",
       "    Preparing 4 nodes for simulation.\n",
       "\n",
-      "Jun 16 21:59:50 SimulationManager::start_updating_ [Info]: \n",
+      "Jun 16 10:12:52 SimulationManager::start_updating_ [Info]: \n",
       "    Number of local nodes: 4\n",
       "    Simulation time (ms): 60\n",
       "    Number of OpenMP threads: 1\n",
       "    Number of MPI processes: 1\n",
       "\n",
-      "Jun 16 21:59:50 SimulationManager::run [Info]: \n",
+      "Jun 16 10:12:52 SimulationManager::run [Info]: \n",
       "    Simulation finished.\n"
      ]
     }
@@ -1208,12 +1235,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 93,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAGdCAYAAAA8F1jjAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAkrhJREFUeJztnQd4U3UbxU+6d6GLvcrelL23DBXFvUARFFEURRw4UVFx4SdOcIEDARERFFmy995lz0JLoXTvle85/9ubJqWUAm2TNO/vedJm3CQ3N+Oe+47zGoxGoxGCIAiCIAg2iJO1V0AQBEEQBOFKiFARBEEQBMFmEaEiCIIgCILNIkJFEARBEASbRYSKIAiCIAg2iwgVQRAEQRBsFhEqgiAIgiDYLCJUBEEQBEGwWVxg5+Tm5iIyMhK+vr4wGAzWXh1BEARBEIoB/WaTkpJQtWpVODk5lV+hQpFSo0YNa6+GIAiCIAjXQUREBKpXr15+hQojKfoL9fPzs/bqCIIgCIJQDBITE1WgQd+Pl1uhoqd7KFJEqAiCIAiCfXG1sg0pphUEQRAEwWYRoSIIgiAIgs0iQkUQBEEQBJvF7mtUBEEQhBtvE83OzkZOTo5sSqHEcHZ2houLyw1bh4hQEQRBcGAyMzMRFRWF1NRUa6+KUA7x8vJClSpV4Obmdt2PIUJFEATBQaFh5smTJ9WRL023uDMR40yhpKJ0FMEXL15Un7H69esXaepWFCJUBEEQHBTuSChW6GXBI19BKEk8PT3h6uqK06dPq8+ah4fHdT2OFNMKgiA4ONd7pCsIZfHZkk+nIAiCIAg2iwgVQRAEQRBsFhEqgiAIgl0Wa44cORIBAQGqAHj37t1XvQ+X++uvv9T5U6dOFft+gnWRYlpBEATB7liyZAlmzJiB1atXIzQ0FEFBQdZeJaGUEKEiCEK5mcR65swZ1cHi7+9v7dURSpnjx48rf47OnTvLti7nSOpHEAS7JysrSx1Zh4eHY9WqVUhLS7P2Ktm1Q601Tnzu4jJs2DA888wzSpgyfVO7dm11+uyzzyyWa9WqFd56661S2FJCWSIRFUEQ7J5z584hPT1dnadfw5EjR9CyZUtrr5bdQQv9P//80yrPfeeddyq79eIwZcoU1K1bF99++y22bdumDOvatWtX6usoWAeJqAiCYPdER0er/35+fuo/nTBpZCaUT5ja8/X1VQKlcuXKCA4OtvYqCaWIRFQEQbB7Ll26pP4zirJlyxYVVYmJiUFISIi1V82u4I6fkQ1rPbcgFIYIFUEQ7D5dkZKSos5XqFBBzaxh6+nZs2dFqFwjrPcobvrFFh1QC9a5sHZJsH8k9SMIgl2TnJysdlDcwXKWCIUKuXDhgrVXTShDmP7hFGjzLjCmAAX7xz6lsyAIQh5JSUnq/4YNDfHBBwYcO1YNTk63onHjCwgNTUODBp6yrRyA3r17K1+VQYMGqcjam2++KemkcoIIFUEQ7JrU1FT1/++/a+HoUZ4zAPDC+vW1MXJkKlavtvYaCmXBK6+8oiIot956qyq2nThxokRUygkG47U0r9sgDO/xQ5mQkGCq+BcEwXHYs2cPDhw4gocfvhs5ORQp+VSqlIGoKHcYLK8W8mBLN3fuderUUWkzQSjLz1hx999SoyIIgt3/EJ45428SKV27UqDkqPPR0e44dMjKKygIwg0hQkUQBLsXKkePBqrzdesC69Zx4Fw2KlXSalf++ivbymsoCMKNIEJFEAS7hnb5ERHabJ+2bbXrPDzc0bGj5q3y999adEUQBPtEhIogCHYfUYmK8lXnGzTIv75Hjwz1f8cOV+S56wuCYIeIUBEEwW5hLwBdaHWhUr9+/m29ernBYMhFZqYTtm613joKgnBjSHuyIAh2C51Hk5PdcNNNx1CjRjN06JB/7FWpUkWEhsYhLc0NTz7pgw0bDKhQwaqrKwjCdSARFUEQ7BZGU3burILZs1vgk0+c0LcvsHmzdtvcuX44fjwQkZG+CA83iJ+KINgpIlQEQbBroXL+vI86T0eoiAggIEC7rW9fy5+3FSussYaCINwoIlQEQbALcnNzsWvXLqxZswZxcXEmoaJ3/BAO4K1TRzvfuDHnv2hD6Xx9s9VtglCQnj174rnnnrOJgZB//fWXtVfDJhGhIgiCXXD8+HEcPXoU0dHR2Lhxo5qaTKGSnq4pkEaNgDvvBFxdteXpRvvRR4no2PEMnJ1zUK+edddfEITrQ4SKIAh2wenTp03nU1JSEBERoYRKZqbWE/DQQ8Dvv1ve5777vODiYkR8vDs2bcot61UWygh+DoTyiwgVQRBsnuzsbFO6p0KF+tiwoQa2b49SO6joaK1GpbCIiaenJ5o0SVTnN28WoVKe0jVPP/20StkEBQWhf//+6vr9+/dj4MCB8PHxQaVKlTB06FDExMRYCNyHH35Y3V6lShVMnjy5WCkYTmPmZGads2fP4oEHHkBAQAC8vb3Rtm1bbNmyxXT7ggUL0Lp1azXbJjQ0FG+//bb6DOswMti9e3d1e5MmTbB8+fLrEu6DBg1CxYoV1To0bdoU//77r+l2pkjbt28Pd3d39VrHjx9vsQ7chs8884zahnwMbq/vvvtObaNHH30Uvr6+qFevHhYvXmy6D6OYI0aMUHN7+N1q2LAhpkyZgtJG2pMFQbB54uPj8zxTfPDooy0RGemEH37IxNSphxAX56mWuVJqp23bXHz7LXDihAtiY/OLbYUiOHu26M0THAy4u2vnMzKAixeLXr569fzzSUlAQsKVby8mP/30E5588kls2LDB9Bnp3bs3HnvsMfzvf/9TjsUvv/wy7r33XqxcuVIt8+KLL6odOIVESEgIXn31VezcuROtWrUq9vMmJyejR48eqFatGhYuXIjKlSurx2ANFVm3bp0SQ59//jm6deumUpYjR45Ut02YMEEtd+eddyphQHHDgXzXUyMzevRoJdTXrl2rhEp4eLgSYOTcuXO4+eabMWzYMPz88884dOgQHn/8cSWM3nrrLYtt+NJLL2Hr1q2YM2eO2p7z58/HHXfcobYNtyPF3pkzZ+Dl5aXWvXr16pg7dy4CAwNVCpavjUKI27nUMNo5CQkJnP6s/guCUD45duyYcc6cOcZHHjll1Pp7tFNgYIrpfGxs4ffdvTvc6OqarZZZvLis19y2SUtLM4aHh6v/Fphv5MJOGzfmL8vzV1venMmTi769GPTo0cMYFhZmcd3EiRON/fr1s7guIiJC7R8OHz5sTEpKMrq5uRl///130+2XLl0yenp6Gp999lmzlw7j/PnzLR7H39/fOH36dHV+2rRpRl9fX3XfwujTp4/x/ffft7jul19+MVapUkWdX7p0qdHFxcV47tw50+2LFy8u9HmLonnz5sa33nqr0NteffVVY8OGDY25ubmm67766iujj4+PMScnx7QNu3btaro9Ozvb6O3tbRw6dKjpuqioKLVemzZtuuJ6jB492njXXXdd+2fsGvbfElERBMHmYTiarFxZSf0PCMhChw4nERiYhl9/bYkKFXJQsWLhbT2VKwegVq04HDsWhK+/BkJDLa32BfukTZs2Fpf37NmDVatWmaIK5jCqwQgLIxAdOnQwXc/UDdMX18Lu3bsRFham7lsYXA9Ged577z2LlAlHPaSmpuLgwYOoUaMGqlatarq9U6dOuFbGjBmjIiDLli1D3759cdddd6FFixbqNj4HH5NpLJ0uXbqoaBDTVjVr1lTX6csTZ2dnFSVp3ry56TpGfciFCxdM13311Vf48ccfVZRF36bXEpG6HkSoCIJgF0IlOtobEREe6nJamgseeGAf3n+/m7rs6WnEnDksnr38vhERATh1SivH+/tvzgACxo0r2/W3O2hIc7XUj07r1ldf3pzHHwdKIE3AdIc53AmzZuPDDz+8bFmmJo4dO1asx+XOXQusWDog67A2oyi4HqxJYXqnIEy9lBSPPfaYqs1ZtGiREiuTJk1SNTesOykurnqLnNlrN79OFzp6Wmv27Nl44YUX1PNQCLGO5eOPP7aozykNRKgIgmAXQuXAgfydY1qaAdu318DZs5qHSlSUC5h6L0yoNGrkipyc/B3Pxo0iVK7KtdSMsFblWpb39dVOJQyLV+fNm4fatWvDxeXyXVvdunXVTpg7VT2iwALtI0eOqJoTneDgYERFRVkUvjISosMoxPfff4/Y2NhCoypcj8OHD6tC1MJo3Lix6ljjc1BAkc26nfI1UqNGDYwaNUqdXnnlFVUMS6HC5+C2oODSxQajPBQWrDG5XvgYnTt3xlNPPWURrSptpOtHEASbhzuKvXsrW1y3ZUtdpKS4mS6HhRV+X2YCQkPzdzSbNmmFEUL5gsWlFA/sxtm2bZvagS5dulR1sDD1wpQQO1ZYUMviWnYIsdjUyclyN8iC3C+//FKZC27fvl2JAPMoAx+fBbSDBw9WO+4TJ04oUbCJHywAb775pipgZVTlwIEDKg3DSMTrr7+ubmeapkGDBnjkkUdUmojFt6+99to1v97nnntOvb6TJ0+qYl6mvShQCIUExRBFCwtpWTzMQt7nn3/+std7LdSvX19tEz4vBd4bb7yhtnVpI0JFEASbhkeFGRkZGD58FyZPzsRddwG1awNDhyajVq14ZeZWlFAh996bgkGDDuG99w5i507NDE4oX7Dmg8KBoqRfv36q1oI7c7YW6ztnpinYicMUEQVD165dL6t1YVqDkQou9+CDD6pUBztedNzc3FSqhV1D7Kzh83zwwQeqxoMwHfPPP/+oZdq1a4eOHTuq7platWqp27ku7KxhfQfbh5nCMa9nMW8fppC6EnydFGcUJwMGDFDi52sWYQGqI4mtyuzmadmypRJbFGm6WLpennjiCZXSuu+++1Stz6VLlyyiK6WFgRW1sGMSExPh7++vWrz8/PysvTqCIJQwFCk8IiR33323aacTGRmF9evXISvLCfXr345q1VxRrVrhj0EvDR5Fs0aAOynzIkNHhgWePCKnL0ZJ1k8INw6FDaMyw4oQK/b+GSvu/tuprH5oWBXMHwdWTJuzd+9epVz5AqhiP/roo7JYJUEQ7AT+fuhHsuZh60qVQlQ4PyTEH+3auVxRpBAeVaemumHjxor45htxMRVsG6aMuAOnH4tQRsW0NJRhWI75uIJqiiE6huCmTp2Kffv2Yfjw4epHRTfIEQTBseER2aVLnti+vT7olH7PPVrqhqF2hrzJ1SIkLK48c6YmPvyQbqG54M9LIfWWgmAT0GWWB/FCGUVUaL/LXN0nn3xy2W0zZ85UPdjsyeYbc//996ve8E8//bS0V0sQBDuKqJw6VQE//thICQxzTcIIS3GLA9u31+6Ynu6EAwdKa20FQbArocIpp7Tt/eWXXyyKkXRYJc15Bwzp6rAQia1d+lwPQRAcG0ZULl7UPDPy6hGvi/r1/RAUpBnHrVunObkLguDAQoU1uiwCYrUxBzYVxvnz503Odzr6Zd52paMrpozMT4IglF8YdV21qo46T4PaWbOu93EC4eSk9Q6MGWPE9OkluZaCINiMUOEERuaDizqxb/uLL75AUlKSMqEpSei+xyIj/cQCXEEQyi90Bb1wQYuo0FuqkE7OYlGpkh8uXNDs1Y1GA0rZTFMQhBLimsvJxo0bd9V2KY61ZisgUzscMW0OoysPPfSQmtpI0xymh8zRL/O2wqDwoWmNDiMqIlYEoXwLlfT0/J+q603/BAQ4ISQkDRcuaBbo12kGKgiCrQsV2gvzdDU44vrdd981XY6MjFT1JxwlrQ+F4qwAOvLxh0h3/lu+fLkaElWxYsVCH5fCp6D4EQSh/JKUlD9nheS5n18XrVunYckSejkYwIYhukiJpYog2Dal1qCnz1LQ0Sdact6CPmuArn80tKFj3ssvv6wsjadMmaJc/ARBEEh2djZyc7Us9b//Fu1AezU++ywRd92VBT8/Jzz8cLCIFEGwA6xqoc8aE7Yu07WONsZMK3FOgnioCIKgk5iYi7CwSDRsmKUG9V4hK1wsqlQJwJtvrsG4cWvRrp02EVZwbGhVT6t9a8P6zr/++uuGHmPGjBnKh6y0Wb16tVrf+Ph4lAVlZnnEiZaFufVzEiWHMgmCIBSGl1cqxo9fr4bFBQUF3dBG4vRYmr8xSsP6trL4URcE4caQoYSCINg0rGEj5hNsrxceBQYEBKjznLRr35POBPMWdqH8IkJFEASbhVFYfSdUEkKFVKhQEVOmdESnTtWxfHmJPKRghXTN008/rVI2jLKxUYOwznHgwIGqJpKeXEOHDlUDKXVSUlLU/BzeXqVKFTUpuTgpGEbemFbROXv2LB544AEler29vVU36xazfncO0WzdmuMaPFQXLGsxGcXTOXr0qDI75e1NmjRRTSTXw4wZM1Q9KA1V77jjDjXNuCBXWxe+3u+//17dn49Tv359LFy40OIxOImZ05k9PT3Rq1cvnDp1CmWJCBVBEGyKCxcuKHdqmjtylP2XX7bFhAk9MXNmvoP1jeDnF6gs+S9ccMO4cfwhL5GHLVecPVv0KW9OpILnr7a8OXQELur24kKLC7qab9iwQc2KY70E04NhYWHYvn07lixZouwu7r33XtN9XnzxRaxZs0btvFkfyVqLnTt3XtPzJicno0ePHjh37pzaoXOGHefZ5eZqNU8sZaAYevbZZxEeHo5p06YpQfFengEQl7vzzjvVulPccN3ZTHKtbNmyRTWiULBx2C8FhHmnbXHWRYfihduJ84VuvvlmZSHCiCOJiIhQ68up43yexx57TPmplSlGOychIYHBW/VfEAT7Jjo62jhnzhx1+u+//4wpKSlGF5dso9ZIbDQOGnTjz3HoUKrp8XgaPdrosKSlpRnDw8PVf3PMt09hp40b85fl+astb87kyUXfXhx69OhhDAsLs7hu4sSJxn79+llcFxERofYPhw8fNiYlJRnd3NyMv//+u+n2S5cuGT09PY3PPvus2WuHcf78+RaP4+/vb5w+fbo6P23aNKOvr6+6b2H06dPH+P7771tc98svvxirVKmizi9dutTo4uJiPHfunOn2xYsXF/q8RfHAAw8Yb775Zovr7rvvPrWuxV0X/fW+/vrrpsvJycnqOq4TeeWVV4xNmjSxeIyXX35ZLRMXF3fdn7Fr2X/L/FBBEGyGY8eOmc4zjH3kyElkZzcxXefvf+PPUb++B7y8spCaqqWSxPjNPmGnqDmMbKxatcpkhWHO8ePHkZaWptKIuo8XYeqGvl3XAqMKjNrotU4F4XowymMetWBkkDOrUlNTcfDgQWVSWrVqVdPt9BS7Vg4ePKjSNebwcRhJKu666DP42NSiw1SWnx9dnC+Ynsd8m13v+t4IIlQEQbAJeHB38eJFdZ71BQzbv/02f6LyxyXfyFBCHScnAxo1SsHOnVrHD2t1GbUv5hBmhyAioujbzT0/2TJ+teXNefxxwCwbc91wh1owJcP0xIcffnjZsqxHMRfBRcGajYIdqnpBN2GdRlFwPZhKYbqkIKwTKUuSi7kuBeu/uA30VJYtIEJFEASbgD+qrEtxcnJSR6w8Mvzrr/yj3SFDgC5dSua5xo6Nw/DhPsjKcsFbb4lIKUieJ2exoFH4tSzv66udShoWjM6bN09ZYbAFvSA0G+UOmbUduiFpXFwcjhw5ompOdOi8HhUVZVH4yuiDDqMPLD5lDUdhURWuB2us6tWrV+h6Nm7cWNV98DkooMjm6wjrNW7c2KKAt7DHudq6FPd5ChbXXs/63ghyDCEIgk2gm0exw4KhZw8Py8nqv/wCDBxYMs/Vt68n6tfXigW3bSuZxxSsy+jRo5V4YDfOtm3bVLpn6dKlePTRR1W6gykhFp+yoJaz6NghxLl1FMbmsCD3yy+/xK5du1RR7qhRoywiDnx8zqIbPHiwSqucOHFCCSTOtiM0Lf35559VJOPAgQMqdTJ79my8/vrr6va+ffuqDppHHnlEpWZY8MpRMtfKmDFjlJj/5JNPlJjiOpunfYqzLsWBr5+Pz+1G0fPbb79ZdECVBSJUBEGwmYgK0WsMAgKqoH17LafwyCPXkFsoBjwSrltXEyqbN9tOiFu4fljzQeFAUdKvXz80b95ctS9T+Opi5OOPP0a3bt1UioiCoWvXrpfVurBlmTUkXI5jXl544QVTLQdhtw47hkJCQlSHDJ/ngw8+gLOzs7qdrdL//POPWqZdu3bo2LGjGgtTKy9vyXWZP3++qplp37696qIp2IWjt2AXNQC4Y8eO+O6779TYmZYtW6rnKyhArrYuxYHRJwoxtmzzedil9P7776MsMeRV/dotdJekFX9CQoI6ChMEwT7h0SuPTg8e7ILIyGqYNcuIpCQDnJxy8cILp/Dhh6El+nxff70Op04Z8OCD9dGqlWX0xlFgUSVHmNSpU6fM6yeEoqGYYCRkWBFixd4/Y8Xdf0uNiiAINgHNuMiCBYHYtQumIlp39xzGW0r8+dq0cUNQ0Gm4unJSu2MKFcE2YZqGO3B6oAiS+hEEwUZgwWJurgEHDribrqtfPxHPPbcJDz+shdVLEr0Q8tixJLBWMDy8xJ9CEK6Lpk2bKvO1gvUzjopsBUEQbCZEHBvricxMLZIyfDjbQn3RsWP9a/a6KN7zBeGpp27B4MEdcfvtwMyZJf4UgiCUAJL6EQTB6rAAkl4VFy5ojm6sS5w2DXBxoWjRWjhLmoYN/ZCQkH+5QKenIAg2gkRUBEGwOvRPITExWsdPjRoUKaX7nG5uzqhRI98fg23KNuRxJQhCHiJUBEGwGaESG6tV/teuXTbPe/PNiabz331HR86yeV5BEIqPCBVBEGxGqFy65FOmQuWFF7IQHKx1FNFvToSKINgeIlQEQbAZodKsWQruvrvkrPKLZ/wWp85v3WrXllKCUG4RoSIIgs0Ila1bg3HyJLB2LfDNN6X/vL6+vqhfX7PuF4daQbBNRKgIgmB1srOz1f/Tp72wY4c21+enn0r/eTkltnVr7bkPHXJCnuecIAg2hAgVQRBsQqhwmMfFi26m665lIu+N0KGDK/z909G+fSJiYuivUjbPK9guHLrHGUGCbSBCRRAEmxAqFy96K7Hi7g5wWG1ZCRVf34ro3fsE0tOz0aIF8MUXZfO8giAUDxEqgiDYhFBJTXVBRoYTWK5y6RIwaVLZPHelShWxYEEj7NoViMREMX6zBzhZeMyYMXjppZdUQXTlypXx1ltvWSwTHx+vJhMHBwergXe9e/fGnj17TLfzfK9evVSdEm/nFGUOxly9ejUeffRRNSiPqUGeCj72lcjMzMTTTz+NKlWqqAF8HCw4yeyDfObMGdx+++1qQjif895770V0dLTpdj5Pq1at8OOPP6qpxVzuqaeeUoaIH330kXqdnNpccNryp59+qqY4e3t7q8nPvI8+jbw8IEJFEASrwx/ixERtsqqnJ6Mc2v+yICjIE7VqJZkub95cNs9r07RunX96553Cl5k1y3K5I0cKX+622/KXefzxElvFn376Se2Yt2zZonbi77zzDpYvX266/Z577sGFCxewePFi7NixA61bt0afPn0QGxurbn/ooYdQvXp1bNu2Td0+fvx4uLq6onPnzvjss8+UkIiKilKnF154oVjr9Pnnn2PhwoX4/fffcfjwYcycORO183rtc3NzlUjh869Zs0atK6eF33fffRaPcfz4cbXOS5YswaxZs/DDDz/glltuwdmzZ9X9PvzwQ7z++uvqdetwJhCfm8MMuV1WrlypRFy5wWjnJCQksKdQ/RcEwT5Zu3at8emnNxn5i1SrVtk//4AB541OTjlGd/cc4zPPGI2ZmUaHIC0tzRgeHq7+W8A3Qj+NGFH4nadMsVxuz57Cl6tbN3+ZHj1KZL179Ohh7Nq1q8V17dq1M7788svq/Lp164x+fn7G9PT0AqtS1zht2jR13tfX1zhjxoxCH3/69OlGf3//a16vZ555xti7d29jbm7uZbctW7bM6OzsbDxz5ozpugMHDqj919atW9XlCRMmGL28vIyJiYmmZfr372+sXbu2MScnx3Rdw4YNjZMmTbriesydO9cYGBhotOnP2DXsvyWiIgiCTaR+9IhKcHDZP/+rr8bBYDCq1NMtt2g1MoJt04IFRWYw3cIIip7WYeojMDBQpU/008mTJ1XEgjz//PMqNdS3b1988MEHputvhGHDhmH37t1qiCZTU8uWLTPddvDgQZWW4UmnSZMmqmiXt+kwAsN0lE6lSpXUcuaTlHmd/lrJf//9p6JF1apVU/cdOnQoLl26pCaSlwdEqAiCYBNCJSHBXZ0PCSn752/QoCJq1443zfxxeMLCYDrVrFn45qCiNF/OQxOal9GkSf4y9euX2KZlmsYc1pIwvUIoUihcKBrMT0zHvPjii6Z6EKZKmFZhqoRiYP78+Te0TkwvUQxNnDgRaWlpqgblbjoY3uDrci3itZ46dQq33nqrEm7z5s1TaayvvvrKVDNTHpDpyYIg2IRQiYryMU1OZhlBQEDZPX/FihVRr95pHD8eiM2bc7gWcGh27rz6Mg88oJ2uxsKFKGsoGM6fPw8XFxdTjUhhNGjQQJ3Gjh2LBx54ANOnT8cdd9wBNzc3VTd1PbC2hXUnPFGkDBgwQNWlNG7cGBEREeqkR1XCw8NV0S9F0vWyY8cOJVomT55sirqwRqY8IREVQRBsQqgcPhykzv/9N9CyZdk+P3dMTZumqfNbt2oFFYL9wnROp06dMHjwYJV+YdRh48aNeO2111RnD6Md7M5hh8/p06exYcMGVVRLMUEobhiVWbFiBWJiYoqdQmH3DQtgDx06hCNHjmDu3LmqU4fpHa4TO3NYxLtz505s3boVDz/8MHr06IG2bdte92utV68esrKy8MUXX6ji3F9++QVTp05FeUKEiiAIVodHrx4emkMsCdI0S5nSvr32/+JFZ5w9W/bPL5QcTI38+++/6N69u2o1ZtTk/vvvV6KE9R3Ozs6qhoNCgbcxRTNw4EC8/fbb6v7s/Bk1apSKirC9mV1FerqoqAgN60O4LIVHu3btlEDiejDSwXVasGCBit5xvShcQkNDMWfOnBt6rS1btlQCid1AzZo1U51G5i3R5QEDK2phxyQmJsLf31/1vDPkJgiC/fHHH3/giSduRmysl7rcty9g1mlaJhw+fBwtW9ZERoYr+vUDnnwSGDwY5Zr09HRVU1GnTh3l+yEUzSOPPKIEB51rhRv/jBV3/y01KoIgWD2awhz7iBE7Ubt2R8THu8CsMaLMcHIKUiKFsFmDzrjlXagIxYfH9EwVrV+/XjZbGSNCRRAEq6IXLdardwn33WcAD6wMhrJfj7p1fdXMn4QE7ajPzE9LEFQkhakjoeyRGhVBEGxicvKLL/ZHhQrOWLDAOuvBOoI2bRJMlxMSoOz8BUGwLhJREQTBJoRKWpqWdvH3t966DB2ajFatjqFnTy8MGhRmvRURBMGECBVBEKwuVLKynJCVpXmXWLMmvl8/TxgM0QgPr4Y6dYBmzay3LoIgaIhQEQTB6kIlLS3/p8iaQoWW659/3hE7d1bF6dM5+PprBzd+EwQbQGpUBEGwulDZvr2a6fKHHwIREdZZF3d3dzRpkqzOb9x4fc6kgiCULCJUBEGwetdPRER+GOWHH+ivYL316dBBEyj797siJcV66yEIgoYIFUEQrArtv5OStIGEOhUqWG110K2bGwyGXOTkGPDdd8DevdZbF0EQykioZGRkoFWrVqoPnRMsdWgvzOsKnjZv3izvjSA4UOqHosAca3b+BAYGwM1Nm0w7dizw5ZfWWxfB/tH3c+b7vtLCYDDgr7/+QnmjTITKSy+9hKpVq17x9v/++w9RUVGmU5s2bcpitQRBsJHUz5NPbseff+7Bvn1a2sfb23rrU7WqP5yc8ieLiBGp40GLfA4SFBxEqCxevFhNr/zkk0+KrLTnhEn95Oqq+SkIguAYERU3txzUqpWj2oF9fa3jTGtu/Fa3bn5xysGDQEyM9dZHEBydUhUq0dHRePzxx9XYaS8vbdhYYdx2220ICQlB165dsXDhwqumkTjIyPwkCIL9G765uNiOW8LAgSlwcspFjRpp+Pdf66aihMvp2bMnxowZo6L1AQEB6gCXk43NiY+Px2OPPaamH3PgXe/evbFnzx7T7Tzfq1cvNfGYtzOSv337djXPhxOXOShPL0co+NhFsXXrVoSFhakBfJyivGvXrsuW2b9/v5rW7OPjo6Y5Dx06FDFmarg4r+/o0aNqCjOfp0mTJlhe1lM8y4NQ4QCnYcOGqVHZfLMKg2/S5MmTMXfuXCxatEgJlcGDBxcpVji+mtMW9VMNa0wvEwShRIXKqVP+WLu2gs0Urj77rAEzZ87Dt9+uwcCBgKMFeVu3zj+9807hy8yaZbnckSOFL3fbbfnLPP54ya3jTz/9BG9vb2zZsgUfffQR3nnnHYud9T333IMLFy6oqP6OHTvQunVr9OnTB7Gxser2hx56CNWrV8e2bdvU7ePHj1fR/M6dO+Ozzz5T4kUvR3jhhReKtU7Jycm49dZblXDgY1JcFLwvBRRFE8UMhdGSJUvUQf29995b7NeXm5uLO++8E25ubur2qVOn4uWXX0a5xXiNvPzyy0zeFnk6ePCgccqUKcYuXboYs7Oz1f1Onjypbtu1a1eRjz906FBj165dr3h7enq6MSEhwXSKiIhQj8vzgiDYHxs3bjQOHHjYyF+j++4z2gRpaWnGOXPmqFNGRoaxvMLXGR4erv6bw/dCP40YUfh9p0yxXG7PnsKXq1s3f5kePUpmvXv06HHZfqJdu3Zq/0TWrVtn9PPzU/sLy3Wpa5w2bZo67+vra5wxY0ahjz99+nSjv7//Na8XHzswMNBie37zzTcW+76JEyca+/XrZ3E/fT92+PDhYr2+pUuXGl1cXIznzp0z3b548WL1GPPnzzfaw2eMcL9dnP33Ncdax40bpyIlRREaGoqVK1di06ZNykDJHEZXqGSpFgujQ4cORYaw+HgFH1MQBPuOqMTEaKlhT09tl2bNGhXCcDojvjxC5hE4Q++CbdGiRQuLy1WqVFERFD2tw/eO9Y/mpKWl4fjx4+r8888/r1JDLE3o27evisDUrVv3htbp4MGDar34+dHp1KmTxTJct1WrVqnPV0G4bg0aNLjq6zt48KDKJpg3qRR8nvLENQsV5vt4uhqff/453n33XdPlyMhI9O/fH3PmzFFi5EqwhYtviCAIjkF2dg62bdOcaWfM0K6bPh1Wx8WlEr78sgleeKEidu4EgoLgMISZzWOsWbPwZbgbMF/ObN9sQZMm+WMR6tcvuXUs2HTBWhKmRAhFCvcjrDcpiN7Nw7TMgw8+qMoOmB6aMGECZs+ejTvuuAOlCddt0KBB+JAWzAUw3/cV9focjVKrXqtZ4NOtq0cqVuYFCaMqzLExV0f+/PNP/Pjjj/j+++9La7UEQbAxkpMZ/c0PoRRyoGkVatTwx5Yt1ZGZ6YKNG4E+fazbNl2WUJhdjQce0E5X4yr9EaUC61HOnz+vCrRr1659xeUYveBp7NixeOCBBzB9+nQlVLhfYtv8tdK4cWMVoUlPTzdFVQr6gnHd5s2bp9bregvIGzdujIiICFU/o4ub8uw/ZnVn2okTJ6pqa0ZZFixYoCIurLgWBMExSEqyvMz2ZFugcuVABAamqvNDhhhRoNZRsGGYymEqhM0ZtMeg6drGjRvx2muvqQJWpoCefvppFXE5ffo0NmzYoIpqKQAIRQQjHytWrFDdOKmp2ufgajBCw8gHu13Dw8Px77//XmbNMXr0aJVOpDDiczLds3TpUrXfK6446tu3rxJYjzzyiEolrVu3Tr228kqZCRW+8azRokOtDjcy38yUlBTVCsbq5bvvvrusVkkQBBvA2TkDvr7p6jyjFl26wCZgV2FGhnbEm5RkwIYN7Law9loJxYFigSKB7bsUANyp33///UqUsB3Y2dkZly5dwsMPP6xuY8cN24XffvttdX92/rBj9b777lOlDuy60dNFRUVomDn4+++/sW/fPpUpoHgomOJhXQmFEUVJv3790Lx5czz33HMqJUUPn+Lg5OSE+fPnK8HVvn17VWvz3nvvldsPh4EVtbBj6KPCHxQKHbaTCYJgX9Dye/jwfoiL88Lvv7OtFDZDjx4XsHZtiOky26ebN0e5gSmKkydPok6dOhYFoELh8OCaIojOtcKNf8aKu/+2HYclQRActuvHxycTBoMnKlSwcrtPAW6+OQNr12rnWWMpDYeOC4/pmSpaLzMVHK9GRRAEx4VdDDx98skyREZm4qabYFPcd58rqlRJUOe7dmXxpbXXSLAWjKQwdSQmo2WPCBVBEKxun29rFvo61aoFonHjS+r8mjXX3gUiCMKNY3u/DIIgOJxQ4dFqcQsJyxJ6WQwadBFNm17AkCG0XLjyFHhBEEoH2/tlEATBYWAx3bp1NfHyy/3QrZsBbFzIG8ViM3Tv7oquXc/A1TXa2qsiCA6JCBVBEKwGq/0PHAjByZP+qv339ddpAGdbb0hQniWt+XTb8oadN38K5fyzJUJFEASrkZSUhORkN5s0fDMXKgkJbvj55xAMHpyLwYNRbtBt2otraCYI14r+2So4EuBakBoVQRCsmvpJS9NGatiahb6Ol5cXPvusG8LD8wfcnTpFE0vYPTQ+o9GYPuyOr5X1QoJQEpEUihR+tvgZ42ftehGhIgiC1aArdefOEdi/vzI4uHbRIh552d4b0rt3koVQWbOmfAgVok+G1sWKIJQkFCk3On1chIogCFaB/il0rUxP136GAgOBhg1t8824914jvvxSO+/lxdoalBsYQeFgu5CQEGRlZVl7dYRyhKur6w1FUnREqAiCYBUyMjJUeDgtzdUma1PMad68IurUicXJkwG45x4jxowpf+kR7lBKYqciCCWNFNMKgmAVGE0hWVna/A9bHtXFOSS9e0eo8+vWyWRCQShLRKgIgmBVoVKvXjo4NL1zZ9t9I2hG16mTZk534oQzIiOtvUaC4DhI6kcQBKvAEfWkf/8E9OnDWgnbfiPat/eEl1cmUlPd1KDC+++39hoJgmMgERVBEKxWo0IGDeoIjvmpUAF48knbfTMqVQpC8+bRaN48Bj4+YpAmCGWFRFQEQbAKmZmZyM01ID1dK+BkJ40tN50EBATg+efnqwLgSpVuxVdfeeGee4CQEGuvmSCUb0SoCIJgFdgKq7cm26rZmzmc7nzmTCjeeacpkpK0AuCAAOCBB6y9ZoJQvpHUjyAIVouoAEZ4eeWoy+3aAa1a2fab0bixp0mkkJUrrbo6guAQSERFEASrCRUvr2wYjVoV7bvvAv362fab0aqVP3x8MpCc7K4ur15t7TUShPKPRFQEQbBa6ic72wlpadrPUMWKtv9GcEBhnTpx6nzNmrnYscPaayQI5R8RKoIgWC2ikpycP9jHHoSKu7s7Row4pc6fOeOEPCsYQRBKEREqgiBYLaKSnOxmV0KFdOrkBk9PrT1JUj+CUPqIUBEEocxhiy8jKikp+UKFPir2QNWqIWjc+KI6L8W0glD6iFARBKHMycnROn2OHg1Q/z08gNmzgfh4+6hTadbsgjq/YoXM/RGE0kaEiiAIVhMqCQlaqy9rPYYMAc6ft/03w8PDAx06pKjzx445Ye9e/rf2WglC+UWEiiAIVhMqzpoprQlfX/t4M9q29YCbmzakkN4vzz1n7TUShPKLCBVBEKwmVFJSND8SncBA+3gzKlcORnCwFlUxGoE1a2zb/l8Q7BkRKoIgWE2o3H//YezfD2zaBCxapNWq2APBwcHo0OGc6XJyMrBtm1VXSRDKLSJUBEGwmlCZObMZmjUDpk8Hbr7Zft4IT09PtGuXqFxqb7klDd98A9SrZ+21EoTyiVjoC4JgNaGSluZq88MIr0SvXs4wGFbj/PnmqF3bU6YoC0IpIUJFEASrCZXUVE2o+Pvb35tQuXII/vknBOvXV1XdSgMGWHuNBKF8IqkfQRDKnPIgVFinovuprFplVEW1giCUPCJUBEGwilDhjj0lxcVuhYqXlxfatUtS56OjDThwwNprJAjlExEqgiBYRahER3vj3DlPdXniRODXX+3vjWjWzAeVKmliZflyDlq09hoJQvlDhIogCFYRKklJ9FAxqMsnTgBJ2v7e7tI/DRpcUucnTQICAoCICGuvlSCUL0SoCIJgFaGi2+frcCdvj0KFLcrk4kWmsoClS629VoJQvhChIgiCVYSKn1862rdPQJs2mg19lSr290b4+Phg8OBIi+tEqAhCySLtyYIgWEWoNGgQi6lTTyAsLMyu34GwMB/4+mYgOdkNYWEGdO5s7TUShPJFqUZUateuDYPBYHH64IMPLJbZu3cvunXrpiaS1qhRAx999FFprpIgCDY1lLDAVEI7JCQkBBMmrMIff6zCjh3A2LHWXiNBKF+UekTlnXfeweOPP2667Gs2HjUxMRH9+vVD3759MXXqVOzbtw/Dhw9HhQoVMHLkyNJeNUEQrChU4uM9sH69v6rr6NTJvoVKjRpbkJ0NZGRkwN3dctCiIAg2LlQoTCpXrlzobTNnzkRmZiZ+/PFHuLm5oWnTpti9ezc+/fRTESqCUM6FyqFDQfjf/2qp2pRIyzIPu4Jzf/z8/NSB1+HDl+DvXxW1all7rQSh/FDqxbRM9QQGBqo89Mcff4xsHnbksWnTJnTv3l2JFJ3+/fvj8OHDiIuLK+1VEwTBikJFd6X187P/t4FRlZkzW6BVqyp44w1rr40glC9KNaIyZswYtG7dGgEBAdi4cSNeeeUVREVFqYgJOX/+POrUqWNxn0qVKpluq1ix4mWPydAqTzo8ihEEwf6EytGj2nedDrVbtgAdOsBu4e9W5cpRMBoNWLZMe00GzSJGEISyjqiMHz/+sgLZgqdDhw6pZZ9//nn07NkTLVq0wKhRozB58mR88cUXFkLjWpk0aRL8/f1NJxbgCoJgf0Jl714tJXzkCPDAA7Br6KfSokW0Oh8dDdxzD/D669ZeK0Fw0IjKuHHjMGzYsCKXCQ0NLfT6Dh06qNTPqVOn0LBhQ1W7Es1vtRn65SvVtTAqQwFkHlERsSII9gWFSmZmfsePPc76MYfp6wYN3ODsnIOcHGfMmwdUr66NBpDIiiCUsVDhkQNP1wMLZZ2cnFQ+l3Tq1AmvvfYasrKy4Oqq5auXL1+uRExhaR/CinqpqhcE+6a8CRU9/VO1ahIiIiqoy2fPAvv2AS1aWHvNBMG+KbViWhbKfvbZZ9izZw9OnDihOnzGjh2LIUOGmETIgw8+qI5ERowYgQMHDmDOnDmYMmWKRcREEITyKVQaN76ozt90E/Daa7B7eADWvv1Z0+W6dbU0kCAINipUGPWYPXs2evToodqO33vvPSVUvv32W9MyrDFZtmwZTp48iTZt2qi00ptvvimtyYLgAEKlQoV0+PjkKvt8ihV7JygoCAMHHoeTU666/L//lY/XJQjltuuH3T6bN2++6nIstF23bl1prYYgCDYqVEaN2o4//wxQBo/lARcXF4SG+qFZswuIjAxCXJxMKBGEkkC+SYIgWM1Cnzv38gTTP2PGbEbDhiHo2lWG/ghCSSDTkwVBKFOMRmO5mvVTUKj4+mYiJuaCep2CINw4IlQEQShTcnNz1U58wYKGeP99N+zfX37eAJpbMkrE0SDx8fHK+E0QhBujfMVdBUGweRhNOXXKH3PmNEdOjhP+/hvg0PR+/WD3MELEqMrq1emYNs0FqalAr17AnXcCbdtae+0EwT4RoSIIQpkLlaQkdyVSyJ49wEWtU7lcQD+VyMhYrFypTYpnTwFHnIlQEYTrQ1I/giCUuVDJyLA8RvLxKT9vAl21O3WKYDWO6bp//rHqKgmCXSNCRRCEMhcqzs6a1wih0XU56VBW+Pj4ICDAE4GBqabroqKAmBirrpYg2C0iVARBKHOhUr/+JdPlNWuAHj3Kz5vAwayMqugutRwPcP48DeGsvWaCYJ+IUBEEOycpKQk7duzAkSNH7KIltmDqx9sb5Q7Wqdx22xF1PiGBc86svUaCYL9IMa0g2DHc6a9duxYpKSnqMttimzVrBlvGEYQKO38CA9NRu3YcTp2qiEWLOD3e2mslCPaJRFQEwY6JjIw0iRRy8OBBJCcnw9aFiotLDjp3voC+fctXIa0Oh60GBgYiLCxKXV6+3NprJAj2iwgVQbBjzrP4AUDDhg1VXQRTP4cOHYKtC5WQkFS8++4BtQN3d0e5hOmfHj1OYdKkg1ixwtprIwj2iwgVQbBjYvJaSYKDg9G4cWN1/vTp0yoFZMtCJSLCD+HhFVXtxrFjKJdQOFapkoyGDQ/BwyMXR48CkycD6enWXjNBsC+kRkUQ7JSsrCxVSEuYZmC6ISWlEi5ezMCZMxGoV68ubFWo/PFHU2zeXMNUo2Lj2arromLFiuo92bnTH6++motDh7TjwkaNgFtusfbaCYL9IEJFEOwUvRbF3d1dnb7/Hhg5sjuMRgP+/TdapRtsceYfhcqFC/kVtOWxRoU4OTmp9I+3dxIOHcr/qf3rLxEqgnAtSOpHEOxcqNBgjKUqTz/NycQGdd2aNZXw9tsZsEUoVFJTXct1148OhUq1aokwGPLbxpcu5ftk1dUSBLtChIog2Cl62odC5dw5IDQU8PQEWraMU9d/8omrckS1RaHSpMkFdb52beCVV1BuYZ2Km1suqlVLUJc7dgQOHKApnLXXTBDsBxEqgmCnpHI0r4pIeKNlSx69A2lpQFgY6yPSkJbmhC++gE0KlYAAraK0Xj3gscdQbvHy8oK/vz/uvPOgurxvH+CaH0wSBKEYiFARBDslPa99xNPTE7/+CqxerV3v5+eDgQOPqvPffWdEVhZs0PDNudynfXSqVq2KsLDzcHHJBS1vVq609hoJgn0hQkUQ7FyoeHh44Ouv86/futUVN92UgoEDj2DmzFM2dwRPoZKe7lKuC2nNqVKlCry8stC06UVTMa0gCMVHhIog2LlQ+e03f1WLUq2aVvtQsSLQuXMghg3bDReXk7A1zIWKI0RUAgICVJtymzbakMKFC4Hc/OHRgiBcBREqgmCH0IFWFyp79njg7FmgVy8gNhaqTbl69erqtkuXLqnlbKnLxHzWjyMIFbYpM6rStm2kuhwdDSxZAsyaZe01EwT7QISKINghdJ7NzTssP3hQq/do0QKoUIE1EVoRJw3H9u0LQteuRnTpApshMZGOul5o1CgTBw8CCxag3EOhEhiYhk6dokED4dtuAx58kO+dtddMEGwfESqCYIdkZGgeKS4urjh4UOt1bdrUcplvv22DiRN7YccOT2zaBJw6BZsgMdGAEycCcOiQm4os7NyJcg/blA0GAzp3PqbESU6Odv3cudZeM0GwfUSoCIKd2ueTtDQf1ZJM6KNiTvfultP+pkyBTWA27NlhCmr1acqtWp2Ht3d+gcoff1h1tQTBLhChIgh2iD50MDbW13RdzZqWywwf7gVPz/ze5BMnYBNkZhrh65sODw+jw9Sp6G3Kbm456Nz5Itq2BUaPhpoeLQhC0YhQEQQ7Fip79oSo/35+WmonOzt/GW9vA158MRJhYVoRZ56RrdWpWTNBubXqEYXHH4dDwDoVUr16JLZvB/79FwjR3j5BEIpAhIog2LFQ2bs3wFSgyhqVo5rPm4knn3Q3mb+tWWNETAys3q2Ulpam2pPT0w3w8HAcp1Y/Pz9V5NyypTbX4ORJx6jPEYQbRYSKINhxjYr5Tp6TkmlJb05wcDBatYqDtze7hAzKw8OasFWa3UqO5KOiw2Japn+qVElG/fra+AMpphWEqyNCRRDsOKKSlqbt8AmtUwpGJ5ydnVG9eiW0aaOlf+bNg1VJSUlBdrYBOTlODidUzNM/7dufMQkVW/K4EQRbJP9XThAEu4uofPVVJNzdGyAigtcVvmy1atXQrdtJ+PsbMHZsLVgTpn10szdHFCohISFwcXFB27YnMXNmI1XgvGWLlrrr18/aaycItokIFUGw44iKk5OLmpzcunXRHh4tW25BpUrJWLeuMiZNcleFnC4u1kn9xMR4mi4zAsSIAq3/HQFGuBhVyc6OQI0a6YiI8ECPHnw/tcnKzZpZew0FwfaQ1I8g2CHZ2dlqB9+zZ221sy9qIi89PFatCsOYMbdgwgR31RK7di2sAoXK8uX5hTQNGkDNKXIkGOEioaGX1P88zYnffrPmWgmC7SJCRRDsVKhonTNOSrAEBha9fK9ebhaXZ8+G1YRKSoqrwxm+FYxwcf7PLbfsh5NTfoEKhYrUqwjC5YhQEQQ7FSoJCR6my5UqFb38wIGBCAjQOk3IuXOwmlBxdbUcHexodSqMcLFWpVatBNx1Vzzq1wfeekszf3OUFJggXAtSoyIIdggnEMfHaxb53LkFBRW9vI+PN4YP34dZs2ri3Dl/1KplPaHSocNZtGkTBCcnX3AANNuqHQ2mf86fP4+HH96FOXN6i0ARhCKQiIog2GlE5d9/G6jzTk7AzTcD8fFF3+eRRwzo21fz0efE4rzhy2VeBNymTRReeSUDH38MfPEFHBL6qZDU1BikpaXi9GnbGRopCLaGCBVBsFOhEhendc9wEi/TBl5eV985tmun5XwiI6Fs3K3RVh0X54Hduz1w5AgcFk9PTzWkkDz5ZCZq1wbef9/aayUItokIFUGwM2hDT6GSnJxfIFuxImsfir5fxYoVUbOmEbVrx6nL8+ejzNebQmXr1uq46SYf3H8/HBq9+yc4+ILJ/C0jw8orJQg2iAgVQbDD+hTi45NpGkhYHP8N3cJdj6r89RfKfL0pVhzRPr8oodKkyUG4uhpV6o7+NqtX284ASUEo90Kldu3a6sfR/PTBBx+Ybj916tRlt/O0efPm0lwtQbBrGE0hL7+8Hvv2GbFjR/F9UcyFyqFDwK23aqmjsjSp051pHa0tuSC+vr5qUKGPTwY6dEhT1z30EFvJgT//tPbaCYIDRVTeeecdREVFmU7PPPPMZcv8999/Fsu0adOmtFdLEOxeqFSokItmzQyXDSIsCrbFHj0awkSMurxoEbBhA8rU9n/3bm3eDQtIyzqqY2tU54AmAG3barOY0jS9gpkzrblWguBgQoVHDTQ40k/ehcR7WVRmvoyro8x9F4QbECq0Y79WeJ82bfj9yjfs+P33shUqJ0/6q/8HDwJz5sChqVGjhvrftu0+C/O3FSscz7FXEKwmVJjqoRAJCwvDxx9/bPqRNee2225TR3pdu3bFwqvMoc/IyEBiYqLFSRAcCf07tH9/JSxbBpw/f233HzDAHxUr5pu/Xev9b0So5OYakJub/7Pj6HUq/v7+Kv3j6pqFli21SloGWTiosHJla6+dIDiAUBkzZgxmz56NVatW4YknnsD777+Pl156yXS7j48PJk+ejLlz52LRokVKqAwePLhIsTJp0iT15dZP+hGJIDiaUPnmm+bo3x9YuvTa7l+1amXcccdhDBu2C/v2JeDrr1FmQiU93TIK5Oh1KkT/Dbv33mPKYXjIEIDZb3GpFQQNg5Fl+NfA+PHj8eGHHxa5zMGDB9GoUaPLrv/xxx+VYElOToa7u+aqWZCHH34YJ0+exLp1664YUeFJhxEVftETEhLUkYkglHfOnTuHBQt24sUXByI11QWTJgGjRrFmpfiPsX79esya5YrZs9ugXTsXLFmCUufYsWPYsWMnPv20L7ZuDcDYsfw9Yd0MHBr+di1VatMJt956G7y8rtJnLgjlBO6/GXC42v77mi30x40bh2HDhhW5TGhoaKHXd+jQQR0NstunYcOGV1xmOd2rrgAFzpVEjiA4AvwOHT0aqEQKeeUVoHlz4JZbrq2I08cnArGxLmryckIC0xAo9YgKowRffHEMrVu3V864V/N+cQT06DB/rKOjz6FOnTrWXiVBsCmuWagEBwer0/Wwe/duNTWU9ShFLVOlitYVIAhC4Tv8hARLsU7Dt2uB37EWLXbA3T0LGRmuWLwYpW7AphfTciifi0wZu0w4UqhEREQooRIbS3t9rV5FEBydUvu52LRpE7Zs2YJevXqpzh9eHjt2LIYMGaIcMslPP/2kfrRYaEv+/PNPlR76/vvvS2u1BKGcDCTU7PN1riXtQxiVrF49CK1anceWLTWUS21ZCRUXUSmXwfT1gQMHEB0djTffzMaHH7qoWpUxYzjIkZHm0n1vBMEhi2n5Q8hC2h49eqBp06Z47733lFD59ttvLZabOHGi8k1hymfBggWYM2cOHn300dJaLUEoF0KladNo0+XPP+eO7vqcUXXzN9avjx5duoMKNWda4NtvK6lhhBc053hBuQv7qfQPSwa9vOJAb7wZM4BWrYAXX5RNJDg2pRZRad269VUdZh955BF1EgSh+OTm5sLVVVMUrPmgwOAE5esRKunpHLlMW3uD6v558EGgS5fSq61JTHTDF19oqeMePaSQ1hy9KaBVqyNwcgo2iUb2FRw9CtSvXzrviyDYOjLrRxDsDEYmcnKcEBSUpdpZr0ek6BN8mzZ1sjB/42C80lzvpUvz97YDB8KhJyhfqU05KSkSHTtahrZ++81KKyUINoAIFUGwy9TPRaxceeiG3Uv79fOGp6dWO0L27EGpwYhKXJyH6XJkpBi+mcNavoCAAJX+efRRLSVHmC1/9dXSe18EwdYRoSIIdjo9+Xos9AtSs2Y13HzzEXXavDlDtSqX5nonJOQLFRIYWHrPZ4/UqlVL/a9Z8zBq1oRpJpJMFREcGREqgmCHNSolJVToDv3EE5F45JHdCAo6W6puqIyoVKumjbzgjnfAAMDDUrc4PEz/cIJ8fHwsHn44XW2PH35gx5TDbxrBgRGhIgh2BiMTzz/fHz16hCqr9Y8/LpnaCHp4sCvn2ryqr229a9dm8a42x4beLYIlHh4eajAr6dXrpGo7v/VW1q3IlhIcFxEqgmBnZGfnIDLSD9HRrti5E9i168aFCsXJ118HoWHDXDXosLSESmqqNhm9tF1wy0P6Jy3tBKKijPjuOyAgwNprJQjWQ4SKINgZNAAzGg3X7UpbEG9vbwQFBeLQoSAcPeqEOXNQaqkfP78MdOmSoyJBQuFUrVpVmeKlpKQgOfmS6fqzZ4F339Xef0FwJESoCIKdkZpqhKdnpjrv5QUEBd34YzKq0qlThDr/+++c6cUICEoMdrIwotKhwzksX56pzMyEwqFIoaU+OX36NA4eBAYNYqQFeOMN4I8/ZMsJjoUIFUGwM7y9M1C1qla08P77wNtvl4xQ8fZmxaYRKSnAp5+iRDuAWACsD2oXC/3ip39YN7R5cw7++SffNfibb0rufREEe0BGgwmCncHIREqK23XN+CnK/K1ePT5mfkrpl1+Am24qubRPcjKHH9ZHZKSzWu/27YEmTUrm8csbHPzK9yQtLQ1hYdEwGKqaipz37QPOn9cKkgXBEZCIiiDYGYxOpKS4lqhQIf36VUSFCmmmy5yAUVKzfyiu4uI88ccfzTB2rBM4zuvff0vmscsjnDKvR1USE4+hUyft+oYNgXPnRKQIjoUIFUGww66f1NSSjaiQGjWqY+DAozAYNHXyzjvXb89fVMePjnT+FE2dOnXUf05Ufu01rYL28GHgzJmSeU8EwV4QoSIIdkZmZq4qfO3XLwtVq5bsxPNRo+LRvr1m375lS8k9NlM/IlSu3VKfKSDW9tSqdQLNmuVPyxYER0KEiiDYGefPe6JPn+N4++0suLuXbHcOi2rvuecAvvlmPT79tOSc3xhRadbsAoKDU9XlV14BevYssYcv91GVU6dOYswYo6l2KDbWyismCGWICBVBsDOWLq2Ft9/ujU6dvFTLaqLmSl8isC22du0UBAREIi4urkQjKq6uucjM1Or3WUgbElJiD19u4fvh6uqqPFX69r2gjN/S0oDvv7f2mglC2SFCRRDsrJA2OVmrT9Hx8yu5x+dOsVq1aiYPj5KMqLBrJSVFEypSn1I82MqtjziIjj6JUaM0T5WwMK1NeejQEnuLBMFmEaEiCHYEd/hRUT4WIqUEZhNawG6T3FwDpk51QsuWRjz+OLB9+42vd1aWE7KztZ8cESrFJzQ0VP0/e/Ys3nwzE3fcAdx7L/DUU8Cvv2rdWYJQnhGhIgh2BHf4TZteUOcrVjTizTdL/jkqVaqEzExf/PRTE+zda1Bphhs1GWMkyLyYtiSjQOWdihUrwt/fX23DM2dOo1IlIF6b7aiYMsWaaycIpY8IFUGwI7izqlAhQ52vVcugrO5Lw8OjWbPKqqZEZ/bsG6uFocDi440YcQbPPy/1KdeCwWAwFdWeOHEC/fsb0aCBdhujaTyVlN+NINgiIlQEwe5caUve7K0goaG10bv3CdNlgwHYu/fG1vvbb9vizz8r4++/gbvuKpn1dBRq164NZ2dnJCQkIDY2Br6+2vW3366lf0rK70YQbBH5eAuCHWFunFaaQqVChQq4555oNVeI0Eq/a9cbiwQlJLgjLs4NR48Cx4+X3Lo6Am5ubqhZs6Y6f+zYMRWVIgsXigGcUP4RoSIINgSPmBOLyLGUlVAh7dpVwciRO9R5DsWLji6Z+URlse7lkXr16qn/586dw6BBaao1PTsb+N//rL1mglC6yFBCQbAR9u/fj/DwcFOnR5s2bVR9wuVzftzKpHOGR/Dt2u2Dv386EhI8MGMG8PLL1/dYXG8+jpOTEd7eBrRsCZuCQur8+fOIiopCbGwsUlNT1XVMt3h7e6tiVhYZV6lSRUU3rFVUGxgYiEuXLuHMmRMYN64pxowBvvsOeOMNKI8VQSiPSERFEGyApKQkk0jRiybNL+ucPWvE/v2aU9qGDcDKlaW3TpzeW716JfTseVJdXrXq+h+LO/3WraNU2zMLQadPh03A9Tp8+DD++ecfbNiwQW33+Ph4ZGZmqtv4n8Z3p06dwpYtW7Bw4UJs3bpVLWPNqArXc9iwXCVOUlKAr7/WbhfHWqE8IhEVQbABuOMhPGKnG+m2bduUUKlatao6ktZh+iU52V2dp7fJgQNA796lt16M7PTrtwtt28Zi/PiO7DO57ohKWlrZRIKKy8WLF5XooOsr8fDwUOZqnK/j4+OjzNYoVigiGWWJjIxUaTmKFp7oN9OsWTMVcSkr+NnYvXs30tLSkJAQiaefrq6GR37yiSZaWftz7BiN+8pslQSh1JGIiiDYAEw7EO782OHBHVJKijM2bNivhtLpFHS1N9MwpYImnHLRoME5HD4cpQbi3X03lMvs9fqoWNtDhduTInD16tVKpDBy1LZtW9x6660ICwtT257FxBQrTPnwcosWLdC/f3/06dPH5BRL594lS5bgyJEjFu9RacJUlN6qzKLap5+mey1rm7SIFycrz5pVJqsiCGWGCBVBsDIZGRmqiJaEqAE4Bixa1BYjRgzGbbd1wbBhacjK0pbNyqKPShrc3HLKRKjQU4U7xv/+C0XbtlXw7LPAvHla2ulaYGQiLc369vkUTDt27FD1QBQXFIUDBgxQkSO+1qJgvRBrRDp16oSbbrpJRV74uhjhoOhhXUtZULduXbUuFy5cgJtbgnpPzPngA/FVEcoXIlQEwcroIoUpBKYf2HL6/vtuyM11gtHohJ9/9sLIkdoRe6dOKfj00yX477/Najhdv36lv34UKiEhyUhPz0/7fPXV9UdUrCVUKEyYUmOajTv61q1bo3379mq+0bXCdFzPnj3VYzBFxDTS8uXLEX0jrVHFhJ8TfR4T62uY9hk8GKZhj59+qvneCEJ5QYSKINiIUGGagbz1lnZ9tWpG+Pmlq/MzZhgwdy4QEwMMH34HevbsjMjIsqlFYAqkTx/+1zxVCJ/3WrId0dHOOHtWy/lcusT6EJQ5e/bsUekaihRGRfTC1OuFj8PH6NevnxIujIytXbtWiYfSTgU1bNhQ/T9z5oyqV2GdyqJF2tyfAQNEqAjlCxEqgmBldN8UPz8/ZVPvkzdz8Nw5AxITPUzL8chZ7+pg90xZepHUrRuKwYMPMi6hLt9zz7XtDI8c8UREhLbCM2feWAfR9cAoCmtJSLt27VTdSUkKuV69eqk0EgUKBdGuXbtUFKm0YAqKJz4Ha1WaN2d9E/DAA8Bvv5Xa0wqCVRChIghWJjk5Wf339fVVhabr1gHsTH7yyfxlvLwyMWlSHGJjNXVgMBjLVKgw1XDXXafQtm2kusyi2mshKcnyp6Ys0z/s2Nm5c6c6zy4dCoprfADgr7+Ajz6Cql7lDAAdhobeew8u27ahXZs2aJlnEEPxsGnTJmTTka2UoyrHjx9Xz8PVmzMHKrqSo5UwCUK5QISKIFgZhu6Jl5eX6brGjTVvjBdf5NFzJt57bwXc3A4gKkr7ygYGZpfpfBd2m3AHP3DgUXX5v/80MVVckpOdrSJUuAPfvHmzijyw1bsxN2xxoE8K3e2qVuXGBu64Q7vM4hzzoUf79wOvvw507gyDmxsaPvEEunt5wclgUA6y69atQ5ZeCV3C8PUwmkOvF7ZLczX4mTh8WBMsglBeEKEiCFaEqQK9W4RtsgV57z1g48ZMVK2apHw8tm7VdvjBwVnX3CJcEt0mTZteQPXqCdccVenU6TzeemslfvopFr/8AtP039Jm3759KmJFEcjC2YJOv4UyZQoNS7QISlSUdh3vx0pV5rxatcpflqYlOkz1rFmDyoMG4fZ330XddetwKTKy1MQKu5Tq16+vzjOtVbduLh58ULtt4kSaA2rRlVIM6ghCmSBCRRCsCHdgenogMtJLmbcxu5CRkV+02qCBj0q9REX5YN48zcPj4EEv3Hpr2a4rU1NVq1YxRVV+/lnzdSlOV66PTzpcXXNQv74R995bNnbv7MQ5ygmIgPJJKbb1Pd8PmsCZh6zYB85K1d9/B265Jf/6gmGtpk3VP9e9e9Hmyy9x83PPIfHECWyaPx+Z+ptawh1ZfF0UYxSyjKpQUx06RLM+YMIErSZIEOwZESqCYEX0aAp3NuHhLqrIlMWQBfeprEfQO4B0rDHbhV0u3bqdhrd3JtzcjOjVK781tiiSkw147bWb0LlzIPJqWsvEL0XfmVeuXPnKC/M9yMzMvzxqlGZG8tNP2uXgYOCuu/LVozkULXzDXnpJq2RlKojP++ijgLs7XFu0UCIn7LnnkNSpE7LyamVKCrZGM9JFDh48iAYNjKrrh+hBHHaRlYJGEoQyQ4SKIFgRtrTqaZ9Nm7TrmjS5vKMmKCgI/v6BquuGbcKenrmm7qCyhDv8wEBP1K17CQkJBuzZAyxfblm2URjJyU5lWp/CLh92U1EA6gWuhcLQQ5s2wLhx+dfREp/1KMyjsBiHfeDffkuP/cvvTwFEgfLhh/ntNq1bAz/+qNJCrtOm4aaEBPhGRSFw1y64tG2LHE4QLEGY/mENEWcS0eGYKTnzzw91GOtWBMFeEaEiCDYgVLhDXbZMu447/eHDLx8wFxZWFy+9tB4hISlIS3PSswxliu4d0ru3NqhQZ/Lk4hfTlraFPotL6Tyrd/lcMeWzdi3AiAfFytSplvUmelqHBjL0qL8eWOdSty68WfOSh8FohPGTT5BbgvkYmgTqURWOBqhb14j77tNuoyEgXxZfpiDYKyJUBMEGhIq7u7ua00KSkrSsQ8Ha2lq1quLQoeo4cSIATZtmmQonyxqmUjp3jkZwsDbMr1MnYOjQ4kVU2Fbt61u668cUCMUKfWlojV8onODHvJWeH2HUhUYkpQHTSI0aqbM5rq5wSU+H05AhMD70kDakpwRgapDFtZcuXVK1OYyqcEDh0qWsLSqRpxAEqyFCRRBsRKjk+b4p2MxRUKhwR/TLL4HYs+cIdu1ytkqNCqHlfGhoTQwbtgudO19SU5yv1tQyY0ZzU5CC5RyluT3pK0I4SLDQ+T1UhKzoNTdkYwSmhOtHFMzBDByohck++wxxixbhbIcO2k2//QYjBdKWLTf8NEwd6qKMURWW1VxJowmCvVGqQmXRokXo0KGD+hLRYnpwgao72j/fcsstqnWQw9hefPHFUjVIEgRbFSqZmZ6m/SZrVPL2ZZfBKEGLFg3g6mrdYwzWRdD8LT09Q4kUBg2KasGOjvZW53NyDErYlBZs0+VvCKcfc/LzZdC/n/kQ/meRD9uqmItihOVKG70k4PM8+yyCbroJTvPmYduTTyLL3R2G06dh7N5da3tmiugGes4ZVdGHFcZw1oKZJcySJSX0OgTBCpTar928efMwdOhQPProo8pSesOGDXjQLFbNqaMUKQzRbty4ET/99BNmzJiBN998s7RWSRBsDn7+yaVL+WZv69fnN5zYKhRMNBy7/fZDpnIPvRi4IPyuZ2S4lHoxLbclHWFJkyZNCvdMeewxrbKU5nosClqwQPvfuTPKiqrVqqHS+PFY/uGHiK9ZEwZ+Bv74A3juOa27yDy0do3DCnXXXUZVyLZtWmSFfnX0VaEuLoO5iYJg+0KFRzTPPvssPv74Y4waNQoNGjRQPxz3Mtyax7Jly9SX6ddff0WrVq0wcOBATJw4EV999ZXpx1sQHCWiUqmSs5p6+8ILKFNr/BuhUaNGaNQoBg0bakfvbHy5Uquwv7/WWs2WZpq9lgZM+dCXhiJKny58GezVZeHpr79qxTVMy5RmJOUK1KxZE/UGDsS6l19Gtrt7/g3z5wOTJl3349J5lwKN3T+sVWnWTGtiSk+HKrBlqczDD99Q4EYQyodQ4VwN2kczPxwWFqZCsBQieiU+4RyM5s2bo1KlSqbr+vfvr1oKDxw4UBqrJQg2hy7Kq1d3wdixwMcf28/kW7ZMczDe7bdzWKEWnGA37z//XB5R+eKLf/HLL3/g/Hngm29K5+BIHzpIAXVZNEXPq7EmhL8vDDFYGR7A1WrbFqd69Mi/sl07TVGY/VZeC7TUZ7Gz7srr4WE0CciNG4FTp7QA0sKFJfISBMF+hQo9DMhbb72F119/Hf/884+qUenZs6caEEao+M1FCtEv87aijkApZsxPgmCv6DVZLFC1R1gXERYWhapVte8hyz9oK8JZfTr6FGFPTwMqViwdFcbfHP42MP3BaIUF+/ZphT9sgSHmEQwr07xdO1x65x1sevZZJFeujDiOyL7zTqBLF82g5jpg9JoHiaxT4W8p34+8piMTr74qURWhnAqV8ePHqyOVok6HDh0y/TC99tpruOuuu9CmTRtMnz5d3T537twbWuFJkybB39/fdKpRQ7MUFwR7RJ8Bk5npYpfheNap+Pn5oEYNrc2Wr4HDoM2La/Xfg0I7cEoARmwO5zmaMZpi8TwUgpxLwNtp2copjzaUWuZvYrt27ZB1551YPHkyduzbh1yOPuYBGNNS3313zY/J5gR63ehRFZoEmtc8MWizaJH9RO4E4Zp+OcaNG6c8Coo6sUVOr7anstdh+yVvY6eP7nAZXaCqS79clN31K6+8goSEBNMpIiJC3kXB7iMqXbv6KV8xlnHlOb/bBRQFjKo89th2ODnlt/syDaS3LFNIbNpUHcuW1VVOtiUNJwdzAjW7C/ViUhPDhgFmHTCYNUtTUja2DTt16oQKwcGIDQ7GivfeQ27bttxwwMiRmkvu888Xb6iSWa0K7fXj4+Nx9uxZNU/x9tu122i0y/ZlQSiXQiU4ODivgO7KJ7pAMoJCYaIf5ehHjvxBqZVnqsQvJtU+W+l0li9frgrhzAVOQfi4XMb8JAj2CCMN3ImTM2cMqoyCAUcOlrMnKA5CQpxx113hqFgxR7nU8kBez2bxdS5eXB9Tp7Yo8TZZbj+9w4WCiVbyJmimZv6EDCHQEdZaBjRFwNRft27dVI1JnJsbVr7xBnJ1ZcEpzv/7n2ZQZ55TKwL+TnJ7ENYG8j346iut2encufwsmCDYA6USi6V4YLfPhAkTVHcPBcuTTz6pbruHfgEql91PCRK2MLN9eenSpaqeZfTo0epLJgiOkvbJynJS/iI6V2pYsVUoDniQMmjQYUydugzPPZdrYVZ3/LgRMTFa+zV12dXM4a4FtiMzmsJ0h24jb4Kjg+mXQmtWVilzxo554aqNQSv87t27q/+x6elY8/TTMNL5T2frVs3SP0/cFqdYlweOSUlJqoaHn6tp07SHYRmMINgLpeajwtbk+++/XwkR5mBPnz6NlStXqqJa/ceNRbb8z+jKkCFD8PDDD+Odd94prVUSBJtM+yQm5nuokMJ8ymwdpnX9/RlCScKhQ6eVd5lu9Lp4sRsuXdIM3157jRb3JSf0mG4mPOixiKYwx/TFF9r5997T+r7ffhu2DiMqjKwwbXMxNhZH778fRr3mhhEh/j6av86rRGma5g2EYiclO8yGDNFqVMzhx9CGynYEoeyECr8kn3zyiao7YWcO0zr6l0aHaaB///1Xjbpnzz+X5xdUEBwpomI+i4VDd+lzYW/we6unGoYP91TeZdQGLK41LxEhQUEl85xsR+bO19fX17I2hU/69NNaSzLbkfOiufYCD+a6dOmiald2N2uGY199BSNzNlR/Bdy9rwajTNw+7IjSRZ0OxcmcOZqNzMSJJfwiBKEEkVk/gmDliEpqqhZtIIMGaXN+7BHuFJm27d9f2yGuWqWViJw+bfkzExh448/FHa/um8IJyRadPizAoL0vYWGGHR780KqhPStgAewKCMCRf/8FnnnGsihYn2JZBNwuNNQkR48eRXJeITFriGi8d//9WuSLXitiXyXYKiJUBMHKEZWkJK2gg/taG6zzvOaoStOmF9G+vdbBN2IEzcXyhRhN7UqiBI11b9x+nOlTvXr1/BvoE88wwdSpWrcM/UjsFPrB6CJjT3S0yZ8Kv/8OcPJy165a23XeEMYrwS5KCh8W1LIekLDrx7z5iR9FBp7ssUVeKP+IUBEEK0dUkpO9TDuPUrIaKTPo38Goyq23av4dUVGWt7NG5UZJT09X0QHCdLKFCy1bpmbM0ObmsJYjJQX2DAtiWahMduzYgUj2FtM7igOTaM3AqAtTbu+/f0WVwe1DwcP/dAxnpyUdINhMpMMoHr3mxFtFsEXs/GdREOw/otKhQyJ27dK8R+wdRlXo4dGwYSwCA7X5PjoBAZklEjFiyodtyQEBAcpwzgTbWXRnMw63+eGHfOt8O4ajRliDwynUHD0SQ1XBKZDcmDSGYxcQFeC4cVd8vTTHZMEz2bVrl4qujB6tGfYSCpTmzcvyVQlC8RGhIghWL6ZlHYFVZuOVWq0K24WfemqziqqQ0NBYzJy574aP2BmF0lMg+gA+Eyy0cHPLv8wOGfNKZTuFr7Ft27bKSJMCbf369UjgmIC+fS0XZG1OEe07rOVhtItGmRR7DDjRt4ebjOU+7OYWBFtEhIogWDn188wzTdX+lLPkrrGpwyZhmzB3is2aXUTLlpqhY1BQKgIDb7wAgqaR7PRhG6/ugK04eVKbhsgdNQcOMSUyfDjKC7p7LYdA8vWvXbsWqd9/D9VvrHPoEDBv3hUfgyKlRYsWpnbllJQUFVHRu7Zp1LeZ2lIQbAwRKoJgZaFy8aKbKmzkZFu6hpYHWAjKdMPzz6/H+PFr8fzzG+HiUjz/jyvB1Idem8JaGItOH07Zo0ih2uNo4E2b7LLb52ppta5du6p2Y5rcrd2wARmcBcTIUevWWk3OVXq/mULi1GtGZnbv3q2uYxs5vVWYNWKdLmG5C419BcEWEKEiCFYWKhcuuJZo664tQBHB2goPjxyEhZ1XKR8LQ7brgJ5MdFnlDrsOBYl5bcrs2dp5TkNkW5G9VyUXERWhey3nGtGfasPGjch+5RVgzRqtF7x//6umkTjiRC+sZXEu9dz06dp0AUZVOLyekT3ORCymCa4glCrl89ssCHaAPucnIEATLCw7yOtGLRcwNcOjd50bnZ6s+6ZQpNBQ0nToz5AAYZFP3oiO8oy3t7cSK9wGMTEx2LhxI3I4s4BTonUyMjSDuEce0UJ1ZjDSxW4isnPnTlUrRS/OBx+kizBrWfKDUiz7EQRrI0JFEKwsVIKDtU4NdtQyIFBe0NtiCxYPXw+MHpznob5qpTVzxGOP7bp12nkH6q+l2GAaiFEqbpctW7aoTh4FP1d0cuMH6uefgc6dNYc3M9jWTcFDV/C9e/earueM19jY/OXeekvrghYEayJCRRCsLFQSE7WvYd4YrHIFW4h1Q7aQkJDrfhy9NoXtyCykVdCZlWkP0qaNtkN2IDjNXrfaP3v2LLZv367qeFTa6/Tp/AVpZsNhhklJpquYPmMnETl+/LhKqxF6yOkty+wG+usvzbZFEKyJCBVBsLJQSUrSajcqVCifbwW7VQYMGGDpeXKNdvns9iF6ykLBATW6ydmOHcCXX8LRoOssty+jV9xG9EhRW4QdQd75jsCq+KmAIRzdavWJ0xQ5esTrxRe121mbnBfEEgSrIkJFEKwoVLTuivIbUSHcifr5+Vl6nlwDx44dU9uKdvmMIig46fDXX/MXYi3MsGFwRKpVq2aaC8RttW/fPhjDwgB29eg1QmxdZlSlwIRItivT84atyrwfYVkLHfrJmDGax4ogWBMRKoJgJbjzTU93QU6OoVwLlRuBR/l62odW8iaxwx0wd8R3361dfuMNrcDCQeEkenbzkEOHDmmTkuvVA2iOx44otvZs3w5066bNQ8qDBbnt2JucJ3L0FBBnObKxihMIuIlTU630wgRBhIogWFeoHD4cCE/PXFUDyuyF+aA4gfvZEyaDN9PwwUuXtPwEc2W0VmV78hNPOPzmYhqnZcuWajvs379fDW5UToL33ae18bAziILFS5stBQ4ozM21SAGxKJepNo4S4mxH1qkw0KIPLOSYB/NiW0EoCySiIghWFCrHjwcgLc1J7QRopHpBM3IV8raP3pLMqcym9mZ2+rDDh+3IrPNhRKAkRjKXA7Tp1U3VeU5KZnRFQVOUFSs0m33OCFq5UnPvffRRNTqZAofpOQ583LZtmyrK5Wb97DPt7mwe4kPQX4VtzOKvIpQlIlQEwYo74rS0fLM3wiNZQePMmTPKgdXDw0M5qpo6WL74Qjv/9NOaG6tgAYVKk7zWHbYem8RKp05sm9JCd7ffrlXLUoHccQdcMjPRsWNHJQZpAsdOIDJqlObSz6waNQ7h/zfflI0ulB0iVATBikIlJcVsiF6ej4Wg2eWr1EWeb4pytWXY6f33gbQ0uskBTz0lm+oKcNZSoWKF/PefZY6RdSxOTqpYWZ8FxGgMhxcyJTltGkCnfnMOHJCoilB2iFARBCsKlY4dI/Dww1mqu4Lz5HTDVUeHJmY0eaPfh14/gf/9T6vyJK+9ll9rIVxRrOhpIIoVVWBLXn5Zc3LTYXpt/nyTKGTLMz+bmzZtUsXM3Mz33qtFUShcWB7E+lwJZgllhQgVQbACdBHlKSbGGz//7Irly4E775S3QkePpoSGhsKNFZ3p6dqeUvcC2biRw5Jkg10FChVdrLD9ODw8XLthwgTg22+B5s210Aj7kb/+WnVVsdVZnyVkMpHLu8sPP2gzgUaPvsyWRRBKDREqgmAFdLvz9HStxkI3WxVogJeEC3lVxSa7fE4IZq+sDkVKOZuOXFpQqDC6oncDMbqixMfjjwMbNmgzgniZ6uPdd+Hh7o5O7dop0RIREWFqD2ctc1wcEBkJ/PijFuAShLJAhIogWNGVlj4qRIRKProLLVMQnEejMK+poEB5990yfLfsH9ar6PUnrFfhMEIlVti+vGiR1s6j+9E8+SSC7rsPvRi1MhpVvcrFixfVzWPHao1ChCkg3pWwZVk6gYTSQoSKIFhRqGRmakUp5m7njh5p0oUKpySb+Pxzzfdj/Hjg9dcZarHeStopNMzTTeHY1WMaZOjhofnR6AqEQx7XrkXQZ5+h56+/wpCVpepV2IHFGpVvvtF843hXzj5kbRVbmceNk3SQUDpI7FQQrEB2Xn1FRoYmVCSiokFnVO4QWZdy2WwgRgTyogLC9cHCZLrRUqSw/ZvFspwVxKJlVYBCxWw2Myl46VJU698fES4uWL9+PXr16gV3dxclTtjtzC7me+7RBMqUKZwflD8nUhBKComoCIKVIirZ2U5YubKWurxqlUPO1CvUiVa3hFctyZyKlzcsTygZatasia5du6rtGxUVhXXr1in3XxUuocMbW9DyMNx2G1o2awZ3d3fExcUpgcOUEUcu0U+Fusa8qJZ1K+JcK5Q0IlQEwUpCJTXVFRkZWlCTI1bOnHHst4KuqDQbs0j7PPwwcxbAkiXWXblyRpUqVdC9e3cVXWH9yapVq5DKgT4UhwyN8DRggMrreN18M3rFxiozuHPnzqliXMKu8dWr82uaa9YE1q/XjG8FoSQRoSIIVhQq5nB0jSNz+vRpdbQeEBCgzMeUVwr7thllEYOZEoeTqHv27Kmcf2nutmLFCsTHx2s3MqpCzxqKxLQ0+A0fjj6cqZRnxHciz7m2bVvNhoWFtWwgatCg5NdTEESoCIIVYBGjwWBEixaxYH1jw4aau7mjQoFy8uRJdV7Z5W/bprnQktBQrSBCKHEqVqyIPn36qDk/rA1auXKlMtszbfdNm4A+fbRlP/4Y/X/4AaH//QfXIUMQlde2zOAXxy/pMyP//FOzvRGEkkKEiiBYSahUqpSCTz/dhe3b2TIKDBvmuG9FbGysMhhj3QRrKDByZP6NjKj89Zc1V69cwxbw3r17qwgLi7xZs6KLRhXmW7xYm6vEWVTLl6PNd9+hxubN8O7dG7EMo5jBWZF33aWdMjK0+hVz935BuB5EqAiCFQ3fTBOBHRx9x1i9enW4sU4lrw5CQffU++6z3so5AOyyYs0KRSKjW5ygzFoU9Tll2o2DIL/+Wi1ryLuP39mziH/33fx0kVn32r//arb7zz0HhIVpGTxBuF7kV1IQrOij8uabzTFwoBZhd1TYIstWWVMRLaf75gk5tZOcNEkGy5QBjGZ16NABjRs3NhnDbdiwQb0/iiefBN5+W+sOooNwvXrY9dBDWLt2rXIT1qctsw6XLFyo2d8wDXTbbVpgRhCuBxEqgmDFiMquXRVUQ4vZQanDQZHClIOvry+C2TLCmT6EBh2MtNx8s7VX0WGgbX7z5s3RsWNHU/syi2x1IaLeG9YPtWsH97//hk9wMJxPn8aGf/4xLcM63Pfes3xcipWdO63wgoRygRi+CYKVhArz9/qsH0d1pmWagS6p+gBCA9tjWUTL6b6c71OtmrVX0SFhCsjHx0dFVFg7RLFCY7hKdHRj9feWLXAzGNAjJARZo0bBkJKCXZGRCHviCfhkZeHVVyuqtmUOaiYsFOcoIUG4HiSiIghWs4r3R06OFkaPiKCdvuO9FRw+yBoHHr2rbh+mFW6/XTv8ZmusYDXYJt63b18EBgYqQzimeJgOUjOC8tI/HkeOwCcmBj4XL6Lzyy8j4oknkMv3bcwYvDQmXXU4c9GEBC04JgjXgwgVQbCSUFm7trbp8pAhwKVLjvdW0JODhFatCnfzach5O0LBunh6eiqvFYpIChQW2DLKopxsSceOMOzYgdzmzeGck4PGv/0GJ06+ZvFt+/Z4qu8RNUbon3+0olpBuB5EqAiClYRKaqqbxXWONu+HkRR6drAuoumsWZqlKS3czT3ZBavDaFe7du3UQEN2qdE9ePny5aqlXNGgAZy2bEFO794W98s9fVrlNNmq3LNn/vVxcQC943ji0GZGWwShKESoCILVhIqlM62Xl2NGU+rl5MCNra+JicDYsVrxrIgVm4JikgMNaQ5H35WUlBRlDnfs2DEtFeTpCefly5F9//3QZaYhKQmXDh60eBx6q9xxB9C9O9C/P7BgAdC5M5A3MFsQCkWEiiBYqT25XbuzpsuMlLOO1FHgjk5vSW7GKEpeu7aifXtJ/diwk+1NN92kJltTbO/cuRObNm1CBhWIkxNcZs1C9h9/ID04GOfatcOquDicPZv/OWcQhpkhLq53uoWHA489Zr3XJNg+IlQEwQrwR75p04sYMyYKb7xhMv50GMLDw9WReOUKFeDKSIoOJ92NH2/NVROKYQ7XpUsXtGjRQkVaKESWLVumCqOJ6113wTUiAmcnTkSu0YiNGzfiMItwFy5ElQpp2NnnBbRvlP+ee3jI5HChaKQ9WRCsJFQCA9Pw+OOX0KxZFZtZJ3phxMXFqZZUTjPmkbLu+cJaBXd3d3Vi6yrnw9D7hJevtTblVF6sv93s2QDTAwwn0aOjRw+VRhBsGwqURo0aISQkBFu2bFGfm9WrV6Nhw4Zo1qwZnN3d0b5vX7ju2qXazxM/+wyGadNgrFULHqdPY3PIL3i1w2x8sKWX8lh54AFg/nzOebL2KxMcTqgsWrQI77zzjqoU54TOHj164C+zmR38sBdk1qxZuP/++0tztQTB6tiKhT6jGixojYiIUOZeKoR/jVC0BAUFqRPnxVC8XAm6nPIIm8/bets2eE6frt3w8cdafYpgdy3MTAXt3r0bJ06cUHVH0dHRyuHW398frVu3Vp8H4y+/qOUNLLDl/wsXMCnpFtSfdBKj3qyE3bu1Sczr1gF5xriCUPpCZd68eXj88cfx/vvvq4FXdJ7cv3//ZctNnz4dAwYMMF1W490FwUEM36wlVPj8nK/DHUtycrLpehcXF/Ud5E7Gy8tLRUu4jjyo4HeYQoaRFh5B85SamoqM8+cRv28fErOzcdTVFYbQUITUq4cqVaoo8cJIjP6cmzdtQu7Jk/D380NdFuYQtoVwKIxgl/Az07ZtW/V+c0YQI2bsCmrSpImKujRo0ACR06Yh/Pnn0fj332HQC6WDgzF8cBwadquEu+/WJojXq6fdRNd+fiyGDtUMigXHxmBUJdslC3/Q2Hf/9ttvY8SIEVd+coMB8+fPx2D2qF0nDFHzRzUhIUGFogXBHmAB4tSpnpg1qwV69HAq06FtjKDs2rXLZHnu6uqKWrVqqYGAFBaFiqdz56AOe6OitIGBx44B0dGqyyPZyQkVXnjBtGhKQADSgoKQGhiItCpV4Fy/PrybNkXmqlUI+PdfeMbFIXn1alTg4zD1wyEwLFQQ7J60tDTs2LFDtTATil62NrMIlwJmx++/o8PrryuDOAXThhMmIPKhF+Hi4YKQEO3qZ5/V5gSR4cO1+UGO1r7vCCQWc/9dKkJl69atKvT3448/4vPPP1c/jK1atcLHH3+s8pemJzcYVPU4j9Jonz1q1Cg8+uijhaaEdLiseXiaL7RGjRoiVAS7gqZZd9/dAufP+6of5wkTgKeeKt3n5AHEnj17TJb1jJZwAB2/ezwqvoyYGC0ds2iRZn5RGJxCx7oSFhlcCy1aKBt2VZvCwYNCuYG7FHZ0UQzTGE6vZ2GEhZ9BRtWc/v0XLX/9FX5RUTC2bg0DTVX4WcjNxdwRS3DvjPz5Tvx48OZWraz6sgQrCpVSSf0wV0neeustfPrppyq6MnnyZOVweOTIEZXXJKxfYVqIIWZWjT/11FMqDD2GU62uwKRJk1SkRhDsmZycXJw/rx0islmC++zSFCo80l2/fr0qlCX16tVTw+cYTbkirHKcOdPS04TTjZs31+ztOcCFc18Kiphx44CgIBhPn0bWkSMwHjsG16goOOlTeAmjKTNmaEJHKFdQmDBCx7lAbF9mV9DBgwfVf9asdOveHeFBQVjWogWa/vEHkvr0QZO0NFXrhOnT0XvGS7jZ8Av+NWpipV27/JSQ4JhcU0Rl/Pjx+PDDD4tchh9IfjgfeughTJs2DSNHjlTXMwrC0PK7776LJ554otD7vvnmm6pmhYV9V0IiKkJ5YNmydejfv5vpMkUK56KUBjxa4ZwWihVGURjtrFy58uULstCR3+///U8LyRNaiq5Zo52nqKGNaMGuHN5v4UL2rWrihkUFFDHm8GeG9Wd8jFtuAYYN0x5brPLLPfw95z5Bj4Rz4GHLli1VKogdQ4y6MKLXpkYN1OzTRxnFcac0DSPxEj5CEvwRGqrp2m75XxmhHFAqEZVx48ZhGH9gioBhZHYPEIb6dPgDydt0k6fC4A/oxIkT1Qf6Si2PenukINgz3J97eGQhPd1VTZktrfw7fwjWrFmjCmDZfdGtWzftyNWc6GjNce7TTxl60WLseQcYePVVLdxDG9Fbby3cMbZWLeCZZ4peEQoSho7ku+twMDXP6AqbKZh25D6ANSwsA+DQQxbgXrx4Eaf//BM1U1LUfZj8f6LCXGTc9xxe+dkfDNIzw8ia6/fe00qafvxRK7alPhbKN9ckVNh6yNPV4EwIigl2FHTt2tXUlkjvBIYErwRb3Fh0JUJEKO94eWWgZcvz2LKlhtrHf/BB6bi/6iKFRY20B7jsu/Xtt8Do0Sxg0S7z+1mtWv7tfftqAqOIluNiIyLFoU3imPapU6eOKrblnCD+3rPzjNEVRvj2GwxY8vHH6Prpp/A5dw6G+Dg8O60JBnYdjmFJn2PTHm8V7Dt6FBg0CGBgnpc5fYGW/EL5pVRqVBjCYWHshAkTlJqmOGEhLbknr9fs77//Vv32HTt2VB4rbGdjK/MLZt0DglBeYatuRob29fP2LvkMCIsWWbDLdA+/j927d79cpLDbjsNWdB59VLMINR86xA6gkhApgpBnwc95Qaxj3LdvnyktydZm7gv2+/hg8aefIig8HGHLlqHipk1osP5HrDP8jE/b/4Y3996Nt2OfQc8xk6l8ceAA0KuX1oTG8imhfFJqPioUJsw7Dh06VP1YMq3DIVb8oBIW8X311VcYO3asqhJncR8Lb+m9IgiOIFTS07WvX0mnffh90v0sKE6Y7uHBgNmTA6+/bilSyJEjjjcZUbDagEPWLHKUAgcbslyA3aFsvKDb7QmDAcubNEG1fv3Qbs4cuB06hBfPjcWI6X5Y+sAlpJlNf+nSRQsECuWXUmlPLkvER0WwR/7991+EhzsjNLQjwsL8S/RokHUADK/TD4XpnsvStSyQ4WHo5s1AYCBw6RLQuzfw88+WaR9BKAPo50P38nP06skzkGPBbUxMjPp9N+TmosWuXajZrBk8v/mGJkTYgxZ4Et9gt1MbpOW6o3VrLQ0kKaDyuf+WoYSCYKWISs2aCejZM6dERQrb++mVQth+XGhNGaMrjKa8+65m4sbqxGXLRKQIVoFF3hxySPsKRtyZtmRqiJF4FuEaXFywp00bLHZxwcXQUBjd3NASe7EG3THYZSEMBiN27tSKbelmS5sgHn6zDpzXC/aPRFQEwQr8+usSnD8P9OvXGVWr+oEZ0Tyn+euGwdFVq1apI1EKFP7wm8wTWSzLQYBiSCHYMPwMs535wIEDFs7JTF3qlysmJaHrjz/CY+dOGNLTsRNheN71S6zJ6qxur+16Dg833op39t6hLg8ZArz/PruPrPjChEKRiIog2DDr11fGiy8OQMuWfhx5gh07bvwx2VVHkcLQefv27fNFSmysZtJG5yxGUATBRuFnlmmf/v37q8+wt7e36hilSKFgYfdQnK8v/n72Waz55RekjB6N1p6HsCqrC+ZjMOo5HcfTWZPx5958h7hffwVOnrTqyxJuEEn9CIIVSE21DJ/caEEtTbOY59f9i/gDr6AbbMeOwKFDQHw88OefN/ZEglAGsL6KhbUDBw5Udhd0L6dg4edcH5J5ITcXi7p3x8Zff0X6M89gsM8KHMhthDvxJ4zKiUWjd89cVbuSkyNvnb0iQkUQrEBKikuJChWGymmUyHx//fr182+4/XbNeEJn6VKt60cQ7ACKEnYIUbBwQjM/39rkcaMpYng2Oxt/d+2KLXPnAncPRh2cxm60wnd4DJV9kjDhhRQc+2O3qgX75BMW72qPTV/SIkzQBRtChIoglDH8kW3Q4ILp8mOPAXnjr67b2E0fNBgWFgZnvdiF8e7Vq/MX5A8725ILm44sCDYMP9N0NmdKqHPnzqrotmDD6unERPx1zz3YPncuskeOwGNBC3DyYAa6h0/FpHt2KFHy4ou08Ddizp1z8Ordh1G3rlGNrxDB4qA+KoIgFA6PCKtXzzusA8AZmzcSUaEXBR+THRKmGT6ZmcB992mW+EFBWhSFbRC09BQEO46w0H+lWrVquHDhAg4dOqSMQ805kZuLE336oOq996KRB+CxYwfexyoEIQbf4EkkxXuh2vwv8CtWIRsGsON50SIjTpww3HBBu1A6iFARBCuavZEbESlsR2YRLWnatGn+DS+9BGzbprUSzZ8PNGjAGRg3tN6CYCsw7UNhzhM9OI4ePYrTp08jx6wQJfLSJUSuXImgkSPRdMgQfDBnDl6ZXRcrs7tiHu5CNvInh3fvLiLFlpEYsCBYWajoda/XA6eVMwTOH+wgRk4IQ+JM7zDVQ48UztsKCZFJxUK5hIZhrF8ZNGiQmhtkKiTPg51wa1JTsei++xCzaj4Gd7mIiXgdn2AcQhANF2Thrbfyl09M5AGAdl4KcG0DESqCYMU5P/Reu95wM1s29WgKJ9HmPbgmSDgJmT3PTMoLggPA1uWGDRuqwlsayHF+kDmpqanYGRmJ+WPH4tTvMzCm1y4cqz8Q039xRd26eQvNmIEpraajWkgmPuv7NxrUz8XLL2vmzYL1EKEiCFYRKs43nPbRoymsSwmkFT7bGJo0Af74Q1sgLEwKZwWHrGNhDQtnXN16661KxLO9WYfpoXCjEfNHjcLGz99Hp07HVeszMU77Fr+e7Iw6aeHwXPEPTpx0wkcfAdWqGjF9uhVflIMjzrSCUMYwEjJ06FmkpnqgUaM6yovtWmdx0tFx6dKlSqj07dsXAbS27dxZm99DWEj71VfaLB9BcHD4Pbl48aLqjuNMIR4sFCZuGkdGAvP+w7nZ6zDAuBhnodnZGpALF0MObr8pDe985ofGja30QsoZ4kwrCDYKfyQ3bqyB5cvr4IsvgFmzrq/Thz++VatWRQB7m3/4IV+kkFWrtFoVQRBU8S2nMnfq1Am33347OnTooC6bfydp3b8sJwcbb2qPWoYzGI4f4YtEdbsbMpBldMUfy/zyU7UZGUiLTVPTKYTSRVI/gmBnXT/x8fE4c+aMZafPunWWC02dqrUlC4JgAa34a9WqpWZh3Xbbbcp7iAW5Osne3lg7+R080msNjjvXx+j2K7Bx/DzMafsxnhuTqxroFNOnY3LwJHi7ZeLO9mewYkGyMoIWSh5J/QhCGcMuhOrVK5gKah94APjtt+Ldl7n01atXIy4uDjVq1FBHiMrUrVcvbYFhwwDm45n2EQThmowTGVVhgTpTEsQzJgYZ/v7IzZszxHowOj8zimlo1gw3h3+MxbhZLWtADvycU3Fr89MYPMQX/R+vCV+/fCt/4fpTPyJUBKGMoVHVyJGXsGBBYwwYoIkUlphcDVrkr127VokUHhUOGDAAnsy1t2gBnDhBMwgt5SPOs4JwQ6Snp6uo5cmTJ9VOtCCuOTmo+fgXaJuy0XSdE3KQi/wWPjenLHz9rStGjJA340aFihi+CYIVUz8UKMURKWlpaVizZo36Yru7u6N79+7w9PQEnn9eEyk8zzoVESmCcMN4eHigQYMG6sQoph5piY2NVd/f4J07kZrijKbYjwPQrAHevHcdql48g0XbqmJZcmek5XqhUUMW8Rrg75GB+JvuwcSs8eh/uwd6PtEQPpVuwEDJwRChIghWFCrFqU9hSJoihS60FCcUKf40tVq+HPjsM22hd98F6uWPthcEoWRg9JJzhnhiAfulS5dwrGZNZISE4O+/nsT+zRXwSYuPUe+2GLi6emDIU/F46tI8HElsjzb/zcaIe7thWUIHtE0dhSXojC93Aq4TMtHFfyf6t7mEfvcHoNWQZnDydJe37ApI6kcQypizZ8/i7ruN2LKlBsaO1bzZikr3rFy5UrU003GzR48e8KG6oZXm7Nn50wxZTCuDSgShTOH38/SePTiTmKjSF+YW/uy66/TcBDQ4vwvp8FRXeTulIjPXGVmwFCVBhhg89HQAPvvcsfpbEiX1Iwi2bPjmelX7/OzsbGzYsEGJFEZSevXqpRlX0dCNkwyJqyvwxhsiUgTBCjAN26B9e+iNQPyu0qslKioKLnv3YvH57iaRQm6//xhu6XUA0auNOLA9EBtO1cOhjLqIMQYhIX9OKfDBB/huaQ1UG9ACPZ5sAm8/x56WKKkfQShj0tNzkZysCRVf3ysvt3PnTtUhxNAz0z1KpKSmAhMn5i/Efsj09DJYa0EQroavry9atWqlTvD3x4GWOzBuzyf4BUMRYwhGt26n4OLnjGq3AdVuS0A/7EDlPz7CF0tvwd4VLTBpoguGDvNHpW++x/NndiF5tS9cx2eiS7UTGHSHC24fUwt16ztW1IVI6kcQypjvv4/C449rc0hcXIB584DbbrNc5sSJE9i+fbsyqqJI4dBBJUhuvx1YswbgZXqp3HILsGCBRFQEwVY5eRJZs+dhR7fn0KxVuirKPX/+vEp7MGra7Y230eLIasRAm25eu0YsZvSejAl/3oFNSc2RWSBN1CQgCrfd54Vx7/jbvVWSpH4EwUZJSck/T1dL9wI1dMx179q1y2TopkQKF7znHmDZMm2hMWOADRvUEDWpTREEG6ZOHbi+8gI6qgs+avaQPkQ07cQJrD1S3SRSSMvW0Yi+uSWeuvkEno7ajYT/MrFrsx8WxHTDWdRCeGwVHPvBiFc/zLtDbCwuxhjgXb2islAqjzheDEkQbEioFOz8Yf3Ktm3bVFEezaUac6gIrfCfegr45x9toW++AcaNA/78EyjCe0AQBNvGMzoarlWC0RX5ztKDBzspczmSW8UPvkOD8Mid63Cn298Idr6ELl470LtrpnIkUEybhomNfkWQbzpub3oUP0w4g3MRlrOM7B2pURGEMqZu3XQMGnQITk6BcHMLRuXK+bcdPXpUeTWwLqVt27YwHD+uDQP67jttgffeA0aNkvdMEMoDnTqh97mO6L1nD85O/xgLqozC0KEN4eTUQLVBHzp0SKWJKu/chX8zX8BFBOJiaiACd6dgxYo1qFWrJuovXYqlxmlIM3pgYXh9LHwHwDtAE/+zuKlDIm4aWgU9Ble8oUnt1kZqVAShjNm/f78aKli3bl20adPGwi9lyZIlKppCkRJKR0xORNaLZZ94QoumGMSWWxAchdy0NBwK7IKmaTtN1/XseRJPPrlNnXfKykKFA2cQtTwbF3Yn4fvsYTiDWkhFfkvht9/mT2jPjYlFjn+Aahi0NjI9WRBsFOqPDz/sitdfr4Po6Pzr9+7dq0RKcHAw6vCKfv3yRQonvX70kYgUQXAwnNLS4HHXIIzxnY7GCFfX3XSTUXOmpvBwdUVsq7oI7R6PpGwvHEITJVIMyEV75+1wc83FTTflPdi5c9gR3B8V3FPRp/phvHX3fqyce0k1E9oykvoRhDImIcEJO3dWVef1EfEM89Kmm7C10cBUT0xM/p043VVGswqC4xEQgNBf3sYU1qodO4azcZGo0CQUPj6hyMzMVL8bp0+fRuXwcKzFi6a7ubnl4LkfjiPXeArh4V64cCEI9bdvV+mjasaz2HquClbO8wPmUQhkoU3QaXRrlYxez7XEzbfYVtRWhIoglDFJZsZO9FGhLfeePXvU5dq1a6Mih/+8+KI2t4f/WcTCbp/AQHmvBMFRMRiA+vVR3ewqFt0yhcxTzkvjEY4mptsaNIyFs5sBzqBvU7I6nfX2RkPDWRw1NjANUjTygAmu2BJTD1v+A7ZkADffkvcgy5dj+Vp3VOndGM165XcmlTUiVAShjElOzj9aYYHbuXPnlLGbs7MzmlWrBvzvf8CzzwIvvADwcqNGVDDyPgmCcEWcN2/E2Z17sWfuaqw7WgnVHuqFAQMGqmiL7tviGxmJ7cb8ujhOe3753gWoHX8Ehw6FYGt6W7RsWRkZs5fj59+8kbLzMH471w19lu3FpC19YC1EqAhCGfP339p8HlfXXCxcaISb2151uVGdOvB66CHN0C08XOv0eeABeX8EQbg6Li5wad8abXgyXelr4duS9eWXeBYdLO5Wq6cTAgJroTOAzjgA4ACiP/scX2yain0YpJYZVneBEjp+VrJDEB8VQShj1q6tqP5nZTnhvfcykJyUBP+UFDT+4ANNpDDEe/PN8r4IglCiuI4YgQ//a4tVY+bjwzZzMOyBNNx/f1fl1xQUFKRmFxGPU+dxEI3V+SpO5xE8KBVbtmyBtZCIiiCUMWlp5gPGEtBk3jw0WbAATpmZ2lVTpgB33CHviyAIJYunJ3z7tEfPPkDP/Cu1urg8jBkZ2Df0I1W3QppUOKGiNYFWrJEToSIIZQgL9zMy8gOZ1SL2o9n2ufkLDBkCPPOMvCeCIFgFg7s7WiRtRPzWfdi7+BxcKgei0z33qKJ/ayFCRRCuldxc4MIFzeOEJ7YOV9GGDFqwYweMmzYhKzEV6QnpcBn3FHK9PPHGG8ewYYMPKnom4q0VL1jeRzp7BEGwNm5u8O/aHN26NjddxQGp1kKEimD/UOmnpWlDdGhMUkA08Egg9/x5ZM2ai9T4DKQkZMGlX1d4dG6uZuvkZGcjJz0dxrQ0HHj5Lxzdmor0LBek57hh8OKecNu3T92mn7IvJuLlr3sjA+7q1LXZZnT5IFiZtTmvPYisFaeQnQFsOtUQU9KeRk7e1+yDL1+Df+VcNJ0UhqZNtfWucyAJOJm3oo89Bnz6qRU2oCAIgu0iQkWwHhQVtGllhCI4WImGrKws0ylj5wEkzPoPSfE5SIrPRsCInvCoH4istDSke3qqEelcbsvgFTgUWx2J8IO3azpG3LYJ6ckGpKcakJkK5LSvgTj3YDzx2RjTU4/86ltUdlmLjGxXpOe4Iw2eSIUX4tAUi/Iq3UngzGn46Mu+6jaKknR4qKa+NOQPzqgcm4xWKcnq/J6NlfH+7pfV+V5YYRIp5JvUx+AZkYm3oXmmVK1WDR4TJwLnz2sjlEePFudZQRCEAohQEUoERi2UwDh8GLk7dyL7QgwSo5KR+cBtyPJ2R0Z6OrLi4tRIcp5Wjj2LyLRgxKMCqvpeQpsfqufnQBceQsL6RERcDMDE1LdMz/H4imlIRzQqV01B2//lF3bNj70JG9FFnQ/JisaMeQ9brNsTaX+g/R2JFtcdzGmEb3NGXvY6emGlxeXsHBecQF2L62hN7YxskwjJznZVbXv0QXGt5Q9sAlwM2XCilZJZWreWz0W4hoagadOm8PLyUuZuhq5dr2NrC4IgOA4iVIQrio709HR1ysjIQFpiEpLemYG4qCzEXgRc6/ghaGAQnC9dgkt8PJwTEpERl4s1G0Mx5eJIxCBI7ci/Mv4E//QYbJnmigSjP+JQEfFojEj0wXHUU8/XLGkfWhsPmp5//Z4G+OL0/QjDDov12ofm2IzO6Bi/HW1xAk5OTurkbsg0CYIUeF3+eirVQr3mlsMsfNwz0LV2JDy9jPDyMsDLG/D0dkLiJmfgfP5yvYffjZ865sLb2wkeHlrgw93dCQ/enIBcoxPcXXNRu2t9DBigGbL17g288Svg7OyCVfNao9r0S3D3coaHtzPGjm+FOg218e2CIAiClYXK6tWr0atXr0Jv27p1K9q1a2caxDZ69Ghs27ZNDWN75pln8NJLL5XWajk0uTk5SM/IQGpqKtLS0tR/npK+XYyLS07jUpw7Lqb4o/uIBHhlpiDtYi4SYlwRH+cBdKmG4b9PRCa0Pvs+h/5D9mIXJUh4uoRA1c7WBesY8zA9Z3qsETnuFfGFcbjFujTDPtP5ZHijWpVa8PZ1V338JzskotKJBPgbsqg8TNQKSUPTLjFo3Kwe7r23ren6Wc0OUcXA0zkT3u4G7NgJ0JfI2xvw8mJnXTukJmTh8TsuwtPHGV6+LujVvxv63cY0jiWnTlXG81Ha/TjzKzTUH43zn8pERFJ+Ox+Qf97ZrPO4110B6HXXtbxDgiAIQkEMxlLqOeKwpFiG+c144403sGLFChw/flxVENPprkGDBujbty9eeeUV7Nu3D8OHD8dnn32GkSMvD8vfyJhoR4A1G/pMh5SUFCQdO4MTz/2NmBhXXEz2Q63QBDTvGIeM81mIq1AZKXe1V/dbOcEJ0w7dbXqcNtiGfWhhEiXk6eZzMG9/N0QZtWF6rbEdO3H5HrwDNmMLOpouz3puLdo+0gyvjc1ChUAXVAhxQ8XK7lj45RlsulgPTshFnYB4HL4QYLGTJxciMvDl5Az4BrnBN8ANXbs7Ic9g0QI23nBkecH7C4IgCLZLcfffpRZR4bCkyhymlgdTCQsWLFARE73NaebMmUrQ/Pjjj2p55u53796NTz/9tNhCpbRZM2U3LpxKVY0lXn7OuPUdS/thknA6Hv98sF8tQ9rcUhmNB2lpDXM2Tt2Lw1viTcsN+74rnFwszYFzMnPww6PrYMxlNsOApp390e2ZVhbLUFtueONPrJ2fgJgLRsQke2HYs4cQ05qtJBpZP4fj6DID3s763HRdryMrsP5IN2TBDV29NuOZu86o6ysEZlg8PgtHzUWKp0sm/Ju2RMjRJESl5y3jFoB3x2ciqKobgoJgOsUeqYf3Jl5ASAgQEOyMhve0Q71WnpizynJbjHy6nhIXPj5OMBg0S/mChNRwxzuf5a/HlWBKRhAEQSiflFmNysKFC9Uo+0cffdR03aZNm9C9e3clUnT69++PDz/8EHFxcRZueTqsl+DJXJGVBozuLH9vP37/PRRbjJyCAFRHBL6fukKdp4ioUzUOAz7wxsVNCXh46n2m+97z4x9I8TsLo9Fgqp3gP6+sJPyZfKtpub8XLUNyVn5NBZd3ys3C8uR8z8AhGxchqW4kEg+lYOqEGupxco1ArdQ0zDRLpyz58Dw+/3kVnNy1sMLumAb4JOtBVEAc4vNSE8nwUSKFXPCogwEDmsDT0xNue/cAG/Jf+x0PeuPLEVqXb9WqTKO4wWBohPpfpyApKwdBlZxRvXooCq0DbRqEJcUwVQ0oXJsIgiAIgnWEyg8//KBESPXq+UOqOdGxTp06FstVqlTJdFthQmXSpEl4++23S319o6OjcfKAEzKNmo2wLk4WXMyfINk1dTM6J55BKj08zO+bFYS1l/LFhs4gt38sLq+PaYkYaK9XxwV5Nup55ORyRHcakmLSsCY5P6UCZFksxyoR/+yKqBFWHT4+PnB6KBPdE6Nx9kga4nPyhEqFmlj5pyY+qlSppOo4SPun2uKXRvr1HNRbW9VnFOSRp7yL2GKCIAiCYANCZfz48SriURQHDx5EI46mz+Ps2bNYunQpfv/9d9worGV5/vnnLSIqNWrUQElTtWpVNGxzCdvDM2mbYWJYnUXaGQNQvXqqGuSU6x9vcd+aXtF4rPrfXAQGg1HNmCOxUU4w1yFDWq5DZparut1k+peTjS8P5ldguji7KPHm0yQVY8Pmq+vY6XLunJdFd8rz45zR+8EBqiuF1H4GuPsZYOVKrXaDAqRKlSrw9S3stWrO7YIgCIJg98W0Fy9eVCmcoggNDbVI50ycOBFffPEFzp07B1cWJuTx8MMPK6Hx119/ma5btWoVevfurQpxC4uolHUx7bafwhF7Vmtt9fRzRfdnWl62TMqFFGz55Yg6b3AyoF7nENTooBWdmnNsxWmcP5JoWq7TiCaX1ajk5hix/ddD2jIGILiuH2p3qXbZY0WfzUL0BQOCq7jQK40zowRBEATBbiju/rvUun50+PB169bFnXfeiU8++cTitm+++QavvfaaSrPoAubVV1/Fn3/+iUOHtJ311ZCuH0EQBEGwP4q7/7Y8nC8FVq5ciZMnT+IxzjEpwIMPPqgiLyNGjMCBAwcwZ84cTJkyxSK1IwiCIAiC4+JSFkW0nTt3tqhZ0aGSWrZsmTJ8a9Omjar3ePPNN22mNVkQBEEQBOtS6qmf0kZSP4IgCIJgf9hM6kcQBEEQBOF6EaEiCIIgCILNIkJFEARBEASbRYSKIAiCIAg2iwgVQRAEQRBsFhEqgiAIgiDYLCJUBEEQBEGwWUSoCIIgCIJgs4hQEQRBEATBZrH7mbu6sS4d7gRBEARBsA/0/fbVDPLtXqgkJSWp/zVq1LD2qgiCIAiCcB37cVrpl9tZP7m5uYiMjISvry8MBkOJqz0KoIiIiCLnEAiyreRzVTrId1C2lXyuyu/3kPKDIqVq1apwcnIqvxEVvrjq1auX6nPwjRGhIttKPlfWQ76Dsq3kc1U+v4dFRVJ0pJhWEARBEASbRYSKIAiCIAg2iwiVInB3d8eECRPUf6FoZFsVH9lWsq1KA/lcybYqr58tuy+mFQRBEASh/CIRFUEQBEEQbBYRKoIgCIIg2CwiVARBEARBsFlEqAiCIAiCYLOIULkCX331FWrXrg0PDw906NABW7duhaOzdu1aDBo0SLkI0gX4r7/+sridddlvvvkmqlSpAk9PT/Tt2xdHjx6FIzJp0iS0a9dOOSaHhIRg8ODBOHz4sMUy6enpGD16NAIDA+Hj44O77roL0dHRcDS++eYbtGjRwmQm1alTJyxevNh0u2ynK/PBBx+o7+Jzzz0n26sQ3nrrLbV9zE+NGjWSbXUFzp07hyFDhqjfJP6GN2/eHNu3b7f6b7wIlUKYM2cOnn/+edWOtXPnTrRs2RL9+/fHhQsX4MikpKSobUERVxgfffQRPv/8c0ydOhVbtmyBt7e32m7c0Tgaa9asUSJk8+bNWL58ObKystCvXz+1DXXGjh2Lv//+G3PnzlXLcxTEnXfeCUeDztLc4e7YsUP9KPbu3Ru33347Dhw4oG6X7VQ427Ztw7Rp05TIM0e2lyVNmzZFVFSU6bR+/XrZVoUQFxeHLl26wNXVVR0ohIeHY/LkyahYsaL1f+PZnixY0r59e+Po0aNNl3NycoxVq1Y1Tpo0STZVHvzozJ8/37Q9cnNzjZUrVzZ+/PHHpuvi4+ON7u7uxlmzZjn8drtw4YLaZmvWrDFtG1dXV+PcuXNN2+bgwYNqmU2bNjn89qpYsaLx+++/l+10BZKSkoz169c3Ll++3NijRw/js88+K5+rQpgwYYKxZcuWhW5D+Q5a8vLLLxu7du1qvBLW/I2XiEoBMjMz1ZEdQ1rm84R4edOmTaWrGu2YkydP4vz58xbbjTMcmDaT7QYkJCSobRIQEKD+8zPGKIv59mJIumbNmg69vXJycjB79mwVeWIKSLZT4TBad8stt1h8fohsr8thaoLp6tDQUDz00EM4c+aMbKtCWLhwIdq2bYt77rlHpavDwsLw3Xff2cRvvAiVAsTExKgfy0qVKllcz8t8k4TC0beNbLfCJ3yzhoBh1WbNmpm2l5ubGypUqCCfMwD79u1TdTp0vhw1ahTmz5+PJk2ayHYqBAo5pqRZB1XY91A+V/lwJzpjxgwsWbJE1UJxZ9utWzc1sVe2lSUnTpxQ26h+/fpYunQpnnzySYwZMwY//fST1X/j7X56siDYw9Hv/v37LXLjgiUNGzbE7t27VeTpjz/+wCOPPKLqdgRLIiIi8Oyzz6q6Jxb6C0UzcOBA03nW8lC41KpVC7///rsqBhUsD6gYUXn//ffVZUZU+LvFehR+H62JRFQKEBQUBGdn58u6L3i5cuXKZfne2BX6tpHtZsnTTz+Nf/75B6tWrVJFo+bbi2nG+Ph4i+Ud9XPGKEC9evXQpk0bFSlg0faUKVNkOxWAqR0W9bdu3RouLi7qREHHAkee59GtfK6uDCOYDRo0wLFjx+SzVQB28jCKaU7jxo1NqTJr/saLUCnkB5M/litWrLBQmrzMnLlQOHXq1FEfVvPtlpiYqCrDHXG7sd6YIoUpjJUrV6rtYw4/Y6yuN99ebF/mj4Ijbq+C8DuXkZEh26kAffr0UWkyRp/0E4+CWXuhn5fP1ZVJTk7G8ePH1U5ZvoOWMDVd0ELhyJEjKgJl9d/4Ui3VtVNmz56tKplnzJhhDA8PN44cOdJYoUIF4/nz542ODDsNdu3apU786Hz66afq/OnTp9XtH3zwgdpOCxYsMO7du9d4++23G+vUqWNMS0szOhpPPvmk0d/f37h69WpjVFSU6ZSammpaZtSoUcaaNWsaV65cady+fbuxU6dO6uRojB8/XnVDnTx5Un1ueNlgMBiXLVumbpftVDTmXT+yvSwZN26c+g7ys7VhwwZj3759jUFBQaoLT7aVJVu3bjW6uLgY33vvPePRo0eNM2fONHp5eRl//fVX0zLW+o0XoXIFvvjiC7UTcXNzU+3KmzdvNjo6q1atUgKl4OmRRx4xta+98cYbxkqVKimh16dPH+Phw4eNjkhh24mn6dOnm5bhl/upp55Srbj8QbjjjjuUmHE0hg8fbqxVq5b6rgUHB6vPjS5SiGynaxMqsr3yue+++4xVqlRRn61q1aqpy8eOHZNtdQX+/vtvY7NmzdTvd6NGjYzffvutxe3W+o038E/pxmwEQRAEQRCuD6lREQRBEATBZhGhIgiCIAiCzSJCRRAEQRAEm0WEiiAIgiAINosIFUEQBEEQbBYRKoIgCIIg2CwiVARBEARBsFlEqAiCIAiCYLOIUBEEQRAEwWYRoSIIgiAIgs0iQkUQBEEQBJtFhIogCIIgCLBV/g+/aapx9lgfXgAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -1237,7 +1264,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "nest-multiscale",
+   "display_name": "neuron9",
    "language": "python",
    "name": "python3"
   },
@@ -1251,7 +1278,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.9"
+   "version": "3.13.11"
   }
  },
  "nbformat": 4,
diff --git a/tutorials/morphologies.ipynb b/tutorials/morphologies.ipynb
index 758c16f..f3f151d 100755
--- a/tutorials/morphologies.ipynb
+++ b/tutorials/morphologies.ipynb
@@ -19,6 +19,13 @@
    "execution_count": 1,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Cannot load crlibm extension. The imath functions will not be available.\n"
+     ]
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -27,8 +34,8 @@
       "              -- N E S T --\n",
       "  Copyright (C) 2004 The NEST Initiative\n",
       "\n",
-      " Version: 3.8.0-post0.dev0\n",
-      " Built: Jan 10 2025 14:51:17\n",
+      " Version: 3.9.0-rc2\n",
+      " Built: Mar 18 2026 09:13:42\n",
       "\n",
       " This program is provided AS IS and comes with\n",
       " NO WARRANTY. See the file LICENSE for details.\n",
@@ -412,9 +419,16 @@
    "execution_count": 15,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -445,7 +459,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -479,9 +493,16 @@
    "execution_count": 17,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring fixed y limits to fulfill fixed data aspect with adjustable data limits.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 2 Axes>"
       ]
@@ -525,7 +546,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -561,7 +582,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgMAAAGFCAYAAABg2vAPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAACOBUlEQVR4nO3dZ1RUydo24BtzxOyYEAOK45gDmHPOAVTMAQUdc0Yx54SiIqiggiCCICpKMIIEUZIIiCQBRcQAkqGhu+v7Ma9+4xlQOu6Gfq61XOeMvXfVLSL9dFXtKhXGGAMhhBBClFYFrgMQQgghhFtUDBBCCCFKjooBQgghRMlRMUAIIYQoOSoGCCGEECVHxQAhhBCi5KgYIIQQQpQcFQOEEEKIkqNigBBCCFFyVAwQQgghSo6KAUIIIUTJUTFACCGEKDkqBgghhBAlR8UAIYQQouSoGCCEEEKUHBUDhBBCiJKjYoAQQghRclQMEEIIIUqOigFCCCFEyVExQAghhCg5KgYIIYQQJUfFACGEEKLkqBgghBBClBwVA4QQQoiSU7hiID4+nusIhBBCiFJRqGLg7du32LZtG9cxCCGEEKWiUMXAw4cPMWLECK5jEEIIIUqFigFCCCFEySlMMSAUCpGUlITWrVtzHYX8Hx0dHfB4PK5jEEIIkTGFKQYSExORnp7OdQzyL6mpqahatSrXMQghhMiYwhQDbdq0wR9//MF1DEIIIUTpKEwxQAghhBBuUDFAisUY4zoCIYQQOaFigBQrPz8fNWrU4DoGIYQQOaBigBTr/fv3yMnJ4ToGIYQQOVCYYuDz58/49u0b1zHI/0lKSkKHDh24jkEIIUQOFKYYCAoKonlqBRIVFYVRo0ZxHYMQQogcKEwxEBERgQMHDnAdg/yf0NBQdOvWjesYhBBC5EBhioHIyEj89ddfXMcg/yc2Nhbt2rXjOgYhhBA5UJhiIC4uDm3btuU6BgFQWFiISpUqoWLFilxHIYQQIgcKUQwIBAIAoDcfBREZGYmOHTtyHYMQQoicKEQxkJCQQKMCCuTly5e0XoAQQpSIQhQDN2/eREFBAdcxyP9xcXGh4owQQpSIQhQDenp6KCoq4joG+T85OTm0eJAQQpSIQhQDampqSElJgVAo5DoKAaCiokInSBJCiBJRiGIAADp27IjXr19zHYMA4PF4qFatGtcxCCGEyInCFANDhgyBt7c31zEIwZcvX2jaihCiVBSmGBg8eDAVA0Qh7Nq1iw5pIoQoFYUpBlq1aoWkpCQ6n4Bj9PUHvn37hnr16nEdgxBC5EZhigEA0NTURHR0NNcxlFpubi5q1arFdQzOCIVCVKigUP8sCCFE5hTqpx5NFXAvIyMDdevW5ToGZ+Lj42mPBUKI0qFigPxE2YuBsLAwdO3alesYhBAiVwpVDLRt2xZxcXE0b82hzMxMpS4GgoODaStmQojSUahiQEVFBRoaGoiLi+M6itLKyMhAnTp1uI7BiZycHLi7u0NNTY3rKIQQIlcKVQwANFXANWWdJmCMYdWqVbhy5QqqVKnCdRxCCJErKgbIT5S1GDA1NcXgwYOLnSJ4+/at/AMRQogcKVwxoKGhgYcPH3IdQ2kpYzHg6+uLuLg4LFy4sNjXd+zYId9AhBAiZ5W4DvC/AgICoKury3UMpaVsxUBqaiqOHTsGBwcHrqMQQghnFG5kwMXFBdOmTeM6htLKzMxUmgWEubm5MDAwwOnTp0s8mCknJ0epN2EihCgHhSoGGGPw8fHBgAEDuI6itJRpZODu3bvQ0NCAurp6idd8+vQJTZo0kWMqQgiRP4UqBl6+fIkuXbqgUiWFm71QGunp6UpTDFStWhV9+/b95TWpqan4448/5JSIEEK4oVDFwM2bN2mKgEOZmZmIjIxUmmKsNAcS0cgAIUQZKFQx8PDhQwwfPpzrGEpr48aNMDMzU5rn7EszJZKamkrFACGk3FOYYuDNmzdo3bo1qlatynUUpeTp6Ync3FylGpkpTTFAIwOEEGWgMMUAPUXAnczMTBgbG+P06dNcR5Gr0kwTvHjxQk5pCCGEOwpTDLi7u2PMmDFcx1BKGzduxLZt29CwYUOuo8hVZmYmVFVVf3mNoaEhnj17JqdEhBDCDYUoBiIiIlCrVi16npsDnp6eyMvLw9SpU7mOIncCgeC3iyWHDBmCJ0+eyCkRIYRwQyGWjTs5OaF9+/Zcx1A6mZmZ2LFjB9zd3bmOorDq1KmDrKwsMMagoqLCdRxCCJEJhRgZ+PbtG/T09LiOoXQ2bNiAbdu2oUGDBlxHUWgdOnRAdHQ01zEIIURmFKIYiIiIQKdOnbiOoVQ8PDyQn5+PKVOmcB1F4Y0YMYIOzyKElGucFwOMMeTl5aFmzZpcR1Ea36cHlO3pgf/F5/NLdV2fPn0QEBAg4zSEEMIdzouB5ORkqKmpcR1DqWzYsAHbt29X6umBoqIixMfHl+raKlWqQCgUlrp4IISQsobzYiAsLAxdunThOobS8PDwQEFBgdJPD1SuXBkTJkxAUFBQqa7v3bs3AgMDZZyKEEK4oRDFQNeuXbmOoRS+Tw+YmppyHUUhGBgY4Pz586W6ltYNEELKMyoGlMj69ethbGys1NMD/9akSRMIhUJ8/vz5t9d26tQJERERckhFCCHyx3kx4Ofnp3Q733HB3d0dhYWFmDx5MtdRFMqyZctw4cKF316noqKCmjVrIicnRw6pypakpCSuIxBCJMR5MbB69Wo4OTlxHaNcy8jIwK5du2h6oBja2toICQlBUVHRb68dOHAg7t+/L4dUZUdAQAAuXbrEdQxCiIQ4LwYWL15MP0xkTEdHB9u3b0f9+vW5jqKQpk6dChcXl99e17NnT5w+fRqMMTmkUnyMMZw4cQLr16/nOgohREKcFwONGjVC8+bN8fLlS66jlEvv3r1DZmYmTQ/8wowZM+Dg4PDbN/kuXbpgwYIFsLS0lFMyxfbgwQNoa2ujTp06XEchhEiI82IAAJYvXw5zc3OuY5RL58+fh7GxMdcxFFrVqlWRnZ2N5OTk3167cOFCPHnyBAkJCXJIpthUVVWRmprKdQxCiBQoRDHQv39/hIeHIysri+so5QqPx8P9+/cxfvx4rqMovE6dOqFq1aq/vU5FRQUnTpzAxo0bIRQK5ZBMcfXp04eKAULKCYUoBlRUVDBv3jxcvXqV6yjlipOTE6ZOnfrbY3oJULFixVLvMNi0aVPMmDEDZ86ckXEqxRYUFKT0BREh5YVCFAMAMHfuXNjZ2dHiLCmytLTEkiVLuI5RJlSqVAkCgaDU18+cOROhoaFKd5ohYwxPnjzBzJkz4erqimbNmnEdiRAiBQrzkbF27dro2rUrfH19MXDgQK7jlHkvX75Es2bN8Mcff3AdpUwQZWTgu+PHj0NfXx9OTk7lfvRFKBTi7t27uHLlCvr16wdLS0vUrl2b61iEEClRmJEBgBYSStO5c+ewYsUKrmOUGaKODABAw4YNsXjxYhw7dkxGqbjH5/NhZ2eHqVOnIiUlBdeuXcPGjRupECCknFGoYqBLly5ITU0t1fawpGQZGRl4/fo1+vXrx3WUMqNixYoiFwMAMGnSJCQmJuLVq1cySMWdgoICnD9/HtOnTwcAODs7w9DQENWqVeM4GSFEFhSqGABoEyJpuHLlChYsWAAVFRWuo5QZlSpVEvuI4qNHj8LY2BiFhYVSTiV/2dnZOH78OPT09NCkSRO4uLhgzpw55X4ahBBlp3DFgI6ODm7evCnWpzTyz9yuvb09Zs+ezXWUMkWcaYLv6tSpg9WrV2P//v1STiVfZ8+exfTp09GjRw/cvHkTkydPRoUKCvcjghAiAwr3L71atWoYMmQIPD09uY5SJj169Ah9+/ZFzZo1uY5SpoizgPDfRowYgcePH+Pt27dSTCVffn5+cHFxwbBhw2hUiRAlo3DFACDaOfPkZ+bm5li+fDnXMcqcT58+SbRWJTk5GR06dECbNm2kmEo+CgsLceDAARQUFFARSYiSUshioG3btuDz+XQ0qojevXuHvLw8aGpqch2lzMnKypLojfzw4cPYsmWLFBPJx/379zF9+nR07dq1VIc1EULKJ4UsBoDSnzNP/r/z58/DwMCA6xhlUmZmJtq1ayfWvW/fvoVAIBD7fi4kJCRg3rx5CA4OhpOTEyZMmMB1JEIIh1SYgm75x+fz0bdvX/j5+aFKlSpcx1F4PB4PAwYMwLNnz2jlt4gYY5gzZw6uXbsm1v3Lli3D9u3boa6uLuVk0peXl4ejR4/i3bt32Lt3L1q0aMF1JEKIAlDYkYFKlSph0qRJNHRZSs7OzpgyZQoVAmJISEhA69atxbo3KioKNWrUUPhCgDEGZ2dnzJo1C0OHDsWlS5eoECCE/KCwxQAA6Ovr09nxpWRpaQl9fX2uY5RJoaGh6NGjh1j3HjlyROHXCrx+/RozZszAx48fcfPmTbELH1E8fPgQYWFhMu+HECIdCl0MNG3aFPXq1UNkZCTXURRaWFgYmjRpQucQiCkkJESsYiAsLAyNGzdG06ZNZZBKepKTk9GsWTMEBASgT58+0NPTk3mfVlZW0NDQkKiN7OxsKaUhhPyOQhcDAGBoaAgLCwuuYyi048eP0zkEEkhISECrVq1Evu/YsWPYtGmT9ANJ2ahRo3Dy5Ek0b94c8+fPh5+fn0z7e/36NTIzMyV6TDElJQUbNmyQYipCyK8ofDEwdOhQvHjxAjk5OVxHUUiMMTx79oz2jBcTYwyMMZE32Xnx4gXatGmDRo0aySiZ9PB4POjr66N3795YvXq1zPtLSkrCrFmzJGrj1KlTWLNmjZQSEUJ+R+GLARUVFejp6cHe3p7rKApJRUUFjx8/xsqVK5Gbm8t1nDInJSVFrIV0JiYmWL9+vQwSSVdmZibmzJmDhQsXQkdHRy59hoeHo3PnzmLfn56ejpSUFPz1119STEUI+RWFLwYAYMGCBbC2toaCPgXJuZYtW2L9+vVYu3Yt11HKHHHWC3h7e6NLly6oW7eubEJJyevXrzFv3jzs2bMHgwYNklu/UVFR6NChg9j3nz17FitXrpRiIkLI75SJYqBevXpo3749Xrx4wXUUhTVjxgwIBAI4OztzHaVMCQkJQffu3Ut9PWMMp0+flstwu7h4PB5OnDgBQ0NDHD16VO6fsHk8HqpXry7Wvbm5uQgPD0efPn2knIoQ8itlohgAgOXLl8Pc3JzrGArt9OnTOHbsGN6/f891lDIjNjZWpJ0Drays0KJFC9SqVUuGqcTDGMPNmzehq6uLjh07wtvbW6JP6OLg8/moWLGi2PevX78e8+bNk2IiQkhplJlioHfv3oiPj0d6ejrXURRWrVq1cObMGSxevJiOgC4loVAo0pvXgAEDULt2bRkmEk9wcDB0dXWRmpoKZ2dnjB07lpOTByMjI8V6MgMAXr16hW/fvtHWyIRwoMwUAwCwcOFCXLlyhesYCq13794YMWIEjhw5wnUUhRcfH49v376JdI+mpiZiY2NllEh0Hz58wLJly+Dg4ABLS0usWLEClStX5izP5cuX0bJlS5Hvy87OxrZt22BpaYkKFcrUjyVCyoUytXftrFmz0LVrV/z999+oWrUq13EU1qZNmzBu3DgMHz4c2traXMdRWH5+fiLvz6CiooJKlSqhqKiI0zfd3NxcHDt2DAkJCdi5cyfatm3LWZbvPnz4gLS0NCxdulSk+xhjWL16NQ4cOABVVVUZpSOE/EqZKsFr1qyJqVOnKvz2r1yrUKECrKyssHr1atrF7ReePHmCoUOHinxf9+7d8fLlS+kHKgWhUAhra2vMnj0bw4YNg7W1tcwLgQcPHiAxMfG31+3duxe7du0SuX0LCwv0798fXbt2FSMdIUQaylQxAABHjx5Feno6rl+/znUUhda8eXNs3bqVHtEqgUAgQH5+vlgLAQcMGABfX18ZpPo1b29vTJ06FSoqKnBxcZHL44KfPn3CsmXLfjt0HxwcjDp16oi8BXFwcDBCQkKwZMkSSWISQiRU5ooBFRUVWFhY4OzZs4iIiOA6jkKbOnUqqlevThs2FSMoKAi9evUS694ePXogKChIyolKdv/+fUydOhVeXl64du0a5s+fL5d5dcYYli9fjq1bt/5yHQBjDAcPHsS2bdtEaj8jIwO7d+/GqVOnOFnsSAj5/8rUmoHvatSo8WOo9P79+6hTpw7XkRSWiYkJhg8fjr59+4q9yrs88vDwEHtHvoKCArx580bKiX6WlZUFe3t7eHh4oG3bttixY4fYJyuKy9HREZmZmVi2bNkvr3N2dsaIESNE2oSJMYZVq1bhyJEjEp1hQAiRDhVWhrf1c3Nzg5mZGW7fvo1KlcpkXSMXoaGh2LhxIzw9Penr9H+mTZsGZ2dnsT6R/v3339DX1xdps6LSYIzB398f1tbWyM/Ph56eHkaPHi3Rc/viev36NYYNG4aAgIBfFpFpaWmYNGkSvL29RfreOnnyJBo1aoS5c+dKIS0hRFJlbprg38aNG4dKlSrB2NiY6ygKrXv37pgwYQIOHDjAdRTOhYeHY+7cuVBVVRWrEPD09ETjxo2lWgh8+fIFJ06cwLRp0+Dv7499+/bh6tWrGDduHCeFAGMM69atw9SpU39ZCPB4PBgYGGDbtm0iFQJ37tyBh4cHFQKEKJAyPTIA/LMQbMKECTAyMpLr/utljVAoxMSJE7Ft2zb079+f6zhyFxsbi0OHDqF+/frYvHkzGjduLHIbGRkZmD9/PpydnaXyWOHly5fx+PFjVKtWDfPnz8eAAQMUYu788uXLcHJywt27d0vMIxAIsGTJEixZsgQDBw4sddv+/v44d+4crly5QqNUhCgSVg58+vSJ9erVi3369InrKArt48ePTEtLi2VkZHAdRW6SkpKYoaEhW7FiBXv//r1EbY0fP569fPlSSsn+ae/r169Sa08a3r59y1q3bs1SUlJKvEYoFLIVK1awu3fvitR2WFgY09HRYfn5+ZLGJIRIWbkozRs3bgwTExPMmTMHbm5unG4Go8iaNGmCNWvWYPjw4XJdDc+F1NRUHDlyBDk5Odi6datUnsWvVauWWCMKJVFVVUWDBg2k1p6kBAIBFixYgOPHj6Np06YlXrd9+3YMGDAA48ePL3XbcXFx2LlzJ65evYpq1apJIy4hRIrK9JqBfxs4cCCaNm2KUaNG4evXr1zHUVizZ89GvXr1kJSUxHUUmUhLS4ORkRG2bNmCpUuX4uLFi1LblGfdunW4dOmSVNpSRCdOnEDr1q0xbdq0Eq/Zv38/WrRoAT09vVK3++HDB6xduxZWVlYKea4DIaSMPlpYEhsbGzx58gTjxo3D8ePHaQ1BCTZt2gQTExOYmppyHUViWVlZePnyJUJDQ/HkyRPk5ubi8OHD6Nmzp9T70tLSwuHDhyEQCCRe2JeVlaVQb4xhYWGwtLREYGBgidfcv38fQUFBuHXrVqnbTUtLg6GhIc6fP69QoyCEkJ+V+QWExfn8+TMWLVqEvn37wsjIiJMV2YqMMYZBgwbBxcUFDRs25DpOqX3+/BmhoaEIDQ1FZGQk+Hw+VFVV0a1bN3Tv3h2dO3eW+TPrFhYWUFdXx9ixYyVqJywsDO7u7ti6dauUkomvoKAA2traOH36NAYPHlzsNYWFhZg+fTocHR1RvXr1Urfdr18/XL16VSHOTiCElKxcFgPAP6vnjx07hidPnuDy5cu/nANVRg4ODnj9+jX27NnDdZRfOnfuHO7duwdVVVU0atQI3bt3R48ePfDnn3+iSpUqcs+TlZWFv//+G1evXpWonVu3boHH42HmzJlSSia+TZs2gTGG48ePl3jNkSNH0KVLF5GLoDlz5uDq1at0EiEhCq5cTRP8W4UKFbBlyxYMHDgQkyZNwuLFi7F8+XKuYymM6dOn48SJE9i0aZNY+/PLQ1RUFB4/fgwXFxdO3viLo6qqitq1ayM5ORktWrQQu52EhASFeMTTy8sL9+/fx/Pnz0u8JikpCZGRkWIdENasWTOkpqaiWbNmksQkhMhYuS/X+/Xrh1u3buHs2bPw8vLiOo7CqFSpEpYsWYKLFy9yHaVYX758webNm2FpaakwhcB3S5YsgZWVlURtJCQkoHXr1lJKJJ73799jxowZsLGx+eUKf2NjY7E3rGrVqhUSEhLEjUgIkZNyXwwA/5zg9/TpUxgZGeHVq1dcx1EYCxYswLVr11BYWMh1lJ9839nO1NRUpP3u5aVnz554+fIl+Hy+2G18/fqV8/UaQUFB6NSp0y+PDjYxMYGGhgbU1NTE6qN169alOv6YEMItpSgGAKBBgwZwcHCAvr4+/XD6P9WqVYOOjg7s7Oy4jvIDYwwrV67Ehg0b0KZNG67jlGjcuHFwd3eXqA2udxsMDg7+7ZqF8PBwGBoait1H69atlXJkwMfHB25ublzHIKTUlKYYAICWLVvCysoKs2bNor0I/o+hoSEuXLgAoVDIdRQAwMGDBzFkyBCFmE//FT09PVy/fl2sexVlza6Pjw8GDBjwy2t4PB7++OMPsftQV1dXuuL70aNHsLCwwPDhw7mOQkipKVUxAACdO3fG0aNHoaOjg9zcXK7jcK5OnToYMmQI7ty5w3UUODo6orCwEHPmzOE6ym/VqlUL9evXx7t370S+19fXF1lZWTJIVXo8Hg9xcXH4888/S7xGGkVLjRo1kJ+fL3E7ZYW7uztsbW1x5coVVK1ales4hJSa0hUDADBo0CCsXr0aenp6KCoq4joO59asWYNTp05x+on1+fPncHd3x+7duznLICp9fX2YmZmJdI+1tTXOnz+PCxcuyChV6QQHB6Nnz56/fOTv8+fPEo0KKAPGGBITE2FnZ4fZs2fDzMwMlpaWtCU6KXPK7aOFvzNt2jR8/vwZy5Ytw6VLlzifv+VSkyZN0KFDB3h7e2PIkCFy7z8mJgaHDh2Cvb19mfp76Nq1a6nn03Nzc7F+/Xr89ddfuHr1Kud/Tk9Pz99OxURERKBTp04S9xUXFyeVXRsVgUAgQHh4OHx9fREYGAgej4dWrVphwIABOHv2LOrVq8f53y0h4lDaYgD4Z748JSUF27dvx8GDB7mOw6mNGzdizZo1ci8G8vPzoaenh5s3b4q0s52i+PPPP5Gfn//L7K9fv8aWLVuwc+dO9O7dW47pSnbt2rXf7n4YERGBPn36SNRPbm4uOnToUKYLgYKCAri7u+Py5cvIz8/H8OHDMWDAAOjr69OhS6TcUMppgn/bs2cPvnz5gjNnznAdhVMaGhqoXbs2QkND5dYnYwxr167FuXPnoK6uLrd+palz586IiIgo8XUbGxscOnQIV69eVZhCoKioCPn5+ViwYMEvr3N0dJR4G+GHDx9ixIgRErXBlYCAAIwZMwaLFy9Gbm4u7Ozs8ODBA2zduhUDBgygQoCUK0pfDKioqMDc3ByPHz+GpaUl13E4tWXLFhw5ckRu/V28eBFdu3aFtra23PqUtm7duuHly5f/+f28vDwYGhri27dvsLGxUaj9El68eIEePXqgUqWSBwavXbsGXV1difdCcHNzw7hx4yRqQ96Cg4Mxd+5cuLi4wMTEBNeuXcPcuXMV6mApQqRNqacJvqtUqRJsbW3RoUMHTJw4UWkXTXXv3h3Z2dmIi4uDhoaGTPsKDAzEixcvFHYHxNLq2rUrnJycfvq979MCO3bsgJaWFkfJSva7T+sJCQm4c+cOrl27JlE/QqEQ3759KzOnFQYEBOD06dNo06YNTp06xfmmUITIExUD/6dmzZowNTXFyZMncfjwYa7jcGb58uVYsGAB/Pz8ZNZHWloa9u7di+vXr5f5xVb169dHenr6j/++evUqPD09YWNjg3r16nGYrGQPHz7E+fPni32Nz+dj/fr1MDc3l/hwoaCgIPTq1UuiNuTB19cXZ8+eRYcOHWBmZqawf2+EyBIVA/8yZcoUHD9+HGlpaWXm04y0JSUlYfLkyTJrXyAQYMWKFTAxMZH5ccPyUqFCBWRnZ2Pz5s3o0KGDQjwtUJKcnBy8e/euxP0FDh48iCVLlqBJkyYS93Xnzh2F3zNi2LBhGDZsGM6fP486depwHYcQzij9moF/q1ChAlavXo1Tp05xHYUz169fh4GBgcza37dvH2bNmoV27drJrA95q1u3LiZNmoRFixZhzZo1ClsIAIC3tzcGDRpUbEZ/f3+kp6djwoQJUunrzZs36NChg1TakpV+/fph1KhRVAgQpUfFwP/Q1dXF/fv3kZGRwXUUuXv58iVat24tsx+Mbm5u4PF4mDp1qkza54KtrS0iIiIwb948hVwf8L/27t1b7Kf+zMxMHDp0CIcOHZJKP/Hx8WjevLnCFkbZ2dk4evQonj9/jrS0NK7jEMI5Kgb+R8WKFbFy5UqcPn2a6yhyZ2VlhSVLlsik7YSEBFhZWWHfvn0yaV/e8vLysHz5cnz9+hWXL19GXFwc15F+KysrCx8/foSRkdF/XpszZw62b98u8V4PYWFh2LBhA5YvX/7bcw+48PXrV6xfvx6LFy+GlpYW7t+/j7Fjx3IdixDO0ZqBYujp6aF///5Yu3YtVFVVuY4jFwUFBXjx4oXMiiBdXV3cu3fvl4+zlRUPHz7EqVOnsGPHDmhra4MxViZO5rt06RJmzpyJ+vXr/+e1OnXqiP2I58ePH3Ht2jX4+fmha9euWLFihcT7E8jCmzdvsH79ekydOhUmJiZcxyFEoZT9n8wyUKlSJRgYGMDMzKzYT1HlkYuLC6ZMmSKTYd2EhAQMHjy4XDyyyRjDgQMHYGtri+bNmwPg/iji0hAIBDA3N8f9+/dLvEbUP8eZM2fg4+ODBg0aYM6cOVi/fr3Cfi3s7Ox+HCJUXDFEiLKjYqAE8+bNQ79+/bBq1SrUqlWL6zgyZ21tjUuXLsmkbTc3N0ycOFEmbcubl5cXxo0b96MQ+K5x48b49OmTwhY8d+/eRZcuXaS606OnpyccHBwU+qmQ/Px8bNy4EW3btlXopzwI4RqtGShB5cqVMWTIEKxevZrrKDKXkJCAqlWrolmzZjJp38/P77eH4pQV5ubmxR5OVNJOhIri1KlTWLNmTbGv8Xg8VKlSRaT2MjMz0bRpU4UuBB4+fAgdHR3MmzdPoUctCFEEVAz8QpMmTTBy5EiuY8jc5cuXsWjRIpm0nZeXh8qVK5eLI139/f3RuXPnYrelVVNT4/xY4pJcv34d0dHRJRZkKSkp/xnp+J0HDx4o9JkDjDEcPnwY586dk/iwJUKUARUDvxATEyOVI1wVmUAggIeHB8aPHy+T9h8/foxhw4bJpG15O3v2LFatWlXsayNGjECTJk0QGRkp51S/VlBQgAMHDsDU1LTET8bJyclo0aKFSO3ev38fo0aNkkZEmXjy5AlGjRpVZg/AIkTeqBj4hejoaLRv357rGDL14MEDDBkyRGaf3N3d3cvFo1vBwcFo06bNLw8c2rNnD3bt2gXGmPyC/cauXbswevRo6OrqlnjN48ePUVRUVOo2GWPIyMhQ2G17GWMwMzPD33//zXUUpZeZmUn7OJQRVAyUgDEGHo+HqlWrch1Fpi5duoTFixfLpG3GGD5//ozGjRvLpH15OnXqFNauXfvLaxo2bIhRo0bh+vXr8gn1G/7+/rh3795v93YQCoUYM2ZMqdsNCwtDt27dJEwnO48ePUK/fv0Uej2DsjA3N4e7uzvXMUgpUDFQgi9fvijsynBp+fLlC9LS0mS2ZWxERES5mGaJiIhAkyZNSnWK3ZIlS+Do6Ijs7Gw5JCtZbm4u9PX1cenSpd9uJJSQkIDWrVuXum03NzeFHu3Zvn07li9fznUMpScQCHDz5k3o6OhwHYWUAhUDJXj9+nWJh7mUF7a2tpg7d67M2r93757M1iLIk4mJCdavX1+qaytWrIhZs2Zh3bp1Mk5VMqFQiHXr1mH69Oml2iJZIBCItBmUIo8MFBYWon379qhRowbXUZSep6cnhgwZgmrVqnEdhZQC7TNQgqioKHTs2JHrGDLDGMONGzd+uQmNpO0/ffoUmzdvlkn78hITEwNVVVU0bdq01PfEx8dzOl+dnJwMOzs7fPv27bfXCoVCkdr+9u0b6tSpo7CP6b169Qpdu3blOobSEwqF2LlzJ+zt7bmOQkqJRgZKUN5HBlxdXcEYk9mGSioqKsjOzlbYN43SOnHiRKlHBb57+fIlp5+c1dTUUKdOnVLtHfDhwweRniR48OCBQj9ue+/ePfTq1YvrGEqNx+Nh7ty56Nq1KzQ0NLiOQ0qJioESlIXjVyWRn5+PmTNnyrSP8ePHIzg4WKZ9yFJiYiIqVKiAli1blvqelJQUNGnShNMiSEVFBSoqKqX61B8dHQ1NTc1St21mZqaw+ws8ffoUXl5e5XpET9F9+/YNEydOxJgxY2BlZVXmPwwoEyoGSpCbm1uutyGOi4tDu3btZNqHrq4uHB0dZdqHLB0/fhwbN24U6Z47d+5g0qRJMkpUenXr1kVmZuZvr3vy5IlIGw61aNFCIR8pvHHjBqytreHp6Vkunl4pi5KSkjBu3Dhs2rQJ8+fP5zoOEREVA8XIyMhAnTp1uI4hU3FxcTIfwmvbti3i4+MV6rn70vrw4QMKCgpEPn3v6dOnGDx4sIxSlV6DBg1++3x3QUEBAgICRBpWV8RPeqampggODsbFixdF3laZSI4xBktLS0ycOBEWFhYKPY1ESkbFQDHK++JB4J/HyVq1aiXzfrS0tBAYGCjzfqTNyMgIGzZsEOme7OxsVK1aVSG2Xv7y5QtevHjxy2sOHDiAnTt3okGDBqVqk8/no2LFitKIJxXZ2dmYNGkSVFRUcPjwYVSoQD/O5Ck7Oxvnzp1Dv3794OXlhfPnz9PizTKMniYoRnlfPAj88wiWPDZU0tXVhbm5eakecVMUfn5+yM3NFfl7wMPDQ6TNe2SpQoUKv9yTPyIiAl+/fhVpFCMlJUVmh1mJorCwEOfPn4eXlxcMDAzKxeOrZcmbN29gZmaGoKAgzJs3D/fv3y/2vA5StlAxUIyoqChMmzaN6xgyk5ubK7fd2dq0aYOEhAQwxhRyiPl/paWl4ciRI2KtdXB3d8epU6ekH0pERUVFyMjIKHEjIaFQiB07dsDKykqkdhMTEznd618oFOL69eu4fv06li5dCicnpzLxPVUe8Pl83L17FxYWFqhZsyb+/vtvnD59Wmpf/8zMzHI/NavoaFytGKtWrcKRI0e4jiEz8fHxIs+FS0JbW/u3Q9aKQCgUYuXKlTh+/LjIG6UUFRUhPz8fqqqqMkpXet+fECjpB7WFhQVmzZqF+vXri9Suk5MTJ1MgjDF4enpi6tSpKCwshIuLCyZOnEiFgBx8/PgR8+fPR9++fREYGIgLFy7A2dkZw4YNk9rXPygoCP379xfpfAwifTQyUAx1dfVyfbiGPBYP/puuri6OHTsGbW1tufUpDhMTE0yaNEmsw6mePn2KQYMGySCV6MLDw9GlS5diX0tOToaPjw+uXbtW6vays7OxadMmqKmpQU9PT1oxS+Xu3buwsbGBtrY2HBwcaDc7ORAIBHjw4AEsLS2RkZGBHj164OLFizKZVnzz5g10dXXh4OCgEGttlBkVA0ooLi5OrqcxtmrVCmFhYXLrTxwBAQFISEgQ+VHC7+7cuaMwuy2+evUKnTt3Lva1DRs24OjRo6X+VOfv749Dhw5h79696N69uzRj/lJ8fDz27duHvLw8nD9/XiEfZyxvkpOTcenSJbi6umLIkCHYv3+/zPZaKSwshIWFBfbv3485c+aUqTVF5RUVA0ooLi4O48aNk1t/jDG5PLkgrvT0dBw8eBAODg5i3c8YQ0pKikjP68uSt7d3sXsdHDx4EA0aNCjVvH9RURH27duH7OxsODo6/vawI2n58uULDh48iPz8fOzbtw9qampy6VdZFRUVwc3NDVZWVigqKsLixYuxdetWmT2iyRjDrVu3sG3bNgwePBjh4eHl/kC4soKKASX09u1btGnTRm795eXlKexxsowxrF69GkePHhX7DS8sLEyhHqni8/nYvXs3nJycfqzytrKygkAgwLlz5357/6NHj3Dy5EmsWrUKo0ePlnVcAEBOTg6MjY3x6dMnbNu2rcSRDSIdb9++haWlJR48eIAxY8bA1NRUpJMrxREYGIgNGzagdu3acHJywl9//SXT/ohoqBhQQnl5eXI91e3r16+lOv6XC6amphg9erREw6G3b9/G9OnTpZhKMs+fP8fRo0cxePBg3LlzB8+fP8fr169x/Pjx397LGMPBgwdhZWUl19Ece3t71KlTRyGexiiveDwebt26hcuXL6NatWpYsmQJ9u7dK9KJleJISkrCtm3b8Pr1axw7dkxht7NWdlQMKJmCggK57C/wb1+/fi31xjby5O3tjfv378PNzU2idiIiIrBz504ppZKciooKtmzZgjZt2kBbWxtaWlpwdnYu1ToBV1dXTJ06Va6FwPfH1m7evCm3PpVJVFQULC0t4ePjg0mTJsHKykouU1qZmZk4dOgQbty4AWNjY9jY2CjUplXkZ1QMKJmEhAS5ThEA/zy7r4gjAw0bNkT//v0laiMkJAQFBQUK+Zhby5Yt8ddffyEsLAzu7u6/3ZyHz+fD0tISTk5Ockr4Dzs7O+jp6dEbhRQlJSXh9u3buH37Nho2bAh9fX0cO3ZMLrs0FhUV4cKFCzh+/DgWLVqEV69eKew0Ifn/qBhQMvJ+rBBQ3GmCWrVqITc3V6I2rl69ChMTEyklkp5Xr15h1apVePr0KVJSUjBp0iQkJibi77//LvEea2trzJkzR677+/P5fNy8eZNGBcTE5/MRGxuLsLAwhIWF4eXLl8jIyEDVqlWhoaEBe3t7uR3cJBQK4eLigp07d6Jv377w9/dH06ZN5dI3kRwVA0rG09NTro8VAv+MDMhzk6PSql27NnJycsS+PzMzE58/f5b56Y+i+vTpE7Zv3w5PT09Uq1YNbdq0gY+PD6ZPn464uDgcP378P5/C8/Ly4OrqKvc35WvXrmHWrFk0KlBKmZmZ8Pf3h7e3N27evImaNWuiW7du6Nq1K0aPHo1NmzaJvJmUNHh7e2Pp0qWoVKkSrl+/XuI+F0RxUTGgZFRVVVG3bl259qnIIwPZ2dli329lZYUlS5ZIMZHk8vLyYGBggDNnzvz0bH69evXg4eEBAwMDTJkyBRcvXkSTJk1+vH769GmsWrVKrof98Pl8ODk5wcXFRW59ljVfv36Fj48Pnj59isDAQFSvXh39+/fHqFGjsHPnTrkuBC5OQEAAduzYgfz8fJibm2P48OGc5iHio2KgGMeOHUNeXh7XMWSibdu24PP5cu1TURcQVqlSRewtUPl8Pp4+fYp169ZJOZX4BAIBli1bBmNj42IXAFapUgVnzpxB165dsXnzZtjY2AD4Z+QmNDQUW7dulWteGhX4r5SUFDx9+hRPnz7Fy5cvUbduXQwcOBC6uro4fPiw3Bf/liQ0NBQ7d+5Eamoq9u/fj1GjRinkuhlSelQMFGPMmDEKOQ8sDfXq1UNiYqJc+yyPh5Dcvn0bkydPVqgfgJs3b8bMmTPRq1evYl/PzMzE+PHjsWTJEmzbtg3AP4+bzZ49GwcPHpRnVBoVwD+PcSYmJv5484+IiEDTpk0xePBgLFmyBF27dpX5Y3+icnV1hbW1NWJjY7Fnzx6F+zdAxKdY32kKonPnzhg3bhwePXpU7oa96tati4yMDLn3W95+YNjb28PW1pbrGD+YmpqiTZs2mDhxYrGvp6WlYcyYMZg7dy7WrFkD4J/1I2fPnsWSJUvQs2dPecaFvb09Zs6cqVSjAgKBAJGRkQgICIC3tzfi4uLQunVrDBo0COvWrUPHjh3lOk0jCsYYzM3NYWxsjF27dsHR0VFhsxLxUDFQgr1792LmzJkYOnRoufqm56oYUETR0dEIDw8X+b6goCB06tRJYQ7NOXToEN6+fYuLFy8W+3p0dDR0dXWxatUqLF26FElJSTA2NsZff/0FJycnuQ898/l83LhxQ2lGBQQCAZycnLB79260aNECs2bNwu7du6GhoVEmiuRv375BX18fhYWFiImJUcj1P0RyVAyUoHnz5hg6dCjs7Owwb948ruNIVUBAANcROPX582ccOHAAAoEAHh4eIt9vbm4u92H1kkRHRyM0NBR2dnYlXqOjo4Px48dj3rx52L9/P+Lj43Hw4EHO9v03MjLCyJEjy/2oAJ/Px7Vr13Du3DmMHDkSPj4+Ze6N1N/fHwsXLsTff/+N1atXl4nihYiHioFf2Lx5M4YNGwYdHR25HdQia0FBQZgyZYrc+mOMya2v38nPz8epU6cQHh6O7du3i7U3+ocPH1CpUiWFOFwlJycHGzduhLW19S+Pf61ZsyY0NDQwY8YMrFmzBsbGxnJM+bOUlJQfxUh5VVhYCGtra1y8eBGTJk2Ch4eH3J/gkZRQKMSRI0dgY2MDe3t7uU8jEQ4w8kvnzp1jhw8f5jqG1IwdO5alpKTIrb+cnBy2dOlSufVXHIFAwKytrdnkyZPZo0ePJGprwYIF7OXLl1JKJj6hUMgWLFjAQkNDf3nd+/fvWdWqVdnKlSsZj8eTT7gSCIVCNnPmTJaYmMhpDlnJy8tjZ86cYb169WJHjx5lWVlZXEcSy8ePH9mIESPY7NmzWWZmJtdxiJyUn8lwGdHX18eZM2fw/PlzrqNILC0tDTweT667gnG9FfGjR48wdepUqKio4ObNmxg2bJhE7X369EkhTig8ceIERowYgW7duhX7ukAgwOnTp7FmzRq0aNECZ86ckevOgsW5ePEixowZU6ojlMuS3NxcnDhxAoMGDYJQKIS3tzc2bdr048TIssTExAR9+vTB7NmzYWtrC1VVVa4jETmhYuA3KleuDH9/f6xduxb+/v5cx5HIrVu3MHXqVLn2ydWGQ5GRkdDT00NgYCCuX7+OefPmSWUhqCLsl/D48WN8+PABc+fOLfb1sLAwTJ8+HU2bNsXmzZvx559/yjnhf8XHx+Pp06dYsGAB11GkJiUlBQcPHsSQIUNQq1Yt+Pr6YvXq1ZxvBCQuxhgOHz4Ma2trLFq0iNYHKBlaM1AKLVu2xO3btzFt2jTs3r27zB7B6ezsDCsrK7n2mZaWJtc30I8fP2L//v2oXLkyTp8+jUaNGsmtb3l4//49zp49i+vXr//ntdzcXOzbtw+5ubm4cuUK6tati82bN4u9sZK0CAQCbN68Gebm5uXiDYYxBltbWxgZGWHLli3w9/f/5ZqNsuL+/fv4888/MXjwYK6jEA5QMVBKjRs3hqurK6ZNm4bc3FxMnjyZ60gi4WKKAPjn+FR5FAPfh2pjY2NhbGwMTU1NqffBOF4MWVBQgJUrV8LCwuI/Q/4eHh4wMzPD1q1bfzqJ8du3b5g0aZK8o/7ExMQEc+fOlduBObIUExODVatWoWvXroiOji4Xp/F9/PgRJ0+exOXLlxVue20iPzRNIIJ69erB1dUV586dg729PddxRMLFFAHwz6NJsp5jv3z5MiZOnIihQ4fi6tWrMikEgH9+aH779k0mbf+OQCDAhAkToK+v/1NB9+nTJyxevBjBwcFwdnb+z5HML1684LQYuHPnDiIiIjj53pMmHo+HPXv2YNmyZTh69CiOHj1a5guBt2/fwtDQEP369UOjRo0QHx+Pw4cPcx2LcIXjBYxlUn5+Pps8eTK7cOEC11FKbcyYMXJ9ioCxf1YlL1myROb9LFy4kH358kXm/bx//56tXLlS5v38L4FAwAwMDNidO3d++r2LFy8yHR0dFhMTU+x93759Y23atJFXzP/w8fFho0ePZgkJCZxlkIYnT54wbW1tZm5uzgQCAddxJBYWFsb09PRY+/btmYWFBcvPz+c6kkK6ffs2y8nJ4TqG3NA0gRiqVauGGzduYP78+cjOzsb69eu5jvRLaWlpKCwslPsUgYWFBQwNDWXaR25uLoqKiuSySJHP58v9jAXGGNauXYuRI0f+2GpYIBBgwIABWL58ORwdHUuch/fz80O/fv3kGfcHJycnuLm54fbt2wpzuI6ovn79io0bN4LH48HFxUXu/36kzc/PD4cOHUJycjK2bNkCGxsbhTv7QBFkZ2fDyMgI58+fR4UKFaCuro4uXbqga9euP/5XXV29XKx/+TeaJhBT5cqVYWtri9evX2PPnj2czyf/ChdTBDweD+Hh4SUemiMtd+7ckdsweEFBgVy3IGaMYfPmzejTpw+mT5/+4/dPnjyJDRs2YP78+b/8geTj44OBAwfKI+pPTp06heDgYFhaWpbJQoAxhsuXL2PcuHGYNWsW7O3ty2whwBiDu7s7Bg0ahC1btmD58uUIDQ2Fnp4eFQLFcHNzw19//YXMzEx8/PgRWVlZcHR0xMSJE5GRkYEzZ86gd+/eqFu3LgYMGIB169ZBIBAU+2vbtm04dOgQbt++jZiYGLmfFisyTsclygGhUMjWrl3LNmzYwIRCIddxisXFFIG1tTVzcHCQeT96enosLy9P5v0wxtjLly/Z0aNH5dKXUChk27dvZ5cuXfrp9yMjI9nixYtL1Ub//v3Z69evZRGvWAKBgG3YsIGdPXtWbn1KW2pqKtPQ0GBGRkYsNzeX6zhi4/P57Pr166x79+5s7Nix7OnTp1xHUmhRUVFs8uTJrGXLlszNze2X1wqFQpaSksLu3bvHAPz214gRI1iLFi1YlSpVWMeOHdm0adPYtm3b2NWrV1lgYKDCbE5FxYAUCIVCtmPHDrZs2TLG5/O5jvOTDx8+sKFDh8q1T6FQyCZPnswKCwtl2s+XL1+Yvr6+TPv4t+fPnzNTU1O59LVnzx5mbm7+0+8VFRWxSZMmsbS0tN/en5+fz5o3by63AjU/P5/Nnz+f3bp1Sy79yUJKSgrr27dvmf4zFBQUsAsXLjBNTU02c+bM3+5QqeyEQiG7dOkSq1WrFhs4cKBIb8xCoZDx+fzf/vr+bzArK4sFBQWxq1evsu3bt7Pp06ezjh07sipVqrDmzZuz0aNHc7omhcaJpEBFRQV79+7FsWPHsGDBAly+fFlhnjv+frStPPn7+6NPnz4y/xo4OjpixowZMu3j33g8nsyGvRljCAsLg6urKwICAqCuro6dO3f+dM3hw4exbNky1K9f/7ftvXjxAr1795bLvGZaWhr09fWxZcsW9OnTR+b9yUJSUhJmzJiBM2fOQEtLi+s4IuHxeAgNDcXx48cREhKCESNG4O7du9DQ0OA6mkJ78+YNDA0N8e3bNzx8+BDa2toi3a+ioiLSYVu1a9dGz549/3POA5/PR0JCAhITEzk9IZeKASnatGkTLCwsMHPmTFy7do3zI24ZY/D19YW7u7tc+7148SJOnDgh836ePHkCAwMDmffznbSLAYFAADMzM7x+/Rrp6eno1q0bJk+eDGNj4/+8iYeFheHDhw+lPmTIw8PjP48ZykJCQgJWr16NkydPltk3n9jYWMyZMweWlpbo0qUL13F+iTGG+Ph4PH/+/MevDx8+oFu3bqhcuTIePXqE1q1bcx1ToRUUFODQoUM4c+YMtm3bhjVr1nD64a1SpUpo164d2rVrx1kGgIoBqTM0NEStWrXQs2dPeHl5cboDXkBAAP766y+57i/+/v171KhRQ+YbDSUkJEBNTU2ux+BKqxh4/fo1rK2tERcXh65du8LIyOiX+/UXFhZix44duHr1aqnaz8vLw8WLF3H27FmJs/5KUFAQ9u/fj0uXLpXZnR4jIiKwePFime5PIQ2GhoZ48+YN4uLioKamBm1tbfTt2xdr165F69aty93Kdll58uQJDA0NoaGhgZCQELRq1YrrSAqDigEZmDt3LvLz8zFhwgScO3eOs+M/LSwssHr1arn2ee7cOaxYsULm/djb22P27Nky7+ffJCkG3r17h2vXriEwMBCamppYvHhxqd989u3bh9WrV5f6scb169fDwMAAM2fOFCtraVy4cAHe3t64du1amd2L38rKCseOHYOHh4fCvyn4+vpi3759GD9+POcHTpVF3759w4ABA/DlyxecO3cO06dPpwLqf1AxICNLly7FmDFjMH/+fMycORMGBgZy/eZLT09HQkKCXAuRvLw8vH37Fp06dZJ5X7du3YKRkZHM+/k3Ho8n9ijL8ePHoampCUdHR5FGM168eIGsrKxSn4dx69YtvHz5Ej4+PmLl/J3w8HAcOnQIVapUgbW1dZl8PC01NRUbNmyAQCCAg4ODwhcCAoEAaWlpmDx5MqdzymWVm5sbli1bhu7du8Pd3R0tW7bkOpJCKnv/kssQNTU1eHp6YsuWLZg3bx5MTEzktj+7tbU1Fi5cKJe+/t1nSSfpSVu7du3kXtkXFBSI9ff39etXpKWl4e+//xbpvvz8fOzbt6/UW1+npKRg/fr1ePDggdTnQBMTE3HgwAGoqqrC1NS0TE4LCAQCmJubw9bWFgcPHpT4OGt5iYuLg4aGBhUCIsrIyMC6devw8OFDWFlZYfTo0VxHUmhUDMhYlSpVcPLkSZw9exb9+/dHYGAg6tatK9M+GWNwcHDAo0ePZNrPv3358gUXL17Eixcv5NanvIk7TXD8+HFs3LhR5PuMjY2xefNm1KpV67fXCoVCzJ8/H7t370bbtm1F7qskX758waFDh5CbmwtjY+Nfrm1QZEFBQVi3bh3GjBkDb2/vMrUZ0tWrV2X+M6O88fDwwNKlSzFq1ChERETIfefQsoiKATlZuXIlOnTogMmTJ+P27dsy/cft5eUFLS0tuR2kwufzsWLFCty4cUNuw8ZczPdlZGSIvGAxIiICL1++FPkAGHt7e8THx5d6B0ETExM0atQI8+bNE6mfkmRnZ8PExASxsbHYunWrXKZ+pEEgECApKQkxMTGIjo5GdHQ0/Pz8UL16dVy7dk3uj9lKQigU4uDBg3B0dMTx48e5jlMmZGZmYsOGDfDw8MDFixcxduxYriOVGVQMyNGIESMgFAoxZcoU3L59W2bVqoWFxX+eUZelHTt2YNGiRVL9RPorjDFOioHAwECMGjVKpHuOHj2Kffv2iXTPo0eP8PjxY9y8ebNU14eEhODChQt48eKFxF+XwsJCnD9/Hl5eXli3bh127dolUXuykp6ejujo6J/e9D9+/PhjL/n27dtDU1MTgwYNwsGDB1GnTp0ytWAsPT0d8+bNQ506dRASElKq0SFl5+npiaVLl2L48OGIiIig0RQRUTEgZ6NGjQJj7McIgbQLgk+fPuHr16/466+/pNpuSW7cuIEaNWpg3LhxcukPAHJycuT+w7GoqAiVKlVCjx49Sn3PnTt30LlzZ/Tu3bvU93zf09/GxqZUc8S5ubmYN28eLl26JNEPP6FQCHt7ezg6OkJfXx9OTk6cv3kWFhYiPj7+pzf9+Ph4FBYWol69etDU1ISmpiZGjRqFlStXomnTppxnlobAwEDMmTMHa9euxfLly8vFn0mWCgsLMXz4cLx69QrXrl3D+PHjuY5UJlExwIHRo0eDMfZjhECa+wBcunQJS5YskVp7v/L69WvcunWr1M+/S8unT59QVFQk1z49PT1FWoCUlZUFKysrODs7l/qe2NhY7N+/H3Z2dqVeALhmzRpMnz4dAwYMKHU//8b+7yCb8+fPY9q0abh586Zc924oTk5ODjp06AANDQ20bdv2x6f8iRMnom3btuX20TrGGCwsLHDy5EnY2tqWuZ0QufDhwwfo6uqiatWqCA0NLVPTQAqHs42QCXNzc2NDhw6V2kEVQqGQNWnShBUUFEilvV/JyMhgEyZMYBkZGTLv69+ysrLY5MmTma2trVz7XbhwoUh/1tWrV7Pg4OBSX//hwwc2YcKEUp078N2jR49YnTp1WFFRUanv+bdnz56x6dOnMxMTE4U6037lypXs+vXrXMeQq5ycHDZnzhw2ZswY9vXrV67jlAleXl6sSZMmbMeOHQp3JkxZRMUAx65cucJ69Oghlbb8/PyYgYGBVNr6FYFAwGbPns3Cw8Nl3te/paWlscmTJ7OwsDC59puZmcnmz59f6uvv3r3LtmzZUurr09PT2YQJE1hycrJIuYRCIVNXV2fp6eki3ZeYmMj69+/PduzYwTIzM0W6V9Z8fHzY1KlTFfYEUGnj8Xjs8uXLrF27dmzv3r2cHlRTVgiFQmZiYsIaNGjA7ty5w3WccoOmCTjWvn17DBkyRCpt2dvbY86cOVJp61cOHjyIyZMny3WF+adPn6Cvr48TJ06gffv2cusXAM6fP48WLVqU6tqXL19i7969pT4PIi8vD4sXL8bx48fRvHlzkXKpqKhg9OjRePDgQakObOLxeDhx4gRiYmJw7do1hdt8paCgABs3bsTNmzfL9Tx5SkoK3N3dce/ePbx48QLt2rWDgYEBNmzYwHU0hZeTkwN9fX28fv0aAQEBZfY8DIXEdTWi7JycnNiJEyckbqeoqIj16tVL5p8s3NzcRPrUKw1JSUlswoQJLCkpSa79fldYWMgmTpz42/PtfX19mY6ODsvOzi51u3p6euzFixdiZ3NxcWELFy787XX3799nEyZMYJ6enmL3JWtGRkbM0tKS6xhSV1RUxHx9fdm2bdtYt27dWMeOHdmGDRvY48ePGY/H4zpemSAUCpmTkxOrVasWmzFjBsvJyeE6UrlDxQDHTE1NpTI/ev/+fbZp0yYpJCpZXFwc09HREXuOWhwxMTFs4sSJLDU1VW59Fsfb25vt3LmzxNfd3d3Z3LlzS71eQygUsmXLlrH79+9LlCsrK4u1bNmyxCLw/fv3bMGCBWz//v1yWUsiruDgYDZ69OhyMz0QExPDzp07x/T09Fjz5s3ZuHHjmJmZGXv79i3X0coUoVDI7t69y3r16sU6dOjAduzYIdefP8qEigGObdmyhT19+lTidhYuXMhCQkKkkKh4ubm5bOLEiezz588y6+N/hYWFscmTJ4s8Jy4rixcvZnFxcf/5fUdHR7Zs2TKRfkht2bKFOTg4SCVX+/bt/9NWYWEhO3bsGJszZw5LSEiQSj+yUlhYyPr378/i4+O5jiKxkJAQtnjxYla/fn02ceJE5ubmxvLy8riOVeb8uwjQ1NRkdnZ2tEhQxqgY4NjcuXMl/iGYn5/PtLW1ZfapSigUsiVLlrDAwECZtF+cgIAANn36dKk9aSENHz58YHp6ej/9nqOjI5s4caJI0zPHjx9nZmZmUsu1YcMGZmxszBj75+/K1taW9erVi7m6ukqtD1k6cOAAO3nyJNcxxMbj8ZidnR3r168f09bWZjY2Ngr1dEZZIhQK2b1791jv3r2pCJAzWkDIsZSUFDRt2lSiNtzd3TFu3DiZLbo6ffo0+vXrh169esmk/f/15MkTXLx4Eba2tqhWrZpc+iyNZs2aoVevXnB1dcXEiRN/nAFx7dq1Uh8iY21tjZycHKkuFps/fz5WrVqF+/fvw8LCAkOHDsWDBw/KxA5sUVFRePDgAR4+fMh1FJElJSXB0tISV69exdChQ2Fqaiq3fyPlDWMMHh4e2L17NzIyMrBz507MmjWL8z0vlArX1Ygy4/P5rHnz5hJ/otfV1WUxMTFSSvUzLy8vtnLlSpm0XRxXV1e2aNEiVlhYKLc+RfF9MWFeXh57+PAhO3r0aKnvPXHiBFuxYoXUR3AePXrEatSowQ4cOFCmhqT5fD4bOnQoi4yM5DpKqRQVFTE/Pz+2e/du1rNnT1azZk125MgR9uXLF66jlVkCgYDt27ePdevWjbVv357Z2trSSABHaGSAQ+fOncP8+fMl+kSfmZmJjx8/ol27dlJM9o/IyEiYmJjA0dFR6m0Xx8HBAU+fPsXFixcV9hNB5cqVsX79ehw9ehSvXr2CjY1Nqe/18vKS6ja/fn5+MDU1Rc+ePTF16lR07NgR1atXl0rb8mBmZoZhw4ahY8eOXEcpFmMMcXFxePDgAR48eIDAwEB069YNo0aNwtWrV9G+fXuF/T5VdDk5ObCxsYGpqSkyMzOxfPlybN++XW4HnZH/oq88R96/fw97e3t4eXlJ1M6RI0fQunVr6YT6HydPnsTatWvlctyrpaUlYmJicPbsWYV/xnzQoEFYtWoV+vTpI9LJkLVq1ZLKVrrOzs64fv06unTpAktLS6iqquL69evw9PTElClTJG5fHiIiIuDg4CDx97+0paen49GjR3jw4AEePXqEhg0bYuTIkVi3bh369OlTbrdClpekpCScPXsWly5dQv/+/XHu3DkMGzZM4f/NKwMqBjjAGMOqVatgYmIi8Q+XoKAgmZ0NUL9+fWhqasqk7X87efIkcnNzceTIEYX/ofD48WPs3LkTw4cPx6ZNmzjJYGtri3Pnzv201mTkyJEwNjbm7ERHUc2fPx9GRkalPoNBVgoLC/Hs2TPcv38fDx48QHp6OoYPH45Ro0bh8OHDqF+/Pqf5ygPGGPz9/XHq1Ck8ePAA8+fPR0BAgExGM4n4qBjggJOTE9TU1NCnTx+J2nn79i1q1KiBP/74Q0rJfpaRkSGzY5aBf35I7Nu3D6qqqjA2NpZZP9IQEBCALVu2oG3btnBwcBB5t8Dc3FzUqFFDKlmqV6/+n0WnDRo0QIMGDRAbGyv3HRpF5eXlhS5dukBXV1fufTPGEBUV9ePNPywsDFpaWhg5ciSuXbuGtm3bloliqixgjGH9+vV4+vQp0tPTsWrVKly8eLFMLGxVRlQMyBljDGvWrMGbN28kbsva2hoLFy6UPFQJ8vLypPYG9r8YY9iyZQs0NTXldsqiuDIyMrBy5Ups2rQJM2fOFKuNpKQktGrVSuIs+fn5JU7bjB49Gp6engpdDAiFQuzYsQP29vZy6zMyMhIvX77EgwcP4OXlhRYtWmDUqFEwNjZG7969aZ5aRuzt7XHx4kWYmppi4cKFtL5CwdG/AjnLzc3FX3/9JfGxxUKhEO7u7jL/RC2LT0kCgQCrV6/GoEGDxH5zlRcej4cZM2bg0KFDGDlypNjtJCQkSGVth7e3d4lnCowZMwYHDhzAqlWrJO5HVq5du4bBgweX+qwHUQmFQrx+/Rp+fn7w9/fHs2fP8OnTJ+jo6GDatGk4ffq0VI8MJ8Xz8/PDqlWr4OPjg+7du3Mdh5QCFQNylpCQIJUzt588eYIBAwbIdM6VMSb1NouKimBgYIDp06dj/PjxUm9fmoRCIRYsWIC5c+dKVAgAQGJiolR+KPr7+6Nnz57FvqalpYWwsDDweDy5LPoUVX5+PkxNTfH48WOptZmdnY0XL17A398ffn5+ePXqFdq3b4/+/ftjxowZMDExQYMGDaTWH/m9+Ph4TJs2DZcvX6ZCoAyhYkDOpPUJ0crKClu3bpVCopLFxsZKvc1Ro0Zh586dGDp0qNTblrZNmzaha9eumD9/vsRtJSQkYOrUqRK3ExMTg127dhX7WqVKldCoUSNcvHgRK1eulLgvaTt16hT09fVRu3Ztse5njOHdu3c/PvX7+fnh27dv0NbWRr9+/bB//3507dqV80WJyuzbt28YP348jIyMMGnSJK7jEBFQMSBn0hgZcHd3h7+/P7p06SKlVMUbOHAgkpOTpTakm5aWhjZt2pSJQuDkyZPIz8+XWsGVmpqKJk2aSNRGfn4+qlSpUuLca2ZmJj5//qyQIy6fP3/GnTt34OPjI/K9wcHBmD17NgoKCtCoUSP069cPAwYMwJYtW6CmpiaDtEQchYWFmD59OoYNG4Y1a9ZwHYeIiIoBOXv79i369esn9v1OTk4wNzfHy5cvpReqBIMHD4a3tzfmzJkjlfYcHR0xa9YsqbQlS46OjvDx8cGNGzektmaCMVbqLYtL4uPjg0GDBpX4+tmzZ7Fw4UKZ7Tshid27d2PHjh0iLdbj8/k4fvw4Ll68iKVLl2LlypWoVauWDFMScTHGsHz5clStWhWnT5+mJzLKICoG5EySaYJLly7BxcUFrq6uMlvl/28DBw7E1q1bpVIMMMZgbW0NPz8/KSSTnbt378Lc3Bz37t1TuNXPnp6eJX7iys7OxoULFxAcHCznVL8XFRWFt2/fYuzYsaW+Jzw8HIsXL0b37t0REhIi00dcieSOHDmCFy9ewM/Pj57OKKPob03Ovn79KtaCphMnTiAoKAjOzs5y2wWtXr16yMjIkEpbnp6eGDt2rMK9wX7HGIOFhQUOHz6MgIAAqRZbmZmZUlnB/u7duxKfJDh37hxmzZqFhg0bStyPtG3duhWHDx8u1afFwsJCHD58+MfGSiNGjJBDQiIJJycnmJqaIiAggJ7UKMOoGJCj77vDiTKExhiDsbEx0tLSYGtrK/c30+bNm0u8bkAgEMDc3BwODg5STCY9nz59wtKlS9GpUyfExsZKvdhKTEyUeI+BDx8+lLjRUU5ODszNzfHixQuJ+pCFx48fo379+ujWrdtvr/X09MSiRYswdepUBAcHi73QkMiPt7c3DAwM4O7uDnV1da7jEAlINolJRPLlyxc0atRIpHuGDh0KHo8Hc3NzTj5VN2rUCNeuXZOoDTs7O+jo6CjUccTf3blzBxMnTsSmTZtw8OBBmYy6JCYmSjyPf//+fYwaNarY1ywsLDB9+nQ0btxYoj6kTSgUYteuXdi/f/8vr+PxeNixYwdWr14NY2NjmJmZUSGg4NLS0rBjxw4MHz4c+/btg5aWFteRiIRoZECOIiIi/rON7K9YW1ujefPmOH78uAxT/VrlypUlWv1fUFAAZ2dnuLi4SDGV5HJzc7F+/Xrk5+fjwYMHMp2TTkhIQP/+/SVqw9vbG2ZmZv/5/aysLOzZs0cmj4FKytbWFkOHDv3l1s1BQUFYsmQJhg4dipCQEJEOfiLy9+nTJ5w4cQIXL17EpEmTEBAQgF69enEdi0gBjQzIUXR0NLKzs0t1bXh4OCwtLWFlZSXjVL8WExMj0fa2ZmZmWL58ucQr6aXpxYsXGDZsGIYNGwYbGxuZL05LSEiQaJogJCQEkZGRxb5R1q5dG02aNFG41dt5eXk4c+ZMiYc5FRQUwMjICPPnz4eZmRlOnTpFhYACS05Oxpo1a6CpqYnMzEwEBwfD2tqaCoFyRHF+QiuB0aNHl+q6rKws6Ovrw8bGhvOh9ZycHLGHbDMyMvD8+fNS/7nlYebMmTA2Noazs7PctkL++vWrWAv78vPzYWRkhMuXL+P+/fvFXqOiooJhw4bB19dX0phSdfLkSSxdurTY752AgAD07t0bRUVFCAoKwoABAzhISEojISEBBgYG6NSpExhjCA8Px/nz56Wyi6oyys/P5zpCiagYkKOWLVsiKSnpl9cwxqCvrw9jY2OFfF5cFEeOHMHmzZsV5lPr2bNnwefz4e7uLrO98YuTkpIi8tfg8ePHmDFjBsaNG4czZ86gXr16JV47YMAAhSoGPn36hLt372Lx4sU//X50dDSGDx+O6dOn48KFCzh+/LhcHpEloouOjsbChQvRvXt3qKqq4s2bNzh9+jRt8iSmxMRErF+/Hi1atEBKSgrXcYpFxYAcVapUCQKB4JfXmJqaom3btpg4caKcUpUsICAAX79+Feve5ORkpKamKsww4t27d+Hp6QkHBwe5LsR89OgRevToUerr09PTYWhoCC8vL9y4cQMDBw787T0DBw4Ua2c/Wdm9ezd27tz543lzPz8/TJkyBdOnT8f06dPx+vVr9O3bl+OUpDjh4eGYNWsW+vbtCzU1NcTFxeHYsWMS756pjBhj8Pf3h46ODrp16wahUIjAwEA0a9aM62jFY0SuxowZw759+1bsa35+fmzEiBGsqKhIvqGK8fr1azZlyhSWnZ0t1v2GhoYsLi5OyqnEExQUxPr378+ysrLk2m9RURGbOHEiy8vL++21QqGQOTg4sMmTJ7NXr16J1I9AIGDVq1dngYGB4kaVmsjISDZmzBhWVFTEbt68yfr27csGDhzIXF1dmUAg4DoeKUFgYCCbMmUKa9iwIdu3b1+JP6PI7xUWFjJ7e3umpaXFWrZsyY4fP84yMjK4jvVbVAzI2cqVK1lQUNB/fj8yMpK1aNGCffz4kYNUP4uNjWWTJk0S+xs4IiKCrV27VsqpxJOUlMR69+7NkpOT5d63hYUFc3Bw+O11sbGxTE9Pj5mamjI+ny9WXw8fPmTt27dnnz59Eut+aRk3bhwzNjZmHTp0YNOnT2cBAQGc5iG/5u/vz1q0aMHq16/Pjh49KnbxT/4p6E+cOMGqVavG+vTpwxwcHBTig11pUTEgZ6dOnWLXr1//6fdiY2NZ79692ePHjzlK9f8lJiayCRMmsK9fv4rdxuzZszl/U2KMsYyMDNa3b1/28uVLTvqeNm0aEwqFJV4jFArZxYsXmba2NktISJC4Tx0dHTZ06FCJ2xGFUChkb968YVZWVqx///6scuXKzNDQkMXExMg1BxGNt7c3GzFiBGvevDnbvHkzS0tL4zpSmfb69Ws2ZMgQ1rFjR2ZhYcF1HLFQMSBnd+/eZfv37//x3xEREax3794sKiqKw1T/+PDhAxs/fjxLTU0Vu42nT5+yvXv3SjGVeHJzc1mfPn2Yu7s7J/2vW7eu2BGg75KSktiMGTPY5cuXf1kwlBaPx2OtW7dmSUlJErf1K4WFhezGjRvs2LFjbMqUKaxFixasX79+bOPGjUxTU5M9efJEpv0T8QmFQvbo0SM2ePBg1rJlS3bu3DmWn5/PdawyLScnh23dupXVq1ePHTt2jBUWFnIdSWxUDMjZmzdv2MKFCxljjAUHB7PevXuzt2/fcpyKsU+fPrEJEyZINJwuFArZ1KlTWU5OjhSTiefKlSts1qxZnPQtFApZr169SnzNwsKCzZo1S6pTF5cuXWKLFy+WWnv/q6CggF26dIl17NiRNW/enB06dIj5+Pj8eDO5cuUK27lzp8z6J+ITCATMxcWF9evXj7Vp04ZZWloyHo/HdawyTSgUMhcXF9ayZUumo6PD3r9/z3UkiVExIGcFBQVs8ODBzN/fn2lrayvEN1FaWhqbMGGCxEPVzs7OzNzcXDqhJDRq1ChO1gl8Z2Bg8J+h14SEBKajo8Osra2lMhrwHZ/PZ3/++SeLjo6WWpvfpaWlsQMHDrBWrVqxJUuWsMjIyP9ck5uby3r16kXzzQpEKBSy0NBQZmRkxBo3bszq1KnDrK2ty9QctqKKj49n48ePZxoaGszDw4PrOFJD2xHLWdWqVZGSkoKNGzfi9u3b+OOPPzjNk5mZiUWLFsHExESiXfLS0tJw4MABBAQESC+cmKKjo1GrVq1fboMrawMGDICbmxvmzp0LPp+PQ4cOISoqCqamplJ/tMjFxQWdOnWSaKfI/xUXF4dTp07B1dUVCxYsQEBAQInfq0uWLMHIkSNRq1YtqfVPRMcYQ1hYGBwdHXHjxg0UFBRAR0cHN27cQN++fVG5cmWuI5ZpmZmZmDdvHnx9fbF27Vo4OTlxvimcNFExwIFv377hwYMHnBcCOTk5WLhwIQ4dOoR27dqJ3U5ubi6WLFkCR0dHhfiBY2FhAUNDQ04zNGrUCHfu3EH37t1hbGyMDh06wM7OTiYbML17904qRZhQKIS/vz9MTEwQFRWFNWvW4OjRo7/cGIgxhoSEBFy8eFHi/onoSioAbGxsoK2trVDbgJdVAoEANjY2MDY2RvXq1fHgwQP07NmT61jSx/HIhFIyMDBgYWFhnGbIy8tj06dPZ6GhoRK1U1hYyGbOnMlCQkKkE0xCubm5TEtLi/Nn2g8ePMjmzJnDDAwMJHoyo7SaNm0q9r1CoZC5u7uz5s2bsy5durDbt2+X+usXGhrKFixYIHbfRHTfpwC2bdvGNDQ0WIsWLdjatWuZv78/59/35cn3fxedO3dmWlpazNvbm+tIMkUjAxxo27Yt4uPj0aVLF0765/F4WLRoETZv3lyqc+ZLIhQKsWLFCixbtgzdu3eXXkAJbN26FVpaWpx+ImKM4eTJk9i+fTvWrFnDWY7fYYzBzc0Ne/fuRd26dWFjY4Nhw4aJ1IatrS3mzp0ro4TkO/Z/IwA3btyAo6PjjxEAa2tr9OnTh0YApCwkJASbN29GQkICDh06BF1dXYXZVl1WqBjggIaGBuLi4jjpu6ioCPr6+vj7778lPoPcyMgIo0aNEvkNRJbevn2LkydPcpohICAAf/75p8IWAowxuLq6Yt++fWjUqBFMTU3Rp08fkdsRCATw9vbGkSNHZJCSUAEgf0lJSTA2NoanpyeMjY1haGiIKlWqcB1LLqgY4EDbtm3h6ekp934FAgEMDAywYMGCUu15/yvHjx+Huro6dHV1pZROcjk5OcjMzJRo/YM0mJqaYvXq1XLtj8/nl+rawMBAjB8/Hn369MG5c+fQu3dvsfv18vLC4MGD5XrWQ3n37wLgxo0byM/PpwJADr59+4aDBw/C0tIShoaGiImJQd26dbmOJVdUDHDg+zSBvE2aNAmGhoYYMWKERO3Y2NggJycHGzdulFIy6fD09MSYMWM4zZCcnIygoCDY2trKpT/GGM6cOVOqlfxJSUmYM2cO9uzZg+XLl0vct62trVyLnvLM2dkZPj4+cHNzQ15eHnR1dXHlyhUqAGSMx+PBzMwMBw8exIQJE/Dq1SulPZmRigEO1KxZE3l5eXLtk8fjoWbNmhKfhujm5oYXL17gzJkzUkomPbdu3cLWrVs5zWBubg4DA4MfJ/bJWkREBJo2bfrbUws/fPiAMWPG4NixY5g8ebLE/ebl5eHNmzcSrTkh/9/69evRtWtXKgDkRCgUwsHBAdu2bYOmpiYePXqErl27ch2LU1QMcKRy5cooLCyU23zUo0ePMHr0aIna8Pf3h729Pa5cuaJwi2mKiooQHR2Njh07cpYhJycHtra2CA0NlVufd+7cwaRJk355TWpqKkaNGoW9e/dKpRAAAFdXV0yaNEnhvg/KoszMTHz9+hV2dnaoXbs213HKNaFQCG9vb2zatAkCgQAXLlzAyJEjuY6lEKgY4EirVq2QmJgo1Y1ifuXWrVs4dOiQ2Pe/f/8eq1evhq+vr0LOET99+hSDBw/m9M1pz549aNiwIerXry+3Pu/cuQMbG5sSX//y5QtGjRqF7du3S3V9h52dnUKODpVFDx48QJ8+fagQkDHGGLp3747k5GScOnUKc+bMoRGYf6GvBEc0NDTktm6gsLAQWVlZaNCggVj3FxUVYfXq1bhz547C7rh169YtTJkyhdMMQUFBMDMzk1t/Hz9+RGZmJjQ1NYt93dfXF126dMG6deswe/ZsqfabnZ0NdXV1qbWpzNzd3TF27FiuY5R7x44dQ2FhId68eYN58+ZRIfA/6KvBkbZt28rt8cLHjx9j+PDhYt+/fft2/P3331LfRldaGGMICAgQ6/E4aUlISMDnz5+hra0ttz7v3r1b7BqQqKgo6OrqYsWKFVi9ejUWLlwocV+ZmZlwcHDA3LlzMWLECE6/1uUJYwzu7u4YN24c11HKtVu3buHkyZPw8PBAo0aNuI6jkGiagCMaGhp4/vy5XPpycXHBgQMHxLr39u3bqFmzpsRPIMhSSEgIunXrxun0hY2NDRYsWCDXaYrr169j9+7dP/47ISEBe/bswfPnz7Fz507MnDlTok8/8fHxcHV1hZubG/h8PsaOHQtjY2NoamrSWgEpuXbtGtLS0tChQweuo5RbL1++hL6+Pu7cuUOjWb9AxQBH5DUyUFRUhIyMDDRs2FDkexMSEmBnZwd7e3sZJJMerqcIhEIhbG1t8fTpU7n16e3tjaCgIHTv3h0pKSnYv38/7t+/DyMjI1haWor1NINAIMCzZ8/g6uqKp0+fQk1NDRMnToS9vb3YU0zk12xtbWFsbExD1jKSmpqKSZMm4dSpU+jXrx/XcRSaCmOMcR1CWcljv4H79+8jISEBBgYGIt3H4/EwY8YMXLhwgfMDlX6Fx+OhQ4cOiIqK4mQ9A2MMmzZtgpOTExITE+XSZ3JyMgYNGoTLly/D1dUVzs7OWLduHQwMDFC1alWR2srKysL9+/fh6uqKqKgo9O3bFxMnTsSgQYOUZuc1rjx79gw6OjqIi4tD9erVuY5T7uTn52Po0KEYPny42COjyoRGBjhUu3ZtMMZkOuTq4uKCPXv2iHzfli1bsGHDBoUuBL7vqGhpaclJIVBUVIQ1a9YgNjYW/v7+cumTx+NhypQp6N69O+bPn4/ly5cjIiICNWvWLHUbiYmJP4b/CwoKMHr0aGzevBkdO3ak4X852rVrF7Zt20aFgAwwxrBkyRI0b94c+/bt4zpOmUDFAIdatWqFL1++oHHjxjJpn8/nIz09XeT2HR0d0aRJEwwaNEgmuaSBMYYNGzZg+vTpEi2OFFdGRgZ0dXWhoaEBNzc3uRzdLBQK0bZtW2RlZWHs2LGwsrIq1Zap2dnZ8PX1hbm5Ob5+/YqmTZti4sSJsLa2ltn3Hvk1X19fREVFwdXVleso5dLmzZsRHR2Np0+f0hRMKVExwCF1dXUkJSXJ7Afy3bt3RT6DIDY2Fi4uLrCzs5NJJmn4/PkzFi1ahOHDh0u8o6I44uLiMGXKFCxbtgyrVq2S26fpwsJCfPjwAQkJCWjVqlWJ13358gW+vr54+vQpgoKCUKVKFfTt2xfDhg3D8uXLRZ5KINK3a9cubN++nf4upEQoFCIwMBAuLi5wcnLCu3fvEB8fL9KImbKjYoBD34sBSQ6L+ZVr165h+/btpb4+Pz8fGzZswOXLlxWyms7KysKJEycQHx+PI0eOoFOnTnLP4O3tjUWLFsHMzEzuz4anpKSgSZMmPxUCjDEkJSXBx8cHPj4+CA8PR4MGDTBgwADo6Ojg8OHD9IajYLy8vBAfH4/FixdzHaVMKyoqgre3N1xcXHD79m1UrVoVU6dOhbW1NXr16kXf9yKiYoBD6urqMl10VqFCBZH22964cSOMjIwUbuU4j8eDhYUFfHx8sH79es5WBV++fBmHDx/GnTt3OClEkpKSoK6ujsjIyB9v/nFxcVBXV8fAgQOxYsUKdO7cWSF3iCT/YIxh165dMDY2pgWaYsjLy4OnpydcXFxw9+5dqKurY+rUqXBzc0Pnzp1pzYsEqBjgkLq6Ory9vWXSdm5uLmrUqFHq621tbdG2bVv07dtXJnnEIRAIYGdnB2dnZxgYGGD16tWc/GMXCAQwMjKCn58ffHx85DrPnpGRgYcPHyIpKQm2trZ49+4djh8/joEDB2LPnj1o27Yt/QAsQx4/foz3799jwYIFXEcpM9LT0+Hq6opbt27h4cOH6N69O6ZOnYo9e/agdevWXMcrN6gY4ND3aQJZeP78eal3iXv9+jU8PDxw9epVmWQRx4ULF3Dz5k3MnTsXLi4unE1bZGdnY+7cuVBVVcWjR49k8tRCfn4+4uLiEBsbi5iYGMTGxiIuLg6FhYVQVVVFfn4+Vq5c+WPjp2PHjkk9A5E9xhh27tyJnTt3ymXBaVkWERGBq1evIigoCM+fP8eQIUMwZcoUnD9/nha9yggVAxxq2LAhvn79KpO2fX19oaOj89vrPn78iJUrV8LZ2VlhPmF+/Pjxx0KgWrVqyayf6OhoXLx4EXZ2dujevTvatGmD1q1b//iVlZWFKVOmwNDQEAcPHpTo61NUVISEhIQfb/jf3/Rzc3NRvXp1aGhooH379vjzzz8xefJktGnT5j9znrdv36ZtgMuw+/fv4/Pnz5g7dy7XURQSn8+Hu7s7rKyscP/+fbRt2xY7duzArVu36BAnOaBigEOyfPONiooq1RanISEhGDRoEOrVqyezLKIQCoVYvXo1zM3NZVII5OXlwdnZGVeuXEHdunWhr6+PI0eOIDs7GwkJCUhISEBMTAwOHDiA6OhoqKmpwcfHB7q6uv8pFlq1avXTG7ZQKMT79+//84b/7ds3VKpUCa1bt0b79u3Rrl07DB06FBoaGiL9GT08PKChoSH1rwmRve+jArt27RJrd8jyLDo6GpcvX4a1tTVatGiBJUuW/Pj3SeSHvis59uHDB6SlpUl10R6fz0eFChVKNbSemZkJLS0tqfUtqSNHjmDWrFm/fHROHKGhobC0tERQUBCmT58OOzs7NGnS5MfrdevWRffu3cHj8bBz506MGjUKPj4+qFGjBoRCIVJTU5GQkIC3b9/ixYsXcHBwQGJiIgoLC/H582eoqqqievXqaNGixY83fD09PbRr104qRxq/ffsWALBt2zaJ2yLyVVhYCH19fURFRUFPT4/rOAohJycHN27cgJWVFd68eYO5c+fC09MTXbp04Tqa0qJigGPNmzeX+ur9V69elfopgvfv33OyMr44/v7++PjxI4yMjKTSXmZmJuzt7WFnZ4fWrVtDX18fZ8+eLXZEJi8vDzt37oS7uzsuXrz40xMLFSpUQLNmzdCsWTP079//P/dmZGSgVq1aMv3Ed+3aNejo6NDjUmXMq1evsGDBAjRo0AAeHh5K/aQHYwzPnj3DpUuX4OTkhL59+2LNmjWYNGkSfV8rACoGOCTqiv/S8vX1xYABA0p1bXJyMlq0aCH1DKL69u0bDh06BEdHR4naYYzBz88PlpaWiIuLw+zZs+Hq6vrLIcc3b95AS0sL+vr6CAoKEnl7WFkPZzLGYGdnh/Pnz8u0HyI9fD4fR44cgYmJCQ4cOAADAwOFWZPDBS8vL0yePBkNGjTAokWLEB4eDjU1Na5jkX+hYoBDMTExaN++vdTbDQoKKvXBROnp6ZyvF2CMYc2aNTh69KjY+7R//vwZNjY2uHHjBnr06IFVq1ahR48ev/0B/PDhQyxbtgzW1taYOnWqWH3LWmhoKHJzc0td4BFuvX79GgsWLECtWrUQFBREj78B+PTpE9q3b4/nz58r5IZmhIoBTr1580bq55gzxsDj8UQaduP6E4u5uTmGDBmCP//8U+R77e3tYW1tjaKiIsyfPx+PHz8u9Rak5ubmOHPmDNzc3BT6PHlbW1vMnj2bfogqOIFAABMTExw6dAh79uzB33//TX9n/8fBwQGtW7emr4cCo2KAQ9HR0VLfTS8hIQFt2rQp9fWyerSxtLy9vREYGIhLly6JfK+zszOOHz+O48ePY+jQoaW+j8/nY+3atXj9+jV8fX2lssBPVvLy8mBhYYFHjx5xHYX8QkxMDBYuXIgKFSrgxYsX9NTH/+jcuTOcnZ1lfkorER+VaRySxciAKOsFEhISflpRL29FRUXYvHkzDh06JNIPCMYYDh48CHt7ezx9+lSkQuDjx48YO3YsioqK4OnpqdCFAAAcOnQImpqatL+AgioqKoKuri60tbWho6MDb29vKgSKsWPHDhQUFODx48dcRyEloGKAQ+/fv5f64j1/f/9Sjza4urpCX19fqv2L4uTJk9ixY4dIBQmPx8OCBQuQk5MDR0fHUk8JCAQCWFtb488//0S3bt1gYWGh8LvAxcTEwMzMDDdv3qRPUwro6dOn6NGjB4KCguDs7Iz169cr9dMCv1KpUqUfhT9RTFQMcEQoFAKA1OfQMjIySr0g0N/fn7OzCN6+fYvIyEhMmDCh1Pd8/vwZY8eOxYgRI3Dw4MFSf+3s7OzQq1cveHh4ICQkBMeOHVP4N1fGGJYvX47NmzfTAjQFk5KSgjlz5kBPTw9GRkZ4+/Ythg0bxnUshTdv3jwEBgbCxsaG6yikGLRmgCOJiYlSf7QmLS2t1MPemZmZqFmzJie7oTHGYGRkhJMnT5b6noiICCxevBgmJiYirao3NzeHsbEx3NzcoK2tLU5cTtjZ2eHTp0/YsGED11HI/yksLMTp06dx8OBBLFmyBFFRUVBVVeU6Vpnw/v17LFy4EE2aNMEff/zBdRxSDCoGOOLq6goejyfVNm/fvl3qR/M8PT0xZswYqfZfWmZmZj828SmN27dv4/Dhw7h+/bpIiyMfPnwIU1NTREVFlanDTdLT07Fx40Y4Ozsr/FSGsnj06BFWrlyJ5s2bw8/PT6wnX5TV9evXsWrVKqxYsQLGxsb0Pa2oGOHE8uXL2fPnz6XaJo/HY7q6uqW6dvHixSwzM1Oq/ZfW7NmzWU5Ozm+v4/P5bPv27UxTU5NlZGSI1MerV69Y69at2Zs3b8SNyZl+/fqx2bNncx2DMMbevXvHdHV1mZqaGrtx4wYTCoVcRyozvn37xubMmcPatm3L/P39uY5DfoPWDHCAMYagoCD06tVLqu1WqVIFLVu2RGxs7C+v4/P5yM3N5WSIMzk5GXXr1v3twr9Pnz5hwoQJqF27Nl6/fo06deqUuo+UlBRMmzYN1tbW0NTUlDSyXF26dAlRUVHYvXs311GUGo/Hw8GDB9G1a1doaGggKioKOjo6Cr/WRFHcvXsXXbt2RfXq1fHy5UvO1iYREXBdjSijN2/eyOyTX2RkJNu6dWuJr/N4PLZixQq2fv16mfT/O3v37mVBQUG/vObJkyesd+/ezMfHR+T2k5OTmaamJrO3txc3Imf8/PxY/fr12atXr7iOotTc3d1Zu3bt2JgxY1h0dDTXccoUgUDA1qxZwypVqsScnZ25jkNEQMUAB06ePMmuXr0qs/anTZvGioqK/vP7wcHBbMKECezBgwcy6/tX+Hw+mzRp0i9f37t3L5swYQL78uWLyO17eXkxdXV1NmvWLElicuLdu3esadOmzMXFhesoSuvt27ds8uTJrFWrVuzWrVs0JSCitLQ0NnbsWKatrc1iYmK4jkNERNMEHDAzMxNpoxxRjR8/Hvfu3fvx34WFhdi1axcuXboEOzs7jBgxQmZ9l4TP52P58uX466+/in29qKgIf/31F1RUVHD79m00bNiw1G3zeDxs3rwZq1atwq1bt2Bvby+t2HKRl5eHKVOmYMWKFZgyZQrXcZROamoq9PT00LNnT3Tr1g2vX7/G5MmTaUpABCEhIejZsydat24Nb29vtGvXjutIRFRcVyPKJi0tjQ0YMECmfdy6dYuNHz+eMfbPaMDEiRM5Gw1gjLHs7Gymp6fH3Nzcin1dKBSy5cuXs1OnToncdnh4OOvWrRtbu3Yty8/PlzSq3AmFQjZz5kymq6tLn0TlLCIighkaGjJVVVXWqlUr+jQrJktLS1a/fn2ZjnYS2aNHC+Xs9u3b0NXVlVn7Dx8+xK1bt+Do6Ihdu3YhLS0Ntra2nD0PnZKSguXLl2Pv3r3o2rVrsdds3LgR8fHxOHfuXKnbFQqFMDU1hZmZGSwsLDgZ7ZCGQ4cOISYmBj4+PvRJVA74fD5cXV1x5swZREREYOnSpYiIiKDjdMVQUFCAlStXwtvbG0+ePEGXLl24jkQkQMWAnDk7O8vsXPp169YhKCgIQ4YMwZgxY7Bjxw6MHDlSJn2VRlhYGHbs2AFzc3M0b9682GueP3+Oly9fws3NrdTtJicnY+HChWjYsCFevHih8OcLlOT27ds4c+YMnj9/XuptlYl4vn79CktLS5ibm6Nx48ZYtWoVZsyYgWrVqnEdrUzKyMhA69atMXDgQAQFBYn0tA9RUFwPTSiT9PR0NmTIEJm0/e7dO1avXj129epV5uvry969eyeTfkrLy8uL9evXj2VlZZV4zadPn1jv3r1ZSkpKqdvdunUrU1NTY3Z2dmV6WD08PJw1aNCA+fr6ch2l3BIKhSwkJIQtWrSIqaqqstmzZ7Nnz56V6e8bRREbG8vq1q3LBAIB11GIlNDIgBzduXMHkydPlknbe/fuxYEDBzB37lyZtC+KvLw8HD9+HG5ubqhdu3ax1/D5fMybNw8nTpxA06ZNS922u7s7LC0tMWrUKGnFlbs3b96gb9++OH78OPr37891nHIpOTkZ3bt3h4qKClauXIno6GhOT+gsb6KiotCjRw+pn61CuEN/k3Lk7OwMHR0dqbcbHR0NHx8fTk8g/DcjIyNs27btl0OHxsbGGDt2LAYOHChS21lZWWX6DTQzMxN6enoYNWoUDAwMuI5TLrm7u6Nnz57Q1dVFUlISdu7cSYWAlL1+/brEJ4NI2UTFgJwEBwcjIiJC6kcWA/+cFb5z506F2PPb1dUVDRs2/OWOY1u3bkVkZCTWrFkjUttRUVFITU1FjRo1JI3Jifz8fEyaNAm9evWCk5MT13HKHT6fj23btmHx4sWws7PDuXPnSn1WBxFNYGAgnc9QztA0gRxERUVh+fLlcHZ2lnrbwcHBiI2NxaxZs6TetqhSU1Nx+fJlODo6Fvv69/0AkpKScPHiRZFWz6empmLq1Kk4f/58mVx1z+fzMXPmTDRs2BAWFhZl8s+gyD58+AA9PT1UrFgRISEhIk09EdGEhobC1dW1zD7BQ0rA9aKF8i4yMpL17t2bxcXFyaT9UaNGsbt378qkbVEIBAI2c+ZMlpCQUOzr8fHxbODAgczS0lLkBVzfvn1j3bt3Z7a2tlJIKn98Pp/p6Oiw4cOHs4KCAq7jlDtHjx5l9erVY8bGxsXuvEmk59mzZ6xhw4Zlcrtv8mtUDMhQeHg46927N4uPj5dJ+46Ojqx///4KsTr61KlTzM7OrtjXnJ2dmba2tlh77ufl5bGBAwcyU1NTSSNyIi0tjfXv35/Vq1fvl09WEPE8evSI1a5dmx0+fJjrKOWejY0Na9CgAW2ZXU5RMSAjYWFhrHfv3iV+UpYUj8djTZo0YefPn5dJ+6IICwtjS5Ys+c/vZ2ZmssWLF7O5c+ey7OxskdvNyspiw4YNY8bGxtKIKXd+fn5MTU2N/f3332L9+cmvPX78mNWvX5/T3TXLu/fv37Njx46xbt26sSpVqjALCwuuIxEZoWJABkJDQ5mWlhZLTEyUWR87duxgq1atkln7pZWXl8cmTJjAMjIyfvr9hw8fsi5durAVK1aIPXJx5MgR1qVLF4UY+RCFQCBghw8fZg0aNGA3btzgOk659OTJE1a/fn3m6enJdZRy5+vXr8zCwoINGjSIqaqqsvnz5zMPDw9WWFjIdTQiQ1QMSFlwcDDT0tKS6aY/wcHBrEOHDiwnJ0dmfZTWmjVrmJ+f34//Tk1NZXPmzGFz5sxhHz9+lKjtAQMGsMDAQEkjytXnz5/ZmDFjWK9evWQ2PaTsvLy8WP369ZmHhwfXUcqN/Px85ujoyNq0acOqV6/Opk6dyhwdHVleXh7X0YicUDEgRYGBgUxbW5u9f/9eZn1kZmayv/76i3l7e8usj9K6e/cu2717N2Psn0Vy586dY1paWuzhw4cStx0ZGcm6d+9eZkYF8vPz2a5du1i9evXY2rVrGY/H4zpSueTt7c3q16/P3N3duY5S5gmFQubj48OWLl3K6tWrxwYNGsR2794t0xFNorjo0UIpsbOzw/Hjx3Hv3j00a9ZMZv1cvnwZADBo0CCZ9VEaISEhOHv2LE6cOAE7OztcuHABI0aMwNOnT1G1alWJ27e0tMTSpUsV/hG86OhoXLhwAdbW1tDQ0MCKFSuwf/9+rmOVSxYWFti2bRvs7OwwZswYruOUWXFxcbh69SpsbW1RsWJFzJ8/H8HBwWjdujXX0QiHVBhjjOsQ5cGECROwadMmDB48WKb9pKSkYNy4cXj58qVM+/kVxhgaNWoETU1NaGpqIjExEWfOnJHajmSpqano3Lkz4uLiFPIAlMLCQri4uMDCwgLh4eFYsGABli1bBk1NTa6jlUtFRUXYt28fTExMYGRkhO3bt3MdqUwoKCjAu3fvkJSUhKSkJDx+/BghISH48uULZs2ahXnz5kFbW1vhC24iHzQyIAUCgQCfP3+Wy6f1pk2b4vPnz+Dz+ahUiZu/PldXV/Tt2xeurq4yaT8rKwtVqlRRuEIgPj4eFy9exKVLl6CpqQkDAwPo6OjQyXcyFBMTg7lz56J27dp48+aNTHbwLKsyMzN/vNEX9+vr169o1qwZ1NXVoa6ujipVqmDu3LnYtGmTVEbvSPlCxYAUPH/+XG4VtoqKCtq1a4fY2FhOtgMVCoXYuXPnj+kKWWjXrh2EQiGEQiHnB6F8+PABlpaWcHBwwMePHzFv3jw8fvwYnTp14jRXeccYw/nz57F9+3YYGxtjzZo1nH8v/Nv58+dRsWJFaGtrQ11dHaqqqjLpJzc3F5GRkQgPD4eDgwOys7ORm5uLpKQkFBYWomXLlj/e7NXV1TFhwoQf/7958+YKsUU5KRuoGJCCe/fuYfz48XLrr3PnzoiIiOCkGDh06BCaN2+O7t27y6wPFRUVqKmpITk5GS1btpRZP8UpKiqCv78/3N3d4e7ujsTERPTt2xeDBw/GiRMnyuy5CGVJamoqlixZguTkZHh7eytM4cUYg7u7Ow4dOoTIyEioq6vj8OHDeP/+PWrUqPHTm/K/f7Vo0QK1a9dGUVERCgsLwePxiv3fL1++ICoqCjweD+Hh4YiIiMD79+/Rrl07dO7cGS1btkTHjh0xYMAAqKuro3HjxjTET6SGigEp8PLywo4dO+TWX6dOnRAeHg5dXV259Qn8MwdpZmaG8+fPy7yv76Mf8igGPnz4AA8PD7i7u+Phw4do2bIlxo4dC1NTU/Tr1w9VqlSReQbyj1u3bsHAwAALFizAzZs3OR3OZowhKSkJz58/x9OnT2FjYwM1NTVs3boVenp6Pz51C4VCpKamIikp6ccc/du3b/HkyRMkJSUhOjoaAoEA1apVQ5UqVVC1atVi/5fP5+Pr16/Q09PDjBkzsHfvXmhqatKQPpELKgYk9P79ezRs2FCu88adO3eGp6en3Pr77uTJk5gxYwYmTpwo875atWqFN2/eYPjw4VJvu7hP/yNGjMDYsWNx6tQpmpfmSP/+/REbG4sbN27IfCFucTIzMxEYGIjnz5//+CUQCKCtrQ0tLS3s2LED69at+8/Qe4UKFdCsWTM0a9as2NM6v095cbXGh5DSoKcJJPT9FL1ly5bJrc/MzEz06tULsbGxcuszJSUF/fv3R0hICOrVqyfz/pYuXYqkpCTcv39fam2eO3cO1tbWiI6Ohrq6OsaOHYuxY8eiX79+NLfKsZCQEAwbNgxBQUHQ0NCQeX98Ph/h4eE/vfEnJCSgS5cu0NbWRp8+faCtrY02bdrQUDxRClSqSsjU1BR3796Va5916tRBUVERcnNzUbNmTbn0aWRkhK1bt8qlEAD+mTfeuXOnVNri8XjYuXMnLl68iNmzZ+PmzZto3ry5VNomkhMKhVi+fDkOHz4s1UKAx+Ph/fv3SEhIQGJi4o//ffDgAXJyctCiRQtoaWlBW1sbhoaG6NatGw3JE6VFxYAE0tPTUbduXbRp00bufa9cuRKdOnVCQkKCzPt6/vw5Xr16hUuXLsm8LwB49+4dAgIC0KdPH4nbioyMxJw5c9C0aVNERkbSOfcK6OzZs2CMYenSpSLfm5SUBB8fHxQWFv70hp+QkIDU1FQ0adIErVu3RqtWrdCqVSuMGDECw4YNw/Dhw2mTHUL+haYJJHD+/Pkfn2q40KxZM6SkpMi0D4FAgLZt2+Ly5csYOnSoTPuKioqCiYkJPDw80LdvXzg6OordllAoxJkzZ7Bnzx7s378fy5cvp+FeBeTn54fBgwfj7t27pd5VkDGGZ8+ewcrKCvb29qhfvz4GDRqEVq1a/Xjjb926NdTU1OiTPiGlRCMDEnBwcMCNGze4jiFToaGhqFatmswKAcYYvLy8cOLECSQmJmL9+vU4c+aMRAsyX716henTp6NOnTrw9/dHhw4dpJiYSMvTp08xbdo0XL169beFQGFhIV68eIFTp07hxYsXqFy5MhYvXozo6GioqanJKTEh5RcVA2J69uwZVFRU0KBBA66jyNSdO3dgaGgo9XaLiorg6OgIExMT1KtXDxs2bMCYMWMk/vR+7949LFq0CF26dMG9e/fok6GCevDgAWbNmlXiOQMCgQAvX77Eo0eP8PjxY/j6+qJNmzZo3749duzYgSVLlijUJkSElHVUDIhJIBAgLy+P6xgyd/PmTbi5uUmtvbdv38LJyQnnz59H//79YWVlhW7dukncLo/Hw9atW+Ho6Ijr169j2LBhkoclMuHq6opFixbBycnpx4gTYwxRUVF4/PgxHj16BC8vLzRs2BDDhg3DokWLYGNjg8aNG3OcnJDyi4oBMQ0YMADt27eX2kI3RfTmzRvUqFFDahv/xMTEQFtbG9OmTcPTp0+ltqI/JiYGs2bNQrNmzfDy5Us0atRIKu0S6btx4wZWrFiBO3fuoGnTprCysvrx6b9ixYoYPnw4Jk+eDFNTU7nvPkmIMqMFhBKIiorCtm3b4OLiwkn/sl5AePDgQVSoUAFbt26VuK3Q0FDo6Ojg/PnzGDFihBTS/fNp0sbGBuvXr8fOnTuxevVqWiSowPbs2QMTExMMHToUYWFhyM7OxtChQ3+s7m/Xrh39/RHCERoZkMCff/6JihUrIjw8HJ07d+Y6jtQ5Ozvj+vXrErfj6+uL+fPn49q1a1IbRcnOzsby5cvx4sULPHjwAD169JBKu0T6vj82aGVlhf79+2PQoEHYvXs3unTpQvP+hCgIKgYktHXrVhw+fBh2dnZy7ZfP58u0/YSEBPD5fLRr106idtzd3bFq1Srcvn1bagVTUFAQZs2ahQEDBiA4OBi1a9eWSrtE+oRCIdasWQMXFxd4eXlxss0wIeT3qBiQUK9evfDt2zfEx8ejbdu2cukzPT0dI0eOhFAolFkflpaWEp9B4ODggF27dsHT01MqXxvGGHR0dPDo0SOYmZlhzpw5ErdJZCM3NxcODg7Ys2cPvnz5guDgYE5O2SSElA6N0UnBli1bcPToUbn0lZ+fj8mTJ0NfX1+mn4jt7OwkGnrfvn07Nm3ahMePH0ulEMjMzMSSJUsQGBiImzdvUiGggBhjCA0NxfLly9G0aVMcOnQI+vr68PHxoUKAEAVHCwilgDGG4cOH4+rVqzLd814gEGDGjBn4888/sX//fpn1k56ejl69eiE+Pl7sBV1z5szB2LFjMXfuXInzCIVCtGvXDjVq1ICfnx9UVVUlbpNIV3h4OPr374+CggLo6Ohg2bJlGDx4MC0IJKSMoJEBKVBRUcGGDRtw4sQJmfXBGMOaNWugqqqKffv2yawfAPD09MTo0aPF/kHOGIO/v7/Ujjo+fPgwVFVV8ezZMyoEFExRURH27duH3r17Y9iwYYiJicG1a9cwZMgQKgQIKUNozYCUjBs3DgcPHsTXr1/RsGFDqbd/+PBhxMfH486dOzL/IXvv3j3MmjVL7PsfPnyI/Px81KlTR+IsDx8+xKlTpxAYGIhatWpJ3B6RnrCwMCxatAjZ2dl48OABBg4cyHUkQoiYaGRASlRUVLB69WocPnxY6m1bW1vDxcUFN27cQOXKlaXe/r8JBAJ4e3tLtINfSkoKpkyZInGWd+/eYc6cObC1tYW6urrE7RHJvH79GkVFRSgsLMTu3buhra39Y88AKgQIKduoGJCiadOmwdXVFQsXLsTbt2+l0ubRo0exe/du3L17Vy6fjAMCAtClSxfUqFFD7DYCAwMlPtiIx+NBR0cHK1euxKhRoyRq69/evXsHLS0txMTESK1NZdG9e3dUr14dqqqqsLa2xuPHj3HixAmJvlcIIYqBigEpqly5MqKjo7FkyRIYGhpi2bJlEhcFDx8+xO7du+W2L/u9e/cwfvx4idp48eIFtLS0xL6fMQZDQ0M0btwY27dvlyjLd0KhEBYWFujUqRPev3+Pzp07w9DQEO/fv5dK++Udj8cDn8/HzZs3sWbNGvj7+6Nfv35cxyKESAsjMiEUCtnDhw+ZmpoaO336NBMKhSK3wefzWfPmzVl+fr4MEhZPTU2NJSYmin1/fn4+a9GihVh/3u+uXLnCqlSpwtLS0sRu49+uX7/O/vrrL9a0aVPm5OTEhEIhCwkJYRMnTmRVq1Zlo0ePZnfu3JHr17ms8fT0ZBUqVGB5eXlcRyGEyACNDMiIiooKhg8fjri4OMTGxmLx4sXIz88XqY3Q0FB07NgR1apVk1HKnwmFQmRlZUl0QIybmxuaN28u0SJHR0dHHDlyBPXr1xe7DYFAgNu3b2PQoEGYO3cuatasiaioKEyfPh0qKiro3r077ty5g6dPn+Lly5eYPXs2VFVV0bdvX2zYsAHOzs4yPfehrLl79y7atWuH6tWrcx2FECIDVAzIWJUqVXD69GmMHDkSQ4YMwf3790t974MHDzBy5EgZpvtZhQoV0KhRI4mOZrazs5No+DgqKgrPnz/H0qVLxbo/NzcX586dQ4cOHaCvr49hw4YhOTkZz58/L/bpBi0tLaSmpiIzMxMhISFYtGgR0tLSYGRkhObNm6NVq1aYPXs2zp49i5CQEJlvA62IioqKcOPGDRw6dIjrKIQQGaFNh+To7t27MDExgVAohJ6eHmbOnIm6deuWeP2wYcNgYmKCbt26yS2jlpYWbt68iRYtWoh879u3bzF69GhERkaiSpUqYvW/dOlS/PHHHyJvqvTx40ecPXsWFhYWaNy4MdavX4+5c+dK9En2y5cvCAgIgL+/P/z9/fHixQtUqFABWlpaqFq1KmbNmoUpU6b88u+wPLh+/TrWr1+PpKQkmT/NQgjhBhUDHEhPT8f169dx/fp1tGjRAosWLcKwYcNQsWLFH9fExcWhc+fOyMnJ+en3ZW306NE4fvy4WIcK6evrQ1tbW+xP9UlJSejSpQuio6PRpEmTUt3j5uYGR0dH2NvbY8CAAdiwYQPGjBkjk9PwCgsLERYWBj8/P5w6dQr5+fn48uULOnXqhAEDBvz4Jck0iywxxpCbm4vPnz/jy5cv+PLlC+7evQtDQ8MSC868vDw0a9YMgwcPxu3bt+UbmBAiP5yuWCAsPDycbdiwgfXq1Ytt376dxcbGMsYYmzx5Mrtw4YLc88ycOZN5e3uLfF9CQgLT0NBgPB5P7L5Hjx7NOnfu/Nvr+Hw+c3FxYf3792cAmK6uLgsNDRW7X3EJhUKWkJDArl69ygwMDNhff/3FADA1NTWmp6fHzMzMWFhYGOPz+XLPVlRUxAIDA9mxY8dY9+7dWY0aNVi1atUYAAaA1alTh7Vt25bVqVOHVapUic2ZM4c9fPjwpzYKCwvZ+PHjWZcuXdjbt2/l/mcghMgPjQwoiKKiIri7u+PKlSsIDQ2FQCBAXFyc2MPtomKM4fHjx9DX18fChQuxa9cuke6fP38+BgwYgGXLlonVP5/PR6tWrXDt2jUMGjSo2Gu+ffsGKysrnD17Fvn5+TA0NMTs2bOhqakpVp+ykJ6ejmfPnsHX1xe+vr548eIFqlWrhn79+v0YOdDS0pL6QjyBQICXL1/Cy8sLT548gY+PD4qKitC/f3907doVLVu2xKBBg9C4cWM0bNjwp++r8PBwnDp1CpcvX0aLFi0wd+5cTJ48GefOncPz58/h6+srk101CSGKg4oBBeTp6Qlzc3NERUXByMgIenp6qFq1qkz6ysrKgo2NDczNzaGuro4FCxZgwoQJqFmzZqnbiI+PR9euXfH161exn3y4c+cO9u7di6CgoJ9+nzEGV1dXuLq64tq1a/jzzz+xZs0azJgxQ2ZfE2kqKChAcHAwfH194efnB19fX+Tk5KBnz54YMGAANDU10aNHD3Tq1Emkwo/H4+HmzZtISUmBl5cXnj59+uPNf8iQIRgyZAh69+4tUpsxMTHw9fXF3bt3cffuXVSoUAHR0dG0+yMhSoCKAQUWGxuLRYsW4f3793j06BE0NDSk1vbr169hZmYGV1dX6OrqYvny5WK3v2bNGmhoaGDVqlVi5xk3bhymTZsGfX19ZGZm4tGjR/Dw8IC7uzuSk5MxYsQI7NmzB3379i3TB+AIhUK8efPmx8jB7du3kZWVBQBo3LgxWrRogebNm6NFixY//f969erh48ePCAoKgq+vL/z9/ZGXl4fBgwf/eFJF1Df/X0lPT0doaCiGDx8ulfYIIYqNioEy4M6dO1i7di22bduGJUuWSPRm6O3tjWXLlqF69epYuXIlZs+eLdF2sp8/f4aWlhZev34tdjuhoaEYNGgQ1q1bhydPnuDZs2dQU1PDmDFjMHr0aPTr109uOzByIScnB58/f0ZycjKSk5Px4cOHH///+6+UlBTUqFEDo0aN+jHd0KlTJ5FGcAghpCRUDJQRnz59wuLFixEbG4vw8HCxh8gPHz6MmJgYWFlZSeUT9oYNG9CwYUMYGRmJ3cYff/yBL1++YMyYMT8KgPbt25fpEQBpS09PR7Vq1egcAEKITNARxmXEH3/8gcWLF+P06dMSzZV7enrCxMREKm+0fD4f586dQ2JioththIWFIS0tDb6+vrTX/S9IshsjIYT8DhUDZQRjDEeOHMG5c+fEbiM9PR1JSUlS28ToxYsXGDZsGP744w+x29i8eTOWLl1KhQAhhHCIioEy4sKFC6hUqRJ69eoldhv37t3DuHHjpDb8bmZmJtab+PfFadevX4e3tzdsbGykkocQQoh4qBgoAxhjMDMzg6GhoUTt3L59GwYGBlJK9c/z6fPmzSvxdcYYkpOTERoa+tOvd+/e4Y8//oCamhqmT58u0cgCIYQQydECwjLgwYMHOHz4MB49eiR2G+np6dDQ0EBqaqrUHj9r3bo1IiMjUaNGDQgEAsTExPz0pv/y5UukpaWhTZs26N69+0+/mjZtKpUMhBBCJEfFgIJjjKFv3744ceIE+vfvL1YbAoEAkyZNQvXq1eHk5CSVXE+ePMH48eOxcOFChIaG4tWrV+DxeOjYseNPb/rdunUr9rRAQgghioOmCRScu7s76tatK3YhEB0djS5duqBly5Y4cuQIEhMToa6uLva6gS9fvmDv3r0/FjLm5eVh8eLF6N69Ozp16iT2DoSEEEK4Q8WAgtPS0sKbN2/Evt/c3ByFhYX48uULpk+fDgCoV68eunXr9uPTe9u2bdG5c2fUqlWrxHby8/NhamqKQ4cOQSgUYu/evVi3bh09904IIeUATROUAc2aNUNKSorI9xUVFUFNTQ2amprw8vL6z2K+kJAQvH///sf11apVQ7169X78ql+/PurVq4dPnz4hKCgIGRkZWLZsGXbt2kWL/gghpByhkQEFFxkZiaKiolJfn5+fj6dPn8LDwwOOjo749OkTjI2NoaKiAjU1NaipqWHSpEk/rk9LS8OVK1fw9etXNGrUCN++ffvpV0xMDCIjI1G/fn34+vqiQ4cOsvhjEkII4RAVAwouJSUFBQUFJb7OGENsbCw8PDzg4eEBLy8v5Ofno1KlSujZsyfat2+PqVOnlnh/gwYNsGHDhl9mKCwslNtRyoQQQuSPpgkUHI/HQ9u2bREfH4+cnBwkJCQgJiYGFy9eRHh4OHJycsDj8QAA6urqGDNmDMaOHYuhQ4dCVVWV4/SEEELKAioGyoBKlf4ZwBEIBP95rUqVKjhy5AjGjBkDTU1NOtyHEEKIyGiaQMElJydDIBBAXV0dBgYGaNOmDVq3bo03b95gzJgx5fpoX0IIIfJBxYCCO3r0KIB/HjH89zHBWlpaXEUihBBSztA0gQITCARo164dUlNTERwcjD///JPrSIQQQsqhClwHICXbvHkzEhISMHPmTCoECCGEyAyNDCiooKAg9OvXD0KhECEhIejSpQvXkQghhJRTNDKggD58+IDJkyejYsWKePbsGRUChBBCZIoWECqYvLw8TJ48GSkpKXBwcEDv3r25jkQIIaSco2JAgfD5fPTr1w9hYWHYs2cPZsyYwXUkQgghSoDWDCiQ6dOn4+bNm+jYsSMiIiJoAyFCCCFyQWsGFISdnR1u3ryJVq1awcfHhwoBQgghckPFgAKwtrbG4sWLoaamhmfPnqF+/fpcRyKEEKJEaJqAY2FhYejevTtUVFQQHByMbt26cR2JEEKIkqGRAQ5lZGRg8uTJYIxh69atVAgQQgjhBI0McOTbt2/o0qULkpOTMXv2bNjZ2XEdiRBCiJKikQEOJCUloX///khOTkb//v1x5coVriMRQghRYlQMyFlISAj69OmDN2/e4NSpU/D19UXlypW5jkUIIUSJUTEgRwcOHMCgQYOQkZEBJycnrFmzhutIhBBCCK0ZkJdjx45h8+bNqFy5Mry9vdG3b1+uIxFCCCEAaGRALs6ePYvNmzejbt26uHv3LhUChBBCFAqdTSBDjDEcPHgQxsbG0NTUxIMHD6CmpsZ1LEIIIeQnVAzICGMMmzZtwokTJ9CjRw94eHigUaNGXMcihBBC/oOKARkQCAQwMDCAlZUVBg4cCFdXV9SpU4frWIQQQkixqBiQMh6Ph7lz58LJyQljx46Fk5MTatSowXUsQgghpES0gFCKcnNzMWnSJDg5OWHmzJm4desWFQKEEEIUHhUDUpKRkYFRo0bh/v37WLZsGezs7FClShWuYxFCCCG/RcWAFHz69AlDhgyBv78/tmzZAgsLC1SsWJHrWIQQQkip0JoBCb179w4jRoxAbGwsDh06hK1bt3IdiRBCCBEJFQMSePPmDUaOHIkPHz7A3NwchoaGXEcihBBCREbFgJhCQkIwevRoZGRkwM7ODnp6elxHIoQQQsRCxYAYfHx8MGHCBBQWFuLWrVsYP34815EIIYQQsdECQhG5ublh1KhRYIzBw8ODCgFCCCFlHo0MiOjmzZuoWbMmPD090bNnT67jEEIIIRKjI4xFxOfzkZycjFatWnEdhRBCCJEKKgYIIYQQJUdrBgghhBAlR8UAIYQQouSoGCCEEEKUHBUDhBBCiJKjYoAQQghRclQMEEIIIUqOigFCCCFEyVExQAghhCg5KgYIIYQQJUfFACGEEKLkqBgghBBClBwVA4QQQoiSo2KAEEIIUXJUDBBCCCFKjooBQgghRMlRMUAIIYQoOSoGCCGEECVHxQAhhBCi5KgYIIQQQpQcFQOEEEKIkqNigBBCCFFyVAwQQgghSo6KAUIIIUTJUTFACCGEKLn/BzO1LTaK1QHHAAAAAElFTkSuQmCC",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -593,9 +614,16 @@
    "execution_count": 20,
    "metadata": {},
    "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Ignoring fixed x limits to fulfill fixed data aspect with adjustable data limits.\n"
+     ]
+    },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgQAAAGVCAYAAACB0OntAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAdgUlEQVR4nO3da3BU9eHG8WcvuYckkkRIJCAECATKZRK1giKi7ehUcBSLOlA7U7W1I0O1VWa0iqJtnaEdx+lFa42+aamlGLXNONo6CChIRbwgUROQcIkkGHIx92Sz2fN/oeafywaSsLu/s3u+n1dMsjn78AL4cvbsWZdlWZYAAICjuU0PAAAA5hEEAACAIAAAAAQBAAAQQQAAAEQQAAAAEQQAAEAEAQAAEEEAAABEEAAAABEEAABABAEAABBBAAAARBAAAAARBAAAQAQBAAAQQQAAAEQQAAAAEQQAAEAEAQAAEEEAAABEEAAAABEEAABABAEAABBBAAAARBAAAAARBAAAQAQBAAAQQQAAAEQQAAAAEQQAAEAEAQAAEEEAAABEEAAAABEEAABABAEAABBBAAAARBAAAAARBAAAQAQBYBsHDhzQ3//+d9MzADgUQQDYRGtrq7xer+kZAByKIABsoqOjQ8nJyaZnRJzP5zM9AYAIAsA2Ojo6lJKSYnpGxK1fv970BAAiCADbaG9vd+QZAgD2QBAANuHElww6OzuVmJhoegYAEQSAbTgxCBoaGpSVlWV6BgARBIBttLe3O+4agvr6emVmZpqeAUAEAWAbTj1DQBAA9kAQADbR0dGhpKQk0zMiiiAA7IMgAGzC7/crLi7O9IyIIggA+yAIABhTX1/PRYWATRAEAIxpamrSOeecY3oGABEEAAwKBALyeDymZwAQQQDAIMuyTE8A8DWCAAAAEASAXfC/ZQAmEQQAjHG5XKYnAPgaQQDYhNP+cfT7/VxQCNgIQQDYxJEjR0xPiKjGxkaNHz/e9AwAXyMIABuwLEtTp041PSOi+GAjwF4IAsAGuru7lZCQYHpGRHHbYsBeCALABjo6Ohz30ceHDh1SYmKi6RkAvkYQADbgxI8+rqio0PTp003PAPA1ggCwAScGQXt7u2bPnm16BoCvEQSADbS3tzsqCDo7O5WUlGR6BoB+CALABpx2hmDPnj1atGiR6RkA+iEIABtw2kWFO3bs0GWXXWZ6BoB+CALABpx2hqCxsZG3HAI2QxAANuCkawhaW1uVmppqegaAQQgCwAacdIbgrbfe0pIlS0zPADAIQQDYgJOuIXjzzTd16aWXmp4BYBCCALABJ50haGtr07hx40zPADAIQQDYgFOuIWhoaOATDgGbIggAG3DKGYKdO3dq6dKlpmcACIIgAGygt7dXXq/X9Iyw2717ty6++GLTMwAEQRAAiJiuri5uWQzYFEEA2EAgEDA9IexqamqUk5NjegaAYRAEgA1UVVWZnhB227dv17Jly0zPADAMggCwgblz56qjo8P0jLDau3evLrjgAtMzAAyDIABsID8/X5999pnpGWHl9/sVFxdnegaAYRAEgA3MmDFDhw4dMj0jbPbu3cvnFwA2RxAANhDrQbBjxw6tWrXK9AwAp0EQADaQm5urmpoa0zPCpqqqSkVFRaZnADgNggCwAZfLZXpC2Bw9elTnn3++6RkAzoAgABBW//znP/X973/f9AwAZ0AQADaRkpKitrY20zNCrqqqSvn5+aZnADgDggCwienTp8fcWw8/++wzYgCIEgQBYBOx+E6DrVu38u4CIEoQBIBNxGIQHDt2TFOmTDE9A8AIEASATUycOFEnT540PSNkKioqVFBQYHoGgBEiCACbiLW3Hm7dupV3FwBRhCAAEBY1NTWaNGmS6RkARoggAGwkNTVVLS0tpmectfLycs2ZM8f0DACjQBAANjJjxoyYeOvhCy+8oJUrV5qeAWAUCALARmIhCCzL0smTJ5WTk2N6CoBRIAgAG5k2bZr+97//mZ5xVvbv368FCxaYngFglAgCwEYmTpyoEydOmJ5xVkpLS3m5AIhCBAFgI263W7Nnz1Ztba3pKWNiWZZOnTql7Oxs01MAjBJBANjMjTfeqC1btpieMSbvvfeeiouLTc8AMAYEAWAzs2fPVkVFhekZY/L444/rqquuMj0DwBgQBIAN5efnR+W7DX70ox9pz549pmcAGAOCALChaH3Z4PLLL9f27dtNzwAwBgQBYEOTJ0/W8ePHZVmW6Smj4vF4lJaWpqamJtNTAIwSQQDY1MKFC7V//37TM0Zt5cqVKi0tNT0DwCgRBIBN3XDDDdq6davpGaNWXFysffv2mZ4BYJQIAsCmsrKy1NjYqEAgYHrKqLhcLuXm5kb9DZYApyEIABtbvHixdu/ebXrGqN10001ReVEk4GQEAWBj1157rV5++WXTM0Zt5syZOnjwoOkZAEaBIABsbNy4ceru7lZPT4/pKaNWUFAQtTdYApyIIABs7jvf+Y5ef/110zNGLVrvpQA4FUEA2NxVV12l1157zfSMUcvNzVVtbW3U3UsBcCqCALC5hIQEeTwedXR0mJ4yahdeeKHeffdd0zMAjABBAESB5cuXq6yszPSMUbv++uu5SREQJQgCIApcdtllevXVV03PGLWMjAy1tbXJ7/ebngLgDAgCIAp4PB6lp6dr165dpqeM2rJly/jAIyAKEARAlHj88cdVUlKi1tZW01NG5Xvf+55eeeUV0zMAnAFBAEQJj8ejDRs26OGHHzY9ZVQSExMlSZ2dnYaXADgdggCIItOmTdPs2bOj7n/cCxcu1NNPP216BoDTIAiAKHPrrbfq5ZdfVn19vekpI3bdddeprq7O9AwAp0EQAFHG5XLp0Ucf1YMPPhg1N/1JS0uLumsfAKchCIAoNHHiRF155ZXavHmz6SmjEi0BAzgRQQBEqZUrV2rv3r2qrq42PWVE8vPzVVVVZXoGgGEQBEAUe+SRR/TQQw8pEAiYnnJGxcXF2rdvn+kZAIZBEABRLCMjQ6tXr9aTTz5pesoZLVy4UB988IHpGQCGQRAAUe6KK67QiRMn9Omnn5qeclopKSlqb283PQPAMAgCIAZs2LBBjz32mHp6ekxPOS2XyxUVL28ATkQQADEgKSlJ69at06ZNm0xPOa2CggIdPHjQ9AwAQRAEQIwoLi6W2+3Wu+++a3rKsLiwELAvggCIIffee6/++Mc/qqOjw/SUoObNm6f9+/ebngEgCIIAiCFer1f333+/br/9dtNTgkpKSlJXV5fpGQCCIAiAGFNQUKBx48aZnjEsj8cjv99vegaAQQgCIAYlJyfb9h/d2bNnq6KiwvQMAIMQBEAMOv/883Xs2DHTM4LiwkLAnggCIAbNmDHDtm/vmzt3rg4cOGB6BoBBCAIgBs2cOdO2QZCQkCCfz2d6BoBBCAIgBk2ZMsW2LxlIX70bwu53VQSchiAAYpDX61Vvb6/pGcNyuVxcRwDYDEEAwIji4mLTEwD0QxAAMSohIcG2NwHy+/2Ki4szPQNAPwQBEKPy8/NVVVVlesYQvb29crv5qwewG/5UAjHKrm89PHz4sKZPn256BoBBCAIgRs2cOVOHDh0yPWOIDz/8UAsWLDA9A8AgBAEQo3Jzc3XixAnTM4b46KOPNG/ePNMzAAxCEAAxyu12y7Is0zOGaGlpUVpamukZAAYhCAAAAEEAxLKUlBS1tbWZntGnrq5O2dnZpmcACIIgAGLYjBkzbHVh4f79+7mgELApggCIYXb7kCPeYQDYF0EAxLDx48fr9ddfNz2jT3V1tSZNmmR6BoAgCAIghuXn5ysjI8P0jAFcLpfpCQCCIAiAGBYfH2+bjxnu7OxUYmKi6RkAhkEQAIiIjz/+WHPnzjU9A8AwCAIAEcEFhYC9EQQAIuLTTz/VrFmzTM8AMAyCAEBE+Hw+xcfHm54BYBgEARDj3G63AoGA0Q1+v1+1tbVGNwA4PYIAiHHp6elqbm42uqGuro6XCwCbIwiAGJeZmamGhgajG06cOKGCggKjGwCcHkEAxDg7BEF1dbXy8vKMbgBwegQBEOMIAgAjQRAAMc4OQfD555/zGQaAzREEQIzLzMxUfX290Q0+n08JCQlGNwA4PYIAiHFZWVnGzxAAsD+CAIhxqampamtrMz0DgM0RBECMM/1xw36/Xx6Px+gGAGdGEAAIq9raWuXk5JieAeAMCALAAXp6eow9N285BKIDQQA4QFtbm95//30jz11dXa3JkycbeW4AI0cQAA5QUlKiJ554Qi0tLRF/bs4QANGBIAAcIC4uTo888ojuu+8+WZYV0eeuqanhGgIgChAEgEOcf/75uvLKK/Xcc89F9Hl7e3vl9Xoj+pwARo8gABzkuuuu06FDh1ReXm56CgCbIQgAh9m4caM2bdqk9vZ201MA2AhBADhMQkKCNmzYoAceeCDsz9Xc3KyampqwPw+As0cQAA40ffp0XXTRRfrb3/4W1ud55513tGbNmrA+B4DQIAgAh7rpppv0/vvv6+DBg2F7ju3bt2vp0qVhOz6A0CEIAAf71a9+pUcffVRdXV1hOX5LS4vS09PDcmwAoUUQAA6WnJys++67Txs2bAj5sevr65WZmRny4wIID4IAcLjCwkIVFhaqtLQ0pMfdvn27Lr/88pAeE0D4EAQA9MMf/lA7d+7UkSNHQnbMPXv26OKLLw7Z8QCEF0EAQC6XS7/5zW/08MMPy+fzheSY3d3dSkxMDMmxAIQfQQBAkpSamqqf//zneuSRR876WEePHtWUKVNCsApApBAEAPrMnz9flmVpy5YtZ3Wcbdu26corrwzRKgCRQBAAGGDFihUKBAJndYwPPvhACxYsCM0gABFBEAAYYPz48WpsbBzzzwcCAVmWJbebv16AaMKfWAADnG0QlJeX61vf+lYIFwGIBIIAwAAZGRlqamoa889z/QAQnQgCAAN4PJ6zuobgs88+U35+fggXAYgEggBAyPT09CguLk4ul8v0FACjRBAACJl33nlHF110kekZAMaAIAAQMtu2bdOyZctMzwAwBgQBgJDZu3evJkyYYHoGgDEgCAAENdoLC9vb21VYWBimNQDCjSAAMER6erpaWlpG9TO7d+/WpZdeGqZFAMKNIAAwxFhuTrRz504tWbIkTIsAhBtBAGCIsQRBc3OzMjIywjMIQNgRBACGyMzMHFUQNDc3Ky0tLYyLAIQbQQBgiPHjx6uhoWHEj3/zzTd5uQCIcgQBgCFG+5LBrl27dMkll4RxEYBwIwgADJGWlqbKysoRP769vV2pqalhXAQg3AgCAEOkpqbK5/ON6LH19fXKzMwM8yIA4UYQABgiPj5e48aNG9Fjn3zySW5IBMQAggDAEB6PR729vWd8XGNjo44fP65Vq1ZFYBWAcCIIAAzhdrtHdOvijRs36qGHHuLjjoEYQBAAGGIk/8D/5z//0Zw5c5SXlxeBRQDCzWt6AAB7sixr2O+1trbqH//4h5599tkILgIQTpwhADBqjz76qB544AG53fwVAsQK/jQDCGq4lw3eeust5ebmKj8/P8KLAIQTLxkAGLHOzk6VlJToueeeMz0FQIhxhgDAiD322GNav369PB6P6SkAQowgADAi+/btU1JSkubMmWN6CoAw4CUDAGfk8/n0+9//nncVADGMMwQAzuh3v/udfvaznykuLs70FABhQhAAOK3y8nJ1d3erqKjI9BQAYcRLBgCG1dvbq9/+9rf685//bHoKgDDjDAGAYf3hD3/Q7bffrqSkJNNTAIQZQQAgqC+//FK1tbW65JJLTE8BEAEu63Q3LAfgWFOnTtWBAweUmppqegqACOAMAYCgVqxYQQwADkIQAAAAggBAcB6PR36/3/QMABFCEAAI6txzz9WpU6dMzwAQIQQBgKAmTpyoL774wvQMABFCEAAIauLEiTp58qTpGQAihCAAEBRBADgLQQAgqAkTJhAEgIMQBACCys7O5qJCwEEIAgBBeb1e9fb2mp4BIEIIAgAAQBAAAACCAMBp8NlngHMQBACGlZCQoK6uLtMzAEQAQQBgWNytEHAOggDAsAgCwDkIAgDDSk9PV2VlpekZACKAIAAwrJ6eHnV2dpqeASACCAIAw2publZRUZHpGQAigCAAMKzq6mpNnjzZ9AwAEUAQABhWfX29srKyTM8AEAEEAYBhWZYll8tlegaACCAIAAAAQQAAAAgCAMNobm5WWlqa6RkAIoQgABBUdXW18vLyTM8AECEEAYCgCALAWQgCAEFxDwLAWQgCAEFxhgBwFoIAQFAtLS1cVAg4CEEAAAAIAgAAQBAACMKyLNMTAEQYQQBgiFOnTik7O9v0DAARRBAAGIJ3GADOQxAAGKKiokI5OTmmZwCIIIIAwBDbt2/XlClTTM8AEEEEAYABWltblZKSooKCAtNTAEQQQQBggL/+9a+65ZZbTM8AEGEEAYA+lmXpvffeU1FRkekpACKMIADQ54033tAVV1xhegYAAwgCAH1eeOEF3XDDDaZnADCAIAAgSTp69KhycnIUHx9vegoAAwgCAJKkkpIS3XbbbaZnADCEIACgzs5Offnll8rNzTU9BYAhBAEAPf/887r55ptNzwBgEEEAOJxlWXr77be1aNEi01MAGEQQAA73TQy4XC7TUwAYRBAADsfLBQAkggBwtJqaGmVkZCgpKcn0FACGEQSAg5WUlOj22283PQOADRAEgEP5fD7V1tbyMccAJBEEgGNxm2IA/bksy7JMjwAQeddcc43Kysp4dwEASZwhABxrxowZ4v8DAL5BEAAONWHCBH3xxRemZwCwCYIAcKi8vDwdP37c9AwANkEQAA6Vl5en6upq0zMA2ARBADgUQQCgP4IAcKjzzjtPJ06cMD0DgE0QBIBDxcfHq6enx/QMADZBEAAAAIIAAAAQBICjxcXFyefzmZ4BwAYIAsDBfD6fdu3aZXoGABsgCAAHa2lpUW1trekZAGyAIAAczO/3Ky8vz/QMADZAEAAO1tjYqHPOOcf0DAA2QBAADtbU1EQQAJBEEACORhAA+AZBADhYR0eHkpOTTc8AYAMEAeBQlmVJklwul+ElAOyAIAAcqr29XSkpKaZnALAJggBwKK4fANAfQQA4FEEAoD+CAHCopqYmjR8/3vQMADZBEAAOxRkCAP0RBIBDcZdCAP0RBIBDcYYAQH8EAeBQBAGA/ggCwKG4qBBAfwQB4FCcIQDQH0EAOBQXFQLojyAAHIozBAD6IwgAhyIIAPRHEAAO1d3draSkJNMzANgEQQA40DcffQwA3yAIAAdqbW1Vamqq6RkAbIQgAByI6wcADEYQAA7ETYkADEYQAA7EGQIAgxEEgAMRBAAGIwgAB+IuhQAGIwgAB+IMAYDBCALAgbioEMBgBAHgQJwhADAYQQA4EEEAYDCCAHAgLioEMBhBADgQ1xAAGIwgAByIlwwADEYQAA7U09Oj+Ph40zMA2AhBADhMIBAwPQGADREEgMO0tLQoLS3N9AwANkMQAA7DBYUAgiEIAIfhgkIAwRAEgMMQBACCIQgAhyEIAATjNT0AQHgdOXJEW7du1b59+1ReXq66ujrFx8erra1NixYt0g033KDU1FTTMwEY5rIsyzI9AkDoHTp0SHfddZdeffVVud1fnQzs7e3t+77X65Xf71dKSoruvPNOPfTQQ0pOTjY1F4BhBAEQg5566indddddCgQC8vv9Z3y82+1WXl6eSktLVVRUFIGFAOyGIABizK9//Ws98MADo/45j8ej+Ph4vfHGG/r2t78dhmUA7IwgAGLIiy++qJUrV4755z0ej9LS0lRRUaFzzz03hMsA2B1BAMSI+vp6FRQUqKmpSWfzx9rj8WjFihV68cUXQ7gOgN3xtkMgRvzpT39Sc3PzWcWA9NWFhy+99JI++uijEC0DEA0IAiAG+P1+PfnkkwPeRXA2vF6vnnrqqZAcC0B0IAiAGPDxxx+rrq4uZMfz+/165ZVXQnY8APZHEAAx4L333gv5Maurq9XU1BTy4wKwJ4IAiAE1NTXyekN/49Ha2tqQHxOAPREEQAxwuVxRdVwA9kMQADEgNzd3RHckHK2cnJyQHxOAPREEQAwIx+2GJ0+erIyMjJAfF4A9EQRADCgsLNSECRNCdjyv16trrrkmZMcDYH8EARADvF6v7rzzzr5PNTxbfr9fP/3pT0NyLADRgVsXAzGisbFRBQUFamxsVCAQGPNxPB6PVq5cqS1btoRwHQC7IwiAGPLvf/9b11577Zh/3uPxKD09XZWVlcrKygrhMgB2x0sGQAxZsWKFNm3aNKaf9Xg8SkpK0muvvUYMAA5EEAAx5t5771VJSYkSExNHfLMit9utqVOnateuXbrgggvCvBCAHREEQAy69dZb9cknn2j58uVyuVxyu93yeDwDHhMXFydJSktL0/33368DBw5o/vz5JuYCsAGuIQBiXHV1tUpLS7Vv3z4dOHBAPp9PGRkZKioq0qJFi3TdddcpKSnJ9EwAhhEEAACAlwwAAABBAAAARBAAAAARBAAAQAQBAAAQQQAAAEQQAAAAEQQAAEAEAQAAEEEAAABEEAAAABEEAABABAEAABBBAAAARBAAAAARBAAAQAQBAAAQQQAAAEQQAAAAEQQAAEAEAQAAEEEAAABEEAAAABEEAABABAEAABBBAAAARBAAAABJXtMDgFg3btw4+Xw+0zNgQ/Hx8WptbTU9A5BEEABh5/P5CAIAtsdLBgAAQC7LsizTIwAAgFmcIQAAAAQBgIGam5t19OhRdXV1Bf2+ZVnau3ev/vvf/6q9vT3oY/x+v3bu3KkdO3bI7/eHcy6AECEIAEiSnn32Wc2cOVMZGRmaOnWq3n333SGPOXnypBYvXqyrr75aa9eu1bRp01RWVjbgMfv379ecOXO0evVq/eAHP1BhYaHef//9SP02AIwRQQBAkpSVlaV77rlH//rXv4Z9zLp169TT06PDhw+rsrJSd9xxh1avXq3GxkZJX509WLNmjebNm6fDhw/r8OHDKi4u1urVqxUIBCL1WwEwBgQBAEnStddeqx//+MdasGBB0O/7fD6VlZVp7dq1ysjIkMvl0j333KPu7m5t27ZNknTw4EGVl5dr/fr1SkhIUHx8vNavX6+Kigp9+umnwz732rVr9cknnwz42oMPPqjdu3dLkjo7O3XHHXeovLxc9957r5YuXaqf/OQnOnXqlOrr67Vu3TotW7ZM99xzz7AvYwA4PYIAwIh8+OGH6urq0oUXXtj3tXHjxqmwsFB79uyRJO3Zs0dut1tFRUV9j5k/f74SEhL6HhPMM888o88//3zA155//nlVVFRI+ipGnn76aa1atUrJycm69dZbtXv3bt188826/vrrlZOTo1tuuUWlpaW6++67Q/nbBhyDGxMBGJHa2lpJUmZm5oCvZ2Zm9n3v5MmTOuecc+R2////NVwu14DHnI01a9bo/vvvlyRlZ2fr6quv1jPPPKPbbrtNkuTxeHT33XfrL3/5y1k/F+A0nCEAMCIul0vSV9cJ9GdZVl8AuFyuId+XpEAgMCASxmrJkiV9v546dWrQrzU0NHBnSGAMCAIAIzJ58mRJ0qlTpwZ8/dSpU5o0aZIkKS8vT01NTQPeahgIBNTQ0ND3mJEKFhZJSUl9v/Z4PMN+jQsYgdEjCACMyNy5c5Wamqpdu3b1fa2hoUEff/yxFi9eLElatGiRLMvS22+/3feYd955Rz09PX2PGU5LS0vfrwOBgOrq6kL8OwBwOgQBAElf/YNcWVmpw4cPS5KOHz+uyspKNTQ0SJK8Xq9uvPFGPfHEEzp27Jh8Pp9++ctfKisrS8uWLZMkTZkyRRdffLE2btyopqYmNTc36+GHH9YFF1yg/Pz80z5/SUmJOjo6ZFmWnnjiCbW1tamlpYUbGwERQhAAkCSVlZVp1qxZff+4r1mzRrNmzdLTTz/d95jHH39c8+bN08yZM5Wdna233npLL7/8slJTUyV9dQ3B5s2b1dvbq/POO085OTnq7OzU888/33cNwnASEhKUmZmptLQ0bd68WcuXL9cvfvELvfTSS+H7TQPow4cbARi1EydOqLm5WQUFBX2v2/dnWZaqqqpkWZby8/NHFANlZWWaP3++GhsbVVBQoJ6eHh05ckQFBQVn/HkAZ48gAGDcN0Hw3e9+1/QUwLF4yQCAcZMmTVJCQoLpGYCjcYYAAABwhgAAABAEAABABAEAABBBAAAARBAAAAARBAAAQAQBAAAQQQAAAEQQAAAASf8HUObEqvzmhVcAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -617,7 +645,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "neuron9",
    "language": "python",
    "name": "python3"
   },
@@ -631,7 +659,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.1"
+   "version": "3.13.11"
   }
  },
  "nbformat": 4,

From d05843c6e21d6dcd23b65b639dfdb16dacf2a82a Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Mon, 22 Jun 2026 14:40:47 +0200
Subject: [PATCH 12/17] more informative warning

---
 src/neat/trees/phystree.py | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index 34f85ad..0394f1e 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -635,7 +635,10 @@ def add_channel_current(self, channel, g_max_distr, e_rev_distr, node_arg=None):
         if len(nodes_with_channel) > 0:
             self.channel_storage[channel_name] = channel
         else:
-            warnings.warn("This node argument does not return any nodes in this tree, no channel was added.")
+            warnings.warn(
+                "Node argument `{node_arg}` does not return any nodes in this tree, " + \
+                f"no `{channel_name}` channel was added."
+            )
             return None
 
         channel = self.channel_storage[channel_name]

From 0e1116dfac4bcea905096319848110c9e0580cd9 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Mon, 22 Jun 2026 14:45:58 +0200
Subject: [PATCH 13/17] fix warning message

---
 src/neat/trees/phystree.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index 0394f1e..dbb704c 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -636,7 +636,7 @@ def add_channel_current(self, channel, g_max_distr, e_rev_distr, node_arg=None):
             self.channel_storage[channel_name] = channel
         else:
             warnings.warn(
-                "Node argument `{node_arg}` does not return any nodes in this tree, " + \
+                f"Node argument `{node_arg}` does not return any nodes in this tree, " + \
                 f"no `{channel_name}` channel was added."
             )
             return None

From 6d114cf24bab2ccc1fbc4e5851754178465a37b2 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Fri, 10 Jul 2026 10:38:10 +0200
Subject: [PATCH 14/17] bugfix in neuron model recording and update of
 trees.rst with missing functions

---
 docs/reference/trees.rst                   | 101 +++++++++++++++++++--
 src/neat/simulations/neuron/neuronmodel.py |   2 +-
 2 files changed, 93 insertions(+), 10 deletions(-)

diff --git a/docs/reference/trees.rst b/docs/reference/trees.rst
index 925517e..9384e2d 100755
--- a/docs/reference/trees.rst
+++ b/docs/reference/trees.rst
@@ -85,6 +85,7 @@ Compartment Tree
    CompartmentTree.get_conc_eq
    CompartmentTree.fit_e_leak
    CompartmentTree.calc_impedance_matrix
+   CompartmentTree.calc_impulse_response_matrix
    CompartmentTree.calc_conductance_matrix
    CompartmentTree.calc_system_matrix
    CompartmentTree.calc_eigenvalues
@@ -123,11 +124,13 @@ Neural Evaluation Tree
    NET.set_new_loc_idxs
    NET.get_reduced_tree
    NET.calc_total_impedance
+   NET.calc_total_kernel
    NET.calc_i_z
    NET.calc_i_z_matrix
    NET.calc_impedance_matrix
-   NET.calc_impedance_matrix
    NET.calc_compartmentalization
+   NET.compute_cond_rescale
+   NET.improve_input_resistance
    NET.plot_dendrogram
 
 
@@ -142,6 +145,8 @@ Neural Evaluation Tree
    Kernel.k_bar
    Kernel.t
    Kernel.ft
+   Kernel.diff
+   Kernel.fit_c
 
 
 *******************
@@ -229,6 +234,7 @@ locations
    MorphTree.distribute_locs_at_d2s
    MorphTree.distribute_locs_uniform
    MorphTree.distribute_locs_random
+   MorphTree.distribute_locs_finite_diff
    MorphTree.extend_with_bifurcation_locs
    MorphTree.unique_locs
    MorphTree.path_length
@@ -258,6 +264,7 @@ Creating new trees from the existing tree.
 .. autosummary::
    :toctree: generated/
 
+   MorphTree.find_common_root
    MorphTree.create_new_tree
    MorphTree.create_compartment_tree
    MorphTree.__copy__
@@ -326,9 +333,14 @@ Separation of Variables Tree
 
    SOVTree.create_corresponding_node
    SOVTree.calc_sov_equations
+   SOVTree.get_sov_matrices
    SOVTree.get_mode_importance
    SOVTree.get_important_modes
+   SOVTree.get_kernels
+   SOVTree.calc_zf
+   SOVTree.calc_zt
    SOVTree.calc_impedance_matrix
+   SOVTree.calc_impulse_response_matrix
    SOVTree.construct_net
    SOVTree.compute_lin_terms
 
@@ -390,29 +402,40 @@ Compute equilibrium potentials and concentrations
    EquilibriumTree.set_e_eq
 
 
-Cacheing the Greens function and separation of variables expansion
+Caching the Greens function and separation of variables expansion
 ==================================================================
 
+.. autoclass:: neat.CachedTree
+
+.. autosummary::
+   :toctree: generated/
+
+   CachedTree.get_cache_defaults
+   CachedTree.set_cache_params
+   CachedTree.get_cache_params
+   CachedTree.maybe_execute_funcs
+
 .. autoclass:: neat.CachedGreensTree
 
 .. autosummary::
    :toctree: generated/
 
    CachedGreensTree.set_impedances_in_tree
+   CachedGreensTree.calc_net_steadystate
 
 .. autoclass:: neat.CachedGreensTreeTime
 
 .. autosummary::
    :toctree: generated/
 
-   CachedGreensTree.set_impedances_in_tree
+   CachedGreensTreeTime.set_impedances_in_tree
 
 .. autoclass:: neat.CachedSOVTree
 
 .. autosummary::
    :toctree: generated/
 
-   CachedGreensTree.set_sov_in_tree
+   CachedSOVTree.set_sov_in_tree
 
 
 Fitting reduced models
@@ -430,10 +453,12 @@ To get stored fit results and associated location lists
 
 .. autosummary::
    :toctree: generated/
+
    CompartmentFitter.convert_fit_arg
+   CompartmentFitter.remove_fit
 
-To check the faithfullness of the passive reduction, the following functions
-implement vizualisation of impedance kernels.
+To check the faithfulness of the passive reduction, the following functions
+implement visualization of impedance kernels and SOV quantities.
 
 .. autosummary::
    :toctree: generated/
@@ -441,6 +466,7 @@ implement vizualisation of impedance kernels.
    CompartmentFitter.check_passive
    CompartmentFitter.get_kernels
    CompartmentFitter.plot_kernels
+   CompartmentFitter.plot_sov
 
 Individual fit functions.
 
@@ -455,10 +481,9 @@ Individual fit functions.
    CompartmentFitter.fit_channels
    CompartmentFitter.fit_concentration
    CompartmentFitter.fit_capacitance
-   CompartmentFitter.fit_syn_rescale
    CompartmentFitter.fit_e_eq
 
-`neat.CompartmentFitter` can also computed conductance rescale values for synapses
+`neat.CompartmentFitter` can also compute conductance rescale values for synapses
 at sites on the original morphology, when they are shifted to compartment locations
 on the reduced morphology. For this, the average conductances of each synapses need
 to be known.
@@ -466,6 +491,9 @@ to be known.
 .. autosummary::
    :toctree: generated/
 
+   CompartmentFitter.get_net
+   CompartmentFitter.recalc_impedance_matrix
+   CompartmentFitter.assign_locs_to_comps
    CompartmentFitter.fit_syn_rescale
 
 
@@ -483,8 +511,10 @@ Simulate full models in NEURON
    :toctree: generated/
 
    NeuronSimTree.create_corresponding_node
+   NeuronSimTree.set_simulation_parameters
    NeuronSimTree.init_model
    NeuronSimTree.delete_model
+   NeuronSimTree.set_rec_locs
    NeuronSimTree.add_shunt
    NeuronSimTree.add_double_exp_current
    NeuronSimTree.add_exp_synapse
@@ -500,6 +530,9 @@ Simulate full models in NEURON
    NeuronSimTree.set_spiketrain
    NeuronSimTree.run
    NeuronSimTree.calc_e_eq
+   NeuronSimTree.calc_impedance_matrix
+   NeuronSimTree.calc_zt
+   NeuronSimTree.calc_impulse_response_matrix
 
 .. autoclass:: neat.NeuronSimNode
 
@@ -524,11 +557,36 @@ Simulate reduced compartmental models in NEURON
    NeuronCompartmentTree.add_sin_clamp
    NeuronCompartmentTree.add_ou_clamp
    NeuronCompartmentTree.add_ou_conductance
+   NeuronCompartmentTree.add_ou_reversal
    NeuronCompartmentTree.add_v_clamp
 
 .. autoclass:: neat.NeuronCompartmentNode
 
 
+Simulate reduced compartmental models in Brian2
+===============================================
+
+.. autoclass:: neat.Brian2CompartmentTree
+
+.. autosummary::
+   :toctree: generated/
+
+   Brian2CompartmentTree.create_corresponding_node
+   Brian2CompartmentTree.get_compartment_index
+   Brian2CompartmentTree.morpho_access_string
+   Brian2CompartmentTree.add_double_exp_synapse
+   Brian2CompartmentTree.get_on_pre
+   Brian2CompartmentTree.initialise_at_veq
+   Brian2CompartmentTree.init_model
+
+.. autoclass:: neat.Brian2CompartmentNode
+
+.. autosummary::
+   :toctree: generated/
+
+   Brian2CompartmentNode.fake_surface
+
+
 Simulate reduced compartmental models in NEST
 =============================================
 
@@ -553,6 +611,20 @@ Neural evaluation tree simulator
 Miscellaneous
 *************
 
+Defining concentration mechanisms
+=================================
+
+.. autoclass:: neat.ExpConcMech
+
+.. autosummary::
+   :toctree: generated/
+
+   ExpConcMech.items
+   ExpConcMech.compute_linear
+   ExpConcMech.compute_lin
+   ExpConcMech.compute_lin_tau_fit
+   ExpConcMech.write_nestml_blocks
+
 
 Defining ion channels
 =====================
@@ -563,18 +635,22 @@ Defining ion channels
    :toctree: generated/
 
    IonChannel.set_default_params
+   IonChannel.ordered_statevars
    IonChannel.compute_p_open
    IonChannel.compute_derivatives
    IonChannel.compute_derivativesConc
    IonChannel.compute_varinf
    IonChannel.compute_tauinf
+   IonChannel.compute_lin_statevar_response
    IonChannel.compute_linear
    IonChannel.compute_linear_conc
    IonChannel.compute_lin_sum
    IonChannel.compute_lin_conc
+   IonChannel.write_mod_file
+   IonChannel.write_cpp_code
 
 
-Compute Fourrier transforms
+Compute Fourier transforms
 ===========================
 
 .. autoclass:: neat.FourierQuadrature
@@ -585,3 +661,10 @@ Compute Fourrier transforms
    FourierQuadrature.__call__
    FourierQuadrature.ft
    FourierQuadrature.ft_inv
+
+.. autoclass:: neat.FourierTools
+
+.. autosummary::
+   :toctree: generated/
+
+   FourierTools.inverse_fourier
diff --git a/src/neat/simulations/neuron/neuronmodel.py b/src/neat/simulations/neuron/neuronmodel.py
index 5d3a691..5f6fe5d 100755
--- a/src/neat/simulations/neuron/neuronmodel.py
+++ b/src/neat/simulations/neuron/neuronmodel.py
@@ -567,7 +567,7 @@ def _create_neuron_tree(self, pprint):
                 self.shunts.append(shunt)
 
     def set_rec_locs(self, locs):
-        self.store_locs(rec_locs, "rec locs")
+        self.store_locs(locs, "rec locs")
 
     def add_shunt(self, loc, g, e_r):
         """

From a684368ba41839f1598bb171bea2c2d4bc7c8f56 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Fri, 10 Jul 2026 12:19:19 +0200
Subject: [PATCH 15/17] optimize unique locs functionality

---
 src/neat/trees/morphtree.py | 70 ++++++++++++++++++++++++++++++++++---
 src/neat/trees/phystree.py  | 14 +++++---
 2 files changed, 76 insertions(+), 8 deletions(-)

diff --git a/src/neat/trees/morphtree.py b/src/neat/trees/morphtree.py
index 17fc792..6230661 100755
--- a/src/neat/trees/morphtree.py
+++ b/src/neat/trees/morphtree.py
@@ -31,7 +31,8 @@
 import pathlib
 import warnings
 from typing import Literal
-from functools import reduce
+from functools import reduce, wraps
+from inspect import signature
 from contextlib import contextmanager
 
 from .stree import SNode, STree
@@ -53,6 +54,7 @@ def computational_tree_decorator(fun):
     """
 
     # wrapper to access self
+    @wraps(fun)
     def wrapped(self, *args, **kwargs):
         if self._computational_root is None:
             raise AttributeError(
@@ -66,7 +68,7 @@ def wrapped(self, *args, **kwargs):
             res = fun(self, *args, **kwargs)
         return res
 
-    wrapped.__doc__ = fun.__doc__
+    wrapped.__signature__ = signature(fun)
     return wrapped
 
 
@@ -77,12 +79,13 @@ def original_tree_decorator(fun):
     """
 
     # wrapper to access self
+    @wraps(fun)
     def wrapped(self, *args, **kwargs):
         with self.as_original_tree:
             res = fun(self, *args, **kwargs)
         return res
 
-    wrapped.__doc__ = fun.__doc__
+    wrapped.__signature__ = signature(fun)
     return wrapped
 
 
@@ -2521,7 +2524,66 @@ def unique_locs(self, loc_arg, name="dont save"):
             the bifurcation locs
         """
         locs = self.convert_loc_arg_to_locs(loc_arg)
-        locs_ = reduce(lambda l, x: l.append(x) or l if x not in l else l, locs, [])
+
+        # Deduplicate by mapping each location onto a hashable canonical key
+        # instead of the O(n^2) `x not in l` membership test with the expensive
+        # `MorphLoc.__eq__`. The key reproduces the equality relation of
+        # `MorphLoc.__eq__` exactly:
+        #   - all locations on the soma (node 1) are equal (any `x`),
+        #   - a location at `x ~ 0` coincides with the `x ~ 1` end of its parent
+        #     node (chaining to the soma if the parent is the soma),
+        #   - a location at `x ~ 1` coincides with the `x ~ 1` end of that node,
+        #   - interior locations are equal iff they lie on the same node with
+        #     `np.allclose` `x`.
+        # Locations aliased to a parent (for `x ~ 0`) are only aliased for the
+        # purpose of the key: the original location object, with its exact
+        # coordinates, is what gets kept and returned/stored.
+        eps = 1e-8
+        # parent-index lookup, built in a single O(n) pass over the (active)
+        # tree so that boundary aliasing does not require the O(n) `self[index]`
+        # search per location
+        parent_idx = {
+            node.index: (
+                node.parent_node.index if node.parent_node is not None else -1
+            )
+            for node in self
+        }
+
+        def _top_key(idx):
+            # canonical key for the `x = 1` end of node `idx`; the soma collapses
+            # to a single key
+            return ("soma",) if idx == 1 else ("top", idx)
+
+        locs_ = []
+        seen_keys = set()  # keys for soma / `x ~ 0` / `x ~ 1` equivalence classes
+        interior_xs = {}  # node index -> list of kept interior `x` values
+        for loc in locs:
+            n, x = loc["node"], loc["x"]
+            if n == 1:
+                key = ("soma",)
+            elif x < eps:
+                # coincides with the `x = 1` end of the parent node
+                key = _top_key(parent_idx[n])
+            elif (1.0 - x) < eps:
+                key = ("top", n)
+            else:
+                key = None  # interior location, handled via `np.allclose` below
+
+            if key is not None:
+                if key in seen_keys:
+                    continue
+                seen_keys.add(key)
+            else:
+                # interior locations are only equal to previously kept interior
+                # locations on the same node (typically a very small group), so
+                # the `np.allclose` comparison stays exact and cheap. The
+                # argument order matches `MorphLoc.__eq__` (`kept == candidate`).
+                xs = interior_xs.setdefault(n, [])
+                if any(np.allclose(x_kept, x) for x_kept in xs):
+                    continue
+                xs.append(x)
+
+            locs_.append(loc)
 
         if name != "dont save":
             self.store_locs(locs_, name=name)
diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index dbb704c..baa2b45 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -23,6 +23,8 @@
 
 import copy
 import warnings
+from functools import wraps
+from inspect import signature
 
 from . import morphtree
 from .morphtree import MorphNode, MorphTree, MorphLoc
@@ -40,13 +42,14 @@ def comptree_removal_decorator(fun):
     """
 
     # wrapper to access self
+    @wraps(fun)
     def wrapped(self, *args, **kwargs):
         with self.as_original_tree:
             res = fun(self, *args, **kwargs)
         self._computational_root = None
         return res
 
-    wrapped.__doc__ = fun.__doc__
+    wrapped.__signature__ = signature(fun)
     return wrapped
 
 
@@ -884,11 +887,14 @@ def create_finite_difference_tree(self, dx_max=15.0, name="dont store"):
             The location corresponding to the compartments of the finite
             difference approximation
         """
+        print("(i)")
         locs = self.distribute_locs_finite_diff(dx_max=dx_max, name=name)
 
+        print("(ii)")
         aux_tree = self.create_new_tree(locs, new_tree=PhysTree())
+        print("(iii)")
         fd_tree = self.create_compartment_tree(locs)
-
+        print("(iv)")
         fd_nodes = fd_tree.nodes
         aux_nodes = aux_tree.nodes
 
@@ -954,7 +960,7 @@ def create_finite_difference_tree(self, dx_max=15.0, name="dont store"):
                         )
                     else:
                         fd_parent.currents[chan] = (0.0, e_parent)
-
+        print("(v)")
         # set concentration mechanisms in separate pass
         for ii in range(len(locs)):
             fd_node = fd_nodes[ii]
@@ -976,5 +982,5 @@ def create_finite_difference_tree(self, dx_max=15.0, name="dont store"):
 
                 fd_node.concmechs[ion] = copy.deepcopy(aux_node.concmechs[ion])
                 fd_node.concmechs[ion].gamma *= ion_factors_aux / ion_factors_fd
-
+        print("(vi)")
         return fd_tree, locs

From f8aa431e8e124f2adde4d8f2f031cba5ffac82f9 Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Fri, 10 Jul 2026 12:46:47 +0200
Subject: [PATCH 16/17] cache node.index : node dict for fast __getitem__
 performance

---
 src/neat/trees/morphtree.py | 39 +++++++++++-------
 src/neat/trees/stree.py     | 81 +++++++++++++++++++++++++++++++------
 2 files changed, 93 insertions(+), 27 deletions(-)

diff --git a/src/neat/trees/morphtree.py b/src/neat/trees/morphtree.py
index 6230661..05c39ef 100755
--- a/src/neat/trees/morphtree.py
+++ b/src/neat/trees/morphtree.py
@@ -507,13 +507,19 @@ def __getitem__(self, index, skip_inds=(2, 3)):
         Returns:
             `neat.MorphNode` or None
         """
+        # the cached lookup builds its map from `self.__iter__`, which skips the
+        # soma helper nodes 2 and 3; it therefore matches only the default
+        # `skip_inds`. Any other `skip_inds` uses the uncached search.
+        if tuple(skip_inds) == (2, 3):
+            return self._node_from_index(index, self.root)
         return self._find_node(self.root, index, skip_inds=skip_inds)
 
     def _find_node(self, node, index, skip_inds=(2, 3)):
         """
-        Breadth-first/stack iteration to replace the recursive call.
-        Traverses the tree until it finds the node you are looking for.
-        Returns SNode when found and None when not found
+        Iterative depth-first search for the node with the given ``index``,
+        starting from ``node``, skipping the node indices in ``skip_inds``.
+        Returns the `neat.MorphNode` when found and ``None`` otherwise. Used as
+        an uncached fallback by `__getitem__`.
 
         Parameters
         ----------
@@ -526,15 +532,12 @@ def _find_node(self, node, index, skip_inds=(2, 3)):
         -------
             :class:`SNode`
         """
-        stack = []
-        stack.append(node)
-        while len(stack) != 0:
-            for cnode in stack:
-                if cnode.index == index:
-                    return cnode
-                else:
-                    stack.remove(cnode)
-                    stack.extend(cnode.get_child_nodes(skip_inds=skip_inds))
+        stack = [node] if node is not None else []
+        while stack:
+            cnode = stack.pop()
+            if cnode.index == index:
+                return cnode
+            stack.extend(cnode.get_child_nodes(skip_inds=skip_inds))
         return None  # Not found!
 
     def __iter__(self, node=None, skip_inds=(2, 3)):
@@ -572,6 +575,7 @@ def reset_indices(self):
         """
         for ind, node in enumerate(self):
             node.index = ind + 1
+        self._invalidate_index_cache()
 
     def get_nodes(self, skip_inds=(2, 3)):
         """
@@ -1119,11 +1123,18 @@ def set_comp_tree(self, compnodes=None, eps=1e-8):
         compnode_indices = [node.index for node in compnodes]
         nodes = copy.deepcopy(self.nodes)
 
+        # Map the original-tree nodes by index once. The loop below only mutates
+        # the deep-copied `nodes` (the future computational tree) via
+        # `remove_single_node`; the original tree -- and hence this map -- stays
+        # valid throughout, so we avoid the repeated `self[...]` lookups whose
+        # cache would otherwise be invalidated on every `remove_single_node`.
+        orig_by_index = {onode.index: onode for onode in self}
+
         for node in nodes:
             if node.index not in compnode_indices:
                 self.remove_single_node(node)
             elif node.parent_node != None:
-                orig_node = self[node.index]
+                orig_node = orig_by_index[node.index]
                 orig_bnode = node.parent_node
                 L, R = self.path_length(
                     {"node": orig_bnode.index, "x": 1.0},
@@ -1135,7 +1146,7 @@ def set_comp_tree(self, compnodes=None, eps=1e-8):
                 node.used_in_comp_tree = True
                 orig_node.used_in_comp_tree = True
             else:
-                orig_node = self[node.index]
+                orig_node = orig_by_index[node.index]
                 node.used_in_comp_tree = True
                 orig_node.used_in_comp_tree = True
 
diff --git a/src/neat/trees/stree.py b/src/neat/trees/stree.py
index 54371f3..a6350d6 100755
--- a/src/neat/trees/stree.py
+++ b/src/neat/trees/stree.py
@@ -222,13 +222,65 @@ def __getitem__(self, index, **kwargs):
         -------
             `neat.SNode` or None
         """
-        return self._find_node(self.root, index)
+        return self._node_from_index(index, self.root)
+
+    def _invalidate_index_cache(self):
+        """
+        Signal that the tree structure (or a node index) has changed, so that
+        the cached ``index -> node`` map used by `__getitem__` is rebuilt on
+        the next lookup.
+
+        This is called automatically by the structure-mutating methods of this
+        class. Code that manipulates the node structure directly (bypassing
+        these methods, e.g. via `neat.SNode.add_child`) must call this method
+        itself to keep `__getitem__` consistent.
+        """
+        # a monotonically increasing version is cheaper and safer than clearing
+        # the cache in place: every cached map is tagged with the version it was
+        # built at, so any structural change invalidates all of them at once
+        self._index_version = getattr(self, "_index_version", 0) + 1
+
+    def _node_from_index(self, index, root):
+        """
+        Return the node with the given ``index`` in the subtree of ``root``.
+
+        A cached ``index -> node`` map is used to make the lookup O(1). The
+        cache is keyed on the ``root`` node so that alternating between
+        different (sub)trees -- e.g. the original and the computational tree of
+        a `neat.MorphTree`, which are selected by swapping `self.root` -- each
+        keep their own map. Every map is tagged with `self._index_version`; a
+        structural change bumps that version (see `_invalidate_index_cache`),
+        invalidating all maps without an O(n) sweep.
+        """
+        if root is None:
+            return None
+        version = getattr(self, "_index_version", 0)
+        cache = getattr(self, "_index_cache", None)
+        if cache is None:
+            cache = self._index_cache = {}
+        entry = cache.get(root)
+        if entry is None or entry[0] != version:
+            # rebuild the map for this root. `self.__iter__` respects the
+            # node-skipping of the subclass (e.g. the soma helper nodes 2 and 3
+            # of `neat.MorphTree`), so the cache matches the default
+            # `__getitem__` semantics exactly. `setdefault` keeps the first node
+            # encountered in iteration order, matching the depth-first search.
+            index_map = {}
+            for node in self.__iter__(node=root):
+                index_map.setdefault(node.index, node)
+            entry = (version, index_map)
+            # drop stale-version entries so detached roots can be garbage
+            # collected and the cache stays bounded
+            for stale_root in [r for r, e in cache.items() if e[0] != version]:
+                del cache[stale_root]
+            cache[root] = entry
+        return entry[1].get(index, None)
 
     def _find_node(self, node, index):
         """
-        Breadth-first/stack iteration to replace the recursive call.
-        Traverses the tree until it finds the node you are looking for.
-        Returns SNode when found and None when not found
+        Iterative depth-first search for the node with the given ``index``,
+        starting from ``node``. Returns the `neat.SNode` when found and ``None``
+        otherwise. Used as an uncached fallback by `__getitem__`.
 
         Parameters
         ----------
@@ -241,15 +293,12 @@ def _find_node(self, node, index):
         -------
             `neat.SNode`
         """
-        stack = []
-        stack.append(node)
-        while len(stack) != 0:
-            for cnode in stack:
-                if cnode.index == index:
-                    return cnode
-                else:
-                    stack.remove(cnode)
-                    stack.extend(cnode.get_child_nodes())
+        stack = [node] if node is not None else []
+        while stack:
+            cnode = stack.pop()
+            if cnode.index == index:
+                return cnode
+            stack.extend(cnode.get_child_nodes())
         return None  # Not found!
 
     def __len__(self, node=None):
@@ -515,6 +564,7 @@ def add_node_with_parent(self, node, pnode):
         if pnode is not None:
             node.set_parent_node(pnode)
             pnode.add_child(node)
+            self._invalidate_index_cache()
         else:
             warnings.warn("`pnode` was `None`, did nothing.")
 
@@ -530,6 +580,7 @@ def soft_remove_node(self, node):
                 node to be removed
         """
         node.get_parent_node().remove_child(node)
+        self._invalidate_index_cache()
 
     def remove_node(self, node):
         """
@@ -542,6 +593,7 @@ def remove_node(self, node):
         """
         node.get_parent_node().remove_child(node)
         self._deep_remove(node)
+        self._invalidate_index_cache()
 
     def _deep_remove(self, node):
         cnodes = node.get_child_nodes()
@@ -567,6 +619,7 @@ def remove_single_node(self, node):
         for cnode in cnodes:
             cnode.set_parent_node(pnode)
             pnode.add_child(cnode)
+        self._invalidate_index_cache()
 
     def insert_node(self, node, pnode, pcnodes=[]):
         """
@@ -608,6 +661,7 @@ def insert_node(self, node, pnode, pcnodes=[]):
             node.set_parent_node(None)
             node.add_child(cnode)
             self.root = node
+        self._invalidate_index_cache()
 
     def reset_indices(self, n=0):
         """
@@ -615,6 +669,7 @@ def reset_indices(self, n=0):
         """
         for ind, node in enumerate(self):
             node.index = ind + n
+        self._invalidate_index_cache()
 
     def get_sub_tree(self, node, new_tree=None):
         """

From aabab14bfecd3f808fd573e779560d91d2e27abe Mon Sep 17 00:00:00 2001
From: "w.wybo" <w.wybo@fz-juelich.de>
Date: Fri, 10 Jul 2026 12:47:20 +0200
Subject: [PATCH 17/17] codestyle

---
 src/neat/trees/morphtree.py | 4 +---
 src/neat/trees/phystree.py  | 4 ++--
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/neat/trees/morphtree.py b/src/neat/trees/morphtree.py
index 05c39ef..91c2f72 100755
--- a/src/neat/trees/morphtree.py
+++ b/src/neat/trees/morphtree.py
@@ -2554,9 +2554,7 @@ def unique_locs(self, loc_arg, name="dont save"):
         # tree so that boundary aliasing does not require the O(n) `self[index]`
         # search per location
         parent_idx = {
-            node.index: (
-                node.parent_node.index if node.parent_node is not None else -1
-            )
+            node.index: (node.parent_node.index if node.parent_node is not None else -1)
             for node in self
         }
 
diff --git a/src/neat/trees/phystree.py b/src/neat/trees/phystree.py
index baa2b45..0a76c98 100755
--- a/src/neat/trees/phystree.py
+++ b/src/neat/trees/phystree.py
@@ -639,8 +639,8 @@ def add_channel_current(self, channel, g_max_distr, e_rev_distr, node_arg=None):
             self.channel_storage[channel_name] = channel
         else:
             warnings.warn(
-                f"Node argument `{node_arg}` does not return any nodes in this tree, " + \
-                f"no `{channel_name}` channel was added."
+                f"Node argument `{node_arg}` does not return any nodes in this tree, "
+                + f"no `{channel_name}` channel was added."
             )
             return None