diff --git a/.github/workflows/lint.yml b/.github/workflows/lint.yml
index b3d41fbaf..d94c8972c 100644
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -2,9 +2,9 @@ name: Lint
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, staging-dynamic ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, staging-dynamic ]
 
 jobs:
   build:
@@ -32,7 +32,7 @@ jobs:
       - name: Install dependencies
         run: |
           python -m pip install --upgrade pip
-          pip install .[test]
+          pip install .[test,dynamical]
 
       - name: Lint
         run: ./scripts/lint.sh
diff --git a/.github/workflows/test.yml b/.github/workflows/test.yml
index ec35d646e..623b04444 100644
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -2,9 +2,9 @@ name: Test
 
 on:
   push:
-    branches: [ master ]
+    branches: [ master, staging-dynamic ]
   pull_request:
-    branches: [ master ]
+    branches: [ master, staging-dynamic ]
 
 jobs:
   build:
@@ -46,7 +46,7 @@ jobs:
         run: |
           sudo apt install -y pandoc
           python -m pip install --upgrade pip
-          pip install .[test]
+          pip install .[test,dynamical]
 
       - name: Test
         shell: bash
diff --git a/chirho/dynamical/__init__.py b/chirho/dynamical/__init__.py
new file mode 100644
index 000000000..42bfed9da
--- /dev/null
+++ b/chirho/dynamical/__init__.py
@@ -0,0 +1 @@
+from . import internals  # noqa: F401
diff --git a/chirho/dynamical/handlers/__init__.py b/chirho/dynamical/handlers/__init__.py
new file mode 100644
index 000000000..0e48323e3
--- /dev/null
+++ b/chirho/dynamical/handlers/__init__.py
@@ -0,0 +1,12 @@
+from ..internals.solver import Solver  # noqa: F401
+from .event_loop import InterruptionEventLoop  # noqa: F401
+from .interruption import (  # noqa: F401
+    DynamicInterruption,
+    DynamicIntervention,
+    Interruption,
+    StaticBatchObservation,
+    StaticInterruption,
+    StaticIntervention,
+    StaticObservation,
+)
+from .trajectory import LogTrajectory  # noqa: F401
diff --git a/chirho/dynamical/handlers/event_loop.py b/chirho/dynamical/handlers/event_loop.py
new file mode 100644
index 000000000..d87845ce2
--- /dev/null
+++ b/chirho/dynamical/handlers/event_loop.py
@@ -0,0 +1,51 @@
+from __future__ import annotations
+
+from typing import Generic, TypeVar
+
+import pyro
+
+from chirho.dynamical.handlers.interruption import Interruption
+from chirho.dynamical.internals.solver import (
+    apply_interruptions,
+    get_solver,
+    simulate_to_interruption,
+)
+
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+class InterruptionEventLoop(Generic[T], pyro.poutine.messenger.Messenger):
+    def _pyro_simulate(self, msg) -> None:
+        dynamics, state, start_time, end_time = msg["args"]
+        if msg["kwargs"].get("solver", None) is not None:
+            solver = msg["kwargs"]["solver"]
+        else:
+            solver = get_solver()
+
+        # Simulate through the timespan, stopping at each interruption. This gives e.g. intervention handlers
+        #  a chance to modify the state and/or dynamics before the next span is simulated.
+        while start_time < end_time:
+            with pyro.poutine.messenger.block_messengers(
+                lambda m: m is self or (isinstance(m, Interruption) and m.used)
+            ):
+                state, terminal_interruptions, start_time = simulate_to_interruption(
+                    solver,
+                    dynamics,
+                    state,
+                    start_time,
+                    end_time,
+                )
+                for h in terminal_interruptions:
+                    h.used = True
+
+            with pyro.poutine.messenger.block_messengers(
+                lambda m: isinstance(m, Interruption)
+                and m not in terminal_interruptions
+            ):
+                dynamics, state = apply_interruptions(dynamics, state)
+
+        msg["value"] = state
+        msg["stop"] = True
+        msg["done"] = True
+        msg["in_SEL"] = True
diff --git a/chirho/dynamical/handlers/interruption.py b/chirho/dynamical/handlers/interruption.py
new file mode 100644
index 000000000..f647171ed
--- /dev/null
+++ b/chirho/dynamical/handlers/interruption.py
@@ -0,0 +1,177 @@
+import numbers
+import warnings
+from typing import Callable, Generic, Optional, TypeVar, Union
+
+import pyro
+import torch
+
+from chirho.dynamical.handlers.trajectory import LogTrajectory
+from chirho.dynamical.ops import State, get_keys
+from chirho.indexed.ops import get_index_plates, indices_of
+from chirho.interventional.ops import Intervention, intervene
+from chirho.observational.ops import Observation, observe
+
+R = Union[numbers.Real, torch.Tensor]
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+class Interruption(pyro.poutine.messenger.Messenger):
+    used: bool
+
+    def __enter__(self):
+        self.used = False
+        return super().__enter__()
+
+    def _pyro_simulate_to_interruption(self, msg) -> None:
+        raise NotImplementedError("shouldn't be here!")
+
+
+class StaticInterruption(Interruption):
+    time: R
+
+    def __init__(self, time: R):
+        self.time = torch.as_tensor(time)  # TODO enforce this where it is needed
+        super().__init__()
+
+    def _pyro_simulate_to_interruption(self, msg) -> None:
+        _, _, _, start_time, end_time = msg["args"]
+
+        if start_time < self.time < end_time:
+            next_static_interruption: Optional[StaticInterruption] = msg["kwargs"].get(
+                "next_static_interruption", None
+            )
+
+            # Usurp the next static interruption if this one occurs earlier.
+            if (
+                next_static_interruption is None
+                or self.time < next_static_interruption.time
+            ):
+                msg["kwargs"]["next_static_interruption"] = self
+        elif self.time >= end_time:
+            warnings.warn(
+                f"{StaticInterruption.__name__} time {self.time} occurred after the end of the timespan "
+                f"{end_time}. This interruption will have no effect.",
+                UserWarning,
+            )
+
+
+class DynamicInterruption(Generic[T], Interruption):
+    """
+    :param event_f: An event trigger function that approaches and returns 0.0 when the event should be triggered.
+        This can be designed to trigger when the current state is "close enough" to some trigger state, or when an
+        element of the state exceeds some threshold, etc. It takes both the current time and current state.
+    """
+
+    def __init__(self, event_f: Callable[[R, State[T]], R]):
+        self.event_f = event_f
+        super().__init__()
+
+    def _pyro_simulate_to_interruption(self, msg) -> None:
+        msg["kwargs"].setdefault("dynamic_interruptions", []).append(self)
+
+
+class _InterventionMixin(Generic[T]):
+    """
+    We use this to provide the same functionality to both StaticIntervention and the DynamicIntervention,
+     while allowing DynamicIntervention to not inherit StaticInterruption functionality.
+    """
+
+    intervention: Intervention[State[T]]
+
+    def _pyro_apply_interruptions(self, msg) -> None:
+        dynamics, initial_state = msg["args"]
+        msg["args"] = (dynamics, intervene(initial_state, self.intervention))
+
+
+class _PointObservationMixin(Generic[T]):
+    observation: Observation[State[T]]
+    time: R
+
+    def _pyro_apply_interruptions(self, msg) -> None:
+        dynamics = msg["args"][0]
+        state: State[T] = msg["args"][1]
+        msg["value"] = (dynamics, observe(state, self.observation))
+
+    def _pyro_sample(self, msg):
+        # modify observed site names to handle multiple time points
+        msg["name"] = msg["name"] + "_" + str(torch.as_tensor(self.time).item())
+
+
+class StaticObservation(Generic[T], StaticInterruption, _PointObservationMixin[T]):
+    def __init__(
+        self,
+        time: R,
+        observation: Observation[State[T]],
+        *,
+        eps: float = 1e-6,
+    ):
+        self.observation = observation
+        # Add a small amount of time to the observation time to ensure that
+        # the observation occurs after the logging period.
+        super().__init__(time + eps)
+
+
+class StaticIntervention(Generic[T], StaticInterruption, _InterventionMixin[T]):
+    """
+    This effect handler interrupts a simulation at a given time, and
+    applies an intervention to the state at that time.
+
+    :param time: The time at which the intervention is applied.
+    :param intervention: The instantaneous intervention applied to the state when the event is triggered.
+    """
+
+    def __init__(self, time: R, intervention: Intervention[State[T]]):
+        self.intervention = intervention
+        super().__init__(time)
+
+
+class DynamicIntervention(Generic[T], DynamicInterruption, _InterventionMixin[T]):
+    """
+    This effect handler interrupts a simulation when the given dynamic event function returns 0.0, and
+    applies an intervention to the state at that time.
+
+    :param intervention: The instantaneous intervention applied to the state when the event is triggered.
+    """
+
+    def __init__(
+        self,
+        event_f: Callable[[R, State[T]], R],
+        intervention: Intervention[State[T]],
+    ):
+        self.intervention = intervention
+        super().__init__(event_f)
+
+
+class StaticBatchObservation(Generic[T], LogTrajectory[T]):
+    observation: Observation[State[T]]
+
+    def __init__(
+        self,
+        times: torch.Tensor,
+        observation: Observation[State[T]],
+        *,
+        eps: float = 1e-6,
+    ):
+        self.observation = observation
+        super().__init__(times, eps=eps)
+
+    def _pyro_post_simulate(self, msg) -> None:
+        super()._pyro_post_simulate(msg)
+
+        # This checks whether the simulate has already redirected in a InterruptionEventLoop.
+        # If so, we don't want to run the observation again.
+        if msg.setdefault("in_SEL", False):
+            return
+
+        # TODO remove this redundant check by fixing semantics of LogTrajectory and simulate
+        name_to_dim = {k: f.dim - 1 for k, f in get_index_plates().items()}
+        name_to_dim["__time"] = -1
+        len_traj = (
+            0
+            if not get_keys(self.trajectory)
+            else 1 + max(indices_of(self.trajectory, name_to_dim=name_to_dim)["__time"])
+        )
+
+        if len_traj == len(self.times):
+            msg["value"] = observe(self.trajectory, self.observation)
diff --git a/chirho/dynamical/handlers/solver.py b/chirho/dynamical/handlers/solver.py
new file mode 100644
index 000000000..92b792242
--- /dev/null
+++ b/chirho/dynamical/handlers/solver.py
@@ -0,0 +1,16 @@
+from chirho.dynamical.internals.solver import Solver
+
+
+class TorchDiffEq(Solver):
+    def __init__(self, rtol=1e-7, atol=1e-9, method=None, options=None):
+        self.rtol = rtol
+        self.atol = atol
+        self.method = method
+        self.options = options
+        self.odeint_kwargs = {
+            "rtol": rtol,
+            "atol": atol,
+            "method": method,
+            "options": options,
+        }
+        super().__init__()
diff --git a/chirho/dynamical/handlers/trajectory.py b/chirho/dynamical/handlers/trajectory.py
new file mode 100644
index 000000000..888167b9a
--- /dev/null
+++ b/chirho/dynamical/handlers/trajectory.py
@@ -0,0 +1,70 @@
+import typing
+from typing import Generic, TypeVar
+
+import pyro
+import torch
+
+from chirho.dynamical.internals._utils import _squeeze_time_dim, append
+from chirho.dynamical.internals.solver import Solver, get_solver, simulate_trajectory
+from chirho.dynamical.ops import State
+from chirho.indexed.ops import IndexSet, gather, get_index_plates
+
+T = TypeVar("T")
+
+
+class LogTrajectory(Generic[T], pyro.poutine.messenger.Messenger):
+    trajectory: State[T]
+
+    def __init__(self, times: torch.Tensor, *, eps: float = 1e-6):
+        # Adding epsilon to the logging times to avoid collision issues with the logging times being exactly on the
+        #  boundaries of the simulation times. This is a hack, but it's a hack that should work for now.
+        self.times = times + eps
+
+        # Require that the times are sorted. This is required by the index masking we do below.
+        if not torch.all(self.times[1:] > self.times[:-1]):
+            raise ValueError("The passed times must be sorted.")
+
+        super().__init__()
+
+    def __enter__(self) -> "LogTrajectory[T]":
+        self.trajectory: State[T] = State()
+        return super().__enter__()
+
+    def _pyro_simulate(self, msg) -> None:
+        msg["done"] = True
+
+    def _pyro_post_simulate(self, msg) -> None:
+        # Turn a simulate that returns a state into a simulate that returns a trajectory at each of the logging_times
+        dynamics, initial_state, start_time, end_time = msg["args"]
+        if msg["kwargs"].get("solver", None) is not None:
+            solver = typing.cast(Solver, msg["kwargs"]["solver"])
+        else:
+            solver = get_solver()
+
+        filtered_timespan = self.times[
+            (self.times >= start_time) & (self.times <= end_time)
+        ]
+        timespan = torch.concat(
+            (start_time.unsqueeze(-1), filtered_timespan, end_time.unsqueeze(-1))
+        )
+
+        trajectory = simulate_trajectory(
+            solver,
+            dynamics,
+            initial_state,
+            timespan,
+        )
+
+        # TODO support dim != -1
+        idx_name = "__time"
+        name_to_dim = {k: f.dim - 1 for k, f in get_index_plates().items()}
+        name_to_dim[idx_name] = -1
+
+        if len(timespan) > 2:
+            part_idx = IndexSet(**{idx_name: set(range(1, len(timespan) - 1))})
+            new_part = gather(trajectory, part_idx, name_to_dim=name_to_dim)
+            self.trajectory: State[T] = append(self.trajectory, new_part)
+
+        final_idx = IndexSet(**{idx_name: {len(timespan) - 1}})
+        final_state = gather(trajectory, final_idx, name_to_dim=name_to_dim)
+        msg["value"] = _squeeze_time_dim(final_state)
diff --git a/chirho/dynamical/internals/__init__.py b/chirho/dynamical/internals/__init__.py
new file mode 100644
index 000000000..15097fed7
--- /dev/null
+++ b/chirho/dynamical/internals/__init__.py
@@ -0,0 +1,4 @@
+# Include only imports that are needed for registering dispatches.
+
+from . import _utils  # noqa: F401
+from . import backends  # noqa: F401
diff --git a/chirho/dynamical/internals/_utils.py b/chirho/dynamical/internals/_utils.py
new file mode 100644
index 000000000..9fa4706e9
--- /dev/null
+++ b/chirho/dynamical/internals/_utils.py
@@ -0,0 +1,107 @@
+import functools
+from typing import FrozenSet, Optional, Tuple, TypeVar
+
+import torch
+
+from chirho.dynamical.ops import State, get_keys
+from chirho.indexed.ops import IndexSet, gather, indices_of, union
+from chirho.interventional.handlers import intervene
+from chirho.observational.ops import Observation, observe
+
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+@indices_of.register(State)
+def _indices_of_state(state: State, *, event_dim: int = 0, **kwargs) -> IndexSet:
+    return union(
+        *(indices_of(state[k], event_dim=event_dim, **kwargs) for k in get_keys(state))
+    )
+
+
+@gather.register(State)
+def _gather_state(
+    state: State[T], indices: IndexSet, *, event_dim: int = 0, **kwargs
+) -> State[T]:
+    return type(state)(
+        **{
+            k: gather(state[k], indices, event_dim=event_dim, **kwargs)
+            for k in get_keys(state)
+        }
+    )
+
+
+@intervene.register(State)
+def _state_intervene(obs: State[T], act: State[T], **kwargs) -> State[T]:
+    new_state: State[T] = State()
+    for k in get_keys(obs):
+        new_state[k] = intervene(obs[k], act[k] if k in act else None, **kwargs)
+    return new_state
+
+
+@functools.singledispatch
+def append(fst, rest: T) -> T:
+    raise NotImplementedError(f"append not implemented for type {type(fst)}.")
+
+
+@append.register(State)
+def _append_trajectory(traj1: State[T], traj2: State[T]) -> State[T]:
+    if len(get_keys(traj1)) == 0:
+        return traj2
+
+    if len(get_keys(traj2)) == 0:
+        return traj1
+
+    if get_keys(traj1) != get_keys(traj2):
+        raise ValueError(
+            f"Trajectories must have the same keys to be appended, but got {get_keys(traj1)} and {get_keys(traj2)}."
+        )
+
+    result: State[T] = State()
+    for k in get_keys(traj1):
+        result[k] = append(traj1[k], traj2[k])
+    return result
+
+
+@append.register(torch.Tensor)
+def _append_tensor(prev_v: torch.Tensor, curr_v: torch.Tensor) -> torch.Tensor:
+    time_dim = -1  # TODO generalize to nontrivial event_shape
+    batch_shape = torch.broadcast_shapes(prev_v.shape[:-1], curr_v.shape[:-1])
+    prev_v = prev_v.expand(*batch_shape, *prev_v.shape[-1:])
+    curr_v = curr_v.expand(*batch_shape, *curr_v.shape[-1:])
+    return torch.cat([prev_v, curr_v], dim=time_dim)
+
+
+@functools.lru_cache
+def _var_order(varnames: FrozenSet[str]) -> Tuple[str, ...]:
+    return tuple(sorted(varnames))
+
+
+def _squeeze_time_dim(traj: State[torch.Tensor]) -> State[torch.Tensor]:
+    return State(**{k: traj[k].squeeze(-1) for k in get_keys(traj)})
+
+
+@observe.register(State)
+def _observe_state(
+    rv: State[T],
+    obs: Optional[Observation[State[T]]] = None,
+    *,
+    name: Optional[str] = None,
+    **kwargs,
+) -> State[T]:
+    if callable(obs):
+        obs = obs(rv)
+        if obs is not rv and obs is not None:
+            raise NotImplementedError("Dependent observations are not yet supported")
+
+    if obs is rv or obs is None:
+        return rv
+
+    assert isinstance(obs, State)
+
+    return State(
+        **{
+            k: observe(rv[k], obs[k], name=f"{name}__{k}", **kwargs)
+            for k in get_keys(rv)
+        }
+    )
diff --git a/chirho/dynamical/internals/backends/__init__.py b/chirho/dynamical/internals/backends/__init__.py
new file mode 100644
index 000000000..b7f072412
--- /dev/null
+++ b/chirho/dynamical/internals/backends/__init__.py
@@ -0,0 +1 @@
+from . import torchdiffeq  # noqa: F401
diff --git a/chirho/dynamical/internals/backends/torchdiffeq.py b/chirho/dynamical/internals/backends/torchdiffeq.py
new file mode 100644
index 000000000..00c586764
--- /dev/null
+++ b/chirho/dynamical/internals/backends/torchdiffeq.py
@@ -0,0 +1,279 @@
+import functools
+from typing import Callable, List, Tuple, TypeVar
+
+import torch
+import torchdiffeq
+
+from chirho.dynamical.handlers.interruption import (
+    DynamicInterruption,
+    Interruption,
+    StaticInterruption,
+)
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.internals._utils import _squeeze_time_dim, _var_order
+from chirho.dynamical.internals.solver import (
+    get_next_interruptions_dynamic,
+    simulate_point,
+    simulate_trajectory,
+)
+from chirho.dynamical.ops import Dynamics, State, get_keys
+from chirho.indexed.ops import IndexSet, gather, get_index_plates
+
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+def _deriv(
+    dynamics: Dynamics[torch.Tensor],
+    var_order: Tuple[str, ...],
+    time: torch.Tensor,
+    state: Tuple[torch.Tensor, ...],
+) -> Tuple[torch.Tensor, ...]:
+    env: State[torch.Tensor] = State()
+    for var, value in zip(var_order, state):
+        env[var] = value
+
+    assert "t" not in get_keys(env), "variable name t is reserved for time"
+    env["t"] = time
+
+    ddt: State[torch.Tensor] = dynamics(env)
+    return tuple(ddt.get(var, torch.tensor(0.0)) for var in var_order)
+
+
+def _torchdiffeq_ode_simulate_inner(
+    dynamics: Dynamics[torch.Tensor],
+    initial_state: State[torch.Tensor],
+    timespan,
+    **odeint_kwargs,
+):
+    var_order = _var_order(get_keys(initial_state))  # arbitrary, but fixed
+
+    solns = _batched_odeint(  # torchdiffeq.odeint(
+        functools.partial(_deriv, dynamics, var_order),
+        tuple(initial_state[v] for v in var_order),
+        timespan,
+        **odeint_kwargs,
+    )
+
+    trajectory: State[torch.Tensor] = State()
+    for var, soln in zip(var_order, solns):
+        trajectory[var] = soln
+
+    return trajectory
+
+
+def _batched_odeint(
+    func: Callable[[torch.Tensor, Tuple[torch.Tensor, ...]], Tuple[torch.Tensor, ...]],
+    y0: Tuple[torch.Tensor, ...],
+    t: torch.Tensor,
+    *,
+    event_fn=None,
+    **odeint_kwargs,
+) -> Tuple[torch.Tensor, ...]:
+    """
+    Vectorized torchdiffeq.odeint.
+    """
+    # TODO support event_dim > 0
+    event_dim = 0  # assume states are batches of values of rank event_dim
+
+    y0_batch_shape = torch.broadcast_shapes(
+        *(y0_.shape[: len(y0_.shape) - event_dim] for y0_ in y0)
+    )
+
+    y0_expanded = tuple(
+        # y0_[(None,) * (len(y0_batch_shape) - (len(y0_.shape) - event_dim)) + (...,)]
+        y0_.expand(y0_batch_shape + y0_.shape[len(y0_.shape) - event_dim :])
+        for y0_ in y0
+    )
+
+    if event_fn is not None:
+        event_t, yt_raw = torchdiffeq.odeint_event(
+            func, y0_expanded, t, event_fn=event_fn, **odeint_kwargs
+        )
+    else:
+        yt_raw = torchdiffeq.odeint(func, y0_expanded, t, **odeint_kwargs)
+
+    yt = tuple(
+        torch.transpose(
+            yt_[(..., None) + yt_.shape[len(yt_.shape) - event_dim :]],
+            -len(yt_.shape) - 1,
+            -1 - event_dim,
+        )[0]
+        for yt_ in yt_raw
+    )
+    return yt if event_fn is None else (event_t, yt)
+
+
+@simulate_point.register(TorchDiffEq)
+def torchdiffeq_ode_simulate(
+    solver: TorchDiffEq,
+    dynamics: Dynamics[torch.Tensor],
+    initial_state: State[torch.Tensor],
+    start_time: torch.Tensor,
+    end_time: torch.Tensor,
+) -> State[torch.Tensor]:
+    timespan = torch.stack((start_time, end_time))
+    trajectory = _torchdiffeq_ode_simulate_inner(
+        dynamics, initial_state, timespan, **solver.odeint_kwargs
+    )
+
+    # TODO support dim != -1
+    idx_name = "__time"
+    name_to_dim = {k: f.dim - 1 for k, f in get_index_plates().items()}
+    name_to_dim[idx_name] = -1
+
+    final_idx = IndexSet(**{idx_name: {len(timespan) - 1}})
+    final_state_traj = gather(trajectory, final_idx, name_to_dim=name_to_dim)
+    final_state = _squeeze_time_dim(final_state_traj)
+    return final_state
+
+
+@simulate_trajectory.register(TorchDiffEq)
+def torchdiffeq_ode_simulate_trajectory(
+    solver: TorchDiffEq,
+    dynamics: Dynamics[torch.Tensor],
+    initial_state: State[torch.Tensor],
+    timespan: torch.Tensor,
+) -> State[torch.Tensor]:
+    return _torchdiffeq_ode_simulate_inner(
+        dynamics, initial_state, timespan, **solver.odeint_kwargs
+    )
+
+
+@get_next_interruptions_dynamic.register(TorchDiffEq)
+def torchdiffeq_get_next_interruptions_dynamic(
+    solver: TorchDiffEq,
+    dynamics: Dynamics[torch.Tensor],
+    start_state: State[torch.Tensor],
+    start_time: torch.Tensor,
+    next_static_interruption: StaticInterruption,
+    dynamic_interruptions: List[DynamicInterruption],
+    **kwargs,
+) -> Tuple[Tuple[Interruption, ...], torch.Tensor]:
+    var_order = _var_order(get_keys(start_state))  # arbitrary, but fixed
+
+    # Create the event function combining all dynamic events and the terminal (next) static interruption.
+    combined_event_f = torchdiffeq_combined_event_f(
+        next_static_interruption, dynamic_interruptions, var_order
+    )
+
+    # Simulate to the event execution.
+    event_time, event_solutions = _batched_odeint(  # torchdiffeq.odeint_event(
+        functools.partial(_deriv, dynamics, var_order),
+        tuple(start_state[v] for v in var_order),
+        start_time,
+        event_fn=combined_event_f,
+        **solver.odeint_kwargs,
+    )
+
+    # event_state has both the first and final state of the interrupted simulation. We just want the last.
+    event_solution: Tuple[torch.Tensor, ...] = tuple(
+        s[..., -1] for s in event_solutions
+    )  # TODO support event_dim > 0
+
+    # Check which event(s) fired, and put the triggered events in a list.
+    # TODO support batched outputs of event functions
+    fired_mask = torch.isclose(
+        combined_event_f(event_time, event_solution),
+        torch.tensor(0.0),
+        rtol=1e-02,
+        atol=1e-03,
+    ).reshape(-1)
+
+    if not torch.any(fired_mask):
+        # TODO AZ figure out the tolerance of the odeint_event function and use that above.
+        raise RuntimeError(
+            "The solve terminated but no element of the event function output was within "
+            "tolerance of zero."
+        )
+
+    if len(fired_mask) != len(dynamic_interruptions) + 1:
+        raise RuntimeError(
+            "The event function returned an unexpected number of events."
+        )
+
+    triggered_events = [
+        de for de, fm in zip(dynamic_interruptions, fired_mask[:-1]) if fm
+    ]
+    if fired_mask[-1]:
+        triggered_events.append(next_static_interruption)
+
+    return (
+        tuple(triggered_events),
+        event_time,
+    )
+
+
+# TODO AZ — maybe to multiple dispatch on the interruption type and state type?
+def torchdiffeq_point_interruption_flattened_event_f(
+    pi: "StaticInterruption",
+) -> Callable[[torch.Tensor, Tuple[torch.Tensor, ...]], torch.Tensor]:
+    """
+    Construct a flattened event function for a point interruption.
+
+    :param pi: The point interruption for which to build the event function.
+    :return: The constructed event function.
+    """
+
+    def event_f(t: torch.Tensor, _):
+        return torch.where(t < pi.time, pi.time - t, torch.tensor(0.0))
+
+    return event_f
+
+
+# TODO AZ — maybe do multiple dispatch on the interruption type and state type?
+def torchdiffeq_dynamic_interruption_flattened_event_f(
+    di: "DynamicInterruption", var_order: Tuple[str, ...]
+) -> Callable[[torch.Tensor, Tuple[torch.Tensor, ...]], torch.Tensor]:
+    """
+    Construct a flattened event function for a dynamic interruption.
+
+    :param di: The dynamic interruption for which to build the event function.
+    :return: The constructed event function.
+    """
+
+    def event_f(t: torch.Tensor, flat_state: Tuple[torch.Tensor, ...]):
+        # Torchdiffeq operates over flattened state tensors, so we need to unflatten the state to pass it the
+        #  user-provided event function of time and State.
+        state: State[torch.Tensor] = State(
+            **{k: v for k, v in zip(var_order, flat_state)}
+        )
+        return di.event_f(t, state)
+
+    return event_f
+
+
+# TODO AZ — maybe do multiple dispatch on the interruption type and state type?
+def torchdiffeq_combined_event_f(
+    next_static_interruption: StaticInterruption,
+    dynamic_interruptions: List[DynamicInterruption],
+    var_order: Tuple[str, ...],
+) -> Callable[[torch.Tensor, Tuple[torch.Tensor, ...]], torch.Tensor]:
+    """
+    Construct a combined event function from a list of dynamic interruptions and a single terminal static interruption.
+
+    :param next_static_interruption: The next static interruption. Viewed as terminal in the context of this event func.
+    :param dynamic_interruptions: The dynamic interruptions.
+    :return: The combined event function, taking in state and time, and returning a vector of floats. When any element
+     of this vector is zero, the corresponding event terminates the simulation.
+    """
+    terminal_event_f = torchdiffeq_point_interruption_flattened_event_f(
+        next_static_interruption
+    )
+    dynamic_event_fs = [
+        torchdiffeq_dynamic_interruption_flattened_event_f(di, var_order)
+        for di in dynamic_interruptions
+    ]
+
+    def combined_event_f(t: torch.Tensor, flat_state: Tuple[torch.Tensor, ...]):
+        return torch.stack(
+            list(
+                torch.broadcast_tensors(
+                    *[f(t, flat_state) for f in dynamic_event_fs],
+                    terminal_event_f(t, flat_state),
+                )
+            ),
+            dim=-1,
+        )  # TODO support event_dim > 0
+
+    return combined_event_f
diff --git a/chirho/dynamical/internals/solver.py b/chirho/dynamical/internals/solver.py
new file mode 100644
index 000000000..3efd03019
--- /dev/null
+++ b/chirho/dynamical/internals/solver.py
@@ -0,0 +1,173 @@
+from __future__ import annotations
+
+import functools
+import numbers
+import typing
+from typing import List, Optional, Tuple, TypeVar, Union
+
+import pyro
+import torch
+
+from chirho.dynamical.ops import Dynamics, State, simulate
+
+if typing.TYPE_CHECKING:
+    from chirho.dynamical.handlers.interruption import (
+        DynamicInterruption,
+        Interruption,
+        StaticInterruption,
+    )
+
+
+R = Union[numbers.Real, torch.Tensor]
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+class Solver(pyro.poutine.messenger.Messenger):
+    def _pyro_get_solver(self, msg) -> None:
+        # Overwrite the solver in the message with the enclosing solver when used as a context manager.
+        msg["value"] = self
+        msg["done"] = True
+        msg["stop"] = True
+
+
+@pyro.poutine.runtime.effectful(type="get_solver")
+def get_solver() -> Solver:
+    """
+    Get the current solver from the context.
+    """
+    raise ValueError("Solver not found in context.")
+
+
+@functools.singledispatch
+def simulate_point(
+    solver: Solver,
+    dynamics: Dynamics[T],
+    initial_state: State[T],
+    start_time: R,
+    end_time: R,
+    **kwargs,
+) -> State[T]:
+    """
+    Simulate a dynamical system.
+    """
+    raise NotImplementedError(
+        f"simulate not implemented for solver of type {type(solver)}"
+    )
+
+
+@functools.singledispatch
+def simulate_trajectory(
+    solver: Solver,
+    dynamics: Dynamics[T],
+    initial_state: State[T],
+    timespan: R,
+    **kwargs,
+) -> State[T]:
+    """
+    Simulate a dynamical system.
+    """
+    raise NotImplementedError(
+        f"simulate_trajectory not implemented for solver of type {type(solver)}"
+    )
+
+
+# Separating out the effectful operation from the non-effectful dispatch on the default implementation
+@pyro.poutine.runtime.effectful(type="simulate_to_interruption")
+def simulate_to_interruption(
+    solver: Solver,
+    dynamics: Dynamics[T],
+    start_state: State[T],
+    start_time: R,
+    end_time: R,
+    *,
+    next_static_interruption: Optional[StaticInterruption] = None,
+    dynamic_interruptions: List[DynamicInterruption] = [],
+    **kwargs,
+) -> Tuple[State[T], Tuple[Interruption, ...], R]:
+    """
+    Simulate a dynamical system until the next interruption. This will be either one of the passed
+    dynamic interruptions, the next static interruption, or the end time, whichever comes first.
+
+    :returns: the final state, a collection of interruptions that ended the simulation
+      (this will usually just be a single interruption), and the time the interruption occurred.
+    """
+
+    interruptions, interruption_time = get_next_interruptions(
+        solver,
+        dynamics,
+        start_state,
+        start_time,
+        end_time,
+        next_static_interruption=next_static_interruption,
+        dynamic_interruptions=dynamic_interruptions,
+        **kwargs,
+    )
+    # TODO: consider memoizing results of `get_next_interruptions` to avoid recomputing
+    #  the solver in the dynamic setting. The interactions are a bit tricky here though, as we couldn't be in
+    #  a LogTrajectory context.
+    event_state = simulate(
+        dynamics, start_state, start_time, interruption_time, solver=solver
+    )
+
+    return event_state, interruptions, interruption_time
+
+
+@pyro.poutine.runtime.effectful(type="apply_interruptions")
+def apply_interruptions(
+    dynamics: Dynamics[T], start_state: State[T]
+) -> Tuple[Dynamics[T], State[T]]:
+    """
+    Apply the effects of an interruption to a dynamical system.
+    """
+    # Default is to do nothing.
+    return dynamics, start_state
+
+
+def get_next_interruptions(
+    solver: Solver,
+    dynamics: Dynamics[T],
+    start_state: State[T],
+    start_time: R,
+    end_time: R,
+    *,
+    next_static_interruption: Optional[StaticInterruption] = None,
+    dynamic_interruptions: List[DynamicInterruption] = [],
+    **kwargs,
+) -> Tuple[Tuple[Interruption, ...], R]:
+    from chirho.dynamical.handlers.interruption import StaticInterruption
+
+    if isinstance(next_static_interruption, type(None)):
+        # If there's no static interruption or the next static interruption is after the end time,
+        # we'll just simulate until the end time.
+        next_static_interruption = StaticInterruption(time=end_time)
+
+    assert isinstance(next_static_interruption, StaticInterruption)
+    if len(dynamic_interruptions) == 0:
+        # If there's no dynamic intervention, we'll simulate until either the end_time,
+        # or the `next_static_interruption` whichever comes first.
+        return (next_static_interruption,), next_static_interruption.time
+    else:
+        return get_next_interruptions_dynamic(
+            solver,
+            dynamics,
+            start_state,
+            start_time,
+            next_static_interruption=next_static_interruption,
+            dynamic_interruptions=dynamic_interruptions,
+            **kwargs,
+        )
+
+
+@functools.singledispatch
+def get_next_interruptions_dynamic(
+    solver: Solver,
+    dynamics: Dynamics[T],
+    start_state: State[T],
+    start_time: R,
+    next_static_interruption: StaticInterruption,
+    dynamic_interruptions: List[DynamicInterruption],
+) -> Tuple[Tuple[Interruption, ...], R]:
+    raise NotImplementedError(
+        f"get_next_interruptions_dynamic not implemented for type {type(dynamics)}"
+    )
diff --git a/chirho/dynamical/ops.py b/chirho/dynamical/ops.py
new file mode 100644
index 000000000..e6412e825
--- /dev/null
+++ b/chirho/dynamical/ops.py
@@ -0,0 +1,42 @@
+import numbers
+import typing
+from typing import Callable, Dict, FrozenSet, Generic, Optional, TypeVar, Union
+
+import pyro
+import torch
+
+R = Union[numbers.Real, torch.Tensor]
+S = TypeVar("S")
+T = TypeVar("T")
+
+
+class State(Generic[T], Dict[str, T]):
+    pass
+
+
+def get_keys(state: State[T]) -> FrozenSet[str]:
+    return frozenset(state.keys())
+
+
+Dynamics = Callable[[State[T]], State[T]]
+
+
+@pyro.poutine.runtime.effectful(type="simulate")
+def simulate(
+    dynamics: Dynamics[T],
+    initial_state: State[T],
+    start_time: R,
+    end_time: R,
+    *,
+    solver: Optional[S] = None,
+    **kwargs,
+) -> State[T]:
+    """
+    Simulate a dynamical system.
+    """
+    from chirho.dynamical.internals.solver import Solver, get_solver, simulate_point
+
+    solver_: Solver = get_solver() if solver is None else typing.cast(Solver, solver)
+    return simulate_point(
+        solver_, dynamics, initial_state, start_time, end_time, **kwargs
+    )
diff --git a/docs/source/dynamical.rst b/docs/source/dynamical.rst
new file mode 100644
index 000000000..208da62a9
--- /dev/null
+++ b/docs/source/dynamical.rst
@@ -0,0 +1,59 @@
+Dynamical
+=========
+
+.. automodule:: chirho.dynamical
+   :members:
+   :undoc-members:
+
+Operations
+----------
+
+.. automodule:: chirho.dynamical.ops
+   :members:
+   :undoc-members:
+
+Handlers
+--------
+
+.. automodule:: chirho.dynamical.handlers
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.handlers.event_loop
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.handlers.interruption
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.handlers.solver
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.handlers.trajectory
+   :members:
+   :undoc-members:
+
+Internals
+---------
+
+.. automodule:: chirho.dynamical.internals
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.internals.solver
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.internals._utils
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.internals.backends
+   :members:
+   :undoc-members:
+
+.. automodule:: chirho.dynamical.internals.backends.torchdiffeq
+   :members:
+   :undoc-members:
diff --git a/docs/source/dynamical_intro.ipynb b/docs/source/dynamical_intro.ipynb
new file mode 100644
index 000000000..ad07affec
--- /dev/null
+++ b/docs/source/dynamical_intro.ipynb
@@ -0,0 +1,2507 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Causal reasoning in dynamical systems"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.292774Z",
+     "start_time": "2023-07-18T18:46:28.196486Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from typing import Dict\n",
+    "\n",
+    "import pyro\n",
+    "import torch\n",
+    "from pyro.infer.autoguide import AutoMultivariateNormal\n",
+    "import pyro.distributions as dist\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from pyro.infer import Predictive\n",
+    "\n",
+    "from chirho.counterfactual.handlers import TwinWorldCounterfactual\n",
+    "from chirho.indexed.ops import IndexSet, gather, indices_of\n",
+    "\n",
+    "from chirho.dynamical.handlers import (\n",
+    "    StaticObservation,\n",
+    "    StaticIntervention,\n",
+    "    DynamicTrace,\n",
+    "    DynamicIntervention,\n",
+    "    SimulatorEventLoop,\n",
+    "    StaticInterruption,\n",
+    "    NonInterruptingPointObservationArray\n",
+    ")\n",
+    "from chirho.dynamical.handlers.interruption import _InterventionMixin\n",
+    "from chirho.dynamical.ops.dynamical import State, Trajectory, get_keys, simulate\n",
+    "\n",
+    "from chirho.dynamical.ops.ODE import ODEDynamics\n",
+    "from chirho.dynamical.handlers.ODE.solvers import TorchDiffEq\n",
+    "\n",
+    "from chirho.observational.handlers.soft_conditioning import (\n",
+    "    AutoSoftConditioning\n",
+    ")\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "# Set seed for reproducibility\n",
+    "seed = 123\n",
+    "pyro.clear_param_store()\n",
+    "pyro.set_rng_seed(seed)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.324680Z",
+     "start_time": "2023-07-18T18:46:29.293433Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class TrajectoryObservation(pyro.poutine.messenger.Messenger):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        data: Dict[float, Dict[str, torch.Tensor]],\n",
+    "        eps: float = 1e-6,\n",
+    "    ):\n",
+    "        times = torch.tensor([t for t, _ in data.items()])\n",
+    "        data_obs_dicts = [s for _, s in data.items()]\n",
+    "        # data_obs_dicts is a list of dictionaries, each of which contains the observations at a single time point\n",
+    "        #  these need to be concatenated into a single array valued dictionary.\n",
+    "        data_obs = dict()\n",
+    "        for key in data_obs_dicts[0].keys():\n",
+    "            data_obs[key] = torch.stack([d[key] for d in data_obs_dicts])\n",
+    "\n",
+    "        self.nipoa = NonInterruptingPointObservationArray(times, data_obs, eps=eps)\n",
+    "\n",
+    "    def __enter__(self):\n",
+    "        self.nipoa.__enter__()\n",
+    "\n",
+    "    def __exit__(self, *args, **kwargs):\n",
+    "        self.nipoa.__exit__(*args, **kwargs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define our SIR model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.357796Z",
+     "start_time": "2023-07-18T18:46:29.323308Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class SimpleSIRDynamics(ODEDynamics):\n",
+    "    def __init__(self, beta, gamma, name=None):\n",
+    "        super().__init__()\n",
+    "        self.beta = beta\n",
+    "        self.gamma = gamma\n",
+    "        self.name = name\n",
+    "\n",
+    "        if name is not None:\n",
+    "            self.postfix = f\"_{name}\"\n",
+    "        else:\n",
+    "            self.postfix = \"\"\n",
+    "\n",
+    "    def diff(self, dX: State[torch.Tensor], X: State[torch.Tensor]):\n",
+    "        dX.S = -self.beta * X.S * X.I\n",
+    "        dX.I = self.beta * X.S * X.I - self.gamma * X.I\n",
+    "        dX.R = self.gamma * X.I\n",
+    "\n",
+    "    def observation(self, X: State[torch.Tensor]):\n",
+    "        # We don't observe the number of susceptible individuals directly, and instead can only infer it from the\n",
+    "        #  number of test kits that are sold (which is a noisy function of the number of susceptible individuals).\n",
+    "        event_dim = 1 if X.I.shape and X.I.shape[-1] > 1 else 0\n",
+    "        test_kit_sales = torch.relu(pyro.sample(f\"test_kit_sales{self.postfix}\", dist.Normal(torch.log(torch.relu(X.S) + 1), 1).to_event(event_dim)))\n",
+    "        I_obs = pyro.sample(f\"I_obs{self.postfix}\", dist.Poisson(X.I).to_event(event_dim))  # noisy number of infected actually observed\n",
+    "        R_obs = pyro.sample(f\"R_obs{self.postfix}\", dist.Poisson(X.R).to_event(event_dim))  # noisy number of recovered actually observed\n",
+    "\n",
+    "        return {\n",
+    "            f\"test_kit_sales{self.postfix}\": test_kit_sales,\n",
+    "            f\"I_obs{self.postfix}\": I_obs,\n",
+    "            f\"R_obs{self.postfix}\": R_obs,\n",
+    "        }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate synthetic data from the SIR model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.410660Z",
+     "start_time": "2023-07-18T18:46:29.355384Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Assume there is initially a population of 99 million people that are susceptible, 1 million infected, and 0 recovered\n",
+    "init_state = State(S=torch.tensor(99.0), I=torch.tensor(1.0), R=torch.tensor(0.0))\n",
+    "start_time = torch.tensor(0.0)\n",
+    "end_time = torch.tensor(3.0)\n",
+    "logging_times = torch.linspace(0, 2.9, steps=21)\n",
+    "\n",
+    "# We now simulate from the SIR model\n",
+    "beta_true = torch.tensor(0.05)\n",
+    "gamma_true = torch.tensor(0.5)\n",
+    "sir_true = SimpleSIRDynamics(beta_true, gamma_true)\n",
+    "with DynamicTrace(logging_times) as dt:\n",
+    "    simulate(sir_true, init_state, start_time, end_time, solver=TorchDiffEq())\n",
+    "\n",
+    "sir_true_traj = dt.trace"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simulate the latent trajectories of the ODE model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.584138Z",
+     "start_time": "2023-07-18T18:46:29.411761Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x183d12710>"
+      ]
+     },
+     "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": [
+    "sns.lineplot(\n",
+    "    x=logging_times, y=sir_true_traj.S, label=\"# Susceptable (S)\", color=\"orange\"\n",
+    ")\n",
+    "sns.lineplot(x=logging_times, y=sir_true_traj.I, label=\"# Infected (I)\", color=\"red\")\n",
+    "sns.lineplot(x=logging_times, y=sir_true_traj.R, label=\"# Recovered (R)\", color=\"green\")\n",
+    "sns.despine()\n",
+    "plt.xlabel(\"Time (Yrs)\")\n",
+    "plt.ylabel(\"# of Individuals (Millions)\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Add noise to state trajectories to generate observations\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.646023Z",
+     "start_time": "2023-07-18T18:46:29.584398Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "obs_logging_times = torch.arange(\n",
+    "    1 / 52, 1.01, 1 / 52\n",
+    ")  # collect data every week for the past 6mo\n",
+    "obs_start_time = obs_logging_times[0]\n",
+    "obs_end_time = obs_logging_times[-1] + 1e-3\n",
+    "N_obs = obs_logging_times.shape[0]\n",
+    "with DynamicTrace(obs_logging_times) as dt_obs:\n",
+    "    simulate(sir_true, init_state, obs_start_time, obs_end_time, solver=TorchDiffEq())\n",
+    "\n",
+    "sir_obs_traj = dt_obs.trace\n",
+    "sir_data = dict()\n",
+    "for time_ix in range(N_obs):\n",
+    "    samp = sir_true.observation(\n",
+    "        sir_obs_traj[time_ix:time_ix+1]\n",
+    "    )\n",
+    "    sir_data[obs_logging_times[time_ix].item()] = {k: samp[k][0] for k in samp.keys()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.683584Z",
+     "start_time": "2023-07-18T18:46:29.645386Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "test_kit_sales = torch.stack(\n",
+    "    [sir_data[time.item()][\"test_kit_sales\"] for time in obs_logging_times]\n",
+    ")\n",
+    "I_obs = torch.stack([sir_data[time.item()][\"I_obs\"] for time in obs_logging_times])\n",
+    "R_obs = torch.stack([sir_data[time.item()][\"R_obs\"] for time in obs_logging_times])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.996315Z",
+     "start_time": "2023-07-18T18:46:29.685112Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Observed # Recovered (Millions)')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot observed data\n",
+    "fix, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "# Plot test kit sales\n",
+    "sns.scatterplot(x=obs_logging_times, y=test_kit_sales, color=\"blue\", ax=ax[0])\n",
+    "sns.despine()\n",
+    "ax[0].set_xlabel(\"Time (Yrs)\")\n",
+    "ax[0].set_ylabel(\"Test Kits Sales ($Millions)\")\n",
+    "\n",
+    "# Plot observed infected\n",
+    "sns.scatterplot(x=obs_logging_times, y=I_obs, color=\"red\", ax=ax[1])\n",
+    "sns.despine()\n",
+    "ax[1].set_xlabel(\"Time (Yrs)\")\n",
+    "ax[1].set_ylabel(\"Observed # Infected (Millions)\")\n",
+    "\n",
+    "# Plot observed recovered\n",
+    "sns.scatterplot(x=obs_logging_times, y=R_obs, color=\"green\", ax=ax[2])\n",
+    "sns.despine()\n",
+    "ax[2].set_xlabel(\"Time (Yrs)\")\n",
+    "ax[2].set_ylabel(\"Observed # Recovered (Millions)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Extend our model to include uncertainty over model parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:30.010774Z",
+     "start_time": "2023-07-18T18:46:29.995553Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# We place uniform priors on the beta and gamma parameters defining the SIR model\n",
+    "def bayesian_sir(base_model=SimpleSIRDynamics):\n",
+    "    beta = pyro.sample(\"beta\", dist.Uniform(0, 1))\n",
+    "    gamma = pyro.sample(\"gamma\", dist.Uniform(0, 1))\n",
+    "    sir = base_model(beta, gamma)\n",
+    "    return sir\n",
+    "\n",
+    "\n",
+    "def simulated_bayesian_sir(init_state, logging_times, base_model=SimpleSIRDynamics) -> Trajectory:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    trajectory = dt.trace\n",
+    "    # This is a small trick to make the solution variables available to pyro\n",
+    "    [pyro.deterministic(k, getattr(trajectory, k)) for k in get_keys(trajectory)]\n",
+    "    return trajectory\n",
+    "\n",
+    "\n",
+    "def conditioned_sir(data, init_state, start_time, end_time, base_model=SimpleSIRDynamics) -> None:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "    with TrajectoryObservation(data):\n",
+    "        simulate(sir, init_state, start_time, end_time, solver=TorchDiffEq())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform Inference!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:30.070437Z",
+     "start_time": "2023-07-18T18:46:30.011493Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Define a helper function to run SVI. (Generally, Pyro users like to have more control over the training process!)\n",
+    "def run_svi_inference(model, n_steps=100, verbose=True, lr=.03, vi_family=AutoMultivariateNormal, guide=None, **model_kwargs):\n",
+    "    if guide is None:\n",
+    "        guide = vi_family(model)\n",
+    "    elbo = pyro.infer.Trace_ELBO()(model, guide)\n",
+    "    # initialize parameters\n",
+    "    elbo(**model_kwargs)\n",
+    "    adam = torch.optim.Adam(elbo.parameters(), lr=lr)\n",
+    "    # Do gradient steps\n",
+    "    for step in range(1, n_steps + 1):\n",
+    "        adam.zero_grad()\n",
+    "        loss = elbo(**model_kwargs)\n",
+    "        loss.backward()\n",
+    "        adam.step()\n",
+    "        if (step % 100 == 0) or (step == 1) & verbose:\n",
+    "            print(\"[iteration %04d] loss: %.4f\" % (step, loss))\n",
+    "    return guide"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:59.292526Z",
+     "start_time": "2023-07-18T18:46:30.043544Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[iteration 0001] loss: 3735.7144\n",
+      "[iteration 0100] loss: 287.4226\n",
+      "[iteration 0200] loss: 262.3965\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run inference to approximate the posterior distribution of the SIR model parameters\n",
+    "sir_guide = run_svi_inference(\n",
+    "    conditioned_sir,\n",
+    "    n_steps=200,\n",
+    "    data=sir_data,\n",
+    "    init_state=init_state,\n",
+    "    start_time=obs_start_time,\n",
+    "    end_time=obs_end_time,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluate the performance of our inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Trajectory({'R': tensor([2.0008e-07, 6.1867e-02, 2.9212e-01, 1.0153e+00, 2.6028e+00, 4.9024e+00,\n",
+       "        7.4742e+00, 1.0078e+01, 1.2638e+01, 1.5133e+01, 1.7558e+01, 1.9916e+01,\n",
+       "        2.2205e+01, 2.4430e+01, 2.6591e+01, 2.8690e+01, 3.0729e+01, 3.2710e+01,\n",
+       "        3.4634e+01, 3.6503e+01, 3.8319e+01]), 'I': tensor([ 1.0000,  3.8834, 13.8651, 38.6749, 69.6112, 86.0551, 89.9492, 89.1990,\n",
+       "        87.1549, 84.8061, 82.4228, 80.0785, 77.7927, 75.5694, 73.4090, 71.3100,\n",
+       "        69.2709, 67.2901, 65.3661, 63.4969, 61.6812]), 'S': tensor([9.9000e+01, 9.6055e+01, 8.5843e+01, 6.0310e+01, 2.7786e+01, 9.0426e+00,\n",
+       "        2.5766e+00, 7.2265e-01, 2.0715e-01, 6.1290e-02, 1.8755e-02, 5.9345e-03,\n",
+       "        1.9405e-03, 6.5509e-04, 2.2812e-04, 8.1873e-05, 3.0258e-05, 1.1505e-05,\n",
+       "        4.4975e-06, 1.8058e-06, 7.4423e-07])})"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simulated_bayesian_sir(init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:01.693275Z",
+     "start_time": "2023-07-18T18:46:59.291560Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Generate samples from the posterior predictive distribution\n",
+    "sir_predictive = Predictive(simulated_bayesian_sir, guide=sir_guide, num_samples=100)\n",
+    "sir_posterior_samples = sir_predictive(init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### First, we compare the approximate posterior distribution with the true beta and gamma parameters generating the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.042675Z",
+     "start_time": "2023-07-18T18:47:01.694295Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1844c31d0>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 2, figsize=(15, 5))\n",
+    "\n",
+    "sns.kdeplot(sir_posterior_samples[\"beta\"], label=\"Approx. Beta Posterior\", ax=ax[0])\n",
+    "ax[0].axvline(beta_true, color=\"black\", label=\"True Beta\", linestyle=\"--\")\n",
+    "sns.despine()\n",
+    "ax[0].set_yticks([])\n",
+    "ax[0].legend(loc=\"upper right\")\n",
+    "\n",
+    "sns.kdeplot(sir_posterior_samples[\"gamma\"], label=\"Approx. Gamma Posterior\", ax=ax[1])\n",
+    "plt.axvline(gamma_true, color=\"black\", label=\"True Gamma\", linestyle=\"--\")\n",
+    "sns.despine()\n",
+    "ax[1].set_yticks([])\n",
+    "ax[1].legend(loc=\"upper right\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Next, we compare the predictive performance on the held out period between $t=1$ and $t=3$ years"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.141589Z",
+     "start_time": "2023-07-18T18:47:02.053763Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def SIR_uncertainty_plot(time_period, state_pred, ylabel, color, ax):\n",
+    "    sns.lineplot(\n",
+    "        x=time_period,\n",
+    "        y=state_pred.mean(dim=0),\n",
+    "        color=color,\n",
+    "        label=\"Posterior Mean\",\n",
+    "        ax=ax,\n",
+    "    )\n",
+    "    # 90% Credible Interval\n",
+    "    ax.fill_between(\n",
+    "        time_period,\n",
+    "        torch.quantile(state_pred, 0.05, dim=0),\n",
+    "        torch.quantile(state_pred, 0.95, dim=0),\n",
+    "        alpha=0.2,\n",
+    "        color=color,\n",
+    "    )\n",
+    "\n",
+    "    ax.set_xlabel(\"Time (Yrs)\")\n",
+    "    ax.set_ylabel(ylabel)\n",
+    "\n",
+    "\n",
+    "def SIR_data_plot(time_period, data, data_label, ax):\n",
+    "    sns.lineplot(\n",
+    "        x=time_period, y=data, color=\"black\", ax=ax, linestyle=\"--\", label=data_label\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def SIR_test_plot(test_time, ax):\n",
+    "    ax.axvline(\n",
+    "        test_time, color=\"black\", linestyle=\"dotted\", label=\"Start of Testing Period\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def SIR_plot(\n",
+    "    time_period,\n",
+    "    test_time,\n",
+    "    state_pred,\n",
+    "    data,\n",
+    "    ylabel,\n",
+    "    color,\n",
+    "    data_label,\n",
+    "    ax,\n",
+    "    legend=False,\n",
+    "    test_plot=True,\n",
+    "):\n",
+    "    SIR_uncertainty_plot(time_period, state_pred, ylabel, color, ax)\n",
+    "    SIR_data_plot(time_period, data, data_label, ax)\n",
+    "    if test_plot:\n",
+    "        SIR_test_plot(test_time, ax)\n",
+    "    if legend:\n",
+    "        ax.legend()\n",
+    "    else:\n",
+    "        ax.legend().remove()\n",
+    "    sns.despine()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.394748Z",
+     "start_time": "2023-07-18T18:47:02.113943Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    sir_posterior_samples[\"S\"],\n",
+    "    sir_true_traj.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    sir_posterior_samples[\"I\"],\n",
+    "    sir_true_traj.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    sir_posterior_samples[\"R\"],\n",
+    "    sir_true_traj.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's explore how different interventions might flatten the infection curve"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Suppose the government can enact different lockdown measures (of varying strength) to flatten the infection curve. Following [2], we define the stength of lockdown measure at time $t$ by $l_t \\in [0, 1]$ for $1 \\leq t \\leq T$. Parametrize the transmission rate $\\beta_t$ as:\n",
+    "\n",
+    "$$\n",
+    "\\beta_t = (1 - l_t) \\beta_0,\n",
+    "$$\n",
+    "\n",
+    "where $\\beta_0$ denotes the unmitigated transmission rate and larger values of $l_t$ correspond to stronger lockdown measures. Then, the time-varying SIR model is defined as follows:\n",
+    "\n",
+    "$$\n",
+    "\\begin{split}\n",
+    "    dS_t &= -\\beta_t S_t I_t \\\\\n",
+    "    dI_t &= \\beta_t S_t I_t - \\gamma I_t \\\\\n",
+    "    dR_t &= \\gamma I_t\n",
+    "\\end{split}\n",
+    "$$\n",
+    "\n",
+    "where $S_t, I_t, R_t$ denote the number of susceptable, infected, and recovered individuals at time $t$ for $1 \\leq t \\leq T$.\n",
+    "\n",
+    "### We can implement this new model compositionally using our existing SIR model implementation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.470158Z",
+     "start_time": "2023-07-18T18:47:02.393888Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class SimpleSIRDynamicsLockdown(SimpleSIRDynamics):\n",
+    "    def __init__(self, beta0, gamma):\n",
+    "        super().__init__(torch.zeros_like(gamma), gamma)\n",
+    "        self.beta0 = beta0\n",
+    "\n",
+    "    def diff(self, dX: State[torch.Tensor], X: State[torch.Tensor]):\n",
+    "        self.beta = (1 - X.l) * self.beta0  # time-varing beta parametrized by lockdown strength l_t\n",
+    "        dX.l = torch.tensor(0.0)\n",
+    "        # Call the base SIR class diff method\n",
+    "        super().diff(dX, X)\n",
+    "\n",
+    "\n",
+    "init_state_lockdown = State(\n",
+    "    S=torch.tensor(99.0), \n",
+    "    I=torch.tensor(1.0), \n",
+    "    R=torch.tensor(0.0), \n",
+    "    l=torch.tensor(0.0)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Let's first look at a deterministic intervention where the transmission rate is reduced by 75% between $t=1$ and $t=2$ due to stronger lockdown measures. We see in the figure below that this lockdown measures indeed \"flattens\" the curve."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.470325Z",
+     "start_time": "2023-07-18T18:47:02.426012Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    sir = bayesian_sir(SimpleSIRDynamicsLockdown)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        with SimulatorEventLoop():\n",
+    "            with StaticIntervention(time=torch.as_tensor(lockdown_start), intervention=State(l=torch.as_tensor(lockdown_strength))):\n",
+    "                with StaticIntervention(time=torch.as_tensor(lockdown_end), intervention=State(l=torch.tensor(0.0))):\n",
+    "                    simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "                    \n",
+    "    trajectory = dt.trace\n",
+    "    # This is a small trick to make the solution variables available to pyro\n",
+    "    [pyro.deterministic(k, getattr(trajectory, k)) for k in get_keys(trajectory)]\n",
+    "    return trajectory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:07.929780Z",
+     "start_time": "2023-07-18T18:47:02.453827Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "lockdown_start = 1.01\n",
+    "lockdown_end = 2.0\n",
+    "lockdown_strength = 0.75\n",
+    "\n",
+    "true_intervened_sir = pyro.condition(intervened_sir, data={\"beta\": beta_true, \"gamma\": gamma_true})\n",
+    "true_intervened_trajectory = true_intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state_lockdown, logging_times)\n",
+    "\n",
+    "intervened_sir_predictive = Predictive(intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "intervened_sir_posterior_samples = intervened_sir_predictive(lockdown_start, lockdown_end, lockdown_strength, init_state_lockdown, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:08.236254Z",
+     "start_time": "2023-07-18T18:47:07.927429Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Plot the static intervention\n",
+    "for a in ax:\n",
+    "    a.axvline(lockdown_start, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")\n",
+    "    a.axvline(lockdown_end, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## What if we're uncertain about when the lockdown will happen?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:08.329716Z",
+     "start_time": "2023-07-18T18:47:08.235883Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def uncertain_intervened_sir(lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    lockdown_start = pyro.sample(\"lockdown_start\", dist.Uniform(0.5, 1.5))\n",
+    "    lockdown_end = pyro.sample(\"lockdown_end\", dist.Uniform(1.5, 2.5))\n",
+    "    return intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:13.731306Z",
+     "start_time": "2023-07-18T18:47:08.270009Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "uncertain_intervened_sir_predictive = Predictive(uncertain_intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "uncertain_intervened_sir_posterior_samples = uncertain_intervened_sir_predictive(lockdown_strength, init_state_lockdown, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:14.049827Z",
+     "start_time": "2023-07-18T18:47:13.732215Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Plot the static intervention\n",
+    "for a in ax:\n",
+    "    a.axvline(lockdown_start, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")\n",
+    "    a.axvline(lockdown_end, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Next, let's consider a state-dependent intervention (\"dynamic intervention\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Here we assume that the government will issue a lockdown measure that reduces the transmission rate by 90% whenever the number of infected people hits 30 million infected. The government removes this lockdown when 20% of the population is recovered."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:14.139374Z",
+     "start_time": "2023-07-18T18:47:14.050158Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def government_lockdown_policy(target_state: State[torch.tensor]):\n",
+    "    def event_f(t: torch.tensor, state: State[torch.tensor]):\n",
+    "        return state.I - target_state.I\n",
+    "\n",
+    "    return event_f\n",
+    "\n",
+    "\n",
+    "def government_lift_policy(target_state: State[torch.tensor]):\n",
+    "    def event_f(t: torch.tensor, state: State[torch.tensor]):\n",
+    "        return target_state.R - state.R\n",
+    "\n",
+    "    return event_f\n",
+    "\n",
+    "\n",
+    "def dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    sir = bayesian_sir(SimpleSIRDynamicsLockdown)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        with SimulatorEventLoop():\n",
+    "            with DynamicIntervention(event_f=government_lockdown_policy(lockdown_trigger), intervention=State(l=torch.as_tensor(lockdown_strength))):\n",
+    "                with DynamicIntervention(event_f=government_lift_policy(lockdown_lift_trigger), intervention=State(l=torch.tensor(0.0))):\n",
+    "                    simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    trajectory = dt.trace\n",
+    "    \n",
+    "    # This is a small trick to make the solution variables available to pyro\n",
+    "    [pyro.deterministic(k, getattr(trajectory, k)) for k in get_keys(trajectory)]\n",
+    "    return trajectory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:19.227835Z",
+     "start_time": "2023-07-18T18:47:14.082066Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "lockdown_trigger = State(I=torch.tensor(30.0))\n",
+    "lockdown_lift_trigger = State(R=torch.tensor(20.0))\n",
+    "lockdown_strength = 0.9  # reduces transmission rate by 90%\n",
+    "\n",
+    "true_dynamic_intervened_sir = pyro.condition(dynamic_intervened_sir, data={\"beta\": beta_true, \"gamma\": gamma_true})\n",
+    "true_dynamic_intervened_trajectory = true_dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state_lockdown, logging_times)\n",
+    "\n",
+    "dynamic_intervened_sir_predictive = Predictive(dynamic_intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "dynamic_intervened_sir_posterior_samples = dynamic_intervened_sir_predictive(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state_lockdown, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:19.534805Z",
+     "start_time": "2023-07-18T18:47:19.228543Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x1889e8a10>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABNcAAAHACAYAAACBAI6gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3hT9ffA8XeSJt2DDlbLKAXK3kP2FBDZioiCAiqgoAIKspFRQMAJ/NyiIjKUIcheX2TvvemAFkrp3ivj98eFSqVAC22Stuf1PHlI773JPQntzc255/M5KpPJZEIIIYQQQgghhBBCCJFnaksHIIQQQgghhBBCCCFEYSXJNSGEEEIIIYQQQgghnpAk14QQQgghhBBCCCGEeEKSXBNCCCGEEEIIIYQQ4glJck0IIYQQQgghhBBCiCckyTUhhBBCCCGEEEIIIZ6QJNeEEEIIIYQQQgghhHhCklwTQgghhBBCCCGEEOIJFdvkmslkIikpCZPJZOlQhBBCFEHyOSOEEKIgyeeMEEJYj2KbXEtOTqZhw4YkJydbOhQhhBBFkHzOCCGEKEjyOSOEENaj2CbXhBBCCCGEEEIIIYR4WpJcE0IIIYQQQgghhBDiCUlyTQghhBBCCCGEEEKIJyTJNSGEEEIIIYQQQgghnpAk14QQQgghhBBCCCGEeEI2lg5AiOLKZDKh1+sxGAyWDkWIXNFqtWg0GkuHUaTIcUAUBI1Gg42NDSqVytKhCCGEKGYMBgOZmZmWDkOIHBXkOZIk14SwgIyMDMLDw0lJSbF0KELkmkqlwsfHBycnJ0uHUiTIcUAUJAcHB8qUKYNOp7N0KEIIIYqJpKQkwsLCMJlMlg5FiIcqqHMkq0iuZWRk0KdPH6ZMmULTpk0BCA0NZcqUKZw6dYqyZcsyceJEWrZsmfWYAwcOMHv2bEJDQ6lbty4BAQGUK1fOUi9BiFwzGo0EBwej0WgoW7YsOp1OqguE1TOZTERGRhIWFkaVKlWkgu0pyXFAFBSTyURGRgaRkZEEBwdTpUoV1GqZBUQIIUTBMhgMhIWF4eDggJeXl5zXCKtT0OdIFk+upaen88EHH3D16tWsZSaTiREjRlC1alVWr17Njh07GDlyJJs2baJs2bLcunWLESNG8O6779KqVSsWL17MO++8w/r16+WPWFi9jIwMjEYj5cqVw8HBwdLhCJFrXl5ehISEkJmZKcm1pyTHAVGQ7O3t0Wq1XL9+nYyMDOzs7CwdkhBCiCIuMzMTk8mEl5cX9vb2lg5HiBwV5DmSRS9lXrt2jZdeeokbN25kW37o0CFCQ0OZMWMGfn5+DBs2jHr16rF69WoA/vjjD2rVqsWQIUOoUqUKc+bM4ebNmxw5csQSL0OIJyKVBKKwkYsX+U+OA6KgyO+WEEIIS5DzRWHtCuocyaJnXkeOHKFp06asXLky2/LTp09To0aNbFfzGzZsyKlTp7LWN2rUKGudvb09NWvWzFovhBBCCCGEEEIIIYQ5WHRY6CuvvJLj8sjISEqWLJltmYeHB7dv387VeiGEEEIIIYQQQgghzMEqxwykpqY+0LlBp9ORkZGRq/VCiPzXvn17/P39s241a9akS5cu/Pzzz/ny/BcvXuTEiRNPFd+aNWvyJZY1a9bg7+/Pa6+9luP6l156CX9/f8LCwvJlf0IUFnIc+JccB4QQQojCT85t/iXnNk/H4g0NcmJra0tcXFy2ZfdPNmdra/tAIi0jIwMXFxdzhShEsTRx4kS6du0KgF6v59ChQ0yaNAk3Nzd69er1VM89YsQIRo4cSYMGDZ7o8X/++We+Tgyv1Wo5fvw4CQkJ2Y4tERERnDt3Lt/2I0RhI8cBOQ4IIYQQRYmc28i5TX6wysq1UqVKERUVlW1ZVFRU1lDQh6338vIyW4xCFEfOzs54eXnh5eVFmTJl6N27N82aNWPbtm2WDg13d/d87fZSsmRJypYty549e7It37lzJ3Xq1Mm3/QhR2MhxQI4DQgghRFEi5zZybpMfrDK5VrduXc6fP09aWlrWsuPHj1O3bt2s9cePH89al5qayoULF7LWF7gzH/Nen/JMGdqSbcsDSIyWsknxlEwm0Ceb92Yy5UvoNjY2aLVaAIxGIz/88AMdOnSgTp06DBw4kMuXL2dtu2nTJjp37kzt2rXp2rUrO3bsAGDgwIHcvHmTCRMmMH78eACuXLnCwIEDqVOnDp07d2bZsmVZz7Nw4ULeeecdXn31VZo0acKRI0eylUw/Lg5/f3++/PJLmjZtyvDhwx/62jp06MCuXbuyLdu5cycdO3bMtiwhIYGxY8fSoEEDWrZsycyZM7Mdv3bu3EmvXr2oXbs2jRo1YsyYMSQnJ2e9lg8++IBp06bRoEEDmjVrxvfff5/7/wBRdJhMkJxs3pscB+Q4IIQQQhQQk8lEckayWW8mObeRcxsLscphoU2aNKFMmTJMmDCBd955h927d3PmzBnmzJkDwAsvvMCPP/7Id999R7t27Vi8eDE+Pj40bdrULPGlXVvJtxtCydCHwvf70agnU6+SPa0aVaFVm/a07DyQkr5PVvYpiiGTCba3hKgD5t2vVwvouBeesF12ZmYmu3fvZv/+/cyePRuAxYsXs3z5cmbOnEnFihX5/vvvefPNN9m6dSupqamMGzeOGTNm0LRpU7Zs2cKYMWP4559/WLhwIT179mTIkCH06dOHtLQ03nrrLXr37s3MmTMJCgpiypQpODo6ZpVm79y5k48//ph69erh6+ubLbZHxXGvrHr37t0sX74co9H40NfYoUMH3n77bTIzM9FqtSQmJnLy5Ek++ugj5s+fn7XdpEmTyMzMZPny5aSnpzNr1ixmzJjB7NmzuXHjBu+//z5Tp06lefPmhISE8OGHH7Jq1SoGDx4MwNatW3nllVdYu3Yt27dvZ/78+XTs2PGB1yWKMJMJWraEA2Y+DrRoAXvlOCDHASHMQK+HyEiIiIDKlcHJydIRCSEKkMlkouWSlhwINe+5TYtyLdg7eC8qObd56Gss6uc26fp0VCoVOo3u8RvnI6tMrmk0Gv7v//6PSZMm0adPHypUqMDixYspW7YsAD4+PixcuJDZs2ezePFi6tevz+LFi5/4DyivjG03s2jyGPbuP8Le07cJuWPg+LVUjl87wxcrztCz4Resm+QNXi0xebXkelolKtTqhEpjlW+3sAZm+t19WtOmTWPmzJkApKWlYWdnx+uvv06PHj0wmUz89ttvjBkzhg4dOgAwc+ZMnn32WdavX0+dOnXIzMykdOnSeHt7M2TIEPz9/bG1tcXe3h6NRoOzszPOzs788ccfeHh4MGrUKAAqVqzIzZs3+fXXX7M+eDw9Penfv/8DMT4ujpdffhmAfv36UalSpUe+3gYNGqDRaDh69CjNmzfnf//7H40bN84278GNGzfYsWMHR44cwdnZOWt/vXr1YsKECRiNRiZPnsxLL70EKMev5s2bc/Xq1azncHNz46OPPkKj0fDmm2/y/fffc+7cOflSXdzIcUCOA3IcEEVRRoaSULt+HaKjlWU+PpJcE6IYUCHnNnJuY95zG4PRQJo+DVsb2wLbx8NYTbbn/nJGgAoVKvDbb789dPs2bdrQpk2bgg4rRw7uFXlr2hreuvtz2KV97N34A3v37WfvyVBaV8uA1JtwYyXXj6/EdxR4u6toVbckrZo1ptWzvanVagAqM2dShZVSqZQKMkOKeferccjzl/n33nuPTp06AUpjES8vLzQaDQDR0dHExcVlG56t1WqpVasWgYGB9OvXj7Zt2zJ48GB8fX3p0KEDffv2xd7e/oH9BAUFcenSJerXr5+1zGAwZO0LwNvbO8cYHxfH4x5/P41GQ7t27di1axfNmzdnx44dD5RLBwYGYjQaad26dbblRqOR69evU6tWLXQ6HV9//TVXr17l6tWrXLt2jZ49e2Zt6+Pjk+21OTo6otfrHxufKEJUKqWCLMXMxwEHOQ48jhwHhHhCaWlw+zaEhEBsLNjbQ+nSyjIhRJGnUqnYO3gvKZnmPbdx0DrkuehGzm2KxrmNyWQi3ZCO3qjHlmKcXCvMfKq1pH+1lvT/QPnZlBoJETshYjcXru3GRnOVmzEmVuyOYMXuv2H239QqP4zRbzzPK+8txM6tnGVfgLA8lQpsHC0dxWN5eHhQoUKFHNfZ2uZ8ADMYDBiNRlQqFd9++y1nzpxh586dbN++nd9//53ff/+d6tWrZ3uMXq+nWbNmTJ069aGxPGx/j4vjcdv9V4cOHZgzZw7jxo1j//79TJs2jZT7EiAGgwFnZ2dWr179wGNLlSrFpUuX6N+/P+3bt6dRo0YMGjSIX375Jdt29+ZzuF9+zRchChGVChzlOHCPHAfkOCAKqaQkCA+HGzdIj47mZmoqYWlphEZGEhYRwfBmzXC1dIxCCLNQqVQ46uTc5h45tynYcxu9UU+GIcNsIxr/yyobGhR2KnsvqPgyNP2WrlOvEB91m11/zGP68JZ0bFACex2cu6HnjWl/sXy8L+x/FaKPP/6JhbBizs7OeHp6curUqaxlmZmZnD9/Hl9fXwIDA/nkk0+oU6cOo0ePZuPGjZQpU4a9e/c+8Fy+vr4EBwfj4+NDhQoVqFChAqdOnWLp0qVPHUdetWjRgqioKH799VeqVauGu7v7A7EmJiaiUqmyYk1LS2PevHlkZGTw119/0bhxYz799FNeeeUV6tSpw/Xr1+VLsyiS5DggxwFRfGRkZBAcHMzevXv5/fff2bt5M1y4APv3c/N//6PUiy9i168ffoMG0Wb4cAZMmcL4RYsIioiwdOhCCJFrcm5TOM5t7lWtgeWGI0vlmhk4uJWi3YtjaffiWADiIq7z/YJ3WbluG/2fSYfrv8P13/lfmD9edQdR89kPQP1gllcIazdo0CC++uorSpYsSYUKFfj+++9JT0+na9euGAwGli9fjrOzM927d+fatWvcvHmTGjVqAODg4EBQUBBxcXH06NGDRYsWMXXqVIYMGUJYWBgBAQFZk2M+TRx55eDgQPPmzfm///s/3nvvvQfW+/n50apVKz788EMmT56MRqNhypQpuLq64uLigpubG5cvX+bMmTM4OzuzcuVKzp49S7lyUrEqiiY5DshxQBRdp0+fZvTo0Vy8eJGIiIhsX6Je79iRVu+8AyVK4FmrFnfi4gCws7XFp2RJypUqhU/JktjrZFoUIUThIuc21n9uk2nMRG/QY6OxIdOQaZEYJLlmAW6lKjB2/nrGzs2E8M1weSHG27sY+vllrt6eQKe60xgztDedXv8MlWNZS4crRK4NGTKEpKQkpkyZQlJSEvXr12fp0qVZV0IWLlzIggUL+Oabb/Dw8GDMmDG0bNkSgP79+7NgwQJCQkJYtGgR33//PbNnz6ZXr164ubnx6quvMmzYsHyJI686dOjA7t27H5iL4J558+Yxa9YsBg0ahI2NDa1atWLy5MmA0oL7woULDBo0CFtbWxo3bsyIESPYuHHjE8UihLWT44AcB0TRdPv2bVq3bk1CQkLWMludDh8PD3zc3alWqRKUL68sB04vX05ZLy88XF2zD9EJCzNz5EII8XTk3Ma6z22MJmNWh1BLNtFQmYrpmISkpCQaNmzI8ePHcbJ0tyKjgdiQ/bz5xuus2xOC8e7/SA1vGP1qQ159Zy72FXL+hReFT1paGsHBwfj6+mJnZ2fpcITINfndzZtHfc7IeykKmvyOiYIwY/p0dm3dyoK33qK8RoOXmxsqDw/Iy+9YWBi0aAGengUXaDFhVd9nRLEnnzvCUtL0aaRmpqK72zAyw5CBvdYeO5ucfw8L6ndV5lyzBmoNJSq1ZvWuQK6e2cf7rz6Dk52KCzfhrXnHKV/7WVaM94Wr34KZu60IIYQQQojiKzU1VbmTlMSUXr3Y9sEHNCpZkpJVq6Ly9s5bYk0IIYTIRwajgQx9Bhq15vEbFzBJrlkTlZpKtVrwxdIDhIVcY8GEfpQvaUtUIpS2CYGjw2F9RTg5DjISHvdsQgghhBBCPBGj0cjYsWNp07o1SefPw6FDqIKC0JUuDaVLQw5d4IQQQghzSjekYzAZ0KgkuSZyolLhWqoSH8xeQWBwGH8vDaBNl/6gdYH0SL5dNJ8vRlbHFH0SiueoXiGEEEIIUUAyMjJ47bXXWLBgAUePHWPzkiWgUilzqkmlmhBCCCugN+jJMGRgo7aOVgLWEYV4KBsHT54fMBEyEyAxhEu7PmXkL7+iN9zi5OVn+Gbxl9hXew1sHCwdqhBCCCGEKOQSExPp07MnO3bvxkaj4cd336Vv375gI18bhBBCWAeTyUS6IR0Atco6asasIwrxeFoXcK+Df8/FLJgyFI0afv0ng1Y93iZ081uQckuq2IQQQgghxBOLuHWLts2bs2P3bhzt7Ngwdy6vDRggiTUhhBBWJdOYSaYh02qq1kCSa4WOSuvE+1O/YfvaH/Fw0XI8GBoO+J1//q8jRB4AfaqlQxRCCCGEEIXMtWPHaN6kCSfOncPL1ZX/ffstXdq1s3RYQgghRDZGk5F0fToqlQoVKkuHk0WSa4WRSkW7HkM4dnAP9ap6EpkAHcZf5P8md4WQZZB6W6rYhBBCCCHE46WlwaVLqM+cISkpiUre3hz4+Wca1axp6ciEEEKIB2QaMtEb9VZVtQYy51qhVrFGM/YfPMabr7/I8r+PkZiYAMdGQNwZqDwMnP1AI5POCiGEEEKI/zAaITwcrl2D6Ggq+fmx/ZtvKOXuTikPD0tHJ4QQQjzAYDSQrk9Ho7Z8d9D/ksq1Qs7BvQLL/tzOuh8nM25gfTBmwJWFcPw9iPgHUiOkik3kuzVr1uDv788ff/yR68eEhoayZ8+efNn/+PHjGT9+/CO3ef7557l69SoAb7/9Ntu2bctxu8zMTBYuXEiHDh2oVasWbdu2Zc6cOSQlJeVLrAXl/vczLCwMf39/wsLCAPD39+fw4cM5Pu7w4cP4+/ubLU5RdBWl48DAgQNZuHBhrvabnp7OO++8Q506dRg4cGDegv6Pp30/8hK3ENnEx8PJk/w6fz4b9+yBcuXAyYk6VapIYk0IUWwVpXOb9u3b4+/vn3WrVq0aTZo04e233yY8PDxf4rWEDEMGBpMBjerRybXnnn2ONWvWmCkqhSTXigCVrRs9X5uAqsnXUKE/SWkqOo3axYGlgyHsL4i/AIY0S4cpipCNGzdSvnx5/vrrr1w/ZuLEiZw5c6YAo/pXSkoKt27dolKlSgCcP3+emg8Z3rJgwQK2bdvGrFmz2LJlC3PmzGH//v18+OGHZon1Sd3/fpYpU4Z9+/ZRpkwZC0dV+Gzfvj3biYe/vz/vvfceABcuXKBv377UrVuXF154gXPnzlk4WutSlI4DebF371727t3L77//zqeffvpUz2XO90MIADIzITAQ08GDzP3yS17/8kv6zp7N5Rs3LB2ZEEJYXFE7t5k4cSL79u1j37597Nmzh88//5yrV6/y0UcfmSXe/KY36skwZFjdcNB7JLlWVNg4QIn6UGMcM/Y2Y/s5aDvpFt8veA9ClkL0UUi7Y+koRREQHR3NwYMHGTFiBMeOHSM0NNTSIT3g4sWLVKlSBY1GQ3R0NOnp6Xh7e+e47dq1a3n//fdp1qwZPj4+NGvWjI8//pjdu3dz507h+JvRaDR4eXmh0VhfebS1u3btGu3atcs68di3bx+zZs0iJSWFoUOH0qhRI9asWUP9+vUZNmwYKSkplg7ZKhS140BeJCYm4unpSa1atShZsmQ+RCqEmURFwbFjGE6c4P3vvmPC0qUAjHzpJaqUL2/h4IQQwrKK4rmNs7MzXl5eeHl5UapUKVq0aMF7773H4cOHSUxMNGPkT89kMpGuT8eECbXKOtNY1hmVeDIaHbjWZuqsr3ihc0MyDTD0u3Te/vATMs59DlEHIf4iGNItHakoxLZs2YKzszM9evSgZMmS2a7spKSkMHXqVJo2bUrTpk2ZMmUK6enpjB8/niNHjrBo0SIGDhz4wDBGgIULF2YbYvXHH3/QpUsXatWqRdOmTZk+fToGg+GRsd0r5X7llVc4ffo0/v7+NG/enLi4uIcOhVSpVBw6dAij0Zi1rH79+mzcuJESJUoASln1/WXF/x1a+euvv9KuXTtq165Nnz59OHbsWNa6M2fO0L9/f+rWrUvnzp3ZuHFj1rpjx47Rp08f6tSpQ/fu3dm6dWvWuvHjxzNr1iyGDx9OnTp16NWrFydOnMha97j38+jRo3Tq1Im6devy/vvvEx8fn+PrDw8PZ/jw4dStW5f27duzaNGix77PRUlgYCBVq1bNOvHw8vLCxcWFTZs2YWtry7hx4/Dz82PSpEk4OjqyZcsWS4dsFYraceC/jx84cCBfffUVTZs2pVGjRsyZMweTycSaNWsYP348t27dwt/fP+u4sGLFCtq3b0/9+vUZOHAgly9fzvP7AY//e9y+fTudO3emXr16zJgxo1j9rYqncLdhAYcPQ1QUb/7yCwvXrgXg8zFjmPf++6jV8pVACFG8FeVzm/vpdDqArON+QkICY8eOpUGDBrRs2ZKZM2eSlvbvqLdHfZc5efIk/fv3p169erRv357ly5cDyvm1v79/tgRlSEgI1apVyxqS+qhzp/bt2zN//nxatmxJr169MJlMXLx8kTcHv0nrJq3p3b03q1asyva6/lz1J12f7UqrZ1rx0/c/5ek9yS/WWU8nnpxag1PZBvyxaiVzAqYxef4yvtkJZ0PX8ueUK5R+ZhRkxkOJetLswMokJyc/dJ1Go8HOzi5X26rVauzt7R+7raOj4xNEqZRLt23bFrVaTfv27Vm3bh0jRoxApVIxefJkLl++zP/93/9hZ2fH2LFj+eKLL5g0aRIhISFZ1T+Pm8/syJEjzJo1i/nz51OjRg3OnTvH2LFjadasGZ06dXro47p27UqrVq2YO3cu1apVo1evXvz222/Ex8czYsSIHB/z2muv8dVXX7Fjxw7atGlD8+bNadmyJZUrV87V+3HhwgXmzZvHokWLqFy5Mr/++iujRo3in3/+ITY2liFDhtCjRw8CAgI4deoUH330EX5+fnh4eDBs2DBGjx5Nq1atOHXqFOPHj8fDw4NGjRoByofOoEGDGDt2LCtWrGDo0KFs27YtV+/nsmXLmDt3Lh4eHkycOJE5c+Ywd+7cbNuYTCZGjhxJtWrVWLt2LZGRkUydOhWVSvXQ96uoCQwMpHnz5g8sP336NA0bNkSlUtp7q1QqGjRowKlTp+jTp0+BxSPHgX+Z8zjwXydPnsTT05Ply5dz9uxZxo8fT+vWrenatSuJiYn89NNP/Pnnnzg7O7Nr1y4WLVrEzJkz8fX1Zd26dbz22mts27YNV1fXXL8fj/t7vHbtGqNGjWLs2LG0atWKX375hePHj9OsWbM8/d+JYsRkgogIuHwZoqPBw4P/XbrEzxs3otFo+G3GDF7u3NnSUQohijg5t/mXJc9tAG7cuMF3331Hq1atst6nSZMmkZmZyfLly0lPT2fWrFnMmDGD2bNnEx0d/dDvMlqtltdff51BgwYREBDA6dOnmT59Op6enjz77LNUq1aN7du3M2TIEAC2bt1K/fr1KVOmzGPPnQA2bNjAjz/+iMlkIjUtleFDh/N8j+eZ+vFUgoODmfXxLBwcHejWvRsH9h9gwScLmPzxZKpXr85XX37FrVu3cv2+5Be5TFUUqVSoXPyYOG0eG36egauTLfuvQKP3znNq7Ydw+38Qdx6MmZaOVNzHycnpobcXXngh27YlS5Z86LbPPfdctm0rVqyY43ZPIjw8nBMnTtCxY0cAOnXqRGhoKMePHyc+Pp4tW7YwdepUGjZsSM2aNZkxYwZly5bF2dkZrVaLg4MDbm5uj92Pg4MDAQEBdOrUCR8fH7p06UKNGjWyJu98GDs7O7y8vLh58yb16tXDy8uL27dvU6tWLby8vHJ8zIgRI5g/fz6lS5dm1apVvPfee7Rq1YrVq1fn6j25efMmKpWKsmXL4uPjw6hRo5g/fz5Go5GNGzdmfbmuVKkSffr04YMPPiAtLY1ly5bRvHlzBgwYQIUKFejZsyf9+vXjl19+yXruypUr8+GHH+Ln58eECRNwdXVl06ZNuXo/R44cSZs2bahVqxaTJ09mw4YND3zgHzp0iFu3bjFz5kwqVapE06ZN+eijj/j1119z9doLO5PJRHBwMPv27aNz58507NiRBQsWkJGRQWRk5AND/jw8PLh9+3aBxiTHgX+Z8zjwXwaDIevvomfPnlSrVo2zZ89iZ2eHs7Nz1lBsOzs7fvjhB4YNG0a7du2oWLEio0aNwtvbm/Xr1+fp/Xjc3+Pq1atp1KgRgwYNws/PjylTpsiwVPFwyclw9iwcPQopKVCuHCZHRz662wBjaO/eklgzI5nfUxRncm7zL3Of20ybNo369etTv359ateuTa9evfDz82P+/PmAkmzbsWMH8+fPx9/fnzp16jBz5kzWrl1LYmLiI7/LrFq1iho1ajBmzBgqVapE7969GTBgAD/88AOgNF64v9nC1q1b6dq1K8Ajz53u6dGjR1Yjhr/W/4Wbuxsj3xtJ+QrladO2DW+89Qa/L/0dgHWr1/Hc88/RrXs3/Cr7Mfnjydja2j72/yO/SeVaUeZQludfepsjlSvS67VxxMZE4mUfDxc/AVsPUOvAtQZYYRtbYZ02btyIra0tLVu2BKBJkya4urqydu1a+vXrh8FgyDapZqNGjbKqsPKiVq1a2NnZ8dVXX3Ht2jUuX77M9evXs/b7OIGBgVmVZ1evXuWVV1555PY9evSgR48exMbGsm/fPn777TcmTZqEv78/tWrVeuRjW7ZsSdWqVenevTs1atSgQ4cO9O3bFxsbG4KDg6lRo0a24TaDBw8G4KeffmL37t3Ur18/a11mZia+vr5ZPzdo0CDrvlqtpkaNGgQGBubqPahdu3bW/Ro1aqDX67nxnwmrAwMDiYuLo2HDhlnLjEYjaWlpxMbGZg2LLapu3bpFamoqOp2OL774grCwMGbNmkVaWlrW8vvpdDoyMjIsFK31KKrHgft5eHhkO0F3cnJCr9c/dD/z58/ns88+y1qWnp5OSEgI169fz/X78bi/x8DAQKpXr561TqvVZvtZCACMRrh5E65cgYQEKFkS7laFpKalUbdqVS6FhDD1zTctHGjxcm9+z5kzZ2Yts7W1zZrfs3v37sydO5fly5czbNgwtm/fjoODgwUjFqJ4KarnNu+99x6dOnUiOTmZhQsXcvPmTT744IOsc/zAwECMRiOtW7fO9jij0cj169cf+V1m0aJF1KlTJ9vj6tevz4oVKwCl2u7zzz8nIiKCzMxMLl26RJcuXbL2+7Bzp3vuzSVnMBq4eu0q165co0WTFtlivDffdFBQEC/2fTFrnaubK94+Tz/Pbl5Jcq2os/OkauOeHNpaipArJ/HW/wSJV+DqQtCVUOZpc64Kd4c+Cct5VBnxfyeqf9RE+/+dN+X+g9TT2rhxI2lpadm+/BkMBrZs2cKLL774iEdmp8rh9+3+L6579+5lxIgR9OrVi1atWjFixAimT5/+2Oddv34906ZNIyUlhfbt2wOQmprK66+/jkql4uTJk9m2v3TpEuvWrctqeV2iRAm6d+9O586d6dSpE4cOHcoxuXb/vAj29vb88ccfHDlyhN27d7NmzRqWL1/OmjVrsLF5+CFWr9fTvXt3hg8fnm35/Y/57+MNBkOu58W5/3fGZDIBypfx/8ZQqVIl/u///u+Bxzs7O+dqP4WZt7c3hw8fxtXVFZVKRfXq1TEajYwdO5YmTZo8kEjLyMjINnShIMhxwPzHgZz8N7EK//4d/ZfBYGDixIkPDM90cnLKU1OU3Pw9/jeG//5Ni2IuPh6uXYOwMLC3h3Llsp3fOdjZ8d2kScx77z3cisEx3prcP7/n/f7888+s+T1VKhWTJk3in3/+YcuWLQU6BYEQ5iTnNpY7t/Hw8KBChQoAfPnll7z44ou88847rFy5Eq1Wi8FgwNnZOccRO6VKlXrkd5mcKsOMRmPW9yQfHx9q167Njh07SE9Pp1GjRlnHwEedO/33+TMMGej1eho3bcz4SeMfGo8Jy58jSXKtONC64FKhFXXcSkCUM5wex5kzZ/G3X4ltZa0y95pjBUtHWezlZX6Agtr2UYKDg7lw4QKTJ0+madOmWcuvXbvG6NGjuX79OhqNhkuXLmVdydmxYweLFy9m7d2Jk++5d7C7f66E+yf+/OOPP3jhhReYNm0aQFbV1TPPPPPIGNu3b09iYiLbt29n+vTpBAUFMWfOHL7//vsctzcYDCxZsoQePXpQo0aNrOU6nQ47Ozvc3d2z4r0/1vsn5zx58iSHDh3i7bff5plnnuGDDz6gefPmHD9+nIoVK7Jnzx5MJlPWh+2oUaOoVasWvr6+nDx5MusDD5RqtoyMjKyE28WLF7PFeunSJdq2bfvI9+CeK1euZF1hO3PmDFqtFh8fH2JiYrK28fX15datW7i7u2d9ed+/fz9r1qxh3rx5udpPYfffEn4/Pz/S09Px8vIiKioq27qoqKgCH4YnxwHzHweelq+vL7dv3872tzxhwgQ6duxI06ZNc/1+PO7vsUqVKtlOno1GI5cuXaJatWoF8rpEIaLXw40bcPWq0rygZEnIIUF8jyTWzM/a5vcUwpzk3MY6zm10Oh2zZs2iX79+/Pzzz7z11lv4+vqSmJiISqWi/N2u0ZcvX+arr75izpw5j/0uc/To0Wz7OHnyZLZROF27duV///sfycnJ9OzZM2v5o86dOnTokLVMb9STYcjA19eXvXv24u3tnZWQ3bhhIxfOX2Ds+LH4Vfbj/LnzWY9LTk4m9Ib5u73KnGvFhY09uNWFki359nRzGk2GSQv+hLjTEHcOUsMtHaGwchs3bsTNzY1+/fpRtWrVrFvXrl2pXLkyGzZsoFevXgQEBHDmzBnOnj3L559/nvVh4eDgQEhICNHR0Xh6elKmTBl+/PFHQkNDWbNmDf/73/+y9uXm5sbJkye5fPkyV69eZfz48URGRj52SJ6TkxORkZE0atSIChUqEBsbS926dalQoUK2g/c9NWvWpG3btrzzzjts2LCBsLAwTp06xbRp08jIyMiaWLR27dr8+eefXLlyhcOHD/PTT/92oLGzs2Px4sX88ccfhIWFsXHjRlJSUvD396d79+7ExcUxb948QkJCWLNmDTt37qRFixa88sornDt3js8//5yQkBA2bNjAZ599RtmyZbOe+8iRI/z0008EBQUREBBAampqVjn1/e9nTj7//HMOHjzIqVOnmDVrFi+//HK2SWBBGdLq7e3N2LFjuXz5MseOHWPKlCnY29s/cCWxKNq7dy9NmzYlNTU1a9nFixdxc3OjYcOGnDx5MqtSyGQyceLECerWrWupcK1CUTwOPK3Bgwfzyy+/sG7dOm7cuMH8+fPZvHkzfn5+ODk55fr9eNzf40svvcS5c+f4+uuvCQoK4pNPPrHIZL3CykRHw7FjcPo02NiAj88DibWUtDSGTJ/O+VxOKyDylzXO7ymE+FdxOrepU6cOL774Iv/3f/9HREQEfn5+tGrVig8//JAzZ85w/vx5JkyYQEpKCi4uLo/9LnPx4kU+++wzgoODWbt2Lb///juvvvpq1v6ee+45jh07xrlz57I1bHjUudM9JpOJDH0GJpOJ57s/T1pqGgEzAggOCmbfP/uYP3c+JdyV4a39+vdj+9btrPlzDcFBwcydOTdbx1NzkeRacaLRgWt1ylTrSKYBPt0EW5fPhfQoiD0LaVGPfw5RbG3cuJHu3bvnOFyqf//+HDhwgBEjRlCtWjUGDx7MW2+9RdOmTRk9ejQAffv2Ze/evbz55puo1eqsD6iuXbuyZcuWbMMjR44ciYeHB/369WPw4MHY2trSv3//bJVcD3P+/Pms+cbOnj2bbe6xnHzxxRf07NmTRYsW8dxzz2V1+vntt9+ySpNHjRqFi4sLffr0ISAggPfffz/r8dWrVycgIIAffviB5557jm+++Yb58+fj5+eHi4sL3377LceOHaNbt258//33fPrpp1SvXh1vb2+++eYb9u7dS7du3fjiiy8YP348PXr0yHru9u3bc+jQIXr16sWFCxdYsmQJLi4uD7yfORk8eDCTJk1i8ODB1K9fnw8//PCBbTQaDV9//TVGo5GXXnqJd999lzZt2jB58uTHvs9FQf369bG1tWXy5MkEBQWxZ88e5s2bx5tvvkmXLl1ISEggICCAa9euZSU3/zuZbnFTVI8DT6Nr166MHj2ar776im7dunHw4EG+/vprKlasCMDEiRNz9X487u+xQoUKfP3112zcuJFevXoRGRlJmzZtCux1CSuXkaF0AT18GCIjoWxZeMhk2gtXrGDJhg30GDMm27QGwjz+O7/nRx99xIYNG5g3b57M7ymEFShu5zajR49Gq9VmNTWYN28ePj4+DBo0iMGDB+Pr65s1F9qjvsuULVuWb7/9lr1799K9e3e+/vprxo8fn61JRalSpahVqxZNmjTJNpfz486dAIwmIxnGDGzUNjg6OrLw64VcD7lO/779mTl9Jv3692PIm0on0gYNG/DxzI9Z8sMSBrw8gBIlSuBfzf+J3p+noTI9bBKRIi4pKYmGDRty/PjxJ+4qUmilRzNi6ED+79fNlHKFM4uqUrLNJ6B1BY+GoHWxdIRFWlpaGsHBwfj6+hb4/E2i8Lo3D9zcuXMtHMm/iuLv7tWrV5k9ezanTp3C0dGRl19+Oavt+pkzZ5g2bRqBgYH4+/szffr0bMOHH+dRnzNF8b0U1kV+x4qw5GQ4d05pXODhAY84j41NSKBSz57EJSbyy8cf81q3bmYM9CHCwqBFC/D0tHQkZhMXF5c1vycoXfPuze9ZrVq1bBfA5s+fT2BgIN98881jn7dYf58RVkc+d0R+MZlMJGcmozfq0arzPndahiEDe609djY5/x4W1O+qzLlWHNl6sGDeJ+w5eJrzV28x+NMr/F1+GSrfARB7BtwbgI10KBJCFH1VqlRhyZIlOa6rU6fOA3NpCCGERSUkwJkzSrWat7cyFPQR5v78M3GJidSuXJlXi3nlrSVZ2/yeQghhzTINmWQaMtFqClfjJhkWWkzZe1Vj+fefYKvTsOkULPrxT4g/D+mRyhxshnRLhyiEEEIIIe6JjoYTJ5R/fXwem1gLi4jgq5UrAZgzcqR559JMS4PgYNi/H/78ExYtgokTYcgQmDVLWV9MyPyeQgiRe0aTkXRDOmqVGhUPdl+1ZlK5VlyptdRu2oUFU9/i3cnfMHY5dK43k6p9foHUsLvzs9UCtfyKCGEJ1jQcVAghhIXdvg1nz0J6ulKxpnr8F46Pv/uOtPR0WtWvT9cWLfI3nsRECA9/8Hb7Nty6BXFxD3+sRgOxsUqCsBi4f37PESNGEBoamm1+z08//ZSAgABefvllVqxYIfN7CiGKtUxDJnqjHp3m4V2vrZVkToozO09GjHyf/+0/STPvMCp73YTTk6Dpd5AUBCoduFYDlRQ4CiGEEEKYncmkzFF29iyo1VCmTK4edjE4mCUbNgDwybvvZs319dQ2bYKvvoKoXDTBcnRUGi2ULq38W6aMcr9EiVy/jqLAycmJH3/8kdmzZ/PCCy9kze/55ptvolKp+Pbbb5k2bRqrVq3C39+f7777DgcHmZ5FCFH8GIwG0g3paNRmrLTOR5JcK+ZUTpX4Y8kCVMlBcGIMJF2DS59D9XGQeBXUOnD2y9UVUiGEEEIIkU+MRmVo5fnzSqLqId1Ac+Jbtizz3nuPC0FBNKtT5+ljSUqCTz6BzZv/Xebq+m/yrEyZBxNpzs45P1dY2NPHU8jI/J5CCPF4mYZMDEZDoaxaA0muCY0Olas/6OOh1mSSD4zh0r4NNCxRH0q1g4SLoLEFx3KWjrTIKaaNekUhJr+z+U/eU1FQ5HerkDMY4MoV5ebq+vBE1UPY2drywYAB+RPLmTMwZYrSnVSjgbfegldeAamuEkLkQD5/xJO4V7VmY4ZpqQrqd1SSawLsvMDJj+vXQ+k8w5XI6DjOlJiL9/M1wNYD4s8pFWz2pSwdaZGg1SpdT1JSUrC3t7dwNELkXkZGBoB5J8UuouQ4IApaSkoK8O/vmihEMjPh4kUIDARPzzwlsUwmE0ajMX+O0wYDLFkC33+v3C9bFmbOBJlsXwiRg3vHnYyMDDm3EXmWbkjHaDKaJblWUOdIklwTCidfypQPx9HFg8vX4xi4OIPtpcehabkUjJkQd1ZpcqArYelICz2NRoObmxt37twBwMHBIf/mQhGigBiNRiIjI3FwcMDmMR3qxOPJcUAUFJPJREpKCnfu3MHNzU2S4YVNWpoyDPT6dWWIpa1tnh6+ef9+xn71FZ+8+y7dWrV68jhu31aq1U6eVH7u3BkmTAAnpyd/TiFEkWZjY4ODgwORkZFotVrUapm3W+SO3qgnNTMVtUpNemb6Uz9fpjETtUH9QLaroM+R5BuSUGhs0XnWZPnisTToMordF9JY8McNPnILgLoBkBoOsWfAvQFo8zY0QTyodOnSAFlfrIUoDNRqNeXLl5ckUD6R44AoSG5ublm/Y6KQSEpSGheEhysdQfN4IcNgMDB+0SIuBAXxz4kTT55c27EDAgKUjqAODvDRR9C1q8y/K4R4JJVKRZkyZQgODub69euWDkcUIhmGDPRGfb5VremNerQaLVp1zpVpBXWOJMk18S9bL6rWbsXCGW8w5MPFTP4D2tfYRmP3BlDuBUgJg7hz4F4fNHaWjrZQu/fhU7JkSTIzMy0djhC5otPp5CpkPpLjgCgoWq1WKtYKm7g4JbEWHQ0+PsrcZnn0+5YtnL12DTdnZ8YPGpT3GFJTYcEC+Osv5eeaNZUkm49P3p9LCFEs6XQ6qlSpkjWViBCPE5MSw+mI07g6uOZbdio8MZyqHlUp71b+gXUFeY4kyTXxL5UKnCsxaMBLbNlzhlUb9tJ/MZz0XoCzaw1w8YfkUEgqAa7VLB1tkaDRaOQLkBDFnBwHhCjmIiOVpgHJyUrF2hNcxEjPyGDKN98AMP7113F3dc3bE1y6BBMnwo0byvngoEEwbFieq+eEEEKtVmNnJ4UY4vGMJiNh0WHo1Xps7fI2DcKj6NV6NDqN2X8PpQRBZKexQ+Xiz7dz3qa8dykCI2DCCj2cGg/6ZKXBQfJ1yIi3dKRCCCGEEIXbrVtw4oQy19oTJtYAvv7zT66Hh1PWy4t3X3459w80GmHpUiWZduMGlCwJX38NI0ZIYk0IIUSBikiKIDwxHC8HL0uHki8kuSYeZFcSN+86LPvyXTq3bcTEfqUh9RacnQ42TmBIheRgkDbLQgghhBB5ZzIpTQvuNQx4irlfEpKSCPjpJwA+HjoUh9xeqY+KgpEj4csvQa+Hdu1g+XJo1OiJYxFCCCFyQ2/UExQbhFatRaspGp3N5ZKUeJBKBU6VaNmyJVuaNYD0KDj0BtzZAyHLoPyLyvxr9t5gVzSyzEIIIYQQZhMWpgwFdXAAN7eneqoV27YRFReHf4UKDO7ePXcP+ucfmDFDmevNzg4++AB69ZKmBUIIIcwiPDGcO8l3KOtc1tKh5BtJromc2diDS1WIPgZOlaD6GLav/IR2xq+w8XwGNA6QFAQ6d1DLXEFCCCGEELkSEQHnzuVLYg3grd69KevlhZ1Oh01uhnIuXAi//KLcr1oVZs+GihWfOg4hhBAiN9L16QTFBuGgdci3DqHWQIaFioezKw2OFSE1gg+/D6PTXJixxgiBP4JdSUi9DWm3LR2lEEIIIUThEBurJNYgXxJroHQe7taqFR2bNn38xuvX/5tYGzAAfv5ZEmtCCCHM6mbCTaJTo3G3d7d0KPlKkmvi4VQqcPYDW3ca1VLasAesg5OHtkPqTdDYQuI1MEirZSGEEEKIR0pKUoaCpqQojQOeUnhUFLEJCbl/wLVr8Mknyv3hw2HUKNDpnjoOIYQQIrdSMlMIjgvG1dYVtapopaOK1qsR+c/GAZyr8nL35rzYvS1GE8z/Gwj6Wekcmh6tzL8mhBBCCCFylpamVKzFxkKZMvnylGM++4xKPXuyZteux2+ckgIffQTp6dCsGQwZki8xCCGEEHkRGh9KfHo8rraulg4l30lyTTyefRlwrMjEt7sBsOow3DizEdLugM5VmXtNn2zhIIUQQgghrFBmJly8CLduQdmy+dI04PjFi6zYto34pCT8fHwevbHJpMyrdv26UjE3Ywao5SuAEEII80pMTyQkPgR3O3dURbCBjnyyise7Ozy0fv36tG9ZD4MRvtxshOBfQesKmQmQdN3SUQohhBBCWBejEa5cgeBgJbGmyZ8mUBMWLQLglS5dqFu16qM3XrMGtmxR9j17NpQokS8xCCGEEHkREhdCSkYKzrbOlg6lQEhyTeSOjSO4+PPhW0qL9+92Q9zldZARA3YekHIdMmItG6MQQgghhLUwmSAoCK5ehVKlQKvNl6fddfQo2w8fRmtjw8zhwx+98aVL8Omnyv0RI6BevXyJQQghhMiL2NRYQhNC8bD3sHQoBUaSayL37MvQpWsPalQph7uzlmvhGRDyO9g4KU0NEkOUE0khhBBCiOIuNFQZDlqiBNjZ5dvTfrtmDQBv9uqFr7f3wzdMSoLx4yEjA1q1UrqDCiGEEGZmMpkIiQsh05CJo87R0uEUGEmuidxTqVE5+rDx58kE7phBo0rAjT+VYaF2XpAapszDJoQQQghRnEVEwPnz4OAATk759rQJSUms/+cfAN7o2fPhG5pMytxqYWFKA4WPP5Z51oQQQlhEVEoUYQlheDp4WjqUAiWfsiJvbD2p6OePjWc9cKoMhmS4vhI0tqBSK80NjHpLRymEEEIIYRmxsXD2rHLfzS1fn3rfqVOkpafjX6ECDapVe/iGK1fCrl1gYwNz5oBr0evKJoQQwvoZTUaC44IBsLPJvypuayTJNZE3ahtwrACGVDLLvca6Y2AKWQ76FLD1hLQISA23dJRCCCGEEOaXlARnzkBqqtKZM591bdmSG3//zU9Tpz6809q5c/DFF8r9UaOgVq18j0MIIYTIjYikCMITw/Fy8LJ0KAVOkmsi7+y8MGBLnZd+oPfnsPNUAoSuURJvNvaQFAiGNEtHKYQQQghhPmlpSsVabKwyFLOAlCtdmuZ16+a8Mj4eJkwAvR7at4d+/QosDiGEEOJR9EY9QbFBaNVatJr8aepjzSS5JvLOxhGNUzk6taoDwIKNQMhSMKSDzh3SYyA5zLIxCiGEEEKYS2am0rwgPBzKloWHVZU9Bb3+MdNumEzK3Grh4eDjA1OnFkgcQgghRG6EJ4ZzJ/kOHg5Ft0Po/SS5Jp6MfRlGvdkDtVrN1jNw5mo03NygzLumc1PmXstMtHSUQgghhBAFy2iEy5chOFhJrGk0BbKb1kOH8tx773E5JCTnDX77DfbuBZ0O5s7N10YKQgghRF6k69MJig3CQeuAjdrG0uGYhSTXxJOxdce3Si1e6NocgM82AcG/Ks0MdK5Ko4OkEIuGKIQQQghRoEwmCAyEq1ehVCnQFsywl6s3bnDwzBm2Hz5MCReXBzc4dQoWLVLuf/ABPKrZgRBCCFHAbibcJDo1Gnd7d0uHYjaSXBNPRqUGx3J88FY3AH4/ADdv3oLwLcp6W09IuQHp0RYMUgghhBCiAIWGwqVL4O4OdgXXBe33Lcr51bNNm1LS/T9fVGJjYeJEMBigc2fo06fA4hBCCCEeJzUzleC4YFx0LqhVxSflVHxeqch/tp40bdyIVk1rk2mAhduAoJ/BZAQbBzAZlOo1k9HCgQohhBBC5LM7d+D8eXBwKNAhmCaTiWV3k2uvdumSfaXRqMytducOVKigJNlknjUhhBAWdDPhJvHp8bjZuVk6FLOS5Jp4cho7cPThw7eeB+DybQ0kh0DEbmW9nRekhEFahOViFEIIIYTIb3q9MhTUaAQ3twLd1bELF7h64wb2trb0bNMm+8qff4aDB8HWFj75BBwdCzQWIYQQ4lGSM5IJjgvG1dYVVTG72CPJNfF07ErRrXMLTuz8ibULBynLgn5S5iBR60CjhcQgMGZaNEwhhBBCiHwTEQGRkeDpWeC7ujcktGebNjjfnzw7dgy++Ua5/9FHULlygccihBBCPEpYQhiJGYm42rpaOhSzk+SaeDpaV9T2Zajv7wUV+ivVbAmXIeqgsl7noVSupd6ybJxCCCGEEPlBr4eQEKVazKZgO6AZDAZWbNsGwKvPPffviuhomDRJqZzr3h169CjQOIQQQojHSUxPJCQ+BHc792JXtQaSXBNPS6UCh7JgNIDWmTuOXTl7A6V6DUBtA1pnSAwEfapFQxVCCCGEeGr3qtb+21igAOgNBj4eOpTnW7ak0zPPKAsNBpg8WUmw+fkpVWtCCCGEhYXGh5KSkYKzrbOlQ7EISa6Jp2frCTo3/t64hQp9/2bwdypMMacg5oSyXlcCMuOU7qFCCCGEEIWVGavWAGx1Ooa98AJ/f/EFOq1WWbhyJRw9Cvb2yjxrBdilVAghhMiN+LR4biTcwN2+4C88WStJromnp9aCQzmeqVseUHE82MQ/l4CgJcp6lQp07krn0MwECwYqhBBCCPEUzFi1lqOUFPjp7uiAUaOgYkXLxCGEEELc50b8DdL0aTjpCq57trWz6uRaeHg4w4YNo0GDBrRv356ff/45a92FCxfo27cvdevW5YUXXuDcuXOWC1SAXUk8vcowqF9nABZsRJl3Lf6Csl7rDIZUSAq2XIxCCCGEEE/KzFVru48dY/GqVUTGxv67cOVKiIuDcuWgZ88Cj0EIIYR4nNjUWEITQvGw97B0KBZl1cm1UaNG4eDgwJo1a5g4cSJffPEF27dvJyUlhaFDh9KoUSPWrFlD/fr1GTZsGCkpKZYOufjSOoF9GUYP6YxKpeLvk3DxJv9WrwHYukNqOGQmWixMIYQQQognYuaqta9WrGDkvHl8tmyZsiApCZYuVe6/9ZZZEnxCCCHEo5hMJq7HXyfTkImD1sHS4ViU1SbX4uPjOXXqFG+//TYVK1akY8eOtGrVioMHD7Jp0yZsbW0ZN24cfn5+TJo0CUdHR7bcbVUuLMS+DFUr+dDzuVYAfL4ZiNgNSUHKehtHMKRAepTlYhRCCCGEyCu9HoKDzVa1FpuQwKb9+wF4tUsXZeGyZZCQAL6+0LlzgccghBBCPE5Magw3E24W+6o1sOLkmp2dHfb29qxZs4bMzEyCgoI4ceIE1atX5/Tp0zRs2DCrvatKpaJBgwacOnXKskEXd7YeYOvJh0O7A/DrPjUR8WSvXrNxhJQwpbuoEEIIIURhEBEBUVFmq1r7c+dOMjIzqVOlCrUqV4b4ePj9d2XlsGGg0ZglDiGEEOJhTCYTN+JvoDfpsdfaWzoci7Pa5JqtrS1Tp05l5cqV1K1bl+eee47WrVvTt29fIiMjKVmyZLbtPTw8uH37toWiFQCo1OBQjub1fWnasBaoNBy6CoRvUxJqAFo3yIiFjBhLRiqEEEIIkTtmrloDWLZ5M3Bf1dpvv0FyMlSpAu3bmyUGIYQQ4lGiUqIISwjD097T0qFYBatNrgEEBgbSrl07Vq5cyZw5c9iyZQvr168nNTUVnU6XbVudTkdGRoaFIhVZ7LxQaV35YcEorp/+m55dmoHJAMG/KuvVNoAJUiURKoQQQohCwMxVa6G3b7PnxAkAXu7cGWJiYMUKZeWwYaC26tN3IYQQxYDRZCQkLgQAOxs7ywZjJax2JtSDBw/y559/smfPHuzs7KhduzYRERF8/fXXlCtX7oFEWkZGBnZ28p9qcRo7cPChll8SOHqAzWCla2jYBvB7E+xKKtVrqeHg7Ac2xXvSQyGEEEJYMQtUrS3fuhWA1g0aUL50afj8c0hNhRo1oE0bs8QghBBCPEpkciThSeF4OXhZOhSrYbWXvs6dO0eFChWyJcxq1KjBrVu3KFWqFFFR2SfFj4qKemCoqLAQ+1Kg1oIhDdwbcDrWH4MhE4J/U9bbOII+SRobCCGEEMK6mblqDeB2dDQ2Go0yJDQyEv78U1kxfDjcnW9YCCGEsBSD0UBwXDBq1Og0usc/oJiw2uRayZIluX79erYKtaCgIHx8fKhbty4nT57EZDIBykR6J06coG7dupYKV9xP66ZUqGXE8dKQ8dQbeZn1x4GwNZARp5wY2jgo87CZjBYOVgghhBAiBxaoWgP4bMwYwrdu5ZUuXWDJEkhPhzp1oFkzs8UghBBCPMyd5DtEJEXg6SBzrd0vT8m1tLQ0/vjjD9577z06dOhA/fr1adCgAZ07d2b06NGsXbuW1NTUfAmsffv2aLVaJk+eTHBwMLt27eKbb75h4MCBdOnShYSEBAICArh27RoBAQGkpqby3HPP5cu+xVNSqcDBB4yZVPUrB8CCrfZKJdv15co2OldIj1aaGwghhBBCWBsLVK3d4+nmhlNCAqxdqyx4+22pWhNCCGFxeqOekLgQbNQ2aDVaS4djVXKVXMvIyGDRokW0bt2aP/74g0qVKjF69GgWLlzIF198wTvvvEOZMmVYuXIlbdu25csvvyQ9Pf2pAnN2dubnn38mMjKSF198kTlz5vD222/Tr18/nJyc+Pbbbzl+/Dh9+vTh9OnTfPfddzg4yPxdVsPWE3RujHytMzqdlgMXUzlwBQhdA0Y9qHVKo4PUCEtHKoQQQgiRnQWq1oxGI9fDw/9d8OOPkJkJjRpB48ZmiUEIIYR4lIikCCKSpWotJ7k6W3j55Zdp3749mzZtwtPz0W/izZs3WbVqFf369WPdunVPFVzlypVZsmRJjuvq1KnD2ntX84T1UWvBoRylS8QwoO9z/LRsPZ9u0dK8aixEHwKvlqB1gdRb4FxJaYQghBBCCGEN7lWtlSljtl0ePHOGlm++SZfmzdk0diyq9euVFcOHmy0GoUhKSuLo0aOcP3+emJgY1Go1np6e1KhRg6ZNm2Jra2vpEIUQwuwyDZkExwZjq7HFRm21vTEtJlfvyE8//YSbm1uuntDb25vRo0czePDgp4lLFAV2JcHGkTFD+/DTsvWsPZLJtdtQ+dbmu8k1Z0i5qQwPdfC2dLRCCCGEEBaba23Zli0AlCxRAtWPP4LBoMyzVq+e2WIo7q5fv853333Hxo0bcXV1pXLlyri5uWE0Grl27Rq//vorKSkpdO/enSFDhuDr62vpkIUQwmxuJ90mMiUSb2f57p6TXJ0x5JRYMxqNqNVq7ty5w/Hjx/H396dSpUqPfIwoZrTOYF+KmpXS6fpsCzZt38/nm2Fx2f+BPlnpGqrWKo0N7MvKXCJCCCGEsDwLVK1l6vWs2r4dgFfr14fZs5UVw4aZLYbi7vPPP2f79u307t2b1atX4+fnl+N2QUFBbNq0iWHDhtGlSxfGjBlj5kiFEML8MgwZBMUG4aB1QKPWWDocq5TnbqHHjx+nVatWHDlyhDt37tCnTx+mTp1Kjx492Lx5c0HEKAozeyWrPWb4ywBsPqvBqE+HiP8p63VukB4FmfGWiU8IIYQQ4h4LVa1tO3SI6Ph4Snl40P7QITAaoXVrqFXLbDEUdz4+PmzYsIG33nrroYk1gEqVKjFy5Eg2bdqEt7dUbwghiofwxHCiU6Nxtzd/k5/CIs/JtTlz5tC1a1fq1q3LqlWrsLW1Zf/+/cycOZOvvvqqIGIUhZnOHXTutGtSib+Xf8Gl1YNRq4FbdxOxGjswZkDaHYuGKYQQQghhqQ6hy+5eoO7XuDE2O3cqC2WuNbPq27cvGk3uqzFsbGzo169fAUYkhBDWIV2fTlBsEE5aJ9SqPKeQio08vzNXrlzh9ddfx97enl27dtGpUyd0Oh1NmjTh1q1bBRGjKMzUGnAsj9qUzvPPtkBXoZuyPPoIpEUp97UuytBQQ4bl4hRCCCFE8WahqrWklBT+2rMHgFcjI8Fkgg4doGpVs8UgsktKSmLBggUEBQVhNBoZN24c9erV45VXXuHmzZuWDk8IIczqZsJNYtNiKWFfwtKhWLU8J9c8PT25du0a165d48KFC7Rr1w6AAwcOUMaMc1OIQsTWC2ycQZ8IDj6YXGuTqTfC7a3Keq0zZCZARrRl4xRCCCFE8WWhqrW/9uwhJS2NyqVK0fj4cWUOWplrzaKmT5/Onj17UKlUbNiwgW3btjF79mw8PT2ZPn26pcMTQgizSc1MJTguGBedi1StPUae351BgwYxYsQIXnjhBWrXrk2TJk345ptvmD59OiNGjCiIGEVhZ2OvNCzIiOfbn1fjN+wGS/7h36GhKg2obSBFKh+FEEIIYQEWqloD6NW2LctmzWK6qysqgC5d4L4mYcL89uzZw/z58/H19WXr1q20a9eOrl27MmbMGI4ePWrp8IQQwmxuJtwkPj0eNzs3S4di9fKcXHvttddYuXIln376KUuXLgXgmWee4c8//6R79+75HqAoIuxLg1pLQnw8wTfj+W0/kHAJkoKU9Vo3SL+jVLAJIYQFDB06lPHjx2f9fOHCBfr27UvdunV54YUXOHfunAWjE0IUKAtVrQE42tvzirc3r1y5AhoNvPWW2WMoUCYTJCfD7dtw4wY4OSmv04qZTCa0Wi1paWkcPHiQNm3aABAfH4+Dg4OFoxNCCPNIzkgmOC4YV1tXVCqVpcOxek90aa5GjRrUqFEj6+d69erlVzyiqNKVAFsv+ndrwkczv2bvJRPXI6HCrc1QdYRS3ZZ2B9IilTnYhBDiIUJCQti3bx/nz58nJiYGlUqFl5cXNWrUoHXr1k/UvW3jxo3s2bOH3r17A5CSksLQoUPp3r07c+fOZfny5QwbNozt27fLFyshihoLVq1l+fpr5d+uXaF8ecvEkJ+MRkhJgYQEMBjA3h5KlVJubm7g7GzpCB/pmWeeYcqUKTg4OKBWq+nYsSMHDx5k5syZtG/f3tLhCSGEWYQlhJGYkUh5l8LzubTl2hbmHZjHl12+xM/94Z2fC0KeK9cuXLjAK6+8Qu3atalevfoDNyFypFKBgw8+pV1p26IBAL8fAG5tAZNR2UbrpDQ2MOotF6cQwmodPXqUQYMG0b17dzZt2oRWq8Xf35/KlStjNBpZvXo1Xbp0YciQIRw6dCjXzxsXF8e8efOoXbt21rJNmzZha2vLuHHj8PPzY9KkSTg6OrJly5aCeGlCCEuyYNXaoI8/Zm5AANFHjiiJvcJctWYwQHw83Lyp3DIyoFw5aNwYWrWCRo2Un608sQYwe/ZsatSogU6nY/HixTg5OXH58mXatGnDpEmTnvh5pUJaCFFYJKYnEhIfgrude6GpWotIimDOvjkkpCcQnxZv9v3n+fLcxIkTcXZ25ssvv8TJyakgYhJFla0HaJ15tXdbdu87zrIDKsb3CEcVexrc64PWFVJvQ0YM2JW0dLRCCCvy4YcfEhERQf/+/Vm0aNFDP39SUlLYunUrX3zxBd7e3nz66aePfe5PPvmEnj17cufOnaxlp0+fpmHDhlknEyqVigYNGnDq1Cn69OmTPy9KCGF5FqxaCwoL45e//0YNvA7QsyeULWvWGJ6aXg9JScoNlCGfvr7g5aVUqNnZWTS8J+Xs7MzkyZOzLRs0aNBTPadUSAshCpPQ+FBSMlLwdPW0dCi5YjKZ+OTAJyRnJuPv4c9zlZ8zewx5PosICgpiw4YNVKhQoSDiEUWZxhbsvXmhU33e0Wk5H5bJmRtQt9wmJbmmtlEq3FLDJbkmhMimT58+NG/e/LHbOTg40Lt3b3r37s2+ffseu/3Bgwc5duwYGzZs4OOPP85aHhkZSeXKlbNt6+HhwdWrV/McuxDCit2rWrNAx/vf71bCtgfK6HQwZIjZY3gi9yrUkpNBrVYq0fz9lco/NzfQ6Swd4VPLzMxk3bp1nD17Fr1ej8lkyrZ+zpw5eXq+x1VIq1QqJk2axD///MOWLVvkIo4QwqIS0hMITQjF3d78Fd1PamfwTv65/g82ahveafQOGrX55/bM87DQ6tWrExgYWBCxiOLAzgs3Nxe6d2oJoDQ2uL0DjBnKet3d6jV9suViFEJYnccl1mJiYh748tOyZctHPiY9PZ1p06YxdepU7P5TXZGamoruP18QdTodGRkZeYhaCGHVLFi1ZjKZWHY3ufYqwAsvKPORFQbh4UoCrWZNaN5cGfJZrRqULFkkEmsAkyZNIiAggNjY2Ac+W57EvQrp+y/aPKpCWgghLOl63HVS9ak46QrHSMWE9ATmH5gPwOB6gynvapk54vJ8JtGzZ08mT55Mnz59qFChAlqtNtv6Xr165VdsoijSlQBdCd7o1x73Ei68UH0P6OMgcj+Uagc2TpAWDelRYONo6WiFEFYoIiKCuXPnMnToUCpVqsQbb7zB8ePHKV26NF9//TXVqlXL1fMsWrSIWrVq0apVqwfW2draPpBIy8jIeCAJJ4QoxGJiIDoaSpc2+65PXb7MpZAQbIE+Oh28/rrZY3giaWlKIrJWLfDwsHQ0BWb79u0sXryYFi1aPPVzSYW0EKIwiUuLIywhDHe7wlO19uXhL4lOjaaiW0UG1xtMRFKEReLIc3Lthx9+wM7Ojk2bNj2wTqVSSXJNPJpKDQ4+PNemJs91fQ4uuUDIUri1SUmugZJUSw4Fex+wQDmnEMK6ffzxx6SkpODm5saaNWu4cuUKK1asYP369cycOZNly5bl6nk2btxIVFQU9evXB8hKpm3dupVu3boRFRWVbfuoqChKlpQh60IUGZGRyr8W6BC6bPNmALoDLv36gWfhmNOGqCilm6kFmj+Yk7OzM6XyoZJQKqSFEIXN9bjrpOvTKelYOM55j906xl+X/wJgcqvJ6DSWq6DO89nErl27CiIOUZzYeoLGHvQpUPY5Jbl2Zx9kJoDWRRkamnYHMmLBrpCcbAohzObQoUOsWbOGMmXKsGPHDjp06EDdunVxd3enW7duuX6epUuXotf/2514wYIFgNI84ejRo3z//feYTCZUKhUmk4kTJ04wfPjwfH89QggLSE+H27fBxcXsuzYajaz4+28AXi2MVWvlyytz5BZhb7/9NgEBAUyePJkKFSpg84QJWKmQFkIUJjGpMYQlhOHhUDgqk9P0aQTsDQDgxeovUq90PYvG80SfFHfu3GHZsmUEBgZiMBioVKkSffv2pWLFivkcniiStE5gWwpTSiiHL6exaqUrs3vHY3d7F5TrBWotmEyQFiHJNSHEA2xtbUlPTyc+Pp7Dhw9ndQQNCwvD1dU118/j7e2d7WdHR2UoeoUKFfDw8ODTTz8lICCAl19+mRUrVpCamspzz5m/85AQogDExEBiIvznOGAO8QkJNNPrOQQ898orShOAwiAqCipUKPJVawDff/89d+7ceegFm4sXL+bqeaRCWghRWJhMJm7E30Bv1OOgLRwdi3848QOhCaGUdCzJyCYjLR1O3pNrx44d46233sLf35969ephMBg4evQov/32Gz/99BMNGzYsiDhFUeNQGlNSMC+9MYHQm/G08IUXSm1Skmtwt7HBLXCqBDb2Fg1VCGFdOnbsyKhRo7Czs8PV1ZW2bduyadMmZs+eTe/evfNlH05OTnz77bdMmzaNVatW4e/vz3fffYeDQ+E42RBCPEZEhNLpUp3n3l5PrcSlS/yRnIzRwQH1a6+Zff9PJDW12FStAcydOzdfnkcqpIUQhUVMagw3E27i6VA4iluuRF9h6ZmlAHzU4iOraL6Q5+Ta3LlzGTBgAB988EG25QsWLGD+/PmsWLEi34ITRZjOA7WtK/17tWXe4pUs2w8vNDmhdAq1L600Nki5cbexQTlLRyuEsCIff/wxv/32Gzdv3qRfv35ZQ2uGDx/Oq6+++sTP+98vU3Xq1GHt2rVPG64QwtqkpMCdO5CHStd8dfdcWd2jh0WGpT6R6Gilaq1ECUtHYhZNmjQBICQkhMDAQIxGI76+vg80IHgcqZAWQhQGJpOJkLgQDCYDdjbWPzRdb9Qz659ZGEwGOvh2oE2FNpYOCXiC5NrVq1ezrrrc78UXX2Tp0qX5EpQoBjQ6sPfm1R7PMG/xSjaeUhGbbKJE+BaoNEi5Kqqxg9Sb4OBTLK6SCiFyx8bGhkGDBmVbJs10hBC5FhMDyckWGd6YcPky4fv2URVQvfSS2ff/RO5VrVWoUGzOxxISEpgwYQI7d+7E1dUVg8FAcnIyjRs3ZvHixTg7Oz/1PqRCWghhLaJSoriVeAsP+8Ix19qKcyu4EHUBZ50zY5uPtXQ4WfKcXPP29ubMmTMPzK92+vRpPAtLpyNhHey8qFPDj9o1/Dh7IZA/D8NbpTaB7+vKyZvWDdKjITMOdMXjSqkQ4vESEhL46aefOHv2LHq9HpPJlG39r7/+aqHIhBBWz2SC8HDQ6SySKFq/cCEDgW4lSrChfHmz7/+JREdDxYrFpmoNYNasWdy+fZtNmzZRqVIlAK5du8b48eOZM2cOs2fPfqLnlQppIYS1MZqMhMSFABSKqrWbCTf55vg3ALzf9H2rGsaa5+Tam2++ybRp0wgKCqJOnTqAklhbunQpY8aMyfcARRGmKwE6d17t1YbxFwJZdkDFW+2DIPEKuPiDxhaMmUrnUEmuCSHuGjduHGfPnqV79+44OVl+fgUhRCGSlKQkiywxHDM5mU1HjwJQu1Ej8+//SaSkgFarzLVWjOzatYslS5ZkJdYAKleuzNSpU3nrrbcsGJkQQuSvqJQowpPC8XLwsnQoj2UymZizbw5p+jQalWlET/+elg4pmzwn1/r06QPAb7/9xpIlS7C1tcXX15eAgACZI0DkjUoNjj7079aE8bN/Ys9FE6HRUO7WZiW5BqB1hpQwcKyoJNuEEMXegQMH+O2337Iu8AghRK7FxCgJIy/zf4kwbNjAFoMBgK59+5p9/08kOhoqVSpWVWugdKVW59DsQqVSYbj7fyiEEIWd0WQkODYYNWp0Gp2lw3msTdc2cejmIXQaHRNbTUSVQwX6f0e0mFOek2ugJNjuJdmEeCo6D8pXqEib5vW4FhjMtdvxlAvfAv7vgkoDWhdIuakMD3Uoa+lohRBWoFSpUjl+6RFCiEcymeDWLbC3QBdyo5HDv/1GLOBma8szheHiQHIy2NoWu6o1gPbt2zN9+nQWLFhA+buvPyQkhFmzZtGmjXVMnC2EEE/rTvIdbifdppRjKUuH8lixqbF8dvAzAIY2GEp51wc/m0wmE+PeGkf5muWpPra6uUPMXXJt0aJFvPHGG9jb27No0aJHbjty5Mh8CUwUE1onsC3JioWj8fL2Q/PP80qH0Ohj4NlUqW5Ta5XGBvZlis1EukKIhxs3bhwff/wx7733HhUqVECr1WZbX7asJOKFEDmIj1cq19zczL/vI0fYdPs2AJ1btMDG5omub5tXTAz4+Vnm/bKwsWPHMmLECDp37ozL3SHECQkJtGrViilTplg4OiGEeHoGo4Hg2GBs1DZoNdrHP8DCPjv0GfHp8VR1r8qAOgNy3Gbruq3s3rwb7U4tr738Gv4l/c0aY64+2Q8fPsxrr72Gvb09hw8ffuh2OZXlCfFYDqUp7XUdbHRQuiOEroZbm5XkGoDODdIjITMBdK4WDVUIYXnvvvsuAEOHDs1aplKpMJlMqFQqLl68aKnQhBDWLDoaMjLAzgITNq9Ywaa7d7u2bm3+/edVMa5aA3BxcWHp0qVcunSJoKCgrGlw7p+DTQghCrOI5AjuJN+htFNpS4fyWPtD97P52mbUKjWTW0/GRv1gGis+Np5Pp30KQN/hfangW8HcYeYuubZ06dIc7wuRL3QeytxqmQnoS3Yi5OhqKmt2gWE8aOyUW+odSIuU5JoQgp07d1o6BCFEYWMwKENCHRzMv+/QUG7t28fJuz92ad7c/DHk1b2qNdfic95169YtypQpg0ql4tatW4CSZKtXr162bUAqpIUQhZveqCckLgStWptjosqapGSmMGffHAD61+pPDa8aOW73VcBXxEbHUsm/Er2G9DJjhP/K1Tu5bt26XD9hr169njAUUWxpdGDvzZnDW+g0cCY6o4aQz1NQ39kDZTor22idlKGhThWUYaJCiGLL29sbgP379xMYGIjRaMTX15fmzZs/MERUCCEAiItTbhZoZMCqVbgDf1evzpn27Snp7m7+GPIiKUmp7itmVWvt27dn//79eHh40L59+4dOlC0V0kKIwi4iKYKIpAjKOlv/hYKvj33N7aTblHUqy/CGw3PcRp+pJ/J2JAATP5mIVmeZ7wO5Sq599dVXuXoylUolyTXxZOxKUtWvPGlpGUQkGNh7GdqU2vxvck3nCim3IC0CHHwsG6sQwqJu377NO++8Q3BwML6+vhgMBq5fv07ZsmVZsmQJpUpZ/6SsQggzi4pSqtfMnYBPTob167EDnn/7bZ4vLFVrVasWq6o1UKqiS9ztiioV0kKIoirTkElQbBD2NvZWX7V27s45VpxbAcDEVhOx1+bckMhGa8OXS7/kwukL1KxXk9D4UHOG+W8cudlo165dBR2HKO50bti5lObF51vw4/KtLNsPbWochIxY0JVQOofa2EPcBdDYg62HpSMWQljI9OnT8fDwYMmSJbje/fIXGxvL2LFjCQgIyPUFISFEMaHXQ3g4ODmZf98bNyoJtvLl4ZlnzL//vEpKUobOlitn6UjM7l5V9H/vCyFEUXI76TZRKVF4O1v3cU5v1DNr7yxMmOhauSvP+Dz6M1SlUlGzXk0zRZezXCXXjh49mqsnU6lUNGrU6KkCEsWUSg0O3rzaoxk/Lt/KH0fULHzdgG34NqjQT9nG1hNSwyHuHLg3VIaKCiGKnUOHDrFy5cqsxBpAiRIl+PDDD3n11VctGJkQwirFxiqdQkubedJmoxFWreIYsLpMGXpduEDTWrXMG0NexcSAvz/c7ZBZnFSrVi3XzdlkWKgQojDKMGQQFBuEg9YBjVpj6XAe6dfTv3It5hpudm6MaTYmx21CroWw/IfljBg/Ahc3y39u5Sq5NnDgwFw9mcxBIJ6KzoM2LZvgU9aLsFuRbDoFvT23/JtcA7ArDSlhEH8OStQHja3FwhVCWIarqyvx8fEPLE9ISJA514QQD4pU5mHBxszDX44cgZAQ/tBqmXf4MDc9PKw7uVaMq9YAfvnll1wn14QQojAKTwwnJjXG6qvWQuJC+OHkDwB82OxD3OzcHtjGaDQy+6PZnDh0gpTkFGYunGnmKB+Uq7OMS5cuFXQcQoDWCbV9afr3aMn8b9ay7AD0bnwWkkPB8e6JnkoFDmUhOQzUtuBWG6x8rLgQIn89//zzTJ48mY8//pjatWsDcPr0aWbMmEHXrl0tHJ0QwqqkpytDQp2dzb/vFco8MZscHCA+nq4tWpg/hry4V7VmiffKCjRt2tTSIQghRIFJ16cTHBuMo9bRqqvWjCYjs/fOJsOQQXOf5nT265zjdhtWbeDEoRPY2dvx9ri3zRxlznKVlcipNfXDSGtq8VQcyvBqr1bM/2YtG06qiE8x4Rq+GSoP/XcblQYcykByiDL/mou/knQTQhQL77//PtHR0bzxxhuYTCYANBoNffv2Zdy4cRaOTghhVWJjITERzD2HVmgo7N/PDeBcfDxqtZpO1jznWmJisa5aAx7aITQn0vBACFHYhCeFE5MWQzkX6z7Or720lhO3T2BvY8/4luNzPC7HRMXw5cwvARj24TDKlrOOHFSukms5taa+94UGyPpZhoWKp6Zzp06dOsyZ+Aad6upwyfwabm0Gv7eyJ9DUOmUOtoTLoLEDp4oWC1kIYV46nY65c+cyceJEQkJC0Ol0lC9fHgcHB0uHJoSwNrdvg1qt3Mxp1Sowmdjs5weBgTSrXRt3a+6+GRMDNWoU26o1gJEjR8qwUCFEkZSmTyMwJhAXnQtqlZk/D/MgIimCrw4rjclGNB5BWeeck2afT/+chLgEqtasSv83+5szxEfKVXJNWlMLs9HoUDn6MH54N6Uj6O4lkBIK8efB7T/zlNg4gDFTWaexBfsylolZCFHgjh49Sv369bGxsXmgyU56ejrnz5/P+rlx48bmDk8IYY1SU+HOHTB3Uis5GdavB2CTvT2AdQ8JTUxUOqn6+Fg6Eovq06ePpUMQQogCcTPhJvHp8ZR3KW/pUB7KZDIxd/9ckjOTqV2yNn1r9M1xu0P/HGLzms2o1WomzZuEjbnnU32EXEUiramFWdl6gfqqMpdayXYQvhlubXowuQagc4W0TIg7r1Sw6UqYP14hRIEbOHBgVgX1o5rsSAW1ECJLTIyS6HJ3N+9+N26E5GTSy5Vjx7VrgJUn12JioGZNJcFWjL322mssWrQIFxcXBg4c+Mgqtl9//dWMkQkhxJNLzUwlJC4EV1tXq67O3Ra0jb039qJVa5nSekqO88KZTCa+nf8tAP0G96NmvZrmDvORcpVcq169eq6fUL7UiKemcwOdO0ePHGHx99E0doURz2+DamNybl5g5wkptyD2DHg0AhtHs4cshChY9zfWkSY7QohcCQ8Hnc6887IajcqQUOBax444rluHq5MTdatWNV8MeZGQoCTV5OI5TZo0yeo4Lc0NhBBFRWGoWotLi2P+gfkAvFH/DSqVqJTjdiqVis9/+ZyfvvqJYR8OM2eIuZKr5JqHhwfR0dHUrVuXTp06UbNmTavOeopCTqUGB29OnP6VX9Yd4WQFDSM6xUHUISjZMufH2JeBlDCIOwcl6inDRIUQRcbjmuncTxrrCCFISoKoKHBxMe9+jxyBkBBwdKTmoEHcfvttQiMirPO82WRSGj5I1RqgzLmW030hhCiskjOSCY4Lxs3WzTo/h+769OCnxKXF4VfCj9frvv7Ibd3c3Rjz8RgzRZY3uUqu7du3j1OnTrFjxw5WrVpFeno6HTp0oGPHjjRp0gS1uSeJFUWfrSd9e3Tk3Wk/cua6nnOhUKv0pocn11QqJcGWelNJrLnWBituMSyEyJv7u7jd31DnHmmsI4TIJiZGmXPNy8u8+12xQvm3e3dwdEQNVChjpXPCJiQoDQyK+Vxr90yYMCHX286ZM6cAIxFCiPwRlhBGYkaiVVet7Q/dz+Zrm1Gr1ExpPQWtRvvANgaDgcP/HKZZ22ZWnSTM9exv9erVo169enz44YcEBgayY8cOPv30U8LCwmjbti0dO3akZcuW2NpKxZDIBzaOuJepTNd2Dflr22GW7Yc5FfaAPglsHnJ1VW0DdqUhMQg09uBc1bxDQYQQBUaa6Qghcs1kglu3wM7OvPsNDYX9+wHI6N0b7d2Ev1UymSAuDmrVAkeZTgNg7dq1qNVq6tatS8WKFS0djhBCPJXE9ERC4kNwt3O32s+i5IxkZu+dDUD/Wv2pVTKHOdaB1UtXM2/SPDr36kzA4gBzhpgnT9Rawc/PDz8/P4YNG0ZERATr1q1j3LhxGI1GTp48md8xiuLKvjSv9mqtJNcOagh4KR31oTeg1mRwq53zYzS2yhxs8ZeUBgeOFcwbsxCiQEgzHSFEriUkKJVr5u4SumqVkrRq0YJvjx5lzogRfDhgAGMGDDBvHLkhVWsP+P7779m+fTu7du0iKSmJDh068Oyzz1KzpnVNmC2EELlxI/4GKRkpeLp6WjqUh1p0dBERyRF4O3szvOHwHLe5E36HxXMWA1C3cV1zhpdnT9y3NDQ0lJ07d7Jr1y5OnDiBr68vHTp0yM/YRHFn60G3Lu1wdlpMaFQK+wKdaF0lEA4NgfJ9oeqInJsX2DiCMRPiz4PaDuxLmT92IUS+qlatWq6vusmwUCGKuZgYSE83b+VacjKsX6/c79ePTStWEB4VhTGHYewWd69qrXZtcHCwdDRWo1WrVrRq1YoZM2Zw6tQptm/fzgcffEBGRkZWoq1x48ZWWwEihBD3xKXFcSP+Bh72HpYO5aFO3T7FHxf+AGByq8nYa+1z3G7+1PkkJyVTq34tXhj4gjlDzLM8JddOnTrFrl272LlzJyEhITRo0IAOHToQEBBAuXLlCipGUVyptdh7VOLFrs+wZNUull1rQ+s2wK2NcGMV3NkDNcZByTYPPlbnBml3lAYHGlvlZyFEofXLL7/IFxohxOMZjXDzpvmTRhs3Kgm28uVJqVeP3R9+CEDXFi3MG0duJCVJh9DHuDcdztixY7l27Ro7d+5kwYIFWdPhzJ4929IhCiFEjkwmEyFxIWQYMijpWNLS4eQoXZ/OzH9mAtDTvyeNvRvnuN2ebXvYvWk3GhsNk+ZNQqOx7jnVc5VcmzRpEnv27CElJYWWLVsydOhQ2rRpg5ubWwGHJ4o9u5K82qc9+45dpVq1qlDnVSjbFc7PVpoXnPgASnWA6mOV4aD/eSwpN5UEm3sDsJGrs0IUVk2bNrV0CEKIwiAuTrl5mPFqvdGoDAkF6NeP3SdOkJ6RQYUyZaju62u+OHIrLg6qVpWqtVzy9PSkVKlSlC5dmqtXr3Lw4EFLhySEEA8VkxpDWHwYng7WOxz0h5M/cD3+Op4OnoxqOirHbZKTkpk3cR4AA4YNoEqNKmaM8MnkKrm2evVqbGxsqFmzJrGxsaxevZrVq1fnuO2vv/6arwGKYk7rSvt27bj8T31Ud4d3nr5dgiTtJJqVPIT6xjKI2AnRh8H/PfDpBar7utfal4GUMGWIqFtd0Ogs8zqEEE+lQ4cO/Pnnn5QoUSJb59CcSPMDIYqx6GjQ60Fnxs/7I0cgJERpDNCtG5sWLQLguebNra/iNi0NtFqw1g6mViI4ODhrtM7p06epUqUK7du3Z9iwYTIHmxDCahlNRkLiQjBixM7GzE19culy9GV+Pa3kjD5q/hHOts45bvfNvG+ICI/Au7w3b41+y5whPrFcJddGjBhhfScHonhQqVE5+kD0bWWOEJWKT776heWrt+JdpiQvdO5I32qXae4dgvr8bLi1GWpOAqeKWY/Hviwkh4Jap9zXuYH6wRa/QgjrNXLkSBzvdrQbOXKkfCYJIR6k1ytdQp0e0lW8oKxYofzbvTsmBwc23e0YapVDQmNjoVQpkNEnDzh27Bi7du1i9+7dhIaG0qhRI7p06cL8+fOlqY4QolCITI7kZuJNPO2ts2pNb9Qz85+ZGEwGOvh2oJ1vu4du27JjS/bt3MdHsz/Czt46E4X/lavk2rvvvlvQcQjxcLYeSpMCQzLYOOHm4oyLsyM3w+/w1c9b+Qoo6+XICw3T6Nv4JK3i+oPfYKg0SEmoqW3AvjQkBUNSCGidwLakMoxU6wY2OU+eKISwHr17986636dPHwtGIoSwWrGxEB+vJI/MJTQU7ibTeOklLoWEEHLrFjqtlvaNc55DxmIMBuXm4wNygeIBAwYMQKvV0rhxY15++WVc73abPXr0KEePHs22ba9evSwQoRBCPJzBaCA4Lhg1amxtbC0dTo6WnV3GpahLuNi6MLb52Edu27R1U/743x/YaJ+4B6fZ5SrS119/nZEjR9I4lycJBw4c4Ouvv2bp0qVPFZwQgJJYsy8FyTfAxon/WzCezwPGsG33If5cv5O/Nu/hVmQSC7fAP1ccOTUzGa59B+HbMdWciMq9vtLUwLEcmAyQmQTJwZAUCBoHsHUHu1KgcwUbZznhFMIKvfbaa7neVqYnEKKYioxUqtxtzHgivmqVss8WLaB8eexv3eKDAQNISknB0d7KLt7FxSkVa15elo7EKpUtWxaAkJAQQkJCHrqdSqWS5JoQwupEJEcQkRRBaafSlg4lRzfib/Dd8e8AGP3M6IfOCZeWmpZVqVaYEmuQy+Ta5MmTmTFjBtHR0XTs2JHmzZvj5+dHiRIlMBqNxMbGcvnyZY4fP86mTZvw8vJi2rRpBR27KE7sSkPSdSU5ptJga6uje5fWdO/SmvT0DHbsOcIff+2gQR1/qOsBFxeQFB1M7eZv8VyLSvQd8C6tWzdXOozoXJWbyaRUw6VFKMNGbWyVSjb7MqB1VW5q6+5IIkRxceTIEVQqFfXq1aNp06bYmPPLsxDC+mVkQHg4OOc8d0uBSE6G9euV+/36AVCxbFkWjBplvhhyy2RSuoRWrWre5GMhsmvXLkuHIIQQTyTTkElQTBA6jQ4btfUd440mI7P2ziLdkE5T76Z0q9Itx+1uBN3gjV5v8Mb7b/DS4JdQq9U5bmetcvXOV6lShaVLl3L06FFWrFjB+++/T0JCQrZt3NzcaNGiBQEBATRp0qRAghXFmK0H6Fwg9bZyX/PvuGtbWx3Pd2rJ851a/ru9R1M2fj2OkMjjfL0uiK/XjcarhAM9urSmd48udGjdGDs7W7BxUm4AhjTITFSSbSob0LooFW227krSTZohCGExmzZtYseOHezYsYPly5fTunVrnn32WVq1aoW9tVWHCCHMLyZGSR6Zc6L+jRuVBFv58vDMM+bb75NISlLmopOqtYf6888/eeGFF3I9p6fBYGDNmjX07du3gCMTQohHu510m8iUSMo6l7V0KDlae2ktJ8JPYGdjx6RWk3I8zppMJgLGBRAbHcs/2/+h35B+Foj06eQprdm4ceOsoaFhYWHExMSgUqnw9PSkjHQdEgVJrQXXmpAUBOnRYMwArbOSAFPlUF2mc6X324vYVG4ZfyxfwrrDyUTGpvDj8i38uHwLTg5aViwey/M97pu7SWP3b9LOmAn6JEi4rPxs46TM0WbrqVS02TjK8FEhzKhSpUoMHTqUoUOHcufOHXbs2MHKlSuZOHEiTZo04dlnn6Vdu3a4ySTdQhRPERHK57LGTBXnRqMyJBSUqjW1mtNXrhARE0Pr+vWxs7Wy+W7i4qBKFaWjqchRaGgo3bp1o1evXnTs2BFfX98ct7t+/TobN27kr7/+olOnTmaOUgghskvXpxMUG4SD1sEqq9YikiL46vBXAIxoPOKhCcC/lv/F8YPHsbO3Y+InEwtl8zKVyWQyWToIS0hKSqJhw4YcP34cJ3N3lRJPzmSCzHhIi4TUm5ARr5xM69yUhFdODGlkBv7Onh1/s3bPDdYdh1uxEPwFVKzoCyXbsO2KByHROnp2bUupkh7/2acB9MnKXG0mPWjslf3ZlZLho0JYWGJiInv27GHnzp3s37+f6tWr88svv1g6LEA+Z4Qwm9RU2LcPtFrzDQs9dAhGjlSSVZs2gaMjb82axQ/r1jGqf38+/+AD88SRG2lpSnKtWTNwd7d0NFYtKCiIH374gU2bNlGiRAkqVaqUNQ1OXFwcV65cISEhgeeff54333wTPz8/i8YrnzNCiODYYE7ePkk5l3KoVdY1jNJkMjFm2xj23thL7ZK1+aH7D2hy+N4ceTuSvu36kpSQxKipoxgwbMBT7Tc0PpTapWrj527eY7T1pTaFeJR7iTSdGzhVVKrYUm8rQznTo5UGBTpXpdLtHo0d2qpD6Fh1CB0H32bh7T2cO7KFim4XlMYGwcF89QVsPAXDP5xD8/q+9O7xPL27d6RSRR+lMk7rotxMJmX4aEYcpIQrnUi1zkr3UVsPZd+awtEqWIiiICwsjJCQEG7cuEFKSgp6vd7SIQkhzO3ekNBy5cyzP5MJfvpJud+9Ozg6YjKZ2HS3a2iX5s3NE0duxcUpw0FLlLB0JFavUqVKzJ49mwkTJnDkyBEuXLiQNVLHz8+PgQMH0rRpUxwcHCwdqhBCkJqZSlBsEC46F6tLrAFsC9rG3ht7sVHbMLnV5BwTawDzpswjKSGJGvVq0P/N/maOMv9Ick0UXmot2JdWbplJkB4FKWGQdkc58dW5PNj90740at9+1PHtpzwmaj9E/I92tfYQkZDBsSDYfyKY/ScW8eHHi6hTtRQv9urK5HHvKKWpKhXY2Cs3+Hf4aOJV5WbjADoPsPOS7qNCFAC9Xs+hQ4fYtWsXu3btIi4ujubNm/PKK6/Qrl073KUqQ4ji5/ZtpWrNXJ+3R4/CiRPKPgcoV9fPXL3KrchI7G1tadOggXniyA2DATIzlcSjnI/kmrOzMx06dKBDhw6WDkUIIR4qLCGM+PR4yruUt3QoD4hLi2PBgQUAvFH/jYdWke3atIvdm3ajsdEwZf4UpQFhISXJNVE0aJ2Um0M5yIhVEmyptyAlFNQ6pdLtvxVlWico0xnKdOaDzzP5IOY4oWc3s27THtYeSmLPRThzJQK39UuY0u4seLWEkq04dCGB+nX8sbXVKQk+XQnlZjKCPgXSwiH5utJ91MZF6XSqc3uwok4IkWt//fUXu3btYv/+/dja2tK2bVumTJlCixYtsLOTalEhiq2kJIiKAhcX8+zPZIJvvlHu9+kDpUsDZFWtdWjSxLrmW4uLUyrWPD0tHYkQQoh8lJSRRHBcMG62blY5P9mnBz8lNi0WvxJ+DKo76KHb3bxxE41Gw+vvvE6VGlXMF2ABeOLk2tWrVwkJCaFFixZER0fj4+Njlf+pophRa5TGA3ae4FxJGSqachPSI5UmCBoHJan230SbWguez1Cu3TO829bEuwkXibqylb83bcdDewdijkHMMe4c+YLmI8DRzoYurWvTvXs3unZqg6eHG6jU/yb5QBk+qk+C+HN3K96clIYI0hRBiDz76KOP0Gq1NG7cmHr16qFWq7l48SIXL158YNuRI0daIEIhhEXExCgdO82VPDpwAM6cAVtbGDw4a/G95FrXFi3ME0dumExK8rFKFaXKTgghRJFxI+4GyRnJlHe1vqq1/aH72XxtM2qVmimtp6DVPPwzaODwgTzT+hnKV7K+15FXeU6uxcfH8/7773PkyBEAtm7dSkBAAKGhoXz33Xd4e3vne5BCPBGNHTh4g31ZyExQho2mht9tiHAHNLbKsE2NffYkl0oFrjXwbFyDQY1HK0NN7+yFyH1cu3qMUq4Gbsfp+XPrSf7cehK1eibN6vjQvWsnXnqxJ74VvP/dv8YObAGjXmmKkHxd6XiqsVfmcLvXFEGq2oR4pHudqjMzMzl69OhDt5OLPEIUIwYD3LwJ9vbm2Z/JBN9+q9zv2zcroRebkMCBM2cAeM6a5ltLTgYnJyhZ0tKRCCGEyEfxafHcSLiBu731TYeSmJ5IwN4AAF6u+TK1StZ67GMKe8XaPXlOrs2aNQt7e3sOHTpEmzZtAJg9ezZjx45l1qxZfP311/kepBBPRaVSklc6V3CqpCTaMuMgNUIZQpoepSS2bJyVOdP+Oxmkgw9U7A8V+9O8fjI3XzzE8X0b2bDjKOuPpHL6Buw/Fcb+Uz9RMnkTvv27gVdLUrSV0Op0aLU2SuODezEA6FMhM1FpxKBSS1WbEI+xdOlSS4cghLA20dEQGWm+5NE//8CFC0oy77XXshbvPnYMo9FIjUqVqFi2rHliyY24OKhcWeloKoQQosi4Hn+dtMw0vBy8LB3KAz49+Cl3ku9Q3qU87zR+J8dt0lLTmD5mOkPeHVJkEmvwBMm1vXv3snTpUlzum9vC3d2dCRMm8PLLL+drcELku/sTbY4VlGqyjDhIi1SGjqbE/juE08ZJSYrdz8YRdZkONO7bgcYvGpmRcJkbZzfz95bdbNgfzvP+tyHwBwj8gW+22jNjdSZdWtege7fudH62nTJ8FP7TFEGq2oR4nC+//JI33ngDJyenXG2fkJDAjz/+yOjRows4MiGERZhMEBqq3DfHkEej8d+qtX794L7mKb3btePsihVExsUVfBy5lZ4OGg2UKWPpSAqNCRMm5HrbOXPmFGAkQgjxcDGpMYTGh+LpYH1zae65voe/r/6NChXT2k7DzibneZG///x7tq/fzvmT51mzbw02NkWjFcATvYr09PQHlsXExBSZN0UUIzaOys3BW5kjLSNOmactLUK5mYzKeq3zgwkulRpcq1O+ZXXeaTmGd9KjIfIARO6D6EP8cz6Z+GRYufkMKzefQaUKoEnNknTt2JKuz/egQb0aqNXqPFS1edytanOSqjZR7JQuXZqePXvSqlUrOnbsSNOmTdH+5wt1amoqJ0+e5O+//+bAgQMMHz7cQtEKIQpcXJzSJdTDwzz727ULrlxRqsDudgi9R6VSUatyZfPEkVuxsUpFX4kSlo6kUEpNTWXLli3Url2b2rVro9VquXDhAidOnKBXr16WDk8IUUyZTCaux11Hb9JjrzXTlAi5FJcWx+y9swEYUGcAdUvVzXG7S2cv8ds3vwHwwYwPilQOKc+vpFu3bgQEBDBjxgxUKhUpKSkcOnSIadOm0bVr14KIUQjz0NiBfWnlZqyqJNoyYiD1tjJ01JAJNnZ352mzezDBZesBPt2VmzGT1XVOcOSfv1i/7RCbjyZw+gYcPneHw+fWMGfxGmLWd8TeuyV4PkOm2k0ZPgoPqWq7cbeq7e48cXallWSc1uXB5gxCFEH9+vWjc+fOLFu2jIkTJxITE4OPjw8lSpTAaDQSFxdHWFgYXl5evPjii6xdu5YS8qVSiKIrLAz0ejBHt2CDAb77Trn/yivg5lbw+3waBgNkZoKPj1yMy4P7q9FGjRrFyJEjH2iQ88MPP3Dw4EFzhyaEEABEpUQRlhCGp731Va3NPzCf6NRofN18Gd4w5wvcer2emR/OxGAw8Gz3Z2nTqY2ZoyxYeU6ujRs3js8++4w+ffqQmZlJz5490Wg09O3bl3HjxuVrcBkZGcyZM4e///4brVbLiy++yOjRo1GpVFy4cIFp06Zx5coVKleuzPTp06lV6/GT5QmRK2ot2HkpN6fKoE+4O3w04m51WySobJTOoDaOoNI88HhNyaY0e7EpzV6EOSm3uHlhG1u2bmfTvmto1QbsY3ZAzA4Amky2xdHZlec6PEPXbn2oV7emMjH7f6vaDGlKsi3+gvKzjQPoSihxal3AxkXpmCpEEeTm5saIESN45513uHz5MhcuXCAmJgaVSoWHhwc1atSgatWqlg5TCFHQEhPh1i3zJbm2b4egIHB2VpJr9/ni9985cv48w/r0oU3DhuaJ53Hi45WKNS/rm4unsPjf//7HqFGjHljeoUMHFi5caP6AhBDFntFkJDguGOChwy0tZWfwTrYGbkWj0vBx24+xtbHNcbtl3y3j8rnLuLi58OHMD80cZcHLc3JNp9Mxfvx4Ro0aRWhoKAaDgXLlyuFYAJOlzpo1i8OHD/Pjjz+SnJzM6NGjKVu2LD169GDo0KF0796duXPnsnz5coYNG8b27dtxcHDI9zhEMafWKAksXQlwrKgktzLjlWq2tChICQdMSqLLxkmpLvsvh7J4NxrEG40G8YZRD3FnIeoARB0i/PpFTgWnA3fYf2Y9kz9fTxl3HV1a+dP1ued4tnNXXF3uzjN1fwdSkxH0KUrCLyX0blMGR7AtqcSqdZHGCKJIUqlUVKtWjWrVqlk6FCGEJdy+DSkpWd06C5Re/2/V2oABSoLtPiu2bePwuXN0aNzYepJriYlQr5555qIronx9fVm9ejUffPBB1jKTycSyZcvw9/e3YGRCiOIqIimC8MRwSjmWsnQo2cSkxjBnn1L5+3rd16npVTPH7UKDQ/nuU+XzdPTU0Xh4mWlaBzPKVXLt6NGjj1x/4cKFrPuNGzd+uojuiouLY/Xq1SxZsoQ6deoAMGTIEE6fPo2NjQ22traMGzcOlUrFpEmT+Oeff9iyZQt9+vTJl/0LkSOVSqlW0zrdnactQ0m0ZcRB2m2l+6gxA9Q6ZRtNDskttQ2411duVUdQpmEM16tuZfPmrWzed5kdZzIJj8lgyV9nWfLXWV5vt4ifZzwPns0xujXApLFDo9Eo87HdiwXAmKkk/pICwWhQhpZmNUZwuTuENOerCEIIIUShkJYGN27AfY21CtSWLcr+XF3hP427ImNjOXL+PADPtWhhnngeJylJmReulHV9+SpsJk2axPDhw9m2bVtWMu38+fOkpaXxww8/WDg6IURxozfqCY4LxkZtg1ZjPRdOTCYTc/bNIS4tjsrulXmzwZsP3XblkpWkp6XTpFUTur3UzYxRmk+ukmsDBw7M1ZOpVCouXrz4VAHdc/z4cZycnGjSpEnWsqFDhwIwZcoUGjZsqAybu7vfBg0acOrUKUmuCfPS6EBzd/ios5/SiCAzHtLuQHoMpN/ffdQx566ftu6Ub9ifYQ37M8xkJD3qPHt3rGPTzoNsPnyHrrVS4MYfcOMPTgRr6DQXOjT1pfOz7Xm2czcqlC+rPI9aCzo35WYyKUNIMxOVWFAp+9e53TeE1PnBbqhCCCGENYuIUIY9li9f8PvS6+H775X7r72mJK3us/XgQUwmE/WqVqWstQzBjIuDSpUeiFXkTaNGjdi2bRubN28mMDAQgDfffJPnn38eF3MldoUQ4q7bSbeJSIqgrHNZS4eSzdbArewO2Y1GpWF62+noNLqHbjt62mi8y3vT6tlWWXmcoiZX36wvXbpU0HE8IDQ0FG9vb9atW8c333xDZmYmffr04e233yYyMpLK/+nK5OHhwdWrV80epxBZVOp/50dzLH+362f83SRbhDKM1JipVLXZOCrDSP87V5tKja1XbTr2r03H/vCZPhlT1BGIPgxRB9l57iaxSfDnzmv8ufMajP8O/3JOdGpdh06dn6dd29Y4OtrfTejd1xjBZFDiuTeEVGVzdwipF9jeG0LqpLwGIYQQwhplZkJIiJI4MseJ+YYNcPMmuLvDSy89sHrT/v0AdLWWqrX0dNBooKx1ffkqrNzd3enZsyc3btzAz8+PzMxMnJycLB2WEKKYyTBkEBgTiL2NPTZWVBgRlRLFvAPzAHizwZv4ezx6yLxGo6H/m/3NEZrFPNH/jslkYv/+/QQGBqLVavHz86Np06b5GlhKSgrXr19nxYoVzJkzh8jISKZOnYq9vT2pqanodNmzojqdjoyMjHyNQYinci+5da/7qD7xbiVZ1N0upOHKvGkaeyXRpnF48MuCjSOq0u2gdDswmfigXghtuqxl2669bD0UxuFrJi6HJnF52QEWLjvAnk8q0brts+DZjER1eRydnFCr1UoSL9sQUj3okyA5BJKuKcNFNY7KEFKdG2idc45HCCGEsJTISIiNNU/yKCMD7g3/GzQI7O2zrTYYDGy52zXSapJrsbFKEwN3d0tHUuilp6czY8YM1q5dC8DWrVv55JNPSE1N5bPPPsPV1dXCEQohiovwxHCiU6PxcfaxdChZTCYTAXsDSEhPoJpnNQbXG/zQbf/+4286duuInb11NWEoCHlOrl2+fJmRI0cSHR1NxYoVMZlMhISEULFiRRYuXIiPT/78p9vY2JCUlMSnn36Kt7c3ALdu3WL58uVUqFDhgURaRkYGduZoxy7Ek1Db3NcUoTwY0pVEmz5BGbaZcbfCjXsVZ45K44L7qVTYuPryTPcxPNN9DFMN6cRd38/u7X+z7Z+T7D+fyDOlg+Dat3DtWyb8qmPFQRMdm1ejQ8cudGjXgkoVfe6Lx025gRKPPhkSLgNGJbGmdQG7kjJfm7AKAwcOzHUJ+a+//lrA0QghzM5oVOY+02qV6qyCtm6dMgTVywteeOGB1YfPnSM2IYESLi40tYZu9QaDkhAsV04ujOWD+fPnExgYyNq1a3n57lx77777LhMmTGDWrFnMnz/fwhEKIYqDNH0agbGBOOuc0ajN8NmXSxuvbmTvjb1o1Vo+bvPxQyvqdm3axcejPuaXxb/w+7bf0eqsZ764gpDn5Nq0adOoW7cu06dPz+oQmpCQwMSJE5kyZQpLlizJl8C8vLywtbXNSqyB0rknPDycJk2aEBUVlW37qKgoSpYsmS/7FqLAaWzvJqs8wamS0vUzM+Hf+doy4yEtUhmmaeOY83xtGlvcKrWn97D29B4GpN6GqENKF9LoIxy8nER0AqzccpaVW84C86no40GHNi1o37oJL/fppFS13R+Prfvd+dpSlXjSIlASfg5KYtDW826yzTnn+eOEKCD3V0fHxsaycuVKOnbsSO3atdFqtVy8eJFNmzbx6quvWjBKIUSBiY6GO3fAHOd6aWnw00/K/SFDwPbBi0tpGRk0qFaNquXLY2NjBcN04uOhRAklGSie2rZt21i8eHG2zqD+/v7MnDmTIUOGWDAyIURxEhofSlxaHOVdzDDPaC5FJEWw4OACAIY1HEZl98o5bpcYn8gnkz4BoG2XtkU+sQZPkFy7cOECc+bMyUqsAbi4uDB69Oh8bSZQt25d0tPTCQ4OxtfXF4CgoCC8vb2pW7cu33//PSaTCZVKhclk4sSJEwwfPjzf9i+EWdk4KDf70uBcRakiy0y4O19bpDJfmyFTqTi7t636PxNG2peGcr2Um1HPoc2nOLxnPTt272XnqUQOXYOQsGh+XLaeXbt38UqXauBUEYAjx8/hX6Uiri5Od+dru7sPyD5fW3LovzHYeoLO/d/52qzoaoooekaOHJl1f9CgQUycOJFXXnkl2zaNGzdm5cqV5g5NCFHQTCYIC1Pua81wcr56NURFKR03e/bMcZP2jRtz/LffyNTrCz6e3EhMhLp1zfP+FAPJycnY/2coMIDRaMRgMFggIiFEcZOQnkBQXBAl7EpYTQMAk8nEzH9mkpSRRK2StRhQZ8BDt/1y1pdE34mmgl8F3hz18C6iRUmeZy+vW7cuB+/OMXG/EydOUL169XwJCqBSpUq0bduWCRMmcOnSJfbu3ct3331H//796dKlCwkJCQQEBHDt2jUCAgJITU3lueeey7f9C2ExKrVSGebgDSVqQ8nW4NUSPBqBY0VlfXoMJN+AlDDIiFU6g95PbYO2ZCNa9p3Bx4t3sXfjD8T+/f/s3Xd8k1UXwPFf0ozuvcsqLXvvLcpQVBTB8eIAFRUREEQRBGTLXoooiqggDkQUUAEB2UuQvUcLlEL3HklHxvvHpQVktSWrcL9+8qF98vTJacEmOffcc55gzQfODH0cXm+bAzuegd0vY4heSuen++Mb0YGWD7/CyImfsXHrXvT6K9cs6tfmEgzulcRWURRiMELqPkjeIW4ZJ0AXB4U54o2QJFnJoUOHaNWq1Q3HGzRowOnTp+0QkSRJVpWZCfHxtuklptfD4sXi49dfB82tJ58BqB2hai0nRwx5CAqydyT3jA4dOjBnzhxycnKKj8XGxvLRRx/Rvn17O0YmSdL9wGw2cy79HLoCHZ5ax5lQvOLUCv65/A9aJ+1tt4Pu27mPlT+uBODDGR+idb4/2guV6BXBvHnzij+uXLkykydPZu/evdSvXx+lUsmZM2f4888/eemlW2cuy2LmzJlMnDiR559/HhcXF1588cXivjtffvklY8eOZdmyZdSoUYMFCxbg6upq0ceXJIdwbX80t4pgMophBIYcKMgQVW3F20gVVwYkuIFSKz5XKMCnIe7NG/Jokw94NHk7XF4tto9mHicu+jhBbpCVDXv2H2PP/mNM+fhbtFoNbZo3oM+LT/Lis4/+Jx4v4EozX1OBqLTLiboyoEELKo8r/dq8rlS23bj6K0llVbt2bRYsWMC4cePQXtmulZOTw9y5c2nYsKF9g5MkyfLi4kQ/sZtUElncsmWQlgZhYfDEEzc9JSo2liBfXzyu2cVhVxkZULUqyEmWFjNmzBhGjhxJ8+bNMZlMPP3002RnZ9O2bVtGjx5t7/AkSbrHJeuSic2MJdDNcdpexWXH8fGejwF4q+lbVPGuctPzcnNymfDeBACe7vU0jVo0slGE9lei5NqePXuu+7xRo0akpqayefPm4mMNGjTg2LFjFg3Ow8OD6dOn3/S++vXrF0/wkaT7itJJJLc0XqK6zWy6so00+8pW0mTxsTGZ4gEJGh9R8eakheBO4pafBvHrqBS3mjOzThGbChuPwaZTajaecCIuJY9N2/+lfZvGxQ+dmpbB598sp33rxrRoUhetViO2p2o04jHMZjDli8Rf5knxRU7OIlbnIJF0U3uC0+0rASTpdiZOnEjfvn1p06YNlStXLh6sExoaypdffmnv8CRJsqScHIiNFf3ErC03F4oGorzxBtyiKu31iRPZffQoP02aRI8OHawf1+3k54sBD7aYoHofSU9P59NPPyU2Npbo6GgMBgPh4eFERETYOzRJku5xBpOB6LRoFChwVjnGwEaT2cSErRPQFepoGNSQ5+s+f8tz50+fT1xsHKEVQ3l71Ns2jNL+SpRcW7JkibXjkCSprIq2kao9gFAw1xDJNkOOSLbp48TNJez6CWJaX6jyvLhlR1Exbg2vhK7llfbJmM2FnI6HTWd9eKDl1UqBrTsPMGbKFwA4O2tp1bQe7ds05sE2TWjRpC7OzlqRTHNyBi0i8WfUi62r+oQrlXVuolebs7+IWeUhquEkqYQiIiJYu3Ytu3btIjo6GoBq1arRunXrUjcWj4mJYcKECRw4cAAvLy9eeuklXn9d9IWIjY1l9OjRHDp0iNDQUEaOHEnbtm0t/v1IknQbCQki6eXvb/3H+uknsQW1UiXo0uWmp6RmZLDj8GGMRiONrml2bzfp6eJnY4vk433k+eef58svv6Ru3bpUrFjxrq8nn2skSSqpuOw4EnISCPVwnEWTX078wr74fTirnBnbfuxtJ5f26teLi+cu8vKAl3H3uL8qqkv0LmTlypU89thjaDQaVq5cedtzn3rqKQuEJUlSmSkUokdaUZ805yBIPwj6eHC9xS9pj0ioMQiqD4DUf1HEraamajM1Q9Mh92M4cgZqDSMwwJf/de/Mlp0HSExKZfOOfWzesQ8ArVbDb4un81jna14QXjvtFK4MR9BBXjzoYsTEUSdX0AaIZJ/aQwxHUJS6HaR0n9FoNISFhVFYWEjr1q1JS0vDyal0QzVMJhN9+/alXr16rFixgpiYGN59912CgoLo2rUrAwYMoHr16vz666/8/fffDBw4kDVr1hAqK0QkyTby8yEmBry8rP9Y2dnwww/i4759b1m1tmbnToxGI/UiIwm/ZqK9XRiNUFgIFSuCUj5vWpK/vz+pqakWuZZ8rpEkqaT0hXqi0qJwU7vdsp+ZrcVmxvLp3k8BeLv521T0uv2CQ1BoEHO/n2uL0BxOif7G5s6dS/v27dFoNMyde+sflEKhkMk1SXI0Gi/wrg9pB8XET+fbNDxWOIF/S3Ez5MK5xXBuEcStgbSDtK0/gbYLp2A2mzl9Noatu/azZae4JSSmUrtG1eJLff71LyxdsZ52LRvStmVDWjdvIKaRFlfZAaZC8Ti550XPNietSK5pA0WPObWHSL45yIQcyTFkZmYyePBg9u7dC8C6deuYNGkSsbGxLFiwgLASvuFNSUmhVq1ajBs3Dnd3d6pUqUKrVq3Yv38//v7+xMbGsnTpUlxdXYmIiGD37t38+uuvvP32/VXiLkl2k5goKsksUDl0Rz/8IBJsVatC5863PO33bdsA6OYITe0zM8HbGwIC7B3JPad27dr079+fevXqERYWhuY/gy2mTJlS4mvJ5xpJkkoqJjOGjLwMKnlWsncoABhNRsZtHUeeIY+mIU15tvaztzz35JGT1KpvuQGX5VGJkmubNm266cf/lZaWdvcRSZJkeVpf8KkPaQcgL0VsybwTlRtU7w8BreHIWNBfhr19Ibw3imr9qFm9CjWrV+HNV57GbDYTdS6WKpWurrKu27Sb7bsPsn33QQCUSiX160TStkVD2rVqxJNdHhDbSIuGNYCYemrQQdZpwHxlOIMraPxEklDlfmVYg2Os5Ej28dFHH+Hi4sI///xTPLVt0qRJDBs2jI8++oj58+eX6DqBgYF8/PHHgJjKdODAAf7991/Gjh3L4cOHqV279nWDcpo0acKhQ4dKHW9BQQEFBQWl/jpJuq8ZDHDuHDg7g8kkbtaSmQnLl4NaLXqtmc3i8f8jv6CAjfv2oVareaxtWwpuco5NZWVB3bri4/vod8x/E13W8uSTT1rkOrZ6rpEkqXzLyMvgQsYF/Fz8UDhIYcFPx37icOJhXNWujGk/BuUtdhetW7WOUf1H8XSvp/lgygcOE7+tlfodaq1atdi5cye+/xmHfvnyZbp27crBgwctFpwkSRbkHCASbOkHRQ80TQn7s/g0hDY/wMlZcPkPOL8YUnZDg4/AXVSqKRQKqkVcv8Iya+IQnnz0AXb8c5jt/xwk+vwlDh09w6GjZ1jw3Qoyz28pPnf3v0fw8/GiWkQlFFpnkQw0m0WyzaiDnLOif5tSIxJuGh9xjpOb2P7q5BjNPiXb2L59O0uWLMHT8+pocj8/P0aMGEHPnj3LdM0OHToQFxfHQw89xCOPPMLkyZMJDLx+QpOfnx8JCQmlvvbs2bNRq9VlikuSJBt55x3xZ34+/PXXLU8bPGQIAOtjYlgfE2ODwO7AwsPEyoOxY8da/TFKU5lWGtZ8rpEkqfwym82cTz9PviGfAFfHqEa+kHGBz/d9DsCQlkNu2QMuOSGZaSOnAeAb4HvfJtagFD3XfvvtN0D8xQ8YMOCGNwpJSUkEyLJ0SXJsLiFgMkDGYSjIFNVgJaFyh3pjIaAdHJ8E2WdgVy+o8TZUeu6mPdIiq1YksmpFXnvpKQDi4pPZufcw23cfJFenF1VrV7w1dCqHj50hMMCXti0a0LZlQx5o1ZjGDWqiUF0dqICpAAx6MaAh54LoMaN0AY2nqG5Te1zt8Sb7tt3T8vPzbziWlpZW6oEGRebOnUtKSgrjxo1jypQp6PX6G6ojNBqNrECTJEm6T+zfv5/FixcTExPDF198wR9//EFYWBiPP/54ma8pn2skSbqZxNxEYrNiHSaxZjAZGLd1HAXGAlpVaMVTNZ666Xlms5mJQyeSlZFFrfq1eG3Qa7YN1MGU6F1I586duXTpEgB79+6lYcOGuLm5XXeOq6srnW/To0KSJAfhVlEk2DKPih5r6lJMcQnuIPq3HRsvqtdOzoSkHSLx5nz7J4PQkACe7daJZ7t1uu64wWDAx9sDrVZDUnIav/25md/+3AzAyCGvMunDAVdPVmpAowGuJAXNxivTSDNBn4jYSqq9MiTBT2w3VbmLm9xKes/o2rUrkyZNYsKECSgUCnQ6Hf/88w9jx47lscceK9M169WrB4ik3dChQ3n66afR6/XXnVNQUICzc+mrJN99913c3e+vaUnl0QsvvMDvv/+OQqHAbDYD8MeoUTxUty4olaTn5+Pq5obWzQ1cXMDNTWxZ1Giu3tRqcew+XrW1iNRU2LMH/Pyu/M63onnz4OefoWZNWLDgtn93FxMSWL1jB01r16ZZ7drWjet2UlPFwIVmzcS/Q8ni1q9fz4gRI3juuefYsmULBoMBlUrFBx98QGZmJi+88EKZrmvN5xpJksqnQmMh0WnROCmc0Kq0d/4CG1h4YCHHko7hrnHnw3Yf3rIabcUPK9i1eRcarYbxn4xHpb6/32+V6Lt3c3Nj4MCBAMUrNrbqdyBJkhW4VwGzATJPXJno6XrHLynm7A9N5sLFZXB6LqT+Azt7Qp0RENzpzl//HyqVis2rviQ/v4B9h06wffchtu46wF8bdzHr8x8Y/ObzBAb43vyLFU5Xk2cgtpKa8kXCLeccmIzgdGUrqdZPbCctmkiqlNv0yqthw4Yxe/ZsevToQWFhIU899RROTk4888wzDBs2rMTXSUlJ4dChQ3TqdPXfbWRkJIWFhQQEBHDu3Lkbzv/v9p2S0Gg08jnTwZnNZnbs2EFhYSEbZ8ygQKvlz+3b6dClC2qVCoxGps2ezcI//uDx5s15unVrutSvj7v2yotghUIkO1QqkVzz9BQTLl1cxM3ZGbRamXQrqcRE8bNyLcVzU1kkJ8Mvv4iJm2+8IZKjtxFZoQKDy7j13GLy8kS89euDTwnbO0ilNm/ePMaNG8cTTzzB0qVLAejTpw8BAQHMnTu3VMk1Wz3XSJJUPl3OvkxSbhJhHnaeQH3Fvrh9fH3wawBGtB1BkPvNh+FdirnEnPFzAOg/vD9Vq1e96Xn3k1KnFrt3786uXbv4+eefOXfuHAqFgho1avDiiy/SsGFDK4QoSZLFKRTgEXElwXYKXAJL17dMoYDK/wO/5nBkNGSdgkMfQGhXqD30arKrFLRaDW1aNKRNi4YMH/wyLTq/jMlkJiEp9dbJtZvF5eQsbkU95YomkupiIef8lYScK6h9wNnvSnLOQyThpHJBo9HwwQcf8M477xAbG4vRaKRixYq4ubmRlpZW4hX/S5cuMXDgQLZu3UpQkHjhcOzYMXx9fWnSpAnffPMNeXl5xdfbv38/TZo0sdr3JdlPdHQ0iYmJaFQqWjdvjrObG11at756gpMTe0+dIlunY+mWLSzdsgVnrZZHWrbk6Q4d6Nq2LT6uriLpUVAAcXFQ1I9LpRLVVy4uIuHm6Xl90k0mXq+XmQnx8eBbwt/7d+Pbb0WPtfr1oVUr6z/e3TKbReKxalUIvXnvG8kyYmJibvq+pn79+iQmJpbqWvK5RpKkW9EV6ohOi8ZD44GT0sne4ZCRl8HozaMxY+bJ6k/ySMQjNz3PbDYzfsh49Do9jVs15oU3ylbNe68pdVOiX375hb59++Li4sL//vc/nn76aQB69+7N+vXrLR6gJElWolCCR3XwiBRbKk1l6O/hHg4tv4WqrwIKiPsTdr4AaXc32EShUPDXL5/y78bvqF+n2l1dC6VabA91CRFbYp0DxfeeFw+pByB5JyRtg9R9IvmWlyIGKUgOq1atWsVJtGrVqlGzZk3c3Ny4fPkyHTt2LPF16tWrR506dRg5ciRRUVFs3bqVGTNm0K9fP5o3b05ISAgjRozg7NmzLFiwgCNHjvDMM89Y8TuT7MXf359Fs2Yx7n//w/kW2+y2ffUV/yxaxLDevYmoUIG8/HxWbd1K77FjafTSS5iVSlGd5u0NwcFQsaK4BQSIJFpeHly8CIcOwe7dsH07bNsGu3bBiRPivuRkyMkBo9Gm379DiYsTPytrV62dOQMrVoiP+/W7Y1XhwGnT+GrFCrJzc60b1+2kpop/X9WqiZ6jktVERkayffv2G46vWLGCyMjIUl1LPtdIknQrF9IvkJmfibezt71DEQmzreNJ1iVTxbsK77d+/5bnKhQKXuz7IhWqVGDs7LEo5XMSAApzUWOREurQoQMDBgwoTqoVWbZsGV9//TXr1q2zaIDWkpOTQ5MmTdi/f7/shSPd30wGyDwmtlG6hJW9N1n6ITgyRgwbQAFVX4HIvo6//dJkENtIjTow5gNXtslqA8Czeum2zEpWc+1gnb1799KoUaObDtYxmUylWuhJTExk4sSJ7N69GxcXF1566SXefPNNFAoFMTExjBo1isOHD1O5cmVGjhxJ62urme5APs+UMwcOiIqp4ODbn2c2Y05J4ei2bfy6aRO/nThBe5WKeXo9KBQYO3fmmUuX6NixIz06dCD0VsOeCgrELS9PVE+ZTCLBo9GIJJ2Hh0ikFPV4c3G597eW6nSwc6eo9rtmGrDF5eZCr14iodmuHcyefduf6/nLl6narRtOTk4krV+Pr1cJhwFZUl4epKRA06YQ5hhbh+5l+/bto1+/frRu3ZpNmzbRrVs3YmJiOHbsGPPnz6dVKSsdrfVcI59nJKn8StOn8c+lf3BXu+OmsX//zJ+O/cSs3bPQOGlY1G0R1f2q3/FrivpROprYzFjqBdUjwjfCpo9b6p9ERkYGDRo0uOF406ZNrTa2WpIkK1KqwLO26E+WGwOuZUyw+TSENj/CiZmigu3ct5C6B5p9XqZtokUys3L49Y+NvPrCk9YZ7axUgdJD9GKDq0MScs9DYSZ41RLVbpJdWWuwTlBQEPPmzbvpfZUrV+b7778vW8BS+VJQAOnpN1ZL5eRAdDRERYk/r3ysyMykPlAfGA9cW/e74/ffWQmsPHCAt2fMoHWdOjzz8MM83bEjla5N3BUNQbj2DbHZLBJt+fmiiu3yZXHcyUkk1lxdRcLNw+Nqws3FRSSj7gUJCZCdDZUqWe8xzGaYPFkk1oKCYOzYOyYsf9+2DYB2DRvaJ7FmNkNSktwOakNNmzZl7dq1/Pjjj4B4/9OwYUOmT59OaBn+DuRzjSRJ1zKZTZxPP0+hqdAhEmunUk4xd89cAAa3GHzLxFphQSGZGZn4B/oDOGRizZ5K/dN48cUXmTZtGtOnT8fnSiNVvV7PF198UebJOZIk2ZmTBrzrgLlQVJ65VhBbJ0tL5Q71x0FgOzg+WQxMODIGGs0s0/UKCgqp2fJpEhJTqVIxlA4PNCt9TKVVNCTByQ3yEiFtH3jUALcq4AC9EO5XNxusAxQPCoiLiyvTGx5JSktLY/Hnn9NOq6WpwQCnT19NpiUk3PyLFAqx5TMiAiIj0Vz5k7Q0avz8M7O2bGG50chuYNfx4+w6fpx358yhWe3aTB80iAebNr31dZ2dxe3aJI7BIBJuOp1IAhZtG9VoxLlFVW6urldvWseYOFZiBQWiT52np3Wr81auhHXrRMJy0iTxc7uDVVu3AvDkAw9YL67buXY76L1cuehA/vjjDzp16sTgwYPtHYokSfeghJwELmVdItDN/gv4ukIdIzeOpNBUSPvK7Xmu9nO3PHfhxwtZvng5o2eN5sEuD9ouyHKi1Mm1/fv3c+TIER588EEqVaqEWq0mJiaG3NxcQkND+euvv4rP3bhxo0WDlSTJipycwbu+qGDTxYkKtrK+iA/uCC7BsOcN0c8s+muIfKPUl9Fo1PR4vAOff/MLc7740TbJtSIKhfgeCrMg4ygUZIFXDblN1AE0a9aMF154gRYtWvD++6IfxNNPP02lSpX45JNPCL7Ttj5JusaOHTt4d/Roavn4cCI9/cYTAgNFEq0ogRYRAeHhIqn1X1WqENy4Me/m5PDuX39xeflyfouK4ldgG/DviRO4/vUXVKgAwcGcvXgRg9FIrfDw2wdZNIn02mrNa6vcUlJErzKT6erEUhcXMRTA3f1qws3Z2XF7dSUmQkaG+NlYy9mzMHOm+Pitt6AEg7jSs7LYdlD0Ee3Wvr31YruVom3D9epZvw+dVGzmzJmMHj2aBx54gK5du9K+fXu05S1hLUmSQyowFhCdFo3GSYPGAQaqTd85nYtZFwlyC2L0A6NvuVPo2IFjfPvpt5hMJgyFBhtHWT6UOrn27LPP8uyzz1ojFkmS7E3lCj71Ie2AqGBzCS17gs2rDtQeAcfGQ9SX4FlTVLSV0uA3e/L5N7/w57rtnImKoXpk5bLFU1ZqT5F41F0AQxZ41QbnW/RQkmxi3LhxhIWF0adPn+Jja9asYezYsYwfP5758+fbMTqpvNmxYwcAbYreODdtCh07ikRa1arXV5CVlLs7PPMMYc88w9unT/P2qlUkrl7Nmtxcmq1cCatWQcuWTCss5Ot9+6hdtSpPd+jAMx07Ui8ysmRb4K+tcruWwSASMrm5kJZ2tZdb0bne3uJ7cnERyRpH2FZqNIqqNRcX6yX/cnNh+HCRqGrdGnr3LtGXrdm5E6PRSN2ICKpaM/F3M0XTQSMjISTEto99n9u6dSsHDx5k/fr1TJs2jQ8++IAOHTrw2GOP0a5duxt6fkqSJJXUpcxLJOuSqeBh4+eUm1gbtZY/z/6JUqFk4kMTbzlYIU+fx5jBYzCZTHTp3oVOT3SybaDlRKlfTXXv3r3448zMTNzd3VEqldbphSRJku2pPcCngUiw5SWK6q2yqvAEZJ2Ai7/AkQ+h5WJwr1KqS1SPrEzXR9rx57rtfPLlUj6bMbzs8ZSVUiO2yuYlXbNNtLLcJmon+/fvZ9WqVfj5+RUf8/HxYciQITcM25GkO9lxpZ9W25wcceD110WCrbQMBrGN1M1NJLCKXhfVqAHDhhE0aBCvbtkitiXu2we7d1MAqIET585x4tw5Ji5cSLVKlXimY0ee7diRhjVqlP71lUolknvX9nIzmURSKS8PLl2C8+fF8Wu3lfr4iNiLqtxsmTxIThZbH61VdWo2w5Qpos9aYCBMmFDiJJ5dt4SmpIjqw8hIuR3UDho1akSjRo0YPnw4x48fZ926dbz//vuoVCr27Nlj7/AkSSqHcgpyiE6PxkvrhZOd30fEZsYyZYfomf9ao9doHNL4lufOmzKPi+cuEhAcwLCPhtkqxHKn1MuDZrOZ+fPn06JFC1q1akVcXBzvv/8+Y8aMoaCg4M4XkCTJ8Wm8RYJNqYG8lLu7Vs33wKcRGHLh4FAw5JT6EkP6iX6Oi5b+QVp65t3FU1YKpUg0OjlDxmHIPAoGvX1iuc/5+Phw4sSJG46fO3dOTkuTSkWv17PvwAHgSnLNyQnq1Cn9hYxGsS0zOFgkQWJjQf+f3w/OztClC3zxBaxYAa++ynf+/iQBS4BugFah4OzFi0z59lt6jhx5t9/eVUqlqArz8RExVqwotl8W9RtLSYHjx2HPHtixA7Ztg3/+gTNnxFCF9HSRnLMGo1H8vJycrFdBt2oV/PWXeIzJk0vUZ61IXn4+SqXS9ltC8/JEH7oaNeR2UDvS6XSsWbOGr776ih9//JGgoCB69epl77AkSSqnzqefJ7sg+5YVYrZSaCxk1KZR6Ap1NApuxGuNXrvluXu372Xp10sBGD1zNJ7eVpzmXc6V+lXMZ599xurVq5k6dSpDhgwBRDXbmDFjmD59Oh9++KHFg5QkyQ60fmJSZuo+MUFTUcbVFaUKGk6FXb0g9wIcGQeNppdqwMFD7ZpSv041jhw/y1ffrWD44FfKFoslqD1BqYXsc1CYDZ61wNnffvHch3r16sXo0aOJjo6mzpVEyKlTp1i0aNF1W0Ul6U727dtHYWEhQa6uVNXpoGZNkYQqDZPpamKtfn3x+blzYptjRgYEBNyYNKpYEQYMgDffxHvXLl5auZKXdu4k22hkNbBcqaShiwuKw4ehQQPyCgpo8cordG7Rgmc6dqR5nToo73b7pEIhhh78t49UYaFI7GRkiC2J1/Zxc3O7eR+3m/1MDAZxrcLC6z8uLBSJOr1e3AoKICtLVJRZQ1QUzJghPi5hn7Vr/T5nDqkZGfh42vDNRNF00MhI61XzSbe1YsUK1q9fz65du/D39+exxx7j+++/p2bNmvYOTZKkcipFl8LFzIsEuNq/vcxn/37GiZQTeGo9mfjQRFTKm6eFcrJyGP/ueAB6vNSD1g+1tmWY5U6pk2srVqxg6tSpNGvWrHirQps2bZg2bRqDBw+WyTVJupdoA0UyqTBbVLOV+Tp+IqG25w1I2gLnvoGI10v85QqFgiH9XuD1dz4iPjG17HFYipMW3CpenSbqWRPcKpVtwqpUaq+++iouLi4sW7aMhQsXolKpqFy5MiNGjKBbt272Dk8qR4r6rbX19ESh00GjRqW7gNksEmv+/iKxVpSYq1sXgoLExNG4ODEB82bVUioVPPCAuKWk4PHnn/T8/Xd6Xrwoppa+/jpUqcKGunU5cvYsR86eZdb331MhKKi4R1vr+vXvPtF2LbVa3Dw8rh4r6uOWnS22cJpMogrM2Vkk2Hx9xXl5eVcb8BsMoirNYBC3azk5Xa1UU6lEAtIazeJ1ujL1Wfsvv1JUullEcrLcDmpnc+bMoUuXLnz33Xc0aNDA3uFIklTOGU1GzqWfw2Q24aq2bzXyztidfH/0ewDGPDCGYPdbL+I4qZxo16kd/2z7h3fGvGOjCMuvUifXUlNTCbzJ6qKnpyc6nc4iQUmS5CCcNOBaETKP3V1yDcC7LtQZDsc+grNfgkdNCGxb4i9//ulH6PBAMypVcJBVfIUSXEKgIBPSD0FhhkiyOd2kikOyuJ49e9KzZ097hyGVc7uLkmtFbS1KWdVEfLxImtWvf/0kT4VCVGL5+IgeZ1FRV/t93azSC0SC7pVX4OWX4dAhsZXx77/hwgU6XrjAb0oly/39+T0zk0uJiXzy00988tNPhPj7882YMXRpbcXV5Jv1cTMYRNJKpxODE4rOU6lE4kyjuf5zWyeJivqsxcSIn/v48aUalmA2m0nJyCDAx8eKQd6EXi+q+6pXL30VpWQxW7duRaFQoNfrOXXqFCaTiUqVKsnWA5IklUlCTgJx2XEEu9n3fUyKLoVxW8YB8GztZ3mwyoO3Pd/F1YUPpnxAbk4urm6yRcGdlHqps2XLlnz99dfXHcvJyWH27Nm0aNHCYoFJkuQgnANEpZYx7+6vVeEpqPgMYBYDDnIvlvhLtVqN4yTWrqXxAudAyD4vttDmO0Bl3X1g//79DBo0iG7duhEfH8+CBQtYvXq1vcOSypml8+axZcQInilKDpWmQiUhQVRt1a8vKtNuRq2G8HBo2VL8mZoqvs5ovPV1FQpRQTdunOgTNmoUrnXr0t1k4oekJJLz81nl6UmviAg8XV2JT0mhSmho8ZfvP3mSzfv2YbzdY1iCSiUSin5+EBYmbkFB4nNvb5GIc3YW59mj+ur332HtWpHYmzRJJDpL4cCpUwQ/8giPDhqE2Wy2UpD/YTKJ7aDh4XI7qJ0ZDAYmT55Ms2bNeOqpp+jRowctW7ZkxIgRsse0JEmlkm/IJyotCheVC2on+00aNplNjNkyhvS8dKr5VuOdFu/c8tysjCwM11Sdu7m73fJc6apSJ9fGjRvHiRMnaNOmDfn5+fTv358HHniAy5cvyy2hknQvUnuBNgAKMixzvVrvgXd9Mdjg4FAx6KCUzkTFcPrsBcvEYwlOWnCrAAXpIsGWGwNmk72jumetX7+evn37EhYWxvnz5zEYDKhUKj744AN+/PFHe4cnlSOuhYW0VyioAFC5cskTMCkpInFWv37JvsbDQyTuWrQALy9RzZZZguEs7u7QvTssWgRLl8ILL+Ds7c2TWVl8Fx1Nkk7HxmrVqHnsmNiOCUxbvJgO/foR+uij9Js8mY179173Avm+EBUF06eLj/v1K/12X8SUUJPJhKtWW/qJrWWVkiKSk3I7qN1NmzaNzZs3M3/+fPbt28fevXv57LPP2LdvH3PmzLF3eJIklSOxmbGk6lPxdfG1axzfHf6OvZf34qxyZnKHyWhVN2/HYDAYGPraUAb0HEBK0l0OtrvPlHpbaHBwMMuXL2f37t2cO3cOg8FAeHg4bdu2tWzPD0mSHINCAS5hoLssEkZ321dMqYaG02F3L8g5B0fHic9L+Ebi0wVLGTRiJk8/0YHli6bfXSyWpFCCa6hIQqYfFgMgXCvYO6p70rx58xg3bhxPPPEES5eK6UV9+vQhICCAuXPn8sILL9g5QqlcKGoaf/as+LykCZi0NFFh1KiR6BVWUgqFqOzy8RHTMaOjxZ+BgSXrNxYZCe++C2+/DVu3wu+/o929mw5nz4oqtxkz4JFHCFEo8PXyIiktjS9/+40vf/sNf29vuj/0EM927Ejnli1LHnN5pNPBBx+ILautWolttmWwautWANtNCdXrxVbbGjXkdlAH8Oeff/LJJ59ctyunffv2aLVahg4dyvDhw+0YnSRJ5UW6Pp3o9Gh8nH1Q2rE389HEo8zfNx+Aoa2GEu4TfstzP5/2OQf+OYCrmys5WTn4B8rBbSVVppnnP/zwA15eXrz44osADBgwgMuXL/P8889bNDhJkhyE1h/UHlCYdfe910BM1ywacJC4Gc4tgohXS/SlD7VrCsCK1Vs4H3OZ8Mphdx+PJWm8wZQPubHgEiqHHFhBTEwMDW/SG6t+/fokJibaPiCpXBr/4YekHT/OG8ePUxdK1m8tM1MkbRo2LPu2PY0GIiJEYq4owaZWi55rJVmkVKuhUydxS0iAP/+EP/6Ay5fht9/4BJgZHs7mDh34Ra9nxe7dpGRk8NWKFRw4deq65JrJZLq3FkbNZpg6FS5cED/fCRNK1WetyIW4OI6cPYtSqeSxtiXvDVpmRdtBa9QQCVjJ7sxmM35+fjcc9/X1JTe39BX3kiTdfwwmA2dSz5BvzMff1X4Jquz8bEZtGoXRbKRz1c50q3Hr4V+b127mu8+/A2DM7DFUiaxioyjvDaV+xTFnzhzmz5+Pq+vVhnYtWrTg888/57PPPrNocJIkOQgnjajCKsyy3DW960HtKyu/Zz+H5J0l+rK6tSLp/GALTCYTn371s+XisSSND+QnQ36avSO5J0VGRrJ9+/Ybjq9YsYLIyEg7RCSVR4u//565q1YRd+6cOHCn5FpOjrjVrQsVLFCV6ukptoo2aya2f8bGimmcpREcLCaKrlgBX3wBjz4KWi3q8+d5eMUKvtqwgYQGDdjQrx9vdu/O69dM083MyaHCY4/RZ/x41uzYQUFh4d1/T/b2xx+wZo1IqJWhz1qR37dtA6Btw4b422JSaHKy2A4aESG3gzqIli1bMnPmTHJycoqPZWVlyR7TkiSVWExGDHHZcQS52W/RxGw2M3nHZOJy4gjzCGNUu1G3bHVw8dxFxg0ZB8CLfV+kU9dONozUcvIN+Zgw2aW/Xakr13799Vc+/vhjmjZtWnysd+/e1KhRg/fff58BAwZYNEBJkhyEcxBkR4nBBpaaiFmxO2SegEsr4PCH0Oo7cKt4xy8b8tYLbNiyh4VLVjFuWF88PR1sepdSA5hBf1lU6UkWNWLECPr168c///xDYWEhX3zxBTExMRw7doz58+fbOzypHIiLi+P8xYsoFQpamkyiaizsNlWwOh1kZECdOqI3m6UolRASAr6+YprouXOiOi4goGRbRa+9TtOm4jZ8OKxfLxr6HzuGats2Om3bRic/P5HEO38ewsNZs2MH8SkpfPvHH3z7xx94ubvTrX17nu3Uic4tWqDVaCz3fdpCVBRMmyY+7tcPGjcu86WKt4Q+8IAlIrs9nU4MuKhZ89aTZCWbGzlyJL1796Zdu3aEh4vtU+fPn6dChQp88cUXdo5OkiRHl65PJyotCm9nb1TKMm0WtIhVp1ex4dwGnBROTOowCXfNzd8z5enzGNZ3GLnZuTRs3pC3R75t40gto9BYSEJuApG+kYR52H53U6kr1/R6/U3HUPv4+JBd2hVXSZLKD0sPNihS+/0rAw6yrww40N3xSx7p0Iqa1aqQnZPLNz/+btl4LEXjDfoEKJS/Fy3h2m04TZs25a+//iIiIoIOHTqQkZFBw4YNWbNmDa1atbJjlFJ5sfNK5WMDHx88QVSt3apiKC9PNJqvUQOqVrVOZZFWC9WqiamilSqJx0tMvP1U0Vtxd4cePcQQhJ9/hpdeEhVcqamwZAk8+yz06cNzOh1bPv6YAc8+S7CfH5k5OXy3ejVPDBlC0MMPs273bot/m1aj18OIEWLLbsuW8MorZb5UelYWWw8cAOBJa/dbM5lE1VrVqqL3nuQwgoKC+PPPP5k1axaPPvooTz31FHPnzmXVqlWE3S4RL0nSfc9gMnA69TT5xnw8tbeYJm4D59LPMWPXDADeavoWdQPr3vLcWWNnEXUyCr8AP6bMn4JKbb+EYFkZTAbicuKo7FWZWv61cFI62TyGUifX2rVrx6RJk4iLiys+lpiYyLRp02hri74UkiTZh0IBrmFgLLDsJEylBhpOA60f5ETD0fGib87tvkSp5J1+osfj3AU/YyzLG1BrU7mLSah62QPMEh566CHi4+MBUbnm7OzM4MGDmTt3Lp999hlDhw4lNDTUzlFK5cWOLVsAaKO+smXgVltCCwpEL6zISJH8snZ/Mi8vsVW0eXOxbfTyZVExV1YREfDOO7B2LcycCe3agZMTHDmC0+TJtP/gA+bpdFz66CO2LVjA2//7H6EBAWTm5FCnatXiy2zZt49VW7aQl59/19+iVUybJiry7qLPWhGNWs1Xo0Yx4Nlniax450rqu5KUJGKW20Ed0rJly9DpdLzxxhv07t2bpUuX8vPPDtqOQpIkh+EI20FzCnIY9vcw8o35tAhrQe8GvW97fs/XelK1elUmfT6JgOBSDGtyECazificeEI9QqkTWMcuW0KhDMm1MWPGUFhYSMeOHWnZsiUtW7bkwQcfxGg0MnbsWGvEKEmSo9D6g8bTsr3XAJwDrkwMVUHiRji/+I5f0uu5x/H18SIzK4fTZ2MsG4+laDxBHysSktJdMZlM7Ny5k8uXL7Ny5UpiYmKIi4u76U2S7mTHTtHjsW1R4upmyTWDAeLiIDwcatUSSSlbUCpFL7XmzUWizWQSW0bz8sp+TZUKHnwQ5syB1ath0CCoUkVcc/VqnN56i3bjxjHXxYXYTz7h4A8/UOGaxvpTFi3iqaFDCejcmRdGjWLF5s3o7yYeS/rjDzHUoajPmq/vXV3OzcWFV598knnWngZZ9G+vRg25HdQByR7TkiSVRbo+nbNpZ/Fx9rHbdlCjycjIjSO5kHGBQLdAJjw44Y6TSiNqRPDT3z/RtHXT257niMxmM3HZcfi7+FMvsB7OKvs9pyrM5juUiNzC6dOnOX/+PCqViipVqpS7JtI5OTk0adKE/fv333SbqyRJt5B1GjJPlqg3Wqld/BVOTAEU0GQuBNx+i9/e/ceoWysSV1cHfWNiNoHuMvg1E1V/Upl9+umnfPbZZzdtwmo2m1EoFMV/njx50g4R3kg+zzim7OxsvL29MZlMxAIV3Nxg40aRgCpSlFirVAnq1RMTPu0lO1tUZV28KD4PCLg+1rIym+HoUdGbbcMGuHYCYtWq8Mgj8MgjmMPC+ODTT/lp3Tpir5nG6+biQte2ben5yCM89eCDdx9PWeI/cEAkCvPz4a234LXXbB9HWWRkiK2s9epZtoefZDFt27a9occ0wJ49e3j//ffZdmXohb3J5xlJchwGk4F9cftIyk2yS7+vInP+mcMPR39A66Rl4RMLqRVQ66bnZaRlEBMdQ4NmDWwcoWXFZcfhofGgcWhju27DhTIMNACIjo4mNDSUGjVqsH37dn744Qdq167Ns88+a+n4JElyNM6Blh9sUKRiD8g6CZdWwpFRYsCB662n8jVvcuveAQ5BoQSlGnSx4BIiPpfK5O233+bll18mOzubjh078ssvv+B7lxUq0v0p5tw5Qv38cMrLo0J2tkhwXJusMplEYi0kRAwwsHdjfw8PEWNwMERHi9jc3UUftbvZSqhQQP364jZ0KOzYAX/9BTt3isEK8+fD/Pko6tZl2iOPMOXbb9mbmMjyjRv55e+/uZiQwM8bNpCckXFdci2/oMC6wxDy8kQycNkyKEqkt2gBr75615f+9/hxdhw6xFMPPki4tfpqpaWJ7cYNGoC1t51KZSZ7TEuSVFpF20HtmVj748wf/HD0BwDGtR93y8SayWRizKAx7Nm2hw9nfMgT/3vClmFaTFJuEi4qF+oH17d7Yg3KkFz7+eefmTBhAt9++y3u7u689dZbtGzZkg0bNhAXF8fgwYOtEackSY5C7S22h+angEuwZa+tUEDtYSJ5l3kMjoyFFgvv+AbSbDZz5PhZGtStbtl4LEHrC3nJUJAu+spJZebp6YmnpycbN24kNDT0lqPEJel26lauTOy335I+YwZs3Xr9llCzWSSvAgNF0slRtuspFCImX1/Rhy0qSlSy+fuDm9vdX9/ZGTp1ErfsbNi0Cdatg3374NgxOHYM5Zw5tGzalJYPP8yMH37g39hYlm/cSOOaNYsvk5CSQrUePejSqhXPdOzI423b4n7Ntrq7cvkyLF8uKu0yM8UxjUZU2L3zjkX64S3+808+++UXTl64wIJRo+76ejdISRHJ24YNbz+dVrK7oh7T06ZNK+7nKXtMS5J0K46wHfRQwiEmb58MwBuN36BzROdbnvv1J1+za/MutM5aatarecvzHFmqLhWlQkn94Pr4ujjGgnup/+YXLlzItGnTaN68ORMnTqRWrVosXLiQf//9lyFDhsjkmiTd6xQKUU2mixPbHi1djaXUQMOpsONZyDgMcashrOstT8/KyqFVlz6ciY7h/IHfqRBmv+ahN6XUXNkeGieTaxbi4eHBJ598wtGjRzEYDPy3u8F3331np8ikciE7G/Lz8TlxQnx+bXItJQW8vUVizVJJIUtSqcQ2woAAsVX0wgWxxTAwENQWat7r4QHduolbSgr8/bdItB09Cnv3wt69KKZNo3nr1jR/5BF44IHiL127axc5Oh3LN25k+caNOGu1PNq6Nc927EjXdu3wKG0i0GSCPXtEldqOHVeH3QQHwzPPwFNPib8vCzCbzfx+ZatfN2tMCU1OFn82aABy+IrDGzNmDP3796djx454eXkBkJmZScuWLWWPaUmSrlM0HbTAWECAq32GASTkJDDs72EUmgrpEN6BNxq/cctzd2/ZzYJZCwAYMXUE1WpXs1WYFpOZl0mhqZCGwQ0JdHOcadulTq4lJibSpEkTADZv3sz//vc/AIKDg8m9tl+HJEn3Lq0/qD2hMBs0Xpa/vkswRLwGZ+bB6U8h8EFQ37yXiKenOwH+3pw4fY55C5cxdezblo/nbmm9QR8H7uG3/D6kkhs2bBhHjx7liSeekD1mpFIxmUyQnIwyPV0kO5ycoO4128v1eqhZUySYHJmrq9iyGhwstnBevgwuLqKyzZITTf39oWdPcbt0CdavF4m26GhR9bd1q3jctm2hdm1eCQ+nwccfs/zQIX7ZuJGo2FhWbN7Mis2b0Wo0/DlnDp1atLjz42Zni0EFv/wCsbFXj7doAc89Jx7PwgMmDp4+TWxiIq7OznRoauGGzklJ4u+lQQPxdyY5PF9fX5YuXVrue0xLkmR99t4Oqi/U8+66d0nTp1Hdtzrj24+/5QCDhMsJfDjgQ8xmMz1e6kHXZ29dwOCocgpyyCnMoUFQA8I8HasKvNTJtapVq/LHH3/g6+tLXFwcnTp1orCwkG+++YaaNctnSaEkSaXkpBUN+rNOWSe5BlDlRbj8B+TGQNSXUOu9W546pN8LbN15gAXfrWD00Ndxc3OxTkxlpXKH/FTIS5TJNQvYtWsX33//PfXr17d3KFI5c/Dff3m4c2ceq1SJJSCmgBZt/TQYRALE0RNr1/LzE5VbISFiq2hsrEiwWeN7qFAB+vQRt6gokWRbt05so92wATZsQAE0Bhq7uTGpalWOVKvGLzodv5w7x7nU1Ou2kK7asoXMnByebN8e76J4z54VVWpr116djurmBk88ISrVqlSx/Pd1xe9btwLwSKtWuFhyO3BCgti+2qCBqDCUyg2j0Uh8fDwJCQn06NGD8+fPk52djUd5+h0hSZJV2Xs7qMlsYuzWsZxJO4Oviy+zHp6Fi/rm74MK8gsY/uZwMjMyqVW/Fu+Nv/V7K0elL9STnpdOnYA6VPKqZO9wblDqfwHDhw/nnXfeITMzkxdeeIGIiAgmTJjAhg0b+OKLL6wRoyRJjsg5EHKiwZgvkm2WplRDrfdh30C4uAwqdAOPm68Yd32kHRHhFYg+f4nFS/+k/2sOOFxF5SEGG7hVEt+bVGZBQUEoLVmdI903dmzaRFp2NqkpKeLAtVtC9XqRyClvb5ydnETiy98fYmLEVtHMTLF1VGuF380AkZHi1r+/2C66Z4+ooIuOFjHk5qI4epQGQANgIhAD+D7zDEREQEQE03bsYPfly6hVKjpHRPCMXk+3ixcp7poSESGq1B591CZbdFddSa5ZdEtofLxI3jZoIP4+pHIjPj6ePn36kJmZSWZmJh07dmThwoUcPHiQr7/+mho1atg7REmS7KzQWGj37aBfHfiKTec3oVKqmN5pOiEeIbc8d81vazh+8Die3p5MWzANrbOVXiNYSb4hn2RdMjX8ahDhG+GQvZcV5v82qykBk8lEdnZ2cQ+ClJQUvLy8UFuq34cNyNHVknSXzGZI3QMFaeBsxT5nB4dB4ibwaQTNF9xyuMGnC5YyaMRMqkVU4tQ/yx0v+WI2ir5rfs3BVfbbuRsbNmzgyy+/ZNCgQVSuXPmG555QB+lnJJ9nHM9zjz/OL2vWMMnHh5Hp6TBzJhRNukxMFJVFlt4SaGuZmSLRFRsrEm8BARbfQnlbBQVi2EJ09PW3y5eLe6aZEQm3n4ET13ypCujo58eLTz5Jr/79724aainExMdT5YknUCqVJK5fj//d9nEzm0XFmouLSOD6yX6b5c1bb72Fv78/48aNo2nTpvz+++8EBwczatQo4uPjWbJkib1DBOTzjCTZU1RqFEeSjhDmEWaXqrUN0RsYsWkEAGPbj+WJ6ref+Gk2m/lp4U9UqlqJth3L12CWQmMhcTlxRPhEUDewLk5KG76uKYVS/yv4999/b3t/s2bNyhyMJEnlSNFgA328eCNhrTdBNd+FlF2QfhDi/4LQR2962qsvPMnoKV9wNvoiazbspOsj7awTT1kpnETFmi4WXEJs9qbxXvT226KvXt++fa9btTKbzSgUCk6ePGmv0CQHZjab2bF3LwBt0tPFwQYNrp6Qny+qv8o7Ly+R0CnaKnrpkjjm5WWb3zsazdXKtmvl5YkhDNHRKKKjGXPldiIxkV9dXFju4sKRtDTWpabicv48va6JNTUjAz8LDS64mcNnzqDVaGhep45lEmtxceDpKQZj+DrGBDOpdPbt28eyZctwuiYxrVar6d+/P927d7djZJIkOYI0fRpR6VF22w56KuUU47aOA+DFei/eMbEGoFAoeOGNF6wcmeUZTAbicuKo7FWZ2gG1HTaxBmVIrvXq1eumxzUaDQEBAWzcuPGug5IkqZzQ+ovtjoVZ1uu95hIMVfvA2c/h9McQ2E70MPsPd3dX3ujdnZnzlrBq7VbHS64BaHwgP1lU+8nJoWUmn2eksrhw+jTxKSmonZxoZjSK/l0+PuJOo7H89Vu7HYVCNM738xPJtehoUcnm72+/KajOzqLHXa1a1x2urdNRW6tltJMTZ2Ji+HXTJhpds+UuKjaWGk8/zQONGvFMx4706NCBEAsnQZ9s356Uv/8mITX17i5kNosKPW9vkbi1YkJQsi5nZ2dSU1MJDw+/7vj58+dlhZgk3ecKjYWcST1jt+2gKboU3lv/HvnGfFpXaM2g5oNueW5Odg4LZi2g73t9cfcof7+7TGYT8TnxhHqEUiewDmonx94pWerk2qlTp6773Gg0cvHiRSZOnMgTT9w5YypJ0j3EyRlcQiH7jPWSawDhL8HlP0F3EaK+gppDbnraO28+zyMPtaRj++bWi+VuOGnBZBTVfjK5VmZhYY41GUgqH3Zs2gRAEx8fXFNSbt5v7V5706xWQ3i42O567pzYrpmRIT5X2X6l/aauSfZVr1yZEa++et3d2w4cwGQysWX/frbs38/bM2bQtmFDkWh76CEqBFmmLYG7qyuRd5N4NJlExZq3t/i35WXF50TJ6nr27MmYMWMYNmwYIJJqe/fuZc6cOTz7rAP2dZUkyWbsOR0035DP+xveJzE3kSreVZjccfItK7nMZjMT3p3ApjWbiDoVxedLP7dxtHfHbDYTlx2Hv4s/9QLr4ayy4LAhK7nrV1ZOTk6Eh4fzwQcf0LdvX1kqLUn3G5dgyD1nvcEGAEoN1BoK+wdBzFIIexI8Im44LSw0kLBQB5/GpvEWvdfcw0HlZu9oyo1evXqVuHHpd999Z+VopPJo544dALQpOnBtci0317oDAOzNzQ3q1RNbRaOjRaN9FxexZdHR+lP+R59u3ejQrBm/btrE8o0b+efoUbYfPMj2gwcZPHMmf3/+OR2bl31BpaCwEM3d9gw2mUTFmr+/qFi7Vyog72MDBgzA09OTcePGodfr6du3L35+frzyyiu89tpr9g5PkiQ7sed2ULPZzKTtkziadBRPrSezH56Nu+bWi4KLP1/MpjWbUKlV9B/W34aRWkZ8TjxeWi/qB9fHTVM+3jNZ7F9EamoqWVlZlrqcJEnlhcYbNH5QmA5OVhxsENAaAh+EpC1wcjo0++K2/YPy8vIxGIy4u9tpC9StqNygIBXykkSCTSqRFi1a2DsEqZyrGxLCA7Vr81BRBf61ybV7pd/anfj7i62w8fGiH1tsrEiwOXgyqEpoKO+99BLvvfQSsQkJ/LZ5M7/8/TeHz56lVf36xed9vXIlKRkZPN2xI5EVK5bo2i+PHcvJCxeYOXgwncrye8ZoFBVrgYGix9q9Vv14H+vVqxe9evVCp9NhNBrxuPL/SWFhoeMNTZIkyersvR10yZElrIlag5PCiSkdp1DJq9Itz121dBXzJs8D4N1x71K3cV1bhXnXzGYzCTkJuKpdqR9cH0+tp71DKrFSJ9dGjBhxw7Hc3Fx27dpFly5dLBKUJEnliEIpBhukJVh3sAFcGW6wG9L2Q8J6CHnkpqfN++pnxkz9kuGDejN88CvWi6csFArRMy73ovi5KR27d4CjGDhwoL1DkMozvZ6BjzzCwCpVYNAgkWQq2l58r/VbuxMnJ6hQQfwMYmLgwgUxYbScVO5VDA5m8PPPM/j558nMycHV+eo2kTk//sjxc+f4YN48GlSvzjMdOvB0x47UCr/5QkZBYSFrdu4kKzcXNxeX0gdjMIiKtZAQkVhzKx8r69Kt5ebmsmfPHpycnGjatClubm64XrNdeMuWLUyZMoV169bZMUpJkuzBnttBt8ds59O9nwLwbqt3aRF268Wgjas3Mun9SQC89OZLPPty+dnKbjabicuJw13jToOgBvi6lK+hQBZZdvH29mb48OGMGzfOEpeTJKm8KRpsYMi27uO4hkLVK/14Tn0Mhtybnubm6kJ6RhZfLVmJyWSybkxlofGGgnTIT7F3JJJ0f8jOBp0OTpwQnzdseHUhQK8Xfb/ul+RaEWdnqFEDWraESpUgNVUMP9Dp7B1ZiXldUyVmMpl4+3//o3OLFjg5OXH4zBlGf/EFtZ99ljrPPcfMJUtu+Pqt+/eTlZtLkJ8fLeqWcFXfaBTJyEuXRAVgaKjYCioTa+Xevn376NChA/379+fNN9/kkUce4cyZMwDExcXx5ptv0q9fPwICbF+xIkmSfRVtB/V19rX5dtDotGg+3PwhZsx0r9md52o/d8tz92zbw4cDP8RkMtHt+W4MHj24xG1V7M1kNnE5+zJeWi8ahzTGz7X89acu9b+MKVOmWCMOSZLKM5XLlcEGZ0Ft5dLd8F4Q9yfoLkH0Qqgx+IZTnnuqM++MmkX0+Uts2bGfDg80s25MpaVwAqVKfA/Owdat9pMkiTOHDhGQk4PPkSPiwH/7rfn7l4uqLavw8hI/j4oVryaMUlLEcU/PcvP7SalU8ubTT/Pm00+TmpHBqq1b+XXTJjbs2cOJc+c4GhVVfK7ZbObwmTOs2roVgCfatbv9Nr+CAsjJEf9WFAqx9bNqVfHvxs8PNBprf3uSDUyfPp26desyefJk1Go106dPZ9KkSfTv358BAwbg6urKzJkz6dq1q71DlSTJhuy5HTQjL4N3179LbmEujUMaM6z1sNsmy/yD/PH29aZ+k/qMnDay3CTWjCYjl7MvE+AaUO62gl6rxMk1nU7Hli1baN++PW5XVucWL17M7t278fHxoXfv3tT6z3h1SZLuIy5BkBMNpgIxgMBanLRQcygceAcu/CiGG/ynd5mbmwsvPvMo879dzoLvfnO85BqAxkf0XStIB235KnmWpHLFbOa1999nx5EjLNdqeRpu7Ld2v1eiKBQiUeTvL5JG8fGiH9vFi6Iiy9vbcaaLloCftzd9unWjT7duZGRn88e2bVSvXLn4/kOnT9P4pZeKP+/Wvv2NF9HrRUJNrxdTVz08RIWfr69IPMqE2j3n7Nmz/PjjjwRdmUA7cuRIWrduzZAhQ3j88cd5//33cZc99STpvmI2m4lOj7bLdtBCYyEf/P0Bl7MvE+YRxvRO01E73b6dTESNCL79/Vt8/X1xcrr5FFFHYzAZiMuOI9g9mPpB5Wd4wc2UaFvoxYsX6dKlC6NHjyYtLQ2AiRMnMnXqVFxdXdFoNLz00kscOHDAqsFKkuTAND5ie2hBhvUfK7AtBLQDsxFOzhC93v6j78ticvGK1VtITkm3fkyl5eQMpkLQJ9g7knLn33//xWAwFH++f/9+CgoK7BiR5Mjy09P59+RJAOrn54tkUWSkuPN+67dWEp6eYrtomzbQpInYPhofDwkJIhFZznh7eNDr8cev2/Z58sIFXK5UKvp4etKxWTMx8TMnR3yvFy+Kj729oVEj8bNo21b8XAICZGLtHqXX6wkMvDpx3NPTE7VaTc+ePRk/frxMrEnSfehi5kVOp5wmwDXApttBDSYDozaPYl/8PlzVrsx6eBbezt43PTf2fCz7du0r/jw4LBiNtnw8TxUaC7mcfZlQj1AaBjcs14k1KGFybfbs2TRo0IDdu3dTsWJFkpKSWLp0KY8//jizZ89m/PjxvP3223zyySfWjleSJEdVNNjAmHfTZJfF1XpPVMil7oXEjTfc3bBeDZo2rE1BQSHf/bza+vGUhcYb9JfBUH56HNnLpEmTWLlyJWfPnqV3797XTad+4403SExMtGN0kiPbv3Mn+YWFBLi6EglQr97VKqz7td9aSbi4QOXKIrHUooWoaivqy5Z7836X5cULXbqQvH49f0ybxrZZs3BJSRGDCQoKRA+1Zs2uft9VqogJq+WkAkCyvCeeeMLeIUiSZAdJuUmcSD6Bu8YdV7Xrnb/AQowmI+O3jmfT+U2olWqmdZxGpG/kzWOMT6J/z/4MemkQ/2z7x2YxWkKBsYC4nDgqe1WmYXBDXNRlGCzkYEqUft29ezeLFi1Cc2WlbuvWrZhMJrp37158Tps2bZg7d651opQkqXzQ+otJmIYcUFv5zaprBQh/GaK/glNzwL81qK5/4uv7cnf2HTrBwiUrebf/i47Xd6BoamheErhXsXc0Di0sLIydO3eyYMECzGYzr732GjVq1CAyMhKj0UhmZiYVK1a0d5iSA9pxpa9WW3d3FDrd9VtCdTrRM+t+7bdWEiqVmIYZFARpaSIJFR8vEm2enmKLpKP9br1WYaGouCsoELfCQgDcFAq61q8v/u4DA8W/A29vUakn3ZcUCsVNXyeoytGWaEmSLCMrP4tjSccwm823rBizBrPZzJQdU1gbtRYnhRNTOk6hVcVWNz03Iy2DAc8PIP5SPBWrVKRarWo2i/Nu5RnySMpNoqpPVWoH1EbjVD4q7e6kRM8Wer0ej2tWdXfv3o2zszPNml3tYySfeCRJujrYIMr6yTWAqi9D3BpR/RX9DdQYeN3dPbs/TPT5S/R58UnHS6yBeEOqdoPcGJEstPH0ofLklVdeKf64Zs2avPPOO6SmpnL27FmMRiN9+vTBzc2NevXqyYUe6SqTiZ3/iJXcNkXVVrLfWtkolVf7soWHi22i1/Zlc3MTiTiVyvbJNqPx+iRafr7Y5qlQiH5pGo1IogUEiCpFZ+frb7IqTUK8qf3oo4/QXpNsLywsZMaMGcX9povIAW+SdO/KM+RxPOk42fnZNu2zZjabmbV7FitPr0SpUDLxoYk8WOXBm56bm5PLoF6DOH/2PIHBgXz+8+f4BZSP6Zr6Qj3JumQifSOpFVDL5tNXralE30lkZCRHjhyhQoUK6HQ6tm3bRtu2bYsr2QD+/vtvIiIirBaoJEnlhHMQ5JwT/cSUt2+6edecnKHWu3DgPbjwPYR1va4CzMPDjalj37ZuDHdL7S36ruWngEuwvaNxWD/++CN169alevXqANSrVw9fXzEIYunSpSxfvhylUsmxY8fsGabkYEzZ2ew8ehSAtrm5IolS1HvLaBTJF7kltPQ8PcWtUiVITBQJttxcMBjErag1gEIhfuZFSbf/3m6VhDMar78ZDDceu7b9gEIhkmcajdjC6eUltrVem0DTaBy7wk6yu2t35BSRW0Il6f5iMBk4mXyShJwEwjzCbLY4bzabmffvPJYeXwrAmAfG8HDEwzc9Nz8vn/defY8Th07g7evNZ0s/I6RCiE3ivFs5BTmk56VTw68GNfxr4KS8txa3SpRc69OnD2PGjOHw4cMcPnwYvV7P66+/DkBiYiLr1q3js88+Y8yYMVYNVpKkckDrC1o/MdjA2QYVIQEPQEAbSN4JJ2dC00/L1xsopQqUTqC7JBKT5Sl2G4qKimLVqlWcOXMGhULBmDFjqF27NtWqiRJ4hUJBhQoVqFChgp0jlRzJ6YMHSc3KwlmlopHBALVqXd32V9RvTTYpLztnZ9GXrUIFUS1WWHjjTacTP2u9XiTJ8vNvTML9l1J5NSnn5CRuWu3VW1GyrOh+jUZWoUl3TVajSdL9zWw2E5UWxfmM84S4h9g08fP1wa9ZfHgxAB+0+YCu1bve9DxDoYERb41g3659uLm78ekPnxJeLdxmcd6N7PxsMvMzqeVfi2p+1VAqStT+v1wpUXKta9euODs7s2rVKgIDA/nmm29o0KABAAsWLOCPP/5g0KBB9OjRw6rBSpJUDhQNNkjdJ944WTtZpFBAzaGQshdS/4HEzRDc4bpTdv97hNmf/8BDbZvS/7VnrRtPWWh8IC8RCjPEx9INihZvjEYjderUoVWrViQlJbFy5Ury8/Pp3r07derUoV69egwdOtTO0UqOIlCtZkH//iRv2YLmxIkb+635+soeW5bg5CQSlXdiMFzte3btzWi8mkxTq2+scHNyEgk3SZIkSbKSayeD2rIH2JIjS/hi/xcADGk5hGdqP3Pb811cXdA6a5m9aDa16teyRYh3LSMvA12hjrqBdanqU9Ux2/VYQIk3uHbq1IlOnTrdcPy9995j1KhRKOWLHkmSimj9Rc81Www2AHCrCFV7Q/TXcGo2+LcS/d+uOHjkNMt/38iJ0+d5q88zjvcL3clZbKPVxcvk2h04XalK6dKlC35+ordEo0aNWLRoEdnZ2Rw/ftye4UmOxGjEz2DgjR494K+/xLFrk2t5ebLfmq0VJcskSZIkyYHYazLoLyd+4ZM9nwDwVtO3eLHei7c9X6VWMWHuBKJPRVO9TnVbhHjX0vRpFBgLqB9Un0pelRzvfZgF3XVGzNXVVSbWJEm6nsoVnIOhINN2j1n1VXAOgbwEOPfNdXe9+OyjuLhoOXH6HLv/PWK7mEpD4yUGMxj09o7E4W3cuLG43xrAmjVrqF27Nq1atSpuWSBJ5OSIW2EhnDsnjl2pusdkEpVQst+aJEmSJN3X7DUZ9PfTvzNt5zQAXm34Kq81eu2W5+74ewcmkwkQC83lJbGWokvBYDLQILgBlb0r39OJNbBAck2SJOmmXELElk1ToW0er2i4AcD57yH3YvFdXp7u/O8p0RR0weIVtomntFQeUJgN+Un2jsThhYVd32A2JCRELvJIN0i5cIHPVq3i8N9/iwNVqohm9yC2hLq4yOSaJEk39e+//2IwGIo/379/PwUFBXaMSJIka7h2MmigW6DNHvevqL+YuG0iAM/XfZ7+Tfvf8twfFvzAOy+/w5hBYzDfqlepgzGbzSTkJIACGgY3pILn/dETWb4bkSTJOjQ+oPG1bfVa4INiS6i5UAw3uOYJqO/LYgrYslUbyMjMtl1MJaVQgMpNJAVNhjufL0nSbW3buJGBX31F72+uVLL+t9+al5fstyZJUrFJkyaxcuVKzp49S+/evcnKyiq+74033iAxMdGO0UmSZGnXTgYNcQ+xWVXV5vObGbtlLGbM9KjZg3dbvnvLx161dBVzxs8BILxaeLmo/Co0FhKbFYub2o3GwY0J8Sgfk0wtodTJNbmSI0lSiSidRC80Q+6tJ8JZmkIBtYaCQgUpuyBld/FdLZvWo07Nquj1+fzwy1rbxFNaGm/IT4P8VHtHIknlm8HAjl27AGhbVNUo+61JknQbYWFh7Ny5k8GDB2M2m3nttdf44IMPWLhwIUajkcxMGy4WSpJkVddOBg12D7bZZNBdsbsYsWkERrORxyIf44O2H9w0YWY2m/lp4U9Men8SAC+9+RJ9BvWxSYx3I6cgh/iceCp5VaJZWDMC3O6v11olSq7JlRxJkspE6y+qsYy5tntMt8pQ6TnxcdSXxYk9hUJB395iovGC71Y4Zlm1UiWmreou2S4hKUn3ouxsdhwR/RXbpKeLY0XJNdlvTZKkm3jllVeYMWMGa9asAeCdd96hefPmpKamYjQa6dOnDw899BCDBg2yc6SSJN2t2KxYm08G3Re3j/c3vI/BZKBTeCfGtB+DUnFjOqYgv4CJQycya+wsTCYTT/d6msGjBzt01ZrZbCYxJ5GcghzqBdajQXAD3DRu9g7L5ko0sqloJWfBggXFKzk1atQgMjKyeCWnYsWK1o5VkqTyRuUGLsGQGwMqd9s9btWXIfZXyDwOKTshoC0Avf73GN/9vJpe/3sMo9GIyhGn1ml9IT8RCjNFJZsEQIcOHUr8omLjxo1WjkZydLkJCRy8MsSgrckE/v4QFibulP3WJEm6iR9//JG6detSvbpoFF6vXr3i4TlLly5l+fLlKJVKjh07Zs8wJUm6S0m5SRxPOm7TyaCHEw8zZN0Q8o35tKvUjokPTUSlvPn7kOFvDmf7hu0olUoGjx7MC2+84NCJtUJjIfE58fi6+FLTvyZB7kH2DsluSvTO8pVXXin+uGbNmrzzzjukpqZy9uzZ4pUcNzc36tWrx9y5c60VqyRJ5ZFLCORcEH3EbvEkYnFaP1G9dmEJnF0A/m1AocDH25N9m5bYJoaycnKGvCTQJ8jk2jXefvvt4o8vXrzI4sWLef7556lXrx5qtZoTJ07w/fff8/LLL9sxSslR7N22DYPRSEV3dyrl5IiqtaIXpno9eHvLfmuSJF0nKiqKVatWcebMGRQKBWPGjKF27dpUq1YNEBXwFSpUoEKF+6MxtyTdi+wxGfRk8kkGrR2E3qCnRVgLpnacitpJfcvze/bpyZF9R/ho3ke0erCVTWIsq+z8bNLz0qnkVYma/jXvy2q1a5Xona5cyZEkqcw0viJJVJgpkl62Et4LYn+BrBOQvB0CH7DdY98ttZfYGupWGVQu9o7GIXTv3r344x49ejBp0iQeffTR4mMdO3akVq1afPzxx/Tvf+uJS9J9oKCAHf/8A0AbZ2coSq4VycuDQNtNBJMkqXwYM2YMAEajkTp16tCqVSuSkpJYuXIl+fn5dO/enTp16lCvXj2GDh1q52glSSqtayeDhnmE2eQxo9KiGLh2ILmFuTQObsysh2ehVWlvOC8jLQNvX28AWjzQgt//+R03d8dNVJnNZpJykzBjpl5gPcJ9wm3Wt86RlSi55ggrOX379sXX15epU6cCcOLECcaOHcuZM2eIjIxk/Pjx1K1b12qPL0lSGSlV4FYJ0g/ZNrmm9YVK/4Pzi0XvtYB2xZUrubl6lq3cgJ+vF08+2t52MZWU2lNMDc1PBlUle0fjcM6fP1+82HOtihUrcvnyZTtEJDmU7Gx2Xem31raoR+y1/dYUCrklVJKkW3JyEm8Qu3Tpgp+feN3SqFEjFi1aRHZ2NsePH7dneJIklcG1k0HDPMJsss3ySOIRhqwbQmZ+JnUD6zLnkTk4q66vmjeZTCz8eCFLv17Kt79/S+WIygAOnVi7dhtorYBaBLrJBcsiJRpoMGbMGH7++Wf27duH2WymVatW5OfnX7eS8/LLLzNz5kyrBLl69Wq2bt1a/LlOp6Nv3740bdqU3377jUaNGvHmm2+i0+ms8viSJN0lrT84uYDBxv+PhvcCJ1fIOg1JV3+HfLVkBX0GTWDCjIW2jaekFArRry43BkxGe0fjcJo0acLkyZOvG6YTGxvLRx99RLt27ewYmeQQsrJY9t57bBgxgqcKCsDNDSIjxX16vei35m7DHpCSJJU7GzduLN6lA7BmzRpq165Nq1ateP311+0YmSRJpWUym2w+GXR7zHbeWv1WcWJtbpe5N2yZ1Ov0jOg3ggWzFpCVkcXW9VtvcTXHkZ2fTXxOPJW9K9M0tKlMrP1HiZJrRa5dyRkyZAifffYZWq2WRYsW0a9fP7y9vS0eYEZGBtOnT6devXrFx9asWYNWq2XYsGFEREQwatQo3Nzc+Ouvvyz++JIkWYDaA7RBUJBu28fVeEPl/4mPoxaA2QTAS88+hkajZv/hkxw4fMq2MZWUxhvy0yA/xd6ROJzJkyeTm5vLgw8+SMuWLWnRogUPP/wwarWaiRMn2js8yd6Sk/Hw9qaTwUAYQL16UDS8RKcDT0+RYJMkSbqFsLDrK1tCQkJQKkv1tkmSJAdgNBk5k3qGUymnbDYZ9I8zfzB0w1Dyjfm0rtia+Y/Nx1Pred05CZcTeO2p19i4eiMqtYrRs0bT+63eVo+trMxmMwk5CegMOjENNOj+nAZ6J6XuLn6zlZygoCCUSiWtWlm+4d60adPo1q0bSUlJxccOHz5MkyZNip/0FAoFjRs35tChQ/To0cPiMUiSZAGuIaC7CGYjKGy4J7/KSxCzDLLPQOJmCO6Iv583Pbo+xNLf1vPVdyuYP2uE7eIpKaUKFErRe8058GozdonAwECWLl1KVFQUUVFRAFSrVo2IiAg7RybZXV4eZGSIarVDh8Sx//ZbCwiwQ2CSJN2vEhMTmTRpEv/88w9arZbHHnuMd999F61WS2xsLKNHj+bQoUOEhoYycuRI2rZta++QJemeYDQZOZVyirOpZ/Fz9bP6ZFCz2cziw4uZ9+88AB6v9jijHxh9w1TQQ/8eYtjrw0hLScPX35fpC6fTsFlDq8Z2NwqMBcTnxOPn4ie3gd5BqZdgbLmSs3v3bvbt23dDc+rk5GQC/9OM2M/Pj4SEBKvEIUmSBWj9QOMFBZm2fVyNF1R5Xnx8TfVa394iEf/D8r/IzdXbNqaS0vhAfqIYBiFdx2g0cunSJRISEmjdujU5OTlkZ2fbOyzJ3rKyGPfNNwxdsICT+/aJY7LfmiRJdmI2mxk0aBB6vZ4ffviBOXPmsHnzZj7++GPMZjMDBgzA39+fX3/9lW7dujFw4EDi4uLsHbYklXsGk4ETySc4k3qGALcAqyfWTGYTs/+ZXZxY612/N+Paj7shsXZwz0H6PduPtJQ0qtepzndrvnPoxFp2fjYJOQmEe4fTLKyZTKzdgcPWN+fn5zN27FjGjBmDs/P1jf/0ej0azfUlnRqNhoKCAluGKElSaSjV4FIBCu2QAKnyAqjcIScaEjcB8GDbJkRWrUh2Ti4/r1xv+5hKQuUCxnzQy4WDa8XHx9O1a1dGjhzJjBkzyMzMZOHChTz66KOcPn26VNdKTExk0KBBNG/enHbt2jFlyhTy8/MB0cftlVdeoWHDhjz22GPs2LHDGt+OZEmZmXz999/M+vFHEtLTwckJioYd6fXg7CyTa5Ik2cy5c+c4dOgQU6ZMoVq1ajRt2pRBgwbx559/8s8//xAbG8uECROIiIjgzTffpGHDhvz666/2DluSyrVCYyHHko5xNu0sgW6BNwwRsMbjjd48mp+O/QTAkJZDGNRi0E2HJtRpWIc6DevQ8fGOfL3ya4LDgq0aW1kZTAbisuPQGXTUD6pP/aD6Vk9Q3gtKvS3UVubNm0fdunVv2pxaq9XekEgrKCi4IQknSZKDcQ4AlTMY88DJhv+/qj2h8vMQ/ZWoXgt6CIXCiTd6PcXw8Z+yYPEK+rzYzXbxlIbaS2wNdasskm0SEyZMoGnTpowbN46mTZsCMHv2bEaNGsVHH33EkiVLSnSdoooCT09PfvjhBzIzMxk5ciRKpZJhw4YxYMAAqlevzq+//srff//NwIEDWbNmDaGhodb89qSyMpu5eOQIl1JTcVIqaW4yQa1aIqEGot+at7fstyZJ0k116NChxBMEN27cWKLzAgICWLhwIf7+/tcdz8nJ4fDhw9SuXRtX16tvWJs0acKhoi3tpVBQUCCLDCQJyDfkcyrlFDGZMQS5BaEyqzAUGqz2eLoCHaM2j2Jf/D6ccWbkAyN5uOrD1z1mbnYuzq7OODk5oVQqmf3tbFzdXFEoFFaNrSzMZjOZ+ZnkFOQQ5B5EpE8kvq6+GA1GjNw/Q9b+W8hVUg6bXFu9ejUpKSk0atQIoPgJY926dXTt2pWUlOubfKekpNywVVSSJAej9gRtIOQlgEuIbR+7ygsQsxRyzkHC3xDyCC/37MroKV/g6eGGTpeHq6sDJujVnpB7EfKTQVXJ3tE4hH379rFs2bLiITsAarWa/v3707179xJfp6iiYOfOncVvfAYNGsS0adN44IEHiI2NZenSpbi6uhIREcHu3bv59ddfefvtty3+PUkWkJPDjj17AGjs5YVbejpceQ0BiH5r/3mDK0mSVOTa3+0XL15k8eLFPP/889SrVw+1Ws2JEyf4/vvvefnll0t8TU9Pz+sKBUwmE99//z0tW7a0aJub2bNno1arS/11knQvO85xmzzOI1f+AzBtM/HXtntjyOIxjrGRki0k3GvGjh1bpq8rUXLNGis5d7JkyRIMhquZ3JkzZwIwdOhQ/v33X7766ivMZjMKhQKz2cyBAwfo16+fRR5bkiQrUSjAJRR0saL3mcKGO9PVHlDlRYj6AqK+guBOBAX6cfnYWvz9vG0XR2kpFKByg9wYcAkDG4wPd3TOzs6kpqYSHh5+3fHz58/j7u5e4uvYqqJAspGsLHYcOQJAW+OV1dUGDcSfJtFrEU/Pm3yhJEkS1y3O9OjRg0mTJvHoo48WH+vYsSO1atXi448/vqEfdEnNmDGDEydOsHz5chYtWiTb3EiSJN1DSpRcs8ZKzp2EhYVd97mbmxj1WrlyZfz8/Jg1axaTJk2iZ8+eLF26FL1ef90ToCRJDkrrL6qxCrNA423bx67SE2J+hNwLEL8eQh917MRaEY236LuWnwIuQfaOxu569uzJmDFjGDZsGCCSanv37mXOnDk8++yzJb6OrSoKJBtJT2fnlZ57bbOyxLGi5JpeL7aDyn5rkiSVwPnz56levfoNxytWrMjly5fLdM0ZM2awePFi5syZQ/Xq1dFqtWRkZFx3Tlnb3Lz77rulWlySpHtJbkEux5KOkZSbRLB78A1DBCztbNpZhq4fSlpeGiFuIcx6eBYVvSoW36/L1TFrzCzW/y56Ojdq0Yjxn4zHx8/HqnGVRWZeJlkFWQS5BVHVpyr+rv4lLqqSblSif3m2WMkpDXd3d7788kvGjh3LsmXLqFGjBgsWLLiuwkCSJAflpAHXCpB5wvbJNZU7VHkJzn5+pXqtM1x5Ao6LTyYlLYP6darZNqaSUKpElZ/uEjgHimq2+9iAAQPw9PRk3Lhx6PV6+vbti5+fH6+88gqvvfZama8rKwrKMYOB5LNnORoTA0AbgCpVwOfKC1m9XlStyX5rkiSVQJMmTZg8eTKTJ08mKEgsasXGxvLRRx/dtB/0nUycOJGffvqJGTNm8MgjYvtYUFAQUVFR151X1jY3Go2mzD2CJKk8y87P5kTaCVILUqnoUxEnK+/w2Be3j/fWv0duYS7VfKvx6aOf4u96dQfEicMnGNl/JJcuXEKpVNL3vb68+var17UycQT5hnyScpNw1bjSKKARlbwqoXaSW8vvVqnTutZYySmJqVOnXvd5/fr1WbFihdUeT5IkK3IOhOwo2w82AKj8P7jwA+guQvxfENaVZSs38ELfD2nZtC471nxt23hKSuMD+YlQmGn7pKSDiYuL48UXX6RXr17odDqMRiMeHh4YjUZOnjxJnTp1Sn1Na1YUSDaQnU10dDQhfn4EGo0E/bffml4PERH2i0+SpHJl8uTJDBo0iAcffBAvLy/MZjNZWVm0atWKiRMnlupa8+bNY+nSpcyePZsuXboUH2/QoAELFiwgLy+v+Lll//79NGnSxKLfiyTdqzLzMjmSeIQ0fRphHmEordxu5u9zfzN682gKTYU0DmnM7Idn4665WjGq1+kZ9NIgMtIyCA4L5qPPPqJhs4ZWjam0TGYTKboUCk2FVPauTIRvBJ5a2TLDUkr9L7BoJScxMbH42N2s5EiSdB9Se4vtoQUZtn9slRuE9xIfRy8Ek4G2LRoCsHPPYY6firZ9TCWhcgFjvtgeep/r2LFjceLL1dUVjytb/S5dusQLL7xQ6utNnDiRb7/99oaKAjk4pxzJyqJlRASX1q5lffCVsfay35okSWUUGBjI0qVL+eOPPxg3bhzjx4/nzz//5JtvvsHLy6vE14mOjubzzz/njTfeoEmTJiQnJxffmjdvTkhICCNGjODs2bMsWLCAI0eO8Mwzz1jxO5Oke0O6Pp1DCYdIy7NNYu2XE78wYuMICk2FPFTlIT7t8ul1iTUAF1cXhk4cykOPPcSP6390uMRadn42sVmxuKpdaRbajAbBDWRizcJKXblmyZUcSZLuUwoFuIaBPs72gw0AKj0H578X2yzj1hBa4UmeeKQdK9dsYeGSlcyZ9J5t4ykptZeI2a2ySLbdR3755Re++OILQIwJf/rpp1Eqr/93k5WVRUQpq5NkRcE9IjkZNBoU+fkEnD0rjjVsKP7MyxPbQWU/IkmSSsFoNHLp0iUSEhLo0aMH58+fJzs7u3hBpyQ2btyI0Whk/vz5zJ8//7r7Tp8+zeeff86oUaPo0aMHlStX5rPPPiM0NNTS34ok3VNSdakcTjxMbkEuYe5hVu0RZjab+XL/lyw8uBCAp2s9zbDWw4q3n/67418UCgVN2zQFoMtTXXik2yMO1beswFhAUm4SWpWWuoF1qexVGa1Ka++w7kkKs9lsLssXRkVFFfcJqFatWqnf0NhbTk4OTZo0Yf/+/bIBqCTZgzEPknaIxJqm5KvAFnN+CZz+REzgbPcrazb+w+M938HXx4vLx9bg7OyATzpmM+ReBL+m4FbJ3tHYVGFhIatXr8ZkMjFy5EhGjhx53RschUKBi4sLLVu2LHFVQXR0NE888QR9+/blxRdfvO4+X19fnnzySapXr07//v3ZvHkz8+fPZ/Xq1SV+4yOfZ2wkPx/d+vU4u7ujPHsW3nwT/P1h7VqRyE9JEVVrLVve9/0KJUkqmfj4ePr06UNmZiaZmZn89ddfTJ8+nYMHD/L1119To0YNe4cIyOcZ6f6TnJvM4YTD5BnyCHYPtmoSK8+Qx0fbPuKv6L8AeLPJm7ze6HUUCgUGg4EvZ37JonmL8A3w5acNP+Hr72u1WMrCbDaTqk8lz5BHBc8KRPhG4O3sbe+w7mllGqVhiZUcSZLuc07O4BIK2Wfsk1yr+IxIsOkvw+U/eaTDE1QMCyL2ciK//bmZF57pcudr2JpCIba15saIpKCVm7Y6ErVazVNPPQVAhQoVaNy4MZmZmfj5+QFw8OBB6tSpU6qGzrKi4B6RlcWMH39k3l9/MaZOHd4G0W+t6AV3Ub81mViTJKmEJkyYQNOmTRk3bhxNm4qKlNmzZzNq1Cg++ugjlixZYucIJen+k5iTyOHEwxiMBkI8Qqz6WEm5SQxdP5QTKSdwUjgxvM1wetTqAUD8pXhGDRjFkX1HAHig8wO4ujnWYMXcglxS9Cn4OvtSJ7AOoR6hVt86K5UhufbflZyOHTuycOFCh1vJkSSpHHAJgpxoMBWA0sZTrlQuUPVlODUHor/GKexxXnupG+OmLWDBd785ZnINxDADfQLkp4if333Iw8ODjh078vjjjzNs2DAAhg4dKkr3v/ySatVKNvG1b9++9O3b95b3V65cme+//94iMUtWlJnJ2gMHSMnIwDU+Xhwr6rdmNoukmlz8kySpFPbt28eyZcuum/CnVqvp378/3bt3t2NkknR/isuO42jiUcxmM0Hu1n39eyzpGEM3DCVFl4KX1otpnabRNFQk2Teu3shH739EdmY27p7ufDj9Qzo90cmq8ZSGwWQgKTcJpUJJTb+ahPuE46K+v1rJ2FOp05dFKznbt28vrhCYPXs2rVu35qOPPrJ4gJIk3cM0PqD1s89gA4CKT4vHz4uHy3/Q58UnUSqV/HvwBEnJafaJ6U6UKrGVVndJJA7uQxMmTKBz584MGTKk+NiGDRvo0KEDEyZMsGNkks2ZzaScOcPeK33WuhQl14r6ren14Owsk2uSJJWKs7MzqampNxw/f/683H4pSTZ2OesyhxMOAxDgFmDVx1pzdg19/+xLii6Fqj5VWfzUYpqGNsVgMDDlgykM7zuc7Mxs6jWux4/rf3SoxFq6Pp247DgC3AJoUaEFtQNry8SajZU6ubZv3z769Olz05WcY8eOWTQ4SZLucQoluFYAg94+iSInZwh/RXwc/TUVQ3xZuWQml4+tJTDAsfomXEfjA/mJUJhp70js4uTJk7z88suo1eriY0qlkt69e8vnoftNbi4btm3DbDZTLzSUML0efH2hqHpRpxOJNRf54lKSpJLr2bMnY8aMYcuWLYBIqv3666+MHj1aTvOUJBu6lHWJQwmHUClV+Lv6W+1xjCYjc/fMZcyWMRQYC2hXqR3fPPkNFTwrAKBSqdDl6lAoFLw68FW++u0rQis6RquQPEMeFzMvAtAopBFNQ5ta9Wcl3Vqpt4UWreSEh4dfd1yu5EiSVCZaf1C5gyEH1HaoLqnYHc5/B3mJcOl3nuhSDl40q1wgP1lsD9V42zsamwsJCWH37t1UrFjxuuMHDhzA31++mLivZGWx9p9/AHjU0xPi4qBNGyhaANTroWpV2W9NkqRSGTBgAJ6enowbNw69Xk/fvn3x8/PjlVde4bXXXrN3eJJ0X7iYeZGjiUfROmnxcfGx2uPkFOTw4aYP2RG7A4BXG77KW03fQoGCgvwCNFqxW++DKR/QrWe34smg9mY0GUnWJWM0G6nqU5UI3wjcNTIfY0+lTq4VreQU9bk5f/48e/fuZc6cOTz77LMWD1CSpHucyhVcQiDnnH2Sa07OUPUVODkDor+BsCfASSsm7KRl4u/nbfuYSkLtJbaGulUWybb7SL9+/Rg1ahQHDx6kbt26AJw6dYrff/+dsWPH2jk6yZZMaWn8degQAI8mJ4uD7duLP4uqYT09bR+YJEnlWlxcHC+++CK9evVCp9NhNBrx8PDAaDRy8uRJ6tSpY+8QJemeFpMRw9HEo7ioXaw64TI2M5Z317/L+YzzaJ20jH5gNF0iu6DX6ZnywRRysnOY9c0sFAoFbu5uDpNYy8rPIj0vnUDXQCL9IglyC7Lq5FSpZEqdXJMrOZIkWZxLMOSeA5NB9BSztQpPXVO9tpKTec3p9dYY9Hn5HNv5s2M+Wak9QRcrKthUlewdjU1169YNX19fli1bxk8//YRKpaJy5cp8/fXXxVPdpPuA0cjBXbtIzszE3dmZ1qmpoNFAixbifr1ebAeV/dYkSSqljh07snPnTnx9fXF1vToF8NKlS7zwwgscPnzYjtFJ0r3LbDZzIeMCx5KO4ap2tWpibe/lvXyw8QOy8rMIcA1g5sMzqRNQh+jT0Xzw5gecP3sepVLJ8UPHqduortXiKI0CYwFJuUk4q5ypH1ifSt6V0DjZeCicdEulfhcrV3IkSbI4ja+4FWSAsx229TlpoeqrcGIqnFtEaMOOnI6KISdXx99b9tD5oZa2j+lOFApwcoXci+ASBkqnO3/NPaRdu3a0a9fO3mFI9pSdjZ9KxYjevTEcOYLm0CFo3vxqfzXZb02SpFL45Zdf+OKLLwDxBv/pp59Gqby+PXVWVhYRERH2CE+S7nlms5nz6ec5nnwcN7UbXs5eVnucn4//zJx/5mA0G6kbWJeZnWfi7+rPn8v+ZMqIKeTn5eMf5M/kzyc7RGLNbDaTqk8lz5hHBc8KRPhGWDXxKJVNqZNrciVHkiSLUzqBa0VIOwDYqWdWhSfh3LeQl4hX5gZefeEJPv3qZz7+8ifHTK6B6LemT4D8FHCx7lhyexsxYgSjRo3C3d2dESNG3PbcKVOm2Cgqya6ysqji48PkQYPglVfEsQceuHp/Xp7styZJUok99dRTqNVqTCYTI0eO5NVXX8XjmspXhUKBi4sLLVs66GsCSSrHzGYz59LPcTz5OB4aDzy11mnpUGgsZPqu6aw4tQKAxyIfY1S7UZgLzYx/dzx//PwHAC0eaMHETyfi62//AWe5Bbmk6FPwdfalbmBdQjxCUCpKPZdSsoESJdfkSo4kSVan9QeVmxhsoLJDM06lBiJeg+OT4fwi3n5tHvMWLmPNhp2ciYqhemRl28d0J0qVSBzoLoNzoEwiSPeXlBSxDTQlBYqmxBZVM5rN4ib7rUmSVEJqtZqnnnoKgAoVKtC4cWMyMzPx8/MD4ODBg9SpUweNRm7BkiRLMpvNRKdFczz5ON7O3lZryp+uT2fY38M4mHAQBQrebv42ver3QqFQ8E6fd9ixcQdKpZK+7/Wlz6A+N+Q7bM1gMpCsS0aBgpp+NQn3CcdFLavxHVmJkmtyJUeSJKtTu4vqq9yL9kmugRhmEP0t5MVTTbWHxx9uy5/rtvPpVz/z6bRh9onpTjS+kJ8AhZn39OTQa6vRZGWaREEB+3bvJj4zkw6ZmbgB1K4NAQHi/rw8sR1UTjGXJKkMPDw86NixI48//njxELehQ4diNpv58ssvqVatmp0jlKR7g8lsIiotihNJJ/Bx8bFaYu1M6hneW/8e8TnxuKndmNRhEm0rtS2+/7XBr3H25FnGfzzeIYYWZORlkJWfRbBHMNV8q+HvaqedPVKpKMzmonFaJbN37957YiUnJyeHJk2asH//ftzli29Jcgz6REj5Rww4sMdgA4BLK+HYR6D2ZqNiNJ2efQ83NxcuHV2Dt5eDNkbPvQietcCrpr0jsZp58+aV+NyBAwdaMZKSk88zVpSSwivPPcfizZsZGhbGjMuXoV8/eP314vvx8IBWrWRFpyRJpfb8889Tp04dhg8fjlqtBsBkMjF58mROnz7NkiVL7ByhIJ9npPLMZDZxNvUsJ1NO4uvsi5vGzSqPs+n8JsZuGYveoKeiZ0VmPzybEOcQTh45SaMWjYrPKywoRK1RWyWGkso35JOYm4i7xp1I30gqelVEZa/3RFKplfpvSq7kSJJkNVo/UX1VmCk+tofQrnDuO9BdpEPVE9StFcGxk9H89Os63urzjH1iuhO1F+gugXsVcHK2dzRWsWfPnuKPTSYT+/fvJzAwkFq1aqFWqzl16hTx8fE8cG3PLemeZUpP56+DBwHokpQkDsp+a5IkWcjJkyeZPn16cWINQKlU0rt3b7p162bHyCTp3mAymziTeoaTySfxc/GzSmLNZDbx1YGv+OrAVwA0D2vOlA5TyLicQZ9+fYg5F8OiPxZRrbbIX9gzsWYym0jVpZJvzKeKdxUifCOs1ndOsp5SJ9cmTJhA586dGTJkSPGxDRs2MHnyZCZMmOAwKzmSJJVDShW4VoD0w/ZLrilVUH0AHBqOIuYHpo0cSSGudH3EgSdTqj1BFwt5SeBWyd7RWMW1zy0TJ04kIiKCMWPGoFKJpzGz2czUqVNJSUmxV4iSrZjNHN65k8SMDNw0GtoWFEBwMBQt7hX1W/Nw0EpTSZIcXkhICLt376ZixYrXHT9w4AD+/nJ7liTdDaPJyOmU05xJPYO/qz+uatc7f1Ep5RTkMHbLWLbGbAWgZ52evNPyHTb9sYmP3v8IXa4OHz8fsrOyLf7YpVU0sMDPxY/6wfUJdg+WAwvKqVIn1+RKjiRJVuUcACoXMOhAZfkn2xIJ6gBedSDzOI9VOQq1h9snjpJSKMDJVWwPdQkT01fvYb/99hu//fZbcWINRO/Pnj170r17dztGJtmETsfareLFckdfX7QJCaJqrahKrajfmkyuSZJURv369WPUqFEcPHiQunXrAnDq1Cl+//13xo4da+foJKn8MpqMnEo5xZnUMwS4BlilQf/FzIu8t/49zmecR+OkYUTbETxc6WFmjprJ8u+WA9C4ZWMmfTaJgOAAiz9+SRlMBpJyk1AqlHJgwT2i1Mk1uZIjSZJVqT1BGwT6y/ZLrikUUGMQ7H0TYn+Dys+DWyUKCw2o1Q7a90DjDfoEyE8RgyHuYYGBgWzfvp3w8PDrjq9fv/6G5ybpHpSdzdor24S7ZF9Zcb52S2huLri5gaudfn9IklTudevWDV9fX5YtW8ZPP/2ESqWicuXKfP311zRtav9m55JUHhlMBk4mnyQqLYpAt0CcVZZvZbI7djcjN40kuyCbANcAZnSegbfOm9eeeo1TR08B8Orbr/Lm0DevW6S1tYy8DDLzMwlxD6GanxxYcK8o9b8ouZIjSZLVuYaA7iKYjaCwUxWWbxMIaAPJO+HsfKZuqcEnC35izdJPaFTfAQcHKFUiKaiLA+fAe7rX1NChQxkyZAibN2+mZk3xd3H06FGOHTvG/Pnz7RydZG0ZFy+y+/RpAB4tSqQ1aXL1BL0eqlS5p/8fkCTJ+tq1a0e7dg7cEkKSyhGDycCJ5BNEpUUR5BZk8cSa2WxmyZElzPt3HiaziXqB9ZjReQb+rv4s/Hghp46ewsvHi4mfTqT1Q60t+tilUWAsIDEnEVeNKw2DGlLRqyJqJ/sOUZAsp9TJNbmSI0mS1Wn9QeMFhVmg8bFfHNUHQvIuSNjAkUPZJCSm8smXS1n02Tj7xXQ7Gl/Ij4fCcFHJdo/q3LkzK1eu5Ndff+XcuXMANGzYkMmTJ1Op0r3Zc066wmRi+8aNGE0manp5USUzE1q3hqJWFUUD0L287BejJEnl0ogRIxg1ahTu7u6MGDHitudOmTLFRlFJUvl3bWIt2C0YrUpr0evnGfKYuG0i66LXAdCtRjeGtxmOxkkDiEo1Xa6O5155juCwYIs+dkmZzWZS9ankGfKo7F1ZDiy4R5WpFlKu5EiSZFVKNbhUgIyj9k2ueVSD0McgbjXvdMzgpz/gp9/WMW3s2wQF2mngwu2oXCA/WVSv3cPJNYDIyEiGDx9OZmYm7u7uKJVKFLJS6d6XnU3XevU4/dNPJLz3HmRmXr8lVKeT/dYkSZIkyUEYTcbiraBBbkEWT6wl5CTw3vr3OJ16GieFE++1eo9OQZ2YO34ub498G62zFicnJwaNGmTRxy0NXaGOZF0yvs6+1A2sS4hHiBxYcI8qUXJNruRIkmRzLkGQEw2GHFC52y+Oav0gfj3NA07RskEV/jl8gS8W/crYYX3tF9PtaHzF5FC3iqC+NxMMZrOZL774gkWLFpGdnc26dev45JNPcHV15cMPP0Sj0dg7RMlasrJQFBZS3cWF6nFx4OQkKteuuZ+wMLFVVJIkqRSufQ8j389I0t0rGl5wNu2sVbaCHog/wPC/h5Oel463szfTOk1DG6+lV5deJMYnYjQaGT7JfkPJjCYjybpkAGr41aCqT1U5sOAe56CduSVJuu+pPcXky5xo+ybXXEKg8nNw4QfeeTifnofh82+W88HgV9BqHTCJo3aHgjTQXQYvB+wNZwGfffYZq1evZurUqQwZMgSA7t27M2bMGKZPn86HH35o5wglq0lNFVtAt2wRnzdocHULqMkEBgME3dsDPSRJso558+aV+NyBAwdaMRJJKv9MZhOnU05zJvWMxRNrZrOZX0/+yoxdMzCajVT3q87MTjPZ+dtOZo2bhaHQQOWIyjzT+xmLPWZpZednk5aXRpBbENX9qhPgZr+ppJLtlCi5JldyJEmyC7cKYrCBQS+2PNpL1Vfh0kp61I2nQpAnlxLT+HnFenr37Gq/mG5H4w25F0X1mureq+BZsWIFU6dOpVmzZsVbQdu0acO0adMYPHiwTK7dqwoKmPf112w5coQ3ExLoDDdOCXV3B19fe0UoSVI5tufKFGIAk8nE/v37CQwMpFatWqjVak6dOkV8fDwPXPt7R5KkG5jMJs6knuFM6hkCXAMsmlgrNBYyfdd0VpxaAcDDEQ/zftP3mT1qNmt/WwvAQ489xNjZY3H3sP3ivMFkICE3Aa2TlnqB9ajsXbm495t07ytRck2u5EiSZBdqb3AOBX0sqMLsF4fGG8JfRn32cwZ0NjPie/j4y5/o9b/HHbPPl9oT8mNE9ZpndXtHY3GpqakEBgbecNzT0xOdTmeHiCSbyM5m+ZYtbD12jIcUihuTa1lZEB4OzpbddiJJ0v1hyZIlxR9PnDiRiIgIxowZg0ol3i6ZzWamTp1KSkqKvUKUJIdnMps4m3qWUymn8HP1s+g2yBRdCsP+HsaRxCMoUDCw+UA6eHbgrR5vEXUyCicnJ94e+TYvvvmiXV6fp+vTyS7IJtQjlOp+1fFxsWPfaMkuSpRckys5kiTZhUIhqq/0l8CYD06WbYJaKpWfh4vLeKNtCudy6zNwyAjHTKwVKapec60AKld7R2NRLVu25Ouvv2bChAnFx3Jycpg9ezYtWrSwY2SSNWVdvszOkycBeNRsFom0oumwRqPYFnqTpKskSVJp/fbbb/z222/FiTUAhUJBz5496d69ux0jkyTHZTabiUqL4lTKKXydfXFVW+715/Hk47y/4X2ScpNw17gzucNkWldsTVxsHMnxyfgF+DF5/mSatGpisccsqXxDPom5ibhr3Gkc0pgwzzBUStl9635Uor91uZIjSZLdaP3AJRjyEkX/M3tRuUBkX/zyJ7Pg+YtQw46xlITaU2yp1cWBZ6S9o7GocePGMXDgQNq0aUN+fj79+/cnLi6O0NBQ5s+fb+/wJCv5e80aDEYj1V1dqarTXV+1lp0tJoT6yFViSZLuXmBgINu3byc8PPy64+vXr6dixYp2ikqSHJfZbCY6LZqTySfxdvbGTWO5tiRro9YycdtECowFhHuHM7PzTCp7VwYgtGIosxbNIqxiGAHBtu1rZjabSdWnkmfIo4p3FSJ9I/HQ3pvDxKSSKXVKVa7kSJJkUwoFuFYSSSKTAey5EhT2JJz/XiStzn8vJok6KoUC1F6QGwOuYfbtWWdhnp6eLF++nN27d3Pu3DkMBgPh4eG0bdsWpVKONr8n6XT8tW0bAF0KC8Wxa5NrOTlQowbISbGSJFnA0KFDGTJkCJs3b6ZmTTEc6OjRoxw7dkwu4kjSf5jNZs6ln+N48nG8nb1x11im15nJbOLzfz9n0eFFALSr1I53673LlDen8ELfF2jbsS0ADZs1tMjjlYa+UE+SLglfZ1/qBtYlxCMEpUK+Br3flfpdqlzJkSTJ5rT+4BwIBangbMdJgEoVVB8Ih4Zxcud3TJ11gbCwikwePcB+Md2O2ktsDdXHg0dVe0djMV27dmXevHm0atWKVq1a2TscyQbMWVms3bsXgEcLC0WFWt264k6DQfzp72+n6CRJutd07tyZlStX8uuvv3Lu3DkAGjZsyOTJk6lUtB1dkiTMZjPn089zPPk4XloviyXWcgtyGb1lNNtixMLaqw1fpY2iDW8+8SZJCUnEnIth5c6VqDVqizxeSRlNRpJ1yZjMJqr5ViPCN8Ki21+l8q3UyTW5kiNJks0pncCtEqQmgNkICif7xRL0EHjV5fyhY3z3y994eboz4p1X8PBwwKmcCgVoPCH3AriGgtO90ehdqVRSWFS9JN0Xjv/7L5dSU3F2cqK90Qht24LTld8DWVng7S1ukiRJFhIZGcnw4cPJzMzE3d0dpVLp2L1WJckOLmRc4HjycTw0HhbbEhmXHce7698lKi0KjZOGD9t9SM7OHPqN64eh0ECVyCpM/2q6zRNrOQU5pOpTCXQNpJpfNQLdAuXvBOk6pU6uyZUcSZLswjkQNL6Qnw7OdqxQUSigxtt0SX+T6iFwJj6HxUv/ZOAb/7NfTLej9oLcWNAngHsVe0djEQ8++CCvvvoqDz30EGFhYWj+sxVQTq2+x5hMZMfG0qpWLXzPncPFaLx+S2hurhhuoJLNgyVJsgyz2cwXX3zBokWLyM7OZt26dXzyySe4urry4Ycf3vC8I0n3o5iMGI4lHcNN7Yan1tMi1zyUcIihG4aSkZeBn4sfUx6YwqpZq1i9fDUAHR/vyJjZY3Bzt92itsFkICk3CZVSRZ2AOlTxroJWZccha5LDKtMrUbmSI0mSzSnV4B4OafvA7Av27Gvg2wRlUBsGPbyTgYth7lc/0/+1Zx2z35dCCWp3Ub3mEgpO5f8NwenTp6lTpw5JSUkkJSVdd598LroH5eTQqkoVdo0YgbF3b9FXrWgqbEGBSKr5+dk3RkmS7imfffYZq1evZurUqQwZMgSA7t27M2bMGKZPn86HH35o5wglyb4uZl7kaOJRXNWueDl7WeSaq06vYsqOKRhMBmr612RSm0l8+PKHnDxyEicnJ94e9TYv9n3Rpq/1MvMyyczPJMQjhOp+1fF18bXZY0vlT6mTa3IlR5Iku3EOArU3FGaCxs5TAasP5OUHdjLqFzgbfZG1f+/i8Yfb2jemW9H4gC4W8hLE9tpy7toJ1tJ9ICsL8vNhzx6cAJo1mAq/7wAATwFJREFUA1fXq/d5e4OXZV7YS5IkAaxYsYKpU6fSrFmz4jfybdq0Ydq0aQwePFgm16T7WmxmLEcTj+KidsHb2fuur2c0GZm7dy4/HP0BgE7hnRj34DicVc7UrFeTuNg4pn05jaZtmt71Y5VUobGQxNxEnNXONAhqQCXvSqjsOVRNKhdKXWbx2Wef8fvvvzN16tTiRFr37t3ZuXMn06dPt3iAkiRJxZy04FYFCrLAbLZvLB7VcK/6OK8/KD795Muf7BrObSmUoHKDnPNgKr+9ylatWsXAgQMZMmQIq1evtnc4ko3EnTxJRl4eXJkWet2WUJ0OKlQAR6walSSp3EpNTSUwMPCG456enuh0OjtEJEmO4VLWJY4kHkHrpLVIYi2nIIch64YUJ9b6Nu7L2NZjcVaJPsHvT3yfH9b9YNPEWro+nYScBEI9QmkZ1pKqvlVlYk0qkVK/Gl2xYgUTJkzgoYceumElZ+3atRYPUJIk6TouIaD2hMIse0cC1fox8BEVSgVs2LKH46ei7R3RrWl8ID9N9F4rhxYvXszIkSPJy8tDr9czfPhwZs+ebe+wJGsrLGTC3Ln4v/QSs48eFcfatRN/5uWBVgu+couGJEmW1bJlS77++uvrjuXk5DB79mxaFG1Ll6T7TFx2HEcTj6Jx0uDjcvc7SGIzY3ll1SvsurQLrZOWiW0ncvm7ywx9bSiGK5PANVoNwWHBd/1YJVFgLOBi5kXMmGkU0ojGIY0ttuVVuj+UOgUrV3IkSbIrlQu4VYSM46Cx8xOeSwhVmv6Ptzr9QGiQHyGBDvwmX+Ekfna5F0SCspytwC1dupRJkybx1FNPAbB+/XpGjBjBkCFDZJ+1e5g5K4u1e/ZgNJmoCVC7NhS9BsnMFIk1D8tMJ5MkSSoybtw4Bg4cSJs2bcjPz6d///7ExcURGhrK/Pnz7R2eJNlcQk4CRxKP4KRwskjfsX1x+xj+93Ay8zMJdAtkZL2RfPnul8X91Y7sO0Ljlo0tEPmdmc1mUvWp5BnyqOJdhUjfSItNPpXuL6V+d1W0kjNhwoTiY3IlR5Ikm3IJhZwLUJgjmvXbU9VXmff6SjCkQt4/wKP2jed2ND6gj4O8RHANs3c0pRIbG0urVq2KP+/QoQN6vZ6kpCSCgoLsGJlkTScPHOBicjJahYIHzebrt4Tm5UFoqJjgK0mSZEGenp4sX76c3bt3c+7cOQwGA+Hh4bRt29YxhxdJkhUl5SZxJPEImMHP7e4HCC0/sZwZu2ZgNBupG1iX3p69Gf/ieNJT0/Hy8WLqF1NtlljLM+SRmJuIl9aLJqFNCPUIRWnPoWlSuVbq5JpcyZEkye7UHuBaAbLP2j+5pvGG8Ffg7Gdwdj4EdwSlgw52UarAyVkkJp2DylX1msFgQKW6Gq9KpUKr1VJQUGDHqCRr++tKb732gCtcTa7l5oKbm9wSKkmSVXTt2pV58+bRqlWr6xZ2JOl+k6JL4UjCEQxGA0Hud7eYaTAZmLV7Fr+c+AWALhFdqBldkxFvj8BoNFKjbg1mfj2TkAohlgj9tsxmMym6FApMBUT4RBDpG4mbxs3qjyvd20r9zkqu5EiS5BBcw0AXAwYdqFztG0uV5zGeX8rKrXH89NnL/PTDEtRqB01caXxF37W8JHANtXc0knRrej1rrwwxeNRshqAgqFZN3JeVBSEh4G7n5LokSfckpVJJYWH5HQAkSZaQpk/jcMJh8o35BLvfXd+zzLxMRmwcwd64vShQMKDZAHL/yuXjTz8G4NEejzJq+iicXZwtEPnt6Qv1JOmS8HX2pb5/fULcQ2SLEckiSv3uT67kSJLkEDTeYntoboz9k2tOzhjCX6P/G9NJyjrLb6vW8L9nnrRvTLeiVIlbbsyV6jUne0dUYmvXrsX9mmSKyWRiw4YN+P6neqmoL5tUvuUkJLDtyhCDR0FUrSkUYlJwYSEE26bBsSRJ958HH3yQV199lYceeoiwsDA0musr0gcOHGinyCTJNjLyMjiScAS9QU+I+91Vkl3MvMg7f73DxayLuKhcmPjQRB6s8iBnNWdZtmgZfd/tywtvvGD1BJfJbCIpNwmT2UQNvxpU9amKi9rFqo8p3V9KnVyTKzmSJDkM14qguwTGPLHd0Y604T1469EvGP9zFp/M+8Jxk2sAWn9RvZafDC7lI0ERGhrKN998c90xPz8/vv/+++uOKRQKmVy7R2zZsIECg4EqSiXVTSZo317ckZMjKtbkllBJkqzk9OnT1KlTh6SkJJKSkq67T1a4SPe6rPwsDiccJqsgi1D3u9vlcDD+IEM3DCUzP5Ng92DGNx1PkypNAKhWuxq/7/4dLx/rDyjLLcglRZ9CgGsA1f2qE+gWKP9fliyu1Mk1uZIjSZLD0PiCczDo4+2/xVGpot9bg5ny60R2H01i1/ZttG73wJ2/zh6Kq9cugHMglIPGrZs2bbJ3CJItmc00Cw7mi+eeQ7FsGQo3N2h8pblxVhZUrgwucrVZkiTrWLJkib1DkCS7yCnI4XDCYTLyMgjzCLurBNRfUX8xfut4Ck2F1PavTfuE9gx+dDCfL/2c+k3rA1g9sWY0GUnKTUKhUFA7oDbh3uFoVVqrPqZ0/yp1ck2u5EiS5DAUCnCrJCZgmgpBqbZrOMF1n6RXh3l8vT6dEWMmsGXTBsf9vaj1E33X8pLBRU7blBxMTg5BajVvOl+pSG3VCjQaMBrFtlA5IVaSJCtYtWoVGzZsQK1W06lTJx5//HF7hyRJNpNbkMuRxCOk6lIJ8yx7Ys1sNrPw4EK+3P8lAA+EPoDbejfmLxfDDzf8saE4uWZNOQU5pOpTCXQNpIZ/DQLcAqz+mNL9rdTJNbmSI0mSQ9H6i+qr/FT7b3FUKBg7dhzfbx7MtiMZrF2+gMeefdO+Md2KUg0oQHcRnAPKRfWadB/JyoK8PNi1S3xeNCVUbgmVJMlKFi9ezPTp02nVqhUGg4Hhw4dz+vRp3n33XXuHJklWpy/UcyTpCEm5SYR5hqEs4+vCAmMBH237iDVRawB4usLTnP78NNsObEOpVDLow0G82PdFS4Z+A6PJSGJuIkqFkjoBdQj3CUfjpLnzF0rSXSpxck2u5EiS5JAUSnCtJHqImQxiu6MdVazZhv+3d9/hUZZZH8e/UzIz6T0hCb230IsFy7qKnde1ix0VRcWCCrYVrIAoKip2BBdWLLi7yMouuvZdBUTpvUkJ6W2STGYyM8/7x0g0ApLEJJNJfp/rygXzzDMz58nNcJIz932f8Rf15qm/buTeJ97k9FGXYbHHBDWmI3IkBZbUugsCBTaRZmLxokXs/fZbRm3fTjuLBY4/PnCH0xnoGGrTD8ki0rAWLlzI448/Xr1v57Jly7jvvvu48847m+8sdJEGUOmtZG3OWrKd2WRE17+wVlJZwj2f3MP3B77HYrJwVfJV/PPBf5KbnUtMXAxTX5rK8BOHN3D0NR2crdYmqg3dE7uTFJHUqK8n8ku1eufMmzeP+++/n8rKSlwuF5MmTWLmzJmNHZuISO04UgLLHD1FwY4EgPsmP8WIXjamXuzFvOOVYIdzZGYbYILyPYGldiLNgdfLi3/5C7e+/TbvAfTvD7Gx4PUGloInqxAsIg1v7969HHvssdW3TznlFFwu1yHb4Ii0JG6vm3U568hyZpEenY6lnl3k95bs5drF1/L9ge+JDItkUrdJ/HXCX8nNzqVj147M/XBuoxbWvH4vWc4syqvK6ZPchyHpQ1RYkyZXqyke+iRHRJo1sxUiO0Lhd2D4g77EMSEpha/+PhO+uxX2vAvpZ0Jc36DGdET2BKg8OHtNP4RI8FXk5PDFmjUAnAE/Lwl1OgNFtvj4oMUmIi2X1+vFav35VyOr1Yrdbsfj8QQxKpHG4/F52Ji3kb2le8mIzsBaz9Ufq7NXc9eyu6o7gj57+rN0juvMt6d8S2VlJU+8+ARRMVENHP3PnG4nhZWFpEWl0T2xO4kRiY32WiK/pVbvoN/6JCdVmwqLSHPgSAVbPHiKAwWjYEs6BtLPgqyP8K15FMsJC4K+ZPWwLA4wfFC+NzD7Tx+YSJB9vmwZ7qoq2gO9oOZ+a336gLUZvo9ERERCSJWvio15G9lVvIv0qPR6F9Z+2RG0Z3RPpp02jbYJbQF4ZNYjhNnCsFjqNxvuaLx+L7nluVjNVjJTMukY15EwS3Cbm0nrVqt3kT7JEZFmz2L7afba94EiWzMoEnk638qzr3/K6//Zwcq33yC2XzNtbmBPgsos8HRoHoVJab18PpYuWQLAmYCpY0do3x48nkBRLVGfRotI41m6dClRUT/PsPH7/Xz88cck/KqJysHVPCKhyOv3sil/EzuLdpIWlVavgpRhGLzxwxu8vOplAI6JPIbc13KZ/eVsHn/xcUwmE45wR0OHXq3UXUpRZRFp0Wn0SOxBQrh+fpXg08e/ItJyOFIhLBaqSsAWF+xoMDsSePN/UWzLruSpWXN49LmzILJdsMM6lMURaAZRsUfFNQmuggKW/tQh9Ez4edZaaSnExQW+REQaQXp6OnPmzKlxLDExkfnz59c4ZjKZVFyTkOXz+9iSv4XthdtJjUytVxfNKl8Vj3/1OEu2BT4MO818GiunrqS4sJiSghJysnJok9GmoUMHAoXBnPIcbBYb/VL60SGug2arSbNR6+KaPskRkWbPGg6RHaB4bbMorlmtVp6YMpHzr57IzI983HzhFNJOf71ZzKo7hD0RXFmB759Ne1pJcGz75ht2ZGcTBpwCPxfXysuhe3cwB3c/RRFpuT799NNghyDSqPyGny35W9hasJXUyFQc1rrPLCt1l3LPx/ew6sAqLCYLpxWfxsfPf4zP66NnZk+eeuOpRiusHZytlh6dTvfE7pqtJs1OrYpr+iRHREJGeBso2wlVTgiLDnY0nHf2HzhmUA++/X4Lj765htl9l0Dbc4Md1qGs4eDOD+y9puKaBIPTye4NGwgPC+OYqiqi4+IgMxMqK8HhgAT9EC0iIlJfOwt3srVwK0kRSfUqrO0r3cft/7qdH0t+JMIcwZC1Q/jX+/8C4LRzT2PyM5MbZSmo1+8luzwbh8VB/9T+tI9tr9lq0izVqrimT3JEJGSERUFEW3BuaRbFNZPJxLQpEzh51I289hnc+fnTdLvo+Oa5/NIWC5V54K8Cs35okSaWk8NpvXqx99xz+fGDD+CEE8BigYKCQGEtJibYEYqIiISkfaX72JS/iTh7HBFhEXV+/NqctUxYNoHiymJSI1Pp8mkXvlz6JQA33XMT191+HaZGWJlxcLZaRnQG3RO7Ex+uD4Cl+dL6ChFpeSIyAvuIecuDHQkAJx0/mLNOPQ6vDx78axlsnhnskI5AKUGCxOOBPXsgKorE5csZBD8vCa2shPT05rmcWkREpJnLK89jQ+4GHFYH0fa6f/D8+e7PGffPcRRXFtMrqRfzzpvHtTdcS0xcDDNen8H1d1zf4IU1r9/Lfud+3D43/VL6MTh9sApr0uzpNykRaXlssRDRHirzwTCCHQ0AUx8aj8lk4oPvYM+6f0Hef4MdkkjzkZ/P+nXrArPU9u+HsDAYPhwqKiAiQktCRSTkeTwezjnnHJYvX159bO/evVxzzTUMGDCAs846i6+//jqIEUpLVFJZwrrcdXj93nrtUfb+xveZ+MlE3D43w+KH8eo5r5IUkcTA4QNZ/O1i/nDmHxo8ZqfbyX7nfpIjkxmWMYyuiV2xmtWHUZo/FddEpGWK6hxYeukuCHYkAPTr041ZU+9m3Vtn0z4J2DANvK5ghyUSfIbBqo8/JvOOOzh5wgR8AEOHBopqpaWQlAS/aKgkIhJq3G43EyZMYNu2bdXHDMPglltuISkpiUWLFvF///d/3HrrrWRlZQUxUmlJKqoqWJezDqfHSWpkap0eaxgGs1fOZtp/p+H3++m7oy8b/7yR/Tv2V58TFd2wudnr95LlzMLldZGZksmQtCFqWiAhRSVgEWmZrOEQ3Q0KvgOfGyz2YEfErTdcAt4K+Pp7qDwA21+GnncGOyyR4CoqYuabbwLQNj8fC8BZZwVmnXo80KZxuo6JiDSF7du3c9ddd2H8aib9t99+y969e1m4cCERERF06dKFb775hkWLFjF+/PggRSsthcfnYUPuBnIrcmkX065Oyza9fi+PffkYS7YtAR/0XNGT9f9eD8DHiz+ma8+uDR5vmaeMAlcBaVFpdE/sTmJEYoO/hkhj08w1EWm5wtN+Wh6aG+xIfmaNgD73svUA+Hf+FUo2BTsikaDa+8MPvPvTUqgJVVXQti2ceiqUl0NkpJaEikhIW7FiBcOHD+edd96pcXzNmjX07t2biIifN5cfPHgwq1evbuIIpaXx+X1szt/M3tK9ZERnYDbV/lf+ck85d/zrDpZsW4K50kynf3Zi8783YzKZuOOhO7jpnpsaPNYsZxblVeX0TenLkPQhKqxJyNLMNRFpuUxmiOkC7jzwFIMtLtgRAXDns98y61VYcLPBpXGPwTHzQHtJSGtUUcHzr7yC1+fj5LAwBlVVwdVXg9UKJSXQoQOEhwc7ShGRehs9evRhj+fl5ZGSklLjWGJiItnZ2U0RlrRQhmGwvXA7Owp3kBqZWqe9yvIr8rn9X7ezpWALthIbcR/EsevHXYRHhPPYi49x0siTGjTWMk8Zha5CUqNS6Z7YnaSIpAZ9fpGmpplrItKyhcVAdFeoKgW/N9jRAJCUEIffDw+8Z8JTuAV+/GuwQ2r1tNF0cDh37eLVf/4T+GnWWnIynH02+P2Br9S67REjIhIqXC4XNputxjGbzYbH4wlSRNIS7CnZw5aCLSSEJ+CwOmr9uN3FuxnzjzFsKdhCTGkMtjdt5P6YS2paKq//7fUGLaz5/D4OOA9Q5imjd3JvhqQPUWFNWgQV10Sk5YtsH1giWpkX7EgAuOOm0bRJTWRnjsGrnwLbXoGKfcEOq9XSRtNB4vPx5quvUlJRQXerlbMBLr8cbDZwOiE6GuLjgx2liEijsNvthxTSPB4PDkftCyIiv5Rdls2GvA1EhkUSZat9s4G1OWu5bvF1ZJVl0S6mHW9c/Qa9M3vTu39v5v1zHj369miwGMs95exz7iM+PJ7hbYfTI6kHNovt6A8UCQHNuriWk5PDbbfdxrBhwzjhhBOYOnUqbrcb0IwCEakDsxWiuoLJBN6yYEdDZGQ4k++5AYBH/2HFWe6GDVMDG7hLk9q+fTsXX3wxe/bsqXH84EbTjzzyCF26dOHGG29kwIABLFq0KEiRtkAFBfz9s88AuNPrxRwbC+efH7jP6YS0NLAHvxGJiEhjSE1NJT8/v8ax/Pz8Q5aKitRGkauI9TnrMWMmzhFX68d9vvtzxv1zHCWuEnon9GbOqDl0SurEk68+yauLXiUptWFmlPkNP9ll2Tg9Tnon92ZoxlDNVpMWp9kW1wzD4LbbbsPlcrFgwQKeeeYZPvvsM5599lnNKBCRunMkQVQXcBeA4Q92NFx3xXl069Ke3GIvM5daoGA5HFga7LBaHW00HUT797Ps4Yd5t00brgK49FKIiADvT8u3k5ODGZ2ISKPq378/GzZsoLKysvrYqlWr6N+/fxCjklBU7ilnXe46XF4XyZG1z53vb3yfiZ9MxO1yk/RREj1X9SQ+PDBjPComCkd4w8yirKiqYG/pXmLtsQzLGEbPpJ6arSYtUrMtru3cuZPVq1czdepUunXrxpAhQ7jttttYsmSJZhSISP1EdQRbIrjzj3pqYwsLs/LY/eMAeGqpmdwSYNPMQOMFaTKjR4/m/vvvJ/xXm+Zro+lGVloK2dlYt23jouzsQBHz4osD9zmdEBurJaEi0qINGzaMtLQ07rvvPrZt28arr77K2rVrufDCC4MdmoQQt9fN+tz1FLoKSYtKq9VjDMPgxZUvMu2/0/CX+ol/J5787/JZ/NfF7N6+u8Fi8xt+cspyKKksoWdiT4ZmDK1T8U8k1DTb4lpycjKvv/46SUk1p4uWlZVpRoGI1I/FATHdwV8Fvsqjn9/ILhz1R4YM6E2YLZz1BelQVQybnwl2WII2mm5seZs2UVVaCgsWBA5ccEGgoGYYgcJbenqgY6iISAtlsViYPXs2eXl5nH/++SxevJgXX3yR9PT0YIcmIcLr97IpfxP7nftJi0rDZDId9TFVviqmfDGFN1e/CdkQNS+Koh1FxMbFMnvhbDp27dggsVV6K9lXuo9IWyRDMobQK7kXdqu2epCWrdn+5BoTE8MJJ5xQfdvv9zN//nyOOeYYzSgQkfpztAk0OCjbFfgziMxmM/NffoTUlETijB/h22sh65+QfiYkHRPU2Fo7u91OcXFxjWPaaLqBeDzcMmkS/1u9mtdKSjjTZgs0MgAoKQkU2dq2DW6MIiKNYMuWLTVud+jQgfnz5wcpGgllhmGwrWAbu4p2kRaVhtV89F/ryz3lTPxkIsv3L8e8zYz1AytlrjLad27Pc289R7tO7RokrgJXAW6fm64JXema0JXwsPCjP1CkBWi2M9d+bcaMGWzcuJE777xTMwpEpP5MpkBzA2s0eIqCHQ09unUkLjYa4vpC+5+Wxa1/VMtDg0wbTTeeXatWseirr9hfUkI7gHPPhaQk8PsDxbVOnQJ7r4mIiMhh7SraxdaCrSRFJNVq/7KCigLGLhnL8v3Lsa6yYrxt4HF5GHr8UOZ+OLdBCmtur5s9pXuwWWwMSR9C35S+KqxJqxISxbUZM2Ywb948ZsyYQffu3dW6WkR+n7AoiOkGHif4vcGOBgh80rd4Z3/W5bWByhxY8wAYvmCH1Wppo+lG4vfz3LPP4vf7OR3oa7HAlVcG7isshMREzVoTERH5DVnOLDblbyLGHkNE2NE/jNpfup/rP7yeLQVbiHfEc8sfbwEDzht9Hs8veJ6YuJjfHVNBRQF5rjw6x3dmWMYw0qPTa7VMVaQlabbLQg969NFHefvtt5kxYwann346EJhRsH379hrnaUaBiNRJeFuIyA4UsiIygh0Nj8x4jSnTX+X0E/vzr5uLA91Dt70M3W8Jdmit0i83mr755pv57LPPWLt2LVOnTg12aCGt+McfeePDDwGYADByZKCY5vWCywV9+oBNHcREREQOp6CigPW567GarcTYj14U2164nVuX3kp+RT7pUem8cNYLtI9tz+Dug+nVr9fvLoB5fB5yynKItkczKHkQGTEZmE0hMX9HpME163/5L7zwAgsXLmTmzJmcffbZ1cc1o0BEfjezBaK7gTkMqsqCHQ1XXnwWYWFW/v3lGj4tuyxwcOebkPN5UONqrbTRdON47YUXKHO56AucBnDNNYE78vMhNRXSatfpTEREpLUp85SxPnc9Hq+HpIiko56/JmcNN3x4A/kH8gl/O5wnBj1B+9jAfsO9+/f+3YW14spissuyaRfbjmEZw2gX206FNWnVmu2//h07djB79mxuuOEGBg8eTF5eXvWXWleLSIOwJ0BUZ3AXgOEPaiidO7blxqvPB2DCs//FnfbT/mvrJkP5niBG1nps2bKF4cOHV98+uNH0unXrWLJkCccdd1wQowt9VSUlzHrrLSAwa8108snQpQu43YH91jp3BoslmCGKiIg0S26vmw25GyhyFdEmqs1Rz/96z9fc/M+bcf7oxDrHimuLixf//GKDxOL1e9lXug+f4WNQ2iAGtBlAtD26QZ5bJJQ12+Laf/7zH3w+Hy+99BIjRoyo8aUZBSLSYCI7giMZKnODHQl/vvt6EhNiWbN+K/e/Z4G4/uAthx/uAa8r2OGJ/C6fLV7Mvvx8UoHR8POstby8wNJQbe0gIiJyCJ/fx+b8zex37ictOu2oM86Wbl/KXcvuwr3ZjXmuGW+Jl849OjP5mcm/O5aSyhL2O/eTHp3O8IzhdIjrgMWsD8ZEoBnvuTZ27FjGjh17xPvVulpEGoTFDtHdA3uc+SrBErzGKCnJCbz5/GRGXT6BmS+9zWnHP8YZjn1QtgM2PAb9Hgt0OxUJNV4vIzt2ZNWJJ7L3yy+xDxsGfftCRQWEhUGHDvq3LSIi8iuGYbCzaCc7i3bSJrINVvNv//q+cP1CnvrmKfgOTB+Z8Pv9DD1+KE++9iTRsfWfXeb1e8kpz8FusdM/tT8d4jocNRaR1qbZzlwTEWkyjpTADLbKXDCMoIZy7hkncuv1gSWhY+56lspej4HJAgf+DT++E9TYROqtoAB27mTQ8uX8H8C11waO5+dD+/aQkBDM6ERERJql/c79bMrfREJ4Anar/YjnGYbBy9+9zFP/fQo+AZaA4Tc456JzmDV/1u8qrJV5ytjv3E9yZDJDM4bSJaGLCmsih6F3hYiIyQTRXcCdB55CsCcGNZwZD9/Orj1ZTLrtahxtBkLlHbD5adjyDMT2hPgBQY1PpK5Kt24l5sMPA/ur9e0LQ4ZAaSlERgZmrYmIiEgNBRUFbMjbQLg1nChb1BHP8/l9PPm/J1m0aRF4ITk7mTzyGHvXWG6484Z6Ny7wG35yywPbpvRJ7kPn+M6EWcLq9VwirYGKayIiANbIwPLQwlUQFhPoIhokDoedJW8/+/OBDpdC8TrIXgarJ8GxC8Bx9C5RIs3B1lWrGHDqqVzp9zMbsByctVZUBJmZEK1NkEVERH7pYGfQKm8VadFH7qRd5avioc8f4uOdH2PCxKQ/TOLki05m1TerOP3/Tq/367uqXORW5JIckUyPpB6kRGpfVJGj0bJQEZGDwtMhIgNcOcGOpIYt239kremynzubrrkP/N5ghyVSK8/OnInL4yHL68XSpQuccAIUFkJcHLRrF+zwREREmpXadgatqKrgjn/fwcfffYx5lZknTnmCC3tfSFJKUr0La4ZhkFeeR1FlET0SezA0Y6gKayK1pOKaiMhBZgtEdws0NagqDXY0AHzy+XIGnXIFF90wmbLujwRm2BX9AFueC3ZoIkdVkJXF3PffB2ACBPZaMwwoK4MuXcARvAYiIiIizU1tO4MWVxYz7p/jWP7tcngD/B/6MW38fY2B3F43e0r3YLfaGZw+mN7JvXFYladFakvFNRGRX7LFQVQX8BSBvyrY0TCwXw/iY2PYumMPtz/2LmQ+HLjjx7cDTQ5EmrFXZs3C5fEwEDg5PR1OPTXQxCAlBdLTgx2eiIhIs1HbzqDZZdnc8OENbPhiA8wDyqFnZk8GDBtQ79cudBWSV5FHp7hODMsYRnp0er33ahNprVRcExH5taiOENEJKrLA8AU1lMSEOOa//Agmk4k5Cxbzzv880PmnPavWPwrO7UGNT+RI3C4Xz7/2GhCYtWa65prArLWqKujcGcK0KbKIiMhBtekMurt4N2P+MYZdS3fBe4AXRvxxBK8uepWk1Lrvx+v1e9lXug+AgWkD6d+mP5G2yN9zGSKtloprIiK/ZrZCXC8IT/upwGYENZyTRwzh/jsDBbWxdz7ObvsoSBwGvkr4YSJUlQU1PpHDWThnDtmFhaQDFycmwjnnQF5eYMZamyPvISMiItLa1KYz6Ma8jVz3j+vIfT8X/g0YcOFVF/LUnKeIiIyo82uWukvZ79xPenQ6w9sOp31se8wmlQdE6kvvHhGRw7E4IK4v2OLBdSDY0TB54liOHdqPUmc5o2+cjLfPI+BIhYo9sG4yGP5ghyhSw+yXXwbgNsB25ZXg94PJBJ06gVk/foiIiEDNzqAJ4QmHPef7A98z7p/jKNlYAisCx27/8+1MemISVuvhl48eic/vI8uZhdvnpn9qfwamDSTGHvN7L0Ok1dNPtyIiRxIWDXGZgUJbZX5wQwmz8tdXHyMmOpJvVq7l9Xc+hwHTwRQGuV/ArreCGp9IDeXlLD7lFKYAY6Oj4fzzA7PW2raFxMRgRyciItIs1KYz6P/2/o/xS8dTXlXOkBOGcO2d1zLt5WlcedOVdd4XrcxTxl7nXpIikhiWMYwuCV2OuLebiNSN3kkiIr/FnhCYwVb4PXhKwBYbtFA6tk/n1WceYN3G7Vx3xXkQZoXe98CGJ2DrbIjpBUnDgxafSLXcXFIXL2YywGWXBWatORyBWWvaIFlERKRGZ9CM6IzDFso+2fkJDyx6AJ/Nx4geI5h26jQc59S9g6ff8JNbngtAn+Q+dI7vjM1i+93XICI/08w1EZGjCU+D2D5Q5QRvRVBDueRPI3nsgZsJC/vps5G2f4KMUYAf1twPruygxidSVVEB774Lu3dDeDhcfDEUFkLHjhAbvOK0iIhIc1GbzqBLti7hvvn34XvNR+wHsTx2wmM4rHUvrFV6K9lXuo8oWxRD0ofQM6mnCmsijUDFNRGR2ojsADE9oDIPfO5gRwOAx1PF3LeXYPS6B2J6QlVJoMFBM4lPWqebr7mGPzz8cGBLmAsvDByMjoZ27YIZloiISLNxtM6g72x4hylvTMGYY0A5pNhScFfU/ee7gooC8ivy6ZLQhWEZw0iNSm2I8EXkMLQsVESkNkwmiO4G/koo2wnhGYGuokHi8/k4edSNfLNyLW6PhxsvfhK+uRJKN8L3d8GgpwJ7xYk0odWffspbH3yAx+ejymIJLAktKYEBAyAyMtjhiYiIBN3ROoO+ufpNXnztRVgM+GHoiKHMeH0GUdGH7yJ6OFW+KrLLsom2RzM4ffARl52KSMPRzDURkdoyWyCmd6Cw5soKaodOi8XCBeeeAsAdD8xkwx5XoMGBxQEF38J3t4G3PGjxSetTfOAAF155JR6fj3OB40aNCnQFTUyEjIxghyciIhJ0pe7SI3YGNQyDWctn8eLMF+HvgB/O+NMZzPrLrDoV1koqSzhQdoC2MW0ZljGMtjFtVVgTaQIqromI1IXFFmhwYE8C14GghnLnuNGM/MMxVFa6ueyGB6iMzIQhL4AlEoq+h5W3BvaJE2lkhs/HtZdfzo6sLDoCc81mTFdcARUV0KUL2A9d8iIiItKaON1O1mSvobiy+JDOoH7Dz/T/Tuet59+C/wSOXXXzVTwy6xHCbGG1en6f30eWMwuP30O/1H4MTBtItD26oS9DRI5AxTURkbqyRkJcZqCIVZkbtDDMZjPzXpxCSnIC6zZu557Jz0H8ABg2G8JioGQdrLwJPMVBi1Fah6cfeoi/f/YZNuA9IGHcuEBBrU2bwJeIiEgr5nQ7WZ29mkJXIenR6TVmknn9XqZ8PoX3N70PfSEiLoK7H7mb2x64DbO5dr+ul3vK2efcR1JEEsMyhtEloQsWs6WxLkdEDkPFNRGR+rDFBWawAXiKghZGm9Qk5r4wGYAXXn+XD//1ZaCz6bBXwBYPpVtgxViozA9ajNKyfbV0KfdOmwbAc8CQ004L7LXm80HnzmDV9q4iItJ6HZyxdrCwZjb9/Cu4x+fh3o/v5aPtH2ExWXjswsf46JuPuPS6S2v13IZhkFueS4m7hF5JvRicPviQ5aYi0jRUXBMRqa/wVIjtC14XeMuCFsaZpx7PHTddBsAdDzyN1+sNNF8Y9hrYkwMNGFaMBVd20GKUFqqqivYlJQwKC+MK4MZu3eChhyA/P7DPWnJysCMUEREJmjJPGWuy15BfkX9IYc1V5eLmv97M5/d9jnWnlRmnzeCMrmcQFVO7/dXcXjd7S/cSERbB0Iyh9Ezqic1ia6xLEZGj0MfJIiK/R0Rb8FVCyXowWYPWoXPaQ+MpdZbzwIQxWA/OFIrqCMNfgxXjoGIPLL8Bhr0UiFmkIezYQYeXXuIrtxtfbCymp58GjwdsNujUKdDQQEREpBX6ZWEtIyajRmGtzFPG2NfHsnXWVnBC4peJHPfocbV+7iJXEeVV5XSK70T3xO5EhEU0xiWISB3op14Rkd/DZILoLhDVNTAzzO8NShh2u403Zj1E544/F84qK92BQtrw1yCiHVQeCBTYynYHJUZpWbb+738wYwZ8+SV2i4WI6dMhJgacTujZExK0LEVERFqnck85a7LXkFeed0hhrchVxJXPXMnWpwKFtYwuGbzx7hs/fzj6G7x+L/tK92FgMChtEP1S+6mwJtJMqLgmIvJ7mcwQ2xMiO4IrCwxfsCPiw399SY/hF7Bx804IbxNYIhrVGdx5sOIGcG4LdogSwpYsWkSvESO4f84cDIAJE6BPHygqgt69oWPHIEcoIiISHOWectbkrCG3PPeQwlpueS6jHxnN3hf3ght6Du7JXxb/hTYZR2/+43Q72e/cT3p0OsMyhtEutl2N5xaR4NK7UUSkIZjDILY3OFKh4gAYRtBC8fv9PPrU6+zZl83J/3cja9ZvBUcSDHsVYnoEGjCsuBFKNgYtRgldu3bs4Mqrr8ZvGJQBplGjYNQoyM2F7t2hS5fAjE4REZFWptxTztqcteSW59I2pm2N4teWgi1cevel5L2VBz44ZuQxvPHuG8TExfzmc/oNPwecB6jwVtAvpR8D0wYS64ht7EsRkTpScU1EpKFYwwMdRG2x4NoPhj8oYZjNZpa+O4tB/XuSl1/EH/7vJr77YWOgw+nQlyE2E6pKYeU4KFodlBglNFVWVnLRqFEUl5czHHiqTx+4665AYa1rV+jRQ/usiYhIq1RRVcHanLXklOeQHlWzecHiLYsZ848xlB4oBeCcK87hudefw+6w/+Zzuqpc7C3dS5wjjmEZw+ia2BWrWdumizRH+glYRKQhhcVA/ACwJULFPvBXBSWMxIQ4/vO3lxg+uC9FxaX88U/j+GblWgiLhqEvQPwg8JbDd7dCwYqgxCih585x41i1cSOJwLsJCdimTw90Bu3UCXr1Aosl2CGKiIg0uYqqCtZkryG7LJv0qHQs5kA+rPRW8sgXj/DIl4/g9rk57rrjuPfpe5k8bTKW38iZhmGQX5FPUWURPRJ7MDRjKEkRSU11OSJSDyquiYg0NFscJAyGiPaBPdi8FUEJIy42mo8XvcgJxw6k1FnOyAtu5cv/fQ/WSBgyCxKPCXQ6XXUH5H4dlBgldMyfO5eX587FBMy3WGg/Y0agM2i7doF91sLCgh2iiIhIk6uoqmBNTqCwlhGdUV1Y21e6jwv/fCGLJy/G5Ddx85CbefacZ7nw0gsx/cb2CR6fh72lewmzhDE4fTC9k3tjt/72DDcRCT4V10REGoM1HOL7Q3RPcBeCpzgoYURHR7L0nVn88cRhlJVX8O7fPw7cYXHA4JmQchL4PfDD3ZD7RVBilObvQFYWN954IwB/Bs544IFAN9A2bQKNDOz6oV9ERFofV5WLtTlrOeA8UKOw9p+t/+Giqy8i+61s2AajvaMZM3DMURsQFFcWk12WTce4jgzPGE56dPpvFuJEpPlQcU1EpLGYrRDbCxIGBApYlTlBaXQQGRnOh3+dyTOPT+C5qXf/Ij4bDJgObU4DwwvrH4acz5o8Pmn+0rZs4RXD4DzgoYsvhkGDIDERMjMhIiLY4YmIiDQ5V5WLNTlrOOA8QNvotljMFrx+L9M+nMak0ZOoWlEFJrjslsu47abbfvO5vH4v+5z78BpeBqUNol9qPyJtkU10JSLSELQboohIYzKZILIDWMKheD1U7IeINDA17d5U4eEO7rhpdPVtr9fLyh82cuzQftD/scBMtv0fwu6/QL/JTRqbNHN79sDll3NFVRWXDxmCafRoiImBfv0gKirY0YmIiDS5X85YS48O7LFWUFHALc/cwvY3toMbbNE2ps+ezgmnnPCbz1XmKaPAVUB6dDo9k3oS54hrmosQkQalmWsiIk3BkQKJQwJ/lu8LzGQLEp/Px1U3T+aEs2/gnb8tCxT6+v4Zet4N3W4NWlzS/Pz9vffI/dOf4MABSE/HdPfdEBkZKKzFxgY7PBERkSZ3sLC237mf9Oh0rGYrq7NXc/5d57N9dqCw1q5POz74zwe/WVjzG36yy7Ip85TRJ7kPg9MGq7AmEsI0c01EpKmExUDCQCh2QMVusCcGmgs0McMwsFos+Hw+Ro99ELfbw1WXngMZ54Df2+TxSPP0zTffcNEll5BiGKyw28n4858DBbXMzMCSUBERkVYmrzyPbYXbfm5eYLKwYN0CZi2fha+tD5PNxFmXnMWDjzxImO3IjX4qvZXklOeQGJ5Ir+RepESmNOFViEhjUHFNRKQpWRwQnxloeODcGpjBZotv0hCsVitvvjAZu93G63/5O9fc+jBuTxU3XHZak8YhzVd+fj4Xn3UWXsPgeCB94sRAV9DMTEhNDXZ4IiIiTcpV5WJX0S52Fe/CMAzaRrfF5XXx4D8e5OviQMf10489nRuuvIGO7Tse8XkMw6DQVYjL66JrQle6JXQjPCy8ia5CRBqTimsiIk3NbIWYHoFZayUbwZUNjtTA/mxNxGKx8MrM+7HbwnjxjfcYe+fjuCuc3HrtqCaLQZonn8/H5Wefzb7iYroDr19yCaahQ6FvX8jICHZ4IiIiTebg0s2t+VsprCwkOSKZiLAItuZvZdy94yhZVoLlGgt3XXIXF/W+6Dc7ezrdTgorC4m1xzI4fTAZ0RnqBCrSgqi4JiISDCYTRLYLzGQr2QAV+yA8LVB4ayJms5nnp0/E4bDz9IvzGf/ALJITorlk7IlNFoM0L2VlZdx85ZUsW7GCcOD9/v2JueQS6NUL2rcPdngiIiJNxul2sr1wO3tK9uCwOmgf0x6TycSiVYuYfvd0/Fv9AJzhP4OL+1x8xOcp85RR6CokwhZBn+Q+tIttR0SYOm2LtDQqromIBJMjGSyDAwU2135wtAGLvcle3mQyMePh23HYbXz21QrOPvWYJnttaV727NnDqcOHsy07GxPwWmIimffcEyisde7cpDMrRUREgsXr97K/dD9bC7ZSXlVOSkQKdqudjbkbmTFvBuvmrINSMIWZuOuxu7j0iksP+zyuKhf5Ffk4whx0T+xO+9j2RNujm/hqRKSpqLgmIhJsYdEQPzAwi825C+wJEBbVZC9vMpl47IGbcZddij1MTaRbpdJS0iZOJCE7m7bAgjZtOPHBBwNdQbt1A7P+XYiISMtX6CpkW8E2spxZxNhjaBfTju8PfM8zf32GTQs2QU7gvJj0GGbPnU3PPj0PeY5KbyX5FflYzVY6J3SmQ2wHYh3qsC3S0qm4JiLSHFjsEJsJlshAo4OqUnCkNOkyUbvdpm6hrUx2djYJa9diu+46wvbt4z0g8txzSbj8cujRIzBrzWIJdpgiIiKNyu11s7t4NzuLdlLlryItKo2VWSuZ88McVueshgNADljsFs689Ezuvu9uoqJrfhDq8XnIr8jHhIn2se3pENeBhPCEoFyPiDQ9FddERJoLswWiuwa6h5btANeBQFdRWwKYNHNIGtaSv/2Nay+/nOtcLqYBpKTQ7tZbYfhw6No10B3Uqh8TRESk5TIMg9zyXLYVbCO3Ipd4Rzwrt63khZdeIM+TB8MgzBzGOeeeQ1KXJC699FJi42vOQqvyVZFfkY8fP2lRaXSK70RieKKaFYi0MvqpWUSkOTGZwJEUKLC5sgJFtoq9gQJbmPbpkN+vsrKSidddx/N//SsAHwMP/+EP2K+/PjBTrUsXiIkJbpAiIiKNrKKqgh2FO9hdvBu/4eebzd/w2kuvUfJVCVQCEXDJ5Zdw9dCrSYlMgZNqPt7r91JQUUCVv4rUqFQ6xXUiOTIZsz4QFWmVVFwTEWmOzJZAN1FHMpT/CGW7wVPyUwOEpmt4IC3LxnXruHTkSNZlZwNwh83GtFtuwT5qVGBvtbQ07a8mIiItmtfvJbssmy35W8iryOOTVZ+w8LWFlC8vh592x4htG8vY8WO54PgLsIbV/JXZ5/dR6Cqk0ltJSlQKneI6kRKZgsWsbRREWjMV10REmjOLA2J6BLqIOneCay+YLIEim0k/xEntGIbBK088wZ0PPUSl308KMLdLF86cMgUGDYJOnSA8PNhhioiINAq/4ae4spiCigKynFlkObP4dNenvP3W25R/UA5G4LyU7imMnzCe088+HfMvPmzy+X2UecooqyrDb/hJCE+gb2pf2kS1wdqE++OKSPOl/wlEREKBLRYSBkBlGjh3QMX+wDLRsLjAUlKRIzEMsmbO5J4HH6QSON1sZt4VV5B6443QvTskJQU7QhERkQZnGAZlnjIKXIGCWn55PhtzN/Ldju/4OOdjSt2l0CZwbvuB7Zlw9wSOP+n46r3SfH4fTo+TMk8ZAFG2qOqln4nhiYRZwoJ1aSLSDKm4JiISKkwmCG8D9sRAcc35035s9iSwRgQ7OmmOcnPh+uvJ+PBDXgJyk5O5Y/p0zCedFGhYEKZfDEREpGVxVbkocBVwwHmALflbWPb9MpZ/uZyd3+3Eu90L7YHR0D6mPVefeDWZl2TSuUtnILBktMxdVl1Qi7ZH0y2hG4kRicSHx2Oz2IJ4ZSLSnKm4JiISasxhENUxsDS0bDeU7wZPEThSAvdJq1dVVcWU0aP547JlnFJaChYLV4weDbfdFpitpoYFIiLSgnh8HopcRewp2cN/dv2Hvy/+Oxv/txHnJicU1jzXnm/noZMf4tQup2IxW/D6vRS6CqmoqsBkMhFti6ZHUg8SwxOJc8RphpqI1IqKayIiocoaCXF9ArPZynZCRVZgjzZ7AqhTVatU5nTy7vTpPD97NquLipgLbGnblqjJk+HMM9WwQEREWgyf30eRq4hvfvyG+Z/MZ4djB+ty1+HxeeBd4MefTjRDao9Uhp84nHPPPJfMgZn4TYE92MqryrGarcTYY+gQ24GEiATiHHHaR01E6kz/a4iIhDp7YmDvtfB0cG4PLBk1h4EtLlBskxbNMAyWL1nCG48+ysJVqyjz+wGIBZ4dPpyol16Cnj3VsEBEREKaz++j3FPO1oKtfPjNh/zto7+xZcUWPNs94AbuASIhKSKJ9JHphOeHc9bpZ3HsiGMJiwij0luJ2+cmqzwLm8VGjD2GzvGdiQ+PJ84Rp26fIvK7qLgmItISmC0QkQH2ZHDnBQps7jzweyAsJvCl2Wwti9sNixdz/733Mm3nzurDXYHrOnfm2nHjSL3mGjUsEBFpxtxuNw8//DDLli3D4XAwZswYxowZE+ywgs7pdrJ813K2FG1hW8k2NudvZs2na8hZloORbwSKab9gibTwp5Q/ce6p55IenY7b56bKXwUGeCwezIaZ+Ih44u3xRNoiibRFEmOPwayfjUSkgai4JiLSklhsgSJbeDpUlUBlDlTs02y2FsLn9fLJSy/Reflyun30ERQVcSbwLHBRbCzXnXEGJ06ciKlz58C+aloCKiLSrD355JOsX7+eefPmkZWVxaRJk0hPT+eMM84IdmiNzjAMfiz8kc9++Iz/rv4v6zatY8+OPRTuK8ST6wEncBXQ+acHFAH7f/q7BZJ7JNP/uP6ceuqpdO3bFYvZgt1qx2K2kBaeRlx4HBFhEYRbw4kIi9DeaSLSqFRcExFpiUymQCHNFgeRHcFdECiyaTZbSNq9ciVv3n8/b37xBXurqrgVeB4gKYkTRo7kwFlnEXfGGRAXBxYtaxERCQUVFRW89957vPbaa/Tp04c+ffqwbds2FixYELLFNcMwKK0sZXvWdnbs38Gu/bvYe2AvWTlZ5OTmUFBQQPTgaFzJLnYX76Z8eTksPvLzpXnT6Nu5L+nR6UR2j6Tq2Cp69exFu47tiI6MxmFxEB8eT6w9lvCw8OpimpZ4ikhTU3FNRKSls9ghIh3C0zSbLYS4nU7+Pnkyb/zlL3ySn4/x0/F4IK5jR5gwAc4/H1NKCnFh+jReRCTUbN68Ga/Xy8CBA6uPDR48mJdffhm/34+5iWcf+/1+isqKyC/JJ684j7DIMPxhfsqryvlx74+sXbWWUmcpzjInzjInJaUlFBUUUVJYQvSJ0VRmVJJXnod7tRsWHeXFBgf+MCWZIAwcbRzEZ8ST3iGdzl07069PP/r07EN8fDwRYRGBollYODaLjTBzGGGWMMKt4TisDkwmU6N/b0REjkbFNRGR1qLGbLZO4M4H136ozA3MZjOHgVmb3jcHxkcfMWTUKNb7fNXH/hgZyXV//CN/uu8+HAMHgt0exAhFROT3ysvLIz4+HpvNVn0sKSkJt9tNcXExCQkJjfbaWc4szvjzGWxasAm/24/f4wcPVH+SA3ABkPnT3zcS6MB5BDltciD6pxuRgT9MdhPWKCu2GBvhMeFExkUSEx9Dv5P70WdQH9rFtKNLfBdip8YSYYsgzBwWKJ5ZwmoU0UREQoGKayIirZHF9qvZbLlQsTdQYEOfAAeb6csvOdvno8hs5to+fbh23Dg6X3klREUFOzQREWkgLperRmENqL7t8Xga9bW3FWxjXdY6yD/CCRaIsEQQGxWLw+rAaGeQ1yWPMEcYYY4wbOE2wiPCiUuMIzExkQHHDmBgv4GkR6eTYE8g4ukIIhwRWMwWrGYrFpMFi9lS40/NOBORlkTFNRGR1uzXe7P5XGBWagi6hx/mwTPO4PGePbG0aRPsaEREpBHY7fZDimgHbzscjbtdw4kdTuQ/D/2Hb/7vG6KjokmMSSQ5LpnU+FRS4lOIckRhNVsxm8yYTCbMJjPmGWZMmFQUExE5DP0GJSIiARZb4Euqud1uHn74YZYtW4bD4WDMmDGMGTOm8V/Ybifq5JMb/3VERCRoUlNTKSoqwuv1YrUGfi3Ly8vD4XAQExPTqK9tMpk4pe8pnNL3lEZ9HRGR1kLFNRERkSN48sknWb9+PfPmzSMrK4tJkyaRnp4esl3cRESk+ejVqxdWq5XVq1czZMgQAFatWkVmZmaTNzMQEZHfR/9ri4iIHEZFRQXvvfceDzzwAH369OG0007j+uuvZ8GCBcEOTUREWoDw8HDOO+88pkyZwtq1a/nkk0+YM2cOV111VbBDExGROlJxTURE5DA2b96M1+tl4MCB1ccGDx7MmjVr8Pv9QYxMRERaivvuu48+ffpw9dVX8/DDDzN+/HhGjhwZ7LBERKSOtCxURETkMPLy8oiPj6/RyS0pKQm3201xcTEJCQlBjE5ERFqC8PBwpk+fzvTp04MdioiI/A6auSYiInIYLperRmENqL796+5uIiIiIiLSeqm4JiIichh2u/2QItrB2w6HIxghiYiIiIhIM6TimoiIyGGkpqZSVFSE1+utPpaXl4fD4SAmJiaIkYmIiIiISHOi4pqIiMhh9OrVC6vVyurVq6uPrVq1iszMTMxmpU8REREREQkI6d8O3G43999/P0OGDGHEiBHMmTMn2CGJiEgLER4eznnnnceUKVNYu3Ytn3zyCXPmzOGqq64KdmgiIiIiItKMhHS30CeffJL169czb948srKymDRpEunp6ZxxxhnBDk1ERFqA++67jylTpnD11VcTFRXF+PHjGTlyZLDDEhERERGRZiRki2sVFRW89957vPbaa/Tp04c+ffqwbds2FixYoOKaiIg0iPDwcKZPn8706dODHYqIiIiIiDRTIbssdPPmzXi9XgYOHFh9bPDgwaxZswa/3x/EyEREREREREREpLUI2eJaXl4e8fHx2Gy26mNJSUm43W6Ki4uDF5iIiIiIiIiIiLQaIVtcc7lcNQprQPVtj8cTjJBERERERERERKSVCdk91+x2+yFFtIO3HQ7HUR9vGAYAZWVlDR+ciEgrFRkZiclkCnYYzYLyjIhI41CuCVCeERFpHPXJMyFbXEtNTaWoqAiv14vVGriMvLw8HA4HMTExR318eXk5ACeddFKjxiki0pqsWrWKqKioYIfRLCjPiIg0DuWaAOUZEZHGUZ88E7LFtV69emG1Wlm9ejVDhgwBAt+AzMxMzOajr3ZNSUnhiy++0CdfIiINKDIyMtghNBvKMyIijUO5JkB5RkSkcdQnz5iMg/OJQ9BDDz3E999/zxNPPEFubi6TJk1i6tSpjBw5MtihiYiIiIiIiIhIKxDSxTWXy8WUKVNYtmwZUVFRXHfddVxzzTXBDktERERERERERFqJkC6uiYiIiIiIiIiIBNPRNycTERERERERERGRw1JxTUREREREREREpJ5UXBMREREREREREaknFddERERERERERETqScU1ERERERERERGRelJx7Qjcbjf3338/Q4YMYcSIEcyZM+eI527cuJGLLrqI/v37c8EFF7B+/fomjLRu6nJd48aNo0ePHjW+PvvssyaMtm48Hg/nnHMOy5cvP+I5oTRWB9XmukJlrHJycrjtttsYNmwYJ5xwAlOnTsXtdh/23FAaq7pcV6iMFcCPP/7Iddddx8CBAzn55JN5/fXXj3huKI1Xc6E8E1rvB1CeCYWxUp4JnbEC5Zmm0BJzTUvOM9Ayc01LyjPQMnON8kwDjJUhh/XII48Y5557rrF+/Xpj2bJlxsCBA42lS5cecl55eblx/PHHG9OmTTO2b99uPProo8Zxxx1nlJeXByHqo6vtdRmGYZx22mnGP/7xDyM3N7f6y+12N3HEtVNZWWnccsstRvfu3Y1vv/32sOeE2lgZRu2uyzBCY6z8fr9x8cUXG9dff72xdetWY+XKlcZpp51mTJs27ZBzQ2ms6nJdhhEaY2UYhuHz+YyRI0cad911l7Fr1y7j888/NwYNGmQsXrz4kHNDabyaE+WZ0Hk/GIbyTCiMlfJMQCiMlWEozzSVlphrWmqeMYyWmWtaUp4xjJaZa5RnGmasVFw7jPLyciMzM7PGm//FF180rrjiikPOfe+994xTTjnF8Pv9hmEE/mGedtppxqJFi5os3tqqy3W53W6jV69exs6dO5syxHrZtm2bMWrUKOPcc8/9zf+0Q2msDKP21xUqY7V9+3aje/fuRl5eXvWxDz/80BgxYsQh54bSWNXlukJlrAzDMHJycozbb7/dcDqd1cduueUWY/LkyYecG0rj1Vwoz4TW+0F5JjTGSnkmdMbKMJRnmkJLzDUtNc8YRsvMNS0tzxhGy8w1yjMNM1ZaFnoYmzdvxuv1MnDgwOpjgwcPZs2aNfj9/hrnrlmzhsGDB2MymQAwmUwMGjSI1atXN2XItVKX69q5cycmk4l27do1dZh1tmLFCoYPH84777zzm+eF0lhB7a8rVMYqOTmZ119/naSkpBrHy8rKDjk3lMaqLtcVKmMFkJKSwrPPPktUVBSGYbBq1SpWrlzJsGHDDjk3lMaruVCeCa33g/JMaIyV8kzojBUozzSFlphrWmqegZaZa1panoGWmWuUZxpmrKwNFXhLkpeXR3x8PDabrfpYUlISbreb4uJiEhISapzbtWvXGo9PTExk27ZtTRZvbdXlunbu3ElUVBQTJ05kxYoVtGnThvHjx3PSSScFI/TfNHr06FqdF0pjBbW/rlAZq5iYGE444YTq236/n/nz53PMMccccm4ojVVdritUxurXTjnlFLKysvjDH/7A6aeffsj9oTRezYXyTGi9H5RnQmOslGdCZ6x+TXmmcbTEXNNS8wy0zFzT0vIMtMxcozzTMGOlmWuH4XK5avyHDVTf9ng8tTr31+c1B3W5rp07d1JZWcmIESN4/fXXOemkkxg3bhzr1q1rsngbWiiNVV2E6ljNmDGDjRs3cueddx5yXyiP1W9dV6iO1axZs3j55ZfZtGkTU6dOPeT+UB6vYFGeCd33w28JpbGqi1AdK+WZ0Bkr5ZnG0RJzTWvPMxA6Y1UXoTxWLTHXKM8E1HWsNHPtMOx2+yHfxIO3HQ5Hrc799XnNQV2u6+abb+bKK68kNjYWgJ49e7JhwwbeffddMjMzmybgBhZKY1UXoThWM2bMYN68eTzzzDN07979kPtDdayOdl2hOFZAdWxut5u7776biRMn1kg+oTpewaQ8E7rvh98SSmNVF6E4VsozoTNWoDzTWFpirmnteQZCZ6zqIlTHqiXmGuWZn9V1rDRz7TBSU1MpKirC6/VWH8vLy8PhcBATE3PIufn5+TWO5efnk5KS0iSx1kVdrstsNle/YQ7q3LkzOTk5TRJrYwilsaqLUBurRx99lDfffJMZM2YcdkouhOZY1ea6Qmms8vPz+eSTT2oc69q1K1VVVYfsvxCK4xVsyjOh9X6orVAaq7oItbFSngmNsVKeaXwtMde09jwDoTNWdRGKY9USc43yzO8bKxXXDqNXr15YrdYam9etWrWKzMxMzOaa37L+/fvzww8/YBgGAIZh8P3339O/f/+mDLlW6nJd9957L/fdd1+NY5s3b6Zz585NEWqjCKWxqotQGqsXXniBhQsXMnPmTM4+++wjnhdqY1Xb6wqlsdq3bx+33nprjUS5fv16EhISauxnAqE3Xs2B8kxovR9qK5TGqi5CaayUZ0JnrJRnGl9LzDWtPc9A6IxVXYTaWLXEXKM80wBjVeu+oq3Mn//8Z+Pss8821qxZY3z88cfGoEGDjH//+9+GYRhGbm6u4XK5DMMwDKfTaRxzzDHGo48+amzbts149NFHjeOPP94oLy8PZvhHVNvr+ve//2306dPH+Nvf/mbs3r3beP75541+/foZe/fuDWb4R/XrFs+hPFa/9FvXFSpjtX37dqNXr17GM888Y+Tm5tb4MozQHau6XFeojJVhGIbX6zXOP/98Y8yYMca2bduMzz//3DjuuOOMuXPnGoYRuuPVnCjPhM774ZeUZ5rvWCnPhM5YGYbyTFNpibmmpecZw2iZuaYl5BnDaJm5RnmmYcZKxbUjqKioMCZOnGgMGDDAGDFihPHmm29W39e9e3dj0aJF1bfXrFljnHfeeUZmZqZx4YUXGhs2bAhCxLVTl+t69913jZEjRxp9+/Y1/vSnPxkrVqwIQsR18+v/tEN5rH7paNcVCmP1yiuvGN27dz/sl2GE7ljV9bpCYawOys7ONm655RZj0KBBxvHHH2+89NJLht/vNwwjdMerOVGeCa33w0HKM813rJRnAkJhrA5Snml8LTHXtPQ8YxgtM9e0hDxjGC0z1yjPBPzesTIZxk/z3kRERERERERERKROtOeaiIiIiIiIiIhIPam4JiIiIiIiIiIiUk8qromIiIiIiIiIiNSTimsiIiIiIiIiIiL1pOKaiIiIiIiIiIhIPam4JiIiIiIiIiIiUk8qromIiIiIiIiIiNSTimsiR3HvvffSo0ePI3598MEH9OjRg3379jVJPIZhcOWVV7Jjxw4uvfRSzj//fPx+f41zqqqqOOuss5gwYUKdn/+///0vd911V0OFKyIitaBcIyIijUl5RqRxmQzDMIIdhEhz5nQ6qaysBOCjjz5izpw5vP/++9X3x8bGUlJSQkJCAhaLpdHj+eCDD1i+fDnTp09n06ZNXHDBBTz88MNcdNFF1ee8+eabzJ49m6VLl5KUlFTn17jiiisYP348w4cPb8jQRUTkCJRrRESkMSnPiDQuzVwTOYro6GiSk5NJTk4mOjoai8VSfTs5ORmbzUZycnKTJCHDMHjppZe47LLLAOjVqxejR49m5syZOJ1OAPLz83nhhRe466676pWEAEaPHs3s2bMbLG4REfltyjUiItKYlGdEGpeKayK/0759+2pMoe7RowdLly7lzDPPpH///kyYMIG9e/dy1VVX0b9/f0aPHk1OTk714z/++GPOOuss+vfvz4UXXsiKFSuO+Fpff/01LpeL/v37Vx+7/fbbMZvN1Ynj6aefplu3blxyySXV5/To0YPnnnuO4cOHc9NNN1FVVcWDDz7I8OHDGThwIDfddFONmE488URWrVrFzp07G+z7JCIi9adcIyIijUl5RuT3UXFNpBHMmjWLadOm8corr7Bs2TIuu+wyLrvsMhYuXEheXh6vvfYaAJs3b2bSpEmMGzeOxYsXM2rUKG644QZ+/PHHwz7vV199xbHHHovJZKo+Fh0dzT333MP8+fP59NNPWbJkCY888kiNcwA+++wz3n77be6++24WLFjAypUrq6eDl5eX88QTT1SfGxUVRWZmJl9//XUjfHdERKQhKNeIiEhjUp4RqT1rsAMQaYmuueaa6k9ievXqRadOnTjzzDMBGDlyJJs3bwbgjTfe4OKLL+bcc88F4KqrrmLlypW8/fbb3HvvvYc878aNGxkxYsQhx8877zzee+89xo8fz5gxY+jevfsh51xyySV07twZgIULF2K328nIyCAuLo5p06ZRXFxc4/yuXbuycePG+n8TRESkUSnXiIhIY1KeEak9zVwTaQTt2rWr/rvD4SAjI6PGbY/HA8COHTuYP38+AwcOrP767LPP2L1792Gft7CwkPj4+MPeN3bsWLxeL7fccsth7/9lDJdccgl5eXmMGDGCMWPG8MUXX9ClS5ca58fFxVFQUFCr6xURkaanXCMiIo1JeUak9jRzTaQR/HojULP58HVsn8/HDTfcwHnnnVfjuMPhOOz5JpMJn8932PsOPuZIj7Xb7dV/79atG59++imff/45n3/+OTNnzmTJkiUsWLCgeuq13+8/YtwiIhJ8yjUiItKYlGdEak/FNZEg6tSpE/v27aNDhw7Vx5588kk6depUow31QYmJiYdMda6Pv//979hsNs466yzOPPNMVq9ezSWXXEJBQUF1N56ioqJ6d+YREZHmQ7lGREQak/KMiJaFigTVNddcw0cffcRbb73Fnj17mDt3LnPnzqVjx46HPb93795s2bLld7+u0+nk8ccf55tvvmHv3r18+OGHtGnTpsb07C1bttC7d+/f/VoiIhJcyjUiItKYlGdENHNNJKgGDBjAk08+yfPPP8+TTz5J+/btefrppxk6dOhhzz/hhBO49957MQzjkM45dXH55ZeTnZ3NPffcQ0lJCX379uWll16qnvpdXl7Oli1bOPHEE+v9GiIi0jwo14iISGNSnhEBk2EYRrCDEJHa8fl8nH766UydOvWIyaoh/O1vf+Mf//gHc+fObbTXEBGR5km5RkREGpPyjLREWhYqEkIsFgtjx45l4cKFjfo677zzDmPHjm3U1xARkeZJuUZERBqT8oy0RCquiYSYCy+8kKysLHbs2NEoz//VV1+RlpbGcccd1yjPLyIizZ9yjYiINCblGWlptCxURERERERERESknjRzTUREREREREREpJ5UXBMREREREREREaknFddERERERERERETqScU1ERERERERERGRelJxTUREREREREREpJ5UXBMREREREREREaknFddERERERERERETqScU1ERERERERERGRelJxTUREREREREREpJ7+H/oa8DK5ZKk8AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    dynamic_intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_dynamic_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    dynamic_intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_dynamic_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    dynamic_intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_dynamic_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Draw horizontal line at lockdown trigger\n",
+    "ax[1].axhline(lockdown_trigger.I, color=\"grey\", linestyle=\"-\")\n",
+    "ax[2].axhline(lockdown_lift_trigger.R, color=\"grey\", linestyle=\"-\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Again, we can represent uncertainty about the interventions themselves."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:19.613896Z",
+     "start_time": "2023-07-18T18:47:19.533372Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def uncertain_dynamic_intervened_sir(lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    lockdown_trigger = State(I=pyro.sample(\"lockdown_trigger\", dist.Uniform(30.0, 40.0)))\n",
+    "    lockdown_lift_trigger = State(R=pyro.sample(\"lockdown_lift_trigger\", dist.Uniform(20.0, 30.0)))\n",
+    "    return dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.507420Z",
+     "start_time": "2023-07-18T18:47:19.564083Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "uncertain_dynamic_intervened_sir_predictive = Predictive(uncertain_dynamic_intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "uncertain_dynamic_intervened_sir_posterior_samples = (uncertain_dynamic_intervened_sir_predictive(lockdown_strength, init_state_lockdown, logging_times))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.783573Z",
+     "start_time": "2023-07-18T18:47:24.508114Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x188abaf90>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_dynamic_intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_dynamic_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_dynamic_intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_dynamic_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_dynamic_intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_dynamic_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Draw horizontal line at lockdown trigger\n",
+    "ax[1].axhline(lockdown_trigger.I, color=\"grey\", linestyle=\"-\")\n",
+    "ax[2].axhline(lockdown_lift_trigger.R, color=\"grey\", linestyle=\"-\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Modeling a superspreader event using counterfactual inference\n",
+    "\n",
+    "Suppose at time $t=0.3$ (`superspreader_time`), there is a superspreader event that results in a rapid infection a large number of people that would have otherwise remained susceptible. We model this as an instantaneous infection of 15 million people (`superspreader_delta`). One month later, suppose that a plane entering a foreign country holds 4 infected individuals (`landing_data`). We would like to answer the following counterfactual questions: if the superspreader event never occured, how many infected people would be on the plane?\n",
+    "\n",
+    "Counterfactuals become interesting when noise is plausibly shared between the factual and counterfactual worlds. Our noise model for the number of infected passengers comprises two sources of noise: one that we assume is shared between the factual and counterfactual regimes, and another that is not. This latter noise encapsulates an aggregation of unknowns that may differ across the factual and counterfactual regimes. The former, however, stems from the precision of a specific infection-screening machine used by the airline to deny boarding to infected would-be passengers. This machine was built before the superspreader event, and we assume its performance is the same across factual and counterfactual worlds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.883515Z",
+     "start_time": "2023-07-18T18:47:24.780163Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# This allows us to specify non-continuous dynamics that won't be affected by e.g. counterfactual handlers.\n",
+    "class NonContinuousDynamics(StaticInterruption, _InterventionMixin):\n",
+    "    def _pyro_apply_interruptions(self, msg) -> None:\n",
+    "        with pyro.poutine.block(hide_types=[\"intervene\"]):\n",
+    "            super()._pyro_apply_interruptions(msg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Superspreader Time tensor(0.2900)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ss_time = logging_times[torch.searchsorted(logging_times, .25)]\n",
+    "print(\"Superspreader Time\", ss_time)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.883741Z",
+     "start_time": "2023-07-18T18:47:24.813977Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "landing_time = ss_time + 4/52 + 1e-4\n",
+    "landing_data = {\"infected_passengers\": torch.tensor(4.)}\n",
+    "\n",
+    "# Because counterfactuals assume the intervened state is the counterfactual world, we have to hackily invert\n",
+    "# this by treating the superspreader event as factual non-continuous dynamics, and the counterfactual as an\n",
+    "# inversion of superspreader infections immediately following the superspreader event.\n",
+    "\n",
+    "superspreader_delta = torch.tensor(15.)\n",
+    "\n",
+    "# HACK counterfactual inverts the factual intervention slightly afterward.\n",
+    "inverse_superspreader_intervention = State(\n",
+    "    S=lambda s: s + superspreader_delta,\n",
+    "    I=lambda i: i - superspreader_delta,\n",
+    ")\n",
+    "inverse_superspreader_time = ss_time + 2e-3\n",
+    "\n",
+    "superspreader_intervention = State(\n",
+    "    # The superspreader event instantaneously subtracts from the susceptible group and adds to the\n",
+    "    # infected group.\n",
+    "    S=lambda s: s - superspreader_delta,\n",
+    "    I=lambda i: i + superspreader_delta,\n",
+    ")\n",
+    "superspreader_time = inverse_superspreader_time - 1e-3\n",
+    "\n",
+    "superspreader_intervention = NonContinuousDynamics(\n",
+    "    time=superspreader_time, \n",
+    "    intervention=superspreader_intervention\n",
+    ")\n",
+    "\n",
+    "inverse_superspreader_intervention = StaticIntervention(\n",
+    "    time=inverse_superspreader_time, \n",
+    "    intervention=inverse_superspreader_intervention\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def get_num_infected_passengers(num_infected_in_millions: torch.Tensor, c=2.):\n",
+    "    # Our model assumes that a given set of passengers on a plane are derived by drawing c passengers\n",
+    "    # randomly from each million people in the country of origin.\n",
+    "    number_of_individuals_infected = num_infected_in_millions * 1e6\n",
+    "    return c * 1e-6 * number_of_individuals_infected\n",
+    "\n",
+    "\n",
+    "class PlaneSuperSpreaderSIR(SimpleSIRDynamics):\n",
+    "    def observation(self, X: State[torch.Tensor]):\n",
+    "        if X.I.shape and X.I.shape[-1] > 1:\n",
+    "            super().observation(X)\n",
+    "        else:\n",
+    "            # An airline builds screening machines that detect infections in passengers. If\n",
+    "            # passengers are infected, they are denied boarding. These screening machines were built\n",
+    "            # before the super-spreader event, so their effectiveness (modeled as 0-1 accuracy rate) is\n",
+    "            # the same between the factual and counterfactual worlds. \n",
+    "            \n",
+    "            enittb = expected_num_infected_trying_to_board = get_num_infected_passengers(X.I)\n",
+    "            # The number trying to board is subject to noise we do not assume is shared between worlds.\n",
+    "            num_infected_trying_to_board = pyro.sample(\"nittb\", dist.Normal(enittb, 1.0))\n",
+    "            \n",
+    "            # The screening machines have some effectiveness rate that is shared between worlds.\n",
+    "            # This is a value between 0 and 1.\n",
+    "            se_frate = torch.sigmoid(pyro.sample(\"u_ip\", dist.Normal(0., 2.)))\n",
+    "            \n",
+    "            infected_passengers = se_frate * num_infected_trying_to_board\n",
+    "            pyro.deterministic(\"infected_passengers\", infected_passengers, event_dim=0)\n",
+    "            \n",
+    "            # The arrival country has 100% accurate tests and test all passengers on arrival, hence the\n",
+    "            # ability to observe number of infected passengers directly.\n",
+    "\n",
+    "\n",
+    "def conditioned_sir_reparam(data, init_state, logging_times, base_model=PlaneSuperSpreaderSIR) -> None:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "    reparam_config = AutoSoftConditioning(scale=.1, alpha=0.5)\n",
+    "    with SimulatorEventLoop():\n",
+    "        with pyro.poutine.reparam(config=reparam_config):\n",
+    "            with StaticObservation(time=landing_time, data=landing_data):\n",
+    "                with TrajectoryObservation(data):\n",
+    "                    with superspreader_intervention:\n",
+    "                        simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "\n",
+    "\n",
+    "def counterfactual_sir(data, init_state, logging_times) -> Trajectory:\n",
+    "    sir = bayesian_sir(PlaneSuperSpreaderSIR)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        with SimulatorEventLoop():\n",
+    "            with StaticObservation(time=landing_time, data=landing_data):\n",
+    "                with superspreader_intervention:\n",
+    "                    with TrajectoryObservation(data):\n",
+    "                        with TwinWorldCounterfactual() as cf:\n",
+    "                            with inverse_superspreader_intervention:\n",
+    "                                simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    trajectory = dt.trace\n",
+    "    with cf:\n",
+    "        factual_indices = IndexSet(\n",
+    "        **{k: {0} for k in indices_of(trajectory, event_dim=0).keys()}\n",
+    "        )\n",
+    "\n",
+    "        cf_indices = IndexSet(\n",
+    "            **{k: {1} for k in indices_of(trajectory, event_dim=0).keys()}\n",
+    "        )\n",
+    "       \n",
+    "        factual_traj = gather(trajectory, factual_indices, event_dim=0)\n",
+    "        cf_traj = gather(trajectory, cf_indices, event_dim=0)\n",
+    "        \n",
+    "        # This is a small trick to make the trajectory variables available to pyro    \n",
+    "        for k in get_keys(trajectory):\n",
+    "            pyro.deterministic(k + '_factual', getattr(factual_traj, k))\n",
+    "            pyro.deterministic(k + '_cf', getattr(cf_traj, k))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expected Number of infected people trying to board in superspreader reality: X.I = 24.08 Million\n",
+      "Expected Screening Failure Rate = 0.08\n",
+      "Expected u_ip -2.4\n",
+      "True # Infected Passengers Factual =  4.0\n",
+      "Number of infected people trying to board in counterfactual reality: X.I = 5.04 Million\n",
+      "True # Infected Passengers Counterfactual =  0.84\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "with SimulatorEventLoop():\n",
+    "    with superspreader_intervention:\n",
+    "        num_infected_in_millions = simulate(sir_true, init_state, torch.tensor(0), landing_time, solver=TorchDiffEq()).I.item()\n",
+    "        expected_num_infected_passengers = get_num_infected_passengers(num_infected_in_millions)\n",
+    "        print(\"Expected Number of infected people trying to board in superspreader reality: X.I =\",\n",
+    "              round(num_infected_in_millions, 2), \"Million\")\n",
+    "        expected_actual_screening_rate = landing_data['infected_passengers'] / expected_num_infected_passengers\n",
+    "        print(\"Expected Screening Failure Rate =\", round(expected_actual_screening_rate.item(), 2))\n",
+    "        print(\"Expected u_ip\", round(torch.logit(expected_actual_screening_rate).item(), 2))\n",
+    "        print('True # Infected Passengers Factual = ', landing_data['infected_passengers'].item())\n",
+    "\n",
+    "with SimulatorEventLoop():\n",
+    "    with superspreader_intervention:\n",
+    "        with inverse_superspreader_intervention:\n",
+    "            num_infected_in_millions = round(simulate(sir_true, init_state, torch.tensor(0), landing_time, solver=TorchDiffEq()).I.item(), 2)\n",
+    "            expected_num_infected_passengers = get_num_infected_passengers(num_infected_in_millions)\n",
+    "            print(\"Number of infected people trying to board in counterfactual reality: X.I =\",\n",
+    "                  num_infected_in_millions, \"Million\")\n",
+    "            true_cf_infected = expected_num_infected_passengers * expected_actual_screening_rate\n",
+    "            print(\"True # Infected Passengers Counterfactual = \", round(true_cf_infected.item(), 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.956013Z",
+     "start_time": "2023-07-18T18:47:24.910383Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class CFGuide(pyro.nn.PyroModule):\n",
+    "    \"\"\"\n",
+    "    A guide modeling the conditional distribution of noise on latent dynamic parameters as a normal\n",
+    "     with parameters defined as a linear combination of functions of those latent parameters.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, original_sir_guide, noise_name: str):\n",
+    "        super().__init__()\n",
+    "        self.original_sir_guide = original_sir_guide\n",
+    "        self.noise_name = noise_name\n",
+    "\n",
+    "    @pyro.nn.PyroParam(constraint=dist.constraints.positive)\n",
+    "    def noise_std_coefficients(self):\n",
+    "        return torch.ones(4)\n",
+    "\n",
+    "    @pyro.nn.PyroParam()\n",
+    "    def noise_mean_coefficients(self):\n",
+    "        return torch.ones(4)\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        self.original_sir_guide.requires_grad_(False)\n",
+    "\n",
+    "        bgd = self.original_sir_guide()\n",
+    "        beta = bgd['beta']\n",
+    "        gamma = bgd['gamma']\n",
+    "\n",
+    "        noise_mean = self.noise_mean_coefficients @ torch.tensor([beta, gamma, beta * gamma, 1.])\n",
+    "        noise_std = self.noise_std_coefficients @ torch.tensor([beta, gamma, beta * gamma, 1.])\n",
+    "\n",
+    "        noise = pyro.sample(self.noise_name, dist.Normal(noise_mean, noise_std))\n",
+    "        return noise\n",
+    "\n",
+    "cf_guide = CFGuide(original_sir_guide=sir_guide, noise_name='u_ip_0.36702409386634827')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:52.258842Z",
+     "start_time": "2023-07-18T18:47:24.941597Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/util.py:303: UserWarning: Found vars in model but not guide: {'nittb_0.36702409386634827'}\n",
+      "  warnings.warn(f\"Found vars in model but not guide: {bad_sites}\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[iteration 0001] loss: 46851.0625\n",
+      "[iteration 0100] loss: 1142.8154\n",
+      "[iteration 0200] loss: 2829.3054\n",
+      "[iteration 0300] loss: 982.5005\n",
+      "[iteration 0400] loss: 919.4028\n",
+      "[iteration 0500] loss: 1258.7483\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Approx. posterior over latent SIR params and noise variables conditional \n",
+    "# on observed data.\n",
+    "sir_guide_reparam = run_svi_inference(\n",
+    "    conditioned_sir_reparam,\n",
+    "    n_steps=500,\n",
+    "    data=sir_data,\n",
+    "    init_state=init_state,\n",
+    "    logging_times=torch.tensor([0.0, 3.0]),\n",
+    "    guide=cf_guide,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:58.954177Z",
+     "start_time": "2023-07-18T18:47:52.258332Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Compute counterfactual\n",
+    "cf_sir_predictive = Predictive(counterfactual_sir,\n",
+    "    guide=sir_guide_reparam, num_samples=100\n",
+    ")\n",
+    "\n",
+    "cf_sir_posterior_samples = cf_sir_predictive(\n",
+    "    sir_data, init_state, logging_times\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:58.997622Z",
+     "start_time": "2023-07-18T18:47:58.954789Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def SIR_cf_uncertainty_plot(logging_times, state_pred, line_label, ylabel, color, ax):\n",
+    "    sns.lineplot(\n",
+    "        x=logging_times,\n",
+    "        y=state_pred.mean(dim=0),\n",
+    "        color=color,\n",
+    "        label=f\"Posterior Mean: {line_label}\",\n",
+    "        ax=ax,\n",
+    "    )\n",
+    "    # 90% Credible Interval\n",
+    "    ax.fill_between(\n",
+    "        logging_times,\n",
+    "        torch.quantile(state_pred, 0.05, dim=0),\n",
+    "        torch.quantile(state_pred, 0.95, dim=0),\n",
+    "        alpha=0.2,\n",
+    "        color=color,\n",
+    "    )\n",
+    "\n",
+    "    ax.set_xlabel(\"Time (Yrs)\")\n",
+    "    ax.set_ylabel(ylabel)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:59.281688Z",
+     "start_time": "2023-07-18T18:47:58.998602Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x188d90dd0>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['S_cf'].squeeze(),\n",
+    "    'Counterfactual',\n",
+    "    \"# Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    ax=ax[0],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['S_factual'].squeeze(),\n",
+    "    'Reality',\n",
+    "    \"# Susceptible (Millions)\",\n",
+    "    \"blue\",\n",
+    "    ax[0],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['I_cf'].squeeze(),\n",
+    "    'Counterfactual',\n",
+    "    \"# Infected (Millions)\",\n",
+    "    \"orange\",\n",
+    "    ax=ax[1],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['I_factual'].squeeze(),\n",
+    "    'Reality',\n",
+    "    \"# Infected (Millions)\",\n",
+    "    \"blue\",\n",
+    "    ax[1],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['R_cf'].squeeze(),\n",
+    "    'Counterfactual',\n",
+    "    \"# Recovered (Millions)\",\n",
+    "    \"orange\",\n",
+    "    ax=ax[2],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['R_factual'].squeeze(),\n",
+    "    'Reality',\n",
+    "    \"# Recovered (Millions)\",\n",
+    "    \"blue\",\n",
+    "    ax[2],\n",
+    ")\n",
+    "\n",
+    "for ax_ in ax:\n",
+    "    ax_.axvline(superspreader_time, linestyle='--', color='black', label='Superspreader Event', linewidth=0.8)\n",
+    "    ax_.axvline(landing_time, linestyle='--', color='purple', label='Flight', linewidth=0.8)\n",
+    "    ax_.set_xlim((0, 1.7))\n",
+    "    ax_.legend()\n",
+    "\n",
+    "ax[0].legend().remove()\n",
+    "ax[2].legend().remove()\n",
+    "ax[1].legend(loc='upper center', bbox_to_anchor=(0.5, 1.15), fancybox=False, shadow=False, ncol=4)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:59.512271Z",
+     "start_time": "2023-07-18T18:47:59.274091Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infected_pass_dist = cf_sir_posterior_samples['infected_passengers_0.36702409386634827'].squeeze()\n",
+    "\n",
+    "sns.kdeplot(infected_pass_dist[:, 1], label='Estimated Counterfactual')\n",
+    "plt.axvline(x=true_cf_infected, color='black', label='Analytical Expected Counterfactual', linestyle='--')\n",
+    "plt.axvline(x=infected_pass_dist[:, 0].mean(), color='red', label='Reality')\n",
+    "plt.xlabel('# of Infected Passengers')\n",
+    "plt.yticks([])\n",
+    "plt.legend(loc='upper center')\n",
+    "plt.xlim(0, 5)\n",
+    "sns.despine()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multilevel SIR Model\n",
+    "\n",
+    "So far we have assumed we only observe data from one region. Now let's imagine we observe data from $M$ different regions, where region $m$ has transmission rate ($\\beta_m$) and recovery rate ($\\gamma_m$) for $1 \\leq m \\leq M$.\n",
+    "\n",
+    "\n",
+    "Note: we assume there are no interactions between regions (i.e., individuals from one region cannot infect those from another)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:59.576356Z",
+     "start_time": "2023-07-18T18:47:59.510352Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def unit_level_sir(unit_name, \n",
+    "                   beta0_prior=dist.Uniform(0.0, 1.0), \n",
+    "                   gamma_prior=dist.Uniform(0.0, 1.0)\n",
+    "                   ):\n",
+    "    beta0 = pyro.sample(f\"beta0_{unit_name}\", beta0_prior)\n",
+    "    gamma = pyro.sample(f\"gamma_{unit_name}\", gamma_prior)\n",
+    "    sir = SimpleSIRDynamics(beta0, gamma, unit_name)\n",
+    "    return sir\n",
+    "\n",
+    "\n",
+    "def multi_level_sir(\n",
+    "    N_stratum,\n",
+    "    init_states,\n",
+    "    logging_times,\n",
+    "    beta_prior=dist.Uniform(0.0, 1.0),\n",
+    "    gamma_prior=dist.Uniform(0.0, 1.0),\n",
+    "):\n",
+    "    solutions = []\n",
+    "    for unit_ix in range(N_stratum):\n",
+    "        sir = unit_level_sir(unit_ix, beta_prior, gamma_prior)\n",
+    "        init_state = init_states[unit_ix]\n",
+    "        with DynamicTrace(logging_times) as dt:\n",
+    "            with SimulatorEventLoop():\n",
+    "                simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "        trajectory = dt.trace\n",
+    "        solutions.append(trajectory)\n",
+    "        # This is a small trick to make the trajectory variables available to pyro\n",
+    "        [pyro.deterministic(f\"{k}_{unit_ix}\", getattr(trajectory, k))for k in get_keys(trajectory)]\n",
+    "    return solutions\n",
+    "\n",
+    "\n",
+    "def conditioned_multi_level_sir(\n",
+    "    multi_data,\n",
+    "    init_states,\n",
+    "    logging_times,\n",
+    "    beta_prior=dist.Uniform(0.0, 1.0),\n",
+    "    gamma_prior=dist.Uniform(0.0, 1.0),\n",
+    "):\n",
+    "    for unit_ix, data in multi_data.items():\n",
+    "        sir = unit_level_sir(unit_ix, beta_prior, gamma_prior)\n",
+    "        init_state = init_states[unit_ix]\n",
+    "        with SimulatorEventLoop():\n",
+    "            if data is None:\n",
+    "                simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "            else:\n",
+    "                with TrajectoryObservation(data):\n",
+    "                    simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:48:00.432415Z",
+     "start_time": "2023-07-18T18:47:59.569623Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Generate synthetic data from the true model\n",
+    "obs_logging_times = torch.arange(1 / 52, 1.01, 1 / 52)  # collect data\n",
+    "N_obs = obs_logging_times.shape[0]\n",
+    "\n",
+    "N_stratum = 5\n",
+    "\n",
+    "multi_data = {}\n",
+    "init_states = []\n",
+    "init_state = State(\n",
+    "    S=torch.tensor(99.0), I=torch.tensor(1.0), R=torch.tensor(0.0), l=torch.tensor(0.0)\n",
+    ")\n",
+    "\n",
+    "beta0_grid = torch.tensor([0.1, 0.05, 0.075, 0.15, 0.12])\n",
+    "gamma_grid = torch.tensor([0.2, 0.3, 0.5, 0.35, 0.4])\n",
+    "\n",
+    "sir_true_trajs = []\n",
+    "for unit_ix in range(N_stratum):\n",
+    "    beta0 = beta0_grid[unit_ix]\n",
+    "    gamma = gamma_grid[unit_ix]\n",
+    "    sir = SimpleSIRDynamics(beta0, gamma, unit_ix)\n",
+    "    with DynamicTrace(obs_logging_times) as dt:\n",
+    "        simulate(sir, init_state, obs_logging_times[0], obs_logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    sir_traj = dt.trace\n",
+    "    with DynamicTrace(logging_times) as true_dt:\n",
+    "        simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    sir_true_trajs.append(true_dt.trace)\n",
+    "\n",
+    "    data = dict()\n",
+    "    if unit_ix != 0:\n",
+    "        for time_ix in range(N_obs):\n",
+    "            data[obs_logging_times[time_ix].item()] = sir.observation(sir_traj[time_ix])\n",
+    "    else:\n",
+    "        data = None\n",
+    "    multi_data[unit_ix] = data\n",
+    "    init_states.append(init_state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Unpooled Multi-level Model\n",
+    "First, we assume that the way each region's population responds to the infectious disease is entirely independent of every other region. This means both that individuals don't interact across regions, and also that we can't learn anything about one population by observing another. Later we'll relax this assumption to make better use of multi-region data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:50:50.419371Z",
+     "start_time": "2023-07-18T18:48:00.432672Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "multi_guide = run_svi_inference(conditioned_multi_level_sir, multi_data=multi_data, init_states=init_states, logging_times=torch.tensor([0.0, 3.0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:51:17.223063Z",
+     "start_time": "2023-07-18T18:50:50.422559Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Generate samples from the posterior predictive distribution\n",
+    "multi_predictive = Predictive(multi_level_sir, guide=multi_guide, num_samples=50)\n",
+    "multi_samples = multi_predictive(N_stratum, init_states, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Note: We do not observe any data for the first of the five regions we wish to model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2023-07-18T18:51:17.222366Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Plot results\n",
+    "fig, ax = plt.subplots(N_stratum, 3, figsize=(15, 15))\n",
+    "\n",
+    "states = [\"S\", \"I\", \"R\"]\n",
+    "colors = [\"orange\", \"red\", \"green\"]\n",
+    "pred_labels = [\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "]\n",
+    "data_labels = [\"Actual # Susceptible\", \"Actual # Infected\", \"Actual # Recovered\"]\n",
+    "\n",
+    "\n",
+    "for i in range(N_stratum):\n",
+    "    for j, (state, color, pred_label, data_label) in enumerate(\n",
+    "        zip(states, colors, pred_labels, data_labels)\n",
+    "    ):\n",
+    "        if i == 0:\n",
+    "            test_time = 0.0\n",
+    "            legend = True\n",
+    "        else:\n",
+    "            test_time = 1.0\n",
+    "            legend = False\n",
+    "        SIR_plot(\n",
+    "            logging_times,\n",
+    "            test_time,\n",
+    "            multi_samples[f\"{state}_{i}\"],\n",
+    "            getattr(sir_true_trajs[i], state),\n",
+    "            pred_label,\n",
+    "            color,\n",
+    "            data_label,\n",
+    "            ax[i, j],\n",
+    "            legend=legend,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Share Information across stratum (Partial Pooling)\n",
+    "Here we will assume that the different regions have similar rate parameters, although we are uncertain about their values a-priori. This means that information about regions 2-5 will inform our predictions for region 1, which we do not have any observations for.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def beta_reparam(mean, var):\n",
+    "    # Formula relating mean and variance of beta distribution to alpha and beta parameters:\n",
+    "    # https://stats.stackexchange.com/questions/12232/calculating-the-parameters-of-a-beta-distribution-using-the-mean-and-variance\n",
+    "    alpha = ((1 - mean) / var - (1 / mean)) * mean**2\n",
+    "    beta = alpha * (1 / mean - 1)\n",
+    "    return alpha, beta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pooling_prior():\n",
+    "    # We assume that there is a shared center of mass for the beta and gamma distributions\n",
+    "    # and that the strata-specific distributions are drawn from this center of mass.\n",
+    "\n",
+    "    beta0_mean = pyro.sample(\"beta0_mean\", dist.Uniform(0.0, 1.0))\n",
+    "    beta0_var = 0.05**2 # we don't think infection rate varies by more than 5% between strata\n",
+    "\n",
+    "    gamma_mean = pyro.sample(\"gamma_mean\", dist.Uniform(0.0, 1.0))\n",
+    "    gamma_var = 0.3**2 # we don't think recovery rate varies by more than 30% between strata\n",
+    "\n",
+    "    beta0_prior = dist.Beta(*beta_reparam(beta0_mean, beta0_var))\n",
+    "    gamma_prior = dist.Beta(*beta_reparam(gamma_mean, gamma_var))\n",
+    "    return beta0_prior, gamma_prior\n",
+    "\n",
+    "\n",
+    "def pooled_multi_level_sir(N_stratum, init_states, logging_times):\n",
+    "    # Draw priors for beta0 and gamma\n",
+    "    beta0_prior, gamma_prior = pooling_prior()\n",
+    "\n",
+    "    # Run the multi-level SIR model with the pooled priors\n",
+    "    return multi_level_sir(N_stratum, init_states, logging_times, beta0_prior, gamma_prior)\n",
+    "\n",
+    "\n",
+    "def pooled_conditioned_multi_level_sir(multi_data, init_states, logging_times):\n",
+    "    # Draw priors for beta0 and gamma\n",
+    "    beta0_prior, gamma_prior = pooling_prior()\n",
+    "\n",
+    "    # Run the multi-level SIR model with the pooled priors\n",
+    "    return conditioned_multi_level_sir(multi_data, init_states, logging_times, beta0_prior, gamma_prior)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pooled_multi_guide = run_svi_inference(pooled_conditioned_multi_level_sir, multi_data=multi_data, init_states=init_states, logging_times=torch.tensor([0.0, 3.0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate samples from the posterior predictive distribution\n",
+    "pooled_predictive = Predictive(pooled_multi_level_sir, guide=pooled_multi_guide, num_samples=50)\n",
+    "pooled_samples = pooled_predictive(N_stratum, init_states, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot predicted values for S, I, and R with uncertainty bands (+/- 2 std. devs.)\n",
+    "\n",
+    "fig, ax = plt.subplots(N_stratum, 3, figsize=(15, 15))\n",
+    "\n",
+    "states = [\"S\", \"I\", \"R\"]\n",
+    "colors = [\"orange\", \"red\", \"green\"]\n",
+    "pred_labels = [\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "]\n",
+    "data_labels = [\"Actual # Susceptible\", \"Actual # Infected\", \"Actual # Recovered\"]\n",
+    "\n",
+    "\n",
+    "for i in range(N_stratum):\n",
+    "    for j, (state, color, pred_label, data_label) in enumerate(\n",
+    "        zip(states, colors, pred_labels, data_labels)\n",
+    "    ):\n",
+    "        if i == 0:\n",
+    "            test_time = 0.0\n",
+    "            legend = True\n",
+    "        else:\n",
+    "            test_time = 1.0\n",
+    "            legend = False\n",
+    "        SIR_plot(\n",
+    "            logging_times,\n",
+    "            test_time,\n",
+    "            pooled_samples[f\"{state}_{i}\"],\n",
+    "            getattr(sir_true_trajs[i], state),\n",
+    "            pred_label,\n",
+    "            color,\n",
+    "            data_label,\n",
+    "            ax[i, j],\n",
+    "            legend=legend,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "1. https://www.generable.com/post/fitting-a-basic-sir-model-in-stan\n",
+    "2. https://benjaminmoll.com/wp-content/uploads/2020/05/SIR_notes.pdf"
+   ]
+  },
+  {
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/dynamical_multilevel.ipynb b/docs/source/dynamical_multilevel.ipynb
new file mode 100644
index 000000000..ad07affec
--- /dev/null
+++ b/docs/source/dynamical_multilevel.ipynb
@@ -0,0 +1,2507 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Causal reasoning in dynamical systems"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.292774Z",
+     "start_time": "2023-07-18T18:46:28.196486Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "%reload_ext autoreload\n",
+    "%autoreload 2\n",
+    "\n",
+    "from typing import Dict\n",
+    "\n",
+    "import pyro\n",
+    "import torch\n",
+    "from pyro.infer.autoguide import AutoMultivariateNormal\n",
+    "import pyro.distributions as dist\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from pyro.infer import Predictive\n",
+    "\n",
+    "from chirho.counterfactual.handlers import TwinWorldCounterfactual\n",
+    "from chirho.indexed.ops import IndexSet, gather, indices_of\n",
+    "\n",
+    "from chirho.dynamical.handlers import (\n",
+    "    StaticObservation,\n",
+    "    StaticIntervention,\n",
+    "    DynamicTrace,\n",
+    "    DynamicIntervention,\n",
+    "    SimulatorEventLoop,\n",
+    "    StaticInterruption,\n",
+    "    NonInterruptingPointObservationArray\n",
+    ")\n",
+    "from chirho.dynamical.handlers.interruption import _InterventionMixin\n",
+    "from chirho.dynamical.ops.dynamical import State, Trajectory, get_keys, simulate\n",
+    "\n",
+    "from chirho.dynamical.ops.ODE import ODEDynamics\n",
+    "from chirho.dynamical.handlers.ODE.solvers import TorchDiffEq\n",
+    "\n",
+    "from chirho.observational.handlers.soft_conditioning import (\n",
+    "    AutoSoftConditioning\n",
+    ")\n",
+    "\n",
+    "pyro.settings.set(module_local_params=True)\n",
+    "\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "# Set seed for reproducibility\n",
+    "seed = 123\n",
+    "pyro.clear_param_store()\n",
+    "pyro.set_rng_seed(seed)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.324680Z",
+     "start_time": "2023-07-18T18:46:29.293433Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class TrajectoryObservation(pyro.poutine.messenger.Messenger):\n",
+    "    def __init__(\n",
+    "        self,\n",
+    "        data: Dict[float, Dict[str, torch.Tensor]],\n",
+    "        eps: float = 1e-6,\n",
+    "    ):\n",
+    "        times = torch.tensor([t for t, _ in data.items()])\n",
+    "        data_obs_dicts = [s for _, s in data.items()]\n",
+    "        # data_obs_dicts is a list of dictionaries, each of which contains the observations at a single time point\n",
+    "        #  these need to be concatenated into a single array valued dictionary.\n",
+    "        data_obs = dict()\n",
+    "        for key in data_obs_dicts[0].keys():\n",
+    "            data_obs[key] = torch.stack([d[key] for d in data_obs_dicts])\n",
+    "\n",
+    "        self.nipoa = NonInterruptingPointObservationArray(times, data_obs, eps=eps)\n",
+    "\n",
+    "    def __enter__(self):\n",
+    "        self.nipoa.__enter__()\n",
+    "\n",
+    "    def __exit__(self, *args, **kwargs):\n",
+    "        self.nipoa.__exit__(*args, **kwargs)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Define our SIR model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.357796Z",
+     "start_time": "2023-07-18T18:46:29.323308Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class SimpleSIRDynamics(ODEDynamics):\n",
+    "    def __init__(self, beta, gamma, name=None):\n",
+    "        super().__init__()\n",
+    "        self.beta = beta\n",
+    "        self.gamma = gamma\n",
+    "        self.name = name\n",
+    "\n",
+    "        if name is not None:\n",
+    "            self.postfix = f\"_{name}\"\n",
+    "        else:\n",
+    "            self.postfix = \"\"\n",
+    "\n",
+    "    def diff(self, dX: State[torch.Tensor], X: State[torch.Tensor]):\n",
+    "        dX.S = -self.beta * X.S * X.I\n",
+    "        dX.I = self.beta * X.S * X.I - self.gamma * X.I\n",
+    "        dX.R = self.gamma * X.I\n",
+    "\n",
+    "    def observation(self, X: State[torch.Tensor]):\n",
+    "        # We don't observe the number of susceptible individuals directly, and instead can only infer it from the\n",
+    "        #  number of test kits that are sold (which is a noisy function of the number of susceptible individuals).\n",
+    "        event_dim = 1 if X.I.shape and X.I.shape[-1] > 1 else 0\n",
+    "        test_kit_sales = torch.relu(pyro.sample(f\"test_kit_sales{self.postfix}\", dist.Normal(torch.log(torch.relu(X.S) + 1), 1).to_event(event_dim)))\n",
+    "        I_obs = pyro.sample(f\"I_obs{self.postfix}\", dist.Poisson(X.I).to_event(event_dim))  # noisy number of infected actually observed\n",
+    "        R_obs = pyro.sample(f\"R_obs{self.postfix}\", dist.Poisson(X.R).to_event(event_dim))  # noisy number of recovered actually observed\n",
+    "\n",
+    "        return {\n",
+    "            f\"test_kit_sales{self.postfix}\": test_kit_sales,\n",
+    "            f\"I_obs{self.postfix}\": I_obs,\n",
+    "            f\"R_obs{self.postfix}\": R_obs,\n",
+    "        }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Generate synthetic data from the SIR model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.410660Z",
+     "start_time": "2023-07-18T18:46:29.355384Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Assume there is initially a population of 99 million people that are susceptible, 1 million infected, and 0 recovered\n",
+    "init_state = State(S=torch.tensor(99.0), I=torch.tensor(1.0), R=torch.tensor(0.0))\n",
+    "start_time = torch.tensor(0.0)\n",
+    "end_time = torch.tensor(3.0)\n",
+    "logging_times = torch.linspace(0, 2.9, steps=21)\n",
+    "\n",
+    "# We now simulate from the SIR model\n",
+    "beta_true = torch.tensor(0.05)\n",
+    "gamma_true = torch.tensor(0.5)\n",
+    "sir_true = SimpleSIRDynamics(beta_true, gamma_true)\n",
+    "with DynamicTrace(logging_times) as dt:\n",
+    "    simulate(sir_true, init_state, start_time, end_time, solver=TorchDiffEq())\n",
+    "\n",
+    "sir_true_traj = dt.trace"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Simulate the latent trajectories of the ODE model"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.584138Z",
+     "start_time": "2023-07-18T18:46:29.411761Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x183d12710>"
+      ]
+     },
+     "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": [
+    "sns.lineplot(\n",
+    "    x=logging_times, y=sir_true_traj.S, label=\"# Susceptable (S)\", color=\"orange\"\n",
+    ")\n",
+    "sns.lineplot(x=logging_times, y=sir_true_traj.I, label=\"# Infected (I)\", color=\"red\")\n",
+    "sns.lineplot(x=logging_times, y=sir_true_traj.R, label=\"# Recovered (R)\", color=\"green\")\n",
+    "sns.despine()\n",
+    "plt.xlabel(\"Time (Yrs)\")\n",
+    "plt.ylabel(\"# of Individuals (Millions)\")\n",
+    "plt.legend()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Add noise to state trajectories to generate observations\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.646023Z",
+     "start_time": "2023-07-18T18:46:29.584398Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "obs_logging_times = torch.arange(\n",
+    "    1 / 52, 1.01, 1 / 52\n",
+    ")  # collect data every week for the past 6mo\n",
+    "obs_start_time = obs_logging_times[0]\n",
+    "obs_end_time = obs_logging_times[-1] + 1e-3\n",
+    "N_obs = obs_logging_times.shape[0]\n",
+    "with DynamicTrace(obs_logging_times) as dt_obs:\n",
+    "    simulate(sir_true, init_state, obs_start_time, obs_end_time, solver=TorchDiffEq())\n",
+    "\n",
+    "sir_obs_traj = dt_obs.trace\n",
+    "sir_data = dict()\n",
+    "for time_ix in range(N_obs):\n",
+    "    samp = sir_true.observation(\n",
+    "        sir_obs_traj[time_ix:time_ix+1]\n",
+    "    )\n",
+    "    sir_data[obs_logging_times[time_ix].item()] = {k: samp[k][0] for k in samp.keys()}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.683584Z",
+     "start_time": "2023-07-18T18:46:29.645386Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "test_kit_sales = torch.stack(\n",
+    "    [sir_data[time.item()][\"test_kit_sales\"] for time in obs_logging_times]\n",
+    ")\n",
+    "I_obs = torch.stack([sir_data[time.item()][\"I_obs\"] for time in obs_logging_times])\n",
+    "R_obs = torch.stack([sir_data[time.item()][\"R_obs\"] for time in obs_logging_times])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:29.996315Z",
+     "start_time": "2023-07-18T18:46:29.685112Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Observed # Recovered (Millions)')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot observed data\n",
+    "fix, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "# Plot test kit sales\n",
+    "sns.scatterplot(x=obs_logging_times, y=test_kit_sales, color=\"blue\", ax=ax[0])\n",
+    "sns.despine()\n",
+    "ax[0].set_xlabel(\"Time (Yrs)\")\n",
+    "ax[0].set_ylabel(\"Test Kits Sales ($Millions)\")\n",
+    "\n",
+    "# Plot observed infected\n",
+    "sns.scatterplot(x=obs_logging_times, y=I_obs, color=\"red\", ax=ax[1])\n",
+    "sns.despine()\n",
+    "ax[1].set_xlabel(\"Time (Yrs)\")\n",
+    "ax[1].set_ylabel(\"Observed # Infected (Millions)\")\n",
+    "\n",
+    "# Plot observed recovered\n",
+    "sns.scatterplot(x=obs_logging_times, y=R_obs, color=\"green\", ax=ax[2])\n",
+    "sns.despine()\n",
+    "ax[2].set_xlabel(\"Time (Yrs)\")\n",
+    "ax[2].set_ylabel(\"Observed # Recovered (Millions)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Extend our model to include uncertainty over model parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:30.010774Z",
+     "start_time": "2023-07-18T18:46:29.995553Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# We place uniform priors on the beta and gamma parameters defining the SIR model\n",
+    "def bayesian_sir(base_model=SimpleSIRDynamics):\n",
+    "    beta = pyro.sample(\"beta\", dist.Uniform(0, 1))\n",
+    "    gamma = pyro.sample(\"gamma\", dist.Uniform(0, 1))\n",
+    "    sir = base_model(beta, gamma)\n",
+    "    return sir\n",
+    "\n",
+    "\n",
+    "def simulated_bayesian_sir(init_state, logging_times, base_model=SimpleSIRDynamics) -> Trajectory:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    trajectory = dt.trace\n",
+    "    # This is a small trick to make the solution variables available to pyro\n",
+    "    [pyro.deterministic(k, getattr(trajectory, k)) for k in get_keys(trajectory)]\n",
+    "    return trajectory\n",
+    "\n",
+    "\n",
+    "def conditioned_sir(data, init_state, start_time, end_time, base_model=SimpleSIRDynamics) -> None:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "    with TrajectoryObservation(data):\n",
+    "        simulate(sir, init_state, start_time, end_time, solver=TorchDiffEq())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Perform Inference!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:30.070437Z",
+     "start_time": "2023-07-18T18:46:30.011493Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Define a helper function to run SVI. (Generally, Pyro users like to have more control over the training process!)\n",
+    "def run_svi_inference(model, n_steps=100, verbose=True, lr=.03, vi_family=AutoMultivariateNormal, guide=None, **model_kwargs):\n",
+    "    if guide is None:\n",
+    "        guide = vi_family(model)\n",
+    "    elbo = pyro.infer.Trace_ELBO()(model, guide)\n",
+    "    # initialize parameters\n",
+    "    elbo(**model_kwargs)\n",
+    "    adam = torch.optim.Adam(elbo.parameters(), lr=lr)\n",
+    "    # Do gradient steps\n",
+    "    for step in range(1, n_steps + 1):\n",
+    "        adam.zero_grad()\n",
+    "        loss = elbo(**model_kwargs)\n",
+    "        loss.backward()\n",
+    "        adam.step()\n",
+    "        if (step % 100 == 0) or (step == 1) & verbose:\n",
+    "            print(\"[iteration %04d] loss: %.4f\" % (step, loss))\n",
+    "    return guide"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:46:59.292526Z",
+     "start_time": "2023-07-18T18:46:30.043544Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[iteration 0001] loss: 3735.7144\n",
+      "[iteration 0100] loss: 287.4226\n",
+      "[iteration 0200] loss: 262.3965\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Run inference to approximate the posterior distribution of the SIR model parameters\n",
+    "sir_guide = run_svi_inference(\n",
+    "    conditioned_sir,\n",
+    "    n_steps=200,\n",
+    "    data=sir_data,\n",
+    "    init_state=init_state,\n",
+    "    start_time=obs_start_time,\n",
+    "    end_time=obs_end_time,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Evaluate the performance of our inference"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Trajectory({'R': tensor([2.0008e-07, 6.1867e-02, 2.9212e-01, 1.0153e+00, 2.6028e+00, 4.9024e+00,\n",
+       "        7.4742e+00, 1.0078e+01, 1.2638e+01, 1.5133e+01, 1.7558e+01, 1.9916e+01,\n",
+       "        2.2205e+01, 2.4430e+01, 2.6591e+01, 2.8690e+01, 3.0729e+01, 3.2710e+01,\n",
+       "        3.4634e+01, 3.6503e+01, 3.8319e+01]), 'I': tensor([ 1.0000,  3.8834, 13.8651, 38.6749, 69.6112, 86.0551, 89.9492, 89.1990,\n",
+       "        87.1549, 84.8061, 82.4228, 80.0785, 77.7927, 75.5694, 73.4090, 71.3100,\n",
+       "        69.2709, 67.2901, 65.3661, 63.4969, 61.6812]), 'S': tensor([9.9000e+01, 9.6055e+01, 8.5843e+01, 6.0310e+01, 2.7786e+01, 9.0426e+00,\n",
+       "        2.5766e+00, 7.2265e-01, 2.0715e-01, 6.1290e-02, 1.8755e-02, 5.9345e-03,\n",
+       "        1.9405e-03, 6.5509e-04, 2.2812e-04, 8.1873e-05, 3.0258e-05, 1.1505e-05,\n",
+       "        4.4975e-06, 1.8058e-06, 7.4423e-07])})"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "simulated_bayesian_sir(init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:01.693275Z",
+     "start_time": "2023-07-18T18:46:59.291560Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Generate samples from the posterior predictive distribution\n",
+    "sir_predictive = Predictive(simulated_bayesian_sir, guide=sir_guide, num_samples=100)\n",
+    "sir_posterior_samples = sir_predictive(init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### First, we compare the approximate posterior distribution with the true beta and gamma parameters generating the data"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.042675Z",
+     "start_time": "2023-07-18T18:47:01.694295Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x1844c31d0>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 2, figsize=(15, 5))\n",
+    "\n",
+    "sns.kdeplot(sir_posterior_samples[\"beta\"], label=\"Approx. Beta Posterior\", ax=ax[0])\n",
+    "ax[0].axvline(beta_true, color=\"black\", label=\"True Beta\", linestyle=\"--\")\n",
+    "sns.despine()\n",
+    "ax[0].set_yticks([])\n",
+    "ax[0].legend(loc=\"upper right\")\n",
+    "\n",
+    "sns.kdeplot(sir_posterior_samples[\"gamma\"], label=\"Approx. Gamma Posterior\", ax=ax[1])\n",
+    "plt.axvline(gamma_true, color=\"black\", label=\"True Gamma\", linestyle=\"--\")\n",
+    "sns.despine()\n",
+    "ax[1].set_yticks([])\n",
+    "ax[1].legend(loc=\"upper right\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Next, we compare the predictive performance on the held out period between $t=1$ and $t=3$ years"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.141589Z",
+     "start_time": "2023-07-18T18:47:02.053763Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def SIR_uncertainty_plot(time_period, state_pred, ylabel, color, ax):\n",
+    "    sns.lineplot(\n",
+    "        x=time_period,\n",
+    "        y=state_pred.mean(dim=0),\n",
+    "        color=color,\n",
+    "        label=\"Posterior Mean\",\n",
+    "        ax=ax,\n",
+    "    )\n",
+    "    # 90% Credible Interval\n",
+    "    ax.fill_between(\n",
+    "        time_period,\n",
+    "        torch.quantile(state_pred, 0.05, dim=0),\n",
+    "        torch.quantile(state_pred, 0.95, dim=0),\n",
+    "        alpha=0.2,\n",
+    "        color=color,\n",
+    "    )\n",
+    "\n",
+    "    ax.set_xlabel(\"Time (Yrs)\")\n",
+    "    ax.set_ylabel(ylabel)\n",
+    "\n",
+    "\n",
+    "def SIR_data_plot(time_period, data, data_label, ax):\n",
+    "    sns.lineplot(\n",
+    "        x=time_period, y=data, color=\"black\", ax=ax, linestyle=\"--\", label=data_label\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def SIR_test_plot(test_time, ax):\n",
+    "    ax.axvline(\n",
+    "        test_time, color=\"black\", linestyle=\"dotted\", label=\"Start of Testing Period\"\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def SIR_plot(\n",
+    "    time_period,\n",
+    "    test_time,\n",
+    "    state_pred,\n",
+    "    data,\n",
+    "    ylabel,\n",
+    "    color,\n",
+    "    data_label,\n",
+    "    ax,\n",
+    "    legend=False,\n",
+    "    test_plot=True,\n",
+    "):\n",
+    "    SIR_uncertainty_plot(time_period, state_pred, ylabel, color, ax)\n",
+    "    SIR_data_plot(time_period, data, data_label, ax)\n",
+    "    if test_plot:\n",
+    "        SIR_test_plot(test_time, ax)\n",
+    "    if legend:\n",
+    "        ax.legend()\n",
+    "    else:\n",
+    "        ax.legend().remove()\n",
+    "    sns.despine()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.394748Z",
+     "start_time": "2023-07-18T18:47:02.113943Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    sir_posterior_samples[\"S\"],\n",
+    "    sir_true_traj.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    sir_posterior_samples[\"I\"],\n",
+    "    sir_true_traj.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    sir_posterior_samples[\"R\"],\n",
+    "    sir_true_traj.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Let's explore how different interventions might flatten the infection curve"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Suppose the government can enact different lockdown measures (of varying strength) to flatten the infection curve. Following [2], we define the stength of lockdown measure at time $t$ by $l_t \\in [0, 1]$ for $1 \\leq t \\leq T$. Parametrize the transmission rate $\\beta_t$ as:\n",
+    "\n",
+    "$$\n",
+    "\\beta_t = (1 - l_t) \\beta_0,\n",
+    "$$\n",
+    "\n",
+    "where $\\beta_0$ denotes the unmitigated transmission rate and larger values of $l_t$ correspond to stronger lockdown measures. Then, the time-varying SIR model is defined as follows:\n",
+    "\n",
+    "$$\n",
+    "\\begin{split}\n",
+    "    dS_t &= -\\beta_t S_t I_t \\\\\n",
+    "    dI_t &= \\beta_t S_t I_t - \\gamma I_t \\\\\n",
+    "    dR_t &= \\gamma I_t\n",
+    "\\end{split}\n",
+    "$$\n",
+    "\n",
+    "where $S_t, I_t, R_t$ denote the number of susceptable, infected, and recovered individuals at time $t$ for $1 \\leq t \\leq T$.\n",
+    "\n",
+    "### We can implement this new model compositionally using our existing SIR model implementation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.470158Z",
+     "start_time": "2023-07-18T18:47:02.393888Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class SimpleSIRDynamicsLockdown(SimpleSIRDynamics):\n",
+    "    def __init__(self, beta0, gamma):\n",
+    "        super().__init__(torch.zeros_like(gamma), gamma)\n",
+    "        self.beta0 = beta0\n",
+    "\n",
+    "    def diff(self, dX: State[torch.Tensor], X: State[torch.Tensor]):\n",
+    "        self.beta = (1 - X.l) * self.beta0  # time-varing beta parametrized by lockdown strength l_t\n",
+    "        dX.l = torch.tensor(0.0)\n",
+    "        # Call the base SIR class diff method\n",
+    "        super().diff(dX, X)\n",
+    "\n",
+    "\n",
+    "init_state_lockdown = State(\n",
+    "    S=torch.tensor(99.0), \n",
+    "    I=torch.tensor(1.0), \n",
+    "    R=torch.tensor(0.0), \n",
+    "    l=torch.tensor(0.0)\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Let's first look at a deterministic intervention where the transmission rate is reduced by 75% between $t=1$ and $t=2$ due to stronger lockdown measures. We see in the figure below that this lockdown measures indeed \"flattens\" the curve."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:02.470325Z",
+     "start_time": "2023-07-18T18:47:02.426012Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    sir = bayesian_sir(SimpleSIRDynamicsLockdown)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        with SimulatorEventLoop():\n",
+    "            with StaticIntervention(time=torch.as_tensor(lockdown_start), intervention=State(l=torch.as_tensor(lockdown_strength))):\n",
+    "                with StaticIntervention(time=torch.as_tensor(lockdown_end), intervention=State(l=torch.tensor(0.0))):\n",
+    "                    simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "                    \n",
+    "    trajectory = dt.trace\n",
+    "    # This is a small trick to make the solution variables available to pyro\n",
+    "    [pyro.deterministic(k, getattr(trajectory, k)) for k in get_keys(trajectory)]\n",
+    "    return trajectory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:07.929780Z",
+     "start_time": "2023-07-18T18:47:02.453827Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "lockdown_start = 1.01\n",
+    "lockdown_end = 2.0\n",
+    "lockdown_strength = 0.75\n",
+    "\n",
+    "true_intervened_sir = pyro.condition(intervened_sir, data={\"beta\": beta_true, \"gamma\": gamma_true})\n",
+    "true_intervened_trajectory = true_intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state_lockdown, logging_times)\n",
+    "\n",
+    "intervened_sir_predictive = Predictive(intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "intervened_sir_posterior_samples = intervened_sir_predictive(lockdown_start, lockdown_end, lockdown_strength, init_state_lockdown, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:08.236254Z",
+     "start_time": "2023-07-18T18:47:07.927429Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Plot the static intervention\n",
+    "for a in ax:\n",
+    "    a.axvline(lockdown_start, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")\n",
+    "    a.axvline(lockdown_end, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## What if we're uncertain about when the lockdown will happen?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:08.329716Z",
+     "start_time": "2023-07-18T18:47:08.235883Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def uncertain_intervened_sir(lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    lockdown_start = pyro.sample(\"lockdown_start\", dist.Uniform(0.5, 1.5))\n",
+    "    lockdown_end = pyro.sample(\"lockdown_end\", dist.Uniform(1.5, 2.5))\n",
+    "    return intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:13.731306Z",
+     "start_time": "2023-07-18T18:47:08.270009Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "uncertain_intervened_sir_predictive = Predictive(uncertain_intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "uncertain_intervened_sir_posterior_samples = uncertain_intervened_sir_predictive(lockdown_strength, init_state_lockdown, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:14.049827Z",
+     "start_time": "2023-07-18T18:47:13.732215Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Plot the static intervention\n",
+    "for a in ax:\n",
+    "    a.axvline(lockdown_start, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")\n",
+    "    a.axvline(lockdown_end, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Next, let's consider a state-dependent intervention (\"dynamic intervention\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Here we assume that the government will issue a lockdown measure that reduces the transmission rate by 90% whenever the number of infected people hits 30 million infected. The government removes this lockdown when 20% of the population is recovered."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:14.139374Z",
+     "start_time": "2023-07-18T18:47:14.050158Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def government_lockdown_policy(target_state: State[torch.tensor]):\n",
+    "    def event_f(t: torch.tensor, state: State[torch.tensor]):\n",
+    "        return state.I - target_state.I\n",
+    "\n",
+    "    return event_f\n",
+    "\n",
+    "\n",
+    "def government_lift_policy(target_state: State[torch.tensor]):\n",
+    "    def event_f(t: torch.tensor, state: State[torch.tensor]):\n",
+    "        return target_state.R - state.R\n",
+    "\n",
+    "    return event_f\n",
+    "\n",
+    "\n",
+    "def dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    sir = bayesian_sir(SimpleSIRDynamicsLockdown)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        with SimulatorEventLoop():\n",
+    "            with DynamicIntervention(event_f=government_lockdown_policy(lockdown_trigger), intervention=State(l=torch.as_tensor(lockdown_strength))):\n",
+    "                with DynamicIntervention(event_f=government_lift_policy(lockdown_lift_trigger), intervention=State(l=torch.tensor(0.0))):\n",
+    "                    simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    trajectory = dt.trace\n",
+    "    \n",
+    "    # This is a small trick to make the solution variables available to pyro\n",
+    "    [pyro.deterministic(k, getattr(trajectory, k)) for k in get_keys(trajectory)]\n",
+    "    return trajectory"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:19.227835Z",
+     "start_time": "2023-07-18T18:47:14.082066Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "lockdown_trigger = State(I=torch.tensor(30.0))\n",
+    "lockdown_lift_trigger = State(R=torch.tensor(20.0))\n",
+    "lockdown_strength = 0.9  # reduces transmission rate by 90%\n",
+    "\n",
+    "true_dynamic_intervened_sir = pyro.condition(dynamic_intervened_sir, data={\"beta\": beta_true, \"gamma\": gamma_true})\n",
+    "true_dynamic_intervened_trajectory = true_dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state_lockdown, logging_times)\n",
+    "\n",
+    "dynamic_intervened_sir_predictive = Predictive(dynamic_intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "dynamic_intervened_sir_posterior_samples = dynamic_intervened_sir_predictive(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state_lockdown, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:19.534805Z",
+     "start_time": "2023-07-18T18:47:19.228543Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x1889e8a10>"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    dynamic_intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_dynamic_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    dynamic_intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_dynamic_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    dynamic_intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_dynamic_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Draw horizontal line at lockdown trigger\n",
+    "ax[1].axhline(lockdown_trigger.I, color=\"grey\", linestyle=\"-\")\n",
+    "ax[2].axhline(lockdown_lift_trigger.R, color=\"grey\", linestyle=\"-\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Again, we can represent uncertainty about the interventions themselves."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:19.613896Z",
+     "start_time": "2023-07-18T18:47:19.533372Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def uncertain_dynamic_intervened_sir(lockdown_strength, init_state, logging_times) -> Trajectory:\n",
+    "    lockdown_trigger = State(I=pyro.sample(\"lockdown_trigger\", dist.Uniform(30.0, 40.0)))\n",
+    "    lockdown_lift_trigger = State(R=pyro.sample(\"lockdown_lift_trigger\", dist.Uniform(20.0, 30.0)))\n",
+    "    return dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.507420Z",
+     "start_time": "2023-07-18T18:47:19.564083Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "uncertain_dynamic_intervened_sir_predictive = Predictive(uncertain_dynamic_intervened_sir, guide=sir_guide, num_samples=100)\n",
+    "uncertain_dynamic_intervened_sir_posterior_samples = (uncertain_dynamic_intervened_sir_predictive(lockdown_strength, init_state_lockdown, logging_times))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.783573Z",
+     "start_time": "2023-07-18T18:47:24.508114Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.lines.Line2D at 0x188abaf90>"
+      ]
+     },
+     "execution_count": 29,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Plot predicted values for S, I, and R with 90% credible intervals\n",
+    "\n",
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_dynamic_intervened_sir_posterior_samples[\"S\"],\n",
+    "    true_dynamic_intervened_trajectory.S,\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    \"Actual # Susceptible\",\n",
+    "    ax[0],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_dynamic_intervened_sir_posterior_samples[\"I\"],\n",
+    "    true_dynamic_intervened_trajectory.I,\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"red\",\n",
+    "    \"Actual # Infected\",\n",
+    "    ax[1],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "SIR_plot(\n",
+    "    logging_times,\n",
+    "    1,\n",
+    "    uncertain_dynamic_intervened_sir_posterior_samples[\"R\"],\n",
+    "    true_dynamic_intervened_trajectory.R,\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "    \"green\",\n",
+    "    \"Actual # Recovered\",\n",
+    "    ax[2],\n",
+    "    legend=True,\n",
+    "    test_plot=False,\n",
+    ")\n",
+    "\n",
+    "# Draw horizontal line at lockdown trigger\n",
+    "ax[1].axhline(lockdown_trigger.I, color=\"grey\", linestyle=\"-\")\n",
+    "ax[2].axhline(lockdown_lift_trigger.R, color=\"grey\", linestyle=\"-\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Modeling a superspreader event using counterfactual inference\n",
+    "\n",
+    "Suppose at time $t=0.3$ (`superspreader_time`), there is a superspreader event that results in a rapid infection a large number of people that would have otherwise remained susceptible. We model this as an instantaneous infection of 15 million people (`superspreader_delta`). One month later, suppose that a plane entering a foreign country holds 4 infected individuals (`landing_data`). We would like to answer the following counterfactual questions: if the superspreader event never occured, how many infected people would be on the plane?\n",
+    "\n",
+    "Counterfactuals become interesting when noise is plausibly shared between the factual and counterfactual worlds. Our noise model for the number of infected passengers comprises two sources of noise: one that we assume is shared between the factual and counterfactual regimes, and another that is not. This latter noise encapsulates an aggregation of unknowns that may differ across the factual and counterfactual regimes. The former, however, stems from the precision of a specific infection-screening machine used by the airline to deny boarding to infected would-be passengers. This machine was built before the superspreader event, and we assume its performance is the same across factual and counterfactual worlds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.883515Z",
+     "start_time": "2023-07-18T18:47:24.780163Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# This allows us to specify non-continuous dynamics that won't be affected by e.g. counterfactual handlers.\n",
+    "class NonContinuousDynamics(StaticInterruption, _InterventionMixin):\n",
+    "    def _pyro_apply_interruptions(self, msg) -> None:\n",
+    "        with pyro.poutine.block(hide_types=[\"intervene\"]):\n",
+    "            super()._pyro_apply_interruptions(msg)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Superspreader Time tensor(0.2900)\n"
+     ]
+    }
+   ],
+   "source": [
+    "ss_time = logging_times[torch.searchsorted(logging_times, .25)]\n",
+    "print(\"Superspreader Time\", ss_time)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.883741Z",
+     "start_time": "2023-07-18T18:47:24.813977Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "landing_time = ss_time + 4/52 + 1e-4\n",
+    "landing_data = {\"infected_passengers\": torch.tensor(4.)}\n",
+    "\n",
+    "# Because counterfactuals assume the intervened state is the counterfactual world, we have to hackily invert\n",
+    "# this by treating the superspreader event as factual non-continuous dynamics, and the counterfactual as an\n",
+    "# inversion of superspreader infections immediately following the superspreader event.\n",
+    "\n",
+    "superspreader_delta = torch.tensor(15.)\n",
+    "\n",
+    "# HACK counterfactual inverts the factual intervention slightly afterward.\n",
+    "inverse_superspreader_intervention = State(\n",
+    "    S=lambda s: s + superspreader_delta,\n",
+    "    I=lambda i: i - superspreader_delta,\n",
+    ")\n",
+    "inverse_superspreader_time = ss_time + 2e-3\n",
+    "\n",
+    "superspreader_intervention = State(\n",
+    "    # The superspreader event instantaneously subtracts from the susceptible group and adds to the\n",
+    "    # infected group.\n",
+    "    S=lambda s: s - superspreader_delta,\n",
+    "    I=lambda i: i + superspreader_delta,\n",
+    ")\n",
+    "superspreader_time = inverse_superspreader_time - 1e-3\n",
+    "\n",
+    "superspreader_intervention = NonContinuousDynamics(\n",
+    "    time=superspreader_time, \n",
+    "    intervention=superspreader_intervention\n",
+    ")\n",
+    "\n",
+    "inverse_superspreader_intervention = StaticIntervention(\n",
+    "    time=inverse_superspreader_time, \n",
+    "    intervention=inverse_superspreader_intervention\n",
+    ")\n",
+    "\n",
+    "\n",
+    "def get_num_infected_passengers(num_infected_in_millions: torch.Tensor, c=2.):\n",
+    "    # Our model assumes that a given set of passengers on a plane are derived by drawing c passengers\n",
+    "    # randomly from each million people in the country of origin.\n",
+    "    number_of_individuals_infected = num_infected_in_millions * 1e6\n",
+    "    return c * 1e-6 * number_of_individuals_infected\n",
+    "\n",
+    "\n",
+    "class PlaneSuperSpreaderSIR(SimpleSIRDynamics):\n",
+    "    def observation(self, X: State[torch.Tensor]):\n",
+    "        if X.I.shape and X.I.shape[-1] > 1:\n",
+    "            super().observation(X)\n",
+    "        else:\n",
+    "            # An airline builds screening machines that detect infections in passengers. If\n",
+    "            # passengers are infected, they are denied boarding. These screening machines were built\n",
+    "            # before the super-spreader event, so their effectiveness (modeled as 0-1 accuracy rate) is\n",
+    "            # the same between the factual and counterfactual worlds. \n",
+    "            \n",
+    "            enittb = expected_num_infected_trying_to_board = get_num_infected_passengers(X.I)\n",
+    "            # The number trying to board is subject to noise we do not assume is shared between worlds.\n",
+    "            num_infected_trying_to_board = pyro.sample(\"nittb\", dist.Normal(enittb, 1.0))\n",
+    "            \n",
+    "            # The screening machines have some effectiveness rate that is shared between worlds.\n",
+    "            # This is a value between 0 and 1.\n",
+    "            se_frate = torch.sigmoid(pyro.sample(\"u_ip\", dist.Normal(0., 2.)))\n",
+    "            \n",
+    "            infected_passengers = se_frate * num_infected_trying_to_board\n",
+    "            pyro.deterministic(\"infected_passengers\", infected_passengers, event_dim=0)\n",
+    "            \n",
+    "            # The arrival country has 100% accurate tests and test all passengers on arrival, hence the\n",
+    "            # ability to observe number of infected passengers directly.\n",
+    "\n",
+    "\n",
+    "def conditioned_sir_reparam(data, init_state, logging_times, base_model=PlaneSuperSpreaderSIR) -> None:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "    reparam_config = AutoSoftConditioning(scale=.1, alpha=0.5)\n",
+    "    with SimulatorEventLoop():\n",
+    "        with pyro.poutine.reparam(config=reparam_config):\n",
+    "            with StaticObservation(time=landing_time, data=landing_data):\n",
+    "                with TrajectoryObservation(data):\n",
+    "                    with superspreader_intervention:\n",
+    "                        simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "\n",
+    "\n",
+    "def counterfactual_sir(data, init_state, logging_times) -> Trajectory:\n",
+    "    sir = bayesian_sir(PlaneSuperSpreaderSIR)\n",
+    "    with DynamicTrace(logging_times) as dt:\n",
+    "        with SimulatorEventLoop():\n",
+    "            with StaticObservation(time=landing_time, data=landing_data):\n",
+    "                with superspreader_intervention:\n",
+    "                    with TrajectoryObservation(data):\n",
+    "                        with TwinWorldCounterfactual() as cf:\n",
+    "                            with inverse_superspreader_intervention:\n",
+    "                                simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    trajectory = dt.trace\n",
+    "    with cf:\n",
+    "        factual_indices = IndexSet(\n",
+    "        **{k: {0} for k in indices_of(trajectory, event_dim=0).keys()}\n",
+    "        )\n",
+    "\n",
+    "        cf_indices = IndexSet(\n",
+    "            **{k: {1} for k in indices_of(trajectory, event_dim=0).keys()}\n",
+    "        )\n",
+    "       \n",
+    "        factual_traj = gather(trajectory, factual_indices, event_dim=0)\n",
+    "        cf_traj = gather(trajectory, cf_indices, event_dim=0)\n",
+    "        \n",
+    "        # This is a small trick to make the trajectory variables available to pyro    \n",
+    "        for k in get_keys(trajectory):\n",
+    "            pyro.deterministic(k + '_factual', getattr(factual_traj, k))\n",
+    "            pyro.deterministic(k + '_cf', getattr(cf_traj, k))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Expected Number of infected people trying to board in superspreader reality: X.I = 24.08 Million\n",
+      "Expected Screening Failure Rate = 0.08\n",
+      "Expected u_ip -2.4\n",
+      "True # Infected Passengers Factual =  4.0\n",
+      "Number of infected people trying to board in counterfactual reality: X.I = 5.04 Million\n",
+      "True # Infected Passengers Counterfactual =  0.84\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "with SimulatorEventLoop():\n",
+    "    with superspreader_intervention:\n",
+    "        num_infected_in_millions = simulate(sir_true, init_state, torch.tensor(0), landing_time, solver=TorchDiffEq()).I.item()\n",
+    "        expected_num_infected_passengers = get_num_infected_passengers(num_infected_in_millions)\n",
+    "        print(\"Expected Number of infected people trying to board in superspreader reality: X.I =\",\n",
+    "              round(num_infected_in_millions, 2), \"Million\")\n",
+    "        expected_actual_screening_rate = landing_data['infected_passengers'] / expected_num_infected_passengers\n",
+    "        print(\"Expected Screening Failure Rate =\", round(expected_actual_screening_rate.item(), 2))\n",
+    "        print(\"Expected u_ip\", round(torch.logit(expected_actual_screening_rate).item(), 2))\n",
+    "        print('True # Infected Passengers Factual = ', landing_data['infected_passengers'].item())\n",
+    "\n",
+    "with SimulatorEventLoop():\n",
+    "    with superspreader_intervention:\n",
+    "        with inverse_superspreader_intervention:\n",
+    "            num_infected_in_millions = round(simulate(sir_true, init_state, torch.tensor(0), landing_time, solver=TorchDiffEq()).I.item(), 2)\n",
+    "            expected_num_infected_passengers = get_num_infected_passengers(num_infected_in_millions)\n",
+    "            print(\"Number of infected people trying to board in counterfactual reality: X.I =\",\n",
+    "                  num_infected_in_millions, \"Million\")\n",
+    "            true_cf_infected = expected_num_infected_passengers * expected_actual_screening_rate\n",
+    "            print(\"True # Infected Passengers Counterfactual = \", round(true_cf_infected.item(), 2))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:24.956013Z",
+     "start_time": "2023-07-18T18:47:24.910383Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "class CFGuide(pyro.nn.PyroModule):\n",
+    "    \"\"\"\n",
+    "    A guide modeling the conditional distribution of noise on latent dynamic parameters as a normal\n",
+    "     with parameters defined as a linear combination of functions of those latent parameters.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    def __init__(self, original_sir_guide, noise_name: str):\n",
+    "        super().__init__()\n",
+    "        self.original_sir_guide = original_sir_guide\n",
+    "        self.noise_name = noise_name\n",
+    "\n",
+    "    @pyro.nn.PyroParam(constraint=dist.constraints.positive)\n",
+    "    def noise_std_coefficients(self):\n",
+    "        return torch.ones(4)\n",
+    "\n",
+    "    @pyro.nn.PyroParam()\n",
+    "    def noise_mean_coefficients(self):\n",
+    "        return torch.ones(4)\n",
+    "\n",
+    "    def forward(self, *args, **kwargs):\n",
+    "        self.original_sir_guide.requires_grad_(False)\n",
+    "\n",
+    "        bgd = self.original_sir_guide()\n",
+    "        beta = bgd['beta']\n",
+    "        gamma = bgd['gamma']\n",
+    "\n",
+    "        noise_mean = self.noise_mean_coefficients @ torch.tensor([beta, gamma, beta * gamma, 1.])\n",
+    "        noise_std = self.noise_std_coefficients @ torch.tensor([beta, gamma, beta * gamma, 1.])\n",
+    "\n",
+    "        noise = pyro.sample(self.noise_name, dist.Normal(noise_mean, noise_std))\n",
+    "        return noise\n",
+    "\n",
+    "cf_guide = CFGuide(original_sir_guide=sir_guide, noise_name='u_ip_0.36702409386634827')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:52.258842Z",
+     "start_time": "2023-07-18T18:47:24.941597Z"
+    },
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/pyro/util.py:303: UserWarning: Found vars in model but not guide: {'nittb_0.36702409386634827'}\n",
+      "  warnings.warn(f\"Found vars in model but not guide: {bad_sites}\")\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[iteration 0001] loss: 46851.0625\n",
+      "[iteration 0100] loss: 1142.8154\n",
+      "[iteration 0200] loss: 2829.3054\n",
+      "[iteration 0300] loss: 982.5005\n",
+      "[iteration 0400] loss: 919.4028\n",
+      "[iteration 0500] loss: 1258.7483\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Approx. posterior over latent SIR params and noise variables conditional \n",
+    "# on observed data.\n",
+    "sir_guide_reparam = run_svi_inference(\n",
+    "    conditioned_sir_reparam,\n",
+    "    n_steps=500,\n",
+    "    data=sir_data,\n",
+    "    init_state=init_state,\n",
+    "    logging_times=torch.tensor([0.0, 3.0]),\n",
+    "    guide=cf_guide,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:58.954177Z",
+     "start_time": "2023-07-18T18:47:52.258332Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Compute counterfactual\n",
+    "cf_sir_predictive = Predictive(counterfactual_sir,\n",
+    "    guide=sir_guide_reparam, num_samples=100\n",
+    ")\n",
+    "\n",
+    "cf_sir_posterior_samples = cf_sir_predictive(\n",
+    "    sir_data, init_state, logging_times\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:58.997622Z",
+     "start_time": "2023-07-18T18:47:58.954789Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def SIR_cf_uncertainty_plot(logging_times, state_pred, line_label, ylabel, color, ax):\n",
+    "    sns.lineplot(\n",
+    "        x=logging_times,\n",
+    "        y=state_pred.mean(dim=0),\n",
+    "        color=color,\n",
+    "        label=f\"Posterior Mean: {line_label}\",\n",
+    "        ax=ax,\n",
+    "    )\n",
+    "    # 90% Credible Interval\n",
+    "    ax.fill_between(\n",
+    "        logging_times,\n",
+    "        torch.quantile(state_pred, 0.05, dim=0),\n",
+    "        torch.quantile(state_pred, 0.95, dim=0),\n",
+    "        alpha=0.2,\n",
+    "        color=color,\n",
+    "    )\n",
+    "\n",
+    "    ax.set_xlabel(\"Time (Yrs)\")\n",
+    "    ax.set_ylabel(ylabel)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:59.281688Z",
+     "start_time": "2023-07-18T18:47:58.998602Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<matplotlib.legend.Legend at 0x188d90dd0>"
+      ]
+     },
+     "execution_count": 38,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x500 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['S_cf'].squeeze(),\n",
+    "    'Counterfactual',\n",
+    "    \"# Susceptible (Millions)\",\n",
+    "    \"orange\",\n",
+    "    ax=ax[0],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['S_factual'].squeeze(),\n",
+    "    'Reality',\n",
+    "    \"# Susceptible (Millions)\",\n",
+    "    \"blue\",\n",
+    "    ax[0],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['I_cf'].squeeze(),\n",
+    "    'Counterfactual',\n",
+    "    \"# Infected (Millions)\",\n",
+    "    \"orange\",\n",
+    "    ax=ax[1],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['I_factual'].squeeze(),\n",
+    "    'Reality',\n",
+    "    \"# Infected (Millions)\",\n",
+    "    \"blue\",\n",
+    "    ax[1],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['R_cf'].squeeze(),\n",
+    "    'Counterfactual',\n",
+    "    \"# Recovered (Millions)\",\n",
+    "    \"orange\",\n",
+    "    ax=ax[2],\n",
+    ")\n",
+    "\n",
+    "SIR_cf_uncertainty_plot(\n",
+    "    logging_times,\n",
+    "    cf_sir_posterior_samples['R_factual'].squeeze(),\n",
+    "    'Reality',\n",
+    "    \"# Recovered (Millions)\",\n",
+    "    \"blue\",\n",
+    "    ax[2],\n",
+    ")\n",
+    "\n",
+    "for ax_ in ax:\n",
+    "    ax_.axvline(superspreader_time, linestyle='--', color='black', label='Superspreader Event', linewidth=0.8)\n",
+    "    ax_.axvline(landing_time, linestyle='--', color='purple', label='Flight', linewidth=0.8)\n",
+    "    ax_.set_xlim((0, 1.7))\n",
+    "    ax_.legend()\n",
+    "\n",
+    "ax[0].legend().remove()\n",
+    "ax[2].legend().remove()\n",
+    "ax[1].legend(loc='upper center', bbox_to_anchor=(0.5, 1.15), fancybox=False, shadow=False, ncol=4)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:59.512271Z",
+     "start_time": "2023-07-18T18:47:59.274091Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
+      "  if pd.api.types.is_categorical_dtype(vector):\n",
+      "/Users/sam-basis/opt/anaconda3/envs/chirho-dynamic/lib/python3.11/site-packages/seaborn/_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
+      "  with pd.option_context('mode.use_inf_as_na', True):\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhsAAAGwCAYAAAAAFKcNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABn70lEQVR4nO3dd1zU9R8H8Ndx7K0MFVHAhYqoKK7EVDQ13KWWFoplaVlqw1y4cqZlFqll1s+9KDWLNNPStMy9BWPLUIaKcse++/7+OO4UAWUd3xuv5+PBo/PG9/u+g/i++EyJIAgCiIiIiLTEROwCiIiIyLAxbBAREZFWMWwQERGRVjFsEBERkVYxbBAREZFWMWwQERGRVjFsEBERkVaJEjYEQYBMJgOX+CAiIjJ8ooQNuVyOjh07Qi6Xi3F6gyGXyyGRSCCRSPhZEpHhkcsBiUT1xd9xeo3dKERERKRVDBtERESkVQwbREREpFUMG0RERKRVpmIXQFVnamqKcePGaW4TERHpIl6h9JiFhQU2btwodhkAAKVSiYKCArHLICIdY2ZmBqlUKnYZJDKGDaq2goICxMfHQ6lUil0KEekgR0dH1K9fHxKJROxSSCQMG3pMEATk5OQAAKytrUX5H1kQBNy6dQtSqRSNGjWCiQmHARGRivp3VHp6OgCgQYMGIldEYmHY0GM5OTmwtbUFAMhkMtjY2NR6DUVFRcjJyYGbmxusra1r/fxEpNusrKwAAOnp6XB1dWWXipHin6FULQqFAgBgbm4uciVEpKvUf4gUFhaKXAmJhWGDagT7YomoPPz9QAwbREREpFUMG0RERKRVDBtklAIDA+Ht7V3m16lTp576+qSkJBw7dgwAkJycDG9vbyQnJ9d4nTKZDPv27avy68PCwhAcHPzE55w/fx4TJ05Ely5d0KlTJ4wfPx4XLlyo8jkrKzIyEufPn6/y6xMTEzF06FD4+vpi9erV1arl5MmTiI2NrdYx1AIDA7Fnz54aORaRvmPYIKM1e/ZsnDhxotSXn59fhV57+fJlAKrpfCdOnNDKtL6NGzfixx9/rPHjqv32228YN24cWrZsic2bN2Pnzp1o0aIFxo4di3PnzmntvI+aPHkyEhISqvz6rVu3AgAiIiIwfvz4atUSEhKCzMzMah2DiErj1NcqyitU4GzCPRQplejW1AkWprU/nUsqlWLEiBGa21Q5dnZ2cHFxqfZxpFJpjRynLIIgaOW4gKrVZN68eXjrrbfw9ttva+6fNWsWUlNTsXLlSuzcuVNr568pMpkMLVu2ROPGjcUuhYjKwZaNKriUlIX+q//Cq9+dQsj/zqD3yqM4FXen1uuwtLREeHg4wsPDYWlpWevnL48gCMgpKKrVL21clE+ePKlpnu/Tp4/mwjtz5kycPn0aX331FYKDg0t1o3h7e+PAgQN4/vnn0a5dO7z//vtISkrC2LFj0a5dO4wZMwZpaWmaz+rrr79GYGAg2rRpg4CAAHz11VcAgD179uCrr77C6dOn4e3tDUC1WuvixYvRpUsXdOnSBR9++CGysrI0NcfExGD06NFo164dxo4di3v37pX7/v744w/IZDKMHTu21GMzZszA4sWLNf++cOECRo8ejfbt2yMwMBA7duzQPDZz5kzMnDmzxOsf7Y4KDAzEtm3bMGrUKPj6+mLo0KG4evUqACA4OBgpKSmYNWuW5hj//fcfgoOD0bZtW/Tv3x/btm3THDcsLAxvv/02XnnlFXTu3BnBwcHYs2cP9u3bp/kepKWlYcqUKejUqRPatGmD4cOHl2ilSUxMxOuvvw4/Pz/06tULmzdv1tQJAGPHjkVYWBj27NmjuU8tODgYYWFhmu/FsmXL0KNHD/j4+CAwMBC7du0q9/MmMmZs2aik1KxcjN94BnflBbC3NIXURILU+3kYv/EMtk3oAr/GdcQuUVSCIGDE1ydxLrH8i5w2+HvUQfikbjU2xU6hUGDatGkICQnB4MGDcf78ecyYMQP+/v6YM2cOEhIS4Ofnh4kTJ0Imk5V6/Zdffonly5cjNzcXEyZMwOnTpzFnzhzMmjULU6ZMwbfffovQ0FDs27cPmzZtwqpVq9CoUSMcP34cCxYsQO/evREUFITo6GhcuHBBc4FbtWoVrl69im+//RYWFhb4/PPPMXXqVGzatAkFBQV488034e/vj8WLF+Pff//F0qVL0aFDhzLfY1RUFJo0aaJZGO5R7u7umtuxsbEYN24cQkJCsGTJEly6dAkLFy6Es7MznnvuuQp9nmFhYVi8eDGaNm2KuXPnYvHixdi5cyfCwsIwdOhQvPbaa3jhhReQl5eHN954A8OHD8eiRYsQFxeHuXPnwsbGBsOGDQMAHDlyBAsWLED79u3h7u6OuXPnAgDmzJmDunXrIiQkBPb29ti5cycEQcCnn36KBQsW4Oeff0Z+fj5ee+01+Pj4YPfu3UhKSsIHH3yARo0a4YcffkC3bt0QFhaG7t2747fffnvie1q/fj2OHj2KsLAwODk5Ye/evVi0aBH69OkDZ2fnCn0uRMaCYaOSpv9wCXflBfBxs8eON7vCXGqCNzafxfHoTEzbdREHpvaAtblxf6z6MqN+/vz5WLRoUYn73NzcEBERgezsbGRlZcHZ2Rnu7u5wd3eHq6srXFxcYGdnBzMzM1hbW8PR0bHMsBESEoJ27doBAFq1agUvLy88//zzAIB+/fohKioKgGq8x7Jly9CtWzcAwOjRo7FmzRpER0fDx8cH1tbWMDMzg4uLC3Jzc7F161b8+OOPmpaOFStWoEuXLrhx4wZu3bqFrKwsLFiwANbW1mjatClOnz6Nu3fvlvn+s7Ozywwaj9u9ezdat26N999/HwDQpEkTxMbGYsOGDRUOG8OHD0ffvn0BAOPHj8fUqVMBqPbMkEqlsLOzg52dHcLDw+Hk5IRp06YBADw9PZGSkoLNmzdrwoazszNGjx6tOba6Vc/FxQWCIKBv377o378/6tevDwB45ZVX8OabbwIATpw4gbt372Lp0qWwtbVF8+bNERoaChMTE9StWxcA4ODgUKHVeFu2bImuXbuiffv2AIBJkyZhzZo1SEhIYNggeoxxXxUr6Z+YTPwdcwfmUhOsfaUD7C3NAABrX+mA/p//hcQ7OVh9OBqzg1rVSj1yuVz05cofJ5FIED6pG3ILFbV6XiszaaVbNaZMmYJ+/fqVuM/UVPW/hKOjI0aPHo3Q0FCsXbsWvXv3xosvvggHB4cKHbtRo0aa25aWlmjYsGGJf6t3yO3atSsuXbqEzz77DLGxsYiMjERGRkaZm9olJSWhsLAQL7/8con7lUolEhISkJSUBE9PzxLLxvv6+mpmzTzO0dERDx48eOp7iY2NRdu2bUvc5+fnV6nxHJ6enprbtra25a4kGRcXh6ioqBKDdBUKRYkxSY9+lo+TSCQYPXo0fv31V5w/fx7x8fG4evWq5vOMj4+Hl5dXiZD14osvVvh9PKpv3774+++/sXz5csTFxeH69euaeomoJIaNSlh9JBoAMKZLY3g4Pbyw21maYfHwNnht41ls/CcB47t7ooGDlVhlik4ikehF646TkxM8PDzKfXzBggV45ZVXcPjwYRw+fBi7du3C2rVr0bNnz6ce+/EBu+VtUBceHo6lS5di5MiR6NevH2bMmFHmGArg4UVs+/btpfahcXJy0nQbPMrMzKzcGn18fPD9999DJpOVauE4e/YsNm7ciJUrV8LCwqLUa5VKpaYeiURS4rxFRUWlnv+kOh5VVFSEbt26Yd68eeU+p6x6Hq3rtddew4MHDxAUFITAwEAUFhbinXfeAfAwTFZEWeH10ff2+eefIzw8HC+88AKGDRuG+fPnlxrjQUQqHCBaQTHpMpyOvwupiQSTejYt9Xhvb1d09qyLgiIl1vwZI0KFVJMyMjKwcOFCeHh44K233sKPP/6Irl274o8//qjR8+zYsQOTJ0/G7NmzMWzYMNSpUwd37tzRXLwfveA1atQIUqkUWVlZ8PDwgIeHB2xtbbFs2TLcuXMHzZs3R0JCArKzszWviYyMLPfcPXr0gJ2dnWbq6KM2bdqE27dvw8rKCl5eXrh06VKJxy9cuAAvLy8AqiAhl8s1jyUlJVXtwwDg5eWF+Ph4uLu7a97jxYsXsWXLlgq9PiYmBmfOnMHGjRsxadIk9OrVS7PjqCAI8PT0RGJiInJzczWv+eSTT0oMhlV7/H0JglBiLZWdO3di7ty5+PDDDxEUFKQ5pjZnEBHpK4aNCvrhnOqXTK8WLqjvUHrmh0QiwbTnmgMAws8m4568oFbro8rLzs5GRkZGqa+cnBw4ODjg999/x9KlS3Hz5k2cOXMGUVFRaN26NQDVxlIJCQm4c6d6s5Dq1KmDkydPapr733vvPRQWFmq6WaysrJCeno7k5GTY2tpi5MiRWLBgAU6dOoWYmBh89NFHSExMhLu7O5555hk0aNAAc+bMQWxsLPbs2YNff/213HPb2Nhg9uzZCAsLw+rVqzXdOHPnzsXRo0cRGhoKABgzZgwiIyOxatUqxMfHY+/evdi+fTteeeUVAKqumr///hsnT57Ef//9h48//rjCLRmA6rOMi4tDVlYWhgwZgry8PMybNw+xsbE4duwYlixZAicnpwody97eHiYmJoiIiEBKSgoOHjxYYvZIQEAAnJ2dNcc/cuQIdu7ciYCAAE0t0dHRyM7ORps2bZCVlYUtW7YgKSkJy5Ytw/379zXncnR0xJ9//omkpCScPXsWH330keY8RFQSw0YFKJUC9l5QhY2R/o3KfV63Jk7wcbNHfpES20/frK3yqIqWLl2KgICAUl8bN26Eubk51q5di6ioKAwZMgTTpk3DiBEjMHLkSADAyJEjcfz4cUyYMKFaNcyePRsymQxDhw7Fu+++C29vbzz33HOaFonnnnsOSqUSAwcOxJ07dzBz5kx069YNU6ZMwahRo2Bqaor169dDKpXCzMwM33zzDe7fv4/hw4djx44dmkBQniFDhmDNmjU4c+YMXn75ZYwbNw6pqanYtm2bZuCjm5sbvvnmGxw/fhyDBw/GunXrMHPmTM1Yh6FDh6J///54++23MWHCBAwaNAiurq4V/gxGjx6Nbdu2ITQ0FLa2tvj222+RkJCAYcOGITQ0FK+88gomTpxYoWPVr18fCxYswLfffotBgwZh/fr1CA0NhampKa5fvw5TU1OsXbsW6enpGD58OJYsWYKPPvoIvXr1AqCa2rpixQqEhYXB09MTM2bMwLp16zBs2DAIgoD+/ftrzrV06VJERkZi4MCBmDVrFgYMGIC2bds+sTWJyFhJBBHa/GQyGTp27Ihz585VaDS82C4lZWHomr9hYy7F+XnPPXEBrz3nk/H+7kto6GiF4x/1homJ9uZm6MIA0by8PM2gO11a64OIdEeVf0/I5YD6GiGTATowCJ6qhi0bFXAkUrUA07MtXJ66UmiQbwPYWZoiJSsX/4qw0BcREZGuYdiogMORqgFmfVvVe+pzLc2kGNLODQAQfq7mN+Z6lFQqRVBQEIKCgrhcORER6SyGjafIlOXj+i3VWgS9vCu2/8WIjqrVFw9cvYXsvLLXE6gJlpaWiIiIQEREBLswiIhIZzFsPMWpONXqiy3r28HJtvz5/Y9q38gRTV1skFeoxK9XbmmzPCIiIp3HsPEU6nEXXZtUbOodoJoGq561En5Wu10pREREuo5h4ylOxavDRt1KvW64X0NIJMDZxHtIupujjdIgl8thY2MDGxubEosPERER6RKGjSe4Jy/Af2mqTbY6e1W8ZQMA6tlb4pmmqtfsv5Ra47Wp5eTkICdHO2GGiIioJjBsPMHF5CwAQBNnG9S1Ma/064e2U20Ytf+i9sIGERGRrmPYeIJLSVkAgHaNHKv0+v5t6sNcaoIbadmIuv303TVJHHv27IG3tzfCw8Nr9JgV3ZTr5MmTiI2NrfTrnmTmzJmYOXNmubV5e3uX+RUcHFztc1dHZGQkzp8/X+XXBwYGYs+ePeU+rlQqsWnTJgwZMgTt2rVD7969sXjxYmRlZVX5nJUhCAK2bdtWrWPs2rULXbt2hZ+fH2Jiqr4PU0FBAXbv3l2tWtROnToFb2/vGjkWGSaGjSe4WBw22lcxbDhYmaF3S9V02Z/YuqGzIiIi0LhxY/z000+inD8kJASZmZkAgKCgIPzwww9aP2f9+vVx4sSJUl/qfUTEMnnyZCQkJGjt+FOnTsWmTZswadIk/PLLL1i+fDnOnz+PCRMmID8/X2vnVTtz5gw+/vjjah1j5cqVGDNmDH755RfNZnhVERERga+//rpatRBVFMNGOQRBqHbLBgAMbf+wK0Wp5G6QuubOnTs4efIkJk+ejLNnz1Zrx9KaYGlpibp1KzcYuSqkUilcXFxKfTk6Omr93GLZv38//vzzT2zcuBFBQUFo1KgRunTpgvXr1yMmJqZWwmZN7A6RnZ2Nzp07o2HDhtVazI+701JtYtgoR/K9XNzLKYSZVIJWDeyqfJzAlq6ws1AtX37u5r0arJBqwsGDB2FnZ4chQ4bA1dW1xAUnMDAQ27Ztw6hRo+Dr64uhQ4fi6tWrmsfPnTuH0aNHo127dmjfvj3eeOMNzXbmjxo/fnypLcwnTZqE1atXa7pMxo4di7CwsFLdKJcvX9aco3///oiIiNA8Fh4ejgEDBqBNmzbo0qULFi5cCIVCUSOfy/Tp0zFgwAAUFqoWpfvxxx/RsWNH3Lp1C3v27MHo0aPx6aefws/PD7169SrRBSUIAtasWYOAgAD4+/tj0qRJSE192LJ3584dTJs2DR06dED37t2xatUqCIKA4OBgpKSkYNasWZouoP/++w/BwcFo27Yt+vfvX6oLYufOnejVqxc6dOiAtWvXPvE97d27F8899xwaN25c4n5nZ2ds2rQJ/fr1A6DqatmwYQP69OmDtm3bIjg4GDdu3NA839vbG6dOndL8+9Hv2alTpxAYGIjt27ejR48eaN++PaZPn46CggIkJydj7NixpY6xc+dOBAYGws/Pr9S5AgMDsXLlSgQEBGDYsGGaropx48ZpuryOHDmCYcOGwdfXF/7+/nj//fdLzE776aefMGDAALRr1w4vv/wyrl+/jlOnTmHWrFlISUmBt7c3kpOTERwcXKJlKzk5WfMYAMTExOD111+Hn58ffH19MWbMGE33H9HTMGyUQ71qaIt6dk/dD+VJLM2k6N+mPgDgp4spNVKbmomJCXr27ImePXvCxES3vpVyubzcr7y8vAo/Nzc3t0LPraqIiAj06tULJiYmCAwMxL59+0r8xRcWFoY333wT+/fvh52dnSY0ZGdnY+LEiejevTt++eUXfPfdd7h58ybWr19f6hwDBw7EoUOHNMfNzs7GiRMnMHDgQE2XSVhYGF577bUSr7tz5w5ee+01tGrVCnv37sXEiRMxY8YMREVF4fTp01i8eDHef/99HDx4EAsXLsQPP/yAI0eOVPmzeNSsWbNw7949bNmyBXfu3MGKFSvw0UcfoUGDBgCAK1euIDIyErt27cI777yDhQsX4sSJEwCArVu34ueff8Znn32GXbt2wcnJCa+99pomuEyePBkZGRnYunUrVq9ejT179mDbtm0ICwtD/fr1MXv2bMyZMwd5eXl444030LFjR+zfvx8zZszA2rVrsW/fPgDA8ePHsWTJEkybNg27du3ClStXkJJS/v9jUVFR8PX1LfOxdu3aaVp11qxZg++//x6zZ8/G3r170bBhQ0yYMKHCs77S09Px22+/YcOGDQgLC8OhQ4ewb98+NGjQQHMxP3HiBPz8/PDHH3/gq6++wty5c7F371507NgRY8eOLbGV/c8//4zvvvsOy5cv13zGYWFhCAsLw82bNzF16lSMGTMGBw4cwOrVq/HPP/9oxmIcP34cc+bMwbhx47B//360adMGEydOhJ+fH2bPnq3pTlN/X8ujVCoxadIkNGzYED/99BN27twJhUKBlStXVugzITIVuwBddT1VFTZaNbCv9rGGtnfDD+eSEXH5FuYP9oGZtGaCgZWVFY4ePVojx6ppT9rNNygoqMRf6K6uruX+Iu/Zs2eJ9+jp6akZ3/CoqjQJ37p1C+fPn8f48eMBAP369cOOHTtw7tw5+Pv7AwCGDx+Ovn37AlC1UEydOhWAahfLt99+G+PHj4dEIkGjRo3Qr18/XL58udR5+vXrhwULFuD8+fPo2LEjDh8+DC8vLzRv3lzzHAcHh1K79kZERMDBwQGhoaEwMTFBkyZNcP/+feTl5cHa2hpLlizR/DXu7u6O//3vf4iOjtbc9ySpqanw8/Mrdf/ChQsxZMgQ1K1bF7NmzcLixYtx6tQptGrVCi+99JLmeRKJBCtWrICTkxNatGiBM2fOYPfu3QgICMCGDRswf/58dOnSBQDw8ccfIyAgAMePH4ebmxsuXLiAw4cPo1Ej1cJ3CxYsQE5ODhwdHSGVSmFnZwc7OzuEh4fDyckJ06ZNA6D63qekpGDz5s0YNmwYwsPDMXjwYAwbNgyAasv3nj17lvues7OzYWf35FZKQRCwdetWvP/+++jTpw8AYNGiRXjuueewf/9+vPzyy0/9bAsLCxEaGormzZvD29sbPXr0wJUrVzBq1Cg4ODgAAFxcVGO5NmzYgIkTJ6J3794AgGnTpuGvv/7C/v37NS0XQ4YMKTX40sHBAY6OjsjKykJoaChGjRoFQPVz8MwzzyA6OhqAajDpoEGDMHr0aADARx99BDMzM9y/fx92dnaa7rSnycvLw8svv4wxY8bA2toagOr/jQ0bNjz1tUQAw0a5Im/VXNjo1sQJzrYWyJTl40R0Jnq3dK32Man6IiIiYGFhgYCAAABA586d4eDggL1792rChqenp+b5tra2mr/OXVxcMGzYMGzcuBGRkZGIiYnBjRs30KFDh1Lnsbe3x7PPPouDBw+iY8eOOHDgAIKCgp5aX3x8PFq3bl2i1UodjADV+I4vv/xSc+7ExETNe3kaV1dXbNmypdT9Tk4P15MZNmwYfvzxRxw/fhy//fZbied5eHiUeG6bNm2wc+dOyOVy3L59G++9916JuvPy8pCQkID8/Hw4OjpqggYATZh7XFxcHKKiokqEIoVCoRmnEBsbW+LiX6dOnRLHfZyjo2OJFoOy3LlzB1lZWWjXrp3mPjMzM7Rp06ZSXQYeHh6a27a2tigqKirzebGxsVi5ciVWrVqluS8/P7/EINmGDRuWex5PT0+Ym5tj3bp1iI6ORnR0NGJiYjB06FAAqp+hRz8jc3NzzJgxo8LvQ83a2hqjR4/Gvn37cPXqVcTFxeH69etwdnau9LHIODFslEPdjdK6BsKGqdQEg9o2wMZ/EvDTxRSjCBsymazcxx4f1FbWOAe1x7uHanKmQkREBPLy8tCxY0fNfQqFAgcPHsTcuXMBqC40ZUlLS8OLL74IHx8fPPPMMxg1ahSOHj2KS5culfn8QYMG4ZNPPsG7776Lf/75B6GhoU+tz9S0/P89jx8/jsmTJ2PYsGHo0aMHJk+ejIULFz71mI8e+9ELYlnkcrlmwOzZs2dLXMgfr02hUMDExEQzZuSLL74oNVPCwcEBZ8+erXCNRUVF6NatG+bNm1fucx5v0Srv+wUAPj4+uHbtWpmPrVq1Ck5OTnjhhRfKfFyhUECpVJb72OPMzUuuy1Ney5tCocDs2bPRrVu3Evc/2jJoYVH+nkxRUVEYPXo0AgMD4e/vj5CQEGzatEnz+JN+hp7m0fcll8sxYsQI1KlTB4GBgRg0aBDi4uLw/fffV/n4ZFx0q6NfR9zPLUTyPdVYgZoIGwAwzE/118mh62nIKSj7r5zKksvlmlkEurZcuXoZ9bK+Ht+h9knPtbKyqtBzKys+Ph7Xr19HaGgo9u3bp/n6/PPPIZPJ8Pvvvz/x9b///jscHBzwzTffYNy4cfD390dSUlK5F5XAwEA8ePAA3333Hby9vUsNUiyLp6cnbty4UeKY06ZNw4YNGxAeHo4XX3wRH3/8MUaOHImmTZvi5s2bNTrDYPXq1XB0dERoaCiWL1+Ou3fvah5LTEws8TN39epVtGjRAvb29nByckJGRgY8PDzg4eGBBg0aYOXKlYiPj4eHhweysrJw69bDDQo3b96Mt99+u9T5vby8EB8fD3d3d82xLl68qGmRad68Oa5cuaJ5vkwmQ2JiYrnvZ8iQITh8+HCpGUdpaWnYtm0bTE1NYWdnB2dnZ1y8eFHzeGFhIa5du6YJT2ZmZiXee2VmMEkkklLv8fbt25r35+Hhga+//rrE+Z/kp59+QqdOnfDZZ59hzJgxaNu2LRITEzU/Bx4eHoiKitI8X6FQIDAwEOfOnStVi7m5ebnv6/Tp00hPT8fmzZsxYcIEPPPMM0hNTeWMFqowho0yRKdlAwAaOFjCwbr8v5Qqo527AzycrJFToMDv19Nq5JgAkJmZWeYYBnqyiIgIODo64qWXXkKLFi00X0FBQWjWrJlmEGJ5HB0dkZqaipMnTyIpKQnr16/HoUOHUFBQUObzLS0t0adPH/zvf//DwIEDSzxmbW2N6OhoZGdnl7h/8ODByMrKwooVK5CQkIA9e/bgyJEj6N69OxwdHXHhwgXcuHED0dHRmDlzJjIyMso9/+MUCgUyMjJKfal/lq5cuYLt27dj3rx5ePnll+Hu7o6lS5dqXp+Tk4P58+cjNjYWu3fvxsGDBzFmzBgAqnVDVq9ejT/++AMJCQkIDQ3F+fPn0aRJEzRv3hxdu3bFnDlzcOPGDZw6dQrr169H9+7dNZ9FXFwcsrKyMGTIEOTl5WHevHmIjY3FsWPHsGTJEk33zauvvooDBw5g9+7diI2Nxbx580oNPn5UUFAQOnfujHHjxuHAgQNISkrCsWPH8Prrr6Np06YYMWKEpv4vv/wSf/zxB2JjYzF37lzk5+drur58fX2xdetWJCQk4MiRI09cROxx6vB89epV5OfnY/z48di0aRP27duHmzdvYuXKlThw4ACaNm1aoeM5Ojrixo0buHz5MuLj47F8+XJcuXJF83MQHByM/fv3Y+/evUhMTMSyZcsgCAJ8fHxgZWWF+/fvIyEhAUVFRWjTpg0OHDiAy5cv4/Lly/jyyy9LnCcnJweHDx9GcnIywsPDsW3btgr/vBGxG6UM0emqLoDm9ao+5fVxEokEQ9u54cs/YrD/Yqpm/Q0SR0REBAYPHlyquRsARo8ejSVLljxxhs/zzz+PM2fOYMqUKZBIJPD19cWMGTMQFhZW7i/goKAg/PLLL6XGawQHB2PFihW4efMmWrZsqbnf3t4e33zzDZYuXYotW7agUaNG+Oyzz9CqVSu88847mDVrFl566SXY2tqiZ8+eGD16NCIjIyv0/m/fvl3m+A6pVIrLly9j7ty5GDx4sGYMyvz58/HSSy9pBmM2aNAALi4uGDFiBFxcXLBy5UpNd9Trr78OuVyOefPmQSaToU2bNvjuu+80gyNXrlyJhQsXamp/6aWXNEFFPaU2ISEBX331Fb799lssXboUw4YNg6OjI1555RVMnDgRAODv749ly5Zh9erVuHv3Ll588UW0atWq3PcskUiwdu1arF+/HqtXr8atW7fg7OyMvn37YvLkyZruitdeew0ymQxz586FTCaDn58ftmzZoln/ZO7cuQgNDcWgQYPg6+uLKVOmVHhxLG9vb3Tv3h0vv/wyVq1ahaCgIGRmZuLLL79EZmYmmjVrhnXr1pUYK/QkwcHBuH79OkJCQmBhYYFOnTph8uTJmgHYnTp1wvz587FmzRpkZGSgTZs2+Prrr2FpaYmuXbvCw8MDgwcPxvbt2zF+/Hj8999/ePXVV1GvXj3MmTNH81n7+flpuury8/Ph7e2NefPmYc6cOUhLq7k/nshwSQQR2sFkMhk6duyIc+fOPXHWglg+/vk6vv87Hq8HeGHuoNY1dtyY9Gz0XfUXTE0kOD2nb5X2W3mUXC7XfH4ymaxK3QnVlZeXh/j4eHh5eZXqHqGSdu/ejf3792Pr1q1il1Ite/bswVdffYU//vhD7FJIT1T594RcDqivETIZIMLvOKoZ7EYpQ3S6qjm7uWvNBqFmrnbwbeiAIqWA3WfFXamSak9iYiIiIiKwbt06jBw5UuxyiIhqHcNGGWI03Sg13+oytptqBsDmfxJQpCh7dDsZluTkZMyZMwcdOnTA4MGDxS6HiKjWMWw8JjuvELfuqwaZNXOpuTEbaoPbucHJxhyp9/Pw2zX2dRqD7t274+LFi/jss890bqXXqnjhhRfYhUJElaL/v/lqmLpVw8XOosZmojzK0kyKV7qqWje+/zu+WscyMTGBv78//P39DeIiRkREholXqMck3FHNM2/irL2BSK92bQwzqQTnEu/hfDU2Z7OyssKZM2dw5syZUutREBER6QqGjcckZKr26PB00l7YcLWz1Ex9XXXoP62dh4iISBcwbDwmsbhlw8PZWqvnmdqnOcylJjgRk4mjN8pfrpuIiEjfMWw8JuGO9ls2AKBRXWvNzJS5P11FbkHp/RWeJicnB56envD09Kzw9tdERES1jWHjMZqWDSfttmwAwLTnWsDNwRJJd3Ox8OeyN4h6EkEQkJiYWGIvBCIiIl3DsPGI+zmFuJej2kJc2y0bAGBrYYoVI9rBRALsPJOEb/+K0/o5SSUwMBDe3t6ar5YtW6Jz58546623SmwSVlVhYWEIDg4GoFpxMzAwUPPYyZMnK7VdORGRvmPYeETiXVWrhoudBWwsamfbmIDmzvhogGo/jCW/RmLFwSgu9lVLZs+ejRMnTuDEiRM4duwYPv/8c0RHR2PGjBk1ep6goCD88MMPmn+HhIRw8zwiMioMG494OF5D+10oj5r4bBNM7dMcALD2aCz6rf4LP11MgULJrhFtsrOzg4uLC1xcXFCvXj10794dU6ZMwalTp0rtwFodlpaWmk28iIiMEcPGIxIz1eM1anezH4lEgveea4Gw0X5wtDZDXIYcU3deRN9Vx7Dz9E3kF1V+8ChVjXoXWBMTEzx48ADTp09Hhw4dEBAQgEWLFpXYwvzIkSMYNmwYfH194e/vj/fffx9yubzUMR/tRlH/d+zYsQgLC0O/fv3wv//9r8TzBw8ejPDwcG29RSKiWsew8QixWjbUBrdzw/GPemN6f284WpshPlOOmXuuoN/nf+FcYtUX/6p1gqDarbE2v2pggOzNmzexfv169OjRAzY2NpgzZw6ys7OxY8cOrF27FleuXMHHH3+see7UqVMxZswYHDhwAKtXr8Y///yD3bt3P/Ec6u6UsLAwvPbaaxg4cCB+++03zeOxsbGIj49Hv379qv1+iIh0Re0MTNATD2eiiLeNsZ2lGSb3boaQZzyx4/RNrP8rDol3cjB6/b/4Jrgjerd01TxXIpGgdevWmts6QRCAgADgn39q97zduwPHjwOV+Bzmz5+PRYsWAQCKiopgZmaGPn36YPbs2bh58yYOHz6M06dPw85OtUfOokWLMGzYMMyaNQtKpRKhoaEYNWoUAMDd3R3PPPMMoqOjn3hOdXeKg4MDbGxsMGjQIKxbtw63b99G/fr1ceDAAQQEBMDBwaEqnwIRkU5i2HhEba2xURE2FqaY0KMJRvo3wofhl/D79TRM3HoO+9/pjpb17QEA1tbWuHat8lNmtU5Xgs9TTJkyBf369YNcLkdYWBhSUlLwwQcfoE6dOrh48SKUSiWeffbZEq9RKpVITExEmzZtYG5ujnXr1iE6OhrR0dGIiYnB0KFDK1VD06ZN4e3tjYMHDyIkJAQHDhzAxIkTa/JtEhGJjmGjmCy/CJmyfABAY5G6UcriYGWGta90wIRNZ3HsvwxM2XEBP78bAAtTqdillU0iUbUw1PYiY9bWlQ45Tk5O8PBQLaz2xRdfYMSIEXj77bexa9cuKBQK2NnZ4ccffyz1unr16iEqKgqjR49GYGAg/P39ERISgk2bNlWp9IEDB+LQoUPo0aMHkpOT0adPnyodh4hIV3HMRjF1F0pdG3M4WNX8bq/VYSY1wWej2sHZ1hz/pcmw83SS2CU9mUQC2NjU7lc1W1PMzc2xePFiREZGYuPGjfDy8kJ2djYkEgk8PDzg4eGBvLw8rFixAgUFBfjpp5/QqVMnfPbZZxgzZgzatm1b5cXVBg0ahEuXLmHfvn3o2bMnbGzEb1kjIqpJDBvFEou7UBrX1Z1WjUc521pgat8WAICwP2KQU1CEnJwc+Pj4wMfHh8uV14C2bdtixIgRWLt2LWxtbdGjRw98+OGHuHz5Mq5du4ZZs2YhJycH9vb2cHR0xI0bN3D58mXEx8dj+fLluHLlCgoKCp56Hmtra0RHR2um17q5uaFt27bYtGkTBg4cqO23SURU6xg2iiXf0+2wAQAvd2qERnWtkCnLx8+XUiEIAq5fv47r169zufIa8t5778HMzAwrV67EihUr4O7ujpCQEIwfPx5eXl5YtWoVACA4OBjt27dHSEgIxowZg9TUVEyePBnXr19/6jmCg4OxYsUKhIWFae4LCgqCqakpevXqpa23RkQkGokgwlVKJpOhY8eOOHfuHGxtbWv79GVasP8aNv6TgEk9m2Lm8y3FLqdcXx+LxfIDUWjn7oDt4/00n59MJhOl+T0vLw/x8fHw8vKCpaVlrZ/fUHz++ee4ffs2PvnkE7FLIapxVf49IZcD6muETKbqMiW9xJaNYsn3cgEADetYiVzJk43o6A4zqQSXku8j8tYDscuhaoqKisLevXuxfft2jBw5UuxyiIi0gmGjWGqWKmy4O+p22HC2tUBvb9VaG79fvy1yNVRdV69excKFCzFy5Ej4+/uLXQ4RkVZw6muxlOKw4abjYQMA+vvUx6HraTh8PV3sUqiaRowYgREjRohdBhGRVrFlA6o1Nu7nqraWd3PU/XEHfVq5QmoiQXS6TOxSiIiInophAw+7UOwtTWFnqVtrbJTF0docnT3rAhLAuX5DeHh4iL5cOWfDEFF5+PuBGDbwsAulYR3dnfb6uIDmzjAxs8SLK35CQkICrK3FqV0qVa1kWpH1JYjIOKnXATIz0/0/5kg7OGYDQIp6JooedKGodW3iBAD4N/4OlEoBJibitGyYmprC2toaGRkZMDMzg4kJ8ysRqQiCgJycHKSnp8PR0VHzxwkZH4YNPNKyoQeDQ9XaujvAxlyKrJxCRN5+AB83cXYJlUgkaNCgAeLj45GYmChKDUSk2xwdHVG/fn2xyyARMWzg4ZgNfZiJomYmNYFfQ2uEL5iAQT9Z4vr5U7CyEqd+c3NzNG/enF0pRFSKmZkZWzSIYQN4pBtFxxf0elxbNwdsux2NhNuqrc/FZGJiwhVEiYioTOxgx8OWDX3qRgGAto3E6TohIiKqDKMPG4UKJW4/yAOgf2HDt+HDsHFPzi4MIiLSTUYfNtIe5EEpAOZSEzjbWohdTqU4Wptrbl9JyRKvECIioicw+rChHq/RwNFStOmjNeFaCjdlIyIi3WT0YSP1vn6O13jcjbRssUsgIiIqE8NGlmq8hj5Ne32UQx0nmFjZ4z+GDSIi0lFGHzZuFbdsNHDQv2mbNjY2iLmZgkZTtuNmthI5BUVil0RERFSK0YeN2/fzAQD17PUvbACAs60FnG0tIAjAf2ncBZaIiHSP0YeNtOJpr/X1NGwAQKsGdgCAyFscJEpERLrH6FcQVa+xUV8Pu1Fyc3Px/PPPI/FODpT9ZuLGbY7bICIi3WPUYaNQoUSmTH+7UZRKJY4dOwYAaPScgNgMdqMQEZHuMepulIzsfAgCYCaVwMnG/Okv0HGx6QwbRESke4w6bKi7UFzt9HtBL7XU+3mQ53NGChER6RajDhtp94vDhr1+LVNeFidbMwBgVwoREekcow4btw1gJopaE2dbAAwbRESke4w6bKQ90N/BoY/zcrEBAMRw3AYREekYo56NkqbH017VrK2tAQBeTjYAMpFwJ0fcgoiIiB5j1C0bt+/rdzeKjY0N5HI55HI5mjd0BgDcZNggIiIdY9RhQ92yYQjdKI2dVC0cN+8ybBARkW4x2rAhCIJerx76uMZ1VWHjfm4h7ucUilwNERHRQ0YbNrLzi5BToACgv90oeXl5GDhwIAYOHAgTZRGcbVVTeNm6QUREusRoB4iq19iwtzSFlblU5GqqRqFQ4Ndff9XcblzXCpmyfNy8mwNfdweRqyMiIlIx2pYNQ+pCUfNwUk1/TbwrF7kSIiKih4w3bNw3nMGhao2Kx20ksRuFiIh0iNGGDUOaiaKmHiSayOmvRESkQ4w4bKhWD9XXwaFl8eD0VyIi0kFGGzbSsw1nEzY1dctGalYuChVKkashIiJSMdqwkSkrAADNdFFD4GpnAQtTEygFIOVertjlEBERATDqsKHqRtHnsGFjYwNBECAIAmxsbCCRSDStG+xKISIiXWG8YSNbHTbMRa6kZmkGiTJsEBGRjjDKsJFboIC8ePVQZzv9bdkoi3qPFE5/JSIiXWGUYUPdhWJuagI7C/1dRDUvLw8jR47EyJEjkZenGvCq6Ubh9FciItIRRhk2MorDhoutBSQSicjVVJ1CocAPP/yAH374AQqFqqWmoaMVACD1PgeIEhGRbjDKsGGo4zUAwE0dNrIYNoiISDcYZ9gwwGmvauqwkSkrQH6RQuRqiIiIjDZs6P+01/LUsTaDhanq26re/4WIiEhMxh027AyvG0UikWhaN1LYlUJERDrAuMOGAbZsAICbo2q/l1tZbNkgIiLxGWfYyDbcMRsA0MBB1bJxizNSiIhIB+jvIhPVYCgtG9bW1pDJZJrbam4OqpaNFLZsEBGRDjDKsKFZZ0PPx2xIJBLY2NiUul89ZoMtG0REpAuMrhslr1CB7LwiAPrfslGeBuqwwZYNIiLSAUYXNu7IVeM1zKQSOFiZiVxN9eTn5yMkJAQhISHIz8/X3K/uRuHCXkREpAuMLmyoVw91stHvpcoBoKioCJs2bcKmTZtQVFSkuV/dspGdX4TsvEKxyiMiIgJgjGHDgNfYULO1MIW9pWo4zi0u7EVERCIz3rBhoOM11LiwFxER6QojDBuGvcaGmhsHiRIRkY4wurCRkW0cLRsNigeJcvorERGJzejCxsNuFMMdswGwG4WIiHSH0YYNFzvDbtng/ihERKQrjG4FUUMas2FtbY309HTN7UdxfxQiItIVRhg2DGfMhkQigYuLS5mP1bNXtWykZ+dDEAS9X1OEiIj0l1F1oxQqlMjKUS1yZehjNurZq8JUToECsvyipzybiIhIe4wqbNwp7kKRmkhQx1r/w0Z+fj4mT56MyZMnl1iuHACszU1hV7ywV9oDjtsgIiLxGFXYUHeh1LUxh4mJ/ncrFBUVYe3atVi7dm2J5crV1F0paQ/ySz1GRERUW4wqbGQY0HiNilB3pbBlg4iIxGRUYSMz2zjW2FCrZ8eWDSIiEp9xhY3iMRsuxtKy4aAOG2zZICIi8RhZ2FDv+GokYcOO3ShERCQ+4wwbxtKNYs+WDSIiEp+Rhg3jaNlw5WwUIiLSAUa1gmhmtuEsVQ4AVlZWiI+P19x+XH0H9SqieVAqBYOY7ktERPrHuMKGgbVsmJiYwNPTs9zH1QNhCxUC7uUUwMlA3jcREekXo+lGKVIocTenuGXDzjjGbJibmsDJRvVe2ZVCRERiMZqwcTenAIIASCRAXQNYqhwACgoKMH36dEyfPh0FBQVlPkczbiObg0SJiEgcRhM21OM16lqbw1RqGG+7sLAQn376KT799FMUFhaW+Zz6xauIpnNGChERicQwrroVYGjjNSpKPf319n12oxARkTiML2wYyXgNNXajEBGR2IwvbBhdywa7UYiISFxGFDYMa42NiqrPhb2IiEhkxhM2so21ZaN4zAZbNoiISCRGEzYyjGxfFDXX4m6UTFk+ihRKkashIiJjZDQriGq6UQxox1crKytcvXpVc7ssTjYWkJpIoFAKyJQVaJYwJyIiqi1GFDZULRsuBtSNYmJiAh8fnyc+R2oigaudBW7dz0PagzyGDSIiqnVG0Y2iVAq4K1e1bLgYUMtGRbly3AYREYnIKFo27uUUQKEUAAB1bQxnzEZBQQGWLl0KAJg9ezbMzct+b/XsOP2ViIjEYxRhQz1eo461GcwMZKlyQLVc+cKFCwEA06dPLz9scPorERGJyHCuvE9grAt6qakX9kpjywYREYmAYcMIaFo2stmyQUREtc8owkaGekEvIxwcCjwSNu6zZYOIiGqfUYSNh0uVG87g0Mqox83YiIhIREYSNoy9G0X1vrNyCpFXqBC5GiIiMjZGFTYMaUGvynCwMoO5qepbncFxG0REVMuMZOqresyGYXWjWFpa4vTp05rb5ZFIJKhnb4Gku7lIe5CHRnWta6tEIiIiIwkb2Ya5vbxUKkWnTp0q9Nx6dpbFYYMtG0REVLsMvhtFEATckRv3mA3g4SDRdA4SJSKiWmbwLRv3cwtRqFAtVe5kYLNRCgoK8MUXXwAApk6dWu4KosDDrebZskFERLXN4MOGeryGvaUpLEylIldTswoLC/HRRx8BAN5+++0nhg1NywZXESUiolpWpW6UpKSkmq5DazLU4zWMdEEvNc2S5exGISKiWlalsDFgwACMHDkSGzduRFpaWk3XVKOMfY0NNVc7bsZGRETiqFLYOH78OF544QX88ccf6NOnD1599VVs374dd+/eren6qs3Y19hQ42ZsREQkliqFjbp162L06NHYvHkzjh07hoEDB+Kvv/5C37598frrr2Pv3r3Izc2t6Vqr5GHLhmENDq0s1+IxG9l5Rcgt4CqiRERUe6o99TUjIwMZGRm4ffs2lEolbGxssHv3bvTq1QuHDh2qiRqrxVDX2KgsOwtTWJmpBshy+isREdWmKs1GiYyMxMGDB3Hw4EGkpKTgmWeewfjx49G3b1/Y2NgAANauXYu5c+eiX79+NVpwZT1cPdS4w4Z6FdGEOzlIe5APDycbsUsiIiIjUaWw8cILL8Df3x8hISEYMGAA6tSpU+o5HTt21IlZK4Y8QNTS0hJ//vmn5vbTuNpbFocNtmwQEVHtqVLYWL58OYKCgmBmZlbi/oKCAs3YjS5duqBLly41UmR1GPL28lKpFL169arw8zVbzTNsEBFRLarSmI2ZM2ciOzu71P3R0dF4//33q11UTREEARkG3LJRWfWKu5LSufMrERHVogq3bGzfvh0ff/wxJBIJBEFA9+7dy3zeM888U2PFVVd2fhEKipQAABcDHLNRWFiI9evXAwDefPPNUi1Nj3Pl9FciIhJBhcPGmDFj0Lx5cyiVSowbNw5ffvklHBwcNI9LJBJYWVmhRYsWWim0KjKL/4K3tTCFpZlhLVUOqLqt3nnnHQBASEjIU8MGu1GIiEgMlRqzod7O/MiRI3Bzc4NEItFKUTXFkMdrVIV6FVF2oxARUW2qcNiYNWsW5syZA1tbW3z11VdPfO6yZcuqXVhNMOSZKFWhXkU0nUuWExFRLar2ol66jGGjJPUqorL8Isjyi0SuhoiIjEWFWzYeba3QlZaLp1GP2XC2YzcKoBq7YmthCll+EdIf5MHWxVbskoiIyAhUqWVDLpfj008/RVxcHJRKJT766CO0b98eY8aMQUpKSk3XWGUZMi5V/riHM1LYlUJERLWjSmFjwYIFOHbsGCQSCX7++WccOnQIS5cuhbOzMxYuXFjTNVYZu1FKc9WstcEZKUREVDuqtILosWPHsHnzZnh5eWHlypXo3bs3goKC0Lp1awwfPryma6wyQw8bFhYW+OWXXzS3K4LTX4mIqLZVKWwIggAzMzPk5eXh5MmTmD9/PgDg/v37sLa2rtECq0MdNlwMdMyGqakpBg4cWKnXqMMGZ6QQEVFtqVLY6Nq1K+bOnQtra2uYmJigb9++OHnyJBYtWoTAwMCarrHKuL18aepulDSutUFERLWkSmM2li5ditatW8Pc3Bxr1qyBra0tbty4gZ49e2LOnDk1XWOVyPOLkFuoAGC4YaOwsBAbN27Exo0bUVhYWKHXsBuFiIhqW5VaNuzs7BAaGlrivpCQkJqop8aou1CszKSwsajS29R5BQUFGD9+PABg5MiRT12uHHi0G4Vhg4iIakeVrsKFhYXYt28frly5gqKiIgiCUOJxXViHQzM41EDHa1RVvUemvgqCoPNLzhMRkf6rUjfKnDlzsGTJEty7d69U0NAVGRyvUSb1/ii5hQpkcxVRIiKqBVVq2fj999+xZs2acreZ1wWGPu21qqzMpbCzNEV2XhHSH+TD3vLpXS9ERETVUaWWDTs7O9SrV6+ma6lRDBvl47gNIiKqTVUKG2+99RaWLFmC2NhYFBXpZlO8Zo0Nbi9fimbcBlcRJSKiWlClbpRvv/0W6enpGDRoUJmPR0ZGVquomqBZY8OOLRuPq2ennv7KtTaIiEj7qhQ2li9fXtN11Dhj6EaxsLDA7t27NbcrypVrbRARUS2qUtjo3LkzAEAmk+HmzZto1qwZCgoKYGurO1uWG0PYMDU1xciRIyv9OnU3CpcsJyKi2lClMRsFBQUIDQ1F586dMWLECKSlpWHmzJl4/fXXcf/+/ZqusUoyNdvLc8zG47iKKBER1aYqhY0VK1YgJiYGe/fu1TTfv/vuu7h37x4WL15cowVWRV6hArLiNSQMecxGUVERwsPDER4eXqmBupqWDe6PQkREtaBK3SiHDh3CmjVr4O3trbnP29sbixYtwmuvvVZjxVVVRvFF1NzUBHYGulQ5AOTn52PUqFEAVF1apqYVe6+udg9bNriKKBERaVuVWjbkcjmsrKxK3a9UKqFQKKpdVHU9nPZqwQtpGVyKW3vyi5R4kKubU5eJiMhwVClsBAYGYtWqVZDJZJr7kpKSsHjxYvTs2bPGiqsqjtd4MkszKRytVSuHcq0NIiLStiqFjXnz5sHU1BRdunRBbm4uXnzxRTz33HOwt7fH3Llza7rGSjOGmSjVpV5r4/Z9hg0iItKuKg1oyMrKwvDhw+Hj4wNvb28kJiaiR48eaNKkSU3XVyWZ2QwbT1PfwRI30rIZNoiISOsqFTZOnjyJZcuWITo6usRurxKJBD///DNmzpwJf3//Gi+ysri9/NO5OapaNlLv54pcCRERGboKd6OcOHECEyZMQMuWLbFlyxb8+++/uHbtGk6dOoWNGzeiSZMmGD9+PC5cuKDNeivk4ZgNtmyUp769aoAvWzaIiEjbKtyysWbNGoSEhGD69Okl7ndwcECXLl3QpUsXODg4YN26dVi/fn2NF1oZGUYyZsPc3Bz/+9//NLcro4GmZYNhg4iItKvCYSMqKgqLFi164nNGjhypE+tsGMsAUTMzM4SEhFTptW4O6pYNdqMQEZF2VbgbJS8vDw4ODk98Tp06dXD37t1qF1Vd6gGiLhyzUa76DqqWjVtZbNkgIiLtqnDYEAQBJiZPfrpEIikxcFQM+UUKPMgrXqrcwFs2ioqKEBERgYiIiEotVw4ADYrDRnZ+EbLzCrVRHhEREYBKzkY5cODAE3d2zc7OrnZB1XWneHComVQCByszkavRrvz8fAwaNAhA5ZYrBwAbC1PYW5riQV4Rbt/Pg52lYX9WREQkngpfndzc3PD9998/9XkNGjSoVkHVpR6v4WTDpcqfxs3RCg9uZyP1fh6a17MTuxwiIjJQFQ4bf/zxhzbrqDEZmvEaht2FUhMaOFgi6nY2B4kSEZFWVWm5cl3GsFFx9YtnpKRykCgREWmR4YYNAx8cWhPc1DNS2LJBRERaZHhhQ8aWjYpq4Khq2bjFhb2IiEiLDC9ssBulwhpoWjYYNoiISHuqtOurLjOmsGFubo6vvvpKc7uy1GGD+6MQEZE2GV7YMKJuFDMzM0yePLnKr29QPEBUll+EB3mFsOdaG0REpAWG243CAaJPZWUuhaO1KmBw2XIiItIWgwob8vwi5BQoABhHy4ZCocDRo0dx9OhRKBSKKh1D3brBGSlERKQtBtWNol491NpcChsLg3prZcrLy0Pv3r0BqJYrt7GxqfQxGjhYIvLWA661QUREWmNQLRvGNDi0prjXUbVsJN/LEbkSIiIyVIYZNjheo8Ia1bEGACTfYzcKERFph2GFDSOaiVJT1C0bSWzZICIiLTGssMFulEprVFfVspF0ly0bRESkHYYZNtiNUmHqlo1MWT7yCqs2o4WIiOhJDDNssGWjwhyszGBXPHOHg0SJiEgbDGp+qLGN2TAzM8OKFSs0t6tCIpHAva41Im89QNK9XDRztavJEomIiAwsbBhZy4a5uTmmT59e7eO417FC5K0HSL7Llg0iIqp5BtONolQKmkW9jCVs1BT19NckTn8lIiItMJiWjfu5hShUCAAAJxvjCBsKhQLnz58HAHTo0AFSqbRKx+HCXkREpE0GEzbU4zXqWJvB3NRgGmyeKC8vD507dwZQ9eXKAU5/JSIi7TKYq7KxjdeoSWzZICIibWLYIE3Lxr2cQsjyi0SuhoiIDI3hhQ0u6FVpthamqGOtmjrL1g0iIqpphhM2OBOlWtzrcNwGERFph+GEjeKWDWe2bFRJo7rFG7JxrQ0iIqphBhc22LJRNeq1Nm4ybBARUQ0zmKmvxrigl5mZGebPn6+5XR1ezqpps3GZ8mrXRURE9CiDCRvG2LJhbm6OBQsW1MixmrjYAgDiMmQ1cjwiIiI1g+hGKVQocTenAABno1RVExdVy0ZKVi63miciohplEGHjrrwAggBITSSoY20udjm1RqlU4tq1a7h27RqUSmW1juVkYw57S1MIApBwh10pRERUcwwibDyciWIOExOJyNXUntzcXLRp0wZt2rRBbm71pqxKJBJ4abpSGDaIiKjmGFTYMKbxGtrQtHiQaDwHiRIRUQ0yiLCRnp0HgOM1qks9biOWg0SJiKgGGUTYSHugatmoZ28pciX6zcuZ3ShERFTzDCJs3H6gatlg2KgedctGXIYMgiCIXA0RERkKgwgb6QwbNcLL2QYSCfAgrwh35QVil0NERAbCIMKGumWjvgPHbFSHpZkUbg6qPVK4kigREdUUg1hBVD1mw9XOuFo2zMzM8OGHH2pu14QmLjZIycpFXIYMnTzr1sgxiYjIuOl92ChUKDX7ohhbN4q5uTlWrlxZo8ds4myD49GZHCRKREQ1Ru+7UTJl+RAEwNREAicb41k9VFuauqpmpMSkc/orERHVDL1v2bh9XzVew9XOwqhWDwVUy5XfvHkTANC4cWOYmFQ/O7aoZwcAiLqdXe1jERERAQYQNjRrbDgYVxcKoFqu3MvLCwAgk8lgY2NT7WO2rK8KGylZuXiQVwh7y5oZC0JERMZL77tR0tTTXo1scKi2OFqbo37x2Jf/2LpBREQ1wHDChj2nvdaUlg3YlUJERDVH78OGZvVQI+xG0Rbv4q6UGwwbRERUA/Q+bKSrx2ywG6XGtKpvDwC4fuuByJUQEZEh0Puw8XD1UIaNmtKmYXHYSH0AhZJ7pBARUfXofdjgmI2a5+VsC2tzKXILFYjjdvNERFRNej31NaegCNl5RQCMb/VQADA1NcXbb7+tuV1TpCYStG5gj7OJ93Al5T6aF6+9QUREVBV6HTbUa2xYm0tha6HXb6VKLCwssGbNGq0cu01DB5xNvIerKQ/wQgetnIKIiIyEXnejqFcPrWdvCYnEuFYP1Tbfhg4AgMvJWeIWQkREek+vw0Z6tnGP1xAEARkZGcjIyIAg1OxAznaNHAEAV1Luo6BIWaPHJiIi46LXYePRlg1jlJOTA1dXV7i6uiInJ6dGj93E2QaO1mbIL1IiklNgiYioGvQ6bNwqDhv1jTRsaJOJiQR+xa0b52/eE7cYIiLSa3oeNnIBAG6OViJXYpg6NK4DADiXyLBBRERVp9dhIzVL1bLBsKEdHT1UYeNswr0aHxNCRETGQ6/DhrplowFXD9UKv8Z1YCaV4PaDPCTeqdkxIUREZDz0NmzkFSqQKSsAADRky4ZWWJlL4ddI1bpxMu6OyNUQEZG+0tuwoZ6JYmlmAkdrM5GrMVxdmzoBAE7GMmwQEVHV6O2ym6lZDweHGuuCXqamphg3bpzmtjZ0bVIXXx4B/om9A6VSgImJcX7WRERUdfobNopbNtwcjLcLxcLCAhs3btTqOTp61IG1uRSZsnxcv/UAbYpXFiUiIqoove1GediywcGh2mRhKsUzTZ0BAMf+yxC5GiIi0kd6GzYezkQx3pYNQRAgl8shl8u1OjW1l7cLAODPqHStnYOIiAyX3oaNlOI1Nox5JkpOTg5sbW1ha2tb48uVP6p3S1cAqpVEM7LztXYeIiIyTHobNm4Vd6M0YDeK1jV0tEK7Ro5QCsCBq7fELoeIiPSMXoYNQRBKzEYh7RvctgEA4OdLqSJXQkRE+kYvw8aDvCLICxQAjHs2Sm0a1NYNEglwJuGeJugRERFVhF6GDfXFro61GazMpSJXYxzqO1iik0ddAMCvV9iVQkREFaeXYYMzUcQxuB27UoiIqPL0MmykcLdXUTzv2wAmEuBS8n3EpGeLXQ4REekJvQwbt7igFwBAKpVixIgRGDFiBKRS7XcnOdtaoE+regCArf/e1Pr5iIjIMOhl2EjJYjcKAFhaWiI8PBzh4eGwtKyd4BXc1QMA8OO5ZMjzi2rlnEREpN/0Mmwk3VUtYNW4rrXIlRifgGbO8HK2QXZ+EfZdTBG7HCIi0gP6GTbuqVo2GtU17pYNMZiYSPBqcevGlpOJWl0mnYiIDIPehY3cAoVmyWxjb9mQy+WQSCSQSCSQy+W1dt4RHdxhaWaCqNvZ+Dfubq2dl4iI9JPehY3ke6ouFDsLUzhYmYlcjXFysDbDiI7uAIC1R2NEroaIiHSd3oWNm8XjNRrVtYZEIhG5GuM18dmmkJpIcDw6E1eS74tdDhER6TC9CxscHKobGtW11uyXsu4YWzeIiKh8ehc2bt7l4FBd8VavZgCAA1dvIy5DJnI1RESkq/QubCTdY8uGrvCub4e+rVwhCMA3x+LELoeIiHSU/oWN4m4Ud4YNnaBu3dhzIVmzZw0REdGj9CpsCIKgGSDKlg3VcuVBQUEICgqqleXKy9LRow66eNVFoULAhuPxotRARES6Ta/Cxl15AXIKFJBIgIbchA2WlpaIiIhARERErS1XXpa3e6taN3acvol78gLR6iAiIt2kV2FD3apRz84Slmbi/CVPpT3b3Bk+bvbIKVBg08kEscshIiIdo1dhQ71MObtQdItEIsFbvZoCADb+k4CcAm7QRkRED+lX2NAMDmUXCqBartzGxgY2Nja1ulx5WZ5v0wCeTtbIyinEztNJotZCRES6RS/DBls2HsrJyUFOTo7YZUBqIsHEnqrWjW+Px6GgSClyRUREpCv0Kmxoliqvw7Chi17o0BCudha4dT+P288TEZGGXoWNuAxVV4Gns43IlVBZLEyleC3ACwDw/Yl4bj9PREQA9ChsyPOLcPtBHgCgqQvDhq4a3akxrMyk3H6eiIg09CZsxGeqWjXq2pjD0dpc5GqoPA7WZnihQ0MAwP/+5iJfRESkR2EjtnijL7Zq6L6QZzwBAIcj0zSDeomIyHjpTdhQj9do4mwrciW6w8TEBD179kTPnj1hYqI738rm9ezQo7kzlAKwmYt8EREZPd25Qj1FXHE3ShO2bGhYWVnh6NGjOHr0KKysdGvtEXXrxs4zSZDnc5EvIiJjpj9ho7gbpYkLWzb0QW9vV3g4WSM7rwh7L3AaLBGRMdOLsCEIgmaAKFs29IOJiQTjunkCADb9k8BpsERERkwvwsbtB3nIKVDA1ETC1UMfIZfL4eLiAhcXF9GXKy/LCH93WJqZIDpdhnOJ98Quh4iIRKIXYUM9OLRxXWuYSfWi5FqTmZmJzMxMscsok72lGQa3dQMAbD99U+RqiIhILHpx5X44XoNdKPpmdJfGAICIy7dwP6dQ5GqIiEgMehE2YtXTXjk4VO/4NXJEy/p2yC9SYs+FZLHLISIiEehJ2Chu2eCeKHpHIpFgTHHrxvZTNzlQlIjICOlF2Ihjy4ZeG+bXkANFiYiMmM6HjQd5hUjJygUAeNezE7kaqgoOFCUiMm46Hzb+u50NAHBzsISDtZnI1egWExMT+Pv7w9/fX6eWKy/LGA4UJSIyWrp9hQIQeesBAKBlA3uRK9E9VlZWOHPmDM6cOaNzy5U/rj0HihIRGS3dDxvFLRst67MLRZ9xoCgRkfHS+bARxZYNgzHMryGszKSITpfhLAeKEhEZDZ0OG0qlgBvFLRut2LJRSk5ODjw9PeHp6YmcnByxy3kqe0szDG7XAICqdYOIiIyDToeN5Hu5kBcoYC41gRfX2ChFEAQkJiYiMTFRb7olxnTxAABEXLmFe/ICkashIqLaoNNhI/K2qguleT1bmHJPFIPQzt0BPm72KChS4sfzHChKRGQMdPoKHnWruAuF4zUMRomBoqc5UJSIyBjodNjQTHvleA2DMrR9Q9iYSxGXIce/cXfFLoeIiLRMp8NGVHE3Cls2DIuthSmGtG8IgCuKEhEZA50NG9l5hUi8q5phwZYNw/NKcVfKwau3kCnLF7kaIiLSJp0NG1eS70MQgIaOVnCytRC7HJ0kkUjQunVrtG7dGhKJROxyKqVNQwe0c3dAoULAD+c4UJSIyJDpbNi4kJQFAPBr7ChqHbrM2toa165dw7Vr12BtbS12OZWmHii64/RNKJUcKEpEZKh0N2zczAKg2lODDNPgdm6wszBF4p0cHI/JFLscIiLSEp0MG4Ig4CJbNgyetbkpXuzoDgD4/kS8yNUQEZG26GTYSL6Xi0xZPkxNJPBxcxC7HJ2Vk5MDHx8f+Pj46MVy5WV5rbsXJBLg2H8ZiE7LFrscIiLSAp0MG+pWjdZu9rA0k4pbjA4TBAHXr1/H9evX9XZxrMZO1ujXuh4A4Pu/2bpBRGSIdDpscLyGcZjQowkAYM/5FNzhNFgiIoOjk2Hjwk3V9uMMG8bB36MO2ro7IL9IiW3cDZaIyODoXNgoKFLiaqpq5VCGDeMgkUjweoAXAGDzyUTkFylEroiIiGqSzoWNKyn3UVCkhKO1GbeVNyJBvg3QwMESmbJ8/HQhVexyiIioBulc2Pi7eL2Fbk2c9G5VTKo6M6kJxnf3BACsPRqDIoVS3IKIiKjG6GzY6N7MWeRKdJ9EIoGHhwc8PDwMIpi90sUDdW3MkXAnB/svsXWDiMhQ6FTYyC1QaFYOZdh4OmtrayQkJCAhIUEvlyt/nI2FKSb0UI3d+OqPGCi4hDkRkUHQqbBxJuEuChRKuDlYwtNJ/y+eVHlju3nC0doMcZly7L+UInY5RERUA3QqbKi7UJ5p5mwQ3QJUebYWpnijeN2Nzw79x5kpREQGQLfCRqwqbASwC6VCcnNz0alTJ3Tq1Am5ublil1Njxnf3RD17CyTfy8WmfxLELoeIiKpJZ8JGVk4BrhWvr/FMUyeRq9EPSqUSZ8+exdmzZ6FUGs7sDWtzU3zQzxsAEPZHDO7KC0SuiIiIqkNnwsbx6EwIAtDc1Rau9pZil0Mie7GDO1rWt0N2XhFWH/5P7HKIiKgadCZs/H49DQDQp1U9kSshXSA1kWDeoNYAgC3/JuJ88RL2RESkf3QibBQqlPjzRjoA4LnWriJXQ7rimWbOeKFDQwgCMPPHyygoMpyuIiIiY6ITYeN0/F1k5xXB2dYc7RvVEbsc0iFzB7aGk405/kuTYe3RGLHLISKiKtCJsPHLZdVqkc+1rgepCae80kN1bMwxf4gPANVg0dPxd0WuiIiIKkv0sFGoUOLA1dsAgEFt3USuRv84OzvD2dmwpwoPbtsAw9q7QaEU8O6O88iU5YtdEhERVYLoYeNEdCaycgrhbGuOLl51xS5Hr9jY2CAjIwMZGRmwsTHcHXIlEgmWDPdFM1dbpD3Ix7vbL3CxLyIiPSJ62PjhfDIAVauGqVT0ckhH2ViYYt0rHWBtLsXJuDt4f9cl7p1CRKQnRL26Z+UU4PdrqimvIzq6i1kK6YHm9ezwTXBHmEtNEHHlFmbtuczAQUSkB0QNG79cTkWBQonWDezRpqGDmKXopdzcXPTq1Qu9evUyqOXKn6RHcxd8Obo9TCTA7rPJmLjlLOT5RWKXRURETyBq2NhxOgkAMLpLYzHL0FtKpRLHjh3DsWPHDGq58qcZ0KYBvhztB3NTExyOTMeL6/7Bf2nZYpdFRETlEDVsJN7JgZ2lKV7wayhmGaSHBrV1w843u8LZ1hxRt7Mx8MvjWH34P+QVcuAoEZGuEX1E5ij/RrCxMBW7DNJDHRrXQcSUHujbqh4KFQJWH45GwCd/YsPxOGTnFYpdHhERFRM1bJhJJZjQw0vMEkjP1bO3xLdjOyJstB/c61ghU5aPxRGR6LTkMN7ffRH/xt2BIHAQKRGRmERtUhjSzg0NHKzELIEMgEQiweB2bhjQpj5+PJeMb4/HITZDjj3nU7DnfArc61hhuF9DDPNriKYutmKXS0RkdCSCCH/2yWQydOzYEfuPHIe3Ozdeqyq5XA5bW9XFUyaTGfTCXpUhCALO38xC+Nkk/HwpFfKCh+M42rk7YLhfQwxu5wYnWwsRqySip5LLgeLfcZDJAP6O01uiho1z585pLpZUeXK5HK6uqrCWnp7OsFGG3AIFfo9Mw97zyfgrOlOzLoe5qQle7OCON3p4oQlbO4h0E8OGwWDYIKORKcvHL5dS8cP5ZFxNeQAAkEiAfq3r4YN+3mhRz07kComoBIYNg8GwQUZHEAScSbiH9X/F4nBkOgDARKJaxfa951pwHBGRrmDYMBgMG2TUotOy8dmh/3DwmmrnYQtTE4R098TbvZrBwcpM5OqIjBzDhsEQfZ0Nqrq8vDwMHDgQAwcORF5entjl6KXm9ezwdXBH7Hn7GXT2rIv8IiW+ORaHZ1eo1uvg7rJERNXHlg09xtkoNUsQBPwRlY5PDkbhvzQZAKChoxWm9/fGkHZuMDGRiFwhkZFhy4bBYMsGUTGJRII+rerhwNRnseLFtqhnb4GUrFxM23URg786gSORaVByl1kiokpj2CB6jNREglGdGuHoh70xvb83bC1McS31AV7fdBbPfX4M20/d5B4sRESVwG4UPcZulNpxR5aP9X/FYfupm8gu3s7eztIUA30bYFBbN/h71oGlmVTkKokMELtRDAbDhh5j2Khd2XmF2HUmCf/7OwEpWbma+y1MTdDZqy66NnFCqwZ2aFHPDg0drSCRcIwHUbUwbBgMhg09xrAhDqVSwKn4u/jpYgr+vJGOtAf5pZ5jbS5FfXtLuNpbwNXOEnaWprCxMIW1uRQ25qbo3dIVzVz5s0/0RAwbBkOUsJGdnQ1/f38cO3aMYaMa5HI53NzcAACpqakMGyIQBAFxGTL8E3sHl5KzEJsuR8IdOQoVT/7fqlUDO4RPeqaWqiTSU3I5UPw7DqmpDBs6xMbGplKtt6KEjdu3b6Nnz561fVoiIiKqAZXtmRAlbCiVSs3GYezXJiIi0i960bJBRERExoPrbBAREZFWMWwQERGRVjFsEBERkVYxbBAREZFWMWwQERGRVjFsEBERkVYxbBAREZFW1WrYyM/Px+zZs+Hv74+AgAB8//33tXl6KkNBQQEGDRqEU6dOiV2KUUtLS8OUKVPQuXNn9OjRA8uWLUN+fuk9V0j7EhMT8frrr8PPzw+9evXChg0bxC6JALz55puYOXOm2GUYrd9//x3e3t4lvqZMmVLh15tqsbZSVqxYgatXr2LTpk1ITU3FjBkz4ObmhgEDBtRmGVQsPz8fH3zwAaKjo8UuxagJgoApU6bA3t4e27Ztw/379zF79myYmJhgxowZYpdnVJRKJd588034+vpi7969SExMxPvvv4969eph8ODBYpdntCIiInDs2DEMHz5c7FKMVkxMDHr37o1FixZp7rOwsKjw62stbOTk5CA8PBzffvstfHx84OPjg+joaGzbto1hQwQxMTH44IMPwAVkxRcXF4eLFy/i77//hrOzMwBgypQp+OSTTxg2allmZiZatWqFBQsWwNbWFp6enujWrRvOnTvHsCGSrKwsrFixAr6+vmKXYtRiY2PRokULuLi4VOn1tdaNEhUVhaKiIvj5+Wnu69ixIy5dugSlUllbZVCx06dPo0uXLti1a5fYpRg9FxcXbNiwQRM01GQymUgVGS9XV1esXr0atra2EAQB586dw5kzZ9C5c2exSzNan3zyCYYOHYpmzZqJXYpRi42NhaenZ5VfX2stGxkZGahTpw7Mzc019zk7OyM/Px9ZWVmoW7dubZVCAMaMGSN2CVTM3t4ePXr00PxbqVRi69at6Nq1q4hVUWBgIFJTU9G7d2/0799f7HKM0smTJ3H27Fn8/PPPWLBggdjlGC1BEBAfH48TJ07gm2++gUKhwIABAzBlypQS1/QnqbWWjdzc3FJFqf9dUFBQW2UQ6byVK1fi+vXreO+998Quxah9+eWX+PrrrxEZGYlly5aJXY7Ryc/Px/z58zFv3jxYWlqKXY5RS01N1VzDV69ejRkzZuDnn3/GihUrKnyMWmvZsLCwKBUq1P/mDxKRysqVK7Fp0yZ8/vnnaNGihdjlGDX1GIH8/Hx8+OGH+Oijjyr8VxxV31dffYU2bdqUaPUjcTRs2BCnTp2Cg4MDJBIJWrVqBaVSienTp2PWrFmQSqVPPUathY169erh3r17KCoqgqmp6rQZGRmwtLSEvb19bZVBpLMWLVqEHTt2YOXKlWy2F0lmZiYuXryIvn37au5r1qwZCgsLIZPJ2N1biyIiIpCZmakZ56f+4/S3337DhQsXxCzNKDk6Opb4d9OmTZGfn4/79+9X6P+LWutGadWqFUxNTXHx4kXNfefOnYOvry9MTLi2GBm3r776Cjt37sSqVaswcOBAscsxWsnJyXjnnXeQlpamue/q1auoW7cug0Yt27JlC37++Wfs27cP+/btQ2BgIAIDA7Fv3z6xSzM6x48fR5cuXZCbm6u5LzIyEo6OjhX+/6LWrvJWVlYYNmwYFixYgMuXL+Pw4cP4/vvvMXbs2NoqgUgnxcbGYu3atXjjjTfQsWNHZGRkaL6odvn6+sLHxwezZ89GTEwMjh07hpUrV2LSpElil2Z0GjZsCA8PD82XjY0NbGxs4OHhIXZpRsfPzw8WFhYIDQ1FXFwcjh07hhUrVmDChAkVPkatLuo1a9YsLFiwAOPGjYOtrS3effdd9OvXrzZLINI5R44cgUKhwLp167Bu3boSj924cUOkqoyTVCrF2rVrsWjRIrz00kuwsrJCcHAw/ygio2Zra4vvvvsOS5cuxYsvvggbGxu8/PLLlQobEoGrOhEREZEWcbAEERERaRXDBhEREWkVwwYRERFpFcMGERERaRXDBhEREWkVwwYRERFpFcMGERERaRXDBhEREWkVwwZRBR04cABTpkwBAFy/fh2DBw+u0nESExMxdOhQ+Pr6YvXq1aUenzlzJmbOnFmhYwmCgLlz56J9+/bo06dPlepRu3PnDg4cOFDl1z+p7j179sDb21vz1bJlS3To0AFTpkxBbGxslc9JRPqhVpcrJ9Jn165dg4+Pj+Z2mzZtqnScrVu3AlDtaung4FCtmqKiorB7926sX78e3t7e1TrWp59+CkEQ8Pzzz1frOOWpX78+fvjhBwCqkJSVlYVFixbhrbfewsGDB7khI5EB4//dRBV07do1tGrVCoBqJ9DWrVtX6TgymQwtW7ZE48aNqx02srOzAQDPPvss6tevX61jaXvnAqlUChcXF7i4uMDV1RUtWrTABx98gMTERO4BQ2TgGDaIniIwMBDe3t74559/8MYbb8Db2xs7d+7E4sWLERYWVuZr9uzZg+effx5t27bFCy+8gDNnzgBQdTXs2bMH+/btg7e3N5KTk5947lOnTiEwMBDbt29Hjx490L59e0yfPh0FBQU4deoUgoODAQAtW7bU1PL7778jKCgI7dq1w4gRI3D69GnN8YqKirBq1SoEBASgY8eOmDJlCu7du4ewsDDs3bsXe/fuRWBgIADgwYMHmD59Ojp06ICAgAAsWrQIeXl5mmOdPXsWw4YNQ9u2bTF16tQS209XlFQqBQCYmZkBUG1KN2zYMPj6+sLf3x/vv/8+5HK5pp53330X/v7+6NSpEz788EPIZDIAQGpqKl577TX4+fmhW7duWLRoEQoLCwGoQtSaNWsQEBAAf39/TJo0CampqZoavL298dNPP2HQoEFo06YNxowZg6SkJM3jV69exahRo9C2bVu8/PLL+OKLLzSf+9M+7+DgYCxatAh9+vRBr169IJPJsHnzZvTu3Ru+vr544YUXcPbs2Up/bkR6RyCiJ7pz545w7do1oWvXrkJ6erqQlpYmtG3bVkhMTBRkMlmp5//4449C+/bthb179wqxsbHCypUrhfbt2wu3b98WHjx4IEydOlWYOnWqkJ6eLhQVFZV6/YwZM4QZM2YIgiAI//77r+Dj4yOMHTtWiIqKEv766y+hbdu2wq5du4T8/Hzht99+E1q0aCGkp6cLMplMiIyMFPz8/IT9+/cLCQkJwqZNm4S2bdsKCQkJgiAIwqeffioEBAQIx44dE6Kjo4UxY8YI7777riCTyTR13blzRxAEQXjnnXeEiRMnClFRUcKlS5eEkSNHCrNmzdJ8Jh06dBA++eQTITY2Vvjyyy+FFi1aaOou6zPp3bt3iftu374tvP7668KAAQOEoqIiITExUfDx8RF27dolJCUlCcePHxe6dOkifP/994IgCMKiRYuEl156Sfjvv/+E69evCwMHDhQ++eQTQRAEYdKkScLkyZOFhIQE4dy5c0L37t2FrVu3CoIgCJs3bxb69+8v/Pvvv0JMTIwwe/ZsoX///kJBQYEgCILQokULoU+fPsI///wj3LhxQxgwYIDw/vvvC4IgCA8ePBC6dOkiLFiwQIiNjRW2bNkitG7dWnj11VcFQRCe+nm/+uqrQvv27YVz584JV65cEa5duyb4+PgIf/75p5CUlCQsWbJE6N69u6BQKCr0s0ikrzhmg+gp6tati8jISDRv3hwuLi5ISkpCnTp10Lhx4zKfv2XLFgQHB2PYsGEAgA8//BBnzpzB1q1b8cEHH8DS0hIA4OLiUqHzFxYWIjQ0FM2bN4e3tzd69OiBK1euYNSoUZpuGPWxvvvuO4waNUozeHXs2LE4c+YMduzYgRkzZmD37t2YMWMGnn32WQDAwoULceDAAdjY2Gjqqlu3Lm7evInDhw/j9OnTsLOzAwAsWrQIw4YNw6xZs3DgwAHUrVsX06dPh0Qiwbvvvotjx4498X2kpqbCz88PAKBQKJCfn49WrVph1apVkEqlUCqVCA0NxahRowAA7u7ueOaZZxAdHQ0ASElJgY2NDdzd3WFlZYUvvvhCc+yUlBT4+PjAzc0NHh4eWL9+Pezt7QEAGzZswPz589GlSxcAwMcff4yAgAAcP35c04ozfvx4dOvWDQAwevRobNu2DQDw66+/wtraGqGhoZBKpWjSpAnOnz+PjIyMp37e6sGyvXr1QocOHQCoWkEkEgnc3Nzg7u6OadOmoXfv3lAqlRyzQgaNYYOoAqKjo9G8eXMAQExMDJo1a1buc2NjYzF58uQS97Vv375asy48PDw0t21tbVFUVFTuuQ8cOIBdu3Zp7issLERAQADu3buHrKwszSBXAGjWrBnefffdMo+jVCo1oURNqVQiMTERMTExaNmyJSQSieYxX1/fJ3aluLq6YsuWLQAAExMTODg4aAIBAHh6esLc3Bzr1q1DdHQ0oqOjERMTg6FDhwJQXcjffvttdOvWDd26dUP//v01F/kJEyZg9uzZ+P333/Hss88iKCgIrVu3hlwux+3bt/Hee++VuJjn5eUhISGh3M9X3QVz48YN+Pj4aLp7ANX38vfff3/q563WsGFDze2AgAC0aNECgwcPRuvWrdGnTx+MHDkSpqb8VUyGjT/hRE8xcOBAJCYmAlCNxSgqKoJSqYSfnx8mTpyISZMmlXi+hYVFqWMoFAoolcoq12Bubl7i30I5gzkVCgXeeOMNTauKmqWlZaUuaAqFAnZ2dvjxxx9LPVavXr0yazAzM3ti2DA1NS1xUX9cVFQURo8ejcDAQPj7+yMkJASbNm3SPN6tWzccO3YMR44cwdGjRzFv3jycOHECn376KYYMGYJu3brh8OHDOHr0KKZMmYI33ngDr7/+OgDgiy++gJeXV4nzPTo4Vz1m5HFSqbTU+3z030/6vNUe/XmwsrJCeHg4Tp8+jT///BN79uzBjh07sGfPHs3nSmSI2G5H9BTr16+Hu7s7vvjiC+zbtw+dOnXCzJkzsW/fPrz88sulnu/l5YVLly6VuO/SpUulLnba4OXlheTkZHh4eGi+du3ahb/++gv29vaoU6cOoqKiNM+PjIzEs88+i7y8vBKtFF5eXsjOzoZEItEcJy8vDytWrEBBQQGaN2+O69evQ6FQlDhWdfz000/o1KkTPvvsM4wZMwZt27ZFYmKi5uK+ceNGXLt2DcOHD8cXX3yBZcuW4dChQwCAzz//HHfu3MHo0aPxzTffYNq0aTh06BDs7e3h5OSEjIwMzfto0KABVq5cifj4+KfW1Lx5c0RGRpYIiteuXSvxOZX3eZflwoUL+Oabb9C1a1fMmjULBw8eRH5+Ps6dO1edj45I5zFsED2Fs7Mz0tLS0KNHD3h4eCAhIQE9e/aEh4cHHB0dSz0/JCQEW7duxb59+xAfH49PP/0UUVFRGDFihNZrDQkJwa+//orNmzfj5s2b2LhxIzZu3AhPT08AqtkRX3zxBf79919ER0djyZIlaN++PSwtLWFlZYWUlBSkpaWhadOm6NGjBz788ENcvnwZ165dw6xZs5CTkwN7e3sMHDgQubm5WLJkCeLi4rBhw4ZqXzAdHR1x48YNXL58GfHx8Vi+fDmuXLmCgoICAMDt27fx8ccf4+LFi0hISMBvv/2mmX4cFxeHjz/+GFFRUYiOjsaxY8c0j4WEhGD16tX4448/kJCQgNDQUJw/fx5NmjR5ak0DBw6ETCbDsmXLEB8fj927d+PXX3+t8Of9OEtLS6xZswbh4eFITk5GREQEcnJyqr1GCpGuYzcK0VPcuHEDTZs2hbm5Oe7evQu5XF7u4FAACAoKQmZmJr788ktkZGSgVatW+P7779G0aVOt19q+fXusWLECYWFhWLFiBRo3bozPPvsMnTp1AgC8+eabyM7OxrRp01BUVIRevXph7ty5AIChQ4di8uTJGDJkCP7991+sWLECixcvRkhICExNTdGjRw+EhoYCUHVBbNiwAQsWLMDQoUPRqVMnDB06tFprdQQHB+P69esICQmBhYUFOnXqhMmTJyMiIgIAMHXqVGRnZ+Ott95CTk4OOnXqhJUrVwIAFixYgIULFyI4OFjzvubMmQMAeP311yGXyzFv3jzIZDK0adMG3333XYXWOLGxscHXX3+NhQsXYseOHfD19cXgwYORnp5eoc/7ca1atcKSJUuwdu1afPzxx3Bzc8PKlStr5WeDSEwSoTq/HYiIDFhSUhLS0tLg7++vuW/hwoXIzc3F8uXLRayMSL+wG4WIqBwymQzjx4/HwYMHkZKSgkOHDuGnn37CgAEDxC6NSK+wZYOI6AnCw8Px7bff4tatW3Bzc8OECRMwcuRIscsi0isMG0RERKRV7EYhIiIirWLYICIiIq1i2CAiIiKtYtggIiIirWLYICIiIq1i2CAiIiKtYtggIiIirWLYICIiIq36P6jslWkwDIZMAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "infected_pass_dist = cf_sir_posterior_samples['infected_passengers_0.36702409386634827'].squeeze()\n",
+    "\n",
+    "sns.kdeplot(infected_pass_dist[:, 1], label='Estimated Counterfactual')\n",
+    "plt.axvline(x=true_cf_infected, color='black', label='Analytical Expected Counterfactual', linestyle='--')\n",
+    "plt.axvline(x=infected_pass_dist[:, 0].mean(), color='red', label='Reality')\n",
+    "plt.xlabel('# of Infected Passengers')\n",
+    "plt.yticks([])\n",
+    "plt.legend(loc='upper center')\n",
+    "plt.xlim(0, 5)\n",
+    "sns.despine()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Multilevel SIR Model\n",
+    "\n",
+    "So far we have assumed we only observe data from one region. Now let's imagine we observe data from $M$ different regions, where region $m$ has transmission rate ($\\beta_m$) and recovery rate ($\\gamma_m$) for $1 \\leq m \\leq M$.\n",
+    "\n",
+    "\n",
+    "Note: we assume there are no interactions between regions (i.e., individuals from one region cannot infect those from another)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:47:59.576356Z",
+     "start_time": "2023-07-18T18:47:59.510352Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "def unit_level_sir(unit_name, \n",
+    "                   beta0_prior=dist.Uniform(0.0, 1.0), \n",
+    "                   gamma_prior=dist.Uniform(0.0, 1.0)\n",
+    "                   ):\n",
+    "    beta0 = pyro.sample(f\"beta0_{unit_name}\", beta0_prior)\n",
+    "    gamma = pyro.sample(f\"gamma_{unit_name}\", gamma_prior)\n",
+    "    sir = SimpleSIRDynamics(beta0, gamma, unit_name)\n",
+    "    return sir\n",
+    "\n",
+    "\n",
+    "def multi_level_sir(\n",
+    "    N_stratum,\n",
+    "    init_states,\n",
+    "    logging_times,\n",
+    "    beta_prior=dist.Uniform(0.0, 1.0),\n",
+    "    gamma_prior=dist.Uniform(0.0, 1.0),\n",
+    "):\n",
+    "    solutions = []\n",
+    "    for unit_ix in range(N_stratum):\n",
+    "        sir = unit_level_sir(unit_ix, beta_prior, gamma_prior)\n",
+    "        init_state = init_states[unit_ix]\n",
+    "        with DynamicTrace(logging_times) as dt:\n",
+    "            with SimulatorEventLoop():\n",
+    "                simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "        trajectory = dt.trace\n",
+    "        solutions.append(trajectory)\n",
+    "        # This is a small trick to make the trajectory variables available to pyro\n",
+    "        [pyro.deterministic(f\"{k}_{unit_ix}\", getattr(trajectory, k))for k in get_keys(trajectory)]\n",
+    "    return solutions\n",
+    "\n",
+    "\n",
+    "def conditioned_multi_level_sir(\n",
+    "    multi_data,\n",
+    "    init_states,\n",
+    "    logging_times,\n",
+    "    beta_prior=dist.Uniform(0.0, 1.0),\n",
+    "    gamma_prior=dist.Uniform(0.0, 1.0),\n",
+    "):\n",
+    "    for unit_ix, data in multi_data.items():\n",
+    "        sir = unit_level_sir(unit_ix, beta_prior, gamma_prior)\n",
+    "        init_state = init_states[unit_ix]\n",
+    "        with SimulatorEventLoop():\n",
+    "            if data is None:\n",
+    "                simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "            else:\n",
+    "                with TrajectoryObservation(data):\n",
+    "                    simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:48:00.432415Z",
+     "start_time": "2023-07-18T18:47:59.569623Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Generate synthetic data from the true model\n",
+    "obs_logging_times = torch.arange(1 / 52, 1.01, 1 / 52)  # collect data\n",
+    "N_obs = obs_logging_times.shape[0]\n",
+    "\n",
+    "N_stratum = 5\n",
+    "\n",
+    "multi_data = {}\n",
+    "init_states = []\n",
+    "init_state = State(\n",
+    "    S=torch.tensor(99.0), I=torch.tensor(1.0), R=torch.tensor(0.0), l=torch.tensor(0.0)\n",
+    ")\n",
+    "\n",
+    "beta0_grid = torch.tensor([0.1, 0.05, 0.075, 0.15, 0.12])\n",
+    "gamma_grid = torch.tensor([0.2, 0.3, 0.5, 0.35, 0.4])\n",
+    "\n",
+    "sir_true_trajs = []\n",
+    "for unit_ix in range(N_stratum):\n",
+    "    beta0 = beta0_grid[unit_ix]\n",
+    "    gamma = gamma_grid[unit_ix]\n",
+    "    sir = SimpleSIRDynamics(beta0, gamma, unit_ix)\n",
+    "    with DynamicTrace(obs_logging_times) as dt:\n",
+    "        simulate(sir, init_state, obs_logging_times[0], obs_logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    sir_traj = dt.trace\n",
+    "    with DynamicTrace(logging_times) as true_dt:\n",
+    "        simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3, solver=TorchDiffEq())\n",
+    "    sir_true_trajs.append(true_dt.trace)\n",
+    "\n",
+    "    data = dict()\n",
+    "    if unit_ix != 0:\n",
+    "        for time_ix in range(N_obs):\n",
+    "            data[obs_logging_times[time_ix].item()] = sir.observation(sir_traj[time_ix])\n",
+    "    else:\n",
+    "        data = None\n",
+    "    multi_data[unit_ix] = data\n",
+    "    init_states.append(init_state)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Unpooled Multi-level Model\n",
+    "First, we assume that the way each region's population responds to the infectious disease is entirely independent of every other region. This means both that individuals don't interact across regions, and also that we can't learn anything about one population by observing another. Later we'll relax this assumption to make better use of multi-region data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:50:50.419371Z",
+     "start_time": "2023-07-18T18:48:00.432672Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "multi_guide = run_svi_inference(conditioned_multi_level_sir, multi_data=multi_data, init_states=init_states, logging_times=torch.tensor([0.0, 3.0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2023-07-18T18:51:17.223063Z",
+     "start_time": "2023-07-18T18:50:50.422559Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Generate samples from the posterior predictive distribution\n",
+    "multi_predictive = Predictive(multi_level_sir, guide=multi_guide, num_samples=50)\n",
+    "multi_samples = multi_predictive(N_stratum, init_states, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Note: We do not observe any data for the first of the five regions we wish to model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "ExecuteTime": {
+     "start_time": "2023-07-18T18:51:17.222366Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Plot results\n",
+    "fig, ax = plt.subplots(N_stratum, 3, figsize=(15, 15))\n",
+    "\n",
+    "states = [\"S\", \"I\", \"R\"]\n",
+    "colors = [\"orange\", \"red\", \"green\"]\n",
+    "pred_labels = [\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "]\n",
+    "data_labels = [\"Actual # Susceptible\", \"Actual # Infected\", \"Actual # Recovered\"]\n",
+    "\n",
+    "\n",
+    "for i in range(N_stratum):\n",
+    "    for j, (state, color, pred_label, data_label) in enumerate(\n",
+    "        zip(states, colors, pred_labels, data_labels)\n",
+    "    ):\n",
+    "        if i == 0:\n",
+    "            test_time = 0.0\n",
+    "            legend = True\n",
+    "        else:\n",
+    "            test_time = 1.0\n",
+    "            legend = False\n",
+    "        SIR_plot(\n",
+    "            logging_times,\n",
+    "            test_time,\n",
+    "            multi_samples[f\"{state}_{i}\"],\n",
+    "            getattr(sir_true_trajs[i], state),\n",
+    "            pred_label,\n",
+    "            color,\n",
+    "            data_label,\n",
+    "            ax[i, j],\n",
+    "            legend=legend,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Share Information across stratum (Partial Pooling)\n",
+    "Here we will assume that the different regions have similar rate parameters, although we are uncertain about their values a-priori. This means that information about regions 2-5 will inform our predictions for region 1, which we do not have any observations for.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def beta_reparam(mean, var):\n",
+    "    # Formula relating mean and variance of beta distribution to alpha and beta parameters:\n",
+    "    # https://stats.stackexchange.com/questions/12232/calculating-the-parameters-of-a-beta-distribution-using-the-mean-and-variance\n",
+    "    alpha = ((1 - mean) / var - (1 / mean)) * mean**2\n",
+    "    beta = alpha * (1 / mean - 1)\n",
+    "    return alpha, beta"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def pooling_prior():\n",
+    "    # We assume that there is a shared center of mass for the beta and gamma distributions\n",
+    "    # and that the strata-specific distributions are drawn from this center of mass.\n",
+    "\n",
+    "    beta0_mean = pyro.sample(\"beta0_mean\", dist.Uniform(0.0, 1.0))\n",
+    "    beta0_var = 0.05**2 # we don't think infection rate varies by more than 5% between strata\n",
+    "\n",
+    "    gamma_mean = pyro.sample(\"gamma_mean\", dist.Uniform(0.0, 1.0))\n",
+    "    gamma_var = 0.3**2 # we don't think recovery rate varies by more than 30% between strata\n",
+    "\n",
+    "    beta0_prior = dist.Beta(*beta_reparam(beta0_mean, beta0_var))\n",
+    "    gamma_prior = dist.Beta(*beta_reparam(gamma_mean, gamma_var))\n",
+    "    return beta0_prior, gamma_prior\n",
+    "\n",
+    "\n",
+    "def pooled_multi_level_sir(N_stratum, init_states, logging_times):\n",
+    "    # Draw priors for beta0 and gamma\n",
+    "    beta0_prior, gamma_prior = pooling_prior()\n",
+    "\n",
+    "    # Run the multi-level SIR model with the pooled priors\n",
+    "    return multi_level_sir(N_stratum, init_states, logging_times, beta0_prior, gamma_prior)\n",
+    "\n",
+    "\n",
+    "def pooled_conditioned_multi_level_sir(multi_data, init_states, logging_times):\n",
+    "    # Draw priors for beta0 and gamma\n",
+    "    beta0_prior, gamma_prior = pooling_prior()\n",
+    "\n",
+    "    # Run the multi-level SIR model with the pooled priors\n",
+    "    return conditioned_multi_level_sir(multi_data, init_states, logging_times, beta0_prior, gamma_prior)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pooled_multi_guide = run_svi_inference(pooled_conditioned_multi_level_sir, multi_data=multi_data, init_states=init_states, logging_times=torch.tensor([0.0, 3.0]))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Generate samples from the posterior predictive distribution\n",
+    "pooled_predictive = Predictive(pooled_multi_level_sir, guide=pooled_multi_guide, num_samples=50)\n",
+    "pooled_samples = pooled_predictive(N_stratum, init_states, logging_times)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Plot predicted values for S, I, and R with uncertainty bands (+/- 2 std. devs.)\n",
+    "\n",
+    "fig, ax = plt.subplots(N_stratum, 3, figsize=(15, 15))\n",
+    "\n",
+    "states = [\"S\", \"I\", \"R\"]\n",
+    "colors = [\"orange\", \"red\", \"green\"]\n",
+    "pred_labels = [\n",
+    "    \"Predicted # Susceptible (Millions)\",\n",
+    "    \"Predicted # Infected (Millions)\",\n",
+    "    \"Predicted # Recovered (Millions)\",\n",
+    "]\n",
+    "data_labels = [\"Actual # Susceptible\", \"Actual # Infected\", \"Actual # Recovered\"]\n",
+    "\n",
+    "\n",
+    "for i in range(N_stratum):\n",
+    "    for j, (state, color, pred_label, data_label) in enumerate(\n",
+    "        zip(states, colors, pred_labels, data_labels)\n",
+    "    ):\n",
+    "        if i == 0:\n",
+    "            test_time = 0.0\n",
+    "            legend = True\n",
+    "        else:\n",
+    "            test_time = 1.0\n",
+    "            legend = False\n",
+    "        SIR_plot(\n",
+    "            logging_times,\n",
+    "            test_time,\n",
+    "            pooled_samples[f\"{state}_{i}\"],\n",
+    "            getattr(sir_true_trajs[i], state),\n",
+    "            pred_label,\n",
+    "            color,\n",
+    "            data_label,\n",
+    "            ax[i, j],\n",
+    "            legend=legend,\n",
+    "        )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## References\n",
+    "1. https://www.generable.com/post/fitting-a-basic-sir-model-in-stan\n",
+    "2. https://benjaminmoll.com/wp-content/uploads/2020/05/SIR_notes.pdf"
+   ]
+  },
+  {
+   "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.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/docs/source/index.rst b/docs/source/index.rst
index bc375b9ba..0eb51ab2f 100644
--- a/docs/source/index.rst
+++ b/docs/source/index.rst
@@ -30,6 +30,7 @@ Table of Contents
    sciplex
    sdid
    dr_learner
+   dynamical_intro
 
 .. toctree::
    :maxdepth: 2
@@ -39,6 +40,7 @@ Table of Contents
    interventional
    observational
    indexed
+   dynamical
 
 .. toctree::
    :maxdepth: 2
diff --git a/docs/source/requirements.txt b/docs/source/requirements.txt
index 33d997a79..a52864c66 100644
--- a/docs/source/requirements.txt
+++ b/docs/source/requirements.txt
@@ -6,3 +6,4 @@ sphinxcontrib-bibtex
 sphinx_rtd_theme==1.3.0
 myst_parser
 nbsphinx
+torchdiffeq
diff --git a/setup.py b/setup.py
index 6f0c66786..a982d3158 100644
--- a/setup.py
+++ b/setup.py
@@ -23,6 +23,8 @@
     "tensorboard",
 ]
 
+DYNAMICAL_REQUIRE = ["torchdiffeq"]
+
 setup(
     name="chirho",
     version=VERSION,
@@ -37,12 +39,14 @@
     },
     install_requires=[
         # if you add any additional libraries, please also
-        # add them to `docs/requirements.txt`
+        # add them to `docs/source/requirements.txt`
         "pyro-ppl>=1.8.5",
     ],
     extras_require={
+        "dynamical": DYNAMICAL_REQUIRE,
         "extras": EXTRAS_REQUIRE,
-        "test": EXTRAS_REQUIRE + [
+        "test": EXTRAS_REQUIRE
+        + [
             "pytest",
             "pytest-cov",
             "pytest-xdist",
diff --git a/tests/dynamical/__init__.py b/tests/dynamical/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/dynamical/dynamical_fixtures.py b/tests/dynamical/dynamical_fixtures.py
new file mode 100644
index 000000000..03f301716
--- /dev/null
+++ b/tests/dynamical/dynamical_fixtures.py
@@ -0,0 +1,100 @@
+from typing import TypeVar
+
+import pyro
+import torch
+from pyro.distributions import Normal, Uniform, constraints
+
+from chirho.dynamical.ops import State, get_keys
+
+pyro.settings.set(module_local_params=True)
+
+T = TypeVar("T")
+
+
+class UnifiedFixtureDynamics(pyro.nn.PyroModule):
+    def __init__(self, beta=None, gamma=None):
+        super().__init__()
+
+        self.beta = beta
+        if self.beta is None:
+            self.beta = pyro.param("beta", torch.tensor(0.5), constraints.positive)
+
+        self.gamma = gamma
+        if self.gamma is None:
+            self.gamma = pyro.param("gamma", torch.tensor(0.7), constraints.positive)
+
+    def forward(self, X: State[torch.Tensor]):
+        dX: State[torch.Tensor] = State()
+        beta = self.beta * (
+            1.0 + 0.1 * torch.sin(0.1 * X["t"])
+        )  # beta oscilates slowly in time.
+
+        dX["S"] = -beta * X["S"] * X["I"]
+        dX["I"] = beta * X["S"] * X["I"] - self.gamma * X["I"]  # noqa
+        dX["R"] = self.gamma * X["I"]
+        return dX
+
+    def _unit_measurement_error(self, name: str, x: torch.Tensor):
+        if x.ndim == 0:
+            return pyro.sample(name, Normal(x, 1))
+        else:
+            return pyro.sample(name, Normal(x, 1).to_event(1))
+
+    @pyro.nn.pyro_method
+    def observation(self, X: State[torch.Tensor]):
+        self._unit_measurement_error("S_obs", X["S"])
+        self._unit_measurement_error("I_obs", X["I"])
+        self._unit_measurement_error("R_obs", X["R"])
+
+
+def bayes_sir_model():
+    beta = pyro.sample("beta", Uniform(0, 1))
+    gamma = pyro.sample("gamma", Uniform(0, 1))
+    sir = UnifiedFixtureDynamics(beta, gamma)
+    return sir
+
+
+def check_keys_match(obj1: State[T], obj2: State[T]):
+    assert get_keys(obj1) == get_keys(obj2), "Objects have different variables."
+    return True
+
+
+def check_states_match(state1: State[torch.Tensor], state2: State[torch.Tensor]):
+    assert check_keys_match(state1, state2)
+
+    for k in get_keys(state1):
+        assert torch.allclose(
+            state1[k], state2[k]
+        ), f"Trajectories differ in state trajectory of variable {k}, but should be identical."
+
+    return True
+
+
+def check_trajectories_match_in_all_but_values(
+    traj1: State[torch.Tensor], traj2: State[torch.Tensor]
+):
+    assert check_keys_match(traj1, traj2)
+
+    for k in get_keys(traj1):
+        assert not torch.allclose(
+            traj2[k], traj1[k]
+        ), f"Trajectories are identical in state trajectory of variable {k}, but should differ."
+
+    return True
+
+
+def run_svi_inference_torch_direct(model, n_steps=100, verbose=True, **model_kwargs):
+    guide = pyro.infer.autoguide.AutoMultivariateNormal(model)
+    elbo = pyro.infer.Trace_ELBO()(model, guide)
+    # initialize parameters
+    elbo(**model_kwargs)
+    adam = torch.optim.Adam(elbo.parameters(), lr=0.03)
+    # Do gradient steps
+    for step in range(1, n_steps + 1):
+        adam.zero_grad()
+        loss = elbo(**model_kwargs)
+        loss.backward()
+        adam.step()
+        if (step % 100 == 0) or (step == 1) & verbose:
+            print("[iteration %04d] loss: %.4f" % (step, loss))
+    return guide
diff --git a/tests/dynamical/test_dynamic_interventions.py b/tests/dynamical/test_dynamic_interventions.py
new file mode 100644
index 000000000..9e79b0732
--- /dev/null
+++ b/tests/dynamical/test_dynamic_interventions.py
@@ -0,0 +1,529 @@
+import logging
+
+import pytest
+import torch
+from torch import tensor as tt
+
+from chirho.counterfactual.handlers import (
+    MultiWorldCounterfactual,
+    TwinWorldCounterfactual,
+)
+from chirho.dynamical.handlers import (
+    DynamicIntervention,
+    InterruptionEventLoop,
+    LogTrajectory,
+)
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.ops import State, get_keys, simulate
+from chirho.indexed.ops import IndexSet, gather, indices_of, union
+
+from .dynamical_fixtures import UnifiedFixtureDynamics
+
+logger = logging.getLogger(__name__)
+
+# Points at which to measure the state of the system.
+start_time = torch.tensor(0.0)
+end_time = torch.tensor(10.0)
+logging_times = torch.linspace(start_time + 1, end_time - 2, 10)
+
+# Initial state of the system.
+init_state = State(S=torch.tensor(50.0), I=torch.tensor(3.0), R=torch.tensor(0.0))
+
+# State at which the dynamic intervention will trigger.
+trigger_state1 = State(R=torch.tensor(30.0))
+trigger_state2 = State(R=torch.tensor(50.0))
+
+# State we'll switch to when the dynamic intervention triggers.
+intervene_state1 = State(S=torch.tensor(50.0))
+intervene_state2 = State(S=torch.tensor(30.0))
+
+
+def get_state_reached_event_f(target_state: State[torch.tensor], event_dim: int = 0):
+    def event_f(t: torch.tensor, state: State[torch.tensor]):
+        actual, target = state["R"], target_state["R"]
+        cf_indices = IndexSet(
+            **{
+                k: {1}
+                for k in union(
+                    indices_of(actual, event_dim=event_dim),
+                    indices_of(target, event_dim=event_dim),
+                ).keys()
+            }
+        )
+        event_var = gather(actual - target, cf_indices, event_dim=event_dim)
+        return event_var
+
+    return event_f
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("logging_times", [logging_times])
+@pytest.mark.parametrize(
+    "trigger_states",
+    [(trigger_state1, trigger_state2), (trigger_state2, trigger_state1)],
+)
+@pytest.mark.parametrize(
+    "intervene_states",
+    [(intervene_state1, intervene_state2), (intervene_state2, intervene_state1)],
+)
+def test_nested_dynamic_intervention_causes_change(
+    model,
+    init_state,
+    start_time,
+    end_time,
+    logging_times,
+    trigger_states,
+    intervene_states,
+):
+    ts1, ts2 = trigger_states
+    is1, is2 = intervene_states
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with InterruptionEventLoop():
+            with DynamicIntervention(
+                event_f=get_state_reached_event_f(ts1),
+                intervention=is1,
+            ):
+                with DynamicIntervention(
+                    event_f=get_state_reached_event_f(ts2),
+                    intervention=is2,
+                ):
+                    simulate(
+                        model, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+
+    preint_total = init_state["S"] + init_state["I"] + init_state["R"]
+
+    # Each intervention just adds a certain amount of susceptible people after the recovered count exceeds some amount
+
+    trajectory = dt.trajectory
+
+    postint_mask1 = trajectory["R"] > ts1["R"]
+    postint_mask2 = trajectory["R"] > ts2["R"]
+    preint_mask = ~(postint_mask1 | postint_mask2)
+
+    # TODO support dim != -1
+    name_to_dim = {"__time": -1}
+    preint_idx = IndexSet(
+        __time=set(i for i in range(len(preint_mask)) if preint_mask[i])
+    )
+
+    # Make sure all points before the intervention maintain the same total population.
+    preint_traj = gather(trajectory, preint_idx, name_to_dim=name_to_dim)
+    assert torch.allclose(
+        preint_total, preint_traj["S"] + preint_traj["I"] + preint_traj["R"]
+    )
+
+    # Make sure all points after the first intervention, but before the second, include the added population of that
+    #  first intervention.
+    postfirst_int_mask, postsec_int_mask = (
+        (postint_mask1, postint_mask2)
+        if ts1["R"] < ts2["R"]
+        else (postint_mask2, postint_mask1)
+    )
+    firstis, secondis = (is1, is2) if ts1["R"] < ts2["R"] else (is2, is1)
+
+    postfirst_int_presec_int_mask = postfirst_int_mask & ~postsec_int_mask
+
+    assert torch.any(postfirst_int_presec_int_mask) or torch.any(
+        postsec_int_mask
+    ), "trivial test case"
+
+    postfirst_int_presec_int_idx = IndexSet(
+        __time=set(
+            i
+            for i in range(len(postfirst_int_presec_int_mask))
+            if postfirst_int_presec_int_mask[i]
+        )
+    )
+
+    postfirst_int_presec_int_traj = gather(
+        trajectory, postfirst_int_presec_int_idx, name_to_dim=name_to_dim
+    )
+    assert torch.all(
+        postfirst_int_presec_int_traj["S"]
+        + postfirst_int_presec_int_traj["I"]
+        + postfirst_int_presec_int_traj["R"]
+        > (preint_total + firstis["S"]) * 0.95
+    )
+
+    postsec_int_idx = IndexSet(
+        __time=set(i for i in range(len(postsec_int_mask)) if postsec_int_mask[i])
+    )
+
+    postsec_int_traj = gather(trajectory, postsec_int_idx, name_to_dim=name_to_dim)
+    assert torch.all(
+        postsec_int_traj["S"] + postsec_int_traj["I"] + postsec_int_traj["R"]
+        > (preint_total + firstis["S"] + secondis["S"]) * 0.95
+    )
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("logging_times", [logging_times])
+@pytest.mark.parametrize("trigger_state", [trigger_state1])
+@pytest.mark.parametrize("intervene_state", [intervene_state1])
+def test_dynamic_intervention_causes_change(
+    model,
+    init_state,
+    start_time,
+    end_time,
+    logging_times,
+    trigger_state,
+    intervene_state,
+):
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with InterruptionEventLoop():
+            with DynamicIntervention(
+                event_f=get_state_reached_event_f(trigger_state),
+                intervention=intervene_state,
+            ):
+                simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+
+    preint_total = init_state["S"] + init_state["I"] + init_state["R"]
+
+    trajectory = dt.trajectory
+
+    # The intervention just "adds" (sets) 50 "people" to the susceptible population.
+    #  It happens that the susceptible population is roughly 0 at the intervention point,
+    #  so this serves to make sure the intervention actually causes that population influx.
+
+    postint_mask = trajectory["R"] > trigger_state["R"]
+
+    # TODO support dim != -1
+    name_to_dim = {"__time": -1}
+
+    preint_idx = IndexSet(
+        __time=set(i for i in range(len(postint_mask)) if not postint_mask[i])
+    )
+    postint_idx = IndexSet(
+        __time=set(i for i in range(len(postint_mask)) if postint_mask[i])
+    )
+
+    postint_traj = gather(trajectory, postint_idx, name_to_dim=name_to_dim)
+    preint_traj = gather(trajectory, preint_idx, name_to_dim=name_to_dim)
+
+    # Make sure all points before the intervention maintain the same total population.
+    assert torch.allclose(
+        preint_total, preint_traj["S"] + preint_traj["I"] + preint_traj["R"]
+    )
+
+    # Make sure all points after the intervention include the added population.
+    # noinspection PyTypeChecker
+    assert torch.all(
+        postint_traj["S"] + postint_traj["I"] + postint_traj["R"]
+        > (preint_total + intervene_state["S"]) * 0.95
+    )
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("logging_times", [logging_times])
+@pytest.mark.parametrize(
+    "trigger_states",
+    [(trigger_state1, trigger_state2), (trigger_state2, trigger_state1)],
+)
+@pytest.mark.parametrize(
+    "intervene_states",
+    [(intervene_state1, intervene_state2), (intervene_state2, intervene_state1)],
+)
+def test_split_twinworld_dynamic_intervention(
+    model,
+    init_state,
+    start_time,
+    end_time,
+    logging_times,
+    trigger_states,
+    intervene_states,
+):
+    ts1, ts2 = trigger_states
+    is1, is2 = intervene_states
+
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with InterruptionEventLoop():
+            with DynamicIntervention(
+                event_f=get_state_reached_event_f(ts1),
+                intervention=is1,
+            ):
+                with DynamicIntervention(
+                    event_f=get_state_reached_event_f(ts2),
+                    intervention=is2,
+                ):
+                    with TwinWorldCounterfactual() as cf:
+                        cf_state = simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+
+    with cf:
+        cf_trajectory = dt.trajectory
+        for k in get_keys(cf_trajectory):
+            # TODO: Figure out why event_dim=1 is not needed with cf_state but is with cf_trajectory.
+            assert cf.default_name in indices_of(cf_state[k])
+            assert cf.default_name in indices_of(cf_trajectory[k], event_dim=1)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize(
+    "trigger_states",
+    [(trigger_state1, trigger_state2), (trigger_state2, trigger_state1)],
+)
+@pytest.mark.parametrize(
+    "intervene_states",
+    [(intervene_state1, intervene_state2), (intervene_state2, intervene_state1)],
+)
+def test_split_multiworld_dynamic_intervention(
+    model, init_state, start_time, end_time, trigger_states, intervene_states
+):
+    ts1, ts2 = trigger_states
+    is1, is2 = intervene_states
+
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with InterruptionEventLoop():
+            with DynamicIntervention(
+                event_f=get_state_reached_event_f(ts1),
+                intervention=is1,
+            ):
+                with DynamicIntervention(
+                    event_f=get_state_reached_event_f(ts2),
+                    intervention=is2,
+                ):
+                    with MultiWorldCounterfactual() as cf:
+                        cf_state = simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+
+    with cf:
+        cf_trajectory = dt.trajectory
+        for k in get_keys(cf_trajectory):
+            # TODO: Figure out why event_dim=1 is not needed with cf_state but is with cf_trajectory.
+            assert cf.default_name in indices_of(cf_state[k])
+            assert cf.default_name in indices_of(cf_trajectory[k], event_dim=1)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize(
+    "trigger_states",
+    [(trigger_state1, trigger_state2), (trigger_state2, trigger_state1)],
+)
+@pytest.mark.parametrize(
+    "intervene_states",
+    [(intervene_state1, intervene_state2), (intervene_state2, intervene_state1)],
+)
+def test_split_twinworld_dynamic_matches_output(
+    model, init_state, start_time, end_time, trigger_states, intervene_states
+):
+    ts1, ts2 = trigger_states
+    is1, is2 = intervene_states
+
+    with InterruptionEventLoop():
+        with DynamicIntervention(
+            event_f=get_state_reached_event_f(ts1),
+            intervention=is1,
+        ):
+            with DynamicIntervention(
+                event_f=get_state_reached_event_f(ts2),
+                intervention=is2,
+            ):
+                with TwinWorldCounterfactual() as cf:
+                    cf_result = simulate(
+                        model, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+
+    with InterruptionEventLoop():
+        with DynamicIntervention(
+            event_f=get_state_reached_event_f(ts1),
+            intervention=is1,
+        ):
+            with DynamicIntervention(
+                event_f=get_state_reached_event_f(ts2),
+                intervention=is2,
+            ):
+                cf_expected = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    with InterruptionEventLoop():
+        factual_expected = simulate(
+            model, init_state, start_time, end_time, solver=TorchDiffEq()
+        )
+
+    with cf:
+        factual_indices = IndexSet(
+            **{k: {0} for k in indices_of(cf_result, event_dim=0).keys()}
+        )
+
+        cf_indices = IndexSet(
+            **{k: {1} for k in indices_of(cf_result, event_dim=0).keys()}
+        )
+
+        cf_actual = gather(cf_result, cf_indices, event_dim=0)
+        factual_actual = gather(cf_result, factual_indices, event_dim=0)
+
+        assert not set(indices_of(cf_actual, event_dim=0))
+        assert not set(indices_of(factual_actual, event_dim=0))
+
+    assert get_keys(cf_result) == get_keys(cf_actual) == get_keys(cf_expected)
+    assert get_keys(cf_result) == get_keys(factual_actual) == get_keys(factual_expected)
+
+    for k in get_keys(cf_result):
+        assert torch.allclose(
+            cf_actual[k], cf_expected[k], atol=1e-3, rtol=0
+        ), f"Trajectories differ in state result of variable {k}, but should be identical."
+
+    for k in get_keys(cf_result):
+        assert torch.allclose(
+            factual_actual[k],
+            factual_expected[k],
+            atol=1e-3,
+            rtol=0,
+        ), f"Trajectories differ in state result of variable {k}, but should be identical."
+
+
+def test_grad_of_dynamic_intervention_event_f_params():
+    def model(X: State[torch.Tensor]):
+        dX = State()
+        dX["x"] = tt(1.0)
+        dX["z"] = X["dz"]
+        dX["dz"] = tt(0.0)  # also a constant, this gets set by interventions.
+        dX["param"] = tt(
+            0.0
+        )  # this is a constant event function parameter, so no change.
+        return dX
+
+    param = torch.nn.Parameter(tt(5.0))
+    # Param has to be part of the state in order to take gradients with respect to it.
+    s0 = State(x=tt(0.0), z=tt(0.0), dz=tt(0.0), param=param)
+
+    dynamic_intervention = DynamicIntervention(
+        event_f=lambda t, s: t - s["param"],
+        intervention=State(dz=tt(1.0)),
+    )
+
+    # noinspection DuplicatedCode
+    with InterruptionEventLoop():
+        with dynamic_intervention:
+            result = simulate(model, s0, start_time, end_time, solver=TorchDiffEq())
+
+    (dxdparam,) = torch.autograd.grad(
+        outputs=(result["x"],), inputs=(param,), create_graph=True
+    )
+    assert torch.isclose(dxdparam, tt(0.0), atol=1e-5)
+
+    # Z begins accruing dz=1 at t=param, so dzdparam should be -1.0.
+    (dzdparam,) = torch.autograd.grad(
+        outputs=(result["z"],), inputs=(param,), create_graph=True
+    )
+    assert torch.isclose(dzdparam, tt(-1.0), atol=1e-5)
+
+
+def test_grad_of_event_f_params_torchdiffeq_only():
+    # This tests functionality tests in test_grad_of_dynamic_intervention_event_f_params
+    # See "NOTE: parameters for the event function must be in the state itself to obtain gradients."
+    # In the torchdiffeq readme:
+    #  https://github.com/rtqichen/torchdiffeq/blob/master/README.md#differentiable-event-handling
+
+    import torchdiffeq
+
+    param = torch.nn.Parameter(tt(5.0))
+
+    dx = tt(1.0)
+    dz = tt(0.0)
+    dparam = tt(0.0)  # this is a constant event function parameter, so no change.
+    ds = (dx, dz, dparam)
+
+    t0 = tt(0.0)
+    x0, z0, param0 = tt(0.0), tt(0.0), param
+    s0 = (x0, z0, param0)  # x, z, param
+
+    t_at_split, s_at_split = torchdiffeq.odeint_event(
+        lambda t, s: ds,
+        s0,
+        t0,
+        # Terminate when the final element of the state vector (the parameter) is equal to the time. i.e. terminate
+        #  at t=param.
+        event_fn=lambda t, s: t - s[-1],
+    )
+
+    assert torch.isclose(t_at_split, param)
+
+    x_at_split, z_at_split, param_at_split = tuple(v[-1] for v in s_at_split)
+    (dxdparam,) = torch.autograd.grad(
+        outputs=(x_at_split,), inputs=(param,), create_graph=True
+    )
+
+    assert torch.isreal(dxdparam)
+    assert torch.isclose(dxdparam, tt(1.0))
+
+    dz = tt(1.0)
+
+    t_at_end, s_at_end = torchdiffeq.odeint_event(
+        lambda t, s: (dx, dz, tt(0.0)),
+        (x_at_split, z_at_split, param_at_split),
+        t_at_split,
+        event_fn=lambda t, s: t - tt(10.0),  # Terminate at a constant t=10.
+    )
+
+    x_at_end, z_at_end, param_at_end = tuple(v[-1] for v in s_at_end)
+    (dxdparam,) = torch.autograd.grad(
+        outputs=(x_at_end,), inputs=(param,), create_graph=True
+    )
+
+    assert torch.isclose(dxdparam, tt(0.0), atol=1e-5)
+
+    (dzdparam,) = torch.autograd.grad(
+        outputs=(z_at_end,), inputs=(param,), create_graph=True
+    )
+
+    assert torch.isclose(dzdparam, tt(-1.0))
+
+    # Run a second time without the event function, but with the t_at_end terminating the tspan.
+    s_at_end2 = torchdiffeq.odeint(
+        func=lambda t, s: (dx, dz, tt(0.0)),
+        y0=(x_at_split, z_at_split, param_at_split),
+        t=torch.cat((t_at_split[None], t_at_end[None])),
+        # t=torch.tensor((t_at_split[None], t_at_end[None])),  <-- This is what breaks the gradient propagation.
+    )
+
+    x_at_end2, z_at_end2, param_at_end2 = tuple(v[-1] for v in s_at_end2)
+
+    (dxdparam2,) = torch.autograd.grad(
+        outputs=(x_at_end2,), inputs=(param,), create_graph=True
+    )
+
+    assert torch.isclose(dxdparam, dxdparam2)
+
+    (dzdparam2,) = torch.autograd.grad(
+        outputs=(z_at_end2,), inputs=(param,), create_graph=True
+    )
+
+    assert torch.isclose(dzdparam, dzdparam2)
diff --git a/tests/dynamical/test_handler_composition.py b/tests/dynamical/test_handler_composition.py
new file mode 100644
index 000000000..7447e5106
--- /dev/null
+++ b/tests/dynamical/test_handler_composition.py
@@ -0,0 +1,137 @@
+import logging
+
+import pyro
+import torch
+from pyro.distributions import Normal
+
+from chirho.counterfactual.handlers import TwinWorldCounterfactual
+from chirho.dynamical.handlers import (
+    InterruptionEventLoop,
+    LogTrajectory,
+    StaticBatchObservation,
+    StaticIntervention,
+)
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.ops import State, simulate
+from chirho.observational.handlers import condition
+from chirho.observational.handlers.soft_conditioning import AutoSoftConditioning
+from tests.dynamical.dynamical_fixtures import (
+    UnifiedFixtureDynamics,
+    run_svi_inference_torch_direct,
+)
+
+logger = logging.getLogger(__name__)
+
+# Global variables for tests
+init_state = State(S=torch.tensor(10.0), I=torch.tensor(1.0), R=torch.tensor(0.0))
+start_time = torch.tensor(0.0)
+end_time = torch.tensor(1.2)
+logging_times = torch.tensor([0.3, 0.6, 0.9])
+
+#
+# 15 passengers tested positive for a disease after landing
+landing_data = {"infected_passengers": torch.tensor(15.0)}
+landing_time = 0.3 + 1e-2
+
+# In the counterfactual world, a super-spreader event occured at time 0.1
+# In the factual world, however, this did not occur.
+
+ssd = torch.tensor(2.0)
+
+counterfactual = State(
+    S=lambda s: s - ssd,
+    I=lambda i: i + ssd,
+)
+superspreader_time = 0.1
+
+# We want to know how many people passengers would have bene infected at the
+#  time of landing had the super-spreader event not occurred.
+
+flight_landing_times = torch.tensor(
+    [landing_time, landing_time + 1e-2, landing_time + 2e-2]
+)
+flight_landing_data = {k: torch.tensor([v] * 3) for (k, v) in landing_data.items()}
+reparam_config = AutoSoftConditioning(scale=0.01, alpha=0.5)
+
+twin_world = TwinWorldCounterfactual()
+intervention = StaticIntervention(time=superspreader_time, intervention=counterfactual)
+reparam = pyro.poutine.reparam(config=reparam_config)
+
+
+def counterf_model():
+    model = UnifiedFixtureDynamicsReparam(beta=0.5, gamma=0.7)
+    obs = condition(data=flight_landing_data)(model.observation)
+    vec_obs3 = StaticBatchObservation(times=flight_landing_times, observation=obs)
+    with vec_obs3:
+        with InterruptionEventLoop():
+            with reparam, twin_world, intervention:
+                return simulate(
+                    model,
+                    init_state,
+                    start_time,
+                    end_time,
+                    solver=TorchDiffEq(),
+                )
+
+
+def conditioned_model():
+    # This is equivalent to the following:
+    # with InterruptionEventLoop():
+    #   with vec_obs3:
+    #       return simulate(...)
+    # It simply blocks the intervention, twin world, and reparameterization handlers, as those need to be removed from
+    #  the factual conditional world.
+    with pyro.poutine.messenger.block_messengers(
+        lambda m: m in (reparam, twin_world, intervention)
+    ):
+        return counterf_model()
+
+
+# A reparameterized observation function of various flight arrivals.
+class UnifiedFixtureDynamicsReparam(UnifiedFixtureDynamics):
+    def observation(self, X: State[torch.Tensor]):
+        # super().observation(X)
+
+        # A flight arrives in a country that tests all arrivals for a disease. The number of people infected on the
+        #  plane is a noisy function of the number of infected people in the country of origin at that time.
+        u_ip = pyro.sample(
+            "u_ip", Normal(7.0, 2.0).expand(X["I"].shape[-1:]).to_event(1)
+        )
+        pyro.deterministic("infected_passengers", X["I"] + u_ip, event_dim=1)
+
+
+def test_shape_twincounterfactual_observation_intervention_commutes():
+    with LogTrajectory(logging_times) as dt:
+        with pyro.poutine.trace() as tr:
+            conditioned_model()
+
+    ret = dt.trajectory
+
+    num_worlds = 2
+
+    state_shape = (num_worlds, len(logging_times))
+    assert ret["S"].squeeze().squeeze().shape == state_shape
+    assert ret["I"].squeeze().squeeze().shape == state_shape
+    assert ret["R"].squeeze().squeeze().shape == state_shape
+
+    nodes = tr.get_trace().nodes
+
+    obs_shape = (num_worlds, len(flight_landing_times))
+    assert nodes["infected_passengers"]["value"].squeeze().shape == obs_shape
+
+
+def test_smoke_inference_twincounterfactual_observation_intervention_commutes():
+    # Run inference on factual model.
+    guide = run_svi_inference_torch_direct(conditioned_model, n_steps=2, verbose=False)
+
+    num_samples = 100
+    pred = pyro.infer.Predictive(counterf_model, guide=guide, num_samples=num_samples)()
+    num_worlds = 2
+    # infected passengers is going to differ depending on which of two worlds
+    assert pred["infected_passengers"].squeeze().shape == (
+        num_samples,
+        num_worlds,
+        len(flight_landing_times),
+    )
+    # Noise is shared between factual and counterfactual worlds.
+    assert pred["u_ip"].squeeze().shape == (num_samples, len(flight_landing_times))
diff --git a/tests/dynamical/test_log_trajectory.py b/tests/dynamical/test_log_trajectory.py
new file mode 100644
index 000000000..727ef099d
--- /dev/null
+++ b/tests/dynamical/test_log_trajectory.py
@@ -0,0 +1,62 @@
+import logging
+
+import pyro
+import torch
+
+from chirho.dynamical.handlers import InterruptionEventLoop, LogTrajectory
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.internals._utils import append
+from chirho.dynamical.ops import State, get_keys, simulate
+
+from .dynamical_fixtures import bayes_sir_model, check_states_match
+
+pyro.settings.set(module_local_params=True)
+
+logger = logging.getLogger(__name__)
+
+# Global variables for tests
+init_state = State(S=torch.tensor(1.0), I=torch.tensor(2.0), R=torch.tensor(3.3))
+start_time = torch.tensor(0.0)
+end_time = torch.tensor(4.0)
+logging_times = torch.tensor([1.0, 2.0, 3.0])
+
+
+def test_logging():
+    sir = bayes_sir_model()
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt1:
+        result1 = simulate(sir, init_state, start_time, end_time, solver=TorchDiffEq())
+
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt2:
+        with InterruptionEventLoop():
+            result2 = simulate(
+                sir, init_state, start_time, end_time, solver=TorchDiffEq()
+            )
+    result3 = simulate(sir, init_state, start_time, end_time, solver=TorchDiffEq())
+
+    assert isinstance(result1, State)
+    assert isinstance(dt1.trajectory, State)
+    assert isinstance(dt2.trajectory, State)
+    assert len(get_keys(dt1.trajectory)) == 3
+    assert len(get_keys(dt2.trajectory)) == 3
+    assert get_keys(dt1.trajectory) == get_keys(result1)
+    assert get_keys(dt2.trajectory) == get_keys(result2)
+    assert check_states_match(result1, result2)
+    assert check_states_match(result1, result3)
+
+
+def test_trajectory_methods():
+    trajectory = State(S=torch.tensor([1.0, 2.0, 3.0]))
+    assert get_keys(trajectory) == frozenset({"S"})
+
+
+def test_append():
+    trajectory1 = State(S=torch.tensor([1.0, 2.0, 3.0]))
+    trajectory2 = State(S=torch.tensor([4.0, 5.0, 6.0]))
+    trajectory = append(trajectory1, trajectory2)
+    assert torch.allclose(
+        trajectory["S"], torch.tensor([1.0, 2.0, 3.0, 4.0, 5.0, 6.0])
+    ), "append() failed to append a trajectory"
diff --git a/tests/dynamical/test_noop_interruptions.py b/tests/dynamical/test_noop_interruptions.py
new file mode 100644
index 000000000..d45075487
--- /dev/null
+++ b/tests/dynamical/test_noop_interruptions.py
@@ -0,0 +1,190 @@
+import logging
+
+import pytest
+import torch
+
+from chirho.dynamical.handlers import (
+    DynamicInterruption,
+    InterruptionEventLoop,
+    StaticInterruption,
+    StaticIntervention,
+)
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.ops import State, simulate
+
+from .dynamical_fixtures import UnifiedFixtureDynamics, check_states_match
+
+logger = logging.getLogger(__name__)
+
+# Points at which to measure the state of the system.
+start_time = torch.tensor(1.0)
+end_time = torch.tensor(4.0)
+# Initial state of the system.
+init_state_values = State(
+    S=torch.tensor(10.0), I=torch.tensor(3.0), R=torch.tensor(1.0)
+)
+
+eps = 1e-3
+
+intervene_states = [
+    State(S=torch.tensor(11.0)),
+    State(I=torch.tensor(9.0)),
+    State(S=torch.tensor(10.0), R=torch.tensor(5.0)),
+    State(S=torch.tensor(20.0), I=torch.tensor(11.0), R=torch.tensor(4.0)),
+]
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+def test_noop_point_interruptions(model, init_state, start_time, end_time):
+    observational_execution_result = simulate(
+        model, init_state, start_time, end_time, solver=TorchDiffEq()
+    )
+
+    # Test with standard point interruptions within timespan.
+    with InterruptionEventLoop():
+        with StaticInterruption(time=end_time / 2.0 + eps):
+            result_pint = simulate(
+                model, init_state, start_time, end_time, solver=TorchDiffEq()
+            )
+
+    assert check_states_match(observational_execution_result, result_pint)
+
+    # Test with two standard point interruptions.
+    with InterruptionEventLoop():
+        with StaticInterruption(
+            time=end_time / 4.0 + eps
+        ):  # roughly 1/4 of the way through the timespan
+            with StaticInterruption(time=(end_time / 4.0) * 3 + eps):  # roughly 3/4
+                result_double_pint1 = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    assert check_states_match(observational_execution_result, result_double_pint1)
+
+    # Test with two standard point interruptions, in a different order.
+    with InterruptionEventLoop():
+        with StaticInterruption(time=(end_time / 4.0) * 3 + eps):  # roughly 3/4
+            with StaticInterruption(time=end_time / 4.0 + eps):  # roughly 1/3
+                result_double_pint2 = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    assert check_states_match(observational_execution_result, result_double_pint2)
+
+    # TODO test pointinterruptions when they are out of scope of the timespan
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+def test_noop_point_interventions(
+    model, init_state, start_time, end_time, intervene_state
+):
+    """
+    Test whether point interruptions that don't intervene match the unhandled ("observatonal") default simulation.
+    :return:
+    """
+
+    post_measurement_intervention_time = end_time + 1.0
+
+    observational_execution_result = simulate(
+        model, init_state, start_time, end_time, solver=TorchDiffEq()
+    )
+
+    # Test a single point intervention.
+    with pytest.warns(
+        expected_warning=UserWarning, match="occurred after the end of the timespan"
+    ):
+        with InterruptionEventLoop():
+            with StaticIntervention(
+                time=post_measurement_intervention_time, intervention=intervene_state
+            ):
+                result_single_pi = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    assert check_states_match(observational_execution_result, result_single_pi)
+
+    # Test two point interventions out of scope.
+    with pytest.warns(
+        expected_warning=UserWarning, match="occurred after the end of the timespan"
+    ):
+        with InterruptionEventLoop():
+            with StaticIntervention(
+                time=post_measurement_intervention_time, intervention=intervene_state
+            ):
+                with StaticIntervention(
+                    time=post_measurement_intervention_time + 1.0,
+                    intervention=intervene_state,
+                ):
+                    result_double_pi1 = simulate(
+                        model, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+
+    assert check_states_match(observational_execution_result, result_double_pi1)
+
+    # Test with two point interventions out of scope, in a different order.
+    with pytest.warns(
+        expected_warning=UserWarning, match="occurred after the end of the timespan"
+    ):
+        with InterruptionEventLoop():
+            with StaticIntervention(
+                time=post_measurement_intervention_time + 1.0,
+                intervention=intervene_state,
+            ):
+                with StaticIntervention(
+                    time=post_measurement_intervention_time,
+                    intervention=intervene_state,
+                ):
+                    result_double_pi2 = simulate(
+                        model, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+
+    assert check_states_match(observational_execution_result, result_double_pi2)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+def test_point_interruption_at_start(model, init_state, start_time, end_time):
+    observational_execution_result = simulate(
+        model, init_state, start_time, end_time, solver=TorchDiffEq()
+    )
+
+    with InterruptionEventLoop():
+        with StaticInterruption(time=1.0):
+            result_pint = simulate(
+                model, init_state, start_time, end_time, solver=TorchDiffEq()
+            )
+
+    assert check_states_match(observational_execution_result, result_pint)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+def test_noop_dynamic_interruption(
+    model, init_state, start_time, end_time, intervene_state
+):
+    observational_execution_result = simulate(
+        model, init_state, start_time, end_time, solver=TorchDiffEq()
+    )
+
+    with InterruptionEventLoop():
+        tt = (end_time - start_time) / 2.0
+        with DynamicInterruption(
+            event_f=lambda t, _: torch.where(t < tt, tt - t, 0.0),
+        ):
+            result_dint = simulate(
+                model, init_state, start_time, end_time, solver=TorchDiffEq()
+            )
+
+    assert check_states_match(observational_execution_result, result_dint)
diff --git a/tests/dynamical/test_solver.py b/tests/dynamical/test_solver.py
new file mode 100644
index 000000000..6c528e751
--- /dev/null
+++ b/tests/dynamical/test_solver.py
@@ -0,0 +1,53 @@
+import logging
+
+import pyro
+import pytest
+import torch
+
+from chirho.dynamical.handlers import InterruptionEventLoop
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.ops import State, simulate
+
+from .dynamical_fixtures import bayes_sir_model, check_states_match
+
+pyro.settings.set(module_local_params=True)
+
+logger = logging.getLogger(__name__)
+
+# Global variables for tests
+init_state = State(S=torch.tensor(1.0), I=torch.tensor(2.0), R=torch.tensor(3.3))
+start_time = torch.tensor(0.0)
+end_time = torch.tensor(4.0)
+
+
+def test_no_backend_error():
+    sir = bayes_sir_model()
+    with pytest.raises(ValueError):
+        simulate(sir, init_state, start_time, end_time)
+
+
+def test_no_backend_SEL_error():
+    sir = bayes_sir_model()
+    with pytest.raises(ValueError):
+        with InterruptionEventLoop():
+            simulate(sir, init_state, start_time, end_time)
+
+
+def test_backend_arg():
+    sir = bayes_sir_model()
+    with InterruptionEventLoop():
+        result = simulate(sir, init_state, start_time, end_time, solver=TorchDiffEq())
+    assert result is not None
+
+
+def test_backend_handler():
+    sir = bayes_sir_model()
+    with InterruptionEventLoop():
+        with TorchDiffEq():
+            result_handler = simulate(sir, init_state, start_time, end_time)
+
+        result_arg = simulate(
+            sir, init_state, start_time, end_time, solver=TorchDiffEq()
+        )
+
+    assert check_states_match(result_handler, result_arg)
diff --git a/tests/dynamical/test_static_interventions.py b/tests/dynamical/test_static_interventions.py
new file mode 100644
index 000000000..0cc258ec5
--- /dev/null
+++ b/tests/dynamical/test_static_interventions.py
@@ -0,0 +1,367 @@
+import logging
+
+import pytest
+import torch
+
+from chirho.counterfactual.handlers import (
+    MultiWorldCounterfactual,
+    TwinWorldCounterfactual,
+)
+from chirho.dynamical.handlers import (
+    InterruptionEventLoop,
+    LogTrajectory,
+    StaticIntervention,
+)
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.ops import State, get_keys, simulate
+from chirho.indexed.ops import IndexSet, gather, indices_of
+from chirho.interventional.ops import intervene
+
+from .dynamical_fixtures import (
+    UnifiedFixtureDynamics,
+    check_states_match,
+    check_trajectories_match_in_all_but_values,
+)
+
+logger = logging.getLogger(__name__)
+
+# Points at which to measure the state of the system.
+start_time = torch.tensor(0.0)
+end_time = torch.tensor(10.0)
+logging_times = torch.linspace(start_time + 1, end_time - 2, 5)
+
+# Initial state of the system.
+init_state_values = State(
+    S=torch.tensor(10.0), I=torch.tensor(3.0), R=torch.tensor(1.0)
+)
+
+# Large interventions that will make a difference.
+intervene_states = [
+    State(I=torch.tensor(50.0)),
+    State(S=torch.tensor(50.0), R=torch.tensor(50.0)),
+    State(S=torch.tensor(50.0), I=torch.tensor(50.0), R=torch.tensor(50.0)),
+]
+
+# Define intervention times before all tspan values.
+intervene_times = (logging_times - 0.5).tolist()
+
+
+eps = 1e-3
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("logging_times", [logging_times])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+@pytest.mark.parametrize("intervene_time", intervene_times)
+def test_point_intervention_causes_difference(
+    model,
+    init_state,
+    start_time,
+    end_time,
+    logging_times,
+    intervene_state,
+    intervene_time,
+):
+    with LogTrajectory(
+        times=logging_times,
+    ) as observational_dt:
+        simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with LogTrajectory(
+        times=logging_times,
+    ) as intervened_dt:
+        with InterruptionEventLoop():
+            with StaticIntervention(time=intervene_time, intervention=intervene_state):
+                if intervene_time < start_time:
+                    with pytest.raises(
+                        ValueError, match="occurred before the start of the timespan"
+                    ):
+                        simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+                    return
+                else:
+                    simulate(
+                        model, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+
+    observational_trajectory = observational_dt.trajectory
+    intervened_trajectory = intervened_dt.trajectory
+
+    assert check_trajectories_match_in_all_but_values(
+        observational_trajectory, intervened_trajectory
+    )
+
+    # Make sure the intervention only causes a difference after the intervention time.
+    after = intervene_time < logging_times
+    before = ~after
+
+    assert torch.any(before) or torch.any(after), "trivial test case"
+
+    # TODO support dim != -1
+    name_to_dim = {"__time": -1}
+
+    before_idx = IndexSet(__time={i for i in range(len(before)) if before[i]})
+    after_idx = IndexSet(__time={i for i in range(len(after)) if after[i]})
+
+    observational_trajectory_before_int = gather(
+        observational_trajectory, before_idx, name_to_dim=name_to_dim
+    )
+    intervened_trajectory_before_int = gather(
+        intervened_trajectory, before_idx, name_to_dim=name_to_dim
+    )
+    assert after.all() or check_states_match(
+        observational_trajectory_before_int, intervened_trajectory_before_int
+    )
+
+    observational_trajectory_after_int = gather(
+        observational_trajectory, after_idx, name_to_dim=name_to_dim
+    )
+    intervened_trajectory_after_int = gather(
+        intervened_trajectory, after_idx, name_to_dim=name_to_dim
+    )
+    assert before.all() or check_trajectories_match_in_all_but_values(
+        observational_trajectory_after_int, intervened_trajectory_after_int
+    )
+
+
+# TODO test what happens when the intervention time is exactly at the start of the time span.
+
+
+# TODO get rid of some entries cz this test takes too long to run w/ all permutations.
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state1", intervene_states)
+@pytest.mark.parametrize("intervene_time1", intervene_times)
+@pytest.mark.parametrize("intervene_state2", intervene_states)
+@pytest.mark.parametrize("intervene_time2", intervene_times)
+def test_nested_point_interventions_cause_difference(
+    model,
+    init_state,
+    start_time,
+    end_time,
+    intervene_state1,
+    intervene_time1,
+    intervene_state2,
+    intervene_time2,
+):
+    with LogTrajectory(
+        times=logging_times,
+    ) as observational_dt:
+        simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with LogTrajectory(
+        times=logging_times,
+    ) as intervened_dt:
+        with InterruptionEventLoop():
+            with StaticIntervention(
+                time=intervene_time1, intervention=intervene_state1
+            ):
+                with StaticIntervention(
+                    time=intervene_time2, intervention=intervene_state2
+                ):
+                    if intervene_time1 < start_time or intervene_time2 < start_time:
+                        with pytest.raises(
+                            ValueError,
+                            match="occurred before the start of the timespan",
+                        ):
+                            simulate(
+                                model,
+                                init_state,
+                                start_time,
+                                end_time,
+                                solver=TorchDiffEq(),
+                            )
+                        return
+                    # AZ - We've decided to support this case and have interventions apply sequentially in the order
+                    #  they are handled.
+                    # elif torch.isclose(intervene_time1, intervene_time2):
+                    #     with pytest.raises(
+                    #         ValueError,
+                    #         match="Two point interruptions cannot occur at the same time.",
+                    #     ):
+                    #         simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+                    #     return
+                    else:
+                        simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+
+    assert check_trajectories_match_in_all_but_values(
+        observational_dt.trajectory, intervened_dt.trajectory
+    )
+
+    # Don't need to flip order b/c the argument permutation will effectively do this for us.
+
+
+# TODO test that we're getting the exactly right answer, instead of just "a different answer" as we are now.
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+@pytest.mark.parametrize("intervene_time", list(intervene_times)[1:])
+def test_twinworld_point_intervention(
+    model, init_state, start_time, end_time, intervene_state, intervene_time
+):
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with InterruptionEventLoop():
+            with StaticIntervention(time=intervene_time, intervention=intervene_state):
+                with StaticIntervention(
+                    time=intervene_time + 0.5, intervention=intervene_state
+                ):
+                    with TwinWorldCounterfactual() as cf:
+                        cf_state = simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+
+    with cf:
+        cf_trajectory = dt.trajectory
+        for k in get_keys(cf_trajectory):
+            # TODO: Figure out why event_dim=1 is not needed with cf_state but is with cf_trajectory.
+            assert cf.default_name in indices_of(cf_state[k])
+            assert cf.default_name in indices_of(cf_trajectory[k], event_dim=1)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+@pytest.mark.parametrize("intervene_time", list(intervene_times)[1:])
+def test_multiworld_point_intervention(
+    model, init_state, start_time, end_time, intervene_state, intervene_time
+):
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with InterruptionEventLoop():
+            with StaticIntervention(time=intervene_time, intervention=intervene_state):
+                with StaticIntervention(
+                    time=intervene_time + 0.5, intervention=intervene_state
+                ):
+                    with MultiWorldCounterfactual() as cf:
+                        cf_state = simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+
+    with cf:
+        cf_trajectory = dt.trajectory
+        for k in get_keys(cf_trajectory):
+            # TODO: Figure out why event_dim=1 is not needed with cf_state but is with cf_trajectory.
+            assert cf.default_name in indices_of(cf_state[k])
+            assert cf.default_name in indices_of(cf_trajectory[k], event_dim=1)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+@pytest.mark.parametrize("intervene_time", list(intervene_times)[1:])
+def test_split_odeint_broadcast(
+    model, init_state, start_time, end_time, intervene_state, intervene_time
+):
+    with LogTrajectory(
+        times=logging_times,
+    ) as dt:
+        with TwinWorldCounterfactual() as cf:
+            cf_init_state = intervene(init_state_values, intervene_state, event_dim=0)
+            simulate(model, cf_init_state, start_time, end_time, solver=TorchDiffEq())
+
+    with cf:
+        trajectory = dt.trajectory
+        for k in get_keys(trajectory):
+            assert len(indices_of(trajectory[k], event_dim=1)) > 0
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("init_state", [init_state_values])
+@pytest.mark.parametrize("start_time", [start_time])
+@pytest.mark.parametrize("end_time", [end_time])
+@pytest.mark.parametrize("intervene_state", intervene_states)
+@pytest.mark.parametrize("intervene_time", list(intervene_times)[1:])
+def test_twinworld_matches_output(
+    model, init_state, start_time, end_time, intervene_state, intervene_time
+):
+    # Simulate with the intervention and ensure that the result differs from the observational execution.
+    with InterruptionEventLoop():
+        with StaticIntervention(time=intervene_time, intervention=intervene_state):
+            with StaticIntervention(
+                time=intervene_time + 0.543, intervention=intervene_state
+            ):
+                with TwinWorldCounterfactual() as cf:
+                    cf_state = simulate(
+                        model, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+
+    with InterruptionEventLoop():
+        with StaticIntervention(time=intervene_time, intervention=intervene_state):
+            with StaticIntervention(
+                time=intervene_time + 0.543, intervention=intervene_state
+            ):
+                cf_expected = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    with InterruptionEventLoop():
+        factual_expected = simulate(
+            model, init_state, start_time, end_time, solver=TorchDiffEq()
+        )
+
+    with cf:
+        factual_indices = IndexSet(
+            **{k: {0} for k in indices_of(cf_state, event_dim=0).keys()}
+        )
+
+        cf_indices = IndexSet(
+            **{k: {1} for k in indices_of(cf_state, event_dim=0).keys()}
+        )
+
+        cf_actual = gather(cf_state, cf_indices, event_dim=0)
+        factual_actual = gather(cf_state, factual_indices, event_dim=0)
+
+        assert not set(indices_of(cf_actual, event_dim=0))
+        assert not set(indices_of(factual_actual, event_dim=0))
+
+    assert get_keys(cf_state) == get_keys(cf_actual) == get_keys(cf_expected)
+    assert get_keys(cf_state) == get_keys(factual_actual) == get_keys(factual_expected)
+
+    for k in get_keys(cf_state):
+        assert torch.allclose(
+            cf_actual[k], cf_expected[k]
+        ), f"States differ in state trajectory of variable {k}, but should be identical."
+
+    for k in get_keys(cf_state):
+        assert torch.allclose(
+            factual_actual[k], factual_expected[k]
+        ), f"States differ in state trajectory of variable {k}, but should be identical."
diff --git a/tests/dynamical/test_static_observation.py b/tests/dynamical/test_static_observation.py
new file mode 100644
index 000000000..dd2c99070
--- /dev/null
+++ b/tests/dynamical/test_static_observation.py
@@ -0,0 +1,310 @@
+import logging
+from contextlib import ExitStack
+
+import pyro
+import pytest
+import torch
+from pyro.infer.autoguide import AutoMultivariateNormal
+
+from chirho.dynamical.handlers import (
+    InterruptionEventLoop,
+    LogTrajectory,
+    StaticBatchObservation,
+    StaticObservation,
+)
+from chirho.dynamical.handlers.solver import TorchDiffEq
+from chirho.dynamical.ops import State, simulate
+from chirho.observational.handlers import condition
+
+from .dynamical_fixtures import (
+    UnifiedFixtureDynamics,
+    bayes_sir_model,
+    check_states_match,
+)
+
+pyro.settings.set(module_local_params=True)
+
+logger = logging.getLogger(__name__)
+
+# Global variables for tests
+init_state = State(S=torch.tensor(1.0), I=torch.tensor(2.0), R=torch.tensor(3.3))
+start_time = torch.tensor(0.0)
+end_time = torch.tensor(4.0)
+logging_times = torch.tensor([1.0, 2.0, 3.0])
+
+
+def run_svi_inference(model, n_steps=10, verbose=False, lr=0.03, **model_kwargs):
+    guide = AutoMultivariateNormal(model)
+    elbo = pyro.infer.Trace_ELBO()(model, guide)
+    # initialize parameters
+    elbo(**model_kwargs)
+    adam = torch.optim.Adam(elbo.parameters(), lr=lr)
+    # Do gradient steps
+    for step in range(1, n_steps + 1):
+        adam.zero_grad()
+        loss = elbo(**model_kwargs)
+        loss.backward()
+        adam.step()
+        if (step % 250 == 0) or (step == 1) & verbose:
+            print("[iteration %04d] loss: %.4f" % (step, loss))
+    return guide
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+def test_multiple_point_observations(model):
+    """
+    Tests if multiple StaticObservation handlers can be composed.
+    """
+    S_obs = torch.tensor(10.0)
+    data1 = {"S_obs": S_obs}
+    data2 = {"I_obs": torch.tensor(5.0), "R_obs": torch.tensor(5.0)}
+    obs1 = condition(data=data1)(model.observation)
+    obs2 = condition(data=data2)(model.observation)
+    with InterruptionEventLoop():
+        result1 = simulate(
+            model, init_state, start_time, end_time, solver=TorchDiffEq()
+        )
+        with StaticObservation(time=3.1, observation=obs2):
+            with StaticObservation(time=2.9, observation=obs1):
+                result2 = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    check_states_match(result1, result2)
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("obs_handler_cls", [StaticObservation, StaticBatchObservation])
+def test_log_prob_exists(model, obs_handler_cls):
+    """
+    Tests if the log_prob exists at the observed site.
+    """
+    S_obs = torch.tensor(10.0)
+    data = {"S_obs": S_obs}
+    time = 2.9
+    if obs_handler_cls is StaticObservation:
+        obs = condition(data=data)(model.observation)
+    else:
+        time = torch.tensor([time, time + 0.1])
+        data = {k: torch.tensor([v, v]) for k, v in data.items()}
+        obs = condition(data=data)(model.observation)
+
+    with pyro.poutine.trace() as tr:
+        with InterruptionEventLoop():
+            with obs_handler_cls(time, observation=obs):
+                simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+
+    assert isinstance(tr.trace.log_prob_sum(), torch.Tensor), "No log_prob found!"
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+@pytest.mark.parametrize("obs_handler_cls", [StaticObservation, StaticBatchObservation])
+def test_tspan_collision(model, obs_handler_cls):
+    """
+    Tests if observation times that intersect with tspan do not raise an error or create
+    shape mismatches.
+    """
+    S_obs = torch.tensor(10.0)
+    data = {"S_obs": S_obs}
+    time = start_time
+    if obs_handler_cls is StaticObservation:
+        obs = condition(data=data)(model.observation)
+    else:
+        data = {k: torch.tensor([v, v]) for k, v in data.items()}
+        obs = condition(data=data)(model.observation)
+        time = torch.tensor([time, time + 0.1])
+
+    with LogTrajectory(logging_times) as dt:
+        with InterruptionEventLoop():
+            with obs_handler_cls(time, observation=obs):
+                simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+    result = dt.trajectory
+    assert result["S"].shape[0] == len(logging_times)
+    assert result["I"].shape[0] == len(logging_times)
+    assert result["R"].shape[0] == len(logging_times)
+
+
+@pytest.mark.parametrize("model", [bayes_sir_model])
+@pytest.mark.parametrize("obs_handler_cls", [StaticObservation, StaticBatchObservation])
+def test_svi_composition_test_one(model, obs_handler_cls):
+    data = {
+        "S_obs": torch.tensor(10.0),
+        "I_obs": torch.tensor(5.0),
+        "R_obs": torch.tensor(5.0),
+    }
+    time = 2.9
+
+    class ConditionedSIR(pyro.nn.PyroModule):
+        def forward(self):
+            sir = model()
+
+            if obs_handler_cls is StaticObservation:
+                obs = condition(data=data)(sir.observation)
+                time_ = time
+            else:
+                data_ = {k: torch.tensor([v, v]) for k, v in data.items()}
+                obs = condition(data=data_)(sir.observation)
+                time_ = torch.tensor([time, time + 0.1])
+
+            with InterruptionEventLoop():
+                with obs_handler_cls(time_, observation=obs):
+                    traj = simulate(
+                        sir, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+            return traj
+
+    conditioned_sir = ConditionedSIR()
+
+    guide = run_svi_inference(conditioned_sir)
+
+    assert guide is not None
+
+
+@pytest.mark.parametrize("model", [UnifiedFixtureDynamics()])
+def test_interrupting_and_non_interrupting_observation_array_equivalence(model):
+    S_obs = torch.tensor([10.0, 5.0, 3.0])
+    I_obs = torch.tensor([1.0, 4.0, 4.0])
+    R_obs = torch.tensor([0.0, 1.0, 3.0])
+    data = dict(
+        S_obs=S_obs,
+        I_obs=I_obs,
+        R_obs=R_obs,
+    )
+    times = torch.tensor([1.5, 2.9, 3.2])
+
+    obs = condition(data=data)(model.observation)
+    obs0 = condition(data={k: v[0] for k, v in data.items()})(model.observation)
+    obs1 = condition(data={k: v[1] for k, v in data.items()})(model.observation)
+    obs2 = condition(data={k: v[2] for k, v in data.items()})(model.observation)
+
+    with pyro.poutine.trace() as tr1:
+        with InterruptionEventLoop():
+            with StaticObservation(time=times[1].item(), observation=obs1):
+                with StaticObservation(time=times[0].item(), observation=obs0):
+                    with StaticObservation(time=times[2].item(), observation=obs2):
+                        interrupting_ret = simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+
+    with pyro.poutine.trace() as tr2:
+        with InterruptionEventLoop():
+            with StaticBatchObservation(times=times, observation=obs):
+                non_interrupting_ret = simulate(
+                    model, init_state, start_time, end_time, solver=TorchDiffEq()
+                )
+
+    assert check_states_match(interrupting_ret, non_interrupting_ret)
+
+    assert torch.isclose(tr1.trace.log_prob_sum(), tr2.trace.log_prob_sum())
+
+
+@pytest.mark.parametrize("model", [bayes_sir_model])
+def test_svi_composition_test_multi_point_obs(model):
+    data1 = {
+        "S_obs": torch.tensor(10.0),
+        "I_obs": torch.tensor(5.0),
+        "R_obs": torch.tensor(5.0),
+    }
+    data2 = {
+        "S_obs": torch.tensor(8.0),
+        "I_obs": torch.tensor(6.0),
+        "R_obs": torch.tensor(6.0),
+    }
+
+    data = dict()
+    data[0] = [torch.tensor(0.1), data1]
+    data[1] = [torch.tensor(3.1), data2]
+
+    class ConditionedSIR(pyro.nn.PyroModule):
+        def forward(self):
+            sir = model()
+            observation_managers = []
+            for obs in data.values():
+                obs_time = obs[0].item()
+                obs_data = obs[1]
+                obs_model = condition(data=obs_data)(sir.observation)
+                observation_managers.append(StaticObservation(obs_time, obs_model))
+            with InterruptionEventLoop():
+                with ExitStack() as stack:
+                    for manager in observation_managers:
+                        stack.enter_context(manager)
+                    traj = simulate(
+                        sir, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+            return traj
+
+    conditioned_sir = ConditionedSIR()
+
+    guide = run_svi_inference(conditioned_sir)
+
+    assert guide is not None
+
+
+@pytest.mark.parametrize("model", [bayes_sir_model])
+def test_svi_composition_vectorized_obs(model):
+    times = torch.tensor([0.1, 1.5, 2.3, 3.1])
+    data = {
+        "S_obs": torch.tensor([10.0, 8.0, 5.0, 3.0]),
+        "I_obs": torch.tensor([1.0, 2.0, 5.0, 7.0]),
+        "R_obs": torch.tensor([0.0, 1.0, 2.0, 3.0]),
+    }
+
+    class ConditionedSIR(pyro.nn.PyroModule):
+        def forward(self):
+            sir = model()
+            obs = condition(data=data)(sir.observation)
+            with InterruptionEventLoop():
+                with StaticBatchObservation(times=times, observation=obs):
+                    traj = simulate(
+                        sir, init_state, start_time, end_time, solver=TorchDiffEq()
+                    )
+            return traj
+
+    conditioned_sir = ConditionedSIR()
+
+    guide = run_svi_inference(conditioned_sir)
+
+    assert guide is not None
+
+
+@pytest.mark.parametrize("use_event_loop", [True, False])
+def test_simulate_persistent_pyrosample(use_event_loop):
+    class RandBetaUnifiedFixtureDynamics(UnifiedFixtureDynamics):
+        @pyro.nn.PyroSample
+        def beta(self):
+            return pyro.distributions.Beta(1, 1)
+
+        def forward(self, X: State[torch.Tensor]):
+            assert torch.allclose(self.beta, self.beta)
+            return super().forward(X)
+
+    model = RandBetaUnifiedFixtureDynamics()
+
+    with LogTrajectory(logging_times) as dt:
+        if not use_event_loop:
+            simulate(model, init_state, start_time, end_time, solver=TorchDiffEq())
+        else:
+            S_obs = torch.tensor(10.0)
+            data1 = {"S_obs": S_obs}
+            data2 = {"I_obs": torch.tensor(5.0), "R_obs": torch.tensor(5.0)}
+            obs1 = condition(data=data1)(model.observation)
+            obs2 = condition(data=data2)(model.observation)
+            with InterruptionEventLoop():
+                with StaticObservation(time=3.1, observation=obs2):
+                    with StaticObservation(time=2.9, observation=obs1):
+                        simulate(
+                            model,
+                            init_state,
+                            start_time,
+                            end_time,
+                            solver=TorchDiffEq(),
+                        )
+    result = dt.trajectory
+
+    assert result["S"].shape[0] == len(logging_times)
+    assert result["I"].shape[0] == len(logging_times)
+    assert result["R"].shape[0] == len(logging_times)