diff --git a/docs/tutorials/gentle_intro/00_index.ipynb b/docs/tutorials/gentle_intro/00_index.ipynb
index 8c5e7e2..b8e4ae2 100644
--- a/docs/tutorials/gentle_intro/00_index.ipynb
+++ b/docs/tutorials/gentle_intro/00_index.ipynb
@@ -1,60 +1,64 @@
 {
-  "cells": [
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "# A Gentle Introduction to Dynestyx\n",
-        "\n",
-        "This multi-part tutorial is a conceptual complement to the [Quickstart](../../quickstart.ipynb). We start from basic Bayesian inference in NumPyro, then show how **dynestyx** extends it to sample and infer **dynamical systems**—with a clear separation between *what* the model is (parameters + dynamics + observations) and *how* we simulate or compute likelihoods (simulators and filters)."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": [
-        "## Contents\n",
-        "\n",
-        "1. **[Part 1: NumPyro and the Bayesian workflow](../01_numpyro_bayesian_workflow/)** — Linear regression with NUTS and ArviZ; generating data with `Predictive`; prior and posterior predictive (Bayesian workflow).\n",
-        "\n",
-        "2. **[Part 2: Dynestyx — discrete-time dynamical systems](../02_dynestyx_discrete_intro/)** — What dynestyx is; separation of concerns; a first model (discrete-time stochastic volatility); context and handlers; generating data with `DiscreteTimeSimulator`; NUTS + simulator for $p(x, \\theta \\mid \\text{data})$.\n",
-        "\n",
-        "3. **[Part 3: Filtering and the marginal log-likelihood](../03_filtering_mll/)** — Computing MLL with the particle filter at $\\theta_{\\text{mean}}$ and $\\theta_{\\text{true}}$; switching to Taylor KF; canonical reference placeholder.\n",
-        "\n",
-        "4. **[Part 4: Filtering + NUTS — pseudomarginal inference](../04_filtering_nuts_pseudomarginal/)** — Using the filter’s MLL inside NUTS to sample only parameters; when this is “overkill” vs. valuable (with links to be filled).\n",
-        "\n",
-        "5. **[Part 5: SVI and warming up NUTS](../05_svi/)** — SVI as a fast alternative; using SVI to initialize NUTS; execution times; rapid prototyping.\n",
-        "\n",
-        "6. **[Part 6a: Continuous-time dynamical systems (SDEs)](../06_continuous_time/)** — `ContinuousTimeStateEvolution` (drift, diffusion coefficient, diffusion covariance); `SDESimulator`; Lorenz 63 with partial observations; `LinearGaussianObservation` and $H$; NUTS + EnKF; full-observations deep dive link.\n",
-        "\n",
-        "7. **[Part 6b: Continuous-time dynamical systems (ODEs)](../06b_odes/)** - `ContinuousTimeStateEvolution` (drift and no diffusions); `ODESimulator`. Probabilistic numerics coming soon!\n",
-        "\n",
-        "8. **[Part 7: Hidden Markov Models (HMMs)](../07_hmm/)** — Working with categorical state spaces models (filtering and Bayesian parameter estimation).\n",
-        "\n",
-        "9. **[Part 8: Hierarchical / mixed-effect inference](../08_hierarchical_inference/)** — `plate` for trajectory-level parameters; hierarchical dynamical models and inference.\n",
-        "\n",
-        "10. **[Part 9: Discrete-time smoothing](../09_discrete_smoothing/)** — `Smoother` for discrete-time models; smoothed state summaries and future-only posterior rollout.\n",
-        "\n",
-        "11. **[Part 10: Continuous-time smoothing](../10_continuous_smoothing/)** — Continuous-discrete smoothing; smoothed state summaries and future-only posterior rollout."
-      ]
-    },
-    {
-      "cell_type": "markdown",
-      "metadata": {},
-      "source": []
-    }
-  ],
-  "metadata": {
-    "kernelspec": {
-      "display_name": "Python 3",
-      "language": "python",
-      "name": "python3"
-    },
-    "language_info": {
-      "name": "python",
-      "version": "3.12.0"
-    }
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# A Gentle Introduction to Dynestyx\n",
+    "\n",
+    "This multi-part tutorial is a conceptual complement to the [Quickstart](../../quickstart.ipynb). We start from basic Bayesian inference in NumPyro, then show how **dynestyx** extends it to sample and infer **dynamical systems**—with a clear separation between *what* the model is (parameters + dynamics + observations) and *how* we simulate or compute likelihoods (simulators and filters)."
+   ]
   },
-  "nbformat": 4,
-  "nbformat_minor": 4
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Contents\n",
+    "\n",
+    "1. **[Part 1: NumPyro and the Bayesian workflow](../01_numpyro_bayesian_workflow/)** — Linear regression with NUTS and ArviZ; generating data with `Predictive`; prior and posterior predictive (Bayesian workflow).\n",
+    "\n",
+    "2. **[Part 2: Dynestyx — discrete-time dynamical systems](../02_dynestyx_discrete_intro/)** — What dynestyx is; separation of concerns; a first model (discrete-time stochastic volatility); context and handlers; generating data with `DiscreteTimeSimulator`; NUTS + simulator for $p(x, \\theta \\mid \\text{data})$.\n",
+    "\n",
+    "3. **[Part 3: Filtering and the marginal log-likelihood](../03_filtering_mll/)** — Computing MLL with the particle filter at $\\theta_{\\text{mean}}$ and $\\theta_{\\text{true}}$; switching to Taylor KF; canonical reference placeholder.\n",
+    "\n",
+    "4. **[Part 4: Filtering + NUTS — pseudomarginal inference](../04_filtering_nuts_pseudomarginal/)** — Using the filter’s MLL inside NUTS to sample only parameters; when this is “overkill” vs. valuable (with links to be filled).\n",
+    "\n",
+    "5. **[Part 5: SVI and warming up NUTS](../05_svi/)** — SVI as a fast alternative; using SVI to initialize NUTS; execution times; rapid prototyping.\n",
+    "\n",
+    "6. **[Part 6a: Continuous-time dynamical systems (SDEs)](../06_continuous_time/)** — `ContinuousTimeStateEvolution` (drift, diffusion coefficient, diffusion covariance); `SDESimulator`; Lorenz 63 with partial observations; `LinearGaussianObservation` and $H$; NUTS + EnKF; full-observations deep dive link.\n",
+    "\n",
+    "7. **[Part 6b: Continuous-time dynamical systems (ODEs)](../06b_odes/)** - `ContinuousTimeStateEvolution` (drift and no diffusions); `ODESimulator`. Probabilistic numerics coming soon!\n",
+    "\n",
+    "8. **[Part 7: Hidden Markov Models (HMMs)](../07_hmm/)** — Working with categorical state spaces models (filtering and Bayesian parameter estimation).\n",
+    "\n",
+    "9. **[Part 8: Hierarchical / mixed-effect inference](../08_hierarchical_inference/)** — `plate` for trajectory-level parameters; hierarchical dynamical models and inference.\n",
+    "\n",
+    "10. **[Part 9: Discrete-time smoothing](../09_discrete_smoothing/)** — `Smoother` for discrete-time models; smoothed state summaries and future-only posterior rollout.\n",
+    "\n",
+    "11. **[Part 10: Continuous-time smoothing](../10_continuous_smoothing/)** — Continuous-discrete smoothing; smoothed state summaries and future-only posterior rollout.\n",
+    "\n",
+    "12. **[Part 11: Missing observations with Filters and Smoothers](../11_missing_observations/)** — Whole-row and partial missingness with the cuthbert Kalman filter/smoother path.\n",
+    "\n",
+    "13. **[Part 11b: Missing observations with `Simulator` + MCMC](../11b_missing_observations_simulator_mcmc/)** — Joint posterior inference over parameters and latent states under Gaussian missing-data simulator conditioning."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
 }
