diff --git a/CHANGELOG.rst b/CHANGELOG.rst
index ffcaf8d1..2289a457 100644
--- a/CHANGELOG.rst
+++ b/CHANGELOG.rst
@@ -1,6 +1,16 @@
 Changelog
 ==========
 
+2.4.0
+------
+
+* Add StimulusFactory enabling Python generated Stimulus creation
+* Stimulus creation through StimulusFactory is decoupled from the Cell object
+* Cell.add_step and Cell.add_ramp use StimulusFactory
+* Move stimuli module to stimulus/circuit_stimulus_definitions
+* [DOCS] Add list of stimuli page that describe, generate and plot the stimuli
+* Add jupyter notebook displaying how to inject the StimulusFactory Stimulus into Cell
+
 2.3.0
 -------
 
diff --git a/bluecellulab/cell/core.py b/bluecellulab/cell/core.py
index ed2d2419..81b49455 100644
--- a/bluecellulab/cell/core.py
+++ b/bluecellulab/cell/core.py
@@ -41,7 +41,7 @@
 from bluecellulab.importer import load_hoc_and_mod_files
 from bluecellulab.neuron_interpreter import eval_neuron
 from bluecellulab.rngsettings import RNGSettings
-from bluecellulab.stimuli import SynapseReplay
+from bluecellulab.stimulus.circuit_stimulus_definitions import SynapseReplay
 from bluecellulab.synapse import SynapseFactory, Synapse
 from bluecellulab.synapse.synapse_types import SynapseID
 from bluecellulab.type_aliases import HocObjectType, NeuronSection
diff --git a/bluecellulab/cell/injector.py b/bluecellulab/cell/injector.py
index e0061823..33c8bdcc 100644
--- a/bluecellulab/cell/injector.py
+++ b/bluecellulab/cell/injector.py
@@ -12,7 +12,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 """Contains injection functionality for the cell."""
-
+from __future__ import annotations
 import math
 import warnings
 import logging
@@ -27,7 +27,7 @@
     get_relative_shotnoise_params,
 )
 from bluecellulab.exceptions import BluecellulabError
-from bluecellulab.stimuli import (
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
     ClampMode,
     Hyperpolarizing,
     Noise,
@@ -36,7 +36,8 @@
     RelativeOrnsteinUhlenbeck,
     RelativeShotNoise,
 )
-from bluecellulab.type_aliases import HocObjectType
+from bluecellulab.stimulus.factory import StimulusFactory
+from bluecellulab.type_aliases import NeuronSection
 
 
 logger = logging.getLogger(__name__)
@@ -69,36 +70,62 @@ def add_pulse(self, stimulus):
         self.persistent.append(tstim)
         return tstim
 
