diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index 7d096f28..3eb90b0a 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -26,7 +26,7 @@ jobs: - name: Install dependencies run: | python -m pip install --upgrade pip - pip install -e .[dev] + pip install -e ".[dev]" - name: Check formatting with black run: | diff --git a/jaxley/channels/channel.py b/jaxley/channels/channel.py index 9bfd9a30..bf6f1d1a 100644 --- a/jaxley/channels/channel.py +++ b/jaxley/channels/channel.py @@ -79,3 +79,13 @@ def compute_current( Current in `uA/cm2`. """ raise NotImplementedError + + def init_state( + self, + states: Dict[str, jnp.ndarray], + v: jnp.ndarray, + params: Dict[str, jnp.ndarray], + delta_t: float, + ): + """Initialize states of channel.""" + return {} diff --git a/jaxley/modules/base.py b/jaxley/modules/base.py index 6fb775f5..490814ff 100644 --- a/jaxley/modules/base.py +++ b/jaxley/modules/base.py @@ -24,6 +24,7 @@ convert_point_process_to_distributed, interpolate_xyz, loc_of_index, + query_channel_states_and_params, v_interp, ) from jaxley.utils.debug_solver import compute_morphology_indices, convert_to_csc @@ -608,17 +609,29 @@ def init_states(self, delta_t: float = 0.025): channel_nodes = self.nodes states = self.get_states_from_nodes_and_edges() + # We do not use any `pstate` for initializing. In principle, we could change + # that by allowing an input `params` and `pstate` to this function. + params = self.get_all_parameters([]) + for channel in self.channels: name = channel._name - indices = channel_nodes.loc[channel_nodes[name]]["comp_index"].to_numpy() - voltages = channel_nodes.loc[indices, "v"].to_numpy() + channel_indices = channel_nodes.loc[channel_nodes[name]][ + "comp_index" + ].to_numpy() + voltages = channel_nodes.loc[channel_indices, "v"].to_numpy() channel_param_names = list(channel.channel_params.keys()) - channel_params = {} - for p in channel_param_names: - channel_params[p] = channel_nodes[p][indices].to_numpy() + channel_state_names = list(channel.channel_states.keys()) + channel_states = query_channel_states_and_params( + states, channel_state_names, channel_indices + ) + channel_params = query_channel_states_and_params( + params, channel_param_names, channel_indices + ) - init_state = channel.init_state(states, voltages, channel_params, delta_t) + init_state = channel.init_state( + channel_states, voltages, channel_params, delta_t + ) # `init_state` might not return all channel states. Only the ones that are # returned are updated here. @@ -626,7 +639,7 @@ def init_states(self, delta_t: float = 0.025): # Note that we are overriding `self.nodes` here, but `self.nodes` is # not used above to actually compute the current states (so there are # no issues with overriding states). - self.nodes.loc[indices, key] = val + self.nodes.loc[channel_indices, key] = val def _init_morph_for_debugging(self): """Instandiates row and column inds which can be used to solve the voltage eqs. @@ -982,11 +995,6 @@ def _step_channels_state( """One integration step of the channels.""" voltages = states["v"] - query = lambda d, keys, idcs: dict( - zip(keys, (v[idcs] for v in map(d.get, keys))) - ) # get dict with subset of keys and values from d - # only loops over necessary keys, as opposed to looping over d.items() - # Update states of the channels. indices = channel_nodes["comp_index"].to_numpy() for channel in channels: @@ -996,8 +1004,12 @@ def _step_channels_state( channel_state_names += self.membrane_current_names channel_indices = indices[channel_nodes[channel._name].astype(bool)] - channel_params = query(params, channel_param_names, channel_indices) - channel_states = query(states, channel_state_names, channel_indices) + channel_params = query_channel_states_and_params( + params, channel_param_names, channel_indices + ) + channel_states = query_channel_states_and_params( + states, channel_state_names, channel_indices + ) states_updated = channel.update_states( channel_states, delta_t, voltages[channel_indices], channel_params diff --git a/jaxley/utils/cell_utils.py b/jaxley/utils/cell_utils.py index 6921b495..5a3516fc 100644 --- a/jaxley/utils/cell_utils.py +++ b/jaxley/utils/cell_utils.py @@ -396,3 +396,18 @@ def group_and_sum( group_sums = group_sums.at[inds_to_group_by].add(values_to_sum) return group_sums + + +def query_channel_states_and_params(d, keys, idcs): + """Get dict with subset of keys and values from d. + + This is used to restrict a dict where every item contains __all__ states to only + the ones that are relevant for the channel. E.g. + + ```states = {'eCa': Array([ 0., 0., nan]}``` + + will be + ```states = {'eCa': Array([ 0., 0.]}``` + + Only loops over necessary keys, as opposed to looping over `d.items()`.""" + return dict(zip(keys, (v[idcs] for v in map(d.get, keys)))) diff --git a/pyproject.toml b/pyproject.toml index b45a1eba..2b93f9a2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -50,6 +50,7 @@ doc = [ dev = [ "black", "isort", + "jaxley-mech", "neuron", "pytest", "pyright", diff --git a/tests/test_channels.py b/tests/test_channels.py index cd966619..89403626 100644 --- a/tests/test_channels.py +++ b/tests/test_channels.py @@ -5,14 +5,16 @@ jax.config.update("jax_enable_x64", True) jax.config.update("jax_platform_name", "cpu") -from typing import Optional +from typing import Dict, Optional import jax.numpy as jnp import numpy as np import pytest +from jaxley_mech.channels.l5pc import CaNernstReversal, CaPump import jaxley as jx from jaxley.channels import HH, CaL, CaT, Channel, K, Km, Leak, Na +from jaxley.solver_gate import save_exp, solve_inf_gate_exponential def test_channel_set_name(): @@ -101,6 +103,92 @@ def test_init_states(): assert np.abs(v[0, 0] - v[0, -1]) < 0.02 +class KCA11(Channel): + def __init__(self, name: Optional[str] = None): + super().__init__(name) + prefix = self._name + self.channel_params = { + f"{prefix}_q10_ch": 3, + f"{prefix}_q10_ch0": 22, + "celsius": 22, + } + self.channel_states = {f"{prefix}_m": 0.02, "CaCon_i": 1e-4} + self.current_name = f"i_K" + + def update_states( + self, + states: Dict[str, jnp.ndarray], + dt, + v, + params: Dict[str, jnp.ndarray], + ): + """Update state.""" + prefix = self._name + m = states[f"{prefix}_m"] + q10 = params[f"{prefix}_q10_ch"] ** ( + (params["celsius"] - params[f"{prefix}_q10_ch0"]) / 10 + ) + cai = states["CaCon_i"] + new_m = solve_inf_gate_exponential(m, dt, *self.m_gate(v, cai, q10)) + return {f"{prefix}_m": new_m} + + def compute_current( + self, states: Dict[str, jnp.ndarray], v, params: Dict[str, jnp.ndarray] + ): + """Return current.""" + prefix = self._name + m = states[f"{prefix}_m"] + g = 0.03 * m * 1000 # mS/cm^2 + return g * (v + 80.0) + + def init_state(self, states, v, params, dt): + """Initialize the state such at fixed point of gate dynamics.""" + prefix = self._name + q10 = params[f"{prefix}_q10_ch"] ** ( + (params["celsius"] - params[f"{prefix}_q10_ch0"]) / 10 + ) + cai = states["CaCon_i"] + m_inf, _ = self.m_gate(v, cai, q10) + return {f"{prefix}_m": m_inf} + + @staticmethod + def m_gate(v, cai, q10): + cai = cai * 1e3 + v_half = -66 + 137 * save_exp(-0.3044 * cai) + 30.24 * save_exp(-0.04141 * cai) + alpha = 25.0 + + beta = 0.075 / save_exp((v - v_half) / 10) + m_inf = alpha / (alpha + beta) + tau_m = 1.0 * q10 + return m_inf, tau_m + + +def test_init_states_complex_channel(): + """Test for `init_states()` with a more complicated channel model. + + The channel model used for this test uses the `states` in `init_state` and it also + uses `q10`. The model inserts the channel only is some branches. This test follows + an issue I had with Jaxley in v0.2.0 (fixed in v0.2.1). + """ + ## Create cell + comp = jx.Compartment() + branch = jx.Branch(comp, nseg=1) + cell = jx.Cell(branch, parents=[-1, 0, 0]) + + # CA channels. + cell.branch([0, 1]).insert(CaNernstReversal()) + cell.branch([0, 1]).insert(CaPump()) + cell.branch([0, 1]).insert(KCA11()) + + cell.init_states() + + current = jx.step_current(1.0, 1.0, 0.1, 0.025, 3.0) + cell.branch(2).comp(0).stimulate(current) + cell.branch(2).comp(0).record() + voltages = jx.integrate(cell) + assert np.invert(np.any(np.isnan(voltages))), "NaN voltage found" + + def test_multiple_channel_currents(): """Test whether all channels can""" diff --git a/tutorials/05_channel_and_synapse_models.ipynb b/tutorials/05_channel_and_synapse_models.ipynb index 3c14c464..8ac263c1 100644 --- a/tutorials/05_channel_and_synapse_models.ipynb +++ b/tutorials/05_channel_and_synapse_models.ipynb @@ -80,7 +80,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 3, "id": "6edc6581", "metadata": {}, "outputs": [], @@ -120,7 +120,7 @@ " e_kd = -77.0 \n", " return kd_conds * (v - e_kd)\n", "\n", - " def init_state(self, v, params):\n", + " def init_state(self, states, v, params, delta_t):\n", " alpha = 0.01 * exp_update_alpha(-(v + 55), 10)\n", " beta = 0.125 * jnp.exp(-(v + 65) / 80)\n", " return {\"n_new\": alpha / (alpha + beta)}" @@ -245,7 +245,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -276,7 +276,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "62c719f9", "metadata": {}, "outputs": [], @@ -316,7 +316,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "id": "97ee3c49", "metadata": {}, "outputs": [], @@ -326,19 +326,10 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "id": "a8c9428c-d0dc-4892-966e-11a43aea216d", "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/michaeldeistler/Documents/phd/jaxley/jaxley/modules/base.py:1533: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n", - " self.pointer.edges = pd.concat(\n" - ] - } - ], + "outputs": [], "source": [ "from jaxley.connect import connect\n", "\n", @@ -349,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "id": "fc6fd5a2", "metadata": {}, "outputs": [ @@ -372,7 +363,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 13, "id": "867f4f38", "metadata": {}, "outputs": [], @@ -382,13 +373,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 14, "id": "01782d18", "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYQAAADeCAYAAAA933f2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAx30lEQVR4nO3dd3xUdb7/8ddMJjPpE9IJJAQIhiJFWgigrBCRIrqKjV3pIrBYKLorekXxurJer2D5YbmugO6qgFjWVSwsUiUUqaHXFCCFJKQnk8zM9/fHSQZiAiaQyaR8no/HeZyZc87M+cwhzHvO+Z7zPTqllEIIIUSLp3d1AUIIIRoHCQQhhBCABIIQQogKEghCCCEACQQhhBAVJBCEEEIAEghCCCEqSCAIIYQAJBCEEEJUkEAQQggBNKFAeOGFF9DpdFWGzp07O+aXlpYya9YsAgMD8fHxYezYsWRkZLiwYiGEaFqaTCAAdOvWjbS0NMewdetWx7w5c+bw73//m88++4xNmzZx/vx57rnnHhdWK4QQTYvB1QXUhcFgICwsrNr0vLw8PvjgAz755BOGDh0KwPLly+nSpQvbt29nwIABDV2qEEI0OU0qEE6cOEF4eDgeHh7ExcWxaNEiIiMj2b17N+Xl5cTHxzuW7dy5M5GRkSQkJFwxECwWCxaLxfHcbreTk5NDYGAgOp3O6Z9HCCGcTSlFQUEB4eHh6PVXPyjUZAIhNjaWFStWEBMTQ1paGgsXLuTmm2/m4MGDpKenYzQa8ff3r/Ka0NBQ0tPTr/ieixYtYuHChU6uXAghXC81NZW2bdtedZkmEwgjR450PO7RowexsbG0a9eO1atX4+npeU3vOX/+fObOnet4npeXR2RkJKmpqfj5+V13zUII4Wr5+flERETg6+v7m8s2mUD4NX9/f2644QZOnjzJbbfdRllZGbm5uVX2EjIyMmpsc6hkMpkwmUzVpvv5+UkgCCGaldocBm9SZxldrrCwkFOnTtG6dWv69OmDu7s769evd8w/duwYKSkpxMXFubBKIYRoOprMHsKTTz7JmDFjaNeuHefPn+f555/Hzc2NcePGYTabmTp1KnPnziUgIAA/Pz8ee+wx4uLi5AwjIYSopSYTCGfPnmXcuHFkZ2cTHBzM4MGD2b59O8HBwQAsWbIEvV7P2LFjsVgs3H777bz99tsurloIIZoOnVJKubqIxiI/Px+z2UxeXp60IQghmoW6fK812TYEIYQQ9UsCQQghBCCBIIQQooIEghBCCEACQQghRAUJBCGEEIAEghBCiAoSCEIIIQAJBCGEEBUkEIQQQgASCEIIISpIIAghhAAkEIQQQlSQQBBCCAFIIAghhKgggSCEEAKQQBBCCFFBAkEIIQQggSCEEKKCBIIQQghAAkEIIUQFCQQhhBCABIIQQogKEghCCCEACQQhhBAVJBCEEEIAEghCCCEqGK7lRSkpKSQnJ1NcXExwcDDdunXDZDLVd21CCCEaUK0DISkpiXfeeYeVK1dy9uxZlFKOeUajkZtvvplHHnmEsWPHotfLjocQQjQ1tfrmfvzxx+nZsydnzpzhpZde4vDhw+Tl5VFWVkZ6ejpr165l8ODBLFiwgB49erBr1y5n1y2EEKKe1WoPwdvbm9OnTxMYGFhtXkhICEOHDmXo0KE8//zzfP/996SmptKvX796L1YIIYTz6NTlx35auPz8fMxmM3l5efj5+bm6HCGEuG51+V6r9cH+vn378u6775Kfn3/dBQohhGh8ah0IPXv25M9//jOtW7dm/PjxbNy40YllCSGEaGi1DoQPPviA9PR0li5dSmpqKsOGDSM6OpqXX36Zc+fOObNGIYQQDaBO54d6eXkxadIkNm7cyPHjx3nwwQd57733iIqKYvTo0XzxxRfOqlMIIYSTXXejslKKzz//nOnTp5Obm4vNZquv2hqcNCoLIZqbunyvXdOVypU2btzI8uXL+fzzzzEYDEybNu163k4IIYQL1TkQzp49y4oVK1ixYgWnT5/m5ptv5u233+a+++7D09PTGTUKIYRoALUOhNWrV7Ns2TLWr19PSEgIEydOZMqUKURHRzuzPiGEEA2k1oHw0EMPMXr0aL788ktGjRol/RUJIUQzU+tAOHv2LCEhIc6sRQghhAvVOhAuD4Pz58+zdetWMjMzsdvtVZZ7/PHH6686IYQQDabOjcorVqxg+vTpGI1GAgMD0el0jnk6nU4CQQghmqg6X4cQERHBjBkzmD9/frNrR5DrEIQQzY1TOrerVFxczIMPPtjswkAIIVq6On+rT506lc8++8wZtQghhHChOh8ystls3HHHHZSUlNC9e3fc3d2rzF+8eHG9FtiQ5JCREKK5cWrXFYsWLeKHH34gJiYGoFqjcmOwdOlSXn31VdLT0+nZsydvvfUW/fv3d3VZQgjRqNU5EF577TWWLVvGpEmTnFDO9Vu1ahVz587l3XffJTY2ltdff53bb7+dY8eOyXUUQghxFXVuQzCZTAwaNMgZtdSLxYsXM23aNCZPnkzXrl1599138fLyYtmyZa4uTQghGrU6B8ITTzzBW2+95YxarltZWRm7d+8mPj7eMU2v1xMfH09CQkK15S0WC/n5+VUGIYRoqep8yGjnzp389NNPfPPNN3Tr1q1ao7Irb5KTlZWFzWYjNDS0yvTQ0FCOHj1abflFixaxcOHChipPCCEatToHgr+/P/fcc48zamlw8+fPZ+7cuY7n+fn5REREuLAiIYRwnToHwvLly51RR70ICgrCzc2NjIyMKtMzMjIICwurtrzJZMJkMjVUeUII0ag1q8uNjUYjffr0Yf369Y5pdrud9evXExcX58LKhBCi8atVIIwYMYLt27f/5nIFBQW88sorLF269LoLu1Zz587l/fff58MPP+TIkSPMnDmToqIiJk+e7LKaRN2k5hQzZ9U+nvpsP9d5y28hRB3U6pDRfffdx9ixYzGbzYwZM4a+ffsSHh6Oh4cHFy9e5PDhw2zdupW1a9cyevRoXn31VWfXfUUPPPAAFy5cYMGCBaSnp9OrVy++//77ag3NovEpLbfx3qbTvL3xJBar1q369CEdiA7xdXFlQrQMte66wmKx8Nlnn7Fq1Sq2bt1KXl6e9gY6HV27duX2229n6tSpdOnSxakFO5N0XeE6649ksPDfh0nJKQbATa/DZlcseaAnd9/U1sXVCdF01eV7rc59GVXKy8ujpKSEwMDAaqeeNlUSCA0vPa+U5/51kHWHtRMBQv1M/NforuxOvsiKbUlMGdSeBWO6urhKIZoup/ZlVMlsNmM2m6/15aKFU0qxalcqf117hIJSKwa9jqmD2/PYsE74mAyUVRwy2n8217WFCtGCXHMgCHGtUnOKmf9FIltPZgHQs62Z/7m3JzFhl9oK+kUFALA/NZfiMiteRvlTFcLZ5H+ZaDBKKf6xPZlFa49SUm7DZNDz5PAYpgxuj5u+ak+5EQGetPH35FxuCbuSLjLkhmAXVS1Ey9GsrkMQjdeFAguTV+xiwb8OUVJuI7Z9AD/MvoVpt3SoFgagnawwsGMgANtOZTV0uUK0SLKHIJzup6MZPPXZAbKLyjAa9DwzsjMT4qLQ1xAElxsYHchnu8+y7WR2A1UqRMt2TYGQm5vLmjVrOHXqFE899RQBAQHs2bOH0NBQ2rRpU981iibKYrXx8rdH+DAhGYDOYb688eBNVdoKrmZgxyAADp7PI7e4DH8vo9NqFUJcQyAcOHCA+Ph4zGYzSUlJTJs2jYCAAL744gtSUlL46KOPnFGnaGLO5Zbwp4/3sD81F4Apg9rz5xExeLi71fo9Qv086BTiw4nMQjYcy5TrEYRwsjq3IcydO5dJkyZx4sQJPDw8HNNHjRrF5s2b67U40TRtPn6BO97cwv7UXMye7iyf1I8FY7rWKQwqjezeGoBvD6TVd5lCiF+pcyDs2rWL6dOnV5vepk0b0tPT66Uo0TTZ7Yo3159g4vKdXCwup3sbM988NphbO1/7rUvv6KEFwubjWeSVlNdXqUKIGlzTLTRrurPY8ePHCQ6WUwNbqtJyG49+uofF646jFIzrH8FnM+KICPC6rve9IdSXTiE+lNns/Odwxm+/QAhxzeocCHfeeScvvvgi5eXarzWdTkdKSgp/+ctfGDt2bL0XKBq/zIJSHvi/7axNTMfdTccrY7uz6J4e13SIqCZ39AgHYM3us/XyfkKImtU5EF577TUKCwsJCQmhpKSEIUOGEB0dja+vL3/961+dUaNoxI6m53P30m3sT83F38udf0yN5YF+kfW6jvv6tkWvg4TT2ZzMLKzX9xZCXFLns4zMZjPr1q1j69atHDhwgMLCQnr37l3lxvaiZdhy4gIz/7mHQouVDkHefDCpH+2DvOt9PeH+ngztHMp/jmTw8Y5knh/Trd7XIYS4jt5OmyPp7bT2vktM4/GVeym3KQZ0CODdh/o49TqBjccymbR8F74eBrY9PRRfj+bRw64QzubU3k7ffPPNGqfrdDo8PDyIjo7mlltuwc2tfo4fi8Zn9a5Unv7iAHYFo7u3ZskDvTAanNsLyi2dgukQ7M3pC0X8c3sKM3/X0anrE6IlqvMeQvv27blw4QLFxcW0atUKgIsXL+Ll5YWPjw+ZmZl06NCBDRs2EBER4ZSinUX2EH7b+5tP89e1RwDtTKKXft+9xr6InOHz3WeZ99l+gnyMbPnzUDyN8qNDiN9Sl++1Ov+se/nll+nXrx8nTpwgOzub7Oxsjh8/TmxsLG+88QYpKSmEhYUxZ86ca/4AonF6b9MpRxhMH9KBl+9uuDAAuLNXOG1beZJVWMY/tic12HqFaCnqvIfQsWNHPv/8c3r16lVl+t69exk7diynT59m27ZtjB07lrS0pnV1qewhXNnft5zmpW+1MJh72w08PqyTS+pY/Usqf15zAF8PA5ueupUAb+nfSIirceoeQlpaGlartdp0q9XquFI5PDycgoKCur61aKRW/HzGEQZPDOvksjAAGNu7LV1b+1FQauX1/xx3WR1CNEd1DoRbb72V6dOns3fvXse0vXv3MnPmTIYOHQpAYmIi7du3r78qhct8ujOFF/59GIBHb41mdrzrwgDATa/jv+7oAsDHO1I4kSE/PISoL3UOhA8++ICAgAD69OmDyWTCZDLRt29fAgIC+OCDDwDw8fHhtddeq/diRcP68VA6z36ZCGhtBvOG34BO13BtBlcysGMQt3UNxWZXPPvVQex2OXNaiPpwzdchHD16lOPHtV32mJgYYmJi6rUwV5A2hEt2J1/kD+9vx2K182C/CBbd071RhEGl1Jxibn99M8VlNhbe2Y2JA6NcXZIQjVJdvtfkwrTLSCBoTmYWcu+728gtLmdo5xD+b3wfDG6N726r/0hI4rl/HcLL6MYPs2+57o70hGiOnHphGsDZs2f5+uuvSUlJoaysrMq8xYsXX8tbikYiq9DCxGU7yS0up2eEP//vDzc1yjAA+GNsO75NTGP76Rxmr9rHykcG4N5IaxWiKahzIKxfv54777yTDh06cPToUW688UaSkpJQStG7d29n1CgaSJnVzp/+uYdzuSVEBXqxbGJfvIyN97bber2OV+/tyag3t7A7+SKv/nCMZ0Z1cXVZQjRZdf45NX/+fJ588kkSExPx8PDg888/JzU1lSFDhnDfffc5o0bRQF785hA7k3LwNRn4+8R+BPqYXF3Sb4oI8OLVe3sC8H+bT/PjIblJkxDXqs6BcOTIESZMmACAwWCgpKQEHx8fXnzxRV555ZV6L1A0jE92pPDP7SnodPD6g72IDvFxdUm1NuLGMKYO1k5znrNqH0fSqt/ASQjx2+ocCN7e3o52g9atW3Pq1CnHvKysrPqrTDSYxLN5vPD1IQCeHB7DsC6hLq6o7v4yojNxHQIpKrMxdcUuMgtKXV2SEE1OnQNhwIABbN26FYBRo0Yxb948/vrXvzJlyhQGDBhQ7wUK5yooLefRT/dQZrMzvGsof2qivYgaDXrefagPHYK9OZ9XypQVu+QezELUUZ0DYfHixcTGxgKwcOFChg0bxqpVq4iKinJcmCaaBqUU879IJDm7mDb+nrx6b89Gda1BXZm93Fk2sR+B3kYOnstn8vKdFFqqd7MihKiZXIdwmZZ2HcLKnSk8/UUiBr2O1TPi6B3ZytUl1YvD5/MZ9/528krK6d8+gA8n95euskWL5dTO7Tp06EB2dna16bm5uXTo0KGubydcJCW7mBe/0fooevL2mGYTBgBdw/34x9T++JoM7DyTw8TlO+XwkRC1UOdASEpKwmazVZtusVg4d+5cvRQlnMtuVzy1Zj/FZTZi2wfwyM3NL8h7tPVnxZR+jlB44L0EMvOloVmIq6n1VUdff/214/EPP/yA2Wx2PLfZbKxfv56oqKh6LU44x0cJSew4k4OX0Y1X7+2JvgFvctOQ+rQLYOX0AUxctouj6QXc8842Vkzu36ROqRWiIdW6DUGv13YmdDodv36Ju7s7UVFRvPbaa9xxxx31X2UDaQltCElZRYx8Ywsl5TZevKsbE+KiXF2S06VkFzN+2Q6Ss4vxNRl4/cFeTfLUWiGuhVPaEOx2O3a7ncjISDIzMx3P7XY7FouFY8eONekwaAmUUvzXVwcpKbcR1yGQh2LbubqkBhEZ6MXnMwfSPyqAAouVhz/6hTfXn5Bus4X4lTq3IZw5c4agoCBn1CKc7LuD6Ww9mYXRoOdvY7s320NFNQnyMfHPh2OZENcOpWDxuuNMXL5T2hWEuEyt2hDefPPNWr/h448/fs3FCOcpLrPyUsVZRTOGdKRdoLeLK2p4RoOeF++6kRvbmFnwr4NsOZHFiDe28MrYHtzWVQ4hCVGrNoTa3g5Tp9Nx+vTp6y7KVZpzG8L/fH+Utzeeom0rT/4zdwge7i37vPyTmYU8/uleDlf0e3Rnz3AWjOlKUBPo0E+IupAb5Fyj5hoIpy8Ucvvrmym3Kf5vfB+GdwtzdUmNgsVq47Ufj/P3LaexK/D3cufZUV24t0/bJn3FthCXc+qFaZdTSlU740g0Pv/z/THKbYrfxQTLoZHLmAxuPDOqC1/NGkTX1n7kFpfz1JoD3P9eAvtTc11dnhAN7poC4aOPPqJ79+54enri6elJjx49+Mc//lHftYl6sDflIt8fSkevg2dGdZFfvjXo0daffz06iKdHdsbDXc+upIvctfRnZq/cy7ncEleXJ0SDuabO7WbOnMmoUaNYvXo1q1evZsSIEcyYMYMlS5Y4o0ZxjZRSvPL9UQDu6d2WG0J9XVxR4+XupmfGkI5sePJ33NO7DQBf7TvPrf+7kQX/Osh5CQbRAtS5DaF9+/YsXLjQcZOcSh9++CEvvPACZ86cqdcCG1Jza0PYdPwCE5ftxGjQs+HJ39HG39PVJTUZiWfz+Ovaw2w/nQOAu5uO+/pGMHNIRyICvFxcnRC159Q2hLS0NAYOHFht+sCBA0lLS6vr2wknUUrx5voTAIwf0E7CoI66tzXz6bQBfDItlgEdAii3KT7ZkcKt/7uRxz7dy+7ki9J+JpqdOgdCdHQ0q1evrjZ91apVdOrUqV6KEtdvx5kcdidfxGjQM/2W5td5XUPQ6XQM7BjEykfiWD09jsHRQVjtin/vP8/Yd7Zx19Kf+WLPWUrLq3f2KERTVOvO7SotXLiQBx54gM2bNzNo0CAAfv75Z9avX19jUAjXWLrhJAD3921LiJ+Hi6tphOw2KMmF4mywFICtrOqgFLi5g94Abu7017vzz1GeHM9ry8f7cllzKJ8DZ/OYu3o/L3x9iDt7hXNvnwh6tjVLw71osmrdhnDw4EFuvPFGAHbv3s2SJUs4cuQIAF26dGHevHncdNNNTis0KiqK5OTkKtMWLVrE008/7Xh+4MABZs2axa5duwgODuaxxx7jz3/+c63X0VzaEPan5nLX0p9x0+vY+OTvWuYxb6Ug/xxkHIKc03Ax6dJQmKGFAdd3yMeqN5Fn9+SC3Zcs5UcWZqwegbRtG8UNHTsQEBoBvq3B3BY8zCBBIVygLt9rtd5D6NGjB/369ePhhx/mwQcf5J///Od1F1pXL774ItOmTXM89/W9dNZMfn4+w4cPJz4+nnfffZfExESmTJmCv78/jzzySIPX6kr/t1m7WvyuXuEtJwzKiiB1ByT9DOd+gbQDUJLz268zmcHDD9yM2mCoGKMDeznYKgZ7OZSXQGk+lBcBYLBbCMRCoD730vuVA2cqhssZfbRg8GujjSsHvzbgH6k9dnOvn20hxDWqdSBs2rSJ5cuXM2/ePObMmcO9997L1KlTufnmm51ZXxW+vr6EhdV8le3HH39MWVkZy5Ytw2g00q1bN/bt28fixYtbVCBk5Jfyw6F0AKY1wxvfOCil/fo//h0c/xHO7wH7r+6frHOD4M4QFA2torTBvx34hYNXIHi2urYvYZsVygq0cCjNg+IsKLxAaW4aZ5KTyExLhaJMgskjTJdNgK4QygrhwlFtqInODcxtLtVYWW/lc+8g2cMQTlfn006LiopYvXo1K1asYMuWLURHRzN16lQmTpx4xS/r+hAVFUVpaSnl5eVERkbyhz/8gTlz5mAwaJk2YcIE8vPz+eqrrxyv2bBhA0OHDiUnJ4dWrarfItJisWCxWBzP8/PziYiIaNKHjF7/z3Fe/88J+kW14rMZ1c8Ga9KUgrT9cGA1HPk35KVUnW+OgHaDIHIAtO4JIV3B3TXtJ1mFFtYdzuC7g+nsOXmOEJVFa1024bpsIt1y6OVXSAdjLsH2C7gXnkNn/Y1eV929oVW7XwXGZc+NLWRPUNSZUw4ZVfL29mby5MlMnjyZkydPsnz5cpYuXcpzzz3HiBEjqtxZrT49/vjj9O7dm4CAALZt28b8+fNJS0tj8eLFAKSnp1frhC80NNQxr6ZAWLRoEQsXLnRKva5QbrPzyQ7tS/KhAc3oXgd55+DAKm24/Be2wQM63AoxI7Rxq8bzmYN8TIzrH8m4/pHkFZez8Xgmm49nsfHEBS4UWCDr0rLB3gaGtoPBwUX08s4lnEzccpMhN1lr88g/rx2myjysDTXxDtE+v3/kr4Z2WlC6KBhF03LdndsVFRXx8ccfM3/+fHJzc2u83/KVPP3007zyyitXXebIkSN07ty52vRly5Yxffp0CgsLMZlMDB8+nPbt2/Pee+85ljl8+DDdunXj8OHDdOnSpdp7NLc9hLWJafzp4z0E+ZjY9vRQjIbr6qrKtex2OL0Bdn2gHRZSdm26mwliRkL3+6Dj0Cb3y1gpxZG0AjafuMDm4xf4JfkiZVZ7lWV8TAZ6tDXTva2ZHm386RHmQVt9FrrKgLiYBBeTL40teb+9Yp/QGsJCAqMlcOoeQqXNmzezbNkyPv/8c/R6Pffffz9Tp06t03vMmzePSZMmXXWZDh1qPg4eGxuL1WolKSmJmJgYwsLCyMjIqLJM5fMrHcoymUyYTM2nu+PKvYNx/SOabhiUXIR9n2hBkHPq0vR2g6Dng9D1Lu2MnSZKp9PRNdyPruF+zBjSEYvVRuLZPHYm5bDzTA67ky5SYLGy7VQ2205lO17n7+VO9zZmbmwzmBtCR3DDjb50DPbRujEvuaiFQ25KzUNZoXZmVWEGnN1Vc2GVgWGO0NpYKgffynGYNHq3AHUKhPPnz7NixQpWrFjByZMnGThwIG+++Sb3338/3t51v+FKcHAwwcHBdX4dwL59+9Dr9YSEhAAQFxfHs88+S3l5Oe7u2h/uunXriImJqfFwUXOTnlfKz6e04xD3941wcTXXIPMIJCyFxDVgreg3yOQHvf4AfadC8A2urc9JTAY3+kYF0DcqgD/9Dmx2xbH0AhLP5XLgbB6J5/I4kpZPbnE5W05kseXEpWNNeh1EBXrTKdSHmFBfokP7ERU5hHY3eWP2rPjyVkoLjCuFRW5y7QIDnRYafq21M6P8wrVTav3aaNN8QsE7WGuol8bvJqvWh4xGjhzJf/7zH4KCgpgwYQJTpkwhJibG2fUBkJCQwI4dO7j11lvx9fUlISGBOXPmMHLkSD788EMA8vLyiImJYfjw4fzlL3/h4MGDTJkyhSVLltT6LKOmfB3Ce5tOsei7o02vMTl1J2xdAsfWXpoW0g36Pwzd7weTj+tqayQsVhvH0wvZfzaXo+n5HE8v5FhGAXkl5Vd8TSsvdyIDvYkK9KJdxbhtKy/C/T0I9fPA3a1iD7JKYCRr7TX556AgTWu7yD8H+Wnaabe1oXcHnxAtHHxCwadi7B1S9bF3EHj4g76J7sk2IU45ZOTu7s6aNWu44447cHNr2LttmUwmVq5cyQsvvIDFYqF9+/bMmTOHuXPnOpYxm838+OOPzJo1iz59+hAUFMSCBQtazCmnX+49B8DdN7V1cSW1oBScXA9bF0PyzxUTddDlDhgwSztLSH5lOpgMbnSvaFOopJTiQoGF4xlaOBxPL+B0ViHJ2cVkFli4WFzOxeLcGu/roNNBiK+J1mZPwv09KsZmWpv7ExRmIijaSJCvCV+TQbvq2m7XrujOP3cpJH4dGEWZ2im49vKKaed++4Pp9FooeAWAZ4C2d1H52KtVxTig6tjDT7umQ/4+nELumHaZprqHcCKjgNuWbMbdTceuZ+Px9zK6uqSa2axw+CvY+jpkJGrT9O7Q8wEYNBuCpC+s+lBksZKSU0xydhFJ2RXjrGLO5ZaQnldKmc3+228CmAx6gnxMBPkYK8YmgnyNBHqb8Pdyx+zpXjE2YvZ0x+xuw1iarYVDYcVQlAmFF7TDUUUXLk2vTUP4Fem0w4kefmDyvcpj86XH7l5g9K4Ye2mn8Rq9tOf65n072QZpVBaNx4+HtcbzwdFBjTMMykth38ew7U2t8RO0/5B9J8OAP2kXZIl6420y0KW1H11aV//Pb7crsovKSMsr4XxuacW4hPN5pWTklZJVaCGrsIxCixWL1c653JI63STIy+iGv6c7Zi8fzJ7+mD274WNyx8fkhpefAR+TAW+jGz7uila6QsyqAF9VgI89H09rHp7WPIxluehLLqIruahdbV5yEYpztMd2K6C0QLmuULmMm6l6SBi9wd1Te+zupV3BbvCouJrd9KvHJu09qjz+1fJuRq1frIq+sRyPL3+u07t8z0cCoRmoDITbujayeyWX5sEvyyDhbe2XImi7/QNmQr+HtcMAokHp9TqCfU0E+5rocZWjiyVlNrIKLVwotJBVoIWEFhYWsovKyC8pJ7e4nLyScnKLyyiwWFEKistsFJfZOJ/3GxfaVeNdMYRrderAw91NGwx6PNzdMPnpMbuX08rNQiu3Usz6Yvx0pfjqSvClGB+K8VbFeNqL8LAXYbIVYbIVYrIWYrCXYrCW4GYrwWArQW8tQVfZl5XNAiUWLXhcTe9+WUi4Xfb8sgC57UXt1GsnkEBo4jLyS9mfmotOB/FdQ1xdjqYgA3a8o506asnXpvm1hYGPQe/x2q8v0ah5Gt2ICPCqdV9YNruioLQyICrGJdq4yGKlyGKlsGJcZLE5HhdarBSVXZpWeU2G/bJwqZmpYrhWCg/K8MSCFxY8ddrYS2fBE22ofOxBGUaseOjKMOmsmHRWPHXlmLBi1FnxoByj43k5RsoxYsVEGe5Ke27Aihs23JRNG3OFw3b2in6zrFfeK0s6n0GUk87nkUBo4tZV7B30ivAnxNfFFxflnIZtb8Hej7VfXaD1JTRoNnS/V85jb8bc9Dr8vYz4exlpF3jt71Nus1NssVFqtVFabqO03F4xtlFqvfTYUm53LFNSZq+yfLnt0lBmVVjtFc+tijLb5fMVZVbtcbHNTrrt0nxnt6zqsOOGHQO2ywY7bthw12mhYahxsDPZ8yainFSXBEITt+XEBQDiu4S6roj0RK2h+NAXl64obtsPBs+FG0bIqYWi1tzd9Ji99Jhx3Y8HpRQ2u6LcpoWJ3Q5Wux1bxfRqg1JYbQq7UljtCrv90thWwzSrvWJZm/Z6hcKutL0spbTH9op1qYrHldPsdkX7KOcdGpZAaMLsduW45+/Ajtfxs+xaKAVnNsHPb8Cpny5Nj46HwXO0K4vl1EDRBOl0OgxuOgxuAM37DKRfk0Bowg6n5ZNXUo6PyUD3Ng3UnUPlqaM/vwHpB7RpOj10/b0WBK17NEwdQoh6J4HQhCVU9HXTv30ABjcnH5YpztH6GNr5nnZVK4DBU2skjpuldcMshGjSJBCasITTWiDEdXDi4aJzu7WzhQ5+DpV99nsFQuwMOXVUiGZGAqGJstsVu85o7Qdx9d1+kJ8GB9do9x9IT7w0PbQ79Juq9Trq7lm/6xRCuJwEQhOVlF1EgcWKyaCnc5jvb7/gt1xM0m5FefQbOLMZxw3o3YzQ7W5tb6BtP2koFqIZk0Boog6e1y746tLa79raD/LOaj2Nnt2lnSX063v9RsRCj/uh693g3cBnMAkhXEICoYk6dF7rx+XGNlforMpqgaKsS52L5SZD1gnIPgGZR6HgfNXldW5aL6Odhms3oQloX/P7CiGaLQmEhma3a32mFF3QunUozdfGloJL4/ISsJVpX+qOsQWsZY7xfWnZ3GUspe0JHbxu1+ZZSy8tr37jVqY6NwjtBhH9od1A7XaUns3/RkJCiCuTQHCG4hzIOKT9Gs86qd0KsiD9UnfAdut1ryIaQA8UXWUhvUG7UYl3kNaXUFA0BHaCoBu06wWkTyEhxGUkEK6TUorUixexnNmOz5nv8DyXgDH35NVfpNNhN/lhM5qxG32wu3tjN/pVjH1RBg+Um/HSoLvssZs7+eV6lmxIxqYz8v8mxOJu8tJ6RXR0v2vUbppu9Lt6txHlxfW7MYQQTudp8NRuXOQEcoOcy1zLDXKKy4uJ/STWyZUJIYRmxx924OVeu15ooW7fa9LrmBBCCEAOGV03T4MnO+7fpD0xuLj7aSFEs+dpcN5FoRII10mn0+HlKd03CCGaPjlkJIQQApBAEEIIUUECQQghBCCBIIQQooIEghBCCEACQQghRAUJBCGEEIAEghBCiApyYdplKrt1ys/Pd3ElQghRPyq/z2rTbZ0EwmUKCgoAiIiIcHElQghRvwoKCjCbzVddRno7vYzdbuf8+fP4+vrWqXvZ/Px8IiIiSE1NrXUvqS2FbJuayXa5Mtk2NbvW7aKUoqCggPDwcPRX6w4f2UOoQq/X07Zt22t+vZ+fn/wBX4Fsm5rJdrky2TY1u5bt8lt7BpWkUVkIIQQggSCEEKKCBEI9MJlMPP/885hMJleX0ujItqmZbJcrk21Ts4bYLtKoLIQQApA9BCGEEBUkEIQQQgASCEIIISpIIAghhAAkEOrF0qVLiYqKwsPDg9jYWHbu3Onqkpxq8+bNjBkzhvDwcHQ6HV999VWV+UopFixYQOvWrfH09CQ+Pp4TJ05UWSYnJ4c//vGP+Pn54e/vz9SpUyksLGzAT1H/Fi1aRL9+/fD19SUkJITf//73HDt2rMoypaWlzJo1i8DAQHx8fBg7diwZGRlVlklJSWH06NF4eXkREhLCU089hdVqbciPUu/eeecdevTo4bioKi4uju+++84xv6Vul1/729/+hk6nY/bs2Y5pDbptlLguK1euVEajUS1btkwdOnRITZs2Tfn7+6uMjAxXl+Y0a9euVc8++6z64osvFKC+/PLLKvP/9re/KbPZrL766iu1f/9+deedd6r27durkpISxzIjRoxQPXv2VNu3b1dbtmxR0dHRaty4cQ38SerX7bffrpYvX64OHjyo9u3bp0aNGqUiIyNVYWGhY5kZM2aoiIgItX79evXLL7+oAQMGqIEDBzrmW61WdeONN6r4+Hi1d+9etXbtWhUUFKTmz5/vio9Ub77++mv17bffquPHj6tjx46pZ555Rrm7u6uDBw8qpVrudrnczp07VVRUlOrRo4d64oknHNMbcttIIFyn/v37q1mzZjme22w2FR4erhYtWuTCqhrOrwPBbrersLAw9eqrrzqm5ebmKpPJpD799FOllFKHDx9WgNq1a5djme+++07pdDp17ty5Bqvd2TIzMxWgNm3apJTStoO7u7v67LPPHMscOXJEASohIUEppYWtXq9X6enpjmXeeecd5efnpywWS8N+ACdr1aqV+vvf/y7bRSlVUFCgOnXqpNatW6eGDBniCISG3jZyyOg6lJWVsXv3buLj4x3T9Ho98fHxJCQkuLAy1zlz5gzp6elVtonZbCY2NtaxTRISEvD396dv376OZeLj49Hr9ezYsaPBa3aWvLw8AAICAgDYvXs35eXlVbZN586diYyMrLJtunfvTmhoqGOZ22+/nfz8fA4dOtSA1TuPzWZj5cqVFBUVERcXJ9sFmDVrFqNHj66yDaDh/2akc7vrkJWVhc1mq/IPARAaGsrRo0ddVJVrpaenA9S4TSrnpaenExISUmW+wWAgICDAsUxTZ7fbmT17NoMGDeLGG28EtM9tNBrx9/evsuyvt01N265yXlOWmJhIXFwcpaWl+Pj48OWXX9K1a1f27dvXorfLypUr2bNnD7t27ao2r6H/ZiQQhHCCWbNmcfDgQbZu3erqUhqNmJgY9u3bR15eHmvWrGHixIls2rTJ1WW5VGpqKk888QTr1q3Dw8PD1eXIWUbXIygoCDc3t2ot/hkZGYSFhbmoKteq/NxX2yZhYWFkZmZWmW+1WsnJyWkW2+3RRx/lm2++YcOGDVW6Uw8LC6OsrIzc3Nwqy/9629S07SrnNWVGo5Ho6Gj69OnDokWL6NmzJ2+88UaL3i67d+8mMzOT3r17YzAYMBgMbNq0iTfffBODwUBoaGiDbhsJhOtgNBrp06cP69evd0yz2+2sX7+euLg4F1bmOu3btycsLKzKNsnPz2fHjh2ObRIXF0dubi67d+92LPPTTz9ht9uJjY1t8Jrri1KKRx99lC+//JKffvqJ9u3bV5nfp08f3N3dq2ybY8eOkZKSUmXbJCYmVgnMdevW4efnR9euXRvmgzQQu92OxWJp0dtl2LBhJCYmsm/fPsfQt29f/vjHPzoeN+i2ue7m8RZu5cqVymQyqRUrVqjDhw+rRx55RPn7+1dp8W9uCgoK1N69e9XevXsVoBYvXqz27t2rkpOTlVLaaaf+/v7qX//6lzpw4IC66667ajzt9KabblI7duxQW7duVZ06dWryp53OnDlTmc1mtXHjRpWWluYYiouLHcvMmDFDRUZGqp9++kn98ssvKi4uTsXFxTnmV55COHz4cLVv3z71/fffq+Dg4CZ/euXTTz+tNm3apM6cOaMOHDignn76aaXT6dSPP/6olGq526Uml59lpFTDbhsJhHrw1ltvqcjISGU0GlX//v3V9u3bXV2SU23YsEEB1YaJEycqpbRTT5977jkVGhqqTCaTGjZsmDp27FiV98jOzlbjxo1TPj4+ys/PT02ePFkVFBS44NPUn5q2CaCWL1/uWKakpET96U9/Uq1atVJeXl7q7rvvVmlpaVXeJykpSY0cOVJ5enqqoKAgNW/ePFVeXt7An6Z+TZkyRbVr104ZjUYVHByshg0b5ggDpVrudqnJrwOhIbeNdH8thBACkDYEIYQQFSQQhBBCABIIQgghKkggCCGEACQQhBBCVJBAEEIIAUggCCGEqCCBIIQQApBAEKKaSZMm8fvf/95l6x8/fjwvv/yy097/8OHDtG3blqKiIqetQzRNcqWyaFF0Ot1V5z///PPMmTMHpVS1Pugbwv79+xk6dCjJycn4+Pg4bT333nsvPXv25LnnnnPaOkTTI4EgWpTLbxiyatUqFixYwLFjxxzTfHx8nPpF/FsefvhhDAYD7777rlPX8+233zJt2jRSUlIwGOS2KEIjh4xEixIWFuYYzGYzOp2uyjQfH59qh4x+97vf8dhjjzF79mxatWpFaGgo77//PkVFRUyePBlfX1+io6P57rvvqqzr4MGDjBw5Eh8fH0JDQxk/fjxZWVlXrM1ms7FmzRrGjBlTZXpUVBQvvfQSEyZMwMfHh3bt2vH1119z4cIF7rrrLnx8fOjRowe//PKL4zXJycmMGTOGVq1a4e3tTbdu3Vi7dq1j/m233UZOTk6Lv0GNqEoCQYha+PDDDwkKCmLnzp089thjzJw5k/vuu4+BAweyZ88ehg8fzvjx4ykuLgYgNzeXoUOHctNNN/HLL7/w/fffk5GRwf3333/FdRw4cIC8vLwq95qutGTJEgYNGsTevXsZPXo048ePZ8KECTz00EPs2bOHjh07MmHCBCp3+GfNmoXFYmHz5s0kJibyyiuvVNnzMRqN9OrViy1bttTzlhJN2rV20SpEU7d8+XJlNpurTZ84caK66667HM+HDBmiBg8e7HhutVqVt7e3Gj9+vGNaWlqaAlRCQoJSSqn//u//VsOHD6/yvqmpqQqo1hV4pS+//FK5ubkpu91eZXq7du3UQw89VG1dzz33nGNaQkKCAhzdInfv3l298MILV/38d999t5o0adJVlxEti+whCFELPXr0cDx2c3MjMDCQ7t27O6ZV3tS88q5V+/fvZ8OGDY42CR8fHzp37gzAqVOnalxHSUkJJpOpxobvy9dfua6rrf/xxx/npZdeYtCgQTz//PMcOHCg2nt6eno69miEADlkJEStuLu7V3mu0+mqTKv8Erfb7QAUFhYyZsyYKrdG3LdvHydOnOCWW26pcR1BQUEUFxdTVlZ21fVXrutq63/44Yc5ffo048ePJzExkb59+/LWW29Vec+cnByCg4NrtwFEiyCBIIQT9O7dm0OHDhEVFUV0dHSVwdvbu8bX9OrVC9CuE6gPERERzJgxgy+++IJ58+bx/vvvV5l/8OBBbrrppnpZl2geJBCEcIJZs2aRk5PDuHHj2LVrF6dOneKHH35g8uTJ2Gy2Gl8THBxM79692bp163Wvf/bs2fzwww+cOXOGPXv2sGHDBrp06eKYn5SUxLlz54iPj7/udYnmQwJBCCcIDw/n559/xmazMXz4cLp3787s2bPx9/dHr7/yf7uHH36Yjz/++LrXb7PZmDVrFl26dGHEiBHccMMNvP322475n376KcOHD6ddu3bXvS7RfMiFaUI0IiUlJcTExLBq1Sri4uKcso6ysjI6derEJ598wqBBg5yyDtE0yR6CEI2Ip6cnH3300VUvYLteKSkpPPPMMxIGohrZQxBCCAHIHoIQQogKEghCCCEACQQhhBAVJBCEEEIAEghCCCEqSCAIIYQAJBCEEEJUkEAQQggBSCAIIYSo8P8BwIpPzHz7ekEAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -434,7 +425,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.12.4" } }, "nbformat": 4,