diff --git a/docs/source/explainable_categorical.ipynb b/docs/source/explainable_categorical.ipynb
index 2c949678..f12d638e 100644
--- a/docs/source/explainable_categorical.ipynb
+++ b/docs/source/explainable_categorical.ipynb
@@ -703,7 +703,7 @@
        "<text text-anchor=\"middle\" x=\"219.61\" y=\"-84.95\" font-family=\"Times,serif\" font-size=\"14.00\">bill_hits</text>\n",
        "</g>\n",
        "<!-- prob_bill_hits&#45;&gt;bill_hits -->\n",
-       "<g id=\"edge5\" class=\"edge\">\n",
+       "<g id=\"edge7\" class=\"edge\">\n",
        "<title>prob_bill_hits&#45;&gt;bill_hits</title>\n",
        "<path fill=\"none\" stroke=\"black\" d=\"M95.52,-146.33C120.5,-135.19 154.89,-119.86 181.13,-108.16\"/>\n",
        "<polygon fill=\"black\" stroke=\"black\" points=\"182.38,-111.43 190.09,-104.16 179.53,-105.04 182.38,-111.43\"/>\n",
@@ -763,7 +763,7 @@
        "<polygon fill=\"black\" stroke=\"black\" points=\"344.22,-45.42 349.43,-36.19 339.6,-40.16 344.22,-45.42\"/>\n",
        "</g>\n",
        "<!-- bill_hits&#45;&gt;bottle_shatters -->\n",
-       "<g id=\"edge11\" class=\"edge\">\n",
+       "<g id=\"edge10\" class=\"edge\">\n",
        "<title>bill_hits&#45;&gt;bottle_shatters</title>\n",
        "<path fill=\"none\" stroke=\"black\" d=\"M247.5,-76.32C270.68,-65.78 304.07,-50.61 330.66,-38.52\"/>\n",
        "<polygon fill=\"black\" stroke=\"black\" points=\"331.82,-41.84 339.48,-34.52 328.92,-35.47 331.82,-41.84\"/>\n",
diff --git a/docs/source/explainable_sir.ipynb b/docs/source/explainable_sir.ipynb
new file mode 100644
index 00000000..fbf3c0f8
--- /dev/null
+++ b/docs/source/explainable_sir.ipynb
@@ -0,0 +1,1774 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Causal Explanations in Models with Continuous Random Variables"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The **Explainable Reasoning with ChiRho** module aims to provide a unified, principled approach to computations of causal explanations. We showed in an earlier [tutorial](https://basisresearch.github.io/chirho/explainable_categorical.html) how ChiRho provides `SearchForExplanation`, an effect handler that transforms causal probabilistic programs to compute causal explanations and other related causal queries. In that tutorial we focused on discrete variables. In this notebook, we illustrate the usage of `SearchForExplanation` for causal models with continuous random variables in the context of a dynamical system.\n",
+    "\n",
+    "We take an epidemiological dynamical system model (described in more detail in our [dynamical systems tutorial](https://basisresearch.github.io/chirho/dynamical_intro.html)), expand it to a causal model with two interacting policies: lockdown and masking, where the former dampens the effect of the latter (the stronger the lockdown, the less the masking matters as people interact less anyway). Suppose both policies have been implemented, resulting in an undesirable overshoot (roughly, the ratio of people who infected after the peak of the epidemic). We want to be able to isolate the role of lockdown and masking in this outcome - in particular, we want to recover the intuition that since lockdown dampened the masking effect, it was lockdown that caused the overshoot, even if masking alone without lockdown would also have led to overshoot. We show how the but-for analysis is not sufficiently fine-grained to explain the effects of different policies during a pandemic. Next, we illustrate how the analysis can be run and various causal explanation queries can be computed by combining ChiRho's `SearchForExplanation` and Pyro's probabilistic inference. We also demonstrate how more detailed causal queries can be answered by post-processing the samples obtained using the effect handler. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Outline\n",
+    "\n",
+    "- [Setup](#setup)\n",
+    "- [Bayesian Epidemiological SIR Model with Policies](#bayesian-epidemiological-sir-model-with-policies)\n",
+    "    - [Assumptions](#assumptions)\n",
+    "    - [SIR Model and Simulation](#sir-model-and-simulation)\n",
+    "    - [Bayesian SIR Model](#bayesian-sir-model)\n",
+    "    - [Bayesian SIR Model with Policies](#bayesian-sir-model-with-policies)\n",
+    "- [But for Analysis with Bayesian SIR Model with Policies](#but-for-analysis-with-bayesian-sir-model-with-policies)\n",
+    "- [Causal Explanations using SearchForExplanation](#causal-explanations-using-searchforexplanation)\n",
+    "- [Fine-grained Analysis of overshoot using Sample traces](#fine-grained-analysis-of-overshoot-using-sample-traces)\n",
+    "- [Looking into Different Contexts for Curious Readers](#looking-into-different-contexts-for-curious-readers)\n",
+    "- [Conclusions](#conclusions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Setup"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "The main dependencies for this example are PyTorch, Pyro, and ChiRho.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numbers\n",
+    "import os\n",
+    "from typing import Tuple, TypeVar, Union, Optional, Callable\n",
+    "import math\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import pandas as pd\n",
+    "import pyro.distributions as dist\n",
+    "from pyro.distributions import constraints\n",
+    "import seaborn as sns\n",
+    "import torch\n",
+    "from pyro.infer import Predictive\n",
+    "\n",
+    "import pyro\n",
+    "from chirho.counterfactual.handlers.counterfactual import MultiWorldCounterfactual\n",
+    "from chirho.dynamical.handlers.interruption import StaticEvent\n",
+    "from chirho.dynamical.handlers.solver import TorchDiffEq\n",
+    "from chirho.dynamical.handlers.trajectory import LogTrajectory\n",
+    "from chirho.dynamical.ops import Dynamics, State, on, simulate\n",
+    "from chirho.explainable.handlers import SearchForExplanation\n",
+    "from chirho.explainable.handlers.components import ExtractSupports\n",
+    "from chirho.indexed.ops import IndexSet, gather\n",
+    "from chirho.interventional.ops import Intervention, intervene\n",
+    "from chirho.observational.handlers import condition\n",
+    "\n",
+    "R = Union[numbers.Real, torch.Tensor]\n",
+    "S = TypeVar(\"S\")\n",
+    "T = TypeVar(\"T\")\n",
+    "\n",
+    "\n",
+    "sns.set_style(\"white\")\n",
+    "\n",
+    "seed = 123\n",
+    "pyro.clear_param_store()\n",
+    "pyro.set_rng_seed(seed)\n",
+    "\n",
+    "smoke_test = \"CI\" in os.environ\n",
+    "num_samples = 10 if smoke_test else 10000"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Bayesian Epidemiological SIR model with Policies"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "We start with building the epidemiological SIR (Susceptible, Infected, Recovered) model, one step at a time. We first encode the deterministic SIR dynamics. Then we add uncertainty about the parameters that govern these dynamics: $\\beta$ and $\\gamma$. These parameters have been described in detail in the [dynamical systems tutorial](https://basisresearch.github.io/chirho/dynamical_intro.html). We then incorporate the resulting model into a more complex causal model that involves two policy mechanisms: imposing lockdown and masking restrictions.\n",
+    "\n",
+    "Our outcome of interest is overshoot, the proportion of the population that remains susceptible after the epidemic peaks but eventually becomes infected as the epidemic continues. One way to compute it is to:\n",
+    "\n",
+    "1. Find the time when the number of infected individuals is at its peak, which we denote `t_max`.\n",
+    "2. Determine the proportion of susceptible individuals at `t_max` in the whole population, which we denote `S_peak`.\n",
+    "3. Find the proportion of susceptible individuals (and have thus never been infected) at the end of the logging period, `S_final`.\n",
+    "4. Return the difference between proportions of peak and final susceptible individuals, `S_peak - S_final`.\n",
+    "\n",
+    "Epidemic mitigation policies often have multiple goals that must be balanced. One typical goal is to increase `S_final`, i.e., to limit the total number of infected individuals. Another goal is to limit the number of infected individuals at the peak of the epidemic to avoid overwhelming the healthcare system. Yet another goal is to minimize the proportion of the population that becomes infected after the peak, that is, the overshoot, to reduce healthcare and economic burdens. Balancing these objectives involves making trade-offs. To properly think through such trade-offs, one needs a decent counterfactual picture of what these outcomes might be under various interventions. In what follows, we focus on overshoot.\n",
+    "\n",
+    "Suppose we are working under the constraint that the overshoot should be lower than 24% of the population, and we implement two public health policies, lockdown and masking, which together seem to lead to the overshoot being too high. As an example, we will work with an example when only one of them holds most of the responsibility, and we are interested in being able to identify which one. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Assumptions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We make a range of assumptions in this tutorial:\n",
+    "\n",
+    "(1) 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, and all the stochasticity is delegated to parameter uncertainty and perhaps observational noise.\n",
+    "\n",
+    "(2) The dynamical system model is known except for the prameters, and accurately captures the process we want to model.\n",
+    "\n",
+    "(3) There are no confounders between the model parameters, i.e. these are not systematically influenced by unobserveed variables in a way that would bias our causal effect estimates.\n",
+    "\n",
+    "There are many models where we could relax or abandon these assumptions, which would lead to other modeling decisions. The general point, however, of how to use *a* model with `SearchForCauses` would, *mutatis mutandis*,  hold as soon as one has a causal model."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### SIR Model and Simulation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# dS = - beta . SI\n",
+    "# dI = beta * SI - gamma * I\n",
+    "# dR = gamma * I\n",
+    "\n",
+    "class SIRDynamics(pyro.nn.PyroModule):\n",
+    "    def __init__(self, beta, gamma):\n",
+    "        super().__init__()\n",
+    "        self.beta = beta\n",
+    "        self.gamma = gamma\n",
+    "\n",
+    "    def forward(self, X: State[torch.Tensor]):\n",
+    "        dX: State[torch.Tensor] = dict()\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",
+    "        return dX\n",
+    "\n",
+    "\n",
+    "# l is a parameter describing the strength of the intervening policies\n",
+    "# it is a value between 0 and 1, and (1-l) is the fraction of the original unintervened beta\n",
+    "class SIRDynamicsPolicies(SIRDynamics):\n",
+    "    def __init__(self, beta0, gamma):\n",
+    "        super().__init__(beta0, gamma)\n",
+    "        self.beta0 = beta0\n",
+    "\n",
+    "    def forward(self, X: State[torch.Tensor]):\n",
+    "        self.beta = (1 - X[\"l\"]) * self.beta0\n",
+    "        dX = super().forward(X)\n",
+    "        dX[\"l\"] = torch.zeros_like(X[\"l\"])\n",
+    "        return dX"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "0.15116800367832184\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Computing overshoot in a simple SIR model without interventions\n",
+    "# note it's below the desired threshold\n",
+    "\n",
+    "total_population = 100\n",
+    "init_state = dict(S=torch.tensor(99.0), I=torch.tensor(1.0), R=torch.tensor(0.0))\n",
+    "assert init_state[\"S\"] + init_state[\"I\"] + init_state[\"R\"] == total_population\n",
+    "\n",
+    "start_time = torch.tensor(0.0)\n",
+    "end_time = torch.tensor(12.0)\n",
+    "step_size = torch.tensor(0.1)\n",
+    "logging_times = torch.arange(start_time, end_time, step_size)\n",
+    "init_state_lockdown = dict(**init_state, l=torch.tensor(0.0))\n",
+    "\n",
+    "# We now simulate from the SIR model\n",
+    "beta_true = torch.tensor([0.03])\n",
+    "gamma_true = torch.tensor([0.5])\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\n",
+    "\n",
+    "\n",
+    "def get_overshoot(trajectory):\n",
+    "    t_max = torch.argmax(trajectory[\"I\"].squeeze())\n",
+    "    S_peak = torch.max(trajectory[\"S\"].squeeze()[t_max]) / total_population\n",
+    "    S_final = trajectory[\"S\"].squeeze()[-1] / total_population\n",
+    "    return (S_peak - S_final).item()\n",
+    "\n",
+    "\n",
+    "print(get_overshoot(sir_true_traj))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The number $0.15$ is the overshoot you get if $\\beta = 0.03, \\gamma = 0.5$, which, say, are the true parameters of the epidemic. This value is observed by simulating the SIR dynamics model with these values and calculating the overshoot directly.\n",
+    "\n",
+    "Also, note that the above dynamical system introduces the variables: `S` - susceptible, `I` - infected, `R` - recovered, and `l` - effect of the intervention. These variables evolve over time and their dynamics are captured by the model. As we add features to our model, we also add new variables to this list. Further on in the notebook, we will describe the probabilities we compute in terms of these variables."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Bayesian SIR model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "Now suppose we are uncertain about $\\beta$ and $\\gamma$, and want to construct a Bayesian SIR model that incorporates this uncertainty. Say we induce $\\beta$ to be drawn from the distribution `Beta(18, 600)`, and $\\gamma$ to be drawn from distribution `Beta(1600, 1600)`. This converts the parameters of the original dynamical system into random variables `beta` and `gamma` in our model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Defining a Bayesian SIR model where we have priors over beta and gamma distributions\n",
+    "\n",
+    "def bayesian_sir(base_model=SIRDynamics) -> Dynamics[torch.Tensor]:\n",
+    "    beta = pyro.sample(\"beta\", dist.Beta(18, 600))\n",
+    "    gamma = pyro.sample(\"gamma\", dist.Beta(1600, 1600))\n",
+    "    sir = base_model(beta, gamma)\n",
+    "    return sir\n",
+    "\n",
+    "\n",
+    "def simulated_bayesian_sir(\n",
+    "    init_state, start_time, logging_times, base_model=SIRDynamics\n",
+    ") -> State[torch.Tensor]:\n",
+    "    sir = bayesian_sir(base_model)\n",
+    "\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": [
+    "### Bayesian SIR model with Policies\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Now we incorporate the Bayesian SIR model into a larger model that includes the effect of two different policies, lockdown and masking, where each can be implemented with $50\\%$ probability. These probabilities won't really matter, as we will be intervening on these, the sampling is mainly used to register the parameters with Pyro. It does, hower, illustrate that the model in principle could incorporate uncertainties of this sort. We encode the intervention efficiencies which further affect the model. Crucially, these efficiencies interact in a fashion resembling the structure of the stone-throwing example we discussed in the tutorial on categorical variables. If a lockdown is present, this limits the impact of masking as agents interact less and so masks have fewer opportunities to block anything. We assume the situation is asymmetric: masking has no impact on the efficiency of lockdown. The model also computes `overshoot` and `os_too_high` for further analysis.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# a utility function\n",
+    "# allowing for interventions on a dynamical system\n",
+    "# within another model\n",
+    "# to avoid conflicts arising from repeated sites in the trace\n",
+    "\n",
+    "def MaskedStaticIntervention(time: R, intervention: Intervention[State[T]]):\n",
+    "\n",
+    "    @on(StaticEvent(time))\n",
+    "    def callback(\n",
+    "        dynamics: Dynamics[T], state: State[T]\n",
+    "    ) -> Tuple[Dynamics[T], State[T]]:\n",
+    "\n",
+    "        with pyro.poutine.block():\n",
+    "            return dynamics, intervene(state, intervention)\n",
+    "\n",
+    "    return callback"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Defining the policy model\n",
+    "\n",
+    "overshoot_threshold = 24\n",
+    "lockdown_time = torch.tensor(1.0)\n",
+    "mask_time = torch.tensor(1.5)\n",
+    "\n",
+    "def policy_model() -> State[torch.Tensor]:\n",
+    "\n",
+    "    lockdown = pyro.sample(\"lockdown\", dist.Bernoulli(torch.tensor(0.5)))\n",
+    "    mask = pyro.sample(\"mask\", dist.Bernoulli(torch.tensor(0.5)))\n",
+    "\n",
+    "    lockdown_efficiency = pyro.deterministic(\n",
+    "        \"lockdown_efficiency\", torch.tensor(0.6) * lockdown, event_dim=0\n",
+    "    )\n",
+    "\n",
+    "    mask_efficiency = pyro.deterministic(\n",
+    "        \"mask_efficiency\", (0.1 * lockdown + 0.45 * (1 - lockdown)) * mask, event_dim=0\n",
+    "    )\n",
+    "\n",
+    "    joint_efficiency = pyro.deterministic(\n",
+    "        \"joint_efficiency\",\n",
+    "        torch.clamp(lockdown_efficiency + mask_efficiency, 0, 0.95),\n",
+    "        event_dim=0,\n",
+    "    )\n",
+    "\n",
+    "    lockdown_sir = bayesian_sir(SIRDynamicsPolicies)\n",
+    "    with LogTrajectory(logging_times, is_traced=True) as lt:\n",
+    "        with TorchDiffEq():\n",
+    "            with MaskedStaticIntervention(lockdown_time, dict(l=lockdown_efficiency)):\n",
+    "                with MaskedStaticIntervention(mask_time, dict(l=joint_efficiency)):\n",
+    "                    simulate(\n",
+    "                        lockdown_sir, init_state_lockdown, start_time, logging_times[-1]\n",
+    "                    )\n",
+    "\n",
+    "    return lt.trajectory\n",
+    "\n",
+    "def overshoot_query(trajectory: State[torch.Tensor]) -> Tuple[torch.Tensor, torch.Tensor]:\n",
+    "\n",
+    "    t_max = torch.max(trajectory[\"I\"], dim=-1).indices\n",
+    "    S_peaks = pyro.ops.indexing.Vindex(trajectory[\"S\"])[..., t_max]\n",
+    "    overshoot = pyro.deterministic(\n",
+    "        \"overshoot\", S_peaks - trajectory[\"S\"][..., -1], event_dim=0\n",
+    "    )\n",
+    "    os_too_high = pyro.deterministic(\n",
+    "        \"os_too_high\",\n",
+    "        (overshoot > overshoot_threshold).clone().detach().float(),\n",
+    "        event_dim=0,\n",
+    "    )\n",
+    "\n",
+    "    return overshoot, os_too_high\n",
+    "\n",
+    "def overshoot_model():\n",
+    "    trajectory = policy_model()\n",
+    "    return overshoot_query(trajectory)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Now that we have our full-fledged model of SIR dynamics along with interventions, we have a complete list of random variables in question. In our explanations, we will abbreviate them as follows. `S` - susceptible, `I` - infected, `R` - recovered, `l` - the effect of intervention, `beta`, `gamma` - the parameters of the SIR dynamics model, `ld` - lockdown, `m` - masking, `le` - lockdown efficiency, `me` - mask efficiency, `je` - joint efficiency, `os` - overshoot, and `oth` - overshoot is too high. We use these notations in the rest of the notebook to describe the probabilities we are computing."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## But for Analysis with Bayesian SIR model with Policies"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "Suppose now we introduced both policies, and this resulted in an overshoot. What intuitively is the case is that lockdown limited the efficiency of masking, and it was in fact the lockdown that in this particular context caused the overshoot (this is consistent with saying that in the context where only masking has been implemented, masking would be responsible for the resulting overshoot being too high).\n",
+    "\n",
+    "We might try to use the but-for analysis to identify which of the policies causes overshoot to be too high. Recall from our previous tutorial, that the key idea behind it is to evaluate whether \"$B$ wouldn't have been the case but for $A$ happening\". This query invites one to ask what would happen if a candidate cause was removed, and declares it responsible just in case the outcome is different in that scenario. To apply it in this case, we investigate the following four scenarios:\n",
+    "\n",
+    "1. None of the policies were applied\n",
+    "2. Both lockdown and masking were enforced\n",
+    "3. Only masking was imposed\n",
+    "4. Only lockdown was imposed\n",
+    "\n",
+    "The hope is that by looking at these we will be able to identify the culprit. We create these four models by conditioning on the policies being imposed as required (in fact, this has the same effect as intervening here, as the sites are upstream from the dynamical system model; we could emulate 1-4 using ChiRho's `do` with the same estimates). For the sake of completeness, we also illustrate the consequences of following a stochastic policy and deciding randomly about the interventions."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Variables in the model: dict_keys(['lockdown', 'mask', 'beta', 'gamma', 'lockdown_efficiency', 'mask_efficiency', 'joint_efficiency', 'S', 'I', 'R', 'l', 'overshoot', 'os_too_high'])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# conditioning (as opposed to intervening) is sufficient for\n",
+    "# propagating the changes, as the decisions are upstream from ds\n",
+    "\n",
+    "# no interventions\n",
+    "overshoot_model_none = condition(\n",
+    "    overshoot_model, {\"lockdown\": torch.tensor(0.0), \"mask\": torch.tensor(0.0)}\n",
+    ")\n",
+    "unintervened_predictive = Predictive(\n",
+    "    overshoot_model_none, num_samples=num_samples, parallel=True\n",
+    ")\n",
+    "unintervened_samples = unintervened_predictive()\n",
+    "\n",
+    "# both interventions\n",
+    "overshoot_model_all = condition(\n",
+    "    overshoot_model, {\"lockdown\": torch.tensor(1.0), \"mask\": torch.tensor(1.0)}\n",
+    ")\n",
+    "intervened_predictive = Predictive(\n",
+    "    overshoot_model_all, num_samples=num_samples, parallel=True\n",
+    ")\n",
+    "intervened_samples = intervened_predictive()\n",
+    "\n",
+    "overshoot_model_mask = condition(\n",
+    "    overshoot_model, {\"lockdown\": torch.tensor(0.0), \"mask\": torch.tensor(1.0)}\n",
+    ")\n",
+    "mask_predictive = Predictive(overshoot_model_mask, num_samples=num_samples, parallel=True)\n",
+    "mask_samples = mask_predictive()\n",
+    "\n",
+    "overshoot_model_lockdown = condition(\n",
+    "    overshoot_model, {\"lockdown\": torch.tensor(1.0), \"mask\": torch.tensor(0.0)}\n",
+    ")\n",
+    "lockdown_predictive = Predictive(\n",
+    "    overshoot_model_lockdown, num_samples=num_samples, parallel=True\n",
+    ")\n",
+    "lockdown_samples = lockdown_predictive()\n",
+    "\n",
+    "predictive = Predictive(overshoot_model, num_samples=num_samples, parallel=True)\n",
+    "samples = predictive()\n",
+    "\n",
+    "print(\"Variables in the model:\", samples.keys())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that the above list of variables matches our list of variables earlier when we constructed the full-fledged SIR model."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x750 with 10 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def add_pred_to_plot(preds, axs, coords, color, label):\n",
+    "    sns.lineplot(\n",
+    "        x=logging_times,\n",
+    "        y=preds.mean(dim=0).squeeze().tolist(),\n",
+    "        ax=axs[coords],\n",
+    "        label=label,\n",
+    "        color=color,\n",
+    "    )\n",
+    "    axs[coords].fill_between(\n",
+    "        logging_times,\n",
+    "        torch.quantile(preds, 0.025, dim=0).squeeze(),\n",
+    "        torch.quantile(preds, 0.975, dim=0).squeeze(),\n",
+    "        alpha=0.2,\n",
+    "        color=color,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "fig, axs = plt.subplots(5, 2, figsize=(12, 7.5))\n",
+    "\n",
+    "colors = [\"orange\", \"red\", \"green\"]\n",
+    "\n",
+    "add_pred_to_plot(\n",
+    "    unintervened_samples[\"S\"], axs, coords=(0, 0), color=colors[0], label=\"susceptible\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    unintervened_samples[\"I\"], axs, coords=(0, 0), color=colors[1], label=\"infected\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    unintervened_samples[\"R\"], axs, coords=(0, 0), color=colors[2], label=\"recovered\"\n",
+    ")\n",
+    "\n",
+    "axs[0, 0].set_title(\"No interventions\")\n",
+    "for ax in axs[:, 0]:\n",
+    "    ax.set_xlabel(\"time\")\n",
+    "    ax.set_ylabel(\"count\")\n",
+    "\n",
+    "\n",
+    "for ax in axs[:, 1]:\n",
+    "    ax.set_xlim(0, 35)\n",
+    "    ax.set_xlabel(\"overshoot\")\n",
+    "    ax.set_ylabel(\"num samples\")\n",
+    "\n",
+    "axs[0, 1].hist(unintervened_samples[\"overshoot\"].squeeze())\n",
+    "\n",
+    "\n",
+    "axs[0, 1].set_title(\n",
+    "    f\"Overshoot mean (no interventions): {unintervened_samples['overshoot'].squeeze().mean().item():.2f}, Pr(too high): {unintervened_samples['os_too_high'].squeeze().float().mean().item():.2f} \"\n",
+    ")\n",
+    "axs[0, 1].axvline(unintervened_samples['overshoot'].squeeze().mean().item(), color=\"red\", \n",
+    "                  linestyle=\"--\", label=\"mean overshoot\")\n",
+    "axs[0, 1].axvline(overshoot_threshold, color=\"black\", linestyle=\"--\", label=\"overshoot threshold\")\n",
+    "axs[0, 1].legend()\n",
+    "\n",
+    "add_pred_to_plot(\n",
+    "    intervened_samples[\"S\"], axs, coords=(1, 0), color=colors[0], label=\"susceptible\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    intervened_samples[\"I\"], axs, coords=(1, 0), color=colors[1], label=\"infected\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    intervened_samples[\"R\"], axs, coords=(1, 0), color=colors[2], label=\"recovered\"\n",
+    ")\n",
+    "axs[1, 0].set_title(\"Both interventions\")\n",
+    "axs[1, 0].legend_.remove()\n",
+    "\n",
+    "\n",
+    "axs[1, 1].hist(intervened_samples[\"overshoot\"].squeeze())\n",
+    "axs[1, 1].set_title(\n",
+    "    f\"Overshoot mean (both interventions): {intervened_samples['overshoot'].squeeze().mean().item():.2f}, Pr(too high): {intervened_samples['os_too_high'].squeeze().float().mean().item():.2f} \"\n",
+    ")\n",
+    "axs[1,1].axvline(intervened_samples['overshoot'].squeeze().mean().item(), color=\"red\",\n",
+    "                linestyle=\"--\", label=\"mean overshoot\")\n",
+    "axs[1, 1].axvline(overshoot_threshold, color=\"black\", linestyle=\"--\", label=\"overshoot threshold\")\n",
+    "\n",
+    "\n",
+    "add_pred_to_plot(\n",
+    "    mask_samples[\"S\"], axs, coords=(2, 0), color=colors[0], label=\"susceptible\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    mask_samples[\"I\"], axs, coords=(2, 0), color=colors[1], label=\"infected\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    mask_samples[\"R\"], axs, coords=(2, 0), color=colors[2], label=\"recovered\"\n",
+    ")\n",
+    "axs[2, 0].set_title(\"Mask only\")\n",
+    "axs[2, 0].legend_.remove()\n",
+    "\n",
+    "axs[2, 1].hist(mask_samples[\"overshoot\"].squeeze())\n",
+    "axs[2, 1].set_title(\n",
+    "    f\"Overshoot mean (mask only): {mask_samples['overshoot'].squeeze().mean().item():.2f}, Pr(too high): {mask_samples['os_too_high'].squeeze().float().mean().item():.2f} \"\n",
+    ")\n",
+    "axs[2, 1].axvline(mask_samples['overshoot'].squeeze().mean().item(), color=\"red\",\n",
+    "                linestyle=\"--\", label=\"mean overshoot\")\n",
+    "axs[2, 1].axvline(overshoot_threshold, color=\"black\", linestyle=\"--\", label=\"overshoot threshold\")\n",
+    "\n",
+    "add_pred_to_plot(\n",
+    "    lockdown_samples[\"S\"], axs, coords=(3, 0), color=colors[0], label=\"susceptible\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    lockdown_samples[\"I\"], axs, coords=(3, 0), color=colors[1], label=\"infected\"\n",
+    ")\n",
+    "add_pred_to_plot(\n",
+    "    lockdown_samples[\"R\"], axs, coords=(3, 0), color=colors[2], label=\"recovered\"\n",
+    ")\n",
+    "axs[3, 0].set_title(\"Lockdown only\")\n",
+    "axs[3, 0].legend_.remove()\n",
+    "\n",
+    "axs[3, 1].hist(lockdown_samples[\"overshoot\"].squeeze())\n",
+    "axs[3, 1].set_title(\n",
+    "    f\"Overshoot mean (lockdown only): {lockdown_samples['overshoot'].squeeze().mean().item():.2f}, Pr(too high): {lockdown_samples['os_too_high'].squeeze().float().mean().item():.2f} \"\n",
+    ")\n",
+    "axs[3, 1].axvline(lockdown_samples['overshoot'].squeeze().mean().item(), color=\"red\",\n",
+    "                linestyle=\"--\", label=\"mean overshoot\")\n",
+    "axs[3, 1].axvline(overshoot_threshold, color=\"black\", linestyle=\"--\", label=\"overshoot threshold\")\n",
+    "\n",
+    "add_pred_to_plot(samples[\"S\"], axs, coords=(4, 0), color=colors[0], label=\"susceptible\")\n",
+    "add_pred_to_plot(samples[\"I\"], axs, coords=(4, 0), color=colors[1], label=\"infected\")\n",
+    "add_pred_to_plot(samples[\"R\"], axs, coords=(4, 0), color=colors[2], label=\"recovered\")\n",
+    "axs[4, 0].set_title(\"Stochastic interventions with equal probabilities\")\n",
+    "axs[4, 0].legend_.remove()\n",
+    "\n",
+    "axs[4, 1].hist(samples[\"overshoot\"].squeeze())\n",
+    "axs[4, 1].set_title(\n",
+    "    f\"Overshoot mean (stochastic interventions): {samples['overshoot'].squeeze().mean().item():.2f}, Pr(too high): {samples['os_too_high'].squeeze().float().mean().item():.2f} \"\n",
+    ")\n",
+    "axs[4, 1].axvline(samples['overshoot'].squeeze().mean().item(), color=\"red\",\n",
+    "                linestyle=\"--\", label=\"mean overshoot\")\n",
+    "axs[4, 1].axvline(overshoot_threshold, color=\"black\", linestyle=\"--\", label=\"overshoot threshold\")\n",
+    "\n",
+    "\n",
+    "fig.tight_layout()\n",
+    "fig.suptitle(\n",
+    "    \"Trajectories and overshoot distributions in the but-for analysis\",\n",
+    "    fontsize=16,\n",
+    "    y=1.05,\n",
+    ")\n",
+    "sns.despine()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The plots above show what happens in different scenarios. We observe that in the model where none of the policies were imposed, the probability of the overshoot being too high is relatively low, $\\approx 0.05$. On the other hand, when both policies were imposed, the probability of the overshoot being too high was relatively high at $\\approx 0.7$. \n",
+    "\n",
+    "To identify which of `lockdown` and `mask` is the cause, we analyze the models where only one of the policies was imposed. Interestingly, the effect of the interventions is somewhat nuanced. Implementing both interventions increases the risk of overshooting as compared to the no-intervention model, but individual interventions would have even worse consequences, which means that the two interventions while jointly increasing the risk to some extent mitigate each other's contribution to that risk as well.\n",
+    "\n",
+    "Crucially, the analysis does not allow us to distinguish the intuitive role that the lockdown played, as opposed to masking (whose impact has been limited by the presence of lockdown). So, we need a more fine-grained analysis where we not only control the variables being intervened on (that is, the policies) but also pay attention to what context we are in. We achieve that level of sensitivity by stochastically keeping part of the context (that is, other variables in the model) fixed (see the tutorial for categorical variables for a more extensive explanation of this method and simpler examples). The key idea is that starting with the actual scenario in which both interventions have been implemented, there is a context such that if we keep it fixed, removing the lockdown would significantly lower the overshoot, but there is no context that we could keep fixed such that if in that context we remove the masking policy, the overshoot would decrease. In the next section, we show how this analysis can be carried out with the help of `SearchForExplanation`."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Causal Explanations using SearchForExplanation\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Before we dive into the code below, let us first define some notation. We use small case abbreviations to refer to the value of the variables under consideration. For example, $\\mathit{ld}$ refers to `lockdown=1` and $\\mathit{ld\\,}'$ refers to `lockdown=0`. We place interventions in the subscripts, for instance, $\\mathit{os}_{\\mathit{ld}}$ refers to the `overshoot` under the intervention that `lockdown=1`. Later on in the notebook, we also employ contexts that are kept fixed in the intervened worlds. We place these contexts in the superscript. For example, $\\mathit{os}_{\\mathit{ld}}^{\\mathit{me}}$ refers to the variable `overshoot` when `lockdown` was intervened to be 1 and `mask_efficiency` was kept fixed at its factual value. \n",
+    "\n",
+    "We use $P(.)$ to denote the distribution described by the model (`overshoot_model` in this notebook). We also induce a distribution over the sets of potential interventions and the sets of context nodes potentially kept fixed. We denote these distributions by $P_a(.)$ and $P_w(.)$ respectively. As an example, $P_a(\\{ld\\})$ refers to the probability that the set of interventions under consideration is $\\{ld\\}$. These distributions are determined using the parameters `antecedent_bias` and `witness_bias` given to the handler `SearchForExplanation`. For more details, please refer to the [documentation](https://basisresearch.github.io/chirho/explainable.html#chirho.explainable.handlers.explanation.SearchForExplanation).\n",
+    "\n",
+    "At a high level, we will transform the original model into one that runs through three \"possible worlds\" at the same time. (1) the \"actual world\", where the model is played in its original unintervened form, (2) the \"necessity world\", where the intention is to investigate the extent to which changing antecedent values to alternative values would change the outcome, and particular interventional settings are rewarded for the outcome being different from the actual value, and (3) the \"sufficiency world\", where we investigate the result of fixing the causal candidates at their actual values, and investigating the extent to which they ensure the outcome being as is (accounting for stochasticity involving other sites), rewarding settings for proximity to the actual value. All this happens across multiple runs which contain different interventional settings to perform search through causal nodes and witnesses, and ultimately we will care about causal candidates that are both necessary and sufficient, that is in a qantity of interest that would be obtained by accounting for information obtained across those possible worlds. If this seems confusing, please take a look at more detailed explanations in the tutorial on explanation with categorical variables.\n",
+    "\n",
+    "Now let's dive into the code, using this notation to describe the quantities we are computing. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "\n",
+    "\n",
+    "We first introduce a function for performing importance sampling through the model that returns cumulative log probabilities of the samples, sample traces, an effect handler object for multi-world counterfactual reasoning, and log probabilities. We use these objects later in the code to subselect the samples."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def importance_infer(model: Optional[Callable] = None, *, num_samples: int):\n",
+    "\n",
+    "    if model is None:\n",
+    "        return lambda m: importance_infer(m, num_samples=num_samples)\n",
+    "\n",
+    "    def _wrapped_model(*args, **kwargs):\n",
+    "\n",
+    "        guide = pyro.poutine.block(hide_fn=lambda msg: msg[\"is_observed\"])(model)\n",
+    "\n",
+    "        max_plate_nesting = 9  # TODO guess\n",
+    "\n",
+    "        with pyro.poutine.block(), MultiWorldCounterfactual() as mwc_imp:\n",
+    "            log_weights, importance_tr, _ = (\n",
+    "                pyro.infer.importance.vectorized_importance_weights(\n",
+    "                    model,\n",
+    "                    guide,\n",
+    "                    *args,\n",
+    "                    num_samples=num_samples,\n",
+    "                    max_plate_nesting=max_plate_nesting,\n",
+    "                    normalized=False,\n",
+    "                    **kwargs\n",
+    "                )\n",
+    "            )\n",
+    "\n",
+    "        return (\n",
+    "            torch.logsumexp(log_weights, dim=0) - math.log(num_samples),\n",
+    "            importance_tr,\n",
+    "            mwc_imp,\n",
+    "            log_weights,\n",
+    "        )\n",
+    "\n",
+    "    return _wrapped_model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The key idea here is that once we transform the original model using `SearchForExplanation` the trace will not only contain the original sites, but also sites representing witness preemptions, sites representing which antecedents were intervened on, and sites representing differences between the values of the outcome variable across counterfactual worlds. At a high level, we'd be using a trace with the following structure:\n",
+    "\n",
+    "| A | Witness A | Antecedent A | B | Witness B | Antecedent B | ... | Outcome | Outcome Diff |\n",
+    "|---|-----------|--------------|---|-----------|--------------|-----|---------|--------------|\n",
+    "|   |           |              |   |           |              |     |         | ...          |\n",
+    "\n",
+    "where each of these is tracked in three worlds: actual, one with the necessity interventions/preemptions, and one with the sufficiency preemptions. This collection of values will come with a corresponding \"table\" of log probabilities, which will be the usual log probs wherever values are sampled from a distribution, and soft equality or soft non-equality penalty terms expressed in the log prob space. This way, we can exploit the already existing sampling method to obtain samples and one-number log-prob summaries that capture answers to counterfactual queries. Potentially, there are other ways to run inference with the transformed models, we will look at conditioning by rejection sampling, but will not discuss other inference methods in this tutorial.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Then, we set up the query as follows:\n",
+    "1. `supports`: We extract the support of each distribution in the model using `ExtractSupports`. We also encode our knowledge that `os_too_high` is a Boolean. Note that constraints for deterministic nodes currently need to be specified manually when using `ExtractSupports`, as we do here.\n",
+    "2. `antecedents`: We postulate `lockdown=1` and `mask=1` as possible causes.\n",
+    "3. `alternatives`: We provide `lockdown=0` and `mask=0` as alternative values. If we don't specify them, the search simply samples the values using uniform/wide distributions for those sites  - which makes sense if the site has continuous support or if we only know the outcome but not the antecedent values. For this simpler application, however, searching through `lockdown=1` or `mask=1` as alternatives would not conceptually do, as we already know what the alternative values should be.\n",
+    "4. witnesses`: We include `mask_efficiency` and `lockdown_efficiency` as candidates to be included in the contexts potentially to be kept fixed.\n",
+    "5. `consequents`: We put `os_too_high=1` as the outcome whose causes we wish to analyze.\n",
+    "6. `antecedent_bias`, `witness_bias`: We set these parameters to have equal probabilities of intervening on cause candidates, and to slightly prefer smaller witness sets. Please refer to the documentation of `SearchForExplanation` for more details.\n",
+    "7. `consequent_scale` is set to effectively lead to probabilities near 0 and 1 depending on whether the binary outcomes differ across counterfactual worlds."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "tensor(0.1328)\n"
+     ]
+    }
+   ],
+   "source": [
+    "with ExtractSupports() as s:\n",
+    "    overshoot_model()\n",
+    "\n",
+    "supports = s.supports\n",
+    "supports[\"os_too_high\"] = constraints.independent(\n",
+    "    base_constraint=constraints.boolean, reinterpreted_batch_ndims=0\n",
+    ")\n",
+    "\n",
+    "query = SearchForExplanation(\n",
+    "    supports=supports,\n",
+    "    alternatives={\"lockdown\": torch.tensor(0.0), \"mask\": torch.tensor(0.0)},\n",
+    "    antecedents={\"lockdown\": torch.tensor(1.0), \"mask\": torch.tensor(1.0)},\n",
+    "    antecedent_bias=0.0,\n",
+    "    witnesses={\n",
+    "        key: s.supports[key] for key in [\"lockdown_efficiency\", \"mask_efficiency\"]\n",
+    "    },\n",
+    "    consequents={\"os_too_high\": torch.tensor(1.0)},\n",
+    "    consequent_scale=1e-8,\n",
+    "    witness_bias=0.2,\n",
+    ")(overshoot_model)\n",
+    "\n",
+    "logp, importance_tr, mwc_imp, log_weights = importance_infer(num_samples=num_samples)(query)()\n",
+    "print(torch.exp(logp))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The handler performs two stochastic searches at the same time (which antecedents to intervene on? which witnesses to keep at the actual values?) while inspecting the distribution of the outcome under these scenarios. For this reason, the most direct probabilistic summaries are impacted by both uncertainties present in the original model *and* the probabilistic search distributions. Since the way the latter are set up, the users might be interested in them (for instance, they might prefer smaller causal sets, or they may prefer higher context sensitivity, both of which can be tuned and are mirrored in the resulting log probabilities). But also, this means there is some nuance as to how to interpret and how to decompose them. Let's talk this through.\n",
+    "\n",
+    "The above probability itself, which potentially is of interest in some applications when one-number summaries are a good enough approximation, is only related to our current query. It is the probability that the overshoot is both too high in the antecedents-intervened world and not too high in the alternatives-intervened world, where antecedent interventions are preempted with probabilities $0.5$ at each site, and witnesses are kept fixed at the observed values with probability $0.5+0.2$ at each site (see the tutorial on categorical variables for an explanation of why this stochasticity is in general useful). Given how search and model stochasticities are composed here, we expect these values to not be very high - but that being so, does not mean low causal role.\n",
+    "\n",
+    "Now, more fine-grained queries can be answered using the 10000 samples we have drawn in the process. We first compute the probabilities that different sets of antecedent candidates have a causal effect over `os_too_high` conditioned on the fact that lockdown and masking were actually imposed in the factual world."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compute_prob(trace, log_weights, mask, verbose=True):\n",
+    "    mask_intervened = torch.ones(\n",
+    "        trace.nodes[\"__cause____antecedent_lockdown\"][\"value\"].shape\n",
+    "    ).bool()\n",
+    "    for i, v in mask.items():\n",
+    "        mask_intervened &= trace.nodes[i][\"value\"] == v\n",
+    "\n",
+    "    prob = (torch.sum(torch.exp(log_weights) * mask_intervened.squeeze()) / mask_intervened.float().sum()).item()\n",
+    "\n",
+    "    if verbose:\n",
+    "        print(mask, prob)\n",
+    "    \n",
+    "    return prob"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We specifically compute the following four probabilities. In each of the computations, we condition on lockdown and masking actually being implemented in the factual world. Given this factual world, each equation represents the probability that a given collection of policy interventions would have changed whether the overshoot was too high. For instance, in equation 1., we assume lockdown (`ld`) and masking (`m`) have been implemented, and we ask about the joint probability that both (a) removing both interventions, i.e. intervening for both  `ld`  and `m` to not happen - which we mark by the apostrophe - would lead to `oth` not happening, $\\mathit{oth}'_{\\mathit{ld'}, m'}$, and (b) intervening for both to happen would lead to `oth`, $\\mathit{oth}_{\\mathit{ld}, m}$. Given the stochasticity between these interventions and the outcome, computing these probabilities is non-trivial. Note that in computing these probabilities, we also marginalize over all the contexts that potentially can be kept fixed, i.e. all possible subsets of $W = \\{\\mathit{le}, \\mathit{me}\\}$\n",
+    "\n",
+    "1. $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{oth}^w_{\\mathit{ld}, m}, \\mathit{oth}'^w_{\\mathit{ld}', m'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "2. $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{oth}^w_{\\mathit{ld}}, \\mathit{oth}'^w_{\\mathit{ld}'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "3. $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{oth}^w_{m}, \\mathit{oth}'^w_{m'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "4. $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{oth}^w, \\mathit{oth}'^w | \\mathit{ld}, m)$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'__cause____antecedent_lockdown': 0, '__cause____antecedent_mask': 0, 'mask': 1, 'lockdown': 1} 0.24283304810523987\n",
+      "{'__cause____antecedent_lockdown': 0, '__cause____antecedent_mask': 1, 'mask': 1, 'lockdown': 1} 0.2902735471725464\n",
+      "{'__cause____antecedent_lockdown': 1, '__cause____antecedent_mask': 0, 'mask': 1, 'lockdown': 1} 2.38618436121385e-09\n",
+      "{'__cause____antecedent_lockdown': 1, '__cause____antecedent_mask': 1, 'mask': 1, 'lockdown': 1} 2.636655116461384e-09\n",
+      "both interventions executed 0.24283304810523987 \n",
+      " only lockdown executed 0.2902735471725464 \n",
+      " only masking executed 2.38618436121385e-09 \n",
+      " no interventions executed 2.636655116461384e-09 \n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "# no preemptions on lockdown and masking, i.e. both interventions executed\n",
+    "both = compute_prob(\n",
+    "    importance_tr,\n",
+    "    log_weights,\n",
+    "    {\"__cause____antecedent_lockdown\": 0, \"__cause____antecedent_mask\": 0, \"mask\": 1, \"lockdown\": 1},\n",
+    ")\n",
+    "\n",
+    "\n",
+    "# # only lockdown executed, masking preempted\n",
+    "lockdown = compute_prob(\n",
+    "    importance_tr,\n",
+    "    log_weights,\n",
+    "    {\"__cause____antecedent_lockdown\": 0, \"__cause____antecedent_mask\": 1, \"mask\": 1, \"lockdown\": 1},\n",
+    ")\n",
+    "\n",
+    "# # only masking executed, lockdown preempted\n",
+    "masking = compute_prob(\n",
+    "    importance_tr,\n",
+    "    log_weights,\n",
+    "    {\"__cause____antecedent_lockdown\": 1, \"__cause____antecedent_mask\": 0, \"mask\": 1, \"lockdown\": 1},\n",
+    ")\n",
+    "\n",
+    "# # no interventions executed\n",
+    "no_interventions = compute_prob(\n",
+    "    importance_tr,\n",
+    "    log_weights,\n",
+    "    {\"__cause____antecedent_lockdown\": 1, \"__cause____antecedent_mask\": 1, \"mask\": 1, \"lockdown\": 1},\n",
+    ")\n",
+    "\n",
+    "print(\n",
+    "    \"both interventions executed\", \n",
+    "    both, \"\\n\",\n",
+    "\n",
+    "    \"only lockdown executed\", \n",
+    "    lockdown, \"\\n\",\n",
+    "\n",
+    "    \"only masking executed\",\n",
+    "    masking, \"\\n\",\n",
+    "\n",
+    "    \"no interventions executed\",\n",
+    "    no_interventions, \"\\n\",\n",
+    "\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As the above probabilities show, `{lockdown=1}` has the most causal role in the overshoot being too high among all the possible sets of causes when both lockdown and masking were imposed. Note, however, that the search probabilities still come into the computation of those values, so they should not be interpreted as, say, \"the probability that the overshoot will be too high in the most damaging possible context\". "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Note that one could also compute the above queries by giving specific parameters to `SearchForExplanation` instead of subselecting the samples, as we did in the tutorial for the explainable module for models with categorical variables. Here, however, we illustrate that running a sufficiently general query once produces samples that can be used to answer multiple different questions.\n",
+    "\n",
+    "Also, we use the log probabilities above to identify whether a particular combination of intervening nodes and context nodes have causal power or not, which is made possible by the fact that our handler adds appropriate log probabilities to the trace (see the previous tutorial and documentation for more explanation). One can also obtain these results by explicitly analyzing the sample trace as we do in the next section."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also compute a relatively natural interpretation of what the degree of responsibilities assigned to both lockdown and mask is as follows. We compute the probability that these factors were a part of the cause of the outcome. Mathematically, we compute the following, where $W = \\{\\mathit{le}, \\mathit{me}\\}$ and $C = \\{\\mathit{ld}, m\\}$:\n",
+    "\n",
+    "1. Degree of responsibility of lockdown: $\\sum_{w \\subseteq W} \\sum_{\\mathit{ld} \\in C} P_w(w) P_a(C | \\mathit{ld} \\in C) \\cdot P(\\mathit{oth}^w_{C}, \\mathit{oth}'^w_{C'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "2. Degree of responsibility of mask: $\\sum_{w \\subseteq W} \\sum_{\\mathit{m} \\in C} P_w(w) P_a(C | \\mathit{m} \\in C) \\cdot P(\\mathit{oth}^w_{C}, \\mathit{oth}'^w_{C'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "\n",
+    "For earlier accounts of the degree of responsibility in the original actual causality framework, see Chapter 6. of *Actual Causality* by Joseph Y. Halpern. While the above is on an implementation of the original notion, it is definitely inspired by the discussion there. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Degree of responsibility for lockdown: \n",
+      "{'__cause____antecedent_lockdown': 0, 'mask': 1, 'lockdown': 1} 0.2677857577800751\n",
+      "\n",
+      "Degree of responsibility for mask: \n",
+      "{'__cause____antecedent_mask': 0, 'mask': 1, 'lockdown': 1} 0.1170731708407402\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Degree of responsibility for lockdown: \")\n",
+    "_ = compute_prob(importance_tr, log_weights, {\"__cause____antecedent_lockdown\": 0, \"mask\": 1, \"lockdown\": 1})\n",
+    "print()\n",
+    "\n",
+    "print(\"Degree of responsibility for mask: \")\n",
+    "_ = compute_prob(importance_tr, log_weights, {\"__cause____antecedent_mask\": 0, \"mask\": 1, \"lockdown\": 1})"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "As the output shows, `lockdown=1` has a higher degree of responsibility than `mask=1`.\n",
+    "\n",
+    "The reader might have the impression that the numbers are relatively low: what one needs to remember though is (1) our explanation of how those one-number summaries have stochastic search probabilities mixed in (which may be of interest, as they track causal set size and context sensitivity), and (2) in this model the witnesses are downstream from the interventions, so part of the time some of the interventions are blocked as their effects are stochastically chosen to be witnesses and fixed at the actual values. We go beyond these one-number summaries and investigate the role of witnesses in more detail in the next section."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Fine grained analysis of overshoot using sample traces"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "In this section, we use the samples we obtained earlier to analyze the distribution of `overshoot` variable in different counterfactual worlds. We first define a function to obtain histogram data from the samples in a particular world, and then we inspect the marginal distribution plots for `overshoot` in different settings."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def histogram_data(trace, mwc, masks, world):\n",
+    "    with mwc:\n",
+    "        data_to_plot = gather(\n",
+    "            trace.nodes[\"overshoot\"][\"value\"],\n",
+    "            IndexSet(**{\"lockdown\": {world}, \"mask\": {world}}),\n",
+    "        )\n",
+    "\n",
+    "        mask_tensor = torch.ones(\n",
+    "            importance_tr.nodes[\"__cause____antecedent_mask\"][\"value\"].shape\n",
+    "        ).bool()\n",
+    "        for key, val in masks.items():\n",
+    "            mask_tensor = mask_tensor & (trace.nodes[key][\"value\"] == val)\n",
+    "\n",
+    "        data_to_plot = data_to_plot.squeeze()[torch.nonzero(mask_tensor.squeeze())]\n",
+    "\n",
+    "        os_too_high = gather(\n",
+    "            trace.nodes[\"os_too_high\"][\"value\"],\n",
+    "            IndexSet(**{\"lockdown\": {world}, \"mask\": {world}}),\n",
+    "        )\n",
+    "        os_too_high = os_too_high.squeeze()[torch.nonzero(mask_tensor.squeeze())]\n",
+    "\n",
+    "        overshoot_mean = data_to_plot.mean()\n",
+    "        os_too_high_mean = os_too_high.mean()\n",
+    "\n",
+    "    hist, bin_edges = torch.histogram(\n",
+    "        data_to_plot, bins=36, range=(0, 45), density=True\n",
+    "    )\n",
+    "    return hist, bin_edges, overshoot_mean, os_too_high_mean"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We first plot the distribution of `overshoot` in the factual world (indicated by `world=0`) and necessity counterfactual worlds (indicated by `world=1`) where intervened variables are set to their alternative value. One can see how the distribution changes in the counterfactual worlds. When `mask` is set to 0, high overshoot is still quite likely, whereas when `lockdown` is set to 0, this visibly shifts the distribution towards the lower values of overhead. This agrees with the intuition that `lockdown` has a higher role in inducing high overshoot."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hist_fact_nec, bin_edges, os_fact_nec, oth_fact_nec = histogram_data(\n",
+    "    importance_tr, mwc_imp, {}, 0\n",
+    ")\n",
+    "hist_mask_nec, bin_edges, os_mask_nec, oth_mask_nec = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 0,\n",
+    "        \"__cause____antecedent_lockdown\": 1,\n",
+    "        \"__cause____witness_mask_efficiency\": 0,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    1,\n",
+    ")\n",
+    "hist_lockdown_nec, bin_edges, os_lockdown_nec, oth_lockdown_nec = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 1,\n",
+    "        \"__cause____antecedent_lockdown\": 0,\n",
+    "        \"__cause____witness_lockdown_efficiency\": 0,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    1,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overshoot mean\n",
+      "factual:  24.302181243896484  counterfactual mask:  26.837486267089844  counterfactual lockdown:  21.276477813720703\n",
+      "Probability of overshoot being high\n",
+      "factual:  0.6021000146865845  counterfactual mask:  0.8484848737716675  counterfactual lockdown:  0.32460734248161316\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(3, 1, figsize=(8, 8), sharex=True)  \n",
+    "\n",
+    "width = 45 / 36\n",
+    "\n",
+    "axes[0].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_fact_nec,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"blue\",\n",
+    ")\n",
+    "axes[0].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[0].set_title(\"Factual\")\n",
+    "axes[0].set_xlabel(\"overshoot\")\n",
+    "axes[0].set_ylabel(\"frequency\")\n",
+    "axes[0].legend()\n",
+    "\n",
+    "axes[1].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_lockdown_nec,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"pink\",\n",
+    ")\n",
+    "axes[1].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[1].set_title(\"Counterfactual - Lockdown\")\n",
+    "axes[1].set_xlabel(\"overshoot\")\n",
+    "axes[1].set_ylabel(\"frequency\")\n",
+    "\n",
+    "\n",
+    "axes[2].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_mask_nec,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"green\",\n",
+    ")\n",
+    "axes[2].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[2].set_title(\"Counterfactual - Mask\")\n",
+    "axes[2].set_xlabel(\"overshoot\")\n",
+    "axes[2].set_ylabel(\"frequency\")\n",
+    "\n",
+    "plt.suptitle(\"Counterfactual distribution of overshoot (Necessity Worlds)\")\n",
+    "\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"Overshoot mean\")\n",
+    "print(\n",
+    "    \"factual: \",\n",
+    "    os_fact_nec.item(),\n",
+    "    \" counterfactual mask: \",\n",
+    "    os_mask_nec.item(),\n",
+    "    \" counterfactual lockdown: \",\n",
+    "    os_lockdown_nec.item(),\n",
+    ")\n",
+    "\n",
+    "print(\"Probability of overshoot being high\")\n",
+    "print(\n",
+    "    \"factual: \",\n",
+    "    oth_fact_nec.item(),\n",
+    "    \" counterfactual mask: \",\n",
+    "    oth_mask_nec.item(),\n",
+    "    \" counterfactual lockdown: \",\n",
+    "    oth_lockdown_nec.item(),\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The above histogram also takes into account the context that is being kept fixed. If `lockdown` is being intervened on, keeping `lockdown_efficiency` fixed would hinder the effect of the intervention. Thus to obtain the relevant samples, we also condtition on the appropriate context by rejecting samples. Once we have done so, we take the samples and plot them as density above. The histogram above plots three quantities. It plots $P(\\mathit{os} | \\mathit{ld}, m)$ as the factual distribution of overshoot, $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{os}^w_{\\mathit{ld}'} | \\mathit{ld}, m)$ as `counterfactual_lockdown` where $W = \\{\\mathit{me}\\}$ and $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{os}^w_{\\mathit{m}'} | \\mathit{ld}, m)$ as `counterfactual_mask` where $W = \\{\\mathit{le}\\}$. These distributions help in comparing how necessity interventions for the two antecedents affect the overshoot."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can have similar plots for sufficiency worlds (indicated by `world=2`) where variables are intervened on to have their antecedent values. While this might seem redundant, this investigates probabilistically the impact of the implemented interventions: after all, it might be the case that the observed outcome is an unusual one and that usually, those interventions do not lead to the outcome of interest. The resulting plots show that when `mask` is set to be 1, there is a higher probability of high overshoot, but that this distribution is flatter than the distribution for `lockdown` being set to 1, which has higher peaks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hist_fact_suff, bin_edges, os_fact_suff, oth_fact_suff = histogram_data(\n",
+    "    importance_tr, mwc_imp, {}, 0\n",
+    ")\n",
+    "hist_mask_suff, bin_edges, os_mask_suff, oth_mask_suff = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 0,\n",
+    "        \"__cause____antecedent_lockdown\": 1,\n",
+    "        \"__cause____witness_mask_efficiency\": 0,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    2,\n",
+    ")\n",
+    "hist_lockdown_suff, bin_edges, os_lockdown_suff, oth_lockdown_suff = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 1,\n",
+    "        \"__cause____antecedent_lockdown\": 0,\n",
+    "        \"__cause____witness_lockdown_efficiency\": 0,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    2,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 3 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overshoot mean\n",
+      "factual:  24.302181243896484  counterfactual mask:  26.423648834228516  counterfactual lockdown:  27.30312728881836\n",
+      "Probability of overshoot being high\n",
+      "factual:  0.6021000146865845  counterfactual mask:  0.6717171669006348  counterfactual lockdown:  0.717277467250824\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(3, 1, figsize=(8, 8), sharex=True) \n",
+    "\n",
+    "\n",
+    "axes[0].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_fact_suff,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"blue\",\n",
+    ")\n",
+    "axes[0].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[0].set_title(\"Factual\")\n",
+    "axes[0].set_xlabel(\"overshoot\")\n",
+    "axes[0].set_ylabel(\"density\")\n",
+    "axes[0].legend()\n",
+    "\n",
+    "axes[1].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_lockdown_suff,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"pink\",\n",
+    ")\n",
+    "axes[1].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[1].set_title(\"Counterfactual - Lockdown\")\n",
+    "axes[1].set_xlabel(\"overshoot\")\n",
+    "axes[1].set_ylabel(\"density\")\n",
+    "\n",
+    "axes[2].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_mask_suff,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"green\",\n",
+    ")\n",
+    "axes[2].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[2].set_title(\"Counterfactual - Mask\")\n",
+    "axes[2].set_xlabel(\"overshoot\")\n",
+    "axes[2].set_ylabel(\"density\")\n",
+    "\n",
+    "\n",
+    "plt.suptitle(\"Counterfactual distribution of overshoot (Sufficiency Worlds)\")\n",
+    "\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"Overshoot mean\")\n",
+    "print(\n",
+    "    \"factual: \",\n",
+    "    os_fact_suff.item(),\n",
+    "    \" counterfactual mask: \",\n",
+    "    os_mask_suff.item(),\n",
+    "    \" counterfactual lockdown: \",\n",
+    "    os_lockdown_suff.item(),\n",
+    ")\n",
+    "\n",
+    "print(\"Probability of overshoot being high\")\n",
+    "print(\n",
+    "    \"factual: \",\n",
+    "    oth_fact_suff.item(),\n",
+    "    \" counterfactual mask: \",\n",
+    "    oth_mask_suff.item(),\n",
+    "    \" counterfactual lockdown: \",\n",
+    "    oth_lockdown_suff.item(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The histogram plots three quantities. It plots $P(\\mathit{os} | \\mathit{ld}, m)$ as the factual distribution of overshoot, $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{os}^w_{\\mathit{ld}} | \\mathit{ld}, m)$ as `counterfactual_lockdown` where $W = \\{\\mathit{me}\\}$ and $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{os}^w_{\\mathit{m}} | \\mathit{ld}, m)$ as `counterfactual_mask` where $W = \\{\\mathit{le}\\}$. Again, these distributions help in comparing how sufficiency interventions for the two antecedents affect the overshoot."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can also combine samples from both sufficiency and necessity worlds to focus on a context-sensitive counterpart of the joint probability of necessity and sufficiency directly (see the previous tutorial for more explanation). We first visualize samples where only lockdown is considered as an intervention. Then we analyze masking as an intervention."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Collecting samples for joint distribution of overshoot under necessity and sufficiency interventions on lockdown\n",
+    "masks = {\n",
+    "        \"__cause____antecedent_mask\": 1,\n",
+    "        \"__cause____antecedent_lockdown\": 0,    # Intervening only on lockdown\n",
+    "        \"__cause____witness_lockdown_efficiency\": 0, # Excluding lockdown efficiency fron the context candidates\n",
+    "        \"lockdown\": 1, \"mask\": 1 # Conditioning on lockdown and masking being imposed in factual world\n",
+    "    }\n",
+    "with mwc_imp:\n",
+    "    data_nec = gather(\n",
+    "        importance_tr.nodes[\"overshoot\"][\"value\"],\n",
+    "        IndexSet(**{\"lockdown\": {1}, \"mask\": {1}}),\n",
+    "    )\n",
+    "\n",
+    "    data_suff = gather(\n",
+    "        importance_tr.nodes[\"overshoot\"][\"value\"],\n",
+    "        IndexSet(**{\"lockdown\": {2}, \"mask\": {2}}),\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "    mask_tensor = torch.ones(\n",
+    "        importance_tr.nodes[\"__cause____antecedent_mask\"][\"value\"].shape\n",
+    "    ).bool()\n",
+    "    for key, val in masks.items():\n",
+    "        mask_tensor = mask_tensor & (importance_tr.nodes[key][\"value\"] == val)\n",
+    "\n",
+    "    data_suff = data_suff.squeeze()[torch.nonzero(mask_tensor.squeeze())]\n",
+    "    data_nec = data_nec.squeeze()[torch.nonzero(mask_tensor.squeeze())]\n",
+    "\n",
+    "a = torch.transpose(torch.vstack((data_nec.squeeze(), data_suff.squeeze())), 0, 1) # Joint distribution\n",
+    "hist_lockdown_2d, rough = torch.histogramdd(a, bins=[36, 36], density=True, range=[0.0, 45.0, 0.0, 45.0])\n",
+    "pr_lockdown = (hist_lockdown_2d[:16, 16:].sum()/hist_lockdown_2d.sum())\n",
+    "\n",
+    "\n",
+    "# Collecting samples for joint distribution of overshoot under necessity and sufficiency interventions on mask\n",
+    "masks = {\n",
+    "        \"__cause____antecedent_mask\": 0,\n",
+    "        \"__cause____antecedent_lockdown\": 1,    # Intervening only on mask\n",
+    "        \"__cause____witness_mask_efficiency\": 0,    # Excluding mask efficiency fron the context candidates\n",
+    "        \"lockdown\": 1, \"mask\": 1    # Conditioning on lockdown and masking being imposed in factual world\n",
+    "    }\n",
+    "with mwc_imp:\n",
+    "    data_nec = gather(\n",
+    "        importance_tr.nodes[\"overshoot\"][\"value\"],\n",
+    "        IndexSet(**{\"lockdown\": {1}, \"mask\": {1}}),\n",
+    "    )\n",
+    "\n",
+    "    data_suff = gather(\n",
+    "        importance_tr.nodes[\"overshoot\"][\"value\"],\n",
+    "        IndexSet(**{\"lockdown\": {2}, \"mask\": {2}}),\n",
+    "    )\n",
+    "\n",
+    "    mask_tensor = torch.ones(\n",
+    "        importance_tr.nodes[\"__cause____antecedent_mask\"][\"value\"].shape\n",
+    "    ).bool()\n",
+    "    for key, val in masks.items():\n",
+    "        mask_tensor = mask_tensor & (importance_tr.nodes[key][\"value\"] == val)\n",
+    "\n",
+    "    data_suff = data_suff.squeeze()[torch.nonzero(mask_tensor.squeeze())]\n",
+    "    data_nec = data_nec.squeeze()[torch.nonzero(mask_tensor.squeeze())]\n",
+    "\n",
+    "a = torch.transpose(torch.vstack((data_nec.squeeze(), data_suff.squeeze())), 0, 1) # Joint distribution\n",
+    "hist_mask_2d, _ = torch.histogramdd(a, bins = [36, 36], density=True, range=[0.0, 45.0, 0.0, 45.0])\n",
+    "pr_mask = (hist_mask_2d[:16, 16:].sum()/hist_mask_2d.sum())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABjUAAALnCAYAAADBOsU+AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzddVgV2RvA8S+NmKCIK4h9UQEFG2xMROxW7Fy7dfVnrrGusSq6dndhYgd259qN4FqIIiF15/cHy9UrISiK6Pt5Hh69M2fOnDl37tx57zlzjo6iKApCCCGEEEIIIYQQQgghhBDfOd3ULoAQQgghhBBCCCGEEEIIIURSSKOGEEIIIYQQQgghhBBCCCHSBGnUEEIIIYQQQgghhBBCCCFEmiCNGkIIIYQQQgghhBBCCCGESBOkUUMIIYQQQgghhBBCCCGEEGmCNGoIIYQQQgghhBBCCCGEECJNkEYNIYQQQgghhBBCCCGEEEKkCdKoIYQQQgghhBBCCCGEEEKINEEaNYQQQgghhBBCCCGEEEIIkSZIo4YQQgjxk3v58iW9e/emTJky2NjYsHTp0tQu0hdxcXFh6NChiabx8/PDxsaGRYsWfaNS/byuXLlC8+bNcXBwwMbGhhs3bqR2kVLUrFmzsLGx4dWrV6ldlO+KjY0Ns2bNSu1i/DA2b96MjY0Nfn5+qV2UFDN06FBcXFy++X6PHDlCvXr1sLe3x8bGhqCgIAC2bNlCrVq1sLW1pWTJkgB4eHjg4eGR7H38COf/j3jOfU2x3wVCCCGE+Db0U7sAQgghRGry9fVl4cKFHD9+nOfPn2NgYIBKpcLV1ZVmzZphbGyc2kVk1apVpEuXjoYNG36V/CdOnMjRo0fp2bMn2bJlw87OLkXzDwsLY+HChZQuXZoyZcqkaN5p0bNnz1i/fj3VqlWjcOHCqV2cryoyMpK+fftiaGjIsGHDMDY2JmfOnKldrB/G9u3bCQgIoF27dqldFJEKvvZ3w48oMDCQvn37UrBgQUaOHImhoSHp0qXj3r17DBs2jAoVKtClS5fv4rs/Lbt79y67du2iQYMGWFlZpXZxUozczwghhBDfD2nUEEII8dM6fPgwffr0wdDQkHr16qFSqYiMjOT8+fP8+eef3L17l3HjxqV2MVmzZg2mpqZf7YerU6dOUbVqVTp27PhV8g8LC8PT05OePXvKjwDA8+fP8fT0xNLS8odv1PD19cXf35/ff/+dJk2apHZxfjg7duzgzp070qjxE6hXrx5ubm4YGhpqln3t74Yf0dWrVwkJCaFPnz44Oztrlp85cwa1Ws3w4cPJnTu3ZvnnPs135coV9PT0vri8qSm+cy6p7t69i6enJ6VLl/7hGjUSup/p3r07Xbp0SaWSCSGEED8fadQQQgjxU3r8+DH9+vUjZ86cLFu2jOzZs2vWtWrVikePHnH48OHUK+BXFhUVhVqtxtDQkICAADJlypTaRRI/oNghmTJmzJjKJUmeDz8fIvWFh4djYGCAru7PO3Kunp5emv+R/HuQ0DUpICAg3uWfew0wMjL6rO2+J9/jORcaGoqJiUlqFyNe+vr66OvLzytCCCHEt/LzRgZCCCF+agsXLiQ0NJTx48drNWjEyp07N23bttW8joqKYvbs2VSrVg07OztcXFyYNm0aERERWtslNI72x/M8xI5Vff78eSZOnEjZsmVxcHCgR48eWmPzu7i4cOfOHc6cOYONjQ02NjZa43sHBQUxfvx4KlWqhJ2dHdWrV2f+/Pmo1WpNmg/nj1i6dCnVqlXD3t6e1atXY2Njg6IorFq1SpM/wOvXr/njjz9wd3fH0dGR4sWL06lTJ27evBnn2MLDw5k1axY1a9bE3t6e8uXL07NnT3x9ffHz88PJyQkAT09PzT5i6yih8crjG2t90aJFNG/enDJlylC0aFEaNmzI7t2742ybXOvWrdO8r40aNeLKlStx0ty7d4/evXtTunRp7O3tadiwIQcOHNBKk5Q6O336NI0bNwZg2LBhmvrYvHmzpj7q1KnDzZs3ad26NcWKFaN69eqa4zxz5gxNmjShaNGi1KxZkxMnTmiVwd/fn9GjR1OzZk2KFi1KmTJl6N27d5wx0WPPv7NnzzJy5EjKlClD8eLFGTx4MG/evElSvZ08eZKWLVvi4OBAyZIl6d69O/fu3dOsHzp0KK1btwagT58+cc7d+Dx+/FhTz8WKFaNp06ZajYsvX76kSJEieHp6xtn2/v372NjYsHLlSs2yL/l8xB7LihUrcHNzo1ixYpQqVYqGDRuyffv2OPt/+/YtQ4cOpWTJkpQoUYJhw4YRFhamlSap1xGIGVrIzc0NOzs7ypcvz5gxYzRj/0PMuXL48GH8/f0151Fi8xPEHmfsufahj69bsWPDP3r06JPHFBERwYQJEyhbtiyOjo5069aNp0+fxluGZ8+eMWzYMJydnbGzs8PNzY2NGzdqpTl9+jQ2Njbs3LmT6dOnU6FCBYoVK0ZwcHCix7Vo0aIU+yxDzLkzYcIEXFxcsLOzo2LFigwePFjr+hwREcHMmTOpXr06dnZ2VKpUicmTJ8d5P48fP06LFi0oWbIkjo6O1KxZk2nTpmml+dR59vH8Bgl9Nzx+/DjBuZEuXLiAjY0NO3bsiLcuY49pxowZNGzYkBIlSuDg4EDLli05derUF9X7/v37qVOnDvb29tSpU4d9+/YlWIaPXb16lY4dO2qu/S4uLgwbNkyzPvacOX36dLxl/PD6OmTIEAAaN26MjY2N5rsm9vx3cnL65HdUYt95seK7F0jO+e/t7c3ff/9NxYoVsbe3p23btjx69ChO3Vy+fJnOnTtTqlQpHBwccHd3Z9myZQBs2rQJGxsbrl+/Hme7uXPnUrhwYZ49e5Zgvcc3p4aLiwtdu3bl3LlzNG7cGHt7e6pWrcqWLVu0tuvTpw8Abdq00ZyfH74/Pj4+mu8PR0dHunTpwp07d7T2P3ToUBwdHfH19aVz5844OjoycOBAxo4di6OjY5xrEUD//v0pV64c0dHRn7WvZ8+e8euvv+Lo6EjZsmX5448/NHl96n4mvjk1knrNT0q9QsyQjp6entSoUQN7e3vKlClDixYtOH78eNw3UAghhPjBSVcCIYQQP6VDhw6RK1cuihcvnqT0I0aMwMvLi5o1a9K+fXuuXLnCvHnzuHfvHrNnz/7scvz+++9kypSJnj174u/vz7Jlyxg7dix//fUXAL/99hvjxo3DxMSEbt26AZAtWzYgZhiE1q1b8+zZM5o3b84vv/zCxYsXmTZtGi9evGD48OFa+9q8eTPh4eE0bdoUQ0NDbG1tmTx5MoMHD6ZcuXLUq1dPk/bx48fs37+fWrVqYWVlxcuXL1m3bh2tW7dm586dWFhYABAdHU3Xrl05efIkbm5utGnThpCQEI4fP87t27dxdnZm9OjRjB49murVq1O9enWAz5pMc/ny5bi4uODu7k5kZCQ7d+6kT58+zJs3j8qVKyc7P4gZvickJIRmzZqho6PDwoUL6dWrF/v378fAwACAO3fu0KJFCywsLOjcuTMmJibs2rWLHj16MGvWLM0xJaXO8ufPT+/evZk5cybNmjWjRIkSAFrn4Zs3b+jWrRu1a9emVq1arFmzhv79+6NWq5kwYQLNmzenTp06LFq0iN69e3P48GEyZMgAxPz4d/HiRdzc3MiRIwf+/v6sWbOGNm3asHPnTtKlS6d1/GPHjtWcfw8ePGDNmjU8efKEFStWoKOjk2C9nThxgs6dO2NlZUXPnj159+4dK1eupEWLFmzevBkrKyuaNWuGhYUFc+fOxcPDA3t7e825G5+XL1/SvHlzwsLC8PDwwNTUFC8vL7p376754ThbtmyUKlWKXbt20bNnT63tvb290dPTo1atWsCXfz4yZ87M+vXr+f3336lZsyZt2rQhPDycW7ducfnyZdzd3bW279u3L1ZWVvTv35/r16+zYcMGzMzMGDRokCZNUq8js2bNwtPTE2dnZ1q0aKF5b65evcqaNWswMDCgW7duvH37lqdPn2p+4E2fPn2C9fs5knJMw4cPZ9u2bdSpU4fixYtz6tSpeIdgefnyJU2bNkVHR4dWrVphZmbGkSNHGD58OMHBwXGG0JozZw4GBgZ07NiRiIgIzecxISn5WQ4JCaFVq1bcu3ePRo0aUaRIEQIDAzl48CDPnj3DzMwMtVpN9+7dOX/+PE2bNiV//vzcvn2bZcuW8fDhQ+bMmaPZZ9euXbGxsaF3794YGhry6NEjLly4oCl7cs6zWAl9N8R+r23bti1OnW7fvp306dNTtWrVBOsxODiYDRs2UKdOHZo0aUJISAgbN26kU6dObNiwIc6QeUmp92PHjtGrVy8KFCjAgAEDCAwMZNiwYeTIkSPR9xRinqDo2LEjpqamdOnShUyZMuHn55esRpFY3bp1I2/evKxbt47evXtjZWWFtbU11apVY8uWLezbt4/Ro0djYmKS4HfUp77zrK2t490uuef/ggUL0NHRoUOHDgQHB7Nw4UIGDhzIhg0bNGmOHz9O165dyZ49O23atCFbtmzcu3ePw4cP07ZtW2rWrMnYsWPZvn07RYoU0cp/+/btlC5dWvNdnhyPHj2iT58+NG7cmAYNGrBp0yaGDh2Kra0tBQsWpFSpUnh4eLBixQq6detGvnz5AMifPz8QMyH70KFDKV++PAMHDiQsLIw1a9bQsmVLvLy8tIarioqKomPHjpQoUYIhQ4ZgbGyMlZUVq1at4vDhw7i6umrShoWFcejQIRo0aKB5wiQ5+4qOjqZjx44ULVqUwYMHc/LkSRYvXkyuXLlo2bIlZmZmyb6fSc6946fqFWIaU+bNm6fp3BAcHMw///zDtWvXKFeuXLLfSyGEECJNU4QQQoifzNu3bxWVSqV07949Selv3LihqFQqZfjw4VrLJ02apKhUKuXkyZOaZSqVSpk5c2acPKpUqaIMGTJE83rTpk2KSqVS2rVrp6jVas3yCRMmKIULF1aCgoI0y9zc3JTWrVvHyXP27NmKg4OD8uDBA63lU6ZMUQoXLqw8efJEURRFefz4saJSqZTixYsrAQEBcfJRqVTKmDFjtJaFh4cr0dHRWsseP36s2NnZKZ6enpplGzduVFQqlbJkyZI4+cYeV0BAQIL10rp163iPbciQIUqVKlW0loWFhWm9joiIUOrUqaO0adNGa/nHdR2f2DopXbq08vr1a83y/fv3KyqVSjl48KBmWdu2bZU6deoo4eHhWsfWrFkzpUaNGpplSa2zK1euKCqVStm0aVOccrVu3VpRqVTK9u3bNcvu3bunqFQqpVChQsqlS5c0y48ePRonn4/rSFEU5eLFi4pKpVK8vLw0y2LPvwYNGigRERGa5QsWLFBUKpWyf//+uJX2gXr16ilOTk5KYGCgZtmNGzeUQoUKKYMHD9YsO3XqlKJSqZRdu3Ylmp+iKMr48eMVlUqlnD17VrMsODhYcXFxUapUqaKp27Vr1yoqlUq5deuW1va1a9fWOhdS4vPRvXt3xc3NLdFyz5w5U1GpVMqwYcO0lvfo0UMpXbq05nVSryMBAQGKra2t0qFDB63zaeXKlYpKpVI2btyoWdalS5c4n5OExB5nfOfdx5/P5B7T6NGjtdL1798/Tp6//fabUq5cOeXVq1daafv166eUKFFCc+7GnjNVq1aN93xO6LhS8rM8Y8YMRaVSKXv37o2zv9jr2pYtW5RChQppna+Koihr1qxRVCqVcv78eUVRFGXJkiWKSqWK99obKynnWexn9vHjx5plCX03xH5G7t69q1kWERGhlClT5pPXxqioKK36URRFefPmjeLs7Kx1PiSn3uvVq6eUK1dO63vt2LFjikql+uT5u2/fPkWlUilXrlxJME3sOXPq1Cmt5fGd87H1+HF+sef8x+/Tx99RSfnOU5S4n6nknv+urq5a78OyZcu0rntRUVGaa+ObN28SLEf//v2V8uXLa11Lrl27luC14EPxnXNVqlSJc50OCAhQ7OzslEmTJmmW7dq1K973JDg4WClZsqQyYsQIreUvXrxQSpQoobV8yJAhikqlUqZMmRLn+CpUqKD06tVLa7m3t7dW2T5nXx9+VyuKotSvX19p0KCB1rEmdD8Tew7FSs69Y1LrtW7dukqXLl3i7FsIIYT4GcnwU0IIIX46scOYJLVXs4+PDwDt27fXWt6hQwet9Z8jtudmrJIlSxIdHY2/v/8nt929ezclSpQgU6ZMvHr1SvPn7OxMdHQ0Z8+e1Upfo0YNzMzMklQuQ0NDzfj10dHRBAYGYmJiQt68ebWGsti7dy+mpqaaYYY+lFhP/89hbGys+f+bN294+/YtJUqUiHdojaSqXbs2mTNn1rwuWbIkEPPUBcQMKXXq1ClcXV0JDg7W1HFgYCDly5fn4cOHmuE7klpnn2JiYoKbm5vmdb58+ciUKRP58+enWLFimuWx/48tK2jXUWRkJIGBgVhbW5MpU6Z4y9CsWTOtHvAtWrRAX18/0XP6+fPn3LhxgwYNGpAlSxbN8kKFCuHs7PzZnwcfHx+KFi2qeQ8g5jParFkz/P39uXv3LgDVq1dHX18fb29vTbrbt29z9+5dateurVmWEp+PTJky8fTp03iH0/lY8+bNtV6XLFmS169fa643Sb2OnDhxgsjISNq0aaM1h0STJk3IkCHDF11vkiupx/Tx8DwfDt0HoCgKe/fuxcXFBUVRtN6P8uXL8/btW65du6a1Tf369bXO509Jyc/y3r17KVSokKYn9odir2u7d+8mf/785MuXT+t4ypYtC6AZaid2vqIDBw5oDXv2oeScZ0nh6uqKkZGR1vBVx44dIzAwkLp16ya6rZ6enmYeCbVazevXr4mKisLOzi7ea8in6v3D68WH81WUK1eOAgUKfPJYYrc5fPgwkZGRn0z/tX3Od97nnP8NGzbUms/j43q9fv06fn5+tGnTJs6cWB+Wo169ejx//lxr6Kft27djbGxMjRo1knn0MQoUKKB1nTYzMyNv3rxa30UJOXHiBEFBQbi5uWnVg66uLsWKFYszhBjEfC99SEdHh1q1auHj40NISIhm+a5du7CwsNA8AZkS+ypRokSc4RuTKrn3jkmp10yZMnHnzh0ePnz4WWUSQgghfiQy/JQQQoifTuxQPR8Gw4nx9/dHV1c3zrAS5ubmZMqUKUkNEAnJmTOn1uvYHyc+HDs/IY8ePeLWrVuaMZ4/9uHY74DWMAufolarWb58OatXr8bPz09rfOoPf8j29fUlb96832RyzEOHDvH3339z48YNrfGov6Tx5JdfftF6HfvjXGz9+/r6oigKM2bMYMaMGfHmERAQgIWFRZLr7FNy5MgR55gyZswYZ6iW2B/7PjxX3r17x7x589i8eTPPnj1DURTNurdv38bZV+7cubVep0+fHnNz80TP6SdPngCQN2/eOOvy58/PsWPHPmsy1ydPnmg12sSKHbrkyZMnqFQqzMzMKFu2LLt27aJv375AzNBT+vr6Wj9Cp8Tno3Pnzpw4cYImTZqQO3duypUrR506dTQ/mn0ooc/ymzdvyJAhQ5KvI7H1G3vcsQwNDcmVK9cXXW+S63OP6eOyv3r1iqCgINatW8e6devi3deXXK8gZT/Lvr6+n/zB99GjR9y7dy/B8yt24unatWuzYcMGRowYwdSpU3FycqJ69erUqlVL02iVnPMsKTJlykSVKlXYsWOH5jOyfft2LCwsNI0uifHy8mLx4sU8ePBAqyEhvvfkU/Ueez5/fK0BktTgW7p0aWrWrImnpydLly6ldOnSVKtWDXd398+exPtLfM533uec/5+6N4j9oVulUiW673LlymFubs62bdtwcnJCrVazY8cOqlatqrkXSq6P33OIed+TMh9T7I/xHzd8xvq4TPr6+vEOU1a7dm2WLVvGwYMHcXd3JyQkBB8fH80waJ+zLyMjozgN20k9rvgk994xKfXau3dvfv31V2rWrIlKpaJ8+fLUq1ePQoUKfVYZhRBCiLRMGjWEEEL8dDJkyED27NnjTBT5KV/y4/mHP3B/6MOe2B/68MfohKjVasqVK0enTp3iXZ8nTx6t18np9Tx37lxmzJhBo0aN6NOnD5kzZ0ZXV5cJEyYkqWxf6uP6OnfuHN27d6dUqVKMGjUKc3NzDAwM2LRpU6KT3n5K7LjbH4s9xtie1R06dKBChQrxpo39wSKl6iyhMn2qrADjxo1j8+bNtG3bFgcHBzJmzIiOjg79+vX7Ju/bt+Lm5sawYcO4ceMGhQsXZteuXZQtW1brB6mU+Hzkz5+f3bt3c/jwYY4ePcrevXtZvXo1PXr0oHfv3lppk/pZTuknmJIqof0mdG2CL7s+fSj2c1S3bl0aNGgQb5qPx6VPzvUKUvaznBRqtRqVSqU1YfWHYn+INTY2ZtWqVZw+fVpzHnl7e7Nu3ToWL16Mnp5ess6zpKpfvz67d+/mwoULqFQqDh48SIsWLRJ8T2Nt3bqVoUOHUq1aNTp27EjWrFnR09Nj3rx58fbET8p16Uvo6Ogwc+ZMLl26xKFDhzh69Ci//fYbS5YsYd26daRPnz7BczuhJ2O+tc85/1Pqs6enp4e7uzvr169n9OjRXLhwgefPn3/yiZ1P5fm5Yss/efJkzM3NP5n3h09AfsjBwQFLS0t27dqFu7s7hw4d4t27d1pP6yV3X19yXIlJ6jU/KfsvVaoU+/bt48CBAxw/fpyNGzeybNkyxowZQ5MmTb60qEIIIUSaIo0aQgghfkpVqlRh3bp1XLx4EUdHx0TTWlpaolarefTokWaiS4iZ+DMoKAhLS0vNssyZM8d5yiIiIoIXL158dlkTCoitra0JDQ3F2dn5s/NOyJ49eyhTpgwTJkzQWh4UFISpqalWGS5fvkxkZGSCE/kmFtBnzpw53h/KYnv3flgeIyMjFi1apNU7d9OmTUk6ns+VK1cuAAwMDD5Zz0mts6/5o/aePXuoX78+Q4cO1SwLDw+P9ykNiOlt/mHP7ZCQEF68eEHFihUT3EdsD+IHDx7EWXf//n1MTU2T/ZRGbL4J5fnhfgGqVavGyJEjNUNQPXz4kK5du2ptl1KfDxMTE2rXrk3t2rWJiIigV69ezJ07l65du2JkZJTkfJJ6HYk9zvv372vOP4i5jvj5+WkdT3LOpY970Mf6+LOWHLHH5Ovrq/V0Rux7FsvMzIz06dOjVqu/yvUqKZLzWba2tv5ko7e1tTU3b97Eycnpk++Drq4uTk5OODk5MWzYMObOncv06dM5ffq0piyfc54ltt8KFSpgZmbG9u3bKVasGGFhYdSrVy/RckLMNSRXrlx4enpq5T9z5sxPbhuf2PP50aNHcdbF93lPiIODAw4ODvTr14/t27czcOBAvL29adKkieYpho+vc1/jqaakfOd97Guc/7Hn8+3btz+ZZ7169Vi8eDEHDx7kyJEjmJmZUb58+RQpR0ISOjdjy501a9YvrgtXV1eWL19OcHAw3t7eWFpa4uDg8FX2FSs519zk3DsmR5YsWWjUqBGNGjUiJCSE1q1bM2vWLGnUEEII8dOROTWEEEL8lDp16oSJiQkjRozg5cuXcdb7+vqybNkyACpVqgSgeR1ryZIlWushJog+d+6cVrr169cn2hv6U9KlSxfvcFSurq5cvHiRo0ePxlkXFBREVFTUZ+9TT08vTo/QXbt2acacj1WjRg0CAwNZtWpVnDxit0+XLp2mTB/LlSsX9+/f1xp64+bNm1y4cCFOeXR0dLTq0c/PjwMHDiTzyJIna9aslC5dmnXr1vH8+fM46z8sd1LrLLH6+FLx9fRcsWJFguffunXrtIaXWbNmDVFRUYk2amTPnp3ChQuzZcsWrWO4ffs2x48f1/o8JEelSpW4cuUKFy9e1CwLDQ1l/fr1WFpaao2/nylTJsqXL8+uXbvYuXMnBgYGVKtWTSu/lPh8BAYGar02NDQkf/78KIqS7PH9k3odcXZ2xsDAgBUrVmidTxs3buTt27da9ZsuXboEG6w+liFDBkxNTeNcn1avXp2s4/hQ7HmyYsUKreUfH6Oenh41a9Zkz5493L59O04+Hw+98zUk57Nco0YNbt68yb59++Kki31PXF1defbsGevXr4+T5t27d4SGhgIxc3l8rHDhwgCaYfQ+9zxL6LsBYobtcXNzY9euXWzevBmVSpWkIWpiryEfnnuXL1/m0qVLn9w2PrHXCy8vL61z9fjx45p5chLz5s2bONfVj+vP0tISPT29OPPkrFmz5rPKnJikfOd97Guc/7a2tlhZWbF8+fI458DH5ShUqBA2NjZs3LiRvXv34ubm9tWHjIz9nvv4+lShQgUyZMjAvHnz4j23k1MXsQ2AXl5eHD16FFdX16+2r1jJ+f5Ozr1jUn18rUifPj3W1tZaQ3IKIYQQPwt5UkMIIcRPydramilTptCvXz9q165NvXr1UKlUREREcPHiRXbv3k3Dhg2BmB8EGjRowLp16wgKCqJUqVJcvXoVLy8vqlWrptXTvUmTJowaNYpevXrh7OzMzZs3OXbsmFZP/eSytbVlzZo1zJkzh9y5c2NmZoaTkxMdO3bk4MGDdOvWjQYNGmBra0tYWBi3b99mz549HDhwIMkTg3+scuXKzJ49m2HDhuHo6Mjt27fZvn27Vs9xiBniZMuWLUycOJErV65QokQJwsLCOHnyJC1atKBatWoYGxtToEABdu3aRZ48eciSJQsFCxZEpVLRuHFjli5dSseOHWncuDEBAQGsXbuWAgUKaM15UqlSJZYsWUKnTp2oU6cOAQEBrF69Gmtra27duvXZdZsUo0aNomXLlri7u9O0aVNy5crFy5cvuXTpEk+fPmXbtm3JqrPYibvXrl1L+vTpMTExoWjRonHSfY7KlSuzdetWMmTIQIECBbh06RInTpxIcE6PyMhI2rVrh6urKw8ePGD16tWUKFGCqlWrJrqfwYMH07lzZ5o1a0bjxo159+4dK1euJGPGjPTs2fOzyt6lSxd27txJ586d8fDwIHPmzGzZsgU/Pz9mzZoVZwiS2rVrM2jQIFavXk358uXjTJabEp+Pjh07ki1bNooXL07WrFm5f/8+K1eupFKlSskejz6p1xEzMzO6du2Kp6cnnTp1wsXFRfPe2Nvbaw0bY2tri7e3NxMnTsTe3h4TExNcXFwSLEOTJk2YP38+w4cPx87OjnPnziWrt/zHChcuTJ06dVi9ejVv377F0dGRU6dOxdsrf8CAAZw+fZqmTZvSpEkTChQowJs3b7h27RonT57kzJkzn12OpErqZ7ljx47s2bOHPn360KhRI2xtbXnz5g0HDx5kzJgxFCpUiHr16rFr1y5GjRrF6dOnKV68ONHR0dy/f5/du3ezcOFC7O3tmT17NufOnaNSpUpYWlpqrl05cuTQzJnxuedZQt8NserXr8+KFSs4ffo0AwcOTFIdVa5cmb1799KjRw8qV66Mn5+f5poc21CTXP3796dr1660bNmSRo0a8fr1a1auXEnBggU/maeXlxdr1qyhWrVqWFtbExISwvr168mQIYOmUS1jxozUqlWLlStXoqOjQ65cuTh8+LBmXpOUlJTvvPik9Pmvq6vL6NGj6d69O/Xr16dhw4aYm5tz//597t69y6JFi+KU+48//gD4oqGnkqpw4cLo6emxYMEC3r59i6GhIWXLliVr1qyMHj2awYMH07BhQ2rXro2ZmRlPnjzBx8eH4sWLM3LkyCTtw9bWlty5czN9+nQiIiK0hp6CmIbclNpXrMTuZz6WnHvHpHJzc6N06dLY2tqSJUsWrl69yp49e+KduF4IIYT40UmjhhBCiJ9W1apV2bZtG4sWLeLAgQOsWbMGQ0NDbGxsGDp0KE2bNtWk/f3337GyssLLy4v9+/eTLVs2unbtGucH3KZNm+Ln58fGjRs5evQoJUqUYMmSJbRr1+6zy9mjRw+ePHnCwoULCQkJoXTp0jg5OZEuXTpWrFjBvHnz2L17N1u2bCFDhgzkyZOHXr16aSaS/hzdunUjLCyM7du34+3tTZEiRZg3bx5Tp07VShf7o8Xff//Njh072Lt3L1myZKF48eJaY4T//vvvjBs3jokTJxIZGUnPnj1RqVTkz5+fP/74g5kzZzJx4kQKFCjA5MmT2bFjh9aPPE5OTowfP54FCxYwYcIErKysGDhwIP7+/l+9UaNAgQJs2rQJT09PvLy8eP36NWZmZhQpUoQePXoku84MDAyYNGkS06ZNY/To0URFRTFx4sQUadQYPnw4urq6bN++nfDwcIoXL65pDIrPyJEj2b59OzNnziQyMhI3NzdGjBjxySE2nJ2dWbhwITNnzmTmzJno6+tTqlQpBg0a9NnHkS1bNtauXcuff/7JypUrCQ8Px8bGhrlz51K5cuU46V1cXDA2NiYkJCTOj1lAinw+mjVrxvbt21myZAmhoaHkyJEDDw8Pfv311886xqReR3r16oWZmRkrV65k4sSJZM6cmaZNm9K/f3+tIW9atmzJjRs32Lx5M0uXLsXS0jLRRo0ePXrw6tUr9uzZw65du6hYsSILFy5McLLrpJgwYQKmpqZs376dAwcOUKZMGebPnx+nF3K2bNnYsGEDs2fPZt++faxZs4YsWbJQoECBJP/g/qWS+llOnz49q1atYtasWezbtw8vLy+yZs2Kk5MTFhYWQMyPyrNnz2bp0qVs3bqVffv2kS5dOqysrPDw8CBv3rxAzHnq7+/Ppk2bCAwMxNTUlNKlS2udg597niX03RDLzs6OggULcu/evST/kN2wYUNevnzJunXrOHbsGAUKFODPP/9k9+7dn93wVLFiRWbMmMFff/3F1KlTsba2ZuLEiRw4cOCTeZYuXZqrV6/i7e3Ny5cvyZgxI0WLFmXKlCla15oRI0YQFRXF2rVrMTQ0pFatWgwePJg6dep8VpkTktTvvI99jfO/QoUKLFu2jNmzZ7N48WIURSFXrlxa9y6x3N3dNXVWtGjRz9pfcpibmzNmzBjmzZvH8OHDiY6OZvny5WTNmhV3d3eyZ8/O/PnzWbRoEREREVhYWFCyZElNZ5KkcnV1Ze7cueTOnRtbW9s461NyX7ESup9JKG1SrvlJ5eHhwcGDBzl+/DgRERHkzJmTvn370rFjx8/KTwghhEjLdJQfadZIIYQQQgjxSZs3b2bYsGFs3LgRe3v71C6OEOIrqV+/PpkzZ44zBI74ubx69YoKFSrw66+/ajXgCSGEEEKkVTKnhhBCCCGEEEL8YK5evcqNGzeoX79+ahdFpDIvLy+io6OTNFm8EEIIIURaIMNPCSGEEEIIIcQP4vbt21y7do3Fixdjbm4e7/Bs4udw8uRJ7t27x9y5c6lWrRpWVlapXSQhhBBCiBQhjRpCCCGEEEII8YPYs2cPs2fPJm/evEybNg0jI6PULpJIJXPmzOHixYs4Ojryv//9L7WLI4QQQgiRYmRODSGEEEIIIYQQQgghhBBCpAkyp4YQQgghhBBCCCGEEEIIIdIEadQQQgghhBBCCCGEEEIIIUSaII0aQgghhBBCCCGEEEIIIYRIE6RRQwghhBBCCCGEEEIIIYQQaYI0agghhBBCCCGEEEIIIYQQIk2QRg0hhBBCCCGEEEIIIYQQQqQJ0qghhBBCCCGEEEIIIYQQQog0QRo1hBBCCCGEEEIIIYQQQgiRJkijhhBCCCGEEEIIIYQQQggh0gRp1BBCCCGEEEIIIYQQQgghRJogjRpCCCGEEEIIIYQQQgghhEgTpFFDCCGEEEIIIYQQQgghhBBpgjRqCCGEEEIIIYQQQgghhBAiTZBGDSGEEEIIIYQQQgghhBBCpAnSqCGEEEIIIYQQQgghhBBCiDRBGjWEEEIIIYQQQgghhBBCCJEmSKOGEEIIIYQQQgghhBBCCCHSBGnUEEIIIYQQQgghhBBCCCFEmiCNGkIIIYQQQgghhBBCCCGESBOkUUMIIYQQQgghhBBCCCGEEGmCNGoIIYQQQgghhBBCCCGEECJNkEYNIYQQQgghhBBCCCGEEEKkCdKoIYQQQgghhBBCCCGEEEKINEEaNYQQQgghhBBCCCGEEEIIkSZIo4YQQgghhBBCCCGEEEIIIdIEadQQQgghhBBCCCGEEEIIIUSaII0aQgghhBBCCCGEEEIIIYRIE6RRQwghhBBCCCGEEEIIIYQQaYI0agghhBBCCCGEEEIIIYQQIk2QRg0hhBBCCCGEEEIIIYQQQqQJ0qghhBBCCCGEEEIIIYQQQog0QRo1hBBCCCGEEEIIIYQQQgiRJkijhhBCCCGEEEIIIYQQQggh0gRp1BBCCCGEEEIIIYQQQgghRJogjRpCCCGEEEIIIYQQQgghhEgTpFFDCCGEEEIIIYQQQgghhBBpgjRqCCGEEEIIIYQQQgghhBAiTZBGDSGEEEIIIYQQQgghhBBCpAnSqCGEEEIIIYQQQgghhBBCiDRBGjWEEEIIIYQQQgghhBBCCJEmSKOGEEIIIYQQQgghhBBCCCHSBGnUEEIIIYQQQgghhBBCCCFEmiCNGkIIIYQQQgghhBBCCCGESBOkUUMIIYQQQgghhBBCCCGEEGmCNGoIIYQQQgghhBBCCCGEECJNkEYNIYQQQgghhBBCCCGEEEKkCdKoIYTAw8ODOnXqpHYxPsnPzw8bGxs2b96c2kX5YURFRTF58mQqVapEoUKF+PXXX1O7SF9k6NChuLi4fDKdh4cHHh4eX60cNjY2jB079rO2PX36NDY2Npw+fTqFSyWEEEIIkbZInPLz+lnjlO9JWvn8CSF+TvqpXQAhfhR37txh3rx5nD59msDAQLJkyUKZMmXo1q0bBQsWTO3ifbfmzp1LgQIFqFatWmoX5bvk4+PDlStX6NWr11fJf9OmTSxatIi2bdtSpEgRcubMmeL7WLVqFenSpaNhw4YpnrcQQgghhEicxCmfR+KUxEmcIoQQIjVJo4YQKWDv3r3079+fLFmy0KhRI6ysrPD392fjxo3s2bOH6dOnU7169dQu5ndp3rx51KxZM0nBgqWlJVeuXEFf/+e5dPn4+LBq1aqvFiycOnUKCwsLfvvtt6+SP8CaNWswNTWVYEEIIYQQ4huTOOXzSZySOIlThBBCpKaf5xtXiK/E19eXwYMHkytXLlatWoWZmZlmXZs2bWjVqhWDBw9m27Zt5MqV65uVKzQ0FBMTk2+2v29BR0cHIyOj1C5GmqcoCuHh4RgbGxMQEECmTJlSu0hCCCGEECKFSZzy7UickjIkThFCCJFUMqeGEF9o4cKFhIWFMW7cOK1AAcDMzIyxY8cSGhrKggULANi9ezc2NjacOXMmTl5r167FxsaG27dva5bdu3eP3r17U7p0aezt7WnYsCEHDhzQ2m7z5s2aPEePHo2TkxOVKlUCIDg4mPHjx+Pi4oKdnR1OTk60b9+ea9euxdn/3bt38fDwoFixYlSoUEFT5g8FBATw22+/4ezsjL29PXXr1sXLyytOutDQUCZNmkSlSpWws7OjZs2aLFq0CEVRNGlsbGwIDQ3Fy8sLGxsbbGxsGDp0aIJ1Hd9YtUOHDsXR0ZFnz57x66+/4ujoSNmyZfnjjz+Ijo5OMK8P+fj40Lp1axwdHSlevDiNGjVi+/btWml27dpFw4YNKVq0KGXKlGHgwIE8e/ZMK01C8zR8PH5q7HEsWrSIdevWUa1aNezs7GjUqBFXrlzR2m7VqlWauor9i6VWq1m6dClubm7Y29vj7OzMyJEjefPmjdb+XVxc6Nq1K0ePHtUcQ+y5dvr0ae7cuaPJO3Yeh0WLFtG8eXPKlClD0aJFadiwIbt37463/rZu3Urjxo0pVqwYpUqVolWrVhw7dkyz7zt37nDmzBnNPmLraNasWVrHEyv2fPbz89Ms279/P126dKF8+fLY2dlRrVo1Zs+eneT3OCmSem6r1WqWLVuGu7s79vb2lC1blo4dO3L16tVE858zZw6FChVixYoVmmVPnz7l119/xcHBAScnJyZMmEBERES823/qHDxw4AA2NjbcvHlTs2zPnj3Y2NjQs2dPrbxcXV3p27ev5nXsHCD79++nTp062NnZ4ebmxpEjRxI9JiGEEEJ8vyROkTgllsQpaSdOia2T06dPa+rE3d1dc/x79+7VxCENGzbk+vXrWtvfvHmToUOHUrVqVezt7SlXrhzDhg0jMDBQK11yPn8fOnbsGMWKFaN///5ERUV91jEKIURKkCc1hPhChw4dwtLSkpIlS8a7vlSpUlhaWuLj4wNA5cqVMTExYdeuXZQuXVorrbe3NwULFkSlUgEx49+2aNECCwsLOnfurNmuR48ezJo1K86j4mPGjMHMzIwePXoQGhoKwKhRo9izZw+tW7cmf/78vH79mvPnz3Pv3j1sbW01275584ZOnTpRvXp1XF1d2bNnD1OmTEGlUmkCj3fv3uHh4YGvry+tWrXCysqK3bt3M3ToUIKCgmjbti0Q08Ome/funD59msaNG1O4cGGOHj3K5MmTefbsmeYR4smTJzNixAiKFi1K06ZNAbC2tk72exAdHU3Hjh0pWrQogwcP5uTJkyxevJhcuXLRsmXLRLfdvHkzv/32GwULFqRr165kzJiRGzducPToUdzd3TVphg0bhr29Pf379ycgIIDly5dz4cIFtmzZ8tk9iHbs2EFISAjNmjVDR0eHhQsX0qtXL/bv34+BgQHNmjXj+fPnHD9+nMmTJ8fZfuTIkXh5edGwYUM8PDzw8/Nj1apVXL9+nTVr1mBgYKBJ++DBAwYMGECzZs1o2rQpOXLkYPLkycydO5fQ0FD69+8PQP78+QFYvnw5Li4uuLu7ExkZyc6dO+nTpw/z5s2jcuXKmnw9PT2ZNWsWjo6O9O7dGwMDAy5fvsypU6coX748v/32G+PGjcPExIRu3boBkC1btmTXlZeXFyYmJrRv3x4TExNOnTrFzJkzCQ4OZsiQIcnO72NJPbcBhg8fzubNm6lYsSKNGzcmOjqac+fOcfnyZezt7ePNf/r06cybN4+xY8dqzvV3797Rtm1b/v33Xzw8PMiePTtbt27l1KlTcbZPyjlYokQJdHR0OHfuHIUKFQLg3Llz6Orqcv78eU1er1694v79+7Ru3VprH+fPn2fv3r20bNmS9OnTs2LFCnr37s2hQ4cwNTX94joWQgghxLclcYrEKRKnpM045dGjRwwYMIDmzZtTt25dFi9eTLdu3RgzZgzTp0+nRYsWAMyfP5++ffuye/dudHVj+iyfOHGCx48f07BhQ8zNzblz5w7r16/n7t27rF+/Hh0dHSDpn78PHTp0iN69e1O7dm0mTJiAnp7eZx2fEEKkCEUI8dmCgoIUlUqldO/ePdF03bp1U1QqlfL27VtFURSlf//+ipOTkxIVFaVJ8/z5c6VQoUKKp6enZlnbtm2VOnXqKOHh4ZplarVaadasmVKjRg3Nsk2bNikqlUpp0aKFVp6KoiglSpRQxowZk2j5WrdurahUKsXLy0uzLDw8XClXrpzSq1cvzbKlS5cqKpVK2bp1q2ZZRESE0qxZM8XBwUFzfPv27VNUKpUyZ84crf306tVLsbGxUR49eqRZ5uDgoAwZMiTR8sV6/PixolKplE2bNmmWDRkyRFGpVFr1piiKUr9+faVBgwaJ5hcUFKQ4OjoqTZo0Ud69e6e1Tq1Wa47PyclJqVOnjlaaQ4cOKSqVSpkxY4ZmWevWrZXWrVvH2c+QIUOUKlWqxDmO0qVLK69fv9Ys379/v6JSqZSDBw9qlo0ZM0ZRqVRx8jx79qyiUqmUbdu2aS0/cuRInOVVqlRRVCqVcuTIkTj5tG7dWnFzc4uzPCwsTOt1RESEUqdOHaVNmzaaZQ8fPlQKFSqk9OjRQ4mOjtZKH1t/iqIobm5u8dbLzJkz4z222PP58ePHCZZHURTlf//7n1KsWDGtz8fHdZ2Qj9+rpJ7bJ0+eVFQqlTJu3Lg4eX54zCqVSvO5mzRpklKoUCFl8+bNWulj9+nt7a1ZFhoaqlSvXl1RqVTKqVOnNOVI6jno5uam9OnTR/O6QYMGSu/evRWVSqXcvXtXURRF2bt3r6JSqZQbN25oldfW1lbrs3njxg1FpVIpK1asSKwqhRBCCPEdkjhF4hSJU9JmnBJbJxcuXNAsO3r0qKJSqZSiRYsq/v7+muVr167VihsSKs+OHTsUlUqlnD17VrMsqZ+/2Pdgz549iq2trTJixIg4dSqEEKlBhp8S4guEhIQAkD59+kTTxa6PTe/q6kpAQIDWo9179uxBrVZTu3ZtAF6/fs2pU6dwdXUlODiYV69e8erVKwIDAylfvjwPHz6M81hx06ZN4/SWyJQpE5cvX46T9mMmJibUq1dP89rQ0BB7e3seP36sWXbkyBHMzc2pU6eOZpmBgQEeHh6EhoZy9uxZTTo9Pb04jzh36NABRVG+ypA2sb1VYpUoUULrseD4HD9+nJCQELp06RJnDNzYHiz//PMPAQEBtGjRQitN5cqVyZcvH4cPH/7sMteuXZvMmTNrXsf2ovuwzhOye/duMmbMSLly5TTnxqtXr7C1tcXExETzeHIsKysrKlSokOSyGRsba/7/5s0b3r59S4kSJbQeb96/fz9qtZoePXpoegbFiq2/lPJheWI/DyVLliQsLIz79+9/cf5JPbf37t2Ljo5OnOGcIO4xK4rC2LFjWb58OX/++ScNGjSId5+1atXSLEuXLp2mN2Cs5JyDJUqU4Ny5c0BMPd28eZNmzZphamqqeVrj3LlzZMqUSdPTMpazs7NWD8RChQqRIUOGJJ2PQgghhPi+SJwicYrEKWk3TilQoACOjo6a18WKFQOgbNmy5MyZM87yD9+XD8sTHh7Oq1evNOk+HFoqqZ8/iHlyp1+/fjRr1oyxY8fGqVMhhEgNMvyUEF/g4yAgIR8HFRUrViRjxox4e3vj5OQExDzSXbhwYfLmzQvETOynKAozZsxgxowZ8eYbEBCAhYWF5rWVlVWcNAMHDmTo0KFUrlwZW1tbKlWqRP369eNMBpgjR444N3iZM2fm1q1bmtf+/v7kzp07zk1M7KPAT5480aTLnj07GTJkiDedv79/vMfzuYyMjOKME5w5c+Y4Y7Z+zNfXF4CCBQsmmCb2mGLflw/ly5dPa1if5Prll1+0XscGDkFBQZ/c9tGjR7x9+1Zz/nwsICBA63V850ZiDh06xN9//82NGze05nj48Bzx9fVFV1dX875+TXfu3OGvv/7i1KlTBAcHa617+/btF+ef1HPb19eX7NmzkyVLlk/muWXLFkJDQxk9erRWgP3xPj/+3H18riXnHCxZsiRr167l0aNH+Pr6oqOjg4ODAyVLluTcuXM0bdqUc+fOUbx48TjH+vH5CDHnZFLORyGEEEJ8XyROiSFxyueROCXpvkac8nH9Z8yYEYj5LHwo9jz+8H15/fo1np6eeHt7x6nrD8uT1M+fn58fgwYNolatWvzvf//7rOMRQoivQRo1hPgCGTNmxNzcXOuGOj63bt3CwsJCc9NhaGhItWrV2LdvH6NGjSIgIIALFy5oxguFmMnVIKbXUEI9Vz4e1/XjXjwQ08umZMmS7Nu3j+PHj7No0SIWLFjArFmzNGPQAml6PMzvvewJTRKXULmVDyYpTIharSZr1qxMmTIl3vUfB08f9tj5lHPnztG9e3dKlSrFqFGjMDc3x8DAgE2bNrFjx44k5/MpCfWS+ri+goKCaN26NRkyZKB3795YW1tjZGTEtWvXmDJliuaz8r0pXrw4N2/eZNWqVbi6uiapIeRLlShRAoCzZ8/y+PFjihQpgomJCSVLlmT58uWEhIRw48YNrUnCY33J+SiEEEKI74vEKd+H773sEqfEL7XjlITqPynvS9++fbl48SIdO3akcOHCmJiYoFar6dSpk1a6pH7+zM3NMTc3x8fHh6tXryY4h6AQQnxr0qghxBeqUqUK69ev59y5c/FOwnfu3Dn8/f1p1qyZ1nJXV1e8vLw4efIk9+7dQ1EUXF1dNetje0gYGBjg7Oz8RWXMnj07rVq1olWrVgQEBNCgQQPmzp2rdbOSFJaWlty6dQu1Wq3VCyr2sdrYR2EtLS05efIkwcHBWr2gYtNZWlp+0fGklNhg686dO+TOnTveNLHH9ODBgzi9jR48eKD1+G/mzJnjfSQ7thfV50johtra2pqTJ09SvHjxZAUCSbFnzx6MjIxYtGgRhoaGmuWbNm2KUwa1Ws29e/coXLhwgvkldAyxExcGBQVpTWL4cX2dOXNG0+OoVKlSmuWfemw/OZJ6bltbW3Ps2DFev379yUaK3LlzM2jQINq0aUOnTp1YunSp1ufB0tKS27dvoyiKVh09ePBAK5/knIM5c+YkZ86cnD9/nsePH2uuSSVLlmTixIns3r2b6OhorXoUQgghxI9J4hSJU2JJnBK/tBCnJMebN284efIkvXr10hou9+HDh/GmT8rnz8jIiHnz5tG2bVs6derEypUrE32CSAghvhUZCE+IL9SxY0eMjY0ZNWoUgYGBWutev37NqFGjSJcuHZ06ddJa5+zsTJYsWfD29mbXrl0ULVpU61HPrFmzUrp0adatW8fz58/j7PfVq1efLFt0dHScR16zZs1K9uzZtR7VTaqKFSvy4sULvL29NcuioqJYsWIFJiYmmhu5ihUrEh0dzapVq7S2X7p0KTo6OlSsWFGzzMTEJNWGtylfvjzp06dn3rx5hIeHa62L7cViZ2dH1qxZWbt2rVad+fj4cO/ePSpXrqxZlitXLu7fv6/13ty8eZMLFy58dhnTpUsHxH3U29XVlejoaObMmRNnm6ioqC+qUz09PXR0dLR6Ivn5+XHgwAGtdNWqVUNXV5fZs2fH6YX0YS+gdOnSxVue2GAtdoxjgNDQULZs2aKVLjYw/TDPiIgIVq9encwjS1hSz+0aNWqgKAqenp5x8oiv51qhQoWYP38+9+7do3v37rx7905rn8+fP2f37t2aZWFhYaxfv14rj+ScgxDztMapU6e4cuWK5smNwoULkz59eubPn4+xsTG2trbJqB0hhBBCpEUSp0icEkvilPfSWpySHAk9ybFs2TKt18n9/GXMmJGFCxeSNWtW2rdvrxkeTQghUpM8qSHEF8qTJw+TJk1i0KBBuLu707hxY6ysrPD392fjxo0EBgYybdq0OI9gGxgYUL16dXbu3ElYWBhDhgyJk/eoUaNo2bIl7u7uNG3alFy5cvHy5UsuXbrE06dP2bZtW6JlCwkJoVKlStSsWZNChQphYmLCiRMnuHr1KkOHDk32sTZr1ox169YxdOhQrl27hqWlJXv27OHChQv89ttvmt5OLi4ulClThunTp+Pv74+NjQ3Hjx/nwIEDtG3bVqsubG1tOXnyJEuWLCF79uxYWVlpJjL72jJkyMCwYcMYMWIEjRs3pk6dOmTKlImbN2/y7t07/vjjDwwMDBg4cCDDhg2jdevWuLm5ERAQwPLly7G0tKRdu3aa/Bo3bszSpUvp2LEjjRs3JiAggLVr11KgQIFPjmeckNgfn3///XfKly+Pnp4ebm5ulC5dmmbNmjFv3jxu3LhBuXLlMDAw4OHDh+zevZvhw4drTUCdHJUqVWLJkiV06tSJOnXqEBAQwOrVq7G2ttYawiB37tx069aNOXPm0LJlS2rUqIGhoSFXr14le/bsDBgwQHMMa9asYc6cOeTOnRszMzOcnJwoV64cOXPmZPjw4dy/fx89PT02bdqEqampVi8oR0dHMmfOzNChQ/Hw8EBHR4etW7em6LBIST23y5YtS7169VixYgWPHj2iQoUKqNVqzp8/T5kyZWjdunWcvB0cHJgzZw5dunShd+/ezJ49GwMDA5o2bcqqVasYMmQI165dw9zcnK1bt8bp0ZaccxBinsrYvn07Ojo6mkYNPT09HB0dOXbsGKVLl9bq2SaEEEKIH5PEKRKnxJI4Je3GKcmRIUMGSpUqxcKFC4mMjMTCwoLjx4/HeXLkcz5/ZmZmLFmyhBYtWtCuXTvWrFmjNW+OEEJ8a9KoIUQKcHV1JV++fMyfP5+NGzdqhqYpU6YMXbt2RaVSxbtd7dq12bBhAzo6OlqPdMcqUKAAmzZtwtPTEy8vL16/fo2ZmRlFihShR48enyyXsbExLVq04Pjx4+zduxdFUbC2ttYEIcllbGzMihUrmDJlCl5eXgQHB5M3b14mTpxIw4YNNel0dXX5+++/mTlzJt7e3mzevBlLS0sGDx5Mhw4dtPIcOnQoI0eO5K+//uLdu3c0aNDgmwULAE2aNCFr1qzMnz+fOXPmoK+vT758+bSCgIYNG2JsbMyCBQuYMmUKJiYmVKtWjUGDBmk9jpw/f37++OMPZs6cycSJEylQoACTJ09mx44dnDlz5rPKV6NGDTw8PNi5cyfbtm1DURTc3NwAGDt2LHZ2dqxdu5bp06ejp6eHpaUldevWpXjx4p9dJ05OTowfP54FCxYwYcIErKysGDhwIP7+/nHGZe7Tpw9WVlasXLmS6dOnky5dOmxsbKhXr54mTY8ePXjy5AkLFy4kJCSE0qVL4+TkhIGBAZ6enowZM4YZM2Zgbm5O27ZtyZQpE8OGDdNsb2pqyty5c/njjz/466+/yJQpE3Xr1sXJyYmOHTt+9nF+KKnnNsDEiROxsbFh48aNTJ48mYwZM2JnZ4ejo2OidfrXX3/Ru3dvBg8ezNSpU0mXLh1Lly5l3LhxrFy5EmNjY9zd3alYsWKcHpNJPQcBzfAS+fLlw9TUVGv5sWPH4h1+QgghhBA/JolTJE4BiVPScpySXFOnTmXcuHGsXr0aRVEoV64cCxYs0Jr/5nM/fxYWFixdupSWLVvSvn17Vq5cGWeOFCGE+FZ0FJkBVAghhBBCCCGEEEIIIYQQaYDMqSGEEEIIIYQQQgghhBBCiDRBGjWEEEIIIYQQQgghhBBCCJEmSKOGEEIIIYQQQgghhBBCCCHSBGnUEEIIIYQQQgghhBBCCCFEmqCf2gUQQgghhBAiORRF4dWrVxgaGqKjo/NN921gYICRkdE33acQQgghhBDi65H4Iu2RRg0hhBBCCJGmvHr1Cmdn51TZt7m5OQcOHJDAQwghhBBCiB+ExBdpjzRqxENRFEJCQkifPv03b50TQgghhBCJi4yMBGDHcgWLbN9uv8EhUKXJCyIjIyXoEMkmMYYQQgghxPdJ4ou0Rxo14hESEkKJEiWwumeLrlovtYsjhBCpwliJYgXeAHhQm3c63/dXhrGJESsezAHAI++vvAsNT+USCfFz2qfe8M32lc5EjUn6b7Y71ADIvaH4PBJjCCFE6scYEjMIkTZ9qxhD4ou04/v+hUoIIUSqykJEahchWbKYZ0rtIgghhBBCCCESkdoxhsQMQgiR9ummdgGEEEIIIYQQQgghhBBCCCGSQp7UEEIIIYQQaZJaUROtfLv9xexLHg8XQgghhBDiRyTxRdqRJp7UWLVqFS4uLtjb29OkSROuXLmSaPpdu3ZRq1Yt7O3tcXd3x8fH5xuVVAghhBBCCJEWSIwhhBBCCCFE2vTdN2p4e3szceJEevTogZeXF4UKFaJjx44EBATEm/7ChQsMGDCAxo0bs2XLFqpWrUqPHj24ffv2Ny65EEIIIYT4mtQo3/xP/BgkxhBCCCGEEB+T+CLt+O6Hn1qyZAlNmzalUaNGAIwZM4bDhw+zadMmunTpEif98uXLqVChAp06dQKgb9++nDhxgpUrVzJ27NgULZuhiSGZsqVHR0cnRfMV4ltSFIWglyFEhKatCaGFEEIIIT7X9xpjSHwhfhQSYwghhBDia/quGzUiIiK4du0aXbt21SzT1dXF2dmZixcvxrvNpUuXaNeunday8uXLs3///hQrl44OVG7vTCn3Yugb6knQIdI0RVGIiojm7PbLHF5yAkUaicV/1OhwC1PN/793arXCrbN3Nf8XQvz41KhRf9P9iR/B9xhjSHwhfjQSY4iEpHaMITGDECIxEl+kHd91o0ZgYCDR0dFkzZpVa3nWrFm5f/9+vNu8fPmSbNmyxUn/8uXLFCtX5fbOVGheGrMsZujKZC7iB6AmmgrNjQA4tPhEKpdGfC8idPToSdXULkaSRbyLoGeZYaldDCGEEN+57zHGkPhC/IgkxhDxSe0YQ2IGIYT4MXzXjRrfI6P0hpRyL4ZZFjMMMEzt4giRIvTQwyyLGaXci3F87Tl5TFwIIYQQ4huR+EL8qCTGEEIIIcTX8l03apiamqKnpxdnwr6AgIA4PaViZcuWLU6PqcTSJ1fGrOnRN9STHlTih6OLHvqGemTKlp6XvhJwCCGE+P5FKwrR33DkiG+5L/H1fG8xhsQX4kcmMYYQQoi0ROKLtEM3tQuQGENDQ2xtbTl58qRmmVqt5uTJkzg6Osa7jYODA6dOndJaduLECRwcHFKkTDo6OjLGrfhhyfktPmSkRLFC8WaF4o2REpXaxfkko3SGrLg/mxX3Z2OUTnq6CiGEiN/3FmPI/Zf40ck5Lj6U2jGGxAxCCPFj+K6f1ABo3749Q4YMwc7OjqJFi7Js2TLCwsJo2LAhAIMHD8bCwoIBAwYA0KZNGzw8PFi8eDGVKlXC29ubf/75h7Fjx6bmYQghRJqjA+QgVPP/752Ojg458mTX/F8I8eNTo8hEfuKzSIwhhBCpI7VjDIkZhBCJkfgi7fiun9QAqF27NkOGDGHmzJnUq1ePGzdusHDhQs2j3v/++y8vXrzQpC9evDhTpkxh3bp11KtXjz179jB79mxUKlVqHYJIgqvXr+DeqjbBIcGpXZRvbtjvQ1iwYl6iadxb1ebkuaRPrvcz16cQQgghxKdIjPFz+JnviSXGEEIIIcSP7Lt/UgOgdevWtG7dOt51K1asiLPM1dUVV1fXr12sNOdFwAtWb1rJhcvnCXobhGkWU8qWdKJ5g5ZkypgptYv3TazetJJT504xc6Jnoummz51GSGgwI/qP/EYlS9zy2SvJkD5jahdDCCGE+K6oUYj+pvsTPxKJMVKGxBgSYwghhBA/Cokv0o7v/kkNkTKePv+X/iP68OTpEwb2HMK8aQv5tUNPLl+7zKDR/Xkb/Par7j8q6vsfj/97ZprFDAMDg9QuhhBpTq0OLkzaPULzetDiHozePCjF8v+c/DxGNWHuhT9TrAwpIaXr5UexT70B53qlUjzfKQdH0316uxTPVwghvjWJMdI2iTGE+DwfxxipoUbbyni9Wprg+qKVirBPvYH0mU1StRw/q691v/89xpJCpJY08aRGWqETFprwSl09FCOjpKXV0UUxNk40rZIueV9Mfy+Zg76+PmOH/o6RYUw5smfLTv48+encvyMr1i/j1w49Wb5uKZevXWLq2L+0tu81rAfOpcrRomFLAPYc2s0Wby+evXhK9mwWuNesi1v1OgA8e/GMTn3bM7jnEHbu38nte7f4tX1PihYpytxlf3P91nWioiPJns2CDi07UtLh/Q9G9x7cZenaxfj6PyZf7nz06dIPq5xWmvXe+3fitXMTLwNeYpHdgqb1muNSoapm/fOXz5m/bC6Xr11CR0eH4sVK0LVtd0wzm7LfZx9rNq8GYh61BujTpR/VKlXXOtbVm1Zy8Oh+rXQThk/CvkhRHvo+YMGKedy8cxMjIyOcS5WjY+vOpDNOB8RMMrluy1r2HNzFm7dvyJXTmrbN21GiWMlE3x+1WmHJ6kXsPbwHfX0DXKu60rLR+56D7q1q81u/ETiVdAbgxu3r/L1kDn7/Pia3VW6a1m/OhOm/M2P8LPLlyZ/k+hTiR2ZgZEC7sc0Y13RaahdFCCGE+CzfMr4AiTEkxpAYQ4hPSSsxxvUTt2n6S2dC3iTy3SCEEGmYNGqkoIIViya4LrhcZZ78tVDzOn+NMui+C4s3bWjx0vjNW615nbduJfRfB2qluX32bpLL9Tb4LRevXsCjSRtNsBHLNIsZlZ2rcPTUEbq370GlclXYsG09/z77l18sfgHgkd8jHvo+YFif4QAcPn6I1RtX0rVdd/Llzs/9R/fwXDgTYyNjqlaspsl76bqldGzViXy582NoYMishTOIiopi0v/+wNjYGF8/X4yNjLXKs2L9Mjq06kzmjJmZs3gWM+dPZ/LoqQCcPHuCBcvn0cmjCw52Dpy9eIYZ86eTzSwbRW2LoVarGT9tLMbG6Zj4vz+Ijo5m7tI5TJ41iYkj/qCCU0Ue+T3iwpXz/D5sPAAmJunj1FcDt0Y89n9MaFgofbv2AyBDhoy8e/eOUX/8D5uChZg27i9eB71m1oKZzF36N/269Qdg256tbPHeTI+OvciXOz/7ffby+9SxzJ78NzlzWCb4Hh08up/6rg2YOnY6N+/c5K950yisKoKjffE4aUNDQxk3dQwlipVkYI/BPH/5jIUr58ebb2L1KcSPrmLjsoQEhXHtxK3ULor4Segb6BMVKb2GvyWZyE/86L5lfAESY0iMITGGEAmJvc9LKzFGVGQUgc9ep3YxRBJJHPH9kPgi7ZBGjZ/Ak6f+KIqClWWueNdbWeYiOCSYN0FvyG2Vm7zW+fA5cYjmDWJ6TPkcP4RNfhty5sgJxPQy6tCqE86lygGQI3sOHvv5svvgLq2Ao16tepo0AC8DXuBcqhx5rPP+t90vccri0bQt9oXtAWhctylj/hxFREQEhoaGeO3cRNWK1TS9tSx/seLm3Zt4eW+mqG0xLl+7xMPHD1n41xLMs5oD0K/bQHoM6cbte7dR5VeRztgYPV09TLOYJVhf6YzTYWhoRGRUpFa6g0cOEBEZQf9uAzE2NiY30K1dd8ZNGUO7Fu0xzWyK187NNHJvQkWnSgC0a9GBK9evsHXXFrq375HgPvNY56VFo1YA5MxhyY6927l87XK8AYfPiUOADr069cHQ0BBrK2sCAgPwXDgzWfUpxKcowEMyaf6fGqYcHM3Da48BqNa6IlGRUWyfu5dlI9dp0qy4P5vdiw9iXcgSdbSa0KAwFEWhcrNynNpxPtH8DQz16fynB5WblSN9pnTcPnefv/sv5fa5e5o0uYtY0WlSa+wrFkZHR4d7lx7yZ/vZ/Hv/WZz8VCXzM37nb2ycuo11k7cC0GxIfRr1dcPIxAifDSd58yJIaxsdHR1ajWhE7c7VyGyeicc3/Fk4bBXn9lwC4H/rBxD47DWevRYB0H16Oxr2caND4T48vvUEfQN9Nr9awqj6k7l44CpTDo7m/tVHRLyLxLVjVaIiotgxby8rxmz4ZH03HuBO4/7uGBjqc3jdceb0XUp0VLSm/hv0ro2VTU7ehYRz6eA//N1vCa//O54MWdLTc1ZHStQoRroMxrz0C2DNxM3sWXo43n3p6OjQZKA7tTtXxzxXVl4/e8PO+ftYPWEzAJ0mtaJc/dJks8pK4NPXHFh9lJVjN2rKM2hxD9JnMWF0w/ePX3ef3o78xfIw0GU0ABUalcVjZBNyFshBeGg4dy8+YFT9ybwLDUdVMj8dxrekgGMe9A30uXfpIX/3X8rdiw8+WU+xYs/P6KhoqraqwIOrvgyqOoaiFYvQebIH+Yrl5u2rYPYt92HJiDWoo+O/ZTUw1Kf9+BZUaV6e9FlMePjPYxYOXckVn+tJLosQQnxrEmNIjBFffQrxKakdYyiKwruQd0S8i6TrlDZUaVE+0RjDssAvONcvxfHNZ/izw+x4Y4zY+9JbZ+/SoHdtDIwM2DR9B6snbKbjxFbU6uBCeGg4y0au1bo3/tT9br6iuek+vR2qkvlRFAX/O0+Z0W0et8/fj3NcmbNlYoL3bzx/HMCEFtMp7KRi6qEx1DdtS8ibUGq0rUz36e0Y33w63ae3wzxXNv45dpMpHWbz6ulrAHT1dOk2rS3VPSqhjlaza9EBTC2ykD6z9j13fErWKJZgvkm57/YY1YRa7V3IYpGZtwFvObLpFHP6LElwf2XrlKD1/xqT196asOB3XD16kzGNYsr4qbglti4amLXT5OdcrxRjvAZTXbfJJ+s+o1kGes3qiH3FImQwTc+/956xZuJmDq09nmgdfchjVBPK1SvN1tm7aPFbIyxyZ6OmfjPMc2Wj58wOOFa1R61Wc273JTx7L+b18zcJ5uXa0YXG/d3JkTc7Tx++YMssb7b/vTfJZREirZJGjRR058iVhFfq6mm9vLf3dMJpdbSnOnmwzedLivVeEu8YKperzD6ffTRv0BJFUfA56UN91wYAvHv3jn+f/cvMBTO0bnCj1dGkT6fdI6lA3oJar+vUrMvfS2Zz8eoFitk54ly6HHn/Cz5i5fngdezN/uug12TPlp3HTx5T00V7csYiqiJs270NgMf+j8mW1VwTbABYW1mT3iQDfk8eo8qvSloFJODxE1/yWufD+INH9wuriqBW1Pg/8cPIwIhXgQEUVhXR2q6wqggPfePedHwoT648Wq/NspjxJuh1vGn9/vUnr3UeraBBld8m/nwTqU8hPiVcR5/O1EjtYlC9TSV2Lz5IzzLDUJXMR995XXnu+5JdCw9o0jQZUJeV4zaw9L9AJDwsArvyhdi/8kiieXee7EGFhmX5s50nzx69pNmgekzcPYJ2BXvxNjCYrDnNmOYzlsuHrzG46hhCgsKwK2eDnr5enLwcqtgxatNAFgxZifeCmOElKjZxos2oJszquYh/jt2kmkdF6vdy5en955rtGvSpTeP+7vzVbR53Lz6kVocqjN06hM52/fC/+5QrR67h1uX9EBZFKxbh9YsgilW25fGtJ9iUyo++gT7XP+gtVqNNZTZO307vssMo7KRi0JIeXDt+iwv7E/6ecqhix6unrxnkMpqcBXIwfG0/7l56qKlnPQM9lo5cy+NbTzDNnpmuU9syaEkPhteZCEC7cc3JXcSK4bXH8+blW3IWyIFRuoR/3Og4sSWunaoxt/9S/jl2E7NfTLEulFOzPvRtGH+2n03Ak0Dy2lvTb343wt6Gsf7PbYm+p7HMcmTht9V9WDBkJce9zpAuYzrsKxQCHR0ATDKmY9/yw8zufQ8dHR0aD3Bn/M7faKfqRVjwuyTtA2LOz+1z99K3/P8AyJrTjN93DmPfssNMbjuLXIUs6Te/GxHvIhJsWOrp2ZHcha0Y32I6AU8CKdegNBN3DadL0QH4332a5LL8jNSKQvQ3/EXkW+5LCEgD8QVIjCExBiAxhki61I4xwsMiuHX2HgVL5CMiPDJJMcaKse/v4RKKMRxc7Hjp/4r+lUZhW86GgYt+pYiTDVePXqd32WFUauZMn7ldOb/vCi/9XwGfvt8durI39y4+ZOavC1BHq8nvkIeoyLhTGJtbZWXS3v9x89Qdpnb6G7U6/o40RiZGNB5Qlz/azEKtVhi6ojdd/mzDJI+Y627zIfWp2rICUzrMwfeGHw36uFGufmkuHfon0Tr9VL6fuu+u0KgsjfrWYXyL6Ty85odZjizkK5Y7wf2Vrl2c0ZsHsXrCZia39UTfUJ/StR016z8VtyRFYnVvaGzI7Qv3WTd5KyFBoZRxK86Q5b14cu8Zt5LxxGPOAjko37AsYxr9iTpajY6ODmO3DCYs+B0DKo9CT1+XXp6dGLG2n6bT1sdcWpan7ZhmePZaxN2LDyngmId+87vxLiScfctT8Lv+JyLxRdohjRopKDlj0H6ttPH5xSInOjo6PH7yGKd41vv5PyZD+gxkzpQZgIpOlVm6dgl3H9wlIiKclwEvqFC2IgBh4TGPtPfq1DvOTa6urnaw9PFj3zWr1KJ40RKcu3iGi1cvsnHbejq06oR7zbqaNHp674Mznf/+VZQf/xOur//RR1EnZgzcL/Wz1qf4sbx4HMDf/ZYC4Hf7CXntc9Oobx2tgOPiwX/YOG2H5nX6zCZkyJKegCevEszX2MSIOt1q8Gf72ZzdfQmAaV3msrL6HGp1dGHDlG3U61GTkDehjG/xl6bHlP+df+PkVa5+aQYv68m0znPxWX9Cs7xhHzd2Lz7I7sUHAVj6v7UUr2qPofH7HwyaDKjLuslbOLwuZruFQ1dRrLIdDfu6MavnIi4fvs6vf7Unc7ZMREdFY13EilW/b6RoJVt2zNtHscq23D57l/CwCE2e9688YuXYjTHlvfuUej1ccaxqn2ijxtvAYDx7LkKtVvP41hPO7LyAo4u9pp73LDmkSfv0wXPm9FnM7LN/YJzemHch78ieKxt3Lz3Q9Bx79uhFgvtKl8GYBr1r49lrkeZm+9/7z7h2/KYmzerxmzX/f/boBRumbqNKs3JJb9T4xRR9A32ObT7Nc9+XADz8x1ez/uPgbHqXeXgFLqVopSKc3nkhSfuAmPNh4ZCVmtftf2/Bi8cBzOoZ82TN41tPyJrTlE6TWrNy7MY412DzXNmo2a4KrXJ3J+DfmKFgNk7dTqmaDtRsX4XFw9ckuSxCiB/P9xpfgMQYaYHEGEIkLKVjjLevgpndezGKouB3+wlNB9XDyMSQNRO9AFg7cQvNhzTArnwhzX3/p+53s1tnY8OUbTy+9QQg3s4uVqqc/LH3fxzfcoY5fRN+sgFing6e0X2+5onzrbN30fp/TTTr6/V0Zc0kL45vOQOAZ89FlHZ1jDev5OT7qfvu7NbZePX0NRf2XyU6KpoXj18m2jjQ8reGHFp7nOWj12uW3b/ySPP/T8UtSZFY3Qc8ecXGqds1r7d67qZkDQcqNXVKVqOGvqE+k9t68uZlzBMkxasVJa+9NR75evDCLwCAP9p6sujadFQl82uNJhCrzehmzBu4nGNeMe/Z04fPsS5ihVuX6tKoIX540qjxE8iUMRMOdo5479tBPdf6WmPeBr5+xeETh3ApXxWd/3qvZsuaDbtC9vgcP0R4ZAQOdo5kyZwFANPMppiZZuXp83+pXK5KsstintUc12puuFZzY9naJew9tFsr4EhMrpy5uHH7utbj59dvXyfXf4+857LMxcuAF7wIeKHpSeXr50tIaLAmjb6+AWp13J4NHzPQ14/TuyFXTmsOHNnPu3fvND2pbty+jq6OLpY5rTAxMcHMNCs3bl/XPI4dm+ZLe3B9yOoXSw4fP0hkZCQGBgYA3Ll/O8XyF+J7c+O09vl9/eQtGvevg66uruZzeue89g1e7BMCEe8iE8z3l/wWGBjqa/2QHh0Vzc0zd7EuHDM+df5iebh69IamQSM+hcoUpGydEoxtMpUTW89qrbMubMmOedqP/l4/dRuHynZATK+lbJZmXDuuPSbvtRM3yVc0DxDzQ/zbV8EUrVSEqIgo7l18wOkdF6j7ay0g5smNyx8NU/Tg6iOt16/+DSRL9kwJHgPAo2t+Wte9V09fk8fOWvO6YPF8eIxqQv5iechgmh4d3ZjvjOzW2fC94cf2uXsYuXEgBR3zcW7fZU5sOcP1k/Ffm6wLW2FobMjFAwn3+qrU1JkGvVz5JX8O0mUwRk9fl5Cg+MeKj8/9y4+4sP8K869M5fyey5zbd5mjG08R/DoEgCzZM9P+9+YUq2RLluyZ0dXTxcjEkOzW2ZK8D4A7F7R7yVoXsuTGR8d97fitmPfaKisvHr/UWpfX3ho9fT2W3NIe3sPASJ+ggOBkleVnpObbjkMrY94K8Z7EGBJjCJGWpXSM8eian1bj3utnb3h47X2HGrVaTVDAW7Jkz6xZ9qn73U3Td9B/QTeqta7IhQNXObLhpNYQuIbpDJl2ZCyH1hzTNNAkJizkndb2r/59rYkRTDKZYJYjC7fOvP9RXq1Wc+f8fc19/+fkC5++7z6y4SQN+7ix/J4n5/Zc4oz3RU5uP5fg0K35HfKwa+H+BMvzqbglKRKre11dXVr81oBKTZzJammGgaE+Bkb6hIeGJynvWM8fvdA0aEBM7Pj8cYCmQQPA94YfbwODsS5sGadRw9jECMsCOei/sDv95nfTLNfT15UJ4r+AxBdph+6nk4gfQbd23YmMimTUpBH8c+MqLwJecP7yOf43cThZTbPi0bStVvpK5Spz5NQRjp8+GiewaNmoFRu2bWDb7q34/+vHQ98H7PfZyxbvzSRmwYp5XLhynqfPn3L3wV2uXr+CVc74x+CNT4M6jThwZD/e+3fy5Kk/W7w3c/LsCRq6NQLAwc6RPLnyMHX2ZO4+uMvte7eYPncKdoXtKZgv5oY/e7bsPHvxjPsP7/Hm7RsiI+P/wTO7uQUPfR/g98SPN2/fEBUVRaVylTE0MGT63Kk8evyQK9cuM2/Z31Qu74JpZlMAGro1YtP2DRw96YPfEz+Wrl3Cg0f3qVurXpKP81MqOVdBURQ8F83ksb8vF66cx2tnTN3HBo1CpAQjJYoFyl4WKHsxUr7vScvCQt5hlM6QBVenseDqNMJDw1Gr1WQ0jTtRZ3J8+PRDQv699wzfm/7Uau8S77BUKeHqkRsUq2xL0UoxDRj3rzzCwMiAPLa5KOJswxWfa1rpP34sXVEUdHUS/8r/eGI6RVHQ/S8AMDYxYuLu4YQGhTGx9Qx6lh7KmP/G1TUwjOkfcXb3JVrn+ZVNf+0g6y+mTN4/ii5/esS7r0/Va+GyKoat7M2ZXRf5n/tEuhePebw8dl8AakUd55qnb/C+/tVqNUNqjGN47Qk8uuFH/Z6uLL45gxx5YobGGLy0J/mL5WFO3yX0KTecbo6DCAoIRt8wef093oUkL3j5WLoMxkRHRfNrySF0cxyk+etYpN8ne9sJIURqkxhDYgwhkiu1YwyjdIbYlMpPufqlEx0qFWJijA8FBQQnGGPEdy8d3z157A/sSbnfXTFmA53s+nPa+wKOVexYeG065eqX1qyPDI/k4v6rlHErQdacCc/pEys6vhhB98t/FvxUvp+6737hF0D7Qn2Y1WMh4WER9JrdiWk+YxOMrSISiSWSEreo1YnHEZB43TcZVJcGvWuzbvIWBrmMppvjIM7tufzN4wjjDDEN4dO7zNWKIzrbD6C30/AvyluItECe1PhJ5MxhyfRxM1i1aRV/zJpEcPBbsmQxpWwJJ1o0bEnGDBm10pcrXZ55y/5GV1eXsiW1HyivWaUWRoZGeO3cxJI1izA2MiZ3rjzUq1U/0TKo1WrmLp3Dy1cvMUlnQvGiJejUukuSj8GppDOd23TFa+cmFiyfh0V2C/p06Yd9kaJAzM328P4jmb9sLsPGDUZHR4fixUrQtW13reM6efYEv40fRkhoMH269KNapepx9lWzSi2uXr9C///1IexdGBOGT8K+SFHGDBnHghXz6P+/vhgZGeFcqhwdW3fWbOdesy6hoSEsWrWQN0FvyGVpzYgBI8mZwzLJx/kpJiYm/G/AKOYsmU3v33qSJ1cemjdowZTZkzEwkMn5RMrRAfIQpPl/ailUWnvs7MJlVfjfeRqnp6OOjg55bGN+xIiOUvPouh/WRaw4vy/+IZf+vfeMiPBIbMsV4rnvMQD09PWwKZWfzTN2AnD/6iNqtKmMnr5egk9rvHkZxJhGfzLl0BhGrOvP782madL63vCncJmC7F/xftzdwmXe96oMfRvGS/9X2Jaz4cqR909b2DoX0np0+cqR67h2qkpkeBRLRqxBURSuHrlOk4F1MTDSj/OkR0rLVciSzNkysWjYKk3PIVXJ/HHSvXkZxL7lPuxb7sM/x27QebIH8wetiJPO/86/vAsNx7GqHbsWHYyz3tZZxbNHLzSThgNY5DbXSvPmRRB5bK21luUvFnec4WsnbnHtxC1Wjt3IyodzKNegNJum78C2nA2zeizkzK6LQMxYxFnME3+aJSl8b/pTvmEZ7eMpZ0NIUCgvP+h1FevuxQfo6euRJXsm/jl2M856IYT4nkmM8f64JMYQImlSO8bQ0dHBOL0xxum1G+wSijE+FBUZ9ckYI6mScr8LMffNm//ayea/dvLbqj7UbFdFMzyUolb4o80shq3qw5SDoxhYZbRmONPkCg0K5dXT19iUys/VozeAmCcSChTPy71LDz8rz1hJue+OeBfBqR3nObXjPNtm72HJzRnktbfWmkw81v0rj3BwsdeadD1WUuKWNy+CSJfRGGMTI97993RFfoe8cfJKqO5tnW04se0cB1YdBWLOIyvVLzy6nrSnQBLie8Of7LmyYm6VVVN268JWZDTNgG88eb9+/oaX/q/4JZ8FB1cf+6J9C5EWSaPGTyS7uQX9uvVPUtoM6TOweenWBNdXLlclwUfDLcwt2L7KO87yD2/8P2ZfpGicbfLlyR9nWe1qbtSu5pZgPtmzZWfEgJEJrjcwMGBY30+3WGfOlJlxw8bHWZ7HOi/jh09KcDtdXV1aNGpFi0atPrmPWBNH/BFn2Yj+2sfwcT0UVhVh1sTZmteHjx9CX08f82wxN0FJrU8h0oLs1tnoOrUtO+fto2DxvNTv6cq8gcs+ud35vZexK1cYrxnxn/fvQsPZMXcvXSZ78PZVMM99YyYKNzIxYvd/P7Rv9dxN/Z6uDF/Tl7WTvAh5E0rhsipunrmL3+0nmrxevwhiUNUxTDk4it9W92V8i+moo9V4zfRm0JIe3D53j3+O36JqqwrktrXSmih8/ZSttB3djCf3nnHv0kNqtq9Cfoc8TGo9Q5Pm8uFrdJvWlqiIKM0P35d9rtH1zzbcOntPczP+tTz3fUlEeCT1ermyY+5e8tpZ02pEY600bcc04/b5ezy65oeBkT5l3Erge8M/3vwiwyNZN3kLnf7wIDIiimvHb5HFPBO5bXOxe/FB/O88Jbt1Nio3c+bW2XuUcSuu1SsN4NLBf2gysC7VPCpy4+RtqrauSB6794FPodIFcKxqz/m9lwl8HkThMgXIbJ5J88i5/51/qda6IrfP3cMkUzo6T/ZIkXrcNmcPDfrUpuesjmz13IWVTU7ajG7Gpuk74h1v3P/Ov+xfeYTBy3oxf+Ay7l58SGbzTDhWteP+FV/OeCd9fo+fUTQKnx7wJSX3J4T4mMQYEmNIjCHSqo4TW7F19u4UjTGS6lP3u4bGhnT504MjG0/y9MFzzK2yoipVgGObT2nlo1armdh6BsNX92XygZiGjcBnrz+rTFs9d9F8aAP87z7l8c0n1O/lSkbTDHzplDmfuu+u0bYyunq63Dx9h3eh4VRtXYF3oeEJztG3YuwGJu8fxb/3n3F47XF09fUoU9uRdZO3JiluuXn6LuGhEXSY0BKvmd4UKlOQGm0ra9Z/qu797z6lYqOyFHFSERwYQqP+dTC1yPLFjRoX9l/hwVVfhq7szd/9lqKnr0fv2Z24fPiaZt7Cjy0fvY5fZ3Qg5E0oZ3dfwsDIAJuS+chgmoFN03fEu41InMQXaYc0agiRBh08egCL7DnIapqVB773WbpmMeXLVtAay1iIH8X+FT4YpTPE8/REov9rKNg5P+ExVGPtWnSQ2WcnYZLJhNCg+McUXTh0FTq6OgxZ3guTjMbcPnefYbV+18y78PZVMIOqjqHLZA+mHB6DOlrNvUsP+ed43B71gc9exzRsHBrDsJV9mNhqBj7rT5AzvwWd/vDA0NiAY5tOs2PuXkrWcNBst2XmLtJnNqHrlDZkyZ4Z3+t+jKz3h9ZkdA+u+hL8OhT/2080k9tdOXwdPX09Ln809NTX8OZlEFPaz6b9+JY06OXKnQsPmD9oOeO2DdWkiYyIpOOEVljkMSciLIKrR28wocVfCea5atwm1FFq2o5pRtacZrz6N1Az/8jJ7efY9NdOes7qiIGRAad3XmDl7xtpM6qpZvtzey+z6vdNdP6vbncvOcS+FT7k/W8ekNCgMOwrFKFBHzfSZ0rHs0cvmT9wuWZS+Kmd/qbfvK7MOT+ZF49fsnj4mgSHy0qOgCevGOE2kc6TPZh7aQpvXwWze/FBVv2+KcFtpnSYQ6sRjegypS3ZLM0IehnEjVN3OLVDGjSEEEJ8OxJjiJ+NYTqDrxJjJMWn7nfV0WoymWVgyLJeZLHITNDLtxzzOs2yUevj5KWOVjO+5V+MWNuPPw+MYmCVUZ9VprV/bME0RxaGLOtFdLQa7wX7ObfnUoJzWyTVp+67g1+H0HxIfbpNbYuuni4Prvoysu4k3r6Kf365Kz7X+b3pVFqNaEyzIfUJDQrj6n9PvSclbnkbGMwkj5l0meyBa6eqXDxwleVj1tP/v3kpPlX3q3/fxC95szNx9wjCQ8PZuWA/x7ecIX1mky+qJ4CR9SfTc2YHpvmMRa1Wc273JTx7L04w/a5FB3kXGkHTgXVjGotCwnl41Vcz8oAQPzIdJb5ugz+54OBgSpQogdU9W3TV2uPqmec2o8vfrbDIlgM9vs7Y6UJ8yqbtG/Dev5PAN4GYZjGjbAknPJq2wdjI+LPzjCaaZy+fMr/7Kl48epWCpRVplbESxXa2AOBOfd7pfPt28CkHR3Pv8sMkTXxnbGLE9uCVALhnaM270HD+t64/dy7eZ+2kLV+3oEIIjX3qDV99H0+fPqVSpUqsXBuEedyRGr6akBBoWDcT58+fJ0OGDN9ux+KHkFCMIfGF+F5IjCG+hdSOMeKLGZLrZ4kxdHR0WHT9L3w2nGDZyHWpXRzxk/vaMYbEF2mPPKkhRBrUyL0JjdybpHYxhPjuzR+8grLuJVK7GEIIIYQQ3z2JMYRImh81xshunY0SNYpxxec6BkYG1OtZixx5s3NI5msQQnyHpFFDCCHED+vZoxds9dyd2sUQQnwl6v/+vuX+hBBCCPFz+1FjDEWtULNtZbr+2QZ04OE/jxlSfSy+N+OfJ0+IH5HEF2mHNGoIIYSIlwI8xUTz/9Qw0GV0ktMqisLTh881/xdCCCGEEEJ8X1I7xpCYIWEv/ALoW+F/qV0MIYRIEmnUEEIIEa9wHX08qJ3axUiy8LAIPPL1SO1iCCGEEEIIIRKQ2jGGxAxCCPFj0E3tAgghhBBp1T71BpzrlUpwfdFKRdin3kD6zCZJztNjVBPmXvgzJYqX6j7n+FOKvoE+K+7PRlUi3zfft/h21OgQ/Q3/1Oik9iELIYQQ4gcnMUbiJMYQX5PEF2mHNGoIIYQQX8n1E7dp+ktnQt6EpnZRfmjxBWlRkVFsnLqdTpNaf1aeFRuXZdH1v9gZuor5l6dS2tUxydvaOtuwO2JtooFjsyH12afeQPfp7bSWTzk4mn3qDVp/ff7urJXGPFc2ft8+jO3BK1n/dCGdJ3ugqye3dEIIIYQQPwOJMb6N7yXGKFqpCHPO/cHOsNUsvT2LGm0rx0lT99earLg/m52hq5h5cgI2pQporTcwMqCXZ0c2vVjMtqAVjNwwgCzZM2ulkRgjbVm1ahUuLi7Y29vTpEkTrly5kmj6Xbt2UatWLezt7XF3d8fHx0dr/axZs6hVqxYODg6UKlWKdu3acfnyZa00Li4u2NjYaP3Nnz8/xY8tqeTsFEIIES9DJRpP5QCeygEMlejULs4nGRob4nl6Ip6nJ2JobJiieevp633WdlGRUQQ+e52iZfmefG69fCsHVh3FtnwhchexStZ2RZxU/La6L7sXH6R78cEc33qG0V6DyWOb65Pbps9swuBlPbl44GqCaVQl8+PWpTr3Lj+Md/3OBftp+ktnzd+CwSs163R1dRm/Yxj6hvr0LTeCP9t5UqNtZdqNbZasY/xRqJVv/yeEEEKIz5faMcbXjBmSS2KM+EmM8V6OPNn5fccwLh++RnfHQXjN2En/Bd0oWaOYJk2lps50ndqWlWM30L3EEO5fecTE3cPJYp5Jk6b79HaUrVOScU2nMaDyKLLmNGP0poGa9RJjvJcW4gtvb28mTpxIjx498PLyolChQnTs2JGAgIB401+4cIEBAwbQuHFjtmzZQtWqVenRowe3b9/WpMmTJw8jR45k+/btrF69GktLSzp06MCrV6+08urduzfHjh3T/LVu/XkNfClBGjWESCb3VrU5ee5EahdDiK9OFwUbArEhEN1Umyo8rvINy7Dg6jR2hq1mxf3ZNO5fBwBdXR1sShXAplQBdHW1H+Gce/FPWv+vsea1a0cXFl2bzs7QVSy6/hfu3Wto1lnkNmefegOVmjoz9dAYdoauomqrCgmWJ3O2jIzaNIjtwStZemsmTu4lNeviezTatVNVVj36m+3BKxm1aRCN+tXB69XSOPlWa12RFfdnsyVwGb+t7ku6DMafVS8AHca3YObJCXG2SYl6yW6djbFbh7A5YAnb3q5gwdVpcXocqUrkY/aZSWwPXslfx37HSpVTa32dbjVYdmcW3u/WsPjGDKq1rqi13jxXNsZ4DWZb0Aq2vF7GiLX9ND2LarStTJtRTcnvkEfzZENs76Xg1yFcO36Lys3LJVp3H2vQ242zuy+xYco2fG/6s2zkOu5euE+9nrU+uW2fv7twcM0xrp+6He964/TGDFvZm+ld5hIcGBJvmvDQcAKfvdb8hb4N06wrUaMo1kWsmOQxk3uXH3J29yWWjVxL3V9roW8gU6V9j1K6F9XevXvp0KEDZcqUwcbGhhs3biSYl6IodOrUCRsbG/bv358ixyOE+DokxhA/i9SOMRKKGVLrXjohEmNIjBFzDNV5+uA58wYux/emP1tn7+bIxlM07Pv+fWjUrw67Fh5gz9LD+N7wY0a3+YSHRlCzgwsAJplMqNXBhbkDlnHp0D/cuXCfKR1mY1uuEIXLFAQkxkhrlixZQtOmTWnUqBEFChRgzJgxGBsbs2nTpnjTL1++nAoVKtCpUyfy589P3759KVKkCCtXvu885+7ujrOzM7ly5aJgwYIMGzaM4OBgbt26pZVX+vTpMTc31/yZmHz7YeBiSaPGT2L63Gm4t6rN7EWz4qz7e8ls3FvVZvrcaalQsrjCI8JZtXElXQd0okHburTs2pxJMybwyO9Rahftm7l6/QrurWoTHBKc2kUR4rtSsHg+Rqzrz+F1x+lSdAArxmyg7djmcR7BzZE3u+b/uYtYkb9YHg6uPgaAS8vytB3TjCUj1tCxSD+WDF9Nu7HNqd6mklYeHSe2wmvmTjoW6ce5PZcSLFPrkU04suEEXYsN5Myuiwxd2ZuMphniTWvrbEOfv7vgNdObbo6DuLD/Mi1/axgn3S/5LXCuV4r/uU9ihPtEilYqQvOhDT67Xg6sOkrhMgX5JZ9FitdLL89OGBoZ0L/SKLoUHcDCoSsJC36ntU3731swb+ByepQaSnRUNAMXddesK1e/NL/+1Z6N07bT2b4/O+fvY+DiXylW2RYAHR0dxm4ZTEazDAyoPIqhNcbxSz4LRqztB8DhdSfYMHUbD/7x1TzZcHjd+x+Fbp29i335wprXsUGgRW7zBOuziJOKCwe0f3g+t/cyhcuqEtwGoGa7yvySz4IVYzYkmKaXZ0dOe19I9EkOl5YV2Ph8EfOvTKXDhJYYpXvfi7CIkw0Pr/ry+vmb92Xbc5n0mU3IbZu83mI/gm853m3sX3J8jV5UoaGhFC9enIEDB8abx4eWLVuGjo6M0yu+Hokx0haJMYSIX2reSydEYgyJMQAKl1XFiRvO771EEaeYbfQN9FGVyMeF/e/zVRSFC/uvUOS/fFUl8mFgqK+V5vGtJzx79ILC/+UjMcZ7qRVfBAcHa/1FRETEW76IiAiuXbuGs7OzZpmuri7Ozs5cvHgx3m0uXbqEk5OT1rLy5ctz6dKlBPexbt06MmbMiI2Njda6BQsWUKZMGerXr8/ChQuJiopKatWmOGlu+4lky2rO0VNH6OTRBSNDIyDmRPU54YN51oQvvN9SZGQk/5vwGy8CXtChVSds8tvwOug1G7atZ+DIfowbNoFCBQt9vf1HRWKgb/DV8hdCfJlG/epw6cBVVv0e0wPB/86/WBexosnAuhzZcFKTrlJTZx6OWgdA1VYVuHHqNk/uPQWgzehmzBu4nGNeZwB4+vA51kWscOtSnX3L3/eI9pqxU5MmMXuXHebQ2uMALP5tNQ1618amdIF4g5R6PV05u+siG6du15S/iJMNZeuU0Eqno6vDn+1na27c9688gqOLHUs+o172LjvMo+t+3Lv0EJeW5TVpUqpesltn4+jmUzz8xzdmuwfP45RvyYg1XDlyHYB1f2xh/M7fMDAyIDI8kiYD3Nm77DDb/94LwKbpOyhcpiBNBtTl8uFrOFa1J6+9NR75evDCL+aH4D/aerLo2nRUJfNz+9w9woLfoY5Sx/sYfsCTV2T/ILgID43A96Y/UZEJD3dgmiMLr5+90VoW+Ow1ZjmyJLiNZYEcdJzYin4VR6KOVsebpnIzZwoWz0eP0kMTzOfgmmM8f/SCl08CyVfUmk6TWpNLlZMxjadoyvbxcca+NsuRhXsJ5ixSw4e9qADGjBnD4cOH2bRpE126dImT/sNeVAB9+/blxIkTrFy5krFjxwJQv359APz8/BLd940bN1i8eDGbNm2ifPnyKXhUQmiTGCMJ+5cYQ4jvWmreSydEYgyJMSDm/j7uvf8b0mc2wdDYkIym6dHT1yPw43yfvyFXIUvNfiPCI+PMwRL47I1m3xJjpL5KlbQb+nr27EmvXr3ipAsMDCQ6OpqsWbNqLc+aNSv379+PN++XL1+SLVu2OOlfvnyptezQoUP079+fsLAwzM3NWbx4MWZmZpr1Hh4eFClShMyZM3Px4kWmTZvGixcvGDZsWLKONaV8140a8+bNY+/evdy/fx9jY2McHR0ZOHAg+fLlS3CbzZs3x6lMQ0NDrl5NuEdkStHRTaQnnBLTWppSaZXPGHQtf578PH32LyfPnqByuSoAnDh7HPNs5liYW2ilVavVbNq+gd2HdvP6dSA5f7Gkef0WlCsTExRHq6OZvXAWl69f5vXrQMyzmVO7mht1a9XX5DF97jRCQoMpYmPLFu/NREVFUaFsRTp7dEVfP/5Tb+vuLdy8e5MZ42eRN3fM+5zd3IJhfYYzYFQ/Zi74i9l//M3Fqxf5fdoYls9eRYb073srzF8+l0ePHzJ++CQArt26xvJ1S7l7/w6ZMmaibEln2jZrh7FxzCOWHfu0o3rlGjx5+oRT507iVKocPTv1YtHKBZw4e5zgkGCyZMqCa9XaNKn3fizBoLdBjJ8+jgtXLpDVNCsdW3WiTImymvVXb1xlyepFPPC9T8YMGXGpUA2PJm3Q04sZGzIyMpLFqxdx9JQPoWGhFMhbkE6tu6DKr+LZi2f8Nj7mB68WXZoC4FKhGv269U/mOy7Ej8e6sCUntp3VWnbt+E0a9nHTeny8UlMnlv3XqFG5eXk2TY+5wTc2McKyQA76L+xOv/ndNOn19HXj3OTdPpe0W7cHV9738HwXGk7Im1CyZM8Ub9pcNjk5vkU7iLl19m6cgOPZwxdaPZFe/RsYZyK3DyVeL7qo1WoOrD5KrfZVNAFHStXLllne9J7TmZLVi3HhwFWObjrFg6u+WmnuX3n/OuDfQACyZM/Mi8cvyVXYip0LtIfFuXbiFg1619Yc2/PHAZpgA8D3hh9vA4OxLmz5yfcpPCwCY5P3TzrcOnuXjkX6JrpNcunq6jJsVR+Wj16P/51/401jbpWVX/9qz5Aa44gMj0wwL+8P6uLhP768+vc1fx4YxS/5LPj3/rMULbf4fMHB2r2cDQ0NMTTUHpc7thdV165dNcuS0ouqXbt2WsvKly+f7KGjwsLCGDBgACNHjsTc/Pv4Ufl7kpZijG8ZX4DEGBJjCPFzSs176YRIjCExhvi5+Pj4kCHD+3uPj2OLb6FMmTJs2bKFwMBA1q9fT9++fdmwYYOmAaV9+/aatIUKFcLAwIBRo0YxYMCAVCnvd92ocebMGVq1aoW9vT3R0dFMmzaNjh07snPnzkTH7MqQIQO7d+/WvP5Wj90XLJ5wIBT8OoQnd59qXucvlgddvfhH/wp9G4bfrSea13ntc6NvoD1RUlK/CD9WrXIN9vvs0wQc+332Ua1ida7e0H4EbsO29Rw+fogeHXqSM0dO/rnxD1P//pNMmTJjX9geRa2Q1SwbQ3sPI2OGTNy8cwPPRTMxzWJGhbLvxym8ev0KZlnMGD98Ev8+fcJkz0nky52fmi7xjxnoc+IwDnaOmmAjlq6uLvVq1WfqnD958Og+xeyKkd4kAyfOHqdG5ZpATBB09NRRPJq2AeDfZ/8y+o//0bpJG/p06cuboDfMXfY3c5fNoW/X9zfvXjs307xBS1o0bAXA9j3bOH3hNEN6DcM8qzkvXr3kZcALrfKs3byadi060L5FR3bs3cbUOX+yaMZSMmbISMCrl4z5cyRVK1SjX/cB+D15jOfCmRgaGNCyUcwEOkvWLOLE2eP07dqf7Nks2LRjI6P+GMH8aYvIljUbw/oOZ+Jf45k7ZT4m6Uww/K/XmxAiaSwL/kIBx7wYpTMke66s+Pz3qLDxf2PGTu8yl5un72pt83Hv+nch4Una18e9cRRFQVf3y0Z3jI4nz0R/rEqCQ2uO0WlSqxSvl12LDnJuz2XKuBWnRPViNB/agHkDl7HV8/33cFTkB4+k/vd72cfznnwtmcwy8PpFULK2CXz6miwW2gGeqUUWXj19HW/6dBmNsSlVgAKOeek5qyMQ84Ohrq4uuyPWMrTm75hkSoepRRb+Pj9Zs52evh72FQtTr0ctahu3RK2O+4THzdN3gJgnQf69/4zAp68pVKpAnLIBCZbvR6ZGh285xWjsvpLSk+pr9qL6lIkTJ+Lo6Ei1atWStd3PIi3FGN8yvgCJMSTGEEIk5GvdSydEYgyJMSDm/j72Xv/9NpkJeRNKxLsI3rxUEx0VjenH+WbPTOB/+QY+fY2hkQHpM5toNSaZWmTW7FtijPdSK77IkCGDVqNGQkxNTdHT04sznG1AQECcOCJWtmzZ4sQT8aU3MTEhd+7c5M6dGwcHB2rUqMHGjRu1Oml9qFixYkRFReHn55do56Cv5bueU2PRokU0bNiQggULUqhQISZNmsSTJ0+4du1aotvp6OhoTVqS0Jv6M6pSzoXrt6/x/MUznr94xo3b16lcvopWmsjISDZsW0efLn0pXrQEObL/QrVK1alcrgq7D3gDoK+vT6vGrSmYT0WO7DmoXK4K1SpW59ipo1p5ZUifga7tupMrZy5KFy9DSYdSXL52KcHyPfnXn1yWueJdl8vSGgD/p/7o6epR0akiPicOa9Zf/ucyIaHBOJeKmaxpw7Z1VCpXhXqu9cmZw5LCqiJ0adONQ0cPao1NV9S2GA3cGvKLxS/8YvELL16+IGeOnBSxsSW7uQW2NrZUcq6sVZaqFatRybkyOXPkpE3TdoS9C+P2vZjJc3bu30k2M3O6tfuVXDlz4VTSmZaNWrPF2wu1Ws27d+/Ytd+b9i06UNKhFNZW1vTq1BtDQyP2Hd6Dnq4eGdNnBCBzpiyYZjEjvUn6BOtMiJ+J7w1/7Jy1h4ewLVcIv9tPUH/Qu/SfYzep2qoCLq0qcH7fFc0N5+vnb3jp/4pf8lnw5N5Trb+nD+M+0pzSHt96gqpkfq1lNiULJJA66RKvl5iA4aX/K674XP8q9fLCL4Ad8/YxpvEUNk7bTu1OSf8h9fENP2zLfVR2ZxseXffTHFv2XFkxt3r/w7B1YSsymmbA9780URFRCf6Ql8fWmnsXHya5PADXT97G0cVea1nxakW5kcDk36FBYXS27083x0Gavx3z9uF7059ujoO4efoOFw9cjZPm1tm7HFx1jG6Og+Jt0ADI75AHeN/77PrJW+SxtyaL+fueesWrFyXkTaimPsTX5+Pjw/nz5zV/Cd3op4YDBw5w6tQpfvvtt9QuyndLYoyUJzGGxBhCpGWpfS/9pSTGiOtHiDEAbpyKb5tiXD8Zs01UZBS3z9/Hser7NDo6OjhWtef6f/nePn+fyIgorTRWqpxY5Dbnxn/5SIyRdhgaGmJra8vJk++H31ar1Zw8eRJHR8d4t3FwcODUqVNay06cOIGDg0Oi+1Kr1QnO7QExw93q6urG6cT1rXzXT2p87O3btwBkzpzw43EQM4FilSpVUKvVFClShP79+1OwYMGvXr47F+LvdQdoWo1j3bv8MMlpH1xNucnrMmfKTEmHUhw4sh8FhZIOpcicUbs+nzx7Qnh4OP+bOFxreVRUFPnyvG9527l3O/t89vEi4DkRERFERUXF6f1kbZUbPd33vcDMspjx6PHDRMv44aPxiankXIUdo/oTEBhAVtOs+Jw4REmHUppHxR/4PuCh7wN8jh96nzcKakXNsxdPNQFMgbza50bVitUYOWk43QZ2pnjRkpRyLE3xosW10uSxzqv5v7GxMSbpTHgTFDOGoZ//YwoVLKTVe6+Iqghh78J4+eolIaEhREVHUURVRLNeX18fVX4Vj588TtKxC/GtvObbP0KYmI3TtuN5ZhKtRjTi8LoTFHFSUa9HLWb1WAiguYH2WXeCFr81RN9Qn7n9l2rlsXz0On6d0YGQN6Gc3X0JAyMDbErmI4NpBjZN3/FVy7/VcxdTfcbSqF8dTm0/h4OLHaVcHZJ83UvIp+ol1sHVR2kzulmK1kv36e04u+sifrf/JYNpehwq2+J7wz/JZV8/ZRsj1vXn7sUHXNx/hbLuJSnfsAyDq8fMH3Bh/xUeXPVl6Mre/N1vKXr6evSe3YnLh69x+3zM9+7Thy/IkTc7+Yvl4YVfAGFvw4iMiOm5ZVehEMtGrtPsz6ZUAQYv68ngamMJePIq3jJ5zdzJ1MNjaNy/Dqd3XqBy83KoSubnr67zNGk6TGhJtpxmTG7niaIoPLymff1+/fwNke8itZZ/nOZdSDhBr95qlv+SzwKXluU5432RoIC35Cuam27T2nLF57rmcfvze6/ge92PIct7sWDISsxyZKHduOZsm7Nbc8w/E7Wiw2eMlvMF+4v5Nyk9qb5mL6rEnDp1Cl9fX0qVKqW1vFevXpQsWZIVK1YkOa+fxfccY6SF+AIkxpAYQ4jkSe0Y4+Me9ql5L50SJMaI60eIMQB2zN1H3R616PRHa/YsPoiDix2Vmjoxos5EzTabpu9g8NIe3D53j1tn7tKgrxvG6Y3YsyTmeyo0KJTdiw/SbWpb3r4KJjQojB4zO3DtxC1u/PdUuMQY76VWfJEc7du3Z8iQIdjZ2VG0aFGWLVtGWFgYDRs2BGDw4MFYWFgwYMAAANq0aYOHhweLFy+mUqVKeHt7888//2jm7AsNDWXu3Lm4uLhgbm5OYGAgq1at4tmzZ9SqFfMU7MWLF7l8+TJly5Ylffr0XLx4kYkTJ1K3bt1P3kN/LWmmUUOtVjNhwgSKFy+OSqVKMF3evHmZMGECNjY2vH37lsWLF9O8eXN27txJjhw5vmoZkzMG7ddKmxTVK9Vg7rK/Aeje7tc469+9CwNg5KAxZDXVbm0zMIiZ4O7ISR8Wr15Eh1adKFSwMOmM07F55yZu372llT52fNdYOjo6qBP5Ys35iyWP/eO/6X7sH/ODjmWOmMmOVPlV5LDIwdGTPrhWc+Pk2RP0/WBM2Hfv3lHLpTbuNevGycs82/vxpY2NjLXWFchbgIXTl3D+8lku/XOJybMmUszWgWF93wdg8R5XAr1shUir3uno04S4n5/UdPfiA35vNo22Y5rRakRjXv0byLJR69i77DAATSxihv5Jn9mErlPbEB2t5vgW7XFgdy06yLvQCJoOrEvnyR68Cwnn4VVfNs/Y+dXLf+3ELWZ0n4/HyCa0G9ecc3sus/mvndTtEf9wGUn1qXqJdWTjKXrO6pii9aKrp0tPz06YW5kREhTGud2X+PujYCYxJ7aeZU7fJTQZ4M6vf7Xn6YPnTOkwhys+1zVpRtafTM+ZHZjmMxa1Ws253Zfw7L1Ys/7YplOUb1CGPw+OIqNpBv5sP5u9yw5TuKyK9JlNOLLxfa8UIxNDrAtZxjvsSqzrJ28zsdUM2o1rQfvxLfG/8y+jG0zWapTImsOU7NYp20s7KiKK4lWL0rBPTCDy4nEARzefZvV/YxRDzP3QCPeJ9JnTmRknxvMuJJx9yw+z9IOgSnwfPuxFFTsMVGwvqtatW8e7TWwvqg/n1UhKL6oPdenShSZNmmgtc3d3Z9iwYVSpUiWBrX5e33uMkVbiC5AYAyTGECIpUjvGeBcarokZYqXmvXRKkBgjrh8lxnj68Dkj6kyk+7R2NOhdm5d+AUzrPJdzey9r0visP0EW80y0HdMM0xxZuHfpIb+5juf18/eTh//dbymKWs3IjQMxMNLn/J7LzPygcUpijLSldu3avHr1ipkzZ/LixQsKFy7MwoULNR2h/v33X63h6ooXL86UKVP466+/mDZtGnny5GH27Nmae189PT3u37+Pl5cXgYGBZMmSBXt7e1atWqXpwGNoaIi3tzeenp5ERERgZWVFu3bttObZ+NbSTKPGmDFjuHPnDqtXr040naOjo9bjNo6OjtSuXZu1a9fSt2/fr1zKtKF4sRJERUX9n707j5ex7v84/r5mzpxzrCfH1i1btz27lHKTFhTiJlH9sqblFqFsEQkVikqou7JkaSPLnVIplRSllESiyJbt2OI42yzX74+TccY5c8ycmTPLOa/n43EerrnmM9f3M2O2z3yv7/crQ1LjC84OkjKHYNtsNiUdO6r6depnP4Ck7Tt/Ue2addShza3ufYeP5Lw4qj+uu+Y6LVyyQH/s3e1xRpbL5dL/PlqhSpdV9th/ffMb9MXXX6h0YhlZLBZd1ehq93XVqlbT/j/3qcKlFfzOo2jRomp5bSu1vLaV/tWshcZNGaszyWdUoniJi9624mWVtH7j15nzU/59JtUvO39RkfgiKpNYRiWLl1RMTIx+2fmLyv29eKLD4dBvu3aqU7vOkuRe5JAiBsjuq2Xf6qtl3+Yac/avFHUoerfX6z9/6yt9/tZXOV53ZG+S2li65XjdhXKK65LYx729Ze0v2WI+nL1GH85e47788KsPeMyJvnD8Ei0cv8TjNsunr9Ly6atyzSVcj8usLF/8L5TT/d/1055s+97/72q9/9/VXo+TtP+YxnV5xuv19gyHJnaflm3/bYM7aMnU95SRdn7IbE455eTLd7/xKFQu9Ow9s3K9fU7/jxcaduMTHpeTDhzX0BvGXTS3o/uO6bEsZ2cVZs4wzXnrq2CfRSVJp06d0qFDh3T0aOa0DX/88YekzFEeWadGulCFChVUqVLO0+8UZtQYwUONcXHUGEDkosbIGTVG+GuMLWt/Uf8rR+R63P/N+kj/m/WR1+vt6XbNGDhHMwbO8RpDjZEp0uuLc3r06OH1RKmcRma3a9dO7dq1yzE+Li5OM2fOzLW9unXravHixf4nmo+iolNjwoQJ+uKLL7Ro0SK/z4Sy2WyqU6eO9u3bl0/ZRR+rxaqXn3nFvX2hokWKqkv72zR70WsyTVNX1KqrsylntX3nLypapKhuuq61/lG+gj5bt0Y/bNmk8mXL6/OvPtNvu3eqfNnAzlT7d7su+nbTN5owbbz63X2valarpVN/ndKS997RgT/3a+Kopz2GXLf61w16c9kbWvy/d9T86n+5z/KSpK4du2nYuEf039dfUtvrb1Z8fLz2HdinzVt/1H9yOHvsnBWrlqnUJYn6Z9VqshiGvvp2nUpdUsrnOWc7tO6g9z5aoVfmv6wObTvqz4MH9ObSRercvossFovi4+PVvnUHzXtrrkoUL6Gypctp6fvvKj0jXW2vbytJKlemnAzD0Hc/blTTRlcpNjZWReKL5PFRBRBJbh/aUT98skVpZ9N1VbtGatPres0Y8Fq40ypwYmwx+mPrXi19Pv/PjgO8CfZZVJL02WefadSoUe7LDz/8sKScFytH7qgxgosagxoDQPhQY4QGNQYQOSK6U8M0TU2cOFGffPKJFi5cmKezy5xOp3bu3KlWrVrlQ4bRq2jRorle36NbLyWUTNCS9xbryNHDKlasmKpVra5unbpLktrd1F679+7SMzMmSzJ0XfNWat+6gzb9tCmgvGJjY/XkY5O05H/vaME785V07KiKFCmi+nUaaOr451SlUlWP+AqXVlDNajW1c9dO3dfjfo/rLq98uSaNmaKFi+fr0YkjZJqmLi3/D7W85rpccygSX1TL3n9XBw8flMViUY1/1tS44RM8fnTITenEMho3fILmvTlHH48aoBLFS6jN9Tfrjs53uWN639FXLpep516eqtS0VFW/vIbGj3xSxf9evK90Yhn9X9e7Nf+deZr+6vO6ocVNejjLsHcgFGJNp55W5sKco9VSGYb3obSRIDY+Vk+vylwYd3T7pz3OnIkkta+qru7D/62iJYro0O4jemnwXH0457Nwp1XgOOwOvfnUsnCngXzmlCXiz6QK5llUknTbbbe5R3r4aseOHRcPKkSoMfIPNYZ31BhApnDXGNFSM/iLGiM0qDEKvmioL5DJMANdOSgfPfHEE3r//ff10ksv6fLLzy+aVqJECcXHZ85ReuGw/ZkzZ6pRo0aqUqWKTp8+rTlz5ujTTz/VsmXLVL16dZ/aTU5O1pVXXqmKu+rK4vL8gC1bJVH3v3y3ype5VFZF9g98gD+ccurIscN6tf8bStqb88JWKFziTYdWaoUkqaM6K82I6H5wxReN08rkRZKkjsV7KC0lPcwZAYXTJ67cp90KhsOHD6tVq1aa/ma6SmefaSnfpJyV7u8cp02bNl10oXBErkirMagvUJBRY+BC4a4xqBmA6JTfNQb1RfSJ6F+o3nrrLUlSz549PfZPmjTJfYbahcP2T58+rbFjxyopKUkJCQmqW7eu3n77bZ+LDQAAAAAFFzUGAAAAEN0iulPDl6HyFw7bHz16tEaPHp1fKQEAACBCmKYhVwjHHEfu+Gb4gxoDAAAAOaG+iB6+TeAJAAAAAAAAAAAQZhE9UgNAGBhG5l9OIqEL2VtuoUzBGth812ag3f6mK7DbS5LhQ5+2aUrnmrJYpayL+LmCsJxVoP+XF94Hi9Vz23Lx/6dA/y8Na+DnBhjFcl9U9WLMDHvAObjOnAn4GEA4OGWwkB8AAACAoKC+iB6M1PCTaZqK4LXVgYCYpnh+AwAAhBD1BQo6nuMAACDYGKnhpzPHz8qR4ZRLTlkV2Bm+QCRxySmH3aHTx86GOxVEkNQoe59LPZsW7hQAhJDTtMgZwt/JQtkWCg/qCxRkLjnlyHBSY8BDuGsMagYA3lBfRA86NfyUfjZD3638SS3vjFPiJYmyUHigAHDJqROnTui7935SRkpGuNNBhEgzYtTJenu40/BZWkq6OiX0CXcaAAD4hfoCBZW7xlhJjYHz0owYdVKX8LWfkq5OJXqGrX0AQHDQqZEHX8xbL0m6qmNDxcRaZUTAHP9AXpmm5LA79N17P+mL1zeEOx0AAIBCh/oCBY1pmnJkOPXdyp/cz28AAIBgoVMjD0xT+nzuen399vcqWaYYRQeig5fnqWmaOn3sLGdPAQCijimLXCFsL5RtoXChvkBBQ40BAIhG1BfRg06NAGSkZOjYPr6kIUpQHMNPNtOpca6vJUnjLf+S3Yjs6TBscTaNW/KwJGl8t+dlT7eHOSMAAPxDfQGgoLOZTo1T5gwB43VtyGsMW5xN494dltn+7VOpGQAgStGpAQDIkVWmmumQezvSv+5brRY1a9/EvR3p+QIInFOGnCFtDwAABCKzxjjs3g71d3ar1aJmHagZAOSM+iJ6WMKdAAAAAAAAAAAAgC8YqQEAAICo5DQlpxm6c3ScpinJDFl7AAAAAEKH+iJ6MFIDAAAAAAAAAABEBTo1AAAAAAAAAABAVGD6KQAAAEQllwy5ZISwPYnh4QAAAEDBRH0RPRipAQAAAAAAAAAAogIjNQAAOUozYtTGeke40/BZWkq62sTcGe40AISQSxY5Q3iOjkumzp1PBQAA/JdmxKiNbg9f+ynpamPpFrb2AUQ26ovowUgNAAAAAAAAAAAQFRipAQAAgKjkNC1ymqE7R8dpMt8tAAAAUFBRX0QPOjWAwqKgvFFGwP0wHY5wpxA403nREJvp1KPaKEmarKtlN6xBziHA/8sL7oMtzqZHFzwkSZrca4bs6faLH8J18cch19tfvImLS0sLwkEAAAAQ1YwAF6YN9Lt1oO37yGY69aj5d41h5EONcbH242x6dMHAzPZ7zfSpZgg5I/AfVA1LYP+fpisIdXeAtRYA5IbppwAAObLK1HX6U9fpT1kV/s6ki7FaLbqu27W6rtu1slr5eAMAAAAiTWaNcUDX6UBYagyr1aLrbr9W191OzQAA0YyRGgAAAIhKLlnkCvlCfgAAAAAKIuqL6EG3NAAAAAAAAAAAiAoR3akxY8YM1apVy+PvlltuyfU2H374oW655RbVr19fHTt21Nq1a0OULQAAAELJJUNOM4R/Cs1848hf1BgAAADICfVF9Ij46adq1KihefPmuS9brd4Xkfrhhx80dOhQPfLII7rhhhu0cuVKDRgwQMuWLVPNmjVDkS4AAACACEeNAQAAAESviB6pIWUWGGXLlnX/JSYmeo1dsGCBWrZsqXvvvVfVqlXTkCFDdMUVV2jRokUhzBgAAACh4JQl5H8oGKgxAAAAcCHqi+gR8Y/c3r171aJFC910000aOnSoDh486DV28+bNuvbaaz32tWjRQps3b87nLAEAAABEC2oMAAAAIHpF9PRTDRo00KRJk3T55ZcrKSlJs2bN0t13362VK1eqePHi2eKPHTumMmXKeOwrXbq0jh07FqqUAaDASJNVHdXZvR3p0lLS1bF4D/c2AAA5ocYAgPBJk1UdjS7u7ZC3n5KujiV6urcBANEpojs1WrVq5d6uXbu2GjZsqBtuuEEffvihunXrFsbMAKAQMAylRfbHRDYUJkDh4jItcpmhG3jsMs2QtYX8Q40BAGEUATUGNQMAb6gvokfETz+VVcmSJVW1alXt27cvx+vLlCmT7Yyp48ePZzuzCgAAAAAkagwAAAAg2kRVp8bZs2e1f/9+lS1bNsfrGzVqpG+++cZj3/r169WoUaMQZAcABYvNdGq4+Z2Gm9/JZjrDnc5F2WJjNHzuAA2fO0C22OgaYQIgb1whXsTPFV1fneEjagwACB2b6dRw10YNd20MS42RWTM8qOFzH6RmAJAN9UX0iOhHbsqUKdq4caMOHDigH374QQMHDpTFYtGtt94qSRoxYoSmTZvmju/Vq5fWrVunuXPnateuXZoxY4a2bt2qHj16hOsuAEDUsspUW+1VW+2VVZE/JNIaY1XbPterbZ/rZY2J/DVAAADhQY0BAOET7hrDGmNV297Xq21vagYAiGYR3S19+PBhPfLIIzp16pQSExN15ZVXavHixUpMTJQkHTp0SBbL+X6ZJk2aaOrUqXrhhRf03HPPqWrVqpo1a5Zq1qwZrrsAAACAfOI0DTlNI4Tthawp5CNqDAAAAOSE+iJ6RHSnxvPPP5/r9QsXLsy2r127dmrXrl1+pQQAAAAgilFjAAAAANEtoqefAgAAAAAAAAAAOCeiR2oAAAAA3rhkhHRxPZdcIWsLAFDImGGegyRU7WdtxzSlUK+rcWH74X7ccxKEBdRNvrIAeUJ9ET0YqQEAAAAAAAAAAKICIzUAAAAQlTIX8gvdOTos5AcAAAAUXNQX0YNODQBAjtJk1e3q6N6OdGkp6bq9XD/3NgAAAIDIEu4ag5oBAAoGOjUAADkzDP2luHBn4Ze/jp0OdwoAQihzzlsjpO0BAIAARECNQc0AwBvqi+jBmhoAAAAAAAAAACAqMFIDAJAjm+nUf7RFkvRfNZDdiOwpqGyxMfrPc70lSf99ZL7sGY4wZwQAAAAgq3DXGNQMAFAw0KkBAMiRVaY6aZck6TXVlz3M+VyMNcaqTg/eIkl6bcQiChSgEHCZFhbyAwAgioS7xqBmAJAb6ovowfRTAAAAAAAAAAAgKjBSAwAAAFHJKYucITxHxxmylgAAAACEGvVF9GCkBgAAAAAAAAAAiAqM1AAAAEBUMk1DLtMIaXsAAAAACibqi+jBSA0AAAAAAAAAABAV6NQAAAAAAAAAAABRgemnAAA5SpdVPdTOvR3p0lMz1OPyB93bAAo+FvIDACC6hLvGoGYAkBvqi+hBpwYAIEemYeiIioU7DZ+Zpqkje5PCnQYAAAAAL8JdY1AzAEDBQKcGAAAAopLLtMhlhu5MKpcZsqYAAAAAhBj1RfSgUwMAkKMY06W+2ipJmqd6chiRvQxTjC1GfZ+6S5I077G35LA7wpwRAAAA4CPDCOz2ZoC/jAXavo9iTJf6mj9LkuYZ9UNeY8TYrOr75N81w5i35LBH4OQvQXhMDEtg/59mMH5pdUXgYwugwKBTAwCQoxi51F07JUkLdYUcIZxXMi9ibFZ1H9ZJkrTwicV0agCFgFOGnArNjzDn2gMAAHnnWWPUDXmNEWOLOV8zjF8SmZ0aAMKG+iJ6RPYvVAAAAAAAAAAAAH+jUwMAAAAAAAAAAESFiJ9+6sYbb9Sff/6Zbf///d//ady4cdn2L1u2TKNGjfLYFxsbq59//jnfcgQAAEDosZAf8oL6AgAAADmhvogeEd+p8e6778rpPD/H4W+//aa+ffvqlltu8Xqb4sWL66OPPnJfNkK04BUAAACAyEZ9AQAAAES3iO/USExM9Lj86quvqnLlyrr66qu93sYwDJUtWza/UwMAAEAYuVjID3lAfQEAAICcUF9Ej6haUyMjI0PvvfeeunbtmuvZUSkpKbrhhhvUqlUr9e/fX7/99lsIswQAAAAQDagvAAAAgOgT8SM1svr000915swZdenSxWvM5Zdfrqefflq1atXSmTNnNHfuXN1555364IMPdOmll4YwWwCIbumy6l61cW9HuvTUDN1b72H3NoCCz2UaIZ7zlklvCxrqCwAIrXRZda/R1r0d8vZTM3Rv/Ufc2wCQFfVF9IiqTo2lS5fquuuuU/ny5b3GNG7cWI0bN/a43L59e7399tsaMmRICLIEgILBNAztVUK40/CZaZra+8uBcKcBAIgi1BcAEFrhrjGoGQCgYIia6af+/PNPrV+/Xrfffrtft7PZbKpTp4727duXT5kBAAAAiDbUFwAAAEB0ipqRGsuWLVPp0qV1/fXX+3U7p9OpnTt3qlWrVvmTGAAUUDGmS3dpuyTpLdWRw4jsfvAYW4zuGp05fchbTy+Xw+4Ic0YA8ptLFjkZHo48or4AgNCLMV26y/y7xjBCX2PE2Ky6a9Rtme1PWiaH3RnS9gFENuqL6BEVnRoul0vLli1T586dFRPjmfKIESNUvnx5DR06VJI0c+ZMNWrUSFWqVNHp06c1Z84cHTx4UN26dQtH6gAQtWLkUq+/OzWWqJYcET64L8ZmVa9x3SVJS559j04NAIBX1BcAEB6ZNcYvksJTY8TYYtRrXOb795Kp79GpAQBRKio6NdavX6+DBw+qa9eu2a47dOiQLJbzH4KnT5/W2LFjlZSUpISEBNWtW1dvv/22qlevHsqUAQAAkM9cklwyQthe6NpC/qK+AAAAwIWipb544403NGfOHCUlJal27doaO3asGjRo4DX+ww8/1PTp0/Xnn3+qatWqGjZsmMeo4xkzZuiDDz7Q4cOHZbPZVLduXT388MNq2LChO+bUqVOaOHGiPv/8c1ksFrVt21aPPfaYihUrlqf7EKio6NRo0aKFduzYkeN1Cxcu9Lg8evRojR49OhRpAQAAALkKdsGxevVqvf3229q2bZtOnTqlFStWqE6dOu7rT506pRkzZuirr77SoUOHlJiYqNatW2vw4MEqUaJEvt7XaEJ9AQAAgGi0atUqTZo0SePHj1fDhg01f/589evXTx999JFKly6dLf6HH37Q0KFD9cgjj+iGG27QypUrNWDAAC1btkw1a9aUJFWtWlWPP/64KlWqpLS0NL3++uu655579MknnygxMVGSNGzYMCUlJWnevHmy2+0aPXq0Hn/8cU2bNi2k9/+cyJ5LBAAAAPDCaVpC/uePcwXHgAEDtHz5ctWuXVv9+vXT8ePHc4w/V3DcfvvtWrFihW666SYNGDBAO3fudMekpKSoSZMmGjZsWI7HOHr0qI4ePaqRI0fq/fff16RJk7Ru3To99thjfuUOAAAAFDaRXl9I0rx589S9e3d17dpV1atX1/jx4xUfH6+lS5fmGL9gwQK1bNlS9957r6pVq6YhQ4boiiuu0KJFi9wxHTt2VPPmzVWpUiXVqFFDo0aNUnJysvskoF27dmndunV68skn1bBhQzVt2lRjxozRBx98oCNHjuTtwQ5QVIzUAAAAAKJN1oJDksaPH68vvvhCS5cu1f33358tPmvBIUlDhgzR+vXrtWjRIk2YMEGS1LlzZ0nSgQMHcmyzZs2amjFjhvty5cqVNWTIEA0fPlwOhyPb+hEAgAgR7sViQ9V+1nZMU1KI7/eF7Yf7cc+JGfg6H6YrCHkACJnk5GSPy7GxsYqNjc0Wl5GRoW3btumBBx5w77NYLGrevLl+/PHHHI+9efNm9enTx2NfixYt9Omnn+YYn5GRoXfeeUclSpRQrVq1JEk//vijSpYsqfr167vjmjdvLovFoi1btqhNmzY+3c9gYqQGAAAA4Ifk5GSPv4yMjGwx5wqO5s2bu/f5UnBce+21HvtatGihzZs3B5xv8eLF6dAAAAAAIlCrVq105ZVXuv9eeeWVHONOnjwpp9OZbZqp0qVL69ixYzne5tixYypTpsxF4z///HM1btxYDRo00Ouvv665c+e6p546duyYe/ucmJgYJSQkKCkpya/7GixUNgAAAIhKLtOQywzhQn5/t5V1jQtJGjhwoB566CGPfbkVHLt3787x+L4WHP44ceKEXnrpJd1xxx15PgYAAABQGISrvli7dq2KFy/u3p/TKI381qxZM61YsUInT57U4sWLNWTIEC1ZsiTHdToiAZ0aAIAcZciqAbrRvR3pMtLsGnD1o+5tAMgvkVB0+CI5OVkPPPCAqlWrpoEDB4Y7HQAAwl5jUDMAiETFixf3qC+8KVWqlKxWa7Y1+o4fP57t5KhzypQpk+0kqZziixYtqipVqqhKlSpq1KiR2rZtq3fffVcPPPCAypQpoxMnTnjEOxwO/fXXXypbtqwvdzHomH4KAJAjl2Fop5GonUaiXEbozlTIK5fLpZ3f79LO73fJ5WISWaAwcMoS8j/pfNFx7i+nTo38LDh8kZycrHvvvVfFihXTrFmzZLPZ/D4GAADBFu4ag5oBQG7CVV/4KjY2VnXr1tWGDRvc+1wulzZs2KDGjRvneJtGjRrpm2++8di3fv16NWrUKNe2XC6Xe5rdxo0b6/Tp09q6dav7+m+++UYul0sNGjTw6z4EC50aAAAAQJCFsuC4UHJysvr16yebzaaXX35ZcXFxfucPAAAAIPL07dtXixcv1vLly7Vr1y498cQTSk1N1W233SZJGjFihKZNm+aO79Wrl9atW6e5c+dq165dmjFjhrZu3aoePXpIklJSUvTcc89p8+bN+vPPP7V161aNGjVKR44c0S233CJJqlatmlq2bKmxY8dqy5Yt2rRpkyZOnKgOHTqofPnyoX8QxPRTAAAvYkyXuug3SdJy1ZDDiOx+8BhbjLoMbi9JWj59lRx2R5gzApDfwjXnra/69u2rkSNHql69emrQoIHmz5+freAoX768hg4dKimz4OjZs6fmzp2rVq1aadWqVdq6dasmTJjgPuapU6d06NAhHT16VJL0xx9/SMoc5VG2bFklJyfrnnvuUWpqqp599ln3YuaSlJiYKKs18qcTBAAUXOGuMagZAOQm0usLSWrfvr1OnDihF198UUlJSapTp45mz57tHt196NAhWSzn31ubNGmiqVOn6oUXXtBzzz2nqlWratasWapZs6YkyWq1avfu3Vq+fLlOnjypSy65RPXr19cbb7yhGjVquI8zdepUTZw4Ub1795bFYlHbtm01ZsyYAB+BvKNTAwCQoxi5dL9+liStVDU5InxwX4zNqvuf6SlJWvnSxxQoAMIu2AWHJH322WcaNWqU+/LDDz8s6fxi5du2bdNPP/0kSWrTpo1HPmvWrFHFihXz7f4CAHAx4a4xqBkAFAQ9evRwj7S40MKFC7Pta9eundq1a5djfFxcnGbOnHnRNi+55BKPESDhRqcGAAAAkE+CWXBI0m233eYe6ZGTZs2aaceOHf4nCgAAAABRgk4NAAAARCVTFrlCeIanS2bI2gIAAAAQWtQX0SOy5xIBAAAAAAAAAAD4GyM1AAAAEJWcpiFnCBfyC2VbAAAAAEKL+iJ6MFIDAAAAAAAAAABEBUZqAAAAICqZpiFXCM9uMjmTCgAAACiwqC+iB50aAIAcZciqobrOvR3pMtLsGnrDOPc2AAAAgMgS7hqDmgEACgY6NQAAOXIZhraoXLjT8JnL5dKWtb+EOw0AAAAAXoS7xqBmAICCgU4NAAAARCWXaZHLDN0ScS7TDFlbAAAAAEKL+iJ60KkB+MIIcI67SHiTsgRhaK/pCvD2QXgcArwfhiXw+QqNmMDeOs1AHwenM7DbS5Jx8Q9pq+lSe9fvkqRVlupyZrmN6QjCUG0fcsj15lbP54I1xqr2994oSVo1+zM5HRd/nIxYW2A5xMcFdHtJUqmEwHJITQ84BcefBwM+BgAAQJ4EWmtFggiocwKu1QL8bu4rq+lSB3OXJOkDo5pHjRGS9mOs6nDfTZntv7YmW80QjHoxYEF4TAxrYMcIuGaVZKYHXqcAgDd0agAAcmSTSw85v5ckfWL5p5wKbcHhL1tsjB6a3keS9MmCL33q1AAQ3Zwy5FTofnwIZVsAABRENrn0kPmDJGm1cXnIawxbbIwemnFPZvvz11IzAPBAfRE9IvsXKgAAAAAAAAAAgL8xUgMAAABRyWUacpmhO7splG0BAAAACC3qi+gR1pEa3333nf7zn/+oRYsWqlWrlj799FOP603T1PTp09WiRQs1aNBAffr00Z49ey563DfeeEM33nij6tevr27dumnLli35dA8AAAAARBJqDAAAAKBgC2unRkpKimrVqqVx48bleP1rr72mhQsX6oknntDixYtVpEgR9evXT+m5LDa0atUqTZo0SQMGDNDy5ctVu3Zt9evXT8ePH8+vuwEAAAAgQlBjAAAAAAVbWDs1WrVqpYcfflht2rTJdp1pmlqwYIH69++v1q1bq3bt2nrmmWd09OjRbGdbZTVv3jx1795dXbt2VfXq1TV+/HjFx8dr6dKl+XlXAAAAEGKZw8MtIfxjeHg0oMYAAABAXlBfRI+IXSj8wIEDSkpKUvPmzd37SpQooYYNG+rHH3/M8TYZGRnatm2bx20sFouaN2/u9TYAAAAACgdqDAAAACD6RexC4UlJSZKk0qVLe+wvXbq0jh07luNtTp48KafTmeNtdu/enT+JAkABlSGLxsS0cm9Huox0u8Z0fta9DaDgc8mQSyFcyC+EbSF/UGMAQHhlyKLHLC3d2yFvP92uxzpNcW8DQFbUF9EjYjs1AADh5TIs2mhcFu40fOZyurTxw83hTgMAAACAFy7Doo2qEL72nS5tXMUoOwCIdhHbqVG2bFlJ0vHjx1WuXDn3/uPHj6t27do53qZUqVKyWq3ZFuw7fvy4ypQpk3/JAgAAIORcpiFnCOehDWVbyB/UGAAAAPCG+iJ6ROx8IhUrVlTZsmW1YcMG977k5GT99NNPaty4cY63iY2NVd26dT1u43K5tGHDBq+3AQDkzGq61Ma5W22cu2U1XeFO56KsMVa16Xmd2vS8TtYYa7jTAQBEIGoMAAgvq+lSW9cfauv6Iyw1hjXGqra9Wqltr1bUDAAQxcI6UuPs2bPat2+f+/KBAwe0fft2JSQkqEKFCurVq5defvllValSRRUrVtT06dNVrlw5tW7d2n2b3r17q02bNurRo4ckqW/fvho5cqTq1aunBg0aaP78+UpNTdVtt90W8vsHANHMJpeGO7+RJK2zVJYzcvvBJUm22BgNn/2AJGnd0m/ldDjDnBEAIByoMQAgctnk0nBzoyTpS6NSyGsMW2yMhs/tn9n+u99QMwBAlAprp8bWrVvVq1cv9+VJkyZJkrp06aLJkyfrvvvuU2pqqh5//HGdPn1aV155pWbPnq24uDj3bfbv36+TJ0+6L7dv314nTpzQiy++qKSkJNWpU0ezZ89maDgAAEAB45Ihlxm6H0NcEd65i0zUGAAAAMgL6ovoEdZOjWbNmmnHjh1erzcMQ4MHD9bgwYO9xnz22WfZ9vXo0cN9VhUAAACAwoMaAwAAACjYInahcAAAACA3pmnIFcLF9UwW8gMAAAAKLOqL6EGnBlBIGNbAF0EzA51uNOADBOF+WILwgWGzBXRzwxXYgnhmQLf+OwfDh8fBtEj2v7etFhnG+WGRpjPwIZKB/l8atgs+wmxWj+1s1+d0jNjYwHKIjw/o9pLkLFU8oNtbgvDaBgAACBszGN9uCwBXmNd2CEKt5nc7LqfkS10STK4L2r/gcQ/D2uX5wrRfPAYAohmdGgAAAIhKLhlyKXQ/hoSyLQAAAAChRX0RPViNBAAAAAAAAAAARAVGagAAcmSXRU/GtnRvRzp7ukNP9pzp3gYAAAAQWTJk0URd494Oefvpdk3sPs29DQCITnRqAABy5DIsWmetEu40fOZyurRu+XfhTgNACLlCvJBfKNsCAKAgchkWfamK4Wvf6dKX734TtvYBRDbqi+gR+afeAgAAAAAAAAAAiJEaAAAvLKZL/3LtlyR9bakklxHZ/eAWq0X/6nSlJOnr9zbJ5XSFOSMA+c1lWuQyQ/feFMq2AAAoiCymSy10UJL0lSqEvMawWC1q0eXqzPaXb6RmAOCB+iJ60KkBAMiRTS6NyVgnSeoUf6fSI3xwny0uRmMWDpQkdSp3n9JTMsKcEQAAAICsYuXSWGVO/9RRnZUW4hojNs6msYuHZrZfvIfSUtJD2j4AIDjo1AAAAEBUYs5bAAAAAMFCfRE9Ivu0WwAAAAAAAAAAgL/RqQEAAAAAAAAAAKIC008BAAAgKrlkyKUQDg8PYVsAAAAAQov6InowUgMAAAAAAAAAAESFPI3UcLlc2rt3r44fPy7TND2uu+qqq4KSGAAAAJAbFvIrWDIyMnTixAm5XC6P/RUqVAhTRgAAAChMqC+ih9+dGps3b9bQoUN18ODBbB0ahmFo+/btQUsOABA+Dlk01XatezvSOTKcmvrAa+5tAEB02LNnj0aPHq0ff/zRY79pmtQXAFDA2GXRs2rq3g55+xkOPdt3lnsbABCd/O7UGDdunOrVq6dXX31VZcuWlWHQowQABZHTsOiTmGrhTsNnTodTn7zxVbjTABBCnElVMDz66KOKiYnRf//7X5UrV476AgAKMKdh0WpVDV/7DqdWz/8ibO0DiGzUF9HD706NvXv36sUXX1SVKlXyIx8AAAAAhcivv/6qpUuXqlq16OlIBwAAABA+fndqNGjQQHv37qVTAwAKOIvpUlPXQUnS95YKchmRPQWVxWpR09b1JUnff/qzXE7XRW4BAIgE1apV08mTJ8OdBgCEV6Cj1C6YHjzk7fvIYrrUVEckSd+rfMhrDIvVoqY3N8xs/+OfIrNmCMJjYlgC+/80XQE+nyTJxZTAAPKP350aPXv21JQpU3Ts2DHVrFlTMTGeh6hdu3bQkgMAhI9NLk3M+EKS1Cn+TqVH+LoatrgYTVz6iCSpU7n7lJ6SEeaMAOQ3k+HhBcKwYcM0depUPfzww6pZs6ZsNpvH9cWLFw9TZgCAYIuVS0+ZmVPGdjS6KC3ENUZsnE1PrRyV2X6JnkpLSQ9p+wAiG/VF9PC7U+Ohhx6SJI0ePdq9zzAMFvIDAAAA4Le+fftKkvr06eOxn/oCAAAAQE787tRYs2ZNfuQBAAAA+CXUZ1KZnEmVLxYsWBDuFAAAAADqiyjid6fGZZddFrTGv/vuO82ZM0dbt25VUlKSZs2apdatW0uS7Ha7XnjhBX355Zfav3+/ihcvrubNm2vo0KEqX76812POmDFDM2fO9Nh3+eWX66OPPgpa3gAAAACC4+qrrw7q8agxAAAAgILN704NSdq3b5/mz5+vXbt2SZKqV6+uXr16qXLlyn4dJyUlRbVq1VLXrl01cOBAj+vS0tL0yy+/qH///qpdu7ZOnz6tp556Sv3799eyZctyPW6NGjU0b94892Wr1epXXgAAAIh8LhlyKYRz3oawrcLm9OnTevfdd931RY0aNdS1a1eVKFHC72NRYwAAACAvqC+ih9+dGuvWrVP//v1Vp04dNWnSRJL0ww8/qEOHDvrvf/+rf/3rXz4fq1WrVmrVqlWO15UoUcKjaJCksWPHqlu3bjp48KAqVKjg9bhWq1Vly5b1OQ8AAAAA4fHzzz/r3nvvVVxcnBo0aCBJmjdvnl5++WXNnTtXdevW9et41BgAAABAweZ3p8a0adPUp08fDRs2zGP/1KlTNXXqVL86NfyVnJwswzBUsmTJXOP27t2rFi1aKC4uTo0aNdLQoUNzLVAAAAAAhMekSZN04403auLEiYqJySxPHA6HxowZo6efflpvvPFGvrZPjQEAAABEF787NXbt2qUXXngh2/6uXbtq/vz5wcgpR+np6Zo6dao6dOig4sWLe41r0KCBJk2apMsvv9w9h+7dd9+tlStX5no7AIAnhyyaabvKvR3pHBlOzXxkgXsbQMHnkkK6kJ/LDFlThcrWrVs9OjQkKSYmRvfee6+6du2ar21TYwBAaNll0QyjsXs75O1nODRj4Bz3NgBkRX0RPfzu1EhMTNT27dtVtWpVj/3bt29X6dKlg5WXB7vdrsGDB8s0TY0fPz7X2KxDzWvXrq2GDRvqhhtu0Icffqhu3brlS34AUBA5DYtWxtQKdxo+czqcWvnqmnCnAQDwU/HixXXo0CFVq1bNY/+hQ4dUrFixfGuXGgMAQs9pWPSeqoevfYdT7738cdjaBwAEh9+dGt26ddPjjz+u/fv3e6yp8dprr6lPnz7Bzk92u11DhgzRwYMHNX/+fL/PhCpZsqSqVq2qffv2BT03AAAAhI/LNEJ8JhUL+eWH9u3b67HHHtPIkSPVuHHm2bs//PCDnnnmGXXo0CFf2qTGAAAAwIWoL6KH350aAwYMUPHixTV37lw999xzkqRy5cpp4MCB6tWrV1CTO1ds7N27VwsWLFCpUqX8PsbZs2e1f/9+FvUDAD9ZTJfquY5KkrZaysllRPYUVBaLoXr/yhxZsvXrHXIxjhMAosKIESPc/zqdmdMHxsTE6K677sq2jl8wUGMAQPhYTFP1lCRJ2qqychmh/UHPYjFUr2WdzPbXbadmAIAo5XenhmEY6tOnj/r06aPk5GRJyvM8smfPnvU4u+nAgQPavn27EhISVLZsWQ0aNEi//PKLXnnlFTmdTiUlZX7wJSQkKDY2VpLUu3dvtWnTRj169JAkTZkyRTfccIMqVKigo0ePasaMGbJYLLr11lvzlCMAFFY2ufRsxqeSpE7xdyo9wtfVsMXb9OyHoyRJncrdp/SUjDBnBCC/cSZVwRAbG6sxY8Zo6NCh7tqgcuXKKlKkSJ6OR40BAJErVk5NM9dKkjoaXZTm/89SgbUfH6tpnz2R2X6JnkpLSQ9p+wAiG/VF9Ajo0yPQRfG2bt3qMbpj0qRJkqQuXbpo4MCB+uyzzyRJ//73vz1ut2DBAjVr1kyStH//fp08edJ93eHDh/XII4/o1KlTSkxM1JVXXqnFixcrMTExoFwBAAAA5J8iRYqoVq3A13KixgAAAAAKNp86Nbp06aLXX39dCQkJ6ty5s4xchgcuX77c58abNWumHTt2eL0+t+vOOVeUnPP888/73D4AAACA0Bs4cKAmT56s4sWLa+DAgbnGzpw5069jU2MAAAAABZtPnRo33XSTeyj2TTfdlGunBgAAABAKDA+PXiVKlHBvFy9enPoCAAAAYUd9ET186tTIevbUQw89lG/J4AIWa2C3dznDn0MwBHo/gnAfDFtg83ya6UGYpzPA+2FJKHHxoIswU9MCur0rwNtLgd8PIybwOVvN0pcEdoD0wNZ6sCSnBNa+JPnwOFhcdunPv7dLJ8pisZ2/8uSpgFMwisQHdvvixTwuW4rEnt8uW0aW1Is/zo5yCQHlkFKxaEC3l6Q/bwrs9sV3B/7a/sdvfwR2gGB83gAoVM5NCSVJkydPDmMmAAAAAKKN36u+3nTTTR7zy55z+vRp3XRTgL/MAAAAAD4yTSPkfwi+Xr166fTp09n2Jycne6yNAQAAAOQn6ovo4Xenxp9//imXy5Vtf0ZGho4cORKUpAAAAAAUDhs3bpTdbs+2Pz09XZs2bQpDRgAAAAAimc/zsKxZs8a9vW7dOo95cF0ulzZs2KDLLrssuNkBAMLGaVg0O6GFezvSOR1OzZ600r0NoOBzSXIphHPehrCtwuDXX391b//+++9KSkpyX3a5XFq3bp3Kly8fjtQAAPnEIYteNRq4t0Pevt2hV0csdG8DQFbUF9HD506NAQMGSJIMw9Cjjz7qeZCYGF122WXZ9gMAopfDsGppySvDnYbPHHanlr72RbjTAAD4qHPnzjIMQ4ZhqHfv3tmuj4+P15gxY8KQGQAgvzgMi5aoVvjatzu1ZNrKsLUPAAgOnzs1zp1JdeONN+rdd99VYmJiviUFAAAAoGBbs2aNTNNU69attWTJEo/6wmazqXTp0rJarWHMEAAAAEAk8rlT45zPPvssP/IAAEQYi+lS9YyjkqTfY8vJFeFTUFkshqrXqyhJ+n3rAblcZpgzApDfXKYhVwgX1wtlW4XBualrs05DBQAo2Cymqeo6KUn6XaXkMkL72WqxGKre5J+Z7f+wm5oBgAfqi+jhd6eGJG3YsEEbNmzQ8ePHsy0aPmnSpKAkBgAIL5vp1PSj70iSOl/2oNIjvFPDFmfT9BVDJEmd645SempGeBMCAPhsz549+vbbb3OsLwYOHBimrAAAwRYrp2aZmWu2djS6KC1vP0vlvf34WM36NvN3q44leiotJT2k7QMAgsPvT4+ZM2dq1qxZqlevnsqWLSsjxL3qAAAAgCTJNGSG8OymULZVmCxevFhPPPGESpUqpTJlynjUF4Zh0KkBAACA0KC+iBp+d2q8/fbbmjRpkjp37pwP6QAAAAAoTF5++WUNGTJE999/f7hTAQAAABAF/O7UsNvtatKkSX7kAgAAAPjMDPGct5xJlT/++usvtWvXLtxpAAAAoJCjvogefk+Qfvvtt2vlypX5kQsAAACAQuaWW27RV199Fe40AAAAgKjwxhtv6MYbb1T9+vXVrVs3bdmyJdf4Dz/8ULfccovq16+vjh07au3ate7r7Ha7nn32WXXs2FGNGjVSixYtNGLECB05csTjGDfeeKNq1arl8ffqq6/my/3zhd8jNdLT07V48WJt2LBBtWrVUkyM5yFGjRoVtOQAAACAaPbGG29ozpw5SkpKUu3atTV27Fg1aNDAa/yHH36o6dOn688//1TVqlU1bNgwtWrVyn396tWr9fbbb2vbtm06deqUVqxYoTp16ngcIz09XZMnT9aqVauUkZGhFi1aaNy4cSpTpky+3c9AVKlSRdOnT9dPP/2kmjVrZqsvevXqFabMAAAAgMiyatUqTZo0SePHj1fDhg01f/589evXTx999JFKly6dLf6HH37Q0KFD9cgjj+iGG27QypUrNWDAAC1btkw1a9ZUWlqafvnlF/Xv31+1a9fW6dOn9dRTT6l///5atmyZx7EGDRqk7t27uy8XK1Ys3++vN353auzYsUO1a9eWJO3cudPjOhYNBwAAQKiYEb6QX7ALDklKSUlRkyZN1K5dO40ZMybHdp9++mmtXbtWL7zwgkqUKKGJEydq4MCBevvtt/2/0yHwzjvvqGjRotq4caM2btzocZ1hGHRqAAAAICQivb6QpHnz5ql79+7q2rWrJGn8+PH64osvtHTp0hzXqFuwYIFatmype++9V5I0ZMgQrV+/XosWLdKECRNUokQJzZs3z+M2Y8eOVbdu3XTw4EFVqFDBvb9YsWIqW7as3znnB787NRYuXJgfeQAAIozTsGhRyWbu7UjndDi1aPrH7m0ACLdgFxyS1LlzZ0nSgQMHcmzzzJkzWrp0qaZOnaprr71WUmYnR/v27bV582Y1atQoyPcycJ999lm4UwAAhIhDFi3QFe7tkLdvd2jB+CXubQCIBMnJyR6XY2NjFRsbmy0uIyND27Zt0wMPPODeZ7FY1Lx5c/344485Hnvz5s3q06ePx74WLVro008/zTUfwzBUsmRJj/2vvfaaXn75Zf3jH//Qrbfeqj59+mQbZR0qeW5179692rdvn6666irFx8fLNE1GagBAAeIwrHoj4Zpwp+Ezh92pN6avDncaAELIJUMK5ZlUymzLl6IjVAXHhbZu3Sq73a7mzZu791WrVk0VKlSI2E6NczIyMnTgwAFVrlw5bMURACB/OQyLFhp1w9e+3amFE5aErX0AkS1c9UXW6WYlaeDAgXrooYeyxZ88eVJOpzPbqO/SpUtr9+7dObZx7NixbNPQli5dWseOHcsxPj09XVOnTlWHDh1UvHhx9/6ePXvqiiuuUEJCgn788Uc999xzSkpKCttSFH5XCydPntSQIUP07bffyjAMrV69WpUqVdLo0aOVkJCgRx99ND/yBAAAACKCL0VHKAoOb8ew2WzZzqoqXbq0kpKSfD5OKKWmpmrixIlasWKFJOnjjz9WpUqVNHHiRJUvXz7HUS0AAABAQbF27VqPDoScRmmEgt1u1+DBg2WapsaPH+9xXd++fd3btWvXls1m07hx4zR06NCw5Ov3WL9JkyYpJiZGX3zxheLj493727dvr3Xr1gU1OQBA+Bimqcr246psPy7DNMOdzkUZhqHKNcqrco3yjBwECgnTDP2flFl0bNq0yf2XdTQG/Ddt2jT9+uuvWrBggeLi4tz7r732Wq1atSqMmQEAgs0wTVUx/1IV86+w1BiGYajKFRVV5YqK1AwAsglXfVG8eHGPP2+dBKVKlZLVatXx48c99h8/fjzbyVHnlClTJttJUjnF2+12DRkyRAcPHtTcuXM9Olly0rBhQzkcDq/T4uY3vzs1vv76aw0fPlyXXnqpx/6qVavq4MGDQUsMABBesaZDrxxepFcOL1KsGfnzzcbG2/TKxyP0yscjFBtvC3c6AAowX4qO/Cw4clOmTBnZ7XadPn0623EiZVG/C61Zs0aPP/64mjZt6rG/Ro0a2rdvX5iyAgDkhzg5NdtcrdnmasUp9OvgxRWJ1eyfn9Psn59TXJHwnAkNAHkVGxurunXrasOGDe59LpdLGzZsUOPGjXO8TaNGjfTNN9947Fu/fr3HtLTnOjT27t2r119/XaVKlbpoLtu3b5fFYsk2Mj1U/O7USElJ8Rihcc6pU6fCNjQGAAAAiCT5VXBcTL169WSz2Tza3b17tw4ePBix62mcOHEix2IoNTWVs2gBAACALPr27avFixdr+fLl2rVrl5544gmlpqbqtttukySNGDFC06ZNc8f36tVL69at09y5c7Vr1y7NmDFDW7duVY8ePSRldmgMGjRIW7du1dSpU+V0OpWUlKSkpCRlZGRIkn788Ue9/vrr+vXXX7V//3699957mjRpkjp16qSEhITQPwjKw5oaTZs21YoVKzRkyBD3PpfLpdmzZ6tZs2bBzA0AAADwyiVDUugX8vNV3759NXLkSNWrV08NGjTQ/PnzsxUc5cuX19ChQyVlFhw9e/bU3Llz1apVK61atUpbt27VhAkT3Mc8deqUDh06pKNHj0qS/vjjD0mZIzTKli2rEiVKqGvXrpo8ebISEhJUvHhxPfnkk2rcuHHEdmrUq1dPX3zxhXr27Omxf8mSJRGbMwAAAAqeSK8vpMwlIE6cOKEXX3xRSUlJqlOnjmbPnu0e3X3o0CFZLOfHMTRp0kRTp07VCy+8oOeee05Vq1bVrFmzVLNmTUnSkSNH9Nlnn0mS/v3vf3u0tWDBAjVr1kyxsbFatWqVZs6cqYyMDFWsWFF9+vTxWGcj1Pzu1Bg+fLj69OmjrVu3ym6369lnn9Xvv/+uv/76S2+99ZZfx/ruu+80Z84cbd26VUlJSZo1a5Zat27tvv7RRx/V8uXLPW7TokULzZkzJ9fjvvHGG5ozZ46SkpJUu3ZtjR07Vg0aNPArNwAAACAQwS44JOmzzz7TqFGj3JcffvhhSZ6LlY8ePVoWi0WDBg1SRkaGWrRooXHjxoXiLufJww8/rPvuu0+///67nE6nFixYoF27dunHH3/UwoUL/T4eNQYAAAAKsh49erhHWlwop+/P7dq1U7t27XKMr1ixonbs2JFre3Xr1tXixYv9TzQf+d2pUbNmTX388cdatGiRihUrppSUFLVp00Z33323ypUr59exUlJSVKtWLXXt2lUDBw7MMaZly5aaNGmS+/LFprhatWqVJk2apPHjx6thw4aaP3+++vXrp48++ihsc3wBAAAg+EzTkGmG8EyqPLQVzIJDkm677Tb3SA9v4uLiNG7cuIjuyMiqadOm+t///qdXX31VNWvW1Ndff60rrrhCb7/9tmrVquX38agxAAAAkBfRUF8gk9+dGpJUokQJ9e/fP+DGW7VqpVatWuUaExsb69eihvPmzVP37t3VtWtXSdL48eP1xRdfaOnSpbr//vsDyhcAAABA8FWuXFlPPvlkUI5FjQEAAAAUbH4vFN6mTRvNmDFDe/bsyYd0stu4caOuvfZa3XzzzRo3bpxOnjzpNTYjI0Pbtm1T8+bN3fssFouaN2+uH3/8MRTpAgAAIERcphHyPwRfnz59tGzZMiUnJ4esTWoMAAAAXIj6Inr4PVLj7rvv1sqVKzVr1izVrVtXnTp1Uvv27f0608lXLVu2VJs2bVSxYkXt379fzz33nO677z698847slqt2eJPnjwpp9OZbQh46dKltXv37qDnBwAFmdOw6N0STdzbkc7pcOrdVz93bwMAokP16tX13HPPafz48WrVqpU6deqkVq1ayWaz5Ut71BgAED4OWbRYNd3bIW/f7tDiqe+5twEA0cnvTo0+ffqoT58++uOPP7Ry5Uq9+eabeuaZZ9SsWTN16tRJnTt3DlpyHTp0cG/XqlVLtWrVUuvWrd1nVgEA8o/DsGrOJS3DnYbPHHan5kx+P9xpAAD8NGbMGI0ePVrr16/X+++/r5EjR8pqtermm29Wx44ddfXVVwe1PWoMAAgfh2HRa0bD8LVvd+q1kYvC1j4AIDjy3C1++eWXa9CgQfr444/1xhtv6MSJExo1alQwc8umUqVKKlWqlPbu3Zvj9aVKlZLVatXx48c99h8/flxlypTJ19wAAAAQWqYZ+j/kD4vFohYtWmjy5Mlav369xo8fry1btqh379753jY1BgAAACTqi2gS0Fi/LVu26KmnntLAgQO1Z88e3XLLLcHKK0eHDx/WqVOnvE51FRsbq7p162rDhg3ufS6XSxs2bFDjxo3zNTcAKGgM01Q5x2mVc5yWEQWftIZhqNxlpVTuslIyDOalBIBolJSUpLfeekuvvfaaduzYofr16+d7m9QYABA6hmmqvHlW5c2zYakxDMNQ+SplVb5KWWoGAIhifk8/dW7aqQ8++EAHDhzQNddco2HDhqlNmzYqVqyYX8c6e/as9u3b57584MABbd++XQkJCUpISNDMmTN18803q0yZMtq/f7+effZZValSRS1bnp8OpXfv3mrTpo169OghSerbt69GjhypevXqqUGDBpo/f75SU1N12223+XtXAaBQizUdmn9oniSp82UPKt3In7nNgyU23qb568ZIkjrXHaX01IwwZwQgv5mmITOEi+uFsq3CJDk5WR9//LHef/99bdy4URUrVlTHjh31wgsvqHLlyn4fjxoDACJXnJxaZK6SJHU0uijN/5+lAmu/SKwW7Z6V2X6JnkpLSQ9p+wAiG/VF9PD706Ndu3aqX7++/u///k8dOnQIaMj11q1b1atXL/flSZMmSZK6dOmiJ554Qjt37tSKFSt05swZlStXTv/61780ePBgxcbGum+zf/9+nTx50n25ffv2OnHihF588UUlJSWpTp06mj17NkPDAQAAgAjUvHlzlSxZUu3bt9cjjzwS8OgMagwAAACgYPOrU8PpdGrChAm6+eablZCQEHDjzZo1044dO7xeP2fOnIse47PPPsu2r0ePHu6zqgAAAFAwcSZV9DNNU2PGjFHHjh1VpEiRoByTGgMAAAB5QX0RPfxaU8NqtWrixIk6ffp0fuUDAAAAoJAwTVMTJkzQkSNHwp0KAAAAgCjh9/RTNWrU0IEDB1SpUqX8yAdZGLbA5pY0051hzyEYAr0fwbgPliLxAd3emR74PJ0B34/ESwLOwXI6OaDbmw5HwDkEej9c8YGvC3H28pIB3d52JrDndOyxuIBuL0lm7MWfTy5nhvTn39vlL5HTen5aDmsQ/i/NksUDur29bAmPy9Ys/7eOCqVkT7Nf9BinagR2VvCJeoEvbri7y38Dun333TcFnMPpmeH/vAFQOFksFlWpUkWnTp0KdyoAEF5hWDQ7LO1nbcc0JYX4fl/Yfrgf95yYgX+3Nl1ByAMAIphfIzUkaciQIZoyZYo+//xzHT16VMnJyR5/AAAAQCi4TCPkfwi+oUOH6plnntHOnTvDnQoAAAAKMeqL6OH3qZn333+/JKl///4yjPMPvGmaMgxD27dvD152AAAAAAq0kSNHKjU1Vf/+979ls9kUH+85Qnbjxo1hygwAAABAJPK7U2PBggX5kQcAIMI4DYveK3eVezvSOZ0u/W/Z9+5tAAVfqGeNiMQZKgqC0aNHhzsFAECIOGXoPVVzb4e8fYdT7730kXsbALKivogefndqXH311fmRBwAgwtgtMZpZpUO40/CZ3e7UjOc/DncaAAA/denSJdwpAABCxG5YNUONw9d+hkMzBs4JW/sAgODI06m333//vYYNG6Y777xTR44ckSStWLFC33//fVCTAwAAALwxTSPkf8gf+/bt0/PPP69HHnlEx48flyStXbtWv/32W5gzAwAAQGFBfRE9/O7U+Pjjj9WvXz/Fx8dr27ZtysjIkCQlJyfrlVdeCXqCAIAwMU0l2M8qwX42asZEJlxSVAmXFA13GgAAP2zcuFEdO3bUli1btHr1aqWkpEiSduzYoRkzZoQ5OwBAUJmmEsx0JZjpYasxEsqUVEKZkmFpGwAQHH53arz88ssaP368nnzyScXEnJ+9qkmTJvrll1+CmhwAIHziXXYt2fyslmx+VvEue7jTuaj4eJuWrnxYS1c+rPh4W7jTAQD4aNq0aRoyZIjmzZsnm+38+/c111yjzZs3hy8xAEDQxcupd7VS72ql4hX6NS3ii8bp3aNz9O7ROYovGhfy9gEAweH3mhp//PGHmjZtmm1/iRIldPr06aAkBQAAAFxcaIdsMzw8f+zcuVNTp07Ntj8xMVEnT54MQ0YAAAAonKgvooXfIzXKlCmjffv2Zdu/adMmVapUKShJAQAAACgcSpQooaSkpGz7t2/frvLly4chIwAAAACRzO9Oje7du+upp57STz/9JMMwdOTIEb333nuaMmWK7rrrrvzIEQAAAMiRGcI/5I8OHTpo6tSpSkpKkmEYcrlc2rRpk6ZMmaLOnTuHOz0AAAAUItQX0cHv6afuv/9+uVwu9enTR6mpqerRo4diY2N1zz33qGfPnvmRIwAAAIAC6uGHH9aECRN0/fXXy+l0qkOHDnI6nbr11lvVv3//cKcHAAAAIML43alhGIb69++vfv36ad++fUpJSVG1atVUrFix/MgPAAAAyJFpSgrlPLSmxKy3wRcbG6snn3xSAwYM0M6dO3X27FldccUVqlq1arhTAwAAQCFCfRE9/J5+atSoUUpOTlZsbKyqV6+uBg0aqFixYkpJSdGoUaPyI0cAAAAABdTMmTOVmpqqf/zjH2rVqpXat2+vqlWrKi0tTTNnzgx3egAAAAAijN+dGitWrFB6enq2/Wlpafrf//4XlKQAAOHnNCxaXbqhVpduKKfh98dFyDmdLn384U/6+MOf5HS6wp0OAMBHs2bNUkpKSrb9qampmjVrVhgyAgDkF6cMrVYVrVYVOcNwfrLT4dTq17/Q6te/kNPhDHn7AIDg8Hn6qeTkZJmmKdM0dfbsWcXFxbmvczqd+vLLL5WYmJgvSQIAQs9uidHUf3YJdxo+s9udevbp98OdBoBQCvUKe6zmly9M05RhZP9h69dff1VCQkIYMgIA5Be7YdWzuip87Wc49Ow9dJgD8IL6Imr43KnRtGlTGYYhwzB08803Z7veMAw99NBDQU0OAAAAQMF01VVXedQXWTs2nE6nUlJSdOedd4YxQwAAAACRyOdOjQULFsg0TfXu3VszZszwOGvKZrOpQoUKKl++fL4kCQAIA9NUvMsuSUqz2KQczqKNNPHxNklSWpo9zJkACAXTNEK8kJ/BQn5BNHr0aJmmqdGjR+uhhx5SiRIl3NfZbDZddtllaty4cRgzBBASUfAd86LMIJxqa7EGmEOA06+GarpZ01S8Mqd9SpM1LP//8UUzZx5JS8k+tbphiYDnYxD+LwxrYMcwg/CcNnOYuh6IdNQX0cPnTo2rr75akrRmzRr94x//kMUS+fOrAwDyLt5l13s/PC1J6tRktNKssWHOKHfx8Ta9/8kISdKtbZ6hYwMAIlyXLplTHFasWFGNGzeWzWYLc0YAgPwWL6dWupZKkjpauirN95+lgtN+0TitPD0/s/2SvXPs2AAARD6/Pz0uu+wynT59Wlu2bNHx48ez9d527tw5WLkBAAAAXpnMeVsgXH311XK5XPrjjz9yrC+uuip8c68DAACg8KC+iB5+d2p89tlnGjZsmFJSUlS8eHGPuW8Nw6BTAwAAAIDPNm/erKFDh+rgwYPZOjQMw9D27dvDlBkAAACASOR3p8aUKVPUtWtXPfLIIypSpEhAjX/33XeaM2eOtm7dqqSkJM2aNUutW7d2X1+rVq0cbzd8+HDde++9OV43Y8YMzZw502Pf5Zdfro8++iigXAEAAAAE37hx41SvXj29+uqrKlu2rMdJU3lBjQEAAAAUbH53ahw5ckS9evUKuENDklJSUlSrVi117dpVAwcOzHb9V1995XH5yy+/1GOPPaabb7451+PWqFFD8+bNc1+2WgNccAsAAAARJxwL+SH49u7dqxdffFFVqlQJyvGoMQAAAJAX1BfRw+9OjRYtWujnn39WpUqVAm68VatWatWqldfry5Yt63F5zZo1atas2UXbtlqt2W4LAAAAIPI0aNBAe/fuDVqnBjUGAAAAULD53anRqlUrPfvss9q1a5dq1qypmBjPQ9x0001BSy6rY8eOae3atZo8efJFY/fu3asWLVooLi5OjRo10tChQ1WhQoV8yQsAAABhwplUBULPnj01ZcoUHTt2LMf6onbt2vnWNjUGAAAA3KgvoobfnRpjx46VJM2aNSvbdfm5kN/y5ctVrFgxtW3bNte4Bg0aaNKkSbr88svdc+jefffdWrlypYoXL54vuQFAQeQ0DH1Z6gr3dqRzulxa+/l29zYAIDo89NBDkqTRo0e79xmGIdM0832hcGoMAAgtpwx9qYru7ZC373Tpy3e/cW8DAKKT350av/76a37kcVFLly5Vx44dFRcXl2tc1qHmtWvXVsOGDXXDDTfoww8/VLdu3fI7TQAoMOwWm56s3j3cafjMnuHUxMeXhTsNACFkmpLMUDYYwrYKkTVr1oStbWoMAAgtu2HVROu/wtd+ul0T73whbO0DiGzUF9HD706NcPj+++/1xx9/6IUXXvD7tiVLllTVqlW1b9++4CcGAAAAICCXXXZZWNqlxgAAAACik8+dGgsWLPAprlevXnlOxpt3331XdevWzdN8umfPntX+/ftZ1A8AAACIEGvWrNF1110nm8120ZEa+bVmHzUGAAAAEJ187tR4/fXXLxpjGIZfnRpnz571OLvpwIED2r59uxISEtyL7iUnJ+ujjz7SyJEjczxG79691aZNG/Xo0UOSNGXKFN1www2qUKGCjh49qhkzZshisejWW2/1OS8AgBTvzNB7PzwtSerUZLTSrLFhzih38fE2vf/JCEnSrW2eUVqaPcwZAQgJhmxHpQEDBujrr79W6dKlNWDAAK9xeVlTgxoDACJXvOnQStdSSVJHS1elGaGdQCS+aJxWnp6f2X7J3kpLSQ9p+wCiAPVFVPD50+Ozzz4LeuNbt2716ASZNGmSJKlLly6aPHmyJOmDDz6QaZpeC4b9+/fr5MmT7suHDx/WI488olOnTikxMVFXXnmlFi9erMTExKDnDwAAAMB/WdfpC/aafdQYAAAAQMEW1jU1mjVrph07duQac8cdd+iOO+7wev2FnS3PP/98UHIDAABAZDNNQzKNEDYYwraQZ9QYAAAAyAvqi+hhCXcCAAAAAAAAAAAAvgjrSA0AAAAgz0yFds5b5tcFAE9GEM4wNQrAuZamM+BDGJbAHkvTFdjjaFitAd3+7yQu3o5pSH+HGRZDRtbnUDCeCxfJIevjbFiM7I97BDwfDWsQcrDZAsvBdfH/y4sx01mvBFGI+iJqhP/dGgAAAAAAAAAAwAd0agAAAAAAAAAAgKjg9/RTPXr00O23365bbrlF8fHx+ZETACACOA1D3ybUcG9HOqfLpW83/O7eBlDwsZBfwUB9AQCFh1OGvjX+4d4OeftOl75d9aN7GwCyor6IHn53atSpU0dTpkzRxIkT1a5dO91+++1q1KhRPqQGAAgnu8WmsTXvDncaPrNnOPXYiHfCnQYAwE/UFwBQeNgNq8bGtApf++l2je38TNjaBwAEh9/TTz322GNat26dJk2apOPHj6tHjx5q37695syZo2PHjuVHjgAAAEB2Zhj+EHTUFwAAAIgI1BdRI09rasTExKht27Z6+eWXtXbtWt16662aPn26rr/+ej344IPasGFDsPMEAAAAUEBRXwAAAADwVUALhW/ZskUvvvii5s2bp9KlS+v+++9XqVKl9J///EdTpkwJVo4AgDCId2bovU1P6b1NTynemRHudC4qPt6mlauHa+Xq4YqPt4U7HQAhY4T4D/mJ+gIACrZ406H37Ev0nn2J4k1H6NsvGqf3Ts7TeyfnKb5oXMjbBxANqC+igd9rahw/flz/+9//tGzZMu3Zs0c33nijpk2bppYtW8r4eyHZLl266L777tPIkSODnjAAIHTiXfZwp+CXIkViw50CAMBP1BcAULjEyxne9ovFh7V9AEDg/O7UaNWqlSpVqqSuXbvqtttuU2JiYraY2rVrq169ekFJEAAAAEDBRX0BAAAAwB9+d2q8/vrratq0aa4xxYsX18KFC/OcFAAAAHBRoV5cj4X88gX1BQAAACIC9UXU8HtNjRdffFGnT5/Otj85OVm9evUKSlIAAAAACgfqCwAAAAD+8HukxnfffSe7Pfsc6+np6dq0aVNQkgIAAAAuijOpCgTqCwAAAEQE6ouo4XOnxq+//ipJMk1Tv//+u5KSktzXuVwurVu3TuXLlw9+hgAAAAAKHOoLAAAAAHnhc6dG586dZRiGDMNQ7969s10fHx+vMWPGBDU5AED4uAxDP5Wo4t6OdC6XqZ9+3OveBlAImEbmXyjbQ9BQXwBA4eOS9JNR1r0d8vZdLv209hf3NgB4oL6IGj53aqxZs0amaap169ZasmSJEhMT3dfZbDaVLl1aVqs1X5IEAIRehsWm4bX7hjsNn2VkODR00KJwpwEA8BH1BQAUPhlGjIbH3BS+9tPsGt5mYtjaBwAEh8+dGpdddpmk88PEAQAAACCvqC8AAAAA5IVPnRpr1qzRddddJ5vNpjVr1uQae9NN4etxL3CcznBnEBk5BCoI98HMyL54ZcgFeD+M08kBp2CmpAZ2gCD8XwR6P4xUW8A5FI31uT84R5bUwJ5PxumzAd1ekmQL7D4E/FyQFOggy8DuQaaSsZYAjxAXcA71vrk7oNtn/Foy4Bz+6fwu4GMA4WCykF/Uor4AJAU6vacZhDclS2CjoYwgjKYyYgP/fh6wAB9LV1p6wClYihcL6PaB1qxGXODfa2UGOJ2TEeh3cwVec0bA89GIjw/4GGaxIoEdIBi/Bf3+R+DHAEKM+iJ6+PSb0IABA/T111+rdOnSGjBggNc4wzC0ffv2oCUHAAifOFeG5u99TZLUu8p9SrfEhjmj3MUVsWn+mpGSpN43TVF6gJ1HAID8Q30BAIVTnGnX/L8WS5J6J3RXuhHaToS4orGav+WZzPYbjFB6SkZI2wcABIdPnRpZh4QzPBwACo8EV+AjMkLpksTi4U4BQChxJlXUor4AgMLrEjMtvO2XKRHW9gFEMOqLqBGEsX3S6dOng3EYAAAAAKC+AAAAAOCV350ar776qlatWuW+PGjQIF199dVq2bKl32dZvfLKK+ratasaN26sa6+9Vg8++KB2797tEZOenq7x48erWbNmaty4sR566CEdO3Ys1+Oapqnp06erRYsWatCggfr06aM9e/b4lRsAAAAinGmE/g9BR30BAACAiEB9ETX87tR4++23demll0qSvv76a23YsEGzZ8/Wddddp2eeecavY23cuFF33323Fi9erHnz5snhcKhfv35KSUlxxzz99NP6/PPP9cILL2jhwoU6evSoBg4cmOtxX3vtNS1cuFBPPPGEFi9erCJFiqhfv35KTw988S4AAAAAwUN9AQAAAMAfPq2pkdWxY8f0j3/8Q5L0+eefq127dmrRooUuu+wyde/e3a9jzZkzx+Py5MmTde2112rbtm266qqrdObMGS1dulRTp07VtddeKymzCGnfvr02b96sRo0aZTumaZpasGCB+vfvr9atW0uSnnnmGTVv3lyffvqpOnTo4O9dBgAAAJBPqC8AAAAA+MPvkRolS5bUoUOHJEnr1q1zFwOmacrpdAaUzJkzZyRJCQkJkqStW7fKbrerefPm7phq1aqpQoUK2rx5c47HOHDggJKSkjxuU6JECTVs2FA//vhjQPkBAAAgchiSDDO0fwg+6gsAAABEAuqL6OH3SI22bdtq2LBhqlKlik6dOqXrrrtOkrR9+3ZVqVIlz4m4XC49/fTTatKkiWrWrCkp86wtm82mkiVLesSWLl1aSUlJOR7n3P7SpUtnu83F5soFAJxnytDOuPLu7Uhnukzt/Hm/exsAEB2oLwCg8DBlaKe1jHs75O27TO384Q/3NgBEozfeeENz5sxRUlKSateurbFjx6pBgwZe4z/88ENNnz5df/75p6pWraphw4apVatWkiS73a4XXnhBX375pfbv36/ixYurefPmGjp0qMqXL+8+xqlTpzRx4kR9/vnnslgsatu2rR577DEVK1Ys3+9vTvweqTFq1CjdfffdqlatmubNm+dOPCkpSf/3f/+X50TGjx+v3377Tc8//3yejwEACJ4Mi02DK/bU4Io9lWGxhTudi8pId2hQt1ka1G2WMtId4U4HQCiYYfjz0xtvvKEbb7xR9evXV7du3bRly5Zc4z/88EPdcsstql+/vjp27Ki1a9d63mUfFqz+448/1L9/fzVr1kxNmjTRXXfdpW+++cbnnP2JDQbqCwAoPDKMGA0q+W8NKvlvZRh+n2cbePtpdg268UkNuvFJZaTZQ94+gAgXBfXFqlWrNGnSJA0YMEDLly9X7dq11a9fPx0/fjzH+B9++EFDhw7V7bffrhUrVuimm27SgAEDtHPnTklSWlqafvnlF/Xv31/Lli3TzJkz3fVEVsOGDdPvv/+uefPm6b///a++//57Pf744z7nHewaw+9ODZvNpn79+mnMmDG64oor3Pv79Omjbt265SmJCRMm6IsvvtD8+fPdiwRKUpkyZWS323X69GmP+OPHj6ts2bI5Huvc/gv/I48fP64yZcrkKT8AAADAX8EuOCTfFqz+z3/+I6fTqfnz52vZsmWqXbu2/vOf/3gdiXChe++9V61bt9ZLL73knhYqP1FfAAAAAL6ZN2+eunfvrq5du6p69eoaP3684uPjtXTp0hzjFyxYoJYtW+ree+9VtWrVNGTIEF1xxRVatGiRpMxpVefNm6f27dvrn//8pxo1aqSxY8dq27ZtOnjwoCRp165dWrdunZ588kk1bNhQTZs21ZgxY/TBBx/oyJEjPuUd7BrD706N5cuX64svvnBffuaZZ9S0aVPdeeed+vPPP/06lmmamjBhgj755BPNnz9flSpV8ri+Xr16stls2rBhg3vf7t27dfDgwRwX8ZOkihUrqmzZsh63SU5O1k8//aTGjRv7lR8AAAAimGmE/k+Z3y2z/mVkZOSYXrALjgsXrK5du7aeeeYZHT16VJ9++qkk6cSJE9qzZ4/uv/9+1a5dW1WrVtXQoUOVmpqq3377zaeH9csvv1SPHj308ccfq3Xr1urXr59WrVrl9X4GivoCAAAAESHC64uMjAxt27bNY603i8Wi5s2be13rbfPmze41685p0aKF1/XkzuVjGIZ7ytYff/xRJUuWVP369d0xzZs3l8ViuehI9HOCXWP43anx3//+V3FxcZIy79Cbb76p4cOH65JLLtGkSZP8Otb48eP13nvvadq0aSpWrJiSkpKUlJSktLQ0SZk9RV27dtXkyZP1zTffaOvWrRo9erQaN27sUXTccsst+uSTTyRJhmGoV69eevnll7VmzRrt2LFDI0aMULly5dS6dWt/7y4AFFpxLrte3/uqXt/7quJckT80Oy7epvlrRmr+mpGKi4/86bIARK9WrVrpyiuvdP+98sor2WLyo+DwZcHqUqVK6fLLL9eKFSuUkpIih8Ohd955R6VLl1bdunV9un+JiYnq06eP/ve//2nx4sWqWrWqxo8fr5YtW+rJJ5/Ur7/+6tNxfEV9AQCFR5zp0Py/3tH8v95RnBn6KWPjisRq/pYpmr9liuKKxIa8fQDIiS/1hSSdPHlSTqfTr7Xejh07lm10cW7x6enpmjp1qjp06KDixYu7j5GYmOgRFxMTo4SEBJ9Hgwe7xvB7AsPDhw+7F+z79NNP1bZtW91xxx1q0qSJevbs6dex3nrrLUnKdrtJkybptttukySNHj1aFotFgwYNUkZGhlq0aKFx48Z5xP/xxx86c+aM+/J9992n1NRUPf744zp9+rSuvPJKzZ49210sAQB8Yaq847R7O+IZUvnLSrm3ASC/rF271v0FX5JiY7P/KJJbwbF79+4cj3uxgsOXBasNw9Drr7+uBx98UE2aNJHFYlFiYqJmz56thIQEP++pVLduXZUpU0aXXHKJXn31VS1dulRvvvmmGjVqpPHjx6tGjRp+H/NC1BcAUJiYKu9Kdm+HnCGVr1zGvQ0AkcCX+iIU7Ha7Bg8eLNM0NX78+HxrJxg1ht+dGkWLFtWpU6dUoUIFff311+rTp48kKS4uzmMuX1/s2LHjojFxcXEaN25ctkIjt+MYhqHBgwdr8ODBfuUDAACAKJLHxfUCak9S8eLFPYqOSHKuACldurTeeOMNxcfHa8mSJfrPf/6jd999V+XKlfPpOHa7XWvWrNHSpUu1fv161atXT48//rg6dOigEydO6IUXXtDgwYO1atWqgHOmvgAAAEBEiPD6olSpUrJarX6t9VamTJlsozJyirfb7RoyZIgOHjyo+fPne+RTpkwZnThxwiPe4XDor7/+8rouXU6CWWP43anRvHlzjRkzRnXq1NGePXvUqlUrSdJvv/2myy67zN/DAQAAAAVOfhQcWReszto5cfz4cdWuXVuS9M033+iLL77Qd9995y5E6tatq/Xr12vFihW6//77L5r7xIkT9f7770uSOnXqpOHDh6tmzZru64sWLaqRI0eqZcuWFz2WL6gvAAAAgIuLjY1V3bp1tWHDBvc0qC6XSxs2bFCPHj1yvE2jRo30zTffuE8ckqT169d7TL16rkNj7969WrBggUqVKuVxjMaNG+v06dPaunWr6tWrJymz7nC5XGrQoIFPuQe7xvC7U2PcuHF64YUXdOjQIb344ovuO7lt2zZ16NDB38MhN4bfS54UzBwCFYz7YETAuNRA70dcEIau2QNcVyEY/xcB3g/T5vfbXjaO4oHlEBPg88mSHoSFWmMvvuaE6cqyHR8r05LlfgfhcQz4//KCOXDNLOtomPGxMn0YT55RMrD7kVY68PeGDpdvC+j2S5KbBJxDgXivR+EUpjOpfJEfBUfWBavr1Kkj6fyC1XfddZckKTU1VVLmyIKsDMOQy+WSL37//XeNHTtWbdu29Tr0vVSpUlqwYIFPx7sY6gsUWmYETO/pcgZ0czPA20uS6Yj8tdsuKgj/l87TyRcPyjUH397jvUrzb2RcXrmyrKPhOn1WTiMIdYU/7buytJ+cImeK5/02LJFQ+5+5eMzFDmEN7Pu9GQnvT0A4RHB9cU7fvn01cuRI1atXTw0aNND8+fOVmprqnmp1xIgRKl++vIYOHSpJ6tWrl3r27Km5c+eqVatWWrVqlbZu3aoJEyZIyuzQGDRokH755Re98sorcjqd7mlvExISFBsbq2rVqqlly5YaO3asxo8fL7vdrokTJ6pDhw4qX768T3kHu8bw+9OjZMmSevzxx7PtHzRokL+HAgAAAAqsYBccWResrlKliipWrKjp06d7LFjdqFEjlSxZUo8++qgGDBiguLg4LV68WH/++aeuv/56n/IeOHCgGjdurJgYz1LB4XDoxx9/1FVXXaWYmBhdffXVQXmcqC8AAAAA37Rv314nTpzQiy++qKSkJNWpU0ezZ892j+4+dOiQLJbzHZtNmjTR1KlT9cILL+i5555T1apVNWvWLPcoiSNHjuizzz6TJP373//2aGvBggVq1qyZJGnq1KmaOHGievfuLYvForZt22rMmDE+5x3sGiNPXeLff/+93n77bR04cEDTp09X+fLltWLFClWsWFFNmzbNyyEBAAAA/0T4mVTBLjikiy9YfW5R8BdeeEG9e/eW3W5XjRo1NGvWLPcUVRfTq1cvffXVV9kWJD9z5ox69eql7du3+/dA+ID6AgAAAGEX4fXFOT169PA6+nvhwoXZ9rVr107t2rXLMb5ixYo+rUt3ySWXaNq0af4lmkWwawy/OzU+/vhjjRgxQh07dtS2bduUkZE5DUpycrJeeeUVig4AKDAM7Y0r496OBnt3HQ13CgDgIZgFh+TbgtX169fXnDlz/E/2b6ZpZpu+SpJOnTqlIkWK5Pm43lBfAEDhYUrao5Lu7ZC3b5ras22/exsAEBrBrjH87tR4+eWXNX78eHXu3FkffPCBe3+TJk308ssv+50AACAypVtseqD6xReUjRTpaXbdf/vMcKcBAFFr4MCBkjI7Th599FGPuW6dTqd27Nihxo0bB71d6gsAKDzSjRjdZ/XeeZ/v7adm6L6Gw8PWPgAUNvlVY/jdqfHHH3/keLZUiRIldPr0ab8TAAAAAPLENDL/QtleAVaiRAlJmWdRFStWTPHx8e7rbDabGjVqpG7dugW9XeoLAAAARATqi6DLrxrD706NMmXKaN++fapYsaLH/k2bNqlSpUp+JxDJ4orEyWpas+13Ol2yp9vdl+OLxnk9hstlKiMtI0+xcUVicxyWI2U+EdJTc4817UaOsbHxsbJYvL9o0lLSs8TaPOZ6zi3WFmeT1ZoPsbExssZk/3/wNdawne8BTE/NcA8xjbFZFWPz/hK4MNZq856DPc0ul8t7rGk63NsZaXa5XC5JkjXGKlus9xwy0u1yOf2PtVgtio2zeVxvKXL+cXDYHXI6zsfmdlyPWIshW7zNa6zT7pTD7vQaazrOP/8ddoc71jAMxWXJL6ccssbG5pKDy+mUPcPpvnzhcc0s/zcuh0t2e9bY3I5ryp5x/v8xPrfHwel53AtjY85fJZdpKiPdt+NeGBsXb/M+K5SZOXLBa2yszWtsbFyMjFzeI9JTs8TG23KPTTn/3mOLi5Ely+veuOD/Juv7lC3WMzZ7DllibdbcY7PctwtjnRe8TtIz7Do3Cj0mxqIYq/fXfXrG+ePGWC2y5fJeme5wynXu/eSCWJvF83PB4bLL1N+vOVlltXh/fTpdWXIwLLJZvOeb4XLI+XcOVsNQbJbjXvjZZM9wyOn4+7Wcw/vJhbGOv9OwWCy5vj4ddqccdoffsRd/j/A91ulwer6Wc/lc9ivWj+8G0fI9wlvsxb5HIHpNmjRJknTZZZfpnnvuUdGiRUPSbmGqLwAAAIDCJL9qDL87Nbp3766nnnpKTz/9tAzD0JEjR/Tjjz9qypQpevDBB4OSVKRYfOg1FS9ePNv+bz/4QWM6Tjofd2S2ihSLzxYnST99sU3DbnzCfXnhHy/pkrIlc4zd8d3vGthslPvya5uf0aVVy+YYu+eXA7q/8Uj35RnrJ6rqFRVzjD2856h6/nOA+/Jza8er1lXVc4w9lXRa3cr3c19+6r0Ratjqihxj086mqVPi+djH3xmsZu28DxdqG3e3e3vkvP66rmszr7GdSt3j7qwY8t8H1LbP9V5jby/XT38dyzyL7z/P9VanB2/xGtuz5mAd2XtMktR3Qnd1e+RWr7H3NRqhvdv/lCTdOayjeo7u7DX2oVbjtfOHPyRJnR9sq/uevMNr7NAbxmnL2l8kSR3ub62HZt7rNfaxWydp46ofJEk33vUvDZ/9gNfYiXdN17plGyVJ//p3U419y/tc29OGvaVPl34nSbryulqaMPc+r7GzHl+q9xd+LUmqd00NPfO/oV5jZz+xVO/OWi1Jqt6gsl78ZLTX2IUTl2rhk8skSZVrV9Brm5/xGrvkuff12qi3JEllK1yi+V+N9Rq7cuFXeunxzOMmJBbT25smeo39ZNn3mvboYkmZHRr/++kpr7HrPtyipwYvcl9etWqY19hvvvldo0cvcV9eunSQinj5kfWnTXs0/MEF7ssLVgzSJaWK5Ri745c/9VDf83Okv7pqqMpXTMwxdu9vh/VAh+fcl19c+pCq1Lg0x9gjf55U75unui9PnX+fatbL+f3k1ImzuvO6p92Xn3z7ITX4V60cY9POpqtz1UHuy2Pn/UdXt6mfY6wktbv8Eff28Of/Ty3bN/Ia2/mKR5X69/agMZ3UtpP3957uN07WXydTJEn3D71Fne7w/t5z+/2v6HBS5vvJ/Xe31P91vtprbM9Bc3VSf2XG3ni1Hmx7rdfYO6e/qa0HjmTerkVjDb31uizXPuQR+/Lv47T7bOZ7xDWlW6tLRe/vEXN2n/8s6nx5XU1t7v097cEvl2vVvl8lSTdXqqWXruty/sq7PGOfvfcVfbLwS0lS07YN9OQK70P0Zwx+Xe/NyJwupl7L2pr2+Xivsa+OWKglU9+TJFVvcrlmbZzsNXbB+MVaOD7zdVS5zmWavfV5r7GLp76n10Zkrk1QrnIZLfrjJa+x7730kWYMzHwdJZQpqXePel93YPXrX+jZe2ZJyuxMWJm8yGvsl0s2aOId519zucWG6nvE7G3P69Kq5XKM3bNtv+6rf/41N3PjZFWtm/OPx/5+jwglQwrPhNwF3Lkh4qFSmOoLACjs4kyHZro+kSQNtLRRuuH3z1KBtV8kVjO/yaz7Bl7zmMeJGwBAfZF/gl1j+P3pcf/998vlcqlPnz5KTU1Vjx49FBsbq3vuuUc9e/YManIAAAAA8l+XLl30+uuvKyEhQZ07d/Y6ckeSli9fHtS2qS8AoPAwJFXVafd2yNs3DPeJHLl91gEAApefNYZhnptfx08ZGRnat2+fUlJSVK1aNRUrlvOZxdEoOTlZV155paodbBLW6afiSxYPcPqpjBxj/Zl+Kq5EsbBPPxVjuMI+/ZStWHxg00+dTXFv53X6qZgiRQKbfuof58/Wzev0U0ZKSmDTT50+63HcvEw/FXPZpWGffiqjYqnApp86e/79Iy/TT1lOJmfmm8/TT8W5MrT41+mSpO61ByvdkvlYpqfapSOZI54Cmn7qgs8Nf6efcl2SOZLu3JRScfE2Lfn8UUlStxsmu+9TbtNPpVQp4XlcP6efOlkt87UTyPRTbe761iPW3+mn3vm5UeZxA5h+qsaDv3jE+j39VGrmuBmmn2L6KSn3USrBcvjwYbVq1UoZff5PymFUbb7JyFDsq69r06ZNOY7mjWYzZ85Uv379VKRIEc2cOTPX2PwayVGQ6wvpfI1RcVddWVze36+BQqcg/LCct59VPOXyPc63HFyB3d7w/l02mOJNh1a6lkqSOlq6Ki3EIzXii8Zp5en5me2X7O3xe4KkXGubkAnC/4WRSy3lizz+VOh5jPT0iwcBPvrEteTiQQGgvsgf+Vlj+P3pcebMGTmdTl1yySWqXv381AOnTp1STExMgfoPSE9N96nguPBDMFix/gyDzCn2XKfGhbL+4HExGVl+DLwYe7pdvkb7FZvh8PhRyd9Yw5bzh7Ejyw/wFxNorMvL/7vT4XT/cHgx/sS6nK5szzWrl+eTy+ny+bnmcpkeP1L7G+vtcTBN0+fXxoU/rl3MhbGmI7eOLN+f72l+vDYujI3J5bb+HDc9kNhcnkruThaXXUrJ7JBLT7UrPYcv+P69R1zw2rTk/kO5z8e1O6ULXnPpafYcH58LY9PSvefvcLjkcPhWHDqcLjmceYu1u7w/911yyuXy8b3H9D0Hp2kq1Xn+vuf2+svp/cRrrCt/Yv19j8ivz+Voiw30e4Q3/nyPQPTIWkSEevqpwlRfAAAAAIVFftYYfnfdPvzww/rggw+y7f/www/18MMPByUpAAAAAOFx6NAhHT582H15y5Yteuqpp/TOO+/kS3vUFwAAAEDBFuwaw+9OjS1btuiaa67Jtv/qq6/Wli1b8pQEAAAAgMgwdOhQffPNN5KkpKQk9enTRz///LOef/75iw4bzwvqCwAAAKBgC3aN4XenRkZGhhyO7NOCOBwOpaWl+Z0AAAAAgMjx22+/qUGDBpIyR0vUrFlTb7/9tqZOnRr0RcIl6gsAAACgoAt2jeF3p0b9+vW1ePHibPvffvtt1a1b1+8EAACRytARW4KO2BLkfUXyyHL44EkdPngy3GkACBHDDP1fYeBwOBQbGytJWr9+vW688UZJ0j//+U8lJSUFvT3qCwAoPExJh1VUh1VU4fhYNU1Th/ck6fCepKAshg2gYKG+yD/BrjH8Xih8yJAh6tu3r3799Vdde+21kqQNGzbo559/1ty5c/1OAAAQmdItNvWuOSDcafgsPc2u3h2eD3caABD1qlevrrffflvXX3+91q9fryFDhkiSjh49qksuuSTo7VFfAEDhkW7EqKe1Y/jaT81Qz+oPha19ACisgl1j+N2pceWVV+qdd97R7Nmz9eGHHyouLk61atXSU089papVq/qdAIAQcboCP4YrArqQA7wfhjXw+2A4AnwsA7y9EYT/BzPQ50MwnguB5uAMPAeLPbBjWDICTkF7UxIDur2Z4vdHOVBwmEbmXyjbKwSGDRumgQMHas6cOercubNq164tSfrss8/cQ8aDifoCCCMjsPc1w2oNPIWY8H+XCfSMfTMj8C+FliLxgeWQwzR+/jD+Pns2IK4Av99b/J5MJDunM6CbR8LzUXFxAR/CKBrY8ykYvx84DvwZ8DGAkKO+yDfBrjHy9G5dp04dTZs2LS83BQAAABDBmjVrpm+++UbJyclKSEhw7+/evbuKFCmSL21SXwAAAAAFV7BrjDx1g+/bt0/PP/+8hg4dquPHj0uS1q5dq99++y0vhwMARKBYl10v7nldL+55XbEue7jTuajYuBi9+OYDevHNBxQbFwFnWAFAFLNarR7FhiRVrFhRpUuXzpf2qC8AoHCINR16MeV9vZjyvmLNwEaX5Kn9eJteXDtOL64dp9h4W8jbB4DCLJg1ht+/+mzcuFH33XefmjRpou+++05DhgxR6dKltWPHDi1dulQvvvii30kAACKPIVM10w67tyOdYTFUq15F9zaAQsD8+y+U7RUCx44d05QpU7RhwwadOHEi27Qs27dvD2p71BcAUHgYMlXLddy9HfL2LYZqXflP9zYAeKC+yDfBrjH87tSYNm2aezG/xo0bu/dfc801WrRokb+HAwAAABBBHn30UR06dEgPPvigypUrl+/tUV8AAAAABVuwawy/OzV27typqVOnZtufmJiokydP+nWsV155RatXr9bu3bsVHx+vxo0ba9iwYfrnPzN7zU+dOqUZM2boq6++0qFDh5SYmKjWrVtr8ODBKlGihNfjPvroo1q+fLnHvhYtWmjOnDl+5QcAAIAIxplU+WLTpk168803VadOnZC0R30BAACAiEB9kW+CXWP43alRokQJJSUlqVKlSh77t2/frvLly/t1rI0bN+ruu+9W/fr15XQ69dxzz6lfv3764IMPVLRoUR09elRHjx7VyJEjVb16df3555964okndPTo0YsOQ2/ZsqUmTZrkvhwbG+tXbgAAAEBh9I9//CPbcPD8RH0BAAAAFGzBrjH87tTo0KGDpk6dqunTp8swDLlcLm3atElTpkxR586d/TrWhWc2TZ48Wddee622bdumq666SjVr1tSMGTPc11euXFlDhgzR8OHD5XA4FBPjPf3Y2FiVLVvWr3wAAAAQPQzOpMoXo0eP1rRp0zR+/HhVrFgx39ujvgAAAEAkoL7IP8GuMfzu1Hj44Yc1YcIEXX/99XI6nerQoYOcTqduvfVW9e/fP6Bkzpw5I0nZVkHPKjk5WcWLF8+14JAyz9K69tprVbJkSV1zzTUaMmSISpUqFVB+AAAAQEH38MMPKzU1VW3atFF8fLxsNpvH9Rs3bgx6e9QXAAAAQMEV7BrD706N2NhYPfnkk3rwwQf122+/6ezZs7riiitUtWpVfw/lweVy6emnn1aTJk1Us2bNHGNOnDihl156SXfccUeux2rZsqXatGmjihUrav/+/Xruued033336Z133pHVag0oTwAoTE5Zi4Q7Bb+cOnE23CkAQNQbPXp0SNujvgCAwuWU4sLb/rHTYW0fAAqjYNcYfndqnFOhQgVVqFAhaImMHz9ev/32m958880cr09OTtYDDzygatWqaeDAgbkeq0OHDu7tWrVqqVatWmrdurX77CoAwMWlW2J1Z43B4U7DZ+mpdt1x/eRwpwEglBgeni+6dOkSlnapLwCg4Es3bLqj+J3haz8lQ3dUfShs7QOIcNQX+SbYNYbfnRpOp1PLli3TN998o+PHj8vlcnlcv2DBAr+TmDBhgr744gstWrRIl156abbrk5OTde+996pYsWKaNWtWtuEpF1OpUiWVKlVKe/fupegAAAAALmLfvn1aunSp9u/fr8cee0ylS5fW2rVrVaFCBdWoUSOobVFfAAAAAAVfMGsMi7+NP/XUU3r66afldDpVo0YN1a5d2+PPH6ZpasKECfrkk080f/58VapUKVtMcnKy+vXrJ5vNppdffllxcf4PUzx8+LBOnTrFwn4AAAAFiRmGv0Jg48aN6tixo7Zs2aLVq1crJSVFkrRjxw6PRbaDhfoCAAAAEYH6It8Eu8bwe6TGBx98oBdeeEGtWrXyu7ELjR8/Xu+//75eeuklFStWTElJSZKkEiVKKD4+XsnJybrnnnuUmpqqZ599VsnJyUpOTpYkJSYmuuevveWWWzR06FC1adNGZ8+e1cyZM3XzzTerTJky2r9/v5599llVqVJFLVu2DDhnACgsYl12Pbl/sSRpTKXuyrD4dxZrqMXGxejJl3pJksY8uEAZ6Y4wZwQA0WnatGkaMmSI+vbtq8aNG7v3X3PNNVq0aFHQ26O+AIDCI9Z06MnUTyVJY4q0VoaR51nR89Z+vE1PLh+a2X6XacpIs4e0fQAorIJdY/j96WGz2VS5cmW/G8rJW2+9JUnq2bOnx/5Jkybptttu07Zt2/TTTz9Jktq0aeMRs2bNGlWsWFGS9Mcff+jMmTOSJKvVqp07d2rFihU6c+aMypUrp3/9618aPHiwYmNjg5I3ABQGhkw1SN3v3o50hsVQw6sud28DKPgM5rzNFzt37tTUqVOz7U9MTNTJkyeD3h71BQAUHoZMNXQdcW+HvH2LoYYt67i3ASAr6ov8E+waw+9OjXvuuUcLFizQ448/LsMI7ANgx44duV7frFmzi8ZceJz4+HjNmTMnoLwAAACAwqpEiRJKSkrKNnXT9u3bVb58+aC3R30BAAAAFGzBrjH87tTYtGmTvv32W3355ZeqUaOGYmI8DzFz5ky/kwAAAAAQGTp06KCpU6dq+vTpMgxDLpdLmzZt0pQpU9S5c+egt0d9AQAAABRswa4x/O7UKFmyZLah2sgnpivcGURGDoEKxn1wOgM/RqACvB+mPfC5Qk1HgGsUBOH/ItD7YZiBj+2LSc4ILIfUwG6v9ABvL8lwXfz/wnCdf6yNdLsMy/nrXIE+FyQp0P/LtHTPy4bL4zrDh/lxbafjA8qhyDFrQLeXpI27qgaWw4EgzENcEN7rUTiZRuZfKNsrBB5++GFNmDBB119/vZxOpzp06CCHw6GOHTuqf//+QW+P+gIIowC/G5uRUCdFgiDUGGZGgPVaoPViRuA1hlw+PA5mljoiw+H50RqM6aAuloM9y/d3u1Om/YK6xoc6Kd8F43UVAbU7EJWoL/JNsGsMv38JmTRpkt+NAAAAAIgOsbGxevLJJzVgwADt3LlTZ8+e1RVXXKGqVavmS3vUFwAAAEDBFuwaIwindwIAAABhwEJ+QXOxjoVzi2tL0qhRo/I7HQAAACD0qC+CKj9rDDo1AABepRnR9TGRlhKEYfMAUAj98ssv2S47nU5dfvnlkqQ9e/bIYrGobt264UgPAFCApCnwKVwDav9sWljbB4DCIj9rjOj6tQoAEDLpFpu6VB0U7jR8lp5qV+dGY8KdBoAQMiTOpAqShQsXurfnzZunYsWKacqUKUpISJAk/fXXXxo1apSaNm0arhQBAAVAmhGjTrF3hK/9lHR1SuwXtvYBRDbqi+DKzxrDcvEQAAAAAIXF3LlzNXToUHexIUkJCQkaMmSI5s6dG8bMAAAAAESjYNcYfnVq2O129e7dW3v27PG7IQAAAACRLzk5WSdOnMi2/8SJEzp79mxQ26K+AAAAAAq+YNcYfnVq2Gw27dixw+9GAADRx+ZyaPzh5Rp/eLlsLke407koW2yMJrzaVxNe7StbLLMrAoWCGYa/QqBNmzYaNWqUVq9ercOHD+vw4cP6+OOP9dhjj6lt27ZBbYv6AgAKF5vp1ET7F5po/0I20xn69uNsmrhimCauGCZbnC3k7QOIcNQX+SbYNYbfv/p06tRJ7777roYNG+Z3YwCA6GGRqatT/3BvRzqL1dDV19dxbwMA8mb8+PGaMmWKhg4dKocjs1PbarXq9ttv14gRI4LeHvUFABQeVplqZh50b9tD3b7VombtGru3Q90+ABRWwa4x/O7UcDqdeuutt7R+/XrVq1dPRYoU8bh+1KhRficRqeJMh6xm9h/ynDJkN6zuy/Gm9zOYXTKUkcfYONMhbz/LmZLSjZhcY82/27owNtZ05voDZZpHrCPX4TxZY22mU1Yfj3vRWFklwwhKrJHlYrqsMv+OjTGdisnluBfG5paDXRa5DIvXWDPL/3uGrHL9fVyr6ZJNLq/HzchyXH9iLaZLsRfEGq7zX9cchkXOv59rFtOV6xky2WLlPdYpixy5xWZ5HBwy3LGGaSoul+NeGBub2+vIsJx/fZqm4i6INVxmllhD9nPPyxxiPY+bJVZSnDMj9xws3mMN1/nLpgxlWM6fIRTn8n7c7LG5fwVPzy3WZXqNjXXZZVxwm6zbHrGmQ0ZuryPjfKzNdHi89xguz4+grMe1mQ5Zcnj/PX/cLO8nLocscikuy1M+zmWX/n4s0w3b+feIv2PPsV7wf5NuiZF57rXscijG9P6aS8/yfxzjdCgml9dRhsUml8WSY2yRNM//m/TYmPOxDqdsjlyOazv/mRHjdMrm9P4czoiJkdOSGW91ORXrOB974WeTXRY5c3k/uTD23K0tpqnYXF/LFjncx/U99uLvEb7HenyGm6bi8yNWuX/eR8v3CG+xF/seEUpGCd+iaAAAknZJREFUqM9uioy7ne+KFCmiJ554QiNGjNC+ffskSZUrV1bRokXzpb3CVF9I0V9jeIv1r8bwPTZSa4ysPOsGl2Jy+dz0JzZr3eBPbChrDGV5hvj7/cHX2Ky1gD+x/tYYgXx/yFrvhe37Q5bvrS5JGVleG7m/R3jGBvQekeW9Lft7ROZvC1lrrqzbQfsd4oL31wtjs7WfNQdZPWJze59Kv+A9IrfYDD9+W8jIcm1mbG6vI+sFv0OcjzVMw2us1XQpJpfnpT3LkXyKzfJazvobgCvAGsOZh7qBGqNgfo/I+jrOb9QX+SfYNYbfz4qdO3fqiiuukCT98ccfHtcZRsE6M3axPlDxHN5kv9WlGqMWWeJWqoiXN6GfVEbDdL378kKt0iXK+UfLHSqlgbrJffk1xypdqpQcY/eopO63tXdfnuFYrao6nWPsYRVVT52PfU5fqJZO5hh7SrHqpk7uy08516qhmZRjbJqs6mTr5r78uPMrNTMP5RgrSW1td7q3Rzq/0XXmfq+xnWJuV9rfT88h+kFttddr7O3qqL8UJ0n6j7aok3Z5BmR5b+4Zc6uOqLgkqa/rZ3Vz/er1uPfFtNNeZS5ec6djq3o6fvYa+1DcLdpplJEkdXb8qvscP3qNHarrtEXlJEkdtFsPabPX2Mf0L23UPyRJN5p7NNy50WvsRGtzrTMqS5L+ZR7QWOd6z4Cj5zenlbxRnxStLUlqmr5PE06t8nrcWSVaamWx+pKkes4jejblI6+xr8U11btxmbHVXcc14+z7XmMXWupqoTUztrJO6zXHh15jl1hq6zVrI0lSOecZzT+2yGvsyqL1NKvkdZKkBDNN7xyd5zX2k6J19FxiG0mZH7YrDr7sNXZdkep6uvT519F7WyZ7jf22ZHU9Xu3/3JcXb52meC8dEFuKVNKIKne7L8/f9bIucabmGLsz/lINqtrHffmVI4tU3nkmx9i9MYn6z6U93JenH31HVRzZ5y6UpCMxJdWn0r3uy88eWqyaGUc8Yt7Z/19J0l+WIrqzSn/3/idTPlFD5+Ecj5umGP27ZE/35bGpn6uZ48D5gAtSv+XSB93bI06tUcv0C17LWfy73H1K/3t70NHVanNmm1S0qKRnJEmLd8+SUjLfP++4fID+isn8kLz/2Ofq+Nfm8we6oIn/u2qojsSXkiTds+dT3fHnV15zuKfJQ9qmKpKkPtvW6L6tn3iN7XPzIG0vnfn6vHPHOj20+YPzVy72jL1z9L36ps4/JUl3fb5RExes9HrcvkN7aUPRRpKkjls3adJ7b3uNHdy1lz6+IjO29a8/a/rSBV5jn7VerU+MzByamof1pPNLr7EzLFfqPV0uSaqnJE2T99hXVV9LVEuSVF0nNUufeY1doDpaqLqSMt8jZsv747tYNfWaGkiSyilFi+T9/eQ9VdMMZZ6dl6AMvSvvj+9qVdGzukqSFC+nVmqF19gvdZkm6lr35dxiQ/U9YrZW5/o94j6dH+I7U58F7XsECo6iRYuqdu3a+d5OYaovpPDXGOF6b8haYzytdWqoYznGpsqqTurivjxOG9RMOX/XkKQ2ut29/ag26jr96TW2ozoHr8bIoofa6YiKSZL6aqu6a6fX2HvVxl1j3KXt6qXtXmMH6EbtVKIkqYt+0/3yXo/ktca4Sfs0XN97jZ2oa/SlKkqSWuigxuobz4AsP8Y8a1yl1aoqSWqqI3rK9P49aobRWO+puiSpnpmkqc7Pvca+ZmmoJdbM0bjVzZOa6fT+nSDPNYbOaqHDe+3ynqW6ZlqbSpISlK4ljhVeYwP5/vCefbHX2G+NChpru959ebF9qdcfQ38yymp4zPnX/QLHSl3i/vbsaYeRqIdizr/uX0t/X5cq57nN9xgJuj/uVvflGRkfqar5V46xh1VMvWL/7b48zfGpapme9cgSxzJJ0inFqXtsV/f+pzI+V0PzqHKSJqs6xZ//beFx+5dq5jqYY6wktY09X5eNdKzXdfbjkjK/By+xL5Xs598PO9m6Z3ZWSBpk/1Ztnbu9Hrd7/O36S/GSpPvtm9TJ6f113yuus44Ymb9D9HFsVjeH99f9/XG3aq9KS5LuzPhZPe0/eY19qEgH7bT+/TuEfbvuy9h0/soL/gtHlOigLbYKkqT26ds1IOWC3wuyeLz4zdpoy3zd35jxu4amrPMa+1SxG7UuNrMW+Jd9rx476/37/bNq6vkeoa+9xs5Qo/PvEdQY7suFtcbI+lmP6BesGsPvTo2FCxcG3CgAAAAQMM6kKhCoLwAAABARqC+ihmGauczvkYu9e/dq3759uuqqqxQfHy/TNAvMmVTJycm68sorVe33WrK6rNmuD9WQrnirAhrSZToCn34qzpr7avKhGBoeY08PbPqpmPPt5nX6KZvVCGz6qbQ093Zeh4bHWC2BTT+VWMq9ndfpp4yzZwObfir1/OOQ16Hh1sRSgU0/leX5kNfpp1xlLwls+qm0wKafMpJT/o4NYPopm/epn7JOP3VuhMYdlf7jjkm32OQ6nnkGRUDTT10wvYjf00+VzDzbyT39VJFYLf45c6RG9/ojlJ568emnHOUTLsjBv+mnzlTOHAESyPRTR9sENv2UbVexv4+b9+mnKk3b5BHr9/RTTtffsQwNP6ewDg2XpJXmcq/XBcvhw4fVqlUrmV17SMWK53t7bhkZMt6eq02bNql48RC2W0gU5PpCipwag+mnmH4qqNNPZXmN5nVqGavFiP7pp7J8r8rr9wfDFhve6aesmccO6D0iyxS3uU0/dW6ERreY29wxaUaMZDE8Yr3J9XV/wTS7F8YWLRqrJacyR2p0u6SX0lPOj2BJk1VGjNUdG7bpp/6uWQOafio21mtsyKafOnX6glimnwooVoW3xkgzYvSJa4nXHIOB+iL6+D1S4+TJkxoyZIi+/fZbGYah1atXq1KlSho9erQSEhL06KOP5keeYZFuxMhiZC84LuTP3G7+xKYHGGt6eefI8OE+nY/1PQe7YfV5ka1Qxhpe7oPDsMr723ZwY11ecnAaFjlz/bqWt1iXYVHaBbGWLD8YXxibbvh+3HQ/crgw1jRyfhRNw3BPBXAxpmF4/FCeqxxiDYuXdvw5rqR0q+9TrFwYm9vDnW7x47he/k99ivX2OEgenSxZb59Te/69R3jGGrnkbzdivPfqXhh77r5kOV5mvrnEnrucy/+jwxLj++veGiOHj8/hC2NT473fUUeMVY6Y3N+zz91rh9Uqh9W393enxarU2POxuX025fR+kkPU37G+v5b9ifX3PcLXWOVXrPLvu0Eov0d448/3CMAXham+kKK/xvDGvxrD99hIrTG8cRgW5f5zbP7HhrLGkJeOR9++P+RvbCi/P3irvUP7/cH7D8Qhe48wcvmxPofjphsxOeYW0O8QueRgN6weOWe2n/MPynY/36d85f9vC74d+8JYI5fa1qfX/d+dZP6+R2T9DcAZcI1xLpYa4xxqDOA8395Bspg0aZJiYmL0xRdfKD4+3r2/ffv2WrfO+zx7AAAAQFCZYfhD0FFfAAAAICJQX0QNv0dqfP3115ozZ44uvfRSj/1Vq1bVwYPeF2cCAESXdItN7S5/JNxp+Cw91a5bao4IdxoAAD9RXwBA4ZFmxHgs3h3y9lPS1Tbu7rC1DwAIDr87NVJSUjzOoDrn1KlTio31fdoU+MDHKYEKfA6BCsZ98HFKl3wV4P0wbL5PVeRVjK8D73NmBuH/IuD7ERv44+AoHth7nTXA+cGtdl8HLHtn2vx++/eQdW2SPB8jwP9LV3xcwDnYSwaWQ2qZwJ/TV1fbE9Dtv02pHnAOBeK9HoWSwUJ+BQL1BQqtQNeMydvymJ4pBPid7sJ5+/N0jKJFLh6U35zep27yhevMmYBTsJYrE9DtzZTUgG5vFC8W0O0lSa7AHkdZgvCd1B5YzaoIeD66SgSeQ3rpogHd3pLhfZ0Hn4/x1eaAjwGEGvVF9PD7E6Np06ZasWKFxz6Xy6XZs2erWbNmwcoLAAAAQCFAfQEAAADAH36fljF8+HD16dNHW7duld1u17PPPqvff/9df/31l9566638yBEAEAY2l0MjDq2UJD3zj47ZFtmONLbYGI14uqsk6ZnRS2XPCHxECwAg/1FfAEDhYTMdGn5itSTp2cS2svuxkHBQ2o+L0fAXe2W2P2iB7OnUDAAQjfweqVGzZk19/PHHuvLKK3XTTTcpNTVVbdq00fLly1W5cuX8yBEAEAYWudTyzA61PLNDFgU4lDwELFZD17Wtp+va1pPFGuB0DgCAkKG+AIDCw2Kaapn6u1qm/i5LEKZQ87t9i0UtOzZRy45NZAnGdFcAgLDIU5d4iRIl1L9//2DnAgAAAKAQor4AAAAA4CufOjV+/fVXnw9Yu3Ztn2NfeeUVrV69Wrt371Z8fLwaN26sYcOG6Z///Kc7pmfPntq4caPH7e644w5NmDDB63FN09SLL76oJUuW6PTp02rSpImeeOIJVa1a1efcAAAAEAVYXC8qUV8AAAAgIlFfRAWfOjU6d+4swzBkmqYM4/yUHubfQwWz7tu+fbvPjW/cuFF333236tevL6fTqeeee079+vXTBx98oKJFi7rjunfvrkGDBrkvFylSJNfjvvbaa1q4cKEmT56sihUravr06erXr59WrVqluLg4n/MDAAAAEHzUFwAAAADyyqdOjTVr1ri3t2/frilTpqhfv35q1KiRJGnz5s2aN2+ehg8f7lfjc+bM8bg8efJkXXvttdq2bZuuuuoq9/74+HiVLVvWp2OapqkFCxaof//+at26tSTpmWeeUfPmzfXpp5/+f3v3Hd9Uvf9x/J20TRkFRGgZFkFBCrKLiEChiizBKqIIKiAKqCxBQRBU9roKKEsvypAhKoJwKeAA/YFyqeBVQEEsKrPKKEVsC6Ur5/dHbSQ0TZuOpGlfz8cjmpx88z2fc3JS8s73DHXr1s2lGgEAAFBEGZLJjXtSeeDU38UW+QIAAABFDvnCa+RqUOOGG26w3R8xYoRefvllhYeH26bVq1dP1apV07x582xf9PMiISFBklShQgW76ZGRkdq0aZMCAwN11113aciQIdnuTRUTE6PY2Fi1bt3aNq1cuXJq0qSJ9u3bR+gAAAAAPIx8AQAAACCvXL5Q+JEjRxQcHJxlenBwsH799dc8F2K1WjVjxgyFhoaqbt26tun33nuvqlevrqCgIEVHR2v27Nk6duyYFi5c6LCf2NhYSVKlSpXspleqVEnnz5/Pc30AAAAoYgy595y37ElVKMgXAAAAKBLIF17D5UGN2rVra/HixZo2bZosFoskKSUlRYsXL1bt2rXzXMjkyZP1yy+/aM2aNXbTe/XqZbsfEhKiwMBA9e/fXydPntSNN96Y5/kBAJxLNvnp/rrP2+4XdclJqbqv5RTbfQCAdyBfAEDJkWzyVffqg2333T7/pBR1r/287T4AwDu5/C/I5MmT9cwzzyg8PFwhISGSpOjoaJlMJv373//OUxFTpkzRjh07tHr1alWtWtVp2yZNmkiSTpw44TB0ZJ4bNy4uTkFBQbbpcXFxqlevXp7qA4ASyWRSssni6SpcwmAGAHgf8gUAlCAmk8d3mGIwAwC8n8uDGo0bN9b27dsVGRmpo0ePSpK6du2qe++9V2XKlHGpL8MwNHXqVG3btk2rVq1SjRo1cnzN4cOHJSnbC/sFBwcrMDBQUVFRql+/viQpMTFRBw4c0COPPOJSfQAAACjCODy8WCBfAAAAoEggX3iNPB3rV6ZMGbvDtvNq8uTJ2rx5s958802VLVvWdr7acuXKqVSpUjp58qQiIyMVHh6u6667TtHR0Zo5c6ZatGhht1dUly5dNGrUKHXs2FEmk0n9+vXTW2+9pZo1ayo4OFjz5s1TUFBQvi4yCAAljZ81Tc+e+VSSNL9qF6Wa3X94uCv8/Hz07IT7JEnzp2xSamq6hysCAOQW+QIASgY/I03D//w/SdKCincp1c2noPKz+Gr4v3pnzH/sB0pNSXPr/AEABSNP/3ocP35ce/bsUVxcnKxWq91zw4YNy3U/77//viSpb9++dtNnzpypHj16yM/PT1FRUVq5cqUuX76satWqqVOnThoyZIhd+2PHjikhIcH2eNCgQUpKStKECRMUHx+v5s2ba8mSJfL393d1UQGgxDLLqo7xByVJC6t28nA1OTP7mtXp/lBJ0sIZmyUGNYDiz5BMbt6Tip2pCgf5AgBKBrNhqOPljCPkFl13p2Ry8/x9zOrY646M+Y9f696ZAyj6yBdew+VBjbVr12rSpEmqWLGiKleuLJPpn3+BTCaTS6EjOjra6fPVqlXT6tWrXe7HZDJpxIgRGjFiRK5rAQAAAOB+5AsAAAAArnB5UOOtt97SyJEj9dRTTxVGPQAAAEDucM7bYoF8AQAAgCKBfOE1XB7U+Ouvv3TPPfcURi24lmHNuU1JqCG/CmIZjCLwVya/y1EQy5DvGorAe2HNfw3mtPz1YcpvDQWwDLnq4+o2Vqukqx4Xgffy2vV49WOT1Zqr9WxOy18NPsn5/1yduVQ+X683J5nzXUOx+FsPwGuRL1BimfL5b7hRAKfa9PHJ18tNvvm/HoKpdOl895Fvafm8rsLly/kuwQgok6/X5zdjGOXL5uv1kqS0nLdJw5ryz/2A0jLMln+e9M3f9ihJSk5x+rRR2s9+/j7227C1XP7eh4KQUqlUvvu4VN2ScyMnfK/kP+cE5LsHAMiey9+iunTpol27dhVGLQAAAABKGPIFAAAAAFe4vFtFzZo1NW/ePB04cEB169aV7zV7ZvTr16/AigMAAACyY+JCfsUC+QIAAABFAfnCe7g8qPHhhx+qTJky2rt3r/bu3Wv3nMlkInQAAAAAyDXyBQAAAABXuDyo8eWXXxZGHQCAIibZ5KdeNw+z3S/qkpNS1avtdNt9ACUAF/IrFsgXAFByJJv81KvOs7b7bp9/Uqp6tZxsuw8AdsgXXiP/V/UCABRPJpP+8vX8hfJc8def+b9IIwAAAIBCUgQyxl9/XvLo/AEA+efyoMa4ceOcPj9z5sw8FwMAAADkmhfsSfXee+9p6dKlio2NVb169fTKK6+ocePG2bb/5JNPNG/ePP3++++qVauWRo8erfDw8H9KMAzNnz9fH330keLj4xUaGqpJkyapVq1adv3s2LFDixYtUnR0tPz9/dWiRQu9+eabri+AG5AvAAAAUCR4Qb6QCj5jfP755/rggw906NAhXbx4URs3blT9+vXt+ujbt2+WU8X26tVLU6ZMydtC5JPZ1RfEx8fb3S5cuKA9e/Zo27ZtSkhIKIwaAQAe4GdN09Cz2zT07Db5WdM8XU6O/Px8NPSlCA19KUJ+fj6eLgcAtHXrVs2cOVNDhw7Vhg0bVK9ePQ0YMEBxcXEO23///fcaNWqUHnroIW3cuFF33323hg4dqiNHjtjavPPOO1q1apUmTZqktWvXqnTp0howYICSk5NtbT777DONGTNGPXr00H/+8x+9//77uvfeewt9efOKfAEAJYefNU1Dz3yuoWc+90jG8PPz0dCJ3TV0YncyAwCvVBgZ4/LlywoNDdXo0aOdzvvhhx/Wrl27bLcxY8YU6LK5wuUjNRYtWpRlmtVq1aRJk1SjRo0CKQoA4HlmWRXx1z5J0pLA8Bxae57Z16yIR+6QJC2Z+6mUmu7higCUdMuXL9fDDz+sBx98UJI0efJk7dixQ+vXr9dTTz2Vpf3KlSvVtm1bDRw4UJI0cuRI7d69W6tXr9aUKVNkGIZWrlypwYMHq0OHDpKkV199Va1bt9b27dvVrVs3paWlafr06XrhhRfUs2dPW9916tRxwxLnDfkCAEoOs6yKuPi9JGlJ0J3un7+vWRGPtc6Y/6tbyAwAioTExES7xxaLRRaLxWHbgs4YktS9e3dJUkxMjNM6S5UqpcDAQJeWrbC4fKSGw07MZvXv318rVqwoiO4AAACAHJkM99+kjNBx9S0lJSVLbSkpKTp06JBat25tm2Y2m9W6dWvt27fP4fLs379frVq1spsWFham/fv3S8oIGbGxsXZ9litXTk2aNLH1+dNPP+ns2bMym83q3r27wsLCNHDgQLs9sbwB+QIAAADu5ql8ER4erubNm9tuixcvdlhfYWQMV0RGRqply5a69957NWfOHCUlJbncR0EpsAuFnzp1SmlpRf/0JAAAAEB+XH3+WUkaNmyYhg8fbjftzz//VHp6uipVqmQ3vVKlSjp69KjDfs+fP6/KlStnaX/+/HlJUmxsrG1adm1OnTolSVq4cKFefPFF3XDDDVq+fLn69u2rzz77TNddd50LS+pZ5AsAAACUBDt37lRAQIDtcXZHaRRGxsite++9V9WrV1dQUJCio6M1e/ZsHTt2TAsXLnSpn4Li8qDGtRfqMwxDsbGx2rFjhx544IECKwwAAABwykMX8stt6PAEq9UqSXrmmWfUuXNnSRnf39u1a6dPP/1UvXv39mR5DpEvAAAAUCR4KF8EBATY5YuiqFevXrb7ISEhCgwMVP/+/XXy5EndeOONbq/H5UGNn376ye6x2WzW9ddfrxdffNF2Li8AAACguMpN6KhYsaJ8fHyyXLAvLi4uy55SmSpXrpxlj6mr22eevzYuLk5BQUF2berVq2fXpnbt2rbnLRaLatSoodOnT+dm8dyOfAEAAADkrDAyRl41adJEknTixAnvGNRYtWpVYdQBAAAAuMZDe1LlhsViUYMGDRQVFWW7qLfValVUVJT69Onj8DVNmzbVN998o/79+9um7d69W02bNpUkBQcHKzAwUFFRUapfv76kjOt7HDhwQI888ogkqWHDhrJYLDp27Jhuu+02SVJqaqp+//13Va9e3cUFdg/yBQAAAIqEIpwvpMLJGHl1+PBhSfLYhcML7JoaAAAAAP7xxBNPaOzYsWrYsKEaN26sFStWKCkpST169JAkjRkzRlWqVNGoUaMkSf369VPfvn21bNkyhYeHa+vWrTp48KCmTJkiSTKZTOrXr5/eeust1axZU8HBwZo3b56CgoJsoSYgIEC9e/fWggULVK1aNVWvXl1Lly6VJHXp0sUDawHX8i/tLx/DJ8v09HSrUpNTbY9LlfHPtg+r1VDKlZQ8tfUvbZHJZHLY1jAMJSflra2llEVms+O2knTlcnKe2vr5+8nHx1zwbS2+8vHN+j7kpW1yUooMI+NXCV8/X/n65batj3z9so/kKVdSZLU6aWtNv6ptqu30cz6+PvKzOOk3OVXWdNfbmn3Msvj72T1v8v/n9HtpKelKT0u3tfXzz75fu7Zmk/yu6fdq6WnpSkt1va3JZJKlVMG0taZblZryzzV+/Evbn3bQetVnMD0t3a6ts8/ntZ97/9LOajCuqeGa9yL1n5oMw1DKlav7zf40iVnalvKTsvt4GlKys7Zp5mzbWvx9ZTKb5G+VVKbMP3WZM5YjOSlr2+xc3dbP4iuzz1VtzYbTtlevt2vXoV1bPx/nf0+u5L5tcnLaP597Xx/5+jpvm8nX1yxfJ397UlLS/vkbcU3b9Gs+1ymp6bL+XYOPj1l+TupNTUtX5i+tPj5m+TmpNzU1Xel/1+BjNsnvqr9/1277qSlpdn8jrv17km1bs9np5zMtNV1pqWkutzWZTE4/G660delzn4+/EQXV1tu+R1z9bzIKPmNI0sWLF3X69GmdO3dOknTs2DFJGUd5BAYG6uTJk4qMjFR4eLiuu+46RUdHa+bMmWrRooXtiHF3Y1ADAOBQislPj9/0tO1+UZdyJU2Pd3rNdh8APK1r1666cOGC5s+fr9jYWNWvX19LliyxHep9+vRpmc3//FAQGhqq2bNn64033tDcuXNVq1YtLVq0SHXr1rW1GTRokJKSkjRhwgTFx8erefPmWrJkifz9/wmjY8aMka+vr8aMGaMrV66oSZMmWrFihSpUqOC+hUe21p5+x+Hpy/Zs+V4vR/xzfZG1Z5eodNlSDvs4sOOQRrefZHu86tibui6wvMO20d/+qmEtx9keLzn0uqrWCnLY9vihUxrU6Hnb44V7Z6lWgxoO2545fk59bx5qezx352SFtKjjsO3F2Hj1rDLA9njG1vFqcmcDh22TLl3RfeX62h5PXDdaLbuFOmwrSR3NPW33X1w5XO16tsq2bURAH9sPIyP//bQ69b8z27YPBQ3QX+fjJUnPzH1c9w3JflCwz01DdPZErCTpiemP6OHR92XbdmDD53TipxhJ0iPjHlC/CQ9l23boHeN15H8ZF/184Nl79NS/HO+BKUmj7pqoH3ZmnMqt21MdNHzhwGzbvnTvTO3d+r0kqX3v1nrhnaezbTv1sfn6+uO9kqQ299+mV957Ntu2c4Ys07Y1/5Uk3XZ3Q01ZOyLbtotGr1bkkv+TJDW4/Wa9+uGwbNsumbFJ6xdntK3TMFjzIp/Ptu3q1z/Ve298JkmqUaeKFm8fm23bdYu/1NIZkZKkwBsqasWeydm2jXz3K7350keSpArXB+iDH2dm2/bzVV9p9lNvS8r4oXBT3NJs23718R5Ne2yB7fF/vp+Sbdu9O3/WhGdW2B5/uOtllSrj+EfWH3b/orE959ser9gzSRUqlXPY9sj+ExrRbbbt8dsbn1WVGyo6bHvi17N6+oF/6p3//jOqWaeKw7Znf/9Tj3d41fZ49qqnVbdR8N+PMtbf2r8fXbyQqN5tptvaTnvrcTVucZPDfq9cTlH3lv+sp1def0S3twtx2FaSutQdY7s/5rXeantPY9vjtd9Msmt7f5OXlPT3/REvRahTRNNs++1596v66+JlSdLTz3fWfQ/fnm3bvve+obOnL0qSnhjaXj37tcm27aCei/TLXwmSpD6PtFb/vmHZtn162LuKPnJGkvTgA7dp8KD22bedtVbf/5zxt6fHnY00pu/d2bYd+foG7dmT8benc1h9vTI4+79/L70eqS/3HJEkhbe4RdOfi/jnyRX2bV97YpE+X7FDknRb56aavnmcsrNg2BJtejPjs9ywbT3N+b/sP59vj1mlj2ZvkiTVCb1Ji/bOyrbtyslrtWpyxmf5xvo3aMnB17Ntu3b2Jr0zJuNo0qAbK2v1sTezbbvpzU+1YFjGZ71C5fJady77z/3n7+7Qa08ukpTxNyIycXW2bb/6KEpTe821PXbWtjh/j7j633oUTsb48ssvNW7cP+/zc889J0kaNmyYhg8fLj8/P0VFRWnlypW6fPmyqlWrpk6dOmnIkCFuWuqsGNQAcuPvvZ68mZGW/x95jXTPr4f8Lkf2+/vknjmfP5ibrtqrJ09S8/9e5nY9nFPZjDtp6XavsRbEtpDfbTLFfj0aks4ej3WpC5/L+avBkpD/f0ZPnrk+X68vFZf9nlNAcWcyMm5uk4d59enTJ9tDwR2ddumee+7RPffck21/JpNJI0aM0IgR2f9Y6Ofnp7Fjx2rs2Ox/zAPgedntvWp73uwjk4/P3/cL59/7zP6d1uDra7vvlMVPpjKlM+77Z79Hc0Zbi62tUa6M06ZGaX9Zr8/4Qd5aPvdtjQo5tC1lsbVVhRwuzupvkVEx4wc/4zrn/cpstq0zOdnLXpJk+qdtSjXHPyhmsvr72rUxnG0+fj62ejPaOtl+fDPaXqmWsQ4MJ3vwW33NtnaZj7Nj+Jjs6rU6OYJJZrNSqpWX1TdjoayW7NsaZtnVkO7vfB2nBV1VQynn393TA8vrcrmMZUor67xtUnAZXS6fUW9aOec7gCVVL63LfhnZJbW887ZXqpXWn1Uy9l5PquR82RJutOhPZezUkFTZeb1/3WLofJmMLzKJjn9jtomvbeh8UsayJQbn0LambG3jazpvC3gDb8gXUsFnjB49etiO9HCkWrVqWr06+0E1TzAZmcfAwSYxMVHNmzdX8G8NZLbm8CWkENm+COVRQfyInd8aCkK+f8QugGXIbx/WK1c8XoO5Uv5+OJUk43JSzo2cvT4pf6+X8r8cBbE9WAOvy18NVx1imafXJ17O1+slSU5OdZAb1rg/812CLfTmVbmy+a4htWr+9lpOrOF4zxdXnL0nf9tDqSP5r+HGWXvz9fqC+PcGxcc260eFPo8zZ84oPDxcPh37yFwmhx+iCpCRmqK0rcv03Xff5XihcOBamRmj9h+hnH6K009l9FumdL5OP2WkplzVNm+nn/KrUF6+Tn5ATk1Oszv91LWnlDJf9bcwLTVN6WlXtXVSw9VtVa2S07bpaValXX2qqly2NZlMsjg5BZZdv2lWWZz84G1Nsyo19Z/TfV172iLj5B/2ba8+TVQ2R1NIf59S6u/PfWqLEJVydrqsdPsarm3rF5v4Tz1WQylXncbI2WmtMtteqZ4xwOPv7+v8c391v9e0NacZ2ba1WHydf+6vpNoGNXLT1tavn4/MV33ufa/ZacnuNFEWH/k4GSC8ciVVVwIz/p76+eZw+qmr/l7n1DY5JVWZv7z5+prl62QwMTklVfHVM7ZF3xxOE5V81Smlrm0bX8d+J7Tk9Kvams3yc7IeUtLTZUrQP22d1JCSlq70zNNamUyyXPW3suZk+4zB6afy0JbTT0nK+De5sDMG+cL7uPyr1saNG9W1a1dZLPYf5pSUFG3dulXdu3cvqNoAAB7ka6Tr8T93SZJWVAxTmslzg7y54evno/7PZRwa/e7rn9rOkQygGCviF/JD7pS0fJGclJyrHadcOX+0K22TXdi5wpW2V//gUZBtU5NTldtjXF1qm5Jm96NSQbVNS02z/QiWc9v0XH9fcdT26kGNq6Wn/XO9ipy40taablXyZft5mn0c12BNt+Z6+7FaDbtrLxRUW8NwsW1S7o+mvratcTn7Zb12nTlzxYUjuq9ta3VSv0vLlpz7nVWubXv1oMa1Uv7+DPla0zTg6DZJ0tKbOyrNnPVnqZRcft6kjGtF6KrPhq+To+pTU9Jl+Bp68qm7JEnL3v4/paU5PgI9NS3972tL5MyVtmlp1mznmaVtulVpuTxC/tq2SU7mkWa1Ki2Hs1H4/n2cfm7aZko3DCVd9ffP2b9N1nRrrv/tsloLp61hGIXSViq8f8OLQtui8D2iUJEvvIbLx7COGzdOCQkJWaZfunTJ7txbAADv5mNY9dBf3+mhv76Tj+H5U4/lxMfXrIcGhuuhgeHycXIoPACgaCFfAEDJ4WtY1evU1+p16mv5eiBj+Pr66OFHW+nhR1s5vQg3AKBoc/lIDcMwHB46dPbsWZUr5/jCUwAAAEBBM8k7znkL58gXAAAAKArIF94j14Ma3bt3l8lkkslk0uOPPy7fq85Ln56erpiYGLVt29almS9evFiff/65jh49qlKlSqlZs2YaPXq0br75ZklSTEyM7r77boevfeONN7K9wMmLL76oDRs22E0LCwvT0qVLXaoPAAAAQOEgXwAAAADIi1wPanTo0EGSdPjwYYWFhals2X8u0Orn56cbbrhBnTp1cmnme/fu1WOPPaZGjRopPT1dc+fO1YABA7RlyxaVKVNG1apV065du+xe8+GHH2rp0qVq166d077btm2rmTNn2h5fe45eAAAAAJ5DvgAAAACQF7ke1Bg2bJgk6YYbblDXrl3l7++f75lfu2fTrFmz1KpVKx06dEgtWrSQj4+PAgMD7dps375d99xzj13occRisWR5LQAAAIoRLuTn1cgXAAAAKFLIF17D5WtqPPDAA5KkgwcP6rfffpMk3XLLLbr11lvzXUzmBQIrVKjg8PmDBw/q8OHDmjBhQo597d27V61atVL58uV1xx13aOTIkapYsWK+awQAAABQcMgXAAAAAFzh8qBGXFycnnvuOe3du1fly5eXJMXHx6tly5Z6/fXXdf311+epEKvVqhkzZig0NFR169Z12GbdunWqXbu2QkNDnfbVtm1bdezYUcHBwTp16pTmzp2rQYMG6cMPP5SPj0+e6gMAAEARw55UxQL5AgAAAEUC+cJruDyoMXXqVF26dElbtmxR7dq1JUm//vqrxo4dq2nTpmnu3Ll5KmTy5Mn65ZdftGbNGofPX7lyRZs3b9aQIUNy7Ktbt262+yEhIQoJCVGHDh1se1cBAHKWYvLV0zf0s90v6lKupOnprnNs9wEA3oF8AQAlR7LZV0/ePsJ23+3zT07VgL7/tt0HAHgnl/8F+frrr7V8+XJb4JCkOnXqaOLEiXryySfzVMSUKVO0Y8cOrV69WlWrVnXY5tNPP9WVK1fUvXt3l/uvUaOGKlasqBMnThA6ACCXDJNJJy2VPV1GrhmGoRO/nvV0GQDcyPT3Dd6NfAEAJYdhMut42Sqem78hnTh23mPzB1C0kS+8h8uDGlarVX5+flk78vWV1Wp1qS/DMDR16lRt27ZNq1atUo0aNbJtu379erVv3z5Ph5+fOXNGFy9e5MJ+AAAAQBFDvgAAAADgCrOrL7jjjjs0ffp0nT37z96wZ8+e1cyZM13eS2ny5MnatGmT5syZo7Jlyyo2NlaxsbG6cuWKXbsTJ07o22+/1UMPPeSwny5dumjbtm2SpEuXLulf//qX9u/fr5iYGEVFRWnIkCGqWbOm2rZt6+LSAkDJ5Wuk67E/d+uxP3fL10j3dDk58vXzUZ/hHdVneEf5+nF+cwDwFuQLACg5fK1pevzYdj1+bLt8re4/Zayvr1n9nmynfk+2k6+vyz+JAQCKCJeP1JgwYYIGDx6su+++23Yo95kzZ3TLLbfotddec6mv999/X5LUt29fu+kzZ85Ujx49bI/Xr1+vqlWrKiwszGE/x44dU0JCgiTJx8dHR44c0caNG5WQkKCgoCC1adNGI0aMkMVicak+ACjJfAyr+lz8RpK0rkILpZmK9kCBj69ZfYZ3lCR9tGSH0lKL/kAMgHziQn7FAvkCAEoOX8Oqx49/KUn68MZ2cvewhq+vj/o92U6StHZNlNLSXDsiEEAxR77wGi4PalSrVk0bNmzQ7t27dfToUUlS7dq11bp1a5dnHh0dnat2zz//vJ5//vlc9VOqVCktXbrU5VoAAAAAuB/5AgAAAIArXB7UkCSTyaQ2bdqoTZs2BV0PAAAAkCsmI+PmNuxJVWjIFwAAAPA08oX3yNOgxt69e7Vs2TL99ttvkjL2pBo4cKBuu+22Ai2uxDMVgfM7FoUa8qsglsGnCJx2J5/LYSrln/8a0vJ3cLBxJTnfJeR3OQy/PP3Zs5N6Xal8vT6/13swpxfAaZUsWS/Iei3D+s82Z5Txl2H+5xQbpoScX5+T/L6X1rL274NR6p+ajDKlZJhzXs/JlfJ32pBL1fP/96Vno+/z9fqPFJrvGorF33oAXo18gZLIlIvvY84YqSn5rsFcLiBfr7dWuT7fNfxVr0K++8gvv8v5OwVRwIW/8l3DudD8ZYyKv+Qv55xvmP+c5JOLuFc61SR9lXE/tqm/kvz+yQTpBRBZ/S86/35fyvLPcp5vVFpXUuw/hwk35b+G/Apu9nu++9jX4D/5ev0XSfn/DeTVlxvluw8AyI7Lv2L85z//0RNPPKFSpUqpb9++6tu3r/z9/dW/f39FRkYWRo0AAACAY4YbbygU5AsAAAAUGeQLr+DyUPy///1vvfDCC+rfv79tWr9+/bR8+XK9+eabioiIKMj6AAAAABRj5AsAAAAArnD5SI1Tp07prrvuyjK9ffv2iomJKZCiAAAAAJQM5AsAAAAArnD5SI1q1aopKipKNWvWtJu+e/duVatWrcAKAwB4VqrJV8/e3N92v6hLTUnT8Mf+bbsPoARw92HbHCJeKMgXAFByJPv4qfdjI2333S0lNV2P/es9230AsEO+8Bou/0r1xBNPaNq0aTp8+LCaNWsmSfr++++1YcMGvfTSSwVeIADAM6wms46Uru7pMnLNajV05Kc/PF0GAMBF5AsAKDmsZrMOVr3Rc/M3DB06edZj8wcAFAyXBzUeffRRBQYGatmyZfr0008lSTfffLNef/11dejQocALBAAAABwxGRk3t2FPqkJBvgAAAEBRQL7wHnk6n0jHjh3VsWPHgq4FAFCE+FrT1f3Ct5Kkjde3UJrZx8MVOefr66Puj94hSdq45hulpXE4OQB4C/IFAJQMvulp6vv9V5KkVaHtlObj3tPc+vqY9dhdoZKk9/7ve6WlW906fwBAwcjzvx4pKSm6cOGCrFb7fwCqV/eeU5UAALLno3QNPPulJCny+lClqWgPavj4mjXouc6SpMi1exnUAEoCznlbrJAvAKD487Oma9RXmyVJHzRt45FBjeceaCdJ+vCr/QxqALBHvvAaLv/rcfz4cY0fP1779u2zm24Yhkwmkw4fPlxgxQEAAAAo3sgXAAAAAFzh8qDGiy++KF9fX/373/9WUFCQTCZTYdQFAAAAoAQgXwAAAABwhcuDGj///LPWr1+v2rVrF0Y9AAAAQK5wIb/igXwBAACAooB84T3Mrr6gdu3a+vPPPwujFgAAAAAlDPkCAAAAgCtyNaiRmJhou40ePVqzZ8/Wnj179Oeff9o9l5iYWNj1AgAAABkMD9xQIMgXAAAAKHLIF14jV6efuu222+zObWsYhvr372/Xhgv5AQAAAMgN8gUAAACAvMrVoMbKlSsLuw4AQBGTavLVmFqP2e4XdakpaXph4DLbfQDFH+e89V7kCwAomZJ9/PTEw0Ns990tJTVdA99Ya7sPAFcjX3iPXP1Kdfvttxd2HXDASE3xdAlFoob8KohlKArrIb81pJ04VUCVeFZRWA6fX4/l6/X5/TfLXV+90yXtsz36teBnEHchf68/Yf/QKmn/vp9c6qL0gfyVUDp/L5ck7Z+Tv9ffou/zXQPfowC4G/kCkKyXLnm6BKWdPZe/Ds6dz3cN5X/yyXcf+WZY8/XytPT8f0O/4c2/8vV6Iy1/O/XcuM19OzH98ff/q2l/gfdtGDl/sz2p7yRJlR08V8XH89ujyZL/wZ6u/p3y10EBbNNSXAH0AQCOuXyh8K+++kr/+9//bI/fe+893X///Ro1apT++it//wgDAAAAKFnIFwAAAABc4fKgxmuvvaZLf+9REh0drZkzZyo8PFwxMTGaNWtWgRcIAPAMH8Oq+4xfdZ/xq3zyufeaO/j4+ui+IZ1135DO8vH1/B5WANyAC/kVC+QLACg5fAyrItKiFZEW7ZGM4ePro4inOyji6Q5kBgBZkS+8hsvHF8bExKh27dqSpM8//1zt27fX888/r0OHDumpp54q8AIBAJ7hJ6uG/31I+OeqpXTXx8Hdys/iq+ELB0qSPn93h9LTOEcuAHgD8gUAlBy+smpY6reSpM99ars9Y/hZfDX8jf6SpG2rviYzAICXcvlfDz8/P125ckWStHv3brVp00aSVKFCBSUmJhZsdQAAAEB22JOqWCBfAAAAoEggX3gNlwc1QkNDNXPmTC1atEg//vij7rzzTknS8ePHVbVqVZf6WrNmjSIiIhQaGqrQ0FD16tVLO3futD2fnJysyZMnq2XLlmrWrJmGDx+u8+edX4jMMAzNmzdPYWFhaty4sfr376/jx4+7upgAAAAA3IB8AQAAAMAVLg9qTJgwQX5+fvrss880ceJEValSRVLGBf7atm3rUl9Vq1bV6NGj9fHHH2v9+vW64447NHToUP3yyy+SpBkzZuj//u//9MYbb2jVqlU6d+6chg0b5rTPd955R6tWrdKkSZO0du1alS5dWgMGDFBycrKriwoAAIAizGS4/4aCR74AAABAUUC+8B4uXVMjLS1Ne/fu1dSpUxUYGGj33Pjx412eefv27e0eP/fcc3r//fe1f/9+Va1aVevXr9fs2bPVqlUrSRkhpGvXrtq/f7+aNm2apT/DMLRy5UoNHjxYHTp0kCS9+uqrat26tbZv365u3bq5XCMAAACAwkG+AAAAAOAql47U8PX11cSJE5WSklLghaSnp2vLli26fPmymjVrpoMHDyo1NVWtW7e2taldu7aqV6+u/fv3O+wjJiZGsbGxdq8pV66cmjRpon379hV4zQAAAADyjnwBAAAAwFUuHakhSY0bN9bhw4d1ww03FEgB0dHR6t27t5KTk1WmTBktWrRIderU0eHDh+Xn56fy5cvbta9UqZJiY2Md9pU5vVKlSllek9O5cgEAAOBl3H1xPQ4PLxTkCwAAABQJ5Auv4fKgxiOPPKJZs2bpzJkzatCggUqXLm33fL169Vzq76abbtLGjRuVkJCgzz77TGPHjtXq1atdLQsAUMBSZNZLamO7X9SlJKfqpXtn2u4DALwD+QIASo5UmfWK5U7bfXdLSU7Vyw/Mtt0HAHgnlwc1nn/+eUnStGnTbNNMJpMMw5DJZNLhw4dd6s9isahmzZqSpIYNG+rHH3/UypUrdc899yg1NVXx8fF2e1PFxcVlOd9upszpcXFxCgoKsnuNq2EIAEo6q8msvarm6TJyzZpu1d6t33u6DABuZDIMmQw37t7kznmVIOQLACg5rCaz9voEe27+6Vbt/XS/x+YPoGgjX3gPlwc1vvjii8Kow8ZqtSolJUUNGzaUn5+foqKi1LlzZ0nS0aNH9ccffzi8iJ8kBQcHKzAwUFFRUapfv74kKTExUQcOHNAjjzxSqHUDAAAAcB35AgAAAIArXB7UKKhz3UrSnDlz1K5dO1WrVk2XLl3S5s2btXfvXi1dulTlypXTgw8+qFmzZqlChQoKCAjQtGnT1KxZM7vQ0aVLF40aNUodO3aUyWRSv3799NZbb6lmzZoKDg7WvHnzFBQUpA4dOhRY3QBQEvgYVt2tk5KkL3Sj0k1F+xRUPr4+uvuxtpKkL977Wulp6R6uCECh45y3xQL5AgBKDh/DqvbpxyRJX/rc5PaM4ePro/a9W2fM/4PdZAYA9sgXXsPlQQ1J2rhxoz744APFxMToww8/1A033KB3331XwcHBLn25j4uL09ixY3Xu3DmVK1dOISEhWrp0qdq0yTiH+/jx42U2m/Xss88qJSVFYWFhmjhxol0fx44dU0JCgu3xoEGDlJSUpAkTJig+Pl7NmzfXkiVL5O/vn5dFBYASy09WvaD/SZK+UrDSi/h1Nfwsvnph+VBJ0lcfRRFQAMCLkC8AoGTwlVWjU6MkSV/51HR7xvCz+OqFd56WJH398V4yAwB4KZcHNdasWaP58+fr8ccf17///W9ZrVZJUvny5bVixQqXQseMGTOcPu/v76+JEydmCRpXi46OtntsMpk0YsQIjRgxItd1AAAAwPuYjIyb27AnVaEgXwAAAKAoIF94D5eHxFevXq1p06Zp8ODBMpv/eXnDhg115MiRAi0OAAAAQPFGvgAAAADgCpeP1IiJibFdJO9qFotFSUlJBVIUAAAAgJKBfAF4kJHPXUSN/J+6x7By+h9Jsl654tH5G2lp7pmP8c98jCtXZDXl6azoeZ+/z1X3k5NlJCfbP+/WarJx2dMFAEDR5/KRGsHBwTp8+HCW6V9//bVq165dIEUBAAAAuWK4+YYCR74AAABAkUG+8AouD4k/8cQTmjJlilJSUiRJP/zwgzZv3qy3335b06ZNK/ACAQAAABRf5AsAAAAArnB5UKNnz57y9/fXG2+8oaSkJI0aNUpBQUEaP368unXrVhg1AgAAAFlwIb/igXwBAACAooB84T3ydPLC++67T/fdd5+SkpJ0+fJlVapUqaDrAgB4WIrMmqo7bPeLupTkVE19eI7tPgDAe5AvAKBk8HTGIDMAQPHg8qDGm2++qYiICNWoUUOlS5dW6dKlC6MuAICHWU1mfaVgT5eRa9Z0q75a942nywDgTu4+Dy17UhUK8gUAlByezhhkBgBOkS+8hsvD4p9++qk6deqk3r1767333tOFCxcKoy4AAAAAJQD5AgAAAIArXB7U2LRpkzZt2qTbb79dy5YtU7t27fTUU08pMjJSSUlJhVEjAMADzIZV7YwYtTNiZDasni4nR2Yfs9o9dIfaPXSHzD5F/3RZAIAM5AsAKDk8nTHIDABQPOTpL/gtt9yi559/Xl988YVWrFihG264QTNmzFCbNm0Kuj4AgIdYZNUr+kav6BtZVPQHNSz+fnpl7Si9snaULP5+ni4HgBtkXsjPnTcUDvIFAJQMns4YZAYAzpAvvEe+h6XLlCmjUqVKyc/PT2lpaQVREwAAAIASinwBAAAAwBmXLxQuSadOndLmzZu1efNmHTt2TC1atNDw4cPVpUuXgq4PAAAAyB57NxUL5AsAAAAUCeQLr+DyoMbDDz+sH3/8USEhIerRo4fuvfdeValSpTBqAwAAAFDMkS8AAAAAuMLlQY1WrVppxowZqlOnTmHUAwAAAOSK289Dy15bhYJ8AQAAgKKAfOE9XB7UeO655yRJFy5ckCRdf/31BVsRAAAAgBKDfAEAAADAFS4NasTHx+v111/X1q1bFR8fL0kqX768unXrppEjR6p8+fKFUiQAAACA4od8AQAAAMBVuR7UuHjxonr16qVz584pIiJCN998syTpt99+04YNGxQVFaUPPvhAFSpUKLRiAQDukyqzXtNttvtFXWpKml57YpHtPoASwDAybu6cHwoM+QIASh5PZwwyAwCnyBdeI9eDGosWLZLFYtG2bdtUuXJlu+eeffZZPfnkk1q0aJHGjx9f4EUCANwv3WTW56rl6TJyLT0tXZ+v2OHpMgAAuUS+AICSx9MZg8wAAMVDrofFv/jiC40ZMyZL4JCkwMBAvfDCC9q+fXuBFgcAAABkJ/NCfu68oeCQLwAAAFCUkC+8R66P1Dh37pxuueWWbJ+vW7euYmNjC6QoAIDnmQ2rbtNZSdL/VEVWU9E+BZXZx6zbOjeVJP3vs/2ypls9WxAAwCnyBQCUPJ7OGGQGACgecv2vR8WKFRUTE5Pt8zExMZzvFgCKEYusmq7/arr+K4uK/pd9i7+fpm8ep+mbx8ni7+fpcgC4g+GBGwoM+QIASh5PZwwyAwCnvCRfvPfee2rfvr0aNWqknj176ocffnDa/pNPPlGXLl3UqFEjRUREaOfOnXbPf/7553ryySfVsmVLhYSE6PDhw1n6SE5O1uTJk9WyZUs1a9ZMw4cP1/nz5/O2AAUg14MaYWFheuONN5SSkpLluZSUFM2bN09t27Z1aeZr1qxRRESEQkNDFRoaql69etlW6sWLFzV16lR17txZjRs31p133qlp06YpISHBaZ8vvviiQkJC7G4DBgxwqS4AAACgIBR04DAMQ/PmzVNYWJgaN26s/v376/jx4w77SklJ0f33359tMPE08gUAAADgmq1bt2rmzJkaOnSoNmzYoHr16mnAgAGKi4tz2P7777/XqFGj9NBDD2njxo26++67NXToUB05csTW5vLlywoNDdXo0aOzne+MGTP0f//3f3rjjTe0atUqnTt3TsOGDSvw5cutXJ9+asSIEXrwwQfVuXNnPfroo7r55ptlGIaOHj2qNWvWKCUlRa+++qpLM69atapGjx6tmjVryjAMbdy40faGGIahc+fOaezYsapTp45+//13TZo0SefOndP8+fOd9tu2bVvNnDnT9thisbhUFwAAAJBfmYFj8uTJatKkiVasWKEBAwbo008/VaVKlbK0zwwczz//vO666y5FRkZq6NCh+vjjj1W3bl1J0jvvvKNVq1Zp1qxZCg4O1rx58zRgwABt3bpV/v7+dv29+uqrCgoK0s8//+yW5XUV+QIAAABwzfLly/Xwww/rwQcflCRNnjxZO3bs0Pr16/XUU09lab9y5Uq1bdtWAwcOlCSNHDlSu3fv1urVqzVlyhRJUvfu3SUp26OoExIStH79es2ePVutWrWSlDHI0bVrV+3fv19NmzYt4KXMWa4HNapWraoPPvhAkydP1ty5c2UYGcfHmEwmtW7dWhMmTFC1atVcmnn79u3tHj/33HN6//33tX//fvXs2VMLFiywPXfjjTdq5MiReuGFF5SWliZf3+xLt1gsCgwMdKkWAAAAeBmrZHLjmSsMF+dV0IHDMAytXLlSgwcPVocOHSRlDFy0bt1a27dvV7du3Wx97dy5U//973+1YMECffXVV3lc4sJFvgAAAECR4qF8kZiYaDfdYrE43IkmJSVFhw4d0tNPP22bZjab1bp1a+3bt8/hPPbv36/+/fvbTQsLC9P27dtzXefBgweVmpqq1q1b26bVrl1b1atXL/qDGpJUo0YNLVmyRH/99ZdOnDghKSMMXHfddfkuJD09XZ9++qkuX76sZs2aOWyTmJiogIAAp4FDkvbu3atWrVqpfPnyuuOOOzRy5EhVrFgx3zUCAAAAuQkdhRE4YmJiFBsbaxcmypUrpyZNmmjfvn22QY3z58/rlVde0aJFi1SqVKk8L6c7kC8AAABQ0oWHh9s9HjZsmIYPH56l3Z9//qn09PQsR31XqlRJR48eddj3+fPnVbly5SztXbkexvnz5+Xn56fy5ctn6Sc2NjbX/RQklwY1MlWoUEGNGzcukAKio6PVu3dvJScnq0yZMlq0aJHq1KmTpd2FCxf05ptvqlevXk77a9u2rTp27Kjg4GCdOnVKc+fO1aBBg/Thhx/Kx8enQGoGAABAEeDui3f/Pa/chI7CCByZgcFRn5ltDMPQiy++qN69e6tRo0ZOL8RdlJAvAAAA4HEeyhc7d+5UQECAbTKnOs1ZngY1CtJNN92kjRs3KiEhQZ999pnGjh2r1atX2wWPxMREPf3006pdu3aOFyC5+rD7zAv5dejQwbZ3FQAAAJAfRTl0rFq1SpcuXbI7QqSkIV8AAADAmwQEBNjli+xUrFhRPj4+WS4KHhcXl2XnqEyVK1fOclSGs/bZ9ZGamqr4+Hi7ozXi4uI8dopWs0fmehWLxaKaNWuqYcOGGjVqlOrVq6eVK1fank9MTNTAgQNVtmxZLVq0SH5+fi71X6NGDVWsWNF2ODsAIHdSZdYCNdUCNVWq5/+5yFFqSpoWDFuiBcOWKDUlzdPlAHADk+H+m/RP6Mi8ORrUKIzAkRkYnPX5zTffaP/+/WrUqJFuvfVWderUSZL04IMPauzYsS6uYe9EvgCAosvTGYPMAMAZT+WL3LJYLGrQoIGioqJs06xWq6KiorI93WrTpk31zTff2E3bvXu3S9fBaNiwofz8/Ozme/ToUf3xxx8euZ6GVASO1LiW1WpVSkqKpIzAMWDAAFksFr311lvy9/d3ub8zZ87o4sWLXNgPAFyUbjJrk7KerqOoSk9L16Y3P/N0GQAgyT5wZF7UOzNw9OnTx+FrMgPH1dfVuDpwBAcHKzAwUFFRUapfv76kjO/LBw4c0COPPCJJevnllzVy5Ejb68+dO6cBAwbo9ddfV5MmTQp+Qb0A+QIAig5PZwwyAwBv98QTT2js2LFq2LChGjdurBUrVigpKUk9evSQJI0ZM0ZVqlTRqFGjJEn9+vVT3759tWzZMoWHh2vr1q06ePCgpkyZYuvz4sWLOn36tM6dOydJOnbsmKSMna4CAwNVrlw5Pfjgg5o1a5YqVKiggIAATZs2Tc2aNSuZgxpz5sxRu3btVK1aNV26dEmbN2/W3r17tXTpUiUmJurJJ59UUlKSXnvtNSUmJtouynj99dfbzl/bpUsXjRo1Sh07dtSlS5e0cOFCde7cWZUrV9apU6f02muvqWbNmmrbtq0nFxUAAAAlTEEHDpPJpH79+umtt95SzZo1FRwcrHnz5ikoKMg2cFK9enW7GsqUKSMp4+LbVatWddeiewz5AgAAAMVZ165ddeHCBc2fP1+xsbGqX7++lixZYjty+/Tp0zKb/zkSLjQ0VLNnz9Ybb7yhuXPnqlatWlq0aJHq1q1ra/Pll19q3LhxtsfPPfecJPtrB44fP15ms1nPPvusUlJSFBYWpokTJ7pjkR3y6KBGXFycxo4dq3PnzqlcuXIKCQnR0qVL1aZNG+3Zs0cHDhyQJHXs2NHudV988YWCg4MlZYwcJSQkSJJ8fHx05MgR2zl0g4KC1KZNG40YMaJInesYALyB2TDUUBkXpT2oQFlNJg9X5JzZbFbDtvUkSQe//llWq9XDFQEodIaRcXPn/FxQGIFj0KBBSkpK0oQJExQfH6/mzZtryZIleTrioDgiXwBA0ebpjEFmAOBUEc8Xmfr06ZPt0d+rVq3KMu2ee+7RPffck21/PXr0sO14lR1/f39NnDjRowMZVzMZhjvfKe+QmJio5s2bK/i3BjJbfTxdDgB4RCkjTZHaKEmKUHddMRW5MxbaKVXGX5GJqyVJEQF9dOVysocrAkqmbdaPCn0eZ86cUXh4uCqGPCIfS84X1Cso1vQUXfhphb777rtcXcgPuBoZAwA8nzHIDIB3KuyMQb7wPkX7FyoAAAAgO3m4uF5+uHNeAAAAANyMfOE1zDk3AQAAAAAAAAAA8DyO1AAAAIB3Mv6+uXN+AAAAAIon8oXX4EgNAAAAAAAAAADgFRjUAAAAAAAAAAAAXoHTTwEAAMArmbiQHwAAAIACQr7wHgxqAAAcSpNZb6uR7X5Rl5aarrfHrLLdBwAAAFC0eDpjkBkAoHhgUAMA4FCayayPFOLpMnItLTVNH83e5OkyALiTYWTc3Dk/AACQZ57OGGQGAE6RL7xG0d/1FgAAAAAAAAAAQBypAQDIhtkwVEd/SpJ+VUVZTSYPV+Sc2WxWndCbJEm/fn9MVqvVwxUBKGyc8xYAAO/i6YxBZgDgDPnCezCoAQBwyKJ0LdKXkqQIddeVIv5PhqWUnxbtnSVJigjooyuXkz1cEQAAAICreTpjkBkAoHjg9FMAAAAAAAAAAMArFO3dbgEAAABn3HnINoeHAwAAAMUb+cIrcKQGAAAAAAAAAADwChypAQAAAK/EhfwAAAAAFBTyhffgSA0AAAAAAAAAAOAVOFIDAAAA3skwJKsbd28y2JUKAAAAKLbIF16DQQ0AgENpMmul6tvuF3VpqelaOXmt7T4AAACAosXTGYPMAADFA4MaAACH0kxmrVIDT5eRa2mpaVo1+SNPlwEAAAAgG57OGGQGACgeGNQAAACAdzL+vrlzfgAAAACKJ/KF12BQAwDgkMkwdKPiJUknVV6GyeThipwzmUy6sf4NkqSTh3+XwbkpAQAAgCLF0xmDzAAAxQODGgAAh/yVriXaJkmKUHddKeL/ZPiXtmjJwdclSREBfXTlcrKHKwJQ2ExGxs2d8wMAAHnn6YxBZgDgDPnCe3j0yq9r1qxRRESEQkNDFRoaql69emnnzp225/v27auQkBC724QJE5z2aRiG5s2bp7CwMDVu3Fj9+/fX8ePHC3lJAAAAAHga+QIAAAAo/jy6223VqlU1evRo1axZU4ZhaOPGjRo6dKg2bNigW265RZL08MMP69lnn7W9pnTp0k77fOedd7Rq1SrNmjVLwcHBmjdvngYMGKCtW7fK39+/UJcHAAAAbmQYGTd3zg9FGvkCAAAAeUa+8BoePVKjffv2Cg8PV61atXTTTTfpueeeU5kyZbR//35bm1KlSikwMNB2CwgIyLY/wzC0cuVKDR48WB06dFC9evX06quv6ty5c9q+fbsblggAAACAp5AvAAAAgOLPo4MaV0tPT9eWLVt0+fJlNWvWzDY9MjJSLVu21L333qs5c+YoKSkp2z5iYmIUGxur1q1b26aVK1dOTZo00b59+wq1fgAAAABFB/kCAAAAKJ48ftXX6Oho9e7dW8nJySpTpowWLVqkOnXqSJLuvfdeVa9eXUFBQYqOjtbs2bN17NgxLVy40GFfsbGxkqRKlSrZTa9UqZLOnz9fuAsCAAAAt+JCfnCEfAEAAIC8IF94D48Patx0003auHGjEhIS9Nlnn2ns2LFavXq16tSpo169etnahYSEKDAwUP3799fJkyd14403erBqAAAAAEUR+QIAAAAo3jw+qGGxWFSzZk1JUsOGDfXjjz9q5cqVmjJlSpa2TZo0kSSdOHHCYegIDAyUJMXFxSkoKMg2PS4uTvXq1SuM8gGg2EqTWWtV13a/qEtLTdfa2Zts9wGUAMbfN3fOD0Ue+QIAii5PZwwyAwCnyBdew+ODGteyWq1KSUlx+Nzhw4cl/RMurhUcHKzAwEBFRUWpfv36kqTExEQdOHBAjzzySOEUDADFVJrJrHfU2NNl5FpaapreGbPK02UAAIoY8gUAFB2ezhhkBgAoHjw6qDFnzhy1a9dO1apV06VLl7R582bt3btXS5cu1cmTJxUZGanw8HBdd911io6O1syZM9WiRQu7vaK6dOmiUaNGqWPHjjKZTOrXr5/eeust1axZU8HBwZo3b56CgoLUoUMHDy4pAAAAClrGOW/dt3uTO+eFvCFfAAAAIK/IF97Do4MacXFxGjt2rM6dO6dy5copJCRES5cuVZs2bXT69GlFRUVp5cqVunz5sqpVq6ZOnTppyJAhdn0cO3ZMCQkJtseDBg1SUlKSJkyYoPj4eDVv3lxLliyRv7+/uxcPALyayTAUpMuSpHMqI8Nk8nBFzplMJgXdWFmSdO7keRl8OQCAEod8AQBFm6czBpkBAIoHk8Ff8CwSExPVvHlzBf/WQGarj6fLAQCPKGWkKVIbJUkR6q4rpiJ3xkI7pcr4KzJxtSQpIqCPrlxO9nBFQMm0zfpRoc/jzJkzCg8PV5XqD8vXt2yhzy+T1Zqi0zHv6bvvvlNAQIDb5ovigYwBAJ7PGGQGwDsVdsYgX3ifov0LFQAAAJAd6983d84PAAAAQPFEvvAaZk8XAAAAAAAAAAAAkBscqQEAAACvZDIMLuQHAAAAoECQL7wHR2oAAAAAAAAAAACvwJEaAAAA8E7G3zd3zg8AAABA8US+8BocqQEAAAAAAAAAALwCR2oAABxKl0mbVNt2v6hLT0vXpjc/td0HAAAAULR4OmOQGQCgeGBQAwDgUKrJRwvUzNNl5FpqSpoWDFvq6TIAuJNhZNzcOT8AAJBnns4YZAYATpEvvAannwIAAAAAAAAAAF6BIzUAAI4ZhiooRZL0lyySqeifgqpC5fKSpL/Ox3u4EgDuYDIybu6cHwAAyIcikDHIDACyQ77wHgxqAAAcKqV0rVOkJClC3XWliP+TUaqMv9adyziUPCKgj65cTvZwRQAAAACu5umMQWYAgOKhaP9CBQAAAGSHc94CAAAAKCjkC6/BNTUAAAAAAAAAAIBXYFADAAAAAAAAAAB4BU4/BQAAAK9ksmbc3Dk/AAAAAMUT+cJ7cKQGAAAAAAAAAADwChypAQAAAC/FhfwAAAAAFBTyhbdgUAMA4FC6TPpcNW33i7r0tHR9/u4O230AAAAARYunMwaZAQCKBwY1AAAOpZp89JpaeLqMXEtNSdNrTy7ydBkA3Mn4++bO+QEAgDzzdMYgMwBwinzhNbimBgAAAAAAAAAA8AocqQEAcMwwVEoZh2RfkY9kKvqnoCpVxl+SdOVysocrAQAAAJBFEcgYZAYA8H4MagAAHCqldEVqoyQpQt11pYj/k1GqjL8iE1dLkiIC+hBSgBLAJEMmN15cz8Tx4QAA5IunMwaZAYAz5Avv4dFfqNasWaP3339fv//+uyTplltu0ZAhQxQeHq6YmBjdfffdDl/3xhtv6J577nH43IsvvqgNGzbYTQsLC9PSpUsLtngAAAAARQr5AgAAACj+PDqoUbVqVY0ePVo1a9aUYRjauHGjhg4dqg0bNujmm2/Wrl277Np/+OGHWrp0qdq1a+e037Zt22rmzJm2xxaLpVDqBwAAgAcZkty4JxU7UhV95AsAAADkGfnCa3h0UKN9+/Z2j5977jm9//772r9/v2655RYFBgbaPb99+3bdc889Klu2rNN+LRZLltcCAAAAKN7IFwAAAEDxZ/Z0AZnS09O1ZcsWXb58Wc2aNcvy/MGDB3X48GE99NBDOfa1d+9etWrVSp07d9bEiRP1559/FkbJAAAA8CSrB27wGuQLAAAAuIR84TU8ftXX6Oho9e7dW8nJySpTpowWLVqkOnXqZGm3bt061a5dW6GhoU77a9u2rTp27Kjg4GCdOnVKc+fO1aBBg/Thhx/Kx8ensBYDAAAAQBFAvgAAAACKN48Patx0003auHGjEhIS9Nlnn2ns2LFavXq1XfC4cuWKNm/erCFDhuTYX7du3Wz3Q0JCFBISog4dOtj2rgIAAABQfJEvAAAAgOLN44MaFotFNWvWlCQ1bNhQP/74o1auXKkpU6bY2nz66ae6cuWKunfv7nL/NWrUUMWKFXXixAlCBwC4IF0mfaUbbPeLuvR0q776KMp2H0DxZzIMmdx4IT93zgt5R74AgKLL0xmDzADAGfKF9/D4oMa1rFarUlJS7KatX79e7du31/XXX+9yf2fOnNHFixe5sB8AuCjV5KOp8p4fa1KTUzW111xPlwEAKGLIFwBQdHg6Y5AZAKB48OiFwufMmaNvv/1WMTExio6O1pw5c7R3715FRETY2pw4cULffvttthfw69Kli7Zt2yZJunTpkv71r39p//79iomJUVRUlIYMGaKaNWuqbdu2blkmAAAAuIlhuP+GIo18AQAAgDwjX3gNjx6pERcXp7Fjx+rcuXMqV66cQkJCtHTpUrVp08bWZv369apatarCwsIc9nHs2DElJCRIknx8fHTkyBHbOXSDgoLUpk0bjRgxQhaLxS3LBAAAAMAzyBcAAABA8WcyDIaErpWYmKjmzZsr+LcGMlt9PF0OAHhEKSNNkdooSYpQd10xFbkzFtopVcZfkYmrJUkRAX105XKyhysCSqZt1o8KfR5nzpxReHi4gsvcJ19zmUKfXyarkaqTl9bru+++U0BAgNvmi+KBjAEAns8YZAbAOxV2xiBfeB+Pnn4KAAAAAAAAAAAgtxjUAAAAAAAAAAAAXoFBDQAAAHgnqwduLnrvvffUvn17NWrUSD179tQPP/zgtP0nn3yiLl26qFGjRoqIiNDOnTvtnjcMQ/PmzVNYWJgaN26s/v376/jx47bnY2JiNH78eLVv316NGzdWhw4dNH/+fKWkpLhePAAAAFCSeEG+kNyfMSSpffv2CgkJsbu9/fbbeVuAAsCgBgAAAFAItm7dqpkzZ2ro0KHasGGD6tWrpwEDBiguLs5h+++//16jRo3SQw89pI0bN+ruu+/W0KFDdeTIEVubd955R6tWrdKkSZO0du1alS5dWgMGDFBycsY5wY8ePSrDMDRlyhRt2bJF48aN0wcffKDXX3/dLcsMAAAAoPB4ImNkevbZZ7Vr1y7brU+fPoW6rM4wqAEAAACvZDIMt99csXz5cj388MN68MEHVadOHU2ePFmlSpXS+vXrHbZfuXKl2rZtq4EDB6p27doaOXKkbr31Vq1enXFBU8MwtHLlSg0ePFgdOnRQvXr19Oqrr+rcuXPavn27JKldu3aaOXOmwsLCVKNGDd1999168skn9fnnn+dvZQMAAADFXFHPF5JnMkamsmXLKjAw0HYrU8Z9F1W/FoMaAAAAgAsSExPtbo5O7ZSSkqJDhw6pdevWtmlms1mtW7fWvn37HPa7f/9+tWrVym5aWFiY9u/fLynj1FKxsbF2fZYrV05NmjTJtk9JSkhIUIUKFVxZRAAAAABukpt8IXk+Y7zzzjtq2bKlunfvriVLligtLS0vi1sgfD02ZwBAkZYuk/aoqu1+UZeebtWeLd/b7gMoAQwj4+bO+UkKDw+3mzxs2DANHz7cbtqff/6p9PR0VapUyW56pUqVdPToUYfdnz9/XpUrV87S/vz585Kk2NhY27Ts2lzrxIkTWr16tcaOHetsyQAAcAtPZwwyAwCninC+kDybMfr27atbb71VFSpU0L59+zR37lzFxsZq3LhxuVnSAsegBgDAoVSTj15WmKfLyLXU5FS9HDHT02UAKAF27typgIAA22OLxeLBarJ39uxZDRw4UF26dNHDDz/s6XIAAPB4xiAzACiKvCFfPPHEE7b79erVk5+fnyZOnKhRo0Z5pF5OPwUAAAC4ICAgwO7m6Et8xYoV5ePjk+WCfXFxcVn2lMpUuXLlLEdcXN0+MDDQNi2nPs+ePat+/fqpWbNmmjp1qmsLCAAAAMBtcpMvJM9njKs1adJEaWlpiomJcb5whYRBDQAAAHinzMPD3XnLJYvFogYNGigqKso2zWq1KioqSs2aNXP4mqZNm+qbb76xm7Z79241bdpUkhQcHKzAwEC7PhMTE3XgwAG7PjMHNBo0aKCZM2fKbOYrPwAAAJCjIpwvJM9mjGsdPnxYZrM5y2mr3IXTTwEAHCplpGmtIiVJDytCV0xF+5+MUmX8tfbsEknSw1UG6srlZA9XBKCke+KJJzR27Fg1bNhQjRs31ooVK5SUlKQePXpIksaMGaMqVapo1KhRkqR+/fqpb9++WrZsmcLDw7V161YdPHhQU6ZMkSSZTCb169dPb731lmrWrKng4GDNmzdPQUFB6tChg6SMAY2+ffuqevXqGjt2rC5cuGCrJ3MvLAAAPMXTGYPMAMDbeSJj7Nu3TwcOHNAdd9yhsmXLat++fZo5c6buu+8+VahQwSProWj/QgUA8KjSSvd0CS4pXbaUp0sA4E4eupBfbnXt2lUXLlzQ/PnzFRsbq/r162vJkiW2w7hPnz5tdxRFaGioZs+erTfeeENz585VrVq1tGjRItWtW9fWZtCgQUpKStKECRMUHx+v5s2ba8mSJfL395ck/fe//9WJEyd04sQJtWvXzq6e6OjovC45AAAFxtMZg8wAIFtFPF9InskYFotFW7du1cKFC5WSkqLg4GD179/f7job7mYyDHe+U94hMTFRzZs3V/BvDWS2+ni6HADwiFJGmiK1UZIUoe5ecaRGZOJqSVJEQB/2ugI8ZJv1o0Kfx5kzZxQeHq4avl3lay5T6PPLZDVSdSL1P/ruu+/sLuQH5AYZAwA8nzHIDIB3KuyMQb7wPkX7FyoAAAAgO1Y3z49dgQAAAIDii3zhNbhqIAAAAAAAAAAA8AoMagAAAAAAAAAAAK/A6acAAADglUyGIZMbLw/nznkBAAAAcC/yhfdgUAMA4JBVJh1QZdv9os5qNXRgxyHbfQAAAABFi6czBpkBAIoHBjUAAA6lmHw0Wnd6uoxcS7mSotHtJ3m6DADuZBgZN3fODwAA5JmnMwaZAYBT5AuvwTU1AAAAAAAAAACAV+BIDQAAAHgpQ3LrqSPYkwoAAAAovsgX3oIjNQAADpUy0vSRsUkfGZtUykjzdDk5KlXGXx+dXaqPzi5VqTL+ni4HAAAAwDU8nTHIDABQPBSZQY23335bISEhmj59um1acnKyJk+erJYtW6pZs2YaPny4zp8/77QfwzA0b948hYWFqXHjxurfv7+OHz9eyNUDQPF0nVJ0nVI8XUauXRdYXtcFlvd0GQCAIoKMAQBFj6czBpkBALxfkRjU+OGHH/TBBx8oJCTEbvqMGTP0f//3f3rjjTe0atUqnTt3TsOGDXPa1zvvvKNVq1Zp0qRJWrt2rUqXLq0BAwYoOTm5MBcBAAAA7pZ5IT933uA1yBgAAABwCfnCa3h8UOPSpUt64YUXNG3aNFWoUME2PSEhQevXr9eLL76oVq1aqWHDhpoxY4b27dun/fv3O+zLMAytXLlSgwcPVocOHVSvXj29+uqrOnfunLZv3+6mJQIAAADgSWQMAAAAoPjy+KDGlClTFB4ertatW9tNP3jwoFJTU+2m165dW9WrV882cMTExCg2NtbuNeXKlVOTJk20b9++QqkfAAAAHsKeVMgGGQMAAAAuI194DV9PznzLli366aeftG7duizPnT9/Xn5+fipf3v48h5UqVVJsbKzD/jKnV6pUKctrcjpPLgAAAADvR8YAAAAAijePDWqcPn1a06dP17Jly+Tv7++pMgAAAOCtDEOSO/duYk+qoo6MAQAAgDwjX3gNjw1qHDp0SHFxcerRo4dtWnp6ur799lu99957Wrp0qVJTUxUfH2+3J1VcXJwCAwMd9pk5PS4uTkFBQXavqVevXiEtCQAUT1aZFK2KtvtFndVqKPrbX233AQAlDxkDAIo2T2cMMgMAFA8eG9S44447FBkZaTdt3LhxuvnmmzVo0CBVq1ZNfn5+ioqKUufOnSVJR48e1R9//KGmTZs67DM4OFiBgYGKiopS/fr1JUmJiYk6cOCAHnnkkUJdHgAoblJMPhqmuz1dRq6lXEnRsJbjPF0GAMCDyBgAULR5OmOQGQCgePDYoEZAQIDq1q1rN61MmTK67rrrbNMffPBBzZo1SxUqVFBAQICmTZumZs2a2QWOLl26aNSoUerYsaNMJpP69eunt956SzVr1lRwcLDmzZunoKAgdejQwZ2LBwAAgMJmldx+eLiPG2cHl5ExAAAAkGfkC6/h0QuF52T8+PEym8169tlnlZKSorCwME2cONGuzbFjx5SQkGB7PGjQICUlJWnChAmKj49X8+bNtWTJEs6pCwAAAICMAQAAAHg5k2EYnETwGomJiWrevLmCf2sgs5XhMgAlk7+RpiX6XJI0UJ2UbCrS4+DyL23RkkOvS5IGNnhOyUkpHq4IKJm2WT8q9HmcOXNG4eHhujGlvXxVutDnl8mqVB23fK7vvvtOAQEBbpsvigcyBgB4PmOQGQDvVNgZg3zhfYr2L1QAAI8xSaqqy7b7RZ3JZFLVWkG2+wAAAACKFk9nDDIDABQPDGoAAADAOxmG3H7OWwAAAADFE/nCa5g9XQAAAAAAAAAAAEBuMKgBAAAAAAAAAAC8AqefAgAAgHeycng4AAAAgAJCvvAaHKkBAAAAAAAAAAC8AkdqAAAcMiQdV3nb/aLOMAwdP3TKdh9ACWDY/gMAALyApzMGmQGAU+QLr8GgBgDAoWSTrwapk6fLyLXkpBQNavS8p8sAAAAAkA1PZwwyAwAUDwxqAAAAwDsZnPMWAAAAQAEhX3gNrqkBAAAAAAAAAAC8AoMaAACH/I00vWN8rneMz+VvpHm6nBz5l7bonR/n6p0f58q/tMXT5QAAAAC4hqczBpkBAIoHTj8FAHDIJKmW4m33izqTyaRaDWrY7gMoATg8HAAAr+LpjEFmAOAU+cJrcKQGAAAAAAAAAADwChypAQAAAO9ktUqyunOGbpwXAAAAALciX3gNjtQAAAAAAAAAAABegSM1AAAA4J045y0AAACAgkK+8BocqQEAAAAAAAAAALwCR2oAABwyJJ1RGdv9os4wDJ05fs52HwAAAEDR4umMQWYAgOKBQQ0AgEPJJl/1VVdPl5FryUkp6nvzUE+XAcCdODwcAACv4umMQWYA4BT5wmtw+ikAAAAAAAAAAOAVOFIDAAAA3snKnlQAAAAACgj5wmtwpAYAwCGLka6FxhdaaHwhi5Hu6XJyZCll0cI9M7Vwz0xZSlk8XQ4AAACAa3g6Y5AZAKB4KDKDGm+//bZCQkI0ffp0SdLFixc1depUde7cWY0bN9add96padOmKSEhwWk/L774okJCQuxuAwYMcMciAECxYpahEP2pEP0psxfsPWA2mxTSoo5CWtSR2WzydDkA3MCQVYbhxpusnl5kuIiMAQBFi6czBpkBgDPkC+9RJE4/9cMPP+iDDz5QSEiIbdq5c+d07tw5jR07VnXq1NHvv/+uSZMm6dy5c5o/f77T/tq2bauZM2faHlssjL4DAAAAJQkZAwAAACiePD6ocenSJb3wwguaNm2a3nrrLdv0unXrasGCBbbHN954o0aOHKkXXnhBaWlp8vXNvnSLxaLAwMBCrRsAAABA0UTGAAAAAIovj59+asqUKQoPD1fr1q1zbJuYmKiAgACnYUOS9u7dq1atWqlz586aOHGi/vzzz4IqFwAAAEWFYWRczM+dN3gFMgYAAABcRr7wGh49UmPLli366aeftG7duhzbXrhwQW+++aZ69erltF3btm3VsWNHBQcH69SpU5o7d64GDRqkDz/8UD4+PgVVOgAAAIAiiIwBAAAAFG8eG9Q4ffq0pk+frmXLlsnf399p28TERD399NOqXbu2hg0b5rRtt27dbPczL+LXoUMH255VAAAAKCYMI+Pmvhm6cV7ICzIGAAAA8ox84TU8Nqhx6NAhxcXFqUePHrZp6enp+vbbb/Xee+/pxx9/lI+PjxITEzVw4ECVLVtWixYtkp+fn0vzqVGjhipWrKgTJ04QOADARRflXRdBvRgb7+kSAAAeRMYAgKLP0xmDzAAA3s9jgxp33HGHIiMj7aaNGzdON998swYNGmQLGwMGDJDFYtFbb72V495Wjpw5c0YXL17kon4A4KIrJl/11H2eLiPXrlxOVs8qAzxdBgB3slozbu5icuO8kCdkDAAo2jydMcgMAJwiX3gNjw1qBAQEqG7dunbTypQpo+uuu05169ZVYmKinnzySSUlJem1115TYmKiEhMTJUnXX3+97dy1Xbp00ahRo9SxY0ddunRJCxcuVOfOnVW5cmWdOnVKr732mmrWrKm2bdu6fRkBAAAAuA8ZAwAAACj+PHqhcGcOHTqkAwcOSJI6duxo99wXX3yh4OBgSdKxY8eUkJAgSfLx8dGRI0e0ceNGJSQkKCgoSG3atNGIESNksXjXKVQAAAAAFCwyBgAAAOD9itSgxqpVq2z3W7Zsqejo6Bxfc3WbUqVKaenSpYVSGwCUNBYjXTP0tSRpvNoqxeTj4Yqcs5SyaMbW8ZKk8V1nKOVKiocrAlDoDHEhP+SIjAEARYenMwaZAYBT5AuvUaQGNQAARYdZhprovO1+UWc2m9Tkzga2+wAAAACKFk9nDDIDABQPDGoAAADAKxlWqww3XsjP4EJ+AAAAQLFFvvAeZk8XAAAAAAAAAAAAkBscqQEAAADvZBic8xYAAABAwSBfeA2O1AAAAAAAAAAAAF6BQQ0AAAAAAAAAAOAVOP0UACBbSfLxdAkuSbp0xdMlAHAnqySrGw/ZNrlvVgAAFFeezhhkBgDZIl94DQY1AAAOXTH56j494Okycu3K5WTdV66vp8sAAAAAkA1PZwwyAwAUDwxqAAAAwDsZ1oyb27hzXgAAAADcinzhNbimBgAAAAAAAAAA8AocqQEAcMjPSNdERUmSJquVUk1F+/oafv5+mrhutCRp8kOzlZqc6uGKABQ2w2rIcOM5bw2TG8+vCwBAMeTpjEFmAOAM+cJ7MKgBAHDIR4Za6oztflH/uu/jY1bLbqG2+0W9XgAAAKCk8XTGIDMAQPHA6acAAAAAAAAAAIBX4EgNAAAAeCcu5AcAAACgoJAvvAZHagAAAAAAAAAAAK/AkRoAAADwSlzIDwAAAEBBIV94D47UAAAAAArJe++9p/bt26tRo0bq2bOnfvjhB6ftP/nkE3Xp0kWNGjVSRESEdu7cafe8YRiaN2+ewsLC1LhxY/Xv31/Hjx+3a3Px4kWNGjVKoaGhuu222zR+/HhdunSpoBcNAAAAgAeQMThSwyHDyBgls5rSGfYBUGKlG+lK/PuPYLrSZTWZPFyRc+mmdCUmJtruW83pHq4IKJkSExNVtmxZmdzyN8PN57w1uTavrVu3aubMmZo8ebKaNGmiFStWaMCAAfr0009VqVKlLO2///57jRo1Ss8//7zuuusuRUZGaujQofr4449Vt25dSdI777yjVatWadasWQoODta8efM0YMAAbd26Vf7+/pKk0aNHKzY2VsuXL1dqaqrGjx+vCRMmaM6cOflfB8gzMgYAeD5jkBkA72QYBvnib2SMDCYj89s1bM6cOaPw8HBPlwEAAOCVvvvuOwUEBBRa/5nf1aofrSffdEuhzedaVnO6YmofyvXy9ezZU40aNdKECRMyXm+1Kjw8XH379tVTTz2Vpf3IkSOVlJSkxYsX26Y9/PDDqlevnqZMmSLDMNS2bVs98cQTGjBggCQpISFBrVu31qxZs9StWzf99ttv6tq1q9atW6dGjRpJkr766is99dRT2rlzp6pUqVIQqwJ5QMYAAADIG/LFP8gYGThSw4GgoCDt3LnTjXsZAgAAFB9ly5Yt1P4z98lJ90kt1Plcy2rO2JMqISHBbrrFYpHFYh9+UlJSdOjQIT399NO2aWazWa1bt9a+ffsc9r9//37179/fblpYWJi2b98uSYqJiVFsbKxat25te75cuXJq0qSJ9u3bp27dumnfvn0qX768LWxIUuvWrWU2m/XDDz+oY8eOri84CgQZAwAAIG/IFxnIGP9gUMMBs9msqlWreroMAAAAOJCSkiJJOlvzN4/M/84777R7PGzYMA0fPtxu2p9//qn09PQsh4BXqlRJR48eddjv+fPnVbly5Sztz58/L0mKjY21Tcuuzfnz53X99dfbPe/r66sKFSrYXg/PIGMAAAAUTd6QLyQyht38PTJXAAAAII9q1Kihzz//XBaLxe17vBuGoYCAALv5OtqLCgAAAIB3IF94HwY1AAAA4FXMZrNq1qzp6TKcqlixonx8fBQXF2c3PS4uLsueUpkqV65s2xvKUfvAwEDbtKCgILs29erVs/Vx4cIFuz7S0tL0119/2V4PAAAA4B/ekC8kMsbVzB6ZKwAAAFCMWSwWNWjQQFFRUbZpVqtVUVFRatasmcPXNG3aVN98843dtN27d6tp06aSpODgYAUGBtr1mZiYqAMHDtj6bNasmeLj43Xw4EFbm2+++UZWq1WNGzcuqMUDAAAA4GZkjH8wqAEAAAAUgieeeEJr167Vhg0b9Ntvv2nSpElKSkpSjx49JEljxozRnDlzbO379eunr7/+WsuWLdNvv/2mBQsW6ODBg+rTp48kyWQyqV+/fnrrrbf0xRdfKDo6WmPGjFFQUJA6dOggSapdu7batm2rV155RT/88IO+++47TZ06Vd26dVOVKlXcvxIAAAAAFBgyRgZOPwUAAAAUgq5du+rChQuaP3++YmNjVb9+fS1ZssR2qPfp06dlNv+zj1FoaKhmz56tN954Q3PnzlWtWrW0aNEi1a1b19Zm0KBBSkpK0oQJExQfH6/mzZtryZIl8vf3t7WZPXu2pk6dqscff1xms1mdOnXSyy+/7L4FBwAAAFAoyBgZTIZhGB6bOwAAAAAAAAAAQC5x+ikAAAAAAAAAAOAVGNQAAAAAAAAAAABegUGNbLz33ntq3769GjVqpJ49e+qHH35w2v6TTz5Rly5d1KhRI0VERGjnzp15nvfixYv14IMPqlmzZmrVqpWGDBmio0ePOn3Nxx9/rJCQELtbo0aN8lzDggULsvTXpUsXp68pyHUgSe3bt89SQ0hIiCZPnuywfUGsg2+//VbPPPOMwsLCFBISou3bt9s9bxiG5s2bp7CwMDVu3Fj9+/fX8ePHc+zXle3JWQ2pqal67bXXFBERoaZNmyosLExjxozR2bNnnc7f1fczp/Xw4osvZulvwIABblsPkhxuGyEhIVqyZEmBrIfcfA6Tk5M1efJktWzZUs2aNdPw4cN1/vx5p+vAlW0opxouXryoqVOnqnPnzmrcuLHuvPNOTZs2TQkJCU5rcOX9y8166Nu3b5b+JkyY4Lb1EBMTk+328MknnxTIelizZo0iIiIUGhqq0NBQ9erVy+5vXGFvCznV4I5tITfrobC3hZxqcMe24Mjbb7+tkJAQTZ8+3TbNHduEsxrctU0AcA0Zg4xBxiBjkDHIGJnIGLlbDyUxY5AvgFwwkMWWLVuMBg0aGOvWrTN++eUX4+WXXzZuu+024/z58w7bf/fdd0b9+vWNd955x/j111+N119/3WjQoIERHR2dp/k/+eSTxvr1640jR44Yhw8fNgYNGmTceeedxqVLl7J9zfr1643Q0FDj3LlztltsbGye5m8YhjF//nyjW7dudv3FxcVl276g14FhGEZcXJzd/P/73/8adevWNb755huH7QtiHezYscOYO3eu8fnnnxt169Y1tm3bZvf84sWLjebNmxvbtm0zDh8+bDzzzDNG+/btjStXrmTbp6vbk7Ma4uPjjf79+xtbtmwxfvvtN2Pfvn3GQw89ZDzwwANOl8vV9zOn9TB27FhjwIABdv1dvHjRaQ0FuR4Mw7Cb97lz54x169YZISEhxsmTJwtkPeTmczhhwgQjPDzc2L17t/Hjjz8aDz/8sNGrVy+n68GVbSinGqKjo41hw4YZX3zxhXHixAlj9+7dRqdOnYzhw4c7rcGV9y8366FPnz7Gyy+/bNdfQkKC29ZDWlpalu1hwYIFRtOmTY3ExMQCWQ9ffPGFsWPHDuPYsWPG0aNHjblz5xoNGjQwjhw5YhhG4W8LOdXgjm0hN+uhsLeFnGpwx7ZwrQMHDhh33XWXERERYUybNs023R3bhLMa3LVNAMg9MgYZg4xBxiBj5H49kDHIGCU1Y5AvgNxhUMOBhx56yJg8ebLtcXp6uhEWFmYsXrzYYfsRI0YYTz31lN20nj17Gq+88kqB1BMXF2fUrVvX2Lt3b7Zt1q9fbzRv3rxA5mcYGV/M7rvvvly3L+x1YBiGMW3aNKNDhw6G1Wp1+HxBr4Nrv+RarVajTZs2xpIlS2zT4uPjjYYNGxqbN2/Oth9XtydnNThy4MABo27dusbvv/+ebRtX38+cahg7dqwxePBgl/op7PUwePBgo1+/fk7b5Gc9XPs5jI+PNxo0aGB88skntja//vqrUbduXWPfvn0O+8jrNpRdDY5s3brVaNCggZGampptm7y8f85q6NOnj92XrZy4Yz3cf//9xrhx45z2k5/1YBiG0aJFC2Pt2rUe2RaurcGRwt4WHNXg7m3BUQ3XKsxtITEx0ejUqZPx3//+127Z3blNZFeDI+7aJgA4RsYgYxgGGcNZDWQMMgYZg4zhqIaSlDHIF0Ducfqpa6SkpOjQoUNq3bq1bZrZbFbr1q21b98+h6/Zv3+/WrVqZTctLCxM+/fvL5CaMg/lqlChgtN2ly9f1l133aXw8HANHjxYv/zyS77me+LECYWFhenuu+/WqFGj9Mcff2TbtrDXQUpKijZt2qQHH3xQJpMp23YFvQ6uFhMTo9jYWLtto1y5cmrSpEm220ZetidXJSYmymQyqXz58k7bufJ+5sbevXvVqlUrde7cWRMnTtSff/6ZbdvCXg/nz5/Xzp079dBDD+XYNq/r4drP4cGDB5Wammq3TLVr11b16tWz3e7zsg05q8GRxMREBQQEyNfX12lfrrx/uakhMjJSLVu21L333qs5c+YoKSkp2z4Kez0cPHhQhw8fztX2kJf1kJ6eri1btujy5ctq1qyZR7aFa2twpLC3hexqcOe2kNN6KOxtYcqUKQoPD7erP3O+7tomsqvBkcLeJgBkj4zxDzKGPTKGPTIGGeNqZAwyRqaSkjHIF0DuOd/qSqA///xT6enpqlSpkt30SpUqZXvO2fPnz6ty5cpZ2ud0brvcsFqtmjFjhkJDQ1W3bt1s2910002aMWOGQkJClJCQoGXLlql3797asmWLqlat6vJ8GzdurJkzZ+qmm25SbGysFi1apMcee0yRkZEKCAjI0r4w14Ekbd++XQkJCXrggQeybVPQ6+BasbGxkuRw28huOfOyPbkiOTlZs2fPVrdu3Ry+L5lcfT9z0rZtW3Xs2FHBwcE6deqU5s6dq0GDBunDDz+Uj49PlvaFvR42bNigsmXLqlOnTk7b5XU9OPocnj9/Xn5+flmCXqVKlWzbyrXysg05q+FaFy5c0JtvvqlevXo57cvV9y+nGu69915Vr15dQUFBio6O1uzZs3Xs2DEtXLjQYT+FvR7WrVun2rVrKzQ01Glfrq6H6Oho9e7dW8nJySpTpowWLVqkOnXq6PDhw27bFrKr4VqFuS04q8Fd20Ju10NhbQuStGXLFv30009at25dlufc9ffBWQ3XKuy/DwCcI2NkIGNkRcb4BxmDjEHGIGOU5IxBvgBcw6BGETd58mT98ssvWrNmjdN2zZo1sxtBbtasmbp27aoPPvhAI0eOdHm+4eHhtvv16tVTkyZNdNddd+mTTz5Rz549Xe4vv9avX6927dqpSpUq2bYp6HVQ1KWmpmrEiBEyDCPbCxtmKuj3s1u3brb7mRd66tChg2303d3Wr1+viIgI+fv7O22X1/WQ289hYcqphsTERD399NOqXbu2hg0b5rSvvL5/2dVw9ZeYkJAQBQYGqn///jp58qRuvPHG3CxeruW0Hq5cuaLNmzdryJAhOfbl6nq46aabtHHjRiUkJOizzz7T2LFjtXr16rwvTB5kV8PVX7YLe1twVoO7toXcrIfC3BZOnz6t6dOna9myZTn+3SksrtTgjr8PALwLGSMDGSMrMsY/yBhkjExkDDJGpsLaFsgXgOs4/dQ1KlasKB8fH8XFxdlNj4uLy7KXUKbKlStnGeV01j63pkyZoh07dmjFihUu7wXk5+en+vXr6+TJk/mqIVP58uVVq1atbPsrrHUgSb///rt2796dq0P7rlbQ6yAwMFCSXNo28rI95UZqaqpGjhypP/74Q8uWLXN5T6ic3k9X1ahRQxUrVtSJEyccPl9Y60GS/ve//+nYsWN5Ck65WQ/ZfQ4rV66s1NRUxcfH27WPi4uzbSvXyss25KyGTImJiRo4cKDKli2rRYsWyc/PL9u+HMnp/ctNDVdr0qSJJGXbX2GtB0n69NNPdeXKFXXv3t1pjY7ktB4sFotq1qyphg0batSoUapXr55Wrlzp1m0huxoyuWNbyKmGqxXWtpCbGgpzWzh06JDi4uLUo0cP3Xrrrbr11lu1d+9erVq1SrfeeqtbtomcakhPT5fknm0CQM7IGI6RMcgYzpAx/kHGIGNcvTxkjOKXMcgXgOsY1LiGxWJRgwYNFBUVZZtmtVoVFRWV7TkFmzZtqm+++cZu2u7du9W0adM81WAYhqZMmaJt27ZpxYoVqlGjhst9pKen68iRI9n+cXPVpUuXdOrUqWz7K+h1cLWPP/5YlSpV0p133unS6wp6HQQHByswMNBu20hMTNSBAwey3Tbysj3lJDNsnDhxQu+++64qVqzoch85vZ+uOnPmjC5evJhtf4WxHjKtW7dODRo0UL169Vx+rbP1kNPnsGHDhvLz87NbpqNHj+qPP/7Idrt3dRvKzd+CxMREDRgwQH5+fnrrrbfytFeHs/cvL3+PDh8+LEnZbg+FsR4yrV+/Xu3bt9f111+fY53Xymk7vpbValVKSopbtoWcash8fWFuC7mp4VoFvS24UkNhbgt33HGHIiMjtXHjRtutYcOGioiIsN0v7G0ipxp8fHw8tk0AyIqM4RgZg4zhDBkjAxkjAxmDjJGpOGYM8gWQB565PnnRtmXLFqNhw4bGxx9/bPz666/GK6+8Ytx2221GbGysYRiG8cILLxizZ8+2tf/uu++MW2+91Vi6dKnx66+/GvPnzzcaNGhgREdH52n+EydONJo3b27s2bPHOHfunO2WlJRka3NtDQsWLDC+/vpr4+TJk8bBgweN5557zmjUqJHxyy+/5KmGWbNmGXv27DFOnTplfPfdd0b//v2Nli1bGnFxcW5ZB5nS09ONO++803jttdeyPFcY6yAxMdH46aefjJ9++smoW7eusXz5cuOnn34yfv/9d8MwDGPx4sXGbbfdZmzfvt34+eefjcGDBxvt27c3rly5YuujX79+xqpVq2yPc9qeXKkhJSXFeOaZZ4x27doZhw8ftts+kpOTs60hp/fTlRoSExONWbNmGfv27TNOnTpl7N6923jggQeMTp06Oa2hINdDpoSEBKNJkybGmjVrHPaRn/WQm8/hhAkTjDvvvNOIiooyfvzxR6NXr15Gr1697Prp3Lmz8fnnn9se52Ybym0NCQkJRs+ePY17773XOHHihF2btLQ0hzXk9v3LbQ0nTpwwFi5caPz444/GqVOnjO3btxt333238dhjj7ltPWQ6fvy4ERISYuzcuTNLH/ldD7Nnzzb27t1rnDp1yvj555+N2bNnGyEhIcauXbsMwyj8bSGnGtyxLeRUgzu2hdy8F4ZRuNtCdvr06WNMmzbN9tgd24SzGty1TQDIPTIGGYOMQcYgY+SuBjIGGYOMQb4AcsI1NRzo2rWrLly4oPnz5ys2Nlb169fXkiVLbIdnnT59WmbzPwe5hIaGavbs2XrjjTc0d+5c1apVS4sWLXJ60T1n3n//fUlS37597abPnDlTPXr0cFhDfHy8XnnlFcXGxqpChQpq0KCBPvjgA4cXNcqNM2fO6Pnnn9fFixd1/fXXq3nz5lq7dq1tNLqw10Gm3bt3648//tCDDz6Y5bnCWAcHDx5Uv379bI9nzpwpSXrggQc0a9YsDRo0SElJSZowYYLi4+PVvHlzLVmyxG50+tSpU/rzzz9tj3PanlypYdiwYfryyy8lSffff7/d61auXKmWLVs6rCGn99OVGiZNmqQjR47YzjUZFBSkNm3aaMSIEbJYLG5ZD7NmzZKUcRErwzB07733OuwjP+shN5/D8ePHy2w269lnn1VKSorCwsI0ceJEu/bHjh1TQkKC7XFutqHc1nDo0CEdOHBAktSxY0e7Nl988YWCg4Oz1ODj45Or9y+3NWTuLbJy5UpdvnxZ1apVU6dOnbKcY7Qw10Om9evXq2rVqgoLC8vSR37XQ1xcnMaOHatz586pXLlyCgkJ0dKlS9WmTRtJhb8t5FTDnj17Cn1byKmG06dPF/q2kJv3QircbSG33LFNOOOOvw8AXEPGIGNkImNkrYGMQca4ugYyBhmDjJEV+QKwZzIMw/B0EQAAAAAAAAAAADnhmhoAAAAAAAAAAMArMKgBAAAAAAAAAAC8AoMaAAAAAAAAAADAKzCoAQAAAAAAAAAAvAKDGgAAAAAAAAAAwCswqAEAAAAAAAAAALwCgxoAAAAAAAAAAMArMKgBAAAAAAAAAAC8AoMaAJzas2ePQkJCFB8f7+lSClVMTIxCQkJ0+PBhT5eShWEYeuWVV3T77bfbanQ0rW/fvpo+fXqu+iwp76s3+/jjj3Xbbbd5ugwAAIACV1K+i5Ixiqb27dvr3Xff9XQZHrFgwQLdf//9ni4DAPLN19MFAJBOnz6t+fPn6+uvv9bFixcVGBiou+++W0OHDlXFihU9XZ5bLFiwQNu3b9d//vMfT5dS5Hz11VfasGGDVq5cqRo1aqhixYoOpy1YsEC+vrn7s96sWTPt2rVL5cqVK+Tq86dv376qV6+eXnrppVy1j4mJ0d13362NGzeqfv36hVxdwWnfvr369eun/v3726Z17dpV4eHhnisKAAB4NTIGGcOZkpwx1q1bp9KlS+e6/Z49e9SvXz99++23Kl++fCFWVrBCQkK0aNEidejQwTbtySefVJ8+fTxYFQAUDAY1AA87deqUevXqpVq1amnu3LkKDg7WL7/8otdee01ff/21PvzwQ1133XWFNv/U1FT5+fkVWv8lSUpKiiwWS4H3e+rUKQUGBio0NNTpNFe2E4vFosDAwIIss9jx9GejVKlSKlWqlMfmDwAAvBcZo/ggYxS866+/3iPzNQxD6enpuR4kKgxly5ZV2bJlPTZ/ACgonH4K8LDJkyfLz89Py5Yt0+23367q1asrPDxcy5cv19mzZ/X6669LkubOnauePXtmef19992nhQsX2h5/9NFHuueee9SoUSN16dJF7733nu25zMOft27dqj59+qhRo0aKjIzU77//rmeeeUYtWrRQ06ZN1a1bN+3cudNuPocOHVKPHj3UpEkT9e7dW0ePHrV7fs2aNerQoYMaNmyozp07a+PGjXbP//HHHxo8eLCaNWum0NBQjRgxQufPn5eUcZqdhQsX6ueff1ZISIhCQkL08ccfO1xfjg5/HjJkiF588UXb4/bt2+vf//63xo0bp2bNmunOO+/Uhx9+aPeaH374Qd27d1ejRo3Uo0cPh4eEHzlyRAMHDlSzZs3UunVrvfDCC7pw4YJdLVOmTNH06dPVsmVLDRgwwGHNe/bs0UMPPaSmTZvqtttuU+/evfX7779Lkl588UUNGTLErv306dPVt29f2/NTp07VH3/8oZCQELVv397hNEfrJiUlRa+99prCw8PVsGFDdezYUR999JGtpmsPDf/f//6nRx99VI0bN1Z4eLimTZumy5cvu7Rez5w5o+eff1633367mjZtqh49eujAgQOKiYlRvXr19OOPP9q1f/fdd3XXXXfJarU6XHfXyqmGu+++W5LUvXt3hYSE2Naj5Ppn4/3331fjxo2zfBa2bdumZs2aKSkpSVLGXpAjRozQbbfdpttvv12DBw9WTEyMrX3me7x06VKFhYWpZcuWmjx5slJTUyVlvG+///67Zs6cadv+Jcenn8rpcxYSEqKPPvpIQ4cOVZMmTdSpUyd98cUXuVq3AACg+CBjkDHIGNlnjGtPP+XsO3RMTIz69esnSWrRooVCQkJs24XVatXixYvVvn17NW7cWPfdd58+/fRTu/coJCREO3fuVI8ePdSoUSOtX79eISEh+u2337LUfPURFbnZTqZNm6ZXX31Vt99+u9q0aaMFCxbYLaMkDR061O79vPb0U1arVQsXLlS7du3UsGFD3X///frqq69sz2d+vj///HP17dtXTZo00X333ad9+/Y5XLcA4C4MagAedPHiRe3atUuPPvpolj2yAwMDFRERoU8++USGYSgiIkI//PCDTp48aWvzyy+/KDo6WhEREZKkTZs2ad68eXruuee0detWPf/885o/f742bNhg1/fs2bPVr18/bd26VWFhYZoyZYpSUlK0evVqRUZGavTo0SpTpozda15//XW9+OKLWr9+vXx8fDR+/Hjbc9u2bdOMGTP0xBNPKDIyUr1799b48eP1zTffSMr4ojRkyBD99ddfWrVqlZYvX65Tp07pueeek5Rxmp0nn3xSt9xyi3bt2qVdu3apa9eu+Vq3y5cvV8OGDbVx40Y9+uijmjRpki0kXbp0SU8//bRq166tjz/+WMOHD9e//vUvu9fHx8fr8ccf16233qp169ZpyZIliouL08iRI+3abdiwQX5+fnr//fc1efLkLHWkpaVp6NChatGihTZt2qQPP/xQvXr1kslkytVyvPTSS3r22WdVtWpV7dq1S+vWrXM4zZExY8Zoy5Ytevnll/XJJ59oypQp2e6Vc/LkSQ0aNEidOnXSpk2b9Prrr+u7777T1KlTXVqvffr00dmzZ/Xmm2/qP//5jwYOHCir1arg4GC1bt06S5D8+OOP9cADD8hszv0/R85qyAxU7777rnbt2mX7Yp+Xz0aXLl105513avPmzXZtIiMj1aFDB5UuXVqpqakaMGCAypYtq/fee0/vv/++ypQpo4EDByolJcX2mj179ujkyZNasWKFZs2apQ0bNtjmvWDBAlWtWlXPPvusbft3JKfPWaaFCxfqnnvu0aZNm9SuXTuNHj1aFy9ezPX6BQAA3o2MQcbICRkjq+y+Q1erVs2WKT799FPt2rXLdmrcxYsXa+PGjZo8ebK2bNmi/v3764UXXtDevXvt+p4zZ45GjRqlrVu3qnPnzmrYsKEiIyPt2mzatEn33nuvJNe2kzJlymjt2rV64YUXtGjRIv33v/+VJNv7N3PmTKfv58qVK7V8+XKNHTtWmzZtUlhYmIYMGaLjx4/btXv99dc1YMAAbdy4UbVq1dKoUaOUlpaW6/ULAAWN008BHnTixAkZhqHatWs7fL527dr666+/dOHCBd1yyy2qV6+eIiMjNXToUEkZP642adJENWvWlJTx4+iLL76oTp06SZJq1KihX3/9VR9++KEeeOABW7+PP/64rY2UsYdT586dbXuI16hRI0stzz33nG6//XZJ0lNPPaWnnnpKycnJ8vf319KlS/XAAw/osccekyTddNNN2r9/v5YtW6Y77rhDUVFROnLkiL744gtVq1ZNkvTqq6+qW7du+uGHH9S4cWOVKVNGPj4+BXa4crt27Wz1DBo0SO+++6727Nmjm2++WZs3b5bVatWMGTPk7++vW265RWfOnNGkSZNsr1+9erVuvfVWPf/887ZpM2bMUHh4uI4dO6abbrpJklSrVi2NGTMm2zoSExOVkJCgu+66SzfeeKMkZft+O1KuXDmVLVs2y7pxNO1qx44d0yeffKLly5erdevWkhy/r5kWL16siIgI2zUdatWqpZdeekl9+/bVpEmT5O/vLynn9XrhwgWtW7fOdph65rYpSQ899JAmTZqkcePGyWKx6NChQzpy5IjefPPNXK+PnGrIPJT8uuuus1s3ef1s3HfffXrhhReUlJSk0qVLKzExUTt27LDtubh161ZZrVZNnz7dFiJnzpypFi1aaO/evQoLC5MkVahQQRMmTJCPj49q166t8PBwRUVF6eGHH9Z1110nHx8flS1b1un2n9PnLNMDDzxgC0TPP/+8Vq1apR9++EHt2rVzaT0DAADvRMYgY+SEjJGVs+/QFSpUkCRVqlTJdk2NlJQULV68WMuXL1ezZs1s6+K7777Thx9+aNuuJenZZ59VmzZtbI8jIiL03nvv2QYpjh07pkOHDum1116TlPvtJCQkRMOGDbOt29WrVysqKkpt2rSx5aLy5cvnmDEGDRqkbt26SZJeeOEF7dmzRytWrNDEiRNt7Z588kndeeedtuXp1q2bTpw44dJ2BwAFiUENoAgwDCNX7SIiIrR+/XoNHTpUhmFo8+bNeuKJJyRJly9f1smTJ/XSSy/plVdesb0mLS0ty4XaGjZsaPe4X79+mjRpknbt2qXWrVurU6dOqlevnl2bzDAiyfalKC4uTtWrV9fRo0fVq1cvu/ahoaFauXKlJOm3335T1apVbWFDkurUqaPy5cvr6NGjaty4ca6W3xVX12symVS5cmXFxcXZ6gkJCbF9iZZk+yKa6eeff9aePXuyTJcy9jjK/CLZoEEDp3Vcd9116tGjhwYMGKA2bdqoVatWuueeexQUFJTnZcuNw4cPy8fHRy1atMhV+59//lnR0dF2ewwZhiGr1aqYmBjbl1Vn6/Xw4cO69dZbsz3vbocOHTRlyhRt27ZN3bp104YNG9SyZUsFBwe7tGzOanAkP5+Ndu3ayc/PT19++aW6deumzz77TAEBAbYQ9/PPP+vkyZN25x2WpOTkZLs9HuvUqSMfHx/b48DAQB05csSFpVaOn7NMV6+fMmXKKCAgwO5QdQAAUDKQMcgYBa2kZIzcfIc+ceKEkpKS9OSTT9pNT01NVf369e2mNWrUyO5xt27d9Oqrr2r//v1q2rSpIiMj1aBBA9v6yO12cnXNUsZnyFkuulZiYqLOnTuXJcuEhobq559/tpvm6LN64cIFBjUAeAyDGoAH3XjjjTKZTPrtt9/UsWPHLM//9ttvqlChgm0vi3vvvVezZ8/WoUOHdOXKFZ05c8Z2CHXmeUmnTp2qJk2a2PVz7WG31x723bNnT4WFhWnHjh3673//q7fffltjx461ux7B1Rczy9wjPbfXQShIJpMpS0BzdNjrtRdfc/Q6Zy5fvqy77rpLo0ePzvLc1Xu6lC5dOse+Zs6cqb59++rrr7/WJ598ojfeeEPLly9X06ZNc708rnL1AtOXL19W79697d7zTFcHRWfrNad5WiwWde/eXR9//LE6duyoyMhI26HbrnD1vc3PZ8Nisahz586KjIxUt27dtHnzZnXt2tVWw+XLl9WgQQPNnj07y3yvvgBhfrdHV1x7UU6TyeSRzyoAAPAMMobryBi5U5wzhqvfoTM/G4sXL1aVKlWy1HS1a9/PwMBA3XHHHdq8ebOaNm2qzZs365FHHrHrOzfbiacyhic/qwCQiWtqAB5UsWJFtWnTRmvWrNGVK1fsnouNjVVkZKTuuece25eGqlWrqkWLFoqMjFRkZKRat26tSpUqSZIqV66soKAgnTp1SjVr1rS7OTskOFO1atX0yCOPaOHChXriiSe0du3aXC/HzTffrO+//95u2vfff686depIyjgU+syZMzp9+rTt+V9//VXx8fG2PTv8/Pxy9aXo+uuvV2xsrO1xenq6fvnll1zXmllPdHS0kpOTbdP2799v16ZBgwb65ZdfdMMNN2RZn9cGtty49dZb9fTTT+uDDz5Q3bp1bddpuHZ5JDm8oKCr6tatK6vVqm+//TbX9f36669ZlrVmzZpZvpRnJyQkRIcPH3Z6/YaePXtq9+7dWrNmjdLT0+1OUVAQMr9sp6en26bl97MRERGhXbt26ZdfftE333xjO7+0lLGdnDhxQpUqVcrS97V7L+ZUd07bf06fMwAAAImMQcYgY7gjY9SuXVsWi0V//PFHlmW7esAmOxEREdq6dav27dunU6dO2V3vpaC2Ez8/P7uarxUQEKCgoCAyBgCvxKAG4GGvvPKKUlJSNGDAAH377bc6ffq0vvrqKz355JOqUqWK7UJ3me677z5t2bJFn376qd2Pq1LGuS3ffvttrVy5UseOHVN0dLTWr1+v5cuXO61h+vTp+vrrr3Xq1CkdOnRIe/bscekw0oEDB2rDhg1as2aNjh8/ruXLl2vbtm22Q3Fbt26tunXravTo0Tp06JB++OEHjRkzRrfffrvtUNwbbrhBMTExOnz4sC5cuGB3keWr3XHHHdq5c6d27Nih3377TZMmTVJ8fHyua5Uy9kYzmUx6+eWX9euvv2rnzp1atmyZXZtHH31Uf/31l55//nnbxRO//vprjRs3zukXw2udOnVKc+bM0b59+/T7779r165dOn78uG6++Wbb8hw8eFAbN27U8ePHNX/+fJcDlCPBwcF64IEHNH78eG3fvl2nTp3Snj17tHXrVoftBw0apH379mnKlCk6fPiwjh8/ru3bt2vKlCm5nme3bt1UuXJlDR06VN99951OnTqlzz77TPv27bO1qV27tpo0aaLZs2erW7duLu/tlZNKlSqpVKlS+vrrr3X+/HklJCRIyvtnQ5JatGihypUra/To0QoODrbbSzEiIkIVK1bU4MGD9b///c+2nqdNm6YzZ87kuu4bbrhB3377rc6ePZvtYe45fc4AAAAykTHIGGSMgnPDDTfIZDJpx44dunDhgi5duqSAgAA9+eSTmjlzpjZs2KCTJ0/q0KFDWrVqlTZs2JBjnx07dtSlS5c0adIktWzZ0u5oj4LaTm644QZFRUUpNjZWf/31l8M2AwYM0DvvvKOtW7fq6NGjmj17tn7++Wf169cv1/MBAE/g9FOAh9WqVUvr16/XggULNHLkSP3111+qXLmyOnTooKFDh2Y5d2jnzp01ZcoU+fj4qEOHDnbP9ezZU6VKldLSpUv16quvqkyZMqpbt64ef/xxpzVYrVZNmTJFZ86cUUBAgNq2batx48blehk6dOig8ePHa9myZZoxY4ZuuOEGzZgxQy1btpSUcXjqm2++qalTp6pPnz4ymUxq27at3Xl5O3furG3btqlfv36Kj4/XzJkz1aNHjyzzevDBB/Xzzz9r7Nix8vHxUf/+/W3zya2yZcvq3//+tyZOnKju3burTp06Gj16tIYPH25rU6VKFb3//vuaPXu2BgwYoJSUFFWvXl1t27bNcqi9M6VLl9bRo0e1YcMGXbx4UUFBQXrsscfUu3dvSVLbtm01ZMgQvfbaa0pOTtaDDz6o7t27u3y9BUcmTZqkuXPnatKkSbp48aKqV6+up59+2mHbevXqadWqVXrjjTf06KOPSsq40N3VewzlxGKxaNmyZfrXv/6lp556Sunp6apdu7bdBeakjIv57du3Tw8++GDeFy4bvr6+evnll7Vo0SLNnz9ft912m1atWpXnz4aUsf1269ZNS5YssV1AM1Pp0qW1evVqzZ49W8OGDdOlS5dUpUoVtWrVSgEBAbmu+9lnn9WECRPUoUMHpaSkKDo6OkubnD5nAAAAmcgY/ywXGYOMkV9VqlTR8OHDNWfOHI0bN07du3fXrFmzNHLkSF1//fVavHixYmJiVK5cOd1666165plncuwzICBAd911lz755BPNmDEjy/wKYjsZO3asZs2apY8++khVqlTRl19+maVNv379lJiYqFmzZtmukfHmm2+qVq1auZ4PAHiCySisE+4BAODAokWL9Omnn9pdMBAAAAAA8oqMAQAlC6efAgC4xaVLl3TkyBG99957Di8WCAAAAACuIGMAQMnEoAYAwC2mTp2qHj166Pbbby+Uw8IBAAAAlCxkDAAomTj9FAAAAAAAAAAA8AocqQEAAAAAAAAAALwCgxoAAAAAAAAAAMArMKgBAAAAAAAAAAC8AoMaAAAAAAAAAADAKzCoAQAAAAAAAAAAvAKDGgAAAAAAAAAAwCswqAEAAAAAAAAAALwCgxoAAAAAAAAAAMAr/D+UdEs1i6H0rwAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 1600x800 with 4 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axs = plt.subplots(1, 2, figsize=(16, 8))\n",
+    "\n",
+    "# Heatmap for counterfactual lockdown\n",
+    "ax = axs[0]\n",
+    "hist_lockdown_2d = hist_lockdown_nec.unsqueeze(1) * hist_lockdown_suff.unsqueeze(0)\n",
+    "im = ax.imshow(hist_lockdown_2d, cmap=\"viridis\")\n",
+    "ax.set(xticks=range(0, 36, 2), xticklabels=bin_edges[0:36:2].tolist())\n",
+    "ax.set(yticks=range(0, 36, 2), yticklabels=bin_edges[0:36:2].tolist())\n",
+    "ax.set(\n",
+    "    xlabel=\"Overshoot under sufficiency Intervention\",\n",
+    "    ylabel=\"Overshoot under necessity Intervention\",\n",
+    "    title=\"Overshoot in counterfactual lockdown\",\n",
+    ")\n",
+    "ax.axvline(x=(overshoot_threshold) * 36 / 45, color=\"red\", linestyle=\"--\", label=\"Overshoot too high\")\n",
+    "ax.axhline(y=(overshoot_threshold) * 36 / 45, color=\"red\", linestyle=\"--\")\n",
+    "ax.axvline(x=(os_lockdown_suff) * 36 / 45, color=\"white\", linestyle=\"--\", label=\"Mean Overshoot\")\n",
+    "ax.axhline(y=(os_lockdown_nec) * 36 / 45, color=\"white\", linestyle=\"--\")\n",
+    "ax.legend(loc=\"upper left\")\n",
+    "ax.text(21, 2, 'pr(lockdown has causal role \\n over high overshoot): %.4f' % pr_lockdown.item(), color=\"white\")\n",
+    "\n",
+    "\n",
+    "cbar1 = fig.colorbar(im, ax=ax, orientation=\"vertical\", fraction=0.046, pad=0.04)\n",
+    "cbar1.set_label(\"density\")\n",
+    "\n",
+    "ax = axs[1]\n",
+    "hist_mask_2d = hist_mask_nec.unsqueeze(1) * hist_mask_suff.unsqueeze(0)\n",
+    "im = ax.imshow(hist_mask_2d, cmap=\"viridis\")\n",
+    "ax.set(xticks=range(0, 36, 2), xticklabels=bin_edges[0:36:2].tolist())\n",
+    "ax.set(yticks=range(0, 36, 2), yticklabels=bin_edges[0:36:2].tolist())\n",
+    "ax.set(\n",
+    "    xlabel=\"Overshoot under sufficiency intervention\",\n",
+    "    ylabel=\"Overshoot under necessity intervention\",\n",
+    "    title=\"Overshoot in counterfactual mask\",\n",
+    ")\n",
+    "ax.axvline(x=(overshoot_threshold) * 36 / 45, color=\"red\", linestyle=\"--\", label=\"Overshoot too high\")\n",
+    "ax.axhline(y=(overshoot_threshold) * 36 / 45, color=\"red\", linestyle=\"--\")\n",
+    "ax.axvline(x=(os_mask_suff) * 36 / 45, color=\"white\", linestyle=\"--\", label=\"Mean Overshoot\")\n",
+    "ax.axhline(y=(os_mask_nec) * 36 / 45, color=\"white\", linestyle=\"--\")\n",
+    "ax.text(21, 2, 'pr(masking has causal role \\n over high overshoot): %.4f' % pr_mask.item(), color=\"white\")\n",
+    "ax.legend(loc=\"upper left\")\n",
+    "\n",
+    "cbar2 = fig.colorbar(im, ax=ax, orientation=\"vertical\", fraction=0.046, pad=0.04)\n",
+    "cbar2.set_label(\"density\")\n",
+    "\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.suptitle(\"Counterfactual heatmap of overshoot under necessity and sufficiency interventions\")\n",
+    "plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The above heatmaps plot the joint distributions arising from necessity and sufficient interventions, particularly $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{os}^w_{\\mathit{ld}}, \\mathit{os}^w_{\\mathit{ld}'}|\\mathit{ld, m})$ where $W = \\{\\mathit{me}\\}$ and $\\sum_{w \\subseteq W} P_w(w) \\cdot P(\\mathit{os}^w_{\\mathit{m}}, \\mathit{os}^w_{\\mathit{m}'}|\\mathit{ld, m})$, where $W = \\{\\mathit{le}\\}$. \n",
+    "\n",
+    "The key to interpreting this heatmap is the fact that we plot two different counterfactual distributions against each other here. Along the x-axis we show what overshoot a model expects under the sufficiency intervention. And here, we see that for both interventions the model expects most of the density to lie above the overshoot threshold (red). So both intereventions are, approximately, sufficient. On the y-axis, however, we show the counterfactual distribution in the necessity world, where the intervention does **not** take place. Note that the scale starts in the upper left corner. This means that the higher the density mass is on the plot, the **lower** is the expected overshoot without that intervention, i.e. \"the more necessary\" a given intervention is for the outcome. Here, only lockdown seems to play a necessary role. Ideally, however, we are interested in whether an intervention is **both necessary and sufficient**, the probablity of which is the proportion of density mass in the upper-right quandrant determined by the dashed red lines. It is evident from the plot above that the counterfactual for lockdown has more probability mass in the top right quadrant (low overshoot in the necessity world and high overshoot in the sufficient world). This gives us a clearer picture into why lockdown has higher causal role in the overshoot being too high as compared to masking."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Looking into different contexts for curious readers"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`SearchForExplanation` allows the users to perform an even finer-grained analysis by visualizing distributions of random variables when different contexts are kept fixed in the model. To illustrate this, we consider the following two scenarios:\n",
+    "1. Intervene on `lockdown=1` while keeping `mask_efficiency` fixed (or not).\n",
+    "2. Intervene on `mask=1` while keeping `lockdown_efficiency` fixed (or not).\n",
+    "\n",
+    "The key motivation for looking into this is the intuition that there is some part of the actual context in which removing lockdown would significantly lower the overshoot, whereas there is no corresponding part of the actual context in which removing masking would lead to lower overshoot - which is the core of the asymmetry between the two interventions in our example.\n",
+    "\n",
+    "We first intervene on `lockdown` being 1 and analyze how the distribution of `overshoot` changes as we keep the `mask_efficiency` fixed (or not)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hist_lockdown_fix, bin_edges, os_lockdown_fix, oth_lockdown_fix = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 1,\n",
+    "        \"__cause____antecedent_lockdown\": 0,\n",
+    "        \"__cause____witness_lockdown_efficiency\": 0,\n",
+    "        \"__cause____witness_mask_efficiency\": 1,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    1,\n",
+    ")\n",
+    "hist_lockdown_notfix, bin_edges, os_lockdown_notfix, oth_lockdown_notfix = (\n",
+    "    histogram_data(\n",
+    "        importance_tr,\n",
+    "        mwc_imp,\n",
+    "        {\n",
+    "            \"__cause____antecedent_mask\": 1,\n",
+    "            \"__cause____antecedent_lockdown\": 0,\n",
+    "            \"__cause____witness_lockdown_efficiency\": 0,\n",
+    "            \"__cause____witness_mask_efficiency\": 0,\n",
+    "            \"lockdown\": 1, \"mask\": 1\n",
+    "        },\n",
+    "        1,\n",
+    "    )\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overshoot mean\n",
+      "mask_efficiency fixed:  18.7790470123291  mask_efficiency not fixed:  25.793893814086914\n",
+      "Probability of overshoot being high\n",
+      "mask_efficiency fixed:  0.08130080997943878  mask_efficiency not fixed:  0.7647058963775635\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(2, 1, figsize=(8, 8), sharex=True) \n",
+    "\n",
+    "axes[0].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_lockdown_fix,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"blue\",\n",
+    ")\n",
+    "axes[0].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[0].set_title(\"Mask Efficiency Fixed\")\n",
+    "axes[0].set_xlabel(\"overshoot\")\n",
+    "axes[0].set_ylabel(\"density\")\n",
+    "axes[0].legend()\n",
+    "\n",
+    "axes[1].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_lockdown_notfix,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"pink\",\n",
+    ")\n",
+    "axes[1].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[1].set_title(\"Mask Efficiency Not Fixed\")\n",
+    "axes[1].set_xlabel(\"overshoot\")\n",
+    "\n",
+    "\n",
+    "plt.suptitle(\"Counterfactual Lockdown: mask efficiency fixed vs. stochastic\")\n",
+    "\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"Overshoot mean\")\n",
+    "print(\n",
+    "    \"mask_efficiency fixed: \",\n",
+    "    os_lockdown_fix.item(),\n",
+    "    \" mask_efficiency not fixed: \",\n",
+    "    os_lockdown_notfix.item(),\n",
+    ")\n",
+    "\n",
+    "print(\"Probability of overshoot being high\")\n",
+    "print(\n",
+    "    \"mask_efficiency fixed: \",\n",
+    "    oth_lockdown_fix.item(),\n",
+    "    \" mask_efficiency not fixed: \",\n",
+    "    oth_lockdown_notfix.item(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The above histogram plots the following distributions:\n",
+    "1. `mask_efficiency fixed`: $P( \\mathit{os}^{\\mathit{me}}_{\\mathit{ld}'} | \\mathit{ld}, m)$\n",
+    "2. `mask_efficiency not fixed`: $P( \\mathit{os}_{\\mathit{ld}'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "The plot clearly shows that depending on the fact that `mask_efficiency` was kept fixed on the factual value or not, the `overshoot` variable changes. Crucially, if we keep the mask efficiency at the actual value, the probability of the overshoot being too high drops down to $\\approx 0.08$."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We then run an analogous analysis for masking - we intervene on `mask` being 1 and analyze how the distribution of `overshoot` change as we keep the `lockdown_efficiency` fixed or not."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hist_mask_fix, bin_edges, os_mask_fix, oth_mask_fix = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 0,\n",
+    "        \"__cause____antecedent_lockdown\": 1,\n",
+    "        \"__cause____witness_mask_efficiency\": 0,\n",
+    "        \"__cause____witness_lockdown_efficiency\": 1,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    1,\n",
+    ")\n",
+    "hist_mask_notfix, bin_edges, os_mask_notfix, oth_mask_notfix = histogram_data(\n",
+    "    importance_tr,\n",
+    "    mwc_imp,\n",
+    "    {\n",
+    "        \"__cause____antecedent_mask\": 0,\n",
+    "        \"__cause____antecedent_lockdown\": 1,\n",
+    "        \"__cause____witness_mask_efficiency\": 0,\n",
+    "        \"__cause____witness_lockdown_efficiency\": 0,\n",
+    "        \"lockdown\": 1, \"mask\": 1\n",
+    "    },\n",
+    "    1,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x800 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Overshoot mean\n",
+      "lockdown_efficiency fixed:  27.030378341674805  lockdown_efficiency not fixed:  26.37188148498535\n",
+      "Probability of overshoot being high\n",
+      "lockdown_efficiency fixed:  0.8642857074737549  lockdown_efficiency not fixed:  0.8103448152542114\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "fig, axes = plt.subplots(2, 1, figsize=(8, 8), sharey=True)  \n",
+    "\n",
+    "\n",
+    "axes[0].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_mask_fix,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"blue\",\n",
+    ")\n",
+    "axes[0].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[0].set_title(\"Lockdown Efficiency Fixed\")\n",
+    "axes[0].set_xlabel(\"overshoot\")\n",
+    "axes[0].set_ylabel(\"density\")\n",
+    "axes[0].legend()\n",
+    "\n",
+    "axes[1].bar(\n",
+    "    bin_edges[:36].tolist(),\n",
+    "    hist_mask_notfix,\n",
+    "    align=\"center\",\n",
+    "    width=width,\n",
+    "    alpha=0.5,\n",
+    "    color=\"pink\",\n",
+    ")\n",
+    "axes[1].axvline(x=overshoot_threshold, color=\"red\", linestyle=\"--\", label=\"overshoot too high\")\n",
+    "axes[1].set_title(\"Lockdown Efficiency Not Fixed\")\n",
+    "axes[1].set_xlabel(\"overshoot\")\n",
+    "\n",
+    "\n",
+    "plt.suptitle(\"Counterfactual Mask: lockdown efficiency fixed vs. stochastic\")\n",
+    "sns.despine()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "\n",
+    "print(\"Overshoot mean\")\n",
+    "print(\n",
+    "    \"lockdown_efficiency fixed: \",\n",
+    "    os_mask_fix.item(),\n",
+    "    \" lockdown_efficiency not fixed: \",\n",
+    "    os_mask_notfix.item(),\n",
+    ")\n",
+    "\n",
+    "print(\"Probability of overshoot being high\")\n",
+    "print(\n",
+    "    \"lockdown_efficiency fixed: \",\n",
+    "    oth_mask_fix.item(),\n",
+    "    \" lockdown_efficiency not fixed: \",\n",
+    "    oth_mask_notfix.item(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Similar to the earlier histogram, the above plot shows the following distributions:\n",
+    "1. `lockdown_efficiency fixed`: $P( \\mathit{os}^{\\mathit{le}}_{\\mathit{m}'} | \\mathit{ld}, m)$\n",
+    "2. `lockdown_efficiency not fixed`: $P( \\mathit{os}_{\\mathit{m}'} | \\mathit{ld}, m)$\n",
+    "\n",
+    "The plot clearly shows that `lockdown_efficiency` as a context has little effect on how intervening on `mask` affects `overshoot`. Again, crucially, whichever context setting we choose here, withdrawing the masking policy does not radically change the fact that the overshoot is still very likely to be too high."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Conclusions"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "`SearchForExplanation` can be used in any `ChiRho` causal model to investigate the causal role of variables of interest in outome variables having the values that they do in particular runs. This is achieved by transforming the causal model into one that allows us to investigate multiple causal settings with \"necessity\" and \"sufficiency\" interventions and their impact on the outcome variable across different possible worlds. Looking back at the heatmap, \"Counterfactual heatmap of overshoot under necessity and sufficiency interventions\" with the accompanying explanation illustrates how paying attention to both conjoining sufficiency and necessity and to searching through actual contexts to be fixed allows us to break the *prima facie* symmetries which makes the usual but-for analysis blind to such a fine-grained analysis. Moreover, the obtained samples can be used to answer more specific causal queries if need be.\n",
+    "\n",
+    "A practical policy-making implication is that developing causal models for problems at hand and employing a strategy analogous to the one discussed in this notebook is a promising strategy for a fine-grained and probabilistically aware responsibility attribution."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "new-pyro",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}