diff --git a/docs/tutorials/gentle_intro/11b_missing_observations_simulator_mcmc.ipynb b/docs/tutorials/gentle_intro/11b_missing_observations_simulator_mcmc.ipynb
new file mode 100644
index 0000000..fd40bd5
--- /dev/null
+++ b/docs/tutorials/gentle_intro/11b_missing_observations_simulator_mcmc.ipynb
@@ -0,0 +1,932 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "292afdd2",
+   "metadata": {},
+   "source": [
+    "# Part 11b: Missing Observations with `Simulator` + MCMC\n",
+    "\n",
+    "Part 11 handled missing observations with `Filter` and `Smoother`, where the latent states are integrated out analytically or approximately.\n",
+    "\n",
+    "In this sequel we keep the same **discrete-time AR(1)-style latent system** from Part 11, but switch to **MCMC + `Simulator`**. That means we now sample the **latent trajectory and the structural parameter jointly**.\n",
+    "\n",
+    "The most important conceptual point is how missingness is interpreted at the level of **discrete-time model indexing**.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "41177033",
+   "metadata": {},
+   "source": [
+    "## 1. Two missing-data cases in a generic discrete-time system\n",
+    "\n",
+    "Consider a generic discrete-time state-space model\n",
+    "\n",
+    "$$\n",
+    "x_0 \\,\\sim\\, p(x_0 \\mid \\theta),\n",
+    "\\qquad\n",
+    "x_k \\,\\sim\\, p(x_k \\mid x_{k-1}, \\theta),\n",
+    "\\qquad\n",
+    "y_k \\,\\sim\\, p(y_k \\mid x_k, \\theta),\n",
+    "\\qquad k = 1, \\dots, T.\n",
+    "$$\n",
+    "\n",
+    "Here `obs_values[k]` always refers to the observation attached to the **latent index** $k$.\n",
+    "The array `obs_times[k]` is just the physical time label associated with that same index.\n",
+    "\n",
+    "So if `obs_values[k]` contains missing values, we do **not** drop index $k$. We still keep the latent state $x_k$ in the model and infer it.\n",
+    "\n",
+    "That leaves two cases.\n",
+    "\n",
+    "### Case A: the whole observation row is missing\n",
+    "\n",
+    "If every coordinate of $y_k$ is missing, then there is simply **no observation factor at index $k$**. If $O_k$ is the set of observed coordinates and $O_k = \\varnothing$, then\n",
+    "\n",
+    "$$\n",
+    "p(y_{k, O_k} \\mid x_k, \\theta) = 1.\n",
+    "$$\n",
+    "\n",
+    "So the simulator still samples or infers $x_k$, but it adds **zero observation log-probability** at that index.\n",
+    "\n",
+    "This is why **all observation models can handle full-row missingness** under the simulator: there is no need to marginalize anything inside the observation distribution at that step.\n",
+    "\n",
+    "### Case B: only part of the observation row is missing\n",
+    "\n",
+    "If only some coordinates are observed, then the simulator needs the marginal likelihood of the observed subset,\n",
+    "\n",
+    "$$\n",
+    "p(y_{k, O_k} \\mid x_k, \\theta).\n",
+    "$$\n",
+    "\n",
+    "That is trickier. It requires some exploitable structure in the observation model.\n",
+    "For example:\n",
+    "\n",
+    "- if the observation is multivariate Gaussian, we can restrict to the observed subvector and covariance submatrix;\n",
+    "- if the observation factorizes coordinate-wise, we can sum the log-probabilities of the observed coordinates only.\n",
+    "\n",
+    "Without that structure, there is no single generic masked-likelihood formula.\n",
+    "\n",
+    "### What `Simulator` can currently do\n",
+    "\n",
+    "For simulator-based inference in this repo:\n",
+    "\n",
+    "- **full-row missingness** works for **all** observation models;\n",
+    "- **partial missingness** works when the observation model has supported structure, notably:\n",
+    "  - `MultivariateNormal` observations,\n",
+    "  - factorizable `Independent(..., 1)` observations.\n",
+    "\n",
+    "We will illustrate both scopes below with three observation families:\n",
+    "\n",
+    "1. multivariate Gaussian,\n",
+    "2. independent asymmetric Laplace observations,\n",
+    "3. a correlated multivariate Student $t$.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "1fc6aae9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import arviz as az\n",
+    "import jax.numpy as jnp\n",
+    "import jax.random as jr\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import numpyro\n",
+    "import numpyro.distributions as dist\n",
+    "from numpyro.infer import MCMC, NUTS, Predictive\n",
+    "from numpyro.infer.initialization import init_to_value\n",
+    "\n",
+    "import dynestyx as dsx\n",
+    "from dynestyx import DiscreteTimeSimulator, Smoother\n",
+    "from dynestyx.inference.smoother_configs import KFSmootherConfig\n",
+    "from dynestyx.models import (\n",
+    "    DynamicalModel,\n",
+    "    LinearGaussianObservation,\n",
+    "    LinearGaussianStateEvolution,\n",
+    ")\n",
+    "\n",
+    "plt.style.use(\"seaborn-v0_8-whitegrid\")\n",
+    "np.set_printoptions(precision=3, suppress=True)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6ad90267",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "obs_times = jnp.arange(0.0, 100.0, 1.0)\n",
+    "true_alpha = 0.4\n",
+    "state_dim = 2\n",
+    "\n",
+    "block_start, block_end = 35, 60\n",
+    "partial_idx_dim0 = np.array([8, 18, 72, 90])\n",
+    "partial_idx_dim1 = np.array([25, 33, 84, 95])\n",
+    "\n",
+    "transition_cov = jnp.array([[0.1, 0.01], [0.01, 0.15]])\n",
+    "transition_cov_non_gaussian = jnp.array([[0.1, 0.01], [0.01, 0.15]])\n",
+    "mvn_obs_cov = jnp.diag(jnp.array([0.25, 0.25]))\n",
+    "asym_laplace_scale = 0.25\n",
+    "asym_laplace_k = 1.7\n",
+    "student_df = 5.0\n",
+    "student_scale_tril = jnp.linalg.cholesky(jnp.array([[0.22, 0.08], [0.08, 0.18]]))\n",
+    "\n",
+    "\n",
+    "def full_only_mask(T, D):\n",
+    "    mask = np.ones((T, D), dtype=bool)\n",
+    "    mask[block_start:block_end, :] = False\n",
+    "    return mask\n",
+    "\n",
+    "\n",
+    "def full_plus_partial_mask(T, D):\n",
+    "    mask = full_only_mask(T, D)\n",
+    "    mask[partial_idx_dim0, 0] = False\n",
+    "    mask[partial_idx_dim1, 1] = False\n",
+    "    return mask\n",
+    "\n",
+    "\n",
+    "mask_full_only = full_only_mask(len(obs_times), state_dim)\n",
+    "mask_full_plus_partial = full_plus_partial_mask(len(obs_times), state_dim)\n",
+    "\n",
+    "\n",
+    "def apply_nan_mask(obs_values, mask):\n",
+    "    return jnp.where(jnp.asarray(mask), obs_values, jnp.nan)\n",
+    "\n",
+    "\n",
+    "def summarize_1d(samples):\n",
+    "    arr = np.asarray(samples)\n",
+    "    return {\n",
+    "        \"mean\": float(arr.mean()),\n",
+    "        \"p05\": float(np.percentile(arr, 5)),\n",
+    "        \"p95\": float(np.percentile(arr, 95)),\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def summarize_state_draws(state_draws):\n",
+    "    return {\n",
+    "        \"mean\": state_draws.mean(axis=0),\n",
+    "        \"lo\": np.percentile(state_draws, 5, axis=0),\n",
+    "        \"hi\": np.percentile(state_draws, 95, axis=0),\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def rmse(a, b):\n",
+    "    return float(np.sqrt(np.mean((np.asarray(a) - np.asarray(b)) ** 2)))\n",
+    "\n",
+    "\n",
+    "def summarize_gaussian_mixture(mean_draws, cov_diag_draws, rng_key, n_draws=400):\n",
+    "    mean_draws = np.asarray(mean_draws)\n",
+    "    cov_diag_draws = np.asarray(cov_diag_draws)\n",
+    "    S, T, D = mean_draws.shape\n",
+    "    flat_mean = mean_draws.reshape(S * T * D)\n",
+    "    flat_scale = np.sqrt(np.maximum(cov_diag_draws.reshape(S * T * D), 1e-8))\n",
+    "\n",
+    "    keys = jr.split(rng_key, flat_mean.size)\n",
+    "    samples = jnp.stack(\n",
+    "        [\n",
+    "            dist.Normal(loc=m, scale=s).sample(k, sample_shape=(n_draws,))\n",
+    "            for m, s, k in zip(flat_mean, flat_scale, keys, strict=False)\n",
+    "        ],\n",
+    "        axis=1,\n",
+    "    )\n",
+    "    samples = np.asarray(samples).reshape(n_draws, S, T, D)\n",
+    "    samples = samples.reshape(n_draws * S, T, D)\n",
+    "    return {\n",
+    "        \"mean\": samples.mean(axis=0),\n",
+    "        \"lo\": np.percentile(samples, 5, axis=0),\n",
+    "        \"hi\": np.percentile(samples, 95, axis=0),\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def _shade_gap(ax, t, start, end):\n",
+    "    ax.axvspan(t[start], t[end - 1], color=\"orange\", alpha=0.15, zorder=0, label=\"missing block\")\n",
+    "\n",
+    "\n",
+    "def _draw_partial_flags(ax, t, indices, y_value):\n",
+    "    ax.scatter(\n",
+    "        t[indices],\n",
+    "        np.full(len(indices), y_value),\n",
+    "        s=55,\n",
+    "        marker=\"|\",\n",
+    "        color=\"purple\",\n",
+    "        linewidths=2,\n",
+    "        zorder=4,\n",
+    "        label=\"partial missing\",\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "def plot_missing_data(t, states, obs_values, *, partial_indices=None, title=\"\"):\n",
+    "    fig, axes = plt.subplots(1, 2, figsize=(12, 3), sharey=False)\n",
+    "    for d, ax in enumerate(axes):\n",
+    "        _shade_gap(ax, t, block_start, block_end)\n",
+    "        ax.plot(t, states[:, d], color=\"C0\", lw=1.0, alpha=0.6, label=\"true state\")\n",
+    "        obs_d = np.asarray(obs_values[:, d])\n",
+    "        obs_mask = ~np.isnan(obs_d)\n",
+    "        ax.plot(t[obs_mask], obs_d[obs_mask], \".\", ms=3, color=\"C1\", alpha=0.8, label=\"observed\")\n",
+    "        if partial_indices is not None and partial_indices[d].size > 0:\n",
+    "            ylo = np.nanmin(states[:, d]) - 0.5\n",
+    "            _draw_partial_flags(ax, t, partial_indices[d], ylo)\n",
+    "        ax.set_xlabel(\"time\")\n",
+    "        ax.set_title(f\"Dimension {d}\")\n",
+    "        handles, labels = ax.get_legend_handles_labels()\n",
+    "        by_label = dict(zip(labels, handles))\n",
+    "        ax.legend(by_label.values(), by_label.keys(), fontsize=8)\n",
+    "    fig.suptitle(title, fontsize=12)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n",
+    "\n",
+    "\n",
+    "def plot_state_recovery(t, states_true, obs_values, summary_a, *, label_a, color_a, summary_b=None, label_b=None, color_b=None, partial_indices=None, title=\"\"):\n",
+    "    fig, axes = plt.subplots(1, 2, figsize=(12, 3.5), sharey=False)\n",
+    "    for d, ax in enumerate(axes):\n",
+    "        _shade_gap(ax, t, block_start, block_end)\n",
+    "        ax.plot(t, states_true[:, d], color=\"black\", lw=0.8, ls=\"--\", alpha=0.5, label=\"true state\")\n",
+    "        obs_d = np.asarray(obs_values[:, d])\n",
+    "        obs_mask = ~np.isnan(obs_d)\n",
+    "        ax.plot(t[obs_mask], obs_d[obs_mask], \".\", ms=3, color=\"C1\", alpha=0.8, label=\"observed\")\n",
+    "        ax.fill_between(t, summary_a[\"lo\"][:, d], summary_a[\"hi\"][:, d], color=color_a, alpha=0.18, label=f\"{label_a} 90% CI\")\n",
+    "        ax.plot(t, summary_a[\"mean\"][:, d], color=color_a, lw=1.2, label=f\"{label_a} mean\")\n",
+    "        if summary_b is not None:\n",
+    "            ax.fill_between(t, summary_b[\"lo\"][:, d], summary_b[\"hi\"][:, d], color=color_b, alpha=0.18, label=f\"{label_b} 90% CI\")\n",
+    "            ax.plot(t, summary_b[\"mean\"][:, d], color=color_b, lw=1.2, ls=\"--\", label=f\"{label_b} mean\")\n",
+    "        if partial_indices is not None and partial_indices[d].size > 0:\n",
+    "            ylo = np.nanmin(states_true[:, d]) - 0.5\n",
+    "            _draw_partial_flags(ax, t, partial_indices[d], ylo)\n",
+    "        ax.set_xlabel(\"time\")\n",
+    "        ax.set_title(f\"Dimension {d}\")\n",
+    "        handles, labels = ax.get_legend_handles_labels()\n",
+    "        by_label = dict(zip(labels, handles))\n",
+    "        ax.legend(by_label.values(), by_label.keys(), fontsize=7)\n",
+    "    fig.suptitle(title, fontsize=12)\n",
+    "    plt.tight_layout()\n",
+    "    plt.show()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37b11de6",
+   "metadata": {},
+   "source": [
+    "## 2. Example 1: multivariate Gaussian observations\n",
+    "\n",
+    "This first model is **identical to Part 11**.\n",
+    "\n",
+    "The latent dynamics are the same 2D linear-Gaussian AR(1)-style system, and the observation model is the same linear Gaussian sensor model,\n",
+    "\n",
+    "$$\n",
+    "y_k \\mid x_k, \\alpha \\sim \\mathcal N(x_k, R).\n",
+    "$$\n",
+    "\n",
+    "Because the observation distribution is multivariate Gaussian, partial missingness can be handled exactly by restricting to the observed subvector and covariance submatrix:\n",
+    "\n",
+    "$$\n",
+    "y_{k, O_k} \\mid x_k, \\alpha\n",
+    "\\sim\n",
+    "\\mathcal N\\big(x_{k, O_k}, R_{O_k O_k}\\big).\n",
+    "$$\n",
+    "\n",
+    "So the simulator scores\n",
+    "\n",
+    "$$\n",
+    "\\log p(y_{k, O_k} \\mid x_k, \\alpha)\n",
+    "=\n",
+    "\\log \\mathcal N\\big(y_{k, O_k}; x_{k, O_k}, R_{O_k O_k}\\big).\n",
+    "$$\n",
+    "\n",
+    "Here we use a mask that combines:\n",
+    "\n",
+    "- a **contiguous fully missing block**, and\n",
+    "- a few **partially missing coordinates** outside that block.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6d2191b3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJoAAAErCAYAAACWx+nxAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAA5VFJREFUeJzsnQd0nFfVtbc0RaPeu2RLsty7ndgpTi+QBiGFEjoBPj4glFAT+FP4gNBLCL0lQEgghYSQ3kiPHfcmW7ZsWb13aYpmpH/tO3rl0Wi6pkk6z1pesqTRlLfeu+8++ySMj4+PQxAEQRAEQRAEQRAEQRBmSOJMn0AQBEEQBEEQBEEQBEEQRGgSBEEQBEEQBEEQBEEQwoY4mgRBEARBEARBEARBEISwIEKTIAiCIAiCIAiCIAiCEBZEaBIEQRAEQRAEQRAEQRDCgghNgiAIgiAIgiAIgiAIQlgQoUkQBEEQBEEQBEEQBEEICyI0CYIgCIIgCIIgCIIgCGFBhCZBEARBiGPGx8dj/RaEOYwcX4IcW4IgCEK4EaFJEAQhjqirq8P//d//4W1vexvWrl2LjRs34r3vfS/+/ve/w263I15ZunQpfvGLXyBeOP/88/H1r38ds53nn38eX/va1ya/37p1q9rW/Bqv/PCHP8SmTZuwbt06PPLIIwH9zQc/+EH1jzQ1NanP+PDDDwf0eG9w//M4CCd8T3xvfI9zgQceeADf//73Z/T5eN7zb8JNIMfBfL0uhGubRvJ64n5sCYIgCPMLfazfgCAIguDkiSeewE033YRFixbhox/9KCorK2GxWPDSSy/hu9/9Ll555RX86le/QkJCQtxtsn/84x8oKiqK9duYc9x9991Tvl+5cqXa1tXV1YhHamtr8Yc//AHvfve78c53vhNVVVWxfkuCD379618rUVDj3HPPVcdXQUFBzLcb3wPfy4IFC8L2nHfddRfS0tLC9nyznUheT9yPLUEQBGF+IUKTIAhCnDiZKDKdddZZ+NnPfga9/uTl+ZxzzsHmzZvxuc99Dk8++SQuvfRSxBt0rwiRh5PkeN7WfX196utll12GU045JdZvJ+6gk4Tn+eHDhxGP5OTkqH/xgNFoDPuxvmLFirA+32wn3q8ngiAIwuxFSucEQRDiALpAEhMTcfvtt08RmTRYSnfllVdO+VlPT496/HnnnYdVq1ap1ePPfOYzU8pePJWKuJfH0DV122234eyzz1bP8/a3vx1//OMfp/zNPffco36+evVqJYbx8UNDQ15L5w4dOoTPfvazOO2009SqOf/m29/+tnot17+599578Y1vfEO99/Xr1+Pzn/88urq6fG6rwcFB3HHHHbjwwgvV+7n88svx4IMPTnvc6Oioes1TTz1ViR4sQeM2c91+X/rSl3DmmWeq56EDx73Uq6WlBTfeeKN6fyxl/PCHP4yDBw9OK0X585//rLYPH8OVfP7sxRdfnPJcNTU16ufPPvvs5N9+9atfxZYtW9Q2Ov3009X3vb296vcsDdu2bZv6p5W3eCp12bdvH66//nolRm7YsAGf+tSncOTIkcnfa3/zxhtv4GMf+5h6j/zMLHFzOByTj3vttdeUE4n7gdvsf//3f5UA6n7ceCuz4f7Xytm4nbSyNU9lleEqt/rlL3+JM844Q73nT3/602hsbPT6WH5WHm9XXHEF1qxZo9w7P/rRj2C1Wqc8jg5ClqtyAs59c8stt2BgYMDjc/LnPG74WXmshBPt2Hr88cfVPuV+43vmZx4bG5t8HM+pH//4x7j44ovV+ctjgI5IHm8avAZwn9x6663q9xSrKWA3NzfjX//61+T1wFPpHEugrrrqKrU9uN34eSl4B/s5nnrqKbWP+DzcZ3Rn8hpy8803qxJh/ozHpJYZ5V7mxc/805/+VG1rfk5+5efmea7xn//8B+94xzvU++S158tf/jLa29s9Xg+15+dnoYjPY4jn+Te/+U2MjIxM/g2fn8cJr498Xp5rvE74KzG02Wxq0eCCCy5Qf8frFLe1u4uV25avzXOSx1p/f/+UxwR6ft9///3qXsDH8FwmzzzzzOT2eNe73qWuy664X094Xl500UX473//q84Tbmfee9yvi/6u79zO7sdWINfTQPahIAiCMDsQoUkQBCFOsng4qM7NzfX6GOZdaG4mTsb+53/+R00oOBCnMMSBP8UETiaDgWV5L7/8shJi+DycGP3gBz/AQw89NDnw5wTw/e9/v/o9xaxHH31UZUl5oqOjQz3WbDbje9/7Hn7/+98rh8tf//pX/OUvf5nyWE4cOYH8yU9+okQWijN8P97gROa6667DY489ho9//ONqsspJKsWq3/zmN1MeywnkgQMH1HvgZ+Pk6ROf+MSkuPKVr3xFCSkU6/ge6Xbg4958881JIYqCA5/j//2//6cmtXyv/GyuAow2QeNzc7txQsdyHwoErnA7ZmVlqQk+t82HPvQh9TzcX9yu/J5/w21C+HO+J/5jeQsndO7wvb7vfe+b3I+c7LW2tqr37f4eeZxwW3E7cdJLcZMiAqFAQxGAE0sKZd/5zndw/PhxfPKTn5wUNbSyKk/vg1x77bVqokz4lWVKkWTHjh1qe/G1+Lk5+eU2dBVAXeHjNIGSn5H78W9/+5v63Jq4weOP5xXPQ4oE3GbPPfccvvjFL057vuHhYbXPKTbxuC4pKfH4utx+zFfjP21bat/zn78wboq6dJ7wGKPIw+3KY1GD5w3PVe6rP/3pT8oxRSGCIqrrc2/fvl0dGxSq+Dtug/z8fHU8eiuXozDH7cZt9tvf/lYJLnQacbu0tbUhGCjgLFmyRL0uRdWf//znuOaaa2AymdRnolDGY5KClCd4jt53333q+sPPyeOe5w2fTzseuC34PHwstwPPD35WX/A8Ky0tVdcSCjoUrbXnJPz8FNo/8IEPqG2Xl5enrgf+4DaiAM3zgtuOoiVFLl4HCF+PoguFtzvvvFN9rqefflqJtZpgE8z5zW3I6xffL4WrF154QQloFHr4vi+55BJ1zfNHZ2cnvvWtb6lz6Xe/+x3KysrU82qvF8j1ne/F/dgK5Hoa6j4UBEEQ4g8pnRMEQYgxXMHmv4qKimm/cw8AZz6TTqdTg/3k5GQ1AdBKlLji3dDQoAb2wUDHDFfTOVnQniclJWVS9OLvOdnghICuK65G8/fuK++uOT3Lly9XE0ktD4VuBYpiXDnnhFiDE09O/jX27t3rdaJJ6G7g83P1npMpwtV0bidO3DiRoZhDsrOz1USU71X7npM5impc+efn4vecRBN+Lv4tJ9KEk0uWgnFyy4kooauBYh8/GyeHGpzEXX311ZPfc0Wek2FOGDmR5oSf7gW6nvj8dJsw04riYXl5ufobCo179uxR74swN0Xbft7KWzhZW7hwoZoQ8rggnNDSlcD3x/epwQkvPy/hRJ8CCsU3bjNud75XiiyFhYXqMXx/FEDp7uD78FdWxcdrWS/8GukyJX5ebmMtG4x5UHT90X1BUcCVo0ePKgGBE1bt+OMxzwkwJ7Y8JjgpppjDY5cTZS0LjfuL29HVaUcXFB1fdFpwgs3zwxt07Lg7WVzFOk7Oec55g4+lwKMdf9wfPDb5+nxvFLwo4mgiNI9jim0UAfieOeEnPEcoILhmqfHvuU+9HV8UICm+UIzT4LlAFw5FAe2aEQg8T7/whS+o/y9evFgJLrzGaOIkj38KyDt37lTnkzs8LyiEaucZPyevgenp6ep7vh+ea9y/2jnM85mOIJ5/3rLtuN+1wH2eF7xO8bzgscLrKfcdf0+XmPY5uF1fffVVr5+V1yiKRtz3dO1oz02XD6+BfA6KWXQQap9fux7yOkvhkF+DOb8pwPP6okFxia4gLhJo75u4ipSeoIBEoZnvl/C+xOslnX7MDwzk+s5z3/3YCuR6Guo+FARBEOIPEZoEQRBijGsZjCsnTpxQK7uucIDOlWqKAZygcvDNsgQ+9tixY2qSxpKNYOAkl8INHQqcdPGfJkhoE0CKV5xcUpTh71lW4W3Qz4kQ/7HkhBN8vjdOTriirYlAGu4TXE6COdHxBieb3AaayOQq7FBIoFDD90f4VROZtHIOliW+9dZbauLEz01hgaUbnIS5TjgJ3WGcUHFba4IfhTZOjv79739PeX0+zv39UKygQ4aTZu4Xlo3QkaI9np0Eue/r6+vVNuK24j4MtLsgBQdOwOhk0yahJCMjY3Ji6Ir7NuO21kqEWMaSlJSkHCacrPIzcvtwohqvsETIVTThNqVox/3rLjRp4p27MMLv6ZrgBJmfl8fCDTfcMOXY5kTYPReN4tT+/fuVy0QTCr3B/UPRgFDA4HHhWurJ0H9fuJfMspSJ5/6uXbvUcauVuVL0oguNx5NWtul6LeC5F2xgv1ZmRtcWj00ep1qZVbDXGdfjj64g4np8cZtnZmaq0lhPcP9QJKGgwnOZDjvX/cxyT7oB6dbjNuL5zOuQdj3whqdrEAUhws/Ka6yrgEP4Gr6EJgomxP36rZWQ8tzk9uPzuMJFA17feLzSGRnM+e16DaJoTOcQS5Fd4bXIn9Dkvk20Y0a7VgRzfXclkOtpqPtQEARBiD9EaBIEQYgxdNpQENEmNxrFxcVTJqRcoeaAXoODc5acsZSCA3wO4rkaHCwsO+Nkgs/Hcjj+46SQJTvLli1Tk2wKIhRG6BriZImTIZaGeAom10rhWHbDyQk/ByeUFDLcoSPBFU48fJUS0UWlOTRc0Saurlk67o/jc3Nba4/hhIZlZCyxo/uAv+fKPF0f/HxcfeckylupmKsg5ipoEboQuA1Z2sXJHb+ynI7iiAbLavj6fB2+f7o1uD28TbTd4eO4rbTP7r493J/H/dhw3dZ05LCMjM4JHnMUMjih5aSeLpR4dBJ4+tx0yHjKU9Lcd+7HBIVHHhPcVnwMt4ev8lUNijo8LnhOUoRITU31+lhuW83xpGXrMBMsUDSHmYbmKtM+E7tRUvCiEMT3wXNWOx5dzyVf79EbdPTQcUORwGAwKNcYn9/9uQPBU7c39/PGFyyV5Weg24cOLzp16Iyim4tiOM83Hr/s1Mhzi//nMcJMIy07zBO+rkFappv7MeHvGNFC8b09Ttt3vs7dYM9v122pHcs8tl0JtJug6zbh9iDaNgnm+u5KINfTUPehIAiCEH+I0CQIghAHcIWeLgSWvGgTMpYOuE5IXVeLmbdC9w0H3yxt0SajzAjSVtM1XAOfiWvQrfY6LMPhP7pu+D4oKLF0RMsZ4goz/3Fyw5V85mcw74OZP+4TYW2iwOwjruhrpS10y8wUOh44WfGUK0JcJ1baZM91OzBoW5v88X3xM/AfJ+ksE+Pn5vvmZ+DvWZ5D94ontNIOb9DVxLJAbjOWA2pZK4QlQixt4mvTKaaJB3Qg0MUQCHx/FIA8hadze/hyF3iCk0W6bei04DFEFxuFMAoLnkqZgsHfMRgKnko3+bndnVvacaP9XivbIXRl8JjgccPzjtvTNTBeK5NjTgxdXxrcTpyMc99RsKTYESm0cHiN7u5u9ZXHMYUgrfyTOUB0V/EzUASgADUTKCiwhIkCE8VHCtkU5uhiYUZbtKHgQWcY/3Eb0NHD45MONJZt8Xykw4v/KFpwn1EwZa4R910o7jzt2sZzzDWDy/0YcYcirfY4VxcZs4h4XdKORz4vxTtXeIxyP87k/ObvuL3c/9b9mhgKoV7fA72ehnsfCoIgCLFBwsAFQRDiAE7oWE7ACaunkhSWQrh21GLZDCeCnGRpkyFO5l9//fUp5XicPLuH9roKUXxeligw64ZwMsWJHEuKtC5adLRopXScLFB0YGYL3y+zotzh8zOjh1kq2iSEDhC6sbyVCQYKSyvo/OLnd4VuLE6IXScinHy6lqHRtcTvWYLD52A5hpYHxckeg53paNI+NydFLEViaRMFP+0fJ9mceLuWs3iCbi+6AJg/wokxhSfXbcTJKF0amsjErB3+3HUbaW4CT9DBQBcUHVmuQg6FLZZoUQQMFE4cWY7DY48TPuazaGHvM+2mxmPQvWsUSwlnCreVq6uDZZPcr3S3uMN9SdwD2vk9tx23Fd0yFFPcuwUyv4nnp+uxTpcFQ5Y/8pGPKFGHrx0pmKXlCo9jilyceLN8j0IY3x8dc5rzTBOZ/LmOfB1fFLh4/FNA4HGvdcPk9iAzPZeDhVliFBw0kY0iH69VdLBRoGfeGa85/MzcPjyetVLYUI9hHhc8z7VOkRrs5ubv7wjLnF2hE4v5R9x3PM+0YHDXBQS+VzofZ3J+011EwZXv0/UYcH8/oRDo9d392ArkehqJfSgIgiDEBnE0CYIgxAGctLIUhHkxnEBxcsefURihqMKBOFenKUwQTVBhmRcH5nR3cMKrta/WApw5UKfTgf84ueFEQ+uqppVTsZSBDg0KNXxNTgYYgEsBinDizs5MnAQwT4MTOz6eIbFaGY0rfG90BnHlm1kfdCDx9Sli+MpfCgRuG5bwUfhiRyWWJPEzsZyGWSaak0Bb9acQR9cXc2tY7sEAaIoonJDTacCJKyepnKRz0k6XBAOxCUUEToL49WMf+5hyvTDQ+5///KfaT/7QOszx/XLSx3I6123EUFy6mriPKGIwa4f7WHM7EH4e7n+WLnkK16brjI42Cg0sc6NDh9ud29o1Z8sf3MecBPNvmHvDSR9zuzgZ5vvT3Bl00LiGlAcCs3Qo6PD44zZgoLsnV1qojhuW1VAUYfYMw5RdBT0Nvmdm3jBwmMcgBUsGsvM4pvCoBSXzmKKzj93AmI3E/cHjho4hPjePEVd4zFEIoEDMz8VzyN/xy3/BwOensMJjidk9PM/ZBY9CBM9dCkC8dvAY5X7n+6AQEYhzjMcXc6n4vO5uEb4m3V98PZ4rfCwFLK2z2EzP5WDhPqMgTpGP5xPFDZZXUcCgWMtjmN8zV4rHAM8FdrHjeehJfAwEOot4feUxwOfj9Y6ikyZGehPq+DiWVHK/UMyngEmBjn/HY47viccuSy95zPAcY9YeRWntWJ3p+c1jmEHkPEbf8573qOu6e2fOUAj0+u5+bAVyPY3EPhQEQRBigwhNgiAIcQKFHa5gU4CgsER3Bld2OdmhO4Yr+lpnOk6OmZ3CQTldOZx88WecxHACwlVnTkwpmlAgoIjBQTsn/VxR52Rag2IVW7lzEkdxhhNMCl1akCxfl39L4YGiCcUpijUs+/I0seZrcuLPCSknUszwYAg2xR1OSChUuQpCwcBVbnb5oqjASRlFIrqR+JncSzc4MePqP7cHBRMGmPM9a64PbitOIPk8fL98n5yUaV3J6BTjZ+ZrMa+KzhFuf0+v5Q1+bjpS+NqucCLJiSUFMm5Tvhb3F98zW3+zxIYdnujYoLhBtxXL8NwzVrgfeAxQQOHEkp+TgcIUBZlfEyicGHMSyv3F56GDgscijwmttIfiBSeE/rqkucO/oWDK90RRhMcyJ9AzLTej+EMHHvcpn5+TdeaNecuK4X6j0MVtztJPbku2cKc7TxMM+BzcDtp5RAGD+46Cpbfjkechj3lOvIMR9wKF5yEn6yxl5DHK19PKMPl5eHzy/fKcpkjJyT/PEQqsdMhQPPYGJ/zMd6KYwePIHQoK3G6c+PPYogjCbmn8Gz53NHNzuB34Hrj/eJzSTcOSYx5LhOcPxVIeszyPeZ7T9cPjNdgyUld4PlLU4/PyesNzjtua78FXxhRFJu4Xdlvj9YXnM89Trcsljylet5mNxn3L90hxig5S7Xlncn7zcTzOeY3j9qAoz/1GYXYmBHp9dz+2+H78XU8jtQ8FQRCE6JMwHmyaoyAIgiAIghBRKERecMEFSmAM1gUlhAdmGtGJRMeba/4bhR46x7QOfIIgCIIgTEUcTYIgCIIgCILgwbFGxw1L31iGRqfR7t27lQtJK7EVBEEQBGE6IjQJgiAIgiAIghssw2RQPkuLWT7IDCLmuTGgmmWtgiAIgiB4RkrnBEEQBEEQBEEQBEEQhLDgva+tIAiCIAiCIAiCIAiCIASBCE2CIAiCIAiCIAiCIAhCWBChSRAEQRAEQRAEQRAEQQgLIjQJgiAIgiAIgiAIgiAIYUGEJkEQBEEQBEEQBEEQBCEsiNAkCIIgCIIgCIIgCIIghAURmgRBEARBEARBEARBEISwIEKTIAiCIAiCIAiCIAiCEBZEaBIEQRAEQRAEQRAEQRDCgghNgiAIgiAIgiAIgiAIQlgQoUkQBEEQBEEQBEEQBEEICyI0CYIgCIIgCIIgCIIgCGFBhCZBEARBEARBEARBEAQhLIjQJAiCIAiCIAiCIAiCIIQFEZoEQRAEQRAEQRAEQRCEsCBCkyAIgiAIgiAIgiAIghAWRGgSBEEQBEEQBEEQBEEQwoIITYIgCIIgCIIgCIIgCEJYEKFJEARBEARBEARBEARBCAsiNAmCIAiCIAiCIAiCIAhhQYQmQRAEQRAEQRAEQRAEISyI0CQIgiAIgiAIgiAIgiCEBRGaBEEQBEEQBEEQBEEQhLAgQpMgCPjgBz+IpUuXTv5btmwZ1q9fj6uuugp/+ctfYLfbp2yl888/H1//+tdnzZZ7+OGH1edqamqKyut1dXXhS1/6EjZv3oyNGzfixhtvREdHR1ReWxAEQRCE6CDjp8jxuc99blaNNQVBmErC+Pj4uNvPBEGYhwOloaEh3Hrrrep7h8OB/v5+vPzyy/jHP/6Biy66CD/72c+QmOjUpg8ePIi0tDQsWLAAs4Genh40NDRgxYoVMBqNEX0tinLXXnut2p4UmPj9j3/8Y6SnpyvBy2AwRPT1BUEQBEGIDjJ+Cj9jY2O444471ELnu971Lnzve9+LwKsIghBp9BF/BUEQZgUUjtatWzfNuVRVVYXvfOc7+M9//oN3vOMd6ucUbGYTOTk56l80eOqpp5QQ9/jjj6O6ulr9bPny5bj88svx5JNPTm5DQRAEQRBmPzJ+Ch+HDh3Ct7/9bezbtw8mkymMzywIQrSR0jlBEHzygQ98AIWFhbj//vs9ls6xHI1laRRYPv3pTyux6owzzsCvfvUr5eq5+eabVfkYf/bDH/4QriZKq9WKH/zgBzjnnHOwatUqXHHFFXjiiSemvD5f684778T3v/999Rxr1qzB9ddfj/r6+imOJZaqnXnmmVi9ejXe+c534pFHHvFZOvfaa6/huuuuU++NJW78+9bW1il/Q0Ftz549eM973qOe97zzzsMf//hHn9vr1VdfRWVl5aTIRPj/RYsW4aWXXpKjTRAEQRDmATJ+Cm78RL72ta8pVz3d9Lm5uVHZT4IgRAYRmgRB8H2RSEzE6aefjr17907LanLlm9/8JpYsWYJf//rX6vE///nPcc0116gVqbvuugsXX3wx/vCHPyhBilBw+sxnPqMErI9+9KPq75gL9cUvfnGKSERonz527JiyUnOla//+/WowovGVr3wFdXV1uP322/H73/9eCUT8/ZtvvunxvfL5P/axj6G4uBg/+clPcNNNN2HXrl1qQNTd3T3Fvv2FL3wBl156KX73u99hw4YNShh75ZVXvG4Hvo+KioppP2eZ4fHjx+VoEwRBEIR5gIyfghs/ET7mvvvuU1mhgiDMbqR0ThAEv+Tl5WF0dBR9fX3q/54466yzlChDFi9erErtuBp1yy23qJ+ddtppeOyxx7Bz505ccskleP3119WA46c//akaiGjPYTab8aMf/UiVmun1zktURkaGckjpdDr1PfOWfvGLX6C3txfZ2dnYtm2bEq0uvPBC9ftNmzYhKyvLYx4TxSM+/5YtW1R2kgYHQXwfXHH76le/OimG0aXFzCVC99Ozzz6L//73v+q9emJwcBALFy6c9vPU1FQMDw/L0SYIgiAI8wQZPwU+fiJ0nwuCMDcQR5MgCH7Ryt0SEhK8PoZuJA1NjGKZmwb/NjMzUwkx5I033lA/Y9kcnVLaP5bKdXZ24siRI5N/S9u1JjKRoqIi9ZWiFGHpG4Undih54IEHVNc3OpooHrlDVxGfn0KWu+OIn4GilbfPReGKWU8jIyN+t5UnfG0/QRAEQRDmFjJ+Cnz8JAjC3EIcTYIg+KW9vV2VwNEl5CsM052UlBSvj6c7igMwT2IQ6ejoUCHaJDk5ecrvtO53dCcRuqJ+85vfqLDtp59+Wv2eeU7f+ta3UFpaOu11iSdnFn/GIG9X3MMo+dy+xCRuB0/OJeZVsfOcIAiCIAjzAxk/BT5+EgRhbiFCkyAIPqHLaOvWrUoQcnUVzRSKLhSimL/kCU/lZ76eizlN/Mcsp+eff16V2jGzidkArmhiGV1P7tDpxFK8mcAg8Jqammk/Z7mfq8NLEARBEIS5i4yfBEGYz0jpnCAIPmHnDwow73vf+8K6pZijRAs1V7dYGqf9q62txS9/+UufweOuNDc3q/I7LWS8qqoKn/jEJ5SjqaWlxaMQlJ+frzKkXGlsbMTu3bu9OqwChdlPDAQ/evTo5M/4f/6MXfEEQRAEQZj7yPhJEIT5jDiaBEGYLO2i0KKVpDFo+9VXX1UDpXe84x2qa1w4oTh06qmnqrBt/lu0aJHqbHfnnXeqoEjW8gcCS+OY2cRudPwMzFpiV7qXXnoJ//M//zPt8bRu33jjjarT3Je+9CX12fhZ2RmPGVLsgDcTGCjOMj6KXXx+wtBxduRjCLogCIIgCHMHGT+FZ/wkCMLcQoQmQRAUzCZ6z3veMxlazS5pFEduu+22ya5r4YSCD8vafv7zn+O3v/0turu7UVhYqAYq7CAXDBSJfvKTn6jnomhUXFyMz372s/jkJz/p8fFXXXWV+nx8Xb4Wc5UoblGAottpJjDw8s9//jO+853v4P/9v/8Hg8GgnEwUtrQueoIgCIIgzA1k/BSe8ZMgCHOLhHFJZRMEQRAEQRAEQRAEQRDCgGQ0CYIgCIIgCIIgCIIgCGFBhCZBEARBEARBEARBEAQhLIjQJAiCIAiCIAiCIAiCIIQFEZoEQRAEQRAEQRAEQRCEsCBCkyAIgiAIgiAIgiAIghAWRGgSBEEQBEEQBEEQBEEQwoIeMcJut6O/vx9JSUlITBS9SxAEQRCE6DA2Ngar1YrMzEzo9TEbCoWEjJ8EQRAEQYj38VPMRlcUmerr62P18oIgCIIgzHMqKiqQm5uL2YSMnwRBEARBiPfxU8yEJjqZtDeZnJwckddwOByora3FkiVLoNPpIvIaguyPiOCwAQOHgQQ9kGiIzEuMjaO21Y4lxXroEhMi8hqCF8ZGgXE7kLEU0Bmd+0OuV3GF7I+5vT/MZrNa7NLGIrMJGT/NP+R6FMzGkvHTnEbGT3GPXK/m9j4xBzF+ipnQpJXLUWRKSUmJ2EYlfH4RmmKP7I9gNpYOsALQJU0KEeHfH+MAhpCSbIJOJ0JTVHEkAg47kJLs3MdyfsQdcr2aH/tjNpbuy/hp/iHXo2A2loyf5jQyfop75Ho1P/ZJYgDjp9k3whIEQRAEQRAEQRAEQRDiEhGaBEEQBEEQBEEQBEEQhLAgQpMgCIIgCIIgCIIgCIIQFkRoEgRBEARBEARBEARBEMKCCE2RYNQCdNQ4vwqCIAiCIAiCIAiCEHtkrh4VYtZ1bk4fuA98BGjfBxSuBq69GzCYYv2uBEEQBEEQBEEQBGH+InP1qCGOpnDTe9wpMvEg5ld+LwiCIAiCIAh+aOwZwZ7GPtlOgiAIkUDm6lFDhKZwk13pdDLRxcSv/F4QBEEQBEEQ/PBSbSce3tkEq90h20oQBCHcyFw9akjpXLihwMRyOaqlPJClbE4QBEGIBnTSyr1HEGYt4+PjaOgZgc0xjkOtg1hbnhXrtyQIgjC3xkYyV48a4miKBDyAC5bPLpFJQtEEQRBmf+bAvdc4v0ozCkGYdfSOjGLQYodRl4A9TVI+JwiCEJGx0Wycq89CRGgSZIIiCIIw25HMAUGY9dR3D6uvZy/Jx+G2QYzY7LF+S4IgCLMXGRvFFBGaBDkJBUEQZjuSOSAIs56G7hEUpCdhU2UOxgHsbx6I9VsSBEGYvcjYKKZIRpNw8iRklzwJMBcEwROS/xPfSOaAIMx6mM+0MDcF6SYDFuWnqe5zFJ0EQRCEEJCxUUwRoUmQk1AQhMBq3DUxmg0PpK49/tAyBwRBmHVYRh1oG7DgzOpc9f268kw8tLMZ/eZRpBmlAEEQBCEkZGwUM+TOJTiRUDRBELwhNe6CIAgRpbFnBOPjwIKcVPX9iuJM6BISsK+pX7a8IAiCMOsQoUkQBEHwjdS4C4IgRJQT3SNIMeqQl2ZU3ycbdVhalC7d5wRBEIRZiZTOCYIgCL6RGndBEISIcmIinykhIWHyZ2vLsvD3bQ3oGrLK1hcEQRBmFeJoEgRBEPwj5bWCIAgRYWxsXJXOLchJmfLzZcXpSNInYq+UzwmCIAizDBGaBEEQBEEQBCFGtA9aYLWPYWGuM59Jw6BLxIqSDOxp6sc4A5wEQRAEYZYgQpMgCIIgCIIgxDCfKTEBKM1Knva7deVZqnSu2zwWk/cmCIIgCKEgQpMwu1uud9Q4vwqCIAiCIMxCGrpHUJKVDKN++rB8UX4aUo16HOkZjcVbEwRBEISQEKFJmJ1QXHrgI8C91zi/itgkCIIgCMIs5ETPsAoC94QuMQErSzJQ3+cmNMlimyAIghDHiNAkzE56jwPt+5wDLX7l94IgCIIgCLOIQcsoeoZHsTBnaj6TK2XZyei3jsE66nD+QBbbBEEQhDhHhCZhdpJdCRSudnbC4ld+LwiCIAiCMMvymYh7xzlXWFZHWgcmogJksU0QBEGIc/SxfgOCEBIUmK692znYosjE7wVBEARBEGYRDT0jyEoxIDPF4PUxBelJ0CUkoLXfgkUFGScX2+jolsU2QRAEYT45mmw2Gy6//HJs3bo1Ui8hzHcoLhUsF5FJEARBEIRZ62ha6MPNpOU0ZScnoqXPMnWx7f0POr/KYpsgCIIwH4Qmq9WKG2+8EUeOHInE0wuCIAiCIAjCrGbUMYaWPjMWeAkCdyUvWaccTZPIYpsgCIIwn4Smo0eP4t3vfjcaGhrC/dSCIAiCIAiCMCegyGQfG8fCXO9B4Bp5KYnoGLDA7hiLynsTBEEQhLjKaNq2bRs2b96ML37xi1i3bl24n14QBEEQBEEQ5kTZnFGXgOIM/zmTeSk61IyMo2PQOhkOLoSXIesYdjabMWAZw6D15L+s5ERcvylbNrcgCEIshabrrrsuqMc7HA71LxJozxup558V2C1Az3EgpxLQxzYwW/ZHUBsL4KJlwjiA8cjsj7HxKV+FKMJtzv2rrk1Tr1Pz+noVR8j+mNv7Q84zIR441DaAirxUJCYm+H1sbrIOCUhQLigRmiLDW01mPFs7hPxUPdJNiUpgohB4uNOKUcc4DDr/+0kQBEGIk65ztbW1EX+Nffv2YT6S4LChasftSB6ogzljEY5tvBXjOmOs39a83R+hnZ62iX+RY1/9cESfX/CGHmismfZTOT/iC9kf8YXsD2Gu0D8yivruEVy9oSygx1PkyE0zosU1p0kIK4OWMRSl6/G5LbmTPzvaZVNCU7/FgbzUmE+bBEEQZg0xv2IuWbIEKSn+QxBDXbHkoHT16tXQ6XSYd3TUIPHVRiBhDEZzI9aWpzu7tMWIeb8/gtpYVqBvH6BLARIjIw7SyUSRaXVFqupoI0SRMRvgGAGyVgO6JOf+mO/XqzhD9sfc3h8jIyNRWegSBG/sa+6HLiEBK0syAt5IJZkm5WgSIgPL5FKNU+Nr6WoifeYx5PmP0hIEQRDiRWjigDHSk6povEZcklcNFK0G2vcBhauh4/dxsB3m7f4ICp0zqp8CUISt2hSZdGIHjzIJzopIngdu54KcH/GF7I+5uT/kHiTEmj1NfVhSlA6TIfDjuTjLhNraboyPjyMhQRaIws2QbQzZE8KSRqbJuX/oaBIEQRBmkdAkhMioBeg9DmRXOlvceoI/v/Zu/48TBEEQBEEQokL3kBVNvWa8b3FeUH9XkpkMq30MXUM25Kc73bBCeMPAF2Tpp5Uspiclos8sQpMgCEIwTJXthdkjMj3wEeDea5xf+b03KC6xXE5EJiFELPYxtXoqCIIgCMLM2dvcjyR9IpYWpQf1d8WZzgXD1n4pn4tU6Vx60nSHWWayDn0WdvAQBEEQAkWEptkIHUosh6PAxK/8XhAiAAWmn73Sg1eOj8j2FUKH16qOGt+iuCAIwjxhT2MflhWlI0kfXBloapIemckGtPTJtTTc0CnGf+4ZTSTTJI4mQRCEuBKaDh8+jM2bN0fyJeYnLIMrXO10KfErvxeECGAeHUe/2YHtjRZxNQmRd2AKgiDMcdoHLGgfsGJteVZIf1+SZRJHUwQYtjmd2yyTcyfLpEO/OJoEQRCCQhxNsxEte+n9Dzq/zpKyuONdw6rTmTB76B5xZhJ0DtvR1G+P9dsRZiPiwBSEoLDZbLj88suxdetW2XJz1M2UbNBhcUFaSH/PnCZ2npOS9vAyaHV4F5qSdWrRTba5IAhC4IjQNFuZZdlLHBT94dXj2NNui/VbEYKga9g58EpLSsSuZnGiCCEwHx2YUioohIjVasWNN96II0eOyDacg1Co2NvUj5UlGdDrQhuCF2WaMGR1YMAiiz/hzmfSxjvuZCUnwuYYVy5vQRAEITBEaIoRVrsDLxxqx5DVPi8mWluPd6uv+zqsGHVIoOJsoWfErlb3NpSasKfVArs40oR54sAMGSkVFELk6NGjePe7342GhgbZhnOU5j4zuodtWFueGfJzlGYlq68SCB7+jnOJCQlIMSRM+12myZml1WeRznOCIAiBIkJTjFa0Ht7ZjGcPduBfO5vmnhXXbaJlMQ9jd0Mf1pVlwWIfx57G/li/QyGI0rmcFB3WlZgwYhtDbac40oS578Ccl6WC4sKKOdu2bVO5lv/4xz9i/VaECEE3U1qSDlV5oZXNkawUgyq9a5VA8LAyZBtTbqaEhASPjibSZ5aFUkGY7ZhtDtz92nEMWkZj/VbmPPpYv4H5yMtHutRg47SqHLx5rAc7G3qxcWHOycE+JyYsL5mtkzK3iVbNwT2wj6XjbSsLcexEA1452oVNVbkeb+ZC/AlNuSk6FGcYUJyhV+VzKwqTYv22BCH+SwV5DYxyqWDXkBVjY+MoyDCFtjigvef54DyLQ6677rqgHu9wONS/SKA9b6Sefz7CRcU9jb1YUZyO8fExBLNp3fdHUYYRTT3Dsn88byyAelACF3EDX8gdMI8hzZgAh2P63yTrEqBLSEDPsB0Oh3Eyb1RyR2MAtz33rzoXpp4Xcr2KD+J9f9R1DOBQ2wDqO4ewoiQD8wFHGPdJMM8hQlOUqW0fxNMH2nDe0nxcvLIIo45xPLanVa1uZRvHYjLY58Tk2Zp2nFmdh7QkfVgnWuOFq/FKV7o6kTOSDVhXZMTLnVYcbB3AypLQreNCdOgZcWBpvlNYWl9qwjOHh2EeHUOyQcyQguCzVDAGCwb/2dOiynJuvGhJcEK+JxcWHWhCXFNbWxvx19i3b1/EX2O+0DJox7GmYaxOHcTu3R0z2h/WXgsO9Y1iRVJPmN/lXIFjWTqwA3dh1zSbMTY+jt3Hhjz+3myxY/eJESS7xD/sqx8Oy7sVgkUPNNZM+6lcr+KLeN0fb7VY0N1txfZ9w7B1zK/F831R3iciNEWR7iEr7t/WiCUFabhweaH62eVrilHXOYQHdzTh40stSIjBYL9zyIr/Hu5EepIeZ1TnhXWiVe/IR+sbrbh0fa76VWGqHhVjqXi5tgsrijPmjqtpLjjR3LCMjqnMAjqayNpiE548NIR9rVZsWuDMiIhX2B3GZEhAkl4EsXA5ZZ450I4lhWk4pWLCfSl4P/e1UsEouyWaes0YtjnU1/KclOi5sObg9W82sGTJEqSkBLGfg1yx5IB09erV0Omc9wBhZrTsa0NlaT/efmaQQrCn/ZHbh+YdTVi6YjmSjbJ/pm4sK9C3D9ClAInGgLfxmx2jKEjTYV2V57LGHV2jSDUmqt/TyUSRaXVFKnSJc2QcO1sYswGOESBrNaBzigRyvYov4n1/7LOcQK5tEDnFuVi3phjzAUcY98nIyEjAC10iNEUx/PtvbzYgNUmH95y6AIkTNyaTQYdrNpbhD68cxxuFOTgjBiUXnYNW9fVY13B4hCaXidab2xqQn2bEovxUjI05V4HOXpyHv25tRH33CCrzUjHrmYVlJxwk/X5rL/INwDofZXOEGU0kw6RDda4Ru1sscS00MbD8F6/14PSFybhgceg5GAJUcP/LtZ1KiOZ2HbCMitAUp+d+v3lUiUxkT1NfcELTTFxYcbQN5hscLEZ6EB+N15gvtA5YUJmfBr0+hKG33QLT4HHoxpdBpzOiLCcVCQmJ6BiyoSpf7nNT0TkTaDnO1gUuAg2PjiHDZITOy99kp+rRNWyf8nuKTN4eL0SKBGdFJK9LbtcmuV7FF/G6P1oHrOr62W+xh+/9zZIFN10Y9kkwfy/L/VFaaX7krWPQdx/CB04pnLb6tCg/DWdW5+LJml50vP03Ue/OpAlNx7uGwxpMzpC1Ay392OyWx0RXRGFGEl450ok5wSwM/2UHufreUTT0232WzZG81JPH6/rSZBzvsaF34nfxyKEOK4ZtY5NCmRAaRzsGcefzR/Di4Q5sWZyHi1cWornXDLt0jYzLc58uJrKmLBN7GvtUSXRUAtvjaBsIQrzCsVVrvwVFmSGM60YtSHzoY6jeepP6yu/z05Jg0CWgRQLBw7Z/6OBml11vZJoSgw4Dr+204g/beiXLaT4hjTXiGs5NB8x2ZJj06BkOU4Mj6TbsFRGaokBrdx9Wv/55fLzhqyh86lPOA9KNt60sQnaqEQ/s6YIjb1lU1VAKTRywjNgc6JgQncLB9hO9qlXshgXZU1bkEhxWnLU4HzWtg2gfmL4tZh1a2Qn3WZTDf0MdUL18bET9v8uHGMPfMYvJNY9pRaERSfoE5WqKVxhYTvot0h0mVJ7a34Y/vlqPDJMBnzt/sbo+VeenKVcTJ0tCCOd+hAefLX1mpJv0OGtxHoasDhzt9JwzMt+vf4IQC/pGRlU5enEoQhPF27b9SHTY1Fd+T1d8YYYJLf1OgVmYGVb7uMpMZdc5b2SZdBi0OoISjdipt67Lphb3hHmACA5xjybOMzuY1+WwGCxkwc0rIjSFoSTOHx0nDqHEchTGcZvXFV+DLhHXbChTq9JHO6I0QXDJaGJeki4RONYZnmBDrqZvO96DNWVZTgeX24rc2qIkZCTr8cqRLsx6tLKTKDvRQuVwpw3tg3bVPa7bPKbCL705mnJd3EyEmUf8O4o54XS/hQs6mQ512FSOQp9ZHE2hwP26vb5HdcX8+FmVkx3MOEHSJyagsccpUgpBnPtRGHw295lRmpWs/uWnJ2F3Q190dtEsu/4JQsCEURxum1hUK85IDv51Kd4WrcKYzqi+amIuz/UmuR6HhUGrc2HKl6MpKzkRHPYMBLGI1TnsHIdwcS8ex0xCmBHBIe7holyyQaeqiaz2MWWymDGy4OYVEZpChDeMFw614/bHDvqdeB0dzUdvxlIk+FnxLc9JVhP5aLp8+DnoaCrJSkZZdgqOdYVH5DrcPqiU4s2VOR5X5PT9J3DmojzsbuxF/8goZj2hlp3EgJeOjWBBtgGnLUiGY3wcXRMDIXe6hx2TQeCubChNRuewHU0+yu5ixZ4JpxXzmehokoFd8NBSzKyfxQXpU0pe9bpEdZ1okIlN8Od+MIPPECa3PM45eOLEk/tsfXmW6uwZyELIfLv+zRYOHz6MzZs3x/ptzF/CLA639VvU5IYLbEG/rsGEsav/hKOb71BftfNsSWE6Oodsk/EHQugM2ZziUZrRl9DkHA/1WQK/rnYM2bEw26AW97jIJ8xxRHCIe5r6zCjJMqkqIhKW8jlZcPOKCE0hBuT+c3sjnj3YobIGa9sHfT7+eL8dNVvu9LviywkCV6LDWb4WyKSSii5fl8Hc9WHKadp6rBtl2cknA2k9rMhtqswBHchHOnxvPyF8nOi1ob7HhrOrUlGc7hzwtg16FoyYceRJaKrKNahgcE3UiSfotFpWYERJpkHZ27VVSiE4ZwyhaOHOgpwUEZoiOfgMcXLL6zjL5SgEkrXlWeq6zvJkQRBi70xgiRtdoX67zXl7Xb0JlvRK9VVjcWEajLoElYUpRN7RxIwmEmhOE6/BdFafWp6sFve4yCfMcURwiHu0RbmcFKfQ1DsSJgFYFtw8IkJTkAxZ7fjjq8dxoGUA79tUjuV5RvQe3+t1QsDQsZ7hUZTlZwe04luQnhRVR1PnkPO1KDRV5aWqycpMV8e4jWo7hnCqaxt0Dyty7LiXlWxQrdOF6ED7dn6aHisKjEgxJiLdmIiWgelCk83BDmPTS+cIc7dWFiZhf7s1rhxDXDls6h/F+lITsiYGhJLTFNpNONXoeeWdQlPvyKi6rglBYDDB8q4/wvLuf/guLwtxctvU55zAlGY7haacVCMW5qZgd0Ov7CZBiANnAh1NxVmmsL4uIxeWFKWr8agwMxgEzqxSZlB6gxUHzKwM1NGkucUL0vQ4pypVLfJxsU+Y44jgELcMW+2q2oaLcox1MRkS1ZhWiBwiNAUBBaBfvXhU2ew+cVYV1hSa8Paam3Dhrs9g7IEPexSbtDKThTmpAb0G81Ao9ERrAk/3FHNXqOwuyE1RDi12n5sJTlcUsLQofeovPKzI5aUlKeu3EB0h5mC7FedUpUyuquYm69DqQWjSusp5cjSR1cVJ6Dc70NgXP+VzO5tZmpCIZQVJyDQ533d/EBZ3wUlrP23FzhIsT0ITmSyfk+4qAbtgf/VKE+4+mux7sSHEyS27ATIInF1UNNaVZ+FIx5AS/gVBiJ0zgSWs3cM2FE3k3YXzdVeVZKpsz75wrcrPY0cTg8D9Oc6Y08SxTyB0DDkfl5+qw/ICoxKcXqoTV5MgxHIh1XVRLjvFiN5wdZ4TPCJCUxAq6G9eqlMunE+fu8hZEtZ7HJkDh6Abs8HR4nn1mflNdAZkphgCeh06mmi3ZSlENKColZtmVB1MkvQ6dfLNVGg61jWM3FQjMpP9f+aCFGC8/WDEOjHNmDk0kaabiSVva0tODlxzUxLROmifJmxq3ehyvAhNzBygxXxfW3xsFwaasxPe2pIkJZwmG5wrk8G2IhZYOmeZLMFyh9cxXs9ULl0kAq7n0PnmyrMH25WgfqJ7RDkbwj255eCpxK0sZ3Vppvq6tylKoeCCEMXz2DLqiLyzMkzOhI4BLh4CRYF2nAvidbmgx3ueuJpmntHkq2zOtfNcoE5pZllyzEXXBK/NZ1eloKbDqvKaBEGITTQEnYmcoxLmNIWtdE7wiAhNQbiZ2Jr2vaeWI2uirpOrzbriNXDojOjLWOpx9Zkr/5oLIBDYrla93qAlKoM2Ck0sm9Ng+RyFopk4quhoYt6TX0YtOGPnl/CO/Z/HeIQ6Mc0IbxPpWTgZ5goc84u2VCarQalGXopOdWobcMsy6h62K6HGWzCmKp8rMmF/W3yUzx3rHlWfcX2JUyDhoI4DPOk8Fxx0v/SbRz3mM03LaQp3d5U52hb4RPcwXj3ahYtXFCItSYe36nvCOrnl+ac6zmVPvc+kJunVJHR3owhNQhSJ0nn85P5W3PHkIfztzRNqcSwe7kPeaO23KLe4Nr4LJ1z8XJSfOn9zmsI0Hhu0jPkMAtfITA58XNE55EB+2snFOi7y8e9fOhae7s6CIARH80QQuLYox2oecTRFFhGaAqTP7Fw501LqFQYTEq69Gy+d+iv8Z8l3p00MGEZMS3OgZXPq+VMMqk6cK2DRGLR1DlmRn3ZSaKrMS8OgxY6uEMvZRmx21ca3IhChqfc40vucjrCx1jBMVMONp4n0LJ0Mv1o/ooQjhlK6kjfRRcW9fK5HBYHrfdrIVxclqQFXPHSf29lsRl6qHuVZJ0uHmNMUTHcY4aSt2FeWSHl2irqujWVVhDXDZC62BWbJ3EM7mlRjhHOW5GPjwmzsauhTPw8XWhC4J3GQ5XONPWbJwROiR5TOY2ZfqtL7QSt+9/Ix/OKFo9he3xPWcyuc5ch8r8xUigSrSjNR3z0yt7LzAhGQwjgeC9jRlMxxxVjAcQX5qSfHJFzk21KRgj0tVlkEE4SYBYGnTJlzM6MpnhcqZjsiNAVI/8ioWo2eNlAwmJBTsRbH+x2wuw1weECPOsaDcjRxYj8lEDyCgzZazzlJcXU0MUCW2kKo5XP1XSPKIh6Qoym7EuOFq2BPNMKcs3zmE9Vw4ykvZRZOhpm3tK3BjNMWJsOkn3r8phmdZWbuQhNL57yVzWlU5BhUpsH+IMvnWOYWzos6S02ZPbWhdGrpEFsRSxh4cLS42Yo9wWsEr2ttjJoIsMyL188j7YPT/k1pKzsH2wKzZI6DmGs2lqny5I0Lc2AedYS1zGUyCNyD0LSsKEPtzz3iahKiRZTO4yGLHdUFafjChYtx/ZYKVar/0M5m1RE4Hh1N7DgXKZYXZ6ivc6bLZKACUhjHY1pGUyClc6xu4D9/4xx27i1wcTSRU8pNatHv1eOS1TTrmIXVDMJJzDaHWqCgo0mD5hH7GJsfxX7BfK4yva2Q4JE+s+1kyZwbFFU48aIlb2HuSYGFOSZcwXA9qAOhIN2kQrqnDNp4Ew3zoE3r9uYqNNGGzQkLy982Vbp0jQuQ+u5hNeCjSuwXgwmG996Dvz30LDau34gzZpiDMGN48+BAhduY70XLS3H9WQT3RySgoPPogUEkGxNVPoA7FGaK0vXTOs/R0bSmyPc+1LrP7Wuz4u1L0/yGaFIQ4uDqleMjuGRZOjYv8F6eFQwH2q2w2sexziV7SmtFfKhDHE3B0NJnUee/r33J/CaWgTBvqCQr11nm5ecY/NNrx09e09xgQO7y4nSsKMlA6bV/RkJv/cnzLdzndAxK5t6+skhd0127e9J5QbdROGAQOBdBPHUJNOoTsaYsE28e68aZ1Xnq+i4IEcXTfTMCDFlHkZ7kdN1WF6Srf0/tb8XuxvgqIeP1j7lsy9ybo4QRlsnyusLyuVDGbXGHJwHJ030mTOMx7iN2nQukdI6OJuJvEat72KGqGlwdTYSLfVz0e71+BG9bmqYqGIRZJH5qx9oMGwQI0YdzdPdFOXboJWymEEiusBA8IjQFCNshZhvHnGq22+CpJDNZrRof6xyeIjQxx4STMn2Qdun8jCTUtA2om19CBAdttJwTWrrdhbO9Tf3O1/cjHrhDJxQHPIH+XYIhGWN5y9HpPP/j7yai5aVEeRAdLigCHe604oMbs6a5mTSK0/U40n3Sck91nyVxuan+J6WrikzY2mBG84AdZZmeL9IcbG1rNOOFo8OwjI7DqE9QLX7DJTSx21xVrhHZbg4sOpq4SsnP45pLJfh2NC0r9j0hoquT17XG3hGcjly/m5OlWxSZrtu0YIq7kyu+vPEfbB3Am8d68OLhTnWjv3R1MdaES2SK0cBQK5ljmeGW6rwpvzulIhv/3N6khH73a2/oVnDv4uAFywvV9fy5mnZcvqZkxq8nCH5xv2+GmbGxcQzbHEpgcSXfBJj6DmPUugCGpMCd5JGEjkYushRnhud+5w0K9U/sa1Wr9mzbPasJVEAK03hsZHRc3Y8CdTQRf2X5ncMTHefcHE2Ei2IvHh3GkS4bVhTO/B4gxJH4KcQtHCsZdQlTxl1ZE6YIuutd5+9C+JDSuQAZHBrC+fu+6tHKy5KIitwUFaI9kyBwjcJ0k7LlTlr5wtT5xJPQxFVw91VuCk0MBJ5S1hJgKR5P5IDymVzISzdOil4xIxgLdoT2R7gZsY3hsYODSgzyNZgpyTCga9gOi31sstSOlW25fkrnSFWuAanGROxv9bz/WNL2s1d61PtYnGfEjWfnKhdU+2B4nEZ8z8e7R7GqaPrny5wYEAbaini+w/OXLbi9dZxzhV03Vee5ANjZ0KsEpJUlGaprnfaPlmVmi7z7lHJ847Ll+PhZlao7T9jCq2NQ5sptyC5vf3njhJpgXr2xVN0fXOFnTjbosL2+d8avpwWB+9pn3PbnLSvAG3XdJ0uyBWEWM2xjp1QgzVVoGrVg2as34MPHvoKxf8RPfiLzmUjAHedCZGVxJpjecKgtfGW5MSOY7pthGI/RzUQykvyPedJNicrN7c/RxHwmLkBneBCvCtL0yE/Tq/GRMEuYg6X98w3OT4vpyHcZk7HbeqpRp8wkQmQQoSnAwbyurx5ZA4e9Tlqq8tPQ0D2s3BuEQg0nGswzCZaCDOekudO181wEcA8C16jITQ0pp4nC2lig+UwuUF0ONXw8bMzBm8iTh4dA7eiKFWk+H8fSOdI2UT7HXAESiNDk7D7H8jnLtNyl7Y1m/HVHn8p6uuHMHLx7baZyHRWm6VXbX64gzpQTPaPqeapzjV4t7oEGd853tCBwXx3nNBbmpKhzdthq95ljQGfPnqY+bFiQNU1wcUWXmIBF+Wnq2hG2G36Uzmk6CLYe68afXzuO7zxeg/u2NWLEalcCmlYy5+4IW7cgSwlw2v1ixkHg2b732ZmLcpVF/LE9LRJ6KcyJ7phkitDUexym7hrox2xI7NgfN/mJLJtLMeqQYYpsAQHF+/Kc5LDmv8WUKC7o0flMAnE0ccyTwUYjZv+OJuYzeXOacsGtpsMalnGQEGfipxC3Y1xPi3Jc9AzWWCEEjghNAcDw1jZdMWx5K7xOWjhBsjGnqdc5WdNW+7nyHyxst8hSn8nOcxGCLiLXfCYN2q6LM0zTHFr+oDDFrJC8NO9Bwt6EJgpzVnsMnSdz7CZyrNumhB5mJ2VMOHu8QWs3jzctp4nZAswN4GAqEFYXmVSmk2vO065mCx7eP6CyCD5ySiaKM06W1RWm61WmGZ1TM6Wu26Y+X56HMr9JR5N0ngs4n4n73ZP47I52XWP5nK8Q15qGDuXO3LAwO6D3kJFsCF1ocg/qjMI5TXH1z68fx7/3tCjR6JJVRfjq25bihgsWY3VZpte/O7UiW3X3nKn7QMscKHPpouIJlm9fsbYEdZ3D2NccXxk2wjwmxHBdTeBOcxVvsiuRWLwajkQjBrOWxc1ikRYEHmwMQSisLMlEbfsgbBPuZCH8QlOgjUZUx7k07+IiXeZ0ndf3iJNi1jBLqhkEz27zziEbSj1kJnMRrndEhKZIIUJTAHDiY09MQv/lv/c6aaELgDbZuq6hSXcPaz9DCRfjyj8FIG/hucHkGPz3cAdGbHaPv+sesnkUmkhlfqoKBA9WaGLZXLADKm1iy/cTS2q6bDihW4Ax3eyumaeI88j+QVTkGLGp3P8NkSITrdytgycdTdnJ3lfi3KnMMSCF5XNtzuN1X6sFD+ztx8ayZLxjRfq059EyC9qHwiE0jWJRrsHje6VowoFjv1kG3YGu9rC8w5fzSINh/xSVG7pHfJar1dXuU2XFgWYRZSUblLAftOjsrUtRhAeGRzqGVAbVh8+owMfPqsIZ1XlqdcwfzGspy06ecfkchSZvQeDuLClMx4ridDyxry22or4gzLA1PUXaaY4mgwkJ196NR1b+DFs3/iRuJoN0NEU6n0mD5cm8/1NsEgJnyOZQ43fmtwRCph9HExcgOoemd5xzpSxTrxbJ2MxEEITIdvij4E88OppSDOJoiiAiNAWAtsKelZHuddLCyRnL5DRxJtR8Jo0CJTTN7ARr6Tfj6QPtquOQO1RvGZLM1/EEHVos/esN0E7IEpmm3pGgy+a0jCbXLnixYNAyqnJVfvPSMXz3iRrVInl/c79SwWcbL9YNo8fswLtWTRd5vFGSqUfrhCOJ7iRPDiFfZU9cnaPQxEHT/bsHVNilt9dnZgGzeLjiNxO4Gtg6SKHJ+8SeriZ/oZ3CyetFIGVzhPuV1zde57yVq43mrcSuoWxsDNDNRLTOnnQ4xnseEycTz9d0qHKVxQW+y1M9cWpFDg63D6J/BqWCzb0jfrsEunLZmhLlBvnv4c6QX1MQwsIMzlmWzilhwL3BhcGE8fzl6LImxFXuXaTzmTQo6LOL58G5Uj4XJZjRlB6gm0kLBPflaBqwjqkAePeOc67wms1xE3Oa3GMHBGFe42ERgtfS5w62h+zW5EIqF5+ZgexOdopRjTlpwBDCjwhNAdBntinXx5TVMw9QZGHLb64Ws4SOOSahwpym9oGZ3YC0Mr4dJ3qnPQ/zmUh+msnrZ+Fn5t8GojJzwskgylCEphSjXoWxxVJooiuBvH/zApxSkaMuSvdubVCZKxScZgvm0TG8cmwEZ1elKJdSoLDzXPugXZX/0NHEXKVgWF2UpALF/76zX2U2XbMmQ2UZeBtgcaVvpkLTsR6bCoT1LTRx5VEcTf7gzZsOymBW3lk+19RrnnpzdilXe33jjwG9SYVfB4rmAA1afIlBxhrL0Hjdu2BZYUhlMWvKMmFITMD2Ez0hvT6v6S39loDC210t4mcvycerR7pier0VBJ6jfRnLYE0wBn3ODlnsXsdjqgwiTvI2tPB9ls5FYpXeE0uL0nC8Ozg3+nxnMEihKTM5UZXke8tXopuJ+HI0aTlNdEaxa68gCN4XIV6u7cTzhzpwtMNZNRTKfLgww7Njny50DmODXuAUAkKEpgDgpIcTIH+Tiaq8NLWKsaO+V7mFQsln0mCI7IjNMRl6GQqcBHLVr2d4VE2K3POZVEcMLyUXFH/OWJSLV492KbePP6s7nVzspMTVtFDIS09C16CPwWGEB2icMDKsk9bzt68qwhcuXIKvvG0plhSl4+GdzTNyHUQTro45xsexeUFwVv3iDL06ZtuH7MrRFEgQuCsUe2gDX1ZgxHvWeheZNBgIPtPOcyyby0vVq7wEb/B3/kI7BWd5B8fMJR7q171BRxOvd9NKfJWrYBl2NI1gVUnmtK6WvuA5yEMn6Bt+DDLWXjjUrsrflhQG72Yi3C7LizNwqC20Mhd2JWUJkb8gcHfOWZKvsm2ePdge0usKQjjoMAM/z74Zf1r4Qziu+XNQ5+yg1T41n8ltdZrBrvHgEuF1lfMa5RyfQalgMOROZF7aufInBCw0sXtuoHBcwYmpedTzMcZFNC7U+luwY+xAsiFRus8Jgo+Fw/7kMjUXJaycCTVmgOM1b/cM0iM5TRFBhKYA6DOPqrwlf3DAT/Hm5SNdyqI3uYoVAlrnuZnkNPHE4qp5fpoRO92cSRSaGNrtSzw7Z1E6CizH8NLBJr9Wd+YzVealhBx4Scu35rKaRhQGaAxvpzDo+v65MnrNhjIY9Al4cGdTXAxc/bGnxYLKHONkEHYwQhOpaXd2QaGAEwwsn7vx7Bx8YEOm+r8/wtF5jkHgzGfyBR1NXHmcDfsu1mVz3G3BCMW83vFvppXPTTgEGbwYaAi4a2h1epI+tEDwKAZ1HuscwvGuEZy3tGBGIb+85nAyGkr3Oc2x6i8I3B2WGzGMnDkuYhUXYgGvxw/vaoY+KRkN+oU41hvcghrLP305miiAD9tiv8DAXBDmYPK6Fq3yXk6aeLvjuFWIVOmc87GDtjGvHedyU3V+F9w4VuLiHBcIBUHwvHD4XG0/jLpENcfUGqAEA6uMOL/05v7W5vfx4oSda4jQFACc9AQS6s2bBlf5uZrE3Aw1uAiR3NQk8M9D7TzHUhjatsuyU7CxIgf7W/pVG25/HecmGbUg5ZGP42P1X8Wi/34G3X39XstTuHLGySaDwEOFohdLOTwKAhEeoHGyxYuXJwcaO/BRbKJd881joZW4RHOwRJfPmuLgJ9omfaJyMe2bCPQOtnSOUGQNdNJNS/lMOs9RPOocsqPKR9mctvJotY/DYhehyW8QeIYpqGtWkl6nbtxsOHC0Y6orZ0dDj7p5L8oP/pqgOs/F+STphUMdaiFheXH6jJ6H9wnlJJwosQl2nwUaBO5OZV6a6gbYFsLrCsJM4b2UMQPXbV6InFSDGp8Eg7/SOdITZHMRXsN2hFjG6ktoKtHKkaNU3qt9/j5ZnQ+YIVuQQtOEi3rI5qV0btjuM5/JFeY0MbaA0QOCIExdOGw3czzZi/OXF2BRfpqq1Al24ZgLn/wTb44mg85Z3cNcYiH8iNAUYEaTFlLrD3ZrIwwGnwkUrejyCTUQvLXfrKy9dB1sWJClVsz3NPU5fzlqwXhHDQp9vcUJcScJNpRY6rB1xw6v5SkUaSgaVOTORGhKUhMfj6WCER6gtQ9a1Aqot/D2xYXpOK0qB0/ub1UCXbyyr815rKwqCq1rXnGGQQ14uAqXlRzZS0NBun5GneeOdTtvCFU5foSmCWeXv1bE8x2KFsWuqz0Blqq+59RytYL+x1fr8cD2RtXhko0B9jT2Y8OC7JDcPhSo4rlW/kT3sCpFPn/ZzNxMpDiLbc+d2z8UFxoztUJ5DxxwsbSDTlRBiCYUQJ4+0IbNlTkq03F1aSYONA8E5a7jOMGv0BSk0PLKkS48vrctbC4/ToYoIBdqzvYolfdyUZROU0YmxCVRyKkKBrqqh21jqkNtoJj0CTDqE5RA5S2jSeuu648l+UmqAkJcTcKsIMrn71P725CTYsSmihxlnGCkDEujg11ESDfpfTr2OY4VR1NkEKHJDxRomIMRSOkcqZpw9cwkn8k1pylURxPLKjiRKExPQrrJgGVF6c5g71EL7P/4MN5TeyM2bP2i94vFhLiTwLyVwpV4ozfDWRvroTyFkxW6WQLtWOUJzV3V5WkVMsIDNLZo58DMVz4Nc5s4gGM3ungtN9nXasXiPGNQWQOulEyUz9HN5M/yPVNm2nmOZXNF6Xq/g0OGdpKZ5jTVdFjn7IojHYlsPDB5/AdRqkqB+ONnVeLqDaWoaR3ET5+txb93tyjhlgJ3KGQlG9EfptV4OhT2NE4I7GF0MxVmJKk8t5lCV1h+WlJIdnDeGxhuGQpcwaOwfkyEJiGKUHx5ZFczkgyJ6p5KVpZkqjK3yWPRz0SGzzHkI6OJ2WdsLjI5aQhgYqSC9fvMMI860BhiBog77DbH6+CUCIUolPdykZJjlZ7hOFwUi1JOVbBOcLodghGaKO6zfM6T0MQF0wGLI+BmLEZdghq3sWOvIMQ1UT5/6zqHVIbl21YWKbe95kiiqykYatuHUF2Q5nNRjmKWZDRFBhGa/DBgHlU3oawASucIB+/sXLa8aOaTEAZIenI0sc3jgzuafK76N7EUJvNkKczGhTnq5OxsqFFOJf2YDSm9h7yXobmIOxkfvBc5mRl4+oDn8FgKTXRweUrzD5TcVOZFUWjycrON4ACtsZfOAJOa9HmDv3v3KeVqQvjf2g7EG/1mB4732LCmJDQ3EymaEJqCDQIPhZl0nuOkwJnP5N9lSDs8RbOZOJraBu34644+/GP3wJzMemIOHMu3JoXiIEtVuS/ZqfGLFy1GVX4atp/oVbX0DKUNBU6SeG0Lx7b+7+FOPLanRbmswpXlxkHLTLOZXKHrNNiBEz8PB0UUvEKFbhI2cZiLx7QQn+xu7MPh9iFcua50skkAJw9cyDvA8rkAJjJc0eZaj68uwOwiRKEn0InRgNmOIatzMYLndzhg9hqZSVZnqKjOe/FYBhKlnKpg0MSiYErnCHMwhzyEgTOfKZCOc+7lcw29o0qgEoS4JYrnL8cldDOV5yRjValzPp2apFel1sGMlziWZAnzkkLfMQe8B/VKuXFEEKHJD1pWSGaAjiZOPtjOeyaii2sgOAc/DL50hbZzupM4aPMGT0TXetSlRenKOritPwtDWctgTzQisXiV7zK0CXEn0ZisFGXmFLlmsTBgjYNDZi3MJJ+JUBDLTjGgK8ylabxYPbPnBPpP7PU6yGS+VCAOND7m3CX5eL6mAy/VdsZVe/C9bRblYOOAJVRcHU3RINTOc+yKR4fSojz/QhNFJrqaQnU08fj5T80gUgyJaOofxcGOuRcWyJV8aiYUpmdSqkrn5Ps2LcAnzqrEVRvKQn4/vOHbHOPKXTATWMZHhyTdEnubgsuA8QbPezZXYLlPuKDAx0lpMF2iWMJLfYiu11DhNZuTdrrZZkuZizB7oQvpP3tbsbYsU3VbnDJmKsnEgZYBjHUf8zuR0crrOZ7xtXClHE0BToya+pwuJgrkDMkPBzynmaHG66JPInCOaZ334o4o5VQF62gi6UE6wZnT5MnRpC2eBbNgt7wgSY1Vaubg+MIXssgxy4ji+csxG+exl6wqnrKox/K5YFynnLPyz+lo8ifOc8EhXIuSwkmCTxGdZ2gKZyBh4OFGK4ug46ByYvWO+SAM0kw26FDTOqBaVXtyPFEEOWdJ3hQ79fryLOU2GF//Y3ScqMHHLj8/YIcQQ2/pWnpyXxs2V42q16bwRCcEV9XXlYVWJuNehhNu8aajtx9lz/0vDPZjQPm6aaV3DEjnpO3cpdO3oyeYy0Lx8fmadqW287OvKM7AytLMGZUOBnJDfvn4CJbkGVWWkjt7W6xYWmBUod4zKWcrzTSgIscQNaFpd4tFZSQEU6rHwHM+vDLbEPDKI8PDQ4HCUl2XDR8+JQuv1o/g2dohLC8wRry0MJrQpcdzb9LRp7kZOSnjQCJIFyFdTTNBu9ayCUOKMfRblNaVjc7QN+q6VCnfTFxIgxbnde+yNcVhWUhQjFpQOdYA2MfUdd5bVxR3tPBwrTtpKNB9S8Prsa6hkyKj23tr/9N7kd53CCkerp2C4O+exXtrffcI6lWumdMpdPnakmmPpXDL9tUNKEEFJzAUhbxMZBhloK1u+3I08XUnJ0Y+no+09DlFITq/6Rb3lQHlEYpEbtfLIx1DXnMfp/wdnVba+wvTOcZJ08HWAcQdM7y3RILBCaEpNUhHE0vn6JTm32e5iErMZ8pO0ak4iUBJMSaiMtegcpo2L4jcODKeONxhxYP7BvCxU7M8jmkFzNvzl4tuNFSsKE5XzmtXaKDgOIwRJoGMw460D6m5mb/rOe8Z2rjTZ6MsIfaOJqvViptvvhmnnHIKtmzZgj/96U+YzfSryQ5vGtFxebivyvE86piYVPDke2hns7ISMt+AThxP4dl0KDgT9qcOcjZWZKsV7O1NI0gMsgyNE7RLVhWhpd+CR3Y3q652dDl96eIl+MKFSyZP0pnAyS5booeTluMHUWw5inEGoHtY0dSUcb8DQhfnFUvovnnZClUiyYkhhb+7XjiKN+q6I7ZSWdtpw1OHhvDnt/qmdWpjdhDdNutKZnbR5z7+7Jk5IXWtC4VQO88d67EpQYwZT4EOCPvMwa9SUER9omZQhXUuzTfi4sVpKix9b2v8ONnC1xnJbZ9HIUvEG5p7dKaB4FwNoyB/6epiNPdZ1PUyKOwWmAaPq6+EDlIKjOvKZy6qu04yi/7zQbyv4Ra0dAWeJUVRil1StPKjUDDqmXmQ4jUQfLSrDkldB9W1M17KXITZwet1Xfj24zX46XNH8OjuZiU4rSnNwvVbKj0O+Dmm4fG8jzk1fvIYNYe3r4kDx04DllHl3A4k37G5d0RNRpYUOkXyI8G4mjyU5/G1eb3hAlQsSlEoNHGsx0XHuMPDvYXu01By6sIBhSIKPXSEB8P6UpPKV7p7e5/KZXJ1NAXacc6V5flJKhKAY6J4hGOfB/cOhO39bW+yKDfZX3f2qzB2YZYQhbEhDRFc0Occ0x2OWXgMsomTPyhGUfBf7MfNpLlAiZTPzQKh6Qc/+AH279+Pe+65B7feeivuuusuPPXUU5jVHedi4GbSRA0OmDip0PJGuoesuHpDmXIYUUw63DbocYLFGyBDZl1hmQVdSQyozA+h5GJhbio+e341vnnZcnzi7CpsWZynxKFwwedigGU4w7ZrLHnoTF0MW4IRw1nLp61oMnOFQiK3c7CTNJZIUnT6xmXLsX5BFp6raT85sAtjaJ4q/6sdRlmWQXUnuWfH1IENQ8CT9AlYmj+7VPhQOs8Fk8+kkZmsQ18IjqbX6keUQHXZcmeI4IJsg7K4P39kWDUJmCvwmhJPKzjpSXrltOHK0kygiMzVL04e89KMeF0TggMRgEctSHzoY6jeepP6Oj5qxvb6XqwoyZiRy8rTJDPRbkGZtQ79zYcD/lPeE4pTEmYsZPvKaTpgzkGLqVpdO8cK/ZRZC4KL849uX5YqUFi65YoV+Mx51coJ6M2xp5XP7W/px7g+yedEhotrvA/6coxw4YuHtMop8jMxUkHgFNuzklWZG0V3roIHjAexqKZlQC0SsglLLEpRZtukiSWVv32pLibdRil2pIXQQIVO6csWpyi3NMUSTYBhRlN+avALAHSSc1zRMhCH2Vp0d7dbsaPJjOePzrxTKUvjazutOG1hMmz2cdy3q39OjamE0KGhgnNdllgXeGh2wqY1NKYHktNE8ZqCu798JsJ5Pq/Z0nkuzoWmkZERPPDAA/jGN76BlStX4qKLLsLHP/5x3HvvvZitcLITaMe5SMATjZMKlkowhJqlciyp44CIq4CH2gY8nlwcNHmyFZ6yMFt9DXViyVW/sE203MhPN4LlseFK/leiRK8djRf8Go+t+jmeWv69aYNNlc+UHVqLcNeyRCrvrO19ubYz7CuV7EbCwcely9JUCRft2n93uTHvabWobCYOvmcTLNXjZCGYQPCOIYcaGFYHIzSZEjFgGVMleoEyaHXgxaPDOH1h8pTuMRcuSVUOsp3NcyOzhjlrzIHTWoLHAzwXM0wMBLfN6NzXcur4fKcvysX+5n70Dw4GJgDzfG3bj0SHTX1tqz+krsMbJ66fYcFlkjmYtQxH7IGV75Kevn68vebrMxay2SWV+5+OE3d2tFjwcPW3cXflD9F1yW/josxFiH9ePdKlnH/vXFeixKZA3eBcuGFGRmOP7wkES+foZvLXQYgEklM0YLGr59REsCVF6SqnKeD8GA9iEfOmKOL6HStFqKNudqpzzBqXOU1u0P21t6lPCTUvHop+oxXmLKWbQpsK5STr8IENmWjsG8U/9vQrAaV7xB5wxzlXijP0aoH4RG98Ck2dw3Z1Xr98bFh93plAkYnb6syKFFy3PhPHe0bxxKHwhPALs5udDX3qmsCGK57g/YRxCKoLuh94HWflQyAVK5wvM7Zhtojz81ZoOnToEOx2O9avXz/5s40bN2LPnj0YGxubtUJT5sSgJRbwhKLI9PDOZjV4Om/ZyZOPne248uYeIssTkJ2MPLG6LFPVvfoLRosFmjsqXDlNbQMWpWZXFOWgfOlG7O+wqom1BgeSHNQuyA2sbM4XvECdsShP5UzwIhmulUqKI8/WDqM6z4jKHKMawLx/fabKKXrs4KDqiEZLc7TK3cIJJwqF6cF1nqObiRZ3uouCCe2kKKdlMQTC04eHlYB4weKp9eElGQa1rbmqx9I6f/AY42rdP/f0h9RhL9JoE5Hc1PhxNBGK+zNZ3ebfcvKolQ9vWJANgy4R+/ftDkwA5vlatApjOqP6+lZ/pirtqZ5h/pS3SWbD+b9C8+B4QIHgfMx473FkDx6esZDNax/XI9zL51gyzkydM5aWosNUhW6L9A0R/EO30ZvHunHGotygF6QW5qSogO99zb6D+1V+ko8gcO1+TFdkIEILowaI1jyFq99sIBBwZyM3scg8blDnzsqSzJiVolCIo2jROxyfooUr2471QJ+YiPOW5uOt+p6oN1kZDNHRpFGRbcR712Wipt2Gv+3oU066/CA6zmlQxKFrvWGGIk6k4CLfulITSjMMqoQukPGPL3dUUboeeal6VOUacfmKNLxeP6IcU8L8heP0/x7uUJl9ntxMGuXZKWjysyBBWDa3KD8t4EzNuO3WOcsJ6+ixs7MT2dnZMBpPCjN5eXkqt6mvL/D8iXiBk0ROWGJVOkfoXuKEic6bd20oU5MljWXF6aoMznWSwFr3nuHRaflMrmrwB0+viCsHg+vgkK6crsHwKMrHOoedokROCtaWZ6ltVdN6stSwc8iqOlsFms/kD7rNuH9eqOkI20rlnlabEiguXnJygkvR6V2r0rG1waxEDOYL8GezkWA7z1FoosjEQXSgMKOJ0NUUCMy72tlsxkWLU5HsIQeK4hPbEG9r8H+j29Viwd5WC4522fCzV7rxj9396IwjwUmbiGkr4PFCVrJxRkKTNkksy3FOHplltGFhNl7pTnOWgfkTgA0mjF39JxzdfAesV/4Bu1rNSqwKWwi42ySzJC9LDdzbA+i6yetWt6EUjoKVMxayeT/gosQxN6FpZ2MvDIkJSjznNbk7zNl5wtzk1SOdagGBZfXBwnNrZUmG6mTry000ZBlV5bX+nivQzmtsGpBq1CHT4FClqAszEtUqeFDd51zEIrrMOQdnmW2s4D5g+WC43OGRgqL51uPdKnqAi6gUENX4KcpCU3qQQeDu0FHOMdmRLuf2DsXRRMqzDGjss8ddNza+H45Di9J1uHpNBrpHHCpCIBR4nzvYbsPKopOLW6ctSMap5cl4ZP8gGuLU0SVEnl0NvUroYdMlX3BRgEYCXx3i2OiJ8+ZAyuY0suK1W+csJ6w1UGazeYrIRLTvbTbPO8/hcKh/kUB73lCfnweqZdSO9CRdxN6jP3JTDRgfH8OpFTlYkG2a8j7yUw2qTnx/cx+q8pxiSWM38zbGUJxhjNl7nsn+yEkxoGPAHJb3frR9EGXZJiRiXG2n8mwTdp7oweoS54Wnnl1wxsdRnJEUltcz6oBzFufiqQPtOL0q2+nQyl3i/GWwz8/zwj6OZ4+MYFl+EkrS9XC4hDCuL2FJpV11ouMNOmGcfxLc4EQrvYtlbXxeig67mi0YtY8F1MmtvmdUdWUJ5rOybTHHbd3DdrUdfUH7/iP7BpCfosfGUpPH18lN1mEdXU1HhtVX5mN5gjlaT9QMYVVhEq5Zk4EdTRa8dGxYddpbW6TH26qAjAweF1PPi2iet12DFjBPOlmfEFfXC3aAOt5lC/k9negaQoZJh1RD4uRzbK7IwutHO7Fr00+xLrUHyKkEEg1ez01HggGW9Ersa7PAbLNjXVlGxLZRQZpRXYsau4dQlO5bNG7rM2M0wQDHVX+EY6jR7+fwR0VOsrKr043MCSonFduP9yjnK3XW7GQDOgfDc00OGAaw9xx3fja9KSLnRzwd73MBhnSzMQbLVEMtr6cLiM/B8n9vi2V0GzGnwx85AQotLf1mlKcnIuGBjzoz0wpXY0nFt1DbPoQLlhcG1GHOFZbNcSIUi07F01bn43zStLe5X5Xunr4wFYbuw7igOhOP7O/G2Uvyp3XC5HXp8X2tqu35mdV52FyZM6NmCFMymmYoNJFTypNhto9hf5sVqSE6pBZkGfBS3bDKhmTnuniB74djo4JUvXIiXVCdiueODCuxqCwzuOOcXXy56Luq6OT+5X3nHSvTlZh1765+fOXc3KDD2YXZDechLx7uwKrSjMmO694oy0lRYj7dqMwO9gS7onPcrzV4CIScVAMOxWO3zllOWIWmpKSkaYKS9r3J5PnAqa2tRaTZt29fSH9H1b67ewgt9RaMdUUml8gfvLmuShtFiWMUu3dPX+lJtprx8t4OlI+1q4v1zlYrBnqtaDxyEE1x2oLd1/4w941gT9c4FqJjxtvtrUODWF1gxO7dTit+qsWK145YsETfrZwqr50wY2zYgUMHQjs+PJE0Ng7zwBD++PQOvG1RYE6pBIcNSSPNsKaUYpylOhPUdLFjwijW5SZh97Hp9esF+nEsy9IhVzfu8feBsq9+5uGOodIzYEdbnw2vHBpEpp/Bnnl0DA3dVizL1GH3sfGgjoUB5iodH4ZjxO7zcc8eM+NEvx3vWJqCvce9b5cCPfB8jxV/er0bp5d5vra91mhGS88ozio2Yn/9MLh+d0FZEmq6bHjtmAXHO/W4uKombNerUNjVYIZ1yKHKm+OJzg4r6hot2LlrOCAB0p1th4dh0idg9+7dU36eMjqMh97sw/iyVCS0HArouZ7YWgPjONB0tAZNiBxjw0N4Y88ADH2+21u/1WLBSL8NtbUTx3KAn8Mb1v5RnGgZwUtbh5Fl0qFtyI7ahmEsSUrF7t1dGOkbwd6ecSwYj47TgNfDqh23I3mgDuaMRTi28dYp18Vonh9C4LxypEt93VIdvJvJNTOM7iLmqXkTmujwTg1AyKLQcqLbf44HRa2zMrumlNSuXt6Dv7enKof4FNFMa/LBx9JJ6OZW5go7O9ad70mgijJ0dHGyFUuOdgyqUsgr1pSo5jbu99vXj3ZheZ4BBU9+Sm3TUwtX49Xsm/DswTblvHd97JP72/Da0W7VCIe/f+lwJ86szlWuy2Su8oXoruG4Yialc66cVZmq/oUKhSbC8rl4Epq0sn/NqXV2VYoS1FhCx07FwYhC+9utqmSu0K28kM9xybI0/OaNXuX6Ls6IL5e1EFl2N/aqapwPnLbQ72OLMkzqeKFz3ZvQREcqo2foUgrmmsmFDEasTMkW9LO4IPgmrOpJYWEhent71cqoXq+fLKejyJSR4dlGvGTJEqSkhKd0ydOKJQelq1evhk4X/EX7UNsgcjtO4IyNS5ERw9Wpk4lX00ktGcLdr9ejqKoaxalAc/frOGVRKdavX4p4I5D90WlsV6vr69bN7P1T6U47UYcLNlWqUE6y2GrH4acOIyG3COuqcvFKz1GcsiAZ69aVIpzo8vrw4M4m5Cyo8l+WZ3d2t2LgsMqEufpPagXfbjPjmSe24dzqZFywynvWw/pFM1tBoMi0uiJV5RHFgiqLA2+22VCQm6Q6uvnieI8NuekWnLkkHYV+nEnuVLfakJdlxLoqz6sbarX00BAGxoDPnJWrrPB+Menx1OEhDCcmqlBLV5id1XZkBNeuz8SWqqk3wo3VwMK6fjx/ZBDLlq2DyZQSlutVKOweqUdOYSLWrVuAeMLUNoiakROoXhb8tZddKx9tqsFpS/OxbvHUgO3k4kH85Y0T6txkB05fcH+8vn0PzIYMXLWhDOvCGQTugaNjTegYsGLdOt8n9UFbA1ZnjmHdupMTsZmwfNSBbb2HkFpUjHUVOXhkdwsWlQ3isrOWqMWLNn0b9rcMYN26CXdmpOmoQeKrjUDCGIzmRqwtT1dlSeE+P9i8JBoLXfMBCjLMZjqtKgepfsra/JW8MYy7rnPY63V6OICMJm3SsKuBmTnjXoPD2SGPAeTZK5Y4haMJAal80UqMH69XGZgsu5/EU5MPlsxNwMcz5HhFcezK5qbmjdh8fv5Is/V4D/Y3Ox0CV64rnfI+KAI291lw2TIrsMO5TRPa9+GSlRb8pS4RDd0jk/mZzx5sV0LmFWuLlbDEDLmXj3TipdpO9XM6nM5d6owuCNbNRGZaOhcu6KzKTdEpoWltSfxMaNlJj3EFWcnO7cTx4jVr0nHXa7144ejwlGgHf5mjNe1WnFLmuQEPx3X8ccuACE3zCY7ZXjzUqUqnizN9L7Rpx19xlkmVPXuC17zajkGsKXW5dgfRrZPlc5Pvw8/ighBloWn58uVKYOIq8imnnKJ+tmPHDjUwTEz0fCHngDHSk6pQX4M5LFyFyUpNitmN2h/VBekwGfSoa+1B2Z6v4Jz6XbDkLoduy/1xezL42h8FmckYtHbDPu7MDwmVEz0WGPU6VOSlQTcx+MhI0WFpUQb2Ng/ilMpcdAzZcObi/LAffxsW5uD1Yz14tqYDnziryvex090AtO93loq074euv0ENXLc2DWLQNo6LFqdAF+FucrxoR/o1vJGVolN5GF0jDr/vods8pt5rQYY+aGGMgeADtjGvr/HysRG82WDGlasysDrAAd651anKKv/k4SGkmRKxoTR58ib3xOEhtWp31iLPIt760iQ8c2QQh9pHsLEqfcbXK65cM0vH2+qON/rMdiwryoiasBUoOWm85iaq/IzsIINVu4ZZuw8szOW5P/VvlxdnIj/dhJ2N/agq8F+7f7jbBqPBhLULsiO+jcpzUrG/eRDjSJi2+u9K19AoFhVM/2yhkqLTKSt6Q48FGysSsK95QIU5a4tF+RnJ6D/W4/d9BUQgK4N51UDRyUm/jt+7fNZwjRni7Zif7Z3meN3b4ibshkJxpgkHmp05Te73TpYj04WSnmQISGhhiQ5XqBmO7c3NpF4zL9s5gZg4NjMNJrVqzlXxKUKT1uRDm3S4ZaMxX4qr6KF29Q0nnDSx3GnQalddPKMN9x/FJO7Pbcd7UZBuUoKQxmt1XchPM6JicTWw++Q2XbZiDYo6m/DMwTZcv6US/63txIuHO3HJqiIlMpHMFAOuWFuixCUee+z2SxfctaeUeXXCeWIwzoQmwgzKaAaCU/wZtIwhM9n79bB9yI78tKmdHuk4Or86RTVGYa+ni5b4X7Bkd7lh29iUfCZXTHoKbXq0DsRPjqUQeXY39aF72IbrNge+4MnznO5RT7BDMBcQFgdRNkdYrpts0GHrsR5cub40oMUFwT9hvbomJyfjyiuvxG233Ya9e/fiueeew5/+9Cd86EMfwmyE7bVZZx+vIhPhwJ8nU0v9QYy17UOiw4rsgdqQuxDFmvzJznMzyxY41jWk3ETuE6N15VkqIG5fEweyCFsQuPuq7NtXFeF414jKefCJh+50tG3+93A3NhTrURBC95K52nmOj+FqXyi1+xSa+s2egwOZmfTkoSGcuyhV5T8Fw9uXpqlshof2DqKmwxnkvLfVimPdNlyxIs3re2VmWFW2DruaXDos2S0wDR53io5BOtP+vrUBv3npGB7Z1QwLVZYAV5G4cpNrGlcuEnUjjRO0fJNQAsHZdZOXbK1dufvxVpGbqjp5BjJROtw9ilUlmTMSvQOlLCvFbyA4w3PZlakwzBNZbhMGgh9sGVCTcwanu07Yea2ccTcWbWXw3mucX70dbwYTXlr3Qzy34ZeyejhL3Eyv19HNlOtV0AkG5nPQFeTpeBu0On+mHE08fnxct7SGJz0+xhJ0PnNikZ1imNb9jdke7Fo0JZjZR5MPXofZbISr8vGA9vljldPE/ccyx4tWFOLsxXkqX+lwm3Ni2DdiU9ea0xflIcGQPGWb8nv+DV1tD2xvwjMH2nHh8gKV2+ROusmAS1YX47PnV6t77a//W4dnDrRN6d5JIaW+x4YnDw2q5insbsaxBPfrkM35uHBkNIULBoK39NuVSBgNOP758cvd6rrvDZayeRqLnl+dirctTcMrx0fw2zd70TPie+xxoM2qBK2yTO/XieIMPVoHfY8Hue8so4F1/WXWrhC/cBz630MdKhPS05jNG8zB4zzR0/7lAgEXXrVqlkBh5tt5y5zdLzsGJ+4rYeogPp8J+9X1pptuwsqVK/HhD38Yt99+O2644QZcfPHFmI30jbDjXPx386Ij4aA5FwOZS2FPdLbjnq0nA1cCeYH451uN2NPYpy5CwcK/YSc+trV0h536kvSJeOZgu/qqCVvhZnFBmroQvlHnzK3wioeBK1fo2A3vgkXxf+yFg4IAO89xcBhK22BNaOqzTH8NdoNjzsD6UhMuXhJ8tgKFC3abWV5oVIPYQx1WPHFoSK3YLc73fWytK9bjWOeIU0wZdZZQVm+9yVlKGYTow2OdxwuzUXY39uGnz9WiJoBAQ74uhelVr33O/+Q/ynDyR6t+KEJTY49ZuQq8BcXmphmVWOOvsw+366BtDBsXBme/DhWuplEg82YHJ1z14yXRV+vfUOCAjNv6hUMdqqRQNTKYII9B5S4dCkPG08qgF9ipsS+tOm5ducJJXj/arc6lszwIAaFQmO7c55MDfReGLM4JaJrO7le0nBSafASC81xj10VPi4ks4aNQ0trv9txugpT7dTiW3eYUEwJcdpLzfheJLkp0gm2v7/H5mPpuZ/kjrydvW1mEZUXpuG9bAzoGLKrM0qhPxAbt2uq2TZnDxEXAXY19OGdJnt8uVBQnP31etXocy+l+9VI9djSP4oF9Q/jO811KBGHTEY4BeH/+6cvd+N6L3aqhB3d9qOHdkWBhtkGJY8390XE1tQ86Ra2mfruPjnMO5KdOF4d43pxTlYpPnZ6tnEp3vtqDPS0Wr89zoN2qmqP4Wryn0MTSOV/355rOUdzx8rBfEYkLvXc8WYMhawQdUn4Eb8F/RE3nkA3nLvV9jrtTPuFcbO4b8bjfOaYJtpSWcMGEcQ1PH2h3/iBMHcTnM2G/utLV9P3vfx+7du3CK6+8go985COYrfSZR5VFN95ZWpQOhy4Jfyq5Ff9Y8hMY3nvPrD0ZODlkuVlWigH3v9WInz1/RE2egxGc2EWGFvuq/OnCAZ0JzE/gAJJCUNjblU/AGym7otR2DPkf6LkMspgZwcwBdq3LnqiHn+sUpunROWxXgytfcLATatvgTFOiymNwXSXkoOevO/pQlWPA1aszQnYuMqz6vesyleX9nu19Klz0smX+y7JWFThLACmoqkl3234kOmzOvK4gHIks1+CK/KWri/CFCxejOMOkcoju39ag3Aa+RIscWzOSe2oCmvxHE+6LzBQj+sy2kBxNvsonKKLw+jDiZ5C6q7FfBdQvjIDr0ROceHGS7WngpMEMJ0IhLZxwUMbDn5bzjW5ZVHSX0S3QPeTdaRUQ2ZUYL1yNcT8rg3R0tg5YIuI2FcIPRe2VpZlhcTORjGS9WgRqnzjWXdEmjOkjjX5FS44lGCzuy9HDjKBSLx3seN7zfRz2Up7h6TrMcUtpEKvyYcfFNZj08PXINNhVTlO4oWvo0d0t6lz1BjOWeJ1imDrHWe8+pVxtn3veqMdb9b04ZWGOV6cor//XbCzDu9aXKpEqkHsz76XsEkjBicPFBw9Y0dxvx6byZPzv6Tm46fw89fX/XZiHj56ahXUlScqpWZljDKnhRKRgVzd2so1W+RybHhFvr0fXF8c0vhb56MK64cwcLCsw4v7d/WrxbmTCLabR2GdXcSTeyuY02BmY9+deLw50crRrFLx98z7hT+zkmC9iofiBunTnEI09I/j9y8fC5hTb0dCLkkwTyoO833MBjNfnRreFOd4j6ruGsaTQ/xjcExSnLl5RqByXJybEcm+LC0JgzI+Z7IwcTfEvNHGAx0F5pzkRSSUrnVbkWQwvOB89sxKfPncRclIM+AcFp+dq0drvfaXflWOdw8oN4W3At26BcxUt0hOZ1WUsuUlUNsxAoaOAg55zl4TeuWe2we4jHAz0+rBdW+xjapASutDkHCT1WxxqpeyV48O4d2cfluQn4QMbs2Ychs6J+Ac2ZGJpfpLqnBJIxxiTIQHLitKcQhMn3QyD1wXnSORnOdg6oFbRORhnh40Pn1GBd59SpiZILDvwBgXQ3qRSJBSviktbMAUOXoODgV2f6EAoz/Z+DaSjiXT7Kc+l26EsY2ouRaShu8KXo4kuj7Qk3YwClz3Brk3MpKGbdHXp1OYD/Px0h3TN1BlhMOGJZXfg4eU/87kySEcaJ4D+wtqF2MMyXU72gi1R8AWPt4KMJI/lrZxE8FqbVLAooHKG7FSjEtQ9weeii89buQbL7hflp2K/KrMfD+g6zLK5mEYtuLkGFyZ0qE5O4WTAMqpKClnmy7GWN2cH85lcz2EKfx8+vQI2O4ULB05flOvX3b6pMifo7clx3w3nVeKmc1LwhS1ZqrSLi0Da83BMxvv+JcvSccOWHHxic2SbPAQLx3+lmdHLaeoedo67GntHvS7wEX9jL2ZtvmdtBq5Zk6E60v3k5W5sbzRPnjsH2nnvSlSOLV/Q0URaBrx//hMT26a13/fiR+tEBpu3LJ8ZE4RLdy7Aa/KfX6tXZfaBzsd8wWvwodYBbKwI/hzk+UyzADvPaaXLrx3twk+eqVVi0UwaMjBiheIXO136u/YL/hGhyQs8aHlDDaY1YixZPnFSxXQ1LQKC00fOrMRnzlukBn1/feNEQBbYY51DWJCb6jW4tjo/DWvLMpUQFEm4Wrd+QbaymLtmBnijc9CKbcd7VMBlSojtemcj2gCmfWJA44nOid+FXjrnPBYoZj16YBBP1Azh7KpUXLc+Q4mS4YBBlh85NQunLwx8gry+PBMt/Ra0m6E6Dh7dfIez82CAKye8yTL0cGVJ5pQbMI87Zgtx9cmX0JSWmobEa++JS1swRf5gS+da+yxqNZvh1t7QSmq6hr0PUumg5AQ1yxTdW2RJlgltAxav1ws6jhiqGwkY1EtHgKeSQ64eztTRxAHb3nYLdpiLYIH3yUZDz7AqnQy3a2s2YLVacfPNN6tmKlu2bFEZl/EM3YNKFAzzog2dfbwfeiqdo8jqnuvj7bqVy85rXoQm5jP5GzMx3JzX550NvQFdh2Pebc4tTyQxtyrsGU17G/uhS0hQzjNmoXhydphHhtE+aJkmFlP4+9iWSly7sWzyOhwJuHCUEUe5S8GyIMuAht7RiE9y+fx0NKUYE5Ww5en1GFlA8Yv5mP7g2GNjWTJuPDsHS/KNeGjfAH7zZq8qA6T4tLIwya97jMHsFKTYudfbomPrRNQCHYm+4KIThemjnW5Za+Firuf3uIjHjBv446vH1XlPQok1cIeLrDweKOyEAp3rvAcx++3nz9WqHLjVZRm48eIl6loTKjyOmbNLsZwLCMLMmL1X4ggzYOZFl12x4t/RpNW08/odbNep2QAvJh86faFyK9y3tUGJgL4miPXdIx7L5jRo437vpgUBtdGcKSyfG7I6ArpYscsKa4P9rfTNNTJMiWo1jFkB3tDCwvNTdTNyND2wdwBvNVpUqRyDvGMd9L+kIFWJiiwPhd4ES3ql+hooLNegw8XTRI8r9b5ECwpNarAfp7ZgOpqCHcw09o6ogSXdOb4EYA6WunyEbjPXxT42huyJ4yZaMBCcu4v7zduKIt0ekYAlc+d4ydnJSU2acdYLS6E4Ged9dYoTwg0O7hbkeM7Nmev84Ac/wP79+3HPPffg1ltvxV133YWnnnoK8Qr3Fa9fAXVZCyLLhJk7zPJxnxxyoSmdQeAkgOuWL0cTnYO87/gSPOjU4qLUU/vbfDZZ2HGiV5XpMVQ/prjliWRlpPvMqAqFXQ29Kq6BohqFJrWP3Jwd7SdqJlyJ07cHx11cCBG8QwcWO+L1+SgfCwcDE3ECa4qTVMaSVkbnvsiXl6oLyvWdYdLh3Wsz8cnTsmG1j+OXr/eooHAKTf7gdb843XvnuaY+5z2kIisRbe75aS4whmLAYlc5YLzvcJEm7Mzl/B4X8Xj0/g/hnpcPqcXUj59Vpa75jJaZCbxu8LrJ3FyW14YCHU3ct3e/Xq/mTjecX413rS8LSxn34sJ0VBekqaymULKCI4HNPobH9rREJHcvkojQ5AXtJJoNpXOEq9xfvHCJ6pQyF6Gz7LrNC1XNNVVrXyGV7J6xKC8+tgMHzJV5Kcqp5AvmGexvHlDdVkIJsJvNKAtsph6NPqziHOywHI2291BgSRBXythY5WObslSnuHiArjuWKlFoCnbFTYVrtgyoZgCessZ4E+b90ZtoweyOSK4qzxSK/MxSC8QNqMHVLQps/gbFdDr4ullrbopoO5qKs0zgW/dUPkeBnauKkXI0+YLlhtxevkR+f3BSSvcgBcS6ziGvxzS7gs7FBRN/jIyM4IEHHsA3vvEN1VDloosuwsc//nHce++9iFe4qEPXil9RMMgsE4qpnjrPUWgKZhLB85zOdE/XEI4V6Gby997Z1YyT8edrOjz+fn9zP7Ye78F5ywoilvkYFC4CXHaKUYn1duvINJFv67Fu3Lv1RFBPTaGbDq/1C7JUBgrL8lSHYDdnR529QC2A5CaNSVByCJRnOucdkS6f07rErSsxeX29jmF2nAtt4s78K2Y3XbosXWUzVeUGNt4oyTCg2YvQdKLXhmRDAtYUsYmM1ev4QAvxP2NRntPVFIacJrp6mU/Ec35yvBanC3UzZkI8Hhu1wNy0B1mWZly/pUpdf9UioL9YAz9dlHkd4T5yz4QMBgpBHD+/f/MCXL+lMuzmAbqaOBbcfsK3ozVijE5dnOE8gR1e73+rIW7Er0CYXzPaIGD7VTIbwsA1uKo4l1eBubp4xdoSvFHX7bXjCWuHKUYw6yRe2FSZq1r1euqiQ3jDemJ/K4ozTVhXFp0OV/EG6/ZZd+9NbFEd5zx0PQmGD2zIwmfPzMGiAAc70YK2YWYRcdIWDFyh4yB/lVumjmsXM857WrzYy5lRNBN7caTR3KRclQwUlrBQYPNHbmqSV6cD4eCC4dyphuheTykyU5zmJNid7mGrcjtFytHkC5bOcVwzk2BhCk1V+WmqI6c3oYnHNINggw0GnQscOnQIdrsd69evn/zZxo0bsWfPHoyNRdbZEAoc6LI0N6CswyCzTLTOc+45TRSegxGaeH1ThhsPkyKWzgUSNcBJFcvZX6/rUi4rV/j9gzuasKYsE2fEoROZCwk6hxWOf04V+XifffVol1rcCqa0jm4muhmWFqYr1zgn8Kp8zs3ZcbzPjopMHRIe+Oi8CkoOFywdy0vV44SX3KRwCk2cMlDYyU/zvNjHRb5QIwsIF322VKao8VegrijmNPWbHdMCxQm3yYIsPUozdOqeRLHJExQxOBdgCXZFXmpYcprYWZJzjHu3NqisIk/lvXOG7EqMFa7CsEOPNlM13nHemZPzYY7NfLrNA+iiTDdThkmPJQWhhXYTlvlft3mBGgNHYu7L+8P68iw8V9Pus/FBRBidujgzPmpW9yDOE7kQ+eLhjlnTDTG8iaJzzNHEG6q3rhhCbGApGkPo2PGEK/sL3DIAmM/EFdaZhjuHk1UlGfiPUYe3jvfisjXF035f0zqoShA+dmZFfKyIxoCKbKNqNdw57Dnwmz9nR5OZ2tHjER6v7Bq3p6kfFUH8HbticCDFwFpvokXBZBeznCm/Y8cQBrJyxT9eoRVaE/0DcV6xwx6Ft/OX+Z885qUnYd/EqqSnAQoFj/w0CvfRtyhTiKFDgu7GdJNhWsc5ClHRhsIcoauJXfuChWVHdKNeurpY2eS5QsjSBtfPR3gd5CWwPCd+FgqiRWdnJ7Kzs2E0njzW8/LyVG5TX18fcnKmnsPE4XCof5HAYR1WK9IO62IgKdWjUGMZtaMsy+T/PWQuQGLhKmdHzcJVGMtcwDfv9eGpxgTlfmvrH1HlxRpDllGk5KUE/JmzTDqMj4+ha9CMnBT9lGtFz7AVRRlJAT3X6ZXZeOt4Dx7d3YyPnrFQXTOsow785Y16ZJr0eOfa4oiLgdr7DGZ/s2Q829qExPb9GB+zAm37MNZ1FI36heicWPja19yHMwMQyXitpNC0kjENGIeeUQ05yahp7cdpldlAogHIXaIESOasXV7Uj/G2fU5Hw8TrKudHNOA24u5I4MJVZFb+NXfnTFyevmAjCrp3HC6dcsNNx6Ad6cZE5Tjg69X3jE55PYr+FHzyknURfR/uFKbyvGWZ3OiUhUF2JqbQdHaFEXkpYzwo0dQzjKJ047TzQ/08I0mdl1V5yXjhUCestlGv2a2B0DNkVU69K9eV4D97W/GzZw8rgfm8pflIcsk21Nwms3o8n2jA0bPuxOPjb+Bd552JnIy0yW2bnqRT92qv16Kuo0h06aLscDv36ULb3dCDUxZmq+tzhG5hYeGcJbnY2dCDQy39Xhd1I0IXt+HJ62fj0f1o6zfio2dUqG3/fE07FuWleF6UszuFPnW/ZZMh5r7qT96nwzFmCOY5RGjyAm2Bs6Vsbj7BAd4Va0pU3sfftp5QXV44iRmZmDhz8HvRiiLEE7yx0R7Klr4Xr5xaGscV0cf3tSgLKGuC5ytlWezuBRWA6S40sWyhe4T27ZQ5e0yvLc/Cm3VdKC8eDyqfiVkZvgZODJf25GiiO4bEc+kcnQQk0JwmrftIIG4YCmwssR22OTw6JDonhCYgQt1qfHDO0nwlxDAbgC2+Xd8TFz+YBROLfcHDjKV7obQNZiYT3Vh0QtApRujydA8BZTthrtjNxwUes9k8RWQi2vc2m2fBs7a2NiLvJcFhQ9WO21E9UIeRmj/g2MZbMc6OmC7s67Cit8eC7oZR9Df5n1AlVH8BSSXNsKaUYnz/Ib+Ptw8NYfv+XmQMN08KHcebBlEw3ovdNu/l865wYtrbM4Bte4YxUnBSIG0asKO7exg9TVbs7grsWKs2juKJQyPIsnWiMkuPZ46Z1fNcvTwVNfv3Ilrs27cv4Mc6xsdxdMiENn0ZCqzHYU4ux7HGQbzSvAeWATtykhPx3PZ+pA76L1VtHrTjWNMw1qQOYvdu52p64pAV25qtWGXqhWFiUt0x7EBr+xC60w3oTy5H8kDd5OuOt+xG9OB1nedNZBcL9tV7z5ubCVazHfuazNh+dFA5xyLBnoYRWEbHsfvYEKwjdhxoNuOtI4MqaoC0DdnRPTiKzh4rdgfhLJ4pPG/7h+14tXYQgy65TsyQaum1YSTfgJpWA+wj/XhzzzD0vcnqmmUaacb+3TZ1rdp1eBDlGXrs3t0P24gDbR1DeOb1EZSkhz7t3VM/ArNlDJY2M87NG8eedhse29aNx9+qVQsk1JfYjZGjuCRdAt65NBU5ybP3Xnaw04ZDwxnobDmBntaGyZ93tVpxtN2K3buHvN8/eO6P1qlrgPu5X9c7isbWEZyRM4Ldu9sQ79gGB/HfHYOwd0ZvASxB24YT18/79gxgzKbDYPMoOGpKGBnGXU/04JrlaZPnqwYXiKobdyqhb6xxJ46+8aQz/zWEe0g4EKHJC1xFny1B4HMOWv1orWfdv4e6Z06sWZN737YGpeyyQxHbc2eYDKjKSw2s5tfPa4SbUytz8PKRLuWi2LAgW62CvXykEy/UdKjj7B1rSzCfYchgUboe9b2j0/KTuoad4Y8FM7Bvxzu05754qB0n+u3YGMDjWe7Ajitnewlv1mAJ6d6mfrWC5CpIaflEmlMlHqHYEEzoJPOZeC0IxKXFzCEtc8FdaOKElqKOclLMvINv0NDxQzcTXZt0cGrCGcuICjNiUx7NldmcFN+5Vr440jGoyu9yJ9xQ/Bx1HUPThCbmM81XwT0pKWmaoKR9bzJ5vkctWbIEKSkREOA7apD4aiPsDhsyzY1YW54+zY1y+K1GrDWN4pQNVeF/fYqT480q7HfdukXqezqIsk7UYN3KclWqFijVXUeQU5SOdauL1LlN4brhSBdKCvtxzuZlAZ9P6yh6J51AXb8FmaZsDOg68Om3L5js+BtpuILMCcLq1auh0wV+L3yxsxYHin6DkqIRpOdUYlViEh5vP4y3rU1GKdrwQJ0B1ctX+S1JrNvZjMULhvG2MxdPbrPSQStqnz+CjJKFatGDMEOksLsd529ZBv2ZDwE9x9Xrrg2iycWMcViBvn2ALgVIjMxiCsdwFJlWV6RGxEFfkDeKg7125OYkqayjYOGxzkxK90moK6+321Cdrse6qjQU59txYOL1tCylHU1m5GXYcPby8HXnDZS3Ou1ISdGp96axtcGM/AwDLlyRDCPMOGwrQ59lHOtWlSDhwY9itGkXDGXrYbnyjzDUH8fpa0uwTrlmxrGt/zD0udlYt6Iw5Pe0feg4SpL0WLeuXH1/CoCrRmzY09ivFko5xqLgyuOBpak1lkR8anNVXFVYBEPHwXZUjfVh4/qlU3+R24c6axOWr1rhNTfVseqfOLLtGSzedDHWujli97xxAusXO3DeaZG5d4SburFmZWJYt646ui+81nn9dJhK0fdCI965sQjrq5zu04WLrbjrxTo067KUw24K9mVIbHlg0tG07PRLJh1NodxDvGVKBrrQJUKTFzi5YZ6EgNjUpTLHgeGSXjo5sOTik2cviuhrhBOWm9C1tPVYj+qI9dCOJrQOWHD2YmdL8fkWAO6JhdlG1HXZPJbNkZlmNMUzBRkmlXWytaEXl9Bl42cVjF0Mucrpz13CGnOusLEUjCHZGswn0gTaeCag0EkX1wzzmQKZOGoCG0vt3IOnGThMdyQz70bNsRGoN1XkqAYCtOd/6pwq9Zm4DwPKw4kQLDf01anPGxzks/3wMpcJ+aL8NHUMu5Yucrtzf1y4fG46F/1RWFiI3t5eldOk1+sny+koMmVkeBYzOFic6YDRI3nVGKflvnGnGqjq8qr5YlMe0tBrUYJPRF5fdSdLURlCiYmJ6hgZMduRkJCIjBRjUK/J4/Zg2yCa+y1KuKKTkdANrW3nQLl8bSl+/twRvFjbhfOXFWJVWfS7pwW7zynu9o7qoStepb6vbR2AzWrGeftvg7HrIPRYiCMtf8Qp1dPL+jXY8fdg6yC2VOdN2WaFmcmqI+XRrhGsKHWKxk19FpTlpCDJyIVaAzDxutFF50yg5QQ/wgIJRQRdBF6jNMsAkyFBOcmq84NfENrVbMXjNYO46fw8j0IHr7095jGsKdGr91+cqVddGJsG7Vg84f7rNjuQk8JxQvTHpyWZzoVH123bNDCqtkuyIRFwcCEtBbW1vUjsOwG0H1AOjoT2A+hvPgok6FGWkzp5riwuSMexrpEZXa+YF7nA5TlJXnoyLlgx3elSkp2CX/+3Di8f6caFMxC3YrEw7vp5c9KSpm2z7FQueCViyOZASpIXQ0ZSqnLR6JKmbi8K/Uc7h3HlutKI3TvCzaKCNOxu6ofNgeiOmXWp6vr51v42VZp5SmXu5DYrzEzB5WtK8MjuFqwoyZy64MG/u/aeyWNG53bMhGPcEMzfy+zWCwznldK5GBBkaGjcvoYH6E7giv0vXzyqLLafPncR3r6qWEQml0DwzmG7arPrHgTOcMyUGAx2ognLpCz2cdy/vdFvRwmWzVG4ZBiiLxgIznk8V2PcHVGaqyee8Ro66RZ0yFBilmKxG1IgsHwrI1mvHE3uaAGf+e7bJ8jOWTN1EF2+plhdL3Y19qnjge+LwaaxgmWWoTiaKB4xjNm1IyqPXd5jXQPZ2XlTyyybjyxfvlxN4nfvPllisGPHDrX6SLElqhhMKtfh6OY7nPkObgNVir88LyMpfLp3nhuaKN1JD7J1NQfgKQadcuSxM9yHz1iIr75tqXJFh7JgdMmqIuWavnD5DCePUYKd51zPW3YuWmLogqn7IBLtFpRb69BUt9/nc9S0DiiBbp3b9ZUCIJ1MtW0nS4zpMl84D8P8w02i6sZrUHECoXCow6rGUu1DnkveRkbHVQZTbopucl+WZ+nR6PJ6HQwCj9ECX3GGQQWRMzpBg/lMC7NOChslmUnquOxOKnVm0bC8t2gVTqBQlXq73i8XF6apJhvMZwsFzQ3JDtiBUJadgvOWFqjQZrqtQ8Zt3DE0PIQdJ3rwtzdP4GfP1aoFmkgFQPPa6+nzaj8bCNBt7gpz3rhIGowrNdZU5qWpqgrmTEabUccY3qrvwSkV2dMiBTZV5mB5cToe3tmkGqxMaaYUR90Q5/bMLUSY+cOLl5TOxQC3Nrnq+9n4Gl4GvEsL03D+sgJ85rxF6kYknEQbQLh3WuFgJ9T2urMJlnxdVJWinDlPHfBet86BBTvUcUXeH7wxMWvIvYsZJx6cgMQ7ytHkPpjxIPg8c7BdDSrXBtG1Mc9L5zkKOlwAnpZfFWWBmo7aVaUZeHp/G9oGLMqZRudbrKALrGfEFnRbXXb74cCSXUM1+H9uY5bPaTBAmOKfls0130hOTsaVV16J2267DXv37sVzzz2HP/3pT/jQhz4UmzekNzlzHTyUPGkD7kiKgu6d57QJVZopuHvBaVW5uOGCxXj3qeU4Z0k+lhVlqG50oZagnlGdpxYFZkvQr6tAzLEtRaOKJasmx0CjeSuxZzhH/c4buxr6lKjoqREAnSK8jjK/jZETvF67u0SF0CjPMqhOcN668XqDjz/W49znzf2ehZXuCac4HUsaC7IMaHB5PS7yxSqyoCRDr7KaNKFswOJQXfIqck7eH5jnR1qHMEUYbx0eU41QXOMCqgvSlVhQ1zEcsruHOYPBzAspbNNJ/sD2JiUYhETvcYy374PNYsbgiV34w7+fx0M7m1UHTrqceT77XAibgfjELrOexonsFsfLJxeLgoHH1c4TvWrs6m+RNJ5gsx6OS9h1MNrsbepTGcS8j7nDe9i71pciLcmAP7xyHD99thavHOkMWUyNFCI0eUBb/Y/noNw5i1ub3IiosdF4DQ/QvvyRMytVqdxMOl/MVbKSE5Fh0k1bwYvlYCfasPMLV8xfOdKFnQ29Hh+jDSxcS5H8lc95Eppmw/WNN/dpgxk3waex7gCOdgypXKNgJn90dHl0NA1Zleg37RyNgUB96apiVcbHUlvN5REruL04VvaUmcVJ6pSVVRfY/pztpV1X4zjIpNBOF5o2EG7q6MXCnNSYZFDFCzfddBNWrlyJD3/4w7j99ttxww034OKLL0a8caJnRGVuuXcNDCcUHZn/wckU4cSKpzdLfoXAoajGiQrP0f3N/UqwXrOwcHIMlPieu2GBUZW3eoLnNc9h9zw1jUUFqUpIpquJbibi3g1YCI3KHAMGrWOT8QGBwsW5IeuYGnM293sWAxis7UlooguKv6OTqNccu0W+wnSnmNE64LyvUADTxDcN5orxOtHSb54ijLMBimtUgDaW4GIU8wJDgSIqCUZo4vanKM3x1rMH20N6XY4z+jOWYnhMj76MpTh70ybcfOly/O+5i1CRm6K6D3tdCJuBC5u5nrzmUmRxh2MjbvtghSZ22O4csgWWoxtHcEzC/N9ICk0ODwt4FOZeP9qtDAreuv3yHvy5C6rxibMq1TH/zIF23PHEIfxzeyNsE2XisWbu2wRCYMeJXuSkGtQETYgBmuVvtr+GEPTFnOVz9b0nXSZc0eLK2ya3gPC5zOlVOWgftOFfO5uVG0kLg+YqBScDrx7pQmVuqt/wVg3efPa39CsnCoUYDiAoFswWoYlCi9XuOClUaIJP+z6MF67GM63JKMk0BOTwcs8uYVC6a07QZMc5TyVqmkAdxawEThLPXpyP5w91qAl2sGVD4UQb6FCccz92/r61QS3QfPq86im/4yrusa5hJQK6syg/FdvrWjH+wFdV+94zsRC9l/0e8xm6mr7//e+rf/HMia7hiOeF8ZwszDBNOpqGrXblZprPQmQosGRQcyewbI4Tpkw1eTSoMRDlI2bbHWgZUN1PPY2HibdSF16X6Ww73D6ozn2WHAd6bxJ8w/EQxYq6bltQgg8fT/FvRWGSV0dTz4gd6UmJqhGLxoJsw6SoU5Q+PtGEJTb7kuHjLNtrmRCa6HTPTtEh06RjMv7k40oyk9HqspDGcY5qIuDhWGb5HIUZ93t+IGiiSrBOcF7DeP+jS51VDa7O3oAwmPBI9XeRVtKIay48C+Uu444VxZl4+kCbc3zkMi6aXAibEJ/GJ8SnBH4f4LyHY0Tuf2+lgh7d5j6gYP2vXU2q1IsZjbMNLpbtaepTgn243Vj95lH8+JnDSnM4fVEuVpZkqvOe0Qkt/RZ8ZGWFfyEsP03943ama4yLA2abY7LLbyyJ/TuIM7RVn1MW5siARhBiUD7HgRFXXQlFJlUyNA9K51xvGuwiQYHob1tPqBr/375Uh28/XoN/bm9SN45p4ZI+7NHsPMfVSc0ZoA0gZoPQpA1ypgSCuzgS6875BY72OnDRysKgr9d0LbFE2t2J0+FNaIpR3Ts7C6rV2Bh1nNNgZiEdJcxccoX5E0c6htR5es/r9VNKcOq7htWx5ym0ngGbyUMNcLTuhWPUgiLzUVQmOtumC/EL9y8bWUSjPIoOBC0zjedpmnH+3AfCRXaqUzzgajxFX085ditKMtTExL28h07Y5w62qyyQVB/iEXOa+Px0KC6QsrmwQUcfXUYUjoKBj6doxDKz1sGT4ylX6FpydTMRhmznp+lVuR7zkUh+DN3kxRl6tA447/0MBq+YEMKmPCbThNZ+yxRHMj+vVlbnCrMBmTvkqWTeHxw3MSw9FJGBIfp0Hz24g508g3OZDFpGUdszigXLNk4bd/C85Wc90j7kuVIjuxLD2cvRN6rD4fGFuHOXHXe/dhyP7m7G63VdPksyTwprBu9u8wCFJr7OI7uaVTYtS71m42IBBUK+f4o/4eZEt3OcxL1x37ZG/ODpQ3jxUAdequ1UzmHXfEt/UOTnmPHjZ1VNLCjEHhGa3OAK9+jYuGpBLwhCdFmYY1A3zpaJVbjJjnPzpHTO1Zr8gdMWIAEJ+O+hDqQYdeoG/fVLluEz51VPXRXzY4/WBlxa+ZyW10GhJd7RGjJMG9AYTBjPX4ana/uVs2Kpn+57vhw6rkG5XBnkAMur0BQDKCx+9MwKvNO9hW2UoRvOUyC4NhiilX/AMor7tjVM5jjVtg9Nliy4w/02mFymygLsCUa0J1ejYOGyqH0eITQoLHJ+wolTpKEboGPAoiYqgxOOprAQ5tDcmL1GgBMPukNeru1SLheulrtDNyhFd5Yga3A1/O9bT6AwIwmXrvbekY7w+suJEkXB+RrmHykW5RpwrHtUubsDgY871jOKRblGFSbOkpy2QXtAQtNkTlOvXUUWMMpAdXiLodDE985jk2NCvjd3uCDH/CSWeRFNdHIvnSMcN7EiXgkzIZTOZSUbQ753MjKjZ3g06IYa+5r71QIP8xqnMGpBznAdStMSTpbPuS+EGUz495Lv4tGVP0P3pb9HZVGucsowB/SxPa3TIhXcPy/1IG+ZiV4btXiADU3omOQYNpLl1pHEWSquj0j5XEPPiKqi+tQ5i1QZHK+nXGBmqSGzmWajMOeKLA+5sf1ED5YUpMWNEigI84nidOegmOVzXJHjYIerehlJ808T5w35CxcuVgMDg69ML0+1+S72aK7AsZyBgwrWxncP2dTAZTaELmckG9Rgx9OAhjfhpl4zrt9SGdKNWHN0McRWc2dw2xAGicYTnHCHlRDbJVOc7B4+mWvFiSUHkGxVzPfITl5/fq0ej+9rxRVrS5RLgqtxnvYPj+nS/Bw8kXsHsm3N6NCVYJlx/pTIzlaYw8MyzmiIsa6d59h1joP9GaMJ81qJSSRyGqPxGgHCc48luO0DVqwty/ToyOD1jmIwz2WW91DYe3Bnk8p2un5L1fT7j9v1g8cCJ54U6aXjXHihYPTckWFVQkbhyB98HLvJUaAqSter7nV0ibv/Ld3iS/M9LABkGbCz2aw6/cZ6ga80wwCrfRz7Wq1KQGMpoTuTgeDMaVIZuxY1afd0nKsyz5xUHO0YVCVKwcBjW3MHhoJWcsfFmGCaeuxp7FeO4BRXN6fL9eXdqUvwe/MtcIyVqbGiK3yt/e1WXLZmE85YlDfFlXr7YwfV/dtbUyIKYhRWvOXJcvzIrnP+yhApWP17d4tyUq4qnT2d5tzhZ6zIjUxOU2OPebIUvTgzGVdtKMPbVxUpQTTYSIh4ZP7N3nzALADu8FMqcmL9VgRhXsIbJcMetc5zWhD4bFf0Q4WDJZ8iU4Ah1Vzd05ocaEHgs6FrEo8H5hJNKZ2bsGI/V9Ou8kaY9ROqU4iDJddSMK28MJ4cTWFnBgGhzLXSxDjycm2n2j8bJspx2NmHAtPrdd14an+b2p6eyuZcSxnq+hzYaytBaYG4iGcD7HhJ10o0rsmuneeY0cSJz4yJRvfIKHeoDFRUX+/Dqc8yHDaaoBvxtaPdyiVx7cby6SXWHq4fPBaWFaUj1RgdAXI+UZZlQJLemdMUCHwcH1+aaYBBl6DEpia3QHAKUQz9zvXgaKKYQ/PUkS6rykiKJXzv5I0TZrXgyIBwd3h88neak4kdWjlZ90Z1YZoq8fQUvuwLZpzNZHFOu3b1mwPvCNY7bFNulzXu3XRdri85g4eRMtzgUQDZUd+rXIzry7OnjSsZoq6VJXuCLnJfeVTcFnSa8VjyBsdp7JDH13vH2tg6ssNBRV6KcvSG3EHQAyyl5Nhcy2LVoLDIzLy50Dhq9n+CMLK9vlfdKHnDFAQhNtDJpLXYZU7AfMpnCqkkI4AuihSaGJjJSQRb1M+GfCbXnCYKF3989biq86e48VxNhxpYMmRzJhNeOiRchRMOvNi6dza13o3mJJid5yhU8jii+LersRdnVudNGQzR6n3GolxVUkct01fwJ0VCDlZZ9hDpcGlh5ozZzLA070dFVnTOD9fOcyqjKSkMLsxodI+MQYdKf2XCnOhS2PUGV87pYOJ5++T+Vpy9OE+JT4FeP3gtvv6s0NylgncoFFRkG3G0KzChiWV2C7ON6u9ISSa7stn9dpzT4MIezzlnEHhs74N0VbF8r2VgFAuynO4sd3i8lWQ5c5o4ZuSknd97Y1FemrrnaA6oQODz0tHkLRg7EAxjNix0nMDQcOBlewyfpljIAG1v1xdd8RrYMytwcKIbsQbv0VuP9yiRKtk4fT+y0Yy2sObNieQtn4loZYR9Zu/H5b4Om8qFY+e9uTCmYuklNabGMOY0tfZbVFxIuRdn2VxAZnBk1AJ7Vx321tuwvqJoTiiIgjCbA8FfPDqsBkOdw3asLp7HK6TuJU7eSjL8dFGk0MQSlK6+fqC9BnllSzBbuGx1MQ629qsAT97g2TmJA0UuCLATyEygcNLUY/bfcW4u4ak7TYDkpiapQRFLGSn+GXU6FRTsaZ/xMRygexrkunYMYhkWOwtKtkucM2qB7f4P4brGPTCa1wCL/xbxcjCt8xxXkXnOpyaFYbISje6RMehQ6YvzlhYoAdi9tMYVdjxi+dszB9tV/tbFK4uCun5wBX5KeY8QNhblGfBs7bC69moCkif4+/oeGy5YfPK+yJK5nU0WlaFF0cJVaPLkaOI5V56lV8JWPCzyMU5hwOLwWDanUZSZjNq2AZRmjKt7iS9HE0UobkOWAHsrG3OHrh1ef3wJLz6ZGLddd2IXhruXA4vvD+iawMxglrJOdtz1cH1JyK7E0oM9yo14xZriSaH3UNugugdvrvJcocPyvTqXTDZ3mCflq+GDFi/D1/C0vfnzrc1WXHrqAp8C92yiKMOkxit0j7HDWzho6BlR56Wn8Ppwxh7EkthfRWLNxAVgrGUv3plQgdwtf4/1OxIEzHdHE++VrMtnfT67oMxLPIlKfvKYvN2QOInQj1lh/Nf1uKJtHxwdK4E1982KG9WC3BT1T4PiBd0N4Vgho3DCDITxUTMSeuvRzcDRgjleOj2DSTCFOdLYO4K36nuUc8nTfmBZ5gdOW+izq432uEUFqegYsMokNd5R1579amU+pafG97UnjDA7SFutD0vpHPEjzM+a1wgQir2+BF/CCSpbwu840Yv3blrgXZSKMxFtvuQ0PeEYQkPvKKpyvbtqmvpG1YKS62NKM/Uq34ih2owl0IQmhnynGD0vqjOnySk0xd6FQkfW4U6rcml5ozTLhDeOdqEtkc4to1rA8AaNBGXZyUpoOrM6sPeguXZCDQPXxm28dqb3HQro2slyYbpdLlzu1mHYw/VlRXE63qjrVo/XQtC3He9Wn9ObmEZH09Zj3aqE0P1c58+Y7+SrdI4l8/wzrTudOxRjHOPjOH9pwewSSXy8R14jK/NSwprT1NAzovZZQAaXOMr+Cwax7kxcABxWM8ptdSi0t8ZVxxBBmG9wAMSVtO1NTqdJ4XwVmjyJSoGWZLjlaCQnjKJS1wFD5wHoONjpPxzz3JBQ4c2eQel+s6sCFE4cNjMc//gwxu+9Bhfu/xoK5q6D+STu3WkChANPDi6fPtCmJi9nVJ8MGPVEIGU0l68pUSHiQnwzmrkQraZqjOuTkFAUvXIwOppY0kXCUjoneOWi5YX40sVL/GfRhHj9EEJ39aQaE3HUT04Tu82ZDIkoydBPyTmikOCa08Qg8NxU7yLSxrJk5YpK8yJERZOqHKMqoSvL8j4OpKOGzeFru0eRatSrkltf0D17omfY70KIRu+wc9tlhRoGPjFuG9MnoTN1cUDXzj2Nfco9E0hr+8q8NLXfte5zLG+v7RjCZg9uY9dGC4yp8tQFz+lG5v3e4HORiM1avHWeY/MZNvGZFLhnkA0ZNQJ4j9zWFIeYrRTwc3Z41xLo0g84NiDOsv8CJfZXkViTXYnR/JWwwAB7/krnBWA2nBCCMIepyDagZ8ShLKVZyfP0MuVJVAogj8nbDSm5sBqNSYtgTzRirGDiWjfPYXZJjq0Z4237MTZqQZH5KErHJhYbhGlwwpJnGoe++zA2laeq1ukzhZPaYLrwCNGH4ad/easdfyu7Df1X3RfVlVROiDTCUjon+Jw8TivTEWIOBXu6lPwFgvP3VTmGKVlGLBOjUMXOcxocW3kqm9NgdtOFiz13C4021XlGfOOCfJj0iT5dj7qEBDQN2FUJkr/3zZKwAbPdqxvHk6OJ25EunpCYGLftPuv3eLDq276vnaMWjLcfxP6GdpWbFojThffl5UUZk87Pbcd7VM7W6jLvXd60iICOQYvHfCbiL5OK927VqMWDmMLuf/mux1g0RZJQjSIBvEcGgrMMlUJaQO/jAe9aAl1j7KgasNAUZ9l/gTJPrQIuGEx4fcOPsVe/C5945wXOHcgDNNDyFEEQIlI+t7XBjLxUnccAyHmBtxKFQEoyPORoFOcO4N7y25Ww8r/vulBWoyc61vQYSzGcvQwpvYfQaqpAacnSaOzd2cmoBVfXfRPp/YeQ6lgHrP6LHEfzQGS6d1sTGrqH8eEtS1EWpmyKYDvP8TaQKhlAwjwun/v3gUFY7GMeRRdOfllad8my6ecny+fqJzr5aqVzFTlzxx1IMYbCSUcX3U3+BXAtD7C+exjZATRGoZhCUWVGwpvBBH3RCvS1t6igbo9dfyeECUfrXrwdFUhae0/AT88sp12NfSpncseJHmxYkO1TNKZoRhcUA8FXeuiwR5jZ5ousZAOGhoaAB74ypZxrTJeEln4zFrgKTTPIhgyKmZSXBfAeWZZJEY8h574yrMhY9zHYW/bCMGZFggctoaHbGSoecBD4LC1bnvdCE62TbzWOYEH1epiSU6N7QgiC4DUQnMRDGGVMCTXnw8MNqTRrFPbEJIxkLj55rZvnsPwuNTUNby35KbItTXiqJRnfSJ8bwZURofe4cn0h0Q5j1wFZhJnjMFz4b282oLHXjA+fURG2ANRQOs/R3epxciYI84BFuQZVrny8ZxTLC6Y3rDjRO6rOVwpS7pRmGrCt0awCrQnDtX05mmYjzLk5oMro/E++GVpPYYolUOsXZPt9PF0n/kSXQGDJP8vVhm129X9fUS6lqEN6Yie9RwE99+LCNOW6emhnE4asDp9lc4SiWUG6SQlT097G8KjKw/MXT0DxbaR5uguoy1QJm30M+Rm66IskweSYuhPAe+Q9iEJlY3sPkN3t87O8NZiF9IQKVCUch8mDlsAmF9yGWrB6wO9xlhlf5vksjvWRZtXN6KoNpbNeNRSEuQKt2xwIlWfOnVW3qON2Q9JCInNS53hXtSDJSzOiwwwM6BciO9MSF+UCcUt2JYyla2QRZp44mZ46OgK7KQkf3VIZE5HJtfMcJy6CMF/heCgzWYe6LptHoYllc8wy8hTgTUcTM3cYCE7RltAtPpcomhCYAu3etTAnRQWCBwIdPrwGzRQtO4q5Rh6FpuxKjBeuhqV+F8w5y5GZWxXwc7Mpx6L8VBxuH0JVXmpA5egU2xg67k6f2XcQuAYFkm3jheo9K8fOhJjS3OosK5tSOhctkWSmRpEA3uOibD0Knv4sxnfUI8GLa2rYasfTh/owVvktVOk68cFLz0WC22ModJbneA+unyvMe6HpUNsAUow6VLhb4GahaigIcwVOLj53Vi58lOULQZKapFercrkBWMXnW04TAxkN+kTViUXwgSzCzBteONSJ1iEHvnz+wpiJTBorSjLUwF0Q5vOYqNpHTtOxHuYzGT0ulLChCt0uzGmiWKUt5s0l1pRmYH1R0mT2kD+YtbOjoReWUYffDrYUhpYWps/4PTI8mwxavFzLDCY0XPBLPPz8q7jqgi1BmxxWlGQqoWlzVWCdc7mt9jf3q8oe1+Omd9gWkIOLbhwLjBh6x++RPtI0acxo7utRsQRJevucHKNU6zuRPHIEDp0dei+uqWcOtqmA+nedWo3730rC8T4HqlzMaSyfbOo146IVXroKziHmvdB0uG1QpfqLJVsQ4gujTpwl4ebqDWXICFeL8DkCB0S7G/tUFlg4BpNzHlmEmRecUpEN40AqKvNiX2Z7zpLAykcEYS7DsrgdTWYMWceUe0mDuU1NfXZsXJnsNSy6KEOvOs+xvC5JnxAXHeXCCR1Cm0v9B4FrLMhJVS4vukqW+Ljv09lJYSg71I5zLqQZ9apr64CXTm2kw5yAzuQqlOb5L+lzZ215pnJ+rizxHgLuHqLOckoGo7uWbzH8PBCnjRYW3j+qQ7qL0NLSZ0apctAH5hibbWOU4srlaMxchoSBQ0jOXYEkDyVxb9X34vI1xVhTlonna9qx9XjPlAWbtgGLylULOAh8FjOvZxxUqVv6LThLBjHCfGHMDoxPlCA4xpEwZgMcXCGboaiTkAgkzuvLyaygukDyhzw5mrTsikBXQwVhdl3zHUH/Wa5pHDlJDsDBDA8PK/4JOrnmC0IUqcp1igF0Na0tMU2KTK8cG1H5TdrvPVGWacCxbptawKObab6XiLNkPi1Jp8rnfAlNnCeSzOSZO8FpaEgz6THgzdHEoPYhm3IKBdJtzh2Gf29ZnBfw47XxTueQZVJootOG3fgCKp2bcGjx8WUTuhj/nh3nzl2SBwxjTpJgSEbB9ffhn8+8jC5jCT45poc2sqY77LE9raqJxWmVueo821yViyf2tWLQcrJkkscdRUct0mIuM69nhrXtg6qTCR1NgjAvJhxDRycmDvx+HMlWMzCYDHXFmwm6JCCtOiwTj3de9zk8+vc7g/qb+x56Un1939WXzOi1H37sOWzbsQ/fu+2LU37e1NKOD33qZrzw7z8G/ZxLT70Ch996bEbvS4jsgNN1hU8Q5tQ1v/8g4DCH8LdjSLbWAn1qhjT997pkIHNFeK7573wnHn300aD+5r777lNf3/e+983otR9++GFs27YN3/ve96b8vKmpCR/60IfwwgsvBP2cS5cuxeHDh2f0vgTBnUyTTjVIodBEsYgB33tbLOA6ySnlyT4Dvssy9djaMAKjPgG5KfN66qegAEA3yYlu32pIX4Ad2AIlw2Tw6WjqGbZFLd4gJ8WoSirZea66wCm2DVhGVWC55lbyRapRp5o0aGIc6RqyqoW7kiwTBueo0ETYUOeKCy/Ar/57FPe+eQLXb6lU4uDOhl7lkvvk2VWTlVIbFmTj6QNt2F7fi/OWFaifNfaOKJHJX+D6XGBeX20OtQ2qCw07EAjCnIdOJopMaiXaACSMYyxxHNCZZiY0jY06n1dzSs2QYEWmcAhMwvyF7Y254JAwUUYnCHMGOpkoMiUYgMQgj+0EB8YSTYAuBUh0m8AqJ6x5wik18/FTsCJTOAQmQZit5XNvNozgrUYzspJ1OGdRKjaWmZQI5Qt2nmOpWFPfKBZVyX2OsD39C4c6lAvHW3wK3Toka8K9E46cJoo53ugZtkbN5cLPnJtmnNJ5jh32SHYAwhrFOrqaXIWm5j7nokZJZjION2POjx0/eFoFfv/KMTy8qxlXrCnBU/vbsK48c0rJebJRh7VlWdhW36PKwLndmQu6eJ5ENcxbhcXuGENdxxDOWSq1/0IUYcvNWHczTNQmHeMYT7A7/z9TR5PDf2nG1h378Ms/3K9U//rGFpx1+kYU5ufiuZfexJhjDL/7+a0oyMuZdADt3ncI3/7R75QVNSnJiG9/4wZULCjB7T/4DXbtrYEuMRHnn70ZN3zyOvzid39Xr8H/n37xB3DF28/B9t0HMWobxR23fgGrllej7ngjvn77z2C12bC0ukK9n5cfv3va+2xobsMHPvl19PYN4NyzNuHLn/3wlN93dffiG9++Ey1tXeqzfPHTH8LZZ2zEwOAQvvntX6C27gQMBoP6u3POPGXy7/YdPIIbv/FD3PXDm7G0smRm21sIG1xR4mDJkJgQkl1dEOIeXuN1wQtN4xSo+HfuQhNxeJ8saWzduhW//OUvodfrUV9fj7POOguFhYV47rnnMDY2ht/97ncoKCiYdADt3r0b3/72tyeu+Unq/xUVFbj99tuxa9cu6HQ6nH/++bjhhhvwi1/8Qr0G/3/66afjiiuuwPbt2zE6Ooo77rgDq1atQl1dHb7+9a/DarWq1+D7efnll6e9z4aGBnzgAx9Ab28vzj33XHz5y1+e8vuuri584xvfQEtLi/osX/ziF3H22WdjYGAA3/zmN1FbW+u85n/5yzjnnHMm/27fvn248cYbcdddd6nXF4SZsmlBMqyOcawpSsLifKPKFgwEdqOj+4S5MHMtCDxU2Kae7puW7l6Ujbd7HJdTaEo36cM2NmBGZn2X5+wiXvfYBX1VaWAZS+GgIN2EjgFXoUlzcAV2v/AkNNGRRXFlPrAgNwXXbCzD/W81qnBvnl9vX1U87XGbq3Kw/UQvDrcPquOua8iGC5bP/XwmMm9H1fXdw+oCs6xofiiKQpyITA98BLj3GudXfj/P2HegFt/+5g14/B+/xL+feBE52Rl4+C8/xfIllXjy2VenPPb3f3kIn77+vXjoLz/FB669HHv2H0bt0RPqOf7991/g/j/+EPUNLTBbpm7Hnt5+bFy3Qj3v1e+4EL/98z/Vz79y60/wPx+5Rv0tBar2jm6P77GhqQ13fv8m/Oven2PnnoN4/uWtU37/fz/6LU7dsBqP3fcL3Pm9m3Dz/92pxKc7f3svigrz8NSDv8FdP7gJP/7lPWrgQA4frcdXbvmxU2SqrgjzVhVmSlGGCUWZc79WXhCiDcUWCkaPP/44/v3vfyMnJ0eVqy1fvhxPPuksedb4/e9/j09/+tN46KGHlPCzZ88eJeLwOfi3999/vxKszOappYA9PT3YuHGjet6rr74av/3tb9XPv/KVr+B//ud/1N9SoGpvb/f4Hik03XnnnfjXv/6FnTt34vnnn5/y+//7v//Dqaeeiscee0w97uabb1biE/9fVFSEp556SolJP/7xj09e8w8fVq8vIpMQTorS9bh2TQaWFiQFLDIRPrYkw+ktyE2dHyKAP+gcMsGG5Ec+7nVcTuElXGVz/hxN5lEHLKNjyE2NXgk/c5o6h6xTSgWZXWUMsOUzP4/m+iLNvWaUZs+vsdTa8ixcuLxAOcPOX1YwmV3lSll2Csqyk7H1WLcqrSPzIQh8XgtNLJvjwcAJhiBEBTqZ2AqTNzKtJeY8gyJLSVEBkk0mZGdl4PRT16qflxQXKEeQK+eftRnf/M4vlHvIaNTjHZeciwXlxbDZRvH+T34d99z3KL746Q+q53Ln3DNPVV+XLalC38AQ+voH0dTchgvPPV39/JILtyAj3XM3pfO2nIqc7EwYDQb1OGY2ufLmW3vx7isvVv8vLyvC2lVLsGd/LbZu34erLr9Q/XxheYkStLTAzY995v9h08bVIjLFKVyRunK9uMzCCq9zHTXzUlAXTkInT0lJCZKTk5Gdna3cR4Q/oyPIFYpBdAjRPWQ0GvGOd7wDCxYsgM1mw/vf/37cc889yk3E53KHTiSybNky9PX1qX/MWbrwQuc1+ZJLLkFGRobHXXPeeecpAYyvyccxs8mVN998E+9+97vV/8vLy7F27VolgtEhddVVV6mfL1y4UAlak9f8j30MmzZtEieTEDewfI7kiaNp0s28zNQNU/dBr+NyunUCCcYOJqNpxOZQ3ew8BYGTHJfcyEjDXEp21TOPDKv7df/AUMBuJq2kUHM0sQSxtd8y0XFufkGB6X/OrsKWau9h7KdV5aC2Ywh7GvuUmBdIeeJcYN4KTYfbBpWbab53XhCiCG25haud1lx+dWuJOR8wGKZW67IUwht0Iz14z4+xclk17v77o7j1jl8hJdmER+69E5++/j2qtO29H/sKjp+YXgjOUjuizu/xceh0iZMrzf5IdLFI809YKuGK+/Pwe7vD7vwsLpeTY/VNsNudJYU//s5X8MrrO7D3QG1A70GILqlJesnqCyfi3hQmYElZwNf8q6/Ggw8+iJUrV+Luu+/GrbfeipSUFDzyyCPK6cTStve+9704fnz6Ig1L7Yg2puPrBHzNdwk7598EdM23T1zzXTh27Jj6OaG76ZVXXsHevXtn97EggvGcYXlBEkoyDMgwzdup3zSySpag2bQI417G5crRFKZ8JpKZ7Ly2UNzxFAROohUGrjma9GNWjE9UW2zY9gXkJAWet0rDhgoQHxt3CQKff0IT7zsVeales77I6tIsmPQ67G7sR3lOyrzRH+bl1Yb2NtZHLpWyOSGa8EZ27d3A+x90fo1VRtMs4ROfv02JSNddcyk+/6kP4ODhOmzffUD9/LRT1uBrX7geiyrLPQpN7qSnpaJiQanKgyIvvLwNA15aYrzyxg61qmO12vD4My/jjE1O15UGX/ufjzyj/t/Y1IYduw9i3epl2LRxFZ545pWTXer+9xtMwZr8m69/8Xp849u/wOjEREQQ5izi3hRC4BOf+IQSka677jp8/vOfx8GDB1XuEn9+2mmn4Wtf+xoWLVrkUWhyJz09XeU7MQ+KsHucu4NKg4JQf3+/ynJiid8ZZ5wx5fd87X/+01mC3djYiB07dmDdunXKsfTEE09M6VKniVL8G+ZD0Z3F3KhZiQjGc4rqPCNu2JIzbya4gVBekIO/lt2OgavumzYu57lMt05mOEvnJtrbe+o8R6EpxaiDyRC90sa8tCTkjjZD17Ffne/ZA7UoG28L+O/pfuIlj8KZFgQ+Hx1NgWDUJ2Ljwmz1fwpN8wX9fHUzsaVjVb7n0hlBiBi8iRUsj+0GZpc49XUcCeOjzg5CrlacUJ8vzHz2E+/D7d//NX70i7vVCvPXv3A9Nq5dgaqKMlz+3s/ClGTEimWLVBD3gUNH/T7f92/7oirDu+t396lMKG+lc4sqyvGpG7+lxKbLLj4bW07boIQjjW98+ZO45bt34dHHnW2v/+/mz6pQcwaR3/LdX+Id192ABCTg+7d9AQaXlfG3nX8mHn7sOfzu7gfxmY86yy0EYU67N1mKME/dm3GFusYH+zcO5/3BYQPGPXSdiwCf/exnVfD3j370I+c1/+tfV9lLVVVVuPzyy2EymbBixQoVxH3gwAG/z/f9739fCT3MSWImlLfSOYpXn/rUp5TYdNlll2HLli1KONLgc9xyyy2T3fGY2cRQcwaR8+cs8ePkna/n6uB629vepnKjGHr+mc98BnNCMI71+EUQwhzmbE9MwrGEMqx3W/wdsNjBCrdwls6la0KTh5wmBoFHu/MtxQ9HZgX6BpaiYOQImvULYcivDvjvtfyqPrNtShC4I4AGQfORzVU52Ha8G9X5aZgvJIwH6i0OAj7l9ddfrwYGWv26OyMjI6ipqVE3f1qjIwEPdHYx4cqTq8X5D68cgy4xAR89Uwa/0cTb/hA8bSwr0Lsb0KUG3y3IG2N2YOio87n5EmPjqG02Y0lpsjofZoQuCUirBhLjV7tmx7urLr8AxUX5OFR7XIlODBqPCZy8OYaB7HXObSfnR9wh16v46rAZ7v0RjTFIpAj4vfOa338QcEwNzw4Ex9iYCuJesmSJ6vA5DV0ykLkivq/5v/ylGoMWFxfj0KFDSjBi0PhsJCbXI83RpAnGs8WJHYnxk/tLOMax+9gQ1lWlQacTh9BsHj/95JnDWFSQhneuK53y84buEfz6pTp87oJqFIepWQjnx7f9+wAuWlGELYun5vn87uU65Xh676YFiCZ3v3Yc+nEb3rnAhh9ss+K6M5dgebFnUd4dy6gDtz92EO/bVI436rpVOPj7Ni2Q8ZMPHGPjM59zxfgeEsz4KewjBLas/c53voPXXntNCU3xBk8Kdpy7dPX09oOCMKfhhIBi0PhE/bVjHOakIdaVATMdKCUkxvWEg5SWFKiyO66UJycn4Tvf/Fys35IgzF3iwb053+E1mWLQeAiryw4HzJzDZa1l4NH03yfoonfND1G0LC0tVWV3zmt+shqbCiGU+4dRMBaEeGNBbipOdDs7gbnnM5Gs5PCJlXQ+UowZ9OJoqsiNfqVNfroJNa029KRWwZ54LChXFcv8kvSJ6B0ZVUHggQpU8xldDESmWBLWUQJbx375y19WlmNvFuVYc7RjSFkhlxXF5/sThIgyZWIwjvFEo3PFbx6syF156fnqnyAIwvy65ocy1HNM3B+SPAtN0WIGrporr7xS/RNmgAjGwhynIjcFOxt60T1kRW6a0yFF+syjSkRhKVg4oWtJ69SmwS50A2Y7cqPYcc41EPy1OpvKL9YCvoOBj+fcer4GgQtRDANnzTwtyrQmM4gxXvOZeFJFuw5WEARBEARBCAIJlhcEIVwdEz38bFVppmo1f/9bjbDTiTBB34gtrPlMGukm/bSuc70THedyUk8KXdGiID1JBXpTLAoljJw5Tcc6h9T/JQhciKij6fzzz1f/gq0ZjFRomPa82lfWxh5qG8DaskwJKosB7vtD8LmxAN7vEhihNh6Zlxgbn/JViCLc5ty/6lyYel7I+REfyP6Y2/tDzrNZggTLC4IQDick8eCOpLDy3lMX4Dcv1eG5mna8fZUzWqVvZHQy7Dqc0AGkdWhzLZsjsTBBFGQ4xa0jHUNKcAvl83BIqwWBC0LIQpPFYlHlcZ7Iz88PKVCTYZORZt++fepr25AdTU29OAP92GNdgPEIhQQKge0PIZDTkzcfW2T3R/2w7IqYoAcaa6b9VM6P+EL2R3wh+2OeITlBgiCEywnppYsi281fvLIIT+1vw6L8NCwuTFcZTZV54c9MYue5AfOoMj8ws4n0DNtg0CUgwxT9rNMUox6pRh2GbY6QPq9WaleaLWVzwnSCOqL37NmDD33oQ167e1x44YUIFnY0iWTXOQ5KV69erRLWH9pahxvN30L14XqgfxXGrv4ToJdww2jhvj8EXxvLCvTtA3QpAHMyIrE/xsaVyLS6InXehdPFHLYHd4wAWaundE2R8yN+kP0xt/cHu6ZEY6FrzhPm7oIekZwgQRDC4YT09LMJzl6ch7qOITywowk3nF894WgK//g7I1kPm2McltGxSQcQHU0s09OEp1i4mo53jYRUKqi5vqRsTpix0LR582YcPnwY4YQDxkiLDnz+kdExtJ2oQbntGBLoEGnfD11/g3TFiQHR2OezH3b0YYpaQsSDuikyRaM97+DQML5220/xqx99E9GgsbkNv/7TP/Hd/+e7u9wHP3Uz/vqb7yK6JDgrInkeuJ0Lcn7EF7I/5ub+kHtQ5IO6BwcH8bWvfQ2/+tWvEA0aGxvx61//Gt/9ru/r+Qc/+EH89a9/jcp7EgQhjpyQProoUuS59pQy3Pn8Efx9a4MKt84KMhg70DBwws5zmtDUo4LIY1dlw+xip9AUSumc831LELgQ8TDweGZ7fS/6TGUwlK5xXlw8qNmCIESO/oEhHKqdsC9HgZa2TjQ2tfp93LYdUsopCIIQ7qDu/v5+HDp0KGobtqWlRYlN/ti2bVtU3o8gCDFEc0K6CkqefuZW1vbuU8pR3z2ivo9EGHjGhHg1YDnZeY6lc7FsUlWQ7tweoTi42LXvirXFqIpAmaEw+4l+MWgMGBsbx5vHu7G6ohC6VfdE3uYtCMI0vvWD36CjswefuvH/8M0vfxLX33ALcnOy1CrS1VdcqASf7932RfXYr9/2U2zauBpXXXEhHn3iRdxz36NwOMZQXbUAt9/0aaSlTi23vev39+HpF16HXpeI1SsW41s3fxbf+v6vldh0yx2/xC1f+RRu+96vUFt3At09fahYUIK7fngzfvDzP6u/v+pDX8TDf/kpXn1zJ37267+pMp3C/FzcfvNn1FdBEAQhuKDub33rW+jo6MCnPvUpfPOb38T111+P3Nxc5zX/6quV4PO9733Pec3/+texadMmXHXVVXj00Udxzz33qOtwdXU1br/9dqSlpU295t91F55++mno9XpVTsnX4j+KTbfccov6d9ttt6nyyO7ublRUVKi/+cEPfuC85l91FR5++GG8+uqr+NnPfua85hcWqtfiV0EQ5ifMZ2IZ3StHu5CdaohI1znSb7ZPzlF7RmIrNBVOBIKH8h447j5jUV4E3pUwF5gXjqaDrQMYMNtxWlWuXzVbEITIcMtXP4WC/Bz85if/T31f39CCO275PO79nXOi4Ym64424/+En8ffffx+P/v1OVFeV45e/v29aSd7fH3wCj/ztZ3joLz9FQmIiWikwfe1/sWp5Nb5102ewa28NEnWJ+Oeff4TnHvk9bKN2vPz6Dtz6tf9Vz0GRqaevHz+882784c7b8a+//RyXXnw2vvOj38nhIAiC4Ks85f0PTiubU9f8W25BQUEBfvOb3ziv+fX1uOOOO3Dvvfd6v+bX1eH+++/H3//+dyU4UWhiBuiUa/7goPr9I488goceekgJV62trer1Vq1apQSnXbt2ITExEf/85z/x3HPPwWaz4eWXX8att97qvOY//DB6enrwwx/+EH/4wx/wr3/9C5deeim+853vyL4WhHnO21YW4fMXLFYOp3Bj0CUixaibdDTxq2OMXducYk8sYAD6R8+smBSchAgyagE6apxf5wERczS98MILiBfePN6jrH3FmZKIL8xvekYcMI+OTa6idI440DIwisQZhoEnGxKRkxJcbkpOdiYWlpf4fMwbb+3BicZWvOdjX1Hf2+12lJcWTXlMeloqFlWW45oP34jzztqED1x7GYqL8tHQ3Db5mFM3rEJWZjru/efjOHaiCfUNzRgZmXqR37PvMFraOvDh//2G+n5sfByJMQpmFISoBy4LcxKWZJhHHUH/3ZjD4bw/9JmR6CETK9mgc65+BxHUnZOTg4ULF/p8zBtvvIETJ07gPe95z8lrfnn5/2/vPsCbqt4/gH/pbqGFWnZBRqXMQgERylLKhrLhr6wCoqKALJlF2eJPwLJlyJAliCwZIqIMEVla2RtayiwIhVK62/yf99TGFgq0mHGbfD/PE5Lc3OTe3ENuTt+85z0Z1nF1dYWXlxc6duyIBg0aoFu3bihSpAjCw8P169SoUQP58uVTQa3Lly+rIJcUgH98ghvJgOrRo0fqe05JUcEpIrJu0icu5Ga871q3f2aeSysELsyZ0STBeu9CrmbbvtVIfHZdQ0tk8UPn7sUmI/TvR+hS89mdGyJL9yghBdP2/g2dFKEG1PXdh4nYcy0e/zWeIgGZoIb5kdsh6510ZyfHDF9y/+yWkpiUmlIsw+VaNK6Lj4f2UfdjYuOQkPDvuPY0y+d9ipDjZ7Dv9xD0HjAW0yZ8lOHxX/Yewoz5K9Gzcxu0b9UQkfej1NSy6SWnpKC6b0V9xlVCYiKioqKz/H6IjMIKOyZkGI/ikzDtp3P6c3526HQpuHs3GntuX0KuXE+e1+W3iaAW5ZHbMevdSGdn54zn/HQ7lpiYel6XIWySWSRD7YQEhyQb6XHLly9HSEgI9u3bp4bkTZs2LcPjv/zyixoS17NnTzVMLjIy8slzfnIyqlevrs+4ku1ERUVl+f0QEb3ozHNRcUn6HwOkD/4ihbitXk77ES4yk7qGWfyhJqey+EDTydsJcHXKgwpF3My9K0RmJUGgoa/nz5DRdCo8BhVfdjFIRtPzgkx2trZISs78l3X3fG44fzFM/aIsQaDDISdRp2ZV1KzugyUrN+L9Xv+H/B7u+Cx4EZydHRE05F39c6/diMAHH03Cd0unoXqVCoi4cxfnLoahfNnS+u0dOHIULZvUQ4fWjdTjR/46Cb/XqqjHbG1tkJSUjCoVy+LjSbMReuU6SpXwxOIVG3DyzEXMnZqa4URkFlbYMbFmEgyRwElAQIAKkPwXEgQa2qTsC2c0nTodj4oVvJ6a0fS8IJPUT5KMpMy4u7ur+knqnB8Zqeo11alTR81uvGTJElXXKX/+/GqonQSogoKC9M+9du0aPvjgA3z33XcqUBQREaFmRC5fvrx+e5IZ1bJlS1ULSh4/cuQI/Pz89DMOynpVqlRRAa3Q0FCUKlUKixcvxsmTJ58YqkdEZOiMpltRqVn1d6MTkNfZXtU6Igv/Ec792XUNLTHYZtGBprjEZFy4l4h2fu78ABNJaq4a3pb6R0Nysg63XWxR1M0etrbGHyJWIL87PIsURJd3R2DK+CEZHqtd0xcbt/2Cph3eR7GihVCzemW1vJx3KfR/rzN69ftE/UEiQ+RGDu6d4bmyvmQ9tes+SGVJFS1cEO0CGqrgUXR0DIaMnoo+vTph6MfT8OPP++HgYI+qPuVw7Z+hdY0b+KF1lw+xblkwJn8yEIODpqhfuqVQ+ZQJGfeTyCI6JqRJco6TGkH79+9XgSZDeNHhGHIOVN8P+ZxVYOZFFChQAJ6enujSpYu+CHea2rVrq7pITZs2RbFixVSASZQrVw79+/dHr169Us/5Xl6qUHh6sr5kPbVr104FoYoWLapuS/AoOjoaQ4YMQZ8+fTB06FD8+OOPcHBwQNWqVVWASjRu3BitW7fGunXrMHnyZAwePDj1nO/h8cR+EhEZY+a587cf6jOaPMw4bC7Hyok/wtn/U9fQUIGhHBBss+hAU0j4fSSl6FCjpLu5d4XI6skfK6sX/duJ37V5sf62g709Zn6W8Y+JNJ3aNFGXZ/ng7TfV5XFb1szJ9HZ66bfrX/81dSGy2I4JaZJk3UhgRIIhbm5ulnPOX70609qdEvyZOXNmps/r1KmTujyLZDTJ5XFbtmzJ9HZ66bfr7++vLkREpuLmZIfouKTUGecexauAPlnJj3D2Wa9raAnBNhtLTj8/FHoPpd3tjTJrABERkUlwtlSLd+rUKVXQWmZRk2LXRERkuRlNKTogOiFJFQM3ZyFwS5311KqCbfZOmg22WWxGk9QkkCkjaxbkh5eIiIi060Uya2S4l1yMIe11jfX6lD1sj2wdLEBKUeaS4u8642xCogTprsmE5JhL+6pzU3KOPF/ltrdREy7ciIxBbEIS8jnb5Zh9zwqTtYeNPeDhnbZRWB0be6DDYuBeKPBSqdT7TzkOhmyT7LyGxQaaXBzsMLp5OZw8cdzcu0JERERWLC4uTg2Pe1otIxcXl2y/phTTNrYTJ04YfRuUdWyP7Px5I7MVPjljoSGdCHtk1Nenp7EDrp7JsZ+PmESZ1fMhdh+Jxt278bh1JR7Jd16sFp6W5ZT2sAg3zmqyTSw20CRYwZ+IiIjM7dixYwgMDMz0MZnlrFGjRtl+TW9v7xcKUGX1F0vpkPr4+LxwMXBie5hFcjxw/wRg6wLYGGdUg2QySZDJp2Ru2P7HWXspm1ISgOQYIJ8PYOuYI89XUptp+43TyOXmAo/ER6hXozyc7LW/31mV09rDGiQbsE1iYmKy/EOXRQeaiIiIiMxNZlU7d+6cQV9TOovG7sSbYhuUdWyPLB2l1Aq0EgAy8oy6EmQyxay9lF6u1BGRcl567NyUUz4fsotuzg64fj8OuR3tkdvJMsu85JT2sCa2BmiT7DzfYouBExEREREREWmJq5Odmhnd5IXAZYay22dSr4mMjIEmIiIiIiIiIhPI65w6I7qHKQNNElz6riewqmPqNYNNZGQMNBGRWV27EQH/1r011Qpa3CciIktw7dq1bM+wZ437RESWndEkTJrRFBkKRJxIDTDJtdwnMiLWaCIiIiLSiF27dpl7F4iIyIjc0jKa8pgw0OReCijkkxpkkmu5T2REDDSRZZEovUTo5eRp72Tuvcm5kmTWlmtAvmKAXeqsHoYyf+labN6+B7Y2NqhTsyq6dGqB+PgEDBr1OS5fuYbinoUx+ZOByOuWB3O+Wo0du35XM0j6VCiDCUH91cwJ0+Ysw8Ejx5CUnIJmDeug3ztv4dCfJzBl5hJVI7Jk8aI4HHIS65cHo1ABD8TExqFR23exc+NChF65jsnBXyE2Ng6urnkwdsT78CpZHKfPXcLoibPUPpYrwy9fIrIiRvzunD9/PjZv3qwKiNapUwddunRBfHw8Bg0ahMuXL6N48eKYPHky8ubNizlz5mDHjh2ws7NTs+NMmDAh9Zw/bRoOHjyIpKQkNGvWDP369cOhQ4cwZcoU6HQ6lCxZEocPH8b69etRqFAhNSuOzOS3c+dOhIaGqtePjY2Fq6srxo4dCy8vL5w+fRqjR49W+1iuXDmDvmciomdxc0oNNL2U27B97GeSc3unr/l3EpkMh86R5eDYY8MFmbaOAjYOSr2W+wayd/8f+HnPQRUA2rhyJq5cu4l9v4fgbuQDdPu/AGz+ZjZKFC+KuYtW42H0I3yz7gdsWjkD65dPRy4bG9y8dQfrvt+JxMQkbFgxAxtWTMfRE2exe99h9fqh4dexdM5EBH86DC0a18X2nb+p5bLNOjV94eBgj6CJMzFl/BC1/YHvd8WwMcFqnRFjp2NIvx5qeTHPwgZ7z0RE1vrduXfvXvz8888qALRx40ZcuXIF+/btw927d9GtWzcVgCpRogTmzp2Lhw8f4ptvvsGmTZvU+rly5cLNmzexbt06JCYmYsOGDepy9OhR7N69W72+BJGWLl2K4OBgtGjRAtu3b1fLZZsS1HJwcEBQUJAKSMn2Bw4ciGHDhql1RowYgSFDhqjlxYoVM9h7JiJ6nqL5nOBsb4tCbiYMNKUFmwqW54/xZBLMaCLLkdnYYzmZUvZIJtOdC0ByfOq13M/vZZCjKFlIAU1fh7NT6i/mHVo3wqatu1CieBG8WrWiWta6+RsYOW4GXPPkhlep4ujYYwga1HsN3Tq1RJHCBbD/0F84fe4yjoScVOvHxsXh/MUr8K1cDqVLFFOZUKJtS3+M+9889OzSBlt37EXgW60QGnYd4Vdvot/QT/X7dO/+A9y9dx8Rd+6inl81tax9QEOs37yT/3OIyDq/Oz28DfLSkoUUEBAAZ2dndb9Dhw4qkCTBpVdffVUta926NUaOHKmyjSTTqGPHjmjQoIEKRBUpUgT79+9X2UdHjhxR60tm0vnz5+Hr64vSpUurTCjRtm1bjBs3Dj179sTWrVsRGBioAlHh4eEqAyrNvXv3VKArIiIC9erVU8vat2+vgltERKZQJK8zxrSqwINNFo2BJrIcHHtsGDJcrkCZ1CCTXMt9A0nRycC2dHQ6NRTCxiZdcqUOsLOzVTeXz/sUIcfPqKyn3gPGYtqEj5CckoLhA3qhiX9ttU7k/Sg4OTng+KkLcHb695ehCmW9EBsXj5NnLuLi5XD41aiCC5fCUbxYEXz/TeoQORlyEXH7rtq+3E4jwzaIiKyCEb87U1JSnlj2xDk/3Tl3+fLlCAkJUVlPvXv3VkPmZOjc8OHD0aRJE7VOZGQknJyccPz4cX0AS1SoUEEFoU6ePImLFy/Cz88PFy5cUEPzvv/++3/P+RERPOcTEREZGYfOkeVIG3vcdV3qNWs0vRipyRTwGdBuRuq1AWs01Xq1ssoukiykpKRkrN/yC2pUq4Sw8BsqICTWbd6J2q/5qpnfWncZgIplvTDog26qntO5i2HqNdZu2oHEpCT1Oj37foz9h45mur02LRpgzOQ5aNqwjqoPUrpkMTyIeqjPhtry4168P2Qi3PO5wbNIIfy896Bavu2nXw32nomIrPW7s1atWiq7SAJAEmCSrKEaNWogLCxMBYSEDI2rXbu2mvlNspsqVqyo6jfJ0Ldz586p11i7dq0aPievIxlLkuWUmTZt2mDMmDFo2rRp6jm/dGk8ePBAnw21ZcsWvP/++3B3d4enp6caYie2bdtmsPdMRDmcZHfePmPQYcRE1og/25NlSRt7TP+NBJcMNFwuPRkCd+Z8KDoGDlGFvGu/VgUNX6+lAkcLlq5VAacyXiUwuG935HZxVnWW2nUfpDKVihYuiHYBDeHo6IArV2+iXdeBSExKRssm9dDo9VqqGPjjWjV7HcFzl2HymIHqvtRomvnZSFUMPC4+AS7Ojpg28SP12NQJQzBqwkzMWbgavj5lDf7e6QWxwD9Rjv3ulCFwZ86cUcPhJNAkAaWGDRuqwNGCBQtUwKlMmTIYPHgwcufOreostWvXTmUqFS1aVN12dHRUtZ3ktgSbWrZsqQp9SzHwx7Vq1UrVa5Li30JqNM2cOVPdj4uLg4uLi8qSElOnTsWoUaNUAXIZhkdEpK9Zl5bhyR+uiV5YLl368SImJDOCSOejfPny6ovfGCTdWopGSgdCftki82J7ZOdgxQORRwHb3ICtcaY+TU7W4ejlaPiWzgNb21xG2QY97eAnAMmPAHdfwDY1Y4yfD211+Nge2mLo9jBFH8RY2H+yPjwfZedgsf9k0Yzdf5JMJpkYQfof0t+QTE/+gJ29JuLf3xbdJjHZ6D9x6BwREeWcIsVERERExqxZJ0EmA9esI7I2HDpHRETaxAL/REREZOqadfLDlvRBjJVFzbIAZAUYaCIiIuvu8BERERGl9T2MOVyOdaDISnDoHBERab/DxyATERER5XQsC0BWghlNZnQg+ADio+Lh6OYIvyF+yKks5X0QkenwvMHjTEREZHVYFoCsBANNZv5D6+H1h3D1dM3RARpLeR9EZDo8b/A4ExERWR2WBSArwUATERERERERkSXUgSLSANZoIqInHJhzFns+O6GutaT7+0H62226DHjmuhu2/IyR46a/0HZWr9+uLtn1vH0iItJqhuGecXvUtZZ0795df7tNmzbPXHfDhg0YOXLkC21n9erV6pJdz9snIiIia8WMJiJ6woG5Z/HwRixcizrDr385zRyhw3+e0N/+/ptZRttO5w7NX+h5xtwnIiJrG8p6+PBh/e3vv//eaNvp3LnzCz3PmPtERESUkzHQREQmcejPE5g5fyWcHB1w49YdVCznhcmfDISjowNWrt2KTdt2IS4uXq0b/OlweL9SAv6te8OnYhmcPR+K6r4V1WPtAwdjw/LpKFujFc4d2YKI23cRNHEWHkY/wu07d9G8cT2MGPj2U/eje59RKF+2NA4cOY7Y2DgM/bAn1m/eiQuXriDwrdZ4u1s7zF74jVq33ztvYfyU+fjr+BnY2tjAv35NfPheFxw9cRaTpi2ETqdT+z9p9IcoXbKYfp/k+bJf4ddv4fqNCLxe51WMGf6+ek05Btt27IVrHmd4eVdE8ZdL4sMPPzRJGxARmcqhQ4cwc+ZMODk54caNG6hYsSImT54MR0dHrFy5Eps2bUJcXJxaNzg4GN7e3vD394ePjw/Onj2L6tWrq8fat2+vspXKli2Lc+fOISIiAkFBQXj48CFu376N5s2bY8SIEc/MiipfvjwOHDiA2NhYDB06FOvXr8eFCxcQGBiIt99+G7Nnz1br9uvXD+PHj8dff/0FW1tbtT9yfj569CgmTZr0zznfUd0uXbq0fp/k+bJf4eHhuH79Ol5//XWMGTNGvaYcg23btsHV1RVeXl4oXrw4z/lERGTxOHSOiEzmxOkLGP3Re9j+3TwkJiVjxdqtiI6OwU+7D2DFgsnY+u1cNPGvjW83/qh/Tt2aVbFj/QJM/iR1WJoEmdLbumMvmjWqg7VLp2HrmrlYu3EH7t1/8Mz9SElJwZbVs9G2pT++mLMMsz4fiVVffY55S77NsN75i1dw4tR5bP5mNtYsnoqw8BuIjYvDV8vXo2/vt7B++XR06xSAYyfPPbGNM+cvY9HMcdi8ejZ27jmAcxfDsHvfYew/dBSbVwZj5dwgXLoc+h+PKBGRdp04cQKjR4/G9u3bkZiYiBUrViA6Oho//fSTur1161Y0adIE337777m3bt262LFjhwpKCQkypSfPadasGdauXatuy/W9e/eef87fsgVt27bFF198gVmzZmHVqlWYN29ehvXOnz+v9nnz5s1Ys2YNwsLCVHDqq6++Qt++fVWAqlu3bjh27NgT2zhz5gwWLVqknrtz504VgNq9ezf279+vlklw7dKlS//xiBIREeUMzGgiIpOpVrk8vEoVV7fbNG+AtZt+xDvd22P6p8Pww0+/ISz8OvYdCEF571L651St/Oxiib27t8fBP45j8YoNKispITERsbGpmVFP80bdGuq6aOECqFKpLJydnOBZxAlRDx9lWO/l4kWQkJCIru+NxOu1q2Nw3+5qXf96NfHxp7PR4NcaaFC3Bpo2rP3ENvxqVIGDg726lChWBA8ePMT+Q38hoGl9ODk5AslJaN2qJaIexmTrGBIR5RTVqlVTWTxp9YwkKPTOO+9g+vTp+OGHH1QgZ9++fSrjKE3VqlWf+Zq9e/fGwYMHsXjxYpWVlJCQoIJBz/LGG2+o66JFi6JKlSpwdnaGp6cnoqKiMqz38ssvq9fr2rWrykoaPHiwWlcymz7++GM0aNBAXZo2bfrENvz8/ODg4KAuJUqUwIMHD1SQKSAgQGV1idatWz+xTSIiq5QYB0SGAu6lUoujk8VhRhMRmYydna3+tk6XAhsbW9y8dQeden2EqIfRqF+7OtoFNFTDE9KooMwz/G/6YixbvRlFixTEB73fhHs+twzPz4y9vf2/+2T79NOgi7MTNq2ahb6930Tk/Si89fYwhF65jg6tG2Hdsi9Qsdwr+Pqb7zH2sy+feK4MqUuTK1cuyB7Z2NggJeXZ+0ZEZCns7P79PVPOy3IOvHnzJjp16qQCLvXr10e7du0eO+c/+w+O//3vf1i2bJkKGn3wwQdwd3fP3jk/3T49zsXFRQ3pk+ylyMhIvPXWWwgNDUWHDh2wbt06Nfzv66+/xtixY594rgypy3DO/+f9SjYVERE9FmT6riewqmPqtdwni8NAExGZTMjxsyqwJB3vTdt2q2FxMpyuZPGi6NW1rcou+vX3P5H8lI65ra0NkpKSMyzbf/go3g3sgOaN6uJmxN+qNpKhOvZ/HD2FdweOQ61XK2PEoN4qG0sCTbJMrrt0bIGB73fD6XNZGw5Rp2ZVbP95H+LjE1Sm1PYff1J/kBARWaKQkBAVWFLn/E2b1LA4GZpWsmRJ9OrVS2UX/frrr0hOznheTyN1kpKSkjIskyyhd999V9VmkteW2kgGO+f/8Yd67Vq1aqm6T5KNJYEmWSbXXbp0wcCBA3H69OksvV6dOnXUsMH4+HiVKSW3tXrO1+rMgzll/4goGySTKeJEaoBJruW+lX7+D1jwe+PQOTOSmV3io+Lh6PbsjA2ts5T3QcZXuKAHRk2YqQJCfjUq4832zRCfkIDV67ejxf/1hYO9PSpX8la1kTLTuIEfWnf5EOuWBeuX9enZEcPHBsPNNTdecs8LnwplcPX6LYPsb/UqFVSR74C3+qsi5hXKeamsK4+X8mL85/MwbfbX6tfxkYN6Z+n1pCi4BNba9RiG3C4OcM/vmeFXcGvC8waPM1m+woULY9SoUSogJEPL3nzzTRV0Wb16NVq0aKGGmVWuXFnVRspM48aN1XAzySZK06dPHwwfPhxubm546aWXVPHwq1evGmR/pQC5FPlOG+5WoUIFlXXl4eGhioRPmzYt9Zw/cmSWXk+G30lgTbK2cufOrbKvtHrO1+rMgzll/4goG2S4XCGf1CCTXMt9K/38H7Dg92bQQJOkQX/++eeq+KH8uiRj4mVmEOkM0JMs5T+TpbwPMr78L+XD119OyrDMzs4ZS+dOzHT9XZsXZ7g/87N/O/cyu5sIaPq6umSmfatGTyxbseCzDI+nXyftNWVmuTSfDOvzxGtI5tWGFTOeWJ7Z89NvU4qGFyrogR/WzIQuKRoDxi9HmTJlYI143uBxJsuXP39+NdQsPQnULF26NNP1d+3aleG+zNiWRoprCwkCySUzMkPd46ToePrH06+T9prpZ/785JNPnngNybx6vCj5056ffptSNLxQoUKqHpUMpRswYIDVnvOJiPSkJlOnr1mjycIZdOicjFmXKWkXLlyoijTK7BpSPNFskuLg9DBUXRMRmVvJlz2xc/cBtOo6GK0DR6NkiZL6IrVERGRZZIigzEDXqlUrlZkl93nOJyL6J9hUsDwLgVswg2U0xcTEqOloJR26UqVKaplkM8nMHZImbfJU4cQ42Kx/G69cDYHNje+ATsv4H5koi/z6lUP8w0Q4uv5bQPW/qlndBzXTZRNZo7xuebBwxlggOQFIfgS4+5p7l4iIjDKUtWbNmupizfLmzat+fCUiIrI2Bgs0ycwa8+fPzzBFrZACj48ePTJ9oEmKit06CRv5g+7WydT7EjUloufy61+OR4mIyEpwKCsRERFpcuicFE2UgolS2DHN8uXLUbZsWVWs0eSkqFjhSkixdVDXzysyRkREREREREREJsxoiouLU9PIZqZAgQJwcXHR31+5cqWaxnXRokXPfE3JeHratLb/iY09ktt+hYuHf0KZ15rA1sZeNmb47VCWpbWzUdrb0sgxktmac+kA6IyziRRdhmsyITnm0r7qs5Dxc8HPhzawPSy7Pfg5IyIiItJIoElmzwgMDMz0sblz56JRo9TZm1atWoVJkyapKW3r1q37zNd82pS2BuNaCifOXDDuNihbZKpfyurHM+Gfi/GcCHvE5jALO+DqmSeW8vOhLWwPbWF7EBEREVlYoEmKOqZN5fo0MtvclClTMHz4cPTo0eO5r+nt7Z0hE8qQ5BdL6ZT6+PjA1tbWKNsgtodRJMcD908Ati6AjYNxNpGiU0Emn5K5YWuTyyjboKdIkWLgMUA+H8A2tX4dz1fawvaw7PaQCUyM/kMXERERkZUyWDFwsXHjRhVkkkymnj17Zuk50mE0dhDIFNugrGN7ZOkopVZQkwCQrXGDQBJksjXyNuhxuVJHRMp56bFzEz8f2sL2sMz2YJ+AyPgzD1rT/hGR8Vjy59/Pgt+bwQJN9+/fx4QJE9CuXTu0bNkSd+7c0T8mxcDZqSMiIiIi0h6tzzyo9f0jIuOx5M+/nwW/N4MFmvbv369S0SWrSS7p/fLLLyhWrJihNkVERERERERERJYcaJIsJrlkVUqKTLkExMbGwljSZpWRABgzqsyP7ZGdg5UAxMsIq3jAJsU47fHPbHMxsXGs0WRqKYmpQ+diYgHbjLNp8XylDWwPy26PtL5HWl8kJ2H/yfrwfJSdg8X+k0Vj/0nzeL6y7DaJzUb/KZdOpzPL3OZ3795FWFiYOTZNREREhJIlS8LDwyNHHQn2n4iIiEjr/SezBZqSkpLw4MEDODo6wsZGqh4TERERGZ/8EhcfH4+8efPCzs6g86IYHftPREREpPX+k9kCTUREREREREREZFmYSkRERERERERERAZhkYEmSecKCgrCq6++irp162LJkiXm3iWrEhERgQEDBuC1115DvXr18Nlnn6k2EVevXkXPnj3h6+uLFi1a4LfffjP37lqV9957DyNHjtTfP336NDp16oQqVaqgQ4cOOHnypFn3z1okJCRg/PjxqFGjBmrXro3g4GCkJZeyTUzv5s2b6NOnD6pVqwZ/f398/fXX+sfYHqb9XAQEBODQoUP6Zc/7zvj999/Vc+QcFhgYqNan/4Z9KPNiH0q72IcyP/aftIX9J+1I0GAfyiIDTVOmTFF/MC9btgxjx47FnDlz8OOPP5p7t6yC/LEsQSapSL9q1SpMnz4du3fvxowZM9Rj/fr1Q/78+bF+/Xq0adMG/fv3x40bN8y921Zh27Zt2Lt3r/6+zDwgnSYJyG7YsAFVq1ZVf2zLcjKuSZMmqZP74sWL8cUXX2Dt2rX49ttv2SZmMmjQILi4uKjPgfxIIeernTt3sj1MHNwYMmQILly4oF/2vO8MuZbH27dvj3Xr1uGll15C37599UFbejHsQ5kP+1DaxT6UNrD/pC3sP2lDvFb7UDoL8+jRI52Pj4/u4MGD+mVz587VdevWzaz7ZS0uXryo8/b21t25c0e/bMuWLbq6devqfv/9d52vr69qozQ9evTQzZo1y0x7az0iIyN19evX13Xo0EE3YsQItey7777T+fv761JSUtR9uW7cuLFu/fr1Zt5by2+LChUq6A4dOqRftmDBAt3IkSPZJmZw//59dc46d+6cfln//v1148ePZ3uYyIULF3StW7fWtWrVSrVF2vf3874zZsyYkeG7PSYmRle1atUM3/+UPexDmRf7UNrEPpQ2sP+kLew/acMFDfehLC6j6ezZs2pGFsnOSFO9enUcO3ZMVUkn4ypQoAAWLVqkoqfpRUdHqzaoUKGCyhxI3zZHjx5lsxjZ559/riLZr7zyin6ZtIcc/1y5cqn7ci1Dh9gexvXnn38iT548amhpGskskyGmbBPTc3JygrOzs8pmSkxMxOXLlxESEoLy5cuzPUzk8OHDqFmzpsrqS+953xnyuGRkppF2rFixIs9h/wH7UObFPpQ2sQ+lDew/aQv7T9pwWMN9KIsLNN25cwfu7u5wcHDQL5Ogh6SU3b9/36z7Zg3c3NxUXaY0EtxbuXIlatWqpdqmYMGCGdb38PDArVu3zLCn1uPAgQP4448/VDpkemwP85Dxz56enti0aROaNWuGhg0bYu7cueqzwjYxPUdHR4wZM0Z9QcsY9ebNm6N+/fqqdhnbwzS6dOmihixKJye95x1/to/hsQ9lXuxDaQ/7UNrB/pO2sP+kDV003Ieyg4WR2kDpg0wi7b4UySLTmjp1qiqmK2M/pcBuZm3DdjEeCbBKnTL5Q1p+ecjKZ4XtYVxSA+vKlStYs2aNymKSE720j3xBsE3M49KlS2jQoAF69eqlxrdPnDgRfn5+bA8ze97ngZ8X0x1zwe8G02MfyrzYh9IW9p+0h/0n7YrVQB/KzhKjq48foLT7j/+hTcbvIElBdikI7u3trdrm8awyaRu2i/FIIfxKlSplyDJ73meF7WFcdnZ2aiipFAGXzKa0gnyrV69GiRIl2CZm+LVaAuFSKF/+7/v4+KhZn+bNm4fixYuzPczoed8ZTzuHSVYIvfgxZx9KG9iHMj/2obSF/SdtYf9J2xw10IeyuKFzhQoVQmRkpKrTlEYyBuSgsvNpOpIRsHTpUtVRatq0qb5t/v777wzryf3H0/bIsLOk/Pzzz6pmmVy2bNmiLnKb7WG+Ghxyck8LMolSpUqpKWLZJqYnM5RKgC99gFXGtEvwj+1hXs87/k97XD5j9OLHnH0o82MfShvYh9IW9p+0hf0nbSukgT6UxQWapICrRLzTF7KS4nHyK7WNjcW9Xc3+AiTDgoKDg9GyZUv9cql/curUKcTFxWVoG1lOxrFixQoVWJJ6QHLx9/dXF7ktx/2vv/7ST2Mp11IEme1hXHJ8JR0/NDRUv0wKUEvgiW1ievKFK0MZ0/+qI+1RrFgxtoeZPe87Q67lfhpJA5eh2jyHvTj2ocyPfSjtYB9KW9h/0hb2n7Stigb6UBYXeZE6J23btsW4ceNw/Phxlc2xZMkSBAYGmnvXrGas7pdffol3331XVbaXbLK0i8yyVaRIEYwaNUrVQVm4cKFqo44dO5p7ty2WBC8kWyPtkjt3bnWR21KIOioqCp9++ikuXryoruUkI8WQyXhKly6NN954Q30OZIanffv2qc9C586d2SZmIIFXe3t7fPzxxyr4t2vXLsyfPx/du3dne5jZ874zOnTooILjslwel/UkQCizr9CLYR/KvNiH0hb2obSF/SdtYf9J217TQh9KZ4FiYmJ0w4cP1/n6+urq1q2rW7p0qbl3yWosWLBA5+3tnelFhIWF6bp27aqrVKmSrmXLlrr9+/ebe5etyogRI9QlzbFjx3Rt27bV+fj46Dp27Kg7deqUWffPWkRFRemGDRumzlF+fn662bNn61JSUtRjbBPTu3Dhgq5nz566atWq6Ro1aqS+M9ge5iHfFQcPHtTff953xp49e3RNmjTRVa5cWdejRw9deHi4GfbasrAPZT7sQ2kb+1Dmx/6TtrD/pC3eGutD5ZJ/DBe2IiIiIiIiIiIia2VxQ+eIiIiIiIiIiMg8GGgiIiIiIiIiIiKDYKCJiIiIiIiIiIgMgoEmIiIiIiIiIiIyCAaaiIiIiIiIiIjIIBhoIiIiIiIiIiIig2CgiYiIiIiIiIiIDIKBJiIiIiIiIiIiMggGmohIE86cOYOQkBAcOnQIZcuWNffuEBEREeUI7EMRkdYw0EREmtCvXz+EhYWhatWq+O2338y9O0REREQ5AvtQRKQ1DDQRkaY4ODigQIEC5t4NIiIiohyFfSgi0goGmojI7Lp3747r169j1KhR8Pf31w+du3btmrq9Z88etVyynSZNmoTz58+jffv28PX1RZ8+fRAdHa1/rTVr1ujXldc9d+6cGd8ZERERkfGwD0VEWsRAExGZ3ezZs1G4cGEEBQWpy+MWLlyIL7/8EhMnTsSKFSvQv39/fPTRR1i8eDGOHj2KdevWqfV27dqFOXPm4JNPPsHGjRtRvXp1BAYG4sGDB2Z4V0RERETGxT4UEWkRA01EZHb58uWDra0tXF1d1eVxffv2Rbly5RAQEAAPDw+0bNkSderUUYEkPz8/XL58Wa23aNEileHUoEEDlCxZEoMGDYKnpyc2b95shndFREREZFzsQxGRFtmZeweIiJ6nePHi+ttOTk4qeJT+fkJCgrp96dIlTJ06FcHBwfrH4+PjVZFxIiIiImvDPhQRmQMDTUSkeZLtlJ6NTebJmMnJyWronWQ5pZcnTx6j7h8RERGRFrEPRUTmwKFzRGQxSpUqhVu3bqFEiRL6y/z581UdJyIiIiJiH4qIjI+BJiLSBBcXF1Vr6b8U7u7VqxeWLVuGTZs2ITw8XA2j2759O7y8vAy6r0RERERawT4UEWkNh84RkSZ07twZ06ZNw9q1a1/4NVq0aIG///4bs2bNUtevvPIK5s2bpwqDExEREVki9qGISGty6XQ6nbl3goiIiIiIiIiIcj4OnSMiIiIiIiIiIoNgoImIiIiIiIiIiAyCgSYiIiIiIiIiIjIIBpqIiIiIiIiIiMggGGgiIiIiIiIiIiIGmoiIiIiIiIiISDuY0URERERERERERAbBQBMRERERERERERkEA01ERERERERERGQQDDQREREREREREZFBMNBEREREREREREQGwUATERERERERERHBEP4fQMU7euHlcrgAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 1200x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def ar1_model(obs_times=None, obs_values=None, predict_times=None):\n",
+    "    alpha = numpyro.sample(\"alpha\", dist.Uniform(-0.7, 0.7))\n",
+    "\n",
+    "    dynamics = DynamicalModel(\n",
+    "        initial_condition=dist.MultivariateNormal(jnp.zeros(state_dim), jnp.eye(state_dim)),\n",
+    "        state_evolution=LinearGaussianStateEvolution(\n",
+    "            A=jnp.array([[alpha, 0.2], [-0.1, 0.8]]),\n",
+    "            cov=transition_cov,\n",
+    "        ),\n",
+    "        observation_model=LinearGaussianObservation(\n",
+    "            H=jnp.eye(state_dim),\n",
+    "            R=mvn_obs_cov,\n",
+    "        ),\n",
+    "        control_dim=0,\n",
+    "    )\n",
+    "    return dsx.sample(\n",
+    "        \"f\",\n",
+    "        dynamics,\n",
+    "        obs_times=obs_times,\n",
+    "        obs_values=obs_values,\n",
+    "        predict_times=predict_times,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "data_key, mcmc_key_sim, mcmc_key_smooth, pp_key = jr.split(jr.PRNGKey(0), 4)\n",
+    "\n",
+    "n_mcmc_warmup = 150\n",
+    "n_mcmc_samples = 150\n",
+    "\n",
+    "with DiscreteTimeSimulator():\n",
+    "    synthetic = Predictive(\n",
+    "        ar1_model,\n",
+    "        params={\"alpha\": jnp.array(true_alpha)},\n",
+    "        num_samples=1,\n",
+    "        exclude_deterministic=False,\n",
+    "    )(data_key, predict_times=obs_times)\n",
+    "\n",
+    "states_clean = np.asarray(synthetic[\"f_states\"].squeeze((0, 1)))\n",
+    "obs_clean = np.asarray(synthetic[\"f_observations\"].squeeze((0, 1)))\n",
+    "t = np.asarray(obs_times)\n",
+    "\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(12, 3), sharey=False)\n",
+    "for d, ax in enumerate(axes):\n",
+    "    ax.plot(t, states_clean[:, d], color=\"C0\", lw=1.2, label=f\"latent $x^{{({d})}}_t$\")\n",
+    "    ax.plot(t, obs_clean[:, d], \".\", ms=3, color=\"C1\", alpha=0.6, label=f\"obs $y^{{({d})}}_t$\")\n",
+    "    ax.set_xlabel(\"time\")\n",
+    "    ax.set_title(f\"Dimension {d}\")\n",
+    "    ax.legend(fontsize=8)\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "obs_mvn_missing = np.asarray(apply_nan_mask(jnp.asarray(obs_clean), mask_full_plus_partial))\n",
+    "plot_missing_data(\n",
+    "    t,\n",
+    "    states_clean,\n",
+    "    obs_mvn_missing,\n",
+    "    partial_indices={0: partial_idx_dim0, 1: partial_idx_dim1},\n",
+    "    title=\"Gaussian observations: full block + partial missing coordinates\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "2deb344d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def conditioned_simulator(obs_times=None, obs_values=None):\n",
+    "    with DiscreteTimeSimulator():\n",
+    "        ar1_model(obs_times=obs_times, obs_values=obs_values)\n",
+    "\n",
+    "\n",
+    "def conditioned_smoother(obs_times=None, obs_values=None):\n",
+    "    with Smoother(\n",
+    "        smoother_config=KFSmootherConfig(\n",
+    "            filter_source=\"cuthbert\",\n",
+    "            record_smoothed_states_mean=True,\n",
+    "            record_smoothed_states_cov_diag=True,\n",
+    "        )\n",
+    "    ):\n",
+    "        ar1_model(obs_times=obs_times, obs_values=obs_values)\n",
+    "\n",
+    "\n",
+    "mcmc_simulator = MCMC(\n",
+    "    NUTS(conditioned_simulator),\n",
+    "    num_warmup=n_mcmc_warmup,\n",
+    "    num_samples=n_mcmc_samples,\n",
+    "    progress_bar=False,\n",
+    ")\n",
+    "mcmc_simulator.run(mcmc_key_sim, obs_times=obs_times, obs_values=jnp.asarray(obs_mvn_missing))\n",
+    "\n",
+    "mcmc_smoother = MCMC(\n",
+    "    NUTS(conditioned_smoother),\n",
+    "    num_warmup=n_mcmc_warmup,\n",
+    "    num_samples=n_mcmc_samples,\n",
+    "    progress_bar=False,\n",
+    ")\n",
+    "mcmc_smoother.run(mcmc_key_smooth, obs_times=obs_times, obs_values=jnp.asarray(obs_mvn_missing))\n",
+    "\n",
+    "posterior_alpha_simulator = np.asarray(mcmc_simulator.get_samples()[\"alpha\"])\n",
+    "posterior_alpha_smoother = np.asarray(mcmc_smoother.get_samples()[\"alpha\"])\n",
+    "\n",
+    "simulator_state_samples = np.asarray(mcmc_simulator.get_samples()[\"f_states\"])[:, 0]\n",
+    "simulator_summary = summarize_state_draws(simulator_state_samples)\n",
+    "\n",
+    "with Smoother(\n",
+    "    smoother_config=KFSmootherConfig(\n",
+    "        filter_source=\"cuthbert\",\n",
+    "        record_smoothed_states_mean=True,\n",
+    "        record_smoothed_states_cov_diag=True,\n",
+    "    )\n",
+    "):\n",
+    "    pp_smoother = Predictive(\n",
+    "        ar1_model,\n",
+    "        posterior_samples=mcmc_smoother.get_samples(),\n",
+    "        exclude_deterministic=False,\n",
+    "    )(jr.fold_in(pp_key, 1), obs_times=obs_times, obs_values=jnp.asarray(obs_mvn_missing))\n",
+    "\n",
+    "smoothed_states = np.asarray(pp_smoother[\"f_smoothed_states_mean\"])\n",
+    "smoothed_cov_diag = np.asarray(pp_smoother[\"f_smoothed_states_cov_diag\"])\n",
+    "smoother_summary = summarize_gaussian_mixture(\n",
+    "    smoothed_states,\n",
+    "    smoothed_cov_diag,\n",
+    "    rng_key=jr.fold_in(pp_key, 11),\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "2c569c1c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Simulator state RMSE: 0.3579166829586029\n",
+      "KF smoother state RMSE: 0.34518691897392273\n",
+      "Simulator missing-row RMSE: 0.4478903114795685\n",
+      "KF smoother missing-row RMSE: 0.41802310943603516\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x350 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(10, 3), sharey=True)\n",
+    "az.plot_posterior(posterior_alpha_simulator, hdi_prob=0.95, ref_val=true_alpha, ax=axes[0])\n",
+    "axes[0].set_title(\"Simulator posterior of $\\\\alpha$\")\n",
+    "az.plot_posterior(posterior_alpha_smoother, hdi_prob=0.95, ref_val=true_alpha, ax=axes[1])\n",
+    "axes[1].set_title(\"KF smoother posterior of $\\\\alpha$\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "missing_rows_mvn = ~mask_full_plus_partial.all(axis=1)\n",
+    "print(\"Simulator state RMSE:\", rmse(simulator_summary[\"mean\"], states_clean))\n",
+    "print(\"KF smoother state RMSE:\", rmse(smoother_summary[\"mean\"], states_clean))\n",
+    "print(\"Simulator missing-row RMSE:\", rmse(simulator_summary[\"mean\"][missing_rows_mvn], states_clean[missing_rows_mvn]))\n",
+    "print(\"KF smoother missing-row RMSE:\", rmse(smoother_summary[\"mean\"][missing_rows_mvn], states_clean[missing_rows_mvn]))\n",
+    "\n",
+    "plot_state_recovery(\n",
+    "    t,\n",
+    "    states_clean,\n",
+    "    obs_mvn_missing,\n",
+    "    simulator_summary,\n",
+    "    label_a=\"simulator\",\n",
+    "    color_a=\"C2\",\n",
+    "    summary_b=smoother_summary,\n",
+    "    label_b=\"smoother\",\n",
+    "    color_b=\"C3\",\n",
+    "    partial_indices={0: partial_idx_dim0, 1: partial_idx_dim1},\n",
+    "    title=\"Gaussian case: simulator vs. smoother state recovery\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5fc4c6e5",
+   "metadata": {},
+   "source": [
+    "## 3. Example 2: independent asymmetric Laplace observations\n",
+    "\n",
+    "Now keep the same latent AR(1)-style discrete-time setup, but switch the observation family to a coordinate-wise **asymmetric Laplace** model.\n",
+    "\n",
+    "If we want to perform Filtering/Smoothing as before, we would need to use a variant that can handle these non-Gaussian observations (e.g. PF/PS or EKF/EKS); however, as noted in the previous tutorial, these methods are not yet set up to automatically support missing data. The EnKF, while configured to automatically support missing data, is not set up to support non-Gaussian observations.\n",
+    "\n",
+    "Nevertheless, the `MCMC + Simulator()` strategy can handle all forms of missingness (partial and full) under non-Gaussian observation models as long as the observation model is independent per observation dimension, which is the case here."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2b0cd6cd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def asymmetric_laplace_model(obs_times=None, obs_values=None, predict_times=None):\n",
+    "    alpha = numpyro.sample(\"alpha\", dist.Uniform(-0.7, 0.7))\n",
+    "\n",
+    "    def observation_model(x, u, t):\n",
+    "        mean_shift = asym_laplace_scale * (1.0 / asym_laplace_k - asym_laplace_k)\n",
+    "        loc = x - mean_shift\n",
+    "        return dist.Independent(\n",
+    "            dist.AsymmetricLaplace(\n",
+    "                loc=loc,\n",
+    "                scale=asym_laplace_scale,\n",
+    "                asymmetry=asym_laplace_k,\n",
+    "            ),\n",
+    "            1,\n",
+    "        )\n",
+    "\n",
+    "    dynamics = DynamicalModel(\n",
+    "        initial_condition=dist.MultivariateNormal(jnp.zeros(state_dim), jnp.eye(state_dim)),\n",
+    "        state_evolution=LinearGaussianStateEvolution(\n",
+    "            A=jnp.array([[alpha, 0.2], [-0.1, 0.8]]),\n",
+    "            cov=transition_cov_non_gaussian,\n",
+    "        ),\n",
+    "        observation_model=observation_model,\n",
+    "        control_dim=0,\n",
+    "    )\n",
+    "    return dsx.sample(\n",
+    "        \"f\",\n",
+    "        dynamics,\n",
+    "        obs_times=obs_times,\n",
+    "        obs_values=obs_values,\n",
+    "        predict_times=predict_times,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "with DiscreteTimeSimulator():\n",
+    "    asym_laplace_synth = Predictive(\n",
+    "        asymmetric_laplace_model,\n",
+    "        params={\"alpha\": jnp.array(true_alpha)},\n",
+    "        num_samples=1,\n",
+    "        exclude_deterministic=False,\n",
+    "    )(jr.PRNGKey(10), predict_times=obs_times)\n",
+    "\n",
+    "asym_laplace_states_true = np.asarray(asym_laplace_synth[\"f_states\"].squeeze((0, 1)))\n",
+    "asym_laplace_obs_clean = np.asarray(asym_laplace_synth[\"f_observations\"].squeeze((0, 1))).astype(float)\n",
+    "asym_laplace_obs_missing = np.asarray(apply_nan_mask(jnp.asarray(asym_laplace_obs_clean), mask_full_plus_partial))\n",
+    "\n",
+    "plot_missing_data(\n",
+    "    t,\n",
+    "    asym_laplace_states_true,\n",
+    "    asym_laplace_obs_missing,\n",
+    "    partial_indices={0: partial_idx_dim0, 1: partial_idx_dim1},\n",
+    "    title=\"Independent asymmetric-Laplace observations: full block + partial missing coordinates\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "b90fea4e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def conditioned_asymmetric_laplace_simulator(obs_times=None, obs_values=None):\n",
+    "    with DiscreteTimeSimulator():\n",
+    "        asymmetric_laplace_model(obs_times=obs_times, obs_values=obs_values)\n",
+    "\n",
+    "\n",
+    "mcmc_asym_laplace = MCMC(\n",
+    "    NUTS(conditioned_asymmetric_laplace_simulator),\n",
+    "    num_warmup=n_mcmc_warmup,\n",
+    "    num_samples=n_mcmc_samples,\n",
+    "    progress_bar=False,\n",
+    ")\n",
+    "mcmc_asym_laplace.run(jr.PRNGKey(11), obs_times=obs_times, obs_values=jnp.asarray(asym_laplace_obs_missing))\n",
+    "\n",
+    "posterior_alpha_asym_laplace = np.asarray(mcmc_asym_laplace.get_samples()[\"alpha\"])\n",
+    "asym_laplace_state_samples = np.asarray(mcmc_asym_laplace.get_samples()[\"f_states\"])[:, 0]\n",
+    "asym_laplace_summary = summarize_state_draws(asym_laplace_state_samples)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8b0d0727",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Asymmetric-Laplace simulator alpha: {'mean': 0.41657981276512146, 'p05': 0.20947781205177307, 'p95': 0.5842270255088806}\n",
+      "True alpha: 0.4\n",
+      "Asymmetric-Laplace state RMSE: 0.3254196345806122\n",
+      "Asymmetric-Laplace missing-row RMSE: 0.4429817199707031\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x350 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n",
+    "az.plot_posterior(posterior_alpha_asym_laplace, hdi_prob=0.95, ref_val=true_alpha, ax=ax)\n",
+    "ax.set_title(\"Simulator posterior of $\\\\alpha$  (asymmetric-Laplace obs)\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"Asymmetric-Laplace simulator alpha:\", summarize_1d(posterior_alpha_asym_laplace))\n",
+    "print(\"True alpha:\", true_alpha)\n",
+    "print(\"Asymmetric-Laplace state RMSE:\", rmse(asym_laplace_summary[\"mean\"], asym_laplace_states_true))\n",
+    "print(\n",
+    "    \"Asymmetric-Laplace missing-row RMSE:\",\n",
+    "    rmse(\n",
+    "        asym_laplace_summary[\"mean\"][~mask_full_plus_partial.all(axis=1)],\n",
+    "        asym_laplace_states_true[~mask_full_plus_partial.all(axis=1)],\n",
+    "    ),\n",
+    ")\n",
+    "\n",
+    "plot_state_recovery(\n",
+    "    t,\n",
+    "    asym_laplace_states_true,\n",
+    "    asym_laplace_obs_missing,\n",
+    "    asym_laplace_summary,\n",
+    "    label_a=\"simulator\",\n",
+    "    color_a=\"C2\",\n",
+    "    partial_indices={0: partial_idx_dim0, 1: partial_idx_dim1},\n",
+    "    title=\"Independent asymmetric-Laplace case: simulator state recovery\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "628f567e",
+   "metadata": {},
+   "source": [
+    "## 4. Example 3: a correlated multivariate Student $t$\n",
+    "\n",
+    "Finally, consider a correlated non-Gaussian observation family: a multivariate Student $t$.\n",
+    "\n",
+    "For a generic correlated observation model, partial missingness is no longer something we can treat with a one-line generic rule. The simulator would need model-specific code for\n",
+    "\n",
+    "$$\n",
+    "p(y_{k, O_k} \\mid x_k, \\alpha),\n",
+    "$$\n",
+    "\n",
+    "and that formula depends on the observation family.\n",
+    "\n",
+    "That is why this case is **not currently supported for partial missingness**.\n",
+    "\n",
+    "Still, **full-row missingness is fine**. When the whole row is missing (e.g. all sensors dropped out), the observation factor at that index simply disappears, regardless of how complicated the observation model is.\n",
+    "\n",
+    "So here we use the **full-row-only** mask and again compare the simulator the **truth**.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "5de1046e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x300 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "def student_t_model(obs_times=None, obs_values=None, predict_times=None):\n",
+    "    alpha = numpyro.sample(\"alpha\", dist.Uniform(-0.7, 0.7))\n",
+    "\n",
+    "    dynamics = DynamicalModel(\n",
+    "        initial_condition=dist.MultivariateNormal(jnp.zeros(state_dim), jnp.eye(state_dim)),\n",
+    "        state_evolution=LinearGaussianStateEvolution(\n",
+    "            A=jnp.array([[alpha, 0.2], [-0.1, 0.8]]),\n",
+    "            cov=transition_cov_non_gaussian,\n",
+    "        ),\n",
+    "        observation_model=lambda x, u, t: dist.MultivariateStudentT(\n",
+    "            df=student_df,\n",
+    "            loc=x,\n",
+    "            scale_tril=student_scale_tril,\n",
+    "        ),\n",
+    "        control_dim=0,\n",
+    "    )\n",
+    "    return dsx.sample(\n",
+    "        \"f\",\n",
+    "        dynamics,\n",
+    "        obs_times=obs_times,\n",
+    "        obs_values=obs_values,\n",
+    "        predict_times=predict_times,\n",
+    "    )\n",
+    "\n",
+    "\n",
+    "with DiscreteTimeSimulator():\n",
+    "    student_synth = Predictive(\n",
+    "        student_t_model,\n",
+    "        params={\"alpha\": jnp.array(true_alpha)},\n",
+    "        num_samples=1,\n",
+    "        exclude_deterministic=False,\n",
+    "    )(jr.PRNGKey(20), predict_times=obs_times)\n",
+    "\n",
+    "student_states_true = np.asarray(student_synth[\"f_states\"].squeeze((0, 1)))\n",
+    "student_obs_clean = np.asarray(student_synth[\"f_observations\"].squeeze((0, 1)))\n",
+    "student_obs_missing = np.asarray(apply_nan_mask(jnp.asarray(student_obs_clean), mask_full_only))\n",
+    "\n",
+    "plot_missing_data(\n",
+    "    t,\n",
+    "    student_states_true,\n",
+    "    student_obs_missing,\n",
+    "    title=\"Multivariate Student t observations: full-row block missingness\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "22513616",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def conditioned_student_t_simulator(obs_times=None, obs_values=None):\n",
+    "    with DiscreteTimeSimulator():\n",
+    "        student_t_model(obs_times=obs_times, obs_values=obs_values)\n",
+    "\n",
+    "\n",
+    "mcmc_student = MCMC(\n",
+    "    NUTS(conditioned_student_t_simulator),\n",
+    "    num_warmup=n_mcmc_warmup,\n",
+    "    num_samples=n_mcmc_samples,\n",
+    "    progress_bar=False,\n",
+    ")\n",
+    "mcmc_student.run(jr.PRNGKey(21), obs_times=obs_times, obs_values=jnp.asarray(student_obs_missing))\n",
+    "\n",
+    "posterior_alpha_student = np.asarray(mcmc_student.get_samples()[\"alpha\"])\n",
+    "student_state_samples = np.asarray(mcmc_student.get_samples()[\"f_states\"])[:, 0]\n",
+    "student_summary = summarize_state_draws(student_state_samples)\n",
+    "missing_rows_student = ~mask_full_only.all(axis=1)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "09f3167a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 500x300 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Student t simulator alpha: {'mean': 0.44460269808769226, 'p05': 0.14976708590984344, 'p95': 0.6652595400810242}\n",
+      "True alpha: 0.4\n",
+      "Student t state RMSE: 0.32692649960517883\n",
+      "Student t missing-row RMSE: 0.3392679691314697\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x350 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots(1, 1, figsize=(5, 3))\n",
+    "az.plot_posterior(posterior_alpha_student, hdi_prob=0.95, ref_val=true_alpha, ax=ax)\n",
+    "ax.set_title(\"Simulator posterior of $\\\\alpha$  (Student t obs)\")\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(\"Student t simulator alpha:\", summarize_1d(posterior_alpha_student))\n",
+    "print(\"True alpha:\", true_alpha)\n",
+    "print(\"Student t state RMSE:\", rmse(student_summary[\"mean\"], student_states_true))\n",
+    "print(\"Student t missing-row RMSE:\", rmse(student_summary[\"mean\"][missing_rows_student], student_states_true[missing_rows_student]))\n",
+    "\n",
+    "plot_state_recovery(\n",
+    "    t,\n",
+    "    student_states_true,\n",
+    "    student_obs_missing,\n",
+    "    student_summary,\n",
+    "    label_a=\"simulator\",\n",
+    "    color_a=\"C2\",\n",
+    "    title=\"Multivariate Student t case: simulator state recovery\",\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f42d8077",
+   "metadata": {},
+   "source": [
+    "## Summary\n",
+    "\n",
+    "The clean simulator-side interpretation is:\n",
+    "\n",
+    "- `obs_values[k]` always belongs to latent index $k$;\n",
+    "- a **fully missing** row means: keep $x_k$, but add **no observation factor** at that index;\n",
+    "- a **partially missing** row means: keep $x_k$ and score only the observed part of $y_k$.\n",
+    "\n",
+    "That immediately implies the key scope split:\n",
+    "\n",
+    "- **full-row missingness** works for **all** observation models under the simulator;\n",
+    "- **partial missingness** needs exploitable structure.\n",
+    "\n",
+    "In this tutorial that structure was:\n",
+    "\n",
+    "- **multivariate Gaussian**: restrict to the observed subvector and covariance submatrix;\n",
+    "- **independent asymmetric-Laplace observations**: sum only the observed-coordinate log-probabilities.\n",
+    "\n",
+    "For a correlated non-Gaussian observation model, like a multivariate Student $t$, partial missingness would require model-specific marginalization code, so we currently fall back to the simpler supported scope: **full-row missingness only**.\n",
+    "\n",
+    "Finally, the comparison story (w.r.t. Smoothers) depends on the observation family:\n",
+    "\n",
+    "- for the **Gaussian** case, the simulator and the Kalman smoother can be compared directly;\n",
+    "- for the **non-Gaussian** missing-data cases shown here, the simulator is currently the primary automagic path; future work can make the Particle Smoothers apply more automatically.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ff7d0f7e",
+   "metadata": {},
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "name": "python",
+   "version": "3.11"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/dynestyx/internal/__init__.py b/dynestyx/internal/__init__.py
new file mode 100644
index 0000000..64da323
--- /dev/null
+++ b/dynestyx/internal/__init__.py
@@ -0,0 +1 @@
+"""Internal helpers for simulator and inference implementations."""
diff --git a/dynestyx/internal/observation_missingness.py b/dynestyx/internal/observation_missingness.py
new file mode 100644
index 0000000..adbb049
--- /dev/null
+++ b/dynestyx/internal/observation_missingness.py
@@ -0,0 +1,163 @@
+"""Internal helpers for conditioned observation log-potentials under simulator inference."""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import Literal
+
+import jax.numpy as jnp
+import jax.scipy as jsp
+import numpy as np
+import numpyro.distributions as dist
+from jax import Array
+from jax.errors import TracerArrayConversionError
+
+from dynestyx.models.checkers import _make_probe_state
+from dynestyx.models.core import DynamicalModel
+
+LOG_2PI = jnp.log(2.0 * jnp.pi)
+
+
+def _masked_multivariate_normal_log_prob(
+    obs_dist: dist.MultivariateNormal,
+    y: Array,
+    obs_mask: Array,
+) -> Array:
+    """Exact masked Gaussian log-prob via a fixed-shape marginalization formula."""
+    mask_f = obs_mask.astype(obs_dist.loc.dtype)
+    residual = (y - obs_dist.loc) * mask_f
+    cov = obs_dist.covariance_matrix
+    mask_outer = mask_f[:, None] * mask_f[None, :]
+    masked_cov = cov * mask_outer + jnp.diag(1.0 - mask_f)
+
+    chol = jnp.linalg.cholesky(masked_cov)
+    whitened = jsp.linalg.solve_triangular(chol, residual, lower=True)
+    quad = jnp.dot(whitened, whitened)
+    logdet = 2.0 * jnp.sum(jnp.log(jnp.diag(chol)))
+    n_obs = jnp.sum(mask_f)
+    return -0.5 * (quad + logdet + n_obs * LOG_2PI)
+
+
+@dataclasses.dataclass
+class ObservationLogPotential:
+    """Evaluate conditioned observation log-potentials and preserve NaNs in outputs."""
+
+    dynamics: DynamicalModel
+    obs_values: Array
+    distribution_mode: Literal[
+        "uninitialized", "masked", "multivariate_normal", "independent"
+    ] = dataclasses.field(init=False, default="uninitialized")
+    safe_obs: Array = dataclasses.field(init=False)
+    obs_mask: Array = dataclasses.field(init=False)
+    row_has_any_observed: Array = dataclasses.field(init=False)
+    has_missing: bool = dataclasses.field(init=False)
+    has_partial_missing: bool = dataclasses.field(init=False)
+    has_fully_missing_rows: bool = dataclasses.field(init=False)
+
+    def __post_init__(self) -> None:
+        """Precompute NaN-aware observation summaries once at construction time."""
+        obs_mask = ~jnp.isnan(self.obs_values)
+        safe_obs = jnp.where(obs_mask, self.obs_values, jnp.zeros_like(self.obs_values))
+        row_has_any_observed = (
+            obs_mask if self.obs_values.ndim <= 1 else jnp.any(obs_mask, axis=-1)
+        )
+
+        try:
+            obs_mask_host = np.asarray(obs_mask)
+        except TracerArrayConversionError:
+            obs_mask_host = None
+
+        if self.obs_values.ndim <= 1:
+            has_partial_missing = False
+            has_fully_missing_rows = (
+                bool((~obs_mask_host).any()) if obs_mask_host is not None else True
+            )
+        else:
+            if obs_mask_host is not None:
+                row_has_any_host = obs_mask_host.any(axis=-1)
+                row_has_all_host = obs_mask_host.all(axis=-1)
+                row_has_any_observed = jnp.asarray(row_has_any_host)
+                has_partial_missing = bool((row_has_any_host & ~row_has_all_host).any())
+                has_fully_missing_rows = bool((~row_has_any_host).any())
+            else:
+                has_partial_missing = self.obs_values.shape[-1] > 1
+                has_fully_missing_rows = False
+
+        try:
+            has_missing = bool(np.isnan(np.asarray(self.obs_values)).any())
+        except TracerArrayConversionError:
+            has_missing = False
+
+        self.safe_obs = safe_obs
+        self.obs_mask = obs_mask
+        self.row_has_any_observed = row_has_any_observed
+        self.has_missing = has_missing
+        self.has_partial_missing = has_partial_missing
+        self.has_fully_missing_rows = has_fully_missing_rows
+
+        x_probe = _make_probe_state(
+            initial_condition=self.dynamics.initial_condition,
+            state_dim=self.dynamics.state_dim,
+        )
+        u_probe = (
+            None
+            if self.dynamics.control_dim == 0
+            else jnp.zeros((self.dynamics.control_dim,))
+        )
+        t_probe = jnp.array(0.0) if self.dynamics.t0 is None else self.dynamics.t0
+        self._configure_from_distribution(
+            self.dynamics.observation_model(x=x_probe, u=u_probe, t=t_probe)
+        )
+
+    def _is_scalar_like_row(self) -> bool:
+        return self.obs_values.ndim <= 1 or self.obs_values.shape[-1] == 1
+
+    def _configure_from_distribution(self, obs_dist: dist.Distribution) -> None:
+        """Choose the log-potential evaluation mode once before scanning in time."""
+        if self._is_scalar_like_row():
+            self.distribution_mode = "masked"
+            return
+
+        if isinstance(obs_dist, dist.MultivariateNormal):
+            self.distribution_mode = "multivariate_normal"
+            return
+
+        if isinstance(obs_dist, dist.Independent) and (
+            obs_dist.reinterpreted_batch_ndims == 1
+        ):
+            self.distribution_mode = "independent"
+            return
+
+        if self.has_partial_missing:
+            raise NotImplementedError(
+                "Partial missingness currently requires marginalizable "
+                "MultivariateNormal observations or factorizable "
+                "Independent(..., 1) observations."
+            )
+
+        self.distribution_mode = "masked"
+
+    def log_potential_step(self, *, x, u, t, t_idx) -> Array:
+        """Return log p(y_{obs} | x, u, t) at a single observation index."""
+        if self.distribution_mode == "uninitialized":
+            raise RuntimeError(
+                "ObservationLogPotential must be configured with an initial "
+                "observation distribution before log_potential_step is used."
+            )
+
+        y = self.safe_obs[t_idx]
+        obs_mask = self.obs_mask[t_idx]
+        row_has_any_observed = self.row_has_any_observed[t_idx]
+        obs_dist = self.dynamics.observation_model(x=x, u=u, t=t)
+
+        if self.distribution_mode == "masked":
+            return obs_dist.mask(row_has_any_observed).log_prob(y)
+
+        if self.distribution_mode == "independent":
+            return obs_dist.base_dist.mask(obs_mask).to_event(1).log_prob(y)
+
+        return _masked_multivariate_normal_log_prob(obs_dist, y, obs_mask)
+
+    def observation_step(self, t_idx) -> Array:
+        """Return the original NaN-preserving observation row."""
+        return self.obs_values[t_idx]
diff --git a/dynestyx/simulators.py b/dynestyx/simulators.py
index 1fe2694..b28c33c 100644
--- a/dynestyx/simulators.py
+++ b/dynestyx/simulators.py
@@ -24,6 +24,9 @@
     _slice_array_for_plate_member,
     _slice_dist_for_plate_member,
 )
+from dynestyx.internal.observation_missingness import (
+    ObservationLogPotential,
+)
 from dynestyx.models import (
     DeterministicContinuousTimeStateEvolution,
     DiracIdentityObservation,
@@ -603,6 +606,29 @@ def _step(carry, t_idx):
         return observations
 
 
+def _apply_observation_log_potential(
+    name: str,
+    states: Array,
+    times: Array,
+    log_potential: ObservationLogPotential,
+    control_path_eval: Callable[[Array], Array | None],
+) -> Array:
+    """Apply observation log-potentials and preserve NaNs in outputs."""
+    ctrl = control_path_eval if control_path_eval is not None else (lambda t: None)
+    T = len(times)
+
+    def _step(carry, t_idx):
+        x_t = states[t_idx]
+        t = times[t_idx]
+        u_t = ctrl(t)
+        lp = log_potential.log_potential_step(x=x_t, u=u_t, t=t, t_idx=t_idx)
+        numpyro.factor(f"{name}_y_{t_idx}_lp", lp)
+        return carry, log_potential.observation_step(t_idx)
+
+    _, observations = nscan(_step, None, jnp.arange(T))
+    return observations
+
+
 class SDESimulator(BaseSimulator):
     """Simulator for continuous-time stochastic dynamics (SDEs).
 
@@ -857,6 +883,69 @@ class DiscreteTimeSimulator(BaseSimulator):
 
     n_simulations: int = 1
 
+    def _simulate_conditioned_scan(
+        self,
+        name: str,
+        dynamics: DynamicalModel,
+        *,
+        times: Array,
+        ctrl_values: Array | None,
+        obs_values: Array,
+    ) -> dict[str, Array]:
+        """Sequential latent-state scan for conditioned observations via log-potentials."""
+        state_transition = cast(DiscreteStateTransition, dynamics.state_evolution)
+        log_potential = ObservationLogPotential(
+            dynamics=dynamics,
+            obs_values=obs_values,
+        )
+
+        with numpyro.plate(f"{name}_n_simulations", 1):
+            x_prev_site: Real[Array, " state_dim"] | Real[Array, ""] = numpyro.sample(  # type: ignore
+                f"{name}_x_0", dynamics.initial_condition
+            )
+        x_prev = x_prev_site[0]
+
+        u_0 = _get_val_or_None(ctrl_values, 0)
+        numpyro.factor(
+            f"{name}_y_0_lp",
+            log_potential.log_potential_step(x=x_prev, u=u_0, t=times[0], t_idx=0),
+        )
+        y_0 = log_potential.observation_step(0)
+
+        def _step(x_prev, t_idx):
+            t_now = times[t_idx]
+            t_next = times[t_idx + 1]
+            u_now = _get_val_or_None(ctrl_values, t_idx)
+            u_next = _get_val_or_None(ctrl_values, t_idx + 1)
+            trans_dist = state_transition(x=x_prev, u=u_now, t_now=t_now, t_next=t_next)
+            with numpyro.plate(f"{name}_n_simulations", 1):
+                x_t_site = numpyro.sample(f"{name}_x_{t_idx + 1}", trans_dist)
+            x_t = x_t_site[0]
+            numpyro.factor(
+                f"{name}_y_{t_idx + 1}_lp",
+                log_potential.log_potential_step(
+                    x=x_t,
+                    u=u_next,
+                    t=t_next,
+                    t_idx=t_idx + 1,
+                ),
+            )
+            y_t = log_potential.observation_step(t_idx + 1)
+            return x_t, (x_t, y_t)
+
+        _, scan_outputs = nscan(_step, x_prev, jnp.arange(len(times) - 1))
+        scan_states, scan_observations = scan_outputs
+
+        states = jnp.concatenate([jnp.expand_dims(x_prev, axis=0), scan_states], axis=0)
+        observations = jnp.concatenate(
+            [jnp.expand_dims(y_0, axis=0), scan_observations], axis=0
+        )
+        return {
+            "times": _tile_times(times, 1),
+            "states": _ensure_trailing_dim(jnp.expand_dims(states, axis=0)),
+            "observations": _ensure_trailing_dim(jnp.expand_dims(observations, axis=0)),
+        }
+
     def _simulate(
         self,
         name: str,
@@ -873,7 +962,8 @@ def _simulate(
 
         Creates NumPyro sample sites for the initial condition (`"x_0"`), subsequent
         states (`"x_1"`, ...), and observations (`"y_0"`, ...). If `obs_values` is
-        provided, observation sites are conditioned via `obs=...`.
+        provided for a non-Dirac observation model, conditioning is handled via
+        per-step log-potential factors rather than `obs=...` sample sites.
 
         Notes:
             - For `DiracIdentityObservation` with provided `obs_values`, the latent
@@ -901,13 +991,36 @@ def _simulate(
             raise ValueError("obs_times must contain at least one timepoint")
 
         n_sim = self.n_simulations
+        is_dirac_observation = isinstance(
+            dynamics.observation_model, DiracIdentityObservation
+        )
+
+        if (
+            is_dirac_observation
+            and obs_values is not None
+            and np.isnan(np.asarray(obs_values)).any()
+        ):
+            raise ValueError(
+                "NaN-valued obs_values are not currently supported with "
+                "DiracIdentityObservation under DiscreteTimeSimulator. "
+                "Dirac observations are treated as exact latent-state constraints, "
+                "so missingness would require a separate marginalization path."
+            )
+
+        if obs_values is not None and not is_dirac_observation:
+            return self._simulate_conditioned_scan(
+                name,
+                dynamics,
+                times=times,
+                ctrl_values=ctrl_values,
+                obs_values=obs_values,
+            )
+
         state_transition = cast(DiscreteStateTransition, dynamics.state_evolution)
 
         # DiracIdentityObservation with observed values: y_t = x_t, so we use plating
         # instead of scan. state_evolution returns a dist; call it with batched inputs.
-        if isinstance(dynamics.observation_model, DiracIdentityObservation) and (
-            obs_values is not None
-        ):
+        if is_dirac_observation and (obs_values is not None):
             with numpyro.plate(f"{name}_n_simulations", 1):
                 numpyro.sample(
                     f"{name}_x_0",
@@ -1019,7 +1132,7 @@ def _step(carry, t_idx):
                 "observations": _ensure_trailing_dim(observations),
             }
 
-        # Default: scan over time (n_simulations == 1)...allows for obs= conditioning.
+        # Default forward-simulation scan (n_simulations == 1).
         with numpyro.plate(f"{name}_n_simulations", 1):
             x_prev_site: Real[Array, " state_dim"] | Real[Array, ""] = numpyro.sample(  # type: ignore
                 f"{name}_x_0", dynamics.initial_condition
@@ -1154,8 +1267,9 @@ def _simulate(
             dynamics: A `DynamicalModel` whose `state_evolution` is a
                 `DeterministicContinuousTimeStateEvolution`.
             obs_times: Times at which to save the latent state and emit observations.
-            obs_values: Optional observation array. If provided, observation sites are
-                conditioned via `obs=obs_values[i]`.
+            obs_values: Optional observation array. If provided for a non-Dirac
+                observation model, conditioning is handled via per-step
+                log-potential factors.
             ctrl_times: Optional control times.
             ctrl_values: Optional controls aligned to `ctrl_times`.
             predict_times: Used when obs_times is None (e.g. from Filter).
@@ -1169,6 +1283,9 @@ def _simulate(
             raise ValueError("obs_times or predict_times must be provided")
 
         n_sim = self.n_simulations
+        is_dirac_observation = isinstance(
+            dynamics.observation_model, DiracIdentityObservation
+        )
 
         if ctrl_times is not None and ctrl_values is not None:
             control_path = _build_control_path(ctrl_times, ctrl_values, times)
@@ -1177,6 +1294,14 @@ def _simulate(
             control_path_eval = lambda t: None
 
         t0 = dynamics.t0 if dynamics.t0 is not None else times[0]
+        log_potential = (
+            ObservationLogPotential(
+                dynamics=dynamics,
+                obs_values=obs_values,
+            )
+            if obs_values is not None and not is_dirac_observation
+            else None
+        )
 
         def _sim_one_trajectory(x0: Array, *, obs_key=None):
             """Simulate one ODE trajectory and emit observations."""
@@ -1188,20 +1313,28 @@ def _sim_one_trajectory(x0: Array, *, obs_key=None):
                 control_path_eval,
                 self.diffeqsolve_settings,
             )
-            observations = _emit_observations(
-                name,
-                dynamics,
-                states,
-                times,
-                obs_values,
-                control_path_eval,
-                key=obs_key,
-            )
+            if log_potential is not None:
+                observations = _apply_observation_log_potential(
+                    name,
+                    states,
+                    times,
+                    log_potential,
+                    control_path_eval,
+                )
+            else:
+                observations = _emit_observations(
+                    name,
+                    dynamics,
+                    states,
+                    times,
+                    obs_values,
+                    control_path_eval,
+                    key=obs_key,
+                )
             return states, observations
 
         if obs_values is not None:
             # Conditioning mode (n_sim must be 1 due to guard above).
-            # Uses numpyro.sample per observation site to support obs= conditioning.
             with numpyro.plate(f"{name}_n_simulations", 1):
                 x0 = numpyro.sample(f"{name}_x_0", dynamics.initial_condition)
             x0_arr: Array = jnp.asarray(x0)[0]
diff --git a/tests/missingness/__init__.py b/tests/missingness/__init__.py
new file mode 100644
index 0000000..6587b6c
--- /dev/null
+++ b/tests/missingness/__init__.py
@@ -0,0 +1 @@
+"""Tests for simulator missing-observation support."""
diff --git a/tests/missingness/models.py b/tests/missingness/models.py
new file mode 100644
index 0000000..6a98af4
--- /dev/null
+++ b/tests/missingness/models.py
@@ -0,0 +1,306 @@
+import equinox as eqx
+import jax.numpy as jnp
+import numpyro
+import numpyro.distributions as dist
+
+import dynestyx as dsx
+from dynestyx.models import (
+    ContinuousTimeStateEvolution,
+    DiracIdentityObservation,
+    DynamicalModel,
+    GaussianObservation,
+    GaussianStateEvolution,
+    LinearGaussianObservation,
+    LinearGaussianStateEvolution,
+)
+from dynestyx.models.state_evolution import AffineDrift
+
+DISCRETE_A = jnp.array([[0.72, 0.08], [0.0, 0.65]])
+DISCRETE_Q = jnp.array([[0.05, 0.01], [0.01, 0.04]])
+GAUSSIAN_R = jnp.array([[0.45, 0.12], [0.12, 0.35]])
+INDEPENDENT_SCALE = jnp.array([0.45, 0.65])
+ODE_A = jnp.array([[-0.4, 0.2], [-0.1, -0.55]])
+
+
+def _nonlinear_observation_mean(x, u, t):
+    return jnp.array(
+        [
+            x[0] + 0.15 * x[1] ** 2,
+            x[1] - 0.1 * jnp.sin(t),
+        ]
+    )
+
+
+def _independent_observation_mean(x, u, t):
+    return jnp.array([x[0] + 0.25 * x[1], x[1] - 0.1 * t])
+
+
+def discrete_linear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=LinearGaussianStateEvolution(A=DISCRETE_A, cov=DISCRETE_Q),
+        observation_model=LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def discrete_nonlinear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=LinearGaussianStateEvolution(A=DISCRETE_A, cov=DISCRETE_Q),
+        observation_model=GaussianObservation(
+            h=_nonlinear_observation_mean, R=GAUSSIAN_R
+        ),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def discrete_independent_normal_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=LinearGaussianStateEvolution(A=DISCRETE_A, cov=DISCRETE_Q),
+        observation_model=lambda x, u, t: dist.Independent(
+            dist.Normal(_independent_observation_mean(x, u, t), INDEPENDENT_SCALE), 1
+        ),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def sampled_discrete_linear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    alpha = numpyro.sample("alpha", dist.Normal(0.72, 0.05))
+    A = DISCRETE_A.at[0, 0].set(alpha)
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=LinearGaussianStateEvolution(A=A, cov=DISCRETE_Q),
+        observation_model=LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def discrete_dirac_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=LinearGaussianStateEvolution(A=DISCRETE_A, cov=DISCRETE_Q),
+        observation_model=DiracIdentityObservation(),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def ode_linear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=ContinuousTimeStateEvolution(drift=lambda x, u, t: ODE_A @ x),
+        observation_model=LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def ode_nonlinear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=ContinuousTimeStateEvolution(drift=lambda x, u, t: ODE_A @ x),
+        observation_model=GaussianObservation(
+            h=_nonlinear_observation_mean, R=GAUSSIAN_R
+        ),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def ode_independent_normal_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=ContinuousTimeStateEvolution(drift=lambda x, u, t: ODE_A @ x),
+        observation_model=lambda x, u, t: dist.Independent(
+            dist.Normal(_independent_observation_mean(x, u, t), INDEPENDENT_SCALE), 1
+        ),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+def sampled_ode_linear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+):
+    alpha = numpyro.sample("alpha", dist.Normal(0.2, 0.05))
+    A = ODE_A.at[0, 1].set(alpha)
+    dynamics = DynamicalModel(
+        control_dim=0,
+        initial_condition=dist.MultivariateNormal(
+            loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+        ),
+        state_evolution=ContinuousTimeStateEvolution(drift=lambda x, u, t: A @ x),
+        observation_model=LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R),
+    )
+    dsx.sample(
+        "f",
+        dynamics,
+        obs_times=obs_times,
+        obs_values=obs_values,
+        predict_times=predict_times,
+    )
+
+
+class _PlateLinearTransition(eqx.Module):
+    A: jnp.ndarray
+
+    def __call__(self, x, u, t_now, t_next):
+        return x @ jnp.swapaxes(self.A, -1, -2)
+
+
+def plated_discrete_linear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+    M=2,
+):
+    with dsx.plate("trajectories", M):
+        alpha = jnp.linspace(0.65, 0.78, M)
+        A = jnp.broadcast_to(DISCRETE_A, (M, 2, 2)).copy().at[:, 0, 0].set(alpha)
+        dynamics = DynamicalModel(
+            control_dim=0,
+            initial_condition=dist.MultivariateNormal(
+                loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+            ),
+            state_evolution=GaussianStateEvolution(
+                F=_PlateLinearTransition(A=A), cov=DISCRETE_Q
+            ),
+            observation_model=LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R),
+        )
+        dsx.sample(
+            "f",
+            dynamics,
+            obs_times=obs_times,
+            obs_values=obs_values,
+            predict_times=predict_times,
+        )
+
+
+def plated_ode_linear_gaussian_model(
+    obs_times=None,
+    obs_values=None,
+    predict_times=None,
+    M=2,
+):
+    with dsx.plate("trajectories", M):
+        alpha = jnp.linspace(0.15, 0.3, M)
+        A = jnp.broadcast_to(ODE_A, (M, 2, 2)).copy().at[:, 0, 1].set(alpha)
+        dynamics = DynamicalModel(
+            control_dim=0,
+            initial_condition=dist.MultivariateNormal(
+                loc=jnp.zeros(2), covariance_matrix=0.5 * jnp.eye(2)
+            ),
+            state_evolution=ContinuousTimeStateEvolution(drift=AffineDrift(A=A)),
+            observation_model=LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R),
+        )
+        dsx.sample(
+            "f",
+            dynamics,
+            obs_times=obs_times,
+            obs_values=obs_values,
+            predict_times=predict_times,
+        )
diff --git a/tests/missingness/test_discrete_simulator.py b/tests/missingness/test_discrete_simulator.py
new file mode 100644
index 0000000..cdfa695
--- /dev/null
+++ b/tests/missingness/test_discrete_simulator.py
@@ -0,0 +1,188 @@
+import jax.numpy as jnp
+import jax.random as jr
+import pytest
+from numpyro.handlers import condition, seed, trace
+from numpyro.infer import MCMC, NUTS, Predictive
+
+from dynestyx import DiscreteTimeSimulator
+from tests.missingness.models import (
+    GAUSSIAN_R,
+    INDEPENDENT_SCALE,
+    _independent_observation_mean,
+    _nonlinear_observation_mean,
+    discrete_dirac_model,
+    discrete_independent_normal_model,
+    discrete_linear_gaussian_model,
+    discrete_nonlinear_gaussian_model,
+    sampled_discrete_linear_gaussian_model,
+)
+from tests.missingness.utils import (
+    latent_conditioning_data,
+    manual_masked_independent_normal_log_prob,
+    manual_masked_mvn_log_prob,
+    observation_log_probs,
+    set_full_row_missing,
+    set_partial_row_missing,
+)
+
+
+def _run_discrete_trace(model, *, obs_times=None, obs_values=None, predict_times=None):
+    with DiscreteTimeSimulator():
+        with trace() as tr, seed(rng_seed=jr.PRNGKey(0)):
+            model(
+                obs_times=obs_times,
+                obs_values=obs_values,
+                predict_times=predict_times,
+            )
+    return tr
+
+
+def test_discrete_no_missing_conditioning_uses_log_potential_path():
+    times = jnp.arange(5.0)
+    forward = _run_discrete_trace(discrete_linear_gaussian_model, predict_times=times)
+    obs_values = forward["f_observations"]["value"][0]
+    latent_data = latent_conditioning_data(forward)
+
+    conditioned_model = condition(discrete_linear_gaussian_model, data=latent_data)
+    conditioned = _run_discrete_trace(
+        conditioned_model, obs_times=times, obs_values=obs_values
+    )
+
+    actual = observation_log_probs(conditioned)
+    states = conditioned["f_states"]["value"][0]
+    expected = jnp.stack(
+        [
+            manual_masked_mvn_log_prob(
+                states[k],
+                GAUSSIAN_R,
+                obs_values[k],
+                jnp.ones_like(obs_values[k], dtype=bool),
+            )
+            for k in range(len(times))
+        ]
+    )
+    assert not any(
+        name.startswith("f_y_") and not name.endswith("_lp") for name in conditioned
+    )
+    assert jnp.allclose(actual, expected)
+
+
+@pytest.mark.parametrize(
+    ("model", "mean_fn"),
+    [
+        (discrete_linear_gaussian_model, lambda x, t: x),
+        (
+            discrete_nonlinear_gaussian_model,
+            lambda x, t: _nonlinear_observation_mean(x, None, t),
+        ),
+    ],
+)
+def test_discrete_gaussian_missingness_factor_values_match_manual_reference(
+    model,
+    mean_fn,
+):
+    times = jnp.arange(5.0)
+    forward = _run_discrete_trace(model, predict_times=times)
+    obs_values = forward["f_observations"]["value"][0]
+    latent_data = latent_conditioning_data(forward)
+    obs_values = set_full_row_missing(obs_values, 1)
+    obs_values = set_partial_row_missing(obs_values, 3, dim_idx=0)
+
+    conditioned_model = condition(model, data=latent_data)
+    conditioned = _run_discrete_trace(
+        conditioned_model, obs_times=times, obs_values=obs_values
+    )
+
+    states = conditioned["f_states"]["value"][0]
+    observations = conditioned["f_observations"]["value"][0]
+    assert states.shape == (len(times), 2)
+    assert observations.shape == (len(times), 2)
+    assert jnp.array_equal(jnp.isnan(observations), jnp.isnan(obs_values))
+    assert jnp.allclose(jnp.nan_to_num(observations), jnp.nan_to_num(obs_values))
+
+    expected = []
+    for k in range(len(times)):
+        mask = jnp.isfinite(obs_values[k])
+        safe_obs = jnp.where(mask, obs_values[k], 0.0)
+        mu = mean_fn(states[k], times[k])
+        expected.append(manual_masked_mvn_log_prob(mu, GAUSSIAN_R, safe_obs, mask))
+
+    actual = observation_log_probs(conditioned)
+    assert jnp.allclose(actual, jnp.stack(expected))
+
+
+def test_discrete_independent_missingness_factor_values_match_manual_reference():
+    times = jnp.arange(5.0)
+    forward = _run_discrete_trace(
+        discrete_independent_normal_model, predict_times=times
+    )
+    obs_values = forward["f_observations"]["value"][0]
+    latent_data = latent_conditioning_data(forward)
+    obs_values = set_full_row_missing(obs_values, 2)
+    obs_values = set_partial_row_missing(obs_values, 4, dim_idx=1)
+
+    conditioned_model = condition(discrete_independent_normal_model, data=latent_data)
+    conditioned = _run_discrete_trace(
+        conditioned_model, obs_times=times, obs_values=obs_values
+    )
+
+    states = conditioned["f_states"]["value"][0]
+    observations = conditioned["f_observations"]["value"][0]
+    assert jnp.array_equal(jnp.isnan(observations), jnp.isnan(obs_values))
+    assert jnp.allclose(jnp.nan_to_num(observations), jnp.nan_to_num(obs_values))
+
+    expected = []
+    for k in range(len(times)):
+        mask = jnp.isfinite(obs_values[k])
+        safe_obs = jnp.where(mask, obs_values[k], 0.0)
+        loc = _independent_observation_mean(states[k], None, times[k])
+        expected.append(
+            manual_masked_independent_normal_log_prob(
+                loc, INDEPENDENT_SCALE, safe_obs, mask
+            )
+        )
+
+    actual = observation_log_probs(conditioned)
+    assert jnp.allclose(actual, jnp.stack(expected))
+
+
+def test_discrete_missingness_mcmc_smoke():
+    times = jnp.arange(5.0)
+    predictive = Predictive(
+        sampled_discrete_linear_gaussian_model,
+        params={"alpha": jnp.array(0.72)},
+        num_samples=1,
+        exclude_deterministic=False,
+    )
+    with DiscreteTimeSimulator():
+        generated = predictive(jr.PRNGKey(1), predict_times=times)
+    obs_values = generated["f_observations"][0, 0]
+    obs_values = set_full_row_missing(obs_values, 1)
+    obs_values = set_partial_row_missing(obs_values, 3, dim_idx=0)
+
+    with DiscreteTimeSimulator():
+        mcmc = MCMC(
+            NUTS(sampled_discrete_linear_gaussian_model),
+            num_samples=1,
+            num_warmup=1,
+            progress_bar=False,
+        )
+        mcmc.run(jr.PRNGKey(2), obs_times=times, obs_values=obs_values)
+
+    assert "alpha" in mcmc.get_samples()
+
+
+def test_discrete_dirac_missingness_raises_clear_error():
+    times = jnp.arange(5.0)
+    forward = _run_discrete_trace(discrete_dirac_model, predict_times=times)
+    obs_values = forward["f_observations"]["value"][0]
+    obs_values = set_full_row_missing(obs_values, 2)
+
+    with pytest.raises(
+        ValueError,
+        match="NaN-valued obs_values are not currently supported with "
+        "DiracIdentityObservation under DiscreteTimeSimulator",
+    ):
+        _run_discrete_trace(
+            discrete_dirac_model, obs_times=times, obs_values=obs_values
+        )
diff --git a/tests/missingness/test_hierarchical.py b/tests/missingness/test_hierarchical.py
new file mode 100644
index 0000000..4a39252
--- /dev/null
+++ b/tests/missingness/test_hierarchical.py
@@ -0,0 +1,113 @@
+import jax.numpy as jnp
+import jax.random as jr
+from numpyro.handlers import condition, seed, trace
+
+from dynestyx import DiscreteTimeSimulator, ODESimulator
+from tests.missingness.models import (
+    GAUSSIAN_R,
+    plated_discrete_linear_gaussian_model,
+    plated_ode_linear_gaussian_model,
+)
+from tests.missingness.utils import (
+    latent_conditioning_data,
+    manual_masked_mvn_log_prob,
+    observation_log_probs,
+    set_full_row_missing,
+    set_partial_row_missing,
+)
+
+
+def _run_plated_discrete_trace(model, *, times, obs_values=None, M=2):
+    with DiscreteTimeSimulator():
+        with trace() as tr, seed(rng_seed=jr.PRNGKey(0)):
+            model(
+                obs_times=times if obs_values is not None else None,
+                obs_values=obs_values,
+                predict_times=None if obs_values is not None else times,
+                M=M,
+            )
+    return tr
+
+
+def _run_plated_ode_trace(model, *, times, obs_values=None, M=2):
+    with ODESimulator():
+        with trace() as tr, seed(rng_seed=jr.PRNGKey(0)):
+            model(
+                obs_times=times if obs_values is not None else None,
+                obs_values=obs_values,
+                predict_times=None if obs_values is not None else times,
+                M=M,
+            )
+    return tr
+
+
+def test_hierarchical_discrete_missingness_preserves_shapes_and_member_local_factors():
+    M = 2
+    times = jnp.arange(4.0)
+    forward = _run_plated_discrete_trace(
+        plated_discrete_linear_gaussian_model, times=times, M=M
+    )
+    obs_values = forward["f_observations"]["value"][:, 0]
+    latent_data = latent_conditioning_data(forward)
+
+    obs_values = set_full_row_missing(obs_values, 1, member_idx=0)
+    obs_values = set_partial_row_missing(obs_values, 2, dim_idx=1, member_idx=1)
+
+    conditioned_model = condition(
+        plated_discrete_linear_gaussian_model, data=latent_data
+    )
+    conditioned = _run_plated_discrete_trace(
+        conditioned_model, times=times, obs_values=obs_values, M=M
+    )
+
+    states = conditioned["f_states"]["value"]
+    observations = conditioned["f_observations"]["value"]
+    assert states.shape == (M, 1, len(times), 2)
+    assert observations.shape == (M, 1, len(times), 2)
+    assert jnp.array_equal(jnp.isnan(observations[:, 0]), jnp.isnan(obs_values))
+
+    member1_state = states[1, 0, 2]
+    member0_log_probs = observation_log_probs(conditioned, prefix="f_p0_y")
+    assert jnp.allclose(member0_log_probs[1], 0.0)
+
+    member1_mask = jnp.isfinite(obs_values[1, 2])
+    member1_safe_obs = jnp.where(member1_mask, obs_values[1, 2], 0.0)
+    expected_member1 = manual_masked_mvn_log_prob(
+        member1_state, GAUSSIAN_R, member1_safe_obs, member1_mask
+    )
+    actual_member1 = observation_log_probs(conditioned, prefix="f_p1_y")[2]
+    assert jnp.allclose(actual_member1, expected_member1)
+
+
+def test_hierarchical_ode_missingness_preserves_shapes_and_member_local_factors():
+    M = 2
+    times = jnp.linspace(0.0, 0.4, 5)
+    forward = _run_plated_ode_trace(plated_ode_linear_gaussian_model, times=times, M=M)
+    obs_values = forward["f_observations"]["value"][:, 0]
+    latent_data = latent_conditioning_data(forward)
+
+    obs_values = set_full_row_missing(obs_values, 1, member_idx=0)
+    obs_values = set_partial_row_missing(obs_values, 3, dim_idx=0, member_idx=1)
+
+    conditioned_model = condition(plated_ode_linear_gaussian_model, data=latent_data)
+    conditioned = _run_plated_ode_trace(
+        conditioned_model, times=times, obs_values=obs_values, M=M
+    )
+
+    states = conditioned["f_states"]["value"]
+    observations = conditioned["f_observations"]["value"]
+    assert states.shape == (M, 1, len(times), 2)
+    assert observations.shape == (M, 1, len(times), 2)
+    assert jnp.array_equal(jnp.isnan(observations[:, 0]), jnp.isnan(obs_values))
+
+    member0_log_probs = observation_log_probs(conditioned, prefix="f_p0_y")
+    assert jnp.allclose(member0_log_probs[1], 0.0)
+
+    member1_state = states[1, 0, 3]
+    member1_mask = jnp.isfinite(obs_values[1, 3])
+    member1_safe_obs = jnp.where(member1_mask, obs_values[1, 3], 0.0)
+    expected_member1 = manual_masked_mvn_log_prob(
+        member1_state, GAUSSIAN_R, member1_safe_obs, member1_mask
+    )
+    actual_member1 = observation_log_probs(conditioned, prefix="f_p1_y")[3]
+    assert jnp.allclose(actual_member1, expected_member1)
diff --git a/tests/missingness/test_observation_log_potential.py b/tests/missingness/test_observation_log_potential.py
new file mode 100644
index 0000000..48d0027
--- /dev/null
+++ b/tests/missingness/test_observation_log_potential.py
@@ -0,0 +1,168 @@
+import jax.numpy as jnp
+import numpyro.distributions as dist
+import pytest
+
+from dynestyx.internal.observation_missingness import (
+    ObservationLogPotential,
+    _masked_multivariate_normal_log_prob,
+)
+from dynestyx.models import DynamicalModel, LinearGaussianObservation
+from tests.missingness.models import GAUSSIAN_R, INDEPENDENT_SCALE
+from tests.missingness.utils import (
+    manual_masked_independent_normal_log_prob,
+    manual_masked_mvn_log_prob,
+)
+
+
+def _build_vector_dynamics(observation_model):
+    return DynamicalModel(
+        initial_condition=dist.MultivariateNormal(jnp.zeros(2), jnp.eye(2)),
+        state_evolution=lambda x, u, t_now, t_next: dist.MultivariateNormal(
+            x, jnp.eye(2)
+        ),
+        observation_model=observation_model,
+        control_dim=0,
+    )
+
+
+def _build_scalar_dynamics(observation_model):
+    return DynamicalModel(
+        initial_condition=dist.Normal(0.0, 1.0),
+        state_evolution=lambda x, u, t_now, t_next: dist.Normal(x, 1.0),
+        observation_model=observation_model,
+        control_dim=0,
+    )
+
+
+def test_observation_log_potential_init_tracks_partial_and_full_row_missingness():
+    obs_values = jnp.array(
+        [
+            [1.0, 2.0],
+            [jnp.nan, 3.0],
+            [jnp.nan, jnp.nan],
+        ]
+    )
+
+    log_potential = ObservationLogPotential(
+        dynamics=_build_vector_dynamics(
+            lambda x, u, t: dist.MultivariateNormal(
+                jnp.zeros(2), covariance_matrix=jnp.eye(2)
+            )
+        ),
+        obs_values=obs_values,
+    )
+
+    assert log_potential.has_missing
+    assert log_potential.has_partial_missing
+    assert log_potential.has_fully_missing_rows
+    assert jnp.array_equal(
+        log_potential.obs_mask,
+        jnp.array([[True, True], [False, True], [False, False]]),
+    )
+    assert jnp.allclose(log_potential.safe_obs[0], obs_values[0])
+    assert jnp.allclose(log_potential.safe_obs[1], jnp.array([0.0, 3.0]))
+
+
+def test_masked_multivariate_normal_log_prob_matches_manual_subset_formula():
+    mu = jnp.array([0.3, -0.2])
+    y = jnp.array([1.0, 0.0])
+    obs_mask = jnp.array([True, False])
+    obs_dist = dist.MultivariateNormal(mu, covariance_matrix=GAUSSIAN_R)
+
+    actual = _masked_multivariate_normal_log_prob(obs_dist, y, obs_mask)
+    expected = manual_masked_mvn_log_prob(mu, GAUSSIAN_R, y, obs_mask)
+
+    assert jnp.allclose(actual, expected)
+
+
+def test_masked_independent_distribution_matches_manual_subset_formula():
+    loc = jnp.array([0.4, -0.7])
+    y = jnp.array([1.2, 0.0])
+    obs_mask = jnp.array([True, False])
+    obs_dist = dist.Independent(dist.Normal(loc, INDEPENDENT_SCALE), 1)
+
+    actual = obs_dist.base_dist.mask(obs_mask).to_event(1).log_prob(y)
+    expected = manual_masked_independent_normal_log_prob(
+        loc, INDEPENDENT_SCALE, y, obs_mask
+    )
+
+    assert jnp.allclose(actual, expected)
+
+
+def test_observation_log_potential_scalar_rows_zero_out_full_missing_steps():
+    obs_values = jnp.array([jnp.nan, 1.25])
+    log_potential = ObservationLogPotential(
+        dynamics=_build_scalar_dynamics(lambda x, u, t: dist.Normal(x + t, 0.4)),
+        obs_values=obs_values,
+    )
+
+    assert jnp.allclose(
+        log_potential.log_potential_step(
+            x=jnp.array(0.2), u=None, t=jnp.array(0.0), t_idx=0
+        ),
+        0.0,
+    )
+    assert jnp.allclose(
+        log_potential.log_potential_step(
+            x=jnp.array(0.2), u=None, t=jnp.array(1.0), t_idx=1
+        ),
+        dist.Normal(1.2, 0.4).log_prob(1.25),
+    )
+
+
+def test_observation_log_potential_partial_missing_unsupported_distribution_raises_at_init():
+    obs_values = jnp.array([[1.0, jnp.nan]])
+    with pytest.raises(
+        NotImplementedError,
+        match="Partial missingness currently requires",
+    ):
+        ObservationLogPotential(
+            dynamics=_build_vector_dynamics(lambda x, u, t: dist.Delta(x, event_dim=1)),
+            obs_values=obs_values,
+        )
+
+
+def test_observation_log_potential_can_fail_late_if_distribution_type_changes():
+    obs_values = jnp.array([[1.0, jnp.nan], [1.0, jnp.nan]])
+
+    def observation_model(x, u, t):
+        if float(t) < 0.5:
+            return dist.MultivariateNormal(x, covariance_matrix=GAUSSIAN_R)
+        return dist.Delta(x, event_dim=1)
+
+    log_potential = ObservationLogPotential(
+        dynamics=_build_vector_dynamics(observation_model),
+        obs_values=obs_values,
+    )
+
+    with pytest.raises(Exception, match="obs_dist"):
+        log_potential.log_potential_step(
+            x=jnp.array([1.0, 2.0]),
+            u=None,
+            t=jnp.array(1.0),
+            t_idx=1,
+        )
+
+
+def test_observation_log_potential_linear_gaussian_matches_manual_reference():
+    obs_values = jnp.array([[jnp.nan, 0.2]])
+    log_potential = ObservationLogPotential(
+        dynamics=_build_vector_dynamics(
+            LinearGaussianObservation(H=jnp.eye(2), R=GAUSSIAN_R)
+        ),
+        obs_values=obs_values,
+    )
+    x = jnp.array([0.5, -0.3])
+    actual = log_potential.log_potential_step(
+        x=x,
+        u=None,
+        t=jnp.array(0.0),
+        t_idx=0,
+    )
+    expected = manual_masked_mvn_log_prob(
+        x,
+        GAUSSIAN_R,
+        jnp.array([0.0, 0.2]),
+        jnp.array([False, True]),
+    )
+    assert jnp.allclose(actual, expected)
diff --git a/tests/missingness/test_ode_simulator.py b/tests/missingness/test_ode_simulator.py
new file mode 100644
index 0000000..368c525
--- /dev/null
+++ b/tests/missingness/test_ode_simulator.py
@@ -0,0 +1,168 @@
+import jax.numpy as jnp
+import jax.random as jr
+import pytest
+from numpyro.handlers import condition, seed, trace
+from numpyro.infer import MCMC, NUTS, Predictive
+
+from dynestyx import ODESimulator
+from tests.missingness.models import (
+    GAUSSIAN_R,
+    INDEPENDENT_SCALE,
+    _independent_observation_mean,
+    _nonlinear_observation_mean,
+    ode_independent_normal_model,
+    ode_linear_gaussian_model,
+    ode_nonlinear_gaussian_model,
+    sampled_ode_linear_gaussian_model,
+)
+from tests.missingness.utils import (
+    latent_conditioning_data,
+    manual_masked_independent_normal_log_prob,
+    manual_masked_mvn_log_prob,
+    observation_log_probs,
+    set_full_row_missing,
+    set_partial_row_missing,
+)
+
+
+def _run_ode_trace(model, *, obs_times=None, obs_values=None, predict_times=None):
+    with ODESimulator():
+        with trace() as tr, seed(rng_seed=jr.PRNGKey(0)):
+            model(
+                obs_times=obs_times,
+                obs_values=obs_values,
+                predict_times=predict_times,
+            )
+    return tr
+
+
+def test_ode_no_missing_conditioning_uses_log_potential_path():
+    times = jnp.linspace(0.0, 0.4, 5)
+    forward = _run_ode_trace(ode_linear_gaussian_model, predict_times=times)
+    obs_values = forward["f_observations"]["value"][0]
+    latent_data = latent_conditioning_data(forward)
+
+    conditioned_model = condition(ode_linear_gaussian_model, data=latent_data)
+    conditioned = _run_ode_trace(
+        conditioned_model, obs_times=times, obs_values=obs_values
+    )
+
+    actual = observation_log_probs(conditioned)
+    states = conditioned["f_states"]["value"][0]
+    expected = jnp.stack(
+        [
+            manual_masked_mvn_log_prob(
+                states[k],
+                GAUSSIAN_R,
+                obs_values[k],
+                jnp.ones_like(obs_values[k], dtype=bool),
+            )
+            for k in range(len(times))
+        ]
+    )
+    assert not any(
+        name.startswith("f_y_") and not name.endswith("_lp") for name in conditioned
+    )
+    assert jnp.allclose(actual, expected)
+
+
+@pytest.mark.parametrize(
+    ("model", "mean_fn"),
+    [
+        (ode_linear_gaussian_model, lambda x, t: x),
+        (
+            ode_nonlinear_gaussian_model,
+            lambda x, t: _nonlinear_observation_mean(x, None, t),
+        ),
+    ],
+)
+def test_ode_gaussian_missingness_factor_values_match_manual_reference(
+    model,
+    mean_fn,
+):
+    times = jnp.linspace(0.0, 0.4, 5)
+    forward = _run_ode_trace(model, predict_times=times)
+    obs_values = forward["f_observations"]["value"][0]
+    latent_data = latent_conditioning_data(forward)
+    obs_values = set_full_row_missing(obs_values, 1)
+    obs_values = set_partial_row_missing(obs_values, 3, dim_idx=1)
+
+    conditioned_model = condition(model, data=latent_data)
+    conditioned = _run_ode_trace(
+        conditioned_model, obs_times=times, obs_values=obs_values
+    )
+
+    states = conditioned["f_states"]["value"][0]
+    observations = conditioned["f_observations"]["value"][0]
+    assert states.shape == (len(times), 2)
+    assert jnp.array_equal(jnp.isnan(observations), jnp.isnan(obs_values))
+    assert jnp.allclose(jnp.nan_to_num(observations), jnp.nan_to_num(obs_values))
+
+    expected = []
+    for k in range(len(times)):
+        mask = jnp.isfinite(obs_values[k])
+        safe_obs = jnp.where(mask, obs_values[k], 0.0)
+        mu = mean_fn(states[k], times[k])
+        expected.append(manual_masked_mvn_log_prob(mu, GAUSSIAN_R, safe_obs, mask))
+
+    actual = observation_log_probs(conditioned)
+    assert jnp.allclose(actual, jnp.stack(expected))
+
+
+def test_ode_independent_missingness_factor_values_match_manual_reference():
+    times = jnp.linspace(0.0, 0.4, 5)
+    forward = _run_ode_trace(ode_independent_normal_model, predict_times=times)
+    obs_values = forward["f_observations"]["value"][0]
+    latent_data = latent_conditioning_data(forward)
+    obs_values = set_full_row_missing(obs_values, 2)
+    obs_values = set_partial_row_missing(obs_values, 4, dim_idx=0)
+
+    conditioned_model = condition(ode_independent_normal_model, data=latent_data)
+    conditioned = _run_ode_trace(
+        conditioned_model, obs_times=times, obs_values=obs_values
+    )
+
+    states = conditioned["f_states"]["value"][0]
+    observations = conditioned["f_observations"]["value"][0]
+    assert jnp.array_equal(jnp.isnan(observations), jnp.isnan(obs_values))
+    assert jnp.allclose(jnp.nan_to_num(observations), jnp.nan_to_num(obs_values))
+
+    expected = []
+    for k in range(len(times)):
+        mask = jnp.isfinite(obs_values[k])
+        safe_obs = jnp.where(mask, obs_values[k], 0.0)
+        loc = _independent_observation_mean(states[k], None, times[k])
+        expected.append(
+            manual_masked_independent_normal_log_prob(
+                loc, INDEPENDENT_SCALE, safe_obs, mask
+            )
+        )
+
+    actual = observation_log_probs(conditioned)
+    assert jnp.allclose(actual, jnp.stack(expected))
+
+
+def test_ode_missingness_mcmc_smoke():
+    times = jnp.linspace(0.0, 0.4, 5)
+    predictive = Predictive(
+        sampled_ode_linear_gaussian_model,
+        params={"alpha": jnp.array(0.2)},
+        num_samples=1,
+        exclude_deterministic=False,
+    )
+    with ODESimulator():
+        generated = predictive(jr.PRNGKey(1), predict_times=times)
+    obs_values = generated["f_observations"][0, 0]
+    obs_values = set_full_row_missing(obs_values, 1)
+    obs_values = set_partial_row_missing(obs_values, 3, dim_idx=1)
+
+    with ODESimulator():
+        mcmc = MCMC(
+            NUTS(sampled_ode_linear_gaussian_model),
+            num_samples=1,
+            num_warmup=1,
+            progress_bar=False,
+        )
+        mcmc.run(jr.PRNGKey(2), obs_times=times, obs_values=obs_values)
+
+    assert "alpha" in mcmc.get_samples()
diff --git a/tests/missingness/utils.py b/tests/missingness/utils.py
new file mode 100644
index 0000000..50c3480
--- /dev/null
+++ b/tests/missingness/utils.py
@@ -0,0 +1,79 @@
+import jax.numpy as jnp
+import numpy as np
+import numpyro.distributions as dist
+
+
+def set_full_row_missing(obs_values, row_idx, *, member_idx=None):
+    if member_idx is None:
+        return obs_values.at[row_idx].set(jnp.nan)
+    return obs_values.at[member_idx, row_idx].set(jnp.nan)
+
+
+def set_partial_row_missing(obs_values, row_idx, dim_idx=0, *, member_idx=None):
+    if member_idx is None:
+        return obs_values.at[row_idx, dim_idx].set(jnp.nan)
+    return obs_values.at[member_idx, row_idx, dim_idx].set(jnp.nan)
+
+
+def manual_masked_mvn_log_prob(mu, cov, y, obs_mask):
+    obs_mask_np = np.asarray(obs_mask, dtype=bool)
+    if obs_mask_np.ndim == 0:
+        if not obs_mask_np.item():
+            return jnp.array(0.0)
+        return dist.Normal(mu, jnp.sqrt(cov)).log_prob(y)
+
+    if not obs_mask_np.any():
+        return jnp.array(0.0, dtype=jnp.asarray(mu).dtype)
+
+    mu_obs = jnp.asarray(mu)[obs_mask_np]
+    y_obs = jnp.asarray(y)[obs_mask_np]
+    cov_obs = jnp.asarray(cov)[np.ix_(obs_mask_np, obs_mask_np)]
+    return dist.MultivariateNormal(mu_obs, covariance_matrix=cov_obs).log_prob(y_obs)
+
+
+def manual_masked_independent_normal_log_prob(loc, scale, y, obs_mask):
+    obs_mask_np = np.asarray(obs_mask, dtype=bool)
+    if obs_mask_np.ndim == 0:
+        if not obs_mask_np.item():
+            return jnp.array(0.0)
+        return dist.Normal(loc, scale).log_prob(y)
+
+    if not obs_mask_np.any():
+        return jnp.array(0.0, dtype=jnp.asarray(loc).dtype)
+
+    loc = jnp.asarray(loc)
+    scale = jnp.asarray(scale)
+    y = jnp.asarray(y)
+    per_dim = dist.Normal(loc, scale).log_prob(y)
+    return jnp.sum(per_dim[obs_mask_np])
+
+
+def latent_conditioning_data(trace):
+    return {
+        name: site["value"]
+        for name, site in trace.items()
+        if site["type"] == "sample" and "_x_" in name
+    }
+
+
+def factor_log_prob(trace, name):
+    return jnp.asarray(trace[name]["fn"].log_factor)
+
+
+def observation_site_names(trace, *, prefix="f_y"):
+    return [
+        name for name in trace if name.startswith(prefix) and not name.endswith("_lp")
+    ]
+
+
+def observation_log_probs(trace, *, prefix="f_y"):
+    pieces = [
+        jnp.ravel(factor_log_prob(trace, name))
+        for name in trace
+        if name.startswith(prefix) and name.endswith("_lp")
+    ]
+
+    if not pieces:
+        raise KeyError(f"No observation log-prob sites found for prefix {prefix!r}.")
+
+    return jnp.concatenate(pieces)