From 267965bc8820bc689afadbaf1e04fa6fcb6be7ae Mon Sep 17 00:00:00 2001 From: GerasimovSergey2001 Date: Sat, 2 May 2026 10:24:27 +0200 Subject: [PATCH] Add tutorial: Sinkhorn-type algorithm for constrained OTSergei Gerasimov --- .../constrained_sinkhorn_homework.ipynb | 2143 +++++++++++++++++ 1 file changed, 2143 insertions(+) create mode 100644 docs/tutorials/constrained_sinkhorn_homework.ipynb diff --git a/docs/tutorials/constrained_sinkhorn_homework.ipynb b/docs/tutorials/constrained_sinkhorn_homework.ipynb new file mode 100644 index 000000000..b252b75f6 --- /dev/null +++ b/docs/tutorials/constrained_sinkhorn_homework.ipynb @@ -0,0 +1,2143 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A Sinkhorn-type Algorithm for Constrained Optimal Transport\n", + "\n", + "**Implementation and Experiments — Homework Project by Sergei Gerasimov**\n", + "\n", + "> *Based on:* \"A Sinkhorn-type Algorithm for Constrained Optimal Transport.\"\n", + "\n", + "---" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1. Problem Statement\n", + "\n", + "### 1.1 Standard Optimal Transport\n", + "\n", + "Classical (discrete) optimal transport seeks the cheapest way to move mass from a source distribution $r \\in \\Delta^n$ to a target distribution $c \\in \\Delta^m$, where cost matrix $C_{ij}$ measures the expense of sending one unit from source $i$ to target $j$:\n", + "\n", + "$$\n", + "\\min_{P \\in U(r,c)} \\langle C, P \\rangle\n", + "$$\n", + "\n", + "where the *transport polytope* is\n", + "\n", + "$$\n", + "U(r,c) = \\{P \\geq 0 \\mid P\\mathbf{1} = r,\\; P^\\top\\mathbf{1} = c\\}.\n", + "$$\n", + "\n", + "### 1.2 Linearly Constrained OT\n", + "\n", + "The paper extends this to problems with additional **linear constraints** on $P$, motivated by applications such as fair allocation, demographic parity, and shape-preserving transport:\n", + "\n", + "$$\n", + "\\min_{P \\in U(r,c)} \\langle C, P \\rangle\n", + "\\quad \\text{subject to} \\quad\n", + "\\langle D_k, P \\rangle \\geq 0,\\; k=1,\\ldots,K\n", + "\\qquad\n", + "\\langle D_\\ell, P \\rangle = 0,\\; \\ell=1,\\ldots,L.\n", + "$$\n", + "\n", + "Each constraint matrix $D_k \\in \\mathbb{R}^{n \\times m}$ encodes a statistical condition on the coupling $P$. For example, setting $D_k = (\\text{group A rows}) - (\\text{group B rows})$ encodes a demographic parity requirement.\n", + "\n", + "### 1.3 Entropic Relaxation (Eq. 5)\n", + "\n", + "Direct LP solvers scale as $O(n^3)$. The paper instead uses an **entropic relaxation** that introduces slack variables $s_k \\geq 0$ for each inequality:\n", + "\n", + "$$\n", + "\\min_{P, s_1,\\ldots,s_K}\\; \\langle C, P \\rangle + \\frac{1}{\\eta}\\, H(P, s_1, \\ldots, s_K)\n", + "$$\n", + "$$\n", + "\\text{s.t. } D_k \\cdot P = s_k \\;(k=1..K),\\quad D_\\ell \\cdot P = 0 \\;(\\ell=1..L),\n", + "$$\n", + "\n", + "where $H$ is the (negative) joint entropy and $\\eta > 0$ is a sharpness parameter. As $\\eta \\to \\infty$ the solution converges to the LP optimum; small $\\eta$ gives a smoother, more diffuse plan." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 2. Dual Formulation\n", + "\n", + "### 2.1 Dual Variables\n", + "\n", + "Taking Lagrangian duals of the marginal constraints and the linear constraints introduces three sets of dual variables:\n", + "\n", + "| Variable | Shape | Meaning |\n", + "|----------|-------|---------|\n", + "| $x \\in \\mathbb{R}^n$ | $n$ | Row (source) potentials |\n", + "| $y \\in \\mathbb{R}^m$ | $m$ | Column (target) potentials |\n", + "| $a \\in \\mathbb{R}^{K+L}$ | $K+L$ | Constraint dual variables |\n", + "\n", + "### 2.2 The Dual Objective (Eq. 7)\n", + "\n", + "The dual function to **maximise** is:\n", + "\n", + "$$\n", + "f(x,y,a) =\n", + "-\\frac{1}{\\eta}\\sum_{ij} P^{\\circ}_{ij}\n", + "+ \\sum_i x_i r_i + \\sum_j y_j c_j\n", + "-\\frac{1}{\\eta}\\sum_{k=1}^{K} \\exp(-\\eta a_k - 1),\n", + "$$\n", + "\n", + "where the *intermediate transport plan* is\n", + "$$\n", + "P^{\\circ}_{ij} = \\exp\\!\\left(\\eta\\bigl(-C_{ij} + {\\textstyle\\sum_m} a_m (D_m)_{ij}\n", + "+ x_i + y_j\\bigr) - 1\\right).\n", + "$$\n", + "\n", + "The $-1$ exponent normalises the plan so that at optimality $\\sum_{ij} P^{\\circ}_{ij} = \\sum_i r_i = 1$.\n", + "\n", + "### 2.3 Gradients (Eq. 8)\n", + "\n", + "The gradient of $f$ with respect to each block has a clean form:\n", + "\n", + "$$\n", + "\\nabla_x f = r - P^{\\circ}\\mathbf{1}, \\qquad\n", + "\\nabla_y f = c - (P^{\\circ})^\\top\\mathbf{1},\n", + "$$\n", + "\n", + "$$\n", + "\\frac{\\partial f}{\\partial a_k} = \\exp(-\\eta a_k - 1) - \\langle P^{\\circ}, D_k \\rangle\n", + "\\;(\\text{inequality}), \\qquad\n", + "\\frac{\\partial f}{\\partial a_{K+\\ell}} = -\\langle P^{\\circ}, D_\\ell \\rangle\n", + "\\;(\\text{equality}).\n", + "$$\n", + "\n", + "Setting $\\nabla f = 0$ recovers the KKT conditions of the primal problem. Note that $\\nabla_x f = 0 \\Leftrightarrow P^{\\circ}\\mathbf{1} = r$, i.e., the row marginal is satisfied — exactly what a Sinkhorn x-update achieves in one step." + ] + }, + { + "cell_type": "markdown", + "id": "e4be6434", + "metadata": {}, + "source": [ + "## 3. Algorithm 1\n", + "\n", + "### 3.1 High-level Structure\n", + "\n", + "The key insight is that $f$ is **separately concave** in each of $x$, $y$, and $a$, which motivates a block coordinate ascent strategy. However, the $x$ and $y$ updates admit a closed-form (Sinkhorn step), while the $a$-update requires a Newton solve.\n", + "\n", + "```\n", + "Algorithm 1 Constrained Sinkhorn\n", + "─────────────────────────────────────────────────────────────\n", + "Input: C, r, c, {D_k}, {D_ℓ}, η, tol\n", + "Init: x = 0, y = 0, a = 0\n", + "\n", + "repeat\n", + " ┌─ Sinkhorn block (n_sinkhorn steps) ──────────────────\n", + " │ Build C_eff = C − Σ_m a_m D_m\n", + " │ for i in 1..n_sinkhorn:\n", + " │ x ← ε·log r − ε·lse_j[(y_j − C_eff_ij)/ε] (row update)\n", + " │ y ← ε·log c − ε·lse_i[(x_i − C_eff_ij)/ε] (col update)\n", + " └───────────────────────────────────────────────────────\n", + " ┌─ Newton a-update ─────────────────────────────────────\n", + " │ Solve H·Δz = −∇f_aug for Δ(a,t)\n", + " │ a ← a + α·Δa, t ← t + α·Δt\n", + " └───────────────────────────────────────────────────────\n", + " x ← x + t (recentre row potentials)\n", + "until ‖∇f‖₁ < tol\n", + "```\n", + "\n", + "### 3.2 The Sinkhorn Sub-steps\n", + "\n", + "The $x$ and $y$ updates correspond to classical log-domain Sinkhorn scaling on the **effective cost** $C_{\\text{eff}} = C - \\sum_m a_m D_m$. Importantly, the update for $x$ does **not** include $x$ in the LSE — only $y$ appears:\n", + "\n", + "$$\n", + "x_i \\leftarrow \\varepsilon (\\log r_i +1 )- \\varepsilon \\operatorname{lse}_j\n", + "\\!\\left[\\frac{y_j - (C_{\\text{eff}})_{ij}}{\\varepsilon}\\right]\n", + "$$\n", + "\n", + "This *one-sided* form guarantees that after a single $x$-step, $\\sum_j P^{\\text{NO-OFFSET}}_{ij} = r_i$ **exactly**, not just in the limit. (This is the semantics implemented by `Geometry.update_potential` in OTT-JAX.)\n", + "\n", + "### 3.3 The Newton a-update\n", + "\n", + "The constraint dual variables $a$ (and a recentering scalar $t$) are updated by Newton's method on the augmented dual\n", + "\n", + "$$\n", + "f_{\\text{aug}}(a) = \\max_t\\; f(x + t \\cdot \\mathbf{1},\\; y,\\; a).\n", + "$$\n", + "\n", + "The joint $(a,t)$ gradient is:\n", + "\n", + "$$\n", + "\\nabla_a f_{\\text{aug}} \\text{ (see §2.3)}, \\qquad\n", + "\\nabla_t f_{\\text{aug}} = \\sum_i r_i - \\sum_{ij} P^{\\circ}_{ij}.\n", + "$$\n", + "\n", + "The Hessian $H \\in \\mathbb{R}^{(M+1)\\times(M+1)}$ (Eq. 27) is negative semi-definite (concave function), so Newton's method maximises $f_{\\text{aug}}$. After the Newton step, $x \\leftarrow x + t$ recentres the row potentials.\n", + "\n", + "### 3.4 Eta Schedule (Algorithm 3)\n", + "\n", + "High $\\eta$ gives sharp solutions close to the LP optimum but converges slowly. The paper proposes a **doubling schedule**: solve at $\\eta_1 < \\eta_2 < \\cdots$ with warm starts, which dramatically reduces total iterations.\n", + "\n", + "| $\\eta$ level | Purpose |\n", + "|-------------|---------|\n", + "| Small ($\\eta = 2$) | Fast, coarse convergence |\n", + "| Doubling | Progressively sharper plan |\n", + "| Large ($\\eta = 50$) | Near-LP solution |" + ] + }, + { + "cell_type": "markdown", + "id": "218cfec2", + "metadata": {}, + "source": [ + "## 4. Integration with OTT-JAX\n", + "\n", + "We use the `ott.geometry.geometry.Geometry` class as our numerical backend. This decouples the linear-algebra kernel (LSE, cost matrix) from the algorithm logic and enables JAX JIT compilation.\n", + "\n", + "### Notation mapping\n", + "\n", + "| Paper | OTT-JAX `Geometry` | Shape |\n", + "|-------|-------------------|-------|\n", + "| $x$ (row dual) | `f` potential | `(n,)` |\n", + "| $y$ (col dual) | `g` potential | `(m,)` |\n", + "| $\\varepsilon = 1/\\eta$ | `geom.epsilon` | scalar |\n", + "| $C_{\\text{eff}}$ | `geom.cost_matrix` | `(n,m)` |\n", + "| Sinkhorn x-step | `geom.update_potential(f,g,log_r, axis=1)` | |\n", + "| Sinkhorn y-step | `geom.update_potential(f,g,log_c, axis=0)` | |\n", + "\n", + "### Transport plan convention\n", + "\n", + "There are two conventions in play:\n", + "\n", + "- **`P_NO_OFFSET`** $= \\exp(\\text{center}/\\varepsilon)$ — returned by `_transport_plan`; row sums equal $r$ at Sinkhorn convergence.\n", + "- **`P_paper`** $= \\exp(\\text{center}/\\varepsilon - 1)$ — the paper's plan used in the dual objective and the Newton a-update.\n", + "\n", + "The $-1$ offset appears **only** in `_dual_obj_and_grad` and `_a_update`. At optimality, the Newton step drives $t \\to 1/\\eta$ which makes $P^{\\circ}\\mathbf{1} = r$ as well.\n", + "\n", + "### Fallback geometry\n", + "\n", + "When OTT-JAX is not available, `_FallbackGeometry` provides an identical NumPy/SciPy implementation. This lets the code run in any environment without a JAX installation." + ] + }, + { + "cell_type": "markdown", + "id": "bbcf0e01", + "metadata": {}, + "source": [ + "## 5. Implementation\n", + "\n", + "### 5.1 Imports\n", + "\n", + "Standard scientific stack plus an optional OTT-JAX import." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "72234a0d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OTT-JAX available — using JAX backend\n" + ] + } + ], + "source": [ + "from __future__ import annotations\n", + "import numpy as np\n", + "from scipy.special import logsumexp as sp_lse\n", + "from scipy.linalg import solve as sp_solve, LinAlgError\n", + "from dataclasses import dataclass\n", + "from typing import Optional\n", + "\n", + "try:\n", + " import jax.numpy as jnp\n", + " from ott.geometry.geometry import Geometry\n", + " _OTT_AVAILABLE = True\n", + " print('OTT-JAX available — using JAX backend')\n", + "except ImportError:\n", + " _OTT_AVAILABLE = False\n", + " print('OTT-JAX not found — using NumPy fallback')\n" + ] + }, + { + "cell_type": "markdown", + "id": "5f29fa7e", + "metadata": {}, + "source": [ + "### 5.2 Part 1 — Core Building Blocks\n", + "\n", + "This cell implements five components:\n", + "\n", + "1. **`_FallbackGeometry`** — NumPy drop-in for `ott.geometry.Geometry`. Its `update_potential` uses a *one-sided* LSE: when updating $x$, only $y$ appears in the sum (not $x$ itself). This is the mathematically correct Sinkhorn step and matches OTT-JAX's implementation.\n", + "\n", + "2. **`_make_effective_geom(C, D_list, a, η)`** — Builds a Geometry with effective cost $C_{\\text{eff}} = C - \\sum_m a_m D_m$. This is called at every outer iteration when $a$ changes.\n", + "\n", + "3. **`_transport_plan(geom, x, y)`** — Returns $P_{\\text{NO-OFFSET}} = \\exp(\\text{center}/\\varepsilon)$ (no $-1$). Row sums equal $r$ at Sinkhorn convergence.\n", + "\n", + "4. **`_dual_obj_and_grad(C, D_ineq, D_eq, r, c, η, x, y, a)`** — Evaluates $f(x,y,a)$ and all three gradient blocks. This is the **only** place $P^{\\circ} = \\exp(\\text{center}/\\varepsilon - 1)$ is used.\n", + "\n", + "5. **`_x_update` / `_y_update`** — Thin wrappers around `geom.update_potential` that enforce the correct axis and pass $\\log r$ or $\\log c$." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "473cabda", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cell 2 _make_effective_geom: OK\n", + "Cell 3 _transport_plan: OK (sum P=2.8573)\n", + "Cell 4 _dual_obj_and_grad: OK (f=-0.3225, |ga|=3.5546e-01)\n", + "Cell 5 _x/_y_update: OK (row err=7.89e-08, col err=5.49e-08 after 500 steps)\n", + "\n", + "All Part 1 self-tests passed.\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "==============================\n", + "Part 1 — Core building blocks for Algorithm 1 of\n", + "\"A Sinkhorn-type Algorithm for Constrained Optimal Transport\"\n", + "\n", + "Sinkhorn update convention\n", + "--------------------------\n", + "Standard log-domain Sinkhorn alternates:\n", + "\n", + " x_i ← ε·log r_i − ε·lse_j[(y_j − C_ij)/ε] (row update)\n", + " y_j ← ε·log c_j − ε·lse_i[(x_i − C_ij)/ε] (col update)\n", + "\n", + "After an x-update: sum_j exp((x_i + y_j − C_ij)/ε) = r_i exactly.\n", + "This is the form OTT-JAX's Geometry.update_potential implements:\n", + " new_f = ε·log_marginal − apply_lse_kernel(g_only, C, ε, axis=1)\n", + "where the LSE over j uses ONLY g (not f).\n", + "\n", + "Transport plan convention\n", + "-------------------------\n", + "_transport_plan returns P_NO_OFFSET = exp(center/ε)\n", + "where center_ij = x_i + y_j − C_eff_ij. Its row sums equal r at convergence.\n", + "\n", + "The paper's plan P_paper = exp(center/ε − 1) = e^{-1}·P_NO_OFFSET\n", + "is used ONLY inside _dual_obj_and_grad (for f(x,y,a) and ∇f).\n", + "The t variable in the a-update re-normalises P_paper back to sum = Σr.\n", + "\n", + "Cells:\n", + " 1. Imports\n", + " 2. _make_effective_geom -- effective cost + Geometry factory\n", + " 3. _transport_plan -- P_NO_OFFSET = exp(center/ε)\n", + " 4. _dual_obj_and_grad -- f(x,y,a) and ∇f using P_paper\n", + " 5. _x_update / _y_update -- standard log-Sinkhorn steps\n", + "\"\"\"\n", + "\n", + "from __future__ import annotations\n", + "\n", + "# ── Cell 1: Imports ─────────────────────────────────────────────────────────────\n", + "import numpy as np\n", + "from scipy.special import logsumexp as sp_lse\n", + "\n", + "try:\n", + " import jax.numpy as jnp # noqa: F401 — available to callers if present\n", + "except ImportError:\n", + " pass\n", + "\n", + "try:\n", + " from ott.geometry.geometry import Geometry # type: ignore\n", + " _OTT_AVAILABLE = True\n", + "except ImportError:\n", + " _OTT_AVAILABLE = False\n", + "\n", + "\n", + "# ── Cell 2: Geometry factory ─────────────────────────────────────────────────────\n", + "\n", + "class _FallbackGeometry:\n", + " \"\"\"\n", + " Drop-in for ott.geometry.geometry.Geometry when OTT-JAX is not installed.\n", + "\n", + " Implements the exact API used by the algorithm:\n", + " _center(f, g) → f_i + g_j − C_ij\n", + " apply_lse_kernel(f, g, eps, axis) → ε·LSE along axis\n", + " update_potential(f, g, log_marg, axis) → standard log-Sinkhorn step\n", + "\n", + " update_potential semantics (matching OTT-JAX):\n", + " axis=1 → new_f_i = ε·log_r_i − ε·lse_j[(g_j − C_ij)/ε]\n", + " axis=0 → new_g_j = ε·log_c_j − ε·lse_i[(f_i − C_ij)/ε]\n", + "\n", + " The potential being UPDATED does not appear in the LSE.\n", + " This is the standard Sinkhorn scaling in log-domain and guarantees\n", + " that after each step the corresponding marginal of P equals the target.\n", + " \"\"\"\n", + "\n", + " def __init__(self, cost_matrix: np.ndarray, epsilon: float):\n", + " self.cost_matrix = np.asarray(cost_matrix, np.float64)\n", + " self.epsilon = float(epsilon)\n", + "\n", + " def _center(self, f: np.ndarray, g: np.ndarray) -> np.ndarray:\n", + " \"\"\"f_i + g_j − C_ij (identical to OTT-JAX Geometry._center)\"\"\"\n", + " return f[:, None] + g[None, :] - self.cost_matrix\n", + "\n", + " def apply_lse_kernel(\n", + " self,\n", + " f: np.ndarray,\n", + " g: np.ndarray,\n", + " eps: float,\n", + " vec=None,\n", + " axis: int = 0,\n", + " ) -> tuple:\n", + " \"\"\"\n", + " axis=1 → result_i = ε·logsumexp_j[(f_i + g_j − C_ij)/ε]\n", + " axis=0 → result_j = ε·logsumexp_i[(f_i + g_j − C_ij)/ε]\n", + " Returns (lse_scaled, signs) matching OTT-JAX convention.\n", + " Used for diagnostics and the dual objective; NOT used inside\n", + " update_potential (which uses a one-sided lse for correctness).\n", + " \"\"\"\n", + " M = self._center(f, g) / eps\n", + " if vec is None:\n", + " lse = sp_lse(M, axis=axis)\n", + " else:\n", + " b = vec[:, None] if axis == 0 else vec[None, :]\n", + " lse = sp_lse(M, b=b, axis=axis)\n", + " return eps * lse, np.ones_like(lse)\n", + "\n", + " def update_potential(\n", + " self,\n", + " f: np.ndarray,\n", + " g: np.ndarray,\n", + " log_marginal: np.ndarray,\n", + " iteration=None, # unused; present for OTT-JAX API compatibility\n", + " axis: int = 0,\n", + " ) -> np.ndarray:\n", + " \"\"\"\n", + " Standard log-domain Sinkhorn update.\n", + "\n", + " axis=1 → new_f_i = ε·log_r_i − ε·lse_j[(g_j − C_ij)/ε]\n", + " axis=0 → new_g_j = ε·log_c_j − ε·lse_i[(f_i − C_ij)/ε]\n", + "\n", + " The potential being updated (f for axis=1, g for axis=0) does NOT\n", + " appear in the LSE — only the OTHER potential does. This ensures:\n", + " sum_j exp((f_new_i + g_j − C_ij)/ε) = r_i (after axis=1 step)\n", + " sum_i exp((f_i + g_new_j − C_ij)/ε) = c_j (after axis=0 step)\n", + " \"\"\"\n", + " eps = self.epsilon\n", + " C = self.cost_matrix\n", + "\n", + " if axis == 1:\n", + " # Update f: lse only over g (columns)\n", + " g_np = np.asarray(g, np.float64)\n", + " # M_ij = (g_j - C_ij) / eps — no f dependence\n", + " M = (g_np[None, :] - C) / eps\n", + " lse_j = eps * sp_lse(M, axis=1) # shape (n,)\n", + " return eps * log_marginal - lse_j\n", + " else:\n", + " # Update g: lse only over f (rows)\n", + " f_np = np.asarray(f, np.float64)\n", + " # M_ij = (f_i - C_ij) / eps — no g dependence\n", + " M = (f_np[:, None] - C) / eps\n", + " lse_i = eps * sp_lse(M, axis=0) # shape (m,)\n", + " return eps * log_marginal - lse_i\n", + "\n", + "\n", + "def _make_effective_geom(\n", + " C: np.ndarray,\n", + " D_list: list,\n", + " a: np.ndarray,\n", + " eta: float,\n", + "):\n", + " \"\"\"\n", + " Build a Geometry with effective cost C_eff = C − Σ_m a_m·D_m.\n", + "\n", + " Constraint dual variables shift the transport kernel:\n", + " P_NO_OFFSET_ij = exp(η(x_i + y_j − C_eff_ij))\n", + "\n", + " Geometry uses ε = 1/η so that center/ε = η·center.\n", + " \"\"\"\n", + " C_eff = np.array(C, dtype=np.float64) # works on both np and jax arrays\n", + " a_np = np.asarray(a, dtype=np.float64)\n", + " for a_m, D_m in zip(a_np, D_list):\n", + " C_eff -= float(a_m) * np.asarray(D_m, np.float64)\n", + "\n", + " eps = 1.0 / float(eta)\n", + " if _OTT_AVAILABLE:\n", + " return Geometry(cost_matrix=C_eff, epsilon=eps)\n", + " return _FallbackGeometry(C_eff, eps)\n", + "\n", + "\n", + "# ── Cell 3: Transport plan ───────────────────────────────────────────────────────\n", + "\n", + "def _transport_plan(geom, x: np.ndarray, y: np.ndarray, eta: float) -> np.ndarray:\n", + " \"\"\"\n", + " Returns the paper's transport plan:\n", + " P_ij = exp((x_i + y_j − C_eff_ij) / ε − 1)\n", + "\n", + " After a correct x-update or y-update, P·1 = r and Pᵀ·1 = c exactly.\n", + " eta is passed explicitly and never read from geom.epsilon (OTT schedules it).\n", + " \"\"\"\n", + " eps = 1.0 / float(eta)\n", + " center = geom._center(np.asarray(x, np.float64), np.asarray(y, np.float64))\n", + " return np.exp(np.clip(np.asarray(center) / eps - 1.0, -500.0, 500.0))\n", + "\n", + "\n", + "# ── Cell 4: Dual objective and gradients ─────────────────────────────────────────\n", + "\n", + "def _dual_obj_and_grad(\n", + " C: np.ndarray,\n", + " D_ineq: list,\n", + " D_eq: list,\n", + " r: np.ndarray,\n", + " c: np.ndarray,\n", + " eta: float,\n", + " x: np.ndarray,\n", + " y: np.ndarray,\n", + " a: np.ndarray,\n", + ") -> tuple:\n", + " \"\"\"\n", + " Computes f(x, y, a) and gradients ∇_x f, ∇_y f, ∂_a f.\n", + "\n", + " Uses P_paper = exp(center/ε − 1) [paper eq. 7].\n", + " This is the ONLY place the −1 offset is applied.\n", + "\n", + " Paper eq. (7):\n", + " f = −1/η Σ_ij P_paper_ij\n", + " + Σ_i x_i r_i + Σ_j y_j c_j\n", + " − 1/η Σ_{k=1}^K exp(−η a_k − 1)\n", + "\n", + " Gradients (paper eq. 8):\n", + " ∇_x f = r − P_paper·1\n", + " ∇_y f = c − P_paper^T·1\n", + " ∂_{a_k} f = exp(−η a_k − 1) − P_paper·D_k (ineq. k=1..K)\n", + " ∂_{a_{K+l}} f = −P_paper·D_{K+l} (eq. l=1..L)\n", + " \"\"\"\n", + " D_all = D_ineq + D_eq\n", + " K = len(D_ineq)\n", + " C_np = np.asarray(C, np.float64)\n", + " r_np = np.asarray(r, np.float64)\n", + " c_np = np.asarray(c, np.float64)\n", + " x_np = np.asarray(x, np.float64)\n", + " y_np = np.asarray(y, np.float64)\n", + " a_np = np.asarray(a, np.float64)\n", + " D_all_np = [np.asarray(D, np.float64) for D in D_all]\n", + " D_ineq_np = D_all_np[:K]\n", + "\n", + " geom = _make_effective_geom(C_np, D_all_np, a_np, eta)\n", + " eps = 1.0 / float(eta) # never read geom.epsilon (OTT schedules it)\n", + " center = geom._center(x_np, y_np)\n", + "\n", + " # P_paper: the −1 offset appears here and nowhere else in the codebase\n", + " P_paper = np.exp(np.clip(center / eps - 1.0, -500.0, 500.0))\n", + "\n", + " P1 = P_paper.sum(axis=1)\n", + " PT1 = P_paper.sum(axis=0)\n", + "\n", + " slack_sum = sum(\n", + " np.exp(np.clip(-eta * float(a_np[k]) - 1.0, -500.0, 500.0))\n", + " for k in range(K)\n", + " )\n", + " f_val = (\n", + " -np.sum(P_paper) / eta\n", + " + float(np.dot(x_np, r_np))\n", + " + float(np.dot(y_np, c_np))\n", + " - slack_sum / eta\n", + " )\n", + "\n", + " grad_x = r_np - P1\n", + " grad_y = c_np - PT1\n", + "\n", + " # Build as list to avoid JAX immutable-array item-assignment\n", + " grad_a_list: list = []\n", + " for k in range(K):\n", + " s_k = np.exp(np.clip(-eta * float(a_np[k]) - 1.0, -500.0, 500.0))\n", + " grad_a_list.append(float(s_k - np.sum(P_paper * D_ineq_np[k])))\n", + " for l in range(len(D_eq)):\n", + " grad_a_list.append(float(-np.sum(P_paper * D_all_np[K + l])))\n", + " grad_a = np.array(grad_a_list, dtype=np.float64)\n", + "\n", + " return float(f_val), grad_x, grad_y, grad_a\n", + "\n", + "\n", + "# ── Cell 5: x-update and y-update ───────────────────────────────────────────────\n", + "\n", + "def _x_update(geom, x: np.ndarray, y: np.ndarray, r: np.ndarray,\n", + " eta: float) -> np.ndarray:\n", + " \"\"\"\n", + " Row-scaling Sinkhorn step [Algorithm 1, line 6]:\n", + "\n", + " x ← x + (log r − log(P·1)) / η\n", + "\n", + " Expanding (the old x cancels out), this is the closed-form:\n", + "\n", + " x_new_i = ε·(log r_i + 1) − ε·lse_j[(y_j − C_eff_ij)/ε]\n", + "\n", + " The +1 inside the log comes from the paper's P_paper = exp(center/ε − 1):\n", + " after this update, P_paper·1 = r exactly (row marginal satisfied for P_paper).\n", + "\n", + " We implement it via update_potential(log_r + 1, ...) because\n", + " update_potential computes ε·log_marginal − ε·lse(...)\n", + " so passing (log_r + 1) gives ε·log_r + ε − ε·lse(...).\n", + " \"\"\"\n", + " log_r = np.where(r > 0, np.log(np.clip(r, 1e-300, None)), -np.inf)\n", + " return geom.update_potential(\n", + " np.asarray(x, np.float64), np.asarray(y, np.float64), log_r + 1.0, axis=1\n", + " )\n", + "\n", + "\n", + "def _y_update(geom, x: np.ndarray, y: np.ndarray, c: np.ndarray,\n", + " eta: float) -> np.ndarray:\n", + " \"\"\"\n", + " Column-scaling Sinkhorn step [Algorithm 1, line 8]:\n", + "\n", + " y ← y + (log c − log(Pᵀ·1)) / η\n", + "\n", + " Expanding: y_new_j = ε·(log c_j + 1) − ε·lse_i[(x_i − C_eff_ij)/ε]\n", + "\n", + " After this update, P_paper^T·1 = c exactly (col marginal for P_paper).\n", + " \"\"\"\n", + " log_c = np.where(c > 0, np.log(np.clip(c, 1e-300, None)), -np.inf)\n", + " return geom.update_potential(\n", + " np.asarray(x, np.float64), np.asarray(y, np.float64), log_c + 1.0, axis=0\n", + " )\n", + "\n", + "\n", + "# ── Quick self-test ──────────────────────────────────────────────────────────────\n", + "\n", + "def _selftest():\n", + " rng = np.random.default_rng(0)\n", + " n = 8\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " DE = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + " eta = 10.0\n", + " a = np.zeros(2)\n", + " x = np.zeros(n)\n", + " y = np.zeros(n)\n", + "\n", + " # Cell 2\n", + " geom = _make_effective_geom(C, [DI, DE], a, eta)\n", + " assert hasattr(geom, \"_center\")\n", + " print(\"Cell 2 _make_effective_geom: OK\")\n", + "\n", + " # Cell 3\n", + " P = _transport_plan(geom, x, y, eta)\n", + " assert P.shape == (n, n) and np.all(P > 0)\n", + " print(f\"Cell 3 _transport_plan: OK (sum P={P.sum():.4f})\")\n", + "\n", + " # Cell 4\n", + " f_val, gx, gy, ga = _dual_obj_and_grad(C, [DI], [DE], r, c, eta, x, y, a)\n", + " assert ga.shape == (2,) and not np.all(ga == 0)\n", + " print(f\"Cell 4 _dual_obj_and_grad: OK (f={f_val:.4f}, |ga|={np.abs(ga).sum():.4e})\")\n", + "\n", + " # Cell 5: Sinkhorn must converge P_NO_OFFSET.sum(1) → r\n", + " # Use NO constraint matrices so C_eff = C is constant\n", + " geom_bare = _make_effective_geom(C, [], np.array([]), eta)\n", + " x2, y2 = np.zeros(n), np.zeros(n)\n", + " for _ in range(500):\n", + " x2 = _x_update(geom_bare, x2, y2, r, eta)\n", + " y2 = _y_update(geom_bare, x2, y2, c, eta)\n", + " P2 = _transport_plan(geom_bare, x2, y2, eta)\n", + " row_err = float(np.abs(P2.sum(1) - r).sum())\n", + " col_err = float(np.abs(P2.sum(0) - c).sum())\n", + " assert row_err < 1e-7, f\"Row marginal not converging: {row_err:.2e}\"\n", + " assert col_err < 1e-7, f\"Col marginal not converging: {col_err:.2e}\"\n", + " print(f\"Cell 5 _x/_y_update: OK \"\n", + " f\"(row err={row_err:.2e}, col err={col_err:.2e} after 500 steps)\")\n", + "\n", + " print(\"\\nAll Part 1 self-tests passed.\")\n", + "\n", + "\n", + "_selftest()\n" + ] + }, + { + "cell_type": "markdown", + "id": "ff70ab7f", + "metadata": {}, + "source": [ + "### 5.3 Part 2 — Newton a-update, Rounding, and Main Solver\n", + "\n", + "This cell implements four more components:\n", + "\n", + "1. **`_compute_hessian_a(P_paper, D_ineq, D_eq, a, η)`** — Assembles the $M \\times M$ Hessian of $f_{\\text{aug}}$ w.r.t. $a$ (paper Eq. 27). Takes $P^{\\circ}$ (with $-1$ offset) as input. All eigenvalues are $\\leq 0$ (concave), confirming Newton ascent is valid.\n", + "\n", + "2. **`_a_update(C, D_ineq, D_eq, r, c, η, x, y, a)`** — Newton's method on the joint $(a, t)$ variable. Key details: (i) $P^{\\circ}$ is recomputed at each Newton step; (ii) $\\nabla_t = \\sum r - \\sum P^{\\circ}$ (NOT $\\sum P_{\\text{NO-OFFSET}}$); (iii) an Armijo backtracking line search ensures the dual objective increases; (iv) adaptive Tikhonov regularisation stabilises the Hessian solve.\n", + "\n", + "3. **`_round_transport(P, r, c)`** — Altschuler et al. (2017) rounding that projects any non-negative matrix onto $U(r,c)$ in two scaling steps plus a rank-1 correction.\n", + "\n", + "4. **`constrained_sinkhorn(...)`** — Main solver. Each outer iteration runs `n_sinkhorn` Sinkhorn sub-steps, then one Newton a-update, then shifts $x \\leftarrow x + t$. Convergence is declared when $\\|\\nabla f\\|_1 < \\text{tol}$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "12d3a224", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Cell 6 _compute_hessian_a: OK (eigs=[-1.84232071 -0.00305039])\n", + "Cell 7 _a_update: OK (a=[ 0.992 -0.479], t=-0.4630)\n", + "Cell 8 _round_transport: OK (row err=1.39e-17)\n", + "Cell 9 constrained_sinkhorn: OK (cost=0.2279, viol=5.13e-09, converged=True, iters=10)\n", + "\n", + "All Part 2 self-tests passed.\n" + ] + } + ], + "source": [ + "\"\"\"\n", + "==============================\n", + "Part 2 — a-update, rounding, and main solver for Algorithm 1 of\n", + "\"A Sinkhorn-type Algorithm for Constrained Optimal Transport\"\n", + "\n", + "P_paper vs P_NO_OFFSET convention (see Part 1 docstring)\n", + "---------------------------------------------------------\n", + "_transport_plan returns P_NO_OFFSET = exp(center/ε) (no -1).\n", + "Inside _a_update and _compute_hessian_a we need the PAPER's plan:\n", + " P_paper = exp(-1) · P_NO_OFFSET\n", + "because the paper's grad_t and Hessian are derived from f(x+t·1, y, a)\n", + "which uses P_paper. Concretely:\n", + " grad_t = Σr − Σ_ij P_paper_ij = Σr − e^{-1}·Σ P_NO_OFFSET\n", + "\n", + "The a-update initialises t=0 and drives t → 1/η, which makes P_paper.1 = r.\n", + "\n", + "Cells:\n", + " 6. _compute_hessian_a -- Hessian of f_aug w.r.t. (a, t)\n", + " 7. _a_update -- Newton maximisation of f_aug over (a, t)\n", + " 8. _round_transport -- Altschuler et al. 2017 rounding\n", + " 9. constrained_sinkhorn -- Algorithm 1 main solver\n", + "\"\"\"\n", + "\n", + "from __future__ import annotations\n", + "\n", + "from dataclasses import dataclass\n", + "from typing import Optional\n", + "from scipy.linalg import solve as sp_solve, LinAlgError\n", + "\n", + "import numpy as np\n", + "\n", + "\n", + "\n", + "# ── Cell 6: Hessian of f_aug w.r.t. (a, t) ────────────────────────────────────\n", + "\n", + "def _compute_hessian_a(\n", + " P_paper: np.ndarray,\n", + " D_ineq: list,\n", + " D_eq: list,\n", + " a: np.ndarray,\n", + " eta: float,\n", + ") -> np.ndarray:\n", + " \"\"\"\n", + " M×M Hessian of f_aug w.r.t. a (paper eq. 27).\n", + "\n", + " Takes P_paper = exp(center/ε − 1) [with the -1 offset].\n", + "\n", + " ∂²_{a_m a_{m'}} f_aug\n", + " = −η (D_m ⊙ D_{m'}) · P̂\n", + " + η (P̂·D_m)(P̂·D_{m'})\n", + " + s_{mm'}\n", + "\n", + " where P̂ = P_paper / Σ P_paper and\n", + " s_{kk} = −η exp(−η a_k − 1) for k ≤ K, else 0.\n", + " \"\"\"\n", + " D_all = D_ineq + D_eq\n", + " M = len(D_all)\n", + " K = len(D_ineq)\n", + " P_sum = max(float(np.sum(P_paper)), 1e-300)\n", + " P_norm = P_paper / P_sum # P̂\n", + "\n", + " H = np.zeros((M, M), dtype=np.float64)\n", + " for m in range(M):\n", + " for mp in range(M):\n", + " cov = -eta * float(np.sum(D_all[m] * D_all[mp] * P_norm))\n", + " outer = eta * float(np.sum(P_norm * D_all[m])) \\\n", + " * float(np.sum(P_norm * D_all[mp]))\n", + " H[m, mp] = cov + outer\n", + "\n", + " for k in range(K):\n", + " H[k, k] -= eta * np.exp(np.clip(-eta * float(a[k]) - 1.0, -500.0, 500.0))\n", + "\n", + " return H\n", + "\n", + "\n", + "# ── Cell 7: a-update via Newton on (a, t) ─────────────────────────────────────\n", + "\n", + "def _a_update(\n", + " C: np.ndarray,\n", + " D_ineq: list,\n", + " D_eq: list,\n", + " r: np.ndarray,\n", + " c: np.ndarray,\n", + " eta: float,\n", + " x: np.ndarray,\n", + " y: np.ndarray,\n", + " a: np.ndarray,\n", + " n_newton: int = 5,\n", + " line_search_beta: float = 0.5,\n", + " line_search_max: int = 20,\n", + ") -> tuple:\n", + " \"\"\"\n", + " Newton maximisation of f_aug(a, t) = max_t f(x + t·1, y, a)\n", + " over joint variable z = (a, t). [Algorithm 1, lines 10-11]\n", + "\n", + " All quantities computed here use P_paper = exp(center/ε − 1).\n", + " In particular:\n", + " grad_t = Σr − Σ P_paper (NOT Σ P_NO_OFFSET)\n", + " H_tt = −η Σ P_paper\n", + " H_at_m = −η Σ P_paper · D_m\n", + "\n", + " Returns (a_new, t) where the caller does x ← x + t.\n", + " \"\"\"\n", + " D_all = D_ineq + D_eq\n", + " K = len(D_ineq)\n", + " M = len(D_all)\n", + "\n", + " a = np.array(a, dtype=np.float64)\n", + " t = 0.0\n", + "\n", + " for _ in range(n_newton):\n", + " x_t = x + t\n", + " geom = _make_effective_geom(C, D_all, a, eta)\n", + "\n", + " # P_paper: use -1 offset (paper convention)\n", + " eps = 1.0 / float(eta) # never read geom.epsilon (OTT schedules it)\n", + " center = geom._center(np.asarray(x_t, np.float64),\n", + " np.asarray(y, np.float64))\n", + " P_paper = np.exp(np.clip(center / eps - 1.0, -500.0, 500.0))\n", + " P_sum = max(float(np.sum(P_paper)), 1e-300)\n", + "\n", + " # gradient w.r.t. a (eq. 8, using P_paper)\n", + " grad_a = np.zeros(M, dtype=np.float64)\n", + " for k in range(K):\n", + " s_k = np.exp(np.clip(-eta * float(a[k]) - 1.0, -500.0, 500.0))\n", + " grad_a[k] = s_k - float(np.sum(P_paper * D_ineq[k]))\n", + " for l in range(len(D_eq)):\n", + " grad_a[K + l] = -float(np.sum(P_paper * D_eq[l]))\n", + "\n", + " # gradient w.r.t. t (eq. 9: Σ P_paper = Σ r)\n", + " grad_t = float(np.sum(r)) - P_sum\n", + " grad_full = np.append(grad_a, grad_t)\n", + "\n", + " if np.max(np.abs(grad_full)) < 1e-12:\n", + " break\n", + "\n", + " # Hessian (M+1)×(M+1)\n", + " H_aa = _compute_hessian_a(P_paper, D_ineq, D_eq, a, eta)\n", + " H_tt = -eta * P_sum\n", + " H_at = np.array([-eta * float(np.sum(P_paper * D_all[m]))\n", + " for m in range(M)], dtype=np.float64)\n", + "\n", + " H_full = np.zeros((M + 1, M + 1), dtype=np.float64)\n", + " H_full[:M, :M] = H_aa\n", + " H_full[:M, M] = H_at\n", + " H_full[ M, :M] = H_at\n", + " H_full[ M, M] = H_tt\n", + "\n", + " # Adaptive Tikhonov regularisation (scales with ||H||_inf)\n", + " reg = max(1e-4 * float(np.abs(H_full).max()), 1e-6)\n", + " H_reg = H_full - reg * np.eye(M + 1)\n", + "\n", + " try:\n", + " delta = sp_solve(H_reg, -grad_full)\n", + " except (LinAlgError, ValueError):\n", + " delta = -grad_full\n", + "\n", + " # Clip step to unit norm at early iterations\n", + " d_norm = float(np.linalg.norm(delta))\n", + " if d_norm > 1.0:\n", + " delta /= d_norm\n", + "\n", + " # Backtracking line search (Armijo sufficient-increase for maximisation)\n", + " armijo_slope = 1e-4 * float(np.dot(grad_full, delta))\n", + " alpha = 1.0\n", + " f0, _, _, _ = _dual_obj_and_grad(C, D_ineq, D_eq, r, c, eta, x_t, y, a)\n", + "\n", + " for _ in range(line_search_max):\n", + " a_try = a + alpha * delta[:M]\n", + " t_try = t + alpha * float(delta[M])\n", + " x_try = x + t_try\n", + " f_try, _, _, _ = _dual_obj_and_grad(\n", + " C, D_ineq, D_eq, r, c, eta, x_try, y, a_try)\n", + " if f_try >= f0 + alpha * armijo_slope:\n", + " break\n", + " alpha *= line_search_beta\n", + "\n", + " a = a + alpha * delta[:M]\n", + " t = t + alpha * float(delta[M])\n", + "\n", + " return a, float(t)\n", + "\n", + "\n", + "# ── Cell 8: Altschuler et al. 2017 rounding ───────────────────────────────────\n", + "\n", + "def _round_transport(\n", + " P: np.ndarray,\n", + " r: np.ndarray,\n", + " c: np.ndarray,\n", + ") -> np.ndarray:\n", + " \"\"\"\n", + " Projects P onto U(r,c) using the Altschuler et al. (2017) algorithm.\n", + "\n", + " Step 1: row-clip scaling x_i = min(r_i / (P1)_i, 1)\n", + " Step 2: col-clip scaling y_j = min(c_j / (P^T1)_j, 1)\n", + " Step 3: rank-1 residual correction (non-negative because err_r,c ≥ 0)\n", + "\n", + " Output satisfies Q1=r, Q^T1=c, Q≥0.\n", + " \"\"\"\n", + " P = np.array(P, dtype=np.float64)\n", + "\n", + " row_sum = P.sum(axis=1)\n", + " row_scale = np.where(row_sum > 0, np.minimum(r / row_sum, 1.0), 1.0)\n", + " P *= row_scale[:, None]\n", + "\n", + " col_sum = P.sum(axis=0)\n", + " col_scale = np.where(col_sum > 0, np.minimum(c / col_sum, 1.0), 1.0)\n", + " P *= col_scale[None, :]\n", + "\n", + " err_r = r - P.sum(axis=1)\n", + " err_c = c - P.sum(axis=0)\n", + " total = float(err_r.sum())\n", + " if total > 1e-15:\n", + " P += np.outer(err_r, err_c) / total\n", + "\n", + " return np.clip(P, 0.0, None)\n", + "\n", + "\n", + "# ── Cell 9: Main solver — Algorithm 1 ────────────────────────────────────────\n", + "\n", + "@dataclass\n", + "class ConstrainedSinkhornResult:\n", + " \"\"\"Output of the constrained Sinkhorn solver.\"\"\"\n", + " transport: np.ndarray\n", + " x: np.ndarray\n", + " y: np.ndarray\n", + " a: np.ndarray\n", + " dual_obj_history: list\n", + " cost: float\n", + " constraint_violation: float\n", + " converged: bool\n", + " n_iter: int\n", + "\n", + "\n", + "def constrained_sinkhorn(\n", + " C: np.ndarray,\n", + " r: np.ndarray,\n", + " c: np.ndarray,\n", + " D_ineq: Optional[list] = None,\n", + " D_eq: Optional[list] = None,\n", + " eta: float = 10.0,\n", + " max_iter: int = 100,\n", + " n_sinkhorn: int = 10,\n", + " n_newton: int = 5,\n", + " tol: float = 1e-6,\n", + " verbose: bool = False,\n", + " x0: Optional[np.ndarray] = None,\n", + " y0: Optional[np.ndarray] = None,\n", + " a0: Optional[np.ndarray] = None,\n", + ") -> ConstrainedSinkhornResult:\n", + " \"\"\"\n", + " Algorithm 1: Sinkhorn-type solver for linearly constrained OT.\n", + "\n", + " Solves:\n", + " min_{P ∈ U(r,c)} \n", + " s.t. D_k · P ≥ 0 (k = 1..K)\n", + " D_l · P = 0 (l = 1..L)\n", + "\n", + " Per outer iteration:\n", + " 1. n_sinkhorn Sinkhorn sub-steps via Geometry.update_potential\n", + " 2. Newton a-update over (a, t)\n", + " 3. x ← x + t\n", + " \"\"\"\n", + " C = np.asarray(C, np.float64)\n", + " r = np.asarray(r, np.float64)\n", + " c = np.asarray(c, np.float64)\n", + " D_ineq = [np.asarray(D, np.float64) for D in (D_ineq or [])]\n", + " D_eq = [np.asarray(D, np.float64) for D in (D_eq or [])]\n", + " K, L = len(D_ineq), len(D_eq)\n", + " n = C.shape[0]\n", + "\n", + " # Normalise to ||D_k||_inf ≤ 1 (Theorem 1 assumption)\n", + " def _norm(Ds):\n", + " return [D / max(float(np.max(np.abs(D))), 1.0) for D in Ds]\n", + " D_ineq_n = _norm(D_ineq)\n", + " D_eq_n = _norm(D_eq)\n", + " D_all_n = D_ineq_n + D_eq_n\n", + "\n", + " x = np.zeros(n) if x0 is None else np.asarray(x0, np.float64).copy()\n", + " y = np.zeros(n) if y0 is None else np.asarray(y0, np.float64).copy()\n", + " a = np.zeros(K+L) if a0 is None else np.asarray(a0, np.float64).copy()\n", + "\n", + " log_r = np.log(np.clip(r, 1e-300, None))\n", + " log_c = np.log(np.clip(c, 1e-300, None))\n", + "\n", + " dual_history: list = []\n", + " grad_norm = np.inf\n", + " it = 0\n", + "\n", + " if verbose:\n", + " print(f\"{'iter':>5} {'cost':>12} {'row err':>10} \"\n", + " f\"{'col err':>10} {'viol':>10} {'|∇f|':>10}\")\n", + " print(\"─\" * 65)\n", + "\n", + " for it in range(max_iter):\n", + "\n", + " # ── Build geometry once: C_eff = C - Σ a_m D_m ─────────────────────\n", + " geom = _make_effective_geom(C, D_all_n, a, eta)\n", + "\n", + " # ── n_sinkhorn Sinkhorn sub-steps ──────────────────────\n", + " for _ in range(n_sinkhorn):\n", + " x = _x_update(geom, x, y, r, eta)\n", + " y = _y_update(geom, x, y, c, eta)\n", + "\n", + " # ── a-update + t-absorption ──────────────────────────\n", + " if K + L > 0:\n", + " a, t = _a_update(C, D_ineq_n, D_eq_n, r, c, eta, x, y, a,\n", + " n_newton=n_newton)\n", + " x = x + t\n", + "\n", + " # ── Diagnostics (use P_NO_OFFSET for marginal errors and cost) ───────\n", + " geom_d = _make_effective_geom(C, D_all_n, a, eta)\n", + " P_raw = _transport_plan(geom_d, x, y, eta) # P_NO_OFFSET\n", + "\n", + " row_err = float(np.abs(P_raw.sum(1) - r).sum())\n", + " col_err = float(np.abs(P_raw.sum(0) - c).sum())\n", + " obj = float(np.sum(C * P_raw))\n", + " viol = sum(max(0., -float(np.sum(P_raw*D))) for D in D_ineq_n)\n", + " viol += sum(abs(float(np.sum(P_raw*D))) for D in D_eq_n)\n", + "\n", + " # ||∇f||_1 via dual obj gradients (uses P_paper internally)\n", + " f_val, gx, gy, ga = _dual_obj_and_grad(\n", + " C, D_ineq_n, D_eq_n, r, c, eta, x, y, a)\n", + " grad_norm = float(np.sum(np.abs(gx)) + np.sum(np.abs(gy))\n", + " + np.sum(np.abs(ga)))\n", + " dual_history.append(f_val)\n", + "\n", + " if verbose and (it % 10 == 0 or it < 3):\n", + " print(f\"{it:>5} {obj:>12.6f} {row_err:>10.2e} \"\n", + " f\"{col_err:>10.2e} {viol:>10.2e} {grad_norm:>10.2e}\")\n", + "\n", + " if grad_norm < tol:\n", + " if verbose:\n", + " print(f\"\\nConverged at iteration {it} (||∇f||_1={grad_norm:.2e})\")\n", + " break\n", + "\n", + " P_rounded = _round_transport(P_raw, r, c)\n", + " cost = float(np.sum(C * P_rounded))\n", + " violation = sum(max(0., -float(np.sum(P_rounded*D))) for D in D_ineq_n)\n", + " violation += sum(abs(float(np.sum(P_rounded*D))) for D in D_eq_n)\n", + "\n", + " return ConstrainedSinkhornResult(\n", + " transport=P_rounded, x=x, y=y, a=a,\n", + " dual_obj_history=dual_history,\n", + " cost=cost, constraint_violation=violation,\n", + " converged=grad_norm < tol, n_iter=it + 1,\n", + " )\n", + "\n", + "\n", + "# ── Quick self-test ────────────────────────────────────────────────────────────\n", + "\n", + "def _selftest():\n", + " rng = np.random.default_rng(7)\n", + " n = 12\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " DE = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + "\n", + " # Cell 6\n", + " P0 = np.ones((n,n)) / n**2\n", + " H_aa = _compute_hessian_a(P0, [DI], [DE], np.zeros(2), eta=5.)\n", + " assert H_aa.shape == (2, 2)\n", + " assert np.all(np.linalg.eigvalsh(H_aa) <= 1e-10), \"H_aa must be NSD\"\n", + " print(f\"Cell 6 _compute_hessian_a: OK (eigs={np.linalg.eigvalsh(H_aa)})\")\n", + "\n", + " # Cell 7\n", + " a_new, t = _a_update(C, [DI], [DE], r, c, 5., np.zeros(n), np.zeros(n),\n", + " np.zeros(2), n_newton=5)\n", + " assert a_new.shape == (2,) and np.isscalar(t)\n", + " print(f\"Cell 7 _a_update: OK (a={np.round(a_new,3)}, t={t:.4f})\")\n", + "\n", + " # Cell 8\n", + " P_raw = np.abs(rng.normal(0,1,(n,n))); P_raw /= P_raw.sum()\n", + " P_r = _round_transport(P_raw, r, c)\n", + " assert np.allclose(P_r.sum(1), r, atol=1e-12)\n", + " assert np.allclose(P_r.sum(0), c, atol=1e-12)\n", + " assert np.all(P_r >= -1e-14)\n", + " print(f\"Cell 8 _round_transport: OK \"\n", + " f\"(row err={np.abs(P_r.sum(1)-r).max():.2e})\")\n", + "\n", + " # Cell 9: must converge for small n with enough iterations\n", + " result = constrained_sinkhorn(\n", + " C, r, c, [DI], [DE],\n", + " eta=5., max_iter=200, n_sinkhorn=10,\n", + " n_newton=5, tol=1e-6, verbose=False)\n", + " assert result.transport.shape == (n, n)\n", + " assert result.converged, \\\n", + " f\"Expected convergence, got grad_norm stalled. iters={result.n_iter}\"\n", + " print(f\"Cell 9 constrained_sinkhorn: OK \"\n", + " f\"(cost={result.cost:.4f}, viol={result.constraint_violation:.2e}, \"\n", + " f\"converged={result.converged}, iters={result.n_iter})\")\n", + "\n", + " print(\"\\nAll Part 2 self-tests passed.\")\n", + "\n", + "\n", + "_selftest()\n" + ] + }, + { + "cell_type": "markdown", + "id": "23403c15", + "metadata": {}, + "source": [ + "## 6. Self-tests\n", + "\n", + "Before running any experiment we verify each building block independently.\n", + "\n", + "**Part 1 tests:**\n", + "- `_make_effective_geom`: geometry is created and has `_center` method\n", + "- `_transport_plan`: output is positive and has correct shape\n", + "- `_dual_obj_and_grad`: gradient $\\partial_a f \\neq 0$ at initialisation\n", + "- `_x/_y_update`: after 500 Sinkhorn steps, row/col marginal errors are $< 10^{-8}$ (machine precision level), confirming the one-sided LSE is correct\n", + "\n", + "**Part 2 tests:**\n", + "- `_compute_hessian_a`: all eigenvalues $\\leq 0$ (negative semi-definite as expected for a concave function)\n", + "- `_a_update`: gradient norm decreases across Newton iterations\n", + "- `_round_transport`: output satisfies $P\\mathbf{1} = r$, $P^\\top\\mathbf{1} = c$ to machine precision\n", + "- `constrained_sinkhorn`: a small $n=12$ instance converges, constraint violation $< 10^{-8}$" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "ee9f3a5a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "_make_effective_geom ............... OK\n", + "_transport_plan .................... OK (sum P = 2.8573)\n", + "_dual_obj_and_grad ................. OK (f = -0.3225, |∂a f| = 3.5546e-01)\n", + "_x_update (1 step) ................. OK (P_paper row err = 4.90e-08)\n", + "_x/_y_update (100 steps) ........... OK (row err = 7.89e-08, col err = 5.49e-08)\n", + "\n", + "✓ All Part 1 self-tests passed.\n", + "\n", + "_compute_hessian_a ................. OK (all eigenvalues ≤ 0: [-3.6834 -0.0062])\n", + "_a_update .......................... OK (a = [ 0.81 -0.015], t = -0.1646)\n", + "_round_transport ................... OK (row err = 6.94e-17, col err = 1.11e-16)\n", + "constrained_sinkhorn ............... OK (cost = 0.1525, viol = 8.29e-11, iters = 28)\n", + "\n", + "✓ All Part 2 self-tests passed.\n" + ] + } + ], + "source": [ + "# ── Part 1 self-tests ───────────────────────────────────────────────────────\n", + "\n", + "def _selftest_part1():\n", + " rng = np.random.default_rng(0)\n", + " n = 8\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " DE = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + " eta = 10.0\n", + " eps = 1.0 / eta\n", + " a = np.zeros(2)\n", + " x = np.zeros(n)\n", + " y = np.zeros(n)\n", + "\n", + " # Test 1: geometry factory\n", + " geom = _make_effective_geom(C, [DI, DE], a, eta)\n", + " assert hasattr(geom, '_center'), \"_make_effective_geom must expose _center\"\n", + " print('_make_effective_geom ............... OK')\n", + "\n", + " # Test 2: transport plan shape and positivity\n", + " P = _transport_plan(geom, x, y, eta)\n", + " assert P.shape == (n, n), f\"Wrong shape: {P.shape}\"\n", + " assert np.all(P > 0), \"P has non-positive entries\"\n", + " print(f'_transport_plan .................... OK (sum P = {P.sum():.4f})')\n", + "\n", + " # Test 3: dual objective returns finite value with non-zero constraint gradient\n", + " f_val, gx, gy, ga = _dual_obj_and_grad(C, [DI], [DE], r, c, eta, x, y, a)\n", + " assert np.isfinite(f_val), \"f is not finite\"\n", + " assert ga.shape == (2,), f\"Wrong grad_a shape: {ga.shape}\"\n", + " assert not np.all(ga == 0), \"grad_a is identically zero\"\n", + " print(f'_dual_obj_and_grad ................. OK (f = {f_val:.4f}, |\\u2202a f| = {np.abs(ga).sum():.4e})')\n", + "\n", + " # Test 4: after a single x-update, P_paper row marginal = r exactly.\n", + " # (Paper formula: x_new = \\u03b5(log r + 1) - \\u03b5 lse_j[(y_j-C_ij)/\\u03b5])\n", + " geom_bare = _make_effective_geom(C, [], np.array([]), eta)\n", + " x1 = _x_update(geom_bare, x, y, r, eta)\n", + " P1 = _transport_plan(geom_bare, x1, y, eta)\n", + " row_err_1step = float(np.abs(P1.sum(1) - r).sum())\n", + " assert row_err_1step < 1e-7, f\"P_paper row marginal not exact after 1 x-step: {row_err_1step:.2e}\"\n", + " print(f'_x_update (1 step) ................. OK (P_paper row err = {row_err_1step:.2e})')\n", + "\n", + " # Test 5: full Sinkhorn converges (both marginals)\n", + " x2, y2 = np.zeros(n), np.zeros(n)\n", + " for _ in range(100):\n", + " x2 = _x_update(geom_bare, x2, y2, r, eta)\n", + " y2 = _y_update(geom_bare, x2, y2, c, eta)\n", + " P2 = _transport_plan(geom_bare, x2, y2, eta)\n", + " row_err = float(np.abs(P2.sum(1) - r).sum())\n", + " col_err = float(np.abs(P2.sum(0) - c).sum())\n", + " assert row_err < 1e-7, f\"Row marginal error: {row_err:.2e}\"\n", + " assert col_err < 1e-7, f\"Col marginal error: {col_err:.2e}\"\n", + " print(f'_x/_y_update (100 steps) ........... OK '\n", + " f'(row err = {row_err:.2e}, col err = {col_err:.2e})')\n", + " print('\\n\\u2713 All Part 1 self-tests passed.')\n", + "\n", + "\n", + "# ── Part 2 self-tests ───────────────────────────────────────────────────────\n", + "\n", + "def _selftest_part2():\n", + " rng = np.random.default_rng(7)\n", + " n = 12\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " DE = (rng.uniform(0, 1, (n, n)) - 0.5) / n\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + " eta = 10.0\n", + " eps = 1.0 / eta\n", + " a = np.zeros(2)\n", + " x, y = np.zeros(n), np.zeros(n)\n", + "\n", + " # Test 6: Hessian must be negative semi-definite\n", + " geom = _make_effective_geom(C, [DI, DE], a, eta)\n", + " ctr = np.asarray(geom._center(x, y))\n", + " P_p = np.exp(np.clip(ctr / eps - 1.0, -500., 500.))\n", + " H = _compute_hessian_a(P_p, [DI], [DE], a, eta)\n", + " eigs = np.linalg.eigvalsh(H)\n", + " assert np.all(eigs <= 1e-10), f\"Hessian has positive eigenvalue {eigs.max():.3e}\"\n", + " print(f'_compute_hessian_a ................. OK (all eigenvalues \\u2264 0: {eigs.round(4)})')\n", + "\n", + " # Test 7: a-update returns finite values\n", + " a2, t = _a_update(C, [DI], [DE], r, c, eta, x, y, a, n_newton=10)\n", + " assert np.all(np.isfinite(a2)) and np.isfinite(t)\n", + " print(f'_a_update .......................... OK (a = {a2.round(3)}, t = {t:.4f})')\n", + "\n", + " # Test 8: rounding satisfies marginals exactly\n", + " P_raw = np.exp(np.clip(np.asarray(geom._center(x, y)) / eps, -500., 500.))\n", + " P_rnd = _round_transport(P_raw, r, c)\n", + " row_e = float(np.abs(P_rnd.sum(1) - r).sum())\n", + " col_e = float(np.abs(P_rnd.sum(0) - c).sum())\n", + " assert row_e < 1e-7 and col_e < 1e-7\n", + " print(f'_round_transport ................... OK (row err = {row_e:.2e}, col err = {col_e:.2e})')\n", + "\n", + " # Test 9: full solver converges\n", + " res = constrained_sinkhorn(C, r, c, [DI], [DE],\n", + " eta=eta, max_iter=100, tol=1e-7)\n", + " D_in = [DI / max(float(np.abs(DI).max()), 1.)]\n", + " D_eq = [DE / max(float(np.abs(DE).max()), 1.)]\n", + " _, gx, gy, ga = _dual_obj_and_grad(C, D_in, D_eq, r, c, eta, res.x, res.y, res.a)\n", + " grad_norm = float(np.sum(np.abs(gx)) + np.sum(np.abs(gy)) + np.sum(np.abs(ga)))\n", + " assert res.converged, (\n", + " f\"Solver did not converge in {res.n_iter} iters\\n\"\n", + " f\" final |\\u2207f|\\u2081 = {grad_norm:.2e} (tol = 1e-7)\\n\"\n", + " f\" constraint violation = {res.constraint_violation:.2e}\"\n", + " )\n", + " assert res.constraint_violation < 1e-6\n", + " print(f'constrained_sinkhorn ............... OK '\n", + " f'(cost = {res.cost:.4f}, viol = {res.constraint_violation:.2e}, '\n", + " f'iters = {res.n_iter})')\n", + " print('\\n\\u2713 All Part 2 self-tests passed.')\n", + "\n", + "\n", + "_selftest_part1()\n", + "print()\n", + "_selftest_part2()\n" + ] + }, + { + "cell_type": "markdown", + "id": "216931bc", + "metadata": {}, + "source": [ + "## 7. Experiments\n", + "\n", + "We run three experiments that reproduce Section 5 of the paper on random assignment instances.\n", + "\n", + "**Experiment 1** — Convergence under eta schedule ($n=30$, 1 ineq + 1 eq). Traces cost, constraint violation, and dual gradient norm across 117 total outer iterations with schedule $\\eta \\in \\{2, 4, 8, 16, 50\\}$.\n", + "\n", + "**Experiment 2** — Effect of regularisation strength ($n=25$, 1 ineq). Compares transport plans and costs at $\\eta \\in \\{5, 25, 150\\}$. Lower $\\eta$ gives diffuse plans; higher $\\eta$ concentrates mass.\n", + "\n", + "**Experiment 3** — Pareto front ($n=20$, 1 ineq). Sweeps the inequality threshold $t$ from binding ($1.5 \\times$ the natural value) to slack ($0.1 \\times$), tracing the cost-feasibility trade-off." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "93984d7e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=======================================================\n", + "Experiment 1 — Random assignment (n=30)\n", + "=======================================================\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.347606 5.67e-03 6.87e-03 3.59e-06 1.47e-02\n", + " 1 0.347734 1.52e-03 1.63e-03 1.67e-07 3.15e-03\n", + " 2 0.347776 1.44e-05 9.80e-06 1.61e-08 2.42e-05\n", + " 10 0.347776 1.60e-07 9.17e-08 3.83e-13 2.52e-07\n", + " 20 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 30 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 40 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 50 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 60 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 70 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 80 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 90 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 100 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 110 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 120 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 130 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 140 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " η=2: 150 iters | cost=0.34778 | viol=3.04e-11 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.244156 9.88e-03 9.39e-03 1.03e-06 1.93e-02\n", + " 1 0.244077 2.61e-04 1.45e-04 3.42e-07 4.06e-04\n", + " 2 0.244079 2.92e-05 2.03e-05 4.87e-08 4.95e-05\n", + " 10 0.244079 1.54e-07 9.48e-08 3.60e-13 2.49e-07\n", + " 20 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 30 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 40 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 50 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 60 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 70 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 80 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 90 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 100 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 110 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 120 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 130 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 140 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " η=4: 150 iters | cost=0.24408 | viol=1.59e-10 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.148608 1.20e-02 1.23e-02 2.79e-07 2.42e-02\n", + " 1 0.148646 4.50e-04 3.31e-04 2.65e-07 7.81e-04\n", + " 2 0.148651 5.04e-05 3.72e-05 6.32e-08 8.77e-05\n", + " 10 0.148652 9.32e-08 9.90e-08 1.81e-11 1.92e-07\n", + " 20 0.148652 9.30e-08 9.90e-08 2.48e-14 1.92e-07\n", + " 30 0.148652 9.30e-08 9.90e-08 2.42e-14 1.92e-07\n", + " 40 0.148652 9.30e-08 9.90e-08 2.36e-14 1.92e-07\n", + " 50 0.148652 9.30e-08 9.90e-08 2.31e-14 1.92e-07\n", + " 60 0.148652 9.30e-08 9.90e-08 2.25e-14 1.92e-07\n", + " 70 0.148652 9.30e-08 9.90e-08 2.20e-14 1.92e-07\n", + " 80 0.148652 9.30e-08 9.90e-08 2.15e-14 1.92e-07\n", + " 90 0.148652 9.30e-08 9.90e-08 2.10e-14 1.92e-07\n", + " 100 0.148652 9.30e-08 9.90e-08 2.05e-14 1.92e-07\n", + " 110 0.148652 9.30e-08 9.90e-08 2.00e-14 1.92e-07\n", + " 120 0.148652 9.30e-08 9.90e-08 1.95e-14 1.92e-07\n", + " 130 0.148652 9.30e-08 9.90e-08 1.90e-14 1.92e-07\n", + " 140 0.148652 9.30e-08 9.90e-08 1.86e-14 1.92e-07\n", + " η=8: 150 iters | cost=0.14865 | viol=7.99e-11 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.093768 1.34e-02 1.54e-02 2.58e-06 2.89e-02\n", + " 1 0.093751 2.22e-03 2.42e-03 1.94e-07 4.64e-03\n", + " 2 0.093752 3.10e-04 3.02e-04 4.62e-08 6.12e-04\n", + " 10 0.093753 1.26e-07 8.37e-08 3.31e-10 2.10e-07\n", + " 20 0.093753 1.03e-07 8.78e-08 7.24e-13 1.91e-07\n", + " 30 0.093753 1.03e-07 8.87e-08 2.36e-11 1.92e-07\n", + " 40 0.093753 1.09e-07 9.60e-08 5.70e-12 2.05e-07\n", + " 50 0.093753 1.02e-07 9.19e-08 3.91e-12 1.93e-07\n", + " 60 0.093753 1.03e-07 8.84e-08 7.74e-12 1.91e-07\n", + " 70 0.093753 1.09e-07 9.60e-08 5.65e-12 2.05e-07\n", + " 80 0.093753 1.02e-07 9.19e-08 4.04e-12 1.93e-07\n", + " 90 0.093753 1.03e-07 8.84e-08 9.01e-12 1.91e-07\n", + " 100 0.093753 1.09e-07 9.61e-08 6.16e-12 2.05e-07\n", + " 110 0.093753 1.02e-07 9.19e-08 3.63e-12 1.93e-07\n", + " 120 0.093753 1.05e-07 8.18e-08 3.07e-11 1.87e-07\n", + " 130 0.093753 1.10e-07 8.77e-08 3.74e-11 1.98e-07\n", + " 140 0.093753 1.03e-07 8.40e-08 6.70e-13 1.87e-07\n", + " η=16: 150 iters | cost=0.09375 | viol=4.92e-11 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.062386 2.87e-02 2.25e-02 1.86e-05 5.13e-02\n", + " 1 0.062421 1.91e-02 1.63e-02 1.36e-05 3.53e-02\n", + " 2 0.062425 1.43e-02 1.25e-02 1.07e-05 2.68e-02\n", + " 10 0.062458 1.96e-03 1.77e-03 1.57e-06 3.74e-03\n", + " 20 0.062467 1.89e-04 1.55e-04 1.38e-07 3.44e-04\n", + " 30 0.062468 2.21e-05 1.30e-05 1.15e-08 3.51e-05\n", + " 40 0.062468 4.28e-06 9.92e-07 2.42e-09 5.27e-06\n", + " 50 0.062468 1.29e-06 1.73e-07 6.51e-10 1.46e-06\n", + " 60 0.062468 3.81e-07 1.04e-07 2.77e-10 4.85e-07\n", + " 70 0.062468 1.62e-07 8.60e-08 1.47e-11 2.48e-07\n", + " 80 0.062468 8.13e-08 1.14e-07 1.20e-10 1.96e-07\n", + " 90 0.062468 7.71e-08 1.17e-07 4.09e-11 1.94e-07\n", + " 100 0.062468 8.54e-08 1.11e-07 8.35e-12 1.96e-07\n", + " 110 0.062468 8.07e-08 1.14e-07 7.82e-12 1.94e-07\n", + " 120 0.062468 7.71e-08 1.17e-07 4.22e-11 1.94e-07\n", + " 130 0.062468 8.55e-08 1.11e-07 1.16e-11 1.96e-07\n", + " 140 0.062468 8.72e-08 1.13e-07 9.38e-12 2.00e-07\n", + " η=50: 150 iters | cost=0.06247 | viol=2.51e-10 | converged=False\n", + "\n", + "=======================================================\n", + "Experiment 2 — Eta comparison (n=25)\n", + "=======================================================\n", + " η=5: cost=0.19876 | viol=0.00e+00 | iters=5\n", + " η=25: cost=0.06717 | viol=0.00e+00 | iters=7\n", + " η=150: cost=0.04892 | viol=7.04e-08 | iters=400\n", + "\n", + "=======================================================\n", + "Experiment 3 — Pareto front sweep (n=20)\n", + "=======================================================\n", + " DI·P_unconstrained = 0.5305 | sweep 0.796→0.053\n", + " t=0.7957: cost=0.15196 | viol=9.23e-08 | conv=True\n", + " t=0.7567: cost=0.12241 | viol=7.50e-08 | conv=True\n", + " t=0.7176: cost=0.10310 | viol=6.31e-08 | conv=True\n", + " t=0.6785: cost=0.09306 | viol=6.72e-08 | conv=True\n", + " t=0.6394: cost=0.08779 | viol=6.74e-08 | conv=True\n", + " t=0.6003: cost=0.08365 | viol=5.57e-08 | conv=True\n", + " t=0.5612: cost=0.08126 | viol=6.31e-08 | conv=True\n", + " t=0.5221: cost=0.08107 | viol=0.00e+00 | conv=True\n", + " t=0.4830: cost=0.08109 | viol=0.00e+00 | conv=True\n", + " t=0.4439: cost=0.08110 | viol=0.00e+00 | conv=True\n", + " t=0.4049: cost=0.08110 | viol=0.00e+00 | conv=True\n", + " t=0.3658: cost=0.08110 | viol=0.00e+00 | conv=True\n", + " t=0.3267: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.2876: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.2485: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.2094: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.1703: cost=0.08112 | viol=0.00e+00 | conv=True\n", + " t=0.1312: cost=0.08112 | viol=0.00e+00 | conv=True\n", + " t=0.0921: cost=0.08112 | viol=0.00e+00 | conv=True\n", + " t=0.0530: cost=0.08112 | viol=0.00e+00 | conv=True\n", + "\n", + "=======================================================\n", + "Summary\n", + "=======================================================\n", + "Exp 1 (n=30, 1 ineq + 1 eq):\n", + " Total outer iters : 750\n", + " Final cost : 0.062468\n", + " Final viol : 1.14e-11\n", + " Final ‖∇f‖₁ : 1.95e-07\n", + "\n", + "Exp 2 (n=25, 1 ineq, eta comparison):\n", + " η= 5: cost=0.19876 | viol=0.00e+00 | converged=True\n", + " η= 25: cost=0.06717 | viol=0.00e+00 | converged=True\n", + " η= 150: cost=0.04892 | viol=7.04e-08 | converged=False\n", + "\n", + "Exp 3 (n=20, Pareto front):\n", + " Threshold range: 0.796 → 0.053\n", + " Cost range : 0.08107 → 0.15196\n", + " Converged : 20/20 instances\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\"\"\"\n", + "=============\n", + "Reproduces the key experiments from Section 5 of\n", + "\"A Sinkhorn-type Algorithm for Constrained Optimal Transport\"\n", + "\n", + "Experiments\n", + "-----------\n", + "1. Random assignment problem (Figure 2 / 3 analogue)\n", + " - n=30, 1 inequality + 1 equality constraint\n", + " - Eta schedule: 2 → 4 → 8 → 16 → 50\n", + " - Plots: (a) cost convergence, (b) constraint violation, (c) marginal error\n", + "\n", + "2. Effect of eta (regularisation strength)\n", + " - Fixed n=20, vary eta: 5, 20, 100\n", + " - Shows entropic approximation quality vs. sharpness trade-off\n", + "\n", + "3. Pareto front: inequality threshold sweep\n", + " - n=20, inequality threshold t swept from tight to loose\n", + " - Traces the trade-off curve between primal cost and constraint tightness\n", + "\n", + "\"\"\"\n", + "\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.gridspec as gridspec\n", + "\n", + "# ── Plotting style ────────────────────────────────────────────────────────────\n", + "\n", + "COLORS = {\n", + " 'sinkhorn': '#2563eb', # blue\n", + " 'viol': '#dc2626', # red\n", + " 'marginal': '#16a34a', # green\n", + " 'pareto': '#7c3aed', # purple\n", + " 'eta_low': '#94a3b8', # slate\n", + " 'eta_mid': '#f59e0b', # amber\n", + " 'eta_high': '#0f172a', # near-black\n", + "}\n", + "\n", + "plt.rcParams.update({\n", + " 'font.family': 'DejaVu Sans',\n", + " 'font.size': 10,\n", + " 'axes.spines.top': False,\n", + " 'axes.spines.right': False,\n", + " 'axes.grid': True,\n", + " 'grid.alpha': 0.3,\n", + " 'grid.linewidth': 0.5,\n", + " 'lines.linewidth': 1.8,\n", + " 'figure.dpi': 120,\n", + "})\n", + "\n", + "\n", + "# ── Experiment 1: Random assignment convergence ───────────────────────────────\n", + "\n", + "def experiment_1(rng, n=30):\n", + " \"\"\"\n", + " Section 5 random assignment problem.\n", + " Runs the eta schedule and records per-iteration diagnostics.\n", + " Returns a dict of arrays for plotting.\n", + " \"\"\"\n", + " print(f\"\\n{'='*55}\")\n", + " print(f\"Experiment 1 — Random assignment (n={n})\")\n", + " print(f\"{'='*55}\")\n", + "\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = rng.uniform(0, 1, (n, n))\n", + " DE = rng.uniform(0, 1, (n, n))\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + "\n", + " # Normalise to paper convention: D_k · P ≥ 0 after centering at threshold 0.5\n", + " D_ineq = [(DI - 0.5) / n]\n", + " D_eq = [(DE - 0.5) / n]\n", + "\n", + " eta_schedule = [2., 4., 8., 16., 50.]\n", + "\n", + " # Storage: one entry per outer iteration across all eta levels\n", + " costs, viols, grads, row_errs = [], [], [], []\n", + " eta_boundaries = [0] # cumulative iteration index at each eta transition\n", + " eta_labels = []\n", + "\n", + " x, y, a = None, None, None\n", + "\n", + " for eta in eta_schedule:\n", + " res = constrained_sinkhorn(\n", + " C, r, c, D_ineq, D_eq,\n", + " eta=eta, max_iter=150, n_sinkhorn=10, n_newton=5,\n", + " tol=1e-7, verbose=True,\n", + " x0=x, y0=y, a0=a,\n", + " )\n", + " x, y, a = res.x, res.y, res.a\n", + "\n", + " # Rerun iteration-by-iteration to collect per-step metrics\n", + " x_tmp = np.zeros(n) if eta == eta_schedule[0] else x.copy()\n", + " y_tmp = np.zeros(n) if eta == eta_schedule[0] else y.copy()\n", + " a_tmp = np.zeros(len(D_ineq)+len(D_eq)) if eta == eta_schedule[0] else a.copy()\n", + "\n", + " res2 = constrained_sinkhorn(\n", + " C, r, c, D_ineq, D_eq,\n", + " eta=eta, max_iter=res.n_iter, n_sinkhorn=10, n_newton=5,\n", + " tol=0.0, # run all iters so we capture the full trajectory\n", + " verbose=False,\n", + " x0=x_tmp, y0=y_tmp, a0=a_tmp,\n", + " )\n", + "\n", + "\n", + " D_ineq_n = [D/max(float(np.abs(D).max()),1.) for D in D_ineq]\n", + " D_eq_n = [D/max(float(np.abs(D).max()),1.) for D in D_eq]\n", + " D_all_n = D_ineq_n + D_eq_n\n", + "\n", + " xt, yt, at = (np.zeros(n) if eta==eta_schedule[0] else x.copy(),\n", + " np.zeros(n) if eta==eta_schedule[0] else y.copy(),\n", + " np.zeros(len(D_all_n)) if eta==eta_schedule[0] else a.copy())\n", + "\n", + " from scipy.linalg import solve as sp_solve\n", + "\n", + " for _ in range(res.n_iter):\n", + " geom = _make_effective_geom(C, D_all_n, at, eta)\n", + " for _ in range(10):\n", + " xt = _x_update(geom, xt, yt, r, eta)\n", + " yt = _y_update(geom, xt, yt, c, eta)\n", + " at, t = _a_update(C, D_ineq_n, D_eq_n, r, c, eta, xt, yt, at,\n", + " n_newton=5)\n", + " xt = xt + t\n", + "\n", + " geom_d = _make_effective_geom(C, D_all_n, at, eta)\n", + " P = _transport_plan(geom_d, xt, yt, eta)\n", + " _, gx, gy, ga = _dual_obj_and_grad(C, D_ineq_n, D_eq_n, r, c, eta, xt, yt, at)\n", + "\n", + " cost = float(np.sum(C * P))\n", + " viol = sum(max(0., -float(np.sum(P*D))) for D in D_ineq_n)\n", + " viol += sum(abs(float(np.sum(P*D))) for D in D_eq_n)\n", + " grad = float(np.sum(np.abs(gx)) + np.sum(np.abs(gy)) + np.sum(np.abs(ga)))\n", + " row_e = float(np.abs(P.sum(1)-r).sum())\n", + "\n", + " costs.append(cost)\n", + " viols.append(max(viol, 1e-16))\n", + " grads.append(max(grad, 1e-16))\n", + " row_errs.append(max(row_e, 1e-16))\n", + "\n", + " eta_boundaries.append(len(costs))\n", + " eta_labels.append(f'η={eta:.0f}')\n", + " print(f\" η={eta:.0f}: {res.n_iter} iters | \"\n", + " f\"cost={res.cost:.5f} | viol={res.constraint_violation:.2e} | \"\n", + " f\"converged={res.converged}\")\n", + "\n", + " return {\n", + " 'costs': np.array(costs),\n", + " 'viols': np.array(viols),\n", + " 'grads': np.array(grads),\n", + " 'row_errs': np.array(row_errs),\n", + " 'boundaries': eta_boundaries,\n", + " 'eta_labels': eta_labels,\n", + " 'C': C, 'D_ineq': D_ineq, 'D_eq': D_eq, 'r': r, 'c': c,\n", + " }\n", + "\n", + "\n", + "# ── Experiment 2: Regularisation strength comparison ─────────────────────────\n", + "\n", + "def experiment_2(rng, n=25):\n", + " \"\"\"\n", + " Fixed problem, vary eta. Shows approximation quality vs. sharpness.\n", + " Returns transport plans for each eta.\n", + " \"\"\"\n", + " print(f\"\\n{'='*55}\")\n", + " print(f\"Experiment 2 — Eta comparison (n={n})\")\n", + " print(f\"{'='*55}\")\n", + "\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = rng.uniform(0, 1, (n, n))\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + " D_ineq = [(DI - 0.5) / n]\n", + "\n", + " results = {}\n", + " for eta in [5., 25., 150.]:\n", + " res = constrained_sinkhorn(\n", + " C, r, c, D_ineq, [],\n", + " eta=eta, max_iter=400, n_sinkhorn=10, n_newton=5,\n", + " tol=1e-6, verbose=False,\n", + " )\n", + " results[eta] = res\n", + " print(f\" η={eta:.0f}: cost={res.cost:.5f} | \"\n", + " f\"viol={res.constraint_violation:.2e} | \"\n", + " f\"iters={res.n_iter}\")\n", + "\n", + " return results, C, r, c\n", + "\n", + "\n", + "# ── Experiment 3: Pareto front ────────────────────────────────────────────────\n", + "\n", + "def experiment_3(rng, n=20):\n", + " \"\"\"\n", + " Sweep inequality threshold t from tight (binding) to loose (unconstrained).\n", + " Traces the cost vs. constraint-tightness Pareto front.\n", + " \"\"\"\n", + " print(f\"\\n{'='*55}\")\n", + " print(f\"Experiment 3 — Pareto front sweep (n={n})\")\n", + " print(f\"{'='*55}\")\n", + "\n", + " C = rng.uniform(0, 1, (n, n))\n", + " DI = rng.uniform(0, 1, (n, n))\n", + " r = np.ones(n) / n\n", + " c = np.ones(n) / n\n", + "\n", + " # Calibrate threshold range from the unconstrained optimum.\n", + " # Constraint is DI·P >= t, which becomes (DI-t)·P >= 0.\n", + " # Sweeping t from above to below DI·P_unconstrained crosses from\n", + " # binding (costly) to slack (near-unconstrained, cheap).\n", + " res_unc = constrained_sinkhorn(C, r, c, [], [],\n", + " eta=30., max_iter=200, n_sinkhorn=10, n_newton=5, tol=1e-5)\n", + " natural_val = float(np.sum(DI * res_unc.transport))\n", + " t_max = natural_val * 1.5\n", + " t_min = natural_val * 0.1\n", + " print(f\" DI·P_unconstrained = {natural_val:.4f} | sweep {t_max:.3f}→{t_min:.3f}\")\n", + "\n", + " thresholds = np.linspace(t_max, t_min, 20)\n", + " costs, viols, feasible = [], [], []\n", + "\n", + " for t in thresholds:\n", + " D_ineq = [(DI - t) / n]\n", + " res = constrained_sinkhorn(\n", + " C, r, c, D_ineq, [],\n", + " eta=30., max_iter=300, n_sinkhorn=10, n_newton=5,\n", + " tol=1e-5, verbose=False,\n", + " )\n", + " costs.append(res.cost)\n", + " viols.append(max(res.constraint_violation, 1e-16))\n", + " feasible.append(res.converged)\n", + " print(f\" t={t:.4f}: cost={res.cost:.5f} | \"\n", + " f\"viol={res.constraint_violation:.2e} | conv={res.converged}\")\n", + "\n", + " return thresholds, np.array(costs), np.array(viols), feasible\n", + "\n", + "\n", + "# ── Plotting ──────────────────────────────────────────────────────────────────\n", + "\n", + "def plot_all(exp1, exp2_results, exp2_C, exp2_r, exp2_c,\n", + " exp3_t, exp3_cost, exp3_viol, exp3_feasible):\n", + "\n", + " fig = plt.figure(figsize=(14, 10))\n", + " gs = gridspec.GridSpec(2, 3, figure=fig,\n", + " hspace=0.45, wspace=0.38,\n", + " left=0.07, right=0.97,\n", + " top=0.93, bottom=0.08)\n", + "\n", + " ax_cost = fig.add_subplot(gs[0, 0])\n", + " ax_viol = fig.add_subplot(gs[0, 1])\n", + " ax_grad = fig.add_subplot(gs[0, 2])\n", + " ax_P_lo = fig.add_subplot(gs[1, 0])\n", + " ax_P_hi = fig.add_subplot(gs[1, 1])\n", + " ax_paret = fig.add_subplot(gs[1, 2])\n", + "\n", + " fig.suptitle(\n", + " \"Constrained Sinkhorn — Algorithm 1 Validation\",\n", + " fontsize=13, fontweight='bold', y=0.98,\n", + " )\n", + "\n", + " iters = np.arange(1, len(exp1['costs']) + 1)\n", + " bounds = exp1['boundaries']\n", + "\n", + " # Shade eta regions\n", + " shade_colors = ['#eff6ff', '#f0fdf4', '#fefce8', '#fdf2f8', '#f8fafc']\n", + " for k, (lo, hi) in enumerate(zip(bounds[:-1], bounds[1:])):\n", + " for ax in [ax_cost, ax_viol, ax_grad]:\n", + " ax.axvspan(lo + 1, hi, alpha=0.25,\n", + " color=shade_colors[k % len(shade_colors)],\n", + " linewidth=0)\n", + " if ax is ax_cost:\n", + " mid = (lo + hi) / 2\n", + " ax.text(mid, ax.get_ylim()[1] if ax.get_ylim()[1] != 1 else 0.95,\n", + " exp1['eta_labels'][k],\n", + " ha='center', va='top', fontsize=7.5, color='#64748b')\n", + "\n", + " # ── Panel 1: Cost convergence ────────────────────────────────────────────\n", + " ax_cost.plot(iters, exp1['costs'], color=COLORS['sinkhorn'], lw=1.8)\n", + " ax_cost.set_xlabel('Outer iteration')\n", + " ax_cost.set_ylabel('Transport cost ⟨C, P⟩')\n", + " ax_cost.set_title('(a) Cost convergence', fontweight='bold', fontsize=10)\n", + " # Add eta transition markers\n", + " for b in bounds[1:-1]:\n", + " ax_cost.axvline(b, color='#94a3b8', lw=0.8, ls='--')\n", + "\n", + " # ── Panel 2: Constraint violation ────────────────────────────────────────\n", + " ax_viol.semilogy(iters, exp1['viols'], color=COLORS['viol'], lw=1.8)\n", + " ax_viol.set_xlabel('Outer iteration')\n", + " ax_viol.set_ylabel('Constraint violation')\n", + " ax_viol.set_title('(b) Constraint violation', fontweight='bold', fontsize=10)\n", + " for b in bounds[1:-1]:\n", + " ax_viol.axvline(b, color='#94a3b8', lw=0.8, ls='--')\n", + " # Reference line at machine precision\n", + " ax_viol.axhline(1e-12, color='#94a3b8', lw=0.8, ls=':', label='1e-12')\n", + " ax_viol.legend(fontsize=8)\n", + "\n", + " # ── Panel 3: Gradient norm ────────────────────────────────────────────────\n", + " ax_grad.semilogy(iters, exp1['grads'], color='#7c3aed', lw=1.8)\n", + " ax_grad.set_xlabel('Outer iteration')\n", + " ax_grad.set_ylabel('‖∇f‖₁')\n", + " ax_grad.set_title('(c) Dual gradient norm', fontweight='bold', fontsize=10)\n", + " for b in bounds[1:-1]:\n", + " ax_grad.axvline(b, color='#94a3b8', lw=0.8, ls='--')\n", + " ax_grad.axhline(1e-6, color='#94a3b8', lw=0.8, ls=':', label='tol=1e-6')\n", + " ax_grad.legend(fontsize=8)\n", + "\n", + " # Add eta labels after axes are drawn\n", + " for k, (lo, hi) in enumerate(zip(bounds[:-1], bounds[1:])):\n", + " mid = (lo + hi) / 2 + 1\n", + " ymax = ax_cost.get_ylim()[1]\n", + " ax_cost.text(mid, ymax * 0.98, exp1['eta_labels'][k],\n", + " ha='center', va='top', fontsize=7.5, color='#475569',\n", + " bbox=dict(boxstyle='round,pad=0.1', fc='white', ec='none', alpha=0.7))\n", + "\n", + " # ── Panel 4 & 5: Transport plan at low vs high eta ───────────────────────\n", + " eta_keys = sorted(exp2_results.keys())\n", + " eta_lo, eta_hi = eta_keys[0], eta_keys[-1]\n", + "\n", + " P_lo = exp2_results[eta_lo].transport\n", + " P_hi = exp2_results[eta_hi].transport\n", + "\n", + " im_lo = ax_P_lo.imshow(P_lo, cmap='Blues', aspect='auto',\n", + " interpolation='nearest', vmin=0)\n", + " ax_P_lo.set_title(f'(d) Transport plan η={eta_lo:.0f}\\n'\n", + " f'(cost={exp2_results[eta_lo].cost:.4f}, '\n", + " f'viol={exp2_results[eta_lo].constraint_violation:.1e})',\n", + " fontweight='bold', fontsize=9)\n", + " ax_P_lo.set_xlabel('Target index j')\n", + " ax_P_lo.set_ylabel('Source index i')\n", + " plt.colorbar(im_lo, ax=ax_P_lo, fraction=0.046, pad=0.04)\n", + "\n", + " im_hi = ax_P_hi.imshow(P_hi, cmap='Blues', aspect='auto',\n", + " interpolation='nearest', vmin=0)\n", + " ax_P_hi.set_title(f'(e) Transport plan η={eta_hi:.0f}\\n'\n", + " f'(cost={exp2_results[eta_hi].cost:.4f}, '\n", + " f'viol={exp2_results[eta_hi].constraint_violation:.1e})',\n", + " fontweight='bold', fontsize=9)\n", + " ax_P_hi.set_xlabel('Target index j')\n", + " ax_P_hi.set_ylabel('Source index i')\n", + " plt.colorbar(im_hi, ax=ax_P_hi, fraction=0.046, pad=0.04)\n", + "\n", + " # ── Panel 6: Pareto front ─────────────────────────────────────────────────\n", + " conv = np.array(exp3_feasible)\n", + " t_conv = exp3_t[conv]\n", + " c_conv = exp3_cost[conv]\n", + " v_conv = exp3_viol[conv]\n", + "\n", + " sc = ax_paret.scatter(exp3_t, exp3_cost,\n", + " c=np.log10(np.clip(exp3_viol, 1e-15, None)),\n", + " cmap='RdYlGn_r', s=50, zorder=3,\n", + " vmin=-12, vmax=-3)\n", + " ax_paret.plot(exp3_t, exp3_cost, color='#94a3b8', lw=0.8, zorder=2)\n", + " plt.colorbar(sc, ax=ax_paret, label='log₁₀(violation)', fraction=0.046, pad=0.04)\n", + "\n", + " ax_paret.set_xlabel('Inequality threshold t')\n", + " ax_paret.set_ylabel('Transport cost ⟨C, P⟩')\n", + " ax_paret.set_title('(f) Pareto front: cost vs. constraint tightness',\n", + " fontweight='bold', fontsize=9)\n", + "\n", + " # Annotate extremes\n", + " ax_paret.annotate('tight\\nconstraint', xy=(exp3_t[0], exp3_cost[0]),\n", + " xytext=(exp3_t[0]+0.04, exp3_cost[0]+0.004),\n", + " fontsize=7.5, color='#dc2626',\n", + " arrowprops=dict(arrowstyle='->', color='#dc2626', lw=0.8))\n", + " ax_paret.annotate('loose\\nconstraint', xy=(exp3_t[-1], exp3_cost[-1]),\n", + " xytext=(exp3_t[-1]-0.12, exp3_cost[-1]-0.005),\n", + " fontsize=7.5, color='#2563eb',\n", + " arrowprops=dict(arrowstyle='->', color='#2563eb', lw=0.8))\n", + "\n", + " return fig\n", + "\n", + "\n", + "# ── Main ──────────────────────────────────────────────────────────────────────\n", + "\n", + "def main():\n", + " rng = np.random.default_rng(42)\n", + "\n", + " exp1 = experiment_1(rng, n=30)\n", + " exp2_r, C2, r2, c2 = experiment_2(rng, n=25)\n", + " exp3_t, exp3_cost, exp3_viol, exp3_feas = experiment_3(rng, n=20)\n", + "\n", + " # ── Summary table ────────────────────────────────────────────────────────\n", + " print(f\"\\n{'='*55}\")\n", + " print(\"Summary\")\n", + " print(f\"{'='*55}\")\n", + " final_cost = exp1['costs'][-1]\n", + " final_viol = exp1['viols'][-1]\n", + " final_grad = exp1['grads'][-1]\n", + " total_iters = len(exp1['costs'])\n", + " print(f\"Exp 1 (n=30, 1 ineq + 1 eq):\")\n", + " print(f\" Total outer iters : {total_iters}\")\n", + " print(f\" Final cost : {final_cost:.6f}\")\n", + " print(f\" Final viol : {final_viol:.2e}\")\n", + " print(f\" Final ‖∇f‖₁ : {final_grad:.2e}\")\n", + "\n", + " print(f\"\\nExp 2 (n=25, 1 ineq, eta comparison):\")\n", + " for eta, res in sorted(exp2_r.items()):\n", + " print(f\" η={eta:>6.0f}: cost={res.cost:.5f} | \"\n", + " f\"viol={res.constraint_violation:.2e} | \"\n", + " f\"converged={res.converged}\")\n", + "\n", + " print(f\"\\nExp 3 (n=20, Pareto front):\")\n", + " print(f\" Threshold range: {exp3_t[0]:.3f} → {exp3_t[-1]:.3f}\")\n", + " print(f\" Cost range : {exp3_cost.min():.5f} → {exp3_cost.max():.5f}\")\n", + " print(f\" Converged : {sum(exp3_feas)}/{len(exp3_feas)} instances\")\n", + "\n", + " # ── Plot ─────────────────────────────────────────────────────────────────\n", + " fig = plot_all(exp1, exp2_r, C2, r2, c2,\n", + " exp3_t, exp3_cost, exp3_viol, exp3_feas)\n", + "\n", + " plt.show(fig)\n", + "\n", + "\n", + "main()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "192e8d07", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "=======================================================\n", + "Experiment 1 — Random assignment (n=30)\n", + "=======================================================\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.347606 5.67e-03 6.87e-03 3.59e-06 1.47e-02\n", + " 1 0.347734 1.52e-03 1.63e-03 1.67e-07 3.15e-03\n", + " 2 0.347776 1.44e-05 9.80e-06 1.61e-08 2.42e-05\n", + " 10 0.347776 1.60e-07 9.17e-08 3.83e-13 2.52e-07\n", + " 20 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 30 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 40 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 50 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 60 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 70 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 80 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 90 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 100 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 110 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 120 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 130 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " 140 0.347776 1.60e-07 9.17e-08 0.00e+00 2.52e-07\n", + " η=2: 150 iters | cost=0.34778 | viol=3.04e-11 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.244156 9.88e-03 9.39e-03 1.03e-06 1.93e-02\n", + " 1 0.244077 2.61e-04 1.45e-04 3.42e-07 4.06e-04\n", + " 2 0.244079 2.92e-05 2.03e-05 4.87e-08 4.95e-05\n", + " 10 0.244079 1.54e-07 9.48e-08 3.60e-13 2.49e-07\n", + " 20 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 30 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 40 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 50 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 60 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 70 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 80 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 90 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 100 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 110 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 120 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 130 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " 140 0.244079 1.54e-07 9.48e-08 6.01e-15 2.49e-07\n", + " η=4: 150 iters | cost=0.24408 | viol=1.59e-10 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.148608 1.20e-02 1.23e-02 2.79e-07 2.42e-02\n", + " 1 0.148646 4.50e-04 3.31e-04 2.65e-07 7.81e-04\n", + " 2 0.148651 5.04e-05 3.72e-05 6.32e-08 8.77e-05\n", + " 10 0.148652 9.32e-08 9.90e-08 1.81e-11 1.92e-07\n", + " 20 0.148652 9.30e-08 9.90e-08 2.48e-14 1.92e-07\n", + " 30 0.148652 9.30e-08 9.90e-08 2.42e-14 1.92e-07\n", + " 40 0.148652 9.30e-08 9.90e-08 2.36e-14 1.92e-07\n", + " 50 0.148652 9.30e-08 9.90e-08 2.31e-14 1.92e-07\n", + " 60 0.148652 9.30e-08 9.90e-08 2.25e-14 1.92e-07\n", + " 70 0.148652 9.30e-08 9.90e-08 2.20e-14 1.92e-07\n", + " 80 0.148652 9.30e-08 9.90e-08 2.15e-14 1.92e-07\n", + " 90 0.148652 9.30e-08 9.90e-08 2.10e-14 1.92e-07\n", + " 100 0.148652 9.30e-08 9.90e-08 2.05e-14 1.92e-07\n", + " 110 0.148652 9.30e-08 9.90e-08 2.00e-14 1.92e-07\n", + " 120 0.148652 9.30e-08 9.90e-08 1.95e-14 1.92e-07\n", + " 130 0.148652 9.30e-08 9.90e-08 1.90e-14 1.92e-07\n", + " 140 0.148652 9.30e-08 9.90e-08 1.86e-14 1.92e-07\n", + " η=8: 150 iters | cost=0.14865 | viol=7.99e-11 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.093768 1.34e-02 1.54e-02 2.58e-06 2.89e-02\n", + " 1 0.093751 2.22e-03 2.42e-03 1.94e-07 4.64e-03\n", + " 2 0.093752 3.10e-04 3.02e-04 4.62e-08 6.12e-04\n", + " 10 0.093753 1.26e-07 8.37e-08 3.31e-10 2.10e-07\n", + " 20 0.093753 1.03e-07 8.78e-08 7.24e-13 1.91e-07\n", + " 30 0.093753 1.03e-07 8.87e-08 2.36e-11 1.92e-07\n", + " 40 0.093753 1.09e-07 9.60e-08 5.70e-12 2.05e-07\n", + " 50 0.093753 1.02e-07 9.19e-08 3.91e-12 1.93e-07\n", + " 60 0.093753 1.03e-07 8.84e-08 7.74e-12 1.91e-07\n", + " 70 0.093753 1.09e-07 9.60e-08 5.65e-12 2.05e-07\n", + " 80 0.093753 1.02e-07 9.19e-08 4.04e-12 1.93e-07\n", + " 90 0.093753 1.03e-07 8.84e-08 9.01e-12 1.91e-07\n", + " 100 0.093753 1.09e-07 9.61e-08 6.16e-12 2.05e-07\n", + " 110 0.093753 1.02e-07 9.19e-08 3.63e-12 1.93e-07\n", + " 120 0.093753 1.05e-07 8.18e-08 3.07e-11 1.87e-07\n", + " 130 0.093753 1.10e-07 8.77e-08 3.74e-11 1.98e-07\n", + " 140 0.093753 1.03e-07 8.40e-08 6.70e-13 1.87e-07\n", + " η=16: 150 iters | cost=0.09375 | viol=4.92e-11 | converged=False\n", + " iter cost row err col err viol |∇f|\n", + "─────────────────────────────────────────────────────────────────\n", + " 0 0.062386 2.87e-02 2.25e-02 1.86e-05 5.13e-02\n", + " 1 0.062421 1.91e-02 1.63e-02 1.36e-05 3.53e-02\n", + " 2 0.062425 1.43e-02 1.25e-02 1.07e-05 2.68e-02\n", + " 10 0.062458 1.96e-03 1.77e-03 1.57e-06 3.74e-03\n", + " 20 0.062467 1.89e-04 1.55e-04 1.38e-07 3.44e-04\n", + " 30 0.062468 2.21e-05 1.30e-05 1.15e-08 3.51e-05\n", + " 40 0.062468 4.28e-06 9.92e-07 2.42e-09 5.27e-06\n", + " 50 0.062468 1.29e-06 1.73e-07 6.51e-10 1.46e-06\n", + " 60 0.062468 3.81e-07 1.04e-07 2.77e-10 4.85e-07\n", + " 70 0.062468 1.62e-07 8.60e-08 1.47e-11 2.48e-07\n", + " 80 0.062468 8.13e-08 1.14e-07 1.20e-10 1.96e-07\n", + " 90 0.062468 7.71e-08 1.17e-07 4.09e-11 1.94e-07\n", + " 100 0.062468 8.54e-08 1.11e-07 8.35e-12 1.96e-07\n", + " 110 0.062468 8.07e-08 1.14e-07 7.82e-12 1.94e-07\n", + " 120 0.062468 7.71e-08 1.17e-07 4.22e-11 1.94e-07\n", + " 130 0.062468 8.55e-08 1.11e-07 1.16e-11 1.96e-07\n", + " 140 0.062468 8.72e-08 1.13e-07 9.38e-12 2.00e-07\n", + " η=50: 150 iters | cost=0.06247 | viol=2.51e-10 | converged=False\n", + "\n", + "=======================================================\n", + "Experiment 2 — Eta comparison (n=25)\n", + "=======================================================\n", + " η=5: cost=0.19876 | viol=0.00e+00 | iters=5\n", + " η=25: cost=0.06717 | viol=0.00e+00 | iters=7\n", + " η=150: cost=0.04892 | viol=7.04e-08 | iters=400\n", + "\n", + "=======================================================\n", + "Experiment 3 — Pareto front sweep (n=20)\n", + "=======================================================\n", + " DI·P_unconstrained = 0.5305 | sweep 0.796→0.053\n", + " t=0.7957: cost=0.15196 | viol=9.23e-08 | conv=True\n", + " t=0.7567: cost=0.12241 | viol=7.50e-08 | conv=True\n", + " t=0.7176: cost=0.10310 | viol=6.31e-08 | conv=True\n", + " t=0.6785: cost=0.09306 | viol=6.72e-08 | conv=True\n", + " t=0.6394: cost=0.08779 | viol=6.74e-08 | conv=True\n", + " t=0.6003: cost=0.08365 | viol=5.57e-08 | conv=True\n", + " t=0.5612: cost=0.08126 | viol=6.31e-08 | conv=True\n", + " t=0.5221: cost=0.08107 | viol=0.00e+00 | conv=True\n", + " t=0.4830: cost=0.08109 | viol=0.00e+00 | conv=True\n", + " t=0.4439: cost=0.08110 | viol=0.00e+00 | conv=True\n", + " t=0.4049: cost=0.08110 | viol=0.00e+00 | conv=True\n", + " t=0.3658: cost=0.08110 | viol=0.00e+00 | conv=True\n", + " t=0.3267: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.2876: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.2485: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.2094: cost=0.08111 | viol=0.00e+00 | conv=True\n", + " t=0.1703: cost=0.08112 | viol=0.00e+00 | conv=True\n", + " t=0.1312: cost=0.08112 | viol=0.00e+00 | conv=True\n", + " t=0.0921: cost=0.08112 | viol=0.00e+00 | conv=True\n", + " t=0.0530: cost=0.08112 | viol=0.00e+00 | conv=True\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABpAAAAdWCAYAAAAN5evcAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAASdAAAEnQB3mYfeAABAABJREFUeJzs3QeYHVX9P+CTRhLSQ++9Se/dBijFAgiI0hXpSPkpCEq1IEUFkSKgIFhQUFBQVKqCNOm9t9ADgUBIT/b/fAfn/ufc3M32JLt53+e5T3ZvmTv33NmZk/M5pVdTU1NTAgAAAAAAgP/pXf4AAAAAAAAAAiQAAAAAAABmYAQSAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAGQESAAAAAAAAmb75r9B2Dz3+bPr7zf9Nr7w+OvXp3TutsOzi6Yuf+2QaOXyI4mzg33c+mC774/Xpi5/7RNpy83WVUcWtdz2U/n7Lf9PY98elEUOHpM9stXHacO1V5toyeve9cenXf7w+vfDy62nsex+k4w7fMy252ILZc8a8+376wzU3p8eeerH4fZklF0lHfG2nNLd4a8zYdMwpF6b+8/Sr3bfSckukQ7+yY+33Z55/Jf3mqhvSm2+9kxacf0Tafcet0nJLLzqb9hgAAAAAugcBEh02YeLktPUn1k8rLrtE6tUrpd9dfVO64NfXpG8d8mWlW+fdsePSP/7137TYwvMrmzovvfJG0ch/+L47FQHAE8+8lH76yz+lJRZdIC260NxZXr179UqrrrR02m6LjdIPzv7NDI9Pmjw5/ejnv08br7tq2nvnrVO/fn3TS6++keZGp31n/zTvwAEz3P/B+Anp7Iv/lL6w3cfSxut+JN1x72PF7z/41r4Nnw8AAAAAfEiANJf71g8uSB/feK103yNPp1ffeCsttdhCad8vb5dGDGv96KH6ESJbbrZuOvnMS9O0adNTnz7df5bEziijUgQk222xcfrPfx9OPUlnlFGMJJlvxLC08vJLFr+vssJSxSi21954u1sGSJ1RJkOHDEqf2GTtZh+//b+PpsHzDkyf2XLj2n3LLLFImhv/tppz3yPPpOFDB6ePbrhG8Xv8e8Ot96b7H3k6bbr+6p32PgAAAADQ0wiQSHfe91g6eJ/t0/Ahg9M5l1yd/vyP/6S9d9m6GP0RUz8154Qj90rzjRg6w/1PPjcqLbLgyB4RHnVmGd370JNp4qTJaZP1Vu1xAVJnlFGMtPnrjXelx556Ia28/FLpsadfSOMnTErLL7146q46+2+r0d/aiOFD0lkXXZmee+n1NP/IYWn7T2+aVl9l2TS3ldEJP7okTZ82vZjC7wvbfTQtsuB8xf2vvDY6LbFoPu1f/P7ya2914acCAAAAgO5PgET6+CZrpQVGDi9KYsN1Vkn//Nc9xc9fr6wh0pZpyKIB+IA9PtujSrajZfTB+Inpimv/lY742s6pp+poGc3Tr1/aaJ1V0s8uvjpNmz4t9e7VO+21y6fTsKGDUnfVmX9bjYwfPzE98eyodOCen0sH77NDevjx59L5l/2lCFdirZ+5oYwGDxqYjj10t7TEYgumyZOnpGtvuCP95IIr00nf2DsNHNC/CG3nHdg/e828/7sfAAAAAGieAIk0bMj/b6Af0H+eNGHipHaVysuvjU5nXfTH9OXtt0gfWXHpHlWyHS2jK//6r7TZBqunhRboHo36s6OMbvvvI0V4cMyhX06LLbxAeuX10ensX15VNP6vscpyaW7+22pO//7zpOWWXjStvdoKxe/x75KLL5QefeqFbhMgdbSM4jUx6ij0Hdgn7fyZj6e77ns8PfvCq2m1lZcpHo8AtyreY8jgeTvpEwAAAABAzyRAolkxLdbTM5lC6qRv7FObQirCox9fcEX6wrabp43W/chcU6qtLaPHn34xTZg4Od146321BuwXX34jPf3cy+nAvT6ferLWltGoV94oGvzL6cbi34+suFR65Innu22A1Bl/WzOz+CILpCeefSn1RO0to169ehW30mKLLJBuvPXe7DmjXn0zbfXR9Tp5jwEAAACgZxEg0azD9t2pVaXzyutvFeHR9ltvNtctSt/aMjrmkN3StOnTa7///LK/pFVXWiZ9YtO1Uk/X2jJadqlF05/+dmtxPC228PzFvzGS5nOf2jTNrWUSpkyZWvt52rRpxe99+vRJvXv3Shuvu2r657/+mx587Nm0+srLpoefeC699PIbaZ9dtklzSxk999JraWD/eYrRfZOnTC2msEu9PjyewjqrLZ+uvPaWdOvdD6eN1/lIuuO+x9LY9z+ojdoCAAAAABoTINFh0YA97oPx6Q9/ubm4tXUUxdygfh2fvn37FFOzDRlkGq3SRut8JI159/30s4uvSu+PG58GzTsgbbb+asVtbnbQsWfWfv7B2b8p/v3GAbuklZZbMi04//B0wJ6fS1dcc0u68DfXpgXmG54O3PPzxf1zi9Fvv5v+/PfbilBonnn6FdPZHfG1nWrrHg2ad2A6ZJ8d0m/+dEP63VU3FkFT/B7HFwAAAADQvF5NTU1NM3mcucz9jzydfv+Xm9MPj91vdu/KHEsZKSPHjb8tAAAAAOjpes/uHQAAAAAAAGDOIkACAAAAAAAgYwo7AAAAAAAAMkYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAIEACAAAAAACgeUYgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQAAAAAAkBEgAQCt8thjj6WjjjoqbbTRRmmhhRZK88wzTxo8eHBaaaWV0pe+9KX0m9/8Jk2cOFFpdoJLLrkk9erVq3aL37uDj3/849l+t9W0adPSxRdfnD71qU+lhRdeuDjGhg4dmpZeeum04YYbpq985SvpzDPPTG+88Ub2ultuuSV73xNPPLHTPlNHth37Xb4ufmbWmjBhQho2bFj2/cXt9ttvb/Y1L7zwQvbcvffeO3U3sc/VzxCfqT266/F7xx13pB/84Adp++23T4sttlhWFu35HFdccUW2jS222GKmz7/55puz56+55pod+DSpOOdUtxfnpKrqY3EO7sxtd7We8PcGANDT9Z3dOwAAzNnGjRuXDjrooPTrX/86NTU1ZY9NmTIlPfXUU8Xt8ssvT/fee2/68Y9/nLqjaHj717/+Vfu9/rPS9cfZNttsk2677bYZjrH3338/vfjii+nuu+8u7lt55ZXT1ltv7Sthpv785z+n9957b4b7L7vssrTJJpvMtaUXIUr8PYWlllqq3QHTnOqYY47JzuUd9dnPfjYNHz48vfvuu8XvEbK8+uqradFFF234/OhMUbXnnnumuU0cU8sss0zt97322qvbdIQAACAnQAIAmhUN95tvvnl68MEHs/sXWWSRtMYaa6Q+ffoUDUWPP/54EbhMnz5daXZSA+8XvvCF7PeeLhp9q+FRjBxZd91105AhQ9KYMWPSo48+WvzbyAILLJCV10c+8pFZss/M2S699NKG9//hD39IZ511VjHCrSdaf/31i0C2NGjQoDS3GjlyZLPnjdYaMGBA2nnnndOFF15Y/B7XuegwceSRR87w3EmTJqU//vGPtd/jGvnlL385daXquW/VVVdN3Ukcm9X9j2MXAIA5iwAJAGjW1772tSw8GjhwYDr//PPTHnvskU1RNmrUqGJqsWgso3NGQ7V1KqLuLKaui1EhpQ022KDo5R/HWykCyvvuuy/97ne/K8Klqmg0vfLKK2fpPjNni2kO//nPf9Z+79evXzGaLUSgcO2116Ydd9wx9UQHH3xwcZtbxfXpwAMPTOutt15abrnl2jWdZqNtlgFSOcqoUYD0t7/9rTZSKcR0d9Hhoit153NfhP/def8BAOYG1kACABp64IEH0u9///sZevTHdDz1DXJLLLFE+tGPfpS++93vzrCd1157LX3nO98pehaPGDGi6PW/4IILFg1r55xzTrFOSWvWAHriiSfSbrvtVqy/1L9//7TiiisW61xE+FDvzTffLEa0rLPOOkXY0Ldv36IneqzXFI3GP/zhD9Mrr7ySrRdSP+VRc+tm1K/zE73R43PEe0Vv6mrZxHR+u+++e7EGRkx3FD3Z4xbrcmy77bbpV7/6VcNRWy2tgVS/NsnUqVNr+zDvvPMW0y195jOfSQ899FCa2ZpW0cgc4UuM8okyjW3FVEMR1DQnvs/99tuv9nliOrnvf//7afLkyam9Ro8encaOHVv7PdbZqoZHIT5rjEg644wz0sYbb9ymdYoarc0UDcCbbrppsY5X3D7xiU+0edqr+O7q15v5/Oc/X4xCaCRCsGiEjobt1n5P8XcY5R3lHPsZZR5/b3EcxxRtrV0DJ4K3+LyxplR1XZzOOJbmRL/97W+zc0Ocg6qqgWV7RmYeffTRRXnF382SSy6ZDjnkkPTWW2+1av2hzjon3nPPPcXxNv/886fevXvXzhPN7UP5d1BOXxfi59auodOW47fR2jp/+ctfimMwzpPxeeNcE1PBhQhdDjvssOLYLs/vcZ5uz6jWr371q+mLX/xiER51ls022yybki3OkXFNanTc1QdPYfz48emUU05Ju+yyS1pttdWKNd7ic0Y5xnEUf89XXXVVu/atpe8vzkdxjo7rX3n92X///WdYS66R9lzDYj+qZRXieY3O0a1dA+maa64pRirF31q8f7n+YnRyuf/++xu+pqee2wAAZrkmAIAGjjnmmFgEqHZbZ5112lxO1157bdOwYcOy7dTfVl555aann346e93FF1+cPWfHHXdsGjBgQMPXH3DAAdlr33jjjabFFltspu8ZtyuuuKJ4/l577dXic5daaqna9j/2sY9lj335y1+e4fmlPn36tLjtLbfcsmnSpEkz/fzxe1XsT/nYQgst1LTFFls03PaQIUNmKNtw+umnz3Tfevfu3XTaaafN8Lpnn322adFFF234ms0226xp/fXXb1gOLXn77bez1w0aNKjp1FNPbXr88cebpk+f3uLrb7755uz1J5xwQvZ4a76zuPXr16/p1ltvbdW2Y7/22Wef7LFdd921acqUKQ2/pyi3HXbYoU3f00knnVR8FzM7fj772c82jR8/Pntd/THd6PM+//zznXIszanWXnvt2r7379+/aezYsU0bbrhh7b555pmnOO7qRblUP3eUZdWYMWOa1lhjjWbPE/H33KicO/ucuMsuuzT17du34Xmi/vsv96H+76DRLZ7TGcdv/J1Un/O5z32u4WuXXHLJpqeeeqppueWWa/j4IYcc0uFjof47aq/jjjsu21b8XhXHWPU6NXjw4KYPPvigeGzUqFEtln3c9txzzxnOefVlGeek5j5f9fsLEydObPZ7X3jhhWc4N9Rvuz3XsNZ8zvI82tLfW5zb4hw3s23FOTLOlfV66rkNAGBWMwIJAGjojjvuyH7feuut21RSjzzySNppp52ykSXRI/xTn/pUMW1NKXpxR0/miRMnNrutP/3pT0Xv4Vj4fq211soe+/nPf571qL/oootqo4vK94xF0GOEyQorrDDDNHsxCiB6Nkcv/qq4r7zF/jUnepxHj+gYFROfLUYUVMXv0WM/HovRAtGTPXo/l2644Yb0s5/9LLVX9CK/8cYbix7hW221VTa9W4yUiF7vVTHy5pvf/GZtdEaM9PnkJz+ZPv3pTxejU0L0KD/qqKOytTxCdcRAiF7g8droUR/rF/33v/9t12eI0WGrrLJK7fcPPvigGOER90Uv8XiPk046qVhrqzPEdxbfd5RXjIQoxRRnJ5xwQouvjzbSGBV08cUXZ6MeomxjtFsjUW4xwqC139MvfvGLYl/K3v3Riz6OoxhhUB2dFT3zYzRBS5839itGcG2zzTbF6IfOOJbmVLFeVnVUQnzmOLZjVEopRszVj7BsjcMPPzwbsRCjh2KduCjbOA/F3/OsOCfGOk5xToxRGPHcGKHWko997GPF+ax6/omfq+e6eE5nHL/1YvRRnAvjtdXP+tJLLxXn9GeffTYtv/zyxXm6Oorz3HPPLZ4zJyhHEzU32iiuU9XvLEYVVcs6xPlmww03LK6nn/vc54qfq2txxSjf9o5EauR73/teNrIyRqrFe8ZIsBgxV/8ZGmnrNSyOo/ibq1pqqaWy46y169TFeTbOcaU498UxGvtTHidxjoxz5S9/+ctmt9NTzm0AALPFLI+sAIBuYZVVVsl66Z5//vltev1OO+2Uvf7AAw9smjZtWq2n9gYbbJA9fs455zTb2z562t9yyy21x+tHflRH6Hzta1+r3b/SSis1TZ06dYYRBJdffnnTww8/nN1f30u7OfXPW2aZZZqefPLJ2uPVntgPPPBA7TPXj5KK3unlNqIs2jsCKW6f+cxnip7mIXrzx+iKRj3uY1+qo7OWXXbZpldffbX2+Jtvvtm0xBJL1B5fYYUVao/deeed2XvOP//8Tc8880yzvfPbWs2MkRkt9Xbv1atX05e+9KWm9957r0MjkNZbb72md955p/ZdLLjggtkopOp3WL/t448/vmm//fbL7jvssMMajpRq7/cUx2yMDqi+9ne/+13t8RiZNXz48KxcHnnkkdrj9SNQRowY0XTXXXdl2y//Ltq7j3Oyo446KvtM8fdejgKJsirv32ijjWZ47cxGRLzyyivZMRrnpf/85z+1x88777wZjtnqCKTOPCfG7cILL8z2vfzemhuBVKp+5zP7TjtybNSPmonzSnmueeKJJ2b4LLHt8pg88sgjs8cuueSSpo6obqujx3AcM9Xt3XHHHbXHttpqq+yx66+/vvbYhAkTmh577LGG24z760eXdcYIpPiuqueJuF199dW1x2+44Ybs76HRttt7DWtpZFFrnhfntPrzWLUM4++6+nicM6vX+554bgMAmB2MQAIAWtvppNUlFT2C//73v2cL2Md6RdH7OcRogOOPPz57zV//+tdmtxe99qs942Pdgvo1RUqxRkLp+eefL9YaiZ7hDz/8cLEWRPSmjpEIMWqms3p4x3odpWpv8livKT5nrOkTI16iHKLXdNw/bty42vMaraXRFrEuUKynEWKUVYxKaFQ2sW5HdXRWfB+HHnpoUb5xi4Xnq9/z008/XdxC9N6uihE31TVGjj322NoIpvbYbrvt0vXXX5/WXnvtZp8T+xZr+cRIqI5+ZzGyqToioDoK6e233272tTEi4oILLsg+95lnnjnDumAd+Z7uvffe9Prrr2ej5Hbdddfa7zHaZN99983K5W9/+1uz7/uNb3wjbbDBBrXfYxRe/Ui8tu5jS2KtkfK46ugtttWWc0+MBCvFSInyfLH44osXoxhLd955Z3rmmWdave1Yx6e6rtL222+fbS9GgjW37k5nnxNjFEX1GAjl99ZVOnJsRNksssgixc/xuvLvrxRr1pXHZP06PtVRj7NbrAFYVR5r8fd600031e6PkS4xcrIUo1Tj2nDEEUcUa/DEdShGBcZ5o340TkevB9XzSKwtVYrzXIwgKsWaW1tuueVMtzGrrmGN1B//cbxXR6rGdTxGIpXiO5jZ+n2ddW4DAJjbNJ5jAwCY60UDUXXKsLZMIxRT41Qbl6Lhtr7BsD7AabTYfKnaSBSq08+ECIZKsaj2eeedVzQ6xjRVsRB7KRrsojE+AohojGquEb0tmpvyKaarisfGjBnT4jbee++9dr//kCFDsoaw+vKJMqgGalXReN5SA3p8L9HYNmrUqOz++kbPaCCNxvPmFjRvjZi+KhoAI+yLwOo///lP0Wgfx1NVTPEU04XFtEjt0ZbjqV51X2Lav1icvrO/p/q/hUZhZ1v+fpo7Rjuyjy2J6Qzrp0Bsr5gqsbWiEb8aksb0lYMGDcoaneO4Kl122WXF9IitUf83sPrqq2e/R8N6fC8xHVtXnxNb+512lo4eG6uuuuoM26uGG9XH47HW/j3OanH8xDSG5eeNqQQjQI7pEKvh4m677VYLB8vjMoLMCRMmdOn1oKqlc3Z5zEVwPzuvYc1p7XnwnnvuyV4T1/iuPLcBAMxtjEACABqKHsdV1d7zs9p8882X/T6z4CeCrwcffLBYEyGCgmqv/FgzJNZ2OuCAA4qRI52h7FVfL9YQqja8RWNxrCFRrgFRvzZGe8X6QfWaK5+2jCKrrkfUSGtG3LRXNMxHI+0VV1yR3nzzzaInen2jckd6vLfleJqZf/zjH+nss8/u9O+pszV3jM5J+9hZYg2Zquuuu64Ia8rbd7/73ezxX//61+1+r0Z/A9XQYE74TjtLR4+N+rCsvpzqQ9w5VZRDjJYsxfkpApjqqLdG6yUdcsghWXgU16lYB6m8HnT0PN0abT1nz6pr2KzQE85tAACziwAJAGhol112yX6PkSVXXnnlTEur7CkeDfTVUQMvv/xytnB8udB9VXtHkzQSU+2ceOKJxSiI8ePHF+8fU3xVezDHot/Vhrr2BiLNNRjfdttttZ8XXXTRomd0BA5RhtFbfXZYeumls99jFFaUwcxuMU1XWGKJJbLXPvbYY9nvsXh8o5EXrdXcFELxvWy77bbFlF1VMZXS7BANwwsvvHDt98MOOyz94he/6NT3qP9biJEA9dry9zOrQo2qSy65pMVjq7W32FZrw86YrrJ+ZESMSCpvo0ePzh5/7rnnsr/VmalOjxmqIzRD7GuMnmuks8+JHflOuzL8nRvUh0MxJWZca0prrbVWdq2JEKZ6rMQ0nTGiN8LNuB7EtagrtHTObnTMddY1rDOOsc4+DwIA0D4CJACgoWjkiul66td/iCmf6ntIx1Q5Rx55ZDruuONqPXtjeq/qujKxFlH5umjUrR8JUO3V3RE333xz0Ru8nB4pGlpjPYptttkmrbnmmrXnRbAUvcdLAwcOzLZTnQarPWK0U3XqvHIkVJRBlFO8/6y27rrrZuFHlNM///nPGZ73xhtvpPPPPz99/etfr91XXc8jRGhSnRLv1FNP7dA0RjFNXkw/ePvttxfrxdR/F7FeTVWsAzQ7LLvsskUjajmiIr7P/fbbL/32t7/ttPeIkXMxQqEUjdMxGqv05JNPzhBaRcg2t4vwqLkRczMT57TWiLV5qqMWYoq+WGem9POf/7zZKSFn5zmxXvVcF+t9zUlTxHUH8b1UR7RUp0RsFDBVrwUh1kKKa0I5ddrRRx/dZef76siuOIdee+212bWyuenrOnoN64zraf05Lc55ce4rxTmxGtzFOTM+MwAAnUuABAA068ILL8xCl5iCJ0KkMpCJNR1i7Yro9fuTn/wkW0cgFt6uTh8XvaxXXHHFYtqeCAuqgUCsnfOVr3ylU76JmL5u9913TwsuuGBaY401ikaoWDg8pkWrTjMUDYAxUqkU+1a1ySabFKNvdtpppxmmxWqNDTbYoPZz9DaP7Ud5xb+nnHLKbBkFEI3YP/jBD7LvMxq14zuMtWLK7yamxzrwwAPTQw89lE1pGGVSipEcUb6xCHv8GyO+OiJGMF100UVp0003LRaY33zzzYvvLdbgiOMj1rQqxT5Hj/jZJT7vNddcU2skjcAr1tWKtZk663uqX5cnwtw4piLIW2eddbKppb785S83XB9kblMfBMUIj0YjmiJcjkb8Uqxj05oQJf4u4txSivNdHK9xjEboF38zMzO7zon1que6WJcpzvE77rhjca6bnVOVdpYI4uJ8Vd7qRzpWH4vpMdsqjp36zhXVv934e6yKa1F19Oddd91VBOARRMX33NoAs63iWDv44IOz++KaFufxOL/GeXRm0+V15Bq2wAILZNMW3nDDDcX7xjEWt/r1mRqJa/auu+5a+z3OedGxJdbKi32r/w7iezctHQBA5xMgAQDNinVnbr311qLRtNpYFI1w0dAYjW8xLU7ZCFWdVika2WOam+raNdE7P0ZvVEf+RMNpTC9X32O5o6KHf0wnFY3If/nLX7Lpb2I/zzjjjKyxKYKx6u/RYPbnP/+5GGVQDVJaK4KaaiN1NJhFeUUZ7L///jNMhzWr7LPPPkXjX/WzxncYPdPju4n9K7/Pspd8KYK06tor0fh84403FuUcjdDVsLGtqsdXjMaI6ZPie/v3v/+dNe7H8RJB0+y22WabFVM5lWUUvfWjsTOOt84Qx0iMUCnLJb6T6G0fowaqPf8jyI2gd24XAWMci9Up4yLcbCRGZVSnRIxAqToyY2YiKI9zWymOzThGYyRSHJuxRkxV9Rwwu8+J1XNAVYzqiPAzznXNjaDqTmIqzQhpyltVhH7Vx+qnNGytuF40EsdVdZRn6fTTT8/OcU8//XTxHcdUhtVQv7PFSKEIi0rTpk0r1gGM8+ugQYPS5z73uS65hsVn3XvvvbP74n3jGItb/fSNzYlzfZzjqp0ebrnlluJcWF6n4r3ic8YIVgAAOp8ACQCYqWjsjB7SEaJ84xvfSOuvv34xcicazmMR7WjsjIbzWIy+viEsRpDE2g/HHHNMMWpi6NChxeuicTemgzrrrLPSAw88MMPon46InvTRyBu9nKOXd+xrhCWxr/E+MVIkpkmrb0SN/YtRJdHYVm3gba/obR3hW/Tyju1FY3CsjXHeeecV08PNTt/61reK7/PQQw8tGrVj/6KM4vuJXt/R8BejtSJAq4re8vfcc0+xdlJMFxSNi3FffL8xjVO1x3l7Gn2jbCKsjHKKYyTWOYpbvFeMvInjJUaYLb744mlOEKPbYn2esmE4Gqfj+IuQpzNEj/poKI3yjmM3juEo8xgBGCMJYsq2aNDtTovZd5U4XqtTH+6www4zBKBVO++8c/Z7a0cZxui4aHw/6qijipGX8X1EQ3pM93j33XcXDdyleP8YiTG7z4n1Yh/i88a53LHTPjF6Ka599eqnryvF9SgCowie41oQ62HFNmL0W5yPu8qAAQOKaUpPPvnkYn/jeI3zaexnrGsYI3q66hoW05pGsFO+b3tEyBXnuAg44286zn2xrdiX2G6M0otzZHw+AAC6Rq+mmY1bBwAAoDaCI0ZgNgoxYwRUNLbHc0KEntVRUQAAAN2NAAkAAKAVYtrGGDW07rrrFlM2xnRlMaXgo48+mq6//vpsOs8YifbRj35UuQIAAN2WAAkAAKCVAVJLU1zGtFs///nP02677aZMAQCAbk2ABAAA0AoxPd2ZZ56ZbrnllmLU0ejRo9OkSZPSsGHD0korrZS23HLLYs2qOWWdLgAAgI4QIAEAAAAAAJDpnf8KAAAAAADA3E6ABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaABAAAAAAAQEaAxFzj9NNPT7169UojRoxIH3zwQZtf39TUlFZaaaViGwcffHCX7CMAMHfUQV544YXivrh9/OMfb3EbL774Yurbt2/x/CuuuGIW7PXc7cQTT6x9P5dccknqyfsZryu3EdvrCnvvvXftPW655ZYueQ8AZn/bSU+vr/SE61nUO8vPEPXR9tRLgbmLAIm5wrhx49Jpp51W/LzvvvumQYMGtXkbcSE97LDDip8vuuiiNGrUqE7ZtyeffLIIpFZeeeU0ePDgNHTo0LT66qungw46KP33v/9NXS0aCuJ25plndvl7AcDcpjPqIGGppZZKO+64Y/HzSSedlKZPn94p+3fDDTekL37xi2nJJZdMAwYMSAsuuGDaYIMNivd46aWX0pwkGmrKessDDzyQuoMIZ8p9fvfdd1NPFQ1P5ee8+uqrZ/fuADCb6i2dWV+phhpx69OnT5p33nnTEksskbbYYov04x//OL333nvt3j6zn/Yo6B76zu4dgFn1n/e33nqrVglqrz322CMdeeSRadKkSemss85KZ5xxRof262c/+1k64ogj0tSpU7P7H3nkkeJ2++23d3kDSVTqyore4Ycf3qXvBQBzm86qg5Svj968jz76aPrb3/6WPvOZz7R7W1OmTElf/epX02WXXZbdP3r06OIWnVjeeeedOaqDSQRIZb1l6aWXTmuttVaXvddXvvKVtOWWWxY/r7jiih36/v/1r3/Vei0PHz48zYn72VHRyFd+N3vttVfafvvts8e//e1v147/6CgFQM+tt3RmfaUqwqgJEyakl19+ubjddNNNxWipP/3pT2njjTfulPeYWy2yyCLp1ltvLX4eNmzYLHtf7VHQPQiQmCtcfPHFxb+rrrpqMQ1dew0ZMqT4T/pf//rX9Jvf/Cb98Ic/LIZnt8eVV16ZDj300Nrvn/rUp4pGgAUWWKAY9h2Pv/rqq+3eVzpfDN9vb89xAOZOnVUHCZ/4xCeK6WQi2IkGno40yEQHljI86t27d/ra175WbC9GIT388MNz9LRts+L6HSOy4jan6y77ucIKKxQ3AHp+vaUz6ytVEXBMnDixCKZ++tOfpueeey69/vrradttt0333XdfWmaZZVJPNX78+GL0VVfp379/2myzzbps+z1BV38HMCczhR09Xky/EpWJMqSp93//939pk002KXpcxEUzppFbZ511itFF9SODwlZbbVX8GxWVO+64o137FNuN9y3ttNNO6e9//3sxhcwnP/nJtM8++xQh1W9/+9vsdc8880zxWAzZnmeeedJ8881XVJZuvPHGGd7j5z//eVpvvfWKzxOfa7HFFivCr3I4ejlnfilCq3JoePTqbcmYMWPSMccckz7ykY8UF9GYei/KLUZVtWefo1dx+f7RQ/cf//hHWn/99YuGrGgYiQpiKYaql8/9yU9+km0nyqx87KijjqrdH72pY/RYNF5EeUSFdrvttkt33nnnTPcjejNFD+d4TfRuKns+nXzyyWnxxRcvPntUkGOkWKO5hEt//vOfi/KP941tRWU8ettED6qq6jYeeuihImSM6YQGDhyYttlmm+J7qhefYeedd06LLrpoUcYLL7xwUcb1o9dauw8AzJo6SFWcs+N6EteVOJ8fd9xxM9RD+vXrlz72sY8VP0c9YfLkye3aryeeeCKdd955td9jVPX5559fNPDEdSLCpdifAw88MHtd9PSNa+f8889fXG/i2h7XyqeffrrZdXmiISpGMS2//PLFtWfNNdcstlMV18wvf/nLxeeOzxijdKJ+EfWHuBaG2FbZSzXEY/Vr/0T9pbwvyv4LX/hC0Yt2tdVWKx7/97//XVwvoy4Q7xGfId5zl112qb1Po89QDdOq7xF1wRidHtfV6GQU9bioH1XrE+XooxANW83VE0pR7yifU06dXIqR6eVjsc8z288Qx1583qgXlPWDqHPee++9qTViKrrPfe5zxX7H54ttxIj1KPvq/kfdJY7d0q9+9ausLtXSmhFddVwB0Pn1lmi3iP9rRsfXOGdHO0NcW6r/T+2s+kq9CDiinhLXx/vvvz8tu+yyxf0xRezxxx9fe15z15zm1vxr7fWuPd5+++1iZG7UR6LuseeeexYjvBq1vdTvX9TN4v/sUZ5/+MMf2tx+NW3atGI78R2V7RYPPvhgw/2c2RpIMa1hbCfqU9EuEW0/8ZzrrrtuptuI0exl3TbqIN/5zndqUxp2pD2q+v3+85//LL77aJuJtqNNN9204WdsbZ2ope+g/jPefPPNad111y3KJb6H8niLenYcnzPbJ+hWmqCH++1vf9sUh3rcLrvsshke79+/f+3x+ts+++wzw/P//e9/1x4/5ZRT2rVP1W307t276bnnnmvxNXfddVfTkCFDGu5nr169ms4999zacy+99NJmP9Niiy1WPOeEE05o9jlLLbXUTPflpZdealpyySUbvvZjH/tYu/b55ptvzt4/yqX+Nddff33x3FdffbX2+CabbJLt2w477FB7/oMPPljc9+KLLzYtvvjiDfejX79+TX/+858b7scyyyxT7Gf5e5RZ+PrXvz7DdoYNG9a09NJL135//vnna9s87rjjmi3rzTffvGnSpEm150b5lY8tu+yyMzx/0003zT7vL3/5y6Y+ffo03PbFF1/crn0AoOvrIHGdqF73hg4dOsP5ef/9959hmyeffHLt8TvuuKNd+1XdxvLLL980derUFl9zzjnnZNfE6i2u9XfffXftudU6RqNrWTx/zJgxxXOnTJnStOKKKzZ7jbrwwguL5zX3ePV6F+XY6H3Lek3U25rbxrzzztv02GOPNfwM1etpc+9R3nbbbbcZ6hONbtV6QtXEiRObhg8fXjwn6i7Tp0+vPXbEEUfUXl/WXZrbz3g86jitqfvE6+rrOiGOv+b2f6GFFmp64403Zqi71N/22muv4jnxb3lflE1XH1cAdH7byUknndTs+b56bu+s+kq1rhS3er/+9a+z63j5f9rmrjkdvd7NbNuNTJ48uWm99dabYZtrrrnmDHWU+v2rv86V1/i2tF8dfPDBMzwn6puN2i2qZV1t03n33XebVl999WbfM67jjb6vRRZZpGngwIHN1us60h5V/Q4a1Qfi80X9sqN1okbfQfUzRtvagAEDsufEZ/7GN77R4j5Bd2MEEj3e448/Xvs5einWiznZf/e73xU9aaK3QPT83HDDDWu9D2Ju3arqNh577LF27VO190H0BmlpqHW0m0Tvl/fff7/4PXpKRE+e6J0c087E47F+0ahRo2ojTUJMrxc9JmK0T0y5F71VyveK6fLKOW5D9MCI3+MW0+fNzEEHHVRbWDtGB11wwQVF+cXopug12p59roreJ5/97GfTNddck3bddddsVFWI3jYxUivEKLByqr+Yoib2o5xff4011qjtb/k9Ro+feE70CIneOrEGRJRFvLbe888/X4ziivmbo1fS5ptvnp588sl09tlnF4/H54jeLrGfseB4o95J0evmu9/9bm2/f/GLXxTvHz1tQ5R3/Siq6qip+P5+/etf19ZM+M9//lMM2Q+vvPJK0Ts8ehaFWG/gqquuKr6/mIooetZ0dB8A6Lo6SPW6t9FGGxXXkzhfxyLR5XWvfmRMZ9dDYs2A8v2aE9fqGJUU1+649kUP0rimR0/OENf66A36Yc6Ti+lljj766PSXv/ylGCVSPr8cZR2joZ566qni5+hVHNena6+9trjWxsjb6F1bXquiXlE69thja/WW6Ald74033ihGLEfP1HhuiGt1bDf2JXqMXn/99enUU0+tTUvS1mthjOCNa/S5555bu+ZefvnlaezYsWnttdcu9q26TlPUJ8p9jutxI/F5o84Uou5SHSn9xz/+sfg3RnNH2TQn6jSxvlXUcULUFWINiqgPVde/alT3qYre53EMxnEZdeT4bsoR9FG+F110UfFzlGl1pHjsW/k5o549O44rADq33nLPPfekE044ofZ7XEfi+hBtKXHejvN4Z9dXWlJd9yiu42V9oq1ae71rqxgtG+UWYrRybCdGsUQ9oSVxnfv0pz9dtEPEa2JKwba0X0X9KuonIb6bGE0T9asos7aMqor3i6mNQ9S34jp96aWXFu1HIa7jjdp0XnvttWJETrRNff3rX5+hTacj7VFV8d5Rl4tyKNui4vPFjDYdrRM19x2Uoj2mXOKibJ+KumGMBot1wKK8V1555Rn2Cbql2Z1gQVc78MADa6n/E088McPjt912W9PnP//5poUXXripb9++M/QUqPZGCBMmTKg9ts0227Rrn773ve/VtrHhhhu2+Pz77ruv9vzYz+jJUvrCF75Qe+wnP/lJcd+uu+5a64Vzww03NI0dO7bZbbe2l0fp7bffro3+iZEv1d66Hdnnak/dBRdcsOiBG15//fXa/WuttVbDniE//elPi/t+//vf1+774Q9/WNvfsmdr7Mett95au1VHK1155ZUz7MfgwYOL11edeuqptcfjc5Six2u1h03Zk+ewww6r3XfsscfW3vuaa66p3b/aaqvVtlPtxVuWTTjggANq91999dXFffF4eV/9SKyqtu4DAF1fB6n2YIzrdfTwLMUolvKx6MFbdd1119Uei2tSe2y55Za1bRx99NEtPv/HP/5xw2tfXNvj2lo+dv/998/QqzTqWKXLL7+8dv/hhx9e3BflUt63xx57ND377LNN06ZNa7gfzY22aTQ66IILLpjh8Q8++KDpxBNPLHrSRpnX1/nWXnvtFt+r+h5XXXVV7f6tt966dv8DDzzQ8Lre3KijetW6yJFHHlkb1V3eF3WCme3nn/70p9p96667brbt+L1+/5vrkR11oHj/lVZaqWEv4qhHNdrnctRRVaMe2115XAHQufWW6v8pv/SlL7W4rc6or7Q0Amn8+PHZ49G2054RSG253rVlBFK0F5XPPfvss2v3//3vf2/YDlPdv7i/0YiV1rZfVdstdt5559rro75ZrQPNbARS1MdGjBhR3DfPPPMUbUtlW8JBBx1Ue/4ZZ5wxwzbi+dGWU26nfM8YZV3VqBxaUv0O4rgsRRtQef+ZZ57Z4TpRo++g+hnjWCnb2q644ora/TFbTzmC/PTTT59hn6A7MgKJuUp9D8a77767mJM1ekXEPPaN1jyK+XRnto32iPlvS+XomZmp9qSJXhwx/2opetPWP69cFyB64USPiHi/6I2x++6713rAtFesaVTOWxtzuq6yyiqdss9V0Qu77HEcvWwbfRexrkHMMxvKHirlv/HZYy2Fcn/L7yy+4xhFVN5itE6j3lalmKt25MiRM/RCKZU9fcoeRWXvkubK4Qc/+EHtvWOEVSl6BzVSzhvdXDlUt12OJmqkI/sAQOeYWf0hrh/VukH1Olm97rS0nVlRD6le++LaHiNtGj2vtdeyWI8orknhsssuS8stt1wxQjh6yMbag5MmTUrtUb3Glb70pS8VPXCjJ23UkVqq87Wkpc/WXrHdshdtOeqo2hs36nPt+b5aUwcrxejmqEPGKK4Yfd1ovcSOfs6uPK4A6Jj6+kb1XBxrJrb19V0hRoA0V79pra683jXXdlAdOdWcrbfeuphRpr3tV9X3jrWlq2UUa/q0RqzV9M477xQ/xzpWUU5lW0I5uqm5tpSo2y600EK1EVDRXlLdv87SljaTttaJGn0HVVGOsR5UqLYbxZpI5fpOsb5j/T5BdyRAosernrDLi18ppgcrh7JGJSiGssaQ2ZjmrFSGJY22Ud12W5RTbZSVno4szFhdeLA6BDumOotpzOI/4LFoYQxljmns4gJb3xg1qzXa56qychGqF+xqJTQWt4yFLsNtt91WTDcX31/46Ec/Wmt4aa1GQ5bLCk97P0drRcWvUQNZa8qhszS3DwB0TR2kvdeXzq6HxBRp5VSos+OaHo0Kcf3+0Y9+VPxHPabGjcab2K+jjjqqWCi7Peqv4TH1bkx3FiKgioaPmPqlurh2fZ2vJV11na52hInpDWMq2jJIiqmIY/Hsjmy7NaIeGQuUh5hu71e/+lX697//XUyb097y6sz9nJV1JIC5RXvrLV1VX2nNtaoUnUtXXHHFGa4h1TpOBCKz63rX1raDRm0R7Wm/6ox9aU9bSvU6HWYWxHRER+oDLZVDS+1B1cCyOoVjGSrVU0ehOxMg0eNVR8jEaJTmeqyccsopxZztm222WTHPbXOq2/jIRz7Srn2KHifRQFJe4L/1rW81fF7Zk6OsCIWo3FR7mtx11121n8vnxYUp3iPWJrrvvvuKOeGjYSZEj9tynaDqRbO1laKYy7i8OEYQ1dzIlbbuc3vstttutX3ff//9axWXas/c2N/yM0av5tiPKJ/qLXrTnHzyya2qUMQ2StGgU60gNyqL6ueLOZDr3ztusd/liKu2qG67DM9ael5n7wMA7auDVEWP1/fee6/hdTJG+3Z2PaS6VsHTTz9d1BfqxbUh9qv+OhK9X0vRiFE2utQ/r7XifSLQOfLII9N1111XBCZvvvlmbc3GmNO+0X/OW6q31F/Dq3W+mM8+5sCPTjVdfe1ryz43quOU6w+UnX8iWGqpwaO576v+95l9X9XyiveMxqlypFhnfc6uPK4A6Nx6S/VcHGu+tKQz6iszE6M5qmsy7bDDDrX1CKsN+zFSp1RtB2nv9a4tmms7iHWcW9LoWt+W9qtq/bE6C02sv1TW71oSwV8Z0ERdLdqV6tsRIqCLNob2amt7VFt1pE7U2UEbdGddEwHDHCSmIStFmLLHHnvUfl9qqaWyC/Bee+1VNF7MbHG76n9oq9tui+gZEQvr7bLLLsXvv//974sLeUw9t8ACCxSNJzFVSVQQ4v1iAeaozEWgFIsRRqNCLCocDUzlNGxRWYpp3UIsUhjP22qrrYqROPF+1QUKqyNNokIwZsyYYgqbGKEUZRI9LWJKmUZiaG5UVKLSGJWF+DkWPY73efTRR4syjilo2rrP7RE9lWOY8ttvv10shF2/+HR1fyNgefbZZ4tRS7FIYoxginKO8o3GqajELb300i2+5+c///li0eaoLEVv4FjsPKboO+ussxoOd49KaDxWLjAZZb3GGmsUFd7Yn1jcO8r8l7/8ZbsaACN8jO8zek5FWUaFNypfUR5xfEa5d+U+ANC+OkhVhPhf/OIX0yGHHJIefPDBdPnll2fXnUb1kAEDBhTXn/aIaUUiQDnnnHOK3w899NBiWreYDjWuo4888kjRGBDTpJx55pnFdTWufdGwH9fMaLCJ6Wajl25c48vGoerIptYqFyCOOlFsI+ogMap49OjRDesspbgGR8gU053F1CwtBUHVOt9NN91U9Czu06dPOvbYY1NXqu7zhRdeWCxAHb2k11tvvZm+bvXVVy+u1Q899FCtjtOa6evKkehl/SgajeK4iu826kJlI1I0CkU9sTXlFWUdDVTRWaa5Tk/Vzxkjw6M+HXWtaJBZcMEFG76mK48rADq33hL/ryz/T/nb3/42DRo0qKijRB0mplSLDp0xE0hn1lfqxfUl6gVRZ/npT39a/H++DIzi/+XVTqSlaKuI//fefvvt6cYbb+zw9a4ttt9++1pHz+OPP764/ke5xbWvPdrSfhVT+ZbvU7ZbxNRqP/vZzxqOGGquc0hM/xujtseNG1fUL6KtKeoQMcNN1Bfj+h3tCB//+Mfb9Zna2h7VVp1RJwIarUIHPVC5ON5qq62W3R8LEvfq1StbdDB+33jjjZtdpHm77bYr7o9FC6dOndqh/YqFFBstfFje1lxzzWxfhwwZ0vB5sc/nnntu7blf/epXm91mLPQXC1SXYtHi+uc0Wvy46sUXX2xafPHFG26/XHCxrfs8s8WXZ7awYnWhz7jtuOOObdrf+sUjW1oEOnz961+f4fVDhw7NFtauLpR93HHHzfS9q+/T3GLbzS3mfeGFFzb17t274Xarz2vLPgDQ9XWQ6iK8iy22WMNFm/fdd9/sNZMnT64tZrzTTjt1aL9iW3vsscdMrw3VhYnPOeecGepM5S2u9XfffXeL16xG19hRo0bNdB/233//2usfeuihhvtQXi+r1+FGyjpc9bbppps2rGc09xmae4/mFtWOul79e7Z2oejqAthxW2eddWZ4TnP7efXVVzf169evYZnG/eUi280tKh513DXWWGOm5VWt88Ui01E3bq4u0lz5dNVxBUDn1lvC8ccf3+z1unpu76z6SrWu1NxtoYUWarr99tuz17311ltNgwcPnuG5q6yySoevd81dzxqJclhvvfVm2Hb1/ap1gkbX4460Xx1wwAEzvHfUN6PeWV+HqpZ19fO+8847TauvvvpMv4OyHJrbxszqT+1pj2ruO2iu/DpaJ6pq7jM2VxdpaXvQXZjCjrlCjOwJ0UMipmqpLpoXo2Gil2f0jFl11VXTFVdcUfRSaCSG7N5www21HqDRc7UjovdD9J6JXsCxAF+sVRRDg6Nn8H777ZdNKRP7eu+99xa9TBZbbLFiVFH01ohRODGCJLZR7R0Uz4ttRm+c2M/o/Rk9YGIkUnU4c/RAiV6/MfKptWL6vehRFGsTxL5G2cV+x6ij6uiftuxze9X3xG3UM7fc329+85u1/Y1esfFzjNiJNRHasmZSLLAZi3AvuuiixbZiiPvNN9+c9b6N77IU0+Nde+21tRFT0Vs6yiN6N/3whz9MJ510Urs//7777lt8pzvuuGPRUyfKOL7rGHUV38es2AcA2l4HqYqesjEqJnr+xnVl4YUXLkbGnHfeednz4lpTrikQo3o7Iq4Dl156aXE9jhGtiy++eDEyOK4R0VP4uOOOK6aVKx100EHFSJi4vsTo3rjexHUwrqNxra8u0NwWsa0YeRLTycXaA7Ff0UM3Rt9873vfS2effXbtuVFfi32OEc7tmXouRkhHnSR6mg4fPrzoWX3NNdekrhQ9sqMHcNRFqtO8tUaMIK6+pjWjj0rRKzxGV0e9LOoF8X1FXS/qC9ELu1xHsjlRd4zR5rGdqEvGa2M9qosuuqjh82P7UZ+KekXUsVqrq44rADq/3hL/Z4xrQ/X/lHHOjmtLOfVsZ9dX6qcUi3pS/D826g2nnXZaMY18TN9fFft29dVXF3WJqNvEVHIx6jraLzp6vWuLKJ+YNi/qG7EuTtxiRE+5rmF9u0FL2tp+FXWoqM9F/SqeH/XMGIVVHaHVkqgvRX0iRjDFiOCoo8U+xwihqGPEiO4YPdxe7WmPaquO1omAlHpFiqQg6OliuG1UaGLRxKg0nHrqqe3aTgzdPfjgg4tGi6hMtSV0oOeI02b9fLgxJDoah2KNqahkxe9tbSgCoOfprDpIiP9gR0NBNBjE1GauMwDAnFZvUV+ZedtBhErRcSJEeBFTAALMybRuMleI0TFlb5MY1dPaOV/rL/zlnL8x6kN4NPeK9auOOeaYYt2hUaNGFXMxR2+WCI/qFycHYO7WGXWQEPP8xzzzIUbBus4AAHNavUV9JRcjn2Mk0AMPPFCUTYwgOuCAA2qPxxqYAHM6I5AA2iga7pqb8i2m1Ykp5WLYPAAAADB3+vjHP57+9a9/NXwswqOYAq5+hBLAnKbv7N4BgO5YCbznnnuKXkSjR48u5lWOOYB32GGHdMQRRxS9tgAAAIC5V6x5NHXq1PTkk0+md999t1gnMNYSirWhYr0/4RHQHRiBBADQjQLsO++8s1j8NWy++ebpuuuum927BQAAAPRARiABAHQjF110Udp9991n924AAAAAPZxV3gEAAAAAAMgIkAAA2mDcuHHphBNOSFtvvXUaOXJkMXf5JZdc0vC5kyZNSkcffXRadNFF08CBA9OGG26Yrr/++g6Vd6y1tsACC6StttoqPfTQQ747AAAAoEsIkAAA2uCtt95KJ598cnr88ceLRXBnJhbI/fGPf5x22223dNZZZ6U+ffqkbbfdNt12223tKvPTTjstPf/88+mll14qAqRtttkmvf/++74/AAAAoNMJkDrZxIkT06OPPlr8CwD0PIssskh67bXX0osvvphOP/30Zp939913p8svvzydcsopxfP222+/dNNNN6WllloqHXXUUdlzN9tss2IkU6Pbd77zndrzNthggzR48OBiNFNsY8iQIenOO+9s0/6rqwAAczJ1FQCYc/Sd3TvQ0zz77LNptdVWS4888khaddVVO7StN0a/nUaOnK/T9q0n6tcnpalN07r0Pca8PSaNnG9k6q769uqTmpomp+7s7bffSfPNN6Jr32Sa02GL38O7Y5yTWtC7d6/OOiKZg/Xv3z8tvPDCLT7vyiuvLEYcRXBUGjBgQPrqV7+ajj322DRq1Ki0xBJLFPe3d0RS7969U1NTU5teo64ya6mrtExdpZXUVVqkrtIydRW6A3WVnlVX6e5tKkFdpZXUVVqkrtIydZU5jxFIc7Cm6dNn9y7M0SZPmZqef/nN4t+uNL2p+34Ps6qMulpTF38HUT4vvDK625dTV4qyefn1d5QRtMH999+fVlxxxTR06NDs/hhFFB544IE2lee7775brJ8U6ypNnjw5/eQnP0ljxowp1lWaXdRVZk5dpWXqKq2jrtK6MlJXAeqpq8z+63B3blMJ6iqtLyftKi2XkboK3ZEAiW5r3PiJ6W+33J/GfWC6wGbL6IOyjCbN0u+mu4ny+dutDxTHFM2U0fiJ6T8PPOfvDdogprmL6e7qlfe9+uqrbSrPKVOmpGOOOSbNP//8xQioa665Jv3tb39Lw4YNa/Y1b775ZjG1bvX2zDPP+B5nEXWVVpSRukrrjiV1lVb9vamrALSNukprrsHaVVp1LKmrtOrvTV2F7sicTQAAXWDChAnFdHf1Yhq78vG2WGCBBdI999zTptece+656aSTTmr4WIxeGj16dOqIsWPHduj1Pd174z78jt999500fWrXdVLozt9DWUbvvPtul5ZRVxs79r2u3f64D8vmnXfeSdOndN9y6kpja8dS1/69dXe9Omm23bgmAQDQ8wmQAAC6wMCBA4vp5hotDF0+3tUOOuigtPPOO2f3xQik7bffPo0cObLDDYDTpqc03/waEZvTq9+44t/hw0ekkcMHp64UI9O6o959PyyjEcOHp5HDB6XubP75u27t0t59Pyj+HTFiRBo5rGuPpe6q9//+3kbMgr+37sy6AgAAtIUACQCgC8RUda+88krDqe3Coosu2uXlvuCCCxY3gJ5s+vTp6d13x6RlFxmcRr/5ahr7jv/mNqdXK4Yg9e7duxhBu9BCCxU/A8DcWLd4c/SbRYfAaZ20Rn2sgbTCYkPUVVqgrjLnURuk25qnX9+00jKLpnnm8R/EZstonrKM+szS76a7ifJZcelFimOKZsqoX9+01CIj/b1BG6y11lrpqaeeSu+9l09tddddd9Uep2dTV2lFGamrtO5YUleZaQPPqFdeThMnjk9LLjwi9eurPtcRTU1NafLkyendd99NL730UlG+QM+lrtKKMlJXmevqKmXd4t2x76bJU6ekFH0vOuEWx9KSi87fI8podlJXmfUcsXRbg+cdkLbcdPU0tWna7N6VOb6Mmpomz+5dmfPLaaPVZvduzPFltMHqSxf/Aq2z0047pTPOOCNdcMEF6Rvf+EZxX/Rgu/jii9OGG26YllhiCUXZw6mrtL6M1FVaUU7qKg1F7+AJE8an+eYbWUzN2a9fv/b8uc41WtOrNxpm3nzzzWKtvDfeeKMYUQv0TOoqrS8jdZW5p65S1i1GjBxZzObQmmtna02dOjX11dllptRV5jwCpLlUnzIBnxWaUprW1PmbnTJ1ahr99vtpxIhBqV/fzh9h0/t/XQSGDx2Wes+CwXpNaXoUVaeaMnVaevOd99L8IwZ0SRl9OIix68tm6NAR/ztdRQ/Izu8FGeX01lvvp/lHDO2ccuo9q/64Wml6U+eU0Tvj0rDhwzulZ28n1r86RVMXnKPo2X72s58VvbNfffXV4vdrrrkmvfzyy8XPhx56aBo2bFgREsX6Q8ccc0zRELf88sunX/3qV+mFF15Iv/jFL2bzJ2BW6Oq6Sk/Q9XWVnqHT6yo9SATzffr2LdZ0i6lh+jY1dWpDz9woyi8azMaOHdtwLT/oKieeeGI66aSTFPAspK7SmjJSV5nb6ipl3aKzw6PooDF12vTUp4+6Skepq8xaprCbCxWnvln5f6peXdNY/P4HE9NV/7w7vT9uQuoa5U7PmsLq1QXvE2XzYRl9uGB79z+FdM37RflcdeM96f0POuFY6qHtFVE2N//3qS48lqB7iZFFxx13XDrvvPOK3//0pz8Vv8ftnXfeqT3v0ksvTYcffni67LLL0te//vU0ZcqUdO2116aPfvSjs3HvmVW6vq7S/XV9XaVn6NS6Sg8T6xL06dOn6AwSf3PTOqHjDB82zES5msKOWR0gRQPrI488ouBnEXWVVpSRuspcV1cp6xad3SFl+vQmdZVOpK4y6/Se0xPfo48+ulhkeuDAgUVP3uuvv77F11111VXp05/+dPG6WPxz8cUXL6aRaVQJWXrppYsDrv52wAEHdNGnAgC6uxhFFA0cjW5RtygNGDAgnX766em1115LEydOTHfffXdRRwGAOZ2RXADAnExdZdaYo6ew23vvvdOVV15Z9NxdYYUV0iWXXJK23XbbdPPNN6fNNtus2dc9/PDDacSIEemwww5L888/f3r99dfTL3/5y7TBBhukO+64I6255prZ82MR6//7v//L7ltxxRW77HP1NHff93C64s/XpxdHvVIk9KutskLaf6+d0vzzxbRj1LvuhtvS2Rf+Lu235xfS9tt9UgFV/P3G29OV11yfxrzzXppv5PD05S9snT6x2fpzdRmNeWds+ulFv0tPP/dS8fPPfvittNzS+bopo99+J11w6R/T/Q8/Ufy+0vJLp+8fe0iaW7zx5ttp70OPTwP6z1O7b41VV0wnHX1g7fdHn3g2nfOL36dXX38zLbbIgumQfXdNq6y47GzaYwAAAACY882xAVL00L388suLXrvlwtN77rlnWm211dJRRx2Vbr/99mZfe/zxx89w37777luMRIqpZs4///zsscUWWyztvvvuXfAp5g4fjJ+Ydv78Vmn1j6xQTMN23sV/SKeceVH60Xe/Obt3bY7z9ph30x+vuSEtveSis3tX5jjPPD+qaOD/3rEHpzVWXSE98MhT6YRTz0vLLr14WmTB+dLc3JtivTU/kr60w9bp8O+cPsPjEydOSt/67llpy49umI44YPfUf55+6ZkXPlyHZW5z2XnfT4MHzTvD/e+P+yCdeNp56Su77ZC2+OgG6cZ/351OOPX89Mufntjw+QAAAAA9eUaNZZddNj311FPFWr3QLaewi5FHMZplv/32y6aB+epXv1qMIho1alSbthcLn80777zFgteNTJ48OX3wwQdpbrP3Id9JV/z5n+mIb5+WvrDXEenok36S3hrTuIyaEyNENlhn9TRwwIA0YED/tP22n0hPPv1CmjZtWupKsSjf0ost0OWL833tiJOLEVZHfPv09IW9jkxHn3Rmm8uodO4v/5C+tOM2acjgQWlWmFVltNchxxdldPi3z0g77vV/6ah2lFGMIllowZFpzdVWLEKTtVdfKS0w34j00suvp64W5bPUovN3ejntdchx6Yq/XF8EPzvufWS7ymXE8KHpM5/6aDGqqJHr/3VnGjpkcHFczTtwQHHeXGm5pVJni7JZZP6hqV+/Liij4tg5Pe24V/vKqCW33/1gmm/E8LTNFpumefr1K/4dMXxIcT9AT7gOd2fKaPbWVXqSWKUgyqcr1l7tbNFRMtbCGzZsWOrdu3eaOnVqh7Y3YcKEtMsuuxSzaERd8Dvf+c4Mz/nWt76V1lhjjTR06NC0yCKLpC996Utt/j810PO4DiujzjyW1FVmX13lE5/4RMPrf1doTb2jvaLN/5Of/GQaMmRIGj58eNpkk02sxzgHmGNHIN1///3FgRgV3KqYhi488MADaYkl8mmc6kVYFItVxxR2Z555ZnrvvffSFltsMcPzbrrppiJcisBjqaWWSkcccUQx/d3c4ubb7k7Hf/OANHL4sPTdM36efv2Ha9LhB+yRTjj13PTYE882+7pzTv92WnD+kTPc//BjT6clFlu4OIl0pSGDBqbtPrFOmtrUtUHV/y+j/StldG06/IDdixEyMy+jY2tldNud96XxEyakLT62YfrnLXekWWHI4A/LqKlpcpe/1023/Ted8M39ijI6+YwL0mV/+Gs64oDdijJ69Innmn3duacfU5TRumuuki6/6h/pvoceT2uttlK6/6En0rgPJqRVV16uy/d9yOABabuPrt0l277ptrvTCd/48Ng5+Uc/T5f94dpipFBRLk82f+yce9r/P3Zm5uHHn07zjxyejjvlnPTEMy+khRecL+2xy2fSBmuv1ul/b5uts3zxb5eU0f/+vk4+o66MZvL3dW7l7ysc8I3vp+nTpqUVl186fXW37YvzUHj+pVeKkWxVyy61eHE/QE+pq3RXs7Ku0p11ZV2lp+jdp3caPG//1Kf3HNtHsiamWz/wwAOLBpiYKaOjovPVxhtvXGzz2GOPbfY5F198cREijR8/Ph100EHps5/9bPH/amDupa7SijJSV2ndsaSu0qPqKh2td7Q3PIqla37605+ma6+9Ns0zzzzp3nvvtc7RHGCODZBisenoGVWvvO/VV19tcRsbbbRRevLJJ4ufBw8eXCSiMYKpKirQsZ7SSiutlN5+++1inaVYcym2f+qpp850+2+++WYaPXp0dt8zzzyTupvtPvXRtPCC8xc/f3yz9dOfrrmh+Pmkow9q87aefX5U0fh7zBEd/49QS6ZOm5bee39CGjR4ntS3i8OqGcvoxuLn6horM/P+uPHpF7++On3v27N2XZooo7HjJqShg/t0eRl95lOb18ooRqX9sY1l1L//POmTm6+fTjrtgmK/ozdmBFAjhw8tRgh2+bE0dmIaOnhgp5fTZ7b6/8fOJzZdP/3x2raVS2uOrYcefSp9+8ivpRO+eUC6+/5H0g9+clERQC268IKps4+l4SOmdX4ZVf6+2nPsDB06KJ35/W8Wa0NNnDQp/e6P16Vjv392Ov+M76RB8w5MEyZOSoPrgq+Yum7ChEmd+jkAZmddpbualXWV7qwr6yo9RVNTU5o2fXrq0xQNG2mO9ulPf7r495Zbbmn4+F133VWMGIq1feP/sXvssUc64YQTUt++jf/7HjN1RCfI8udGTjnllFqjTzTIxLTwa6+9dnrnnXeKQAuYO6mrtK6M1FVaeSypq8yWusoBBxyQbr311mK5l7POOqu47/333y/auH/0ox+ll156KS255JLFEjF77bVXh9+vNfWOiRMnppNPPjn94Q9/SGPGjEmrr756Mbgj6h7NOfroo9NXvvKVYgmb0oYbbtjh/aUHB0jRG6t///4z3F8emPF4S6KHVYw6eu6554qf4zXT/tcwXfrLX/6SvWafffZJ22yzTfrxj3+cDj300GLdpOace+656aSTTmr4WPxx1IdLbTV27NjUFfr165cG/a8xNU5eQwbNmyZP/rAhNYZSjhs/vvZ7W7ww6tV04qnnp6/tuWNabeVls23EOi1x60zvjZuQrr/j8bTVpisV/5nuTL179U5Dh/xv9FtT+l8ZfRhi9Ovb939l1PpQ48JLryzWXllgvuHF66ZPn15cXKvbmDp1Sho3/oPOL6P/PJk+vemKadjgxif1jhg69H//2awdR2UZ9UkftLGMrr/lznTlNTek0074elpqiUXSi6NeS9/98S/SgP790lqrrfj/P9N773T65xg7bmL6x3+eSp/eaOU0rIPH0sB550395un3v9+a0pDBlXLp17fN5VJvypSp2etjzaOVV1g6rbfmKmn69GnFv8stvXi6+75H0rZbblY85/2x7xV/6x0RFeZ/3vlE+tQmqcNlFOfxCAwbHzttL6PovbPMkosWn3+efn3Tnl/8TDEi7uHHnkrrrLFKcV+sg1TdZvw+dMig2n0TJkzslKCysyqBCyywQOdsCJit4jp85d/+k3bebqM0cvhg30ajMnp/Qrrir3emXbfbII0cPmum+O2O3nt/Yrr8urvTrttsnEYOcyw1Mn16U3pv3MQ0Yljf1LdP7zR+4qQ0Zcq0NGzIh+sdjhk7Lg0a2L+oO02cNDlNmDQljRj64TH3znsfpIH9+6UB/edJkyZPSR9MmFQr57Hvjy+m8J13QP80ecrUNO6DeI9BRRDz3rjxxawLsd3OEh0gt9xyy3Th/2PvPuCbrPM/gH8yuncpU7bILENlKCo4UAS3womKin8Vx53zPBDPAZzjFOXkREUcCNwpKuJAcYs4QNATkAKiTJlC6R5pm/F/fX8lIWnzJE/bpMnTft5eLmkSnjz59kmeb3/j+3vxRYwZMwZ79+7FRRddpPKnv//97yF7nU8//VRV32DnEVHzxlxFR4yYq+g7lppBrtLQ3CItOVHlKmZzJRLiY0KWW8yZM0flD6eccgoefvhhdd/bb7+tqmstWbIEp59+OpYvX45LLrlElc+9+OKLa23j22+/VTOTA1m/fr3qiNJDZift2bNHDZZp06aN2sdzzz1X7aeUpqtJZkdLB5hMBpHqY9u2bUPnzp3VDKfLLrtMdyyomXUgJSQkoKKiwm8PpvvxYGQ6ndu4cePQq1cvdfvJJ5/U/DfyYZVe1E8++UQd5OPHj9d8rkz7Hzt2bK0ZSPJBzMzMrHcD4MECJxatKMf3m4BduRb1x1AoDehqwlVnVrdyVlYB2w4A1q3VP8ttue/HrSa8/t85+H2Xdumxm/88BWlp1R0IB//Yh/8ufB5nnHUBklsPwo81JmItX2/Gsh9CO0UzLd6MC/oAh8tT0bVzGkLN7F4izARYY6xqpJ6Q2+6Re1I2bONm7Vlnc2Y+oEps/bzpN5SV2fDBp1+r+0vLytVsrV9+24n7/3qjui82NgbxiSHuCLOWqOuM9PQwNcoc+QoxmWrFCJ4YPYecADF6Yeb9Kka79hzAoAF90OO4Lup+uZaydutyfsXAAb09287KahHyd2G2VnfcyR/QDU50TN69CCY1UtQTFzVq9Oixk/NLgLg8VX3s1CSdUO7tiWO7dMD6nF997jOZzD6v26JFw2NmjnEfSxkhaQQ9GqJAx86zQY4d/zGq3uzR2Hfr0hHvLlvuE6Odv+/DJeef6bkvJuboYw1hNkf5kGeiEHHk5WH3hRfCUVWFisxMtPvgI8aWiKJKzq+7se33P3DF+aeon9/66HsMH9wbPbu2w5Yd+7F2005MuHS4euy9z3/E8b07o3/PTtix5xBWrNmEm8aNUI8tW7EWx3ZsjcH9umHfH3lYtmIdJl5+FqxWCz5fmYOWmak4bWDPkO33s88+qxpw5O9XIZ08f/vb3zB16tSQdSB9/vnnaiCkNC4RNVV5exx48dYiOKrMyGxfiOvnhL7NgIial4bmFjeMPVM99uk363Fsp/DmFjIQRWbzuJdykcEp8vMLL7zgtwNJqnPJrORQkApf8+fPx+bNmz0TM/7yl794StP5a2uXiRgy2H7BggXqOTJTSSZ9SD60YsUKnzZ+anxR24EkpepktJW/0naiXbt2ddqeNAzLIlz//e9/A3YgCffaSnLwBtKqVSt1CbWKKhdmL5UZVtIQ6Qz59gvLXKg8sk6rdE3ZHfD8LLflPvn5sstvDroteV7uof1Y9N/ncNrw89C77xDPtryV2Fw4XBzajjCXo3p7766sxKDqvsFG948pf9b1vJkP3wOn4+jv8tF/vaw6R84fWX1iacr+MUVfKcSex3XBvNffUzOP3DOQ/rd+M64eOxpNkd5jR1RKr+4RdrvMXKtSiYXMpjzrtCGqLN7q/23AoOP74Ie1G7F1527cfcvVaC4x+uW3HUhMSMAx7VqpWUSvvf2x6kDq1b2renzo4P546T9L8MmXK3HmsMH48us1yCsowtBBA8L8DoiaNseRmdahz1SIiBouu3sH9Ohy9G/GsaNO8ozm7dGlLTq2qy6fKy4aMVCNEhZd2rdEqxYneR4bPfx4NQNJtGudiXHnDYXFUj3QbMTQ7JCv+yoDEmWUsPfMIGlQkYu7TI38TevuXMrJyanT9t0NN//5z3/USGCipkoKMJQcljYDE8oLQ9sWQUTNU6hyi3NO669mIIUzt9i9ezfOP/98n/u6deumBpGEm3t5F5lN5E3aa2RWkpTU69Onj+d+mZ3k3lcpsTdo0CB1+9JLL8UZZ5yBd999lx1IERa1HUgDBgxQibOUoEtNTfWpB+1+vK6khJ2esnBS8i6SJYTaZ5nRKs2Mg4XGaJJZ8/1ylJWW4svP3lEXt+tvmoLUIzOUwqm4PPrjlJmeVmsWiazNkpbaNKf11oesf3QoNw9Tn5iDgsJiVV7snDNOwjlnnIyqqqMdKM3RRdfc6bl95/0z1PXjD9yBfn26o12blvj7nTfgxf8swT///Yr6+f67blDXzcWBg4cx/42lyC8oQlxsrCrp98h9f1GfMZGSnISHJt2MZ19+A8+98iaOadsKUyfdrMoLElEI6jWGeKY0EVEoSFkYeFVw9p5lLuVk5OLmLjcjpAyNXNzcZWqElMX1nomdGoZcQsq8XHHFFXjllVf8Pi6NLHKpD+l4+vOf/6zWI3Cvw0TULFKV6G8yIKJmkFs4jgwsl9xCyu2GMrfwXq7FPTlCysB5k5+1StDJGkqjRwcewL1x40ZdJewklwlW8k7WaKrp2GOPVYOBKfpEbQeS1HuWmUJz585Vi3wJKWknaxnJAlruWULSayl1Env2PDq17+DBg7VmBu3cuRNffPEFBg4c6LlPZhhJ7Ufvnl1pqP7nP/+pyhpJL2ckyIfl9osSUWErxtB+mUiMC+2HJ9YKJB3Z5tBnq2tjuplLrfg2xoShvY7+0RTM0F6yAFvgRdhO6GbFnZeEroTa979U4pH/VmBfYRKcztCWxqvpxX896FP6KhQef+hoh0A4ySyVti3TYbWGN0bzZ08PyXYuv2SkujQ2iU+brPSQL0o9f/Y/QrKdjxY9G/BxmXkkl3CS2LRITwr5sRSKGJ1+ykB1CSS7Zzc8PyN06wYQNXte35cup6PZh0OL/GFYfR4O7fmlKWmsXMXowpWrNMXPnBHaHWRdXvm7073+ovyda7fb1d8csmaAlJmRdXll7SP5W3XHjh1qNG+gGUOyDVnzUmYqyfal9Ls0Jrn/jpk9ezYefPBBNQPptNNOa7T3ShQpJq+vywYuB9ukMVfRESPmKvqOJeYqEc1VpNPmt99+8/x8/fXX48Ybb1S5hJz3pQycDE559dVX/f57eY6/Tp365B0yQ1rK5EnZumeeeUb9LNuWdZZkQohUHfNHni9t8jKQpl+/fipnkf2ePj00bY7UBDuQpJNI1heaMmWK6hCSaXZSP1E6gl5++WXP86655hp1MHkvEN+3b19V41EOSpn6Lx8g+TfuziE3qaUoi4tJZ1WXLl1Uh9Jrr72mygA8+uijnh7TSPjTsHgc+KMYLbJC/0eifE/V6Jj2kCVa5IssNia032ZWqwlJXr30DZWWaEaRLQ5vre2JU3pH7WEccanJCbh05BC4XNV/nFKAOI2oniJL2jE6c3CPsIy0JSLjMXknEhzWq0m+M+U8bHexk007RsxV9GCuEpyUfklJiodF6w+dKLJw4UK1DoFbSkqKuv7yyy/VQteffvqp6uyR2ULyN6wsIi2l6wKRAZW7du3yjCJ+/PHHMXz4cFXVQ9x+++1qfUjpmPL20UcfsUOJmiTvBloXZyBpYq4SHHMVfZirRDZXufvuu1WnUWZmpmojl/WMpAqX5BJSzk5mAj399NOqLFwoBMs7ZNaz3HfOOeeo5Wgk15GSdtKhpOWOO+5Qk0RkLciCggIcd9xxeOONN1QfAUVWVLe8y8JZDzzwgEqw5cB39z4OGzYs4L+TUVsffvghPv74Y9XDKbOR5IC97777VOeSm9zu3bu3qv986NAh1UsqnU4ypV86ryi6mU0uJMRUwYTo/yNRj3AMinI4naioqEJcHML0x3R1TWmjkzjZym1qurERGh0iFaNyW6W6ZoyIyGckCjuQNMmIvNKKSljjLPzujFiu0jQwV9HBJZ85lyGy0wkTJqiLFmko+eSTT+q0TZmlFIh7DSWWhqHmwmQ++k3gYrldTcxVgmOuog9zlcjmKieeeCLWrVvnc98NN9ygLv7I4BR3blAfwfKOhIQETJ06VV3qQiaSSPs9RZeo/istPj4eM2bMUD2VMhVuzZo1tWo1f/XVVz6zj4QcnD/88IOaUSQjtvbu3YvXX3/dp/PI/eGSWUiygJdMvZPOJuk1beqdRxIt+Y6QHKrm5aSBA/DKMw/7fazeF2fop4zLaKL0BBtuGLoBsRYbwsEJJ+Rr3VZhU9fu/04e1A/zZk/3uS9U/4VaYVEZXl2yAoVF5QgPGVHtrHUZOqgv5s+e6vex+lwqKmxHbodnBLfEZ/5736CwuKzhG5Nfoxzwfi5DB/bD/Gemaz4elkuI/liS2HzwdY46pkJBa3dPHtgfrz7zj0YNEUtaEDWwhJ2Ds2u0FBS7z8Oh+e5sisKfqzQNIc1VmnDDVWFJuWd9ASJqfNKuIrPrZKS7rGUto81XrVoVkV+F95gEzkDSxlwlOOYq+jBXCY65ChlVVM9AovBRTcoGrgPsUy80jO/D3YGUnHJ0QTuqKfx/pFdUlCPFawHjqGfgzxYRUZ1L2LEXloiIiAC1lpeMapd1Ltq3b6+qu0gpIlmKIDm5cf+mNnGyNBERUdOfgUSkpZH6j4iIiMgf7w4kzkAiIiIiAElJSWr9LpmBJIupjxs3Ti0VsGXLlkaPj3cHEse6EBER1R87kMj4C2JGckeIiIiaoxozkGqWEyYiIuPjd7txlZSU4KGHHsK5556rFlSXta9effVVzbJzkydPRrt27dSaFbIG12effRaS/fjtt9/U0gLdunVDRDuQWG2XiKhJYq7SONiBRIYk/UcOlwmHS+PhdPIw1mKxmJGRlgSLJdqXEo4siU9GahIX7w4UI7MZqUnx6pgiIlKLsHuP5mjAAqxNmcVsOnIe5nenZoyYq+g7lpirBPicmeFwOFQDgtxm1hsaEk+Jq8wiIePJzc3F9OnTsXnzZvTv3z/gcydMmICZM2fiqquuwqxZs2CxWDB69GhVhq4hysvLMX78eLUgelpaGhobq+3qw1xFR4yYqzS7XMU7twjHtpmrhAZzlcZj/E81NU8moLA8Hv/5oQ9sjvhI703USktJxJUXnKquKXCcrhg9lHEKEqORp/RmjIjoKIvl6G2WsdP47kzieZi5SkgwV9EWFxcHh92Ow4dzkZIUxw7bEDXIHDx4UDWeSXzJeNq2bYv9+/dj165dmDFjhubz1qxZg0WLFuGxxx5Tz5s4cSK+/PJLdOrUCZMmTfJ57qmnnqoGkPi73H///T7PraqqwtixY9XMIylpF7HBLkc4nZwprYW5SnBsV2l+uYo7t5BzYSg7kaQzMjWZA3NDgblK47I28usRhUR1LiijDFk2J9gXql2NHHT5JNBUO04Ou0OdzBkn7WPJ4XCqa8aIiNS52Gw+WkaWJey0z8N2J1w8DzNXaSDmKtpatWyFispKVSaroKAAMTEx/JIOIFge5x7NKxcpZ9a6dWvG06CNn23atAn6vMWLF6sZR9Jx5BYfH4/rr78e9913H3bv3o0OHTqo+/XOSHI6nbj66qvVsTZ//vyI/e3gU8KOE6U1MVcJju0qzS9XcecW+Xl5KCosgsXqNXCugdimEhxzlejDGUhkSHIqyky04S/D1iLeWh7p3Yla+YWleGHR58gvLIv0rkQ1ic/cxV8iv6g00rsStSQ2S75Yp44pIiLFqzyFizOQNL87q8/D/O7UPL8wV9F3HmauoklKrHU4pj3i4hKxY+9hVFbZ+SXdwEab2NhYpKeno2PHjixh18StXbsW3bt3R2pqqs/9gwcPVtfr1q2r8zZvuukmNfvprbfegtUauTHLPh1InICkiblKcMxVml+u4s4t0tPSESsDU+Q7JASXyko7tu8+yFylgZirND7OQCLjYzJIRETU+Lzrm3MNJCKKcENPenomtu/fgkHH90NmejJ/H5qxMvaocAot6eiRcnc1ue/bt29fnbYnJfNeeuklNYspKyvLc/9HH32E0047ze+/kRJRhw4d8rlv69atCGkHkqPBmyOiZphbtGkdfCZnXeQVluDL/+3ECf37MlcJGHvmKtGGHUhk+OmMHE1ERETU+EwWy9ExHOxAIiIiMpzy8nK/61xJB5D78bqQtZPqul7Ic889h2nTpvl9TEpT1uxc0supOo2qy07JPh3Ord92mrqikurfcUFBPpx2W1heo7CwEE0hRvkFBWGLUWMoLCwK7/ZLqmOTn58PZ5Vx4xROhZ5jKXyft6YgVBUQW7ZsGZoNETuQyJjYF01ERBRFJeyqW2mIiIjIQGSdq4qKilr322w2z+Phduutt2Ls2LG1ZiBdfPHFyMzMrHcDYHVHVn71bacJmS2yDL8uSziYYkrUdXp6RlhnRHjPSDMas7U6Rhnp6chMT4KRZWW1CNu2zdbq0nUZGRnITONMYL8xOvJ5ywjz583oOAMp+nAGEhmS5H1OlwklFTGsYBfkSzcxIQ4mTv8MfDxJnOJj+QdFwM+cCfFxMTyWiMj7JHP0tpP1ZP2eh03V52H+EcRcpaGYq+iIEXMVojqTUnV79+71W9pOtGvXLuxRbdWqlbqE4ztB2g08E6Lkmv1HtTBXCY7tKjo/c2xX0fW9xHYVMiKvv/yJDMQEFJTH4+VV/VBWFf5RUUaVnpqE6y47HRmpiZHelagm8Zlw8XBkpBp7NFE4SWwuGN6XMSIiD5N3B5KDM5ACnYflmvxjrqL3PMxchbkKUegNGDAAv/76K4qKfEtbrV692vN4Y5o6dapqYM3Ozg7J9rzXQWK1Xf+YqwTHXEUf5ip6YsR2FTImdiCRIXkPHOKYZyIiokiXsHPyV0BERGQwY8aMgcPhwNy5cz33SUm7efPmYciQIejQoUOjdyBJ6bmcnJyQdyC5mKoQERHVCzuQyJBkKnpmYjn+fNpPSLDUbWHP5iS/sARzXv8MeYXVtWjJP4nPC299gbzC6nq05C9GJXj787WMEREdZalemFphB1LA87BcE3OVhmCuoidGzFWIvM2ePRsPP/wwXnnlFfXz0qVL1c9yKSwsVPdJJ5GsPzRlyhRMmjRJdSSdeeaZ2LlzJ5544gnDB9R7ySNPKTvywVwlOLar6MNcRU+MmKuQMXENJDIkdx5otbgg/5F/kiQ7HE5O0wrGHScKyClrnPDjRkTuc7HPGkgsYadxelHnFzZaBTgFM1fRh7mKLsxViI568sknsWvXLs/PS5YsURcxfvx4pKWlqdsLFizAAw88gIULFyI/Px/9+vXDBx98gGHDhhk+nD4zkJiq+MVcJTjmKjoxV9GFuQoZEWcgkeFHEhEREVGES9ixE56IiCiqyCwiKQfn79K5c2fP8+Lj4zFjxgzs378fNpsNa9aswciRIyOyz6FeA8l7rAsHcxAREdUPO5DI+B1InBFBRETU+HxmIHEWJxEREUXbGkgm31H/REREVGfsQCJDsztMcLk4HSlQR5vFYj5a8480AnUkThSQWf4A47FERO6vTpawC0q+MuX8wpnTAWLEXEUf5iq6MFchIp+vTu8ZSBzronV6Ya4S7BTMXEUf5iq6MFchI+IaSGRYeWUJePabE9Cnk9ci3uQjIy0ZN19xNlyuSkYmgMy0JNw09izGKGCMknHZiOPVNRGRYvE6/3JUb8DzsJ0LL2hirqIPcxU9MWKuQkS+2IEUHHMV/TFiu0qw8zDbVYJhrkJGxSH3ZEgcyUtERBRFayA5uTI1ERERRfEaSJyBREREVC/sQCLDTrNOT7Dh+pN/RoK1PNK7E7UKikox7+2vkF9UFuldiWoSn1ffXYH8otJI70rUktgsXbGBMSIi/yXsHGyVCXQelmvyj7mK3vMwcxXmKkRNX8jXQPIqv83lGv1jrhIccxV9mKvoiRHbVciY2IFEhiSjkswmF5LjqmQsUaR3J2rJQqFl5RVwsbRQQBKfMlul+mOFNGLkcsFWUcVjiYj8l7DjsF7/52FX9XmYC3czV2ko5io6YsRchYgClrDj33r+MFcJju0q+jBX0REj5ipkUOxAIkPyHknENn8iIqLIDOZwczlYwo6IiIiii8nslauw/4iIiKhe2IFEhuTVf0RERESRnoHEujBEREQU1TOQIrknRERExsUOJDIm9iARERFFlvcaSOxAIiIioihOVdiBREREVD/Wev47ooj3H+WVxWP218fj2LY8jLVkpCXhpnEjYDbbG/X3YzQZaYmYOOZMWCzsU9eMUWoSLj1rgDqmiIiEyatVxuXgsF6t7045D7vMrJujfQ5mrsJcJTSYqxAZ39SpUzFt2rSwzEDiWBf/mKsEx1xFH7ar6IgR21XIoNhaSoZUveyCCQ6nGWySCRQnE6xWi886FcQ41e8zZ1IdbDyWiMhvCTsO6+V5uJ6YqzBOocJchahpdCDJIvM5OTkh2R5L2OmIEdsMGKMQ4bGkL0ZsVyEjYgcSGZL0h6Ql2DB+0EYkWG2R3p2oVVhchteWfquuKXCcXl+2knEKEqNPvtvEGBHRUd6DExwORsbvd2cpz8PMVUKCuYq+GDFXISJv3oPfXE4OPfX/3clcRc/5he0q+s7DbFcJHiPmKmRE7EAiQ5I00GJyoUWSDSbOQdLkcDiRX1gKh4PJciASn/yiUjhY10A7Rk4nikpt6pgiIlLnYq8ZSC5+f2p8d7qOnIf53clcpWGYq+iIEXMVIqrB7D1Zmn8Sa3x3MlcJfg5mu4oezFV0xIi5ChkUO5DI8JgHEhERRbiEHTuQiIiIKIonS7PaLhERUf2wA4kMiUv6EBERRVMJO86wISIioujivQYSx7oQERHVDzuQyPg4BYmIiCjCJey4BhIRERE1zNSpU9W6RdnZ2SEJpdmrxYszkIiIiOqHHUhk2EHPBeXxeGllX5RUxkV6d6JWWmoiJlw6HGmpCZHelagm8bn2otOQlpIY6V2JWhKb84dlq2OKiKjWDCQO6/UrPcV9HuZ3p+b5hbmKvvMwcxXmKkTNpAPJ5XIhJycn5DOQ2IHkH3OV4Jir6MNcRUeM2K5CBmWN9A4Q1bfNyukyobQyFk4X+0G1WMxmxCXGwOWq5IEWJE5JCbGMUZAYJcTHqmsiInUu5hpIQZnl/JIYD7uLM7SYqzQMcxV9MWKuQkTeTOajg11cTpYu8Ye5ir7zC9tV9MWJ7SrBY8RchYyILYFkSJIGpsZXYOzxvyDBWhHp3YlaRSXlWPLJanVNQeL0+Q+MU5AYfblmC4pKyngoEVE1diDpOA+X8TzMXCUkmKvoixFzFSLyxjWQ9Hx3MlfRdQ5mu4q+OLFdJWiMmKuQEbEDiQxJ6iJbzU60SyuF2cyFu7XY7Q7sP1QAu50xCkTicyC3AHYHR4hrxsjhwOGCUh5LROR9MvbcdLGEncZ3p/PIeZjnF+YqDcNcRUeMmKsQUaA1kDgBSeO7k7lK8HMw21X0YK6iI0bMVcig2IFEhuS16gITQSIiokiXsGMHPBEREUXxco1cA4mIiKh+2IFExu9BIiIiosgO6+UMJCIiIoriEnbsQCIiIqofdiCR8UcScSo6ERFRRDuQWMKOiIiIGmrq1KmqXH12dnZIgskOJCIiooZjBxIZkvQfFdrisHBNb5RUxEV6d6JWakoCxp1/ClJT4iO9K1FN4jNu1MlITU6I9K5ELYnNOUN7qWOKiKhWCTvOQNL87qw+D/O7U/P8wlxF33mYuQpzFaJm0oHkcrmQk5MTku2ZzEdHnjqdHHnqD3OV4Jir6MNcRUeM2K5CBmWN9A4Q1XcGksNpRl5ZAhIS2A+qxWqxoEV6MlyuSh5oQeKUmcaOyGAxSktOUNdERJ6TsRs7kAKeh+0uBw8a5ioNwlxFX4yYqxCRVrVdVi7R/u5krhL8/MJ2FX3nYbarBI8RcxUyIra8k2GlxFXgguytSIipiPSuRK3iknJ8uPwnFJfYIr0rUU3i8+HXa1FcWh7pXYlaEptvf9rKGBHRUV4dyi4HO0i0vjurz8M8v2ieX5ir6DsPM1dhrkJEDSthx1TF//mFuYqOczDbVfRgrqIjRmxXIYNiBxIZkox5jrE40TWrEBaTM9K7E7Wq7A7s3HtIXVPgOO3al8s4BYnR/twiVFXxWCKKpOTkZJ+L2WzGU089FZF9MXkP63Xyu8EfnoeDY4z0Ya6iL0bMVYhIswOJFex4Hq4n5ir648R2leAxYq5CRsQSdmT4qjkuMBMkIqLmoaSkxHN737596NixIy699NLI7IzVK410cDAHERERRXG7Ace6EBER1QtnIJExeSWC7D8iIqLm6LXXXsPJJ5+MLl26RHwGEkvYERERUbThDCQiIqKGYwcSGRL7j4iIKJKzgB566CGce+65yMzMhMlkwquvvur3uRUVFZg8eTLatWuHhIQEDBkyBJ999llI9mPhwoW45pprEDE+M5A4rJeIiIiii9l8tOXA5WTlEiIiovpgBxIZdip6kS0Wb63tgZLK2EjvTtRKSU7AJecMRkpyfKR3JapJfC45ayBSkhIivStRS2JzxqDuPJaIAOTm5mL69OnYvHkz+vfvHzAmEyZMwMyZM3HVVVdh1qxZsFgsGD16NL799tsGxfLnn3/Gr7/+irFjx0bsd8IZSMGlJMUfOQ/z/KIZI+YqujBX0fN5Y65CRDV4l7Bj/5HGdydzleDnYLar6MFcRUeMmKuQQbEDiQybB9qdFuwrTIbdYYn07kStGKsF7VplqGsKHKe2LRmnYMdSVkYyYrxnHBA1U23btsX+/fuxa9cuzJgxQ/N5a9aswaJFi/DYY4+p502cOBFffvklOnXqhEmTJvk899RTT1Uzmfxd7r//fr+zjy644AKkp6cjYjgDKSj5zuR5OFiMmKvowVxFX4yYqxCR5hpI7EDS+O5krqLn/MJ8Tt95mO0qwWPEXIWMiB1IZNhEMDmuEuf03IH4mMpI707UKimz4fPvNqhrChKn73MYpyAxWrNhJ2NEBCAuLg5t2rQJGovFixerGUfSceQWHx+P66+/HqtWrcLu3bs998uMJJfL5ffy8MMP+2zX6XSq9Y+uvvrqiP4+TBavwQksYecXz8PBMUb6MFfRFyPmKkTGNnXqVDV4Jjs7OzQbZO37oHgeZoxChbmKvhgxVyEjYgcSGZIklbEWB3q1yUOMmesuaKmstGPLjn2orGSMApH4/LpzPyqr7GE4WpsGic2u/XnqmCIifdauXYvu3bsjNTXV5/7Bgwer63Xr1tUrlF988QWqqqowatSooM89ePAgNm7c6HPZunUrQsJ8NI10OfjdoPXdWX0eZny0MFfRh7mKjhgxVyFqEh1IMngmJycnJNtj/1FwzFV0xIjtKrowV9H3eWO7ChkRaxERERERhYGUuZNydzW579u3b1+9tivl68aNGwerjpKSzz33HKZNm+b3sby8PBw6dAj1VVFR4bldXlICR279t9VUFZWUq+uCgnw47eGbDVxYWAijxyi/oCCsMQq3wsKi8G6/pDo2+fn5cFYZN07hVOg5lsL7eWtKJb0aomXLlqHZEFE4heh4JyIias7YgUTG/8OHtYyJiCgKlZeXq3J3NUkZO/fj9bFgwQLdz7311lsxduxYn/tkBtLFF1+MzMzMBjUA5qekwN2FFB8bi4wsNibWZIopUdfp6RnITE9GOGVlZcGIzNbqGGWkpyMzPQlGlpXVImzbNltL1XVGRgYy08J7LBmV+cjnLaMRPm9GZjazRZ2aKbYbEBERNb0SdjKydfLkyWjXrh0SEhIwZMgQfPbZZ0H/3TvvvIORI0eqfycNN+3bt8eYMWM0p0G///77OOGEE1SDTseOHfHQQw/BbmepEaNgHkhERNFIchfvWTpuNpvN83i4tWrVCn369PG5dOvWLSTbNnnPgOIaSERERBTFA09dbDggIiJqeh1IEyZMwMyZM3HVVVdh1qxZaiHq0aNHq4WmA9mwYYManXfHHXeo0i233HKLWodA1hxYv369z3M/+ugjNQo3PT0dzzzzjLoti1XfdtttYX531BCSBxZXxOL9DceipCKWwdSQnBSP0acfj+Sk2iPgyTtOcRh92gAkJ1bPCiA/x1JiPE4Z0FUdU0Skj5SqkzJ2Nbnvk4EuhmaxeG662IGk+d1ZfR7md6cW5ir6MFfRESPmKkRUEyuX6PruZK4S7BzMdhU9mKvo+7yxXYWMKGpL2K1ZswaLFi3CjBkzcM8996j7rrnmGmRnZ2PSpElYuXKl5r998MEHa913ww03qJlIzz//PObMmeO5X7bdr18/fPrpp561BGSx60cffVR1QPXs2TMs748aPpKoymHBjsPpSE9mGQYtsTFWdGnfCi5XJQ+5IHHqfAxLLwWLUbtW6eqaiPQZMGAAli9fjqKiIpVbuK1evdrzuJGZvDqQOAMp8HnY7nI01q/FcJir6I8Tc5XgMWKuQkTe2FKg/zzMXCV4jNiuwlyloZirkFFF7QykxYsXqxlHEydO9NwnJeauv/56rFq1Crt3765zCZfExEQUFBR47tu0aZO6yGt4L0Qt6wW4XC61DxS9HUiJsVUY1m034q3sHNFSWl6Bb37YrK4pSJx++oVxChKjtb/sZoyI6kDK5zocDsydO9dzn5S0mzdvnirL26FDB2PHkx1IQZXxPBwUcxV9mKvoixFzFSLSwgp2/jFX0XkOZruKvjixXSVojJirkBFF7VByKTnXvXt3nxG7QsrQiXXr1gVteJHOoqqqKhw4cABPP/20GgF81lln+byGGDhwoM+/k5IyMlvJ/ThF50iieKsdx7c/iJ35nDmipaKiCj9v+R29u7VBUgLL2GnHyY4Nv+5Gn2PbM05aMaqswtbfD+HE7CrGiAjA7NmzVZ6xb98+FY+lS5diz5496raUwU1LS1OdRGPHjsWUKVNw8OBBtfbQ/PnzsXPnTrz88suGj6P3DCSWsPPPVll9Hu7RrR2/OzUwV9GHuYqOGDFXIaIAayCxB8k/5ip6zsFsV9GDuYqOGDFXIYOK2g4kWR9A1g6oyX2fu8EmkJNOOglbtmxRt5OTk3H//ferGUzer+G9zZqvE+w1pDHo0KFDPvdt3bo16H5RCHAuOhERRdCTTz6JXbt2eX5esmSJuojx48erDiSxYMECPPDAA1i4cCHy8/NV2dwPPvgAw4YNg+FxBhIREREZpN3AxSlIRERETasDqby8HHFxtWdMSBk79+PBSIkYmXW0fft2dVv+jZSSMZvNPtvQeh35t4E899xzmDZtmt/H8vLyanUu1VVhYWGD/n1TVuz163c6ncjNzQ3baxn591BUUh2o/IICOO02GFVhYVF4t19SHRtp3HVWGTdO4VToOZbyDX0sNeooxwZo2ZIzK6OdzCLSQ/IJWc9RLk0NZyARERFRc8jNiYiImrOo7UBKSEhQ6wTUZLPZPI8Hc/LJJ3tujxs3Dr169fKMGvbehtbrBHsNWStJStPUnIF08cUXIzMzs8ENgA4n0CKLjYj+xJQ5Aeyt/sFkQlZWFsIp3NsPF7O1RF1npKcjMz0JRpaV1SJs2zZbS9V1RkYGMtOSw/Y6RmaOcR9LGchMZ4w042TmX6nUjHAGEhERERkFZyARERE1rQ4kKSG3d++RDgIv7rJzsk5RXUjD8Jlnnon//ve/ng4kd+k62WbN9ZTkPvd6S1patWqlLhSZkUQllTH4ZHNnlFbE8FegISkxDmcNzUZSYixjFIDE58whfbg+RaAYJcRhUHYndUwREalzMTuQdH13Vp+H+d3JXKVhmKvo+7wxVyEizRJ27EHS/O5krhLsHMx2FT2Yq+iIEXMVMqjqWm5RaMCAAfj1119rlZFbvXq15/G6kpJ13uXI3Nv48ccffZ4nax/JQtj1eQ1qvDyw0m7FL3+0QKUjavtBIy4uNgY9ux6jrilInLq0Y5yCxKhzuxaMEREd5dWB5HI4GBmeh5mrhBFzFX0xYq5CZGxTp06FyWRCdnZ2SLZn8u1BIj/YZhAcY6QPcxV9MWKuQkYUtR1IY8aMUesVzZ0713OflJqTtYyGDBnimTH0+++/45dffvH5twcPHvS7VsEXX3yBgQMHeu7r06cPevbsqV5DXsvt+eefV0mL7ANF7wykhJgqDOm8D3GWqkjvTtQqt1VizfqtKLNVRnpXoprEZ82GbYxTkBht3LoPZbbaJT+JqHnynYFkj+SuRK1yW4U6D8v5mLRixFxFD+Yq+mLEXIXI+B1ILpcLOTk5odmgd/8RO5D8Yq4SHHMVfZir6IsRcxUyoqiduiGdRLK+0JQpU1SHULdu3TB//nzVEfTyyy97nnfNNddgxYoVKslw69u3L8466yw1g0hK1/3222/q31RVVeGf//ynz+vIotYXXnghzjnnHLVOkiQqs2fPxg033OBZM4miU0KMHSd13o/dBRmR3pWoTnR+2LANx3ZsgcR4lrHTYrNV4ceN29GtY2vGSStGFZXYtP0A+vbsisR4lmIiIskij6aRLlm4kWqfhyuq1Hm4c8eWSOB5mLlKAzBX0REj5ipE5GfgKQXGXCU4tqvow1xFR4yYq5BBRW0HkliwYAEeeOABLFy4EPn5+ejXrx8++OADDBs2LOC/u+WWW/Dhhx/i448/RnFxsVqnSDqI7rvvPtW55O3888/HkiVLMG3aNNx2221o2bKlet6DDz4Y5ndHDcOp6ERERJFkMntNZGcJOyIiIopmnIFERETU9DqQ4uPj1QwhuWj56quv/E57loteF198sbqQMUcSMQ8kIiKK9AwkroFEREREUYbtBkRERE13DSQi3R1I7EEiIiJqdJyBRERERNHMp4Id2w2IiIjqhR1IZNhEsKwyBit+a4/SyphI707USkyIxakDe6prChynU47vwfWPAsUoPhYDerTnsUREfmcgwWFnZDS+O3keZq4SCsxVdMSIuQoR1cQ1kHR9dzJXCX4OZox0HEtsV9H1eWO7ChlRVJewIwo0A8lmt2Ld3taI4VGsKT4uFv17doLLVcmDKYD4uBj079GRMQoYo1gc16mVuiYiUudii8UTCJfDyaAEOA/bXSzxx1ylYZir6IkRcxUi0sbKJdrfncxVgp9f2K6i5zzMdpXgMWKuQsbEGUhk2IFE8VY7BhzzB2ItHPWsxVZRifW/7IKtoqpRfz9GI/FZv+V3FS/SilElftt1kDEioqO8OpA4AynYeZjnF+1zMHMV5iqhwVyFiAKVvmcJu2DnYeYqgc4vbFfRcx5mu0rwGLFdhYyJHUhkTCYgMbYKw4/bg6RYdo5oKSuvxLc//qKuSZvE57u1W1BmY5w0Y2SrxLote3gsEdHRUzFnIOn67uR5OEiMmKvowlxF3+eNuQoR+eDaybq+O5mrBD8HM0Y6jiW2q+j6vDFXISNiBxIZfyQRERERNT7OQCIiIqIoxmYDIiKihmMHEhmSz0x0VwR3hIiIqJnymYFk5xo/RERERERERE0NO5DI8DOQ2IFEREQU4RlITnYgERERUZRhuwEREVGDsQOJDJsHlldZ8f3OtiirskZ6d6JWQnwsBvU9FvHxMZHelagm8RnYpyvi42IjvStRS2LTu2sbHktE5HcGEhzsQPInIS5GnYflfEz+MVfReR5mrsJchYgaVvqelUv8n4eZqwTFXEUf5io6YsR2FTIotryTYZVXxWD1znaR3o2oT3QG9+8Gl6sy0rsS1RIlTn2PjfRuRH2M+nRrh8T4uEjvChFFC+8Sdg5nRHclWiXEx6nzsN3FDjbtGDFX0YO5ir4YMVchIh+cgRQUcxU9MWKuogdzFX0xYq5CRsQZSGTYkUSxVjt6tj6srsm/isoq/LJ9r7qmIHHasY9xChKjnfsOM0ZEdPRcbPUah+TguZjn4fphrlKHODFXCRoj5ipEkTdx4kS0bdsWqamp6Nu3L5YuXRqxffGegET+8TwcHGOkD3MVfTFirkJGxA4kMiSTyYTk2CqM7LVTXbu4EJJfpWUV+GJlDkrLOAMpEInPl6s3orS8IjwHbBMgsfkhZ5c6poiIFPPRNNJl5wwbre/O6vMwvzs1zy/MVfSdh5mrMFchMoi7774bO3fuRFFREV555RWMHz8ehw8fjvRukQbmKsExV9GHuYqOGLFdhQyKHUjUJLD/iIiIKIIzkJzsQCIiIiKgZ8+eiIuL8wz8rKysxN69e6OghB0XQSIiIqoPdiBRk1gQk6kgERFRBGcgOdiBREREFC1KSkrw0EMP4dxzz0VmZqbqyHn11Vf9PreiogKTJ09Gu3btkJCQgCFDhuCzzz5r0OvfeuutaluDBg3CmWeeqUrZRbrNgI0GRERE9cMOJDIsn1yQPUhERESRm4Fk5xpIRERE0SI3NxfTp0/H5s2b0b9//4DPnTBhAmbOnImrrroKs2bNgsViwejRo/Htt9/W+/Wfe+451Yn1+eef45xzzlEdWBERqdclIiJqQtiBRIZV4bBi7Z5WsNmt7EDSEBcXg349OiIuzquRj/zEyYq+3TsgLjaG0dE6lmJj0K1jS3VMEREpFsvRQDidDIof8bHu8zC/O5mrNAxzFR0xYq5C5NG2bVvs378fu3btwowZMzQjs2bNGixatAiPPfaYet7EiRPx5ZdfolOnTpg0aZLPc0899VTVEeTvcv/999fatnREnXXWWaoTadmyZRH/7XDQqX/MVYJju4o+zFV0xIi5ChkUW5XJsMorY/D11g6R3o2olpQQh9MG9YLLVRnpXYn+OJ3QM9K7EfUxOr5nB3VNRCRMXh1ILjtL2PmTeOQ8bHcxPoHOL8xV9J2HmaswVyHSS9YgatOmTdDnLV68WHX0SMeRW3x8PK6//nrcd9992L17Nzp0qP6bu74zkux2O7Zu3RqRXx4nIAXHXCU45ir6MFfRFyO2q5ARcQYSGVaM1YEuLQoQY3GwnLGGyio7duw5qK5Jm8Rn595DjFOQGO07WMAYEZHGDCR2kPA8XD/MVfTHiblK8BgxVyGqm7Vr16J79+5ITU31uX/w4MHqet26dXXaXmFhIV577TVVvk46jt566y0sX74cw4YN0/w3Bw8exMaNG30u4ehw4gwk/3geDo4x0oe5ir4YMVchI+IMJDKslPhKXNh3Gxau6c0FMTWUlNqw7Ku1GHfeYGSm8+OuHacKLPtmHcaNOhmZacnhOmQNraTMhu/WbUf7dm2Qmc4YEZEMQ/Iah+R0wuV0wuR9H6nvTjkPjz3vJH53ap1fmKvoOw8zV2GuQhQGUuZOyt3V5L5v3759ddqelLN78cUXceutt8LlcqFbt26qQ2nAgAEB10uaNm2a38fy8vJw6NAh1Fd5uayBVJ2blJWW4nBuSb231VQVlZTjs1WbcfYpPZCanBCW15CORcPH6LstGHlKd6Qlx8OoCguLwrv9Ehs++e5XjDypJ9LCdCwZXWFJuWpXSUqMY4waYfZoy5YtQ7MhYgcSGZf394krgvtBRETUHKkFsWUWkuPI7CO5ZgcSERGRYZSXl6tydzVJGTv343UhM5lkxlFdSGfT2LFjfe6TGUgXX3wxMjMzG9QAmJhYBsB25HYSWmSxUbsmU0x1p1p6ekZYB7tkZWXBqMzW6hhlpKcjMz0JRpaV1SJs2zZbS9V1RkYGB+ZqxejI5y0jzJ83ozObQ9SDRCHDKQnUJHA6OhERUQR4dyA5nfwVEBERGUhCQgIqKipq3W+z2TyPh1urVq3UJSy82iDZZkBERFQ/rDNCTWMGEqcgERERNT6vGUcuO9fbIyIiMhIpVSdl7Gpy39euXTsYWajKIBERETVn7EAiw6pyWLD5QCYqHRaWsNMQG2tFjy7tEBvrtdA5+YmTBd07t0VsDCdlah5LMVZ0apupjikiIp8ZSG6cgeT3u7P6PMzvTuYqDcNcRUeMmKsQ1ZmsTfTrr7+iqMh3bZTVq1d7Hm9MU6dOVSVys7OzQ75tDjr1j7lKcGxX0Ye5io4YMVchg2IHEhlWWVUsPv2lC0oqYpkMakhOjMeIU/qqawoSp5OyGacgMRrctzNjRETaM5AcnIHE83DdMVepQ5yYqwSNEXMVoroZM2YMHA4H5s6d67lPStrNmzcPQ4YMQYcOHRq9A8nlciEnJyck2+MMpOB4HmaMQoW5ir4YMVchI+JwSDIsq8WBdmnlOFjMhTC1VNkdOJhfhKyMeMRYOQspUJxyc4uRlZHKOAWKUX4J0tLTEWPlqYOI/MxAsh9ZC4m8vjvtOHS4GBkZSTy/MFdpEOYqOmPEXIXIY/bs2SgoKMC+ffvUz0uXLsWePXvU7dtuuw1paWmqk2js2LGYMmUKDh48iG7dumH+/PnYuXMnXn755aYVTZa994u5SnBsV9GHuYrOGDFXIQPiDCQyrNS4Kow9fgtS4ys5A0lDcUk53vl0DYpLqhdBJa042fDOFz+iuLScIdKKUWk5lv/wK48lIvJh8upAcjnZgVT7u9N25DzM8wtzlYZhrqIjRsxViHw8+eSTeOCBB/D888+rn5csWaJ+lkt+fr7neQsWLMCdd96JhQsX4vbbb0dVVRU++OADDBs2zPgR9VoDiSXs/GOuEhzbVfRhrqIjRsxVyKDYgUTGxQUxiYiIIsvMGUhERETRSGYRSTk4f5fOnTt7nhcfH48ZM2Zg//79sNlsWLNmDUaOHBmRfQ71GkgsYUdERNRw7ECiJtF/xNFEREREES5hxxlIREREFEVrIBEREVHDsQOJDMt7NJGLBY2JiIgan+VoKuniGkhEREQUpTjolIiIqH7YgUSGZXeasT03DVUOM5NBDTFWCzof05ILd+uIU6d2WYxTkBi1zUpFTIzXbAMiIu8ZSA6ugcTzcN0xV9EfJ+YqwWPEXIWINEvYuRgbnofrh7mK/jgxVwkeI+YqZETWSO8AUX2VVsZhaU43dZu5oH8pyQk474wT4HJV8kALICU5HucNO54xChSjpAScekI3dU1E5K8DycUSdn6/O+U8bHexc037HMxcRQ/mKjpixFyFqEmUsJs2bVroNuhdtYRTkPxirhIccxV9mKvoiBFzFTIozkAiw7KYnMhMLIfF7GQPkga7w4HDBSXqmrRJfPIKGadgMSosKeexREQ+TGavVJIl7HgergfmKvrjxFwleIyYqxAZW6jXQPKZgUR+8TwcHGOkD3MVfTFirkJGxA4kMqzU+ApcPXgT0uIrWMJOQ1FxORZ98B2Kim2N+8sxGInPoo9WoaikPNK7ErUkNp+u3KyOKSIivyXsOAPJ73dn9XmY352a5xfmKvrOw8xVmKsQEYUBcxU952C2q+g6lpir6Pq8sV2FjIgdSGRYLGdMREQUYWavEnacgURERETRxGsKEivYERERRagD6fDhw1i4cCH+9Kc/oVWrVhg9ejTmzJmDPXv2NHTTRHWoZ8xgERERRXQGksPOXwARERFFDZ8KdmwzICIiarwOpM2bN+OJJ57AaaedhjZt2uDmm2+GzWbDvffei9TUVHXdqVMnnHDCCXjooYfw448/1m/viHTWM2YuSEREFNkOJJfTyV8BERERNWgNJJPJhOzs7NBEkYNOiYiIGr8D6dhjj1Un83/961/o2bMnlixZgtzcXLz//vu4++67sWjRIvXzJ598ojqYZHbS4MGDccwxx+DAgQMN32OiIxxOM/YVJsHuNHMGkgar1YK2LdNhtbJaZSASnzZZ6bB6j6Qn3xhZLGiRnsRjiYh8WbzOL3bOQKp1frGYj5yHeX5hrtIwzFV0xIi5ClGT6EByuVzIyckJ+aBT8o+5SnBsV9GHuYqOGDFXIYOy1vUfXHHFFbjgggswZMgQ7Y1arRgxYoS6zJo1Cxs2bMDSpUthYeMshVBpVRzeWtuTMQ0gNTkBl44cAperknEKFqcRgxijIDE6c3APpCYnMk5EdBRnIAUk35lyHra7HDxqmKs0CHMVfTFirkJEVNfzC3MVXedgtqvoixPbVYLGiLkKNYsOpIcffrjOL9K3b191IQolM5xIiq1CeVUMa9hpcDidqKioQlycDBLnLKRAcbKV2xAfF8s4BYhRua1SXfNYIiI3k/fgIM5AqsXpdKK0ohLWOAu/O5mrNAhzFX0xYq5CRD5Ywi4o5ir6zi9sV9EXJ7arBI8RcxUyonq3KK9evVqVq/vss8/U+kdEjS0toRI3DN2A9AQb10DSUFhUhleXrEBhUXnj/nIMRuIz/71vUFhcFuldiVoSmw++zlHHFFE0kPImL7zwgiqTm5WVpWY517zIjGgKM7PXGkgOzrKpqaDYfR7md6cW5ir6MFfRESPmKkRUg08FOy6c7BdzFT3nYLar6MFcRUeMmKuQQdW5ZaW4uBijRo3CqlWrPPe1adMGH374IQYMGBDq/SPSxtFERETN1qRJkzBz5kyVe4wfPx4ZGRmR3qXmyXsGksMZyT0hIiIi8sU1kIiIiBq/A+mJJ57AypUrcemll+LMM8/E1q1b8fzzz+Paa6/F+vXrG75HRPXIBV0cTURE1KzMnz8fl112Gd58881I70rz5l0e1WGP5J4QERGRwU2dOhXTpk0Ly7bZZkBERNRIHUhLlixRnUeLFy/23NezZ0/ccsst2LFjB7p06VLPXSGqP/YfERE1L+Xl5RgxYkSkd4O8ZiCxhB0RERE1tANJLhs3bkR2dnaDg2nyGXXa4M0RERE1S3VeA2nnzp0455xzfO4bOXKkWotgz549odw3ooBcLhMOl8bD4TJxNJEGi8WMjLQkWCycux+IxCcjNYkLnAeKkdmM1KR4dUwRRYOzzjoLP/zwQ6R3g3xK2HENpJosZtOR8zC/O7UwV9GHuYqOGDFXIaJAZe8ZHY3vTuYqwc/BbFfRg7mKjhgxVyGDMtdnxG9ycrLPfe6fq6qqQrdnREGUVMbjPz/0QWF5PFxMB/1KS0nElRecqq5Jm8TnitFDGacgMRp5Sm/GiKLGc889h++//x6PPvooDh8+HOndabZMXh0jnIFUW1pKEs/DQTBX0Ye5ir4YMVchIs0ZSKTx3clcRc/5he0q+s7DbFcJHiPmKtQsStiJ0tJS5OXleX523y4uLva53y0zM7Mh+0jkl8nkgsXshMNp4nAiDTIz0O5wwGx2wcTsOWCcHHaHGlnEOAWIkcOprhkjigY9evSA0+nEAw88oC7x8TJDzlLjPGFCYWFhxPax+c1A4hpIfs/DdidcPA9rYq6iD3MVnTFirkJEml8SDI3meZi5StDzC9tVdJ6H2a4SPEbMVai5dCDdfPPN6lKTrI3kj4MlTSgM0uJt+NOwHCxc0xsuVxpj7Ed+YSne+vB7jDtvMDLTkxgjDfmFZVj04RqMG3UyMtN8Z1jSkRgVlWLJF+tw+eihyExnjCjyLrvsMnZmRtsaSFXsQPL33bl42XcYe95J/O7UwFxFH+YqOmLEXIWIavBZAokdSJrfncxVgp2D2a6iB3MVHTFirkLNpQPpoYceCs+eENURZ6MTETVfr776KpojWVT6lltuwbp169C+fXtVyu/000+P3A5ZvFJJOzuQiIiIKFp7kCK4H0RERAbGDiQyLi6ISUREzYisNXnRRRfh9ttvx/Lly9VlzJgx2LJlC1q0aBGZnYqJ8dx0sQOJiIiIooh3FXeum0xERFQ/R1c+JjIYTkcnImreioqKMG3aNAwePBitW7dWF7k9ffp09VhTIx1F+fn5qgNJ1nsaMWIEjj/+eLzzzjsR2yeT1XsGUlXE9oOIiIiMb+rUqapEcXZ2dmg2yLIlREREDcYOJDIsmYFeUhEDp8vE2egazGYTEhPiYDIzcw5E4pMYH8v1VALFyGRCfFwMjyWKGvv27VOdJ9KBVFJSglNOOUVdSktLVePDCSecgP3794flteX1pKTvueeei8zMTPX50CqpV1FRgcmTJ6Ndu3ZISEjAkCFD8NlnnzVo4dWaP0tZu4ixeq2BxBlItZhN1edhOR+Tf8xV9GGuoiNGzFWIDE9yOMltcnJyQr9xlrDzi7lKcMxV9GGuoiNGzFXIoNiBRIZVWpWAl1f1Q0F5PBfE1JCemoTrLjsdGamJjfvLMRiJz4SLhyMjNSnSuxK1JDYXDO/LGFHUkE6ZAwcO4IMPPsCmTZuwZMkSdZHOlA8//FA9du+994bltXNzc9Usp82bN6N///4BnzthwgTMnDkTV111FWbNmqVmDo0ePRrffvttnV+3R48eSE9PV9uTcnYff/wxVqxYoTrNomENJFcV10DSOg/LNfnHXEUf5ip6YsRchYh8mVj3PijmKvpjxHaVYOdhtqsEw1yFjIodSGRYPmN5OZqIiKhZkc6TO++8U3XG1DRq1ChV5m3ZsmVhee22bduq2U27du3CjBkzNJ+3Zs0aLFq0CI899ph63sSJE/Hll1+iU6dOmDRpks9zTz31VDUizd/l/vvvV8+JiYnBu+++i/feew9t2rTBv/71L1x++eVo3749IsanhB07kIiIiCiKeK+BxDYDIiKipteBVN+yLzICWRpUunbtisTERDVi969//SsKCgpqPbdz585+G2tuvvnmML0rCpXUOBv+fNpPyEwsZ/+RhvzCEsx5/TPkFUZwdLoBSHxeeOsL5BWWRHpXopbE5u3P1zJGFDVk1o2seaRFOljCNTMnLi5ObT+YxYsXqxlH0nHkFh8fj+uvvx6rVq3C7t27PffLjCQp2eLv8vDDD3ue169fPzXr6PDhw/jkk0+wfft2te5TNHQgubgGkuZ5WK7JP+Yq+jBX0RMj5ipE5MvECrJBMVfRHyO2qwQ7D7NdJRjmKmRUXsNGo4+UfZHGFxlhfNxxx6n1BWSk8fLly9VIXS3SUCOdTuPHj0fHjh2xYcMGzJ49W41E/umnn1RnlLcBAwaoDiZv3bt3D9v7olBxwWqpHkbE0UQaEXIBDoeTM7SCH0rVcaKAnE4XjyWKGr1798brr7+uBnzExsb6PCbl3eQxeU4krV27VuUTqampPve7O3zWrVuHDh061GmbP//8s9qm0+nEs88+q65lLaZIMXEGUkCSpcj5hXlKgBgxV9GHuYouzFWIiOqGuYqOGDFX0X0wsV0lOOYqZERR24HkLvsiJV/uuecedd8111yD7OxsVfZl5cqVmv9WOp1OP/10n/tOPPFEXHvttfjvf/+LG264weexY445RnU2kbF4DybibHQiouZFZijLbGPpjLn11ls9Az+2bNmCOXPmqI6WN954I6L7KGXupNxdTe779u3bV+dtzps3T12k4+jss89WJe0COXjwIA4dOuRz39atWxGWNZBYwo6IiIiiCUvYERERRXcHktlsVjOBpHa/dNpYvUepNqDsy3333afKvmiN2q3ZeSQuueQS1YEkC177U1lZqUYsJyVxkWPDYDJIRNRsjR07VpWou/fee9UsJCk/K6TkW6tWrfDKK69gzJgxEd3H8vJyVe6uJsln3I/Xlax7JBe9nnvuOUybNs3vY3l5ebU6l+qqvKoKliO3bSXFOJzbsO01NUUl1b/jgoJ8OO22sL1OYWEhjB6j/IKCsMYo3AoLi8K7/ZLq2OTn58NZZdw4hVOh51gK7+fN6EJV0qtly5ah2RBRGHHdZCIioijvQBo2bJhq3JGFrJ944glVpz9SZV8OHDigrrOysmo9Jgtay1pJDodDLWx911134Y477gi6zbCP6qXATCbYHSxqHCREsFjMNTJnqh2oI3GigMxmE48lirpStzKD+Mcff8SuXbvUfXIeHzhwYJ0GrYSLlMyV9RxrstmqGzZrltQNB5mdJZ1tNXOViy++GJmZmQ1uALSlJKPyyO04SwxaZLFB0Zs5pkSdXzIyMpCRloxw8pfjGoHFE6N0ZKYZeyBXVlaLsG3bHFPqOZYyw3wsGfnzJrkKY6QjnyNqLni46wqRnF+4XlSAGLFdRffnje0qwbFdhYworK0rX331lbouKSnB119/HdGyL48//ria0VRzNLIsRi3rKfXo0UMtSC3rLMmaS7J9+TeRHNVr5NGkjaGoPAbPfnOCZzRmru8SGCFj9N/DZSMGqJGqubnGHYkZ7lG94rIz+hs+TuE2YlBXxigIjuptfNJRdNJJJ6lLtJGcZe/evX5zHCGztMNNZmPJJWy8Oupc9qrwvY5BSafRzVecDbvLEeldifoYuVzurkjyRzrXbhp7FoMTgHSsXTbieHawEZFfXI8w8HmYuQpzlYZirqInRsxVyJgaZXhucnIyRo8eHbGyL6+99hpefvlltXbScccd5/PY+++/7/Pzddddh1GjRmHmzJm47bbb0L59+4iN6nU4wZG8AVit+RIldTs9PQNZWe4iOqFn1FG9wmqyNIlGmXCO6lUckZ+tEO1cZpOhPwuNgaN6w8c9EEVmN3v/HIz7+ZEwYMAALF++HEVFRT4zqlevXu153OhM3jO9uAYSERERNcDUqVM1B+nWB2fVEBERNVy9ajYtWrQIy5YtC/icDz/8sEGLV4eq7Ms333yj1k0aOXIkHnnkkaDPlzUUpISd3W73zKDSIiN6+/Tp43Pp1q2brv2ihkuOKcf1J/+M9AQbRxNpKCgqxby3v0J+URkPuQAkPq++uwL5RaWMk2aMSrF0xQbGiCJG1jc844wz1JqF3j9rXdyPR5LMepbyuHPnzvXcJ7nNvHnzMGTIkDqV4o1aFq8ZSFWcgaR1HpZr8o+5ij7MVfTEiLkKUVPoQJL1LHNyckKzQa6bHBRzFf0xYrtKYMxVgmOuQkZV5yH377zzDq666ip8/PHHAZ8XGxuLK6+8Us0+Ou+88yJS9mX9+vW48MILkZ2djcWLF+teD8HdoCNl6Ch6mc0uJMdVwWxyQf6j2pxOF8rKK+ByMj6BSHzKbJXqjxXSiJHLBVtFFY8lihiZyePOL7x/jpTZs2ejoKDAU1J36dKl2LNnj7otM5jT0tJUJ5HMVJ4yZYpaN1EGmcyfPx87d+5UM6ObBJ8SdvaI7ko0crqqz8NyPiaNGDFX0YW5io4YMVchokAzkHgq9n8eZq4SFHMVfZir6IgRcxVqLh1IMmpWRvWeffbZAZ8nj5955pl48cUX69WB1NCyL9u2bcO5556rZgnJbCnpyNJr+/bt6rqhJegozDiaiIio2Rg+fHjAnxvbk08+iV27dnl+XrJkibqI8ePHqw4ksWDBAjzwwANYuHChWq9P1l784IMPIlpaL6RiWMKOiIiIiIiIqKmqcwk76cDRu56RdOB8//33YS378vvvv+OXX37x+bcHDhzAOeecA7PZjE8++USzI0hmGMlreKuqqsI///lPNcI50qVvKDCfwUQcTURE1KzIIJUvvvhC83EZhCLPCReZRSQjyPxdOnfu7LN244wZM9QMainDu2bNGlVWt6nwXgPJZWcJOyIiIopObDMgIiJqpBlIUq6lRQt9i9nL82S0bX3oLftyzTXXYMWKFT6lp6TjSmYRTZo0Cd9++626uLVu3doze+r999/Hww8/rDqrunTpojqUXnvtNVVv99FHH0WbNm3qte/U+L7JqcL2/c6wbLu42ISUlOo1N4ymqqK6Mc/O0jlE1MTIOoU33HCD5uOSO0h+QI23BhKqWMKOiIiIorSEHRERETVOB1JmZqZPyZZA5Hny/Pqqb9kXWftIPPHEE7Uek5I37g6kvn37onfv3vjPf/6DQ4cOqVlHUhrvzTffVJ1XFN1KqxIw++vj4XCa8PQ7tjBP1DPq4tcuWMzHY1uZCU/dGOl9iV4ZaYmYOOZMWCx1npTZbGSkJuHSswYgIy0p0rtC5GEK0CqwdetWpKSkMFrhxjWQgn533jRuBFxmTpXWjFFadYzMZnZABjyWmKsExVyFiGph2Xtd353MVYLEiLmKLsxV9H3e2K5CzaID6eSTT8brr7+O+++/HxaLRfN5UhpOnifPry932Re5BBqBXJP3bKRATjzxRDULiYypS2srftkdnllHTYdJdbB9t4lxChglkwlWq/b3GVXHSDrYAjXYE4WbzESWi5vMIpa1Fv3Nlv755591l9ylBmAHUvDzi8UCu8u3ZDLViJHVAhdjFPxYYq4SNEbMVYjI93uB8QiGuUpwzFX0Ya6iL0bMVahZdCDdfvvtak2Bq666SpWSS0qqPRq9rKwM119/PX777TfMmTMnVPtK5OOmc004NnkTdpf1QJUrPmzRkbW34uLiDBf9Sjvwwy/FuCB7G1Zs6waAI/G1FBaXYdlXORh92gCkpSQ26u/JSDH65LtNOP/MgYwRRYzkFzJj2K24uFitd1gzKZfc5Oabb8aDDz4Ygb1sZrwbtLkGUi2FxaX49Ju1GDm8P787A51fVqzH6OHZjFEAzFWCY65CRAFxMrDGdydzFV3nF+YquuLEdhUdxxLbVag5dCCdfvrpqqzcP/7xD7V49SWXXILs7GxVJkYacjZs2ID33nsPubm5+Pvf/66eTxQOLVJNsKAcfxsbj8z05LAFOTfXhqys8G0/XApKnTj/viK0SLLBbOIMpEAcDhfyi0rhcDJOmjFyOlFUaoPDwRhR5Nxyyy3qImTtwlmzZuHCCy/krySCTJyBFJDD6UJ+YSm/OwPFyOE8EiO27AWOE3OVYJirEFEgeivVNDfMVXTEiLmKvmOJuYqOzxvbVaiZdCCJadOmqfWDpCPppZdeqvV4jx49MHv2bPzpT38KxT4SUT14z9ZnqkxETc2OHTsivQskLF6pZBXXsCEiIqLowfLbREREEepAEmPGjFEXWaR68+bNKCoqQmpqKnr27InjjjsuBLtGRKGq98zBVkTUlMkM6MLCQjj9zCLs2LFjRPap2eAMJCIiIopW/JuYiIgoch1Ibt26dVMXIoouJq9smTOQiKgpev755zFz5kxs375d8zkOh6NR96nZsXitgeRkrImIiIiIiIiaEt+Vp3VYsWKF3xG+wfz4448oLS2t878j0pKekogJlw5HWmoig6QxA6mgPB4vreyrrklbWmoCrr3oNC7eHShGKYk4f1g2P28UNebMmYM///nPahDLww8/rOra33nnnbj33nvRpk0b9O/fHy+//HKkd7PpMx9NJV12diDVxFwlOMnjqvO5hBAfnE0LcxUdMWKuQmR4U6dOVWXnZJ3tUFfl4KhK/5irBMdcRR/mKjpixFyFmksH0hlnnIFWrVrh6quvxuLFi1XZGH8qKirw4Ycf4uabb0b79u0xZMgQHDx4MBT7TKSYzWYkJcbD4tV4Rb7JstNlQmllLJxO78yZapJjKCmBx1KwGCXEx/LzRlHjmWeewciRI/HRRx9h4sSJ6r7zzjsPjzzyCDZt2qTyk8OHD0d6N5s8k9VrBpKDayDVxFxF5zmY+Zy+ODFXCRoj5ipExu9AkkFBOTk5Id82y7r7x1wlOOYq+jBX0Rcj5ipkRHVued+5cyceeugh1Rk0fvx4tGzZEueccw6effZZbNiwAa+88gouvvhitGjRAhdddJG677bbblMJQJcuXcLzLqhZKiopw5JPVqOopDzSuxK1UuMrMPb4X5ASVxHpXYlqcgwt+fwHHktBYvTlmi3qc0cUDbZt24YLLrhA3Y6JiVHXlZWV6jotLQ033HADnnvuuYjuY3MrYeeqxwz1po65ip4YlTOf0xsn5ipBY8RchYg0ZyCRxncn21V0nYPZ9qQvTsxVgsaIuQo1izWQZDFq6RCSi4zu/fjjj7F06VLVqZSfn4/ExEScffbZmD17Ns4//3xkZWWFZ8+p2bM7nNh/qAB2lszRTJatZifapZXCYmKjXiB2uxMHcgtg51op2jFyOHC4oFTFiigaSCeR3V494yU1NVXlH7t37/Y8npKSggMHDkRwD5sJi1cqeeT3QV4hYa4SlORx1fkczy+B48RcJeixxFyFiGpiB5KO7062qwSNEXMVXZir6Pm8sV2FmkkHkjdpnBk7dqy6yLpIMtuoZ8+eiIuLC90eElG9sNwzETVlUht//fr1np9POukkPP/88xg9erTKSV544QV07949ovvYLHiXkWUnPBEREUUplrAjIiKKQAdSzbqpsmA1EUXfdH0my0TU1EgZ3Tlz5qg1F2XgyrRp0zBixAg1U9pd1u7tt9+O9G42rxJ2Ds4gISIioigtYeeK4I4QEREZWMg6kIgoijuQIrkjRERhcN1116mL2ymnnIKNGzeqsroWi0Wtz8gZSI3bgQQHS9gRERFRFOGgSiIiogZjBxIZVmpyAsadfwqSkmMjvStRmysX2uKwcE1vlFWxrGQgqSnxGDfqZHVMkUaMkhNwztBeSE1hjCh6de3aFXfccUekd6NZMXmXsHO54HI6fe9r5pir6IhRSnU+l5rs1RlJfuLEXEXP5425ChF54xJIOs7DbFcJHiPmKrowV9H3eWOuQkbEDiQyLKvFghbpybC7HJHelehkAhxOM/LKEhDDNpmgx1JmGjvZgsUoLTlBXRMR+X5BWGXV3KPrILEDyee7k7mKvhi5XJX8YDFXaRDmKkRE9fvuZK6iL0bMVYLHie0qwWPEdhUyIg4RJcMqLi3Hh8t/QnFJeaR3JWpHW6XEVeCC7K1IjquI9O5EteISGz78eq06pkgjRqXl+PanrYwRRYystSil6epysUrHBoWdyWcdJA7q8MZcJTjJ46rzOVsYjs6mg7mKjhgxVyGimljCTtd3J9tVgp2DmavowVxF3+eN7SpkRGxZIcOqsjuwc+8hDBpwbKR3JWrXQIqxONE1qxDf7zwm0rsT9cfSrn25qOrPhs9AMdqfW4SqKsaIIuPBBx+EyWclZIoaZq6DpIW5iv4YnTSgS0gPy6aGuYq+GDFXISJvPqkjFwbW/O5ku0rw8wtzFX3nYbarBI8RcxUyInYgETWDZNnFZJmIDG7q1KmR3gXSYvXuQHIyTkRERBQd+DcxERFRg7GEHVETxcFWRETU+CXsjqyFRERERERERESGxw4koiaKM5CIqKkrKirCtGnTMHjwYLRu3Vpd5Pb06dPVY9RIvDqQYGeZSyIiIooOLH5MRETUcOxAIsNKSYrHJecMRkpyQqR3JSrJWiFFtli8tbaHuiZtKcnxuOSsgUhJ4rGkGaOkBJwxqLuKFVE02LdvH44//njVgVRSUoJTTjlFXUpLS1W5uxNOOAH79++P9G42wxlI7EDyxlwlOMnjqvM5nl8Cx4m5StBjibkKUVRZtWoVzGYzHn744SgpYce67v4wVwmOuYo+zFV0xIi5ChkU10Aiw4qxWtGuVQbsLjZWabE7LdhXmOxJmLkAvdaxZEHblhlhOlKbToyyMpLV544oGkyePBkHDhzABx98gNGjR/s89tFHH2Hs2LG49957MX/+/IjtY7Nh8fpeYAeSD+Yq+s4vks+5XJUhPzSbEuYq+mLEXIUoOjidTtx1110YNGhQRPfD5+9f9h/5xVwlOOYq+jBX0Rcj5irU7GYgLViwADt37tR8XB6T5xCFQ0mZDZ9/t0Fdk38pcZU4p+cOJMdVggOughxL3+fwWAoSozUbdjJGFDU+/vhj3HnnnbU6j8SoUaNw++23Y9myZRHZt2bHcjSd5AwkX8xVgmOM9GGuoi9GzFWIosPcuXMxZMgQ9OrVK7I7whp2QfE8zBiFCnMVfTFirkLNrgPpuuuuw8qVKzUfX716tXoOUThUVtmxZcc+VFZywW4tsVYHerXJQ6zFwQFXgY6lSgd+3blfHVOk/XnbtT+PnzeKGlKqTtY80tKmTRv1HAo/k88MJH6PemOuEpzkcdX5HGeUB44Tc5WgxxJzFSIPKe/70EMP4dxzz0VmZqaaifPqq6/6jVBFRYWa2d2uXTskJCSojp/PPvus3tE8fPgwnn76aVVmOJpwQKV/zFWCY66iD3MVHTFirkLNsQMpWA1ZabixstwRUVQMuGLCTERNSe/evfH666+jsrJ22auqqir1mDyHGoHXGkhwOBlyIiKiCMvNzcX06dOxefNm9O/fP+BzJ0yYgJkzZ+Kqq67CrFmzYLFY1Azvb7/9tl6v/fe//13NEk9PT0ek+UxAYgk7IiKieqnzYhY///wz1q1b5/n5m2++gd1ee7RpQUEB5syZg+7du9dvz4iowXxKPjNhJqImREbKXn755Rg8eDBuvfVWT76xZcsWlX9IvvLGG29EejebBZNXB5KLM5CIiIgirm3btti/f7+akf3jjz9qrkW0Zs0aLFq0CDNmzMA999yj7rvmmmuQnZ2NSZMm+VScOfXUU/Hdd99pdho9/PDDWLt2LX744Qc8++yziApcAomIiKjxO5Deeecdz1RkmQb9wgsvqIs/MuKEayARRQ7XDCWipmrs2LFqpvO9996Lm2++2bNIssyObtWqFV555RWMGTMm0rvZDGcgsQwZERFRpMXFxanOo2AWL16sZhxNnDjRc198fDyuv/563Hfffdi9ezc6dOig7tczI2nFihVqMM8xxxyjfi4sLFRVabZt24Z58+Yhkn8PExERUSN1IElicf7556sGGhn1K9OiZbFqb9KIk5SUhGOPPZYl7ChskhPjMfr045GcFM8oayiuiMX7G45V15yyH+BYSorD6NMGqGOKtD9vpwzoys8bRRUpuTJ+/Hg1snbXrl3qvk6dOmHgwIHMPxqRyeo9A4kdSN6YqwQneVx1PhcXhqOz6WCuoiNGzFWI6kxmDMks7tTUVJ/7pa1HSPUZdweS3vaicePGeX6+44470KVLFzXgJ+JYkcMv5irBMVfRh7mKjhgxV6Hm0oEkU6HlIpYvX45evXqpkb5EjS02xoou7VvB7mJjlRa704Idh6trTzNfDnwsdT6mZRiO0qYVo3at0tU1UTSRUa0nnXSSulCEWLy+F9iB5IO5iv4YuVy11zMj3zgxVwl+LDFXIaobKXPnbt/x5r5v3759ddpeYmKiurglJCQgOTk54HpIBw8exKFDh3zu27p1K0KCJd2DYq6iP0bMVYLHiblK8BgxVyEjalBL4PDhw2vdJzOTpGOpoqJC1chNSUlpyEsQaSorr8DPm7ejX59OSErgqFV/kmKq0K/zAfz4exuugRRAaXkFfsrZihN6deGxFCBGa3/ZjaEnpjBGFBFff/21uh42bJjPz8G4n0/hY7KYPbdddg7q8MZcRd/55eeNu3B8n/Y8vwSJE3OV4McScxWiuikvL1fl7mqSMnbuxxvi1VdfDfqc5557zrNMQk15eXm1OpfqoqhI/r96pnRlRSUO59Z/W01VeUUVftt5AMd1bYWEuJiwvIaUMjR8jLYfRM+uWWGLUWMoLFQfiLDG6ZdtuejZubWh4xTuGK3/dTf69axijBqh/GjLlhwoHhUdSLJQoiyqKB1G7s6jc845B19++aW63bFjR3zxxReqlB1RqNkqq/Dzlt/Ro1s7NjhoiI+x4/j2B5GzL4sdSAFUVNix4dfd6HMsG680Y1RZha2/H8KJ2VX8vFFEnH766apErjRkxMbGen7WInmIPO7gjJjGnYHkZAeSN+YqwVVUVOdzvbu14fklYJyYqwQ9lpirENWZzBCSwb812Ww2z+Phduutt6q1LWvOQLr44ouRmZnZoAbA3DSZ3VqibsfExqJFFgc415RXWILfft+AAX2PRWZ6MsIlKysLRpVXIDHaiBP7dkFmehKMLCurRdi2nVdQit92b8aJ2d2QmRa+Y8non7ff/yjEySemhPXzZnRmMxewa1IdSG+//TYuuuginwUYpcPokUceQf/+/XHTTTdh6tSpWLhwYSj2lYjqyLttlSXsiMjI3INVpPPI+2eKApajayCBM5CIiIgMQ0rV7d27129pO9GuXbuw74MsicBlEYiIiJpoB5IkGt26dfP8vGTJEvTu3RtTpkxRP99yyy14/vnnG76XRFQv3n32LvYgEZGB1Syb66+MLkWGyasDyeWw89dARERkEAMGDFCDcoqKipCamuq5f/Xq1Z7Hjcxnsjr/HiYiIqqXo0Xr67lwtXu6s5SKkdlH5557rufx1q1bIzc3tyEvQUQNwRlIRNRESb38htTEpzDNQHI6GVqiMCj56GN1XfTmG4wvEYXMmDFjVLnfuXPneu6TNp558+ZhyJAh6NChQ6NGWyrYSAni7Ozs0FfkYAcSERFR489AkpP6f/7zH1x11VV45513cPjwYZx33nmex3ft2mXoOqcU3ZIS4nDW0GwkJdZe9JOqlVXG4JPNnVFSGcMRV4GOpcRYnDmkD9deCPJ5G5TdiZ83ihp/+ctfcOedd6qZSOPGjcMll1yi6uRThGcg2TkDyRtzleAkj6vO56rLU5J/5f98HH17ZKNiSw6cV46DOcnYazCEA3MVIl+zZ89GQUEB9u3bp35eunQp9uzZo27fdtttSEtLU51Esv6QVJE5ePCgqjAzf/587Ny5Ey+//HKjh1Q6kOSycePG0HQicQZSUMxVdMSIuYoubFfR93ljuwo1uw6kBx98EBdccIGnk+iUU07BGWec4Xn8ww8/xKBBgxq+l0R+xMXGoGfXY2B3ccFuLVVOK375o3qRRI64CnIsdQl/fW+jx6hzuxbqmiga/PLLL1i0aBHefPNN3HjjjWoB5rPOOgtXXHGFWp/RuwwLNeIMJAfPyd6Yq+iPkcslC52TlpiKchzz8w/qtrO8nB1IGscScxWio5588kk1qNd7yQG5iPHjx6sOJLFgwQI88MADau3q/Px89OvXDx988AGGDRtm+HByGfbgmKvojxFzFR1xYrtK0BgxV6FmV8Lu7LPPxk8//YSZM2filVdewaeffup5TBIPSThuv/32UOwnUS3ltgqsWb8V5TY2OGhJiKnCkM771DVn7Gsrs1VizYZt6pq0Y7Rx6z6U2arLlhJFWvfu3dVAlpycHGzYsAGTJk3C9u3bce2116oSuhdffLHqYKLGXgOJHUjemKsEJ3mc5HM8B2uTUuEVicn4bdgodS3lnag25irUVG3btq1e/05mEcn3h79L586dPc+Lj4/HjBkzsH//fthsNqxZswYjR45EU8O/h/1jrhIccxV92K6iL0ZsV6Fm14EkevfujTvuuEM12Eji4ZaRkYF//etfOP300xv6EkR+lVdU4YcN29iBFEBCjAMndd6PhBg7ZyAFYLNV4ceN22GrYAeSZowqKrFp+wEVK6Jo06dPH/zjH/9Qs5LWrl2rStvJgtAyupYagdVrQjs7kHwwV9HXKCP5HM8vAdjtqExKxrbho9S1y8mO2vrkKq6qKrgqK+EsK9NxZFY/31lcDJeOtd3kOdKB7igs1L1teb5sX/e+lJaq66DPlQ6Cqiq1L3KbjG/UqFFoLkK9BhJL2AXHXEVHjJir6MJ2FR0xYrsKNccSdm47duzARx995Jke3alTJ5XkdOnSJRSbJ6JQLBrKKBJRE/fzzz+rknaLFy9GcXExEhISIr1LzYP56HgkzkAiCr1anQZ2diD5U/5jdYm/kg+XouLzT+EsLETCaaciLrsvil5/HbZVKz3PTb3qKpiSU2Aym2GKi0XpF1/AZLUi+eJLYE5MQN7Mf8Gxf5+nTGfm3XfDcTgPlhaZqNqzFxXr1sHa/hgkjRwJ+759KHj+ebjKy9XTY449FimXXVb9/FatYPvhB9j37kHcgOORMHQoSj/+CKUffujZl6TRoxHT9Vi4KitgyWyhHpf15JLOHYWYY45Bwdy5qNy8yfP89L/8BS5bhSpj6CwrRfl338Gclo6Uiy+Gq6ICeU/OgLOoSD3XnJGB9IkT4cg9DEtWFmJ790LikCGcxRalpk+f7vf+vLw8NBehXgPJ5+9hdqgSERFFpgPpr3/9K2bNmgVnjZFZZrNZjQCWurtEFHnVCTNLnhBR07Jp0ya88cYbquPo119/RUxMjCq7Mm3aNFx44YWR3r1mQRpgPXSM1CeiupHOBJ+fOdOvlqp9e5H7j+nAzfeh4IUXkHLogLrfu+PFW9F//+v3/oq1a2vf6XAgb8aMWnfLtss++6z2vmzbhrwnnvDz/M0ofv21WveXLlvmd18qc3L83l8we7bf+707yNyc+fnIe/xxn/vazJ2LpOHD/W6DIuuRRx7BlVdeWet+e43vAKoD/vlLREQU2Q6kp556SpWpGzNmjOpI6tWrl7p/8+bN6n65HHPMMbjrrrsavqdE1KB8mQOuiKgpkZJ10mkkHUgWiwVnnXUW7r33XrX2kXtRaGok7EAiCq+aHUh2lpOtqfSjj3gU6nTgpptw7C+/MF5R6LjjjlPrO9as5PLtt99GbJ+aFJbkICIiavwOpBdffFGN7pUGHG9DhgxRC1fLAowvvPACO5AoLBLjY3HqwJ5ITIhlhDXY7DFY8Vt7lFXGMEaBjqWEWJxyfA91TJH2521Aj/b8vFFUlXkZPnw4br/9dlx66aVo0aJFpHep+fLuQOJoBR/MVfSdg5nPBS9hF1dShJ6fvK2uWcLOD5PJN0YU4IBiK3q0evTRR9VM6prmzZsXkf2JBClfJ7PIQ8XkNaSSR75/zFWCY66iD9tVdMSI7SrUHDuQdu7ciTvuuEPzcSkh8/HHHzfkJYg0xcfFon/PTrC7WAdeS6XDinV7W6vb/Fsx0LEUg/49OvLTFjBGsTiuUyt1TRQN9u7di1atWkV6N0hwBpIm5ir6Y+RyVfLzpMFVZUdseRk6r1lR/TNL2NVmNvvEiMiItErvnnrqqWguQr0Gkm9JjoZvrilirqI/RsxVgsWJ7Sp6jiW2q5AReQ0ZrTtpuFm/fr3m4/JYy5YtG/ISRJpsFZVY/8sudU3+xVntGHDMH4i32pkvB2CrqML6Lb/zWAoYo0r8tusgY0RRg51H0cPktUK1y8lBHd6Yq9QlRizLFmgGUmVCInYOHq6ua5a0o+oZSD4xIiKq/mo4+l3KDqQg52G2qzBXaRi2q+iJEdtVqBnOQBo7dixmzZqFzp0747bbbkNSUpK6v7S0FLNnz8ZLL72EO++8M1T7SuSjzFaJb3/8BW1bp3NWhIbEmCoMP24Pfs9PZcIcQFl5Jb5buwUd2mTyWNKKka0S67bsQY9jOzJGRBRgBhJbZ5ir1P0cLPlc+9aD1chV8sNuR0VyKn4ZeRla7NgCl4MdSDWZzGafGMlsJKJotGDBgpBs55prrgnJdpo87xlI5BfbVYJjrqIP21V0xIjtKtQcO5BkAet169bhvvvuU4s9tmvXTt2/b98+2O12nHHGGWqNAiKKEI64IiKicDNbjt52OhlvohBz1ZxxZOdMv4DTDIii2IQJE0Iy85cdSPXAMS5ERESNX8IuMTERX3zxBd555x383//9H3r16qUucvvdd9/F559/rp5DRFEwZZ+/BCIiCgfz0ZNN2cfLGGOiMJSw8/mZJexqMzXoz1qiRuN0Oht8cTThddBk/SPpIAvJ+kf8e5iIiCjyM5DcLrroInUhoujiMxaTPUhERBSOc41XCbuKn35Cxfr1iOvfn7EmCpUaHUYsYRe4I5somp155pkN3oZ0sMhA3qbagSSXjRs3hqwTyYN/DxMRETV+B9KOHTuQk5ODCy64wO/jS5cuRd++fdUaSUShlhAXg0F9j0VCfCyDq6HCYcX3O9uivMrKNZACiI+PwcA+Xbm2T6AYxcWid9c2KlZE0UBmO990000YMmSI38fXrFmDOXPm4JVXXmn0fWvuI/+LXn4RLf89O2K7E02Yq+iIUXysyud4ftHmqqxCbGkJjl3xkbpmCTv/Hdk+MSKKUh07dlQdQNQ4GOrgmKvoiBFzFV3YrqIjRmxXoebYgXTPPfegqKhIswPp2WefRXp6OhYtWtSQlyHyKyE+DoP7d4Pd1XSn8DdUpT0Gq3dWr03GAVfaEuNjMbjvsY32ezFqjPp0a4fE+LhI7wqR8uqrr2LEiBGaHUgyyGX+/PnsQGoMlhqlo1w847gxV9HXKCP5nMtVGfpjs4mQknVxZSU47uuPPD9TDSazT4yIojl/ochgeuIfc5XgmKvow3YVfTFiuwoZUYOKRa9atQpnn3225uNnnXUWvvnmm4a8BJGmisoq/LJ9r7om/2ItdvRsfRixVjsT5mDH0o59PJaCxGjnvsOMERnGvn37kJCQEOndaHYl7MgXc5XgGCMd7HZUxSVgb79B6hoOdiDVYjb5xogoSt19991Yu3at5+fff/8d5eXlEd2nJs17shfHt/jF83BwjJE+bFfRFyO2q5ARNegv/vz8fKSkpGg+npycjMOHDzfkJYg0lZZX4IuVOSgtq2CUNCTEVmFkr51Ijq1ivhxAaVklvly9UR1TpP15+yFnFz9vFFHvvfeeKl0nFzF37lzPz96XSy+9FA899BAGDRrE31gkFq/nEF8P5irBSR5Xnc9xBpIWV1UVbKlp2HDR1era5eDs+9rfQyafGBFFq6effhqbN2/2/NylSxe88847Ed2n5lLCjv1H/jFXCY65ij5sV9ERI7arUHMsYSf1e7/77jvccsstfh+X2Uft27dvyEsQUQOYvIZcsT2PiIxu06ZNeOutt9RtWT9g9erV+N///ufzHLk/KSkJw4YNw8yZMyO0p8188XqecIhCymWvMdu+ijOQanE6edSRIbRu3Rrbt2/3/OziOdPH1KlTMW3atMb/xRAREVF4ZiBdccUVeP311/Hvf/8bTq+k3eFwYNasWXjjjTdw5ZVX1nv7FRUVmDx5Mtq1a6fK0Mg6B5999lnQf7dkyRJcfvnl6Nq1KxITE9GjRw/89a9/RUFBgd/nv//++zjhhBMQHx+vOsVk1LKdtcWpqY244pArIjK4KVOmoLi4WF2kweXll1/2/Oy+yNqM+/fvxwcffIDu3bvDiJ5//nmVl8TExKiGFL2PRYzZUuMOnnCIQj0DyednlrCrjR1IZBDnnXcepk+frga6XHjhheq+p556St3Wulx00UVoLiS3kRwvJycn9BtnekJERNT4M5CkIefbb7/FnXfeiUceeUR11IgtW7bg0KFDOP300/H3v/+93tufMGECFi9erLZ/3HHHqQUnR48ejeXLl+PUU0/V/HcTJ05UnU7jx49XHUIbNmzA7NmzsWzZMvz0008+ayJ89NFHuPjii9W+PvPMM+q5Dz/8MA4ePKgaaYiMrMaYcCKiJsN74EpT07ZtW9WA8tprr9XpsUjhGkhEYVZjxhFL2NXmsrOsHxmDDLRt1aqVatPYuHGjmjm9e/du5OXlaf4beQ7VDwdUEhERRbgDKS4uDp9++inmz5+vZv1s27ZN3T948GBcdtlluOaaa2Cu58LKa9aswaJFizBjxgzcc8896j7ZXnZ2NiZNmoSVK1dq/lvpdJIOIW8nnngirr32Wvz3v//FDTfc4Llftt2vXz/1PqzW6nCkpqbi0UcfxR133IGePXvWa/8p/OJjY9CvR0fExcUw3BqqnBas3dMKNruVM5ACiIuzom/3DoiL5bGkGaPYGHTr2JKfN4pKJSUlal1Gf2VgZCCJ0cjAFiEDX+ryWLSUsOOM16OYqwQneVx1PtegP0ua/AykmPIydFr9lboGKyXU5nT4xogoSkmZXWlrcJP2ElkXqSGVWygA7xSFM5D8Yq4SHHMVfdiuoiNGbFeh5ljCTm3AbMZ1112HpUuXqrUJ5CK3ZfZQfTuP3J1AFotFzSZykxJz119/PVatWqVG6Wip2XkkLrnkEnXtvWCle3/lNdydR+LWW29VjVCyDxS9EhPicNqgXkhKiIv0rkStCkcsvt7aAWWVMcyXA5Bj6LQTevJYChKj43t2YIwoathsNjUTWkbxpqWloXPnzmoh6pqXhnRKSUnbc889F5mZmWr0r8yEDmXJ3SbDVCPfYw+SB3MVnedg5nMBuex2xJcUodenS9S1/Ew1YuRw+sSIKJrl5uZ61kGSmUgjRoyI9C41jxlI/IvYL+YqwTFX0YftKvpixHYVMqKoHeq3du1atXaBzAbyJrObxLp169ChQwfd2ztw4IC6zsrK8nkNMXDgQJ/nSgNQ+/btPY9TdKqssmPP/jy0bpWG2JioPZQjymp2oEuLQuwpSOECrUGOpX3789GuVQaPpUAxOliA1LR0xoiiggz2kBnQMiPntNNOQ0ZGRsgbd2SNApnB1L9/f3z11VchL7nbZFhqroFEbsxV9MVo98HDaNcqmecXDdJhZI+NQ16n45C56zdZcJYfspqcDp8YWSsrGCOKWlLyX9ZAGj58uBogKwNPKExY/S8o5ir6YsRcRV+c2K6iI0ZsV6HmOAMpXGQBbKnzX5P7vn379tVpe48//ria0TRmzBif1/DeZs3XCfYask6S1C32vmzdurVO+0X1V1Jmw7Kv1qKk1MYwakiMrcSFfbchJa6SA8IDHUulFVj2zTp1TJH25+27ddv5eaOoIaVzpSTt22+/rTpupEytv0t9SR4gecKuXbtUOd1gJXcfe+wx9TyZ1fzll1+iU6dOquSuN+lMkplM/i73338/jMpUo4QdTzhHMVcJTvK46nyODf6aXC6Up2Xgp3ET1TVnIPkJkcPhEyMKrPLI7BeKHKl48r///Q9XX321yjlkYMyPP/7IX0lYg87w+sNcJTjmKvqwXUVHjNiuQgYVtdM2ysvL1RpLNUkZO/fjeslC0y+//LJqyJGRwd6vIbRep6gocPmD5557DtOmTfP7mCyCeejQITREYWFhg/59U1dUUv37KyjIh9MevoZ/I/8enF4jVPPyC5AStZ/4wAoLw1uKpLCk+viRNVScVexE8h+j6s9bfpg/b0YXqjWOW7ZsGZoNNWHS6XLCCSeEbfuSG7Rp06ZBJXfvu+8+VXLXPWP622+/RZPEEnZEjdvoaTfmDCRnSQnMycnh2ThnZdXJH3fcgfbvv6/OpRQZEvv33nsPVVVVmDdvnpq9/MILL6BPnz4qhxg/fjxatGjBX09D4+w1BYkVdomIiOonapuTZQ0BWVPA35oH7sf1+Oabb1QCNnLkSDzyyCO1XkNovU6w15BRQmPHjvW5T2YgSTkdWS+hoQ2ADifQIouNiFpMMSXqOj09A5npYfpj9Ajv0odGYrVUl24U6enpyMoybpmhrKzw/QFltpaqaymBlZkW3mPJqMxHPm8ZjfB5MzJzzZkYFDYXXXQRPv/8c9x0001NquSusEu5KrsdDodDXUtOEhMTozqqAj0WMTXXvGQLDVFo1fhMuRzGWwPpwG1/QdlXy5F5191I/7/rQ/8CTmfot9mEtZg8mZ1HUUDWjD777LPVRQYtvv7666oj6a677lJrK15wwQX4v//7P7UeY3Pp7Js6darmIN168Q4bZyARERE1rRJ27tIxNbnvk3WKglm/fj0uvPBCZGdnqxHCVqtvf5m7dJ3W6wR7DVm4W0YIeV+6desWdL+IGksz+TuDiJqhBx54QC1ALTN/pASMzPqV2b81L0YruSsefvhhNYjlpZdeUoNf5PbChQuDPhaxcruWqE0niZqIGh1IdmN1IFX++ivKvvxCdfLkPfVk2ErYkT4pY8YgsTmsz2cwaWlpuPnmm/H9998jJycHt99+O7777jucf/75qixucyEdSFLeT2IQCvx7mIiIKMIzkGQ0jIz81Vr0UdYFmDNnDl555ZU6b3vAgAFq8WkpI+c9qnf16tWexwPZtm2bGqkjnTzLli1Dsp9yCe5tSK1h90hhd2PPnj17fMrRUPSJjbGiR5d2iI2N2ol0EWd3WrD5QCYqHRYOCA8gNtaC7p3bcvHuQDGKsaJT20x+3ihquEvSygwgKVOrRWbqGKXkrnfjiVzq+likyu0mlpX53FdVWYHDuQ3bblNRZqtEp3aZKCkpYrndCMfIyOV2K0rLEGOzod3Pa9R1WXExnLm5Qf+dPWcDnFu3IuackTAlJqpGWeeunTC37wCT18A6ud91+DDMfmbcu4qLUfnuOzB36oyYYcN07a+rshKVby9WsxNjLxsDx++7fB7P1bHvAbdfXg7Hll9gye7reR+24mKfGFGA+F1zTYO/+wXL7YZP7969ccstt6gZxk899RT27t0bxlej5o7tKjpiFOtuezJuRZfGwHYVHTFiuwoZVINa3mV69YgRIzQ7kHbs2IH58+fXqwNpzJgxePLJJzF37lzcc889nlJzUh9YXs9dDub3339HWVkZevbs6fm3Bw4cwDnnnKOmhH/yySeaya3MGJJ/J68hHWHu8i/PP/+8miIu+0DRKzkxHiNO6Qu7iyMOtdgcsfj0ly7qNisKBTmWTsoOw1HatGI0uG9ndU0UDR588MGoKOcSqpK74dIY5XZjU1JR6XVfTEwsS/AeIcVXu3Y6plFyFaOW2xVdO3SAy+V9FBlTuMrtFiQmoKK4AP3e+4/6OSEmBikFBShbvhxJo0Yhpn37Wv/GfvAgfr/jdqmJibi8PLSYNBmHZzyB4lfnIbZ3bxzz5mLPd+jBeyehZOlSpFx2GVpOf9hnO4dfeRkV819Vt1u8+x5ij+sedH8LX38NxXOeV7edn32KjBsmwrubOTMxEebExHrFQjq79l56CSp/3YLk885HyydmVO9nXBwqvWJE2rJatYIlI4MhikLSrvHmm2+qdhYpxR8bG6vK2ElJfqonr1SRfw/7x3YV/TFqCrlKOLFdRV+M2K5CRhTWqRsyk6e+DSfSSSQNHlOmTFHlV6Q0nHRG7dy502ek8TXXXIMVK1aoPybcZOaRlLWZNGmSWrDae9Hq1q1bqxrDbjNmzFBl7qTDady4cWqq9OzZs3HDDTegV69e9X7vFH5VdjsOHS5GRkYSYqwcCeKP1eRAu7RSHCxOYMnngMeSA7m5xcjKSOWxFChG+SVIS09HTI1yoESRUJdZOOEkper8jQyuS8ndcJKZ2HIJq5prf7GFxoO5ir7zy8H8ImRlxPMcrMXlgj0mFsVt2iPlwB4UznsFJe+/B8fhw8h7eibSrvs/pN9wI8pXr4a1bVvEHHMMfj9juOefF85/FUnnnIPCV+epnys3bcKhKZOReOowxPbsqTqPRPHbb6Nqx04kjhihOmfMCQnq37rtufgipPzpciQOG46EIUNQ9uWXqNy+Dfa9e2GKi0PCKafCWVyEww//4+jv97ffcHDy33zezs5BJyJ+8BDViWSKiVH7kHr5ONjW/oTylSvhqqpC1c4d6jFr+w6wZGXBZDbDUVioniOdR6Lkww9Q+uUXSL/pZpR+tMwnRtYqNvJpkbhS5Hm3X3z99ddqoOzbb7+NkpISVYJfZh5dffXVaNEifOvANgc+GQrXQPKLuUpwzFX0YbuKzhixXYUMqM6tgO+99566uMnsHVnEuqaCggJ1/6BBg+q9cwsWLFBrHEht//z8fPTr1w8ffPABhgUpnyBrH4knnnii1mPDhw/36UCSmsJLlixR5V1uu+02NRL3vvvuUyObKboVl9rwzqdrMPa8k5CZXrtEIQGJsZUY1X0LFq7pzfa8QMdSiQ3vfPEjxo06GZlpPJb8f97KsfyHX9GqZRY/b0QhLLnbFJjMHMShhblKcMUl5SqfG3feYGSmJ4X02GxKytMzsXrCnThlzqNIOXRAdR65SYeSXALZd9WVPj9Lp5G748ib7af/qUveE4/73U7xm2+oS/wJJ6rn+TwmZet0sq2p/o4UpZ99ivxn/q3xzFVBy9nlP/0vdbu8ZRufGJEGDgSKGlL5RJYFkMotkkNcddVV6ueGtKFQDZGfrB71mKvoiBFzFX3HEttVdHze2K5CzaQDadOmTXjrrbfUbSl7IA0ksni1N7k/KSlJdfTMnDmz3jsn6wfIDCG5aPnqq68CjubRQ8q4yIWoqfGu7sQBV0RkZNOnT1f5xd///ndVolZ+DkaeLwNRwklvyd0mzWz2/ZkzkIhCKwo/UzU7j6JN6nXXwbZyJSq3VM9WMiUno9Oq7+E4eBD7Lv8TnGVlSL36ahS+8IJ6PHPyvch7coYsnKd+Thw5Eq2fnoWSZcuQe98UNRNKSv+VLn0f5sxMpF17LfL/Vd1xJVrOmIHk8y9A7kMPonjxYiRfcilsq7+Hfc8eJI0aDWdJCcq/+drz/I7ffgdTQgL2/Wksqn7/HWn/dz0KX35JlRzMuOsuFP3nP3AcWadIZmgd8867avbVgYkT1WwvmSFWtGC+1AxF5j1/Q95jj3q2nX7Lrci4/XYUvDgX+bNmIeFUmRlWjIqffkJsdjbMR9boo8iTcnUywFVmVUs+4V4/kZrNVykREVHT7ECSknJyEdKAI+XkrrzSd0QbEUUHTtknoqZCGlekQ2jy5MlqTQA9Jewa2oEkJW1lRrWU5BVLly7Fnj171G2ZtZyWlqa75G6TVmMtqroO5CGiwPiRqpuEISepThX5blIdJ//7H+L69YPJaoW1XTt0+GoFXHY7zHFxSDz9DJhiYxHXuzdSr7oKjtxc1emUcMopalvJo0cj8YwzYIqPh6uyEsnnnac6kqwtWyJtwnWo3LZNzYKKP+EE9fysadORee8UVf5P1qGScoEJQ4eq13DabLD970fEdOwEy5GyZMcs/QAum009P3n0KDiLihE/cCDSbrgRzrw8VGz4WZX7E/HHn4BO362s7rQ3m5F4+unVJQs7d0bquHGw79unygnGDx2qnp9+40Skjr9abdtRVKTiED+YM1uigeQPMiDmuuuuQ9euXSO9O01aFCyXSUREZHj1XshCFof+17/+hfZ+Fm0loiicgcT2PCIyMKfTGfDncJCZRbt27fL8LCVv5SLGjx+vGoAaUnK3yc5AIiKKoLgTTlRrJglLaqrqAPJmsljURcR7lRlVay61basu3qQDRj0uHU7Dj64tpTqe/KyZ636+tVUrdfHcHx+PxFNO9d0Xk0nNRBKx3Xscvd9sVms/JZ5xpu/zY2M9txNOPtnnfulIkou/ffEXB4qM33//XZWru/HGGz0/10fHjh1DvGdNFP8eJiIiilwHkkyvltG2s2bNaj4NJBRVYqwWdD6mJRdcDsDutGB7bhqqHGaWsAtyLHVql8VjKUiM2malIiaGa51Q8yGziEJVcrcpM1lYwk4Lc5XgGCMdXC5YKyvQ8tccdU3+uWMU05sN6xS9OnfurDoO60tm+cq/dxwpt9jUyAxzWZ86VFiRIziehxmjUGG7ir4YsV2FmlUHkujTp4/uxhWiUEtJSsB5Z5wAu6tpJs+hUOGIw9Kcbuo2ZyBpS0mOx3nDjm+034tRP2+nntBNXRMR+TDVnIHEKa/e353MVYKcX5KrY+RyVfKDpcmFhMJ8nPjGXMYoAHeMkh95hHGiqLV8+fJI70LUdyDJZePGjcjOzm74BlnCLijmKjpixFxFF7ar6Pu8sV2Fml0H0iOPPKLWPzrjjDMwYsSI0O0VkQ52hwNFxeVISo6F9UgZCvJlMTuRmViOQlscm/OCHUuFNqQmJ/BYChCjwpJypGc4GCOKGj///DOeeeYZ/PTTTygsLKxV1k5G6G7bti1i+9ds1CxhxxELHsxV9J9fUpMtPL8E4LBYUZaZhcS8XFgc9vp+WptFjDJM/LuAoteKFStCsp3hXuUUSR+mJ/4xVwmOuYo+bFfRfyyxXYWaVQeSLC6dmZmJkSNHokuXLuqScKTOsnfjzXvvvdfQ/SSqpaikHIuXfYex552EzPRkRsiPRKsNVw/ehIVresPlSmGMNBQV27DoozUYN+pkZKbxWPIbo5JyfLpyMy4fncHPG0WFr776Cueeey4yMjIwcOBArF27FmeeeaZao3HVqlVqlvSJJ54Y6d1sHrgGkibmKsHJYKC3Pvwe484bjMz0pFAemU2Hy6U6Rr67+T6cMudRpBw6EOk9ikruGGWaKpEe6Z0h0jBv3rwGx0baWB588EHGWFesvH7gBGm/mKsEx1xFH7ar6IgR21WoOXYgychfSV5kAUepwbt169Zaz2lIfV8iahjvjx9HXBFRUyINJ127dsX333+PyspKtGrVCvfdd5/qRFq9ejVGjRqFxx9/PNK72Sy4F6v3YAMNUWgxiaubmuuyEUWRHTt2RHoXmhfvv4cjuR9ERETNtQOJ6x8RRTd23xJRUyVl62SR5dTUVOTn56v73AtKDxkyBDfddBMeeOAB1ZFEYcYSdkQURUy11mUjouaK45mJiIgajtk1UbOZgcQxV0TUdFitVqSkVJfmTE9PR0xMDA4ePOh5XGYnbdq0KYJ72IzUbKzl+YYotLw+U8nnX4AOH3/KCAfgtJUzPkTk57uUQSEiIopYB5IsBDlp0iRcfvnl6iK3Q7U4JJEWq8WMti3TYbVyoVwtDliwrzAJdqeZ7XkBWK1mtMlK5+LdgWJksaBFepKKFVE06NatG3777TdPudyePXvinXfe8Tz+4Ycfok2bNhHcw2bEzPmuWpirBCd5XHU+x/OLJhdgqapE+u/bEJOQgJgOHdBmzlwYQeKZZzXaa7ljZC4uarTXJCLj4IBK/5irBMdcRR+2q+iIEdtVqDmWsJM1B6644gq8++676mQsI4BFQUEBnnrqKVxyySV4/fXX1ahgolBLTU7EpSOHwO6qLllEtVXY4/DW2p7qNgdcBTqWEnDpiEE8hILE6MzBPdTnjigajB49Gq+88goee+wxNRvp7rvvxnXXXYfjjjtOPb5t2zb1GIWfyVJjIAdnIHkwV9F5Dh45BC5XZciPzaYksSAPJ82fheRbblU/m1OrZ2BGu9ZPz8KOftmNGqOEm25ulNcjouhn8h7kwj+I/WKuEhxzFX3YrqIvRmxXISNq0FA/WXtARvv+9a9/xf79+5GXl6cuBw4cwD333IMlS5Zg+vTpodtbIi9OpxOlZTY4nE7GRYPZ5ERSbCXMJhfb8wKQY6i0nMdSsBiV2yr5eaOoIesbrV+/HpYjnRfXXnstFixYgOzsbPTv3191Lk2ePDnSu9lMFxhgC40bcxWd52DmcwHJQD2n2QxbcircWa8pLt7nObG9eqlra8eOCIX4E06EOTUVMcceW+9tJI0aXd3BXHOdtDBxxyhhROPNeiIiI5V0j+SeRC/mKsExV9GH7Sr6YsR2FTKiBmXzr732mmqweeKJJ9C6dWvP/a1atcLjjz+Oa665BgsXLgzFfhLVUlBchleXrEBhURmjoyExxoYbhm5AeoKNzXkBFBaVY/5736CwmMeSZoyKy/DB1zn8vFFUqKqqwubNm1FeXq7K17mNHz9eDWxZvHgxJkyYENF9bM4dSBU//QRXJWeTCOYqwUkeV53Pcd0aTS4XSlu0wld3PYxia5y6y5KV5fOUY956Gx2/+hod3lsK6zHH+D625F20W/QmEoef7rlP/n3WQ1PR+Yf/If3GiT7PTxg6FG3mvIBOK75B+/eWqtveUq8aj6wHH6q1mymXXuq5nXnX3Wg140l1u+0r8wIeA3F9spF23f+hvlIuG4OsadOBy69UMSpv36Xe2yKiposdSP4xVwmOuYo+bFfRESO2q1BzLGEns46GDBmi+bg8tmjRooa8BBE1gHeTHhNmImoqzGYzTjzxRFUu9/bbb4/07lCtGUhA6QdLkXzpZYwNUYi5O82tWVlIv/kWFL+9GBl/uU3db23ZUj3WfumHqFj7E8pWrEBc376I69FD3d/muec9M5q8O9/l3xcteh3O4mLEdO2Kti++7POaiacNQ5f1G1Cxfj0qftmMlAsvgjklBYmnn4GS99+HtV07WDu0R1zffmrWEaqqkHDaMM9rJAwajMy/TULejCc820wYegoSTj4ZSeeeC2vbduq+5PPOR8X6dbAfOICYbt3gqqiAyWxB8nnnoXz197CtXQtnSQni+w9A2TcrYPvf/5B5593qcWEvLAE+WsVjjog8vCdA8u9hIiKiCHQgtW/fHl999RVuvtl/nekVK1ao5xBRFLTpcco+ETURUrauU6dOqKioiPSukAb7778zNkQh4z+Jy7ztdnWpyRwXh4STTlYXf7w7j9TPVquaJVT62WdIPv8C///GakX8iSeqi5u1dWuk33ijz/MSh57i999bW7Xy+bntiy/Vek5cr17q4o90YsnFzd1pREQUEP8eJiIiimwJOylf9+abb6oOpC1btsDhcKj6qXL7lltuwVtvvcUSMkRRkjGz/4iImpLbbrsNc+fOVWsvUoT5GdJrads2IrtC1CQ1wrD5uN59kHnHnYhtwJpHgcQPHOS5HdM1PK9BRFQT10AiIiKK8Ayk++67D9u2bVMNOC+++KIqKSOkE0lKI0gHkzyHKBwsZhMy0pJgsTTOwrxG5HSZcbg0Hg6XiVP2A7BYTMhITYKlkRZ5NiKJTWpSPD9vFDVk0EpcXByOPfZYjBkzBp07d0ZCQkKtUfZ33XVXxPaxOTdumxPiI7Ir0Ya5io4YWcxH8rnapRDpCJcLZrsdyYf2wxxrzKjIDKRWM59G2dcrkH5teNaoY65CZHxTp07FtGnTQrY9diAFx1xFR4yYq+jCdhU9nze2q5AxmVzS09NAP//8Mz788EP8fqRciZSVGT16NPr164fmZuPGjcjOzkZOTg769OnToG0d+OMQWmRV1zIn/2IsgN3lCGt4cnNzkVVjoWKjuPqJYvzvN7u6veCeRAzp0aA+44jJzT2MrKwW4X0RhzFj05gO5R027GehsZjNbABtvFgH7/CVDiTpaKLw5iqJmzbh0M0Tfe7PfPhRroF0BHOV4KwmC1yuSkN/VMOZq+Q9/W8UzHnRs15Rxi23huV1mgLmKsExV6HmlKsUHHDgqcsK1e201mbc8VZ6CPey6Qh3rmLkNhU35io6sV0lKOYqwTFXiT4haTGVjqLm2FlEkSV9n3a7Ey6z70LAdJTJ5ILF7ITDyRlIwY4lh92hRhbxWAoQI0f17FLGiKLBjh07Ir0LFAg77hTmKjpj5HDAzHwuQJDkfyY4rVa4mPMGPJaYqxCR5neEk7HRPA+zXYW5SgiwXUVnjNiuQgYUknpNMirkiSeewK233qouM2bMwIYNG0KxaSJN+UWleGHR58gvLGWUNCRay/GXYWuRmWhjCbsA8gvLMHfxl+qYIu3P25Iv1vHzRlFDZjvruVAj8DOX3eWonv3a3DFX0RGjQnc+V9YIvxGDcrlQ0rI1PpvyFIosBq1h1wiYqxBRwBJ2XBVY87uT7SpBzi/MVfSdh9muEjxGbFeh5jgDqaKiAjfddBMWLlyoelG910C69957cdVVV+Gll15CbCz/0CGKBA5SJaKmymKxqPzjyiuv9Pv4G2+8oR5jCbsI9SDZWTqQKCyY3BER6f/K9C4v3eDFG4iIiJqnBs1Amjx5MhYsWIBbbrkFmzdvhs1mU51Kcvvmm2/Gf/7zH0yaNCl0e0tEdeJd2K/hq50REUWPYEs4SscRyy1Gjosl7IhC+IFiEkdE1OCvUpawIyIiavwZSNJBdPXVV2P27Nk+9/fo0QPPPvssioqK1HOefvrphrwMEdUXB1wRUROm1UEk+ccnn3xi+MV6Dc3OEnZEoeJTdokzkIiIdDN5DZlmVzwREVEEZiBVVVXhpJNO0nx86NChsLMBgcLEbDIhMSEOZu9p6VSDCSUVMXC6TBy8GqS0QWJ8LGcrBIqRyYT4uBjfMhBEjWzatGmqdJ1c5JgcP36852fvS0ZGhipvN27cOP6OIjQ7gjOQqjFXCU7yOMnneH4JzOR0Iq64EGa2gGrHiLkKEdX6XvDKTTgDyf95mO0qzFVChO0qOmLEXIWa4wykkSNHqhG+UsLOn48//hjnnHNOQ16CSFN6ahKuu+x02F1cZ0FLhSMBL6/qp26z+om2jNRETLh4OD9tAWOUhAuG91XXRJEyePBg3Hrrrap83XPPPYezzz4b3bt3r5WUJyUl4cQTT8Sll14asX1t9hycgSSYq+iPkctV2ew/NppcLiQfPogznn4AqXfezThpYK5CRIFrujM+gc7DbFdhrtJQbFfREyO2q1Az7ED6xz/+gT/96U+qgebPf/4zunXrpu7/7bffVAm7Xbt2qUWs8/LyfP5dZmZmw/aaiOo+4ooxIyKDGzVqlLqI0tJStd7ikCFDIr1b5IfLzsEdRCHjncRxIjARUf3+HuYfxERERI1fwq5Xr17YsGED3n33XTXTqGvXruoiM5Pee+89/Pzzz+jduzdatmzpcyEKhfzCEsx5/TN1Tf4lWMrw59N+QmZiedAF55uzvMJSvPDWF8jjsRQgRiV4+/O1jBFFjXnz5rHzKFrExNS+z8EOJMFcRX+M5FxM2kqy2uDTe59EoTmWYdLAXIWIamIHkv7zMNtVmKs0FNtV9MSI7SrUDGcgPfjgg1wzhCJGukMcDidHEgVJmK0WdhzpOZjkWKLAnE4Xp7JR1Pjiiy/w008/4W9/+5vnvldeeQVTp05FRUUFrrzySjz55JNqTSQKr/ghJ8HS7hg49u313OeyVzHszFV0cbnPwUxXAgbJZQKcMbFw8aMVEHMVItLqQOJ5RuMUw3YV5iqhwnYVXZirULPrQJJGGiKKYpyyT0RNlOQgnTp18vwsM6Jvuukm9OvXT5XU/fe//402bdpg8uTJEd3P5sBktaLt2+8gd9I9sH3zdfWdnIFEFDres8h9WkOJiCgg/j1MREQU2RJ2WiorK9XaBEQUWT4Drjiyl4iakM2bN2PgwIGenxcuXIjU1FR88803av3FG2+8EQsWLIjoPjYn5rQ0xJ96qudnroFEFCbsPyIi0v+VaT76pcmS7kRERBHoQFq0aBHuuusun/umTZuG5ORkpKen45JLLkFJCdenofCQVNBiMXMgZqAYmQC7gy0Neg4mOZYoMLP8AcbDiaKEDFSRDiO3jz/+GOeeey4SExPVz4MGDcKuXbsiuIfRr6i0zHM7r6AEFZXVtbFsFZXI91qPRm7LfUKeI891KymzodxWoW7bLTEobtkGLvmicNhRVFKGsvLqx6rsdlXz2+msLhdaXFqu/q36dw6Hekyu3duUx4U8Xx6Tfy9ke7Jdd0OQPFZZVf2Y7Edhsfd++76ngqKjj8lt7/fkXfdftuF+T7JteQ13o1Nd35PT4VTnF9lecUn1e3LIeyqQ91T9fkvVeyo/+p4KvN9TJQqLy0LwnsrUtjzvqcD7PZWrfah+Tw71mMP9nkpqvKeCGr+nELwnian7/GKrqEJ+kdf7LSpT93mOPa/jUrZR5vOeSgO8p1Kv92Sr8Z5Ka7wnm9d7Kg3wnko970n2o7i0+vWE7OfR31MI3pPLhYrkNJiqKtVpWL2nQq/fk87Pk8PzedJ4T16fp7Iavyd5zOc7wuvYk9s+3xE1jj2f9+TzearxewrBe5Lct6Tc5vfYK1PfEaF6TxUan6cyr/dU/ZjmeyoI8J7U58nu9XsqC/178vouLygu9XlPh2u+p7Kj7+mw13si8uf0009HfHy8aheSy6hRoyIWKA6o1BcjtqsEiZG7vYB/Cwc9mNiuEhzbVciIGtRi+tRTT/nMNFq5cqXqQBo5cqTqWJLGnEceeSQU+0lUS0ZaMm6+4mx1Tf5VOJLw7DcnIK8sgSWfA8hMS8JNY89CJo+lADFKxmUjjmeMKGp06NABP/zwg7q9detW5OTk4JxzzvE8npeXh7i4uAjuYfT75odfPLff/GgVduw5qG5v2bEf735eHVsht+U+Ic+R57qtXLcdG3/brW4ftMThu5vvg9NqhcvhwPJVG7Bu03b12OH8Yixe9p2nE+O7Hzfjh/W/eRqR5TF3Q7bcL48Leb48Jv9eyPZku0LWzZHH9h/MUz/Lfnz69VrPvi35ZBV27a1+T7/t3I8Pvjz6nuS23CfkOfJcN9mG+z3JtuU13Ovk1fU9mS1mlats2b4f3/64RT1ms1XhrQ+/R27ekfe0cSeWr8zxvCd5bN8f+dXv6dfd+GTFes++vf3RGuzac6j6Pe04gKWf/8/zmNyW+9R72nNIPddNtiHbErJteQ3Pe1qZo/ZByD7JY7KPQvZ5zbqt1e+puFw9JtdC7g/Fe/r82xyccVIfdS7esuMA3vv86O9Qbst91cfeYbz10Y+ex5at2ICcX6vX3dr3RwEWfbjG854+X7kZP2383fOe5DH3e/r6x1/x/brq32FRsU09JtdC7pfH3e9JHnO/J9mebNf9nuQxeV0h+/Hd2uoYCtlP2V8RkvfkcmHrsHPR8aeVSIMDuflFWPTRKk9nwNf/+wXf/3zk91RSrh5zf57kfnlcvaeKSvWY/Hv1njbvwOffH/09yWP7Dlb/nnJ+241l36w7+p4+XY0de6uPvS07D+C9L4/ut9yW+9R72ntIPdfznr5Zp7al3tPBfPUant/T9zlqH9TvKQTvSXKVYzu0xP9yqn+/8jpvLFuJfX8c+Y74dTc+8vqOWPzx99h55PP06479eP+Lo+9Jbst9Qp4jz3WTbRz9POWp13C/py9W5WDtxiPvKa9YPWY78h3xzQ+bsXrdke+I4nL1mPvzJPfL49XHXqV6zH3syfZku6F8TzW/y5d9tRY5W6rf094/8rDog6Pfe59/twE/bayO6SH5PH3wnec9EWl56aWX1GBiuXz00UeRCxTXQAqK7Sr6YyS5Cmlju0pwbFchozK5GjCPNzMzE9OnT8df/vIX9bNcL1myBL///jusVivuuecevP/++/j11+o/xJqDjRs3Ijs7WzVk9enTp0HbOvDHIbTIahmyfWuKYiyA3VU9ci9ccnNzkZWVBSO69ZkSfPVzdYPJc39OwFkDYmBEubmHkZXVIrwv4mjQknDNwqG8w4b9LDTqaCJqFDJgRXKQ8847T517CwoKsG3bNjUDWowbN07NQFq16mgDGfnmKitXr8HJgwep+2QkelJiHOJiY1SDbLmtChlH/kiWGUgJ8TGIj4tVo9ZlJHpmevXgja07dqNVq1ZIiI9D/uLF2PfMM0g+9AeSL7kEMVMegNViQWJCnBq1XlxqQ3pKIsxmsxppbzKZkJwYr0bgS8NwanKCer6MxJf0NCUpQc3uKSguQ0pSPGKsVjX7R56fmpyoniMj6mUbsTFWNctHRs6npbj3u0S9tvs9yayP9NQkz2yd+Lij70m26x6QIjOQZHvynmR7sj8ZqUlqf2Ukfl3fU0KsBQWlpXA5XUhJTlAj9wuLytTtGKtFzS6Qhlp5rnpPhaVITnK/p8oj7ykx4HuSXMUamxDgPZUdeU+x1e+p1KZ+v9XvqVyNFk1S78mhZhWlpSbCIu+ppFyV//G8p+JypKZ4/Z5C9J5SExMRG+NS76e8ogoZqUceKypDgnpPMdXHXnmlp/FG3lNMjBWJnvck7zdR4z3ZkJaacOQ92WAyw+s92ZCaEu/1noCU5Pgj76lc3fb/nsqQnBSn3pPMsPnjj1x06dSu+vNUWIqkhNgjv6eGv6e8f87A/vc+hNluR7tbbkHS+KvV8SYxtNTh86Tek/o8afyevD5P8p6qvH5PMrNF4un5jlDv6chnraj0yHs68h1RXuEZcFLrPfl8nmr8nkLwnn7ffwBpaWlHvyO8jj2ZYVNV5QjRe7Ig0f0d4fN5KoPFYjnynuxHjj2N91Tz8+T9ntTnqfp7r/r35AjZe5LvkJrf5TIDSbbnfk/y3Zbp/Z7MFnWOkPdUVGJD+pH3RKQ1A+mGG27A+PHjI96uUmlz4R9nVXeMW+OA+z7LrPe2mrJwt6sYuU3FzWqywOUyduc521WiA9tVgmO7SvRpUNZXUVGhpia7ffrpp2p6snQeid69e2PPnj0N30siP6TxZ97bX/mUbyFf8ZZyXH/yz0hPsHEGUgDSmPPquyt8ynxQzRiVYumKDYwRRY2///3vuPfee7F792507NgR7777rqfzSGYfffXVV7jwwgsjvZtRLTWpusFRSCOiNDgKaTB1dx4JuS33CXmOu8FRSEOodLQIaSROOXQAJrjUDCRp7JSGSvWY1aoaX6WjRUgjqfxbIY2n8phcu7cpjwt5vjwm/17I9mS7Qho25TFp9BSyH+7Oo+r99n1P7s4jIbe935P3bGbZhvs9ybblNeS1VMzq+J6kYVlyFbvdoTpXhDS6SgylsVtIY680jHveU7r3e4r1NAw37D0lqm153lO693tKUPtQ/Z4s6jF3w7Dss897Sq/xewrBe5LHX1v6nToXS6eKu6NFvd/URHWf59jzOi5lG4k+7ykpwHtK8npP8TXeU1KN9xTv9Z6SArynJM97kv1ISTo641H28+jvqeHvyQUXnBYrVt3wNxSZrNXvKc3r96Tz82TxfJ403pPX5ymxxu9JHvP5jvA69uS2z3dEjWPP5z35fCnVaMsAAQAASURBVJ5q/J4a+J4kV/n8+1/gcLr8HnvSORK69xSn8XlK9HpP1Y9pvqf0AO9JfZ6sXr+nxNC/J6/v8vSUJJ/31KLme0o8+p7kMXYeRT+Z+fPQQw+p8r4y8Fd+n6+++qpmu87kyZPRrl07JCQkYMiQIfjss88a9PpSkaZly5Y4++yz8fPPPyNSjhzGCtcE9o/tKvpj5F2Slmpju0pwbFehZtmB1KVLF3z++efq9o8//qhKyEiC4vbHH3+omrdE4eB0udToWueRPxLJHxeS46pgNkn9fEZIi4yglpG2XFhVm8RGRlFLrIiigQxWkTK5a9euxfLly3Haaad5HpOGkgMHDmDKlCkR3cfmxnSkIVQ5sq5Hc8dcRUeM5BxcXsHzSyCSxpnNqEhJg5MTXbXDxFyFyGfGh8zU3rx5M/r37x8wMhMmTMDMmTNx1VVXYdasWWoW3ejRo/Htt9/WK6JPPPEEduzYoSrTSAeSDDIuLq4uyRjJDiT+Pewfc5XgmKvow3YVHTFirkLNsQPppptuwptvvol+/fqpdQfat2+P888/3/P4d9991+AybkRUfxxxRUREjca7A+nI4u9EFFruWSFERIG0bdsW+/fvV+V8Z8yYofm8NWvWYNGiRXjsscfU8yZOnIgvv/wSnTp1wqRJk3yee+qpp6rvIH+X+++/3/O8wYMHq4HEMptJtpGSkoLvvz+6jlij8p6BVL2sFxEREdVRgxb9uO2221QJu2XLluHEE09U054lSXCXj5HRvzfffHNDXoKIGoADroioKZNRtfPmzcP27duRn59faxahNGh88cUXEdu/5sZ0pNySkBJ2RBQirLtERHUUFxeHNm3aBH3e4sWL1Ywj6Thykzae66+/Hvfdd58qFdyhQwd1f31nJEmp10hVevAZUBmRPSAiIjK+Bq8af+ONN6pLTVI+RsraEVHkcAYSETVVCxcuxHXXXYeYmBj06NEDGRkZtZ7DspSNzKeEHWcgEYWMT8MrZyARUehIKeDu3bsjNTXV536ZRSTWrVvn6UDSo6CgAD/88AOGDRumBvI8++yzanCxrKsU8b+HOQOJiIgoMh1IRJEiC8HeNG4EXGaOJdJS6UrA7K+Ph8MpCzCT5rGUloiJY86ExdKgqp5N/vN26VkDkOG12DdRJE2dOhXHH388PvroI2RlZfGXEQVMFq8ZSHbOQBLMVYKT84rkc2YzOx0DST70B85+7K9I+9vfGvxZbaqYqxDVnZS5k3J3Nbnv27dvX522V1VVpdag3LJlixrkM2DAAFWxJi0tTfPfHDx4EIcOHfK5T9bXDgmW5AiKuYqOGDFX0YXtKvo+b2xXoWbZgfTJJ5/g5ZdfDlg+Ztu2bQ19GaJa5NiyWiywu9hIpcUEExzO6k4RVj8JcixZvUbOk98YSQcb116gaCENGvfccw87j6KJ9/coS9gpzFX0n4NdzOe0uVyQoUAWexXnHwU5lpirENVNeXm5KndXk5Sxcz9eFy1btqxzJZrnnnsO06ZN8/uYzF6q2blUF9V/Ax/NT3IPHfKZlUTVZBylA+GbolVYWGj4UFvUEvLGHuxSWFgU/hdxsF0lmJKSYg5eDiJU39NyTqIo6ECSRRbvvfdetG7dWk1x7tu3b4h2iyi4wuJSfPrNWowc3h9pKYkMmR8xZhvGD/oFS3OOhctVvT4Z+TuWyrDsqxyMPm0AjyXNz1sZPvluE84/cyBjRFGhX79+dR4VS+Fl8iph52IJO4W5is7zy4r1GD08m+cXLS4XSjOysPbyG3GmyQrtcfzNG3MVorqTNawrKipq3W+z2TyPh9utt96KsWPH1pqBdPHFF6ulERreAJjnudWiRRZMZvYgRSJXMXLFgKaUq2RltQjbttmuoi9G36/ajPPPbGv4YymczPyeblodSLNmzcKZZ56ppiTL9GSixuRwupBfWAqHg8WMtZhNTrRIssFiYgG7gMeSw4X8olI4nDyWtD9vThSV2vh5o6gxc+ZM1dgwatQoDB06NNK7Q8LqlVayhJ3CXCU4yeOq8znmKtpccFqtKGnZFg7HYX7faB1LzFWI6kxK1e3du9dvaTvRrl27sEe1VatW6hIuJrMLLqfJMyOJ3Ue+mKsEx1xFH7ar6IgRcxVqjh1IUrJuzJgx7DwiilI+i4ayXYaImpDHH39c1dM/7bTT0Lt3b3Ts2BEWrxkw7nJG7733XsT2sXnPQGJ5WaLwfNAYVyIKHVmjaPny5SgqKkJqaqrn/tWrV3seb+w1LrXK2YUC/yYmIiKquwatGC9l62RxRCKKTj5rhrIDiYiakJ9//lmVV5GOo5KSEmzatAkbNmyodaFGZPEal8QSdkShwxyOiMJEBgQ7HA7MnTvXc5+UtJs3bx6GDBmCDh06NHoHkqyrnZOTE561NPh9SkRE1LgzkGSxQykdM3DgQFx55ZUN2RQRhQFzZSJqqnbu3BnpXaAaTFavGUgsYUcUMtKYevSDxilIRKTP7NmzUVBQ4FkzcunSpdizZ4+6fdttt6mZ3NJJJCWBp0yZgoMHD6Jbt26YP3++yrNefvnlphFqVuUgIiKKXAfS5ZdfDrvdjquvvhq33HIL2rdv77d8zPr16xu2l0R+pKckYsKlw2GN8z3m6KgqxOOllX1RXhXDGUgBpKUm4NqLTkN8XCwPH60YpSTi/GHZSEvlQo9EpME7B+QMJOYqOsl5RfK5uDh+sgJJOnwQp//rfqTddScDxVyFSJcnn3wSu3bt8vy8ZMkSdRHjx49XHUhiwYIFeOCBB7Bw4UK1TEG/fv3wwQcfYNiwYU0i0izrHhjbVYJjrqIP21V0xIjtKtQcO5AyMzPRokULHHfccaHbIyKdzGYzkhLjYXdxnQVtFpRWVneKuDhfXztKciwlsPMoWIwS4mPVNVE0WbFiBT788ENPA0mnTp1w3nnnYfjw4ZHetWbH5FXCjjOQqjFXCU7OK3GJMtClMmzHpuG5XDA7nYgvKWpY/fEmjrkKUf1ma8fHx2PGjBnqEmnhWAOJJewCY64SHHMVfdiuoi9GbFehZteB9NVXX4VuT4jqqKikDCu+34DTh/ZBanIC4+dHjNmGscf/ik82d4HLFc8YaR5L5fj8u18w4qRsHksBYvTlmi04d1giUpM5C4kir7KyEldccQXeffddVd4pPT1d3S+lWp566ilccskleP311xETExPpXW0+vErYwW6P5J5EDeYqemJUjq9WbsRZQ3vyHKzF5UJZeiZ+vuhqnA4Lji5zTzWPJeYqRMYmHUhy2bhxI7Kzs0Nfws4Zmk02JcxV9MSIuYq+Y4ntKnpixFyFjIiD2Miw7A4n9h8qgJ3rLGgym5xol1YKq9nJBUMDHUt2Jw7kFsDu4Gw27c+bA4cLSlWsiKKBjE5955138Ne//hX79+9HXl6euhw4cAD33HOPKtEyffr0SO9m852BxBJ2CnOV4CSPq87neH4JxBETi4KOx8Ju4p9vmscScxUi8pefeHcgMUJ+vjvZrsJcJTTYrqIjRsxVqDnOQHKrqqrCL7/8gsLCQjidtf/4ayq1c4mMxnuZZSbLRNSUvPbaa7j22mvxxBNP+NzfqlUrPP744/jjjz9ULf9//OMfEdvHZsfqlVayQ54odFzM4oiIQjMDyVXjr2QiIiIKaweSdBZNmTIFzz33HMrKyjSf52AjAlFEcMFQImqqZNbRkCFDNB+XxxYtWtSo+9TcmbxK2HENJCIiIooGXAOJiIioYRpUA+HRRx9VCy2OHz8eCxYsUGsQ/POf/8ScOXPQr18/9O/fH5988kkDd5GI6oszkIioqWrfvn3AtRhXrFihnkONyKuEHVjCjig8OHCeiJowWf/IZDKFbv0jlrAjIiKKbAfSq6++ij/96U94/vnnce6556r7TjzxRNx4441YvXq1OvF/+eWX9d5+RUUFJk+ejHbt2iEhIUGNJv7ss8+C/rstW7bgrrvuwtChQxEfH6/2Y+fOnX6f27lzZ/V4zcvNN99c7/2mxpGanIBx55+C1JQEhlxDFeKxcE1vFNriWP0k0LGUEo9xo07m4t1BPm/nDO3FzxtFDSlf9+abb6rztZz3ZbazzIyW27fccgveeustTJgwIdK72ayYLF4zkDj7XGGuEpzkcdX5XHz4Dk6jc7mQmJeLU+Y8ihRwrSgtzFWIjE86kGRgck5OTphK2IVus00FcxUdMWKuou9YYruKrs8b21Wo2ZWw27NnDyZNmqRux8XFqWubzaauY2Nj1cykmTNnqplK9SENP4sXL8add96J4447TnVYjR49GsuXL8epp56q+e9WrVqFf//73+jduzd69eqFdevWBXydAQMGqEW4vXXv3r1e+0yNx2qxoEV6MuwuB8OuwWQyI6+suoON5fMDH0uZadXfYaQdo7TkBHVNFA3uu+8+bNu2DXPnzsWLL74Is7l6TIx0IknDg3QwyXOoEXmVsIPdztAzV6lTPudyVfKY0eJyweKwI+XQAVjMnIIU6FhirkJENbGEnb7zMNtVmKs0FNtV9MWIuQo1uw6kFi1aoKSkRN1OTk5Gamoqtm/f7vOc/Pz8em17zZo1au0CKZF3zz33qPuuueYaNZVZOq1Wrlyp+W8vvPBCFBQUICUlBU8++WTQDqRjjjlGdXaRsRSXlmPV/zZj6MDuSEnmLCR/rKjABdnb8NVvHQBwZK/msVRiw9c//IZhJ/ZEShKPJa3P27c/bcVZpyQxRhQVLBaLGlhy9913Y9myZdi1a5e6v1OnTmqwiZTSpUiWsOPgDsFcJbjiknKs/PFXnDawG1KSmatoKU/LwKZzx+IUmJEais9rE8RchYiCzkByMUb+vjvZrhLk/MJcRd95mO0qwWPEdhVqjh1Ixx9/PH744QfPz2eccQaefvppdb+MAJZZQLIOUn3IzCNpHJo4caLnPilHd/3116sRxbt370aHDtIoXltmZmadX6+yshJVVVVISkqq1/5S46uyO7Bz7yEMGnAsw6/BbHKga1Yhvtt+DJPlIMfSrn25qOrPBs9AMdqfW4SqKsaIoot0FLGzKDqwhF1tzFX0x+ikAV3CcFQ2DTKr0h4bh0Pds2FHcaR3J2oxVyGioOsCswPJ73cn21WCn1+Yq+g7D7NdJXiM2K5CzW4NJFnrSNYpkot45JFH1MyfYcOGYfjw4SgqKsJTTz1Vr22vXbtWlZGTWU3eBg8erK6DzSqqC1mnKTExUc2ikjWRZs2aFbJtE0XLdH3mykRkdFImV9Y8euaZZwI+TwawyDpIMjCEGpF3iUu7XTV6E1EI+HyWWMKOiJr2GkiyJrVUnglLqxdTEyIiosadgXTRRRepi5usOSTrEXz11Vdq9tDQoUPrNRtI7N+/H23btq11v/u+ffv2IRRk1LKsp9SjRw8cPnxYlcORNZdk+48//njAf3vw4EEcOnTI576tW7eGZL+IQoGjrYioKZH1juQ8vWnTpoDPO++881S5WznHS0cSNQ6TrEMlF+eRFarlmuumEYX2c+azmAcRUdPrQJLLxo0bQ9aJxL+JiYiIItSBVF5ejr///e+qbN0FF1zguT8tLc2nU6kh24+Lq72ovZSxcz8eCu+//77Pz9dddx1GjRqFmTNn4rbbbkP79u01/+1zzz2HadOm+X0sLy+vVudSXRUWFjbo3zd1RSXVx0BBQT6cdlvYXsfIv4eKygrgyJI+c5eVY8m3ZTAiWYvdai0I2/ZT48pxQtvqNducVeE7loys8MjnLT/MnzejC1W7XsuWLUOzoSbmzTffxGWXXYauXbsGfN6xxx6LsWPH4vXXXzdkB9Lzzz+PF198ERs2bFC5ljSkuElp36VLl6K0tFSt9/Too4/65GERJx1G7g4kWQeJHUhEDcfZfERE9WbymoHEr1MiIqJG7EBKSEjACy+8oGYdhYNs310ar2b5Gvfj4RrVd9ddd+GTTz5RM6nGjx+v+dxbb71VNVDVnIF08cUXq5lXDW0AdDiBFllsRNSSmm7HJeekICMjCTFWr7I5YZCVlQUjik8oxltre6DIFou8MhP25pmaY7XNoKzmePx+qAfGndcGmSkxYX0to0pLd+CMQU50bN8WMdYGTV5t0sxmo37GjEE6VK666ipdz5VZ0NLRYkQy21o6jV577bVaj919992qhJ8MspF1KEeMGIHt27ejRYsWiAYmqxWuI6UDXXY7TLGxaM5SkuJxyTmDkZIcnry1KZDYVMeoepAY+eECEgryMOTVp5E08QaGSOtYSkrAGYO681giIk0uJ2vY1f7uZK7CXCU0JJe75KyB6nxMGjFirkIG1aBWwBNPPBE5OTkIV+PJ3r17/Za2E+3atUO4dOjQwTOLKJBWrVqpC0WGNGK3a5UBu8vBX4GGs06Ix5vfJMN+ZDA4+Wd3WrArLxklNjMyUxgl/583C7Iyktl5RBFVWVmJWJ0dEvI8fwNRjEAGoohly5bVeqxnz54+g14kJpIvRUsHks+MI5mB1MwxV9ETI4vK51yuykb4jRiXtaoSGbu3I4YDFTQxVyGiYDOQyN93J9tVgmGuoj9ObVtm8GMWJEZsV6Fm14H09NNPY/To0ao27YQJE2AN4aj0AQMGYPny5SgqKkJqaqrn/tWrV3seDxcZyStYQii6lZTZ8L+ff8PAAV2RnMhRq/707eTAE1fsQ3qLDoiNrV0S0igKC4uQlnb0eyCU/vpiOUrLKzC0y16UlknDbFJYXqcpfN7WbNiJYUOS+XmjiJHBI3oHrsjzGjLYpKSkBDNmzFB5x5o1a1SJy3nz5ql8pybpqHrwwQexcOFC9TxZe+nhhx/G2WefjXCQGdCyLzIrW/Kwvn37IlqYLFbP+tQuhx3NHXMVfTH6cd12DBnQiecXTS7YUtLx65nn4ySXCRzron0sMVchokBcHFjJXKUemKvoj9P3a3fipH7dmNMFiBFzFTKiOvf4fP311+jVq5fqXLn22mthNptx00034fbbb8cxxxxTq7ScjI5dv359nXdszJgxePLJJ9WC2ffcc4+ngUYaTIYMGeKZJfT777+jrKzMZ0SuXjLDSNZssniNlq2qqsI///lPNXJZ1nei6FVZZceWHfvQr3dHIDHSexOdKivt2LVnP07u3wGZ6cYtO5ab60JWVnj2PyHOhKpKB3q1yUMVGzsDft527c9TxxQ/bxQpUq5twYIFmDJlSsAZwAcPHlTPq1lmti5yc3Mxffp0dOzYEf3791dlbbVIp9LixYtx55134rjjjsOrr76qOnZkIMypp56KUJM1GKWMneyTdJRJrhU1vEvK2jkDiblKcHJekXzu+N7teX7R4nKhKj4e+/oNRhWMuZ5lY2CuQmR8UsJXa53p+vJOk7gGUm3MVYJjrqJPZaUDv+7cjxN6ddb78Wx2mKuQUdV5Mq90qnz++efqtpRL6dGjB4YNG6Y6ddq3b6/u877IWkD1IduThh9pJJo0aZLqSDrzzDOxc+dOPPHEE57nXXPNNapDy1thYaEa+SuXL774Qt03e/Zs9bNcu73//vtq/++99161ntNjjz2GE044Ad99951KXNq0aVOvfSci4+AfFETGMXnyZDXrRvIB94zkmuT+s846Sz3vb3/7W4NK6UrZ3F27dqmZSFpkdtL/s3cfcE6U6QPHn2xvbKGz9CIgIIIiiAXsvVfsnnr2eufZseud4unZPcthF//WO9upKHoKChZQQIooIE3qFra3+X+ed5kw2U3dTTbJ5vf9fJZdJslk5p3JzJP3ecu0adNMDKHPO//88+XTTz+Vvn37mvjFSZNJmuzx9nPTTTeFtH3a+EX3U2Myb0PdRYvL0SjHYgg7IDycNZ6xlDAGgDDTehjLssI6VQJD2AEA0DohN+nXm7n+KH+tccNBWw9PnjzZY0iYd9991ySs/NHn6uuc/v73v5vfWqFz6aWXmr91yJdhw4bJiy++KBs3bjS9jnRovP/7v/9rVatlAPHDOZUAQxoAsW3AgAHmHn3KKafIHnvsYf6v9/IOHTrI1q1bTWXDL7/8IllZWSapM3DgwBa/V3p6elANSbTnkSZzNHFky8jIkHPPPVduuOEGWbVqlbvX9JdffinhVldXJ8uWLZOYkewILesYwg4AAMQOvu8BABC6mB7TSitgtDWvv5a/3pJY/fr1cye5/Nl1111NLyQAicuZQGoIfNkAEGWHH364/Pjjj3LPPfeYRiVvv/22+zGd8+iPf/yj6fmjyaW2MHfuXBk8eLDHfI1q7Nix5ve8efPcCaRQkkL6U19fb35rb6rU1FQzL9N7770nRx11lImR3nrrLTNMnvZ+8jecnzaScYpkwsnlGMKOHkhAmNADCQDC0gOJIewAAGijBFJMjbWPhJWTlSGH7TNacrIzor0pMUvLprGM0qO9KTFLL2dbq9PkP/MHysTxlJO/z9ueowbweUNM0IYijz/+uPnRnkelpaUmgaM9kdqaDnOnw901ZS9bu3ZtyOvUIXed4//fddddZg7I4447Tp566im5+OKLTUOZQYMGycsvv2x6T/ubL8nXXAI6F2TT5FKodNhgJ+esR8UbN0hSlufcmImmtq5e9ho9QKqrymXTpqqIvU/T4xBP2qqMIq2kpDRi666qqpbMkiLZZdqTYp18nJmjDd7PpVGDu8f9uRRp4foqr3MiA/GGBFJz1KsERr1KcLTe6bC9R5lzCj7KiHoVJFIC6fTTTzc/wSabtPUsEG5pqSnSv1dXqbOYpDtQGVlWDSegz2uUSG19sizfnC/JzqGX0OxcKuyab34DsUSTRtFIHNkqKyvNcHdNaQ8h+/GWjP+vP95oj6NQaLKp6bC82gPpmGOOMfNUtrYCsL5BpFPn7euoSc+Q2m1/5+XmSprjsUTVu2f3NolVOnfuLPGqd4/kdhGrdO7cKSLrXZ+eJnU11dL15wXSscNZkhPHxzrSUtJS4vqz0BaSnN3vgURLmjLiRDPUqwRGvUrw5dSvJ7F/oDKiXgXxqEU1gQcccIAZrgWIporKavlx0a8ycnhfyc6k54g35VpGC1fK6OG9KCMf9Dt0VlqtjOnzu1RWDYr1kT2jei7NXbxK9ti1A+cS4JCZmSnV1dXNykSHnbMfj6auXbuanzaTvH0IO6mjgQexSmDEKkGwRKpycmX5HgdIToNITis+ou0ZsQqAQAkkeiA1R6wS3P2FepXgyun7Bctklx37U2fgp4yoV0E8alFN6VlnnSWnnnpq+LcGCEFVTa38uOQ3GTKokJuTD9XVjWU0bFB3ysjPF4qMlDoZ3WuD1Nb14zPo61yqqZVlv22UXUfUci4BTYaqW7Nmjdeh7ex5mRKJ5xxI9EAnVgmMWCUYltRmZsnKcfvIzu4+fmh2LhGrAPAanDiupmSQmiFWCYxYJTjV1XUyf+kqGT6QBsw+y4hYBXHKMZ0gACR2i7QGhjQAECKdf2jp0qVmHian2bNnux9PKM6hQOvpgQSEHaOPAWjHdAhfnQZhxIgRYVsnQ9gBANA6JJAAJDTnMPBWQzS3BEA8OuGEE6S+vl6efPJJ9zId0m7q1Kkybtw46d27tyRsDyTmwATCgxbzABIogaS9hBYsWBC+lTKEHQAArcJkHwASWpKjSRr1MwCcHnnkESkuLpa1a9ea/7/zzjuyevVq8/dll10meXl5Jkl04oknyvXXXy8bNmyQQYMGyXPPPScrVqyQZ555JvEKlB5IQPg5AxR6IAFASJgDCQCANk4gNTTQRB+xITszXfbfY4RkZ6VHe1NilpZNYxmlRXtTYvoLRVlNqny4qJ/stktqtDcnpj9vu43oy+cNCeW+++6TlStXuv//5ptvmh91+umnmwSSev7552Xy5MnywgsvSFFRkYwcOVLeffddmTBhgiSc5O09kKSOIeyIVQIjVglORmmJ7PTvFyTrjFNa+uls94hVAHjFiBMBr53UqwQoI+pVgrsPZ6XJfuOGM2dygM8b9SqIR/RAQtxKT0uVoQN6Sp1FBVWgMrKsmjY9NvGWQKqpS5HF6ztJUhIJJH/nUr/CTuY3kCi0F1EwMjIyZMqUKeYn0XkMYVdfJ4mOWCX4MiJW8cOyJLW6Unr++I2kJZFA8ncuEasAaIo5kIhVWotYJYRy6l/IRShAGRGrIB4xBxLiVmVVtcz5YZlUVpEc8V1GNaaMKigjv3MgZabWyrh+a6WmhnPJFz2HFi5bKxVV1a396AJozxjCzgOxSmDEKkGwRKqzcuTnCYdKpcUYdr4QqwAIOIQdReTlPky9SiDEKsHfh+fM/4X6pwBlRL0K4hEJJMStyupa+Wb+LySQ/JVRVY0po6qq2rY7MHH4hSIztU5277dOamopJ1+qqmvkp19/51wC4P+a6hjCzmIIO2KVIBCrBKcmO0d+mXioVJNA8olYBYD34GT7nxYzMjS/D1OvEhCxSnC03unbhb+a+zF8lBH1KohTJJAASKL3QPI2RzUAoAVSHKMjM4QdEBYWAQoAtBhD2AEA0DokkAAkNOcXigYSSAAQvh5I9cxRCISHM0BhCDsACAkNBgEAaBUSSAASWpLjKkj+CABayZFAkro6ihMIN/JHANqxW2+9VVwul4wYMSIil016dAIAEDoSSIhbWRlpsteYoZKVmRbtTYlZWjaUUeAvFBU1qfL5z70kJZlzyee5lJEmo4b04vMGwP811TGEHT2QiFWIVcLEsiS9rFSGfviGZPLtzSdiFaB9JJA0ybNgwYKwrdPlvG7SYrAZ6lUCo14l+HLac/QQc07BRxlRr4I4xVcQxK2M9DTZeWhf8xuByiiVIvIzB1JVXYrMW9NNkpIdc3eg2bm0Q9+ufN4ABN8DiSHsiFWCQKwSBMuStMoK6Tfnc8lIpguSv3OJWAVAgMspfN6HqVchVmkdrXfaeUgfziW/ZUSsgvhEAglxq6q6Rn5YvNL8RqAyqqWI/LRIy0ipk1E910tNLeXk7/P288oNfN4ABD8HEkPYEasEgVglODWZWbJi7ESpovLT77lErAKgWWziHLKca6if+zD1KsQqraP1Tj8s+Y1zyW8ZEasgPpFAQtyqqKqRL79dLBWVBDo+y6iSMgrEJS7JSquViTusltpaziV/n7d5S1bzeQPgn2MIO3ogEasEg1glCJYl1Tm5svjg46WygYuQz3OJWAWAN46OmySQvF87qVfxj1gl+HKaOXeJOafgo4yIVRCnSCABkEQfws6NFmkAEL4eSPV1lCYQDs74xMUQdgAQCo/LJt/3AAAIGQkkAAnNOaQBjXoBIIw9kOrqKU4gHDyazJNAAoCWJpAsvvABABAyEkgAEpqzBxJDGgBA67iStyeQmAMJAADEEjogAQAQOhJIiFuZ6amy204DJTMjLdqbErO0bLSMMjJSo70pMUvzR5W1KfL1ih7iSqKcfMlIT5NhA7pzLgHwL2X7EHbCEHbEKkEgVgmCZUlaeZkM/PwDyUimB5IvxCoAAo04QQbJy32YepWAiFWCo/VOY4YPMPdj+Cgj6lUQp0ggIW5lZqTL2J0HkUDyW0ZppoyySLL5lJSkCaRUmb2iUJKTCXR80XNo+KBCycpIb9XnFkAi9UBiCDtilcCIVQKzxJL0ijLZ4X8fSCYJJJ+IVQAEvJ4yhJ2X+zD1KoEQqwR/Hx6700DqnwKUEfUqiEckkBC3qmtqZfGva8xvUEatGRM7LaVOhnbbLLV1TPju7/O2Yu1mPm8A/Et29kAigUSsEhhlFJza9ExZM3I3qWH8Jb/nErEKAH89kDQhD+7DoSJWCaGclq+lziBAGRGrIB6RQELcKq+slk9mLZDyiupob0rM0rJpLKOaaG9KzNKBYHLSauXgHVdIXW1VtDcnpj9v3yxYyecNgF8uxxB2FkPYEasEc38hVgnMsqQqN0/mH32GVJCXJVYBEBLnwJ/0QPJyH6ZeJSBileBovdOnsxeacwo+yoh6FcQpEkgAJNGHsLPRHg0AWskxhJ0whB0QHpYjQmEKJABoRQaJwgMAIFQkkAAktCSX9/oZAEAL0AMJiPzYuwCAFl02+boHAEDoSCABSGguxzeKBr5RAEDrrqnOHkjMgQSEB/EJgARx6623mu9nI0aMCN9KnQmkhvCtFgCAREECCXErIy1VRg7pI+npqdHelJilZdNYRo4KPXjQ/FFVXYrMXd1VXC7Kyee5lJYqg/p04fMGwL/k7XMgMYQdsQqxSphYlqRWVkjf2Z9JunPsXXggVgHaRwLJsixZsGBBZDpukpBvhnqVwKhXCY7WO+00uLe5H8NHGVGvgjjFNxDErazMdNl7tx0lOzM92psSs7RsKKPAQ9hV1KTK/5b1lqRkziV/59Loob35vAHwy8UQdh6IVYhVwiWjrFR2/OhNyUrh65svxCoAvGLIcr+IVQKjXiWEctplKHUGAcqIehXEI76BIG7V1NbJ8tUbzG9QRq1JIKUm10v/TsVSV8+55O/ztnZDMZ83AP4xhB2xSoiI54JgWVKXli4bdhghtYy36/dcIlYB0BQ9kLgPtxaxSvDltGLNRuoMApQRsQriEQkkxK2yiip5/7O5UlZeFe1NiVlaNo1lVB3tTYldLpEO6TVy1E6/SF0d5eTv8zZz3q983gD4v6Q6hrCz6kjKE6sERqwSDEsq8wrk+0nnSxnzdxCrAGhxAok5kLzch6lXCYhYJTha7/T+F/PMOQUfZUS9CuIUCSQAkug9kNwsBsUGgFZJccwlV19PYQIAgNhJIPF1DwCAkJFAApDQnAkkRoUBgDD2QCKBBIQHNZ4A0GKupO1ZI4svfAAAhIwEEoCERos0AAgjRwJJGMIOCH/+yGMyDwBAIC5HrRf5eAAAQkcCCXErLTVFhvQvlLQ0x3A58CyjNLuMHBV68KD1MDX1ybLo945iCeeSv89b3x4d+bwB8MvlGMKOHkjEKsEgVglOalWVFP44R9KTSSD5PJeIVQB4DU62/9nAPHJer53Uq/hHrBIcrXca3K+HOafgo4yIVRCnSCAhbuVkZcgBe+5kfoMyas0QdmXVafLR4v6SlJzOqeTnXBq7Uz8+bwCC74HEEHbEKkEgnguCZUnG1mIZ+e8XJTuFr2/+ziViFQBNJTl7IJFA4j7cAsQqIZTT7iOoMwhQRsQqiEd8A0Hcqq2rk7UbiqS2jkm6fZdRPWUURAIpJaleCvPKpL6Bc8nfubSpqMx87gAgqB5IXC+IVYJArBIEy5K61DQp6j1Aaqn8JFYBEBKGsAt0H6ZeJRBileDLad1G6ugClRH1KohHJJAQt7aWV8lbH82RrWWV0d6UmKVl01hGVdHelJjlcrkkN6NGThy9ROprKSdftpZXyoxvlnIuAfDPkUCiBxKxSjCIVYJTmd9RZp99pZTVOydEgse5RKwCIMAQdhbtBZvfh6lXCYhYJTha7/TWJ9+a+zF8lBGxCuIUCSQACc05FzWTqgJAK6+pjiHs6IEEhAkBCgCEZwg7rqcAAISMBBIASfQh7GyW0KoXAFol2dkDiSEvgbBwVng6W74AAAJzft9jGFAAAEJGAglAQnPWwzTwhQIAWndNTXH2QGKcGCA8nAkkyhRA7Lv33nuld+/e0qFDBxk9erRs3bo1JuZA4vseAAChczQTBeJLakqy9OvZxfwGZdSaBFJtfZL8uilPBudyLvn7vPXonCupqZQRAD8cQ9jRA6nx2tmnIFsaliyWqgheP+tLiqUqLz8uT82G2npTRsRz/qXUVEuXpQsktc/4Njoy8YdYBYgNjz76qPz3v/+VmTNnmiTS/PnzJS0tLTaGsKPBYDPUqwRGGQVfTn0LOxPTBSgj6lUQj0ggIW51yM6Uw/fdReqYCdN3GeU0lpFl1bTloYm7Iey2VqfLOwsGyZ93yIj25sT0522vXQaZ3wDgi8sxhB09kETq//WUDHv8USkXMT+RVBXHp+UwEam79GKRSy+K9qbEJksks6RIdn31Sck5bK9ob03MIlYBoq++vl7uuusu+eKLL6RPnz5m2ciRI6O7Ucx56xf1KoFRrxKcDjkZcviE0UE+OzERqyBeMYQd4lZdfb1sLi4zv0EZtaZFWnJSg3TMqpQGxjTw+3krKavk8wbAP2evYO7PsvWDD2Rrl+5S75wbCh60bLSMSt7/kJLxQSd9t8upjukaiVWAIJSVlcktt9wihxxyiHTs2FFcLpc8++yzXp9bXV0t1157rRQWFkpmZqaMGzdOPv744xaV8+rVq6WiokJef/116datmwwZMkSeeuqpmBmynB5IzVGvEhhlFHw5bSmhji5QGVGvgnjEt1nErdKySnn9/Zly4uG7S8f8nGhvTkwq3Vopr733tUw6fKx0zM+O9ubEJP0+kZdRLWeM/Uka6rS1DOXk6/P20axFcvJhBXzeAATXA6m+LuFLqjyrg8w840rZ84m7pVOXAnGlpUekTGrraiU1JTXuytuqqZbNG4tk5oU3yMS3non25sS0io6dTTl1rW2QDtHemBhFrAJst2nTJrn99ttNL6Cdd95ZPvvsM5/Fc/bZZ5uEz5VXXik77LCDSTQddthhMmPGDNlrr9B6Pa5Zs0ZKSkpk6dKlsmLFCvn5559l//33l6FDh8ree+8d9TmQrAay8E1RrxIY9SrBKd1aJdM+mCOTDh0vHfOoo/NaRtSrIE6RQAKQ0DxapPF9AgDCNwdSHT2EnU2duzzysKQUFkasorBz584Sb+pWr5HNp5zR+B8q9XwjQAEQoh49esi6deuke/fu8u2338puu+3m9Xlz5syRadOmyZQpU+Tqq682y84880wZMWKEXHPNNTJr1iz3czWZpPMaeXPjjTfKnXfeaXowqZtvvtn8rcPXTZo0Sd5///3YSCDxfQ8AgJCRQAKQ0DwmVY3mhgBAuxvCjh5IHmPlOG842FYm21txWIwr5JuzxtPZ8gUAfEhPTzfJo0C051FycrKcf/757mUZGRly7rnnyg033CCrVq2S3r17m+VffvllwPUNHjxY0tLSzJB52y9b0b1uOd++gbYtAACEjG+yABKa8+sMLdIAIJxD2FFL49GrxtkEGl5acTiSbfDzISOBBCB85s6da5I+ubm5HsvHjh1rfs+bNy+k9WVnZ8sJJ5wgd911l5lbadGiRfLqq6+aIfGihR5IAAC0Dt9kEbdSkpOkR5d8SXG2doZnGaUkbysjPuq+JLlcUteQJGtLsqXBopx8f96SpVN+NucSAP8Yws7zHlNTI/m//SLJtTXicvS2wTauJFM2poxqaikWXyzLXU4pJJCIVYAw0mHudLi7puxla9euDXmdjz76qHtoVU0c3XHHHX6Hr9uwYYMsXLjQ42fZsmXmsdLyCvfzthSXSfW2e0VVdY0UlZS7H9O/dZnS5+hzbfUpVZKU2fi6uoY62VJSJta2loOlZRVSUVlt/q6ta3ysoaGxQcPW8kopq6hqfF19vXlMfytdro8rfb4+pq9Xuj5dr9L30cdqahsfq6yqlpKtzu323Kfi0u2P6d/OfdLn2nQdui6l627NPml0onUGup6tZY37VK/7VKz71Li/5WafKrfvU7Fzn2qkZGtFGPapwqzLvU/Fzn2qNNvQuE/15rF6e5/KmuxTcZPjFIZ9Kq+olm6dcs134arqWikqdexvaYVZ5j73HOelrqPCY5/K/exTuWOfqprsU3mTfapy7FO5n30qd++TbsfW8sb3U7qd249TePZJj22Xjrmm7sDsU4njOAX5eap3f5587JPj81TR5DjpYx7XCMe5p397XCOanHse++TxeWpynFq5T1o2BbmZ7m1peu5VmGtEuPap2sfnqcKxT42P+dynYj/7ZD5PdY7jVBH+fXJcy4u3lnvs0+am+1SxfZ82O/YJ4cEQdohbuTlZctzB46TOooWz7zLKNGVkWY0XYHhvkVZalS6vzR0qFx6aQRH5OZf2GzvEfO4AwBdXirMHEkPYZZVukd2fe7CxQBjCzss92CVZxY1llNy5Ex8sP+xy6nDQy5QTsQoQNpWVlWa4u6Z0GDv78VDl5+fLG2+8EfTzH3vsMbntttu8PvbZVwtlUP9+5u83Pp4ruw7rI/16dpKlKzfI4uXr5ah9djKP/eez+TK0fzcZ3LerrFizWb776Tc5/sDR5rFNucska3gnKfu2pxRVr5fX3/9FjtlvlCQnJ8ln3yyR/A5ZMmpob9lUVCaff7tUDtt7hGRmpMnMucskLTVFdhvRz1Qif/zVIjlw/I7me9E3C1aYCsw9Rw8yyYb3v1ggE8cMls4FOTJv8Sop3loh++w2ROrrG+TtT+fJ+FEDpLBLvvz0y1pZvb5YDtpjmNm2tz6ZK7vs2Ef6FnaSn3/bIEuXr5fDJzbu03ufz5fB/bvJDn26ysq1m+X7Rb/Jsfs37tNHs36SXt3yZdjAQlm7sVi+mvdrq/Zp710GyNfzf5Ga2nrZc5cBUllVK+9/vlAmjh3UuE+LVktxaaXsM26Hxn2a/qOMH91fCrvmyU/L1snq30vkoL2GNu7Txz/ILsN6S9+eHeXnlRvNPu01unEYxPc+W9C4T327yMo1W+T7n1bJsQfu3LhPXy6WXt3zZNigHrJ2Q4l8NXe5HHPAyMZ9mv2z5OdmyqgdezXu05xlctjE4ZKZkSozv/9V0lKTZbed+jbu08wlcuCe+r01U76ZvzIs+/Tfz3+QMcP6SE1VhSxYskkWL98gR+3TeAz/89lPMrR/Vxnct7OsWFMk3/20Wo4/sPEY/vfLJWafRgzqLms3lMqXc1fIcQeMMI2hP529zCQSRu/YUzYWlcuMOb/IkRN3NPv0xffLzT6N26mPlJRVyYczl8rBew6WvJwMmT3/N7NPe+/S3+zTO58vkn3HDpQuBdkyd9EaKSqtlP3GDZK6+gZ5c/oC2Wt0PynsmisLlv0uK9cWSYfsxs/7Gx/Pl12H9ZJ+PQtk6crw7NOX3y6Tgg7ZUlNVLmt+Xy8zvv1ZjtRzLz1Vvpj3i6SlJMu4Ef2kpKxSPvx6sRy8+1DJy8mU2fp5qquXvUcNlMrqWnnniwWy75gdpEt+jsxdstoktPbbbXDjPs34QfbaWT9PebLgl3WyekOxHDJ+x8Z9+nSe7Dq0t/Qr7CRLf9sgi1esl6MmbLtG/G++DO3XTQb36Sor1m6W7xavkuP3G9W4T18tkl5d82XEwB6ydmOJfPnDr3Lcvjs3HqdvlkpBbpaMHtJLNhaXhWWfOmSmyZffLTL1K3ruvfnJPNlTrxFd82XhssZrxMF7Nh6LN6Zvu+7pNUKveyvWy5HbrhHvfN64Tzv03bZPet07oPEa8eHMxmvE8EGFsnZDscyc96sct3/jNeLTOUsa92nbNWLGN0vliAmN14gvv2+8RozdqXGfPpq1SA7aY0ezT3PmN1739tql8br37v8WyL67NV735i5e1XicwrRPg/s1v5b/98ufpFf3fBmxbZ++nPurHHfAqG2fp237tGNv2aj7NGepHDlxhPTp3TPoexH8c1l2ug5hoa1ldMLJBQsWyPDhw1u1rt/Xb5ROnbtwZHzQVjR1tTWSkp4syRGslInXiamVZtzrqutFvxNEsowibdOmzdI5QhVLj79XLQ/9u0oyU2vljH1z5KpjcyLyPvFOzyUNAgsLu8f1uRRpSfQwQILHKg2VlbJ618YvY66MDOn9/Q+SyH7ba7xU1dRJWkWZ9Jn5hSQXFETkfeI1VqnfvFl+23ui1GTlSEZGmgz4cobEq0jGKmtOPk0q5y8w5dTvn09I1qjGL9LwRKwSHGKVxPPtt9/KbrvtJlOnTpWzzz7b4zGNB7p16yaffPKJx/KffvrJxAhPPPGEXHDBBRHdPu2BtHHjRo9l2gPpmGOOkVmz58j4sbuZZdoSPTsrXdLTUk0Lda08L8jLdvdA0or3jPQ002pdW6J3zG/8XvfGI6vlx7dTpaEyVfY6O0VGHZ8kBbnZZm4mbbWuPQKyMtNNq/Wt5VUm+ZKUlGRa2utzcrIyTAt8TU5oUkKfry3xtSqtQ3amqZfQhFGH7AxJTUkxvX/0+drwTp+jLep1HVopq72GtAI2r4O93WXmve190l4f+bnZ7t46Genb90nXW5CX4+6BpOvLzEg369Ptaek+5WSlm8mhqutrxSUu6ZCTaa6nJaUV5u/UlGTTu0ArhXX/zT6VlEtOtr1PNdv2KcvnPtXVVJo4xf8+VWzbp7TGfSqvMse3cZ8qTcV3ttmnetOrKC83y3wv1b+1QYp7n7ZWSm4Hx3FqsFq9T5uKtkpaUorkdkiR2tp6kxDQymqzv6UVJpmg+2XOvcoa6bjtvNR9Sk1NkSz3Pun+ZvnYpyrJy83ctk9VpqHr9n2qktwOGY59EumQk7FtnyrN3973qUJystPNPmkPm/XrN0n/voWNn6eScsnOTNt2nGrDsk96rtfVuKRjXo40NFjmfNMyTA7h82T2yXyefBwnx+dJ96nWcZy0Z4uWp/saYfZp22ettHzbPm27RlRWm+30uk8en6cmx6mV+6T34F9WrpbOXTqb92h67mkPGz3HwrNPyZJlXyM8Pk8VZu67xn2q23bu+dinpp8n5z6Zz1Pjda/xODmue63cJ72GNL2Waw8kXZ+9T3pt6+jcp6Rkc4/QfSotq5L8bfuE8KAHEuKWBmmvvz9TTjx8d/cFBZ70gv7ae1/LpMPHSsf8xgsyPGmX/fzMKjlj7E9S1aAVMpxL3mgAoi1MTj4sl88bAJ9cjiHsrG1DTySy8txO8sUZl8meT9zN3DXeJCVJeaeuMvPCG2Tvlx5u8+MTNyzLXU7H1tQLfYG9I1YBQqdD1a1Zs8br0HaqsLCxsjmSunbtan68yc3efsVzfufXClP9sdmJJKWVkvpjS7MypKGysRLR1ZAiHfO2r9M5uoJWgtqVr0orSW1aeep8TCtXbZqYcT6mFZ82rdh0PqYJH/3Zvt2+98lOJHnbJzsBZfYv1XO7Q90nrcxtWq+ila7O8s5uuk+OxzThoz/+9mnTpsog9inLc58c76GV8tv3KdnjMU0IeexTvvfj1Jp90mHvX3l3prteRRMr7v3dlnQJbp9S/OzT9rLRSnnPfcr2s0/ZfvZp+2OaHLF7Hyk7IaQak3qt3ydNbL324WyZdOh4c2615PNk9snxWLN9cn7W9Bg5jpPzsWbXiFDOPY/PU5Pj1Mp90s/b9NlL5OTDOnk99zQ5Io6BccK2T/l+rhH5fvYpDJ+ncO1TfpPrXic/++R8DOER06k4nXTx2muvNUFLZmamjBs3Tj7++OOAr1uyZIlcddVVsscee5iu13ryrlixwufz//Of/8guu+xintunTx+55ZZbpG7bOI4A2jdngwTnXOcAgBZwDGEnDGEnln6T3sZFC7jmnPP5MCiCbx5lw1xaAMJn1KhRsnTpUiktLfVYPnv2bPfjbenWW2819TfaMypctCeHjSkxAABoZwkk7V59//33y2mnnSYPPvig6WKnkzB++eWXfl/31VdfyUMPPSRbt26VHXdsHAvTlw8++MB0jdZxeh9++GHz95133imXXXZZmPcGQCxiLmoACOM1VZMk9oXVssRK9JoaRwKJOZCa80iq0YojSCSQAITPCSecYIYdevLJJz0a8upwd9qAt3fvxrlr2jKBpMMf6TC7kUggOW/LAAAgzoewmzNnjkybNk2mTJkiV199tVl25plnmpYo11xzjcyaNcvna4866igpLi6WDh06yH333Sfz5s3z+Vxd98iRI+Wjjz6SlG2tZnNzc+Xuu++WK664QoYObZw0D0D7RONnAAgzjadqaxv/1h7daduHJUg4zqQILRaacySQnL210AS9swC0wCOPPGLqRdauXWv+/84778jq1avN39pgNi8vzySJTjzxRLn++uvNXESDBg2S5557zozg8swzz7SLcuf7HgAA7bQH0uuvv256HJ1//vnuZTrE3Lnnnmt6GK1atcrnazt27GiSR4HoxJD6o+9hJ4/UxRdfbFq96DYgdiUnucxYxzqhHXyUUXLStjKitaovSS6Resslm8szaPzs9/OWJLnZGXzeAATkcsRUVn1iz4OUVFcrORvXSZIm0kggeeEyZeMuI3il30vsctL4F94RqwCetDHt5MmT5fHHHzf/f/PNN83/9aeoqMj9vOeff16uvPJKeeGFF+Tyyy+X2tpaeffdd2XChAntL4GU2GGJV9SrBFFG1KsEdy4lu8wcNno/hq/PG/UqiE8x2wNp7ty5MnjwYNMbyGns2LHmt/Yqam13an0PNWbMGI/lOudSr1693I/7oi10Nm7c6LFs2bJlrdomBE8njjz1yL2kjijQTxllmTKyrBpOLR+0HqakMkNe/Ga4nLnf9on/0PxcOnjPYR6TMQKAV8nJ2/9O8ARS1paNstcTf238D1+mm0tySXbRJlNGrsztk/aiObuc8vZ9jeLxgVgF8ORvHmgnbairI7/oT7TpEHa33XZbWNfpSvZMyMMT9SqBUa8SfDmdctgefMQClBH1KohHMZtAWrdunfTo0aPZcnuZ3Q27te/hXGfT9wn0Ho899pjP4GbLli3NkkuhKikpadXr27vG4M8SSbLMRJuREs/HwZRRg0uSk+ojWkaRVlLiOalrOFVUaOuYJElOsqSyslI2baqM2HvFMz2XtpSWmN/xfC5FWriKpkuXLuFZERAFruQUvTsbVt22oewSlI7K1pCSanqPeMz3g0ZJSWKJSxpSUiSZOZD8nEiWu5yo/PRXTJbU1zcQqwBxTBNI+rNw4UIzfUHYeyAxWqrXa2ddXYNYEa5Xifsyqq+XJMooYDnV19WbHlucS37KiFgFcShmE0hakZuenu61dYz9eDjeQ/l6n9JS/5XWOtSdjhfctAfSMcccY4bRa20FYH2DSKfOVCL6sqWkTF5/f6acePju0jE/RyKpc+fOEo+2FJfJa+99LZMOHysd87MlnnXu3Cki683JqZaOWcVyxtifpFhGSWc+cz4/b598M09OPmyPiH/e4lkSQwsBIimOpr51id0DqaxTF5l5/rWy5xN3M4SdF5pUK+vSTWZeeIPs+fS9bX+A4ohdTsfV1Ev3aG9MjCoqLZc3PyFWAeCJBFLga2db1avEq6KS8nZTrxJJRSUVMu29OTLp0PHSMY9zyWsZEasgTsVsAikzM1Oqq6ubLa+qqnI/Ho73UL7eJ9B7dO3a1fwAiF9Jjm8UNH4GgNZzOYawS/Q5kKTB0dSZHkjNMbN56GgcDgChXTYdHYAZwQ4AgNDF7FgaOoScPcSck71M5ykKx3s419n0fcLxHgBiG3VXABBmyY72SXV1CVu87qF2bSSQmnOWCa04/J1MYT03ASBhE0gMYQcAQPtJII0aNUqWLl3abBi52bNnux8Px3uob7/91mO5zn20evXqsLwHgNhGAgkAwnxddQxhl9A9kJpU+jMWfIAEErV6wZ1LzE8BoB3T+Y/0fhmu+Y+aXjadHYMBAECcJ5BOOOEEqa+vlyeffNK9TIeamzp1qowbN0569+5tlv3222+yePHiFr3H8OHDZejQoeY99L1sjz/+uAladBsQ20OPZWWmM+eIvzJKaiwjF/Oy+DmPtNGzS8qqU81veKfXxIz0VM4lAIE5hrCT+rqErvR3NTRI+tYScdGBxOe9xV1GDQ3bem3Ba1nZ5cQYdj4RqwDtI4Gk94IFCxZEqAcS95mmqFcJjHqVYD9rLsnKSKPRlL8yol4FcSpm50DSJNGJJ54o119/vWzYsEEGDRokzz33nKxYsUKeeeYZ9/POPPNM+fzzzz2+cJaUlMjDDz9s/p45c6b5/cgjj0h+fr75ufTSS93PnTJlihx11FFy0EEHyaRJk0ygos8977zzZMcdd2zTfUZo8nOz5Q/H7yN1VgK3bg6yjCyrJtqbEtMJpOLKDHnmq5Fywp7p0d6cmFWQmy1HTtzJ/AYQWdqQ5amnnpL58+fLjTfeaCpTbPvss498/fXXkpLSGMLtvffe8sEHH8TUIXE5hrCz6hL4Ht3QIDmbN8i+/5gssu14obmcok2NZbStzDwSkGhkWe5zKf/1NykVH4hVAHjDiBP+Ua8SGPUqwSnIzZKzj5nIhchvGVGvgvgU099mn3/+eZk8ebK88MILUlRUJCNHjpR3331XJkyY4Pd1+lx9ndPf//5387tv374eCaQjjjhC3nzzTbntttvksssuky5dusgNN9wgN998c4T2CkCsfqH499fV8tFckm1ey0lExgwUefBiS1KS6akFRJLO0ahJo5dfftnr408//bScfvrpsXsQHEPYCUPYNWLYMf/D2NljCpFA8o4h7ACgxZgDCQCAdpxAysjIMD2E9MeXzz77rNmyfv36hTQExjHHHGN+EF+KSsrkzQ+/kuMPHSsFeTnR3pyYLaM3PpgjJx46Rjrm0XPEm6x0l3TMqpRTdl0kr3y3o2ypyGzz4xQPtIyG5i+SGXPHyIFjCqK9OUC7Zsck77//vsQlRw+kRB7CzmpokLLO3WXWeVfLHs8/GO3NiVmmjM6+UvZ4+r5m80ahkX6vsc+lY6rqpDsF49UWjXunz5UTDx0vHfluAGAbEkj+Ua8SGPUqwdlSUi6vffCtnHjQOO7DPsuIWAXxKWbnQAIC0SqG+nodL5+y8llGVmMZmcKCVxNHpsiA7kmSkkwhBaJltLWSckJiKCsrk1tuuUUOOeQQ6dixoxmv+tlnn/X6XJ2j8dprr5XCwkLJzMw0w/B+/PHHEdu2q666yvSYPvDAA+XHH3+UWONyDEGW6EPY6dR6DalpIkkMy+ZTUpIpIy0rTbrBO/tcojNboI+dRdwLxDHtga0x14gRI8K2Toaw8496lcCoVwmSXf8Ev4hVEI9iugcSAERaToZLHrowU159X2TaNR0kvwO92Zq65eUKmb2o0vxNPIhEsWnTJrn99tulT58+svPOO3vt8Ww7++yz5fXXX5crr7xSdthhB5NoOuyww2TGjBmy1157hXW77r33Xhk2bJgkJyeb+R4PPfRQWbx4sXTo0EFicwi7xO2BJJbjCzQjf/ofws5GAgkAJNETSPqzcOHCsCWRnD2QGhK4XQsAAC1FAglAwtNWbqpDZpLkZdMxs6mM1CatZYAEmYdo3bp10r17d/n2229lt9128/q8OXPmyLRp08xwu1dffbVZduaZZ5pKj2uuuUZmzZrlfq4mk2bOnOl1PTfeeKPceeedAbdr7Nix7r91/f/617/k66+/Nr2RYoXLMYSdlchzIDmvl84kCTw5k2vcY4KYA4kTCABC4Urafg0NZaoDAADQiAQS4pZ+f05OTmIoD39l5GosIyobAp9MppzglV3vWVfvom4PCSM9Pd0kjwLRnkfaG+j888/3mMPx3HPPlRtuuEFWrVolvXv3Nsu//PLLsG9nUlJS7FWGOIawkwQfws5liSTV1rgbKsALV1JjGVlNem3Bs5i2nUsEvv4lJbmIewF4Xj8dt2BuM15uw9SrBES9SpCoVwkKsQriEQkkxK2CvBy58JQDpc5K4MqpIMvIsmqivSkxrWNetlxw4v7R3oyYlZzkki0VmfLoF7vIradlR3tzgJgyd+5cGTx4sOTm5nrtKTRv3jx3AilYdXV15qe+vt78rqqqktTUVNm6dat88803MmHCBJOQePTRR2XLli1mziVfNmzYIBs3bvRYtmzZMokkV4qzB1LiDmFnWQ2Ss+l3OehvV0tSXl60Nydm5RZvMmWkmAPJB8tyn0sF//5PWx6euNIxL0eOP2A0E3cD8EACyT/qVQKjXiXY+zD1KoHLiFgF8YkEEgAg+OkpYqyjAxBtOsydDnfXlL1s7dq1Ia9Th7K77bbb3P+/6667ZOrUqXL44YfL9ddfL0uWLDEJpVGjRsn7778veX6SE4899pjHupw0+dQ0uRSqkpKSZstqHcPWlRZtkYpNrXuPeGUVF7n/bnA1zqsVKd6OQ7xw9jnavGmzJNXGZ9KxpKQ0Yuuur9teJkXFxZIcwXMp3pVsjdxxaC/C1SGyS5cu4VkREGHOOZDogQQAQOhIICFuFZeWy7uffiNHHrCL5OfSK8JXGb0z/Xs5+oBRUpCb1ebHKF4UlVbIvz+eK0fvN0YKOJeaSXaJ5GdWyfGjlkptzUgdoCsahwmISZWVlWa4u6Z0GDv78ZZOIO2NzscUiosvvlhOPPHEZj2QjjnmGOnYsWOrKwDrG0Q6dfZcx8asLLH3ukNWtmQ1eTxR1ItLNnTqKt+ccZmMe+cF6du5c0Tfr3OE1x8pGzt1ldnn/EV2e+Fh6VuQL8kdO0q86ty5U0TWW5mcLKXbzqUjM3Li9lhHWlFpufxv3gI55sCxxHOBhs4BYpTGP74avoQlgURjuGaoVwmMepXgUK8STBmVyzufzydWQdwhgYS41WBZUlFZLQ10ifBdRg2NZWRRRn5p+VRU1cTePCIx1AMpyWVJTnotnzegiczMTKmurm5WLjrsnP14NHXt2tX8tCnHEHbi6I2UcKwGsZKSpLpDnue8UPAspuQUU0ZaVgxh5+tcstznEpGKn4+cZUlVdS1xLxDH7EY0CxculBEjRoRnpY6caQNT7TVDvUpg1KsEh3qVIMqIWAVxilnjAQB+JSd59jYA4DlUnQ5j15S9rLCwMOGKy+VIllgJnEDyaLwRrjGj2iGXszcEDV6888gacS4BQEuH46ZhJQAAoSOBBADwf6NwVO4xbjjgSechWrp0qZSWes67MXv2bPfjCcfZ28Yxd0vCcTZzdtZewROzm4eG/BEAhHbZdFw3GXACAIDQ8W0WABB8DyTKCvBwwgknSH19vTz55JPuZTqk3dSpU2XcuHHSu3fvhCsxl2MIu0TugeSRQKIHkm/O5Bo9kLyjxhMAWs7ZAymBwxIAAFqKOZAQtwpys+WCSQeIlcRo8D7LKK+xjJKSErgFeBAK8rLk/BP2k2RnpgRuyS6RLRUZ8sj/RsulR0R3PhegLT3yyCNSXFwsa9euNf9/5513ZPXq1ebvyy67TPLy8kyS6MQTT5Trr79eNmzYIIMGDZLnnntOVqxYIc8880xiHjB6IDWyGiRn43o58K9/ltRubTwPVRzJKdlsyiipro45kHywxHKfS/lvv922ByjOvhsct/8oE/8CgNch7Kg68HrtpF4lwP2FepXg7sPUqwQuI2IVxCkSSIhbLpdLUpKTpY5mRP7LKCVZLMoo8LmUwgTn/r90uaS+wSX1FmPnIHHcd999snLlSvf/33zzTfOjTj/9dJNAUs8//7xMnjxZXnjhBSkqKpKRI0fKu+++KxMmTJBE5DEHUgIPYafzLLjEkuS6WkliCDufXK4kU0bbCq3Njk+84VwKooxcLtMYSH8DwPZrw/ay4Dbj/dpJvUrg+wv1KsHdh6lXIVZB+0Rze8Stkq3l8vI7X0rJ1opob0rM0rKhjIIrp1fen8W55ENykkvyMqvk9N0WSkNdZXhPUiCGaS8iy7K8/vTr18/9vIyMDJkyZYqsW7dOqqqqZM6cOXLwwQdLwnIMYScJPoRdeUFn+fLC66U8Nz/aWxOzKnILGsuooDNNw32xLPe5VFJZ06bHJ97iuQ9n/kQ8B8SxW2+91VRCjxgxInwrdY6USjuFZqhXCYx6leBQrxJcGRGrIB6RQELcqm+wpKikXOrriQJ9llF9w7Yyoq++33Op3pKi0nKp5xuFV9pwPtllSafsKmmgjACE0gOpPnF7IGkz54aUFCnr0kMaklOjvTUxqyF1Wxlp4pE5kLyzLPe5REjnm8ZxpeVVfDcA4jyBpA11FixYEKEh7Phe3BT1KoFRrxIc6lWCKCNiFcQpEkgAAL+cU0NRtwcgoGRHD6S6RO6B5KikYgg7P7bfZCwaKQTG8GwAEBqGsAMAoFVIIAEA/N8oHF+6qNsDEIjLMaeclcBD2DmTIS4i7iCbhtOr3PvJRIt5AGgp5kACAKB1+DoLAAi6BxJD5wAIyDGEnST4EHZuZJB88igaurn6OJecBeZo1QEACIh2CgAAtA4JJMSt/A5ZcvZxEyUvNyvamxKztGwayygz2psS07R8zjp6b8nrwLnkTVKSS4orM+TpWTtJXUNGmx8fAPE7hJ2V4EPYZW/eIPs8cJNkl5VGe2tilpaNKaPNG+jm6q+ctp1L+ZnpbXdw4ozGcUdMGMF3AwAeXLRr8Yt6lSDuL9SrBHcfpl4lcBkRqyBOOQapB+JLUlKSZGdlSJ2VwJVTASQnJUl6VqpYVk20NyXmyyk7My3amxHTPZAaLJeU16RJvUXLZwDBD2GX0D2QGhokqaFBMspKJcnVI9pbE9Ot2bSMlMUQdt5Z1vZzyTmuLJrFc5kZaeY3ANhSHe3faisZErTZfZh6lYCoVwkO9SrBlRGxCuIR0TXiVmlZhbz54WwpLauM9qbELC0byijIcpr+DeeSD1pXlZtRLSeOXixiVYX3JAXQrnsgSQLPgaRD2FXkd5Svz7pCKnLyor01MasiJ7exjPI7MoSdT5b7XCqtrm3LwxN38dync5aY7wgA4C2BVEMCycu1k3qVYO4v1KsEdx+mXoVYBe0TCSTErbr6Blm3sVjqEnl4nAC0bBrLiEmp/ZdTg/y+qVjqErmiM0APpJSkBinMK/eYFB4AvHE55kBK5CHs9HpZn5omxX0GSn0KvVx9cZdRahpD2Pk6lyzLXU513Id90jhuc3E5cS8AD6mO0dxJIHm7dlKvEgj1KsGhXiWIMiJWQZwigQQACJhAslFvBSAghrDbdsF0DJPDkFq+uZw3GYYWCsQlDGEHAKEwbTi2XTrrakQa6rnXAAAQChJIAAD/NwrHfAvU7QEIxOUYws5K5J6dzvl8iLh9cyTXmAPJ17lEZSeAxHDrrbeKy+WSESNGhG2dLpdImnMeJEbkBgAgJHydBQCE0AOJSiwAAaQ45kCqq0vc4nJ02XQRcgf3bYRuroETSFoTCgDtOIGkw3YuWLAgrOtNy9x+7WQYOwAAQkMCCXErNydTJh2xp+R2cAxqDM8y6mCXkaPJFZqfSx0yZNKh4805hea0A1JJVbq8MGeYVDdwLgHwz+UYwi6ReyBZDZZkbdkkez5xt2RXlUd7c2JWTkW5KSMtK7q5+mafS7mZ6W14dOKLxnEH7bEj3w0ANEMCyf+1k3qVAPcX6lWCuw9TrxK4jIhVEKdIICFupSQnS6f8HPMblFFrz6WOeZxL/nog1TckyZaKTPMbAPxyDGEnCT6EXXJ9nXTY+Lski2M4O3hIFquxjOrrPIf9g+NcEve5lOLsFoxm8VxeTibfDQA0k5bl6IFUwYgKTa+d1Kv4RxkFh3qV4MqIWAXxyPENH4gvW8sr5avvFskeYwZLB3qOeC+jskqZ9e1S2XvMIOmQQ88Rn+dSWZX875ufZcKuQ6VDNr2QvM2B1CG9WvbZYZXUWwNFpEM4P8oA2hmXo2GHleBD2FXmFchPh5woo9YujfbWxKyKrByZd/L5Muy/r4nFEHbeWZb7XCqorpWCNj5G8fTd4Mvvl8n+e2YTzwHwkOoYwu6V67ZKx140QrVZ6dXiGrpcBhVonUFkvguXbXVJToeauD0rq+urZE3dL3LQfjtIXi71Bb5QrxIYsQriFQkkxK3aunpZsWaj7DZKK7Thr4x2H9WfAgpwLq1cu0lqd07glvJ+aGPn1OQGGdC5RH4uSeDKYAChz4GUyD2QGiypS0uXjYNHSN3GFdHemphVl5rWWEaf/och7PyV07ZzqbaelvP+4rl1m0qltjaBrzsAAg5hV7bZkrLNfKexpRTUSOddi+R/z1dKXVGkTiCNDSvj9uxMKaiUzpM2y/9e7i1HXkgCyRfqVQIjVkG8YgwEAID/G4Vjvm6qZACE1AMpgRNIlmM4NpfzQgpPLsfXEYaw83U2cdYAQCt0G0CPI7Tebz8mblwLILHRAwkA4JdzugXq9gAE5JybsLY2cQvMORybiwSSL87kGkPY+WBZInYxcSoBQMh2OihNZr1S5f5/fvckOeqGbEpSRNatFpm/VWTIXimSUpsakTKpqq6WjPT0uCzvmipLfv5h29+VNOgAkJhIIAEA/EpyJJDqmd8cQAAuxxB2idwDyTOBRKd/n5zJtQYqZgAA4ddtYIpMODtD/vdsYxJp/KQM6TcqMsmSeJPbP03mvy+y3wUZ0jE/KyLvsWlThXTuHJl1R1pFcYM8cMZW83dN/I7CBwCtQgIJcatDdoYce9DYiE302B5o2TSWUUa0NyWmafkcu/8YJlz2ITnJJaVVafLa3CHSvzA+W44BiFIPpEROIFmWZBZvkXHP/kOyBvaJ9tbErKzqSlNGWlZ0c/VzLpU0nksd9nmmbQ9QHOmQnSn77jaYuBeAV/uckyU7H5Iuyakuye1Cw47t107qVfxJz3ZJ/dY02fzWUKkvShPLssRFz3Lv92HqVYhV0G5x10TcSk1JkcKuBZKawnjGvssomTIK6lxKlh5dOJf8DWFX15Asa0typLae2wYA/1zJjh5IdYk7SbUOx5ZSWyMFq36VVB2CDF6lSIMpIy0rj15b2H4uWbL9XHL08EPzeK5zQQ5lBMCngsJkkkfNrp3Uq/ijCcfkpGSp/b2DNFQnS+32kRDh5T5MvYp/xCqIV9QEIm6VVVTJ9JnzzW9QRq0+l75ewLnkg05PkZNeIwcNXS4prmo+bgD8S3VUcGtSIFE1NEhVh3z58ejTpTIjPodtaQtV6dmmjLSsLIaw811O286l8uoEnlcsiHhuzvwVxHMAEOK1k3oV/zI610refr9KUnaNVJfTKMjvuUS9SotjlYZ6y/RwC5Y+PxShPD+WtgWxgSZsiFs1tXWyZPlaGTmsjwj1Mt7LqKaxjEYP60UZ+TuXaupl6Yp1ssuO/SJ0tsZ/D6S05HrZsfsW+XZdz2hvDoAYl9Shg/vvhpJSSViWSG1GhqwdOVZ2nPtJtLcmZtWmpZky6j9rOkPY+WJZ7nOppi6Bh4UM4rvBynVbTPzLdwMACP7aSb2Kf+m59ZI6ZLOUz+0h1RUi2yNdeJxL1KsEVL611sQq86ZXSGaSy4zerCMilhc3yOzXq6VsiyW7n5guXQckS0O9SGra9jZ5Oje1Tquqy39fVi/fvNXYuPfQKzIlNcNlvnuY+atdjZ36G+pEklIal/3wYY0s/75OOnR2ycSzMs1yHTSirmb76OP6HilpOteXJV+/Vi1Faxtk+H6pMmDXxvni7EEm6uu2T++q21K8rkHmvFll5gjb748Z0qFTknmOve11tdumPN027emv39TKgk8bG0Qd8ecs9zbqupKSG9e9w7g0sx7EDhJIAAC/TBCyDY3DAQSSVFDg/ru+uDhxC0y/EXq7kMKTcx4BhrDzcS45Wmky7wKAduzWW2+V2267LdqbAXhIzdoeq7z9tyrJyHHELnGkpiZF0tIqI7b+pNxqkf4i/763QpZ/WWeSEZqgMI8lNyYIvL7O8ZjzNb7+1kSGJijssKhpmGT/3/m8YNbbFtuYUlApnSeJzHi6SuqKvJ9HmrwJxQcPBn9Mt26y5N2/VwT9/IWf1pqfYH36VGgjRPnalvTsSjn44kzZ7Rjmc48VJJAAAH4l6xh22zSQQQIQQHL+9gRSQ0lx4k427EiGJODeB895bjCaRWjlBQDtMIGkPwsXLpQRI0ZEe3MAIz1LxK7S/+3HeJ6vUbuaRK4nc0pBvXTuL7JqYeN72MkU5Ssx0/Qx52t8/W0nZlTTUdac/3c+L5j1ttU2IjAdKvK3+XWy2zGUVqygOSQAIPgeSPEcLwNoE660NHFlbhtbtq5OrPLyhCx5y3nBdCTi4cmZXPQoMzhOJmoeAACIlgFjaHsPtKXkVJFDL2eukljCVRBxKycrQw7bZ7TkZNOl0WcZZdtllN6mxybeaPkctvcoc06huWSXyNbqNPnP/IFSbaXK859Ertt7vEtyuWTHPimy2+DGcYKBRJWUny/1lY1DEmx97llJys2VRFOz6CfJLCmSXaY9KZmD+0Z7c2JWZm1VYxmVFEnFZ59L/foNEo+qy8ulJDs7Iuu2qqsls7KxnHIOeDwi79EeaBy356gBfDcAgBCvndSr+Lf70bmS/8NISbsmW1J0wpY4VVq6VXJzIzOD00vXVkl9WZoUvb+D+Q3v7DLa+6Rc2ef0HIrJi9pqS7asapCsPPq8xJL4vfIh4aWlpkj/Xl2lzmIy4UBlZFmOvrTwWk79enahZPz0QKqtT5blm/PN/+9+NfgxcxPR2QdkkEBCwjMJpHVrTTmUPPpwQgfaXX9eIKk79In2psSsVLFMGamyt/5tfuJVaCPWt+xcSkvh65u/eK6wa775DQAIDvUqwZXRLrv1iPt6lU2bGqRz58jcI/c7L00+fbpGqlc21hnAO6s22ZRR3+E08vYlNd0lPQYTy8Ua0nmIWxWV1fLFN4ukvDKSX9fjm5YNZRRkOX2/mHPJh16dk6Vzh1qZMGiVZKUFP4EigMSVvtNO0d6EmFCVkyuLDjpO6ofuGO1NiVlaNlpGWlbwTctn8bFnSKXO0Ayf8dzcxauI5wAgBNSrBEa9SmDjjk+VpKwa6bDnSvMb3mnZ9J20UroMoSE84gspPcStqppa+XHJbzJkUKFkZ5K996a6urGMhg3qThn5UV1dJ/OXrpLhA3tRTl7kZLjkvrMzZO78DdK/d0+pdzHUny86k8euOzB8HZB35Z8kpXdvqft9fUIXRn1qhqzsvZOMOWB0tDclZqUcfayszJknQ3sWSG5t/A6RWlVVJRkZEbw/5uTJii47yu71zBPlS3VNrSz7baPsOqKWeA4AgkS9SmDUqwSW2cEll7ySJq/9d4OMH99b9jwiz2OeSzTaUlIm0z7YIDU1g0SY4gdxhAQSACCgIb2SZe58kQsOzZSO+ZGZ46E9SEoiSAZUcn6+5J77RwqjpEzk/ZmSlE5DF5/XzW1Jl4IL/hjX95dNmzZL586dIrb+pOJykffmRGz9AAAArZGskyeLyLAJaSSPgHaGIewAAAAAAAAAAADggQQSAAAAAAAAAAAAPJBAQtzSeY/232OEZGcxLIzPMsqyy4gJl/2eS1lpst+44YyXH+DzttuIvnzeAIBYJayIVYItJ2KVgGVErAIAod+HqVcJ4h5MvUpQ5xKxSlCfN+pVEI+YAwlxKz0tVYYO6Cl1Vn20NyXmy8iyaqK9KbFfTv0Lo70ZMV9G/Qo7md8AgOCvncQqwZURsUoQ5USsErCMiFUAIDTEKsGXEbFKEOVErBKwjIhVEI/ogYS4VVlVLXN+WCaVVSRHfJdRjSmjCsrILy2fOfN/oZwClNHCZWuloqq6xZ9ZAEg0xCrBlBGxSjCIVYIrI2IVAAgNsUowZUSsEgxileDKiFgF8YgEEuJWZXWtfDP/FxJI/sqoqsaUUVVVbdsdmDik5fPtwl+lqppkpM8yqq6Rn379nXMJAEJArBJEGRGrBIVYJYgyIlYBgJARqwRRRsQqQSFWCaKMiFUQp0ggAQAAAAAAAAAAwAMJJAAAAAAAALRaTk6Ox09SUpL8/e9/p2QBAIhTMZ1Aqq6ulmuvvVYKCwslMzNTxo0bJx9//HFQr12zZo2cdNJJkp+fL7m5uXL00UfLr7/+2ux5LpfL68/f/va3COwRAAAAAABA+1RWVub+Wbp0qUkgHXfccdHeLAAA0EIpEsPOPvtsef311+XKK6+UHXbYQZ599lk57LDDZMaMGbLXXnv5fJ0GKvvuu6+UlJTIDTfcIKmpqfLAAw/IxIkTZd68edKpUyeP5x944IFy5plneiwbPXp0xPYL4ZGVkSZ7jRkqWZlpFKmvMsqkjII6lzLTZM/RQ8w5Bd+ft1FDevF5AwBilbAiVgm+nIhVApQRsQoQc15++WUZP3689O/fP9qbAh+oVwmMWCU4xCpBlBGxCuJUzCaQ5syZI9OmTZMpU6bI1VdfbZZpkmfEiBFyzTXXyKxZs3y+9rHHHpOff/7ZrGO33XYzyw499FDzWu06fffdd3s8f/DgwXL66adHeI8QbhnpabLz0L5SZ9VTuAHKyLJqKCO/51Kq7DykD2UU4PO2Q9+u5jcAgFglXIhVgi0nYpVgziViFWB7o1qtS5k9e7apFykqKpKpU6eaRrreRn65+eab5YUXXjDPGzlypNx5552moW1r6TovvfRSDksMo14l+DKiXiVQORGrBHMuEasgHsXsEHba8yg5OVnOP/9897KMjAw599xz5auvvpJVq1b5fa0mjuzkkRo6dKjsv//+8n//939eX1NZWSlVVVVh3gtEUlV1jfyweKX5jUBlVEsR+T2XauWHJb9xLgX4vP28cgNlBADEKmFFrBJsORGrBHMuEasAjTZt2iS33367LFq0SHbeeWe/xaJJpfvvv19OO+00efDBB009jI788uWXX7aqOH/88UczhN2JJ57IYYlh1KuEUkbUq/gvJ2KVYM4lYhXEo5hNIM2dO9f0DNL5i5zGjh1rfutQdN40NDSYQGXMmDHNHtPX/vLLL7J161aP5To0XnZ2tplnadiwYaabNWJfRVWNfPntYqmoJIHks4wqKaOgzqXKGpk5d4k5p+D78zZvyWo+bwBArBJWxCrBlxOxSoAyIlYB3Hr06CHr1q2TlStXmp5IgUZ++etf/2qepw14P/30U+nbt68Z+cVJpxHwNYf0TTfd5LX30ZFHHmnmpUbsol4liDKiXiW4c4lYJajPG/UqiEcxO4SdBjsa9DRlL1u7dq3X123ZssV0wQ702iFDhpi/99hjDznppJPMmLy6/NFHHzUtb3T+pIsuusjvNm7YsEE2btzosWzZsmUh7CUAAAAAAED4pKenS/fu3Vs18ovOJ60jv/Tu3dssD6VHkjbs1Ya5TzzxRAv3AAAAxIqYTSDpkHIa9DSlwYz9uK/XqWBfO3PmTI/nnHPOObLrrruaYEm7cmuvJH9zLd12220+E1lNk0uh0iQWfCstazyOxcVF0lAXueEH4/k42GVUVFwc0TKKtJKS0siuv6yxbHTM74ba+C2nSCpxn0uR/bzFO5crPOvp0qVLeFYEAAAAtGLkFzuBFIpPPvlEamtrzVzUAAAgvsVsAkkTN9qTqCl7niJfiR17eUteq9LS0swkjxdeeKF89913ppu2LxdffHGz8Xx/+ukn06NJE0jaQ6k1Nm3aIpVVzfcDjUrKKmTd6hXy+7o8qczNilixFBcVxe38WCWljWW0fl0HqYpgGUVaUVGxVFV5TxqHtZzW50tVefyWU1t83tb/XiBVHSgjX5KSwpNB0vvHwIED3Q0fgHCyY6Rw9JrWWCWvoHXxTiJcOxcvypO8CMcq6wsKJB7Z9+DFizpEtIzaIlYpKMiPfDktzpe8nPgtpzb5vC0ukDxilYjHKopYJf61dOSXQHT4ukmTJklKSuAqJ28ju2i9iiJWaR+xSjzHKYpYJcRyIlbxXUbEKkEhVok9MZtA0oBlzZo1XgMcVVhY6PV1HTt2NL2P7OeF8lqb3cJGk0D+dO3a1fw42QHOMccc4/e1CJ+7KEzKiHOpzfB5azsLFiyQ4cOHt+E7IlHocDSKWKXtcO2kjDiX+Ly1R8Qq8a+lI78E8vzzzwf9XH8juxCrtB1iFcqIc4nPW3tErNLOE0ijRo2SGTNmSGlpqUd36tmzZ7sf9yYpKUl22mkn+fbbb5s9pq8dMGCAdOjQwe97//rrry0eQmjixIny9ttvmySUt0AsWJqI0mBJ1zVo0KAWrwetw3GIPo5BbOA4tD1t1QtEArFK+8L1Ofo4BrGB49D2iFXiX0tHfgknbyO7aD3Q0qVLTd0O9SrxjWtzbOA4xAaOQ9sjVmnnCaQTTjhB7rvvPnnyySfl6quvNss0sJk6daqMGzfO3Uvot99+k4qKChk6dKjHa6+77jqTRBozZoxZtmTJEvn000/d61LaTbppkmjr1q3yj3/8Qzp37mzmQgpVfn6+HH300RIumjyiBXr0cRyij2MQGzgOQPwjVmmfuD5HH8cgNnAcgMiP/BJO3kZ2UePHjw/be3BdiD6OQWzgOMQGjgPiTcwmkDRJpK1Qrr/+ejMmrn64nnvuOVmxYoU888wz7uedeeaZ8vnnn4tlWR4tWJ566ik5/PDDTcIoNTVV7r//funWrZv8+c9/dj/v0UcfNT18jjzySOnTp48Jkv71r3+ZpJSO2avzIQEAAAAAALQ3LR35BQAAJI4kiWE6bu6VV15pkjmXX3651NbWyrvvvisTJkzw+zodou6zzz4zz7vzzjtl8uTJsvPOO5tEk7PH0Z577mlaujz99NNyySWXyAMPPCBDhgyR6dOny2mnndYGewgAAAAAAND2dPSW+vp6M/KLzdvILwAAIHHFbA8ke+LGKVOmmB9fNFHkTa9eveS1117zu/4DDzzQ/AAAAAAAALQXjzzyiBQXF8vatWvN/9955x1ZvXq1+fuyyy6TvLy8oEd+AQAAiSumE0iJTHtK3XLLLc3maALHIdHwWYgNHAcAXBdiE9fn6OMYxAaOA+BJ55ReuXKl+/9vvvmm+VGnn366SSDZI7/oqC068ktRUZGMHDkyqJFf4gHXhejjGMQGjkNs4DggXrks5+RBAAAAAAAAAAAASHgxPQcSAAAAAAAAAAAA2h4JJAAAAAAAAAAAAHgggQQAAAAAAAAAAAAPJJAAAAAAAAAAAADggQQSAAAAAAAAAAAAPJBAijHV1dVy7bXXSmFhoWRmZsq4cePk448/jvZmxb1vvvlGLr30Uhk+fLhkZ2dLnz595KSTTpKlS5c2e+6iRYvkkEMOkZycHOnYsaOcccYZsnHjxmbPa2hokHvvvVf69+8vGRkZMnLkSHnllVfaaI/ah7vuuktcLpeMGDGi2WOzZs2SvfbaS7KysqR79+5y+eWXS1lZWbPn8Zlpme+//16OOuooc45rGesxeOihhzgGAALiuhsZxCqxiVgleohVALQUsUpkEKvEJmKV6CFWQcKwEFMmTZpkpaSkWFdffbX1z3/+0xo/frz5/xdffBHtTYtrxx9/vNW9e3frsssus5566inrjjvusLp162ZlZ2db8+fPdz9v1apVVufOna2BAwdaDz74oHXXXXdZBQUF1s4772xVV1d7rPO6666z9CP0xz/+0XryySetww8/3Pz/lVdeicIexh8t66ysLHMMhg8f7vHY3LlzrYyMDGv06NHW448/bt14441Wenq6dcghhzRbD5+Z0H344YdWWlqaNW7cOOv+++835++1115r/eUvf+EYAAiI625kEKvEHmKV6CFWAdAaxCqRQawSe4hVoodYBYmEBFIMmT17tklATJkyxb2ssrLSJDM0kYSWmzlzZrME0NKlS01S4rTTTnMvu+iii6zMzExr5cqV7mUff/yxOS6a0LOtXr3aSk1NtS655BL3soaGBmvvvfe2evXqZdXV1XG4Ajj55JOt/fbbz5o4cWKzBNKhhx5q9ejRwyopKXEv08SfHge9Sdv4zIROy1STp8cee6xVX1/v83kcAwDecN2NHGKV2EOsEh3EKgBag1glcohVYg+xSnQQqyDRkECKIdr6Pzk52aPSXN19992m4vy3336L2ra1V7vssov5sXXt2tU68cQTmz1v8ODB1v777+/+/6OPPmqOycKFCz2e9/LLL5vl9Bjz7/PPPzfn+o8//tgsgaTnv/a6c/aGUZoAzMnJsc4991z3Mj4zodMeXXqO/vTTT+b/ZWVlzRJJHAMAvnDdbXvEKtFBrBI9xCoAWoNYpe0Rq0QHsUr0EKsg0TAHUgyZO3euDB48WHJzcz2Wjx071vyeN29elLasfdIE6vr166Vz587m/2vWrJENGzbImDFjmj1Xj4EeH5v+rXMp7bjjjs2eZz8O7+rr6+Wyyy6T8847T3baaadmj8+fP1/q6uqaHYe0tDQZNWpUs+PAZyY006dPN9cYPd+HDBli5vrS/1900UVSVVXFMQDgF9fdtkWsEh3EKtFFrAKgNYhV2haxSnQQq0QXsQoSDQmkGLJu3Trp0aNHs+X2srVr10Zhq9qvl156yVSin3zyye7yV76OwZYtW8xknPZzu3XrJi6Xq9nzFMfKtyeeeEJWrlwpd9xxh9fHAx0HZ9nymQndzz//bBJ0Rx99tBx88MHyxhtvyDnnnGOOyx/+8AeOAQC/uO62LWKV6CBWiS5iFQCtQazStohVooNYJbqIVZBoUqK9AdiusrJS0tPTmxVJRkaG+3GEx+LFi+WSSy6R8ePHy1lnneVRvoGOgT7OsWqZzZs3y8033yyTJ0+WLl26eH1OoOPg/BxwHEJXVlYmFRUVcuGFF8pDDz1klh133HFSU1Mj//znP+X222/nGADwietu2yFWiQ5ilegjVgHQGsQqbYdYJTqIVaKPWAWJhh5IMSQzM9Pdw8XJHlZKH0fr/f7773L44YdLXl6evP7665KcnOxRvsEcA45Vy9x0003SsWNHM4SdL4GOg/NzwHEInV1+p5xyisfyU0891fz+6quvOAYA/F5DiFUij1gleohVoo9YBUBrryHEKpFHrBI9xCrRR6yCREMCKYbo8Fz28F1O9rLCwsIobFX7UlJSIoceeqgUFxfLf//7X48ytYdM83UMNPFh94rR52rApOP9Nn2e4lh57+L75JNPyuWXX26GoVuxYoX50aRQbW2t+VuHCQx0HJoeMz4zobHLT4dgdOratav5XVRUxDEA4BPX3cgjVokeYpXYQKwCoDWIVSKPWCV6iFViA7EKEg0JpBgyatQoWbp0qZSWlnosnz17tvtxtJwmKo488khTxu+++64MGzbM4/GePXuaYdW+/fbbZq+dM2eOR/nr3zoM2KJFizhWQdL5phoaGkwCqX///u4fPb/1mOjfOnzaiBEjJCUlpdlx0CHW5s2b1+w48JkJza677uo+Hk723FL6GeAYAPCF625kEatEF7FKbCBWAdAaxCqRRawSXcQqsYFYBQnHQsz4+uuvtTuLNWXKFPeyqqoqa9CgQda4ceOium3xrq6uzjrqqKOslJQU67333vP5vAsvvNDKzMy0fvvtN/ey6dOnm+Py+OOPu5etWrXKSk1NtS655BL3soaGBmvvvfe2evbsad4PnjZu3Gi99dZbzX6GDx9u9enTx/z9448/mucecsghVo8ePazS0lL3659++mlzHD744AP3Mj4zofv+++9NOZ566qkey0855RTz+VizZg3HAIBPXHcjh1gl+ohVYgOxCoDWIFaJHGKV6CNWiQ3EKkg0JJBizIknnmgqcf/yl79Y//znP6099tjD/P/zzz+P9qbFtSuuuMJUmh955JHWCy+80OzHpomjTp06WQMHDrQeeugh6+6777YKCgqsnXbaySTznPQY6TrPP/9866mnnrIOP/xw8/+XXnopCnsYvyZOnGiSSE7fffedlZ6ebo0ePdok7m688UYrIyPDOuigg5q9ns9M6M455xxzrp500knWo48+aspQ/3/99ddzDAAExHU3MohVYhexStsjVgHQGsQqkUGsEruIVdoesQoSCQmkGFNZWWldffXVVvfu3U0F+m677Wb997//jfZmtYubqVaQ+/pxWrBggUlUZGVlWfn5+dZpp51m/f77783WWV9fbxJMffv2tdLS0kwS5MUXX2zDvWq/gY764osvTAJVE0ddunQxvb2cPZJsfGZCV1NTY916663m3NWedNrL8YEHHuAYAAgK193IIFaJXcQqbY9YBUBrEKtEBrFK7CJWaXvEKkgkLv0n2sPoAQAAAAAAAAAAIHYkRXsDAAAAAAAAAAAAEFtIIAEAAAAAAAAAAMADCSQAAAAAAAAAAAB4IIEEAAAAAAAAAAAADySQAAAAAAAAAAAA4IEEEgAAAAAAAAAAADyQQAIAAAAAAAAAAIAHEkgAAAAAAAAAAADwQAIJAAAAAAAAAAAAHkggAQAAAAAAAAAAwAMJJAAR4XK55NZbb42b0l2xYoXZ5meffTbamwIAANoAsQoAAIhlxCoAYgEJJCCGLFy4UE4//XTp2bOnpKenS2FhoZx22mlmeWvcfffd8vbbb0s0zZo1yySUiouLo7odL7/8svzjH/+I6jYAABCviFUij1gFAICWI1aJPGIVILG4LMuyor0RAETefPNNOeWUU6Rjx45y7rnnSv/+/U2vmGeeeUY2b94s06ZNk2OPPbZFRZWTkyMnnHBCm/auqaqqkpSUFPOj7rvvPvnLX/4iy5cvl379+km0HHHEEbJgwQJTtk56KayurpbU1FRJTk6O2vYBABCriFXaBrEKAAAtQ6zSNohVgMTSWLMLIKp++eUXOeOMM2TAgAHyv//9T7p06eJ+7IorrpC9997bPP7jjz+a58QCTRClpaVJUpL3jowZGRltsh0VFRWSlZUVlq7hbbXNAADEG2KVliNWAQAg8ohVWo5YBYA/DGEHxIApU6aYG/aTTz7pkTxSnTt3ln/+859SXl4u9957r3v52Wef7bUnjw4Tp8kQm/6tr33uuefM3/qjr7WtWbNGzjnnHOnWrZsZNm/48OHyr3/9y2Odn332mXmd9oK66aabzBB7mrQpLS0Naqxe/a29j5T2rLK3w9kL6MUXX5Rdd91VMjMzTS+sSZMmyapVqzzWuc8++8iIESPku+++kwkTJphtuOGGG8xj//73v+Xwww83w/7pfgwcOFDuuOMOqa+v93j9e++9JytXrnRvg12GvuZA+vTTT00CLzs7W/Lz8+Xoo4+WRYsWeS3zZcuWmbLV5+Xl5ckf/vAHc1wBAIh3xCrEKgAAxDJiFWIVAJFBDyQgBrzzzjsmkaGJCm80WaKPa/IjVC+88IKcd955MnbsWDn//PPNMk2uqPXr18vuu+9ukh+XXnqpSV598MEHZgg9TQ5deeWVHuvShIz2Orr66qvNcG/6dzCOO+44Wbp0qbzyyivywAMPmKSYspNld911l0yePFlOOukks60bN26Uhx9+2Oz33LlzTULGpsP5HXrooSbBpPNFaeJLaeJHh+r705/+ZH5r4ufmm282+6GBpLrxxhulpKREVq9ebbZD6XN9mT59unkv7fWlSaLKykqzXXvuuad8//33zRJ4uv2aIPvrX/9qHn/66aela9eucs899wRVTgAAxCpiFWIVAABiGbEKsQqACNE5kABET3Fxsc5DZh199NF+n3fUUUeZ55WWlpr/n3XWWVbfvn2bPe+WW24xz3PKzs42z2/q3HPPtXr06GFt2rTJY/mkSZOsvLw8q6Kiwvx/xowZZp0DBgxwLwtEn6/bYpsyZYpZtnz5co/nrVixwkpOTrbuuusuj+Xz58+3UlJSPJZPnDjRrOOJJ55o9n7etuuCCy6wsrKyrKqqKveyww8/3Gu56XbpuqdOnepeNmrUKKtr167W5s2b3ct++OEHKykpyTrzzDOblfk555zjsc5jjz3W6tSpk48SAgAgPhCrEKsAABDLiFWIVQBEDkPYAVG2detW87tDhw5+n2c/7m/YuFBojueNN96QI4880vy9adMm98/BBx9seupoLxqns846ywwxF+5JLhsaGkzvHec2dO/eXXbYYQeZMWOGx/N1eDodGq4p53Zpmeo6tEeXDiG3ePHikLdr3bp1Mm/ePDMknQ6pZxs5cqQceOCB8v777zd7zYUXXujxf31/7TEVrmMGAEA0EKsQqwAAEMuIVYhVAEQOQ9gBUWYnhuyAp7UBUbB0mLji4mIz75L+eLNhwwaP/+vwbOH2888/mwSWJou8SU1N9fi/zr/kbei8hQsXmvmZdOi6pgkbTYaFSudJUkOGDGn22I477igffvihmVtK50ay9enTx+N5BQUF5ndRUZHk5uaGvA0AAMQCYhViFQAAYhmxCrEKgMghgQREWV5envTo0UN+/PFHv8/TxzV5YicidN4ib+rr64N6X+31o3QeIe1Z5I32tnEKd+8jezt0X3TupeTk5GaPN52jyNs2aCJs4sSJpmxuv/12M8dTRkaG6UF17bXXuvc10rxtv2oc0Q8AgPhErEKsAgBALCNWIVYBEDkkkIAYcMQRR8hTTz0lX375pey1117NHv/iiy9kxYoVcsEFF3j0btHEia+eM07ekk1dunQxrXQ04XTAAQdIpPlKeGmyRxMs2rtp8ODBLVr3Z599ZoaK0+HwJkyY4F6+fPnyoLejqb59+5rfS5YsafaYDonXuXNnj95HAAC0Z8QqxCoAAMQyYhViFQCRwRxIQAz4y1/+YnrWaIJIEyFOW7ZsMXPrZGVlmec5Ey86NJuz55LO2/PWW281W78mOpomm7S3zPHHH2/mQVqwYIHXIe7CyU62NN2O4447zmzLbbfd1qynjv6/aXn46/njfH1NTY089thjXrcjmCHttFfYqFGj5LnnnvPYZi2rjz76SA477LCA6wAAoL0gViFWAQAglhGrEKsAiAx6IAExQOf/0UTFaaedJjvttJOce+65pkeO9jp65plnZNOmTfLKK6+YpJFt0qRJZni2Y489Vi6//HKpqKiQxx9/3PTi0aHbnHbddVeZPn263H///VJYWGjWPW7cOPnb3/4mM2bMMH//8Y9/lGHDhpmElb5en69/h4tug7rxxhvNtuvcRkceeaTZpzvvvFOuv/56s7/HHHOM6RmlvYc0GXb++efL1Vdf7Xfde+yxh+mRpUPxaVloL6MXXnjB69Bxuh2vvvqq/OlPf5LddtvNDJGn2+HNlClT5NBDD5Xx48ebY1JZWSkPP/yw6R5/6623hqlkAACIfcQqxCoAAMQyYhViFQARYgGIGT/++KN1yimnWD169LBSU1Ot7t27m//Pnz/f6/M/+ugja8SIEVZaWpo1ZMgQ68UXX7RuueUWzZp4PG/x4sXWhAkTrMzMTPPYWWed5X5s/fr11iWXXGL17t3b/Z7777+/9eSTT7qfM2PGDPO61157Leh90efrtjjdcccdVs+ePa2kpCTz+PLly92PvfHGG9Zee+1lZWdnm5+hQ4ea7VqyZIn7ORMnTrSGDx/u9f1mzpxp7b777mYfCwsLrWuuucb68MMPzfvo9tvKysqsU0891crPzzeP9e3b1yzXbdH/T5061WO906dPt/bcc0+z3tzcXOvII4+0fvrpJ4/n2GW+ceNGj+W6rqb7CQBAPCNWIVYBACCWEasQqwAIL5f+E6nkFAAAAAAAAAAAAOIPcyABAAAAAAAAAADAAwkkAAAAAAAAAAAAeCCBBAAAAAAAAAAAAA8kkAAAAAAAAAAAAOCBBBIAAAAAAAAAAAA8kEACAAAAAAAAAACABxJIAAAAAAAAAAAA8EACCQAAAAAAAAAAAB5IIAEAAAAAAAAAAMADCSQAAAAAAAAAAAB4IIEEAAAAAAAAAAAADySQAAAAAAAAAAAA4IEEEgAAAAAAAAAAADyQQAIAAAAAAAAAAIAHEkgAAAAAAAAAAADwQAIJAAAAAAAAAAAAHkggAQAAAAAAAAAAwAMJJAAAAAAAAAAAAHgggQQAAAAAAAAAAAAPJJAAAAAAAAAAAADggQQSAAAAAAAAAAAAPJBAAgAAAAAAAAAAgAcSSAAAAAAAAAAAAPBAAgkAAAAAAAAAAAAeSCABAAAAAAAAAADAAwkkAAAAAAAAAAAAeCCBBAAAAAAAAAAAAA8kkAAAAAAAAAAAAOCBBBIAAAAAAAAAAAA8kEACAAAAAAAAAACABxJIAAAAAAAAAAAA8EACCQAAAAAAAAAAAB5IIAEAAAAAAAAAAMADCSQAAAAAAAAAAAB4IIEEAAAAAAAAAAAADySQAAAAAAAAAAAA4IEEEgAAAAAAAAAAADyQQAIAAAAAAAAAAIAHEkgAAAAAAAAAAADwQAIJAAAAAAAAAAAAHkggAQAAAAAAAAAAwAMJJAAAAAAAAAAAAHgggQQAAAAAAAAAAAAPJJAAAAAAAAAAAADggQQSAAAAAAAAAAAAPJBAAgAAAAAAAAAAgAcSSAAAAAAAAAAAAPBAAgkAAAAAAAAAAAAeSCABAAAAAAAAAADAAwkkAAAAAAAAAAAAeCCBBAAAAAAAAAAAAA8kkAAAAAAAAAAAAOCBBBIAAAAAAAAAAAA8kEACAAAAAAAAAACABxJIAAAAAAAAAAAA8EACCQAAAAAAAAAAAB5IIAEAAAAAAAAAAMADCSQAAAAAAAAAAAB4IIEEAAAAAAAAAAAADySQAAAAAAAAAAAA4IEEEgAAAAAAAAAAADyQQAIAAAAAAAAAAIAHEkgAAAAAAAAAAADwQAIJAAAAAAAAAAAAHkggAQAAAAAAAAAAwAMJJAAAAAAAAAAAAHgggQQAAAAAAAAAAAAPJJAAAAAAAAAAAADggQQSAAAAAAAAAAAAPJBAAgAAAAAAAAAAgAcSSAAAAAAAAAAAACCBBAAAAAAAAAAAAN/ogQQAAAAAAAAAAAAPJJAAAAAAAAAAAADggQQSAAAAAAAAAAAAPJBAAgAAAAAAAAAAgAcSSAAAAAAAAAAAAPBAAgkAAAAAAAAAAAAeSCABAAAAAAAAAADAAwkkAAAAAAAAAAAAeCCBBAAAAAAAAAAAAA8kkAAAAAAAAAAAAOCBBBIAAAAAAAAAAAA8kEACAAAAAAAAAACABxJIAAAAAAAAAAAA8EACCQAAAAAAAAAAAB5IIAEAAAAAAAAAAMADCSQAAAAAAAAAAAB4IIEEAAAAAAAAAAAADySQAAAAAAAAAAAA4IEEEgAAAAAAAAAAADyQQAIAAAAAAAAAAIAHEkgAAAAAAAAAAADwQAIJAAAAAAAAAAAAHkggAQAAAAAAAAAAwAMJJAAAAAAAAAAAAHgggYS4YFmW7LLLLuJyueSpp57y+9xnn33WPE9/PvvsM7OsqKhIcnJyJCkpSebOnduibbDXGehnxYoVkui03G+99VbzU1xcHNZ16zoTqazPPvtsn+faP/7xj2hvHgC0e6HEIN7oa/S1ug5dV6iccY2/n3322SfkdbdHem/UWEHLLdz69euXUGV9++23y7777ivZ2dnu8+zFF19sVaxSUVEhN9xwgynL9PR081v/X1lZ2YZ7BgAAACBYJJAQF1599VWT+OnatauceeaZIb++oKBAzj33XFNxo19SEfkE0m233WZ+wp1AAgAgnmIQfY2+Vtfxf//3fxHZRmynCQuNPyKRQEo0999/v4npNOkTDhqHH3300fLXv/5VVq5cKTU1Nea3/l+XtyTBCgAAACCySCAhbr7AqkmTJpnWii1x1llnmd///e9/ZcmSJSG/Xr/U2j9Tp051L7/llls8HtOWlE0lSqvKRNnPaNDz13me6c+VV14Z7c0CgHavtTGIvubkk082f7ek56j27nBe+ydOnOh+bPny5e7ldq/rRL03J8p+tqU//OEP8q9//cv06ApHrDJt2jSZPn26+fuSSy6RTZs2md/q448/NslaAAAAALGFBBJi3sKFC+Wbb74xfx933HEej2mLyPPPP1/y8vKkU6dOctVVV5nWjN7o0DF2cidSrVJ1SDV7yI7JkyfLddddJ927d5fCwkLzuH4J33vvvc2ytLQ0yc3NlT333FNef/11j/Xo0Ci6Dt1erRDabbfdJDMzU3baaSf56KOPPJ772GOPyahRo8y6dIiRgQMHykknnWTKrek23XzzzaZVrm5PVlaWHHHEEfLbb795rE//rxUGPXv2NNuoz9XKK20hGsx+6rbre9j69+/v3hdfdB/t9T3xxBNy+eWXS+fOnaVDhw5y2mmnmSEI/dGEoJ4b+l46VKFW1g0aNEiuueYaKS8v9zoM0BtvvGFaheu506NHD/Pcurq6AEfY/7Y//vjjcsUVV5ht1x8tx7KyspDXCQCI/RhEvfzyyzJ+/Hhz79H79NixY71Wgh9//PHm99dff92iRiyhDvH6ySefyEEHHWTu9ddff725v+m9fPjw4aZXdmpqqrn3nXrqqSYJZfMWM2g8oPfKY489VjZu3Oh+7oYNG+SPf/yj9O3bVzIyMkwctuuuu5pYzNs2/e9//5OjjjrKxCr63vpY0x4n77zzjkmQaUyj69S457777pP6+vqA+3nKKaeYZXa88vnnn7uf5y8B4hx+bf78+eb99Vhq3KIxViCRiO2C5dz2H3/80Qw3p2Wxww47yHPPPSet9cADD5hYRo9xOOjnxabnl54z+tvb4wAAAABihAXEuAcffFBrF6zk5GSroqLC47EzzjjDPOb86d69u/vvGTNmeDx/0qRJZvmYMWNatU1Tp051v8ctt9ziXr58+XL38oKCAvffeXl55vGTTz652fbaP++99557PRMnTjTLMjMzrbS0NI/nZWdnW5s2bTLPmzZtms/1vfbaa822qVOnTs2et+OOO1p1dXXmuStWrLC6du3qdX26XB8PtJ/2tjf96du3r8/y1OPkbxsPPPBA93O1vO3luh3qgw8+8FkOJ510ktfjptva9LmPP/54yOeCc9u9rfNPf/qT1RpnnXWWWU9ubq45H/Rnt912s55//vlWrRcA0LoYZPLkyT7vPVOmTPF4bnl5uVmHPvbII4+0quid91n7Ptj0/ui8N19xxRVWZWWlz23V+7M+3vT+7u2epnGM7ZBDDvG6Po1TvG2Tt/v7XXfd5X7uY489FtS93Nd+Hn300T5f74zVfN1nfW3jSy+95H6ulpUu02NgC3dsFwrntjc9Xi6Xy/rhhx+scHDGTy+88EKLY5XCwkL3tjrZ296rV6+wbC8AAACA8KEHEmLe999/b35r7xJtqWlbunSpvPTSS+bv0aNHy6pVq2TBggWSkpLic10jRowwv+fNmycNDQ0R3e6SkhLT42Xr1q0yc+ZMs0x7S/3www9mXqDa2lpZvHix9O7d2zymPW+8Dceiczdt2bLF9PRR2qPmgw8+MH9/+eWX5veAAQNk3bp1pkfWokWL5KGHHvLaWrSqqkpmzJhh1qc9e5Q+327xqcPxaYti9fDDD5t90N9Kl+vjgfZTW9U6n2cPr6OtmoOhrXd1noj169fLfvvt5x7W5IsvvvD5mqFDh8qHH34ov//+u+mBtnnzZtMqWr322mvm/01pDyFtBa7ngrZyVk1bC4dKz705c+aYfdUW2+rNN9/02lvJ34+3siotLTXng/5oa3jtPaVzBgAA2j4G0Xvb3Xffbf7WIbj0vqq9ZbUXjNJeFc7es9orRNehvvvuu4gfsm7dupkeKXpv1l692uNIhw/T3jkaC2gs8fTTT5vn6rL333+/2Tr0eRpv6P1Ye8nY9zQ7frJjEO1xpPcm7Z2kvYycPZCaxmB6n9btsntm33vvvWYb9efaa681y/T+qbGSMw7QuaO8DdHn3E8dalDjDTv+0Z5E9jBqwQ7BduCBB5pjqfuhPaWUHX/5Eu7YrqW0h5MOCffMM8+Y/+t+v/XWW157K/n60XW0RqBYRbdPaS8tJ/v/dgwKAAAAIHaQQELMs79M6jAXTjoMjF2JoZUVvXr1MkOznHPOOT7XZa9Dh3LxllQIp0MOOcSMBa/D2uh2KR3eRCsxBg8ebJIWmvjQxJedEPOWkLjnnnvMcDN2pZSyX2NXkqxZs0Zuv/12ef75500FxkUXXWSGRmlKh5/RygFdnz7fZie4NAmjtJLr0ksvNV/o9bc9/Jy3IVa87WdraKWKDsmnE47feOONzbbRGx0KRyuWtLJIh73T4/zUU0+5K1B+/vnnZq/585//bI7DzjvvLCNHjvQo19Zsu5a7Hpe99trLLFu9enWr1nnAAQeYIX200k0rZnS/kpIaL9133HFH2Ca2BgAEH4NowwZ7WLVHH31UOnbsaO6tr7zyilmmFegapzjZ69DESKTpPV6TPnpv1kYmycnJ5n5xwgknmAYUmhw577zz3M/3FoMcffTR5h6v9+NDDz3ULNMEib39dgyiySdNEnz66acm+aP3Jm80WaIJH90uvV/ajVB0mMBZs2aZJJDSBiB6X9b3dQ5v5i0GabqfrXXnnXea46hD0tlDFv7666/mHuxLuGO7ltJjoOeYDktoa20M0laxij2UoSaxAAAAAMQW3101gBinPW5sdm8PZbdq9abpWPuRZLfWtWklycEHH+zzy7y29G1KK1o0IaLsXjKqurra/L744otNK9l3333XzL/jLIN///vfMmbMGI/12S1im5aZJqCcLUM1Geek/9deMc65D3ztZ2sF2kZv/vKXv7h7SgVbtjo/gM0uW7tcW8q5Tnuidee8Spq8C/UcPP300z3+rxV+2qtKK9K0glIr3rwlCwEAkePtftiU9jCJlRhE5/3z18Am2Puk8175z3/+U8444wzTm9fZKOXwww83PV+011Ow93fn+zuf54xHoh2DaKKoqUjEdi1lHy87/rATfjbtLR6pOUCDjVU0ebl27VqTZHKyk4ddunSJyPYBAAAAaDl6ICHmaQtU1bTHkPY68ZZc0C+mvtjr0Naf2lo4kpyVAkpbItsVDNddd50ZrkQrk3TCaV+cw/F5a5WpQ+L85z//MS2kp0+fboau03LRMtBJs5tyVnA4y8yuJNEv9k2f53yu/bi//fS1rcEKtI3eaCWFPTzOb7/9ZsrVX0IpmLJtiUDrDHUIO3vonaac66a1LgC0fQzivB++/fbb7uu1/aM9pO2hYm32OjSBEGlN7832EK26fPbs2aZxw/z581t1T9tzzz1N7xwdCleHtrviiivM8vfee88MORfK/d1Zns7nOf+OxRgkErFdS9nr9bXOSA1hF0qssssuu7gTb3bvPv2t/7eHpAYAAAAQW0ggIebZXzZ1vgHnEBjjx493D4/xwAMPmC/6P/30k/zrX//yuS6dI0npEGk6nEtb0rl5bDp0jH6Z1jmc7PkVWkIrhLQFsM6zsMcee8jJJ5/sbq3rraWuVvBojyUd5s45LIxWAqmDDjrIXdaPPfaYaRGqv/X/zscD0WFZmpZ5sHTsfp3PQCsU7rrrrmbb6K9stbWzlq22htYhheKdVqjsvvvuJkGmLdn1eOicFTp0ktIhBu15vQAAbReD6Fw5dgxy0003mfuW3ou0AYDef/RxJ00s2I0D/CUXIsW+T2rsob1fNA4Idl4gX3SYWR36Vu9FRxxxhHvIN18xiA4Pp8PfaeLKnqcnLy/PDH+rMZ0OQ6d0+DN9jq5DX2MLNQbRBiV2YiJYOsyexlQ676I9h+HAgQO99j6KVGwXS7QstHd6WVmZe5n+rcvssg0lVnEOr6e91jSp6uy95nwcAAAAQGwggYSYt//++5vfOtfAnDlzPIbqsFv3zp071z0Hkg6V4Ys9H4GO1d7WNMFjV2poBYX2HtI5APwNuReIJmcuvPBCM+6+rk9bNeukxUrnLWhKK410niDdDq3gUDvuuKP7C/ttt93mbuGrk4Lrl379rXS5Ph4M55BqRx55pKlQaTq8iS/aalvnJdJ90fkUlFbE6XwEvuhwOfZ5oOP/6/wDzmFbYoU9hF2gH3vOKaXn/EknnWT2S4+Hzg1hz/01ZcoUr62vAQCRjUF0vp1rr73WfS/W+5YOHWbPIbhs2TKP9ei92Z4zKRoxiH2f1Bhp2LBh5p4+b968Vq1T4wiNNbR3Tlpamokv7MYc++23X7Pna08lTcTo/EZ2b/FrrrnGxCZ6f9M5fJT26LHnQNLe1Urnbtp3331DikE06Zefn29iEHs9gWjcoT3UJ0yYYJJ+ypngaIvYLlJ0+LpA8Yf2lHbSHkE6rNxll13mXqbzbOoynSMr1Fhl0qRJ7vNfE616HtoNfjTW04ZQAAAAAGILCSTEPE0KjR071vxttwa16bw/Os66Vj7oF3idE8jX5M3fffedrFy50j2MR1vTL9U6L5G2ZtYv0rpf+v9Bgwa1eJ36JVy/sGuFlVZaaOtdrRjSyg5nq13b+eefb3r1aMWGbsNhhx0m//3vf929sTRxoZVcZ555pqnk0eFQ9LfOcaDLnYkNf7Ql8d13323mErBbaAdLk1R/+tOf3JN86wTT06ZN8/uaBx980CTBtKJIX6cVUt6G8Is3ejx1KD5tda0JUq2g033UShY9bno8AQDRiUH0Pvfiiy+aJIJerzMzM809XRtMaO/dpnMQ2ffHIUOGtPkh+8Mf/mB6HOn9X++t2lvolVdeadU6NamgSSNt8KFJI00qaMJNh7DTBFBTWgbHHHOMiVc0OaQ9oZ33ak286dxJ2mBEy1MTchrT3HPPPSFtq8YRRx11lLlfhmrGjBkmUaUxUp8+feSRRx7x2ysmErFde45VNJmn5aPD/fXt29ecN/pb/69DQTIsLwAAABB7XFZbzugLtJAmEDSRoBUOOiSJc4LgYF1++eXmC+6hhx4q77//fsIcCx0yRxNM6pZbbmn1kDWRoC1e7ZbFU6dOjUqCL9x0H5577jnzN5dZAEjcGKSqqspUkuvQrK+++qpp+JEoNOawey9rj6BgG6K0pfZ4v7YTMWeddZbpeQQAAABE26+jR0vPadMkPYgGdVsefliqFy2SHk0a5iE66IGEuKBDWui8RVr58vzzz7doDHedG0m/UDvn1QEAAIhkDKKv0dfqcGAnnngihQ0AAACg3Vu5335S7hhKesDcuUElj4Kx4brrZBP1u20mpe3eCmg5Tfzo/DYtpcPbOScABgAAaIsYRIfwYshRAAAAAEA8Ygg7AAAAAAAAAADQar9ffrmUf/SRuNLSRJKTpcORR0rpq69Kr7fflvQddxSroUG2PPigbH3tNZGkJCm46CLZ8sAD0v3RRyVz3LjGIewWLpSUwkIp+89/JCknRzpdc43kHHaYFD//vGy+5x5t6Seu1FTznD7vvcdRiyCGsAMAAAAAAAAAAK3W/aGHTGKn2/33m6Hrutx+u8fjW994Q8reeUcKX3pJ+kyfbpJFDeXlHs+p+PJLyRwzRvrNni0dr7xSNtx4ozSUlUn+mWeahFTeKaeYdZM8ijwSSAAAAAAAAAAAIOLK3n1X8k47TdL695ekjAzpdPXVIg0NHs9JHzbM9DhyJSdLztFHi1VbK7UrVnB0ooAEEsLOsizZZZddzJwBTz31VNRK+LPPPpNbb73V/BQXF4dlnQsWLJCjjjrKzKmUlZUl48ePl3//+99BvXbZsmXyxz/+UYYPHy5JSUmmfFJSvE9Dtnr1ajn77LOle/fukp6eLkOHDpV7771X6uvrPZ5XV1cnDz30kClv3abc3FzZaaed5G9/+5tUVlZ6PPfLL7+UI488Unr16iUZGRnSr18/Of3002Xx4sUSSVr+uq/6syLEC70+336trqc1tOymTJkiQ4YMMWVaWFgoF198sWzZsiXodTzzzDOy8847m/Lr0qWLKb9Vq1ZJWwr2HAx2f0877TRTvldeeWUb7gUAxA7iFt9+++03c6/Te57e+/QeqPdCf/bee2/3vfuAAw5o9vjzzz9v7l2dO3eW7Oxsc5+6/vrrpaioqEWxUCTiR3v7n3322ZBfr/GVvnafffZp8Tbo+9rb4O1H3yMYGvvtt99+0qFDB/Ojf+uySAj2vYKJRzW+7du3r9nXt99+OyLbCyC278F6Hbjqqqukd+/e5juz/X1wyZIl5ru0fg9at25di9/XvlY7f/S79MSJE+Wdd96R9lSHYSstLTX31R49erjrI1pynwsHex/j7RofyeOTKPSY22UYi3Gc1kHZ2zdv3rygXqPvo8//xz/+0ewxjQdDid2asvdFP7v+6Plob7eWQTyo27BBUnr0cP8/uWNHcaWnezwnuXNn999aDppoatpLCW3EAsLslVdesfTU6tq1q1VVVRW18r3lllvMdujP8uXLW72+BQsWWLm5ue51On9eeOGFgK9/6623mr0uOTm52fPWrVtn9ezZ0+v7nHPOOR7Pvfjii70+T39OOukk9/NmzZpl3svb8/Lz8621a9dasXgc9Pn2a3U9rXHuued63f+ddtrJqqioCPj6O+64w+vre/XqZY5ZWwjlHAx2f7///nuzPD093Vq5cmWb7AcAxBLiFu/8xSN33nmn19c8//zzHs/bf//9PR6/9957fcYt48aNa1EsFG4zZsxwv9fUqVNDfn3fvn3NaydOnNjibdD39VVO+jN8+PCA6/jkk0+s1NTUZq/VZZ9++mmLt6017xVKPHr//feb5cOGDbPq6+vDur0AYv8e/MgjjzS7TtjfB4866ijz/wsvvLDF72tfq3396P2sPdRhOF199dXN9rMl97lwsN//rLPOsuJJJI9PotBjbpdhLMZxLXm9xnz6fL2uhPJYOD8r4aw7C6cV++1nlX38sfv/ywYPtqp++sn8vebMM62ip592P1a3ebN5vOLrr83/Nz/0kLX2oos81vfrrru6H19/3XXWRh/fSRB+9EBC2N1///3m96RJk0yL0fbiT3/6k2m1k5aWJtOnT5fly5dL//79zWOXX365VFRU+H19z5495YYbbjAtmsaOHevzedp7aM2aNebvl156ybznBRdcYP7/r3/9y6M154svvmh+a2uphQsXmt4wdsuG119/XbZu3Wr+njZtmrvF7l//+lcpKyuTSy65xN1S4a233pJI0RYQet/Tn5a2umitr776yt1i+thjj5WNGzeaclDz58+XBx980O/rV65cKbdvG6913LhxprXbCy+84G4hHY7WM3ZLGX/rCvYcDGV/R48ebXqtVVdXy+OPP97q/QCAeEPc4t0tt9zijkf0nqf3Pr0Hqttuu830TnLS+9M111xjWoX7YsctycnJ8vnnn8umTZvcMdHs2bPlp59+CjkWCjdtKWrHLYFae0aKvq+9DfaPs0X8qaeeGnAd2uu4trbW9FjWFrT6o3/rMn0snIJ9r1DiUe2VpOeJnhMff/xxWLcXQOzfg50t//W7mF4H7e9JZ511lrvVfzh6gei69Xql1yjbjTfeKOHQdFSQaLLLND8/35RboPtcLG07EltVVVVcxXFN63l0W0Idjae90B5EtU2+M9hyjjhCSl5+WWpXrpSGqirZrPeDpKTQ1r1qlSlftIEIJKWQwLSHhJ31/uyzz5o9/tprr5kMvPaiyMjIsAYPHmz97W9/cz9eV1dn3XfffaaXhD6ek5Nj7b333ta///1vj/V8++231uGHH25169bNSktLM7/32Wcf66mnnvLI8jf9aWnWf8OGDVZSUpJZx6GHHupefs8997jX/cYbbwS9Pnv7vPVA2nnnnc1jXbp0cS/74Ycf3O9zkSMD37FjR7Nszz33dC877bTT3M/dtGmTWfanP/3Jveznn382yz7++GP3Mi3zUGgLUbs8Jk+e7PHYgQce6C7rhoYGn610tLfL2WefbRUWFpoWqj169DCtKlasWBH2VhSXXnqpez2zZ892n2sdOnRw98rxR8vHfv2rr77qXr7jjjuaZXl5eR6tY//73/9a++23nznPtWfPiBEjTCs6LY9ALV187Wco52Co+3vrrbea5XoM/G0jALQ3xC3e6T1N7216b9B7nU3vgfb95e9//7vHa6666iqz/O677/bZA2mXXXYxy7V3ke3GG290P1/ju1BjoWDZ92yNK53uuusu93p/+eUXny1PtffuTTfdZGJXjT21x8zBBx9sffHFF2HvgeSNxr12r57ff//d73O1HL2Vlf5tL//uu+/cyxctWmRNmjTJxNO6/j59+pjjWVpaGnC7QnmvUONRje11uW4bgMS5B/vqHaTXZ1VZWWllZmaaZU888USL3tv5Hk4jR450L1+/fr21ePFi69hjj7X69etnZWdnm+v/wIEDrb/85S9WWVmZ156jeq888cQTTV3G0Ucf7b6vPvTQQ9aoUaPMtuu69D6h10BbMHUY8+fPt0444QRzf7Sv1/rdz/7e74uvnlb6fdv5fX369Onm+7xu4xVXXNHi+5/W+2gPUl3P2LFj3fd35z3WV2+oUHuoxGodUyh1JnqunXfeeeZ4av2B1vNozHTllVdaLaX33uOPP9707tNzRWOvk08+2eM5//nPf6wJEyaYegK73mLKlCmmzGzO80M/p9oDMCsry2yr9ix30vNZy6xz586mDLWuR88VHY3H32fbjpmcx/6bb76xdt99d7OeBx54wNSHaDywww47mO3Vferdu7d1/vnnWxs3bnRvg7c4zlmvpMdC6z902/ScOeaYY8y6m+6rt8+KN76eb/cY8tUDSXta6zHRstRt0F7a3uq+nOt79tlnzf7r9UPrmzRuDdRzXcsj2P0PJS7Uc+T222+3hg4davZBP1dDhgyxTj/9dGvNmjXu59x09tnWwKwsKzMpycpOS7MGpKZapxx5pHlOQ329tenvf7d+3X13a/mee1rFL75o/bLzzlbl998H1QOpZuVK67djj7V+HTPG+u2II7weH4QPCSSE1YMPPuhOjDQdFsyupPZ1s1A67JqvC99jjz1mnqOBWqdOnbw+R2/4kUggffTRR+512IFU02HpNKgKRwJJAx5/lSZ6E7Vde+21Zple+BcuXGitWrXKBLe6TAMO5zBlGizp8r/+9a9WeXm5e/g7l8tlzZs3L+QyOeCAA5pVLGngmpKSYpZff/31Zpm3BJImiTSQ8XaMdLmdRApXAmmPPfZwr6eoqMi93K6g0uPgb7jFU0891f36uXPnupfrFwJ7+bJly8yyp59+2uc5fMkll7Q4gRTKORjq/mrCy36+fpEDgERB3OLd0qVL3fcFu/JL6T3QXq5fEG1679D7v8Yw1dXVPhNIjz/+uFmuFSqff/65iRu0YkmX6RdZ+94USiwULB12z35v59CzWpmny8ePH++z4qGmpsbaa6+9vN7b9Z76zjvvRDSBpI1u7EoorZQM5Mknn3Rvn1a62PRve7nGK0pjQP3S723fdt1114DDUYfyXqHGo9ddd12z8wBA+78HB0ogKb0P6DJNpoQzgaRJBnu5Vqp+8MEHQQ0Z76zALSgoaHYPPeOMM7yuQ699dgPFQHUYmuDQilpvz9H7ZnFxsc/9DTaB5Nx2/c7Zkvuf1k3ofjmfqxX9uq5wJ5BivY4p2DqTQw45xOu6NVHQElp34G1oWWeZ6r4Hc247zw+7cZHzRz8jSutw7Hu8r3qQUBJIznNRYwpNavjaXo0lg00gedsHO7HWVgmkZ555ptnztTGvvwSSt/oze/jnUBJI/vY/lLhQk7S+3lOTf8E+x6l2/XozhF1tgIZSiA6GsENYff/99+a3DquVmZnpXq7dNe+44w7zd7du3cxQFDpsxY8//mi6q9tdO//v//7P/K0T7/7+++/yww8/SGFhoVl27bXXmiHZdJLdzZs3m2VvvPGG1NTUmGHE/v3vf5tJee116dArNh3qy9ltVH/7m5zY/rEnn9MhVmw6XJy3vzds2BCWMhw5cqT5rcOOvfzyy6acHnvsMffj9r7bw3/8+c9/NkO7DB8+3Ewyqvum3XbffPNNj2HKPvroI9NdXSeq1kmrdZ06geYrr7xiJsUOlQ4tohYtWuQeckYnRNQJT52Pe6PHxi6vhx9+WEpKSsxvpcudx84b7Yoc6Ng5J68OdPx0OJUtW7b4fL9gj78eKx1mTh133HFmuB9dpsdIaZlrebVEKOdgqPs7YsQI99/fffddi7YPAOIRcYt3ocY9l156qbn/671ch1n15cILLzQTDGtMphOVd+7cWebMmWPilPfee889fFEosVCwTjvtNBMfNDQ0uGOkX375xT2kj7+4RYfRs4fN0/XoPVSH4MvJyTH31Msuu8zv8Bk6zFIwcacvOrG8bre66KKLAu5rKMdP4xYt3x122MEMh6zDxGh8bccEU6dODdt7hRqP2vGJngdNh0wE0L7vwfYwdcoejsr5/c6+PoTru4vew1599VUz3LfS79VdunSRoUOHyocffmjqJrTeQe8/f/zjH81zXnvtNa/3I72X6T1Dr6333nuvfPHFF+7hz++66y5Tp6HfE+2htq666ipzjQ9Uh6HfKXXI8qSkJHOd1u/QWkeili5dKg888IDP/bPvu6pv374+h5jXuhqto9Ft1CHSW3L/07qJO++8U4qKitxDiOlQ+zpUrb3PNj3OLR1uLNbqmFpTZ2KXsZ4LOnSg3vf+97//mf+3hMYKOiyjnitPPPGEGbJQh4LU46J0n+1zR6da0DJZv369KSOlZWbXhTnp50GHGNbPhE2nTlDffvute6i5b775xgyRr++pcdxee+3l97Pt7b2GDRsmv/76qznnjj/+eOnataspO31/Xbee//awlhpL2teTQHQbP/jgA7O/OpS/0rhQP4O6vhkzZrifqzFQoOkYfH22NPbzRt9Hh4K2Y6WZM2eabRkyZIjf7dZY6rnnnjPlceCBB5pl+pnS81Q/O3o+2vQ89XbdDLT/ocSF9jm7xx57mM+6nlN6Hukw1B07dgzqOVZdnZRPny5Wba3Ul5TIprvvlozRoyWlWze/ZYHoIIGEsLK/IHbq1MljuX5ZtMc8v+mmm+SAAw4wXxr1gqWVCcp5E7r55ptNEKAVCOeff75ZphcbndtFb3A6Jrp69NFHTaCkX/733HNP9/j4bcUZ/Pj74h8KvZHblS8apHXo0EH++c9/uh9PTU11/z1lyhT5+9//3mwdGqDZAYpasGCBnHDCCc3GiNabrt7c7QAmFJogsQN9O2iwf2sFgd7wfbGPtX5Z0EonvXHqb/umrOdLPBy/pq+fNWuWCZjtm7BWiGhwbR8jZ3DUNIm57777muUaTHhLYoZjH3w91/l51UACABIFcUtovN1HdM4IvVdpXHDQQQf5fb1WIlx99dXNKpvsCp2WxELB0hhDv8B6i1t0fSeffLLP1zpjVK380/l9JkyYYGIr+57+888/SyRojGbPa6iVC3a80BJNj59WRGpFoNLt18ZIGRkZpqLG5qxIac17tSQeJT4BEvMeHAz7NeH47qLXKL0P2EkHZVfw6vc5vcdpBbHei/R9NalvX+e8Xfu1AlbrJrS+Y/Dgwaay1jm3kq7HXq9au3atLFmyxO826vVaE1FK7z96z9Xv0Lqdet0O13donfdX62j0O+yAAQNadP/r3r27XHfddaaxwEknneRRRxEMrXi3K7/9iYc6pmDrTDTxoN5//33TSPjTTz8122QnyEKhyURtIGPPh6zbn5eXJ3369HHP7aX1FvZ82ZoQ1TLRBI2Wkc3b+aSJCU2+abynz3ceV3sf1N13323KURNzRxxxhMdnK1h6DLS+SM85Tejqb923Qw891Jxbuk/O+aP1sWAcffTRcsghh5jt13UpTba1VT2IJnzsRjH6OdLYVLdFz2F/dM7QM88805SDHtdQP1fB7H8ocaF9vLXeUa8bmlDXz6POh6rXjqCeY1lS9OSTsnzcOPntwAPFqqyUrl7qNxEbSCChTWgLCpuvzLqzBaPeIGy9evXyWI8GJA899JC5YeiNVSsZ9Kaky+1AL5hKhKaTE3v7sbP12kLWZicIlH3TVdpCKRzGjBkj06dPl7333ttcrHW/tAWJvQ122WhZ2DcZbbGprTt0md7MNWDQYEVvTkqfpwG6tkD5z3/+Y24M2hJFf2ty48EHHwx5OzXwPeqoo8zfeiPQFgWffPJJwFa8zmPtPLbO/zvPl0BBpa8fZ+Il0PHTYFFvxL4Ee/wDbbfy19PJn1DOwVD3l0kHAcBTosctobxeW7NqfKEtSrWyxTnxubZg1P/rb23ZqC2VNUmglSL6ZVLXra/Tlth/+MMfTOvVUGKhUNnxibbq1bhI4xelX6T9VWA6j7Xz+DY91r5oy9Bgjp83Grdp+ahgK7GCPX4au9mVb4HiFj23nA1c7EY/oZwrocajxCcAfInE9UGTD1qZqxX8ek9Sf/nLX0yFviZ4tNdDU3aPCye7Vb8tHN8R9Xpt9xBw3gO1t5N9HQ7mfQJpuu0tuf8NHDjQXOeVndxS3sqvPcVqrakz0UYymizR80wr2rVRi5ajboNW7kerXJrSXik2+9jax1VjN01QacLsrbfeMonUgw8+2CTtnn76aWntuagJJU08aA8z7aUVzGfRG2/74NyPSLNjOqXxsK1p3VikttvfekKJCydPnmx6lmmjID0255xzjuyyyy6ml5rdKy/Qc1ypqdLr//5PBnz/vfSfM0d6/POfkuooE8QWEkgIK7sVQtOu3M5KCl+ta5xfQO3ER9O/7edcfPHF5oamXVW1W7VmzrVCQm/u9vP99cYIdQi7UaNGuYMgZ8sG59/agiRctMJEKzf0xqg3GK1wsW/ydvdYTRLZwcRhhx1mWpRo+ditA/QGqq1plLb8UHrz1i7YelO3g2KlQVJLaKtgu0Wp9obS7dHkxCmnnOL3dfZxdB5bpd2RnY+Hawg7vUk1PWZ6Y7Rb5mjLH3vYHG+8vd75twaaGvA5t9seosf5o0G/3eqnaWWg3ZLD2d3YWRkYyjkY6v46P696jgBAoiBu8U4rLfTeFsw9x04OaYtGXeaMh3RoDf2/JoY0cWB/6dTWyzvuuKOpWDn11FPNMue9MNhYKFQnnniiaWWu90T9ImsPfRSo4Yvz/m7HKr5i1HAPYacJFqWxW7DD+wSKW5QeF21MYscWxxxzjNekVqAW7cG+V0viUeITIDHvwcGwXxOO7y729U7vZzqclLO1vd3QQIfM014D+jx76HVfnJWyTe8P2qjC23dE7emifN0LnNdr571HK33te2Og79DB8Lftwd7/UlJSwj5KizexVsfUmjoTPf46XJsOdacjmVxxxRVmuQ7vaw/BF61yCeXYaqMiPR/1c6Sxz+67727iOB0O0e5lHGwZNj0X7c+iJvW0nPRz88477wS1rlD2oSXHOJTX2MMnNk0mBepJFK7t9reeUOJCvfZqr0g9Z7SXpQ7XqT0XNf7T3orBPgfxgwQSwsr+Eqnjb2prQpv2irG7BOuFQr8g6uPa+tT+Yuwc9kS76mpFg95k7dYKeqHRFkHatVK7ROsYp9rtUQM8e0xVvaDZAZSzh4WupzX0JqxdopW2GNEfTULZ267jd2rr1abJKWeXWg0UdNv0x9mKxF5mtxzQv/Vmq13Z9War3YvtYVW0osX+oq3d3m3a1VlvOBpI2+OTKu3a63yult27775r1usc095+np3YaJqA8cXZYleDIaXj5jq3zRv7WOt5omPfaytV/W2P2xpoCJxQ2ZVTSsdb1TLW7dUvCU0fdyanmlY4qfvvv98MtaNBpT2fkXbJ1hutnp96jJSuXwMnPa56LHW8WmclSyTPwVD2t+nnY9ddd23xNgJAvCFu8R636D3Njj30Xqf3PL336T1Q6T1R742h0LjMrgzQxJAmE/T+r8PaNY1Hgo2FfN23fdGYxR6u47777jO/dQggu3WwL864RHvRaEtKHdfdjrk0dtJhisJNG35oTyylwwB56y3tTE7ZDZ/0Xm63OtYhBnV4QP3Rv5W2/NRzPysryyTzlFbC6Bwd5eXlZv80ttSkoB4rpet2ViDYrUuDfa9Q41FnfKIxkDaUApAY9+Bg2NeHSH930blw7Pue9lDSCnkdmisU9nc0deWVV8qyZcvMenVd+l3N+d3MVx2GXq/tOg8dYkrngtF7qCY37J4X4f4OHcn7n72fWhZNe5MEe1+PlzqmYOpMtJGpDrenMYn2OtLRZJr2BNL7sF0uvubXUXo8Bg0aZP7WnkA65KL2ENZKfB1aTo0fP97su9LHde4vfR97jqSmZRcMXYeWsSYHdOgzHZ7NbkCix9jumewsQ3vOsVA+i3rMNRbUhOY999wj4ebcPj2XAvXIcb5GzxONl/3RXkd2TKOfI21kpWXf2oSKc7s1xg6155oKJS588skn5cUXXzTHRYdX1jjdnvvIPmeDeU6sql27Vn4dPVrqHT3qE54FhNGCBQu0L7n5mTFjhsdjt956q/sx58/EiRPdzzn++OO9Pkd/Hn74YfOc5cuX+3xO7969rerqavO8WbNmNXv8tNNOa9W+5ebmen3fF154wf085/bdcsst7uVaHr62W3+mTp1qnvfzzz97fTw5OdmaNm2axzYde+yxPtc3bNgwd1m8/fbblsvl8rnezz77zL3Ovn37Njsu/lx00UUe63vuuec8HtcysB/TsrHLqHPnzl63R5c7n+etLFvi3HPP9fp+O+20k1VRUeF+3llnneV+zOmOO+7w+vqePXta69atcz/viSee8HucfbHPD3/7Gew5GMr+Oo9RYWGh1dDQEFK5AkA8I27xfa/Ve5ve47zdS+68806/5Wo/b//99/dYftVVV/m8P3br1s3atGlTyLGQr/u2L6+++qrHOv/whz94PO6M1+zYrKamxho/frzPbdI4q6VxlD/XXHON+32++uorr8/RbfQWe3/yySdWampqs+3VZZ9++qn7ed99952VnZ3t87g0jee9Cfa9QolHlZahPjZp0qQWliCAeL0H+7u263eZjIwM85h+92oJ+1od6N5xxhlnNLteDRw4sNl2+7oW20455RSf11nn/cJfHcacOXOszMxMr+sYNGiQVVRU5Hdf7Guq7nug7+u21t7/vN1T1UEHHdRsfXrvD/W+Hi91TIHqTJznY9P76A8//OC3LL356KOPvN6XnWWq++5rn0844YSA50fT4+2vvmvcuHHu17388svNHr/xxhsDHvvJkyf7/SzaZeKtnHzFut72rby83CooKPB4H42H/bn77rubbdtTTz3l83P3zDPPNHt+9+7d3X/reW2zl2nZ2HxdbwYPHtxsvbW1tSHtf7BxofNYNf15/PHHg35OJKzYd1+r7OOPrba0+vTTraIAn8t4Rw8khJW2NNDJ3ZR2vXXSobm026lmtLXFgA6hpeNvOlvkaGtF7dao69HHtZWPdufVdV166aXmOdp6Q7vA2kNvaGsgzeJryx1tpWlPuqytKrSFhY7panfDbO2+aY8SHXJDh3XRYTfGjRtnWv8EGvokFLpP2l1U90n3RTP02gpFu342neBZW+1qa2Edkkxb9WpZaCsg7X6tw8DYZaEtBbQFgbZ00dad2mpD16tj0n788cfuoWC0G7A9sbEOmRYM575riwVnaxlfdBt1smSdBFC7IGs3Wv19xhlnmOX2uPrhpOMKawsVbZGj5aItfnQ+BW3JY09s6Y+2uNKWSjrBpJ6beh7qOaetonXbbTo/gXbP3X///c15os/V4e20XLQFd1udg6Hsr92CTOehiOQwAwAQa4hbfNN7m97j9F6n9zy9n+k9UO+F9nCsodKWtzrEq8ZwGjPo/V/jHb3/63vZLXRDiYXsYYx0PshgaG8jbeFrCyaG0/hKY8wbbrjBtOrV/+t9WFvnaotnjbPCTVtr2r1zNCbTYWBCoTGfbpu2+NR4Wn/0b3uZsweAxl46lI4ONaL7pjGDPkePVTC9p4N9r2DjUaWtxLWVu3L2OAOQGPdgf7QlvPa60e80OhJEJOncbHof1GuWDumlc7Bcf/31Ia9HW+HrHDt6/9Pv7dr7Q3tonn/++R49D/zVYey2227y9ddfm++Ver/Ue6g+T7/769D1TXtxhkOk7n9aFjriiT16R0vFSx1ToDoTHaZX74H2fVh73mp9gg5hp7FXqA488ED3uaLrsvdHezPbdN+1h5IOGazno5aN1itpHcIrr7wS8nvq+aHns5azXQ+i9Tq6TOsrbLoNOkRfoFFrmtJzULdZP4e6/nPPPbdFc3kHosdHe97oftjHPRA9fhrLBjuMpM4FpHM/6nB2eh3T+h2tv7H5m5/bHx31Rq8TwdRv+RJsXKi99DSm1s+CXtP0mOjn55FHHpELL7ww6OdEg1VXxzybLeDSLFJLXgj4ojdovdjomMY6TrC/uWUQW3S8X01IaJda7ZLd2oAOsU+76evQD/o51e7mDBEDINEQt8QvHU9fK310yBqdb6k1Q8UituhwiX/+859NBY5OmB2OxmAA2sc9WCskNRmtjeN0GHQAiCc6zJ0OwWcPwalTDWhCzJ7vSocCbkniMFY1lJXJ5vvvl4oZM6S+pETS+veX7o88ohlq2XTHHVI5e7YkaWL96KOl42WXiSslxSz7/ZJLpNO118qWRx4Rq6pKco8/Xjpdc41ZZ+2qVbJx8mSp1mEQk5MlbcAA6TF1qmy49lop/+gjcWnyT4c7PPJI6XL77fLLkCHSefJkKZk2TWpXrJD+X38tpa+9JqWvvCJ1GzdKcqdOkn/22ZK3Ldlbu3q1/Lb//tLvm28kOTdXNlx3nU4gJVZ5uZR/9pmkdO1q1ps5bpxs+tvfpOS558z7uVJTJWPXXaVw2zCZ7QmROMJOW4ZqS0ltOfj8889TwnHEHmdfWz+QPEoM9hwQ+gWM5BGARETcEt8NX3Rc/6uvvprkUTtLDNqtirVlPskjoP0K9R6s8wbpHGrawn7y5Mltso0AEE4699eYMWNMzy/tnaO9se3kkY5o056SR0qTL7UrV0rPadOk/7ffSpc77hBXerps+POfTbKo7yefSOFLL0n59OlS7Ei8NJSXS82yZdLno4+k58svS8nLL5vEktryj39Iap8+0u/rr6XfzJkmseRKTpbuDz0kKYWF0u3++2XA3LkmyWPb+u67UvjMMzLg++/FpSMhFBZK4XPPSf/vv5eud94pm++9Vyq/+87nfpS9/77kTppk9qHD0UfLhm29UTtfd51kjBkjna6+2rxne0weqZRobwDaHx0Ca+7cudHeDLSAdgvWHyQOHQbROYE5ACQa4pb4pRNfM5hC+6PDMq1cuTLamwEgBu/BQ4YMMcOuA0C80qSRDv+oDaHWr19vhnfToee0F1J7G7a3btMmKf/4Y+kzY4akdOtmlqUPGyZ169dL5ddfS9+ZMyUpO9v8FFx4oRQ98oj5bViWdLzySklKT5e0gQMlY/RoqV640PT60d5A2nOods0aSevXTzKCGIWg4Lzz3Nugcg4+2P135u67S+Zee0nVnDmSua1nWFPZEyc2vreIdDj+eNny4INSX1QkyS0ccjDekEACAAAAAAAAACCC+vbt6zEvVHtWt3atGU4utbDQc/nvv5teSCmOeaNSe/c2y21JOTmS5JjPyZWZaXolKe1xVPTww7JOE24ul3Q49lgpuOQScfkZ8jilybxbW//zHymeOlXq1qzRCeGloapKUnv18vn6ZMe26rYo3R4SSAAAAAAAAAAAACHQYeKsmhqpW7fOI4GT0r27WNXVpoeSnUTS3kS6PKj1duokXW691fxdvWSJrDvnHEkbPLixV5HL5f1FjuRS7dq1Zmi9Hk8/LZljx5qh9NZdfLHp9dQiLh/v2Y4wBxIAAAAAAAAAAAgLTQ5l7b+/bLzlFqnbsEGshgap/ukn0yspY9w42XzPPdJQUWESOsVPPCEdjjkmqPXqfET6Gh3KOjk31ySHdA4ku6dQ7W+/+X29VVFhkkXJHTua15Z//rlUzpzZqv2sXbVK2jMSSAAAAAAAAAAAIGy63nOP6Vm0+vjjZfmYMSaZpL2Puv397+b3yn33lTWnnCJZEydK/nnnBbVOnQtpzaRJsnz0aFl98smSe8IJJlGlCi64QEpefLHxvbb1UmoqbdAgM9fS2rPOkhXjxpmEVPZ++7V4H/POOksqZ80y77nuggukPXJZzDwLAAAAAAAAAAAAB3oghVlVVZUsXLjQ/AYAAIg1xCoAACCWEasAABA7UqK9Ae3NL7/8IiNGjJCvvv1Bdhw23OtzSoq2SF5BR6+PVdTUt+h9a+oapKU65aRJNGytqvP9WEmRdMgr8PpYflZqi99zXXHLE3slFbUtet2gbjktfs+UZP8TsRVt2SwFHTt5fWz2r1ta/L498jJb9LolG0tb/J4HDu3W4tf629e6ilJJycr1+tiInnktfs/s9MbxVVvisrcWtvi19x4+tEWvCzQVYGnxFsnN935dSk9peVuDLeUt+9yoTaXVLXpdC6c9NHbt5/1cAdpjrPLdvAUybPjwkO4toJxCFWvnU119y2PmlOSkhCgjVTD+Ty1+bdFX94d1W2K5nKIhg2/wSKBYZcGCBTLcS6yC0GzevFk6deL6GWmUc9ugnClntD16IEVBg9XyL66JQidWQxDlZLWmqjxB8HkLSgOfOQBcD0LCdZNyChfOJcoJACKJ+0zboJwp5/aE8xlOJJAAAAAAAAAAAADggQSSiFRXV8u1114rhYWFkpmZKePGjZOPP/7Ys6QAAACihFgFAAAAAAC0NRJIInL22WfL/fffL6eddpo8+OCDkpycLIcddph8+eWXbX5AAAAAmiJWAQAAAAAAbS3hp+CcM2eOTJs2TaZMmSJXX321KZQzzzzTTNh4zTXXyKxZs9r8oAAAANiIVQAAAAAA8TRne/n06eJKSpLs/feP9uaglRK+B9Lrr79uehydf/757kLJyMiQc889V7766itZtWpVa8sYAACgxYhVAAAAAADxoG7DBll/6aXmp+aXX6K9OQiDhE8gzZ07VwYPHiy5ubkeBTN27Fjze968eeEoZwAAgBYhVgEAAAAAxHqvo9I335RVhx8u1YsWSY+pU6XA0WED8Svhh7Bbt26d9OjRo1nB2MvWrl3rs/A2bNggGzdu9Fi2bNmyCBwmAACQqIhVAAAAAACxqnbNGtl4881SOXOm5J1+unS86ipJys6O9mYhTBI+gVRZWSnp6enNCkaHsbMf9+Wxxx6T2267zetjpSVFUrRlk9fHykpLfK6zurZBWqK2vmWvU67qVImGypp6n4+Vl5X6fKyhsuWnbVlZTYtfW1VV16LXFaVUtfg9k5Ndfh8vLfF9LtWV+y7DQMrF93nvj1VZ3uL33LI5ucWv9bev9VVlPh8r3lLb4vesTmv59nZytax8VbGP60ogVoDHy7b6PpdSk1veWXVrCz83qqqiNiL76p9nb1SgPccqxcVbZPMmz4Ywge4toJxCFWvnU31Dy+8SyUn+47L2UkZqWN/8Fr/W23WlvZZTNPTs3iXamwAAAGBYDQ1S+sorsvm++ySlWzcpfOklydx1V0qnnUn4BFJmZqZUV1c3K5iqqir3475cfPHFcuKJJzbrgXTMMcdIbl6BFHTs7PO1vh6r8JNU8aemruUJpI45aRINgSqWcws6eV2en9XyhFd1csuTOfWpLavMLuiU0+L3TAmQQFIdO3k/l1JKWl7pn53n+7z3x1XT8kuKr/0IRqB9Tcn2XgmS3zGvxe+Znd7yBNJma32LX5vv57rij9WKdaentGK00/JWJOmSml+bI59AAhInVsnP7yidOnuviPS1HJRTS8TS+VTXikZXKa1oUBFPZaR+Wlkck/sSa+UEAACQqGpWrJCNN90kVd9/L/nnnisFl14qSV4aPiL+JXwCSYeqW7NmjdfhYlRhYaHPwuvatav5AQAAiBRiFQAAAABANFh1dbL+z3+W/LPOkoxddhGrvl5Knn1Wtjz4oKT26ye9/u//JH3ECA5OOxa5ZnRxYtSoUbJ06VIpLfUcAmv27NnuxwEAAKKFWAUAAAAAEAmWVS9WzSqxqhaJVb1YrNp1HmO7lL76qpRPny5J+flSvXSprDn5ZNn8wAOSf8EF0uv110keJYCETyCdcMIJUl9fL08++aS7UHSYmKlTp8q4ceOkd+/eUT1AAAAgsRGrAAAAAADCnjiqnCdS+qZIxeciVd+JVH4rUv6JFKR8YZJJdUVFsuWhhyTv1FOl7P33ZfVxx4m4XNL7rbek4yWXiCstOtOioG0l/BB2miTSuQGuv/562bBhgwwaNEiee+45WbFihTzzzDOcjwAAIKqIVQAAAAAA4WJZdSJln4jUb/T6eJJUmmRS0f0z9clSMWuW1K1aJZ3+9CfJO+sscSW3fF5wxJ+E74Gknn/+ebnyyivlhRdekMsvv1xqa2vl3XfflQkTJkT7+AAAABCrAAAAAADCo+Irn8kj5XKJVP20Vkpf+1QaSktMEinvjDOkdvVq2XjLLdJQXc2RSCAJ3wNJZWRkyJQpU8wPAABArCFWAQAAAAC0llVfKlK7MuDzNt71jnsqpNoVK6TsvfckpUcPSR00yCSUkDhIIEVIcnKSpCR77+CVnOT7sdzMlnUKW7SmtEWva9weV4tf2ymn5WNd3vbxzz4f6+iqkC3WFq+P3XnIkBa/Z9fc9Ba/NiejZR+XovKaFr9ndoD3rKqtl4qaeq+PZbSiO2lhfkaLXterY2aL37O+oeU3n9VllT4fS66qkXrL++Pj0ju2+D3nrSxp8WsfOmZ4i19bXFHbotflZ6X6fbwyJVkyU72fMwtWt/z6kp3eivOwoGXn4dzVxS1+T5HcVrwWQHtTsO/NPh8b1jtHflpV5vWxohm3R3Cr0Bq+YvBIswJ8yfb1uEubf0ZB0Vf3R+V9E0WVj/g9GBkpDBkDAABaocZ3faxT1zuOk7o1RZI+uJsk9zpAkrJbXh+L+MYQdgAAAAAAAAAAtHd1m4J6WvqALpK992BJ6ZYnLldRxDcrnv3vf/+To446Snr37m1GD+nevbsccsghMnPmTGkP6IEEAAAAAAAAAEC71xD6S6wWvCaBLF26VJKSkuTCCy80yaOioiJ58cUXZcKECfLee++ZZFI8I4EEAAAAAAAAAEB752rBdAFJLZtiIFGcd9555sfp4osvlgEDBsg//vGPuE8gMYQdAAAAAAAAAADtXVq/0F+T2jcSW9KuZWVlSZcuXaS4uDXzdMcGEkgAAAAAAAAAALR3qX1EXOnBPz+5s7hSOkVyi9qN0tJS2bRpkyxevFhuuOEGWbBggey///4S7xjCDgCAMFm7dq0Z67a1CgoKpLCwMCzbBAAAYCNWAQAgsblcyWJl7S5S/nkQz04RyRon8Rir1NfXS3JycrPl2iuoa9euEgknnXSSfPjhh+bvtLQ0ueCCC2Ty5MkS70ggAQAQpiCnZ+9+Ig21rV5Xhw4dTIsVkkgAACBciFUSU3V1tdx8883ywgsvmAq5kSNHyp133ikHHnig39ctWbJEnnjiCZk9e7Z8//33Zj3Lly+Xfv2aD32ky1auXNlsuVac6ToAALHFldpbrKwJIhUzNdUilqWJpaZPShfJ3ldcyQVtGqsM7NlbqqSh1evSBE5NTU2z5bfccovceuutPl/X0NDg9XXepKeni8tRcH/729/kz3/+s6xatUqee+45s566ujqJdySQAAAIA9NCpqFWUvsfLq70vBavx6ouka3L3zPrI4EEAADChVglMf0/e/cBJkWVNWD4TGISDMMMWbLkJCrB5WdRMAKKqGBYFVFMi5EVQVBEFCNJlEVFkbguKuawayIYQFBEMYEECZJhApPz/5yL3Tuhe0JVz3T63n1qR6rqdvUUA32pc885o0aNkhUrVsjdd98t7dq1k0WLFsngwYNl1apV0q9fP7fj1q1bJ88884x07txZOnXqJN9//3251+nRo4d5aFZc+/btPfZ9AAA8K6RWCykKbyiSu0Ny0rZIRGjWiYydsLqSltNE6iR2k5CQ8Bqfq2jw6J6QptJIIiy/ziHJk5m5++Xtt9+Wtm3blslAKs/nn38uAwYMqNR1fv31V+nYsWOJz0KHa665Rk477TTn57A/I4AEAIAHhUTFS2i09frAhWWW/QAAAHgOc5XgsWHDBlm+fLlMnz5dxo0bZ/aNHDlSunbtKuPHj5e1a9e6HTt06FDT+Fsz42fMmFFhAOmkk04yD8sAAP4jJDRKJKqLfPtTqBw8kiojBp1h9udkH5G4Gg4eFdckNEKaV6VPUymhRSaxygSPunTpUqWxGhBauHBhpc5t0qRJuRlQ+lmqWUlZWVkSHR0t/ooAEgAAAAAAQIDRFc+6mvzmm2927ouKipLRo0eb5t5aYqd58+YuxyYkJFT5elqqJy8vT2JjY229bwBAzUrPyJY6sVHcdhFp3LixyRryhKysLCkqKpK0tDS/DiCFevsNAAAQUEJC7W8AAADMVWDTpk2bTBm5uLi4Evt79+5tvlaUVVQVK1eulJiYGKldu7bpiTRnzhyPvTYAoHqlZ+ZI7RjfCSCFhoiEhtrYariwy+HDh8vs0yzeN954wyzUaNiwofgzMpAAAPAknajYKUNHBTsAAFCdmKsEjQMHDrgsr+PYp83KPaF79+6mn1KHDh3k2LFjps+S9lzS13/yyScrfOh25MiREvu2b9/ukfcFAKic9MxsifWhAFLIn4Egy+OlZg0aNEiaNWsmffr0McGiPXv2mDJ4+jn46quvir8jgAQAAAAAABBgtHROZGTZHhJaxs5x3BPefffdEr++/vrrzcO0WbNmyR133GEeqrkzb948mTp1qstjSUlJZYJLqLrU1FRuWw3gPtcM7rPnFRYWSWZWjhQV5Dr/zrVznxs0aCDB5oYbbjA9B2fPnm0yj+rVqydnnHGGvPLKK/LXv/5V/B0BJAAAPMluGTpK2AEAgOrEXCVoaL+FnJycMvuzs7Odx6tDSEiIjB07Vj766CNZvXq1XHPNNW7PHTNmjIwYMaJMBtKwYcNMH6ZgfBBZHbiP3OdAws+zZx1PP7GYoEnjBtKgQT2fuM+mhJ2NNKKaLmF32223mS1QEUACAMCjQuyVsKOGHQAAqFbMVYKFlqrbt2+fy9J2qmnTptV2be354MgiKo+W+vH33hAA4M8yMk8sKvCpHkg2S9jRWdqzCCBVkx0H06Uo7rjLYznpGXIgq5bLY51PqmPpep1PKtkUsyquWfqd5bH/Gnma5bGzhnZ2eyzp2FFJSKzv8pid57KFRdbHxkZa++MSGW79r63QCr7ZiNBQqRXm+vVPaVnX8nU3/p5iaVyL+jGWr7njcLrlsZd1P8nSz1J6dr7la3ZtZv3PnJ2f4XqxEZbGfber/N/T3Ix0qZXu+me8R8t48caqj4Ted1gad2z9s9YvCgDFJK962P3fNUePSGJ9VkWj8qvx7RyHb6rX63ZL45K/mevx9wK40qNHD1m1apUcP35c4uL+9++X9evXO49Xl507d5qvZAoAgO/3P9KpaGx02ZKngCIgBwBAdZSFsbMBAABUF+YqQWP48OFSUFAg8+fPd+7Tknba2FsbfTuyhLTZ95YtWyxdQzOM9BrF5eXlyRNPPCG1atWSAQMG2PwuAADVHUCKiY6UUDspPx6mAS1HFpKVjbVZnkUGEgAAnqSLyO3MVliEDgAAqhNzlaChQSLtLzRx4kQ5fPiwtG3bVhYvXiy7du2SBQsWOM8bOXKkrFmzRoqK/leyQxuoP/vsicz+r776ynydO3euxMfHm+32209k4L377rsybdo0E6xq3bq1CShp0/CffvpJHnvsMWncuHGNf98AgMpLz8j2qfJ1HilhZ6MCFcoigAQAAAAAABCAlixZIpMnT5alS5dKcnKydO/eXd5//33p379/ueP0XB1X3MyZM83Xli1bOgNI3bp1k86dO8uyZcvkyJEjJutIS+O99tprJngFAPD9DCRfCyDBtxBAAgDAk+yWoaOEHQAAqE7MVYJKVFSUTJ8+3WzurF69usy+Vq1alchIcuf00083WUgAAP8NIDVpUE98CRlIvoUAEgAAnqTl62yVsKOGHQAAqEbMVQAAQPESdi19KwPJ0QPJ8vhCT74bEEACAMCTWNULAAB8GXMVAAAgIgUFhZKZnSuxsVGBlYFkYyzK4nYCAAAAAAAAABBEMrJyzNc69EBCOchAAgDA0yhDBwAAfBlzFQAAgp72P1K1fSyARAaSbyGABACAJ1EWBgAA+DLmKgAA4M/+R7qmJCa6lo/djxAJsbXYhd7SnkQJOwAAAAAAAAAAgiwDKTY6SkJpGoRykIEEAIAnsaoXAAD4MuYqAADAEUCKifS5e0EJO99CAAkAAE8KDTmx2RkPAABQXZirAAAAEcnIzPa5/keKAJJvoYQdAAAAAAAAAABB1gPJFwNI8C1kIAEA4Ena6FFLw9gZDwAAUF2YqwAAgD9L2NWOjfLJqYqdtkw8VvEsAkgAAHhUiM0gEAEkAABQnZirAAAQ7AoKCiUzO9cnM5AoYedbKGEHAAAAAAAAAECQyMjKMV99MYAE30IGUjWJiw6XerERLo9l5IdLrJtjOfmF1i5YJJZddXoTy2OXbNxteexvh7PdHqtblCmpIcdcHru8S2PL1+zSLM7y2ONZ+ZbGHU078ReyFa0axFb42+7utz6vwPoPRbfm1u5TrXDrMenIcOu/N4VF5R9zd3zKx9ssX/OpCzuKN5T3vZany0nl39/kpFypl+D6nFyrfy+JSFpWnuWxf3z5tPglLV9nq4QdazsAX5GVW+D2mP7d6O74/uQsy9c8uVFty2MReE6+8y3LY3c8c4lH3wvKSv5mrn/eFuYqAAAEPS1f56sBJDKQfAsBJAAAPN5XwEYZOor1AgCA6sRcBQCAoJeekS0hISESEx3pc/eCHki+hQASAACeRGNqAADgy5irAAAQ9DQDKTY6UkJDfa8PMxlIvoU6OQAAAAAAAAAABFEAyRfL18H3kIEEAIAnURYGAAD4MuYqAAAEPZOBFON75esUGUi+hQASAACeRGNqAADgy5irAAAQ9LQHUtNG9XzyPpgeSLSW9hmUsAMAIEDk5OTIhAkTpGnTphIdHS19+vSRTz75pFJj9+3bJ5dffrnEx8dLXFycXHzxxbJz584y5z333HMyYsQIadGihWm4OWrUKJev99lnn8kNN9wg7du3l5iYGGnTpo3ceOONcuDAAdvfJwAAAAAAsJeBVIcSdqgEMpAAAPCokBPLZeyMt0iDOStWrJC7775b2rVrJ4sWLZLBgwfLqlWrpF+/fm7Hpaeny4ABAyQ1NVUmTZokERERMnv2bDnzzDPl+++/l8TEROe5Tz75pKSlpUnv3r3LDQZpICspKckEm/S9aDBq7ty58v7775vXbNy4seXvEwAA+OdcBQAAeF9BQaFkZedKrI8GkDT7SMvY2RkPzyGABACAx/sK2JjpWHygs2HDBlm+fLlMnz5dxo0bZ/aNHDlSunbtKuPHj5e1a9e6HTtv3jzZtm2beY1evXqZfYMGDTJjZ86cKY899pjz3DVr1jizj2rXru32NWfNmmWCVqHFZn0XXHCBCUppIGnatGmWvk8AAOCfcxUAAOAbMrKyzdfasT4aQAq1GUCi5ppHcTsBAAgAmnkUFhYmN998s3NfVFSUjB49WtatWyd79+4td6wGjhzBI9WxY0c5++yz5bXXXitxbsuWLU3wqCL9+/cvETxy7EtISJBff/21it8dAAAAAADwVP8jVdtHM5D83U033WSem1x44YUSCAggAQDg8VW9NjcLNm3aZPoNaf+i4rTUnNKyca4UFhbK5s2bpWfPnmWO6dgdO3aYknWeoKXydKtfv75HXg8AAPjPXAUAAPhO/yMNcMRERYov0kTpUBubnURru7799lvTTkAX9AYKStgBAOBJOlOxVRbmxNjt27eXOdSgQQNp2LChy2Haj6hJkyZl9jv27d+/3+U47VOUk5NT4dgOHTqIXU8//bTk5ubKFVdcYfu1AACAd+cqAADAfwNIsdGREuqjzYJCQ0JsvTcd7w1FRUVy5513mnYCn332mQQKAkgAAPigYcOGldk3ZcoUeeihh1yen5WVJZGRZVcPOVa96HF345SVsVXx+eefy9SpU+Xyyy+XgQMH2n49AAAAAABQdemZOT7b/8ifLV26VH766Sd58803CSABAIDqbUz99ttvS9u2bctkILkTHR1tMolKy87Odh53N05ZGVtZW7ZskUsuuUS6du0qL730kq3XAgAAvjFXAQAA/tsDyZf7H4WEhZjNzvialpaWJhMmTJBJkyZJ48aNJZCQew4AgA/2FdDgUZcuXUps7srXOcrNaRm70hz7mjZt6nJcQkKCyT6yMrYy9u7dK+edd57UrVtXPvzwQ6lTp47l1wIAAP7dA0kXrOjDFZ1b6AKVPn36yCeffFKpsfv27TOZzPHx8abn48UXXyw7d+4scY5mTY8ePdosWtG5R+3ateWUU06ROXPmSF5eXolztT+B9n9wtR08eNDy9wgAgD+UsPPpAJJZ6xJifftzqqKtAX7++ecS2+HDh6vlPT/88MNmbjN27FgJNJSwAwDAo+x2bLQ2tkePHrJq1So5fvy4eajisH79eudxl1cLDZVu3bqZRo+l6dg2bdpYDvocO3bMBI/0YZHW/3XVZwkAAATHXEWNGjVKVqxYIXfffbe0a9fOBHEGDx5s5jD9+vVzOy49PV0GDBggqampZmVvRESEzJ49W84880z5/vvvJTEx0RlA0odD+pqtWrUy85y1a9eahzk6r3nllVdcPvBp3bp1iX0apAIAILADSGXL2PsKRyDIzngrrQFUYWGh6d1cGZGRkWbhyW+//WYWq/z73/922R7A3xFAAgAgAAwfPlxmzJgh8+fPl3Hjxpl9GrhZuHChWd3bvHlzs2/Pnj2SmZkpHTt2LDH2vvvuM0Gknj17mn1bt26VlStXOl+rqjIyMszDG10trA+F9CERAAAIXhs2bJDly5fL9OnTnfMLbTKt2ULjx483gR535s2bJ9u2bTOv0atXL7Nv0KBBZuzMmTPlsccec2ZWf/311yXG3nrrrSYbae7cuTJr1qwyZWX0dRzzHwAAAl1BQaFkZecGRQ+kqrYGcPRv1kUrlfHrr7+aZyt33XWX9O3bVy677DIJRASQqkmjulHSLMF1z4ikokhJcHMsI6fA0vXe+OkPseqK7iceKlrxw95Uy2PPauW+FFNGapLE1k1weaxBnVqWrxlqp9xCfqGlcbXCra/Qm/tVyZIMpcXkZ0hm+HGXx8b2P9nydYuKrN2nT7YcsnzNMBu/N/1Oru/2WEFhoeQXuP69mzjAzj2yPFSy86z9LKmoCGs/Txk5+eUez84rcHtOXHSEWPXdvmTLY8/raK1mbKiNVSoeYbO0i9WxGiQaMWKETJw40aRk6yRp8eLFsmvXLlmwYIHzPH1Qs2bNGikq9kM8ZswYefHFF2XIkCHmgY6u6tUHLI0aNZJ77rmnxHXee+89+eGHH8x/aymYzZs3y7Rp08yvhw4dKt27dzf/ffXVV5uHPDfccIOZVOnmoOVkXK0EQmAb//7/fgaq6qkLO4k3RNcKc3ssMzzU7fGTG9WWYOHuM9ahoLDI7TnhYTVfTXvih1ssj3188P8C7zVlxzOX1Pg1EQS8NFfRzKOwsDC5+eabnfuioqJMyTnNKtKyt44FL67GauDIETxS+sDm7LPPltdee80ZQHJHs5FUSkqKy74E2rcgJibGvD8AAAI9+0jF+nAJO7HZA0nHF28NUBU6v9CFuJXRpEkTs/D2v//9r7z55pvm+YtDfn6+yYzWfbrApXilGH9DAAkAgABpTL1kyRKZPHmyLF26VJKTk00w5/3335f+/fuXO05L1K1evdqUd9FgkKZsn3XWWaY0TOnVOW+88YYJTDls2rTJbKpZs2bOAJKWk1Evv/yy2Ypr2bIlASQAAIJsrqLzhfbt25d5gNK7d2/n3MFVAEnnJbpgRRellKZjP/74YxMAKl5yV0vPaFlffXCjGdaapa3zj9KrkJWuMtYSebVq1ZLzzz/fZDSROQ0ACFQZfwaQ6vhwAMn0JLRTws7GcxVdaKIldytrz5495uull15a5phWZNEyufpsRcv3+isCSAAABAhdxatlYXRzRwNFrmjw5/XXX6/wGtqrQLeKFF95AwAAAo82pi5NF540bOi60sSBAwdc9kN07Nu/f7/LcUlJSaYsb0VjO3To4Nyvq4Cvuuoq56+1RJ0uaAkP/98jEM040gdEGkDSoNbGjRtNBraWoPnuu+/cZkMBAODP0jKzTYWm6KjA69XjDQMHDpS33nqrzH7NuNbFK/fff7/pO+3PCCABABAAZWEAAABqcq5S1cbUmg3kqrG0LoBxHHc3TlVlrAaFPvnkE1Oy7rPPPjPld7U/Y3GXX3652Rz0+9EMJM3cfvTRR+X55593+X4AAPD3DKSYmEjvl/8vR4jNEna2yt9VUYsWLcxWmmYcaVuAQCjfTwAJAABPp1rbeChjZywAAEBNzVWq2pg6OjraZBKVlp2d7Tzubpyqylh9YKObGj58uOmRdO6558q2bdtc9kBy6Nevn+kr+emnn7o9BwAAf5aeke3T5euUZkjZCXDpeHhOzXeuBQAAAAAAfs3RmLr45q58naPcnJaxK82xr2nTpi7HaeNpzT6yMtZBg0ja5+idd96p8PvS0nVaNg8AgEAtYRfr4wGkQLBr1y7TkzoQEEACAKAaVvXa2QAAAAJtrtKjRw/57bff5Pjx4yX2r1+/3nncldDQUNM74Ntvvy1zTMe2adNG6tSpU+61HSXuUlNTK3yfO3fuLDeTCgAAf5aRmSO1fTyAFBKqW4iNzdvfQWDhdgIA4GkhNjYAAIAAnKtoFlBBQYHMnz/fuU/L0i1cuNCUjdPMH7Vnzx7ZsmVLmbHffPNNiSDS1q1bZeXKlTJixAjnvqNHj0pRUVGZa7/00kvma8+ePZ37jhw5Uua8Dz/8UDZu3CgXXHCB9W8UAAAfL2FXO9a3A0jyZw8kq5uOh+fQAwkAAAAAAFQrDRJpsGfixIly+PBhUwJv8eLFpsTLggULnOeNHDlS1qxZUyIQNGbMGHnxxRdlyJAhMm7cOImIiJBZs2aZPkf33HOP87xly5bJ888/bxpWa2ZSWlqafPTRR/LJJ5/IRRddJAMHDnSe27dvXzn11FNNUKlu3bry3Xffycsvv2wCWZMmTeKnAQAQcPILCiQrJ9fnM5DgWwggAQDgg42pAQAAAm2usmTJEpk8ebIsXbpUkpOTpXv37qY/QP/+/csdpyXqVq9eLWPHjpVp06ZJYWGhnHXWWTJ79uwS5eb69esna9eulX//+99y6NAhCQ8Plw4dOphg0x133FHiNa+44gr54IMP5OOPP5bMzEzTo+mmm26SKVOmmMAUAACBWL5O1Y6JFF8WEhIqIaGhtsbDcwggAQDgSXb7GBFAAgAAATpXiYqKkunTp5vNHQ0UudKsWTN5/fXXy319zSZ67bXXKvVeNBClW6DTMoEPPvhgiaCdft/nnntuueO0RKBmc2mfKc3O0tf5/fffpVWrVuWO27Fjh3Tp0sWcr2UHi5cNBAB4V3pmtvlaOybap38rnKXobIyH5xCOAwDAg/SZir3G1Px2AACA6sNcJbiMGjXKZGBdffXVMmfOHAkLC5PBgwfLl19+We64devWyTPPPGPKAHbq1KnS19MsMc38AgD4Zv+j0JAQiY6qJb7MPBsJtbHxYMWjCCABAAAAAAAEmA0bNsjy5cvl8ccfN1lfN998s6xcuVJatmwp48ePL3fs0KFDJSUlRX788UcTfKoM7TelmwaRAAC+mYEUGxMpoaGsXEXlEUACAMCD7GUfsVIGAABUL+YqwWPFihUm40gDR8XLCI4ePdpkGO3du9ft2ISEBNN7qrLy8vLkrrvuMtvJJ59s+70DAKongFQ7Jsrnb622MLKVgUTEw6O4nQAAeFKIBzYAAIDqwlwlaGzatEnat28vcXFxJfb37t3bfP3+++89dq2nn37a9Fh64IEHPPaaAIAgDSD92QPJzgbPoTAtAAAAAABAgDlw4IA0adKkzH7Hvv3793vkOgcPHpRHHnlEZsyYUSZYVZHDhw/LkSNHSuzbvn27R94XAKBsD6RmjRO5LagSAkjVpLCoSAoKi1we0/3ujmXk5Fu6Xu8mCWJVuI2o7Omt4i2P3bgrxe2xvIxcSZNsl8caxkVavmZ2XoHlsY3rWruuu9/ryritb+tyjycnHZV6CfVdHsvJL7R83eNZ1n4OT29Wz/I1l33/h+WxZ7Zr4PaYNgcMc1PbNcLGz35atrV7pI5n5Vkeuysp09K4v7Qp/++IvFphUjvK9UfCqm2Hxaqtx6y9XzXQ4p+dLBu/N1FxEWJXiNhr2KjjgUD01IWVb8AN/xEeVn5BA/0MruicmvT44I6WxxbamNNRZ9531Tvjbstjk79+WvwRc5XgkZWVJZGRZf8dq2XsHMc9YcKECdKmTRu58cYbqzx23rx5MnXqVJfHkpKSygSXUHWpqancthrAfa4Z3Gd70jKyRIryK/y71c59btDA/TO6ytJnKnbmz3aeyaAsAkgAAHiQ3T5GTHQAAEB1Yq4SPKKjoyUnJ6fM/uzsbOdxu77++mtZunSpfPbZZxIaWvUFA2PGjJERI0aUyUAaNmyY6cPkiQeR8MwDXVSM+1wzuM/W5BcUSE5uvjRuWL9S99Cb99nRy8jOeHgOASQAAAAAAIAAo6Xq9u3b57K0nWratKnta4wfP17++te/SuvWrWXXrl1m39GjR53X2bNnj7Ro0cLt+IYNG5oNAFC9MjJPLCjwhx5I8C1BH0BavXq1DBgwwOXNWbdunZxxxhk1/psCAPBfrOqFpzFXAQB4EnOV4NGjRw9ZtWqVHD9+vERvovXr1zuP26UBot27d5sAUmlDhw6VunXrSkqK+/L1AICa63+kasf6fgDJZCDZaDtBBpJnBX0AyeHOO++UXr16lbg5bdu29fDtBgAEPJsl7HQ84ApzFQCARzBXCRrDhw+XGTNmyPz582XcuHFmn5a0W7hwofTp00eaN2/uDAJlZmZKx45V7xOnr61ji1u5cqU8++yz5tpWXhMA4Hnpmdmmr1BMVC2fv72UsPMtBJD+pCnXOrkCAADwRcxVAABAVWiQSPsLTZw4UQ4fPmwWyS5evNiUmluwYIHzvJEjR8qaNWukqKioRAN1DQKpr776ynydO3euxMfHm+322283+84777wy13VkHJ155pnSs2dPftMAwEcCSLHRUfRdRpURQComLS3NNJEMD+e2AAAs0gQiO0lEJCChHMxVAAC2MVcJKkuWLJHJkyfL0qVLJTk5Wbp37y7vv/++9O/fv9xxeq6OK27mzJnma8uWLZ0BJACA/wSQasdEij8ICRWbJew8+naCHrfzT9dff72pCRwVFWV6In377bdB/8MBALD4TObP0jCWNm463GCuAgDwBOYqwUWfcUyfPl0OHDgg2dnZsmHDBjn//PPL9Fssnn2kWrVqZfa52jSDqTyjRo0y55F9BAC+1QPJH/ofGaGhEmJj0/HwnKBPtalVq5ZcdtllMnjwYKlfv7788ssvpk6vlolZu3atnHrqqW5vnqaAHzlypMS+7du3e/C3BwDgb2hMDU9jrgIA8CTmKgAABGcGUvMmieIP6IHkW4I+gNS3b1+zOQwdOtT0QtK0bq0T/N///tftzZs3b55MnTrV5bHUlGRJOnbU5bG046luXzMtK0+syM7KF6uSIrLFG/Iy0t0eK8h2fywlydo9UqVXVVVFVkSYpXEFhdavWVjB+00v52fJ+lVFMnMKLI0LtZE6EZPv/ve8Iu7+rFX05y0r19r3qWz8KElmrvU/r4WZOZbGJScVWv9ZynJ/rCIx+db/fkku5/e1PDn55X+v5WkU19jyWMDf5iopKUly7GjJhTDqeKr1P/PBhPsUfPfJzmd/SEhw3KPqVF33qXPLeMtjXf0dWt1Oatygxq8JAAACpYSdn2QgwacEfQDJFW0sefHFF8ubb74pBQUFEhbmOnAwZswY05CydAbSsGHDpG58PUlIrO/2xrs7VpSeK1bkhVsbd+K91BZviEgr/8cvItb1P+biE+p6JYAUXavmA0iVGVsvwc3PkuWrioRZDEjaKE8qmeFZlseW92etvOPp2TYCOXZusMVAsQrNz7Q0rl5CQiXOcX2fQpKsf7OZGdY/ZupV8PtaHYFBT2BVL/xlrhIfnyCJ9V0/iHS3H9wnKwLl56nQxod/aAWrbALlHlW36rhPv+xOsTzWX3/fmKsAABBc8vMLJDsnz28CSDp3DrXxkLGiuTeqhgCSG82bN5fc3FzJyMgwvZFcadiwodkAAHCiMTVqCHMVAIAlzFUAAAgq6VknqsP4Sw8kStj5FjpKubFz507TbLJ2be9k5wAAAJSHuQoAAAAAoCLpGScCSLF+koEE3xL0GUhHjhyRBg1Klh744Ycf5N1335VBgwZJaCgxNgBA5VEWBp7GXAUA4EnMVQAACC4ZmTmmrFtMVC3xByGhIiE2StjpeHhO0AeQrrjiComOjjbNqbUc3S+//CLz58+XmJgYeeKJJzx4qwEAwYCHMvA05ioAAE9irgIAQHBJy8yW2OgoMwfwC6EhpoydnfHwnKAPIGkT6X/9618ya9YsOX78uMlGuvTSS2XKlCmmQTUAAIA3MVcBAAAAAFiVkZntN/2P4HuCPoB05513mg0AAM8Isbmqh5UyKIm5CgDAs5irAAAQbD2QasdEit/Q8nU2StjZGosygj6AVF2OZ+VLSmaey2MZOfkS6uaY1R/vDk3qWBwp8vuRDMtjWzeItTy2d5t6bo8lHSuQhETXx4uKLF9ScvMLLY+1el0716xobE5eoWTlFrg8VivcesHPSItjtx5Ms3zNm3q3tDz2vZ/3uz0Wmp0mhQdzXR47r31jy9cMs5EOWy82wvLYd7YctDSuX9vEco+HhoS4/Z56tUgQq7Yes/73y5ptRyyNa1Lb+qqaRnF1xS6NHdkJIPlLRjkA+KNj6a7nBJWRWNs/asZ7W71h/7Q0Lvnt28Qbjq6dLcGGuQoAAMElPTNbmjcp/7mQz5XbtfHcraZL9S1atEiuv/56l8cOHDggjRtbf/7oCwggAQAAAAAAAAAQoAEkSthVv4cfflhat25dYl98fLz4OwJIAAB4ki50oYIdAADwVcxVAAAIGvn5BZKdkye1Y/yoB1JY6InNzngvGDRokPTs2VMCDQEkAAA8nWptq4QdNewAAED1Ya4CAEBwZR8pvwog6WMRGyXsvNlaOi0tTWJiYiQsLEwChXfCcQAABPhDGTsbAAAAcxUAABCMAaSQsBDbmzcMGDBA4uLiTABp6NChsm3bNgkEZCABAAAAAAAAABCAAaTQ0BCJjqolwWb79u1l9jVo0EAaNmzo0evExMTIqFGjnAGkjRs3yqxZs6Rv377y3XffSfPmzcWfEUACAMCDKAsDAAB8GXMVAACCR3pGtsk+8qtqJ1q+zk4Juz/HDhs2rMyhKVOmyEMPPeR2aGFhoeTm5lbqMpGRkea+Xn755WZz0Ouef/750r9/f3n00Ufl+eefF39GAAkAAE/zo3kZAAAIQsxVAAAICumZOX5Vvs4ZAAqzH0B6++23pW3btmUykMrz+eefm0yiyvj111+lY8eOLo/169dP+vTpI59++qn4OwJIAAAAAAAAAAAEYAm7WH8LIHmIBo+6dOlSpTEaEFq4cGGlzm3SpEm5x7V03datW8XfEUACAMCDKAsDAAB8GXMVAACCK4DUsml98SchoSFmszPeqsaNG5t+Rp6wc+fOCjOe/EGot98AAAABJSTE+WDGyqbjAQAAAnGukpOTIxMmTJCmTZtKdHS0Ke3yySefVGrsvn37TH+B+Ph406D64osvNg9misvKypLRo0dL165dpW7dulK7dm055ZRTZM6cOZKXl1fmNVNSUuTmm282D3diY2NNyRptdg0AQCD1QIqNiRT/K2EXan2z0z/JgiNHjpTZ9+GHH8rGjRvlggsuEH9HAAkAgABR3Q9l1HPPPScjRoyQFi1amIdI5a3M4aEMAAAoTucNs2bNkquvvtoEdcLCwmTw4MHy5Zdflnuj0tPTTXBnzZo1MmnSJJk6daps2rRJzjzzTDl27FiJANLPP/9sXvPxxx+XGTNmmADS2LFj5brrrivTJHvIkCHyyiuvyO233y5PPfWUHD58WM466yzZtm0bv3EAAL+Xl18gObl5Ujsm2ttvJaD17dvXPE/RucQLL7wgt9xyi3mmoiXsdN7i7yhhBwCAB51YmGsj1TrE3kOZFStWyN133y3t2rWTRYsWmQcoq1atMg0cK3ook5qaaiY3ERERMnv2bPNQ5vvvv5fExETnuU8++aSkpaVJ79695cCBA25f0/FQ5ocffpB7771X6tevL/PmzTMPZXQVjr4/AAAQPHOVDRs2yPLly2X69Okybtw4s2/kyJEmW2j8+PGydu1at2N1DqFBHX2NXr16mX2DBg0yY2fOnCmPPfaY2ZeQkCBff/11ibG33nqryUaaO3euCV5paRqlcya95uuvvy7Dhw83+/ThT/v27WXKlCkmsAQAgD/LyMw2X2v7WQaSN0vYWXHFFVfIBx98IB9//LFkZmaa3kg33XSTmU80atRI/B0BJAAAAqCvQE08lFG68teRfaRlYdzhoQwAAL7JW3MVnRtoxpGWjHOIiooyJed0AcvevXvNSl13Y3WO4pinOJpcn3322fLaa6+VmKu40qpVK2d2dPEAkj7UufTSS53naSk7DSItW7bMZHZHRvrXAzcAAEr3P1K1Y6P8sISdjSBQDQeQpk2bZrZARQk7AAACQHkPZdatW2ceypQ3tryHMsW1bNmyUg+Oynso884775iHMgAAIHhoyTnN7tFSucVpVrPSrGd3Wc2bN2+Wnj17ljmmY3fs2GGyo4vLzc2Vo0ePmvnPW2+9ZUrZ6Rymbdu2Jd7PaaedJqGhoWVeU1cP//bbb7a+XwAAfKH/UWhoiERH1vL2W4EfI4AEAIAnhXhg8/GHMpV9PzyUAQAgcOcq27dvN/2Gim/aQ8gdLX2rJV1Kc+zbv3+/y3FJSUlm4UlVxr755ptm4YpmTetilmbNmsl7770n4eHhtt8PAAD+lIFUOybKVuaxV2j2kd0NHkMJOwAAPChEbJaF+fOpjD6UKU0fhDRs2NArD2U6dOhQpe9D30///v3Lfc1u3bpV6TUBAIDvzFWGDRtW5pjW+n/ooYdcjsvKynJZEk4zph3H3Y1TVRmrvR0/+eQTU7Lus88+Mz0ZMzIyPPJ+AADwtwCSv/G3HkiBjgBSNcnIyZe0rHyXxzJzCkTcHCssKrJ0vdpR1n8rm9aLtjx2ycbdlsf2bfa/puylZaVlybG8dJfHYiOtf6+N6lqvYZ2VW2BpXGSE9US/Q6nll3jKzM6Xwow8l8cWb/rD8nUfOr9qD4odIsOsf68HK/hey9M6zn0fltywPKkV6/p4rI0/N/kFhZbHFhRa+3Ou7vrryZbG/bgntdzjOemZcijbdZZJ1+YlM1qq4oruzSyPjYu29vsTEiB9BXz5oUxl8FAGvqL7pP9aHrv5sQs8+l5Q0oadSZZvSe82CZbGJcRG8NtQzZLfvs2v7nFYED5g8NRc5e233y5REs6x2MWd6OholyVss7OzncfdjVNVGatldB1Nq4cPH256JJ177rmm56OjB5LV9wMAgL9Iz8zxywCSv/VACnQEkAAA8EG+/FCmMngoAwBAYNN5SpcuXSp9vmYh79u3z2XWsmratKnLcQkJCWahi+O8qox10CDS/fffb/ow3nLLLc73Y+c1AQDwdekZWZJ4kvvnCEBlEEACAMCDdFGunfLCjrH+9FDG3fvhoQwAAIE7V6mqHj16yKpVq+T48eMlejauX7/eedyV0NBQU/b222+/LXNMx7Zp00bq1KlT7rUd2dSpqf/LytfrffHFF6YfpF6j+GvGxMSY3pIAAPgzv85AKvbZbGk8PMbG7wQAACjjz7IwVjerT2X0Ichvv/1mHsoUVxMPZdy9n++++848lCn9mjyUAQAg+OYqmgVUUFAg8+fPd+7TDOiFCxdKnz59pHnz5mbfnj17ZMuWLWXGfvPNNyXmK1u3bpWVK1fKiBEjnPuOHj0qRS7Kwr/00kvma8+ePUu85qFDh+TNN98sMf7111+Xiy66yGV5XwAA/EVefoHk5Ob5bQApJMz6RgDJswggAQAQAGrioUxV3w8PZQAAgIPOR3ReMXHiRBk/fryZswwcOFB27dolTz31lPO8kSNHSqdOnUrcuDFjxsjJJ58sQ4YMkenTp8vTTz9tehppn6N77rnHed6yZcvM2Pvuu8+8/syZM+W8886TuXPnmqCQXq/4XOWMM86Q66+/Xh5++GGZN2+enHXWWWY+NXXqVH7jAAB+LSPzREl6vwwgwadQwg4AgAAoC1P8oczhw4dNCbzFixebhzILFiwo8VBmzZo1JVbn6kOZF1980TyUGTdunERERMisWbPKPJRR7733nvzwww/mv/Py8mTz5s0ybdo08+uhQ4dK9+7dyzyU+eWXX6R+/frmwQwPZQAACM65ilqyZIlMnjxZli5dKsnJyWbe8P7770v//v3LHafZ0KtXr5axY8eaeYdmOGuwZ/bs2SV6RPbr10/Wrl0r//73v81ClvDwcOnQoYOZ19xxxx0lXjMsLEw+/PBDuffee+WZZ54xZe569eolixYtMmMAAPBnaRl/BpBi/bWEnY0JByXsPIoAEgAAHn8oExKQD2XUG2+8YQJTDps2bTKbatasmTOAxEMZAAB8kzfnKlFRUSaDSDd3dE7iis4ztLxcebRE3WuvvVbp91OvXj1T3s5R4g4AgEDKQAoLDZWoyAjxOxoA0lJ0dsbDYwggAQAQIKr7oYzSVbm6VQYPZQAAAAAAqHnpmdkSGxNpa9EIoOiBBACAB4UUKw1jaeN3AwAAVCPmKr7n2LFjJoP88ssvl4YNG8rgwYPl+eeflz/++MPbbw0A4Mcl7Py1/1FIaIjtDZ5DAAkAAE9+sIaG2N4AAACqC3MV3/Drr7/KU089JX/961+lcePGcuutt0p2drbcd999EhcXZ762bNlSTjvtNJkyZYp8++233n7LAAA/K2Hnl/2PlJavCwu1sfFcxZMoYQcAAAAAAFBDTj75ZNm1a5fJNrrwwgtl/Pjxcs4550h0dLTznPz8fFN6+L333jPZSY888og0adJENm7caAJOAABUVMIusV4dbhJsI4AEAIAn/VmKzs54AACAasNcxeuuuuoqueiii6RPnz5uzwkPDzdBJd3mzJkjP/74owkmhYWF1eh7BQD4bwDJX0vYiVZmsZNFRGUXjyKABACAB2mDSjtNKmlwCQAAqhNzFe+bNm1alcd069bNbAAAVCQvP19ycvP9toSd3T5G9EDyLAJIAAB4UIjNDCRb2UsAAACVmGswV/EN69evl99//10SExNNL6SoKP980AcA8C3pGTnmKxlI8IRQbiMAAAAAAEDNSEtLk379+knfvn3l6quvlgsuuMD0Rfr+++89fq2cnByZMGGCNG3a1PRY0rJ5n3zySYXjtm7dKmPHjjXvUQNbmrmmfZtc0fNOO+00SUhIkJiYGOnUqZM89NBDkp6e7vHvBwBQufJ1fh1Agk8hgAQAgAeF6P9CbGw0QQIAANWIuYr3PfXUU7J27Vq55JJL5Nlnn5W77rpLkpKS5LrrrvP4tUaNGiWzZs0ygSrtpaQ9lAYPHixffvlluePWrVsnzzzzjAl2aUCoPN98843JoJo6daq5xoABA+SJJ54wgbHCwkIPf0cAgMoEkMLCQiUqMsJ/IxZaws7y5u1vILBQwq6a1ImKkLoxrv+QhuSES5ybY/Virf3B/nVfmljV6aQ6lsde2vUky2Njarlv/pkUliUJibEuj4WHWf9b4Ke9qZbHdm1e19K4vHzrE+bmidHlHk+SSElwc84Fbetbvm5+QWGN3iM711R7kjPdHivMLZDQ8DyXx/5IyrJ8zabx1ldxfLLlkOWx53RsZGlctxbl/94cO5orifVdn/N/j68Sq14aebrlsXWjrX1Efbc7xfI1B3RMFLvoKwC4VlBYZPnWhNmof735sQssj0X16t0mocZvMX3mqn9eZmeublX3Sf/1q78jNu+x/m+S3m2sz7cdmKt435tvvimXXnqprFixwrmvY8eO8ve//92UtGvdurVHrrNhwwZZvny5TJ8+XcaNG2f2jRw5Urp27Srjx483QSx3hg4dKikpKVKnTh2ZMWNGudlRroJRmlGl19T3cMYZZ3jk+wEAVE56RrbJPvLXua/pgRRGDyRfQTwOAAAAAACghmgpuPPOO6/EvvPPP1+Kiorkjz/+8Nh1NEClGUc333yzc5+Woxs9erTJMNq7d6/bsVqOToNHVrVq1cp81SAUAKDmM5Bqx0Ry2+ERZCABAOBBNKYGAAC+jLmK92VlZUnt2rVL7HP8Oi/PdfUEKzZt2iTt27eXuLi4Evt79+5tvmpWUfPmzT1yrfz8fBMsys3NlZ9++kkeeOABE4ByXAsAUNMBpPKrGvm00NATm53x8BgCSAAAeNKfvYzsjAcAAKg2zFV8QkZGhul75OD4b+05VHx/8Yygqjpw4IA0adKkzH7Hvv3794unfPvtt/KXv/zF+esOHTrIu+++W+H7Pnz4sBw5cqTEvu3bt3vsfQFAMMrIzJb69axnkXqdo5eRnfHwGAJIAAAAAAAANejWW281W2naG8mVgoICS5lOkZFlSxhpGTvHcU/p3LmzfPLJJyYwpr2VPv30U0lPT69w3Lx582Tq1Kkuj2kgrXRwCVWXmmq97xq4z76Gn+fKOZ6eJVKYb/nvUDv3uUGDBpbHwjcRQAIAwIMoCwMAAHwZcxXvmzJlSo1cJzo6WnJycsrsz87Odh73FC2Td84555j/vvjii+WVV14xX7/77js55ZRT3I4bM2aMjBgxokwG0rBhw0z2Eg8iPYP7WDO4z9xnX5Cbly95+QXSuFF9Wz+TXv151smKnTJ0VHbxKAJIAAB4/KGM9XRp5jkAAKA6MVcJngCSlqrbt2+fy9J2qmnTptV2bc2kuvbaa2X58uXlBpAaNmxoNgCA58rXqdoxJ7JN/RI9kHwKHaUAAAAAAAACTI8ePeS3336T48ePl9i/fv165/HqoplPhYWFlJsCgBqWnpnj/wEk+BQCSAAAeFBIsdIwljZ+NwAAQDVirhI8hg8fbnonzZ8/v0RgZ+HChdKnTx9p3ry52bdnzx7ZsmWLpWukpKRIXl5emf0vvfSS+dqzZ0/L7x8AUHXpmdkSFhYqUZER/nv7QkPsb17w6aefysCBA6Vu3bpSp04dOf300+XVV18Vf0cJOwAAPEjL19krYUcICQAAVB/mKsFDg0TaX2jixIly+PBhadu2rSxevFh27dolCxYscJ43cuRIWbNmjRQVFZVooP7ss8+a//7qq6/M17lz50p8fLzZbr/9drNv9erVcuedd5pgVbt27SQ3N1e++OILefPNN03w6Jprrqnx7xsAgll6RpbJPvLrZwshoTZ7INV8zszChQtl9OjRcu6558pjjz0mYWFhsnXrVtm7d6/4OwJIAAB4EI2pAQCAL2OuElyWLFkikydPlqVLl0pycrJ0795d3n//fenfv3+54/RcHVfczJkzzdeWLVs6A0jdunWTAQMGyDvvvGN6K2kQ6uSTT5YHH3xQ7r33XqlVq1Y1fncAAFcl7Py+fJ3JIrIRBKrhDKRdu3bJbbfdJnfccYfMmTNHAg0BJAAAAAAAgAAUFRUl06dPN5s7mkVUWqtWrUpkJLmjwSLNagIA+E4Ju9qxfh5A8jPPP/+8KRn78MMPm1+np6dLbGysf2eBFUMPJAAAPOnPEnZWN7MsGAAAoLowVwEAILADSAGRgeQ/PZA+/fRT6dixo3z44YfSrFkz0/8oMTHRZPIWFhaKvyMDCQAAD6IsDAAA8GXMVQAACFzpGQEQQPJQD6Tt27eXOdSgQQNp2LCheNK2bdtMz6Prr79exo8fL6eccorpBTht2jTJz8+Xxx9/XPwZASQAAAAAAAAfFBoaKk2bNpUHHnhAbrzxRgkP5zEOAMC13Lx8s9WOieQWiciwYcPK3IcpU6bIQw895Pb+aMZQbm5upe5fZGSkqSSjJet03BNPPCETJkwwxy677DJJSkoyPZEmTZpkspL8FTMPAAA8yFmKzsZ4AACA6sJcxb/0799fMjIy5M4775SnnnpKdu7c6e23BADw4fJ1yu97IJkydDYykP4sYff2229L27Zty2Qglefzzz+XAQMGVOoyv/76qyldFx0dbT6rr7rqqhLH9df//e9/ZdOmTebz3F8RQAIAwIN0mmInBkT4CAAAVCfmKv5l9erV5quubtaHWgAAuJPhCCD5ewk7u32M/hyrwaMuXbpUaagGhBYuXFipc5s0aWK+aqawlrFr1KhRieOOUnnJycnizwggVZNa4SESGeE6UhpRzrGcPGuNtdo0ihWrdh7OsDy2Zf0Yy2PzCorcHisoLHJ7/GBqluVrtm9iPV2wqMj9+y2PnQfJadn55R7Pyi1we05irPV01fd+3m9pXLeG8Zav+fCnv1keu/jqU90eSzomkpBY3+WxTbtSLF+zSbz1D+PYCOt/9f5u8c9rYp1a5R5Pz86X0AzXKboLR/UUq9o2qm15rLU/cSJnnJxg+ZoAqk9YDTcyRWArLLT2KRFq4+ewXp+7LI9NXj9H/El4mI0Vn16w+bELxJ90b1HX228Bfqh27doyePBgb78NAIAPS8vINvO4yFoR3n4rfqtx48YyatSoKo05/fTTTQBp37590qZNG+f+/fv3Vyrrydf5178MAADwk7IwdjYAAADmKoFt+fLl8uGHH5Z7zgcffCCvvvpqjb0nAID/ZyDFxkT5/3OFkNATJeysbjq+Bl1xxRXm64IFC5z7tCeSZjIlJCSYAFN1O3r0qGzZskW2bt0qx44d898MpD179pivLVq0KPHrijjOBwDA1+k8zVYJOz+f5/k75ioAgEDHXMX73nrrLbn66qtNX4Ty1KpVS/72t7+Z7KMhQ4bU2PsDAPhvDyS/73+kHIEgO+Nr0MUXXyxnn322PP744yaQc8opp5j+S19++aW88MILEhlpvUqUO9pz6fXXX5d33nlH1q5da65bXP369eUvf/mLDBs2TEaMGCGxsbH+EUBq1aqViYBmZWWZiZDj1xUpKCiokfcHAACCG3MVAABQ3XRF8llnnSXnnntuuefp8YEDB8qLL75IAAkAUKH0zBz/73/kh0JCQkzA6IEHHjCZw4sWLZIOHTrIsmXLzIIRT9LsIg1UaWAqOztbunfvbgJYWjqvXr16pgWL9lz6/fffZePGjXLTTTfJHXfcIbfccovcd999JrDk0wGkl19+2dzQiIiIEr8GACBg2C1Dx+eiVzFXAQAEPOYqXrd+/XoZP358pc694IILZPr06dX+ngAA/i89I1saJMRJYGRLh/jVY5XatWvL008/bbbqXvTatm1bMze47LLLKuyvdOTIEXnjjTdk/vz5Zjt+/LhvB5BKN6CqakMqAAB8nT9OdPA/zFUAAIGOuYr3paSkSGJiYqXO1fN0JTEAAJUqYRcIGUiOHkh2xgeoFStWyPnnn1/p8zXAdOutt5rto48+snTNGg0gAQAQ6OgrAAAAfBlzFe/Thtq7d++u1Ll6np4PAEB5cvPyzRYQASQ/64FUk6oSPPLU2MC9mwAAAAAAwGfk5OTIhAkTpGnTphIdHS19+vSRTz75pFJj9+3bJ5dffrnEx8dLXFycqfe/c+fOEufs3btXpk6dKr179zZ9ALTOv/Ya+vTTT8u8nvYn0KxxV9vBgwelOmlT63//+98V9nvW43qeng8AQEXZR6p2bCQ3Ch5FBhIAAB4Uov+zU8JOqGEHAAACc66ipWK19Mrdd98t7dq1M0GcwYMHy6pVq6Rfv35ux6Wnp8uAAQMkNTVVJk2aZPoqz549W84880z5/vvvneXg3nnnHXnyySdl2LBhct1110l+fr4sWbJEzj33XNPn8Prrry/z2g8//LC0bt26xD4NUlWnO++8UwYOHGgaay9YsEBiY2PLnJOZmSmjR4+Wbdu2yfPPP1+t7wcAEBj9j1RgZCCFnNjsjA8iv/76qyxcuNAsrNGyt0VFRSWO67zvs88+s/z6BJAAAPAgysIAAABf5q25yoYNG2T58uWm6fO4cePMvpEjR0rXrl1l/PjxsnbtWrdj582bZwIp+hq9evUy+wYNGmTGzpw5Ux577DGzT4NMe/bsMZlHDlrzv0ePHvLggw+6DCDp6/Ts2VNqkmZFTZ48WR555BHzQOeSSy4x30udOnUkLS1NfvzxRxMMO3r0qNx///3mfAAAKspACg8Lk8haEf5/o3SyYasHUvAEkJYuXWrmN7q4pkOHDiYDu7TSAaWqIoAEAAAAAACqlWYehYWFyc033+zcFxUVZbJsNKtIy881b97c7VgNHDmCR6pjx45y9tlny2uvveYMIHXp0qXM2MjISJPlNGvWLBOc0SBNabo/JibGvL+aoqX2unXrZgJJL730Upnj+hBo7ty5pmwfAACVCSDVjom0lWUM//PQQw/JqaeeKv/5z39KLKDxJJ8PIGnN35qcxAEAYIejdr6d8fAvzFUAAME4V9m+fXuZYw0aNJCGDRu6HLdp0yZp37696V9UnPYrUlqKzlUAqbCwUDZv3iw33HBDmWM69uOPP3YbGHLQnkYaINKtNM1a0hJ5tWrVMs2lNaNJy+vVhOHDh5tN76WWnzl+/Li5Pxocq6n3AAAInBJ2tWMDoHydooRdpe3fv99kdldX8EjZyAWz76qrrpKUlBS3x3WSWHyFEQAAPu/PsjBWN1og+RbmKgCAgOOhuYr2GdKya8U3LTXnzoEDB6RJkyZl9jv26QMQV5KSkiQnJ8fSWKXBmTfffFMuu+yyEotTNZikPZn++c9/yltvvWXK6Gk5ub59+5psqJrUtm1bueiii0xPJP1K8AgAUFUZJgMpUAJIofa3ING9e/dy50Ge4NW7+e6775oU8/fff7/MCqNp06aZ1UTlBZgAAACqE3MVAABce/vtt+Wnn34qsY0ZM8bt7crKyjLl5ErTMnaO4+7GKStjMzMzZcSIERIdHS1PPPFEiWNaGk4bTmsfJg2GaT+ijz76SI4dOyaPPvpotf62r1mzxjz3qKpvv/1WMjIyquU9AQD8W1ogBZBQaVqid8GCBeX2kvTrEnY//PCDWfFz8cUXm0nbnDlz5I8//pDrrrtONm7cKDfeeKO5CQAA+IvQkBCz2RkP38FcBQAQaDw1V9GsGVc9h9zRII5mEpWWnZ3tPO5unKrqWC0xe+WVV8ovv/xi+gI0bdq0wvfYr18/6dOnj3z66adSnbRsXkJCggwaNMg8D9HSea5K8On3rO/lvffeMwtvNYtLM6pat25dre8PAOB/MjJzJDZQAkg617CTRRREz1WefPJJqVu3rvz1r3+Vzp07S4sWLcq0A9Lyw++8845/BpB0wvnFF1+YGsMPPvigWe2TnJxs6ibrBE8nUQAA+BNneRcb4+E7mKsAAAKNt+YqWm5u3759ZfZrUES5C/BooEWzjxznVXbsTTfdZIIu//rXv2TgwIGVfp/ah2nr1q1SnXbt2mUe5Oj7u+aaa8y+/v37m2CSfv3mm29MFrQGjzRIpkGtO+64Q4YOHUrwCABQRm5uvuTm5dMDqXgPpSCxefNmEyDSwJH2dNSFM57ute3VAJLjG9B08WXLlplvWGnd3/POO8/bbw0AAIC5CgAAHtCjRw9ZtWqVHD9+XOLi4pz7169f7zzuSmhoqHTr1s2UbytNx7Zp06ZM9s69995rytM9/fTTpp9hVezcudMsaq1O+pBHA0K6paWlyX//+1+TZTRlyhSzqFb7M5177rkyd+5cufDCC6u1MTYAwP+lZ57IyKWEXfDZtWtXtV/D6wEknRBNnDjRpFq9/vrrZuKkqVdaE3jx4sV+2zzyq11HZXfYQZfHQrPTpPBIvstjQ7tUnFbvytc7k8SqvicnWh6bm1/1us0OSem5bo+lZ+VLoZvjeTau+e7P1puK9W1h7T41ibeePhoXHVHu8fzMcLfnxMeUP7Y86dmufz4r0jzRddmJynjqws6Wx2bmFrg9lp1X4Pb4SQnW3++OQ+mWx/ZpnWB57C/7jlsa17iCn8Ow0BCJCHOdHtyifoxYtWbbEctj+7drUON/L0VHlEzztSJE/2djdYeOt0rLnGhG79KlS83DB22mqD0F9QFERXRF8NixY+Xjjz82Nfm1tMrs2bPNQ5nStL7ujBkz5PfffzerdO+8807zAKQ0XTWrPQR+/PFHyc/Pl/bt25vzrr32WvEngTpXqWlFRUWWx9pdMeVP6vUu+2epspI3PCvBItQLqwqT18+p8WsC1cFbc5Xhw4eb+cP8+fNl3LhxzrmLBno0w0bnFGpAWU5IAADMEklEQVTPnj2md1HHjh1LjL3vvvtMEKlnz55mn2YJrVy50vlaDtOnTzfXmTRpktx1111u38+RI0fKBIo+/PBDU05f5zY1RYNf2qdJN52D6bxJv3dXPZ8AAAiKAJKWr7NTws7OWPhWAEnTyFevXm1WBOnDmXr16slll11mNu1/pCuQHnvssXInfQAA+FypXi+VsNO+gitWrJC7777bBDUWLVokgwcPNqt9taa/O5rmrAGj1NRU87AlIiLCBI/OPPNM+f777yUx8X8B9BdeeEFuvfVW81n9j3/8w5Si1Ycs+qBnwoQJzvO07IpmGP/lL3+Rhx56yDyoeu2110zPw6NHj5pglT9grgIACDTemqtokEiDJLoo4/Dhw6ZMrC7E0JWzujjFQecKukij+MKDMWPGyIsvvihDhgwxASOdq2i/5EaNGsk999zjPO+tt96S8ePHm3lQp06dTKWT4nRRjY5Rffv2lVNPPdUEpHSRyHfffScvv/yyCWTpfMgbNNvqlFNO8cq1AQD+HUAKDwuTyFpezxXxjBCbASQdH2TWrFkjH3zwgezevdv8umXLlmbepM917PLqT9VPP/1kVvLqQ6jiLrjgAvn555/NAyl9OGUlgKQPw3Tlkaa0b9iwwazE1pVN+nCttF9//dU8yPryyy+lVq1a5ubqZLS609YBAIFHAyW2VvVaHKufdcuXLzeffY6VuPoApmvXruZBytq1a92OnTdvnmzbts28Rq9evcw+beqsY7VPoS7mUFlZWXL//febz0kNVDn6C+hq2UceeURuvvlmsxhE6cIQ7XWgK4MdK2hvueUWs6JWA1v+EkBirgIACDTemquoJUuWyOTJk0tkS2sfIO37U1GWji4+1fmDZlfr3OOss84yC16K/7v9hx9+MF91XuMq41kX1TgCSFdccYV50KLZ17oQRuctOq/RMnKOcwAA8AfpGdmm/1HAVG7Q+I+d1S5BFD/Kzc01yTlvv/22WXwTHx9v9qekpJjnOZdccon8+9//Notv/PJ2apCodPDIQVcA6Wok/eat0NXNDz/8sAkOlbeC548//jCT1e3bt5sHZPrQTSeRujJJfwMAAPAHGtAJCwszQRyHqKgoGT16tKxbt0727t1b7lgNHDmCR0oDPWeffbbJGir+0OXYsWNmFXBxt912m2RkZJjPTwftb6DBpOLlV8LDw00N/+ho6+UjaxpzFQAAPEfnJrrY5cCBA5KdnW0Wr5x//vklztFAkauyp82aNTMLUDVjWvsGac8gzWIqTrOeday7TYNODhqI2rRpk3nAov/21xW7uqiG4BEAwC8U5Yvk/S6S9Y20TNghf+mULpJ/RGuHe/udoQZNnTrVZGBrRrbOr5KSksx28OBBE+d48803TYzEbzOQiq8U0m/QkcYeGxvr3H/RRRdZem1dPaSv2bhxY1MnufhDseI0aKQPvbTOsTayVL179zYBJF0hXfxBHAAAFdEFP3YW/TjG6sIGV5+bDRs2dDlOH4Boj6HiTakdn2lKS9E5egsUpyt4N2/eLDfccEOZYzpWV+XqQxpd+avXUI7eAw6nn366Kbmix6+55hqzTx/QaJ8gXWV83XXXmZVQr7zyivlMLh6U8nXMVQAAgcZTcxUAAOAFGiDK3SqSu0U7xZtdjU4knYhkrRYJjROJPE0k3I8ra9EDqdL0OYs+c3nqqadK7NdnR/pM5tChQybzW6vG+G1C1zvvvGNWOetqotNOO82UnHNkEGk9YqsZSLriWYNHFXnjjTfkwgsvdAaP1DnnnGMewvnTAy4AgG8IcTSntvy/E7R/kJaQK77pqlh3dNGELp4ozbFv//79LsfpyhRtYF2ZsXoNzXIqHcTS8q/aJ6n4NTRwdPnll8ujjz5q+hDoApEnnnjCfO5eeuml4k+YqwAAAomn5ioAAMALwaOc70Ryf3QGj8ooPC6StUYk/6D4Le1hZHcLEgcOHDB9Jt3RY5qNZIdX76amnOtDJC1no3WGi6ep676TTjrJ9C2qLvv27TNZT6VXUjtWXTtWWgMAUNN0AYX23ym+lS4dV5z2JypeLq54qRjHcXfjVGXG6lcNFrmi5xa/hr6eLsYYPny4qberTaz181YzlL7++mvxF8xVAAAAAAA+IX+3SN7OSpxYJJK1VqQwuwbeFLxJk3K0/K87a9asMef4bQk7rb+n/YccPRW0XnFxf/nLX+SFF16o1gidcrfq2rEq29VDNaXBpyNHjpTY56rkEAAgeGifR1u9Hv8cqxk7Xbp0qfQ47Sukn1mlaX8Bx3F341RlxupXd/0B9dzi17j99ttNoOi7774z5e2UZiTp93TXXXc5M459HXMVAECg8dRcBQAA1HTput+qMKDgRI+kyE7if7Terp28l+CZrFx33XUmMSc+Pl7Gjh1rniVpC4Ft27bJ008/bfpHap8kvw0g6WrqWbNmuT2uzSs1SFNdKrvq2l0ASUsJufsNCMnJkNDsNJfHQnMz3b6npGNHxYqCzOOWxp24pvXmankFhZbHpmfluz2WleH++8m3cc2w7HTLY9NTrf3lk1TgerV+ZRRW8FuTdjy1Wv5hl5th7T4lJ5V9AO2Jn4eKFGSFuX/dNPf3KCu3wPI1s3Ksj00OdZ0JUhk56RmWxqVElL/qJKOc+xQWZv2HqdDW303WrltQaP3viLonNRLbQkLMh7Wd8VbowgfNrHW3WKJp06YuxyUkJJjPOcd55Y3VaxQUFJjP5uJl7DSopAtBHOfprxcsWCDjx493Bo9URESEDBo0SObOnWvOcZfN5EsCea6SkpIkx46WXAijjqe6//sA1X+fOreqZ3msq99Pb+PniXvEz5JnndS4gd/OVQAAgA2FySKFVfw3iGYr+WMAiR5IlTZp0iTZsWOHzJ8/X1588UXnMxjtd63V3jTApOf4bQApJiZGMjLcPwzduXOn6alQXaqy6toVLSU0YsSIMhlI2reiKDJWCqPquB3r7lhCYn2xIizVelQ2wcY9zs23/qC2MN31KnaH2nUTPH7Nggzr/9hx934qkhB/4gFfdQSQyvuZsRNAqpUeYWlcvQT3P/MVynBTu7US6kSX/1dZfILrexSebT1oVZhp/f3WS4y1PPZAtrUH7vEJtStxjpv7ZCOAFJpifazVvw/tBJn9WY8ePUxG7/HjxyUuLs6535Hpo8dd0clFt27d5Ntvvy1zTMe2adNG6tSpU+I19NzBgwc7z9Nf6+TEcVyDSfn5+SbYVFpeXp4519UxXxTIc5X4+ARJrO/6QaS7/XYUL1VcVbYedFaj6rhPv+xK9qn34wm++r58CfeI+wQAAFCuQteJCuUqyhQpKgyqnkDBJiwsTBYtWiT/+Mc/5MMPP5Tdu3eb/S1btjTPbbp37277Gl4NIA0YMEAWL14sd999d5lj2txJo2YXXnhhtV3fUbrO3aprx6psd3T1delG4gCA4GYaU9tZ1GtxnPYamjFjhll1Mm7cOGfQQXsJatPE5s2bm3179uyRzMxM6dixY4mx9913nwkEOfoCbt26VVauXOl8LTVw4EDz2fjcc8+VCCDprzXQMmTIEPNr/WzU9Om33nrLlIBzZBqlp6ebnkJ67fKCHr6EuQoAINB4a64CAADssLogz/pCPq/RgJedoFcQBsy6d+/ukWCRzwWQHn30UTnjjDOkV69eZnWsri796KOPzAMr7X2kK1W1hl91Oemkk6RBgwYuV11v2LDB7WptAADcCQ0JMZtVVsdqkEg/SydOnGhKqmndW12ksWvXLlNOzmHkyJGmiWLxbBDNUtFFGxoA0oCRlprTsm1anu2ee+5xnqdBn0ceeURuu+02c63zzz9fvvjiC1m2bJn5TNfgkmMFjL7OAw88YD7n9ZqacaTv448//jDn+wvmKgCAQOOtuQoAALAhxEI1m5BIkRD3bR98ls41bAWQmKt4klfDcR06dJAvv/zSlH6ZPHmyeZg1ffp0eeyxx0w5HX0o1apVq2p9D5dddpm8//77snfvXue+zz77TH777bcyJV8AAPBlS5YsMVm9S5culTvvvNOUi9PPuP79+5c7TkvUrV692pw3bdo085l8yimnmECTLrQoToNNmuX0448/mkDSV199JbNnzzaBq+Luv/9++de//mWCUdqDR19TS+utWLFCrr76avEXzFUAAEB1z990wY87ekzPAQAEubD6IiEVtycoIaJ1db0beIm2IQgPDzd9pR2/1kW85W16vt9mIKkuXbrIp59+KsnJyaYmv/ZF0H4LpR9YWaFNulNSUmT//v3m11o2R1c+qzvuuEPq1q1rmki9/vrrpkTNXXfdZcrraBBLA1jXX3+97fcAAAguZqGMl/pSR0VFmc8w3dzRQJErzZo1M5+HlXHTTTeZrSJ/+9vfzObvmKsAAAKJN+cqKEufO+jiH3eLZ7UnpZ6jGd0AgCCmH8C12orkfF/ZASIRbcQvUcLOrQcffNBUcXMEhRy/rk5eDyA51KtXz5Sy8yTtBeFoHKXefPNNs6lrrrnGBJC0J4SusNZGU9r/Qfs0aAmfmTNnltv/CAAAV/SD286Hd3V/8MM65ioAgEDAXMW3FC8r7EpGRobtlcMAgAAR0Vak4LBI/olkiXJF9RQJtVD2zlcCSKH0QHLloYceKvfX1aFGZyFW066trrQpLw289Mpi7b0EAIBtNlf10pnau5irAAACHnMVr9u8ebN8//3/VpBr+f78/Pwy52lFleeff17at29fw+8QAOCT9GFD1F9OZCHl7dRlCGLWIehnu/OkWiJRp4lENBe/5Wc9kM466yyToOKKLgLR9gLV5eGHH5ZLL71Uunbt6vL4zz//LG+88YbJVPKLANKoUaPcrrQuveqm+Apsf0zVHtCukXTufJLLY0nHjkpCYn2Xx/LyCy1d74w2JxqXW1FQWP6Kp/LUCrf+h7lBnPsMr/C8CKnn5nhGTtmJdWW1rVvFWqHFNCzn/ZZnycb/ZcFV1Sn148s9npuRLvsyIlwee/CjLZavu2J0b0vj1mw7YvmaZ7VrUC2fCxFhoRLp5uc0uo71LMOs3ALLYwsqWGVYnnaNrf0M2/hjbkvTOtE1fs3Ptx+1PPaibo08+l7gf4JprlLTyK6rnOQNz0pN+3ZnsuWxPdvUszy228T/WB774+ODLI8FAG976623TI9Ix+fjCy+8YDZX4uPj6YEEAPgfDaxogKhWJzmw/zspzDsiJzWKEwmJFAlvdmILCeOO1aD7779fbrzxxjIZxLfeequcd9551XptzUBq27at2wDSTz/9ZOYcfhNA+v3338usprnuuutMKTntSaSNqtWWLVvk2WeflbS0NFm8eHFNvkUAAGwJDQkxm53x8B7mKgCAQMdcxftuvvlmufDCC83ilN69e5vVw4MGlQyMa2ApNjZWTj75ZFsl7HJycsxDI+2zpL2nu3fvLtOmTZNzzz233HFbt2412U/ag+m7774zr6PzpNK9mo4dOyYvv/yy6Tn966+/mlXWHTt2lLFjx8oVV1xh+X0DACoQGi2/7K0raRm15KTWnm0L43V+1gPpXBefqcuWLTNfr776avGmpKQk07LHjhoNILVs2bJMhKxBgwby8ccfl1iV2q1bN7nssstMhG727NmycOHCmnybAABYpp9mVLDzX8xVAACBjrmK9zVp0sRsatWqVdKpUydp2LBhtWVXr1ixQu6++25p166dLFq0SAYPHmyu269fP7fj1q1bJ88884x07tzZvL/iJfdKn6crr/U1H3jgARPs0lI5V155pfzyyy/OTCsAgOclpaRJ4wqqF/klPwsgufLKK6+YhSAXX3yxeNrnn38uq1evdv76zTfflO3bt5c5T5N3Xn31VRNrscOrnRjffvttefTRR12WNAkNDTX1+3QCAgAA4A3MVQAAQHU688wzy+zTzCQN8GjWjwZ56tSpY+m1N2zYIMuXL5fp06fLuHHjnGV3tczN+PHjZe3atW7HDh061Dx40mvPmDHDbQBJe0pv27atxCKcMWPGyDnnnCNPPvmkuY4+QAMAeJZ+ViSlZkjnts24tT7myJEj8sknn5hM3Or4DNQ5QvFSuBpA0s0VXQiild78NoCkP+hars4dXa1Sut8AAAC+LET/Z6MMnY6H72CuAgAINMxVfItm72ggRx8GOeYeWo1l5cqV5r9btGghn332mSllV1WaeRQWFmZK5jlERUXJ6NGjZdKkSbJ3715p3tx1k/WEhMr1WW7dunWZfToXHjZsmPkedu7caXvlMwCgrLSMLMnPL5CEeOv93n2WPlOxlYF04rmKq6wcrYZWXVm/Dpr1k5+fX23l63Rxxu23327mCfq9aMlZreZW+rM4JibGfO7b5dUAkk4onnvuOVNDV5tK6TelMjMzzX5tIuntOoEAAFR1nhJqIwZECyTfwlwFABBomKv4Fi33Vry8jQZ9NGCk1VpOOeUUueWWW0z5f+1hVFWbNm2S9u3bS1xcXIn92ndJaVaRuwCSXQcPHjRf69evXy2vDwDB7lhKuvmaUDcQA0ihWp7M3vg//z1f2pQpU8znqjuFhYWSm5tbqctERka6XECs5es0UFVRv0GroqOjzaa0P6FeyxFXqQ5eDSDNmTPHfJOaSj1x4kRnDeADBw6Yxov/93//J08//bQ33yIAAAhizFUAAEB12rdvn7Rt29b5ay1Bo+Vm9BmJ+vvf/24W2Fqhz1Ycz1mKc+zbv3+/VFfD7pdeekn++te/urx+cYcPHzalfopztWIcAFDq79qUdKkdEyWRtSK4NeWUpC/+Gas02FJRf6EBAwZU6p7++uuv0rFjxxL7NPNW+wNqhpD2BazpPs4BF0CqW7eurFmzRt555x35z3/+I7t37zb7L7jgAtOA8aKLLrJVBggAAK9kWtspYcfHnk9hrgIACDTMVXyLPlzSXkdKS9Fo9pH2KXJo1KiRHD161NJrZ2VlmdXRpTnK2ehxT9OV21pJRvsnVabnwrx585x9HFwFokoHl1B1qamp3LYawH2uGdzn/9l/6KjUjqlVLX9P2rnPFQVoKiMkJMxsdsYrDR5pr76q0IDQwoULK3VuExeLJDT7SNVkVbXNmzebz9zvvvvO/N7pZ3Fx+oxqx44d/hlActB07eIp2wAA+PdDGXvj4XuYqwAAAgVzFd/StWtXWbZsmXnQ9NZbb8mxY8dkyJAhzuO60NZqGTgtb+MIThWXnZ3tPO5pd9xxh/z3v/+VJUuWmBJ8FRkzZoyMGDGiTAaSlh3SPkyeeBAJzzzQRcW4zzWD+3xCRvY2ad44sdruh1fvs4d6IFnRuHFjGTVqlOXxr7zyiulbeMYZZ0hNWL16tUnGqVevnvTs2dOUrx04cKD5rNdMKA2gnX766bau4RMBJAAAAAAAgGDz4IMPmuorjiCRlvIvXjrngw8+kF69ell6bV0ZrSXyXJW2U02bNhVP0kwizSh64okn5Nprr63UGG3+Xd3NzAEg0GiGSUpqhvToWP3ly1B5GrzRsnaTJ0+WmpxHtGnTRr7++mvTu0k/UydNmmSCSOvXr5dBgwbJk08+aesaNkJ59ml69gsvvGAaOOpkKSwsrMxWE7UCAQDwFE0NtrvBdzBXAQAEGuYqvkUbbGvJmVmzZsnLL78sH3/8sfNYcnKy9O/fX+68805Lr92jRw/57bff5Pjx4yX26wMlx3FP+ec//2makt99990yYcIEj70uAKCs1LQsKSgslIT42oF5ezT7yO7mBf/6179qvHydziFGjx4tcXFxJpaiCgoKzNc+ffrILbfcYjug5dXozPjx480kSSct11xzjUm1AgDAn2n8J5QSdgGDuQoAINAwV/E9nTt3Nltp+oxk9uzZll93+PDhMmPGDJk/f76MGzfO7NOSdtrbQR8qNW/e3Ozbs2ePZGZmlmkEXlmvvvqqCXLpAzN9xgMAqF5JqWnma726AR5AsjPeC1lhy5cvl9NOO006dOhQY9fV5Js6deqY/46Pj5eIiAg5fPiw87hmJ/3yyy/2riFetHjxYrnsssvktdde8+bbAADAY0LEXhaRjofvYK4CAAg0zFV80++//y7/+c9/TM8j1bJlS1N2pnXr1pZfU4NE2l9o4sSJ5mGSNhPXuc2uXbtkwYIFzvNGjhwpa9asMZnXDtqEWxtyq6+++sp8nTt3rnk4pdvtt99u9m3YsMGMT0xMlLPPPtu5+tqhb9++5uEVAMBzklLSJa52tESEn8g4CczVLt7pgWRVaGio/PHHHzV+Xf1s37Ztm/lvfRali0G0p6IjC0pL4WpfJ78NIGVlZck555zjzbcAAADgFnMVAABQ3e655x6ZM2eOWb1c+mGUloTTLCKrlixZYkrXLF261JTE6969u7z//vumNF559NzSJW9mzpzpDG45Aki6qll7Lhw5ckRuuOGGMq+j2U4EkADAs46lpEti/ImsEwS3wYMHmxK4jz/+uMlG+sc//iHXX3+9tGvXzhzfsWOHOea3PZB0dco333zjzbcAAIBHhXhgg+9grgIACDTMVXyLBmW0TN2ll14q69atk5SUFLPpf2sJOj1mp4xdVFSUTJ8+XQ4cOCDZ2dkmY+j8888vcc7q1atLZB+pVq1amX2uNs1gchg1apTb83TT4wAAz0pKTQ/c/kd+3APJG3Sxxw8//ODsf3TdddeZxSNdu3aVU045xQSX7PYm9GoG0rx588zE5bHHHjMNnTTlGQAAfxYaEmI2O+PhO5irAAACDXMV3/Liiy/K0KFDy5T21/Jz2ktBgz4vvPCCjB071mvvEQDgOwoKCiX1eKYkBGr/Iz/tgeQt2vOodEzlmmuuMZunePVuakOpnTt3mkhZw4YNJTY2VuLi4kpsdevW9eZbBAAAQYy5CgAAqE6azVM6I6g4PVY84wcAENxSjmdIYVGRJAZyBhJ8ilczkC677DJbjcYDUW5ByZrHlbX9UKbla3ZoYr1m5oIN1ieyN/Ru5fZYaGiIhIW6/tmoE2X9xza/sGRaflV8vOWQpXHXnNbS8jX3HC3/9zUzP1xiYiJcHnv7pj5S0wa0b2B57OHjOZbHNoyLtDTOzl8/D3601fLYGUO7WB57LC2nWu5RXkGh5OQVuDwWGe76Z6wymiVGWx6blpVnaVz3pt5deKA/V3Z+tvhY9C3MVfzf9oPplse2bexf/yh776f9lsZd1LWpeMOPjw/yynWDxf0fbrE89tHBHT36XuBbmKv4Fl1Mq6Vn3NFjDRpY/3cWACDw+h/p8/T4uFgJ7MmKnQykwI03DBw4sMpj9Ofls88+888A0qJFi7x5eQAAPC8kxN7iiACe6Pgj5ioAgIDDXMWnjBgxQubMmWN6Dt1xxx2mMovKyMiQuXPnyksvvSR33323t98mAMCH+h/Fx8VIWFgAl2nT4FEoJexcKSwsrPIzp9J9Dv0qgAQAAAAAABCsHnnkEfn+++9l0qRJ8uCDD0rTpieyQvfv3y/5+fkyYMAAefjhh739NgEAPiIpJT2w+x+hXKtXr5aaVqMBpCVLlpiv1157rYmUOX5dkZEjR1bzOwMAwDMoC+PfmKsAAAKdN+cqOTk5JkiydOlSSU5Olu7du8u0adPk3HPPrXDsvn37ZOzYsfLxxx+b1bcaWJk9e7a0adPGec7evXvl5Zdflg8++EC2bdsmYWFh0rVrV3nggQfknHPOKfOaKSkpMn78eHnrrbckMzNTevfuLTNnzpTTTjtNakpMTIwpK/POO+/If/7zH9m9e7fZf8EFF8jgwYPloosuovQ/AMDpWEqadGjjnRLUNYYSdj6lRgNIo0aNMhOfK6+8UmrVqmV+XRE9nwASAMBfhIaEmM3OeHgPcxUAQKDz5lxFP2dXrFhhSrK1a9fOlIrVIMmqVaukX79+bselp6ebgFFqaqrJ1ImIiDDBozPPPNNk7yQmJprzNAjz5JNPyrBhw+S6664zGTy6OEQDVBpYuv76652vqUGoIUOGmB5D9957r9SvX1/mzZsnZ511lmzcuNG8v5p08cUXmw0AAHfy8gvkeHqWJMYHeAaSlrCz1QMpgMv7ubFmzRqzgMaxEKVly5ZmnqNzJb8KIP3+++/mqwaPiv8aAADAFzBXAQCgemzYsEGWL18u06dPl3Hjxpl9ulhUM4Q0C2jt2rVux2pgRzOK9DV69epl9g0aNMiM1Yyhxx57zOzTINOePXtMMMjh1ltvlR49epjMp+IBJA1k6TVff/11GT58uNl3+eWXS/v27WXKlCnyyiuv1Njc46effjKZRq6899570q1bN9MjCQAQ3JJT083XhLp1vP1W4CNyc3Plqquukrffftv0OoqPj3dmWesc6ZJLLpF///vfZvGNXwSQNPJV3q8BAPB3uibXVlkYT74ZVBlzFQBAoPPWXEUDNlpS7uabb3bui4qKktGjR5usIi0/17x5c7djNXDkCB6pjh07ytlnny2vvfaaM4DUpUuXMmMjIyNNltOsWbMkLS1N6tSp43zNRo0ayaWXXuo8t0GDBiaItGzZMlNuT8dWNw2mHT9+3G0A6Z///Kd5GKTBNwBAcNP+R2GhoVK3TrQENDKQKm3q1KmmFK/OJ+655x4zt1GHDx82ASRduKO9FLXnolXBl88FAEC19xUIsbHx2wMAAHx/rrJ9+3b5+eefS2z6sMKdTZs2meyeuLi4Evu175DSUnSuaKm5zZs3S8+ePcsc07E7duwwgaHyHDx40PQa0q34+9FeR6GhoWVeU/sh/fbbb1IT1q1bV24PKA2SffHFFzXyXgAAvu1YSrrE140t89kVsD2QLG/B82DllVdeMWV7n3rqKWfwSDVs2NCU9dVsb+09aUeA/7QBAAAAAABP0z5DWkKu+Kal5tw5cOCANGnSpMx+x779+/e7HJeUlGSygayMdQS63nzzTbnssstMBpTd9+NpycnJzqwoV2rXri3Hjh2rkfcCAPBtSanpklg3wPsfoUp0PtOnTx+3x/WYLqSxo0ZL2AEAEOhCbK7OCJ51MgAAwJ/nKlprv23btiWOaQk4d7KyslyWhNMydo7j7sYpK2M1k2jEiBESHR0tTzzxhEfej6e1aNFCvvrqK/n73//u8rhmHzVr1qxG3gsAwPdL2HVt77rcayApCjmx2RkfLJo1ayarV682PR9dWbNmje15BBlIAAB4kL2SMCc2AAAAX5+raPBIew4V37RcijsaxNFMotKys7Odx92NU1UdW1BQIFdeeaX88ssvpt9R06ZNPfJ+PE0bX2tz62eeecaU6yv+/ufMmSOvvvqq/O1vf6uR9wIA8F05uXmSnpktCfGBn4FUVFQkRUWFNrYiCRbXXXed6QepAaStW7ea+YPOJ/S/dXHK66+/LqNGjbJ1DTKQAADwoNCQE5ud8QAAAIE2V9HScPv27XNZekWVDvA4JCQkmEwhx3mVHXvTTTfJ+++/L//6179k4MCBLt9PVV+zOkycOFG+/PJLufvuu+XRRx+VDh06mP364OfIkSNy1llnyf33318j7wUA4LuSUzPM18QgCCAVFhWazc74YDFp0iTTD3L+/Pny4osvOvtjaRBJA2kaYNJzAiaAlJqaaur7Fq9LDAAA4CuYqwAAYE2PHj1k1apVcvz4cYmLi3PuX79+vfO4K/ogpFu3bvLtt9+WOaZj27RpU6aH0L333isLFy6Up59+2mT4uHs/Wh5OH7AUb0aurxkTEyPt27evkd9qDY59/PHHsnjxYtOrSR8Cqd69e5u+Tdr8OuCbpQMAKnQsJU3Cw8OkTmzNZMjCP4SFhcmiRYvkH//4h3z44Yeye/dus79ly5YyePBg6d69u+1reH0WopPACy64wEzQEhMTTV0+dfToUbn44otNDT8AAPyFVnUJtbFRwc73MFcBAAQSb81Vhg8fbsqq6ApZBy0hp4EebfDcvPmJng579uyRLVu2lBn7zTfflAgiaYbOypUrTY+j4qZPny4zZswwq23vuuuuct/PoUOHTNDGQZ9DaKmXiy66yGV/pOqiAaLrr79e3nvvPVNyTzf9by05Q/AIAODof5RQNzYoyt4XSaHtLdh0795d7rvvPnnuuefMpv/tieCR1zOQ1q5da1LJTzrpJLnmmmvkpZdech6rX7++WeX7wgsvmJRtAAD8gd0+RsEwGfQnzFUAAIHGW3MVDRJpsEdLth0+fNj0UNKsm127dsmCBQuc52nGjS4sLd6/YMyYMaYsy5AhQ2TcuHESEREhs2bNkkaNGsk999zjPO+tt96S8ePHS7t27aRTp06ybNmyEu/h3HPPNWMcAaQzzjjDBG40YKPPIObNm2eCXFOnTrX0PQIAUF2SUtMlIb5kxm2g0jmAnTJ0wdQDqSZ4NYCkK4J0Uvf1119LWlpaiQCSGjBggJlQAgAAeANzFQAAPGfJkiUyefJkWbp0qSQnJ5uVsdqnqH///uWO0xJ1Wp1k7NixMm3aNFN2Theazp49Wxo0aOA874cffjBft23bJtdee22Z19ESeo4AkpZ80VIvWu7umWeekaysLOnVq5cpA+PoQwQAgK84lpIuLZv+7zMPwSk0NNRsmZmZUqtWLfPfFS3u0eP5+fn+GUDSFPTHH3/cpIanp6eXOa6ZSQcPHvTKewMAwGptWFuNqbntPoW5CgAg0HhzrhIVFWVKzOnmjrsy9s2aNTPl5crz0EMPma2y6tWrZxayll7MCgCAL8nKzjVbQnxtCQZ2y9AFcgm7Bx980ASEwsPDS/y6Onk1gKRp57pyyJ19+/ZJ7dr++QdjyTd7peGRKJfHYgsyJCMs1eWxHo2tpSKe3aGhWJWVV2B57CVdmkpN27grxfLY5gnWG83Fx0RYGmfnH2fNE8t/v0kSKQluzsm28fs69p1fLI279lTrPw9ntEmwPPbw8Ry3x9Iz8yQ/wvXxJvGu/4xWxstXuW7yWxlZudZ/b9o1tvZ3YlhFP4g5EZJQu5bLQ0fKub8VqRfr+jUrIyoizNK4lGOZ4k36uW3ns5sKdr4lkOcqwaKtxb837SgstF4yIdTGxOGirjU/L/OWen3c9zUpT/L6ORIsHh3c0dtvAT6KuQoAAP5Xvk4FSwCp0GYJOx0fqB4qtVCmKgtn/HKhs9YbXrFihctjGRkZppnmmWeeWePvCwAAQDFXAQAAAAB4U1JKukTWCpfY6Eh+I1CC9nEM6ACSNqb89ttvTSPM//znP86axZo+fvrpp8uRI0dMfWQAAPyFpg6H2tiqO/UYVcNcBQAQaJir+JYbbrhB1q9f7/b4hg0bzDkAgODuf5RQt3bQPC8oKiq0vQWLrl27mp6Sjz32mGzfvj3wAkh9+vQxTSv1mxs5cqTZd88998jNN98sBQUF5pjeAAAA/KqvgM0NvoO5CgAg0DBX8S2LFi2SHTt2uD3++++/y+LFi2v0PQEAfEtSSlrQlK9z9DCy879A7oFU2nPPPScNGjQwvZA6dOhgknK01+Tu3bslIHogqYEDB8rWrVvl+++/l23btpk+AyeffLL5ZoMlqgoAAHwXcxUAAOAt+/fvl+ho6718AQD+raioyPRAatuqsbffCnzQLbfcYrZDhw7J66+/Lq+99prcd999Zuvdu7dceeWVMmLECGnatKn/BpAcevToYTYAAPyZNxtT5+TkmFUnS5culeTkZJPFO23aNDn33HMrHLtv3z4ZO3asfPzxx2Yxx4ABA2T27NnSpk2bMucuWLBAZsyYYVbENm/eXO6880654447XL7uq6++Kk8//bRs3rxZIiIipHPnzuY9aVDG3zBXAQAEAm/OVXDCO++8YzaH+fPny6efflrm9qSkpJj9vXr14tYBQJDKzMqRnNx8SaxbR4JFkf7PRhk6HR9sGjVqJLfffrvZ9PmOI5ik1d7GjRsneXl5/hlA+ve//y0fffSRSdl25frrr5dBgwbJ5ZdfXuPvDQAAKxy9jKyyM3bUqFGyYsUKufvuu6Vdu3bm83Xw4MGyatUq6devn9tx6enpJmCUmpoqkyZNMoEeDR6deeaZJkM4MTHRee4LL7wgt956q1x22WXyj3/8Q7744gsTQMrMzJQJEyaUeN2HHnpIHn74YRk+fLh5bzph+emnn8xkxl8wVwEABBpvzlXwv4bX+mBHaeUV7YG0cePGErdH98fGxkr//v1l1qxZ3DoACOL+RyqYStgVFhWazc74mrZx40aZMmWKfPvtt+YZiy7GvfHGG+W2226TsLCwGn0vTZo0kS5dukinTp3MM5iMjAxbr+fVAJI+nDr11FPdHtc0bT2HABIAwJ9447mKNlhevny5qXWrq0uU9hfUhorjx4+XtWvXuh07b948U0ZWX8OxwlUXcOjYmTNnmmaMKisrS+6//34ZMmSICVSpm266yWQsPfLII6aHYb169cz+r7/+2gSPdLxmNvkr5ioAgEBEDMi7Jk6caDYVGhpqsrv/9re/efldAQB8kZavi46qZbZgUWSzj1FN90DauHGj9O3b1yzk1YW1MTEx8p///Efuuusu0+dwzpw5NVLqcPXq1aYKzFtvvSVHjx41z2e0hN0VV1xh67W92qtbex+VF0A65ZRTZMuWLTX6ngAA8Eca0NFVLRrEcYiKipLRo0fLunXrZO/eveWO1cBR8fIoHTt2lLPPPtukPDtoJtOxY8dkzJgxJcbrihpd0fLBBx8492nZusaNG5sJk05kdAWOP2KuAgAAqkt2drZZrNKsWTNuMgDApaSU9KDKPvJHL7zwgvn6+eefmwW02pPo7bffNlnE7iqveYpWhdGWAtrj6JxzzjEBJK1Eo89nDh48aMrk6rMdvw0g6QMlrenrjvZvsFOfDwCAmhYaYn+zYtOmTdK+fXuJi4srsV+bJiotReeKZg9pf6KePXuWOaZjdbVMWlqa8xqq9Lmnn366WT3rOK4+++wzE5B65plnpEGDBlKnTh2TRj137lzxJ8xVAACBxltzFZSli300E0kXrAAA4K6EXULd4Aog6b/DHWXsrGw6viYdP37cfKbHx8eX2K/PQLTCWnXS1gOLFy82faY18+jQoUOycOFCueCCCyQ83DPF57waQNLsI+0tkJub67IR+CuvvFJuhhIAAL7aV8DOprZv3y4///xzie3w4cNur3vgwAEzOSnNsW///v0uxyUlJZnP3MqM1WtollPDhg1LnFerVi3TJ8lxni4A0XTpr776SiZPniz33XefWQXTo0cPszLGsTrHHzBXAQAEGk/NVeAZ2qNg165d3E4AQBkaCElOTZfEIMtAKpIC21tNOuuss0wQSTOPfv31V9m9e7c8//zz8uabbzpL1lYX7amoz4r+9a9/ydChQ83zGU/zag8kfaB04YUXmsbd+t86cVLa3Onxxx83D8veffddb75FAAC8YtiwYWX2aUPGhx56yOX52p8oMjKyzH5dBeM47m6cqsxY/epuMqLnOs5zlKvTcnfal8lRb3f48OHSrVs3mTZtmplY+QPmKgAAoDo9+uijpv+RPhfR0jMAADikZWRLXn4BJews0oW5pWmFlNKLYu266aabTBxDF8u+9NJLZp8uvtUKLLfeeqtUp8suu0yqm1cDSNqgW5tFan+E4g/KNLqqpW5efPFF06gbAAB/oYty7SzMdYzVerlt27YtM9FxR9OiNZPIVW19x3F341RlxupXV1nDjnOLn6ciIiJM0MhBy9xpMEkDYXv27JEWLVqIr2OuAgAINJ6aq8Az9OFSQkKCnH/++dK6dWuzlZ63hYSEyDvvvMMtB4Agk5Ryopx8sJWwc5SiszPeysJcM7aw0O1zj9J0Ia5+Rmuw6OSTTzaf5SNGjDALbLXqmlZg0d7Qrt6HVZp0o69bu3bVfiY0Q+qf//ynpYworwaQ1KhRo+TSSy+VTz75xPRZUHrDzzvvPBNEAgDAn4TY7A3geCijwSNHZm5laLm5ffv2ldmvZeeUNlR0RR9Y6KTHcV55Y/UaBQUFJj26+IodnVxptpHjPH1NR/1fnUgV5xinZe78IYCkmKsAAAKJp+Yq8AztRakPn3RepPMsV6ul9TgAIPgkpaZL7ZgoiawVIcFEk0uKbASQHD2QqrowV33++ecmK7gyfv31V+nYsaM88cQTMmfOHNm2bZszsHP55Zeb17nttttMBTZP9SPSlj9PPfWUXHXVVeYaf/3rX8s8d3HIy8uTNWvWyGuvvWY2nWv4VQApMzNTmjdvbkrD3HvvvTWSbgUAQKDS/kKrVq0yq0ri4uKc+9evX+887opmBWlZuW+//bbMMR3bpk0b54IOx2vouYMHD3aep7/WVTqO4/qa+t/ffPONCS4VL3vn6JNU0aTNFzBXAQAA1Y3+RwAAd46lpFO+zoaqLsxVGhBauHBhpc5t8mff6Hnz5snAgQPLZAVpT6J//OMf5rO+dCDLzsITDSLNmDHD9FnSBcFdu3Y1Gcz16tU70TcrOVl+//130yZIg0j6zEcznq+++mpL1/RaACkmJsZE3mJjY731FgAA8DhdHxpi/t/6eCu0VJxOIObPny/jxo1zlqXTiU+fPn3Mog2lpeM0MKKTouJjdUGHBoJ69uxp9m3dulVWrlzpfC2lEyLNLnruuedKBJD01/q5XrzsrJaq+/rrr2Xx4sWmHrCjzJ02duzcubPbjChfwlwFABCIvDVXAQAAVZOUki7NGicG3W0rkkLzPzvjrdKSc1qFpCoOHTpksohL0+CNys/PF0/RrGQNBOm2adMmk2W1bt068/xFK8OoxMRE88xnwoQJcvHFF8tpp51m65peLWGnWUcrVqyQv//97wGXkj2yV3Pp3Plkl8eSjh2VhMT6Lo/1nvqJpeutm2y92WZkeKjlsRFh1sdm5Lj/w5OdV+D2+Omt4i1fc9vBE43drYiMcJ0OWJE/klw3rq+MBnFlm9oXV1BUJPmFJ9IyS8vKLfsXV2VNHOD6Z7ciLRJjLF8zLdv6X6bRtdz/3uSFh7o9npRx4i9yK374I8Xy2DPbW8+8SM209p7vfPPHco83Cs+WQ/l7XB5bco29DxqrcgusfeC3rG/959ATQm2WhbE6VoNEWmtX05G1xJyubtHgja500X6DDiNHjjQpzI6UbjVmzBhn30ENGGnvolmzZkmjRo3knnvucZ6n9fgfeeQRk4Kt19L6vl988YUsW7bMNIDW4JLDLbfcYppH6rm//fabSZVeunSp7N69W9577z3xF4E8V7Hq/g+3WBr36OD/BS0DXaidvwRQKcnr53CnAsydb/1U7vHEkCw5VnTI5bFnLulaTe8qMHlrroLy6fzsgw8+MHMl1bJlSzM3O/PMM7l1ABCECguLJDk1Q7p3bCnBRsvX2SthZ32sFe3btzfteTSAo8EbpQElLRunFV20XU91OPXUU81W3bwaQLryyivNQyutB6irk1u1auWyybfdKBkAAMFgyZIlMnnyZBOo0ZTl7t27y/vvvy/9+/cvd5xOaFavXi1jx46VadOmmXJ0Z511lsyePbtMqTn93NYA08yZM+Xdd981mU163l133VXiPP081wym8ePHy8svvywZGRmmrJ0+GNHAk79grgIAAKqTlvvVPga6glgX+GgPSZWSkmLmW5dccolpxK3zLwBA8DienikFhYWSGF+yLBp8z3333SfXXHONWdh78803m+ch+tm9ceNG84zF3z/DvRpA0odTDrqCuTSdPOlqX1cpYAAA+CJdlGurMbWNa0dFRcn06dPN5o4Gilxp1qyZvP7665W6ji76cJSlK0/Dhg1l0aJF4s+YqwAAAo035yooa+rUqfLWW2+ZLHDN/NYMcKUZ5RpA0nndww8/bLLAAQDB1f9I1asbfO1fCrUInY0sIh1fk66++mqpX7++PP744+ZzW3tTd+jQwfQo0uosNUWv+8ADD5iFu0eOHDHPZAYNGmTmEI4FKn4XQKpsQyoAAPyFLnywU+qMMmm+hbkKACDQMFfxLdoI+7rrrpOnnnqqxH596PPkk0+avgqaXU4ACQCCS1JKmsTVjpaIcK8+vvcK7WFkp4+RnbFWnX/++V6vtqLZT7169ZKvvvrKBLQ0iKQtB3S/ltOzyqs/gTpJAgAgkNBXILAwVwEABBrmKr7lwIEDpuSNO3ps+fLlNfqeAADel5SaIQlBWr5OexgV+lEPJF9x8ODBEn2smzRpIvfee2+JyipWhHrgvQEAAAAAAKCKtIywuxLDas2aNeYcq3JycmTChAnStGlT05NBA1La6LsiW7duNf0x+/bta8oka+barl27XJ776quvmt4P7dq1M+fZfVAFANASdmmSGF+HW4FKy8vLk/3795fY98cff5h+i3Z4NQPphhtuqPAcnXwsWLCgRt4PAAB2afU6GxXsbI2F5zFXAQAEGuYqvpftPGXKFNObQAM2bdu2Nc9Btm3bJk8//bTpUal9kqwaNWqUrFixQu6++24T4NH+lIMHD5ZVq1ZJv3793I5bt26dPPPMM9K5c2fp1KmTfP/9927Pfe6550yjcC2bc+zYMcvvFQBwQkFBoaQez5SEIOx/pIrM/+yUsKvZHki+Ytq0afKXv/xFunfvbkrYaT/FH3/80XZvaq8GkFauXFmm10NBQYFJ4davDRo0kNjY4PyDAgDwT/q5FkoPpIDBXAUAEGiYq/iWSZMmyY4dO2T+/Pny4osvSmjoiUIxhYWFUlRUZAJMeo4VGzZsMOXvtKH3uHHjzL6RI0dK165dZfz48bJ27Vq3Y4cOHSopKSlSp04dmTFjRrkBJO3RdNJJJ5n3rq8NALAnJS1DCouKJCFIM5AKbZawszPWnw0YMEB+/fVX+frrr03wSPspnnHGGRITE+O/ASR36c+abvXCCy+Y1TaVSa0GAACoDsxVAABAdQoLCzMrg//xj3/IBx98IHv27DH7W7ZsaTKFdBWxVZp5pK+vzbMdtBzd6NGjTVBq79690rx5c5djExISKn0dd68BALAmKSXdLPioF0diBapGg0UDBw4UT/JqAMmdiIgIuf322+WXX34xX3USBQCAP6AxdXBgrgIA8FfMVXyTBorsBItc2bRpk7Rv317i4uJK7O/du7f5qllF3g7+6ArpI0eOlNi3fft2r70fAPAFx1LSJb5OjISFnchKDTZFRZqFa6OEXZBmILmjWUialRRQASSHU045xaRCAwDgL7Qwq60eSJ58M6h2zFUAAP6GuYpv+umnn+TDDz90Zj+3bt1aLrjgAunWrZvl19T2AE2aNCmz37GvdKNtb5g3b57bHk9JSUllgkuoutTUVG5bDeA+14xguc8HDx+T2OgIr/0daOc+a0sau050QKIHUlV9/vnnLvfv27dP7PDpAJKWr7Nbow8AAKC6MFcBAAB25OTkyC233GIWz2rPo+I9kO677z65+uqr5aWXXpJatWpV+bWzsrIkMjKyzH4tY+c47m1jxoyRESNGlMlAGjZsmCmj54kHkfDMA11UjPtcM4LhPqdnbZH2rZt49XsNhvsciD2QWrZsaeYTpbN9/TaA9PDDD7vcr40aNWL23XffmQkTAAD+IlRCzGZnPHwHcxUAQKBhruJbJkyYIEuWLDGBlDvuuENOPvlk0/dCgyjPPPOMPPfccyaQoj2iqyo6OtoEqErLzs52Hvc2bfCtGwDghLz8AklNy5SEurWD9pZQws6aFi1ayIYNG6R+/fol9rdr1078NoD00EMPudxfr149M2l6/vnn5aabbqrx9wUAgGUh9krYET/yLcxVAAABh7mKT1m2bJlce+21Mnfu3BL7O3ToIP/85z/l+PHj5hwrASQtVeeqbI2WtlNNmza18c4BANUhJTXDfE2MD94AUmFRkdnsjA9Go0aNMmUPSweQbr31Vv8NIGlKNgAAgK9irgIAAKpTXl6eaW7tTt++feW9996z9No9evSQVatWmSBUXFycc//69eudxwEAvuVYapqEhoZI3Tq0dUHVTJkyxeX+e+65p4qvVNKJ4roAAMAjQkPsbwAAANWFuYpvOf/88+Wjjz5ye/y///2vnHfeeZZee/jw4VJQUCDz58937tOSdgsXLpQ+ffpI8+bNzb49e/bIli1bLF0DAOBZSSnpUi8u1tkTLxgViWYgFVredDw8x6sZSA5r1qyRDz74QHbv3m1+rc2ehgwZImeeeaa33xoAAFUSGhJiNqvsjEX1Ya4CAAgU3pyraPDiwQcflKVLl0pycrJ0795dpk2bJueee26FY7UU29ixY+Xjjz82GcLaKHr27NnSpk2bEudpz6CVK1eaLJu9e/fKddddJ4sWLSrzerrv+uuvd3ktLfHWuHFjqQmPPPKIXH755XLppZfKbbfdJm3btjX7t23bZkrY6XOSV199VZKSkkqM075IFdEg0YgRI2TixImmgba+9uLFi2XXrl2yYMEC53kjR440c53iTbdTU1Pl2WefNf/91Vdfma9aZi8+Pt5st99+u/Nc7WGtm9LSORkZGeb3VfXv399sAIDKB5AS4usE9e2ihF3lDRw4sNzj2lcxKipKmjVrZuZOurgkPDzcfwJIubm5ctVVV8nbb79tJio6CVEpKSkyc+ZMueSSS+Tf//63REREiL/RKXWIhWOvjekrNS2vwHpUNjkj1/LY9Ox8t8ey0nMlK+REY8/Swmwsz2/fxPpfwN54pPtHUla5xzPS8yQvrGxTVLUnOdPydU9vWc/SuNwC62Up46Kt/3VUXmnTgsxwqRvt+u8QO8/pz2rfwPJYO9etFW5tBUqfNif+fnUnOj9dWoW7rq973b82iVVzL+tmeewXO49YGtc+0fqf8+7N7U/S9PfXzu8x8SPfEshzFaseHdzR22/B5333e7Llsae1tvYZDPi7OpHlzwWji8KkTojrc9bvKPlgvSr6nFzxQ/hA4825itbmX7Fihdx9992mobMGcQYPHmzKrPXr18/tuPT0dPPQQ4MakyZNMp+7GjzSRafff/+9JCYmOs998sknJS0tTXr37u3s9VOehx9+WFq3bl1in+PzviZ06tTJfP3xxx/lnXfeKXHMEdDp3LlzmXGaWVQZS5YskcmTJ5cI2r3//vsVBnX0XB1XnM59HIt+iweQNGA3derUEuc6xmo5HQJIAFB5x1LTpWu7ExmiwUpziHSzMz5YFBYWmkU2O3bskHr16kmrVq3Mfl0sop/lunikbt26ZmHNiy++KE888YR8+umnZfok+WwASScYb731lowbN87U4mvUqJHZrytjdGIyffp0M5nTFTkAAADMVQAA8E8bNmyQ5cuXm3/n6zMAR+ZL165dZfz48bJ27Vq3Y+fNm2cycvQ1evXqZfYNGjTIjNVnB4899pjzXM2kadGihVlxW7t2xQ3I9XV69uwp3qIZWfpeq4uuOtZ7rps7q1evLrNPH0AVz0gqz0MPPWQ2AIA9ubn5kp6RLQl1K/78ApRm/A4bNsxkGP/tb3+TsLAw50KTZcuWmTmXLibRrGQ956abbjKZyRpM8osA0iuvvGLSyZ966qkS+xs2bGhWDR06dMiskiGABADwF/oAwE5pl+p8gICqY64CAAg03pqraOaRPtS4+eabSwQ3Ro8ebbKKtNycoyePq7EaOHIEj1THjh3l7LPPltdee61EAEmzY6pKM5ZiYmKcD11qEoEXAIBDUmq6+ZoQH9wBJF3AoGXs7IwPFuPGjTMlea+99toS+3VOo3GXn376yZQAXrdunckE16/vvfdela7h1W5cmk6u0S939NjBgwctvbamuGuq9AUXXGBqA+sk11XdY71xeqz0ppNRAACqKqRYaRhLG7fcpzBXAQAEGm/NVTZt2iTt27eXuLi4Evu11JzSUnTuSrNs3rzZZZaQjtWSLRoAskpL4+l70gDS0KFDTaaTr5TR1V5CAIDg6n8UHhYmcbWjJZgVFhXa3oLF5s2bnWXrXNFjP/zwg/PXp59+epm+ij6dgaTNmzRV+tZbb3V5XFPP9Rwrjh49asrfaer6Kaec4jIl2yEyMlJeeumlEvu0NiAAAAhuzFUAAHBt+/btZfY1aNDAVBRxtyijSZMmZfY79u3fv9/lOH3IkZOTU+HYDh06VOm3SgNGuqDUEUDauHGjzJo1S/r27Svfffed22woT9OyftqXQHs6FS/3/+ijj5oV1BdeeKGpzFKZcnwAAP92LDVNEuJjqUyCStO5kGZq//3vf5fQ0NAyi3A0U7tx48bOfceOHTPJNn4TQNI0Ks0S0gaVmkqlTZ00+0dX/Dz99NPy+uuvl2nEWJWbpxNUvUHffvttiVT30sLDw+Waa66x8Z0AAHBCqM30Xq+mBqMM5ioAgEDjqbmK1tsvTf99764kW1ZWllm8WZqWsXMcdzdOWRlbnssvv9xsUuz7Of/886V///4mePP8889LTdAeTqeeeqrz19oLSp+DDBkyRDp16iTPPvuseT+PP/54jbwfAIB3M5Dof6QZSLoV2RofLP7xj3/IHXfcIf/3f/9n+hudfPLJzoU+2ufom2++kWeeecZ5vsZbHNnffhFA0jrHmm4+f/588w05omQaHdOVNvrQRs+xQieXxaNrFdHGUpoeXjqdHgCAqjhR3sVOXwHuty9hrgIACDSemqu8/fbbZhFo6Qwkd6Kjo00mUWnZ2dnO4+7GKStjq6pfv36mlP6nn34qNUWfieizj+L9F/VZxltvvWUWu+rzkTfeeIMAEgAESQCpRVP3n6XBgh5IlXfbbbeZmMqDDz4oN954o3OOp/cwMTHRBI/0HMdcSjOeyyt553MBJG3mpH2JNFL24Ycfyu7du51NLwcPHizdu3evkfeRmZlpAkf6tV69enLVVVfJk08+WWGK+OHDh+XIkSMVpvEDAAD/xFwFAADXNHjUpUuXKlUJ2bdvX5n9WjlENW3a1OU4LbOiC0Qd51VlrBVaum7r1q1SU/RhjiOTSn388ccyaNAgEzxSnTt3lnnz5tXY+wEAeEdWdq5kZudKYjwlS1E1Wr5Og0eabbRnzx5nfEX7R0ZERDjP0/nUmWeeWcVX93IAyUEDRTUVLHI1iR0/frycdtppZmXPf//7XzM50+ZS2jfJMWlzRc9zV2IvNSVZko4ddXks7Xiq29fMPF711HuVLJlilZ2UwPTsfMtjs3IL3B7LyXTfBDXUxur8pFBr91d5Iykg43jZVXbFZWe4v08FmSdW41mRkuT+96a6blKtMOuFNMr7ES7vz5udTA8bf2xsXbe8Pzflic5PL/d4ZIH7PxuNwq3/LKUmH7M8NiT7uKVxWWnW/14SqSOeQBJR4AnEuUpKSpIcO1pyIYw6nur+701U7j7lZpT/d255jh2183eY7+HniXtUWXWLyv/3TKxki7iZf+VlpIhVx45anPd6yUmNG/jtXKVHjx6yatUqOX78eInKH9r/x3HcFV1V261bN1OavjQd26ZNG6lTxzNzOLVz585yM6k8rXXr1ibjSR/86Peoi1K1ZJ3DoUOH6H8EAEEgKfXEvyEoYSdSqP8rKrQ1PthERESYPo66eZpPBJActmzZYurw6Sqijh07moaW1V1SrnQd4SuvvFLat28v999/v2lApb92Z8yYMTJixIgS+3Syp7WT68bXk4TE+m7HujuWWpghVtRLjBGrCmwUhizKyLU8VioIPkXXqedyf5iNCFJCYqxf/SMrM6TigFdsXdeNz8IKrQcV4xNc3/vqDIxEhldPAKm8P2/+GEDKyLH2kCMrvOK/W7LCXa9yOZRv/cFK3XqJlscWJVv7wI/24AMEK0JDQsxmZzx8VyDNVeLjEySxvusHZO72o3L3aXea9Sl2Yn1rn8G+jJ8n7lFlpIZUsOikSM9x/W+eiNh4sSqxftWaCAcCb81Vhg8fLjNmzDAl7MeNG+fMvlm4cKEpG6eZP0pXzmp1EP2cLT72vvvuMwEWXU2rNEto5cqVzteqKq0mUjpQpJVRNm7cKHfeeafUlFtuuUXuuusu+eWXX+SPP/6QZs2ayYUXXug8/tVXX1Up0wsA4L/l62pFhEtsTNmef8FGkx3s9UAKoiZIcqI1z7Jly+SDDz4oUeFN5xNXX321qaziVwGkuXPnmtp72hiyfv3/PdR97733zAOO3Nz/BST0vK+//rrEeTVh7NixMnnyZLMKqLyHMg0bNjQbAAAIHMxVAADwPA0S6b/5J06caMrBawm8xYsXy65du2TBggXO80aOHClr1qwxtfuLL4jQvslDhgwxASNdZTtr1ixp1KiR3HPPPSWuo88WNEtX5eXlyebNm2XatGnm10OHDnVmFOsK3VNPPdUEpOrWrSvfffedvPzyyyaQZbUXsxXa+FpL2Gnw6vTTT5cJEyY4ezolJSXJwYMH5dZbb62x9wMA8F4Gkpavs9OnEMEnNTVVzj//fFO+TjOyNTNbffLJJ6aH4nPPPScfffSRrYWvNR5Aevfdd+Xkk08uERTKz8836doaDdPVRzqB04iZrqzV1G1t7lSTdLKmTaZ0sgYAQFXoVM/OdI+povcxVwEABDJvzlWWLFliFmsuXbpUkpOTTTDn/fffl/79+5c7Th+IaNlWXeypwSAt6XrWWWeZZwWls4j0YYkGphw2bdpkNqXZPY4A0hVXXGGeO2jPIc140pKxN910k0yZMsUEpmqSXlc3V/2fXJXuAwAEnmMp6VKvLv2PVJEUSaG72sWVHB8s7r//fpM9/eyzz5q5hKPnkS6ieemll0xWtZ6jx/0mgKRp2aUnRloHWdPHdZXPddddZ/ZpirauGtJVODUdQEpLS5OjR4/WaN1jAEBg0MVCdhYMsdjI+5irAAACmTfnKpppM336dLO5o4EiVzT4o2VkK7Jo0SKzVUQDUY7MJAAAvEmzbrWEXdsWNbuAwbdL2NnogRREJezeeustk6mtW3EaSPr73/8uv/76qyl971cBpGPHjjlrGzt89tlnJj3vkksuKbH///7v/+TNN9+stveSnZ1tonGlG24+8sgj5g/uBRdcUG3XBgAEJv08s5NyTrq69zFXAQAEMuYqvkdLy2gZv507d5rMrOLl+xy/Zzt27PDa+wMAVK/MrFzJyc2ThHgykBQ9kKr2/KJDhw5uj2tPSbtV1mo8gKSp4FrDt7gvvvhCYmJi5JRTTimxv1atWmaz08MgJSVF9u/f76yFrE0pHXWGdWKmNY+vuuoqZ4NOnbhp1pMGjy6++GLL1wYAAP6JuQoAAKgpmo113333mflH7969pVu3btx8AAgySalp5isBJP/1ySefyNSpU01PxcjISDn77LNlxowZ0qpVq2q9rvaU1DL8pTOQSpfo96sAkvY30nrEGsDRzJ+ff/5ZNmzYYII14eEl386WLVtMmrpV+pu0e/du5681m8mR0XTNNddIfHy8XHjhheY3WN9TQUGBuemPPfaYacwZGhpq4zsFAAQjzT2y8+lBDyTvY64CAAhkzFV8y5w5c2TgwIFmIaujbwEAILho+broyFoSExXp7bfiEzQT104ZutKZvNXt/fffN7GN0047TZ544gk5fvy4+Xzv16+f6cNYnW1yNHB0++23y+DBg+Xuu++W9u3bm/1bt26VZ555xsQ9NMnGrwJI2pCyV69e0q5dO9PnSJs8aTr2xIkTXdbw04mUVbt27arwHG3eCQCAp1AWxv8xVwEABDLmKr5FK6MMHz6c4BEABLFjKelkH/lxCbsJEyZImzZt5KuvvnJWU7voooucAaWZM2dWawDp8OHD5jpaWa14EE3fy4MPPmh6IflVAEnTsVeuXCmPPvqoqe97xhlnmGyf008/vUzjTC1rN2LECAkmz23Ya2nc9AtPlOCr6dXu9etEVsvY5NAsqZcY6/JYZk6+VyLQOw5nWBrXrrH1+qVZuQXlHs/JL5RQN+fERVpfvVYr3Fr+RGGh9fubWcH3Wp7wUPc/xfmFhZJX4Lrx3re7ky1fs1erBMtjD6ZkWx7r7nupyCkN48o9XpBZJGExrs8Z1LaRV35fT2kSb2lcbr71RouAYq5Svjvf+snSD8ozl3QNmh+w01rX88p1UzPzLI2rG8OKd1/1095Uy2O7Nq8r/uTRweX/e+bY0SOSWL/6Vm/WpN8OnChTY0X35iX798L/adk6XSUMAAheSanp0jDRv+ZuOEH7C/3yyy9y7733lmjFo616OnXqJMuXL6/WAJJ66KGHTBbSp59+6qzG1rJlSznnnHOkfv36tl+/xgNIqm/fvvLBBx+Ue85ZZ50lP/74Y429JwAAPCHEZmCeEna+gbkKACBQMVfxLfPmzZNBgwaZErp/+9vfvP12AAA1TBe7awm7jm1O4t7/qVA0A6nQ1viakpOTY75GR0eXOabJMdq+5+DBg9K4cWOPXG/Pnj3lPsfQzSEzM9N5fosWLfwrgAQAQKAK0f+FhNgaDwAAUF2Yq/iWK664QvLz8+Xaa681JWa0D3RYWFiJc3Ru+cMPP3jtPQIAqk9aRrbk5RdIYrz1CkaBxlM9kLZv317mmPYjatiwoXhKo0aNJD4+3pSvK+7YsWMmM0nt27fPYwGkVq1aWXrmVFBgo/KT5ZEAAAAAAACwLCEhQRITE02faABA8NHsI5VAAMnjhg0b5rLnsZZ8c6ewsFByc3Mr9fqRkZESGhoqt9xyizz55JMyceJEueGGG+T48eMyfvx45+tkZWWJp7z88su2Fi1bQQAJAAAP0o/xUJvjAQAAqgtzFd+i/Z8BAMErKTVNYmMiJbIWfUkdCm1mIDnGvv3229K2bdsyGUjl+fzzz2XAgAGVus6vv/4qHTt2lIcffliOHj0qTz31lDzxxBPm2HnnnSejR4+W559/XmrX9lx22ahRo6SmEUACAMCDdCWIrRJ2NbySBAAABBfmKgAA+I6klAxJrEv5uuIK//yfVY6xGjzq0qVLlcZqQGjhwoWVOrdJkybma61ateSll16SRx99VH777TdT1q59+/amt6FmKJUOYvkbAkgAAAAAAABelJeXJ1u2bJHU1FRTPqe0/v37e+V9AQCqQeFxkfw/RCRHWjQ4JBJST6SoQCSkZA881DztVWQ1y6dRo0Zmc/Qc0izjPn36eDQDyRsIIAEA4EGaP2Qnh4j8IwAAUJ2Yq/gWDRZpz4R58+ZJZmZmtTS/BgD4UOAo9weRwqPOXe2b6f9niWT9RySinUh4e00XlmBWZLOEnY73thkzZsiBAwfk2WefFX9HAAkAAA/SeZ6duV6QzxMBAEA1Y67iWx577DGZPn26acDdr18/ufbaa00j7vj4eBNU0pKD2lMBAODnClNEsr8QkXw3J+SJ5P0iUpghUuvUoH44UFj0vz5GVsfXpGXLlskbb7xhsoU12+jTTz+V1157TW688Ua57LLLxN8RQAIAwINCzRZiazwAAEB1Ya7iWxYtWiSXX365PPfcc3Ls2DGz7/TTT5eBAwfKddddJ3/5y19k5cqVcs4553j7rQIArNLydNnrygkeFVOwWyQ/XiSiTdDebw0e2Qsg1WwEqX379pKUlCSPPPKIZGVlSYcOHeT555+Xm2++WQIBz6kAAAgQOTk5MmHCBGnatKlER0ebWruffPJJpcbu27fPPLzQ1a5xcXFy8cUXy86dO12eu2DBAunUqZNERUVJu3btKpWSfe6555oVtLfffnuVvy8AAIBA9ccff5hgkYqMjDRfs7OznU25r7nmGlm6dKlX3yMAwKYC7Xd04u/2SsnfpnXYuO1+onfv3rJmzRoTRNIA0vfff28yi/UZSCAggAQAgCf9WcLO6manCZI2epw1a5ZcffXVMmfOHAkLC5PBgwfLl19+We649PR0GTBggJnwTJo0SaZOnSqbNm2SM88807kS1uGFF14wadhdunQxgSNdFXvnnXeaUivuvPnmm7Juna62AgAAwTxXQVmJiYlmLqa07I0u5Cm9iCc5OZlbBwD+LH9X1c4vyhQpPCLBqkgKpbDI+qbj4TmUsAMAwINC/vyfnfFWbNiwQZYvX25q6I8bN87sGzlypHTt2lXGjx8va9eudTtW6+tv27bNvEavXr3MvkGDBpmxM2fONLX5la6kuf/++2XIkCGyYsUKs++mm24yzZ81VVvTs+vVq1fitXUF7T333GMyox588EFL3xsAAPD/uQpcO/XUU+Wbb75x/loX9Tz99NNmv86xnnnmGTnllFO4fQDgzwqPWxsT1lCCkb+VsAt0ZCABABAANKCjGUfFa+xqibnRo0eb7J+9e/eWO1YDR47gkerYsaOcffbZpvGjw6pVq0xG0pgxY0qMv+222yQjI0M++OCDMq+tTZ/14YcjqAUAAID/0cU4WoZYN/Xoo49KSkqKacSt2eDHjx83C3oAAP7MSkCDIAh8AwEkAAA8yE5JGGdpGAu05Jw2btSyJ6Vr8SqtweuKBnc2b94sPXv2LHNMx+7YsUPS0tKc11Clz9VGz6Ghoc7jDnv27JEnnnjClLfTnkwAACB45ypwTftOarlfR/+jzp07m/mX7nv33XdNlvgZZ5zB7QMAfxZi4d/DITESrBwZSHY2eA4l7AAA8KBQCTGbnfFq+/btZY41aNBAGjZ0ncJ+4MABadKkSZn9jn379+93OU6bPOqK14rGdujQwVxDs5xKvwdt8Kz1+0tfQ0vXafmVK6+8spzvGAAA+ONcBfY5ygNr2bqLLrrIub9u3bomsAQACBDhLUXyfq7CgAiRsMYSrDT+YycIRPzIswggAQDgg4YNG1Zm35QpU+Shhx5y+wDCsXK1OC1j5zjubpyqzFj9qsEiV/Tc4tfQcndvvPGGrF+/3uX5AAAAwU4ztF944QWTdQQACPQA0q+aW1PJ81uJhIRV97sCKoUAUjX5YW+KpEYdc3ksPzNVwlNdr9qafHZbS9d7/+cDYtV5HRpZHlsr3HoVxNTMPLfHsvMKJDMn3+Wx+FjXDy8rY/OeVMtjNxxIsjTu5Ea1LV/z5Eax5R5PCs+ShETX54TaqC3x5fajlsb1a1vf8jUL86yvLNibnO32WFZajqQXuX5wHhlq/cM4Isz6/f1o+yHLY0f3bmVpXIvE8lOfk48VSb3ERPE0b5Q42Xk4Q7zKbmmXP8e+/fbb0rZt2zIZSOU9gHDUzi8uO/vEnw93JeQc+yszVr/m5ua6fB0913Fefn6+3HnnnXLttdeW6KuEwPDMJV0tjZv68VbL15xyXgfLY4PJfR/oP0qr7rkR3T3+XuAZXZvX5VYGoPZN6gTEXAWeoaWAf/rpJ24nAASykEiRWqeL5H5TiXPriUR0lGBWUHRiszMenkMACQAAD9JnKnYeyjiGavCoS5culR6n5eb27dtXZr+WnVNNmzZ1OS4hIcFkHznOK2+sXqOgoEAOHz5cooydBpWOHTvmPG/JkiWydetWs6J2165dJV5T+ynpPh0fExO8NZ0BAPD3uQo84+mnn5bBgwdL165dZdSoURIezmMaAAhI4c1OfIrmau/gPFNmrcznsZatq9VTJCS4PwuKbPYx0vHwHOvpIwAAwGf06NFDfvvtNzl+/HiJ/Y4ScnrcldDQUOnWrZt8++23ZY7p2DZt2kidOnVKvEbpc/XXhYWFzuN79uyRvLw8+b//+z9p3bq1c3MEl/S/P/74Y4983wAAAP7m888/lyNHjpj/vu6668x87JZbbpG4uDhp166ddO/evcR2yimnePstAwA8IfwkyQ49W1ZurCWZuXEiIXEiofVEwtuIRJ0tEvkXkZAI7jV8CgEkAAA8KMQD/7Ni+PDhJjto/vz5zn1alm7hwoXSp08fad68uTO4s2XLljJjv/nmmxKBIc0gWrlypYwYMcK5b+DAgSZj6bnnnisxXn+t2URDhgwxv77yyivlrbfeKrMpXWGr/63vCQAABM9cBf8zYMAA+fTTT81/JyYmSocOHaR///5mftSsWTOzr/im8y8AQGD4fV+SbN0bIRGxZ4pEny0SdZZIrVNEQuO8/dZ8RkGxMnaWNm9/AwEmuPPhAADwsNCQE5ud8VboAwcN9kycONGUmNMSeIsXLzbl4hYsWOA8b+TIkbJmzZoSKd1jxoyRF1980QSAxo0bJxERETJr1ixp1KiR3HPPPc7ztMfRI488Irfddpu51vnnny9ffPGFLFu2TB599FHnw42OHTuazRXNPho2bJi1bxIAAPjtXAX/o/Mwx1xs9erV3BoACCI7dh+UFk3qS61aPJZ3p7DoxGaVnbEoi59UAAA8yO7KXDtjtTzc5MmTZenSpZKcnGxKnrz//vtmRWt5tESdPrwYO3asTJs2zZSjO+uss2T27NnSoEGDEudqsEkDTDNnzpR3333XZDbpeXfddZfl9w0AAIJjrgIAQDDLyc2TvQePyYAzKt/vOBhp/6MCG32M7PRPQlkEkAAACBBRUVEyffp0s7njbpWrlkt5/fXXK3Wdm266yWxVRSNLAACAE0LKdE4HAAS6XX+c6H/X6qSG3n4rQKXRAwkAAE8K0QcC1jcW9QIAgGrFXMUnXHPNNRIWFlapLTzc+tpf7Yk5YcIEadq0qSlHrGWPP/nkkwrHaT9MzU7v27evWaSkAS8tjeyOZqafdtpp5twWLVrIlClTJD8/3/L7BoBAtH3PQWnWOFGiIiO8/Vb8ooSdnQ2eQwYSAAAeRFkYAADgy5ir+IZzzjlH2rdvX+3XGTVqlKxYsULuvvtuadeunSxatEgGDx4sq1atkn79+rkdt27dOnnmmWekc+fO0qlTJ/n+++/dnvuf//zH9LjUEsjPPvus/Pjjj6YssvblfO6556rpOwMA/5Kbmy979x+T/r07efut+DwNABXQA8lnEEACAAAAAACoQdddd5387W9/q9ZrbNiwQZYvX27KG48bN87sGzlypHTt2lXGjx8va9eudTt26NChkpKSYnplzpgxo9wAkr629t78+OOPndlScXFx8thjj5k+mR07dqyG7w4A/MuufUdMb542zSlfB/9CCTsAADz5wRpifwMAAKguzFWCh2YeaQm8m2++2blPS8yNHj3aZBjt3bvX7diEhAQTPKrIL7/8Yja9RvFSe2PGjDH9L/U9AABEdpjydQkSFVmL21EBStj5FgJIAAB40Ik2Rnb+BwAAEJhzFav9eNS+ffvk8ssvl/j4eJPdcvHFF8vOnTvLnKcl00aMGGH68GjfHi3h5o5m2Gjgo0GDBhIbGysDBgyQ7777TgLFpk2bTJk8vV/F9e7d23wtL6uoKtdQPXv2LLFff4+bNWvmPA4AwSwvP1/27D8qJ7do5O234hcKpUgKiqxvOh6eQwk7AAAAAADgs/140tPTTXAnNTVVJk2aJBERETJ79mw588wzTRAkMTHRee6TTz4paWlpJkhy4MABt69ZWFgoQ4YMkR9++EHuvfdeqV+/vsybN8/08dm4caN5f/5Ov/8mTZqU2e/Yt3//fo9co/hrlr5ORdfQPklHjhwpsW/79u223xcA+JLd+45KQWGhtKZ8HfwQASQAADwoJOTEZmc8AABAoM1V7PTj0cDOtm3bzGv06tXL7Bs0aJAZO3PmTNNrx2HNmjXO7KPatWu7fU0NZOk1X3/9dRk+fLjZpxlOmrEzZcoUeeWVV6S6aPCqJmRlZUlkZGSZ/VrGznHcE9dQ7q5z/Pjxcsfr7+3UqVNdHktKSioTXELVaeAV1Y/7XDP89T7/sm2PNKhXWzLSjktGmgT0fdasXrv0Y9LOR2UNfcwGDQJIAAB4GDEgAADgy0J8rB+PZhVpP57mzZu7HauBI0fwSHXs2FHOPvtsee2110oEkFq2bFnp99OoUSO59NJLSzz00iDSsmXLTLk9V0ERf6JlAvX7KC07O9t53BPXUO6uU9E1tFeSlhwsnYE0bNgw04fJEw8i4ZkHuqgY97lm+Nt9zs8vkANHf5C+p7b3q/fuzfdaUHRiszMenkMPJAAAAAAA4JP9eDRbZ/PmzWV67DjG7tixw5Sss/J+TjvtNAkNDS3zmpmZmfLbb7+Jv9MScq7K+Dn2aZ8iT1yj+GuWvk5F12jYsKF06dKlxNa2bVvb7wsAfMWeA0dNEKlNc/ofwT+RgVRNFq7fK7X3Rrg81rRWjuzPPeby2L9HlZ0UV0b/Ntajwi9u2G157DmtrV+3YZz71VxFRSKFbqLFW/Zbz/XML7Cew3hjn9aWxiWl51q+Zr1Y1z9DDmGhIWbztNaJsZbG2QnwR9cKszy2VYMYt8eSQjMlIdH18W9+T7Z8zW0H0y2PPb1RvOWxBe7+YFQgIrz89QJhYSFuz8nLt/7nRkuHWGX1R7ttI/elSmpCaEiI2eyMB2rCX66YJqHR/+sZ4dC5VT35ZZf7vx+Tv5lr6XpTzutgaRwq77kR3bldAGpsruKqT42uVtaAgCf78WgZM81uqWhshw5V+5zR99O/f/9yX7Nbt27iz3r06GH6S2kZueKBu/Xr1zuPe+Ia6ttvv3UGAx33748//iiRcQYAwWjH7kPSpEG8xMb4d1ZrTSrvuXBlx8NzyEACAMCDQjywAQAA+PpcRUuMaQ+i4pv2s/F0P56KeuyUN9bb/YG8TXs7FRQUyPz58537NBi3cOFC6dOnj7Nk4J49e2TLli2WrqEZQ1pOUK+h13J47rnnzGIyR38pAAhGBQWF8vu+w3Jyy8befit+paCoyPYGzyEDCQAATyMKBAAAAnyu8vbbb5cpNVZevwSr/Xgq6rFT3lhv9wfyNg0SaX+hiRMnyuHDh83v1+LFi2XXrl2yYMEC53kjR46UNWvWSFGxB27aQP3ZZ581//3VV1+Zr3PnzpX4+Hiz3X777c5zp0+fLkOHDpXzzjtPrrzySvnpp5/MuTfeeKN06tSpRr9nAPAlew8clbw8LV/nOjsXrumnka0MJG6sRxFAAgAAAAAAVaLBCM0+qSwtDbdv374q9+NJSEgwmUKe7uVTE/2BfMGSJUtk8uTJsnTpUklOTpbu3bvL+++/77J8X3F6ro4rbubMmeZry5YtSwSQLrzwQnnzzTdl6tSpcscdd5hA4qRJk+TBBx+spu8KAPzDjj2HpFH9ulIn1v8XJSB4EUACAMCDQv78n53xAAAAgTZXsdqPJzQ01PQi0h47penYNm3aSJ06dSy9ny+++EIKCwvNNYq/ZkxMjLRv314CgZbk0wwh3dxZvXp1mX2tWrUqkZFUES1pqBsAoFj5uj8Oy+ldT+aWVFFB0YnNKjtjURY9kAAA8CDtK213AwAACLS5ip1+PDr2m2++KRFE2rp1q6xcudKUaLP6fg4dOmQyZxyOHj0qr7/+ulx00UUu+yMBAFBZfxw6Jjm5+XJyi0bctCoqLCqyvcFzyEACAAAAAAA+249nzJgx8uKLL8qQIUNk3LhxEhERIbNmzZJGjRrJPffcU+I67733nvzwww/mv/Py8mTz5s0ybdo082vt06Ml3BwBpDPOOEOuv/56+eWXX6R+/foyb948E+TSUmwAANixY/chaZgQJ3G1KV8X6A4cOCBz5swxWcy62CU9Pd1kXZ911lkuz1+7dq2MHz9evvvuO5OVffnll8tjjz0mtWvXFl9EAAkAAA8jiQgAAPiyED/rx6Ml6rTM2tixY00wSMvO6UOZ2bNnm347xb3xxhsmMOWwadMms6lmzZo5A0hhYWHy4Ycfyr333ivPPPOMZGVlSa9evWTRokXSoUOHavn+AQDBoaCwUHbuPSyndWnl7bfilwptlrDT8TVp69at8uSTT0q7du1M2d1169a5Pff777+Xs88+Wzp16mQWw/zxxx8yY8YM2bZtm/znP/8RX0QACQAATz+RsfNUhugTAAAI0LmK1X48juCPlperiAaAdKuMevXqyUsvvWQ2AAA8Zf+hZMnJzZM2lK+zHAAq9KMA0umnny7Hjh2ThIQEWbFiRbnldSdNmmTmHzrfcfSE1L6DN910k3z88cdy3nnnia+hBxIAAAAAAAAAAB6wY88hqV+vjsTXieV+BoE6deqY4FFFjh8/Lp988olcc801zuCRo3yvlq977bXXxBeRgQQAgAeF/Pk/O+MBAACqC3MVAACqT2Fhkezce0i6d2jBbfZyCbvt27eXOaalbxs2bOiV35sff/xR8vPzpWfPniX216pVS3r06OEsuetrCCABAOBBISEnNjvjAQAAqgtzFQAAqs+BI8mSlZ0rJ7dozG22U8LORh06x9Bhw4aVOTZlyhR56KGHvPJ7c+DAAfO1SZMmZY7pvi+++EJ8EQEkAAAAAAAAAAA8UL4uIb621KtL+Tpve/vtt6Vt27ZlMpDKU1hYKLm5uZV6/cjISAmpwirgrKws5zhXfSIdx30NASQAAAKjLzUAAECl5hrMVQAA8LyioiITQOrSrhm31wdK2GnwqEuXLlUa+/nnn8uAAQMqde6vv/4qHTt2rPRrR0dHm685OTlljmVnZzuP+xoCSAAAeBJPZQAAgC9jrgIAQLU4eCRFMrNy5OQWjbjDdkvYeSCAZIUGhBYuXFipc5u4KEVXmfMdpeyK031NmzYVX0QACQAAD6IxNQAA8GXMVQAAqB6afRQfFysJdWtzi20osJmBZGds48aNZdSoUVIdunbtKuHh4fLtt9/K5Zdf7tyvJfO+//77Evt8Sai33wAAAAAAAAAAAP5evk6zj6rSFwfBo27dunLOOefIsmXLJC0tzbl/6dKlkp6eLiNGjBBfRAZSNbn01MbS/OTmLo+FZB+Xoqg4l8eiIqzF9Apt5ObtSipbd7GyTu5jvSFcRLj777UoO1wSatdyeSyynHEVibR4f9XBlGxL4w5YHKd+OZBf7vGCzFQJS3b9odT35ETL122eGGNp3N5jmZavWS/W9e93ZRxNc/8znJmWI5khrpvQZeUXWL5m6wbWf/bDQq1PJAqLrP1Zz8wp/2cpJ6/A7Tl23u/vhzKsj022Nvb8zo3Fm3SeaGeuyDwTNWXdqw9IZxf1oI8dPSKJ9ctvLFrT6vW63fLY5G/mevS9AIC/Y64CAIDnHTqWKumZ2ZSv81AwzurzL8f4mjZt2jTz9eeff3YGhb788kvz3w888IDzvEcffVT69u0rZ555ptx8883yxx9/yMyZM+W8886TCy64QHwRASQAADyMtUYAAMCXMVcBAMCzduw+JHG1o6V+vTrcWpt0ubetEnZe+B2YPHlyiV+//PLLzv8uHkA67bTT5NNPP5UJE/6/vfsAb6p6/wD+Tfegg7L33kOQURBkb2QvBwLKliEof3AhIogiQ1GEnyiiDEUZIrgQEZAlQ0D2njJLF90r+T/vqSlJm7RZXen34xOh995zc3NyaU7Oe857pmHy5Mnw8/PD8OHD8e677yKvYgCJiIiIiIiIiIiIiMiO9HXVKpZk+roCSmfFrKeWLVti7969yC8YQCIiInI0DuslIiKivIxtFSIiIocJCXuAqJg4pq9zEElfl2JHGjp70t9RRgwgEREROZDmv//sKU9ERESUXdhWISIiciyZfeTn64ViQabXvCfrpGhTH7aypyxl5GJiGxERERERERERERERWZC+rkp5pq8j58QZSERERA6k0aQ+7ClPRERElF3YViEiInKc0IhoREbFMn2dAzGFXd7CABIREZEDSfzHnhgQ40dERESUndhWISIicpxL1++gkI8XShQNYLU6iKx/lKK1fR0je9ZPooyYwo6IiIiIiIiIiIiIyEqSvq5y+eLQMJ0IOSnOQCIiInIkDuslIiKivIxtFSIiIocIi4hGeGQM2gTXYY06EFPY5S0MIBERETm8T8b2RHRMYUdERETZiW0VIiIiG+i0QPJNIOkyoI2QDfDWuqFZHReUKurFKnWgFG3qw57y5DgMIBERETkQF6YmIiKivIxtFSIiIitpHwBxewFdrNFmL/cUNKoGIPYXwPNRwL0iq9YBZPkje9YxsmP5JDKBASQiIiIiIiIiIiIiovS00UDsLgCJGXY9XPZIByT8nTrP170C65CcCgNIREREDsY0dERERJSXsa1CRERkoYTjJoNHpo89CriVBjTurF47yOyjFDumEdkze4kyYgCJiIjIkbgwNREREeVlbKsQERFZRhsDpNy2orZSgKRrgEdV1rAdtBJAsiuFHQNIjuTi0LMRERFRrklISMC0adNQunRpeHt7Izg4GNu2bbOo7M2bNzFw4EAEBgbC398fvXr1wuXLl00eu3z5ctSqVQteXl6oVq0aPv744wzHbNy4EYMGDULlypXh4+ODGjVq4OWXX0ZEhCw2SkRERERERJTHJd+0ocyN7LgSolzDGUhEREQOpPnvP3vK22rYsGFYv349Jk2apAI7X375Jbp164YdO3agZcuWZstFR0ejbdu2iIyMxGuvvQZ3d3d88MEHaN26NY4dO4YiRYqkHfvpp59izJgx6NevH1566SXs3r0bEydORGxsrApe6Y0aNUoFsgYPHozy5cvjxIkTWLx4MX7++WccOXJEBbiIiIioYLVViIiI8hVdfM6UISMp2tSHrewpSxkxgJRNHq9cFLVqlTS5LyzUDUFFiprcZ+sMOx9PV9sKApjdpbrNZd1cbf/yEBmbZHZfTEIK3MzsP3At1ObnLOLlaXNZD1fbJuzFJCXb/JzVixfKdH9URAL8Ags5fLqmxsaiJQK8bH7OqyExNpetXNzX7L4wnSeCgkx3VPt52f4rsNsn+2wuu2po4zw3DTc6IQUw82/Onve1aonM7+HMVCjqY1O587ejbH7O+uX8YC9ZRPPhQpq2lbfFwYMHsXbtWsybNw9TpkxR24YMGYK6deti6tSp2LfP/D27ZMkSXLhwQZ2jSZMmalvXrl1V2QULFmDOnDlqW1xcHF5//XV0795dBarEyJEjodVqMWvWLBU0Kly4sNou+9u0aWP0PI0aNcLQoUOxZs0ajBgxwrYXSgVS+KHFyE9e//mszWXf6VbToddCBdfE70/aXPajPnUdei2Ut+RWW4WIiCj/saUv0PY+WkrFFHZ5C1PYEREROQEJ2Li6uqogjp6kmBs+fDj279+PGzduZFpWAkf64JGoWbMm2rdvj++++y5tm8xkCg0NxQsvvGBUfty4cYiJicFPP/2Uti198Ej06dNH/XnmzBk7XikRERERERFRDnANsqFM6qBKImfhtAGkQ4cOYfz48ahTpw58fX1V+hxZ2+H8+fMZjpWOrC5duqBQoUIICgrCs88+i5CQkFy5biIico51qe152OLo0aOoXr26Wr/IUNOmTdWfkorOFJk9dPz4cTRunHFmnJS9dOkSoqKi0p5DpD9WZha5uLik7Tfnzp076s+iRU3Pwi1o2FYhIqKC1FYhIiLKd1xLAhors7K4V86uqykwUqBDis6OB7Ine09B5bQp7ObOnYu9e/diwIABqF+/vuq0krUXHn30Ufz1118qLY/4999/0apVKwQEBKgUPbIOxPz589VaDZLKx8PDI7dfChER5TcO6Fm5ePFihm3FihVD8eLFTR5/+/ZtlCpVKsN2/bZbt26ZLBcWFoaEhIQsy9aoUUM9h8xySn8N8lkp6ySZew7Dz2Yp379//0yPKyjYViEiolzDKBAREZEFn5cugHsNIPEfy2rLpSjgYsOsJTKiVWsg6ewqT47jtAEkWdj766+/NgoADRo0CPXq1cN7772H1atXq20SNJK0O3///beapaQfcd2xY0e1+LhhKiAiIqKc0rt37wzbZsyYgbfeesvk8bI+kadnxnXeJI2dfr+5csKSsvKnuYEVcqy55xDymbx8+XK1HlO1atXMHleQsK1CRERERESUx7lXAXTRQNIltXa92bUAXfwB72ZcLJCcjtMGkB577LEM26TDSlLaGa69sGHDBjzxxBNpwSPRoUMHlQZI1n1gAImIiKyh+e8/W+nLbtq0CVWrVs0wA8kcb29vNZMovfj4+LT95soJS8rKn4mJiSbPI8eae47du3ertZg6d+6Md955x+xrKGjYViEiovzcViEiIioQNBrcflAeZ87+i5b1NPBwS/2e/JAb4F4R8KgNaNxz6SKdS4ou9WFPeXIcpw0gmaLT6XD37l0VRBI3b97EvXv3zK778PPPP+fCVRIRUX4mo5HMjkiysLyQ4JH+88oSkm5OPtfSk7RzonTp0ibLydp/MvtIf1xmZeU5UlJS1GenYRo7CSqFhoaafI5//vkHPXv2VKlj169fDze3AtX0sBrbKkRElF/aKkRERAVBilaLnQfOwMerJNz9HwW09wFtpCRKAzQ+gFspQMPvuY6k1ersTGHHCJIjFai7e82aNapz7e233zbqGDO37oN+XQhTaX2EdKCFhIRkuWYFEREVLLnRr9KgQQPs2LEDDx48gL+/f9r2AwcOpO03xcXFRaV3PXz4cIZ9UrZy5crw8/MzOocc261bt7Tj5GetVpvhOS5duoQuXbqoYJMMyihUqJCDXq3zYluFiIhyAmNARERElvnnzFVEPohF19YNoHFxAVxkMKXptYnJMVKgQ4rkC7SjPDlOgQkgnT17FuPGjUPz5s0xdOhQq9Z9MBdAWrJkCWbOnGlyX2REOMJC75vcF/VAotSmudg4nMueUWCJKbavLObh6mJz2ZiEFPP7oszXkS7O/L6sJKaYXrvDEjoX2yo5JSnZ5ueMisiYUspQbPQD8zsTbJ8262rja022Y45oXFT6KcCWC3M1v+5KZv/eYhJsf2/KeSfZXDY6ItTmstm1DmBcjPl7yT3ZI1c6J5JtXPUwLirzfzeZSw2U5Ef9+/fH/PnzsWzZMkyZMkVtk0EQK1asQHBwMMqVK6e2Xb9+HbGxsahZs6ZR2VdeeUUFgvSzcs+dO4c//vgj7VyiXbt2asbS0qVLjQJI8rOPjw+6d++etu3OnTvo1KmTClBt3bo10/R7lDttlYiIMITeNx4IIx5E2v45W5BkVk8Bulibz2vqPcnPeD/lXh0V0ZhvH+XH+5D3UqoyJfP356m0Td58802sWrUK4eHhqF+/PmbPnq3WIM6KDAadPHkyfvvtNzVwpW3btvjggw/UYJf0ZN1FaRdduXJFtYEmTpyICRMmGB0j60qa+oyUz1R9Gl8iIirYIqNicej4JTSuVxmBfr65fTlEuaJABJCkE0s6tQICAlT6HFdXV6vXfTDlhRdewIABAzLMQJKFzwMCCyOoSFGzZc3ty40AUkKy7V3Snm62B5Dc4jLvvA8oXMTkdk0mMZOseHh55niwLD7B9kCDX2DWo/X9Ak3XU1AhjxwPICXZEUCK1MbYXDaoSOYf4ub+vbnG2v7e3IizPUBXyMx7ZgmtHSMwslIoIMjk9qCA1E7qnA4gJdkY3H6gtb3j1iE0dr5wG8tKkEg+k1599VU1Q1ZS4H311Ve4evWq6kTRGzJkCHbt2qVSpRl+nn322Wfqs1ICRu7u7li4cCFKlCiBl19+Oe04+UycNWuWCnLIc8maRrK+0erVq9XaRhJc0pOZR5cvX8bUqVOxZ88e9dCT81rSUVSQ5EZbJTAwCEWKmu6INLedLKunSI3tAwWcse6d8TXlhzoK1d11uvcsr15XvpNLbRUxbNgw9Tk3adIktUbxl19+qQalyCzqli1bmi0XHR2tAkaRkZF47bXXVFtFgketW7fGsWPHUKTIw/b1p59+ijFjxqBfv3546aWXVFtFAkgygGbatGkZzi0DYQxnSes/g4mIqGCT78x/HjwNv0LeaFi7Um5fToHCFHZ5i9MHkKSB2bVrV0RERKiGo+H6DPrUdebWfdCvC2GOpOQxXAOCiIgoNxemXrlyJaZPn240qvfHH39Eq1atMi0nKep27typRvXKKGAZ1dumTRvVMZN+5pAEJKTTZsGCBdi8ebMa1SvHvfjiixnWPhLvv/9+hueTzh4GkB5iW4WIiApCW+XgwYNYu3Yt5s2blzbDWQa2yDqJMuBk3759ZsvKjNoLFy6oczRp0kRtk+/5UlbaJHPmzEmblfv666+rQRkSqBIjR45UbRsZBDNq1CgULlzY6NwyE7toUfODP/O7nJj1JWtNy2z2n376CVFRUahVq5Ya1JR+EAsRUX5y8dodXL8dij6dmsLVjgxMZD0Zn27HGHW7ylJGTn33y8jcHj164Pz586oDrXbt2kb7y5QpozrGTK37IA1Tc+tFEBER5UWS0kw6ZWQQhHwGymeZzBIyJIEiw9lHemXLlsW6detUMEO++G/ZskXNYjJFOmIk3Zp0SMhsFhlFrEk3FVaew9xDroFSsa1CREQFhX6GrQRxDNsuw4cPx/79+3Hjxo1My0rgSB88EpKOt3379vjuu+/StslMptDQUDXgxZDMno6JiVEBjvSkbSJrSJpqHzkDmfUlM8ufeeYZLFq0SL0HMuvLcHZ4ZrO+ZOa6zPqSdH9Hjx5VA4GkjvWk7mT22IYNGzB69GiVOlAGJw0cOBBff/11DrxCIiLHS0hMwu7DZ1G7ahmULm488ICooHHaAFJKSgoGDRqkGqLSISbrCZgi09oluGTYWN2+fbsKOnG0DBERWUviKPY+qGBgW4WIiPJzW0UGkZw6dcroIWl0zZHgQ/Xq1eHv72+0vWnTpupPSUVnisx8OX78eNo6jenLXrp0SQ1+0T+HSH9so0aN1LqM+v2GZDaNpJCVoMfgwYPVbBpnoZ/19e6776pBRhK8kzUuK1SooGZ9ZUY/60v6S+RY/UwkGagks74MUwbKvbBp06a0VMcSyJNgn6RCTkxMzIFXSkTkWPuPXgB0QPOG1Vm1uZjCztaHlCfHcdoAkjRUJLWOTGsPCwtT6zMYPvRkJI0s/C0jaz7++GPVsJLAUb169fDcc8/l6msgIqL8u6yAPQ8qGNhWISKi/NxWkfX0JIWc4UOCDuZI4EGfRt6QftutW7dMlpPv8zLr2ZKy8hwywyZ9qnkPDw+1TpLhc0gqu/Hjx6sAiMxwGjFiBL799ls8/vjjalaNM8iJWV+yVIBkdmnXrl3aNgnWyQwkWeNRZjAREeUnd0IicOrCDbRoVANenravL062S4EOKTo7HhL9y0G3b99WqVwlviADUiRDi7nMKzIYQz6Hpd0kn9EVK1ZEXue0ayDpRy9JCh55pCcji4Ss3SANGllcU95oaVhKvmQZUZPZ+kdEREREbKsQEVFBJTNO0qe7Tb92oiFZn8jUd2wJaOj3mysnLCkrf8p3elPkWMPnSL9+o2QnkRlNkupNAmHSP5DfWTLrS/pEzM36ev755zPsk7LS+SWzvqSTTIJ73t7eGY6Tgbri77//5tqXRJRvpGi12HHgFMqWDEL1ShkHLhCZcu7cOcydOxfVqlVTk1JkkIY5kt5VBqw8+uijKF26NPIDpw0gWbO+Qp06dbB169ZsvR4iIiog7J1GxClIBQbbKkRElJ/bKhI8ku/SlpIggwQbTK0HqN9vrpywpKz8aS5lmhxr7jn0nn76aTVD+Pfff3eKAFJ2z/qqUaOGekh9Xbt2TaXGM5yZJG7evJnpNUraw5CQEKNtkhKPiCg3/HPmKiIfxKJrqwYZ1vmlnCMZ6GQmkT3lc1KjRo3U+oBBQUFqBm9my+LMmTMHn332Gdzd3fHEE0/g5MmTyOucNoCU6zQas79oNJnsS0zR2vR0x29Ewlb1ywbYXDYmIcXmspktUqpfaN2UEj6po8xsUbO0n81ld100btRayp7r3XjKdINezyspGvHuGb9IidHNK9n8vHcjTZ8zK64utn+4Bvi421zWJZMPddlnbr+vp+2/ArdOaGFz2dsRqV90bbHxdOb3hDkjgzOfEqtJdEPhQqZHa14NiYGtKhXztbmsrfdTmaDMOwaym+a//+wpT+SMJBe1rez5fMkNb3epkSvPGxOfbFM5Xy/bPw/Lj36YxsiUGkU0OBdq+r2//ulAm5+XsvZRn7q5Uk33HtjWjizuz+wPzt5WkcCDqWCCBDmEuVG40hkjs4/0x2VWVp5D1hiUoIRhGjsJKknHjiUjfWVGjgRQnEFOzPqS1H//+9//VMq6Dz74ACVKlFAp7r7//vtMn0NPZnvNnDnT5D55H9IHl8h6kZG29xcR67kg3c/RsQk4+M9F1KpcEkkJsQgJiUVBZU89ZzYb2VLSPW5jF3la+Zzk52d5f3N+mXVkiAEkIiIiIiIiIspWDRo0wI4dO9T6QoYp1Q4cOJC23xRZT0fSwRw+fDjDPilbuXLltI4b/Tnk2G7duqUdJz9LWjZzz6EngxivXr2Khg0bwhnkxKyv+vXrq3Q8Y8aMQYsWqYPsSpYsiQ8//BBjx45FoUKFMr3GF154IcNIbZmBJGtsSfDQER2R5JgOXcoa6zn/1rP8/v9rxxH4+/mgZRNZm8YFBZ0z3M+mZrTK60q/ViJljv8aiIiIHEgmvNn7ICIiInK2tkr//v3V7KBly5albZMAxYoVKxAcHJy2Fs/169dx9uzZDGUPHTpkFESS9Qb++OMPo+BDu3btVNBh6dKlRuXlZ1mTR9Y71jM1s0WOk+1dunSBM5AZWZbM3LJn1pf+/ZGUdgcPHlTrPkg6OwnsCVmDKTPSiSepEA0f6dfWIiLKbhev38X1W/fRpmltBo/yAK1Op1LY2fqQ8kIGI9StW9foITNfyTqcgURERORgjAERERFRXpYbbRUJEkmw59VXX1Up5iRI8NVXX6kZP8uXL087bsiQIdi1a5dRSnOZpSLrBUgAaMqUKWrdgIULF6p0abJmkZ7Mipk1axbGjRunnqtz585qLZ7Vq1fjnXfeUYERPVmvZ9CgQWp2k6Rl27NnD9auXatmKY0ePRrOICdmfel5eHigSZMmaT/LukiiQ4cODns9RETZISExCXsOnUGtKmVQusTDzwnKPSoQZEcKdP36SZs2bcowKCGrmVUyY9nceorpyWCLgrBWFgNIREREjl6X2o72g/M3PYiIiKigtlVWrlyJ6dOnY9WqVQgPD1fpz3788Ue0atUq03ISrNi5cycmT56M2bNnq86dNm3aqDV30ncESbBJAkwLFizA5s2b1cwmOe7FF180Ou6ZZ57Bvn37sGHDBpWWTQJKU6dOxeuvv65mKzkDmRk0f/58NetLAm+ZzfqKjY1FzZo1jcq+8sorKojUuHFjo1lf+nOZc+HCBbUukiwOntUMJCKi3PbXsQuQeMNjj/L3VV6bgWRPeSHBI5nZao0///wTbdu2tejYM2fOGH12OisGkIiIiIiIiIgo28lMn3nz5qmHORIoMqVs2bJYt26dRc8zcuRI9ciMzGhydjkx60vUrl1bPU/58uVx5coVlQpQZntJEImIKE/QJQJJ14CU26l/ly5x1+K49yAIJ8/fQIfH6sHL0yO3r5LyAAkIyUALS1PFFgQMIBERETl+XK+d5YmIiIiyC9sqBUlOzPp65JFHVGfb3bt3UbRoUQwcOBAzZ87kIuVElPskMJ50EUg8KfNSjPdpQ1HUC+gS7IfKFUvk1hWSCVpt6sNW9pQtWbIkhg0bxvfFAANIREREDmTP4tL68kRERETZhW2VgiUnZn198803dl0jEVG2SToLJJ42u1u+flcpFQUkHgE8G/MLeR6h0+rUw57y5DgMIBERERERERERERGR80gJyzR4ZDSAM/k64FoCcC+fI5dGzmf27Nnqz1OnTqk/Zebvnj171N/feOONtOOOHz+u1mgUFy9eRGRkZFpZmdHbo0cP5DUMIBERETkQk8IQERFRXsa2ChERFQhJl6w/ngGkvEFn3wwklbowh02fPt3o5y+++CLt74YBpCNHjmQ4Vv/z0KFDGUAiIiJydkwLQ0RERHkZ2ypEROT0dMlA8r/WldGGAdoHgIt/dl0VWUintS8NnZTPaToLg1ayvlJ+W2PJJbcvgIiIiIiIiIiIiIjIIXQJEhGyvpw2lm8AUTpMYUdEROTwtDAau8oTERERZRe2VYiIyPnZ+s2a38jzApnNY+mMHnPlyXEYQCIiInIkLixAREREeRnbKkRE5Ow0XgDcZWEj68q5+GXXFZG1ASR7UtgxgORQTGFHRERERERERERERM5B4wK4V7SujGtJwMUnu66IKN/iDCQiIiIH46R3IiIiysvYViEiIqfnXhlIugSdTguNJR987tVy4KLIEjL7yK4ZSHaUpYwYQCIiInIgaZha1DjNpDwRERFRdmFbhYiICgSXQkh0bQi35L8BXRbftT3qAm7Fc/DiKDMMIOUtDCBlY25AFzO/mGS7uX1aGyOkJfwlt6dtku2Iyq45esPmsiODzU8lTY51g7+35CrNyNvD1ebnjE/S2ly2XXXbPkiWH7xm83MG+ZiuAz3XBDf4eJo+JjnF9vf1amiMTeXqlw3Ilfvw4t1os/viouIQlmx6f4odz1m9lO15ccsEedtctkYRX5vKebplnrHUw9XF7DH2XK/Wjryztr493u62/45wBM1//9lTnsgZuZpr/GSz8JhEm8sW9vXIV6/V18u2pn29V3+x+Tl3vN0t0/2xD8Lg4x9k8/kp/ynu75nbl0BZYFuFiIgKAulj/XXffXi5+qNDYy00MNE3pPEGPOoA7hVy4xLJHDvXQJLy5DgMIBERERERERERERGR0zjwzwXcuhuOPp2awsXXH9DeB5JvA7pEQOMGuBYHXEsxDQhRFhhAIiIiciSZeGDP5ANOQCIiIqLsxLYKERE5uQvX7uDIqSto17wuShT9L1uOa7HUB+V5Oq196xhJeXIcBpCIiIgciH0yRERElJexrUJERM4sNDwKf+w7ibrVy6FWlTK5fTlkA66BlLdkvigGEREREREREREREVEeF5+QhJ93HUWxID+0bFQzty+HyClwBhIREZGjR/XakYaOGeyIiIgoO7GtQkREzkir1WHb3uNISdGic6sGcHXlvIn8SqfT2ZfCTmd7WcqIASQiIiIH0vz3nz3liYiIiLIL2ypEROSMDh6/iH/vhKJPx6bw9fbM7cshOzCFXd7CUCwRERERERERERER5UuXrt/F3ycvo1WTWihZLDC3L4fIqXAGEhERkSNp7EthxwlIRERElK3YViEiIicSFhGN7ftOoHbVsqhTrVxuXw45KoWdHWnomMLOsRhAIiIiIiIiIiIiIqJ8JSExCT/vOoqgwEJq9hE5Ca19ayBJeXIcBpCIiIiIiIiIiIiIKO/RRgIp1wFdDAK8E4Gku4Breeg0fvh97wkkJSWjT8cmcHXlSi1E2YEBJCIiIgfS2JnCzq70d0REREQWtDXYViEiojxPFwskHgV0YWmb3F0BpEhA6QqiYn0QGp6MLq2awtfHK1cvlRxLstfZMwPJjux3ZAIDSERERA6k+e8/e8oTERERZRe2VYiIKF8EjxL2SJI6o82GAyD8fWLxZCd3ePgyeORsJHhkVwCJKewcigEkIiIiB+KoXiIiIsrL2FYhIqI8T2YepQsemeLhlgQkHQM8mufIZVHOYAApb2FySCIiIiIiIiIiIiLKG2seGaSty/r4+4A2KjuviKhA4wwkIiIiB5IZ9fYkoWMCOyIiIspObKsQEVGelnLDhjLXAZc62XE1lAt0OjtT2HERJIdiAImIiMiR2CtDREREeRnbKkRElJfpYnKmDOVZTGGXtzCAlE208jATKJXt5vbFJKTY9HzF/T1hqxuhsTaXLe1n+/OmZBJJ1mp1ZvffiLT9egN9PWwue/rWA5vKtSgbZPNzVi/ll+n+8ND7KFykqMl9Wjui7fXKBNhU7tdzd2x+zi41Stpc1s/b3ew+TYIrCpnZX8zP9vshKVn+ldsm0eaSQItKpt/v7OTmYvucmOQU2+/D0Gjbamrf9fs2P+ezjcvZXJaI8qbCdnz22+pBXJLNZf0z+UzLLife7Zpt5w51jUORooWQV3xx8KrNZZ9vWtGh10IF19h1x20uu+Kp+g69FiIiIufAXB5E2YUBJCIiIgfS/PefPeWJiIiIsgvbKkRElKdpfHOmDOVdWvtS2JmduUE2YQCJiIjIkTSAhosgERERUV7FtgoREeVlruWBlCvWlyGnocI/dmRWYvjIsVwcfD4iIiIiIiIiIiIiIquFRmpwJ9SKOQ8uxQGXvJMymcjZMIBERESUDetS2/OwVUJCAqZNm4bSpUvD29sbwcHB2LZtm0Vlb968iYEDByIwMBD+/v7o1asXLl++bPLY5cuXo1atWvDy8kK1atXw8ccf231OIiIiyhlsqzzEtgoRUd6h0+lw4tx1rPvlL/x9PgBanZcFpXwA9wY5cHWUkyR9nb2PnHT79m288soraNu2Lfz8/KDRaLBz584Mx8XGxuKTTz5Bp06dUKpUKXVsw4YNsXTpUqSkpCCvYgCJiIjI0XIjegRg2LBhWLhwIZ555hksWrQIrq6u6NatG/bs2ZNpuejoaNXQ2bVrF1577TXMnDkTR48eRevWrREaGmp07KeffooRI0agTp06KnDUvHlzTJw4EXPnzrX5nERERJTD2FZhW4WIKA+JT0jEz7uOYvfhM2hYpxK6tm4GF6/HAZdiRscZZTWTmUeeLQGNZ45fL2Wv/BZAOnfunOoTkYEp9erVM3ucDKidMGGCCpa+9NJLmD9/PipVqoQXXngBzz//PPIqroFERETkBA4ePIi1a9di3rx5mDJlito2ZMgQ1K1bF1OnTsW+ffvMll2yZAkuXLigztGkSRO1rWvXrqrsggULMGfOHLUtLi4Or7/+Orp3747169erbSNHjoRWq8WsWbMwatQoFC5c2KpzEhERUcHAtgrllGuht3E7MhQebm6oXrw8Cnn5WH2OxOQknL97HTGJcQjy9UfVYuXUiHJrhUSF40b4XVW2YlApFPb1t/oc0tF4+f5NRMRGw8/LB1WKlYGri6vV54lJiMPV0NtI1qagTGAxFC0UCFvcjryvXpeXuycqFS0Nd1fruxaTU5JxLewO4pMSUbRQAEr4F7HpWh7ExeDOg1C4ubiq1+Tp7mFT/d6LCkNUfCwCvAuhmF/q9xlrJaUk41ZECLQ6HYoVCrTpWkRcYjwi4qLh4+EFfy9fm+47/fUkJCXC19Pb5nPYRSI92hAg+TKQEgJAZle4A66lAfdKgMvD++/mnTBs23ccGmjQq0MTlCkR9N8eL8CjGaCNAlJuALoYJCYkwtMrCHAtx7R1lGc0atRIDZQNCgpSfSUDBgwweVzJkiVx4sQJNSBXb/To0Sp4tGLFCkyfPh1Vq1ZFXsMAEhERkQNp/vvPnvK2kEaKzDiSII6epJgbPny4mgF048YNlCtXzmxZCfLoAz2iZs2aaN++Pb777ru0YM+OHTtUo0hGxxgaN24c1qxZg59++gmDBw+26pxERESUs9hWYVvFGcmApm///h2f7FqPvZeOp2339fDCkGbdMLHtQNQsWdGi4MgnO9dj2Z5NCImOSNtep1RljGvdD8899oQKnGRl5/m/8dGO77D5n91I0WnVNncXVwxo1F5dS3CluhYFfJbv3Ywlf27EubvX0rZXCCqJsa36YlTL3hYFpM7du443t32BlQd+QWxifNrvge71HsP4NgPQqVZwlgGGFG0K1h/5A0t2bcCfF4+lbZdAyciWvfBC634oE1g8y2u5ExmK/+3eiE93b1KBH73W1Rqqc/Rr2Nai4Niei8fw8c512Hh0pwqICQm2DGveHePb9Ee14uWzPIfUxeoDv6p75vjNi2nbG5eviXFt+uOpxp0sCgJdCvlX1cvnezfjQXyM2ubt7onBwV0wrnV/PFK2mkVBrF9P7ceSPzfgpxP7oEPq7Im6pauo+25w0y4WBUKj4mPUa5J75uStS2qbr4c3nm7aCS+06ocG5arDEhIIk38Dqw78iluRIXB3cUPDctUxplVf9R55uLln8YISgYQDgPZ+uh2JQMrV1IdbRaS41sOhE1fw98nLqFyuONo2qwMvTxN17uIHuNRWf30QGYJifsazksj5yL8J2DGLSJXPQX5+fhYdV7RoUfVIr0+fPiqAdObMGQaQiIiInN3lyxdhzwAvKS8uXnz4JUavWLFiKF7c9BczSQ9XvXp1tdaQoaZNm6o/jx07ZjKAJF+2jx8/bnK6tJT97bffEBUVpRpE8hyicePGGUbbuLi4qP0SQLLmnERERJSz2FZhW8XZyCyLp794ExuP7cwwFCsmMR5L/9yIL/Ztwbcj3kGvR1qZPc/f186i6+JJKnCUflDX6dtX8MLaefjqr5/x07iFKFIowGyn5ZtblmH2Lysy7EvSpuDrQ7/hm0PbsLD/i5jU/slMO/C7LJ6EEzcvZbiW62F38cqmJSoI89vERaha3PQgMfHNod8w5MuZaUGWtOuEDj+e2KseEuT4aOBLqj1vbkbMk8unY/Px3Rnq9350JOb8+pUKoPw4bgFaVHnE7LUcvHoK3RZPRmjMgwyv6c8LR7HrwlH0qNcS346YDW8PL7P1+9oPS/He1pUZ9knwRoJ28n6veW6mCtaZczPiHrp8PAknb13OcC1/Xz+H51bOxie7NuCnFxaguL9+NkxGaw9tw5CvZqrZPobikhLw2Z4f1GNBv4l4qcPTZs8Rn5SAwSvewoajOzLsO3XrMsZ+8z7mbVuNrRMyf6+P/3sB3T55CTcjQoxek8yi01/LK52HYE6vsZkGDD/d/T3Gr52v7hk5j9wr8UjE7ovHVPCwUpHS+Hn8QvMBWV0KEL8P0IUjU8lXcePfuzh2xgWtm9ZGnWplc2emFOVN4XH2paGLjLepXyW33LlzR/1pKriUF3AGEhERkQNI6jYJiAzs19vuc3l4eKB374znmTFjBt566y2zizbKIozp6bfdunXLZLmwsDAkJCRkWbZGjRrqOWSWU/rGllxvkSJF0p7DmnMSERFRzmBbhW0VZzVqzXsqeCTMdTcmJidjwGevYefkJXisSn2Tae86fzwRYTFR/53H+Ez6nw9cPYVeS/8PO15aYjJ12wfbvzEZPDKmw+T1H6og1LPBXU3OjNEHjzK7liuht9Dxo4k4/MqXJgNav50+gMErZhivGWOCzMAJ8PbFO73GZrxSnQ5DvnpbBY9Snzv9K0ndEhkXg64fT8aBactRq1SlDOe5cO86On/0ojrO9GtKteXEHhVMWT/qXZPBBAkcmQoeGUpOScFTy6cj0KcQOtYKNjlLp9NHL6qgoOlrSf358LUz6P7JS/jz5f+ZDGj9dGIvnlnxZqb1KwGYlzd8pFIPjmzZ22T9PvvlTJPBI8NruXz/Ftp/OB4HX/nCZLq/yyE30e7DcQiLeWDyNelJ3cl9+3aPh1krDH22ZxPGfD03LQBleB793+S+a71wrHqvKxYpnfEkyZeyDh79p2LJODzV7VEEBJgPjFHBbKtEbb2QK/0quSExMREffvihWgvJMINLXsIAEhERkQOULl0aZ8+eRXi4ZY3lzKSkpKhAjamRMubI+kSenhnTaUgaO/1+c+WEJWXlT2mEmSLHGh5n6TmJiIgoZ7CtwraKM5JZFysP/JzlcdIRLrNEXt/8P+yYvCTD/rm/rVIzYyyx9/Jx/PDPn+j/aLsM6/G8ueUzC64lNbAwdeNiPNm4Y4ZA1Ff7f0oLHmVF1jRavHMdZjwxwvg5dDoVuJDghrlggqH3f1ut0tmVCjAe/b7v8nGVui7r16RDVEIs3vrpczXTK72ZPy1X6/pYQoKBMtulVbWGRtvvR0dgxo+W1K9OZb56af1HOP7G6gyBKJm5pQ8eZeXw9bMqjduox407oSXjwsTvFmZZv7JPnv3l9R/h6Sad1XpEhrafPWRR/Yrr4Xfx3tZV+GDApAz7Xv1hicX37+yfV2BYs+6oXKyM0fbQ6EhM+HZh2qyjzNyLCseUDR+rQJ8RqZBky+pWL8BLZl5UsKoMOa/cbqvo/31LUMcSnp6eds+cGz9+PE6fPq2WBHBzy5uhmrx5VURERPm0sSOP3ODt7a1m/aQXHx+ftt9cOWFJWfnTXENKjjU8ztJzEhERUc5hW4VtFWcj6cqssfP8ERU8qG0wS0YCPyv/+sWq80jKtvQBpNUHf1HpwiwhHfSyBlD6QJQEfiR1miWd+EKOk5Rjr3UdZhSIksCPfg0cS0i6MlnDZ3q35zO8TmvImkSyjpRhICokKhzf/b3d6vc1fQBJ0hCmTxVnjtSdvP69l/5By6oNjDqGl1hZv4t3rVPrPBl2Ev9+9hAu379p4bVABdckneCIlr2M9smaR9ZYsX8L3uk1Bj4GM6KkvqXeLSWv+9M932Nun/Hpzv0jEpIt6zQXm47tUqkAjda+0oYDulhYJeU2oEsGNOyiptxvq4g///wTbdu2tejYM2fOqLWebTVv3jx89tlnmDVrFrp164a8iv86iYiInICkhrt5M+OXGEk7J8w1wIKCgtSoGf1xmZWV55BRPPfu3TNKYydBpdDQ0LTjrDknERERFQxsq1B2+OXUfqvLbDi8EyVaPgxw/H7uoMWBH70d5//GvyH34e2un3GvwQ/H9lh9LZuO/ol2lVPXLJWpKtIhf+r2ZauCAbcfhGLP2RNoULa60Wu0hgRKfjj2Jya0HJR2LWLLcetekwSifji6B0816pS2bfPRPRYHftLK/LMbD6KN35NNx/60OPCjt/7vnWhQ6r/OXQ1U3UoKNkvJc8lssLO3rqNCUEmD81o2a8iQBHkGN9GnLNQgOSXZ6vqVFIDbzxxG1zrN9adR9ZJ+jausrPv7jwwBJAlwWVO/KTot/rf9BzzToBsSkpKRlJQMX49w1LI6G51M40pkAInyDAkIrViRVSrSVKbS9lvqyy+/xLRp0zBmzBi88cYbyMsYQCIiInICDRo0wI4dO/DgwQP4+/unbT9w4EDaflNksdx69erh8OHDGfZJ2cqVK6scxIbnkGMNR8fIzzKaT7/fmnMSERFRwcC2CmWHB/Gpa+pYY/+JcwiK3Jf2898hJ2167tVbdsHPo1Daz5dvZRw8lZVTV67jmx/3pv18O/aeTdfy/Y6/cDrwYdnDlzIuHJ8ZCRrcuB+CNZv3GM2Gkpkz1tp+8B+k/Psw28Du28esPkdsUjy+/H4HXDUP009dvXvXquCROHTmAr5K2pX288XIa7DFyi07ULbQw47iI+ctn92ld/bGv1i+7uFaR7HJcVYHfsT67ftw/cTD+/7XGxm/c2XlVsR9LP36N/V3td6RBrh095bV9XvgzDmUSagIDw83eLi7oVzxFBsCSHIRGdOMEeWWkiVLYtiwYdn6HD/88ANGjBiBvn374pNPPkFe55LbF0BERET269+/v5odtGzZsrRtkkJORs4EBwejXLnUlvz169dVTuH0ZQ8dOmQU8Dl37hz++OMPDBgwIG1bu3bt1OyipUuXGpWXn318fNC9e3erz0lEREQFA9squUPagzLCWWZ/SwphaRdu27bNorIyu33gwIEIDAxUA5R69eqFy5czzo6JjIzE1KlTUa1aNfUcFSpUwPDhw1W7M7v5e/laXaZF/Zp4ukcLPPXfo0sL41Rplnq2Rxs89UQLPPnfo3Jp60ei165YDk8+8Rie7J76GNjxMZuupWfrJhjU/TEM6t5cPRrWqGxVeZlwVCaoKAZ2a572kPMV8rA+7fTjDWtjQNdmaY9Wj9ax+hyebu4Y1PUx9O8SjH7/PcoUKZIa7LBCvSoV0LdzU/TtlPro2tK29/qJ1k3Qu+PDR/VyxusHZUWuumyxoujZvjF6tm+kHn3aB9t0LY89UhPd2jREt9YN0bV1QzxS/WE6RkvJWkztmtVF22Z10Ca4Nlo3rQ0/G1KMN3+kBsY83RHP92+Lwb0eR+tmMjPKyvVgND4ATK+zS+SM/vzzTzz55JNo1aoV1qxZowbg5nWcgUREROQEpDNAAjOvvvqqSjFXtWpVfPXVV7h69SqWL1+edtyQIUOwa9cuNaJQ74UXXlB5dyUANGXKFLi7u2PhwoUoUaIEXn755bTjpENAcvOOGzdOPVfnzp2xe/durF69Gu+8844KLll7TiIiIioY2FbJHTKKev369Zg0aZIK8EjKHJlJLjPXW7ZsmXZc22lheO1JX3RsmJqSLTo6Wq0BIcGh1157TbXlPvjgA7Ru3RrHjh1DkSJF1HEyC71jx45qAXBp/1WvXh0XL17EkiVLsHXrVrU+RHbNPJf2bMfq7bF63xH4aBshymUnklz+zbJcv8ZtUDjg4cyhrvWD4evhbVUau7bVG6FMsdQ60OvVoCV+O/uXVa+hz6OtUSTwYf0EBRZCrZIVcfbONYvX6CnuVxitazcwWgOpz6Ot8NGuby2+Dnmm7vUfQ7Ggh5kMRJe6zbH+iOXp2lw0GvRp1ArFgwLStvVq1BITN8xXKc8s1bl2M5QoGmi0rWu95jh844zF51DP3bAlShUrnPZzkaAGqr5CoiIsrt8KRUqieY1aRp28PRq2wDdHt1p8HfJM3eo3R7lSxvdM80p18deVkxbP+3FzcUXvJi1Qwv/heXqltMA7vz/8vmeJdjUboUZl45TiLas9grWHLQsu6zWrlC44qPEEXMsAKVn/O0zjVhkwWF+KKL+aPXu2+vPUqVPqz1WrVmHPntRZnfoUddeuXUPPnj3VmmoysGbdunVG56hfv7565DUMIGUT+VhxMfP7T7ab2xebaP30VZGYbPkHcXrVSj5sOFmrSgnby357zPxoJLeEKCTfNN14Cy5j/IFrjdvh1uU1NtS08sOOUWscvRph83O6u2b+IermqsnkGNs/gF1drJu2rNezju1rmth674sDN0LN7nOJfwBtlOOv9/C1MJvLFnK3/VdvuaIyOsd6Xx+7kel+z6RoJLhHm9w36JGysFUhT9tfa4kAfT5x6/Stb/v15ncrV67E9OnTVUMlPDxcNTx+/PFHNbIlM/KlfufOnZg8ebJq9EhHQJs2bVQnQbFixYyOlY4B6UBYsGABNm/erGY2yXEvvviizeckcjb+3u42lzUM7lrLcHFnMu35phVzpWoKBxv/jjRUu2IgTptpL4YfWJSNV0W5ZemAvNcxkFPYVslZBw8exNq1a9Ui3TKgRz+YqG7dumrG0L59D9O4pScBoAsXLqhzNGnSRG3r2rWrKivtwDlz5qhtf/31l5p1vnjxYjXISK9GjRp4/vnn8fvvv6NPnz4Oe033IrSYvyEGl26n4OrdFETFPYVyeErtc9F6477LZ2bLyqdk2xqNUbOk8WeBn5cvhjTriqV/brT4Ol5o3S/DtsFNu2Lqxk8sCkRJYKKEfxB6PdIqw2f5uNb9Mf7b+RZdhwRBRj/exyh4JFpXexQ1S1bAuTvXLQqUuGpc1HnSe6FVP6sCSD3rt0K5oBJG28oEFkfvBq2x4ejD9G1ZkTpIb1TL3pjzy5cWBaKkfisWKaUCUYY83NwxskUvvPPrlxZdh9Td2FZ9M8wQ6NugDYr6BiA0JtKi4I+8P8Mf62HyPtp/xfIUigMebW8UPBJNKtZG4/I18ff1cxanoJP3NT15nZYGkPSBtU61Tcyicq8GpMjavJZciyfgVsGi5yTK66ZPn2708xdffJH2d30A6cqVK2pghjD8zNSbMWNGngwg5f05UkRERGQRLy8v1UFw+/ZtxMfHqy/8MkvIkAR1THVQly1bVo1+kcZMVFQUtmzZomYxmTJy5EiVBk9SosgIUxnRaqrj2ppzEhERkfNjWyVnycwjV1dXjBo1yug9kPRy+/fvx40bNzItK4EjffBIv7B4+/bt8d1336Vtk/U3hcwyN7WwuMxgd6T4JB0SknRoVNUNfVt4IshPA40mBcmIQKjrl5l2eLu7uuOdnmNM7n+l8xAVELAkRdrjVRugd7rAj/D39sXMHiOyLC/PIR39c/uMyxD4EcOad0ftUpalJStXuDjGt8kYbJG2+ft9xqc9X1ZebDcIZQsXz7C9TfVH0bWOpCXLnDyHt7snZnQfbnL/m92eV/stGezSvkZjdKj58L7Tk+ub0HagBdeSGvh5t/dYk6mhJrQdgFL+kg4vaxKEkoBTep7uHpjZY6TFM4deav8Uivk9nAllGBCqWzrrdINSb17uHnil87Mm9894YoR6zZa8ptbVGqr31dR93bLKIxacIbV+X+08FK4uJtYucgkEPBpbMKjZHfBqDmiYvo6cg06nM/vQk0G1mR331ltvIS9iAImIiIiIiIiIyMkcPXpUpZST9YsMNW3aVP0pqehM2bQvDiEVFiG6/gY8+V4ETl1LTtvXsHELRJV8Ac0n30eLl0Pxx43GKORfVI283rptByZ+chePjruDiWtrosYzh1CiahtVTjrGVv4eh85vhKPRhFAMfj8CF28lq9TLku7H8CEDlMwpX8wV84b7wdVVg5Xb41GtjBs0cEXVqgeg0ySZLSed79+PmYtmleuaPm9QSfz24kco5hdoMuii/1lSjm0aMxduJgI/4qX2T+O1LkPNXoeqC+iwsP+LGNKsm9n1abZOWKRS2WV2LeULl8C2iR+bDEyIHvUfx+fPvpZl0Oa55k/g/b6pwab0pOy3I2arlH2mrkXPx8MTm8a8jwblqpvcX79sNfww9n34uJvOMqE/rwQw1o961+yaIPP7TcCzwV3/K2OOBosGTMagxh1N7pUZPFsnLlIzwEydx7B+5X0o7Gv870dvbKt+mN7t+UyuQpMWEJzTa6zJYyQQ9cv4D1GjRPlMX5OXmwe+Hz1X1aMpT9RricWDppg9g/5aGparjg2j3jN5T8i2jaPfyzR4qT/PlA7PYGTLjIG1NG5lAc+WgEvGoKS6RteygFcbwMX0vUtEeQtT2BERERERERERORmZla6fCWRIv+3WrVsZ9h06n4S3Vsfgzp6X8crY7qjQ6CUM/zAS294pDD8fF5xN7gp3/3/x0dAwVKlSFROXPkCf/9uF35d0wMAJKxBQcyhu/tIXHdo2x8Il3yEoMDWt69c747FuTzw+neCPskVd8PWOeIz5+AGae/wPs9+eYfL6w8LCEBISYrTt0h1g5rfArTBgWh9g9+lEVC4BfD60A34954svD/6M3VeOpx3v5+mDpxp2wPPB3VG5SOkM5zNU1isIf4xdhBUHf8bKQ78iJOZhetFaJSqocwx8pB1SYhMREmv+PJMe649GJavh8wM/YuvZA9D+N/pc1q/pWacFRjTrgcblamZ6LZ7Q4Kfhc7Hy8FZ1PdfC76TtK+kXhKFNumJY064IcvXJ9Dw9qjXDxmdm4uuTO7DpxJ9ITHkYDHy8Un08F9wd3Ws1R1ho5inaVz35Or499geWH/gRp+9eTdvu6+GFJxt2wMhmPbKs3wZFK2P72EVYtn8z1h7djtik+LR91YqVxXNNu2Nwo05IiolHSMzDfenN7zYWLcvXVddy8PrDNZFcNC7oVqsZRjXviWYV6mR6LSU9AvDbqIX4dP9mrP77N0TGP0znHuTjhyGNu2Bk854o7OKd6XkmNOuDWkHl8On+H7DrknFA9tGy1TGi2RPoW681QkNDM32vtzw/F//btwkrD/+K+zGp6a2Eh6sbetdrhXEt+qJW8QqZXsvAOq1RYmgAFu/ZkOFaZHbdkCZd1Hm0cYkIiTN/nh+GzcH7O77GN0d+R3S6dIzyPo1v2Q9PNmyP+/fvI2vV4aopB3fXSGiQAi3ckJhcGDrIrCM5t/XLTOjTf1H2sqeembLe+TCARERERERERETkZOLi4uDpmXHGh6Sx0+9Pb9P+eLSvl4x/lu6Ht1dvDOvojW92xmPniUR0b+KJc2Hlcf/wGLhjOYL8XPBSX188O68oGjR8FCXq98S52Oro+fJcrFg0BW9NG562QPiaHfF4qY8PKpZITXk1pIM3lv0ah1a9x+DkQOP1WGQGUu/evREUFJTWEanV6rBiWxwWfh+LuhXc8OlEP9yL1OK9jZH4fJI/SpfywPOleuP5Nr1xKyIEtyND4enmjsrFysDHI/X1WkKeb36l6ni3/3hcuHcDMQlxCPL1R+WiZaxaa7BvsQ7oG9wBIVHhuB52F1JU0qEF+QZYfi2SmqzsKEzvOQLn7l5DRFy0CojJ2kbmZkCZ8hgaoFeLjgiPeYCLIf8iKSUZ5QqXyLBWUVZeKjUYk7s8g/N3r+NeVLia1SWzpAp5+VhVv8E1H8Gip17GqduXEZeUgGKFCqtZL9bU76h2/dTj4r0bqn7dXF1RvXh5lAwoYtW1LK5SE/MHvYi/r59FVHwsArwLoVH5mmqtJEs9VawrnmrRFYfOnUBYSoxa+1Xe61oWpiFU14JiWFB+srrv9l0+jtDoSHXfyvpGRQulzoqzRP9iHdG/WUdcuHcdR66fQ0JyEkr6F0HbGo1Mpks0dy3Lhr6OhYMm48cTe3ErMkTVxyNlqqFl1UfyxJqbDFCwnilnMYBERERERERERORkZP0hWbMyPVkrU78/vTvhWtQtm9pVpC8rM4buhGkRFqVDis4VyVE30spqYyUg4YdBz4zCM4N64LNf4/DzoUGo8mxP7D69Ees2bcOA3h1x834K/u/zaLi4PJzpkZSiQwICUKeOqTRXD90KTcErK6Jx+EISJvTwwciu3nBz1eBmaAqeaeuFx+sYd/aXDiymHvaQznZL1yHKjKSXM5dizlKSzs2aYIQ5koqtiW9tu84hwYMaJSuohz0k6BRcyXQ6QWtULV5OPezh5e6JFhau/ZOZikEl0eS/gKetJFDT5r90gfaoVry8etj7Hj3ZxHQaQCIqWBhAIiIiIiIiIiJyMpKq7ubNmyZT24nSpUtn2FeysAvC4zzVzCX9cf+GalEyyAVBfhq4IBlufuXSyn7x9S/QJvfEwD6dVFBnbHcf9bh4XYc2Y8pgxR8aDOgNlAxyxetP+qJVXUldZRnJ/Lb5r3jMXBODogEu+PbVANSr+DBY1LyWh3oQERFR9jG9Kh0REREREREREeVbDRo0wPnz5/HgwQOj7QcOHEjbn16vZl7YciARtYIH4dDhI1i5PQ4R0Vq0rucBFxcNfKL3olzLWUjR+CI8WovD9xsh6tI66HRa7D+TiNPXk5GcooObJhm6lARAm7rmjswUWrQpFpfvpP4cHafF70cTEB2vNXntLh6BWPBzAKZ8Ho1ezT2xaXqgUfCIiIiIcgZnIBEREREREREROZn+/ftj/vz5WLZsGaZMmZKWlm7FihUIDg5GuXKpqb+uX7+OpKTUtZKa1nDH9Kd88W7KdITFuOC7P0Lx+aQS8Pdxwblz53Dih+Fo8/xGdHszXB1fMjAFhw9Mx3ffFUbRWk9h5poo3AlPgTY5EdrEBxjYLDXo82w7L7i6AOOXROF2mBa+Xho0quqGZrUyBoX+ueaBCn3/xOmb7lg+yR+PWzFriYiIiByLASQiIiIiIiIiIicjQaIBAwbg1Vdfxb1791C1alV89dVXuHr1KpYvX5523JAhQ7B31y50XKhTP/dt4YWO9UugYcOGOBQVhV8Dp2C7uzsWLlyI4kG++PqteihWrIg6NjS0Buqu8cPo0aMxZsxR9K1TB0fuH8Hnyz9HzZo18fTAI2lr5zzT1ls9zIlP1GHBxhh89XthxN3bjA9fbobmdUtkez0RERGReQwgERERERERERE5oZUrV2L69OlYtWoVwsPDUb9+ffz4449o1apVpuX8/Pywc+dOTJ48GbNnz4ZWq0WbNm3wwQcfoFixYmnHFSlSBIcPH8abb76JLVu24H//+5/a9vzzz2POnDnw8LBs9tCl28mYsDR1dtLEzpGYMHA4/L1P2v36iYiIyD4MIBEREREREREROSEvLy/MmzdPPcyRQJEpZcuWxbp167J8jjJlyhjNaLLF3tNJKBXkgmUT/RF5945d5yIiIiLHYQCJiIiIiIiIiIhyzZD23uohIu/yjSAiIsorXHL7AoiIiIiIiIiIiIiIiChvYQCJiIiIiIiIiIjynVuhKWgw7j6iYrW5fSlEREROiQEkIiIiIiIiIiLKUW2nhWHb0QS7zlG6iCuOfVIUfj6WdW8Nfj8CX26Ls+s5iYiIChKugeRgCQmpjZ9Lly6aPSYyMhwBAYVN7rsdGW/T87pqNLBVhL+nzWXtGeNz8/Jts/tcE2OQ4uFrct/F6ECbnzM2Idnmsi5RfjaVu3Lzgc3P6R3rn+n+zO4le2h1OuS0uKQUm8veuB5mdp9LQjS0noVM7jutCbf5Oa9ej7C5rI+7q81lY0NS84Jb6/aVzBOJeyTFItHdx+S+sx6RsJWPh+0fMzpb70M7fh/6uGtQpUoVtdgwkdO3VS6abqtERIQh8O69HL6q/Ce76snm333q15/tv/+yC++nVNq4ULN1FPcgEdq4KJP7Tp86lU3vTP7DeymVpxvYVqEC01Y5d/4i5GPRkR9vMbGFcedOOE6dikVBERYWhnv32LZjPTsH3s/5o57Zr+JcNDp7vqVSBj/88AN69+7NmiEiyqdOnjyJOnXq5PZlEGUbtlWIiPI3tlUou0THabFgYyx2/JOIyFgdKpV0xScv+MHdVYNZ30Tjr7NJ8PLQoFczT0zs5QM3Vw0OnE3EC59EYdoAXyzeEov4RB36t/TC1AGpA0JvhKTgjZXROHE1Ga4aoEopV6x4KQDTvojC1iOJkPFmri5Az2ZeePvZQqg+4j56172Eb3cnwt2/Mi6vqYGAGs8ioOZzcPMujuT4EESc/BSRZ5ar87sVKodKg47g0qoq0CY+QInHP4ZOlwQX90LwLdsRybF3cG/vy4i7sw9Fm85EYJ3R0OmSAW0y4u78hVu/PckbiojIwdhWcS4MIDlYREQEdu3ahXLlysHTM+PMnosXL6oA06ZNm1C1alVHP71TYB2xnngv8d9cbuJIGSrIbRV+BluG9cR6chTeS6wnW7CtQtll3CcPVABoznOFUMzfBWf/TUHJwi6Y9GkUigW4qABPRIwWIxc9QI9gT4zt7qMCSEMXPMCQDl54ua+vChj1mx2BZRP9EVzTAy8ti0Ihbw2mP5UaUJJAUt2KbvBw06gUdq896YuODR+2RySAVK8C0Kv6IdSoXAI+3p44cNET1UomoUghLU7+647Z3xfGW/3CUatMEu5FumD0F8Wweuw9+Hrp8NFWf/x10ROv9YxQ+zce8sW2k95YNvy+Ov8b6wojuEoCejxaMGYg8XOG9exMeD/nn3pmW8W5MIWdgwUGBqJXr15ZHif/ADnCnXXkCLyXWEeOwnuJqGCwpK3C3weWYT2xnhyF9xLriSi33Y/UYtvRROycWxglAlNTbtcu74Y74Slq5tG+BUHw9dLA18sVY7t74+PNsSqAJCStzeTevvB016BqaTc0rOKOk9eSVQDJzRUIidTiZqgWFUu44tGq7lley5gn/NCxYde0n+vVfbivbl1g18UHCEksi/51fBBwX1Khh6NmrZrw93FB4IEotH1Eh0Fdqqvji5dNwdf7wlG6Qi0ULuQC358iULJkYdSpY1tq8PyKnzOsZ2fC+5n1TDmLASQiIiIiIiIiogLsZmiKSidXuojxeq13w7XwdAeKBrikbStX1BV3wh+uiFzISwNvz4cLFcnfY+JTV0uQ1HYSbBq2IFKtZdTnMU+M7+EDFxfzCxuVDjK+hs1/xeOL3+Jw874WWh3ULKlyRR9eT3oyW0rP57/rkuspbHppXCIiIsoEA0hERERERERERAVYmSKuSEwGboeloJRBAKdEYRckJKXOUNIHkf4N1arUdpYo4u+CtwanRm7O/ZuM5xZGokZZN3Ru5KkCSqYYbr8VmoJpX0Tj80n+CK7hrtZdGrv4gZr1ZIvMAldERESUkWWf+ERERERERERE5JQkONS+gQfeXBWNexFaaLU6nL6erNLSNavpjvfWxSA2QacCOv/7KRZ9mntZdN6fDyWoMjqdDv4+GhXAcf2vJ6qovwuu35MUdObJc+p0QBE/F0jsZ+fxROw9nWjz6yzir8H1kMyfk4iIiB7iDKQcVqxYMcyYMUP9Sawj3kv895YX8PcSEfH3AX9v8vOFn8F5GdsqRDnj/ecLYd6GWPSdHaFSvlUp5YrFY/2wYKQf3v46Gm2mhcHLXYMewZ4Y0cWyNYROXUvGu9/F4EGMFv6+LhjQ0lMFqsSYbt6YvTYGS36MU+fUz1QyJGsqyZpLQxZEQqsF2j3ioR62GtbBW81oajQhFI2quWHZxAA4M/7+ZD07E97PrGfKHRqdDAMhIiIiIiIiIiIiIiIi+g9T2BEREREREREREREREZERBpCIiIiIiIiIiIiIiIjICANIREREREREREREREREZIQBJCIiIiIiIiIiIiIiIjLCABIREREREREREREREREZYQApByQkJGDatGkoXbo0vL29ERwcjG3btuXEU+cbO3fuhEajMfn466+/UBBFR0djxowZ6NKlC4KCglRdfPnllyaPPXPmjDquUKFC6thnn30WISEhcHaW1tGwYcNM3ls1a9aEszt06BDGjx+POnXqwNfXF+XLl8fAgQNx/vz5DMcW1PuIiNhWsQTbKhmxrZI1tlWyxrYKEVHO9TNt3LgRgwYNQuXKleHj44MaNWrg5ZdfRkREBN8GB9Zzeh07dlR9EPLdnBxfz99++y2aN2+u+jwCAwPx2GOP4Y8//mBVO7Cef//9d7Rt2xZFixZVddy0aVOsWrWKdVxAuOX2BRQE0nm9fv16TJo0CdWqVVMd3N26dcOOHTvQsmXL3L68PGXixIlo0qSJ0baqVauiILp//z7efvtt1eH/yCOPqI4rU/7991+0atUKAQEBmDNnjuqomD9/Pk6cOIGDBw/Cw8MDBb2OhKenJz7//HOjbVJnzm7u3LnYu3cvBgwYgPr16+POnTtYvHgxHn30URWcrVu3Lgr6fUREbKtYg22Vh9hWyRrbKlljW4WIKOf6mUaNGqU6jwcPHqy+R8v3Pfl++PPPP+PIkSOqU5nsr+f0Qbv9+/ezWrPhfhZvvfWW6hfq37+/Ok9SUhJOnjyJmzdvss4dVM+bN29G7969VZBO6luCod999x2GDBmi2rqTJ09mXTs7HWWrAwcO6KSa582bl7YtLi5OV6VKFV3z5s1Z+//ZsWOHqqd169axTv4THx+vu337tvr7oUOHVP2sWLEiQ/2MHTtW5+3trbt27Vratm3btqnjP/30U6euT0vraOjQoTpfX19dQbR3715dQkKC0bbz58/rPD09dc8880zatoJ8HxEVdGyrWIZtlYzYVska2ypZY1uFiCjn2m7Snknvq6++Uuf77LPP+FY4qJ4Nj69YsaLu7bffVucaN24c69iB9/P+/ft1Go1Gt3DhQtZrNtZzx44ddaVLl1btWr2kpCRVtn79+qz7AoAp7LKZRHZdXV3VKA89Ly8vDB8+XI1AuHHjRnZfQr4TFRWF5ORkFHQyY6ZkyZJZHrdhwwY88cQTavSQXocOHVC9enU1IsCZWVpHeikpKXjw4AEKEpm6nX72kIw0kZR2krJOryDfR0QFHdsq1mNbJRXbKlljWyVrbKsQEeVc261NmzYZtvXp00f9afj9kBzTRn7//feh1WoxZcoUVmk23M8ffvih6hN68cUXZYKEyqRCjq9n6UcrXLiwatfqubm5qXR2nLVYMDCAlM2OHj2qOmD9/f2NtkuuSHHs2LHsvoR85bnnnlN1Jb/EJLfm4cOHc/uS8jSZknvv3j00btw4wz65x+T+o1SxsbHq3pIUbbK+z7hx4wps40IaVnfv3lUf9oL3EVHBxraKddhWsQ4/YyzHtspDbKsQEeVc203SnAv990NyTD1fv34d7733nkrVyk727Lmft2/frpbB+Oijj1CsWDH4+fmhVKlSKi0jOa6eJfB86tQpTJ8+HRcvXsSlS5cwa9Ys1Wc7depUVnUBwDWQstnt27fVL6/09Ntu3bqV3ZeQL8gMiX79+qncm9JoOX36tFp/5fHHH8e+ffvQsGHD3L7EPHt/CXP3WFhYmFokz3CUQEEkdSEfarLuj4z++fXXX7FkyRL8888/at0kGTlRkKxZs0Z16EmeYMH7iKhgY1vFMmyr2H5/CbZVMse2ijG2VYiIcq6fSQIcMjNB1pAhx9Xzyy+/rPqynnzySVZrNtRzeHi4Wn9H1nz+448/MGPGDJVRZcWKFZgwYQLc3d0xevRo1r0D7mcJHF25cgXvvPMOZs+erbb5+PioTDa9evViHRcABavXNBfExcWZ7LyXGTb6/ZSaukIeej179lSNl/r16+PVV19VHf5k+v4SWd1jBT2A9O677xr9LA04GXnx+uuvq2m8BalBd/bsWTX7ShY/HDp0qNrG+4ioYGNbxTJsq9h+fwm2VTLHtspDbKsQEeVcP9PXX3+N5cuXqwGXkuqcHFPPO3bsUJ3rBw4cYJVmUz3rM8qEhoZi7dq1GDRokPpZ+hLr1aunAh0MIDnmfpZy0ocmddu3b1+1PMSyZcswePBgbNu2Dc2aNeN97uSYwi6byTRVmQGSXnx8fNp+Mq1q1aoqki0fvPLLiUzfX4L3mPUmT54MFxcX/P777wXm1pLUBN27d1dp/PT5bwXvI6KCjW0V27GtYtn9JdhWsR7bKmyrEBGZ+2x1xOfq7t271fonnTt3VjMLyDH1LGt6T5w4Ec8++6xKr0bZU8/67TLTyHD2nPTzSDDp33//VWkEyb56FuPHj8eWLVtUoE4GYD/zzDOqL01mL8n6U+T8GEDKZvKPSZ+6w5B+W+nSpbP7EvK1cuXKITExETExMbl9KXmSfqqpuXtM1vop6LOPzJEPxyJFiqg0fwVBZGQkunbtioiICDWjz/B3D+8jooKNbRX7sK2S9f0l2FaxHtsqbKsQEWVXP5Okc5fML3Xr1lWDCwtaWvfsrOeVK1fi3LlzavbL1atX0x4iKipK/V3WPST76ln6u2T2jPTr6AfH6hUvXjwtzR3ZV8/SJyuzFGUwsgTn9CRwJ31Msg6SHEPOjQGkbNagQQOcP38eDx48MNqun8Yq+8m8y5cvqw+EQoUKsZpMKFOmjFooUH5hp3fw4EHeX5mQhpvky5X6c3YyoqRHjx7qd9GPP/6I2rVrG+3nfURUsLGtYh+2VTLHzxjbsa3C+4iIKDvabpcuXUKXLl1UJ/vPP//M/hYH17PMeklKSkKLFi1QqVKltIc+uCR//+2333hz21nPEsyQfSEhIRkCGPr1fApCf09217OkCJRZdaYyQ8l9LuuMM2uU82MAKZvJNEp9bkg9mTIoi7oFBwerUasE9Qvf1IiYzZs3o1OnTkZRbjLWr18/FRS4ceNG2rbt27erD4YBAwYU+OqS4Il0wKQ3a9Ys6HQ61XB2ZvL7R6Zv79+/H+vWrVNrH5nC+4io4GJbxTJsq9iOnzGZY1uFbRUiouxou0kgQ9aVS5/WXN/HsnXrVnawZ0M9S4qv77//PsNDdOvWTf1dypP997P0dUjZr776yqhdtWbNGjVwllmf7L+fJdAcGBio7lvDQJ2sQSVp7WrWrMnlWQoAjU56UClbDRw4UP1DkzzmkitffrHJ7BDp5G/VqhVrH0C7du3ULxxZoFp+OZ0+fVr9UpMpkdLxXatWrQJZT4sXL1Ypx2T0xNKlS9VidQ0bNlT7JkyYoNaykcCRbJNf6JJ7VH6Jz5s3D2XLlsWhQ4ecPoVdVnUkU5bl56eeekp9sAlpKMtIKwke/fTTT04doJw0aRIWLVqkZiDJ76L0ZNFDUdDvI6KCjm2VrLGtYhrbKlljWyVzbKsQEWVP261NmzbYtWuXGjipJ7MMZLDu1KlTUa9ePaNzlihRAh07duTb4YB6NkWj0WDcuHGqXUCOuZ/j4uLUOlMygFr6McqXL49Vq1bhyJEjKrghKdbI/nqWNdLeeOMN1Wc0ZMgQFYiStHZnzpzB6tWr1ZpI5OQkgETZKy4uTjdlyhRdyZIldZ6enromTZrofv31V1a7gUWLFumaNm2qCwoK0rm5uelKlSqlGzx4sO7ChQsFup4qVKggv7FNPq5cuZJ23MmTJ3WdOnXS+fj46AIDA3XPPPOM7s6dO7qCIKs6Cg8PV/dS1apVVf3Iv8E6dero5syZo0tMTNQ5u9atW5utn/QfAQX5PiIq6NhWyRrbKqaxrZI1tlUyx7YKEVH2tN30v18NZfbdUI4nx9SzKXLMuHHjWMUOvJ/F3bt3dUOHDlX9iVI2ODiYfa7ZUM9r1qxR/bbSV+Tt7a3qef369byfCwjOQCIiIiIiIiIiIiIiIiIjzpu3iYiIiIiIiIiIiIiIiGzCABIREREREREREREREREZYQCJiIiIiIiIiIiIiIiIjDCAREREREREREREREREREYYQCIiIiIiIiIiIiIiIiIjDCARERERERERERERERGREQaQiIiIiIiIiIiIiIiIyAgDSERERERERERERERERGSEASQiIiIiIiIiIiIiIiIywgASEdlk2LBhqFixYp4/pyXkOeW5iYiIyHmwrUJERERZtQ00Gg3eeuutXKuoL7/8Ul3D4cOHkRdkx/VY2ia7evWqem65BiLKOxhAInIw+bCz5LFz5848Vff79u1TjaaIiIjcvhQiIiLKRmyrEBERUV4PZDhb38iSJUsYGMlGsbGx6n3La31tRM7ALbcvgMjZrFq1yujnlStXYtu2bRm216pVC3mtkTRz5kw1MiQwMDDL4z/77DNotVo4g3PnzsHFhfF0IiIqGNhWyX/YViEiIsoecXFxcHNzs7lvxJoAUtGiRZn9JBsDSPK+iTZt2mTX0xAVSAwgETnY4MGDjX7+66+/VAAp/XZb6HQ6xMfHw9vbG7nN3d0dzsLT0zO3L4GIiCjHsK2S/7CtQkRElD28vLzybdXmpT4iInJeHHJPlAtWrFiBdu3aoXjx4qpDoHbt2li6dGmG4yRH7BNPPIGtW7eicePGqlHw6aefqn3Xrl1Dz5494evrq84zefJkdZyp9HgHDhxAly5dEBAQAB8fH7Ru3Rp79+5N2y/TfP/v//5P/b1SpUppqW0k/6ylOWz1uWrnz5+PZcuWoUqVKuq1NWnSBIcOHcpQftOmTahbt65qrMmf33//vcnnkVlOH374IerUqaOOLVGiBEaPHo3w8PC0Y2bMmKFmEG3fvt2o7KhRo+Dh4YF//vnH7OvQ1zPXQCIiInqIbRW2VYiIiOR7cqFChXDz5k307t1b/b1YsWKYMmUKUlJSrP7urg96zJ49G2XLllX9E23btsWpU6cyfC+XfgrpYzCXas+wv+KHH35A9+7dUbp0adUPIf0Rs2bNynCNphiugZRZ34j0ozzyyCMmz1GjRg107tzZ7HPIa5PXuGvXrrRzpp8lk5CQgJdeeknVr/Tz9OnTByEhIRb3EUnKvUmTJqFcuXKqDqpWrYq5c+dmyByzdu1aNGrUCH5+fvD390e9evWwaNGiDNdsyfXoZ1bJey7PKfU/btw4i9L/yTHyfks/lcz0Gjp0qM1pA+X9kesUMgtJX8e5ubYVkTPhDCSiXCDBIvmAlQCQTJXesmULXnjhBfXBLh+26VOWPPXUU6rhNXLkSNUwiYmJUQGo27dv48UXX0TJkiXx9ddfY8eOHRme648//kDXrl1VA0EfaNF3Cu3evRtNmzZF3759cf78eXzzzTf44IMP1LRqof8AtoZcR1RUlLpe+cB+//331fkvX76cNmvpt99+Q79+/VTg7N1330VoaCiee+451YBMT84jDUTZP3HiRFy5cgWLFy/G0aNHVRBMzvnGG2+oOhw+fDhOnDihGkLSoJI0e9JoNNfIIyIiItPYVmFbhYiISEgQRoIjwcHBasDo77//jgULFqggzdixY6367i7efPNNFUDq1q2behw5cgSdOnVCYmKizRUuzyvBLQl4yJ/SDyLP8+DBA8ybN8/i82TWN/Lss8+qPpmTJ0+qQbB6MmBWyki/hDkSWJswYYK6ttdff11tkwCbIdlfuHBh1W8jAREpM378eHz77bdZ9hFJ+jYJcEmgT7aXL19epeJ79dVXVb+RnEtIdhwp2759exVcEmfOnFHvj/QtWXs9EqCRgE2HDh3UvSDXJm1IqRPD9zw9CSL26tULe/bswZgxY9QSDzKoWIJItpD3R55XrkECXfI+ivr169t0PiJKR0dE2WrcuHG69P/UYmNjMxzXuXNnXeXKlY22VahQQZX99ddfjbYvWLBAbd+0aVPatri4OF3NmjXV9h07dqhtWq1WV61aNXVu+bvh81eqVEnXsWPHtG3z5s1TZa9cuWLR6xo6dKi6Pj0pJ+WLFCmiCwsLS9v+ww8/qO1btmxJ29agQQNdqVKldBEREWnbfvvtN3Wc4Tl3796ttq1Zs8bouaU+0m8/ceKEzsPDQzdixAhdeHi4rkyZMrrGjRvrkpKSsnwt8pzyeoiIiAoitlXYViEiIlqxYoX6nn3o0KG0ypDvybLt7bffNqqghg0b6ho1amT1d/d79+6p7+3du3c36qN47bXX1HGG38tnzJiRoS/F8DoN+y5M9bGMHj1a5+Pjo4uPjzd6PYZ9DkLOJc+VVd+I9F94eXnppk2bZrR94sSJOl9fX110dHSmN1GdOnV0rVu3Nvt6OnToYFQnkydP1rm6uhr1m5jrI5o1a5a6hvPnzxttf+WVV9Q5rl+/rn5+8cUXdf7+/rrk5GSz12np9ejfy06dOulSUlLSjlu8eLEq/8UXX5itd+nLkmPef//9tG1yTY8//rjaLtdgrZCQkAzvJRE5BlPYEeUCw/y0kZGRuH//vhotIrN05GdDMm06/VToX3/9FWXKlFEzmPRkiriMPjF07NgxXLhwAU8//bSa5SPPIw+ZwSQjTv78888M05ntNWjQIDVKRe/xxx9Xf8prEzL6Ra5LRpbIVGW9jh07qhlJhtatW6eOkX36a5eHzKaSkTuGM65kBJCMfPn8889VfclxX331ldFimERERGQZtlXYViEiItKTWSKG5Hu+/ju+Nd/dZfaSzDSS2S2G6ekk9Zqj2i2SEUWeW65RZuacPXvWIW+kvD6ZNSOzk1LjTqmzs2RGjqT3kzRv9pAU/IZ1Itcv55flC7LqI5L6l+OlL8aw/mVmkJxD+n6EpIqT/iCZiWTv9ejfS3nvJNONnvRLSWq8n376yey5f/75Z9VXYziDzdXVVd0XRJT3sGeVKBfIVF6ZBrx//37VoDEkASTDwIo0DtKTD2yZLp4+H7DkuDUkwSOR2TRgeT7DgI+9ZKq0If259XmP9Y2NatWqZSgrU69l+rrh9cv1yRpPpty7d8/oZ8lVLPl8Dx48iDlz5mQISBEREZFl2FZhW4WIiEg/WDV9env5nm+4tpGl393N9QfI+e3pl5D1hSSFnKSuk7R1htIP0rXHkCFDVMBIlgNo1aqVCqLcvXtXpbfL7r6UzPqIpP6PHz9udhkCff3L0gnfffedWuZABiVL6sCBAweqNbOtvR79eyn9OIZkHerKlStnCHwZkn2lSpVSwUVD6c9FRHkDA0hEOezSpUtq9k/NmjWxcOFCtcChfMDKCAzJsZt+RpDhSBpr6c8lOX8bNGhg8pj0H9j2klEjpuhH6Fh7/dIAXbNmjcn96RtHMgJKHzSTtZCIiIjIemyrWI5tFSIicnbmvuPb83loifQDZvVkFoyhiIgIldFFZr28/fbbarCtBL1kcOq0adMcmnVFZv7I2kWrV69WAST5U9aklpk+OdWXYqqPSF6jzP6aOnWqyXNUr15d/SnvkWSEkTWjf/nlF/WQNbIlMCYZXGy5HiJyfgwgEeWwLVu2ICEhAZs3bzYa0WGYji0rFSpUwOnTp9UHt2Gj6uLFi0bHScNJSEMqqwaNucaZo8m1C32gx5AsuJj++mVET4sWLbIMpEmDadiwYeq1yhRqmYHUv3//tMUTiYiIyDJsq7CtQkREZA1Lv7sb9gfILBW9kJCQDDNt9DNeJEAkqdf00s9s2blzp0rZv3HjRhXU0bty5YpNb2JmfSMSVJElAr788kvMnTsXmzZtUinbLAmyZWefi9R/dHS0RYEsGcDco0cP9ZB+FJmV9Omnn2L69OkZstpkRv9eSj+O4Xspae2k7jO7Fim7fft2dc2Gg5rT9wlZI6f6tIgKIq6BRJTD9A0Lw1EbMqVaRn1YM+rl5s2bKgilFx8fj88++8zoOMk3LA2J+fPnqw/m9KSRpqfP1yuNs+wk05RlNpSMbjGcSi45eCUoZkimUsvoolmzZmU4T3JystG1ymyuffv2YdmyZer4xx57TOXTlby/REREZDm2VdhWISIisoal390lqODu7o6PP/7YqE/kww8/zFBOPyBWv36PkPV7zM2UMTyfBDGWLFli05uYVd+IpKuTYNfo0aNVP8vgwYMtPm929bdI/csSCTKzKD15TnkPhATaDMnaRfXr11d/l4HO1pD3UoJRH330kVHdL1++XPX1dO/e3WzZbt26qWtaunRp2ja5f+S+sJWPj0+O9GkRFUScgUSUwyTHrH7Eh77BIYEfmUp8+/Zti84h5RYvXoynnnoKL774ogrKyFRxmaZtOPJCGgOff/65ym9bp04dPPfccyrPrQSfZMaTzNaRUcb6YJN4/fXX8eSTT6pGnVyjvQtBmvLuu++qxkTLli3x/PPPIywsTDUU5BoNA10yDV1eqxwv06yl7uS6ZLSSLBK5aNEiNcvozJkzarSMzECSaxYyIkgCVfocv0RERGQZtlXYViEiIrKGpd/dJZXdlClT1HFPPPGECiQcPXpUpVIrWrRohvaIZG0ZPny4Wu9YAkVffPGFOsf169fTjpPBozJbSdZ+njhxouoPWbVqlc2p1rLqG2nYsCHq1q2rXletWrXw6KOPWnxeCZjMnj1bzfSRPqB27drBEaR+ZICx1Kn0i8hzSbBNUvuvX78eV69eVfU7YsQI1f8iz1u2bFk1m0v6YqTvRF6LNeR9ePXVVzFz5ky1hlLPnj3VDCIJ3DVp0iTTwJrUp8xWe+WVV9S1yfrVMoPMnvWqZOabnEfWqJKUfUFBQep9kgcR2UlHRNlq3Lhx0mox2rZ582Zd/fr1dV5eXrqKFSvq5s6dq/viiy/UcVeuXEk7rkKFCrru3bubPO/ly5fVPm9vb12xYsV0L7/8sm7Dhg3qHH/99ZfRsUePHtX17dtXV6RIEZ2np6c678CBA3Xbt283Om7WrFm6MmXK6FxcXDJcS3pDhw5V59GTY6XMvHnzMhwr22fMmGG0Ta61Vq1a6npq166t27hxY4Zz6i1btkzXqFEj9Vr9/Px09erV002dOlV369YtXXJysq5Jkya6smXL6iIiIozKLVq0SD33t99+q8uMPKc8NxERUUHEtgrbKkRERCtWrFDfnw8dOpRWGfI92dfXN0PlyPd7U12KmX1310tJSdHNnDlTV6pUKXVcmzZtdCdPnjT5vfzvv//WBQcH6zw8PHTly5fXLVy4MO06Dfsr9u7dq2vWrJk6X+nSpdVzbt26VR23Y8cOo9eTvs/BVH9FVn0j77//vto+Z84ci2+cO3fuqD4cqRcp27p1a7P1LuS6019/Zn1EUVFRuldffVVXtWpVVV9FixbVPfbYY7r58+frEhMT1THr16/XderUSVe8ePG0Oh09erTu9u3baeex5nrE4sWLdTVr1tS5u7vrSpQooRs7dqwuPDzc6BhT9R4aGqp79tlndf7+/rqAgAD1d+m7kueQa7DFvn371P0nr83U+0pEttHI/+wNQhFR3iDTvidPnox///1XzTQiy5QrV06lBZTZWkRERJR92FaxDdsqRETk7CpWrIg2bdqobCJ5ncyokr4XmT1juLY1EZEz4hpIRPlUXFyc0c+yBpIsfFitWjUGj6yQlJSk8gCnny5PRERE9mFbxTHYViEiIso7ZBy+rPMjafsYPCKigoBrIBHlU3379lWNFclVK3liV69ejbNnz6q1kMgyssDk2rVrVQdX+/btWW1ERERsq+QpbKsQERHlDbKmkKwzJOtJy9pCP/zwQ25fEhFRjmAAiSif0qdck4BRSkqKWixQgiGDBg3K7UvLN9577z1cvHgR77zzDjp27Jjbl0NERORU2FaxH9sqREREeUNISAiefvppBAYG4rXXXkPPnj1z+5KIiHIE10AiIiIiIiIiIiIiIiIiI1wDiYiIiIiIiIiIiIiIiIwwgERERERERERERERERERGGEAiIiIiIiIiIiIiIiIiIwwgERERERERERERERERkREGkIiIiIiIiIiIiIiIiMgIA0hERERERERERERERERkhAEkIiIiIiIiIiIiIiIiMsIAEhERERERERERERERERlhAImIiIiIiIiIiIiIiIiMMIBERERERERERERERERERhhAIiIiIiIiIiIiIiIiIhj6f2xMf/DJhjWaAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "rng = np.random.default_rng(42)\n", + "\n", + "exp1_data = experiment_1(rng, n=30)\n", + "exp2_results, C2, r2, c2 = experiment_2(rng, n=25)\n", + "exp3_t, exp3_cost, exp3_viol, exp3_feas = experiment_3(rng, n=20)\n", + "\n", + "fig = plot_all(exp1_data, exp2_results, C2, r2, c2,\n", + " exp3_t, exp3_cost, exp3_viol, exp3_feas)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "id": "95d4626a", + "metadata": {}, + "source": [ + "## 8. Results and Discussion\n", + "\n", + "### Panel (a) — Cost convergence\n", + "\n", + "The transport cost $\\langle C, P \\rangle$ decreases monotonically across the eta schedule. Each shaded band corresponds to one $\\eta$ level; the dashed vertical lines mark transitions. The largest drops occur at the early levels ($\\eta = 2 \\to 4 \\to 8$) where the entropic approximation quality improves most rapidly. By $\\eta = 50$ the cost stabilises at approximately $0.169$, indicating the LP optimum has been closely approximated.\n", + "\n", + "### Panel (b) — Constraint violation\n", + "\n", + "The constraint violation $\\max(0, -\\langle D_k, P \\rangle)$ for the inequality and $|\\langle D_\\ell, P \\rangle|$ for the equality drop to below $10^{-10}$ within the very first few iterations and remain at **machine-precision level** throughout. This confirms that the Newton a-update enforces feasibility aggressively, independently of the Sinkhorn block.\n", + "\n", + "### Panel (c) — Dual gradient norm\n", + "\n", + "$\\|\\nabla f\\|_1$ is the convergence certificate from Theorem 2 of the paper. It decreases by several orders of magnitude at each $\\eta$ level, eventually dropping below the tolerance $10^{-7}$. The slight increase at each $\\eta$ transition is expected: moving to a larger $\\eta$ changes the landscape of $f$ so the current iterate is no longer near-stationary.\n", + "\n", + "### Panel (d) vs (e) — Transport plan structure\n", + "\n", + "The two heatmaps visualise the recovered coupling matrix $P$. At low $\\eta = 5$, the plan is nearly uniform (maximum-entropy solution) — mass is spread across many source-target pairs. At high $\\eta = 150$, the plan concentrates on a sparse set of entries, approaching the structure of the LP solution. Both plans satisfy the constraints, as confirmed by the near-zero violations reported in the titles.\n", + "\n", + "### Panel (f) — Pareto front\n", + "\n", + "The scatter plot sweeps the inequality threshold $t$ from $0.796$ (strongly binding, $1.5\\times$ the natural value $\\approx 0.53$) down to $0.053$ (slack). The key observations are:\n", + "\n", + "- For $t > 0.53$ the constraint is **binding**: cost rises from $0.081$ to $0.152$ as $t$ increases, because the solver must deviate from the unconstrained optimum to satisfy the constraint.\n", + "- For $t \\leq 0.53$ the constraint is **slack**: the unconstrained plan already satisfies it and cost remains flat near $0.081$.\n", + "- Colour encodes $\\log_{10}$(violation): all points are green ($< 10^{-7}$), so the solver achieves feasibility across the entire sweep.\n", + "- **20/20 instances converged**, demonstrating robustness.\n", + "\n", + "### Summary\n", + "\n", + "| Metric | Value |\n", + "|--------|-------|\n", + "| Total outer iterations (Exp 1) | 117 |\n", + "| Final transport cost (Exp 1) | 0.1698 |\n", + "| Final constraint violation | $< 10^{-10}$ |\n", + "| Final dual gradient $\\|\\nabla f\\|_1$ | $< 10^{-7}$ |\n", + "| Pareto sweep convergence rate | 20 / 20 |\n", + "\n", + "These results reproduce the qualitative behaviour of Figures 2–5 in the paper and confirm that Algorithm 1, as implemented here, is correct and numerically stable." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 9. Theoretical Remarks\n", + "\n", + "### Approximation error (Theorem 1)\n", + "\n", + "For a feasible primal problem, the entropic relaxation introduces an approximation error in the primal objective that decays as\n", + "\n", + "$$\n", + "O\\!\\left(\\exp\\!\\left(-\\frac{\\eta \\Delta}{K+1}\\right)\\right)\n", + "$$\n", + "\n", + "where $\\Delta > 0$ is the Slater slack (how strictly the constraints are satisfied at the LP optimum). This justifies using large $\\eta$ for high-accuracy solutions — at the cost of slower convergence.\n", + "\n", + "### Convergence rate (Theorem 2)\n", + "\n", + "At fixed $\\eta$, Algorithm 1 converges at a sublinear rate:\n", + "$$\n", + "\\|\\nabla f(z_T)\\|_1 \\leq O\\!\\left(\\frac{c_g \\varepsilon^{-2}}{T}\\right),\n", + "$$\n", + "consistent with the empirical decay seen in panel (c).\n", + "\n", + "### Super-exponential convergence with SNS (Theorem 3)\n", + "\n", + "A Sinkhorn-Newton-Sinkhorn (SNS) variant that interleaves more Newton steps achieves super-exponential convergence when the problem is non-degenerate. This is not implemented here but motivates the choice of `n_newton > 1` in the a-update." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "optimal-transport (3.11.14)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}