diff --git a/.github/workflows/test_notebooks.yml b/.github/workflows/test_notebooks.yml index fbd3b2aba..d0b1f5dda 100644 --- a/.github/workflows/test_notebooks.yml +++ b/.github/workflows/test_notebooks.yml @@ -39,7 +39,7 @@ jobs: - name: Install Python packages from requirements.txt run: | pip install --upgrade pip - pip install -e .[test] + pip install -e .[test,dynamical] - name: Run Notebook Test run: | diff --git a/chirho/dynamical/handlers/interruption.py b/chirho/dynamical/handlers/interruption.py index 5ebe47f79..1e9c53577 100644 --- a/chirho/dynamical/handlers/interruption.py +++ b/chirho/dynamical/handlers/interruption.py @@ -126,9 +126,10 @@ def __init__( self, times: torch.Tensor, observation: Observation[State[T]], + **kwargs, ): self.observation = observation - super().__init__(times) + super().__init__(times, **kwargs) def _pyro_post_simulate(self, msg: dict) -> None: super()._pyro_post_simulate(msg) diff --git a/chirho/dynamical/handlers/trajectory.py b/chirho/dynamical/handlers/trajectory.py index 17c233036..b2cd5cd9d 100644 --- a/chirho/dynamical/handlers/trajectory.py +++ b/chirho/dynamical/handlers/trajectory.py @@ -19,9 +19,10 @@ class LogTrajectory(Generic[T], pyro.poutine.messenger.Messenger): trajectory: State[T] _trajectory: State[T] - def __init__(self, times: torch.Tensor): + def __init__(self, times: torch.Tensor, is_traced: bool = False): self.times = times self._trajectory: State[T] = State() + self.is_traced = is_traced # 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]): @@ -46,6 +47,10 @@ def _pyro_post_simulate(self, msg) -> None: self.trajectory = self._trajectory self._trajectory: State[T] = State() + if self.is_traced: + # This adds the trajectory to the trace so that it can be accessed later. + [pyro.deterministic(name, value) for name, value in self.trajectory.items()] + def _pyro_simulate_point(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"] diff --git a/docs/source/dynamical_intro.ipynb b/docs/source/dynamical_intro.ipynb index f6201c560..4c5d77195 100644 --- a/docs/source/dynamical_intro.ipynb +++ b/docs/source/dynamical_intro.ipynb @@ -7,6 +7,52 @@ "# Causal reasoning in dynamical systems" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Outline\n", + "\n", + "- [Setup](#setup)\n", + "\n", + "- [Overview: Causal Inference in Continuous Time Dynamical Systems](#overview:-causal-inference-in-continuous-time-dynamical-systems)\n", + " - [Task: Modeling Causal Interventions in Continuous Time Systems](#task:-modeling-causal-interventions-in-continuous-time-systems)\n", + " - [Challenge: Representational Complexities of ODEs in Causal Inference](#challenge:-representational-complexities-of-odes-in-causal-inference)\n", + " - [Assumptions: Deterministic Dynamics and No Latent Confounders](#assumptions:-deterministic-dynamics-and-no-latent-confounders)\n", + " - [Intuition: Understanding Interventions in Dynamical Systems](#intuition:-understanding-interventions-in-dynamical-systems)\n", + "\n", + "- [Example: Assessing Intervention Strategies in an Epidemic Model](#example:-assessing-intervention-strategies-in-an-epidemic-model)\n", + " - [Variables](#variables)\n", + " - [Motivation](#motivation)\n", + " - [Source](#source)\n", + "\n", + "- [Causal Probabilistic Program](#causal-probabilistic-program)\n", + " - [Model Description](#model-description)\n", + " - [Observation Model](#observation-model)\n", + " - [Generating Synthetic Disease Data using `simulate`](#generating-synthetic-disease-data-using-simulate)\n", + " - [Informal Prior Predictive Check: Visualizing Samples](#informal-prior-predictive-check---visualizing-samples)\n", + "\n", + "- [Probabilistic Inference over Dynamical System Parameters](#probabilistic-inference-over-dynamical-system-parameters)\n", + " - [Informal Posterior Predictive Check: Visualizing Samples](#informal-posterior-predictive-check---visualizing-samples)\n", + "\n", + "- [Exploring Interventions](#exploring-interventions)\n", + " - [Modeling a Deterministic Intervention](#modeling-a-deterministic-intervention)\n", + " - [Modeling an Uncertain Intervention](#modeling-an-uncertain-intervention)\n", + " - [Modeling a State-Dependent Intervention](#modeling-a-state-dependent-intervention)\n", + " - [Modeling a State-Dependent Intervention with Uncertainty](#modeling-a-state-dependent-intervention-with-uncertainty)\n", + "\n", + "- [References](#references)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Setup\n", + "\n", + "Here, we install the necessary Pytorch, Pyro, and ChiRho dependencies for this example." + ] + }, { "cell_type": "code", "execution_count": 1, @@ -21,32 +67,28 @@ "%reload_ext autoreload\n", "%autoreload 2\n", "\n", + "import warnings\n", + "\n", + "warnings.filterwarnings('ignore')\n", + "\n", + "import os\n", + "import matplotlib.pyplot as plt\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", + "import torch\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", - "from chirho.observational.handlers import condition\n", + "from pyro.infer.autoguide import AutoMultivariateNormal\n", "\n", "from chirho.dynamical.handlers import (\n", - " StaticObservation,\n", - " StaticIntervention,\n", - " LogTrajectory,\n", " DynamicIntervention,\n", + " LogTrajectory,\n", " StaticBatchObservation,\n", + " StaticIntervention,\n", ")\n", - "from chirho.dynamical.ops import State, simulate, Dynamics\n", - "\n", "from chirho.dynamical.handlers.solver import TorchDiffEq\n", - "\n", - "from chirho.observational.handlers.soft_conditioning import (\n", - " AutoSoftConditioning\n", - ")\n", + "from chirho.dynamical.ops import Dynamics, State, simulate\n", + "from chirho.observational.handlers import condition\n", "\n", "pyro.settings.set(module_local_params=True)\n", "\n", @@ -55,14 +97,79 @@ "# Set seed for reproducibility\n", "seed = 123\n", "pyro.clear_param_store()\n", - "pyro.set_rng_seed(seed)" + "pyro.set_rng_seed(seed)\n", + "\n", + "smoke_test = ('CI' in os.environ)\n", + "num_steps = 10 if smoke_test else 1000\n", + "num_samples = 10 if smoke_test else 200" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Overview: Causal Inference in Continuous Time Dynamical Systems\n", + "\n", + "### **Task:** Modeling Causal Interventions in Continuous Time Systems\n", + "This tutorial focuses on estimating the effects of interventions in systems described by continuous time dynamics. We use ChiRho to model scenarios where interventions occur at specific moments in time, impacting the trajectory of a system governed by ordinary differential equations (ODEs). This approach is particularly relevant for complex systems in physics, biology, and engineering where time-continuous processes are fundamental representations of cause-effect mechanistic knowledge.\n", + "\n", + "### **Challenge:** Representational Complexities of ODEs in Causal Inference\n", + "ODEs inherently contain causal semantics, as they describe how changes in one variable lead to changes in others over continuous time. However, they do not map directly onto causal graphical models, which do not provide a direct semantics of time. This means that the algorithms that commonly operate on causal graph data structures, such as the do-calculus, do not apply. Rather than abandon these models as out-of-scope for existing data structures, we instead extend the intervention semantics in ChiRho for this broad model family.\n", + "\n", + "### **Assumptions:** Deterministic Dynamics and No Latent Confounders\n", + "In this tutorial, we make several key assumptions. First, we assume that all dynamics in the system are deterministic, meaning that the system's behavior can be precisely described by its current state and the governing equations without random variability. Secondly, we assume that the dynamical system model accurately captures the real-world processes it is intended to represent. This includes the correct formulation of the ODEs and a comprehensive representation of all relevant variables and their interactions. Lastly, we assume that there are no confounders between the model parameters. This means that the parameters are not influenced by unobserved variables that could bias our causal estimates. In subsequent tutorials we'll relax these assumptions.\n", + "\n", + "### **Intuition:** Understanding Interventions in Dynamical Systems\n", + "\n", + "ChiRho tackles these representational challenges by providing a generic semantics of interventions in continuous time dynamical systems by interrupting and modifying the behavior of simulation runs. Using this semantics of intervention with continuous-time systems allows ChiRho to provide automated support for common interventional and counterfactual questions described throughout the causal inference literature in these settings. In other words, once we provide an intervention semantics for continuous-time dynamical systems in ChiRho, we get all of ChiRho's causal reasoning functionality for these problems \"for free\". In addition, as we'll see in subsequent tutorials, providing an intervention semantics for continuous time dynamical systems makes it almost trivial to define hybrid models that combine continuous time component (e.g. disease dynamics) with atemporal components (hierarchical regression).\n", + "\n", + "The key intuition behind this approach is that interventions in continuous time systems can be represented as alterations to the parameters or state variables in the ODEs at some moment in time. In other words, intervening on an ODE at time $t$ involves (i) simulating up until $t$, (ii) modifying the terminal state from the initial simulation $X(t) = do(X(t), X')$, and (iii) simulating forward from the (intervened) $X(t)$ until the end of the full simulation. By simulating how these changes propagate through the system over time, we can estimate the causal effect of interventions." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Example: Assessing Intervention Strategies in an Epidemic Model\n", + "\n", + "### Variables\n", + "\n", + "In this example, we will explore the SIR (Susceptible, Infected, Recovered) compartmental model, a fundamental model in epidemiology. Here, the variables of interest are:\n", + "- $S(t)$: the number of susceptible individuals at time $t$,\n", + "- $I(t)$: the number of infected individuals at time $t$, and\n", + "- $R(t)$: the number of recovered individuals at time $t$.\n", + "\n", + "These compartments interact through a set of ordinary differential equations that describe the rate at which individuals move from being susceptible to infected, and from infected to recovered.\n", + "\n", + "### Motivation\n", + "\n", + "Understanding the impact of different public health interventions on the spread of an infectious disease is crucial for policymakers and health officials. For example, policymakers may wish to predict the impacts of mask mandates, social distancing campaigns, or vaccination efforts. By simulating these interventions in the model, we can estimate their impact on the epidemic trajectory, such as changes in the peak infection rate or the total number of infections over time. In this example we'll see how to model such interventions using ChiRho.\n", + "\n", + "### Source\n", + "\n", + "For our example, we will use simulated data that follows the dynamics of the SIR model." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Define our SIR model" + "## Causal Probabilistic Program\n", + "\n", + "In this section, we encode our causal assumptions about disease dynamics using an ordinary differential equation embedded in Pyro. To do this we'll first implement a `PyroModule` that describes the differential expressions declaratively, and then use a `ChiRho.dynamics.handlers.Solver` such as `TorchDiffEq` to solve the differential equation. Later in this example we'll extend the model with uncertainty.\n", + "\n", + "### Model Description\n", + "\n", + "The `SIRDynamics` class encapsulates the dynamics of the SIR model. The model is defined by two key parameters: `beta` and `gamma`. These parameters govern the rate of infection and recovery, respectively. The `diff` method in the class defines the differential equations for the Susceptible (`S`), Infected (`I`), and Recovered (`R`) compartments. Specifically:\n", + "- The rate of change of `S` is given by `-self.beta * X[\"S\"] * X[\"I\"]`, representing the transition of susceptible individuals to the infected state.\n", + "- The rate of change of `I` is `self.beta * X[\"S\"] * X[\"I\"] - self.gamma * X[\"I\"]`, capturing both new infections and recoveries.\n", + "- The rate of change of `R` is `self.gamma * X[\"I\"]`, representing the transition from infected to recovered.\n", + "\n", + "These equations encapsulate the causal relationships within the SIR model, where the number of susceptible and infected individuals causally influences the dynamics of the disease spread.\n", + "\n", + "### Observation Model\n", + "\n", + "The `sir_observation_model` models how noisy data is generated from (latent) disease dynamics. In this model, we only observe the number of infected (`I_obs`) and recovered (`R_obs`) individuals. These observations are modeled as Poisson-distributed, capturing the inherent variability and uncertainty in real-world observations of infectious diseases.\n" ] }, { @@ -76,50 +183,38 @@ }, "outputs": [], "source": [ - "class SimpleSIRDynamics(pyro.nn.PyroModule):\n", - " def __init__(self, beta, gamma, name=None):\n", + "class SIRDynamics(pyro.nn.PyroModule):\n", + " def __init__(self, beta, gamma):\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", - " @pyro.nn.pyro_method\n", - " def diff(self, dX: State[torch.Tensor], X: State[torch.Tensor]) -> None:\n", + " def forward(self, X: State[torch.Tensor]):\n", + " dX = State()\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", - " @pyro.nn.pyro_method\n", - " def observation(self, X: State[torch.Tensor]) -> None:\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", - " # }\n", - "\n", - " def forward(self, X: State[torch.Tensor]):\n", - " dX = State()\n", - " self.diff(dX, X)\n", - " return dX" + " return dX\n", + " \n", + "def sir_observation_model(X: State[torch.Tensor]) -> None:\n", + " # We don't observe the number of susceptible individuals directly.\n", + " event_dim = 1 if X[\"I\"].shape and X[\"I\"].shape[-1] > 1 else 0\n", + " pyro.sample(\"I_obs\", dist.Poisson(X[\"I\"]).to_event(event_dim)) # noisy number of infected actually observed\n", + " pyro.sample(\"R_obs\", dist.Poisson(X[\"R\"]).to_event(event_dim)) # noisy number of recovered actually observed\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Generate synthetic data from the SIR model" + "### Generating Synthetic Disease Data using `simulate`\n", + "\n", + "Using our `SIRDynamics` model, we can generate synthetic data both for the (latent) true dynamics, as well as the noisy observations. In this scenario\n", + "we'll assume that the epidemic began at $t=0$, we gather measurements from $t=0.5$ to $t=1$ months, and that we are interesting in forecasting disease dynamics until $t=3$ months.\n", + "\n", + "For this scenario we'll assume that the true infection rate is $\\beta=0.03$ and the true recovery rate is $\\gamma=0.5$.\n", + "\n", + "**Note:** Here we use a new effectful operation introduced in the `chirho.dynamical` module, `simulate`, which solves the differential equation passed as the `dynamics` argument. Similar to `pyro.sample`, `simulate`'s behavior can be modified using several effect handlers. In the following code snippet we show a `Solver` handler, `TorchDiffEq`, which wraps the torchdiffeq.py (https://github.com/rtqichen/torchdiffeq) package for solving ODEs for use with `chirho`. In addition, we use the `LogTrajectory` handler to store the results of the simulation at multiple points in time, rather than the default behavior of just returning the terminal state." ] }, { @@ -137,23 +232,32 @@ "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", + "step_size = torch.tensor(0.1)\n", + "logging_times = torch.arange(start_time, end_time, step_size)\n", "\n", "# We now simulate from the SIR model\n", - "beta_true = torch.tensor(0.05)\n", + "beta_true = torch.tensor(0.03)\n", "gamma_true = torch.tensor(0.5)\n", - "sir_true = SimpleSIRDynamics(beta_true, gamma_true)\n", + "sir_true = SIRDynamics(beta_true, gamma_true)\n", "with TorchDiffEq(), LogTrajectory(logging_times) as lt:\n", " simulate(sir_true, init_state, start_time, end_time)\n", "\n", - "sir_true_traj = lt.trajectory" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simulate the latent trajectories of the ODE model" + "sir_true_traj = lt.trajectory\n", + "\n", + "obs_start_time = torch.tensor(0.5) # Measurements start 0.5 month into the pandemic\n", + "obs_sample_rate = torch.tensor(1/30) # Take measurements one per day\n", + "obs_end_time = torch.tensor(1.0) # Measurements end after 1st month\n", + "\n", + "obs_logging_times = torch.arange(obs_start_time, obs_end_time, obs_sample_rate)\n", + "N_obs = obs_logging_times.shape[0]\n", + "with TorchDiffEq(), LogTrajectory(obs_logging_times) as lt_obs:\n", + " simulate(sir_true, init_state, start_time, obs_end_time)\n", + "\n", + "sir_obs_traj = lt_obs.trajectory\n", + "with pyro.poutine.trace() as tr:\n", + " sir_observation_model(sir_obs_traj)\n", + "\n", + "sir_data = State(**{k:tr.trace.nodes[k][\"value\"] for k in [\"I_obs\", \"R_obs\"]})" ] }, { @@ -166,40 +270,10 @@ } }, "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": [ - "" + "" ] }, "execution_count": 4, @@ -208,7 +282,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -219,22 +293,27 @@ ], "source": [ "sns.lineplot(\n", - " x=logging_times, y=sir_true_traj[\"S\"], label=\"# Susceptable (S)\", color=\"orange\"\n", + " x=logging_times, y=sir_true_traj[\"S\"], label=\"Susceptable (S) - Ground Truth\", 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.lineplot(x=logging_times, y=sir_true_traj[\"I\"], label=\"Infected (I) - Ground Truth\", color=\"red\")\n", + "sns.scatterplot(x=obs_logging_times, y=sir_data[\"I_obs\"], label=\"Infected (I) - Measured\", color=\"red\")\n", + "sns.lineplot(x=logging_times, y=sir_true_traj[\"R\"], label=\"Recovered (R) - Ground Truth\", color=\"green\")\n", + "sns.scatterplot(x=obs_logging_times, y=sir_data[\"R_obs\"], label=\"Recovered (R) - Measured\", color=\"green\")\n", "sns.despine()\n", - "plt.xlabel(\"Time (Yrs)\")\n", + "\n", + "plt.xlim(start_time, end_time)\n", + "plt.xlabel(\"Time (Months)\")\n", "plt.ylabel(\"# of Individuals (Millions)\")\n", - "plt.legend()" + "plt.legend(loc=\"upper right\")\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Add noise to state trajectories to generate observations\n", - " " + "### Extending the `SIRDynamics` model with uncertainty over parameters\n", + "\n", + "In our [tutorial](tutorial_i.ipynb) we extended our deterministic causal model to include uncertainty by adding prior distributions on model parameters. Even though our model here takes the form of a differential equation, it can still be extended to include uncertainty succinctly in exactly the same way. In the following code blocks we add uniform priors over $\\beta$ and $\\gamma$." ] }, { @@ -242,69 +321,127 @@ "execution_count": 5, "metadata": { "ExecuteTime": { - "end_time": "2023-07-18T18:46:29.646023Z", - "start_time": "2023-07-18T18:46:29.584398Z" + "end_time": "2023-07-18T18:46:30.010774Z", + "start_time": "2023-07-18T18:46:29.995553Z" } }, "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 TorchDiffEq(), LogTrajectory(obs_logging_times) as lt_obs:\n", - " simulate(sir_true, init_state, obs_start_time, obs_end_time)\n", + "# We place uniform priors on the beta and gamma parameters defining the SIR model\n", + "def bayesian_sir(base_model=SIRDynamics) -> Dynamics[torch.Tensor]:\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", - "sir_obs_traj = lt_obs.trajectory\n", - "with pyro.poutine.trace() as tr:\n", - " sir_true.observation(sir_obs_traj)\n", "\n", - "sir_data = State(**{k:tr.trace.nodes[k][\"value\"] for k in [\"test_kit_sales\", \"I_obs\", \"R_obs\"]})" + "def simulated_bayesian_sir(init_state, start_time, logging_times, base_model=SIRDynamics) -> State[torch.Tensor]:\n", + " sir = bayesian_sir(base_model)\n", + " with TorchDiffEq(), LogTrajectory(logging_times, is_traced=True) as lt:\n", + " simulate(sir, init_state, start_time, logging_times[-1])\n", + " return lt.trajectory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Informal Prior Predictive Check - Visualizing Samples\n", + "\n", + "To see how our uncertainty over parameters propagates to uncertainty over disease trajectories, we can visualize samples from the prior predictive distribution." ] }, { "cell_type": "code", "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "prior_predictive = Predictive(simulated_bayesian_sir, num_samples=num_samples)\n", + "sir_prior_samples = prior_predictive(init_state, start_time, logging_times)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": { "ExecuteTime": { - "end_time": "2023-07-18T18:46:29.996315Z", - "start_time": "2023-07-18T18:46:29.685112Z" + "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, mean_label=\"Posterior Mean\"):\n", + " sns.lineplot(\n", + " x=time_period,\n", + " y=state_pred.mean(dim=0),\n", + " color=color,\n", + " label=mean_label,\n", + " ax=ax,\n", + " )\n", + " # 95% Credible Interval\n", + " ax.fill_between(\n", + " time_period,\n", + " torch.quantile(state_pred, 0.025, dim=0),\n", + " torch.quantile(state_pred, 0.975, dim=0),\n", + " alpha=0.2,\n", + " color=color,\n", + " label=\"95% Credible Interval\",\n", + " )\n", + "\n", + " ax.set_xlabel(\"Time (Months)\")\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_start_time, test_end_time, ax):\n", + " ax.axvline(\n", + " test_start_time, color=\"black\", linestyle=\":\", label=\"Measurement Period\"\n", + " )\n", + " ax.axvline(\n", + " test_end_time, color=\"black\", linestyle=\":\"\n", + " )\n", + "\n", + "\n", + "def SIR_plot(\n", + " time_period,\n", + " state_pred,\n", + " data,\n", + " ylabel,\n", + " color,\n", + " data_label,\n", + " ax,\n", + " legend=False,\n", + " test_plot=True,\n", + " test_start_time=obs_start_time,\n", + " test_end_time=obs_end_time,\n", + " mean_label=\"Posterior Mean\",\n", + "):\n", + " SIR_uncertainty_plot(time_period, state_pred, ylabel, color, ax, mean_label=mean_label)\n", + " SIR_data_plot(time_period, data, data_label, ax)\n", + " if test_plot:\n", + " SIR_test_plot(test_start_time, test_end_time, ax)\n", + " if legend:\n", + " ax.legend()\n", + " else:\n", + " ax.legend().remove()\n", + " sns.despine()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, "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": 6, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -314,81 +451,67 @@ } ], "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=sir_data[\"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", + "fig, ax = plt.subplots(1, 3, figsize=(15, 5))\n", + "SIR_plot(\n", + " logging_times,\n", + " sir_prior_samples[\"S\"],\n", + " sir_true_traj[\"S\"],\n", + " \"# Susceptible (Millions)\",\n", + " \"orange\",\n", + " \"Ground Truth\",\n", + " ax[0],\n", + " legend=True,\n", + " test_plot=False,\n", + " mean_label=\"Prior Mean\",\n", + ")\n", "\n", - "# Plot observed infected\n", - "sns.scatterplot(x=obs_logging_times, y=sir_data[\"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", + "SIR_plot(\n", + " logging_times,\n", + " sir_prior_samples[\"I\"],\n", + " sir_true_traj[\"I\"],\n", + " \"# Infected (Millions)\",\n", + " \"red\",\n", + " \"Ground Truth\",\n", + " ax[1],\n", + " legend=True,\n", + " test_plot=False,\n", + " mean_label=\"Prior Mean\",\n", + ")\n", "\n", - "# Plot observed recovered\n", - "sns.scatterplot(x=obs_logging_times, y=sir_data[\"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)\")" + "SIR_plot(\n", + " logging_times,\n", + " sir_prior_samples[\"R\"],\n", + " sir_true_traj[\"R\"],\n", + " \"# Recovered (Millions)\",\n", + " \"green\",\n", + " \"Ground Truth\",\n", + " ax[2],\n", + " legend=True,\n", + " test_plot=False,\n", + " mean_label=\"Prior Mean\",\n", + ")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Extend our model to include uncertainty over model parameters" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "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) -> Dynamics[torch.Tensor]:\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) -> State[torch.Tensor]:\n", - " sir = bayesian_sir(base_model)\n", - " with TorchDiffEq(), LogTrajectory(logging_times) as lt:\n", - " simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3)\n", - " trajectory = lt.trajectory\n", - " # This is a small trick to make the solution variables available to pyro\n", - " [pyro.deterministic(k, trajectory[k]) for k in trajectory.keys()]\n", - " return trajectory\n", - "\n", - "\n", - "def conditioned_sir(obs_times, data, init_state, start_time, end_time, base_model=SimpleSIRDynamics) -> None:\n", - " sir = bayesian_sir(base_model)\n", - " obs = condition(data=data)(sir.observation)\n", - " with TorchDiffEq(), StaticBatchObservation(obs_times, observation=obs):\n", - " simulate(sir, init_state, start_time, end_time)" + "Here, we can see that without any data our prior has induced extremely broad uncertainty over resulting disease dynamics." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Perform Inference!" + "## Probabilistic Inference over Dynamical System Parameters\n", + "\n", + "One of the major benefits of writing our dynamical systems model in Pyro and ChiRho is that we can leverage Pyro's support for (partially) automated probabilistic inference. In this section we'll (i) condition on observational data using the `StaticBatchObservation` effect handler and (ii) optimize a variational approximation to the posterior using Pyro's SVI utilities." ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "ExecuteTime": { "end_time": "2023-07-18T18:46:30.070437Z", @@ -397,8 +520,14 @@ }, "outputs": [], "source": [ + "def conditioned_sir(obs_times, data, init_state, start_time, base_model=SIRDynamics) -> None:\n", + " sir = bayesian_sir(base_model)\n", + " obs = condition(data=data)(sir_observation_model)\n", + " with TorchDiffEq(), StaticBatchObservation(obs_times, observation=obs):\n", + " simulate(sir, init_state, start_time, obs_times[-1])\n", + "\n", "# 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", + "def run_svi_inference(model, num_steps=num_steps, 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", @@ -406,7 +535,7 @@ " 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", + " for step in range(1, num_steps + 1):\n", " adam.zero_grad()\n", " loss = elbo(**model_kwargs)\n", " loss.backward()\n", @@ -418,7 +547,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "ExecuteTime": { "end_time": "2023-07-18T18:46:59.292526Z", @@ -430,9 +559,17 @@ "name": "stdout", "output_type": "stream", "text": [ - "[iteration 0001] loss: 3508.8616\n", - "[iteration 0100] loss: 356.7882\n", - "[iteration 0200] loss: 268.6550\n" + "[iteration 0001] loss: 1200.2018\n", + "[iteration 0100] loss: 1005.9126\n", + "[iteration 0200] loss: 92.1272\n", + "[iteration 0300] loss: 57.2114\n", + "[iteration 0400] loss: 56.9112\n", + "[iteration 0500] loss: 65.3042\n", + "[iteration 0600] loss: 65.4536\n", + "[iteration 0700] loss: 60.4688\n", + "[iteration 0800] loss: 59.6470\n", + "[iteration 0900] loss: 57.3681\n", + "[iteration 1000] loss: 57.6638\n" ] } ], @@ -440,12 +577,11 @@ "# 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", + " num_steps=num_steps,\n", " obs_times=obs_logging_times,\n", " data=sir_data,\n", " init_state=init_state,\n", - " start_time=obs_start_time,\n", - " end_time=obs_end_time,\n", + " start_time=start_time,\n", ")" ] }, @@ -453,12 +589,14 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Evaluate the performance of our inference" + "### Informal Posterior Predictive Check - Visualizing Samples\n", + "\n", + "Now that we've approximated the posterior distribution over parameters, let's see how the posterior samples compare to the ground truth parameters and disease trajectories." ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "ExecuteTime": { "end_time": "2023-07-18T18:47:01.693275Z", @@ -468,20 +606,13 @@ "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" + "sir_predictive = Predictive(simulated_bayesian_sir, guide=sir_guide, num_samples=num_samples)\n", + "sir_posterior_samples = sir_predictive(init_state, start_time, logging_times)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "ExecuteTime": { "end_time": "2023-07-18T18:47:02.042675Z", @@ -489,33 +620,19 @@ } }, "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": [ - "" + "Text(0.5, 0, 'Gamma')" ] }, - "execution_count": 11, + "execution_count": 12, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -527,91 +644,18 @@ "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.kdeplot(sir_posterior_samples[\"beta\"], label=\"Approximate Posterior\", ax=ax[0])\n", + "ax[0].axvline(beta_true, color=\"black\", label=\"Ground Truth\", linestyle=\"--\")\n", "sns.despine()\n", "ax[0].set_yticks([])\n", "ax[0].legend(loc=\"upper right\")\n", + "ax[0].set_xlabel(\"Beta\")\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.kdeplot(sir_posterior_samples[\"gamma\"], ax=ax[1])\n", + "plt.axvline(gamma_true, color=\"black\", 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": 12, - "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()" + "ax[1].set_xlabel(\"Gamma\")" ] }, { @@ -624,63 +668,9 @@ } }, "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -690,40 +680,37 @@ } ], "source": [ - "# Plot predicted values for S, I, and R with 90% credible intervals\n", + "# Plot predicted values for S, I, and R with 95% 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", + " \"# Susceptible (Millions)\",\n", " \"orange\",\n", - " \"Actual # Susceptible\",\n", + " \"Ground Truth\",\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", + " \"# Infected (Millions)\",\n", " \"red\",\n", - " \"Actual # Infected\",\n", + " \"Ground Truth\",\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", + " \"# Recovered (Millions)\",\n", " \"green\",\n", - " \"Actual # Recovered\",\n", + " \"Ground Truth\",\n", " ax[2],\n", " legend=True,\n", ")" @@ -733,32 +720,32 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Let's explore how different interventions might flatten the infection curve" + "## Exploring Interventions" ] }, { "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", + "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", + "\\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", + "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", + " dS/dt &= -\\beta(t) S I \\\\\n", + " dI/dt &= \\beta(t) S I - \\gamma I \\\\\n", + " dR/dt &= \\gamma I\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", + "where $S, I, R$ 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." + "We can implement this new model compositionally using our existing SIR model implementation." ] }, { @@ -772,32 +759,30 @@ }, "outputs": [], "source": [ - "class SimpleSIRDynamicsLockdown(SimpleSIRDynamics):\n", + "class SIRDynamicsLockdown(SIRDynamics):\n", " def __init__(self, beta0, gamma):\n", " super().__init__(beta0, gamma)\n", " self.beta0 = beta0\n", "\n", - " @pyro.nn.pyro_method\n", - " def diff(self, dX: State[torch.Tensor], X: State[torch.Tensor]):\n", + " def forward(self, X: State[torch.Tensor]):\n", " self.beta = (1 - X[\"l\"]) * self.beta0 # time-varing beta parametrized by lockdown strength l_t\n", + " dX = super().forward(X)\n", " dX[\"l\"] = torch.tensor(0.0)\n", - " # Call the base SIR class diff method\n", - " super().diff(dX, X)\n", + " return dX\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", - ")" + "init_state_lockdown = State(**init_state, l=torch.tensor(0.0))" ] }, { "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." + "### Modeling a Deterministic Intervention\n", + "\n", + "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. \n", + "\n", + "To implement this succinctly we'll use ChiRho's `StaticIntervention` handlers, which interrupt the enclosing `simulate` call to change the value of the `State` at a particular moment in time. These handlers compose freely with each other, and with the `LogTrajectory` and `TorchDiffEq` introduces earlier." ] }, { @@ -811,18 +796,22 @@ }, "outputs": [], "source": [ - "def intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, logging_times) -> State[torch.Tensor]:\n", - " sir = bayesian_sir(SimpleSIRDynamicsLockdown)\n", - " with LogTrajectory(logging_times) as lt:\n", + "def intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, start_time, logging_times) -> State[torch.Tensor]:\n", + " sir = bayesian_sir(SIRDynamicsLockdown)\n", + " with LogTrajectory(logging_times, is_traced=True) as lt:\n", " with TorchDiffEq():\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)\n", + " with StaticIntervention(time=lockdown_start, intervention=State(l=lockdown_strength)):\n", + " with StaticIntervention(time=lockdown_end, intervention=State(l=torch.tensor(0.0))):\n", + " simulate(sir, init_state, start_time, logging_times[-1])\n", " \n", - " trajectory = lt.trajectory\n", - " # This is a small trick to make the solution variables available to pyro\n", - " [pyro.deterministic(k, trajectory[k]) for k in trajectory.keys()]\n", - " return trajectory" + " return lt.trajectory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We see in the figure below that this lockdown measures indeed \"flattens\" the curve." ] }, { @@ -836,15 +825,15 @@ }, "outputs": [], "source": [ - "lockdown_start = 1.01\n", - "lockdown_end = 2.0\n", - "lockdown_strength = 0.75\n", + "lockdown_start = torch.tensor(1.0)\n", + "lockdown_end = torch.tensor(2.0)\n", + "lockdown_strength = torch.tensor(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", + "true_intervened_trajectory = true_intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state_lockdown, start_time, 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)" + "intervened_sir_predictive = Predictive(intervened_sir, guide=sir_guide, num_samples=num_samples)\n", + "intervened_sir_posterior_samples = intervened_sir_predictive(lockdown_start, lockdown_end, lockdown_strength, init_state_lockdown, start_time, logging_times)" ] }, { @@ -857,63 +846,9 @@ } }, "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -923,42 +858,39 @@ } ], "source": [ - "# Plot predicted values for S, I, and R with 90% credible intervals\n", + "# Plot predicted values for S, I, and R with 95% 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", + " \"# Susceptible (Millions)\",\n", " \"orange\",\n", - " \"Actual # Susceptible\",\n", + " \"Ground Truth\",\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", + " \"# Infected (Millions)\",\n", " \"red\",\n", - " \"Actual # Infected\",\n", + " \"Ground Truth\",\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", + " \"# Recovered (Millions)\",\n", " \"green\",\n", - " \"Actual # Recovered\",\n", + " \"Ground Truth\",\n", " ax[2],\n", " legend=True,\n", " test_plot=False,\n", @@ -967,14 +899,17 @@ "# 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\")" + " a.axvline(lockdown_end, color=\"grey\", linestyle=\"-\", label=\"End of Lockdown\")\n", + " a.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## What if we're uncertain about when the lockdown will happen?" + "### Modeling an Uncertain Intervention\n", + "\n", + "In the previous example we assumed that the time the intervention was applied was entirely determined by the policymakers. However, in practice, how an intervention is implemented may depend on many external factors that out of the policymaker's control. Instead, we'd like to represent additional uncertainty over when the intervention is applied. It turns out that implementing this extension is remarkably straightforward using ChiRho, we simply call the `intervened_sir` model with `lockdown_start` and `lockdown_end` drawn from some distribution as follows:" ] }, { @@ -988,10 +923,16 @@ }, "outputs": [], "source": [ - "def uncertain_intervened_sir(lockdown_strength, init_state, logging_times) -> State:\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)" + "lockdown_start_min = torch.tensor(0.5)\n", + "lockdown_start_max = torch.tensor(1.5)\n", + "\n", + "lockdown_end_min = torch.tensor(2.0)\n", + "lockdown_end_max = torch.tensor(2.5)\n", + "\n", + "def uncertain_intervened_sir(lockdown_strength, init_state, start_time, logging_times) -> State:\n", + " lockdown_start = pyro.sample(\"lockdown_start\", dist.Uniform(lockdown_start_min, lockdown_start_max))\n", + " lockdown_end = pyro.sample(\"lockdown_end\", dist.Uniform(lockdown_start_min, lockdown_start_max))\n", + " return intervened_sir(lockdown_start, lockdown_end, lockdown_strength, init_state, start_time, logging_times)" ] }, { @@ -1005,8 +946,8 @@ }, "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)" + "uncertain_intervened_sir_predictive = Predictive(uncertain_intervened_sir, guide=sir_guide, num_samples=num_samples)\n", + "uncertain_intervened_sir_posterior_samples = uncertain_intervened_sir_predictive(lockdown_strength, init_state_lockdown, start_time, logging_times)" ] }, { @@ -1019,63 +960,9 @@ } }, "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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", + "image/png": "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", "text/plain": [ "
" ] @@ -1085,42 +972,39 @@ } ], "source": [ - "# Plot predicted values for S, I, and R with 90% credible intervals\n", + "# Plot predicted values for S, I, and R with 95% 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", + " \"# Susceptible (Millions)\",\n", " \"orange\",\n", - " \"Actual # Susceptible\",\n", + " \"Ground Truth\",\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", + " \"# Infected (Millions)\",\n", " \"red\",\n", - " \"Actual # Infected\",\n", + " \"Ground Truth\",\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", + " \"# Recovered (Millions)\",\n", " \"green\",\n", - " \"Actual # Recovered\",\n", + " \"Ground Truth\",\n", " ax[2],\n", " legend=True,\n", " test_plot=False,\n", @@ -1128,22 +1012,24 @@ "\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\")" + " a.axvspan(lockdown_start_min, lockdown_start_max, color=\"grey\", linestyle=\"-\", label=\"Start of Lockdown\", alpha=0.15)\n", + " a.axvspan(lockdown_end_min, lockdown_end_max, color=\"grey\", linestyle=\"-\", label=\"End of Lockdown\", alpha=0.15)\n", + " a.legend()" ] }, { "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." + "### Modeling a State-Dependent Intervention\n", + "\n", + "In the previous example we assumed that the intervention was applied at some (uncertain) moment in time, but was independent of the disease dynamics themselves. However, more practical interventions may be expressed as policies that dynamically respond to the dynamical system's state.\n", + "\n", + "Using our running example, let's 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. Importantly, here we don't know a-priori when this event will happen, instead we need the intervention to be applied dynamically based on the results of the simulation as it is run.\n", + "\n", + "To implement this we'll use ChiRho's `DynamicIntervention` handler, which takes as input an `event_fn`, describing when to apply the intervention, and an `intervention`, describing what happens when the intervention is applied.\n", + "\n", + "**Note:** The `DynamicIntervention` is strictly more expressive than the `StaticIntervention` described before, as one can define an `event_fn` that only triggers when $t$ is above a specific value. However, this expressiveness comes with additional runtime costs, as the solver must now solve a root-finding problem during the simulation. Therefore, we recommend using the `StaticIntervention` when the intervention time is independent of the state, and a `DynamicIntervention` otherwise." ] }, { @@ -1171,18 +1057,14 @@ " return event_f\n", "\n", "\n", - "def dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, logging_times) -> State:\n", - " sir = bayesian_sir(SimpleSIRDynamicsLockdown)\n", - " with LogTrajectory(logging_times) as lt:\n", + "def dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, start_time, logging_times) -> State:\n", + " sir = bayesian_sir(SIRDynamicsLockdown)\n", + " with LogTrajectory(logging_times, is_traced=True) as lt:\n", " with TorchDiffEq():\n", - " with DynamicIntervention(event_fn=government_lockdown_policy(lockdown_trigger), intervention=State(l=torch.as_tensor(lockdown_strength))):\n", + " with DynamicIntervention(event_fn=government_lockdown_policy(lockdown_trigger), intervention=State(l=lockdown_strength)):\n", " with DynamicIntervention(event_fn=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)\n", - " trajectory = lt.trajectory\n", - " \n", - " # This is a small trick to make the solution variables available to pyro\n", - " [pyro.deterministic(k, trajectory[k]) for k in trajectory.keys()]\n", - " return trajectory" + " simulate(sir, init_state, logging_times[0], logging_times[-1])\n", + " return lt.trajectory" ] }, { @@ -1198,13 +1080,13 @@ "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", + "lockdown_strength = torch.tensor(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", + "true_dynamic_intervened_trajectory = true_dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state_lockdown, start_time, 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)" + "dynamic_intervened_sir_predictive = Predictive(dynamic_intervened_sir, guide=sir_guide, num_samples=num_samples)\n", + "dynamic_intervened_sir_posterior_samples = dynamic_intervened_sir_predictive(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state_lockdown, start_time, logging_times)" ] }, { @@ -1217,64 +1099,10 @@ } }, "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": [ - "" + "" ] }, "execution_count": 23, @@ -1283,7 +1111,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -1293,57 +1121,58 @@ } ], "source": [ - "# Plot predicted values for S, I, and R with 90% credible intervals\n", + "# Plot predicted values for S, I, and R with 95% 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", + " \"# Susceptible (Millions)\",\n", " \"orange\",\n", - " \"Actual # Susceptible\",\n", + " \"Ground Truth\",\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", + " \"# Infected (Millions)\",\n", " \"red\",\n", - " \"Actual # Infected\",\n", + " \"Ground Truth\",\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", + " \"# Recovered (Millions)\",\n", " \"green\",\n", - " \"Actual # Recovered\",\n", + " \"Ground Truth\",\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=\"-\")" + "ax[1].axhline(lockdown_trigger[\"I\"], color=\"grey\", linestyle=\"-\", label=\"Lockdown Trigger\")\n", + "ax[1].legend()\n", + "ax[2].axhline(lockdown_lift_trigger[\"R\"], color=\"grey\", linestyle=\"-\", label=\"Lockdown Lift Trigger\")\n", + "ax[2].legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "## Again, we can represent uncertainty about the interventions themselves." + "### Modeling a State-Dependent Intervention with Uncertainty\n", + "\n", + "Perhaps not surprisingly, we can also extend our `dynamic_intervened_sir` model to include uncertainty about the `lockdown_trigger` and `lockdown_lift` conditions themselves. Just as before, this can be accomplished simply by calling the `dynamic_intervened_sir` model with arguments drawn from some distribution as follows:" ] }, { @@ -1357,10 +1186,16 @@ }, "outputs": [], "source": [ - "def uncertain_dynamic_intervened_sir(lockdown_strength, init_state, logging_times) -> State:\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)" + "lockdown_trigger_min = torch.tensor(20.0)\n", + "lockdown_trigger_max = torch.tensor(40.0)\n", + "lockdown_lift_trigger_min = torch.tensor(10.0)\n", + "lockdown_lift_trigger_max = torch.tensor(30.0)\n", + "\n", + "\n", + "def uncertain_dynamic_intervened_sir(lockdown_strength, init_state, start_time, logging_times) -> State:\n", + " lockdown_trigger = State(I=pyro.sample(\"lockdown_trigger\", dist.Uniform(lockdown_trigger_min, lockdown_trigger_max)))\n", + " lockdown_lift_trigger = State(R=pyro.sample(\"lockdown_lift_trigger\", dist.Uniform(lockdown_lift_trigger_min, lockdown_lift_trigger_max)))\n", + " return dynamic_intervened_sir(lockdown_trigger, lockdown_lift_trigger, lockdown_strength, init_state, start_time, logging_times)" ] }, { @@ -1374,8 +1209,8 @@ }, "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))" + "uncertain_dynamic_intervened_sir_predictive = Predictive(uncertain_dynamic_intervened_sir, guide=sir_guide, num_samples=num_samples)\n", + "uncertain_dynamic_intervened_sir_posterior_samples = (uncertain_dynamic_intervened_sir_predictive(lockdown_strength, init_state_lockdown, start_time, logging_times))" ] }, { @@ -1388,64 +1223,10 @@ } }, "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": [ - "" + "" ] }, "execution_count": 26, @@ -1454,7 +1235,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAABNcAAAHACAYAAACBAI6gAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1yV5fvA8c+ZrIOgiAMH4siNA8UsNWeOllnO0q+aaebIzMzcI7XUyp2rMkemlpqVZY7yl2UOXLkVERQcILLHmb8/HkUQVPZhXO/X67yE86zrIHDzXOe670tls9lsCCGEEEIIIYQQQgghskxt7wCEEEIIIYQQQgghhCisJLkmhBBCCCGEEEIIIUQ2SXJNCCGEEEIIIYQQQohskuSaEEIIIYQQQgghhBDZJMk1IYQQQgghhBBCCCGySZJrQgghhBBCCCGEEEJkkyTXhBBCCCGEEEIIIYTIJkmuCSGEEEIIIYQQQgiRTcU2uWaz2YiLi8Nms9k7FCGEEEWQjDNCCCHykowzQghRcBTb5Fp8fDx+fn7Ex8fbOxQhhBBFkIwzQggh8pKMM0IIUXAU2+SaEEIIIYQQQgghhBA5Jck1IYQQQgghhBBCCCGySZJrQgghhBBCCCGEEEJkkyTXhBBCCCGEEEIIIYTIJkmuCSGEEEIIIYQQQgiRTVp7ByBEUWWz2TCbzVgsFnuHIkSu0Ol0aDQae4chhEjFYrFgMpnsHYYQuUKj0aDValGpVPYORQhxl9zTiKIkL8cZSa4JkQeMRiPXr18nISHB3qEIkWtUKhUVK1bEYDDYOxQhBBAXF8e1a9ew2Wz2DkWIXOPs7Ez58uXR6/X2DkWIYk/uaURRlFfjTIFIrhmNRrp168akSZNo1qwZAFevXmXSpEkcP34cLy8vxo8fT4sWLVKO+eeff5g1axZXr16lQYMGzJw5k0qVKtnrJQiRwmq1EhQUhEajwcvLC71eL+/AikLPZrMRHh7OtWvXqFGjhlSwCWFnFouFa9eu4ezsjKenp4wzotCz2WwYjUbCw8MJCgqiRo0aqNWygo0Q9iL3NKKoyetxxu7JteTkZN577z0uXryY8pzNZmPYsGE88cQT/PDDD+zevZvhw4ezY8cOvLy8CAsLY9iwYYwYMYKWLVuyZMkS3n77bbZv3y4/8MLujEYjVquVSpUq4ezsbO9whMg1np6eXLlyBZPJJMk1IezMZDJhs9nw9PTEycnJ3uEIkSucnJzQ6XQEBwdjNBpxdHS0d0hCFFtyTyOKorwcZ+z6dtClS5fo0aMHISEhaZ7/999/uXr1KtOnT6datWoMGTKEhg0b8sMPPwCwefNm6tWrx8CBA6lRowazZ88mNDSUQ4cO2eNlCJEhebdVFDXy5oUQBY/8XIqiRv5+EqJgkZ9JUdTk1fe0XX9SDh06RLNmzdi4cWOa50+cOEGdOnXSZMj9/Pw4fvx4yvYmTZqkbHNycqJu3bop24UQQgghhBBCCCGEyA92nRbap0+fDJ8PDw+nTJkyaZ7z8PDgxo0bmdouhBBCCCGEEEIIIUR+KJA1nomJiek6N+j1eoxGY6a2CyGyp23bttSsWTPlUbduXTp16sTq1atz5fxnz57l6NGjOYpvy5YtuRLLli1bqFmzJv369ctwe48ePahZsybXrl3LlesJIYSQcSY1GWeEECL3yThzn4wz+cvuDQ0y4uDgQFRUVJrnUi825+DgkC6RZjQaKVGiRH6FKESRNX78eLp06QKA2Wzm33//ZcKECbi7u9O1a9ccnXvYsGEMHz6cxo0bZ+v477//PlcXVNXpdAQEBBATE5Pm98fNmzc5depUrl1HCCHEfTLOyDgjhBB5ScYZGWfsoUBWrpUtW5aIiIg0z0VERKRMBX3Ydk9Pz3yLUYiiytXVFU9PTzw9PSlfvjwvv/wyzZs35/fff7d3aJQqVSpXO7qUKVMGLy8v9u3bl+b5PXv24Ovrm2vXEUIIcZ+MMzLOCCFEXpJxRsYZeyiQybUGDRpw+vRpkpKSUp4LCAigQYMGKdsDAgJStiUmJnLmzJmU7Xnuv+n0buNJnw7eTBj0FKtmvs6ejbO5fGIXpsSY/IlBFD42G5jj8/dhs+VK6FqtFp1OB4DVamXVqlW0a9cOX19f+vbty/nz51P23bFjBx07dqR+/fp06dKF3bt3A9C3b19CQ0P58MMPGTduHAAXLlygb9+++Pr60rFjR9avX59ynkWLFvH222/z2muv4e/vz6FDh9KUUT8ujpo1a7JgwQKaNWvGW2+99dDX1q5dO/bu3ZvmuT179tC+ffs0z8XExPD+++/TuHFjWrRowYwZM9L8jtqzZw9du3alfv36NGnShNGjRxMfH5/yWt577z2mTJlC48aNad68OStXrsz8f4AQQmSGzQbx8fn7kHFGxhkhRLFis9mIN8bn28Mm44yMM4VEgZwW6u/vT/ny5fnwww95++23+eOPPzh58iSzZ88G4JVXXuHLL79kxYoVtGnThiVLllCxYkWaNWuWL/HZrnzLtr8jSDIBhAAHUrapVdC5kZ6fZ/qCiw8YfNh5PBkvn0Y80ag9Dm4V8iVGUcDYbLCrBUT8k7/X9Xwa2v8FKlW2DjeZTPzxxx/8/fffzJo1C4AlS5awYcMGZsyYQZUqVVi5ciWDBg1i586dJCYmMnbsWKZPn06zZs347bffGD16NP/3f//HokWLeOmllxg4cCDdunUjKSmJN998k5dffpkZM2Zw+fJlJk2ahIuLS0q59p49e5g6dSoNGzbEx8cnTWyPiuNeqfUff/zBhg0bsFqtD32N7dq1Y+jQoZhMJnQ6HbGxsRw7dowPPviAuXPnpuw3YcIETCYTGzZsIDk5mY8++ojp06cza9YsQkJCeOedd5g8eTJPPfUUV65cYcyYMWzatIkBAwYAsHPnTvr06cPWrVvZtWsXc+fOpX379ulelxBCZIvNBi1awD/5PM48/TT8JeOMjDOZZLVCUhI4OIBGY+9ohBBZZLPZaPF1C/65mn9jzdOVnuavAX+hknHmoa9Rxpm0ks3JqFQq9Br943fORQUyuabRaFi6dCkTJkygW7dueHt7s2TJEry8vACoWLEiixYtYtasWSxZsoRGjRqxZMmSbP/AZZWl7T7WfjqJoEtnuXL1OkHXIgm6HseVmyaSTOCgMULkEYg8gtUK3YZCQrKSeKtWTk2dKm7UqVGROnXq0KjpM9T17wjO3qCWPzKKtHz6/sypKVOmMGPGDACSkpJwdHTkf//7Hy+++CI2m41169YxevRo2rVrB8CMGTPo0KED27dvx9fXF5PJRLly5ahQoQIDBw6kZs2aODg44OTkhEajwdXVFVdXVzZv3oyHhwejRo0CoEqVKoSGhrJmzZqUwah06dL07t07XYyPi6NXr14A9OzZk6pVqz7y9TZu3BiNRsPhw4d56qmn+PPPP2natGmatRBCQkLYvXs3hw4dwtXVNeV6Xbt25cMPP8RqtTJx4kR69OgBKL+jnnrqKS5evJhyDnd3dz744AM0Gg2DBg1i5cqVnDp1qsANRkKIQkzGGRlnCvI4cy+xZjSCTifJNSEKKRUFf6yRcaaYjjOA1WYl2ZKc74k1KEDJtdTljwDe3t6sW7fuofs/88wzPPPMM3kdVoa0LmV5dcSKtE/abFhNCdwMOYXx9llwj4G4IKJvXqZB1T2cCU4gOsHGxetWLl6/w48H7gD/8ZLfRraNBtQOYKjKJ79oqVvfj6atXqRsrY6gzb3FDoUdqVRKBZklIX+vq3HO8s3WyJEjefbZZwGleYinpyeau38A3759m6ioqDRTsHU6HfXq1SMwMJCePXvSunVrBgwYgI+PD+3ataN79+44OTmlu87ly5c5d+4cjRo1SnnOYrGkXAugQoWMKz0fF8fjjk9No9HQpk0b9u7dy1NPPcXu3bvTlVAHBgZitVpp1apVmuetVivBwcHUq1cPvV7PF198wcWLF7l48SKXLl3ipZdeStm3YsWKaV6bi4sLZrP5sfEJIUSmqFRKBVlCPo8zzjLOPI6MMyiVlUlJkJxcaJLAQoj0VCoVfw34iwRT/o01zjrnLBfRyDhTDMeZu0wWE2aruXgn1wo9lQq13oXy1ZtB9fvTU0sC/3SyYDMncD34DGcCdnPmxAHOnLvI2cCbPFlbBap4sCYTeuUs45YB/AesprIHNH3Chaa+VfBv6o9fi+co4f0MOJQCVYFcLk88ikoFWhd7R/FYHh4eeHt7Z7jNwcEhw+ctFgtWqxWVSsXy5cs5efIke/bsYdeuXXz77bd8++231K5dO80xZrOZ5s2bM3ny5IfG8rDrPS6Ox+33oHbt2jF79mzGjh3L33//zZQpU0hIdYNqsVhwdXXlhx9+SHds2bJlOXfuHL1796Zt27Y0adKE/v37880336TZ794aD6nl1hoSQggBKOOMi4wz98g4U0DGmdSJNZ0OCtiNmBAia1QqFS76gj3WyDhTzMaZu6w2K0aL0W4xSYYmP6g1qPSueNVoRvteExg5+2eWbTnLvqOhjFt5EV44D613YKwxhn6dfKhdyRGVCkJuww8H4hm3/DRtB33NpHdehS1lYXs1THue59xPY7CFHwJjFFiM9n6VohhwdXWldOnSHD9+POU5k8nE6dOn8fHxITAwkE8++QRfX1/effddfvnlF8qXL89ff/2V7lw+Pj4EBQVRsWJFvL298fb25vjx46xduzbHcWTV008/TUREBGvWrKFWrVqUKlUqXayxsbGoVKqUWJOSkpgzZw5Go5Eff/yRpk2b8umnn9KnTx98fX0JDg4uUIONEEIUBjLOFLFxxmZTkmrJyaDVStWaEMLuZJwpYuNMKmaLGbPVjNpOhUhSuWYvKrVSxaR1AUqDwQef8p34pt1UMMUSczuUo//8yqED+zh8/ByHz9zCv6YWSID4Kxw6eoUW03+hQslPadfAkfZP1qBd+w541X8JDNWU6aQaZ9BkLtMtRGb179+fhQsXUqZMGby9vVm5ciXJycl06dIFi8XChg0bcHV15YUXXuDSpUuEhoZSp04dAJydnbl8+TJRUVG8+OKLLF68mMmTJzNw4ECuXbvGzJkzUxbMzEkcWeXs7MxTTz3F0qVLGTlyZLrt1apVo2XLlowZM4aJEyei0WiYNGkSbm5ulChRAnd3d86fP8/JkydxdXVl48aN/Pfff1SqVCnLsQghRHEn40wRGmeMRqVqTaMBtbynL4QoGGScKULjzF02m41kSzJqlRqr7eHNH/KSJNcKknvTBrUulKhYjtbdG9P65VFgjgVjNLbEm5AYAtFnuXTqdxx0Rwm9Y2PNn0ms+fM/+Pg/ant9RrsGLgzr2YhaDVpB6SeVZJveDbQG5SGNE0QODBw4kLi4OCZNmkRcXByNGjVi7dq1Ke+OLFq0iHnz5rFs2TI8PDwYPXo0LVq0AKB3797MmzePK1eusHjxYlauXMmsWbPo2rUr7u7uvPbaawwZMiRX4siqdu3a8ccff6Rbn+CeOXPm8NFHH9G/f3+0Wi0tW7Zk4sSJgNKW+8yZM/Tv3x8HBweaNm3KsGHD+OWXX7IVixBCFGcyzhSRccZohMREJakmiTUhRAEi40wRGWdSMVmVtdZ0Gh1Wi32SaypbYarzy0VxcXH4+fkREBCAwWCwdziZY7OCOR5MsWCMIvFOMH/v/4s9f+5j9z9nCTh/h3v/mwemwpM1lI8vxVQg2cWXus2egxK1wcED9KVAdy/Zln7utMi+pKQkgoKC8PHxwdHR0d7hCJFr5Hs7awrlOCMKDfl5FAWayXS/uYZWm36bi4uy/loG5Hs782ScEXlJfhZFYWGz2Yg3xSvJNbUOo8WIk84JR23G37d59b0tlWuFiUoNOlfl4eyFU4katC/vR/sXXmd20g0iw8P4c/8R9u0/SJPWlSHmOMReYO7mUFbsDaW216/0aOFK9+eepG6T9uBaS6mU07srCTetQTm3TCUVQgghhBDZYTYrFWuQPrEmhBBC5DKz1YzZYkarse+YIyNeYabWgWMZ5WGtQSn3O3Sr1JhuL78ApjigD9gsGDdOR687ydkwG9M2xTJt0y5qe+2i+9PO9HiuOXWbtAPXJ0CtBY2LUtXm6Am6EkqyTTqTCiGEEEKIx7FYlMSa1frQyjQhhBAit9hsNowWI6hAhX2b5khyrah4INGG8Q4kRUDSdb5ePJX5ccls332UzVt+Yuff5zgbZmP65gTW7dvDpc/2oNK7Q5lWULYNGKpDfDBo9EqCzbEM6EuCzk2q2oQQQgghRHoWizIV1GKRxJoQQoh8YbaaMVlNaFX2T23ZPwKR+1In2izVwRiJm/M1+nYz0Ldrc6KTtGz//SCbf9hKo8omVPqbYIrCFLydrqO280oLD3r36o1TlS5gSYToc8p5tc6g95CqNiGEEEIIcZ/VqlSsmc2g19s7mgJr8ODBlCpVio8//hiAM2fOMGXKFC5cuED16tWZNm0a9erVs3OUQghRONhsNkwWEwAqlX2r1gAkM1LUafTgVA5K+YHnU+BaAzcXPX1fbMT29Z8z7dO10GYnNF3KtiB/dhyHNxbfpkLHxYwZ8jyBe2ZCcjg4lVeSdknX4fZhCN8PEf9C3BUwxUDx7IshhBBCCFF8WSyQnAzx8UqjAkmsPdQvv/zCvn37Uj5PSEhg8ODBNGnShC1bttCoUSOGDBlCwr1GEEIIIR7JYrNgtBrRqDT2DgWQ5FrxoVIpUzvd60KZp8G9oZIsSwiD5Ago2ZA2fWbxyaQhVPFy4048fPqLlRr9/o8ur77JLwtfwnr1J6V6zeCtnMsUA3eOQvjfSsIt/qrSzVQIIYQQQhRNNtv9pgVxccpUUJtNEmuPEBUVxZw5c6hfv37Kczt27MDBwYGxY8dSrVo1JkyYgIuLC7/99psdIxVCiMLDaDFis9lQF5DZdAUjCpG/tC7gWhU8nwaPpkqn0KQISjvFMXb4a1w6/jvb131Kx5b1sNng1xPw/Iwb/LfrM/ijM5ycAjHnlemhLt6gdVWq2yKPwK39cPuYkrSzJNn7lQohhBBCiNxgtYLRqCTT4uKUijW1WkmqaQpG1UBB9cknn/DSSy9RvXr1lOdOnDiBn59fylQmlUpF48aNOX78uJ2iFEKIwsNitWCymNCqC85KZ5JcK87UOnCuAB7+ULo5uFQBcyya5Ou88OyT/LZtNRcObeHdId3p0qIqDepWB2syhP3C6jkDubilH9w+AlonZeqpcyXQOkLiNbh9SEm03fkPEm+C1WzvVyuEEEIIIbIq9dTPe9M/tVqlaYFabiUe58CBAxw5coS33347zfPh4eGUKVMmzXMeHh7cuHEjP8MTQohCyWgxYrVZC0zVGkhyTYDSlMCxNJRsAB5PglNFZapo4g1q+Hjx2awP+OXHTfD0Bmj2FbddnmXo11B7yBneHPwWV38ZAJFHlamnWgM4eylJO7UG4i8ra7NFHFA6kJoT7f1q7ctiBHNC/j0sxiyFd/v2bUaOHEmTJk3o0KEDW7ZsSbP9o48+ombNmmke69atAyAwMJAXX3yRpk2bsmjRojTHffLJJ6xevTpTMRw9epQhQ4bQrFkzmjZtyoABAzh27FiWXsfjbNmyhbZt2wJw8OBBatasCcC1a9eoWbMm165de+xxWZX6Oplx9uxZjh49mq1r5cTjvgZCiALuXmVRfj2MMs5kpNCPMxlN/bRalSo1nU75my+broWFUbNevWIxziQnJzNlyhQmT56Mo6Njmm2JiYnoH5hKq9frMWbxZ0oIezBajCSYEvLlYZT7mQwV+nEmByxWC0aLEY0646rpsNAwGtRtkO/jTMGpoRMFg0Mp0LtDUgWIDYSEUKUrqL6k8odUSV8Sqpah/TN3+Hn3YVb9CWv2/8fQ9oP5sF9DyvoPh5INlYSdroTysJrBFAW3A5RzOVdSKt10bjn646zQsRiVij5zXP5dU2tQKhM1j18HxWazMWzYMKxWK2vWrOHmzZt88MEHGAwGnn32WUAZcN577z1efvnllOMMBgMAn332GU2bNqVbt27069ePDh06UKtWLSIjI9mzZw/bt29/bAw7d+5kzJgxDBw4kNGjR6PVatm0aRP9+vVj9erV+Pn5ZfML8XCNGjVi//79uX7enBo2bBjDhw+ncePG9g5FCFFYGI1w6JCSDMkvBgP4+2dqvS0ZZwqWDMeZe0k1o1GpULPZlCo1rdwyZMfixYupV68eLVu2TLfNwcEhXSLNaDSmS8IJUdAYLUYOXTtEnCl/xhqDzoB/RX/0cj/zUIVqnMkFJqsJq82KXl2w1vqUkVKkp1IryS8HD0gMg9hLEB+iJN50rlSqUI6fNn7BP4dOMGH6fP488B8LfoOVfxxnVKdBjO3XGLcGbytJNgC1FhxKg94DzLEQcw7iAsGxHDhXVK5TgOZK5xmbWUmsqfWgccj761mSlevZzMDjf/GcOnWKY8eOsXv3bipVqkSdOnUYNGgQX375ZZrB6I033sDT0zPd8ZcvX6Z3797UrVuX6tWrc/nyZWrVqsWXX35Jnz59HvvHYlxcHJMnT2bo0KFppk58+OGHhIWFMXfuXL777rusfQ0yQa/XZ/h6hBCi0DGblcSaXg8O+TDOJCcr1zObM5Vck3GmALNa7yfVzHeX8tBqi9eboHngl19+ISIigkaNGgGkJNN27tzJ888/T0RERJr9IyIi0k0VFaKgMVvNxJni0Kv1OGjzdqxJNicTZ4rDbDVnKrkm40zRZ7VZH1m1Zk8yLVQ8nFqnNCwo/ZTSZdSSrHQEvduo4Cn/Buz96St2/bCEpg1qkJAMn+6A2NCjcHAQHB4Gd07eP59KpVSyuVRSquMSw4rnlFGNA2gc8+GRtcHu6tWrlCpVikqVKqU8V7NmTU6dOoXJZCIuLo6bN29SpUqVDI/38vLizJkzxMTEEBISgpeXF5GRkezatYtevXo99vp79+4lLi6Ofv36pdv2wQcf8NFHHwFKKXOvXr0YNmwYfn5+bN++HZvNxpIlS2jRogVNmjThrbfeIiwsLOX4mzdvMmjQIBo2bMjLL79MSEhIyraMypt/++03WrVqRePGjZk8efJDp2hcuHCBvn374uvrS8eOHVm/fv1jX+c9bdu2Zf369fTo0YP69evz0ksvcerUKQD69u1LaGgoH374IePGjXvstRYtWsTbb7/Na6+9hr+/P4sXL05X7r1x48aUPypu3rzJyJEjadq0KfXq1ePll18mICAg07ELIQo4BwdwdMz7RxYTeDLO3Fegxpn334f4eC6cPEnfwYPxbdWKjj16sH7z5pRzLVq2jLdHj+a1N97Av3VrFi9fTtvnnktzvY0//MCzL72kfD1u3WLk++/T9JlnqNesGS/36UNAMVyof+3atfz0009s27aNbdu20bZtW9q2bcu2bdto0KABx44dw2azAUrFzdGjR2nQoIGdoxYicxy0DjhqHfP0kdXknYwz9xWocSYX72c6PtsRi9XC7Vu3eX/0+zzz1DM0a9yMPj36cPzY8UzHnhckuSYeT+sEJWpC6SfBUAWSIyHxOljNqFQq2rduxsE937J1zTw+Hv8GFRt0BZUGbh9k+9KBJP8zXEnKpaZxVNZmcyqnrA12OwDC/1a6kOZTibFIq3Tp0sTGxpKYeD/JeePGDcxmM7GxsQQGBqJSqVi2bBmtWrXixRdfZOvWrSn7Dhs2jFWrVtGsWTNatWpFw4YN+frrrzP1Lg/AuXPnqFq1akpZdmoVK1ZM02Hr2LFjVK9enU2bNtGiRQvWrVvHTz/9xKeffsrGjRvx8PBg4MCBmEwmAN555x2sViubN2/mzTff5JtvvnlkLJs2beLzzz9n2bJl/N///R/Lly9Pt09SUhJvvvlmyoD4wQcfsHTpUrZt2/bY13rPokWLGDx4MNu3b8fV1TVlwF20aBHlypVj/PjxTJgwIVPX2rNnD88//zzffPMNr7zyCjdv3kwZ3AB+//13OnfuDMCYMWOwWCx89913bNu2jbJlyzJ16tRMxy2EENkh48x9dh9nPv+ccmXLMn70aCaMHElSYiJvjh6NX6NGbN+4kQ9GjWLpypVs+/nnlHPt+fNPnu/cmW+WL+eVl17iZng4p86cSdn++549dL77Js6YiROxWK18t3o12zZsoGyZMkydNSvTcRcVFSpUwNvbO+Xh4uKCi4sL3t7edOrUiZiYGGbOnMmlS5eYOXMmiYmJKWO1ECLrZJy5z+7jTB7cz+zcuZP2HdujVqmZ+OFErBYrq9etZsPmDZQpW4ZZM+w7zhSDuXgi1+jdQNcAnCoo0zoTQ5WpnjoDKpWKrs+1Blor+1YdwMGf5/HSZ39RZe2/LHujOx27DQKf/ykVcfeotUozBZsHmGIg6jTEBStJPOeKoHXO/9dZTDVo0IAyZcowY8YMJk6cSHh4OF9//TUAJpOJy5cvo1KpqFq1Kq+//jqHDx9m0qRJGAwGOnToQOPGjdm/fz/x8fGULFmSO3fusHPnTrZv387ChQvZunUrNWvWZPbs2ZQsWTLd9WNjYzMciDKiUqkYOnRoyiC3atUqpkyZQrNmzQCYPn06LVq04K+//qJSpUocO3aMP/74Ay8vL2rUqMGpU6f47bffHnr+8ePHp6yH8M477zBv3jxGjBiRZp+ffvoJDw8PRo0aBUCVKlUIDQ1lzZo1dO3aNVOv4+WXX6Z9+/YADBgwgHfeeQcAd3d3NBoNrq6uuLq6snnz5sdeq3Tp0vTu3Tvl3E8++SS///479erVIzo6moMHDzJ27FhsNhvt27enY8eOlCtXDoDXXnuNwYMHZypmIYTILhln7rPbODNyJCQk4K7ToVGpcDUYcC1Vis3btuFRsiSj7k5jqlK5MqHXr7Pm22/p+vzzAJT28KD3q6+mnPvJpk35fc8e6tWpQ3RMDAePHGHsu+8q40zr1nRs145yZcsC8FqPHgweOTJTMRcXBoOB5cuXM2XKFDZt2kTNmjVZsWIFzs7yt68Q2SXjzH1F9X5m6KihaFQaWrdtTbv27ShbThlnevTqwci37TvOSHJNZI1KBY6eSoODuCCIvaCs6+VYNu26HM4VuF3yFbzKnubKzUg6fWym39/L+OzNHXg0nwSlGqU/r95NeRijIfqUss6bwUfpPKqRxV3zmoODA/Pnz2fUqFH4+fnh4eHBoEGDmD17NgaDga5du9KmTRvc3d0BqFWrFleuXGHDhg106NABUOb73+t8tXr1anr37s358+fZunUr27dvZ8GCBSxevJhJkyalu767uzsxMTGZitXDwyNlIIqPj+fGjRu8++67qNX3i3GTkpK4cuUKycnJuLu74+XllbKtfv36jxyMfH19Uz6uU6cOERERREdHp9nn8uXLnDt3LmUdFQCLxYJGk/n5/6lL0g0GQ8o7Uw/KzLUqVKiQ5pjnnnuOFStWMHr0aPbs2YO3t3dKuXjv3r3ZsWMHR48eJSgoiFOnTmG1WjMdd1Gya9cuhg8fnua5jh07snDhQs6cOcOUKVO4cOEC1atXZ9q0adSrV89OkQpR+Mk4c1++jzM2GwZHR0xms7JW3r311O6+nstBQZy7eJFGTz99/1pWa9pxpnz5NOd+rmNHVqxezegRI9jz5594V65MzRo1AOjdvTs7du7k6IkTBF25wqmzZ4vtOJPaxx9/nOZzX1/fNFUzQoickXHmvqJ2P7N7924qe1fmiSeeQKVS0b1nd3b+upMTx09wJegKZ8/Yf5yR5JrIHrUWStRQkmHRZ5VEmFO5NOt8denQgvOHtjFx1lIWrtjImr9s/HYihMX93+TVbi+iqvmOcvyD9G7K2mymaLhzQlmPzVAVnMrnTyOAYszX15e9e/cSHh5OyZIl+fvvvylZsiQuLi4AKQPRPVWrVuXff/9Nd56oqCh+++03fvzxRzZs2ECDBg1wdXWlZcuWfP755xleu27dunz11VfExcWle8fnyJEjrF69mrlz5wLKwHmPxWIBYMGCBfj4+KQ5zs3NjQMHDqSsZ3KPTqfjUVIPaveOffAYs9lM8+bNmTx58iPP9SiPiyMr13J4YO2jDh06MGXKFC5evJhmSqjVamXgwIHExMTQpUsX2rZti8lkSpdgKi4uXbpEmzZtmDFjRspzDg4OJCQkMHjwYF544QU+/vhjNmzYwJAhQ9i1a5dUFQiRAzLOKPJ1nLFYlIRakrJmbkbNJ8xmM82bNmXy3XVxMpJunGnThimzZnExMDDNlFCr1crAoUOJiY2ly7PP0rZVK2WcGTMm269DCCEyS8YZRVG7n9n5+07aPdsOjVqD1Wpl6JtDiY2N5dlOz9KqtTLOjBll33FG1lwTOeNYBjz8wbUqJN0CY1SazQaDM/NnjeHvX7+kzhPe3IqBHgvhjSnbYf+rELZDafP+IJVKaXrgUhlsFrhzTGl+EB8C1oyz4SJnoqKi6N27N3fu3MHT0xOtVsuff/6Jv78/oPyy79+/f5pj7q0r8KDVq1fTq1cvHB0dUalUKe8iWCyWdAPDPS1btsTV1ZV169al2/bNN99w48YNnJyc0m0rUaIEHh4ehIeHp6xpUr58eebOnUtQUBBPPPEE0dHRBAcHpxxz9uzZR34tLly4kPLxyZMnKVeuXLqEio+PD0FBQVSsWDHlusePH2ft2rWPPHd2ZOda9wb/X3/9lX/++Yfn7i48fenSJQ4fPszq1at56623aN26Nbdu3QJ46P9NURYYGMgTTzyBp6dnyqNEiRLs2LEDBwcHxo4dS7Vq1ZgwYQIuLi6PfIdQCPFoMs7cly/jjM2mdP6Mj1eSaw9WIqSaceBTpQpBISFUrFAB78qV8a5cmeP//cfajRsfenpXV1daPvUUv/7+O/8cOsRzHTsCcOnyZQ4fPcrqZct46403aN2yJbfudsUsjuOMECL/yDhzX1G6n9mxYwf/HviXZzs9iwoVlwMvczTgKMtWLuONN9+gZauWRITbf5yR5JrIOa0TuPsqUz2tZkgIVRJiqTRv6svRPzcw+f030Wo1tG7oCcY7cHIyHBmmJM0yolKBQyll/TVrEtw+oiTZEq4p1xK5xt3dnYSEBObOncvVq1fZvHkzP/zwA4MGDQKgTZs2HD58mC+//JKQkBC+/fZbtm3bxsCBA9OcJzo6ml9//TWlo079+vU5dOgQZ86cYfv27TRs2DDD67u4uDB+/HgWLVrE/PnzCQwM5OzZs0yaNIk///yTiRMnPjT2/v37M3/+fPbu3cuVK1eYOHEiR48epWrVqlSrVo3mzZszfvx4zp07x+7duzMc8FKbMWMGJ06c4O+//2bhwoXpBmGAF198kaSkJCZPnkxgYCD79u1j5syZeHh4PPLcmeXs7Mzly5eJiorK9rWee+45vv76a6pWrZryLliJEiVQq9X88ssvhIaG8ttvv7Fo0SKAh3YRKsoCAwMz7Bh14sQJ/Pz8UN29+VSpVDRu3JjjxbDbnRC5RcaZ+/J8nLFYlOSa0aj8q9enXb4DcHZy4vKVK0RFR/Nily7KtWbOJDAoiH379zNz7lw8MlhTKLXnOnbk6/XrqVqlCj7e3gCUcHVVxpmdOwkNC+O33btZtGwZUDzHGSFE/pFx5r6idD+zevVqvKt4pyRBXe+OMzt/3UlYWBi7f9/NsqX2H2dkWqjIHSo1uHgr0zmjz0H8NWVttlQNCRwc9EwbN4R+PZ+jauUyEPwtXFrJ/+0/hNfZnlR/6g2o2g/U6acroFKDQ2llrbfkSLh9GBzLgWsNpSFCYWJJLrDX+fzzz5kyZQovvPACFStWZMGCBSnz9X19fVmwYAELFy5kwYIFVKhQgU8//TTNvHlQ3pXp2bNnyrsyfn5+vPzyy/Tr14/atWs/clB58cUXKVGiBCtXrmT9+vWoVCrq16/P+vXr06wb8KA33niD+Ph4Jk+eTFxcHPXq1ePLL7/Ezc0t5XVNmjSJXr164eXlRd++fdmyZctDz9e7d2+GDh2KyWSiR48e/O9//0u3j8FgYOXKlcyaNYuuXbvi7u7Oa6+9xpAhQx7+Bc6C3r17M2/ePK5cucLixYuzda02bdpgs9no0qVLynPlypVj6tSpLFmyhM8++wwfHx8mTpzIBx98wJkzZ/D09MyV+AsDm81GUFAQ+/fvZ/ny5VgsFjp16sTIkSMJDw9P09EJlLUxLl68aKdohciC5HwaZ7JxHRlnFHk6zhiNyhRQm01ZU02b8Z/7vbt3Z96CBVwJDmbxp5+yctEiZs2bR9fevXF3c+O1nj0Z8sAN54PatGqFzWqly92qNYByZcsy9cMPWbJyJZ8tWoSPtzcTx47lg8mTOXPuHJ4PTMkSQhROyea8H2uycw0ZZxRF5X6mdevWWG1WOnTqgArlTaKy5cry4cQPWblsJYsWLMK7ijdjx41l8oTJnDt7DrdSGSw9lQ9UtmJanx0XF4efnx8BAQGZ7ughMslihNhLEHcJ1A7g4JHu3dJ7oq6fo06rAUTFmZj+KozqXh2t3xxlOuijWM2QFK6c11BVaXxQQJoeJCUlERQUhI+PT9qWzRYj3D6kNIDIL1qDMm1Xk0HCUogseuj3diEVGhpK27Ztefnll/nf//7HtWvX+Oijj+jQoQMXL17Ez8+Pkam62y1YsIBjx46xevXqTJ1fxhmRlzL8eTQa4dAhiMvHccZgAH//DNfxEvns3tpqRqPy99FDkmp2ZzKBiws8ZJ2eojbW5CUZZ0ReetjPotFi5NC1Q8SZ8mesMegM+Ff0Ry/3M8WS2WomzhiHVqVNmVHyOEaLESedE47ajMeQvBpnCuioKwo1jR7caitrpsWcVaZwOpVXmiA8IN5Witp1G7D3ryO8/y1sPXyJze++htcz06Bc24dfQ60F5/JgjleukXRLqWJzKqdUuRVEGr2S6LLl43RWlVYSa0I8RIUKFTh48CBubm6oVCpq166N1Wrl/fffx9/fP11ZudFolBs9UbDp9Uqiy5yP44xWK4m1guBetZrFoiStMnkDIoQQWaXX6PGv6I85n5bo0aq1klgrxowWI9hApS7445ok10TeUKnA2UuZJhpzFhKu3k2wpf3FWMGrDLu3fsHX325n9MTP+OdiPH7jE/l+5Fie7vgaPDEiw6RcCq0LaJwg+bYyVdS5MpSoDjrXPH6B2aTRAzI4CFFQPNgxqlq1aiQnJ+Pp6UnE3QW474mIiKBMmTL5GJ0Q2aDXS7KruElOhsTEu82g5P9eCJH39Bq9JLxEnrNYLZgsJjRqzeN3LgAKaImPKDJ0BnBvAM4+kHAdLEnpdlGpVAx87SWO7FlHvdrVuBEFbWbCF6vWYzs4WKlKexSVWlnfzdET4q8oDQ9ig6ThgRDikf766y+aNWtGYmJiynNnz57F3d0dPz8/jh07ltJxyGazcfToURo0aGCvcIUQIr17ibVHrK0mhBBCFEZGixGrzYq6oM5Me0DhiFIUbho9lKynTNtMvAXmhAx3q161Egd++5ruL7XHZIE/z2kg6iT887qyVtljr+MAhspKsu3OMYg8olS0CSFEBho1aoSDgwMTJ07k8uXL7Nu3jzlz5jBo0CA6depETEwMM2fO5NKlS8ycOZPExEQ6d+5s77CFEEKROrGmKRzv6gshhBCZYbFaMFqMhaZqDSS5JvKLWgdudZS12JIj4SELYBoMzmz8cjYr50/kq6/XoSrxBBgj4fBwCPwSbNbHX0vvDs4VIClCqWKLPpd/HTqFEIWGwWDgyy+/JDIykldeeYUJEybQs2dPBg0ahMFgYPny5QQEBNCtWzdOnDjBihUrcHZ2fvyJhRAir0liTQghRBFmspqw2qxoVIVnjJP6cZF/1Boo8YSyyH7MGbBZQJ++Ta5KpWJQ367KJ6W+wnb6E4bO+Ilezb+g9TMnof70DI9Le617DQ/ilGsZI+82WSiZ+69LCFFo1ahRg6+//jrDbb6+vmzdujWfIxJCiMeQxJoQQogizGqzFrqqNZDKNZHfVGpwrQbuvmBJVKrYHkXjyJcnGrB8L7SfDfPX/I3t79cg+kzmrqc1gHNFZXpoxCGID8lc9ZsQQgghREEjiTUhhBBFnMliwmK1FKqqNZDkmrAHlQoMVaBkA6V6LSn8kbv3eaUTr3fvjMUK766D1z+7QcK+gRD6Syavp1E6l6q1EHkMok5l2FhBCCGEEKLAksSaEEKIIu5e1VphaWKQWuGLWBQdzhWhZEMl+ZV4A+525Uu3m7Mja76YzoJZY9Bo1Hz7Dzw91Uzw3ilw5bvMX0/vDo6lIfYS3A54fNWcEEIIIURBIIk1IYQQxYDZasZsNaNVF74VzCS5JuzLqRyUbAQaJ0gMe2iCTaVSMXJIL/Zs/YIynqU4HgwtpsPFP+fBpRUPPS4djSO4VFLWYLt9GOKDZZroAxISEpg/fz6dOnXC19eXZs2aMXLkSC5evGjv0NJo27YtW7ZsSff8uHHjqFmz5kMfBw8ezPK14uLi2LZt22OvLYQQ4vFknEnvkeOMJNaEECJLZJxJrzDcz9hstkJbtQbS0EAUBI6loVRjuHMCEkKVTp8qVYa7PvO0H0f2rOHZV4Zz+UoIV8Kt1Li0AkwxUGu0sqbb46jUyjRRYxREHgdjtNJoQeOYqy+rMIqPj6dPnz4kJCQwbtw4atWqxZ07d1i/fj29evVi27ZtVKpUyd5hPtKECRN47733ANixYwdfffUV33//fcp2N7fHNMPIwOrVqzl48CBdu3bNrTCFEKJYknEmYw8dZySxJoQQWSLjTMYKw/2M2WrGbDGj1RTONFXhjFoUPXp3JcEWeRQSryvJr4eoVKEc+35awYlTF+hQNRjOzoXg78AUC/UmKWurZfaaGkdlmqgpRukm6uCRKy+nsFqyZAm3b99mx44dlChRAoAKFSowe/Zsrl+/zurVq5k0aZKdo3w0V1dXXF1dUz7WaDR4enrm6Jy2zFZGCiGEeCQZZzKW4ThjNktiTQghskjGmYwV9PuZe1VrqEBFxoU2BV3hrLcTRZPOFUr6KlNEk249ctcynqXo0OZJ8O4JvtO5cEPN4b9+geMfgCU589dMmSZ6B24fgbgrxXaaqNVqZevWrQwYMCBlIEptzpw5vP/++wBs2bKFXr16MWzYMPz8/Ni+fTtWq5VVq1bRrl07fH196du3L+fPn085/sES5i1bttC2bVsADh48SNu2bfn2229p2bIlDRs25P3338doNKbs/91339G6dWsaN27M0qVLs/06r127Rs2aNVmyZAlNmzZl+vTpLFq0iL59+6bZ716p9JYtW1i8eDGHDh2iZs2aKdsvXrxIr169qF+/Pl27duXs2bPZjkkIIYoDGWeyMM7YbFy8cIFegwZR/+mn6dq7N2dTvVYhhBDpyThTeO9nLFYLJqsJrarw1n9Jck0ULPqS4F5f+dgYlalDgi2NaDvHlXazYf9f+yBgFJjjM3/Ne9NE1Vplamr0ObCasxx6ZsTHxz/0kZSUlOl9ExMTM7VvVoSEhBAZGUmTJk0y3F6mTBkcHe9PnT127BjVq1dn06ZNtGjRgiVLlvDVV18xfvx4tm7dSoUKFRg0aBAJCQmZuv6tW7fYuXMnq1atYtGiRfz+++8p6wL89ddfzJw5k1GjRrFx40b+++8/QkNDs/T6HnT06FF++OEH+vXr98j9unTpwsCBA2nUqBH79+9Pef77779n0KBBbN++HTc3N6ZMmZKjeIQQIjfIOPNwhW6c2baNQQMGsH3jRtxKlGDKzJk5ikcIIXJLfo41WSHjTMYKw/2M0WoEm7LWemElyTVR8DiVBbe6YE4Ac9xjd/co6UaNGtWJTYSOn8Devw7D4aGZTs6l0Lsr00Jjz0P0KbAYH3tIVhkMhoc+XnnllTT7lilT5qH7du7cOc2+VapUyXC/rLhz5w6Qdg7/P//8Q6NGjVIezz33XMo2lUrF0KFDqVatGiVLlmTdunW88847tGvXjmrVqjFjxgw0Gg3bt2/P1PVNJhMTJ06kZs2atGzZkpYtW/Lff/8BsHnzZl544QW6du1KjRo1mDVrFg4ODll6fQ/63//+R+XKlalSpcoj93N0dMTZ2RmdTpemHLt37960b98eHx8f+vbty7lz53IUjxBC5AYZZx6u0IwzZjPYbPR+9VXat26Nj7c3fXv35lwBW4hbCFF85edYkxUyzmSsoN/PmK1mTBYTGnXhXgJBkmuiYHKuBCVqQXIkWJIeuavB4MwvGxbwbJsnSUiG5+bCr/vOwKHBj51emo7WCRzLQtxliDqhJPiKiXul0zExMSnPNWrUiG3btrFt2zbefvvtNO8ueXh4pLzzc/v2baKiomjQoEHKdp1OR7169QgMDMx0DN7e3ikfGwwGzGalgjAwMJDatWunbCtZsmSOFyKtUKFCjo5PfX1XV1eSk7MwHVkIIYohGWcywWZTmhjwwDhjMMg4I4QQjyHjTNYUlPsZk8WE1WYttF1C7ym8E1pF0aZSgWs1JbEWe/HutE3dQ3d3dnZk+/rP6DFwHNt/+z9e+hw2mS/T1TIImi4F54qZv7bGAZwqQMI1pXqtZH3QpZ+znx1xcQ+vxNM8sFjxrVsPTwyq1Wl/8Vy5ciVHcYEyELi7u3Ps2DF8fX0BcHJyShkgPDzSNntI/U7Lw951sVgsWK0Zr2FnsVjSPafX69N8nnrhzQcX4dTpHv79kBmpY86o/PjeQPgwD/5/CSFEQSDjTNptDyrw44zJpDwAjbpw32QIIYqugjrWyDiTVmG4n7FYLRgtRrSZbUpYgMmoLQoulRrcaoGLNySEgS39L6/UHBz0fL96Dt1fao/JDK8ugF8PhMHBNyA+OGvXVmuVhFxyhNLBNPl2Dl7IfS4uLg99pJ7//7h9nZycMrVvVmi1Wl555RW++eabDAfMmzdvPvRYV1dXSpcuzfHjx1OeM5lMnD59Gh8fH0AZPFKvm3D16tVMx1ajRo2UkmpQBvTg4Cz+nz7Cg7HFx8cTGRmZ8nlhnvsvhCheZJwpxOPMvao1GXOEEAVcfo41WSHjTOG7nzFZi0bVGkjlmijo1DpwqwNWIyRcB+cKj/yjU6fT8u2Kj3B00PPf6fM82cgGyZfhyAh48itwKJ35a6vUyvWSbsDtAKWCzal8LryogmvEiBEEBATQq1cvhg8fTt26dblz5w6bN2/m+++/5/nnn3/osf3792fhwoWUKVMGb29vVq5cSXJyMl26dAGgfv36rFu3jqpVqxIYGMiWLVvSvbPzMK+//jr9+/enadOm+Pn5sWTJknSLpeZE/fr1WbBgAb/++iu1atVi8eLFad5Jc3Jy4tatW1y7do2KFbNQBSmEECINGWceMc7cvMm1kBAqPmbtHCGEEA8n40zhuZ+xWq0YLcZCv9baPZJcEwWf1gnc6ykVZEk3Hpvg0mq1rF4ylZjYeNwdTXBwoDLFM+Ad8F8O2iwsjKlSKde7V8HmXg+cKxfZd5WdnJxYu3Yt33zzDUuXLiU4OBi9Xo+vry+LFi2iffv2Dz124MCBxMXFMWnSJOLi4mjUqBFr166lVKlSAEyaNImJEyfy/PPPU79+fUaOHMmyZcsyFVeTJk2YPXs28+fPJzIykldeeSXNmgU51bx5c/r378/kyZNRq9UMGDAgTQl7hw4d+O6773juuefYu3dvrl1XCCGKGxlnHjLOtGnDd99+y3O9e7P3l19y7bpCCFHcyDhTeO5nTFYTFqsFvSZzCcqCTmV7cOJvMREXF4efnx8BAQFZ7kIi7CT5tpLgslnBMQsVaAnX+Hr2azxROp6nn/IHvwWPXL/toYxRYI5XGi24Vlcq2zKQlJREUFAQPj4+6cqihSjM5Hs7a2ScEXlJfh6LEJsNEhOVKaGZrIAo1EwmcHGBh6w1JN/bmSfjjMhL8rMo8pLVZiXOGAc2cr1yzWgx4qRzwlGb8fdtXn1vF/6JraL4cPBQKsdsZjBGZ/qw7347zcCl8bz0OVw8fQj+m64k6LJK7w56N4g+A1GnwWrK+jmEEEIIIVIzm8FofGiySQghhChqTBalaq2oTAkFSa6JwsapPLjVBVOsUkWWCS90bEXTRnW4HQtd5kDEhV/h/KLsXV9rAEdPpYPpnVNKN1EhhBBCiOywWiEpSVluooguOSGEEEKkZrXdXWtNVXQSayDJNVEYuXhDiZrKOmjWR7cXBnBxceKnbz+nSmUvLt2Erp9B0oW1cOXb7F1f4wjOXhAfBDFnpIJNCCGEENljNCqVa1pZBlkIIUTxYLKYMFvNRapqDSS5JgojlQpcq4FTBUi8kalDypbx4JcN83ErYeDvC9B/OVjPfAbXf89eDGodOJeH2MvKNNFMJPmEEEIIIVJYLMo6a5qidXMhhBBCPMy9qjX1Q9YvL8yK3isSxYNapzQW0DqD8U6mDqlTqypbvpmLTqdl478wYRNwcgrcPpLNGPTgVA7iLkP0WbBasnceIYQQQhQvNpuSWLNaJbkmhBCi2LhXtaZVF72KbUmuicJL76ZMDzXFgyUpU4e0bdWUVfMnAuBUygeb1QTH3oOYC9mLQeMAjmUg7hLEnEuTYCumjXhFESbf00IIkUukiYEQQohipihXrYEk10Rh51wRDN6QeFN5FzgT+vV6nhP/t4HJc9ehKtVYaYwQMBISwrIXg8ZRSbDFXICY8+i0yjvQCQkJ2TufEAWU0ag08NBIlYUQQmSf1apUrYE0MRBCCFFsmK3mIlu1BlA0X5UoPlRqcH0CjNGQfAscy2bqMN+6NZQPGn9K/L6BhAUHUUM7App9CXr3rMehcbzbRfQCGpUadzc3bt26BYCzszMq+eNZFHJWq5Xw8HCcnZ3RysLbQgiRfSaT8pCqNSGEEMWEzWYj2ZxcZKvWQJJroijQOivrr0UeAXMcaA2ZPvTmHSPPz9Jy/aqag9OCqaAbDf7LlTXdshyHE+ABMecoV6IWcD/BJkRRoFarqVy5siSLhRAiu1I3MZDfpUIIIYoJk1VZa02nKbpvLElyTRQNTmXBtTpEnQZnR8hkqaleryMuwURopJXnP1XzfxNP4np+IdR+L3txaJ0BG6qY85R3q0OZMjUwmaWTqCga9Ho9anXRfbdJiKLAarVitVrz7XpqtTpLvxdq1qzJmjVraNasWa7G0bZtW4YPH063bt0eu++WLVtYvHgxe/fuzdUYMsVkYtyUKWzdseOhu6xZsYJmTZqkeW7RsmUcCghg7cqVeR2hEEI8Vn6ONTLOZE/fvn3x9/dnxIgR6bYdPHiQfv36cf78eQD27NnDtGnTiI6OZvHixZQuXZrExEQaN26c5rhr167Rrl27h17T39+ftWvXpnu+Zs2aLP9yOY2aNEJF0X1jSZJrougwVFU6hybdUNZiy4SS7iXYsXEBT3YcwPErkfRaDD+9twF1yYZQ7uG/OB5J6wLYIPoMGpUajaGqvDsthBAiz92bvm0ymfLtmjqdDk9PT0m8Z4bFAkYjE95/n/dGjQJgx++/89XatXyf6mbEzc0t3aED+/Wjb+/e+RWpEEI8VH6PNTLO5L5GjRqxf//+lM8XLlxIixYtGDZsGB4eHnTp0oXhw4enS66VL18+zXGvvvoqAwcOpEuXLoDyf5WRP/b9gc5Zh0ZdtNdtluSaKDrUOmV6qDEajFGZXjvNx7sCP63/jNYvDWHH8WTm/Azj9NOVtdxcKmUvFq1BabAQfRpQgcFHEmxCCCHylNVqxWQyodFo8qXxiMViwWQyYbVa5aYnM0wmsFhwdXPD9e5TrgYDGrUaz9KlH3moi7Nz3scnhBCZkJ9jjYwzeUOv1+Pp6ZnyeWxsLH5+flSoUOGRx2k0mjTHaTQaXF1d0zz3IJvNRolSJbBYLUW6ag2kW6goavTu4FYLTLFgSc70Yf5+9Vj8yVgAJm6GA2fj4fgHYEnKfiw6V+URfQoSrmb/PEIIIUQW3LvhyY9Hbvvjjz94+eWX8fX1pUuXLvz+++8p28xmM5999hktWrTAz8+PkSNHcufOnXTnOHHiBI0aNeL7778H4ObNmwwaNIiGDRvy8ssvExISkmb/wMBA3njjDRo3bkzLli1ZvHgxVquVM2fOUKdOHWJjY1POU7NmTX744YeUY3v16sXmzZtZtGgR7733HlOmTKFx48Y0b96clamncFqtYDQqa609xrWwMGo2bsySlStp+swzTP/4YxYtW0bfN99M2Wf/gQO80KMHvs2bM2j4cGZ88gnjpkxJ2b563TpaduxI45Yt+WjOHPoOHsyW7dsBpfPzR3Pn0qxtW5q1bcuYCROIio5+6LWFECIjMs4UsHEmCw4ePEjNmjUBZbpraGgo48ePp23btvTt25fQ0FA+/PBDxo0bl+Vzjxs3jnHjxvHiiy/SvHlzLl2+hF99P44FHAMgKSmJ6VOm06p5Kzq268i2Ldto2rApYaFhAFy7eo23Br3FU02fosfLPVizeg3PdXwu5fxHA47yWs/XaN6kOT1e7sGeXXtStk2ZMIUpE6bweo/Xad2yNVeuXMnW1ye7JLkmih7nSuDsrUwPtdkyfdiAPi/S+5WOWKww9GsNtpgLcPbTnMWiK6FME40+DUnS3EAIIYR4mAMHDjBixAheeuklfvzxR7p37867777LqVOnAFiwYAFbt25l1qxZbNy4kdu3bzMlVUIJICgoiCFDhjBixAheffVVAN555x2sViubN2/mzTff5JtvvknZPzIykj59+lCmTBk2b97MlClTWLduHWvWrKF27dq4u7tz5MgRAA4dOoRKpeLo0aMAxMXF8d9//9GyZUsAdu7ciYODA1u3buWNN95g3rx5BAUFKRe6W7WWmeTaPUePH+eHdevo16dPmuevXrvG0HffpfOzz7Jtwwbq163L+k2bUrZv37GDhcuXM37MGDauXs21sDAOBwSkbP9s8WJOnT7NyoULWbN8OXFxcbwzdmymri2EEIVZkR5nsun777+nXLlyjB8/nu+//55FixalfD5hwoRsnfPHH39k1KhRLF++nPKVygOkVK3N/XguJ46fYPGyxXw892O++fobLBYLoCQ33xn+Dq4lXFn33ToGDBrAii9WpJw3IiKCUcNH8cJLL7Bxy0b+N/B/TJk4haMBR1P2+eXnXxgybAiLly6mSpUq2fyqZI9MCxVFj0oNbk+AORqSw8GxTOYOU6lYNu9DAGa9/RSqG1Ph2lYo2RAqPPfIYx9J7w5JNyHqFHg0URJuQgghhEhj/fr1dOzYkf79+wPg4+PDyZMn+eqrr/j000/ZtGkTH3zwAa1atQJg2rRp/PrrrynHR0REMGjQIHr06MHAgQMBuHjxIseOHeOPP/7Ay8uLGjVqcOrUKX777TcAfv75Z5ycnJgxYwZarZZq1aoRHh7OkiVL6N+/P0899RSHDh2iTZs2HD58mFatWqXc9Pz777/4+PhQrlw5ANzd3fnggw/QaDQMGjSIlStXcurUKXy8vTNdtZba//r0oXKl9MtTbN66Fd+6dXl70CAA3hk6lH/+/Tdl+7ebNvG/Pn3o3KEDAJ9Mn84znToBkJiYyLqNG/lh3Tpq1qgBwJyPPqJZmzacv3gRFxeXR15bCCEKsyI7zvj4ZPtrUqpUqZTpnaVKlQLuT/d0dXV9zNEZq1+/Pm3btsVkMRFvjE95PiEhgZ+3/8yiLxbh28AXgPfHvc/wt4YDcPjQYW7euMk367/BYDBQtVpVLl28xG+/Kl/LTRs24f+kP7369AKgcuXKnD93nm/XfUtjP2V9uDr16tDymZY46Zyy9wXJAalcE0WT1gVK1ASrGcwJmT6sRAkD366YSZWGz0E15Y9WzsyG2MCcxeNQRpmqGnUqZ1NNhRBCiCIqMDAQX1/fNM81atSIwMBA7ty5Q1RUFHXr1k3ZVr169TRd0BYuXEhoaGjKTQjApUuXcHd3x8vLK+W5+vXrp7lm3bp10Wrvv9/cqFEjwsPDiYmJoUWLFhw8eBCAI0eOMGDAAIKDg4mMjOTAgQMp1QQAFStWTDOFycXFBbPZrFStmc1ZTq5VSBVzaucvXqR+qq8DQMNUX7fzFy9Sv06dlM/dSpTA5+6791dDQzGZTPTq359GTz9No6ef5plOnbBarVxJNY3pYdcWQojCrMiOMwVMhQoVsNlsJFuSSb3M2pWgK5hMJurWu/81vpdkA7h44SKVvStjMBgy3B4UFMT//fl/PO3/dMpj44aNhFy5P3552XH8kso1UXQ5lgNDNYg5By4VQZXFOfvVB/Hb7n14aS7g6zgOmn8D2mwuKKxSgXN5iL8GUWehZH1Qy4+fEEIIcY+Dg0O656xWK1arNc1NycO0bt0af39/5s+fT6dOnVLegbc9sERE6m5mD7smKAtpP/3000yYMIHg4GBu3LiBv78/1atX59ixYxw4cICJEydmeN57bPfWWsvGQtwZxQag0WrTvabUn2s0Gh5cFOPe9ntTb7796iucndK+q+/h4ZGy9trDri2EEIVZkRxnsrAMUn5xcHDAbDVjtprRprrnvZcYTB3zg+PXg1Jvt5gtdHm+CwPfHJhmn9T/dw56+41fUrkmii6VClyrg1O5bK139s13v9J54gV6LtYQfzsITs/K0hpu6ePRgLMXJARB7MWcnUsIIYQoYnx8fDhx4kSa544dO4aPjw8lSpSgZMmSnDt3LmXb2bNnadWqFUlJSkV427Ztee211yhbtixz584F4IknniA6Oprg4OA0x6W+5unTpzGZTGmuWapUKdzd3fH09KR69eqsWrWKhg0botFoaNKkCb/88gvXr1+nSZMmj35RFotStZaJm7bMqlG1KqdTvQYgzefVq1Xj9JkzKZ/HxcURfFVprFTpbtVDVFQU3pUr411ZqRCY/emn3L59O9diFEKIgqhIjjMFkM1mw2gxAqTpEFqpciV0Oh1nz9z/+qT+uFq1aoQEhxAfH5/hdu8q3oSEhFC5cuWUx74/9vHrL/en7tqTJNdE0abRKwk2my3L0zG7dHgar3KenAu1MHKtCq7/Ble35CwetQ4cPCHmAsQHP35/IYQQoog5efIk//d//5fmkZiYSP/+/dm5cyfffPMNV65cYfXq1ezatYvevXsD0LdvXxYsWMC///7LxYsXmTlzJg0bNsTR0THl3BqNhokTJ7J161aOHTtGtWrVaN68OePHj+fcuXPs3r2bdevWpez/wgsvYDQamTx5MoGBgezevZtFixbRu3dvVCrlhuDpp59m69atNG6srOfSpEkTduzYgb+/P3q9/uEv1GZTEmvZqFp7lB7dunH8v/9YsXo1QcHBLPvyS44cO5Zy+9K3Vy/WbNjA73v2EHj5MuOnTychIQGVSoXBxYXuL7/M1NmzOXjkCJcuX2bspEkEX71KxQoVcjVOIYSwl2IzzjxGcHBwuq/DjRs3Hnucs7Mzly9fJioqKlvXtWHDZDWlqVq7d94Xu77I3I/n8t/J/zh54iRzP1aSlKjA/0l/ypYry4ypM7h8+TK7f9/NhvUbUr5O3Xt15+zpsyxZuISQ4BB+/eVXFi9YTPny5bMVZ26TeWmi6HPwBJfKEHdZ+TeTPEuXZP3yGbTtOpSv/rTRrg70Uc0Dt7rgViv78WidwWqEmDOgcQKnstk/lxBCCPGAe1P/Cup15s2bl+6533//nQYNGjBnzhwWLVrE3Llz8fHxYf78+TRv3hyAwYMHExsby6hRozCbzbRu3ZpJkyalO1ezZs149tlnmT59Ot9//z2ff/45kyZNolevXnh5edG3b1+2bFHeLDMYDKxatYqZM2fStWtXSpUqxf/+9z+GDBmScr6WLVvy5Zdf4ufnB4Cfnx82my3NOjgPlcUOoZlRwcuLhXPm8Mnnn7Pwiy94ulkz2rVunTJd6LmOHQm+epUps2aRbDTSs1s3KpQvn7J93Lvv8sn8+Yx8/31MZjNNGzVixaJFGU7HEUKIh8mPsUbGmUyMM4/w008/8dNPP6V57qOPPqJy5UffE/fu3Zt58+Zx5coVFi9enKVr2my2lGmvqavW7nl3zLvMnD6Ttwa9hcHVQI9ePViycAk6nQ61Ws28z+cxY9oMer/amyo+VXih6wv8s/8fQFlPbf6i+Sz4fAFrVq+hTJkyvDvmXbo83yVLMeYVla0gTtLNB3Fxcfj5+REQEJBmwTxRRJliIeJfpZOo3j1Lh075eDnT567E4KTh2EcWqvtUgKfWgS573VNSJN0ClV7pIKp3y9m5hBAFjowzIi8lJSURFBSEj49PyjvqVquV8PDwNFNP8ppOp8PT0xN1LldnFXo2G8THK8m1XJwSCnDh0iXMZjN1at1/o2/wyJHUr1OHEW+9xaGAACpVqED5uwtum81mnmzbliWffUazgjC9yGQCFxfIYO0gyPh7W2RMxhmRlx72s5jfY42MM4WL2WImzhSHVqVNqThL7Y89f9CseTOcnZW1zE+fOs2AvgP4+9DfxMbEcu7cOZ56+qmU/b/5+hv2/99+Vn69MtMxGC1GnHROOGozHkPyapyRyjVRPOhcleYGUceVj7PQ3GDSmDf4Y/8R/jpwjJ5LdPwzORSHU9Oh4RxlXbfsciwDCdeUDqKlGoM2/9sFCyGEKDrUajWenp4p7xjn1zXlhicD9zqE5nJiDSDk2jUmTJvGZ7NnU6VyZf45eJADhw4xevhwAHb/8QfHTp5k2vjxuDg7s2bDBgwGAw1Tda8TQojsyu+xRsaZwsNms2G03l1r7SH3ySuWreCv//uL/m/0JyE+gfmfzqd1m/vV1++OeJcxH4zh6ZZPczX4Kt+u+5aBgwZmeK6CRpJrovhwrgiJYZAcAY6Zn4qp1Wr5dvlHNHimD0cvR7PliIbeuj8geANU6ZOzmJy8lARb9Bko6ausySaEEEJkk9yEFAA2m9IhFHL2JtxDtG/dmouXLjFh+nRuR0bi4+3N5x9/TK0nngBg5NChTP/4Ywa8/TbJSUk0atCAVYsXSwdQIUSukbFGZMRis2C0GNE8opBl5scz+WT2J/Tp3gedTsczbZ7hvbHvAVDKoxSfzPuEpYuX8umcTynlUYqevXvSo1eP/HoJOSLJNVF83GtucPuQ0txAk/kS0IoVyrJm6TSiomPp7R8LZ+fAhcVQ+ikwVMl+TCo1OJVXmhtoHMGttvKcEEIIIQonsznPqtbuGTpoEEMHDcpwm8HFhTkzZuTZtYUQQoiMGC1GsPHIxGvValVZvmr5Q7e3btua1m1b50F0ea9A38Vfv36dIUOG0LhxY9q2bcvq1atTtp05c4bu3bvToEEDXnnlFU6dOmW/QEXh4VgWnCpBUniWD33u2Ra81r0zVO4OpZsrTQlOTQdbDhfzVOuUKaKxlyDuSs7OJYQQQgj7yeOqNSGEEKIgslgtmCwmNOri2xynQCfXRo0ahbOzM1u2bGH8+PHMnz+fXbt2kZCQwODBg2nSpAlbtmyhUaNGDBkyhISEBHuHLAo6lQpcqypdOk0x2T5HeLnhfPKzDtudk3BlQ87j0jqBvgTEnIXEmzk/nxBCCCHyn9msrLeWh1VrQgghREFjtBix2qyoi/EsrAL7yqOjozl+/DhDhw6lSpUqtG/fnpYtW3LgwAF27NiBg4MDY8eOpVq1akyYMAEXFxd+++03e4ctCgO9m9LcIPkO2LK+EGdyspHGnUczboOJNX8BF7/InYozXQkl+RdzDsySKBZCCPF4xbTpe8EkVWu5Qr6nhShY5GdSPI7Fqqy1plUXjjeW8up7usAm1xwdHXFycmLLli2YTCYuX77M0aNHqV27NidOnMDPzy+lA4VKpaJx48YcP37cvkGLwsOlEjh4QPLtLB/q4KBn+KDuAIz+VsutO8m5Mz0UwKEMGG9D9Hmw5sL5hBBCFEkajTLtwngvmSPsz2KRqrVccG8myr3OcUII+7j3Myizw8TjmKymQlW1llfjTIEd/R0cHJg8eTIzZsxgzZo1WCwWunXrRvfu3dmzZw/Vq1dPs7+HhwcXL160U7Si0NE4gGsNuH1YWTtNrc/S4aPffp0NW37nxKkLvLtew/q3704P9Xk9Z3GpVEqDg4RgpcLOtWrOzieEEKJI0mq1ODs7Ex4ejk6nk65tBUFiopJcs2a9Kr5YMZtBo1GSkanYbDYSEhK4desW7u7uKQlkIYR9aDQa3N3duXXrFgDOzs4pxS1C3GOxWkg0JYIKkk3J9g4HUJJ9aos6XbYrr8eZAptcAwgMDKRNmzYMGDCAixcvMmPGDJo3b05iYiJ6fdpkiF6vl3dvRdY4lQPnipBwDVwqZulQnU7Lys8n8GTHAXz7t4XXn4LO6i+gTEtw8c5ZXGq9MkU09oKSYHPwyNn5hBBCFDkqlYry5csTFBREcHCwvcMRViskJytvkkmi89HMZnBwUBJsGXB3d6dcuXL5HJQQIiP3fhbvJdiEeJDJalIaGag0BSb5araa0Wl06NQZV6bl1ThTYJNrBw4c4Pvvv2ffvn04OjpSv359bt68yRdffEGlSpXSJdKMRiOOjo52ilYUSiq1UhmWHA6mONAZsnR408Z1GTm4J/OXbWDoN3pO1UrG8N80aLYSVDnMguvdIPE6RJ8Fjyagke9tIYQQaen1emrUqCFvLhYEFy7A9etQrpxUrj3OjRvQuDGULJluk06nk4o1IQqQe2/klClTBpPJZO9wRAGTbE7m6PWjAJRwKGHnaO67HnudJzyeoLJ75XTb8nKcKbDJtVOnTuHt7Z0mYVanTh2WLVtGkyZNiIiISLN/REQEZcqUye8wRWGnLwkGH4g+DVpnJeGWBTM+HMrWX/4k+Op15vyiY/orJyH4O6jyWs5jcywL8Vch5gK418tybEIIIYo+tVotby7aW3g4XL0KJQrOjUWBZjaDTgfyfStEoaHRaCTxLdK5GXWTO+Y7VC5RGQpG0RoAZrUZjV6T738fFdi79TJlyhAcHJzm3djLly9TsWJFGjRowLFjx1K6PNhsNo4ePUqDBg3sFa4ozFy8QV8KjJFZPtRgcOaLeeMYOuBV3nt3pPLkhaUQH5LzuFRqcCoLcZeVqatCCCGEKFhMJrh4UekU6uxs72iEEEKIfGG0GLkSdQWDzlBgpoPaW4FNrrVt2xadTsfEiRMJCgpi7969LFu2jL59+9KpUydiYmKYOXMmly5dYubMmSQmJtK5c2d7hy0KI40juFYHcyJYs17u3Ln90yydNw632r3Awx+syfDftNzpHqpxVKarRp8D452cn08IIYQQuSc4WJnmKLMnhBBCFCM3424SmRhJSaf0U/yLqwKbXHN1dWX16tWEh4fz6quvMnv2bIYOHUrPnj0xGAwsX76cgIAAunXrxokTJ1ixYgXO8o6hyC7H8uBcAZJysFinSoWt7kROhzlB1AkI3pg7selLgjVJSbBZZF0dIYQQokC4cwcuXVLWDpPpUkIIIYoJs9XMlagrOOucUcvSRSkK7JprANWrV+frr7/OcJuvry9bt27N54hEkaXWgKGqklwzJyjrr2VRdEwcr/zvI/4+aOLUbKimXgKeLcAl/UKKWeZUDuKvQexFcKujdCMTQgghhH1YLEpiLTkZPD3tHY0QQgiRb27G3eR24m3KG8rbO5QCRdKMQtzj4AHOlSD5drYOL+Hqgs1mIynZzJA1JbBZcnF6qEoDjmUgLhASw3J+PiGEEEJk37VrEBqqdAcVQgghigmL1UJwdDB6tR6tukDXauU7Sa4JkZpLZdDowRyf5UNVKhXLPxuPo6MDe47HsOZv/d3poZtyJzatE2gclOmhppjcOacQQgghsiY2VmliYDCAVm4shBBCFB/hCeGEx4fj4exh71AKHEmuCZGa3h2cKkFS9qrXqletxNSxbwIw+ls1t6KBC4tzp3sogENpMMcpCbZsNF8QQgghRA5Yrcp00Lg4Za01IYQQopiw2qwERwWjVWulai0DklwT4kEulUHrmK3qNYDRb79Og3pPEBmdxLubPZTuoac+Aps1d+JzKgeJ1yDucu6dUwjB4MGDGTduXMrnZ86coXv37jRo0IBXXnmFU6dO2TE6IUSBcP06hIRId1AhhBDFTkRCBLfib1HKqZS9QymQJLkmxIP0buBUEZIjs3W4Tqdl1fyJqNVqvv3jNr+e1MOdoxCyOXfiU2uVCrbocxB1RjqICpELfvnlF/bt25fyeUJCAoMHD6ZJkyZs2bKFRo0aMWTIEBISEuwYpRDCrhITlemgjo7g4GDvaIQQQoh8Y7PZuBp9FQC9Rm/naAomSa4JkRGXyqBxVKZgZkOTRnV4Z0gvaj/hQ8naPZQnLyyGhNDciU/rAo6lIfYC3DkGptjcOa8QxVBUVBRz5syhfv36Kc/t2LEDBwcHxo4dS7Vq1ZgwYQIuLi789ttvdoxUCGE3Nhtcvgx37oCHrDMjhBCieIlMjOR67HWpWnsESa4JkRG9293OodmrXgOYOeFtjv25niefHwklG4Ml8e70UFvuxKhxBOcKkHgdbh+BxJu5c14hiplPPvmEl156ierVq6c8d+LECfz8/FCpVIDSsKRx48YcP37cTlEKIewqPByCgsDTE+7+XhBCCCGKA5vNxtWYq1iw4Kh1tHc4BZasQifEw7hUgoRrYIoDnSHLhzs5pfrFU28S/N0LIg/Dta1QqVvuxKjWgnNFSL4FdwLAXAsMVUAleXMhMuPAgQMcOXKEn376ialTp6Y8Hx4enibZBuDh4cHFixezfA2z2YzZbM5pqEIIezEa4dw55c0xvR4sFntHVLhZrcrXMJu/F7XSoVUIIfLVnaQ7hMaEUtqptL1DKdBkdBLiYXQllOq12PPZSq7dk5SUzPyVe7hypibLup2Ecwug9FNKY4LcoFKBY1kwRkPUSWUqa4maoJH1YIR4lOTkZKZMmcLkyZNxdEz7LlxiYiJ6fdr1JPR6PUZj1tc4vHnzJnFx2ZtiLoQoAIKDlUfZshATY+9oCr/ERIiIAFP2up5XrFgxlwMSQgjxKFejr2K2mqVq7TEkuSbEo7hUgoSr2a5eAzh/KZjxHy3BZrPR/6lqPFkuEE7PBL+FuTu1RO+mJNTiLoElAdzqKAlCIUSGFi9eTL169WjZsmW6bQ4ODukSaUajMV0SLjM0Gk26RJ0QopCIilI6hJYqBTqdvaMpGlQq0GqVKsAsshTSqsHg4GCmT5/O0aNHcXNz4/XXX2fQoEEAXL16lUmTJnH8+HG8vLwYP348LVq0sHPEQgihiEqKIjQ2VNZaywRJrgnxKDpXcPGGmLPZTq41qPcEA/q8wFfrtzN6vYa/x+hQRRyA0J+h4gu5G6/GEZwqQOINMMeDW93cq5ATooj55ZdfiIiIoFGjRgApybSdO3fy/PPPExERkWb/iIgIypQpk+XraDQaNBpNzgMWQuQvsxmuXlWmMRqyX8EuHqBWg0ajPIoBq9XK4MGDqV+/Plu3biU4OJjRo0dTtmxZnn/+eYYNG8YTTzzBDz/8wO7duxk+fDg7duzAy8vL3qELIQRXo69iNBtxdnG2dygFniTXhHgc54oQH6x05NS5ZusUMz4cysZtuzhw9AKbgjrSs8pOOPcZlH4SHD1zN161Vml0kBwBkQFQohYYfGQdNiEesHbt2jRroc2bNw+AMWPGcPjwYVauXInNZkOlUmGz2Th69ChvvfWWvcIVQuQXoxHi4iAyEm7dUqaDCpFNERER1K5dm6lTp2IwGKhSpQrNmzcnICCA0qVLc/XqVb777jucnZ2pVq0aBw4c4IcffmDEiBH2Dl0IUcxFJ0VL1VoWyN22EI+jMyhNAnLQOdSrvCcfjPwfAB8sO0GSUy0wx8LpWbnXPTQ1lUpJ2mldlHXYwv+BqDNKg4bkSLAk5f41hShkKlSogLe3d8rDxcUFFxcXvL296dSpEzExMcycOZNLly4xc+ZMEhMT6dy5s73DFkLkhYQEuHlTaVwQEABHj8KVK1CyZLGpsBJ5o0yZMsyfPx+DwYDNZiMgIIDDhw/j7+/PiRMnqFOnDs7O9ytC/Pz8pDO1EKJAuBZzjURTIi56F3uHUihI5ZoQmeFUAeKCwRST7XXM3nv7dZav3kLw1RssONiGDxpcgvC/4PpO8OqUywHfpXNV1mEzxUDcbSWRp1KD2lFJGupLKf9qXUDjLE0QhLjLYDCwfPlypkyZwqZNm6hZsyYrVqxIcwMkhCjErFalOi02VllcPyYGkpKUKYsuLlCmjPKxELmobdu2hIWF0aZNGzp27MisWbPSLTfg4eHBjRs3snRe6UothMhtscmxhNwJwV3vXujWu7RarFgslmz/XsxuV2pJrgmRGToDGLwh6jRoXbPViMDZ2ZHZk4bR7+0pzFmxg5E/9sfp6io4Oxc8moKDRx4EDqj14JCqbbLVDNYkpXIuOVy5wVBrlfXatC6gcwedi5KA0zgoz6sdcrf5ghAF0Mcff5zmc19fX7Zu3WqnaIQQWWKzKWuk2WxgsShjm9Wa8cf3ulUmJCgdK/V6JaHm7i5jnchTCxcuJCIigqlTpzJ79uxc60wtXamFELktODqY23duU85QjhgKV6fsxLhE7qjvcCM5a29U3JPdrtSSXBMis5wrQnyIUgWmd8vWKV7r3pkTpy8yuN/LOFWtANF/Qcx5OPMJNJqTywE/hFoLagNoUy3OfC/hZopV1mqzWQEbqHWg0itJNl0J5Rit093E292HWn6NCCGEsBOrFcLDlcYDJpOSQLPZ0ibUMuLkBG5u0gFU5Kv69esDkJyczJgxY3jllVdITExMs092OlNLV2ohRG6KN8ZzK/EW7s7uhbIpl1qjRqPN3u/FnFTpyV2xEJmldVE6h0adUhJN2Xh3W61WM2/6qPtP1JsMB/rBzb1wYzeUa5978WYpsAwSbnA36ZYMViMkhoHVdHeDCjR6JfGmdbqbeHNJlXC7W/EmTRSEEELklZgYCAmBGzeU6jMHB9Bqlemc9x4qlUzvFHYVERHB8ePHad/+/t941atXx2Qy4enpyeXLl9Ptn9XO1NKVWgiRmyKSIki2JlPKuXA2MlBr1Hb5vSjJNSGyIqV6LRr07jk+3aUIZ6pXHQCBq5TqtVJNcuW8uUatvVuZ9sAiljarknCzmu5OL70NtrtZfpX6bnJNr6zjpnNLVe0m00yFEELkkNEIYWFKtVpyMnh4SAWaKLCuXbvG8OHD2bdvH2Xvdp49deoUpUqVws/Pj6+++oqkpKSUarWAgAD8/PzsGbIQohhLNCVyPfY6Br3h8TuLNOStPCGyQusMLlWU5FoOunzabDbeHvMxT/h347crdcBQDYx3lPXXCgOVWkmS6VyV9dycvcClkvJwLKtUsdmsymuKPQ+3j0LEAQjfDzf/D27tg9tHIOaCkqxMugXGaLAk5033VCGEEIWfzaZMAT15Ei5cUKrVypWTxJoo0OrXr0/dunUZP348ly5dYt++fcydO5e33noLf39/ypcvz4cffsjFixdZsWIFJ0+e5NVXX7V32EKIYupW3C3iTfGSXMsGqVwTIqucvSD+So6q11QqFc7OjthsNsZMXUz77ZPQHhmkdA71bAFenXM15HyVUu3mlH5byjRTk9JMITH0fjJNrVOaL6j1yvRUnStonJRqt3vTTNV6qXgTQojiKD5emQIaFqZM/SxXTqZ7ikJBo9GwdOlSZsyYQc+ePXFycqJv377069cPlUrF0qVLmTBhAt26dcPb25slS5bg5eVl77CFEMVQkimJsLgwXPWuqJB7rqzKdnItLCyM27dvo1arKV26dEqZsxBFntYZDD4QdUKZ8pjNZM/E995g9YafOH3uMqu2n+etFgMhcCWcngUlaoOhSu7GXRCkJN4yYDWlSrzdhMRraRNvKp2SaMsw8eYgU02FEKIoMpmUNdVCQpQunyVLKmurCVGIlC1blsWLF2e4zdvbm3Xr1uVzREIIkd6t+FvEGmMpbyhv71AKpSwl1wICAtiwYQP79+8nKioq5XmVSoWHhwctW7ake/fuNG7cOLfjFKJgcSoPcZeV9cZ0JbJ1Cnc3V6aOHcyIcXOZ/PFyeh/6Hrc7RyEyAE58CE9+rVRrFRdqnfJ4kM0GNvPdNd6MDyTeVEqyTqW7u8abi5J40zqlSrrdXetNmisIIUThYbPBnTsQHAwREWAwKNVqQgghhMh1yeZkQmNDMegMUrWWTZlKrgUGBjJ16lQiIyNp06YNn3/+OdWqVcPd3R2bzcadO3c4f/48AQEBjB07lrJlyzJt2jSqV6+e1/ELYR9aZ3CqCLHnsp1cAxjS/xUWr9rE+UvBzJ6/ho8/mAn/9IHYi3DuM6g7PheDLqRUKiV5ptaRrrEC3K14u9tcwRgBSWH3K95UGmUqqUavVLppDcp6cKmr3TQOGSf1hBBC5D+bDaKi4Pp1pWJNpYIyZUA6IQohhBB5JjwhXKrWcihTybVp06YxfPhwmjVrluH2cuXKUa5cOZ555hlGjx7N/v37mTZtGmvXrs3VYIUoUJy9ICEIzAlKsi0bdDot86aP4oU+7/L5sm8Z0r8bPr7T4cgIuLoFSvlB+Y65HHgR87CKN7i7xtvd6abGaEgKT9XVVHV3DTf93emmrqAz3E+6qfUy3VQIIfJTTAyEhsLNm2A2yxRQYTf//PMPf/31F6dPnyYyMhKVSoWnpyd16tShVatW+Pv72ztEIYTINUazkdCYUFx0LlK1lgOZSq6tWbMmSydt0aIFLVq0yFZAQhQaejdw9IKE4Gwn1wCee7YF7Vr5c/zUeS4EhuDTtjlUGwiBX8Kpmcr6ay6VczHwYuRRzRVs1vsVb5YEpUFFvCnVsbpU002d71a9OT9Q8aaXqjchhMipuDilUcH168oaa5JUE3aydetWli1bRnx8PM2bN+fpp5/G3d0dq9WaMlNnzJgxODs78+abb/LKK6/YO2QhhMix8IRwopOjKWeQ5RdyIlsNDQIDAylTpgyurq789ddf7N27lzp16tC9e/fcjk+Igs25AiSEKEkatT5bp1CpVHy5cBJuJQy4u7kqT1Z7EyKPwZ2jcHzc3fXX5EYjV6nUypp2Ga1rl2adNxMYIyHphpKQgwyq3lyU5Nu9jqapq9/UMpVJCCEyFB+vVKmFhkJSEri7g1MGb4YIkQ/69u1LxYoVmTt3Lr6+vo/c99ChQ2zcuJEtW7awfv36fIpQCCFyn9GiVK05aZ1QI2tU50SWk2sbN25k+vTpfP311xgMBoYOHcqTTz7Jrl27CAsL45133smLOIUomBw8wLEMJN8Gp+xn+r0rPTC3Xa2FBh/B330g9gKc+xzqjsthsCLT0qzzlgGb5e5001RVb1YzcK+7qfb+8VpnpfJNZ7ibbEs95VQvjRaEEMVPYqKSVLt2DRISlKRayZL2jkoUc9OmTaNq1aqZ2tff3x9/f38CAwPzOCohhMhbtxNuE5UcRTkXqVrLqSwn11atWsUnn3yCv78/M2bMoHbt2qxatYrDhw/z7rvvSnJNFC8qNThXhsQbSsJFlbMqJZvNxvZf91HRqyx+DWuD7wwIGAFXv7+7/lqHXApc5IhKoyyu/bBurilrvRmVxFtyBFgt3E++6UClfaDRgnP6xJsk34QQRU14OFy6BLGxUKIEeHnZOyIhAB6ZWEtOTub8+fP4+Pjg6uqa8ny1atXyIzQhhMgTJovpftWa3HPkWJaTazdv3sTPzw+AP/74g549ewJKU4P4+PjcjU6IwsDRE/QlwXgHHErn6FQfffolk2cvo23LpuzZ9gV4NoeqA+Dy13DqIyhRC1wq5VLgIs88cq23e1NO7ybfHmy0gOp+5ZtGd3e9N5e0yTepfBNCFEbJyRAUBEYjlC8vzWJEgXXp0iXGjx/PuHHjqF69Oj179iQoKAgnJye++OILnnzySXuHKIQQOXYr/haRSZFStZZLspxcq1q1Kj/99BOlSpUiLCyM9u3bYzKZ+Oqrr6hVq1ZexChEwabWgaEK3A4AvUeObhb69XyOGfNWsfevw/y5/witWzSB6kPgzjG4cxxOfAhPfpXt9d1EAZBmymkGjTDSrfcWBUm3Mki+pap8u5eAe7DqTa2/m+QTQogCICwMoqKgXDlJrIkCbdq0aVSqVAkfHx++//57YmNj2b9/Pz/88AOffPIJW7dutXeIQgiRI4mmREKiQzDoDFK1lkuyfNf1wQcfMGrUKKKjo+nTpw/VqlVj+vTp7Nq1i2XLluVFjEIUfI5lQeemTAHUu2f7NN6VyjPo9a588fX3TP54Oft+8kOl1kKDmcr6azHn4Nx8qDM210IXBcxj13tLXflmUirfbBF313y7K2XNN61S7ZbScOHBxNvdbqdykyuEyGuxscoaayVKgFr+iBcF28mTJ/n5558pWbIku3fvpkOHDpQuXZrnn3+epUuX2js8IYTIsWsx14g1xlLeUP7xO4tMyXJyrXnz5hw4cIDY2Fjc3NwAePvtt/nwww/R6R5yMyhEUadxVKZrRp3KUXINYMLogXz17Xb+OnCM3X8epEObJ5Xkne90CHgHQjYp66+Va5c7sYvC5XHJN7i/5pstVcMFmxms1rvHq+8m1e41XTAoCTiNo1IJ51Q2/16PEKLos9mUxFpysjQuEIWCq6srERERaLVajh8/zpAhQwA4e/YsHh4edo5OCCFy5k7iHUJjQinpUBIV8iZ7bsnWfKGEhASCgoIwm83YbLY025o2bZorgQlR6DiVh7jLYI5XEhXZVMGrDG/1f4UFyzcw+ePltG/dDJVKBZ5Pg08/CFoDp6ZDiZrgXDEXX4AoMh615huk6nZqVhJwyTch8e7nDqWUx6OSd3aUlJTETz/9xF9//cXp06eJjIxEpVLh6elJnTp1aNWqFZ06dcLJ6SGvXQiR/27fVqaESmJNFBLdunVj6NCh6PV6KlasSIsWLdiwYQNz5syR5m1CiELNYrVwNeYqFpsFJ538vZybspxc+/HHH5k6dSqJiYnptqlUKs6ePZsrgQlR6OhcwckL4oJylFwDGPfO/1ixZgv/HvmPX3f/TZcOLZQNNd5W1l6LOgnHxkKzFUrVkRBZkdLt9IHnTXFpp5cWIEajkRUrVrBmzRqqVKnCU089xbPPPou7uztWq5U7d+5w/vx5Nm7cyMcff0yfPn146623cHBwsHfoQhRvJhOEhCi/c+TnURQSo0ePpn79+oSGhvL888+j0Wjw8vLis88+o02bNvYOTwghsi08IZxb8bco7ZSzRnwivSwn1z7//HO6d+/OyJEjMRjkpl6INJwrQEIIWJKV9a2yqVzZ0gx7owe///Evzk6O9zeotdBgFhzoC7EXlASb33xpcCCKvF69etG2bVt27NhB6dKP/mMgNDSUTZs20bNnT7Zt25Y/AQohMnbrFkREQFmZbi4Klw4dOqT5/JlnnrFTJEIIkTuSzcmERIXgoHFAK03Pcl2Wv6JRUVH069dPEmtCZERfSlkfLemmMk00B6aPG8InU0agfnDhZ6dy4LcADg2B24fg5BSl4YF0eRFF2FdffYW7u3um9q1QoQLvvvsuAwYMyNughBCPlpioVK0ZDErlmhCFRGhoKPPnz+e///7LcBmcPXv22CkyIYTIvtDYUO4k3aG8qzQxyAtZTq61adOG33//nYEDB+ZFPEIUbioVOFeChDBlel0O3hFwSl2x9iC3OtBoLgSMghu7wMEDar0nXR9FkZVRYs1qtaJWq7l16xYBAQHUrFmTqlWrPvIYIUQ+Cg2FuDgoV87ekQiRJWPHjuXOnTu89tprUlAghCgSYpNjCY0Jxd3RHTVSlJEXsnznX7ZsWT7//HN+/fVXvL2903UInT17dq4FJ0Sh5OCpJLuMd8DRM8eni49PZPGqjdSpWZUXOrW6v6H0k1B/KpycCMHfgUNpqNo/x9cToqALCAhg1KhRzJ07l6pVq9KtWzeSk5NJTExk7ty5dO7c2d4hCiGiopTkmru7vPEjCp2TJ0+ydetWqlevbu9QhBAix2w2G1ejr5JsSaakozQXyitZTllGR0fz/PPPU7169XSJNSEEoNaAizdYEsFmzfHpFq74jnHTF/PBtEVYLJa0G706Qa3RyscXFsO17Tm+nhAF3ezZs+nSpQsNGjRg06ZNODg48PfffzNjxgwWLlxo7/CEEFarMh3UZALp3CsKoSpVqhAZGWnvMIQQIldEJERwPe46pRxL2TuUIi3LlWtSmSZEJjiWAZ0bmKJBn7N3B95+oztzF6/l7IUgNm7dRZ9XO6XdoUofSI6AoDVweqZyvTItc3RNIQqyCxcusHDhQpycnNi7dy/PPvsser0ef39/pk6dau/whBDh4UojAw8Pe0ciRLa8+eabTJw4kQEDBmQ4U6dp06Z2ikwIIbLGZDEREhWCVqVFr5EmeHkpWwtC7d69m1WrVnH58mUsFgs+Pj68/vrrdO3aNZfDE6KQ0jgo1Wt3TuQ4ueZWwsCYYa8zYeZSps5ZQY+u7dFqH/jRfWIEJEdC2M9wfBw0/QJK+uboukIUVKVLl+bSpUskJCRw5swZxo0bB8A///xD+fKyQKsQdmU0QnAw6PUgMxxEITV27FgApk2blm6bSqXi7Nmz+R2SEEJky43YG9xOuk05F1n/NK9lObn23Xff8cknn/D6668zePBgrFYrR48eZdq0aZhMJrp3754XcQpR+DiWBa0LmOJAl7PFcEe82ZPPvljPxcAQ1m36lf59Xki7g0oF9SaC6Q6E/w1H34Vmq8Dgk6PrClEQ9e/fn2HDhqFWq6lfvz7+/v4sW7aMxYsXS3W1EPZ2/bqy3po0MRCF2Llz5+wdghBC5Fi8MZ6QmBBc9a6oVdLEIK9lObm2atUqpkyZkqZKrX379tSoUYNly5ZJck2Ie3QGcK4IsRdznFxzdXXhg5H/Y+zUhUyft4rXundGp3vgx1ethQYfw+GhEH0KjgyHJ79SknxCFCH9+vWjSZMmhIWF0aJFCwCefPJJWrduTa1atewcnRDFWHw8XL0Krq6glj/iReGWlJTE9u3bCQwMxGKxULVqVbp06SKdqIUQhYLNZuNazDXiTfF4GbzsHU6xkOW/fG7fvk3Dhg3TPd+oUSOuX7+eGzEJUXQ4e4FaB5akHJ9q2Bs9KFvGg6DgUL7+9iGNC7RO4DdfmZKadBOOjABTTI6vLURBU6dOHdq3b4+joyMADRs2lMSaEPZksymJtaQkJbkmRCF24cIFnn32Wb744gvCwsIICwtj+fLldO7cmUuXLtk7PCGEeKyopCjCYsLwcJT1T/NLlpNrtWvXZtu2bemel3bVQmRA5w6OXpAUkeNTOTs7Mn7UALq/1J6WTzZ6+I56d2iyGBw8Ie4yBLybK8k9IQqKM2fO0KdPH+rXr0/t2rXTPYQQdnDnjjIltGTO1hkVoiCYOXMmTz/9NLt27WLRokUsXbqUPXv28MwzzzBr1ix7hyeEEI9ktpoJjg7Ghg0HrYO9wyk2sjwt9P3336d///4cPHiQBg0aAHD8+HHOnTvHsmXLcj1AIQo1lQpcq0DyTTDFgi5n7+aPGNyTkUN6PX5Hp/LQZBEcHARRJ+DISGg0R0m8CVHIjR8/HldXVxYsWIDBkLMp10KIXGA2K00MABzkj3hR+B0/fpwpU6akaSCl1Wp58803efXVV+0YmRBCPF54fDgR8RF4unjaO5RiJcvJtUaNGrFlyxY2bdpEYGAgDg4ONG3alM8//1y6tAmREX1JpbFA1GmlwUEOFpNUqVRpPrfZbOmeS+FaXZkiGvAO3DkK/w64P2VUiELs8uXL/PTTT3h7y/eyEHZnsUBQEISHQ1lZ41MUDZ6enoSEhFC1atU0z4eEhODi4mKnqIQQ4vESTYlcib6Co9YRjUpj73CKlSwn1wCqVavGhx9+mNuxCFF0uVSBxBuQHAGOZXJ8umuhN5k46wuq+VRk0phBD9+xZENo9hUEjIKEq/DvQKWCrZRfjmMQwl5q165NYGCgJNeEsDeLBS5fhitXwMMDNPJHvCgaevXqxcSJE3nnnXfw9fUF4MSJEyxcuFCatwkhCiybzUZIdAixybGUN0jhU37LVHKtX79+LF68mBIlStC3b9+HV8oAa9asybXghCgyNA5Q4gmIOASWZOXzHPjn8Em++e5nXFyceLNvV8qVLf3wnV2rQfPVcPQ9pYvo4WFQbyJUeD5HMQhhLy+99BITJ06kW7dueHt7o9Pp0mxP3c1aCJFHrFalYu3KFShVSqaDiiLljTfeIDExkXnz5hEdHQ1A6dKl6d+/PwMHDrRzdEIIkbHbCbcJjQnFw9EDFQ/P2Yi8kankmr+/f8rNS7NmzfI0ICGKLMey4FwZEoLBpVKOTtX9pfZ8tnQ9BwNOMeWT5Sz/bMKjD3DwAP9l8N9UuLFb+TfhKlQfkqNpqkLYw6pVq3B0dGTHjh3ptqlUKkmuCZHXrFYlqSaJNVFEqVQqRowYwYgRI7h9+zYODg6yxqcQokAzmo1cibqCWqWWJgZ2kqnk2vDhwzP8WAiRBSo1lKgGyeFgjMpRcwGVSsW86aNo+dwgVq39kXcG96ZOraqPPkjjCA1mgXMluPw1BH4J8SFQf2qOK+mEyE979+61dwhCFF/3EmuBgUpnUEmsiSJi27ZtdOnSBb1ez7Zt2x65r7yJI4QoaK7FXiMyKZJyhnL2DqXYylRyLSvrq82ePTvbwQhR5OlKKNM0o04onUNzsMhkiycb8vJzbdj6yx98MH0RP337+eMPUqnhiWFKBd3pmXBjFyTdhEbzwKFUtmMRIr/dunWL9evXExgYiMVioWrVqnTv3p0qVarYOzQhiq57ibXLl5XEmqOjvSMSItcsXLiQZ555Br1ez8KFCx+6n1RICyEKmqikKK5GX8XdwR01MivJXrLV0EAIkQMulZWEVlI4OOXsnYWPJw/np53/x887/+KPv47QpmWTzB1Y8QVwKg/Hx0LUybudRD8Hw2Oq34QoAI4cOcKbb75JzZo1adiwIRaLhcOHD7Nu3Tq++uor/PykYYcQuc5mg+BgJbHm5iaJNVHkpK6KlgppIURhYbaauRJ1BbPVjLPO2d7hFGuZSq5JNZoQuUitA9fqcPsQmBNB65TtUz1R3Zu3+r/C4lWb+HjB6swn1wA8miidRI+OgoRrSifRhp9AaVlXURRsH3/8Ma+//jrvvfdemufnzZvH3Llz+e677+wUmRBF1L3EWmAglCgBTtkft4QoqA4fPpyp/VQqFU2aZOHvLSGEyEM3Ym9wK/4WZV3K2juUYi9TybXFixdn+oSyJpsQmeDgCc7eEHcJNJXgER14H2fy+2/i7ubKmOF9s36woQo8uRqOjYE7xyFgJFTpC9UHKWu0CVEAXbx4kXnz5qV7/tVXX2Xt2rV2iEiIIsxmg5AQuHRJSaw5y7viomjq2zdzf0epVCrOnj2bx9EIIcTjxRnjuBJ9BVe9K5ocLDckckemkmsHDx7M1MlUOUgQCFGsqFTgWhWSboHxTo7WO/MsXZIZ44dmPxa9OzRdCqdmQtgvELQabu6GOh9KFZsokCpUqMDJkyfTra924sQJSpcubZ+ghCiKbDa4ehUuXpTEmijyzp07Z+8QhBAi06w2KyFRISSZkqSJQSqB5wNxKGufZkuZSq5JJYAQeUDrAiVqQORRpdGBOudLINpsNi5dvkqNapWzdqBaD77ToGwbODNHmSZ6ZBh4PQe13s1RZ1MhctugQYOYMmUKly9fxtfXF1ASa2vXrmX06NF2jk6IIuTaNSWx5uoqiTVR5IWFhWV6Xy8vrzyMRAghHi88PpywuDA8nD3sHUqBERwYzMh+I6lSswpLVy4F9/y9fqbu5qU1tRB5xMkLnK4rFWzOOftD7VZ4JF37juH0uUACA36ktId71k9StrWyFtuFLyBkk1LJFr5fSbB5PZej6atC5JZu3boBsG7dOr7++mscHBzw8fFh5syZdO7c2c7RCVFE3L6trLHm4qI8hCji2rZti0qlwmazZbj93jaZFiqEsLdEUyJBUUE4aBzQqXX2DqdAiI6K5sNhHxIfF4/ZbMbBIf+r1zKVXJPW1ELkEbVWaW5gvA3meKWaLZtKe7iTmJRETGw8M+atYsHsMdk7kdYAdd4Hr85w6iNlXbj/pkLYDmWqqEulbMcoRG7p1q1bSpJNCJHLkpMhKEj52GCwbyxC5JM9e/bYOwQhhHgsm81GSHQIMckxlDeUt3c4BcbXi78m7GoY5SqU471P3kPvoM/3GDKVXJPW1ELkIQcPcK4CMefAxTnb1WFqtZq5U9+hwyvDWPrVZoYP6pH16aGpudeDp9bBlXVwaaXS3fTvXlD9Tajyeq5MYxUisxYvXswbb7yBk5PTY5vsSGMdIXLgXgODyEgoJ2u4iNwTn5jIe59+ynudO1PDz8/e4aRToUIFe4cghBCPFZkYSWhMKB6OHqiQWUX3DBk9hMSERHr274lzSfssZZGpu2NpTS1EHjP4QPItSL4NjtlfkL1962Z0bv8Uv+7+hw9nLOb71XNyFpdaC1X7Q7n2cHqWkmC7sBjCfoO648C9gUwVFfni4MGD9OvXDycnp0c22ZHGOkLkUHi40sTAwwPUantHI4qQOatX8/3u3Rw7fZoDzz9PQfvuql27Nvv378fDw4NatWo9cjyRaaFCCHswWoxcuXMFtUqNg9Y+i/YXVE7OTnw460MAbsTdsEsMmUqu9e3bN80A86i1CGSwESIbtE7gWgNuHwGrUWkwkE1zpo5k595/+eGnvfxz6ARP+TfIeXzOFaHJEmVq6LnPlKmiBwdBidpQ+RUo3wk0jjm/jhAPkbqxjjTZESKPJCYq00G1WrDDWiWi6Dp16RLLNm8GYEbfvqgLYOL2m2++wc3NLeVjebNGCFHQhMaEcjvpNuVcpLIc4Mg/Rzhz4gx93+pbIH5nZyq51rlzZ/bv30+1atV49tlnad++PZUr52C6mRAiPafyShIr4WqO1jWrV7s6A197kVVrtzFm8gL+/vXL3Pllo1JBhefA82m4sERpdhBzVlmX7dwCqPA8VHoFDFVyfi0hHvC4ZjqpydqfQmSD1QpXrkBMjEwHFbnKarUy5rPPsFitvNCqFc82bmzvkDLk7++f8nGzZs3sGIkQQqQXlRRFSHQI7g7uqFUF7w2K/BYSFMKU0VOIj43H3cOdF3u8aO+QMpdc+/zzzzGZTBw4cIDdu3fTp08fSpYsSYcOHXj22WepVatWXscpRNGnUkOJGmCMBGMU6N2zfarp497i2x9+Iz4hkfCIO5TxLJVrYaJ3h3oT4IlhELodQn6AxFAI3qA8PPyh0qtQppWsyyZyzaOa6aQmjXWEyKZbtyA0FEqVkun+IlcZTSYa1qzJheBgZo0YARaLvUPKULt27TK9rzQ/EELkJ6vNSkh0CGarGWedfdYTK0hio2OZMHwC8bHx1GtYj05dO9k7JCCTyTUAnU5Hq1ataNWqFdOmTePYsWPs2bOHd955B7PZTPv27Wnfvj1NmzbNy3iFKNp0JZTpoZHHlK6d2UxOlS9Xmr93fEn9OtXRaDS5HORdenfw6ac0N4j4F0I2Q/jfyrpstw+BQxmo1BUqvgyOnnkTgyg2pJmOEHkoPh4uXwZHR5kOKnKdo4MDH7/zDh8MGEDJEiXghn3WwnmcmzdvYrFYaNiwIe3atcPDw8PeIQkhBACRCZGEx4dTyikXCyYKKbPJzNT3pnL1ylXKli/LjIUz0OvzvzNoRrJ1565SqWjcuDGNGzdmxIgRrF+/nqVLl7JmzRpZc02InHKuBMnhkBAGLhWzfZqG9WumfPzt97+x/9/j+DeuS9PGdahVo0ruJd1UavB8SnkkXoerW+DaNqVBw6UVEPgleDSDcm2hTOscVeSJ4ksa6wiRRywWZZ21hASZDipync1mS1maomSJEnaO5tH+/fdf9u3bx+7du1m+fDk1atSgQ4cOtG/fnkqVsr9chxBC5ITFauFa7DU0Kg06tc7e4djd4k8WE3AgAEcnR2YunklJj5L2DilFtpJrkZGR7N27l71793LgwAFKlizJyy+/nKVyaiHEQ6g1SvVaciQYo0HvluNTbtvxJ5t/3M0XX38PgMHFmSaNatO0UR38G9flhY6tcHDIhYy/U3llumj1N+HGXrj6Pdw5DhH/KA9mQanGULYtlG0NjmVyfk1RLPTt2zdT+0ljHSGy6Pp1pZKodPY7VQuRkT8OH2bBt98y9913qVEI1mo2GAw899xzPPfccxiNRg4cOMCePXvo3bs3Hh4eKYk2WQ5HCJGfIhIjiEiIwNNZZgL9+N2PbNuwDYAJn0ygeq3q9g3oAZlOrl26dIm9e/eyZ88e/vvvP2rWrEm7du0YMWIEtWvXzssYhSh+9O7gWh2iToDWJcdrl/Xv/TyVK5bj0NHTBJw4S1x8An/uD+DP/QHodFpig/8vZd/tv+4DoEnDOniVz+YvcbUevDopj7grcHMP3NwLMech8ojyODsH3H2hbBsl2eZcIUevURRt586ds3cIQhQ9MTFK1ZqLi9IhVIhckpiczPuff86VsDC++eknPho2zN4hZYler+eZZ57hmWeeYdq0aRw/fpxdu3bx+uuvU7JkSXbt2mXvEIUQxYDJYuJa1DV0ah0aVR4t9VOI6B30aLVaBgwfQMt2Le0dTjqZ+kuqQ4cO3Lhxg6ZNm/Liiy8yf/58ypcvn9exCVG8uVRWpocm3QJnrxydqkuHFnTp0AIAs9nM2QtXOHzsNIePniE+ITFN1dq0uSs5ekJJZJQr64Ffg9o0aVgbvwbKI8sJN0MVMLwB1d6AhGtw808l0RZ18v7j/AIoUVNJtJXvpHRNFSKVsLAwypcvj0qlIiws7JH7ennl7OdFiGLBbFYSa8nJULLgTKkQRcPna9dyJSyM8qVL88GAAfYOJ9uSkpLYv38/e/bsYd++fWg0Gho2bGjvsIQQxUREQgSRSZGUdSlr71AKhM4vd6aObx0qVy2Y1dAqm81me9xOqcufVY/pIFVYpuPExcXh5+dHQEAABoPB3uEIkbHk20pzAI0z6PL++9RmszFk9CwOHD7JmfNBWK3WNNurVqlAYMCPKZ/v//c4lSuWo1KFso/93ZBOUjjc/EN5RAYAqa7l7gtenaFcB1mjLT+Z4sBqhrKtoICt6VCrVi3+/vtvPDw8qFWrFiqVitTD173PszotNDg4mOnTp3P06FHc3Nx4/fXXGTRoEABXr15l0qRJHD9+HC8vL8aPH0+LFi0yfe5748xvv/1GiQK+1pAohoKD4fx5KFsW8qrxjSiWLgQH88wbb2Aym1k9fTrPt2qVdocbN8DPL1tJXYvFQpkyebukxK1bt/jjjz/Ys2cP//77L6VLl6Zdu3a0a9eOpk2b5l2jqGyQcUaIostoMXL8+nGSLcmUdCy+b4KF3wxHpVJRukzml6+4EXeDJzyeoLJ71pNwORlnMlW5tmbNmmydPKeMRiOzZ8/m559/RqfT8eqrr/Lu/7N33+FN1V0Ax79J2nRvSgebUmjZeyMoLlwgLsSBiiIyZcreGwFBhgoKiggOXlyIA1CWIEPZe3fQ0r2bNMl9/7hQQFQ6bpuO83mePLS3ye+e1No0557fOUOGoNPpOH78OBMnTuT06dPUqlWLyZMnU79+fbvEKUSRcfID9xBIPgoOLlDE5cA6nY4PFowFICMji0PHTnPg4AkOHDrJ/oPHaVD3xr52m83Gwz0Gk5qWgZ+vF00a1KFJwzo0bRhGkwZ1CA2pil6v//eTOftDtafVmzkZrm6DKz9Dwr4bFW0n3oYKbSH4IajYAQzORfr8Rcm1ZcsWfK69EduyZYsma9psNvr06UODBg3YsGEDly5dYujQoQQEBPDII4/Qv39/ateuzfr169m8eTMDBgzghx9+kMo4UfolJcHFi+DlJYk1oSlFURg2fz45Fgv3t2nDwx1K3radf7N06VK2bt3K8ePHCQ8Pp3PnzgwdOlR6rAkh7OJqxlVSTCkEuJffqrXU5FRG9BlBdlY2by9/m8rVSvbupjwl1+rUqYOXV/6aqqekpOT7MX83bdo0/vjjDz788EMyMjIYMmQIwcHBPPbYY/Tp04dHH32UWbNmsXbtWl5//XV++eUXXF1dC3VOIUoct+pqlVf2VXVgQHGd1s2Fti0b0bZlo9xjN1eyJSWnUr1qMMdPnSchMYXN2/ayedve3K8/9uBdfLNmfu7nB4+cIiy0Os7OTrefzOgNlbuqt+x4iPkJojdB6kmI26HeDG7qxNHgLuDbrMgTjaJkqVSp0j9+XBjx8fGEh4czadIk3N3dqV69Om3atOHAgQNUqFCBiIgI1q1bh6urKyEhIezevZv169czcOBATc4vhF2Yzep2UKtV7bUmhIbW/vgjuw8dwtXZmdmDB+e/qt2OFi1ahKOjIy1btiQoKIiIiAg+/vjjf7zvzJkzizk6IUR5kp2TTURKBG6Obuj5j2KFMiw7K5sx/cdw8exFKlSsgINjye8Nm6cIX375Ze655x6eeeYZ/P3/u9/SlStXWLduHdu2bePrr78ucGDJycmsX7+elStX0rBhQwBeeeUVDh06hIODA05OTowcORKdTsfYsWPZvn07P/74I927dy/wOYUokQxG8Kytbg+1ZKgDDuzk5ko0P19vDm1fS3a2iWMnz/Pn4ZP8dfgUfx05xaFjp6lbp2bufa/GJdKk03MYDAbCQqvRqH5tGtULpXGDOjSqF0pARb8bJ3GuANWfU2/pF9QkW/QmyL4CUd+pNyd/dVhC5e7gVqU4vwXCTvIzOCev20IrVqzIO++8A6jVFn/++Sf79u1j4sSJHDp0iLp1695ywaZZs2YcPHgwP2ELUfJERkJ8PAQG2jsSUcYoisLnP/0EwIiXXqJKKfsZ69atW6lKBgohyq7Y9FjSzGkEuZfPPveWHAuThk3i6MGjuHu6M+eDOQQGl/zXlDwl19atW8cHH3zAww8/TM2aNWnbti0hISH4+PhgtVpJTk7m1KlTHDhwgHPnztGzZ0/WrVtXqMCu90Jr2bJl7rE+ffoAMH78eJo1a5b7AqjT6WjatCkHDx6U5Joom5z9wb0mpJ4AgwvoSs4VDGdnJ5o1DqdZ4xvJD6vVSlaWKffziKhY/Hy9SEhM4djJ8xw7eZ7Pvvox9+tvDerFrIlqNVB2tonT5y4TFlodo3sNqN0PQvuq20Sjf4CYzeqghwur1ZtfK6j6JPh3KPRUVVFy+fn5kZCQQKNGjbj//vupV6+epm+C7rnnHqKjo7n77rt54IEHmDFjxm39Fvz8/IiJidHsnEIUu4wMiIpSt4P+17b9fDp96RLuLi4EF3EvLFGy6XQ6vnr7bT7btImeXbrYO5x8mzVrlr1DEEIIMs2ZRKZF4mH0QEf5S/grisLciXPZs20PRicjM5fMpGZozTs/sATI0ztRo9HIgAEDeOWVV/juu+/YsWMHX3/9NYmJieh0Ovz8/Khbty7du3enS5cumgwIiIiIoFKlSnz99de899575OTk0L17d9544w3i4uKoVavWLff38/PjzJkzhT6vECWWe00wxauJJeeSvffeYDDg7n5TxU/jcOJObyb6ShyHjp3m4JHTHDp2hkNHT3P63GVCQ25Un/15+CTtuvTGwcFAWGh1GtYLpUF4LRrWq0XDur2pFDYMXfzvELEB4ndDwh/qzckfKneDKo+Ds7zBK2t27tzJwYMH2bx5M1988QUmk4nOnTtz77330rJly//u75cHixYtIj4+nkmTJjFz5kyysrIwGo233MdoNGI2mwt1HiHsKjoasrM1nQ568NQpHuzXD51Ox4qJE0tVjy2hPUcHB3o9+qi9wyiQkSNHMnDgQKpUyVtF/MWLF1m8eDFvv/12EUcmhChPYjJiyMjJKLdVa+/Pe5+fvvkJvUHPpPmTaNC0gb1DyrN8lXm4urryzDPP8MwzzxRVPLkyMzO5dOkS69atY+bMmcTFxTFhwgRcXFzkTY8onwxO4HF9e2iWOuCgFNHpdFQKrkil4Io8dN+NiYsZGVm33O9qXBKeHm6kpmVw9MQ5jp44d8vXl8x5i369n4KAu7l6+Rin96yjnvPv+BAH55bD+Y/UKraqT4JfyxJV5ScKp3HjxjRu3Jjhw4dz7tw5Nm/ezLx584iMjKRTp07ce++9tG/fHienf+jrdwcNGqgv3CaTieHDh/PEE0+QlXXrz6bZbMbZWYZqiFIqNVVNrnl7a7rs2598gsVqBaB1g9LzB7DQjsls5tONG3nhkUcwOpasSdP50bVrV15//XUqVarEvffeS9u2bW9LtJ07d44///yT77//nitXrjB+/Hg7RSuEKIvSzelEpUbh5eRVLqvWMjMy2b1tNwAjJo+gbae2do4of0rsHioHBwfS09OZN29ebvPq6Oho1q5dS7Vq1W5LpMmbHlEuOFcEtxqQdhrcqkIZ6A3i5nZrkrDbw51Ifug3IqJiOXzsDEeOn+XwcfXfk2cuUS/sRlnwj79foFf/TQAEV/SgfmWoH5BGvcq/Ub/KbzSoXQmXWk9ApcfUoQmizAgJCSEkJITXX3+d2NhYvv76a0aOHInNZuOvv/7K0xrx8fEcPHiQe++9N/dYrVq1yMnJwd/fn/Pnz992/4KO5hbCrhRF3Q6akwMu2l2YOXr2LD/u2oVOp+PLuXPxu5a4UxSF0YsW8WC7dnRq3lyz84mSacnnnzPjww/5bvt2vl6wwN7hFFi7du345ptv2LhxI+vWrWPSpEkYjUa8vLyw2WykpKSgKAoNGzbkqaee4pFHHsGxFCcThRAlT1RqFNmWbHyctaswL01c3VxZtHoRf+z4g/sfvd/e4eRbiU2u+fv74+TkdMtUuBo1anDlyhVatmxJfHz8LfeXNz2iXNDpwCMEzPHqFlHn/x4wUlrpdDqqVg6kauVAHnngxhYjk8l8y/a/HIuFqpUDuRwZQ/TVNKKvws83rbNpZBQPWhfBmfc5mNmeQ8nh1G3YgvDaNW7ZtipKp4iICLZs2cLWrVv5888/qVGjBp07d87z4yMjIxkwYADbtm0jIEDdan306FF8fX1p1qwZH330EdnZ2bkXbg4cOECzZs2K5LkIUaSSkyE2VtPtoADzV68G4PF77rklifbLnj2s2LCBFRs2cH+bNkx+4w1Cq1bV9NyiZIiMjWXBp58C8NxDD/3r/XQpKRh37sS4bRtkZZH2ySea/zxqwdHRkW7dutGtWzdSU1M5ceJEbhucChUqUKdOHTw8POwdphCiDErJTiEmPQZvJ297h1LskhOT8fb1BsDL26tUJtagBCfXGjVqhMlk4sKFC9SoUQOA8+fPU6lSJRo1asTy5ctRFAWdTpc75a1v3752jlqIYuDgom4PTTwAOengWPgeh6WFk9Ot28F7P9+N3s93IzU1neOnLnD05LncraTHTp6lXufnwPwzpJ7if99vYeqGLbmPrVo5kLp1alK3Tg3q1qnB4w/fja+PV3E/JZFPBw8eZOvWrWzZsoWLFy/StGlTOnfuzPTp0/PcJ+e6Bg0aUK9ePcaMGcPo0aOJiopi7ty59O3bl5YtWxIUFMTo0aPp168fv/76K4cPH2bmzJlF9MyEKCLXq9YsFijAlul/c/LCBb7dtg2Aoc8/f8vXWtSrR58nnuCjr7/m59272bp3L70ff5wRvXrhLYmJMmXC0qVkmUy0adSIJ2+qAgbQJSfnJtQcDxxAZ7MBoDg5ocvMRLFHwPng6elJq1at7B2GEKIcUBSF6LRocmw5uDiWrtY/hXXs4DGGvzac14e+Trdnu9k7nEIpscm1mjVr0qlTJ0aPHs2kSZOIi4vjgw8+4I033uDBBx9k3rx5TJ8+nR49erBu3TqysrLoUgonEwlRIC5B4BkOKcfUnmIO5bsKy9PTndYtGtC6xT/0+1FehKQ/qXbgbe6pd4bjURCTDJcjY7gcGcOPW34HoGPbZrnJtTVfbuL3vYcJC61GeO0ahIVWp1JwRU2nU4r8GTt2LNu2bSMzM5P27dvTp08fOnbsiHch+kcZDAaWLl3K1KlTeeaZZ3BxceGFF17gxRdfRKfTsXTpUsaOHUv37t2pVq0aS5YsITg4WLsnJURxSExUq9Z8fTVddsGaNQA81rEjYdcugl7n4+nJjIEDeblrVyYuW8bPu3fz/ldf8cXPP/PWSy/x0mOP4eBQYv8EFXm0/cABvt22DYNez6xBg9DpdGpCbccOjL/9huNff+Um1AAsISGYO3XC1LAhiuw2EUKIXMnZycSkxZS77aAXz15k1BujyMrMYve23Tz2zGOFHlJmTzpFUfJ94SgtLY1vv/2WCxcu0K9fPw4dOkRISAhVNS75T0tLY+rUqfzyyy+4uLjQs2dP+vfvj06n4/Dhw0ycOJFz585Rp04dJk+eTN26dfO8dnp6Os2aNePAgQOaTDcVotgpNkg9BSknwaUiGKTn4B1lXIKLa0k89S0nIswci4LjMS6cTqrId19+iMHZG4DnXh/HZ1/9eMtD3d1cCQutTlhoNRbNGoGPtydAbgVtmZCTDjYLBNwF+pLVRyYsLAwHBwfq1auH0Wj8z+/5J598UoyR/bvrrzM//vgjnp6e9g5HlEc2Gxw9CvHxoHEy42J0NAs/+4ze3bpR/28T3P/u1337GL9kCScvXiSkShV2rlyJoyTXSrUci4WOvXtz+tIl+jz8MPPq1FETagcP3ppQq1VLTah17IjtenVxTAw0a1agbaFWq1XawNxEXmeEKP1sio3jV48TmxFLgFuAvcMpNpGXInnzpTeJvxpP3UZ1mbdiHi6u2lTtxaTHUNuvNlW985+fKszrTL6Ta6dPn6ZXr14EBQVx+vRpNm3axNKlS/nxxx95//33admyZYECKW6SXBNlgs0KKcch7Qy4BoHeeOfHCDAnQ8R6uPwFmBLUYwYXqNwVqj/Hxh3n2LnnICdOX+DkmYucvRCJ9do0PAcHA5mRu3B0VN8YvjJwMtt+/5M6tapRp1Y1aodUy/04OMi/dCXeSnBy7d13383z93LAgAFFHE3eyJseYXdxcXDoEFSoAHZOZlksFlZv3EiVwEDuvbbVzpyTw4kLF2hUu7ZdYxP5t2z5csavWYO/wcApq5Wb02SW0FBMnTph7tgRW+XKtz9YkmuakdcZIUq/+Ix4DscextvZG6OhfLyXu3zhMkNeHkJCXALVa1Vn4ccL8fLWrj2PvZJr+f5La9q0aTz77LMMGjSIJk2aADBz5kx8fX2ZM2cOX331VYECEUIUgN4AXmFqQiTzArhUAr1UA9yR0RtCekONFyD6J7i4BtLPwqV1cPlLHg5+iIeHvaxOZAXM5hzOXYjkxOkLxFxNyE2sARw/dYHzF6M4fzGKTZt/v+U0Xp7uxJ3efMv9RcEMHDjQ3iEIUbpYLBAZqSbVNEys2Wy2Am3ZcHBw4OWuXW85tvKbbxi7eDFP3nsvY199lSqBgVqFKbSmKBjOnFF7qO3YwZMXLrAd6HEtsWapXRtTx47/nlATQghxG6vNSmRaJDp05Saxdun8JYa8PITE+ERqhNZg/ofzNU2s2VO+/9o6cuQI06ZNu+14jx49WHOt/4YQohjpHcG7LmCBzEhwrQQ6g72jKh30Rqj8KFR6BBL+gAufQMJeiPoOojZC0P1Q82WMHiGE16lBeJ0aty3xzafzOHnmIqfOXrrlduFSNL4+XpJY00ivXr0YMGAALVq0yNP9f//9d5YtW8bqa9MMhSh3EhLUm7+2U6WHzZ9PSloao3v3LvQE0MtXrgDw1ebNfLdtG32efJI3e/bES4YelAwWCw5HjqgJtZ07McTG5n6pjl7Pd40akdO+PUkdOmArA9Vk99xzT54rpLds2XLnOwkhxB0kZCUQnxlPBZcK9g6l2OzetpvE+ERCaocw78N5uVNCtWJTbESmRRLqG6rpunmR73d9vr6+XLhw4bb+an/++Sd+fn6aBSaEyAeDE3jVv1bBFn0twVZ6m0EWO50OKrRWb8lH4NxHELcDrvyo3gLuhpq91SrBvwmo6EdART86tmt2y3GzOYfYuITczy9cimLt+p8YPeTl0rVVtIQYN24cU6ZMISEhgXvvvZe2bdsSEhKCj48PNpuNpKQkTp06xYEDB/jhhx/w9/dn4sSJ9g5bCPvIyYGICDAawaDdxZbLV66wdtMmLFYrbzz9dKHXmz5wIE8/8AATly1j519/8e7atazZuJERL71Er0cfxehYsranl3lmMw6nT+Nw5AiOhw/jcPQo+rS03C8rTk6kN28OHTuS07o1ShnbhnhzhfTly5f5+OOPefbZZ2nQoAGOjo4cP36cTz/9lF69etkxSiFEWWG1WYlKi8JB54BDOdp59MxLz+Ds7EynBzvh7eOt6domq4mJuyey58oexueMZ3CLwZqufyf5/q/42muvMW7cOPr27YuiKOzZs4cNGzbw8ccfM2TIkKKIUQiRFw4u4N0AkiyQFa1uEZUkTv55N4BmCyD1JJxbCbFbIfZX9ebfTk2y+TS84zJGoyNVKqlbnNLTM7nrkT5ERseSbTIzZXTfon4WZU5oaCirV69m3759rFu3jsGDB5OamnrLfby9vWnXrh3Tp08vNf0/hSgScXHqlFCNt1kuWrsWi9VKx2bNaFGvniZrNqpdmw3z5/PLnj1Meu89Tl+6xOhFizh69iwLR47U5Bzin+nS0nA4fvxGMu3ECXQ5Obfcx+bpibltW8zt25PdpAn3DRlCs2PHGNumDd72CbvIPP7447kfd+/enenTp9OlS5fcY507dyY8PJx33nmHfv362SNEIUQZkpiVSEJmQrmoWou4GEGFihVwcXVBp9PR7dlump8j05LJuF3j+PPqnzjqHQnzvb0ooqjlO7nWo0cPKlasyIcffoizszNz5syhRo0aTJ06lYceeqgoYhRC5JWjO3g3hKS/IOsKuAbbO6LSyzMMmsyG9PNwfqXamy1ul3rzbaH2bPNtlqcEpru7K6MG92LAW3OY+vYKPNxdGTHwxWJ4EmVPixYtcreGRkZGkpiYiE6no0KFCgQFBdk5OiFKALNZrVpzcQENx9lHXb3Kmh9+AGDYi9r+/tLpdNzfpg33tGjBmi+/ZO6nnzI0KgrvZ59FcXYmx9UVg5sbipsbiqvrjdv1z93csFWogCUkBFxdNY2tzMjJwXDpEobz53G8llAznD+P7m9zzWze3uQ0aIDl+i00NLdn38dff83h06e5FB3NWy+/bI9nUWwuXLhA7X8YtFGlShWioqLsEJEQoiyxKTai06IxYCjzVWvnT59nyCtDqBlak5lLZ+Ls4qz5OdLMaYzaOYpjCcdwcXBhRNMRhPuFa36eOynQf8l77rmHe+65R+tYhBBaMHqpCbbEPyE7FpzLz0jnIuFeExpOhZA+cGEVRH0PifvUm09TqNUH/JrfcZn+rz5NWnomo6cuZuSkRXi4u9L35SeLPv4yrHLlylSWxtlC3Co2FlJSNK9ae3ftWnIsFto2akTbRo20W1hRMJw/j3HXLhx372boiRMMAIyHDuXeZRAQCcwE/qteTtHpsFWujKVWLSy1a2MNDcVSqxaKt7d28ZZ0ioIuIQGHc+cwnD+f+6/h0iV016Ze38xaqZKaTGvYkJwGDdRhBP9w0Sg+OZnpK1YAMKZ3byqU8e9ps2bNmDFjBjNmzCAgQP07KiIigmnTptGhQwc7RyeEKO2SspKIz4zH18XX3qEUqbMnzzK091BSk1PJyMggx5yjeXIt2ZTMiO0jOJN8BndHd+Z0mIOvk32+r3lKri1evDjPCw4YMKDAwQghNOLkq25dTPwLTAngJP0QC82tCtQfDyGvwYWPIeJrSPoT9vVVK9hq9VH//Q+j3nyJtPQMZixYSb8Rs3F3c+X5p6XiVwihkexsdUKou7umVWsxCQms/v57AIZr0W8qJwfHQ4dw3LUL4++/39IoH0AXHk5mmzbkNGxIUkoKK6dOJdtiYaNOx/OhoYwLC6MKoMvMVG8ZGeijojDEx2OIiMAQEYHTr7/mrmf191cTbddu1ipVsAUGgpNT4Z+LPZhM6BMSbtzi49FfuYLD+fMYzp1D/7ct89fZ3N2xhoSoyceGDcmpXx8lj/2Sp69YQUp6OvVDQuj16KNaPpsSacaMGQwaNIhOnTrh5eWFoiikpqbSpk0bpk6dau/whBClmE2xEZUWhQ4djvqy21v0zIkzDOs9jNSUVMLqhzF3+Vw8PLUdWJSQlcCw7cO4mHoRbydv3r7rbWp51yImPUbT8+RVnpJrf/zxR54WkybdQpQgzhWv9WD7C8zJYPS2d0Rlg0sg1H0Lar4E51epSbbEA7D3dfBtDrVeB98m//rwaWP7kZaeybvLP+elAZOp4OfNg53bFlf0QoiyLDYW0tJA4y3Sy9evx5STQ8v69enQ5N9/v92J4dIlXFatwvGPP9BnZuYeV4xGcpo3V3t7tWlzS8LHA/i1Rg1mrFjBd9u388np03xx8SKvPfEEg197De+bJovqkpJwOHMGw5kzOJw9i8Pp0xiiojDExWGIi8P4+++3xGPz9cUaGIgtKCj3X1tgoPpxxYrqQIjioCiQlYU+NRVdair6lJQb/15Pnt38701DBv5xOb0ea5UqWGvWVJNp1/61VaxYoF6sf508yacbNwIwa/BgHBzK9hYmgIoVK7Ju3TrOnj3L2bNnAbX3Z0hIiJ0jE0KUdslZycRlxOHj7GPvUIrM6eOnGdZ7GGmpaYQ3DGfO+3M0T6zFZMQwdNtQojOiqeBcgXkd51HNs5qm58ivPL06rl69uqjjEEIUBddgsJkh6SA4uEEZvjpS7JwD1CRbjV5qki3ya0jcD3v3g19LtZLNp/FtD9PpdLwzYxhp6ZkcOnaaZo2Kvx+AEKIMysxUq9Y8PDQfZjP0hRfw9fKiYe3aBbuQarXi/NVXuK5Ykdsw3+bri7lNG8zt2pHTtCk4//s2kdCqVVk5ZQr7jx1j8gcfsPvQId5du5ZPvvuOlVOmcFfTpgAoPj7ktGxJzk0DTXQZGRjOnVOTbqdP43D2LIboaHRZWegTE9EnJsLx47edU9HpUHx91Z5uLi4ozs43bi4u8PfPHRzAYgGrVd1+abWCxaJ+fP349X8zMm5NpKWk3DZI4E4UoxFbhQrY/PzUf/39sdaooSbSqlfXrCrPZrMxauFCFEXhqfvuo3XDOw/0KSusViuRkZHExMTQvXt3Lly4QFpaGh4e2r5BFEKUH4qiEJ0WjQ4dRkMxXcApZqeOnWLYq8NIT02nbqO6zHl/Du4e7pqeIzItkqHbhnI16yqBroHM7zifYHf79xov0KWniIgIvvzyS86dO4ejoyMhISH06NEDf39/reMTQhSWaxUwxakTRF2lP5XmXAKh3qhrlWwfQeS3kLBXvfm1UivZ/jZdVK/Xs/ydsWRmZuPpqe2LjRCinIqJgYwMCNb+j0s3Fxf6P/NMgR6rj4rCfdYsHI8cAcDcqhVZvXphCQvL99bV5vXq8e0777D5jz+Y8v77RF69Sr2aNf/zMYqbG5aGDbHcnBRSFDWxFRODISYG/ZUr6r/XboaYGHTZ2egSEiAhId/PuaAUR0cULy9sXl4onp7YPD3V5Nm1BJpyPZHm54fi7l4sE8HPRUZyLjISNxcXJvYtP5Our1y5wiuvvEJKSgopKSl07tyZFStW8Ndff/Hhhx9Sp04de4cohCiFkrPVqjUvZy97h1JkjE5q0rB+4/rMfn82bu5umq5/IeUCw7YPIzE7kSruVZjXcR4VXStqeo6CyndybdOmTQwfPpxmzZpRr149bDYbv//+Ox9++CHLli2jTZs2RRGnEKKg9AbwqKX2XstJVyeKCu25BEK9MVDzZTj3EUR9Cwl/qLcKbaHOIPW/wzUODg63JNZWrvmWhvVCadZYKtn+SVhYWJ4rZk6cOFHE0QhRwqSnQ1QUaNxk3mQ2Y3R0LFi1mqLg9O23uC1bhi47G8XFhYz+/TE9/HChkkI6nY77WrfmnhYtOHXpEn7XnrOiKAydN4+7mzfnkbvuQv9fiTudDsXLC6uXF9Z/SpIoCrrkZPRXr6pJtuxsdFlZ6LKz4W+f5x7LyQEHBxQHBzAYwGBAMRjUira/f+zqeiOBdlMiDReXYkmY5Udo1ar8sXo1R86eJTCP/dnKgilTptC8eXMmTZpE8+bq0KL58+czduxYpk2bJrt6hBD5pigKV9KuYMWKk6GU9vzMgxq1ajD/w/lUrlYZVzdtJ3ifTjrN8O3DSTWnUtOrJm/f9Ta+ziVnKES+k2sLFixg2LBhvPLKK7ccX7JkCdOmTWPjtZ4MQogSxOgD7jUg+Rg4uIJOu0bX4m9cgqD+2GuVbCsh6juI/x3i90Dlx6BWX3CucMtDvvj6F14ZNAU/Xy+2ffcB9cKkp8vfffLJJ7kfHzlyhJUrV9KvXz8aNGiAo6Mjx48fZ/Hixbz44ot2jFIIO0lIUIcZ+Gjbv2XeJ5/w0+7dTHnjDTo2v/NU5Ov0V6/iNmcOxv37Achp3Jj0t97CpmEvOIPBQN2bqta2HzjA6u+/Z/X339Owdm3Gvfoqd7doUbDEoE6H4uODVePvZ2nl5+1Np3z89y8L9u/fzxdffIHBYMg95ujoSL9+/Xj88cfztVZsbCzTp09nz549ODk58dBDDzF06FCcnJyIiIhg/PjxHDx4kODgYMaMGUP79u21fjpCiBIgxZTC1YyrZa7XmqIofLbiM+o2rEuTVmpf1tp1a2t+nqPxR3lrx1tkWDII8wljzl1z8DR6an6ewsj3O+yrV69y991333b8wQcfJDIyUpOghBBFwK26OjXUFG/vSMoH10pQfxx0WA+B9wI2tS/bjsfh7HKwZOXe9cF72tCiSV0SElN4/MURZGVl2y3skqply5a5ty+//JLZs2fTs2dPGjRoQFhYGN27d2fmzJm3JOGEKBesVnWQgYuLpssmp6Xxwf/+x7Fz50jPyrrzA0CtVvvxR7xefhnj/v0oRiMZAweSOn++pom1f9I0PJwRvXrh5uLC4dOneXrkSB57803+uLYdVeTPyQsX+GHnThRFsXcoduHs7EzCP2wJvnDhAu7ued8BoCgKgwYNIisrizVr1rBgwQJ+/fVX3nnnHRRFoX///lSoUIH169fTtWtXBgwYQHR0tJZPRQhRQlxJu4JFsZSpqjWr1co7U99h+TvLGTdoHAlxRdNKYX/sfoZvH06GJYMGFRowr+O8EpdYgwIk1x555BFWrlyJ1Wq95fjatWu57777NAtMCKExgxN41gZbDlgleVNsXCtD41nQ6kPwagDWLDj7PuzorvZnU6x4errz45fvEhzoz5lzl5k8Z7m9oy7Rrl69it8/bE9ycXEhNTXVDhEJYUepqeq20Hy84c+LD9avJz0zk/AaNejSrt0d769LSMBj3DjcZ81Cn5FBTng4yStWkP3EE/nurVYQHm5uvPXyyxxYu5Y3nn4aJ0dHdh86xMMDB9Jj1Cjik5OLPIayQlEURi1axIvjxvHOmjX2DscuevTowYQJE/jtt98ANam2fv16xo8fz5NPPpnndc6fP8/BgweZOXMmoaGhNG/enEGDBvH999+zZ88eIiIimDJlCiEhIbz++us0btyY9evXF9GzEkLYS0r2tao1p7JTtWbKNjFxyES++fwbdDodvQf1xs9f+/YBO6J2MHrnaLKt2TQPaM6cDnNwc9S2j5tW8rQt9IUXXsgtq8/JyeGvv/5i27ZthIeHo9frOXPmDFFRUXTs2LFIgxVCFJJzILhVhfSL4FbF3tGULz6NoPVHELMZTi+GrCg4OgUurYM6g/Gt0Iplb4+i6/PDeHvJpzzd7T6aNgqzd9QlUqdOnRgzZgzjxo0jLCwMRVE4cuQI06ZNo0uXLvYOT4jilZQENpvaz0sjWSYTy//3PwCGvfjif/cvA4y//Ybb/PnoU1NRHBzIfPllsp95RtOY8qqCtzdT+/XjjSef5O3Vq1mzcSPnIyPx1jj5WJZ9v307O//6C2ejkSc6d7Z3OHbRv39/PD09mTRpEllZWfTp0wc/Pz9eeuklevfuned1/P39WbFiBRUq3NoOIj09nUOHDlG3bl1cXW/0JGrWrBkHDx7U6mkIIUqIK+lXyLHl4ORQNqrWUpJTGNN/DMcOHsPR6Mi42ePoeL/2uaCfLv7E7P2zsSk27qp0F+NajSvRU1bz9FdPq1atbvm83d+uYNatW1e7iIQQRUenA/cQyLoK5mQwets7ovJFp4Og+yCgI1z6As6tgLTTsL8/+LfjsfaDeLrbfXzx9S/0HjyFvb98gqNj8b85LemmTJnCxIkTeeGFF7DZbIDaf6lbt26MGzfOztEJUYwsFoiLA1dtGwZv2LqVpNRUqgQE8Ohdd/3nfZ02bcJ99mw1nFq1SB89GmuI/ftGBlesyPxhw+j/zDMkJCfjcC3RZzKbmbZiBa89/jhVi3irammUZTIxYelSAAY8+2y5/R59//33PProo7zwwgtkZmZitVrx8PDI9zqenp506NAh93Obzcann35K69atiYuLo2LFWyfc+fn5ERMTU+j4hRAlR6opldj0WLydvO0diiauRF5hZN+RRFyIwN3TnRmLZ9CwWcM7PzCf/nfmfyw6uAiAB6s/yPBmw3HQl+z3RXmKbsCAAUUdhxCiuDh6qFMrkw+BgzuU8F9SZZLeCDWeh0qPqAm2y19C3C6I282ilx/ml988OHjkND9t3c0jD3S483rljLu7O/PmzWPy5MlcuHABgBo1auSrD44QZUJqKqSlgb+/ZksqisKHGzYA8HLXrrc0dP87xz/+wG3uXACyHn+czH79wNFRs1i0EFK5MiGVK+d+vvr771n2xRes+N//eO6hhxj6/PME/y3BUZ4tXreOiNhYKlWsyKBnn7V3OHYzefJkPv/8c7y9vW+pLCusuXPncvz4cb766itWrVqF0XhrBYbRaMRsNmt2PiGE/cWkx5Bjy8HZwdneoWjiq9VfEXEhgoqBFZnz/hyq16qu6fqKorD6xGo+OvYRAE+EPkH/Rv3Rl4KBfHl6Vz169GjGjh2Lu7s7o0eP/s/7zpw5U5PAhBBFyK0KZMeCKU6dbinsw+gN4cOh6tNw+l2I/ZWA9O9Y0dsV95Bnuf/+O/c5Kq/S0tL49ttvuXDhAv369WPfvn2EhIRQtWpVe4cmRPFJTFT//Y8EWH4dPHWKQ6dPY3R0pOdDD/3r/QynTuExcSI6mw3T/feTOWiQWp1bwjUND6djs2ZsO3CAVd9+y9pNm+j12GMM7tmTgH/o5VieRMbGsuizzwCY1Lcvrs5l441gQbRq1Yrvv/+evn373pYAK6i5c+fy8ccfs2DBAmrXro2TkxPJf+sFaDabcS7H33chypp0czox6TElsvl+QfUd1her1cpzrz2Hf4B2F/dATawtPbSUL898CcBLdV+iV91eBZv8bQclP/0nhNCe3lGtXgOwZNo3FqH2wWsyF1q8B+416d40k/u91sKelyDlmL2jK3FOnz7N/fffz/r161m3bh0ZGRn8/PPPdO3alb1799o7PCGKh9msbgl107apb8PQUD6bOZPxffpQwdv7H++jj47Gc9QodNnZmJs3J33EiFKRWAM1ubZ+3jy+eecd2jRqhCknhw/Wr6d5z55MXLbstoFd5cnE994jy2SiTaNGdLv7bnuHY1cJCQksXbqUxo0b0759ezp37nzLLb+mTp3KypUrmTt3Lg888AAAAQEBxMffOsE9Pj7+tq2iQojSKyYtBpPFhKujtu0bittff/yV24rF0ejIm+Pe1DyxZlWszN0/NzexNqDxAF6q91KpSaxBHivXbq5G6969O40bN8bxb2X/ZrOZ7du3axudEKLoOFUAtxqQekpN7pSiX1xlll9zaPsZXP4cznwAKceJ+L4XR7Pa0OXFqdIj75pp06bx7LPPMmjQIJo0aQKor1O+vr7MmTOHr776ys4RClEMUlMhIwM0fiNuMBi4v02bf/26LjkZz5Ej0SclYQkNJW3KlBK3FTQv2jVuzLfvvMP2AweY+dFH7D9+nFOXLv3nNtiyrscDD3Di/HlmDhxYqt7MFIWnn36ap59+WpO1Fi9ezLp165g/fz4PPvhg7vFGjRrxwQcfkJ2dnVutduDAAZo1a6bJeYUQ9pVhzuBKxhW8nLzsHUqBKYrCmuVrWLFwBU88/wQDRg0oktcHs9XMtD+msT1qO3r0jGgxgi7VS9+Qsnw3W3rxxRfZtWsXvr6+txw/e/YsQ4cO5fDhw5oFJ4QoQjoduNeA7BgwJ4JT+d4OU2LoHaD6cxD4AEd+nEa7kTuB3Rz37Ebl1gOgyuOgK79v/oDcyaB/16NHD9asWWOHiISwg4QE9ff4HSZ5aiorC4/RozFERmINCCB11izNhykUJ51OR8fmzbmrWTO27N1L8E29667Ex/PJd9/R98kn8SpAI/vS6L7WrencsuUdp8OWB48//njuxykpKXh4eKDT6fL9pvLcuXMsXbqUPn360KxZM+Li4nK/1rJlS4KCghg9ejT9+vXj119/5fDhw9JiR4gyIjYjluycbHzcfewdSoFYrVYWTV/EN59/A3BbcZVWsixZTPh9Avti9+God2R8q/HcVfm/hymVVHl69fzss88ICwsjPDwcRVFo164d4eHht9yeeOIJWrRoUdTxCiG05OAKHrXVraG2HHtHI27mXIG6j86jXlhN0rLhjQ/SUY7Ngt29IKl8X8Tw9fXNHWRwsz///BO/ct4zSZQTJpOaXNNwS6jVauXBfv2YsWIFqenpt9/BYsFjyhQcT5zA5ulJ6pw5KGXk/zedTse9rVpRt2bN3GML16xh7scf06RHD2atXElyWpodIyxaFosl92NJrKkURWHZsmW0atWKNm3aEBUVxYgRI5gwYUK+Bg5s2bIFq9XKsmXLaN++/S03g8HA0qVLiYuLo3v37nz77bcsWbKE4ODgInxmQojikGHOIDotGg+n0nlxJjsrmwlvTuCbz79Bp9MxaMwg+g7vq3nVWpo5jRHbR7Avdh/OBmdmtp9ZahNrkMfKtZ49exIaGorNZqNXr14sWrQIL68b5Y06nQ4XFxdq165dZIEKIYqISzC4xkBWNLhWvvP9RbExGAysWDKTJp2e4/u/LHy+14kerU7CH69ApUehzuByuVX0tddeY9y4cfTt2xdFUdizZw8bNmxg1apVDB061N7hCVH0UlIgM1PTLaGb//iD/cePcy4ykiEvvHDrFxUFt3fewbh7N4rRSNqMGdiqVdPs3CVRh6ZN2XXwICcuXODtjz/m/a++ok/37vR96il8PMtOY+qk1FTu69uXVx9/nFcffxwHB5kgDrBkyRI2btzIrFmzGDJkCKBWs02YMIE5c+Ywbty4PK3Tp08f+vTp869fr1atGp9++qkmMQshSo6rGVfJzMkk2L30JcuTk5IZ038Mxw8dx9HoyLjZ4+h4f0fNz5OYnciI7SM4l3IOd0d3ZneYTT2/epqfpzjl+fJUixYtaNWqFVu2bOHee++lZcuWhIaGUqdOHVq0aEH9+vU1m6YjhChGeoM63EBvhJx/qFYQdlUvLISxQ18BYNAaZxLc1UbIRH0HO5+CKz+DotgxwuLXo0cPJk+ezA8//ICzszNz5sxh586dTJs2jeeff97e4QlR9BIS1O2gGlYZffT11wD07NIFFyenW77m8sknOH//PYpeT9r48Vjq19fsvCXVwx06sO3DD/lo0iTq1qxJWkYG81avpkmPHsxfvdre4Wlm1kcfcTE6ms82bbJ3KCXKhg0bmDJlCnfffXdupUa7du2YPXs2m+R7JYT4D5nmTLVqzVj6qtasVivDXhnG8UPH8fD0YN6KeUWSWItOj2bA1gGcSzmHj5MPCzstLPWJNSjAtNCgoCAWLlxIu3btaNu2La1bt6Zjx4588MEHRRGfEKI4GH3AvSaYEkCx2Tsa8Tej33yZ+uEhxCWkMGSNAVp9BO4hYE6CQ2Pgr+GQHX/nhcqIffv2cdddd7FmzRr27NnDvn37+OKLL7j33nvZvHmzvcMTomhlZanJNXd3zZY8HxnJlr170el0vPTYY7d8zWnjRlxXrgQgY/Bgcjp00Oy8JZ1er+exTp34bcUKVk2ZQv2QENIzM8vMFtFj586x8ttvAZgxcKBUrd0kISHhH6d2enp6kpkpU9aFEP8uOi2ajJwM3I3avU4XF4PBQK9+vQiqHMTiTxfTsFlDzc9xLvkcA34dQHRGNEFuQSy+ZzEh3iGan8ce8p1cmzlzJhs2bGDYsGF88803bNiwgQEDBrB69WoWL15cFDEKIYqDW3VwrgDZV+0difgbo9GRFe+MR6fTsfqLH9h8KAvafgohr6nDDa5uU6vYIr8rF1VsL774IqmpqbcdP3PmjGwLFWVfSoqaYHNx0WzJ6wmWzi1bUqNSpdzjjrt34zZvHgCZzz+PqWtXzc5Zmuj1eh656y62Ll/OJ1OnMqBHj9yv7Tt2jKkffEBCcrL9AiwARVEY8+672Gw2unbqRPtrk5eFqnXr1nz44Ye3HEtPT2f+/Pm0atXKTlEJIUq6VFMqUWlReDt5o6P0TF02mUy5H991312s+nYV1UK0b/9wJP4Ig38bTGJ2IjW9arL47sVUcq905weWEvm+RPXNN9+wePFiWrZsmXssLCyMSpUqMXz4cAYMGKBpgEKIYmJwAs9wSNwH5hQwlt6x0WVRq+b1Gdb/efQ6He1aNQK9I4S+DoH3wJEpkHoCjk6GmJ+h3hhwCbJ3yJr67LPPmDJlCjqdLnewzj9p27ZtMUcmRDGLiwNHR3VSqAYys7P57IcfAHilW7fc4w4nTuAxeTI6m43sBx4gq3dvTc5Xmun1eh76W+Xe7JUr+W3/flb873/0euwx+j3zDIGlYNDDt9u2sevgQZyNRib17WvvcEqcSZMmMWDAANq1a4fJZKJfv35ER0cTHBzMsmXL7B2eEKIEUhSFyJRIcmw5+DmW/NeB6zZt2MSqpatY9PEiAoIDAHD6W3sILey5soeJuydispqo71efme1nlsqts/8l38k1Z2fnfxzD6unpqfn0CCFEMXP2B48wSD4MBmc14SZKjDmTBt3+e9YjFFqvhItr4Oz7EL8bdj4DdQZClSdAVzYmv8lgHSGAjAxITtZ0S+iGrVtJSU+nWlAQna9dONWlpeExfjy67GzMLVqQMWKEZsm8subV7t1JSk3l0OnTLP3iCz7csIHnHn6YgT16UCUw0N7h/aPM7GwmXksQDerZs8TGaU+BgYF89dVX7N69m/Pnz2OxWKhRowbt27eXiapCiH+UmJVITHoMPs4+9g4lTxRFYfX7q/no3Y8A+P6r7+k9qGgupP1y6Rdm7ZuFVbHSOrA1k9pMwtnBuUjOZU/5Tq6NHDmSMWPGMHLkSJo0aYKDgwMnT55k+vTp9OrVi+jo6Nz7yihpIUoh9+pgSYW08+BWpcwkZ8qCmxNrVquVmNgEKgVXBL0D1OwFFTvC0amQfAiOz4Yrv0D9ceBW1Y5Ra6dFixYAbNmyBUdHRzIyMqhRowYAP/zwAy1atJDBOqJsS0mB7Gzw0e4P95b16vFy166EVa+OwWAAwPX999HHx2OtXJm0yZNBenH9qwfbtuWBNm3Ysncv81evZu/Ro3z09dd88t13DH7uOUa/8oq9Q7zN74cOcSUujsoBAbdscRU3jB8/nocffpjWrVvTpk0be4cjhCjhrDYrEakR6NDhVAqKE2w2G4tmLOLrtV8D8Nxrz/HKwKJ5vVp/Zj3vHnwXgPuq3sdbLd7CQV82/67I97MaPnw4AG+88UbuGz3lWo+fEydOsGDBAhRFQafTceLECQ1DFUIUC50ePMMgJwOyYsBVkuQlzYVLUTz72ljSMzL589c1GI3Xqondq0Or5XD5Szi9GJL+hF3PQmhfqN5T7c9WBly+fJn+/fvz0ksvMWjQIAA++eQTJk6cyHvvvUezZs3sHKEQRUBR4OpV0DiBHFqtGnOHDMn93OGvv3D+/nsA0keMAFdXTc9XFul0Ou5t1YrOLVuy6+BBFnz6KdsOHKDSPzTELwnubdWK31asICElBVfnslc5oIXMzEz69++Pi4sLDzzwAA899JC8tggh/lV8ZjzxmfH4u/rbO5Q7yjHnMGPMDH7d9Cs6nY6BowfS/bnump9HURRWHlvJJyc+AeCJWk/Qv3F/9GW4cCPfybUtW7YURRxCiJLE4AzedSF+nzqR0lg6ypvLC08PN85djCQ+IZm5737C2GE3lXDr9FDtGfDvAMemQcJeOLUQYn+FBhPBTfvmpMVt9uzZ9O3blz59+uQeW7duHe+//z4zZsxg/fr1doxOiCKSkaFWrmm4JfQ2JhPub78NQPZjj2Fp1KjozlUG6XQ62jdpQvsmTThw/Dj1a9XK/dqnGzfy8+7dDHn+eZqEhdkxSlV4zZr2DqFEmzdvHmazmZ07d/LLL7/Qr18/XFxc6NKlCw899BANGjSwd4hCiBLCbDVzKfkSRr0RQwm/kJ2ZkcnENyey7/d9ODg4MHrmaDo/1Fnz81gVKwv/XMi359WBSa/Ue4UXwl8o823E8p02rFSpEpUqVSIzM5Pjx4/j4+ODzWYjODg492vXb0KIUszoA17hagWbJcve0Yib+Pl68870YQBMnfchZ85dvv1OrsHQfIm6LdTgpvbR29UTLq4FxVbMEWvr4sWLPPjgg7cd79KlC2fPnrVDREIUg+RkMJlAoybD8cnJ9J85k33HjuXuQHBdtQpDVBS2ChXIvCl5LfKvWd26OF2rMlQUhUVr1/LDzp3c17cvT40Ywc6//sr9vhcHRVGYuGwZuw4eLLZzlnZGo5F77rmHmTNnsmPHDnr27Mnnn3/O008/be/QhBAlSGxaLMmmZLydve0dyh3ZbDYSExJxdnFm5tKZRZJYy7HlMG3PNL49/y06dAxpOoQX675Y5hNrUIDkWkpKCi+99BJdu3Zl8ODBJCQkMH36dB555BGioqKKIkYhhL24VgaPWpB9FWwWe0cjbtLzyQe5/+7WmExmXh8645/fpOl0ULkbtP8c/FqCzQQn58HevpAZWewxa6VmzZps2rTptuNbt26latWy0V9OiFvYbOqWUA238K3ZuJHPf/qJ0YsWodPpMJw+jfPnnwOQPmQISlFWyJUzOp2ONdOn88wDD2DQ6/l13z66DRnCg/368cOOHdhsRXvBQ1EURi1cyJLPP6fn6NHEJycX6fnKCqvVyu+//86kSZO45557WLVqFY8++igff/yxvUMTQpQQWTlZRKZF4u7oXiq2O7p7uDPn/Tm8s/IdWrRrofn6mTmZjN45ml8jf8VB58CE1hPoGtJV8/OUVPn+CZg2bRouLi7s2bMnd0TrjBkzCAwMZNq0aZoHKISwI51OnUbpWkntv1aMV9nFf9PpdCx7exQuLk78unM/n6zb+O93dglUq9jqjgKDy41ebJe/KpVVbG+++SbvvvsuL774IrNnz2b27Nm88sorzJ8/P7cvqBBlSno6pKZqtiXUarWy6lt1q0bvbt3AYsF9zhx0Nhumu+8mp107Tc4jbgitVo0lo0ezd80aXunWDWejkQMnTvDi+PGMWLCgyM57PbH24ddfo9PpmDloEBW8vYvsfGXFqFGjaNu2LYMHD8ZkMuVWr02ePJmW16bqCiHElfQrpJnT8HDysHco/+rSuUt898V3uZ/7+fsR1kD79gRJ2UkM2TaE/bH7cTY4M7P9TO6ucrfm5ynJ8p1c27FjB0OHDsXT0zP3mK+vL6NHj2bfvn2aBieEKAEMRnV7qKM7mOLtHY24Sc3qlZk44jUAho5fQFx80r/fWaeDqk9Cu7Xg0xSsWXB8FuwfoCZOS5G77rqLDRs2EB4ezvnz57l8+TJhYWFs3LiRjh072js8IbSXnAw5OZoNM/jljz+IiI3Fx9OTbvfcg/Pnn+Nw9iw2Dw8yBg7U5Bzin1ULCmLOm2/y57p1DHn+eTzd3Hji3ntzv56SlkZGljatGBRF4a2bEmuLRo6kZ5cumqxd1pnNZqZPn86uXbuYOXMmHTp0yJ2mK4QQAGmmNCJTI/F28kZHydzyeOLwCQa+OJB5k+fx20+/Fdl5rmRcYeCvAzmVdAovoxcLOi2gRaD2lXElXYFmoJpMptuOJSYm4iCj2oUomxw9wasuJB4ASzo4yHahkmJov+f5bP1PODo4kJyShn+FOwyfcK0MLd+DS1/A6XfVgQc7n4HwIVBR+74LRSU0NJTRo0eTkpKCu7s7er2+XPRyEOWQ1ar5ltCPNmwA4LmHHsLt6lVcV60CILN/fxRfX83OI/5dRV9fxr76KoN79sTNxSX3+LzVq1n744+81r07rz7+OL5eXgVa/3pi7aObEmvPSmItz+bPnw/Arl27OHfuHDabjRo1atC2bVscHR3tHJ0Qwt4URSEyNRKzxYyvc8l83dy3ax/jB48nOyubsPphNG7ZuEjOczb5LCN3jCQxO5EA1wDm3jWXqh7ls01LvrNhjzzyCNOnT2fKlCnodDoyMzPZs2cPEydO5KGHHiqKGIUQJYFLEHjUhpRjoHcCvfxxWRI4Ojqw6fNFBFT0zftVdZ0eqvcA/7ZwZJI67ODoNPD7BeoMKdJ4taAoCu+99x6rVq0iLS2Nn376iYULF+Lq6sq4ceMwalTdI0SJkJambgnVKOl1LjKSrfv2odPpePnRR9XtoDk5mFu0wPTAA5qcQ+Sdu6tr7sc2m40df/5JUmoqc1atYvG6dTz/8MP0ffJJqgYF5WvdTzduzE2svfvWW/T4hyEw4t/FxsbyxhtvcOHCBWrUqIHVauXSpUsEBwezcuVKAgIC7B2iEMKOkrOTiUmLwcflDhe17WTrpq3MGDUDi8VC87bNmfLOFFzdXO/8wHw6GHeQsTvHkmHJoKZXTeZ0mEMFlwqan6e0yPe20JEjR9KoUSO6d+9OZmYm3bp1o3fv3rRp04aRI0cWRYxCiJLCvSa4VoWsK9J/rQQJDvIv2HYVt6rQajnUGQx6IyT8AUcnaR6f1pYsWcK3337LrFmzchNpjz/+OLt27WLOnDl2jk4IjSUnqwMNNNodsPKbbwC4t1Urah84gOOhQyjOzmQMHapuHxd2o9fr2fz++6yYOJEGoaFkZmfzwfr1tHjuOV6bMoVDp0/nea1nHniAR+66SxJrBTRp0iT8/Pz47bff+N///sc333zDr7/+SnBwMNOnT7d3eEIIO7LarESkRqCg4GTQZoK3lr5Z9w1TR0zFYrFw94N3M2PJjCJJrO2I2sGI7SPIsGTQsEJDFnZaWK4Ta1CAyjWj0cioUaN48803iYiIwGq1UrVqVVxdtf8PJoQoYfQO4BWmbg3NjlUb5YsSIzvbxLR5H6LX65kyum/eHqQzQI0XwL89nHwH3GoUaYxa2LBhA7NmzaJFixa5W0HbtWvH7NmzGTx4MOPGjbNzhEJoxGJRt4TetG2wsGpWqkSVgABevftuXBctAiCzd29s+ayMEkXDYDDQ7e676dqpE9sOHGDxunX8tn8/G7ZupaKvL41q1/7Xx16fGq3T6TA6OrJy8mTZLl9Ae/bs4fPPP8frpm25Pj4+DB8+nOeee86OkQkh7C0+K56rGVdLZCLp5JGTLJiqDsnp+kxXBo0dVCT9Ir87/x0LDizAho12we2Y0HpCiUw0Frd8J9eSk5OZOHEioaGhDBgwAICOHTvStGlTpkyZgodHyZ2UIYTQgIPbjf5rpkRwKpl9BsqjX3fuZ/r8jzAYDDz5WGca1gvN+4Pda0Cj6WCzFF2AGklISKBixYq3Hff09CQzM9MOEQlRRK5vCfX312zJV7p1o9cjj+A5YQL6jAxywsPJ7t5ds/WFNnQ6HZ2aN6dT8+YcOXOGpV98Qd8nn8z9+l8nT3Lq4kW6d+6M0dERm83GyHfeQafTMefNN9HpdJJYKwQvLy9SUlJuO56amio914Qox3KsOUQmR+Kod8RBX/L6zYc1CKPXG72wWq30HtRb89cBRVFYfWI1Hx37CICHazzMkKZDSuT3wh7yvS104sSJJCQk0OWmpqjvvfce8fHxTJs2TdPghBAllLM/eDcAmxnM/zGhUhSrLve2o/sjd2O1WukzZDpWq9XeIRWJ1q1b8+GHH95yLD09nfnz59OqVSs7RSVEEUi69vtV46vOLjt34vz77ygODmSMGKH5+kJbDUJDWTZ2LFUCb1SLz1u9mgGzZtH02WdZtHYtwxcsYNW337Lq22/Zf/y4HaMtGx5++GHGjRvH7t27SU9PJz09nV27djF+/HjpMS1EOXY14yqJ2Yn4OJecXms2m42szBtTpl/q/xKvDn5V88SaVbGy8K+FuYm1F8JfYHiz4ZJYu0m+vxO7du3i888/JyQkJPdYeHg4EyZMkDJpIcoT10qg2NRm+OZkMHrbOyIBLJo5gs3b9vLHgaMs++grBrz2jL1D0tykSZMYMGAA7dq1w2Qy0a9fP6KjowkODmbZsmX2Dk8IbeTkQGwsuLlpstzeo0e5HBNDt6ZN8Vm4EICs557DWrOmJuuL4qMoCq0aNOCvkyeJiY9nyvvvA2q12+JRo2hRr56dIyz9Bg8eTEJCAr17987dbmswGHjqqaekx7QQ5VR2TjaXUy7j6uiKXpfvGqUiYbFYeHvi20ReimTuB3NxcXUpkqpls9XMjL0z+C3yN3ToGNh4IN1Dper97/KdXHN2diYmJuaW5BpAYmIiDho12xVClBJuVQAFkg4BOjB63ekRoohVCq7IzPED6D9yNmOmLaXbQ52oXKn0TzXbtWsXLVq0wGg0EhgYyFdffcXu3bs5f/48FouFGjVq0L59e/T6kvHHjhCFlpwMGRnwD1ugC2LOqlX8tn8/F0NCmJmUhKVaNbLkomippNPpGNijB68/8QTrN29myeefcz4qindGjODp+++3d3hlgtFoZNasWYwZM4aLFy9iNBqlx7QQ5Vx0ejRp5jSC3EtGj9Iccw7T3prGtp+3oTfoOfrXUVq0a6H5edJz0hm/azx/xf2Fg86BMa3GcE+VezQ/T1mQ72xY9+7dGTNmDEOGDKHetStjJ0+eZOHChXTt2lXzAIUQJZxb1WsVbEdApwdH6btob31ffoJPv9zE7n2HGThqLhtWv23vkAptwIABbNq0icDAQDp37sxXX31FmzZtaNOmjb1DE6JoxMer0zs1SBgfPXuW3/bvR6/T8fq5cyg6HRkjR8K1abuidDI6OvJsly70ePBBss1mXJykmbRWpMe0EOJmydnJRKRE4OXkhQ7797PMzspm4pCJ/LHjDxwcHJg4b2KRJNYSshIYuWMk51LO4eLgwtS2U2ke0Fzz85QV+U6uDR48GEVRmDVrFsnJyYA6PeeFF16gT58+WscnhCgN3KrdSLChA0d3e0dUrun1ej5YMIYmnZ7j59/2cP5iJDWrV7Z3WIXi6enJkiVLaNq0KVFRUWzcuBF393/+OevWrVvxBieE1jIy1OSap6cmyy378ksAnnR1pXpGBlmPP45Ftg6WGTqdThJrGrveY3rQoEG5x9577z1mzJjBtGnTmD17th2jE0IUJ4vNwqXkS1hsFtwctWnVUBgZ6RmM6T+GQ/sP4eTsxNSFU2nZvqXm57mcdpkR20cQmxmLj5MPszvMprbPv0+sFgVIrhkMBoYNG8awYcNITEzE0dFRrt4IUd7pdOq0ScUGKcdABzhIgs2e6ofXYuW7E2nfujHVqwbbO5xCmzBhAu+++y6///47Op2OFStW/OMWUJ1OJ8k1UfolJ0NWFvgUvmHylbg4/rdlCwDDMzKwubuT9fLLhV5XiLJMekwLIa6LSYvhasZVKrpp06ahMFKTUxn5+khOHj2Jm7sbM5fOpGGzhpqf53jCcUbtHEWqOZVK7pWY22Euwe6l//1EUct3cs1isfDll1/SsWNHgoODWbhwIT///DN169Zl7NixeHt7F0GYQogST6cDjxBAgZTjgA4c7H91pzx7/umyM9Gsc+fOdO7cGYB77rmHr776Cl9fXztHJUQRsNkgJgZcXDRZbvn//keOxUJ7o5EWZjMZzz6LIhdFhfhP0mNaCAGQbk7nYspF3I3uGHT2n6ydlJhEdGQ0nt6ezP1gLnXq1dH8HLuv7Gby7slkW7MJ8wljZvuZJWo6akmW71eHWbNm8dNPP9GkSROOHz/O8uXLGTRoENu3b2fq1KnMmzevKOIUQpQGuQk2G6ScQE2wSfPfkuC3nfvxcHejWeNwe4dSaFu3brV3CEIUnZQU9aZB8jgtM5OPv/sOgBFmMzYfH7K7y3QvIe5EekwLIWyKjYtJF8nOySbQPdDe4QBQrWY13l7+No5GR2rUqqH5+psubGLugbnYFBstAlowue1kXOW9XJ7lO7n2ww8/sHTpUsLCwli+fDnt27enT58+3H333fTo0aMoYhRClCY6PXiEXtsiehJcKoLB2d5RlWsfrfmG3oOm0rBeKPu3rMbRsXRfdT9+/DjTpk3jyJEjWCyW275+4sQJO0QlhEYSEtTqNQ2qY+KTkqhbowYJx4/ziNVK1vPPa1YRJ0RZJj2mhRCx6bHEZMTg5+pn1ziuRF4hLjYud/tn7bra9z1TFIXPTn7G8qPLAbi/2v2MbD4SB33pfs9Q3PL93crKysLPzw+LxcL27dsZPnw4ADabTcqkhRAqnR48aqsJttRT4BIgCTY7evSBu/Dz9eLwsTPMX/opbw1+yd4hFcqYMWPw8PBg4cKF/zrUQIhSyWSCuDhw02ZLfY1KlfilQwfMR46gVKxI9qOParKuEGWd9JgWonzLNGdyMfkizgZnHPWOdosj8lIkQ14ZQlpKGvM+nEe9RtoPI7IqVhYfXMyGsxsAeLbOs/Rp0Aedzv5TUUubfGfDmjZtyty5c3F3dycrK4t7772XkydPMnXqVFq3bl0UMQohSiO9ATzD1ARb2hlwriA92OzEv4IPb09+k5cHTmby3OU81fXeUj099Pz583z33XdUq1bN3qEIoa3kZEhPh4AATZbTZWTg8umnuAHpL70ERqMm6wpRHkRERPDZZ59x6dIlJk2axE8//USNGjVo1qyZvUMTQhQhRVG4nHqZdHO6XbeDXr5wmSEvDyEhLoGqNasSEKTN3wY3M1lNzNg7g22R29Cho3/j/jwZ+qTm5ykvbh+1dgfTpk0jJyeHY8eOMXPmTPz8/Ni0aRN+fn5MnDixKGIUQpRWegN41QXvemBOAVOivSMqt3o9+wh3t29OVpaJN4bPQlEUe4dUYOHh4Zw7d87eYQihLUWB2FhwdIR/mISbv6UUVn37LWmffoo+NRVrlSqY7r9fo0CFKPv27dvHY489RlRUFDt27MBkMnH+/Hl69erFzz//bO/whBBFKC4zjqjUKHxdfNFhn+qti2cvMrjXYBLiEqheqzrvrHyHChUraHqONHMab+14i22R23DQOTC+9XhJrBVSvivXgoKCWLZs2S3HhgwZollAQogyRm9Qt4g6uEHyMciMBpcgdfiBKDY6nY735o2m4V3P8vOve1i7/id6PvmgvcMqkK5duzJu3Di6d+9OtWrVcHS8tVy/W7du9glMiMJIT4ekJNBg69neo0cZPn8+04FIwPrKK5r0cBOivJg7dy7Dhg3j+eefp0mTJgCMHDmSihUrsmjRIu6XZLUQZZLJYuJi0kUc9A44GZzsEsO5U+cY9uowkhOTCakTwrwV8/D29db0HHFZcby14y3Op5zH1cGVae2m0bRiU03PUR7l+y+txYsX/+fXBwwYUOBghBBllE4HrpXB4ALJRyEzAlyCQZpkFqvataoxdugrTJj5Hm+OncfD97fHy7P09SxbsWIFzs7O/PDDD7d9TafT5Su5Fhsby/Tp09mzZw9OTk489NBDDB06FCcnJyIiIhg/fjwHDx4kODiYMWPG0L59ew2fiRA3SUoCsxmcCv/H/JLPPwfgScBYqxYpHTsWek0hypPTp0/T8R/+v+ncuTPz58+3Q0RCiOIQkRJBsinZbttBIy5GMOTlIaSmpFK7Xm3e/uBtPL09NT3HxdSLjNw+kqtZV/F19mV2h9mEeodqeo7yKt/vbP/4449bPrdarURGRpKamsoDDzygWWBCiDLIyQ/8mkPKcciIAOeK4CCT64rTW4N68euO/bz2Yjc8PUpnD7ytW7dqso6iKAwaNAhPT0/WrFlDSkoKY8aMQa/XM3LkSPr370/t2rVZv349mzdvZsCAAfzwww8EBwdrcn4hclksEBMDroUfd38uMpJNu3YBMBTIfPXVQm8zFaK8qVSpEkeOHKFKlSq3HP/tt9+oVKmSnaISQhSlxMxEIlMj8XHyQZ//7lmaCAwOpH6T+iQlJjHn/Tl4eGo7SOVw/GHG7hxLWk4aVTyqMKfDHILcgjQ9R3mW7+Ta6tWr//H4jBkzZKKEEOLOHNzApzEYXCHtLNg8wOhl76jKDaPRka3fvGfvMEqE8+fPc/DgQXbt2kWFCmofi0GDBjF79mzuuusuIiIiWLduHa6uroSEhLB7927Wr1/PwIED7Ry5KHNSUiA1Ffz9C73Ue19+iaIoPAyE1K9PaqtWhY9PiHLmzTffZNSoURw5cgSr1crXX39NZGQkGzduZM6cOfYOTwihMbPVzMWUiyiKgouj/S78OxodmbRgEjnmHNzctb0IviNqB1P3TMVsM1PXty4z28/Ey0neg2lJsz1ZL7zwAt27d2f06NFaLSmEKKv0juAVribaUk9Adiw4VZQ+bHaQmJSCm6sLTk4le4pgWFhYni/gnDhxIk/38/f3Z8WKFbmJtevS09M5dOgQdevWxfWmSqJmzZpx8ODBPMcsRJ7Fxam//wyGQi2TkJzMuk2bABgOZL72mvxeFaIA7rvvPqpUqcJHH31EaGgoW7ZsoUaNGqxZs4ZGjRrZOzwhhMaiU6OJz4wn0K34t4MePnCYXb/uou+wvuh0OoxGI0aNp3t/ffZrFv61EAWFdsHtGN9qPM4OzpqeQ2iYXNu2bRtOGvQJEUKUEzo9uFcHB9drgw6iwDUIdIV7cyny7uuNv/H6sBn0e+VJJo7sY+9w/tMnn3yi+Zqenp506NAh93Obzcann35K69atiYuLo2LFirfc38/Pj5iYmHyfx2q1YrVaCx2vKKOysuDqVXBzA5utUEt99M03ZJnNNAVaN29OaoMGhV5TCM3ZbGC1qrd8Ks7fpWFhYf9YpXb+/Hlq1qxZbHEIIYpWSnYKl1Mv4+XkhV5XvNtB/9r7F6P7jSY7K5vgysF07dFV0/UVReHDox/y6clPAXi05qMMbjIYB+l7XSTy/V295557bqseyMjIICUlhbfeekuzwIQQ5YRzRfBzvpZgiwTnADDIlZTiYDKbuRqXyIwFK3mm2/2E1dB2xLeWWrZsWeTnmDt3LsePH+err75i1apVt101NBqNmM3mfK9rtVoL9DhRTsTFqZNCAwMLlGy4WcaVKxhRq9ZSXn6ZHEnqipJIUdQ+gyXw9+L+/fvZvHkzBoOBBx54gIYNG+Z+LSMjg8WLF/Ppp59y5MgRO0YphNCKxWbhYvJFcqw5+Dr7Fuu5/9zzJ6P7j8aUbaJF2xY82O1BTde32Cy8feBtfrz4IwCv1HuFF8JfkFZeRSjfybW/95rR6XQ4OjpSv359qlWrpllgQohyxNETfJtC6klIvwgGIzhVUKvbRJF5utt9fLzuezZt/p2+w2fw61fzKK8vt3PnzuXjjz9mwYIF1K5dGycnJ5KTk2+5j9lsxtk5/4nfgIAA3N1L31RWUQxsNrh0CXx9wavwfU8WZmczFvDp2BFD8+aFj0+IopCWBhUqgJ+fvSO5xdq1a5k8eTLVqlXDaDSycuVK3nnnHe6//342b97MpEmTSE1N5dVXX7V3qEIIjcSkx3A14yoV3Sre+c4a+mvvX7mJtdZ3tWbyO5M13QWYaclk0u5J7I3Zi16nZ2jToTxS8xHN1hf/LN/Jtccff7wo4hBClHcGJ/BuAE7+kHYGMi6rCTZHSUoUFZ1Ox9K5o6jX7mm27fqTlWs38UqP++0dVrGbOnUqa9euZe7cublTrwMCAjh79uwt94uPj79tq2heODg44OAg5ffiHyQmQlKSmmQoZL81jh2D334jUK+H/v0Lv54QRUWvV38+S9jvxVWrVtG7d29GjBgBwJo1a3j33XeJjo5m1qxZdOrUibFjx942QVQIUTplmDO4nHwZN0c3DMXYlubQ/kOM7qcm1lp1aMWUhVM07bGWlJ3EqJ2jOJV0CieDExNbT6RtcFvN1hf/Ls9lIYcPH2bSpEkkJiYCkJiYSP/+/WnSpAmdO3dmzZo1RRakEKKc0OnBNRgqtAbv+mDNVLeK2nLsHVmZVb1qMJPfeh2A4VOWcTU+yc4RFa/Fixezbt065s+fz8MPP5x7vFGjRhw7dozs7OzcYwcOHJBG1kJbcXHq9rhC/lH958mTHHz7bfWThx4C6QclRL5duXKFp556Kvfzp556inPnzvHee+8xf/583nvvPUmsCVFGKIpCRGoEGTkZeDh5FNt5U5NTGTNgDNlZ2bRo10LzxFpkeiT9t/bnVNIpPI2eLOi4QBJrxShPybXff/+dnj17cvnyZSwWCwBDhw7l999/56233mLo0KGsWLGC9evXF2mwQohywuAEnnXArxW4BENWDJgS1D4tQnNv9n2Wxg1qk5Scxsx319o7nDtavHgxWVlZuZ9/8MEHpKam5nudc+fOsXTpUl577TWaNWtGXFxc7q1ly5YEBQUxevRozpw5wwcffMDhw4d58skntXwqojwzmyEyEjwK/0f98KlTaXLkCEv1enjtNQ2CE6L8MZvNeNz0/6PRaMTJyYmxY8fy0EMP2TEyIYTWEjITiE6NxtfFF10xNkXx9PZk2MRhtL6rNdPenabpVtATiScYsHUA0RnRBLkFseSeJdT1q6vZ+uLO8lSPvWzZMvr27cuAAQMAOHPmDHv27KFPnz706NEDULcXvf/++zzxxBNFF60Qonxx8gVHL3AOhLTT6lZR54rg4GLvyMoUBwcHPpg/lg3f/cz4wT3tHc4/euyxx6hfvz716tVjyZIldOvWjcqVKwPw3nvv0aVLFzw9PfO15pYtW7BarSxbtoxly5bd8rVTp06xdOlSxo4dS/fu3alWrRpLliwhODhYs+ckyrmEBLX3VKVKhVrmwPHj/HrqFAbgkS5dCr1egaSlQUoKODmBiws4O5e4LX9CFJRULAtRtpitZi6lXEKv0+Nk0C659V8URckdJHBPl3u4+8G7NR0ssPvKbibvnky2NZva3rWZ2WEmfs4lq69leZCnv3yOHj3K1KlTcz/fvn07Op0utzcNQP369bl48aLmAQohyjm9AdyqgJMfpJ2DzEuQk6z2ZpMx0ppp0bQeLRpUA5vF3qH8o9mzZ3P06FGOHTuGoig8+uij+Pj4UKtWLcxmM9u3b+euu+7K15adPn360KdPn3/9erVq1fj000+1CF+I20VHqwkofeEGt0ydMweAHno9Vf82dKrIWSxw9ar6PGrVUqeepqVBaqr6Nb1eTbZdT7gV8rkKUZR0Ot1tb3b/6ZgQonSLSYshMSuRALeAYjnfsUPHWDh9IdMWTaNioNq7V8vfKxsvbGTegXnYFBstAlowuc1kXB1dNVtf5F2e3pnqdDqUm7Zj/f777/j6+lKvXr3cY2lpaQWaoiaEEHni4Kr2YXMJhLSzkBUFzgFgkN875UF4eDjh4eE89dRTrFu3jp9//hmTyZRbSb1161Y+/PBDMjMz2bNnj73DFeK/paWp/dYKOSH0r5Mn+eboUXTAuEceUScwFpe0NHUgQ1AQ1KmjTjwFdbtrRoZ6S01VK/QyM9X72mxqfzkXF3Bzk+o2UaIoisITTzyB/qYkcFZWFi+88AKGvw0I2bJlS3GHJ4TQQLo5nUupl3A3uqPXFf0FnxOHTzCyz0gy0jP46N2PGDV9lGZrK4rCx8c/ZtXxVQA8UO0BRjQfgYMUH9hNnr7zTZo04ccff+SNN97g8uXL/PHHH7f1nVm7di0NGjQokiCFEAIAnQ6c/cHoDSnHIe08uFe1d1SiGAwePJh69epRt25ddDodBoOBypUrU7lyZQwGA5MmTaJKlSq5Q3eEKNHi4yErC/z9C7XM5JkzAXjWYCBs0CAtIruzm6vVGjSA6tXB0fHG141G9ebjo36uKOpzvZ5wS0pSE20xMWqyzdUV3N3VyjYh7Gjmtf+fhBBlk02xcTn5MqYcEz7uPkV+vpNHTzK8z3Ay0jNo1LwRg8cO1mxti83Cgj8XsPHCRgCeD3+e3vV6S6WtneUpuTZkyBBeeuklfv75Z6KiovD29uaNN94AYPfu3Xz66ads376djz/+uEiDFUIIAPSO4FZdHXSQkw6O7vaOSBSxLl26cOzYMT766KPcbaGhoaHUqlULq9XKuXPnCAoKwvd69YwQJZXVqg4ycC3clo2/Tpzgm2PH0APjH3sMvL01Ce8/3VytVrs2+OWhn4tOpz5XV1c1mVi9ulrdlpoKyclqoi4l5UbCzt1drWr7W6WQEEXt8ccft3cIQogiFJ8ZT3S6OsSgqJ06dorhrw0nIy2DBk0bMHPpTFxctekZnWXJYvKeyey5sgc9egY3HUzXkK6arC0KJ0/Jtfr167Nx40Z+/vln9Ho9Xbp0yX0Dc+TIEWw2G5988glNmjQp0mCFECKX0QvcqkHKCXBwU9/AiTLrwQcf5MEHHwQgLCyMFStWkJSUxJkzZ7DZbMyePZshQ4YQGhrKF198YedohfgPiYlq9VZA4Xq9XNm6lWDgboOBsGsDp4rMnarV8stoVLewVqgAISFqr7bUVLWiLz4erlxRK95cXMDTU72/EEIIUUBmi5mLSRdx1DtiNBTta8qZE2cY/upw0lPTqd+kPrPfm42rmzY90JJNyYzaMYqTSScx6o1MaD2B9pXaa7K2KLw8b8gNCAjghRdeuO34fzWDFkKIIuVWBTIjISdF3SoqyoXg4GACAwMJDw+nbdu2fPnllyxfvhw/Pz9Onjxp7/CE+G+xsWriqDD9xmw2Htq+nXNA2rPPFrp3239KT1f7puWnWi0/dDrw8FBvlSrdWtUWE6Oe22JRn6OHh1xIEUIIkW+RaZEkm5IJdA8s0vMoisKCqQtIS02jXuN6mibWotKjGLljJFHpUXgaPZnZfib1/Ord+YGi2JSasU19+vRh1KgbDQCPHz/OU089RaNGjXjiiSc4evSoHaMTQtiFgxu41wBzCig2e0cjisnWrVvx8bnRK+P7778nKCgIo9FIw4YN7RiZEHeQkaFOCS1sMmzLFjh3Dmd3d/x799Ymtr9TFDXWjAyoXx+aN9c+sfZPrle11aoFbduqt9q11e20ERFqctJkKvo4hBBClAmpplQiUyPxcvJCX8TpD51Ox9SFU3ngsQeY8/4c3NzdNFn3ZOJJ+m/tT1R6FIGugSy+Z7Ek1kqgUpFc27hxI9u2bcv9PDMzkz59+tC8eXP+97//0aRJE15//XUyMzPtGKUQwi5cK4OTL5ilkb0QooSLiVErwTw8CrzEoRMn+Gz+fKwAzz9fqLX+U3y82vusZUs1uVWYbaAFpderU0jr1oX27aFFC/XzxEQ10ZaSog5FEEJjixcvJisrK/fzDz74gNTUVDtGJIQoiOtDDMxWM26O2iS6/onZbM792M/fj9EzR2uWWNtzZQ9v/vYmyaZkQr1DWdJ5CVU9ZKBbSVTik2vJycnMmTPnlkmkP/zwA05OTowcOZKQkBDGjh2Lm5sbP/74ox0jFULYhcEJ3GtCTibYLPaORggh/pnZrCaECpkMGz99Os/FxTHKaIQePTQK7m8yMiAnB8LD1SqyksDZGSpXVpN9bdtCWJhaXRcZKdVsQhOPPfYYY8aMYc2aNSxZsoSEhITcr7333nukpKTYMTohREFczbhKTEYMFVyK7rXsasxVXu76Mr98/4vma/9w4QfG7BpDtjWbFgEtWNhpIX7OxVBFLgok38m14r6SM3v2bLp27UqtWrVyjx06dIhmzZrljprV6XQ0bdqUgwcPFlkcQogSzCUInP3BnHDn+wohhD1cvaoOMijEVM8DR4/y3cmT6IFXn3xSnaypNYtFrVoLDYXAou1NUyDXq9nCwqBduxvVbElJcPnyjR5tQuTT7NmzadKkCWfOnMmdSn3PPffQp08fzGYz27dvJyIiwt5hCiHyKDsnm0vJl3AyOOGgL0Sf0/+QGJ/IsN7DiLocxSfLPrmlgq0wFEXh4+MfM2f/HGyKjQeqPcCM9jNwddSmf5soGnlKrtnrSs7u3bvZv38//fr1u+V4XFwcFStWvOWYn58fMTExRRKHEKKE0zuCRwhYc8CWY+9ohBDiVjabWrXm5KQmhwpo0owZAPR0dKTO669rFd2tYmLUwQIhISV/eMD1arZWrdRqtgYN1O9xbKz6/U5OlkSbyLPw8HCeeuopJk2aBMDPP//MJ598wrPPPoter2fr1q306tWL1q1b2zdQIUSeRKZGkmJKwdvZu0jWT0lOYdirw4i4GEFAUABvL38bowbTrS02C/MOzGPlsZUAPB/2PKNajMJRb4f2DCJf8pTCnT17NkePHuXYsWO5V3J8fHyoVatW7pWcu+66iypVqmgWmMlkYuLEiUyYMAFnZ+dbvpaVlXXbD67RaNQsUyyEKIWcA8AlELKvgmuwvaMRQogb4uMhLg7+dmEwP/YfOcL3p0+jB8Y/84zaD01rCQnqumFh9umxVlA6Hfj4qLcaNdSkWny8OpDh+oXX6xNJC5HcFGXb4MGDqVevHnXr1kWn02EwGKhcuTKVK1fGYDAwadIkqlSpQmKi9HgVoqRLykoiMjUSHycfdGh/oSg9LZ0RfUZw4cwF/Pz9mP/RfAKCAwq9bpYliyl7prD7ym706BncdDBdQ7pqELEoDnlKroWHh+dezVm3bh0///wzJpOJM2fOsGfPHrZu3cqHH35IZmYme/bs0SSwxYsXU79+fTp06HDb15ycnG5LpJnN5tuScEKIckSnV3uvZV8FazYY5PeBEKIEUBSIilITQIVIWE2+VrX2nNFI7aKoWsvKUm/NmhV+mqk9GQzqVFM/P6hZU90uGhenJtmiotTkmoeHWvWmQYWBKDu6dOnCsWPH+Oijj3KLCUJDQ6lVqxZWq5Vz584RFBSEr6+vvUMVQvwHi83C5ZTL2BQbLo4umq+fmZHJqL6jOH3sNN6+3sz/cD6VqlYq9LrJpmRG7xzNicQTGPVGxrceT4dKt+dCRMmVp+SaPa7kbNy4kfj4eJo0aQLcmMDx008/8cgjjxAfH3/L/ePj42/bKiqEKGecKoBLZci8DG6V7R2NEEKoEy2vXFGrqgpo/+HDfH/mDHpg3LPPgovGbxasVrUnXJ066pbQssLRUa0WrFgRatVSE20xMWqFXmKiOrQBwMFB3U7q7Kz+azDYN25hFw8++CAPPvggAGFhYaxYsYKkpCTOnDmDzWZj9uzZDBkyhNDQUL744gs7RyuE+DfRqdFczbhKRbeiyQ389M1PHD14FHdPd95e/jbVQqoVes2o9ChG7hhJVHoUnkZPZrSbQf0K9TWIVhSnPCXX7HElZ/Xq1Vhu6pPx9ttvAzB8+HD27dvH8uXLURQFnU6Hoij8+eef9O3bV7PzCyFKIZ0OPKqD6QpYMsCh6EZuCyFEnsTEqJNCC5EQ0+3YQVuglpMTtV97TbvYrouJgaAgNQFV0vusFZSTkzqgITBQTapdr9TLzITUVHUraWammoCz2dTvg9Go/ndzc5PtpOVMcHAwgYGBhIeH07ZtW7788kuWL1+On58fJ0+etHd4Qoh/kZSVxMWUi3g4eWDQFc2Fkm7PdiMpIYnWHVtTK6zWnR9wBycTTzJq5yiSTckEugYy5645VPWoqkGkorjlKblmjys5lf525dTtWm+RatWq4efnx7x585g+fTo9evRg3bp1ZGVl0aVLF03OLYQoxYw+4FoN0k5Lck0IYV+ZmWpj/cJsszSbafbDD+wEsvv2VaurtJScrCaewsLUf8sDR0f15ul545iiQHb2rUm35GS18jA6Wv26q6s6obW8fJ/Ksa1bt97y+ffff5/7ccOGDYs7HCFEHpgtZs4nncditeDrrO32bYvFgmJTcDQ6otPpeGXgK5qsu+fKHibtnkS2NZtQ71BmdZiFn7OfJmuL4pfvmbQl4UqOu7s777//PhMnTuSLL76gTp06fPDBB7i6ymhaIQTgVhUyoyAnFRw973x/IYQoCrGxkJYGVQtxBfqbbyA2Fp2/Py5PP61dbKAmk9LToXHjQm1bLRN0OrVK7e8VhiaTmmBLSVEr/JKS1EpEo1GtaJOqNiGEsDtFUbiUcomErAQC3QI1XdtmszF73GzSUtOYvGAyThpdYPnhwg+8feBtbIqNFgEtmNxmMq6Oks8ozfKdXLPXlZxZs2bd8nnDhg3ZsGFDkZ1PCFGKOXqAe3VIOQoOHmV3m5MQouTKyYHLl9VKpwL+Dtp/8CDfvvsuQwCfV17RtmLKZlP7rNWsCRpOey9znJxu9G0LCVGTkSkp6pCExESpahNCiBLgauZVLqdcxs/ZD71OuwseiqLw7sx3+eW7XzA4GDh19BQNmxUu56EoCqtPrOajYx8B8EC1BxjefDiO+lI0pVv8o3wn14QQolRwrQKZEZCTrG4VFUKI4nT1qpp8KcSAgInTp/NDZiaxLi6837WrhsGhVtVVqAC1a0vlVV7p9epWUk9PNSF5vaotKUn97y1VbUIIUewyzBmcTzyP0WDEyUHbCxyrlq5iw2cb0Ol0jJ4+utCJNYvNwsK/FvLd+e8AeD7seXrX741OCgHKBEmuCSHKJgcXcA+BpD/VraFF1NRUCCFuY7OpvdaMxgJPntz755/8cOECBmBEr17qWlpJTVXjCg/XfvJoeXJzVVtoqLoFODVVqtqEEKKYWG1WLiRdIMOcQYB7gKZrr/90PR8v/RiAQWMGce8j9xZqvWxLNlP/mMqu6F3o0DGoySAer/W4FqGKEkKSa0KIssslGDIugSkRnP3tHY0QorxISFArmfwL/ntn0owZALzg4kKtXr20ikytrEpOhoYN1co1oQ29Xh1c4eV1a1Xbv/Vqc3UtcOJVCCGEKio1iivpV/B39UeHdtVfP3/7M+/OfBeAVwa8wuM9C5cESzGlMGbXGI4lHMNR78iE1hPoUKmDFqGKEkSSa0KIsstgBI8QSNgPNgvo5VeeEKIYREWpFUsFrDb7dccONl28iAEY+8or6mRLLSiKmuipXl29iaJzp15tV66oFY7Xq9q0ngIrhBBlXFJWEheSL+Dh5IGDhn/jp6WksWjmIgCefOFJXuj7QqHWu5JxhZE7RhKRFoG7ozsz2s+gYQWZOlwWyTtNIUTZ5hwELoGQfRVcg+0djRCirEtJURMnvr4FerjVamXIlCkAvO7uTq0XCvdH/S0SE9V+YaGhUjVVnP6pV1tq6o2qttRUtdLRYFCr2tzdwUH+RBdCiH9jtpg5n3geq82Ku6O7pmt7eHkw5/05bNm4hX4j+xWqH9qZ5DO8teMtErMTqehSkTl3zaG6Z3XtghUlirxyCyHKNr1B7b1migdLltqLTQghikpMDGRnqxVLBbDyk084lJSENzB55EjtkiwmE2RlQbNmavJG2I+Tk7pl2N//RlVbaqqa/IyLU4dNWK1qNdv1LaTS7FoIIQB12uallEskZCcQ6B6o2bpWqxXDtQtPdRvWpW7DuoVa70DsAcb/Pp5MSyY1vWoyu8Ns/F2kTU1ZJiOMhBBln1MFcK0Kpjh7RyKEKMuystRBBl5eBV7ioYMH6QVMqlqVCl26aBOXoqgJm2rVIFgqeEsUnQ48PNSpsg0aQIcO0L49NG4MPj7qz1RkpHpLSFATt0IIUY5dzbjK5ZTL+Dn7odconXHp3CVe7vYyp46d0mS9Xy79wls73iLTkklj/8YsunuRJNbKAalcE0KUfToduNeArBgwp4Cx4G98hRDiX129qlYgVa1asMcfOEDwrl2s0uthzhztqpWubwetVUvdoihKLkdHdUuxry/UqAGZmTe2kMbGqv9evapWNLq5qTfZQiqEKCcyzBmcTzqP0WDEyUGbCcwx0TEM7zOcuJg43p//PvNWzCvwVlBFUfj89Oe8d/g9AO6ucjejW4zGaNBw4rcoseTVWAhRPjh6qMMNkg6pH+vkDaYQQkMWC1y8qCY7CvBHuTk7G+P8+eon3buriTAtyHbQ0s3VVb0FBqq98q5vIU1IgPj4G1tInZxubCGVBKoQogyy2CycSzpHhjmDAPcATdZMSkhi+KtqYq1azWpMeHtCgRNrNsXGskPL+PLMlwA8FfoUbzR6A7285yg3JLkmhCg/XKtAVjSYEsBZSrOFEBqKi4OkJAgKKtDDe/Tuje7UKea7ulKtb19tYrq+HbRGDdkOWhbcPBihcmXIyYG0tBsDEZKT1ZuigIuLmmxzdi6efm2Kov4rveGEEEUkOjWamPQYKrpWREfhf9ekp6Uzos8IIi9FEhAUwNzlc/H28S7QWjm2HGbtncWWiC0A9G3Ylx51ehQ6RlG6SHJNCFF+GIzqcIOEfWAzg15KtIUQGrDZ4PJldUtfAbbo/bpjBxtOncIATHniCfD21iYu2Q5att28hbR6dbUfW2rqjWRbaqpa3abTqRVtbm5qhZuWTCY1oZedrf6M6XRqhaSbmxqfEEJoIDk7mYspF/F08sRBX/gUhslkYuzAsZw9eRYfPx/eXvE2FQMLNogoMyeTCbsnsD92PwadgbdavMX91e4vdIyi9JHkmhCifHEJBNdgyLoCrpXsHY0QoixITFSTGX5++X6o1WrlzSlTAOjr7k69fv20iUm2g5Y/zs7qrWJFdQrp3/u1JSerPxcGw41+bQVJgNls6rppaWoyuUIFdSCDg4NavRkbqyb1cnLAaFR//mS7qhCigHKsOVxIvoDFasHX2VeTNT9b/hmH9h3C1c2VOe/PoUr1KgVaJzE7kVE7R3E66TTOBmemtJ1Cy8CWmsQoSh9JrgkhyhedXq1eM8WBJQMc3OwdkRCiNFMUdUKozVagqqCPPv6Yw0lJeAOTR43SptpHtoMKne5GAi0oCGrXvtGvLSlJTX5dT4A5Ot6obPuvysvsbDVBZzarFZFhYWoiz9v7RuIsKAjq1LlRQXd9u/TN21XLKbPZTPfu3Rk/fjytWrUCICIigvHjx3Pw4EGCg4MZM2YM7du3t3OkQpQs0anRxGXEEeCmTZ81gB6v9ODCmQt0e7YboeGhBVojKj2KEdtHEJ0RjbeTN7PazyLMN0yzGEXpI8k1IUT54+QLrtUh9SS4uUqPGCFEwSUkQFSUWr2TTynp6YxdvhyASdWq4ffAA9rEJNtBxd/9vV+bxaIm29LS1J+X+Hi1+tJiUavN3NzURJhefyNRZjSCv79apVahwr8nkw0G8PFRb9Wq3diuer2Czmgsdz+XJpOJYcOGcebMmdxjiqLQv39/ateuzfr169m8eTMDBgzghx9+IFiS4kIA6nbQS6mX8HLywqAzaLaui6sLUxZOKfDjTyed5q0db5FkSiLILYi5HeZS2aOyZvGJ0kmSa0KI8sm9uro1NCcZjD72jkYIURrZbHDhglqR4+yc74dPnzGDuJwc6gD9ZszQJtEv20FFXjg4qBVn3t5QpcqN4QhpaWrC+Pr2TkUBDw+oV0+tUvPyyv/P6c3bVWvVUn8+y1EF29mzZxk2bBjK9aEP1+zZs4eIiAjWrVuHq6srISEh7N69m/Xr1zNw4EA7RStEyZFjzeFi8kXNtoNu2rCJmKgYXur/UoEnggLsj93P+N/Hk2XJopZ3LWZ3mI2fc/7bQoiyR5JrQojyycEVPEIg6S9w9AQNr4YJIcqJuDi4ckWt5sknc3Y2G379FYD57dvjWKdO4eO5vh20enXZDiry5+bhCNWqqVs/09LUSjYfH7XaTAvXhyuUI3v37qVVq1YMGTKExo0b5x4/dOgQdevWxfWm70ezZs04ePBg8QcpRAkUnRrN1YyrmmwH3b1tN3MnzsVmtRFSJ4S77rurQOtsubyFmXtnYlEsNK3YlKltp+LmKC1mhEqSa0KI8su1EmRGQXacOuhACCHyympVq9YMhgIlHow//sihnBzWOzvz0KRJ2sR0fTtoaGi523YnNGY0FmhAh7hdz549//F4XFwcFSveOp3Qz8+PmJiY4ghLiBJNy+2gxw8fZ9LQSdisNh547AE63NuhQOt8efpLlhxaAsDdle9mdMvRGA0aXXgQZYIk14QQ5ZfeUa1eS9gLVhMY8t+MXAhRTsXGqrfAAiTm09Nh6VJcgRf69VO35hWWbAcVolTJysrC+LfEvNFoxGw253stq9WK1WrVKjQh7CrHmsP5hPOYzCa83byxWW0FXuvyhcuMemMUpmwTLdu1ZNjEYSg2BQXlzg++RlEUlh9bzrrT6wDoHtKdfg37oUdfqNiEtmzYyDBnkGHOQK/ToyhKgX4vFuZ3qSTXhBDlm3MAuFSBzMvgJo1IhRB5kJMD58+r1T3/NV3xH1itVr6aMIEnExMxVK0KTz1V+HhkO6gQpY6TkxPJycm3HDObzTgXoH+j1WotUFJOiJIoMiWSmNQYKrpWLFSiI/5qPG/1fYvU5FTq1KvDuDnj0Ol1+VrTarOy4NACfrr8EwC9w3vzTOgzKDYFK5LQLgmyc7JJN6djxYqroytVPavi7eSNh5NHsf9elOSaEKJ80+nAowaYYiEnHRyl4kMIcQcxMWq/tQIksj5ctYrXt2/nHmDzkCHoHB0LH09CgmwHFaKUCQgI4OzZs7cci4+Pv22raF7XcpeKVVEGJGUlkZiRSHBgMB5OHgVex5JjYcJzE4i9EkuVGlVY+OlCfPzyN8As25LNuF/HsSNiBwadgdHtRvNo7UcLHJPQTo41h5TsFDItmbi5uFHLrRaBboH4uvradauuJNeEEMLoDe41IOUYOLhpM7FPCFE2mc1q1Zqra76r1lLS0xm3YgUAXatVQ9e+feHjycxUY6pfX7aDClGKNGrUiA8++IDs7OzcarUDBw7QrFmzfK/l4OCAQz5/HwlR0uRYcziXcg4LFgJcCzfEwGAw0PPVnrw39z0Wf7aYChUr5OvxqaZUhvw0hEOxh3AyODGz80zuqlawIQhCG1ablTRzGmnmNBx0Dvi6+VLPox5+rn64G0vG3z/yW1gIIQBcq0JmNJgTwCl/L8BCiHIkOlodHFA5/9vIp0ybRlxODmHAGzNmFD6Rb7GoFXRhYbIdVIhSpmXLlgQFBTF69Gj69evHr7/+yuHDh5k5c6a9QxPCLi4lXyI6LZpKHpU0We/RZx7lvsfuw9klf1utr2ZcZeCmgZxLOoeH0YMFDyygcWBjTWIS+aMoChk5GaRkp6Cg4OHkQXiFcPzd/PF29kavK1nV+iUrGiGEsBcHF/CoBZYssOXYOxohREmUnQ3nzqkVYvncfvnHX3/xzubNAMxv3x7HOnUKH09MDFSqpG4HlYpbIUoVg8HA0qVLiYuLo3v37nz77bcsWbKEYEmUi3IoMSuRs0ln8XH2wUFf8Pqfz1d+TmJ8Yu7n+U2sXUy+SO9ve3Mu6RwVXCuw/NHlklizA5PFxNWMq0SkRpBtzaaqd1VaVW5Fh6odqFOhDr4uviUusQZSuSaEEDe4BINrjFrBJsMNhBB/FxkJKSlQtWq+HpZtMvHS8OHYgOeMRrpMmlT4WOLj1SRfeDho0bdNCFHkTp06dcvn1apV49NPP7VTNEKUDDnWHE4nnMZsNePv6l/gddZ9uI63J7zN2hVrWfvLWlxcXfL1+GNxxxj842CSs5Op6lmVxQ8tJthDkt3F5fq2z1RTKkaDEV8XXyp5VsLPxQ83o5u9w8sTSa4JIcR1egN4hIIpEXJSwdHT3hEJIUqKjAy4eBG8vPJdJTZ5xgxOpqQQACwaOxa8vQsfi8kEDRqogwyEEEKIUkqL7aC//fgb8ybOA6Dbs93ynVjbE7mHEb+MIMuSRXiFcBY+uBBfF98CxyPy5p+2fdarWA9/V3+8nL1KZHXaf5HkmhBC3MzoDe4hkHz42nADg70jEkKUBBERkJYGVark73EmE88dOsRmYFyTJvg+/HDh4rBY1Kq1unUhKKhwawkhhBB2pMV20KN/HWVs/7EoikL357vTq3+vfD3+p3M/MfG3iVhsFlpWasnce+eWmkqp0spkMZFiSiHLkoWb0Y2q3lUJdA/Ez8UPR0PprcaX5JoQQvydW1UwXYXsOHAJtHc0Qgh7S02FS5fAxyf/vc2WL6d+ZCR7fH0xzJ1buDgUBa5cUYcphIRInzUhhBCllsli4lT8qUJtB428FMmQXkMwZZtod087Rk4fiS4fr43rjq5j3u55KCjcV/M+JneajNFgLFAs4r/9fdqnn6sf9Tzrlaptn3ciyTUhhPg7g1EdbpCwFyyZ4OBq74iEEPYUEQGZmVAhf5OEr+zcSdAnnwBgGDOm8NtBExLAw0P6rAkhhCjVFEXhdMJprqRfobJHwfocJycmM+j5QSQlJFGnfh1mvjcTB4e8pTcURWHZ/mV8dPAjAJ6u+zTD2w4vddsQS4MMcwbJ2cmlYtpnYUlyTQgh/omTP7jVgNRTaiWbVIgIUT4lJ8Ply+Dnl6+H7TlwgI5vvslwYOqDD6Lv1KlwcWRkgNkMDRuqCTYhhBCilIpIjeB80nkC3AIw6AvWgiUzIxOAgOAA3vn4HVzd8nYx3GKzMHPnTL459Q0AfZv1pXeT3vmqeBP/zWw1k5KdQqYlEzdHN6p4VSHIIwhfF98yXRkoyTUhhPgnOh241wRTHJgSwDl/FStCiDJAUdQhBmYzVKyY54dlm0y8PHIkZuCy0Yh+xIjCxXG9z1q9ehAoW9WFEEKUXolZiZyIP4GboxvODs4FXie4SjAfffMRyYnJ+AfmbVtptiWbMVvHsP3SdvQ6PaPbj+bxsMcLHIO4QVEU0s3ppJhS0Ov0+Ln6Ee4Rjp+rH+5Gd3uHVywkuSaEEP/GwUWdHpqwH6wmMDjZOyIhRHFKTISoqHxvB50wbRonU1IIBBaOH69OGC2o633WqlSBmjWlilYIIUSplW3J5kTcCcwWM8EewQVa4+LZi1SvVR0Ab19vvH298/S4VFMqQ38aysHYgzgZnJh+z3Q6Ve9UoBjEDTnWHJKzk8m0ZOJh9KCWby0C3QPxcfEpc9s+76R8PVshhMgvlyBwrQrZV+0diRCiOF2vWrNawTnvV9b3HDjAvE2bAHi/aVN8u3QpXBzx8eDpCWFh0mdNCCFEqWVTbJyKP0VsRiyB7gWrwv7qk694+u6n+eqTr/L1uNj0WF797lUOxh7E3ejO4i6LJbFWSOnmdCLTIonNjMXd6E7z4Oa0q9qOehXr4efqV+4SayCVa0II8d90evAMUbeHmpPB6G3viIQQxSE2Nt9Va1nZ2bw0YgQ24HmjkccKOx00PV3dEtq4sfRZE0IIUapdTrnMheQLBLgFFCjxsnPzTuaMnYPNZiMpISnPj7uQdIEBmwYQmxGLv6s/73Z5l1q+tfJ9fqH2q0vOTiYzJxNXoys1vGsQ5K72Uito77yyRJJrQghxJ46e6vTQ5EPg4A56+dUpRJlmMsHp0+DgAE553w4+cdo0TqWmarMdNCdHnQ4qfdaEEEKUcvGZ8ZyMP4mH0aNAfdZOHD7B6DdGY7PZePSZR3n1zVfz9LgjsUd486c3STGlUM2rGou7LCbIIyjf5y/vsnKySMpOwqbY8HXxpU6FOvi7+uNmdLN3aCWKvEMUQoi8cKsKpqvq9lDXgvWIEEKUEhcuqNsxq1TJ+2Oyswn54w/cgA+aNy/cdlCrVe2zVr06hIQUfB0hhBDCzrJysjgRdwKL1YK/a94GD9ws8lIkb774JlmZWbS6qxVjZ4/N02TPnZd38tbmtzBZTdSvWJ93HngHb2fvAjyD8klRFNLMaSRnJ+Pk4ERlz8pU8qyEn4ufVKn9C0muCSFEXugd1OEG5kSwpKsVbEKIsic+Hs6dU7eD6vOxbeW993g9KYnufn74z5lT9UpVZAAARfhJREFU8PNfH2AQGAh166rVc0IIIUQpZLVZORl/krjMOKp45uOC1TWJ8YkM7DmQhLgEQsNDmf3+bBwc7/y6+P3p75m6fSpWxUrbKm2Z3Xk2Lo4uBXkK5c71rZ8ZORl4GD0I9w8n0D0QLyevPCU1yzP5i00IIfLKyQ/cakLqcTC4qv3YhBBlR04OnDmjJrjc8r7VwfLnnzisWQOA//jx6gCCgoqJAW9vqF8/X4MUhBBCiJLmYvJFLiVfIsg9qEB91n5Y/wMRFyMIqhzEok8X4e753xe3FUXhk8Of8O7edwF4qNZDTOg4AQdp6XJHJouJpOwkcmw5+Dj7UKdCHQLcAiQpmQ/yzlAIIfLDvQYY/cAUb+9IhIbMZjOPPPIIf/zxR+6xiIgIXnrpJRo3bsxDDz3Ezp077RihKBaXLqnJrYoV8/yQXXv3EtavH78qCjzyCLRvX/Dzx8erPd7q15cBBkIIIUq1qxlXOZVwCi9nL4wGY4HWeK7PcwweP5h317yLf+B/bym12qzM/X1ubmLthYYvMKnTJEms3UG6OZ3I1EgSsxLxd/OnVaVWtK3Slure1SWxlk/ykyaEEPlhcALP2pCwD6zZYJDKktLOZDIxbNgwzpw5k3tMURT69+9P7dq1Wb9+PZs3b2bAgAH88MMPBAdLz70yKSlJ3Q7q7Q2GvPUSiYmP5+mhQ4m2WFjp5MTdw4YV/PwpKepk0KZNwc+v4OsIIYQQdpZhzuBE3AkURcHTKX/V3IqiYLVYcXB0QKfT8ULfF+74mGxLNuO2juO3S78B8GarN3m+4fMFCb1csCk2Uk2ppJhScHN0o6ZPTYI9gvF18ZWtn4UgyTUhhMgv50BwqwZp59RBB/IiVGqdPXuWYcOGoSjKLcf37NlDREQE69atw9XVlZCQEHbv3s369esZOHCgnaIVRcZqhbNnITtb7bWWBzkWC0+/9hrR2dmEA0umTy94tVlGBqSlQaNGECRTzIQQQpReFpuFk/EnScxKLFCftSWzlnDq6ClmfzAbVzfXO94/KSuJoT8P5cjVIxgNRqZ0msK9Ne8tSOhlnsVmITErkWxLNl7OXjSs2JAA9wA8nKRaXguSXBNCiPzS6cCjNpiT1QmizgH2jkgU0N69e2nVqhVDhgyhcePGuccPHTpE3bp1cXW98Udds2bNOHjwYPEHKYpeZKR6y0dV4rBx49gREYEnsKFnTzw6dSrYuU0mdTto3bpQrVrB1hBCCCFKAJti43T8aS6nXCbIPSjfVVDrPlzHqsWrANi7Yy+dHuz0n/ePSIlg0I+DiEiNwNPJk/n3z6dxYOOCBV+GZVuySchMQEGhgmsF6lesT0W3ijg5ONk7tDJFkmtCCFEQDi7gGQaJ+8CSAQ55b34uSo6ePXv+4/G4uDgq/q3vlp+fHzExMcURlihOaWlw+rQ6hCCPkzlXr1vHu5s3qx83aECdIUMKdm6LRe3xFhICoaFSBSuEEKLUUhSFMwlnOJ14Gn9XfxwNjvl6/M/f/My8ifMA6D+q/x0Ta0evHuXNn94kOTuZYPdgFnVZRHXv6gWMvuxRFIV0czrJpmQc9Y5U8qxEZc/KVHCtgEGft/YXIn8kuSaEEAXlXBHca0HKcXBzBp28UJUVWVlZGI23Nt81Go2YzWY7RSSKhM2mbgfNyIAqedu6cuj4cfrMU//4H+/tzWOLFxcsKWazQXS0et7w8Dz3eRNCCCFKGkVROJ90npPxJ/Fx9sl3I/x9O/cx8c2JKIrC0y8/zUsDXvrP+/928TfGbh2LyWoivEI4Cx5YQAXXvLV1KOusNispphTSzGm4G92p7VubII8gvJ29pZ9aEZPkmhBCFJROB+41wZwEWbHgKo3uywonJyeSk5NvOWY2m3F2lgEWZUp0NFy+nK/poDX/9z8eUhSyDQYmLV8ObgWoWlUU9dz+/lCvHhgLNkVNCCGEKAkupVziWNwxvJy8cDe65+uxp46eYnjv4eSYc+j8cGeGTR72n0mgL459wdzf56Kg0K5KO2Z2nomr4517s5V1OdYcErMSMVvNeDt70zigMQHuAbgZZXdNcZHkmhBCFIbBCJ51ICEFzClg9LJ3REIDAQEBnD179pZj8fHxt20VFaVYZqa6HdTZGZzy2HPku+/w+PprvgKyZsxAX6NGwc599Sq4u0ODBuAqbwiEEEKUXhEpERyNPYq7o3u+G+NbrVZGvzGajPQMmrZpypRFUzD8SyW3TbHx7t53WX14NQCPhz3OW+3ewkFfvlMaWTlZJGYnokNHBdcKVPWqir+bP0aDXLgrbnp7ByCEEKWeky94hKrJNVuOvaMRGmjUqBHHjh0jOzs799iBAwdo1KiRHaMSmlEUdTtoSgr4+eXpIdv/9z+UGTMA0L3+Oq6dOxfs3ImJoNdDw4bgJcl4IYQQpVd0WjRHrh7B2cEZL+f8v6YZDAZmLJtB646tmffhPJyc//lil9lqZtyv43ITa280f4Mx7ceU28SaoiikmlK5nHKZVHMqVTyr0Lpy6/+3d+fxUVX3/8dfs2WWzGRPyEIIm0BYZLOIC9LivlurVvyJC1ZbN6y2XxXQVqVVESu2itZqrdYN97X6EFGsYlXcAAHZd2JC9mSyzHp/f1wZiQRIkGQy4f18PMZk7r1z77meDJ/kM+ecD4f2PJSClAIl1uLkwPxpFBHZ35J7m9NDG7dCcvvLjkvXMmbMGPLy8pg6dSpXXHEFCxYsYOnSpdxxxx3xbprsD2VlsHGjOR20DeuPPP/KK5xz++38Enhq3Dhsl1yyb9etqTGrg44YYU4JFRERSVBl/jK+Lvsam8VGuju9Xa81DCM29XPQ0EHc//T9uz22prmG/3vn//iq9CtsFht/GP8HTj7o5B/V9kQViUaoaa7BH/LjS/JRnF1MrjeXNFdavJsmaOSaiMj+YbWZ00PtXghUxrs18iPZbDYeeOABysvLOfPMM3nttdeYM2cO+flaVy/hNTfDqlVmZdA2rKG3fPVqLv5uxFqhz4dtxgxz5Fl71dSY1z74YOjZs/2vFxER6SIqGitYWraUqBFtdyGB7d9u54KTLmDxZ4v3euy6qnVc+MqFfFX6FcmOZP524t8OyMRaOBpme8N2SupLcNqdjMwdyRG9jmBQ1iAl1roQjVwTEdlfHD5IHQSVX4C9GWxa/D6RrFq1qsXzoqIinnzyyTi1RjrMhg1QWdmm6qA19fX8/Ne/piEa5WirlTsefthcK629qqvNEWsHH9zmqqQiIiJdUXVTNUtKlxCMBMn15rbrtSVbSrj8l5ezbdM27px6J0/Pexrrbj6wWrh5IdPfm05DqIECXwGzj59N3/S+++MWEkbUiFLVVEVjqJFsTzYH9ziYnOQcHDZHvJsmrVByTURkf3Lng7cS6tdBcq82TTkTkU5SUmKutZaVtdfRZ9FolEm/+Q1r6uvpBcz9wx+w9+/f/msqsSYiIt1EbXMtS0qX0BRuIs+b167Xblq3iSt+eQVl35bRs3dPZj82u9XEmmEYPL3saf766V+JGlFG5Y3irmPuOqBGaBmGQU1zDfXBejLcGQzOHkyeL++AXWMuUah3RET2J4sVfAMgWAOB7eDqEe8WiQiY0zJXrICkJEjee1n6GXfeyRurVuEEXjr9dLJOOaX916yqgmAQhg/XVFAREUlo9YF6lpYtpTZYS4G3oF2vXbtyLVeeeyWV5ZX0OagPD8x9gOzcXdceDUVC3PnRnby66lUAzhh4BjccccMBNVKrtrmWmkANqc5URuaNJN+XrwIFCULJNRGR/c3uhpRBUPUZhBvAvvc/5EWkAzU3m4m1hoY2Jbm+XbWKmS+/DMBD/fszetq09l+zqgpCISXWREQk4fmDfpaWLaWqqYoCX0GsGEFbrPx6JVdOvJLa6loGDB7AnLlzSM/ctQBCTXMN179zPV+WfonVYuW3h/6WiUMntutaicwf9FPZVIkvycfBOQdTkFKA2+GOd7OkHZRcExHpCO4e4O0PtSsg2QUWW7xbJHJgikRg5UooLW1bkqumhrybb+YNw+Bdn48L//EPsLXz/VtZCeGwmVgraN+n+yIiIl1JfaCeJaVLKG8sp2dKz3Ynu55++Glqq2sZMnII9z15HylpKbscs65qHdfNu45t9dtIdiRz+9G3c0ThEfvrFrq0xlAjlU2VuO1uirOK6ZXai+QkfTCfiJRcExHpKN6+EKyGpjLwqMqkSFysX28WMcjL22uSLFhZSdKUKbB+PROys5nw8MOQsusfAXtUWWkm9JRYExGRBFcXqGNJ6RKqmqromdITq6X91bJvmnUTOXk5XHTVRXh9uxYFOhALFxiGgT/op6a5hiR7En3T+1KUWkSqKzXeTZMfQck1EZGOYkuClIFQWWeuwZaUFu8WiRxYSkpg1SrIyDDXWtuD+f/9L5fdeCNvhEIMzsiABx9s/3TOigqIRs3EWr4S6iIikrhqm2tZXLqYmuYa8n357Uqsrf1mLf0G9cNisZDkTOKqqVftcsyBWLggHA1T01xDQ6gBX5KPAZkDyPPlke7edZqsJJ72p55FRKTtnBmQOghCfog0x7s1IgeOHQUMHA7w7vpJ+c4Wfvopp//f/7EhFOIvDgfMmQO9e7fvehUVYBhKrImISMKraa4xE2uBGgp8Be1KrL335nucf+L5zL51NoZhtHpMU6iJW/57C7M/mU3UiHLGwDOYc+KcbptYaw43U1JfQqm/FLfDzai8URzR6wgG5wxWYq0b0cg1EZGO5ullJtfqVoGnAFRGW6RjtaOAweeLF3PS1VfTGI1ygs3GA3//Oxx0UPuuV15ufh0+3Jx+KiIikqCqm6pZUrqEumAdBd62Fy8wDIPnH3+ev/zhL0QiEcrLyolEItjtLX/v3VizkevnX8/66vVYLVauOfQazht6XrcrXGAYBnWBOmoDtTjtTvJ9+RSkFJDlycKuvwW6JfWqiEhHs1jAdxCE66Gp1EywdbNfIES6jHYUMPj6m284/je/oT4aZbzVyov33Ydz+PC2XysaNa/jdsPQoZCb+yMbLyIiEj+VjZUsLl1MU7iJfG9+mxNewUCQu266i1eefgWAU395KjfNugnbD9Y6nbduHn/68E80hhrJdGfy5wl/5pD8Q/b3bcRVKBKiprmGpnATviQfxdnF5HpzSXWmdrsEorSk5JqISGewJUHqEAg3QKACXNnxbpFI97Rhg/nIzd1jAYNV69ZxzCWXUBUOc6jFwuv33INnzJi2XyccNtd0y8oyE2vpmtYhIiKJq6KxgiWlS2gKNZHrzW1zIqhiewXXX3o9Sz9fitVq5erpV3P+r89v8fpgJMi9n9zLcyueA2BU3ihun3A7WZ6sDrmXzmYYBg2hBmoCNViwkOHKYHDOYLI92bgd7ng3TzqJkmsiIp3F4TMTbFVfmNNEHXteB0pE2unbb81RaxkZ4HTu/rholBunTGF7MMgI4K077sB35JFtv05zM5SVQWEhDBkCHs+PbbmIiEjclDeUs6R0CYFIgDxf25c3CIfDXPaLy9i8fjPeFC+3P3A7h//s8BbHfFv/LTe+eyPLy5cDcPGIi/n16F93i6mROxco8CZ56ZvWl1xvLhnuDGzWPVcol+4n8X+iRUQSiTsXfAOh5mtzNJt1zxUMRaSNamth+fK9FzAwDLjjDh4rK+Nai4WZf/wj6ccc0/br1NebxRIOOggGDTKvJyIikqDK/GUsKVtCOBIm19u+5Q3sdju/+f1veHj2w9z9z7sp6lfUYv9HWz7iDwv+QG2glhRnCreOv5VxReP2Z/Pjwh/0txilNihrEFmeLJKTkuPdNIkjJddERDqbtw9E/FC/HpILoR0VmESkFc3NZmJtLwUMAoEAzvvug5dfJtVq5dE//QmOO67t16mshGDQnAbaty9Y9d4VEZHE9W39tyzdvpRoNEoPb482vSYSifDt1m/pWWTG2+NOP46fnfgzHEnff9gUiUb4x5f/4J9f/ROAwVmDufOYO8n3JW417Z1HqSUnJdM7tTf5vnyNUpMYJddERDqb1WaOXgv5vytwkLi/aIjEXSgE33yz1wIGm0pKOHnSJC6qreX3AH/4Q9sTa4ZhTjl1OmHkSCgo2C9NFxERiYeoEWVj9UZWVq7EZrGRk5zTptfV1dQx7YpprF25lifefILsXHMN4Z0Ta5WNldy04CY+K/kMgLMHn821Y68lyZaYszUC4QBVTVVEjAgZ7gwGZg0k25OtUWqyCyXXRETiwe6GtCFQ8RkEqsCZEe8WiSSeYNAcsbZhA+Tl7baAwaIvv+S0q66iLBhkNjD5mmvIOOWUtl1jR+GCjAxzxFpm5v5rv4iISCcLRoKsrljNuup1+JJ8pLpS2/S69avX87uLf8eWjVtwuV2sW7Uullzb4eMtH3PrB7dS0ViB2+5m+rjpnND/hI64jQ7XGGqkqqkKm8VGD28PeqX2IsuTpVFqsltKromIxEtSOqQNhqovIdwIdi2KLtJmOyfW8vN3u/bZi6+8wvl//jPNhsFw4I1rriFj0qS2XSMQMEfEFRSYhQv2tJabiIhIF+cP+llRvoKtdVvpkdwDl93Vpte9//b7/HHKH2nwN5DXM4+7/3k3A4cObHHev376V15e+TIAfdP6MvOYmfRJ79Mh99FRDMOgPlhPTXMNLruL3mm96ZnSkwx3Rpurp8qBS8k1EZF4cheAtw7qVoKnALpB5SSRDteGxJphGMyaPZsbnn4agJPtdp65++62VwWtr4fqaujXD4qLISkxp7OIiIgAVDRWsHz7cqqaqijwFbSpWmeDv4F7b7uXl58yk2ajDhvFzIdmkp6ZHjvms22fcesHt1LqLwVg4tCJXPmTK9ucuOsKokaU2uZa6oJ1+JJ8FGcXk+fNa/OoPhFQck1EJL4sFkg5CCIN0LgNPD3NbSLSumAQvv4aNm3a44i1K377W/7+0UcAXO31cs+jj2Lv23fv549GoazMLFYwbBj06bPb6aYiIiJdnWEYbKnbworyFUSiEQpTCts8Cuux+x+LJdbOu/Q8pkyfgt1hphAaQ43ct+g+nl/xPAAFvgL+MP4PjM4b3TE30gHC0TDVTdU0hZtIdaUyvMdw8nx5eByaTSLtp+SaiEi8WR2QUgzhBmguA3f7yqCLHDACAVi2bK+JNZ57jhH/+x9WYHbPnkx57DFIS9v7+ZuaYPt2yMmBQYMgK2s/Nl5ERKRzhaNh1lSuYXXlarxJXrI92Xt/0U4uvvpiln+1nMnXTOaQww+Jbf/q26+45b+3sK1+GwBnFZ/FlEOnJExSKhQJUdlUSTgaJsOdwZCcIeQk5+C0O+PdNElgSq6JiHQFDi+kDoaqzyFUB46UeLdIpGvZObFWUAD2XX+FMcJhLPfeC3Pn8mtg3PjxDL7zzt0n4WIvNKCy0rzGgAHQvz+4Emc6i4iIyA81hhr5pvwbNtduJsuT1abE19LPl/Las68xbeY0rFYrnmQPDzz7QGx/c7iZOZ/NYe6yuRgY5Hpzufmomzm04NCOvJX9JhAOUNlUiYFBdnI2RalF5CTntGmKrMje6KdIRKSrcOWAbyBULwWbC6xa40kEaFNi7eNPP+X/bryRV+vryQS48koGX3TR3qdZB4PmNFCfz5wGmpenqdkiIpLQqpqqWL59OeWN5eR783HY9vwhUzAQ5KG/PMQTDz5BNBpl8PDBnHn+mS2OWVq2lFv+ewubazcDcMbAM/jt2N/iTer6xX6aQk1UNldixUquN1eVP6VDdOnkWllZGX/+85/55JNPcDqdnHTSSVx33XU4nU62bNnCzTffzOLFi8nPz2fatGkc2dZFikVEuqrk3hCsg8aN4CnUH/kigQAsXQpbtuw2sfbsc89x4axZBAyDm61WHrj9djjmmL2fu6bGLFxQWAgDB6oaqIiIJLSoEWVb3Ta+qfiGQDhAYUohVot1j69Z+fVK/vjbP7Ju5ToATvrFSRxzyvcx1B/088iXj/D0sqeJGlGyPdncdNRNHFF4RIfey/7QEGygqqkKh81Br5ReFKYWkunOVOVP6RBdNrlmGAZTpkwhJSWFp556itraWqZNM4enXn/99Vx55ZUMGDCAF198kfnz53PVVVfx5ptvkp+fH++mi4jsO6sNUgdCuE7rr4k0N5vFC3aTWAuGQtwyYwZ3vPkmAKc5HMy6/34YvZfFlCMRKC0FpxMOPhiKilS0QEREElpdoI41lWvYWrcVj8NDvm/PfxeHQ2H+df+/eOTeR4iEI6RnpjNt5jR+duLPAIhEI7y++nUe+PwBqpqqADj5oJP53WG/I8XZtZcvqQ/UU91cjdvhpl9GP3qm9CTNlaakmnSoLptcW79+PYsXL+ajjz4i67sFhadMmcLMmTM56qij2LJlC3PnzsXj8dCvXz8+/vhjXnzxRa6++uo4t1xE5EeyeyC1GCo/g1A9OHzxbpFI59tLYm35ypVMmjKFr6rMX/ivTU1l1r//ja2gYM/nbWiAigpz+ufAgZCR0VF3ICIi0uHC0TBb67ayunI1jcFGenh7kGTb+9Iif77hz7z+7OsATDhpAlPvnEp6ZjoAn5d8zj0f38PqqtUA9ErpxXWHXceRvbruTDHDMKgN1FIbqMWb5KU4u5h8X36XTwRK99Flk2vZ2dk88sgjscTaDn6/nyVLljB48GA8nu8XZRw9ejSLFy/u5FaKiHSQHeuv1exYf20vC7KLdCfV1bBihVm5s5XE2rwXX+S0O+8kYBhkAA+NHMlZ994Lycm7P2c4bJ7PaoXBg6FvX0jSuoYiIpK4qpuqWV25mpL6ElKcKRSmFu7xeMMwYqO3fjHpF3z4zof8fsbvOf7047FYLGyt28pfP/0rCzYuAMCX5OPSUZdy9uCz97puW7xEohFqmmvwh/ykOlM5OOdg8nx5JCft4XcCkQ7QZZNrKSkpjBs3LvY8Go3y5JNPMnbsWMrLy8nJyWlxfGZmJqWlpZ3dTBGRjuPtA6FaaNys9dfkwGAYsG2bmVhrboaePc1k2A6RCDzxBGMffJBcw2Cw3c4/p04l7/TT93zOqipobITcXOjXD7Ky9H4SEZGEFYqE2FSzibXVawlEAuT78vdY8bJiewUP3f0QaelpXDn1SgCGjhzKG4vewOV24Q/6efSrR3lm2TOEoiFsFhtnFp/Jr0f/mjRXWifdVfuEo2Gqm6ppCjeR4c5gQNYAcr25uOyq9i3x0WWTaz80a9YsVqxYwQsvvMBjjz1G0g8+bU5KSiIYDMapdSIiHcBqg9RBEK6HwHZw9Yh3i0Q6TigEa9bA2rXgdpsj1r5jGAbvvPEGx770EpavvyYF+N/YseTdcguWH4xwb2HHFNDUVBg1CvLzWy2IICIikijKG8pZW7WWb/3fkuHKINuTvdtjm5uaeeofT/H4nMdpbGgkyZnEeZedF5v+6XA6eHnlyzz4+YOxddXGFozl2rHX0i+jX6fcT3sFI0GqmqoIR8NkujMZ2mMoOck5bZoKK9KREuI3zFmzZvH4448ze/ZsBgwYgNPppKampsUxwWAQl0tZahHpZuzJkFIMVZ9DyA8OVTOUbsjvh2++MddXy86GnZZ9qKiu5jdXXcWLq1bxIPCb5GT4/e/JP+WU3Y8+C4WgrAwcDhg0CHr3bnFOERGRRNMcbmZjzUbWVa3DMAx6+npis7ZejCcajfLWS2/xwJ0PUPZtGQBDRg7h2j9eS3pmOoZh8NGWj5jz2RzWVK0BoCi1iGvHXssRhUd0yYX/m8PNsQRgdnI2RalFZCdn73HEnkhn6vI/iTNmzOCZZ55h1qxZHH/88QD06NGDtWvXtjiuoqJil6miIiLdgrsH+AZA7TKwObX+mnQvZWXmNNDa2l3WV3vzP//hkj/9idJQCDvQUFgIDz5oTu9sTTRqTgFtbjZHqfXrp4IFIiKS0MLRMKX+UtZXr6eisYIsd9Ye1xNbu3Itt157K98s/QaA3IJcrpp2FceddhxRory97m0eX/x4rFhBijOFy0ZdxlmDz+pyiapINEJdoI76YD1JtiTyffkUphaS5cnCarHu/QQinahrvXt+4P7772fu3Lncc889nHDCCbHtw4cP5x//+AfNzc2x0WpffPEFo0ePjldTRUQ6lrcPhOqgcQt4emq9KEl8kQhs2ACrVpnrqvX8/ue6pq6OG2+4gYc++wyAwRYLT5x/PqOuvrrlGmw7q683E2uZmTB0qJmAs7X+ib6IiEhXF4qEKGsoY2P1RioaK3DZXRSmFO41qZSSmsL61etJ9iZz8dUXc+4l52JxWHh51cv8e8m/2Va/DQCPw8OZg87kohEXdbl11fxBP7XNtRgYpDhTGJozlCxPFmmutC45qk4EunBybd26dTzwwANcdtlljB49mvLy8ti+MWPGkJeXx9SpU7niiitYsGABS5cu5Y477ohji0VEOpDVDikDv1t/rdysJiqSqJqaYOVK2LgR0tPB54vtevWJJ5h8//1URSIAXJuRwZ/vuw/3wIGtn6uxESorzXXahg6FXr1Ay0SIiEiC2pFU21C9gcrGSlx2F3m+vFZHlYWCId5+5W2WfL6E6XdNByAnL4eZD81k8IjBJKUkMXfFXJ5Z9gyVTZUApLnSOHfIuZw9+GxSXamdem97EowEqW2upTHcSHJSMr3SepHrzSXTndllK5WK7KzLJtfeffddIpEIDz74IA8++GCLfatWreKBBx5g+vTpnHnmmRQVFTFnzhzy8/Pj1FoRkU7g8ELKIKj6QuuvSeKqqjKngW7fDnl5sKNA0bZt8MAD9Hr7baoxR6vdf8op/Gz69NaLEPj95rlcLujbF4qKzMIFIiIiCSgUCVHqL2VjjTlSzW13k+/Lb3VdNX+dn5eeeom5j8xle+l2AE6feDpDRw4FoPjwYp5Z/gzPr3gef9APQK43l/OHnc/pA0/H7XB33o3tQdSImtM+A/XYrDYyPZkU+4rJ8ux56qtIV9Rlk2uXXXYZl1122W73FxUV8eSTT3Zii0REugB3LvgO+m79NZc5ok0kEQSDsHkzrFtnFhwoLASrlUWffsoXjz3G5YsXQyjESIuFd8eMYdy0adh3qhgasyOp5nZD//7medLSOvtuRERE9osdSbUNNeZINbfdTYGvoNWkWllJGXP/OZeXnnqJhvoGALJ6ZHHuJedS1LeIdVXreOGbF3ht1WsEIgEA+qT14cLhF3JC/xO6xJpqhmHgD/qpC9QRJYovyceg7EFke7JJd6drLTVJWPF/d4mISPt4+0Kodqf117SulHRhhmEWLVizBsrLzURYVhYbN21i6tSpzF29GgdwLNB/zBiYMoWfDRq063nq66G62qz6OWCAuUabRqqJiEiCag43s71hOxuqN1DVVIXH4dltUg1gyWdL+PXZvyYcCgPQ56A+TLp8EkeedCTvb32fqxZcxfLy5bHjh2QP4eIRF3NU0VFxT1gZhkFDqIG6QB2RaITkpGSK0oro4e1Buisdp90Z1/aJ7A9KromIJBqrHVKHQDQMDdsguSfoUz7piurqzJFqW7aYUzt79qTG7+f23/6Wvy5cSBCwAOf5fCRffz2ccMKuxTrq6sykWnIyDBpkJtV2WqNNREQkUUSNKDXNNZTWl1JSX0JdsI5kR3KrSbWaqho2rdvE8J8MB2DIiCFkZmdS0KuA839zPq5iF2+seYOZz8+MjVKzWWyM6zWOc4eey+i80XFd/N8wDBpDjdQF6ghFQyQnJVOYWkhOcg4Z7gxcdq2PKt2LkmsiIonI7oG0YWBEoLEEPAWqICpdx85TQJuaICeHpmiUv8+axZ9ffpnK74oVTHA4uPvCCxl56aUtK3tGo2ZSrbYWvF4YMgQKCszvRUREEkxzuJmKxgq21m2loqGCcDRMijOFXim9WiTAQsEQC99dyH9e+A8L311IemY6byx6A5vNht1hZ/aLs/mw8kPuWX0PW9/aGntdn7Q+nD7wdE7sfyKZnsx43CLwfUKtPlhPMBLE4/CQ58sj15tLujsdj8MTt7aJdDQl10REEpXDC+kHQ9VX0FQC7nwl2CS+DANKS2Ht2u+ngKakwLx5hJ96ilvWrKEOKLZYuPuEEzhx6lQsnp1+0W5uhpoac022lBQYNgzy881RayIiIgnEMAyqm6sp85exrW4b9cF6nDYnGe6MFtMgDcNgxZIV/OeF//D2K29TW10b25eZncnmrZtZG17L62te55OtnxA1ogAkO5I5rt9xnDbgNIbmDI3bKLVINEJDqIH6QD0RI4LH4SE7OZs8bx4Z7gwVJpADhpJrIiKJzJEC6cOh6ktoLgV3XrxbJAeqH0wB/WzLFl6cMYM7Nm/GUlWFD7jFZsM7YgQXz5iBPSfHfN2OUWp1dWbl0Oxsc5Radvb3lURFREQSxO5GqRWmFLaaAHvk3kd46O6HYs+zemTx01N/StqhaXxj/Ybz5p9HKBqK7R+VN4rTBpzG0X2OjlvVz1AkRH2wnsZQIwDeJC9FaUVkJ2eT6kxVQk0OSEquiYgkuqS07xJsX0FzGbh6xLtFciBpaIBvv4V164j4/bz2wQfc8+STLKyqAuB44GfZ2XDOOVz7859/X9kzEDDXUgsGzVFqgwdDTo65XyMwRUQkgTSGGqlprmF7w3bKG8rxB/27jFKLRCIs+3IZC+cvZOxPxzL6sNEAHP6zw3ns/sf4yYSfkH5oOhsyNvBi5YsY24zY+QtTCjmm7zGcNuA0ClMLO/3+DMOgOdyMP+inKdyEw+rA5/TRK7UX6e500lxpJNn0gZgc2JRcExHpDpyZ308Rba4AV1a8WyTdXW2tmVTbvJn6sjL+9eyz/HX+fNYHzEWVHcC5qankXXQRTJxoFjSIRs3X1dWBwwFZWWaBgqwscKpSmIiIJI6GYAPVzdVs92+noqmChmADdqu9xSg1f52fD97/gA/nf8hH730Um/JZU13DyLEjWbZ9GQuaF5DzxxwWBhaCAVSa5x+SPYTxReP5ae+f0ietT6dO+9yRTGsINdAcbsYwDFwOF6muVAZ6B5LmSiPFmbLbyqYiByIl10REugtXjplgq14MgSpwZsS7RdLdGAZUVcHWrVBSAlu3svmDDzj4qaeoNcxP2DOA3/TuzZVXXUX++PHma+rrzQeYRQkGDYIePTRKTUREEoZhGPiDfrPap7+UqqYqGkINOG1OvEleMlIyYgmwxoZGrrvoOr5a9BWRcCR2Do/PQ+GoQlZnrOaYJ46hLlAX22e32vlJ/k8YXzSe8UXjyU7O7tR7awo30RhqNJNpGLjsLrwOL73TepPiTMHn9JHsSI5rBVKRrkzJNRGR7sSdB0bUTLAFa8wpoyI/ViQCFRWwZQvL332X1QsW8PPSUli6lELDIAPoYbFw7ZgxXPD73+Pp1Qv8fti2zXy91wt9+5rrqKWna5SaiIgkhB1ri9UF6ij1l1LTXENTqIkkWxIpzhTSnemsX7WeDxd9iL/ez8VXXwyAJ9lD2bdlRMIRMgoz8AzxUFVYRWNuI6tsq8yTB8yiBEf2OpLxReM5vPBwvEmdUxU7HA3TFGqiOdxMc7gZi8WCy+7C5/TRN70vPqcPX5IPj8OjZJpIGym5JiLS3XgKwIhA9RKwWM2iByL7IhSC7dvZ9P77zH3wQZ7+8kuWNjWRDpwEOAHLyJHMP/RQep99NlYwR6iVlIDPB/36mQm1tDQl1EREpMuLGlH8QT91gToqGyupaKygMdRIOBrGZXfhNJxsW72NxZ8uZvGixSz5fAn1tebIbHeym4N/fjDfVH3DF99+QcUxFeCCqswqqjDXIfU4PIzIHcGo3FEckn8Ig7IGYbd27J/koUgolkQLRAIYhoHdasdld5HmSiPLk2Um05w+3Ha3kmki+0jJNRGR7ii5F0TDUPO1mWCzd84nodINfDeNs2LFCl64/Xaeev99Fu6Y0om5ltpRXi+V55xD/skng89H38ZGM6nm9UL//uYaaunpqvYpIiJdXmOokbpAHbXNtZQ1lOEP+gmEA1ixUl9aT//+/XHYHABcM+kaPnrvoxavtzltOHo7aMpr4tev/hp2hL4Cc2TaiNwRjM4bzai8UR2aTDMMg2AkSCASIBAOEIgEiBpRHFaHmUhzp5HpziQ5KRmPw4PH4VERApH9SMk1EZHuytvHnCJau9xMmDh88W6RdGHRujqiX32F/c03YeFC/rpoEX8KhwGwAOOdTs475BB+MXEiGUVF5qi2pCTzUVhoJtOUUBMRkS4sEo3QGGqkIdSAP+CnoqmC2kAttf5atqzdwrbV29i8ajPrvlnHmhVraPA38NSHT1HvqmdlxUrK0suweq1EC6PQC+gFkdwIEZu5rlq2J5tBWYMYlTeK0XmjGZA5YL8n03ZOogUjwVjBAYvFgsPmwGlzku5JJ8OVoUSaSCdSck1EpLuyWMDX1/zevxrCDWbRA4s1vu2SLqN02TLm/fWvvD1vHu9s3cp90Si//G7fecB/7Hb+39Ch/PLnP6fn0KFmxc/kZHNkWkYGpKSY0z+t+pkSEZGupynUREOogYZgg1mIoKaUDRs2kJaThsvjwml38uo/X+WRux8hEonsegI7/L9//j/o/d3zYmAoYIEeyT0YlDWIQVmDKM4qZlDWILI8+69aezgaJhgJEowECUVCBCNBokYUgCR7Ek6bk1RnKoUphXidXtx2Ny67C7fD3eFTTUVkV3rXiYh0ZxYrpPSHpFSoWwkNW8DdA2yueLdM4iAUCLDw4Yd5+6mneHvJEhY3NbXY/67Fwi+HDoURIygeOpQvDzoIPB5zzbScHDOZlpICDkd8bkBERKQVkWgktq5Yc7iZzaWbWfT5ItauWcvG9Rsp2VDCtg3b2F6yHSNqMPGuiTgPcrK5bjNfb/3aTKy5gdwfPLLAYrOQ78vnoIyDzERadjGDMgeR6cn8UW2OGtFYAm1H8iwUDWEYBljAbrHjsDtIsiaR7knH5/DhdXrNBJrdrSSaSBejd6OIyIHAlW2uu1a/GvwbwZEMSenxbpV0sJLly6n98EOKN2+Gjz+m7PPPmeD3tzhmlN3O8b16ccLYsRx2wgmQl2eunZaVZY5KS0kBtztOdyAi0r0FAgFuvfVW5s2bh8vlYvLkyUyePDnezeqSdkyHrG2oZcOmDazftJ5NmzaxYdMGtmzewrgzx+Hp7aGysZIPXvmA//7tv62fKAmeWfQMNH73vBC4FpLSk+id3pveab3pk9aH3qnm94Wphbjs7ftQckfiLBQJEYqGCEfDsed8Vy/AYrFgt9hJsiWRZEsi3Z2OL8mHy+HCaXPitDtjX62adSDS5Sm5JiJyoLC7IW2YmVSrXQmNW8GVC/rUs1torq/nqxdf5JPXX+eTzz/nk5ISNofDHAO8890xPYEJViv56emccPDBHHvaaeSMHGlO8UxLM6d8JiersqeISCe56667WLZsGY8//jglJSXccMMN5Ofnc8IJJ8S7aZ0uGAyytWQrW0u2su3bbWz7dhtDfjIEd46bbfXbmPfWPF6Y+QKN1Y2tvv6t5rdg1HdP/EAWkNny4e7hJi8vj4KUAvK85tc+aX3ok9aHHt4ee0xiRY0okWiEcDRMxIjEEmY7HjtGnFnM/5gjz2wOHFYHKc6U2NpnTrsTh9URS6rteKhKp0hi019UIiIHEovVrCTqSDGniTZuA1cW2JPj3TJph8bSUjwbNsCyZbB8Occ//jgLamoI/eA4KxBwOOCww6C4GIYN492RI80pnj6fmUjzeLRmmohIHDQ2NvL888/z8MMPM2TIEIYMGcKaNWt46qmnEj65Fg6HqampobKyksrKSraWbmVz6Wa2bd/GoEMH4SvwUdVcxaIPF/HGX9/AX+Un1PDDKAacCoz+7vv1QPV339uB1B888iDVmUpOcg55RXnknZhHnjePfF8++b588rx5+JJ8GBhmosyIxBJmESNCdVN1bNuOZJnFYsHAAL4faWa3mg+b1UayIxmX3RUbbWa3fp9QS7Il4bCZXzXyTKT7U3JNRORAlJQG6aPAkQb1ayDcqHXYuqCG7dtZ8dZbLPvwQ5YtXsyyTZtYVlWFNRply07HGUAIyAYOS01lbO/ejD30UA454wx8xcVmAs3tNh92hX4Rka5g5cqVhMNhRo4cGds2evRo/v73vxONRrF28gcfhmHQ0NhAZW0lFTUVeFI8WF1WmsJNrN+4nk8/+pSqmipqamqoraulrrYOf70ff72fgacMxDfIR32wno0fb2T1A6t3f6FTgEO++349tAhoVsALJH/31QsOq4M0Vxppw9Jw3+SmR0EPcnNyyfBkkOHKIM2dRrornTRnGlarFcMwiBgRMylmYE7DNKAuWEd9sB6rxYrVYsVmtZlfLTZsVhsuu5kgS7In4bK5cNgc2Ky275NpFlsscbZjm0abicgO+g1bRORAZUuClIFmsYPaldBcBkn7r8qV/Ahvv825Z53Fc37/d5+X76o2PZ3Uvn2hTx/+kpaG9/DD6X3MMVi8XjOJ5nSaFWNFRKRLKi8vJz09naSkpNi2rKwsAoEANTU1ZGRkdNi1S+pLOOHmE/jmyW+IBqNEA1HzU5qdg85ZmJUxAZYDz+/+fJtyN33/2p2X9nRiFgpwAx6wJ9vx5fnITM/Ek+TBleHCyDfIyMkgMyuTnMwcUt2peJ1eUpwp5nRKuweb1YbFYoklxqxYsVgssQTZzgkvu9Vcx2zH6LIdybPdfd2ROFOiTER+DCXXREQOZBYLuPPMaaK1KyHSSGylXYmf994j/bvEWo7FwtDkZIb26MHQ/v0Z+pOfMOTkk0kZNAhcLkhKYpimdYqIJJympqYWiTUg9jwYDHbotddUruHrkq+hcjcH2MFm2MzpjnYnllwLjQMbsXvsJHmScHqcuJJduL1uPF4PhcMKyS3KJTkpmaTDknCc4yA3K5d0bzqpzlRSnamx6pY7EltWi7VlwmwPDwuWXUabxfYpKSYiXYCSayIiYq65lj7CTK6pwEH83XYbN40dy63JyeQceqi5PpoSaCIi3YrT6dwlibbjucvVsUs1HFV0FO/+4V0WnrYQX7KPzNRMMlIzyE7PJis1izR3Gg6bAwuWWPJqR5LLYrHEvra2TUTkQKS/oERExGS1gdUX71Z0KYFAgFtvvZV58+bhcrmYPHkykydP7vgLO50U/PznHX8dERGJmx49elBdXU04HMb+3XqY5eXluFwuUlJSOvTaFouFCUMnMGHohA69jojIgULJNRERkd246667WLZsGY8//jglJSXccMMN5OfnJ3wVNxERib/i4mLsdjuLFy/mkEPMFf6/+OILhg0b1unFDERE5MfRv9oiIiKtaGxs5Pnnn2f69OkMGTKEY489ll/96lc89dRT8W6aiIh0A263mzPOOINbbrmFpUuXMn/+fB599FEuuOCCeDdNRETaSck1ERGRVqxcuZJwOMzIkSNj20aPHs2SJUuIRqNxbJmIiHQXU6dOZciQIVx44YXceuutXH311Rx33HHxbpaIiLSTpoWKiIi0ory8nPT09BaV3LKysggEAtTU1JCRkRHH1omISHfgdruZOXMmM2fOjHdTRETkR9DINRERkVY0NTW1SKwBsec/rO4mIiIiIiIHLiXXREREWuF0OndJou147nK54tEkERERERHpgpRcExERaUWPHj2orq4mHA7HtpWXl+NyuUhJSYljy0REREREpCtRck1ERKQVxcXF2O12Fi9eHNv2xRdfMGzYMKxWhU8RERERETHprwMREZFWuN1uzjjjDG655RaWLl3K/PnzefTRR7ngggvi3TQREREREelCVC1URERkN6ZOncott9zChRdeiNfr5eqrr+a4446Ld7NERERERKQLUXJNRERkN9xuNzNnzmTmzJnxboqIiIiIiHRRmhYqIiIiIiIiIiKyj5RcExERERERERER2UdKromIiIiIiIiIiOyjA3bNNcMwAPD7/XFuiYhI95GcnIzFYol3M7oExRkRkY6hWGNSnBER6Rj7EmcO2ORaQ0MDAOPHj49zS0REuo8vvvgCr9cb72Z0CYozIiIdQ7HGpDgjItIx9iXOWIwdH3kcYKLRKNu3b9cnXyIi+5H+Tf2e4oyISMfQv6smxRkRkY6xL/+uHrDJNRERERERERERkR9LBQ1ERERERERERET2kZJrIiIiIiIiIiIi+0jJNRERERERERERkX2k5JqIiIiIiIiIiMg+UnJNRERERERERERkHym5JiIiIiIiIiIiso+UXBMREREREREREdlHSq7tRiAQYNq0aRxyyCEceeSRPProo7s9dsWKFZx99tkMHz6cX/ziFyxbtqwTW9o+7bmvyy+/nIEDB7Z4LFiwoBNb2z7BYJBTTjmFTz/9dLfHJFJf7dCW+0qUviorK2PKlCmMGTOGcePGcccddxAIBFo9NpH6qj33lSh9BbBp0yYuueQSRo4cyU9/+lMeeeSR3R6bSP3VVSjOJNb7ARRnEqGvFGcSp69AcaYzdMdY053jDHTPWNOd4gx0z1ijOLMf+sqQVt12223GqaeeaixbtsyYN2+eMXLkSOOtt97a5biGhgbjiCOOMO68805j7dq1xowZM4zDDz/caGhoiEOr966t92UYhnHssccar776qrF9+/bYIxAIdHKL26a5udm48sorjQEDBhiffPJJq8ckWl8ZRtvuyzASo6+i0ahxzjnnGL/61a+M1atXG5999plx7LHHGnfeeecuxyZSX7XnvgwjMfrKMAwjEokYxx13nPG73/3O2LBhg/H+++8bo0aNMl577bVdjk2k/upKFGcS5/1gGIozidBXijOmROgrw1Cc6SzdMdZ01zhjGN0z1nSnOGMY3TPWKM7sn75Scq0VDQ0NxrBhw1q8+efMmWOcf/75uxz7/PPPGxMmTDCi0ahhGOYP5rHHHmu8+OKLndbetmrPfQUCAaO4uNhYv359ZzZxn6xZs8Y47bTTjFNPPXWP/2gnUl8ZRtvvK1H6au3atcaAAQOM8vLy2LbXX3/dOPLII3c5NpH6qj33lSh9ZRiGUVZWZlxzzTVGfX19bNuVV15p/PGPf9zl2ETqr65CcSax3g+KM4nRV4ozidNXhqE40xm6Y6zprnHGMLpnrOluccYwumesUZzZP32laaGtWLlyJeFwmJEjR8a2jR49miVLlhCNRlscu2TJEkaPHo3FYgHAYrEwatQoFi9e3JlNbpP23Nf69euxWCwUFhZ2djPbbdGiRRx66KE8++yzezwukfoK2n5fidJX2dnZPPLII2RlZbXY7vf7dzk2kfqqPfeVKH0FkJOTw7333ovX68UwDL744gs+++wzxowZs8uxidRfXYXiTGK9HxRnEqOvFGcSp69AcaYzdMdY013jDHTPWNPd4gx0z1ijOLN/+sq+vxrenZSXl5Oenk5SUlJsW1ZWFoFAgJqaGjIyMloc279//xavz8zMZM2aNZ3W3rZqz32tX78er9fL9ddfz6JFi8jNzeXqq69m/Pjx8Wj6Hp133nltOi6R+grafl+J0lcpKSmMGzcu9jwajfLkk08yduzYXY5NpL5qz30lSl/90IQJEygpKeFnP/sZxx9//C77E6m/ugrFmcR6PyjOJEZfKc4kTl/9kOJMx+iOsaa7xhnonrGmu8UZ6J6xRnFm//SVRq61oqmpqcU/2EDseTAYbNOxPzyuK2jPfa1fv57m5maOPPJIHnnkEcaPH8/ll1/O119/3Wnt3d8Sqa/aI1H7atasWaxYsYJrr712l32J3Fd7uq9E7au//e1v/P3vf+ebb77hjjvu2GV/IvdXvCjOJO77YU8Sqa/aI1H7SnEmcfpKcaZjdMdYc6DHGUicvmqPRO6r7hhrFGdM7e0rjVxrhdPp3OV/4o7nLperTcf+8LiuoD33dcUVVzBp0iRSU1MBGDRoEMuXL+e5555j2LBhndPg/SyR+qo9ErGvZs2axeOPP87s2bMZMGDALvsTta/2dl+J2FdArG2BQIDf//73XH/99S2CT6L2VzwpziTu+2FPEqmv2iMR+0pxJnH6ChRnOkp3jDUHepyBxOmr9kjUvuqOsUZx5nvt7SuNXGtFjx49qK6uJhwOx7aVl5fjcrlISUnZ5diKiooW2yoqKsjJyemUtrZHe+7LarXG3jA79O3bl7Kysk5pa0dIpL5qj0TrqxkzZvCvf/2LWbNmtTokFxKzr9pyX4nUVxUVFcyfP7/Ftv79+xMKhXZZfyER+yveFGcS6/3QVonUV+2RaH2lOJMYfaU40/G6Y6w50OMMJE5ftUci9lV3jDWKMz+ur5Rca0VxcTF2u73F4nVffPEFw4YNw2pt+b9s+PDhfPXVVxiGAYBhGHz55ZcMHz68M5vcJu25rxtvvJGpU6e22LZy5Ur69u3bGU3tEInUV+2RSH11//33M3fuXO655x5OPvnk3R6XaH3V1vtKpL7aunUrV111VYtAuWzZMjIyMlqsZwKJ119dgeJMYr0f2iqR+qo9EqmvFGcSp68UZzped4w1B3qcgcTpq/ZItL7qjrFGcWY/9FWb64oeYG6++Wbj5JNPNpYsWWK88847xqhRo4y3337bMAzD2L59u9HU1GQYhmHU19cbY8eONWbMmGGsWbPGmDFjhnHEEUcYDQ0N8Wz+brX1vt5++21jyJAhxssvv2xs3LjRuO+++4yDDz7Y2LJlSzybv1c/LPGcyH21sz3dV6L01dq1a43i4mJj9uzZxvbt21s8DCNx+6o995UofWUYhhEOh40zzzzTmDx5srFmzRrj/fffNw4//HDjscceMwwjcfurK1GcSZz3w84UZ7puXynOJE5fGYbiTGfpjrGmu8cZw+iesaY7xBnD6J6xRnFm//SVkmu70djYaFx//fXGiBEjjCOPPNL417/+Fds3YMAA48UXX4w9X7JkiXHGGWcYw4YNM8466yxj+fLlcWhx27Tnvp577jnjuOOOM4YOHWr8/Oc/NxYtWhSHFrfPD//RTuS+2tne7isR+uqhhx4yBgwY0OrDMBK3r9p7X4nQVzuUlpYaV155pTFq1CjjiCOOMB588EEjGo0ahpG4/dWVKM4k1vthB8WZrttXijOmROirHRRnOl53jDXdPc4YRveMNd0hzhhG94w1ijOmH9tXFsP4btybiIiIiIiIiIiItIvWXBMREREREREREdlHSq6JiIiIiIiIiIjsIyXXRERERERERERE9pGSayIiIiIiIiIiIvtIyTUREREREREREZF9pOSaiIiIiIiIiIjIPlJyTUREREREREREZB8puSYHnBtvvJGBAwfu9vHSSy8xcOBAtm7d2intMQyDSZMmsW7dOrZu3crAgQMZMWIEgUBgl2PvvvvuWBv3h48//ph169YB8NJLLzFhwoR9Os/s2bN57rnn9kubREQSneLM9xRnREQ6hmLN9xRrpCtQck0OONOnT2fhwoUsXLiQadOmkZubG3u+cOFCTjnlFBYuXEheXl6ntOfll18mPz+ffv36xbaFw2H+97//7XLs/PnzsVgs++3aF110ERUVFT/6PJdccgkPPfQQ1dXV+6FVIiKJTXHme4ozIiIdQ7Hme4o10hUouSYHHJ/PR3Z2NtnZ2fh8Pmw2W+x5dnY2SUlJZGdnY7PZOrwthmHw4IMPMnHixBbbDznkEN57770W29atW0dDQ0OnBcj2SElJ4cgjj+Tpp5+Od1NEROJOcWb/U5wREWlJsWb/U6yRH0PJNZEf2DGMeccQ6oEDB/LWW29x4oknMnz4cK677jq2bNnCBRdcwPDhwznvvPMoKyuLvf6dd97hpJNOYvjw4Zx11lksWrRot9dauHAhTU1NDB8+vMX2o48+mgULFmAYRmzb/PnzOeaYY1p8yhONRnnkkUc4+uijOfjgg5k0aRKrVq2K7R84cCCvvvoqp5xyCkOHDuW8885jy5YtALHh0hdccAH33XcfYAbG++67j0MPPZRDDjmEmTNnxs5VUlLC5MmTGTlyJIcddhgzZswgFArF9k+YMIFnn32WaDTa9v/ZIiIHIMUZxRkRkY6mWKNYI51LyTWRNvjb3/7GnXfeyUMPPcS8efOYOHEiEydOZO7cuZSXl/Pwww8DsHLlSm644QYuv/xyXnvtNU477TQuvfRSNm3a1Op5P/zwQw477LBdhkUffvjh+P1+vv7669i2d955h2OOOabFcXPmzOHRRx9l2rRpvPzyyxQUFPCrX/2KxsbG2DH33Xcf06dP56WXXqK6upp7770XgBdeeCG2f/LkyYAZbDZs2MDcuXO57bbb+Ne//sUHH3wAwIwZM/B4PLzyyivMmTOHt99+u8WaBGPHjqWiooLVq1fvy/9iEZEDmuKM4oyISEdTrFGskY6j5JpIG1x00UUMHz6csWPHUlxczOGHH86JJ55IcXExxx13HBs2bADgn//8J+eccw6nnnoqRUVFXHDBBRx11FE888wzrZ53xYoVLdYl2MHpdHLEEUfw7rvvAlBWVsbmzZsZM2ZM7BjDMHjyySe55pprOProo+nXrx8zZszAZrPx2muvxY67+OKLOeywwxgwYAATJ05k2bJlAGRkZACQmppKcnIyAA6Hgz/96U/06dOHk046iUGDBrFy5UoAtm3bhs/nIz8/n1GjRvGPf/yD8ePHt2hzYWEhK1as2Of/zyIiByrFGcUZEZGOplijWCMdR8k1kTYoLCyMfe9yuSgoKGjxPBgMAuYaAk8++SQjR46MPRYsWMDGjRtbPW9VVRXp6emt7jv66KNjaxTMnz+f8ePH43A4YvsrKyupqalpMfza4XAwdOjQWLUcgKKiotj3Xq+3xbDnH8rMzMTj8cSe+3y+2L396le/4vXXX+ewww7juuuuo6SkhJ49e7Z4fVpaGpWVlbs9v4iItE5xRnFGRKSjKdYo1kjHsce7ASKJ4IcLgVqtreelI5EIl156KWeccUaL7S6Xq9XjLRYLkUik1X0//elPuemmm9i6dSvvvvsu5557bov9Tqdzt23YeY2AnYPX3rS24OmONRJOO+00DjvsMObPn8/777/PlClTuPTSS7n22mtjx0aj0d3+vxERkd1TnFGcERHpaIo1ijXScfQTI7If9enTh61bt1JUVBR7PPvss7E5/j+UmZlJTU1Nq/syMjIYOXIkr7/+OkuXLmXcuHEt9vt8PrKysli8eHFsWygUYvny5fTp02d/3VLM7NmzqaysZOLEiTz00EP89re/Zd68eS2Oqa6uJisra79fW0RETIozijMiIh1NsUaxRtpPyTWR/eiiiy7izTff5N///jebN2/mscce47HHHqN3796tHj948OAWlXB+6Oijj+bhhx9mzJgxuN3uVq/3t7/9jffee49169Zx8803EwgEOOmkk9rUXo/Hw5o1a6ivr9/rsevXr+e2225j5cqVrFmzhv/+978MHjw4tt/v97Nt2zaGDBnSpmuLiEj7Kc4ozoiIdDTFGsUaaT8l10T2oxEjRnDXXXfx9NNPc9JJJ/Hcc8/xl7/8hZ/85CetHj9u3Di+/PLLFuWpd3b00UfT0NCwS0WdHSZPnszZZ5/NzTffzJlnnklpaSlPPPFEbGHPvZk0aRJ33XVXrGz1ntxyyy1kZWUxadIkzjnnHHJycpg+fXps/1dffUVubi79+/dv07VFRKT9FGcUZ0REOppijWKNtJ/F2N07QEQ6XCQS4fjjj+eOO+7YbbBKFFOnTqWwsJArrrgi3k0REZHvKM6IiEhHU6wR0cg1kbiy2WxcdtllzJ07N95N+VGqq6v56KOPmDhxYrybIiIiO1GcERGRjqZYI6LkmkjcnXXWWZSUlLQoNZ1oHn30US6//PLdluAWEZH4UZwREZGOplgjBzpNCxUREREREREREdlHGrkmIiIiIiIiIiKyj5RcExERERERERER2UdKromIiIiIiIiIiOwjJddERERERERERET2kZJrIiIiIiIiIiIi+0jJNRERERERERERkX2k5JqIiIiIiIiIiMg+UnJNRERERERERERkHym5JiIiIiIiIiIiso/+P2tmnL5C7+U3AAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -1464,603 +1245,49 @@ } ], "source": [ - "# Plot predicted values for S, I, and R with 90% credible intervals\n", + "# Plot predicted values for S, I, and R with 95% 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", + " \"# Susceptible (Millions)\",\n", " \"orange\",\n", - " \"Actual # Susceptible\",\n", + " \"Ground Truth\",\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", + " \"# Infected (Millions)\",\n", " \"red\",\n", - " \"Actual # Infected\",\n", + " \"Ground Truth\",\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", + " \"# Recovered (Millions)\",\n", " \"green\",\n", - " \"Actual # Recovered\",\n", + " \"Ground Truth\",\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": 27, - "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(StaticIntervention):\n", - " def apply_fn(self, dynamics, state):\n", - " with pyro.poutine.block(hide_types=[\"intervene\"]):\n", - " return super().apply_fn(dynamics, state)" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "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": 29, - "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(obs_times, data, init_state, logging_times, base_model=PlaneSuperSpreaderSIR) -> None:\n", - " sir = bayesian_sir(base_model)\n", - " batch_obs = condition(data=data)(sir.observation)\n", - " landing_obs = condition(data=landing_data)(sir.observation)\n", - " reparam_config = AutoSoftConditioning(scale=.1, alpha=0.5)\n", - " with TorchDiffEq():\n", - " with pyro.poutine.reparam(config=reparam_config):\n", - " with StaticObservation(landing_time, observation=landing_obs):\n", - " with StaticBatchObservation(obs_times, observation=batch_obs):\n", - " with superspreader_intervention:\n", - " simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3)\n", - "\n", - "\n", - "def counterfactual_sir(obs_times, data, init_state, logging_times) -> State:\n", - " sir = bayesian_sir(PlaneSuperSpreaderSIR)\n", - " batch_obs = condition(data=data)(sir.observation)\n", - " landing_obs = condition(data=landing_data)(sir.observation)\n", - " with LogTrajectory(logging_times) as lt:\n", - " with TorchDiffEq():\n", - " with StaticObservation(time=landing_time, observation=landing_obs):\n", - " with superspreader_intervention:\n", - " with StaticBatchObservation(obs_times, observation=batch_obs):\n", - " with TwinWorldCounterfactual() as cf:\n", - " with inverse_superspreader_intervention:\n", - " simulate(sir, init_state, logging_times[0], logging_times[-1] + 1e-3)\n", - " trajectory = lt.trajectory\n", - " with cf:\n", - " factual_indices = IndexSet(\n", - " **{k: {0} for k in indices_of(trajectory, event_dim=1).keys()}\n", - " )\n", - "\n", - " cf_indices = IndexSet(\n", - " **{k: {1} for k in indices_of(trajectory, event_dim=1).keys()}\n", - " )\n", - " \n", - " factual_traj = gather(trajectory, factual_indices, event_dim=1)\n", - " cf_traj = gather(trajectory, cf_indices, event_dim=1)\n", - " \n", - " # This is a small trick to make the trajectory variables available to pyro \n", - " for k in trajectory.keys():\n", - " pyro.deterministic(k + '_factual', factual_traj[k])\n", - " pyro.deterministic(k + '_cf', cf_traj[k])" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "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 TorchDiffEq():\n", - " with superspreader_intervention:\n", - " num_infected_in_millions = simulate(sir_true, init_state, torch.tensor(0), landing_time)[\"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 TorchDiffEq():\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)[\"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": 31, - "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": 32, - "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: 58092.1367\n", - "[iteration 0100] loss: 20789.3926\n", - "[iteration 0200] loss: 916.2467\n", - "[iteration 0300] loss: 859.0110\n", - "[iteration 0400] loss: 890.1702\n", - "[iteration 0500] loss: 838.2838\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", - " obs_times=obs_logging_times,\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": 33, - "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", - " obs_logging_times, sir_data, init_state, logging_times\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 34, - "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": 35, - "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": [ - "" - ] - }, - "execution_count": 35, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "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": 36, - "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": [ - "
" - ] - }, - "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()" + "ax[1].axhspan(lockdown_trigger_min, lockdown_trigger_max, color=\"grey\", linestyle=\"-\", label=\"Lockdown Trigger\", alpha=0.15)\n", + "ax[1].legend()\n", + "ax[2].axhspan(lockdown_lift_trigger_min, lockdown_lift_trigger_max, color=\"grey\", linestyle=\"-\", label=\"Lockdown Lift Trigger\", alpha=0.15)\n", + "ax[2].legend()" ] }, { diff --git a/scripts/test_notebooks.sh b/scripts/test_notebooks.sh index 6e3664410..72a1d86a3 100755 --- a/scripts/test_notebooks.sh +++ b/scripts/test_notebooks.sh @@ -1,5 +1,5 @@ #!/bin/bash -INCLUDED_NOTEBOOKS="docs/source/tutorial_i.ipynb docs/source/backdoor.ipynb docs/source/dr_learner.ipynb docs/source/mediation.ipynb docs/source/sdid.ipynb docs/source/slc.ipynb" +INCLUDED_NOTEBOOKS="docs/source/tutorial_i.ipynb docs/source/backdoor.ipynb docs/source/dr_learner.ipynb docs/source/mediation.ipynb docs/source/sdid.ipynb docs/source/slc.ipynb docs/source/dynamical_intro.ipynb" CI=1 pytest --nbval-lax --dist loadscope -n auto $INCLUDED_NOTEBOOKS