From 7e33f3a5019380acde412275d3b3bbcd2c33593a Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Fri, 13 Feb 2026 19:12:46 +0100
Subject: [PATCH 01/14] intial implementation

---
 bluecellulab/circuit/config/definition.py     |  14 +-
 bluecellulab/circuit/config/sections.py       | 105 ++-
 .../config/sonata_simulation_config.py        |  59 +-
 bluecellulab/circuit_simulation.py            | 409 ++++++----
 bluecellulab/simulation/modifications.py      | 476 +++++++++++
 bluecellulab/simulation/neuron_globals.py     |  47 +-
 .../simulation_config_modifications.json      |  45 ++
 .../sonata-modifications.ipynb                | 334 ++++++++
 pyproject.toml                                |   1 +
 .../simulation_config_modifications.json      |  38 +
 tests/test_circuit/test_simulation_config.py  | 200 +++--
 tests/test_simulation/test_modifications.py   | 736 ++++++++++++++++++
 tests/test_simulation/test_neuron_globals.py  |  32 +-
 13 files changed, 2253 insertions(+), 243 deletions(-)
 create mode 100644 bluecellulab/simulation/modifications.py
 create mode 100644 examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json
 create mode 100644 examples/2-sonata-network/sonata-modifications.ipynb
 create mode 100644 tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json
 create mode 100644 tests/test_simulation/test_modifications.py

diff --git a/bluecellulab/circuit/config/definition.py b/bluecellulab/circuit/config/definition.py
index a096cfb4..014b0184 100644
--- a/bluecellulab/circuit/config/definition.py
+++ b/bluecellulab/circuit/config/definition.py
@@ -17,7 +17,11 @@
 from typing import Optional, Protocol
 
 
-from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
+from bluecellulab.circuit.config.sections import (
+    Conditions,
+    ConnectionOverrides,
+    ModificationBase,
+)
 from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
@@ -36,6 +40,9 @@ def condition_parameters(self) -> Conditions:
     def connection_entries(self) -> list[ConnectionOverrides]:
         raise NotImplementedError
 
+    def get_modifications(self) -> list[ModificationBase]:
+        raise NotImplementedError
+
     def get_compartment_sets(self) -> dict[str, dict]:
         """Return SONATA-style compartment_sets mapping."""
         raise NotImplementedError
@@ -108,8 +115,5 @@ def output_root_path(self) -> str:
     def extracellular_calcium(self) -> Optional[float]:
         raise NotImplementedError
 
-    def add_connection_override(
-        self,
-        connection_override: ConnectionOverrides
-    ) -> None:
+    def add_connection_override(self, connection_override: ConnectionOverrides) -> None:
         raise NotImplementedError
diff --git a/bluecellulab/circuit/config/sections.py b/bluecellulab/circuit/config/sections.py
index 15bfad4e..c5afa4d6 100644
--- a/bluecellulab/circuit/config/sections.py
+++ b/bluecellulab/circuit/config/sections.py
@@ -14,7 +14,7 @@
 """Classes to represent config sections."""
 
 from __future__ import annotations
-from typing import Literal, Optional
+from typing import Any, Literal, Optional
 
 from pydantic import field_validator, Field
 from pydantic.dataclasses import dataclass
@@ -29,6 +29,7 @@
     from libsonata._libsonata import Conditions as LibSonataConditions
 except ImportError:
     from libsonata._libsonata import SimulationConfig
+
     LibSonataConditions = SimulationConfig.Conditions
 
 
@@ -44,6 +45,7 @@ def string_to_bool(value: str) -> bool:
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class ConditionEntry:
     """For mechanism specific conditions."""
+
     minis_single_vesicle: Optional[int] = Field(None, ge=0, le=1)
     init_depleted: Optional[int] = Field(None, ge=0, le=1)
 
@@ -51,6 +53,7 @@ class ConditionEntry:
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class MechanismConditions:
     """For mechanism specific conditions."""
+
     ampanmda: Optional[ConditionEntry] = None
     gabaab: Optional[ConditionEntry] = None
     glusynapse: Optional[ConditionEntry] = None
@@ -59,6 +62,7 @@ class MechanismConditions:
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class Conditions:
     mech_conditions: Optional[MechanismConditions] = None
+    mechanisms: Optional[dict[str, dict[str, Any]]] = None
     celsius: Optional[float] = None
     v_init: Optional[float] = None
     extracellular_calcium: Optional[float] = None
@@ -80,6 +84,7 @@ def from_blueconfig(cls, condition_entries: dict) -> Conditions:
         )
         return cls(
             mech_conditions=mech_conditions,
+            mechanisms=None,
             extracellular_calcium=condition_entries.get("cao_CR_GluSynapse", None),
             randomize_gaba_rise_time=randomize_gaba_risetime,
         )
@@ -111,8 +116,14 @@ def from_sonata(cls, condition_entries: LibSonataConditions) -> Conditions:
             glusynapse=ConditionEntry(msv_glusynapse, init_dep_glusynapse),
         )
 
+        # Store the full generic mechanisms dict from libsonata
+        generic_mechanisms = None
+        if mech_dict is not None:
+            generic_mechanisms = dict(mech_dict)
+
         return cls(
             mech_conditions=mech_conditions,
+            mechanisms=generic_mechanisms,
             celsius=condition_entries.celsius,
             v_init=condition_entries.v_init,
             extracellular_calcium=condition_entries.extracellular_calcium,
@@ -125,6 +136,7 @@ def init_empty(cls) -> Conditions:
         specified."""
         return cls(
             mech_conditions=None,
+            mechanisms=None,
             celsius=None,
             v_init=None,
             extracellular_calcium=None,
@@ -132,6 +144,94 @@ def init_empty(cls) -> Conditions:
         )
 
 
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationBase:
+    """Base class for all modification types."""
+
+    name: str
+    type: str
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationNodeSet(ModificationBase):
+    """Modification that targets a node_set."""
+
+    node_set: str
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationTTX(ModificationNodeSet):
+    """TTX modification — blocks Na channels on all sections of target cells."""
+
+    pass
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationConfigureAllSections(ModificationNodeSet):
+    """Applies section_configure to all sections of target cells."""
+
+    section_configure: str
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationSectionList(ModificationNodeSet):
+    """Applies section_configure to a named section list of target cells."""
+
+    section_configure: str
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationSection(ModificationNodeSet):
+    """Applies section_configure to specific named sections of target cells."""
+
+    section_configure: str
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class ModificationCompartmentSet(ModificationBase):
+    """Applies section_configure to segments in a compartment set."""
+
+    compartment_set: str
+    section_configure: str
+
+
+def modification_from_libsonata(mod) -> ModificationBase:
+    """Convert a libsonata modification object to a BlueCelluLab dataclass."""
+    type_name = mod.type.name  # e.g. "ttx", "configure_all_sections", etc.
+    if type_name == "ttx":
+        return ModificationTTX(name=mod.name, type=type_name, node_set=mod.node_set)
+    elif type_name == "configure_all_sections":
+        return ModificationConfigureAllSections(
+            name=mod.name,
+            type=type_name,
+            node_set=mod.node_set,
+            section_configure=mod.section_configure,
+        )
+    elif type_name == "section_list":
+        return ModificationSectionList(
+            name=mod.name,
+            type=type_name,
+            node_set=mod.node_set,
+            section_configure=mod.section_configure,
+        )
+    elif type_name == "section":
+        return ModificationSection(
+            name=mod.name,
+            type=type_name,
+            node_set=mod.node_set,
+            section_configure=mod.section_configure,
+        )
+    elif type_name == "compartment_set":
+        return ModificationCompartmentSet(
+            name=mod.name,
+            type=type_name,
+            compartment_set=mod.compartment_set,
+            section_configure=mod.section_configure,
+        )
+    else:
+        raise ValueError(f"Unknown modification type: {type_name}")
+
+
 @dataclass(frozen=True, config=dict(extra="forbid"))
 class ConnectionOverrides:
     source: str
@@ -148,8 +248,7 @@ class ConnectionOverrides:
     def validate_mod_override(cls, value):
         """Make sure the mod file to override is present."""
         if isinstance(value, str) and not hasattr(neuron.h, value):
-            raise bluecellulab.ConfigError(
-                f"Mod file for {value} is not found.")
+            raise bluecellulab.ConfigError(f"Mod file for {value} is not found.")
         return value
 
     @classmethod
diff --git a/bluecellulab/circuit/config/sonata_simulation_config.py b/bluecellulab/circuit/config/sonata_simulation_config.py
index 797aec45..2141b136 100644
--- a/bluecellulab/circuit/config/sonata_simulation_config.py
+++ b/bluecellulab/circuit/config/sonata_simulation_config.py
@@ -19,7 +19,12 @@
 from typing import Optional
 import warnings
 
-from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
+from bluecellulab.circuit.config.sections import (
+    Conditions,
+    ConnectionOverrides,
+    ModificationBase,
+    modification_from_libsonata,
+)
 from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 from bluepysnap import Simulation as SnapSimulation
@@ -66,33 +71,49 @@ def get_all_stimuli_entries(self) -> list[Stimulus]:
         for value in inputs.values():
             # Validate mutual exclusivity and existence of compartment_set
             if "compartment_set" in value and "node_set" in value:
-                raise ValueError("Stimulus entry must not include both 'node_set' and 'compartment_set'.")
+                raise ValueError(
+                    "Stimulus entry must not include both 'node_set' and 'compartment_set'."
+                )
 
             if "compartment_set" in value:
                 if compartment_sets is None:
-                    raise ValueError("SONATA simulation config references 'compartment_set' in inputs but no 'compartment_sets_file' is configured.")
+                    raise ValueError(
+                        "SONATA simulation config references 'compartment_set' in inputs but no 'compartment_sets_file' is configured."
+                    )
                 comp_name = value["compartment_set"]
                 if comp_name not in compartment_sets:
-                    raise ValueError(f"Compartment set '{comp_name}' not found in compartment_sets file.")
+                    raise ValueError(
+                        f"Compartment set '{comp_name}' not found in compartment_sets file."
+                    )
                 # Validate the list: must be list of triples, sorted and unique by (node_id, sec_ref, seg)
                 comp_entry = compartment_sets[comp_name]
                 comp_nodes = comp_entry.get("compartment_set")
                 if comp_nodes is None:
-                    raise ValueError(f"Compartment set '{comp_name}' does not contain 'compartment_set' key.")
+                    raise ValueError(
+                        f"Compartment set '{comp_name}' does not contain 'compartment_set' key."
+                    )
                 # Validate duplicates and sorted order
                 try:
                     last = None
                     for trip in comp_nodes:
                         if not (isinstance(trip, list) and len(trip) >= 3):
-                            raise ValueError(f"Invalid compartment_set entry '{trip}' in '{comp_name}'; expected [node_id, section, seg].")
+                            raise ValueError(
+                                f"Invalid compartment_set entry '{trip}' in '{comp_name}'; expected [node_id, section, seg]."
+                            )
                         key = (trip[0], trip[1], trip[2])
                         if last is not None and key < last:
-                            raise ValueError(f"Compartment list for '{comp_name}' must be sorted ascending.")
+                            raise ValueError(
+                                f"Compartment list for '{comp_name}' must be sorted ascending."
+                            )
                         if last == key:
-                            raise ValueError(f"Compartment list for '{comp_name}' contains duplicate entry {key}.")
+                            raise ValueError(
+                                f"Compartment list for '{comp_name}' contains duplicate entry {key}."
+                            )
                         last = key
                 except TypeError:
-                    raise ValueError(f"Compartment list for '{comp_name}' contains non-comparable entries.")
+                    raise ValueError(
+                        f"Compartment list for '{comp_name}' contains non-comparable entries."
+                    )
 
             stimulus = Stimulus.from_sonata(value, config_dir=config_dir)
             if stimulus:
@@ -105,6 +126,12 @@ def condition_parameters(self) -> Conditions:
         condition_object = self.impl.conditions
         return Conditions.from_sonata(condition_object)
 
+    @lru_cache(maxsize=1)
+    def get_modifications(self) -> list[ModificationBase]:
+        """Returns the list of modifications from the conditions block."""
+        mods = self.impl.conditions.modifications()
+        return [modification_from_libsonata(m) for m in mods]
+
     @lru_cache(maxsize=1)
     def _connection_entries(self) -> list[ConnectionOverrides]:
         result: list[ConnectionOverrides] = []
@@ -126,7 +153,7 @@ def get_compartment_sets(self) -> dict[str, dict]:
         full_path = Path(filepath)
         if config_dir is not None and not full_path.is_absolute():
             full_path = Path(config_dir) / filepath
-        with open(full_path, 'r') as f:
+        with open(full_path, "r") as f:
             return json.load(f)
 
     @lru_cache(maxsize=1)
@@ -145,7 +172,9 @@ def get_node_sets(self) -> dict[str, dict]:
             base_node_sets.update(sim_node_sets)
 
         if not base_node_sets:
-            raise ValueError("No 'node_sets_file' found in simulation or circuit config.")
+            raise ValueError(
+                "No 'node_sets_file' found in simulation or circuit config."
+            )
 
         return base_node_sets
 
@@ -215,8 +244,7 @@ def tstop(self) -> float:
     @property
     def duration(self) -> Optional[float]:
         warnings.warn(
-            "`duration` is deprecated. Use `tstop` instead.",
-            DeprecationWarning
+            "`duration` is deprecated. Use `tstop` instead.", DeprecationWarning
         )
         return self.tstop
 
@@ -253,10 +281,7 @@ def spikes_file_path(self) -> Path:
     def extracellular_calcium(self) -> Optional[float]:
         return self.condition_parameters().extracellular_calcium
 
-    def add_connection_override(
-        self,
-        connection_override: ConnectionOverrides
-    ) -> None:
+    def add_connection_override(self, connection_override: ConnectionOverrides) -> None:
         self._connection_overrides.append(connection_override)
 
     def _get_config_dir(self):
diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 15bc4924..24127d72 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -14,7 +14,6 @@
 """Ssim class of bluecellulab that loads a circuit simulation to do cell
 simulations."""
 
-
 from __future__ import annotations
 from collections.abc import Iterable
 from pathlib import Path
@@ -28,7 +27,6 @@
 import pandas as pd
 from pydantic.types import NonNegativeInt
 from typing_extensions import deprecated
-from typing import Optional
 
 import bluecellulab
 from bluecellulab.cell import CellDict
@@ -38,21 +36,33 @@
     CircuitAccess,
     BluepyCircuitAccess,
     SonataCircuitAccess,
-    get_synapse_connection_parameters
+    get_synapse_connection_parameters,
 )
 from bluecellulab.circuit.config import SimulationConfig
 from bluecellulab.circuit.format import determine_circuit_format, CircuitFormat
 from bluecellulab.circuit.node_id import create_cell_id, create_cell_ids
-from bluecellulab.circuit.simulation_access import BluepySimulationAccess, SimulationAccess, SonataSimulationAccess, _sample_array
+from bluecellulab.circuit.simulation_access import (
+    BluepySimulationAccess,
+    SimulationAccess,
+    SonataSimulationAccess,
+    _sample_array,
+)
 from bluecellulab.importer import load_mod_files
 from bluecellulab.rngsettings import RNGSettings
 from bluecellulab.simulation.neuron_globals import NeuronGlobals
-from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
+    Noise,
+    OrnsteinUhlenbeck,
+    RelativeOrnsteinUhlenbeck,
+    RelativeShotNoise,
+    ShotNoise,
+)
 import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
 from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.simulation import (
     set_global_condition_parameters,
 )
+from bluecellulab.simulation.modifications import apply_modifications
 from bluecellulab.synapse.synapse_types import SynapseID
 
 logger = logging.getLogger(__name__)
@@ -108,23 +118,27 @@ def __init__(
         self.circuit_format = determine_circuit_format(simulation_config)
         if self.circuit_format == CircuitFormat.SONATA:
             self.circuit_access: CircuitAccess = SonataCircuitAccess(simulation_config)
-            self.simulation_access: SimulationAccess = SonataSimulationAccess(simulation_config)
+            self.simulation_access: SimulationAccess = SonataSimulationAccess(
+                simulation_config
+            )
         else:
             self.circuit_access = BluepyCircuitAccess(simulation_config)
             self.simulation_access = BluepySimulationAccess(simulation_config)
             SimulationValidator(self.circuit_access).validate()
 
         self.dt = dt if dt is not None else (self.circuit_access.config.dt or 0.025)
-        pc = parallel_context if parallel_context is not None else neuron.h.ParallelContext()
+        pc = (
+            parallel_context
+            if parallel_context is not None
+            else neuron.h.ParallelContext()
+        )
         self.pc = pc if int(pc.nhost()) > 1 or print_cellstate else None
         self.print_cellstate = print_cellstate
         self.save_time = save_time
 
         self.rng_settings = RNGSettings.get_instance()
         self.rng_settings.set_seeds(
-            rng_mode,
-            self.circuit_access.config,
-            base_seed=base_seed
+            rng_mode, self.circuit_access.config, base_seed=base_seed
         )
 
         self.cells: CellDict = CellDict()
@@ -156,7 +170,9 @@ def instantiate_gids(
         add_projections: bool | list[str] | str = False,
         intersect_pre_gids: Optional[list] = None,
         interconnect_cells: bool = True,
-        pre_spike_trains: None | dict[tuple[str, int], Iterable] | dict[int, Iterable] = None,
+        pre_spike_trains: None
+        | dict[tuple[str, int], Iterable]
+        | dict[int, Iterable] = None,
         add_shotnoise_stimuli: bool = False,
         add_ornstein_uhlenbeck_stimuli: bool = False,
         add_sinusoidal_stimuli: bool = False,
@@ -266,15 +282,18 @@ def instantiate_gids(
         if self.gids_instantiated:
             raise BluecellulabError(
                 "instantiate_gids() is called twice on the "
-                "same CircuitSimumation, this is not supported")
+                "same CircuitSimumation, this is not supported"
+            )
         else:
             self.gids_instantiated = True
 
         if pre_spike_trains or add_replay:
             if add_synapses is False:
-                raise BluecellulabError("You need to set add_synapses to True "
-                                        "if you want to specify use add_replay or "
-                                        "pre_spike_trains")
+                raise BluecellulabError(
+                    "You need to set add_synapses to True "
+                    "if you want to specify use add_replay or "
+                    "pre_spike_trains"
+                )
 
         # legacy for backward compatibility
         if add_projections is None:
@@ -288,23 +307,25 @@ def instantiate_gids(
             self.projections = add_projections
 
         self._add_cells(cell_ids)
+        self._apply_modifications()
         if add_synapses:
-            self._add_synapses(
-                pre_gids=pre_gids,
-                add_minis=add_minis)
+            self._add_synapses(pre_gids=pre_gids, add_minis=add_minis)
         if add_replay or interconnect_cells or pre_spike_trains:
             if add_replay and not add_synapses:
-                raise BluecellulabError("add_replay option can not be used if "
-                                        "add_synapses is False")
+                raise BluecellulabError(
+                    "add_replay option can not be used if add_synapses is False"
+                )
             if self.pc is not None:
                 self._init_pop_index_mpi()
                 self._register_gids_for_mpi()
                 self.pc.barrier()
                 self.pc.setup_transfer()
                 self.pc.set_maxstep(1.0)
-            self._add_connections(add_replay=add_replay,
-                                  interconnect_cells=interconnect_cells,
-                                  user_pre_spike_trains=pre_spike_trains)  # type: ignore
+            self._add_connections(
+                add_replay=add_replay,
+                interconnect_cells=interconnect_cells,
+                user_pre_spike_trains=pre_spike_trains,
+            )  # type: ignore
         if add_stimuli:
             add_noise_stimuli = True
             add_hyperpolarizing_stimuli = True
@@ -315,14 +336,16 @@ def instantiate_gids(
             add_ornstein_uhlenbeck_stimuli = True
             add_linear_stimuli = True
 
-        if add_noise_stimuli or \
-                add_hyperpolarizing_stimuli or \
-                add_pulse_stimuli or \
-                add_relativelinear_stimuli or \
-                add_shotnoise_stimuli or \
-                add_ornstein_uhlenbeck_stimuli or \
-                add_sinusoidal_stimuli or \
-                add_linear_stimuli:
+        if (
+            add_noise_stimuli
+            or add_hyperpolarizing_stimuli
+            or add_pulse_stimuli
+            or add_relativelinear_stimuli
+            or add_shotnoise_stimuli
+            or add_ornstein_uhlenbeck_stimuli
+            or add_sinusoidal_stimuli
+            or add_linear_stimuli
+        ):
             self._add_stimuli(
                 add_noise_stimuli=add_noise_stimuli,
                 add_hyperpolarizing_stimuli=add_hyperpolarizing_stimuli,
@@ -331,28 +354,33 @@ def instantiate_gids(
                 add_shotnoise_stimuli=add_shotnoise_stimuli,
                 add_ornstein_uhlenbeck_stimuli=add_ornstein_uhlenbeck_stimuli,
                 add_sinusoidal_stimuli=add_sinusoidal_stimuli,
-                add_linear_stimuli=add_linear_stimuli
+                add_linear_stimuli=add_linear_stimuli,
             )
 
         configure_all_reports(
-            cells=self.cells,
-            simulation_config=self.circuit_access.config
+            cells=self.cells, simulation_config=self.circuit_access.config
         )
 
         # add spike recordings
         for cell in self.cells.values():
-            if not cell.is_recording_spikes(self.spike_location, threshold=self.spike_threshold):
-                cell.start_recording_spikes(None, location=self.spike_location, threshold=self.spike_threshold)
-
-    def _add_stimuli(self, add_noise_stimuli=False,
-                     add_hyperpolarizing_stimuli=False,
-                     add_relativelinear_stimuli=False,
-                     add_pulse_stimuli=False,
-                     add_shotnoise_stimuli=False,
-                     add_ornstein_uhlenbeck_stimuli=False,
-                     add_sinusoidal_stimuli=False,
-                     add_linear_stimuli=False
-                     ) -> None:
+            if not cell.is_recording_spikes(
+                self.spike_location, threshold=self.spike_threshold
+            ):
+                cell.start_recording_spikes(
+                    None, location=self.spike_location, threshold=self.spike_threshold
+                )
+
+    def _add_stimuli(
+        self,
+        add_noise_stimuli=False,
+        add_hyperpolarizing_stimuli=False,
+        add_relativelinear_stimuli=False,
+        add_pulse_stimuli=False,
+        add_shotnoise_stimuli=False,
+        add_ornstein_uhlenbeck_stimuli=False,
+        add_sinusoidal_stimuli=False,
+        add_linear_stimuli=False,
+    ) -> None:
         """Instantiate all the stimuli."""
         stimuli_entries = self.circuit_access.config.get_all_stimuli_entries()
         # Also add the injections / stimulations as in the cortical model
@@ -377,7 +405,9 @@ def _add_stimuli(self, add_noise_stimuli=False,
             if stimulus.compartment_set is not None:
                 targets = self._targets_from_compartment_set(stimulus, compartment_sets)
             elif stimulus.node_set is not None:
-                gids_of_target = self.circuit_access.get_target_cell_ids(stimulus.node_set)
+                gids_of_target = self.circuit_access.get_target_cell_ids(
+                    stimulus.node_set
+                )
                 for cell_id in self.cells:
                     if cell_id not in gids_of_target:
                         continue
@@ -393,35 +423,75 @@ def _add_stimuli(self, add_noise_stimuli=False,
             for cell_id, sec, segx, sec_name in targets:
                 if isinstance(stimulus, circuit_stimulus_definitions.Noise):
                     if add_noise_stimuli:
-                        self.cells[cell_id].add_replay_noise(stimulus, noise_seed=None, noisestim_count=noisestim_count, section=sec, segx=segx)
+                        self.cells[cell_id].add_replay_noise(
+                            stimulus,
+                            noise_seed=None,
+                            noisestim_count=noisestim_count,
+                            section=sec,
+                            segx=segx,
+                        )
                 elif isinstance(stimulus, circuit_stimulus_definitions.Hyperpolarizing):
                     if add_hyperpolarizing_stimuli:
-                        self.cells[cell_id].add_replay_hypamp(stimulus, section=sec, segx=segx)
+                        self.cells[cell_id].add_replay_hypamp(
+                            stimulus, section=sec, segx=segx
+                        )
                 elif isinstance(stimulus, circuit_stimulus_definitions.Pulse):
                     if add_pulse_stimuli:
                         self.cells[cell_id].add_pulse(stimulus, section=sec, segx=segx)
                 elif isinstance(stimulus, circuit_stimulus_definitions.Linear):
                     if add_linear_stimuli:
-                        self.cells[cell_id].add_replay_linear(stimulus, section=sec, segx=segx)
+                        self.cells[cell_id].add_replay_linear(
+                            stimulus, section=sec, segx=segx
+                        )
                 elif isinstance(stimulus, circuit_stimulus_definitions.RelativeLinear):
                     if add_relativelinear_stimuli:
-                        self.cells[cell_id].add_replay_relativelinear(stimulus, section=sec, segx=segx)
+                        self.cells[cell_id].add_replay_relativelinear(
+                            stimulus, section=sec, segx=segx
+                        )
                 elif isinstance(stimulus, circuit_stimulus_definitions.ShotNoise):
                     if add_shotnoise_stimuli:
-                        self.cells[cell_id].add_replay_shotnoise(sec, segx, stimulus, shotnoise_stim_count=shotnoise_stim_count)
-                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeShotNoise):
+                        self.cells[cell_id].add_replay_shotnoise(
+                            sec,
+                            segx,
+                            stimulus,
+                            shotnoise_stim_count=shotnoise_stim_count,
+                        )
+                elif isinstance(
+                    stimulus, circuit_stimulus_definitions.RelativeShotNoise
+                ):
                     if add_shotnoise_stimuli:
-                        self.cells[cell_id].add_replay_relative_shotnoise(sec, segx, stimulus, shotnoise_stim_count=shotnoise_stim_count)
-                elif isinstance(stimulus, circuit_stimulus_definitions.OrnsteinUhlenbeck):
+                        self.cells[cell_id].add_replay_relative_shotnoise(
+                            sec,
+                            segx,
+                            stimulus,
+                            shotnoise_stim_count=shotnoise_stim_count,
+                        )
+                elif isinstance(
+                    stimulus, circuit_stimulus_definitions.OrnsteinUhlenbeck
+                ):
                     if add_ornstein_uhlenbeck_stimuli:
-                        self.cells[cell_id].add_ornstein_uhlenbeck(sec, segx, stimulus, stim_count=ornstein_uhlenbeck_stim_count)
-                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeOrnsteinUhlenbeck):
+                        self.cells[cell_id].add_ornstein_uhlenbeck(
+                            sec,
+                            segx,
+                            stimulus,
+                            stim_count=ornstein_uhlenbeck_stim_count,
+                        )
+                elif isinstance(
+                    stimulus, circuit_stimulus_definitions.RelativeOrnsteinUhlenbeck
+                ):
                     if add_ornstein_uhlenbeck_stimuli:
-                        self.cells[cell_id].add_relative_ornstein_uhlenbeck(sec, segx, stimulus, stim_count=ornstein_uhlenbeck_stim_count)
+                        self.cells[cell_id].add_relative_ornstein_uhlenbeck(
+                            sec,
+                            segx,
+                            stimulus,
+                            stim_count=ornstein_uhlenbeck_stim_count,
+                        )
                 elif isinstance(stimulus, circuit_stimulus_definitions.Sinusoidal):
                     if add_sinusoidal_stimuli:
                         self.cells[cell_id].add_sinusoidal(stimulus)
-                elif isinstance(stimulus, circuit_stimulus_definitions.SynapseReplay):  # sonata only
+                elif isinstance(
+                    stimulus, circuit_stimulus_definitions.SynapseReplay
+                ):  # sonata only
                     if self.circuit_access.target_contains_cell(
                         stimulus.target, cell_id
                     ):
@@ -429,8 +499,12 @@ def _add_stimuli(self, add_noise_stimuli=False,
                             stimulus, self.spike_threshold, self.spike_location
                         )
                 else:
-                    raise ValueError("Found stimulus with pattern %s, not supported" % stimulus)
-                logger.debug(f"Added {stimulus} to cell_id {cell_id} at {sec_name}({segx})")
+                    raise ValueError(
+                        "Found stimulus with pattern %s, not supported" % stimulus
+                    )
+                logger.debug(
+                    f"Added {stimulus} to cell_id {cell_id} at {sec_name}({segx})"
+                )
 
             if isinstance(stimulus, Noise):
                 noisestim_count += 1
@@ -439,13 +513,10 @@ def _add_stimuli(self, add_noise_stimuli=False,
             elif isinstance(stimulus, (OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck)):
                 ornstein_uhlenbeck_stim_count += 1
 
-    def _add_synapses(
-            self, pre_gids=None, add_minis=False):
+    def _add_synapses(self, pre_gids=None, add_minis=False):
         """Instantiate all the synapses."""
         for cell_id in self.cells:
-            self._add_cell_synapses(
-                cell_id, pre_gids=pre_gids,
-                add_minis=add_minis)
+            self._add_cell_synapses(cell_id, pre_gids=pre_gids, add_minis=add_minis)
 
     def _add_cell_synapses(
         self, cell_id: CellId, pre_gids=None, add_minis=False
@@ -478,7 +549,7 @@ def _add_cell_synapses(
                     syn_id=idx,  # type: ignore
                     syn_description=syn_description,
                     add_minis=add_minis,
-                    popids=popids
+                    popids=popids,
                 )
             logger.info(f"Added {syn_descriptions} synapses for gid {cell_id}")
             if add_minis:
@@ -499,7 +570,9 @@ def _targets_from_compartment_set(
 
         comp_name = stimulus.compartment_set
         if comp_name not in compartment_sets:
-            raise ValueError(f"Compartment set '{comp_name}' not found in compartment_sets file.")
+            raise ValueError(
+                f"Compartment set '{comp_name}' not found in compartment_sets file."
+            )
 
         comp_entry = compartment_sets[comp_name]
         comp_nodes = comp_entry.get("compartment_set", [])
@@ -508,7 +581,10 @@ def _targets_from_compartment_set(
 
         targets: list[tuple] = []
         for cell_id in self.cells:
-            if population_name is not None and getattr(cell_id, "population_name", None) != population_name:
+            if (
+                population_name is not None
+                and getattr(cell_id, "population_name", None) != population_name
+            ):
                 continue
             try:
                 resolved = self.cells[cell_id].resolve_segments_from_compartment_set(
@@ -516,7 +592,9 @@ def _targets_from_compartment_set(
                     comp_nodes,
                 )
             except (ValueError, TypeError) as e:
-                logger.debug(f"Failed to resolve compartment_set for cell {cell_id}: {e}")
+                logger.debug(
+                    f"Failed to resolve compartment_set for cell {cell_id}: {e}"
+                )
                 continue
 
             for sec, sec_name, segx in resolved:
@@ -528,17 +606,22 @@ def _targets_from_compartment_set(
     def _intersect_pre_gids(syn_descriptions, pre_gids: list[CellId]) -> pd.DataFrame:
         """Return the synapse descriptions with pre_gids intersected."""
         _pre_gids = {x.id for x in pre_gids}
-        return syn_descriptions[syn_descriptions[SynapseProperty.PRE_GID].isin(_pre_gids)]
+        return syn_descriptions[
+            syn_descriptions[SynapseProperty.PRE_GID].isin(_pre_gids)
+        ]
 
     @staticmethod
-    def _intersect_pre_gids_cell_ids_multipopulation(syn_descriptions, pre_cell_ids: list[CellId]) -> pd.DataFrame:
+    def _intersect_pre_gids_cell_ids_multipopulation(
+        syn_descriptions, pre_cell_ids: list[CellId]
+    ) -> pd.DataFrame:
         """Return the synapse descriptions with pre_cell_ids intersected.
 
         Supports multipopulations.
         """
         filtered_rows = syn_descriptions.apply(
             lambda row: any(
-                cell.population_name == row["source_population_name"] and row[SynapseProperty.PRE_GID] == cell.id
+                cell.population_name == row["source_population_name"]
+                and row[SynapseProperty.PRE_GID] == cell.id
                 for cell in pre_cell_ids
             ),
             axis=1,
@@ -548,7 +631,9 @@ def _intersect_pre_gids_cell_ids_multipopulation(syn_descriptions, pre_cell_ids:
     def get_syn_descriptions(self, cell_id: int | tuple[str, int]) -> pd.DataFrame:
         """Get synapse descriptions dataframe."""
         cell_id = create_cell_id(cell_id)
-        return self.circuit_access.extract_synapses(cell_id, projections=self.projections)
+        return self.circuit_access.extract_synapses(
+            cell_id, projections=self.projections
+        )
 
     @staticmethod
     def merge_pre_spike_trains(*train_dicts) -> dict[CellId, np.ndarray]:
@@ -577,23 +662,23 @@ def _find_matching_override(self, overrides, pre: CellId, post: CellId):
         matched = None
         for ov in overrides:
             # ov.source and ov.target are nodeset names
-            if (
-                self.circuit_access.target_contains_cell(ov.source, pre)
-                and self.circuit_access.target_contains_cell(ov.target, post)
-            ):
-                matched = ov   # "last match wins" like Neurodamus ordering
+            if self.circuit_access.target_contains_cell(
+                ov.source, pre
+            ) and self.circuit_access.target_contains_cell(ov.target, post):
+                matched = ov  # "last match wins" like Neurodamus ordering
         return matched
 
     def _add_connections(
-            self,
-            add_replay=None,
-            interconnect_cells=None,
-            user_pre_spike_trains: None | dict[CellId, Iterable] = None) -> None:
+        self,
+        add_replay=None,
+        interconnect_cells=None,
+        user_pre_spike_trains: None | dict[CellId, Iterable] = None,
+    ) -> None:
         """Instantiate the (replay and real) connections in the network."""
         pre_spike_trains = self.simulation_access.get_spikes() if add_replay else {}
         pre_spike_trains = self.merge_pre_spike_trains(
-            pre_spike_trains,
-            user_pre_spike_trains)
+            pre_spike_trains, user_pre_spike_trains
+        )
 
         connections_overrides = (
             self.circuit_access.config.connection_entries()
@@ -607,26 +692,34 @@ def _add_connections(
                 syn_description: pd.Series = synapse.syn_description
                 delay_weights = synapse.delay_weights
                 source_population = syn_description["source_population_name"]
-                pre_gid = CellId(source_population, int(syn_description[SynapseProperty.PRE_GID]))
+                pre_gid = CellId(
+                    source_population, int(syn_description[SynapseProperty.PRE_GID])
+                )
 
-                ov = self._find_matching_override(connections_overrides, pre_gid, post_gid)
+                ov = self._find_matching_override(
+                    connections_overrides, pre_gid, post_gid
+                )
 
                 if ov is not None and ov.weight == 0.0:
                     logger.debug(
                         "Skipping connection due to zero weight override: %s -> %s | syn_id=%s",
-                        pre_gid, post_gid, syn_id
+                        pre_gid,
+                        post_gid,
+                        syn_id,
                     )
                     continue
 
                 if self.pc is None:
-                    real_synapse_connection = bool(interconnect_cells) and (pre_gid in self.cells)
+                    real_synapse_connection = bool(interconnect_cells) and (
+                        pre_gid in self.cells
+                    )
                 else:
                     real_synapse_connection = bool(interconnect_cells)
 
                 if real_synapse_connection:
                     if (
-                            user_pre_spike_trains is not None
-                            and pre_gid in user_pre_spike_trains
+                        user_pre_spike_trains is not None
+                        and pre_gid in user_pre_spike_trains
                     ):
                         raise BluecellulabError(
                             """Specifying prespike trains of real connections"""
@@ -655,7 +748,9 @@ def _add_connections(
                             spike_location=self.spike_location,
                         )
 
-                    logger.debug(f"Added real connection between {pre_gid} and {post_gid}, {syn_id}")
+                    logger.debug(
+                        f"Added real connection between {pre_gid} and {post_gid}, {syn_id}"
+                    )
                 else:  # replay connection
                     pre_spiketrain = pre_spike_trains.get(pre_gid, None)
                     connection = bluecellulab.Connection(
@@ -665,15 +760,21 @@ def _add_connections(
                         stim_dt=self.dt,
                         parallel_context=None,
                         spike_threshold=self.spike_threshold,
-                        spike_location=self.spike_location
+                        spike_location=self.spike_location,
                     )
 
-                    logger.debug(f"Added replay connection from {pre_gid} to {post_gid}, {syn_id}")
+                    logger.debug(
+                        f"Added replay connection from {pre_gid} to {post_gid}, {syn_id}"
+                    )
 
                 if ov is not None:
                     logger.debug(
                         "Override matched: %s -> %s | syn_id=%s | weight=%s delay=%s",
-                        pre_gid, post_gid, syn_id, ov.weight, ov.delay
+                        pre_gid,
+                        post_gid,
+                        syn_id,
+                        ov.weight,
+                        ov.delay,
                     )
 
                     syn_delay = getattr(ov, "synapse_delay_override", None)
@@ -681,28 +782,38 @@ def _add_connections(
                         connection.set_netcon_delay(float(syn_delay))
                         logger.debug(
                             "Applied synapse_delay_override %.4g ms to %s -> %s | syn_id=%s",
-                            syn_delay, pre_gid, post_gid, syn_id
+                            syn_delay,
+                            pre_gid,
+                            post_gid,
+                            syn_id,
                         )
 
                     if ov.delay is not None:
                         logger.warning(
                             "SONATA override 'delay' (delayed weight activation) is not supported yet; "
                             "applying weight immediately. %s -> %s | syn_id=%s | delay=%s",
-                            pre_gid, post_gid, syn_id, ov.delay
+                            pre_gid,
+                            post_gid,
+                            syn_id,
+                            ov.delay,
                         )
 
                     if ov.weight is not None:
                         connection.set_weight_scalar(float(ov.weight))
                         logger.debug(
                             "Applied weight override factor %.4g to %s -> %s | syn_id=%s | final_weight=%.4g",
-                            ov.weight, pre_gid, post_gid, syn_id, connection.post_netcon_weight
+                            ov.weight,
+                            pre_gid,
+                            post_gid,
+                            syn_id,
+                            connection.post_netcon_weight,
                         )
 
                 self.cells[post_gid].connections[syn_id] = connection
                 for delay, weight_scale in delay_weights:
                     self.cells[post_gid].add_replay_delayed_weight(
-                        syn_id, delay,
-                        weight_scale * connection.weight)
+                        syn_id, delay, weight_scale * connection.weight
+                    )
 
             if len(self.cells[post_gid].connections) > 0:
                 logger.debug(f"Added synaptic connections for target {post_gid}")
@@ -716,24 +827,48 @@ def _add_cells(self, cell_ids: list[CellId]) -> None:
             if self.circuit_access.node_properties_available:
                 cell.connect_to_circuit(SonataProxy(cell_id, self.circuit_access))
 
-    def _instantiate_synapse(self, cell_id: CellId, syn_id: SynapseID, syn_description,
-                             add_minis=False, popids=(0, 0)) -> None:
+    def _apply_modifications(self) -> None:
+        """Apply condition modifications from the simulation config to cells."""
+        try:
+            modifications = self.circuit_access.config.get_modifications()
+        except (NotImplementedError, AttributeError):
+            return
+        if modifications:
+            apply_modifications(self.cells, modifications, self.circuit_access)
+
+    def _instantiate_synapse(
+        self,
+        cell_id: CellId,
+        syn_id: SynapseID,
+        syn_description,
+        add_minis=False,
+        popids=(0, 0),
+    ) -> None:
         """Instantiate one synapse for a given gid, syn_id and
         syn_description."""
-        pre_cell_id = CellId(syn_description["source_population_name"], int(syn_description[SynapseProperty.PRE_GID]))
+        pre_cell_id = CellId(
+            syn_description["source_population_name"],
+            int(syn_description[SynapseProperty.PRE_GID]),
+        )
         syn_connection_parameters = get_synapse_connection_parameters(
-            circuit_access=self.circuit_access,
-            pre_cell=pre_cell_id,
-            post_cell=cell_id)
+            circuit_access=self.circuit_access, pre_cell=pre_cell_id, post_cell=cell_id
+        )
         if syn_connection_parameters["add_synapse"]:
             condition_parameters = self.circuit_access.config.condition_parameters()
 
             self.cells[cell_id].add_replay_synapse(
-                syn_id, syn_description, syn_connection_parameters, condition_parameters,
-                popids=popids, extracellular_calcium=self.circuit_access.config.extracellular_calcium)
+                syn_id,
+                syn_description,
+                syn_connection_parameters,
+                condition_parameters,
+                popids=popids,
+                extracellular_calcium=self.circuit_access.config.extracellular_calcium,
+            )
             if add_minis:
                 mini_frequencies = self.circuit_access.fetch_mini_frequencies(cell_id)
-                logger.debug(f"Adding minis for synapse {syn_id}: syn_description={syn_description}, connection={syn_connection_parameters}, frequency={mini_frequencies}")
+                logger.debug(
+                    f"Adding minis for synapse {syn_id}: syn_description={syn_description}, connection={syn_connection_parameters}, frequency={mini_frequencies}"
+                )
 
                 self.cells[cell_id].add_replay_minis(
                     syn_id,
@@ -806,7 +941,7 @@ def run(
         dt = self.dt
 
         config_forward_skip_value = self.circuit_access.config.forward_skip  # legacy
-        config_tstart = self.circuit_access.config.tstart or 0.0             # SONATA
+        config_tstart = self.circuit_access.config.tstart or 0.0  # SONATA
         # Determine effective skip value and flag
         if forward_skip_value is not None:
             # User explicitly provided value → use it
@@ -838,6 +973,7 @@ def run(
 
         self.fih_prcellstate = None
         if self.pc is not None and self.print_cellstate:
+
             def dump():
                 for cell in self.cells:
                     pop = cell.population_name
@@ -846,15 +982,21 @@ def dump():
                     self.pc.prcellstate(g, f"bluecellulab_t={neuron.h.t}")
 
             def schedule_dump():
-                t_dump = self.save_time if self.save_time is not None else self.circuit_access.config.tstop
+                t_dump = (
+                    self.save_time
+                    if self.save_time is not None
+                    else self.circuit_access.config.tstop
+                )
                 neuron.h.cvode.event(t_dump, dump)
 
             self.fih_prcellstate = neuron.h.FInitializeHandler(1, schedule_dump)
 
         if show_progress:
-            logger.warning("show_progress enabled, this will very likely"
-                           "break the exact reproducibility of large network"
-                           "simulations")
+            logger.warning(
+                "show_progress enabled, this will very likely"
+                "break the exact reproducibility of large network"
+                "simulations"
+            )
 
         sim.run(
             tstop=t_stop,
@@ -862,10 +1004,11 @@ def schedule_dump():
             dt=dt,
             forward_skip=effective_skip,
             forward_skip_value=effective_skip_value,
-            show_progress=show_progress)
+            show_progress=show_progress,
+        )
 
     def get_mainsim_voltage_trace(
-            self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None
+        self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None
     ) -> np.ndarray:
         """Get the voltage trace from a cell from the main simulation.
 
@@ -932,7 +1075,7 @@ def get_time_trace(self, t_start=None, t_stop=None, t_step=None) -> np.ndarray:
         return time
 
     def get_voltage_trace(
-            self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None
+        self, cell_id: int | tuple[str, int], t_start=None, t_stop=None, t_step=None
     ) -> np.ndarray:
         """Get the voltage vector for the cell_id, negative times removed.
 
@@ -968,7 +1111,7 @@ def delete(self):
 
         NEURON objects are explicitly needed to be deleted.
         """
-        if hasattr(self, 'cells'):
+        if hasattr(self, "cells"):
             for _, cell in self.cells.items():
                 cell.delete()
             cell_ids = list(self.cells.keys())
@@ -986,12 +1129,12 @@ def fetch_cell_kwargs(self, cell_id: CellId) -> dict:
         """Get the kwargs to instantiate a Cell object."""
         emodel_properties = self.circuit_access.get_emodel_properties(cell_id)
         cell_kwargs = {
-            'template_path': self.circuit_access.emodel_path(cell_id),
-            'morphology_path': self.circuit_access.morph_filepath(cell_id),
-            'cell_id': cell_id,
-            'record_dt': self.record_dt,
-            'template_format': self.circuit_access.get_template_format(),
-            'emodel_properties': emodel_properties,
+            "template_path": self.circuit_access.emodel_path(cell_id),
+            "morphology_path": self.circuit_access.morph_filepath(cell_id),
+            "cell_id": cell_id,
+            "record_dt": self.record_dt,
+            "template_format": self.circuit_access.get_template_format(),
+            "emodel_properties": emodel_properties,
         }
 
         return cell_kwargs
@@ -999,12 +1142,14 @@ def fetch_cell_kwargs(self, cell_id: CellId) -> dict:
     def create_cell_from_circuit(self, cell_id: CellId) -> bluecellulab.Cell:
         """Create a Cell object from the circuit."""
         cell_kwargs = self.fetch_cell_kwargs(cell_id)
-        return bluecellulab.Cell(template_path=cell_kwargs['template_path'],
-                                 morphology_path=cell_kwargs['morphology_path'],
-                                 cell_id=cell_kwargs['cell_id'],
-                                 record_dt=cell_kwargs['record_dt'],
-                                 template_format=cell_kwargs['template_format'],
-                                 emodel_properties=cell_kwargs['emodel_properties'])
+        return bluecellulab.Cell(
+            template_path=cell_kwargs["template_path"],
+            morphology_path=cell_kwargs["morphology_path"],
+            cell_id=cell_kwargs["cell_id"],
+            record_dt=cell_kwargs["record_dt"],
+            template_format=cell_kwargs["template_format"],
+            emodel_properties=cell_kwargs["emodel_properties"],
+        )
 
     def global_gid(self, pop: str, gid: int) -> int:
         """Return a globally unique NEURON GID for a (population, node_id)
@@ -1076,8 +1221,6 @@ def _register_gids_for_mpi(self) -> None:
 
             self.pc.set_gid2node(g, int(self.pc.id()))
             nc = cell.create_netcon_spikedetector(
-                None,
-                location=self.spike_location,
-                threshold=self.spike_threshold
+                None, location=self.spike_location, threshold=self.spike_threshold
             )
             self.pc.cell(g, nc)
diff --git a/bluecellulab/simulation/modifications.py b/bluecellulab/simulation/modifications.py
new file mode 100644
index 00000000..9d03eb8a
--- /dev/null
+++ b/bluecellulab/simulation/modifications.py
@@ -0,0 +1,476 @@
+# Copyright 2023-2024 Blue Brain Project / EPFL
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Module for applying SONATA condition modifications to cells.
+
+Implements all five SONATA modification types:
+- ttx: Block Na channels via TTXDynamicsSwitch
+- configure_all_sections: Apply section_configure to all sections
+- section_list: Apply section_configure to a named section list
+- section: Apply section_configure to specific named sections
+- compartment_set: Apply section_configure to segments in a compartment set
+
+The section_configure parser follows neurodamus's ast.parse() + restricted exec()
+pattern (neurodamus/modification_manager.py).
+"""
+
+from __future__ import annotations
+
+import ast
+import logging
+import re
+
+from bluecellulab.circuit.config.sections import (
+    ModificationBase,
+    ModificationCompartmentSet,
+    ModificationConfigureAllSections,
+    ModificationSection,
+    ModificationSectionList,
+    ModificationTTX,
+)
+
+logger = logging.getLogger(__name__)
+
+# Mapping from SONATA section list names to Cell property names
+SECTION_LIST_MAP: dict[str, str] = {
+    "somatic": "somatic",
+    "soma": "somatic",
+    "basal": "basal",
+    "dend": "basal",
+    "apical": "apical",
+    "apic": "apical",
+    "axonal": "axonal",
+    "axon": "axonal",
+}
+
+
+class _AttributeCollector(ast.NodeVisitor):
+    """AST visitor that collects all attribute names referenced in an expression."""
+
+    def __init__(self):
+        self.attrs: set[str] = set()
+
+    def visit_Attribute(self, node):
+        self.attrs.add(node.attr)
+        self.generic_visit(node)
+
+
+def _validate_assignment(node) -> list:
+    """Return assignment targets from an AST node, raising on non-assignments."""
+    if isinstance(node, ast.Assign):
+        return node.targets
+    if isinstance(node, ast.AugAssign):
+        return [node.target]
+    raise ValueError(
+        "section_configure must consist of one or more semicolon-separated assignments"
+    )
+
+
+def parse_section_configure(
+    config_str: str, placeholder: str = "%s"
+) -> tuple[str, set[str]]:
+    """Parse a section_configure string, returning sanitized code and referenced attrs.
+
+    Follows neurodamus's ConfigureAllSections.parse_section_config() pattern.
+
+    Args:
+        config_str: The raw section_configure string (e.g. "%s.gbar = 0").
+        placeholder: The placeholder to replace with 'sec' (default: "%s").
+
+    Returns:
+        Tuple of (sanitized_config_str, set_of_referenced_attribute_names).
+
+    Raises:
+        ValueError: If the config string contains non-assignment statements
+            or references attributes not on the placeholder.
+    """
+    # Replace placeholder with internal variable name
+    internal = config_str.replace(f"{placeholder}.", "__sec_wildcard__.")
+    collector = _AttributeCollector()
+    tree = ast.parse(internal)
+    for elem in tree.body:
+        targets = _validate_assignment(elem)
+        for tgt in targets:
+            if not isinstance(tgt, ast.Attribute) or tgt.value.id != "__sec_wildcard__":
+                raise ValueError(
+                    "section_configure only supports single assignments "
+                    f"of attributes of the section wildcard {placeholder}"
+                )
+        collector.visit(elem)
+    sanitized = internal.replace("__sec_wildcard__.", "sec.")
+    return sanitized, collector.attrs
+
+
+def _exec_on_section(config: str, section, attrs: set[str]) -> bool:
+    """Apply a sanitized config string to a NEURON section if it has all attrs.
+
+    Returns True if applied, False if skipped due to missing attributes.
+    """
+    if all(hasattr(section, attr) for attr in attrs):
+        exec(config, {"__builtins__": None}, {"sec": section})  # noqa: S102
+        return True
+    return False
+
+
+def apply_modifications(
+    cells: dict, modifications: list[ModificationBase], circuit_access
+) -> None:
+    """Apply a list of modifications to instantiated cells.
+
+    Args:
+        cells: Dict mapping CellId to Cell objects.
+        modifications: List of Modification dataclass instances.
+        circuit_access: CircuitAccess instance for resolving node_sets.
+    """
+    for mod in modifications:
+        if isinstance(mod, ModificationTTX):
+            _apply_ttx(cells, mod, circuit_access)
+        elif isinstance(mod, ModificationConfigureAllSections):
+            _apply_configure_all_sections(cells, mod, circuit_access)
+        elif isinstance(mod, ModificationSectionList):
+            _apply_section_list(cells, mod, circuit_access)
+        elif isinstance(mod, ModificationSection):
+            _apply_section(cells, mod, circuit_access)
+        elif isinstance(mod, ModificationCompartmentSet):
+            _apply_compartment_set(cells, mod, circuit_access)
+        else:
+            raise ValueError(f"Unknown modification type: {mod.type}")
+
+
+def _resolve_target_cells(cells: dict, mod, circuit_access) -> list:
+    """Resolve node_set to the subset of instantiated cells that match."""
+    target_ids = circuit_access.get_target_cell_ids(mod.node_set)
+    return [cell_id for cell_id in cells if cell_id in target_ids]
+
+
+def _apply_ttx(cells: dict, mod: ModificationTTX, circuit_access) -> None:
+    """Apply TTX modification — enable TTX on all target cells."""
+    logger.info(
+        "Applying modification '%s' (type=ttx) to node_set '%s'", mod.name, mod.node_set
+    )
+    target_cell_ids = _resolve_target_cells(cells, mod, circuit_access)
+    count = 0
+    for cell_id in target_cell_ids:
+        cells[cell_id].enable_ttx()
+        count += 1
+        logger.debug("  TTX enabled on cell %s", cell_id)
+    logger.info("Modification '%s' (ttx): enabled on %d cells", mod.name, count)
+    if count == 0:
+        logger.warning(
+            "TTX modification '%s' matched zero cells in node_set '%s'",
+            mod.name,
+            mod.node_set,
+        )
+
+
+def _apply_configure_all_sections(
+    cells: dict, mod: ModificationConfigureAllSections, circuit_access
+) -> None:
+    """Apply configure_all_sections — exec section_configure on all sections."""
+    logger.info(
+        "Applying modification '%s' (type=configure_all_sections) to node_set '%s'",
+        mod.name,
+        mod.node_set,
+    )
+    config, attrs = parse_section_configure(mod.section_configure, placeholder="%s")
+    target_cell_ids = _resolve_target_cells(cells, mod, circuit_access)
+
+    n_cells = 0
+    n_sections = 0
+    for cell_id in target_cell_ids:
+        cell = cells[cell_id]
+        cell_applied = 0
+        for sec_name, section in cell.sections.items():
+            if _exec_on_section(config, section, attrs):
+                cell_applied += 1
+                logger.debug("  Applied to section '%s' of cell %s", sec_name, cell_id)
+        if cell_applied > 0:
+            n_cells += 1
+        n_sections += cell_applied
+
+    logger.info(
+        "Modification '%s' applied to %d sections across %d cells",
+        mod.name,
+        n_sections,
+        n_cells,
+    )
+    if n_sections == 0:
+        logger.warning(
+            "configure_all_sections '%s' applied to zero sections, "
+            "please check its section_configure for possible mistakes",
+            mod.name,
+        )
+
+
+def _apply_section_list(
+    cells: dict, mod: ModificationSectionList, circuit_access
+) -> None:
+    """Apply section_list — exec section_configure on a named section list."""
+    logger.info(
+        "Applying modification '%s' (type=section_list) to node_set '%s'",
+        mod.name,
+        mod.node_set,
+    )
+
+    # Extract list name from section_configure: e.g. "apical.gbar = 0" -> "apical"
+    # The format is "<list_name>.attr = value [; <list_name>.attr = value ...]"
+    match = re.match(r"^(\w+)\.", mod.section_configure)
+    if not match:
+        raise ValueError(
+            f"section_list modification '{mod.name}': cannot extract section list name "
+            f"from section_configure '{mod.section_configure}'"
+        )
+    list_name = match.group(1)
+
+    prop_name = SECTION_LIST_MAP.get(list_name)
+    if prop_name is None:
+        raise ValueError(
+            f"section_list modification '{mod.name}': unknown section list name '{list_name}'. "
+            f"Supported: {list(SECTION_LIST_MAP.keys())}"
+        )
+
+    # Replace list_name. with sec. for exec
+    config_str = mod.section_configure.replace(f"{list_name}.", "sec.")
+    # Parse and validate the sanitized string
+    collector = _AttributeCollector()
+    tree = ast.parse(config_str)
+    for elem in tree.body:
+        _validate_assignment(elem)
+        collector.visit(elem)
+    attrs = collector.attrs
+
+    target_cell_ids = _resolve_target_cells(cells, mod, circuit_access)
+    n_cells = 0
+    n_sections = 0
+    for cell_id in target_cell_ids:
+        cell = cells[cell_id]
+        try:
+            section_list = getattr(cell, prop_name)
+        except AttributeError:
+            logger.warning(
+                "section_list '%s': cell %s has no '%s' property, skipping",
+                mod.name,
+                cell_id,
+                prop_name,
+            )
+            continue
+
+        if not section_list:
+            logger.warning(
+                "section_list '%s': cell %s has no '%s' sections, skipping",
+                mod.name,
+                cell_id,
+                list_name,
+            )
+            continue
+
+        cell_applied = 0
+        for section in section_list:
+            sec_name = section.name().split(".")[-1]
+            if _exec_on_section(config_str, section, attrs):
+                cell_applied += 1
+                logger.debug("  Applied to section '%s' of cell %s", sec_name, cell_id)
+        if cell_applied > 0:
+            n_cells += 1
+        n_sections += cell_applied
+
+    logger.info(
+        "Modification '%s' applied to %d sections across %d cells",
+        mod.name,
+        n_sections,
+        n_cells,
+    )
+    if n_sections == 0:
+        logger.warning(
+            "section_list '%s' applied to zero sections, "
+            "please check its section_configure for possible mistakes",
+            mod.name,
+        )
+
+
+def _apply_section(cells: dict, mod: ModificationSection, circuit_access) -> None:
+    """Apply section — exec section_configure on specific named sections."""
+    logger.info(
+        "Applying modification '%s' (type=section) to node_set '%s'",
+        mod.name,
+        mod.node_set,
+    )
+
+    # Extract section names from section_configure
+    # Format: "apic[10].gbar = 0; apic[10].gbar2 = 1" or "dend[3].x = 5"
+    # Find all unique "<name>[<idx>]." patterns
+    section_names = list(
+        dict.fromkeys(re.findall(r"(\w+\[\d+\])\.", mod.section_configure))
+    )
+    if not section_names:
+        raise ValueError(
+            f"section modification '{mod.name}': cannot extract section name(s) "
+            f"from section_configure '{mod.section_configure}'"
+        )
+
+    # Build per-section config strings
+    # For each unique section name, replace "<name>[idx]." with "sec."
+    # and parse to get attrs
+    section_configs: dict[str, tuple[str, set[str]]] = {}
+    for sec_name in section_names:
+        escaped = re.escape(sec_name)
+        config_str = re.sub(escaped + r"\.", "sec.", mod.section_configure)
+        # Filter to only statements that reference this section
+        # (handle multi-section configs like "apic[10].x = 0; dend[3].y = 1")
+        collector = _AttributeCollector()
+        tree = ast.parse(config_str)
+        for elem in tree.body:
+            _validate_assignment(elem)
+            collector.visit(elem)
+        section_configs[sec_name] = (config_str, collector.attrs)
+
+    target_cell_ids = _resolve_target_cells(cells, mod, circuit_access)
+    n_cells = 0
+    n_sections = 0
+    for cell_id in target_cell_ids:
+        cell = cells[cell_id]
+        cell_applied = 0
+        for sec_name, (config_str, attrs) in section_configs.items():
+            try:
+                section = cell.get_section(sec_name)
+            except (ValueError, TypeError):
+                logger.warning(
+                    "section '%s': cell %s does not have section '%s', skipping",
+                    mod.name,
+                    cell_id,
+                    sec_name,
+                )
+                continue
+            if _exec_on_section(config_str, section, attrs):
+                cell_applied += 1
+                logger.debug("  Applied to section '%s' of cell %s", sec_name, cell_id)
+        if cell_applied > 0:
+            n_cells += 1
+        n_sections += cell_applied
+
+    logger.info(
+        "Modification '%s' applied to %d sections across %d cells",
+        mod.name,
+        n_sections,
+        n_cells,
+    )
+    if n_sections == 0:
+        logger.warning(
+            "section '%s' applied to zero sections, "
+            "please check its section_configure for possible mistakes",
+            mod.name,
+        )
+
+
+def _apply_compartment_set(
+    cells: dict, mod: ModificationCompartmentSet, circuit_access
+) -> None:
+    """Apply compartment_set — exec section_configure on resolved segments."""
+    logger.info(
+        "Applying modification '%s' (type=compartment_set) to compartment_set '%s'",
+        mod.name,
+        mod.compartment_set,
+    )
+
+    # Load compartment sets
+    try:
+        compartment_sets = circuit_access.config.get_compartment_sets()
+    except ValueError as e:
+        logger.warning(
+            "compartment_set '%s': cannot load compartment_sets_file: %s",
+            mod.name,
+            e,
+        )
+        return
+
+    comp_name = mod.compartment_set
+    if comp_name not in compartment_sets:
+        raise ValueError(
+            f"compartment_set modification '{mod.name}': compartment set "
+            f"'{comp_name}' not found in compartment_sets file."
+        )
+    comp_entry = compartment_sets[comp_name]
+    comp_nodes = comp_entry.get("compartment_set", [])
+    population_name = comp_entry.get("population")
+
+    # Parse section_configure — bare format: "attr = value"
+    # Prefix with "seg." to make it executable
+    config_str = re.sub(r"(\b\w+)\s*=", r"seg.\1 =", mod.section_configure)
+    # But we need to be careful: only LHS identifiers should be prefixed.
+    # Better approach: use ast to parse and validate
+    # For compartment_set, the format is "attr = value [; attr = value ...]"
+    # We prefix each bare assignment target with "seg."
+    statements = [s.strip() for s in mod.section_configure.split(";") if s.strip()]
+    prefixed_parts = []
+    all_attrs: set[str] = set()
+    for stmt in statements:
+        prefixed = "seg." + stmt.strip()
+        prefixed_parts.append(prefixed)
+    config_str = "; ".join(prefixed_parts)
+
+    # Parse to collect attrs
+    collector = _AttributeCollector()
+    tree = ast.parse(config_str)
+    for elem in tree.body:
+        _validate_assignment(elem)
+        collector.visit(elem)
+    all_attrs = collector.attrs
+
+    n_cells = 0
+    n_segments = 0
+    for cell_id in cells:
+        cell = cells[cell_id]
+        node_id = cell_id.id if hasattr(cell_id, "id") else cell_id
+
+        if (
+            population_name is not None
+            and getattr(cell_id, "population_name", None) != population_name
+        ):
+            continue
+
+        try:
+            resolved = cell.resolve_segments_from_compartment_set(node_id, comp_nodes)
+        except (ValueError, TypeError) as e:
+            logger.warning(
+                "compartment_set '%s': failed to resolve segments for cell %s, skipping: %s",
+                mod.name,
+                cell_id,
+                e,
+            )
+            continue
+
+        cell_applied = 0
+        for section, sec_name, seg_x in resolved:
+            segment = section(seg_x)
+            if all(hasattr(segment, attr) for attr in all_attrs):
+                exec(config_str, {"__builtins__": None}, {"seg": segment})  # noqa: S102
+                cell_applied += 1
+                logger.debug(
+                    "  Applied to segment '%s(%s)' of cell %s", sec_name, seg_x, cell_id
+                )
+        if cell_applied > 0:
+            n_cells += 1
+        n_segments += cell_applied
+
+    logger.info(
+        "Modification '%s' applied to %d segments across %d cells",
+        mod.name,
+        n_segments,
+        n_cells,
+    )
+    if n_segments == 0:
+        logger.warning(
+            "compartment_set '%s' applied to zero segments, "
+            "please check its section_configure for possible mistakes",
+            mod.name,
+        )
diff --git a/bluecellulab/simulation/neuron_globals.py b/bluecellulab/simulation/neuron_globals.py
index 2305790b..20236797 100644
--- a/bluecellulab/simulation/neuron_globals.py
+++ b/bluecellulab/simulation/neuron_globals.py
@@ -13,12 +13,15 @@
 # limitations under the License.
 """Module that handles the global NEURON parameters."""
 
+import logging
 from typing import Optional
 from typing import NamedTuple
 import neuron
 from bluecellulab.circuit.config.sections import Conditions, MechanismConditions
 from bluecellulab.exceptions import error_context
 
+logger = logging.getLogger(__name__)
+
 
 def set_global_condition_parameters(condition_parameters: Conditions) -> None:
     """Sets the global condition parameters in NEURON objects if GluSynapse is
@@ -35,14 +38,31 @@ def set_global_condition_parameters(condition_parameters: Conditions) -> None:
         set_minis_single_vesicle_values(mechanism_conditions)
         set_init_depleted_values(mechanism_conditions)
 
+    # Apply all mechanism variables generically (matching neurodamus behavior)
+    if condition_parameters.mechanisms:
+        for suffix, variables in condition_parameters.mechanisms.items():
+            for var_name, value in variables.items():
+                global_name = f"{var_name}_{suffix}"
+                if hasattr(neuron.h, global_name):
+                    setattr(neuron.h, global_name, value)
+                    logger.debug("Set NEURON global %s = %s", global_name, value)
+
 
 def set_init_depleted_values(mech_conditions: MechanismConditions) -> None:
     """Set the init_depleted values in NEURON."""
     with error_context("mechanism/s for init_depleted need to be compiled"):
-        if mech_conditions.glusynapse and mech_conditions.glusynapse.init_depleted is not None:
+        if (
+            mech_conditions.glusynapse
+            and mech_conditions.glusynapse.init_depleted is not None
+        ):
             neuron.h.init_depleted_GluSynapse = mech_conditions.glusynapse.init_depleted
-        if mech_conditions.ampanmda and mech_conditions.ampanmda.init_depleted is not None:
-            neuron.h.init_depleted_ProbAMPANMDA_EMS = mech_conditions.ampanmda.init_depleted
+        if (
+            mech_conditions.ampanmda
+            and mech_conditions.ampanmda.init_depleted is not None
+        ):
+            neuron.h.init_depleted_ProbAMPANMDA_EMS = (
+                mech_conditions.ampanmda.init_depleted
+            )
         if mech_conditions.gabaab and mech_conditions.gabaab.init_depleted is not None:
             neuron.h.init_depleted_ProbGABAAB_EMS = mech_conditions.gabaab.init_depleted
 
@@ -50,15 +70,24 @@ def set_init_depleted_values(mech_conditions: MechanismConditions) -> None:
 def set_minis_single_vesicle_values(mech_conditions: MechanismConditions) -> None:
     """Set the minis_single_vesicle values in NEURON."""
     with error_context("mechanism/s for minis_single_vesicle need to be compiled"):
-        if mech_conditions.ampanmda and mech_conditions.ampanmda.minis_single_vesicle is not None:
+        if (
+            mech_conditions.ampanmda
+            and mech_conditions.ampanmda.minis_single_vesicle is not None
+        ):
             neuron.h.minis_single_vesicle_ProbAMPANMDA_EMS = (
                 mech_conditions.ampanmda.minis_single_vesicle
             )
-        if mech_conditions.gabaab and mech_conditions.gabaab.minis_single_vesicle is not None:
+        if (
+            mech_conditions.gabaab
+            and mech_conditions.gabaab.minis_single_vesicle is not None
+        ):
             neuron.h.minis_single_vesicle_ProbGABAAB_EMS = (
                 mech_conditions.gabaab.minis_single_vesicle
             )
-        if mech_conditions.glusynapse and mech_conditions.glusynapse.minis_single_vesicle is not None:
+        if (
+            mech_conditions.glusynapse
+            and mech_conditions.glusynapse.minis_single_vesicle is not None
+        ):
             neuron.h.minis_single_vesicle_GluSynapse = (
                 mech_conditions.glusynapse.minis_single_vesicle
             )
@@ -73,7 +102,7 @@ class NeuronGlobals:
     _instance = None
 
     def __init__(self):
-        raise RuntimeError('Call get_instance() instead')
+        raise RuntimeError("Call get_instance() instead")
 
     @classmethod
     def get_instance(cls):
@@ -112,7 +141,9 @@ def load_params(self, params: NeuronGlobalParams) -> None:
         self.v_init = params.v_init
 
 
-def set_neuron_globals(temperature: Optional[float] = 34.0, v_init: Optional[float] = -80.0) -> None:
+def set_neuron_globals(
+    temperature: Optional[float] = 34.0, v_init: Optional[float] = -80.0
+) -> None:
     """Set the global NEURON parameters."""
     if temperature is None and v_init is None:
         return
diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json
new file mode 100644
index 00000000..e5a1a295
--- /dev/null
+++ b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json
@@ -0,0 +1,45 @@
+{
+    "manifest": {
+      "$OUTPUT_DIR": "./output_sonata_modifications",
+      "$INPUT_DIR": "./input/"
+    },
+    "run": {
+      "tstart": 0.0,
+      "tstop": 100.0,
+      "dt": 0.025,
+      "random_seed": 1,
+      "spike_threshold": -30
+    },
+    "conditions": {
+      "v_init": -65,
+      "modifications": [
+        {
+          "name": "TTX_block_NodeB",
+          "type": "ttx",
+          "node_set": "Mosaic_B"
+        },
+        {
+          "name": "double_cm_all",
+          "type": "configure_all_sections",
+          "node_set": "Mosaic_A",
+          "section_configure": "%s.cm = 2.0"
+        },
+        {
+          "name": "scale_soma_cm",
+          "type": "section_list",
+          "node_set": "Mosaic_A",
+          "section_configure": "somatic.cm *= 1.5"
+        }
+      ]
+    },
+    "target_simulator": "NEURON",
+    "network": "circuit_sonata.json",
+    "node_set": "Mosaic_A",
+    "output": {
+      "output_dir": "$OUTPUT_DIR",
+      "spikes_file": "out.h5",
+      "spikes_sort_order": "by_time"
+    },
+    "inputs": {},
+    "reports": {}
+  }
diff --git a/examples/2-sonata-network/sonata-modifications.ipynb b/examples/2-sonata-network/sonata-modifications.ipynb
new file mode 100644
index 00000000..bf960420
--- /dev/null
+++ b/examples/2-sonata-network/sonata-modifications.ipynb
@@ -0,0 +1,334 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# SONATA Condition Modifications\n",
+    "\n",
+    "This notebook demonstrates how to use SONATA **condition modifications** in BlueCelluLab.\n",
+    "\n",
+    "Modifications are defined in the `conditions` block of a SONATA simulation config and allow you to\n",
+    "alter cell properties before the simulation runs. BlueCelluLab supports all five SONATA modification types:\n",
+    "\n",
+    "| Type | Description |\n",
+    "|------|-------------|\n",
+    "| `ttx` | Block Na channels (insert TTXDynamicsSwitch) |\n",
+    "| `configure_all_sections` | Apply a statement to all sections of target cells |\n",
+    "| `section_list` | Apply a statement to a named section list (somatic, basal, apical, axonal) |\n",
+    "| `section` | Apply a statement to specific named sections (e.g. apic[10]) |\n",
+    "| `compartment_set` | Apply a statement to segments defined by a compartment set |\n",
+    "\n",
+    "See the [SONATA-extension documentation](https://sonata-extension.readthedocs.io/en/latest/sonata_simulation.html#parameters-required-for-modifications) for the full specification."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1. Compile mechanisms\n",
+    "\n",
+    "As in the previous tutorial, we first compile the NEURON mechanisms."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!nrnivmodl ../mechanisms"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "import logging\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "from bluecellulab import CircuitSimulation\n",
+    "from bluecellulab.circuit.config import SonataSimulationConfig"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Enable INFO logging for the modifications module to see what happens\n",
+    "logging.basicConfig(level=logging.WARNING)\n",
+    "logging.getLogger(\"bluecellulab.simulation.modifications\").setLevel(logging.INFO)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Examine the simulation config with modifications\n",
+    "\n",
+    "We have prepared a simulation config that includes three modifications in its `conditions` block."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim_config_path = Path(\"sim_quick_scx_sonata_multicircuit\") / \"simulation_config_modifications.json\"\n",
+    "\n",
+    "with open(sim_config_path) as f:\n",
+    "    config_dict = json.load(f)\n",
+    "\n",
+    "print(json.dumps(config_dict[\"conditions\"], indent=4))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The three modifications are:\n",
+    "\n",
+    "1. **`TTX_block_NodeB`** (`ttx`): Blocks Na channels on all cells in the `Mosaic_B` node set by inserting `TTXDynamicsSwitch`.\n",
+    "2. **`double_cm_all`** (`configure_all_sections`): Doubles membrane capacitance (`cm = 2.0`) on **all** sections of `Mosaic_A` cells.\n",
+    "3. **`scale_soma_cm`** (`section_list`): Further scales `cm` by 1.5x on only the **somatic** sections of `Mosaic_A` cells.\n",
+    "\n",
+    "After both modifications, somatic sections of Mosaic_A cells will have `cm = 2.0 * 1.5 = 3.0`, while dendritic/axonal sections will have `cm = 2.0`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Parse modifications with BlueCelluLab\n",
+    "\n",
+    "BlueCelluLab parses the modifications into typed dataclasses via `get_modifications()`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sonata_config = SonataSimulationConfig(sim_config_path)\n",
+    "modifications = sonata_config.get_modifications()\n",
+    "\n",
+    "for mod in modifications:\n",
+    "    print(f\"  {mod.name}: type={mod.type}, class={type(mod).__name__}\")\n",
+    "    if hasattr(mod, 'section_configure'):\n",
+    "        print(f\"    section_configure: {mod.section_configure}\")\n",
+    "    if hasattr(mod, 'node_set'):\n",
+    "        print(f\"    node_set: {mod.node_set}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 4. Run simulation with modifications\n",
+    "\n",
+    "When `CircuitSimulation.instantiate_gids()` is called, modifications are automatically applied after cells are created but before synapses and stimuli are added. This matches the ordering used by [neurodamus](https://github.com/openbraininstitute/neurodamus).\n",
+    "\n",
+    "The INFO-level logs show exactly which modifications were applied and to how many sections/cells."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim = CircuitSimulation(sim_config_path)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from bluepysnap import Simulation as snap_sim\n",
+    "import pandas as pd\n",
+    "\n",
+    "snap_access = snap_sim(sim_config_path)\n",
+    "all_nodes = pd.concat([x[1] for x in snap_access.circuit.nodes.get()])\n",
+    "all_cell_ids = all_nodes.index.to_list()\n",
+    "print(f\"All cells in circuit: {all_cell_ids}\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Instantiate all cells — modifications are applied automatically\n",
+    "sim.instantiate_gids(all_cell_ids, add_stimuli=False, add_synapses=False)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 5. Verify modifications were applied\n",
+    "\n",
+    "Let's inspect the cells to confirm the modifications took effect."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print(\"=\" * 70)\n",
+    "print(\"Checking membrane capacitance (cm) on Mosaic_A cells\")\n",
+    "print(\"Expected: somatic cm=3.0 (2.0 * 1.5), dendritic cm=2.0\")\n",
+    "print(\"=\" * 70)\n",
+    "\n",
+    "for cell_id in sim.cells:\n",
+    "    cell = sim.cells[cell_id]\n",
+    "    print(f\"\\nCell {cell_id}:\")\n",
+    "\n",
+    "    # Check soma cm\n",
+    "    if cell.somatic:\n",
+    "        soma_sec = cell.somatic[0]\n",
+    "        print(f\"  soma cm = {soma_sec.cm}\")\n",
+    "\n",
+    "    # Check a dendritic section cm (if available)\n",
+    "    for sec_name, sec in list(cell.sections.items())[:5]:\n",
+    "        if 'dend' in sec_name or 'apic' in sec_name:\n",
+    "            print(f\"  {sec_name} cm = {sec.cm}\")\n",
+    "            break"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 6. Compare: with vs without modifications\n",
+    "\n",
+    "To see the effect of modifications on simulation output, let's run two simulations\n",
+    "side by side — one with and one without modifications — and compare the voltage traces."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Simulation WITH modifications (already instantiated above)\n",
+    "sim.run(t_stop=100.0)\n",
+    "traces_with_mods = {}\n",
+    "for cell_id in sim.cells:\n",
+    "    traces_with_mods[cell_id] = {\n",
+    "        \"time\": sim.get_time_trace(),\n",
+    "        \"voltage\": sim.get_voltage_trace(cell_id),\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Simulation WITHOUT modifications (baseline)\n",
+    "baseline_config = Path(\"sim_quick_scx_sonata_multicircuit\") / \"simulation_config_noinput.json\"\n",
+    "sim_baseline = CircuitSimulation(baseline_config)\n",
+    "sim_baseline.instantiate_gids(all_cell_ids, add_stimuli=False, add_synapses=False)\n",
+    "sim_baseline.run(t_stop=100.0)\n",
+    "traces_baseline = {}\n",
+    "for cell_id in sim_baseline.cells:\n",
+    "    traces_baseline[cell_id] = {\n",
+    "        \"time\": sim_baseline.get_time_trace(),\n",
+    "        \"voltage\": sim_baseline.get_voltage_trace(cell_id),\n",
+    "    }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot comparison\n",
+    "fig, axes = plt.subplots(len(sim.cells), 1, figsize=(12, 3 * len(sim.cells)), sharex=True)\n",
+    "if len(sim.cells) == 1:\n",
+    "    axes = [axes]\n",
+    "\n",
+    "for ax, cell_id in zip(axes, sim.cells):\n",
+    "    if cell_id in traces_baseline:\n",
+    "        ax.plot(traces_baseline[cell_id][\"time\"], traces_baseline[cell_id][\"voltage\"],\n",
+    "                label=\"baseline\", alpha=0.8)\n",
+    "    if cell_id in traces_with_mods:\n",
+    "        ax.plot(traces_with_mods[cell_id][\"time\"], traces_with_mods[cell_id][\"voltage\"],\n",
+    "                label=\"with modifications\", alpha=0.8, linestyle=\"--\")\n",
+    "    ax.set_ylabel(\"Voltage (mV)\")\n",
+    "    ax.set_title(str(cell_id))\n",
+    "    ax.legend(loc=\"upper right\")\n",
+    "\n",
+    "axes[-1].set_xlabel(\"Time (ms)\")\n",
+    "plt.tight_layout()\n",
+    "plt.savefig(\"ex2_modifications_comparison.pdf\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 7. Graceful skipping behavior\n",
+    "\n",
+    "An important design decision: modifications **skip** sections or cells that don't match,\n",
+    "rather than failing. This is essential because `node_set` targets can contain heterogeneous\n",
+    "cells (e.g., some with apical dendrites, some without).\n",
+    "\n",
+    "- Sections missing a referenced attribute are silently skipped\n",
+    "- If zero sections matched, a warning is logged\n",
+    "- Invalid `section_configure` syntax still raises an error\n",
+    "\n",
+    "This matches [neurodamus's behavior](https://github.com/openbraininstitute/neurodamus) for `configure_all_sections`\n",
+    "and extends it consistently to the new types (`section_list`, `section`, `compartment_set`)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "- Modifications are defined in `conditions.modifications` of the SONATA simulation config\n",
+    "- BlueCelluLab parses them via `SonataSimulationConfig.get_modifications()`\n",
+    "- They are automatically applied during `CircuitSimulation.instantiate_gids()`, after cell creation\n",
+    "- All five types are supported: `ttx`, `configure_all_sections`, `section_list`, `section`, `compartment_set`\n",
+    "- Logging at INFO level shows what was applied; WARNING level flags zero-match cases"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/pyproject.toml b/pyproject.toml
index 75a4c699..3b439f08 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -33,6 +33,7 @@ dependencies = [
     "matplotlib>=3.0.0,<4.0.0",
     "pandas>=1.0.0,<3.0.0",
     "bluepysnap>=3.0.0,<4.0.0",
+    "libsonata>=0.1.34",
     "pydantic>=2.5.2,<3.0.0",
     "typing-extensions>=4.8.0",
     "networkx>=3.1",
diff --git a/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json b/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json
new file mode 100644
index 00000000..08196b71
--- /dev/null
+++ b/tests/examples/sim_quick_scx_sonata_multicircuit/simulation_config_modifications.json
@@ -0,0 +1,38 @@
+{
+    "manifest": {
+      "$CIRCUIT_DIR": "usecase3",
+      "$OUTPUT_DIR": "."
+    },
+    "run": {
+      "tstop": 50.0,
+      "dt": 0.025,
+      "random_seed": 1
+    },
+    "conditions": {
+      "v_init": -65,
+      "modifications": [
+        {
+          "name": "TTX_block",
+          "type": "ttx",
+          "node_set": "Mosaic_A"
+        },
+        {
+          "name": "configure_all",
+          "type": "configure_all_sections",
+          "node_set": "Mosaic_A",
+          "section_configure": "%s.cm = 2.0"
+        }
+      ]
+    },
+    "target_simulator": "NEURON",
+    "network": "circuit_sonata.json",
+    "node_set": "Mosaic_A",
+    "compartment_sets_file": "compartment_sets.json",
+    "output": {
+      "output_dir": "$OUTPUT_DIR/output_sonata_modifications",
+      "spikes_file": "out.h5",
+      "spikes_sort_order": "by_time"
+    },
+    "inputs": {},
+    "reports": {}
+  }
diff --git a/tests/test_circuit/test_simulation_config.py b/tests/test_circuit/test_simulation_config.py
index 4b38a867..d5816e05 100644
--- a/tests/test_circuit/test_simulation_config.py
+++ b/tests/test_circuit/test_simulation_config.py
@@ -26,7 +26,17 @@
     ConnectionOverrides,
     MechanismConditions,
 )
-from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, Hyperpolarizing, Linear, Pulse, RelativeLinear, ShotNoise, RelativeShotNoise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
+    Noise,
+    Hyperpolarizing,
+    Linear,
+    Pulse,
+    RelativeLinear,
+    ShotNoise,
+    RelativeShotNoise,
+    OrnsteinUhlenbeck,
+    RelativeOrnsteinUhlenbeck,
+)
 from tests.helpers.os_utils import cwd
 
 
@@ -73,15 +83,32 @@ def test_init_with_invalid_type():
 
 def test_get_all_stimuli_entries():
     sim = SonataSimulationConfig(multi_input_conf_path)
-    noise_stim = Noise(target="Mosaic_A", delay=10.0, duration=20.0, mean_percent=200.0, variance=0.001, node_set="Mosaic_A",)
+    noise_stim = Noise(
+        target="Mosaic_A",
+        delay=10.0,
+        duration=20.0,
+        mean_percent=200.0,
+        variance=0.001,
+        node_set="Mosaic_A",
+    )
     hyper_stim = Hyperpolarizing("Mosaic_A", 0.0, 50.0, node_set="Mosaic_A")
     pulse_stim = Pulse("Mosaic_A", 10.0, 20.0, 0.1, 25, 10, node_set="Mosaic_A")
     linear_stim = Linear("Mosaic_A", 10.0, 20.0, 0.1, 0.4, node_set="Mosaic_A")
-    relative_linear_stim = RelativeLinear("Mosaic_A", 10.0, 20.0, 50, 100, node_set="Mosaic_A")
-    shot_noise_stim = ShotNoise("Mosaic_A", 10.0, 20, 2, 5, 10, 0.1, 0.02, 0.25, 42, node_set="Mosaic_A")
-    relative_shot_noise_stim = RelativeShotNoise("Mosaic_A", 10.0, 20, 2, 5, 50, 10, 0.5, 0.25, 42, node_set="Mosaic_A")
-    ornstein_uhlenbeck_stim = OrnsteinUhlenbeck("Mosaic_A", 10.0, 20.0, 5, 0.1, 0, 0.25, 42, node_set="Mosaic_A")
-    relative_ornstein_uhlenbeck_stim = RelativeOrnsteinUhlenbeck("Mosaic_A", 10.0, 20.0, 5, 50, 10, 0.25, 42, node_set="Mosaic_A")
+    relative_linear_stim = RelativeLinear(
+        "Mosaic_A", 10.0, 20.0, 50, 100, node_set="Mosaic_A"
+    )
+    shot_noise_stim = ShotNoise(
+        "Mosaic_A", 10.0, 20, 2, 5, 10, 0.1, 0.02, 0.25, 42, node_set="Mosaic_A"
+    )
+    relative_shot_noise_stim = RelativeShotNoise(
+        "Mosaic_A", 10.0, 20, 2, 5, 50, 10, 0.5, 0.25, 42, node_set="Mosaic_A"
+    )
+    ornstein_uhlenbeck_stim = OrnsteinUhlenbeck(
+        "Mosaic_A", 10.0, 20.0, 5, 0.1, 0, 0.25, 42, node_set="Mosaic_A"
+    )
+    relative_ornstein_uhlenbeck_stim = RelativeOrnsteinUhlenbeck(
+        "Mosaic_A", 10.0, 20.0, 5, 50, 10, 0.25, 42, node_set="Mosaic_A"
+    )
     entries = sim.get_all_stimuli_entries()
     assert len(entries) == 9
     assert entries[0] == linear_stim
@@ -104,6 +131,11 @@ def test_condition_parameters():
             gabaab=ConditionEntry(minis_single_vesicle=None, init_depleted=None),
             glusynapse=ConditionEntry(minis_single_vesicle=None, init_depleted=None),
         ),
+        mechanisms={
+            "ProbAMPANMDA_EMS": {"init_depleted": True, "minis_single_vesicle": False},
+            "ProbGABAAB_EMS": {"property_x": 1, "property_y": 0.25},
+            "GluSynapse": {"property_z": "string"},
+        },
         celsius=34.0,
         v_init=-80.0,
         extracellular_calcium=None,
@@ -124,7 +156,10 @@ def test_connection_entries():
         synapse_configure=None,
         mod_override=None,
     )
-    assert entries[2].synapse_configure == "%s.NMDA_ratio = 1.22 %s.tau_r_NMDA = 3.9 %s.tau_d_NMDA = 148.5"
+    assert (
+        entries[2].synapse_configure
+        == "%s.NMDA_ratio = 1.22 %s.tau_r_NMDA = 3.9 %s.tau_d_NMDA = 148.5"
+    )
     assert entries[-1] == ConnectionOverrides(
         source="Excitatory",
         target="Mosaic",
@@ -132,7 +167,7 @@ def test_connection_entries():
         weight=None,
         spont_minis=None,
         synapse_configure="%s.mg = 1.0",
-        mod_override=None
+        mod_override=None,
     )
 
 
@@ -149,7 +184,7 @@ def test_connection_override():
         weight=2.0,
         spont_minis=0.1,
         synapse_configure="%s.mg = 1.4",
-        mod_override=None
+        mod_override=None,
     )
     sim.add_connection_override(connection_override)
 
@@ -252,12 +287,16 @@ def test_extracellular_calcium():
 
 def test_get_compartment_sets(tmp_path):
     file = tmp_path / "compartment_sets.json"
-    file.write_text(json.dumps({
-        "soma_set": {
-            "population": "Mosaic",
-            "compartment_set": [[0, "soma", 0.5]]
-        }
-    }))
+    file.write_text(
+        json.dumps(
+            {
+                "soma_set": {
+                    "population": "Mosaic",
+                    "compartment_set": [[0, "soma", 0.5]],
+                }
+            }
+        )
+    )
     sim = SonataSimulationConfig.__new__(SonataSimulationConfig)
     sim.impl = type("impl", (), {"config": {"compartment_sets_file": str(file)}})
     result = sim.get_compartment_sets()
@@ -268,36 +307,38 @@ def test_get_compartment_sets(tmp_path):
 def test_get_node_sets(tmp_path):
     # Circuit file content
     circuit_file = tmp_path / "circuit_node_sets.json"
-    circuit_file.write_text(json.dumps({
-        "set_from_circuit": {
-            "population": "PopA",
-            "node_id": [1, 2]
-        },
-        "overwritten_set": {
-            "population": "PopB",
-            "node_id": [3]
-        }
-    }))
+    circuit_file.write_text(
+        json.dumps(
+            {
+                "set_from_circuit": {"population": "PopA", "node_id": [1, 2]},
+                "overwritten_set": {"population": "PopB", "node_id": [3]},
+            }
+        )
+    )
 
     # Simulation file content
     sim_file = tmp_path / "sim_node_sets.json"
-    sim_file.write_text(json.dumps({
-        "overwritten_set": {
-            "population": "PopB",
-            "node_id": [99]
-        },
-        "set_from_sim": {
-            "population": "PopC",
-            "node_id": [4]
-        }
-    }))
+    sim_file.write_text(
+        json.dumps(
+            {
+                "overwritten_set": {"population": "PopB", "node_id": [99]},
+                "set_from_sim": {"population": "PopC", "node_id": [4]},
+            }
+        )
+    )
 
     # Simulates the SonataSimulationConfig instance
     sim = SonataSimulationConfig.__new__(SonataSimulationConfig)
-    sim.impl = type("impl", (), {
-        "circuit": type("circuit", (), {"config": {"node_sets_file": str(circuit_file)}})(),
-        "config": {"node_sets_file": str(sim_file)}
-    })
+    sim.impl = type(
+        "impl",
+        (),
+        {
+            "circuit": type(
+                "circuit", (), {"config": {"node_sets_file": str(circuit_file)}}
+            )(),
+            "config": {"node_sets_file": str(sim_file)},
+        },
+    )
 
     # Call method
     result = sim.get_node_sets()
@@ -305,68 +346,77 @@ def test_get_node_sets(tmp_path):
     # Validate merged result
     assert set(result) == {"set_from_circuit", "overwritten_set", "set_from_sim"}
     assert result["set_from_circuit"]["node_id"] == [1, 2]
-    assert result["overwritten_set"]["node_id"] == [99]  # Overwritten by simulation file
+    assert result["overwritten_set"]["node_id"] == [
+        99
+    ]  # Overwritten by simulation file
     assert result["set_from_sim"]["node_id"] == [4]
 
 
 def test_get_node_sets_only_circuit(tmp_path):
     circuit_file = tmp_path / "node_sets.json"
-    circuit_file.write_text(json.dumps({
-        "only_circuit": {
-            "population": "PopX",
-            "node_id": [5]
-        }
-    }))
+    circuit_file.write_text(
+        json.dumps({"only_circuit": {"population": "PopX", "node_id": [5]}})
+    )
     sim = SonataSimulationConfig.__new__(SonataSimulationConfig)
-    sim.impl = type("impl", (), {
-        "circuit": type("circuit", (), {"config": {"node_sets_file": str(circuit_file)}})(),
-        "config": {}
-    })
+    sim.impl = type(
+        "impl",
+        (),
+        {
+            "circuit": type(
+                "circuit", (), {"config": {"node_sets_file": str(circuit_file)}}
+            )(),
+            "config": {},
+        },
+    )
     result = sim.get_node_sets()
     assert "only_circuit" in result
 
 
 def test_get_node_sets_only_sim(tmp_path):
     sim_file = tmp_path / "node_sets.json"
-    sim_file.write_text(json.dumps({
-        "only_sim": {
-            "population": "PopY",
-            "node_id": [6]
-        }
-    }))
+    sim_file.write_text(
+        json.dumps({"only_sim": {"population": "PopY", "node_id": [6]}})
+    )
     sim = SonataSimulationConfig.__new__(SonataSimulationConfig)
-    sim.impl = type("impl", (), {
-        "circuit": type("circuit", (), {"config": {}})(),
-        "config": {"node_sets_file": str(sim_file)}
-    })
+    sim.impl = type(
+        "impl",
+        (),
+        {
+            "circuit": type("circuit", (), {"config": {}})(),
+            "config": {"node_sets_file": str(sim_file)},
+        },
+    )
     result = sim.get_node_sets()
     assert "only_sim" in result
 
 
 def test_get_node_sets_no_files():
     sim = SonataSimulationConfig.__new__(SonataSimulationConfig)
-    sim.impl = type("impl", (), {
-        "circuit": type("circuit", (), {"config": {}})(),
-        "config": {}
-    })
+    sim.impl = type(
+        "impl", (), {"circuit": type("circuit", (), {"config": {}})(), "config": {}}
+    )
     with pytest.raises(ValueError, match="No 'node_sets_file' found"):
         sim.get_node_sets()
 
 
 def test_get_report_entries():
     sim = SonataSimulationConfig.__new__(SonataSimulationConfig)
-    sim.impl = type("impl", (), {
-        "config": {
-            "reports": {
-                "soma_v": {
-                    "cells": "target_cells",
-                    "section": "soma",
-                    "variable_name": "v",
-                    "compartments": "center"
+    sim.impl = type(
+        "impl",
+        (),
+        {
+            "config": {
+                "reports": {
+                    "soma_v": {
+                        "cells": "target_cells",
+                        "section": "soma",
+                        "variable_name": "v",
+                        "compartments": "center",
+                    }
                 }
             }
-        }
-    })
+        },
+    )
     result = sim.get_report_entries()
     assert "soma_v" in result
     assert result["soma_v"]["variable_name"] == "v"
diff --git a/tests/test_simulation/test_modifications.py b/tests/test_simulation/test_modifications.py
new file mode 100644
index 00000000..287ad47b
--- /dev/null
+++ b/tests/test_simulation/test_modifications.py
@@ -0,0 +1,736 @@
+# Copyright 2023-2024 Blue Brain Project / EPFL
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Unit tests for bluecellulab/simulation/modifications.py."""
+
+from pathlib import Path
+from unittest import mock
+
+import pytest
+
+from bluecellulab.circuit.config.sections import (
+    ModificationBase,
+    ModificationCompartmentSet,
+    ModificationConfigureAllSections,
+    ModificationSection,
+    ModificationSectionList,
+    ModificationTTX,
+    modification_from_libsonata,
+)
+from bluecellulab.simulation.modifications import (
+    _apply_configure_all_sections,
+    _apply_section,
+    _apply_section_list,
+    _apply_ttx,
+    _exec_on_section,
+    apply_modifications,
+    parse_section_configure,
+)
+
+
+# ---- parse_section_configure tests ----
+
+
+class TestParseSectionConfigure:
+    def test_simple_assignment(self):
+        config, attrs = parse_section_configure("%s.cm = 2.0")
+        assert config == "sec.cm = 2.0"
+        assert attrs == {"cm"}
+
+    def test_multiple_assignments(self):
+        config, attrs = parse_section_configure("%s.gbar = 0; %s.cm = 1.5")
+        assert "sec.gbar = 0" in config
+        assert "sec.cm = 1.5" in config
+        assert attrs == {"gbar", "cm"}
+
+    def test_augmented_assignment(self):
+        config, attrs = parse_section_configure("%s.gbar *= 0.5")
+        assert config == "sec.gbar *= 0.5"
+        assert "gbar" in attrs
+
+    def test_invalid_non_assignment(self):
+        with pytest.raises(ValueError, match="assignments"):
+            parse_section_configure("%s.gbar")
+
+    def test_invalid_no_placeholder(self):
+        with pytest.raises(Exception):
+            parse_section_configure("gbar = 0")
+
+
+# ---- _exec_on_section tests ----
+
+
+class TestExecOnSection:
+    def test_applies_when_attr_exists(self):
+        section = mock.MagicMock()
+        section.cm = 1.0
+        result = _exec_on_section("sec.cm = 2.0", section, {"cm"})
+        assert result is True
+        assert section.cm == 2.0
+
+    def test_skips_when_attr_missing(self):
+        section = mock.MagicMock(spec=[])  # no attributes
+        result = _exec_on_section("sec.cm = 2.0", section, {"cm"})
+        assert result is False
+
+
+# ---- modification_from_libsonata tests ----
+
+
+class TestModificationFromLibsonata:
+    def _make_mock(self, type_name, **kwargs):
+        m = mock.MagicMock()
+        m.type.name = type_name
+        m.name = kwargs.get("name", "test_mod")
+        if "node_set" in kwargs:
+            m.node_set = kwargs["node_set"]
+        if "section_configure" in kwargs:
+            m.section_configure = kwargs["section_configure"]
+        if "compartment_set" in kwargs:
+            m.compartment_set = kwargs["compartment_set"]
+        return m
+
+    def test_ttx(self):
+        mod = self._make_mock("ttx", node_set="target")
+        result = modification_from_libsonata(mod)
+        assert isinstance(result, ModificationTTX)
+        assert result.name == "test_mod"
+        assert result.node_set == "target"
+
+    def test_configure_all_sections(self):
+        mod = self._make_mock(
+            "configure_all_sections", node_set="target", section_configure="%s.cm = 2"
+        )
+        result = modification_from_libsonata(mod)
+        assert isinstance(result, ModificationConfigureAllSections)
+        assert result.section_configure == "%s.cm = 2"
+
+    def test_section_list(self):
+        mod = self._make_mock(
+            "section_list", node_set="target", section_configure="apical.gbar = 0"
+        )
+        result = modification_from_libsonata(mod)
+        assert isinstance(result, ModificationSectionList)
+
+    def test_section(self):
+        mod = self._make_mock(
+            "section", node_set="target", section_configure="apic[10].gbar = 0"
+        )
+        result = modification_from_libsonata(mod)
+        assert isinstance(result, ModificationSection)
+
+    def test_compartment_set(self):
+        mod = self._make_mock(
+            "compartment_set", compartment_set="my_set", section_configure="gbar = 1.5"
+        )
+        result = modification_from_libsonata(mod)
+        assert isinstance(result, ModificationCompartmentSet)
+        assert result.compartment_set == "my_set"
+
+    def test_unknown_type(self):
+        mod = self._make_mock("unknown_type")
+        with pytest.raises(ValueError, match="Unknown modification type"):
+            modification_from_libsonata(mod)
+
+
+# ---- Handler tests with mocked cells ----
+
+
+def _make_mock_cell(sections=None, section_lists=None, enable_ttx=True):
+    """Create a mock cell with sections and optional section lists."""
+    cell = mock.MagicMock()
+    if sections is None:
+        sections = {}
+    cell.sections = sections
+
+    # Section list properties
+    for list_name in ["somatic", "basal", "apical", "axonal"]:
+        if section_lists and list_name in section_lists:
+            setattr(
+                type(cell),
+                list_name,
+                mock.PropertyMock(return_value=section_lists[list_name]),
+            )
+        else:
+            setattr(type(cell), list_name, mock.PropertyMock(return_value=[]))
+
+    if enable_ttx:
+        cell.enable_ttx = mock.MagicMock()
+    return cell
+
+
+def _make_mock_section(name="soma[0]", attrs=None):
+    """Create a mock NEURON section with given attributes."""
+    section = mock.MagicMock()
+    section.name.return_value = f"Cell.{name}"
+    if attrs:
+        for k, v in attrs.items():
+            setattr(section, k, v)
+    return section
+
+
+def _make_circuit_access(target_cell_ids=None):
+    """Create a mock circuit access."""
+    ca = mock.MagicMock()
+    if target_cell_ids is not None:
+        ca.get_target_cell_ids.return_value = set(target_cell_ids)
+    return ca
+
+
+class TestApplyTTX:
+    def test_enables_ttx_on_target_cells(self):
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell()
+        cells = {cell_id: cell}
+        mod = ModificationTTX(name="block", type="ttx", node_set="target")
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        _apply_ttx(cells, mod, ca)
+        cell.enable_ttx.assert_called_once()
+
+    def test_zero_match_warning(self, caplog):
+        import logging
+
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell()
+        cells = {cell_id: cell}
+        mod = ModificationTTX(name="block", type="ttx", node_set="empty")
+        ca = _make_circuit_access(target_cell_ids=[])
+
+        with caplog.at_level(logging.WARNING):
+            _apply_ttx(cells, mod, ca)
+        assert "matched zero cells" in caplog.text
+
+
+class TestApplyConfigureAllSections:
+    def test_applies_to_matching_sections(self):
+        sec1 = _make_mock_section("soma[0]", {"cm": 1.0})
+        sec2 = _make_mock_section("dend[0]", {"cm": 1.0})
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(sections={"soma[0]": sec1, "dend[0]": sec2})
+        cells = {cell_id: cell}
+        mod = ModificationConfigureAllSections(
+            name="set_cm",
+            type="configure_all_sections",
+            node_set="target",
+            section_configure="%s.cm = 2.0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        _apply_configure_all_sections(cells, mod, ca)
+        assert sec1.cm == 2.0
+        assert sec2.cm == 2.0
+
+    def test_skips_sections_missing_attr(self):
+        sec1 = _make_mock_section("soma[0]", {"cm": 1.0})
+        # Create a section that explicitly lacks the 'cm' attribute
+        sec2 = _make_mock_section("dend[0]")
+        del sec2.cm  # remove the auto-created attribute
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(sections={"soma[0]": sec1, "dend[0]": sec2})
+        cells = {cell_id: cell}
+        mod = ModificationConfigureAllSections(
+            name="set_cm",
+            type="configure_all_sections",
+            node_set="target",
+            section_configure="%s.cm = 2.0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        _apply_configure_all_sections(cells, mod, ca)
+        assert sec1.cm == 2.0
+        # sec2 should not have cm set since it was missing
+        assert not hasattr(sec2, "cm")
+
+
+class TestApplySectionList:
+    def test_applies_to_section_list(self):
+        sec = _make_mock_section("apic[0]", {"gbar": 1.0})
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(
+            sections={"apic[0]": sec},
+            section_lists={"apical": [sec]},
+        )
+        cells = {cell_id: cell}
+        mod = ModificationSectionList(
+            name="no_gbar",
+            type="section_list",
+            node_set="target",
+            section_configure="apical.gbar = 0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        _apply_section_list(cells, mod, ca)
+        assert sec.gbar == 0
+
+    def test_warns_empty_section_list(self, caplog):
+        import logging
+
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(section_lists={"apical": []})
+        cells = {cell_id: cell}
+        mod = ModificationSectionList(
+            name="no_gbar",
+            type="section_list",
+            node_set="target",
+            section_configure="apical.gbar = 0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        with caplog.at_level(logging.WARNING):
+            _apply_section_list(cells, mod, ca)
+        assert "no 'apical' sections" in caplog.text
+
+    def test_unknown_list_name_raises(self):
+        mod = ModificationSectionList(
+            name="bad",
+            type="section_list",
+            node_set="target",
+            section_configure="unknown_list.gbar = 0",
+        )
+        with pytest.raises(ValueError, match="unknown section list name"):
+            _apply_section_list({}, mod, _make_circuit_access([]))
+
+
+class TestApplySection:
+    def test_applies_to_named_section(self):
+        sec = _make_mock_section("apic[10]", {"gbar": 1.0})
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(sections={"apic[10]": sec})
+        cell.get_section.return_value = sec
+        cells = {cell_id: cell}
+        mod = ModificationSection(
+            name="set_gbar",
+            type="section",
+            node_set="target",
+            section_configure="apic[10].gbar = 0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        _apply_section(cells, mod, ca)
+        assert sec.gbar == 0
+
+    def test_warns_missing_section(self, caplog):
+        import logging
+
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell()
+        cell.get_section.side_effect = ValueError("not found")
+        cells = {cell_id: cell}
+        mod = ModificationSection(
+            name="set_gbar",
+            type="section",
+            node_set="target",
+            section_configure="apic[10].gbar = 0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        with caplog.at_level(logging.WARNING):
+            _apply_section(cells, mod, ca)
+        assert "does not have section" in caplog.text
+
+
+class TestApplyConfigureAllSectionsZeroMatch:
+    def test_warns_zero_sections(self, caplog):
+        import logging
+
+        cell_id = mock.MagicMock()
+        # Cell with sections that all lack the referenced attribute
+        sec = _make_mock_section("soma[0]")
+        del sec.nonexistent_attr
+        cell = _make_mock_cell(sections={"soma[0]": sec})
+        cells = {cell_id: cell}
+        mod = ModificationConfigureAllSections(
+            name="zero_match",
+            type="configure_all_sections",
+            node_set="target",
+            section_configure="%s.nonexistent_attr = 1",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        with caplog.at_level(logging.WARNING):
+            _apply_configure_all_sections(cells, mod, ca)
+        assert "applied to zero sections" in caplog.text
+
+
+class _CellWithoutApical:
+    """Helper cell-like object that raises AttributeError for 'apical'."""
+
+    sections = {}
+
+    @property
+    def apical(self):
+        raise AttributeError("no apical property")
+
+
+class TestApplySectionListAttributeError:
+    def test_warns_missing_property(self, caplog):
+        """Test the AttributeError branch when cell lacks the section list property."""
+        import logging
+
+        cell_id = mock.MagicMock()
+        cell = _CellWithoutApical()
+        cells = {cell_id: cell}
+        mod = ModificationSectionList(
+            name="no_prop",
+            type="section_list",
+            node_set="target",
+            section_configure="apical.gbar = 0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        with caplog.at_level(logging.WARNING):
+            _apply_section_list(cells, mod, ca)
+        assert "has no 'apical' property" in caplog.text
+
+    def test_invalid_section_configure_raises(self):
+        mod = ModificationSectionList(
+            name="bad",
+            type="section_list",
+            node_set="target",
+            section_configure="= 0",
+        )
+        with pytest.raises(ValueError):
+            _apply_section_list({}, mod, _make_circuit_access([]))
+
+
+class TestApplySectionEdgeCases:
+    def test_invalid_section_configure_raises(self):
+        mod = ModificationSection(
+            name="bad",
+            type="section",
+            node_set="target",
+            section_configure="gbar = 0",  # no section[idx]. prefix
+        )
+        with pytest.raises(ValueError, match="cannot extract section name"):
+            _apply_section({}, mod, _make_circuit_access([]))
+
+    def test_zero_match_warning(self, caplog):
+        import logging
+
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell()
+        cell.get_section.side_effect = ValueError("not found")
+        cells = {cell_id: cell}
+        mod = ModificationSection(
+            name="zero",
+            type="section",
+            node_set="target",
+            section_configure="apic[10].gbar = 0",
+        )
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        with caplog.at_level(logging.WARNING):
+            _apply_section(cells, mod, ca)
+        assert "applied to zero sections" in caplog.text
+
+
+class TestApplyCompartmentSet:
+    def _make_segment(self, attrs=None):
+        seg = mock.MagicMock()
+        if attrs:
+            for k, v in attrs.items():
+                setattr(seg, k, v)
+        return seg
+
+    def test_applies_to_resolved_segments(self):
+        from bluecellulab.simulation.modifications import _apply_compartment_set
+
+        cell_id = mock.MagicMock()
+        cell_id.id = 0
+        cell_id.population_name = "NodeA"
+
+        seg = self._make_segment({"gbar": 1.0})
+        section = mock.MagicMock()
+        section.return_value = seg  # section(seg_x) returns the segment
+        section.name.return_value = "Cell.soma[0]"
+
+        cell = mock.MagicMock()
+        cell.resolve_segments_from_compartment_set.return_value = [
+            (section, "soma[0]", 0.5)
+        ]
+        cells = {cell_id: cell}
+
+        ca = mock.MagicMock()
+        ca.config.get_compartment_sets.return_value = {
+            "my_set": {
+                "population": "NodeA",
+                "compartment_set": [[0, "soma[0]", 0.5]],
+            }
+        }
+
+        mod = ModificationCompartmentSet(
+            name="set_gbar",
+            type="compartment_set",
+            compartment_set="my_set",
+            section_configure="gbar = 0.5",
+        )
+        _apply_compartment_set(cells, mod, ca)
+        assert seg.gbar == 0.5
+
+    def test_warns_missing_compartment_sets_file(self, caplog):
+        import logging
+        from bluecellulab.simulation.modifications import _apply_compartment_set
+
+        ca = mock.MagicMock()
+        ca.config.get_compartment_sets.side_effect = ValueError("no file")
+
+        mod = ModificationCompartmentSet(
+            name="no_file",
+            type="compartment_set",
+            compartment_set="my_set",
+            section_configure="gbar = 0",
+        )
+        with caplog.at_level(logging.WARNING):
+            _apply_compartment_set({}, mod, ca)
+        assert "cannot load compartment_sets_file" in caplog.text
+
+    def test_raises_missing_compartment_set_name(self):
+        from bluecellulab.simulation.modifications import _apply_compartment_set
+
+        ca = mock.MagicMock()
+        ca.config.get_compartment_sets.return_value = {}
+
+        mod = ModificationCompartmentSet(
+            name="missing",
+            type="compartment_set",
+            compartment_set="nonexistent",
+            section_configure="gbar = 0",
+        )
+        with pytest.raises(ValueError, match="not found in compartment_sets file"):
+            _apply_compartment_set({}, mod, ca)
+
+    def test_warns_failed_segment_resolution(self, caplog):
+        import logging
+        from bluecellulab.simulation.modifications import _apply_compartment_set
+
+        cell_id = mock.MagicMock()
+        cell_id.id = 0
+        cell_id.population_name = "NodeA"
+        cell = mock.MagicMock()
+        cell.resolve_segments_from_compartment_set.side_effect = ValueError("bad")
+        cells = {cell_id: cell}
+
+        ca = mock.MagicMock()
+        ca.config.get_compartment_sets.return_value = {
+            "my_set": {
+                "population": "NodeA",
+                "compartment_set": [[0, "soma[0]", 0.5]],
+            }
+        }
+
+        mod = ModificationCompartmentSet(
+            name="fail_resolve",
+            type="compartment_set",
+            compartment_set="my_set",
+            section_configure="gbar = 0",
+        )
+        with caplog.at_level(logging.WARNING):
+            _apply_compartment_set(cells, mod, ca)
+        assert "failed to resolve segments" in caplog.text
+
+    def test_zero_match_warning(self, caplog):
+        import logging
+        from bluecellulab.simulation.modifications import _apply_compartment_set
+
+        cell_id = mock.MagicMock()
+        cell_id.id = 0
+        cell_id.population_name = "NodeA"
+
+        # Segment missing the referenced attribute
+        seg = mock.MagicMock(spec=[])
+        section = mock.MagicMock()
+        section.return_value = seg
+
+        cell = mock.MagicMock()
+        cell.resolve_segments_from_compartment_set.return_value = [
+            (section, "soma[0]", 0.5)
+        ]
+        cells = {cell_id: cell}
+
+        ca = mock.MagicMock()
+        ca.config.get_compartment_sets.return_value = {
+            "my_set": {
+                "population": "NodeA",
+                "compartment_set": [[0, "soma[0]", 0.5]],
+            }
+        }
+
+        mod = ModificationCompartmentSet(
+            name="zero_seg",
+            type="compartment_set",
+            compartment_set="my_set",
+            section_configure="gbar = 0",
+        )
+        with caplog.at_level(logging.WARNING):
+            _apply_compartment_set(cells, mod, ca)
+        assert "applied to zero segments" in caplog.text
+
+    def test_skips_wrong_population(self):
+        from bluecellulab.simulation.modifications import _apply_compartment_set
+
+        cell_id = mock.MagicMock()
+        cell_id.id = 0
+        cell_id.population_name = "NodeB"  # wrong population
+        cell = mock.MagicMock()
+        cells = {cell_id: cell}
+
+        ca = mock.MagicMock()
+        ca.config.get_compartment_sets.return_value = {
+            "my_set": {
+                "population": "NodeA",
+                "compartment_set": [[0, "soma[0]", 0.5]],
+            }
+        }
+
+        mod = ModificationCompartmentSet(
+            name="wrong_pop",
+            type="compartment_set",
+            compartment_set="my_set",
+            section_configure="gbar = 0",
+        )
+        _apply_compartment_set(cells, mod, ca)
+        # Cell should not have been touched
+        cell.resolve_segments_from_compartment_set.assert_not_called()
+
+
+class TestApplyModifications:
+    def test_dispatches_ttx(self):
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell()
+        cells = {cell_id: cell}
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        mod_ttx = ModificationTTX(name="ttx", type="ttx", node_set="target")
+        apply_modifications(cells, [mod_ttx], ca)
+        cell.enable_ttx.assert_called_once()
+
+    def test_dispatches_configure_all_sections(self):
+        sec = _make_mock_section("soma[0]", {"cm": 1.0})
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(sections={"soma[0]": sec})
+        cells = {cell_id: cell}
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        mod = ModificationConfigureAllSections(
+            name="cas",
+            type="configure_all_sections",
+            node_set="target",
+            section_configure="%s.cm = 5.0",
+        )
+        apply_modifications(cells, [mod], ca)
+        assert sec.cm == 5.0
+
+    def test_dispatches_section_list(self):
+        sec = _make_mock_section("apic[0]", {"gbar": 1.0})
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(
+            sections={"apic[0]": sec},
+            section_lists={"apical": [sec]},
+        )
+        cells = {cell_id: cell}
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        mod = ModificationSectionList(
+            name="sl",
+            type="section_list",
+            node_set="target",
+            section_configure="apical.gbar = 0",
+        )
+        apply_modifications(cells, [mod], ca)
+        assert sec.gbar == 0
+
+    def test_dispatches_section(self):
+        sec = _make_mock_section("apic[10]", {"gbar": 1.0})
+        cell_id = mock.MagicMock()
+        cell = _make_mock_cell(sections={"apic[10]": sec})
+        cell.get_section.return_value = sec
+        cells = {cell_id: cell}
+        ca = _make_circuit_access(target_cell_ids=[cell_id])
+
+        mod = ModificationSection(
+            name="sec",
+            type="section",
+            node_set="target",
+            section_configure="apic[10].gbar = 0",
+        )
+        apply_modifications(cells, [mod], ca)
+        assert sec.gbar == 0
+
+    def test_dispatches_compartment_set(self):
+        seg = mock.MagicMock()
+        seg.gbar = 1.0
+        section = mock.MagicMock()
+        section.return_value = seg
+
+        cell_id = mock.MagicMock()
+        cell_id.id = 0
+        cell_id.population_name = "NodeA"
+        cell = mock.MagicMock()
+        cell.resolve_segments_from_compartment_set.return_value = [
+            (section, "soma[0]", 0.5)
+        ]
+        cells = {cell_id: cell}
+
+        ca = mock.MagicMock()
+        ca.get_target_cell_ids.return_value = set()
+        ca.config.get_compartment_sets.return_value = {
+            "my_set": {
+                "population": "NodeA",
+                "compartment_set": [[0, "soma[0]", 0.5]],
+            }
+        }
+
+        mod = ModificationCompartmentSet(
+            name="cs",
+            type="compartment_set",
+            compartment_set="my_set",
+            section_configure="gbar = 0.5",
+        )
+        apply_modifications(cells, [mod], ca)
+        assert seg.gbar == 0.5
+
+    def test_unknown_type_raises(self):
+        mod = ModificationBase(name="bad", type="unknown")
+        with pytest.raises(ValueError, match="Unknown modification type"):
+            apply_modifications({}, [mod], mock.MagicMock())
+
+
+# ---- Integration test: parse modifications from simulation config ----
+
+parent_dir = Path(__file__).resolve().parent.parent
+
+modifications_conf_path = (
+    parent_dir
+    / "examples"
+    / "sim_quick_scx_sonata_multicircuit"
+    / "simulation_config_modifications.json"
+)
+
+
+def test_get_modifications_from_config():
+    """Test that SonataSimulationConfig.get_modifications() parses correctly."""
+    from bluecellulab.circuit.config import SonataSimulationConfig
+
+    sim = SonataSimulationConfig(modifications_conf_path)
+    mods = sim.get_modifications()
+    assert len(mods) == 2
+
+    assert isinstance(mods[0], ModificationTTX)
+    assert mods[0].name == "TTX_block"
+    assert mods[0].node_set == "Mosaic_A"
+    assert mods[0].type == "ttx"
+
+    assert isinstance(mods[1], ModificationConfigureAllSections)
+    assert mods[1].name == "configure_all"
+    assert mods[1].section_configure == "%s.cm = 2.0"
diff --git a/tests/test_simulation/test_neuron_globals.py b/tests/test_simulation/test_neuron_globals.py
index 80f6a902..7a7b5352 100644
--- a/tests/test_simulation/test_neuron_globals.py
+++ b/tests/test_simulation/test_neuron_globals.py
@@ -16,8 +16,18 @@
 import pytest
 import neuron
 
-from bluecellulab.circuit.config.sections import ConditionEntry, Conditions, MechanismConditions
-from bluecellulab.simulation.neuron_globals import NeuronGlobalParams, NeuronGlobals, set_global_condition_parameters, set_init_depleted_values, set_minis_single_vesicle_values
+from bluecellulab.circuit.config.sections import (
+    ConditionEntry,
+    Conditions,
+    MechanismConditions,
+)
+from bluecellulab.simulation.neuron_globals import (
+    NeuronGlobalParams,
+    NeuronGlobals,
+    set_global_condition_parameters,
+    set_init_depleted_values,
+    set_minis_single_vesicle_values,
+)
 
 
 @mock.patch("neuron.h")
@@ -64,6 +74,24 @@ def test_set_minis_single_vesicle_values():
     assert neuron.h.minis_single_vesicle_GluSynapse == 0.0
 
 
+@mock.patch("neuron.h")
+def test_set_global_condition_parameters_generic_mechanisms(mocked_h):
+    """Test that generic mechanisms dict applies all variables as NEURON globals."""
+    # Make hasattr return True for the globals we expect
+    mocked_h.cao_CR_GluSynapse = 1.0  # so the extracellular_calcium path works
+    conditions = Conditions(
+        mechanisms={
+            "ProbGABAAB_EMS": {"property_x": 1, "property_y": 0.25},
+            "CustomMech": {"custom_var": 42.0},
+        },
+    )
+    set_global_condition_parameters(conditions)
+    # Verify generic setattr calls were made for existing attributes
+    assert mocked_h.property_x_ProbGABAAB_EMS == 1
+    assert mocked_h.property_y_ProbGABAAB_EMS == 0.25
+    assert mocked_h.custom_var_CustomMech == 42.0
+
+
 def test_neuron_globals():
     """Unit test for NeuronGlobals."""
     # setting temperature

From 97c27e77186e6eaf9251b6d7ab85239fc6309a56 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 15 Feb 2026 16:17:11 +0100
Subject: [PATCH 02/14] initial implementation spatially_uniform_e_field

---
 bluecellulab/cell/core.py                     |  45 +++
 bluecellulab/circuit_simulation.py            | 100 +++++++
 .../stimulus/circuit_stimulus_definitions.py  |  43 +++
 bluecellulab/stimulus/extracellular.py        | 233 +++++++++++++++
 .../extracellular-efield-stimulus.ipynb       | 267 ++++++++++++++++++
 tests/test_cell/test_core.py                  |  15 +
 .../test_circuit_stimulus_definitions.py      | 110 +++++++-
 tests/test_stimulus/test_extracellular.py     | 204 +++++++++++++
 8 files changed, 1016 insertions(+), 1 deletion(-)
 create mode 100644 bluecellulab/stimulus/extracellular.py
 create mode 100644 examples/2-sonata-network/extracellular-efield-stimulus.ipynb
 create mode 100644 tests/test_stimulus/test_extracellular.py

diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index 40596285..a5c178e6 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -831,6 +831,51 @@ def n_segments(self) -> int:
         """Get the number of segments in the cell."""
         return sum(section.nseg for section in self.sections.values())
 
+    def compute_segment_coordinates(self) -> dict[str, np.ndarray]:
+        """Compute 3D coordinates of segment endpoints for all sections.
+        
+        Extracts 3D point data from NEURON sections and interpolates segment
+        boundary positions along the section axis. Used for extracellular
+        stimulus displacement calculations.
+        
+        Returns:
+            Dictionary mapping section names to arrays of shape (nseg+1, 3)
+            containing [x, y, z] coordinates of segment endpoints in micrometers.
+            Sections without 3D point data return empty arrays.
+        """
+        segment_coords = {}
+        
+        for section in self.sections.values():
+            n_pts = int(neuron.h.n3d(sec=section))
+            
+            if n_pts == 0:
+                logger.warning(
+                    f"Section {section.name()} has no 3D points, "
+                    "cannot compute segment coordinates"
+                )
+                segment_coords[section.name()] = np.array([])
+                continue
+            
+            arc_positions = np.array([neuron.h.arc3d(i, sec=section) for i in range(n_pts)])
+            x_coords = np.array([neuron.h.x3d(i, sec=section) for i in range(n_pts)])
+            y_coords = np.array([neuron.h.y3d(i, sec=section) for i in range(n_pts)])
+            z_coords = np.array([neuron.h.z3d(i, sec=section) for i in range(n_pts)])
+            
+            if section.L > 0:
+                arc_normalized = arc_positions / section.L
+            else:
+                arc_normalized = arc_positions
+            
+            seg_positions = np.linspace(0, 1, section.nseg + 1)
+            
+            x_interp = np.interp(seg_positions, arc_normalized, x_coords)
+            y_interp = np.interp(seg_positions, arc_normalized, y_coords)
+            z_interp = np.interp(seg_positions, arc_normalized, z_coords)
+            
+            segment_coords[section.name()] = np.column_stack((x_interp, y_interp, z_interp))
+        
+        return segment_coords
+
     def add_synapse_replay(
         self, stimulus: SynapseReplay, spike_threshold: float, spike_location: str
     ) -> None:
diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 24127d72..74502358 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -58,6 +58,7 @@
     ShotNoise,
 )
 import bluecellulab.stimulus.circuit_stimulus_definitions as circuit_stimulus_definitions
+from bluecellulab.stimulus.extracellular import ElectrodeSource
 from bluecellulab.exceptions import BluecellulabError
 from bluecellulab.simulation import (
     set_global_condition_parameters,
@@ -155,6 +156,8 @@ def __init__(
 
         self._gid_stride = 1_000_000  # must exceed the max node_id in any population
         self._pop_index: dict[str, int] = {"": 0}
+        
+        self._efield_sources: dict[CellId, ElectrodeSource] = {}
 
     def instantiate_gids(
         self,
@@ -177,6 +180,7 @@ def instantiate_gids(
         add_ornstein_uhlenbeck_stimuli: bool = False,
         add_sinusoidal_stimuli: bool = False,
         add_linear_stimuli: bool = False,
+        add_extracellular_stimuli: bool = False,
     ):
         """Instantiate a list of cells.
 
@@ -345,6 +349,7 @@ def instantiate_gids(
             or add_ornstein_uhlenbeck_stimuli
             or add_sinusoidal_stimuli
             or add_linear_stimuli
+            or add_extracellular_stimuli
         ):
             self._add_stimuli(
                 add_noise_stimuli=add_noise_stimuli,
@@ -355,7 +360,11 @@ def instantiate_gids(
                 add_ornstein_uhlenbeck_stimuli=add_ornstein_uhlenbeck_stimuli,
                 add_sinusoidal_stimuli=add_sinusoidal_stimuli,
                 add_linear_stimuli=add_linear_stimuli,
+                add_extracellular_stimuli=add_extracellular_stimuli,
             )
+            
+            if add_extracellular_stimuli:
+                self._apply_extracellular_stimuli()
 
         configure_all_reports(
             cells=self.cells, simulation_config=self.circuit_access.config
@@ -380,6 +389,7 @@ def _add_stimuli(
         add_ornstein_uhlenbeck_stimuli=False,
         add_sinusoidal_stimuli=False,
         add_linear_stimuli=False,
+        add_extracellular_stimuli=False,
     ) -> None:
         """Instantiate all the stimuli."""
         stimuli_entries = self.circuit_access.config.get_all_stimuli_entries()
@@ -420,6 +430,11 @@ def _add_stimuli(
                     "cannot resolve target location."
                 )
 
+            if isinstance(stimulus, circuit_stimulus_definitions.SpatiallyUniformEField):
+                if add_extracellular_stimuli:
+                    self._add_extracellular_stimulus(stimulus, targets)
+                continue
+            
             for cell_id, sec, segx, sec_name in targets:
                 if isinstance(stimulus, circuit_stimulus_definitions.Noise):
                     if add_noise_stimuli:
@@ -513,6 +528,91 @@ def _add_stimuli(
             elif isinstance(stimulus, (OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck)):
                 ornstein_uhlenbeck_stim_count += 1
 
+    def _add_extracellular_stimulus(
+        self,
+        stimulus: circuit_stimulus_definitions.SpatiallyUniformEField,
+        targets: list[tuple],
+    ) -> None:
+        """Process extracellular e-field stimulus and accumulate into ElectrodeSource per cell.
+        
+        Args:
+            stimulus: SpatiallyUniformEField stimulus definition
+            targets: list of (cell_id, section, segx, section_name) tuples
+        """
+        cell_targets = {}
+        for cell_id, sec, segx, sec_name in targets:
+            if cell_id not in cell_targets:
+                cell_targets[cell_id] = []
+            cell_targets[cell_id].append((sec, segx))
+        
+        for cell_id, seg_list in cell_targets.items():
+            cell = self.cells[cell_id]
+            
+            if cell_id not in self._efield_sources:
+                es = ElectrodeSource(
+                    base_amp=0,
+                    delay=stimulus.delay,
+                    duration=stimulus.duration,
+                    fields=stimulus.fields,
+                    ramp_up_time=stimulus.ramp_up_time,
+                    ramp_down_time=stimulus.ramp_down_time,
+                    dt=self.dt,
+                )
+                self._efield_sources[cell_id] = es
+            else:
+                new_es = ElectrodeSource(
+                    base_amp=0,
+                    delay=stimulus.delay,
+                    duration=stimulus.duration,
+                    fields=stimulus.fields,
+                    ramp_up_time=stimulus.ramp_up_time,
+                    ramp_down_time=stimulus.ramp_down_time,
+                    dt=self.dt,
+                )
+                self._efield_sources[cell_id] += new_es
+            
+            es = self._efield_sources[cell_id]
+            segment_coords = cell.compute_segment_coordinates()
+            
+            soma_coords_all = segment_coords.get(cell.soma.name())
+            if soma_coords_all is None or len(soma_coords_all) == 0:
+                logger.warning(
+                    f"Cell {cell_id} soma has no 3D coordinates, "
+                    "cannot apply extracellular stimulus"
+                )
+                continue
+            
+            soma_position = np.mean(soma_coords_all, axis=0)
+            
+            for sec, segx in seg_list:
+                sec_coords = segment_coords.get(sec.name())
+                if sec_coords is None or len(sec_coords) == 0:
+                    logger.warning(
+                        f"Section {sec.name()} has no 3D coordinates, skipping"
+                    )
+                    continue
+                
+                seg_idx = int(segx * sec.nseg)
+                if seg_idx >= len(sec_coords):
+                    seg_idx = len(sec_coords) - 1
+                
+                segment_position = sec_coords[seg_idx]
+                displacement_vec = (segment_position - soma_position) * 1e-6
+                
+                segment = sec(segx)
+                es.segment_displacements[segment] = displacement_vec
+            
+            logger.debug(
+                f"Added extracellular stimulus to cell {cell_id} "
+                f"with {len(seg_list)} target segments"
+            )
+
+    def _apply_extracellular_stimuli(self) -> None:
+        """Apply all accumulated extracellular field sources to segments."""
+        for cell_id, es in self._efield_sources.items():
+            es.apply_segment_potentials()
+            logger.debug(f"Applied extracellular potentials to cell {cell_id}")
+
     def _add_synapses(self, pre_gids=None, add_minis=False):
         """Instantiate all the synapses."""
         for cell_id in self.cells:
diff --git a/bluecellulab/stimulus/circuit_stimulus_definitions.py b/bluecellulab/stimulus/circuit_stimulus_definitions.py
index 2849c8bb..9429d938 100644
--- a/bluecellulab/stimulus/circuit_stimulus_definitions.py
+++ b/bluecellulab/stimulus/circuit_stimulus_definitions.py
@@ -50,6 +50,7 @@ class Pattern(Enum):
     ORNSTEIN_UHLENBECK = "ornstein_uhlenbeck"
     RELATIVE_ORNSTEIN_UHLENBECK = "relative_ornstein_uhlenbeck"
     SINUSOIDAL = "sinusoidal"
+    SPATIALLY_UNIFORM_E_FIELD = "spatially_uniform_e_field"
 
     @classmethod
     def from_blueconfig(cls, pattern: str) -> Pattern:
@@ -98,6 +99,8 @@ def from_sonata(cls, pattern: str) -> Pattern:
             return Pattern.RELATIVE_ORNSTEIN_UHLENBECK
         elif pattern == "sinusoidal":
             return Pattern.SINUSOIDAL
+        elif pattern == "spatially_uniform_e_field":
+            return Pattern.SPATIALLY_UNIFORM_E_FIELD
         else:
             raise ValueError(f"Unknown pattern {pattern}")
 
@@ -380,6 +383,17 @@ def from_sonata(cls, stimulus_entry: dict, config_dir: Optional[str] = None) ->
                 node_set=node_set,
                 compartment_set=compartment_set,
             )
+        elif pattern == Pattern.SPATIALLY_UNIFORM_E_FIELD:
+            return SpatiallyUniformEField(
+                target=target_name,
+                delay=stimulus_entry["delay"],
+                duration=stimulus_entry["duration"],
+                fields=stimulus_entry["fields"],
+                ramp_up_time=stimulus_entry.get("ramp_up_time", 0.0),
+                ramp_down_time=stimulus_entry.get("ramp_down_time", 0.0),
+                node_set=node_set,
+                compartment_set=compartment_set,
+            )
         else:
             raise ValueError(f"Unknown pattern {pattern}")
 
@@ -511,3 +525,32 @@ class RelativeOrnsteinUhlenbeck(Stimulus):
 class Sinusoidal(Stimulus):
     amp_start: float
     frequency: float
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class SpatiallyUniformEField(Stimulus):
+    fields: list[dict[str, float]]
+    ramp_up_time: NonNegativeFloat = 0.0
+    ramp_down_time: NonNegativeFloat = 0.0
+
+    @field_validator("fields")
+    @classmethod
+    def validate_fields(cls, v):
+        if not v:
+            raise ValueError("fields list cannot be empty")
+        
+        for i, field_dict in enumerate(v):
+            if "Ex" not in field_dict or "Ey" not in field_dict or "Ez" not in field_dict:
+                raise ValueError(
+                    f"Field {i} must contain Ex, Ey, and Ez components"
+                )
+            
+            frequency = field_dict.get("frequency", 0.0)
+            if frequency < 0:
+                raise ValueError(f"Field {i} frequency must be non-negative")
+            
+            phase = field_dict.get("phase", 0.0)
+            if not isinstance(phase, (int, float)):
+                raise ValueError(f"Field {i} phase must be a number")
+        
+        return v
diff --git a/bluecellulab/stimulus/extracellular.py b/bluecellulab/stimulus/extracellular.py
new file mode 100644
index 00000000..ba9c44d4
--- /dev/null
+++ b/bluecellulab/stimulus/extracellular.py
@@ -0,0 +1,233 @@
+# Copyright 2023-2024 Blue Brain Project / EPFL
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Extracellular stimulus signal synthesis and application."""
+
+from __future__ import annotations
+
+import numpy as np
+import neuron
+
+
+class ElectrodeSource:
+    """Constructs an extracellular potential field as the sum of multiple user-defined e-fields.
+    
+    Applies the resulting signal to segment's e_extracellular reference.
+    Adapted from Neurodamus stimuli.py for BlueCelluLab.
+    
+    Args:
+        base_amp: baseline amplitude when signal is inactive
+        delay: start time delay in ms
+        duration: duration of the signal, not including ramp up and ramp down
+        fields: list of user-defined electric field components (dicts with Ex, Ey, Ez, frequency, phase)
+        ramp_up_time: duration during which the signal amplitude ramps up linearly from 0, in ms
+        ramp_down_time: duration during which the signal amplitude ramps down linearly to 0, in ms
+        dt: time step in ms
+    """
+
+    def __init__(self, base_amp, delay, duration, fields, ramp_up_time, ramp_down_time, dt):
+        self.time_vec = neuron.h.Vector()
+        self._cur_t = 0
+        self._base_amp = base_amp
+        self._delay = delay
+        self.fields = fields
+        self.duration = duration
+        self.dt = dt
+        self.ramp_up_time = ramp_up_time
+        self.ramp_down_time = ramp_down_time
+        
+        if delay > 0:
+            self.time_vec.append(self._cur_t)
+            self._cur_t = delay
+        
+        self.efields = self.add_cosines()
+        self.segment_displacements = {}
+        self.segment_potentials = []
+
+    def delay_time(self, duration):
+        """Increments the ref time so that the next created signal is delayed."""
+        self._cur_t += duration
+        return self
+
+    def add_cosines(self):
+        """Add multiple cosinusoidal signals.
+        
+        Returns:
+            numpy array of shape (3, n_timepoints) for Ex, Ey, Ez field components
+        """
+        total_duration = self.duration + self.ramp_up_time + self.ramp_down_time
+        tvec = neuron.h.Vector()
+        tvec.indgen(self._cur_t, self._cur_t + total_duration, self.dt)
+        self.time_vec.append(tvec)
+        self.delay_time(total_duration)
+        
+        self.time_vec.append(self._cur_t + self.dt)
+        
+        res_x = neuron.h.Vector(len(self.time_vec))
+        res_y = neuron.h.Vector(len(self.time_vec))
+        res_z = neuron.h.Vector(len(self.time_vec))
+        
+        for field in self.fields:
+            vec = neuron.h.Vector(len(tvec))
+            freq = field.get("frequency", 0)
+            phase = field.get("phase", 0)
+            Ex = field["Ex"]
+            Ey = field["Ey"]
+            Ez = field["Ez"]
+            
+            vec.sin(freq, phase + np.pi / 2, self.dt)
+            self.apply_ramp(vec, self.dt)
+            
+            if self._delay > 0:
+                vec.insrt(0, self._base_amp)
+            vec.append(self._base_amp)
+            
+            res_x.add(vec.c().mul(Ex))
+            res_y.add(vec.c().mul(Ey))
+            res_z.add(vec.c().mul(Ez))
+
+        return np.array([res_x, res_y, res_z])
+
+    def compute_potentials(self, displacement_vec):
+        """Compute potential at a segment given displacement from reference point.
+        
+        Args:
+            displacement_vec: 3D displacement vector in meters [dx, dy, dz]
+            
+        Returns:
+            numpy array of potentials in mV over time
+        """
+        return np.dot(displacement_vec, self.efields) * 1e3
+
+    def apply_ramp(self, signal_vec, step):
+        """Apply linear ramp up and down to signal.
+        
+        Args:
+            signal_vec: hoc Vector to apply ramp to
+            step: time step in ms
+        """
+        ramp_up_number = int(self.ramp_up_time / step)
+        ramp_down_number = int(self.ramp_down_time / step)
+
+        if ramp_up_number > 0:
+            ramp_up = np.linspace(0, 1, ramp_up_number)
+            for i in range(ramp_up_number):
+                signal_vec[i] *= ramp_up[i]
+        if ramp_down_number > 0:
+            ramp_down = np.linspace(1, 0, ramp_down_number)
+            vec_len = len(signal_vec)
+            for i in range(ramp_down_number):
+                signal_vec[vec_len - ramp_down_number + i] *= ramp_down[i]
+
+    def apply_segment_potentials(self):
+        """Apply potentials to segment.extracellular._ref_e for all segments."""
+        for segment, displacement in self.segment_displacements.items():
+            section = segment.sec
+            e_ext_vec = neuron.h.Vector(self.compute_potentials(displacement))
+            
+            if not section.has_membrane("extracellular"):
+                section.insert("extracellular")
+            
+            e_ext_vec.play(segment.extracellular._ref_e, self.time_vec, 0)
+            self.segment_potentials.append(e_ext_vec)
+
+        self.cleanup()
+
+    def cleanup(self):
+        """Clear unused variables to free memory."""
+        self.efields = None
+        self.segment_displacements = None
+
+    def __iadd__(self, other):
+        """Combine with another ElectrodeSource object.
+        
+        Merges time vectors and sums overlapping e-fields.
+        
+        Args:
+            other: another ElectrodeSource instance
+            
+        Returns:
+            self with combined time vector and e-fields
+        """
+        assert np.isclose(self.dt, other.dt), "multiple extracellular stimuli must have common dt"
+        
+        combined_time_vec, self.efields = self._combine_time_efields(
+            self.time_vec.as_numpy(),
+            self.efields,
+            other.time_vec.as_numpy(),
+            other.efields,
+            self._delay > 0,
+            other._delay > 0,
+            self.dt,
+        )
+        self.time_vec = neuron.h.Vector(combined_time_vec)
+        return self
+
+    @staticmethod
+    def _combine_time_efields(t1_vec, efields1, t2_vec, efields2, is_delay1, is_delay2, dt):
+        """Combine time and efields vectors from 2 ElectrodeSource objects.
+        
+        Args:
+            t1_vec, t2_vec: numpy arrays of time points
+            efields1, efields2: arrays of shape (3, n_timepoints) for Ex, Ey, Ez
+            is_delay1, is_delay2: whether stimuli have delays
+            dt: time step
+            
+        Returns:
+            tuple of (combined_time_vec, combined_efields)
+        """
+        if is_delay1:
+            t1_vec = t1_vec[1:]
+            efields1 = efields1[:, 1:]
+        if is_delay2:
+            t2_vec = t2_vec[1:]
+            efields2 = efields2[:, 1:]
+
+        t1_ticks = np.round(t1_vec / dt).astype(np.int64)
+        t2_ticks = np.round(t2_vec / dt).astype(np.int64)
+
+        if not (t1_ticks[-1] < t2_ticks[0] or t2_ticks[-1] < t1_ticks[0]):
+            combined_time_ticks = np.union1d(t1_ticks, t2_ticks)
+            
+            idx1_left = np.searchsorted(t1_ticks, combined_time_ticks, side="right") - 1
+            idx1_right = np.searchsorted(t1_ticks, combined_time_ticks, side="left")
+            mask1 = idx1_left == idx1_right
+            
+            idx2_left = np.searchsorted(t2_ticks, combined_time_ticks, side="right") - 1
+            idx2_right = np.searchsorted(t2_ticks, combined_time_ticks, side="left")
+            mask2 = idx2_left == idx2_right
+
+            combined_efields = np.zeros((len(efields1), len(combined_time_ticks)), dtype=float)
+            combined_efields[:, mask1] += efields1[:, idx1_left[mask1]]
+            combined_efields[:, mask2] += efields2[:, idx2_left[mask2]]
+
+        elif t1_ticks[-1] < t2_ticks[0]:
+            combined_time_ticks = np.concatenate((t1_ticks, t2_ticks))
+            combined_efields = np.concatenate((efields1, efields2), axis=1)
+        else:
+            combined_time_ticks = np.concatenate((t2_ticks, t1_ticks))
+            combined_efields = np.concatenate((efields2, efields1), axis=1)
+
+        combined_time_vec = combined_time_ticks.astype(float) * dt
+
+        if combined_time_vec[0] > 0:
+            combined_time_vec = np.concatenate([[0.0], combined_time_vec])
+            combined_efields = np.concatenate(
+                [np.zeros((combined_efields.shape[0], 1)), combined_efields], axis=1
+            )
+
+        assert combined_efields.shape[1] == len(combined_time_vec), (
+            "Time and efield length mismatch"
+        )
+
+        return combined_time_vec, combined_efields
diff --git a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
new file mode 100644
index 00000000..319f4d32
--- /dev/null
+++ b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
@@ -0,0 +1,267 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Extracellular E-Field Stimulus\n",
+    "\n",
+    "This notebook demonstrates how to apply a spatially uniform extracellular electric field stimulus to neurons in a SONATA network.\n",
+    "\n",
+    "The `spatially_uniform_e_field` stimulus allows you to apply electric field components (Ex, Ey, Ez) that can be constant (DC) or oscillating (AC) with configurable frequency and phase. This is useful for modeling transcranial electrical stimulation (TES), deep brain stimulation (DBS), or other extracellular field effects."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Compiling mechanisms\n",
+    "\n",
+    "First, compile the NEURON mechanisms:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!nrnivmodl ../mechanisms"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Import libraries"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import json\n",
+    "from pathlib import Path\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "from bluecellulab import CircuitSimulation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Create simulation configuration with e-field stimulus\n",
+    "\n",
+    "We'll create a SONATA simulation config that applies a spatially uniform e-field to a target population. The field has:\n",
+    "- DC component: Ex=100 V/m, Ey=-50 V/m, Ez=50 V/m\n",
+    "- AC component: Ex=50 V/m at 10 Hz\n",
+    "- Ramp up/down for smooth transitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Load the base simulation config\n",
+    "base_config_path = Path(\"./sim_quick_scx_sonata_multicircuit/simulation_config.json\")\n",
+    "with open(base_config_path, 'r') as f:\n",
+    "    sim_config = json.load(f)\n",
+    "\n",
+    "# Add extracellular e-field stimulus\n",
+    "sim_config[\"inputs\"] = {\n",
+    "    \"extracellular_efield\": {\n",
+    "        \"input_type\": \"extracellular_stimulation\",\n",
+    "        \"module\": \"spatially_uniform_e_field\",\n",
+    "        \"delay\": 50.0,\n",
+    "        \"duration\": 200.0,\n",
+    "        \"node_set\": \"l4pc\",\n",
+    "        \"fields\": [\n",
+    "            {\"Ex\": 100, \"Ey\": -50, \"Ez\": 50, \"frequency\": 0},\n",
+    "            {\"Ex\": 50, \"Ey\": 0, \"Ez\": 0, \"frequency\": 10}\n",
+    "        ],\n",
+    "        \"ramp_up_time\": 10.0,\n",
+    "        \"ramp_down_time\": 10.0\n",
+    "    }\n",
+    "}\n",
+    "\n",
+    "# Save modified config\n",
+    "modified_config_path = Path(\"./sim_quick_scx_sonata_multicircuit/simulation_config_efield.json\")\n",
+    "with open(modified_config_path, 'w') as f:\n",
+    "    json.dump(sim_config, f, indent=2)\n",
+    "\n",
+    "print(\"E-field stimulus configuration:\")\n",
+    "print(json.dumps(sim_config[\"inputs\"][\"extracellular_efield\"], indent=2))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Initialize simulation with e-field stimulus"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create simulation\n",
+    "sim = CircuitSimulation(modified_config_path)\n",
+    "\n",
+    "# Select a few cells from the target population\n",
+    "target_cells = sim.circuit_access.get_target_cell_ids(\"l4pc\")\n",
+    "cells_to_simulate = list(target_cells)[:3]\n",
+    "\n",
+    "print(f\"Simulating {len(cells_to_simulate)} cells: {cells_to_simulate}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Instantiate cells with e-field stimulus\n",
+    "\n",
+    "Use the `add_extracellular_stimuli=True` flag to enable e-field application:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.instantiate_gids(\n",
+    "    cells=cells_to_simulate,\n",
+    "    add_extracellular_stimuli=True  # Enable e-field stimuli\n",
+    ")\n",
+    "\n",
+    "print(f\"Instantiated {len(sim.cells)} cells\")\n",
+    "print(f\"E-field sources created: {len(sim._efield_sources)}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Add voltage recordings"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Record soma voltage for all cells\n",
+    "for cell_id in sim.cells:\n",
+    "    sim.cells[cell_id].add_voltage_recording()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Run simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sim.run()\n",
+    "print(\"Simulation completed!\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Plot results\n",
+    "\n",
+    "Visualize the voltage traces showing the effect of the e-field stimulus:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig, axes = plt.subplots(len(cells_to_simulate), 1, figsize=(12, 3*len(cells_to_simulate)), sharex=True)\n",
+    "if len(cells_to_simulate) == 1:\n",
+    "    axes = [axes]\n",
+    "\n",
+    "for i, cell_id in enumerate(cells_to_simulate):\n",
+    "    cell = sim.cells[cell_id]\n",
+    "    time = cell.get_time()\n",
+    "    voltage = cell.get_voltage_recording()\n",
+    "    \n",
+    "    axes[i].plot(time, voltage, linewidth=0.8)\n",
+    "    axes[i].set_ylabel(f\"Cell {cell_id}\\nVoltage (mV)\")\n",
+    "    axes[i].axvspan(50, 60, alpha=0.2, color='green', label='Ramp up')\n",
+    "    axes[i].axvspan(60, 240, alpha=0.2, color='yellow', label='E-field active')\n",
+    "    axes[i].axvspan(240, 250, alpha=0.2, color='orange', label='Ramp down')\n",
+    "    axes[i].grid(True, alpha=0.3)\n",
+    "    if i == 0:\n",
+    "        axes[i].legend(loc='upper right')\n",
+    "\n",
+    "axes[-1].set_xlabel(\"Time (ms)\")\n",
+    "plt.suptitle(\"Voltage Response to Extracellular E-Field Stimulus\", fontsize=14, y=1.0)\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "This notebook demonstrated:\n",
+    "1. **Creating** a SONATA config with `spatially_uniform_e_field` stimulus\n",
+    "2. **Configuring** multiple field components (DC + AC)\n",
+    "3. **Applying** the stimulus with ramp up/down\n",
+    "4. **Visualizing** the neuronal response to the e-field\n",
+    "\n",
+    "### Key parameters:\n",
+    "- `fields`: List of field components with Ex, Ey, Ez (V/m), frequency (Hz), phase (rad)\n",
+    "- `ramp_up_time`, `ramp_down_time`: Smooth transitions (ms)\n",
+    "- `delay`, `duration`: Timing control (ms)\n",
+    "- `node_set`: Target population\n",
+    "\n",
+    "The e-field is applied to all segments of each neuron based on their 3D spatial positions relative to the soma, providing realistic modeling of extracellular stimulation effects."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/tests/test_cell/test_core.py b/tests/test_cell/test_core.py
index 2cd1c5ef..f204e243 100644
--- a/tests/test_cell/test_core.py
+++ b/tests/test_cell/test_core.py
@@ -922,3 +922,18 @@ def test_add_currents_recordings_with_point_process(self):
         called = [c.args[0] for c in mock_add.call_args_list]
         assert "ina" in called
         assert "i_ExpSyn" in called
+
+    def test_compute_segment_coordinates(self):
+        """Cell: Test compute_segment_coordinates for extracellular stimuli."""
+        segment_coords = self.cell.compute_segment_coordinates()
+        
+        assert isinstance(segment_coords, dict)
+        assert len(segment_coords) > 0
+        
+        soma_name = self.cell.soma.name()
+        assert soma_name in segment_coords
+        
+        soma_coords = segment_coords[soma_name]
+        assert isinstance(soma_coords, np.ndarray)
+        assert soma_coords.shape[1] == 3
+        assert soma_coords.shape[0] == self.cell.soma.nseg + 1
diff --git a/tests/test_stimulus/test_circuit_stimulus_definitions.py b/tests/test_stimulus/test_circuit_stimulus_definitions.py
index dd8bf74e..8e0604f4 100644
--- a/tests/test_stimulus/test_circuit_stimulus_definitions.py
+++ b/tests/test_stimulus/test_circuit_stimulus_definitions.py
@@ -14,7 +14,12 @@
 # limitations under the License.
 
 import pytest
-from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, Pattern, Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
+    Noise, 
+    Pattern, 
+    Stimulus,
+    SpatiallyUniformEField,
+)
 
 
 def test_pattern_from_sonata_valid():
@@ -72,3 +77,106 @@ def test_from_sonata_noise_requires_one_mean_field():
 
     with pytest.raises(ValueError, match="Noise input must contain exactly one of 'mean' or 'mean_percent'."):
         Stimulus.from_sonata({**base, "mean": 0.01, "mean_percent": 5.0})
+
+
+def test_pattern_spatially_uniform_e_field():
+    """Test that spatially_uniform_e_field maps correctly."""
+    assert Pattern.from_sonata("spatially_uniform_e_field") == Pattern.SPATIALLY_UNIFORM_E_FIELD
+
+
+def test_spatially_uniform_e_field_valid():
+    """Test valid SpatiallyUniformEField construction."""
+    stim = SpatiallyUniformEField(
+        target="T",
+        delay=0.0,
+        duration=10.0,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 75}],
+        ramp_up_time=2.0,
+        ramp_down_time=3.0,
+        node_set="T",
+        compartment_set=None,
+    )
+    assert stim.fields == [{"Ex": 100, "Ey": -50, "Ez": 75}]
+    assert stim.ramp_up_time == 2.0
+    assert stim.ramp_down_time == 3.0
+
+
+def test_spatially_uniform_e_field_empty_fields():
+    """Test that empty fields list raises validation error."""
+    with pytest.raises(ValueError, match="fields list cannot be empty"):
+        SpatiallyUniformEField(
+            target="T",
+            delay=0.0,
+            duration=10.0,
+            fields=[],
+            node_set="T",
+            compartment_set=None,
+        )
+
+
+def test_spatially_uniform_e_field_missing_components():
+    """Test that missing Ex/Ey/Ez raises validation error."""
+    with pytest.raises(ValueError, match="Field 0 must contain Ex, Ey, and Ez components"):
+        SpatiallyUniformEField(
+            target="T",
+            delay=0.0,
+            duration=10.0,
+            fields=[{"Ex": 100, "Ey": -50}],
+            node_set="T",
+            compartment_set=None,
+        )
+
+
+def test_spatially_uniform_e_field_negative_frequency():
+    """Test that negative frequency raises validation error."""
+    with pytest.raises(ValueError, match="Field 0 frequency must be non-negative"):
+        SpatiallyUniformEField(
+            target="T",
+            delay=0.0,
+            duration=10.0,
+            fields=[{"Ex": 100, "Ey": -50, "Ez": 75, "frequency": -10}],
+            node_set="T",
+            compartment_set=None,
+        )
+
+
+def test_from_sonata_spatially_uniform_e_field():
+    """Test parsing SONATA spatially_uniform_e_field stimulus."""
+    entry = {
+        "module": "spatially_uniform_e_field",
+        "delay": 0.0,
+        "duration": 10.0,
+        "node_set": "TestTarget",
+        "fields": [
+            {"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 100},
+            {"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0},
+        ],
+        "ramp_up_time": 2.0,
+        "ramp_down_time": 3.0,
+    }
+    
+    stim = Stimulus.from_sonata(entry)
+    assert isinstance(stim, SpatiallyUniformEField)
+    assert stim.delay == 0.0
+    assert stim.duration == 10.0
+    assert stim.node_set == "TestTarget"
+    assert stim.compartment_set is None
+    assert len(stim.fields) == 2
+    assert stim.ramp_up_time == 2.0
+    assert stim.ramp_down_time == 3.0
+
+
+def test_from_sonata_spatially_uniform_e_field_defaults():
+    """Test parsing with default ramp times."""
+    entry = {
+        "module": "spatially_uniform_e_field",
+        "delay": 0.0,
+        "duration": 10.0,
+        "node_set": "TestTarget",
+        "fields": [{"Ex": 50, "Ey": -25, "Ez": 75}],
+    }
+    
+    stim = Stimulus.from_sonata(entry)
+    assert isinstance(stim, SpatiallyUniformEField)
+    assert stim.ramp_up_time == 0.0
+    assert stim.ramp_down_time == 0.0
diff --git a/tests/test_stimulus/test_extracellular.py b/tests/test_stimulus/test_extracellular.py
new file mode 100644
index 00000000..10b03044
--- /dev/null
+++ b/tests/test_stimulus/test_extracellular.py
@@ -0,0 +1,204 @@
+# Copyright 2023-2024 Blue Brain Project / EPFL
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+
+#     http://www.apache.org/licenses/LICENSE-2.0
+
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import numpy as np
+import pytest
+
+from bluecellulab.stimulus.extracellular import ElectrodeSource
+
+
+def test_electrode_source_init():
+    """Test ElectrodeSource initialization."""
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[{"Ex": 50, "Ey": -25, "Ez": 75}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    assert es.duration == 10
+    assert es.dt == 1.0
+    assert len(es.fields) == 1
+
+
+def test_apply_ramp_case1():
+    """Test ramp application when ramp_up/down_time > dt and is multiple of dt."""
+    import neuron
+    
+    dt = 0.5
+    ramp_up_time = 2.0
+    ramp_down_time = 1.5
+    
+    es = ElectrodeSource(0, 0, 100, [], ramp_up_time, ramp_down_time, dt)
+    stim_vec = neuron.h.Vector(list(range(1, 11)))
+    
+    assert np.isclose(es.ramp_up_time, ramp_up_time)
+    assert np.isclose(es.ramp_down_time, ramp_down_time)
+    assert np.isclose(es.dt, dt)
+    
+    es.apply_ramp(stim_vec, es.dt)
+    
+    expected = [0, 2/3, 2, 4, 5, 6, 7, 8, 4.5, 0]
+    np.testing.assert_allclose(stim_vec.as_numpy(), expected)
+
+
+def test_apply_ramp_case2():
+    """Test ramp when ramp_up/down_time > dt but not multiple of dt."""
+    import neuron
+    
+    dt = 0.5
+    ramp_up_time = 2.4
+    ramp_down_time = 1.7
+    
+    es = ElectrodeSource(0, 0, 100, [], ramp_up_time, ramp_down_time, dt)
+    stim_vec = neuron.h.Vector(list(range(1, 11)))
+    
+    es.apply_ramp(stim_vec, es.dt)
+    
+    expected = [0, 2/3, 2, 4, 5, 6, 7, 8, 4.5, 0]
+    np.testing.assert_allclose(stim_vec.as_numpy(), expected)
+
+
+def test_apply_ramp_case3():
+    """Test ramp when ramp_up/down_time < dt (no ramp applied)."""
+    import neuron
+    
+    dt = 0.5
+    ramp_up_time = 0.3
+    ramp_down_time = 0.4
+    
+    es = ElectrodeSource(0, 0, 100, [], ramp_up_time, ramp_down_time, dt)
+    stim_vec = neuron.h.Vector(list(range(1, 11)))
+    
+    es.apply_ramp(stim_vec, es.dt)
+    
+    expected = list(range(1, 11))
+    np.testing.assert_allclose(stim_vec.as_numpy(), expected)
+
+
+def test_dc_field():
+    """Test constant (DC) field when frequency=0."""
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    
+    assert es.efields.shape[0] == 3
+    
+    for i in range(3):
+        field_values = es.efields[i]
+        assert np.all(field_values[1:-1] != 0)
+
+
+def test_ac_field():
+    """Test AC (cosine) field with non-zero frequency."""
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[{"Ex": 100, "Ey": 0, "Ez": 0, "frequency": 10}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    
+    assert es.efields.shape[0] == 3
+
+
+def test_multi_field_summation():
+    """Test that multiple fields sum correctly."""
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[
+            {"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 100},
+            {"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0},
+        ],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    
+    assert len(es.fields) == 2
+    assert es.efields.shape[0] == 3
+
+
+def test_compute_potentials():
+    """Test potential calculation from displacement vector."""
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    
+    displacement = np.array([1e-6, 2e-6, 3e-6])
+    potentials = es.compute_potentials(displacement)
+    
+    assert len(potentials) == len(es.time_vec)
+
+
+def test_iadd_combining_sources():
+    """Test combining two ElectrodeSource objects."""
+    es1 = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[{"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    
+    es2 = ElectrodeSource(
+        base_amp=0,
+        delay=5,
+        duration=10,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    
+    original_len = len(es1.time_vec)
+    es1 += es2
+    
+    assert len(es1.time_vec) >= original_len
+
+
+def test_iadd_different_dt_raises():
+    """Test that combining sources with different dt raises assertion error."""
+    es1 = ElectrodeSource(
+        base_amp=0, delay=0, duration=10, fields=[], 
+        ramp_up_time=0, ramp_down_time=0, dt=1.0
+    )
+    
+    es2 = ElectrodeSource(
+        base_amp=0, delay=0, duration=10, fields=[], 
+        ramp_up_time=0, ramp_down_time=0, dt=0.5
+    )
+    
+    with pytest.raises(AssertionError, match="multiple extracellular stimuli must have common dt"):
+        es1 += es2

From 9870c4d940f201730f52762136247693bd52493b Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 12 Apr 2026 10:16:27 +0200
Subject: [PATCH 03/14] Merge main and re-apply e-field stimulus implementation

- Merged main into uniform_e_field_stimulus branch
- Re-applied SpatiallyUniformEField stimulus pattern and class
- Re-applied ElectrodeSource integration in circuit_simulation.py
- Re-applied compute_segment_coordinates() to Cell class
- Ported axon/myelin interpolation methods from neurodamus
- Updated _add_extracellular_stimulus to use coordinate interpolation
- Added unit tests for coordinate helpers (interp_axon_positions, interp_myelin_positions)
- All pytest tests pass
---
 bluecellulab/cell/core.py                     |  97 ++++++++++++++-
 bluecellulab/circuit_simulation.py            | 110 +++++++++++++++++-
 .../stimulus/circuit_stimulus_definitions.py  |  43 +++++++
 bluecellulab/stimulus/extracellular.py        |   2 +-
 tests/test_stimulus/test_extracellular.py     |  72 +++++++++++-
 5 files changed, 317 insertions(+), 7 deletions(-)

diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index 35e29079..b00faf5e 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -879,9 +879,104 @@ def compute_segment_coordinates(self) -> dict[str, np.ndarray]:
             z_interp = np.interp(seg_positions, arc_normalized, z_coords)
             
             segment_coords[section.name()] = np.column_stack((x_interp, y_interp, z_interp))
-        
+
         return segment_coords
 
+    @staticmethod
+    def get_segment_position(
+        sec_seg_points: np.ndarray,
+        soma_local_position: np.ndarray,
+        section: NeuronSection,
+        x: float,
+        func_loc2glob: Optional[callable] = None,
+    ) -> np.ndarray:
+        """Get the global coordinates of the segment.
+        For axon and myelin, interpolate along the y-axis of the local soma coordinates,
+        and then convert to global coordinates.
+
+        Args:
+            sec_seg_points: segment global positions in the current section
+            soma_local_position: soma local position to interpolate axon and myelin position
+            section: hoc section
+            x: offset along the section, in [0, 1]
+            func_loc2glob: function to convert local coordinates to global ones for axon and myelin,
+                          return the local coordinates if None
+        Returns:
+            global coordinates [x, y, z], type np.array
+        """
+        if not section.n3d():  # Axonal segments don't have 3d points associated, so we guess
+            if "axon" in section.name():
+                pattern = r"axon\[(\d+)\]$"
+                if match := re.search(pattern, section.name()):
+                    axon_index = int(match.group(1))
+                    local_positions = Cell.interp_axon_positions(
+                        x, axon_index, soma_local_position
+                    )
+                    return func_loc2glob(local_positions) if func_loc2glob else local_positions
+            elif "myelin" in section.name():
+                pattern = r"myelin\[(\d+)\]$"
+                if match := re.search(pattern, section.name()):
+                    myelin_index = int(match.group(1))
+                    local_positions = Cell.interp_myelin_positions(
+                        x, myelin_index, soma_local_position
+                    )
+                    return func_loc2glob(local_positions) if func_loc2glob else local_positions
+            else:
+                raise ValueError(f"section {section.name()} has no 3d points defined")
+        else:
+            seg_index = int(np.floor((len(sec_seg_points) - 1) * x))
+            return sec_seg_points[seg_index]
+        return None
+
+    @staticmethod
+    def interp_axon_positions(x: float, axon_index: int, soma_position: np.ndarray) -> np.ndarray:
+        """Interpolate the coordinates of the axon segment for the given x,
+        because of no 3d point for the new axons.
+        Assume that the axon is oriented along the y-axis from soma, 30 um displaced for 1st axon,
+        60 um for 2nd axon, the same x- and z-coordinates as soma.
+        x=0 is soma, and x=1 is the end of the axon section.
+        """
+        if axon_index > 1:
+            raise ValueError("More than 2 axon sections exist!")
+        xpos = [soma_position[0], soma_position[0]]
+        ypos = [
+            soma_position[1] - 30 * int(axon_index),
+            soma_position[1] - 30 * int(axon_index + 1),
+        ]
+        zpos = [soma_position[2], soma_position[2]]
+        lens = [0, 1]
+
+        # Interpolate the coordinates for the given location x along the segment
+        seg_x = np.interp(x, lens, xpos)
+        seg_y = np.interp(x, lens, ypos)
+        seg_z = np.interp(x, lens, zpos)
+
+        return np.array([seg_x, seg_y, seg_z])
+
+    @staticmethod
+    def interp_myelin_positions(x: float, myelin_index: int, soma_position: np.ndarray) -> np.ndarray:
+        """Interpolate the coordinates of the myelin segment for the given x,
+        because of no 3d point for the new myelin section.
+        Assume that the myelin is oriented along the y-axis from soma,
+        1000 um displaced after the 2nd axon, i.e. [soma-60, soma-1000]
+        """
+        if myelin_index > 0:
+            raise ValueError("More than 1 myelin section exist!")
+        xpos = [soma_position[0], soma_position[0]]
+        ypos = [
+            (soma_position[1] - 60) - 1000 * int(myelin_index),
+            (soma_position[1] - 60) - 1000 * int(myelin_index + 1),
+        ]
+        zpos = [soma_position[2], soma_position[2]]
+        lens = [0, 1]
+
+        # Interpolate the coordinates for the given location x along the segment
+        seg_x = np.interp(x, lens, xpos)
+        seg_y = np.interp(x, lens, ypos)
+        seg_z = np.interp(x, lens, zpos)
+
+        return np.array([seg_x, seg_y, seg_z])
+
     def add_synapse_replay(
         self, stimulus: SynapseReplay, spike_threshold: float, spike_location: str
     ) -> None:
diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 6d12d644..86f07ee5 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -159,6 +159,7 @@ def __init__(
 
         self.gids: Optional[GidNamespace] = None
         self._instantiated_cells_mpi: set[CellId] | None = None
+        self._efield_sources: dict[CellId, ElectrodeSource] = {}
 
     def instantiate_gids(
         self,
@@ -182,6 +183,7 @@ def instantiate_gids(
         add_sinusoidal_stimuli: bool = False,
         add_linear_stimuli: bool = False,
         add_seclamp_stimuli: bool = False,
+        add_extracellular_stimuli: bool = False,
     ):
         """Instantiate a list of cells.
 
@@ -368,6 +370,7 @@ def instantiate_gids(
             or add_sinusoidal_stimuli
             or add_linear_stimuli
             or add_seclamp_stimuli
+            or add_extracellular_stimuli
         ):
             self._add_stimuli(
                 add_noise_stimuli=add_noise_stimuli,
@@ -379,8 +382,9 @@ def instantiate_gids(
                 add_sinusoidal_stimuli=add_sinusoidal_stimuli,
                 add_linear_stimuli=add_linear_stimuli,
                 add_seclamp_stimuli=add_seclamp_stimuli,
+                add_extracellular_stimuli=add_extracellular_stimuli,
             )
-            
+
             if add_extracellular_stimuli:
                 self._apply_extracellular_stimuli()
 
@@ -409,6 +413,7 @@ def _add_stimuli(
         add_sinusoidal_stimuli=False,
         add_linear_stimuli=False,
         add_seclamp_stimuli=False,
+        add_extracellular_stimuli=False,
     ) -> None:
         """Instantiate all the stimuli."""
         stimuli_entries = self.circuit_access.config.get_all_stimuli_entries()
@@ -550,6 +555,109 @@ def _add_stimuli(
             elif isinstance(stimulus, (OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck)):
                 ornstein_uhlenbeck_stim_count += 1
 
+    def _add_extracellular_stimulus(
+        self,
+        stimulus: circuit_stimulus_definitions.SpatiallyUniformEField,
+        targets: list[tuple],
+    ) -> None:
+        """Process extracellular e-field stimulus and accumulate into ElectrodeSource per cell.
+
+        Args:
+            stimulus: SpatiallyUniformEField stimulus definition
+            targets: list of (cell_id, section, segx, section_name) tuples
+        """
+        cell_targets = {}
+        for cell_id, sec, segx, sec_name in targets:
+            if cell_id not in cell_targets:
+                cell_targets[cell_id] = []
+            cell_targets[cell_id].append((sec, segx))
+
+        for cell_id, seg_list in cell_targets.items():
+            cell = self.cells[cell_id]
+
+            if cell_id not in self._efield_sources:
+                es = ElectrodeSource(
+                    base_amp=0,
+                    delay=stimulus.delay,
+                    duration=stimulus.duration,
+                    fields=stimulus.fields,
+                    ramp_up_time=stimulus.ramp_up_time,
+                    ramp_down_time=stimulus.ramp_down_time,
+                    dt=self.dt,
+                )
+                self._efield_sources[cell_id] = es
+            else:
+                new_es = ElectrodeSource(
+                    base_amp=0,
+                    delay=stimulus.delay,
+                    duration=stimulus.duration,
+                    fields=stimulus.fields,
+                    ramp_up_time=stimulus.ramp_up_time,
+                    ramp_down_time=stimulus.ramp_down_time,
+                    dt=self.dt,
+                )
+                self._efield_sources[cell_id] += new_es
+
+            es = self._efield_sources[cell_id]
+            segment_coords = cell.compute_segment_coordinates()
+
+            soma_coords_all = segment_coords.get(cell.soma.name())
+            if soma_coords_all is None or len(soma_coords_all) == 0:
+                logger.warning(
+                    f"Cell {cell_id} soma has no 3D coordinates, "
+                    "cannot apply extracellular stimulus"
+                )
+                continue
+
+            soma_position = np.mean(soma_coords_all, axis=0)
+
+            for sec, segx in seg_list:
+                sec_coords = segment_coords.get(sec.name())
+                segment_position = None
+
+                if sec_coords is None or len(sec_coords) == 0:
+                    # Try axon/myelin interpolation for sections without 3D points
+                    if not sec.n3d():
+                        try:
+                            segment_position = cell.get_segment_position(
+                                np.array([]), soma_position, sec, segx, func_loc2glob=None
+                            )
+                        except ValueError:
+                            logger.warning(
+                                f"Section {sec.name()} has no 3D coordinates and "
+                                "could not interpolate, skipping"
+                            )
+                            continue
+                    else:
+                        logger.warning(
+                            f"Section {sec.name()} has no 3D coordinates, skipping"
+                        )
+                        continue
+                else:
+                    seg_idx = int(segx * sec.nseg)
+                    if seg_idx >= len(sec_coords):
+                        seg_idx = len(sec_coords) - 1
+                    segment_position = sec_coords[seg_idx]
+
+                if segment_position is None:
+                    continue
+
+                displacement_vec = (segment_position - soma_position) * 1e-6
+
+                segment = sec(segx)
+                es.segment_displacements[segment] = displacement_vec
+
+            logger.debug(
+                f"Added extracellular stimulus to cell {cell_id} "
+                f"with {len(seg_list)} target segments"
+            )
+
+    def _apply_extracellular_stimuli(self) -> None:
+        """Apply all accumulated extracellular field sources to segments."""
+        for cell_id, es in self._efield_sources.items():
+            es.apply_segment_potentials()
+            logger.debug(f"Applied extracellular potentials to cell {cell_id}")
+
     def _add_synapses(self, pre_gids=None, add_minis=False):
         """Instantiate all the synapses."""
         for cell_id in self.cells:
diff --git a/bluecellulab/stimulus/circuit_stimulus_definitions.py b/bluecellulab/stimulus/circuit_stimulus_definitions.py
index ab39199b..5edf6c3a 100644
--- a/bluecellulab/stimulus/circuit_stimulus_definitions.py
+++ b/bluecellulab/stimulus/circuit_stimulus_definitions.py
@@ -50,6 +50,7 @@ class Pattern(Enum):
     ORNSTEIN_UHLENBECK = "ornstein_uhlenbeck"
     RELATIVE_ORNSTEIN_UHLENBECK = "relative_ornstein_uhlenbeck"
     SINUSOIDAL = "sinusoidal"
+    SPATIALLY_UNIFORM_E_FIELD = "spatially_uniform_e_field"
     SECLAMP = "seclamp"
 
     @classmethod
@@ -99,6 +100,8 @@ def from_sonata(cls, pattern: str) -> Pattern:
             return Pattern.RELATIVE_ORNSTEIN_UHLENBECK
         elif pattern == "sinusoidal":
             return Pattern.SINUSOIDAL
+        elif pattern == "spatially_uniform_e_field":
+            return Pattern.SPATIALLY_UNIFORM_E_FIELD
         elif pattern == "seclamp":
             return Pattern.SECLAMP
         else:
@@ -383,6 +386,17 @@ def from_sonata(cls, stimulus_entry: dict, config_dir: Optional[str] = None) ->
                 node_set=node_set,
                 compartment_set=compartment_set,
             )
+        elif pattern == Pattern.SPATIALLY_UNIFORM_E_FIELD:
+            return SpatiallyUniformEField(
+                target=target_name,
+                delay=stimulus_entry["delay"],
+                duration=stimulus_entry["duration"],
+                fields=stimulus_entry["fields"],
+                ramp_up_time=stimulus_entry.get("ramp_up_time", 0.0),
+                ramp_down_time=stimulus_entry.get("ramp_down_time", 0.0),
+                node_set=node_set,
+                compartment_set=compartment_set,
+            )
         elif pattern == Pattern.SECLAMP:
             return SEClamp(
                 target=target_name,
@@ -534,3 +548,32 @@ class SEClamp(Stimulus):
     durations: Optional[list[float]]
     voltages: Optional[list[float]]
     series_resistance: float
+
+
+@dataclass(frozen=True, config=dict(extra="forbid"))
+class SpatiallyUniformEField(Stimulus):
+    fields: list[dict[str, float]]
+    ramp_up_time: NonNegativeFloat = 0.0
+    ramp_down_time: NonNegativeFloat = 0.0
+
+    @field_validator("fields")
+    @classmethod
+    def validate_fields(cls, v):
+        if not v:
+            raise ValueError("fields list cannot be empty")
+        
+        for i, field_dict in enumerate(v):
+            if "Ex" not in field_dict or "Ey" not in field_dict or "Ez" not in field_dict:
+                raise ValueError(
+                    f"Field {i} must contain Ex, Ey, and Ez components"
+                )
+            
+            frequency = field_dict.get("frequency", 0.0)
+            if frequency < 0:
+                raise ValueError(f"Field {i} frequency must be non-negative")
+            
+            phase = field_dict.get("phase", 0.0)
+            if not isinstance(phase, (int, float)):
+                raise ValueError(f"Field {i} phase must be a number")
+        
+        return v
diff --git a/bluecellulab/stimulus/extracellular.py b/bluecellulab/stimulus/extracellular.py
index ba9c44d4..f07169ca 100644
--- a/bluecellulab/stimulus/extracellular.py
+++ b/bluecellulab/stimulus/extracellular.py
@@ -111,7 +111,7 @@ def compute_potentials(self, displacement_vec):
 
     def apply_ramp(self, signal_vec, step):
         """Apply linear ramp up and down to signal.
-        
+
         Args:
             signal_vec: hoc Vector to apply ramp to
             step: time step in ms
diff --git a/tests/test_stimulus/test_extracellular.py b/tests/test_stimulus/test_extracellular.py
index 10b03044..965b344e 100644
--- a/tests/test_stimulus/test_extracellular.py
+++ b/tests/test_stimulus/test_extracellular.py
@@ -191,14 +191,78 @@ def test_iadd_combining_sources():
 def test_iadd_different_dt_raises():
     """Test that combining sources with different dt raises assertion error."""
     es1 = ElectrodeSource(
-        base_amp=0, delay=0, duration=10, fields=[], 
+        base_amp=0, delay=0, duration=10, fields=[],
         ramp_up_time=0, ramp_down_time=0, dt=1.0
     )
-    
+
     es2 = ElectrodeSource(
-        base_amp=0, delay=0, duration=10, fields=[], 
+        base_amp=0, delay=0, duration=10, fields=[],
         ramp_up_time=0, ramp_down_time=0, dt=0.5
     )
-    
+
     with pytest.raises(AssertionError, match="multiple extracellular stimuli must have common dt"):
         es1 += es2
+
+
+def test_interp_axon_positions():
+    """Test axon position interpolation."""
+    from bluecellulab.cell import Cell
+
+    soma_position = np.array([0.0, 0.0, 0.0])
+
+    # Test axon[0]
+    pos = Cell.interp_axon_positions(0.0, 0, soma_position)
+    np.testing.assert_allclose(pos, [0.0, 0.0, 0.0])
+
+    pos = Cell.interp_axon_positions(0.5, 0, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -15.0, 0.0])
+
+    pos = Cell.interp_axon_positions(1.0, 0, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -30.0, 0.0])
+
+    # Test axon[1]
+    pos = Cell.interp_axon_positions(0.0, 1, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -30.0, 0.0])
+
+    pos = Cell.interp_axon_positions(0.5, 1, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -45.0, 0.0])
+
+    pos = Cell.interp_axon_positions(1.0, 1, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -60.0, 0.0])
+
+
+def test_interp_axon_positions_error():
+    """Test that more than 2 axon sections raises error."""
+    from bluecellulab.cell import Cell
+
+    soma_position = np.array([0.0, 0.0, 0.0])
+
+    with pytest.raises(ValueError, match="More than 2 axon sections exist"):
+        Cell.interp_axon_positions(0.5, 2, soma_position)
+
+
+def test_interp_myelin_positions():
+    """Test myelin position interpolation."""
+    from bluecellulab.cell import Cell
+
+    soma_position = np.array([0.0, 0.0, 0.0])
+
+    # Test myelin[0]
+    pos = Cell.interp_myelin_positions(0.0, 0, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -60.0, 0.0])
+
+    pos = Cell.interp_myelin_positions(0.5, 0, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -560.0, 0.0])
+
+    pos = Cell.interp_myelin_positions(1.0, 0, soma_position)
+    np.testing.assert_allclose(pos, [0.0, -1060.0, 0.0])
+
+
+def test_interp_myelin_positions_error():
+    """Test that more than 1 myelin section raises error."""
+    from bluecellulab.cell import Cell
+
+    soma_position = np.array([0.0, 0.0, 0.0])
+
+    with pytest.raises(ValueError, match="More than 1 myelin section exist"):
+        Cell.interp_myelin_positions(0.5, 1, soma_position)

From 5748b30464ae2162f6ead9d4269fe839e482a968 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 12 Apr 2026 10:26:38 +0200
Subject: [PATCH 04/14] Fix mypy type annotations in e-field implementation

- Import Callable from typing instead of using builtins.callable
- Add proper type annotation for func_loc2glob parameter
- Change return type to Optional[np.ndarray] for get_segment_position
- Add type annotation for cell_targets dict in circuit_simulation.py
- Remove unused variable post_sec_id (ruff F841)
---
 bluecellulab/cell/core.py          | 8 +++-----
 bluecellulab/circuit_simulation.py | 2 +-
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index b00faf5e..3c6acc55 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -19,7 +19,7 @@
 
 from pathlib import Path
 import queue
-from typing import Iterable, List, Optional, Tuple
+from typing import Callable, Iterable, List, Optional, Tuple
 from typing_extensions import deprecated
 
 import neuron
@@ -564,8 +564,6 @@ def add_replay_minis(self,
         sid = synapse_id[1]
 
         weight = syn_description[SynapseProperty.G_SYNX]
-        # numpy int to int
-        post_sec_id = int(syn_description[SynapseProperty.POST_SECTION_ID])
 
         weight_scalar = connection_modifiers.get('Weight', 1.0)
         exc_mini_frequency, inh_mini_frequency = mini_frequencies \
@@ -888,8 +886,8 @@ def get_segment_position(
         soma_local_position: np.ndarray,
         section: NeuronSection,
         x: float,
-        func_loc2glob: Optional[callable] = None,
-    ) -> np.ndarray:
+        func_loc2glob: Optional[Callable[[np.ndarray], np.ndarray]] = None,
+    ) -> Optional[np.ndarray]:
         """Get the global coordinates of the segment.
         For axon and myelin, interpolate along the y-axis of the local soma coordinates,
         and then convert to global coordinates.
diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 86f07ee5..7652399a 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -566,7 +566,7 @@ def _add_extracellular_stimulus(
             stimulus: SpatiallyUniformEField stimulus definition
             targets: list of (cell_id, section, segx, section_name) tuples
         """
-        cell_targets = {}
+        cell_targets: dict[CellId, list[tuple]] = {}
         for cell_id, sec, segx, sec_name in targets:
             if cell_id not in cell_targets:
                 cell_targets[cell_id] = []

From eaebfdcf5f73bf17554b1a871a1365df4c3bb663 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 12 Apr 2026 10:31:56 +0200
Subject: [PATCH 05/14] Fix test and linting issues for e-field stimulus

- Add spatially_uniform_e_field to test_pattern_from_sonata_valid test
- Fix docformatter issue in circuit_simulation.py (wrap docstring)
- All 68 stimulus tests pass
- All 58 cell core tests pass
---
 bluecellulab/circuit_simulation.py                       | 3 ++-
 tests/test_stimulus/test_circuit_stimulus_definitions.py | 1 +
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 7652399a..2289677f 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -560,7 +560,8 @@ def _add_extracellular_stimulus(
         stimulus: circuit_stimulus_definitions.SpatiallyUniformEField,
         targets: list[tuple],
     ) -> None:
-        """Process extracellular e-field stimulus and accumulate into ElectrodeSource per cell.
+        """Process extracellular e-field stimulus and accumulate into
+        ElectrodeSource per cell.
 
         Args:
             stimulus: SpatiallyUniformEField stimulus definition
diff --git a/tests/test_stimulus/test_circuit_stimulus_definitions.py b/tests/test_stimulus/test_circuit_stimulus_definitions.py
index 0a40427a..621a5044 100644
--- a/tests/test_stimulus/test_circuit_stimulus_definitions.py
+++ b/tests/test_stimulus/test_circuit_stimulus_definitions.py
@@ -35,6 +35,7 @@ def test_pattern_from_sonata_valid():
         "relative_shot_noise": Pattern.RELATIVE_SHOT_NOISE,
         "ornstein_uhlenbeck": Pattern.ORNSTEIN_UHLENBECK,
         "relative_ornstein_uhlenbeck": Pattern.RELATIVE_ORNSTEIN_UHLENBECK,
+        "spatially_uniform_e_field": Pattern.SPATIALLY_UNIFORM_E_FIELD,
         "seclamp": Pattern.SECLAMP,
     }
 

From a776d1947717ef754e7bdf40d31ad9c639d2a84a Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 12 Apr 2026 10:45:32 +0200
Subject: [PATCH 06/14] Add tests to increase coverage to 94%

- Add tests for ElectrodeSource.__iadd__() edge cases (delay, non-overlapping, concatenation)
- Add test for cleanup() method
- Add tests for Pattern.from_blueconfig() method
- Add tests for SINUSOIDAL and SECLAMP patterns in from_sonata()
- Coverage increased from 93% to 94%
---
 .../test_circuit_stimulus_definitions.py      |  68 +++++++++++-
 tests/test_stimulus/test_extracellular.py     | 104 ++++++++++++++++++
 2 files changed, 171 insertions(+), 1 deletion(-)

diff --git a/tests/test_stimulus/test_circuit_stimulus_definitions.py b/tests/test_stimulus/test_circuit_stimulus_definitions.py
index 621a5044..2224bb7d 100644
--- a/tests/test_stimulus/test_circuit_stimulus_definitions.py
+++ b/tests/test_stimulus/test_circuit_stimulus_definitions.py
@@ -49,6 +49,30 @@ def test_pattern_from_sonata_invalid():
         Pattern.from_sonata("unknown_pattern")
 
 
+def test_pattern_from_blueconfig_valid():
+    """Test valid mappings from blueconfig strings to Pattern enum values."""
+    valid_patterns = {
+        "Noise": Pattern.NOISE,
+        "Hyperpolarizing": Pattern.HYPERPOLARIZING,
+        "Pulse": Pattern.PULSE,
+        "RelativeLinear": Pattern.RELATIVE_LINEAR,
+        "SynapseReplay": Pattern.SYNAPSE_REPLAY,
+        "ShotNoise": Pattern.SHOT_NOISE,
+        "RelativeShotNoise": Pattern.RELATIVE_SHOT_NOISE,
+        "OrnsteinUhlenbeck": Pattern.ORNSTEIN_UHLENBECK,
+        "RelativeOrnsteinUhlenbeck": Pattern.RELATIVE_ORNSTEIN_UHLENBECK,
+    }
+
+    for blueconfig_pattern, expected_enum in valid_patterns.items():
+        assert Pattern.from_blueconfig(blueconfig_pattern) == expected_enum
+
+
+def test_pattern_from_blueconfig_invalid():
+    """Test that an invalid blueconfig pattern raises a ValueError."""
+    with pytest.raises(ValueError, match="Unknown pattern unknown_pattern"):
+        Pattern.from_blueconfig("unknown_pattern")
+
+
 def test_noise_requires_exactly_one_mean_field():
     """Noise dataclass should validate exactly one of mean/mean_percent."""
     with pytest.raises(ValueError, match="Noise stimulus must define exactly one of 'mean' or 'mean_percent'."):
@@ -177,8 +201,50 @@ def test_from_sonata_spatially_uniform_e_field_defaults():
         "node_set": "TestTarget",
         "fields": [{"Ex": 50, "Ey": -25, "Ez": 75}],
     }
-    
+
     stim = Stimulus.from_sonata(entry)
     assert isinstance(stim, SpatiallyUniformEField)
     assert stim.ramp_up_time == 0.0
     assert stim.ramp_down_time == 0.0
+
+
+def test_from_sonata_sinusoidal():
+    """Test parsing SONATA sinusoidal stimulus."""
+    from bluecellulab.stimulus.circuit_stimulus_definitions import Sinusoidal
+
+    entry = {
+        "module": "sinusoidal",
+        "delay": 0.0,
+        "duration": 10.0,
+        "node_set": "TestTarget",
+        "amp_start": 0.1,
+        "frequency": 10.0,
+    }
+
+    stim = Stimulus.from_sonata(entry)
+    assert isinstance(stim, Sinusoidal)
+    assert stim.delay == 0.0
+    assert stim.duration == 10.0
+    assert stim.amp_start == 0.1
+    assert stim.frequency == 10.0
+
+
+def test_from_sonata_seclamp():
+    """Test parsing SONATA seclamp stimulus."""
+    from bluecellulab.stimulus.circuit_stimulus_definitions import SEClamp
+
+    entry = {
+        "module": "seclamp",
+        "delay": 0.0,
+        "duration": 10.0,
+        "node_set": "TestTarget",
+        "voltage": -70.0,
+        "series_resistance": 0.02,
+    }
+
+    stim = Stimulus.from_sonata(entry)
+    assert isinstance(stim, SEClamp)
+    assert stim.delay == 0.0
+    assert stim.duration == 10.0
+    assert stim.voltage == -70.0
+    assert stim.series_resistance == 0.02
diff --git a/tests/test_stimulus/test_extracellular.py b/tests/test_stimulus/test_extracellular.py
index 965b344e..28ec5889 100644
--- a/tests/test_stimulus/test_extracellular.py
+++ b/tests/test_stimulus/test_extracellular.py
@@ -204,6 +204,110 @@ def test_iadd_different_dt_raises():
         es1 += es2
 
 
+def test_iadd_with_delay():
+    """Test combining sources with delay."""
+    es1 = ElectrodeSource(
+        base_amp=0,
+        delay=2,
+        duration=10,
+        fields=[{"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    es2 = ElectrodeSource(
+        base_amp=0,
+        delay=5,
+        duration=10,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    es1 += es2
+
+    assert len(es1.time_vec) > 0
+    assert es1.time_vec[0] == 0
+
+
+def test_iadd_non_overlapping():
+    """Test combining sources with non-overlapping time ranges."""
+    es1 = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=5,
+        fields=[{"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    es2 = ElectrodeSource(
+        base_amp=0,
+        delay=10,
+        duration=5,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    es1 += es2
+
+    assert len(es1.time_vec) > 0
+
+
+def test_iadd_time_concatenation():
+    """Test combining sources with time vector concatenation edge case."""
+    es1 = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=5,
+        fields=[{"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    es2 = ElectrodeSource(
+        base_amp=0,
+        delay=5,
+        duration=5,
+        fields=[{"Ex": 100, "Ey": -50, "Ez": 50, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    es1 += es2
+
+    assert len(es1.time_vec) > 0
+    assert es1.time_vec[0] == 0
+
+
+def test_cleanup():
+    """Test that cleanup() clears references."""
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=10,
+        fields=[{"Ex": 50, "Ey": -25, "Ez": 75, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+
+    assert es.efields is not None
+    assert es.segment_displacements is not None
+
+    es.cleanup()
+
+    assert es.efields is None
+    assert es.segment_displacements is None
+
+
 def test_interp_axon_positions():
     """Test axon position interpolation."""
     from bluecellulab.cell import Cell

From 14bd377021721f3c239c17bb5773d440ab11fb33 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Mon, 13 Apr 2026 08:04:57 +0200
Subject: [PATCH 07/14] Fix pycodestyle W293 errors - remove trailing
 whitespace from blank lines

---
 bluecellulab/cell/core.py                     | 18 ++++----
 bluecellulab/circuit_simulation.py            |  2 +-
 .../stimulus/circuit_stimulus_definitions.py  |  8 ++--
 bluecellulab/stimulus/extracellular.py        | 46 +++++++++----------
 4 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index 3c6acc55..8e3bce4c 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -837,21 +837,21 @@ def n_segments(self) -> int:
 
     def compute_segment_coordinates(self) -> dict[str, np.ndarray]:
         """Compute 3D coordinates of segment endpoints for all sections.
-        
+
         Extracts 3D point data from NEURON sections and interpolates segment
         boundary positions along the section axis. Used for extracellular
         stimulus displacement calculations.
-        
+
         Returns:
             Dictionary mapping section names to arrays of shape (nseg+1, 3)
             containing [x, y, z] coordinates of segment endpoints in micrometers.
             Sections without 3D point data return empty arrays.
         """
         segment_coords = {}
-        
+
         for section in self.sections.values():
             n_pts = int(neuron.h.n3d(sec=section))
-            
+
             if n_pts == 0:
                 logger.warning(
                     f"Section {section.name()} has no 3D points, "
@@ -859,23 +859,23 @@ def compute_segment_coordinates(self) -> dict[str, np.ndarray]:
                 )
                 segment_coords[section.name()] = np.array([])
                 continue
-            
+
             arc_positions = np.array([neuron.h.arc3d(i, sec=section) for i in range(n_pts)])
             x_coords = np.array([neuron.h.x3d(i, sec=section) for i in range(n_pts)])
             y_coords = np.array([neuron.h.y3d(i, sec=section) for i in range(n_pts)])
             z_coords = np.array([neuron.h.z3d(i, sec=section) for i in range(n_pts)])
-            
+
             if section.L > 0:
                 arc_normalized = arc_positions / section.L
             else:
                 arc_normalized = arc_positions
-            
+
             seg_positions = np.linspace(0, 1, section.nseg + 1)
-            
+
             x_interp = np.interp(seg_positions, arc_normalized, x_coords)
             y_interp = np.interp(seg_positions, arc_normalized, y_coords)
             z_interp = np.interp(seg_positions, arc_normalized, z_coords)
-            
+
             segment_coords[section.name()] = np.column_stack((x_interp, y_interp, z_interp))
 
         return segment_coords
diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 2289677f..547bce34 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -458,7 +458,7 @@ def _add_stimuli(
                 if add_extracellular_stimuli:
                     self._add_extracellular_stimulus(stimulus, targets)
                 continue
-            
+
             for cell_id, sec, segx, sec_name in targets:
                 if isinstance(stimulus, circuit_stimulus_definitions.Noise):
                     if add_noise_stimuli:
diff --git a/bluecellulab/stimulus/circuit_stimulus_definitions.py b/bluecellulab/stimulus/circuit_stimulus_definitions.py
index 5edf6c3a..5db45ad8 100644
--- a/bluecellulab/stimulus/circuit_stimulus_definitions.py
+++ b/bluecellulab/stimulus/circuit_stimulus_definitions.py
@@ -561,19 +561,19 @@ class SpatiallyUniformEField(Stimulus):
     def validate_fields(cls, v):
         if not v:
             raise ValueError("fields list cannot be empty")
-        
+
         for i, field_dict in enumerate(v):
             if "Ex" not in field_dict or "Ey" not in field_dict or "Ez" not in field_dict:
                 raise ValueError(
                     f"Field {i} must contain Ex, Ey, and Ez components"
                 )
-            
+
             frequency = field_dict.get("frequency", 0.0)
             if frequency < 0:
                 raise ValueError(f"Field {i} frequency must be non-negative")
-            
+
             phase = field_dict.get("phase", 0.0)
             if not isinstance(phase, (int, float)):
                 raise ValueError(f"Field {i} phase must be a number")
-        
+
         return v
diff --git a/bluecellulab/stimulus/extracellular.py b/bluecellulab/stimulus/extracellular.py
index f07169ca..373eceae 100644
--- a/bluecellulab/stimulus/extracellular.py
+++ b/bluecellulab/stimulus/extracellular.py
@@ -21,10 +21,10 @@
 
 class ElectrodeSource:
     """Constructs an extracellular potential field as the sum of multiple user-defined e-fields.
-    
+
     Applies the resulting signal to segment's e_extracellular reference.
     Adapted from Neurodamus stimuli.py for BlueCelluLab.
-    
+
     Args:
         base_amp: baseline amplitude when signal is inactive
         delay: start time delay in ms
@@ -45,11 +45,11 @@ def __init__(self, base_amp, delay, duration, fields, ramp_up_time, ramp_down_ti
         self.dt = dt
         self.ramp_up_time = ramp_up_time
         self.ramp_down_time = ramp_down_time
-        
+
         if delay > 0:
             self.time_vec.append(self._cur_t)
             self._cur_t = delay
-        
+
         self.efields = self.add_cosines()
         self.segment_displacements = {}
         self.segment_potentials = []
@@ -61,7 +61,7 @@ def delay_time(self, duration):
 
     def add_cosines(self):
         """Add multiple cosinusoidal signals.
-        
+
         Returns:
             numpy array of shape (3, n_timepoints) for Ex, Ey, Ez field components
         """
@@ -70,13 +70,13 @@ def add_cosines(self):
         tvec.indgen(self._cur_t, self._cur_t + total_duration, self.dt)
         self.time_vec.append(tvec)
         self.delay_time(total_duration)
-        
+
         self.time_vec.append(self._cur_t + self.dt)
-        
+
         res_x = neuron.h.Vector(len(self.time_vec))
         res_y = neuron.h.Vector(len(self.time_vec))
         res_z = neuron.h.Vector(len(self.time_vec))
-        
+
         for field in self.fields:
             vec = neuron.h.Vector(len(tvec))
             freq = field.get("frequency", 0)
@@ -84,14 +84,14 @@ def add_cosines(self):
             Ex = field["Ex"]
             Ey = field["Ey"]
             Ez = field["Ez"]
-            
+
             vec.sin(freq, phase + np.pi / 2, self.dt)
             self.apply_ramp(vec, self.dt)
-            
+
             if self._delay > 0:
                 vec.insrt(0, self._base_amp)
             vec.append(self._base_amp)
-            
+
             res_x.add(vec.c().mul(Ex))
             res_y.add(vec.c().mul(Ey))
             res_z.add(vec.c().mul(Ez))
@@ -100,10 +100,10 @@ def add_cosines(self):
 
     def compute_potentials(self, displacement_vec):
         """Compute potential at a segment given displacement from reference point.
-        
+
         Args:
             displacement_vec: 3D displacement vector in meters [dx, dy, dz]
-            
+
         Returns:
             numpy array of potentials in mV over time
         """
@@ -134,10 +134,10 @@ def apply_segment_potentials(self):
         for segment, displacement in self.segment_displacements.items():
             section = segment.sec
             e_ext_vec = neuron.h.Vector(self.compute_potentials(displacement))
-            
+
             if not section.has_membrane("extracellular"):
                 section.insert("extracellular")
-            
+
             e_ext_vec.play(segment.extracellular._ref_e, self.time_vec, 0)
             self.segment_potentials.append(e_ext_vec)
 
@@ -150,17 +150,17 @@ def cleanup(self):
 
     def __iadd__(self, other):
         """Combine with another ElectrodeSource object.
-        
+
         Merges time vectors and sums overlapping e-fields.
-        
+
         Args:
             other: another ElectrodeSource instance
-            
+
         Returns:
             self with combined time vector and e-fields
         """
         assert np.isclose(self.dt, other.dt), "multiple extracellular stimuli must have common dt"
-        
+
         combined_time_vec, self.efields = self._combine_time_efields(
             self.time_vec.as_numpy(),
             self.efields,
@@ -176,13 +176,13 @@ def __iadd__(self, other):
     @staticmethod
     def _combine_time_efields(t1_vec, efields1, t2_vec, efields2, is_delay1, is_delay2, dt):
         """Combine time and efields vectors from 2 ElectrodeSource objects.
-        
+
         Args:
             t1_vec, t2_vec: numpy arrays of time points
             efields1, efields2: arrays of shape (3, n_timepoints) for Ex, Ey, Ez
             is_delay1, is_delay2: whether stimuli have delays
             dt: time step
-            
+
         Returns:
             tuple of (combined_time_vec, combined_efields)
         """
@@ -198,11 +198,11 @@ def _combine_time_efields(t1_vec, efields1, t2_vec, efields2, is_delay1, is_dela
 
         if not (t1_ticks[-1] < t2_ticks[0] or t2_ticks[-1] < t1_ticks[0]):
             combined_time_ticks = np.union1d(t1_ticks, t2_ticks)
-            
+
             idx1_left = np.searchsorted(t1_ticks, combined_time_ticks, side="right") - 1
             idx1_right = np.searchsorted(t1_ticks, combined_time_ticks, side="left")
             mask1 = idx1_left == idx1_right
-            
+
             idx2_left = np.searchsorted(t2_ticks, combined_time_ticks, side="right") - 1
             idx2_right = np.searchsorted(t2_ticks, combined_time_ticks, side="left")
             mask2 = idx2_left == idx2_right

From 13e4230af0329a837def081aa13984b92a749e87 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 26 Apr 2026 11:00:58 +0200
Subject: [PATCH 08/14] fix: merge main, fix examples, lint, tox race
 conditions, and docformatter

---
 bluecellulab/cell/core.py                     |  15 +++--
 bluecellulab/stimulus/extracellular.py        |  12 ++--
 .../singlecell_H5_morph_H5_container.ipynb    |  10 ++-
 .../extracellular-efield-stimulus.ipynb       |  15 +++--
 .../compartment_set.h5                        | Bin 33928 -> 33928 bytes
 .../compartment_set_ik.h5                     | Bin 0 -> 33928 bytes
 .../output_sonata_compartment_set/node_set.h5 | Bin 33928 -> 33928 bytes
 .../output_sonata_compartment_set/spikes.h5   | Bin 11016 -> 11016 bytes
 .../simulation_config_efield.json             |  58 ++++++++++++++++++
 tests/test_stimulus/test_extracellular.py     |  48 +++++++--------
 tox.ini                                       |   5 ++
 11 files changed, 117 insertions(+), 46 deletions(-)
 create mode 100644 examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/compartment_set_ik.h5
 create mode 100644 examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_efield.json

diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index 8e3bce4c..d1518f63 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -888,9 +888,9 @@ def get_segment_position(
         x: float,
         func_loc2glob: Optional[Callable[[np.ndarray], np.ndarray]] = None,
     ) -> Optional[np.ndarray]:
-        """Get the global coordinates of the segment.
-        For axon and myelin, interpolate along the y-axis of the local soma coordinates,
-        and then convert to global coordinates.
+        """Get the global coordinates of the segment. For axon and myelin,
+        interpolate along the y-axis of the local soma coordinates, and then
+        convert to global coordinates.
 
         Args:
             sec_seg_points: segment global positions in the current section
@@ -930,9 +930,11 @@ def get_segment_position(
     def interp_axon_positions(x: float, axon_index: int, soma_position: np.ndarray) -> np.ndarray:
         """Interpolate the coordinates of the axon segment for the given x,
         because of no 3d point for the new axons.
-        Assume that the axon is oriented along the y-axis from soma, 30 um displaced for 1st axon,
-        60 um for 2nd axon, the same x- and z-coordinates as soma.
-        x=0 is soma, and x=1 is the end of the axon section.
+
+        Assume that the axon is oriented along the y-axis from soma, 30
+        um displaced for 1st axon, 60 um for 2nd axon, the same x- and
+        z-coordinates as soma. x=0 is soma, and x=1 is the end of the
+        axon section.
         """
         if axon_index > 1:
             raise ValueError("More than 2 axon sections exist!")
@@ -955,6 +957,7 @@ def interp_axon_positions(x: float, axon_index: int, soma_position: np.ndarray)
     def interp_myelin_positions(x: float, myelin_index: int, soma_position: np.ndarray) -> np.ndarray:
         """Interpolate the coordinates of the myelin segment for the given x,
         because of no 3d point for the new myelin section.
+
         Assume that the myelin is oriented along the y-axis from soma,
         1000 um displaced after the 2nd axon, i.e. [soma-60, soma-1000]
         """
diff --git a/bluecellulab/stimulus/extracellular.py b/bluecellulab/stimulus/extracellular.py
index 373eceae..6f7c0c84 100644
--- a/bluecellulab/stimulus/extracellular.py
+++ b/bluecellulab/stimulus/extracellular.py
@@ -20,7 +20,8 @@
 
 
 class ElectrodeSource:
-    """Constructs an extracellular potential field as the sum of multiple user-defined e-fields.
+    """Constructs an extracellular potential field as the sum of multiple user-
+    defined e-fields.
 
     Applies the resulting signal to segment's e_extracellular reference.
     Adapted from Neurodamus stimuli.py for BlueCelluLab.
@@ -55,7 +56,8 @@ def __init__(self, base_amp, delay, duration, fields, ramp_up_time, ramp_down_ti
         self.segment_potentials = []
 
     def delay_time(self, duration):
-        """Increments the ref time so that the next created signal is delayed."""
+        """Increments the ref time so that the next created signal is
+        delayed."""
         self._cur_t += duration
         return self
 
@@ -99,7 +101,8 @@ def add_cosines(self):
         return np.array([res_x, res_y, res_z])
 
     def compute_potentials(self, displacement_vec):
-        """Compute potential at a segment given displacement from reference point.
+        """Compute potential at a segment given displacement from reference
+        point.
 
         Args:
             displacement_vec: 3D displacement vector in meters [dx, dy, dz]
@@ -130,7 +133,8 @@ def apply_ramp(self, signal_vec, step):
                 signal_vec[vec_len - ramp_down_number + i] *= ramp_down[i]
 
     def apply_segment_potentials(self):
-        """Apply potentials to segment.extracellular._ref_e for all segments."""
+        """Apply potentials to segment.extracellular._ref_e for all
+        segments."""
         for segment, displacement in self.segment_displacements.items():
             section = segment.sec
             e_ext_vec = neuron.h.Vector(self.compute_potentials(displacement))
diff --git a/examples/1-singlecell/singlecell_H5_morph_H5_container.ipynb b/examples/1-singlecell/singlecell_H5_morph_H5_container.ipynb
index 7c7c1486..84a51bcc 100644
--- a/examples/1-singlecell/singlecell_H5_morph_H5_container.ipynb
+++ b/examples/1-singlecell/singlecell_H5_morph_H5_container.ipynb
@@ -80,12 +80,10 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "# First delete previous compiled mod files\n",
-    "! rm -r arm64 # for mac-based systems\n",
-    "! rm -r x86_64 # for linux-based systems\n",
-    "# Compile mod files\n",
-    "data_folder=\"../../tests/examples/container_nbS1-O1__202247__cADpyr__L5_TPC_A\"\n",
-    "!nrnivmodl $data_folder/mod\n"
+    "# Compile mechanisms - examples/mechanisms contains all required mod files\n",
+    "!nrnivmodl ../mechanisms\n",
+    "# Path to cell model data folder\n",
+    "data_folder = \"../../tests/examples/container_nbS1-O1__202247__cADpyr__L5_TPC_A\""
    ]
   },
   {
diff --git a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
index 319f4d32..6f319e34 100644
--- a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
+++ b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
@@ -70,10 +70,13 @@
    "outputs": [],
    "source": [
     "# Load the base simulation config\n",
-    "base_config_path = Path(\"./sim_quick_scx_sonata_multicircuit/simulation_config.json\")\n",
+    "base_config_path = Path(\"./sim_quick_scx_sonata_multicircuit/simulation_config_noinput.json\")\n",
     "with open(base_config_path, 'r') as f:\n",
     "    sim_config = json.load(f)\n",
     "\n",
+    "# Extend simulation time to cover delay + duration + ramp\n",
+    "sim_config[\"run\"][\"tstop\"] = 300.0\n",
+    "\n",
     "# Add extracellular e-field stimulus\n",
     "sim_config[\"inputs\"] = {\n",
     "    \"extracellular_efield\": {\n",
@@ -81,7 +84,7 @@
     "        \"module\": \"spatially_uniform_e_field\",\n",
     "        \"delay\": 50.0,\n",
     "        \"duration\": 200.0,\n",
-    "        \"node_set\": \"l4pc\",\n",
+    "        \"node_set\": \"Mosaic_A\",\n",
     "        \"fields\": [\n",
     "            {\"Ex\": 100, \"Ey\": -50, \"Ez\": 50, \"frequency\": 0},\n",
     "            {\"Ex\": 50, \"Ey\": 0, \"Ez\": 0, \"frequency\": 10}\n",
@@ -117,7 +120,7 @@
     "sim = CircuitSimulation(modified_config_path)\n",
     "\n",
     "# Select a few cells from the target population\n",
-    "target_cells = sim.circuit_access.get_target_cell_ids(\"l4pc\")\n",
+    "target_cells = sim.circuit_access.get_target_cell_ids(\"Mosaic_A\")\n",
     "cells_to_simulate = list(target_cells)[:3]\n",
     "\n",
     "print(f\"Simulating {len(cells_to_simulate)} cells: {cells_to_simulate}\")"
@@ -162,7 +165,7 @@
    "source": [
     "# Record soma voltage for all cells\n",
     "for cell_id in sim.cells:\n",
-    "    sim.cells[cell_id].add_voltage_recording()"
+    "    sim.cells[cell_id].add_voltage_recording(sim.cells[cell_id].soma)"
    ]
   },
   {
@@ -204,8 +207,8 @@
     "for i, cell_id in enumerate(cells_to_simulate):\n",
     "    cell = sim.cells[cell_id]\n",
     "    time = cell.get_time()\n",
-    "    voltage = cell.get_voltage_recording()\n",
-    "    \n",
+    "    voltage = cell.get_soma_voltage()\n",
+    "\n",
     "    axes[i].plot(time, voltage, linewidth=0.8)\n",
     "    axes[i].set_ylabel(f\"Cell {cell_id}\\nVoltage (mV)\")\n",
     "    axes[i].axvspan(50, 60, alpha=0.2, color='green', label='Ramp up')\n",
diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/compartment_set.h5 b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/compartment_set.h5
index a6cff9c3516a3a81a11a3ff8a2280a070624c0d3..12278f4f47c12070af821f6cabbc491ad2fc6500 100644
GIT binary patch
literal 33928
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
Z!oQy1ZTfHLyZ?!EgP+Y&V*Vq1{|mH=@tObt

literal 33928
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
N;1@nh=)Z;U{{UYC8Xo`v

diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/compartment_set_ik.h5 b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/compartment_set_ik.h5
new file mode 100644
index 0000000000000000000000000000000000000000..27ba76cff1638baf31e027295158c47b113150bf
GIT binary patch
literal 33928
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
P=k(S`p|?B#!}os!N89Fu

literal 0
HcmV?d00001

diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/node_set.h5 b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/node_set.h5
index 80331282806f1488bda76647419c0679fe494986..242773258d8d3ceb60b1c19c5c5ea92e66e24788 100644
GIT binary patch
literal 33928
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
bpEn%%=l)&cf9vo5C)N$F_fdTQBYgi0mlV2X

literal 33928
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

diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/spikes.h5 b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/output_sonata_compartment_set/spikes.h5
index e9ff9c7caae9503ba8e6c6a15fdcdbf232dc8d8c..6893b37189e65289598d5aeffc11e0339316da38 100644
GIT binary patch
delta 576
zcmWkpO-NKx7=1xtO*TkEsEc6|u}y*S1eGZ}=`12Dg<y~(!OcT3&BTHhF@w-JQ84$r
zmlhLYKh!uyf;cKc1iH}GL;RU0rGi8$2p1tD5-vP<bvXC@eCMWOsn~c$Fzzh*zTcn5
zr^Alp=rlT($>-D9dYQ>&_R?ryBtM}LXmH*9X@y$)5)lR1+%<)#7P}O(#4FtjZ%3FL
zRQP9cSm7jlDn+5#$ozAK*lo}IJ*E(Ca$R>?g%DU_a8{v%=ob{~UNQKM2YNlvGgHAx
zeE&6HE(>xIM%o0M7CQwKUzzL?_(cD%VDb(Vj|AZ&c~bD=D8G~u?3|<jjo>eN;-g^S
z>R$wn0qQe?Br&lfSU%5*Yl4D(|09StGq)>oR3D?^zo4J!1T{kM_@{D>ngJd>rE%s0
zjddEUt1Pb9*tYs5jU!nOzp9ZfW&Wnd#F`zfQ41dG)4*}|4QcGsSNT|DhVSk(jlNOx
zQR;*2&&3%Cvf#5u;vx-m8l^cFFYpj~ew_pE(YV0@-#K81`VZnEgBpt^2E`WostmS>
zZrGr@mHe!M|DHX~1_g_texE(p4SrE~ZyAjI<lr*TVEO|WJutWtWibD+>`B!DZVCYT

delta 576
zcmWkqPe_ze9Q=fctz;F0a1CVZU>A|#Gp#h8s6&L=Ay~vHsKX<2S(QX7s9j>Stq%Ks
z?~(8X33O8tgK(>ZQP@FGA3@n4B)b&U)x&1csd=aQX6DVjd0!z_NIkEQXIpm!K`>lI
z?n4wsx`^Zx=iF)$FVae>zr?mM4C^#9Q_dw0X*|5H)UV?jrFQDQ8e1N(Xv{L-b4{c3
zDEWv+!Q*|6ee6q!M$Gq3Y8*TkhUI4(r-|V!-H0Lo@lNBdH$G`h><oh3R~D|b(7ud!
zWG6c4oE6Ly!}EeWpXpo{)OV5(2-F}a4GVgAF?mmr{KBV<3)*IQwG&kQxoJV3+${>O
zo?zb_L7Et@2$nrx7ku=%A&7NR|1DT3F~2QYq$rgC33flF5I4y0;Xm7J&`0hL7&Lb?
zaM+-_n)(rgrVS1}V-TCAf6f3NFB&X)eZZjq1_x&hM!?)%gKheW2L=`D>ajs)j(m<j
z(amQWILQI84H~|&V3mc$=)J*8oEQEuSR>|sazG9FAL1tcDvLhPV-_Wk`z^+)_arU0
wJa4g3r`X$NF+Ivbuvqr|g2k=xJa@?=y}$vr$|66;Wj8G<G@|nD+D8rl0iCq(@c;k-

diff --git a/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_efield.json b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_efield.json
new file mode 100644
index 00000000..53c6a55e
--- /dev/null
+++ b/examples/2-sonata-network/sim_quick_scx_sonata_multicircuit/simulation_config_efield.json
@@ -0,0 +1,58 @@
+{
+  "manifest": {
+    "$OUTPUT_DIR": "."
+  },
+  "run": {
+    "tstop": 300.0,
+    "dt": 0.025,
+    "random_seed": 1
+  },
+  "conditions": {
+    "v_init": -65
+  },
+  "target_simulator": "NEURON",
+  "network": "circuit_sonata.json",
+  "node_set": "Mosaic_A",
+  "output": {
+    "output_dir": "$OUTPUT_DIR/output_sonata_noinput",
+    "spikes_file": "out.h5",
+    "spikes_sort_order": "by_time"
+  },
+  "inputs": {
+    "extracellular_efield": {
+      "input_type": "extracellular_stimulation",
+      "module": "spatially_uniform_e_field",
+      "delay": 50.0,
+      "duration": 200.0,
+      "node_set": "Mosaic_A",
+      "fields": [
+        {
+          "Ex": 100,
+          "Ey": -50,
+          "Ez": 50,
+          "frequency": 0
+        },
+        {
+          "Ex": 50,
+          "Ey": 0,
+          "Ez": 0,
+          "frequency": 10
+        }
+      ],
+      "ramp_up_time": 10.0,
+      "ramp_down_time": 10.0
+    }
+  },
+  "reports": {
+    "soma": {
+      "cells": "Mosaic_A",
+      "variable_name": "v",
+      "type": "compartment",
+      "dt": 1.0,
+      "start_time": 0.0,
+      "end_time": 20.0,
+      "sections": "soma",
+      "compartments": "center"
+    }
+  }
+}
\ No newline at end of file
diff --git a/tests/test_stimulus/test_extracellular.py b/tests/test_stimulus/test_extracellular.py
index 28ec5889..14c0363c 100644
--- a/tests/test_stimulus/test_extracellular.py
+++ b/tests/test_stimulus/test_extracellular.py
@@ -37,54 +37,54 @@ def test_electrode_source_init():
 def test_apply_ramp_case1():
     """Test ramp application when ramp_up/down_time > dt and is multiple of dt."""
     import neuron
-    
+
     dt = 0.5
     ramp_up_time = 2.0
     ramp_down_time = 1.5
-    
+
     es = ElectrodeSource(0, 0, 100, [], ramp_up_time, ramp_down_time, dt)
     stim_vec = neuron.h.Vector(list(range(1, 11)))
-    
+
     assert np.isclose(es.ramp_up_time, ramp_up_time)
     assert np.isclose(es.ramp_down_time, ramp_down_time)
     assert np.isclose(es.dt, dt)
-    
+
     es.apply_ramp(stim_vec, es.dt)
-    
-    expected = [0, 2/3, 2, 4, 5, 6, 7, 8, 4.5, 0]
+
+    expected = [0, 2 / 3, 2, 4, 5, 6, 7, 8, 4.5, 0]
     np.testing.assert_allclose(stim_vec.as_numpy(), expected)
 
 
 def test_apply_ramp_case2():
     """Test ramp when ramp_up/down_time > dt but not multiple of dt."""
     import neuron
-    
+
     dt = 0.5
     ramp_up_time = 2.4
     ramp_down_time = 1.7
-    
+
     es = ElectrodeSource(0, 0, 100, [], ramp_up_time, ramp_down_time, dt)
     stim_vec = neuron.h.Vector(list(range(1, 11)))
-    
+
     es.apply_ramp(stim_vec, es.dt)
-    
-    expected = [0, 2/3, 2, 4, 5, 6, 7, 8, 4.5, 0]
+
+    expected = [0, 2 / 3, 2, 4, 5, 6, 7, 8, 4.5, 0]
     np.testing.assert_allclose(stim_vec.as_numpy(), expected)
 
 
 def test_apply_ramp_case3():
     """Test ramp when ramp_up/down_time < dt (no ramp applied)."""
     import neuron
-    
+
     dt = 0.5
     ramp_up_time = 0.3
     ramp_down_time = 0.4
-    
+
     es = ElectrodeSource(0, 0, 100, [], ramp_up_time, ramp_down_time, dt)
     stim_vec = neuron.h.Vector(list(range(1, 11)))
-    
+
     es.apply_ramp(stim_vec, es.dt)
-    
+
     expected = list(range(1, 11))
     np.testing.assert_allclose(stim_vec.as_numpy(), expected)
 
@@ -100,9 +100,9 @@ def test_dc_field():
         ramp_down_time=0,
         dt=1.0,
     )
-    
+
     assert es.efields.shape[0] == 3
-    
+
     for i in range(3):
         field_values = es.efields[i]
         assert np.all(field_values[1:-1] != 0)
@@ -119,7 +119,7 @@ def test_ac_field():
         ramp_down_time=0,
         dt=1.0,
     )
-    
+
     assert es.efields.shape[0] == 3
 
 
@@ -137,7 +137,7 @@ def test_multi_field_summation():
         ramp_down_time=0,
         dt=1.0,
     )
-    
+
     assert len(es.fields) == 2
     assert es.efields.shape[0] == 3
 
@@ -153,10 +153,10 @@ def test_compute_potentials():
         ramp_down_time=0,
         dt=1.0,
     )
-    
+
     displacement = np.array([1e-6, 2e-6, 3e-6])
     potentials = es.compute_potentials(displacement)
-    
+
     assert len(potentials) == len(es.time_vec)
 
 
@@ -171,7 +171,7 @@ def test_iadd_combining_sources():
         ramp_down_time=0,
         dt=1.0,
     )
-    
+
     es2 = ElectrodeSource(
         base_amp=0,
         delay=5,
@@ -181,10 +181,10 @@ def test_iadd_combining_sources():
         ramp_down_time=0,
         dt=1.0,
     )
-    
+
     original_len = len(es1.time_vec)
     es1 += es2
-    
+
     assert len(es1.time_vec) >= original_len
 
 
diff --git a/tox.ini b/tox.ini
index 27621d68..2fd7e135 100644
--- a/tox.ini
+++ b/tox.ini
@@ -59,6 +59,11 @@ deps =
     nbmake>=1.5.1
     scipy>=1.11.1
     seaborn>=0.12.2
+allowlist_externals =
+    bash
+commands_pre =
+    bash -c "cd examples/1-singlecell && rm -rf arm64 x86_64 && nrnivmodl ../mechanisms"
+    bash -c "cd examples/2-sonata-network && rm -rf arm64 x86_64 && nrnivmodl ../mechanisms"
 commands =
     pytest --ignore=examples/7-Extra-Simulation/ --numprocesses=auto --forked --nbmake examples # exclude long tests
 

From 660eb24955028b46c89a7f9437e351c2ea7e64e0 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 26 Apr 2026 11:42:40 +0200
Subject: [PATCH 09/14] fix: apply extracellular e-field to all segments, not
 just soma

Previously _add_extracellular_stimulus only iterated over the soma
segments from the resolved targets list (seg_list), causing the
e-field displacement to be ~zero and producing no visible effect.

Neurodamus iterates over all sections/segments of each target cell.
This fix replaces the seg_list loop with iteration over all sections
and segments of each cell, matching the neurodamus implementation.

Verified: voltage difference with vs without e-field increased from
~0 mV to >48 mV.
---
 bluecellulab/circuit_simulation.py            |  62 +++++----
 .../extracellular-efield-stimulus.ipynb       | 129 +++++++++++++++---
 2 files changed, 146 insertions(+), 45 deletions(-)

diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 0962a058..5f32c2f7 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -627,45 +627,49 @@ def _add_extracellular_stimulus(
 
             soma_position = np.mean(soma_coords_all, axis=0)
 
-            for sec, segx in seg_list:
-                sec_coords = segment_coords.get(sec.name())
-                segment_position = None
-
-                if sec_coords is None or len(sec_coords) == 0:
-                    # Try axon/myelin interpolation for sections without 3D points
-                    if not sec.n3d():
-                        try:
-                            segment_position = cell.get_segment_position(
-                                np.array([]), soma_position, sec, segx, func_loc2glob=None
-                            )
-                        except ValueError:
+            n_segments = 0
+            for sec in cell.sections.values():
+                for seg in sec:
+                    segx = seg.x
+                    sec_coords = segment_coords.get(sec.name())
+                    segment_position = None
+
+                    if sec_coords is None or len(sec_coords) == 0:
+                        # Try axon/myelin interpolation for sections without 3D points
+                        if not sec.n3d():
+                            try:
+                                segment_position = cell.get_segment_position(
+                                    np.array([]), soma_position, sec, segx, func_loc2glob=None
+                                )
+                            except ValueError:
+                                logger.warning(
+                                    f"Section {sec.name()} has no 3D coordinates and "
+                                    "could not interpolate, skipping"
+                                )
+                                continue
+                        else:
                             logger.warning(
-                                f"Section {sec.name()} has no 3D coordinates and "
-                                "could not interpolate, skipping"
+                                f"Section {sec.name()} has no 3D coordinates, skipping"
                             )
                             continue
                     else:
-                        logger.warning(
-                            f"Section {sec.name()} has no 3D coordinates, skipping"
-                        )
-                        continue
-                else:
-                    seg_idx = int(segx * sec.nseg)
-                    if seg_idx >= len(sec_coords):
-                        seg_idx = len(sec_coords) - 1
-                    segment_position = sec_coords[seg_idx]
+                        seg_idx = int(segx * sec.nseg)
+                        if seg_idx >= len(sec_coords):
+                            seg_idx = len(sec_coords) - 1
+                        segment_position = sec_coords[seg_idx]
 
-                if segment_position is None:
-                    continue
+                    if segment_position is None:
+                        continue
 
-                displacement_vec = (segment_position - soma_position) * 1e-6
+                    displacement_vec = (segment_position - soma_position) * 1e-6
 
-                segment = sec(segx)
-                es.segment_displacements[segment] = displacement_vec
+                    segment = sec(segx)
+                    es.segment_displacements[segment] = displacement_vec
+                    n_segments += 1
 
             logger.debug(
                 f"Added extracellular stimulus to cell {cell_id} "
-                f"with {len(seg_list)} target segments"
+                f"with {n_segments} target segments"
             )
 
     def _apply_extracellular_stimuli(self) -> None:
diff --git a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
index 6f319e34..d3f0d755 100644
--- a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
+++ b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
@@ -22,9 +22,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "/Users/mandge/Desktop/obi/repos/BlueCelluLab/examples/2-sonata-network\n",
+      "cfiles =\n",
+      "Mod files: \"../mechanisms/Ca.mod\" \"../mechanisms/CaDynamics_DC0.mod\" \"../mechanisms/CaDynamics_E2.mod\" \"../mechanisms/Ca_HVA.mod\" \"../mechanisms/Ca_HVA2.mod\" \"../mechanisms/Ca_LVAst.mod\" \"../mechanisms/DetAMPANMDA.mod\" \"../mechanisms/DetGABAAB.mod\" \"../mechanisms/GluSynapse.mod\" \"../mechanisms/Ih.mod\" \"../mechanisms/Im.mod\" \"../mechanisms/K_Pst.mod\" \"../mechanisms/K_Tst.mod\" \"../mechanisms/KdShu2007.mod\" \"../mechanisms/NaTa_t.mod\" \"../mechanisms/NaTg.mod\" \"../mechanisms/NaTs2_t.mod\" \"../mechanisms/Nap_Et2.mod\" \"../mechanisms/ProbAMPANMDA_EMS.mod\" \"../mechanisms/ProbGABAAB_EMS.mod\" \"../mechanisms/SK_E2.mod\" \"../mechanisms/SKv3_1.mod\" \"../mechanisms/StochKv.mod\" \"../mechanisms/StochKv3.mod\" \"../mechanisms/TTXDynamicsSwitch.mod\" \"../mechanisms/VecStim.mod\" \"../mechanisms/gap.mod\" \"../mechanisms/netstim_inhpoisson.mod\"\n",
+      "\n",
+      "MODOBJS= ./Ca.o ./CaDynamics_DC0.o ./CaDynamics_E2.o ./Ca_HVA.o ./Ca_HVA2.o ./Ca_LVAst.o ./DetAMPANMDA.o ./DetGABAAB.o ./GluSynapse.o ./Ih.o ./Im.o ./K_Pst.o ./K_Tst.o ./KdShu2007.o ./NaTa_t.o ./NaTg.o ./NaTs2_t.o ./Nap_Et2.o ./ProbAMPANMDA_EMS.o ./ProbGABAAB_EMS.o ./SK_E2.o ./SKv3_1.o ./StochKv.o ./StochKv3.o ./TTXDynamicsSwitch.o ./VecStim.o ./gap.o ./netstim_inhpoisson.o\n",
+      " -> \u001b[32mCompiling\u001b[0m mod_func.cpp\n",
+      " => \u001b[32mLINKING\u001b[0m shared library \"/Users/mandge/Desktop/obi/repos/BlueCelluLab/examples/2-sonata-network/arm64/./libnrnmech.dylib\"\n",
+      "Successfully created arm64/special\n"
+     ]
+    }
+   ],
    "source": [
     "!nrnivmodl ../mechanisms"
    ]
@@ -38,7 +53,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -65,9 +80,40 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "E-field stimulus configuration:\n",
+      "{\n",
+      "  \"input_type\": \"extracellular_stimulation\",\n",
+      "  \"module\": \"spatially_uniform_e_field\",\n",
+      "  \"delay\": 50.0,\n",
+      "  \"duration\": 200.0,\n",
+      "  \"node_set\": \"Mosaic_A\",\n",
+      "  \"fields\": [\n",
+      "    {\n",
+      "      \"Ex\": 100,\n",
+      "      \"Ey\": -50,\n",
+      "      \"Ez\": 50,\n",
+      "      \"frequency\": 0\n",
+      "    },\n",
+      "    {\n",
+      "      \"Ex\": 50,\n",
+      "      \"Ey\": 0,\n",
+      "      \"Ez\": 0,\n",
+      "      \"frequency\": 10\n",
+      "    }\n",
+      "  ],\n",
+      "  \"ramp_up_time\": 10.0,\n",
+      "  \"ramp_down_time\": 10.0\n",
+      "}\n"
+     ]
+    }
+   ],
    "source": [
     "# Load the base simulation config\n",
     "base_config_path = Path(\"./sim_quick_scx_sonata_multicircuit/simulation_config_noinput.json\")\n",
@@ -112,9 +158,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulating 3 cells: [CellId(population_name='NodeA', id=0), CellId(population_name='NodeA', id=1), CellId(population_name='NodeA', id=2)]\n"
+     ]
+    }
+   ],
    "source": [
     "# Create simulation\n",
     "sim = CircuitSimulation(modified_config_path)\n",
@@ -137,9 +191,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Section cNAC_L23BTC_bluecellulab_6308c0c97dda4190af9f1b220cca022e[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_6308c0c97dda4190af9f1b220cca022e[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_6308c0c97dda4190af9f1b220cca022e[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_ccc1c1ac43644916a4cc251a6ad864e2[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_ccc1c1ac43644916a4cc251a6ad864e2[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_ccc1c1ac43644916a4cc251a6ad864e2[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b7a5e075dd80467381fbf545f8ccb7f2[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b7a5e075dd80467381fbf545f8ccb7f2[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b7a5e075dd80467381fbf545f8ccb7f2[0].myelin[0] has no 3D points, cannot compute segment coordinates\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Instantiated 3 cells\n",
+      "E-field sources created: 3\n"
+     ]
+    }
+   ],
    "source": [
     "sim.instantiate_gids(\n",
     "    cells=cells_to_simulate,\n",
@@ -159,7 +237,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -177,9 +255,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulation completed!\n"
+     ]
+    }
+   ],
    "source": [
     "sim.run()\n",
     "print(\"Simulation completed!\")"
@@ -196,9 +282,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x900 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "fig, axes = plt.subplots(len(cells_to_simulate), 1, figsize=(12, 3*len(cells_to_simulate)), sharex=True)\n",
     "if len(cells_to_simulate) == 1:\n",
@@ -248,7 +345,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": ".venv",
    "language": "python",
    "name": "python3"
   },
@@ -262,7 +359,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.0"
+   "version": "3.12.13"
   }
  },
  "nbformat": 4,

From c9b6e35c3c3e1d5e192b8928a5d7dff2152e14fc Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Sun, 26 Apr 2026 12:05:40 +0200
Subject: [PATCH 10/14] generate figure for efield stimulus notebook

---
 .../extracellular-efield-stimulus.ipynb       | 39 ++++++-------------
 1 file changed, 12 insertions(+), 27 deletions(-)

diff --git a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
index d3f0d755..dff7507a 100644
--- a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
+++ b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
@@ -22,24 +22,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "/Users/mandge/Desktop/obi/repos/BlueCelluLab/examples/2-sonata-network\n",
-      "cfiles =\n",
-      "Mod files: \"../mechanisms/Ca.mod\" \"../mechanisms/CaDynamics_DC0.mod\" \"../mechanisms/CaDynamics_E2.mod\" \"../mechanisms/Ca_HVA.mod\" \"../mechanisms/Ca_HVA2.mod\" \"../mechanisms/Ca_LVAst.mod\" \"../mechanisms/DetAMPANMDA.mod\" \"../mechanisms/DetGABAAB.mod\" \"../mechanisms/GluSynapse.mod\" \"../mechanisms/Ih.mod\" \"../mechanisms/Im.mod\" \"../mechanisms/K_Pst.mod\" \"../mechanisms/K_Tst.mod\" \"../mechanisms/KdShu2007.mod\" \"../mechanisms/NaTa_t.mod\" \"../mechanisms/NaTg.mod\" \"../mechanisms/NaTs2_t.mod\" \"../mechanisms/Nap_Et2.mod\" \"../mechanisms/ProbAMPANMDA_EMS.mod\" \"../mechanisms/ProbGABAAB_EMS.mod\" \"../mechanisms/SK_E2.mod\" \"../mechanisms/SKv3_1.mod\" \"../mechanisms/StochKv.mod\" \"../mechanisms/StochKv3.mod\" \"../mechanisms/TTXDynamicsSwitch.mod\" \"../mechanisms/VecStim.mod\" \"../mechanisms/gap.mod\" \"../mechanisms/netstim_inhpoisson.mod\"\n",
-      "\n",
-      "MODOBJS= ./Ca.o ./CaDynamics_DC0.o ./CaDynamics_E2.o ./Ca_HVA.o ./Ca_HVA2.o ./Ca_LVAst.o ./DetAMPANMDA.o ./DetGABAAB.o ./GluSynapse.o ./Ih.o ./Im.o ./K_Pst.o ./K_Tst.o ./KdShu2007.o ./NaTa_t.o ./NaTg.o ./NaTs2_t.o ./Nap_Et2.o ./ProbAMPANMDA_EMS.o ./ProbGABAAB_EMS.o ./SK_E2.o ./SKv3_1.o ./StochKv.o ./StochKv3.o ./TTXDynamicsSwitch.o ./VecStim.o ./gap.o ./netstim_inhpoisson.o\n",
-      " -> \u001b[32mCompiling\u001b[0m mod_func.cpp\n",
-      " => \u001b[32mLINKING\u001b[0m shared library \"/Users/mandge/Desktop/obi/repos/BlueCelluLab/examples/2-sonata-network/arm64/./libnrnmech.dylib\"\n",
-      "Successfully created arm64/special\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "!nrnivmodl ../mechanisms"
    ]
@@ -198,15 +183,15 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Section cNAC_L23BTC_bluecellulab_6308c0c97dda4190af9f1b220cca022e[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_6308c0c97dda4190af9f1b220cca022e[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_6308c0c97dda4190af9f1b220cca022e[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_ccc1c1ac43644916a4cc251a6ad864e2[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_ccc1c1ac43644916a4cc251a6ad864e2[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_ccc1c1ac43644916a4cc251a6ad864e2[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cADpyr_L2TPC_bluecellulab_b7a5e075dd80467381fbf545f8ccb7f2[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cADpyr_L2TPC_bluecellulab_b7a5e075dd80467381fbf545f8ccb7f2[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
-      "Section cADpyr_L2TPC_bluecellulab_b7a5e075dd80467381fbf545f8ccb7f2[0].myelin[0] has no 3D points, cannot compute segment coordinates\n"
+      "Section cNAC_L23BTC_bluecellulab_da083b03534845b48cdfd8b406265650[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_da083b03534845b48cdfd8b406265650[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_da083b03534845b48cdfd8b406265650[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_902a11d68e21497f839c788402f3a3ec[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_902a11d68e21497f839c788402f3a3ec[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_902a11d68e21497f839c788402f3a3ec[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_ff297d0e788c4afea357b943aa3f863b[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_ff297d0e788c4afea357b943aa3f863b[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_ff297d0e788c4afea357b943aa3f863b[0].myelin[0] has no 3D points, cannot compute segment coordinates\n"
      ]
     },
     {
@@ -287,7 +272,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKUAAAOICAYAAAAHKEItAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd4k9XbBvC7TdI23aXMllVm2Xsv2XuDiAqKDBFB/VyIIipuEVEBJwqiArIFBdkiyJK9t+xN927Gdz2npv+2tNCUtln3z+u9WtKMk+TNa9+7z3mOm9lsNoOIiIiIiIiIiKgQuRfmgxEREREREREREQmGUkREREREREREVOgYShERERERERERUaFjKEVERERERERERIWOoRQRERERERERERU6hlJERERERERERFToGEoREREREREREVGhYyhFRERERERERESFjqEUEREREREREREVOoZSREROaMSIEahatSr+/vvvu17vwIED6nrPPvusVfcvtxk8eHCmy4xGIy5evAh7d+nSJTX+7LZatWqhZcuWePrpp3H48GFbD9XpnDt3Ll/vb+nSpTm+lxm3MWPG5On+Y2JiEBERAXs3ffp09Ty3bduWaR9/8cUX83R/7dq1Q+vWrVGYY7/X9u677+Z67Lm9r507d6p/T5s2LU9jz+44mB15X+S68lxzY8eOHRg3bpw6FtWsWRNNmjTBI488gp9//hkpKSn3/Gzd7/t/v1555RX1+OfPn7fJ4xMRkWPR2noARESU/wYMGIAtW7Zg5cqVaNGiRY7XW7Zsmfo6cODA+3o8CaNGjx6NLl26qJMpR1ChQgU15ozi4+Nx6NAhLF++XL1+CxcuRHh4uM3G6EwmTZqkQtINGzbk+3137NhRbTkpVaqU1fe5efNmvPzyy/j8889VKEAFa9CgQWjQoEGOP69YsaJV9/fRRx/d877kq1xPAhR78d1336kxyXFHgqiiRYsiMjJSHY8mT56sjunff/89vL2904PTUaNGoXz58vjggw/UZUWKFFH3UaZMGRs/GyIiontjKEVE5ISkWiAoKAhr167Fm2++CS8vrzuuI39xX7VqFUJDQ9G8efP7DqVOnz4NRyIne7179872Zw0bNsSrr76qKhtmzpxZ6GNzRn/++Se02oL5tUNChZzey7zau3cvoqKi8vU+KWd169bN1/cwN/d1t2OALVy/fl1VbcnxWMIpd/f/TWiQ4ElCp9mzZ2Pu3LnpgboEVvv27VOhlIUEVvb0vIiIiO6G0/eIiJyQh4eHOimRyp+NGzdme51NmzYhOjoa/fr1y3TyQ0Dfvn1VkLd7926+HERUKPbv34/U1FS0adMm22OyBFNubm74559/+I4QEZHT4FkIEZETT+ETMt0jp6l7cuJjuZ7lpEj+At+4cWPVy0Sm482YMQPJyck5Po5UEw0bNkx9L9eVqhXpaSLi4uLw6aefomfPnqoSQu6zQ4cO6i/+EphlFBsbq3q9PPDAA6q3k4RlEpw9/vjjqvIrI5my8uGHH6J9+/bqPqX3yoQJE3DlyhXkB3ldsqsuM5lM+PHHH1XgV7t2bVVRJf279uzZc8d1pf+LPIf69eujXr16ePDBB1UPpIyGDBmipp0dOXJETdWpU6eOei4y1S27XkYypeyxxx5T9ymPL+OQqgkZV9Z+Mt988w1++eUX9OjRI71Xlkz/kfcko+3bt6v7bNasmbpe165d1XuWlJSU6XqyD0jVmOwTlj43zzzzDE6ePHnX19IyHqkCuXz58h29dfKyz+WV9N2R90LGfuvWrUz7nuxj8rrKdeR9+eqrr9TPhg4dmr7/WfofSdDbrVs3NV5LTyGz2aymez788MNqv6hRo4Z6zZ9//vlse+v88ccfePTRR9WUNXnu8piWnlB52d/uRe5fxm4wGPLU70hel9dee029FvK85fPcp08ftZ9n7Sck+5Hsq23btlXfy2tgj3LqKXX27Fk1ZvlMyHPt1KlTtp+J7Bw7dkztz40aNVLvl0wBzW1fMl9fX/V1xYoV2VbpybS8gwcPqioqIccTGZvleC7PRZ5Tdj2l5P2XY4H0ypPjtXwOZL8bP368Op4eP34cTzzxhLrccgzKeKzI2rfMQvYnuVzuPyd3690ln5+s0yelgvehhx5S47NU0MmUxYzHOSIich6cvkdE5KQqV66sQg7pRSInOIGBgek/k5MkuVxOPkqWLJl+IvDCCy+oEx85WQ4ODsbWrVvVyYhc94cffsg2qJFQRaYCSghi6e0j9yEnK3JCL6GFnGDI9xJErV69Wk1BuXHjBj755BN1HxJAyGOeOHFCVSnJiaBMSZEG1X5+fukna0Kqu+T+JICSXliVKlVSJ/0LFixQIZYEMeXKlbuv104qpOQ1k9cnI3l95HXq3LmzCplkLHJiKCdk8lwkUBFz5szB+++/j+7du6vrSfWDnDRKcCYnthJcWMjjSCgk4YScwMpJrYQb0uxY7tvy3OWkTII4eW4jR46EXq/H+vXrVZAnJ33yPmWsrpDXQ15veSzpqbRmzRoVIMgJ6Mcff5weCMl9Va9eHU899RQ8PT1V36cvv/xShRByIi7k/ZUTVrm+nCBKUCghkzyGPD8ZmwQ62bH0t5FxyvjkNbCchOZ1n8sqMTHxrif+AQEB0Gg0aoqTBCuySUAn/aLE66+/rgKzqVOnqutIqCD7nfS/ku8lWMlITvb79++vgkSdTqcuk+cnAZLs/xJoSEgl4ZE8R9mXZSqt5boS7sljy+sg9y+vu7yWEjjJzyTMsWZ/K2gyPVfCa3kv5LNXokQJ9fldvHixeh3ltZXLLeSzL6+RvKdy3LEcY+4mISHhru+hTEeWKqHcyum+5HMjW04k9JH9Wz538v7Kvin7vYSUEuBKCCzvV3akH528N/JzOd7JPiQBk3xOc0PCUjluS0gt4bw0m5fL5Ngg+4o8f6mCtZDgS0IlOS5IACb7iPTJyik8u3nzpjrWyHFJ9h2ZUiv98+RYKsdeCVrlcgld5Tgqj/fWW2+hMMnnRD4/0gvxueeeU2OQAFee4+3bt/HSSy8V6niIiKgQmImIyGn98ssv5ipVqpjnz5+f6fI5c+aoy9esWaP+HRsba27YsKG5SZMm5lu3bmW67pQpU9R1p0+fnn6Z/Puhhx5K//fff/+tLvv888/TL1u/fr267Lvvvst0fykpKeZWrVqZ69atm37ZrFmzsr3ul19+qS5v27Zt+mVvvPGGuXr16ua9e/dmuu7JkyfNNWvWNI8YMeKur8nFixfVfQ4aNMh8+/btTNuFCxfMy5cvV+OrUaOG+cCBA+m3+/3339Xtvv3220z3FxcXZ+7SpYt67RISEtRl3bt3N3ft2jXT9eLj49Xlr7/+evpljz76qLrPiRMnZvv+TJs2Tf1bxiXPWe5T7sfCZDKZn3/+eXXdpUuXZnp+8lrI7SyMRqO5Q4cO6nlZxvnWW2+p62Z9z5955hn1+iQnJ6t/f/PNN+p6q1atynS9GzduqOfdrVs3873Ia5rxfbR2n8vOkiVL1PXutR09ejTT7caNG6cuX716tXnx4sXq+9deey3TdT755BN1+Y4dO9Ivk/1bLnvppZcyXTciIkK9P08++eQdY5TXUm5z8OBB9W95T6pVq2Z+5JFH0l9fERkZaW7cuLG5d+/eVu9vlnHJ5zDjPvDCCy/csa+lpqZmur/sPrvyPsn7ZfHee++p6xw6dCjTbU+dOqUuHzVqVPpl48ePV5d9+umn5tywjP1eW3R0dK7uT8Z+t/vJ+DzlvZXL5L22fJ7kM9qmTRv1fmS0cOFCdV35LOR0HJT3tFatWuYzZ86kXybvsVwn62Pn5Nq1a+bhw4ffMW55vydMmJDpMy3OnTunfi6vu8Xd3v+vvvoq07FY9jm5XI45FgaDwdy8eXNz69at0y/Luo9ZyP4kl8v9Z90HZGzZvc4ZWV4bC9mX5P8NcrzKOB55bbP7fBERkeNjpRQRkROTv3y/9957agpfxkoG+eu4NPm1VGRIdYxU0MjKeVKtktHTTz+tKkCkYmPs2LG5fmyZWicVPJZVoixk2pRUrkiljUzHkOoZuW+5nlRWZCTVOV9//XX6v6X6RCqtZOU8qRjKWA0h45apHvJcpELIx8fnruOT6hWZnpOV/GVe7kcqUWTKlMXvv/+uvkrVStYqDJlCI5UU0utFqhukMkTGIRU/8h5I9YI8v99++y3bscg0uIykukluK1UDUi2wbt06VX0iVU0ZX08Z6//93/+p+5XXUKrMLGQaTsbVt+R1rlatGi5cuKCqs6RaxFLB8s4776jXXp63VL189tlnmcYjz93f319VbWR87nJdeb6//vorzpw5Y9UKafm5z0n1lkwly0nZsmUz/Vuqew4cOKCet1ToVKlSBRMnTsz12LMuDCBVPFJdZzQaM10uz89SlWOZCiXVV3I9qajJWPUiFUVSyWZ5f63Z3wqaTMmTfU+OGRby2bVMBcw6JVRYu3jC8OHD76hMzCjrceRepBozO3dbkU6qhU6dOqWOlfL8Mr7ucqyUCij5LMprkZU0HJd9QKY3yvHJQt5jqU6Sxvm5IVVos2bNUp8nqVjatWuXuq3c/5IlS9RnXarpWrVqhbyQ45GFVO7JcVSOBzJtN+PnunTp0uozUtjkmCSfSak8lOnPUsUp4/npp58KfSxERFQ4GEoRETkxmYIi0zEsUzRCQkLUdLqjR4+qk0DLdCIJKoRMhctKTqrlRM5yHWvICdmiRYvUybPcXnqdyBQkyzQcSyj177//qpOgjCfplttLoCA9f4ScJMoJlGzZBUoW165du2dAItNh5GRbyHQXmfon05HkxFh6XmUNSmSMQnpi5USmgAlZuU+mHkpvJNnkRFOmo0iYINNyMk5DkkCjWLFime5H3hd5zS0rGt7t/ZHXTU7YLX28LLLep7C8vpbwRIIRyxQz2WS6kUwJkhNr6T9jCVTkuctrdLfXXJ67NaFUfu5zcl1rQhAJgOSkVz4DYsqUKbmaJmiRdd8QElhIiCChk0x9lNdDglfLey2BqmUqnMgYXFhkfC2s2d8KmjwHCaBkX5aeRPK48t5Y+n5l1+snu9fobuS55+Y9lP3QcjywkNBCptlllJcVRaWXlJCplLJZ85rL50/e4+ymDme3j9+LfJZkkwBMPq/yOZVeUjLlTqbAyr6W9XiZG1mPC/LaZXe5HJct+2xhkpBapjBLCCWbvK9NmzZVnwMJaAtqBU8iIrIdHtmJiJyc9IKRfkbyF3ZZvUm+F9KPyeJeJx9yUmTtCZCcfEtPFgmSpGGtbFIBJNU4b7zxRqaV7aTnUk73L2GB5STUcvIrVUBZq4syyk0PG6nWynjiKkGMVEZJxYxUDc2bN08FRhby2BKWfPHFFzneZ1hYWHrgICGPnEj+9ddfqj+UVBNZGhNnbCqd0/OWEMByAnav90fGlvV+ctN/R56PVKJJ+CWhnIxT+ubICe+3336reltJgCP3L+HX22+/neN9hYeHwxoFsc9ZQ56nhVQSWjN+y4m8hfTckoBLqlqk/5Q0OZeKFKnykIbfGav9ZF/Pzftjzf52P7I2Ps+OBG1SsSefRQkmJSCQ3kfS6yinSq2sr1F+kc+VhDIZhYaG5rjKaF72SamUkgAkO/cKRWRfyCq3DbqlOlBCL0tYnvG1lOOnBMZSdSUVqPKZlf3LWjmN35p+XRllrQ6839tLNZ4cd6Q/l3x25Jgk1Wnyvsv/OySosvwxhYiInANDKSIiJycNcKV5s4RS8ld3mRYkl2U8obVMb7JU5mRtIi0nStY2D5fpRVIpIg3QZYnzrA13M5LxSeWFnKBkPJmVkzmpOrFMxZO/mktVkFRKZVcJIVPC5C/8OTUivhcJ6qTJ8Pz581VDXQlmLCdrEspI9YqcjGetKpC/7EvjZwkR5CRfqtHk5E9OImUT0qRXmlrLlDz5uUwZs7wWWacbyomtVF5Y3qOM70/WptsS/kn1iDQzt5Y8HxmX7A9SzSH7h1S/yJRPqRSRfUYCOnnu8l7Kc8l6QihTi2QfsabSKOtzyq99LrfkpF6as0sQKfuYfG9pKp0XMqVUAikJpqRZfUaWENhCXkvLa5+1gkaaaMsUMgldcru/5ZblcyX7VsZgIuMqhDmRykEJCOXYUbx48fTLZZ8obFLJmHVqXl4/71lZ3hsJp7IeX2Q/kcUCcpr+J5fLscdSbZVRdqsvZkeqoKTRvzTRl/c9KzkWWVbYs/bzdr8y7j93O5Zbc9us+5+87jJ9Uo5n8gcCOdbJ9F2ZHirHYwke5fWxTDsnIiLn8L9leoiIyGnJSY6c7Eq1jpxIZqySEjK1TKb6yV+hJaTISFZik6Aip8oBYVn1LWNFgPRAEZbwxUJO7CwnaZa/kktVifTfkZ4pGcm/My6NLic3UqUhJ+vyXDKSJc2ffPJJNS3rfqZ4SJWCTJuR1d8yLndvef5Z+y3JCZNUkUgfJHmdJJSSIEdWH7NUxVimM1mCmKzBm2WJdwtZvU/6qsgUOiErusltJCSTyzOexFlWyMvLSmzSW0lWGpOpnRlP8KXSJ+M45blLcCaPn5HsS7Jqn6wSl3Hlv+zIfWXcP+53n8srmT4qwZH0yJLnL6uLSSAol8nPMo43t1UuOe3rsp/L/p6xIkn2XwkX5HlnrFKSx5YAV3qdyeuS2/0ttyxhkky/s5DnJlViuXl+EghnDccs+8P9VstYQ56HBEYZN6nYyg+y6qdUXcmxxTJ90kJWo5PXPesxykIqCmUsUoEnq/VZyGsjn+fcsByXZTXIjPtixgBIQm0JpizTP7M79haE7PYfIVPD70WmLwsJ/DOSad0Zp0PK50JCKDmmZJyiKZ8Hy2eroCrwiIjIdlgpRUTkAqQBtpzcvv/++6pvUNYAQy6TKXWyvHivXr0waNAgFaJI5ZFM3ZGQQparz4mlAbJcV/pWSYgijc7l3zJlUE62pNJCTkJkGob8lV/+Gi5BlJzoSjAiVRiTJk1SzXXl8eQERk4Os1bmSNgj9yPhkUztqFOnDq5evaoqe+SERZ7H/ZCxyfLjMoXn448/VuGJVCxJ011Zmlx6ZEl1kjw/CRXk31LNJX/Jt5x8yWslr7dMX5TATSpapKJIKo/kr/xZey9JKCX3KdMSZUl6qa6R52Vp/C5hlpwQT506VTX0lrHIfcpS81KhI/cp75u1JMST28u0SllOXt4LeS4ydVEqryxNkaWCSqb3yXOSKh3p8SLvnbzm8lVep3tVbsj+JL3MpCqpfv366dM487rPZWQJXO9GnovsS7KPSc8xGbMlZJHKJOkDJj+zhECWnkhSNSdVSdJMPSfSdFreG6kokpNsOYGXig8JMCzBk+UkW8IEqZiT4E2ec8+ePVW4KFOWJICV+xHW7G+5PQbIa/T888+rz5vsP/KZyxj65kQeW8IHCQtkX5NKNglHZJ+Wz7XsA/dLgpy7BQ7y3mVs0l0Q5PGl+b18LmTasxwDpFpPppLJeymfQ+kVlxOZ+iu3GTZsmPrsyn4gr3Fue6PJcVkWd5DPiEzzlecrYYyMS6orLQGihJcWEhZKMCWfY9mH5HhVEGQ8EvhLBawE43JMlMeU8D5rP6/sqsgkOJQKLzmOyRgl9JOgT+4nYwAoYasExPLZkM+ATLOWY448N5mumJdeYUREZN8YShERuQA5+ZbpSTL9YfDgwdkGCBIMSBAhJzwyjUimWljCEDlRutsUGZmGJCe6cuImJy4yDUaqsyR4kmojCQCkGkXuT6pT5K/6EgDICY0lYJHHnDZtmgok5ORZqgHkBEhCi4y9heREXB5HTurl+ciJmvR+kp4rctKclz4rWcm0EQkOpLGzPL4EE3JiKOP54Ycf1PjkOcm4JWCSHlFy0mYhJ65yQionXTJOOYmT5/7ss8+mN9fO2ktGToYlhJD3Sh5bnkvG5y3hngQaUnVh6VEkJ3TyOsp7eq9KpexIuCRToaTiRYIoCSgkYJSgRE4O5YRQyHsnP5d9Q8YoAZVUGslqfhLgyf3ci4QhEkLJqoayr0kodT/7XEbSc0a2u5EwZcWKFWr88l7Jc7SQfVUqmuRnsm/Jv2Vs8jxlSpVUv0jQmhPZB+Q5fP755ypQEPK8JJiQoEGCRNnXu3fvrn4mz0/eS3nfZZ+X/UiqdOS1tKz4aM3+lhvSC0ruQwJQCd7k/ZNqLPnc3u25CdnHpBJIgigJDSWEkLBE3jPZxyV4keDsbivb3Yvcj2w5keC8oEMpIaGHBCDyuZUecBImSo86CW4lrMpuAQEL+TzKbeU9la+yP8v9yQqZQ4cOzdXjy/FGFkOQ8FF6Klmmf0rYL8dKCWozNpGXz6YE9fIZlp5vb775Zp6nod6N7C+yL0plphwPpapJjrlyXLhbfz8L2eckcJXPkxy35fguxwJ5jhlDKQl/5TnJY8m+Kq+/fJZkUQY5JrLRORGR83Ez22JpDSIiogykGbqcdGatipLwSsILqRqSE3hnIydaUm0gVWE82SIiIiIiV8OeUkREZHPyV3QJnqTaIiOpXJG+ORJMERERERGRc+H0PSIisjmZ3iTTVaQXi/Q2kul40kNFLpNpKzKVi4iIiIiInAtDKSIisjlp8C2rkVl6C8nKU9K7RZoNS38mCamIiIiIiMi5sKcUEREREREREREVOvaUIiIiIiIiIiKiQsdQioiIiIiIiIiICh1DKSIiIiIiIiIiKnQMpYiIiIiIiIiIqNAxlCIiIiIiIiIiokLHUIqIiIiIiIiIiAodQykiIiIiIiIiIip0DKWIiIiIiIiIiKjQMZQiIiIiIiIiIqJCx1CKiIiIiIiIiIgKHUMpIiIiIiIiIiIqdAyliIiIiIiIiIio0DGUIiIiIiIiIiKiQsdQioiIiIiIiIiICh1DKSIiIiIiIiIiKnQMpYiIiIiIiIiIqNAxlCIiIiIiIiIiokLHUIqIiIiIiIiIiAodQykiIiIiIiIiIip0DKWIiIiIiIiIiKjQMZQiIiIiIiIiIqJCx1CKiIiIiIiIiIgcJ5Qym82IiIhAVFRU/o6IiIiIiIiIiIicntaaK1+9ehULFizAli1bcOLECZhMJnW5RqNB9erV0bp1a/Tr1w8hISEFNV4iIiIiIiIiInICbmYpeboHqYiaMmUKNm7ciObNm6utUqVKCAwMVMFUZGSkCqn27t2Lv/76C23btsX48eMRHBxcOM+CiIiIiIiIiIicL5SS6qchQ4agR48e0Ol0d71uYmIiVqxYgfnz52P58uX5OVYiIiIiIiIiInKlUCo1NfWeYVR+3IaIiIiIiIiIiFxDrkIpi+TkZBw/fhzXrl1DSkoK9Ho9ihUrhvDwcHh6esKVyLTFGzduwMfHB25ubrYeDhERERERERGRXZCoKT4+HsWLF4e7u/v9NTqXMEp6Si1evFhVQEkvKQ8PDxVMyep7UhH14IMP4sUXX1SXuwIJpNq0aWPrYRARERERERER2aXNmzejZMmS9xdKTZ48GQcOHMB3332HunXrqtX2LIxGI/bt24e33noLb7/9ttpcgVRIWV5gX19fOHJ6GR0djYCAAFZ8kV2JT4nHuuPrEOgXCC+tl03GkGqMgbfHflQvVg96nZ9NxkD2edyMi4uHry8rZcm+cN8ke8T9krJliAFu7gfc6wEa2/yOZTYkIS4uCr7lOsJNl3ZuR2QPzE5yjh4XF6cKeSzZyX2FUn/88Qd++OEH1KxZ846fSUDVsGFDvPvuuxgxYoTLhFKWnUMCKUcPpSRYlOfgyDs8OR+3FDd4eXsh0D8Qep3eJmNIMbpB6+4BX19/6HWBNhkD2Z+0We86HjfJ7nDfJHvE/ZKyZXADEjwAnT+gsc3vWGZDImBKSvv/OUMpsiNmJztHv9dzyHliXwaSbN2+ffue09nY2JyIiIiIiIiIiHIjV5VSTzzxBF566SU89thjqipKGlVZekrdunULe/bsUVP7Ro0alasHJSIiIiIiIiIi15arUOrxxx9HqVKl8OOPP+Kbb75Rjc+lBEvKymTVvVq1aqmeUt26dSv4ERMRERERERERkWuEUqJz585qM5lMiImJQVJSkqqWCgoKcop5jkRERERERERkHel/lJqaypctn5jNZjUrTTIXe85apH1TxkXwCjyUsvjiiy8wfPhwBAYGqqqphx56CP7+/vc9ECIiIiIiIiJynPDk2rVriIqKsvVQnI7JZLpnX297ILlQyZIl7ys8szqUmjlzJgYPHgy9Xo+vvvoKXbt2ZShFRERERERE5EIsgZT0nPb29rbrqh5HXH1Po9HY7WsqY0xISFAL3glp91RooVTasq53fk9EREREREREzk9CE0sgFRwcbOvhOBWzA4RSQgqVhARTsh/kdSqfez6Pi4iIiIiIiIicmKWHlFRIkevy/u/9v5+eYgylXNzRqzEYt+iorYdBREREREREDsaeK3nIMd5/9/t5UO6Aji/VYMKRq3G2HgYRERERERERuRj2lHJxRXw8EJ2YCpPJDI2GKTcRERERERHlXYoxBQaTodBeQq27Fh4aj1xfv127drh8+XKmYht/f380aNAAkyZNuq+m3VQIodTx48fTv9+3b18eHpLsSbCvB4xmIDIhBUX9vGw9HCIiIiIiInLgQGrXpV2ISy282Ti+Ol80Lt3YqmDq1VdfRbdu3dT3JpMJp0+fxhtvvIHx48dj7ty5BThaylMo9c8//yC3GjVqlOvrku15e2hRyt8Tp27EMZQiIiIiIiKiPJMKKQmkPNw94Kn1LPBXMtmQrB5PHteaUMrPzw/FihVL/3eJEiXwzDPP4KWXXkJsbKz6OdlRKDVkyJBM/5byNlmmUJYA1Ol0iImJUcv/Scnb9u3bC2qsVECqFvfBkSsxaFaxKF9jIiIiIiIiui8SSHlpC2cmTkpKSr7cj4dHWqjl7p7Weluqp95//33s3bsXBoMBtWrVwttvv42KFSti586dmDBhAsaMGYNp06apMYwaNQp169bF66+/juvXr6Njx4744IMP1P1JptKkSRP8/fffOHr0KGrUqJF+X1nJfT/22GOZZqm98sor6qvc3/Tp03H27Fl4eXlh1apVKFmyJF5++WW0b98ejihXjc7lxbBs77zzDurUqYPff/9dTd/btWsX1q9fryqkhg8fXvAjpnxXo5Qv9l+M4itLRERERERELufChQv45ptv0KpVK/j4+KgpfaNHj0ZoaCh+/fVXLFiwAEajEVOmTEm/zY0bN1QW8uOPP6rrfvLJJ3jvvfdUcCTfS2C0YcOG9Ot//fXX6Ny5M5YuXaoqsyTESsljoLZu3TpVKCT31b9/f1XlJSGaI7J69b2pU6fizTffzJTolS5dWs3JlDeRHE/d0v7451yE2qmJiIiIiIiInJn0j6pXr57apAKqT58+KuOwhE5JSUl46KGHVIVS2bJlVWVT3759MwU/qampqgdVhQoV8Mgjj6ggS75KtVTbtm1RrVo1VdFk0bp1azz++OPqcaRKKiIiQlVO5UVAQAAmT56s7kvCLXkeS5YsgUs0Opepe1KKFh4enunyc+fOwdOz4OeMUv6rGeKL23EpuBSZiDJFvPkSExERERERkdOSyqJOnTohPj5eTYeT1fheeOEFBAUFqZ97e3tj8ODBWL58OQ4fPqzCJZl2V7Ro5pY3ZcqUUV9lKp2QyioLuSxjJVT9+vXTv/f19UVYWBjOnDmjAixr1axZM326oeXfcl8uEUo9/PDDar7isGHDVDAl1TWHDh1SHerHjRtXMKOkAqXXaVAzNAC7z0cwlCIiIiIiIiKnFhwcjHLlyqnvP/vsMwwYMED1h/rll19U32wJq+QyCanatWuHHj16qGDq+++/z3Q/Wm3mSMXSjyo7Wa8r0wHds7m+FAJlJT2tMt4+t/fllKHU2LFjVZf6RYsWqTmRonLlypg0aRJ69epVEGOkQtCgXBD+OReJvvVK8/UmIiIiIiIilyAVR9I7e9CgQZgzZw5GjhypemdLz6iVK1emB0Bbt269r5Y3GRuXywp/0seqatWqd1xPQjERFxeXvgrgpUuXUL58+fTrnDhxQk0XtARRUs3VuHFjuEQoJeTNko2cR6PyQZi27pSth0FERERERERUqGrXrq0qo7744gtVbBMYGIiEhATVyFymxm3fvh0///yzmnaXVxJwyQp80sNKqrNCQkLUv7OSoh+Z+idFQJK7rFmzRk0dzBhKXbx4UfW/GjhwoPr5kSNH8NFHH8FpQ6kZM2aolfX0er36/l6VVOSYlVInb8QiOiEVAd5pySwRERERERGRtZINyQ73OP/3f/+nAh4Jez7++GM8/fTTeOutt5CcnKwqmmR22GuvvaZ6bOdFz5491Sp+0mS9YcOG+Pbbb++Yhick+JLHleBKVvbr2LGjaqAeGRmZfp06deqoRunSoF3CKll0ztLfyilDqZ07d2Lo0KEqlJLvc5Ld3EdyDEV9PREW7IM9FyLQLryErYdDREREREREDkbrroWvzhdxqXGZmnwXJHk8edzc2rhxY7aXFylSRE3by1hwk7Xopn///upriRIl1BS6jLL+WwKljKQy6v3338/VGHv06IHevXvnmLHIInMffvih2hxdrt65jC9m1heWnEfD8ml9pRhKERERERERkbU8NB5oXLoxDCZDob14EkjJ4xJcp6cUOaeG5Ypg0Z6Lth4GEREREREROSgJiBgSUW4xlKJMlVITlx9GUqoRXjoNXxkiIiIiIiKi+5SfM87GjRsHZ5K2fiARgLCiPvDz0uLw5Wi+HkRERERERERUoBhKUTppoibVUrvP/6+rPxERERERERGRXYdSqamp+Oeff3Dw4EH1PTmmRuWLYPe5CFsPg4iIiIiIiIicXL6FUtHR0RgyZAg2b96Mxx9/HEajMb/umgpR/XJB2HM+Emazma87EREREREREdl/o/MiRYpgw4YNCA0NxbBhw6DRsFG2I6oR4o/4ZCPO305A+aI+th4OERERERERETmpfKuUcnd3V4GU8PX1za+7pULmqdWgeog/9l1kXykiIiIiIiIisnEoFR4ejmrVqqFVq1Z47LHHCnA4ZA/qlQ3E/gtRth4GEREREREROZwUAAmFuMnj5V67du1QtWrVbLedO3fmeLtffvkFTZs2Rb169fDzzz+r6+fG0qVL1WPm5JVXXlFbfrt48aJqryQuXbqkxitfHXL63nvvvacqoWSKXlhYGByF9EWaPn06FixYAIPBgM6dO2PixInw9PRUP79y5QreeOMN7Nq1C8WLF8f//d//oVu3bnB19coGYdaWs7YeBhERERERETkUCYh2AYgrxMeUmVqNAXjk+havvvpqtuf+AQEBOd5mypQpGDp0KPr3749ixYqhU6dOsGevvvoqGjdujDZt2qBUqVLYunWrynQcMpTq16/fXX9+/fp1/Prrr1i+fDlWrVoFe/Htt99i3rx5mDZtGnx8fPDCCy9gxowZ6quEVE8++SRKly6NZcuWqWDq5ZdfRqVKlVClShW4snplAnH0SgySUo3w0rE3GBEREREREeWG4b9ASgKitGKQgpX83+MZrAql/Pz8VLBkjdjYWBXyWNoWWXt7W9JoNHY73jz3lEpOTsbKlSsxfPhwVYr2+eefq0DHXsjqf7Nnz8b48ePRrFkz1K5dG+PGjcORI0fUz6WM7erVqyrtrFChAh566CG0bt0a+/btg6srHaRHoLcOhy9H23ooRERERERE5HAkkPIqhK0wgi+kT9WTdkZDhgxR0/wyTt+TbGH06NGoU6eOykekGEYyiezs3r0bffr0URnFs88+i8TExBwfNyUlBe+//75qpVSjRg113zKN0CIhIQGTJk1CkyZN1Pb666+rrEamA0rhjYxDxptx+t7HH3+MRx99NNPjfPLJJ3j88cfV9zExMXjppZdQv359tGzZEm+//TaSkpJgN6vvyQsolUVr1qxBXFwc3Nzc1OBlxT2ZAmcvTp06hcjISHTo0CH9sl69eqlNyBskYVXGpuxffPFFnqYIyuaoLOPP+hzqlgnEvguRaFAuyGZjI9eWvm/Cdp8x9bjqsR37c06Fc9wksjXum2SPuF9SDjtG5s0G0v4//t//z/n/9Dy+ftmdD5uzbAXN+sfLy3Fpy5YtKhiSYhypljpx4kSm+xo7dqzqxS39o27evKnaBElWMmbMmEyPFxERoWZsDRo0CFOnTsXvv/+OmTNnqpAqu/F8/fXX+PPPP9XjBgcHqyxGQiIJp4oWLYrXXnsNJ0+eVFmGtCmS2V8yU0ym7v3777+q/5U8nmQ3lvHKtMXvvvsOt27dUvcpJN+RgiP5udxWZpbJrDMJuN59911MnjxZfc3utcz4OmT3s3wJpaRBlkzPkxfg8uXLqFixokrWOnbsiAcffFDNqbSnQEpIAijzQffu3aveFAmoZM6nJH4eHh7qOUnZnaSE8tyCgoLwzDPPZAqxciM6OjrHBNQRyI4i6aqQD41FteJ67Dp7EwNrp+2kRIUtPiVeHQTlAGrU2uYzlmKMg94jSY3BoLU6wycnJcdNy1+LMh43iWyN+ybZI+6XlC1DHDRJSTAmxwEa2/yOZTYkIjkpGYaYaLhpZeoXWUMqeEwmkzoXznw+LN+b/vtaGL/D5+3x3nzzTRXuZBQSEoIVK1Zke31LLyaZ9iebPHf16EYjduzYofpVz58/X/XiLleuHF588UUVGEkglPG6EkJJ9iD9rC2h1ebNm9WxMuPraLmNtBaSQKhWrVrq3yNHjlQB1NmzZ9VjSZg0a9YsVaElJAw7fvw4vL29odPpoNfr1Xil+slyv3Kf5cuXx9q1a1WeI6GW5CcSdEmQtWHDBmzbtk3dzvJaSeYjWYrlsvRX32hU9ylTG+XcLSNLEHYvuToCSPgkL6yUfbVt21Z9bw/kpED6WWVHXhT5uaSPEyZMUC+UvEHyVUraJIiRkE1Swq+++kqV30koJaVwljc8NyT4ylht5Wgs6aU8j4wnV00rp2LJ/ut3bfRGVJC0KVqV9svnS6/V2+TFTjEaoHP3UmPw0jru55wK5rgp+wVDKbIn3DfJHnG/pGwZDECCF6DzBTS2+R3LbNDAzRgHH/8AuOl8bDIGRybn2rdv31a9imT7H81/XYLka2H0J87b48m5v+QcGWm1WvVcZHbYqFGj0i+X72VqnpAgSK4jX9WjazQqyImKilLT5ywkd5DXSMKgrNeViip5LIvatWurfCLz65h2fSms+fvvv1XbIbnt0aNH04+tUjAkoZDkF5bbShWXbBbyu2rG8VrG37VrVxU+DR48GOvXr0eLFi1U1dTBgwfV2LOuFiiXSXBVs2bNO8Yo9ylhlZeX1x0/y7dQSkrJZKDffPONqjySAUo4ZevA4sCBA6r7fXZkTqTsBLLanuVNkXmVzz//vEos5QUKDAxUqZ+8iDI/U3a+hQsXWhVKyZvs6CcllueQ8XnUKROEqzFJuBGbjBL+mXcuokLdL2G7z5h6XPXYjv85p4I/bhLZA+6bZI+4X1I2O0XmzRYy/I7H/5/n5eVLe9/ufP3csmwFzfrHk/FKACPVQtmRPEAWcbPIWMCR9XgmXyUYkj7V2bUD8vf3z/YYmPF7nU6X6ecZp719+umnWLRokVp8TnIZKbSRPEauK7fLOKbsnmd245Wte/fuKt+RYp5169apqXtyuYRPEjAtWbLkjvsrUaLEHY+T836Q+xkFuWp0/sEHH6jyLQlw5I7lqyRpUjklL1huy7LymySRMpczu83SWV52DouwsDBVUibzOGW6oeyElsTQ8nNpUEaAr6cWVUv4Yd+FKL4cRERERERE5BKk4kdmh1k2KWa5G8kRZPqeTPGz3EaqiqQPVNZgpnLlyqraKeNUvWPHjuV43wsWLFAzvWQ6oMzysjRFlxymTJkyqthGputZSDFR37597/kcpSWTbHL/586dS29jJM9FgioZt+W5SLHPRx99pKZs2nT1PenDJKVjn332mQqopMmVzFOUUEf6S0k5m5R/2Yvq1aur5DDjG3TmzBn4+PionUrmXEoz9Iw7g/zcsrwjAfXKBmLfxUi+FERERERERGQF6S+UVAhb5j5GuSXBizQkz7pZ+i1bQ1aokxxBei5JgYzMwJIgSfo5ZZ3CJhVKEixJniJ9oWbNmoU9e/bkeN+SXWzatEn1xJb7lUbmQgIiaSUh1VNyXzLt7tChQ6qfdtOmTdV1JK+RwEmmWWZHxvLll1+idevW6S2JJKiShu4Sgsl9HjlyRLVDktdFqr5sGkplJE+ud+/eqhP81q1b1QseHx+v5mXaC3lRpWmXNC/bv38/9u3bp5qaDxw4UM3f7NGjhypNe+utt3D+/Hn8/PPPqqO+3IYyrsDHSikiIiIiIiLKbYcgCTikqia2ELaU/x7Puob57733ngqTsm5z5syx+m2W4EnCHckXJE8YN24c2rRpo1oJZSVTASWIkgBJMpVt27apr3cbp1RSSYAk4VCXLl1UDypLdZWslCc9qoYNG6aaoMtsMmmiLiT7kIxjxIgR2d63VF5J2CT3nZFURZUuXRqPP/64ul+pnpL2SAXFzXwfa1rLynMy39Ayf/DGjRt2tQqfpIfSEExW15On2atXL4wfP15VfYnTp0+rqYjSm0o67b/wwguqGiw3ZMpigwYNVKrp6I3O5X3M2uhcnLwei94z/sahNztBq8lTfkl0X6vvrT66GiWDSkKvs1Wj8yho3bejZvFm0OvuXrZLrsMybZ2NzsnecN8ke8T9krJliAJubAd0zQBNoM1W34uLugbfsK5sdJ4HMqVLGm9LYJG1wXVaUFSYKxpKIJV2ju8MzP+txCdhl733O7vbfpDbzESblxdIVquTBFFK3mQJQpnSJ9VT2SWBtiThkzQ1ly07lSpVwk8//VTo43IUlYr5QuvuhhPXY1EjhKvwERERERER0b14OFVIRAXL6vKXmTNnYsWKFar5uaXiSBppyTKFUuZFzsPd3Q11OIWPiIiIiIiIiOwhlFq2bBkmT56Mtm3bppeSyUp8H374IVavXl0QYyQbYl8pIiIiIiIiIrKLUEo6t2fXN0o6seelUz3Z/wp8+7kCHxERERERERHZOpSS5QW/++67OxpYSTd26fROzlcpdfZWPKITUm09FCIiIiIiIiJy5VBKVqs7evSomrKXnJyMMWPGqOUOL1++bHeNzun+Bft6okyQN/ZfiuLLSURERERERET5xurV90qWLInFixdj+/btOHv2LAwGg1r+r2XLlnB3tzrjIgeZwrfvQiTaVClm66EQERERERERkauGUhbNmjVTGzm/emUC8efJm7YeBhERERERERG5WigVHh6evtLevRw7dux+x0R2pl7ZIExbfwpmsznX+wERERERERER0X2HUnPnzk3//tChQ5g9e7bqJVWrVi3odDrVY2rGjBkYOnRobu6OHEy1Uv5ITDXi31vxqFDM19bDISIiIiIiIntlTAHMhsJ7PDctoPHI9dXbtWunemKn39zNDf7+/mjQoAEmTZqEUqVKwd688sor6usHH3wAlwylGjdunP69vEkffvihanSesZIqNDQUEyZMwOOPP14wIyWb8dC6o3ZoAHafj2QoRURERERERDkHUrd3AYa4wnuFtL5AcGOrgqlXX30V3bp1U9+bTCacPn0ab7zxBsaPH5+pKIfssKfUjRs3EBwcfMfler0eMTEx+TUusjNNKhTBzrMReLBhGVsPhYiIiIiIiOyRVEhJIOXuAWg8C/7xjMlpj6cqs3IfSvn5+aFYsf8t5FWiRAk888wzeOmllxAbG6t+ToXD6uXyHnjgAZUq7t27FwkJCYiPj8eOHTvUZV27di2YUZLNNQ4Lxq5zt209DCIiIiIiIrJ3EkhpvAphy7/gy8MjLdRyd0+LSaR6avjw4ahXr55qXfTwww/jzJkz6mc7d+5U0wAXL16sZpE1atQI3377Lf755x906dJF3ebll19WVVhiyJAhquXR4MGDUadOnUz3lZ09e/agb9++qF27Np599lkkJiZm+vmmTZvSfy4VX2vXrlWXz5kzB/369Uu/3ooVK1C1alVcvHhR/Vvym5o1a+L8+fNqTF9++aV6jnI/nTt3xpYtW2D3odTkyZMRFhamnoDMuWzYsCFGjBiBunXrYuLEiQUzSrK5BuWCcCUqCVeiMn8YiIiIiIiIiBzZhQsX8M0336BVq1bw8fFRYdLo0aNVm6Jff/0VCxYsgNFoxJQpUzLNIlu/fj1+/PFHdd1PPvkE7733nur7JN+vWrUKGzZsSL/+119/rYKfpUuXqsqsUaNGISUl5Y6xREREqB7ezZs3x/Lly1GpUiX88ccf6T/fvn07xo0bh969e6uxDRw4EP/3f/+Hw4cPo2XLljh+/Liq9hISkknPLCkqsvxbemaVK1dO/furr75C9+7d8dtvv6m2TK+//np6kGa30/d8fX0xdepUvPXWW/j333/VZRJSyeXkvHw9tagZ4o9d/0agT71QWw+HiIiIiIiIKE+kf9Tbb7+tvjcYDGoBt/bt26sZYCIpKQkPPfSQqmjy9vZWl0ll0qxZs9LvIzU1VfWgkjwkJCQEH330ER555BFVsCOqVauGs2fPpl+/devW6T245bElAPv777/Rtm3bTGNbvXo1goKC8OKLL6qqLQmgNm/enP7zn3/+WYVblvuSxz948CC+//57FYbJtMTdu3er+5UQSh5XQikJsbZt26Ye16JNmzbplVVPPfWUus7NmzdVaGa3oZQlEZQXQsrNJC2sUKGCSufKly+f/yMku9E4rAh2MpQiIiIiIiIiByb9ozp16qSms02fPl2txvfCCy+oMEhIECVT7aRSSSqQJFw6evQoihYtmul+ypRJ67ns5eWlvkpllYVclrESqn79+unfS1GPhElnzpy5I5SSy2TKnVQ4Wcj0QcsUPvm5BGYZyXTBJUuWqO9lOuGuXbvUbW7duqXCrc8++yy9yur5559Pv13GDMdSaCQhnV1P35PETVI5mUNZunRptUn6JomazHsk5+4rtfNf9pUiIiIiIiIixyWLt8kUturVq6cHNjJlTqqfhIRVAwYMUNPapAhHQizpEZWVVpu5zsfSjyo7Wa8rBT7ud7l+RlLJZeHpeWcfLZlyZ5l2J1P4JK+R7EaqtqTlkgRZsp07dw5NmjTJ9n4tzGYzCpPVlVIyP/LRRx9VKWJGH3/8sZpfKXMtyTk1Ll8E/96Kx83YZBTzK4SVFIiIiIiIiIgKkDQ4f+eddzBo0CDVKHzkyJGq0khmiK1cuTI9TNq6det9BTbS68lCej5JH6uqVavecb3KlSvjzz//VKGV5bGPHTuWXoUlFVYHDhzIdJt9+/apy0WzZs1UgCZT/iSQCgwMVMHazJkzVV9wy3REe2F1pdSpU6fQv3//Oy6XFFFeKHJeAd46VC3hh3/ORdh6KERERERERGSvjMmAMakQtuR8Ga6sPieZxhdffIHr16+rICchIUE1Mr906RIWLVqkWhhl15g8tyTgkumAUrH02muvqT5UTTJULVnIanrS0+rdd99V0walj1XGWWnSS2rNmjX44YcfVOWTBGnr1q1T0w2FTEGUpuXyeBJCCfkqjdcz9pNy2FBK0jlpopWVJHVZ51eS82kifaXOcgofERERERERZeGmBbS+gCkFSI0t+E0eRx5PHvc+yQp2Mp1NZoBJj6ann35aLfDWq1cvtWLepEmTcPv2bRVa5UXPnj3VzDJpLC7TA7/99ts7pvSJgIAAtVKf9LKyNCeXrxZ16tRRTdXnz5+PHj16qF5Sn376qaqQspApfJawTUjFlFR52WMo5Wa2sv5M3gzpFP/YY4+lP0EJpGQZRGmYJVP7XEFcXJxKGyWxdOSVB+Xtj46OVjt+xkZqOVl16Co+XX8Sa/+vTaGMj1xXfEo8Vh9djZJBJaHX6W0yhhRjFLTu21GzeDPodYE2GQPZ53FT/h8gx/7cHDeJCgv3TbJH3C8pW4Yo4MZ2QNcM0NjmdyyzIRFxUdfgG9YVbjofm4zBkUklz7///qumjFmafKczpsgLXHiDkUBK4wF7NmTIEDRu3FitpJeb46bRaIRGo7H73zXvth/kNjOxOk60LBf4008/Yfbs2arJlgxASsu6du2al+dBDqRZhWCMvRGHGzFJKO6f5eBDRERERERErk0FRPYdEpH9yFONmwRTlnCKXEuQjwdqhgbg7zO30LdeaVsPh4iIiIiIiIicOZSSZly51adPn/sZDzmAFpWKYssphlJERERERERE9yLtjug+QqnPP//8rj+XJl0xMTHqe4ZSzq9VpaJ47pf9aq6rvc9xJSIiIiIiIiIHDqU2btyY7eUmkwnz5s3DZ599hrJly6pu9OT86pcLQkxSKk7fiEPlEn62Hg4RERERERHZgJXrppGTMefD+5/ndRMPHTqEN998E2fOnMHIkSPV5uHBZmauwEunQaPyRdQUPoZSRERERERErkWn06mvCQkJ0Otts1I22Z68/xn3h0IJpWRZv6lTp+KXX35B8+bNsWLFClUlRa6lVeWi+Pv0LTzRMszWQyEiIiIiIqJCpNFoEBgYiBs3bqh/e3t7s7VLPlYfGY1G9Rrba7scGaMEUvL+y34gYy2UUOrXX3/FRx99BK1Wi08++QRdunTJ8wOTY2tZqRg+W38KqUYTdBp3Ww+HiIiIiIiIClHJkiXVV0swRfnHZDLB3d3+z7MlkLLsBwUaSskUPZmqt2/fPgwZMgTjxo1TSSi5rvCSftB7aLDnfCSaVgi29XCIiIiIiIioEEkVT6lSpVC8eHGkpqbytc/HKqTY2Fj4+fnZbaWUZcre/VRIWRVK9e7dGwaDASVKlMCRI0cwevToHK87d+7c+x4U2T93dzc8ULU4Nh2/wVCKiIiIiIjIRUkwkR/hBP0vlEpOToaXl5ddh1L5JVeh1JNPPukSLwZZp314cUxddxITulXjS0dERERERERE+R9KyXQ9oqxaVi6KZxbsw4XbCSgbzOmcRERERERERJTPoVS7du1Uk62iRYuiQoUKeO+996x4CHJWfl46NA4rgo3Hr+PxFlyFj4iIiIiIiIjyOZTq27evmr4XHByM8uXLW3H35OzaVi2ODcdvMJQiIiIiIiIiooKdvnflyhXVeEtCqmvXrqlO+46wVCEVjPbVSuCjP04gPtkAH89c7U5ERERERERERLA6TWrfvj0iIiLU9926dcPly5f5MrqwsKI+KB2kx9bTt2w9FCIiIiIiIiJy5lBKqqSy+55cV7vw4lh/9Lqth0FEREREREREDoTz7ui+da5ZEuuOXUeq0cRXk4iIiIiIiIhyhaEU3bcGZYPgoXHHzrNp0zqJiIiIiIiIiPI9lJIG50SZdiJ3N3SuURKrD1/lC0NEREREREREBd9Tisiia62SWHPkGowm7h9EREREREREVACh1Pvvvw8/Pz/1/eTJkxEcHGztXZATaly+CCSv3H2OU/iIiIiIiIiI6N60sFLfvn3V17i4OFSsWBFarVZ97+vrm6vbb9u2DVu2bMGRI0cQERGhpgMWK1YM1atXR+vWrdG4cWNrh0R2QKtxR6caJbD68DU0qcCgkoiIiIiIiIjyuVIqJSUFEydOVOHRgAEDcP36dbzyyisYPnw4oqOjc7zdsmXL0LlzZ7z88su4desWWrRogSFDhuDhhx9Gw4YNcfHiRbz44ovo0qULlixZgvwgUw0///xzNG/eXI339ddfR3JycvrPd+/ejX79+qFu3bro3bu3Cswo77rWLIU/Dl+DiVP4iIiIiIiIiCi/K6U++ugjnD59WoVMDz30kLps3LhxmDBhAt555x1MmTLljttI+FS6dGn1s9q1a9/1/nft2oVffvkFS5cuxc8//4z78e2332LevHmYNm0afHx88MILL2DGjBnq6+3btzF69Gi1SVj2+++/Y8yYMfjjjz9QsmTJ+3pcV9WsYjBSjCbsOheBpqyWIiIiIiIiIqL8DKXWrl2LmTNnomrVqumXyfdvv/02nnjiiWxv89Zbb6FChQq5un+paJLtzJkzuB9GoxGzZ8/G+PHj0axZs/TwbPny5er7vXv3QqPRYMSIEerfEk7J9ffv36+qtch6Oo07etQuheX7LjOUIiIiIiIiIqL8DaXi4+Oh1+vvuNxkMqkgKDubNm1SlUolSpTI9eNIv6r7cerUKURGRqJDhw7pl/Xq1UttIjAwEFFRUSpk69ixIzZs2KCeW5UqVayeIujIKxJaxp9fz6FP3RA8NvsfvNmzOjx1mny5T3JN6fsmbPcZU4+rHtuxP+dk38dNovzCfZPsEfdLymHHyLzZQNr/x//7/zn/n052xOwkv2vmdvxWh1Lt2rVT0+E+/PDD9MukH5RM3WvTpk22t1m4cCGmTp2KBg0aoGfPnmq6XEBAAArSpUuX1GNIRZSMVwKqTp064aWXXoKHh4fqY/XII4/gmWeegbu7uwrUZGXB3FZ0WUgfrZzCOEfZURISEtT30nT+foX5uyHQS4vf9p5Dh/Ci+TBCclXxKfGqB5wspGDU2uYzlmKMg94jSY3BoLX6cElOSo6bSUlJ+XbcJMov3DfJHnG/pGwZ4qBJSoIxOQ7Q2OZ3LLMhEclJyTDERMNNa7DJGIgK4xzdVuQcKjesPgJMmjQJr776qppiJ9VR/fv3R2xsLFq2bKkaiWdnzZo1OHr0qOrXNGvWLDXVT64vAVX79u3h6emJvJCTAmm0nh0Zk/xcwjDpdyVjfeONN9RXGadURUmYNnbsWLRt21ZVTEmwVqdOHauqtCT4yu3Kg/acXsrzyK8dvl+D0lh3Kgr9m9xftRu5Nm2KVh0b5POl195ZnVkYUowG6Ny91Bi8tI77OaeCOW7KfuHIvyiQ8+G+SfaI+yVly2AAErwAnS+gsc3vWGaDBm7GOPj4B8BN52OTMRAV1jm6LUi7pAIJpfz8/DB9+nQV6EjfJ4PBgLCwsHsGOdWrV1fb888/j8OHD6uA6pNPPlEr+Ukw1aNHDxVU5Xbg4sCBAxg6dGi2P5P7llDKslKgkFUC5fFfe+01FY7Jmy2hlKhRowYOHjyIuXPnqh5YuSU7iSPvKBmfQ349jz71SqPztL8QnZiKQG+PfLlPcj3p+yVs9xlTj6se2/E/52Tfx02i/MJ9k+wR90vKZqfIvNlCht/x+P9zsjduTvC7Zm7HnqdaSZkKFxERofpECfleNtGoUaN73r5mzZpqe/HFF3Ho0CGsX79eTQeUiqZt27blehxNmjTBiRMnclzFT2ScjifhmUwHkrEeOXIE4eHhmW5TrVo11YuK7k9YUR9UD/HHbwev4tGm5fhyEhEREREREdH9h1I//vijCpCkQiq7JOzYsWO5vi8Jh44fP662q1ev3hES3Q+pytLpdOq+pQJLSGWXBGnS5Lx48eI4ffp0ptucPXsWpUuXzrcxuLIHG5bB/F0XGEoRERERERERUf6EUl988QXGjBmD4cOH56kXlPSAkv5NskkT8sqVK6Nbt26q31NISAjyi/T6ePDBB1X/KgnRZKrexx9/jIEDB0Kr1aqvDz/8MObMmaOmD8rqe1u3bsWyZcvybQyurFfdELzz+1EcvhyNmqEF29SeiIiIiIiIiFwglJKV6rp06WJVIHXhwoX0IEr6SYWGhqJ79+4qiKpUqRIKivSQmjJlCkaNGqVCqV69euGFF15QP6tbt67qjfX555/js88+U1P7vvnmGxWS0f3z9dSiV50QVS31bt9afEmJiIiIiIiI6P5CKamSkqBHGohLuJQbnTp1QrFixVSYJberXbs2CoOHh4dqai5bdqRCSjYqGIMbl8Ujs3bi1W7V4ONpm6VeiYiIiIiIiMg+WZ0UlC9fHp9++ik6dOiQ7c+z6yk1e/Zs1ZRcqqzIddQuHYAyRbzx28ErGNSorK2HQ0RERERERESOHEpNmjRJNQ7v27cvvLy8cnWbZs2apX+fkJCARYsWqabiKSkpd1z3/ffft3ZIZKek8f3Djctg3q6LDKWIiIiIiIiI6P5CKVkx7/nnn0eZMmWQF3Lbffv2oXnz5rkOtchx9a4Xig9WH8f+i1GoWybQ1sMhIiIiIiIiIkcNpfr374/ly5dj3LhxeXrAnTt34vvvv0e9evXydHtyLP5eOgxsWAbfb/0Xnw/me05EREREREREeQylYmNj8csvv2Dx4sUoXbo0NBpNpp/PnTv3rrevUKECkpKSrH1YcmCPNy+PTtP+wtXoRJQK0Nt6OERERERERETkiKGUTNt78skn8/yAH3zwAcaOHYuePXsiJCTkjubnffr0yfN9k30qX9QHrasUw4/bz+PlLuG2Hg4REREREREROWIoJYHS/Vi4cCHOnz+P+fPnw9PT847G2AylnNPwlmF46uc9GNeuMvQemavriIiIiIiIiMj1WB1KJSYmqul7p0+fhtFoTL9cVtI7evQoVq9efdfby7S/Tz75BN26dcvbiMkhNa1QRE3dW7z3EoY0LWfr4RARERERERGRjWWeO5cLEydOxNdff63CqRUrViA1NVUFVL///ju6d+9+z9sHBQWhUqVKeR0vOSipghvdpgK+3nwGqUaTrYdDRERERERERI4WSv3111+YOnWq2ipWrIjHH38cixYtUl9PnTp1z9u/8cYbmDx5MrZv346LFy/iypUrmTZyXj1qh0Cnccev+/k+ExEREREREbk6q6fvJScno3z58ur7ypUr4/Dhw6hZsyYGDRqERx999J63tzRJHzZsmKqesTCbzerfx44ds3ZI5CA07m546oGK+OLP0+hbL1T9m4iIiIiIiIhck9WhlFRHbdu2DQMGDFCh1J49e/DQQw8hNjZWBVb3smHDhryOlZyAhFGfrT+F1YevqsopIiIiIiIiInJNeVp979lnn4XJZELv3r1VH6nRo0fjxIkTaNWqVba3kal6zZo1U9+Hhobm6nEk+GrevLm1wyM7J9P3pLfUjI2n0a1mKbizWoqIiIiIiIjIJVndU6p9+/Zqhb0mTZqgVKlSmDdvHsLCwjB48GC89957Oa64N2TIEKxatQrx8fE53rc0T//111/VfcltyDkNbFgGsUkGrDzI3lJERERERERErsrqSilRpkyZ9O/Dw8PVdjfSFH3Hjh348ssv8corr6B27dqoUKGCWolPKq6ioqJUpdXx48dRt25dVY3VokWLvAyNHICXToPnOlTG1LUn0bVmKXhorc5GiYiIiIiIiMjVQqnLly/j008/xaFDh2AwGFSD8tz0jGratKnazp49i61bt+Lo0aOqqbk0Nw8ODkavXr0wZcoUlCtXLu/PhhxGv/ql8c1fZ7HgnwsY2iytcT4RERERERERuQ6rQ6mXX34ZkZGReOSRR+Dr62v1A0qFlGzk2mTlvZc6V8Wryw6hf/3S8PHMU9EeERERERERETkoq5OAgwcPYtmyZahUqVLBjIhcRsfqJfDV5jP4dstZPNehiq2HQ0RERERERESFyOpmPuXLl0dERETBjIZcikzdfL1HdXy9+SwuRSbYejhEREREREREZM+VUiNHjsTEiRMxbNgw1f9Jp9Nl+nmjRo3yc3zk5OqVDUL32qXw7u/H8OWjDWw9HCIiIiIiIiKy555S4q233sq28kWalxNZY3yXcLT7+E9sPXULLSsX5YtHRERERERE5AKsDqWOHz+eq+vt2bMHtWrVgoeHR7Y/++GHH3D+/Hl89dVXWLlyJUJDQ9G9e3drh0NOoJifJ57tUBlvrDiM1c+2hofW6lmlRERERERERORgCuzsX6b5Xb9+/Y7L165di1GjRqkQ6t9//4XBYIBWq8Urr7yCefPmFdRwyM491rw8dBp3fPnnGVsPhYiIiIiIiIgcOZQym83ZXj5jxgy8+eabGD9+PDQajbrsiSeewHvvvYfZs2cX1HDIzkkgNWVAHXy5+TROXIu19XCIiIiIiIiIqIAV+jwpmbJXt27dOy6vXbt2tpVV5DpqlQ7A483D8PLiAzAYTbYeDhERERERERE5UyhVqVIlbNmy5Y7Lly1bpn5Gru25DpURm2zAd1v/tfVQiIiIiIiIiMieGp3frwkTJmD06NHYsWMHUlNTVaNzqZ46fPgwvvzyy8IeDtkZL50GUwbUxqOzdqFV5WKoHuJv6yERERERERERkTNUSjVs2BCrV69GxYoV0a5dO0RFRanpfKtWrUKzZs0KezhkhxqUK4LRbSpi3Py9SEgx2Ho4REREREREROQMlVKiWLFiePbZZ23x0OQgxrarhL/P3MLklUfxQf/ath4OERERERERETlKKBUWFgadTnfH5VId5ebmdsflcplcXwKrrl27YvDgwQU1NHIAGnc3fDqoLrp+tgXNKxVFrzohth4SEREREREREdk6lLL0gJKeUFn16dNHfV26dGm2t3300UcxY8YM9VWm7ZnNZnVfP/74I/r374/ixYur3lJxcXEYOXJkXoZHTiIkUI9PHqyDZ+bvQ6VivuwvRUREREREROTKodSsWbPw8ccfIyAgAD4+PndUO1lCqZwsX74cb7/9Nrp3755+Wfv27VG1alXV9Fx+Xq1aNUycOJGhFKF9tRKqv9SoH3dj5diWCPLx4KtCRERERERE5Iqh1Pfff4+XXnoJw4cPz9MDXrhwAeHh4XdcXrlyZZw9e1Z9X758edy+fTtP90/O5+m2lXDkSgyenrcXc59oDK2m0PvzExEREREREVE+s/rsPjk5GZ06dcrzA8qUvenTpyMhISH9Mvl+5syZqF07raH15s2bUa5cuTw/BjkXd3c3TH2wDiLiU/DqskNqyicRERERERERuVgo1bNnT8ybNy/PwYBM3Tt16hRatWqlekj169dPfX/y5ElMnjwZW7duxXvvvYfnnnsuT/dPzsnHU4s5wxpj66lbmLbupK2HQ0RERERERESFPX1PGpAvXrwYv/32G0qXLn3HCntz58696+3LlCmDFStWYPv27SqI0mg0aupes2bNVE+qwMBAVSlVpEgR658NObWSAV744YnGGPDVdhT398KjTVlNR0REREREROQyoZT0exo9evR9PagEUS1btlSbRUpKCo4dO4Y6derc132Tc6tcwg/fPdYQQ7/fBW8PDfrVL23rIRERERERERFRYYRSY8eOzVQ1ZTQa1Up8ubV371689dZbOH36NEwm0x1h1eHDh60dErmYhuWL4NuhDTFy7m71bwZTRERERERERI4nT8uY/fDDD6oPVKNGjdC0aVO0aNECM2bMyNVt33nnHYSGhuKrr76CXq9XTc8nTpyopu199NFHeRkOuaAWlYqqYGri8sNYsueSrYdDRERERERERAVdKSWr5P3000949tlnUa9ePVXtJNVPEkp5eHhg1KhRd729NDmfMmUKKlasiBo1aqieVI888giCg4Px7bffolu3btYOiVw8mBo1dzeiE1PxRMswWw+JiIiIiIjIoZ2+EYeT12Mha5uFBulRvZQ/PLR5qmchyv9QauHChXj33XfRrl279MuqVauGEiVKqMvvFUpJdZRM0xMVKlTAiRMn0KZNG9SuXRv//vuvtcMhFyfB1M8jm+KJOf/gWkwSXukSDnd3N1sPi4iIiIiIyKEcuxqDV5cdUl+rlPBTC5Gdvx2PxBQjOlQrgb71QtE2vDg0PN8iW6++J83OswoLC0NERMQ9by/T/aZOnaqm7Eml1Zw5c/Dggw9i48aN8Pf3t3Y4RKhbJhBLn2qump9fi07CRwNqw0uXFnwSERERERHR3e0+F4HHZ/+Dx5qXw9wnGsPPS6cuN5vNOHk9DisPXFGtU2SxqZGtK6Bf/VB4annORffP6ho8CZK+//77TE3Kpdm5XCbVTvfy2muvITo6GmvXrkX37t3h6+urgqr3338fTz/9tPXPgEhWhSzqgyVPNcflqEQM+GobLkUm8HUhIiIiIiK6h5uxyRj90x683KUqXuocnh5ICamWqlrSDy92roq/Xm6LMW0r4fut/6L91M1Yvu8yTCYzX18q3EqpCRMmqB5Q27ZtUz2hxJEjR5CSkoJZs2bd8/YyzW/u3Lnp//7xxx/VSnxSJSX9pfLLzp07MXTo0Gx/tmnTJoSEhODixYt4/fXXsX//fvXvV199FS1btsy3MVDhKubnifkjm2Lyb0fQc/pWzHi4vpreR0RERERERNn76I/jaFS+CIY0LXfXl0j6Sg1oUFpN45NASm73zV9nMb5rONpUKcaXlwonlJIG5atXr8bKlStx9uxZeHp6qtX3evbsCR8fn3veXvpP/f333yhSpEh68lq5cmVcvnwZXbp0wb59+5AfpKJr69atmS577rnn1Cp/EkBJGaJUZlWpUgVLlizB+vXrMXbsWKxatUr9nByTHCjf6VMLtUMDMeKH3RjeMgzPdqgMnYaN+YiIiIiIiDK6GJGAXw9cwZrnWqtz89yQnlL9G5RG99ql8OP283hm/j7ULh2ACV2roXoIW/JQAYdSIigoKMcqpOwsX74cS5cuVd9bwqCsVVE3btxAsWL5l67KSoAZ7++3337DyZMnsWbNGvXvHTt2qEqpBQsWwNvbW4Vt27dvVwHVuHHj8m0cZBsPNiqD2mUC8NyC/fjr1E18OqguKhTz5dtBRERERET0ny/+PI3utUohrOi9C0yykj6+0l9qYMPSmLHxNPp+8Td61QnBC52qomSAF19jyr9Qqn379li8eLEKo2TVvbslqBs2bLjjso4dO+LSpUvq+127dqFu3bp3VFVJMCTXKwipqan49NNPMXr06PQKrQMHDqB69erqcS0aNGigpvJZQ0I22RyVZfyO/BxyUrWEH5aPaY4pa0+ix/St+L8OlfF48/LQsmrKsfZN2G7/VI+rHts5PyOUN8583CTHxn2T7BH3S8phx8i82UDa/8f/+/+5i/4//VJkIpbsvYxV41re1+81AXodXuteDUOalcOUNSfQ9uM/MaJVGEa1rgBfzzzVwbg0s5P8rpnb8edqD5FpbZYQKS9VRHJbuQ8RGhqqGpxLJVNhkemGsbGxqheWxc2bN1G8ePFM1wsODsa1a9esum9p2i6N3h15R0lISGsKnttyTUczrmUImpX1wbtrzmDx7ouY2KUiaoX42XpYdA/xKfFITk5WK34atbb5jKUY46D3SFJjMGj5P1T633EzKSnJqY+b5Ji4b5I94n5J2TLEQZOUBGNyHKCxze9YZkMikpOSYYiJhpvWAFf0+bozaFelCIp6GtV57f0K0ADvdKuAB+sUwyeb/sW8nefxVMuy6FOnBLTu/J3J1c7R4+LicnW9XB0B+vbtm/699H4aPnw49Hr9HQ84Y8aMHKfvWciLKn2bctKnTx/klpwUXL9+PdufydQ9SxXUwoULMWDAAHh5/a+EMDEx8Y5gTP4tDdutERAQoFYQdPT0Up6HI+/w99K+VgBaVgvF15vPYtT8I+hdN0RVThX3Z1mpvdKmaFXPOvl86bWZjzeFJcVogM7dS43BS+u4n3MqmOOm7BfOfNwkx8N9k+wR90vKlsEAJHgBOl9AY5vfscwGDdyMcfDxD4Cbzvqpa47uSlQiVhy6gRVjWyAgIH//YN8qIO3ca82R6/jwj+NYsO86JnQNR9uqxfi7kwudo2s0mvwLpaSh+e3bt9X3M2fORHh4uHqBMpJ+TdKf6ZVXXrnj9p9//nmuBiMvuDWhlEzBy6m3lYyzQ4cOaty7d+9Wq+xlJCe7UVFRmS6TQCpjcJXbMTvyjpLxOTj687gXL50Wz3aogt51Q/HRmuNoO3UzRrSqwLJSe98vYbt9Uz2uemzn/3yQdVzluEmOh/sm2SPul5TNTpF5s4UMv+O54v/PZdW8DtVKoGrJgmlMLq9p11ql0L5aCVUx9eKiA6hWyh+vdquGmqGZswRyzuNmbseeq1BKmpA//vjj6f+2TMXLSCqnHnvssWxvv3HjRhSEJk2a4MSJE3e9zpYtW1C6dGlUrVo10+UlSpTA6dOnM11269atO6b0kfMpX9QHXzzSAHvOR+KD1cfw847zKpx6tGlZ+HllbsBPRERERETkTG7FJeOX3Rex9KkWhbI6+uMtwtC3fmnVVH3AV9vQrWYpjGtfOU/N1cn55CqUatq0KY4fP66+l0bn0vTc0jA8LyTk+vnnn3HmzBnVj6lChQoYOHAgypcvj/x28OBB1K9f/47L69Spg2+++UZNAbRUR+3Zs0c1OyfX0KBcEBY+2Qx/nriJGZtO48s/T6tG6HLQLOJTeD3PiIiIiIiICsvc7efROCwY1UMKpkoqp2boE7pWw5Cm5fDp+lPo/Olf6FKjJJ5uWwlVS7Lfrytzt/YGUvWUUyAlYdO9yFS6zp07Y+fOnaqCSbZ//vkHvXv3VqFQfjt16hQqVap0x+WNGzdGqVKlMGHCBHUdCagkwJLeU+Q6pKSwbXhxLB7dDN8MbYh9F6PQ7P0NeH7hfuy7EOnwKx4QERERERFZJKQYMHf7OTzZuoJNXpTSQd74eGAdbHi+Dfy8tOg1YytGzt2tzr3INVm91IH0l/r444/V1DfLqnNy4i79mCIiInD06NG73v6DDz7Ao48+ihdeeCHT5XKfU6ZMUX2p8pNMyfP398+26dYXX3yB1157Df369UO5cuVUH6qQkJB8fXxynHCqaYVgtZ28Hqum9A35bhfKBXtjcOOy6F6rFIJYPUVERERERA5s0e5LCA3Uo3nFYJuOo0wRb7zbtxaeaV8Z3/51Fo/O2onKJfwwrEV5dK1ZSk37I9dgdSglDcMljJIV+N577z28/PLLakW+efPm4d13373n7aUqSQKorKRC6ccff0R+W716dY4/kyDqp59+yvfHJMdWpYQf3updEy93Ccev+69g8Z6LeGvlEbSpUgy96oaiY7US0HvkbiUBIiIiIiIie2AwmjBr61m81Dncbhpol/D3wsQe1fFsh8pYvOcSpq07iXd+P4ZHmpTFgw3LICTQNqtwkx2HUocOHcIvv/yCatWqYfny5aof1COPPIKwsDDVa6pv3753vX1oaKiaJpe1f5SspFe0aFHrnwFRAfHx1OLhJmXVduF2An7dfxmfrT+JlxcfQMtKRdVKEu3Di6O4v3UrNhIRERERERW21YevQbqTdKtZ0u5efFlwaliLMDzWrDw2n7qJudvOYeam02omy4AGpdGpekkWBjgpq0MprVYLP7+0RmQSSB07dgzNmjVD8+bN8eGHH97z9iNGjMAbb7yhpgHWrl07PZCSKqnnn38+L8+BqMCVDfZWK0SMbVcJJ6/HYf2x61i0+yImLj+MGiH+KqRqVjFYNU/39rD6Y0VERERERFRgpOXON3+dxfCWYdBq7HdqnLu7G9pWLa626zFJWLbvMqZvPI2Jyw6jW61S6FqrJJpXLMrpfU7E6rPnevXq4bvvvsP48eNRs2ZN/P777xg2bBgOHz4MT0/PbG+TmpoKnU6nvpf+TUKmzc2ePVvdRqqsZOpf165d7/f5EBUoKXOV1SFkk5Uibsclq9X7/j5zC+MXH8SN2GTUKROIphWKoF6ZINQuE4DifqykIiIiIiIi29l+9jYuRiZgUKMyDvM2yNS+0W0qqqbsBy9FY/n+y3h16SHEJhtUS5XONUuideVirKBytVBKVqt76qmnUKZMGTz00EOYO3euWskuISEBY8aMyfY2LVq0QJcuXdCjRw91XQmmLOEUkSML9vVE/wal1SZ/fbgUmYjtZ25jx7+38cfhYzh7Kx6l/L1Qu3SgCqiql/JXPatKBXjZzTxuIiIiIiJybt9v/Vf1aXLEWR1y3iR/+JdtUo/qOHApGqsPX8V7q45hXPQ+NC5fBK2rFEWrysUQXtKP51kOxuo9slKlSli7di2SkpKg1+uxZMkS7Nq1C4GBgahbt262t5k4cSL++OMPNXUvKCgI3bp1Q69evVRfKiJnIQdLWUVCtgf/+wtEbFIqDl2OVsn+wUtRWLz7Es7djoePhxaVSviiSnE/VC7hiwrFfFC2iLdaItVLxybqRERERESUP87fjsdfJ2/hnT61nOKcq26ZQLW90iUc/96S53YTf526hWnrTsHPS6v6UDUsH6Raq4SX9IfGncUADh9KXblyJdvLIyMj1dcqVaqkXy8kJOSO60kAJVtcXBzWr1+vAqoHH3xQVVt1794dPXv2RNmyZe/vmRDZIWnYJ3OeZbNISjXi7M14nLoRi5PXY7Hz3wi1NOuFiAQkphpRwt9TBVRlgrxRuog3Svp7qcukfLW4vyeCfTx5YCUiIiIiolyZu/08OtUogZIBztVWRAKqCsXkD/y+eLxFGJINRuw5H4ld/0Zg3dHr+OiPE+p69coGol7ZINULWGaulA7Ss5rK0UKpdu3aZXrTZJpS1qlHlsuk8XlOfH190adPH7VJQLVu3ToVUH399deoWrWqCqeGDh16P8+HyO5JJVR1OSCG+N/xGboVl6LCqYsRCelfD1yMUk3+pF9VRHyKCqSK+UpI5YkiPh4I8vZAkPqqQ6C35d869TXQWwdfT62qzJKmgURERERE5Drikw1YuPsi5gxrBGfnqdVkKggwmsw4fi1GBVX7L0Zh7ZFrOHUjTp0fSTgl52NV1KwVX1Qo6qPOrdhixU5DqQ0bNuT7A0tA1bdvX7Xt2LFDrdz3/vvvM5QilyUHwGJ+nmqTUtPsSPp/IyYZN2KTcD0mGbfjUxAVn4LIhFScuRmPyIRI9X2kuiwFsUmG9Nv6eGjg66WFj6dWHYhVWOWphd9/X/UeGnhq3VVolvVr2uauDvTyVf7toXGHVuMGnXx1d1OreFguk3/zgE5EREREZFtL911G+WAf1C+b/fmFM5M/5tcICVDb0Gb/m7Uis1WOXonBkSsxWL7vCs7eilPnVgF6HSoW81EhVbki3ggJ1CM0SI/QQL2qMpPzHrJRKBUaGpqvDyoVIf/884/qTSXT+aRJeocOHfDSSy/l6+MQORsJhSx9q3LDYDQhPsWo/kIiW+x/X+OSDIiTrxkuT041ISYxFckGkzpYy/a/701IMhjVdSQYS/rva6rRnONjpwVVbtC5/xdUadyh+y+8slyu06aFWpm+V5uEWibEJuswuJkJ+rTFO4mIiIiIyIrz7h+2nVMr2PEPxmnkj+tqEarSgZleKzkv+vdmPM7cjMNZ2W7FY8upW7gclYhrMUkwmc0o4eelQqrifp4o6vvf5ufxv+9907739tDw9S7IRufh4eF3fYFzmr5nMBiwbds2NWVPKq8kiGrTpo1qgt66dWt4eHhYOxQiugcJgAL0sukK7H90UhZrMJmRajTBYDQj1ZT2NeP36mf/XcdyPYNJvv/f7VIy/Ey+xiUn4Y8jbpi8PB7vDtAjwJt/mSAiIiIiyq2/T99WMyh61C7FF+0eZBZJrdIBasvuD/3SSuVKVKIKqWTmyq34ZNVuZe+FSNyKS8btuBT1Vc555A/s/l46+Ot18PfSpn1V38tXrfoqwZWPR9psFfk+7as27XudBj5uOf/xH64eSs2dOzfTv41GIy5cuIDZs2fjueeey/Y2UgG1efNmFUQ1a9YML7/8Mjp27AgfH5+8j5yIbE4C6rQqqLS/OuSn+JR4hBQ5ioX/eGLG+mi82jOQf3EgIiIiIsqlOdv+xcNNynJ173z4Q79M5ZOt4T3+YB+dmIqYRANiklL/+z41w/dpl1+PTlKzWRJTjEhIMSBBfU3bEuXfqUa806MyHm6euZrLWVkdSjVu3PiOyyRoKl++vOoJ1aVLlzt+LqvySWAlPytSpEjeR0tELsXdHRjZ1huvLozDn8eT0Laa3tZDIiIiIiKye+dvx+Ovk7fwTp9ath6KS/3BXhaeku1+mEwmxMTEwFVYHUrlRMKms2fPZvuzn3/+Ob8ehohcjI+nG4a29MMPW2LRrJKnarROREREREQ5m7fzAjrWKKEadJNjcbtLuyRnZHUotXz58jsui4+Px+LFi1G3bt38GhcRUboWlb2wan8CftufgAGNfPnKEBERERHlQPqzLtl7CZ8OqsfXiJwvlPr888/vSPF0Oh1q1aqVY08pIqL7IceZQU19Me2PKHSv4w29B6ulqGBIL4CbcSbciDEhIt6E27LFmRCZYEJ8shnJBjMSU8yIS0yFCalq35Q/ZskKwe5u0nPADb6ebvDzkq/u6mugtztK+LmjuL8GJfzd1c9d7S9gREREVHg2HLuh+kg1rxjMl52cL5TauHFjwYyEiOguapfxQIkALdYdTkSv+lwkge6PBE0nrqfixDUD/r1lxMUIIy5EGHAp0ohkAxDo7YYiPu4I/m8L8kkLk/y83OGpdYO72QQ/b09JTGEymWEyA0YT1IorEl7FJplxPs6gvkYlyIotJlyLMSIpFfD2cENooAbli2pQoahWfS0frEGVEjoE+zJwJSLnIqvqxiWbkepmgtEsx8m0yySc99ACnhr5mva9RtJ9IrpvC3dfxIMNy8Cdnyly1p5SZ86cwZIlS1QPKfkfSnh4OAYMGIDQ0ND8HyER0X/VUv0a+uDbP2PQtbY3dFr+4kq5czPWiL0XUrHvQioOX07F8WsG3IozITTQHeEldahYXIN24Z4oXcQbZYI0KB2kgZfO7a7VVHFxZvj6eltV8SS3i0ky43qMEZcjTTh7SwIxA34/mIqzNw24Em1CSX931AjRoUaIFjVCdahTWoeSAfm7siURUX6QatJztw24Fm3C1WgjrkUbcTVaQngjYhLNiEk0qWOeBFJpEtJvK9WlEuabs6x4LqF9kHdahalsQd7u6rgYEqhBaJBGBfqyyR8KiCh716KTsOXUTbzTpyZfInLeSqlnnnkG9erVQ82aNWE0GrFz507Mnj0b3377LRo1alQwIyUil9eogid++tsN208noXU4V+Kj7IOfCxFGbD2dgp1nU7DvYqqqfqpcXIt6ZXToWssL/9dRiyoltKrqqTBJgBWgl80dVUoAbeGZ6ecxSSYcvWLAkSupalt7NBknrxvUiVijcjo0LO+BRuU9UKm4htP/iKhQw6dDl1Nx7GoqztwwqkBdgvTIBDOK+rqrkKhkgDtKBWhQM1SL4n6e6ljnr3eHv5eb2kypCQj094VO4watTHd2d1PHa6maSjGYkWKAmh4t1aUyXTrqvy0iwaRCr+1nU3A50ogr0UZEJZhRxMcNlYppUamEVh3fZasZqlNBFpGrW7znIlpUKoqQQP6uTE4aSk2ZMgXPPvssRo4cmenyL7/8Eu+++262jdCJiPKDu5sbutbxxqoDCQylKJ2cuGw9nYytp1JUGCWVSA3KeaBpBQ8MaKBH3bI6+BdyAJUXMkYZs2wWcckm7D2fit3nUrDiQBIm/xYDHw93tKzsgTZVPNGqsgeK+bGSiojyh/TM23cxRVWWHryUVl16OcqEcsEaVcFZsZgWLSp5o0IxLcKKanIV7qdVl7qpKqiM1aWqL60GKqjy+S+jLxlw7zHGJplw9qYRp24Y1CbH/u//TlDTsGWctUunVZnWKaNDrVDdXStfiZyNtBT4ZfdFvNatmq2HQlRwodTVq1fRvn37Oy7v0qULvvrqK2vvjojIKg+E6/HztjicupaCyiX/d/JOrkWqn9YdTcLaI8n451wKKhXXqoDm3b7+aFReB28naYYvzdJbV/FUm5CKgv0XU/HXyWTM2RaPFxdFI7ykFm2qeqJTdU91Isb+EUSUWxLw7D6fil3/pqhNgijpoyeVmfXLeuCxZt5qKrFUeNoLCcLqlJFNl+nyyHgTDl5OxYGLqdhxNgVfbY5XFajyPJr9F/jLHymkLyCRs9px9jYSko1oF17C1kMhKrhQqmvXrpg1axbeeustteqexaJFi9CtWzdr746IyCrenu5oW02vqqWeZSjlUi7cNuDX/Un440iSalDepIIHutT0xNQHA1S/EVcgzYAbh3mo7cXOfqphu1SJ/XkiGY99H6kqETrX8ELnmp5oXN5DrQZIRJSxakn66skxQ7Y951PVFGE5Xgxu7I1PB+lUXz1HXCFU+kxJBalslud69pZRBVSy/bgjQYVwcvyUPoKylQvOU3tdIru14J+L6N+gNDxkniyRg7D6SJycnIy1a9fir7/+Uj2lJJg6ceIELl68iDp16mDo0KHp1507d25+j5eISE3he2HeLTzWyohAb9cII1y5l8nvB5OwbF+i6mnSurInRrTyQduqnuwdAqjV+nrX1atNqqjkxGvNkSQ8Mz8aRpMZnap7oU89LzQJ82AFFZGLSko1Y+upZKw7mozNJ5MRnWhGi0oe6FFHj48HBqBMEecMZiRYk+mGsj3SxFuFVGduGtVrsOFYMt5bFYuyRdIWupBNevYxyCdHFpWQgj+OXMOqZ1rZeihEVrH6/0IVKlTA6NGjM11WtWpVa++GiCjPQoO0qBbigU1HE9G3oS9fSScjS4VvOpGMX/5JVCcP0h+kb309Zj0WhCJccemuVVSWqX6Te5tVT5jfDiZh7LxoeGqB3vX06FvPC1VKZJ7yQkTO2RtKjp+rDyepAEYagHeu4alCqEZhHi45hU1CKpnqLdvwlj6qZ5/0o9p4PBnj5ker60j1bbdaaUG+xt31XiNybMv3XUbt0ABUKs7fjcnJQ6mxY8emfx8XF6dW3wsIyEVXQiKifNShhh7ztsehdwMf1QCdHJ8sKb5gV4IKo+Rc4MFG3pjUww9lOb3CanIyJT1hZHutu5868Vq6LxG9ZtxGhaJa9KuvR//6ei6rTuREpFpSpuTJNGcJWkr4u6uAZf7IImpVPEecklfQPfu61PRSm1SW7vw3BasOpVWaiq41vdCjtpfqU8hefWTvpBJQpu490TLM1kMhslqe6nV/+OEH1Vfq1q1b6t9FihTB4MGDMwVWREQFqXEFL8z6MwZHLqWgVpn/lu0hh/wlasupFMzdnqD+qi/T86RZ+QNVPflX6nwiK1u1DfdUm/RT+eNwEhbtScRHa2LVSZf0kWkSpuMJK5GDHkMPXErF0r1JWHkgET6e7uhT1wtLxxRRiyAwiMp9kN+8oqfa3uxpVk3ffz+UhCd/ilSN1SXE71/fy2mnOpLjO3Q5GpciE9G9VilbD4XIalYfWWfOnImffvoJzz77LOrVqweTyYS9e/dixowZ8PDwwKhRo6wfBRGRlXRaNzxQTY91RxIZSjmgZIMZv+5LxKytCapv1MON9Xirtz9CXaRhua3IydXAht5qO33DoCrTnvopEkHe7niosbc68ZI+VURk/5WlS/cmYsneRNyIMaF7LS989WgQq3rygfSVal7JU22Tevpj0/FkLN6TiJmb4lC/rA4DGuhVBZoEgET2QqqketYpBR+Zr0/kYKzeaxcuXIh3330X7dq1S7+sWrVqKFGihLqcoRQRFZYONdMansckmuBvR8tVU84kgPppR4KqjJIgZEQrb9Wk20vHaSWFTfqqTOzhr1bxk+boC3Yl4uO1sehZ2wvDWvigZih7TxHZE5li9tfJFPy8M62ytHlFDzzXwVctaMBjaMGQ3luWKX43Y41qauR3WxPw5opYtYjEo029Ua0Uj5VkWwkpBqzcfwU/jmjCt4JcI5SSPlLly5e/4/KwsDBERETk17iIiHLV8LxyCR3+PJaIXvV9+IrZsRsxRnz9V7w6mWpQzgNTBgagTWWuCGcP5GTWsoKfVE/N2RaPgV9FqB40Ek51qu7JFamIbOhGrBGLdidi3s4EpBqBhxqxstQWivlp1Oqvsh28lKr+wNL3i9uoEaJT4ZRMh2Y4SLaw6tA1hATqUac0+zyTY7K6tECm7H3//fdq2p6FNDuXy2rXrp3f4yMiume11PojCaqvBtnnFJM3fo1B6yk3cTHCiEVPBuPnEUXQtqonG8faafXUO30CsGNCMVV9IUumt5lyE19tjkNUwv/+v09EBUv+n7bjbArG/ByJlh/cVN+/3sMff79SDM938uNUZxuTVWE/GhCAnROKq6mTMzbGodn7N/D+qlhcjDDYenjkYhb+cxGDGpVhDzlynUqpCRMm4JFHHsG2bdtQo0YNddmRI0eQkpKimp8TERWmppW88N3mGBy/mopqIR588e3E5SgjvtgUp/pwtK/miaVPBaN6CKc4OIoAb3eMbO2DJ1p6Y93RZMzZloDP1sdjUCM9hrf0ZrNfogLst7fyQBK+3xqvjqMPNfLGuuf9UI6rkNrtsfKJlj4Y1sJbBYc/7UhE+6m30C7cU1VUNSjHRSSoYJ25GYf9l6Lw9ZAGfKnJdUKpihUrYvXq1Vi5ciXOnj0LT09PtGjRAj179oSPD6fPEFHh93toE67HusMJDKXspGeUNIOVaQ2danhh5bhgVCnBMMqRV6Sy9FM5fDkVX22OVydcXWt54cnWPgwaifLJrTgjft6RiB93JMBf74YnWvigX30veHuwX6IjkFUOm1X0VJuEiXO3JWDYnEhUKKpV4b40RpeVUIkKokqqU/USCPLhH2bJceWpPX9QUBCaN2+umpu7u7ujatWqDKSIyGY61NDjlYW3MbyNiavh2EhCignfb03A15vj0aC8DsvGsDLK2Ujj8xkPB+LCbQO+3ZKAfl/eRuMwD4xu44NmFTw4bYAoD45dTVXHzhUHEtXnif32HJ+sIjuhmx/GtffB4t2JmLo2Dh+sjsVjzb0xuJG3qq4iyg+pRhOW7L2ETwfV4wtKrhVK3bp1C+PGjcP+/fvh7++vektJ83Oplpo2bRr8/PwKZqRERDkoV1SHcsE6bDmRhC61vfk6FaJUoxkL/knE5xviEBKowTdDA9Vfisl5lQ3W4u0+/ni2gw9+2JaAp36KQvlgLZ5s44MuNdgrjCg3dp5NwYxNcfjnXAr61tOzqtQJ+Xq64/EWPhjSzBvrjyXjuy3x+HxDPB5urFdT+0oGaGw9RHJwG47dgJdOg+YVg209FKLCDaVee+016HQ6rFu3DqVLl1aXnT9/Xl3+5ptvYurUqfc3IiKiPFZL/XEogaFUIdpyKhmTV8aqZcrf7u2PzjU8WS3jQor6avBCJz9VKSXB5Nu/xeCTdW4Y29YXPWp7ccU+omyal/95MkX12zt+zYDHm3vj00GBCPZl5YyzT4PuXMNLbfsupODLP+PV4h/96ulVmB9WNE8TV4iwcPdFPNiwDBeOIYdn9VFw165dWLhwYXogJcqVK4eJEyfi4Ycfzu/xERHlSosqXpi9JRZnbqSiYnH2MCpI528b8M7vsaqp63MdfDG0mTd7ZbgwH093DG/po5ZEX7InER+vjcOn6+PwdFsf9Kmn575BLs9kMmPNkWTM/DMOV6NMqsfQd48Hwd+LYZSrqVfWA98M9cCp6wZ8uTkOnafdQsfqXnjqAR81RZoot65FJ2HLqZt4p09NvmjkeqFUmTJlcOLECVSuXDnT5VeuXEFISEh+jo2IKNf0Hu5oWcUL648koGLxAL5yBSAuWZqYx2P23/FqusmmF4uqahkiy6IDDzfxxsCGeizfl4gv/ozHZxviMeYBH/RvoFc/J3K16c2ykt4Xf8YhLsmMUa19MLixN/Qe/Cy4usoltPjkwUA839GIWVviMeCrtB59Yx7wRZMwrthH97Z4z0W0qFQUIYF6vlzkeqFU//798dZbb+HIkSOoV68etFotjh07hrlz56Jfv35Yvnx5+nX79OmT3+MlIspR+xp6TF4Wicda+sFLx79A5+eUk9WHk/HWyhiULaLB4tHB/Isu5UhWmBrY0FsFl78fSsL0jXFqk2l+gxp5w0vHE3JybkmpZizek6hWq9S4A0+18UHf+gxm6U6lgzR4s5c/xrXzxZxt8Rg1NxKVimsxrr0vHqjCBSQo5+rLX3ZfxKtdq/ElItcMpX744QfVzHzNmjVqs/Dx8cl0mSyNylCKiApT5RI6FPPXYNupJLSrzobn+eFSpBGTfo3B/ospmNjdH33rebFvFOWKVuOG3nX16FnbC38cSVbN8KXSTqpFHmnCahFyzlVI5+1MxDd/xSPQ2x0vdfZF91rsr0b3Jn3FpEefHB9/2pGAFxdGIzTIHc+080X7auzXSJntOHsbCclGtK9Wgi8NuWYotXHjxoIZCRHRfZIwXBqerz+SyFDqPhmMZsz+OwHT1sepptUbni+GIB9Wn5H13N3d0K2Wl1qZT1agkqopqSAZ2Ur6UOlVTyoiRxadaFIrUcrU5jJFNGp1yo7VuBIlWc/Pyx1PPeCLx5p7q4DzlaUxKO7njmfa+6JTde5TlGbBPxfRr34oPLT8/yc5h1ztyZ999hni4uJyfacxMTGYNm3a/YyLiChPWofrcfZGKi7eNvAVzKODl1LRa8ZtzP8nAd8/HoSPBgQwkKJ8Cac61fDCirHBmDIwAKsPJ6Hlhzcxc1McYpNMfIXJ4dyKM+LDP2LR4oOb+Pt0Mj4fHIhfnw5Wq6zJ/k6UV94e7hjRygdbxxdTffreWBGDrp/dxm8HE9WKt+S6ohJS8MeRaxjUqIyth0JUuJVSpUqVQu/evdGqVSt06NABTZo0gU6XeYWIxMRE7Nu3D7/99hu2bduG0aNH598oiYis+Ctj00pe2HA0AY+38ufrZoVkg1lNsfpuazxGt/FVqwGxOTUVREVj26qeql/K1tMp+Gx9nJruJCv4SXVAgJ5/+SX7diXKqPbZBf8koGkFD8wZFoSG5T1sPSxyQtKDb1iLtAb5i3Yn4r3fY9XqpmPb+qoqZpkmTa5l+b7LqBUagErF/Ww9FKLCDaUefPBBdOrUCT///DNeffVVREREoHTp0ggKCoLJZEJUVBQuXbqEYsWKYcCAAVi2bJn6GRGRLbSvrsfU1VF4pJkfdFzxK1cOX07FCwujodUAy58ORnhJLk1NBR9OtarsiZaVPLD9bFo49e2WeAxr4Y0nWvionjxE9uTcLQO+/DMey/YnokM1Ty76QIUaTg1p5o1BjfRYsjcRH6+Nw2cb4vB0W1/0qctwypUWnpGpe0+0DLP1UIhs01MqMDAQTz/9NMaMGYMTJ07g6NGjKpySXyqDg4NRvXp1VKlSJX9HR0SUBzVLe6g+NbvOJqFFFS6VezcpBrOaPvX1X/F4qo0vxrT1UaunERUW+T2ieUVPte04m6J6Tn2/9SYeb+6tqqfYy4xs7cS1VNWk/48jSao6ZdUzRdUKaUSFzUPrpqqmBjTQY9m+RHW8lArnp9v6qBVP5efkvA5djsbFiAR0r1XK1kMhylfavPzyGB4erjZ7tnPnTgwdOjTbn23atAkhISHYv38/PvjgAxWyFS9eHCNGjMDAgQMLfaxElL/kONX+v4bnDKXufqL1f79EQ9pTLB4djJqhrI4i25KpUE0rFMHucyn4fGOc6jkl1QEjWnmjqK+Gbw8VKll1VMKov04mqxBgw/NFUaYIwyiyPfnj0YMNvdGvnh4rDyalh1PSJF16UHHqvXOSKqledUPg48njEDmXXO3REyZMyPUdvv/++7AH9erVw9atWzNd9txzz6mKLwmkbt68iZEjR2Lw4MEqmDpy5Ih6njIF8YEHHrDZuIkof7StpscvO+JwPdqAEgH8n3fW8u+52xPwweo4PNHSG8+29+VfV8muSH+euU8Uwb4LUjkVj1Yf3lIr9Y1s7YPifgynqGCPj1KxJ2HU3gupeKSJHu+8XAwl/Lnfkf2RnlJSIdWrjhd+O5ik9lsJqEa19sHDjb2h92DllLNISDFg5f4r+HFEE1sPhSjfWX2mJg3N//jjD9SqVUtt0vBcpvLt3bsXffr0gb3w8PBQAZOFNGA/efIk1qxZo/69fv16FC1aFM8//7z6d/ny5VV11cqVKxlKETmBIB8N6pf3xMajiRjcjM0gLW7HmfDy4mgcvZqqmvM2qcDmvGS/6pX1wPePe+DQpVRVOdX6o5tq6sroNj4MCSjfw6hNJ5LVSf2p6wY1fXT64EBOHyWHoHF3Q++6evSs7YW1R5MxY1McvtgUj+GtvDGkqbdaBIYc26pD1xASqEed0gG2HgqRbUKpjNVPUm00duxYtWU0a9YsbN++HfYoNTUVn376qVoRsEiRIuoyWUmwWrVqd1w3Li7O6l9iZHNUlvE78nMg55S+byLv+6c0PP96UwwGNvZRv7DlZQxQj+0cn5Gtp5PxwsIY1C+rw6pnglUjaWd4XoWNx83CVzNUi2+GBOLolVRM3xSvwqkHG+pVOBUSyAoW7pt5ZzSZsepQMr74Mx4340wY0dIbsx8PTD+J5zHy/vGYWXjc3IDONTzRqboHNp9MwYxN8fjqz7QFJCRotasFJCy/Y6X/rmWLIWT4Hc/Ofx/65Z8LGNSotPqexyXnZ3aSc/Tcjt/qSqk///xTBVNZtW/fHtOnT4c9Wr16NWJjY/HII4+kXyarB8pmcfv2bfz+++8YN26cVfcdHR0No9EIR95REhIS0vvwENmL+JR4JCcnq6DYqM3bZ6xycNrBfPuJaNQtY/0UvhRjHPQeSWoMBq3jTgFMNZoxfXMqFuxOxcsdPdC/rgZupgRYmcHTf2SfSkpKUt/zuFm4yvoDU3prcbKZO779OwXtpiaiVy0thjfXITTQjk62bIT7pnWLPKw4ZMD321NhNAHDmurQp44HvHRmwMDjI/dLx9cwFJj9iA67L2jw9dZEtbrpQw10GNpEh2AfO/id3xAHTVISjMlxgMY2v2OZDYlITkqGISYabloD7NW52wk4cDEKU3pXVuee5PzMTnKOntuCH6uPAGFhYViyZAleeOGFTC/azz//jKpVq6IwyUnB9evXs/2ZTN3z9vZW3y9cuBADBgyAl5dXjvcjYZRM5xs0aJBVYwgICICvry8cPb2U5+HIOzw5H22KFp6enurzpdfmfQW99jXcsPWMAS2rWf85TTEaoHP3UmPw0jrm5/xatBFj50cjPtmMFWODuWJUPh43Zb/gcdM26vsCX1aAmmYl0616fZ2olkWXFajKunAjau6b9xafbMKCf+QEPRF+Xm54roMfetbx4qqj3C+dVtsaadve82m90rrMTMDgRt4Y1dobJQNsWGlqMAAJXoDOF9DY5ncss0EDN2McfPwD4Kbzgb367e8r6FKzJMqVLGrroVAhMTvJObpGk7tjjNW/ub322mtqGtzatWvTQyhpEi7BjkzhK0wHDhzIcYW9mTNnokOHDqoCavfu3Xj99dezvV58fDzGjBmDc+fOYd68edDrrTv5lZ3EkXeUjM/B0Z8HOZf0/RL3t2/KKnzj5t5CZLwJRaxcvUs9rnpsx/x8/H06Gc/Mj0a7cE+83ccfXjrHew72isdN+1ClpA6fDQ7EMzclnIpDx2m3VU+Vse18EVbUNcMp7pvZi0ow4YdtCZi9LR7limgxubc/OlbzhHsepnYT90tH1KC8J74f5onDl1PV8fKBj2+hfwM9nmrjY5tVJS2/Y6X/rmUDGX7Hs9ff85INRizZcwkzH6lvt2OkguHmBOfouR271Ueghg0bqkBKpsSdOXNGXTZixAh0794d/v7+KExNmjTBiRMn7nqdLVu2qGl62VVxSTmZjP3ChQv44YcfVLNzInIuxf21qFHaA38eS0S/Ro5Z7WQtk8mMLzfHY8bGeLzZyw+DGqVVjRI5q4rFtPjkwUA8086gegN1/vQWOlbzUitQ1Smjs/XwyIYu3Dbg+78TsHB3IuqW0WHG4EC0qOTh0L/kE92PmqE6fPloEE5eT1XN0Nt/cgtda3phZCsf9TOyL2uPXEeAXodmFYJtPRSiApOnWFyahWfsz2TPDh48iPr1699xuclkUs3aL126hB9//BEVK1a0yfiIqOB1qOGNn/6ORZ+GPnB38hOR6AQTnl8YjZM3DFg0ugh/wSSXUr6oFh8NCMAz7X3x/dZ4DP42QjVJf7K1D9pWZVWMK9l7IQWztsRj/dFkdK7phQWjiqB2aZ5wE1lUKaHDpw8F4v9uG/Dd1gQM/CoC9cvpVJjfujKDW3sxf9cFDG5clkE6ObVchVITJkzI9R1mXKnPHpw6dUqttJfV4sWLsXPnTnz55ZeqwuvmzZvqcp1Oh8DAQBuMlIgKSqMKnvh2UzSOXEpBrTKeTvtCn7iWihFzo1C1hBa/jQ1GgD2tskNUiEoHaTCppz+ebe+Ln3cl4JWlMQjQu6lKAFk2nVNZnXclvXVHk1VD5xPXDHiokR4bXyym9gciyl654LTprP/XwRc/7kjA879Eo5ifuzpeSr81D61z/zHPnp27FY/d5yLx+eB6th4KUYFy+oYLt27dynZa4Zo1a1S11JNPPpnp8saNG6vKKSJyHjqNGx6opse6I4lOG0qtPZKkKqSGt/RWJ+Lsk0IEFcyOecAXw1v64Nf9ifj2rwRMWROnlkZ/pIk3gnwY3DqD2CQTluxJxOxtCUg1mDGshQ9mD9PD34vvL1FuyfFQqkylUmrJ3kTM2BSHKWti1edpcBN+nmxhwT8X0bF6CRT1dc7fXYmsCqXsrfrJGtL7KjvfffddoY+FiGynfQ1vvDj/FmISTfDXuzvV6hyyms6Xf8ZjysAAdKuV/SqjRK7MU+uGBxt6Y0B9PTafTME3f8Vj+sY49Kqjx2PNvTnN1UFJT5y52xOwbG8SKpXQ4vmOvuoYKH+IIKK8kUpSCe0HN9Jj3bFkdbz8fEMc+tXXY2gzb1Qu4fQ1DXYhKdWIRbsv4rOHWCVFzi9XR5UrV67k+g5DQkLuZzxERAWidBGtWqlr49EE9GngHA3PE1PMeGlxNPZdSMHC0UVQI4T9UojuRioI24Z7qk2mu0qgIX1UqpXSqnBKmv1yqop9SzWmTdGT906OfT1qe2HeyCJsaE9UAMfLzjW81HbgYip+2B6P7tNvoWE5DxVOdajmCS0D4AKz8sAVFPHxQItKbHBOzi9XoVS7du3u2VxN/lov1zl27Fh+jY2IKF91re2DuX/Homc9H2gcfBnwq9FGjJobqf6i+evYYBT1Zc8UImtULanDu30D8HIXPzX169P1cXj7t1g83FiPhxp7IySQnyl7cjnKiMW7EzF/V4I6EX60qR5fPBKIIpyCSVTgZBXTT8oE4rVuJiz4JwGTV8Zg8krgkabeeKiRN4J9nacC3R7IefX3f5/DsBZhbHBOLiFXodSGDRsKfiRERIXQ8Pz7v2Kw73wyGoY57jS3I1dS8cScSLWamDQnZWUHUd4F6N3xREsf1Wdqy+kUzN2WgDZTbqJZRQ8MauiNDtU91fQ/KnzJBqmKSsLC3YnYfiYFrSp74p0+/qrSzdH/sEDkiCR8erqtr1rRdP2xtIrFzzbEoWN1LwxqqEfLSh7saZkPdv4bgavRiehbLzQ/7o7IOUKp0FB+IIjI8clf1zvV8sbqAwkOG0ptPpmMsT9HYUxbH4xu48O/oBHl41SVNlU81XYt2qga/X60JhYTl0ejTz09BjXSI7wkp8gWhmNXU/HLP4lYvj8RgXp3DGyox5QBASjhz+o1Inv5fapLTS+1nblpUMGxLLbiqQUGNNBjYENvrnp5H2ZtOYuHGpWF3oPHPHINuQqlwsPDc33iw+l7RGTPOtTQY/GuOFyJMiAk0LGadS7YlYC3Vsbig/7+all7IioYJQM0qhpgzAM+2PlvKhbuTkCfmbdRubhWffa61/ZCqQCeLOSnixEGrDiQhJUHknD+thHdanni60eD0DhMx/CdyI5VLKbFhK5+eLGTLzYdT1YB1Rcf30TTCh7oX1+PjtU94ePJ6X25dfhyNP4+fRvv9atVoO8bkT3J1RnZ3LlzC34kRESFIMhHgyaVvLDmYAKGtfZ3mN4CU9fG4ccdCZgzLAhNKnjYekhELkH+ICcnVrK92cuE1YfSQpMPVseifjkdetbRo1tNL/ZTyaMbMUb8djAJKw8m4fDlVLSs5Ikn2/iok1hfnsQSORRZ9bJTDS+1XY9JqzaVlYFfWRqN9tW80KuOFx6oyunQ9/LZhlN4uElZFPdzzIp+ogILpRo3bnzHZXFxcbhw4QIqVaqElJQU+Po6x2pWROT8utX2xrsrIjG4mS+8dO5231Nl/OJo7D6fiiVPBaNScceq7iJyFv5e7hjUyFttN2KNKqBavi8Rb62IUf2nOlX3QvtqnmyQfg9nbxpULxrpFbXvQioalvfAwAZ6fP9YEILYtJzIKchU2zEPSLWpr1rpVKog3/k9Fi8uikaXGl7oVtsLzcuZ4WnrgdqZnWdvY9vpW3j3pQdsPRSiQmX12Y0EUJMnT8bSpUvVv9esWYMPP/wQiYmJ+OSTTxAQEFAQ4yQiyjdVS+lQ3F+DLSeS0LGmt92+svHJJjz5YxSiE01YOqYIivtxuhCRPZDP4mPNfdR2KdKIPw4n4beDiXhzZQzCS2rVUunS+LdGiNblp54ZjGYcuJSKdUfTgqiLEUY0r+Sh+nTNeDiQfaKIXGCl05dK6tT0vv0X0wKqicuiEZVgQpuy5dGxshFtK5lU/zhXlmIwYdKvR/BM+8qskiKXY3Uo9dFHH+H06dNYtmwZHnroIXXZuHHjMGHCBLzzzjuYMmVKQYyTiChfp+R0re2NVQcTVI+p3PbMK0zyy9qwOZHQ69ywYFQR9mMgslOlgzQY0cpHbZHxJvx5Mhnrjybju60R0Hu4oXlFD7SoJJsnQgOdP1iW6cZnbhrx9+lkbD2dgh1nUqDRQK0W+kInP7Su4sGpeUQuSH7XqlfWQ22Tevjh6KVIrNudhO/2GPDSmhtoGOqBNhU80LKcJ6oX17rUCpty3Hzn96PqOQ9rEWbr4RDZfyi1du1azJw5E1WrVk2/TL5/++238cQTT+T3+IiICkSrqnrM/TsWx66konqoffVokqlBQ7+LRJkiGkwfHAgvnev8YkbkyGT6Wd96erXJ1FuZnibhzIJdiZiwNAZlgjSqSqiBOjHTIayoxi5DcWsroY5fM2DP+RTsvZCKXf+m4Ha8CY3Lp4Vxz7b3RfVSWi4TT0Tp5LhXo5Q7ajS5hudahuFKvB82nEnGlnPJ+GJHPCSPal7WAy3KeaJZWQ9UKOL4x8rsXIlKxN+nb2HVoas4fCUGS0Y3h4fWtSvGyDVZHUrFx8dDr79z1SeTyQSj0Zhf4yIiKlCeOje0r6HHb/vj7SqUkhWoHv0uEg3K6vDRgAC17DIROR5P7f+apL/QCYhNMqnAZsfZFMzblYAJy1Lh7eGGumV0qFfGA9VDtGrqn1RTudtphUCq0Yx/bxlw7KoBR68acPBiqpqOI+dQdcvq0KBcWn8o6RPFMJ2IcivEX4Mh9bzVZjCZcehaKv4+n4Lfjidh8sYY+Hi4oV4pD9QL0aF+qA51SuocruIyKdWII1disO9CJPbKdj4KN+OSUTM0AO3Di6vV9koFcGVlck1Wh1Lt2rXDtGnTVB8pi4sXL6qpe23atMnv8RERFZhudXww9oebuBZlQMlA2zcQP33DgEdnRaBzDS+80dPPbk9Mich6fl7uagUq2USKwazCnb0XUlRF1e+HklQTcAmzqpRMC6gqFNWqiknZyhbRqPsojGkkkQlmnL9twPnbxv82A05cN+DUDQM0bm6oWlKLaqW06FnHC2/28lMLMLjSVBsiKjhadzfUC5EAygNjm6Ut+HL0Rir2XknF3supWHAwAVdiTCgfpEHVYlqEF9MhvJgWVeV4GahRt7clo8mMq9GJOHU9DseuxeDY1VgcvxqDs7fiEaDXoX7ZQNQrG4QhTcujdukA+Hja/vdPIluz+lMwadIkvPrqq2pFPqmO6t+/P2JjY9GyZUu8/vrrBTNKIqICUMxPg6aVvPD7gQQMb+Nv09f44KVUPPZ9BIY09cb/dfR1yjJ1IvofD60b6pTRqW1Yi7TL5ORLgqkT1wxqSpwEVsv3G3EhwojYJDMCvd1Q0l+Dor7uCJbNJ+2rv95d9Z/z0gFuRgOK+KeokMhsBsz/BU3yNTkViEs2ISHFjLhkM+KTzYiIN+FmrGxG3Iwz4UaMCfEpZvUY5YI1KCeBWLAWHap7qaBMLmMARUSFRYJ6S0g1vGHaZTfijDh204DjNww4cSsVa04l4cxtA0xmINRfg7KBGpQJSPta0lejjpVFvd1R1McdRfTueT6GmUxmRCWm4lZcMm7FJqtKp5uxybgYkYDzEQm4EJGASxGJMJhMCCvqg/BS/qhW0g+964Sgakk/lA6yzz6mRA4XSvn5+WH69OmqOurMmTMwGAwICwtDxYoVC2aEREQFqGc9H7yxNAKDmvjCtxCqELIj03lG/hCJZzv4qmbJROS6J1/VSunUllV0gkmFU9djjKpn0604E27HmXDyukEFVokpZiSmmhGXZECyQU7OzOrkR85/5BRIvnpp3eDt6QZfTzc1HUa+l5M1CcaK+3mimJ+7CqNCgzQONzWGiFxHcV+N2tqEeaZfJtP+rsYYcSHaiAtRaduhawZsiE/GLTlmJpgQm2xWx0NfDzcV5HvrAE93T/j67oXGPe20OC3ClzAfSDIYkZBsRHyKIf2rBF/eHvLHATlmeqKorwfKBHmrKXhlinijXLAPQgP17A1FVFCh1Pnz5xESEgKdTocyZcqobfv27dbcBRGRXalUQocKxbRYdzgBfRv6FvrjbzyehLHzovFmTz882Mi70B+fiBxDgLc7asmGOwMrC6mIiouLg68vqy2JyLXItL0ygTKFT4sW5bK/TpLBjNsJprSK0VQzEpKSEREVAXNQKMya/wVcFnqdBt4eWnh7auAjXz00CPb1UJcRUf7J1SdKfsl59913MW/ePMyZM0dN3bP48ccfsWnTJjz22GMYP348SxKJyCGrpb79MwY96vlAV4iNxX/dn4hXlsRg6oMB6FYrrc8MEREREeU/qRaV6X2AbIDZYEScvwm+YSXgpmOlOpGt5Ko2e+7cuVi1ahVmzpyZKZASX3zxhbp82bJlmD9/fkGNk4iowDSs4Kn6u2w7lVRor/JPOxLw6tIYfDUkkIEUERERERG5pFyFUgsXLlRNzNu2bZvjinwvvvgiQykickjubm6qWmrl3nhVGVrQvvgzDh/+EYsfnghCmyp3losTERERERG5glyFUpcvX0bt2rXvep2mTZuq5udERI6obTU9bsYZcfBiSoE9hgReH6yOxXdbErBgVBE0LO9RYI9FRERERETkFKFUcHCwCqbu5tq1awgMDMyvcRERFSpPnRu61/HB0t3xBXL/RpMZE5fHYMX+RCwaXQQ1QnJuVkxEREREROQKchVKdezYEdOnT0dqamq2PzcYDJgxYwZatmyZ3+MjIio0Xet44/T1VJy4mr/VUikGM55dEI3tZ1Kw6KlgtdofERERERGRq8tVKDVmzBhcv34d/fr1U/2ljh49qqbqHT58GL/88gv69u2r/j1u3LiCHzERUQHx83JHl9reWPJP/lVLJaSYMHJuJM7dNmDR6GCEBqat+EJEREREROTqcvXnen9/fxVGffzxx/jggw+QmJiY3h/Fz88P3bp1U4FU0aJFC3q8REQFqkddb4z54SbO3UxFSJH7u6/oBBOe+CESWndg/sgiKvQiIiIiIiKiNLmeQyL9ot555x1MmjRJVUXFxMSoy8qWLQuNhn/5JyLnEOSjQbvq3qq31NhOeb+fGzFGDP0+EqWDNJjxcCC8dG75OUwiIiIiIiKHZ3VjEw8PD1SsWLFgRkNEZAd61/fBMz/exNUoD5TJQ7XUqesGDJsTiSZhOnzYPwBaDQMpIiIiIiKirDiXhIgoi+L+GrSsoseve4xWvzZbTyWj35e30a++Fz4eyECKiIiIiIgoJwyliIiy0a+RD7adMuJypGeuXh/psffzzgSMnBuFN3v64/mOfnBzY4UUERERERFRTrguORFRNkICtWgdrsGCHaXQueq9V9ibuCwGf51KwexhQWhawYOvKRERERERUX6EUleuXEFuhYSE5Pq6RET2rF8jLZ7/yR/7LpjQPIdWervPpWD8kmgU9XXHqmeC1dQ/IiIiIiIiyqdQql27dvechiJTV+Q6x44dy81dEhHZvSI+bnio6VU8M780fhqRivCSuvSfnb9twMxN8Vh5IAnj2vtgVCsfNjQnIiIiIiLK71Bqw4YN1twnEZHT6F73Jvw9yqP3jNtoXcUTxfzccfKaAQcvpaJHbS/88VwwygVzJjQREREREZG1cnUmFRoaavUdExE5AykSHdNWiz71ArH2SBJikswY2FCPmY8EogSn6hERERERERVsKBUeHp7rVaQ4fY+InFHFYlo89YCvrYdBRERERETkWqHU3LlzC34kRERERERERETkMnIVSjVu3PiOy+Li4nDhwgVUqlQJKSkp8PVlBQEREREREREREeWOO6wkAdTEiRNVUDVgwABcv34dr7zyCoYPH47o6Ghr746IiIiIiIiIiFyQ1aHURx99hNOnT2PZsmXw9PRUl40bNw6RkZF45513CmKMRERERERERETk6qHU2rVr8dprr6Fq1arpl8n3b7/9Nv7666/8Hh8RERERERERETkhq0Op+Ph46PX6Oy43mUwwGo35NS4iIiIiIiIiInJiVodS7dq1w7Rp01Sjc4uLFy+qqXtt2rTJ7/EREREREREREZETsjqUmjRpEtzd3VWj88TERPTv3x+dOnWCv78/Xn/99YIZJRERERERERERORWttTfw8/PD9OnTVXXUmTNnYDAYEBYWhooVKxbMCImIiIiIiIiIyLVDqfPnzyMkJAQ6nQ5lypRR2/bt2+GKzGaz+ppxGqOjPg95DhqNBm5ubrYeDlG6+JR4JCUkIUoThSRtkk1emVRjDLw9UhAXFwOjLu0zT5R23IyXPYTHTbIr3DfJHnG/pGwZYuSXPcA9BtDY5ncssyEJcQlJckIHN/6eR3bE7CTn6JasxJKd5MTNfK9r/Hcn7777LubNm4c5c+aoqXsWY8aMwaZNm/DYY49h/PjxDv2iWePatWvsoUVERERERERElIPNmzejZMmS9xdK/fDDD/j6669VMNW2bds7fr5x40ZMmDABzz77LB5++GG4Allt8MaNG/Dx8XGZII6IiIiIiIiI6F4kaoqPj0fx4sVVX/L7CqW6d++OsWPHomvXrjleZ9GiRZg7dy5Wrlx5z8EREREREREREZFry9Xqe5cvX0bt2rXvep2mTZuq5udERERERERERET5EkoFBwerYOpePZYCAwNzc3dEREREREREROTichVKdezYEdOnT0dqamq2PzcYDJgxYwZatmyZ3+MjIiIiIiIiIiInlKueUjExMRgwYAA8PT0xZMgQ1KxZE35+foiOjsaRI0fw008/qQZW8+fPR4kSJQpn5ERERERERERE5NyhlIiKisLHH3+MVatWITExUV0mN5Vwqlu3bhg3bhyKFi1a0OMlIiIiIiIiIiJXCqUsUlJSVENzqZ6SHlJly5aFRqMpuBESEREREREREZHTsTqUspCbRUZGwt3dnQ3OiYiIiIiIiIjIKlprrnz16lUsWLAAW7ZswYkTJ2AymdTlUilVvXp1tG7dGv369UNISIh1oyAiIiIiIiIiIpeSq0qpiIgITJkyBRs3bkTz5s3VVqlSJVUhJcGUVExJSLV371789ddfaNu2LcaPH4/g4ODCeRZEREREREREROR8oZRUP8mqez169IBOp7vrdaUJ+ooVK9RKfMuXL8/PsRIRERERERERkSuFUqmpqfcMo/LjNkRERERERERE5Bry3Ojc1cm0xRs3bsDHxwdubm62Hg4RERERERERkV2QqCk+Ph7FixdXC+TlS6Nz+h8JpNq0acOXhIiIiIiIiIgoG5s3b0bJkiVxX6HUjBkzkFtjx46FK5AKKcsL7OvrC0dOL6OjoxEQEMCKL7Ir8SnxWHd8HQL9AuGl9bLJGFKNMfD22I/qxepBr/OzyRjIPo+bcXHx8PVlpSzZF+6bZI+4X1K2DDHAzf2Aez1AY5vfscyGJMTFRcG3XEe46dLO7YjsgdlJztHj4uJUIY8lO7mvUOratWtYvHgxQkJCEBoamuP1HPkFs5bluUog5eihlNFoVM/Bld4/sn9uKW7w8vZCoH8g9Dq9TcaQYnSD1t0Dvr7+0OsCbTIGsj9ps951PG6S3eG+SfaI+yVly+AGJHgAOn9AY5vfscyGRMCUlPb/c4ZSZEfMTnaOfq/nkKtQ6p133kG5cuUwa9YsfPjhhyqcIiIiIiIiIiIiyqucu01lMXLkSDRp0gSTJ0/O84MRERERERERERFZ3ej8vffew6VLl/jKERERERERERFR4VRKCZnTGB4efn+PSERERERERERELs+qUMqyEl9iYqL6/ptvvkFMTIxdNwj7/PPP0bx5czRu3Bivv/46kpOTM/XKqlq1aqbtp59+sumYiYiIiIiIiIhcgdWh1MyZM5GQkKC+/+qrr9RShfbq22+/xbx58zB16lTVpH3Hjh0qVLM4c+YMXnjhBWzdujV969+/v03HTERERERERETkCqzqKfW/ZV3v/N7eyBKKs2fPxvjx49GsWTN12bhx47B8+fJModTw4cNRrFgxG46UiIiIiIiIiMj1WB1KOYpTp04hMjISHTp0SL+sV69eahNxcXG4fv06ypcvf1+PI8GcPYdz95KQbMCBSzFo5e9v66EQZfvZUv/Z6DOmHlc9tmN/zqmA9k3uE2RnuG+SPeJ+STnsGJk3G0j7//h//z/n/9PJjpid5HfN3I7faUMpWSUwICAAe/fuxbRp01RA1alTJ7z00kvw8PBQVVJubm5qCuJff/2FwMBADBs2DH379rXqcWT6olRlOardF6Iw6bdT+D3UT70eRPYiPiVe9YCTANmotc1nLMUYB71HkhqDQeu0h0vKw/9gk5KS1Pc8bpI94b5J9oj7JWXLEAdNUhKMyXGAxja/Y5kNiUhOSoYhJhpuWoNNxkCU03HT0jLJkX/XlHOo3LD6CJDxRbH1CyQnBVLtlJ3Y2Fj1c+knNWHCBJhMJrzxxhvqqzQ8P3v2rBp/hQoV8Oijj+Kff/5Rl8sKgx07dsz1GCT4kts4qjLF3BCZaFDPw9bvJ1FG2hQtPD091edLr9Xb5MVJMRqgc/dSY/DSOu7nnArmrz6yX/C4SfaE+ybZI+6XlC2DAUjwAnS+gMY2v2OZDRq4GePg4x8AN52PTcZAdLfjpqOfo2s0GufvKXXgwAEMHTo025998sknKpSaOHGiWnlPvPLKK3j++efx2muvoU+fPmjbtq2qkBLh4eE4d+4c5s+fb1UoJTuJI+8oRf28kJhqQmKqET6eOlsPh+iOz5b6z0afMfW46rEd+3NOBbh/cr8gO8N9k+wR90vKZqfIvNlCht/x+P9zsjduTvC7Zm7HbnUodfz48fTv9+3bB1tq0qQJTpw4ke3Pdu3apb5KJZRFWFiYmg4UERGBokWLpgdSFnJdWaHPlQR56xDgpcXJ63GoVzbI1sMhIiIiIiIiIheRq1BKprblVqNGjWAPqlevDp1Op0K0li1bqsukj5SPj48Koz777DMVqs2ZMyf9NnLdjCGWK5D0snaoH/aej2QoRURERERERET2FUoNGTLkjiBDpu7p9XoV/MTExKj5gv7+/ti+fTvsgfT6ePDBB/H222/jww8/VOP9+OOPMXDgQGi1WjV175tvvsF3332nputt3boVy5cvx9y5c+Fq6oT6Yc+FSAy39UCIiIiIiIiIyGVorZ2yt3jxYrW9++67qFixYvpKd9K7yVKRZC+kh9SUKVMwatQoFUr16tULL7zwgvpZ7dq1VbXU559/rr6Ghoaqpuj16tWDq6lb2h+L9p9Sr5Ejz1klIiIiIiIiIsdhdU8pCW5mz56dHkiJ0qVL49VXX1Wr2I0YMQL2wsPDQzU1ly07HTp0UJurq1HKF7fiUnA5KhGlg7xtPRwiIiIiIiIicgHu1t5AKmmuX79+x+Wycp0s306OR6/ToEYpf+w5H2nroRARERERERGRi7C6Uurhhx/Gyy+/jGHDhiE8PFxN+Tp06JDqxTRu3LiCGSUVuPrlglSz8951Q/lqExEREREREZH9hVJjx45FsWLFsGjRInz99dfqssqVK2PSpEmqZxM5pnplAvH9tnO2HgYRERERERERuQirQykxaNAgtZHzqFrSD6eux8JkMsPdnc3OiYiIiIiIiMgOQqkZM2Zg+PDh0Ov16vt7VVKR4wkr6oMUg0k1Oy9ThM3OiYiIiIiIiMgOQqmdO3di6ND/Z+8+wJsq3zaA383q3qUtLaMtexWQvWXvrYADBHEgAv4FF0OmioAMFRQRQUCGgIKojCogQ/beG9mzdKVtmmZ81/tC+4EUaUvbnCT3j+tcCSdN8ub05CTn6fM8by8ZlBLX/6sJOtknnUYlA1OnbiQxKEVEREREREREyghKLViwIMvr5FhKh3rj5I0kNC0XYuuhEBEREREREZGDU9l6AKQcpYO9cep6kq2HQUREREREREROgEEpylQm1Aunbui5RYiIiIiIiIgo3zEoRZlKh3jjzC09TGYLtwoRERERERER5SsGpShT8UBPeXnhTgq3ChERERERERHZR1AqPT0du3fvxqFDh+R1sj9qlQtKFvJiXykiIiIiIiIisp+gVEJCAnr27IlNmzahd+/eMJvNefXQVIBKh3jh9E32lSIiIiIiIiKi/KXJqwcKCAjA+vXrER4ejj59+kCtVufVQ1MBKhXijePXErnNiYiIiIiIiMg+MqVUKpUMSAleXl559bBUwEoFe+EMM6WIiIiIiIiISAmZUmXLloWLiwuCgoIQFRWFefPm5fe4yIaZUuduJcsZ+DRq9sEnIiIiIiIiIhsGpT755BOZCSVK9CIjI/NpKKQExQI84OJydwa+EoWY8UZERERERERENgxKdenS5T9vv3HjBn755ResXLkSq1evzquxkY1m4BPBqNM3khiUIiIiIiIiIiLlNTpPS0tDTEyMDETt2LFDlvc1adIkb0dHNlFKzMB3Q49WFfkLICIiIiIiIiKFBKX27NmDFStWYN26ddDr9TIY1bt3bznjXnBwcP6MkgpU6RBvnLiexK1ORERERERERPkmW52sL126hOnTp6Np06Z48cUXceDAAXn5008/yV5TXbt2ZUDKgZQMvlu+R0RERERERERk00yp5s2bo3jx4ujZsycaN24sr5NjZ0pxBj4iIiIiIiIisnmmVKdOnRAbG4tZs2Zh8uTJso9UQkJCvg6MbDsDH+7NwEdEREREREREZLOg1Keffopt27Zh9OjRsoeUuKxXr57MnLJarbK3FDniDHz8vRIRERERERGRDYNSgk6nQ4sWLfD555/LANXHH38MDw8P2VNK9Jfq168f1q9fn0/DpIJWWs7Ax75SRERERERERKSQ2fcEEYzq2LGjXOLj4+VMfL/99hsGDRqEo0eP5v0oqcCVCvbCKWZKEREREREREZGSglIZRF8pHx8fdOvWDd27d8fNmzfzbmRkU6VCvPHboWv8LRARERERERGRbcv3MogeUl9//TVq1aqFOnXq4MqVK3j33XcxcuRI+Pn55c8oySaZUhkz8BERERERERER2TwoNWPGDKxatUo2Pxd9poTOnTvj77//xsSJE/N8gGQbxQM95Qx8FzkDHxEREREREREpISi1YsUKjB07Fo0bN5Yz8QliJr4JEyZgzZo1UBKR1fXFF1+gbt26qFmzJj788EOkpaVl3n716lW8+uqrqFy5Mpo3b47Vq1fbdLxKnIGPfaWIiIiIiIiISBFBqdjYWAQHBz+0XvSWSklJgZJ8++23WLRoESZPnozZs2djx44dmD59urzNZDLh9ddfh0ajkYG2vn374r333sOpU6dsPWxFlfCduckZ+IiIiIiIiIhIAUGp2rVr47vvvntgnV6vx5QpU2SfKaUwm82YO3cu3n//fdn7Kjo6GgMHDsycHXDTpk24du0aJk2ahKioKPTo0QMNGzbE/v37bT10xSgdwkwpIiIiIiIiIlLI7HujR4/GgAEDZMmeKIXr37+/LIMLCwuTDdCV4vTp04iLi0OzZs0y13Xo0EEuwq5du2SwysvLK/P2r776yiZjVaqSwd74/fB1Ww+DiIiIiIiIiBxQjoNSoaGhWL58ObZv345z587JMrjIyEjUr18fKlWOE6/yzeXLl+Hr64t9+/Zh6tSpMkDVokULOVOgaNB+6dIlhIeH47PPPsMvv/wCf39/DBo06IEgVnb7VonFXmWMP6vXUCrYE2dv6eUMfKLHFJFN9k3Y7j0mn1c+t32/z6ngjptEtsR9k5SI+yU9Ysd4cLGBu5/j9z7P+ZlOCmJ1kO+a2R1/joNSGUSWkVhsyWAw4MaNG1nelpSUJG8X/aSGDh0Ki8WCUaNGyUvR8Fz0vxK9pNq0aYOZM2di586dMij1448/olKlStkeQ0JCgiwVtOcdJaMXWEbj+gy+mrtvhKMXbqB4gLuNRkjOKtmYLLMxRXmwWWOb95jRrIe7ziDHYNLk+nBJDkYcF8XnS1bHTSJb4r5JSsT9krJk0kNtMMCcpgfUtvmOZTWlIs2QBlNiAlw0JpuMgSin5+j2RJxDZUe2jgBly5bN9sY4fvw4CsrBgwfRq1evLG8TPa7EScOIESPkzHvCBx98gMGDB2P48OFQq9Xw8/OT5Ygiw6tChQrYs2cPli5dmqOglMjGur8E0F6jl+J1ZPU7FjPwXU8BoiN9bTA6cmYaowaurq7y/eWusU1Q1Gg2Qatyk2Nw09jv+5zy57gp9gt7/qJAjof7JikR90vKkskEpLgBWi9AbZvvWFaTGi5mPTx9fOGi9bTJGIhyc45uL0TMJc+CUvPnz8+8fvjwYdlAXPSSEsEbrVaLY8eOyVntHhUgyi+isfrJkyezvE30jBJEE/MMosxQZF7cuXNHziAofsH3lxyK2x/1eI8iHsOed5T7X0NWr6N0iDdO39SjZUX7fo1kx/slbPcek88rn9v+3+dUcMdNIlvivklKxP2SstgpHlxs4b7vePw8J6VxcYDvmtkde7aCUhmZRsLIkSMxYcIE2ej8/kwq0Z9JlMn17t0bSlC+fHkZMDtx4oTsdyWcPXsWnp6eMkOqcuXKsjG7KL3LiOCJ28XroP9XKthLBqWIiIiIiIiIiPJSjjuT37x5E4GBgQ+td3d3R2JiIpRClFV069YN48aNw4EDB7B//37Z1PzZZ5+FRqNBu3btZH+pMWPG4MKFC1i4cCG2bNki70P/r1SIN07dYFCKiIiIiIiIiGwclHr66acxbNgwOaudaL6VnJyMHTt2yHWtW7eGkogeUg0bNsRrr70mlwYNGmDIkCGZQStRhihmEBQBKlGiKGbpE72l6P+VCvGSM/CZLfbd+Z+IiIiIiIiIlCXHUx2MHTtWzmLXs2dPmWkkiPK3Tp06yabiSqLT6WRTc7FkpWTJkvjhhx8KfFz2pHiAh5gpFRfvpCAyiA0AiYiENJMVt2+bkGgAEg0WJKZakZxmgfnerNIijq9RAZ6uLvByVcHLzQX+HiqE+qrk/4mIiIiIKBdBKZFhNHnyZFn2dv78+cwG4fY8Ax09mkatQlQhT5y+kcSgFBE5FYvFistxZpy4bpLLyRsmXL5jxuV4M2L1FmjVKfB1V8HH3QU+biLYJCbPEC1T7/ZONVuA5DQr9Gl3A1axyRYY0gFvVxeE+qpRPFCNUiEalArWoLS4DNHAVWO/zSyJiIiIiPI9KJXRV0r0YBKNwUWjcDHDnejVFBERkZuHIzvoKyWanbdgZSMROTBDuhUHL6VjzwUjdp03Yt+FdKSmW1EyWIMyoRqUL6xB64quCPNVw0+biuIh3lCrVTma3ldkVF1LNONavAXnb5tw+qYJC3em4NQNE9LSragQrkW1Ylo8VVyHWpE6BHoxq4qIiIiIHFeOg1J79uzBq6++ijJlyqBKlSoyKLV7925ZBjdnzhxUq1Ytf0ZKNlM62AunbiTxN0BEDufSHRM2nkzDhhNp2H7WCB93FWpEaPF0GVe808JbBqN0/8peEsElvT4NKpVLjqfF9fUQiwplQ4HGcH3gMf+JNctA2L6LRnyxXi8DVRXCNGhU2hUNS7viqWJaaNTMpCIiIiIiJw5Kffrpp3jxxRczG4ZnEDPbTZo0CUuWLMnL8ZFCmp2vOXLd1sMgIsoTF2JNWHXAgN8OGXD2lgk1InRoUtYVI9r6oEQhtQweFTTxnJFBGrl0reYu191KMmPrGSM2n0rDGz/Ew2K1olVFN7St5IbaUToGqIhIsUSgPT7FihtJZlyPN+PirXQkm5ORaswoabbCaLZmljuLY6BWDVkK7e3mIsuiRXl0mJ9aLiHeKh7ziIgcVI6DUqdPn5YBqH975plnsGDBgrwaFymsfC9jBj51DjMDiIiUID7FgpX7U7HygAFHr6bL7KP+jT3RuKyrPAlSokLeanSu6i4X0d9qz4V0/H7IgLeXJsjjcdtK7uhewx0Vw7W2HioROXHw6WqCBYcvp+P0DZMM9N9dzEgxWmUPvWAfFYI8rSjkc3fiBw+dC0J8VDILVUwMIeZ3FpNDpJutSDJYcTPJLEud41IsuJZgxo3EuxMrFfZVZZZTlw7Romzo3etaZpASETlXUCo8PByHDh16qH/UwYMHERQUlJdjIwXNwCe+NFy6k4IIzsBHRHZ0srT/Ujp+2JEigzmVwrXoVt0drSv6w99TmYGoRxGlgjUjdXIZ2d4bu/9Jx4p9qej2zR1EBKrRo6Y7OlZ2l6WBRET5OfPo/ovpsu+e6MF38HK6DB6JCRtEkKhEIQ1aVHCTWadF/NXwdFXdK3nWy0mRcpOJajKLjCsLLt0xy8CXKG1euicFJ66ZZLZVdPjdPnzVimtRK0qn2D80EBFRHgWlXnnlFYwaNQrnzp1DdHR0ZkBKZEkNHjw4pw9HdjQDn+grxaAUESmd0WTFLwdSMffvFFy8Y0aXp9yxakAgyoQ6RkaRyFgV5Xti+bC9twy4Ldmdik9WJ8msqr71PWU2ARHRkxIBpaNXTdhyOg3bzhqx+x8jvN1U8vhTt6QObzztiQphWrjr8i+TXvTSC/dTy0U8bwaRQXrutujFZ8TeC+kYvyYJF2LNsv9eRi++imGaHPf/IyKigpXjb61dunSRl6Kx+dy5c+Hq6orIyEh8/PHHaN26dX6MkRSAM/ARkdIlp1lkcGb2lmS4a13Qt4EnOlVxk3+pd1SiFKZ7DQ+5HLuajjl/p6DNF7dRJ0qHVxp4on5JnU16ZBGR/RJldLvPGxFzLA1/HDPI3lB1StztvfdhO2+ZFaWE44oINokAvFi61bi77kq8WfbhE8s3m5Lh4eqC1qIXX7SbnNmUASoiIuXJ1Z9SRWAqIzhFzqFUsBdOcwY+IlKgJIMF321Nwdy/k1E8UI2R7XzQooKr0/XAKx+mxWfP+uK9Vl6yZPF/SxJk35ZBTb3QorwrT8aI6JFE1tGue2XBa48aZJ+m5uVd8VFnX9QtoYPrv2YhVSqRTfVcTQ+5iOCamFV19WEDXp0fJ1+DmCji2eruKFfYMTJniYicJii1cuXKbD9gp06dnmQ8pFClQ7ywljPwEZGCGNKtmL89BV//pZd/Kf/qBT958qSEv+DbUrC3GoObe6P/015YvCsFo1YlYtqfKgxs4oXWFRmcIqL/d+amCT/vS5Ulz6npVrSPdsec3v6oWtT+s4pEYE2U8IllXCcfGaASE150/ioWpUM06FbdA+0ru8lZ/oiISOFBqS+++OI/b09OTkZiYqK8zqCUYyoZzBn4iEgZRNPbH/ek4ov1egR5qTC1ux8alWYw6t/ctC7oU89TZgyIpsAf/X43ODWkhRdaVnB1+uAdkTMH9EUvuoU7U+RspM3Lu2FsRx8ZvHHUmezuD1CN7mjBrwcNWLonVR4XO1VxR596Hg7Td5CIyCGDUhs2bMhyvcViwaJFi/D555+jWLFiGDlyZF6PjxQiItADFquVM/ARkU39fSYNY35NkoGpUe190KoCM3+yE5zqVcdT9p0SJ2Ef/pKIbzarMbS1t5zNj4icwz+3TTIQtWxvqgzov1jLA3P7+DtdppCYne+FWh5yOX4tHfO2paDD9FhUj9Dh5XoeaFyGnytERAUp19PzHD58GKNHj8bZs2fx6quvykWn45dbh56BL8gLp2/qOQMfERW4S3dM+Oj3JGw7Y8RbzbzQq44HdHbS40QpRD+VnrU90PUpN8zekoKXv4+TM1m938obpUI4Wx+Ro86eJ8rWZm1JlsfP5hXc8PULfvK97+ylzoLoLfVpV1+829JbljsP/TkRnq4ueKORJzo/5e6wmWNEREqS42+her0ekydPxo8//oi6deti1apVMkuKHF+pEC+cupGE5uVDbD0UInISaSYrZmzUY9bmZHSs7I4N7wShkLfa1sOyax66u83Pn6/ljukbktHuy9voWs0d77TwRoCnc2VMEDkqkU26+ohBHjsvx5llQHriM76y5xw9LNBLhQFNvPBaQ0+sOmjAVxv1+Hy9Hv2e9sKz1dxlxikRESkgKPXLL79g4sSJ0Gg0mDJlClq1apVPwyIlKlfYB8ev3e0dRkSU33b/Y8QHPyXAXeeCpa8HIroI+33kpSAvNUZ38EHvuh4yC63xZ7dkv6nna3pAw+wAIruUarRiye4UOSOp8Ep9D3Sr4S6D0fR4IgP3mWru6FzVTc7aJwL30zfo8XpDTzxfy4PBKSIiWwWlRImeKNXbv38/evbsiYEDB8LDwyM/xkMKVr6wD37ed9nWwyAiB5dosGDCmiSs2G/A2828ZANaBknyT0SQBrNf8sfGk2kY+2siFu1MlcEqUd5DRPYTjBL9omZuSkaIjwrvtxKzbbrx2JlLapUL2ld2R9tKbvjjeBo+/1OP2VuS8b/mXuhS1Z3blYiooINSHTt2hMlkQkhICI4ePYp+/fo98mfnz5+fl+MjBSkf5oNzt5ORYjTBQ8f+I0SU90RgRGRHiem6174ViGKBPNYUFNHct16JIMz5Oxl9v49Dk3Ku+LCtN4J9WO5DZA/BqFBfFT7t4oOm5Ti7Zl5RqVzQsoIbmpdzxa+HDJgcc7ecXPSgalGe25mIKC9k69v+66+/zmaIhGBvVwR46HDyehKqFvPnFiGiPJNitOCT1UlYud+Ake288Wx1d37u2Kh0pV8jL3Su6i5L+ppOuS0boT9f012enBGRMhjSrfhhB4NRBUUc/zpWcZfZZz/uTsXwFYmYuUmN4W285ax9RESUz0EpUa5HJGZpEdlSx64lMihFRHnmwCUjBv+YIBvNrnkrEEUDmB1layE+anz5nB/+OpmGESsTsWJ/KsZ38UHpEPb1IrIls8WKn/amYsofennMZGZUwQfue9bxQJen3GTfrl5z4tCsnCs+aO2NMD9mlRIR5Ua2vvk3adIEKpUKQUFBiIqKwieffJKrJyPHaHZ+7CqbnRNR3pxciSayX2/Sy9ngRCNZ0ceDlOPpMq6IeTsQ0/7Uo8P0WLxS31POUMWZqIgKltVqxfrjaZiwVi9nJR3e1lv2O2IGo214ut6dxbRbdXdMWJuEZlNuy88wMXufmJyDiIjyOCjVuXNnmSUTGBiIiIiIHDw8OWKz83nb/7H1MIjIzt1MMuN/SxJwPcGM5f0CUTGcGThKJWbtGtbGR5auDP05Ab8dMsisqTolXG09NCKnsPeCEZ+uScK5W2YMauqJ52p6yIwdsr1QXzWmdvfDvotGjPk1CT/uTsHQNt5oF+3GEnQiovwq37t69ar8a40IUl2/fh3BwcEyi4qcgyjfEz2lRIYDMxqIKDe2n03DoCUJqBOlw6xefvBy5WeIPagQpsWK/oH4flsK+s6Lx7PV3PFeKy+ZMUBEee+f2yaMX5OELaeNeKWBB+b09oS3G99vSvRUMR1WvBEgZ40d+1sSFu9KxbhOPihRiOXoRESPk+NPtqZNm+LOnTvyeps2bXDlypWcPgTZsaggT5gsVlyITbb1UIjIzlgsVszYqMfL38fjf8288HkPXwak7Iz4Y0Tf+p5YPSgQx6+lo9XnsTLISER5J8lgwfjVSWg57TYCPFX4690gDG7uzYCUwolSyq7V3LF+SJCcQbbtF7cx5Y8k2ZSeiIjyMCglsqSyuk7OQaNWoWyot2x2TkSUXYkGi8yuEbMWLesXgBdqebC0wY5FBGmw5LUAvFzPQ/5eR/2SiOQ0i62HRWTXRBa6KP9q/NltHLycLjMTx3fxRbA3G2jbEx83FUZ38MGy1wPlZBGtpt3G5lMM3hMRPQpzgClXfaXY7JyIsuvcLRM6zYiFFVb8OpD9oxwpK6BPPWZNEeWF3f8Y0XFGLL7ckIyPOvlg8av+KB/GXnv2rFKRuyXPL9f3wJsL4zFwcTxuJpptPSwiIsVhUIpyNwMfM6WIKBvEX4lFQKp5eTd895I/fN35seMMWVMpRmZNEWXHlXgzBiyKR+85cWhd0Q1/Dg5Cq4psku1IJc+96njKkj6h6ZTbWLIrhdUmRET3yfHZgWhwTs5NNDtnphQR/RdR3j1rczL6L4zH2I4+GNram5MjOEnW1LFr6Wj7RSz2XzTaelhEiiX6DH3+px7NJt+GTgNseCcIbzb2gpuW37MdUbCPGl8+54cvevjh8/V6vDA7DhdjTbYeFhGR/feUIuckekrdTErDbT3r44noYelmK95bnog5W5NlBk2nqu7cTE6WNdW9hjue/zYOU2KS5P5ARP9P9BcSfYZijhmw8FV/TOnmhxAf9o1yBo3LuiLm7SBEFVLLiSJmb0mWvcSIiJxZjoNS48ePh7e3t7w+duxYBAYG5se4SMG83bQoHuiBo1fZ7JyIHp416uXv43Dkajp+GRCI6CLsieKM5Sr9GnnhpzcCEHMsDV2+isWZm8wIILqeYJa9hd5cFC/7DK0aEIinium4YZyMt5sKH3Xyxdze/li4MwVdv76DUzfSbT0sIiKb0eT0Dp07d5aXer0eJUqUgEajkde9vLyydf9t27Zhy5YtOHr0KO7cuSPLAQsVKoTy5cujYcOGqFmzZs5fBRW4SuG+OHIlAY1KF+LWJyLpRqIZvefGIchLhaWvB3D6cicnmjSLwOSUGD3afxmL91p54aU6HrLUj8iZiGzBedtSMPUPPVpUcJX9hTijHtWK0mHNW0GY+qceHabHov/TXujXyBM6DY+RRORcchyUMhqNMkPq559/lv9ft24dJkyYgNTUVEyZMgW+vr5Z3m/FihWYOXMmkpOTUadOHdSrVw9+fn6wWCyIi4vDyZMn8c4778DDwwOvvvoqunbt+sQvTpQafvnll1iyZAlMJhNatmyJESNGwNXVFR988IEc07/VqlUL8+fPf+LndnTRRXyx90KcrYdBRAoh/sorGvXWK+mKT7r4QKvml2oCXDUuGNrGG03KumLw0nisP56GSc/6orAvS5XIeWbV+3BlIkwWK759yQ91S7jaekikIKKHmOi52LaSG95bnoDVhw2Y+Iwvs4yJyKnkOCg1ceJEnDlzRgZ0evToIdcNHDgQQ4cOxUcffYRJkyY9dJ+ePXuiSJEi8rbo6Oj/fPxdu3bhxx9/lEGvhQsX4kl8++23WLRoEaZOnQpPT08MGTIE06dPl5fDhw+XlxmuXLkix9mrV68nek5nUSncD9///Y+th0FECjnp6vt9HF6u74m3mnpyQgzKMiNg7f+CMPbXJLScehvjOvmgQ2XOMEaOK1ZvwadrkvD7YQMGNvFE3/rMgKFHE6Xuopxz5qZkdPsmVk4c8VZTNr4nIueQ46BUTEwMZsyYgTJlymSuE9fHjRuHl19+Ocv7jBkzBlFRUdl6fFG+J5azZ8/iSZjNZsydOxfvv/++zMzKCJ6tXLlSXhd9sTJ6Ywkic6pVq1Zo1qzZEz2vs6gY7oNriQbcSkpDIW/+1Y/IWW06lYb+P8RjeFtvPF/Lw9bDIYX3URFZUs3Ku2Lozwmy39THnXzg55Hj9pZEimWxWLF4dyomrk1CrUidbGpdxJ+ZgfR4omxvUFMvtKzgineXJyDm6N2sqWrF2XeMiBxbjoNSovzO3f3hmZREGZ4IBGVl48aNMlMpJCQk288j+lU9idOnT8uywPuDTB06dJDLv23fvh27d++WpYi5KRG05xkJM8af09fg5apBVJAnDl2OR5Oywfk2PnJemfsmbPcek88rn9u+3+f5Zc0RA4YsTcCnXXzQoYq702yj3B436a4W5V1RtWgghq5IRMtptzGhqw8aleYfN7hv2r8jV9IxYmUi7iRbMaWbryxbFZz9WMFjZs6UDtHgp34BmL01BS/OvoPna3pgSAsvuOscrCw+4ztW5nctWwzhvu94Tv4+JWWxOsh3zeyOP8dBqSZNmshyONFHKsOlS5dk6V6jRo2yvM/SpUsxefJkVKtWDe3bt5e9nR7VeyqvXL58WT7Hvn375HhFgKpFixZ49913odM9+BeHWbNmyQbuhQsXzvHzJCQkPDIYZy87SkpKirwums7nRNlgD+w+ewPVCvNkgvJesjEZaWlpciIFs8Y27zGjWQ93nUGOwaTJ8eHSof1yKB0frzViYidXPF3SLLeRsxDHTYPBkKvjJt3l7gJM7azBioOQs5G1q6jB4KY6eDjaSVcB475pG4kGK6ZvMmLFARN61dLilXo6uGvToddzRjXul7n3YjWgbnF3jPzNgJbTUjGmrStqFHegrDuTHmqDAeY0PaC2zXcsqykVaYY0mBIT4KLhLLHkGOfoSpLd84McHwFGjhyJYcOGyRI7kR0lGpInJSWhfv36+PDDD7O8j8hAOnbsGNauXYvZs2fLUj/x8yJA1bRpU9l4PDfEScGNGzeyvE2MSdwugmGi35UY66hRo+Tl/eMUAbUdO3bIHlO5IQJf2Z15UMnRS/E6crrDV4sMwtYzsfkeYCTnpDFq5LFBvL/cNQ9nZxYEo9kErcpNjsFNY7/v87wmZpH6LCYd373kjzolnK+sIOO4KfYLe/6ioAS96gNPlzfhnWWJ6D4nDZOf9cFTLFXJNe6bBb+9fzlgwMer9SgTqsHvgwIRVYh/wOB+mXeivYCf+t+dvXHA0mR0fcoN77fygqerA5Q9m0xAihug9QLUtvmOZTWp4WLWw9PHFy5aT5uMgSivz9GVRK3OXiA9x5+cog+TmNFOBHNE3ycxq11kZORjy+3Kly8vl8GDB+PIkSMyQCVm6xOz4YnAVLt27WSgKrsDFw4ePPjIxuTisUVQSjy+CKBl9I0Szy8CUCqVKjNgVq5cOZQsWRK5IXYSe95R7n8NOX0d0UX88NVf5zIfgyhf9kvxz0b7l3xe+dz2/z7PK3P/TsaUP/SY39cfTxVzvoDUkx436WHFA7VY8loAvhOlKt/Fo089D/yvmRenRee+qWhnbpow8pdEeTmqvTfaRbNx/3/hMTP3NGoX9G3ghabl3PD+TwloOS0WE7r6on4pO69UyPiOlfldy0ZjuPcdj5/npDQuDvBdM7tjz9Wfc0Qp3J07d2SfKEFcF4tQo0aNx96/YsWKcnnnnXdw+PBh/Pnnn7IcUGQ0bdu2LdvjqFWrFk6ePPnIWfyE+xusi+CZKAcSYw0KCpLrtmzZIoNilHMVwnxxJzkN1xMNKOxrm0wWIio487ffC0i97I+qThyQorynVrngtYaeaFRah7d/TMDGk2myJ0+5wlpublIUQ7oV0zfoMXtrMnrU8MA3Pf1kE3+i/BYRpMHiVwOwcGcqXl8Qj/aV3TCsrTd8uP8RkZ3LcVBqwYIFMoAkMqSyioQdP348248lgkMnTpyQy7Vr11C2bFnkFZGVpdVq5WOLDCxBZHaJQJqfn19mWpwIivXr1y/PnteZuOvUKB3ijUOXExiUInJwC3akYNJaPeb1ZUCK8k+ZUC1WvhmILzfo0fmrWJkx9WoDTxm0IrK1jSfSMHJVIgI8VVjeLxAVwxk0pYKlUrmgZx0PPF1Gh2Fisoipt/FJF180LmPnWVNE5NRyHJT66quv0L9/f/Tt2zdXvaBED6iYmBi5iCbkpUqVQps2bWS/p7CwMOQV0eujW7dusn+VCKKJANRnn32GZ599Fpp7DYuvXLkiZxPMbekeAZXCfXH4cgJaVgjl5iByUAt3pmDCmiTMe9m5S/ao4KZFH9LCG43LusrZHf88lobJ3XxRPJC9esg2riWYMfbXRPx9xoj3WnnjuZruDJSSTRUN0Mis5aV7UjFocTyal3fFyHY+8PNg1h4R2Z8cf8MTvZhatWqVo4DUxYsXMwNRop9UeHg42rZtKwNR+RkQEj2kJk2ahNdee00GpTp06IAhQ4Zk3h4bGysv2ag796KL+OKP4zfz4LdFREq0dE8Kxq9Owvd9/FGNDaipAIkA6OpBQfh0TRLafB4ry1Ser+lu170VyL6YzFZ8vy0FU//Qo0UFV6wfEoRC3g40+xnZNXEs7F7DAw1Lu2LYz4loPvU2Purkg5YV3Gw9NCKi/A1KiSwpEegRDcRFcCk7WrRogUKFCslglrhfdHQ0CoJOp5NNzR81s17lypUf2ZOKsqdSET9M/uOUDPrxRIHIsaw9YsDoVUn47iU/VI9ghhQVPHedC8Z09JFZAO8uT0DMUQMmPuOLEB8GBih/7b1gxPAViUg3W/HtS36oW4LlUaRMhX3VmNPbDyv2G/De8gT8dsiA0e19EOjFrCkictCgVEREBKZNm4ZmzZpleXtWPaXmzp0rm5JnzHhHjqN8YR+kGM04dzsZJQrZZjpXIsp7f59Jkw2nv3zOF3V4MkY2JmaZWvu/IIxZlYgW97IB2lfmBBuU9+KSLZiwNgm/HDBgQBNP2dNMlJQSKZn4w3CXp9xRv5QOH668e5wc09EbbStxVkgicsCg1MiRI2Xj8M6dO8PNLXvpoXXq1Mm8npKSgmXLluHcuXMwGo0P/ez48eNzOiSyIZ1GhehwX+y7EMegFJGDOHgpXc7s83FnHzQrzzIAUgZfdxWmdPfDmsMGDF+ZgLVH0jC6gzfLqShPWCxWLNubKgNSVYrqEPN2oOzbQ2RPgr3VmPmiH34/bMDIXxLx60EDxnXykeuJiJQqx5+2Ysa8wYMHo2jRorl6QnHf/fv3o27dutkOapGyPVXcH/suxuPZ6rnbJ4hIOU7fMKH33DsY3NxL/tWVSGlaV3JD9QitLC0VPVRGtfdBpyrMBqDcO3DJiFG/JOG23oxPOvuiZQVXtiQgu86aahftjjpRrhi1KhHNp9w9TnauyuMkETlIUKpr165YuXIlBg4cmKsn3LlzJ+bMmYOqVavm6v6kPE8V88O0P0/behhE9ISuJ5jRa84d9KztgZfre3J7kmKJZtMzXvCTfc8+/CURqw4YZGZfmB+zASj7RBBq4lq9zCZ5raEH+jXykn3MiByB6Ck1/fm7x8kRKxNlr6lPOvsg1JfHSSKy86BUUlISfvzxRyxfvhxFihSBWv3ggW3+/Pn/ef+oqCgYDIacj5QU66li/jh5IwmJhnT4uGltPRwiygV9mgV9vo9Dg1KueLs5+8ORfWhV0Q11onQY93sSWk69jQ/aeOO5Gu5QqRhYoP+eVW/BjhRM+UOPuiVYqkeOf5ysHaXD2N/uztA3oq03ulXnTKZEZMdBKVG29/rrr+f6CT/99FMMGDAA7du3R1hY2EPNzzt16pTrxybbCPZxQ7ifOw5eikeDUoX4ayCywxO0NxfGI9BTJbNNOJMm2RNfDxU+e9YX7Su7YdjPCTLrZUJXHxQPZD8getj2s2my9DPdYsWM5/3QsDRn1SPH5+ehwpRufth4Ig1Df747Q9/4Lr4o4s+sKSKyvRx/YxMBpSexdOlSXLhwAYsXL4ar64NfBMSJEINS9pstte8Cg1JE9sZqtWLkqkRcT7Bg2RsB0KqZYUL2qVFpV6x7OwgT1ujRalosBjX1xCsNPLlPk3Q5zozxa5Lw14k0vNXMC73renBWPXI6jcu6ImZwEMavTkKrabfxfmtvvFCT2aVEZGdBqdTUVFm+d+bMGZjN5sz1Yia9Y8eOYc2aNf95f1H2N2XKFLRp0yZ3IybF9pXacPKWrYdBRDk0a3MK/jiWhpVvBsLH7cHMVSJ74+WqkjNNdajihuErEvHzPgM+6uSDWlE6Ww+NbCTJYMFXfyVj7t/JaFPRDRveCUKID7NDyHmJz3qRJdW2khve/ykBvx1MxYSuvogIYnapvYlPMWLVwavYfjYW528nw2oFwv3dUTsqAO2iwxDmxwlryD7k+AxkxIgR+Oabb2RwatWqVUhPT5cBqt9//x1t27Z97P39/f1RsmTJ3I6XFKpa8QDsvxgnp1QmIvsgmp9+sV6Pub39Ec4G0eRAakTo8PugQDxTzV32ShuyNB6xeouth0UFXJb8w44UPD3pNvZdMGLZ64GY0t2PASmie+qXckXM20EoE6pFq89vY0pMElKN/B5vDwzpZnz+52nUGb8Bvxy4iugifhjcvDTea1UG9UoGYeuZWDz92V8Y+vNhxCUbbT1cosfKcUh88+bN+Pzzz1G3bl2cPn0avXv3RsWKFWWvKPH/xxk1ahTGjh2LN998M8tG6aLPFNmfsoW9kW624OwtPUqFeNt6OET0GCeup+OdZQmY0t0XFcM5QQE5HlGK+nojT7Sr7IYxqxLRZPItvN/KGz3YCN3h/XUyDR//ngSTxYrxXXzQvLwre+URZcHTVYWxHX1kAF/MZPrz/tsY2c6b7xkFuxCbjDd+2Ae1ygU/vFIL1Yr7P/QzfetHynOy8auPo/nUzZjWvQrqlwqyyXiJ8iUolZaWhoiICHm9VKlSOHLkiAxKde/eHS+++OJj75/RJL1Pnz4PfEEQfU3E/48fP57TIZECaNUqGaXfeyGOQSkihYtLtuDV+fGy307LCm62Hg5RvhJZgLN6+WP9cQNGrUrC0j2pGN3BG1WKsqTP0Ry7mi77Rh26nI7/NfPCC7XYN4ooO6KLaLHijQB5fBQlfYt2aTG6vQ9L+hTm6NUEvDh7JzpVDcewNuXk+dejlCjkhW97VceyPZfx6vw9GNGuHF6oVbxAx0uUb0GpEiVKYNu2bXjmmWdkUGrv3r3o0aMHkpKSZMDqcdavX5/TpyQ7Ub24P/ZciEOPmsVsPRQi+o+SlgGL41EuVINBTTy5nchpNC3nhrolXPH1X3o8NysOrSu64r1W3gj1ZX8he3f+tglT/9Aj5pgBL9bywJfP+cnZxogo+1QqF/So6YFWFd0waV2SLOl7pb4n3mzsBXcdJ0GxtWNXE/H8tzvxeqMo9H86e61wRMJHtxpFERHkiVfm7YbZYkWvOneTS4jsfva9t956CxaLBR07dpR9pPr164eTJ0+iQYMGWd5n+/btqFOnjrweHh6erecRgS9RIkj2o1ZUIEasPGzrYRDRfxBZBLeSLPimf4D8AkrkTMSJ1eAW3uhe0wMT1iShyeTbeL2hJ15r6MmTLjt0LcEs++L9vC8Vnau6Y8OQQghjfzyiJyICuh939kWPGh6ypO+nfbfwTgtvdK7qxu8NNnIzyYC+83bjlfqR2Q5I3a9mZAC+f7kmen23C16uGnR5qki+jJMot3L8Z6SmTZvKGfZq1aqFwoULY9GiRYiMjMRzzz2HTz755JEz7vXs2ROrV69GcnLyIx9bNE//5Zdf5GOJ+5B9ETXNV+MNuBqfauuhEFEWVuxPxfK9qZjV00/OUkbkzCV9XzznhwV9/bHhRJrsN7Vyfyon67ATd5It+Oi3RDT+7BYSDVasfisIn3b1ZUCKKA9VKqLFz28E4IPW3pjyRxLaT4/FtrOPr4qhvGU0WfDa/L2oHRWIAU1yP1nYU8X88U3Pahi+4ohst0KkJLma+7No0aKZ18uWLSuX/zJ58mTs2LEDX3/9NT744ANER0cjKipKzsQnMq7i4+NlptWJEydQpUoVmY1Vr1693AyNbEhE3iuG+WDn+Vh0rsoIPJGSnLyejuErEvHVC37sEUF0T7XiOqzoH4BfDhowYW0SZm1OxrstvfF0GR0bYyvQbb0Zs7ekYMH2FNSI1GJ5v0BO1ECUj0RGdccq7rL/5Ny/k/H6/HjUitLJQFXJ4FydRlIOTf7jpAxMje9S6Yk/l8TMfGKGvn4/7MXvA+sj2Id9RUkZcnw0uXLlCqZNm4bDhw/DZDLJBuXZ6RlVu3ZtuZw7dw5bt27FsWPHZFNz8eYKDAxEhw4dMGnSJBQvzgZs9l7Ct+v8HQaliBQkOc2C/gvj0be+B54u42rr4RAp7qRLlH61ruiGH3akYMiyeJQopJHBqZqRbIauBNcTzDJguHhXKuqU0GF+X38ZUCSiguGmdcEbT3uhW3UPfL5ej7Zf3JYz9g1s4sW+fPlo+9lYLNh+AasG1IObNm/6H/auG4EDl+Lx7vJD+L5PDf4BhuwzKPXee+8hLi4OL7zwAry8vHL8hCJDSizkmGpGBOCT1ZxBkUgpxB8ORIZUIW+1nI2KiB590iVmpOxewx1ztqbg5e/jUK24FkNaeMuZqajgXY4zY+YmPZbtSZUB9WX9ApgZRWRDgV4qjO3og151POTkAk9/dgvP1/TAG097yu8ZlHdSjCa8s+wg3m9VFiWDvfPscUVCyNiOFdF62mYs2HGBjc/JPoNShw4dwooVK1CyZO5rWslx1YgMwD+xybiZaGBKKJECLNmdiq1njFg9KBBqNjYneixvNxXeauaFnnU8ZECk+zd3ZKnYm097ybIVyn+HLqdj9pZkrD1iQMuKblg1IBBlQhkYJFIKUbo34wU/HL2aLoNTDSfexkt1PeTEEf6e7FmZF77ccAYhPq7oWTvvq4h83bWY3K0KXv5+NxqVLoTigZyNmWwrx0eNiIgI3LlzJ39GQ3ZPHOTKhvpg1z/cR4hsTXxZHPtrEr7o4YtgH/4FkygnAjxVGNbGB1vfL4TKRbR4ZX4cnp0Zi40n0x5qXUBPTkxVvu6oAd1mxqLHrDty+/8xOAhfPufHgBSRQlUI02L2S/5Y/Jq//M7RYOIt2Z/vZpLZ1kOza2duJmHu3+fxUadK+TbjYZ0Sgej8VDhG/nKUn2lkf5lSr776KkaMGIE+ffrI/k9a7YN/uapRo0Zejo/skJh2dOe5O2gXHWbroRA5rRSjBQMXxaNfI0/ULck+UkRPUq4iSvhebegpe069szQBwT4q9KnngQ6V3WXZH+VeQooFP+1LxbztKTCarOhd1xPfvuQOX3dmWxDZiypFdVjQNwC7/zHi67+S0WDCLdlz6rWGnigeyIboOSH+6PHhyqN4vmZxlA/zQX56v2VZNJn8F9YcuY42lQrn63MR5XlPKWHMmDFZ1qiK5uXk3GpHBWDKH6dsPQwip/bR70nyZHpAE6ZkE+UFHzcV+j/thT51PWUQ5dvNKfh0TZLsp/JibQ82+83hSde+i+lYuDMFvx8yoFK4FoObe6FNJTdo1QzyEdmrGhE61Oitw/Fr6fhmUzKaT70tZ+4TZX0Vw1mCmx2rDl7F2Vt6zOpVLd9/X74eWgxrUw5jfz2GxmWC4a5jVj3ZSVDqxIkT2fq5vXv3olKlStDpdFneNm/ePFy4cAEzZ87Er7/+ivDwcLRt2zanwyEFqhkZiNM39YjVpyHQixkaRAXtz2MG/HrAgNVvsY8UUV5z17nIINQLtdzx9xkjvt+WgoYTb6F5BTd0r+6OeiV17N/2CLF6C349mCpn0buaYEbXp9zZL4rIAZUrrMW0Hn4YcseE2VtS8OzMOygfppEN0sVMpzoNg89Z0aeZ5IRRw9uWg7dbwQTxujwVjvk7LmDO3+fxZmP2jCbbyLfcaFHmd+PGjYfWx8TE4LXXXpNBqPPnz8NkMkGj0eCDDz7AokWL8ms4VIACPHUoE+KNbWdjud2JCtitJDPe/ykRYzv5oGgAU+aJ8ovIDq9fylX2UxG9j4r4qTF4aYIsW5kSk4SLsSZufACpRitWHUyVsxnWHn8Tvx0yoG8DD+waFozRHXzYL4rIgYnvIWM6+mDHsEJoW8kN0/7Uo+6ntzA5JgnXEtib79++3HBaNh3vUDmsQD/LPmhVFjP/Oou4ZGOBPS/R/fLtjOVRTUCnT5+O0aNHo3379liyZIlc9/LLL6NQoUL44osv8Pzzz+fXkKgANSgVhK2nb6N9AR5UiZydOO6+tzwRdUvq0KmKm62HQ+Q0RM+UoW288U5LL2w6mYale1LRdMptVC2mRbtoN7Sq4OZUkw2IQNTWM2lYc8SAdUfSEOqrQueq7hjTwZvBciInJHrEvVzfE73resgZgedvT0HDKWmoHV4Cz1Q0o0UZK9ydvD/fmZt6fP/3P1j5Zj0ZKCpIoul5tQh/TN94Bh+2K1+gz00kFPif0UXJXpUqVR5aHx0dnWVmFdmn+qUKYdjPh+VJckEfWImc1Q87U3HyejrWvBXE9x2RDYh+SM3Ku8nltt6M3w4aZGbQmF+TUK2YVvZMalHBDWF+jhegiku2YP2JNMQcNWDz6TQEe6vRsoIrfnw9ABXCNDwmEZGcSa5haVe5XL8ThxVbk/DFDl+M+PMm2pRxQ+cK7qhRROt0JdBGkwWDlx5Az9rFUa5w/jY3f5S3m5XG89/uwODmpeHpykx7KlgFvseVLFkSW7ZseSgjasWKFfI2cgw1IwJwKykN528nI6qQl62HQ+TwLt0x4dPVSfi2lx98PThrFZGtBXmp0buep1xuJpqx9qhBNvUe93sSShTSoFFpnTwxE42B7XEGP0O6FfsuGGXWg+itdfhKugw+tSjvhiEtvFA6hIEoInq0UB8XvFH9JvrVjsLBW5746YgB/X+Jg8rFBS1KuaJVaTfUKaZz6MkPLsamYO3Ra1i5/6p8ne+0LGOzsUQX8UXRAA/8fvgaulUvarNxkHMq8KDU0KFD0a9fP+zYsQPp6emy0bnInjpy5Ai+/vrrgh4O5RMxe0P1CH9sPXObQSmifCYyEkUfqU5V3VC3JCcXIFIaUbrXq46nXBJSLdh2xohNp9Lw3vIExKVYULWoDtWKa1EtQoenimllqYsSm5QfuGTE/ovp2H8pHXv+McLPQyUbu79U10NehjhRiSIR5Q1RUVGlsE4uo5p6Y9clI9adTsO7axJgMFnxdKQrGoiluA4h3vZ9jEk1mrHzfKxscbLl9G2cu61H3RJB6FWnONpVDoObVm3T34MIRv209zKDUuT4Qanq1atjzZo1mU3N4+PjZTnfxIkTERbG/kOOpP69vlK96kTYeihEDk3MZHUh1oRZvfxsPRQiegwRcGpdyU0uIqB85qYZu/8xYs8FI35dlYiLd8woWUiDcoU1KFtYg3KhWpQJ1aCwr6pASuBMZiv+iTXj1A2TXE7fMOHI1XQ5rqggNaoU1aJVRTeM6eCDEoXULMsjojyjUbmgbnFXuYgA1f6r6dh0Lg0/7E/Be2sSUCpQg/oROtQoosNTYVoEeyk7SJVkSMfBSwnYdzEO28/GYu+FOBTydpW9dwc2LYkGpQrB171gZtnLjrbRhfHx6uO4mWRAsDd7k1LBsUnBqGhq/tZbb9niqakANShZCF9vPAuT2QKNWnl/9SVyBFfizRi/OgnTX/CDlyvfZ0T2RASZSoVo5PJ8LQ+57maSGYcupePEdROOXjXhp72pOH/bDJ0GKOKvRlF/jbwM81MhwFMFf4+7lyJrScwgbkqzwqKxwFWjgmjLkm62wmQGjGYrjGYgIcWCeLGkWuXljUQzrsRbcCVOXJpxLcEM8ZFdMliD0sEaVCqiQbca7qhSRMvSYCIqMKKMr1q4Ti6DGwDxIsv0ohFb/knD1K16nLptQhFftQxOVS6sRdlCGpQppEWgjVoYJKSm49SNJJy4noRjVxOx/2Kc/H9hX3c8VdwfbaILY3yXSige6KHYYH6IjxueKuaHdUdvyP5WRHYflIqMjIRW+3Dkt0mTJlm+EcU68fMiYNW6dWs899xzTzwG8RfIL7/8Us7yZzKZ0LJlS4wYMQKurnfLW/bs2YNPPvkE586dQ/HixfH++++jbt26T/y8dFf5MB+o1S44eDkB1Yr7c7MQ5TFxjBv2c4LMWmhUmmV7RI5ANAhvVl4sD/ZvuhxnxqU4My7fEZcmHLtmks3F7yRbZAmgWAzpGfdIyfKxxdcvHzcXGcCSi7sLCnmrEe6nQs1ILYr4qWXAK9xf7XSNholI2fzcVbIZuliExDQLDlxNx76r6dj6jxHf7UnGlUQLgjxUKB2kQXF/tQxaFfG5exnqrYa/m4uc5S+nQSHxfSs13Yw7yUbcTErD5bhUXI5LkZeX7qTImfOuJRgQ4uOKMqE+KBfqjf81K4Wnivkj2Me+Mo7aVCqMNYevMShFyg9KZfSAEj2h/q1Tp07y8ueff87yvi+++CKmT58uL0XZnniTi8dasGABunbtiuDgYNlbSq/X49VXX8WT+Pbbb2WZ4NSpU+Hp6YkhQ4bI5xaXsbGxsreVWESw6vfff0f//v2xdu1ahIaGPtHz0l3iC229EndL+BiUIsp7P+0z4Pg1E754jmV7RI5MNEIXmUti+S8WiwVxCXpo3TyRbnaBxWqFTu0CjfruzICiXYlS/0JPRJQTPq4qNIx0lUuGpDSLzKASy6UEM07eMmHD2TRcTjDjpt4CKwCdGvBzU8HfXQVXtRVqqw7uXgeg1dxNpkg3W+RseEazBWnpFpkBFZdiRJrJIgP7gZ6uKOLvLpuCi8sKFUNRspAXyoR6w89DZ/e/xFYVQ/Hx78dxW5+GIC/+wZMUGpSaPXs2PvvsM/j6+spAz/3EF52MoNSjrFy5EuPGjUPbtm0z1zVt2hRlypSRTc/F7eXKlZMZTU8SlDKbzZg7d67MfqpTp45cN3DgQPn4wr59+6BWq/HKK6/I/4vglPj5AwcOoFWrVrl+XnqQqJletvcy3mpWipuGKA+JDImPf0/E+C6+imyKTEQFT3wP02lc4OVWMP2niIiUxNtVlVny929mixWJaVbEpVrkIsoBDUYj9EmpUAeGIh3ae4F8FXQalSyBFpei55O/h04uPu5ah88iFeWGlYuKEr7reKEWS/hIoUGpOXPm4N1330Xfvn1z9YQXL15E2bJlH1pfqlQpWUYnREREyEymJ3H69GnExcWhWbNmmes6dOggF8HPz082WY+JiUHz5s2xfv16JCcno3Tp0k/0vPSgxmWDMXzlEZnuGuBp/389IFKKT9ck4aliOrSswL9iEREREf0XEUzydxfL//8hz2qyQh9vhldkKFy0DyZbOLPWFUOx9giDUqTgoFRaWhpatGiR6ycUJXuiz5Po5eThcbepZ0pKCmbMmIHo6Gj5/02bNskeT0/i8uXLMptLZESJ8j0RoBLjFgE1nU4nZwF84YUXMGjQIKhUKplZNX78eERFReXoeUT5oVjsVcb48+s1BHu7yrrqv07eROeq4fnyHOSYMvdN2O49Jp9XPrey3udiKvZVB1MR83aQ/L+SxuYM8vu4SZRb3DdJibhf0iN2jAcXG7j7OX7v85yf6ZlaVgjBp2tOIC45zSFKEu2R1UG+a2Z3/DkOSrVv3172aXrvvfdylRouSvdEqVyDBg1kRpQYqOhRVbhwYXzxxRfYunWrDFh9/vnnj30sg8GAGzduZHlbUlKSvH3y5MkYOnSo7LMwatQoefnhhx/KrKhLly5hwIABaNy4scyY+uijj1C5cmWUKFEi268nISFBBrTsldj+Iigo5Feqf91IX8QcvoImUV758vjkmJKNyTIILvrLmTW2eY8ZzXq46wxyDCaNTSYrfYiYSWvYilS8Vk8LP20q9Hpbj8j5iOOm+HwRWCJFSsJ9k5SI+yVlyaSH2mCAOU0PqG3zHctqSkWaIQ2mxAS4aEw2GYMSeauA0sEeWLX3H3SMDrH1cJyStQDO0QuCOIfKDk1uHnj58uX47bffUKRIkYdm2Js/f/5/3r9o0aJYtWoVtm/fjlOnTsm+TqJ0T/R9EhtclNWJTKmAgIDHjuXgwYPo1atXlrdNmTJFnjSI3lQ1a9aU6z744AMMHjwYw4cPl72xxC9bBKWEChUq4NChQ3L8Y8aMyfb2ENlYXl5edh+9FK8jv3b41pWL4qU5u+Dh5Q2tmGeaKBs0Ro2cKVO8v9w17jbZZkazCVqVmxyDm0YZ7/NvtyTDChX6N/WXvWPIdsdNsV/Y8xcFcjzcN0mJuF9SlkwmIMUN0HoBatt8x7Ka1HAx6+Hp48vyvX9pWzkcm87Fo1cDtrZx1HP0giBiPfkSlBLZTSLT6UkHV79+fblkMBqNOH78uMxUyq5atWrh5MmTWd62a9cueXl/OV5kZKTMvLhz5w6OHj36UG8r0WBd9KLKCbGT2POOcv9ryK/XUbmIn2wUuO9iPGpHBebLc5DjydwvYbv3mHxe+dzKeJ9fSzDj8z+T8V1vf7hqGeB15OMmUW5x3yQl4n5JWewUDy62cN93PH6eP6h1xcL4/M8z0KeZ4O32YBIKFdTu6WL3+2Z2x57joFRGZpEgy2rMZhnByy7R40lkIp05c0aW0v07WHXkyBHkhfLly8ssrhMnTmQGv86ePStnDBTZWMHBwXIM9xON1kX2F+UtlcoFjcsEY+OJmwxKET2BCWuS0Ky8K2pHsb6fiIiIiPJHVCEvRAZ5YsOJm+hYhX2BKX/l6k/t8+bNkz2hatSogdq1a6NevXqYPn16tu4r+jaFh4dj5syZcHd3l03PRYmdCBRNnDgReUWUVXTr1k32sDpw4AD279+Pzz77DM8++yw0Go283Lx5M77//nvZW0pcin5Wzz//fJ6Ngf5fk7LBWH/iJjcJUS7tu2jEuqNpeL+VN7chEREREeWrVvdm4SPKbznOlBKz5P3www946623ULVqVZntJLKfRFBKzGr32muv/ef9RXncpEmTZDNx0cdJZDOJWfACAwPx7bffok2bNsgrooeUeC4xJlGX2aFDBwwZMuSBWQBFc3XRVF2U9s2aNUv2t6K8V79UEAYt2Y+LsSkoFnh31kUiyh5x/Br7axJea+iBML/s1WYTEREREeVWm0qFMWvzOaQazXDX8fsnKSgotXTpUnz88cdo0qTJA72YQkJC5PrHBaVEdlRGwyvR70n0hGrUqBGio6Nx/vx55CURJBNNzcWSlaZNm8qF8p+oRRb9pGKOXccrDf6/zxcRPd6qgwbcSDSjXyNlNFsnIiIiIsdWOsQLhX3dsOnUTbSqWNjWwyEHluPyPdFHSjQ7/zeRaSQaiD+OKPebPHkybty4ITOtVq9ejfj4eGzYsAE+Pj45HQ7ZWQroGqaAEuVIitGCT9ckybI9d539NjokIiIiIvtqUs3zN1JkUEoEkubMmfNAk3LR7FysE9lOjyOylhISEhATE4O2bdvK3k8iUDV+/Hi8+eabOX8FZDdalA/FwUvxuJFosPVQiOzGrM0pCPFRo0NlN1sPhYiIiIicbBa+9cdvIs1ktvVQyIHluHxv6NChsgfUtm3bZE8o4ejRozAajZg9e/Zj7y/K/ObPn5/5/wULFshZ8ESWlOgvRY6rkLcrqhX3x7qj19GrzsPZdkT0oFtJZszanIwFff3lLJZERERERAWlYrgP/Dy02Hr6NpqWC+GGJ2VkSokG5WvWrEHv3r1lc/KwsDDZR2rdunUoW7bsY+8v+k/dX+Yn0gJFc3GTycT+Tk6gtSjhO8xZHIiyY/qGZNQvqUO14jpuMCIiIiIq+BK+CmzBQgrLlBL8/f3Rq1evbP/8ypUr8fPPP2fOIiXK9P6dFXXz5k0UKlQoN8MhOyKa5H30+3HE6tMQ6OVq6+EQKdbFWBOW7E7BrwMDbT0UIiIiInJSrSuF4uXv9yDdbIFWneOcFqK8CUqJGeqWL18ug1Fi1j0RMX2U9evXP7SuefPmuHz5sry+a9cuVKlSBZ6eng/8jIeHh/w5cmyhvm6oVMQXfxy7gR41i9l6OESKNeUPPdpXdkfpEJY1ExEREZFtVC3qDzetCjvOxaJBKSaRkI2CUgMGDMgMIg0cODDHTyLuKx5DCA8Plw3OdTqWozhzCd/qI9cZlCJ6hGNX07HmiAEb3uEHPxERERHZjuhr2vJeCR+DUmSzoFTnzp0zr1+5cgV9+/aFu7v7Az+j1+sxffr0R5bvZRBZVqtXr37kc3Xq1Ck7QyI71qZSYUxad5IlfESP8FmMHi/W9kC4n5rbiIiIiIhsqlXFUAxavB/jOlaEmpPvkC2CUufOnUNsbKy8PmPGDNnQ3NfX94GfOXXqFJYsWYIPPvjgoft/8cUX2RqMCFgxKOX4ivh7oEpRP/x26BpeqstZ+Ijut+cfI3adN2LSM8ySIiIiIiLbqxUpepy6YPvZWNQvFWTr4ZAzBqVEE3Ix216GjFK8+4nMqZdeeinL+2/YsOFJxkgOqGOVcPy07zKDUkT/8vl6PfrU80CgFxtJEhEREZHtieyoDpXDsPLAFQalyDZBqdq1a+PEiRPyumh0LpqeBwQE5PpJRZBr4cKFOHv2LMxmM6KiovDss88iIoJZM86ibaXCGPvrMVyITUbxwAeb3hM5q70XjNh3IR1f9PCz9VCIiIiIiDJ1rhqO577dIUv43HVsMUF5J8d/ihdZT48KSIlg0+Ps2bMHLVu2xM6dO1GkSBG57N69Gx07dsTevXtzOhyyU/6eOjQsXQgr91+19VCIFOOL9Xq8VNcD/p7MkiIiIiIi5agY7oNgH1f8efyGrYdCzpgp9e/+Up999hnOnDkjs5wEq9UKo9GIO3fu4NixY/95/08//RQvvvgihgwZ8sB68ZiTJk2SfanIOXSqGoYpMacwqGlJ2U+MyJkduGTE7n/SMbU7s6SIiIiISFnE+VrnKuH45cAVtK8cZuvhkAPJ8Z/jP/zwQxl8EjPw3b59Gy+//DJatWolZ9/7+OOPH3v/06dPo2vXrg+tf+aZZ3D8+PGcDofsWLNyIbiZlIbDVxJsPRQim/tifTJ61vZAALOkiIiIiEihfYE3nbqFO8lGWw+FnDkodfjwYYwaNQrdu3dH+fLlZT+o9957D8OHD5e9ph4nPDwchw4demj9wYMHERTETv7OxE2rRptKoVi+97Kth0JkU4cvp2P7WSNebejB3wQRERERKVKxQA9EF/HD74fYgoVsGJTSaDTw9vaW10VAKiO7qW7dujh58uRj7//KK6/IoNa0adNkfyqxTJ06FWPGjEGfPn1y8xrIjnWvURQr9l+BIf1uKSiRM/pygx7P13JHkBebRhIRERGRcnWqEibP34hsFpSqWrUqvvvuOxgMBlSsWFEGlURPqSNHjsDV1TXL+6Snp2de79KliywB3Lx5M95++2188MEH2LFjhyz9E72myLk8VcwfoT5uWH34mq2HQmQTZ26a8NepNLzagLNQEhEREZGytYsOw5EriTh7S2/roZCzNjofOnQo3njjDRQtWhQ9evTA/PnzUbNmTaSkpKB///5Z3qdevXqy71S7du3kz4rAlFiIRMM8kS21ZPcldHmqCDcIOZ3ZW5LRobI7Qn2ZJUVEREREyp9FvXmFECzdfQlD25Sz9XDIGYNSJUuWRExMjMyUcnd3x08//YRdu3bBz88PVapUyfI+I0aMwNq1a2Xpnr+/P9q0aYMOHTqgXDnuxAQZjJq47qSMtpco5MVNQk7jZpIZK/an4teBgbYeChERERFRtvSoURRv/3gA77QsA606x8VXRDkPSl29mnUjs7i4OHlZunTpzJ8LC3t4ekgRgBKLmKHvzz//lAGqbt26yWyrtm3bon379ihWrFh2hkIOKMBThxblGW0n5zNvWwrqlnBF6RCtrYdCRERERJQt9UoEwVWjxvrjN9GqYii3GuV/UKpJkyayzCqD6CF1///vX5fR+DwrXl5e6NSpk1xEgOqPP/6QAapvvvkGZcqUkcGpXr16PcnrITv1XM1iGLR4Pwa3KC0PcESOTp9mwYLtKfimp5+th0JERERElG0q1d0WLD/uvsigFBVMUGr9+vXIayJA1blzZ7mIRucTJkzA+PHjGZRyUnWiAuHrrsXvh66xtxQ5hR93pyIySIPaUTpbD4WIiIiIKEeeqVYEX244javxqQjzc+fWo/wNSoWHhyMviayq3bt3y95UopxPNElv1qwZ3n333Tx9HrKvaPtLdSMw9+9/0Llq+EOZeESOxGS2Ys7WZAxr48N9nYiIiIjsjghE1S8ZhGV7LuOtZqVsPRxypkbnZcuW/c+TqEeV75lMJmzbtk2W7InMKxGIatSokWyC3rBhQ+h0zBZwdl2rFcFn605i38U4VCseYOvhEOWbmGNp8rJVRVduZSIiIiKy2xYso1YdxZuNS0DDhudUUEGp+fPnP/B/s9mMixcvYu7cufjf//6X5X1EBtSmTZtkIKpOnTp477330Lx5c3h6euZ23OSAvFw16FajKOb8/Q+DUuTQvt+WjJ51PKBWMSOQiIiIiOxT03IhGPPrMcQcu4E2lQrbejjkLEGpmjVrPrROBJoiIiJkT6hWrVo9dLuYlU8ErMRtAQHMgKFHe6lOBJpN2YRrCako7MvaZHI8x6+l49DldHzzor+th0JERERElGviD6y96hTH99v+YVCKck2FPCKCTefOncvytoULF+L5559nQIoeq1igBxqWLoT52y9wa5FDmr89BR0ru8PfM88Ov0RERERENiFm4Tt0OR7HribyN0AFkym1cuXKh9YlJydj+fLlqFKlSu5GQXSf1xtF4eW5u/HG0yXg46bltiGHEZ9iwYr9qfjpjUBbD4WIiIiI6In5eejkRFXztv2DCc9Ec4tS/gelvvjiiwf+L5qea7VaVKpU6ZE9pYhyokZEAMoV9sGC7RfwZuOS3HjkMJbtSUWlcC0qhDHYSkRERESOQcyi3mnG3/igdVn4e3ICM8rnoNSGDRtyeheiHOvfuASGLD2Il+tFwl2n5hYku2e2WDF/Rwreb+Vl66EQEREREeWZsqE+qFLUDwt3XsCAJqW4ZSlHctXU5OzZs5g4cSL69euHN954A59//jmuXLkCpbFarTKzq27durJB+4cffoi0tLtTsQtHjhxB9+7dUbVqVXTr1g0HDhyw6Xjp/zUqXQihvm74cfdFbhZyCJtOpSEt3YqWFdxsPRQiIiIiojz1eqMSmPv3PzCkm7llKX+DUiJTqmPHjjh8+DAiIyNRtGhR7Ny5E23btsXu3buhJN9++y0WLVqEyZMnY/bs2dixYwemT58ub4uNjUXv3r1RunRp2Q+rTZs26NOnj5wpkGxPlIX2f7okZm0+B6PJYuvhED2xRTtT0aOGO7RqF25NIiIiInIoT5cuhELerli255Kth0KOXr43adIkvPXWW3j11VcfWP/111/j448/zrIRui2YzWbMnTsX77//PurUqSPXDRw4MHN84tLPzw+jR4+GWq1GiRIlsHXrVixevBhDhgyx8ehJaFUxFFP+OIlley/hhVrFuVHIbt1INMtMqVHtvW09FCIiIiKifEkqEBNVTVp3Es/VLAaNmjNNUz4Fpa5du4amTZs+tL5Vq1aYOXMmlOL06dOIi4tDs2bNMtd16NBBLsKlS5dQoUIFGZDKUKZMmRyX8IkSQbHYq4zxK/E1qFyAwc1LY+xvx9ClajjctOwt5Uwy903Ybv+Uzyuf+8nGIBqc147SoYi/WpHvNXKc4yY5N+6bpETcL+kRO8aDiw3c/Ry/93nOz/Q80aZiKCbHnMJvh66iY5XwvHlQJ2R1kO+a2R1/joNSrVu3lqVwY8aMkbPuZVi2bJksgVOKy5cvw9fXF/v27cPUqVNlgKpFixZ49913odPpEBQUhBMnTjxwn+vXr8ufy4mEhASZlWXPO0pKSkpmdFtp6hR1R4C7BrM2nsRLtXhgcybJxmTZA06v18Ossc17zGjWw11nkGMwaXJ8uJQsVisW70rF4CY6+Thk/8Rx02AwKPa4Sc6L+yYpEfdLypJJD7XBAHOaHlDn7jvWk7KaUpFmSIMpMQEuGpNNxuCIetYIxYwNp9EowpPfkxz0HD27snvuk+MjgDhJjImJwebNm1GxYkUZmDp58qTMPKpcuTJ69eqV+bPz589HfhInBTdu3MjytqSkJHm76Cc1dOhQWCwWjBo1Sl6KhuciQPXVV19h6dKl6NKlC7Zv347169cjJCQkR2MQgS8vLy+7j16K16HUHf79NuXxvyUH0KdhKXi7/X8glBybxqiBq6urfH+5a9xtMgaj2QStyk2OwU2Tu/f51jNpMKSnol1VX+g0ynyPUe6Om2K/UOpxk5wT901SIu6XlCWTCUhxA7RegNo251JWkxouZj08fXzhovW0yRgcUc96Xvh22xXsuGyQ7VjIMc/Rs+P+qrQ8DUpFRUXJWffuJ8rebOHgwYMPBMHuN2XKFBmUGjFihJx5T/jggw8wePBgDB8+XDY4HzduHD766CMZrCpXrhyee+452bQ9J8ROYs87yv2vQamvQ8zEVzrUG7O3/iPL+cg5ZO6XsN2+KZ9XPnfux7BktwHPVPOAq5Z19Y5E6cdNcl7cN0mJuF9SFjvFg4st3Pcdj5/necdNp8GAJiUx9c9TaFEhFGrRk4VysXu62P2+md2x5zgoNWDAgMzrsqzGbJYRPFuoVauWzNLKyq5duzKDaBnEbIEi0+vOnTuyfK9r167o1KmTnIkvODgYEydORJEiRQps/JT9nfn9VmXQ87tdeL5mMYT6unHTkV24k2zBH0cNWPu/IFsPhYiIiIioQHSvURTfbDrH3lKULbn60/28efPQoEED1KhRA7Vr10a9evUwffp0KEn58uVlaeH9faPOnj0LT09POevejh078Pbbb8uUMhGQEilyW7ZskYEuUp5qxQPQrFwIJqx9sA8YkZL9vC8VVYtpEVXINr0SiIiIiIgKmqtGjUFNS2Lan6dhMlv4C6C8DUrNmDFDzrL35ptvYuXKlfj555/Rv39/LFy4ELNmzYJSiF4f3bp1kyV6Yka9/fv347PPPsOzzz4LjUYjs6Y2btyIRYsWyX5YonG7aFouMqdImT5oXRbrjl7H3gs5a0ZPZCvL96bi2eoe/AUQERERkVPp8lQRmfjx8/4rth4KOVpQSjQG//jjj9GjRw/ZS0r0YnrhhRdk8Gfx4sVQEtFDqmHDhnjttdfkIrK7hgwZIm8TDc2nTZuGBQsWoH379jh//jzmzp0rM6lImcL83NGvUQmM/fUoLBb7nh6THN/xa+m4EGtG64quth4KEREREVGB0qpVeLt5aUz94xRSjfY7Wz3lvxzXlIg+UhEREQ+tF5lHoleTkuh0OtnUXCxZefrpp+VC9uO1hlH4cfclLN97Gd1qFLX1cIgeacX+VLSs4ApPVzY4JyIiIiLn0z46DHO2nse3W85hUNNSth4OKVSOz5aqVq2KOXPmwGL5/9pQ0excrIuOjs7r8RE9wE2rxqj25fHJmuO4lZTGrUOKZLZYsXK/AV2ecrf1UIiIiIiIbEKlcsHI9uUxc9NZXE8w8LdAeZMpNXToUFmut23bNlSoUEGuO3r0KIxGI2bPnp3ThyPKMTG16MoDVzD2t2P48rmq3IKkOH+fMcrLeiV1th4KEREREZFNJ6xqUjYYk9adxORulfmboCfPlCpRogTWrFmD3r17IzAwEGFhYbJf07p161C2bNmcPhxRrozuUAGbTt7EhhM3uAVJkaV7Hau4Qa1ysfVQiIiIiIhsPmHV74ev4tDleP4m6CG5anbi7++PunXrok6dOqhevbq8zgbhVJCCvd0wrE05jFhxBEmGdG58UozkNAvWHklD56os3SMiIiIiKuLvgdcalsDwFUdgMv9/GyCiXJXv3b59GwMHDsSBAwfg4+Mje0uJ5uf16tXD1KlT4e3tzS1LBaJ7jaL4/fA1jFp1FFO6VeFWJ0UQAanigWqUD9PaeihERERERIrQ/+kS+PXgVczffgEv14+09XDInjOlxEx2Wq0Wf/zxB3bu3Indu3dj7dq1MBgMGD16dP6MkigLLi4u+OzZythw4qY8wBEppXSPDc6JiIiIiB6csOrjThUx5Y9TuBqfyk1DuQ9K7dq1Cx9++CGKFCmSua548eIYMWIENm7cmNOHI3oiIT5u+LRLNIavOIwrPLiRjd1KMmPHOSPaV3az9VCIiIiIiBSlbskgtKwQKitdrFarrYdD9hqUKlq0KE6ePPnQ+qtXr8qm50QFrVXFULSpVBhv/3iANcpkU2uPpqFqMS0K+6r5myAiIiIi+pfhbcth34U4rGKlC+W2p1TXrl0xZswYHD16FFWrVoVGo8Hx48cxf/58dOnSBStXrsz82U6dOuX04YlyZWT78ug0429MXHdSNkAnsoXfDqaibSVmSRERERERZSXAU4dPulTCu8sOomZkAAr7cnIgZ5fjoNS8efNkM/N169bJJYOYfe/+daLfD4NSVFA8dBp807M6OkzfiugivmgXzaw9Klg3Es3YeyEdXz7nx01PRERERPQIooTvj2M38M6yg1jwci2oVC7cVk4sx0GpDRs25M9IiJ5QZJCnnIXvf0v2o3SIt1yICsqawwZUj9Ah2Iele0RERERE/2VU+/JoNW0L5m3/B33qcTY+Z5atnlKff/459Hp9th80MTERU6dOfZJxEeVK8/Ih6Fs/En3n7cZtfRq3IhWY3w4Z0DaapXtERERERI/j7abF1O5VMHHtSRy+nMAN5sSyFZQqXLgwOnbsiNGjR2Pr1q1IT09/6GdSU1Oxbds2DBs2DB06dJD3IbKF/zUrjSpF/dF33h6kGs38JVC+uxpvxoFL6Whd0ZVbm4iIiIgoG0RPqYFNS+KNhXuRkPJwjIGcQ7bK97p164YWLVpg4cKFMuh0584dFClSBP7+/rBYLIiPj8fly5dRqFAhPPPMM1ixYoW8jcgWRE3yZ89Go+d3uzBoyX7MfLEa1KxTpny0+rABtaN0CPJi6R4RERERUXb1a1gCe/+Jw+ClB/Btr+rsL+WEst1Tys/PD2+++Sb69++PkydP4tixYzI4JRqaBwYGonz58ihdunT+jpYom1w1aszqWQ1dv96GESsP45POleS+SpRfpXs9anDmECIiIiKinCYUiL7A7aZvwYyNZzCwaSluQCeT40bn4sS+bNmyciFSMj8PHRb0rYXus7Zj9KqjGN2hAgNTlOcux5lx5Eo6WvZmdigRERERUU75emjxzYvV0e2b7Ygq5IW20WwF5EyyFZQaOnRoth9w/PjxTzIeojwV5ueORa/URvdvtkOnUWFYm3IMTFGeijl6t3TP3zNbLfqIiIiIiOhfyof54IvnqmDAov0I83ND1WL8g6+zyPFZlGhoLnpGnTlzBu7u7vDx8ZH9pFatWgWViidlpDxFAzyw+LXaWHXwKsb+dgwWi9XWQyIHsu6oAS0rcNY9IiIiIqIn0aRsCN5tWQavzt+DS3dSuDGdhCan2U//+9//MGDAALncb/bs2di+fXvej5AoDxQP9MSy1+ui55ydiE9Jx8RnoqFVM4hKTyZWb8GeC+n4vIcfNyURERER0RPqXTcCF2JT8OJ3O7Hs9ToI9uEffx1djs/K//rrL7Rr1+6h9U2bNsWePXvyalxEea5YoAeW9auDE9eT8PqCvUgxmriV6YmsP2FAxXAtQn056x4RERER0ZMSPaxHtiuPGhEBeGH2TtxJNnKjOrgcB6UiIyPx008/PbDOarVi4cKFKFOmTF6OjSjPBXu7YclrtWVA6pmvt+NKfCq3MuVazNE0tKzgyi1IRERERJSHM/J92qUSSoV4odecnUhISee2dWA5DkoNHz4cixcvRsuWLTFo0CC5NGvWDGvWrMGYMWPyZ5REecjXXYv5L9dClWJ+6Dh9K/b8c4fbl3IsOc2CzafT0KI8U4qJiIiIiPKSRq3CtO5VEerjhh7f7sBtfRo3sIPKcVCqevXqiImJQa9evRAUFCSXV155RQalypUrlz+jJMpjYia+TzpXwltNS6Hnd7vw/d/nZcYfUXZtPmVEUX81SgZnqzUfERERERHl8Jzt6xeroWSwF7p9sx1XWeXikHJ1NhUQEIAXXngh70dDVMB61olA2cI+GLR4P7aeicWkZ6Lh76nj74Eei7PuERERERHlLzE51bTuVTBi5WE8O3M75r1cAyWDvbnZnS0oNXTo0Gw/4P0z9RHZA9FEb81bDfDe8kNo/fkWTHo2Gg1KFbL1sEjBjCYr1p9Iw4K+/rYeChERERGRQ1OrXGSVy5Q/TqHzV9sw4/mn0LA0z9ectnyPyBH5eejwTc9qGNCkJN74YR/eW36QDfXokXaeN8JT54LocC23EhERERFRAczKN6RFGYztWEHOpD5/+z/c5s6UKcXsJ3KWA92LtYujcdlgDF9xGM2mbsKo9uXRtlJheRvR/aV7LSq4yZlBiIiIiIioYHSuWgRF/T1kYOrgpQSM61QBHjr2eLVn2frtXb16NdsPGBYW9iTjIbK5cD93zO1dA78cuIoxvx7D/G0X8GG78qhUxNfWQyMFsFisiDmahinduD8QERERERW06hEB+H1QAwxash8dpv+Nr154CqVD2GfKoYNSTZo0eWymiJi5TPzM8ePH82psRDYj9uVOVcPRrHwIZv51Fs9+sw1tKhXG281Ko2iAB38zTuzg5XSkmayoFcWG+EREREREthDq64ZFr9TC5+tPo9OMv/FeyzLoVSeClQyOGpRav3497M3OnTvRq1evLG/buHGjzOi6dOkSPvzwQxw4cED+f9iwYahfv36Bj5WUy8tVg3dalkGPmkUxOeYUmk7ZhE5VwjCgcSkUC2RwyhnFHEtDk7Ku0KpZukdEREREZCsatUr2mapTIlBOWrX6yHVM7BqNiCBP/lIcLSgVHh4Oe1O1alVs3br1gXX/+9//4OfnJwNQIrPrzTffROnSpfHTTz/hzz//xIABA7B69WqWINJDivh7YGr3KhjYpCSmbzwj+021q1QYfepFsqzPyfxxzIDBzZkeTERERESkBHVLBGHd/xpi4toTaPPFFgxqWgp96kXAVaO29dAor4JSZcuWzXajZ6WU7+l0OhQq9P/TRP722284deoU1q1bJ/+/Y8cOmSm1ZMkSeHh4oESJEti+fbsMUA0cONCGIycliyrkhSndRHCqFOZsPY/us7ajfGEf9K4XgZYVQqFVc0JLR3b+tgkXY81oWJqle0RERERESuHpqsGYjhVly5VRq45iya6Lsi9wk7LBnLTKEYJS8+fPhz1LT0/HtGnT0K9fPwQEBMh1Bw8eRPny5WVAKkO1atVkKR/R40QGeWJcp4qytG/ZnkuYsPYERq86io5VwtHlqXBUCGMTbEf0x7E01C2pg5crg49EREREREpTKyoQvw2sj8W7LmLIsoOoFO6Ld1qUQeWifrYeGj1JUKpmzZoPrdPr9bh48SJKliwJo9EILy8vKNWaNWuQlJSEF154IXPdrVu3EBwc/MDPBQYG4vr16zl6bFEGKBZ7lTF+e34NtuTjpkHf+pHoUzcC28/F4qd9V/DM19tRPNADHSqHoUWFEJQopNz3hl3sm7Dd/imfVz733THEHDOgcxU3vl+cHI+bpFTcN0mJuF/SI3aMBxcbuPv98t73TJ4LORS1ygUv1i6OdtGF8fWmc+gxawfqlgzE281K2UXygNVBztGzO/5sBaXuJwJQY8eOxc8//yz/L8rhJkyYgNTUVEyZMgW+vgX3SzYYDLhx40aWt4nSvYwsqKVLl+KZZ56Bm5tb5u1ivKLE737i/+L15URCQgLMZjPseUdJSUmR17NboklZq1hIi4otI/DO00Ww/tQd/HHiJqb+eQpF/dzQuHQgni4VgPKhXvIgSY+XbExGWlqaDICbNbZ5jxnNerjrDHIMN9PU2H8hHRM6aOT/yXmJ46b4/BF43CQl4b5JSsT9krJk0kNtMMCcpgfUOT4lzRNWUyrSDGkwJSbARWOyyRgof4mzrv51C6NbdCDm7rgskweqFfPFizXCUDvCV7Hf46wOco6e3XOmHB8BJk6ciDNnzmDFihXo0aOHXCd6MA0dOhQfffQRJk2ahIIiSvAeNcPejBkz0KxZM8TGxmLPnj1ylr37ubq6Ij4+/oF1IiB1f+AqO0QQTslZYtmNXorXYc87vJKIsGzP4ED0rF8K+jQTNp26hZij19F/6TF5YKxbIhD1SgbJJSLQg9v9ETRGjXyfiveXu8YdtmA0m6BVuckxbDyjQcVwDaIK+9hkLKS846bYL3jcJAPfAdUAAG8LSURBVCXhvklKxP2SsmQyASlugNYLUNvmXMpqUsPFrIenjy9ctJytzZGJvJmPuhbCWy3SMH/7BQz79RSCvV3Ru14k2kcXlv2olMTqIOfoanX2Gs3neOvHxMTIgE+ZMmUy14nr48aNw8svv4yCVKtWLZw8efI/f2bLli0oUqTIA+MVQkJCZHDtfrdv336opO9xxE5izzvK/a/B3l+HEnm7adEuOkwuZosVh68k4O8zt7HmyHWM++04fD20eKqYH6oW80fVon6ILuIHdx1niXhgv4Tt9k35vPK5XRBzLA0tKrjxfUIP7p88bpLCcN8kJeJ+SVnsFA8utnDvOx4/z51HsI+b7Ak8oElJrNh/BfO2/YNxvx1D20qF0a1GUVQv7q+Y73YuDvBdM7tjz3FQKjk5Ge7uD2ctWCwWRZaxHTp0CE899dRD6ytXroxZs2bJEoyM7Ki9e/fKZudE+UGU7VUp6ieXNxuXRKrRLINU+y/GYd/FOHy39TzuJBtRKtgLZUO9Ubawz93LUB+E+Lja9QHJ3qUardh6Jg3vtbLfrEgiIiIiIgLctGo8V7MYetQoiiNXErFs7yW8Mm8P/Dy0aF2xMFpXDEV0EfvOUrInOQ5KNWnSBFOnTpV9pDJcunRJlu41atQISnP69Gk0aNAgy+bthQsXlmWH/fv3x8aNG2UAa/z48TYZJzkfkRFVMzJALhlpmlfiU3H0aiJOXk/CocvxWLr7Es7HJsPXXStn/IsI9JRN1MX14oHi/x7w83iwNxrlvS2nLQj1UaNUsLJSe4mIiIiIKHdE0KlSEV+5DGtTDn+dvIV1R6/jxe92wttVgxYVQvF0mUKoFRnIapZ8lOMzrJEjR2LYsGEyqCOyo7p27Spntqtfv/5DfZuUQJTk+fj4ZFnf+NVXX2H48OHo0qULihcvLssSw8LCbDJOInFQLOLvIZeWFUIzN4jIqDp9Mwn/xKbgn9vJ+Cc2GVtO38aF2GTc1hvh5aqRmVSFfd0R6uuGwr5umZeFvNzg76lFoKcrD6RPYM0RM9pFu/OvJUREREREDpo91apiqFyMJgv+PnsbMUdvYPiKI7iVlIbqEf6oXyoIdaIC5Qx+Oo3K1kN23qCUt7c3vvzyS5kddfbsWZhMJkRGRqJEiRJQojVr1jzyNhGI+uGHHwp0PES5yagSvabE8m9JhnRcSzDI5XpC6r1LAw5dTpCXt/RpiEsxyllu3bVqBHjqMpdAT53saSX6Xom/BHi7iUULL3mpubdO3K6R91U56ayBqUYV/jppwdvNcjYJAhERERER2R8RcGpcJlguoppFJAdsPX1LJgbM2nxOJg1UCvfFU8X9ZX9gcZ4mEgJY7lcAQakLFy7ITCKtVouiRYvKZfv27bl8aiJ6UneDRlqUDvF+5M+IBusJqem4k5yGWL1RBqlik424ozciPjUdNxIMOJOWjiSD6d6SLmcNFNdTjOYHDs4iOOWmzbjMWFTy8v/XqaBTq6BVq6BRi+su8lL8X6t2uXcpbnORPycu77/NVXP3sawuaUhOs/0+sue8L8L9XFAmVGvroRARERERUQESgSbROkUsPetEyCDVudvJ2HdB9AWOx7Q/T+PUjSRZvSJ6Ape71xu4TKg3IgM9ZZ8qBqvyICglNvzHH3+MRYsW4fvvv5elexkWLFgg+zG99NJLeP/997nBiRTYYD0jO6pkziaXhMlsQXKaGSnpJhjSLfKvAgaTGYaMy/vWics0093/p5stSDdbkZxmQoLFAqPJKteZ7l0Xlxk/I9ffuzSaLUhLt8CQfvc5001uGNAiHQ1KPzy5QkFZeygI3WpwRkQiIiIiImcnAkwlCnnJ5dnqReU6ce5y5qYex68l4sT1JPx26Comx+hxW58GHzfNA/2AiwV6ZrZbCfVxg6cre9ZmawvMnz8fq1evlj2X7g9ICaIv04YNG2TD8GLFiuH555/Pn98+ERU4keHk66GCLwo+SyjZmIyJMeswc72LPIAXDSz4A/ae82ZciXND56oMShERERER0cNEtUjFcF+53E9UoFyITZGL6AssegLvPH8H1xPvtlwRf9D3dtPI4JQIUgV7uyHI624yQYMIT/j6Pvh4jipbZ3lLly6VTcwbN278yBn53nnnHRm8YlCKiPJKpSIW3ErSYfqfCfjk2QCZ9VVQUtIsmLspHS/VvwJvtzIF9rxERERERGT/RJuVrIJVGdVo8SnpdwNU94JUNxINuJNslP2Bo/w0KFcMTiFbQakrV64gOjr6P3+mdu3assSPiCgvPVPTDSOWJ2PVvmR0ru5VYBt30XY9Qv1UeLrcnQJ7TiIiIiIicnyiDNDfUyeXcoV9HgpYJSQkwFlkax7DwMBAGZj6L9evX4ef38OzgxERPQmdxgUDm/li6S49LsamF8jGPHQpDRuPp+KVpzVwcc5JB4mIiIiIiJQRlGrevDm+/PJLpKdnfUJoMpkwffp01K9fP6/HR0SE0oV1aFPZE1/EJMjm6PkpMdWCL2MS8FIDbxT2y9YhkoiIiIiIiHIhW2dc/fv3x40bN9ClSxfZX+rYsWO4dOkSjhw5gh9//BGdO3eW/x84cGBuxkBE9Fg9annBYgWW7tTn29YSqbJfrU9AqVAtmlew3Yx/REREREREziBbPaV8fHxkMOqzzz7Dp59+itTU1MwTOG9vb7Rp00YGpIKCgvJ7vETkpLQaF7zVwhdDl95BtUhXlC2sy/PnWL47Gf/cSsekHkGyzpuIiIiIiIjyT7bnWBf9oj766COMHDlSZkUlJibKdcWKFYNazenSiSj/FQ/S4rk6XpiyJh4TugfC3zPvjj3bzxjwy95kfPRsALzdWbZHRERERESkmKBUBp1OhxIlSuTPaIiIHqNdFQ+cvZmOSavjMaZzgMygelJHLxsx/Y8EDGrhi4ggLX8HREREREREBYDpAERkV0RZ3RtNfWEyW/HlHwkwi0ZTT+DkNSPG/xqHlxt6o1YJtzwbJxEREREREf03BqWIyO64alwwvIM/LsSaZIZTbgNTu88ZMHZlHF6s542mFTzyfJxERERERET0aAxKEZFd8vVQY0wXf/xz24Rxv8QhKdWS7fuKINayXXpMW5eAAc190SqaASkiIiIiIiJF9pS6evVqth8wLCzsScZDRJRtfh5qfPJsgCzjG7zoNl552gc1o1z/c+a8U9eMmLM5CSlGC8Z1DUBUMHtIERERERERKTYo1aRJk8dOj261WuXPHD9+PK/GRkT0WO46Fd5t44e/Thgwc30Clu9Sy1K86KI6FPJWAy5AbJIZx64asfmEAadvpKNdVQ90qeYFV+2TN0knIiIiIiKifAxKrV+/PpcPT0SU/0RAvHE5d9Qp6Yq/jhuw7bQBczcnwnSvok+jgsyIEo3M327lK0v/iIiIiIiIyA6CUuHh4fk/EiKiJ+SmVcn+UGIRfaMS7/WZ8nJTQatmVhQREREREZHdBaXKli372PK9DCzfIyIlUKtc4O/JjCgiIiIiIiK7DkrNnz8//0dCREREREREREROI1tBqZo1az60Tq/X4+LFiyhZsiSMRiO8vLzyY3xEREREREREROSAVDm9gwhAjRgxQgaqnnnmGdy4cQMffPAB+vbti4SEhPwZJREREREREREROXdQauLEiThz5gxWrFgBV1dXuW7gwIGIi4vDRx99lB9jJCIiIiIiIiIiZw9KxcTEYPjw4ShTpkzmOnF93Lhx2Lx5c16Pj4iIiIiIiIiIHFCOg1LJyclwd3d/aL3FYoHZbM6rcRERERERERERkQPLcVCqSZMmmDp1qmx0nuHSpUuydK9Ro0Z5PT4iIiIiIiIiInJAOQ5KjRw5EiqVSjY6T01NRdeuXdGiRQv4+Pjgww8/zJ9REhERERERERGRQ9Hk9A7e3t748ssvZXbU2bNnYTKZEBkZiRIlSsCZWK1WeXl/xpi9vg7xGtRqNVxcXGw9HKJMycZkGFIMiFfHw6Ax2GTLpJsT4aEzQq9PhFl79z1PdPe4mSz2EB43SVG4b5IScb+kLJkSxZc9QJUIqG3zHctqMkCfYhAndHDh9zxSEKuDnKNnxEoyYieP4mJ93E/c58KFCwgLC4NWq81ct337dgQHBztdUOr69essVyQiIiIiIiIieoRNmzYhNDT0yYJS4kc+/vhjLFq0CN9//70s3cvQv39/bNy4ES+99BLef/99u47k5YRo7H7z5k14eno6zWsmIiIiIiIiIspOHElMlCeSmEQLqCcKSs2bNw/ffPONDEw1btz4ods3bNiAoUOH4q233sLzzz//2MEREREREREREZFzy1ZQqm3bthgwYABat279yJ9ZtmwZ5s+fj19//TWvx0hERERERERERM44+96VK1cQHR39nz9Tu3Zt2fyciIiIiIiIiIgoT4JSgYGBMjD1uMbffn5+2Xk4IiIiIiIiIiJyctkKSjVv3hxffvkl0tPTs7zdZDJh+vTpqF+/fl6Pj4iIiIiIiIiInLWnVGJiIp555hm4urqiZ8+eqFixIry9vZGQkICjR4/ihx9+kF3VFy9ejJCQkIIZOREREREREREROXZQSoiPj8dnn32G1atXIzU1Va4TdxXBqTZt2mDgwIEICgrK7/ESEREREREREZEzBaUyGI1G2dBcZEmpVCoULVpU9pwiIiIiIiIiIiLKLk22fxLAtWvXsGTJEmzZsgUnT56ExWKR69VqNcqXL4+GDRuiS5cuCAsLy8nDEhERERERERGRk8lWptSdO3cwadIkbNiwAXXr1pVLyZIl5Wx7IjAVFxcng1T79u3D5s2b0bhxY7z//vvMoCIiIiIiIiIiotwHpUT2k2hw3q5dO2i12v/8WdFvatWqVbLp+cqVKx/30ERERERERERE5ISyFZRKT09/bDAqL+5DRERERERERETOIUeNzi9evIikpCSUKVMGGo3moSDUgQMHUKNGDTgDUbZ48+ZNeHp6wsXFxdbDISIiIiIiIiJSBBFqSk5ORnBwsJwk74mCUjdu3MCAAQNw+PBh+f+AgAAMGTIEXbt2zfyZ27dvo0GDBjh+/DicwfXr19GoUSNbD4OIiIiIiIiISJE2bdqE0NDQJ5t9b9y4cbJpuZh1T8Sw5s+fj5EjR+LMmTOyoXmGHCRd2T2RIZWxgb28vGCvxO8sISEBvr6+zPgiRUk2JuOPE3/Az9sPbho3m4wh3ZwID90BlC9UFe5ab5uMgZR53NTrk+HlxUxZUhbum6RE3C8pS6ZE4NYBQFUVUNvmO5bVZIBeHw+v4s3hor17bkekBFYHOUfX6/UykScjdvJEQaldu3bJxuWFChWS/3/nnXdQpUoVvP322zCZTBg+fLhcb88bLKcyXqsISNl7UMpsNsvX4Ey/P1I+F6ML3Dzc4OfjB3etu03GYDS7QKPSwcvLB+5aP5uMgZTn7h9gtDxukuJw3yQl4n5JWTK5ACk6QOsDqG3zHctqSgUshruf5wxKkYJYHewc/XGv4dGFffdxd3dHXFzcA+uaNWuGqVOnymDVhAkTnmyURERERERERETkVLIVlGrTpo3Mhlq7di0SExMfCEyJgNSCBQvw3nvv5ec4iYiIiIiIiIjI2YJSokyvefPm+Oijj3D06NEHbmvbti2+/fZbnD9/HkojGrQPGjQINWvWlE3Yx48fj7S0NHnbpUuX0Lt3b1mGKIJuW7dutfVwiYiIiIiIiIicRraCUjqdTvaREoGbOnXqPHS7WPfnn39iyZIlUFIdpghIpaamYuHChbLUcOPGjZg2bZq87c0330RQUBB++ukndOzYUc4uePXqVVsPm4iIiIiIiIjIKWQrKHW/6dOny0CPMGvWrMxyPrVajcqVK0Mpzp07hwMHDsjsqFKlSqF69eoySPXbb79hx44dMlNq7NixKFGiBF5//XWZMSUCVEREREREREREpMCg1IwZM5CSkiKvz5w5U05VqERipsDZs2fLbKh/T0t48OBBlC9fHh4eHpnrq1WrJoNYRERERERERESU/zS5m9b14etK4+PjI/tIZbBYLPjhhx9Qu3Zt3Lp1C8HBwQ/8fGBgIK5fv57j5xHbQMnbIbvjt+fXQI4pc9+E7fZP+bzyufkeoSz2TR43SWG4b5IScb+kR+wYDy42cPdz/N7nOT/TSUGsDvJdM7vjz3FQyl5NmjQJx44dw/Lly/H999/LPln3E/83Go05flyRKWY2m2HPO0pG5puLi4uth0OUKdmYLCcmENmNZo1t3mNGsx7uOoMcg0njNIdLysZx02AwyOs8bpKScN8kJeJ+SVky6aE2GGBO0wNq23zHsppSkWZIgykxAS4ak03GQOTI5+jiHCo7NM4SkJo3b55sdl66dGm4uroiPj7+gZ8RASk3N7ccP7avry+8vLxg79FL8Tr+OH4Ty/Zcwre9qtt6WETQGDXyvSreX+4ad5tsEaPZBK3KTY7BTWO/73PKn+Om2C/s+YsCOR7um6RE3C8pSyYTkOIGaL0AtW2+Y1lNariY9fD08YWL1tMmYyB63Dm6PX/XFH3H8yUodf9GsYcNNG7cOCxevFgGplq2bCnXhYSE4MyZMw/83O3btx8q6csOsQ3sYTtk5zV8u/kc9lyIs/vXQ44hY7+U/2y0T8rnlc9t/+9zyqf9k/sFKQz3TVIi7peUxU7x4GIL933H4+c5KY2LA3zXzO7YVY7aUypjpsAlS5ZgypQpaNu2beZ6MUvg0aNHM8svhL179ypq9kBbUKnsd4cnIiIiIiIiIvuS40ypEydOZF7fv38/lOrs2bP46quv8Nprr8mZ9URz8ww1a9ZE4cKFMXToUPTv3x8bN27EoUOHMH78eDgzV02OY5RERERERERERPkXlNq9e3e2H7BGjRpQgvXr18sG5F9//bVc7nfy5EkZsBo+fDi6dOmC4sWLY8aMGQgLC4Mz06oZlCIiIiIiIiIiBQWlevbs+VBtoCjdc3d3h1arRWJiomxi5ePjg+3bt0MJRIaUWB5FBKJ++OGHAh2T0ukYlCIiIiIiIiIiJQWl7i/ZW758uVw+/vhjlChRQq67fPkyRowYgfr16+ffSCnfadTsKUVEREREREREBSPH9VqTJ0/G6NGjMwNSQpEiRTBs2DDMmjUrr8dHBUjDRudEREREREREpNSglCjdu3HjxkPr//nnH7i6uubVuMgGOPseERERERERESl29r3nn38e7733Hvr06YOyZcvK3lKHDx/G/PnzMXDgwPwZJRUIZkoRERERERERkWKDUgMGDEChQoWwbNkyfPPNN3JdqVKlMHLkSHTo0CE/xkgFRH2vfE8EGkVGHBERERERERGRYoJSQvfu3eVCjkV1LxBlslihZdNzIiIiIiIiIrJ1UGr69Ono27cv3N3d5fXHZVKRfZfvmcwiKGXr0RARERERERERnD0otXPnTvTq1UsGpcT1R2HJl31Tq+72vU+3WOAORqWIiIiIiIiIyMZBqQULFmR5nRyL+t5cjCJTioiIiIiIiIgoP90LQxD9f6aUyWzh5iAiIiIiIiKifMWgFP3/znBvwr10CzOliIiIiIiIiCh/MShFmTJCUcyUIiIiIiIiIqL8xqAUZbJY74al0tlTioiIiIiIiIiU0Og8O9LT03HgwAG4urqiXLly0Gq1efXQVMCpUmaW7xERERERERGRvWRKJSQkoGfPnti0aRN69+4Ns9mcVw9NBZ4pxUbnRERERERERGQnmVIBAQFYv349wsPD0adPH6jV6rx6aCog92JSMDFTioiIiIiIiIjsJVNKpVLJgJTg5eWVVw9LBYiNzomIiIiIiIhIUZlSZcuWhYuLC4KCghAVFYV58+bl/8iowLHROREREREREREpKij1ySefyEwoUaIXGRmZ/6MiG5fvsacUERERERERESkgKNWlS5f/vP3GjRv45ZdfsHLlSqxevTqvxkY2YjJnFPIRERERERERESms0XlaWhpiYmJkIGrHjh2yvK9JkyZ5OzqySfkeG50TERERERERkeKCUnv27MGKFSuwbt066PV6GYzq3bu3nHEvODg4f0ZJBVu+Z2b5HhEREREREREpICh16dIlWZ4nglFXrlxBiRIl8OKLL6J58+bo1q0bunbtyoCUA7Dem38v3cLyPSIiIiIiIiJSQFBKBJ+KFy+Onj17onHjxvI6OZ6MWBQzpYiIiIiIiIgov6my80OdOnVCbGwsZs2ahcmTJ8s+UgkJCfk+OLJV+R4zpYiIiIiIiIhIAZlSn376KYxGI/766y/8/vvvGD16NEaMGIGqVavCarXK3lLkCDLK99hTioiIiIiIiIgU0uhcp9OhRYsWcklJScEff/yB1atXQ6VSyf5S9evXx7PPPoumTZvm74gp32TEopgpRURERERERESKm31P8PDwQMeOHeUSHx8vZ+L77bffMGjQIBw9ejTvR0kF2ujcxEbnRERERERERKTEoFQG0VfKx8dHzsDXvXt33Lx5M+9GRgWOjc6JiIiIiIiISFGNzu8nekh9/fXXqFWrFurUqYMrV67g3XffxciRI+Hn55c/o6SCbXTOTCkiIiIiIiIiUlpQasaMGVi1apVsfi76TAmdO3fG33//jYkTJ+bHGKmAy/fSzWx0TkREREREREQKC0qtWLECY8eORePGjeHi4iLX1atXDxMmTMCaNWtgT9LS0jBs2DBUr15dNmqfM2cOnFlmppT53hUiIiIiIiIiIqX0lIqNjUVwcPBD60VvKTErnz0RmV1HjhzBvHnzcPXqVbz//vsICwtDq1at4IxEaaaQnjENHxERERERERGRUjKlateuje++++6BdXq9HlOmTJF9puyFCKAtW7YMw4cPR4UKFdC8eXO88sorWLhwIZxVRn4UM6WIiIiIiIiISHGZUqNHj8aAAQNkyZ4of+vfv7/MMhIZRqIBur04ceIETCYTqlatmrmuWrVqmDlzJiwWC1QqVbazizIyjOxRxvjFYrnX4Nxkttj1ayLHkLlvin822h/l88rntu/3OeXfcZNISbhvkhJxv6RH7BgPLjZw93P83uc5P9NJQawO8l0zu+PPcVAqNDQUy5cvx/bt23Hu3DkZ2ImMjJQ9mbIbyFGCW7duwd/fP7NZuxAUFCQDbfHx8QgICMjW4yQkJMBsNsOed5SMsktjejo0KhekGNLk6yKypWRjsnw/ikxMs8Y27zGjWQ93nUGOwaTJ8eGSHJQ4bhoMBnk9o7cikRJw3yQl4n5JWTLpoTYYYE7TA2rbfMeymlKRZkiDKTEBLhqTTcZA9LhzdHv+rinOobIj10eAOnXqyMVepaamPhCQEjL+bzQas/04vr6+8PLygr1HL8Xr0Gi00GlUcFFr5P+JbElj1MDV1VW+v9w17jYZg9FsglblJsfgprHf9znlz3FT7Bf2/EWBHA/3TVIi7peUJZMJSHEDtF6A2jbfsawmNVzMenj6+MJF62mTMRA97hzdnr9rqtXqvAtKlS1bNtsb4/jx47AH4mT338GnjP+7ubll+3HEdrHnHeX+1yDKpERQymSx2v1rIvuXsV/KfzbaH+Xzyue2//c55dP+yf2CFIb7JikR90vKYqd4cLGF+77j8fOclMbFAb5rZnfs2QpKzZ8/P/P64cOHMXfuXNlLqlKlStBqtTh27BimT5+OXr16wV6EhIQgLi5Olh9q7pXliJI+EZASMwk6IxGQ1apVbHRORERERERERPkuW0GpmjVrZl4fOXIkJkyYIBud359JFR4ejqFDh6J3796wB+XKlZPBqAMHDqB69epy3d69e2WgzZ56Y+V1UEonglIWi62HQkREREREREQOLsfRl5s3byIwMPCh9e7u7khMTIS9EOPt1KmTnE3w0KFD+PPPPzFnzhy7yvbKaxbr3fK9dLN9d/knIiIiIiIiIgcMSj399NMYNmwY9u3bJzvCJycnY8eOHXJd69atYU9EZleFChXw0ksvYcyYMRg4cCBatGgBZyVCUVq1C0xmZkoRERERERERUf7K8ex7Y8eOxahRo9CzZ09Y7pV5ia7qIutoxIgRsCciW0qUIoqF7nb5lz2lLMyUIiIiIiIiIiKFBaXEFNiTJ0+WmUXnz5+X6yIjI+V6sm9sdE5EREREREREig1KZfSVWrhwIc6ePQuz2YyoqCg8++yziIiIyPsRUoER+VFsdE5EREREREREiuwptWfPHrRs2RI7d+5EkSJF5LJ792507NhRzl5H9ouNzomIiIiIiIhIsZlSn376KV588UUMGTLkgfWfffYZJk2ahCVLluTl+KjAy/dcYLrXK4yIiIiIiIiISDGZUqdPn0bXrl0fWv/MM8/g+PHjeTUustnseyqYzGx0TkREREREREQKC0qFh4fj0KFDD60/ePAggoKC8mpcZKvZ9zQqpJuZKUVERERERERECivfe+WVVzBq1CicO3cO0dHRmQGpBQsWYPDgwfkxRirA8j3R6NxsYaYUERERERERESksKNWlSxd5+cMPP2Du3LlwdXVFZGQkPv74Y7Ru3To/xkgFxAqr7CmVzvI9IiIiIiIiIlJaUCojMJURnCLHIfqb6zQqNjonIiIiIiIiImUEpVauXJntB+zUqdOTjIdsninFRudEREREREREpJCg1BdffPGftycnJyMxMVFeZ1DKflnu9ZRio3MiIiIiIiIiUkRQasOGDVmut1gsWLRoET7//HMUK1YMI0eOzOvxUUGyZpTvsdE5ERERERERESmwp5Rw+PBhjB49GmfPnsWrr74qF51Ol7ejowLF8j0iIiIiIiIiUmxQSq/XY/Lkyfjxxx9Rt25drFq1SmZJkf0TCVKyp5ToeE5EREREREREpJSg1C+//IKJEydCo9FgypQpaNWqVf6NjAqc1SoanbvI4JTFYoVK5cLfAhERERERERHZLiglSvREqd7+/fvRs2dPDBw4EB4eHvkzIrIZ0UlK9JQS0i0WuKrU/G0QERERERERke2CUh07doTJZEJISAiOHj2Kfv36PfJn58+fn5fjIxvMvieYzFa45rrjGBERERERERHRf8tW2OH111+HiwtLuRyeLN/7/6AUEREREREREZFNg1KiXI8cnwhDae8r3yMiIiIiIiIismlQqkmTJlCpVAgKCkJUVBQ++eSTfBsQ2Y7FaoVOfTcjjplSRERERERERGTzoFTnzp1l+V5gYCAiIiLydUBkO1YroHJxgZh0z8RMKSIiIiIiIiJSUvne1atXYbVaZZDq+vXrCA4OlllU5DhBKY1KxUwpIiIiIiIiIspXOY4mNW3aFHfu3JHX27RpgytXruTHuMhG5Xuin71G7cJMKSIiIiIiIiJSVlBKZElldZ0cg8iUEjPwGU383RIRERERERFR/mHdHT2QKQUXQKdRId3M2feIiIiIiIiIKP8wKEWZ7sWkoBOZUgxKEREREREREZGSglKiwTk5Juu98j2ZKWViphQRERERERERKbSnFDlmo3Ot2gVpzJQiIiIiIiIiIiUFpcaPHw9vb295fezYsQgMDMyPcZEtyPI9ZkoRERERERERkQKDUp07d4ZOp4Ner0eJEiWg0WjkdXKU8j2RKcWeUkRERERERESUvzQ5vYPRaJQZUj///LP8/7p16zBhwgSkpqZiypQp8PX1/c/7b9u2DVu2bMHRo0dx584d2aOqUKFCKF++PBo2bIiaNWsiryQmJsqxbdy4ERaLBU8//TSGDRsGHx8feXtcXBxGjhyJrVu3wt/fH2+99RY6duwIZ599TwSlOPseERERERERESkqU2rixIk4c+YMVqxYAVdXV7lu4MCBMsDz0UcfPfJ+4udbtmyJ9957D7dv30a9evXQs2dPPP/886hevTouXbqEd955B61atcJPP/2EvDBq1CicOHECs2bNwnfffYezZ89ixIgRmbcPHToUSUlJ+PHHH/HGG2/I2w4dOgRndTcm5QJX2eicvcOIiIiIiIiISEGZUjExMZgxYwbKlCmTuU5cHzduHF5++eUs7yOCT0WKFMGkSZMQHR39n4+/a9cuGSQSmVgLFy5EbqWkpMgsrsWLF6NixYpynciSeuGFF5CWloYbN27IDKr169fLsZUuXRoHDhzAokWLHjtGR2WFNbN8j43OiYiIiIiIiEhRQank5GS4u7s/tF6Ux5nN5izvM2bMGERFRWXr8UX5nlhEVtOTUKlUmDlzJsqVK/fAejFG8RoOHjyIwoULy4BUhmrVquGbb76Bs7JYIMspdaJ8z2Sx9XCIiIiIiIiIyIHlOCjVpEkTTJ06VfZqyiBK70TpXqNGjbK8j8hI8vT0REhISLafRzRRfxJubm6yR9X95s+fL7O6AgICcOvWLQQHBz9wu5hJUGRQ5YTVapWLvcoYv1xkq3MrtGoXpJnMdv26yP7dv1/aal+Uzyuf277f55R/x00iJeG+SUrE/ZIesWM8uNjA3c/xe5/n/EwnBbE6yHfN7I4/x0Ep0RhclMGJbCaRHdW1a1fZl6l+/fr48MMPs7zP0qVLMXnyZJmJ1L59e9lb6nEN0bPDYDA8Mogkmqd7eHhk/v+HH37AmjVrMHv2bPl/0ZhdzCJ4P/F/0cg9JxISEh6ZIWYvO4oodRTE7zMlORmwmKFPTpWvjchWko3JstRWzO5p1tjmPWY06+GuM8gxmDQ5PlySgxLHTfH5I4jsUiKl4L5JSsT9krJk0kNtMMCcpgfUtvmOZTWlIs2QBlNiAlw0JpuMgehx5+j2/F1TnENlR46PAN7e3vjyyy9ldpQosTOZTIiMjPzPzCbR2+nYsWNYu3atDAqJ/lMiiCUCVE2bNs1smJ5TogSvV69eWd4m+l41a9ZMXhe9qUQml2hsLp5XEM/57wCU+L/IsMoJEVzz8vKCvUcv7wYJVfD28oKnezxcNLo8CRwS5ZbGqJHvU/H+ctc8XDJcEIxmE7QqNzkGN439vs8pf46bYr+w5y8K5Hi4b5IScb+kLJlMQIoboPUC1Lb5jmU1qeFi1sPTxxcuWk+bjIHocefo9vxdU61WZ+vnchWWFjPt3blzR5bkCeK6WIQaNWpkeZ/y5cvLZfDgwThy5IgMUE2ZMkXOeCcCU+3atZMBo+wOXKhVqxZOnjz5nz8jZt0TMwaKWf9eeumlzPWilFDMAng/8X+RYZUTYiex5x3l/tcgG52r7s2+Z7HY/esiOMR+Kf/ZaF+Uzyuf2/7f55RP+yf3C1IY7pukRNwvKYud4sHFFu77jsfPc1IaFwf4rpndsec4KLVgwQLZT0pkSGX1pMePH3/sY4jZ8MTyzjvv4PDhw/jzzz/lY4pMpm3btiGvrFixQgakxOP27t37gduqVKmCK1eu4Pr16wgNDZXr9u7dK9c7K4v17u9QzL5nZKNzIiIiIiIiIspHOQ5KffXVV+jfvz/69u2b67K7DCK76sSJE3K5du0aypYti7wSHx+PsWPHonPnzmjbtq1sbJ5BNDovWrSozMx69913MXz4cBkc++2332TvKWclsgRFLFOnUSHRkG7r4RARERERERGRA8txUEqlUqFVq1a5DkiJxuQxMTFy2bdvH0qVKoU2bdpg1KhRCAsLQ175+++/ZXMwkS0llvutX78eRYoUkVlUIiDVrVs3Wbb3ySefIDo6Gs7LChUzpYiIiIiIiIhIiUEpkSU1adIk2QsqPDw8W/e5ePFiZiBK9JMS9xPZSyIQVbJkSeQH8fhi+S+BgYGYOXNmvjy//Zbv3c2USjfb9/STRERERERERORgQamIiAhMmzYtc2a7f8uqp1SLFi1kJpLIsBLBLOfORlJ+l3+d6Clltth6OERERERERETkwHIclBo5cqTsxSR6Nbm5uWXrPnPnzpUz5YnSP1IuEZK6W77nwkbnRERERERERKSsoJRoTj548GDZKDy76tSpk3ld9HlatmwZzp07B6PR+NDPjh8/PqdDojxisVjvle+pkc5MKSIiIiIiIiLKRzlOXeratStWrlyZ6ycUAS0xg19iYmKuH4PyL1NKBKWYKUVEREREREREisuUSkpKwo8//ojly5fLGezUavUDt8+fP/8/779z507MmTMHVatWzfloKX9Z75bv3W10zp5SRERERERERKSgoJQo23v99ddz/YRRUVEwGAy5vj/lH4vVCpeMRucmBqWIiIiIiIiISEFBqQEDBjzRE3766afyMdq3b4+wsLCHmp936tTpiR6fnrx8T2RKGc13Z+IjIiIiIiIiIlJEUCo1NVWW7505cwZmszlzvWhafuzYMaxZs+Y/77906VJcuHABixcvhqur6wO3ubi4MChl60wpOfueyJT6/98tEREREREREZHNg1IjRozAtm3bULduXaxduxatW7eWQabDhw9nK4tK9KKaMmUK2rRpk9sxUz6xWiHL90RQKp2ZUkRERERERESkpKDU5s2b8fnnn8ug1OnTp9G7d29UrFhRluWJ/z+Ov78/SpYsmdvxUj4SBXsZjc7ZU4qIiIiIiIiI8tODDZ2yIS0tDREREfJ6qVKlcOTIEXm9e/fu2LNnz2PvP2rUKIwdOxbbt2/HpUuXcPXq1QcWsh2rLN+72+ics+8RERERERERkaIypUqUKCHL95555hkZlNq7dy969OiBpKQkGbB6nIyZ+/r06SP7Fz0YEHHB8ePHczokytPyvXuZUmbOvkdERERERERECpt976233oLFYkHHjh3Rtm1b9OvXDydPnkSDBg0ee//169fndqxUQLPvadUuLN8jIiIiIiIiImUFpZo2bSpn2BNBqcKFC2PRokX45Zdf8NRTT6Fnz55Z3keU6tWpU0deDw8Pz9bzZDRTp4KefQ8yU4rle0RERERERESkqKCUULRo0czrZcuWlcvjZtz76quv8Nxzz6FRo0bw9PTM8udSU1MRExODJUuWyIAXg1I2KN9zcYFW5QKLFTCZLdCoc9x2jIiIiIiIiIgo74NSV65cwbRp03D48GGYTCbZC+px5XmTJ0/Gjh078PXXX+ODDz5AdHQ0oqKi5Ex8IuMqPj5elv+dOHECVapUkSWC9erVy+nQ6Alk/B5V9zKlhHSzFRo1NysRERERERERKSAo9d577yEuLg4vvPACvLy8sn2/2rVry+XcuXPYunUrjh07Jpuai8ycwMBAdOjQAZMmTULx4sVzOiTKAxmxRdHoXHsvO8possBdx6gUERERERERESkgKHXo0CGsWLECJUuWzNUTigwpsZCyZOS7ZfSUEjgDHxERERERERHllxw3DIqIiMCdO3fyZzRk8/I9EZTSiBo+BqWIiIiIiIiISEmZUq+++ipGjBiBPn36yFI7rVb7wO01atTIy/FRARGNzTPK90RJpU6tQrrJwu1PRERERERERMrpKSWMGTPmodtEMEP0iSL7Y71XwHcvSUqW8KWbGZQiIiIiIiIiIoUEpcQMedmxd+9eVKpUCTqdLjfjIls1Ohf1ewC0ahekMVOKiIiIiIiIiJTSUyonZX43btx4ZMBq0KBB6NixI65du4ZZs2bh999/z6+hUI5m37uLmVJEREREREREZJdBqYzG2f8WExOD1157DeHh4Th//jxMJhM0Gg0++OADLFq0KL+GQ9ku38vIlFLByEwpIiIiIiIiIrK3oNSjTJ8+HaNHj8b7778PtVot17388sv45JNPMHfu3IIeDv2r0XlGqtTdTKmsA4tERERERERERHYXlLpw4QKqVKny0Pro6OhHlvtR/svIbLuXKCVn3zOazdz0REREREREROQYQamSJUtiy5YtD61fsWKFvI1sIyMnKqN8T2RKGU3MlCIiIiIiIiIihcy+96SGDh2Kfv36YceOHUhPT8fMmTNl9tSRI0fw9ddfF/Rw6BGNzmVPKbOF24eIiIiIiIiIHCNTqnr16lizZg1KlCiBJk2aID4+XpbzrV69GnXq1Cno4dB/lO+ls9E5EREREREREdlbplRkZCS0Wm2WtxUqVAhvvfVWfj01PUGmVObse6J8j5lSRERERERERKSkoFRGuZ0ov/u3Tp06ycuff/45y/uK7CiXjHSc+4h1IoglAlatW7fGc889l5uhUS5ZMqJS9+jULkhnUIqIiIiIiIiIlBKUmj17Nj777DP4+vrC09PzocBSRlDqUV588UVMnz5dXoqyPVE2JgJcCxYsQNeuXREcHCx7S+n1erz66qvIK2PGjMGZM2fk82S4dOkSPvzwQxw4cABhYWEYNmwY6tevD2eUEZLKLN+Tjc7ZU4qIiIiIiIiIFBKUmjNnDt5991307ds3V0+4cuVKjBs3Dm3bts1c17RpU5QpU0Y2PRe3lytXDiNGjMizoNS+ffuwePFi1KhRI3OdCIa9+eabKF26NH766Sf8+ef/tXcf4FGV2ePHT6akV6okdJAuRVxEBF1QWAVRFtG1oi5ro/zdtYCIiK6iKxZ2EdyfDRUVXRX7qouKiwUVbKCISFuqdJKQnin/57wzdzKTBEggyUwy3w/PfW6dzDvhnZu5Z8577ocyceJEU9tKA1QS7cP3KHQOAAAAAAAiKShVXFwsw4YNO+on3LJli3Tp0qXC9uOPP142btxoltu2bSv79u2TmlBSUiJ33HGHycoKpnf/00ypl156SRITE03h9S+++MIEqCZNmiRRW+hcggudhw7pAwAAAAAACFtQauTIkbJw4UKZPHlypbWhjkSDQ4888ojce++9JhikCgoKZN68edKzZ0+zvnTpUmnTpo3UhMcff9xkYWmga/ny5YHtK1eulG7dugXaoPr27WuG8lU3mGMFdOojq/0e/wA+/R/Vdac9Ropd7nr92lC/WX3T/AtTPzTPa567fr/PUUt9kz6BCEPfRCSiX+IQHSN0CgPf33H/33P+piOCeBvIZ82qtr/aQSmt9fTqq6/KO++8Iy1btqxwh70FCxYc9vE6dO+6666TQYMGmUCRNlQLp7do0ULmzJkjn332mQlY/eMf/5BjtWHDBjNs78033zTzYHv27DH1q4I1btxYdu7cWa3nyMnJEbfbLfWV/v41KHjQVWzWc3NzTLDR63ZJXoHbvD4gHPJL8k1mpp5z3I7wvMdK3HmSEFtk2uBy1NrNSlEPz5tFRUVm+Wi+nAFqC30TkYh+iUq58sReVCTu4jwRe3g+Y3ldhVJcVCwuvf5xuMLSBuBw1+j1/bOmXkNVRbXPABpI0qDS0WrVqpW89dZbZqjcL7/8Ina73QzdO+WUU8wvPD093WRKNWrU6Ig/Sy8Kdu3aVek+vYufDtvToXhNmjSpsL+wsFBiY2NDtum6DverDi34npycLPU9eun1+n4X+vtXyYnxptC5vj4gHBwlDomLizPvrwRHQljaUOJ2idMWb9oQ76i/73PUznlT+0V9/qCAhoe+iUhEv0SlXC6RgngRZ7KIPTyfsbwuu8S48yQpNU1inKE38AIi4byZlpZWrz9raqynVoJSWgzcYjIY3O5qBy60cXqXu+A73WkwaM2aNdKrV68q/xwdgjd27NhK9910002mbX/4wx8q3a8Xu9nZ2SHbtA3x8fFSHdpJ6nNHUb726+soi8Tq3ffyS9z1/rWh/rLeW+ZfmPqhed7A+4P3Airpn/QLRBj6JiIR/RKVdIrQKRyCPuPx9xyRJqYBfNasatuPKlfy2WeflSeffFL27t1r1jWr6eKLLw4JWB3uTnh33XWXrF+/XjweT4Vg1Y8//ljldpx88smydu3aSvddfvnl5medeOKJZr20tNQEqfr06SP//ve/pXnz5qYNwfT1lB/SF03R2OAuo3ffc7lD/38AAAAAAABqSrWDUlqQ/Pnnn5cbbrjBBHg0sKSBprlz55rhb9dcc81hH3/PPfdIVlaW3HzzzeZnzJo1ywzB08dPnz5dasqDDz4YqPmhnnvuOZNZpds18KQZWVoEXY+xsqO++eYbU+w8GmmGYHAkU4NSpe76XVgNAAAAAAA0oKDUyy+/LDNnzpQhQ4YEtnXt2tVkHun2IwWl1q1bJw888IB06NBBunfvbgqlX3rppabI+BNPPCHDhw+XmqDtCaZDDDX4ZN3Vr1+/fqa4+tSpU2X8+PHy8ccfy6pVq+S+++6TaKThJ1tQqpTefa+UTCkAAAAAAFBLbNV9gNaR0mLn5bVr1072799/xMcnJCQECl61b98+MPyuZ8+esmnTJqkr2oZHH33U3IVv9OjRpvi6ZoFlZmZKNPJ4dPheWVTKYdNMKYbvAQAAAACACAlK6ZC9+fPnh9SD0lpNuk0DS0fSv39/eeihh8yQPf1Z7777rik4vmTJEklNTZXaonfh0yF8wTRrSoci/vDDD/LOO+/IgAEDJFqZgXrBmVIOrSnF8D0AAAAAABAhw/d0uJsOt1u2bJkZfqdWr15t7lynxc+PZNq0aXLLLbfI4sWL5aKLLpJXX33VBKo0c+nOO+88uleBGil0HjJ8zxYjJWRKAQAAAACASAlKaS2o9957T95++23ZuHGjxMXFyamnniojR46UpKSkKtV6WrBgQWBds5f0LniaJaX1pRDGQudSvtA5w/cAAAAAAECEBKVURkaGjB079qieUIuif/7559KoUSOzrnd8O/7442X79u1y1llnyXfffXdUPxc1W+jcYY9h+B4AAAAAAAhvUOqMM84ww+w0GKV33dNA0qF89NFHFba98cYb8tprrwWGiU2YMKFCVtTu3buladOm1X8FqBEerzfk/zWWTCkAAAAAABDuoNTEiRMDQ/O0YHh1DR06VLZt22aWly9fLr17964w1C8xMdEch3AO3yvjMEEpCp0DAAAAAIAwBqV+//vfB5Z1mN24ceMkISEh5Ji8vDyZO3dupY/XAJQGtlRWVpaMGDFCYmNjj63lqFFe0UypsnWnPYaaUgAAAAAAILxBKS1ovm/fPrM8b9486dKli6SlpYUc88svv8hLL70kt956a6XD9yw6ROzdd9895HONGjWqOu1HDfFoplS54Xsu3QgAAAAAABCuoJTWe7ryyisD61bWUzDNnLriiisqffycOXOq1BgNihCUChMTlAodvlfi4u57AAAAAAAgjEGp/v37y88//2yWtdC5Fj237p5XFUuWLDn6FqLuhu9J6PA9l4egFAAAAAAACGNQqqoBJs2oatas2RF/hh73wgsvyIYNG8Ttdkv79u3lggsukLZt21a3OaghOlLPbisLSzkpdA4AAAAAACIpKKX1pR588EFZv369CSgpr9crJSUlsn//fvnpp58O+/ivv/5arr76auncubO5C5/+jBUrVsjzzz8v8+fPl759+x79q8FR83i00Hn5oBSZUgAAAAAAIEKCUtOnTzeBJL0D37333iuTJ082d+RbuHChzJw584iP/9vf/iaXXXaZ3HTTTSHbNdD1wAMPmGLpCE+mVFCilDi4+x4AAAAAAKhFtuo+4IcffpAZM2bIH/7wB+nWrZsZeqeBqWnTpplaU0eybt06Of/88ytsHzNmjKxZs6a6zUEN0Ww3W/m777m5+x4AAAAAAIiQoJTD4ZCUlBSzrAEpK5A0YMAAWbt27REfn5WVJatWraqwfeXKldKkSZPqNgc1xFMuKKWZUi6P1wSrAAAAAAAAwj58r0+fPvLUU0/JlClTpEePHvLvf/9brrrqKvnxxx8lLi7uiI//05/+ZDKttDZVz549AwGp5557Tm688cajexWokeF7wbSmlCp1eyXWEXxfPgAAAAAAgDAEpaZOnSrXX3+9tGrVSi666CJZsGCB9OvXTwoKCmT8+PGVPqa0tFScTqdZHj16tJlrYfOnn37aBLLatWtn6lGdffbZx/p6cJQ0JmULyptz+le02Hmso9oJdQAAAAAAADUblOrYsaMsXrxYioqKJCEhQRYtWiTLly+X9PR0cze9ypx66qly1llnyTnnnGMCWBqYsoJTiMyaUk5/dhR1pQAAAAAAQNiCUjt27Kh0+4EDB8y8U6dOgeMyMzMrHHf77bfL+++/b4buZWRkyPDhw+Xcc8+Vrl27HlvrUXs1pfyZUiVuD79lAAAAAAAQnqDUkCFDJCYoYKFZNcHrwdsqu4OeBqB0ysvLkw8//NAEqC688EIzBHDEiBEycuRIad26dU28HhxDTang/1Kn3Z8p5SEoBQAAAAAAwhSU+uijj2rkyZKTk2XUqFFm0gDVBx98YAJUjz32mHTu3NkEp8aOHVsjz4Xq8XhCM6U0wOiwxUipi7vvAQAAAACAMAWlsrKyavyJNUD1+9//3kxffvml3H///XLfffcRlAoTr1fEFlPxDnwM3wMAAAAAABFR6LxLly4Vhu4Fq2z4Xnk61G/FihWmYLoO59M795155plyyy23VLc5qKWaUsphj2H4HgAAAAAAiIyg1IIFC0LW3W63bNmyRZ5++mn585//fMjHuVwuWbZsmRmyp8MBNRB1+umnmyLop512msTGxh7dK0CNBaXKBxtj7TaG7wEAAAAAgMgISvXr16/CtlNOOUXatm1rht+dddZZFfZrBtTSpUtNIEqPnTx5sgwdOlSSkpKOvuWo8ULn5YfvaaZUKYXOAQAAAABAJASlDqVRo0aycePGSvft2LHDZFFpwEqPQ+TxVjJ8T2tKlbq4+x4AAAAAAIiAoNQbb7xRYVt+fr68+uqr0rt370of88ILLxxd6xDWTCkdvufSHQAAAAAAAOEOSs2ZMydkXesQOZ1OOeGEEw5bUwr1r6aUDt/j7nsAAAAAACAiglJLliyplYYg8jKldPiey02mFAAAAAAAiJCaUhs2bJBFixaZGlKaXdOlSxcZM2aMZGVl1XwLEbaaUg6tKeWmphQAAAAAAKh5tqPJlDrvvPPkhx9+kHbt2kmrVq3kq6++khEjRsiKFStqoYmoq+F75YNSsXr3PYJSAAAAAAAgEjKlHnjgAbnhhhvk6quvDtn+z3/+U2bOnFlpIfRwZv888sgj8tJLL4nL5ZLf/e53cvvtt0tcXJzZv3XrVpk+fbp8//33kpmZKbfddpsMHDhQopGpZ15u+J7DpplSDN8DAAAAAAARkCn166+/yhlnnFFh+1lnnSWbNm2SSPLEE0/IwoUL5aGHHpInn3xSvvzyS5k7d24gYDVhwgRp0qSJGYqo2V8TJ06UHTt2SDRyuT3itIdGpZwOrSnF8D0AAAAAABABQamzzz7bBHhKS0tDtr/yyisyfPhwiRRut1uefvppmTJlipxyyinSs2dPmTRpkqxevdrs1wCVZkr99a9/lQ4dOsi1114rvXv3NgGqaKQZUVrYPJjTxvA9AAAAAAAQIcP3iouLZfHixfLJJ59Ijx49xOl0ytq1a02Ap1evXjJ27NjAsQsWLJBwWbdunRw4cEDOPPPMwLZzzz3XTGrlypXSrVs3SUxMDOzv27evGcoXjYpdHoktH5Qyhc4ZvgcAAAAAACIgKNW+fXu57rrrQrZ17txZIs22bdskLS1Nvv32W5k9e7YJUA0bNkxuueUWiY2NlT179kizZs1CHtO4cWPZuXNntZ5HhwHqVF9Z7S91u00QKvi1OOwxUuL21OvXB6n3fdP8C1MfNM9rnrt+v89RS32TPoEIQ99EJKJf4hAdI3QKA9/fcf/fc/6mI4J4G8hnzaq2v9pBKa27ZMnLyzPD5DT4Ew5FRUWya9euSvcdPHjQ7Nd6UlOnThWPxyMzZswwcy1uXlhYaIJTwXS9pKSkWm3Iyckxv4P63FEKCgrkYH6hiMdlXk+A2yV5+QWh24A6kl+SbzIzzXnGEZ73WIk7TxJii0wbXI5qny7RQOl5U/++qJhydy0Fwom+iUhEv0SlXHliLyoSd3GeiD08n7G8rkIpLioWV26OxDhcYWkDcLhr9Pr+WVOvoariqM4Azz77rKkrtXfvXrPeqFEjufjii0MCVnVBh+AFDxcM9vDDD5uLBr3bXr9+/cy2W2+9VW688UaZNm2auQNfdnZ2yGM0IBUfH1+tNmhALjk5Wep79DLGkSdJCZ6QAGNiQpzYHLFhCzoiujlKHOZ9qu+vBEdCWNpQ4naJ0xZv2hDvqL/vc9TOeVP7RX3+oICGh76JSES/RKVcLpGCeBFnsog9PJ+xvC67xLjzJCk1TWKcSWFpA3C486Zeh9fnz5p2u712glLz5s2T559/Xm644Qbp06ePyTzSIXJ6VzvNNLrmmmukrpx88smmnlVlli9fHhhuaGnXrp3JvNi/f780b95c1q9fH/IYDbKVH9J3JNpJ6nNHUdr+UnP3PVvIa0lw2qXI5an3rw/1k/XeMv/C1AfN85rnrv/vc9RS/6RfIMLQNxGJ6JeopFOETuEQ9BmPv+eINDEN4LNmVdte7bvvvfzyyzJz5ky56KKLTC2prl27yqWXXip33323vPjiixIptIi5FmH/+eefA9s2bNggSUlJkp6eboqy6534rCEY6ptvvjHbo1FOYamkJzpDtiXGOaSghFRWAAAAAABQ82xHMy6wbdu2FbZrFpJmIEUKHVZx4YUXmmCZ3lHvu+++kwcffFAuuOACcTgcZkhfixYtTL0pvVPf448/LqtWrZIxY8ZINDqQXyIZiaE1thKddikoqb/1sgAAAAAAQAMKSumQvfnz55thexYt9K3bevbsKZFEa0iddtppZkihToMGDZKbbropML7x0UcfNXfhGz16tLz11ltmaGJmZqZEo/0FpRWCUgmxdikkKAUAAAAAAGpBtWtKaWaRDtdbtmyZdO/e3WzTYXBaJFyLn0cSrXGlRc11qkybNm1MfSyIbN1fIC0zQotJJ8Y6JJ+gFAAAAAAAiISgVIcOHeS9996Tt99+WzZu3GjujnXqqafKyJEjTb0m1D/780tkZ26RdGqeErI9KU4zpagpBQAAAAAAIiAopTIyMmTAgAHmDnY2m80UPCcgVX99tjFbemSmSkZSueF71JQCAAAAAACREpTau3evTJo0yRQPT01NNbWltPi5ZkvNnj1bUlJCs20Q2bxer/zr219l9ImtKuzT4XsUOgcAAAAAABFR6FzrMzmdTvnggw/kq6++khUrVsj7778vRUVFcuedd9ZKI1F7/revQEpcHvnDbyoGpbTQeQHD9wAAAAAAQCRkSi1fvlxefvlladmyZUjB8Ntvv10uueSSmm4falm7Jknyyrg+khRXsSukxDskr4iaUgAAAAAAIAIypVq1aiVr166tsH3Hjh2SmZlZU+1CBEhPdJq772kmFQAAAAAAQFgzpc4//3y56667ZPXq1dKnTx9xOByyZs0aWbBggYwePVreeOONwLGjRo2q0caibqUn+AqfZxeWSLOUeH79AAAAAAAgfEGpZ5991hQz/89//mMmi959L3hbTEwMQal6LtZhk6RYu2QXlBKUAgAAAAAA4Q1KLVmypGZbgIiWnhgrB/JLwt0MAAAAAAAQjTWl/vGPf0heXl6Vf2hubq7Mnj37WNqFCJGR5JQDBaXhbgYAAAAAAIjGoFSLFi3kvPPOkzvvvFM+++wzKS2tGKQoLCyUZcuWyW233SbnnnuueQzqv4zEWMkuIFMKAAAAAACEYfjehRdeKMOGDZMXXnjBBJ32798vLVu2lIyMDPF4PJKdnS3btm2Tpk2bypgxY+T11183+1D/NU2Ok90Hi8PdDAAAAAAAEK01pdLT02XChAkyfvx4Wbt2rfz0008mOKUFzRs3bizdunWTTp061W5rUecy0xNkR3Yhv3kAAAAAABDeQucahOrSpYuZEB1BqZXbssPdDAAAAAAAEI1BqalTp1b5B953333H0h5EmMz0eDKlAAAAAABAeAqdly9orjWj1q9fLwkJCZKammrqSb311ltis1X7xyHCZZnhe0Xi9XrD3RQAAAAAANCAOKqb/fTnP/9ZJk6caKZgTz75pHzxxRc130KEVatGiVLscsuvOUVmKB8AAAAAAEBNqHZq03//+18555xzKmw/44wz5Ouvv66RRiFyxDvt0rZJkqzddTDcTQEAAAAAANEclGrXrp0sWrQoZJsO7XrhhRekc+fONdk2RIgux6XI2p0EpQAAAAAAQBjvvjdt2jS57rrrZPHixYEg1OrVq6WoqMgM4UPD07l5qqz5NTfczQAAAAAAANEclDrppJNMQOq9996TDRs2mG1/+tOfZMSIEaboORqevm0y5F8rtpiMuJiYmHA3BwAAAAAARGNQSjVq1EguvfTSmm8NIjYotSevWLbsL5A2jZPC3RwAAAAAABAtQampU6dW+QcG36kPDUNCrF1ObJ0h/127R64YQFAKAAAAAACEodA5otPIXpny5vfbw90MAAAAAAAQTZlSZD9hxAkt5K/v/CS/7DoonZqn8AsBAAAAAAC1H5TasWNHlX9gZmbmsbQHESojKVYu6NtS5ny0TuZecmK4mwMAAAAAAKIhKDVkyJAj3nXNujPbmjVraqptiDATBneUoQ8vlc/X75VTOzYJd3MAAAAAAEBDD0p99NFHtd8SRLzM9ASZOryr/OVf38ui6wdIq0aJ4W4SAAAAAABoyEGprKys2m8J6oVLT25t6kpd9tRXMv/K30iHpsnhbhIAAAAAAGioQakuXboccfieheF7DZv2gztHdpf7//OzjJr3ucwY2V3OPzGryv0DAAAAAACgykGpBQsW8NtCgM0WI1PP7ip9W2fI9Dd/lJe/3io3D+ss/do14rcEAAAAAABqLijVr1+/Ctvy8vJky5Yt0rFjRykpKZHk5MgbxpWTkyN33323fPLJJxIXFyejRo2Sv/zlL2Kz2cz+rVu3yvTp0+X77783dw287bbbZODAgeFudr0xrPtx0r9DY3ny000y7pkVckLLNLlyQFs5o2tzsdvInAIAAAAAAIfmi85Ugwagbr/9dhOoGjNmjOzatUtuvfVWGTdunAkCRZK77rpLdu/eLS+88II88MAD8vrrrweyvvRugRMmTJAmTZrIokWL5LzzzpOJEyfKjh07wt3seiU13ik3Du0kn04ZLAM6NJY731otp836WB75aJ1s3V8Q7uYBAAAAAICGEpSaNWuWrF+/3gR4NPtITZo0SQ4cOCD33HOPRJKlS5fKVVddJccff7z0799fzjnnHPniiy/Mvi+//NJkSv31r3+VDh06yLXXXiu9e/c2ASpUX3pirEwccrx8MnmwzBjZTb7bmi1DHvqvjH70c3nm802y+2ARv1YAAAAAAFC94XvBFi9eLPPmzZPOnTsHtumyDpP74x//KJEkPT1d3nrrLROQys3NlU8//VSGDh1q9q1cuVK6desmiYmJgeP79u1rhvJVh2Zc6VRfWe2vqdegw/aGdmtupv35JfL+jzvlzZU75K/v/CQ9stLkjC7NZHCXZtK9RaqpTQUcsW9K+N5j5nnNc9fv9zki+7wJ1BT6JiIR/RKH6BihUxj4/o77/57zNx0RxNtAPmtWtf3VDkrl5+dLQkJChe0ej0fcbrdEkhkzZsjkyZPlxBNPNO0bMGCAGaKn9uzZI82aNQs5vnHjxrJz585qPYcOWYy0113djlJQ4BtmV9N30LOLyIguaWbal18in204IJ9u2C9PfLpR4hw2Oal1mpzYKlX6tkqV9k0SxcYd/BAkvyRfiouLTf06tyM877ESd54kxBaZNrgc1T5dooHS82ZRkS/7kzuPIpLQNxGJ6JeolCtP7EVF4i7OE7GH5zOW11UoxUXF4srNkRiHKyxtAOr6Gr0u6TVUVVT7DDBkyBCZPXu23H///YFtOgxOh+6dfvrpUpf0okBrWlWmadOmsmnTJunRo4cJRGkQSmtMPfHEE3L99ddLYWGhxMbGhjxG17VmVnWkpaVFZJH36kYv9XXUZodPSxNpn9lUxg4SKXF55NstB2T5pv3yycb98vePN5sgVZ/W6dI9M016ZKWaeVZ6fL1+E+LYOEocZoiwvr8SHBUD4XWhxO0Spy3etCHeUX/f56id86b2C85RiCT0TUQi+iUq5XKJFMSLOJNF7OH5jOV12SXGnSdJqWkS40wKSxuAcF6j1za7XdNUaiEodccdd5i71Gmhc80+Ov/88+XgwYPmrnV6J7u6pEPwxo4dW+m+W265RR5++GH573//G8iI0kDUnXfeKVdffbW52M3Ozg55jAak4uPjq9UG7ST1uaMEv4a6eh1xTruc0qGJmVSp2yM/bM+RVVuz5ccdufLhml2ybneepMQ7pMtxKdKhabJvapYsHZslS4vUeIb+RYFAv5TwvcfM85rnrv/vc9Tv8yZQVfRNRCL6JSrpFKFTOAR9xuPvOSJNTAP4rFnVtlc7KJWSkiKPPPKIyY7asGGDuFwuadeunSkWXtdOPvlkWbt2baX73n33XcnIyAgZoqc1pHT4oQ65a968uSnYHmzv3r0VhvSh9jntNjmxdYaZLEWlblnza66s25UnG/bkybINe+W5LzfL5n35EuewS5vGidKqUaK0ykiUlhkJvuVGCWY9KY5hVgAAAAAARLpqXb1v3rxZMjMzxel0SqtWrcxk3c0u0mhwSe8IuG/fPlMrSm3cuNEUNm/UqJH06tVLHn/8cTME0MqO+uabb0yxc4RfvNMufVpnmClYscstm/cVyP/25svWA4Wy7UCBLNuwT7Z9vVW27i+Q/BK3NEqKNYGqFmnx0iLNNz8uLV4y0xPkuNR4aZ4aL7GOat94EgAAAAAA1HVQSsc0zpw5UxYuXCjPPPOMGbpnee655+Tjjz+WK664QqZMmRIx6WW9e/c22Vta6PzWW281AapZs2bJZZddZtqor6FFixYydepUGT9+vHkNq1atkvvuuy/cTcdhaJZUp+YpZqqsn2YXlMrWAwWy7UCh7MgulJ05RbJqe478Z/VOs7zrYLF4vF5pkhznC1al+oNVJoBVFsRqlhpnngsAAAAAAIQxKLVgwQIzHG7evHkhASn16KOPypIlS0xwp3Xr1nLJJZdIJHA4HKaouQbTLr30UpMhdd555wXuvqdFt7Tt06ZNk9GjR0ubNm3M69NMMNRPGmzMSIo1U8+W6ZUe4/Z4Zc/BYvk1p1B+zSky086cQlPT6oOfdsmv2YUmcKXHZSQ6TVZVs1QNXsUFlpun+JZ1apIcKw47WVcAAAAAANRKUOrll182RcwHDx58yDvy3XzzzSZ4FSlBKXXccceZ+leHooGo559/vk7bhPCy22JMVpROfQ5xjAak9uUXy+7cYtmVWyQ7c4tkV66uF8mP23N8yweLZG9eidhixGRd+YJUcf6glW+5eVrZckZiLMXZAQAAANQrLrdHil0ecbm94vJ4xOXRuVc8Hq+5vrHHxIjNJuKw2QLLes2l6057/S7UjQgKSm3fvl169ux52GP69+9vspKA+k5Pos1S4s3UIyvtkMeVuDyyJ88XuNKAlQardHnL/gJZ8b/9Zlmn3CKXOSGbn5kaF6hr1TQlzmRaaVDLTP51hg0CAAAAqIuA04Y9+fLTrzmycU++bM8ulO0HCmV/fonkFpXKwSKXFJS4D3nNpF/mH47Go+IcNnN9E+/0zc168LJ/v25LjNXj7GaeGOsIWrZXsuwwywk6Oe3m5llowEEpLRSugamsrKxDHrNz505JT698yBTQEGmx9Kz0BDMdTmGJ22RWWUEra1q366As21Asew+WyN68YtlfUCJer0hKvEOaBgJVQUErM8Wa4JW1X0/CAAAAAHA41t3NV+/wTT/tyJGfdx4UW0yMdGmRIh2bJkubRkkyoEMTc82RmuCU1HiHpMQ7Jd5hF4c9xgSiNPijc4tmTLm9XhOgMpPXl0VV6vaam1RpllVxqSewrO0w28z20G163VRY6pb9+aUmOFbgX9ftuqzH6bygxCVFpR4pcXsC7dAkAA1O6fWRBqzKlu3llh2SEGsLHGMFtjTQpes61wCatRwXtEzgK4xBqaFDh5phcPPnzzd33ivP5XLJ3LlzZeDAgbXRRqBe05Ncm8ZJZjrSNxUamLKCVGVTibnboGZf6bIJYOWXmJN+Uqzd1NDSOw6mJ8ZKo0SnmetwwUZJvmXfPqeZ63Y9oQIAgIZDPxOUuPQuxTrXC0GdfOu+baH7rPXiUq9oEoRvXrZPLyb1Ws+lkxmy43sO37pu9+8P7At+jG9uJVDoF24ej0dibIVm2dpm5v5lK9cieFkvefW6V5MfdIiQWY7RZd3uXzfDhHx1RXWfb1mP04tn30WqfuxxOmJEv8eL1XWHb3ustc+/LWRdj3Xo3Pe4eGdMyBTnCN2mxwGRRLOctOzI6u0agMoxQagNe/JMoKl7Zqp0z0yTPw5sZ5bbNUkOCTJVl3l/iu99U9dK3R4TtCryB61Cg1iukIBW8LJeSwUHvayAly5rAM1a1nlwMpj+nnwBKl92ly+YFRTAsrY5bL4gl385rlzAKzhjLNbu26/rmvRg5nabOK0TZRSoUlBK7043ZswYUxD88ssvlx49ekhKSork5OTI6tWrTV2m/Px8c3c7AEf5ZrTbAsMGj0S/fTigAay8EjM/kK/z0sDy5v35snJbqTnhZuu2glLJKSw1j9UTohZxN0XhE2MlTb8FSXBIarwz8I2Ibx66XTO49LGMCwcAoPo0aFNQ4pXCEt/cLJdWss1aLi1bLtuvF2BeyS/2b/M/XgNJwTQgE6eBGIc19wVSypYr32dtT4y1id6E2KH1YkytmBj/ulUrxvccGoyx9gevW8Eh6zK3sLBQEhMTTDDJKi+js8ByuW0xEiNeKQtu+eaafSHiNkEu33qF/f5lX8aGSKlOLs3Y8P3+NfBmll1eKSr1Sm5R2T6z3x+QCxzvD97psWYKLFf8fcc7rCCVSJzOA+tl28222BhJdMZIYmyMJMSGzs2yM0aS4mxl252+uf4f8RkMhwtA6bRqm2/+v30F5o7iGnzSwNPwE1pI96w0yUyLb1D9SDOXdNLrldqgd3fXc0GRyxf40uwsXdbglgasivzZXZoFZgJZut2f+WUFuHILS4OCXL4gmpaB0cywElfFrDGd1MxzjpdLTo2OkWhVCkqlpqaaYucPPvig/O1vfzN/WKz/JA1ODR8+XCZNmiRNmjSp7fYC8H8j0Tg5zkxVpZlYGpgygauCsoCVbtPx4nrC3H2w2Mz1j1tuocs/L5V8/1hy/dBZPnCVHOeQxDi7JMU6JCnOYbK3zFy3mXXfeG/fNv92f7qsvg4gkui3/sEXHdaFSPBFiV4Q5hwsFbEXSJFLAvv1IkYfb+aaUeAWcwFkZRX49gcve80FkwaZ9ULKZBMEZxaYjAGvL3PAnz1Qtt23rJ8rbSGTL3vAl0lQlkEQyDDQiz2zvSzLIJBJYPdddMb658HbQ47Rx2gGgf+xeqx1MWsubE0WQeXrerF7LN/GArVNM4mCgz26rAGgwwWIygeTyj/emgeXZfEFfsoCDlYAIskMKQnd1jgpdFvIfn9wQyfzPnNa7+HIeZ/p9UJeXokkJ8c2mIthfU0mEy3474Mr9O9GcBCrOGi71Wd25XoC/epQfUyPteip81D/9xWDWmUBrcqCX9ZjNViW4F/n3Fw/HDQBqFxfAMofiNq0N98EoE7ISjPT+X1bmrmW+sCx0XOWBu41g6m2Al+VnV80aFWQlyvRokpBKaX1ou655x654447ZOvWrZKbm2u2tW7dWux2hgMB9SETq7qBrOCAlgauTPDKH6jSuQa08ordUlDskrwSl+QXu0z9LJ1rGmyezov9c91f4vtmQOnn0kQdxx3nkJQ4hyTHO0yAy0zxWthQZGeuQ5qkFkl6oleOS7NLZoZDGifbzIU3YNFvxHMLvZJT6DHfeh8s8khese9Dvk55xR7/3L+tpPx+nfuOKV/L03yzXe4bbw20OG0eSY4vG76hF4M6/EMDtxq80VoFwUEbK5ijF4q638o60O1WQMkKMFlZAmKtBzIHfOv+XYGLOyt7QINVVnBLfyfWum/yrwcd57GG4viH/ZhgmWYJeMoyCXS7/v40mBacPRAccLOyD4KHAwUPG9LHBHNWI4hV0+sExeo/7bfWxXulwZ+gC/tDbS8fSArOVvL/iQq8/8su4CsGi6wL/uQ4mzRPqTxoVFnwQNcjKWiE6tPzr/X3obb7uwa2qpJNF7x9b56n4rFBfb3I/9igcjzm/Kh900yxoXN9nYlB24LX44P6uO9Y/RsYvO6bzIW9nWyvqtLMm837CkzNp192HjTztbtyZev+QhOA0psxaeBp9IlZBKAaZCDMJoVRdL1T5aCUJTY2Vjp06FA7rQEQsQEtM9wvKbZGxn6bQFWJBqxcJmCVbwJXvowtXc8rcsn+Ah3nHSNb93lk3c4i+TXbLbtz3eZCvmWGQ9o3c0q7pk7p0MwhrZs4zQUn6i8NomQX6LBUzejzTVagKccKOAXWfcGnXP8+DSpZwY60BJskx/m+JdZJLxZ9c81AiJHMdN2vGXv+Y2JDj7M+RPsCGZV/ePZ9658nycnJDeZb/7qqdVNZ0Kqq69ZQm+o+/nBBMWv4kpVhUhbMqv66GdqkQcegYU3W8Cd9Tl9x2LJjfAVjfe2xjonE/qT/f8HZf1Zw0sr0cwUHK/11hYKzBn2FbssyCq2skuAsE53rhbdmk5Ttr/g4vbjWbRb9/ZXPNApcHJcLCmm2UUJG6IV1hQBS8M9y6m3NI+//A9FF+6Cvn9ZiZqCVwRUUuAqs67IV1LUCWv7hoxr4soK6FeallQe+lAamfOdfr8TGdJdYR7HEOfYGan6ZSc/N/mX9W+yb+4Ja5twaEzqMNHiYqcZ7yw8ztbb7hpb6vgzSd7fX7ZKifJskeA6IzeEbCRQYc2oWYyoML1XecsW9raGkZctl85D9/gLgus0U9TbDu8pqGekXujtzimTrgQJzgyQdVdDpuBTp3DxZTunQWK4c0FY6H5di7uANRHVQCgCOhY77TkvU6fApsPkl+fLeT7/IcRmNJcHpu8OhXtzsynHLln0u2bi7VJZvKJIXvyyVgmKvtGrskA7NnNKxuW9q3dhB4dEw0g+6GmDal+eR/fke2ZfvmweW/dv3F/jmBwp8w9T0G9b0BJsJLqUmxITMNaDUtYUjZFta0DF6ERmJF/XRzhQFjfV9c16fg2K6rFl4le3XgIo1PNMEcYKCNaY4tAZn/PPgTJzyfBdPvt9ZcGZccCadlSkakl1nZdOZqyyv2G1FZrksey50iGjZcllGXdm+smODi1Ufqq3WcE8r2KZDOx3lsgTjg4J4VmahlXWoAWFrmx7jO9ZaL6t1ZB0THEgi6wI4Nr5hSfp3tBaHIbnLiuwHF9wvKT4oJXt/kWLpLsXeZH/GrVeKNRNX9/sD2ma7mXyP1WxnPS8FF9/XYI/ONRvY5Q8Ahey3CvCbx/nOcVb7vG6niPMXiYmxmXWzPdB+/9y/JbjutJ6ntaC+LXiu5+/y20zRfWvZCorpOS20QHZaYqxZPrNrc2nVKEFaZiSau20THEc0ICgFoN7Qi5uWjRxmGnC8ryC8foDYc9BjglQbdpfKF+uL5PnPD5oAVtsmTungD1Id39wpmRl2hv4dJa2d4gsweX2BpEMFm/wBp4P+7KXUeK1/ZpNGSf4p0SaNkm3SvokjsE0zGHSb7gtX4AINV7iDYuV5gy6YrLuVWVlGwXcy89URCw0mWfXFrHpjwdv0HacXYAUFhRIf77vCtO5YFjw0NLj2mDkmqAaZVYTaCnQFZ3w5g4acatCJCyUAR6JfFFmB5QpceoLJ96WL2sOT+eN1FUpe9k5JbjdEYpyHv0s2gNpDUApAvf/A0yzVbqb+HX2BKv2mf2e2W9bvKpX1u0vlgx8L5PGPS823Ve2Dsqk6NndI05Tou6OgXhTrMKhAMKlcgOlAJcEmLd6qF6oaRMrQwFJSWbDpuDSbdM8sCzJZgaaMJL0jSnT9boEj0fONL7Oo5uvRNMSC0gAAoGGrUlBqx44dVf6BmZmZx9IeADhm+m2/FkXX6bQuvowBzSDYus8VCFS99nWeGQaoNYWsbCprSk+018uhclYQyTcczhds0mFx+/yBpuB9OqxIh74EgkhB2Uztmjikb1t/BlNQkEmHypEdAQAAAKBOg1JDhgw54jdu+u2cHrNmzZqaahsA1OgQnrZNnWY6079NaxNs3uMLUmmwatm6ItlxwG0CNBqoatfULZ2OS5Y2qV5JqIO7wGp7rOLduUX+ebkC3xpkCg4uBQ+VS9Ghcv4MJTP3D5Xrme40mU3BmUw6afFvsikAAAAARHRQ6qOPPqr9lgBAHdMaB51axJrJUlDsMbWpNEj1y65S+XB1G7n7zWJp12SPZKXb/UPXbCYApAV+nQ5fjRUtiWAVBrYKamq9F81Isu5ikx9ya2a964pvOdcfhNIhckqLfZvi3fG+7KRUf0FvXW+ZYZeeLf1D5fxBJ52nJ9pMsVIAAAAAaFBBqaysrNpvCQBEgMQ4m5zQKs5MJW6XOGzfSIvE/rJud6K5858W+c4u8JhbIfvuDiNS6r/zliaUht6a2FcM2LpFuWYwWXeN0mGD1rIGuIIDUJUWBAUAAACAaAxKdenSpcpDPBi+B6ChaZwcIy0zwnNnGAAAAACI6qDUggULar8lAAAAAAAAiBpVCkr169evwra8vDzZsmWLdOzYUUpK9PbDybXRPgAAAAAAADRAtuo+QANQt99+uwlUjRkzRnbt2iW33nqrjBs3TnJycmqnlQAAAAAAAIjuoNSsWbNk/fr18vrrr0tcnK/GyqRJk+TAgQNyzz331EYbAQAAAAAAEO1BqcWLF8u0adOkc+fOgW26fPfdd8snn3xS0+0DAAAAAABAA1TtoFR+fr4kJCRU2O7xeMTtdtdUuwAAAAAAANCAVTsoNWTIEJk9e7YpdG7ZunWrGbp3+umn13T7AAAAAAAA0ABVOyh1xx13iM1mM4XOCwsL5fzzz5dhw4ZJamqqTJ8+vXZaCQAAAAAAgAbFUd0HpKSkyCOPPGKyozZs2CAul0vatWsnHTp0qJ0WAgAAAAAAILqDUps3b5bMzExxOp3SqlUrM33xxRcSjbxer5kHD2Osr69DX4PdbpeYmJhwNwcIyC/Jl6KCIsm2Z0uRoygsv5lSd64kxpZIXl6uuJ2+9zzgO2/maw/hvImIQt9EJKJfolKuXP2wJ2LLFbGH5zOW11UkeQVFekEnMXzOQwTxNpBrdCtWYsVODiXGe6Qj/D9k5syZsnDhQnnmmWfM0D3L+PHj5eOPP5YrrrhCpkyZUq9/adWxc+dOamgBAAAAAAAcwtKlS+W44447tqDUs88+K4899pgJTA0ePLjC/iVLlsjUqVPlhhtukEsuuUSigd5tcPfu3ZKUlBQ1gTgAAAAAAIAj0VBTfn6+NGvWzNQlP6ag1IgRI2TixIly9tlnH/KYV155RRYsWCBvv/32ERsHAAAAAACA6Falu+9t375devbsedhj+vfvb4qfAwAAAAAAADUSlGrcuLEJTB2pxlJ6enpVfhwAAAAAAACiXJWCUkOHDpVHHnlESktLK93vcrlk7ty5MnDgwJpuHwAAAAAAABqgKtWUys3NlTFjxkhcXJxcfvnl0qNHD0lJSZGcnBxZvXq1PP/886aA1YsvvijNmzevm5YDAAAAAACgYQelVHZ2tjz44IPy7rvvSmFhodmmD9Xg1PDhw2XSpEnSpEmT2m4vAAAAAAAAoikoZSkpKTEFzTV7SmtItW7dWux2e+21EAAAAAAAAA1OtYNSAAAAAAAAwLGqUqFzNEzFxcVy2223yUknnWSK1M+fPz/cTUKU+uCDD6Rz584h0//7f//P7Pvpp5/kggsukF69esn5558vP/74Y7ibiyigWcHnnHOOfPXVV4FtmiV85ZVXSu/evc2w9c8++yzkMcuWLTOP0b46duxYczxQF33znnvuqXAO1XqflnfeeUfOPPNM0zcnTJgg+/fv5z8GNWLXrl3m73W/fv1k0KBBct9995nPl4pzJiK1b3LORDht3rxZxo0bJ3369JHf/va38uSTTwb2Ret5k6BUFJs1a5a5wH/22WdlxowZ5g6K77//fribhSi0fv16GTx4sDnxWpN+YCgoKJBrrrnGBE5fe+01c/K+9tprzXagtuiH1htvvFHWrVsX2KZJxXoxr7UTFy1aJOedd55MnDhRduzYYfbrXPePHj1aXn31VWnUqJGMHz/ePA6ozb6pNmzYIDfddFPIOVSD+GrVqlUybdo001//9a9/mfILU6dO5T8Fx0zPb3rRr7VmX3jhBZk9e7Z8/PHH8ve//51zJiK2byrOmQgXj8djrm0yMjLk9ddfl7vuukv++c9/yttvvx3d500dvofok5+f7z3hhBO8X375ZWDbvHnzvJdddllY24XodNNNN3kfeuihCttfeeUV75AhQ7wej8es63zo0KHeRYsWhaGViAbr1q3znnvuud6RI0d6O3XqFDhHLlu2zNu7d29z7rRcccUV3jlz5pjlv//97yHnz4KCAm+fPn1CzrFAbfRNNWjQIO+nn35a6eNuueUW75QpUwLrO3bs8Hbu3Nm7ZcsW/kNwTNavX2/64p49ewLb3n77be/AgQM5ZyJi+6binIlw2bVrl/eGG27wHjx4MLBtwoQJ3hkzZkT1eZNMqSj1888/i8vlMpknlr59+8rKlStNBBeoS/qNVdu2bSts1/6o/TImJsas6/zEE0+U77//nv8g1Irly5fLySefbDJKyvfFbt26SWJiYmCb9k2rL+p+zeizJCQkSPfu3emrqPW+mZeXZ4apVHYOraxvtmjRQjIzM8124Fg0bdrUDDspf/dt7ZOcMxGpfZNzJsKpWbNmJmMvOTnZZDh98803smLFCjPMNJrPm45wNwDhsWfPHpM2GBsbG9imJ24dGpCdnW3SAYG6oCfkTZs2meEmjz32mLjdbjnrrLNM2rX2044dO4Yc37hx4wpDV4Cacskll1S6XfuifpAo3xd37txZpf1AbfVNDeprwP7//u//5JNPPjF3Rr7qqqvk97//vdm/e/du+iZqRWpqqqnVY9EvNbWWWf/+/TlnImL7JudMRIohQ4aYIXmDBw+W3/3ud3LvvfdG7WdNglJRSsdYBweklLWuRVSBuqInY6s/6jcH27ZtM/WkioqKDtlP6aOoa0fqi/RVhMvGjRtNUKp9+/Zy2WWXmW9cp0+fbr6FHTp0qDmXch5FXXjggQfMzUm01skzzzzDORMR2TdXr17NORMRYc6cObJ371658847TSH+aP6sSVAqSsXFxVXowNZ6fHx8mFqFaJSVlWXuIpWWlmY+JHTt2tV8o3XLLbeYVNbK+il9FOE4Z2oW6aH64qHOqfptLVCbRo0aZb5l1Qwp1aVLF/nf//4nL774oglKHapvato/UJMX/XrjHC0o3alTJ86ZiNi+efzxx3POREQ44YQTzLy4uFhuvvlmc4MSDTxF42dNakpFqebNm8uBAwdMXSmLpgRqp28IHRv1i15MWXWjVIcOHcwJWmsC6DcIwXS9fOoqUBfnzMP1xUPt1z4M1CY9d1oBKYtmTWmdKfom6sLdd98tTz/9tLn41yEoh+t3nDMR7r7JORPhpOfBDz/8MGRbx44dpbS09IjXPQ35syZBqSil2SgOhyOkMJoWWtOIrc1Gt0Dd+fTTT03x3uBvBtasWWMusrS433fffRe41anOv/32W+nVqxf/RahT2uc05V+HQgWfM62+qHNdt2h/1qEC9FXUtn/84x9y5ZVXVriZiQamKuubv/76q5nom6gJc+fOlZdeekkefvhhGTFiRGA750xEat/knIlw0jIlEydODHxxpH788UdTz1mve6L1sybRhyilafua8q9jWFetWmUitvPnz5exY8eGu2mIMnoHSE1Hvf32201tlKVLl8qsWbPkT3/6kyl4npubKzNnzpT169ebuZ6Azz777HA3G1FGh5LqXcumTp1qCu0//vjj5tw5ZswYs19TrjVgqtt1vx7XsmVLE3AFapMO3dM6Uk899ZRs2bJFFi5cKG+88Yb88Y9/NPsvvvhiefPNN+WVV14xwarJkyfLb3/7W2nVqhX/MTgmWjD60UcflauvvtpcTGnGvTVxzkSk9k3OmQgnTQDRO+bddttt5tpGr3seeOABue6666L6vBnjtVIQEHX04l6DUosXLzYFUceNG1fh21agLuiJVe84oZl7SUlJctFFF8mECRNMirWejGfMmGE+YHTu3Fnuuusuc7tUoLZpf1uwYEHgj/3mzZtl2rRp5pa8bdq0MR8oBgwYEDheP1hoP9a7oGiwVYcNcOGPuuib+sWSFkzVWlJap+8vf/mLDBs2LHD8a6+9Zvbn5OTIqaeeavqm3oEXOBZ6YfTQQw9Vum/t2rWcMxGxfZNzJsJJs6T07/AXX3xhEkUuu+wyufbaa811T7R+1iQoBQAAAAAAgDrH8D0AAAAAAADUOYJSAAAAAAAAqHMEpQAAAAAAAFDnCEoBAAAAAACgzhGUAgAAAAAAQJ0jKAUAAAAAAIA6R1AKAAAAAAAAdY6gFAAAAAAAAOocQSkAAIAadOutt0rnzp0POb322mtmvm3btjr5vXu9Xrn88stlw4YNNfpzb775Zvn8889r9GcCAIDoEuPVTyoAAACoEQcPHpSioiKz/O6778r8+fPl1VdfDexPS0uTnJwcadSokdjt9lr/rWsQ7KuvvpL777+/Rn/u5s2b5frrr5c33nhDYmNja/RnAwCA6ECmFAAAQA1KSUmRpk2bmkmXNfBkreukARyd10VASr97/Oc//ykXX3xxjf/sNm3aSGZmpgm8AQAAHA2CUgAAAHVIh+0FD9/T5ffee0/OPvts6dWrl9x4442ydetWGTt2rFm/5JJLZNeuXYHHf/DBBzJ8+HCzb8yYMbJ8+fJDPtdnn30mhYWF5lilGVNDhgwxmVunnnqq/OY3v5EnnnhCVqxYIWeddZb06dNHJk+eLB6Pxxz/888/y0UXXWQeP2jQIJk7d27Iz9ef9dJLL9XSbwoAADR0BKUAAADCbM6cOfK3v/1NHnvsMVm8eLHJbNJJAz579uwxgSMrSDRlyhQzbO6tt96Sc889V66++mozlK4yn376qZxyyikSExMT2LZ792758MMP5bnnnpPrrrtOHn74Ybn33nvN8+uyZj599NFH5lgNUHXt2lXeeecdmTlzpjz55JOydOnSwM/SwNbKlSslNze31n9HAACg4SEoBQAAEGZXXnmlyUbq37+/CQINGDDAZE7p8rBhw2TTpk3muKeeekouvPBCGTlypBk+p9lUp512mrz44ouV/tyffvpJOnToELKttLTUBLbat28vl156qcmK0nnv3r1l8ODB5jk3btxojt2+fbukp6dLVlaWeZ6nn35aunXrFvhZrVq1EofDIWvWrKnV3w8AAGiYHOFuAAAAQLTT4I4lPj7eBIGC10tKSsyy3kFPh/r961//CgkyDRw4sNKfu3//fsnIyDjk8+nPVod6vmuvvdZkT+nz/fa3v5XzzjvP1MOy2Gw2U7h93759x/T6AQBAdCIoBQAAEGbli55rsKcybrfbDNcbNWpUyHYruFSeDtvTx5Sn2U1Veb5rrrnGZGzpcL8lS5bIFVdcIXfffbdccMEFgWM00+pQjwcAADgcPkEAAADUE+3atTMF0nXonjVpFtMnn3xS6fGNGzeW7Ozso3qu4uJiueeee8zdAq+66ipTg0qHDv7nP/8JCUjl5ORIkyZNjvo1AQCA6EVQCgAAoB7VntJC5AsWLJAtW7bIM888Y6a2bdtWerzWf1q7du1RPVdcXJx8++23JjNKa0z98MMP8vXXX4fUlNLhhKpLly5H+YoAAEA0IygFAABQT2gx8lmzZsnChQtl+PDh8vLLL8tDDz0kv/nNbyo9ftCgQSaw5PV6j+r5Zs+eLYWFhTJmzBgZN26cnHTSSTJ+/PjA/m+++Ub69OkjycnJR/2aAABA9IrxHu2nFAAAAEQ0rSf1u9/9Tu67775DBq6OxeWXX24CVloAHQAAoLrIlAIAAGjABdS1WPlLL71U4z9bh+79+uuvJmMLAADgaBCUAgAAaMA0k2nHjh2B+k81Zd68eXLHHXeI0+ms0Z8LAACiB8P3AAAAAAAAUOfIlAIAAAAAAECdIygFAAAAAACAOkdQCgAAAAAAAHWOoBQAAAAAAADqHEEpAAAAAAAA1DmCUgAAAAAAAKhzBKUAAAAAAABQ5whKAQAAAAAAQOra/wcZua2R4YApBQAAAABJRU5ErkJggg==",
       "text/plain": [
        "<Figure size 1200x900 with 3 Axes>"
       ]

From 16e662bbfd5b8f3e19e5586c5334506cca4186af Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Wed, 29 Apr 2026 11:37:48 +0200
Subject: [PATCH 11/14] feat: neurodamus-parity for spatially uniform e-field
 stimulus

- Add Cell.set_local_to_global_matrix() and local_to_global_coord_mapping()
  with quaternion->rotation matrix construction (no scipy dependency).
- Rename compute_segment_coordinates -> compute_segment_local_coordinates;
  add compute_segment_global_coordinates that applies the cell transform.
- Switch _add_extracellular_stimulus to iterate the resolved seg_list
  (honoring compartment_set or node_set->all sections per neurodamus
  target_point_list semantics).
- Set soma displacement to zero in _add_extracellular_stimulus.
- Pass a local-to-global closure to get_segment_position for axon/myelin
  sections that lack 3D points.
- Populate the cell transform during instantiate_gids using a new
  SonataCircuitAccess.get_cell_position_rotation helper.
- Make Cell.delete robust against partially-initialized cells.
- Add unit tests for cell coordinate helpers, integration tests for the
  e-field stimulus glue, and additional ElectrodeSource coverage.
---
 bluecellulab/cell/core.py                     |  86 ++++++++--
 .../circuit_access/sonata_circuit_access.py   |  30 ++++
 bluecellulab/circuit_simulation.py            | 109 ++++++++-----
 tests/test_cell/test_segment_coordinates.py   | 150 ++++++++++++++++++
 .../test_stimulus/test_efield_integration.py  | 129 +++++++++++++++
 tests/test_stimulus/test_extracellular.py     |  40 +++++
 6 files changed, 496 insertions(+), 48 deletions(-)
 create mode 100644 tests/test_cell/test_segment_coordinates.py
 create mode 100644 tests/test_stimulus/test_efield_integration.py

diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index d1518f63..9d2ec32f 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -162,6 +162,49 @@ def __init__(self,
         # Persistent objects, like clamps, that exist as long
         # as the object exists
         self.persistent: list[HocObjectType] = []
+        self._local_to_global_matrix: Optional[np.ndarray] = None
+
+    def set_local_to_global_matrix(
+        self, position: np.ndarray, quaternion: Optional[np.ndarray] = None
+    ) -> None:
+        """Set the local-to-global coordinate transform for this cell.
+
+        The transform is a 3x4 matrix [R | t] built from a unit
+        quaternion (w, x, y, z) and a 3D translation vector.  If
+        *quaternion* is None, only the translation is applied (identity
+        rotation).
+        """
+        matrix = np.eye(3, 4, dtype=np.float64)
+        if quaternion is not None:
+            w, x, y, z = quaternion
+            # Normalised quaternion → 3×3 rotation matrix
+            xx, yy, zz = x * x, y * y, z * z
+            xy, xz, yz = x * y, x * z, y * z
+            wx, wy, wz = w * x, w * y, w * z
+            r = np.array(
+                [
+                    [1.0 - 2 * (yy + zz), 2 * (xy - wz), 2 * (xz + wy)],
+                    [2 * (xy + wz), 1.0 - 2 * (xx + zz), 2 * (yz - wx)],
+                    [2 * (xz - wy), 2 * (yz + wx), 1.0 - 2 * (xx + yy)],
+                ],
+                dtype=np.float64,
+            )
+            matrix[:, :3] = r
+        matrix[:, 3] = position
+        self._local_to_global_matrix = matrix
+
+    def local_to_global_coord_mapping(self, points: np.ndarray) -> np.ndarray:
+        """Apply the local-to-global coordinate transform to *points*.
+
+        Args:
+            points: array of shape (N, 3) with local coordinates.
+
+        Returns:
+            Array of shape (N, 3) with global coordinates.
+        """
+        if self._local_to_global_matrix is None:
+            return points
+        return points @ self._local_to_global_matrix[:, :3].T + self._local_to_global_matrix[:, 3]
 
     def _init_psections(self) -> None:
         """Initialize the psections of the cell."""
@@ -483,7 +526,6 @@ def create_netcon_spikedetector(self, target: HocObjectType, location: str, thre
 
                 - The position is out of bounds (e.g., negative or greater than 1.0).
         """
-
         if location == "soma":
             sec = public_hoc_cell(self.cell).soma[0]
             source = sec(1)._ref_v
@@ -785,7 +827,6 @@ def add_variable_recording(
             segx: Segment position between 0 and 1.
             dt: Optional recording time step.
         """
-
         if section is None:
             section = self.soma
 
@@ -835,8 +876,8 @@ def n_segments(self) -> int:
         """Get the number of segments in the cell."""
         return sum(section.nseg for section in self.sections.values())
 
-    def compute_segment_coordinates(self) -> dict[str, np.ndarray]:
-        """Compute 3D coordinates of segment endpoints for all sections.
+    def compute_segment_local_coordinates(self) -> dict[str, np.ndarray]:
+        """Compute local 3D coordinates of segment endpoints for all sections.
 
         Extracts 3D point data from NEURON sections and interpolates segment
         boundary positions along the section axis. Used for extracellular
@@ -880,6 +921,29 @@ def compute_segment_coordinates(self) -> dict[str, np.ndarray]:
 
         return segment_coords
 
+    compute_segment_coordinates = compute_segment_local_coordinates
+
+    def compute_segment_global_coordinates(self) -> dict[str, np.ndarray]:
+        """Compute global 3D coordinates of segment endpoints for all sections.
+
+        Same as :meth:`compute_segment_local_coordinates` but with the
+        local-to-global transform applied (if set via
+        :meth:`set_local_to_global_matrix`).
+
+        Returns:
+            Dictionary mapping section names to arrays of shape (nseg+1, 3)
+            containing [x, y, z] global coordinates in micrometers.
+            Sections without 3D point data return empty arrays.
+        """
+        local_coords = self.compute_segment_local_coordinates()
+        global_coords = {}
+        for sec_name, coords in local_coords.items():
+            if len(coords) == 0:
+                global_coords[sec_name] = coords
+            else:
+                global_coords[sec_name] = self.local_to_global_coord_mapping(coords)
+        return global_coords
+
     @staticmethod
     def get_segment_position(
         sec_seg_points: np.ndarray,
@@ -888,8 +952,9 @@ def get_segment_position(
         x: float,
         func_loc2glob: Optional[Callable[[np.ndarray], np.ndarray]] = None,
     ) -> Optional[np.ndarray]:
-        """Get the global coordinates of the segment. For axon and myelin,
-        interpolate along the y-axis of the local soma coordinates, and then
+        """Get the global coordinates of the segment.
+
+        For axon and myelin, interpolate along the y-axis of the local soma coordinates, and then
         convert to global coordinates.
 
         Args:
@@ -1042,8 +1107,12 @@ def delete(self):
         """Delete the cell."""
         self.delete_plottable()
         if hasattr(self, 'cell') and self.cell is not None:
-            if public_hoc_cell(self.cell) is not None and hasattr(public_hoc_cell(self.cell), 'clear'):
-                public_hoc_cell(self.cell).clear()
+            try:
+                hoc_cell = public_hoc_cell(self.cell)
+            except BluecellulabError:
+                hoc_cell = None
+            if hoc_cell is not None and hasattr(hoc_cell, 'clear'):
+                hoc_cell.clear()
 
             self.connections = None
             self.synapses = None
@@ -1233,7 +1302,6 @@ def add_currents_recordings(
     ) -> list[str]:
         """Record all available currents (ionic + optionally nonspecific) at
         (section, segx)."""
-
         # discover what’s available at this site
         available = currents_vars(section)
         chosen: list[str] = []
diff --git a/bluecellulab/circuit/circuit_access/sonata_circuit_access.py b/bluecellulab/circuit/circuit_access/sonata_circuit_access.py
index 13c4d27d..84b0cbdc 100644
--- a/bluecellulab/circuit/circuit_access/sonata_circuit_access.py
+++ b/bluecellulab/circuit/circuit_access/sonata_circuit_access.py
@@ -25,6 +25,7 @@
 from bluepysnap.exceptions import BluepySnapError
 from bluepysnap import Circuit as SnapCircuit
 import neuron
+import numpy as np
 import pandas as pd
 from bluecellulab import circuit
 from bluecellulab.circuit.circuit_access.definition import CircuitAccess, EmodelProperties
@@ -93,6 +94,35 @@ def get_cell_properties(
             cell_id.id, properties=properties
         )
 
+    def get_cell_position_rotation(
+        self, cell_id: CellId
+    ) -> tuple[np.ndarray, Optional[np.ndarray]]:
+        """Return (position, quaternion) for a SONATA cell if available.
+
+        Position is a 3-element ndarray [x, y, z].
+        Quaternion is a 4-element ndarray [w, x, y, z] or None.
+        Returns (zeros, None) when the attributes are not present.
+        """
+        node_pop = self._circuit.nodes[cell_id.population_name]
+        props = node_pop.get(cell_id.id)
+        if "x" in props and "y" in props and "z" in props:
+            position = np.array(
+                [props["x"], props["y"], props["z"]], dtype=np.float64
+            )
+            orientation_keys = (
+                "orientation_w",
+                "orientation_x",
+                "orientation_y",
+                "orientation_z",
+            )
+            if all(k in props for k in orientation_keys):
+                quaternion = np.array(
+                    [props[k] for k in orientation_keys], dtype=np.float64
+                )
+                return position, quaternion
+            return position, None
+        return np.zeros(3, dtype=np.float64), None
+
     @staticmethod
     def _compute_pop_ids(source: str, target: str) -> tuple[int, int]:
         """Compute the population ids from the population names."""
diff --git a/bluecellulab/circuit_simulation.py b/bluecellulab/circuit_simulation.py
index 5f32c2f7..7c16135a 100644
--- a/bluecellulab/circuit_simulation.py
+++ b/bluecellulab/circuit_simulation.py
@@ -452,12 +452,22 @@ def _add_stimuli(
                 gids_of_target = self.circuit_access.get_target_cell_ids(
                     stimulus.node_set
                 )
-                for cell_id in self.cells:
-                    if cell_id not in gids_of_target:
-                        continue
-                    sec = self.cells[cell_id].soma
-                    sec_name = sec.name().split(".")[-1]
-                    targets.append((cell_id, sec, 0.5, sec_name))
+                if isinstance(stimulus, circuit_stimulus_definitions.SpatiallyUniformEField):
+                    # Neurodamus target_point_list includes all sections of each cell.
+                    for cell_id in self.cells:
+                        if cell_id not in gids_of_target:
+                            continue
+                        cell = self.cells[cell_id]
+                        for sec in cell.sections.values():
+                            sec_name = sec.name().split(".")[-1]
+                            targets.append((cell_id, sec, 0.5, sec_name))
+                else:
+                    for cell_id in self.cells:
+                        if cell_id not in gids_of_target:
+                            continue
+                        sec = self.cells[cell_id].soma
+                        sec_name = sec.name().split(".")[-1]
+                        targets.append((cell_id, sec, 0.5, sec_name))
             else:
                 raise ValueError(
                     f"Stimulus '{stimulus}' has neither node_set nor compartment_set; "
@@ -615,57 +625,71 @@ def _add_extracellular_stimulus(
                 self._efield_sources[cell_id] += new_es
 
             es = self._efield_sources[cell_id]
-            segment_coords = cell.compute_segment_coordinates()
+            segment_coords_local = cell.compute_segment_local_coordinates()
+            segment_coords_global = cell.compute_segment_global_coordinates()
 
-            soma_coords_all = segment_coords.get(cell.soma.name())
-            if soma_coords_all is None or len(soma_coords_all) == 0:
+            soma_coords_global = segment_coords_global.get(cell.soma.name())
+            if soma_coords_global is None or len(soma_coords_global) == 0:
                 logger.warning(
                     f"Cell {cell_id} soma has no 3D coordinates, "
                     "cannot apply extracellular stimulus"
                 )
                 continue
 
-            soma_position = np.mean(soma_coords_all, axis=0)
+            soma_position_global = np.mean(soma_coords_global, axis=0)
+            soma_position_local = np.mean(
+                segment_coords_local.get(cell.soma.name(), soma_coords_global),
+                axis=0,
+            )
+
+            def local_to_global(pos: np.ndarray) -> np.ndarray:
+                stacked = np.vstack([soma_position_local, pos])
+                transformed = cell.local_to_global_coord_mapping(stacked)
+                return transformed[1]
 
             n_segments = 0
-            for sec in cell.sections.values():
-                for seg in sec:
-                    segx = seg.x
-                    sec_coords = segment_coords.get(sec.name())
-                    segment_position = None
+            for sec, segx in seg_list:
+                segment_position = None
 
-                    if sec_coords is None or len(sec_coords) == 0:
+                if "soma" in sec.name():
+                    segment_position = soma_position_global
+                else:
+                    sec_coords = segment_coords_global.get(sec.name())
+                    if sec_coords is not None and len(sec_coords) > 0:
+                        seg_idx = int(segx * sec.nseg)
+                        if seg_idx >= len(sec_coords):
+                            seg_idx = len(sec_coords) - 1
+                        segment_position = sec_coords[seg_idx]
+                    elif not sec.n3d():
                         # Try axon/myelin interpolation for sections without 3D points
-                        if not sec.n3d():
-                            try:
-                                segment_position = cell.get_segment_position(
-                                    np.array([]), soma_position, sec, segx, func_loc2glob=None
-                                )
-                            except ValueError:
-                                logger.warning(
-                                    f"Section {sec.name()} has no 3D coordinates and "
-                                    "could not interpolate, skipping"
-                                )
-                                continue
-                        else:
+                        try:
+                            segment_position = cell.get_segment_position(
+                                np.array([]),
+                                soma_position_local,
+                                sec,
+                                segx,
+                                func_loc2glob=local_to_global,
+                            )
+                        except ValueError:
                             logger.warning(
-                                f"Section {sec.name()} has no 3D coordinates, skipping"
+                                f"Section {sec.name()} has no 3D coordinates and "
+                                "could not interpolate, skipping"
                             )
                             continue
                     else:
-                        seg_idx = int(segx * sec.nseg)
-                        if seg_idx >= len(sec_coords):
-                            seg_idx = len(sec_coords) - 1
-                        segment_position = sec_coords[seg_idx]
-
-                    if segment_position is None:
+                        logger.warning(
+                            f"Section {sec.name()} has no 3D coordinates, skipping"
+                        )
                         continue
 
-                    displacement_vec = (segment_position - soma_position) * 1e-6
+                if segment_position is None:
+                    continue
+
+                displacement_vec = (segment_position - soma_position_global) * 1e-6
 
-                    segment = sec(segx)
-                    es.segment_displacements[segment] = displacement_vec
-                    n_segments += 1
+                segment = sec(segx)
+                es.segment_displacements[segment] = displacement_vec
+                n_segments += 1
 
             logger.debug(
                 f"Added extracellular stimulus to cell {cell_id} "
@@ -979,6 +1003,13 @@ def _add_cells(self, cell_ids: list[CellId]) -> None:
             self.cells[cell_id] = cell
             if self.circuit_access.node_properties_available:
                 cell.connect_to_circuit(SonataProxy(cell_id, self.circuit_access))
+                # Set local-to-global transform if position data is available.
+                if hasattr(self.circuit_access, "get_cell_position_rotation"):
+                    try:
+                        position, quaternion = self.circuit_access.get_cell_position_rotation(cell_id)
+                        cell.set_local_to_global_matrix(position, quaternion)
+                    except (KeyError, ValueError):
+                        pass
 
     def _apply_modifications(self) -> None:
         """Apply condition modifications from the simulation config to
diff --git a/tests/test_cell/test_segment_coordinates.py b/tests/test_cell/test_segment_coordinates.py
new file mode 100644
index 00000000..7b0497c5
--- /dev/null
+++ b/tests/test_cell/test_segment_coordinates.py
@@ -0,0 +1,150 @@
+"""Tests for cell coordinate helpers."""
+from unittest.mock import MagicMock, patch
+
+import numpy as np
+import pytest
+import neuron
+from bluecellulab.cell.core import Cell
+from bluecellulab.circuit.node_id import CellId
+
+
+def _patched_public_hoc_cell(sections_cache):
+    """Return a mock public_hoc_cell that exposes .all."""
+    def _mock(cell):
+        m = MagicMock()
+        m.all = list(sections_cache.values())
+        return m
+    return _mock
+
+
+@pytest.fixture
+def simple_cell():
+    soma = neuron.h.Section(name="soma")
+    soma.nseg = 1
+    soma.L = 10.0
+    soma.diam = 10.0
+    neuron.h.pt3dadd(0, 0, 0, 10, sec=soma)
+    neuron.h.pt3dadd(10, 0, 0, 10, sec=soma)
+    dend = neuron.h.Section(name="dend[0]")
+    dend.nseg = 3
+    dend.L = 100.0
+    dend.diam = 2.0
+    dend.connect(soma(1), 0)
+    neuron.h.pt3dadd(10, 0, 0, 2, sec=dend)
+    neuron.h.pt3dadd(110, 0, 0, 2, sec=dend)
+    cell = Cell.__new__(Cell)
+    cell.cell_id = CellId("", 0)
+    cell.cell = neuron.h.Cell()
+    cell.soma = soma
+    cell._sections_cache = {"soma": soma, "dend[0]": dend}
+    cell._local_to_global_matrix = None
+    return cell
+
+
+def test_local_coords(simple_cell):
+    with patch("bluecellulab.cell.core.public_hoc_cell", _patched_public_hoc_cell(simple_cell._sections_cache)):
+        coords = simple_cell.compute_segment_local_coordinates()
+    assert "soma" in coords
+    assert "dend[0]" in coords
+    assert coords["soma"].shape == (2, 3)
+    assert coords["dend[0]"].shape == (4, 3)
+
+
+def test_global_coords_identity():
+    soma = neuron.h.Section(name="soma")
+    soma.nseg = 1
+    soma.L = 10.0
+    neuron.h.pt3dadd(5, 5, 5, 10, sec=soma)
+    neuron.h.pt3dadd(15, 5, 5, 10, sec=soma)
+    cell = Cell.__new__(Cell)
+    cell.cell_id = CellId("", 1)
+    cell.cell = neuron.h.Cell()
+    cell.soma = soma
+    cell._sections_cache = {"soma": soma}
+    cell._local_to_global_matrix = None
+    with patch("bluecellulab.cell.core.public_hoc_cell", _patched_public_hoc_cell(cell._sections_cache)):
+        local_c = cell.compute_segment_local_coordinates()
+        global_c = cell.compute_segment_global_coordinates()
+    np.testing.assert_array_equal(local_c["soma"], global_c["soma"])
+
+
+def test_l2g_identity():
+    cell = Cell.__new__(Cell)
+    cell.cell_id = CellId("", 2)
+    cell.cell = neuron.h.Cell()
+    cell.soma = neuron.h.Section(name="soma")
+    cell.set_local_to_global_matrix(np.array([10.0, 20.0, 30.0]), np.array([1.0, 0.0, 0.0, 0.0]))
+    pts = np.array([[1.0, 0.0, 0.0]])
+    np.testing.assert_allclose(cell.local_to_global_coord_mapping(pts), [[11.0, 20.0, 30.0]])
+
+
+def test_l2g_90z():
+    cell = Cell.__new__(Cell)
+    cell.cell_id = CellId("", 3)
+    cell.cell = neuron.h.Cell()
+    cell.soma = neuron.h.Section(name="soma")
+    angle = np.pi / 4
+    cell.set_local_to_global_matrix(np.zeros(3), np.array([np.cos(angle), 0.0, 0.0, np.sin(angle)]))
+    pts = np.array([[1.0, 0.0, 0.0]])
+    np.testing.assert_allclose(cell.local_to_global_coord_mapping(pts)[0], [0.0, 1.0, 0.0], atol=1e-6)
+
+
+def test_l2g_translation_only():
+    cell = Cell.__new__(Cell)
+    cell.cell_id = CellId("", 4)
+    cell.cell = neuron.h.Cell()
+    cell.soma = neuron.h.Section(name="soma")
+    cell.set_local_to_global_matrix(np.array([5.0, -3.0, 2.0]), None)
+    pts = np.array([[1.0, 2.0, 3.0]])
+    np.testing.assert_allclose(cell.local_to_global_coord_mapping(pts), [[6.0, -1.0, 5.0]])
+
+
+def test_get_seg_pos_3d():
+    sec = neuron.h.Section(name="testsec")
+    sec.nseg = 2
+    sec.L = 100.0
+    neuron.h.pt3dadd(0, 0, 0, 2, sec=sec)
+    neuron.h.pt3dadd(100, 0, 0, 2, sec=sec)
+    pts = np.array([[0, 0, 0], [50, 0, 0], [100, 0, 0]])
+    np.testing.assert_allclose(Cell.get_segment_position(pts, np.zeros(3), sec, 0.0), [0, 0, 0])
+    np.testing.assert_allclose(Cell.get_segment_position(pts, np.zeros(3), sec, 0.5), [50, 0, 0])
+    np.testing.assert_allclose(Cell.get_segment_position(pts, np.zeros(3), sec, 1.0), [100, 0, 0])
+
+
+def test_get_seg_pos_axon():
+    axon = neuron.h.Section(name="axon[0]")
+    axon.nseg = 1
+    axon.L = 30.0
+    soma_pos = np.array([10.0, 20.0, 30.0])
+    pos = Cell.get_segment_position(np.array([]), soma_pos, axon, 0.5, func_loc2glob=None)
+    np.testing.assert_allclose(pos, [10.0, 5.0, 30.0])
+
+
+def test_get_seg_pos_axon_l2g():
+    axon = neuron.h.Section(name="axon[0]")
+    axon.nseg = 1
+    axon.L = 30.0
+    soma_pos = np.array([1.0, 0.0, 0.0])
+    pos = Cell.get_segment_position(np.array([]), soma_pos, axon, 0.5, func_loc2glob=lambda p: p + 10.0)
+    np.testing.assert_allclose(pos, [11.0, -5.0, 10.0])
+
+
+def test_get_seg_pos_value_error():
+    sec = neuron.h.Section(name="dend_sec")
+    sec.nseg = 1
+    sec.L = 10.0
+    with pytest.raises(ValueError, match="has no 3d points defined"):
+        Cell.get_segment_position(np.array([]), np.zeros(3), sec, 0.5)
+
+
+def test_no_3d_warning(simple_cell, caplog):
+    axon = neuron.h.Section(name="axon[0]")
+    axon.nseg = 1
+    axon.L = 30.0
+    axon.connect(simple_cell._sections_cache["dend[0]"](1), 0)
+    simple_cell._sections_cache["axon[0]"] = axon
+    with patch("bluecellulab.cell.core.public_hoc_cell", _patched_public_hoc_cell(simple_cell._sections_cache)):
+        with caplog.at_level("WARNING", logger="bluecellulab.cell.core"):
+            coords = simple_cell.compute_segment_local_coordinates()
+    assert coords["axon[0]"].size == 0
+    assert "has no 3D points" in caplog.text
diff --git a/tests/test_stimulus/test_efield_integration.py b/tests/test_stimulus/test_efield_integration.py
new file mode 100644
index 00000000..7b7cfad4
--- /dev/null
+++ b/tests/test_stimulus/test_efield_integration.py
@@ -0,0 +1,129 @@
+"""Integration tests for spatially-uniform e-field stimulus (PR #82)."""
+from pathlib import Path
+from unittest.mock import patch
+
+import numpy as np
+
+from bluecellulab import CircuitSimulation
+from bluecellulab.stimulus import circuit_stimulus_definitions
+
+parent_dir = Path(__file__).resolve().parent.parent.parent
+
+
+def _fake_efield(node_set="Mosaic_A", compartment_set=None):
+    """Return a minimal SpatiallyUniformEField stimulus."""
+    target = compartment_set if compartment_set is not None else node_set
+    return circuit_stimulus_definitions.SpatiallyUniformEField(
+        target=target,
+        node_set=None if compartment_set is not None else node_set,
+        compartment_set=compartment_set,
+        fields=[{"Ex": 100, "Ey": 0, "Ez": 0, "frequency": 0}],
+        delay=0,
+        duration=10,
+        ramp_up_time=0,
+        ramp_down_time=0,
+    )
+
+
+def _instantiate_with_efield(sim, gids, **patches):
+    """Instantiate cells with the patched stimulus list and skip the apply step
+    so that segment_displacements stay populated for inspection."""
+    with patch.object(
+        sim,
+        "_apply_extracellular_stimuli",
+        lambda: None,
+    ):
+        with patch.object(
+            sim.circuit_access.config,
+            "get_all_stimuli_entries",
+            **patches,
+        ):
+            sim.instantiate_gids(
+                cells=gids,
+                add_stimuli=True,
+                add_extracellular_stimuli=True,
+            )
+
+
+def test_efield_targets_all_sections():
+    """EField stimulus on node_set should target all sections, not just soma."""
+    base = parent_dir / "examples" / "2-sonata-network" / "sim_quick_scx_sonata_multicircuit" / "simulation_config_noinput.json"
+    sim = CircuitSimulation(base)
+    target = sim.circuit_access.get_target_cell_ids("Mosaic_A")
+    gids = list(target)[:1]
+    _instantiate_with_efield(sim, gids, return_value=[_fake_efield()])
+    cell = sim.cells[gids[0]]
+    assert gids[0] in sim._efield_sources
+    es = sim._efield_sources[gids[0]]
+    assert es.segment_displacements is not None
+    assert len(es.segment_displacements) > 1
+
+
+def test_efield_soma_displacement_is_zero():
+    """Soma segments should have zero displacement vector."""
+    base = parent_dir / "examples" / "2-sonata-network" / "sim_quick_scx_sonata_multicircuit" / "simulation_config_noinput.json"
+    sim = CircuitSimulation(base)
+    target = sim.circuit_access.get_target_cell_ids("Mosaic_A")
+    gids = list(target)[:1]
+    _instantiate_with_efield(sim, gids, return_value=[_fake_efield()])
+    cell = sim.cells[gids[0]]
+    es = sim._efield_sources[gids[0]]
+    soma_seg = cell.soma(0.5)
+    assert soma_seg in es.segment_displacements
+    np.testing.assert_allclose(
+        es.segment_displacements[soma_seg], [0.0, 0.0, 0.0], atol=1e-12
+    )
+
+
+def test_efield_compartment_set_targets():
+    """EField stimulus should honour compartment_set targets."""
+    base = parent_dir / "examples" / "2-sonata-network" / "sim_quick_scx_sonata_multicircuit" / "simulation_config_noinput.json"
+    sim = CircuitSimulation(base)
+    target = sim.circuit_access.get_target_cell_ids("Mosaic_A")
+    gids = list(target)[:1]
+    fake_compartment_sets = {
+        "dend_only": {
+            "population": gids[0].population_name,
+            "compartment_set": [[gids[0].id, 1, 0.5]],
+        }
+    }
+    with patch.object(
+        sim.circuit_access.config,
+        "get_compartment_sets",
+        return_value=fake_compartment_sets,
+    ):
+        _instantiate_with_efield(
+            sim, gids, return_value=[_fake_efield(compartment_set="dend_only")]
+        )
+    cell = sim.cells[gids[0]]
+    es = sim._efield_sources[gids[0]]
+    assert es.segment_displacements is not None
+    # Should have at least one segment displacement, and soma(0.5) is not present.
+    assert len(es.segment_displacements) >= 1
+    assert cell.soma(0.5) not in es.segment_displacements
+
+
+def test_get_cell_position_rotation_returns_quaternion():
+    """SonataCircuitAccess returns position and quaternion when present."""
+    base = parent_dir / "examples" / "2-sonata-network" / "sim_quick_scx_sonata_multicircuit" / "simulation_config_noinput.json"
+    sim = CircuitSimulation(base)
+    target = sim.circuit_access.get_target_cell_ids("Mosaic_A")
+    gid = next(iter(target))
+    pos, quat = sim.circuit_access.get_cell_position_rotation(gid)
+    assert pos.shape == (3,)
+    assert quat is not None
+    assert quat.shape == (4,)
+
+
+def test_cell_transform_is_populated():
+    """Cell transform should be populated during instantiate_gids when SONATA coords exist."""
+    base = parent_dir / "examples" / "2-sonata-network" / "sim_quick_scx_sonata_multicircuit" / "simulation_config_noinput.json"
+    sim = CircuitSimulation(base)
+    target = sim.circuit_access.get_target_cell_ids("Mosaic_A")
+    gid = next(iter(target))
+    sim.instantiate_gids(cells=[gid])
+    cell = sim.cells[gid]
+    assert cell._local_to_global_matrix is not None
+    # Verify the translation part matches SONATA node position
+    pos, _ = sim.circuit_access.get_cell_position_rotation(gid)
+    np.testing.assert_allclose(cell._local_to_global_matrix[:, 3], pos)
diff --git a/tests/test_stimulus/test_extracellular.py b/tests/test_stimulus/test_extracellular.py
index 14c0363c..91fb3469 100644
--- a/tests/test_stimulus/test_extracellular.py
+++ b/tests/test_stimulus/test_extracellular.py
@@ -370,3 +370,43 @@ def test_interp_myelin_positions_error():
 
     with pytest.raises(ValueError, match="More than 1 myelin section exist"):
         Cell.interp_myelin_positions(0.5, 1, soma_position)
+
+
+def test_apply_segment_potentials_inserts_extracellular():
+    """Test that apply_segment_potentials inserts the extracellular mechanism."""
+    import neuron
+
+    es = ElectrodeSource(
+        base_amp=0,
+        delay=0,
+        duration=2,
+        fields=[{"Ex": 100, "Ey": 0, "Ez": 0, "frequency": 0}],
+        ramp_up_time=0,
+        ramp_down_time=0,
+        dt=1.0,
+    )
+    # Create a minimal section with one segment
+    sec = neuron.h.Section(name="testsec")
+    sec.nseg = 1
+    seg = sec(0.5)
+    assert not sec.has_membrane("extracellular")
+    es.segment_displacements[seg] = np.array([1e-6, 0.0, 0.0])
+    es.apply_segment_potentials()
+    assert sec.has_membrane("extracellular")
+
+
+def test_combine_time_efields_disjoint_reverse_order():
+    """Test _combine_time_efields when t1 is strictly after t2."""
+    dt = 1.0
+    t1 = np.array([5.0, 6.0, 7.0])
+    e1 = np.ones((3, 3))
+    t2 = np.array([0.0, 1.0, 2.0])
+    e2 = np.ones((3, 3)) * 2
+    combined_t, combined_e = ElectrodeSource._combine_time_efields(
+        t1, e1, t2, e2, False, False, dt
+    )
+    expected_t = np.array([0.0, 1.0, 2.0, 5.0, 6.0, 7.0])
+    np.testing.assert_allclose(combined_t, expected_t)
+    assert combined_e.shape == (3, 6)
+    np.testing.assert_allclose(combined_e[:, :3], e2)
+    np.testing.assert_allclose(combined_e[:, 3:], e1)

From 8d70b20bf032bf9197b06a3bbb00e65f3dac4526 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Wed, 29 Apr 2026 13:16:09 +0200
Subject: [PATCH 12/14] update notebook results

---
 .../extracellular-efield-stimulus.ipynb       | 33 ++++++++++++-------
 1 file changed, 21 insertions(+), 12 deletions(-)

diff --git a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
index dff7507a..8da9ab61 100644
--- a/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
+++ b/examples/2-sonata-network/extracellular-efield-stimulus.ipynb
@@ -158,9 +158,9 @@
     "# Create simulation\n",
     "sim = CircuitSimulation(modified_config_path)\n",
     "\n",
-    "# Select a few cells from the target population\n",
+    "# Select a few cells from the target population and sort them to have [id=0, id=1, id=2]\n",
     "target_cells = sim.circuit_access.get_target_cell_ids(\"Mosaic_A\")\n",
-    "cells_to_simulate = list(target_cells)[:3]\n",
+    "cells_to_simulate = sorted(target_cells, key=lambda c: c.id)[:3]\n",
     "\n",
     "print(f\"Simulating {len(cells_to_simulate)} cells: {cells_to_simulate}\")"
    ]
@@ -183,15 +183,24 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "Section cNAC_L23BTC_bluecellulab_da083b03534845b48cdfd8b406265650[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_da083b03534845b48cdfd8b406265650[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_da083b03534845b48cdfd8b406265650[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_902a11d68e21497f839c788402f3a3ec[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_902a11d68e21497f839c788402f3a3ec[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
-      "Section cNAC_L23BTC_bluecellulab_902a11d68e21497f839c788402f3a3ec[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cADpyr_L2TPC_bluecellulab_ff297d0e788c4afea357b943aa3f863b[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
-      "Section cADpyr_L2TPC_bluecellulab_ff297d0e788c4afea357b943aa3f863b[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
-      "Section cADpyr_L2TPC_bluecellulab_ff297d0e788c4afea357b943aa3f863b[0].myelin[0] has no 3D points, cannot compute segment coordinates\n"
+      "Section cNAC_L23BTC_bluecellulab_eaa2264807614006a786fd24d3ed3ac1[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_eaa2264807614006a786fd24d3ed3ac1[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_eaa2264807614006a786fd24d3ed3ac1[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_eaa2264807614006a786fd24d3ed3ac1[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_eaa2264807614006a786fd24d3ed3ac1[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_eaa2264807614006a786fd24d3ed3ac1[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_68f5db97c24c45f28c8fe405c2d7ce92[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_68f5db97c24c45f28c8fe405c2d7ce92[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_68f5db97c24c45f28c8fe405c2d7ce92[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_68f5db97c24c45f28c8fe405c2d7ce92[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_68f5db97c24c45f28c8fe405c2d7ce92[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cNAC_L23BTC_bluecellulab_68f5db97c24c45f28c8fe405c2d7ce92[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b39caeaf01114e0296ac87544085a895[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b39caeaf01114e0296ac87544085a895[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b39caeaf01114e0296ac87544085a895[0].myelin[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b39caeaf01114e0296ac87544085a895[0].axon[0] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b39caeaf01114e0296ac87544085a895[0].axon[1] has no 3D points, cannot compute segment coordinates\n",
+      "Section cADpyr_L2TPC_bluecellulab_b39caeaf01114e0296ac87544085a895[0].myelin[0] has no 3D points, cannot compute segment coordinates\n"
      ]
     },
     {
@@ -272,7 +281,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x900 with 3 Axes>"
       ]

From 7b3a929aef69849fd221e79f944a83940817f823 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Wed, 29 Apr 2026 13:22:48 +0200
Subject: [PATCH 13/14] lint: docformatter fix in sonata_circuit_access

---
 .../circuit/circuit_access/sonata_circuit_access.py         | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/bluecellulab/circuit/circuit_access/sonata_circuit_access.py b/bluecellulab/circuit/circuit_access/sonata_circuit_access.py
index 84b0cbdc..dca79184 100644
--- a/bluecellulab/circuit/circuit_access/sonata_circuit_access.py
+++ b/bluecellulab/circuit/circuit_access/sonata_circuit_access.py
@@ -99,9 +99,9 @@ def get_cell_position_rotation(
     ) -> tuple[np.ndarray, Optional[np.ndarray]]:
         """Return (position, quaternion) for a SONATA cell if available.
 
-        Position is a 3-element ndarray [x, y, z].
-        Quaternion is a 4-element ndarray [w, x, y, z] or None.
-        Returns (zeros, None) when the attributes are not present.
+        Position is a 3-element ndarray [x, y, z]. Quaternion is a
+        4-element ndarray [w, x, y, z] or None. Returns (zeros, None)
+        when the attributes are not present.
         """
         node_pop = self._circuit.nodes[cell_id.population_name]
         props = node_pop.get(cell_id.id)

From 610b608821e787895acb9e12a4d59160781c0636 Mon Sep 17 00:00:00 2001
From: "@darshanmandge" <darshanmandge@users.noreply.github.com>
Date: Wed, 29 Apr 2026 17:44:41 +0200
Subject: [PATCH 14/14] docformatter 1.7.8 has tokenisation regressions; pin
 until upstream fixes

---
 tox.ini | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tox.ini b/tox.ini
index 2fd7e135..b864d694 100644
--- a/tox.ini
+++ b/tox.ini
@@ -41,7 +41,8 @@ deps =
     pandas-stubs>=2.0.0
     types-setuptools>=67.8.0.0
     ruff>=0.0.270
-    docformatter>=1.7.2
+    # docformatter 1.7.8 has tokenisation regressions; pin until upstream fixes
+    docformatter>=1.7.2,<1.7.8
 commands =
     ruff check . --select F541,F401 --per-file-ignores="__init__.py:F401"
     pycodestyle {[base]name} --ignore=E501,W504,W503