diff --git a/docs/tutorials/control/control_optimization.ipynb b/docs/tutorials/control/control_optimization.ipynb new file mode 100644 index 00000000..fd79dfe1 --- /dev/null +++ b/docs/tutorials/control/control_optimization.ipynb @@ -0,0 +1,454 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "02ba24af", + "metadata": {}, + "source": [ + "# Learning the control: optimizing a linear feedback control\n", + "\n", + "\n", + "This notebook demonstrates how to optimize a simple feedback control by computing gradients through `DiscreteControlLoopSimulator`\n", + "We use:\n", + "1. a simple 1D linear-Gaussian dynamical system (a noisy random walk, `x_{k+1} = A x_k + B u_k + noise`) with the full state directly observed under Gaussian noise,\n", + "2. a linear feedback policy `u_k = -K x_hat_k` that drives the state toward 0,\n", + "3. a plot comparing the controlled trajectory against an uncontrolled (`K=0`) baseline." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ccd86c86", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:12.674337Z", + "iopub.status.busy": "2026-07-31T14:38:12.674168Z", + "iopub.status.idle": "2026-07-31T14:38:14.308456Z", + "shell.execute_reply": "2026-07-31T14:38:14.308142Z" + } + }, + "outputs": [], + "source": [ + "import equinox as eqx\n", + "import jax.numpy as jnp\n", + "import matplotlib.pyplot as plt\n", + "import numpyro\n", + "import numpyro.distributions as dist\n", + "from numpyro.handlers import seed\n", + "\n", + "import dynestyx as dsx\n", + "from dynestyx.control.discrete_controller_simulators import DiscreteControlLoopSimulator, filter_state_mean\n", + "from dynestyx.inference.configs.filter import KFConfig\n", + "from dynestyx.models import DynamicalModel\n", + "from dynestyx.models.observations import LinearGaussianObservation\n", + "from dynestyx.models.state_evolution import LinearGaussianStateEvolution\n", + "\n", + "\n", + "import jax\n", + "import optax\n", + "from optax import sgd, adam" + ] + }, + { + "cell_type": "markdown", + "id": "dc797c14", + "metadata": {}, + "source": [ + "## 1. Define the dynamics\n", + "\n", + "`state_dim = control_dim = observation_dim = 1`. The transition is `x_{k+1} = A x_k + B u_k + noise`, with `A = 1` -- a marginally-unstable random walk when uncontrolled, so the effect of feedback control is visually obvious. The observation model directly observes the full state under additive Gaussian noise (`H = I`, no control dependence)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6257e9bd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:14.309707Z", + "iopub.status.busy": "2026-07-31T14:38:14.309601Z", + "iopub.status.idle": "2026-07-31T14:38:14.441687Z", + "shell.execute_reply": "2026-07-31T14:38:14.441409Z" + } + }, + "outputs": [], + "source": [ + "state_dim = control_dim = obs_dim = 2\n", + "\n", + "dynamics = DynamicalModel(\n", + " initial_condition=dist.MultivariateNormal(jnp.array([0.0, 0.0]), 5.0 * jnp.eye(state_dim)),\n", + " state_evolution=LinearGaussianStateEvolution(\n", + " A=jnp.eye(state_dim), B=jnp.eye(control_dim), cov=0.05 * jnp.eye(state_dim)\n", + " ),\n", + " observation_model=LinearGaussianObservation(\n", + " H=jnp.eye(obs_dim, state_dim), R=0.2 * jnp.eye(obs_dim)\n", + " ),\n", + " control_dim=control_dim,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "96175f05", + "metadata": {}, + "source": [ + "## 2. Define the controller\n", + "\n", + "A simple linear feedback policy `u = -K x_hat`, implemented as an `equinox.Module`." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5a9993d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:14.443202Z", + "iopub.status.busy": "2026-07-31T14:38:14.443121Z", + "iopub.status.idle": "2026-07-31T14:38:14.445643Z", + "shell.execute_reply": "2026-07-31T14:38:14.445189Z" + } + }, + "outputs": [], + "source": [ + "class LinearPolicy(eqx.Module):\n", + " K: jnp.ndarray\n", + "\n", + " def __call__(self, x_hat, s, key):\n", + " return -self.K @ filter_state_mean(x_hat), s" + ] + }, + { + "cell_type": "markdown", + "id": "21c5b513", + "metadata": {}, + "source": [ + "## 3. Differentiating through the closed loop\n", + "\n", + "`DiscreteControlLoopSimulator` is pure JAX under the hood and so we can compute gradients. Since this doesn't need NumPyro's tracing machinery (no conditioning, no MCMC), we call `sim.simulate(dynamics, rng_key=..., predict_times=...)` directly instead of going through `dsx.sample`/`numpyro.handlers.seed` -- this makes the PRNG key explicit, which matters once we optimize `K` over many epochs in section 4: each epoch gets a fresh key rather than reusing the same fixed noise realization, so the optimizer can't simply overfit `K` to one specific trajectory." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "b05b434c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:14.446701Z", + "iopub.status.busy": "2026-07-31T14:38:14.446636Z", + "iopub.status.idle": "2026-07-31T14:38:15.892601Z", + "shell.execute_reply": "2026-07-31T14:38:15.892351Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Initial loss value: 5.538885\n", + "Gradient of loss w.r.t K: [[-14.676369 -10.56624 ]\n", + " [ -8.130766 -5.853739]]\n" + ] + } + ], + "source": [ + "predict_times_short = jnp.arange(0.0, 5.0)\n", + "\n", + "\n", + "def rollout_final_state_norm(K, key):\n", + " policy = LinearPolicy(K=K)\n", + " sim = DiscreteControlLoopSimulator(\n", + " control_policy=policy,\n", + " policy_state_init=None,\n", + " filter_config=KFConfig(filter_source=\"cuthbert\"),\n", + " )\n", + " result = sim.simulate(dynamics, rng_key=key, predict_times=predict_times_short)\n", + " final_state = result.states[0, -1, :]\n", + " return jnp.linalg.norm(final_state)\n", + "\n", + "\n", + "K0 = jnp.eye(state_dim) * 1e-1\n", + "key0 = jax.random.PRNGKey(0)\n", + "loss_value = rollout_final_state_norm(K0, key0)\n", + "grad_K = jax.grad(rollout_final_state_norm)(K0, key0)\n", + "print(\"Initial loss value:\", loss_value)\n", + "print(\"Gradient of loss w.r.t K:\", grad_K)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "b84628d7", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:15.893592Z", + "iopub.status.busy": "2026-07-31T14:38:15.893537Z", + "iopub.status.idle": "2026-07-31T14:38:16.243371Z", + "shell.execute_reply": "2026-07-31T14:38:16.243140Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "autodiff grad_K[0, 0]: -14.676369\n", + "finite-difference estimate: -14.676332\n", + "OK: matches within tolerance\n" + ] + } + ], + "source": [ + "# Finite-difference check for one entry of K (K[0, 0]) which confirms the\n", + "# autodiff gradient through the whole closed loop is correct.\n", + "eps = 1e-3\n", + "K_plus = K0.at[0, 0].add(eps)\n", + "K_minus = K0.at[0, 0].add(-eps)\n", + "finite_diff = (\n", + " rollout_final_state_norm(K_plus, key0) - rollout_final_state_norm(K_minus, key0)\n", + ") / (2 * eps)\n", + "\n", + "print(f\"autodiff grad_K[0, 0]: {grad_K[0, 0]:.6f}\")\n", + "print(f\"finite-difference estimate: {finite_diff:.6f}\")\n", + "assert jnp.allclose(grad_K[0, 0], finite_diff, atol=1e-3)\n", + "print(\"OK: matches within tolerance\")" + ] + }, + { + "cell_type": "markdown", + "id": "0fae0c98", + "metadata": {}, + "source": [ + "# 4. Optimizing the controller\n", + "\n", + "Here we optimize the control matrix $K$ by unrolling forward over a short time and sampling a new initial condition at each optimization step." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "394573ba", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:16.244438Z", + "iopub.status.busy": "2026-07-31T14:38:16.244386Z", + "iopub.status.idle": "2026-07-31T14:38:59.059188Z", + "shell.execute_reply": "2026-07-31T14:38:59.058880Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 0: Loss=2.6394, K=[[0.10999993 0.00999993]\n", + " [0.00999993 0.10999993]]\n", + "Epoch 10: Loss=2.1864, K=[[ 0.17811827 -0.01132447]\n", + " [-0.0058398 0.17027593]]\n", + "Epoch 20: Loss=1.1784, K=[[ 0.2542053 -0.01834987]\n", + " [-0.03070187 0.23029748]]\n", + "Epoch 30: Loss=0.8324, K=[[ 0.3045337 0.00152742]\n", + " [-0.02864028 0.29052168]]\n", + "Epoch 40: Loss=0.3923, K=[[ 0.35525057 0.0017233 ]\n", + " [-0.01739779 0.3305604 ]]\n", + "Epoch 50: Loss=1.0520, K=[[ 0.40615872 -0.00147044]\n", + " [-0.01411944 0.37170437]]\n", + "Epoch 60: Loss=1.3664, K=[[ 0.43990442 0.01074153]\n", + " [-0.00952533 0.4138038 ]]\n", + "Epoch 70: Loss=0.4713, K=[[ 0.46063015 0.01035106]\n", + " [-0.02110424 0.4399218 ]]\n", + "Epoch 80: Loss=0.4863, K=[[ 0.48730075 0.02812148]\n", + " [-0.0194033 0.45730466]]\n", + "Epoch 90: Loss=0.3954, K=[[ 0.49853238 0.03747003]\n", + " [-0.01219637 0.46724102]]\n" + ] + } + ], + "source": [ + "epochs = 100\n", + "learning_rate = 1e-2\n", + "losses = []\n", + "\n", + "optimizer = adam(learning_rate)\n", + "K_opt = jnp.copy(K0)\n", + "optim_state = optimizer.init(K_opt)\n", + "key = jax.random.PRNGKey(0)\n", + "for epoch in range(epochs):\n", + " key, subkey = jax.random.split(key)\n", + " loss_value = rollout_final_state_norm(K_opt, subkey)\n", + " grad_K = jax.grad(rollout_final_state_norm)(K_opt, subkey)\n", + "\n", + " updates, optim_state = optimizer.update(grad_K, optim_state)\n", + " K_opt = optax.apply_updates(K_opt, updates)\n", + "\n", + " if epoch % 10 == 0:\n", + " print(f\"Epoch {epoch}: Loss={loss_value:.4f}, K={K_opt}\")\n", + " losses.append(loss_value)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "10edb578", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:59.060489Z", + "iopub.status.busy": "2026-07-31T14:38:59.060430Z", + "iopub.status.idle": "2026-07-31T14:38:59.127549Z", + "shell.execute_reply": "2026-07-31T14:38:59.127323Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Loss (||x_T||)')" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 5))\n", + "plt.subplot(1, 2, 1)\n", + "plt.plot(losses)\n", + "plt.title(\"Loss over epochs\")\n", + "plt.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss (||x_T||)\") " + ] + }, + { + "cell_type": "markdown", + "id": "6b29705c", + "metadata": {}, + "source": [ + "We now run the loop with both the initial and optimized K to compare results. Our optimized controller drives the system to zero much more quickly compared to the initial controller we chose." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "c64bc97d", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:59.128515Z", + "iopub.status.busy": "2026-07-31T14:38:59.128461Z", + "iopub.status.idle": "2026-07-31T14:38:59.456882Z", + "shell.execute_reply": "2026-07-31T14:38:59.456528Z" + } + }, + "outputs": [], + "source": [ + "predict_times = jnp.arange(0.0, 30.0)\n", + "\n", + "\n", + "def run(K, key):\n", + " policy = LinearPolicy(K=K)\n", + " sim = DiscreteControlLoopSimulator(\n", + " control_policy=policy,\n", + " policy_state_init=None,\n", + " filter_config=KFConfig(filter_source=\"cuthbert\"),\n", + " )\n", + " result = sim.simulate(dynamics, rng_key=key, predict_times=predict_times)\n", + " return result\n", + "\n", + "trace_unopt = run(K0, key0)\n", + "trace_opt = run(K_opt, key0)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d6197c9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T14:38:59.458150Z", + "iopub.status.busy": "2026-07-31T14:38:59.458085Z", + "iopub.status.idle": "2026-07-31T14:38:59.650457Z", + "shell.execute_reply": "2026-07-31T14:38:59.650220Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "fig, axes = plt.subplots(2, 1, figsize=(8, 7), sharex=True)\n", + "\n", + "runs = [\n", + " (trace_unopt, \"Unoptimized control\", \"tab:red\"),\n", + " (trace_opt, \"Optimized control\", \"tab:blue\"),\n", + "]\n", + "for result, label, color in runs:\n", + " t = result.times[0]\n", + " true_state = jnp.linalg.norm(result.states[0, :], axis=-1)\n", + " obs = jnp.linalg.norm(result.observations[0, :], axis=-1)\n", + " filtered_mean = jnp.linalg.norm(result.filtered_states_mean[0, :], axis=-1)\n", + " axes[0].plot(t, obs, \".\", color=color, alpha=0.4, label=f\"{label} (observed norm)\")\n", + " axes[0].plot(t, true_state, \"--\", color=color, alpha=0.7, linewidth=1, label=f\"{label} (true state norm)\")\n", + " axes[0].plot(t, filtered_mean, \"-\", color=color, label=f\"{label} (filtered mean)\")\n", + "\n", + "axes[0].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + "axes[0].set_ylabel(\"state\")\n", + "axes[0].legend()\n", + "axes[0].set_title(\"DiscreteControlLoopSimulator: driving a 1D linear system to 0\")\n", + "\n", + "t_u = trace_opt.times[0][:-1]\n", + "u_1 = trace_opt.controls[0, :, 0]\n", + "u_2 = trace_opt.controls[0, :, 1]\n", + "\n", + "axes[1].step(t_u, u_1, where=\"post\", color=\"tab:blue\", label=\"$u_{k,1}$\")\n", + "axes[1].step(t_u, u_2, where=\"post\", color=\"tab:orange\", label=\"$u_{k,2}$\")\n", + "axes[1].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + "axes[1].legend()\n", + "axes[1].set_ylabel(\"control $u_k$\")\n", + "axes[1].set_xlabel(\"time\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dynestyx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/docs/tutorials/control/controller_demo.ipynb b/docs/tutorials/control/controller_demo.ipynb new file mode 100644 index 00000000..321f1439 --- /dev/null +++ b/docs/tutorials/control/controller_demo.ipynb @@ -0,0 +1,741 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "02ba24af", + "metadata": {}, + "source": [ + "# `DiscreteControlLoopSimulator` demo\n", + "\n", + "This notebook demonstrates `dynestyx.control.discrete_controller_simulators.DiscreteControlLoopSimulator`, which implements the discrete time online control loop\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "&x_0 \\sim p(x_0)\\\\\n", + "&y_0 | x_0 \\sim p(y_0 | x_0, t_0) \\\\\n", + "&\\hat{x}_{0|0} = \\text{FilterUpdate}(y_0, t_0) \\\\\n", + "&u_k, s_{k+1} = \\text{ControlPolicy}(x_hat_{k|k}, s_k) \\\\\n", + "&x_{k+1} | x_k, u_k \\sim p(x_{k+1} | x_k, u_k, t_k, t_{k+1}) \\\\\n", + "&y_{k+1} | x_{k+1}, u_k \\sim p(y_{k+1} | x_{k+1}, u_k, t_{k+1}) \\\\\n", + "&\\hat{x}_{k+1|k+1} = \\text{FilterUpdate}(x_hat_{k|k}, u_k, y_{k+1}, t_k, t_{k+1}) \\\\\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "at each step, sampling the next state and observation, filtering the observation into an updated belief, and asking the policy for the next control.\n", + "\n", + "We use:\n", + "1. a simple 1D linear-Gaussian dynamical system (a noisy random walk, `x_{k+1} = A x_k + B u_k + noise`) with the full state directly observed under Gaussian noise,\n", + "2. a linear feedback policy `u_k = -K x_hat_k` that drives the state toward 0,\n", + "3. a plot comparing the controlled trajectory against an uncontrolled (`K=0`) baseline." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "ccd86c86", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:18.102367Z", + "iopub.status.busy": "2026-07-31T15:54:18.102187Z", + "iopub.status.idle": "2026-07-31T15:54:19.922342Z", + "shell.execute_reply": "2026-07-31T15:54:19.922046Z" + } + }, + "outputs": [], + "source": [ + "import equinox as eqx\n", + "import jax\n", + "import jax.numpy as jnp\n", + "import jax.random as jr\n", + "import matplotlib.pyplot as plt\n", + "import numpyro.distributions as dist\n", + "\n", + "from dynestyx.control.discrete_controller_simulators import DiscreteControlLoopSimulator, filter_state_mean\n", + "from dynestyx.inference.configs.filter import KFConfig\n", + "from dynestyx.models import DynamicalModel\n", + "from dynestyx.models.observations import LinearGaussianObservation\n", + "from dynestyx.models.state_evolution import LinearGaussianStateEvolution" + ] + }, + { + "cell_type": "markdown", + "id": "dc797c14", + "metadata": {}, + "source": [ + "## 1 Simple linear dynamics\n", + "\n", + "`state_dim = control_dim = observation_dim = 1`. The transition is \n", + "$$\n", + "x_{k+1} = ax_k + u_k + \\eta_k,\n", + "$$\n", + "with $a=1.05$, is linear with additive Gaussian noise. Without control, this system is unstable and $x_k \\rightarrow \\infty$.\n", + "The observation model is \n", + "$$\n", + "y_k = x_k + \\sigma\\varepsilon_k\n", + "$$\n", + "$\\sigma=0.2$, observes the full state under additive Gaussian noise. We define the dynamics in the usual dynestyx way." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "6257e9bd", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:19.923844Z", + "iopub.status.busy": "2026-07-31T15:54:19.923715Z", + "iopub.status.idle": "2026-07-31T15:54:20.046419Z", + "shell.execute_reply": "2026-07-31T15:54:20.046094Z" + } + }, + "outputs": [], + "source": [ + "state_dim = control_dim = obs_dim = 1\n", + "\n", + "dynamics = DynamicalModel(\n", + " initial_condition=dist.MultivariateNormal(jnp.array([5.0]), 0.1 * jnp.eye(state_dim)),\n", + " state_evolution=LinearGaussianStateEvolution(\n", + " A=jnp.array([[1.05]]), B=jnp.array([[1.0]]), cov=0.05 * jnp.eye(state_dim)\n", + " ),\n", + " observation_model=LinearGaussianObservation(\n", + " H=jnp.eye(obs_dim, state_dim), R=0.2 * jnp.eye(obs_dim)\n", + " ),\n", + " control_dim=control_dim,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "96175f05", + "metadata": {}, + "source": [ + "## 2. Define the controller\n", + "\n", + "A simple linear feedback policy `u = -K x_hat`, implemented as an `equinox.Module` (per the control-loop's requirement that the policy be any callable, e.g. a learned neural policy or, as here, a fixed gain). `filter_state_mean` extracts a point estimate from whatever filter-family belief `DiscreteControlLoopSimulator` produces (Kalman-family states expose `.mean` directly; particle-filter states are summarized as a weighted mean instead), so the same policy code works regardless of `filter_config`.\n", + "\n", + "With `a - b*k = 1 - 0.5 = 0.5`, well inside the unit circle, the closed loop should converge to 0." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "5a9993d0", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:20.047593Z", + "iopub.status.busy": "2026-07-31T15:54:20.047536Z", + "iopub.status.idle": "2026-07-31T15:54:20.049438Z", + "shell.execute_reply": "2026-07-31T15:54:20.049208Z" + } + }, + "outputs": [], + "source": [ + "class LinearPolicy(eqx.Module):\n", + " K: jnp.ndarray\n", + "\n", + " def __call__(self, x_hat, s, key):\n", + " return -self.K @ filter_state_mean(x_hat), s" + ] + }, + { + "cell_type": "markdown", + "id": "58a11e91", + "metadata": {}, + "source": [ + "## 3. Run the closed loop, with and without control\n", + "\n", + "`DiscreteControlLoopSimulator` is called directly: `sim.simulate(dynamics, rng_key=key, predict_times=...)` returns a `ControlledSimulatedResult`. We use `predict_times` (not `obs_times`/`ctrl_times`) since the trajectory doesn't exist yet until the loop generates it. \n", + "\n", + "`filter_config=KFConfig(record_filtered_states_mean=True)` makes the filtered state estimate available as an output (it's needed internally either way, for the policy; this only controls whether it's also returned). We run twice with the same key: once with the stabilizing gain `K=0.5`, once with `K=0` (no control) as a baseline." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "17da83f4", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:20.050377Z", + "iopub.status.busy": "2026-07-31T15:54:20.050322Z", + "iopub.status.idle": "2026-07-31T15:54:20.936142Z", + "shell.execute_reply": "2026-07-31T15:54:20.935751Z" + } + }, + "outputs": [], + "source": [ + "predict_times = jnp.arange(0.0, 30.0)\n", + "\n", + "\n", + "def run(K: float, key):\n", + " policy = LinearPolicy(K=jnp.array([[K]]))\n", + " sim = DiscreteControlLoopSimulator(\n", + " control_policy=policy,\n", + " policy_state_init=None,\n", + " filter_config=KFConfig(record_filtered_states_mean=True),\n", + " )\n", + " return sim.simulate(dynamics, rng_key=key, predict_times=predict_times)\n", + "\n", + "\n", + "key = jr.PRNGKey(0)\n", + "result_controlled = run(K=0.5, key=key)\n", + "result_uncontrolled = run(K=0.0, key=key)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "b79a15db", + "metadata": {}, + "source": [ + "## 4. Plot the resulting dynamics\n", + "\n", + "Top panel: noisy observations (dots) and the filtered state estimate (line) for both runs. Since the full state is directly observed here, the observations already closely track the true state, and the filtered estimate smooths out the sensor noise. Bottom panel: the control sequence chosen online by the policy for the controlled run." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "538926f3", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:20.937485Z", + "iopub.status.busy": "2026-07-31T15:54:20.937419Z", + "iopub.status.idle": "2026-07-31T15:54:21.104654Z", + "shell.execute_reply": "2026-07-31T15:54:21.104422Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 1, figsize=(8, 7), sharex=True)\n", + "\n", + "runs = [\n", + " (result_uncontrolled, \"no control (K=0)\", \"tab:red\"),\n", + " (result_controlled, \"controlled (K=0.5)\", \"tab:blue\"),\n", + "]\n", + "for result, label, color in runs:\n", + " t = result.times[0]\n", + " true_state = result.states[0, :, 0]\n", + " obs = result.observations[0, :, 0]\n", + " filtered_mean = result.filtered_states_mean[0, :, 0]\n", + " axes[0].plot(t, obs, \".\", color=color, alpha=0.4, label=f\"{label} (observed)\")\n", + " axes[0].plot(t, true_state, \"--\", color=color, alpha=0.7, linewidth=1, label=f\"{label} (true state)\")\n", + " axes[0].plot(t, filtered_mean, \"-\", color=color, label=f\"{label} (filtered)\")\n", + "\n", + "axes[0].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + "axes[0].set_ylabel(\"state\")\n", + "axes[0].legend()\n", + "axes[0].set_title(\"DiscreteControlLoopSimulator: driving a 1D linear system to 0\")\n", + "\n", + "t_u = result_controlled.times[0][:-1]\n", + "u = result_controlled.controls[0, :, 0]\n", + "axes[1].step(t_u, u, where=\"post\", color=\"tab:blue\")\n", + "axes[1].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + "axes[1].set_ylabel(\"control $u_k$\")\n", + "axes[1].set_xlabel(\"time\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "3c23bfc6", + "metadata": {}, + "source": [ + "## 5. A black-box, partially-observed nonlinear SDE\n", + "\n", + "So far the dynamics were already discrete-time. Here we go further: the control loop's\n", + "transition $p(x_{k+1} \\mid x_k, u_k, t_k, t_{k+1})$ is allowed to be *any* black-box callable, so\n", + "we integrate a genuine SDE with many small sub-steps between observations, and\n", + "`DiscreteControlLoopSimulator` never sees anything but the discrete grid.\n", + "\n", + "We consider a 2-d dynamical system $x_t \\in \\mathbb{R}^2$ obeying\n", + "\n", + "$$\n", + "\\begin{aligned}\n", + "dx_t &= A x_t^2 + u_t + \\sigma\\, dW_t \\\\\n", + "y_{t_k} &= H x_{t_k} + \\eta_{t_k}\n", + "\\end{aligned}\n", + "$$\n", + "\n", + "with $A = \\begin{pmatrix} 0.025 & 0.01 \\\\ 0.01 & 0.025 \\end{pmatrix}$ (mild coupling, so that\n", + "observing $x_1$ is actually informative about $x_2$) and $H = \\begin{pmatrix} 1 & 0\n", + "\\end{pmatrix}$ for $t_k = k \\Delta t$ -- we only ever observe the first component.\n", + "\n", + "Two consequences of these changes:\n", + "\n", + "- **The transition has no closed form and isn't Gaussian.** A composition of many small nonlinear\n", + " Euler-Maruyama steps is not Gaussian, so `KFConfig`/`EKFConfig` (which need a linearizable\n", + " one-step Gaussian transition) don't apply. We use a **particle filter** (`PFConfig`)\n", + " instead, and check below that an **ensemble Kalman filter** (`EnKFConfig`) works too.\n", + "- **$x_2$ is only observed indirectly**, through its dynamical coupling to $x_1$ via $A$'s\n", + " off-diagonal terms." + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "ab001049", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:21.105666Z", + "iopub.status.busy": "2026-07-31T15:54:21.105608Z", + "iopub.status.idle": "2026-07-31T15:54:21.242429Z", + "shell.execute_reply": "2026-07-31T15:54:21.242138Z" + } + }, + "outputs": [], + "source": [ + "from dynestyx.inference.configs.filter import EnKFConfig, PFConfig\n", + "from dynestyx.models import ContinuousTimeStateEvolution, FullDiffusion\n", + "\n", + "state_dim_2d = control_dim_2d = 2\n", + "obs_dim_2d = 1\n", + "A = jnp.array([[0.025, 0.01], [0.01, 0.025]])\n", + "sigma_2d = 0.1\n", + "\n", + "continuous_nonlinear_dynamics = DynamicalModel(\n", + " initial_condition=dist.MultivariateNormal(\n", + " jnp.array([3.0, 2.0]), 0.05 * jnp.eye(state_dim_2d)\n", + " ),\n", + " state_evolution=ContinuousTimeStateEvolution(\n", + " drift=lambda x, u, t: A @ (x**2) + u,\n", + " diffusion=FullDiffusion(sigma_2d * jnp.eye(state_dim_2d)),\n", + " ),\n", + " observation_model=LinearGaussianObservation(\n", + " H=jnp.eye(obs_dim_2d, state_dim_2d), R=0.05 * jnp.eye(obs_dim_2d)\n", + " ),\n", + " control_dim=control_dim_2d,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "77c82d46", + "metadata": {}, + "source": [ + "Wrapping its output in a small `.sample(key)` / `.shape()` object turns it into a discrete-time\n", + "`state_evolution` the control loop can call without knowing anything happens in between. This is a genuine black box, only usable with filters\n", + "(PF, EnKF) that only need to *sample* the transition. The control is held constant\n", + "(zero-order hold) across the sub-steps via `control_path_eval`." + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "0e528d46", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:21.243689Z", + "iopub.status.busy": "2026-07-31T15:54:21.243622Z", + "iopub.status.idle": "2026-07-31T15:54:21.246237Z", + "shell.execute_reply": "2026-07-31T15:54:21.246036Z" + } + }, + "outputs": [], + "source": [ + "from dynestyx.solvers import euler_maruyama_integrate_state_to_time\n", + "\n", + "substep_dt = 0.02 # ~5 EM sub-steps per 0.1-spaced observation interval\n", + "\n", + "\n", + "class SubSteppedSDEStep:\n", + " \"\"\"A single control-loop transition that is itself a sub-stepped SDE\n", + " integration -- the simulator only ever sees `.sample()`/`.shape()`,\n", + " exactly as it would for e.g. a MuJoCo step.\"\"\"\n", + "\n", + " def __init__(self, cte, x_prev, u, t_now, t_next, *, dt0):\n", + " self._cte, self._x_prev, self._u = cte, x_prev, u\n", + " self._t_now, self._t_next, self._dt0 = t_now, t_next, dt0\n", + "\n", + " def sample(self, key):\n", + " x_out, _, _ = euler_maruyama_integrate_state_to_time(\n", + " self._cte,\n", + " self._x_prev,\n", + " self._t_now,\n", + " key,\n", + " self._t_next,\n", + " dt0=self._dt0,\n", + " control_path_eval=lambda t: self._u,\n", + " )\n", + " return x_out\n", + "\n", + " def shape(self):\n", + " return self._x_prev.shape\n", + "\n", + "\n", + "def black_box_sde_transition(x, u, t_now, t_next):\n", + " return SubSteppedSDEStep(\n", + " continuous_nonlinear_dynamics.state_evolution, x, u, t_now, t_next, dt0=substep_dt\n", + " )\n", + "\n", + "\n", + "nonlinear_dynamics = DynamicalModel(\n", + " initial_condition=continuous_nonlinear_dynamics.initial_condition,\n", + " state_evolution=black_box_sde_transition,\n", + " observation_model=continuous_nonlinear_dynamics.observation_model,\n", + " control_dim=continuous_nonlinear_dynamics.control_dim,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "0c194243", + "metadata": {}, + "source": [ + "The controller is the same `LinearPolicy` as before, with a $2\\times2$ gain $K = k \\cdot I$. The case \n", + "$k=0$ reproduces the uncontrolled (unstable) system. " + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "3ee4a287", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:21.247091Z", + "iopub.status.busy": "2026-07-31T15:54:21.247047Z", + "iopub.status.idle": "2026-07-31T15:54:22.860176Z", + "shell.execute_reply": "2026-07-31T15:54:22.859857Z" + } + }, + "outputs": [], + "source": [ + "predict_times_2d = jnp.arange(0.0, 6.0, 0.1)\n", + "\n", + "\n", + "def run_2d(k: float, key, filter_config):\n", + " policy = LinearPolicy(K=k * jnp.eye(control_dim_2d))\n", + " sim = DiscreteControlLoopSimulator(\n", + " control_policy=policy,\n", + " policy_state_init=None,\n", + " filter_config=filter_config,\n", + " )\n", + " return sim.simulate(nonlinear_dynamics, rng_key=key, predict_times=predict_times_2d)\n", + "\n", + "\n", + "pf_config = PFConfig(n_particles=500, record_filtered_states_mean=True)\n", + "\n", + "key_2d = jr.PRNGKey(0)\n", + "result_pf_controlled = run_2d(k=1.0, key=key_2d, filter_config=pf_config)\n", + "result_pf_uncontrolled = run_2d(k=0.0, key=key_2d, filter_config=pf_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "b6ef7ed9", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:22.861513Z", + "iopub.status.busy": "2026-07-31T15:54:22.861440Z", + "iopub.status.idle": "2026-07-31T15:54:23.008679Z", + "shell.execute_reply": "2026-07-31T15:54:23.008435Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def plot_2d_runs(runs, controlled_result, title):\n", + " fig, axes = plt.subplots(3, 1, figsize=(8, 9), sharex=True)\n", + "\n", + " for result, label, color in runs:\n", + " t = result.times[0]\n", + " true_state = result.states[0]\n", + " filtered_mean = result.filtered_states_mean[0]\n", + " axes[0].plot(t, true_state[:, 0], \"--\", color=color, alpha=0.7, linewidth=1, label=f\"{label} (true)\")\n", + " axes[0].plot(t, filtered_mean[:, 0], \"-\", color=color, label=f\"{label} (filtered)\")\n", + " axes[0].plot(t, result.observations[0][:, 0], \".\", color=color, alpha=0.4, label=f\"{label} (observed)\")\n", + " axes[1].plot(t, true_state[:, 1], \"--\", color=color, alpha=0.7, linewidth=1)\n", + " axes[1].plot(t, filtered_mean[:, 1], \"-\", color=color)\n", + "\n", + " axes[0].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + " axes[0].set_ylabel(\"$x_1$ (observed)\")\n", + " axes[0].legend()\n", + " axes[0].set_title(title)\n", + "\n", + " axes[1].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + " axes[1].set_ylabel(\"$x_2$ (unobserved, coupled through $A$)\")\n", + "\n", + " t_u = controlled_result.times[0][:-1]\n", + " u = controlled_result.controls[0]\n", + " axes[2].step(t_u, u[:, 0], where=\"post\", color=\"tab:blue\", label=\"$u_1$\")\n", + " axes[2].step(t_u, u[:, 1], where=\"post\", color=\"tab:purple\", label=\"$u_2$\")\n", + " axes[2].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + " axes[2].set_ylabel(\"control $u_k$\")\n", + " axes[2].set_xlabel(\"time\")\n", + " axes[2].legend()\n", + "\n", + " plt.tight_layout()\n", + " plt.show()\n", + "\n", + "\n", + "plot_2d_runs(\n", + " [\n", + " (result_pf_uncontrolled, \"no control\", \"tab:red\"),\n", + " (result_pf_controlled, \"controlled (K=1.0)\", \"tab:blue\"),\n", + " ],\n", + " result_pf_controlled,\n", + " \"Black-box sub-stepped SDE, partial observation, particle filter (PFConfig)\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "06382335", + "metadata": {}, + "source": [ + "### Does an EnKF work here too?\n", + "\n", + "Both `_cuthbert_filter_pf` and `_cuthbert_filter_enkf` only call\n", + "`dynamics.state_evolution(...).sample(key)` to propagate particles/ensemble members -- neither\n", + "needs `.log_prob()` or `.mean` on the transition, so both are equally black-box-compatible with\n", + "`nonlinear_dynamics` above (KF/EKF, which linearize a Gaussian one-step transition, are not --\n", + "there's no such transition here to linearize). EnKF's only extra requirement is on the\n", + "*observation* model: state-independent Gaussian noise. Since `nonlinear_dynamics.observation_model`\n", + "is still a `LinearGaussianObservation` (just with a rectangular $H$), EnKF takes its fast\n", + "closed-form path -- no probing, no rejection.\n", + "\n", + "So yes: `EnKFConfig` runs on the identical setup below. The difference is accuracy, not\n", + "compatibility -- EnKF represents the filtering distribution as a Gaussian ensemble (cheap, and\n", + "fine here since the nonlinearity is mild and the noise is Gaussian), while PF makes no\n", + "distributional assumption on the belief at all, which matters more the further the true\n", + "posterior drifts from Gaussian (stronger nonlinearity, multimodal beliefs, etc). For this\n", + "system the two should look similar; PF remains the more general default for a genuinely\n", + "arbitrary black box." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "bddda28c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:23.009731Z", + "iopub.status.busy": "2026-07-31T15:54:23.009673Z", + "iopub.status.idle": "2026-07-31T15:54:24.086636Z", + "shell.execute_reply": "2026-07-31T15:54:24.086404Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAN6CAYAAAATiN+GAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjExLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvctoD+AAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs3Qd0FNXbBvBn03sCCb333hFQQcBCsaOCvaLY8RN7bwi2vxUVe8OCithBFAEpYqNI7x3SIL1ns995bpi4CSm7JGGzyfM7ZyE7uztzZ2bLfefe+16bw+FwQEREREREpBJ8KvNiERERERERBRYiIiIiIlIl1GIhIiIiIiKVpsBCREREREQqTYGFiIiIiIhUmgILERERERGpNAUWIiIiIiJSaQosRERERESk0hRYiIiIiIhIpSmwkCMsWbIENpsN33//fYVHZ+3atea5n332mcfLUh2vl9rh3HPPRffu3Y/5a0szbNgwDBo0CHVVVR9Pqdr3nDecHz8/P9x7773wVvn5+bjnnnvQvHlz8/s0atQos4x/P/jggzV2XzMyMtCsWTO8/vrrni6KV8t34/y7KjU1FTExMXj//ffhaQosqsCuXbtw4403omPHjggJCUHLli1x5pln4ssvv0ReXl5VbEJqiYKCAnz88cc48cQT0bBhQ4SHh6N37964//77sXPnzmLPveqqq8wXjXXje6tFixYYPXo0pk2bhrS0tCPWX/I1JW9///2322Vu3br1UX/ZHUv8cuaxFM/TuZCS30np6enFDsq+fftMAMPvwF9++aVOHTBW/p5//nl89dVX5jdh7ty5Lr+2shXQynj66afh7++P8ePHF1vOCm1ZvzmNGzc+6u1xvQyKS/rpp58QFhaGXr164cCBAxWWoeTvXm5uLt544w0MHz4c0dHRCAoKQtu2bc1v66effmoer6nnvywRERG46667TF2CAaAnKbCopB07dqBPnz5YtmwZ3nrrLcTHx5u/e/bsiYsvvhg//PBD1ZwpqRVuu+02XH755Tj99NOxcuVKxMXFmS/r7777DhdccEGpr2EA4XA4kJSUhEWLFpkris8++yy6du2KFStWlPuakrf+/fujLvr6669N65p4ns6FbNq0CSeccIL5vVy4cCFOPfXUOnVQGEjxQuSAAQNMxddqmeB39OTJk1ETsbL68ssv4/rrr0dAQMARjw8dOrTU35zY2NgqLccnn3yCs846C3379sVvv/2GJk2aVFgG59+9gwcP4qSTTsIDDzyAsWPHYvXq1eZq/7x588zzrr76anz++efwxvN/3XXXmf3zdKuFAotKYpMgK3wffPCBeVMzimbz1pQpU4qiahHi+4Tvl/POO898qbFJma0QI0eOxF9//YWzzz673AMVGBhorqrwi/2ff/6Bj4+PaRnz9NUJERFX8btu8ODB5vtr6dKl6NevX507eAyogoOD4U14JT8lJQWXXXaZx8rAwIbb54U5BgKRkZFur+OKK67AmjVrzEW6m266ydTXGCi1b98eTzzxBBYvXox69erBG89//fr1TavL9OnT4UkKLCrp0KFD5n9WEks6+eSTi12JSUxMLNY8x4pip06d8NhjjxXrMuU8LoBdXtgVhc3F559/ftH2+AFr06aNacLjNtgdq6TMzExTge3QoYPZFrveXHPNNeZN7Spup1WrVuZDcPzxx5sPXUVc3U+rjA899BA6d+5s9oX7OnHiRBN1l4UVaV6155cKg7eq3BdeXbn22mvNVRB+2fAYs39rVlaWeXz9+vUmWOS5cMarHlzvpZdeWub2+aVst9tLfa9w3x9++GGX94XNvmwKZzPwhx9+iJrcr3v79u0meAoNDTXHlc21OTk5xZ57ww03FL1fWOFg8zSDJgZQpa2T3cZ41YrNv3wv8P3D9wLPg7UeHtPy+o27uk13r6bxqhcDRpbttNNOM5Wn0rhyXFgJ44+o1W2OlbA333zTvI+c8UeS6+JngvvN57ErpivHjle5WAZetStp0qRJ5vPLz7Srx+xozoWrx87aB3aj4T7ws8hjc+edd5ouIkfLnePnyrar47yxdZzP5XbbtWuHL774wjy+detWU5ngcn638DejLK685ypzjCry888/m99Fbpvnlr9Nzqw+57yxyw27FbObsfW7VxZ2s+JreLWXv5s9evQw76MhQ4Zg48aN5jnffvut6UnAsrPL5PLly49Yjyvbd94WrzyzxwLXyd+4mTNnlltOdsnhaxcsWGA+M6V12ymvixPPNctFTz75ZNFrnFu7edX71VdfNfvI3ySeL1604m9Xafvw448/mqv//Jy//fbbZW6breo8X+yOe7Qqc+x4XNjizzrMrFmzin2nuIrHn/vLi3PdunUr9TnHHXcczjjjjKL7/O1n9yJe1GOdgO9dlsHqguXOfv19FOc/OTnZfEfzN5/fJWPGjDE9HVhXuuiii44oPz9fbJ3n94XHOKRS3nvvPQcP40033eTIzMx067WHDh1yfP75547IyEjHPffcU7R88eLFZp3nn3++48knn3QkJCQ4/v33X0fr1q0d55xzjuPll192PP7442b52rVrHW3btnUMGzas2Lqzs7MdgwYNcrRo0cLx/fffO1JTU81zjz/+eEenTp0caWlpZZbL2v65557rePDBBx1xcXGO7du3O8477zxHYGCg46+//ip67po1a8xzP/30U7f3k8fruOOOczRu3NjxxRdfOA4ePOjYtWuX45VXXnG88MILxcry3Xffmfv79u1z9O3b19GqVSuz7Yq4sy9JSUnmWLZv396xZMkSR0pKiuPrr7921K9f3xzf/Px887xPPvnErPO5554z95OTkx3t2rVzdO3a1ZGenl5mWQoKCsz5aNSokeOff/6psOxXXnml2U5Z52rnzp3m8QsvvNDl1xwNHusHHnjA7dcNHTrU0bNnT8fo0aMdv//+uzmefB+Eh4c7xo0bV+brcnNzHRs2bDDv/+joaMeBAwdKXefSpUsdiYmJjo8//tg8NnLkSEevXr1KXSc/N926dTuqbVb0Wsv//vc/c+wffvhh8z7btm2bOTd+fn6OX375xe3jwn2LiopyXHbZZY7du3ebz8uqVascN9xwg3mdZebMmQ4fHx/HzTff7NixY4f5vPEzxO3y+6miY7d8+XJT7unTpx9xTBo0aOAYO3as28fM3XPhzrHjevn55THg99r777/vsNlsRd8Z7nLn+Lmy7eo6b2PGjHH8/fff5vuGn0dfX1/HwoULzbH+888/zfJHHnnEHEd+fx3tZ7G08+NqWUtjfSe9/fbbjoCAAMeQIUPMd21F+F26YMECR4cOHcw+OuO+O/+W8PuO2zj77LMd1157rTnue/fudZx00knmu3nevHmmHPx94W/I8OHDHU2aNDG/k+5u39oWzwfXyd8T/hZfffXV5hht3Lixwn3j+ejXr1+xZXl5eWa9Jb9rS+5rWc+zXHXVVY6wsDBzvPle5D5fcskl5vd369atxfbhrLPOclx88cVm+ebNmx0///xzmWXm7yCfWxp+/rlPFXH32HG9gwcPdlx33XXmdffee2+Z63alDE888YRZD98PrrDb7Y5TTz3VfJ5nzZplPjf8/HTs2NHUx1hnOZr9Guri+Wed48QTTzR1pJ9++sls/9dffzX1mebNmxf77bewfFwPv5s8RYFFJbGyyKCCH/7Q0FDHiBEjHHfddZd5E/CN4gpWeOvVq1dqZdgZAwr+iJX8IXj11VfN8/ljbHnppZfMMq7LGb9w/f39y/0RtrZf8ss8KyvLvMG5j+4EFmXtJyvmfO38+fMrLAsDixUrVjiaNWvmGDhwoCM2NrbC7bm7LwzW+Nw//vij1OCRwY+F55w/qosWLTI/xPwiZyWrIvzQt2nTxqyvS5cupvLx+uuvm/NSUkVBgvVFxB/qkq8p7cb3Z0Wsiokrty1btpS7Ln558nnOwZvzeWdlqDz8Yefnatq0aUess+Q5qmxgUd42XXktK5l8D7BiU/Ic8QfIuVyuHhdWqHmfQUBZ+D5m5b/k+5tYwWIQawXE5R277t27myDf2ZdffmmeP3fuXLePmTvnwt1jx+/A1atXF3vuaaedZj5P7nL3+Lmy7eo4b9yu84UUBnWsSPG4rVy5smg5X8P1skJztJ/FkufHnbKWxvk7id997l6As96HvJBSUWDBIMK5LL/99ptZzve38+8xzw2Xs7Lo7vatbfEilPM6WekLCgoyv/+eCiz4e8THGPQ5y8nJMReIeC6c96Fp06bmvVQRfsb5/EmTJpX6ON+LZf1OOFd+3T12zutlcFGessrACx/O71cucyX4o2+//dY8/8033yy2nJ8553Pg7n4NdfH8z5492yxjYO+MF4tLHtuSFxwfe+wxh6eoK1QlsemKzY579+41/efZBMvBaGwyZnPY5s2biz2fTcccixEVFWW6EljNZ+x/X7L7D5u3nbGLAYNBvt5Zly5dipq5nZstmY2BfVmdsRmTzXNs1q5IyT7/bNpjthe+tmSTfkmu7CebJFlGNt1VhIPg2azNAX88vo0aNSr2OLsBlNec6Mq+zJ8/3zSFc0CVM6uZmY9bXnjhBXN+eZ6/+eYbM3Cf56ci7NKwZcsWs90rr7zSdKFgMyu7NhztoC1r8FdFg7dLZmU5FthsXHLAOLvC0K+//lq0jE277HLArmdsbuY+8Zzy3LD53xnPfclzdDTc2WZF/vjjD3N8OX7GGQfknXPOOaZbkPPn25Xjws8puyf83//9n3mPldZVidtNSEgwgxBLYhdJ7qPVFaS8Y8csL+y+4zzA/d133zXfF+ySVB3H7GiPHT+j7NLijF2r2PTP97m723bn+Lmy7eo4b9yuc/cxdofhd4aVVc7i6+truqs4/xa4+1msbFnLwm3xOJXX1Yfdk9jNjF3IuC/O3XxceX+NGDHCvM5ifSez6yvfT+X9Zrq7fX73O6+T3ff4eSnt2B8r/N2nkolA+Fnl72fJ333WMayuVeVhdxzi+60sZQ2cLi0VvTvHjklK+J7+6KOPMGfOnHLLWVoZ3O2u58z6zS/53cTPHD9/znUCd/fLFewyRexuWvK8OW/HGbfpfM48QYFFFWEFmdl+nnvuOfz555+mLykzXzDDgIVvcH4580uOGYHYt5Vv/Keeeso8XnL8gXO2A+cPdVnLnd9IHCvAG998vPFL0qrgs/JQ3hgGS8nKu7WM5S6vkurqfnKsR2njDcpaZ3Z2thlsdTR9K13ZFx6T0lLjseLEPslWP3Pri5rnm2XioK/SfnTLwnPBrBTMY80BcRwfwx9ojjUp7we+JAaz1LRpU1SVRx999IgvZo5L4Vidksu530d73Mk6nqyUnnLKKaZv6nvvvWeWMwUfb/zRK/m5cPU9Ux53t1kR6/NU2vvHWub8/nHluLAyyeCb73eO6eGAQgYFHJjHcpKVcWXChAlFn3Prs271v3X+rJd17PheZmX4nXfeMff3799vxknw+4vrqo5jdrTHruT3n/Vjys+iq+MFLO4eP1e2XR3nrbTt8nu/rOWlVSpcec9VxTEqCxOcMPUs02zeeuutRwSB69atM+NJeNx48Yhj6fgcKxWnK++vyvxmurv9st4LnqzQWeeK70Hn333eZsyYccR5cvW7lBcIqbQg+Wi4c+waNGhgsj9xjAODUwbrR4u/ZbR7926Xns/jxePIsWSlfTeV/NxU9Xvi4MGDpv7B8ULOeD455qI01jmq7gHo5VFgUU1YUeRcBbzaY+VE5iBbXuljBZv/W1cKyhpkU9qV6PKWO+ObjhU/XhHnjZUC/qhZlUJ+UCvCK1GlLWMFpLxsV67uJ78wOBDSFa+99pq5GsBIvbTJ7hgcOFd6S179d2VfmFGhtOdx3fyRcf4g80eIg7o50Gvbtm2VyinOH7k77rijaOC+q5gVg0rL811TlHXcyfqy5iA2Hk8O7ue+8IuY73G+N0qrTLhyha0i7m6zInzvOO+bM2uZ8/vHleNCbM3jZ5U/TKzgMEUhWwxYOXNeJwc+W5/zkp91BrEVHTtuk60DrHzw+4rpCrkO5wsjVX3MjvbYufL95yp3j5+r267q81aZ3wJ333MluVvWsrAyxFYwBigcYM5EAM7BBQe5Mjhj6y+vUlsXkNwZhFqZ4+Tu9qvyfVhVeK54nNkzwPl33zpXJQMDV79LeWGN75GqSh3r7rFjJZ7BHlugeBHvaFsh2EuBKmr5cP5u4nEsLXkAPzslK/dV/Z6Ijo429Q8muXHG81nWxQBrULkVRHmCAotK4g9FaV88/BDzqh8/kM4fXlZknfENw0lSqhqbc9l0W9Y8B+40q1r4pcurmGxudG5uLo0r+8nmPX5RWc195WF2C+a/5xULZkXgj1xV7wuvxu7Zs+eIrEBWufk48YPOpmZe7eHVWwYVnIuiotm9eZWE80+UxgqwrCtDFeGXCrOCsAy82lxT8Uuu5PG0rjhZx7Os94y72a74WXP3inVlt2kZOHCg2f7s2bOLLeePErPRcCIn58qbO8eFGPyySxIr/vyRtS4MsGsg11tRRhVXMBsa31csB1skWA5mHjmaY+bOuXD32FWlqjx+pTkW581V7r7nLFVZVla82HLDFgtmyWJ2HasVh1gpLjlHArvAHCue3r4reAWdn8HSPl/83efxtDKGVSV2qz6aCVarCi9Esq7ArohsKXO3DkDsCshsbXzvldV9j11CrfnHrM9Fye8mds/kBcXyPjdVgRP4EVtAnbHuUlYWPPaYIXZ98xQFFpXEFG784Zs6darp0sImcb5h+YXJ8RVMRWhFseznz8deeuklUzndsGGDqSSXHAdRFdhliF2RuH6mZmOFgelO2YLCL3VWHCrCLy92jWGXJaaoZAWWTXPM9VweV/eTV/B4xf+SSy4xZeRVFlbsOWblxRdfPGK9DNA4azUrQMxlzTEtrnJlX3hcWJFieX7//XczToEBCVNu8kPKfbD6o/Ncs8y8asv18guG+bFLzp7tjF/4d999t2nNYpcnBlssA38EmPaRQQK3XRZeSWYQyy9Fpnpk8MpgpmQzaU3CMUdMo8v3Ha+W8Zjxije7iPDcE38oeHWFc7+w+yDfB+ySwy94VjhdZfV1//fffyvsa19V27TwffDII4+Yitrjjz9e9D7je6K0gNKV48KKHK/ucsJNXvnm+5GVeK7b+sFhwM3WPFbAeQWYnzumR+SPHitEJcdplYfvS77/2XrGixIlZ9d155i5cy7cPXau4meD373snlqWqjx+lmN93lzlynuuNFVdVp4Tpv7mbyNbxvhdzCvrVj9yvv94hZjfsUwLWpVdPcvj6e27g6lSmS695FVrtpSxlZHje/g7ygtWbG3n55C/dRzPd7QYtHB8IH+jPYUtCBzXwPcr3zdHMxEcP4s8fmxlY5DLC8BsceV3Hj8f/K3nd5v1nuBnlr/bvLDJzw0/PwxsOHbi9ttvR3U666yzTGDPNLu8iMnvEo6TYVpgdncrDesW/P5lbxGP8diw8VqCafeY1eeUU04xGRaYKYjZCU4++WSTlrRkBqmnnnrKZMZgpoDevXubrAPM0MRTYaVrLJlitWQaMWYKcMZMHyWzFlnZPCZPnmwyYnB7TBd3wgknOF577TVHRkZGmfvkvP3nn3/epEhlalZmY2J6Q2elZYVydT+tbBP33XefyebBVITMAjNx4kSTJq+8Y8HXcDnT8ZbHnX2h/fv3m4wqzHTCc8lMGszoYKWRtbJtffDBB8VeFx8fbzJW9e/f32TgKAvTQF5//fUm60pISIg5Pkxdd+utt5o0iM5KZnjic7kNZmdh1g9m0ympvKxQvH300UeOY5lulseZ2aP4+QgODjbHlZlFSqZ5ZCpkpvVj+suYmBiTvYP7x0xWTHFZcp2lYQpLZrRhWkXuK89zeZmdXN2mqxml6MMPPzTpkHmumLGH3wPM1HI0x4WfX6aMZLpFpjvkfjFzEzOU8DNW8ruB5eR+8HPElMl8HztnMCrv2FmYSYTHjt8VpaXidPWYuXsu3D12ZWUz4zGz8DuJy6x0xOWpzPErue1jdd743imZWaasjFzufBbLOj+ulLU05WW34/cKH7vgggtMdiJmv+G2+R5ghh1+3zLlK58zZ86cCrNCMZ2oM54LLuc5clZWZiVXtl/Wtojng8e3OrNCWeeCr+fnqmTmI77H3nnnHZNunp8j3vgb/Oijj5rfqYr2oSysM/C9PGXKFLeyQvFmpRd299iVlUKW3znMhshsaVbGJldT3hJ/o1lvYzpifkatuseoUaNMvc35N5z7zePPx5lRs2HDhuY9zXTGFnf3a6gb55/Hbvz48eY7meeS2UKZFZNZLa+44opiz2X6W+6Lc4Y+T7DxH8+FNSJSW7EfPlvwSpuISqS6sUWUV+84LqSsDCoi4jq2zrOVgL0xSnYZk2MnLy/PjAFiqx+7YVv4N3uKsGXpaFreq4q6QomISK3DLhPsWqWgQqRqsMsuK7XlzdAt1Y9jPti12nnqAXaTYrdRdlX1ZFBBarEQkWqhFgsREZGjxxYIZo5kVkwGDGyFZWsss35ynI2VDrwmqXklEhERERGp4y688ELTnZiDyjnvDAfmcxkzRdXEoILUYiEiIiIiIpVWM8MdERERERHxKgosRERERESk0upcDj6OpOeEKBwMU9XTr4uIiIiI1CacmYKZpzhhZEVjO+pcYMGggjMmioiIiIiIazjzelmzftfZwIItFdbBiYiI8HRxRERERERqrNTUVHNR3qpDl6fOBRZW9ycGFQosREREREQq5soQAg3eFhERERGRSlNgISIiIiIilabAQkREREREKq3OjbFwNSVtbm6up4shIkfB398fvr6+OnYiIiLHmAKLEhhQ7NixwwQXIuKdoqKi0LhxY81VIyIicgwpsCgxAciBAwfM1U6m1apoEhARqXmf4czMTMTHx5v7TZo08XSRRERE6gwFFk7y8/NNpYQzC4aEhHjurIjIUQsODjb/M7ho2LChukWJiIgcI7ok78Rut5v/AwICjtXxF5FqYF0YyMvL0/EVERGvlbtnD3J37oS3UGBxlBOAiEjNpc+wiIjUBgkvvIhtp5+BQx/NgDdQYCG1ztq1a5GRkVFht7d169bBk0kC1q9f77Hti4iISM2Wu3MnUufOZbpShPTvB2+gwEI8bvfu3YiNja2y9fXo0QO///57uc954YUX8Oijj7oVjFQlPz8/jBs3Dt9///0x26aIiIh4j8S33jJBRdjQoQjq0gXeQIGFeNxNN92Ep5566phtLzk5GU888QQeeeSRotYLBiN//fXXMSsDM449+OCDuPPOO00mIxERERFL3v79SPnmW/N3yMCB8BYKLGqBnTt3Ii4uzvydmJhY9Hdp+PiWLVvcmgCQV/K3bdtmKuDurrOisu3btw9paWk4ePCgaTXgjetxfh1bNHjfwoo473P50XjnnXfQtWtXdO/e3dzfuHGj+Z/zl3D73BfOY8K/s7KykJOTY5axjBwMbJXRGbs1cT9KYksMy1la8DBmzBizj/PmzTuq/RAREZHa6eA77/LKJ3zr14dvvXrwFgosaoFrr70W119/Pfr27Yt+/fqhbdu2OOWUU4p17WGlePTo0WjevDmGDRuGBg0aYPr06eWul6l3x48fj/r162P48OFmwrH33nvPrXVWVLbXX38dK1euxJw5c3DRRReZG4MNvm7ChAmmJeGkk07CY489Zp6/ZMkStG/f3qyrZ8+e6NKlC1asWOHW8frqq68wcuTIovvXXXed+f/xxx8327/jjjvMvnPbd999t9m/s846y5SRZePykkEN92/RokVF9xmsDBgwwAQwQ4YMQaNGjfDFF18Ue01gYKDZN5ZHREREhPITE5H85Zfm78D27RB+2mnwFgosaomff/7ZVOp37dplruZv2rSpWCX///7v/8zV8f3795vKMa/aswvSP//8U+Y6+fjixYvNIGdWpLdv346kpCS311le2SZPnmwq15dddllRi0WbNm3MY3PnzjWBB1/DgIbBCMclnH322ab1g4HNwIEDzTJXW2DYEsEuT7169Spaxn0kboPb//bbb4s9xtYIBgosoysYlDBwOeecc0w5ud8fffQRrrzyyqLWEeeAZNmyZS6tV0RERGq/Q++/D0dODoJ69USzadPgGxYKb1HjJshjxZUDW8PDw8t8DiuYfB5n1eUs2dXNnpwMe2pqsWU+ISHwi4mBIzcXeaUMPA5o2dL8nxcXZ94cznzrR5s3iT0tDXanijrZAoPg36ih22U8//zzzRVyYsvBaaedhlWrVpn77KLz8ccf4+uvvzatD3TBBReYCv0bb7yBN99884j18fiyMvzZZ5+ZFgKKiIjApEmT3F5neWUrD1sJBg8eXHSf2+J2n3zySZNOlOf+ueeeMy0pv/zyC04//fQK13no0CHTnSkmJgau4BgIltkds2fPRmpqKs477zwTRBFncu/QoQN+/PFHdO7cuei5XHdVDlwXERER72VPTkbSJ5+av6Ovvx5+ERHwJjUmsODVblYSOVsurz6zy8xrr72GE088sdgEdhMnTsTbb7+N0NBQU7F85ZVXTPeV6pS+eAlSf/ih2LKQAQMQfc3VyE9ORtyUqUe8psX0183/h97/ALk7dhR7rP5VVyF00EBk/vMPkj+bWeyxoK5d0GDiRLfLyNnCnfH47N271/zNlgb28bfGFFjYpaeslKtbt241V/f79OlT6uPurLO8spXHarlwLhOXOc+KzgCBASYfc4U1+aGrLRwly+CKDRs2mHEZY8eOPeKxkuNU+Dx2iRIRERE5NONjFGRmwicsDD5BQV53QGpEYMGAgelBeUW6U6dO5ory7bffbq5Yc9BsdHS0ed4zzzyDzz//3FztZt96XhVn9xRWbktWcKtS2JDBCO7V84gWC/KLikKj++8r87X1r7qy1BYLCunXD4Ft2x7RYlHVWJEnDkQu2WXHeqykoMNvZj6nqtbprpKtUVxvye25u022urCFxZXAprQylDbxGgMsa9Z2K3hhwMNuVRVhF7KjCV5ERESkdrGnZ+DQRx+ZvwO7dEFo//7wNjVijAUrb2yFYFBB/v7+eOCBB0x3HOcUoOxvz0G9DCqIg3vZslFaV54qLV9UlOna5HxjNyiyBQQc8ZjVDcrsS6NGRzxm9ZXzDQ8/4rGj6QZVkdatW6NevXqYP39+0TJWhBcuXFhmiwS767ACXnKeBQZ9R7vOsjCIsdZbHo5HYOYm3iwc+M3uTe5sc+jQoVi+fHmx9x+737lSBqtbFMeVWNasWVOsJYLdt/bs2VPqXBolW0pYDg6MFxERkboteeZnKEhJgS04GNHXXWfqmN6mRrRYlMYa5NqsWTPzPwcJs7J2/PHHF3seu0r9/fffHimjt2ClmVmVOG9CWFgYOnbsaLqZcRwAB2CXhsHd008/jVtvvdVcpWfWJ44XYKsSb0ezzrIwUOS4BFayrXWV5uSTTzZBAcdyTJ061VTmOeaDYxkYdLiKg6hvuOEGTJs2zewH94+BFLM2MXBg6we7V5WG3bAYCNx///1m7g3OifHQQw8Va8lgOVkmji3heBBmhmLXMQbAzDzFLFFWcPLHH38Uy7QlIiIidU9BdjYOvve++Tuoe3eEnVC8vustamRgkZ6ebiq0I0aMMH32idl1yOoWZWGXk6VLl5a5LvZh583Cim9tw640HMBcclyDczceHk8OiJ8xY4ZpCWKqVl5RtwZel4atQ1wPB2MzJSozKXFMizvrdKVs7PaWkJCA2267zQzM/+6770p9HTGomTJlCh5++GEzyRzH19xzzz3FntOtWzcToJSFXezYIsZgxhoH8e6775oMVVdffbUZaD1z5kyzHufxHJZPPvnEBFRMS8uWG7ak3XzzzaablYVd9njcPv30U3Ns2BrnHFTQW2+9ZTJccVC3iIiI1F3Js2bBnpho5q1o+H+3weZXI6voFbI5ati0v9nZ2TjzzDPN1dzffvutKHsPB8Tyyu+CBQvM1XMLK6OcYIyPl+bRRx8tmgPBWUpKSrGKoLVtdrNhpdYaYyC1E99HbGEpObfEscL3GrNjffjhhxpjUU3HV59lERHxBo68PGwdORL5+w+g0UMPov6ll6Im4UX5yMjIUuvONXKMhYUtC+eee64ZWPvrr78WSwnKScqoZGpO3rceK819991nDoR1Y3cqEXZn8lRQQQxcOUeGBm6LiIjUbSnffW+CCp/QUESedRa8mU9NCyo4GRqvJpfsBsMuN5xt+aeffio2EJbzFzi3YJTEVJ6MrpxvIiIiIiKe5rDbcfBwEqLArl3hU848bt6gRnTgYjYhDnRdsWIFZs2aZfrZW/MSNGzYsCgYeOSRR8yg2N69e5tB3M8//7xJ7cmBuCIiIiIi3iRt3jzk7tzJTDtoeMekUtPaexOfmtJ3i1mg2Cpx1VVXYdSoUUU35xYKDrpl95VvvvnGDLIljsMoOaBbRERERKQmczgcSJz+hvk7pE9vhPTuDW9XI1osOB+CqzMns7sUbyIiIiIi3ip94ULkbNrECbXQ8O67URvUiBYLEREREZG61Fpx8HBrRb2LL0Lw4ekVvJ0CCxERERGRYyjzjz+QtXo1bIGBiKlFY4UVWIiIiIiIHEOJr71u/g/u0wd+TtMreDsFFiIiIiIix0jWqlXI/PNPwGZDwzvvrFXHXYGF1DqcMHHJkiXlPufHH380M7xb4uPjcfHFF6N9+/Y47rjjkJSUZNazfv16t9Z7rLE8rVu3LrrPSfc4+V9BQYFHyyUiIiKlS3hlmvk/uFcvBHfvhtpEgYV4HFMMP/roo1W2vn379iE7O7vMx/Pz8/F///d/xeY/eeyxxxAXF4e5c+fiu+++M3OrcD2chLG09fJxBhq///47PInl4Uz1liFDhiArKwvvvPOOR8slIiIiR0pftAgZS5ea1opG99+P2kaBhXhcYmIikpOTj9n2vv76azPT++mnn160bM2aNWYGd7ZYcNb3+vXrY8+ePejWrVuZ2RwYaHA9Nc2ECRPwv//9z5RRREREaoaC3FzETpli/g475RQE96wdmaCcKbCoBdiFh7OS33fffejfvz/69OmDZ555pljFkn+/9NJLpptPu3btMGbMGPz7778VrpsTEp588sno0KGDmfV8E/Mtu7HOiso2adIkzJ8/31xhZwsAb9u2bTOve/jhh3HnnXeia9euGDduXFEQctNNN6Fz585m+e23324mWHTHRx99ZOZC8fEpfPuzK9Eff/xhKuNWGVq2bIlBgwZhy5Ytpa6jZ8+e5v+xY8ea5zMosVoQWG7ODs/yXXbZZdjJGTUPy8zMNM///PPPcc4555jjZrUucC6Xyy+/HB07djTHlMetZMvLggULTKtEly5dcNFFFxVbt4X7tnnzZvz1119uHRcRERGpPofeex95u3bDr0EDNH1qau081I46JiUlhTVa839JWVlZjvXr15v/qaCgwGHPyPDIjdt21SmnnOLw8fFxPPHEE6b8s2bNcgQFBTlmzpxZ9JypU6c66tev7/jiiy8c//77r+O6665zREREOGJjY8tc70svveQIDQ11TJs2zbFu3TrHV1995Rg7dqxb66yobIcOHTLPGT9+vGPPnj3mlpeXV/S6Bx980LFhwwZHfHy8OSaDBg1ynHDCCY7ly5c7lixZ4ujVq5dj5MiRxcrN8/vzzz+XuV+RkZGOjz76qOj+3r17HX369HHcddddRWXg/nA9K1euLHW9u3fvNvc///xz83zuM8s3YsQIU55ly5aZ/Z00aZKjSZMmjuTkZPO6tLQ087qYmBjHZ5995tixY4dZxvVx2UMPPeRYu3at4/fffzf7efHFFxdtf/PmzY7AwEBzTHg+3njjDUdwcLDD19f3iH3s2LGj4+mnn3bUVSU/yyIiIp6Uu3+/Y0OPno71nTo7kmbPrjV155JqxMzbNZUjKwub+vbzyLY7rfgHtpAQl58/YsQIPPjgg+ZvXs3mwOSff/7ZXOnPy8vDlClTTEvBBRdcYJ4zffp0LFq0CC+++CKmTj0yaubYAl5559iDm2++2SzjFXheZSd31lle2TjrelBQEMLCwsyVfGcnnnginnjiiaL7HP/w999/Y8eOHUXPnTFjBnr06GFaHAYOHFjhcUpJSTG3Jk2aFC1r1qwZAgICEBERUbRelqk81usbNGhQ9Bq2vCxdutQMBA85fO7YCjJnzhzMnDnTdFGysAXnwgsvLHafLRGPP/540bL33nsPnTp1MsezYcOGZl3cR+uY8HywC9frr79eavlKa80QERGRYy9uylQ4cnPh36wZIg/XpWojBRa1RPfu3Yvdb9SokRkDQNu3b0daWhpOOumkosfZDYj3V69eXer6mA2JFfCRI0cWW251H3JnneWVrTx9+/Ytdp/rbdOmTbEAhOuOiYkxj7kSWHDgNvn5Vf1bf9myZSYgY4Xf6urF/xMSEkw3p/L2ja9lFzB2y+JreLMyO/G1DCy4j+yW5ozBSGmBBffP2lcRERHxnIzlfyDt55/N302emgqbzVZrT4cCi3LYgoNNy4Gntu0OX1/fI5ZZlVtrgHFgYGCxx3m/rMHHVqW05Gss7qyzvLKVp2SrAddbWnnK24+SOCibz2erQlXjeAiOzVi4cOERj4WHh5e7b3ztpZdealouSmKrCHEf2bLirOR9C4MZtviIiIiI5zjy8nDgkUfM36EnnYTQ446r1adDgUU5GFG60x2ppuIAYVbuecWbf1tWrlxZNAi5JA7W5lVvDgDm31WxzrJwPa4EGuwWZLWUWBV1pog9cOCAGfDs6jkdMGAAVqxYYQZeHy22znBdzuVmBil2P+JjTZs2dWt9fC2PXcnuYM54Htj1yVlpLU5MN7thwwY8++yzbpVBREREqlbSp58ib9cu2AIDa++AbSfKClUHhIaG4pprrjFjJjjnASvD7L/PcQnW+ImSIiMjMX78eDzwwAOmwkuswHPMxdGusywc48AsRhUFFxzfwW5PzBTFLkesQE+cONFkiDr11FNd3h4DCo57qAwGD0xL65wli1mz2FWLmZ32799vlh06dAhPP/20OS7lYXYsBnGcz8NqfeG6nefauPHGG/HNN9/ghx9+MPeZgWvatMJJdpxxrEdUVBSGDh1aqX0UERGRo5efmIiEl18xfze67z741a9f6w+nAos64rnnnjPjEdi6wEHKDBg+/PDDI8Y/OGMq2bPPPhuDBw82gQav9Ds//2jWWRpWmHmFnd2UrHSzpWH3odmzZ+PPP/8022PledeuXfjyyy9L7W5V3oR8u3fvNgPBK4PpYBnkMMBgulmWj5V6Bl0cK8GB6Wxl4ViVsubDsDC1LSfmmzVrlhnIzuPN9L3OwQG3wQHzHPTO/T/rrLNw5ZVXHrGud9991wQkZXVjExERkeoX99RTKEhPR1DXrogaW5joprazMTUU6hDOecBKGyt7rJyV7OfOjEO86lxRVqCahHM7WFmNLJxwjrNDR0dHF3sur/Knp6ebK/+uDh7ieAser5LrcmWd7pQtKSkJGRkZpqLO55R8nTM+zm3xXJbEFhSOSyivYs0r/Wy1sK7+c0wCz7nVxYoDp9nqwIHm/v7+Za6Xz+Nric+1sNWBx6TkPloT63EwdlnjI/geZYsIA4zSWK013Hduh8eYrT5W16gzzjgDGzduLPP1dYG3fpZFRKR2yFq9GjsvvMj83fL99xA6aBBqY925JAUWTlQZqTsYELBrl1Uhry04/oSBIFtL6jJ9lkVExFMcdju2n30OcrdtQ+jgwWj59ltefTLcCSw0eFvqJLYI1LagorTsUyIiInJsJc/83AQVtoAANJk6pU4dfo2xEBERERGpAvbkZMQ//7z5O/q66+B/OGV8XaHAQkRERESkCiS8/IoZsB3QujVibri+zh1TBRYiIiIiIpWUtWEDkj77zPzd+NFHYTuc/KUuUWAhIiIiIlIJzPp44N77mB0GoScNQeiggXXyeCqwEBERERGphJTZs5HDSXP9/NDk8GTCdZECCxERERGRSsywHfdkYfan6PHXwL9Jkzp7LBVYiIiIiIgcBUdBAfbecisKMjLg37QpYm6+uU4fRwUW4jHXXnstNmzYUOb9o3XLLbfg33//Lfc5W7ZswX333QdvnPjt5ptvNpPVVMTT++hOWUVERLzRofc/QNaqVWagdvPpr8MnIAB1mQILcdkrr7yCmTNnVtkRe+edd7Bv374y7x+t999/H7t37y73ObfddhsaNWpUdH/ixIn45Zdfij1n5cqVuO666zB37tyjLsvWrVvxwAMPmKApJyfHpddwuwwIWKavvvqq2GNBQUHIzc3FYy7033TeR840zjJsYv/PY8SdsoqIiHibzFWri+asaPTAAwjq2BF1nQILcdlPP/2E33//3euP2F9//YXFixeboMHy4YcfYu3atUX3Fy1ahGHDhiEgIAAjRow4qu1cf/31GDVqFDZu3GiCpry8vApfM3v2bAwYMABpaWmIiYnBDTfcgJtuuqnYcxhwvPbaazh48KDL+8jAgmU4cOAAjiVXyioiIuJt7OkZ2MtuT/n5CDv5ZERdOM7TRaoR/DxdAKka+/fvx4wZM7Bnzx706NEDV111lakUW1hpZmvDoUOH0LNnT1xxxRUIDg4uevz5559H69atUb9+fXPl3m63Y+zYsejbt695/L333jPdi3bu3GmufNPkyZPxySefmNeFh4djzpw5aNq0Ke68807z+Lfffotff/0VPj4+GDlypLm5a9myZWY9vPLNslx88cXw9fUtepwV5o8++gh///03WrVqhUsuuaTCdb7xxhs455xzEBoaWurj3N6FF16Iu+++u1JX29kNaPr06fjmm2+OaHkoDffl1ltvxe23345nnnnGLDv++ONNYMMgpVevXmYZz2+7du3Mfv/f//2fS/vIddKzzz5r3idNmjTBgw8+aMp41113mfPE98iYMWPQp08f3HPPPZg6dSoaOM0YeuONN5ob3z+unh9XyioiIuJt9k2aBPvBg/CtVw9Np06BzWbzdJFqBLVY1AJLlixB586dzf9t2rTBP//8Y4ICCyv8rPTxajWDgGnTpmHw4MGmMmj58ccfzdXlRx99FNHR0eYK86BBg7BixQrzOCuH9erVMxVSLueNgQlfx8rwI488gpYtW6JLly5F4xyuvvpq8xpWbi+44AI89NBDbu3Xk08+aV4XGBiIFi1a4KWXXjLBCSvgFl6RZyW4cePGSEhIMOWqqMvRzz//jBNPPLHUxz744AOzTVbASwYV3EcGVWXdePycsQLuzhcNjzW7grFybjn11FPRsGFDfP/998WeO2TIEMybN8/lfezXr5/5v2vXruYYMUhhCwpbMU455RT8+eefJgjg+WVrCZenpKQUWyeDS+cuZq6cH1fKKiIi4k2SPv0UGb/9BthsaDbtFfhGRnq6SDWGWixqwYQsrMCPGzcOb7/9dtHyvXv3Fj3OCi9vzz33XFFlnAHIm2++aQIAC1sr5s+fX3TFmeMDWNFmUHLSSSeZymP79u2LWiwsDDDYdcj/8AyTbNlg95fffvvNBDBWxZZlvOaaa8y2K8JB3Axy+D+3SRMmTDABDrsLnX/++WY7rOyy249VcebjvLpf3oBiVo5LKwOvqvOqPffZuXJvYWWcx6AsrGBXBo83MfizMDBhS4z1mKVt27Zljv0obR8vu+wy8z4544wzTBcvSk9PN//zWDIosLBVqirOjytlFRER8Sa5O3cidspU83f0hAkIPVz/kEIKLFyQnJmLlKzi/eNDAvzQIDwQufkFOJCSdcRrWkUXdkGJTclGTr692GPRYYEIC/RDanYekjL+azWgIH9fNIoIgquY+YeVTnZvcda8eXPzP6+A83HninJUVJSpYDIYcA4shg8fXqwbS6dOnYoClPLwqroVVBADimbNmhUFFcRuOax4s+uMK4EFW0JCQkJMMMTgiPg/y7dq1SpTcWX5WQm3ggpiF6byAgsrQ1FYWNgRj/FYcT+sY1fSeeedh+qUlVX4PmK3Mme8bz1mYfnLyrZU3j6WZvTo0W6X1ZXz40pZRUREvIUjNxf7Jt0B5OUhqEcPNJh4q6eLVOMosHDBos0J+HbV/mLLBrWNxnUntTVBx+PfrT/iNe9cdVzh/0u2Y3tCRrHHxg9pgxPaxeDvnYfw8fLi2Yu6NY3ApBGdXD6BSUlJ5n/nDEfO4uPjzf8cCOyM961uThbnMRfESiLHWlSEgUrJbZbcHq+8s4tVXFwcXJGYmIiIiAj079+/2HIObO7evXvRdrhOZ5GRkfDzK/ttza5ZLIt13JxxTMW6detMRZtdj6wr+85docrLWsWK9ssvv4yjxf0lls15bAPHxbAlwFlycvIR++7KPrpy/qrq/LhSVhEREW9x4PHHkb1+ven61PyVl2FzuhgrhRRYuGBoxwbo3SLqiBYLigoJwMNndS3zteMHty21xYL6t66Pdg3CjmixcId1dX3btm3FutBYrK47u3btMl1qLLzPMRHucHW8ALfJQeTsa8+B28RxD7GxsS5vky0erFBffvnlZXYx4nbYosIr5VbZOIg9Pz+/zPWyRYLjDNavX4+zzjqr2GMsK7uTMTBhiw4HJXP8wbHqCmVVyFm2oUOHFh03nlt2Y3LGAMgaWO/KProz1sPaD+cxOJmZmcXuu3J+XCmriIiIN0j9aR5Svpxl/m4ydQr8Gzf2dJFqJA3edgGDB3Ztcr6xGxQF+Pkc8ZjVDYoaRwYd8Ri7QVFEkP8Rj7nTDcqq4HH8w5QpU0zfegvHShCvfPNx9qG3BtWyXzy7sjh3V3EFx2CwMlmR008/3VREmcLVwgHjbBE5+eSTXdqW1e2IrQQl53iwxhtwO7wq//nnnxc9/sILL1S4bgYNCxYsKPUxVsCZyYkVeVbKOQjauUzlDd5mJdtdjz/+uBknYnU9Y0YmHisLH2OF3rkbFgMpdjfjfri6j2x9YguDK+ePA+HZfYnd1pznBrG6PLl6flwtq4iISE2WFxeP/ffea/6OvOAChLtYl6mL1GJRC3CwMStuzAw1cOBAMwkax0tYV9s5kJopS3nVmANtmU6WaVmZWtQdHCfBQcCs6LLiyXSzZQU7DGSYmpSVfrYgMGMVK8kMTlzBtLV8LSvrHPjLbFPbt283FdUvvviiqLWGARVT53KMCfvxs2wVXUHn3BA8Vmzd4HZKCy5YueeV/7PPPtsMRuZ8FO5iKl6mcWXrEHE8C1tDOJDeStnKNLS9e/cuapF49913TWal4447zmSDYnDA7lXO4z44toRjLpwzf7myj+eeey4mTZpkWmLY8sJsWqXh/jMjFsvLY8+uTDyHzl3MXDk/rpZVRESkpnIUFGDP9RPgyMqCf6tWaPzQg54uUo1mczhfhqwDWPlkP3ym0rT6tFt4xX/Hjh1mcDFnDfYmrPhxQjRWJNllp2Q/d7YgsJLLK/ys1FpzIjinpOW4CFZoLZwMLyMjwwzOtrB7zerVq81yVhZ5Vbvk6yzspsSAgl2M2GrCK+HO2O2IrQ5WxbfkfStzEa94s9y8os+B2iW79bBMHC/Crl5MpcoKPVtGyuu2xEnneI45f4eVEYqBV7du3Yo9j5VkdkcqOT+DK3j82A2oJAYOVtkYtHD8AY+Phele2eLEc8aUsc5d2IhBDgNJpvktT8l95Ed94cKFJmMUUwAz0GBLBANG5zEdljVr1pgsWexix4CVLVAMVp2Pa0Xnx9WyVjVv/iyLiEjNkTBtGhKnvcp+xmj79WwElhjzWNfrziUpsHCiykjdwYrwDz/8YFpgvAnfowycrrzyygoDHU/voztlrY5tK7AQEZHKyFq9GjsvvczMrt340UdR76IL6+QBTVVgcXQHR5URkdpBn2UREamMvLg47DjvfDO7dvjoUWj2/PN1dnbtVDcCCw3eFhERERE5LD8lBTvHXWiCCr8mTdDkscfqbFDhLgUWIiIiIiIACrKzsevii5EfFwefyEi0+vAD+FZwlV7+o8BCREREROo8R34+dl91FXK374AtKAitPngfAeUkgpEjKbAQERERkTqNmRMPPPIoslatBvz80OKNNxDUubOni+V1atw8FkxRygm2mNs/Kqr4bNebN2826VSdMW1maalORURERERckfC/55Eyaxbg44NmLzyP0IEDdOC8ObD4888/zWRny5cvR1xcnJkYbNiwYcWew3z8s2bNKjbXAPPUWzMXi4iIiIi4I/6ll3Dw7bfN340fexQRp52mA+jtgQVni2a+e87YzAm5yjJ06FB8+eWXx7RsIiIiIlL7HJrxMQ6+Pt38HXPrLag3dqyni+TVaswYi8svvxxjxoypcCKtrKws07rBQISzTYv3YoAYHx9f5v2j9fXXXyM2Nrbc53B262+++QbeOD/DV199hYKCggqfW9o+7tmzB99//z1+/PFH5ObmmmPOvNRVfQ6qEsvDfbZs377dzGouIiJSGalz5iDuySfN31EXXYiYm27SAa0tgYWrfvnlF9xwww0YPnw4WrVqhe+++67c5+fk5JiJPZxvcnSWLl2K1atXV9nhGzt2LP79998y7x8tzjT9999/l/ucRx99FD/99FPR/W+//daM7SlZMWfXu3/++adSg8EWL15sKux2u92l17DCv2jRIlP5P3jwYLHHgoKCTKueK93/Su4jAwp2I5w+fboJOPhZ4DHnDNWlnQOWneVOSEiAJ7E848aNK3YMzjrrLBMkiYiIHO2s2vvuups/dgg77VQ0fvhhzVVR1wKL008/3QzeXrFihRnkza5TF154IbZs2VLma6ZOnWpmC7RuLZQ27KjxWNaG8Sz79u3Da6+9hvvuu69o2RVXXGEq3hZWphm8Pvnkk0f9nuGx6tKli1k3K+xsbasIW+I6duyICRMmYPLkySZ4/uyzz4o9h+V+6KGHkJeX59Y+vvnmm7j22mvNfr7xxhsIDAzE+eeff0SSBAsDIZZ73bp1qEmaNm2KCy64AI8//riniyIiIl4oZ/t27Ln+BiA/H8H9+6P5//4Hm49XVYlrLK86imeffTaio6PN3z4+PnjiiSdM5ai8VgtWrNjVw7rV5qucvLL7ww8/YNeuXUc8xkooWxx4rJyvUFt4VX3t2rVIT0/HkiVLzBVz54owWwDYvYhX9XkVmzde0bdel5ycjHnz5uG3334rek1SUhLmzp1rlh9tSxHLsHDhQrOOAwcOlPocBpncb5bDlS5CrFQPGTKkzIBh9+7d5vGwsDCz7YYNGx5V2XnM2TLwwgsvuPyaq6++2rQqbNiwAcuWLTOV5/Hjxxfr2nXaaaeZ1oTZs2e7vI/sSrRx40ZzDK3zx9aMiy66CPXq1St1Hdbniu8FPp/nwJXzwoCEzz906BC2bdtm1uPcGsR9YWsM348ZGRmlbputRCwfA6TSMFj7+OOPzftORETEVbn792PXJZfCnpyMoJ490fKN6bAFBOgA1rbB20eD4zHq169/RApaZww8eKvNmEWLV555tbtPnz6mMnfppZcWXdHl/dGjR5sxKcyixcxbvCLuXOF97LHHTLcxVhLbtWtnXkOs3LJi/ccff5hKHoMz6wr6CSecUPQ6Vu47deqEgQMH4qSTTsKnn36K6667Dj169DDbZapgVgTPPPNMl/eLmcFY8eVgfl5VZxnuvfdec7O8++67uOmmm0zKYQYvjRo1qnDsDSu6bOkqDSv0I0aMQL9+/cx+stuN5eeffy42HqGkgIAAE/xaeIytdbqCx5xjB7gdBs5044034uGHHzaBAffTet8ziQH3w7mLUHn7OHPmTNOtas2aNUUtHexyxeetXLnSpHcuyQpcfv31V/O6Zs2amWNT0Xlh0MGWDnZXYrDXs2dP815o37696Z714osvmvPFwJRBHMvGIIgYGHLdDCr4Xlq/fj169ep1RNn4GI/R/PnzzXtfRESkInmxsdg5dpwJKvybNUOLN6bDJzRUB64qOWqYPXv2OFisBQsWFFteUFDgSE9PL7Zs48aNDh8fH8f777/v8vpTUlLM+vl/SVlZWY7169eb/61tZuTkeeTGbbtq5MiRjkGDBjmSk5OLyv3VV18VPT5ixAjznNzcXHP/zz//dPj6+jrmzJlT9JxTTjnFERMT49i7d6+5n5OT4+jcubPjkUceKXrOGWec4bjtttuKbZuvCw8Pd2zfvr1oWVxcnFn20ksvFS176KGHHA0aNCh23Hkefv7551LvJyYmOqKiohxffPFF0eMbNmxwhISEOJYvX160ndDQUMfbb79d9Jwbb7zRrOe7774r9Vjl5eWZ98y3335bbHlkZKTj0ksvdURHRzuuuuoqR35+/hGvvf322x3nn39+mbcrrrii1G3Onj3blCktLc1RHp4zPo/75axXr16O66+/vtiyyZMnOzp16uTWPg4cONDxxBNPFN1PSEgw21u5cmWp54DrKflZdOW8cD/5Or43+D6yfPnll47GjRs7du/eXbSM75GWLVuabdGMGTMcERERjm3btpn7fE/zfcj3a0n9+/d33HPPPaUeg5KfZRERqduyt293bBww0LG+U2fHpkHHO3IP13ekcnXnko66xYJXhdn9ZM6cOVi1apXp9sIxDN27d8eoUaNw7rnnmiu4rmL3CHbVsAaKcp3Eq6K88Sorr3JeddVVpqsIr3Q+9dRTGDBgAC6++GJUh6w8O7o+/N/g12Np/eMjERLg59Jx49Vdngcef7LZbCbDFvG8sLsKr+z6+/ubZTyOPEdsVeD/Fr6GV6WJ527w4MHmnFTknHPOMS0hFvbh9/PzK7rCTryazfPFclhlKw+v0HM/uB7ryjnrvS1btjRX0HnFmlfbQ0JCTPch5+28/vrrZa6X3XN4Vby0cQU8HjyGTz/9dKnZyTiPSnWyWkNKdk1i97+SXX7YUlfWoOry9rGyXDkvFra2OH8HsHWJLSPs5sSudXxdeHi4+SxznBTHo7CViK0dbdu2Na/h+eB6Jk2adERZyjsGIiIiluytW7HrwotQkJEBv4YN0erjGabFQqqe24EFKwOsILBLA/tHszsMK6CsALBrAysIt9xyC2699VYzvoF/sxJSEQYSrHgSu3kwZShvDCR4YwWFXTBeffVVk9WGla8HH3zQVCpdWX9tZY2nYDek0ljjKayKmoXdUtgFpmRFzRm7kLlSceNgWmc7d+40FU3n88IAgM/jY66wyj1jxoxiyxlUNmnSpGjfObjZ6jZEHFNQ3vuB4yYoMzPziMfuueceE6ycfPLJJgBitypn7naFcpfVZY9ls4JE4riXkuNB+Nmz9sWdfawsV85LWe8LvpbnquRr2ZWpsLGk8JwOGjSo2OMl37uuHAMRERHK3rABu8dfa4IK/xYt0GrGR/Av8fsuVcftGvm0adPw+eefmwo+szSVVonj1VKmhWUfflZMmVmnIrxy7nz1vDSs6B3LTDDB/r6m5cATuG1XWBVQ9p93bjWwWIPdS17x5lVt67HK4hXsktssbVAtW09c3SavZPO9Vd5kiAyESm6Hlc3yxliUF+BwLAmD11NPPdVkhOIV+MaNGxc9zlYhXl0vS2hoaKUCC6sCzW1wbIqFCQfOOOOMYs9l+csKJt0N4tzhynkp633B13K8BLNTuXNOyxqgzf275JJLXC67iIjULanzf8X+O++EIysLQV27osXbb8GvxEVU8XBWKM4RwExArECVdWWYVyU5yJMVsTvvvBPeihUjdkfyxK1kpawsrFyydaDkVWBr/gNe6ebjzhmEeCWb2ZpOPPFEt44Hrw5zoHZFuF5eeWZaYAsDTVb6S16NLsvIkSNNUMpWK2fcPgMUazsc8OycDrW8TEmWU045xWQkKk1MTIwJKIKDgzFs2LBiiQHYFcrKqFTa7YMPPoC7eFysOTc4YJzBjXOlnZ81Dqjn4HtnLD8DoKPZR1fx881WFOdz7sp5KQtfy3lBSs7N4ZxViueUXemcs3uVdk75/mIygfKOgYiI1F3J33yDfRMnmqAiuE8ftPzgfQUVNbHFoqzUlFX1fHEPAxCmFuWYFlbsWBlmdihm42EFjUEeK8Qch8JsPZwj4Z133jEtBzfffLNb22LF95VXXsH7779vggxWFEvTv39/kw6Uwefdd99tWhCmTJliusVx+67o27eveS3LPXHiRHTt2tXMuMwMQp988ol5X3GsCLvR8Gr+XXfdZbJCsUWtotnbOZcDMxbxeDCAKO2qObtCcf94PBloNG/eHO5i9z6mWf3rr7/MfVbGmWWKXQetlhAG3hx3wGPKivxzzz1n0ssyZStb6Djeg8E899XCDFvMlsRjfLT76M45f/nll817i8eFFwwqOi9l4TlimlmOi+J7j61tDKqYecyaeJFjKfj+ZGsoM14x9THT2pbE7fE4uvp+EhGRuuPghx8ifupTZvK7kEGD0OL11+BTid9CqcbAghUApsR0BStMrl6hlqPHLmSsxHJCNlaC2d2E3dUsrHyzcsaKH7v6MAjh7OXOqVSZIpZpZp0xdS1bOyysSHIAONdhja8p7XXEcThsReFzGdywwl8yxSvL5TyOoeR9VqpZuWeFnFf22TrDcQ7O4w2YwpYTwfE9yfEWnEeD439K9vd3xjJz31iZ58BgawB6hw4dip7Dgc/c1u23327Kzu58FQUsJXGQMlvtrH2zrvKzy5oVWHBOCiYnsFx++eVm/ziImV2imM6XY4ycsTzXXHNNsW5aruwjx45wgLSltAnySp4DDmhnt0fOx8HWFAYWFZ0XBkhcT8lub+wKxVYUvi/4P48nAybntMd8DQMxzi7O1hqmquV79X//+1/Rc5jIgcE0z7uIiIizxDfeRMKLLxbOqH3KKWj2wvPw0TwVx4yNqaHceQErr6xYWBITE03XBl4VZYWE3SRY6eTVyPvvv99c3axJeFWbZeMg3IiIiGKPZWdnmwGmrPg5V7ql9uG8DG+99Za5Gu9N+B7lnBCcC6Ki8Sreuo8V4bwZDGo4E3xZ9FkWEal7kj6bidjHHjNBRcTZZ6PplCdhq8MJfo5F3bnSgYUzboBdJZjik1dVeaWSq2M/anZp4FVkK31pTaHAQqT2U2AhIlJ3sO554N77kPLNN+Z+vUsvRaMH7ofNKWukHJvAolJHnN1u2J+e/bmtgdzs83/BBRfgvPPOM6k7RURERESqQ4Hdjj0Tri8KKqKvvx6NHnxAQYWHVKp9iBlznLO3OONyZm0REREREalq9uRk7LriSuRs3mzuN7hjEmKuu04H2oMq1WIxZMgQ09eZE9bl5uaaZcxmw4Gn7NvNuQBERERERKpSzp492HbGmYVBha8vGj/xuIIKbw8smLGFGWM4xoKTgzETDyfnYtcoTmTHLDQiIiIiIlUlY/ly7Bo7DvaDB+EbFYVWH36AemPH6gDXAJUeKs8MNWPHjjX55tn1iSkwmYa0QYMG8FaVGM8uIjWAPsMiIrXzuz1x2jQkvj6dfe4R1L07mk97Bf7lpF+XY6tKcnAxDz7z5rMblDdPiGfNU8BuXZWZVExEPIuzyxPnXREREe9XkJODfZPuQPr8+eZ+xBmno8mTT8JH0wPUrsCCs+ZOmDAB69atwx133GFmDuYkepzt+YMPPoA3YWYrduXiXByskHBiNxHxrqtZDCri4+PNBQ93JzUUEZGaJy82FrvHX4vcbduYfhQNJk1C9LXjTSZSqUWBBSfH44zFDCji4uKKlnPm5+3bt5t5LI4//nh4C75BOU6Ek+Tt2rXL08URkaPEoKK8mclFRMQ7ZK5Yib033WQyQNmCgtD85ZcRdtIQTxdLqiOw4DwWHE/Bwdv/+9//cODAgaLHTjzxRPz8889eFVhQQEAAOnToUJTlSkS8C1sb1VIhIuL9kj7/HLFPTAby8uDfvDlavPsOAlu29HSxpLoCC3Y3aNq0qfm7ZHNUXl6eGXPhjdgFKkh99kRERESOOUduLmKfnILkmTPN/fCRI9F0ypPwCQ3V2ajhKjWIoHv37li4cKEJIJwDi6SkJHz++efo169fVZRRREREROqA/IQE7LriiqKgIvL889HsxRcUVHgJm6OSeRlPPfVUZGdnIyYmxnQfOu644/D222+jefPmZmB3TeuSkJqaisjISKSkpCAiIsLTxRERERERAFmrVmHPzbeY+Sng54eGd92J6Cuv1LHxorpzpdMefffddxg6dCjWrl2LBQsW4J133sGYMWMwb968GhdUiIiIiEjNk/TFF9h1+RUmqPCJjESrDz5QUFEXWyy8jVosRERERGrQeIonJiP5iy/M/dCThqDp00/Dz4vnRavLdedKDd7mPBUrV67EZZddhv79+1dmVSIiIiJSh+TFx2PvTTcje+1acz/m/25DzIQJsGkeMa9Vqa5Q7dq1wx9//GHGVXTp0gWTJ082c0CIiIiIiJQ3P8WOc84tDCr8/dH4yclocMMNCirqcmAxePBgMwne1q1bcckll2DGjBkm2ODy6dOn49ChQ1VXUhERERHxekkzP8euyy+HPSkJvtHRaPPFF6h3/vmeLpZUgUoP3iYGEw899BA2btyIv/76y3SLuu222zBlypSqWL2IiIiIeLmC3FwceOhhxD7yCGC3I6h3L7T9aS6COnfydNGkilRqjEVJq1evxsyZMzFr1iwUFBSgpWZHFBEREanz8vbvx54bb0LOpk2cVRkNbr8d0ddde8QEy1LHA4tdu3bhk08+wccff4x169Zh0KBBuOeee3DRRReZuS1EREREpO5K+f57HHjwITiys2ELCECzF19E+MnDPV0sqWmBBeesuO6669ChQwdceuml5sZuUSIiIiJSt9nT001AkTZ3rrnv37IlWrz5BgJbt/Z00aQmBhadOnXCb7/9ZgZri4iIiIhYs2jvu+tu5O3ZY+5HXXQhGj/wAGz+/jpAtVilAos///wT+/fvV2AhIiIiInDk5yPh1Vdx8I03gYIC+DVtiiZPPI6wE0/U0akDKhVYNG7cGP/880/VlUZEREREvFLu3n3YO3EictavN/fDTx+NJo89Bt/wcE8XTbwh3eyZZ56JFStWYO7hvnMiIiIiUvckf/sttp95ZmFQ4e+PRg8+iObPP6+goo6pVIsF08omJCRg9OjRqF+/Pho0aFDs8WuuuQZ33313ZcsoIiIiIjWQPS0NsU88gdRvvzP3/Vu1Qos3pmuAdh1VqcCiT58+ePTRR8t9XERERERqnwyOtb33PuTv3w/4+CDqQg7Qvh82vyqdJk28SKXOfO/evc1NREREROqGgowMxE59Cilffmnu+zdrhqbPPouQvrqgXNdVaowFORwOfPbZZ5g4cSI+/fTToknzli9fXhXlExEREZEaIn3ZMmwdMbIoqAg7eThafz1bQYUYlW6r4gzbS5YsQXR0NAICAnDxxRcjMjISp512Gv766y/zt4iIiIh4L3t6BuL/9xySP/3M3PeJikLTqVMRPnyYp4smtaXFYunSpWYuiw0bNuDKK68sWh4VFWXmtpg5c2ZVlFFEREREPCTt119NxicrqIg460y0/+UXBRVStS0Wa9aswahRoxAREQGbzVbssVatWmHnzp2VWb2IiIiIeEh+Whr233EnMn77rWgsRZMnJyN00CCdE6n6FovQ0FDEx8ebv0sGFpzfghPoiYiIiIh3Sf76a2wbNrwoqIgcOxZtv/1GQYVUX4vFyJEjzaDt77//vmhZVlYWnn/+eTNp3ssvv1yZ1YuIiIjIMWRPTkbcM88g5avZ5r5fo0Zo+swzCB04QOdBqjewaNiwIT788ENceumlJqAICgrCiy++CH9/f7z77rumO5SIiIiI1Gz2jAzETZ2KtJ/moSAtzSyrd8klaHjnHfAJCfF08aSuZIU666yzTHpZtlDs27fPZIfiuAt1gxIRERGp2QrsdhycPh0H33kXjsxMsyywY0c0fuhBhBx3nKeLJ16mSqZGZBYopp2lvLw8pKSkVMVqRURERKSapHz/PeKeehr2xERz3zcmBg0nTULkOWfD5uur4y7HfoK8hx9+GH/88Yf5e8uWLWjZsiUaNGiAsWPHmsnzRERERKTmyNq4Ebuvm4D9d95lggpbcDAaTLod7X+eh6jzxiioEM8EFqtXr8aPP/6IgQMHmvtPPfUUTjrpJCxbtgwrV6403aPc9ffff2PGjBmIi4sr9XG73Y7Fixfjyy+/xKZNmypTfBEREZE6I2f3buy87HLsPHcMMhYvBvz9Ue/yy9D+1/mImTABPsHBni6i1OWuUGypGDDgvywB8+bNMxmievXqhUsuuQT//PMPRo8e7dK6+Nr77rsPmZmZ2LhxIxYsWIBGjRoVe05SUpLJRBUbG4tu3bqZGb+vv/56PPfcc5XZDREREZFaKz81FbGPPoY0XvAtKDDLwkeORMM7JiGgZUtPF09qkUoFFiEhIWbANv37778mM1TPnj3N/YyMDERGRrq8rpycHEyfPh1NmjRBixYtSn3OAw88gNTUVKxbtw7h4eGmZYQzfDPYOO200yqzKyIiIiK1isNuR/KXXyJu6lNwZGebZcG9e6PRffciuFcvTxdPaqFKBRaszLPF4OKLLzbdothKwYnyOLaCLQ7vvfeeW9mlaO/evaU+znV++umnuP/++01QQSeccIJpMfn4448VWIiIiIgclvT55zj04YfI3brN3Pdv3hyN7r8fYcOHHTGpsUiNCCzYVckKIMaNG4e77rqrqPXi9NNPN12iqsqePXuQnJyM7t27F1veo0cPM8t3eS0hvFnY4iEiIiJSG6X//jtiH3sceTt3mvu+kZGIueUW1LvoQtj8/T1dPKnlKp1uli0GzuMsiAFFVQYVZKWwrVevXrHl9evXLze97dSpU/HYY49VaVlEREREapKcHTtw4MGHkMWLrczK6etrJrhrcPNN8I2K8nTxpI6odGDBeSveeecd/PDDD6YbE8dInHrqqbjxxhsRXIXZBax1paenF1uelpZW7nY4IHzSpEnFWizKGsMhIiIi4k0KcnOR/NlMJLzyStGM2aFDh6LRPfcgsG0bTxdP6phKBRb5+fkYPnw41q9fj/PPPx/9+/c3aWKfffZZ0z1q+fLlCA0NrZKCMhjw9/c3s3w74/22bduW+brAwEBzExEREakt7OnpSJz2KpK/+goFh7t5B3Zoj0b33YfQE07wdPGkjqpUYPHtt99i9+7dZj4JTopneeaZZ3D88cfjww8/NC0XVYHBwSmnnILPP/8c48ePN8sSEhLw66+/4qWXXqqSbYiIiIjUZPb0DBz66EMkzfgY9oMHzTLfevXQ4LbbEHXB+bD5VbozishRq9S7Lz4+HqNGjSoWVFBYWBjOPfdc87irtm/fbtLHcq4K+vnnn03XKqavtVLYPv300zjxxBNNFioGLu+++64ZzH3VVVdVZjdEREREarycXbuw57oJyNu929znYOx6V1yOmBtugO/hjJkiXhtYsML/5ptvmi5Rfk4RMlPDcvK8G264weV1cT4Ma6buSy+91HRx4o1zZViBBf9ftWqVGdPB9LYMKCZMmICAgIDK7IaIiIhIjW2hSPnma2SvW4+Ub79lP3TAZkPk2Wch5taJCGjezNNFFCliczAKcDPt67ZthTmR6Y477jCV/2uuuQZNmzY13ZM4r8TmzZtNoNChQwfUJBy8zYn7mEkqIiLC08URERERKXUMRcr3PyDpo4+Qy9SxdrtZHjpkiJkxO6hzZx01qXF1Z7dbLGbOnFk0X4WzJUuWHLHsjTfewHPPPefuJkRERETqrIw//kDcU08jd9s2OHJzzbKg7t3R8M47EDpokKeLJ1J1LRZ8uv1w1FwRHx8fc6tJ1GIhIiIiNU3+oUPmlrtlC+Kf+x/y9u0zy/1btkTD2/8P4aNGacZsqX0tFpwG3nk8hYiIiIgcHQYQKXPmInXOHOTv3w/74SQ2vtHRiLn5JtQbO1YzZovXqHSEcPDgQTz++OP47rvvik2Q98QTT5gxFyIiIiJSnD0tDQffeQdpv8w3wYUjK8ss9wkJQf3x1yD6qqvgU0VzgYl4RWCRm5uLk046CQUFBbjpppvMJHaxsbFm/oqBAwdi7dq1pulEREREpK5jd/LcHTvgGxWFQx/NwKH3P4AjO7uohaL+5Zej3sUXwVd1J6mLgcWPP/5oxlusWLHCZIay3HzzzSbg+PTTT91KOSsiIiJS2zjy8pDxx59Inj0b2atWIT8xEY6cnKIxFNHXXIPIc8+BT1CQp4sq4rnAgvNMMIBwDirMSv38THcozsotIiIiUlel/jQPKV99hewNG5CfkMBmC7M8qFs3RF93LcJPOw02X19PF1PE84FFq1atTErZrKwsBAcHFy3nhHnz58/H5ZdfXhVlFBEREfEKeQcOIPPvvxHcqxfSFy/GoQ8+LJopm0IHD0b0teMRMnCgsjxJreN2utmSYyz69OljUspeffXVaNasGeLi4jBjxgwcOHCgRo6xULpZERERqUp5cfHI+udvpC9dhuw1a5B/8GBhdqeCgsIn+PoiYvRoRI+/BkFduujgi1ep1nSzzgICAvDbb7/hsccewyuvvIJ9+/ahcePGOO200zB79uwaF1SIiIiIVAV2a/KtVw8F2dmIfeIJZK1eDfvBg/8FE+zu1LMnIk4fbYIK/0aNdOCl1qtUi4U3UouFiIiIuMtht5uMTllr1yJr1Wpk//svfCIikLVyZdFAbArs3BkRp5+OiNGjENCihQ60eL1qbbHg+Al3Jshz9/kiIiIiNYE9NRU+4eEmq9OBBx9E1up/UZCWBntycrGWiYA2bQqDidNHI7BdO4+WWcST3K7xT5s2DatWrcI999yDLuX0E9y6dSteeOEFE+FMmTKlsuUUERERqVaOgoLCVol//zUDr3M2bDTdnbLXry+ab8Li37y56eJkgonOnTUQW+RoAosJEyaYQKFfv37o1q2bSTfbsWNHE0CkpaVhy5YtZtzFypUrzRwWd999tw60iIiI1EiO/HwzuDp361bEPv44crbvgD0lhV0uCp+wY0fRBHahAwciZNBAhA4aBP8WLRRMiFTVGIuDBw/i/fffx5w5c7BmzRokJSWZflcMNkaOHIlrrrnGDOSuaTTGQkREpG4ryMlB1qpVSP3+e2T8+Zfp6pS/f3+x53D8ROjAAQgZOMj8H9C+vQIJqZNS3RhjocHbIiIiUifkJyUh7skpyPzrLzP7Nez2osdsAQFmbgm2RrBVIojdmzRxnQiOWbpZERERkZoqPy0d6fN+QuqcOSjIyDQpYZ0HXfvGxCBs2FCEDx+O0OOPh09IiEfLK+LtFFiIiIhIrZlbggOtU77/wQzAzo+NLZYKljjQOmz4MBNMBHXvDpuPj8fKK1LbKLAQERERr8LhofkHDpggImvtOmT9/TeyN20yqWBLsvn7I2TQoMJgYtgw+Ddt6pEyi9QFCixERESkRmOWJrZAcGI6DrrOXreucC6Jknx8ENC2DYK6dEVQt64I6toVwd26wSc01BPFFqlzFFiIiIhIzZpLYts2ZK5aZYKIrJWrkLt9+5FPtNngGxWFwPbtEHzccQgbPARBnTtpnIRIbQ4sYmNjkZycjM6dO1f3pkRERMTLFGRmInPFSmStWIHMlSuR/e+/KMjIOOJ5tqAg+DVsiHoXX4yQ/v3h37oV/MLDPVJmEfFQYDF37lwsXLjQzHkhIiIidZsjN9dkZ8pY/gcyli5F1po1xdK+ki04GME9egB+fgjq3g1hgwerS5NIXQosFi9ejDfeeOOI5du3bzczc4uIiEjd47Dbkb1+AzKWL0fG4sWmexODC2e2kBAEtmljsjSFnngCwk8+GTY/9dYW8TZV9qndtm0b9u3bh5tvvrnYcrZWpKenV9VmREREpIbL3bMH6Yt+Q8by35H5+/IjujYxkAgfNhQhAwYgqGdPBHXpolmtRWqBKr0c0KpVK1xwwQXFluXk5JjWDBEREamdHPn5yFq5Eqk//4L0+b8gb9/+I1K+BrRrh9CBAxA++nQE9+qpQEKkFrI5mAy6CmRlZSE3N9dM+V1bpiUXERGR0jHda/riJUhnz4SFC4u3SthsCOzYERGnn47Q4weZtK/q2iTindypO1eqxWLGjBno2rUr+vbti2AOtAoOrszqREREpAangc3ZuhVp839F2k8/IWfTJs5UVyxrU3CvXiaYiBg9Cr66eCdS51QqsAgKCsKwYcMwa9YsnHbaacUe27NnDzZu3HjEchEREan57OnppnuTmZhu9Wpk/bPiiLES/i1aIGLUKDOrNYMKm6+vx8orIl4eWHA8RVpaGs4991y8+eabuPTSS5GYmIgpU6bgtddew1133aXAQkRExBsmpdu5E2nzfkbm338hZ9Nm5CckHPlEX18EduqE8BEjEHnmmQho3swTxRWR2jp4++qrr0aTJk0wbtw4fP/99/jhhx/QvHlzM28Fl4mIiEjNUpCTY8ZFpP26ANlr1iD/YCIKUlKPeJ5vdDSC+/ZF6IABCO7dC0GdOsEWEOCRMotIHQgsmPVp8+bNplvUZ599ZlooOCmej49P1ZRQREREKqUgPx85GzchY+kSJM/6Cnn79h05KV1gIAK7dEZIn74I7tsHIb17w69BAx15ETk2gcWiRYtw2WWXmeDi/vvvx3HHHYfzzjsPEydOxMsvv6zgQkRExAPyU9OQvuBXpC9ahOw1a5EfF3fEpHQ+oaFmHonQQQMR3Lcfgjp3MmlhRUQ8Elhs2rQJ1157LSZNmoTw8HCzbNmyZRg1apQZf/Hxxx8rU5SIiEg1YsCQ+e+/yNmyFfaEBGT+9RcyV64E8vOLPc8nLAwh/fsjZOBAhAw4DkGdO2uwtYjUzHksnCUkJOCMM87AiBEjMHnyZNQkmsdCRES8mT0tDWk//4K0n3826V/z4+PhyMk54nm24GATSHBSOgYTZnZrvyqdF1dE6oDUYzWPRVkaNGiABQsW4LfffquO1YuIiNQJ+QcPIm3BAmQu/wPZGzaYdK/5sbFHPtFmQ0Dbtgju0QNBPboX/s9AQl2bROQYqrZLF6GhoRg9enR1rV5ERKRWKbDbkbVqNfL27kXO+vVI+/VX87fzJHQW/2bNENSjR1EgEdS1G3zDQj1SbhERi9pERUREjjH2QrYnJSF94SKkL1mCnA0bkLd/f6ldmnwiIhDcpzeCe/REcM8eCOreHX716+uciUiNo8BCRESkmiadY4sD54vI2bYduXv2mOxM9oMH4cjPR0F6+pEv8vU1g6o5izXnjeD//i1bwmaz6RyJSI2nwEJERKQS7KmpyFi+HJl//43s9YdbHrKyzHiIkilei7HZ4Ne4MYJ79URwr94miAjq2gU+QUE6HyLilRRYiIiIuNJ1KTkZefv2I2fLFmStWsVBEcg/lISsFStMt6bSf2X94N+kCQJat0ZAixYIaNUS/i1aFv7fvDl8AgN17EWk1lBgISIiclhBTg7yExJMlyWmcQ3q3Qf5sQdw6IMPkLVipUn1ytaII/j4ILB9ewRxDESXLoWBRMuWJqhQilcRqSsUWIiISJ2Tf+iQGf9gT0lF2JDBZlnsk1MKU7qmpZnuTezKxBvs9iNe79+ixeGMTMzMxKxMXeETEuKBPRERqTm8KrD46aefsJKziZaYM2P8+PEeK5OIiHgHBgvJX84qnFSOA6izs1GQnY30xYuRvW4dstesKXVMhG9MDIK7dzetESaYYFamevU8sg8iIjWZVwUWs2fPxsKFC3HuuecWLQvSIDcREXFiz8xE9r//Imv1amRv3AhHdo7pmpR34ACyVq40wQMzMjny8szzs1evLnqtT2ioCRwK07oWtkb4sTuTsjKJiNSuwIK6d++Op556ytPFEBERD3HY7bCnpCB782bkbNyInK3bYD90EPlx8cjdvdt0ZXIFZ6UO7NKlWGtEQJs2sPn4VPs+iIjURl4XWOzbtw8vv/wyIiMjcfzxx6Njx46eLpKIiFSxrLXrkJ8QbwZQ5+7chdy9exHQrJm5n/nPP+b/0makdg4a/Bo1gl/jRvBv2Ah+DRua+/6NCv/nff9GjWALCNC5ExGpq4FFWloaNm7caAKMCRMm4KGHHsKDDz5Y5vNzcnLMzZKamnqMSioiIiVTtiIvz1TmmV0p448/TAtD3u49pptSQWoqgnv3Nn9n/vln4TwQpcxEbbEFBiKgVSsEdGiPoA4dEdi+nRlUzaDBNypK3ZdERI4xm8N803uHNWvWmK5QVl/XWbNmYezYsViyZAlOOOGEUl/z6KOP4rHHHjtieUpKCiIiIqq9zCIidWqeh717TWsBB0ZnrlqFrNX/mjke7MlJsKelwzc8HL4REWYSOd5QUFDhujnuIaBdOwTy1r5d4d/t28O/aVN1WxIRqWa8KM+eQq7Unb0qsChNkyZNcPPNN5fZalFai0WLFi0UWIiIuMiRn2+yKOVu346cHTuQt28f/OrXR96BWDPjtD0xEQWZnGW6cDC0Wzj7dEwM/Jo2gX+TpvBv3Bj+TZuYGanN/SaN4RsdrdYHEREvCCy8ritUSb6+vkhPTy/z8cDAQHMTEZHSFeTnFwYNmzYhZ/sO5O3ZU5h21dfHdFNietbyuiSVZAsJgV9UlOmO5FuvXuH/Jf72a9jAtDj4N2yocQ4iIrWE1wQWdrvdjK3o1q1bsXktONZi6NChHi2biEhNl7tnDzJXrkLOpo2FYxriYgEHTHYl0yUpP7/ilfj6mgHPTL/KGaXZmmD+blz4t2/9aPjWi4KPBkSLiNRJXhNYsMfWlVdeiZYtW5rgYvfu3Zg5c6bpBjV69GhPF09ExKM4J0PW2rXIi41DzubNyN3Jloe9ZjxDzrZtyI+LK38FNht869cvbEU4HDj4NWlcFDT4NW4Cv5ho2Hx9j9UuiYiIl/GqMRYFBQWYO3eumX27Xr16GDx4MHr27Flt/cRERDyJX8/MjMR5FXxCQkzK1cy//jaDofNiY5G3by/g44vAdm2Rs2kzMn7/3QyaLotfgwYI6NABAS1bFrU4FAYQTdQlSURESlWnBm+7S4GFiNS44CEtDT5hYSaASFu4ENmcwyE+3gyYNilY+/SBb0Q4Mv7+B9lr1hSmYS0ngGDLQ2DHjgjs0AGBHdoX/t++vcnIJCIi4o46NXhbRMRbMivZ/PxMIJH20zzkx8Wabkt5sQdgT05B1LhxKEhOQtr8+cjds9cEFEzfykngMv/6q+wWiDZtENC6tQkcAjsykOgAv+joY75/IiIiCixERCoZMHAANG+cb4GDmznBW+rcn2BPSS58LDkZNj9/1L/ySuTu2IGD778PR2YmCjIzTbcmZmDK/P33sudwaN26KIAo/Ls1Alq1hm9YqM6diIjUGAosREQOc9jtKEhPh29kpLlv5mhISzNBgD0jw3RBijr3XNNSkPTVV0j/5RfT2sCB0wwO/Fu2QEDTZiYDU/bGDWZeB0dWlgkg2PKQ+t13pR9rX18ENG9eGDxYAUSb1ghs0wa+MTGaw0FERLyCAgsRqXPBAwMBn6Ag5MXHI33BQuQnJBSNaWC61KaTJ5uAgi0LBWnpcBTYgbx8FOTkIO2X+bAfPGgGT5dM0cp5ICrKuuQcNBQGEW0Q0LyZ5nIQERGvp8BCRGqdgtxcc5Xf5u+P7A0bkPXvmmLBQ9iQIah30YWmG1L6ksWs9ZsWB7ZWcKK4Tf2PM39XyMfHzBrtGxMNv+gYMxt10d/R9eHL/2OiTUDBxzjGQkREpLbSr5yIeBW2NrDlgDNBW4OU0375xQx4zk9MgD0xEfaUVMTccguCu3dDzo4dyPhjeWHwwC5L2VlI/vILJLz8MuyHDpW7LXaJOmIyuCZN/0vTylmjFSyIiIgYCixExHODnlNTzeBkn8BAZG/ejOx161GQWZhKtSAr22Q6ihg10nRZin/6GRTkZAP59sIV+Pqi+SsvmxStbJXggGkTPNgLzMNxT01F3r79yGeXpXKyajtnVioaGN2ihQkcWDYRERFxjQILEanSSSw50Dk/KQkFSUkmG5I9PR1BnbugID0NyV9/g7y9e02mJHY1YnDBVgVbUJDpgsRAgN2LzOzOfr7wDQtHytdfm8AgP+kQbL5+pnuTzY+P+2P3Ndcgb/eewqCinOCBc0QEtGqlzEoiIiLVSIGFiByBcy2w8p+7cxfydu9C3v79ZhAzxyfk7tyJvAP7UZCdYwYvO+z5AOv0DofpalReBb80ebt2lf2YG+sxaVkZPLRuBf+WLU06VnO/VUszxoFjLkRERKT6KLAQqQNBAlOesuWA4wE4iDg/ORmp8+Yhf98+5B2INQOb2brgV6+eyXaUu3v3ERmPjpqvb2F3p7BQ0wLhEx7u9HeYmQ3aJzSs8O+wMIBjFgoKzM10ayqww2Hd5/9c5ih8jGMgGEgEtGwJ3+hoBQ8iIiIepMBCxMswe5EtIMD8nb1pswkI2M2IXYsYPIQPHw7/pk2R/M03SPnmW/O4mYwtOxu2wEBTQWcLBOyHxyo4ySmlCxGzHvk1aoSAli3g37wF/Bo3gn+jxiZYsPkf7ppk3fz+uw/rvo/PMToyIiIi4kkKLERqCGY6MmMSklPgExJsBhCz6xHHGDDLUdEMzr4+aPb88+Y1SZ99asYYML0qWxgKsrJMMJG3b5+Za6Fcfn6F2Y6aNYN/s6YmGLEyHvk1bgz/xo3hExx8bHZeREREvJ4CC5Eq7nZUkJGJgtQUU8kPbNfOLE9fuhT2Q0koyMosmok54owzTBcedklK/eFHkz7VEjJwIKKvvsoMZGagYQsJhn9wEHwbxMCRlY3Yp55C7patyNmyxczNUBYTNLCloVkzBJgAollhANGsWWGqVA6SFhEREakCCixEXFSQkYH8Q4cOtx4koyAlBX6NmyCkbx/TtSjh1VdRkJoKR17h2ARmOmr+4gvm74zfFpsWB7ZE2IKDzWPsusSxDT4hIQjq1bNwZmemWc1IR/bGjdh9zXjkxcchPzauwsna2MIQ2KGDSc9q/u/QHoFt2ypdqoiIiBwzNgcvsdYhqampiIyMREpKCiIiIjxdHPHQGAUOXjZjE5j2NCcXYYNPNI8lffGFaQFgiwIDCf5f/5prENi6NZJnzULaT/PgsNtNmlSOc+DyoK5dTJelrLXrwLxDDg42zsuHIy/XDDRmsGCNcbD+NtmT3MQxDRzrwC5KAe3aFQYP7QuDCA6AFhEREfFk3VktFsfYD5/MxdaEdFzYpwmiO7YzFUWlwXSfiYc5izLTnR7+32QbCggoTInKWZjjYk2QkJ+QCN+YaAR16GDSpybNnGkGLhcFCD4+SO3TxwQS7FrELkxF683NNd2UShvoTFl//VW5N4TNZlowfEJD4N+goXk/FA6ObgS/Ro3h3+jwskaNCjMmiYiIiNRQCiyOsdf+icc6/2hM3x2LEbu/wzn7/0brRhEIbN2mcPKutm0QeHgWYHaR8SRmGMrbvbswg5Cfn6nYMktQYerQMPgyK9Dh7ETlYQWd6ypIS4M9Lc3Mh8AsRmZZZpbpPmRPS4U9NY1NaLAF+JtxBTm7dprxBBzUzAo+sxmxws1KPydE4/8mLSmDDPO6gMLUqhyrUEYgUBbOzVAhm82cEx+n4+AbFlqYKrXouHDZ4b95fBg0BAUXdoEKCjKDoXmz/maWJgWWIiIiUhsosDiGCgocGNPUFxmxadjpH45v2g3Bt21PxKAD6zDmj8Xo/uOPpitN0clhl5dWreDXoAH8oqPNVXe/6Bj4xUSbnP0mDSgn/mJqz6OdBC052QQPuYdv5u9du5G7Z0/FWYVY1w4IKEwvygqylWb0cCXfzuAhKbnq5kNgsFNOmUrtXuTnd7iSH2ICIZ+Qwgr/ETcTDIQUCwqKggUGDua1wUqdKiIiIlIGjbHwAFboF29JxDuLt2HRlv8qyp2QjvMT/8WJ6xfB51DFlXoLJwnzZZBRr57JImRmQHYUFM2GbO4X2E1/f3b/gb2wm09+XOFYgnLXzcCFA43T0gpbCA53HzItBW4yQUhgIHzr14NvVFRhJZ2tAMEh/1XmIyIKW0J4RT8oELbAINgCA+ATFFT4es6LwAnUfDlfgt9/983/DGz8TKYj8/rDLSpqERARERGp/jEWCiw8bEtcGt5duhNfrdiLnPzCynqjiEBc2rMBzgtJRfC+nSZNKbv35CcmInfHjsK5DjjomJmCjqKCXxJbRuBjg29UPfizdYRzG7RsgYhRoxDQtGnhIOccTsrmb8YwMDiwZnO2JmUrSM8w2Yx4n4+brlIc8xAeXtSFygQAIiIiIuI1FFhU0cGpLqvmLUV+7AG0cGTCl5mCsjKRN3AwZmdF4oPftiIhuzBYCHTYMTJ3L86qn49THriVF/ex96abC1sheFU+gF2gbIi6cJwZm5C26DezXl7l9+FjAYEIaNEcAc2bmwHJHMjMK/mm4h8UZMZxMD0p/xYRERERKUmBRQ0PLCb/bxY2HMyGn68PWgQUoE2IA8NO7I52g3ojY/8BfPPrWny0x44NKf8NQG4aGYQzezXF6R2i0LN1DHyOclyFiIiIiIirFFhU0cGpLvYCB/YmZWJrfLq5bYlPxxXHt0LP5lFYti0R6/enol2DUGTm2vHz+jj8siEe6Tn/DYBuFR2CM3o0wZk9m6JLk3CNIRARERGRaqHAoooOzrHEMQscZLx0ayLmb4jH7kOZZllwgC9GdmsMf18ffLNqHxZsikd23n/jKhiAMMA4q1cTtG+oSdJEREREpOoosKiig+NJ2Xl27EjMwLaEdLSJCUW3ppH4c8chvLZgKzJy85GUkYedBzOQX/DfxOmdG4djUNto9GkZhb4t66F5vWC1ZoiIiIjIUVNgUUUHp6ZhdyhmkWLAsfNgpvmbcUWevQCLtyQgz/5fkEHRoQHo07KeCTR4Y1ersEBlZhIRERER1yiwqKKDU9OxqxS7RbG7FFs2nvpxA7YlZCAxPQdp2flmGgtnPjagbYMwHNeqHnq3jELjyGBEBfsjKsQfUcEBCA/ygw+fJCIiIiICBRZ1JrAoS2p2HnYkZGDlniTk2x1YuScZCzbGm8Hg5WFIERHsj3oh/ogM9kdkSIAJPHifXbGObxeNFvVDjtl+iIiIiIj31J3VL6YWigjyR68WUebm3LqxLT4DCzfH4++dSdgSnwY/HxvSc+xISMtBLmflBpCSlWduZWlRL9gEGCe0izH/N4rQHBgiIiIiopm39R44HHQcysg14zb2HMrA3qRshAb6IjzIHxtjU/HrxngcTM9FalbeEd2rmkUFY2Cb+ji5c0Oc0D4G9UMDdExFREREagmNsaiigyP/BR5sxWArx5ItB7HxQCr2p2Rj7f4UMwm4swbhgSYzVZvoEBNktIkJM1mtmkQFmZS5IiIiIuI9FFhU0cGR8iVn5mLBpgQs3FTYvWpfcla54zc4boOT+7VrEIZm9YLRol6IGbPBZY0jgjRwXERERKSGUWBRRQdH3MNsVH/tOGS6VHFm8S1x6diTlGnGcDjPt1EaXx+bCS44k3jzeiEICfBF+4ZhZm4O/h/g56vTISIiInKMafC2eERMWCBG92hSaleqxPRcE2zsScoy/2/Yn4ot8emIT8sxLR/2Aodp8Sit1YOtHSGBvmbSP3ar4nMbHQ5CujeLRMPwIBOYiIiIiIjn2Bys9dUharGoefLtBdifnI1dhwon/tuRkI6tCenYfTAT+5OzkFti4j9nDCeC/H3RuUk4ejSLRKCfjxnL0To6BI0igxEd6m8Cj4YRQWY7WXl283xmxLLZFIyIiIiIlEddoaro4IjnFRQ4TKvGzoMZ2HWwMPDYmZhxePbxDDNBYHnYkMGxHexOFRboj63xaSb4CAoozHrF2cmnntfDzEj+5T97kZ1fgPBAP3OfEwZ2ahyOqJAA5OTbYYMNAX4agC4iIiJ1R6obdWe1WIjXYmObCToOBxnOQceBlOxy5+MoKcjfB0F+vqa1w9/PBl+bDX6+PhjdvbGZD4SZsP7YfgihgX5mpnMGJ8e1qY9x/VuYrlwfLNtlgg4uD/T3QYCvDy7o19y0ijBlL7tvhQf6mzS+XAefpxYTERERqekUWFTRwRHvlp1nR3xqDuLSshGXylsO4s3/2SYgsZal5+S7tV4GEGzRYGtHy/ohCAvyw4HkLLOcgQnHe/Dvh8/shuiwAEz+fj32JhUfO3L90HYY0KY+ft92EIs2JyA0wNcEMv6+NrRtEIqTOzcy5f9xzQGznF23uG4/XxuGtI8xy9hVjBMbMigK9vc1Xbz4v4/Gm4iIiEgV0eBtkcNjL1pGh5hbeTJz85GYlouE9GwkmP9zTCarxMP/F93Sc5CbX2Buh/JzzaSCHIBelh/XxJr/2RWLc3pEBfub7lVssVi8JcG0smRk5yPPbkdyFrt0OcDkWQxaOB6EgcXy7QeRb3cgr8CBvPwC5BcUYHD7GLPeT//ajc2xaUWtNxyJcvGAlujfuj7+2H4QP/zLoMRmWlhCAvxMEMQWGI4sMcFMkB/CAgq7fYUF+Zo5RxiwcF1qTRERERF3qSuUiItY4U7Lyceh9FwczMgxs5EfzMjFwfScw/8fubyCLLvlYsMDWynYrcpqDeH/XJ5nd5hxHxxjkmcvvFVmW9b2uH6mc+Cq2EpitZTUC/FHvdAA81hOfoFpGWGw1DAiEM3rBaNT4wiTLjgqxB8NwgLg46OxKCIiIrWBWixEqgGv4kcE+Ztb65hQlwaeJ2XmmlS7VguIaQXh/4dbRhIPL0/OzDPdmoq9/nAlnjfkuFdWdsfiOA4GBgwGOI8Ix3mwxaOsAITLnQfD5zo9xkAJCRkuByhsLeJcJGydGdqxAZpFBZvB98lZeQgN8DPpgznm5IR20Ti+XbQZE7N0a6IJYvhatqLUC/VHt6aRZp1p2XkmmGGLSnUEjNx3Hp8Ch6OoO5uIiIi4Ry0WIjUEK7hsiWDrA7tbmf+L/i5cziCDFWCOxQj08/1vwLhfYWuGtay8ijEDHrvDCjQcsNsLAw7+zW1xG6bLF7eXZy8qg/UYW0oycvIRm5KDA6lZJmhKyshDbKp7A+YtDH4YgFiVeu4bW2k4V8m1Q9qgWVQIXpq/2ZQ7OPBw960gP1w3pC0aRwZh3rpYrNmXYvaH+8XnMVjhOJXtCel4e8mOwn0+/DgDw0fP7ma2ffeXq00Lk7O7RnVC58YRmL1yL+ZviDcBDYOk4AA/9G0ZhRHdGpv9nL8hrmhsi9WaxHEzxAQC9oKCw+NifODvY0NkiL85P+x6x3E95vjbC8vF7mrcXx5ja7A/j4efT+G4mi6NI8zYGY4R4nniMv/Dj1VXwCUiIkIavF0ODd4WqT4cF8JB8bEp2SbQsAbIs+UmJTPPVMjZasH/U0pppSkPK+7sfsUxK0wJfHzbaDM4fmNsmtkeR5k4wBYah1keExpoWjp2H8oylXTe2HrD6Us4mSMr6GZW+MPdyKznWC0WpotZfoHpFmZhiuKG4YWvZepiFp/bY6Wfwd3ZvZohOMAHP6+PQ3p2vlkPbz42Gy4c0ALdm0Zi8ZZEE5Q4j43p2CgcZ/Vqao7Lm4u2mWXOMwzdOKydaTFjsLM/KatYmU7q2ACdm0Rg/f5ULN2aYLbFgTTMbMbj1a9VfeTl27F4a6IZX8P1+B0O3ga0iTbHk61J7OYXeDhAMnPDNA5Hh0bhyMrNN8cwPNgPEU6ZzZpGBZvtM9DkujQuR0SkdqrVgcWBAwcwY8YMxMXFoUePHrjkkkvg7+/v8usVWIjUDPzqYderwmCjMPBIysxDfFo29nGGds7EnlQ4GzsDAKkZGJwwMOH8LsxIxtYqNpAVdr9jC44PBraJRpOoIBPwpWbnmUAwIphBoR96NY/CgLb1kZVrx9p9qaaFyp9jiHx8TFDWvmG42Q5bZxiwcXlQgE+VBi9sGWKrEYNKtvYwqQIDSt4n7osCJRGRWh5YbN68GSeccAIGDBiAgQMH4uOPP0azZs3wyy+/wNfX16V1KLAQ8c6WEI7D4EzszkEHr5abQeaHU/KyQmi1OLDyWzgA/fBjh7sPFT6Hzy3sSlTydXyMWMdkdyZrfAq7oznft7oxsdWF5cvMtZuZ3bMP/29uucX/Z4XWasHg+Ha2KhT+XTh3CuvNVisHK7aFLQyFlfni9wsXOt8v2t/Dx6Lo/8PHwhwTHw7+tyHXXjjwn13bWHbecvIKkG0SAhQ+Zi3npJEsd1WzuuuZoOTwMWDwwHTLbDHZlpBuWpJ4Osy+24AezSJNqxEDFmZlc+4SxuCAwQ5TD6Rm5ZvnWwL8fHFu76ampeW9pTuQmpVXeIxhM61UVw9ug9bRIZi7NhYLNyUcbvsim2m1Yde6Q+k5+P7fA4UtY06/mqd1bWwCEmZwS8nOM5kPuC/sotazeSRaRYeaIIbjqSKC/U0LEW+NIwPNY9x3tuiZboZMxlBQ2N2wVf1Q0zLFzG9s5eM5YLdFFqxNg1CTLIHrZHa5ovcGgIiQwrFJ7P73+/bEom6U5r2a70Cv5pGmfOv3pyA2Nadw3FVBYYtgK2bRqx9iysKxX87dAPk/j7Fpzcsv+O99nVuArPx8cx7Y1dAaM8b3DsvMsjH5A1vPeD75msKugzYE+hfOCcTzzfcpt8dzxBvHWZnWsQA/pdAW8bBaG1iMGTMGSUlJWLBggfmy2rt3L9q1a4e33noLV1xxhUvrUGAhIuIeVlJZ2TSBU9Gt8D7H4TAgYWCVlp1f2M2NrVCZeaYCX3T/cKsUu1x5z6+O1ASFwY0vQvwZ3PibMVYMzqxsdfVCePM3gSUDGOtvpvj29vFH1tg7BsoMyNgCeCA5u+hzyPFuDJw7Ng5DWlYe5qyNLbrIwf95oaNf63rmM7xid7JJq84wlBcYGIi2axiGNjGhJqPhv3tTil2s4HHv26qeCUw551KunUF1YZdRrq9F/VBzIYYXfPh5N0nTD3c55flhl1QGkrsOZRYtZ2Dua2PLZJjZv92HMszFGjKhvg0m2yCDzNTsfFP+wolnC1tDGVB3bBxuAtGtCRkIPjy5Ld8f3Oawjg0QHlzYi4XHS6pGrQws8vLyEB4ejpdffhkTJkwoWj5y5EiEhYVh1qxZLq1HgYWIiOfwyjnHn2Tm5R9uNSnRQnJ4mXMLiqtDcVhp4VVyVrbSc1ixyj/8N/+3I+Pwfetv/vqxguKcztlK7/xfmuf/HnelRchkYgOKruizDKaiZ/4u3K51n/tmVarYcuPcesX1sJJl3S9sxSrcT76k8Je7MKOZNVaHlT3n8TlWCxzLVfS304Sb/7XeseWm8NywPGyBKUxjbf1dWJnk9k0SBJNA4vAx4/9+bDHyNxU/Vg6trHT/pa92lOiCdrgV8HBrCV9njXkyleHDrR1VUTmJCPI7nAzhcIWZxxhATHigaRXhOCy2CFmtgix744hA9GoRZfZvw4HUohYUJn5g5XVEt0aICg7A7qQM03rDin1h5dcHzeuFmECH+8n3udWSaM7W4Qo3gwNW1LldK/hmOYZ1bGhaQNlytutQBrL4Gci1m3PRrF6wadlhJZ6tt9Z5qmya8drKfJ4Ot4KacWN+vmZ8XFRogEmmwfNisjwGc9yYn1Pr3OH/OeHs4Tmg+Bmxgh7rM1h0//D2CpcXjvEzn5uC4p8fvtfzrfuHzx3f43yvm/PsdNGm8ALOkRdy7h3dGScensfqWKuV6WZ3796NnJwctGnTptjytm3bYunSpWW+jq/hzfngOP9PHKMRHByMrKwsE8BYAgMDzS0jIwN2u71oeVBQEAICApCeno4CfiseFhISAj8/v2LrptDQUJPXPy2tcDIzCwMlvp7rd8aTlp+fj8zMzKJlfD0DqNzcXGRnZxctZxcwrr/kfmqfdJ703tPnqaZ+R4QF+sCWz9TD7KdkvuEQERF1TL/3WAEIDAxCUFCgR7/LGQyY4KEGnidP/j5xG2wly2QgYvPHwSw7tu5PRGJaFg5l5CE9Ow9BISEICgjAnthE7DyUaZ6bmWNHFvyQmeeAIzcLyU7Ds2wBwYCjAI68HKQ4HQafwBA4CuxmOcUlAqt3xMEnIBgOex4c+U7Z7mw+mLZgq1nGx/5biS98/ANRkJcDm8NugkEGYz5+AfDx80dBbjYcjsIuaWY1fv6w+XJ5VlEk+MGijbD5B8Lm44uCnP+OL+1LCjTb5j45s/YJ+TkmQGOrDq/u8zwF+gIBjjxTQWZFOTDAD4FBocjPy0VuDstTmLSCZfcLDEJeTi7y8grnXzKfj4AABAUHw8eeCx8HxyMVBqTBwUEIDgqEPScbfj7MXlfYAhIQGAg//wDkZGWaMlkV78CgEPj5+yE7I83UwK3KOJfbfHyQnXl4otnDDwSHhMFRUIDsrMzD74HCgNzuF4S0zBwkp6UfXmZHJltNEYDUzCxkZmYXHd8Cmw98ArhP2Ug/fJ72JxQ/Tyj473PDc2E7fJ7M8bSWl3KezPIyzpPNv/zzZL3HynrvFT7ZVup7b29CI6B9jEe+I9xqg3B4iTVr1pgLMb///nux5XfffbejXbt2Zb7ukUceMa8r7zZ+/HjzXP7vvJyvpREjRhRb/tZbb5nlXbt2LbZ87ty5Znl4eHix5WvXrnWkpKQcsV0u42POy/ha4rqcl3NbxG07L2fZSttP7ZPOk957+jzpO0Lf5XX19+ngoaQj9mnhmh2OT+YsKbYsJDTMMWfNfsdjr31cbHmjVu0dj327zjHi+oeLLa/Xsb+j/+SfHdFDLi22PKznCEere743/zsvjzzxYrM8qHWfYsvrj7rV0enBHx1BDVoWWz7k1ucdl7/zh8M/KLTY8skfznV8uHD9Efu0Y1+845+Vq732PFXXe2/oyac6tsSlOW64/Z5iy08+5yLHGwu3OvqNOL/Y8l7nXOu4ccbfjsZdBxZb3viM2xwdH/jREdSwVbHlTS563NH+/h8ctoDgYstbXPeao+0dXx6xT6c+NcfR4cbpxZb5BIY4rv/ob8f5979WbHloo1aOU/+30HHGTY8WWz7s5FM9dp727NlTdG4q4jVdoXbu3GlaK+bMmYNRo0YVLWe3qL///hsrVqxwucWiRYsW2LNnT1FzTl29IqR90nnSe0+fJ31H6Ltcv09H95vL5Vb3MR9fP/gHBiE9IxPZ2RwUX9jdy8c/AL5+/sjMyECALwrnvgnwRVRYqMdby1SPOLq6EavNPE885+waZHVhZPemwOAQ+Pn6Ij09rVj3utLOE9fD88Tt7YlPMuPPOGYtx873TTCaRvijfpAN2xPTEezni+bRYR6r7/G5UVFRtWuMBXee/bsef/xx3H777UXLhwwZglatWpkUtK7QGAsREREREVR53dlrhswz0h47dizef/99E5XRqlWrsGzZMlx44YWeLp6IiIiISJ3mNS0WFB8fj2HDhpm/e/fujblz55oUtO+8847L61CLhYiIiIhIHU43a2G/sp9++qlo5u1Bgwa59XoFFiIiIiIidTjdrIUDUc4++2xPF0NERERERLxxjIWIiIiIiNRcCixERERERKTSFFiIiIiIiEilKbAQEREREZFK87rB25VlJcEqObOgiIiIiIgUZ9WZXUkkW+cCi7S0NPN/ixYtPF0UERERERGvqUMz7WytmseisgoKCrB//36Eh4fDZrN5JOpjULNnz54KcwFLzaJz57107ryXzp330rnzXjp33im1muqYDBUYVDRt2hQ+PuWPoqhzLRY8IM2bN/d0McwJV2DhnXTuvJfOnffSufNeOnfeS+fOO0VUQx2zopYKiwZvi4iIiIhIpSmwEBERERGRSlNgcYwFBgbikUceMf+Ld9G58146d95L58576dx5L5077xRYA+qYdW7wtoiIiIiIVD21WIiIiIiISKUpsBARERERkUpTYCEiIiIiIpWmwEJERERERCpNgYWIiIiIiFSaAgsREREREak0BRYiIiIiIlJpCixERERERKTSFFiIiIiIiEilKbAQEREREZFKU2AhIiIiIiKVpsBCREREREQqzQ91TEFBAfbv34/w8HDYbDZPF0dEREREpMZyOBxIS0tD06ZN4eNTfptEnQssGFS0aNHC08UQEREREfEae/bsQfPmzct9Tp0LLNhSYR2ciIgITxdHRERERKTGSk1NNRflrTp0eepcYGF1f2JQocBCRERERKRirgwh0OBtERERERGpNK9ssfjxxx/x66+/IiQkBJdffjk6dOjg6SKJiIiIiNRpbrVYJCUl4aWXXsKoUaPQuHFjBAYGomHDhjj55JPxzDPPID4+vvpKCiA/Px9jxozBhAkTEBkZaW4XXXQR1q5dW63bFRERERGR8tkczCFVgczMTEydOhXPP/882rZti6FDh6Jz586mYs/0U1u2bMFvv/1mKvg33ngjHn30UURFRaGqPfvss3jiiSewbt26osxO2dnZyMjIQHR0tMsDUFjulJQUjbEQEREREamiurNLXaHeeOMN7NixA7///jt69uxZ5vM2b96MF154wbReTJkyBVVt+vTppuuTc7rYoKAgcxMRERERkRreYsEuSH5+rg/HcPf5rmCUxFaQDz/8EHa7Hf/884+ZqINdodq0aVPm63JycsytZMostViIiIiIiFRdi4VLYyzcDRKqOqggdrkidoXi4G0O2GbXqy5dumDRokVlvo5duKzxGLxpcjwREREREQ+1WJQnMTERq1atMreVK1di4MCBmDhxIqorWho5ciTmzp1btPzcc881g8rLCi7UYiEiIiIi3ih3927Y/Pzg37Rp7RljYeE4CwYPVhDB//fu3QsfHx80a9YM7du3N1miqgN3pGXLlkeM8ejRowdmzJhR5uuYuYo3ERERERFvkvDSy0j98Uc0uv9+1L/8MtR0LgcWzAh1xx13mIHS3bp1Q69evXDXXXdhzZo1Jop57rnnqrekAC677DL88MMPmDx5MgICAsxYjnnz5qF///7Vvm0RERERkWMlPykJafPmAQ4Hgvv08YoD73Jg0bx5c1OZv//++3HPPfeYv4kBRWxsLI4FbnvZsmUmsDnuuOPMAG6O52DQIyIiIiJSW6TM/hqOvDwEdeuG4O7dUKsmyBs3bhz+/PNP/Pzzz6Y70i+//IJjLTQ01My4/e677+L000/HW2+9hdWrV2tAtoiIiIjUGg6HA8mff27+jrpwHLyFW2Ms2P2JE+F9/PHHuPLKKzF48GCT8tXX1xfHis1mw5AhQ8xNRERERKS2yfzjT+Tu3AmfkBBEnH4GvIXLLRbOLr30UmzatAmtW7fGa6+9hp07dxabK0JERERERI5O8uczzf8RZ50F37BQ1OrAgsLCwvD000+bwdsZGRlmkjqOt0hPT6/aEoqIiIiI1BH5hw4h9efCIQf1vKgbFFV6JruOHTtizpw5+Oabb3D77bcjLi4Ozz77bNWUTkRERESkDkmZPRvgoO0ePRDUtSu8SZVNkX3OOeeYyes2bNhQVasUEREREakzHAUFSLIGbY8bC29z1F2hSsM5Lvp4SZ5dEREREZGaJPOPP5C3azd8QkMRefrpyN2zB/kHD6JOBhYiIiIiInJ0rNaKiLPPMsGFLSAQWStXos51hRIRERERkaPDlom0X+abv+tdeKH5379RQ/g3OhXeQi0WIiIiIiIelvzVV4WDtnv2RFDnzkj55htk/PknvMlRtVhs2bIF06dPx44dO5Cbm1vssfPOOw/XXHNNVZVPRERERKTWD9pO/vyLohSz9uRkpP78M6LGjEGtDiz279+P4447Dl26dEHfvn3h7+9f7PGYmJiqLJ+IiIiISK2WuXw58vbsgU9YGCJGj0baL7/A5ueP0BNOQK0OLObNm2cCil9//bV6SiQiIiIiUockzSwctB159tmw+fkh/bfFCD3hePgEB8ObuD3Gws/Pz0yKJyIiIiIilZOfkIC0+YWDtqMuHIfMFStRkJGBsGHDvO7Qut1iMWTIEEyZMgVpaWkIDw+vnlKJiIiIiNQByV/NBvLzEdyrF4I6dTLjLfwaNoB/w4aolYHFokWL8N133xXd9/X1Rbdu3TB69Ogjgothw4bhzDPPrPqSioiIiIjUtkHbXxQO2o668EI47HbYfH0R2LYtvJFLgUViYiLWrl1bdL9Zs2bmtmvXriOe27lz56otoYiIiIhILZSx7Hfk7d0Ln/BwRIwehcQ33oB/o0aIOv981NrA4vzzzzc3ERERERGpGskzZxYN2ranpiL73zUIubKP1x5eTZAnIiIiInKM5cXHI+1wllUO2k5fsMC0XIT06+e158Ltwdsffvghnn/++VIf8/HxQWRkJI4//njcfvvtaNCgQVWUUURERESkVknhoG27HcF9+iCgWTMkTnsV4aedBltAAOpMi0X37t1hs9kQHx+PoUOH4uKLL8app56KlJQUc2NQ8fXXX5vHcnJyqqfUIiIiIiK1YdD2uHHI2bkTNj9fhA09Cd7M7RaLwMBApKenY8OGDaZ1wvLEE0/gxBNPxIgRI/DYY4+hX79++Oqrr0zgISIiIiIihTKWLkXevn3wiYgwg7Z9goLQ9KmnvLq14qhaLP744w8MHz68WFBBwcHBJs3ssmXL4O/vj7POOgubN2+uyrKKiIiIiHi9JGvQ9jnnmEHbBTk5Xh9UHFVgwTks/vrrL+Tl5RVb7nA4sHTpUjMzNx06dAjNmzevupKKiIiIiHi5vLh4pC9YaP6uN24sDn3wAQ6+/TZqA7cDi3PPPdfMa8EZuKdPn45vv/0Wb7/9Nk455RSsXLkSl1xyiRl/sXjxYowZM6Z6Si0iIiIi4oVSvppVOGi7b1/Y/P2Ru207wgYPRm3g9hgLdoH6/fffzTgKjquIjY012Z9OPvlk002KrRRZWVmmS1RERET1lFpERERExMsUZGcj6dPPzN/1LhyHtPm/wq9BDIJ69ECdDCyIwcNbb71V1AWKWaJKjrfgTURERERECiV//jny4+Ph16QJggcNQtzjTyDqvDGw+dSOqeUqvRclgwoRERERESmuICsLiW8WXpiPufEGIC8fQZ06IfSEE1BbuB1YPPfccyaYKOt25513Vk9JRURERES8VNInn8KemAj/5s0RNWYMApo3Q4OJt8KnFvXycbsr1Lhx49C7d+9iyzIyMvDdd9/ht99+w/XXX1+V5RMRERER8WoFGRlFmZ9ibrwROVu2AL5+COrUEbWJ24FFy5Ytza2kc845B2effTY2bdqEDh06VFX5RERERES82qEZH8OelAT/Vi0RcfZZiJsyBf6NGtW6wKJKR4pwtm2mnBUREREREcCeno6D775rDkWDm29G7pYtyD8Qi7CTT651h6fKAovk5GT88MMPiI6OrqpVioiIiIh4tUMffoiClBQEtG2L8NNPR8o33yCgVSsE1sIePm53hXrvvffw9NNPF1tmt9uxd+9etG7dGpdddllVlk9ERERExCvZU1Jw6L33zd8NbrkZWX//jdxdu9HwzjtqZWZVtwOLPn364JZbbim+Ej8/M+7i1FNPRUBAQFWWT0RERETEKx364AMUpKWZ1onwUaPgyMlB/auvRmD79qiN3A4smBGqZFYoERERERH5T35SEg598KH5O+bWW4D8fJNaNnTgANRWRzXzNjG17Pfff2+6QDVp0sS0VowePbpqSyciIiIi4oUOvfueSTMb2KULgnv3xv777kf09RMQ1LF2ZYKq9OBtdoUaNmyYCS7y8vLw559/4qyzzjJzXDgcjqovpYiIiIiIl8g/eBCHPv7Y/N3g1luQMvtr2Pz9zaDt2sztFou//voLH330EX7//XcMHDiwaPmGDRtw8sknm1YMBhkiIiIiInXRwXfehSMzE0Hdu8OvWTMkf/4F6l91FXwCA1Gbud1i8ccff2DMmDHFggrq0qULrrzySvO4iIiIiEhdlJ+QgKRPPjF/x9xyC1K+nIWA1q0RUovHVhx1YBEaGor4+PhSH4uNjTWPi4iIiIjURYlvvQVHdjaCe/VCcL9+8A0PQ9S4cbUyvWylA4tRo0Zh0aJFuPfee7F7924zh8X+/fsxZcoUfPLJJzjnnHOqp6QiIiIiIjVYXlwckj+baf5ucNtE+IWHocHEiQhs2wZ1gduBBTNAzZ49GzNnzkSrVq3MHBbNmjXDK6+8ghkzZqBr167VU1IRERERkRrs4BtvwJGbi+D+/WDPykLWunWoS44q3eyIESOwadMmrFmzpijdbI8ePRAcHFz1JRQRERERqeHy9u9H0hdfmr/rXX45UmbPRsSo0Qju1g11hduBxbRp0xAXF4cnnngC/fr1MzcRERERkboscfobQF4eQgYNQt6OHfANj0D4iNNQl7jdFSo8PNy0Unhafn4+EhMTkZGR4emiiIiIiEgdlrtnD5K/+sr8HXnO2chatRpR542BT0AA6hK3AwvOrr1kyRKsXbsWnnTzzTejQYMGeOCBBzxaDhERERGp2xJfe51XvRF64onI27cfAe3aIrh/f9Q1bneFWrx4sZltu3fv3ujVq5ep3Du74IILcO2116I6ffnll2aiPs6dISIiIiLiKZn//IOUr782fzeYeCsCu3RBQXp6nUgvW+nAIiYmxgQPZWncuDGq086dOzFx4kTMnz8fF198cbVuS0RERESkLAU5OTjw4EOAw4HIc86Bf7NmpvuTT/36dfKguR1YDB061Nw8Na7ikksuwYMPPqjWChERERHxqMRpryKXA7UbxCCoezfETX0KTadOga2Oja2oVLpZCwdOs1uUs6CgIHOrDgwo6tWrh5tuusnl1+Tk5JibJTU1tVrKJiIiIiJ1B+eoOPjuu+bvBrfdhvQFCxF55hl1Nqg4qsHb9Pzzz6NRo0YICwszFX3nGyv/1YFjO9588008++yzJhsUb5z1Ozs72/xdlqlTpyIyMrLo1qJFi2opn4iIiIjUDY68vMIuUHY7wkeNQv6BWPhGRSL8lFNQl9kcDofDnRcsX74cw4cPx3PPPYe+ffvC39//iDEWzZs3r+py4p133sE999xTbFlycrLZfmhoqJlbw9fX16UWCwYXKSkpiIiIqPJyioiIiEjtljh9OhJefAm+kZFo8tRTSJ45EzE33oDgXr1Q27DuzIvzrtSd3Q4sXn/9dfz5559477334GnMTDVs2DC8+OKL1XJwRERERESc5Wzbhh3njjGtFk2feRqhxx+PzL//Ni0XtTETlDt1Z7e7QvFqP7sfiYiIiIjUJQ67HQceeNAEFaFDT0L4GWfAr0EDRIweXSuDCne5HViccsop2LhxI3744Qd4Gsd0cJyHiIiIiEh1S/r4Y2StWgWf0FDE3Hgj4h59DHmxsTrw7mSFYvenxx57rFg2qDPPPBMhISEIDw8v9lxmbHr44YdxLCxYsOCYbEdERERE6rbcvXsR/0Jh9/sGd96B9Pm/AjYb/KKjPV007wosOI6hZABRlq5du1a2TCIiIiIiNQaHJMc+/DAcWVkIOe44BLRqjYxFv6HBbRNhK5HIqC5zKbDo0qVL0YR0mZmZJs1raYGG9ZiIiIiISG2RMmsWMpb9DltgIBo9cD8OvvMugvv1RdDh+rEc5RiL1157rVi3KFcfExERERHxNnlx8Yh7+hnzd4OJE+ETFg7fqChEXXCBp4tWu2beLimLzUMhIVW5ShERERERz3WBevxxFKSlIahHD9S/8grY/PzQ6P77lAWqMoHFsmXLMG/ePPN/eno6Hn300WKPc0D3jBkz8Morr7i6ShERERGRGittzhykz58P+Puj8eQnkPzVVwgbOgz+jRp6umjeHVjs3r0bv/zyC/bt24e8vDzztzNOmPF///d/OO+886qjnCIiIiIix0x+UhJiJz9p/o6ZMAH2+Hik/7oAIX37AgosKhdYXHTRReb2zTffICkpCVdddZWrLxURERER8aouUHFPToH90CEEduiAepdegrjJTyL0+EEIbN/e08WrPWMszjnnnOopiYiIiIhIDZD00Qykfv894OODJk9ORur3hRNDR6pnTtVmhRIRERERqa3SFy9G3FNPmb8b3nEHAlq3RuY//yDy3HPg6+K8bnVVlWaFEhERERHxVjnbtmHf7ZOAggLTOlH/mqtN9qfGjz4C38hITxevxlOLhYiIiIjUeRysvefGm1CQno7gfv1MMJGzZQsKsrPhV68ebD6qNldER0hERERE6jRHXh723fZ/yNu9G/5Nm6L5yy+hICMDia++htQ5cz1dvNrVFWrr1q1Yu3atSyvs0KEDunXrVtlyiYiIiIgcm0nwJj+JzD//hE9ICJq//jp869VD4muvwxYQgIgRp+ksVGVgMXfuXDz44INF93NycpCdnW3+DgoKKvo7ICAAd999N5544glXty8iIiIi4jFJMz5G8syZgM2Gpv97DkGdOiLpiy+QvW4dYm6+GT6hoTo7VdkV6pZbbkFycrK57d+/H+3atTPBQ2JiIrKyspCSkmJm3G7WrJmZJE9EREREpKZLX7IUcVOnmr8b3nkHwocPR+7efWYivKgLxyG4u3rhVOsYi/nz55vuTmzBiI6OLpp1m8HHiBEjMHv2bHdXKSIiIiJyTOVs3459t99emAHq3HNR/5przPKA5s3Q6IEHED5smM5IdQcWu3btQmgZTUJhYWHmcRERERGRmsqenIw9N96IgrQ0BPfti8aPP4b82Fik/jTPjLlgcCHHILA47rjjMGvWLHz99dfFli9cuBBvv/02BgwYcBTFEBERERE5Nhmg9v7f7cjbdTgD1Csvw5GTg4Rp08wAbj4ux2iCvIEDB5puUBdeeCHq1auHJk2aID4+HnFxcbjttttw1llnHWVRRERERESqOQPUk08ic/ny/zJAhYcj/sWXTEARc8cd8AkI0Ck4SjYHj/BR2L17N+bNm4d9+/ahcePGGD58ODp27IiaLjU1FZGRkWbAOceGiIiIiEjdcGjGx4ibPNlkgGr+6qsIGz4Mh959F1mrVqPBpNsR2KaNp4vo1XVnt1ssLC1btsT48eNht9vh53fUqxERERERqXYpP/yAuClTzN8N75iE8JOHw5Gbi4KcHNS/+ioFFZ6aeXv9+vU49dRTER4ejnvvvdcsW716Ne66666qKJOIiIiISJXhoOz9d99jMkBFjR2L+uPHm6CCE+DF3HgjQvr21dH2RGDB5hCmle3evTsuuuiiouW9evXCokWLsGrVqqool4iIiIhIpaX9ugD77rgDsNsRec45aPzYo8jdvh0HHnoYefv2wWaz6Sh7KrD45Zdf0LVrV7z44ovo0qVLscdOOukk/Pjjj1VVNhERERGRo5a+eDH23XYbkJ+PiDPOQJMpT8J+8CASX58Ov4YN4deokY6uJwMLDtbmBHlUMsLjWAvOxC0iIiIi4kkZv/+OvbfcarI9hY8YgaZPP1WYVva11+ATHIzo66+HTeOEPRtYMPPTsmXLjggsGFB89dVX6NmzZ9WWUERERETEDZl//YU9N91sAomw4cPR7LlnTRBx6KMZKEhJRcwtN8M3rPQJn+UYpptlFqhBgwahRYsWZgbu7OxsnHzyyZg2bZrJDcwxFgE1OP+v0s2KiIiI1F6ZK1diz/hrUZCZidAhQ9D81WlFc1Pk7t5tWjAC27XzdDG9hjt1Z7dbLHx9ffHTTz+ZyfG++eYbfPnll7j99tvNeAuOv6jJQYWIiIiI1F5Za9Zgz3UTTFARcvygwlm1c/OQ9MUXJgtUQMuWCipq4gR5xJcyigkLCzMBhzdQi4WIiIhI7ZO9YQN2XXkVClJTEdy/H1q++SYc+flIeOll2FNS0PCuO+Gvwdo1c4I8a4wFNyQiIiIi4inZmzdj99XXFAYVvXujxfQ3zMR3CS++BEd2tpkQT0FF9XMpsHjrrbfw5JNPurTCCRMm4P77769suUREREREKpSzfbsJKuzJyQjq0QMt3noTNh8b4p9/Ho58OxowqGjYUEeypgQWHKz94IMPurRCZYUSERERkWMhe9Nm7Ln2WjM3RWCXLmj59lvwDQ833fVDTzrJzKjtFx2tk+ENYyy8kcZYiIiIiHi/jOV/YO8tt6AgPR2BHTqg5YcfmG5Pefv3I6RfP08Xr9Y4JmMs/v33X8yZMwd79+5FkyZNcOqpp2LAgAFHuzoREREREZek/PAD9t97H5CXZwZqt3j1VdjT0sxAbd+oKDPOwuYliYVqE7fTzdKkSZPQu3dvvP/++9i4cSM+++wz013qqquuMk1PIiIiIiJVjfXMg++8i/133GmCivCRI9HynXdgT0pCwvMvwLdeFBrcdpuCCg9xu8Vi0aJFZjD3ggULMHTo0KLlK1euxMiRI828FmPHjq3qcoqIiIhIHeaw2xH31NNI+ugjc7/eFZej0b33InfnLiS8/DL8mzZFg1tuhk9IiKeLWme53WKxdu1anH/++cWCCurTpw+uvvpq00VKRERERKSqMHXsvkl3FAUVDe++G43uuw82Hx/4xUSbQdoNJt6qoMLbAou2bdsiPj6+1Me4nI+LiIiIiFQFTm63e/x4pP30E+Dvj6bPPYfoa65G9rr1JsWsb0QE6l9xOXyCgnTAvS2wGD58OOLi4nDnnXdiy5YtyMjIwM6dOzF58mQsWbIE5557LvLz882toKCgekotIiIiIrUeMzztvPRSZP39D3zCwtDyrbcQeeYZyPjzTyS+9hrSfl3g6SJKZcZYTJs2DStWrDC3//3vf0c8Xr9+/aK/77jjDjz33HPubkJERERE6rjsjRuxZ8L1yI+Ph1+jRmjx5psI6tQR6YsXI+mTTxE6aCAizznb08WUygQWF154Ifr37+/Sc1u0aOHu6kVERESkjsv4/XfsveVWFGRkILBDexNU+DdpgrT585H8xZcIGz4cUePGwmazebqoUpnAgsGCAgYRERERqQ7Js7/GgYcfNulkQ/r3R/NXp8E3MtI85hMejojRoxBx9tkKKmpDYMHxFJy7oixt2rRBp06dKlsuEREREalDHAUFZoK7g2+8Ye6Hjx6Fpk89BVtAALL+/RdBPXogVJMx167A4quvvsLdd99dbBkHaXPCEjZH3XXXXXj66aersowiIiIiUosVZGdj/z33FmZ+AhB9w/VoMHGi+TtpxsfIWLoUje69BwGtW3u4pFIem6MKpsrOysrCDz/8gEcffRTLly9HWFgYqsvSpUuxbNky+Pn5YfDgwTjuuOPcen1qaioiIyORkpKCiIiIaiuniIiIiFQsPyEBe26+BdmcC83fH00efxxRY86FIz8fhz74AJl//4P6V16B0EGDdDg9wJ26s9vpZksTHByMCy64AEOGDDEzb1cHtoocf/zxuPfee5GQkIBt27bh5JNPxqRJk6pleyIiIiJSvbI3bcaOCy80QQXHUbR85+3CoCI3F4lvvonMlSsRfd11Cipqa1eo8sTExJgxGNWB3axefPFFDBw4sGjZ6aefjjPOOAPjx49Ht27dqmW7IiIiIlL10n/7Dftun2QyP7GLU4vpr//X1clmM7Nqx9xwI4K7q45XawMLNoccOnSo2DK73Y41a9bgzTffNPNcVFdg4RxUUN++fc3/e/bsUWAhIiIi4iUOzfgYcVOmsEsKQgYMQPOXX4JvVJTpFmUFGjE33ODpYkp1BxYMHjhAuyRfX19MmDDBdIk6VmbMmIHAwED069evzOfk5OSYm3NgJCIiIiLHHsdNxD31NJJmzDD3I88/D00eecRkfsrZuhWJr0+HX+NGaHjnnUonWxcGbycnJyMxMbHYMg6kbtq0KQICAnCsLFmyBKeeeiqmTp2K22+/vczncUD5Y489dsRyDd4WEREROXbs6enYN2kSMn5bbO43uGMSoq+91gQQGcv/wKEZHyGwTVtEX389fMNCdWq8cPB2lWSFOtb++usvnHbaaaaF5Jlnnin3uaW1WHCCPwUWIiIiIsdG7u7dZibtnM2bYQsKQtNnnkbEiBHmsbRffkHyl7MQevwg1Lv0Utj8qnQIsNT0rFBpaWl44IEH0LNnT9SvX9+Mb7jtttuOaMmoDv/88w9GjBhhBmxXFFQQu0rxIDjfREREROTYSJ03DzvOO98EFb4NYtDqo4+KggpTV+vQAZFjxqDeFVcoqPBybrdY5OfnY8CAAUhKSsKVV15prv7Hxsbi448/Ni0Dq1evrrZ5LFasWGG6P11zzTV47rnnjmodmsdCREREpPoxZWzcc88h6cOPzP3gvn3R7Pn/wb9xY9hTU5E6dy6ixoyBzd9fp6MGc6fu7HZb05w5c8wGGEA4r/zOO+80E9Z9+umnuO6661DVMjIyTPcnf39/M6aD81lYzj//fLcnyhMRERGR6pG7d58ZT2EmveNM2teOR4PbbjNBRN7+/Uh49VVerUbY0KHwb9RIp6GWcDuw2LFjh5mYrmTEwi5Ho0ePNo9XBx8fn1KzUVnbFhERERHPS/v1V+y/9z4UpKbCJzISTZ+aivDhw81jWevW4eDbb8OvfjRibr4JfvXre7q44snAolmzZnj77beRm5tbLAsUZ8b+7bffMG7cOFQHzu7t3EohIiIiIjWHIy8P8S+8iEPvvmvuB/XqiebPPw//Zs3MfbZUJL76GoK6dUX0+PHwCQrycInF42MssrOz0aNHDzNomwOoGWjExcXhww8/xMaNG7Fu3TpER0ejptIYCxEREZGqlRcba2bRzlq50tyvf+UVaHjHHWZ+Co614P+UuWIlgnv3MrNqi3eo1qxQQUFBpmWCmaCYGerMM8804ysaNWqEZcuW1eigQkRERESqVvrixdhx7hgTVPiEh6PZyy+h0X33mWAid+dOxD4x2cxTQSF9+yioqMWOKlFwkyZN8O7hZi5mgtIYBxEREZG6N4t2wivTcPCNN8z9oK5d0eylFxHQogXYISb911+RPHs2Apo1R2C7tp4urtTUwIIT1LFJpGPHjkVBxe7du7Fr1y4MGTKkqssoIiIiIjVIzrZtZoB29po15n69Sy5Gw3vugU9gIAoyM3HwvfeQvWYtwk87FZHnnKP5KeoIt7tCcc6KK664Ag0bNiy2nF2hbr31VmzevLkqyyciIiIiNYTDbsfBd9/DjjHnmaDCJyLCzE3R+OGHTVBBZjxFgcNkfYo6/3wFFXWI24HFTz/9hEGDBiEqKqrYcrZcjBo1Ct9++21Vlk9EREREaoBc9k654krEP/OMGZAdOmQI2n73LSJOP90EHCnf/2CeY/PzQ4Nbb0Fwjx6eLrLU9K5QeXl5ZnR4abg8NDS0KsolIiIiIjWAo6AASZ99hvhnn4MjKws+ISFoeN+9iLrgAthsNuQnJeHQu+8hZ+tW+EaEI6BlS08XWbylxWLo0KH44YcfsGDBgmLLV6xYgY8++gjDD0+AIiIiIiLejXNP7Ln2WsQ9/oQJKkIGDkSbb79FvbFjTVCRtWYN4iY/ifyEBDS4/f8QdtJJni6yeFOLRYcOHXDPPfeY2bfZJapVq1bYv38/li5dimuvvRaDBw+unpKKiIiIyDHBrE4pX81G3NSpKEhPhy0oyMxLUe/SS4rSxRbk5ODQhx8hoF1b1L/iSviGqddKXef2BHmWX3/9FV988YUZzB0TE4Ozzz4bZ511Fmo6TZAnIiIiUra8+HjEPvwI0hcuNPeDe/dGk6lTENimTVFGKL+GDeEbHo78xET4Rkeb1gupndypOx91YOGtFFiIiIiIHIkDsJNnzUL8/55HQUoKbP7+aHDbRNS/+mrYfH3hyMszA7TT5s1DxKiRJo2s1H6pbgQWRzWPhYiIiIjUHpwZm92ecjZtKprsrslTUxHUsaO5n7t3H/6/vfsAb6u8+gD+t4blPRNvO3tvkpAJhCzCCHtTRtm7YUOhrJZCCfOjbCi77FH2CgkrgSRk7504ie3Ee1uypO85R5ZiZXrJkqz/j+ci+Wr4SnLs99z3PecUv/IKbAX5iD/pRMROmeLnI6ZAxMCCiIiIKERZt25FwcyZqPx+ln4tfSk6X3sNEs85R2cshL2yCrtmzoQpORmpt92mnbWJ9oeBBREREVGIsVdUoPDZ51D8xhvSSwAwGpF49tnodO01MCUm6n3qi4pgjI/XpOxOV14BS48eruZ3RAfAwIKIiIgolPIoPvgQu598EvbiYt0nje5Sb7sVlp49XfdxOlH161yUvv8+4k44HnFTpiCiXz8/HzkFAwYWRERERCGg6rffUPDgQ548ivDu3ZF6+21evSes27ej7JP/oXbFCkSPG4eYI47w4xFTyAYW//3vf/HKK6/g9ttvx6RJk9rqaYmIiIioFaxbtqBg5iOonNWQRxEfj87XXovEs8/y5FHo/XJzUfDAP2FMSkKnq69C5ODBfN/JP4GFlJ+KjY3Fueeei1tvvRU33XRTWz01ERERETVTfUkJCp9+BiXvvAPU17vyKM49F52vuRrGhAQtH1s1dy7qNmxE0gXnw5yVhU7XXK0VoaS8LJHfAosTTjhBN1mXV9ywZo+IiIiI2pd0xC55800UPvc8HBUVui/mqKOQcustmoAtVZ7Kv/pKG+DZy8oRMXgQHFYrDOHhiBw0iB8XBU6OhXReTE5ObuunJSIiIqKDcDocKP/yK+x+7DHYdu7UfZZ+/ZB66y2IHjPGc5+CBx6Ao7ICUaNHI3bSJJjT0vi+UvsFFnPnzsW3337bpCccO3Yspk6d2trjIiIiIqImql6wAAUPz0Tt8uX6tSk1FZ1vmIH4E09E/a5dKHr5ZSSceSaMsbFIuvACmDMz9TpRuwcWubm5mDNnjufrjRs3Yvv27cjOzkZmZiYKCgqwefNmpKam6kZEREREvle3eTN2PfrongZ3UVFIvvxyDR5E2ccfo+KH2TAmJsAufSliYxHRty8/GvJfYHHWWWfpJnbv3o2RI0fis88+05wKt19++UUTtzlbQURERORb9cXFrsTsd9/1JGYnnHG6VnsydeqEmhUrUfLG63DU1CL+hON1yROb21HA5VjMnj0bRx55pFdQIcaPH6/Bx5dffonrrruuLY+RiIiIiBoqPRX/5xUUv/UWnNXV+p7ETJiAlJtv0gZ3UulJGGNjYOnVC/GnnebppE0UcIFFYWEhSktL93tbWVmZ3k5EREREbcdeWoqiV19FyetvwNEQUEQMHKgBRfTo0bBXVKD4zbdg3boVqXfcjvAuXZB86aX8CCiwA4spU6ZgxowZuPfee3HFFVcgLS0NRUVFePPNN7VB3s8//+ybIyUiIiIKMfbychS/9jqKX3sNjspK3Wfp3w+dr70OMUdPABwOVMyejfLPPtPb4k6YDjidfj5qClXNDix69eqF9957D9dffz3uu+8+GAwGOBwOTdp++eWXMXr0aN8cKREREVGIsFdWovj111H86mtwlJfrPkufPuh83bWIkXyJsDDdt/vpp1G7eg2ix41D/EknstIT+VWYUzratYDVasWyZcuwY8cOnbUYPHgwIiMjEejKy8sRHx+vy7akWzgRERFRoJDmdSVvvYXi//wH9rIy3Rfes4fOUMROnYIwg0HzLOTSGB+PmuUrNJ8ivGtXfx86dVDNGTu3uEGe0WjUJ09JSUFOTk5Ln4aIiIgo5NUXFqLkvfdQ8sabsJeU6PsR3q0bOl17DeKmTUOY0Qin1Yqy775DxdffIHrsGCSecw4iBw0M+feOAoehJQ/64osvtH9Fnz598H//93+6b+nSpTjmmGPa+viIiIiIOqya5cux87bbsOHoiSj8v6c0qJDE64yZD6P7558h/vjjAYMB1YsWI++++1D+1VdaBSr+5JP9fehErZ+x2LlzJ/70pz/h8ccf16Z4VVVVun/IkCGQVVU//PADJk6c2NynJSIiIgoJMvNQ/s23KH7zDdQuXebZHzFkMJL+dD7ijp2GMNOeIZq9sBBFL72EiP790fn662FmM2LqKIGFdOCWylAXXXQRHn30UU9gIaRx3o8//sjAgoiIiGgv9bt3o+Td91Dy7juw724oz282I/64Y5H4pz8hctAgz30dVVWomDMHccccA1Pnzkj7210wp6fzPaWOFViUlJQgsaHRirsigVtlZSWSkpLa7uiIiIiIglzN0qUofuNNlH/zDdDQwE6ChYRzzkbimWdqp2w3p8OBql9/Rdkn/4Ozvh6RAwZoYjaDCuqQgcXw4cMxc+ZM1NTUeAUWubm5eOutt/D222+39TESERERBRVbQQHKP/8CZZ99hro1azz7I4cNQ9L5f0LslCkIM5u9HlO7bh1K3/8AttxcRI8ZjfiTToIxIcEPR0/UToGF9Kk4/PDDNcCQMrN2u10b5UlAMWbMGEyePLmFh0JEREQU3L0nKr79DmWffYrq3373NKoLCw9H3PHHI/FP5+kMhJvkplo3b0ZYuAXhWZnaXdsQYUHKrbfC0r2bH18JUTv2sZBg4plnnsG7776rfSySk5Nx8skn45ZbboHFYkEgYx8LIiIiastE7MpfftVgovKH2XDW1Xluixw+HPHTpyNu2jFeMw/1xcWo/v13VP32O+oLChB95BFIOvdcDTT2XmZOFExj5xY3yAtWDCyIiIioNWToVLNkCco/+wzlX36lMw1u4d27I/7EExF3wgk6C7G36gULUPSfV3QZlCyLkiVP0lGbAQWFZIM8man46aeftOTstGnTYGpUDo2IiIioI5JE6uqFf6Bi1ixUzPoe9TvzPLcZO3XSfhNxJ07XkrDuIEGXOm3cqMnYxuROiD/heFh69ULSBedrUGGIiPDjKyJqe82OCiSP4rvvvsNpp52mUctZZ52lQYbkXhARERF1FI7qalT++isqv5+FyjlzYC8r89wWFhWFuCmTETf9RESPHuXVd8JRW6tLnSp/+hm2HTtg6twJMTk5epssiYoeM8Yvr4co4AKLYcOG4eOPP9aysx988IFWgho7dix69OiB8847D3/+85/RpUsX3xwtERERkQ9J/kPl7Nmo+H4WqubO9cqZkKAgZuJExE6epMGBITLS67GOujoYLBbU5+ej5J13ETlkMBJOPw2Wvn251IlCQpvkWEip2ZdffhkPPvggrrvuOjzyyCMIVMyxICIiosasubkaSMgSp5pFiwGHw3ObOSsLsZMmaTAhy5caz0y4l0jVLF6Myp9+gqO2Dql/vUODCMm7YKlY6gh8mmOxd3Wo77//XmctZBYjMjISAxqVUSMiIiIKNHJOVXpLaDDx/feoW7vW63bJk4iZPAmxkybD0rvXfmcbZLlTxTffaEUoR0UFLL17a/UnNwYVFIpaFFjMnz9fg4l33nkHpaWlOO644/DKK69g+vTpAV9uloiIiEKP025HzaJFGkhIQCG5Dx5GI6JGjHDNTEyaCHPmvtWc3EudpO9EhCxtMplQvWgxooYPR8xRR7IzNlFLlkL93//9H2bMmIHx48dr0vYZZ5yBxMTEoHkzuRSKiIgoNEggIHkSEkxIjwl7SYnntrCICESPH6ezEjETjoLpAGMZCUhqV69B9fz5WmJWvs58+F8wREez7wSFhHJfLoUaMWIE/vjjD03i9ofHH38cTzzxBAoKCjBo0CD9WoIcIiIiCm1Omw01K1Z4ms9J7kPj5GtDfDxiJ0xA7JTJiB43bp/k632er74eeXffA3txMUxpqYg7dhqiRo7UoEKw9wRRKwOL33//Xbtt+yOwkATxO++8E++9956WvX344Ye1l8aqVauQ01DGjYiIiEKDZzbh999Q9fvvqFn4h5aIbcyUluZa4jRlsi5bksZ0B1K/ezeq5s9H7fIVSLnxBoSFh2vvCVkaZc7JYSBB1NaBRVZWFubOnQt/mDlzJi699FKccMIJ+vVDDz2kuR7PPvusVqQiIiKijsvpcKBu/QbXjMTvv2sXa0d5udd9JGk66vDDETV6FKJHjdJO2AebWZAV4VW/zkXVvLmwbtyEMIsFkcOGanK2MTwc0WPHtsMrIwrRwEIStB944AG8+uqrOOecc9otWbu4uBhr167FP//5T88++UUxYcIEvwU6REREdOABu8MJOJxO2B1OSEanXfc54XC4bpP9+nVDumeY/Bcml/oFIPfZsQPVf/yBmj8WovaPRXCUFCMMThicThgddphi4xEz4jDEjhqljeqkOlOYwXDoqlDr12sXbFEh4whLBGIuuggRgwbrTIVNytBa7XDKf049FH2c69J1bHLcclUvnXtes+zVS8/+fe8Lz3327HNf1jsc+t7UO5yNLh2otzf+2nXp/h77Oxb92uHe79qHxvfxOp5Gx9/oNWCf1+T93J7bGq67Pk/3c8lx7rmuz9cG9hcnhjWMC90/O41/lsIaf91wB0MYYAhzXcrj3NcNBtf95Ot9Htvwzfe3331MdodsDv1Zl+vyuuVzc/870P1212cnn7PN7oC13qmXssl9rQ3XXZsT1noH/n7yAEzsm4oOF1i89NJLOsCXRngXX3zxPkkc0sfi73//O9pafn6+Xnbu3Nlrf0pKChYsWHDAx9XV1enWOAGl8aUwm81aKrempgY2m/wqcZGgSbaqqiotresWERGB8PBwVFZWwtGo1nVUVBRMJpPXc4vo6GgYDAZUVFR47Y+NjdXHy/M3Ju9pfX09qhtN58rjY2JiYLVaUVtb69lvNBr1+fd+nXxN/Jz4s8d/T/wd4d/f5bLfaqtHpXzfhgG0E2GIiopBTV0dqqtrdL8MIuxOwGiJRGVVDaqqa2F1yGDDAQcMCDNbUFFZjRprnQ7eZOARZjQjzBSO6qpKWG121yDTKftNgNGMmqoqWOvrdVBSL6Mbs0Wfq6qyQve5BjYOOEwW/d7WmmqvAWpYeKTODtjqajyDRbktLDwK9vp61Ftd+/V1yeDKHIH6eivqbTY4GwZPThhgCI+As94Gp33P31YYjDDI8djqAMeez8P1msxwWGtlamLPfpMZYcZoOMIOB4aP3LPfbEGYwQhHXcPfyqWAcfkKmMI3wGA0IMxWA6OMFN2BgDkSDrsd9XXVrsG2vK6wpQizRMHp6AOnHM+WbcC723SUaJD3wG7T49/zTdvyNcn+moaDO8BrarRfvrdT7t94f3ikPq8eeyMGfU127/18TUH9Oe0ukd9HqX4Z7zWrzpOzmdauXet8//33D7gtW7bM6QsrV67UuPmnn37y2j9jxgxnnz59Dvi4e+65p+G8woG3Sy65RO8rl433y2PF1KlTvfa/+OKLur9///5e+7/++mvdHxsb67V/xYoVzrKysn2+r+yT2xrvk8cKea7G++V7CfnejffLse3vdfI18XPizx7/PXXU3xETJ012FpTXOG+47a9e+08++3zn/M1FzhPOOM9r/zlX3uj8ZPF255DRR3rtP/+WB5z//mG9M7VLT6/9Z9/9rPPW95c6wyOjvfafcN9/nac8/t0+r+nwez51DrjO+xjDwiOdXW773Jlyxn1e+83JObo/adp1Xvsjug7T/fHjzvHaHzN4qu6Xy8b75X6yXx7XeL88r+yX79N4vxyH7Jfjarw//eKnndkz3tvnNck+ua09X1PCuLOd3W791BnZdWhQvqaut3/ujB3i/ZqSjzjX2feur5zR3Q/z2p85fYZzyH3fOCM6d/Ha3/vCfzpHPfC902iJ8to//rbXnNMe9v73IdtZ/57lPPHvb3sfe0S08/LXFziPv+Up7/cxs7vz+rcXOSdd9jev/V2GjHHe/N4S59gzrvTaP2TSKc47P17mHDr5VK/9R59ztfMfn6909jpsnNf+M2b83fnYt2udaXv9e7ru4f84X/hxozMiKsZr//2vf+3899dL93lNsk9u83rfo2KcL/28yTnjkVe99md07aX7L7j1n177+48c73x2zgbncRd6f35jjj3d+eT365yjp53utX/yedc4H/pq9T6vafq19zrv+d8KZ+fsHl77z/7bs847Plq2z++Iix/70Hnjm3P3eU33fLDAeeNzn+71mqKdL/600XnzY96vKadHb+d3K/OdN//jMe/3fdJkv/0uz83N9fz+PpQ26bzdXkuhkpOT8eGHH+LUU0/17JeSt9L5+8cff2zyjEV2drY+xj3bwrP7PLsvOLPE2TLOAO45y1VaXoGqWitqbXbU2RxwyFm7MCOKSspQY7M37LfDaQyH1RGGkrIy2OpdU/Y2hwNOowX1TqCyQs6QN0z3251wmiP1LH5tdTVsDUsB5Oy5MzwSNms96mqrPUs8bLKcwhgBq7UONqu1Q541ljPqZmMYLGYzIuSMobMeZtgRbjLAbDQg0hKOyKhIGOxWGOGA2WDQx4Q3fE4OWw0McMJkMOgSjoiG/XJW3hQWJu0Z9DHRUVGwWMJhq6nU5zUZDTAbwnQm3Gw2oq66yrUUpGE5SUxsjI4r6mqqvJaJxMbGw+Go15kMY8O6ErPRiLjYWNhsVtRb61z3NUDPfsbFxOh+m7VOj1tuM9lsMKxZjeKff0HF77/B2tCcLjwsDOEGA+RdN/fti+iRIxE5cgSSRo2CJS4OFRWVusTEvVwnIjJSP6fi0rKGZTiu5ThmSwRsBbtQtGoVqrfmIn7yRJgSEmDauMk1VurWRXMn5PjltcXHx+lMRm1NjWsJTRhgNBh0xkl+7urqaj1LXuR3RExMNKx1Vv25dL8vcgaYKx+4miO6g65QkfsmJCQ0qdxsiwILebHPPPOM5jZMnjwZl19+OdavX6+bNMvzlb59+2LKlCl46qmn9Gs5dAkSzj///CYnb7OPBREFI/l9J0tY3IN62eR6jdV1KYN/99e19Q2Xer+G/Y0eJ/u8rte7Hu/ZV+9a3x3IZJAXbjToZtZBeJgOrmVAbjKEuQbOuq/x9T2XJqMMiN2P3/NYc8N+1+Z93T3Yd39PS8Olfi37TWEINxr1ud2DaNela922DGT33h8K5Uq1BOyyZaia9xuqfpuHmqXLgEYDICG5DlGjRyN6zGhtVGc8xODF6/nr67VZnSh+/Q3ULFkMR3UNYDIivEsXJJx8sieXgogCrI+F/HE79thjNedBopd169bp/szMTK3WJH0uJO/BF26++Wb85S9/0RKzUm72X//6l3b+vvLKK33y/YiImkITQesdKK+1obK2HhW19aisk0ubXnd/XVVXr/fTxLyGSznDr5vd4bpNzvg3XPcEEA3Bg7/G+pFmIyLMhoZL92ZAZLgRESYjIhouZeBtMe01CG8YeO89KA9vGOAbZfDuGeh7D/olKPAa5DcaxLvXzlNgloCtW7sWVb/P10CiesFCOPcqAWvOyEDUGAkkxmrCtalTpyY/v1Rrqtu4EdYNG1C3YSOsW7Yg/cF/whgTA1NqKmInT0Z4z56wdO2qSdhE1H6aHVjMnj0bO3fuxNKlS3XmIC8vzzOFctRRR2mPiWuvvdYXx6qlZiVquuqqqzwN8r7++mt06dLFJ9+PiDrOwL/xmXv32Xy5Xm31/to9iPdcyuDe2nC//dyn2uoKHGTpTnuRMXVUuEkH9+6Bvgz6deCvg3zXoL9xIOAODtzXLY0eK/dvHDC49rnuI4FCKJxVpzYIJObPR/X8BaheuHDfErCJia7yr6PH6KyEOTu7yT9XMiNhyy9AeFamfq+8v/5VZyQMsbGw9OyJ+JNP8jxX3DFT+VESBVNgsWbNGhx99NG6PmvvXwoZGRkadPjSjTfeqBsRhQZZM11aY8PuijoUVtbppft6eW09aqz1DQN+hysAsMm+PUuAZOAv19uD/EqMCTchNsKEmAi5NLuuW1zXo8NdZ/U9m9E1cN/f2X3ZNFhoCBBcwYDrUs7ec7BPgRxIGGJitBmde3lTU0rAei3727ETdWvXaPM7KQsLhwOZjz2qze2S/vxnmFJSdOO/g6YprbaioLwO8ZFmJEabYTEZEcjkZ6Dxckwt/RoiSwdDLrBITEzEtm3b9PreH/Cvv/7qlVhNRLQ/Uv6yuNqKosqGrUoCBbm+J2jY3XBdbm/L2QDPgN1sRJSc3W80eHdflzP4cltkuKlhcG/Yc939tdmk95X7uYOH6HCTrqUn6kgcNTWoXbEC1UuWoGbxkv0HEtHRmhuhjekOPxwR/fp68h6awl5aCtuuXYjo3RuOqmoUPPAAwmR5Xc+eiDv2WH0+NDxf5KBBCGXa0M9qx67yWhRXWTGia5Lu/3zZTmwtqtYlmTKLWl5jw/mju2BU92Qs3FKCt+e7xm4i2mLCiK6JuGBMV11+OWt1AZKiw5EcE47EqHANQCQ3ScjvYVnK6Z7VlRM4PVNjkBIbgbX5FVi4tdjVn6Ghj0VmQiSmDUzTEzwv/7LJ08vB3cfh+km99HftG/O2YHV+hVdPh1MPy8JRvTtj3qYivPzzZq/X3a1TNO46ob9ev/S1hQ1Fi/b0kbjnxAH6vedtLNK/ISmxFnSOtSAlLkJP6jAoCdDAQvIrrr/+eu1n4c5WlwpLDz/8MObNm4c33njDF8dJREFAcgPyy2qRX16LnaU1yJPrZbUaJEjQ4A4eZAaiuWUjEqPM+keiU4zFc5kQaXYFAp4Bv/cZfs/1Rvfh2nyiQ88W1GgQsVgva6VqU339PoFE5IjhiNZAYlSzAwnP74z8fFR88w2q5i/QHIn0hx6EMSYaKbfcjPCsrKDOkXAvwayrt+vAOSkqXE88yIkVV+Wsg3cDl6BhV4Wr8lSftFgNGB7/bp0O9GXQ7vb0efH6+62k2qZBQucYC3p0itETHtlJUXqf0T2SMSAzDmU1Nn1e2eR4hDzvF8vzvJ5TBusvXjBCB+PP/7gRmwu9qxldckQ3DSzkedblV2gQ4i5SEBdh8jyHvG4pWuC63VWwwE2OTWZO5HeyqSG/qkvD8fbsHIOLx3dz90j0BENufxqd43qfGv4nXVM6xbhez5aiKg0uJKfN7YwRWZg2MB3biqoxf0sxkqPDERdpRkKUWd+HxOjwZs2il1S7Ppu0uAh97IItxfh6Rb5+1jI7HRdhRu/UGEzql6qf97IdZbpP3hv5vnsvMXXn6bkb4rlPeslMk/w9lYBJnjcYtKgq1C+//KJdt7dv365lsaRclZSCffPNNzWxOpCxKhRR88ivCMkvkF+kpdU2vZQ/YPllrsAhr7QWeQ3XJYBo6m8U+QOjZ8iiLXqWLDnGor/sJWiQP4ydYsPROSZCv5b7yUwDBe6SBflj6BoccJlWMHHU1aF25UpPECGzEvbdhfvcT5YdRQ4dqlvUyBGI6NevRYGE5/tarSh+5VX9nsb4eNiOmgT7gKEwRUftWVZoMemgTQbLcgbavV9Kv8rPmpxcaA35uZXfZ9V1dlRZ63XZpHRAHtMjWW//fVOR/q5zd0uWAeLIrkk6IF6dV66DV0+RhXo7uiVH4+zDc3SgfvuHy7TSWmNPnTtMc6Me+3YtVu4s10G4u2DBmSOyMb5XJyzNLcW7C3NRWFHnWQokswN3HNtPv/9bv29znYXXLUJ/T8oJk7Y4Gy+BhcwkF1daNQAZ2yNZjzG3WJonAhE6U+sa8MrSzUAnn6d76WxGQqRuf2wtwbsLtqG4Sk5uud7fXqmxuP3Yvvr+/v3zVTrwlxmbhIaZm8n9XEvuZMZn+Y4yr8/mgrFddYZlxY4yDS4izEZP0Y4uydE4fXiW/uze9sEyr2OT9+//zhmmf9f+9fUaDc4ak6BqXM9OmL1mF978bSuundgTw3ISEQxj5xb3sZCSs1JudseOHRpUHHHEEVrrNtAxsKBQ5p5CL6mS5UdWr0v5gyKX7sChrCGIkGBCKhY1leQIpMVH6JYRH4H0hEj9IyiBQyedard4pts5e9B8siQhr7QGOzWoq8HRfVOQGheB71cV4Of1u/UPoAzu5b0dnJWA4wen61nFN+ZthYwFZKDgrsl/5VE99Dk/+GO7/vFtbEr/FPRMicUfW4sxe81uT6UqueydGosLx3bVAdSN7y716soqz//EWUP17OLr87bo0gz54+lOBj+iVycMyIjH9pJq/WO8J7HcqGcP5Y+xkOeObDSAcX8PeX1yJlKWZEgHajkeOSsqs1cyCNUu0zIQDoKBjz/YCgp0OZMEElVLFqNy9TrtJ2JwOmGxW/UMsSw5ksDBFUgMQdTQoTBlZLTJ4NW6dSsc6ZnYXFSFpe9/gTH9s5Bz1Bi8vShPl+M0NqFvii7l2VJYpQO+xuTn5enzDtPr9366Un/G5Syw/IzJz40M1GXAKAP13zYV6e+9aqnMZrVjUGY8zh2Vo7Opd3683Ot55SW+dKGru7cM+GRQLf+W9Ky6IQznHJ6jAzwJOr5fXeApeiDfu2tyNCb3T9WfSRkQykypnJGX2yQQ6pcWp/8+Vu4s0+N1//xKUD4gIw5dO0Vj4+5KLNhcrEFTSlxD8BATzp/nNia/Tyrq6vXvnPxqyUmO0gDxw0Xb9W+eLCOTSwmwHjptkAYZMiMhMwiuwM510kv+lh0qyHI2fC95zvKaPdUC5WdFLN5Wor/X5W+n/N6Sy+ykSP2e8rtOtvgo/+bF+LTcrJskb0+YMMHTvG7z5s3o16+fNvAgIt+RgVNVnd2zjtZT0rRuT2lT935Jbtagwb1VW/XsX0vILzsZ+Lm2cB3MauDQEDzoZXykzjowz6B15A+RBHcyEyQD/gl9XCW8H/hiFTbtrvIMgDrHRuggRz4L+SPXJy1Oz6za7Q7YndClEI1niGTMba13LXdoPEh0J7k3JoMdIWdTJUhwJZa7yshmJbrOKssA7rzROZ4SsLJGWs7SykBLZDfcz90jQ0rxun/+dpTU4PNlebrfHZc0PnN4wztLdJ87+JQzhDPPGKKzV6/O3YJFW0u8jve04Vk4blC6Ljl4bs5GPcacpEgNVGRttgzaWjJT506qlyUUmwordWmLlga22fV7yNlt+Tf22rwtGnhpM0GnU9+DW4/po/8WZEAigwr3oFdu65seq4MTGajIZ+0urSsDULldztY3DqYaH5d7n/xsyMCncYWzXikxemZ2w64K/LSmAJV5u1C1fSeq8guQkLsRxy/5CrYwIx4Zfg7qIobDedgITYiWWYP7ezmRMXwwXi+LxZKdla4ZqIowmOYW4vhBZg1iN+yqxP+W7PCczZWATn7+BmXF63HJZ7d3UKdLglauwof/+xVLd9ehqM9ghEVGISK5Lwb07aHf//hB6XqG3NnoMXLmWMhJijuO69uwv6EdcKNTolMHpOog0N2XRZajuH8G5f2RTX6GE6MiNQ+qe2fXz4L8LN0wpbcuO5Hb5VIGb/K95f29bZrre+6P5C3Itj/yOU4dkHbAx0pgfSA9OsfoRr4ln69radKe5UXyM3PeKO8qo41PmkjeSKu/V+K+tx9sJkJ+LhsvAQsGLZqxkIZ4F198MUaPHo0lS5bgyCOP1C6DUm521qxZAR1ccMaCApms3ZRp0x0N+QmSp7Cz1J2v4DpLvfeZ5ZaQM2gSACQ1zBzIdRkoyB9ayWWQ6xJAJDa6lD+6TH5r25kjd6K6fB4yuyBnz/71zRpdiiBnMoUM7p48e5j+0ZOzpDJQlXW9MpjrCMvD3GuL3QGGzDpIELFse6mnqZ97sCbLUOR92FpUpWf43D0vJLCRM3ryh1veUzlLvbW4Ws82y7+lvmmxuGlqH31PX5u7RQOCLslROsiXINw9KH5vQS62FlfpQF+CBQmC/jK5l342ny7diU+X7PCcgZYgQQYEcmZcBq6SiKq3mV1rp+Wxl4zvps/7wk8bsaWo2tOXRIKPKyf00Nfz7cp8vLsg1+s9keOZMbm3nhyY8c4Szxp0WaMuj//3uYfp+/Dot2uxaqcriVr/kNfW4PSYCgzPW4XFq3fgu6pIhFtrYLbXw2K3oXNNKY7IX4HwPn2wYNAExPXoitg+vRCZlqqPH5KVoD9Ty7eXoaC81pNQK2fW+6XH6Tr/Tbsr8dWKfH3NEhTJgF7ez7un99fP8qo3F+lzyO8RqYy2Y2s+rt/1G8zbt+KrjGFw9B2AvoN7oUdKjK4b50kIosDn06VQv//+O2666SbNsxDnnXeetiq/7bbbcOKJJ+L+++/HKaecgkDFwIL8TQYGklwm0/ubCquweXeVDoIkcJCpefeZ4kORwY0rSaxReVOLq7ypu8ypbBIs7L3JOl9q/YzCropaDQZkACZnsY/o2UnP1s7dUKgJdzIgk/1yFleSJ/umxem6bFkz6x4wC1kGcePUPnq/9//Y7klQlxkhuc7BV8tJMCFLCSRYllm7537cqLMP7sBNgoAXzh+u77EEB5V1diRFu4JpCXJkBkAeK0F/W5W7lOcS8j0lQJIgxr0kRgby8u9TZlkkOPl9c5FnyYx7JmRM92SE5e/E1kUrULNmLZxrVwOrVsBcWuxaytSIIS7OtZxp2DBEDhuGiIGDNDm6rehsRFUNjKUlsO3ehbnrd6OkuBw1Wd1RHROPmE1rMK50IzKOP8ZVcpblQomCjk+XQi1evBhDhgzxfC0zFHPmzEG3bt1w+umnY/ny5QEdWBC1Bxkg5pbUYHNhpS5dkUBCqmpsKXSdQT0YWfmhy4walhdp0lnDciM5wye3yRKEjnC2OtA/Q6liJWfA5eytJKbL+y7LbWSJ2S3vL/W6v4yXRnVL0sBCEvxkrbRcN+vZZgMGNVQoyUqMxPQh6Row6BZr0VKIQu4na7ip7chMhwQGQoLqvx7XTwf2EvjJTInsc491zx/T9YDP05bBXePnkiVPsu2P/Bsf37OTVmmSBGsp+SqXW1auhKOszPX6Gt1fKihZ+vZFxID+iBw4UHMkwrt1a3L/iEM3qcuHLTcX9YWFqN9diKQLztcE7ornn3P1mgDQLzwcps6dET+2NyIH94DzqO4MJohCSLMDC4lY1jf8ApHZC6kK1bdvX0+uRffu3dv+KIkClFTRkAGkbLL22L1JIHGwmQeZZejWOQbdkqPQrVMMunaK0qBBgofUWAsT9Vpx9lSWz8iZXhlMyqzAnLW7UVZj1fXn7lrrkngsZ35lrfjGXZWuii9Sg93hxOR+qbp2Wuqov/rrFn1eWYoiAcDAhrXR8vnJEhmZVZAz2zJ4bZyIfkVDUvT+SEUZdwlI8g8Z2EvAHog/v/V5eajRIGKlJ5iQHg/7MJsR0acPIgYMQMTAARpISBdqyVdoLanYZNu+A46aakQOGABHbS123nILnDZXcCz5GKaUztrfwhgbq52vhQQU0g278awEZyiIQkuzAwspJ3vNNddo920JMC666CLdb7fbdfZCbiPqaCSxdU1+hZaE0+ChIZCQ2YcDLSaMMBs0aOjWSYKHaK0YIkmDsk/WH/MPbssGXrK2W953d1UOWYsvNdglObakyqZLRmQ9+M2SOBsWhs+W7tT191ENPSxkkyUlQq5HhBu1zrr7NllSJqRyjDxHSkPw0Pgss3x2su6eqKWcDgdsO6W79FrUNMxESDBhLy7e985Spal374YgYqBeWnr3gqENezzY8vJQ/vU3sG7bivr8As2O1hKz998HQ0QEEs46G+a0VJizsvTrxiw9DhxIE1FoaVHy9rp16/D2228jNTUVl1xyCcxmM1asWIEffvhBm+cFMuZY0MHIPwcZtK7Oq9A65bJJQCEzEAf6lyJBQs+UGN2kmof7ekY8ExNbQ9aeSzAgA3pJcF2cW6qVhNxNj84Yka1VOqTzq5RZjW9Ue1yCgeZWASLyXQCRh7oN62HduBF16zegbsMG1G3aBGd19b4PMJlg6dXLs5wpYsBAWPr0brMgQmYjrJs26dKlunXrEN69BxJOOVkDi+LX30B4TjbMWdmuy/T0oG5QR0RB1MciWDGwIDdZLrOuoEJriksgsUqCiLxyXT+/PzJYlaoovVJiPcGDbLJGm/ateOSuGiMN8KRcpOQqLNpW4lmOJJtUmnKXZZSKPDIzJH01JLiTpOh/nDJQS9h+vmynBhWyfCUzMRJZCZFMaqbAW8a0a5cO1uvWrXcFD7Jt3Lj/AEL+AJvNCO/RQ4MImYXQ5Ux9+sBgaV3jt70DCemabYiKQuWvv6Lk7bclgUg7Z0syddSI4YgaPrzNvh8RdTw+72Mh3+Cxxx7DF198od2309PTMXnyZK0MJc3yiAKNLI9ZX1CJ5TtKNbFWyilKMLG/xm9ST14Chv7pcbqkxrXFamO3UCeDp4LyOhRV1enAv7ShidAJQ9K11Odbv2/FT+t2axUbt+lDMnDysExNgP50yU7PkiNZppQaZ/EEFtIwS4I9mQGSJmqZCVE6AyFOGJzht9dMtDd7ZRXq1jcEEBJIrF2L2vXrPQnV+zCbYenaFZZePRHes6fmQlh69tJZgdZ0rz5QJ22dkVi3DrXr1mlDuvgTpiNu2jF6DAmnnabLqtqq4R0RUatmLGpqajBy5EhUV1drqdmsrCwUFBTgnXfe0X2LFi1CUlISAhVnLDo+ORMuydTLtksAUaoNs6TWu1SA2Zsk4Q7MjPcKIiSoCOWKS9J4T3JJiho11pM+AZcd2V0Di6vfWuRpchZlMSE+0oRrju6pMwvSP0BmJtyN9OIjXU20Qvn9pOAlScvWzZtRt3HP0iHZbDt27P8BRiPCJYDo3csTPGgwkZPT5gGE5xhravT4wrvkaCJ1yTvvoHLOj5pELUuq5Fgi+veHOcXVZJGIKKBmLP73v//BarVi6dKl2r/C7fbbb8cRRxyBN954A3/5y1+afdBELSXLZ5ZsK8WCLSVYuLVYO/LKUpy9xVpcQcTgrHhtQDU4MwHZSZEhc9auccde6corMzjSnG13pVUvpTa+zC7IkqNn52zUYCA5RvpeWNC5YbZGHisJzfJeSi7D3gHDkGwmNFPwsVdUuPIfJIDYuNF1fdMm2LZv927x3IgkNstSItki+rguw7t3b9NlTAdSu3q1JntLsGPdlqvHmHTRRYgePQoxEyci5qijYEpLC5nfbUQUOJodWEiH7QkTJngFFSI8PBzHHHOMRjVEviRNyf7YUuIJJFbuLNdZisakL8AACSIyG4KIrAR0SYoKmUZjEkSs2FGu+SO7Gro7yybdhyXBfNHWUvy0fndDL4VwfZ+kcpWQGZsnzxmm7+H+BibyeKJgo30YduzQpUHWLVtg3bIVdZs3wbphI+p37z7g46S0quRBSOUjDSQkiOjVC6bERJ8er8xESM6GbDa93I2E00/TWYnKn37W1yDHE33Eka7jSemsj+PMBBEFVWAxfPhwPP7447okKjJyTx3w+vp6LTd71113tfUxUojbXlKNXzcUYv5mVyCxtWjfREjpATG8SyJGdk3EiK5J6J0a69VXIJRK4g7LTtCA4P0/crWPgyQ8y/sxtkcnLZsqThuehTNHZu/3eaQng2xEwViBqT4/3yt48FyX2Yf6/Rdm8MxA9OyhVZIsPbq7Lnv2gDEpySdn/iX4d0rwUFziCSAk+Ik/4Xi9beftd8BZV6f3lWVN2jeiuloDi6Q/X6SJ35yRIKKgDCzWrl2rHbfdJKCQAOP8889HRkYGdu/erTkWJSUlmshN1BolVVZtTibBhGxb9gok5G98n9RYjOyahBENgYQEFqFIqi5JGdbF20q1opXM3Dx46iCkxEXg1ml9DzjrEGpBF3UcTrsdtrx82LZthXXbNli3btNL19e5nsH4/oRFRGi+g+RBhHfp4sqH0GCiuw7Y21p9cbGWmrWXlMBeWgJ7Sal+v+ixY2HdsAG7Hn3Mc19DVCTMOa6u6/JvNvnSS/SYJOCRik6NtWX/CiKidg8sZCbi7rvv3mf/o48+us++jz/+GEOHDm2bo6OQIGfVF24pwS8NgcSKnWVey5plEDw0OwGjuydpMDEsJ9FTLaijkzOXUrnK4YA2dZMO0fJ+SXM4ue3+z1Zpedy+abE4a2S2vk/u6lUxFt8kixL5miwD0mVL27fDlrsd1txtsDUEEDrzYLMd+MFSwjUryyt4CO/aRa+bUlMRZjC0/RKrnTs1qJHmcrZtuUg460xYunVD5ew5qPjuOz0bYoyLgzExURvMCVN6hit4SEzU45Lyr41PAkQOGtSmx0lE1B7Yx4LanQyI1++qxKzVu/DLht2aK+GuMuTWOzVGl+6M79kJo7onITbC3OGav8kQItpiwo/rduP9hbmuwMHhhKSLDMiIw4zJvfV+f3l7z2yhkLHHY2cN1fKuUv0qNS6CQQQF3ayDLlnavgO27bmuAEKu5+bCumM77LsLD/p4WQYkZ/d19iEnB+YucinBQ46rqZuPKjA5bTYNeKSZXPSYMbov/+//cFWJCguDOT1Njytu2jSY09JgLy3V1yp5Gr46JiKioO9j0VhxcTESExO51pMO2UdiweZifL96F75fXYBtxd7Lm9LiIjCuZyeM75WsAYUMljuSoso6rC2owIZdldqUL6+0VnMcjhmQhm7J0Th2YDrMxob+DoYwdIp2zTpEmFxlXl19H6C9HywmIyLNRr2didQUqCcPpKeDNXc7bDtkxiF3T+AgQcTOnQfNdxCGmBiYs7MRnpUJc3ZDEKEBRI6r4pHR9W+gPUrOln38Meo2bYYtT47bDhgMiBg0CMaYGCScdirCLBadidi7IpQxgVXSiCi0tCiw2Lp1K2699VZ8/vnn2rsiIiICEydOxCOPPIJ+/fq1/VFSUJIGanPWSSCxC3PW7kJFo47WUqZ0bI9kTOjdGeN7dUaPzt7LAII9iXpnaQ22FFZrDoiUZf1ieR5+XLsb6QkRmkh93MB09E13Rf05yVG67Y/JaMDo7mw6SYHHabXqmXtZAqSzDhJEuAOH7dvhqKg4+BPIkqWMDB2Qyxae7bo0Z7quG+Qsfzv/Tmjc+E4SpZMlSdpi0TwOOabocWNdMyNZmQhryHOQHhFERNTCwKKqqgpHHXWUNsZ7/vnnkZ2djfz8fLzyyisYP348Vq9ejRQ24glZ24qq8d3qAny/qgDztxR7lYFNjg7HxL4pmNQvVTsryzKgYCavTUq4umdXXv11M1bllaOo0qpfyyyD3CaBxfTBGTj1sCwuWaLgnHXI3ea6lABCAgmZgcjPhyb/HISxcyeEZ2U3ChzkeqbmQGi+QxvMOkinafdMQcWcObAXl8AQGaEJz2ERkbB07wZT586atyGbISICYZGu/jXyGuXSVlCAohdfci1pcjph7JSMiH79PLen3n5bq4+TiCgUNHtk98UXX+jSp9mzZ8Ns3rPu/cwzz8TUqVPx7rvv4rrrrmvr46QAtrmwCl8uz8MXy/J0YL13roQEEpP7pWpicbBVI3I4nKittyMq3KR5ID+sKcD2khrdZFZC8iL+fe5hiDAbNYCQClVZiZHIToxCWnyEp2xrYjSruFBgkUGz5ADYdux05Q3sbLhstDmqqg76HFplyR0wZGe5ggi5zM6GOTMThkYlyVt7rBoIWK2o/PlnDQTqC3Zpnoa9rAyZjz6iyc+SOC1N49xBBOx2JJ7/J8R07ozqPxah5M03Gw48DGERFkT06YtOV16hS5bkdcROmqi9IUzJnCUkImqXwEJmJ0aOHOkVVAj5pT9mzBjk5eW16ECoYwQTEjiM6pakgYRsB1riEygkOVr6ZLgaxVmwNr9Cc0Ck5G1JtQ1lNVZduiSlW2VVxqdLd2ppW2kmJ4nl2UlRMDUESycPy/T3yyHyqlakzdXy8rTkqVzW5+e5AomGIEKW+xyKnO3XXAcJICTXQS9dsxByW0uWK0kZVntpGRw11XBWV2sQoNWbcnI0l6Fi1vfa48FRLVs1jEmJSJkxAzAaUfb55zAlJcOUlqpLk0wpqUBDYnTSBed794mw2bRIgogcOADG666Fs7bW9bw11Z4mdzLjkXThhfzpISJq78CiZ8+eeOKJJ1BaWoqERolp0jDvs88+42xFB7Zpd6UrmFiej9V7BROSL3H8oHRMHZCGpAA/O59XVqN9H5ZuL8XGXZVa2vaMEdmYNjBNlzfV2ezITIzEwMx4JESZdeZByOzD0+ce1mFyQSjIqyoVFqF+V4EuSZKz95JYXC9BhPR4kCBi165DLlXyLFfKyNQZBnNmRsNlw5aeftBZB4fVql2rdSsq0vtKjwYZ0Bc+93zDzIEED64AIf3v9+vsQOn7H6CmUW8kidrjTz1FAwvY63WmxBAZBXNCovZ3MDX0R5KlU5mPPdakf4NyH3cehL7OhAREMpmaiCiwys3a7XbNpcjNzcW5556LzMxMFBQU6BIomcVYtGgRovZq5hOsJbPI1fX6k8U78PmyPO3q3DiYkCpOxw9Kw9T+aQG91EeWMEklJlmeFB9lxtvzt+Gndbu1pOvgrAT0So1BcrRFE8qJAiGvQc7o1+8u1MChvkCCh4ZL+VquFxbqMp9DkrKsaWmuLSNdB+jmtPQ9gUNGuuYcHIwEBJ7gYfduWHr2hKVXL1QvWICil//juZ8M4iP69UWnq67S11H0/Aua6xAWFaX5DhIoRI8epddtBbuAepvnNnksA3YiouAfO7eoj4XMTjz++OM6Q7F9+3bttj1lyhTcdtttAT9YZ2DRtKpGXy3Pxwd/bNcO2G6y5GdskAQT0pF6+Y4yLM0t1aVadTYHLhrXFUf06qzLn8KNBgYS1H7BQnm5KzjYtQv1RYWwFxXrGX57UZFe1hcXwS4zEMXFhyzD6mE0wtSpky4JMqekugIHCRokeNDraXr7/hrCeXIWnE7UrVkDe1k57BXlepxyPeH007ShW/Hrr6Nq7jzP4ySPIW76CYidMEGDG8lnkOVQshni4hgcEBF1QD4PLIIZA4sDJylLFScJJr5anocqq+tsqKw4GNM9GScPzcTUAamaoBxIAVBhhRW7K2uxWy/rdDmWLMV64aeNmL+5GD1SYjAkKwFDshOQER/BgQ+1KafDoQnQkkTsmlVouJSvC/ZcSr5AcxhiYzWBWConmVJTYE5N23NdAoaUVJg6JXuqKmmQUlYGR1W1LiOSWQbJWZCKSNYtW1D+1Ve6T2+rqoYxIR6pd9yhj93+lxlw1tUhLDICxrh4DSgk4dmckoLaNWu0bKwneIiO5k8QEVGIKW+PBnny5NLPwmp1ldZ0S0tL01K0FBxyi6vx4aLtuuUW7xn8dEmOwumHZeGUwzKRlei/pW0S9xaU12l+x86yWl3WdO6oHL3trx8t9/TGsJgN6BxjQWWvzhpYSGnXc0d1YXlXahbJGZClSBosFJfAXlLsSjQuKm64XgJ7caPrpaVNW5LUsMZfg4PkZBglaNDLJJiSO8GUnASj5zIZhka5Afv8m7DZYN22DRWLFyF6/BEwxkSj7JNPUL1g4Z47mYyIP2G6Bhb6GIcDxqRkrd6kOQudO3vumnbvPRow7O97RvTt27w3kIiIQlqLZiyuueYaPPfcc3DsJzHwpptu0kZ5gYozFkCN1a4N2z74Ixe/bSr2vDcxFhNOGJyO04dnYXgX/3RTr7XZUVVXj+QYi5ZzfeirNfq1SI4JR1p8JG6Y3EuPbcWOMkSFG9E51qLHzjXaoU2rANXVwVFZqZs0O3NUVjRcr4SjvAJ2WepTXgaHLP3R67L8p8y1FKi8XCsGNVtYmPY90FkFWZbkvpSZhdSGy5SUQ+YyHIrMOtSuWg3rls1w2uq1cVvn66+DpUcP1JeUaHUlzVmIjkaY2cx/D0REFPgzFt999x3eeecdfPnllzjssMP2KTsrXbgpcKshvTFvK/47fxtKq226T2KHcT06aTBxzIA0RIa3vmFVc5TV2LBqZzk27q7Ehl2V2h+if0YcbpzSW8u/SkO9nikx6N45WntJNCZVmyhEOjxL4rK7TGqe61IqINWXlOpSHQ0epOeCzfVz3SoSKMTFwZiUpJspKRHGRLmeCJPuS3btk+uJSTAlJnhVH2ptcCR5GFaZDd6yRS9TbrgBYSaTdrSWoCH+5JM1gVrKvbqXQmnZ1IbSqURERP7S7MBiw4YNOP3003HMMcf45oiozS3aVoL//LIZX63I93TCliZu5xyeg1OGZSIjoW2aWDXVDmks53BqD4gNuyrw0s+bkBofgR6dYzChT2ftGyGkShN7Q3RsjtpaTQKu37Wn6pD2WpC+CzsbAojdu7UbcpOFhbmW9sTEwBgbA0N0jF43xMZ4cgiM8XGabKxfu6/Hu26T++4v4bmtaRBRUKAzJRG9e+syrLzbb9ceC0KWSVl69tL3yBgTg06XXebzYyIiImr3PhZff/11q74p+Z7kIny1Ig//+XWLVkZyk+Z1fx7XDVP6p7ZrF2yp0vT75mLM21ikeR2juyfjsiO766zDk+cMYy5ER5xlkOZsEhgUNFRDkuBBggh3AFFYqLMNTSHLfswZGa6KR9JrISNDS6dKfoIGDzHuLVZzCNojMGgqR12d5mFIWVV5zRWzZ8O2bRus23J16ZYxMREZD/5TcxziTzpJl01JIzrJnSAiIurQORa1tbWYMGECzjnnHJx55pmIjXWdXXYLDw/XLVB19ByLoso67dPwxm9bNelZSGnVE4dm4M/jumJARvsvH/pjawmenbMBhrAwrc4kzfQGZcbDZAycwR81o3SqVB6qKG/oryDN2PL3zDJodaQ8LZ3a1FkGCRq06pCUTpVL7bngCh6kbKpcyrKjQMuhkSZ1+tp37dL3I2LwYF2SVPnzL6iaO7ehfGuFBlnRRx6BpHPP1cZ1hc88A3OOdLDOQXiXHAYRREQUuuVmJTH7lltuOeDtTN72j82FVXhuzkZ8vGSHzlYISWo+f3QXraIk+QrtQZZaSc7Eb5uKtM+F5G6U19q00/XIron75ElQ+5BKQq5So1WaiyCJvnLpLj/qvs2V6FwBR0WlziZo0rM7h6EhKbop3ZyF5B1okNCQxOwVPMiW4vpaSqsGWtCw/xmY3QjPytSvdz/9NOrWrNX3VRmN6HztNYjo1w/VCxeiduVKGHTZVay+PnNGpuexREREwcSngUVeXp6WmT2QjIwM5OS4yoEGoo42Y5FfVosnZ63HewtzPfkTg7PidXbi+EEZ7dYErrjKiu9XF+C3jUWakJ0WH4FJ/VIwsW9qu3z/YOWsr4e9xFW21O4ewFc0DOwrK2D3DPD3DPalH4GcLZcBvpQRlWU2TqdcOvba59Rma3r/vcpCt5rJpMGBdnROT9vTmM1zPS0gZxkORt8vu10TpWX5UtUvv8CamwvbtlydiZEZmMwnn9AlS+XffaeJ05JALTMqWokpiF4rERFRQFSFki7bspF/lVRZ8eyPG/Ha3C2oa5ihOLpPZ1xzdM92KxUrDeqKKq2ahC3Xf1lfqLkT43omIycpKuQGWu5lQhokyFbSqA+CpyeCuw9CiZYIlZ4J7UlmETSxee+toUypK18hdk/is1yXpGdNfnbvj0VYRHA0G5Sgyp3PIZ+JfB0xYKD2d6hZsRLlX3zhahwnW001LN17IOXGG/S1lX36mQZL4T26I+boCQjPzvZUYYqbMsXfL42IiKhjVIVasWLFAW/v1asXBgwY0NrjogOQng5S4emFnzahoqG/gywxunVaX4zsmtQug+c1+RX4dUMhFm4pQUqcBfefNFCb6D125pAOkzehQYLMFGhw4AoC7CUNwYI7cHAHD2WlqNevy1pW7lTKm8bHuwbuOoh3LZ/xDOY9+1yDeu1+bDS6BrlhBoTJe24wuBKWvfbJfQyuoKFRf4OORD+nykpX8KCVpXahfnchEs87FwaLBUUvvYzaVau8gipT5xQNLAyRETCnpXoHVsmdPPfNfPyxgEoCJyIi6nCBhfSv+Otf/+q1r66uDvX19drTQvIvHnjggbY8RpL3uN6O//6+DU/P3oDCSteyln7pcbj1mD5aorU9zh7vqqjFI9+s1VmKlLgITB+SoYnYboEaVMiyIW2G1jggKC3zDhI81yWIcH3d1I7K+0tGli7LUu1H+x0kNPQ8cPdBkN4Hnj4IiRpUuM+E06GTpa1bt+jSrtijj9bPaOett3kSxaV0rCzRkhkICSziTzoR8SdO130akDUijeVkO+DnyKCCiIjI95239yZBhZSgvfXWW/Hbb78FdO5CsOVYSN7ER4u244nv12v/B9E1OQo3Tu2DEwalw+DDkrHyo7Fse5k2rzv1sCztPSG5HCO6JmrPCX8thdHlLQ1Li2RZ0Z7lRd5LjTxBQ3l58/ogNCJnsnXw794kYNCgwXVpcn/dEEjIpSGyffuCdNQgQkqxyvsveQ4l/30btu3bXcnSYWHaIC7lphv1vjXLV7iCuM6dNJggIiKiIMmx2O+TmEw44YQTNLj48MMP8ec//7ktnjbkzVm7Cw98sRrrd1Xqe5EaZ8FfJvXGGSOyYPbh7IBUlZq3qQjfrszX5PAeKTGotzt0RuLsw3N8k5fgDhKKir3zEmRfSePrJXDWuAKs5tKlLo0CAK8tMUFLhe4dRHCg2rrPVoODiAj9um7TJq08JbMN7i1iwACtDFW7Zg1qli7T+9sK8mHL3Y6okSORdP6fGpYvdUbUiOEIz8nRUq2NP5fIQQNbcZRERETUVtq09qdEMwerGEVNI4P5v3++Cl8sz9OvE6LMuOqoHrhwbFdEmH27ZEYCiLs+Wa5VnoblJGp1qebMTuhgUmYUZMagqKghQGgIFNxBQ1GjfcXFLapYJGvgPcuLEuWyYXmRXncFBl6zCbLcKID7qwQbz/KyklIYLOEwZ2bq51n2yf+8lpxJ7kfWE4/rY0refFN7XXgYDOh0xeUaWNQXFqFu3TrNAZGZh8ihQxHRq5feTZaPJV/MkxVEREQdLrAoLi7Grl27vPbZ7XYsX74cL7zwAp5//vm2PL6QIoN6aWz36LfrUFlXr52x/zy2K66f3AtxEWafBjI/rNmFUw/L1MDltMOy0LVTNFLjInTQb2+oqONafiRLjEpcQYE7mVmChNKG5GYJFKTTcDOFRUa6Zgz2ChZceQnJe/ITGnIUDNGhV3WqvegskgYN8jm7Pu+IgQNhTklB5U8/ofyrr11BQ8PysqiRI5B8ySWak2AvLtJALjwn2xPUyfPJZ9Xpuuv0UgI83Ux7fv3EjB+nGxEREYVQYPGf//xnvw3yIiIicNVVV+HUU0+FL0lFqnnz5unyq7Fjx6JPnz7oCJbmluLOT5ZjxY5y/XpYTgIeOHkQ+me0TR6I9DaQwaJ7oFhfVIR1+RX4Ps+GFZVATH0tur2zFhkleehcVobyslKUlpZpPkNLSDlSTyCQnOQKFORS9yV7kpfd92FeQvv2zrDlF+xZfiZlb8srkHj+n3Tgv+uhh2Ddum3PZ2k26eckgYU0uoseM3qvfBNXNTK5nnLzzQf8vhI4EhERUcfV7OTtyspKlMrZykZkkJ+SkgKDD6uoyGEed9xx2LFjB0aPHo3q6mp89NFHuO2223DPPfcEbfK2dKWWSksyUyGfRFyECbcf2w9nj8w+ZGK2BAsyMJRBYn1+HmwFBQfsl7B3laPPu47BgrR+SKkuwdi8FRhUuBEmabJ2kHKoOpjUGQPJR2ioaOSufNQoN0EGoZJ0S/4jPxvWzZt1eZEsM5KfCXNmFhJOO1V/HvLuaKjsZjB48ks6X3+9ziTULFumsxHuz1N6V3B2iIiIKDSV+7Lztr84HA58++23mDZtmmefJIqffvrpWLNmTZNnLgIlsJC3/bNleZpLsbvCtXTo1GGZuOO4fugca9HbJRiw7diJeklmzct3XeYXwJafh3oJJgoKXFVymqAgKhELU/piYE0BelrqsS2lGxxx8egXKyU64xs2Vy6CMcH9tWuTXgoshxr47JVVgL1eP7PKH39EydvvwBAVqYnPMqtg6d0LsRMnuoKOLVv2lLplWVUiIiJqr8Bi7ty5SEtLQ/fu3Q91V51RWLt2LSZOnAhfKygo0OOS3hrHHnts0AQWmwur8LdPVuCXDYX6dZdI4PbEIgwt2Qzbjh2w7dypAUWTqh+FhWnyqyk9HebUFF1m5M5RsCckYZkzBr+UG7GlGkiIi8LZo7pgVPc9vScoeMk/Xfk5qV2xArUrlqNu4ybETDwaiWecoYnV0jQuvFs3Bg5EREQUOOVmZfnTqFGjMHXqVFxwwQUYN24cYmJiPLdXVVVp3sNbb72FTz/9FE8//TTawwcffKBN+YYNG3bA+0jzPtkavzn+TM5+6J6X8Jo1FTaDCWa7DWevm4XT189GuMMO7wVmLnK2WYOGtDSY0lJhTk2DOV2up8GcmgpTSso+3ZSl34Qso/p6RR7eX7hd8zSu7dMZQ7ISAraJXaiS5PiaFStRX1ToCgCkg7bJhKjDD9eSqnUbN8JeVu7qpG006aU5OwfGmGhUfPMtyj75RBvyRfTtg8Rzz9Eka2GMi9ONiIiIqL00KbCQgEKSph9++GGcddZZGmikp6dr9FJRUYGdO3fCYrHg/PPPx+LFi5GT07ReB1988YVWkzqYK6+8EgkJCfvsX7RokeZX3HXXXTprcSAPPvgg7rvvPgQCqfL0R40FNrMJw3atxbXLPkZOjAnmYUNhzsyAOSNDy3aGZ2bqdVNGBgxNLJEqQcv8LcX4ce1uLQ975shsjO/VGYflJGqXbPIvSYKX2Sjr9u06yyDBYOJZZ+ptRS++6CmF67TXS1dERA4eDFgsqPj2W+3v0Fj8yScjbtoxiBp+mFZfsvTqtU9wSURERNTemp1jIWf/ZXZCAoKSkhKdEhkwYIDOYkQ1M2H3/fffxx9//HHQ+0gFquRk76U7K1euxNFHH41TTjkFzz333EETS/c3Y5Gdne23pVArfpyP1btrcOLh3RCeltbq3go2u0OXVH25LE97T/RLj8OU/qkYkr1vMEa+o/07amo8/RskQdqcng5L9+7aGbrQPYtnMsKcnqH5DrJkyZ0bITMQez+f/Fw7tJGcDXDYtXeEJOBrDw/ORhAREVE76JDJ226rVq3SoOLEE0/UvhnNrVYTCDkWbZ2v8cAXqzCyaxKOH5yOrERWY2oOSX6X8qtS7laWJUlAAIcDTrtDB/OyNCk8K0vvK8uSHJWVXg3gYo89Vsuwlrz7Hipnz/Z67phJE135DhUVqF21GuFZmVqutXH/BiIiIqKQyrEIFKtXr9ak8JYGFR1BXb1dlzut3FmOGZN7oVunaDx8+hAkRbOrdFNYt25F7Zq1sOmSpB1aojd20iQknHoK6rZswe7HXF2i3aRqUsa/HtLrRS+97CrbazQ2lN9N8DQDjBo5EpYe3ff0d5BqSw0BhDE2FtGjDm/znwUiIiKiQBI0MxbSt6Jnz57a5XvGjBleQYX0txgsa9I78IxFrc2OOWt34esV+aiss2NMj2ScNypHO2V32KVFMptQWwtHba0O4GVWQSpgyQxDvXR/l2Rn+TmQbs4y2E9K0p8LWVokfRskeHDlNOxAwsknI7xrV5T973+o+GE2zFmZrnyWrCzNUZBlS5IHIffX0rqSRG00anAg+S5CmgrK14a4uJAMaomIiCj0lHfUGQupSCXkhTXWOIeiow6yH/xyNfLKajGuZyccOygNKbHBl5AtgYLmHqSk6Ncl778Pe2EhHLV1rgDCWoek886DpWdPlH/+Ocq/+NLr8VGjRiH5zxehvqgY+ff/fZ/nz37uWb0s/Pe/tU+Du6qWuWEpk4g79ljEnXjifgMDaeoX0bv3AY/ftFeuDxEREREF4YxFWwmWGQtrvQM/rNmFw7sl6TKn1XnlSIm1IDnGgoCfabBatVSqvawM5d98g/qCXajfVaAdoKV6UeaTT+jAvvi112CvrIQhIgJh4RaERVgQM368zh5Yc3O1epIhMgJhersrYVkG9/L8crt0h5Zmb9qy3OFARL9+egx169frciWZkZDjICIiIqKW6bAzFqFAelD8tqkIHy/egdIaG+IjzbrsSao9BQpZmiTLj9x9FqoX/oH6wt2wFxVp8BAxYAA6XXG5LieqXbkKptQURA4dClNKql7XQCAsDEkXXnjA7xGena3b/kiQYenR44CPlaVNRERERNS+Wh1YzJo1Cx999BGmTJmCk08+WffNmTNHS8Jec801bXGMIUMqPL02dwtyi6txWJdEnHZYFtLi/bPkSfINwiIjdWahYs4cWDduRP3uQtTL0qXKSiRdeAGix4zRfbVrVmvug6VPX0SPS4a5ISCQpOX0++71y/ETERERURAFFjt27MCpp56KO++8E//973+xbNky3H333diyZQsWLFjQdkcZApWeLCYjwk0GRIYbccdx/dAzZU9nc19x90qQZOjKH3+ELT/ftWypIF+7PWfMfFiDg/q8PNhLy2DOSEfEoIEwdeoMS0/XjEH06FG6EREREVFoa1Vg8dtvv2HSpEm49dZb9esbb7wRTz75pK7DokMrrKzDx4t2YEtRFe47cQAyEyJx27S+zXrrtGmaVDAKC9PqR/XFJXDW1mhCtKO2RpcMSZM2SWYu/+47OBv2y4yEMSYWKTfdqPkI5V9+paVSZalSdK/xMDdq3pd4zjn8OImIiIjId4FFt27dsHXrVs/Xjz76KM4991wUFRUho6FEJ+2rsq4eXyzbiVmrdyHGYsKJg1KB+nrAGK6lUmXGwFEjJVZr4aiuQZglHNGHH65BROFzz8FRWaXLkRxVVRogpD/wD01qLv/6a1QvWOj6JlKC1WJB3PHHaWDhdDj1vgZLBMxxsQiLiPSUUZWgJOORmSyhSkRERET+CSwOO+wwDBkyBF9//TWmTZumA9NXX30VJ5xwAiIigq8canuQ5UcPPPUZ8osqMMGWj3G122GZbUPNGadro7a6Nau1EZtHWJguO5LAwtVXwQxzehoM0dEwRMfAEBuj/R1EwhlnIOG001xVlCwWr0DB0r0bUv7ylwMeF/syEBEREVG7lpuV/ImuXbsiWAVCudkV3/6M+PIixMe4SqlKuVVp3ibLj2RWQcq0uvdrgCCN4IiIiIiIOlK52Q8++AArVqzASy+9BJNp34dLZ2yjdC6mAxo49YgD3iZN2mQjIiIiIgomzT4VfvbZZ2PhwoU48cQTUVVV5dm/a9cu/OUvf9GqUEREREREFFqaHVhkZWXhl19+QXV1NY4++mhs2LABf/vb39C9e3fNtZg8ebJvjpSIiIiIiDpW8nZCQgI+/fRTDBs2DL169dKg4plnnsF5553HZVBERERERCGo2TMWNpsNzz//PAYOHKhLoSZOnKj7x4wZw6CCiIiIiChENTuweOqpp3Dbbbfh8ssvx8aNG/H9999j+vTpGDt2LH7//XffHCUREREREXWspVBTpkzBRRddhKSkJM++J554ApmZmdqF+5NPPmGeBRERERFRiGl2YDFo0KD97r/llls0uPjhhx8YWBARERERhZhWdd7e27nnnutVgpaIiIiIiEJDmwYWIjo6GoHM3WhcuggSEREREdGBucfM7jF0uwYWga6iokIvs7Oz/X0oRERERERBM4aOj48/6H3CnE0JPzoQh8OBnTt3IjY2FmFhYX6J+iSoyc3NRVxcXLt/f2o5fnbBi59d8OJnF7z42QUvfnbBqdxHY0wJFSSoyMjIgMFw8IKyITdjIW+IdA/3N/nAGVgEJ352wYufXfDiZxe8+NkFL352wSnOB2PMQ81UtLiPBRERERER0d4YWBARERERUasxsGhnFosF99xzj15ScOFnF7z42QUvfnbBi59d8OJnF5wsATDGDLnkbSIiIiIianucsSAiIiIiolZjYEFERERERK3GwIKIiIiIiFqNgQUREREREbUaAwsiIiIiImo1BhZERERERNRqDCyIiIiIiKjVGFgQEREREVGrMbAgIiIiIqJWY2BBREREREStxsCCiIiIiIhajYEFERERERG1mgkhxuFwYOfOnYiNjUVYWJi/D4eIiIiIKGA5nU5UVFQgIyMDBsPB5yRCLrCQoCI7O9vfh0FEREREFDRyc3ORlZV10PuEXGAhMxXuNycuLs7fh0NEREREFLDKy8v1pLx7DH0wIRdYuJc/SVDBwIKIiIiI6NCakkLA5G0iIiIiImo1BhZERERERNRqDCyIiIiIiKjVQi7HgoiIiIhob3a7HTabLeTeGLPZDKPRGHqBRX5+Pp5++mnMnTsXJpMJ48ePx4wZM5qUpU5EREREtL8+DTLGLC0tDdk3JyEhAWlpaa3u8RbmlHczSKLIXr164ZJLLsGYMWNQXV2Nu+66CxEREfj555812mpqyaz4+HiUlZWxKhQRERFRiMvLy9OgIiUlBVFRUSHVQNnpdOqYeteuXRpcpKent2rsHDQzFjJFs2rVKg0k3Lp164aBAwdi/vz5GDdunF+Pj4iIiIiCi5y4dgcVycnJCEWRkZF6KcGFvA+tWRYVNIGFaBxUCIvFopf19fUIlqiw3upo1mNM4YaQipyJiIiI2os7p0JmKkJZVMPrl/cjZAKLvd13333aWnzUqFEHvE9dXZ1ujadz/EWCihf+8mOzHpPeIx6n3HwYgwsiIiIiHwn1k7hhbfT6g7bc7MyZM/H+++/jrbfe2mcmo7EHH3xQ14W5N2lJHkzyNpY1e5aDiIiIiKi9BeWMxVNPPYW//e1v+Oijj3DkkUce9L533HEHbrzxRq8ZC38FF7Ks6fInj2rSfW11drxy6y8+PyYiIiIiopAMLKTc7C233IIPP/wQxx133CHvL3kY7lyMQJhmMlvapk4wEREREVEgCaqlUM8++yxuuukmDSqOP/54fx8OEREREZFfPPfcc/jss8+89slqnpdeeslvn0jQBBYlJSW45pprNJ/izjvvxNChQz3bxx9/7O/DIyIiIiJqN//6179QUFDgte+FF17A6tWr4S9BsxRKGnIsWrRov7fl5OS0+/EQERERUccj7QFqbPZ2/76RZmOTqzNJs7otW7boCfbGFi9ejPPOOw/+EjSBhdTU3fvNIyIiIiJqSxJU9L/7m3Z/U1fdfwyiwps2NF+6dClMJpM2inbbsWOHNrkbMmSIfv3VV1/p/cRVV12l1VF9LWiWQhEREREREbBkyRL06dPHq+WCzFaEh4ejX79++nVNTY12FZcWDZJS0B6CZsaCiIiIiKg9liTJ7IE/vm9TLVu2DIMGDfLaJzMU/fv3h9ls1q9PPfVU3T755BO0FwYWREREREQNJM+hqUuS/KW8vFzTBNzmz5+Pl19+Geecc45fjyuw3zXyNMtragO+UG9JT0RERNTRHX/88bjkkkt03Ge1WjWZOyUlxZNf4S8MLIJAUztwp/eIxyk3H8bggoiIiKgDu/DCC9GzZ08sX74cffv2xVFHHYVnnnkGxx57rF+Pi4FFgJLZBwkU8jaWNfkxct96q4PdvYmIiIg6uHHjxunmJv3eGvvtt98wZ84cFBcXa5PpYcOG4eyzz/bpMTGwCFAytSWzDxIoNGWpVFNnNYiIiIio46urq9OqUBdffLF+XVVV5fPvycAiwIMLs6XpFQKIiIiIiIQsj5KtPbGPBRERERERtRoDCyIiIiIiajUGFkRERERE1GoMLIiIiIiIqNUYWBARERERUauxKlSIdukW7NRNRERERG2FgUUH05x+FuzUTURERERthUuhOlCX7uZyd+omIiIiImotzliEWJduwU7dRERERNTWGFh0EOzSTURERBQ6Fi1ahKioKPTt29ezb+3ataioqMCIESP8ckxcCkVEREREFGQuuugifPnll1777rrrLrzwwgt+OybOWBARERERNXA6nX7JQTWFG3QFSlNYrVasWbMGQ4cO9dq/ePFi3HDDDfAXBhZERERERA0kqHjhLz+2+/tx+ZNHwWwxNum+K1euhM1m8wosysvLsWnTJq991dXVyMvLQ9euXWE0Nu25W4NLoUKcJHI3ZZPonYiIiIj8b8mSJcjJyUFSUpLXPjF48GC9nDlzJrKzszFp0iT07NlTZzh8jTMWIa6pfS/Y84KIiIhCgSxJktkDf3zfplq2bBmGDBnite/HH39E9+7dERsb69m3c+dOWCwWzJgxA88//zwef/xx+BIDixDueyF9LJrb86KpU3REREREwSgYKm1u27YNKSkpnq9LSkrw4osvYuTIkZ59t9xyi+e6w+HAoEGDfH5cDCxCUHP6XrDnBREREVFgGTBgAJ599lkceeSRmsj9yiuvoLa2dp9kbvGf//wHhYWFuOSSS3x+XAwsQlQwRONEREREtK/bb79d818/+ugj7WPx7rvvajWoCRMmeN3vn//8pyZ0v/HGGzAYfJ9azcCCiIiIiCiIREVF4e9//7vXvvfff9/r6yuvvBJbt27Fgw8+iOXLlyMxMRFdunTx6XExsCAiIiIi6mAWL16Muro6baQnpiRajDsAACWRSURBVE2bhoceesin35OBBTWZ5Fu0dYMXIiIiImp7v//+O9obAwtqMpamJSIiIqIDYYM8alJp2uZwl6YlIiIiotDBGQs6KJamJSIiIqKmYGBBh8TStERERNSRSenWUOZso9fPpVBEREREFJLMZrNeVldXI5RVN7x+9/vRUpyxIJ9gBSkiIiIKdEajEQkJCdi1a5enP0QoVbZ0Op0aVMjrl/dB3o+QCyykLfmWLVvQp08fxMbG+vtwaD9YQYqIiIiCQVpaml66g4tQlJCQ4HkfQiawWLp0KWbOnIlvvvlGg4vZs2fv07qc/F9BSqpCNbeClNnSugiZiIiIqCVkhiI9PR0pKSmw2Wwh9yaazeZWz1QEZWCxYMECHHPMMbjvvvvQs2dPfx8O7YUVpIiIiChYyeC6rQbYoSqoAotLL71UL7dv3+7vQ6EDYAUpIiIiotDEqlBERERERBRaMxYtUVdXp5tbeXm5X4+H9sUKUkRERETBr8MHFg8++KDmZFDgYgUpIiIiouDX4ZdC3XHHHSgrK/Nsubm5/j4kalRBqjncFaSIiIiIKPB0+BkLi8WiGwUWVpAiIiIi6liCKrAoKirC5s2bPQ1M1q5di5iYGGRkZOhGwYUVpIiIiIg6jqAKLObNm4d7771Xrw8fPhwvvviibpdffrlu1PEx0ZuIiIgoMIU5nU4nQohUhYqPj9d8i7i4OH8fDjUxmHjhLz82672S/I1Tbj5MZ0WIiIiIyPdj5w6fvE3Bj4neRERERIEvqJZCUWhiojcRERFR4GNgQUGBid5EREREgY2BBXVYTPQmIiIiaj8MLKjDYkdvIiIiovbD5G3qUJjoTUREROQfnLGgDqWlid5cNkVERETUOgwsqMNpSaI3l00RERERtQ6XQlHI4rIpIiIiorbDGQsKWeyPQURERNR2GFhQSGvJsinmYxARERHti4EFUTMxH4OIiIhoX8yxIGoC5mMQERERHRxnLIiagGVsiYiIiA6OgQVRE7GMLREREdGBcSkUURvjsikiIiIKRZyxIGpjXDZFREREoYiBBZEPcNkUERERhRoGFkT+/AcYbkB6j3jkbSxr8mPkvjUVtib135DnlyCHiIiIyNfCnE6nEyGkvLwc8fHxKCsrQ1xcnL8PhwjyT7De6mhSY76m9tBw65Qdg1NuOqzJwQUDESIiImrp2JkzFkRBsmyqJbMbhbmVeHHGT02+vzz/KTc3PRAhIiIicmNgQdQBk8JlFuTjRxdpYNEcXGZFRERELcWlUEQhvsSqPZZZcYkVERFRcOJSKCJqVmUqXy+z4hIrIiKijo9LoYjI58usuMSKiIio4+NSKCIKqEpWnN0gIiIKHFwKRURBW8mKsxtERETBiTMWRORTnN0gIiIKXu0+YzFv3jwMHToUkZGRbfF0RNSBBMrsRnOwihUREZGfZizmz5+Pt956C08++aR+LRHNe++9h8suuwyBhp23iUJzdqM5WEqXiIjITzMWhx9+uAYS33zzDUaMGIGTTjoJd911V1s8NRGFEF/ObjRHc0rpMgghIiJq5YzFypUrsWrVKgwYMAC9evWC3W7H9OnTUVFRgQceeACTJk1CIOKMBVHoNQBsznO2pGN5UzUnCGkOLt0iIqKgn7GYM2eOLn9as2YN0tLSYDQa0a9fP1gsFlRXVyMqKqo1T09E1CYNAJvjzL+O9Fk/j+bMhPgyYGEgQkREAZtjIU+xefNmLF261LP1799fZy4CDWcsiKi9Z018PRPSXFy+RUREvhg7NzuwKC4u1upPwVoBioEFEflDMC7dEly+RUQU2sp9GVg88sgjuP3229G7d28MGTJEy8y6L2U5VKBjYEFEoRqwBNLMCQMWIqLg4NPAorKyEn/88QcWL17s2VasWKF/sFJSUnD33Xfjmmuuga/s2LEDr7/+OgoKCjBo0CCcf/75CA8Pb/LjGVgQUSgL1uVb/g5YmoM5LETUkfg0sNifvLw83Hbbbdi2bRvuvPNOTJkyBb4gSeJjx47F+PHjMWrUKLzxxhsazPzwww8wmZqWh87AgoioYy/f8jfOxhBRR9LugYWQp5kwYQJeeOEF9OnTB74g/THkxUkgIWejdu7ciW7duuH555/HRRdd1KTnYGBBRORfDFiCdzYm2GZvmvuz5u/jJQq5wELufqB/dPfee68mdcvsRVuz2WyIiYnBU089hcsvv9yzf9q0aVrW9qOPPmrS8zCwICLqmHwRsDT3+3f02ZhgCoZa8nn44njlOGps9ibfP9JsDLrgpqMGZL78nWIKovfMp30sHn/8cfz73//GsGHDNGFbtsGDB+vg/qeffsLEiRPhC1u3boXVatUZisbk619//fWAj6urq9Ot8ZvT+FKYzWYNiGpqajSAcZN+HLJVVVVpA0C3iIgIzeuQfBOHY88PnLwHsiSr8XOL6OhoGAwGbR7YWGxsrD5enr8x+dDq6+u1F4ibPF4CK3kPamtrPfuld4g8/96vk6+JnxN/9vjvib8j2vt3eTWmXdvHMxBpq9/lcpzvPjQXBdv2dJo3Gc0wG8NRZ6uBw7nn2GWf3Lb3/nBTBIwGI2qs3n9vLKYIhIUZUGvbc4z63pij4HQ6UFe/5xhFZHg07A47rI32G8IMsJgjUW+3wWa3eu0vzAWeue57vc3zWg0mhJsssNbXwe6oD6jXlLuxCv939VcHfU2yX/YFy2tqyufU2teUnBmNM24Zrf/OOsrYSIKKb55ZjdL8Op98Tqnd4vCnu47U7xfo471mzUE4m2nr1q3O559/3nn11Vc7x44d64yJiZHvpltycrJz/fr1Tl9YtmyZfo958+Z57b/11ludPXr0OODj7rnnHs/xHWi75JJL9L5y2Xi/PFZMnTrVa/+LL76o+/v37++1/+uvv9b9sbGxXvtXrFjhLCsr2+f7yj65rfE+eayQ52q8X76XkO/deL8c2/5eJ18TPyf+7PHfE39HdJzf5RdffLHX/rvu/JvTWlvvnDJ5itf+5555Xvf36+f9mj7/7Avdv/drWrxoqbNwV/E+r0n2yW17vyZ5Dnmuxvvle8l++d6N9w/uOcr57ytmOY8dfoHX/jF9j9X9ctl4v9xP9vfNGuG1/9wjb9T9aYldvPZffdxDuj/CHOW1/84zXnbO/POnzXpNn33q/Zrke8lzy/duvF+OLZBek+yT2xrvk8fKc8hz8TUF9udUV2MLivFebm6u53fdobQ6x0IevmnTJuzevVub4h1qiqQ1MxZdu3bFV199pcuf3GRZ1MKFC7Fo0aImz1hkZ2cjNzfXc6w8u8+z+8Fw9kRwtoyfE3/2+O8pWH5HyH45E+7v33vuJSeHek2y3z3bdLDf5WFmC4bf+xWcjc7uw2CEwWyBw1YHOPYce5jRjDCTGT0TTXj+T7LE6sCvqdZmx7FPz0eYwQhHnfcZb/meCDPAaa3x2n9Yj3S8fvFIr8+jPf8+yff47KklKNpR1eFmYfQ9MIajKNyIt8JLZcDr9Xk053MKC48EnA44bXUwOYHLKiJ0/2VPTkV0pDHgxxFy34SEhPZN3vY1efHyoiSP48Ybb/TslwpRshxKKkQ1BXMsiIiIQkNz8xuaotpqx4h/fK/XF941GVHhxjbJm5BjPeO5eVi4taRZx7Pq/mMQFd7sle0dJrepucd63ku/Y0luaZMfI0P1hX9r2ufcFFV19Rj7j1l6fcn9UxFtMSOkcyz8RSK4M888E6+88gquvPJKjaykn8bcuXNxxx13+PvwiIiIKMAGkac/Nw9/NHOg3hwy2GyrQb0EHu9fOaZJgVDj4Eau+zMpXJ7TbGmbQbevA8hqmx0LtpcCzXgbRnRJRHJ0eJu9d5FmI5b+/RjP9Y4maAIL8eCDD+Loo4/WxHHp9v3dd9/hsssuw/HHH+/vQyMiIqIAIgNNXwYVMuBs64GhDF6bG6i4A4xD3q9LogYuwVKJyNcBZFvONvn6Mw4mQfXKOnfurLkU33//vXbelrK2w4cP9/dhERERUQBr6iCyOfxZFla+twQKzVk2JfctqrK2+fvg7/eiJQFkW89CUJAGFkISTo477jh/HwYREREF8rKXRkuE2nLJUiBo6bKpps5uNFf/9LiG2RC0u8afs79mIWiPJv0rkwpKGzdubMpdteJSjx49mnRfIiIiokDKmwgWTV1S05LZjeZalVeOAfd8A3/raAFkMGrSu//uu+/illtuadIT3nTTTXjkkUdae1xEREQ+EwjdkH1Rsailmvr6/P2+tXTZS0dMkvXF7EZzSV1RqWQlgYW/hfrnHCiaVG5W7tK4Bu6hqjfJFqhYbpaIKLS15Kx3c5Z6NLW0aCCdeW/K62vJILKtl8j4qtQrBX+AzM85MMbOQdPHoq0wsCAiCh6+7kPgC00ZTPv6GEKBv/s3EIWKcl/3sZBulg899BA+++wzbN++Henp6Zg8eTL+9re/oVOnTi09biIionY9q3+os94tOUvf3PXmvqhY1FS+moXw9RIZLnshCkzNnrGQ9u2HH344SkpKcOGFF2qydn5+Pt566y1tMb506VJtRR6oOGNBRBQ8VX18eVa/qXX9m3q8LRlMB0JvAV/lTfhyiQyXvRB1kBmLr776Sr+BBBCNn/zmm2/G+PHj8fbbb2vTOiIiovZuZuWLwWlzGlp9cf14vyeFB0rDro7eCIyI9tXsf/GbN2/GxIkT94lYLBYLjj32WL2diIgoFJtZcTBNRKGs2YFFZmYmXnrpJVitVm1W5+ZwOPDTTz/hzDPPbOtjJCKiDti0jFV9iIhCPMeitrYWgwYNQlJSEi655BINNAoKCvD6669jzZo1WLlyJZKTkxGomGNBRBQYy5tY1YeIKMRzLCIiInRm4s4779StsLAQiYmJmDJlCv7zn/8EdFBBRBTqtd59kXwrsxBsWkZERM0OLPLy8mCz2TSIEFIJSvIriIjak787ADdHqDRDE1zeREQUupodWLz77rvau+KRRx7RrxlUEFFH65zc1lpyRt+XmttnoSMmWRMRUQAEFjk5OZgzZ44PDoWIyHeVhXw1mG6ujtgMLZBKpxIRURAFFtOnT8e//vUvPPHEEzjvvPPQuXNn3xwZEZGfOif7SiCc0Q/GPgtERNRBA4snn3wS8+fP1+2GG27Y5/abbrrJs0yKiMjXJKg4VBOu5g6mfSUQBunss0BERAETWEifiqFDhx7w9i5durT2mIiI2hQH00RERAEYWERHR2PgwIFIS0vb57aioiKtGEVE1F5N1oiIiChIA4tXXnkF+fn5+13udLDbiIiCqSQrERERNY8BbaiiogIxMTFt+ZREFCJaUulJkqElb4GIiIiCaMZi1qxZ+Pjjj7FkyRJUVVXh2muv9bpd9v3vf//Da6+95ovjJKIQWt7EJmtEREQdOLCorKzUxnilpaXabVuuNxYXF4eZM2dqOVoiotYsb2pKpSciIiIKLE3+y33SSSfp9u2336KsrAxnnHGGb4+MiIIelzcRERGFjmafEpw6dapvjoSIOjQubyIiIurYWpS8/dlnn+Goo45CTk6Olp1tvN1///1tf5REFPTcy5sOtfm7gRwRERG104zFqlWrcPrpp+Pyyy/HRRddBLPZ7HV7//79W3goRBQs2G+CiIiIWh1Y/PLLL5pr8dRTTzX3oUTUTgN6NynF2tQZgKY+t9MJnPHcPKzKK2/ycRAREVHH1+zAIjk5mb0qiNqQLwf0/dPj8P6VY3Co2MLXwQL7TRAREXV8YU4Z1TRDcXExxo0bh48++gj9+vVDsCkvL0d8fLxWtpISuUT+FMzdppsatDR35oSIiIiCc+zc7BmL7777TpvhDRkyBIMGDUJsbKzX7WeddRauuuqq5h81UQhqSTnWpgzoWzoDwWCBiIiIWqrZgUVWVhYuuOCCA97erVu3Fh8MUShr63KsX1w/vln5GM15biIiIqJWBxayDEo2Imrbqklt3W1aAgR2ryYiIqL20uJRzI4dOzBr1ixs374d6enp2teie/fubXt0REEomPMmiIiIiNo1sHjmmWdw8803aw+LjIwMFBQUoLKyEnfddRfuvvvuFh8MUajmTbBqEhEREYVcYLFu3TrccMMNePbZZ3HhhRfCaDTqGdpPPvkE5513HiZNmsSlUkQ+ypsgIiIi6jCBxezZs3HyySfj4osv9uyTAdEpp5yCyy67DN9//z0DC+qQAiFvgoiIiChQmVoyuPLXmVWpn/vGG2/gueeew5o1azTHQ3I7iHyNeRNEREREB2dAM02cOFGXPb355ptwOBye/Z9++ileeuklTJ48Gb4yc+ZMrF69Go888gjsdrsO9ojaA/MmiIiIiNp4xqJ379549NFHcfnll+Paa6/VilC7du1CRUUF7rzzTp8ug/rHP/6hl1KJishfmDdBREREtK8WLf6+5pprNM9C8inc5WYnTJjAcrMUEpg3QURERLSvFmeVZmZmalWoQFdXV6ebW3l5uV+Ph4I/IZuIiIiI2ih5+9RTT8Xtt9+OUaNGefavX78eV199Nb788kvtb9EUl1xyCV577bWD3mft2rXo0aNHiz+7Bx98EPfdd1+LH08dFxOyiYiIiPyYvC3Ln6qrq72CCtGrVy9dEvX+++83+blefPFF1NbWHnRrTVAh7rjjDq0m5d5yc3Nb9XzUcTAhm4iIiMiPMxYyg9ClS5f93ib7pWpTUxkMBt18yWKx6EZ0MEzIJiIiImqdZo/qu3fvrk3yZDahMSn/+s033xww6CAKhoTsQ23sjk1ERETURoHF1KlTNYdC+lV8+OGHWLhwofawOO6447Bjxw6ceeaZ8JXXX38dJpMJXbt21a8nTZqkX99///0++54UnLkT1db6JmxMyCYiIiLy21IoGcjLzMQVV1yhQYQ0yZOzuEcccYR2wo6Li4OvnH/++Tj33HP32e/r5VQUPJiQTURERBRE5Wazs7O1+pM0xZPmeMnJyUhISICvSQAjgQ3RgTAhm4iIiMg/WjVKj42N1Y0oEDEhm4iIiKj98PQ/dVjskE1ERETUfpicQERERERErcYZCwqapGzJnzgUVnoiIiIi8g8GFhTwWOmJiIiIKPBxKRQFPFZ6IiIiIgp8nLGgoMJKT0RERESBiYEFBRVWeiIiIiIKTFwKRURERERErcbAgoiIiIiIWo1LochvWEKWiIiIqONgYEF+wRKyRERERB0Ll0KRX7CELBEREVHHwhkL8juWkCUiIiIKfgwsyO9YQpaIiIgo+HEpFBERERERtRpnLKhNsdITERERUWhiYEFthpWeiIiIiEIXl0JRm2GlJyIiIqLQxRkL8glWeiIiIiIKLQwsyCdY6YmIiIgotHApFBERERERtRoDCyIiIiIiajUGFkRERERE1GoMLIiIiIiIqNUYWBARERERUasxsCAiIiIiolZjYEFERERERK3GPhZ0SE6nU7tqH0q19dD3ISIiIqKOiYEFHTKoOP25efhjawnfKSIiIiI6IC6FooOSmYrmBhUjuiQi0mzkO0tEREQUQjhjQU228K7JiAo/dMAgQUVYWBjfWSIiIqIQwsAiRLUkb0KCiqhw/sgQERER0b44SgxBzJsgIiIiorbGHIsQxLwJIiIiIkKoz1jk5+djwYIFMJlMGD58OFJSUvx9SEGNeRNEREREFFKBhSzfufjiizFr1iwMHToU1dXVmDdvHh555BFcddVV/j68oMW8CSIiIiIKucDiqKOOwosvvqizFeLll1/GFVdcgWnTpqFbt27+PkQiIiIiopAVNDkWBoMBF110kSeoENOnT4fdbsfq1av9emxERERERKEuaGYs9ufrr7/WgGPgwIEHvE9dXZ1ubuXl5e10dEREREREocOvgcUvv/yCDRs2HPQ+p512GmJjY/fZL4+74YYbcP311yMnJ+eAj3/wwQdx3333tcnxEhERERFRAAYWa9as0eDiYI477rh9Aott27Zh8uTJmDBhAmbOnHnQx99xxx248cYbvWYssrOzW3nkREREREQUMIHFpZdeqltz5ObmakAxbNgwvPPOO145F/tjsVh06+ia2kl7727aREREREQhl2Oxfft2DSqGDBmC9957D2az2d+HFBDYSZuIiIiI/C1oAova2lpMnDgRlZWVujzqrbfe8tw2btw49OrVC6GqJZ20xYguiYg0G31yTEREREQUWoImsKivr8fYsWP1+q+//up1W/fu3UM6sGhJJ20hQUVYWJjPj4mIiIiIOr6gCSxiYmLw6quv+vswAh47aRMRERGRPwRNgzwiIiIiIgpcDCyIiIiIiKjVGFgQEREREVGrMbAgIiIiIqJWY2BBREREREStxsCCiIiIiIhajYEFERERERG1GgMLIiIiIiJqNQYWRERERETUagwsiIiIiIio1RhYEBERERFRqzGwICIiIiKiVjO1/inIV5xOJ2ps9kPer9p66PsQEREREfkSA4sADipOf24e/tha4u9DISIiIiI6JC6FClAyU9HcoGJEl0REmo0+OyYiIiIiogPhjEUQWHjXZESFHzpgkKAiLCysXY6JiIiIiKgxBhZBQIKKqHB+VEREREQUuLgUioiIiIiIWo2BBRERERERtRoDCyIiIiIiajUGFkRERERE1GoMLIiIiIiIqNUYWBARERERUasxsCAiIiIiolZjYEFERERERK3GwIKIiIiIiFqNgQUREREREbUaAwsiIiIiImo1BhZERERERNRqDCyIiIiIiKjVGFgQEREREVGrMbAgIiIiIqJWY2BBREREREStZmr9U1BTOZ1O1NjsTbpvtbVp9yMiIiIiCgQMLNqRBBX97/6mPb8lEREREVG74FKoADeiSyIizUZ/HwYRERERUceZsbDb7XjrrbfwzTffoLKyEgMGDMDVV1+NrKwsBAMJEFbdf0yzHxMWFuazYyIiIiIiCrnA4sILL0RMTAxOPvlkmEwmvPTSSxg+fDgWLVqEzMxMBDoJEKLCg+otJyIiIiJqkjCnZBQHiYqKCsTGxnq+rqur00DjxRdfxEUXXdSk5ygvL0d8fDzKysoQFxfnw6MlIiIiIgpuzRk7B1WOReOgQshMhSyP6t+/v9+OiYiIiIiIgmwplJg/fz5uvfVWjZ62bduGDz/8EIcffvgB7y+zGrK5yeOIiIiIiKgDLYV66KGH8PXXXx/0PpKs3Th/ori4GMuWLUNhYSFefvllrFu3Dj/99NMBcyzuvfde3Hffffvs51IoIiIiIqK2Wwrl18BizZo1yM/PP+h9Ro0ahcjIyP3eVl9fj969e+O0007DzJkzmzxjkZ2dzcCCiIiIiKgNAwu/LoXq27evbi0llaHS09NRUFBwwPtYLBbdiIiIiIjId4Imebu2thZPP/20Jmu7ffvtt1iwYAGmTp3q12MjIiIiIgp1QZO8bTabsXnzZmRkZKBLly4oLS3F7t27NYfivPPOa/LzuFd+MYmbiIiIiOjg3GPmpmRPBFUfC1FdXY3Vq1cjOjoa3bp1a/Yyp+3bt2uOBRERERERNU1ubi6ysrI6VmDRWg6HAzt37tSeGNIJu725k8flw2GDvuDCzy548bMLXvzsghc/u+DFzy44lftojCmhgjSpllVDBoOhYyyFaivyhhwq2moP8oEzsAhO/OyCFz+74MXPLnjxswte/OyCU5wPxphSFapDJW8TEREREVHgYmBBREREREStxsCinUmy+T333MPeGkGIn13w4mcXvPjZBS9+dsGLn11wsgTAGDPkkreJiIiIiKjtccaCiIiIiIhajYEFERERERG1GgMLIiIiIiJqtZDrY+FvmzdvRnFxMfr27avdwyl4rF27Frt378b48eP9fSjUDNLUZ8OGDdrYJzU1le9dkH1269evR0pKSkD0H6LmmzdvHsLDwzF8+HC+fQFOmgdv2rTJa580Eh43bpzfjomax263Y/Xq1YiKikL37t3hDwws2rEb4mmnnYbffvtNBzjyD/iZZ57B+eef316HQC304Ycf4rHHHtN/rCUlJbDZbDCZ+E8n0MkfyFtvvRWzZs1C165dsXHjRv0D+cYbb6BTp07+Pjw6CAngb775ZnzxxRfo0qWLfpa9evXCO++847c/ltR88jfuuuuuQ7du3TS4p8D23nvv4c4778SwYcM8++Rv3Zw5c/x6XNQ0H330Ea655hoNKmRLS0vD22+/3e5/77gUqp3cdNNN2mJ927Zteub78ccfx8UXX4x169a11yFQC61atQr/+te/9I8kBQ8JJM455xydIVy8eDG2bNmCHTt24Oqrr/b3odEhbN++HSeddJIGGH/88YeeiJGz3vzsgseyZcvw4IMP4qKLLvL3oVAzSBD4yy+/eDYGFcHhp59+whlnnIEHHnhA//YtX75cg8SCgoJ2PxYGFu2grq4O//3vf/XMTWJiou675JJLdHr/9ddfb49DoFb429/+xuVPQWjKlCk6SyhT+SIpKQlnnXWW/rGkwCZnTE899VTPZxcZGYlRo0ZpYEiBr7q6GmeffTaeeuoppKen+/twqJlLaSQolBl6mZ2n4HDvvfdi8uTJesLabcKECRgwYEC7HwsDi3YgMxTyi7bxGlP5gzlixAg9k0pE7WPBggXo2bMn3+4gIb8f5Yzpv//9b13CJo2fKPDJSTTJRTv55JP9fSjUgvGKBIXHHHMMOnfujBdffJHvYRCcvP7ll18wffp0zUuTWd68vDy/HQ8XircDWYohkpOTvfbL13JWgIh8T9bnf/rpp/j666/5dgcJWTIqvyNlyeikSZNwxBFH+PuQqAn/zmSQs2jRIr5XQWbw4MH6b8198kWCiiuuuAI9evTAxIkT/X14dACFhYU6uyQzTX369NHcCslpGjNmjK6W2Xvs6WucsWgHZrNZL2tra73219TU6LphIvKtb7/9Vtd6P/roo5g6dSrf7iAhS0VllkmWQMms7wknnODvQ6KDKC0t1YHoVVddpbNNEmBIbqH87ZPr7pNsFJgkeGg8o3vZZZfhsMMOw7vvvuvX46KmjTG/++47LFmyRIN6qUAqmxTBaG8MLNqBVDURe68Plq9zcnLa4xCIQpb8spUlGf/4xz9www03+PtwqAViYmJ0sLpw4UI9O0eBSQKIQYMG4YMPPsDtt9+u2+zZs1FUVKTXV65c6e9DpGaSEt3MbQpsnTp10vYFkpcmubtCZikkmfvnn39u9+NhYNEOpP669K2QZRhuu3bt0vrekmBKRL4hpWalupAktvnjzA21TFVV1T77ZGrfYrFokEGBSZZgNK4oJNsFF1yAzMxMvc6lbMH1766srAzz58/HwIED/XZMdGgGg0HHknsHgFJdT/Jk2htzLNqJlN07/fTTtYeF/CN9+OGHNVtfymFSYJMBTX5+via1iV9//RVGo1HPzMXHx/v78OgApGfMiSeeiOOOOw5jx471qgbFJoeBTWaX5Cy3VDmRf2PyWcrvTDnrHRER4e/DI+qQ5Hel5DJJYRlZ1iZLR6UfwowZM/x9aHQI999/v/ZpkgIXcvn7779rfoX0JmlvYU6n09nu3zWEl2RIMpSsM5V/uLfddpun/CwFLulh8dlnn+2z/4knntDPkQLTW2+9hWeffXa/t7HkbGCTP0uSBCz/7uT3pSwnPffcc3HUUUf5+9ComeRvnswcyudJgd/I9+mnn8bcuXN1dlAqWV577bWIjY3196FRE6xYsUILXmzdulWX2V966aV6Uq29MbAgIiIiIqJWY44FERERERG1GgMLIiIiIiJqNQYWRERERETUagwsiIiIiIio1RhYEBERERFRqzGwICIiIiKiVmNgQURERERErcbAgoiIfGrz5s349NNP+S4TEXVwDCyIiKjNbNq0aZ9O9T/++COuvvpqvstERB0cAwsiImozP/zwA6677jqvfd26dcNJJ53Ed5mIqIMz+fsAiIioY9ixYwcWLFiAqqoqvPPOO7pvyJAhyMnJwTHHHOO53/r163WbMmUKli1bpo8bMWIEMjIyYLPZMHfuXH2O0aNHIykpaZ/vs3XrVixZsgTJyck47LDDEBUV1a6vk4iI9o+BBRERtYm8vDwsXrwY1dXV+OSTT3SfDPqLi4tx11134cQTT9R933zzDf7xj3+gU6dOSE1NRWVlpQYY//73v/HYY49pgFFSUoJt27bh119/Ra9evfRxTqcTM2bMwJtvvqlBR2FhoX7PDz/8ECNHjuSnSETkZwwsiIioTcisw+WXX65Bg3vGQrz66qv73LegoADPPfccTj75ZP16+vTpuPTSS/HVV19h2rRpuu/oo4/G448/jmeeeUa/fumll/DFF19g3bp1OlshHnjgAVxwwQVYvXo1P0UiIj9jYEFERO0uJSXFE1QImYGQWQt3UOHeJ0ur3F555RUMHjwYs2fP1tkL2WJiYrBmzRqduUhPT2/310FERHswsCAionaXmJjo9bXFYtnvvtraWs/XW7ZsgdVqxQcffOB1v7POOkv3ExGRfzGwICKioBAXF4eJEyfi4Ycf9vehEBHRfrDcLBERtRlZmtR4lqEtyTKpt956CxUVFV77paoUERH5H2csiIiozUj51927d2sCd8+ePbXcbFu5++67MWvWLK0Addlll2nFqd9//12b8v30009t9n2IiKhlGFgQEVGb6d27N7788kt8+umnWLlypQ7+926QJ/c5/vjjvR7Xt29fr8RtMXDgQK+vpafF/PnztdysBBQRERGYPHkyzj77bH6CREQBIMwpZTWIiIiIiIhagTkWRERERETUagwsiIiIiIio1RhYEBERERFRqzGwICIiIiKiVmNgQURERERErcbAgoiIiIiIWo2BBRERERERtRoDCyIiIiIiajUGFkRERERE1GoMLIiIiIiIqNUYWBARERERUasxsCAiIiIiIrTW/wNt98ihYbxOMwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "enkf_config = EnKFConfig(n_particles=500, record_filtered_states_mean=True)\n", + "\n", + "result_enkf_controlled = run_2d(k=1.0, key=key_2d, filter_config=enkf_config)\n", + "result_enkf_uncontrolled = run_2d(k=0.0, key=key_2d, filter_config=enkf_config)\n", + "\n", + "plot_2d_runs(\n", + " [\n", + " (result_enkf_uncontrolled, \"no control\", \"tab:red\"),\n", + " (result_enkf_controlled, \"controlled (K=1.0)\", \"tab:blue\"),\n", + " ],\n", + " result_enkf_controlled,\n", + " \"Same black-box SDE + partial observation, ensemble Kalman filter (EnKFConfig)\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "c2d17df1", + "metadata": {}, + "source": [ + "## 6. A sampling-based alternative: MPPI\n", + "\n", + "All the policies so far have been deterministic linear feedback (`u = -K x_hat`). `dynestyx.control.MPPI` is a different kind of policy entirely -- Model Predictive Path Integral control: at every step, sample many candidate control sequences, roll each one forward, score them with a cost function, and take the softmax-weighted average as the actual control (only the first step of that average is applied; the rest becomes next step's warm-started plan). It plugs into the exact same `control_policy=` slot as `LinearPolicy` above -- `DiscreteControlLoopSimulator` doesn't know or care which kind of policy it's driving.\n", + "\n", + "MPPI needs two things `DynamicalModel` doesn't directly provide: a **rollout function** `(x0, u_seq) -> x_seq` for *planning* (deliberately generic -- it doesn't have to use `dynamics.state_evolution` at all; it could wrap an external simulator), and a **loss function** scoring a rolled-out trajectory. Here we build the rollout directly from `dynamics.state_evolution`'s deterministic mean -- a standard MPPI simplification: the real system is stochastic (see the control loop's own `.sample()` calls), but the *planner* only needs a reasonable prediction of where a candidate control sequence leads, not a faithful stochastic simulation." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "0fc2b864", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:24.087616Z", + "iopub.status.busy": "2026-07-31T15:54:24.087560Z", + "iopub.status.idle": "2026-07-31T15:54:24.089359Z", + "shell.execute_reply": "2026-07-31T15:54:24.089192Z" + } + }, + "outputs": [], + "source": [ + "from dynestyx.control import MPPI, mppi_initial_state\n", + "\n", + "\n", + "def make_mppi_rollout(dynamics, dt=1.0):\n", + " def rollout_one(x0, u_seq):\n", + " def step(x, u):\n", + " x_next = dynamics.state_evolution(x, u, 0.0, dt).mean\n", + " return x_next, x_next\n", + "\n", + " _, xs = jax.lax.scan(step, x0, u_seq)\n", + " return xs\n", + "\n", + " return jax.vmap(rollout_one, in_axes=(None, 0))\n", + "\n", + "\n", + "def quadratic_loss(x_seq, u_seq):\n", + " return jnp.sum(x_seq**2) + 0.01 * jnp.sum(u_seq**2)" + ] + }, + { + "cell_type": "markdown", + "id": "f03a6255", + "metadata": {}, + "source": [ + "`horizon` and `n_samples` trade off planning quality against compute; `noise_std` controls how widely candidate sequences are spread around the current plan, and `temperature` controls how sharply the softmax weighting favors low-cost samples. These values are not tuned beyond \"converges reliably\" -- the point here is the mechanism, not competitive performance. `dynamics`, `control_dim`, and `predict_times` are the same ones defined in section 1, and `trace_uncontrolled` (the `K=0` baseline) is reused directly from section 3 for comparison." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "a603e321", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:24.090231Z", + "iopub.status.busy": "2026-07-31T15:54:24.090179Z", + "iopub.status.idle": "2026-07-31T15:54:24.544962Z", + "shell.execute_reply": "2026-07-31T15:54:24.544669Z" + } + }, + "outputs": [], + "source": [ + "horizon = 10\n", + "n_samples = 300\n", + "\n", + "mppi = MPPI(\n", + " dynamics_model=make_mppi_rollout(dynamics),\n", + " loss_fn=quadratic_loss,\n", + " horizon=horizon,\n", + " n_samples=n_samples,\n", + " noise_std=1.0,\n", + " temperature=1.0,\n", + ")\n", + "\n", + "sim_mppi = DiscreteControlLoopSimulator(\n", + " control_policy=mppi,\n", + " policy_state_init=mppi_initial_state(horizon, control_dim),\n", + " filter_config=KFConfig(record_filtered_states_mean=True),\n", + ")\n", + "\n", + "result_mppi = sim_mppi.simulate(dynamics, rng_key=jr.PRNGKey(0), predict_times=predict_times)" + ] + }, + { + "cell_type": "markdown", + "id": "658796bb", + "metadata": {}, + "source": [ + "Same reading as before: observed (dots) and filtered (solid) state, contrasted against the `K=0` no-control baseline from section 3 (same dynamics, same key), plus MPPI's chosen control sequence." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5dbcf7d2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-07-31T15:54:24.546070Z", + "iopub.status.busy": "2026-07-31T15:54:24.546010Z", + "iopub.status.idle": "2026-07-31T15:54:24.603614Z", + "shell.execute_reply": "2026-07-31T15:54:24.603390Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axes = plt.subplots(2, 1, figsize=(8, 7), sharex=True)\n", + "\n", + "runs_mppi = [\n", + " (result_uncontrolled, \"no control (K=0)\", \"tab:red\"),\n", + " (result_mppi, \"MPPI\", \"tab:green\"),\n", + "]\n", + "for result, label, color in runs_mppi:\n", + " t = result.times[0]\n", + " obs = result.observations[0, :, 0]\n", + " filtered_mean = result.filtered_states_mean[0, :, 0]\n", + " axes[0].plot(t, obs, \".\", color=color, alpha=0.4, label=f\"{label} (observed)\")\n", + " axes[0].plot(t, filtered_mean, \"-\", color=color, label=f\"{label} (filtered)\")\n", + "\n", + "axes[0].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + "axes[0].set_ylabel(\"state\")\n", + "axes[0].legend()\n", + "axes[0].set_title(\"MPPI vs. no control\")\n", + "\n", + "t_u = result_mppi.times[0][:-1]\n", + "u = result_mppi.controls[0, :, 0]\n", + "axes[1].step(t_u, u, where=\"post\", color=\"tab:green\")\n", + "axes[1].axhline(0.0, color=\"black\", linewidth=0.8, linestyle=\"--\")\n", + "axes[1].set_ylabel(\"control $u_k$\")\n", + "axes[1].set_xlabel(\"time\")\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "dynestyx", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/dynestyx/control/__init__.py b/dynestyx/control/__init__.py new file mode 100644 index 00000000..0aa071e4 --- /dev/null +++ b/dynestyx/control/__init__.py @@ -0,0 +1,18 @@ +"""Online control loop and control policies for discrete-time dynestyx models.""" + +from dynestyx.control.discrete_controller_simulators import ( + ControlledSimulatedResult, + DiscreteControlLoopSimulator, + PolicyCallable, + filter_state_mean, +) +from dynestyx.control.mppi import MPPI, mppi_initial_state + +__all__ = [ + "ControlledSimulatedResult", + "DiscreteControlLoopSimulator", + "MPPI", + "PolicyCallable", + "filter_state_mean", + "mppi_initial_state", +] diff --git a/dynestyx/control/discrete_controller_simulators.py b/dynestyx/control/discrete_controller_simulators.py new file mode 100644 index 00000000..3ebadffa --- /dev/null +++ b/dynestyx/control/discrete_controller_simulators.py @@ -0,0 +1,301 @@ +"""Closed-loop control simulator: interleaves simulation, observation, filtering, and control. + +Implements the online control loop: + + x_0 ~ p(x_0) + y_0 | x_0 ~ p(y_0 | x_0, t_0) + x_hat_{0|0} = FilterUpdate(y_0, t_0) + u_k, s_{k+1} = control_policy(x_hat_{k|k}, s_k, key_k), k = 0..T-1 + x_{k+1} | x_k, u_k ~ p(x_{k+1} | x_k, u_k, t_k, t_{k+1}), k = 0..T-1 + y_{k+1} | x_{k+1}, u_k ~ p(y_{k+1} | x_{k+1}, u_k, t_{k+1}), k = 0..T-1 + x_hat_{k+1|k+1} = FilterUpdate(x_hat_{k|k}, u_k, y_{k+1}, t_k, t_{k+1}), k = 0..T-1 + +`FilterUpdate` is implemented by `compute_cuthbert_filter_update` +(`dynestyx/inference/integrations/cuthbert/discrete_filter.py`), which drives +cuthbert's `Filter.filter_prepare`/`filter_combine` primitives one step at a +time instead of over a whole pre-supplied trajectory. This works for any +filter family exposed there (`KFConfig`, `EKFConfig`, `EnKFConfig`, +`PFConfig`); the belief `x_hat` returned each step is therefore whatever +state type that family produces (e.g. a Kalman-family state with a `.mean` +property, or a `ParticleFilterState` with `.particles`/`.log_weights`) -- +see `filter_state_mean` below for a family-agnostic point estimate. + +Important: the control passed to `dynamics.observation_model` for +`y_{k+1}` is `u_k` (the control that drove the transition into `x_{k+1}`), +not a same-index `u_{k+1}`. This differs from `DiscreteTimeSimulator`'s +pre-supplied-trajectory convention, where `ctrl_values[t]` is paired with +both the observation and the outgoing transition at the same index t. That +convention is impossible to satisfy online: `u_{k+1}` is chosen by +`control_policy` from `x_hat_{k+1|k+1}`, which itself depends on having +already observed `y_{k+1}`. See `compute_cuthbert_filter_update`'s docstring +for details. + +`DiscreteControlLoopSimulator` computes its own controls online, so unlike +`DiscreteTimeSimulator` it is driven with `predict_times` only -- do not +pass `ctrl_times`/`ctrl_values` to `dsx.sample` (simulator handlers are +generation-only and reject `obs_times`/`obs_values`; `ctrl_values` is +rejected here too, since it would conflict with online control). +""" + +import dataclasses +from typing import Any, Protocol, runtime_checkable + +import jax +import jax.numpy as jnp +import jax.random as jr +from jax import Array +from jaxtyping import PRNGKeyArray, PyTree, Real + +from dynestyx.inference.configs.filter import BaseFilterConfig +from dynestyx.inference.filters import _default_filter_config +from dynestyx.inference.integrations.cuthbert.discrete_filter import ( + compute_cuthbert_filter_update, +) +from dynestyx.models import DynamicalModel +from dynestyx.simulation.base import BaseSimulator +from dynestyx.simulation.utils import _ensure_trailing_dim, _tile_times +from dynestyx.types import SimulatedResult +from dynestyx.utils import _should_record_field + + +def filter_state_mean(state) -> Array: + """Point-estimate summary of a cuthbert filter state, any family. + + Kalman-family states (`KFConfig`, `EKFConfig`, `EnKFConfig`) expose a + `.mean` property directly. `PFConfig` states (`ParticleFilterState`) have + no such property -- they represent the belief as a weighted particle + cloud (`.particles`, `.log_weights`), so the point estimate is the + weighted mean instead. Broadcasts over any leading batch/time axis, so it + works on both a single belief and a whole scanned-out sequence of them. + """ + if hasattr(state, "mean"): + return state.mean + if hasattr(state, "particles") and hasattr(state, "log_weights"): + weights = jax.nn.softmax(state.log_weights, axis=-1) + return jnp.sum(weights[..., None] * state.particles, axis=-2) + raise TypeError(f"Cannot summarize filter state of type {type(state).__name__}") + + +@runtime_checkable +class PolicyCallable(Protocol): + r"""Structural protocol for a control policy $\pi$. + + $$u_k, s_{k+1} = \pi(\hat x_{k|k}, s_k, \mathrm{key}_k)$$ + + `x_hat` is whatever belief state the chosen `filter_config` family + produces (see module docstring); use `filter_state_mean` for a + family-agnostic point estimate. `key` is a fresh PRNG key for this step, + for policies that need their own randomness (e.g. sampling-based + controllers like `dynestyx.control.mppi.MPPI`); deterministic policies + simply ignore it. Any plain callable matching this signature works, + including an `equinox.Module` with a matching `__call__` (e.g. a learned + neural policy) or a plain Python function (e.g. an LQR gain lookup). + """ + + def __call__( + self, x_hat: Any, s: PyTree, key: PRNGKeyArray + ) -> tuple[Real[Array, " control_dim"], PyTree]: + raise NotImplementedError() + + +@dataclasses.dataclass +class ControlledSimulatedResult(SimulatedResult): + """`SimulatedResult` extended with the control loop's extra outputs. + + Registered as deterministic sites the same generic way as + `SimulatedResult`'s own fields (`dynestyx.simulation.utils. + _register_simulated_result_sites` iterates every dataclass field and + skips `None` values) -- so the existing recording-gating logic just + means passing `None` for a field instead of conditionally omitting a + dict key, as the old (pre-refactor) version of this class did. + """ + + # control_time = time - 1 (no control is chosen after the final state). + controls: Real[Array, "n_simulations control_time control_dim"] | None = None + filtered_states_mean: Array | None = None + policy_states: PyTree | None = None + + +class DiscreteControlLoopSimulator(BaseSimulator): + r"""Closed-loop simulator: simulate, observe, filter, and decide controls online. + + Unlike `DiscreteTimeSimulator`, which requires the entire control + trajectory as a pre-supplied `ctrl_values` array, `DiscreteControlLoopSimulator` + computes each $u_k$ online from the filtered belief $\hat x_{k|k}$ via + `control_policy`. See the module docstring for the full loop equations + and the control-index convention used for `dynamics.observation_model`. + + Attributes: + control_policy: Control policy $\pi$; see `PolicyCallable`. + policy_state_init: Initial policy state $s_0$ (any PyTree). + filter_config: Selects the filtering algorithm + (`KFConfig`/`EKFConfig`/`EnKFConfig`/`PFConfig`). Defaults to + `_default_filter_config(dynamics)` when `None`. Its + `record_filtered_states_mean`/`record_max_elems` fields gate + whether the `filtered_states_mean` output is recorded, exactly + as they do for `Filter` (see `dynestyx.utils._should_record_field`). + n_simulations: Currently only `1` is supported. + """ + + def __init__( + self, + *, + control_policy: PolicyCallable, + policy_state_init: PyTree, + filter_config: BaseFilterConfig | None = None, + n_simulations: int = 1, + ) -> None: + super().__init__(n_simulations=n_simulations) + self.control_policy = control_policy + self.policy_state_init = policy_state_init + self.filter_config = filter_config + + def simulate( + self, + dynamics: DynamicalModel, + *, + rng_key: PRNGKeyArray, + ctrl_times=None, + ctrl_values=None, + predict_times=None, + **kwargs, + ) -> ControlledSimulatedResult: + if dynamics.continuous_time: + raise ValueError( + "DiscreteControlLoopSimulator only supports discrete-time models " + "(see class docstring). Wrap continuous-time state evolution " + "in a Discretizer first." + ) + if ctrl_values is not None: + raise ValueError( + "DiscreteControlLoopSimulator computes controls online via " + "`control_policy`; pass ctrl_values to a plain " + "Simulator/DiscreteTimeSimulator instead if you want " + "open-loop control." + ) + if self.n_simulations != 1: + raise NotImplementedError( + "DiscreteControlLoopSimulator does not yet support n_simulations > 1." + ) + + times = predict_times + if times is None: + raise ValueError("predict_times must be provided") + T = len(times) + if T < 1: + raise ValueError("times must contain at least one timepoint") + + filter_config = ( + self.filter_config + if self.filter_config is not None + else _default_filter_config(dynamics) + ) + + key, k_x0, k_y0, k_filt0 = jr.split(rng_key, 4) + + x_0 = dynamics.initial_condition.sample(k_x0) + y_0 = dynamics.observation_model(x_0, None, times[0]).sample(k_y0) + # Give the bootstrap FilterUpdate a non-degenerate t_prev (borrowing the + # width of the first real interval, matching compute_cuthbert_filter's + # own dummy-row convention). This step is a genuine no-op transition + # for every filter family (nothing has happened before t_0), but some + # backends (e.g. EKF's Taylor linearization) evaluate the transition + # unconditionally via jnp.where rather than jax.lax.cond, so t_prev==t + # would construct a zero-width-dt, zero-covariance distribution whose + # NaN log-density leaks through the gradient even on the discarded + # branch -- a state-evolution whose covariance scales with dt (e.g. an + # Euler-Maruyama-discretized SDE) hits this; a fixed-covariance one + # (e.g. LinearGaussianStateEvolution) does not. + dt0 = times[1] - times[0] if T > 1 else jnp.asarray(1.0, dtype=times.dtype) + x_hat_0 = compute_cuthbert_filter_update( + dynamics, + filter_config, + None, + k_filt0, + y=y_0, + u=None, + t=times[0], + t_prev=times[0] - dt0, + ) + s_0 = self.policy_state_init + + def _step(carry, t_idx): + x_prev, x_hat_prev, s_prev, step_key = carry + step_key, k_trans, k_obs, k_filt, k_policy = jr.split(step_key, 5) + t_now = times[t_idx] + t_next = times[t_idx + 1] + + u_k, s_next = self.control_policy(x_hat_prev, s_prev, k_policy) + + trans_dist = dynamics.state_evolution(x_prev, u_k, t_now, t_next) + x_next = trans_dist.sample(k_trans) + + obs_dist = dynamics.observation_model(x_next, u_k, t_next) + y_next = obs_dist.sample(k_obs) + + x_hat_next = compute_cuthbert_filter_update( + dynamics, + filter_config, + x_hat_prev, + k_filt, + y=y_next, + u=u_k, + t=t_next, + t_prev=t_now, + ) + + new_carry = (x_next, x_hat_next, s_next, step_key) + outputs = (x_next, x_hat_next, y_next, s_next, u_k) + return new_carry, outputs + + init_carry = (x_0, x_hat_0, s_0, key) + _, (xs, x_hats, ys, ss, us) = jax.lax.scan(_step, init_carry, jnp.arange(T - 1)) + + states = jnp.concatenate([jnp.expand_dims(x_0, axis=0), xs], axis=0) + observations = jnp.concatenate([jnp.expand_dims(y_0, axis=0), ys], axis=0) + + mean_shape = filter_state_mean(x_hat_0).shape + record_mean = _should_record_field( + filter_config.record_filtered_states_mean, + (T, *mean_shape), + filter_config.record_max_elems, + ) + filtered_states_mean = None + if record_mean: + filtered_states_mean_vals = jnp.concatenate( + [ + jnp.expand_dims(filter_state_mean(x_hat_0), axis=0), + filter_state_mean(x_hats), + ], + axis=0, + ) + filtered_states_mean = _ensure_trailing_dim( + jnp.expand_dims(filtered_states_mean_vals, axis=0) + ) + + policy_states = None + if s_0 is not None: + # A stateless policy (policy_state_init=None) has nothing to + # record; jnp.expand_dims can't be applied to None directly, and + # there is no meaningful "policy_states" trajectory to report. + policy_states = jax.tree_util.tree_map( + lambda leaf: jnp.expand_dims(leaf, axis=0), ss + ) + + return ControlledSimulatedResult( + times=_tile_times(times, 1), + x_0=jnp.expand_dims(x_0, axis=0), + states=_ensure_trailing_dim(jnp.expand_dims(states, axis=0)), + observations=_ensure_trailing_dim(jnp.expand_dims(observations, axis=0)), + controls=_ensure_trailing_dim(jnp.expand_dims(us, axis=0)), + filtered_states_mean=filtered_states_mean, + policy_states=policy_states, + ) + + +__all__ = [ + "ControlledSimulatedResult", + "DiscreteControlLoopSimulator", + "PolicyCallable", + "filter_state_mean", +] diff --git a/dynestyx/control/mppi.py b/dynestyx/control/mppi.py new file mode 100644 index 00000000..a53d3f46 --- /dev/null +++ b/dynestyx/control/mppi.py @@ -0,0 +1,110 @@ +"""Basic Model Predictive Path Integral (MPPI) controller. + +Deliberately simple: samples candidate control sequences as Gaussian +perturbations around a nominal sequence, scores each with a user-supplied +loss, and returns the softmax-weighted mean -- the standard MPPI control law. +No colored noise, adaptive covariance, or other refinements; the goal is a +plain example that plugs into `DiscreteControlLoopSimulator`'s +`control_policy=` slot (see `dynestyx.control.discrete_controller_simulators. +PolicyCallable`), not a state-of-the-art implementation. +""" + +from collections.abc import Callable + +import equinox as eqx +import jax +import jax.numpy as jnp +import jax.random as jr +from jax import Array +from jaxtyping import PRNGKeyArray, PyTree, Real + +from dynestyx.control.discrete_controller_simulators import filter_state_mean + + +def mppi_initial_state( + horizon: int, control_dim: int +) -> Real[Array, "horizon control_dim"]: + """Zero nominal control sequence, the natural `policy_state_init` for `MPPI`.""" + return jnp.zeros((horizon, control_dim)) + + +class MPPI(eqx.Module): + r"""Model Predictive Path Integral (MPPI) controller. + + At each call: sample `n_samples` candidate control sequences of length + `horizon` as Gaussian perturbations around a nominal sequence (the policy + state `s`, warm-started from the previous call), roll each through + `dynamics_model`, score the resulting trajectories with `loss_fn`, and + combine them via the standard MPPI weighting + + $$w_i \\propto \\exp(-\\mathrm{loss}_i / \\lambda), \\qquad + u_{0:H-1} = \\sum_i w_i\\, u^{(i)}_{0:H-1}$$ + + i.e. a softmax over the (negated, temperature-scaled) per-sample losses. + Only the first control of that weighted-mean sequence is applied this + step (receding horizon); the remainder becomes next step's nominal + sequence, shifted left by one with the last entry repeated. + + Attributes: + dynamics_model: Any callable `(x0, u_seq) -> x_seq`, deliberately not + tied to dynestyx's own `DynamicalModel`/filtering machinery -- a + bare JAX-compatible rollout function (e.g. wrapping a + `DynamicalModel`'s `state_evolution` with a `jax.lax.scan`, or an + external simulator). If `batched=True` (default), it must accept + `u_seq` shaped `(n_samples, horizon, control_dim)` and return + `(n_samples, horizon, state_dim)` in one call (e.g. internally + vmapped). If `batched=False`, it only supports a single + `(horizon, control_dim) -> (horizon, state_dim)` call at a time; + `MPPI` then drives it with `jax.lax.map`, JAX's for-loop + construct that calls it once per sample without requiring the + model itself to support batching. + loss_fn: `(x_seq, u_seq) -> scalar`, called once per sample (vmapped) + over the rolled-out state and control trajectories. + horizon: Planning horizon length `H`. + n_samples: Number of sampled control sequences per call. + noise_std: Standard deviation of the Gaussian perturbations added to + the nominal sequence, scalar or shape `(control_dim,)`. + temperature: MPPI's $\\lambda$; higher values flatten the weights + toward a uniform average, lower values concentrate weight on the + lowest-loss samples. + batched: Whether `dynamics_model` accepts a batch of control + sequences in one call (see above). + """ + + dynamics_model: Callable = eqx.field(static=True) + loss_fn: Callable = eqx.field(static=True) + horizon: int = eqx.field(static=True) + n_samples: int = eqx.field(static=True) + noise_std: Real[Array, ""] | Real[Array, " control_dim"] + temperature: float = 1.0 + batched: bool = eqx.field(static=True, default=True) + + def __call__( + self, x_hat: PyTree, s: Real[Array, "horizon control_dim"], key: PRNGKeyArray + ) -> tuple[Real[Array, " control_dim"], Real[Array, "horizon control_dim"]]: + x0 = filter_state_mean(x_hat) + nominal = s + control_dim = nominal.shape[-1] + + noise = self.noise_std * jr.normal( + key, (self.n_samples, self.horizon, control_dim) + ) + candidates = nominal[None, :, :] + noise # (n_samples, horizon, control_dim) + + if self.batched: + x_trajectories = self.dynamics_model(x0, candidates) + else: + x_trajectories = jax.lax.map( + lambda u_seq: self.dynamics_model(x0, u_seq), candidates + ) + losses = jax.vmap(self.loss_fn)(x_trajectories, candidates) + + weights = jax.nn.softmax(-losses / self.temperature) + weighted_seq = jnp.einsum("k,khc->hc", weights, candidates) + + u0 = weighted_seq[0] + next_nominal = jnp.concatenate([weighted_seq[1:], weighted_seq[-1:]], axis=0) + return u0, next_nominal + + +__all__ = ["MPPI", "mppi_initial_state"] diff --git a/dynestyx/inference/integrations/cuthbert/discrete_filter.py b/dynestyx/inference/integrations/cuthbert/discrete_filter.py index aef1c4b2..7e154a3c 100644 --- a/dynestyx/inference/integrations/cuthbert/discrete_filter.py +++ b/dynestyx/inference/integrations/cuthbert/discrete_filter.py @@ -3,6 +3,7 @@ import jax import jax.numpy as jnp +import jax.random as jr import numpyro.distributions as dist from cuthbert import filter as cuthbert_filter from cuthbert.enkf import ensemble_kalman_filter @@ -151,6 +152,134 @@ def _drop_if_time_leaf(leaf): return jax.tree.map(_drop_if_time_leaf, states) +def _build_cuthbert_filter_obj( + dynamics: DynamicalModel, + filter_config: BaseFilterConfig, + filter_kwargs: dict, + key: jax.Array | None, + *, + want_parallel: bool, +): + """Dispatch on filter_config type to build the cuthbert Filter object. + + Shared by compute_cuthbert_filter (whole-trajectory) and + compute_cuthbert_filter_update (single-step): the Filter object itself + (init_prepare/filter_prepare/filter_combine) only depends on `dynamics`, + never on trajectory data, so both callers build it the same way. + """ + if isinstance(filter_config, PFConfig): + if key is None: + raise ValueError( + "Particle filter requires a PRNG key: set 'crn_seed' in the filter config, " + "or run inside a NumPyro seeded context (e.g., with numpyro.handlers.seed)." + ) + filter_obj = _cuthbert_filter_pf(dynamics, filter_kwargs) + elif isinstance(filter_config, EnKFConfig): + if key is None: + raise ValueError( + "Ensemble Kalman filter requires a PRNG key: set 'crn_seed' in the filter config, " + "or run inside a NumPyro seeded context (e.g., with numpyro.handlers.seed)." + ) + filter_obj = _cuthbert_filter_enkf(dynamics, filter_kwargs) + elif isinstance(filter_config, KFConfig): + filter_obj = _cuthbert_filter_kalman(dynamics, filter_kwargs) + elif isinstance(filter_config, EKFConfig): + filter_obj = _cuthbert_filter_taylor_kf(dynamics, filter_kwargs) + else: + raise ValueError( + f"Unsupported cuthbert config: {type(filter_config).__name__}. " + "Expected KFConfig, EKFConfig, EnKFConfig, PFConfig." + ) + + parallel = ( + want_parallel + and isinstance(filter_config, KFConfig) + and filter_config.associative + ) + if parallel and not filter_obj.associative: + raise ValueError( + "Associative filtering was requested, but the constructed cuthbert " + f"filter is not associative: {type(filter_config).__name__}." + ) + return filter_obj, parallel + + +def compute_cuthbert_filter_update( + dynamics: DynamicalModel, + filter_config: BaseFilterConfig, + prev_state, + key: jax.Array, + *, + y: jax.Array, + u: jax.Array | None, + t: jax.Array, + t_prev: jax.Array | None = None, +): + r"""One-step FilterUpdate: state_k + u_k + y_{k+1} -> state_{k+1}. + + Unlike `compute_cuthbert_filter` (whole-trajectory), this performs exactly + one predict+update step using cuthbert's `Filter.filter_prepare`/ + `filter_combine` primitives directly, without requiring future + observations. This is what makes online control possible: the state + returned here can be consumed by a policy to choose the next control + before the next observation exists. + + Pass `prev_state=None` for the bootstrap call (computing the filtering + state after only the first observation, with no control history yet); + this internally calls the cuthbert filter's `init_prepare` first. + + Control convention (important, and different from `compute_cuthbert_filter` + / `DiscreteTimeSimulator`): `u` is the control that drove the transition + *into* the state being filtered, i.e. u_k when producing state_{k+1} from + state_k and y_{k+1} -- matching `FilterUpdate(x_hat_k, u_k, y_{k+1}, ...)` + in the control-loop equations. `compute_cuthbert_filter`/ + `DiscreteTimeSimulator` instead pair `ctrl_values[t]` with *both* the + observation and the outgoing transition at the same index t, which is + only valid when the whole control trajectory is already known in advance. + For online control this is impossible: u_{k+1} cannot exist before + y_{k+1} is observed, since it is computed by the policy from the filtered + state that itself depends on y_{k+1}. So `u` here is used for both + `CuthbertInputs.u` and `CuthbertInputs.u_prev` in the single-row input + built for this step. Pass `u=None` for the bootstrap call, matching y_0's + lack of a control argument in the control-loop equations (numerically + equivalent to zeros for models with a control-input matrix, since D=None + or u=None are both treated as "no control contribution"). + """ + filter_kwargs = _config_to_filter_kwargs(filter_config) + key_state, key_prep = jr.split(key) + filter_obj, _ = _build_cuthbert_filter_obj( + dynamics, filter_config, filter_kwargs, key_state, want_parallel=False + ) + + control_dim = dynamics.control_dim + u_arr = jnp.zeros((control_dim,)) if u is None else jnp.asarray(u) + is_first_step = prev_state is None + t_arr = jnp.asarray(t) + t_prev_arr = t_arr if t_prev is None else jnp.asarray(t_prev) + + if is_first_step: + dummy_mi = CuthbertInputs( + y=jnp.zeros_like(jnp.asarray(y)), + u=jnp.zeros_like(u_arr), + u_prev=jnp.zeros_like(u_arr), + time=t_arr, + time_prev=t_arr, + is_first_step=jnp.asarray(False), + ) + prev_state = filter_obj.init_prepare(dummy_mi, key=key_state) + + mi_t = CuthbertInputs( + y=jnp.asarray(y), + u=u_arr, + u_prev=u_arr, + time=t_arr, + time_prev=t_prev_arr, + is_first_step=jnp.asarray(is_first_step), + ) + prep_state = filter_obj.filter_prepare(mi_t, key=key_prep) + return filter_obj.filter_combine(prev_state, prep_state) + + def compute_cuthbert_filter( dynamics: DynamicalModel, filter_config: BaseFilterConfig, @@ -200,36 +329,9 @@ def compute_cuthbert_filter( is_first_step=jnp.arange(obs_len + 1) == 1, ) - if isinstance(filter_config, PFConfig): - if key is None: - raise ValueError( - "Particle filter requires a PRNG key: set 'crn_seed' in the filter config, " - "or run inside a NumPyro seeded context (e.g., with numpyro.handlers.seed)." - ) - filter_obj = _cuthbert_filter_pf(dynamics, filter_kwargs) - elif isinstance(filter_config, EnKFConfig): - if key is None: - raise ValueError( - "Ensemble Kalman filter requires a PRNG key: set 'crn_seed' in the filter config, " - "or run inside a NumPyro seeded context (e.g., with numpyro.handlers.seed)." - ) - filter_obj = _cuthbert_filter_enkf(dynamics, filter_kwargs) - elif isinstance(filter_config, KFConfig): - filter_obj = _cuthbert_filter_kalman(dynamics, filter_kwargs) - elif isinstance(filter_config, EKFConfig): - filter_obj = _cuthbert_filter_taylor_kf(dynamics, filter_kwargs) - else: - raise ValueError( - f"Unsupported cuthbert config: {type(filter_config).__name__}. " - "Expected KFConfig, EKFConfig, EnKFConfig, PFConfig." - ) - - parallel = isinstance(filter_config, KFConfig) and filter_config.associative - if parallel and not filter_obj.associative: - raise ValueError( - "Associative filtering was requested, but the constructed cuthbert " - f"filter is not associative: {type(filter_config).__name__}." - ) + filter_obj, parallel = _build_cuthbert_filter_obj( + dynamics, filter_config, filter_kwargs, key, want_parallel=True + ) raw_states = cuthbert_filter( filter_obj, diff --git a/tests/test_discrete_control.py b/tests/test_discrete_control.py new file mode 100644 index 00000000..648d7574 --- /dev/null +++ b/tests/test_discrete_control.py @@ -0,0 +1,811 @@ +"""Tests for DiscreteControlLoopSimulator and compute_cuthbert_filter_update.""" + +import equinox as eqx +import jax +import jax.numpy as jnp +import jax.random as jr +import numpyro.distributions as dist +import pytest +from numpyro.handlers import seed, trace + +import dynestyx as dsx +from dynestyx.control.discrete_controller_simulators import ( + DiscreteControlLoopSimulator, + filter_state_mean, +) +from dynestyx.discretizers import Discretizer, euler_maruyama +from dynestyx.inference.configs.filter import EKFConfig, EnKFConfig, KFConfig, PFConfig +from dynestyx.inference.integrations.cuthbert.discrete_filter import ( + compute_cuthbert_filter, + compute_cuthbert_filter_update, +) +from dynestyx.models import ( + ContinuousTimeStateEvolution, + DynamicalModel, + FullDiffusion, + StochasticContinuousTimeStateEvolution, +) +from dynestyx.models.lti_dynamics import LTI_discrete +from dynestyx.models.observations import LinearGaussianObservation +from tests.fixtures import _n_particles +from tests.test_utils import assert_trace_sites_exist_and_field_all_finite + +# --------------------------------------------------------------------------- +# Shared helpers +# --------------------------------------------------------------------------- + + +def _lti_1d(A=1.0, B=1.0, Q=0.05, R=0.1): + """1D linear-Gaussian model matching the tutorial's discrete-time demo.""" + return LTI_discrete( + A=jnp.array([[A]]), + Q=Q * jnp.eye(1), + H=jnp.array([[1.0]]), + R=R * jnp.eye(1), + B=jnp.array([[B]]), + ) + + +class _LinearPolicy(eqx.Module): + """u = -K x_hat, as an equinox.Module policy.""" + + K: jax.Array + + def __call__(self, x_hat, s, key): + return -self.K @ filter_state_mean(x_hat), s + + +def _linear_policy_fn(K): + """Plain-function equivalent of _LinearPolicy.""" + + def policy(x_hat, s, key): + return -K @ filter_state_mean(x_hat), s + + return policy + + +class _BlackBoxState: + """A genuinely black-box transition result: only `.sample()`/`.shape()`, + no `.log_prob()`/`.mean` anywhere -- standing in for e.g. a MuJoCo step.""" + + def __init__(self, x_prev, u, t_now, t_next, state_dim): + self._x_prev, self._u, self._t_now, self._t_next = x_prev, u, t_now, t_next + self._state_dim = state_dim + + def sample(self, key): + dt = self._t_next - self._t_now + x_next = jnp.tanh(self._x_prev) + self._u * dt + return x_next + 0.05 * jr.normal(key, x_next.shape) + + def shape(self): + return (self._state_dim,) + + +def _black_box_state_evolution(x, u, t_now, t_next): + return _BlackBoxState(x, u, t_now, t_next, state_dim=x.shape[-1]) + + +def _black_box_dynamics(): + return DynamicalModel( + initial_condition=dist.MultivariateNormal(jnp.array([1.0]), 0.1 * jnp.eye(1)), + state_evolution=_black_box_state_evolution, + observation_model=LinearGaussianObservation(H=jnp.eye(1), R=0.1 * jnp.eye(1)), + control_dim=1, + ) + + +def _run_trace(model, *, rng_seed=0): + with seed(rng_seed=rng_seed): + return trace(model).get_trace() + + +# --------------------------------------------------------------------------- +# Group 1: filter_state_mean +# --------------------------------------------------------------------------- + + +def test_filter_state_mean_uses_mean_property_when_present(): + class _KFLikeState: + mean = jnp.array([1.0, 2.0]) + + assert jnp.allclose(filter_state_mean(_KFLikeState()), jnp.array([1.0, 2.0])) + + +def test_filter_state_mean_weighted_particle_average(): + class _PFLikeState: + particles = jnp.array([[0.0], [2.0], [4.0]]) # 3 particles, state_dim=1 + log_weights = jnp.log(jnp.array([0.25, 0.25, 0.5])) + + result = filter_state_mean(_PFLikeState()) + expected = 0.25 * 0.0 + 0.25 * 2.0 + 0.5 * 4.0 # = 2.5 + assert jnp.allclose(result, jnp.array([expected]), atol=1e-5) + + +def test_filter_state_mean_unsupported_type_raises(): + class _Neither: + pass + + with pytest.raises(TypeError, match="Cannot summarize filter state"): + filter_state_mean(_Neither()) + + +# --------------------------------------------------------------------------- +# Group 2: compute_cuthbert_filter_update core correctness +# --------------------------------------------------------------------------- + +_T = 6 +_OBS_TIMES = jnp.arange(_T, dtype=jnp.float32) +_CTRL_VALUES = jnp.ones((_T, 1)) * 0.3 +_OBS_VALUES = jnp.array([[0.5], [0.4], [0.3], [0.2], [0.1], [0.05]]) + + +def _step_through_filter_update(dynamics, filter_config, *, key_seed=0): + """Drive compute_cuthbert_filter_update one step at a time over _OBS_VALUES, + using the same same-index control convention as compute_cuthbert_filter + (ctrl_values[t] paired with both the transition into t and the observation + at t), so the result is directly comparable to the whole-trajectory filter. + """ + prev_state = None + means = [] + k = jr.PRNGKey(key_seed) + for t_idx in range(_T): + k, sub = jr.split(k) + u_for_call = None if t_idx == 0 else _CTRL_VALUES[t_idx - 1] + t_prev = None if t_idx == 0 else _OBS_TIMES[t_idx - 1] + prev_state = compute_cuthbert_filter_update( + dynamics, + filter_config, + prev_state, + sub, + y=_OBS_VALUES[t_idx], + u=u_for_call, + t=_OBS_TIMES[t_idx], + t_prev=t_prev, + ) + means.append(filter_state_mean(prev_state)) + return jnp.stack(means) + + +@pytest.mark.parametrize( + "filter_config", [KFConfig(filter_source="cuthbert"), EKFConfig()] +) +def test_compute_cuthbert_filter_update_matches_whole_trajectory(filter_config): + dynamics = _lti_1d() + _, states_batch = compute_cuthbert_filter( + dynamics, + filter_config, + jr.PRNGKey(0), + obs_times=_OBS_TIMES, + obs_values=_OBS_VALUES, + ctrl_values=_CTRL_VALUES, + ) + means_batch = states_batch.mean.ravel() + means_step = _step_through_filter_update( + dynamics, filter_config, key_seed=0 + ).ravel() + assert jnp.allclose(means_batch, means_step, atol=1e-4) + + +def test_compute_cuthbert_filter_update_bootstrap_ignores_u(): + """The bootstrap call (prev_state=None) must skip the transition entirely + (is_first_step=True), regardless of what `u` is passed. This model's + transition is control-affine (B=1.0), so if the no-op gating broke and a + phantom transition used `u`, a huge `u` would visibly shift the mean -- + making this a meaningful check, not just a no-op-by-construction one. + """ + dynamics = _lti_1d() + filter_config = EKFConfig() + y0 = jnp.array([0.5]) + t0 = jnp.array(0.0) + + state_no_u = compute_cuthbert_filter_update( + dynamics, filter_config, None, jr.PRNGKey(0), y=y0, u=None, t=t0 + ) + state_huge_u = compute_cuthbert_filter_update( + dynamics, filter_config, None, jr.PRNGKey(0), y=y0, u=jnp.array([999.0]), t=t0 + ) + assert jnp.allclose(state_no_u.mean, state_huge_u.mean, atol=1e-6) + + +def _euler_maruyama_dynamics(): + # euler_maruyama() requires an already-resolved StochasticContinuousTimeStateEvolution + # (with bm_dim metadata filled in), which only happens inside DynamicalModel.__init__ -- + # matching exactly what Discretizer._sample_ds does internally. + cte = ContinuousTimeStateEvolution( + drift=lambda x, u, t: u, + diffusion=FullDiffusion(0.2 * jnp.eye(1)), + ) + continuous_dynamics = DynamicalModel( + initial_condition=dist.MultivariateNormal(jnp.array([1.0]), 0.1 * jnp.eye(1)), + state_evolution=cte, + observation_model=LinearGaussianObservation(H=jnp.eye(1), R=0.2 * jnp.eye(1)), + control_dim=1, + ) + # DynamicalModel.state_evolution is declared as the broader + # ContinuousTimeStateEvolution | DiscreteStateTransition union; narrow it + # for the type checker the same way Discretizer._sample_ds does at + # runtime (dynestyx/discretizers.py), via an isinstance check. + assert isinstance( + continuous_dynamics.state_evolution, StochasticContinuousTimeStateEvolution + ) + return DynamicalModel( + initial_condition=continuous_dynamics.initial_condition, + state_evolution=euler_maruyama(continuous_dynamics.state_evolution), + observation_model=continuous_dynamics.observation_model, + control_dim=continuous_dynamics.control_dim, + ) + + +def test_compute_cuthbert_filter_update_default_t_prev_is_degenerate_for_dt_scaled_transition(): + """Documents the actual failure mode of the bug found and fixed this + session: for a transition whose covariance scales with dt (e.g. an + Euler-Maruyama-discretized SDE), omitting `t_prev` collapses to dt=0 for + the first real step, which produces a zero-covariance distribution whose + NaN log-density leaks through EKF's Taylor-linearization gradient (via + jnp.where evaluating both branches). This is why + DiscreteControlLoopSimulator always supplies an explicit, non-degenerate + t_prev for its bootstrap call (see the next test). + """ + dynamics = _euler_maruyama_dynamics() + state = compute_cuthbert_filter_update( + dynamics, + EKFConfig(), + None, + jr.PRNGKey(0), + y=jnp.array([0.9]), + u=None, + t=jnp.array(0.0), + # t_prev omitted -> defaults to t (dt=0) + ) + assert bool(jnp.any(jnp.isnan(state.mean))) + + +def test_compute_cuthbert_filter_update_explicit_t_prev_avoids_degeneracy(): + dynamics = _euler_maruyama_dynamics() + t0 = jnp.array(0.0) + state = compute_cuthbert_filter_update( + dynamics, + EKFConfig(), + None, + jr.PRNGKey(0), + y=jnp.array([0.9]), + u=None, + t=t0, + t_prev=t0 - jnp.array(1.0), + ) + assert jnp.all(jnp.isfinite(state.mean)) + + +@pytest.mark.parametrize( + ("filter_config", "tol"), + [ + (PFConfig(n_particles=_n_particles(500)), 3e-1), + (EnKFConfig(n_particles=_n_particles(500)), 3e-1), + ], +) +def test_compute_cuthbert_filter_update_pf_enkf_agree_with_kf_mean(filter_config, tol): + dynamics = _lti_1d() + _, kf_states = compute_cuthbert_filter( + dynamics, + KFConfig(filter_source="cuthbert"), + jr.PRNGKey(0), + obs_times=_OBS_TIMES, + obs_values=_OBS_VALUES, + ctrl_values=_CTRL_VALUES, + ) + kf_means = kf_states.mean.ravel() + means = _step_through_filter_update(dynamics, filter_config, key_seed=1).ravel() + assert jnp.mean(jnp.abs(means - kf_means)) < tol + + +# --------------------------------------------------------------------------- +# Group 3: DiscreteControlLoopSimulator validation/error paths +# --------------------------------------------------------------------------- + + +def _simple_policy_and_state(): + return _LinearPolicy(K=jnp.array([[0.5]])), None + + +def test_rejects_continuous_time_dynamics_not_wrapped_in_discretizer(): + dynamics = DynamicalModel( + initial_condition=dist.MultivariateNormal(jnp.zeros(1), jnp.eye(1)), + state_evolution=ContinuousTimeStateEvolution( + drift=lambda x, u, t: u, diffusion=FullDiffusion(0.1 * jnp.eye(1)) + ), + observation_model=LinearGaussianObservation(H=jnp.eye(1), R=0.1 * jnp.eye(1)), + control_dim=1, + ) + policy, s0 = _simple_policy_and_state() + + def model(): + with DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=s0): + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + with pytest.raises(ValueError, match="only supports discrete-time models"): + _run_trace(model) + + +def test_rejects_ctrl_values(): + dynamics = _lti_1d() + policy, s0 = _simple_policy_and_state() + + def model(): + with DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=s0): + return dsx.sample( + "f", + dynamics, + predict_times=jnp.arange(0.0, 5.0), + ctrl_times=jnp.arange(0.0, 5.0), + ctrl_values=jnp.zeros((5, 1)), + ) + + with pytest.raises(ValueError, match="computes controls online"): + _run_trace(model) + + +def test_rejects_obs_values_conditioning(): + dynamics = _lti_1d() + policy, s0 = _simple_policy_and_state() + + def model(): + with DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=s0): + return dsx.sample( + "f", + dynamics, + obs_times=jnp.arange(0.0, 5.0), + obs_values=jnp.zeros((5, 1)), + ) + + with pytest.raises(ValueError, match="generation-only"): + _run_trace(model) + + +def test_rejects_n_simulations_greater_than_one(): + dynamics = _lti_1d() + policy, s0 = _simple_policy_and_state() + + def model(): + with DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=s0, n_simulations=2 + ): + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + with pytest.raises(NotImplementedError, match="n_simulations"): + _run_trace(model) + + +def test_requires_obs_times_or_predict_times(): + dynamics = _lti_1d() + policy, s0 = _simple_policy_and_state() + + def model(): + with DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=s0): + return dsx.sample("f", dynamics) + + with pytest.raises(ValueError, match="obs_times or predict_times"): + _run_trace(model) + + +def test_requires_seeded_context(): + dynamics = _lti_1d() + policy, s0 = _simple_policy_and_state() + + def model(): + with DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=s0): + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + with pytest.raises(ValueError, match="PRNG key required"): + trace(model).get_trace() + + +# --------------------------------------------------------------------------- +# Group 4: end-to-end shape & output-key tests +# --------------------------------------------------------------------------- + +_ALL_FILTER_CONFIGS = [ + KFConfig(filter_source="cuthbert", record_filtered_states_mean=True), + EKFConfig(record_filtered_states_mean=True), + EnKFConfig(n_particles=_n_particles(64), record_filtered_states_mean=True), + PFConfig(n_particles=_n_particles(64), record_filtered_states_mean=True), +] + + +@pytest.mark.parametrize("filter_config", _ALL_FILTER_CONFIGS) +def test_end_to_end_shapes_and_finiteness(filter_config): + dynamics = _lti_1d() + policy = _LinearPolicy(K=jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None, filter_config=filter_config + ) + predict_times = jnp.arange(0.0, 8.0) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + tr = _run_trace(model) + assert_trace_sites_exist_and_field_all_finite( + tr, + "f_times", + "f_states", + "f_observations", + "f_controls", + "f_filtered_states_mean", + where="end-to-end shapes test", + ) + T = len(predict_times) + assert tr["f_states"]["value"].shape == (1, T, 1) + assert tr["f_observations"]["value"].shape == (1, T, 1) + assert tr["f_controls"]["value"].shape == (1, T - 1, 1) + assert tr["f_filtered_states_mean"]["value"].shape == (1, T, 1) + + +@pytest.mark.parametrize( + ("record_val", "expect_present"), + [(True, True), (False, False)], +) +def test_record_filtered_states_mean_explicit_gating(record_val, expect_present): + dynamics = _lti_1d() + policy = _LinearPolicy(K=jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator( + control_policy=policy, + policy_state_init=None, + filter_config=EKFConfig(record_filtered_states_mean=record_val), + ) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + tr = _run_trace(model) + assert ("f_filtered_states_mean" in tr) is expect_present + + +def test_record_filtered_states_mean_default_size_heuristic(): + """record_filtered_states_mean=None (default) records only when the total + element count is within record_max_elems -- mirrors Filter's own + _should_record_field convention.""" + dynamics = _lti_1d() + policy = _LinearPolicy(K=jnp.array([[0.5]])) + + small_cap_sim = DiscreteControlLoopSimulator( + control_policy=policy, + policy_state_init=None, + filter_config=EKFConfig(record_max_elems=0), + ) + + def small_cap_model(): + with small_cap_sim: + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + tr_small_cap = _run_trace(small_cap_model) + assert "f_filtered_states_mean" not in tr_small_cap + + default_sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None, filter_config=EKFConfig() + ) + + def default_model(): + with default_sim: + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + tr_default = _run_trace(default_model) + assert "f_filtered_states_mean" in tr_default + + +def test_stateless_policy_runs_without_crashing_and_omits_policy_states(): + """Regression test: policy_state_init=None previously crashed + (jnp.expand_dims(None, axis=0)) when assembling the result dict.""" + dynamics = _lti_1d() + policy = _linear_policy_fn(jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=None) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=jnp.arange(0.0, 5.0)) + + tr = _run_trace(model) + assert "f_policy_states" not in tr + + +def test_array_policy_state_preserves_shape_and_values(): + """A non-trivial (non-None) policy state threads through the scan with the + correct shape and evolution rule. + + Note: a genuinely nested-pytree policy state (e.g. a dict of arrays) is + NOT supported end-to-end today -- BaseSimulator's shared + `_run_single_member_simulation` (dynestyx/simulators.py) enforces a + `dict[str, Array] | None` return type at runtime via jaxtyping, so + `policy_states` itself must stay a flat `Array`, not a nested structure. + This is a shared constraint across all simulators, not something specific + to fix here. + """ + dynamics = _lti_1d() + + def counting_policy(x_hat, s, key): + # u is irrelevant to this test; s is a running step counter. + return jnp.zeros(1), s + 1.0 + + sim = DiscreteControlLoopSimulator( + control_policy=counting_policy, policy_state_init=jnp.zeros(1) + ) + predict_times = jnp.arange(0.0, 6.0) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + tr = _run_trace(model) + policy_states = tr["f_policy_states"]["value"] + T = len(predict_times) + assert policy_states.shape == (1, T - 1, 1) + assert jnp.array_equal(policy_states[0, :, 0], jnp.arange(1, T, dtype=jnp.float32)) + + +# --------------------------------------------------------------------------- +# Group 5: behavioral/control correctness +# --------------------------------------------------------------------------- + + +def test_closed_loop_stabilizes_vs_uncontrolled_baseline(): + """u = -K x_hat with A - B*K stable drives the state near 0; K=0 (no + control) does not, for the same marginally-unstable (A=1) system used in + the tutorial notebook.""" + dynamics = _lti_1d(A=1.0, B=1.0, Q=0.05, R=0.1) + predict_times = jnp.arange(0.0, 20.0) + + def run(K): + policy = _LinearPolicy(K=jnp.array([[K]])) + sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None + ) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + return _run_trace(model, rng_seed=0) + + tr_controlled = run(K=0.5) + tr_uncontrolled = run(K=0.0) + + final_controlled = jnp.abs(tr_controlled["f_states"]["value"][0, -1, 0]) + final_uncontrolled = jnp.abs(tr_uncontrolled["f_states"]["value"][0, -1, 0]) + + assert final_controlled < 1.0 + assert final_controlled < final_uncontrolled + + +def test_observation_uses_previous_step_control_not_same_index(): + """Regression test for the control-index convention: y_{k+1} must be + generated using u_k (the control that drove the transition into x_{k+1}), + never a same-index u_{k+1} -- which is causally impossible online since + u_{k+1} is chosen from x_hat_{k+1|k+1}, computed from y_{k+1} itself. + Uses an observation model whose mean depends on u so a same-index leak + would be directly visible in the recorded observations. + """ + control_dim = 1 + + dynamics = DynamicalModel( + initial_condition=dist.MultivariateNormal(jnp.array([0.0]), 1e-6 * jnp.eye(1)), + state_evolution=LTI_discrete( + A=jnp.array([[1.0]]), + Q=1e-6 * jnp.eye(1), + H=jnp.array([[1.0]]), + R=1e-6 * jnp.eye(1), + B=jnp.array([[0.0]]), + ).state_evolution, + observation_model=LinearGaussianObservation( + H=jnp.zeros((1, 1)), # observation ignores state entirely + R=1e-6 * jnp.eye(1), + D=jnp.array([[1.0]]), # observation is (near-)exactly u + ), + control_dim=control_dim, + ) + + def growing_policy(x_hat, s, key): + # A distinct, easily-identified control value at every step. + return jnp.reshape(s + 1.0, (1,)), s + 1.0 + + sim = DiscreteControlLoopSimulator( + control_policy=growing_policy, policy_state_init=jnp.array(0.0) + ) + predict_times = jnp.arange(0.0, 6.0) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + tr = _run_trace(model) + controls = tr["f_controls"]["value"][0, :, 0] + observations = tr["f_observations"]["value"][0, :, 0] + + # observations[0] has no control yet (bootstrap, u=None -> D contribution 0). + assert jnp.allclose(observations[0], 0.0, atol=1e-2) + # observations[k+1] should match controls[k] (u_k), not controls[k+1] (u_{k+1}). + assert jnp.allclose(observations[1:], controls, atol=1e-2) + + +def test_determinism_same_seed_reproducible_different_seed_differs(): + dynamics = _lti_1d() + policy = _LinearPolicy(K=jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator(control_policy=policy, policy_state_init=None) + predict_times = jnp.arange(0.0, 8.0) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + tr_a = _run_trace(model, rng_seed=0) + tr_b = _run_trace(model, rng_seed=0) + tr_c = _run_trace(model, rng_seed=1) + + assert jnp.array_equal(tr_a["f_states"]["value"], tr_b["f_states"]["value"]) + assert not jnp.array_equal(tr_a["f_states"]["value"], tr_c["f_states"]["value"]) + + +def test_eqx_module_policy_matches_equivalent_plain_function_policy(): + dynamics = _lti_1d() + K = jnp.array([[0.5]]) + predict_times = jnp.arange(0.0, 8.0) + + def run(policy): + sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None + ) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + return _run_trace(model, rng_seed=0) + + tr_module = run(_LinearPolicy(K=K)) + tr_fn = run(_linear_policy_fn(K)) + + assert jnp.array_equal(tr_module["f_states"]["value"], tr_fn["f_states"]["value"]) + assert jnp.array_equal( + tr_module["f_controls"]["value"], tr_fn["f_controls"]["value"] + ) + + +# --------------------------------------------------------------------------- +# Group 6: continuous-time / Discretizer composition +# --------------------------------------------------------------------------- + + +def test_discretizer_wrapped_sde_runs_end_to_end(): + cte = ContinuousTimeStateEvolution( + drift=lambda x, u, t: u, + diffusion=FullDiffusion(0.1 * jnp.eye(1)), + ) + dynamics = DynamicalModel( + initial_condition=dist.MultivariateNormal(jnp.array([5.0]), 0.1 * jnp.eye(1)), + state_evolution=cte, + observation_model=LinearGaussianObservation(H=jnp.eye(1), R=0.2 * jnp.eye(1)), + control_dim=1, + ) + policy = _LinearPolicy(K=jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator( + control_policy=policy, + policy_state_init=None, + filter_config=EKFConfig(record_filtered_states_mean=True), + ) + predict_times = jnp.arange(0.0, 10.0) + + def model(): + with sim: + with Discretizer(discretize=euler_maruyama): + return dsx.sample("f", dynamics, predict_times=predict_times) + + tr = _run_trace(model) + assert_trace_sites_exist_and_field_all_finite( + tr, + "f_states", + "f_observations", + "f_controls", + "f_filtered_states_mean", + where="discretizer sde test", + ) + + +def test_discretizer_wrapped_nonlinear_2d_diverges_uncontrolled_stabilizes_controlled(): + state_dim = control_dim = 2 + A = 0.05 * jnp.eye(state_dim) + + dynamics = DynamicalModel( + initial_condition=dist.MultivariateNormal( + jnp.array([3.0, -2.0]), 0.05 * jnp.eye(state_dim) + ), + state_evolution=ContinuousTimeStateEvolution( + drift=lambda x, u, t: A @ (x**2) + u, + diffusion=FullDiffusion(0.1 * jnp.eye(state_dim)), + ), + observation_model=LinearGaussianObservation( + H=jnp.eye(state_dim), R=0.05 * jnp.eye(state_dim) + ), + control_dim=control_dim, + ) + predict_times = jnp.arange(0.0, 6.0, 0.1) + + def run(k): + policy = _LinearPolicy(K=k * jnp.eye(control_dim)) + sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None, filter_config=EKFConfig() + ) + + def model(): + with sim: + with Discretizer(discretize=euler_maruyama): + return dsx.sample("f", dynamics, predict_times=predict_times) + + return _run_trace(model, rng_seed=0) + + tr_controlled = run(k=1.0) + tr_uncontrolled = run(k=0.0) + + assert_trace_sites_exist_and_field_all_finite( + tr_controlled, "f_states", where="nonlinear 2d controlled" + ) + assert_trace_sites_exist_and_field_all_finite( + tr_uncontrolled, "f_states", where="nonlinear 2d uncontrolled" + ) + + final_controlled = jnp.max(jnp.abs(tr_controlled["f_states"]["value"][0, -1])) + final_uncontrolled = jnp.max(jnp.abs(tr_uncontrolled["f_states"]["value"][0, -1])) + + assert final_controlled < 1.0 + assert final_uncontrolled > 5.0 + + +# --------------------------------------------------------------------------- +# Group 7: black-box transition compatibility +# --------------------------------------------------------------------------- + + +@pytest.mark.parametrize( + "filter_config", + [PFConfig(n_particles=_n_particles(64)), EnKFConfig(n_particles=_n_particles(64))], +) +def test_black_box_transition_runs_under_pf_and_enkf(filter_config): + dynamics = _black_box_dynamics() + policy = _LinearPolicy(K=jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None, filter_config=filter_config + ) + predict_times = jnp.arange(0.0, 5.0) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + tr = _run_trace(model) + assert_trace_sites_exist_and_field_all_finite( + tr, "f_states", "f_controls", where="black-box PF/EnKF test" + ) + + +@pytest.mark.parametrize( + ("filter_config", "expected_exception"), + [ + (KFConfig(filter_source="cuthbert"), TypeError), + (EKFConfig(), ValueError), + ], +) +def test_black_box_transition_rejected_clearly_by_kf_ekf( + filter_config, expected_exception +): + dynamics = _black_box_dynamics() + policy = _LinearPolicy(K=jnp.array([[0.5]])) + sim = DiscreteControlLoopSimulator( + control_policy=policy, policy_state_init=None, filter_config=filter_config + ) + predict_times = jnp.arange(0.0, 5.0) + + def model(): + with sim: + return dsx.sample("f", dynamics, predict_times=predict_times) + + with pytest.raises(expected_exception): + _run_trace(model)