diff --git a/jaxley_mech/channels/benav12.py b/jaxley_mech/channels/benav12.py new file mode 100644 index 0000000..ca05ead --- /dev/null +++ b/jaxley_mech/channels/benav12.py @@ -0,0 +1,214 @@ +from typing import Dict, Optional, Union + +import jax.debug +import jax.numpy as jnp +from jax.lax import select +from jaxley.channels import Channel +from jaxley.solver_gate import exponential_euler, save_exp, solve_gate_exponential, solve_inf_gate_exponential + +from jaxley_mech.solvers import SolverExtension + +META = { + "cell_type": "bipolar cell", + "species": ["Human Embryonic Kidney Cells"], + "reference": "Benav, H. (2012)", + "doi": "http://hdl.handle.net/10900/46043", + "note": "The model is using the reduced voltage not the membrane potential. Therefore, the resting potential has to be given as a parameter." +} + + +class Ca_T(Channel): + """ Transient type of Calcium Channel """ + + def __init__(self, + v_rest_global: float, + name: Optional[str] = None): + + self.current_is_in_mA_per_cm2 = True + + super().__init__(name) + self.channel_params = { + # To match the experimental data, I had to adapt the conductance + f"{self._name}_gCa_T": 0.03634, # S/cm^2 + + # The facilitate the calculation we treat the resting potential + # as fixed and set it to v_rest_global + f"{self._name}_v_r": v_rest_global, # mV + + } + self.channel_states = { + # This is the calcaultion from the dissertation of H. Benav: + # E_{Ca_T} = Neernst Ca++ * 45/100 + E_K * 55/100 + # E_K is taken from usui96 of Kv channel + # E_{Ca_T} = 132.65mV ×0.45 + (-58mV) * 0.55 = 27.5mV + # Equilibrium potential for calcium: + "eCa": 27.5, # mV + + + # Experimentally determined values for the gating variables + # Initial value for m gating variable + f"{self._name}_m": 0.1, + # Initial value for h gating variable + f"{self._name}_h": 0.9, + } + self.current_name = f"iCa_T" + self.META = META + + + def update_states( + self, + states: Dict[str, jnp.ndarray], + dt: float, + v_m: float, + params: Dict[str, jnp.ndarray], + ): + """Update state of gating variables.""" + prefix = self._name + m, h = states[f"{prefix}_m"], states[f"{prefix}_h"] + + # Since the gating variables are given in the steady state form + # use solve_inf_gate_exponential to calculate the new values + m_new = solve_inf_gate_exponential(m, dt, *self.m_gate(v_m, params[f"{self._name}_v_r"])) + h_new = solve_inf_gate_exponential(h, dt, *self.h_gate(v_m, params[f"{self._name}_v_r"])) + + return {f"{prefix}_m": m_new, f"{prefix}_h": h_new} + + def compute_current( + self, states: Dict[str, jnp.ndarray], v_m, params: Dict[str, jnp.ndarray] + ): + """Compute the current through the channel.""" + prefix = self._name + m, h = states[f"{prefix}_m"], states[f"{prefix}_h"] + Ca_T_cond = params[f"{prefix}_gCa_T"] * m* h + + return Ca_T_cond * (v_m - params["eCa"]) # mS/cm^2 *mV = mA/cm^2 + + def init_state(self, states, v_m, params, delta_t): + + """Initialize the state such at fixed point of gate dynamics.""" + prefix = self._name + + + m_inf, _ = self.m_gate(v_m, params[f"{self._name}_v_r"]) + h_inf, _ = self.h_gate(v_m, params[f"{self._name}_v_r"]) + + return { + f"{prefix}_m": m_inf, + f"{prefix}_h": h_inf + } + + @staticmethod + def m_gate(v_m, v_rest): + # Activation + # The model in the dissertation of H. Benav is based on reduced voltage + # and not on the membrane potential. Therefore, always subtract the resting potential. + v = v_m - v_rest + + # Calculate the time constant + tau_m = 1.358 + (21.675 / (1 + save_exp((v_m-39.9596)/4.110392))) + + # Calculate the steady state value + m_inf = (1 / (1 + save_exp((v - 37.5456)/-3.073015))) + + + # Give m _inf and tau_m back + return m_inf, tau_m + + @staticmethod + def h_gate(v_m, v_rest): + # Inactivation + + # The model in the dissertation of H. Benav is based on reduced voltage + # and not on the membrane potential. Therefore, always subtract the resting potential. + v = v_m - v_rest + + # Calculate the time constant + tau_h = 65.8207 + 0.00223 * save_exp((v-80) / 4.78719) + + # Calculate the steady state value + h_inf = (1 / (1 + save_exp((v - 8.968)/8.416382))) + + # Give h_inf and tau_h back + return h_inf, tau_h + + +class K_IR(Channel): + + """ Inward Rectifying potassium channel """ + + def __init__(self, + v_rest_global: float, + name: Optional[str] = None): + + self.current_is_in_mA_per_cm2 = True + + super().__init__(name) + + self.channel_params = { + + # To match the experimental data, I had to adapt the conductance + f"{self._name}_gK_IR": 6.27e-4, # S/cm^2 + + + # Using the same equilibrium potential as the potassium channel + # implemented by the Usui class + "eK_IR": -58, # mV + + # The facilitate the calculation we treat the resting potential + # as fixed and set it to v_rest_global + f"{self._name}_v_r": v_rest_global, # mV + } + self.channel_states = { + # Experimentally determined values for the gating variables + # Initial value for m gating variable + f"{self._name}_m": 0.9985, + } + self.current_name = f"iK_IR" + self.META = META + + + def update_states( + self, states: Dict[str, jnp.ndarray], dt, v_m, params: Dict[str, jnp.ndarray] + ): + """Update state of gating variables.""" + prefix = self._name + m = states[f"{prefix}_m"] + + # Since gating variables are given in a differntial equation, + # use solve_gate_exponential to solve the gating variable + m_new = solve_gate_exponential(m, dt, *self.m_gate(v_m, params[f"{self._name}_v_r"])) + + return {f"{prefix}_m": m_new} + + def compute_current( + self, states: Dict[str, jnp.ndarray], v_m, params: Dict[str, jnp.ndarray] + ): + """Compute the current through the channel.""" + prefix = self._name + m = states[f"{prefix}_m"] + g = params[f"{prefix}_gK_IR"] * m + return g * (v_m - params["eK_IR"]) # mS/cm^2 *mV = mA/cm^2 + + def init_state(self, states, v_m, params, delta_t): + + """Initialize the state such at fixed point of gate dynamics.""" + prefix = self._name + alpha_m, beta_m = self.m_gate(v_m, params[f"{self._name}_v_r"]) + + return { + f"{prefix}_m": alpha_m / (alpha_m + beta_m) + } + + @staticmethod + def m_gate(v_m, v_rest): + """Voltage-dependent dynamics for the n gating variable.""" + + # The model in the dissertation of H. Benav is based on reduced voltage + # and not on the membrane potential. Therefore, always subtract the resting potential. + v = v_m - v_rest + + alpha = 0.13289 * (save_exp((v - 8.94)/ -6.3902)) + beta = 0.16994 * (save_exp((v - 48.94)/ 27.714)) + + + return alpha, beta diff --git a/jaxley_mech/channels/benav12.py:Zone.Identifier b/jaxley_mech/channels/benav12.py:Zone.Identifier new file mode 100644 index 0000000..e69de29 diff --git a/notebooks/channels/benav12.ipynb b/notebooks/channels/benav12.ipynb new file mode 100644 index 0000000..45267de --- /dev/null +++ b/notebooks/channels/benav12.ipynb @@ -0,0 +1,425 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Imported successfully!\n" + ] + } + ], + "source": [ + "from typing import List\n", + "\n", + "from matplotlib.ticker import ScalarFormatter, FormatStrFormatter\n", + "import matplotlib.pyplot as plt\n", + "\n", + "import numpy as np\n", + "import jax.numpy as jnp\n", + "import jaxley as jx\n", + "from jaxley_mech.utils import prettify\n", + "\n", + "import jax\n", + "jax.config.update(\"jax_enable_x64\", True)\n", + "\n", + "import seaborn as sns\n", + "sns.set_style(\"whitegrid\")\n", + "\n", + "from jaxley_mech.channels.benav12 import Ca_T, K_IR" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_iv_curves_ramp(channels: List[jx.channels], \n", + " v_start: float = -100, \n", + " v_end: float = 50, \n", + " v_step_increase: float = 0.05, \n", + " measurements_per_step: int = 1, \n", + " title_str: str = None) -> None:\n", + " \"\"\"\n", + " Plot I-V curves for a list of channels by setting a holding voltage and\n", + " then applying a ramp voltage. Measure the current at each voltage step. \n", + " You can set the number of measurements per step to increase the resolution.\n", + " The mean is always taken over the number of measurements per step.\n", + " Before the holding voltage and after the ramp voltage padding is applied to\n", + " eliminate the edge effects. The I-V curve is plotted for each channel.\n", + " \n", + " channels: List[jx.channels] - List of channels to plot I-V curves for\n", + " v_start: float - Start voltage of the ramp in mV\n", + " v_end: float - End voltage of the ramp in mV\n", + " v_step_increase: float - Voltage step increase in mV\n", + " measurements_per_step: int - Number of measurements per step\n", + " title_str: str - Title of the figure\n", + " \"\"\"\n", + "\n", + " # Calculate the time step, which is the inverse of how many measurements are \n", + " # taken per step, so that the total time is the index of the taken measurement\n", + " dt = 1 / measurements_per_step\n", + " \n", + " # Calculate the padding steps based on the voltage step increase\n", + " padding_time = 10\n", + " padding_steps = int(padding_time / v_step_increase)\n", + "\n", + " # Define the number of voltage steps and create the ramp by repeating the voltage\n", + " # steps for the number of measurements per step\n", + " num_points = int((v_end - v_start) / v_step_increase)\n", + " v_ramp = jnp.repeat(jnp.linspace(v_start, v_end, num_points), measurements_per_step)\n", + " \n", + " # Apply padding to the voltage ramp\n", + " v_ramp = jnp.pad(v_ramp, (padding_steps, padding_steps), 'edge')\n", + " \n", + " # Total time with padding\n", + " total_time_pad = (len(v_ramp) - 1) * dt\n", + "\n", + " # Initialize cell components\n", + " compartment = jx.Compartment()\n", + " branch = jx.Branch(compartment, nseg=1)\n", + " cell = jx.Cell(branch, parents=[-1])\n", + "\n", + " # Set cell parameters\n", + " params = {\n", + " \"length\": 5.0,\n", + " \"radius\": 2.5,\n", + " \"capacitance\": 10,\n", + " \"v\": -80 # Assuming v_rest is -80 as per the function call\n", + " }\n", + " for name, param in params.items():\n", + " cell.set(name, param)\n", + " \n", + " # Define variables to record\n", + " to_records = ['v']\n", + " for channel in channels:\n", + " cell.insert(channel)\n", + " cell.init_states()\n", + " \n", + " # Add current names to records, excluding specific channels\n", + " if channel._name not in ['CaPump', 'CaNernstReversal']:\n", + " to_records.append(channel.current_name)\n", + "\n", + " # Initialize the array to store averaged currents at each voltage step\n", + " currents = np.zeros((len(channels), num_points))\n", + "\n", + " # Set up clamp and recording\n", + " cell.delete_recordings()\n", + " cell.delete_stimuli()\n", + " cell.clamp('v', v_ramp, False)\n", + " for rec in to_records:\n", + " cell.record(rec, verbose=False)\n", + "\n", + " # Integrate with the refined time step\n", + " s = jx.integrate(cell, delta_t=dt, t_max=total_time_pad)\n", + " s = prettify(s, to_records, dt)\n", + "\n", + " # Remove padding for analysis\n", + " s_pad = {}\n", + " for rec in to_records:\n", + " s_pad[rec] = s[rec][padding_steps:-padding_steps]\n", + " s_pad['time'] = s['time'][padding_steps:-padding_steps] - (padding_steps / measurements_per_step)\n", + " \n", + " # Calculate the average current at each voltage step\n", + " for i, rec in enumerate(to_records[1:]):\n", + " if 'i' in rec:\n", + " # Convert nA to pA by multiplying with 1e3\n", + " current_values = s_pad[rec] * 1e3\n", + " \n", + " # Calculate the mean current for each voltage step\n", + " for j in range(num_points):\n", + " # Use the start and end index to calculate the mean current\n", + " start_idx = j * measurements_per_step\n", + " end_idx = (j + 1) * measurements_per_step\n", + " currents[i, j] = np.mean(current_values[start_idx:end_idx])\n", + "\n", + " # Plot I-V curves for each channel\n", + " fig, axes = plt.subplots(1, len(channels), figsize=(10, 5 * len(channels)))\n", + " if len(channels) == 1:\n", + " axes = [axes]\n", + "\n", + " for idx_channel, channel in enumerate(channels):\n", + " axes[idx_channel].plot(v_ramp[padding_steps:-padding_steps:measurements_per_step], currents[idx_channel, :], linestyle='-', label=f'{channel._name}')\n", + " axes[idx_channel].set_xlabel('Ramp Voltage (mV)')\n", + " axes[idx_channel].set_ylabel('Current (pA)')\n", + " if title_str is not None:\n", + " axes[idx_channel].set_title(f'{title_str}')\n", + " else:\n", + " axes[idx_channel].set_title(f'I-V Curve for {channel._name}', fontsize=16)\n", + " if len(channels) > 1:\n", + " axes[idx_channel].legend()\n", + " axes[idx_channel].yaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=False))\n", + " axes[idx_channel].xaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=False))\n", + " axes[idx_channel].yaxis.set_major_formatter(FormatStrFormatter('%.3f'))\n", + " \n", + " # Plot voltage clamp for reference\n", + " fig, ax = plt.subplots(figsize=(10, 5))\n", + " ax.plot(s_pad['time'], s_pad['v'], linestyle='-', label='Vclamp')\n", + " ax.set_xlabel('Index of Voltage step')\n", + " ax.set_ylabel('Voltage (mV)')\n", + " ax.set_title('Voltage Clamp', fontsize=16)\n", + " ax.yaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=False))\n", + " ax.xaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=False))\n", + " ax.yaxis.set_major_formatter(FormatStrFormatter('%.3f'))" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA20AAAHWCAYAAADkYGFVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACMnklEQVR4nOzdeVhUZfsH8O/MMOz7KosrCKisihGIWqZp+TPTTK00e7NcyrTSTM1c0lfNrNfMyrKyNEvNrUxt18JEUwMBN2RxAZRV9m2YOb8/xhkdQWQQODPM93NdXjDnPOfMPTcjcPM85z4SQRAEEBERERERkUGSih0AERERERER3R6LNiIiIiIiIgPGoo2IiIiIiMiAsWgjIiIiIiIyYCzaiIiIiIiIDBiLNiIiIiIiIgPGoo2IiIiIiMiAsWgjIiIiIiIyYCzaiIiIiIiIDBiLNiIiapT8/HxMnz4dkZGRCAgIwJdffil2SAYlICAAH3zwgdhhtLijR48iICAAR48e1eu4Dz74AAEBAS0UVcvTxF9YWCh2KM3C2L8eRKbGTOwAiIha086dOzF37lxs374dwcHBdfYrFArExMSgS5cu+Pbbb+s9hyAIuO++++Ds7Ixdu3a1dMgGY/ny5YiNjcW0adPg6uqKoKCgFnmeOXPmNCqvI0aMwIoVK1okBkO1Z88eFBQU4Jlnnmn0MUqlErt378bu3btx7tw5VFRUwN3dHZGRkXjyySfr/X9gSpgfIjIGLNqIiG4il8sxZMgQbN26FVlZWfD29q4z5tixY7h69apevzi3BUeOHMEDDzyAiRMntujzjBkzBlFRUdrHmZmZWLNmDcaMGYNevXppt3fo0KFF49BXYmIiZDJZiz7Hjz/+iPPnzzf6vVdVVYVp06YhNjYWvXv3xuTJk+Hg4ICsrCzs378fu3btwsGDB9GuXbsWjRsApk6dikmTJrX48+jDkPJDRNQQFm1ERLcYNmwYtmzZgr1799b7S+aPP/4IqVSKhx9+WITobqioqIC1tXWrPV9BQQHs7e2b7XzV1dWQy+WQSnVX6oeHhyM8PFz7OCkpCWvWrEFYWBiGDx9+2/O1dj5uZWFhIdpz387KlSsRGxuLuXPn1in0pk2b1qpLXM3MzGBmZli/dhhSfoiIGsJr2oiIbtGrVy94e3tjz549dfYpFAr8/PPPiIyMhIeHR4PnUalU+OqrrzBs2DAEBwfj3nvvxcSJE5GUlARAPYMUEBCAnTt31jn21uujNNefpKamYubMmejduzeefPJJfP755wgICEBWVladc7z77rsICgpCcXGxdtvJkycxceJE9OrVC6GhoRg3bhxOnDjR4OvYuXMnAgICIAgCNm/ejICAAJ1rYS5fvozp06fjnnvuQWhoKEaPHo2DBw/qnENzHdTevXvxv//9D3379kVoaCjKysoafO47xfTPP/9g0aJFiIqKQv/+/QEAWVlZWLRoEQYPHoyQkBBERkZi+vTpyMzMrPccJ06cwPLly3HvvfciLCwML774Yp3rlpKSkjBx4kRERkYiJCQEAwYMwNy5c3XG1HdNW05ODubOnYvo6GgEBQVh6NCh2L59e7252bdvHz7++GP069cPwcHBmDBhAi5evKgdN378eBw8eBBZWVnar8GAAQNum6OrV69i69at6NOnT70zczKZDBMnTtTOIjU2b7dz8uRJPP/88+jduzfCwsIwbNgwfPXVV9r9t15D1ZT3f0ZGBmbNmoVevXrh3nvvxerVqyEIAq5cuYKpU6eiZ8+e6NOnD7744os7xqtvfjRKS0sxZ84cREREoFevXpg7dy4qKyt1xuzYsQNPP/00oqKiEBQUhIcffhjffPNNnecYMGAAJk+ejOPHj2PUqFEIDg7GAw88gN27d+uM0+e9CgB//vknnnzySYSFhSE8PByTJk3C+fPn75gTIjJchvUnLyIiAyCRSDBs2DCsW7cO58+fR9euXbX7YmNjUVRUhGHDht3xPG+88QZ27tyJfv36YdSoUVAqlTh+/DhOnjzZ5OtkZsyYgY4dO+KVV16BIAi4//778c4772D//v147rnndMbu378fffr0gYODAwAgLi4Ozz//PIKCgjBt2jRIJBLs3LkTEyZMwDfffIOQkJB6n7N3795YuXIlZs+ejT59+ujMduXn52Ps2LGorKzE+PHj4eTkhF27dmHq1KlYs2YNBg0apHOujz76CHK5HBMnTkRNTQ3kcnmT8qCxePFiODs748UXX0RFRQUAdYEVHx+PoUOHol27dsjKysK3336Lp59+Gnv37oWVlZXOOZYuXQp7e3tMmzYNWVlZ+Oqrr/DWW29h9erVANQzjBMnToSTkxMmTZoEe3t7ZGZm4tdff20wtvz8fIwePRoSiQRPPfUUnJ2d8ddff+GNN95AWVlZnUJh/fr1kEgkePbZZ1FWVobPPvsMs2bNwnfffQcAmDJlCkpLS3H16lVtwWhjY3Pb5//rr79QW1uLRx55pFG51DdvN/v7778xefJkuLu74+mnn4arqyvS0tJw8OBBTJgwoVHP3xivvPIKfH19MXPmTPz555/4+OOP4ejoiC1btuDee+/FrFmzsGfPHrz99tsIDg5G7969b3suffOj8fLLL8PHxwevvvoqTp8+je+++w7Ozs547bXXtGO+/fZbdO3aFQMGDICZmRkOHDiAxYsXQxAEPPXUUzrnu3jxImbMmIFRo0ZhxIgR2LFjB+bMmYMePXrofO8B7vxeBYDdu3djzpw5iImJwaxZs1BZWYlvv/0WTz75JHbt2gUfHx+9Xi8RGQYWbURE9dAUbXv27MGrr76q3f7jjz/CwsICgwcPbvD4I0eOYOfOnRg/fjzmz5+v3f7ss89CEIQmxxUYGIh3331XZ1tYWBj27dunU7QlJibi8uXLmDZtGgB185RFixYhMjISn332GSQSCQBg7NixGDp0KFavXn3b2Yn27dujffv2mD17Njp16qRTtH366afIz8/H5s2bERERAQB4/PHH8cgjj2D58uV44IEHdJY/VldXY8eOHbC0tGxyDm7m4OCAL7/8Uudasvvuuw9DhgzRGXf//fdjzJgx+Pnnn/Hoo4/q7HN0dMQXX3yhzYlKpcKmTZtQWloKOzs7xMfHo7i4GJ9//rlOsf3KK680GNv//vc/KJVK7NmzB05OTgCAJ554Aq+++irWrl2LsWPH6uShuroau3fvhrm5OQDA3t4e//3vf5GSkgJ/f3/06dMHGzduRElJSYPLRDXS0tIAoNEdAvXNm4ZSqcSCBQvg7u6O3bt36yyhvZv3en1CQkLw1ltvAVBf+zhgwACsWLECr776qnYp8//93/+hb9++2LFjR4NFm7750ejWrRuWLVumfVxUVITt27frFG1ff/21ztd23LhxmDhxIjZs2FCnaMvIyND5//PQQw+hf//+2LlzJ15//XWdsXd6r5aXl+O///0vHn/8cSxZskR73IgRIzBkyBB88sknOtuJyHhweSQRUT38/PzQvXt37N27V7utoqICf/zxB+677z7Y2to2ePwvv/wCiUSiLZpupvmFqynGjh1bZ9tDDz2EU6dO4dKlS9pt+/fvh7m5OQYOHAgAOHPmDC5cuIBhw4bh2rVrKCwsRGFhISoqKhAVFYVjx45BpVLpHc+ff/6JkJAQ7S+cgHr2Z8yYMcjKykJqaqrO+EcffbTZCjYAGD16dJ3mHzefX6FQ4Nq1a+jQoQPs7e1x+vTpes9x89ckIiICSqVSu+TUzs4OAHDw4EEoFIpGxSUIAn755RcMGDAAgiBo811YWIiYmBiUlpbi1KlTOseMHDlSW7Bp4gDUy0+bQrP0tKHZuJvpmzeN06dPIzMzE08//XSdax7v5r1en1GjRmk/l8lkCAoKgiAIOtvt7e3RuXPnO+ZN3/xo3Pp/MCIiAkVFRTpLfW/OZWlpKQoLC3HPPffg8uXLKC0t1Tnez89P5/+Ps7PzbeO/03v18OHDKCkpwdChQ3Xec1KpFKGhoXrfpoGIDAdn2ojIpFVVVdX5JcrNzQ2Aerbt7bffxr///ouePXvit99+Q2VlZaOWU126dAnu7u5wdHRs1njrW9o0ZMgQrFixAvv27cOUKVMgCAJ++ukn9OvXT1tcXrhwAQDq/OX+ZqWlpdqllI2VnZ2N0NDQOtu7dOmi3e/v799g/HejvvNVVVXhk08+wc6dO5GTk6Mz23Pr1xoAvLy8dB5rCo+SkhIAwD333IPBgwdj7dq1+PLLL3HPPfdg4MCBGDZsmE6RdbPCwkKUlJRg69at2Lp1623H6BOHvjRf+/Ly8kaN1zdvGpri4uavc0u5NUd2dnawsLCAs7Nzne1FRUUNnkvf/NwuBs3Xqbi4WHvOEydO4IMPPkBCQkKd6900s2Ianp6edZ7DwcFB51rUOz235j2i+X9+uyWpd/pjExEZLhZtRGTS9u3bV6ehxLlz5wAAQ4cOxTvvvIMff/wRPXv2xI8//ggHBwf069evWZ77drMQSqXytsfU16HQw8MDERER2L9/P6ZMmYKEhARkZ2dj1qxZ2jGaX8Bnz56Nbt261Xvu1ui82JyzbED9+ViyZIn2Wr2wsDDY2dlBIpForwO81a3dKzU0YyUSCdasWYOEhAQcOHAAsbGxmDdvHjZs2ICtW7fWO1OjmbV85JFHMGLEiHrPf+uyvDvFoS9N4Xzu3Lnbfs1vpm/e7lZT3v/15eh2t1m4U8z65qehGG5+vkuXLuGZZ55Bly5dMGfOHHh6ekIul+PPP//El19+WWdGW5/bRNzpuTUfV65cqf3jU1Ofi4gMC4s2IjJpMTEx2LBhQ737PDw8EBkZiZ9++gkvvPACDh8+jBEjRtx2duVmHTp0wKFDh1BUVHTb2TbNrNatMynZ2dn6vQiol0guXrwY6enp2LdvH6ysrHD//fdr97dv3x6A+i/t0dHRep//dry8vJCRkVFne3p6unZ/a9NcfzVnzhztturq6gZnixojLCwMYWFheOWVV7Bnzx7MmjUL+/btw+OPP15nrLOzM2xsbKBSqZo13/osN+zXrx9kMhn27Nlz2+vRbtbUvGneWykpKXq91uZ8/zeFvvlprD/++AM1NTX4+OOPdd7/rbE0UfO1cHFxadb3HRGJj9e0EZFJc3d3R3R0tM6/mw0bNgwFBQVYsGABFApFo7pGAsCDDz4IQRCwdu3aOvs0fw23tbWFk5MTjh8/rrO/vtbgdzJ48GDIZDLs3bsXP/30E+677z6dmbOgoCB06NABX3zxRb3LweprG94Y/fv3R2JiIuLj47XbKioqsG3bNnh7e8PPz69J570b9c0mbNq0qcEZnIYUFxfXmbXRzMzU1NTcNobBgwfj559/RkpKSp39Tc23lZVVo4tPT09PPP744zh06BA2bdpUZ79KpcIXX3yBq1evamO+VWPy1qNHD/j4+GibpNysodmu5nz/N4W++WksTR5vXV66Y8eOuwu4Efr27QtbW1t88skn9V5/2dT3HRGJjzNtREQNGDx4MBYvXozff/8dnp6eDXaju9m9996L4cOHY9OmTbh48SL69u0LlUqFEydOIDIyEuPGjQOg7rT46aef4o033kBQUBCOHz9e78zVnbi4uCAyMhIbNmxAeXl5nRt/S6VSLF26FM8//zz+7//+DyNHjoSHhwdycnJw9OhR2NraYt26dXo/76RJk7B37148//zzGD9+PBwcHLB7925kZmbigw8+uO1yrpZ033334fvvv4etrS38/PyQkJCAw4cPN/n6wl27duHbb7/FwIED0aFDB5SXl2Pbtm2wtbVtcKnszJkzcfToUYwePRqPP/44/Pz8UFxcjFOnTiEuLg7//POP3rH06NED+/btw/LlyxEcHAxra+sG79U2Z84cXL58GUuXLsUvv/yC+++/H/b29rhy5Qp++uknpKenY+jQoQCanjepVIpFixZh6tSpePTRRzFy5Ei4ubkhPT0dqamp+Pzzz297bHO9/5tKn/w0Vp8+fSCXyzFlyhSMHTsW5eXl+O677+Di4oK8vLwWeiVqtra2WLRoEWbPno2RI0fi4YcfhrOzM7Kzs/Hnn3+iZ8+eWLBgQYvGQEQtg0UbEVEDbG1tcf/99+Onn37C0KFD9Vqetnz5cgQEBGD79u1YuXIl7OzsEBQUhPDwcO0Yzc1xf/75Z+zfvx/9+vXDZ599hqioKL1jffjhh3H48GHY2NhobzR9s8jISGzduhUfffQRvv76a1RUVMDNzQ0hISEYM2aM3s8HAK6urtiyZQveeecdfP3116iurkZAQADWrVuH++67r0nnvFtvvPEGpFIp9uzZg+rqavTs2RMbNmyocx+7xrrnnnuQlJSEffv2IT8/H3Z2dggJCcGqVau0y9Hq4+rqiu+++w4ffvghfv31V3z77bdwdHSEn5+fzvWG+njyySdx5swZ7Ny5E19++SW8vb0bLNqsrKywfv167Ny5E7t378ZHH32EqqoquLu7IzIyEqtWrdLeJP5u8ta3b1989dVX+PDDD/HFF19AEAS0b98eo0ePbvC45nz/N4U++WmsLl26YM2aNVi9ejXefvttuLq64oknnoCzszPmzZvXQq/khmHDhsHd3R2ffvopPv/8c9TU1Givex05cmSLPz8RtQyJ0BJXFxMREREREVGz4DVtREREREREBoxFGxERERERkQFj0UZERERERGTAWLQREREREREZMBZtREREREREBoxFGxERERERkQHjfdpakUqlQm1tLaRSqV73eiIiIiIiorZFEASoVCqYmZlBKm14Lo1FWyuqra1FUlKS2GEQEREREZGBCA4Ohrm5eYNjWLS1Ik0FHRwcDJlMJnI0gFKpRFJSksHEYyqYd3Ew762PORcH8y4O5l0czLs4mPfmocnjnWbZABZtrUqzJFImkxnUG9zQ4jEVzLs4mPfWx5yLg3kXB/MuDuZdHMx782jMZVNsREJERERERGTAWLQREREREREZMBZtREREREREBoxFGxERERERkQFj0UZERERERGTAWLQREREREREZMBZtREREREREBoxFGxERERERkQFj0UZERERERGTAWLQREREREREZMKMt2jZv3owBAwYgODgYjz/+OBITExscv3//fgwZMgTBwcEYNmwY/vzzT539giDg/fffR0xMDEJCQvDMM8/gwoULOmOKioowc+ZM9OzZExEREZg3bx7Ky8ub+6URERERERFpGWXRtm/fPixfvhwvvvgidu3ahcDAQEycOBEFBQX1jv/3338xc+ZMjBo1Crt378YDDzyAF198ESkpKdox69evx6ZNm7Bo0SJs27YNVlZWmDhxIqqrq7VjZs2ahdTUVGzYsAHr1q3D8ePHsWDBghZ/vUREREREZLqMsmjbsGEDRo8ejcceewx+fn5YvHgxLC0tsWPHjnrHb9y4EX379sVzzz0HX19fvPzyy+jevTu+/vprAOpZto0bN2Lq1KkYOHAgAgMDsXLlSuTm5uK3334DAKSlpSE2NhZLly5FaGgoIiIiMH/+fOzduxc5OTmt9tqJiIiIiMi0mIkdgL5qampw6tQpTJ48WbtNKpUiOjoa8fHx9R6TkJCAZ555RmdbTEyMtiDLzMxEXl4eoqOjtfvt7OwQGhqK+Ph4DB06FPHx8bC3t0dwcLB2THR0NKRSKRITEzFo0KBGvwalUtnosS3lSnEVZm9PxJXCEljG/g2JRL1dAsmNQRLdY255qD2mznG37Ks7toET3bK/znlu2lt3X0OnvUN8OvtuH8+txzbltQiCgNLSUtgnHNc+163xyCQSSKUSyKSATCq58fj6R7Obt0kBqUS9TTNGJpWot8kkMJdJYWEmhfn1fxZmsusfb2y3uL7dwkwKa3MZbCzMIJPWeXVGTfP/zhD+/5kK5lwczLs4xMy7SiWgRqlCTa1K+7H6ps9ralWoVQlQXv934/Mb22tVApRK9UeVIOhuV6lQq9Q9ViUIEASoP+L6R5XuY5Wg/pmnGad5rBIAAbc81pzr+mPN+W+MVxME9WeaxxAElJaVw/bYUe0PXUG4kZsbx2ke39h5Y9tNbjm/zrluOUd9z4PGPo+REwQBVVVVsPzrUJ3fm4xBZ1dr/G90KOQyceev9Pl+YXRF27Vr16BUKuHi4qKz3cXFBenp6fUek5+fD1dX1zrj8/PzAQB5eXnabbcbk5+fD2dnZ539ZmZmcHBw0B7fWElJSXqNbwnxV6txOP3a9UelosZisq7mix1BgyxkEljJJbAyk8BaLoGlmRTW1x/bmEthbyGFg4X6482f25qrC0ZDZQj//0wNcy4O5l0c9eVdKQioVAioUKhQrhBQcf3zqloB1UoB1bXqf1XXP6+qFVCjFLT7NY+rlQJqlYBCJUChuvG5si1VA02VVyN2BKapuEzsCJok5WopDnWKh5OVTOxQGs3oira2IDg4GDKZuG+SUEFARFARTiSnoHPnzpBKpfX+Vei2jxvYeevPjnr/EqXdd/tjb31ONBRfg88p3HZf3eds+Cdfc7wWlUqFy5mX0d6nPSRSSZ0TCYL6B7xKJUB5/a+dqus/lFWqmx/f+KupZvzN+1QqQKFSQaFUoaZWQHWtUvvX1+ram/4Se8v2WpU6oOrrvyAUNZiRusykErRzsISXgyW8HK3g6WAJL0dLeDtaoYurDbwcrUSZxVMqlUhKSjKI/3+mgjkXB/PecgRBQGlVLQrKa1B4/Z/m84KyaqRn5UJqaYuyaiVKqhQorapFaZUCZdWtO/tmLpNALru+wuL6RzOZBGZSqXqlhlS9EkOmWbkhld70eX0fb9ovu7HSQwJAKlGvUJFKJJBI1I/Vn1/fL73l8fX9uP5ROx6a80B7Ls1jzcdbSSQSqFQqZF6+hPbtO0B206yJZmXOjZVENx93Y9Ttx0h0ttU3BrcbU89KpHqPN2JKlQoZGRno3LkzZFLju9qqvbM1Ojhbix2G9vt1Yxhd0ebk5ASZTFan6UhBQUGd2TQNV1dX7YxZfePd3Ny029zd3XXGBAYGas9RWFioc47a2loUFxdrj28smUxmED9Ig32coMy3QFiAu0HEYyqUSiUSzAoQFtbeIPNeXatEebUSZVW1KKtW/yuvrkWp5mOVAsWVChSW1yC/7KZfXMqqUVJVi1qVgMxrlci8VgngWp3zW5hJ0dnVBr7utvB1s0V3TzsE+zjCy8GyVZZYGMr/P1PCnIuDeddPZY0SV0uqcLW4CldLKnGluAo5xVXqjyVVuFpShcLyGijuOK1Vdds9lnIp7C3lsLM0g62lHDbmMljJZbAyl8HaXAZrczNYyjWf39iuHmN2Y6n7LcveNYWZ5nNjXK7WVEqlEgnIQ1iYN9/vrUipVMK+Ihth/vwdsrUYXdFmbm6OHj16IC4uDgMHDgSgnrmIi4vDuHHj6j0mLCwMR44c0bmu7fDhwwgLCwMA+Pj4wM3NDXFxcejWrRsAoKysDCdPnsQTTzwBAAgPD0dJSQmSk5MRFBQEADhy5AhUKhVCQkJa6NUStT71tW0yONuY631sTa0K+WXVuFJciayiKmQXVWr/XSqswIX8ClTXqnD2ainOXtVdlutsY45gbweE+Djgns7OiOjoDCtz/iAgouYhCALyy2pwqbAclworcLGgApcKKtSfF1Ygr7T6zie5zsZcBmdbczjbWMDVxhzONuZwspajqjgf3Xw7wtHaHHaWcthbmak/Wqo/mpsZ34wEERkGoyvaAOA///kPXn/9dQQFBSEkJARfffUVKisrMXLkSADA7Nmz4eHhgZkzZwIAnn76aYwfPx5ffPEF+vfvj3379iE5ORlvvfUWAPUU+NNPP42PP/4YHTt2hI+PD95//324u7trC0NfX1/07dsXb775JhYvXgyFQoElS5Zg6NCh8PDwECcRRAbG3EwKL0creDlaoVfHuvuVKgGZ1yqQlleGtNxynM8txansEpy7WorC8hr8mZKHP1PU14jKZRKE+jgiytcF/f3dEN7Bqc01RyGi5icIAvJKq5GSU4aUnFKczy3D+ZxSpOSUoqSqtsFjrc1laOdgiXb2ltqPng6W8Lj+2NXWAs425rCU1/2DklKpREJCJcLCfDjzQETNziiLtocffhiFhYVYs2YN8vLy0K1bN3z22Wfa5Y5XrlyB9Kb1tT179sSqVauwevVqvPfee+jUqRM+/PBD+Pv7a8c8//zzqKysxIIFC1BSUoJevXrhs88+g4WFhXbMqlWrsGTJEkyYMAFSqRQPPvgg5s+f33ovnMjIyaQSdHSxQUcXGwwIvLG9SqHE2aulSMoqRvzFaziSXoDs4iocv3gNxy9ewwd/pMLFxhwPdHPHg93bIaara72/NBGRaREEAdnFVUjKLEJiZjGSstT/iioU9Y6XSAAvByt0uH49SwcXa3R0sUZHZxt0cLaGvZWZSS0tJCLjYZRFGwCMGzfutsshN23aVGfbQw89hIceeui255NIJJgxYwZmzJhx2zGOjo5499139Q+WiBpkKZchrL0jwto7Yvy9HSEIAi4VVuBIegEOpRbg4LlcFJTXYNvxTGw7ngl7SzMMC/XCqF4+CGvvyF+yiExEda0SSZnFOJpRiOMXCpGYWYyC8rpdA6USoJOLDfzcbeHvYYeuHuqPnV1t+AcfIjJKRlu0EVHbJZHcmJEb07sDFEoVjqYX4tfTV/HzqRxcLanC5qOXsPnoJfi62WD8vR3xeER72FjwWxpRW1JTq8Lxi4U4kl6IfzIKEH+pCNW1Kp0xZlIJAtrZIcTHAcHejgj2dkBXD1sWZ0TUpvA3HCIyeHKZFDFdXRHT1RULh/VAXHoBtp/IxP7kK0jLK8eiPafx7q8peOKeDvhPn07wdLASO2QiaqLMaxX4MyUPB8/l4XBqPsprdNvlu9iY457OzujdyRnhHRzRzdOeBRoRtXks2ojIqEilEvTxc0UfP1e8NbwHdsdn4Yu/LyAjvxyf/pWOLw9fwLjIjph6ny/c7CzufEIiEpUgCDiXU4p9SVfxU/IVpOTo3qzX1dYcffxcEdnZBZFdnNHF1YZLoonI5LBoIyKjZWcpx/ioTngqsiMOnMvFuj/TcOzCNXzxdwa+/ecSno3phBfu8+OySSIDdPZqCfYmXsHepCtIzyvXbpdKgJ4dnHBfgBvuC3BHd097SNk5lohMHH+TISKjJ5VK8EA3DwwIdMeh1Hys+iUFJy8X4cMDadj5bxbe/L/ueLCbm9hhEpm8a+U1+D4hC9+dyMSp7BLtdnMzKfp1dcPQkHYYEOABB2u5iFESERkeFm1E1GZIJBL07eqGGD9X/HI6B0v3nsblwkq8sPlf9PVzwVMBvLEtUWsTBAFxaQXYfPQSfj2dgxqlupGIXCbBfQHu+L8QTwwIdIedJQs1IqLbYdFGRG2ORCLB4B7t0N/fDR8fTMPHf6YhNrUAJy5IsNgqC6N6tec1MUQtrLJGid0JWfjy7ws4l1Oq3d7d0x6PR/hgeJg3nG3MRYyQiMh4sGgjojbLUi7DK4P88Wi4N17dGo/4y8V4bXsS/jibh5WjQviXfaIWcK28Bl/8nYFNRy5qb3JtJZdhZE9vPHFPBwR5O4gcIRGR8WHRRkRtXmdXG2x5PhJvbTuMbWfKsT/5Ks5dLcUn43uhq4ed2OERtQn5ZdVYH5uOTXEXUXG9Tb+PkxUmRHXC6N7t4WDFP5IQETUVizYiMglmMilGdrPFYzFBmPZtAtLzyzH8w7/x7uOheCjYU+zwiIzWtfIafHggFV8fvYgqhfp6te6e9pg2wA+De7SDjJ0fiYjuGos2IjIpoe0dseelGEzfEo+/Uwvwwjf/Yv7Q7pgY01ns0IiMSpVCiY1xF/DBH6koraoFAIT6OGD6A10xINCd140SETUjFm1EZHJcbC3w1X/uwZIfT+OruItY8uNpZBdV4o2Hu/F+UER3IAgC9iRewdv7zyKrqBIAENjODq8/FIj7/N1YrBERtQAWbURkksxkUix6pAc8Ha2wYv9ZfH4oA2VVtVg+MpiFG9FtpOeV4c3vk/F3agEAoJ29JWY+6I+RPX24DJKIqAWxaCMikyWRSDClvy/c7Sww67uT2Hr8MgCwcCO6RZVCqb59xsE01ChVsDCT4sX7/fB83y6wMpeJHR4RUZvHoo2ITJ5mluCVrQnawm3FY8Fc5kUEIDGzCK9sTUBaXjkAoJ+/G5YM74GOLjYiR0ZEZDpYtBERARge5g2JRIKXt8Rj6/HLcLUzx2uDA8UOi0g0CqUKHx1Iwwd/nEetSoCbnQUWDuuOocGe/IMGEVErY9FGRHTdI6FeqKypxes7kvDhgTS0s7fE+KhOYodF1Ooy8svx8pZ4nMwsBgAMDfbE0keD4GRjLnJkRESmiUUbEdFNxvTugKvF1fjfbylY8MMptHOwwqDuHmKHRdRq9iddwWvbE1FWXQs7SzMsGR6E4WFenF0jIhKRVOwAiIgMzfQH/PDEPR0gCMArWxOQmlsmdkhELU6hVGHJj6cxdfO/KKuuRe9OTvj55X54NNybBRsRkchYtBER3UIikeCt4T1wT2dnlFXXYtKm4yitUogdFlGLyS+rxpPrj+DzQxkAgEn9uuCb5++Fl6OVyJERERHAoo2IqF5ymRQfPtkT7ewtkZ5Xjle3nYQgCGKHRdTszueU4tEP/8axC9dgZ2GGdeN6Yd7D3SCX8VcEIiJDwe/IRES34WZngXXje8FcJsWvp3Pw1eELYodE1Kxiz+dh5EeHkXmtEh1drLHrxT4YEtRO7LCIiOgWLNqIiBoQ1t4R8x5Wt/5ftv8szl0tFTkiouax9dglPLPhGEqra3FPJ2fseqEP/NxtxQ6LiIjqwaKNiOgOJkR3wv0BbqipVWHGlnhUKZRih0R0V9b/lY7XdyRBqRIwMtwbm567B85s509EZLBYtBER3YFEIsHKUaFwsTHH2aulePeXc2KHRNQkgiDg3V/O4b/7zgAApvT3xbujQ2FhJhM5MiIiagiLNiKiRnCzs8DKUSEAgM8PZeDk5SJxAyLSkyAIWLznND74IxUAMHtIAOY8FMh2/kRERoBFGxFRIz3QzQPDw7ygEoDXdyRCoVSJHRJRowiCgKV7z+DLwxcgkQBLHg3CC/f5iR0WERE1Eos2IiI9LPi/7nCyluPs1VKsj00XOxyiOxIEASt/Pqe9B9uKkcEYf29HkaMiIiJ9sGgjItKDi60F5g/tDgB4/7fzuFxYIXJERA1b83sqPj6YBgBYMrwHxvTuIHJERESkLxZtRER6GtnTG1FdXFBdq8KK/WfFDofotr46fAH/+y0FADB/aDeMj+okbkBERNQkLNqIiPQkkUiwYFh3SCXA3qQrOJJeIHZIRHX8fCoHi/acAgC8MtAfz/XtInJERETUVCzaiIiaoJunPZ64R73M7K09p6FUCSJHRHTDuYIavLLtJAQBeOKeDpj+AJuOEBEZMxZtRERN9Oogf9hbmuH0lRLsOJEpdjhEAICM/HIsP3QN1bUqDAh0x5LhPdjWn4jIyLFoIyJqIhdbC7w0oCsA4P3fz6O6VilyRGTqSqsUmPL1vyitERDsbY+1T4bDTMYf9URExo7fyYmI7sL4qI7wsLdAVlElvj16SexwyISpVAJmbjuJ1LxyOFtKsX58L1ibm4kdFhERNQMWbUREd8FSLsP0B9SzbWsPpKGiplbkiMhUffBHKn45nQNzmQSz+zjCzc5C7JCIiKiZsGgjIrpLoyPao4OzNfLLqvHl4Qtih0Mm6LfTOdrW/kuG90BXZ3ORIyIioubEoo2I6C7JZVK8Mkg92/ZZbAYqa3htG7Wey4UVeGVbAgBgQlRHjOrlI25ARETU7Fi0ERE1g2EhXujgbI3C8hpsOcZr26h1KJQqzNgSj9KqWoR3cMT8/+sudkhERNQCWLQRETUDM5kUk/urb1786V/pqKlViRwRmYL//ZqCfy8Vwc7SDGvGhkPOTpFERG0Sv7sTETWTx3r6wM3OAleKq7A7IUvscKiNiz2fh4//TAMArBgZgvbO1iJHRERELYVFGxFRM7GUy/BcTGcAwLo/06BSCSJHRG1VUUUNZm47CUEAnozsgKEhnmKHRERELYhFGxFRM3rq3o6wtzRDel45Dqbkih0OtVGLfjiF3NJqdHGzwZtDeR0bEVFbx6KNiKgZ2VqYYew9HQAAG/6+IG4w1Cb9lHwVuxOyIZUA7z4eCitzmdghERFRC2PRRkTUzMbf2xESCRB7Ph+puWVih0NtSGF5DebvTgIATO7vi/AOTiJHRERErYFFGxFRM2vvbI2B3TwAABvjLogbDLUpC75PRn5ZDfw9bPHywK5ih0NERK2ERRsRUQv4T3QnAMD2E5koqVKIGwy1CQfO5uLHxCuQSSV49/EwWJhxWSQRkalg0UZE1AKifF3g72GLiholdpzIFDscMnKVNUos+CEZAPBsn04I9nEQOSIiImpNLNqIiFqARCLBuHs7AgC2/HMZgsD2/9R0H/xxHpcLK+HlYImXB/qLHQ4REbUyFm1ERC1keJg3LMykOJdTipOZxWKHQ0YqJacUn/6VDgBY9EgP2FiYiRwRERG1NoMq2n755Rc8++yziIyMREBAAM6cOVNnTHV1NRYvXozIyEiEh4fjpZdeQn5+foPnFQQB77//PmJiYhASEoJnnnkGFy5c0BlTVFSEmTNnomfPnoiIiMC8efNQXl6uM+bs2bN48sknERwcjP79+2P9+vV3/ZqJqO1ysJJjaLD6psdbj10SORoyRoIgYP7uZNSqBAzs5oEHe7QTOyQiIhKBQRVtFRUV6NmzJ2bNmnXbMcuWLcOBAwewevVqbNq0Cbm5uZg2bVqD512/fj02bdqERYsWYdu2bbCyssLEiRNRXV2tHTNr1iykpqZiw4YNWLduHY4fP44FCxZo95eVlWHixInw8vLCzp07MXv2bKxduxZbt269+xdORG3W6N7tAQA/JGSjvLpW5GjI2OxLuop/MgphKZdi0SO8iTYRkakyqKLt0UcfxbRp0xAVFVXv/tLSUuzYsQNz5sxBVFQUgoKCsGzZMsTHxyMhIaHeYwRBwMaNGzF16lQMHDgQgYGBWLlyJXJzc/Hbb78BANLS0hAbG4ulS5ciNDQUERERmD9/Pvbu3YucnBwAwA8//ACFQoFly5aha9euGDp0KMaPH48NGza0SC6IqG2I7OyMTi7WKK9RYm/iFbHDISNSpVBi+X71ipMp/X3h42QtckRERCQWo1oYn5ycDIVCgejoaO02X19feHl5ISEhAWFhYXWOyczMRF5ens4xdnZ2CA0NRXx8PIYOHYr4+HjY29sjODhYOyY6OhpSqRSJiYkYNGgQEhISEBERAXNzc+2YmJgYrF+/HsXFxXBwaHwnL6VSqecrbxmaOAwlHlPBvItDzLyPjvDByp9TsOXYJTzW06vVn18sfK/fnS8OpSPzWiXa2VtgYp+Ojc4j8y4O5l0czLs4mPfmoU/+jKpoy8/Ph1wuh729vc52FxcX5OXl1XuMZruLi0udYzTXwuXn58PZ2Vlnv5mZGRwcHLTH5+fnw8fHR2eMq6urdp8+RVtSUlKjx7YGQ4vHVDDv4hAj7/5yJSQA/r1UhJ8OHUc7W6P61nvX+F7XX1GVEh/8rv4Z9XigJVJOJ+t9DuZdHMy7OJh3cTDvrUe03xx++OEHLFy4UPt4/fr1iIiIECucVhUcHAyZTPyboiqVSiQlJRlMPKaCeReH2HmPOnMMh9MKkKZwwpAw31Z/fjGInXNjNm9XMiprBYR4O2D6sHshlUoafSzzLg7mXRzMuziY9+ahyWNjiFa0DRgwAKGhodrHHh4edzzG1dUVCoUCJSUlOrNtBQUFcHNzq/cYzfaCggK4u7vrHBMYGKg9b2Fhoc5xtbW1KC4u1h7v6upap0ul5rFmxq2xZDKZQb3BDS0eU8G8i0OsvD8a7o3DaQX4IfEKXnqgKySSxv8Sbuz4XtdPam4pvrt+Q/YFw7pDLm/aj2rmXRzMuziYd3Ew761HtEYktra26Nixo/afpaXlHY8JCgqCXC5HXFycdlt6ejqys7PrvZ4NAHx8fODm5qZzTFlZGU6ePInw8HAAQHh4OEpKSpCcfGP5yZEjR6BSqRASEgIACAsLw/Hjx6FQKLRjDh8+jM6dO+u1NJKITNOQoHYwN5MiNbcMp7JLxA6HDNh7v6ZAJQAPdvdARCfnOx9ARERtnkF1jywqKsKZM2eQlpYGAMjIyMCZM2e015XZ2dnhsccew4oVK3DkyBEkJydj3rx5CA8P1ynahgwZgl9//RUAIJFI8PTTT+Pjjz/G77//jnPnzmH27Nlwd3fHwIEDAaibmfTt2xdvvvkmEhMTceLECSxZsgRDhw7VzgAOGzYMcrkcb7zxBs6fP499+/Zh48aN+M9//tOKGSIiY2VvKcfAburZ/u8TskSOhgxVclYx9iVdhUQCzBocIHY4RERkIAzqavg//vgDc+fO1T5+5ZVXAADTpk3DSy+9BACYN28epFIppk+fjpqaGsTExOhcGweoi73S0lLt4+effx6VlZVYsGABSkpK0KtXL3z22WewsLDQjlm1ahWWLFmCCRMmQCqV4sEHH8T8+fO1++3s7PD555/jrbfewsiRI+Hk5IQXXngBY8aMaZFcEFHbMzzMG/uSruKHk9mY81A3yPS4TolMw6pfzgEAhod6wd/DTuRoiIjIUBhU0TZy5EiMHDmywTEWFhZYuHBhnULtZufOndN5LJFIMGPGDMyYMeO2xzg6OuLdd99t8LkDAwPxzTffNDiGiOh27gtwg72lGXJKqnH8QiEiu7jc+SAyGccvFOLguTyYSSV4eaC/2OEQEZEBMajlkUREbZmFmQyDurcDAOxPvipyNGRIBEHAOz+r/+D4eER7dHK1ETkiIiIyJCzaiIha0UNB6qLt51NXoVIJIkdDhuJIeiGOZhTC3EyK6Q/4iR0OEREZGBZtREStKKarK2zMZbhSXIWTmUVih0MG4sMDqQCAMRHt4elgJXI0RERkaFi0ERG1Iku5DAO6qbvS/sQlkgQg4XIRDqXmQyaVYFK/LmKHQ0REBohFGxFRK9MskdyffBWCwCWSpk4zy/ZomDfaO1uLHA0RERkiFm1ERK2sv78bLMykuFRYgdNXeKNtU3b2agl+PZ0DiQSYep+v2OEQEZGBYtFGRNTKbCzM0N/fDQDw86kckaMhMX10IA2AevbVz91W5GiIiMhQsWgjIhLBgz3USyT/OMuizVRdKqjAj4nZAIAX7mPHSCIiuj0WbUREIrgvwA0SCZCcVYKckiqxwyERbDicAZUA9O3qiiBvB7HDISIiA8aijYhIBK62Fgj1cQQAHDibK24w1OpKqhTYduwyAOC5vuwYSUREDWPRRkQkkgcC3QEAv7NoMznbjl1GeY0SXd1t0a+rq9jhEBGRgWPRRkQkkgHd1EXbofP5qFIoRY6GWkutUoUNf18AADwb0xkSiUTcgIiIyOCxaCMiEkl3T3u0s7dEpUKJI+kFYodDreSX0znIKqqEs405RoR7ix0OEREZARZtREQikUgkuP/6Esk/uETSZHxxKAMA8FRkB1jKZSJHQ0RExoBFGxGRiB64qWgTBEHkaKilJWUW4/jFa5DLJBh/b0exwyEiIiPBoo2ISERRvi6QyyTIvFaJiwUVYodDLWzz0YsAgIeDPeFubylyNEREZCxYtBERicjGwgw9OzgBAGJT80WOhlpSSZUC3yeob6Y9jrNsRESkBxZtREQi63u95fuh83kiR0ItaXd8FioVSvh72CKio5PY4RARkRFh0UZEJLKYrm4AgMOpBahVqkSOhlqCIAjYfOQSAOCpyI5s809ERHph0UZEJLJgbwc4WMlRWl2Lk5nFYodDLeDExWs4l1MKK7kMI3qyzT8REemHRRsRkchkUgn6+LkAUN9om9qer4+oG5A8EuoFe0u5yNEQEZGxYdFGRGQAYvzUSyRjeV1bm1NYXoN9SVcBAE/d20HkaIiIyBixaCMiMgCaZiTxl4tQWqUQORpqTt8nZKFGqUIPL3uE+DiKHQ4RERkhFm1ERAagvbM1OrlYQ6kSEJdWIHY41Iy2n8gEAIyOaC9yJEREZKxYtBERGYg+furZtrh0Fm1txensEpzKLoFcJsEjoV5ih0NEREaKRRsRkYGI7KJuRnI0vVDkSKi57PhXPcs2sJsHnGzMRY6GiIiMFYs2IiIDcW9nZwDAmaslKK7gdW3GTqFUYXd8FgBgVC8fkaMhIiJjxqKNiMhAuNtboourDQQB+OcCZ9uM3cFzeSgor4GrrQX6+buJHQ4RERkxFm1ERAYksot6tu0or2szettPXAYAjAj3glzGH7dERNR0/ClCRGRAIjtfv64tgzNtxqygrBq/n8kFADzGpZFERHSXWLQRERkQzUzbqexilPB+bUZrX9IV1KoEBHnbI7CdvdjhEBGRkWPRRkRkQDwdrNDRxRoqATjO69qM1g8nswEAj4Z5ixwJERG1BSzaiIgMTGRnzXVtLNqMUVZRJY5duAaJBBga4il2OERE1AawaCMiMjCa69qO8Lo2o7Q3UT3L1ruTMzwdrESOhoiI2gIWbUREBkZzXVtyVjHKq2tFjob0pVka+Uiol8iREBFRW8GijYjIwPg4WcPTwRJKlYCTmUVih0N6SM8rQ3JWCWRSCR4Kaid2OERE1EawaCMiMkA9OzoBAP69eE3kSEgfe05eAQDE+LnCxdZC5GiIiKitYNFGRGSAenVQF20nWLQZDUEQ8MPJLABcGklERM2LRRsRkQHqpZlpu1QElUoQORpqjDNXSpGWVw5zMyke7OEhdjhERNSGsGgjIjJA3b3sYSmXorhSgfT8MrHDoUbYn6xeGnl/gBvsLOUiR0NERG0JizYiIgMkl0kR4uMIgEskjcX+5KsAgIeDeW82IiJqXizaiIgMlHaJ5MUicQOhO0rNLUVqbhnkMgnuD3QXOxwiImpjWLQRERkobTOSS5xpM3Q/n8oBAPTxc4U9l0YSEVEzY9FGRGSgNG3/U3PLUFRRI3I01JCfri+NHNKD92YjIqLmx6KNiMhAOduYo4urDQAg/lKRuMHQbWVeq0BSVjGkEmBgd3aNJCKi5seijYjIgGlm245fLBQ5ErodzdLI3p2c4cobahMRUQtg0UZEZMB6Xr+u7eTlYpEjodv5WbM0MohLI4mIqGWwaCMiMmAhPg4AgMRM3mTbEOWVVuPY9VnQwbyejYiIWgiLNiIiAxbQzg4WZlKUVNXiQkG52OHQLX47kwNBAEJ9HODlaCV2OERE1EaxaCMiMmBymRQ9vOwBAImZXCJpaH4/o76ebWA3NiAhIqKWYzBFm0KhwDvvvINhw4YhLCwMMTExmD17NnJycnTGFRUVYebMmejZsyciIiIwb948lJc3/Nfn6upqLF68GJGRkQgPD8dLL72E/Px8nTHZ2dmYNGkSQkNDERUVhbfffhu1tbU6Y44ePYoRI0YgKCgIgwYNws6dO5vnxRMRNSDExxEAkHC5SNQ4SFeVQolDqeqfJQ+waCMiohZkMEVbVVUVTp8+jalTp2Lnzp1Yu3YtMjIyMHXqVJ1xs2bNQmpqKjZs2IB169bh+PHjWLBgQYPnXrZsGQ4cOIDVq1dj06ZNyM3NxbRp07T7lUolJk+eDIVCgS1btmDFihXYtWsX1qxZox1z+fJlTJ48GZGRkfj+++8xYcIEzJ8/H7Gxsc2bCCKiW4S1dwSgvq6NDEdcWgGqFCp4Oliim6ed2OEQEVEbZjBFm52dHTZs2ICHH34YXbp0QVhYGN58802cOnUK2dnZAIC0tDTExsZi6dKlCA0NRUREBObPn4+9e/fWmZHTKC0txY4dOzBnzhxERUUhKCgIy5YtQ3x8PBISEgAAhw4dQmpqKt555x1069YN/fv3x4wZM7B582bU1KhvaLtlyxb4+Phgzpw58PX1xbhx4zB48GB8+eWXrZEeIjJhmmYkp7JLoFCqRI6GNH4/q/65MyDQHRKJRORoiIioLTMTO4CGlJWVQSKRwN5efT1HfHw87O3tERwcrB0THR0NqVSKxMREDBo0qM45kpOToVAoEB0drd3m6+sLLy8vJCQkICwsDAkJCfD394erq6t2TExMDBYtWoTU1FR0794dCQkJiIqK0jl3TEwMli1bpvfrUiqVeh/TEjRxGEo8poJ5F4cx5729oyXsLc1QUlWLM9nF2mvcDJ0x5/xOBEHA72dyAQD3+7sa1Gtsy3k3ZMy7OJh3cTDvzUOf/Bls0VZdXY1Vq1Zh6NChsLW1BQDk5+fD2dlZZ5yZmRkcHByQl5dX73ny8/Mhl8u1hZ+Gi4uL9pj8/Hydgg2A9vGdxpSVlaGqqgqWlpaNfm1JSUmNHtsaDC0eU8G8i8NY897JXorEKmDvkWQouliLHY5ejDXnDblQpMCV4iqYywDr8iwkJGSLHVIdbTHvxoB5FwfzLg7mvfWIVrT98MMPWLhwofbx+vXrERERAUDdlGTGjBkQBAGLFy8WK8QWExwcDJlMJnYYUCqVSEpKMph4TAXzLg5jz3uf3BQk5qbjGuwRFhYkdjiNYuw5b8jhg2kAChDj54bIXuFih6OjLefdkDHv4mDexcG8Nw9NHhtDtKJtwIABCA0N1T728FB33lIoFHj55ZeRnZ2Nr776SjvLBqhntgoLC3XOU1tbi+LiYri5udX7PK6urlAoFCgpKdGZbSsoKNAe4+rqisTERJ3jNN0lbx5za8fJ/Px82Nra6jXLBgAymcyg3uCGFo+pYN7FYax5D+vgBABIzCo2uviNNecNOXBOvQrjge4eBvva2mLejQHzLg7mXRzMe+sRrRGJra0tOnbsqP1naWmpLdguXryIL7/8Ek5OTjrHhIeHo6SkBMnJydptR44cgUqlQkhISL3PExQUBLlcjri4OO229PR0ZGdnIywsDAAQFhaGlJQUFBQUaMccPnwYtra28PPz0445cuSIzrkPHz6sPQcRUUsKvd72PyWnFBU1tQ0PphZVUFaN+Ou3XxgQ6C5uMEREZBIMpnukQqHA9OnTkZycjFWrVkGpVCIvLw95eXnaDo6+vr7o27cv3nzzTSQmJuLEiRNYsmQJhg4dqp2py8nJwZAhQ7QzZ3Z2dnjsscewYsUKHDlyBMnJyZg3bx7Cw8O1BVdMTAz8/Pwwe/ZsnD17FrGxsVi9ejWeeuopmJubAwDGjh2Ly5cvY+XKlUhLS8PmzZuxf/9+PPPMM62eKyIyPe0cLOFuZwGVAJzOLhE7HJN28FweBAHo7mkPTwcrscMhIiITYDCNSHJycvDHH38AAIYPH66zb+PGjYiMjAQArFq1CkuWLMGECRMglUrx4IMPYv78+dqxCoUCGRkZqKys1G6bN28epFIppk+fjpqaGsTExOhcTyeTybBu3TosWrQIY8aMgZWVFUaMGIHp06drx7Rv3x6ffPIJli9fjo0bN6Jdu3ZYunQp+vbt2yL5ICK6VZC3A/44m4tT2SWI6OR85wOoRfyZol4aeX9g/cvyiYiImpvBFG0+Pj44d+7cHcc5Ojri3Xff1es8FhYWWLhwoU6hditvb2+sX7++weeOjIzE7t277xgjEVFLCPKyv160FYsdislSqQQcSlVf39zfn0sjiYiodRjM8kgiImpYdy/1TbaTs7g8UiynsktQWF4DWwszhHdwFDscIiIyESzaiIiMhOam2udzS1FTqxI5GtP013n10sgoXxfIZfwRSkRErYM/cYiIjISPkxUcrORQKAWk5JSKHY5J+uv69Wz9urqKHAkREZkSFm1EREZCIpFoZ9t4XVvrK6uuxYmL1wAA/fzZhISIiFoPizYiIiNyo2jjdW2t7UhaAWpVAjo4W6Oji43Y4RARkQlh0UZEZER6XG9GwqKt9WmuZ+vnz6WRRETUuvRq+a9SqfDPP//g+PHjyM7ORlVVFZydndGtWzdER0fD09OzpeIkIiIAQd7qmbYzV0qgVAmQSSUiR2Q6Ys+rW/3368qlkURE1LoaNdNWVVWFjz76CP3798ekSZMQGxuL0tJSSKVSXLx4ER988AEeeOABPP/880hISGjhkImITFdnV1tYyWWoqFEiI79c7HBMxuXCCmTkl8NMKkGUr4vY4RARkYlp1Ezb4MGDERYWhqVLlyI6OhpyubzOmKysLPz444949dVXMWXKFIwePbrZgyUiMnUyqQSBnnaIv1SEU9nF8HO3FTskk6BZGtmzgxPsLOv+DCQiImpJjSravvjiC/j6+jY4xtvbG5MnT8azzz6LK1euNEtwRERUV5CXA+IvFeF0dgmGh3mLHY5JiE1RL43sy1b/REQkgkYtj7xTwaaRkpICuVyODh063FVQRER0e5oOksls+98qlCoBcekFAIAYFm1ERCQCvRqR1KesrAx79+7Fd999h1OnTuHMmTPNERcREd3GzR0kBUGARMJmJC3pzJUSFFcqYGthhmBvB7HDISIiE9Tkou3YsWPYvn07fvnlF7i7u2PQoEFYsGBBc8ZGRET18G9nC5lUgqIKBXJKqtHOwVLskNq0uDT1LNs9nZ1hJuOdcoiIqPXpVbTl5eVh165d2L59O8rKyvDQQw+hpqYGH374Ifz8/FoqRiIiuomFmQxdXG1wPrcMZ66WsGhrYYfT1NezRbNrJBERiaTRfzKcMmUKhgwZgnPnzmHevHmIjY3Fm2++2ZKxERHRbQR6qq9rO3ulVORI2jaFUoV/MgoBAPd2YdFGRETiaPRM219//YXx48fjiSeeQKdOnVowJCIiupPAdnbYcxI4d7VE7FDatKSsYpTXKOFgJUf364UyERFRa2v0TNs333yD8vJyjBw5Eo8//ji+/vprFBYWtmRsRER0G4Ht7AAAZ69ypq0laa5nu7eLM6RSNnwhIiJxNLpo09xc+9ChQxgzZgz27t2Lfv36QaVS4e+//0ZZWVlLxklERDfRLI9MyytDTa1K5GjaLk3RFu3LVv9ERCQevdtgWVtbY9SoUfj222/xww8/4D//+Q/Wr1+P6OhoTJkypSViJCKiW3g5WMLO0gwKpYD0fP7RrCVU1ypx/KJ6RUkUm5AQEZGI7qp3cZcuXTB79mz8+eefeO+995orJiIiugOJRHJjiSSbkbSIhEtFqFKo4Gprjq7utmKHQ0REJuyubq595coVAICnpycGDhyIgQMHNktQRER0Z4Ht7HHswjVe19ZC4tI117O58AbmREQkKr2LttraWqxduxabNm1CRUUFAPWSyXHjxmHatGmQy+XNHiQREdUVoG1Gwg6SLeEwr2cjIiIDoXfRtmTJEvz666947bXXEBYWBgBISEjA2rVrUVRUhMWLFzd3jEREVI9unuqi7Rxn2ppdlUKJhEtFAHg9GxERiU/vou3HH3/Ee++9h/79+2u3BQYGwtPTE6+++iqLNiKiVuLvoS7arhRXoaiiBo7W5iJH1HbEXypCjVIFdzsLdHKxFjscIiIycXo3IjE3N4ePj0+d7T4+PlwaSUTUiuws5fBxsgLA+7U1t2MX1F0je3d25vVsREQkOr2LtqeeegofffQRampqtNtqamrw8ccfY9y4cc0aHBERNSywnfp+bVwi2bw0Rds9nZxFjoSIiKgJyyPPnDmDuLg49OvXD4GBgQCAs2fPQqFQICoqCtOmTdOOXbt2bfNFSkREdQS2s8NvZ3LYjKQZ1SpV+PfiNQDAPZ1ZtBERkfj0Ltrs7e0xePBgnW2enp7NFhARETVeoKemgyRn2prL6SslKK9Rwt7SDAHXrxskIiISk95F2/Lly1siDiIiagLNDbbPXS2FSiVAKuX1V3frnwz10siITs7MJxERGQS9r2kjIiLD0cnFBuZmUlTUKJFVVCl2OG2CtgkJr2cjIiID0aiibeLEiUhISLjjuLKyMnz66afYvHnz3cZFRESNYCaToourDQDgfC6XSN4tQRBw/ILmejYnkaMhIiJSa9TyyCFDhuCll16CnZ0d7r//fgQFBcHd3R0WFhYoKSlBamoqTpw4gb/++gv9+/fH7NmzWzpuIiK6rquHHc5eLUVKThkGBHqIHY5RS8srR0F5DSzMpAj2dhQ7HCIiIgCNLNoef/xxDB8+HPv378f+/fuxbds2lJaq/6IrkUjg5+eHmJgYbN++Hb6+vi0aMBER6fJ3twUAnM8pEzkS46dZGhnW3hHmZryCgIiIDEOjG5GYm5tj+PDhGD58OACgtLQUVVVVcHR05E21iYhE1NXjetHG5ZF37dj1JiRs9U9ERIZE7+6RGnZ2drCzYytkIiKxdb3elj41t4wdJO/SP2xCQkREBohrP4iIjFxHZ2vIZRJ2kLxLV4orkXmtElIJ0LMjm5AQEZHhYNFGRGTk1B0k1UskU3N5XVtTHbveNbKHlwNsLZq8EIWIiKjZsWgjImoDNNe1peTwuram+veiumjrxVk2IiIyMCzaiIjagK7u6uvaznOmrcniL6mLtvAOjuIGQkREdAu9i7YHHngA165dq7O9pKQEDzzwQLMERURE+vHXdJDkTFuTVCmUOJVdAgDo2YEzbUREZFj0LtqysrKgUqnqbK+pqUFOTk6zBEVERPq50fa/DIIgiByN8UnKKkatSoC7nQV8nKzEDoeIiEhHo6+0/v3337Wfx8bG6rT7V6lUiIuLg7e3d/NGR0REjdLRxUang6SPk7XYIRkVzfVsPTs4QSLhLROIiMiwNLpoe/HFFwEAEokEc+bM0T2JmRm8vb3rbCciotYhl0nR2dUGKTllOJ9bxqJNTyc0RVtHR3EDISIiqkeji7azZ88CAAYMGIDt27fD2Zk3HiUiMiRd3e3URVtOKe4PcBc7HKMhCAL+vVQEgNezERGRYdL7RjR//PFHS8RBRER3qauHLZAEnM9hB0l9ZF6rRH5ZNeQyCYK8HcQOh4iIqI4m3T00Li4OcXFxKCgoqNOUZPny5c0SGBER6UfT9j+Fbf/18u/1Vv/dvRxgKZeJHA0REVFdehdta9euxYcffoigoCC4ubnxgm0iIgOhafufmlMKQRD4/bmRbjQhcRQ3ECIiotvQu2jbsmULli9fjkcffbQFwiEioqbq6GIDM6kE5TVKXCmugpcjW9c3Bq9nIyIiQ6f3fdoUCgV69uzZErEQEdFdMDdTd5AEgBTeZLtRKmuUOHPl+k21O7JoIyIiw6R30TZq1Cjs2bOnJWIhIqK75OeuXiKZllcuciTGITGzCLUqAR72FvBysBQ7HCIionrpvTyyuroa27ZtQ1xcHAICAmBmpnuKuXPnNjmYDz74AHv37sXVq1chl8vRo0cPvPLKKwgNDdWOKSoqwpIlS3DgwAFIpVI8+OCDeOONN2BjY9NgzCtWrMC+fftQU1ODmJgYLFy4EK6urtox2dnZWLRoEY4ePQpra2s8+uijmDlzps7rO3r0KFasWIHz58/D09MTU6dOxciRI5v8eomImpuvm6ZoYzOSxjhxvQlJr468qTYRERkuvWfazp07h8DAQEgkEqSkpOD06dPaf2fOnLmrYDp16oQFCxZgz549+Oabb+Dt7Y1nn30WhYWF2jGzZs1CamoqNmzYgHXr1uH48eNYsGBBg+ddtmwZDhw4gNWrV2PTpk3Izc3FtGnTtPuVSiUmT54MhUKBLVu2YMWKFdi1axfWrFmjHXP58mVMnjwZkZGR+P777zFhwgTMnz8fsbGxd/WaiYiak6+7+g9Yaewg2Sj/XiwCwOvZiIjIsOk907Zp06aWiAMAMGzYMJ3Hc+fOxfbt23Hu3DlERUUhLS0NsbGx2L59O4KDgwEA8+fPx6RJkzB79mx4eHjUOWdpaSl27NiBVatWISoqCoC6iHv44YeRkJCAsLAwHDp0SFsIurq6olu3bpgxYwZWrVqFadOmwdzcHFu2bIGPjw/mzJkDAPD19cWJEyfw5Zdfom/fvi2WEyIifdyYaePyyDsRBAEJl4sAAOHsHElERAasSfdpA4CLFy/i0qVL6N27NywtLZu9vXRNTQ22bt0KOzs7BAQEAADi4+Nhb2+vLdgAIDo6GlKpFImJiRg0aFCd8yQnJ0OhUCA6Olq7zdfXF15eXtqiLSEhAf7+/jrLJWNiYrBo0SKkpqaie/fuSEhI0BZ9N49ZtmyZ3q9NqVTqfUxL0MRhKPGYCuZdHKaS947O6o6R+WXVKCyrgoOVXLRYDD3n2UXqm2qbSSUI9LA12Dj1Zeh5b6uYd3Ew7+Jg3puHPvnTu2i7du0aXn75ZRw9ehQSiQS//PIL2rdvj3nz5sHBwUE7E9VUBw4cwKuvvorKykq4ubnhiy++gLOzMwAgPz9f+7n2BZiZwcHBAXl5efWeLz8/H3K5HPb29jrbXVxctMfk5+frFGwAtI/vNKasrAxVVVWwtGz8BexJSUmNHtsaDC0eU8G8i8MU8u5sJUVhpQo/H46Hv4u52OEYbM7jMqsAAO3tZTh7yjBjvBuGmve2jnkXB/MuDua99ehdtC1fvhxmZmY4ePAgHnroIe32hx9+GCtWrGh00fbDDz9g4cKF2sfr169HREQEIiMjsXv3bly7dg3btm3Dyy+/jO+++w4uLi76hmqwgoODIZPJxA4DSqUSSUlJBhOPqWDexWFKeQ/89xgOpxVA6uSFsDAf0eIw9Jz/fPUcgCLc29UTYWE9xA6n2Rh63tsq5l0czLs4mPfmocljY+hdtP3999/4/PPP0a5dO53tnTp1QnZ2dqPPM2DAAJ2ukJrr0aytrdGxY0d07NgRYWFhePDBB7F9+3ZMnjwZrq6uOk1JAKC2thbFxcVwc3Or93lcXV2hUChQUlKiM9tWUFCgPcbV1RWJiYk6x+Xn5wOAzhjNtpvH2Nra6jXLBgAymcyg3uCGFo+pYN7FYQp593WzxeG0AmTkVxrEazXUnCdmFQMAwjo4GmR8d8tQ897WMe/iYN7Fwby3Hr27R1ZUVNRbpBQVFcHcvPHLcGxtbbXFWceOHW9b+KhUKtTU1AAAwsPDUVJSguTkZO3+I0eOQKVSISQkpN7jg4KCIJfLERcXp92Wnp6O7OxshIWFAQDCwsKQkpKCgoIC7ZjDhw/D1tYWfn5+2jFHjhzROffhw4e15yAiMhS+btc7SLLt/20pVQKSs9Q31Q5t7yhuMERERHegd9EWERGB3bt362xTqVT47LPPEBkZ2eRAKioq8N577yEhIQFZWVlITk7G3LlzkZOTgyFDhgBQNxDp27cv3nzzTSQmJuLEiRNYsmQJhg4dqp2p04zXzJzZ2dnhsccew4oVK3DkyBEkJydj3rx5CA8P1xZcMTEx8PPzw+zZs3H27FnExsZi9erVeOqpp7SF6NixY3H58mWsXLkSaWlp2Lx5M/bv349nnnmmya+ZiKgl+LrzXm13kp5XhrLqWliby9DV3U7scIiIiBqk9/LI1157Dc8884y2K+M777yD1NRUFBcX49tvv21yIDKZDOnp6di1axeuXbsGR0dHBAcHY/Pmzejatat23KpVq7BkyRJMmDBBe3Pt+fPna/crFApkZGSgsrJSu23evHmQSqWYPn26zs21b37udevWYdGiRRgzZgysrKwwYsQITJ8+XTumffv2+OSTT7B8+XJs3LgR7dq1w9KlS9nun4gMjqbt/6WCCiiUKshlev99rs07maleGhnk5QCZlDfVJiIiw6Z30ebv74+ff/4ZX3/9NWxsbFBRUYFBgwbhqaeegru7e5MDsbCwwNq1a+84ztHREe++++5t9/v4+ODcuXN1zr1w4UKdQu1W3t7eWL9+fYPPrWmSQkRkyNrZW8LaXIaKGiUuFVZoizi64eT1+7OFtncQNxAiIqJG0KtoUygUeO6557B48WJMnTq1pWIiIqK7IJVK0MXNBslZJUjLLWPRVo+TmUUAgBAfR1HjICIiagy91szI5fI6s1hERGR4NIVaWl65yJEYnupaJc5cUTchCWMTEiIiMgJ6X+jwyCOPYPv27S0RCxERNZMbRRubkdzqzJVSKJQCnKzl8HGyEjscIiKiO9L7mjalUolvv/0Whw8fRlBQEKysdH/gzZ07t9mCIyKipunCtv+3lXh9aWRoe0dIJGxCQkREhk/voi0lJQXdu3cHAGRkZOjs4w8/IiLDoJ1pyy2DIAj8/nyTBE0TEl7PRkRERkKvok2pVGL69Onw9/eHgwM7bhERGarOrjaQSICSqlrkl9XAzc5C7JAMRuL1dv/sHElERMZCr2vaZDIZnn32WZSUlLRUPERE1Aws5TLt9VpcInlDSZVCmw92jiQiImOhdyOSrl27IjMzsyViISKiZsRmJHUlZxZDEABvRyu42nL2kYiIjIPeRdvLL7+Mt99+GwcOHEBubi7Kysp0/hERkWG4cV0b2/5rnLy+NJKt/omIyJjo3Yhk0qRJAICpU6fqXNiuudD9zJkzzRcdERE1maZoS8/nH9Q0Tl5vQhLiw+vZiIjIeOhdtG3cuLEl4iAiombmy7b/dSRlqWfaeD0bEREZE72Ltnvuuacl4iAiombm666eacu8VokqhRKWcpnIEYnrWnkNsooqAQA9vO1FjoaIiKjx9C7ajh071uD+3r17NzkYIiJqPi425rC3NENJVS0uFJQjsJ1pFyqnr6g7H3dwtoa9pVzkaIiIiBpP76Jt/PjxdbbdfG0br2kjIjIMEokEnd1scfJyETLyWLSdylYvjezhZdp5ICIi43PXM20KhQJnzpzB+++/j1deeaXZAiMiorvXxdUGJy8XIT2fHSRPZatn2li0ERGRsdG7aLOzs6uzrU+fPpDL5VixYgV27tzZLIEREdHd6+yqbkaSwaLtpqKNnSOJiMi46H2ftttxcXFBRkZGc52OiIiaAYs2tcoaJdKvd9HkTBsRERkbvWfazp49W2dbbm4u1q9fj8DAwGYJioiImkeX623/00287f+ZqyVQCYCrrQXc7S3FDoeIiEgvehdtjz76KCQSCQRB0NkeFhaG//73v80WGBER3b1OLuqi7VqFAtfKa+BkYy5yROLg9WxERGTM9C7afv/9d53HUqkUzs7OsLCwaLagiIioedhYmKGdvSWullQho6DcZIu20+wcSURERkzvos3b27sl4iAiohbS2dVGXbTllaNnByexwxEFm5AQEZExa3Qjkri4ODz88MMoK6t7XURpaSmGDh2K48ePN2twRER09zq7mXYzEoVShbNXSwFwpo2IiIxTo4u2r776CqNHj4atrW2dfXZ2dhgzZgw2bNjQrMEREdHd62LiHSTT8spQU6uCrYUZOjhbix0OERGR3hpdtJ07dw59+/a97f4+ffrg1KlTzRIUERE1H03bf1O9wfapLPXSyO6e9pBKJSJHQ0REpL9GF235+fkwM7v9JXBmZmYoLCxslqCIiKj5aIq2C/nlUKmEO4xuezTXs3Xn0kgiIjJSjS7aPDw8cP78+dvuP3fuHNzc3JolKCIiaj7tna1hJpWgUqFETmmV2OG0ulPsHElEREau0UVb//798f7776O6urrOvqqqKnzwwQe4//77mzU4IiK6e3KZVHstV0aeaS2RFAQBp6+wcyQRERm3Rrf8nzp1Kn755RcMHjwYTz31FDp37gwASE9PxzfffAOlUokpU6a0WKBERNR0nV1tkJ5fjvT8ckT7uYodTqu5XFiJ0qpamMuk6OpRt5EWERGRMWh00ebq6ootW7Zg0aJFeO+99yAI6usiJBIJYmJisGDBAri6ms4vAkRExkTbjMTEZto0SyP929lCLmv04hIiIiKDotfNtb29vbF+/XoUFxfj4sWLAICOHTvCwYFLToiIDNmNe7XVvddmW6a9qbYnf04REZHx0qto03BwcEBISEhzx0JERC2ks4neq03bhMSbTUiIiMh4ca0IEZEJ6OKqvp7r8rVK1NSqRI6m9Whn2tg5koiIjBiLNiIiE+BhbwFrcxmUKgGXr1WIHU6ryCutRm5pNSQSILAdizYiIjJeLNqIiEyARCK5sUTSRJqRaJZGdna1gY1Fk64GICIiMggs2oiITISpXdd2Y2kkm5AQEZFxY9FGRGQiumja/ptI0XbjptpcGklERMaNRRsRkYkwtbb/p9mEhIiI2ggWbUREJqLz9Q6SprA8sqy6Vvs6uTySiIiMHYs2IiIT0dlFPdOWU1KN8upakaNpWWeuL430dLCEs425yNEQERHdHRZtREQmwsFaDpfrBUxbn207lXX9ptpcGklERG0AizYiIhPS2USakWg6R3bn0kgiImoDWLQREZkQU7lX2yk2ISEiojaERRsRkQnp4qZpRtJ2O0jW1KpwPrcUANDdk0UbEREZPxZtREQmxBRusJ2SUwqFUoCDlRw+TlZih0NERHTXWLQREZmQLm43rmkTBEHkaFqG5v5s3T3tIZFIRI6GiIjo7rFoIyIyIR2crSGRAKVVtSgorxE7nBZxKpudI4mIqG1h0UZEZEIs5TJ4O6qXDLbVJZLaJiTeLNqIiKhtYNFGRGRi2nIHSZVK0N5Yuwfb/RMRURvBoo2IyMR0acP3artQUI7yGiUszKTa10lERGTsWLQREZkY7Q2289pe23/N0shAT3uYyfgjjoiI2gaD/Ym2YMECBAQE4Msvv9TZXlRUhJkzZ6Jnz56IiIjAvHnzUF7e8F+Lq6ursXjxYkRGRiI8PBwvvfQS8vPzdcZkZ2dj0qRJCA0NRVRUFN5++23U1tbqjDl69ChGjBiBoKAgDBo0CDt37myW10pE1Jpu3Kut7c208abaRETUFhlk0fbrr7/i5MmTcHd3r7Nv1qxZSE1NxYYNG7Bu3TocP34cCxYsaPB8y5Ytw4EDB7B69Wps2rQJubm5mDZtmna/UqnE5MmToVAosGXLFqxYsQK7du3CmjVrtGMuX76MyZMnIzIyEt9//z0mTJiA+fPnIzY2tvleOBFRK9DMtF0sqIBS1bba/rNzJBERtUUGV7Tl5ORgyZIlWLVqFeRyuc6+tLQ0xMbGYunSpQgNDUVERATmz5+PvXv3Iicnp97zlZaWYseOHZgzZw6ioqIQFBSEZcuWIT4+HgkJCQCAQ4cOITU1Fe+88w66deuG/v37Y8aMGdi8eTNqatQtsbds2QIfHx/MmTMHvr6+GDduHAYPHlxnJpCIyNB5O1rB3EyKGqUKWdcqxQ6n2QiCoL1HG5uQEBFRW2ImdgA3U6lUeO211zBx4kR07dq1zv74+HjY29sjODhYuy06OhpSqRSJiYkYNGhQnWOSk5OhUCgQHR2t3ebr6wsvLy8kJCQgLCwMCQkJ8Pf3h6urq3ZMTEwMFi1ahNTUVHTv3h0JCQmIiorSOXdMTAyWLVum9+tUKpV6H9MSNHEYSjymgnkXB/Ouq5OLNVJyynA+pwTejhYt8hytnfOrxVUoKK+BTCpBVzdrk/1a870uDuZdHMy7OJj35qFP/gyqaFu/fj3MzMzw9NNP17s/Pz8fzs7OOtvMzMzg4OCAvLy82x4jl8thb6+7VMbFxUV7TH5+vk7BBkD7+E5jysrKUFVVBUtLy0a+SiApKanRY1uDocVjKph3cTDvas5mCgDAocQUOFZmtehztVbOj2dXAQC8bGU4e4pfZ77XxcG8i4N5Fwfz3npEK9p++OEHLFy4UPv4k08+wcaNG7Fz505IJBKxwmoVwcHBkMlkYocBpVKJpKQkg4nHVDDv4mDedYXnpuBIVjpqzB0RFtajRZ6jtXMeW5gKoAi9urgjLCykxZ/PUPG9Lg7mXRzMuziY9+ahyWNjiFa0DRgwAKGhodrHP/30EwoKCnD//fdrtymVSrz99tvYuHEj/vjjD7i6uqKwsFDnPLW1tSguLoabm1u9z+Pq6gqFQoGSkhKd2baCggLtMa6urkhMTNQ5TtNd8uYxt3aczM/Ph62trV6zbAAgk8kM6g1uaPGYCuZdHMy7mq+7HQAgo6CixfPRWjk/c7UUABDk7cCvMfheFwvzLg7mXRzMe+sRrWiztbWFra2t9vHo0aN1CjYAmDhxIoYPH46RI0cCAMLDw1FSUoLk5GQEBQUBAI4cOQKVSoWQkPr/qhoUFAS5XI64uDgMHjwYAJCeno7s7GyEhYUBAMLCwrBu3ToUFBTAxcUFAHD48GHY2trCz89PO+avv/7SOffhw4e15yAiMiZd3NQdJNtS239Nu//u7BxJRERtjMF0j3RycoK/v7/OP7lcDldXV3Tp0gWAuoFI37598eabbyIxMREnTpzAkiVLMHToUHh4eABQd58cMmSIdubMzs4Ojz32GFasWIEjR44gOTkZ8+bNQ3h4uLbgiomJgZ+fH2bPno2zZ88iNjYWq1evxlNPPQVzc3MAwNixY3H58mWsXLkSaWlp2Lx5M/bv349nnnmm1XNFRHS3ulxv+3+luAoVNbV3GG34iisUyLzeCbOHJztHEhFR22JQjUgaY9WqVViyZAkmTJgAqVSKBx98EPPnz9fuVygUyMjIQGXljTbW8+bNg1QqxfTp01FTU4OYmBid6+lkMhnWrVuHRYsWYcyYMbCyssKIESMwffp07Zj27dvjk08+wfLly7Fx40a0a9cOS5cuRd++fVvnhRMRNSNHa3M425ijsLwGGfnlRt8i/9QV9f3ZfJys4GAtv8NoIiIi42LQRdsff/xRZ5ujoyPefffd2x7j4+ODc+fO6WyzsLDAwoULdQq1W3l7e2P9+vUNxhMZGYndu3c3HDQRkZHo7GqDwvIapOcZf9F24/5sXBpJRERtj8EsjyQiotalWSKZnmf817XxptpERNSWsWgjIjJRXdzUzaAy8stEjuTuneJMGxERtWEs2oiITFRnzUybkXeQrFIokZqnLjw500ZERG0RizYiIhPlq2n7n1cOQRBEjqbpzl0thVIlwMXGHB72FmKHQ0RE1OxYtBERmagOLtaQSoDS6lrklVWLHU6T3Xx/NolEInI0REREzY9FGxGRibIwk8HHyRqAcTcjOZWtbvfPpZFERNRWsWgjIjJhXTRLJI34ujY2ISEioraORRsRkQnTNiPJM84OkkqVgLNXWbQREVHbxqKNiMiE3Wj7b5wzbel5ZahSqGBjLkMnFxuxwyEiImoRLNqIiEyYsd9gW7M0spunPaRSNiEhIqK2iUUbEZEJ01zTdqmwAgqlSuRo9HejCQmXRhIRUdvFoo2IyIR52FnCSi5DrUrA5cIKscPR240mJOwcSUREbReLNiIiEyaVSm5qRmJcSyQFQdC5RxsREVFbxaKNiMjEGWvb/6yiShRXKiCXSeDvYSd2OERERC2GRRsRkYnTNiPJN662/5pZtq7udjA3448zIiJqu/hTjojIxGna/qcZ2fJI3lSbiIhMBYs2IiITp7mmzdiWR56+3jmS17MREVFbx6KNiMjEaa5pyyutRmmVQuRoGo+dI4mIyFSwaCMiMnF2lnK42VkAMJ7ZtsLyGlwprgIAdPNkExIiImrbWLQREZHRtf3X3FS7k4s17CzlIkdDRETUsli0ERERfN00RZtxdJDk0kgiIjIlLNqIiOjGTJuRLI/kTbWJiMiUsGgjIiJ0cVW3/Te25ZFs909ERKaARRsREWk7SGbkl0MQBJGjaVh5da22YQqXRxIRkSlg0UZERGjvbA0zqQSVCqW2K6OhOnu1BIIAtLO31Ha9JCIiastYtBEREeQyKTq4WAMA0gy8GUlylqYJCZdGEhGRaWDRRkREAICu7urr2s7nGHrRdv16Nm8ujSQiItPAoo2IiAAAXd3VN6lONfSZtuudI4M400ZERCaCRRsREQEA/K7PtKUa8Exbda0S53NKAQBBnGkjIiITwaKNiIgA3FS0GfBMW8rVMtSqBDhZy+HpYCl2OERERK2CRRsREQEAfN1sIZEAheU1KCirFjuceiVfvz9bkLcDJBKJyNEQERG1DhZtREQEALAyl8HHyQoAcD7XMGfbtE1IeH82IiIyISzaiIhIy8/t+hJJQy3aNE1IvNmEhIiITAeLNiIi0urqcb2DpAEWbbVKFc5e0dyjjTNtRERkOli0ERGRlrYZiQEWbWl55aiuVcHWwgwdna3FDoeIiKjVsGgjIiItTdF2PrdU5Ejq0lzP1t3LHlIpm5AQEZHpYNFGRERamqItp6QaJVUKkaPRpe0cyaWRRERkYli0ERGRlr2lHB72FgAMb4nkqSzN9WxsQkJERKaFRRsREeno6n69GUmO4RRtKpWAUzfdo42IiMiUsGgjIiId2mYkeYZTtF0srEB5jRIWZlL4utmIHQ4REVGrYtFGREQ6tM1IcgynGYmmCUk3T3uYyfiji4iITAt/8hERkY6uBjjTpmlCwuvZiIjIFLFoIyIiHZqZtsxrlaioqRU5GjXNTBtvqk1ERKaIRRsREelwsbWAs405BAFIyy0XOxyoVAISM9VFW4gPizYiIjI9LNqIiKgOfw/1bNs5A7iu7UJBOUqramFhJkVAOzuxwyEiImp1LNqIiKiOwHbqa8fOXikRORJoZ9m6e9lDziYkRERkgvjTj4iI6gi8PqNlCDNtJzOLAAChPo6ixkFERCQWFm1ERFRHoKd6pu3MFfGLNl7PRkREpo5FGxER1eHvYQuJBMgvq0Z+WbVocdQqVTh1vd1/aHtH0eIgIiISE4s2IiKqw9rcDB2drQEA566KN9uWklOGKoUKdhZm6OxiI1ocREREYjKoom3OnDkICAjQ+Tdx4kSdMUVFRZg5cyZ69uyJiIgIzJs3D+XlDbekrq6uxuLFixEZGYnw8HC89NJLyM/P1xmTnZ2NSZMmITQ0FFFRUXj77bdRW6t7f6KjR49ixIgRCAoKwqBBg7Bz587meeFERAZI06nxjIjNSBKvX88W7OMAqVQiWhxERERiMqiiDQD69u2LQ4cOaf+99957OvtnzZqF1NRUbNiwAevWrcPx48exYMGCBs+5bNkyHDhwAKtXr8amTZuQm5uLadOmafcrlUpMnjwZCoUCW7ZswYoVK7Br1y6sWbNGO+by5cuYPHkyIiMj8f3332PChAmYP38+YmNjmzcBREQGQtNBUsyZtpPa69kcRYuBiIhIbAZXtJmbm8PNzU37z8HhxoXnaWlpiI2NxdKlSxEaGoqIiAjMnz8fe/fuRU5OTr3nKy0txY4dOzBnzhxERUUhKCgIy5YtQ3x8PBISEgAAhw4dQmpqKt555x1069YN/fv3x4wZM7B582bU1NQAALZs2QIfHx/MmTMHvr6+GDduHAYPHowvv/yypVNCRCSKbp7qmbazIhZtidrOkWxCQkREpstM7ABu9c8//yAqKgr29va499578fLLL8PJyQkAEB8fD3t7ewQHB2vHR0dHQyqVIjExEYMGDapzvuTkZCgUCkRHR2u3+fr6wsvLCwkJCQgLC0NCQgL8/f3h6uqqHRMTE4NFixYhNTUV3bt3R0JCAqKionTOHRMTg2XLlun9GpVKpd7HtARNHIYSj6lg3sXBvOvPz019DVlKTilqFLWQ6bk88W5zXq1Qamf5grzs+LVrJL7XxcG8i4N5Fwfz3jz0yZ9BFW19+/bFoEGD4OPjg8uXL+O9997D888/j61bt0ImkyE/Px/Ozs46x5iZmcHBwQF5eXn1njM/Px9yuRz29vY6211cXLTH5Ofn6xRsALSP7zSmrKwMVVVVsLS0bPTrTEpKavTY1mBo8ZgK5l0czHvjKQUBFjIJqmtV+OnvE/C2a9qPjKbmPKWgBrUqAQ4WUuRknEWuhNe06YPvdXEw7+Jg3sXBvLce0Yq2H374AQsXLtQ+Xr9+PYYOHap9rGlEMnDgQO3sW1sRHBwMmUwmdhhQKpVISkoymHhMBfMuDua9aQLi4pCYVQypkw/Cgtrpdezd5vxk3EUAhejZyQXh4eF6H2+q+F4XB/MuDuZdHMx789DksTFEK9oGDBiA0NBQ7WMPD486Y9q3bw8nJydcvHgRUVFRcHV1RWFhoc6Y2tpaFBcXw83Nrd7ncXV1hUKhQElJic5sW0FBgfYYV1dXJCYm6hyn6S5585hbO07m5+fD1tZWr1k2AJDJZAb1Bje0eEwF8y4O5l0/3TztkZhVjHM5Zfi/0Kblrak51zQhCWvvxK9ZE/C9Lg7mXRzMuziY99YjWiMSW1tbdOzYUfuvvsLn6tWrKCoq0hZO4eHhKCkpQXJysnbMkSNHoFKpEBISUu/zBAUFQS6XIy4uTrstPT0d2dnZCAsLAwCEhYUhJSUFBQUF2jGHDx+Gra0t/Pz8tGOOHDmic+7Dhw9rz0FE1BZ191L/setUduu3/T9x8RoAoFdHp1Z/biIiIkNiMN0jy8vL8fbbbyMhIQGZmZmIi4vDCy+8gI4dO6Jv374A1A1E+vbtizfffBOJiYk4ceIElixZgqFDh2pn6nJycjBkyBDtzJmdnR0ee+wxrFixAkeOHEFycjLmzZuH8PBwbcEVExMDPz8/zJ49G2fPnkVsbCxWr16Np556Cubm5gCAsWPH4vLly1i5ciXS0tKwefNm7N+/H88880yr54qIqLUEeauLtuSs4lZ93tySKmReq4REAoS2Z+dIIiIybQbTiEQmkyElJQW7d+9GaWkp3N3d0adPH8yYMUNbOAHAqlWrsGTJEkyYMAFSqRQPPvgg5s+fr92vUCiQkZGByspK7bZ58+ZBKpVi+vTpqKmpQUxMjM71dDKZDOvWrcOiRYswZswYWFlZYcSIEZg+fbp2TPv27fHJJ59g+fLl2LhxI9q1a4elS5dqC0oioraom6c9pBIgt7QauSVVcLfXbzl4U/17ST3LFuBhBztLeas8JxERkaEymKLN0tISn3/++R3HOTo64t13373tfh8fH5w7d05nm4WFBRYuXKhTqN3K29sb69evb/C5IyMjsXv37jvGSETUVlibm8HXzRbnc8uQnF2MAa1UtGmWRvbk0kgiIiLDWR5JRESGKdhbvTwxKbP1rmv791IRAKBXBxZtRERELNqIiKhBPa4XbcnZrXNdW3WtEknXO0dypo2IiIhFGxER3YFmpq21mpGcyi5BjVIFZxtzdHKxbpXnJCIiMmQs2oiIqEHdvewhkQBXiquQX1bd4s/3r+Z6tg6OkEgkLf58REREho5FGxERNcjWwgydXW0AtM5sG5uQEBER6WLRRkREdxTkpV4i2dI32RYE4UbRxiYkREREAFi0ERFRI2iuazt5uahFnycjvxy5pdUwl0kR1t6xRZ+LiIjIWLBoIyKiOwrr4AgAiL9cBEEQWux5jmYUap/PUi5rsechIiIyJizaiIjojoK9HWAmlSCvtBqZ1ypb7HmOpBcAAO7t7Nxiz0FERGRsWLQREdEdWcpl2vu1/XvpWos8hyAIOJqunmm7t4tLizwHERGRMWLRRkREjdLz+hJJTUv+5naxoAJXS6ogl0kQziYkREREWizaiIioUTTdHP+9VNQi5z+aoV4aGdbeEVbmvJ6NiIhIg0UbERE1iua+aWeulKCyRtns5z9yfWlkZGcujSQiIroZizYiImoULwdLtLO3RK1KQGJmUbOeW3092/UmJLyejYiISAeLNiIiahSJRIKeHR0BACeauRlJen45sourYC6Tap+DiIiI1Fi0ERFRo0V0VLfi13R5bC5/nssDANzT2RnW5mbNem4iIiJjx6KNiIgaLdpPvXTx2IVC1NSqmu28f6aoi7Z+/q7Ndk4iIqK2gkUbERE1mr+7HZxtzFFRo2y269qqFEpt58j+/u7Nck4iIqK2hEUbERE1mlQqQdT1RiFxaQXNcs5/MgpRpVChnb0l/D1sm+WcREREbQmLNiIi0kuUr7poO9xMRZtmaWR/fzdIJJJmOScREVFbwqKNiIj0oinaTly6hirF3d+v7eC5XABAP3+3uz4XERFRW8SijYiI9NLF1Qbt7C1RU6vC0Yy76yKZmluKtLxyyGUS9GUTEiIionqxaCMiIr1IJBLcH6ieFfvjTM5dnevnU+rj+/i5wt5SftexERERtUUs2oiISG8DAj0AAL+dyYUgCE0+z/7kKwCAIT3aNUtcREREbRGLNiIi0luMnysszKTIKqpESk5Zk85xubACyVklkEqAQd09mjlCIiKitoNFGxER6c3KXIbo6w1JfmviEsmfkq8CAO7p7AwXW4tmi42IiKitYdFGRERNMqi7eknjj4lX9D5WEATs+DcTADA02LNZ4yIiImprWLQREVGTPBTUDmZSCc5cKUFKTqlex57KLsHZq6Uwl0nxSKh3C0VIRETUNrBoIyKiJnGyMcd9Aeoukt8nZOl17PYT6lm2QT084GDNrpFEREQNYdFGRERNNjxMPUv2fUI2VKrGdZGsrFFi9/Uib1QvnxaLjYiIqK1g0UZERE02sJsH7CzNkHmtEn+m5DXqmJ3xmSiqUKC9sxX6dXVr4QiJiIiMH4s2IiJqMitzGcZEtAcAfPF3xh3Hq1QCPj+kHvdMdGfIpJIWjY+IiKgtYNFGRER3ZUJ0J0gkQOz5fJzOLmlw7J7EbKTnlcPOwgyjI7g0koiIqDFYtBER0V1p72ytbdu/8ueztx1XU6vCu7+kAACm3OcLO0s2ICEiImoMFm1ERHTXZj4YADOpBAfP5eHgudx6x3x0MBWXCivgZmeB//Tp1LoBEhERGTEWbUREdNc6u9pgfFRHAMDrOxKRV1qts/9oegHW/pEKAHjz/7rD2tys1WMkIiIyVizaiIioWcweHIgubjbIKanG+M+P4lJhBQDgr/N5eH7jcdSqBAwL9cKwEE+RIyUiIjIu/FMnERE1CytzGT6f0BuPr4vD2aulGPS/WDhbSpFbcRUA0LuTE94ZFQKJhB0jiYiI9MGZNiIiajadXW2w64Vo9PFzQa1KQG6FEmZSCSZEdcSmiZGwlMvEDpGIiMjocKaNiIiaVXtna2x+7l6k55bicHwyhkSHwdXOSuywiIiIjBaLNiIiahEdXaxxzdUcTtbmYodCRERk1Lg8koiIiIiIyICxaCMiIiIiIjJgLNqIiIiIiIgMGIs2IiIiIiIiA8aijYiIiIiIyICxaCMiIiIiIjJgLNqIiIiIiIgMGIs2IiIiIiIiA8aijYiIiIiIyIAZXNGWlpaGKVOmoFevXggLC8Njjz2G7Oxs7f7q6mosXrwYkZGRCA8Px0svvYT8/PwGzykIAt5//33ExMQgJCQEzzzzDC5cuKAzpqioCDNnzkTPnj0RERGBefPmoby8XGfM2bNn8eSTTyI4OBj9+/fH+vXrm+11ExERERER1cegirZLly7hySefRJcuXbBp0yb88MMPeOGFF2BhYaEds2zZMhw4cACrV6/Gpk2bkJubi2nTpjV43vXr12PTpk1YtGgRtm3bBisrK0ycOBHV1dXaMbNmzUJqaio2bNiAdevW4fjx41iwYIF2f1lZGSZOnAgvLy/s3LkTs2fPxtq1a7F169bmTwQREREREdF1ZmIHcLP//e9/6NevH2bPnq3d1qFDB+3npaWl2LFjB1atWoWoqCgA6iLu4YcfRkJCAsLCwuqcUxAEbNy4EVOnTsXAgQMBACtXrkR0dDR+++03DB06FGlpaYiNjcX27dsRHBwMAJg/fz4mTZqE2bNnw8PDAz/88AMUCgWWLVsGc3NzdO3aFWfOnMGGDRswZsyYFswKERERERGZMoMp2lQqFQ4ePIjnnnsOEydOxOnTp+Hj44PJkydri63k5GQoFApER0drj/P19YWXl9dti7bMzEzk5eXpHGNnZ4fQ0FDEx8dj6NChiI+Ph729vbZgA4Do6GhIpVIkJiZi0KBBSEhIQEREBMzNzbVjYmJisH79ehQXF8PBwaHRr1WpVOqTmhajicNQ4jEVzLs4mPfWx5yLg3kXB/MuDuZdHMx789AnfwZTtBUUFKCiogLr16/Hyy+/jFmzZiE2NhbTpk3Dxo0bcc899yA/Px9yuRz29vY6x7q4uCAvL6/e82q2u7i41DlGcy1cfn4+nJ2ddfabmZnBwcFBe3x+fj58fHx0xri6umr36VO0JSUlNXpsazC0eEwF8y4O5r31MefiYN7FwbyLg3kXB/PeekQr2n744QcsXLhQ+/iTTz4BADzwwAN45plnAADdunXDv//+iy1btuCee+4RI8xmJQgCAKB79+6QyWQiR6Ou7k+fPm0w8ZgK5l0czHvrY87FwbyLg3kXB/MuDua9eWjyqKkRGiJa0TZgwACEhoZqHzs7O8PMzAy+vr4643x9fXHixAkA6pkthUKBkpISndm2goICuLm51fs8mu0FBQVwd3fXOSYwMFB73sLCQp3jamtrUVxcrD3e1dW1TpdKzWPNjNudqFQqAMDp06cbNb61GFo8poJ5Fwfz3vqYc3Ew7+Jg3sXBvIuDeW8emhqhIaIVbba2trC1tdXZFhwcjIyMDJ1tFy5cgLe3NwAgKCgIcrkccXFxGDx4MAAgPT0d2dnZ9V7PBgA+Pj5wc3NDXFwcunXrBkDdCfLkyZN44oknAADh4eEoKSlBcnIygoKCAABHjhyBSqVCSEgIACAsLAyrV6+GQqGAXC4HABw+fBidO3du9NJIMzMzBAcHQyqVQiKRNOoYIiIiIiJqewRBgEqlgpnZnUsyg7mmDQAmTpyIV155Bb1790ZkZCRiY2Nx4MABbNy4EYC6gchjjz2GFStWwMHBAba2tli6dCnCw8N1irYhQ4Zg5syZGDRoECQSCZ5++ml8/PHH6NixI3x8fPD+++/D3d1d2+DE19cXffv2xZtvvonFixdDoVBgyZIlGDp0KDw8PAAAw4YNw4cffog33ngDzz//PM6fP4+NGzdi7ty5jX59UqlUp5EJERERERHRnUiExiyibEXbt2/Hp59+iqtXr6Jz58546aWXtMUVoL659ooVK7B3717U1NQgJiYGCxcu1FkeGRAQgOXLl2PkyJEA1FXsmjVrsG3bNpSUlKBXr15YuHAhOnfurD2mqKgIS5YswR9//AGpVIoHH3wQ8+fPh42NjXbM2bNn8dZbbyEpKQlOTk4YN24cJk2a1ApZISIiIiIiU2VwRRsRERERERHdIBU7ACIiIiIiIro9Fm1EREREREQGjEUbERERERGRAWPRRkREREREZMBYtBERERERERkwFm1EREREREQGjEWbCfj4448xduxYhIaGIiIiot4x2dnZmDRpEkJDQxEVFYW3334btbW1OmOOHj2KESNGICgoCIMGDcLOnTtbI/w2IyMjA1OnTkVkZCR69uyJJ554AkeOHNEZ05ivA+nv4MGDePzxxxESEoLevXvjhRde0NnPvLecmpoaDB8+HAEBAThz5ozOvrNnz+LJJ59EcHAw+vfvj/Xr14sUZduQmZmJefPmYcCAAQgJCcHAgQOxZs0a1NTU6Ixj3lvG5s2bMWDAAAQHB+Pxxx9HYmKi2CG1KZ988gkee+wxhIeHIyoqCi+88ALS09N1xlRXV2Px4sWIjIxEeHg4XnrpJeTn54sUcdvz6aefIiAgAP/973+125jz1sOizQQoFAoMGTIETzzxRL37lUolJk+eDIVCgS1btmDFihXYtWsX1qxZox1z+fJlTJ48GZGRkfj+++8xYcIEzJ8/H7Gxsa31MozelClToFQq8dVXX2Hnzp0IDAzElClTkJeXB6BxXwfS388//4zZs2dj5MiR+P777/Htt9/i//7v/7T7mfeWtXLlSri7u9fZXlZWhokTJ8LLyws7d+7E7NmzsXbtWmzdulWEKNuG9PR0CIKAt956C3v37sXcuXOxZcsW/O9//9OOYd5bxr59+7B8+XK8+OKL2LVrFwIDAzFx4kQUFBSIHVqb8c8//+Cpp57Ctm3bsGHDBtTW1mLixImoqKjQjlm2bBkOHDiA1atXY9OmTcjNzcW0adNEjLrtSExMxJYtWxAQEKCznTlvRQKZjB07dgi9evWqs/3gwYNCYGCgkJeXp932zTffCD179hSqq6sFQRCElStXCkOHDtU57uWXXxaeffbZlg26jSgoKBD8/f2FY8eOabeVlpYK/v7+wt9//y0IQuO+DqQfhUIh9O3bV9i2bdttxzDvLefgwYPCkCFDhPPnzwv+/v7C6dOntfs2b94s9O7dWyfH77zzjjB48GAxQm2z1q9fLwwYMED7mHlvGaNGjRIWL16sfaxUKoWYmBjhk08+ETGqtk3zc/Wff/4RBEEQSkpKhB49egj79+/XjklNTRX8/f2F+Ph4kaJsG8rKyoQHH3xQ+Pvvv4Vx48YJS5cuFQSBOW9tnGkjJCQkwN/fH66urtptMTExKCsrQ2pqqnZMVFSUznExMTFISEhozVCNlpOTEzp37ozdu3ejoqICtbW12Lp1K1xcXNCjRw8Ajfs6kH5Onz6NnJwcSKVSPProo4iJicFzzz2HlJQU7RjmvWXk5+fjzTffxMqVK2FpaVlnf0JCAiIiImBubq7dFhMTg4yMDBQXF7dmqG1aaWkpHBwctI+Z9+ZXU1ODU6dOITo6WrtNKpUiOjoa8fHxIkbWtpWWlgKA9v2dnJwMhUKh83Xw9fWFl5cXf1e5S2+99Rb69++vk1uAOW9tLNoI+fn5Or+wAtA+1izdu92YsrIyVFVVtU6gRkwikeDLL7/E6dOn0bNnT4SEhGDDhg347LPPtD9wGvN1IP1cvnwZALB27VpMnToV69atg4ODA8aPH4+ioiIAzHtLEAQBc+bMwdixYxEcHFzvmIbyzushmsfFixfx9ddfY+zYsdptzHvzu3btGpRKJVxcXHS2u7i4MKctRKVSYdmyZejZsyf8/f0BqN+/crkc9vb2OmNdXFz4vfwu7N27F6dPn8bMmTPr7GPOW5eZ2AFQ06xateqOF4/v27cPvr6+rRSRaWrs16FLly5YvHgxXFxcsHnzZlhaWuK7777DlClTsH379nqv+aHba2zeVSoVAPX1hIMHDwYALF++HP369cNPP/2k88ss3Vlj8/7333+jvLwckydPbqXI2ramfL/PycnBc889hyFDhmD06NEtHSJRq1q8eDHOnz+Pb775RuxQ2rQrV67gv//9L7744gtYWFiIHY7JY9FmpJ599lmMGDGiwTHt27dv1LlcXV3rdLnS/HXQzc1NO+bWvxjm5+fD1ta23qVPpqKxX4cjR47g4MGDOHbsGGxtbQEAPXr0wOHDh7F7925MmjSpUV8HUmts3jV/6bv5l1lzc3O0b98eV65cAdC49z+p6fN+T0hIqDPL9thjj2HYsGF4++23b/s9BUCdmSBTp+/3+5ycHDz99NMIDw/HkiVLdMYx783PyckJMpmsTtORgoIC5rQFvPXWWzh48CC+/vprtGvXTrvd1dUVCoUCJSUlOjM/BQUF/F7eRKdOnUJBQQFGjhyp3aZUKnHs2DFs3rwZn3/+OXPeili0GSlnZ2c4Ozs3y7nCwsKwbt06FBQUaJd3HD58GLa2tvDz89OO+euvv3SOO3z4MMLCwpolBmPV2K9DZWUlAPUyyZtJJBLtbFBjvg6k1ti8BwUFwdzcHBkZGdrbXSgUCmRlZcHLywsA866PxuZ9/vz5ePnll7WPc3NzMXHiRPzvf/9DaGgoAHXeV69eDYVCAblcDkCd986dO+tcg0X6fb/XFGw9evTA8uXLIZXqXgXBvDc/c3Nz9OjRA3FxcRg4cCAA9fK9uLg4jBs3TuTo2g5BELBkyRL8+uuv2LRpU50/TAcFBUEulyMuLk67siI9PR3Z2dkm/7tKU917773Ys2ePzra5c+eiS5cueP755+Hp6cmctyIWbSYgOzsbxcXFyM7OhlKp1N4rqUOHDrCxsUFMTAz8/Pwwe/ZsvPbaa8jLy8Pq1avx1FNPaS9WHzt2LDZv3oyVK1fisccew5EjR7B//3588sknYr40oxEWFgZ7e3vMmTMHL774IiwsLLBt2zZkZWXhvvvuA4BGfR1IP7a2thg7diw++OADeHp6wsvLC59//jkAYMiQIQCY95agKYg1rK2tAai/52j+Mj5s2DB8+OGHeOONN/D888/j/Pnz2LhxI+bOndvq8bYVOTk5GD9+PLy8vPD666+jsLBQu0/zV2/mvWX85z//weuvv46goCCEhITgq6++QmVlpc4MBd2dxYsX48cff8RHH30EGxsb7UoKOzs7WFpaws7ODo899hhWrFgBBwcH2NraYunSpQgPD2cB0US2trbaawY1rK2t4ejoqN3OnLceiSAIgthBUMuaM2cOdu3aVWf7xo0bERkZCQDIysrCokWL8M8//8DKygojRozAzJkzYWZ2o64/evQoli9fjtTUVLRr1w4vvPACfyDpISkpCatXr9Z2W+ratSteeOEF9O/fXzumMV8H0o9CocB7772H77//HlVVVQgNDcW8efPQtWtX7RjmvWVlZmbigQcewO7du9GtWzft9rNnz+Ktt95CUlISnJycMG7cOEyaNEnESI3bzp07b1t8nTt3Tvs5894yvv76a3z++efIy8tDt27dMH/+fO3MMt29W+8PprF8+XLt7yLV1dVYsWIF9u7di5qaGsTExGDhwoVcqteMxo8fj8DAQLzxxhsAmPPWxKKNiIiIiIjIgLHlPxERERERkQFj0UZERERERGTAWLQREREREREZMBZtREREREREBoxFGxERERERkQFj0UZERERERGTAWLQREREREREZMBZtREREREREBoxFGxERUQvKzMxEQEAAzpw5I3YoDXrttdewbt26Vnmu0aNH4+eff26V5yIiagtYtBERUauZM2cOAgICEBAQgB49emDAgAFYuXIlqqurxQ6tjpqaGkRGRuLTTz+td/+HH36I6OhoKBQKvc579OhRBAQEoKSkpDnCbBZnz57FX3/9hfHjxzf5HD///DO6deuGnJycevc/+OCDWL58OQBg6tSpePfdd6FSqZr8fEREpoRFGxERtaq+ffvi0KFD+O233zBv3jxs3boVa9asETusOszNzfHII49gx44ddfYJgoBdu3Zh+PDhkMvlIkTXvDZt2oTBgwfDxsamyecYMGAAHB0dsWvXrjr7jh07hosXL2LUqFEAgH79+qG8vBx//fVXk5+PiMiUsGgjIqJWZW5uDjc3N3h6emLgwIGIjo7G4cOHtfuvXbuGV199FX379kVoaCiGDRuGH3/8Uecc48ePx5IlS/Df//4XvXv3RnR0NLZt24aKigrMnTsX4eHhGDRoEP7880/tMZoZroMHD2LYsGEIDg7G6NGjkZKScttYR40ahQsXLuD48eM62//55x9cvnwZo0aNgkqlwtq1a9GvXz8EBQVh+PDhty1GMjMz8fTTTwMAevfujYCAAMyZMwcA8Ndff+GJJ55AREQEIiMjMXnyZFy6dEnn+H///RfDhw9HcHAwRo4cid9++63O0suUlBQ899xzCA8PR3R0NF577TUUFhbe9jUqlUr8/PPPGDBggM72AQMG4KOPPsLs2bMRHh6O+++/H7///jsKCwsxdepUhIeHY9iwYUhKSgIAyOVyDB8+vN6ibceOHQgNDUXXrl0BADKZDP369cPevXtvGxcREd3Aoo2IiESTkpKC+Ph4ndmqmpoa9OjRA59++il+/PFHjB49GrNnz0ZiYqLOsbt27YKTkxO+++47jBs3DosWLcKMGTMQHh6OXbt2oU+fPpg9ezYqKyt1jlu5ciXmzJmD7du3w9nZGVOmTLntEseAgAAEBwfXmW3buXMnwsPD4evri40bN2LDhg14/fXX8cMPPyAmJgYvvPACLly4UOd8np6e+OCDDwAAP/30Ew4dOoQ33ngDAFBZWYn//Oc/2LFjB7788ktIJBK8+OKL2iWEZWVlmDp1Kvz9/bFr1y7MmDED77zzjs75S0pKMGHCBHTv3h3bt2/HZ599hoKCArz88su3/RqcO3cOpaWlCAoKqrPvq6++Qs+ePbFr1y70798fs2fPxuzZs/HII49g586d6NChA15//XUIggDgRpF77P/bubuQJts/DuDfbeJbMzVfdmCyTcX5gqGiSElFFDlNM9qKiBRsiZl1kPYqFYE2jQzJAw16oaKoCCUKmtJBgpBIOSuIdDU1DxLTZYv5gqH+D8L76W7q3+fJJ63n+wHh5r52/e5rlwfjy31d17NnQo2hoSE0NDQIb9mmrFixAq2trTOOi4iI/sLQRkREv1RjYyPi4uIQExODjIwM2Gw2GAwGoV2hUMBgMCAyMhLBwcHIysrC6tWrYTKZRHUiIiKwb98+qFQq5OXlwc3NDb6+vti+fTtUKhUKCgrw+fNndHR0iPrt378fycnJ0Gg0KC8vh81mw+PHj2ccr16vR319PYaGhgB8C08NDQ3Q6XQAgCtXriA3NxebNm1CSEgIDh8+jIiICFy/ft2plkwmg7e3NwDAz88PAQEB8PLyAgCkpKRg48aNUCqViIyMhNFohMViwbt37wAADx8+BACUlpYiLCwMa9euxZ49e0T1b968iaioKBQWFiI0NBRRUVEwGo1oaWlBV1fXtN/vw4cPkMlk8PPzc2pbs2YNduzYIcynw+FATEwMUlNToVarkZubC6vVioGBAQBAWFgYYmNjRSHXZDJhcnISaWlpotqBgYHo7e3lvjYiojlwWegBEBHRf0tSUhJOnz6NkZERXLt2DTKZDCkpKUL7+Pg4Ll68iPr6evT19eHr168YGxuDu7u7qI5GoxGuZTIZfHx8EB4eLtzz9/cHANhsNlG/2NhY4drHxwdqtRqdnZ0zjjc9PR1lZWUwmUzQ6/UwmUyQSCRIS0uDw+HAx48fER8fL+oTHx+P9vb2uU8KgO7ublRVVeHly5cYHBwU3l719vYiPDwcXV1d0Gg0cHNzE/rExMSIarS3t6OlpQVxcXFO9Xt6eqBWq53uj46OwtXVFRKJxKnt+zmems/v53gq6NlsNgQEBAAAdDodysrKcOLECcjlctTW1kKr1UIul4tqu7u7Y2JiYtr/LRERiTG0ERHRL+Xh4QGlUgkAMBqNyMzMxL1797Bt2zYA395c3bhxA8XFxdBoNPDw8IDRaHRawujiIv4Jk0gkontTIWQq/PxTcrkcKSkpqKurg16vR21tLVJTU7FkyRI4HI6fqv29vXv3IigoCKWlpQgMDMTExATS09P/1umUw8PDWLduHQ4dOuTUNhWqfuTr64uRkRGMjY3B1dVV1DbdfH6/lHW6OU5LSxNCbmJiIsxmM4qKipyea7fb4enpycBGRDQHXB5JREQLRiqVIi8vDxcuXMDo6CiAb4dtrF+/HpmZmYiIiEBwcPC0+8P+qRcvXgjXdrsd3d3dCAkJmbWPXq9Ha2srnjx5gra2NmF/llwuR2BgIMxms+jzZrMZYWFh09aaCj3j4+PCvcHBQXR1dSE/Px8rV65EaGgo7Ha7qJ9arYbFYsHY2Jhwb+oQkCnR0dF4+/YtgoKCoFQqRX+enp7TjicyMhIAYLVaZ52DuZLL5dBqtaitrUVdXR1UKhUSEhKcPmexWIRnExHR7BjaiIhoQWm1WkilUty6dQsAoFQq8fTpU5jNZlitVpw6dUrYMzUfqqur0dzcDIvFgmPHjsHX1xcbNmyYtU9iYiKUSiWOHj2KkJAQ0XJIg8GAS5cu4dGjR+js7ERFRQXa29uFUyJ/FBQUBIlEgsbGRnz69AlDQ0Pw9vaGj48P7t69i/fv36O5uRnl5eWifhkZGZicnMTJkydhtVrR1NSEq1evAvjrjdfOnTtht9tRWFiIV69eoaenB01NTTh+/LgoJH5v2bJliI6OntdDQXQ6Hdra2nDnzh1h79+PWltbkZycPG/PJCL6kzG0ERHRgnJxccGuXbtw+fJlDA8PIz8/H1FRUTAYDMjKyoK/v///DVV/R1FREc6cOYOtW7diYGAANTU1TssCfySRSKDT6WC3251CSHZ2NnJyclBeXo7NmzejqakJ1dXVUKlU09ZSKBQ4cOAAzp8/j1WrVqGkpARSqRSVlZV4/fq1sIfuyJEjon5yuRw1NTV48+YNMjMzUVlZiYKCAgAQxq9QKHD79m1MTEzAYDAgIyMDRqMRXl5ekEpn/snX6/XCQSfzISEhAWq1Gg6HA1u2bHFq7+vrQ1tb24yBjoiIxCSTP7vYn4iI6DfQ0tKC7OxsPHv2DEuXLl3o4cyLBw8eoLi4GM+fP/+pvWGjo6PQarWorKyc9hCT+Xbu3Dl8+fIFJSUl//qziIj+BDyIhIiI6Ddx//59LF++HAqFAh0dHaioqIBWq/3pwzzc3d1x9uxZDA4OztNIZ+fn54ecnJxf8iwioj8BQxsREdFvor+/H1VVVejv70dAQAC0Wi0OHjw4L7WTkpLmpc5c7N69+5c9i4joT8DlkURERERERIsYDyIhIiIiIiJaxBjaiIiIiIiIFjGGNiIiIiIiokWMoY2IiIiIiGgRY2gjIiIiIiJaxBjaiIiIiIiIFjGGNiIiIiIiokWMoY2IiIiIiGgR+x8+Kc4NaTLaqQAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_iv_curves_ramp([Ca_T(v_rest_global=-80)],\n", + " v_start=-100,\n", + " v_end=50,\n", + " v_step_increase = 0.05,\n", + " measurements_per_step = 1,\n", + " title_str = \"I-V curve for Transient Calcium Channel\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import jax.numpy as jnp\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from matplotlib.ticker import ScalarFormatter, FormatStrFormatter\n", + "from typing import List\n", + "\n", + "import jaxley as jx\n", + "\n", + "def plot_iv_curves(channels: List[jx.channels], \n", + " v_holding: float,\n", + " v_step_values: List[float],\n", + " dt: float = 0.5,\n", + " title_str: str = None) -> None:\n", + " \"\"\"\n", + " Plot I-V curves for a list of channels by setting a holding voltage and\n", + " then applying a step voltage. The maximum current is recorded and plotted.\n", + " \n", + " channels: List[jx.channels] - List of channels to plot I-V curves for\n", + " v_holding: float - Holding voltage in mV\n", + " v_step_values: List[float] - List of step voltage values\n", + " dt: float - Time step of the simulation in ms\n", + " title_str: str - Title of the figure\n", + " \"\"\"\n", + " \n", + " # Define constants\n", + " v_step_on_time = 500\n", + " v_step_duration = 2000\n", + " total_time = 5000\n", + " padding_time = 10\n", + " \n", + " # Calculate the padding steps\n", + " padding_steps = int(padding_time / dt)\n", + "\n", + " # Calculate the total time with padding\n", + " total_time_pad = total_time + 2 * padding_time\n", + "\n", + " # Create the time vector\n", + " time_steps = int(total_time_pad / dt)\n", + "\n", + " # Initialize the cell and its components\n", + " compartment = jx.Compartment()\n", + " branch = jx.Branch(compartment, nseg=1)\n", + " cell = jx.Cell(branch, parents=[-1])\n", + "\n", + " # Set the parameters of the cell\n", + " params = {\n", + " \"length\": 5.,\n", + " \"radius\": 2.5,\n", + " \"capacitance\": 10,\n", + " \"v\": v_holding\n", + " }\n", + "\n", + " # Set the parameters of the cell\n", + " for name, param in params.items():\n", + " cell.set(name, param)\n", + " \n", + " # Initialize the variables to record, always record the membrane potential\n", + " to_records = ['v']\n", + " # Insert the channels and initialize their states\n", + " for channel in channels:\n", + " # Insert the channel and initialize its states\n", + " cell.insert(channel)\n", + " cell.init_states()\n", + "\n", + " # Get the prefix of the channel\n", + " prefix = channel._name\n", + "\n", + " # Collect the current names to record. Don't record the\n", + " # CaPump and CaNernstReversal\n", + " if (prefix != 'CaPump') and (prefix != 'CaNernstReversal'):\n", + " # Get the current name and states of the channel\n", + " current_name = channel.current_name\n", + " # Which variables to record\n", + " to_records += [current_name]\n", + " \n", + " # Initialize the array to store the maximum currents\n", + " max_currents = np.zeros((len(channels), len(v_step_values)))\n", + "\n", + " # Loop over all the step voltage values\n", + " for idx_v_step, v_step_value in enumerate(v_step_values):\n", + "\n", + " # Create step voltage array, add the padding and apply the step voltage\n", + " v = jnp.zeros(time_steps) + v_holding\n", + " v_step_on = int(v_step_on_time / dt)\n", + " v_step_off = int((v_step_on_time + v_step_duration) / dt)\n", + " v = v.at[v_step_on:v_step_off].set(v_step_value)\n", + " v = jnp.pad(v, (padding_steps, padding_steps), 'edge')\n", + "\n", + " # Delete recordings and stimuli\n", + " cell.delete_recordings()\n", + " cell.delete_stimuli()\n", + "\n", + " # Apply voltage clamp\n", + " cell.clamp('v', v, False)\n", + "\n", + " # Record variables\n", + " for rec in to_records:\n", + " cell.record(rec, verbose=False) # Deactivate verbose\n", + "\n", + " # Integrate the cell model\n", + " s = jx.integrate(cell, delta_t=dt, t_max=total_time_pad)\n", + " s = prettify(s, to_records, dt) \n", + "\n", + " # Remove padding for plotting and adjust time array, watch out for the indexing\n", + " s_pad = {}\n", + " s_pad['time'] = s['time'][padding_steps+1:-padding_steps] - padding_time\n", + " for rec in to_records:\n", + " s_pad[rec] = s[rec][padding_steps+1:-padding_steps]\n", + "\n", + " # Adjust the step onset index for the padding\n", + " step_onset_index = v_step_on - padding_steps\n", + " step_offset_index = v_step_off - padding_steps\n", + "\n", + " # Get the maximum current for each channel, exclude the first record which is the membrane potential\n", + " for i, rec in enumerate(to_records[1:]):\n", + " if 'i' in rec:\n", + " # Find the index of the maximum current. Ensure that the maximum current is identified\n", + " # only after the step voltage is applied, and not during the initial holding phase.\n", + " max_current_index = np.argmax(np.abs(s_pad[rec][step_onset_index:step_offset_index])) + step_onset_index\n", + " \n", + " # Convert nA to pA by multiplying with 1e3\n", + " s_pad[rec] = s_pad[rec] * 1e3\n", + " \n", + " # Find the maximum current\n", + " max_current = s_pad[rec][max_current_index]\n", + " \n", + " # Append the maximum current to the array\n", + " max_currents[i, idx_v_step] = max_current\n", + "\n", + " # Create a single figure and axes for all conditions\n", + " if len(channels) == 1:\n", + " fig, ax = plt.subplots(1, 1, figsize=(10, 5))\n", + " ax = [ax] # Make it iterable\n", + " else:\n", + " fig, ax = plt.subplots(1, len(channels), figsize=(10, 5*len(channels)))\n", + "\n", + " # Loop over all the channels\n", + " for idx_channel, channel in enumerate(channels):\n", + " # Find the indices where the current changes sign\n", + " sign_changes = np.where(np.diff(np.sign(max_currents[idx_channel,:])))[0]\n", + " equilibrium_potential = None\n", + "\n", + " # If there are sign changes, calculate the equilibrium potential\n", + " if len(sign_changes) > 0:\n", + " # The equilibrium potential is the average of the two holding voltages where the current changes sign\n", + " equilibrium_potential = (v_step_values[sign_changes[0]] + v_step_values[sign_changes[0] + 1]) / 2\n", + "\n", + " # Plot the I-V curve for the current channel\n", + " ax[idx_channel].plot(v_step_values, max_currents[idx_channel, :], marker='o', linestyle='-', label=f'Max {current_name}')\n", + " if equilibrium_potential is not None:\n", + " ax[idx_channel].axvline(equilibrium_potential, color='r', linestyle='--', label=f'Equilibrium: {equilibrium_potential:.2f} mV')\n", + " ax[idx_channel].set_xlabel('Step Voltage (mV)')\n", + " ax[idx_channel].set_ylabel('Maximum Current (pA)')\n", + " if len(channels) > 1:\n", + " ax[idx_channel].legend()\n", + " if title_str is not None:\n", + " ax[idx_channel].set_title(f'{title_str}')\n", + " else:\n", + " ax[idx_channel].set_title(f'I-V Curve for Max {current_name}', fontsize=16)\n", + " \n", + " # Ensure y-axis does not use scientific notation\n", + " ax[idx_channel].yaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=False))\n", + " ax[idx_channel].xaxis.set_major_formatter(ScalarFormatter(useOffset=False, useMathText=False))\n", + " ax[idx_channel].yaxis.set_major_formatter(FormatStrFormatter('%.3f'))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot an I-V curve for the K_IR channel\n", + "plot_iv_curves(channels = [K_IR(v_rest_global=-60)],\n", + " v_holding= -60,\n", + " v_step_values = np.arange(-120, -71, 3), \n", + " dt = 0.5,\n", + " title_str = 'I-V curve for Potassium Inward Rectifying Channel')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "jaxley_env_edit_linux", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.7" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}