-    def add_step(self, start_time, stop_time, level, section=None, segx=0.5):
-        """Add a step current injection."""
-        if section is None:
-            section = self.soma
-
-        tstim = neuron.h.TStim(segx, sec=section)
-        duration = stop_time - start_time
-        tstim.pulse(start_time, duration, level)
-        self.persistent.append(tstim)
-        return tstim
+    def add_step(
+        self,
+        start_time: float,
+        stop_time: float,
+        level: float,
+        section: NeuronSection | None = None,
+        segx: float = 0.5,
+        dt: float = 0.025
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Add a step current injection.
 
-    def add_ramp(self, start_time, stop_time, start_level, stop_level,
-                 section=None, segx=0.5):
-        """Add a ramp current injection."""
-        if section is None:
-            section = self.soma
+        Args:
+            start_time: Start time of the step injection in seconds.
+            stop_time: Stop time of the step injection in seconds.
+            level: Current level to inject in nanoamperes (nA).
+            section: The section to inject current into.
+                Defaults to the soma section.
+            segx: The fractional location within the section to inject.
+                Defaults to 0.5 (center of the section).
+
+        Returns:
+            Tuple of time and current data.
+        """
+        stim = StimulusFactory(dt=dt).step(start_time, stop_time, level)
+        t_content, i_content = stim.time, stim.current
+        self.inject_current_waveform(t_content, i_content, section, segx)
+        return (t_content, i_content)
 
-        tstim = neuron.h.TStim(segx, sec=section)
+    def add_ramp(
+        self,
+        start_time: float,
+        stop_time: float,
+        start_level: float,
+        stop_level: float,
+        section: NeuronSection | None = None,
+        segx: float = 0.5,
+        dt: float = 0.025
+    ) -> tuple[np.ndarray, np.ndarray]:
+        """Add a ramp current injection.
 
-        tstim.ramp(
-            0.0,
-            start_time,
-            start_level,
-            stop_level,
-            stop_time - start_time,
-            0.0,
-            0.0)
+        Args:
+            start_time: Start time of the ramp injection in seconds.
+            stop_time: Stop time of the ramp injection in seconds.
+            start_level: Current level at the start of the ramp in nanoamperes (nA).
+            stop_level: Current level at the end of the ramp in nanoamperes (nA).
+            section: The section to inject current into (optional). Defaults to soma.
+            segx: The fractional location within the section to inject (optional).
+
+        Returns:
+            A tuple of numpy arrays containing time and current data.
+        """
+        stim = StimulusFactory(dt=dt).ramp(start_time, stop_time, start_level, stop_level)
+        t_content, i_content = stim.time, stim.current
+        self.inject_current_waveform(t_content, i_content, section, segx)
 
-        self.persistent.append(tstim)
-        return tstim
+        return t_content, i_content
 
     def add_voltage_clamp(
             self, stop_time, level, rs=None, section=None, segx=0.5,
@@ -395,32 +422,22 @@ def add_relative_ornstein_uhlenbeck(
         else:
             return self.inject_current_clamp_signal(section, segx, tvec, svec)
 
-    def inject_current_waveform(self, t_content, i_content, section=None,
-                                segx=0.5):
-        """Inject a custom current to the cell."""
-        start_time = t_content[0]
-        stop_time = t_content[-1]
-        time = neuron.h.Vector()
-        currents = neuron.h.Vector()
-        time = time.from_python(t_content)
-        currents = currents.from_python(i_content)
-
+    def inject_current_waveform(self, t_content, i_content, section=None, segx=0.5):
+        """Inject a custom current waveform into the cell."""
         if section is None:
             section = self.soma
+
+        time_vector = neuron.h.Vector().from_python(t_content)
+        current_vector = neuron.h.Vector().from_python(i_content)
+
         pulse = neuron.h.IClamp(segx, sec=section)
-        self.persistent.append(pulse)
-        self.persistent.append(time)
-        self.persistent.append(currents)
-        setattr(pulse, 'del', start_time)
-        pulse.dur = stop_time - start_time
-        currents.play(pulse._ref_amp, time)
-        return currents
-
-    @deprecated("Use inject_current_waveform instead.")
-    def injectCurrentWaveform(self, t_content, i_content, section=None,
-                              segx=0.5):
-        """Inject a current in the cell."""
-        return self.inject_current_waveform(t_content, i_content, section, segx)
+        self.persistent.extend([pulse, time_vector, current_vector])
+
+        pulse.delay = t_content[0]
+        pulse.dur = t_content[-1] - t_content[0]
+        current_vector.play(pulse._ref_amp, time_vector)
+
+        return current_vector
 
     @deprecated("Use add_sin_current instead.")
     def addSineCurrentInject(self, start_time, stop_time, freq,
@@ -435,7 +452,7 @@ def addSineCurrentInject(self, start_time, stop_time, freq,
         t_content = np.arange(start_time, stop_time, dt)
         i_content = [amplitude * math.sin(freq * (x - start_time) * (
             2 * math.pi)) + mid_level for x in t_content]
-        self.injectCurrentWaveform(t_content, i_content)
+        self.inject_current_waveform(t_content, i_content)
         return (t_content, i_content)
 
     def add_sin_current(self, amp, start_time, duration, frequency,
@@ -454,9 +471,9 @@ def add_alpha_synapse(
         tau: float,
         gmax: float,
         e: float,
-        section: HocObjectType,
+        section: NeuronSection,
         segx=0.5,
-    ) -> HocObjectType:
+    ) -> NeuronSection:
         """Add an AlphaSynapse NEURON point process stimulus to the cell."""
         syn = neuron.h.AlphaSynapse(segx, sec=section)
         syn.onset = onset
diff --git a/bluecellulab/circuit/config/bluepy_simulation_config.py b/bluecellulab/circuit/config/bluepy_simulation_config.py
index 2ff153fc..7ba8f4ee 100644
--- a/bluecellulab/circuit/config/bluepy_simulation_config.py
+++ b/bluecellulab/circuit/config/bluepy_simulation_config.py
@@ -25,7 +25,7 @@
     from bluepy.utils import open_utf8
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
 class BluepySimulationConfig:
diff --git a/bluecellulab/circuit/config/definition.py b/bluecellulab/circuit/config/definition.py
index d5daf397..b640e7e4 100644
--- a/bluecellulab/circuit/config/definition.py
+++ b/bluecellulab/circuit/config/definition.py
@@ -18,7 +18,7 @@
 
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 
 class SimulationConfig(Protocol):
diff --git a/bluecellulab/circuit/config/sonata_simulation_config.py b/bluecellulab/circuit/config/sonata_simulation_config.py
index 89317757..ab5af112 100644
--- a/bluecellulab/circuit/config/sonata_simulation_config.py
+++ b/bluecellulab/circuit/config/sonata_simulation_config.py
@@ -17,7 +17,7 @@
 from typing import Optional
 
 from bluecellulab.circuit.config.sections import Conditions, ConnectionOverrides
-from bluecellulab.stimuli import Stimulus
+from bluecellulab.stimulus.circuit_stimulus_definitions import Stimulus
 
 from bluepysnap import Simulation as SnapSimulation
 
diff --git a/bluecellulab/ssim.py b/bluecellulab/ssim.py
index 3c68b0b5..6cd1ed87 100644
--- a/bluecellulab/ssim.py
+++ b/bluecellulab/ssim.py
@@ -40,8 +40,8 @@
 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.importer import load_hoc_and_mod_files
-from bluecellulab.stimuli import Noise, OrnsteinUhlenbeck, RelativeOrnsteinUhlenbeck, RelativeShotNoise, ShotNoise
-import bluecellulab.stimuli as stimuli
+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,
@@ -298,40 +298,40 @@ def _add_stimuli(self, add_noise_stimuli=False,
             for cell_id in self.cells:
                 if cell_id not in gids_of_target:
                     continue
-                if isinstance(stimulus, stimuli.Noise):
+                if isinstance(stimulus, circuit_stimulus_definitions.Noise):
                     if add_noise_stimuli:
                         self.cells[cell_id].add_replay_noise(
                             stimulus, noisestim_count=noisestim_count)
-                elif isinstance(stimulus, stimuli.Hyperpolarizing):
+                elif isinstance(stimulus, circuit_stimulus_definitions.Hyperpolarizing):
                     if add_hyperpolarizing_stimuli:
                         self.cells[cell_id].add_replay_hypamp(stimulus)
-                elif isinstance(stimulus, stimuli.Pulse):
+                elif isinstance(stimulus, circuit_stimulus_definitions.Pulse):
                     if add_pulse_stimuli:
                         self.cells[cell_id].add_pulse(stimulus)
-                elif isinstance(stimulus, stimuli.RelativeLinear):
+                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeLinear):
                     if add_relativelinear_stimuli:
                         self.cells[cell_id].add_replay_relativelinear(stimulus)
-                elif isinstance(stimulus, stimuli.ShotNoise):
+                elif isinstance(stimulus, circuit_stimulus_definitions.ShotNoise):
                     if add_shotnoise_stimuli:
                         self.cells[cell_id].add_replay_shotnoise(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             shotnoise_stim_count=shotnoise_stim_count)
-                elif isinstance(stimulus, stimuli.RelativeShotNoise):
+                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeShotNoise):
                     if add_shotnoise_stimuli:
                         self.cells[cell_id].add_replay_relative_shotnoise(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             shotnoise_stim_count=shotnoise_stim_count)
-                elif isinstance(stimulus, stimuli.OrnsteinUhlenbeck):
+                elif isinstance(stimulus, circuit_stimulus_definitions.OrnsteinUhlenbeck):
                     if add_ornstein_uhlenbeck_stimuli:
                         self.cells[cell_id].add_ornstein_uhlenbeck(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             stim_count=ornstein_uhlenbeck_stim_count)
-                elif isinstance(stimulus, stimuli.RelativeOrnsteinUhlenbeck):
+                elif isinstance(stimulus, circuit_stimulus_definitions.RelativeOrnsteinUhlenbeck):
                     if add_ornstein_uhlenbeck_stimuli:
                         self.cells[cell_id].add_relative_ornstein_uhlenbeck(
                             self.cells[cell_id].soma, 0.5, stimulus,
                             stim_count=ornstein_uhlenbeck_stim_count)
-                elif isinstance(stimulus, stimuli.SynapseReplay):  # sonata only
+                elif isinstance(stimulus, circuit_stimulus_definitions.SynapseReplay):  # sonata only
                     if self.circuit_access.target_contains_cell(
                         stimulus.target, cell_id
                     ):
diff --git a/bluecellulab/stimulus/__init__.py b/bluecellulab/stimulus/__init__.py
new file mode 100644
index 00000000..9124499e
--- /dev/null
+++ b/bluecellulab/stimulus/__init__.py
@@ -0,0 +1 @@
+from .factory import StimulusFactory
diff --git a/bluecellulab/stimuli.py b/bluecellulab/stimulus/circuit_stimulus_definitions.py
similarity index 99%
rename from bluecellulab/stimuli.py
rename to bluecellulab/stimulus/circuit_stimulus_definitions.py
index e08dac35..a2e17f1a 100644
--- a/bluecellulab/stimuli.py
+++ b/bluecellulab/stimulus/circuit_stimulus_definitions.py
@@ -11,7 +11,11 @@
 # 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.
+"""Defines the expected data structures associated with the stimulus defined in
+simulation configs.
 
+Run-time validates the data via Pydantic.
+"""
 from __future__ import annotations
 
 from enum import Enum
diff --git a/bluecellulab/stimulus/factory.py b/bluecellulab/stimulus/factory.py
new file mode 100644
index 00000000..c62b90fc
--- /dev/null
+++ b/bluecellulab/stimulus/factory.py
@@ -0,0 +1,254 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+class Stimulus(ABC):
+    def __init__(self, dt: float) -> None:
+        self.dt = dt
+
+    @property
+    @abstractmethod
+    def time(self) -> np.ndarray:
+        """Time values of the stimulus."""
+        ...
+
+    @property
+    @abstractmethod
+    def current(self) -> np.ndarray:
+        """Current values of the stimulus."""
+        ...
+
+    def __len__(self) -> int:
+        return len(self.time)
+
+    @property
+    def stimulus_time(self) -> float:
+        return len(self) * self.dt
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}(dt={self.dt})"
+
+    def plot(self, ax=None, **kwargs):
+        if ax is None:
+            ax = plt.gca()
+        ax.plot(self.time, self.current, **kwargs)
+        ax.set_xlabel("Time (ms)")
+        ax.set_ylabel("Current (nA)")
+        ax.set_title(self.__class__.__name__)
+        return ax
+
+    def plot_during_simulation(self, duration: float, ax=None, **kwargs):
+        if ax is None:
+            ax = plt.gca()
+        # Create an array for the entire duration
+        full_time = np.arange(0, duration, self.dt)
+        full_current = np.zeros_like(full_time)
+
+        # Replace the corresponding values with self.time and self.current
+        indices = (self.time / self.dt).astype(int)
+        full_current[indices] = self.current
+
+        ax.plot(full_time, full_current, **kwargs)
+        ax.set_xlabel("Time (ms)")
+        ax.set_ylabel("Current (nA)")
+        ax.set_title(self.__class__.__name__)
+        ax.set_xlim(0, duration)
+        return ax
+
+    def __add__(self, other: Stimulus) -> CombinedStimulus:
+        """Override + operator to concatenate Stimulus objects."""
+        if self.dt != other.dt:
+            raise ValueError("Stimulus objects must have the same dt to be concatenated")
+        # shift other time
+        other_time = other.time + self.time[-1] + self.dt
+        combined_time = np.concatenate([self.time, other_time])
+        # Concatenate the current arrays
+        combined_current = np.concatenate([self.current, other.current])
+        return CombinedStimulus(self.dt, combined_time, combined_current)
+
+
+class CombinedStimulus(Stimulus):
+    """Represents the Stimulus created by combining multiple stimuli."""
+    def __init__(self, dt: float, time: np.ndarray, current: np.ndarray) -> None:
+        super().__init__(dt)
+        self._time = time
+        self._current = current
+
+    @property
+    def time(self) -> np.ndarray:
+        return self._time
+
+    @property
+    def current(self) -> np.ndarray:
+        return self._current
+
+
+class EmptyStimulus(Stimulus):
+    """Represents empty stimulus (all zeros) that has no impact on the cell.
+
+    This is required by some Stimuli that expect the cell to rest.
+    """
+    def __init__(self, dt: float, duration: float) -> None:
+        super().__init__(dt)
+        self.duration = duration
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(0.0, self.duration, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.zeros_like(self.time)
+
+
+class Step(Stimulus):
+    def __init__(self, dt: float, start: float, end: float, amplitude: float) -> None:
+        super().__init__(dt)
+        self.start = start
+        self.end = end
+        self.amplitude = amplitude
+
+    @classmethod
+    def threshold_based(
+        cls,
+        dt: float,
+        threshold_current: float,
+        threshold_percentage: float,
+        start: float,
+        end: float,
+        post_wait: float,
+    ) -> CombinedStimulus:
+        amplitude = threshold_current * threshold_percentage / 100
+        res = cls(dt, start, end, amplitude) + EmptyStimulus(dt, duration=post_wait)
+        return res
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(self.start, self.end, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.full_like(self.time, self.amplitude)
+
+
+class Ramp(Stimulus):
+    def __init__(
+        self,
+        dt: float,
+        start: float,
+        end: float,
+        amplitude_start: float,
+        amplitude_end: float,
+    ) -> None:
+        super().__init__(dt)
+        self.start = start
+        self.end = end
+        self.amplitude_start = amplitude_start
+        self.amplitude_end = amplitude_end
+
+    @property
+    def time(self) -> np.ndarray:
+        return np.arange(self.start, self.end, self.dt)
+
+    @property
+    def current(self) -> np.ndarray:
+        return np.linspace(self.amplitude_start, self.amplitude_end, len(self.time))
+
+
+class StimulusFactory:
+    def __init__(self, dt: float):
+        self.dt = dt
+
+    def step(self, start: float, end: float, amplitude: float) -> Stimulus:
+        return Step(self.dt, start, end, amplitude)
+
+    def ramp(
+        self, start: float, end: float, amplitude_start: float, amplitude_end: float
+    ) -> Stimulus:
+        return Ramp(self.dt, start, end, amplitude_start, amplitude_end)
+
+    def ap_waveform(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 220.0,
+        start: float = 250.0,
+        end: float = 300.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the APWaveform Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
+
+    def idrest(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 200.0,
+        start: float = 250.0,
+        end: float = 1600.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the IDRest Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
+
+    def iv(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = -40.0,
+        start: float = 250.0,
+        end: float = 3250.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the IV Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
+
+    def fire_pattern(
+        self,
+        threshold_current: float,
+        threshold_percentage: float = 200.0,
+        start: float = 250.0,
+        end: float = 3850.0,
+        post_wait: float = 250.0,
+    ) -> Stimulus:
+        """Returns the FirePattern Stimulus object, a type of Step stimulus.
+
+        Args:
+            threshold_current: The threshold current of the Cell.
+            threshold_percentage: Percentage of desired threshold_current amplification.
+            start: The start time of the step.
+            end: The end time of the step.
+            post_wait: The time to wait after the end of the step.
+        """
+        return Step.threshold_based(
+            self.dt, threshold_current, threshold_percentage, start, end, post_wait
+        )
diff --git a/docs/requirements_docs.txt b/docs/requirements_docs.txt
index 7ea66bc5..0d6d642d 100644
--- a/docs/requirements_docs.txt
+++ b/docs/requirements_docs.txt
@@ -1,3 +1,4 @@
 sphinx>=7.0.1
 sphinx-bluebrain-theme>=0.4.1
 sphinx_autodoc_typehints>=1.23.2
+seaborn>=0.13.2
diff --git a/docs/source/api.rst b/docs/source/api.rst
index a2449b57..b70b1a91 100644
--- a/docs/source/api.rst
+++ b/docs/source/api.rst
@@ -17,6 +17,7 @@ bluecellulab
    connection
    dendrogram
    exceptions
+   graph
    importer
    neuron_interpreter
    plotwindow
@@ -25,7 +26,8 @@ bluecellulab
    rngsettings
    simulation
    ssim
-   stimuli
+   stimulus
    synapse
    tools
-
+   utils
+   type_aliases
diff --git a/docs/source/conf.py b/docs/source/conf.py
index 22e0c400..0be4e8ca 100644
--- a/docs/source/conf.py
+++ b/docs/source/conf.py
@@ -34,7 +34,17 @@
     "sphinx.ext.viewcode",
     "sphinx.ext.napoleon",
     "sphinx_autodoc_typehints",
+    "sphinx.ext.doctest",
+    "matplotlib.sphinxext.plot_directive",
 ]
+
+# Configure doctest
+doctest_test_doctest_blocks = 'default'
+
+# For matplotlib plots in Sphinx
+plot_include_source = True
+plot_html_show_source_link = False
+
 autosummary_generate = True  # Turn on sphinx.ext.autosummary
 autodoc_default_options = {
     "members": True,
diff --git a/docs/source/index.rst b/docs/source/index.rst
index f603bdb4..4d4fc123 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -13,6 +13,7 @@
    :maxdepth: 2
 
    Home <self>
+   list_of_stim
    api.rst
    compiling-mechanisms.rst
    changelog
diff --git a/docs/source/list_of_stim.rst b/docs/source/list_of_stim.rst
new file mode 100644
index 00000000..0e39d53a
--- /dev/null
+++ b/docs/source/list_of_stim.rst
@@ -0,0 +1,138 @@
+
+List of Stimuli
+===============
+
+.. plot::
+   :context: close-figs
+   :include-source: False
+
+   import seaborn as sns
+   sns.set_style("darkgrid")
+   sns.set(rc={'figure.figsize':(10, 6)})
+
+
+This section provides an overview of the various stimuli available for use within BlueCelluLab. We showcase how each stimulus can be generated and visualized.
+
+Setting Up
+----------
+
+The stimuli visualization is controlled through a `StimulusFactory` object, which is configured with a time step (`dt`) parameter. This allows for precise temporal resolution in stimuli generation.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   from bluecellulab.stimulus import StimulusFactory
+   stim_factory = StimulusFactory(dt=0.1)
+
+Stimulus Types
+--------------
+
+Step Stimulus
+~~~~~~~~~~~~~
+
+**Definition**: The step stimulus represents a sudden change in value at a specified point in time, maintaining this new value until the end of the stimulus period.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   step = stim_factory.step(start=20, end=180, amplitude=70)
+   step.plot()
+
+
+Multiple step stimuli with different amplitudes.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   step1 = stim_factory.step(start=50, end=150, amplitude=60)
+   step2 = stim_factory.step(start=50, end=150, amplitude=80)
+   step3 = stim_factory.step(start=50, end=150, amplitude=100)
+   step4 = stim_factory.step(start=50, end=150, amplitude=120)
+
+   # Create a figure and an Axes object
+   fig, ax = plt.subplots()
+
+   # Plot the step functions on the same axes
+   step1.plot_during_simulation(200, ax=ax, color='red')
+   step2.plot_during_simulation(200, ax=ax, color='green')
+   step3.plot_during_simulation(200, ax=ax, color='blue')
+   step4.plot_during_simulation(200, ax=ax, color='orange')
+
+   plt.show()
+
+
+Ramp Stimulus
+~~~~~~~~~~~~~
+
+**Definition**: A ramp stimulus gradually changes from an initial value to a final value over a defined period. This allows for the examination of systems' responses to gradual input changes.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   ramp = stim_factory.ramp(start=20, end=180, amplitude_start=0.25, amplitude_end=0.5)
+
+   ramp.plot()
+
+
+
+APWaveform
+~~~~~~~~~~
+
+**Definition**: The action potential waveform is a step stimulus with a defined amplitude and duration.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   ap_waveform = stim_factory.ap_waveform(threshold_current=0.5)
+   ap_waveform.plot_during_simulation(600)
+
+
+IDRest
+~~~~~~
+
+**Definition**: The IDRest stimulus is a step stimulus with a defined amplitude and duration.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   id_rest = stim_factory.idrest(threshold_current=0.5)
+   id_rest.plot_during_simulation(2000)
+
+IV
+~~
+
+**Definition**: The IV stimulus is a step stimulus with a defined amplitude (negative value) and duration.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   iv = stim_factory.iv(threshold_current=0.5)
+   iv.plot_during_simulation(4500)
+
+FirePattern
+~~~~~~~~~~~~~
+
+**Definition**: The fire pattern stimulus is a step stimulus with a defined amplitude and duration.
+
+.. plot::
+   :context: close-figs
+   :include-source: True
+
+   fire_pattern = stim_factory.fire_pattern(threshold_current=0.5)
+   fire_pattern.plot_during_simulation(4500)
+
+
+.. plot::
+   :context: close-figs
+   :include-source: False
+
+   # Testing
+   assert len(ramp.current) > 0
+   assert len(step.current) > 0
\ No newline at end of file
diff --git a/examples/1-singlecell/singlecell.ipynb b/examples/1-singlecell/singlecell.ipynb
index 6947b29a..7920a1b2 100644
--- a/examples/1-singlecell/singlecell.ipynb
+++ b/examples/1-singlecell/singlecell.ipynb
@@ -91,7 +91,7 @@
     "from bluecellulab import Cell, Simulation\n",
     "from bluecellulab.circuit.circuit_access import EmodelProperties\n",
     "\n",
-    "from bluecellulab.stimuli import OrnsteinUhlenbeck, ShotNoise\n",
+    "from bluecellulab.stimulus.circuit_stimulus_definitions import OrnsteinUhlenbeck, ShotNoise\n",
     "from bluecellulab import RNGSettings"
    ]
   },
diff --git a/examples/2-sonata-network/sonata-network.ipynb b/examples/2-sonata-network/sonata-network.ipynb
index fc145ad6..cd8b086d 100644
--- a/examples/2-sonata-network/sonata-network.ipynb
+++ b/examples/2-sonata-network/sonata-network.ipynb
@@ -43,6 +43,16 @@
     "**Note**: The compiled mechanisms need to be provided before importing bluecellulab."
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# hack that imports libsonata before NEURON to avoid libc conflict\n",
+    "import libsonata  # https://github.com/BlueBrain/libsonata/issues/273"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": null,
diff --git a/examples/3-bpap/bpap.ipynb b/examples/3-bpap/bpap.ipynb
index 7e647b25..90cfd6d2 100644
--- a/examples/3-bpap/bpap.ipynb
+++ b/examples/3-bpap/bpap.ipynb
@@ -60,15 +60,7 @@
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "\t1 \n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from pathlib import Path\n",
     "from itertools import islice\n",
@@ -80,7 +72,7 @@
     "\n",
     "from bluecellulab import Cell, neuron\n",
     "from bluecellulab.simulation import Simulation\n",
-    "from bluecellulab.stimuli import Hyperpolarizing\n",
+    "from bluecellulab.stimulus.circuit_stimulus_definitions import Hyperpolarizing\n",
     "from bluecellulab.circuit.circuit_access import EmodelProperties"
    ]
   },
@@ -255,7 +247,15 @@
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\t1 \n"
+     ]
+    }
+   ],
    "source": [
     "# Define the base directory\n",
     "base_dir = Path(\"../1-singlecell/\")\n",
@@ -346,7 +346,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x1200 with 10 Axes>"
       ]
@@ -400,7 +400,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "/tmp/ipykernel_4475/2640247676.py:6: RuntimeWarning: overflow encountered in exp\n",
+      "/tmp/ipykernel_31723/2640247676.py:6: RuntimeWarning: overflow encountered in exp\n",
       "  return a * np.exp(-b * x) + c\n"
      ]
     },
@@ -528,7 +528,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.4"
+   "version": "3.11.7"
   },
   "orig_nbformat": 4
  },
diff --git a/examples/5-stimuli/stimuli.ipynb b/examples/5-stimuli/stimuli.ipynb
new file mode 100644
index 00000000..9e14735a
--- /dev/null
+++ b/examples/5-stimuli/stimuli.ipynb
@@ -0,0 +1,609 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Exploring the available stimuli in bluecellulab\n",
+    "\n",
+    "## Introduction\n",
+    "\n",
+    "In this notebook, we will explore the available stimuli in bluecellulab."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-02-29T10:08:39.609415Z",
+     "iopub.status.busy": "2024-02-29T10:08:39.609004Z",
+     "iopub.status.idle": "2024-02-29T10:08:40.473044Z",
+     "shell.execute_reply": "2024-02-29T10:08:40.472580Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "from bluecellulab import create_ball_stick\n",
+    "from bluecellulab.simulation import Simulation\n",
+    "from bluecellulab.stimulus import StimulusFactory\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "sns.set_style(\"darkgrid\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Stimuli Creation\n",
+    "\n",
+    "Here we create the StimulusFactory object responsible for creating various stimuli. It takes the dt parameter that represents the time between two samples.\n",
+    "\n",
+    "**Note:** Any stimuli created by StimulusFactory contain a set of essential functions. This enables users to treat all stimuli the same way using those functions - without having to write specific code to analyse each stimulus object."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-02-29T10:08:40.908307Z",
+     "iopub.status.busy": "2024-02-29T10:08:40.907649Z",
+     "iopub.status.idle": "2024-02-29T10:08:40.914572Z",
+     "shell.execute_reply": "2024-02-29T10:08:40.913404Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "stim_factory = StimulusFactory(dt=0.1)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Later it can be used to create a step protocol as below."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Step Stimulus"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-02-29T10:08:40.920185Z",
+     "iopub.status.busy": "2024-02-29T10:08:40.919386Z",
+     "iopub.status.idle": "2024-02-29T10:08:40.930025Z",
+     "shell.execute_reply": "2024-02-29T10:08:40.929020Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Step(dt=0.1)"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step = stim_factory.step(start=50, end=150, amplitude=70)\n",
+    "step"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plotting the step protocol."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Step'}, xlabel='Time (ms)', ylabel='Current (nA)'>"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "step.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Plotting it during the simulation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-02-29T10:08:40.931820Z",
+     "iopub.status.busy": "2024-02-29T10:08:40.931658Z",
+     "iopub.status.idle": "2024-02-29T10:08:41.056839Z",
+     "shell.execute_reply": "2024-02-29T10:08:41.056411Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Step'}, xlabel='Time (ms)', ylabel='Current (nA)'>"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "step.plot_during_simulation(200)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(1000,)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "step.current.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Ramp Stimulus"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Or similarly for creating a ramp protocol."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-02-29T10:08:41.058453Z",
+     "iopub.status.busy": "2024-02-29T10:08:41.058299Z",
+     "iopub.status.idle": "2024-02-29T10:08:41.061104Z",
+     "shell.execute_reply": "2024-02-29T10:08:41.060827Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Ramp(dt=0.1)"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "ramp = stim_factory.ramp(start=70, end=180, amplitude_start=0.25, amplitude_end=0.5)\n",
+    "ramp"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2024-02-29T10:08:41.062497Z",
+     "iopub.status.busy": "2024-02-29T10:08:41.062377Z",
+     "iopub.status.idle": "2024-02-29T10:08:41.166807Z",
+     "shell.execute_reply": "2024-02-29T10:08:41.166456Z"
+    }
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'Ramp'}, xlabel='Time (ms)', ylabel='Current (nA)'>"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAj8AAAHHCAYAAABQhTneAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXn0lEQVR4nO3deVxUhf7/8dcwbIqIyOIG4g64oKRm4VKaS6GtXuveVs2szBZLs9Rc0JTKNs1ui5ZXvd7KMr2JppZlaZeszDQN9xVXNtnXmfP7w598IzfAgQPM+/l4+HjEmXPOfM6nAd6cz5kzFsMwDERERESchIvZBYiIiIhUJoUfERERcSoKPyIiIuJUFH5ERETEqSj8iIiIiFNR+BERERGnovAjIiIiTkXhR0RERJyKwo+IiIg4FYUfERERcSquZhcgInIhn3/+OePHjy/+2mq14ufnR/fu3Xn66adp0KCBidWJSHWm8CMiVdqTTz5JUFAQBQUF/PbbbyxfvpwtW7YQFxeHh4eH2eWJSDWk8CMiVVqvXr3o0KEDAEOGDMHX15d58+axfv16oqOjTa5ORKojXfMjItVKly5dADh69CgABQUFzJ49mzvuuIPOnTvTqVMn7r77bn788ccS2yUmJhIaGsoHH3zAkiVLuOGGG+jYsSMPPvggJ06cwDAM3n77bXr16kVERAQjR47kzJkzJfbRp08fHnnkETZt2sStt95Khw4diI6OZt26dZVy7CLiGAo/IlKtHDt2DIC6desCkJWVxaeffsrVV1/N2LFjefzxx0lNTeWhhx4iISHhvO1XrlzJf/7zH+677z6GDRvGTz/9xOjRo3nzzTfZuHEjI0aM4M477+Tbb7/l5ZdfPm/7Q4cO8fTTT9OrVy/GjBmD1Wrlqaee4ocffqjYAxcRh9HYS0SqtKysLFJTUykoKGDbtm3MnTsXd3d3evfuDYCPjw/ffPMN7u7uxdvceeed3HTTTSxevJiZM2eW2N+pU6dYt24d3t7eANjtdt577z3y8vJYtmwZrq5nfyympaWxcuVKYmJiSuz70KFDvPXWW/Tv3x+Av/3tb9x44428+uqrdO/evUJ7ISKOofAjIlXa0KFDS3zdpEkTZs2aRcOGDYGz7wKzWq3A2SCTkZGB3W6nffv2/PHHH+ft78YbbywOPgAREREA3HLLLcXB59zyuLg4Tp06RXBwcPHywMBA+vXrV/x1nTp1uO2225g3bx5JSUkEBARc+UGLSIVS+BGRKm3y5Mk0b96czMxMli1bxs8//1ziTAzA8uXL+fDDDzl48CCFhYXFy4OCgs7bX6NGjUp8fS4IXWx5enp6ifATEhKCxWIpsW6zZs2AsyM5hR+Rqk/hR0SqtIiIiOJ3e/Xt25e7776bMWPGsGbNGry8vPjvf//L888/T9++fRk+fDh+fn5YrVbee++94oui/+zcWaK/cnG58CWQhmE47mBEpErQBc8iUm1YrVaeeeYZTp8+zZIlSwBYu3YtwcHBzJ07l9tuu42ePXsSFRVFfn5+hdRw+PDh8wLRoUOHgLMjORGp+hR+RKRa6datGxERESxcuJD8/PziMzl/DiTbtm3jt99+q5DnP336NF999VXx11lZWaxYsYLw8HCNvESqCY29RKTaGT58OE899RSff/45119/PevWrWPUqFFcf/31JCYm8vHHH9OqVStycnIc/tzNmjVj4sSJ/P777/j5+bFs2TJSUlKIjY11+HOJSMVQ+BGRaqd///40bdqUDz/8kDVr1pCcnMwnn3zCpk2baNWqFbNmzWLNmjX89NNPDn/uZs2aMWnSJF555RUOHjxIUFAQb7zxBj179nT4c4lIxbAYuppPRKRU+vTpQ+vWrXnvvffMLkVEroCu+RERERGnovAjIiIiTkXhR0RERJyKrvkRERERp6IzPyIiIuJUFH5ERETEqSj8iIiIiFNR+BERERGnojs8X0JKSibOdjm4xQJ+ft5OeeyOpl46hvroGOqjY6iPjlFRfTy338tR+LkEw8BpX9zOfOyOpl46hvroGOqjY6iPjmFWHzX2EhEREaei8CMiIiJOReFHREREnIrCj4iIiDgVhR8RERFxKgo/IiIi4lQUfkRERMSpKPyIiIiIU1H4EREREaei8CMiIiJOxfTws2TJEvr06UOHDh0YMmQI27dvv+i6n3/+OaGhoSX+dejQocQ6hmEwe/ZsevToQUREBEOHDuXQoUMVfBQiIiJSXZgaflavXk1sbCyjRo1i+fLlhIWFMXz4cFJSUi66TZ06ddi0aVPxv2+//bbE4/PmzWPx4sVMnTqVpUuXUqtWLYYPH05+fn5FH46IiIhUA6aGnwULFnDnnXcyePBgWrVqRUxMDJ6enixbtuyi21gsFgICAor/+fv7Fz9mGAaLFi1i5MiR9O3bl7CwMF555RVOnz7N119/XRmHJCIiIpeRV2gz9flN+1T3goICdu7cySOPPFK8zMXFhaioKLZu3XrR7XJycujduzd2u522bdvyzDPP0Lp1awASExNJSkoiKiqqeH1vb286duzI1q1bGThwYJlqtFjKeFA1wLljdsZjdzT10jHUR8dQHx1DfbwyydkFTFm9i18T0/ns0SiCalsduv/S/n8xLfykpaVhs9nw8/MrsdzPz48DBw5ccJvmzZszc+ZMQkNDyczM5MMPP+Tvf/87q1atomHDhiQlJRXv46/7TE5OLnONfn7eZd6mpnDmY3c09dIx1EfHUB8dQ30sux/2JfPUx7+RnJVPLTcrXh6u+PnVMaUW08JPeURGRhIZGVni6+joaD7++GNGjx7t8OdLScnEMBy+2yrNYjn7Te2Mx+5o6qVjqI+OoT46hvpYdkV2g/n/O8wHPx7BAFr61+blW9rSKrCOw/t47v/P5ZgWfnx9fbFaredd3JySklLiOp5LcXNzIzw8nCNHjgAQEBBQvI/AwMAS+wwLCytzjYaB0764nfnYHU29dAz10THUR8dQH0snKSufiat2sTUxHYBbOzRkbO+W1HI/O+4yq4+mXfDs7u5Ou3btiI+PL15mt9uJj48vcXbnUmw2G3v27CkOPUFBQQQEBJTYZ1ZWFtu2bSv1PkVEROTK/e9gKncv+pWtienUdrMyPTqMF/q3wdPNsdf5lIepY69hw4bx3HPP0b59eyIiIli4cCG5ubnccccdAIwbN44GDRowZswYAObOnUunTp0ICQkhIyODDz74gOPHjzNkyBDg7DvB7r//ft555x1CQkIICgpi9uzZBAYG0rdvX9OOU0RExFkU2Q3e/eEQC386CkDrAC9iB4UTUr+2yZX9H1PDT3R0NKmpqcyZM4ekpCTCw8OZP39+8djrxIkTuLj838mpjIwMJk2aRFJSEj4+PrRr146PP/6YVq1aFa8zYsQIcnNzmTx5MhkZGXTu3Jn58+fj4eFR6ccnIiLiTE5m5PHCql1sO54BwOCOjXj6+pZ4uJp+T+USLIahqeXFJCc73wVtFgv4+3s75bE7mnrpGOqjY6iPjqE+XtzG/SnErNlNel4RXu5WJvZvQ7/QgAuuW1F9PLffy6lW7/YSERGRqqXQZuftjYdYsiURgPAGdZg5KJygerVMruziFH5ERESkXI6n5zFxVQI7TmQCcFdkY57s1QL3Kjbm+iuFHxERESmzDXuTmbZ2D5n5RXh7uDJ5QBuub126W9WYTeFHRERESq2gyM6c7w/wydbjALRv5M2MgeE09vE0ubLSU/gRERGRUkk8k8uEuAQSTmUBcE/nIEb1bIabtWqPuf5K4UdEREQu6+vdSby4bg/ZBTZ8PF2ZcmMoPVv6XX7DKkjhR0RERC4qv8jOGxv2s2zbCQA6Nq7LiwPDaFi3+oy5/krhR0RERC7ocGoO4+MS2JuUDcADVwfzaFQIrtVszPVXCj8iIiJynjUJp4n9ai85hTbq1XIj5qZQoprXN7ssh1D4ERERkWJ5hTZe/XY///39JABXBfnw4sAwAurUnI+JUvgRERERAA6m5DA+7g/2J+dgAR68pikPXRuCq4vF7NIcSuFHREREiNt5kpe/3kdekZ36td2YFh1GtxBfs8uqEAo/IiIiTiy30MbL6/exaucpALo2rce06DD8vdxNrqziKPyIiIg4qX3J2Yxf+QeHUnNxscCIa0MY1q0p1ho25vorhR8REREnYxgG//39JK9+u5/8Ijv+Xu68ODCMzsH1zC6tUij8iIiIOJHsgiJiv9rL2l1JAFzTzJeYm0KpX7vmjrn+SuFHRETESew+ncWEuASOpOVitcCj3Ztx/9XBuFhq9pjrrxR+REREajjDMFi27QRvbNhPgc0gsI47MwaG0ynIx+zSTKHwIyIiUoNl5RcxY91evt5zdszVo0V9ptwYSr1abiZXZh6FHxERkRoq4VQm41cmcCw9D6uLhcd7Nufuzk2cbsz1Vwo/IiIiNYxhGCzdepzZ3x+g0GbQqK4HMwaG06FxXbNLqxIUfkRERGqQjLxCpq/dw4Z9KQBc38qPSQPaUNfTecdcf6XwIyIiUkPsOJHBxLgEjmfk4+pi4anrWnBXZGMsTj7m+iuFHxERkWrOMAyWbDnG3I0HsdkNmvh4MnNQOG0beptdWpWk8CMiIlKNncktJGbNbjYdSAXghjb+vNC/DXU89Cv+YtQZERGRamrbsXQmrtrFqcx83K0Wnr6+JYM7NtKY6zIUfkRERKoZu2Gw6KejvPvDIWwGNPWtxcxB4YQG1jG7tGpB4UdERKQaScspYMqXu4k/lAbAgLAAxvdrjZe7fqWXljolIiJSTfyaeIYXVu0iKasAD1cXxvZuya0dGmrMVUYKPyIiIlWczW7wr5+O8P7/DmM3oFn9WsQOakurAC+zS6uWFH5ERESqsJTsAiat3sXPR84AMLBdA567oRW13KzmFlaNKfyIiIhUUT8dTmPS6l2k5hTi6erCc31bMahdQ7PLqvYUfkRERKoYm91gfvxhPvjxCAbQwq82sTeH08JPYy5HUPgRERGpQpKy8nlh1S5+TUwH4NYODRnbuyWeGnM5jMKPiIhIFRF/KJUpq3eTlltIbTcr4/u15sbwQLPLqnEUfkRERExWZDd494dDLPzpKACtA7yIHRROSP3aJldWMyn8iIiImOhkRh4vrNrFtuMZAAzu2Iinr2+Jh6uLyZXVXAo/IiIiJtl0IIWpX+4mPa8IL3crE/u3oV9ogNll1XgKPyIiIpWsyGbn7U2H+PcviQCEBdYh9uZwgurVMrky56DwIyIiUolOZOQxIS6BHScyAbgrsjFP9mqBu8ZclUbhR0REpJJs2JvMtLV7yMwvwtvDlUkD2tC7tb/ZZTkdhR8REZEKVlBk562NB/n412MAtGvozcxB4TT28TS5Muek8CMiIlKBEs/kMiEugYRTWQDc0zmIUT2b4WbVmMssCj8iIiIVZP2eJKav3UN2gQ0fT1cm3xhKr5Z+Zpfl9BR+REREHCy/yM6bG/bz2bYTAEQ0rsuMgWE0rKsxV1Wg8CMiIuJAR9JyGb/yD/YkZQNwf9dgRnYPwVVjripD4UdERMRB1iacZuZXe8kptFGvlhsxN4US1by+2WXJXyj8iIiIXKG8QhuvfbufFb+fBCAyyIcXo8MI9PYwuTK5EIUfERGRK3AoJYfn4/5gf3IOFmDYNU0ZcW0Iri4Ws0uTi1D4ERERKadVO0/x0td7ySuyU7+2G9Oiw+gW4mt2WXIZCj8iIiJllFtg4+X1+4jbeQqALk3rMT06DH8vd5Mrk9JQ+BERESmDPacyeXTJVg6k5OBigYeuDeHBbk2xasxVbSj8iIiIlIJhGPx3x0le/WY/eYV2/L3ceXFgGJ2D65ldmpSRwo+IiMhlZBcU8dLX+1iTcBqAa5r5EnNTKPVra8xVHSn8iIiIXMKe01mMj0vgSFouVgs80z+UIe0DsaAxV3Wl8CMiInIBhmHw+fYTvP7tfgpsBoF13Jk5KJy+nYJITs7EMMyuUMrL9HttL1myhD59+tChQweGDBnC9u3bS7XdqlWrCA0N5bHHHiux/Pnnnyc0NLTEv+HDh1dE6SIiUkNl5RcxIW4XL329jwKbQY8W9VlyX2c6BfmYXZo4gKlnflavXk1sbCwxMTF07NiRhQsXMnz4cNasWYOf38U/9TYxMZGXX36ZLl26XPDxnj17EhsbW/y1u7tmsiIiUjoJpzKZEJdA4pk8rC4WRvVoxj1dgnCxaMxVU5h65mfBggXceeedDB48mFatWhETE4OnpyfLli276DY2m42xY8fyxBNPEBwcfMF13N3dCQgIKP7n46OkLiIil2YYBp/8eozhH/1G4pk8Gnp7MO+ujtzXNVjBp4Yx7cxPQUEBO3fu5JFHHile5uLiQlRUFFu3br3odm+//TZ+fn4MGTKELVu2XHCdn376iWuvvZa6detyzTXXMHr0aHx9y37HTWd8rZ87Zmc8dkdTLx1DfXQM9fHSMvOKmLZ2D9/uTQbgulZ+TB7QBp9abiXWUx8do6L6WNr9mRZ+0tLSsNls5423/Pz8OHDgwAW3+eWXX/jss89YsWLFRffbs2dP+vXrR1BQEEePHuX1119nxIgRfPLJJ1it1jLV6OfnXab1axJnPnZHUy8dQ310DPXxfL8dPcPj/9lKYloublYL428KZ1j3Zlgu8ZtUfXQMs/pYbd7tlZWVxbhx45g+fTr169e/6HoDBw4s/u9zFzz37du3+GxQWaSkON/V/BbL2RejMx67o6mXjqE+Oob6eD7DMFiy5RhvfX8Qm92giY8nMweF066RNykpWRfcRn10jIrq47n9Xo5p4cfX1xer1UpKSkqJ5SkpKfj7+5+3/tGjRzl27BgjR44sXma32wFo27Yta9asoWnTpudtFxwcjK+vL4cPHy5z+DEMnPbF7czH7mjqpWOoj46hPp6VnltIzJrdbDyQCsANbfx5oX8b6ni4lqo/6qNjmNVH08KPu7s77dq1Iz4+nr59+wJnw0x8fDz33nvveeu3aNGClStXllj25ptvkp2dzcSJE2nYsOEFn+fkyZOcOXOGgIAAxx+EiIhUO9uOpTNx1S5OZebjZrXw9PUt+VvHRpccc0nNYurYa9iwYTz33HO0b9+eiIgIFi5cSG5uLnfccQcA48aNo0GDBowZMwYPDw/atGlTYvu6desCFC/Pzs5m7ty5DBgwAH9/f44ePcqsWbMICQmhZ8+elXtwIiJSpdgNg8U/J/LOpoPYDAiu50nsoLaENqhjdmlSyUwNP9HR0aSmpjJnzhySkpIIDw9n/vz5xWOvEydO4OJS+nfjW61W9uzZw4oVK8jMzCQwMJDu3bvz1FNP6V4/IiJOLC2ngKlrdvO/g2kADAgLYHy/1ni5V5tLX8WBLIahqeXFOOPtyy0W8Pf3dspjdzT10jHUR8dw5j7+mniGF1btIimrAA9XF8b0bsltHRqWa8zlzH10pIrq47n9Xo4ir4iI1Eg2u8G/fjrC+/87jN2AEN9axN4cTusAjbmcncKPiIjUOCnZBUxevYufjpwBILptIM/d0Jra7mW735vUTAo/IiJSo/x8JI1Jq3eTkl2Ap6sL425oxc3tL/yOYHFOCj8iIlIj2OwG8+MP88GPRzCAFn61ib05nBZ+XmaXJlWMwo+IiFR7SVn5TFq9iy1H0wG4tX1DxvZpiaebxlxyPoUfERGp1n48lMrk1btJyy2klpsL4/u15qbwBmaXJVWYwo+IiFRLRXaD9344xL9+OgpA6wAvZg4Kp1n92iZXJlWdwo+IiFQ7pzLzeWFVAr8dywBgcMdGjL6uhcZcUioKPyIiUq38cCCVKV/uIj2vCC93KxP6taZ/WKDZZUk1ovAjIiLVQpHNzj83HWLxL4kAhAXWYeagcIJ9a5lcmVQ3Cj8iIlLlncjIY2JcAr+fyATgrsjGPNmrBe6upf/8R5FzFH5ERKRK+25fMtPW7iEjr4g6HlYmDQilT2t/s8uSakzhR0REqqRCm5053x/k41+PAdC2oTczB4XRxEdjLrkyCj8iIlLlJJ7JZUJcAgmnsgC4u3MTHu/ZHDerxlxy5RR+RESkSlm/J4npa/eQXWCjrqcrU24MpVdLP7PLkhpE4UdERKqE/CI7b27Yz2fbTgDQoVFdZg4Ko2FdT5Mrk5pG4UdEREx3JO3smGv36bNjrvu7BjGyezNcNeaSCqDwIyIiplq36zQz1u0lp9BGvVpuTL0plO7N65tdltRgCj8iImKKvEIbr2/Yz/LtJwGIbFKXFweGE+jtYXJlUtMp/IiISKU7lJLD+LgE9iVnYwGGXdOUEdeG4OpiMbs0cQIKPyIiUqlW/3GKl77eS26hnfq13Zh2UxjdmvmaXZY4EYUfERGpFLmFNmat38fKnacA6BLsw/ToMPzraMwllUvhR0REKtz+5GzGxyVwMCUHFws8dG0ID3ZrilVjLjGBwo+IiFQYwzBYueMUr3yzj/wiO35e7swYGEbn4HpmlyZOTOFHREQqRE6BjZe+3suXCacBuCbEl5joUOrXdje5MnF2Cj8iIuJwe05nMT4ugSNpubhY4NHuzXjg6mBcLBpzifkUfkRExGEMw2D59hO89u1+CmwGgXXceXFgOJFBPmaXJlJM4UdERBwiK7+ImV/t5avdSQB0b16fqTeGUq+2m8mViZSk8CMiIlds16lMxsclkHgmD6uLhVE9mnFPlyCNuaRKUvgREZFyMwyDT387zpvfHaDQZtDQ24MZg8KJaFzX7NJELkrhR0REyiUzr4jp6/bw7d5kAHq19GPygDb41NKYS6o2hR8RESmznScymBCXwPGMfFxdLDx5XQv+HtkYi8ZcUg0o/IiISKkZhsFHvx7jre8PUmQ3aOzjycxB4bRr6G12aSKlpvAjIiKlkp5byLS1e/h+fwoAfVr780L/Nnh76leJVC96xYqIyGVtO5bOxFW7OJWZj5vVwujrWjKkUyONuaRaUvgREZGLshsG//45kX9uOojNgOB6nsQOaktogzpmlyZSbgo/IiJyQWk5BUxds5v/HUwDoH9oAOP7taaOh351SPWmV7CIiJxna2I6E1clkJRVgIerC8/0bsntHRpqzCU1gsKPiIgUsxsG/9p8lPf+dwi7ASG+tYi9OZzWARpzSc2h8CMiIgCkZBcw5ctdbD58BoDotoE8d0NrartbzS1MxMEUfkREhJ+PpDFp9W5Sss+Oucbd0Iqb2zXQmEtqJIUfEREnZrMbfPDjYebHH8EAmvvVJnZQOC39vcwuTaTCKPyIiDip5Kx8Jq3exS9H0wG4pX0Dnu3TCk83jbmkZlP4ERFxQpsPpTH5y12k5hRSy82F5/u2JrptA7PLEqkUCj8iIk6kyG7w/g+HWLD5KAbQOsCLmQPDaeZX2+zSRCqNwo+IiJM4kZ7LY0u3sTUxA4A7Ihrx9PUtNOYSp6PwIyLiBDYdSCVmzW7ScgrxcrcyoV9r+ocFml2WiCkUfkREarAim51/bjrE4l8SAQgNrEPsoHCCfWuZXJmIeRR+RERqqJMZeUyI28XvJ86OuR64NoSHuwXjbnUxuTIRcyn8iIjUQN/tS2Ha2t1k5BVRx8PKpAFtuCuqBcnJmRiG2dWJmEvhR0SkBim02Xnr+4N89OsxANo29GbGwDCNuUT+ROFHRKSGOJaey4S4XfxxMhOAuzs34fGezXHTmEukBIUfEZEa4Ju9yUxfu5usfBt1PV2ZPCCU61r5mV2WSJVUrvBz9OhRtmzZwrFjx8jLy6N+/fqEh4cTGRmJh4eHo2sUEZGLyC+yM+e7Ayz97TgAHRrVZcagMBrV9TS5MpGqq0zh54svvmDRokXs2LEDf39/AgMD8fDwID09nSNHjuDh4cHNN9/MiBEjaNKkSUXVLCIiwNG0XMbHJbD7dBYA93cNYmT3ZrhqzCVySaUOP7fddhtubm7cfvvtvPXWWzRq1KjE4wUFBWzdupVVq1YxePBgpkyZwk033eTwgkVEBNbtOs3Mr/aSXWDDx9OVmJvC6N6ivtlliVQLpf7zYMyYMXz66afcc8895wUfAHd3d7p168a0adP48ssvCQ4OLtV+lyxZQp8+fejQoQNDhgxh+/btpdpu1apVhIaG8thjj5VYbhgGs2fPpkePHkRERDB06FAOHTpUqn2KiFR1eYU2Zn61h4mrdpFdYKNTk7osub+zgo9IGZQ6/PTs2bNU6505cwZfX1/at29/2XVXr15NbGwso0aNYvny5YSFhTF8+HBSUlIuuV1iYiIvv/wyXbp0Oe+xefPmsXjxYqZOncrSpUupVasWw4cPJz8/v1T1i4hUVYdSc3jwo99Yvv0kFuDBbsG8c2dHGnjrWkuRsnDYYHjTpk089dRT9OrVq9TbLFiwgDvvvJPBgwfTqlUrYmJi8PT0ZNmyZRfdxmazMXbsWJ544onzzi4ZhsGiRYsYOXIkffv2JSwsjFdeeYXTp0/z9ddfl/vYRETMtvqPU9z/71/Zm5SNby033hrcgZE9muPqYjG7NJFq54re6n7s2DGWLVvGihUrSE9Pp1evXrz88sul2ragoICdO3fyyCOPFC9zcXEhKiqKrVu3XnS7t99+Gz8/P4YMGcKWLVtKPJaYmEhSUhJRUVHFy7y9venYsSNbt25l4MCBZTo+ixP+TDl3zM547I6mXjqGs/cxr9DGy+v3sXLHKQC6BPvw4sAw/OuU7WyPs/fRUdRHx6ioPpZ2f2UOPwUFBXz11Vd8+umn/Prrr0RFRXHy5EmWL19OaGhoqfeTlpaGzWbDz6/kfSj8/Pw4cODABbf55Zdf+Oyzz1ixYsUFH09KSirex1/3mZycXOra/m877zJvU1M487E7mnrpGM7Yxz2nMhn10Tb2ns7CYoEn+7TmyRtaY72Csz3O2MeKoD46hll9LFP4mT59OnFxcTRr1oxbbrmFN954A19fX9q1a4fVaq2oGgHIyspi3LhxTJ8+nfr1K+fCvpQU5/sMHIvl7IvRGY/d0dRLx3DGPhqGwcodp3h5/T7yi+z4ebnz4sBQujb1JS01q1z7dMY+VgT10TEqqo/n9ns5ZQo/H330ESNGjGDEiBHUqVOn3MUB+Pr6YrVaz7u4OSUlBX9///PWP3r0KMeOHWPkyJHFy+x2OwBt27ZlzZo1BAQEFO8jMDCwxD7DwsLKXKNh4LQvbmc+dkdTLx3DWfqYU2Dj5fV7Wf3HaQC6hdQj5qYw/LzcHXL8ztLHiqY+OoZZfSxT+HnllVdYtmwZPXv25LrrruPWW28t0wXOf+bu7k67du2Ij4+nb9++wNkwEx8fz7333nve+i1atGDlypUllr355ptkZ2czceJEGjZsiJubGwEBAcTHxxMeHg6cPWO0bds2/vGPf5SrThGRyrI3KYvxKxM4nJaLiwUe7d6MB64OxkUXmIg4VJnCz6BBgxg0aBBHjx5l+fLlTJs2jdzcXOx2O/v27aNVq1ZlevJhw4bx3HPP0b59eyIiIli4cCG5ubnccccdAIwbN44GDRowZswYPDw8aNOmTYnt69atC1Bi+f33388777xDSEgIQUFBzJ49m8DAwOKAJSJS1RiGwfLfT/LaN/sosBkE1nHnxYHhRAb5mF2aSI1Urnd7BQcH8+STT/LEE0+wadMmPvvsM5599llmzpxJ//79eeGFF0q1n+joaFJTU5kzZw5JSUmEh4czf/784rHXiRMncHEp27vxR4wYQW5uLpMnTyYjI4POnTszf/58feaYiFRJWflFxH61l3W7z75hI6q5LzE3hlGvtpvJlYnUXBbDcMy0LS0tjf/+9798/vnnfPHFF47YpemSk53vgjaLBfz9vZ3y2B1NvXSMmtzH3aeyGB/3B0fP5GG1wKiezbmnS1CFjLlqch8rk/roGBXVx3P7vZwrus/Pn/n6+jJ06FCGDh3qqF2KiNRIhmHw6W8nePO7/RTaDBp4ezBzUDgRjeuaXZqIUyhX+LHZbHz++ef8+OOPpKSkFL/rCsBisbBw4UKHFSgiUpNk5hXx4ro9fLP37L3HerX0Y/KANvjU0phLpLKUK/zMmDGD5cuXc91119G6dWsseieCiMhl7TyZyYS4BI6n5+HqYuGJXs35x1VN9DNUpJKVK/ysWrWKN998k+uuu87R9YiI1DiGYfDRr8d46/uDFNkNGtc9O+Zq10hjLhEzlCv8uLm50bRpU0fXIiJS46TnFjJt7R6+33/2hq69W/szqX8bvD0ddsmliJRRuT7V/cEHH2TRokU46I1iIiI10vbjGdy7+Fe+35+Cm9XCs31a8fLN4Qo+IiYr13fgli1b2Lx5M99//z2tW7fG1bXkbubOneuQ4kREqiO7YbDkl0Te3nQIm90gqJ4nsYPCCWugD8MUqQrKFX7q1q1Lv379HF2LiEi1dyankKlrdvPDwVQA+oUGMKFfa+p46GyPSFVRru/G2NhYR9chIlLtbU1M54VVCZzOKsDdamFMn1bc3qGh3s0lUsXoTxERkStkNwwW/nSU9344hM2Apr61eOnmcFoH1DG7NBG5gFJf8Dx8+HB+++23y66XlZXF+++/z5IlS66kLhGRaiE1p4Anl/3OPzedDT43hQey+N6rFHxEqrBSn/m58cYbeeKJJ/D29qZ37960b9+ewMBAPDw8yMjIYN++fWzZsoXvv/+e6667jnHjxlVk3SIipvvlyBleWL2LlOwCPFxdGNenFTe3b6Axl0gVV+rwM2TIEG699Va+/PJLvvzyS5YuXUpmZiZw9iMtWrVqRY8ePfjss89o2bJlhRUsImI2m93gwx+PMP/Hw9gNaO5Xm9hB4bT09zK7NBEphTJd8+Pu7s6tt97KrbfeCkBmZiZ5eXnUq1cPNzd9Lo2I1HzJWflM+nI3vxw5A8DN7Rrw7A2tqOVmNbcwESm1K7rg2dvbG29v3bdCRJzD5kNpTP5yF6k5hdRyc+H5vq2JbtvA7LJEpIz0bi8RkcsoshvM+98hFmw+igG08vcidlA4zfxqm12aiJSDwo+IyCWcysxn0qoEth7LAOD2iIY8c31LPDXmEqm2FH5ERC7ih4OpTFm9i/S8Imq7WZnYvzX9wwLNLktErpDCj4jIXxTZ7LzzwyEW/ZwIQGhgHWYOCqepby2TKxMRRyjXp7rfcMMNpKWlnbc8IyODG2644YqLEhExy8mMPB7+ZHtx8BnSqTEf/KOTgo9IDVKuMz/Hjh3Dbreft7ygoIBTp05dcVEiImb4bl8K09buJiOvCC93K5MGtOGGNgFmlyUiDlam8LN+/fri/964cWOJt7nb7Xbi4+Np0qSJ46oTEakEhTY7czce5D9bjgEQ3uDsmCuons72iNREZQo/o0aNAs7e0fn5558vuSNXV5o0aXLechGRquxYei4T43ax8+TZO9b/46omPNGrOW7Wcl0VICLVQJnCz65duwDo06cPn332GfXr16+QokREKsM3e5OZvnY3Wfk2vD1cmXJjG65r5W92WSJSwcp1zc8333zj6DpERCpNQZGd2d8dYOlvxwHo0MibGYPCaVTX0+TKRKQylPut7vHx8cTHx5OSknLexc+xsbFXXJiISEU4mpbLhLgEdp3OAuC+LkE81qMZrhpziTiNcoWfuXPn8vbbb9O+fXsCAgKwWCyOrktExOG+2p3EjHV7yC6w4ePpytSbQunRws/sskSkkpUr/Hz88cfExsZy2223ObgcERHHyyu08caGA3y+/QQAnZrU5cWB4TTw9jC5MhExQ7nCT2FhIVdddZWjaxERcbhDqTlMiEtgb1I2FmBot2AejmqGq4vOWIs4q3INuf/2t7+xcuVKR9ciIuJQq/84xf3//pW9Sdn41nJjzuD2PNajuYKPiJMr15mf/Px8li5dSnx8PKGhobi6ltzN+PHjHVKciEh55BXamPXNPr7YcfaO852DfZgeHUZAHY25RKSc4Wf37t2EhYUBsGfPnhKP6eJnETHTgZRsxq9M4EBKDhbgoWubMvyaEKw62yMi/1+5ws/ixYsdXYeIyBVbueMkL6/fR36RHT8vd6ZHh9K1qa/ZZYlIFVPu+/wAHD58mCNHjtC1a1c8PT0xDENnfkSk0uUU2Hhl/V5W/XEagKub1mNadBh+Xu4mVyYiVVG5wk9aWhqjR49m8+bNWCwW1q1bR3BwMBMmTMDHx0ef7yUilWZfUjbj4/7gUGouLhZ4JKoZQ7sF46I/xETkIsr1bq/Y2FhcXV3ZsGEDnp7/dzv46OhoNm7c6LDiREQuxjAMlm8/wdD/bOVQai4Bddx5584IHrymqYKPiFxSuc78/PDDD3zwwQc0bNiwxPJmzZpx/PhxhxQmInIxWflFxH61l3W7kwC4tpkvMTeF4ltbYy4RubxyhZ+cnJwSZ3zOOXPmDO7u+uEjIhVn96ksxsf9wdEzeVgt8FiP5tzbNUhne0Sk1Mo19urSpQsrVqwoscxutzN//ny6devmiLpEREowDINPfzvOsI+2cvRMHg28PXjvro7cf7Wu7xGRsinXmZ9nn32WoUOHsmPHDgoLC5k1axb79u0jPT2djz76yNE1ioiTy8gr5PmVCazfkwxAzxb1mXxjKPVquZlcmYhUR+UKP23atGHt2rX8+9//xsvLi5ycHPr168c999xDYGCgo2sUESe280QmL3z5M0dTc7G6WHiyV3P+cVUT3VZDRMqtzOGnsLCQhx56iJiYGEaOHFkRNYmIYBgGH289zpzvDlBkN2hc14OZg8Jp16iu2aWJSDVX5vDj5ubG7t27K6IWEREA0nMLmb52D9/tTwFgQLsGPN+7JXU8rui+rCIiQDkveL7lllv47LPPHF2LiAi/H8/g3sW/8t3+FNysFp7t05J37+2Mt6eCj4g4Rrl+mthsNj766CP+97//0b59e2rVqlXicX2qu4iUld0wWPJLIm9vOoTNbhBUz5OZg8Jp29Bb1/eIiEOVK/zs2bOHtm3bAnDw4MESj+mHlIiU1ZmcQmLW7mbTgVQA+rYJYGL/1hpziUiFKPNPFpvNxpNPPkmbNm3w8fGpiJpExIn8lpjOxFUJnM4qwN1qYUzvltwe0Uh/SIlIhSnzNT9Wq5UHH3yQjIyMiqhHRJyE3TBYsPkIjy7dxumsApr61mLB3ZHc0bGxgo+IVKhynVNu3bo1iYmJBAcHO7oeEXECqTkFTFm9mx8PpwFwY3ggz/dthZe7xlwiUvHK9ZNm9OjRvPzyyzz11FO0a9eO2rVrl3i8Tp06DilORGqeLUfP8MKqXSRnF+Dh6sK4Pq24uX0Dne0RkUpTrvDz8MMPAzBy5MgSP7AMw8BisZCQkOCY6kSkxrDZDT7cfIT58YexG9C8fm1m3hxOK38vs0sTESdTrvCzaNEiR9chIjVYcnYBk1bv4pcjZwAY1K4B425oRS03q7mFiYhTKlf4ufrqqx1dh4jUUJsPpzF59S5ScwrxdHXh+b6tGdiugdlliYgTK1f4+fnnny/5eNeuXctVjIjUHEV2g3nxh1nw4xEMoJW/F7GDwmnmV/uy24qIVKRyhZ/77rvvvGV/vvZH1/yIOLfTmfm8sHoXWxPTAbitQ0PG9G6Jp8ZcIlIFOOTMT2FhIQkJCcyePZunn37aIYWJSPX0v4OpTPlyN2dyC6ntZmVCv9YMCA80uywRkWLlCj/e3t7nLevevTtubm689NJLfP7556Xe15IlS/jggw9ISkoiLCyMSZMmERERccF1161bx7vvvsuRI0coKioiJCSEYcOGcdtttxWv8/zzz7N8+fIS2/Xo0YMPPvig1DWJSNkV2ey888NhFv18FIA2AV7E3tyWpr61LrOliEjlcugdxfz8/M77rK9LWb16NbGxscTExNCxY0cWLlzI8OHDWbNmDX5+fuet7+Pjw8iRI2nRogVubm58++23TJgwAT8/P3r27Fm8Xs+ePYmNjS3+2t3d/coOTEQu6WRGHhNX7WL78bN3fv9bx0aMvr4lHq5lvom8iEiFK1f42bVr13nLTp8+zbx58wgLCyv1fhYsWMCdd97J4MGDAYiJiWHDhg0sW7as+F5Cf9atW7cSXz/wwAOsWLGCLVu2lAg/7u7uBAQElLoOESm/7/enMG3NbtLzivBytzJpQBtuaKPvPxGpusoVfm677TYsFguGYZRY3qlTJ2bMmFGqfRQUFLBz504eeeSR4mUuLi5ERUWxdevWy25vGAY//vgjBw8eZOzYsSUe++mnn7j22mupW7cu11xzDaNHj8bX17dUdYlI6RTa7MzdeJD/bDkGQHiDOswcFE5QPY25RKRqK1f4Wb9+fYmvXVxcqF+/Ph4eHqXeR1paGjab7bzxlp+fHwcOHLjodpmZmfTq1YuCggJcXFyYMmUK3bt3L368Z8+e9OvXj6CgII4ePcrrr7/OiBEj+OSTT7Bay/ZOE2e82/65Y3bGY3e0mtzLY2dymRC3i50nMwH4x1VNeKJXc9wrYMxVk/tYmdRHx1AfHaOi+lja/ZUr/DRp0qQ8mzmEl5cXK1asICcnh/j4eF566SWCg4OLR2IDBw4sXjc0NJTQ0FD69u1bfDaoLPz8zr+w21k487E7Wk3r5ZodJ3n2s21k5hVR19OVWUM6MqBdwwp/3prWR7Ooj46hPjqGWX0sU/iJj49n+vTpLF269LwPL83MzOTvf/87MTExdOnS5bL78vX1xWq1kpKSUmJ5SkoK/v7+F93OxcWFkJAQAMLDw9m/fz/vv//+edcDnRMcHIyvry+HDx8uc/hJScnkL5O9Gs9iOftidMZjd7Sa1suCIjuzvzvAJ1uPA9C+kTexg8Jp5ONJcnJmhT1vTeujWdRHx1AfHaOi+nhuv5dTpvCzcOFC7rzzzgt+aru3tzd33XUXCxYsKFX4cXd3p127dsTHx9O3b18A7HY78fHx3HvvvaWuyW63U1BQcNHHT548yZkzZ8p1AbRh4LQvbmc+dkerCb1MPJPLhLgEEk5lAXBvlyBG9WiGq9Wl0o6tJvSxKlAfHUN9dAyz+limAf3u3btLvKvqr7p3787OnTtLvb9hw4axdOlSli9fzv79+5k6dSq5ubnccccdAIwbN47XXnuteP333nuPH374gaNHj7J//34+/PBDvvjiC2655RYAsrOzefnll/ntt99ITEwkPj6exx57jJCQkEvWLSIX99XuJO5d/CsJp7Lw8XTljdvb8dR1LXC16m3sIlI9lenMT3JyMq6uF9/E1dWV1NTUUu8vOjqa1NRU5syZQ1JSEuHh4cyfP7947HXixAlcXP7vB2xOTg4xMTGcPHkST09PWrRowaxZs4iOjgbAarWyZ88eVqxYQWZmJoGBgXTv3p2nnnpK9/oRKaP8IjtvbNjPsm0nAOjYuC4zBoXTwLv0b2wQEamKyhR+GjRowN69e4uvufmr3bt3l3m8dO+99150zLV48eISXz/99NOX/PgMT09P3clZxAEOp+YwPi6BvUnZAAy9OphHujfD1UVvcRGR6q9M562vu+46Zs+eTX5+/nmP5eXl8dZbb9G7d2+HFScile/LhFPc9+9f2ZuUjW8tN+YMbs+ons0VfESkxijTmZ+RI0eybt06BgwYwD333EPz5s0BOHDgAP/5z3+w2Ww8+uijFVKoiFSsvEIbr36zn//uOAlA52AfpkeHEVBHYy4RqVnKFH78/f35+OOPmTp1Kq+//nrxHZ4tFgs9evRg8uTJl3ybuohUTQdSshm/MoEDKTlYgOHXNOWha0Ow6myPiNRAZb7JYZMmTZg3bx7p6ekcPnwYgJCQEHx8fBxenIhUvJU7TvLK+n3kFdmpX9uN6dFhXB2ij4MRkZqr3J/q7uPjQ0REhCNrEZFKlFNg45X1e1n1x2kAujatx7ToMPy99M5IEanZyh1+RKT62peUzfi4PziUmouLBR6OCmHo1U015hIRp6DwI+JEDMPgv7+f5NVv95NfZCegjjvTo8PoHFzP7NJERCqNwo+Ik8guKCL2q72s3ZUEwLXNfIm5KRTf2hpziYhzUfgRcQK7T2cxIS6BI2m5WC0wskdz7usahItFYy4RcT4KPyI1mGEYfLbtBG9u2E+BzSCwjjszB4XTsYnenSkizkvhR6SGysov4sV1e1i/JxmAHi3qM+XGUOrVcjO5MhERcyn8iNRAf5zMZEJcAsfS87C6WHiiZ3Pu7twEi8ZcIiIKPyI1iWEYfLz1OHO+O0CR3aBRXQ9mDgqnfaO6ZpcmIlJlKPyI1BAZeYVMX7uHDftSALi+lR+TBrShrqfGXCIif6bwI1ID7DiRwYS4BE5k5ONmtfBUrxbcGdlYYy4RkQtQ+BGpxuyGwX+2HGPuxoPY7AZNfDyJvTmc8AbeZpcmIlJlKfyIVFNncguJWbObTQdSAejbxp+J/dtQx0Pf1iIil6KfkiLV0LZj6UyIS+B0VgHuVgvP9G7JHRGNNOYSESkFhR+RasRuGCz86Sjv/XAImwFNfWsxc1A4oYF1zC5NRKTaUPgRqSZScwqY8uVufjyUBsCAsADG92uNl7u+jUVEykI/NUWqgS1Hz/DCql0kZxfg4erCs31ackv7hhpziYiUg8KPSBVmsxt8uPkI8+MPYzegef3azLw5nFb+XmaXJiJSbSn8iFRRydkFTF69i5+PnAFgYLsGPHdDK2q5Wc0tTESkmlP4EamCfjqcxqTVu0jNKcTT1YXn+rZiULuGZpclIlIjKPyIVCFFdoP58Yf58McjGEBL/9rEDmpLc7/aZpcmIlJjKPyIVBFJWflMXLWLrYnpANzaoSFje7fEU2MuERGHUvgRqQL+dzCVKV/u5kxuIbXdrIzv15obwwPNLktEpEZS+BExUZHd4N0fDrHwp6MAtA7wInZQOCH1NeYSEakoCj8iJjmZkccLq3ax7XgGAH/r2IjR17fEw9XF5MpERGo2hR8RE2zcn0LMmt2k5xXh5W7lhf5t6BsaYHZZIiJOQeFHpBIV2uzM3XiQ/2w5BkB4gzrMHBROUL1aJlcmIuI8FH5EKsnx9Dwmrkpgx4lMAO6KbMyTvVrgrjGXiEilUvgRqQQb9iYzbe0eMvOL8PZwZfKANlzf2t/sskREnJLCj0gFyi+y8eo3+/j41+MAtG/kzYyB4TT28TS5MhER56XwI1JBEs/kMumjbfx+7OxNC+/pHMSons1ws2rMJSJiJoUfkQrw9e4kXly3h+wCGz6erky5MZSeLf3MLktERFD4EXGo/CI7b2zYz7JtJwDoEuLL1AGtaeCtMZeISFWh8CPiIIdTcxgfl8DepGwAhnULZsIt7UlPy8YwTC5ORESKKfyIOMCahNPEfrWXnEIb9Wq5MS06lKjm9XV9j4hIFaTwI3IF8gptvPrtfv77+0kArgry4cWBYQTU8TC5MhERuRiFH5FyOpiSw/i4P9ifnIMFePCapjx0bQiuLhazSxMRkUtQ+BEph7idJ3n5633kFdmpX9uNadFhdAvxNbssEREpBYUfkTLILbTx8vp9rNp5CoCuTesxLToMfy93kysTEZHSUvgRKaV9ydmMX/kHh1JzcbHAiGtDGNatKVaNuUREqhWFH5HLMAyD//5+kle/3U9+kR1/L3deHBhG5+B6ZpcmIiLloPAjcgnZBUXEfrWXtbuSALimmS8xN4VSv7bGXCIi1ZXCj8hF7D6dxYS4BI6k5WK1wKPdm3H/1cG4WDTmEhGpzhR+RP7CMAyWbTvBGxv2U2AzCKzjzsxB4XRs4mN2aSIi4gAKPyJ/kpVfxIx1e/l6z9kxV48W9ZlyYyj1armZXJmIiDiKwo/I//fHyUwmxCVwLD0Pq4uFx3s2557OTbBozCUiUqMo/IjTMwyDT7YeZ/Z3ByiyGzSq68GMgeF0aFzX7NJERKQCKPyIU8vIK2T62j1s2JcCwPWt/Jg0oA11PTXmEhGpqRR+xGntOJHBhLgETmTk4+pi4anrWnBXZGONuUREajiFH3E6hmGwZMsx5m48iM1u0MTHk5mDwmnb0Nvs0kREpBIo/IhTOZNbSMya3Ww6kArADW38eaF/G+p46FtBRMRZ6Ce+OI1tx9KZuGoXpzLzcbdaePr6lgzu2EhjLhERJ+NidgFLliyhT58+dOjQgSFDhrB9+/aLrrtu3TruuOMOunTpQqdOnbj11ltZsWJFiXUMw2D27Nn06NGDiIgIhg4dyqFDhyr2IKRKsxsG/9p8hEc+2capzHya+tbiw7sj+VsnXd8jIuKMTA0/q1evJjY2llGjRrF8+XLCwsIYPnw4KSkpF1zfx8eHkSNH8sknn/DFF19wxx13MGHCBDZu3Fi8zrx581i8eDFTp05l6dKl1KpVi+HDh5Ofn19ZhyVVSFpOAaM/38Hbmw5hM2BAWACL7o0kNLCO2aWJiIhJTA0/CxYs4M4772Tw4MG0atWKmJgYPD09WbZs2QXX79atG/369aNly5Y0bdqUBx54gNDQULZs2QKcPeuzaNEiRo4cSd++fQkLC+OVV17h9OnTfP3115V5aFIFbDl6hnsW/0r8oTQ8XF2Y2K8106PD8HLXtFdExJmZFn4KCgrYuXMnUVFR/1eMiwtRUVFs3br1stsbhkF8fDwHDx6ka9euACQmJpKUlFRin97e3nTs2LFU+5SawWY3mB9/mMc+3U5SVgHN6tfiX3dHcluEru8RERETL3hOS0vDZrPh5+dXYrmfnx8HDhy46HaZmZn06tWLgoICXFxcmDJlCt27dwcgKSmpeB9/3WdycnKZa3TG35Pnjrm6HntydgGTV+3ipyNnABjUrgHP3dCKWu7WSq+luveyqlAfHUN9dAz10TEqqo+l3V+1O//v5eXFihUryMnJIT4+npdeeong4GC6devm8Ofy83Pe+75Ux2P/YV8yT338G8lZ+dRyszL9tvb8rXOQ2WVVy15WReqjY6iPjqE+OoZZfTQt/Pj6+mK1Ws+7uDklJQV/f/+Lbufi4kJISAgA4eHh7N+/n/fff59u3boREBBQvI/AwMAS+wwLCytzjSkpmRhGmTer1iyWsy/G6nTs58Zc8+OPYAAt/Grz0s3htPD3Ijk507S6qmMvqyL10THUR8dQHx2jovp4br+XY1r4cXd3p127dsTHx9O3b18A7HY78fHx3HvvvaXej91up6CgAICgoCACAgKIj48nPDwcgKysLLZt28Y//vGPMtdoGDjti7u6HHtSVj4vrNrFr4npANzaoSFje7fE081aZeqvLr2s6tRHx1AfHUN9dAyz+mjq2GvYsGE899xztG/fnoiICBYuXEhubi533HEHAOPGjaNBgwaMGTMGgPfee4/27dvTtGlTCgoK+O677/jiiy+YOnUqABaLhfvvv5933nmHkJAQgoKCmD17NoGBgcUBS2qO+EOpTFm9m7TcQmq7WRnfrzU3hgdefkMREXFqpoaf6OhoUlNTmTNnDklJSYSHhzN//vzisdeJEydwcfm/N6Tl5OQQExPDyZMn8fT0pEWLFsyaNYvo6OjidUaMGEFubi6TJ08mIyODzp07M3/+fDw8PCr9+KRiFNkN3v3hEAt/OgpA6wAvYgeFE1K/tsmViYhIdWAxDJ24u5jkZOeb6Vos4O/vXWWP/WRGHi+s2sW24xkADO7YiKevb4mHq+k3Kz9PVe9ldaE+Oob66Bjqo2NUVB/P7fdyqt27vcR5bTqQwtQvd5OeV4SXu5WJ/dvQLzTA7LJERKSaUfiRKq/IZuftTYf49y+JAIQ3qMPMQeEE1atlcmUiIlIdKfxIlXY8PY+JqxLYceLsW9bvimzMk71a4F4Fx1wiIlI9KPxIlbVhbzLT1u4hM78Ibw9XJg1oQ+/WF78HlIiISGko/EiVU1Bk562NB/n412MAtGvozcxB4TT28TS5MhERqQkUfqRKSTyTy4S4BBJOZQFwT+cgRvVshptVYy4REXEMhR+pMtbvSWL62j1kF9jw8XRl8o2h9Grpd/kNRUREykDhR0yXX2TnzQ37+WzbCQAiGtdlxsAwGtbVmEtERBxP4UdMdSQtl/Er/2BPUjYAD1wdzKNRIbhqzCUiIhVE4UdMszbhNDO/2ktOoY16tdyIuSmUqOb1zS5LRERqOIUfqXR5hTZe+3Y/K34/CUBkkA8vRocR6K3PXxMRkYqn8COV6mBKDuPj/mB/cg4WYNg1TRlxbQiuLhazSxMRESeh8COVZtXOU7z09V7yiuzUr+3GtOgwuoX4ml2WiIg4GYUfqXC5hTZeWb+PuJ2nAOjStB7To8Pw93I3uTIREXFGCj9SofYlZzNhZQIHU3NwscBD14bwYLemWDXmEhERkyj8SIUwDIMvdpxk1jf7yS+y4+/lzosDw+gcXM/s0kRExMkp/IjDZRcU8dLX+1iTcBqAa0J8iYkOpX5tjblERMR8Cj/iUHtOZzE+LoEjablYLfBI92Y8cHUwLhaNuUREpGpQ+BGHMAyDz7ef4PVv91NgMwis486MgeF0CvIxuzQREZESFH7kimXlFzFj3V6+3pMEQI8W9ZkyIJR6td1MrkxEROR8Cj9yRRJOZTIhLoHEM3lYXSyM6tGMe7oEacwlIiJVlsKPlIthGCzdepzZ3x+g0GbQqK4HMwaG06FxXbNLExERuSSFHymzjLxCpq/dw4Z9KQBc19KPyTe2oa6nxlwiIlL1KfxImew8kcGEuASOZ+Tj6mLhyeta8PfIxlg05hIRkWpC4UdKxTAM/rPlGG9tPIjNbtDYx5OZg8Jp19Db7NJERETKROFHLis9t5CYNbvZeCAVgBva+PNC/zbU8dDLR0REqh/99pJL2nYsnYmrdnEqMx83q4Wnr2/J3zo20phLRESqLYUfuSC7YbDop0Te2XQQmwHB9TyJHdSW0AZ1zC5NRETkiij8yHlSsvIZ/fkO/ncwDYABYQGM79caL3e9XEREpPrTbzMp4dejZ5j05W5OZeTj4erCmN4tua1DQ425RESkxlD4EQBsdoN//XSE9/93GLsBzerXInZQW1oFeJldmoiIiEMp/Agp2QVMXr2Ln46cAeCOq5owukczarlZzS1MRESkAij8OLmfj6TxwqpdpOYU4unqwnN9WzHs+tYkJ2diGGZXJyIi4ngKP07KZjeYH3+YD348ggG08KtN7M3htPTXmEtERGo2hR8nlJSVz6TVu9hyNB2AW9s3ZGyflnhqzCUiIk5A4cfJ/Hgolcmrd5OWW0gtNxfG92vNTeENzC5LRESk0ij8OIkiu8F7PxziXz8dBaB1gBczB4XTrH5tkysTERGpXAo/TuBUZj4vrErgt2MZAAzu2IjR17XQmEtERJySwk8N98OBVKZ8uYv0vCK83K1M6Nea/mGBZpclIiJiGoWfGqrIZuefmw6x+JdEAMIC6zBzUDjBvrVMrkxERMRcCj810ImMPCbGJfD7iUwA7opszJO9WuDu6mJyZSIiIuZT+KlhvtuXTMyaPWTmF1HHw8qkAaH0ae1vdlkiIiJVhsJPDVFoszPn+4N8/OsxANo29GbmoDCa+GjMJSIi8mcKPzVA4plcJsQlkHAqC4C7Ozfh8Z7NcbNqzCUiIvJXCj/V3Po9SUxfu4fsAht1PV2ZcmMovVr6mV2WiIhIlaXwU03lF9l5c8N+Ptt2AoAOjeoyc1AYDet6mlyZiIhI1abwUw0dSTs75tp9+uyY6/6uQYzs3gxXjblEREQuS+Gnmlm36zQz1u0lp9BGvVpuTL0plO7N65tdloiISLWh8FNN5BXaeH3DfpZvPwlAZJO6vDgwnEBvD5MrExERqV4UfqqBQyk5jI9LYF9yNhZg2DVNGXFtCK4uFrNLExERqXYUfqq41X+c4qWv95JbaKd+bTem3RRGt2a+ZpclIiJSbSn8VFG5hTZeWb+PuJ2nAOgS7MP06DD862jMJSIiciUUfqqg/cnZjI9L4GBKDi4WeOjaEB7s1hSrxlwiIiJXTOGnCjEMg5U7TvHKN/vIL7Lj5+XOjIFhdA6uZ3ZpIiIiNYbCTxWRU2Aj9uu9rEk4DcA1Ib7ERIdSv7a7yZWJiIjULAo/VcCe01mMj0vgSFouLhZ4tHszHrg6GBeLxlwiIiKOpvBjIsMwWL79BK99u58Cm0FgHXdeHBhOZJCP2aWJiIjUWKaHnyVLlvDBBx+QlJREWFgYkyZNIiIi4oLrLl26lBUrVrB3714A2rVrxzPPPFNi/eeff57ly5eX2K5Hjx588MEHFXcQ5ZCVX8TMr/by1e4kALo3r8/UG0OpV9vN5MpERERqNlPDz+rVq4mNjSUmJoaOHTuycOFChg8fzpo1a/DzO/+TyTdv3szAgQO56qqrcHd3Z/78+Tz44IOsWrWKBg0aFK/Xs2dPYmNji792d69a183sOpXJ+LgEEs/kYXWxMKpHM+7pEqQxl4iISCUwNfwsWLCAO++8k8GDBwMQExPDhg0bWLZsGQ8//PB567/22mslvn7xxRdZu3Yt8fHx3HbbbcXL3d3dCQgIqNDay8MwDD797ThvfneAQptBQ28PZgwKJ6JxXbNLExERcRqmhZ+CggJ27tzJI488UrzMxcWFqKgotm7dWqp95ObmUlRUhI9PyWtkfvrpJ6699lrq1q3LNddcw+jRo/H1LftdkR19Imb59pPM+mY/AL1a+jHlxjb41KpaY65zx6yTUFdOvXQM9dEx1EfHUB8do6L6WNr9mRZ+0tLSsNls5423/Pz8OHDgQKn28eqrrxIYGEhUVFTxsp49e9KvXz+CgoI4evQor7/+OiNGjOCTTz7BarWWqUY/P+8yrX85rZrk0LR+bR6IasaD3ZthqcLfPY4+dmemXjqG+ugY6qNjqI+OYVYfTb/gubzef/99Vq9ezaJFi/Dw+L+PfBg4cGDxf4eGhhIaGkrfvn2LzwaVRUpKJobhsJKJ8K/N5w92+f/7znLcjh3IYjn7YnT0sTsj9dIx1EfHUB8dQ310jIrq47n9Xo5p4cfX1xer1UpKSkqJ5SkpKfj7+19y2w8++ID333+fBQsWEBYWdsl1g4OD8fX15fDhw2UOP4aB0764nfnYHU29dAz10THUR8dQHx3DrD66VP5TnuXu7k67du2Ij48vXma324mPjycyMvKi282bN49//vOfzJ8/nw4dOlz2eU6ePMmZM2eq5AXQIiIiUvlMHXsNGzaM5557jvbt2xMREcHChQvJzc3ljjvuAGDcuHE0aNCAMWPGAGdHXXPmzOG1116jSZMmJCWdvUdO7dq18fLyIjs7m7lz5zJgwAD8/f05evQos2bNIiQkhJ49e5p2nCIiIlJ1mBp+oqOjSU1NZc6cOSQlJREeHs78+fOLx14nTpzAxeX/Tk59/PHHFBYW8uSTT5bYz+OPP84TTzyB1Wplz549rFixgszMTAIDA+nevTtPPfVUlbvXj4iIiJjDYhiaWl5McrLzXdBmsYC/v7dTHrujqZeOoT46hvroGOqjY1RUH8/t93JMu+ZHRERExAwKPyIiIuJUFH5ERETEqSj8iIiIiFNR+BERERGnovAjIiIiTkXhR0RERJyKwo+IiIg4FYUfERERcSqmfrxFVWexmF1B5Tt3zM547I6mXjqG+ugY6qNjqI+OUVF9LO3+9PEWIiIi4lQ09hIRERGnovAjIiIiTkXhR0RERJyKwo+IiIg4FYUfERERcSoKPyIiIuJUFH5ERETEqSj8iIiIiFNR+BERERGnovAjIiIiTkXhx0nZbDbefPNN+vTpQ0REBH379uXtt9/mz592YhgGs2fPpkePHkRERDB06FAOHTpkXtFVwM8//8yjjz5Kjx49CA0N5euvvy7xeGl6dubMGcaMGcNVV11Fly5dmDBhAtnZ2ZV4FOa7VB8LCwuZNWsWN998M506daJHjx6MGzeOU6dOldiH+nj51+OfTZ48mdDQUP71r3+VWK4+lq6P+/fv59FHH6Vz58506tSJwYMHc/z48eLH8/PziYmJoVu3bkRGRvLEE0+QnJxcmYdhusv1MTs7m2nTptGrVy8iIiKIjo7mo48+KrFOZfVR4cdJzZs3j48++ojJkyezevVqxo4dy/z581m8eHGJdRYvXszUqVNZunQptWrVYvjw4eTn55tYublycnIIDQ1lypQpF3y8ND0bO3Ys+/btY8GCBbz77rv88ssvTJ48ubIOoUq4VB/z8vL4448/GDlyJJ9//jlz587l4MGDjBw5ssR66uPlX4/nfPXVV2zbto3AwMDzHlMfL9/HI0eOcPfdd9OiRQsWL17MF198wWOPPYaHh0fxOjNnzuTbb7/lzTffZPHixZw+fZrHH3+8sg6hSrhcH1966SU2btzIrFmzWL16NQ888ADTp09n/fr1xetUWh8NcUoPP/ywMX78+BLLHn/8cWPMmDGGYRiG3W43unfvbsyfP7/48YyMDKN9+/ZGXFxcpdZaVbVp08b46quvir8uTc/27dtntGnTxti+fXvxOt99950RGhpqnDx5svKKr0L+2scL2bZtm9GmTRvj2LFjhmGojxdysT6ePHnS6Nmzp7Fnzx6jd+/exoIFC4ofUx/Pd6E+jh492hg7duxFt8nIyDDatWtnfPnll8XLzvV269atFVVqlXahPg4cONCYO3duiWW333678frrrxuGUbl91JkfJxUZGcmPP/7IwYMHAdi1axdbtmyhV69eACQmJpKUlERUVFTxNt7e3nTs2JGtW7eaUnNVV5qebd26lbp169KhQ4fidaKionBxcWH79u2VXnN1kZWVhcVioW7duoD6WFp2u51nn32W4cOH07p16/MeVx8vz263s2HDBpo1a8bw4cO59tprGTJkSImRzo4dOygsLCzxvd+yZUsaN27Mb7/9ZkLVVVNkZCTffPMNp06dwjCM4t9BPXr0ACq3j64O3ZtUGw8//DBZWVncdNNNWK1WbDYbTz/9NLfccgsASUlJAPj5+ZXYzs/Pz+nm2KVVmp4lJydTv379Eo+7urri4+NTvL2UlJ+fz6uvvsrAgQOpU6cOoD6W1rx583B1deX++++/4OPq4+WlpKSQk5PDvHnzGD16NGPHjmXjxo08/vjjLFq0iKuvvprk5GTc3NyKw/k5fn5+6uOfTJo0iUmTJtGrVy9cXV2xWCy8+OKLdO3aFaBS+6jw46S+/PJLVq5cyWuvvUarVq1ISEggNjaWwMBAbr/9drPLEwHOXvz81FNPYRgGMTExZpdTrezYsYNFixbx+eefY7FYzC6n2rLb7QDccMMNDB06FIDw8HB+/fVXPv74Y66++moTq6teFi9ezG+//cY777xD48aN+eWXX4iJiSEwMLDE2Z7KoPDjpF555RUefvhhBg4cCEBoaCjHjx/nvffe4/bbbycgIAA4+1fPny+STElJISwszJSaq7rS9Mzf35/U1NQS2xUVFZGenl68vZxVWFjI6NGjOX78OAsXLiw+6wPqY2n88ssvpKSk0Lt37+JlNpuNl19+mUWLFvHNN9+oj6Xg6+uLq6srLVu2LLG8ZcuWbNmyBTj7eiwsLCQjI6PEWYuUlBT18f/Ly8vjjTfeYO7cuVx//fUAhIWFkZCQwAcffEBUVFSl9lHX/DipvLy88/4atFqtxW91DwoKIiAggPj4+OLHs7Ky2LZtG5GRkZVaa3VRmp5FRkaSkZHBjh07itf58ccfsdvtREREVHrNVdW54HP48GH+9a9/4evrW+Jx9fHybr31Vr744gtWrFhR/C8wMJDhw4czf/58QH0sDXd3dzp06FB8feQ5hw4dokmTJgC0b98eNze3Et/7Bw4c4Pjx43Tq1Kkyy62yioqKKCwsvOTvncrso878OKnevXvz7rvv0rhx4+Kx14IFCxg8eDAAFouF+++/n3feeYeQkBCCgoKYPXs2gYGB9O3b1+TqzZOdnc2RI0eKv05MTCQhIQEfHx8aN2582Z61bNmSnj17MmnSJGJiYigsLGT69OkMHDiQBg0amHVYle5SfQwICODJJ5/kjz/+4L333sNmsxXP+318fHB3d1cf/7/LvR7/Ghrd3Nzw9/enRYsWgF6P51yuj8OHD+fpp5+ma9eudOvWjY0bN/Ltt9+yaNEi4OwbGwYPHsxLL72Ej48PderU4cUXXyQyMtKpws/l+nj11Vcza9YsPD09ady4MT///DMrVqzg+eefByq3jxbD+NNd7cRpZGVlMXv2bL7++uviMc3AgQMZNWoU7u7uwNkb9s2ZM4elS5eSkZFB586dmTJlCs2bNze5evNs3rz5gheP3n777bz00kul6tmZM2eYPn0633zzDS4uLvTv358XXngBLy+vyjwUU12qj48//jg33HDDBbdbtGgR3bp1A9RHuPzr8a/69OnD/fffX3ztCqiPULo+fvbZZ7z//vucPHmS5s2b88QTT5T4QzA/P5+XXnqJVatWUVBQQI8ePZgyZYpTjb0u18ekpCRef/11Nm3aRHp6Oo0bN+auu+5i6NChxWeEKquPCj8iIiLiVHTNj4iIiDgVhR8RERFxKgo/IiIi4lQUfkRERMSpKPyIiIiIU1H4EREREaei8CMiIiJOReFHREREnIrCj4hUGc8//zyPPfaYac//7LPP8u6771bY/vft20evXr3IycmpsOcQkcvTHZ5FpFKEhoZe8vHHH3+coUOHYhhGiU90riy7du3igQce4JtvvqnQj3Z48sknCQ0NZdSoURX2HCJyaQo/IlIpzn04KcDq1auZM2cOa9asKV5Wu3ZtUz9PauLEiVitVqZNm1ahz7NhwwZeeOEFNmzYgKurPltaxAwae4lIpQgICCj+5+3tjcViKbHMy8vrvLHXfffdx/Tp05kxYwZdu3YlKiqKpUuXkpOTw/jx44mMjKRfv3589913JZ5rz549PPTQQ0RGRhIVFcWzzz5LamrqRWuz2WysXbuWPn36lFjep08f/vnPfzJu3DgiIyPp3bs369evJzU1lZEjRxIZGcnNN9/M77//XrzNsWPHePTRR+natSudOnVi4MCBJeqLiooiPT2dn3/++UpbKiLlpPAjIlXa8uXL8fX15dNPP+Xee+9l6tSpPPXUU0RGRrJ8+XK6d+/OuHHjyM3NBSAjI4MHHniAtm3b8tlnnzF//nxSUlIYPXr0RZ9j9+7dZGZm0r59+/MeW7hwIVdddRXLly/nuuuuY9y4cYwbN45bbrmFzz//nKZNm/Lcc89x7iT6tGnTKCgo4N///jcrV65k7Nix1K5du3h/7u7uhIeH88svvzi2USJSago/IlKlhYWF8dhjj9GsWTMeeeQRPDw88PX15c4776RZs2aMGjWKM2fOsHv3bgD+/e9/07ZtW5555hlatmxJ27ZtmTlzJps3b+bgwYMXfI7jx49jtVrx8/M777FevXrx97//vfi5srKy6NChAzfddBPNmzdnxIgR7N+/n+Tk5OJ9XXXVVYSGhhIcHEzv3r3p2rVriX0GBgZy/PhxB3dKREpLA2cRqdL+fKG01WqlXr16tGnTpniZv78/ACkpKcDZC5c3b95MZGTkefs6cuQIzZs3P295Xl4e7u7uWCyWSz7/uef68/OfC0wpKSkEBARw//33M3XqVDZt2kRUVBT9+/cnLCysxD49PDyKz1SJSOVT+BGRKu2vFwVbLJYSy84FlnNjp5ycHHr37s3YsWPP21dAQMAFn8PX15fc3FwKCgpwd3e/6POfey43N7eLPv+QIUPo0aMHGzZs4IcffuD999/nueee47777iveJj09naZNm17myEWkomjsJSI1Srt27di7dy9NmjQhJCSkxL8/X3vzZ+Hh4QDs37/fITU0atSIf/zjH8ydO5dhw4axdOnSEo/v3bu3+DlFpPIp/IhIjXL33XeTnp7OM888w/bt2zly5AgbN25k/Pjx2Gy2C25Tv3592rVrx5YtW674+WfMmMHGjRs5evQoO3fuZPPmzbRs2bL48cTERE6dOkVUVNQVP5eIlI/GXiJSozRo0ICPPvqIV199leHDh1NQUEDjxo3p2bMnLi4X/3vvb3/7G//973+59957r+j57XY706ZN4+TJk9SpU4eePXsyfvz44sdXrVpF9+7dadKkyRU9j4iUn25yKCLC2Yueb7zxRt54440LXiztCAUFBQwYMIBXX32Vzp07V8hziMjlKfyIiPx/mzdvJjs7+7ybHTrK4cOHiY+P5+9//3uF7F9ESkfhR0RERJyKLngWERERp6LwIyIiIk5F4UdEREScisKPiIiIOBWFHxEREXEqCj8iIiLiVBR+RERExKko/IiIiIhTUfgRERERp/L/AAUUqVqIW7/FAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ramp.plot()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### APWaveform Stimulus\n",
+    "\n",
+    "Here we will create an APWaveform Stimulus object which is a type of Step Stimulus."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "CombinedStimulus(dt=0.1)"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "apwaveform = stim_factory.ap_waveform(threshold_current=0.5)\n",
+    "apwaveform"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3000,)"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "apwaveform.current.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(3000,)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "apwaveform.time.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'CombinedStimulus'}, xlabel='Time (ms)', ylabel='Current (nA)'>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "apwaveform.plot()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: title={'center': 'CombinedStimulus'}, xlabel='Time (ms)', ylabel='Current (nA)'>"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "apwaveform.plot_during_simulation(600)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "3000"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(apwaveform)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Combining Stimuli\n",
+    "\n",
+    "We can also combine multiple stimuli into a single stimulus. In fact APWaveform is a combined stimulus.\n",
+    "\n",
+    "\n",
+    "**Note:** The stimuli are combined in the order they are added."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "stim2 = stim_factory.ramp(start=200, end=450, amplitude_start=0.2, amplitude_end=0.5)\n",
+    "stim3 = stim_factory.step(start=0, end=150, amplitude=0.21)\n",
+    "stim4 = stim_factory.step(start=0, end=150, amplitude=0.0)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "combined_stimulus = stim2 + stim4 + stim3 + stim2"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x500 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "ax = combined_stimulus.plot(marker='o', drawstyle='steps-post', color='w', markersize=4, markerfacecolor='c', markeredgecolor='c', markeredgewidth=1)\n",
+    "ax.figure.set_size_inches(10, 5)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Applying the Stimulus to the Neuron Model\n",
+    "\n",
+    "Now let's apply the combined stimulus we created to a Neuron model and simulate.\n",
+    "\n",
+    "### Creating the Cell (Neuron)\n",
+    "\n",
+    "Next, we load a basic neuron model that we'll be using for our simulation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To display them on the same axis we can use the function `plot_during_simulation` to plot the current for the duration we specify."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\t1 \n",
+      "Running the simulation...\n",
+      "Done.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# in another simulation inject the combined stimulus\n",
+    "cell = create_ball_stick()\n",
+    "cell.inject_current_waveform(t_content=combined_stimulus.time, i_content=combined_stimulus.current)\n",
+    "sim = Simulation(cell)\n",
+    "duration = 1500\n",
+    "print(\"Running the simulation...\")\n",
+    "sim.run(duration, dt=0.1)\n",
+    "print(\"Done.\")\n",
+    "time, voltage = cell.get_time(), cell.get_soma_voltage()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(2, 1, figsize=(12, 8))  # 2 rows, 1 column, wider figure\n",
+    "\n",
+    "# Plot voltage over time on the first subplot\n",
+    "axs[0].plot(time, voltage, marker='.', markersize=0.1, color='k', linewidth=0.15)\n",
+    "axs[0].set_title('Time vs Voltage')\n",
+    "axs[0].set_xlim(left=0)  # Make the plot start from 0 on the x-axis\n",
+    "\n",
+    "# Plot injected current over time on the second subplot\n",
+    "axs[1] = combined_stimulus.plot_during_simulation(duration, axs[1], marker='.', drawstyle='steps-post', color='w', markersize=1, markerfacecolor='c', markeredgecolor='c', markeredgewidth=1)\n",
+    "axs[1].set_title('Time vs Injected Current')\n",
+    "axs[1].set_xlim(left=0)  # Make the plot start from 0 on the x-axis\n",
+    "\n",
+    "plt.tight_layout()  # Adjusts subplot params so that subplots fit into the figure area\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In the plot above we see that the voltage activity start at the time we inject the stimulus and it lasts until the stimulus ends."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "More information on the available stimuli can be found at the documentation: https://bluecellulab.readthedocs.io/en/latest/"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.11.7"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/examples/README.rst b/examples/README.rst
index 326084f5..b0d2b00d 100644
--- a/examples/README.rst
+++ b/examples/README.rst
@@ -19,3 +19,5 @@ BlueCelluLab's usage examples
      - Simulating back propagating action potential in a dendritic tree
    * - `epsp.ipynb <4-epsp/epsp.ipynb>`_
      - Simulating excitatory post synaptic potential on a Hippocampal CA1 cell
+   * - Exploring the stimuli available at BlueCelluLab
+     - `stimuli.ipynb <5-stimuli/stimuli.ipynb>`_
diff --git a/pyproject.toml b/pyproject.toml
index 11d11811..c89294fc 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,5 +22,6 @@ omit = [
 [tool.coverage.report]
 exclude_lines = [
     "pragma: no cover",
-    "raise NotImplementedError"
+    "raise NotImplementedError",
+    "..."
 ]
diff --git a/tests/test_cell/test_injector.py b/tests/test_cell/test_injector.py
index 1bb8ccac..914873c6 100644
--- a/tests/test_cell/test_injector.py
+++ b/tests/test_cell/test_injector.py
@@ -13,7 +13,7 @@
 
 from bluecellulab.circuit import SonataCircuitAccess
 from bluecellulab.circuit.node_id import CellId
-from bluecellulab.stimuli import (
+from bluecellulab.stimulus.circuit_stimulus_definitions import (
     Pulse,
     Noise,
     Hyperpolarizing,
@@ -71,15 +71,15 @@ def test_inject_pulse(self):
 
     def test_inject_step(self):
         """Test the step current injection."""
-        tstim = self.cell.add_step(start_time=2.0, stop_time=6.0, level=1.0)
-        assert tstim.stim.to_python() == [0.0, 1.0, 1.0, 0.0, 0.0]
-        assert tstim.tvec.to_python() == [2.0, 2.0, 6.0, 6.0, 6.0]
+        t_arr, i_arr = self.cell.add_step(start_time=2.0, stop_time=6.0, level=1.0, dt=1)
+        assert t_arr.tolist() == [2., 3., 4., 5.]
+        assert i_arr.tolist() == [1., 1., 1., 1.]
 
     def test_inject_ramp(self):
         """Test the ramp injection."""
-        tstim = self.cell.add_ramp(start_time=2.0, stop_time=6.0, start_level=0.5, stop_level=1)
-        assert tstim.stim.to_python() == [0.0, 0.0, 0.5, 1.0, 0.0, 0.0]
-        assert tstim.tvec.to_python() == [0.0, 2.0, 2.0, 6.0, 6.0, 6.0]
+        t_arr, i_arr = self.cell.add_ramp(start_time=2.0, stop_time=6.0, start_level=0.5, stop_level=1, dt=1)
+        np.testing.assert_allclose(t_arr, [2., 3., 4., 5.], rtol=1e-5)
+        np.testing.assert_allclose(i_arr, [0.5, 0.666667, 0.833333, 1], rtol=1e-5)
 
     def test_voltage_clamp(self):
         """Test adding voltage clamp."""
@@ -396,7 +396,7 @@ def test_inject_current_waveform(self):
         i_content = [amplitude * math.sin(freq * (x - start_time) * (
             2 * math.pi)) + mid_level for x in t_content]
 
-        current = self.cell.injectCurrentWaveform(t_content, i_content)
+        current = self.cell.inject_current_waveform(t_content, i_content)
         assert current.as_numpy() == approx(np.array(
             [0.00000000e+00, 2.35726407e-14, 4.71452814e-14, -6.11403104e-13,
              9.42905627e-14, -1.92849988e-12, -1.22280621e-12, -3.24559665e-12,
diff --git a/tests/test_circuit/test_simulation_access.py b/tests/test_circuit/test_simulation_access.py
index ddb83385..f62eda25 100644
--- a/tests/test_circuit/test_simulation_access.py
+++ b/tests/test_circuit/test_simulation_access.py
@@ -46,8 +46,7 @@ class TestSonataSimulationAccess:
     def setup_method(self):
         self.simulation_access = SonataSimulationAccess(str(hipp_simulation_with_projections))
 
-    @staticmethod
-    def test_init_file_not_found():
+    def test_init_file_not_found(self):
         """Test BluepySimulationAccess init edge cases."""
         with pytest.raises(FileNotFoundError):
             SonataSimulationAccess(parent_dir / "examples" / "non_existing_file")
diff --git a/tests/test_circuit/test_simulation_config.py b/tests/test_circuit/test_simulation_config.py
index ed598261..cbaf5d6d 100644
--- a/tests/test_circuit/test_simulation_config.py
+++ b/tests/test_circuit/test_simulation_config.py
@@ -12,7 +12,7 @@
     ConnectionOverrides,
     MechanismConditions,
 )
-from bluecellulab.stimuli import Noise, Hyperpolarizing
+from bluecellulab.stimulus.circuit_stimulus_definitions import Noise, Hyperpolarizing
 from tests.helpers.os_utils import cwd
 
 
diff --git a/tests/test_stimulus/__init__.py b/tests/test_stimulus/__init__.py
new file mode 100644
index 00000000..e69de29b
diff --git a/tests/test_stimuli.py b/tests/test_stimulus/test_circuit_stimulus_definitions.py
similarity index 79%
rename from tests/test_stimuli.py
rename to tests/test_stimulus/test_circuit_stimulus_definitions.py
index 2d50d0ba..4729f0ac 100644
--- a/tests/test_stimuli.py
+++ b/tests/test_stimulus/test_circuit_stimulus_definitions.py
@@ -2,13 +2,13 @@
 
 from pydantic import ValidationError
 import pytest
-from bluecellulab.stimuli import SynapseReplay
+from bluecellulab.stimulus.circuit_stimulus_definitions import SynapseReplay
 
 
 def test_synapse_replay_validator():
     """Assures synapse replay's validator fails."""
     with pytest.raises(ValidationError):
-        synapse_replay = SynapseReplay(
+        _ = SynapseReplay(
             target="target1",
             source="source1",
             delay=0,
diff --git a/tests/test_stimulus/test_factory.py b/tests/test_stimulus/test_factory.py
new file mode 100644
index 00000000..f399dc89
--- /dev/null
+++ b/tests/test_stimulus/test_factory.py
@@ -0,0 +1,143 @@
+import pytest
+import numpy as np
+
+from bluecellulab.stimulus.factory import CombinedStimulus, EmptyStimulus, Stimulus, Step, Ramp, StimulusFactory
+
+
+class TestStimulus:
+
+    def test_abstract_methods(self):
+        with pytest.raises(TypeError):
+            s = Stimulus(0.1)
+
+    def test_repr(self):
+        s = Step(0.1, 1, 2, 3)
+        assert repr(s) == "Step(dt=0.1)"
+
+    def test_len(self):
+        s = Step(0.1, 1, 2, 3)
+        assert len(s) == 10
+
+    def test_plot(self):
+        s = Step(0.1, 1, 2, 3)
+        ax = s.plot()
+        assert ax.get_xlabel() == "Time (ms)"
+        assert ax.get_ylabel() == "Current (nA)"
+        assert ax.get_title() == "Step"
+
+    def test_plot_during_simulation(self):
+        s = Step(0.1, 1, 2, 3)
+        duration = 15
+        ax = s.plot_during_simulation(duration)
+        assert ax.get_xlim() == (0, duration)
+
+
+class TestStimulusFactory:
+
+    def setup_method(self):
+        self.dt = 0.1
+        self.factory = StimulusFactory(dt=self.dt)
+
+    def test_create_step(self):
+        s = self.factory.step(1, 2, 3)
+        assert isinstance(s, Step)
+        assert np.all(s.time == np.arange(1, 2, self.dt))
+        assert np.all(s.current == np.full(10, 3))
+
+    def test_create_ramp(self):
+        s = self.factory.ramp(1, 2, 3, 4)
+        assert isinstance(s, Ramp)
+        assert np.all(s.time == np.arange(1, 2, self.dt))
+        assert np.all(s.current == np.linspace(3, 4, 10))
+
+    def test_create_ap_waveform(self):
+        s = self.factory.ap_waveform(threshold_current=1)
+        assert isinstance(s, CombinedStimulus)
+        # below write np almost equal
+        np.testing.assert_allclose(s.time, np.arange(250, 550, self.dt))
+        assert s.current[0] == 2.2
+        assert s.current[-1] == 0.0
+
+    def test_create_idrest(self):
+        s = self.factory.idrest(threshold_current=1)
+        assert isinstance(s, CombinedStimulus)
+        assert s.stimulus_time == 1600
+
+    def test_create_iv(self):
+        s = self.factory.iv(threshold_current=1)
+        assert isinstance(s, CombinedStimulus)
+        assert s.stimulus_time == 3250
+        # assert there are negative values
+        assert np.any(s.current < 0)
+        # assert no positive values
+        assert not np.any(s.current > 0)
+
+    def test_create_fire_pattern(self):
+        s = self.factory.fire_pattern(threshold_current=1)
+        assert isinstance(s, CombinedStimulus)
+        assert s.stimulus_time == 3850
+
+
+def test_combined_stimulus():
+    """Test combining Stimulus objects."""
+    s1 = Step(0.1, 1, 2, 3)
+    s2 = Step(0.1, 3, 4, 5)
+    combined = s1 + s2
+
+    assert isinstance(combined, CombinedStimulus)
+    assert np.all(combined.time == np.concatenate([s1.time, s2.time + s1.time[-1] + 0.1]))
+    assert np.all(combined.current == np.concatenate([s1.current, s2.current]))
+    assert combined.dt == 0.1
+    assert len(combined) == len(s1) + len(s2)
+    assert combined.stimulus_time == (len(combined) * combined.dt)
+
+
+def test_combined_stimulus_different_dt():
+    s1 = Step(0.1, 1, 2, 3)
+    s2 = Step(0.2, 3, 4, 5)
+    with pytest.raises(ValueError):
+        combined = s1 + s2
+
+
+def test_empty_stimulus():
+    dt = 0.2
+    duration = 1.0
+    stimulus = EmptyStimulus(dt, duration)
+
+    assert stimulus.dt == dt
+    assert np.all(stimulus.time == np.arange(0, duration, dt))
+    assert np.all(stimulus.current == np.zeros_like(stimulus.time))
+
+
+def test_combine_multiple_stimuli():
+    """Test combining multiple stimuli."""
+    dt = 0.1
+    stim1 = Step(dt, 99, 101, 3)
+    stim2 = Ramp(dt, 3, 4, 2, 4)
+    stim3 = EmptyStimulus(dt, 1)
+    stim4 = Step(dt, 5, 6, 1)
+
+    combined = stim1 + stim2 + stim3 + stim4
+
+    assert isinstance(combined, CombinedStimulus)
+    assert combined.dt == dt
+
+    shifted_stim2_time = stim2.time + stim1.time[-1] + dt
+    shifted_stim3_time = stim3.time + shifted_stim2_time[-1] + dt
+    shifted_stim4_time = stim4.time + shifted_stim3_time[-1] + dt
+
+    expected_time = np.concatenate([
+        stim1.time,
+        shifted_stim2_time,
+        shifted_stim3_time,
+        shifted_stim4_time,
+    ])
+    expected_current = np.concatenate([
+        stim1.current,
+        stim2.current,
+        stim3.current,
+        stim4.current,
+    ])
+
+    assert np.all(combined.time == expected_time)
+    assert np.all(combined.current == expected_current)
diff --git a/tests/test_tools.py b/tests/test_tools.py
index b04b7b3a..67cb8f64 100644
--- a/tests/test_tools.py
+++ b/tests/test_tools.py
@@ -126,7 +126,7 @@ def test_calculate_input_resistance(self):
             emodel_properties=self.emodel_properties,
         )
 
-        assert input_resistance == pytest.approx(375.8880669033445)
+        assert input_resistance == pytest.approx(375.7000429068128)
 
     def test_calculate_SS_voltage(self):
         """Unit test calculate_SS_voltage."""
@@ -138,7 +138,7 @@ def test_calculate_SS_voltage(self):
             emodel_properties=self.emodel_properties,
             step_level=step_level,
         )
-        assert SS_voltage == pytest.approx(-85.13127127240696)
+        assert SS_voltage == pytest.approx(-85.13054046713455)
 
     def test_calculate_SS_voltage_subprocess_exception(self):
         """Unit test calculate_SS_voltage_subprocess."""
diff --git a/tox.ini b/tox.ini
index 77bcb68b..d3f29bda 100644
--- a/tox.ini
+++ b/tox.ini
@@ -50,12 +50,14 @@ commands =
 [testenv:examples]
 envdir={toxworkdir}/{envname}
 deps =
-    pytest>=7.3.1
-    nbmake>=1.4.1
+    pytest>=8.1.0,<9.0.0
+    pytest-xdist>=3.3.1  # multiprocessing
+    pytest-forked>=1.6.0  # isolation
+    nbmake>=1.5.1
     scipy>=1.11.1
     seaborn>=0.12.2
 commands =
-    pytest --nbmake examples
+    pytest --numprocesses=auto --forked --nbmake examples
 
 [testenv:docs]
 envdir =