{ "cells": [ { "cell_type": "markdown", "id": "22273e7f", "metadata": {}, "source": [ "# `implicit-ue-nn` — user equilibrium as an implicit layer (act two)\n", "\n", "**What.** `implicit-ue-nn` is a lean variant of Liu, Yin, Bai & Grimm's (2023)\n", "end-to-end implicit-neural-network user equilibrium (`[liu2023end]`,\n", "[docs/REFERENCES.md](../../docs/REFERENCES.md)): a small MLP learns a per-link,\n", "flow-monotone cost correction, and Wardrop UE is imposed as an **implicit\n", "layer** — the forward pass is a damped logit route-choice fixed point, the\n", "backward pass differentiates through the equilibrium condition itself\n", "(implicit function theorem). The emitted flow is always *some* learned cost's\n", "equilibrium, so it is demand-feasible **by construction**.\n", "\n", "**Why it is in the benchmark.** `learned-surrogate` (act one,\n", "[19-learned-surrogate.ipynb](../01-static/19-learned-surrogate.ipynb)) made the\n", "point that link-flow accuracy is not an equilibrium certificate: a per-link\n", "ridge regressor is censored `feasible=0` on every TNTP net. `implicit-ue-nn` is\n", "**act two**: it clears that audit — feasibility is architectural — and the\n", "harness then asks the next question: is a demand-feasible flow automatically a\n", "GOOD equilibrium? The certified gap says no. See\n", "[docs/design/adr-025-implicit-ue-nn.md](../../docs/design/adr-025-implicit-ue-nn.md)\n", "for the full derivation, the honest sourcing (the canon paper is paywalled and\n", "was attributed unread; the mechanism was cross-verified from the authors' own\n", "open posters/preprints), and every measured anchor.\n", "\n", "**Scope.** The Braess identity anchor (A1, zeroed head), the implicit-function-\n", "theorem hypergradient verified against finite differences (A2), feasibility by\n", "construction at random untrained weights (A4), and the honest held-out story on\n", "Sioux Falls — TWO directions, both axes NAMED: a converged classical solver\n", "wins on wall-clock, but at MATCHED shortest-path-call budget the learned layer\n", "wins." ] }, { "cell_type": "markdown", "id": "a1969084", "metadata": {}, "source": [ "## How this notebook is graded\n", "\n", "**A notebook never claims a number it does not compute in that cell.** Every\n", "scored quantity below — feasibility, the certified relative gap, the wmape flow\n", "errors, the hypergradient/finite-difference agreement — is recomputed live by\n", "the P1 `Evaluator` (or an explicit finite-difference check) from the flows the\n", "model emitted, in the cell where it is claimed. The identifiability caveat below\n", "is a MEASURED result, not a hedge: this notebook does not claim the trained\n", "model beats an untrained baseline on the held-out gap, because that claim is\n", "false for this lean variant ([README](../../README.md), *Certified, not\n", "self-reported*)." ] }, { "cell_type": "code", "execution_count": 1, "id": "838e8dad", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:49:46.239058Z", "iopub.status.busy": "2026-07-21T13:49:46.238266Z", "iopub.status.idle": "2026-07-21T13:49:48.218265Z", "shell.execute_reply": "2026-07-21T13:49:48.217615Z" } }, "outputs": [], "source": [ "# Setup. `implicit-ue-nn` is the benchmark's first GUARDED model: it needs the\n", "# optional `torch` extra (`pip install tabench[torch]`). The guard mirrors\n", "# `src/tabench/models/__init__.py`'s own import-guard pattern.\n", "#\n", "# The inline backend is Agg-based: figures render headlessly into the notebook,\n", "# so CI can execute tutorials without a display. NEVER matplotlib.use(\"Agg\")\n", "# in-kernel — it silently suppresses inline figure capture.\n", "%matplotlib inline\n", "try:\n", " import torch # noqa: F401 (the optional torch extra; absence -> ModuleNotFoundError)\n", "except ModuleNotFoundError as exc:\n", " if exc.name != \"torch\":\n", " raise\n", " raise ModuleNotFoundError(\n", " \"implicit-ue-nn needs the optional 'torch' extra: pip install tabench[torch]\"\n", " ) from exc\n", "\n", "import numpy as np\n", "\n", "from tabench import (\n", " BiconjugateFrankWolfeModel,\n", " Budget,\n", " Evaluator,\n", " LearnedSurrogateModel,\n", " RngBundle,\n", " Trace,\n", " braess_scenario,\n", " load_scenario,\n", " viz,\n", ")\n", "from tabench.models import implicit_ue as M\n", "from tabench.models._paths import PathEngine\n", "from tabench.models.implicit_ue import ImplicitUENNModel" ] }, { "cell_type": "markdown", "id": "b385bf96", "metadata": {}, "source": [ "## A gradient of feasibility mechanisms\n", "\n", "Three learned models on this benchmark answer the SAME question — how does a\n", "learned flow become demand-feasible? — with three different mechanisms:\n", "\n", "| model | conservation | raw emission is feasible? |\n", "|---|---|---|\n", "| `learned-surrogate` | none | censored (act one) |\n", "| `het-gnn` | soft training loss | censored raw, feasible by an explicit decode |\n", "| `implicit-ue-nn` | **architectural** | **feasible, always** (this notebook) |\n", "\n", "Here feasibility is not trained toward, decoded, or hoped for: the layer's\n", "forward pass IS a logit route-choice fixed point `h* = D_od . softmax_od(-beta\n", "c_theta(Delta^T h*))`, and every OD's route flows sum to exactly its demand —\n", "node balance is exact by construction, for ANY parameters theta, trained or not." ] }, { "cell_type": "code", "execution_count": 2, "id": "3983b1f2", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:49:48.223047Z", "iopub.status.busy": "2026-07-21T13:49:48.222770Z", "iopub.status.idle": "2026-07-21T13:49:48.226460Z", "shell.execute_reply": "2026-07-21T13:49:48.225849Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "scenario : braess\n", "content hash : cf00f411cdccec88…\n", "total demand : 6.0\n" ] } ], "source": [ "scenario = braess_scenario()\n", "print(f\"scenario : {scenario.name}\")\n", "print(f\"content hash : {scenario.content_hash()[:16]}…\")\n", "print(f\"total demand : {scenario.demand.total}\")" ] }, { "cell_type": "markdown", "id": "d4870566", "metadata": {}, "source": [ "## A1 — the identity anchor: a zeroed cost head reproduces the analytic UE\n", "\n", "The cost head is `relu(gain) * softplus(mlp(static)) * (v/cap)`: nonnegative\n", "and increasing in flow for EVERY parameter value (architectural monotonicity),\n", "and identically zero when the parameters are zeroed. With the correction\n", "zeroed the layer is a plain logit loading at the TRUE BPR costs; on the Braess\n", "diamond the analytic UE is an equal-cost point, so the fixed point must equal\n", "the oracle flows `(4, 2, 2, 2, 4)` regardless of the logit temperature." ] }, { "cell_type": "code", "execution_count": 3, "id": "f0ecc13e", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:49:48.230692Z", "iopub.status.busy": "2026-07-21T13:49:48.230318Z", "iopub.status.idle": "2026-07-21T13:49:48.275978Z", "shell.execute_reply": "2026-07-21T13:49:48.275490Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "zeroed-head flows : [4. 2. 2. 2. 4.]\n", "fixed-point residual : 9.94e-12 (46 damped steps)\n", "certified relative gap : 1.941e-09\n", "common route time : 92.000001\n" ] } ], "source": [ "def _zeroed_head() -> M._CostHead:\n", " head = M._CostHead()\n", " for p in head.parameters():\n", " torch.nn.init.zeros_(p)\n", " return head\n", "\n", "\n", "def _solve_layer(sc, head, n_iter=M._N_FP_ITER):\n", " engine = PathEngine(sc.network)\n", " rs = M._build_routes(sc.network, sc.demand, engine, M._N_CG)\n", " net = M._torch_network(sc.network)\n", " h, residual, steps = M._solve_fixed_point(head, rs, net, n_iter)\n", " return (rs.delta.t() @ h).detach().numpy(), residual, steps\n", "\n", "\n", "v_a1, residual_a1, steps_a1 = _solve_layer(scenario, _zeroed_head())\n", "metrics_a1 = Evaluator(scenario).evaluate(v_a1)\n", "ref_flows = np.array([4.0, 2.0, 2.0, 2.0, 4.0])\n", "route_time = metrics_a1[\"tstt\"] / scenario.demand.total\n", "print(f\"zeroed-head flows : {np.round(v_a1, 6)}\")\n", "print(f\"fixed-point residual : {residual_a1:.2e} ({steps_a1} damped steps)\")\n", "print(f\"certified relative gap : {metrics_a1['relative_gap']:.3e}\")\n", "print(f\"common route time : {route_time:.6f}\")\n", "assert metrics_a1[\"feasible\"] == 1.0\n", "assert metrics_a1[\"relative_gap\"] < 1e-6\n", "np.testing.assert_allclose(v_a1, ref_flows, atol=1e-5)\n", "np.testing.assert_allclose(route_time, 92.0, atol=1e-4)" ] }, { "cell_type": "markdown", "id": "9674446d", "metadata": {}, "source": [ "## A2 — the implicit-function-theorem hypergradient, verified against finite differences\n", "\n", "Training differentiates the equilibrium condition itself: the adjoint\n", "hypergradient `dL/dtheta = (dg/dtheta)^T (I - dg/dh)^{-T} dL/dh`, solved as an\n", "EXACT dense linear system (no unrolled forward graph). Every parameter of a\n", "well-conditioned, deterministic cost head is checked here against a central\n", "finite difference of the FULL fixed-point solve — \"the row is not shipped\n", "without A2.\"" ] }, { "cell_type": "code", "execution_count": 4, "id": "87fcd955", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:49:48.280005Z", "iopub.status.busy": "2026-07-21T13:49:48.279594Z", "iopub.status.idle": "2026-07-21T13:49:50.291516Z", "shell.execute_reply": "2026-07-21T13:49:50.290326Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "parameters checked : 50\n", "max IMD-vs-FD rel error : 2.28e-08\n" ] } ], "source": [ "sc_a2 = braess_scenario()\n", "engine_a2 = PathEngine(sc_a2.network)\n", "rs_a2 = M._build_routes(sc_a2.network, sc_a2.demand, engine_a2, M._N_CG)\n", "net_a2 = M._torch_network(sc_a2.network)\n", "v_obs_a2 = torch.as_tensor([4.0, 2.0, 2.0, 2.0, 4.0], dtype=M._DTYPE)\n", "scale_a2 = float(sc_a2.demand.total)\n", "\n", "# A deterministic, mild, guaranteed-interior head (random init can be\n", "# softmax-saturated and stiff, where both the solve and FD are unreliable).\n", "head_a2 = M._CostHead()\n", "with torch.no_grad():\n", " head_a2.l1.weight.copy_(\n", " torch.linspace(-0.2, 0.2, head_a2.l1.weight.numel(), dtype=M._DTYPE)\n", " .reshape_as(head_a2.l1.weight)\n", " )\n", " head_a2.l1.bias.zero_()\n", " head_a2.l2.weight.fill_(0.15)\n", " head_a2.l2.bias.zero_()\n", " head_a2.gain.fill_(1.0)\n", "\n", "_, grads_a2 = M._hypergradient(head_a2, rs_a2, net_a2, v_obs_a2, scale_a2)\n", "\n", "\n", "def _full_loss() -> float:\n", " h, _, _ = M._solve_fixed_point(head_a2, rs_a2, net_a2, M._N_FP_ITER)\n", " v = rs_a2.delta.t() @ h\n", " return 0.5 * ((v - v_obs_a2) ** 2).sum().item() / scale_a2\n", "\n", "\n", "eps = 1e-4\n", "max_rel = 0.0\n", "for param, grad in zip(head_a2.parameters(), grads_a2, strict=True):\n", " flat, gflat = param.detach().reshape(-1), grad.reshape(-1)\n", " for i in range(flat.numel()):\n", " orig = flat[i].item()\n", " with torch.no_grad():\n", " flat[i] = orig + eps\n", " lp = _full_loss()\n", " with torch.no_grad():\n", " flat[i] = orig - eps\n", " lm = _full_loss()\n", " with torch.no_grad():\n", " flat[i] = orig\n", " fd = (lp - lm) / (2 * eps)\n", " max_rel = max(max_rel, abs(gflat[i].item() - fd) / (abs(fd) + 1e-8))\n", "\n", "print(f\"parameters checked : {sum(p.numel() for p in head_a2.parameters())}\")\n", "print(f\"max IMD-vs-FD rel error : {max_rel:.2e}\")\n", "assert max_rel < 1e-5" ] }, { "cell_type": "markdown", "id": "0245faa8", "metadata": {}, "source": [ "## A4 — feasibility by construction, at RANDOM untrained weights\n", "\n", "This is the property `learned-surrogate` lacks: even a never-trained head\n", "emits a demand-feasible flow, because the layer's output IS `v = Delta^T h`\n", "with each OD's route flows summing to its demand. Contrast on the SAME\n", "scenario: the ridge surrogate's per-link prediction routes nobody." ] }, { "cell_type": "code", "execution_count": 5, "id": "e7ee9e97", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:49:50.295940Z", "iopub.status.busy": "2026-07-21T13:49:50.295448Z", "iopub.status.idle": "2026-07-21T13:49:50.357563Z", "shell.execute_reply": "2026-07-21T13:49:50.356882Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "random-theta flows : [3.949 2.051 1.8981 2.051 3.949 ]\n", "fixed-point residual : 9.93e-12\n", "feasible : 1\n", "ridge (learned-surrogate) feasible : 0 (censored)\n" ] } ], "source": [ "torch.manual_seed(4)\n", "head_a4 = M._CostHead() # random init, never trained\n", "v_a4, residual_a4, _ = _solve_layer(scenario, head_a4)\n", "metrics_a4 = Evaluator(scenario).evaluate(v_a4)\n", "print(f\"random-theta flows : {np.round(v_a4, 4)}\")\n", "print(f\"fixed-point residual : {residual_a4:.2e}\")\n", "print(f\"feasible : {metrics_a4['feasible']:.0f}\")\n", "assert np.all(np.isfinite(v_a4)) and np.all(v_a4 >= 0.0)\n", "assert metrics_a4[\"feasible\"] == 1.0\n", "\n", "v_ridge_a4 = LearnedSurrogateModel().solve(\n", " scenario, Budget(iterations=1), RngBundle(0), Trace()\n", ").final.link_flows\n", "metrics_ridge_a4 = Evaluator(scenario).evaluate(v_ridge_a4)\n", "print(f\"ridge (learned-surrogate) feasible : {metrics_ridge_a4['feasible']:.0f} (censored)\")\n", "assert metrics_ridge_a4[\"feasible\"] == 0.0" ] }, { "cell_type": "markdown", "id": "1888003b", "metadata": {}, "source": [ "## The identifiability caveat, and the honest held-out headline\n", "\n", "Training matches equilibrium *flows*, not cost *parameters*: the equilibrium\n", "is identified, `theta` is not. On a disjoint TNTP scenario (Sioux Falls — a\n", "different topology AND a different congestion regime than the 8–14-node\n", "synthetic training family) the trained model is feasible with a real, finite,\n", "honestly POSITIVE certified gap — never claimed to beat an untrained baseline\n", "on that gap, because for this lean variant that claim is false (adr-025). Two\n", "directions, both axes NAMED, never hidden:\n", "\n", "1. a CONVERGED classical solver (matched-or-less wall-clock) certifies an\n", " orders-better gap — the accuracy-vs-certificate point, again;\n", "2. at MATCHED shortest-path-call budget the direction REVERSES — the learned\n", " layer's cheap fixed-point iterations buy a better certificate than the same\n", " number of Dijkstra sweeps' worth of Frank-Wolfe AON iterations." ] }, { "cell_type": "code", "execution_count": 6, "id": "50dac9c0", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:49:50.361294Z", "iopub.status.busy": "2026-07-21T13:49:50.360946Z", "iopub.status.idle": "2026-07-21T13:50:00.887383Z", "shell.execute_reply": "2026-07-21T13:50:00.885619Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "implicit-ue-nn : feasible=1 relative_gap=0.1684 wmape=0.1450\n", "learned-surrogate: feasible=0 (censored) wmape=0.2820\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "bfw (converged) : relative_gap=3.228e-06 (the wall/convergence axis)\n", "bfw (sp_calls=6) : relative_gap=2.233e-01 (the matched shortest-path-call axis — the learned layer wins here)\n" ] } ], "source": [ "sc = load_scenario(\"siouxfalls\")\n", "assert sc.family != M.TRAINING_FAMILY # disjoint from the training family, by hash\n", "oracle = sc.reference.link_flows\n", "wmape = lambda v: float(np.abs(v - oracle).sum() / np.abs(oracle).sum())\n", "\n", "v_impl = ImplicitUENNModel().solve(\n", " sc, Budget(iterations=M._N_FP_ITER), RngBundle(0), Trace()\n", ").final.link_flows\n", "m_impl = Evaluator(sc).evaluate(v_impl)\n", "print(f\"implicit-ue-nn : feasible={m_impl['feasible']:.0f} \"\n", " f\"relative_gap={m_impl['relative_gap']:.4f} wmape={wmape(v_impl):.4f}\")\n", "assert m_impl[\"feasible\"] == 1.0 # feasible BY CONSTRUCTION\n", "assert np.isfinite(m_impl[\"relative_gap\"]) and 0.0 < m_impl[\"relative_gap\"] < 1.0\n", "\n", "v_ridge = LearnedSurrogateModel().solve(\n", " sc, Budget(iterations=1), RngBundle(0), Trace()\n", ").final.link_flows\n", "m_ridge = Evaluator(sc).evaluate(v_ridge)\n", "print(f\"learned-surrogate: feasible={m_ridge['feasible']:.0f} (censored) \"\n", " f\"wmape={wmape(v_ridge):.4f}\")\n", "assert m_ridge[\"feasible\"] == 0.0\n", "assert wmape(v_impl) < wmape(v_ridge) # clears the audit, no worse a flow error\n", "\n", "# Direction 1 — a CONVERGED bfw (matched-or-less wall-clock) wins outright.\n", "v_bfw = BiconjugateFrankWolfeModel().solve(\n", " sc, Budget(iterations=300, target_relative_gap=1e-6), RngBundle(0), Trace()\n", ").final.link_flows\n", "m_bfw = Evaluator(sc).evaluate(v_bfw)\n", "print(f\"bfw (converged) : relative_gap={m_bfw['relative_gap']:.3e} \"\n", " \"(the wall/convergence axis)\")\n", "assert m_bfw[\"relative_gap\"] < m_impl[\"relative_gap\"]\n", "\n", "# Direction 2 — at MATCHED sp_calls the direction REVERSES.\n", "v_bfw_sp = BiconjugateFrankWolfeModel().solve(\n", " sc, Budget(sp_calls=M._N_CG), RngBundle(0), Trace()\n", ").final.link_flows\n", "m_bfw_sp = Evaluator(sc).evaluate(v_bfw_sp)\n", "print(f\"bfw (sp_calls={M._N_CG}) : relative_gap={m_bfw_sp['relative_gap']:.3e} \"\n", " \"(the matched shortest-path-call axis — the learned layer wins here)\")\n", "assert m_impl[\"relative_gap\"] < m_bfw_sp[\"relative_gap\"]" ] }, { "cell_type": "markdown", "id": "b8889e9d", "metadata": {}, "source": [ "## Visualize\n", "\n", "The certified artifact is per-link flows on a road `Network`, the same shape\n", "every static model here emits, so `tabench.viz` applies directly (adr-035's\n", "viz rule)." ] }, { "cell_type": "code", "execution_count": 7, "id": "e751a2b5", "metadata": { "execution": { "iopub.execute_input": "2026-07-21T13:50:00.892139Z", "iopub.status.busy": "2026-07-21T13:50:00.891867Z", "iopub.status.idle": "2026-07-21T13:50:01.489519Z", "shell.execute_reply": "2026-07-21T13:50:01.488167Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAzkAAANWCAYAAADdsEKWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3wc1bk+8Gdme1F175bk3hu2caNjAzHEtARIIyQkuckNSe4vkEt6AkluyU24NwmEkg4JgYReTC+2weDemyRX2ZZt1e2zM+f3x6xWuyq26u6c3efLx1jaXe0eydJonjnveY8Sj2sCREREREREOULN9gCIiIiIiIj6EkMOERERERHlFIYcIiIiIiLKKQw5RERERESUUxhyiIiIiIgopzDkEBERERFRTmHIISIiIiKinMKQQ0REREREOYUhh4iIiIiIcgpDDhFZ0pe+9CXcfPPNGX/d999/H+efvwgDBgzs8uu3HetVV12Fb33rW302prbPN336dPzmN7/p8se/++67KCoqRkNDQ5c/RgiBr371DowZMxZFRcXYtm1bn39eRERE/cWe7QEQEXXkZz/7GYQQGX/du+/+NqZPn4Ynn3wCPp8v46/fFW+++Sa8Xm+/vsZrr72Gxx57DC+88DzGjh2LAQMG9OvrERER9SWGHCKypKKioqy8bnV1NT772VsxYsSIrLx+VwwcOLDfX6O6uhpDhw7BggUL+v21iIiI+hrL1Ygoa55++hmcf/4iDBkyFGPHluHqq69BMBgE0L4ELBqN4s4770RFxTgMHjwEy5evwMaNm5L3P/rooxg9enTa8z///PMoKioGYJZfXX31NVi16trkDFFdXT0mT56Ce++9F4cOHUJRUTHq6urw5S9/BUVFxXj00Ueh6zq+/OWvYPr0GRgyZCjmzp2H+++/v1uf50MPPYzZs+dg8OAhGDduPD75yU/15MuV1LZcraioGH/8459wyy23YOjQYZg9ew5efPHFTj8+FArhuuuux+WXL++whO1LX/oSvvnNO3HkyFEUFRVj+vTpHT5PfX0DvvCFL2D06DEYOnQYrrvuelRWVgIwv97l5RV4+ulnko9fsmQJJkyYmHz/vffew6BBgxEKhSCEwE9/+lNMnToNgwYNxsSJk3DnnXd290tDREQEgCGHiLLkxIkTuO222/CJT9yCDz5YjxdeeB4rV67stETte9/7Hp599jk88MD9eOedt1FeXoZrr70WdXX1XXo9RVHwwAP3Y9OmTXjggQcAAF//+tcxbNgw3HXXXRg5ciT27duLwsJC/OxnP8W+fXtx7bXXwjAMjBgxHH/84x+xfv37uOuuO/GjH/0Y//znU1163U2bNuOuu+7Ct799NzZs+BD/+MeTWLx4UfL+Rx99NBnEeuM//uM/sGrVKqxduxaXX34ZPv/52zv82jQ0NOCjH10FwzDw9NNPobi4/Wv/7Gc/w7e/fTdGjBiBffv24s033+zwNf/lX76EzZu34G9/+yteffUVCCFw/fU3QNM0KIqCRYsWYc2aNQDMQLR37z5EImHs27cPALBmzVrMmTMHXq8XzzzzLH7zm/vxy1/+Aps2bcRjjz2KKVOm9vrrQkRE+YnlakSUFSdOnEA8HsfKlSuTMzBTp3Z8UhsMBvHII7/D/ff/BpdddhkA4H//93/x5psz8Oc//xl33PHVLr3m8OHD8ctf/hJf/OIXcfJkLV599VW8++47sNvNQ+GQIUOgKEBhYSGGDBmS/Li77747+fbYsWPxwQcf4qmnnsK1164652sePXoEPp8Py5cvR0FBAUaPHo2ZM2cm7y8sLMT48eO7NP6zufnmm3D99dcDMAPhAw/8Fps2bcSll16afExtbS1uvfVWlJdX4JFHHobT6ezwuYqKiuD3+2GzqWlfh1SVlZV48cWX8Morq5MlbQ8//BCmTJmK559/AatWfRRLly7B73//BwDAunVrMWPGDAwZMhjvvrsGEyZMwJo1a7B48eLk12nw4MG48MIL4XA4MGrUKMydO7fXXxciIspPnMkhoqyYPn06LrjgAixatBif+tSn8Yc//BH19Q0dPra6uhqapqWtD3E4HJg7dw727dvbrdddteqj+MhHPoJf/OIX+PGPf4yKiopzfsxDDz2EZcsuQHl5BYYPH4E//OEPOHr0aJde76KLLsKoUSMxc+Ys3H777fj73/+OUCiUvH/lypXYsOHDbn0OHZk6dVrybZ/Ph8LCQpw6dSrtMR/96CqUlZXjD3/4facBp6v27t0Lu92OefPmJW8rLS3FuHHjkv8mixcvxp49e3D69GmsXbsWS5YswZIlS7BmzRpomoYPPvgAS5YsSYzto4hEIpg5cxb+9V+/iueeew7xeLxXYyQiovzFkENEWWGz2fDMM0/jySefwKRJE/Hgg7/FvHnzcPDgwR49n6qqaFvppmntT5JDoRC2bNkCm82GqqrKcz7vk0/+A9/5znfxyU9+Ek899U+8++67uOWWW6BpsS6Nq6CgAO+88w4eeeQRDBkyFPfe+xMsXrykW+2cu8LhSJ+YVxTAMIy02y6//HKsW7cOe/bs6dPX7szUqVNRUlKCNWvWYs2atVi61Aw5a9euxaZNmxLBdT4AYOTIkdiw4UP8/Of/DY/HjX/7t/+HK664EpqmZWSsRESUWxhyiChrFEXBwoULcffdd+Pdd9+F0+nE888/3+5xZWVlcDqdWL9+ffI2TdOwadNmTJw4CYDZcay5uTnZuAAAtm/f3u65vv3t70BVVTz55JN44IHf4u233z7rGNevfx/z58/H5z//OcycORMVFeWorq7u1udpt9tx0UUX4sc//hHWrVuLw4cP45133unWc/SFH/zg+7jppptw9dXX9DroTJw4EfF4HBs2bEjeVldXhwMHDiT/Tcx1OefjxRdfwJ49e7Bw4UJMmzYN0WgUv//97zF79uy0Nt0ejwdXXHEF/vM//xMvvPA8PvjgA+zcubNX4yQiovzEkENEWbFhwwb893//HJs2bcaRI0fw7LPP4fTp05g4cWK7x/p8Ptx222fx3e9+D6+99hr27NmDr371qwiFQvjkJz8JAJg7dx68Xi9+9KMfoaqqGk888QQee+yxtOdZvXo1/vKXv+Chhx7ExRdfhK9+9av40pf+pdMyOQCoqKjAli1b8Nprr+PAgQO45557sHnz5i5/ni+//DIeeOABbNu2DYcPH8Zf//o3GIaRXIfz3HPPYd6887r8fL1177334MYbb8DKlVcnGwD0REVFBa666kp89at34L333sP27dvx+c/fjmHDhuGqq65MPm7JkiV48sl/YPr06fD7/VBVFYsXL8Lf//5Ecj0OYDZg+NOf/oRdu3ahuvogHn/8cXg8nnYd84iIiLqCIYeIsqKgoADr1q3DDTfcgLlz5+Gee+7Bvffek2ws0NYPfvADXH31Stx++xewbNkFqKqqxj//+U+UlBQDAEpLS/Dgg7/FK6+8ikWLFuHJJ5/Et771reTHnz59Gl/5yr/iW9/6FmbNmgUAuPvuf8egQYPw9a9/vdNx3nrrrVi58iP47GdvxcUXX4K6unrcdtttXf48i4qK8Nxzz2Hlyqsxf/4C/P73v8MjjzyCyZMnAwCampqwf//+Lj9fX/jpT3+KVas+ipUrr8aBAwd6/Dy//vVvMGvWTHzsYx/DZZddDiEEnnzyCTgcjuRjFi9eDF3Xk2tvADP4tL2tqKgIf/zjn7B8+QosXrwYb731Nv72t7+htLS0x+MjIqL8pcTjWua3FCciIiIiIuonnMkhIiIiIqKcwpBDREREREQ5hSGHiIiIiIhyCkMOERERERHlFIYcIiIiIiLKKQw5RERERESUUxhyiIiIiIgopzDkEBERERFRTmHIISIiIiKinMKQQ0REREREOYUhh4iIiIiIcgpDDhERERER5RSGHCIiIiIiyikMOURERERElFMYcoiIiIiIKKcw5BARERERUU5hyCEiIiIiopzCkENERERERDmFIYeIiIiIiHIKQw4REREREeUUhhwiIiIiIsopDDlERERERJRTGHKIiIiIiCinMOQQEREREVFOYcghIiIiIqKcwpBDREREREQ5hSGHiIiIiIhyCkMOERERERHlFIYcIiIiIiLKKQw5RERERESUUxhyiIiIiIgopzDkEBERERFRTmHIISIiIiKinMKQQ0REREREOYUhh4iIiIiIcgpDDhERERER5RSGHCIiIiIiyikMOURERERElFMYcoiIiIiIKKcw5BARERERUU5hyCEiIiIiopzCkENERERERDmFIYeIiIiIiHIKQw4REREREeUUhhwiIiIiIsopDDlERERERJRTGHKIiIiIiCinMOQQEREREVFOYcghIiIiIqKcwpBDREREREQ5hSGHiIiIiIhyCkMOERERERHlFIYcIiIiIiLKKQw5RERERESUU+zZHgAR9U5NfRx1QR0uuwKXXYHTkfg78b5NBRRFyfYwiYiIiDKGIYdIckVeFQJAVBMIxQTqQwZicQFDmPerCjoMP61/MwQRERFRblHicU1kexBE1LeEEIgbQCwuENWE+XfiTyzxR9NbH++0o134Sb7tUGBTGYKIiIhIHgw5RHnKMDoKP2h9XxNoOTjYVLSfBXK0vu+wcTaIiIiIrIMhh4g6JIQ52xNLCUEt4afl/bhhPlaBORPktHdeGsfZICIiIsoUhhwi6jE9ZTaobWlcLG4GpJYDjF1Fcgaoo7VBds4GERERUR9hyCGifiOEQCwxG9QyA5Q2KxQX0Ftmg5QOSuLsSCuNUxmCiIiIqAsYcogoq+K6aF8Sl1IaF0tpkOCwtW+QkFoaZ2e7bCIiIgJDDhFZnCEEtLhANI52pXEtb6e2y052h0vM/rR2iwMcnA0iIiLKCww5RCQ1IcySt2ina4PatMu24Sx7Bimw2xiCiIiIZMeQQ0Q5zxBtw0/7rnEicSS0qR2UxKXODLFBAhERkeUx5BB1IBwzoOk9/9Fw2BR4nGofjoj6kxACcR0drwtKhKOO2mW3LY1ju2wiIiJrYMghaiMcM7DsJ1WIxnv+o+GyK3jn7nIGnRzStl1267ogJN9v1y67kz2DuHkqERFR/7JnewBEVqPp5onsU3eUw+/ufkgJRAysuq8Kmi7g6YfxUXbYVAUepwKPs+P7WzZPbbcuSBNoDhuItmmX3WGr7JTbVM4GERER9RhDDlEn/G4VBW5btodBklCU1hK2zsQTs0ExLb0krincuoFqi5Z22W3DT0tpHNtlExERdY4hh4goQ+yqArtTgfcss0GxlKYILUEorAk0hszZoI7aZTvT1gW1hiO2yyYionzFkENEZBGKosDlAFwOBQUd3J/aLrttY4SGoBmCtDabp3a0Lqi1QQJng4iIKDcx5BARSUJRFNhtgN2mwOfq+DEt7bLN8NM6KxSMCtQHjXabp7o62zPIwXbZREQkL4YcIqIcoioK3A4FbgfQUecLIcx22K3d4URKEDJng+Kpm6fa0WkIcrFdNhERWRRDDlE3HD16BL+9/1coLR2Ar//bndkeDlG3KYrZwtpxttkgo4O9guJAICIQjRtp7bJtanoISm6amnif7bKJiCgbGHKIumHkyFG4/Qv/giefeDzbQyHqN2oX22W32zhVE2iOmCGo7eap5uxPx7NCbJdNRER9jSGHiIi6JbVdtr+Tx+iGaL9nUFygKbFnUGq7bLuKlO5wSruucWyXTURE3cWQQ9QNDQ31+Oujf8a2rVuwccMHmDtvfraHRGRJNlWB91ztsnW02zMoogk0hg1EtdYGCYrS2bqg1tvZLpuIiFIx5BB1Q3FxCe789+9kexhE0lMUc08fl73jdtkAENfbrgsy/24JQR22y27TGKHlfbbLJiLKLww5RERkSXabArtNgfec7bKRVhoXignUhzpol91B+Gn9myGIiCiXMOQQEZGU0tpldyCtXXaiMUJLGApGzRCkddIuu+3GqS4H22UTEcmEIYeIiHJSV9tlty+JA4JRgbqggZjWebvslvDDdtlERNbDkEPUiUDEyOjHEVHmqaoCt1OB+ywNEuK6WQ7Xdm1QZ+2yzdCDDkvjOBtERJQZDDlEbThs5gnJqvuqevwc5lVdnswQyU5RFDjsgOMc7bI73DMobOBMHGmbp9pVJGeAOlobZO/hbFAsLuC085hDRNRCicc1ce6HEeWXcMyApvf8R8NhU+Bxqn04IiKSVcvmqanrgloCUUso0ltmgzpsl4200ri27bIjMQNbj8RQ4lNRNtABB8MOERFDDhERUbZ11i67NQy1PtZhQ1oIMgyB2mYzJdkUYOwgOwb4bVwfRER5jSGHiIjI4gwhoKW2yk5tmR01oLVZCljiVTBhWCfdFoiI8gDX5BAREVmcqihwOQCXo/3szOEzGo436InHAX63gqHFnfTVJiLKEww5REREEvO5VJT6BAYW2FDkVdut2SEiykcsVyMiIiIiopzC9k9ERERERJRTGHKIiIiIiCinMOQQEREREVFOYcghIiIiIqKcwpBDREREREQ5hSGHiIiIiIhyCkMOERERERHlFIYcIiIiIiLKKQw5RERERESUUxhyiIiIiIgopzDkEBERERFRTmHIIZJUNC5wsjGOg6c1CCGyPRwiIiIiy7BnewBE1D019RqaIgKabr6vKICiKNkdFBEREZGFMOQQSUQIgYaQgC5SbwP2n9TgtAEOuwKHTYHTpsBhBxw2BXaVIYiIiKg3YrEY4vF4Vl7bbrfD6XRm5bVlpsTjGutciCQihMCpZh0nmwwAgMcBDCq0Q4sLxHQBTRfQ4oCmC8QNQAGSgcdpU+BIhCHzbTMMqQxBREREHYrFYrjhpk/CpWYn5BQXF+NXv76fQaebOJNDJBlFUTC40I5Cj8DRujj8bgVFno6X1xmiNfDEdAEtbpa5BWNG8m0BwK4iGXhaw49izg7ZFNg4G0REKcIxA5re82ukDpsCj5PLgkkO8XgcLjWOt+rGIy4y+31rVwxciP2Ix+MMOd3EkEMkKbdDwbghjrM+RlUUuByAy9FxQBHCnO1pCTwtM0HBqIFYyAxHumGu+2kJPK2zQEh7myGIKD+EYwaW/aQK0XjPQ47LruCdu8sZdEgqcWGDLmwZflU9w6+XOxhySHpCCNQ0xDGsyAZV5S/M7lCURFixdR5QdMMMQFpiJiimC0TjAoFIS3mc+Ti7LWUWyAY47elv21SGIKJcoCWOAU/dUQ6/u/vH3EDEwKr7qqDpAp5+GB8REcCQQzlg7f4wdh6LYsxAB1ZM92d7ODnHpprlau6zzQalzALFEuVxzREj+bYhAFVJrAtKrA9q+zZng4jk4nerKHBn+qo2EVHXMOSQ1IJRA7trogCA4/UaDCG4iD7DFCXRyc1+9tmgWLx1RigWF4hoAs2J2aB4YjaoZVbJnAVKfdt8n7NBRESUNdn4FcRfez3GkENSW7s/BCNRFh7TgWN1cYwacPZ1KlZztE5DY9jA1BGubA+l39hUBR6n0mlpihApa4JS1ge1LG6O6WarbFtLg4SUcrjU9UFsl01EREQAQw5J7ODpGKpPaWm37TkRlS7kbDsaRX1Qx5Thzrw9QVcUs3TNaVeADrKeEGYDhJbAYwYhgVDMQGPbdtltGiKwXTYREfUFJfFfpl+TeoYhh6S193is3W0HT2nQdHHWhfRWE44ZcDuUvA04XaEoCuw2wG7rfDbISMwGte4XZL4dTMwGafH27bJbN05lu2wiIqJcwpBD0jqv3IMSnw07jkag6UCpT4XXpUKmZRtCCIQ1gVIfF+/2lqoocNnN1rQdSbbLTgSerrbLNoNQ6/ogu42zQUSdefedt7B1y2ZUV1XhX+/4OsaWlWd7SESUpxhySFqlPhvml3uw42gENhW4/rxC6a7AR+MCQgCeTjqXUd9Ja5fdyX5qhpEoh0tplx2LCwTbtstWOyuJM0vuVIWzQZSfli67EEuXXYjfP/IgTpw4wZBDOUYxr4Rl+jWpRxhySGoti9QL3KqUJ5XhmNk1gRviWYOqKnCfq122gUSnuESDhLhAIGIk305tl+2wI209kJPtsikPPPPUP2Cz2bHw/EXZHgoR5TGGHJJaKGYAALxOOU8Yw4nxeyQdf77p+uaprfsFaXpru2wtZTaow3bZKWuF2C6bZPT3xx/DP/7+OC657HLs3rUTk6dMzfaQiPqQgszPrPB3QU8x5JDUgi0hxyXnTEhYS8zkOOQcP7Vnbp6qwN1Jk7+Wdtkt+wW1vG22y27dPNWmILEmCMnmCKlvs102WdGNH7sZN37s5mwPg4iIIYfkFoqaIcErablXiDM5eSe1Xbavs3bZAmn7BWlxgXBMoDHxdtt22cnmCG32DlI5G0RE1Hd4SJUKQw5JTf5ytZaQJuf4qe8pigK7AtjPsnlqarvs1L2DQjEjEYrMdtk2Fe2bI6TMCLFdNhER5SqGHJJaSPpyNXP8bparUTd0pV22biBtv6CYntgzKGTerrfMBqU1R1DatM9mu2wiIpITQw5JTfZytWR3NbaQpj6UunlqZwwjpRyupWV2XCAYFclSueTmqZ20y3bYFdjYLjtvBSJGRj+OKNuUxH+Zfk3qGYYckloulKu57ArXTlDGqaoClwq4ztEuu2UWqGVGqKVdthY31w4l22Un9gjq6G2GoNzisClw2RWsuq+qx8/hSnx/EBH1F4YckprM5WpCCIQ1A4Vu+cZOuS+1Xba3k8e0tMvW4q0zQtF45+2yzZbZ7d9mu2y5eJwq3rm7HJouevwcDpvC/cFIPgpbSMuEIYekFooKKIqc5V6aDugGNwIleXWnXXbq3kERzUi+3bJ5atp+QW3eZrts6/E41U4bYxARWQFDDklLN8yrxl6nIuUJUEvTARkDGlFXpLbL7ogQZshJ3S8olmiX3ZR4O55YvtHZfkEt7bNZ8klERKkYckhaMpeqASlNBziTQ3lKUczGBZ5ztMuO6y1BKNEuO7l5qvm+EGa77A73C0qUxHE2iIh6j+VqMmHIIWnJ31mNG4ESnYvahdkg3UDafkEx3dwzqDFREhdPaZfdGn7azgixXTYRUS5hyCFpSd9ZTWtpHy1nSCOygtR22WfdPDXeEoQSLbI7a5edmP3paO8gbp5KlOf44y8VhhySVihR7iVvuRpncogyQVUUuBxda5edundQMGogFjLDkW6YjZVSN0vtaO8ghiAiImtgyCFphaJmSPBJW67GNTlEVpDaLrszupHSKS5REheNCwQirfsIAYDdljIL1MHeQWyX3TtNYR27jkUxe6wbLjuPnUTUOYYckpb85WrsrkYkC7NdNuA+22xQyixQy95BzYnNU2Px1nbZne0XlInNU4UQeGVHEEOLbJg5Wr4m0FWnNOw+HsPwEgdGD2DIocxSEv9l+jWpZxhySFryl6sJOBJrCYhIboqS6OTWSYMEoHXz1JY9gsw9gzrePLWzdtkOG3o1G3TwtIamiIFA1MC0kW7pZpZ0wzzusyqQiM6FIYek1VKuJnN3NZaqEeWP7myemrp3UGMX2mWX+tRzBhbDENhVEzXfFkD1KQ3jhjj7+tPsV4mMA8myGeUKhS2kZcKQQ9IKSbxwP544YSlhqRoRJaRunupztb+/o3bZ5p5BAnG3GX7OpuqUlpwBB4C9J6IoH+SQaiNVI5FyJBoyEWUJQw5JyRDmL3a3Q86FvMn20ZzJIaIu6kq77LPZfTya9n4oJnCsIY5RpZ1MLVlQciZHwuM+5QLO5MiEZ1gkpUhMQEDipgMxNh0goswaVmRHkcf8te+wAQVutdNGClbFcjUi6irO5JCUWjuryZnTOZNDRJk2r8yDQMTAS9sDKB/kxIxR7mwPqdtaytVs7DxAROfAMyySkvyd1eRdT0RE8jJEYk2LnIdOzuQQUZdJepijfNfaWU3O33TcCJSIsqE1JMh57Gxdk5PdcRCR9bFcjaQkf7laYvyS1cMTkdxknwnRk93VJP0ESGqKws1AZSLnGSLlvaD05WqcySGizBNC7hbMnMkhoq7iYYKkJH25mmYkNvTL9kiIKJ8Y5qFT2pkQ2WeiiChzWK5GUpK+XC0m4HEoUCQ90SAiObWEBFkPPQbL1SiruE+OTOQ8Q6S8F5a4XM0QAhFNsFSNiDLOYLkaEeUJzuSQdIQQCMUMOGyAwybfb+pIyx45bDpARBkme7mX7OMnySnJ/5EEeC2EpBOLC+iG3KVqAJsOEFHmtc6EyHmiZhgCCliuRkTnxrMskg43AiUi6hkh+UyIIeQdOxFllpxniZTXgtJ3VmspV+OPHxFlVi6syeF6HCLqCh4qSDryd1bjTA4RZUfrmhY5jz+GENKOnYgyi40HSDryl6txTQ4RZUfLPjmy5gTDkHcWiuSnKAqUDDceyPTr5RKeZZF0ZN8INKQlZnLYXY2IMozlakSULziTQ9KRv1zN7A7kZsghogyTvVxNFwJORc5jP+UCbgYqEx4pSDryl6sZcDsVKJKeZBCRvITkm2kKlqsRURdJepijfCZzuZoQAhFNsLMaEWWF7OVqOsvViKiLWK5G0gnFDNhUwGWX77d0NC5gCHZWI6LskLlcrTWgyTd2yhH81pMKr4eQVDRdQNPNzmQylnu1dlaTb+xEJD+Zu6u1jF3WWSgiyizO5JBUZC5VA4BworOal+VqRJQFrTM52R1HT7SM3cbDJ2UNGw/IhIcKkkoudFYDOJNDRNkh85oclqsRUXfIeaZIeSsXOqsB3AiUiLIjOZMjYcqReRaKiDKP5WoklZaZHJ+kMyFhLTGTwz1yiCgLhMRBIbkmh9eIKEsURYGS4fKxTL9eLuGhgqQSiiZmciSdCWktV5Nz/EQkN5arEVG+4EwOSSW5JkfWcrVE4wE3Z3KIKAtaSr5k7E7J7mqUfWw8IBM5zxQpb0nfXS0m4LIrsPG3NBFlgWHIGxJkXk9ERJnHkENSSTYekLTcKxwz2FmNiLLGEELakKNLXGpHRJnHcjWSSihmQAHgljAoaLpA3AA83COHiLLEEPKuaWF3Nco6fu9JhWdbJA3dEIhoAh6nIuUv6db20fKNnYhygxDydiczDDYeIKKu40wOSSMsfakaO6sRUXYZQkDWjNC6Jie746B8xsYDMuGhgqSR7Kwm6UxIKNFZjXvkEFG2mOVq2R5Fz7BcjYi6gzM5JI1kZzVZ20cnZ3L4G5qIskPqNTmJlGOTdPwkPwXW3wxU0zQ88sjD2L5tG5qbm1BaWoqrr/koLr74EgBAKBTCQw/+Fps2bYTT6cTyFVfg+utvSH58f9+fSQw5JI1c6KwGsFyNiLLHEIBN0ozAcjWic9N1HSXFxfju976PIUOGYP/+/fjpT+7BgAEDMHPmLPzud48gEAjgN/f/Fo2Njfjxj36IQYMG4YILLgSAfr8/k3ioIGkEkxuByvkbOqwlZnJYrkZEWWIY8raQZrka5bNwOIxQKJT8o2lah49zu9342MdvwtChQ6EoCiZMmICpU6dhz+7diEajWLd2DT5+003w+XwYPnw4rrjiCrzx+usA0O/3ZxpDDkmjdSNQOb9tOZNDRNkmcqBcTdbxUw5QlOz8AfClL96Oz3z6k8k/Tz31zy4NORaL4cCB/RgzZixqao4hHo9j7Niy5P1jx5bh8OFDANDv92cay9VIGvKXqwk4bIBD1loRIpKeIQBFzkModJarUR67/4EH4fF4ku87HI5zfowQAg88cD+GDRuG+QsWYO/ePXC53LDZbMnHeH0+hMNhAEAkEunX+zONIYekEcqBcjVuBEpE2WQIlqsRycjj8cDr9Xb58UIIPPzQgzhecwzf/e73oaoq3G43YrEodF1PBpFQKJgMT/19f6bxjIukEY7JW66mGwKxuGBnNSLKqlzoribr+IkyRQiBRx5+CAcO7Me3v/M9eH0+AMDw4SNgs9lw6ODB5GMPHjyI0aNHZ+T+TJPvbJHykhAC4ZiAy67AJuFlPG4ESkRWwH1yiHLfI488jL179+A73/0+/H5/8naXy4VFixbj8cf/ilAwiOPHa/DySy/i4ksuzcj9mcZyNZJCRBMwhMylauYslJud1YgoS4QQicYD2R5Jz7CFNGWdogAZ3ienu6936lQtXln9MhwOB/7lS19M3r502TLcfvsX8NnbPocHH3wAX/zi7XA6nVix4oq09s79fX8mMeSQFEISl6oBrTM5so6fiOQnJJ8J4WagROc2aNBg/P2Jf3R6v9frxde+9o2s3Z9JDDkkhWBU7pCQbB/NmRwiypKWmRBF0pDAmRzKNiXxX6Zfk3qGhwqSQi50VgO4JoeIskf2kMA1OUTUHZIe6ijf5M5GoPztTETZYYiW7mRZHkgPsbsaEXUHy9VICrmwESjAcjUiyp7WmRA5j0PcDJSyToLGA9SKhwqSQmvjATl/2MOaAVUBnHY5x09E8pO98YDs4yeizGLIISkky9Vccn7LhmPmRqCyLvglIvm1lntleSA9pLNcjYi6Qc4zRso7MperGUIgogl4HPKNnYhyh+zlamw8QETdwbMusjwhBEIxA3abnOVeEU1AgE0HiCi7WltIZ3ccPSV7dzgiyiw2HiDLi8UFdAMo9Mj5my3ZdEDCWSgiyh3J7mqSHorYXY2yjo0HpCLpoY7yicylagA3AiUia5C93Ktl/DZJx09EmcWZHLI8bgRKRNR7Qvo1OeYnoPBQSlmiJP7L9GtSz/BQQZaXKxuBytr+mohyQ+7M5Ej6CRBRRnEmhyyvpVzNJ23IadkIVM7xE1FuSK7JkTQjGOb1ImnHTzmAa3KkwrMusjz5y9XM8bs5k0NEWdQSEmTdrytZribn8IkowziTQ5Ynf+MBAQWAm40HiCiLZC1X210TxcHTGprCZkp7Y3cIw4rtmDLcleWREZGVyXnWSHklF9bkuB2KtIt9iSg3yNpC+kidhhONccQTM1GHz2jYfSya3UERkeVJdqijfCRzuZoQAmFNcCNQIso6Q9LuapOHtZ+xmTqSszhEdHYsVyPLC8UEVAVw2eX6xQyYG5kagk0HiCj7hKTlaiNL7SjxqqgPmRe8CtwqJgxxZnlUlJfYeEAqPPMiS4vrArG4gNepSLlYtnWPHPnGTkS5xTDk7K6mKAqmj3In3589xg1Vtk+CiDKOIYcsLVmqJu16HG4ESkTW0FKuJuH1IpQNcsCuAk4bUD7Ike3hEJEEWK5GlhaKJjqrueQMCS0bgXrYWY2IsqzQo8LtUOCT8HiqKgpuPr8QgLwtsCkXsFxNJgw5ZGmtMzly/pC3lqvJd1JBRLllWLEDH5lplzYk2GRrC0dEWcWQQ5Yme7lay/i5JoeIrEDWgENkBYrCeRyZyHnmSHkjKH25WmImh93ViIiIiDKGZ15kafKXq3Emh4iIiCjTWK5Glta6EaiceTwcE3DaFdjY7pSIiEhybDwgEznPHClvJLurSbomJxwz2FmNiIiIKMM4k0OWFpK4BbOmC8QNdlYjIiLKHfKdj+QrhhyyLN0QiGgCHqci5e7WYcnXExERtRWOGdB00eOPd9gUXvghooxgyCHLaulMJm+pWktnNYYcIpJfOGZg2U+qEI33POS47AreubucQYfkpHBNjkwYcsiyZJ8Jae2sxl/mRCQ/TReIxgWeuqMcfnf3j2uBiIFV91VB0wU8/TA+IqJUDDlkWcEc6KwGsH00EeUWv1tFgduW7WEQEZ0VQw5ZVkj2cjWNG4ESERHlCharyYVnX2RZoajk5WoxbgRKRERElA2cySHLSm4EKutMTrJcTc7xExERUSol0XwggwQvlPYUQw5ZVrJcTdY1OZoBu2q2TCUiymWB5mb8+le/RFFhMc5fvAQzZ83O9pCIKM/JefZIeUH+cjXBWRwiygv/eOJxxOM6oChwOp3ZHg4REUMOWZfM5Wq6YbZa5XocIsoHMS2G6dNn4Atf+jIefvCBbA+HqJ8oWfpDPcFyNbIkIQTCMQGnXYFdwnKvCDurEVEeufqaa/F/9/0chw8fwrILLsz2cIiIGHLImiKagCHkLVULsbMaEeWRIUOH4p6f/le2h0HUv5QsNB6AAogMv2SO4GVmsiSZS9WAlM5qnMkhIiIiyjiegZElhaLyd1YDOJNDRERElA0sVyNLap3JkTMktO6RI+f4iYiIKF022gDwLKLnGHLIklpCjk/acrXETA7L1YioD0U0A+9XhnHgZAzLp/kwagDbNRMRdYQhhyxJ/nK1xPg5k0NEfeBMII6th6PYfTwK3byGggO1WlZCTiBiZPTjiCyDjQekwpBDliR/uZoBVQGcdjnHT0TWsflQBO/uC7W7ffpIV0bH4bApcNkVrLqvqsfP4bIrcEi4LQARyYchhywpGXJkncmJCXgcCpSMX/EholwTN9pfxnXZFQzw2zI6Do9TxTt3l0PTe35Z2WFT4JG0DJmIq3LkwpBDltRSribjL0NDCEQ0kfETECLKTXPHuHDgZAynmvXkbSNK7Fm5iOJxqvBk/FWJiLpPvjNIynlCCIRiBuwq4JQwJ0Q1AQF2ViOivrHpUBSnmnWoCqAmDivDS3iNkojobHiUJMvRdCBuAIVuVcpyr5amA+ysRkS9deBkDOsOhAEAV8zwo8CtYv/JGKaOcGd5ZER5KFuNB6hHGHLIclrX48j5g51sH82ZHCLqhdqmOF7ZEQAALBnvQcVgs5Pa4EL+6iYiOhceKclyQtGWzmpyzoS0bgQq5/iJKPuaIwae29yMuAFMHeHC7DGcuSHKNrYdkAvPwshyQrGWPWbk/PYMay0bgfLQRETdF4sLPLelGcGYwMgSOy6c5JWydJeIKJvkPIuknJacyZG2XI0zOUTUM4YQeGVHAKebdRR7VVw50w+bKuexkIgom1iuRpYTjMlersY1OUTUM+v2h1F1SoPboeDqWQVws4EJkXWw8YBUePQky5G/XM0cv5vlakTUDTuORrDpUASqAlw5w49in4Q99ImILIIzOWQ5sperhWIG3A4FKmvoiaiLjtRpeGtPCABw8WQfRpY6sjwiImqPrQdkIuelcsppIYnL1YQQCMcES9WIqMvqgzpe3BqAIYC5Y92YMsKV7SFZjhACWw+Hcaxey/ZQiEgSnMkhywnFBFRFznKvmA4YghuBElHXhGMGnt3cjGhcoGKwA4vGebI9JEv6+weNePCtejjtCn7/uREYWsSZLiI6O56JkaXEdYFY3JwJkbFlKpsOEFFX6YbAi9sCaAwbGFRgw+XT/FIe9zJh25EIALO99u6aaJZHQ/lLydIf6gmGHLIUmUvVALaPJqKuEULgzd1BHKuPw+dSsHJWARw2nsx0JjX8GSKLAyEiafBMjCxF/s5qiZAmYakdEWXOxoMR7KqJwa4CK2cVwO/u/2PeO3uC+PnLp9AY0vv9tfpa6gSXwZRDWdLSQTrTf6hnuCaHLEX2zmqcySGiczlwMoZ1B8IAgOXT/Rhc2P+/ivefiOLe508BALYfieIPnx/Z76/Zl1InuXRmHCLqAoYcshT5y9W4JoeIOlfbFMcrOwIAgMXjPagY7MzI6/5xbUPy7eONceyuiWDycHdGXrsvpLbkFww5lDXWbyH98ksv4q233sLhw4cwa/Zs3Hnnt5L3HT1yBL/73SOorq6C3e7AvHnz8JlbPwuXy+zoGAqF8NCDv8WmTRvhdDqxfMUVuP76G5If39v7M03OM0nKWfKXqyVmcthdjYjaCEQMPLelGXEDmDLchTljMhMyjjdo2HgwnHZbauiRAcvViLqmpLQU1153HS655NJ299133y8xfPhwPPTQI/j5z/8Hhw4dwj+efCJ5/+9+9wgCgQB+c/9v8cMf3YPXX3sNb7/9Vp/dn2k8EyNLSc7kSFuuxpkcImovFhd4bkszglGBkSV2XDTZm7FOao9/0Nhusf7mQxFsT3Qsk4Et5WyFGYfyUTgcRigUSv7RtI73jFqwYCHmz1+AgsLCdvfV1p7E0mXLYHc4UFhUhHnz5uHw4cMAgGg0inVr1+DjN90En8+H4cOH44orrsAbr7/eJ/dnA0MOWUpyTY7EMzlOuwKbypBDRCZDCLyyI4BTzTqKvSqunOnP2DHidHMcrybK49r6y3sNGRlDX0gtV2PIoazJYueBL33xdnzm059M/nnqqX92e/grV16Nt99+G7FoFA319fjggw8wd948AEBNzTHE43GMHVuWfPzYsWU4fPhQn9yfDVyTQ5YifblazJB27ETUP9btD6PqlAaXXcHVswrgzmA5a/WpGOJGx/cdOBnL2Dh6K61cjYtyKA/d/8CD8HhaNwt2OLq/Ie6s2XNw/29+hU996hMwDAPnnTcfF110MQAgEonA5XLDZrMlH+/1+RAOh/vk/mzg2RhZSkjicq+4LqDpco6diPrHjqMRbDoUgaoAV830o9hnO/cH9aGZoz1YPN6LgpQW1TYVGFlqx+cvLMnoWHojdeLL6CS0EeUyj8cDr9eb/NPdkBMIBPDjH/0Ql1xyKf7yl8fwu9//ES63G//3v/cBANxuN2KxKHS9tcV8KBRMBqve3p8NDDlkGYYhEI4JuB1ylnu17JHD9tFEBABH6jS8tScEALh4sg8jS7t/5bW3nHYF37tmMH5587DkbcOK7XjksyOxYnpBxsfTU2khhxM5RN128uQJxGIxXHHlVbA7HPD7/bjsssuwadMmAMDw4SNgs9lw6ODB5MccPHgQo0eP7pP7s4FnY2QZLZ3JZC33Su6Rw41AifJefVDHi1sDMAQwd6wbU0a4sjoeNXXhvoQzIWpKymG5GlHndF1HLBaDoesQhkAsFkNc0zBi+Ai43W6sXv0ydF1HOBzG66+9hrIycw2Ny+XCokWL8fjjf0UoGMTx4zV4+aUXcXGiS1tv788Grskhy5C/sxo3AiUic23es5ubEY0LVAx2YNG47JVrtEidCZExI3Amh6xAUZSMdUVMvmY398n5xz+exJNP/D35/iduuQlTpkzFD374I9z1rX/Ho3/5M/7218egqiomTpyEL3/lK8nHfva2z+HBBx/AF794O5xOJ1asuAIXXHBhn92faQw5ZBmyd1YLafKuJyKivqEbAi9uC6AxbGBQgQ2XT/Nn/KSoI+ndyfonJWw9HMGROg0rpvtht/Xt58zuakRdc+ONH8ONN36sw/smTZqEH99zb6cf6/V68bWvfaPf7s80Oc8mKSfJ31mNG4ES5TMhBN7cHcSx+jh8LgUrZxXA0ccn+z2VOhOi90NI2HUsild3BrHneAyBaN/Xw6U3HmDKoWxRsvSHeoJnY2QZLTM5PmnL1TiTQ5TPNh2KYFdNDHYVWDmrAH63dX7Fpq7J6euJnGP1GlZvN/fiWVjhQbG37zvIqdwMlIi6yTpHYMp7yTU5ss7kaJzJIcpXlbUxrN1v7gexfLofgwutVQ2uplwN7suZkIaQjqc3NkMXwIShTiwe3z/rj1iuRkTdZa2jMOW1kOQL98MxAzYVcGR2GwwiyrLapnhyJmPxeA8qBjuzPKL2+mMmJKoZ+OeGZoQ1gaFFNlwxo//WH6U3HmDKoSxRlPSdaTPzohl+vdwh59kk5aRk4wFpy9UEvE7VEouMiSgzAhEDz21pRtwApgx3Ys4Yd7aH1KG+7k5mGALPbQmgLqijwK1i1dzCfl1/JHsLbCLKPIYcsgyZy9V0QyAaF9wjhyiPxOICz21pRjAqMLLEjosm+yx7kUPpw+5qQgi8vjuIg6c1OGzAtXML4HP173E7rdyOEzlE1AXynU1SThJCIBQTcNpgmW5E3RHR5C61I6LuEULglR0BnGrWUexVceVMP2yqdY9dqYfV3s6EbD4UwdbDUSgAPjKrAIMysP4ovdyOKYeIzo1rcsgSIpqAIQBvP18N7GtRzcBbe0LQEj1Zm8I6dh6LYvwQJ5x2657wEFHvrN0fRtUpDS67gqtnFcBt8YYjfbUmp7I2hjd3hwAAF07yZmz9kdKHIY2I8gNDDlmCrHvkxA2gtllPvl8fMlB/KAKXXcG4IdZbfExEvbfzWBSbDkWgKsBVM/0o9lm/20hflKudao7j+S3NEABmjnJhztjMrT+ypYyf8ziULYqiZLwkVWHjgR6T64yScpaeuLRYYKF9JbrC51IxpDD9BMfjUDB6gCNLIyKi/nSkTsObu4MAgIsm+zCyVI6f9d42HghGzU5qmg6MGeDAxVMyu/4odSZK56IcIuoCzuSQJQwssOGiyV4ML5bjhCFVxWAnTjaFk+/PL/ewVI0oB9UHdby4NQBDAHPHujF1hCvbQ+qy1JDT3YkcTRd4emMzmiMGSn02rJyd+fVHSh93hyPqGQWZb+nM84mekuuyOeUsVVEwYajLUjuEd9XoAY7kL+AhhTaMKuW1A6JcE44ZeHZzM6JxgfJBDiwa1z+bXvYXRWktejGE2TihK4QQeHlbAMcb4/A4FFw7Nzvrj1I3A2XfASLqCp6NEfWSw6ZgUIENtU065pd7LNtCloh6RjcEXtwWQGPYwKACG5ZP779NL/uTqgJ6YtG+QNeuD6/dH8beEzHYFOCaOQVZW3+U2h2O5WqUNdwMVCoMOUR9YPk0P3TDgE2VbyaKiDonhMCbu4M4Vh+Hz6Vg5awCKdvcA2bJWkubFMMA1HPklV3Honi/0izFvXy6P6vrj1iuRkTdxTMyoj7CgEOUezYdimBXTQx2FVg5q0DKktoWajc6rB2r17B6ewAAsLDCk/X1R6rKcjUi6h55j9ZERET9qLI2hrX7zZmM5dP9GJyBTS/7U1c7rDWEdDy9sRm6ACYMdWLx+OyvP0rbzJQph4i6gCGHiIiojdqmeHImY/F4T8Y2vexPXSn5impmq+iwJjC0yIYrZlhj/ZGStiYne+MgInnIfVmKiIiojwUiBp7b0oy4AUwZ7sScMZnb9LI/mSVfZroxOkg5hiHw3JYA6oI6CtwqVs0ttMz6I3ZXI6vg5pzy4EwOERFRgqYLPLelGcGowIgSOy6anNlNL/uT7SwzOUIIvL47iIOnNThswKq5BfC5rHOKkLrkkeVqRNQV1jmCERERZZEQAqu3B3CqWUexV8VVMzO/6WV/Olu52uZDEWw9HAUAfGRWgeXWH6X+M+jMOETUBdY6ihEREWXJugNhVJ3S4LKbraKzsellf+qsu1plbQxv7g4BAC6c5LXk+iOWq5ElcJ8cqeTWEZyIiKgHdh6LYuPBCFQFuHKmHyVZ2vSyP6WWfLUEhVPNcTy/pRkCwMxRLswda831R2md4bhRDhF1AWdyiIgorx2t0/Dm7iAA4KLJPozK4qaX/Sn1qqZuAMGo2UlN04ExAxy4eIp11x91tf01Uf9SkPmZFWv+TMqAIYeIiPJWfVDHC1sDMAQwZ4w765te9qfUDTVjcYFXdzSjOWKg1GfDytnWXn+UOnY2HiCirmDIISKivBTRzFbR0bhA+SCHJTa97E+pGeatPUGcaNThcSi4dq711x9xJoeIuoshh4iI8o5uCLywNYCGkIFBBTYsn26NTS/7U2pQqKzVUOBWcc2cAhRLsP4ofU1O9sZBeS4b1WrUY9a+dENERNTHhBB4c3cQx+rj8LnMTmpW2fSyP6lpIU5g+XQ/Rkqy/ojlakTUXZzJISKivLLpUAS7amKwq8DKWQXwu/Pjep+eUuc1fZRc649S4xnL1ShblMR/mX5N6pn8OLITERHB3BNm7f4wAGD5dL/lNr3sLw0hHc2R1jqvWaPkCTgAYEs5W2G5GhF1RX4c3YmyIKIZ0A3A5+K1BCIrqG2KY/X2AABg8XiPJTe97A9RzWwVnToBIttkSNpGptKNnnIGNwOVCkMOUT+oD+r48TO1CMcExg91Yt5YD2aPdaPAbf0FvkS5KBAxO6nFDWDKcCfmjLHmppd9zTAEntsSQF1QT2sRLVvJl8LGA0TUTQw5RP1A0wUimoAAsO9EDPtOxPC39Y2YNMyFeWUezBrthpczPEQZoekCz21pRjAqMKLEjosmW3fTy74khMDru4M4eFqDwwaU+lQ0hHQA8gWFtHI1yQIaEWUHQw5RPxhcaMc3rxyId/cGsflQBGFNwBDArpoodtVE8dh7wNQRbswrc2P6KLfl96ggkpUQAqu3B3CqWUexV8WVM6y96WVf2nwogq2HowCAj8wsQPXpWPI+2XJCWrkau6tR1mSjh3R+HK/6A0MOUT8pG+RE2SAnbjpfYNexKDZUh7HtSATRuEDcALYeiWDrkQgcNgUzRpkzPNNGuOGw84BG1FfWHQij6pQGl91sFe1x5scFhcraGN7cHQIAXDjJi4ohzrS9ZnTJpkNYrkZE3cWQQ9TPHDYFM0e7MXO0G7G4ge1HzcCz/UgEccMspdl4MIKNByNwO8zHzivzYMpwV95ccSbqD7uORbHxYASqAlw5048SCTa97AunmuN4fovZaGDmKBfmjjXXH6VtqClXxoFNkXc9EeUQbgYqFYYcogxy2lXMHevB3LEehGMGth6JYGN1GDuPRWEIIKIJrK8MY31lGD6XgtljPJhX5sGEIc60zfCI6OyO1ml4Y3cQAHDRZB9GSbLpZW8Fo2YnNU0Hxgxw4OIpreuP0kq+JEsKatqaHLnGTkTZwZBDUgvHDGh6z3/hOWxK1spXPE4VCyu8WFjhRSBiYMvhMDZUh7H3RAxCAMGowJp9IazZF0KhW8WcsR7MK3OjfLCzzc7lRJSqIajjha0BGAKYM0auTS97Q9MFnt7YjOaIgVKfDStnp68/Sj1syBYTFIlnoYgoOxhySFrhmIFlP6lCNN7z33guu4J37i7Pep2+361iyQQflkzwoSmsY9PBCDZUh3Gg1lwo3BQx8NaeIN7aE0SJz4Z5Y82SttEDHHnRJYqoqyKagWe3NCMaFygf5MCi8Z5sDykjhBB4eXsAxxvj8DgUXDu3oF1Dk9QOZbpk61rSZ6GyOBDKc2w8IBOGHJKWpgtE4wJP3VEOv7v7ISUQMbDqvipouoCVToMKPTZcONmHCyf7UBfUsbHanOE5dEYDYO7B8+rOIF7dGcSgAhvmlZklbSNK8qMch6gzuiHw4tYAGkIGBhXYsHy6P29mPdfuD2Pv8RhUBbhmTgGKO1h/lPq1kK3iy5Y6CyXb4IkoKxhySHp+t5qzm2yW+my4bJofl03zo7Ypjo0HzcBzrD4OADjVrOOlbQG8tC2A4cV2zCvzYG6ZB0MK+aNN+UUIgTd3h3C0Pg6fy+yk5rDlR8DZdSyK9yvDAIDl0/0Y2cn6o/SSL7mCQurYe1GhTNQriqJkvHpC4UxOj/FMiEgSgwvtuGJGAa6YUYCaeg0bEoGntsnc3K+mIY5nNzfj2c3NGD3AYQaesW4M8PPHnHLf5kMR7KqJwq4CK2cV9Gh2V0bH6jWs3h4AACyo8Jx1/ZHM3dVSG69Ils+IKEt49kMkoeElDlxd4sDKWQU4UhfHhkRJW13QDDyHz2g4fEbDPzc0oXywA+eVeTBnjAdF3tyc8aL8Vlkbw5r9rTMZg/NkJrMhpOPpjc3QBTBhqBNLzrH+KLUJgWwhxybxLBQRZUd+/CYgylGKomD0AAdGD3Bg1dwCVJ/SsKE6jI0Hw2gMm6tzq2o1VNVq+Pv6JkwY6sS8Mg9mj3HDn6MlfpRfapviyZmMReM8qBjszPKIMiOqGXhqYzPCmsDQIhuumOE/ZxlN6r2ytZBOK1dj4wHKGjYekAlDDlGOUBQF5YOdKB/sxPXnFWL/yRg2VIex6VAEwagBAWDviRj2nojhr+83YvJwF+aVeTBrtDvr3eWIeiIQMfDclmbEDWDKcGdy08tcZxgCz20J4ExAR4FbxUfnFHZp/VH6XjP9OMB+wHI1IuouhhzKWXt278Lbb72BY0eP4pZPfhoTJ03O9pAyRlUVTBzmwsRhLnx8ocCemig2HAxj86EIIpqAIYCdx6LYeSyKR1Vg6kg3zivzYPpIF1wOBh6yPk0XeG5LM4JRgREldlw02ZcX7dSFEHh9dxAHT2tw2IBVc7u+/iitDbNkQUFluRpZQTYmcqjHGHIoZ02aPAX79u7B+++tg92ev9/qNlXB1JFuTB3pxs0LBXbWRLChOoJtRyKIxQXiBrD1cARbD0fgtCuYMdKc4Zk6wg2HnUdzsh4hBF7ZEcCpZh3FXhVXzkjf9DKXbT4UwdbDUQDAR2YWdGv9kcxBQeamCUSUHfl75kd54eqPXovyinHYtnULKsaNz/Zwss5hVzBrtAezRnsQ1QxsPxrFhuowdhyNIG4AsbjAhoMRbDgYgduhYNZoc4Zn0nBX3pxEkvWtOxBGZa0Gl91sFZ0v5ZZVtTG8uTsEALhwkhcVQ7q3/igtKEi2rkXmWSjKJVyTIxOGHMpZr7+6Gnt278aRI4dw8yc+ne3hWI7LoSY3Eg3HDGw9HMGH1WHsronCEEBEE3i/Moz3K8PwuVTMGePGvDIPxg9xptXHE2XSrmNRbDwYgaoAV870o6SDTS9z0anmOJ7fEoAAMGOUq0frj2Re15K2nogph4i6gCGHctYlly3HJZctz/YwpOBxqlg4zouF47wIRAxsPmy2pN53PAYBIBg18O6+EN7dF0KhR8XcsR6cV+ZB2SBHXqyDIGs4Wqfhjd1BAOZMxqhONr3MNcGogX9uaEZMFxg9wIFLpvRs/RHL1YgonzDkEFEav1vF0gk+LJ3gQ2NIx6ZDYXxYHUZVrQYAaAobeHN3EG/uDqLUZ8PcMrOkbVQpAw/1n4agjhe3BWAIYM4YN6aNzI9Oapou8PTGZjRHDJT6VFw9u+frj1I/TJcsKLBcjaxASfyX6deknmHIIaJOFXltuGiyHxdN9qMuEDfX61SHcfiMGXjqgjpe3RHEqzuCGFxoS5a/DS/OjyvslBkRzcCzW5oR0QTKBzmw6BybXuYKIQRe3h7A8cY4PA4F184thLsX3Q9Tg4JkEzlom+sMIdI+HyKithhyiKhLSv12XD7Nj8un+VHbFMeGarOkraYhDgCobdLx4tYAXtwawPBiezLw5Mvu89Q/dEPgxa0BNIQMDCyw4fJp/rw5uV13IIy9x2NQFeCaOQUo7uX6IyWt8YBcKaddyDEANT+WY5GVsIW0VHj2QdILRHrWJqinH0fA4EI7rpxZgCtnFuBYvYaN1WZJ26lmHQBQ0xDHs5ub8ezmZowZ4MC8Mg/mlnlQmieLxKlvCCHw1p4QjtbH4XOZndScedLWfNexKN47EAYALJ/ux8g+WH9ky5HNQAH5xk9EmceQQ9Jy2BS47ApW3VfV4+dw2ZUu7RROnRtR4sCIEgdWzi7A4TOaOcNzMIL6oBl4Dp3RcOiMhn9saMK4wU7MLfNg7lg3Cj0MPHR2mw9FsPNYFHYVWDmrAAVd3PRSdsfqNazeHgAALKjwYOoIV588r8zrWjoqV+MldSI6G4YckpbHqeKdu8uh9WIFrcOm5M0eG/1NURSMGejEmIFOrJpXiOpTZuDZWB1GU2LW7EBtDAdqY/j7B42YONSJeWUezB7jgc/FfwNKV1kbw5r95kzG5dP8eVP22BDS8fSmZugCmDDUiSV9uP5IyZHuaoB8+/xQruA+OTLJj98alLM8ThX5sQRZLqqioGKwExWDnbjhvELsOxnDhuowNh8KIxgVEALYczyGPcdjeOy9RkwZ4cK8Mg9mjnIzdBJqm+LJmYxF4zwY181NL2UV1Qw8tbEZ4ZjAkCIbrpjh79OOhTJvBqooZo+plmgm2fCJKAsYcoioX6mqgknDXJg0zIWbFhZhd00UG6rD2HI4gogmYAhgx9Eodhw1y5KmjzI3HZ0+0gWnnYEn3wQiBp7b0oy4AUwZ7uzRppcyMgyB57YEcCago8CtYtWcwj4vpU1d1yJbuRpgbgiqJ9KNbI0TKFco6VOimSA4k9NTDDlElDE2VcG0keYeJ1pcYMcxsyX1tiNRaLpA3DDXYWw+FIHLrmBGIvBMGeHi2qk8oOkCz29pRjAqMLzYjosm92zTS9kIIfDG7iAOntbgsAGr5hbA3w/rj2TeDBQwx68n3mbGIaJzYcghoqxw2BXMHmOuyYloBrYfMWd4dh6LIG4A0bjAh4mubR6HgtljzMAzcZirx5shkrXtPR5FbbOOIo+Kq2b2fNNL2Ww+FMGWw1EAwEdmFvTb+qP0kNMvL9GvzMYJ5sBlHD8RZRZDDhFlnduh4rxyD84r9yAUNbDlsDnDs+d4FIYAwprAugNhrDsQht+lYs5YM/CMG+LMmz1T8sGYgU7MGWNg+ihX3qzNqqqN4c3dIQDAhZO8qOjH9UcybwYKmOVqLViuRtmgJP7L9GtSzzDkEJGleF0qFo33YtF4L5ojOjYfMgPP/hMxCACBqIF39obwzt4Qirwq5o714LwyD8YOdKSVNhmGwJE6DcOLHXDkyd4qsitwq1gywZvtYWTMqeY4nt8SgAAwY5Sr39cfpc7k6BKGhNTYK+HwiSjDGHKIyLIK3DYsm+jDsok+NIR0bDwYxobqMKpPaQCAxpCBN3YF8cauIAb4bZg31oN5ZR6MLLXjpW0BPLelGUMK7fjGigEo8nJfHrKOYNTspBbTBUYPcOCSKf2//kiVeDNQoKVxgjlwIeNUFMmPHaSlwpBDRFIo9tpwyRQ/Lpnix+nmeCLwRHCkzgw8ZwI6Vu8IYPWOAAYX2NAYNtswnWyK4xerz+AbKwZwA1KyBE0XeHpTM5rCBkp9Kq6enZn1R9KXq6XOREk4fiLKLIYcIpLOwAI7lk8vwPLpBTjRGMfGRIOCE41xAEBts572+BONcfz3S6dx55UD4Xcz6FD2CCGwensAxxvi8DgUXDu3EG5HZtYfybwZKJA+fgmHTznB+lM5L7/0It566y0cPnwIs2bPxp13fivt/tdffw3PPvMM6urOoLCwEJ+59bM477z5AIC6ujr89oHfYNeuXfD7C3Dd9dfj0ksvS35sb+/PNIYcIpLa0CI7rppVgCtn+nGsPo4NB8N4a3cQES39LKi2Scd3/1GLn904BK4MnVQStbXuQBh7jsegKsDVcwpQ7Mtc6LalrcnJ2Mv2mdTZLjYeIOpYSWkprr3uOmzftg1n6s6k3ffaq6/ghReex9e+/nWMHVuGxsZGRKOR5P33/fIXGDJ0KB56+Hc4cuQw7r3nxxg+bDimTJ3aJ/dnGn/TE1FOUBQFI0sd+OhZNlEMawIHT8cyPDIi065jUbx3IAwAuHyaD6NKHRl9/dTNQGWMCCxXo3wWDocRCoWSfzRN6/BxCxYsxPz5C1BQWJh2u6HrePzxx/GZWz+LsrJyKIqC4uJiDBkyFABw4sQJ7NmzBzfffAvcbjfGj5+AJUuX4Y033+iT+7OBMzlElHN8LhXNEfNStaqYXbtsqtmieMJQV5ZHR/noWL2G1dsDAIAF5R5MG9m/ndQ6khr9ZZwJYbkaZZ2ipH8jZuo1AXzpi7en3Xz9DTfixhs/1uWnqampQWNjA6qrqvDgbx+AruuYNXsOPvWpT8Pr9eLwoUMoKSlGcXFx8mPGjh2LV1avBoBe358NDDlElHO+eeVA1NRrKPbZUOqz5c2mkplgGAKbDgYxsMCBsYMYGLuiIaTj6U3N0AUwYagTSyZ4sjIO2bur2VJbxDPlUJ65/4EH4fG0Hjscju7NBAcC5kWW7du34ac/+08AwH2//B/88Q+/x5f+5cuIRMLw+XxpH+Pz+RAOm7PPvb0/GxhyqN+daNTwvX/WQlWA/7hxKFv5Ur/zuVSM54xNv/j23w/jmY31AIBF4wvw+YsHY36Fv9/bH8sqqpmtosMxgSFFNlwxI3tfq/SQkJUh9EpqSJNxTRHJL5ubgXo8Hni9Pd9HzO02Z48/uupaFCZK2T666lrc98tfJO73IBQKpX1MKBRKBqve3p8NXJND/SquC9zz7Ck0hg3Uhwz8Y0NTtodERD1kGAIvbmlIvr9ufzNu/W0lrv3FXvzjgzNSlkD1J8MQeG5LAGcCOgrcKladZb1YJsjfXU3uFthE2TR8+HA4HM5O7x89Zgzq6urR2NiYvO1gdTVGjx7dJ/dnA2dyqF/9eV0DTqW0823Z04SI2jMMgZguoMUFNF1A0w3EWt5O/B2LG4n7Wt5vud/o4LazfYyR8jodPDb1vsT70bjR4QzA3uMRfPeJI/jlS8fx1nemwGbj9TMAeGN3EAdPa3DYgFVzC+B3Z/frklq1aUg4E6JKHtJSRTQDB09rGDvQkbEW4pQfdF2HruswdB3CEIjFYlAVBU6XC0uXLcMzTz+dbDzwzNNPY16iffTQoUMxadJE/PWxR3HrZ2/DkcOHsWbNu/jmN+/qk/uzgSGH+s27+4J4ObHQtkX16RjiuoA9i1czibLhD2/X4sUt9QjF0sNFagCRvQTnTCCOtfsDWDap8NwPznGbDoax5XAUAPCRmQUYXJj9X7ep3dVknHSzSR7SUn3vn7XYczwKr1PBhZN8WD69AGWDOr/KThZh/W1y8I9/PIknn/h78v1P3HITpkyZih/88Ef4zGduxSMPP4SvfPlLcDgcmDvvPHz6059JPvaOO76OBx64H5+77Vb4/X7c8olPprV/7u39mabE45qEhzqyujOBOL722AnE4u2/vX64ajAmDeN6CcofWw4GcfOv92d7GP3OpgBvf38qSn2ZbY1sNVWnYnhqQzMEgAsneTGvLHs16ale3xXAf754GgBwyRQf7rxyUJZH1DUHT8ewensAL21rTnZNPK/cgwXlHlwzpxCqZOvBdENg1f8ebnf7wAIbLpniwy3nl2RhVHQ2oVAIn/n0J7F14O0w1MyGUdWIYebpB/GHP/65V2ty8lH2Ly1RTjp4Wusw4ADA9qMRhhzKK6pFqlFUBXDaFThsChw2FY7E2623mbcn30+93a7CYVPw7MY6RDv42Z45xovvXTsy7wPOqeY4nt8cgAAwY5QLc8dmvlV0Z9LLvbI3ju763j9P4lh9PO22D6vC+LAqjIF+O5ZO9HXykZmj6QJNYR2NIQONYR0NIR1NYQMNIR2N4ZS3QwaawnqHz3G6Wcfj65tQ4rXhypmcDbUmCaZyKIkhh/rFjFFurJxVgLf3BtEUTq8rkK2UendNBIfPaLh4ij+ri4ZJXjNG+/C9a0filW0NEAKtAcKeCBu2NmEjGT7UlPBh3t72ttaPUdsHFrsCZ0qY6YtW2lW1EWysDibfv2hKIe5YMQwThlljtiKbglGzk1pMFxg9wIFLpvgs1XVO1oX7trN8DZ32/vn66oZAc8RAY0hHQ1hHUzK8mCHFDC8tbxsIRvuufs7lsM73DJHMGHKoXzhsCj6xqBhnAjrWHTBbCl41048irw0rpvmzPLquawjp+I8XTiMaF9hxLIKJQ12oC+qobYqjtkmH16XgXy8dgAF+/ijR2X38/IH4+PkDsz2MXvv2R0fif16ogc9twyeWDMTcMnl+nvuTpgs8vakZTWEDpT4VV8/2W25/ptRrNLpEUznXnleIX64+0+72UaWOLpcCGkIgGDXQGDISsyxmOGkMm2GlMaSbf8Lmbc1hA/31FbLbAAgg3iYXeZwKbpxfhEumFPTTKxPlF56ZUb+qPhUDADhswM0Li6VrOLD/RBTRuIDDBmw7EsW2I9F2j9l6OIKLp/BEj/LDpOEePPj5imwPw1KEEFi9PYDjDXG4HQpWzS20ZMcsWTcDXTG9AH97vxEnGtNL1q4/rxAnm+JoChloCKeElESJWGt4MYNLf33OqgIUeWwo8qoo8tpQ5FET7yfe9tpQ7LGh0Kui2GODx6ngv148jTX7Q8mP/8isAty8sBhel/W+byiFgvRe7Jl6TeoRhhzqN6GogeOJX0pjBjqlCziAuYD4nBSz9a9qsau2RJQZ6w6Esed4DKoCXDOnACU+a254bPVytahmtJaDpaxvaQwZGFZsR31IT55jqoqCB9+qB1Df5+NQABS0BJVESEkNL8VeFYUeG4q9ZrDxudRuNz+4enYhKk/FMLTQjk8vKUH5YHZWI+prDDnUb6pOtwaEcklbY1adMvf1ieuA1wVoHawX/eOaBjy9sQnnlXmwoMKLcUOc0nX7IaKe2V0TxXsHwgCAy6f5MKrUuo0XrLrPjBAC//HiaazbHzrr4+y9uJDkc6nJcFLkUVHstSWCihlcWmZZCj02FHrUfi81nDTchd9+ZkS/vgb1PSXxX6Zfk3qGIYf6TXVtasix7i/+zgghkjM5xT4bvnXVQPzshVMIRtufHDSGDby2K4jXdgVR6rNhfrkHCyu8GDvQYamFx0TUd47Va8m9wBaUezBtpHU6qXXEqvvMnAno5ww4bbkdijmT0jLT0lIulvp34u1Cj41NY4jyEEMO9ZvKU3LP5JwO6Agk9mQoH+TA6AFO3HXlIPzshVMIxcyg84ULS1B1SsMHVSE0JrrI1QV1vLw9gJe3BzC40IYF5V4srPBipIWv8BJR9zSEdDy9qRm6AYwf4sSSCdbvLpd6wcVKa3IGFtixam4h3q8MmTMuidmUIm9KaVjqbItXhcvOtStEdHYMOdRvqhOlXg6bIuUJflXKTFTLTtRjBjrxrasG4ckNTZg01IlF431YNB64eWER9hyP4v2qMDZUh5PtRGubdDy3pRnPbWnG8GI7FlZ4saDcg6HF8n09iMgU1cxW0eGYwJAiG66c6Zdixja98YCFUg6AW5eW4Nal3ASTiPoOQw71i2DUSHbCGTvQYblWql1R3clM1JiBTvzbivRWwKqqYMoIN6aMcONTi4ux81gE6yvD2HgwjIhmnkzUNMTxz41N+OfGJowZ6MDCci/ml3swsIA/hkRWd+BkDB9UhbFonAcbDkZwJqCjwK1i1ZxCaUqhhhS2Hmt43CGiXMejHPWLzgKCTFI7q5V143OwqwpmjvJg5igPYnGBbUciWF8VwpZDEcR0M/AcOq3h0OlGPP5BI8YNdmJBhQfzy70o9lqzKxNRvttQHUZNQxxPbmgGYLbFXzW3AH63PGVTI0oc+Mqlpdh/IoabFxZlezhE8lGULLSQluMiihUx5FC/SFuPI2FrTCFEstyu1Gfrcfhw2hXMK/NgXpkHEc3AlsMRrK8MYduRSHIjuAO1MRyojeGx9xoxaZgLCyrMxxe4GXiIrCCuCxxvSN+jZcwABwYWyPczunJWYbaHQESUEQw51C9k76x2qllHINrSdKBvQprboWJhhdmEIBg1sOlQGOsrQ9h5LApDAALA7uNR7D4exZ/WNmDqCBcWVngxZ6wHXqc8V4uJcs3xhjj0NktYDtRq2H4kipmjrd1RjYj6koLM787JmZyeYsihftFS6uW0KxhRIl/IqU4rVev78ftcKpZO8GHpBB+awjo2Hgzj/cow9h6PQsDsfLT9aBTbj0Zhf7ceM0a5saDCi9mj3XBZcCd1ou4IxwxobVNDNzhsCjwZDP77TkTb3eZ1KhhcKN9MDhFRvmDIoT4XiBg42WTumjl2gJxNB6oyuKao0GPDRZP9uGiyH/VBHR9Wh/B+ZRiVidmwuAFsOhTBpkMROO0KZo82A8/0kW447fJ9bSm/hWMGlv2kCtF4z0OOy67gnbvLMxZ0KhOlqwAwuNCGuWM9mDjUCbskDQcot8l20YAoUxhyqM9VSb4eB+h504HeKvHZcPm0Alw+rQCnmuP4oMosaTt0xjzJisUF1leFsb4qDI9DwdyxHsyv8GDqCHevdgOn9nji0D80XSAaF3jqjvIeLdoPRAysuq8Kmi6QqZ1pFo3zYMvhKBaP93CDX7IUGS8ayExRlIz//PN403MMOdTnZO+sltp0YIDfhqIsdTwbVGDHVTMLcNXMAhxv0MxwUxlCTWIBdFgTWLM/hDX7Q/C7VMwr82BhhQcTh7qgMvD0Ck8c+p/frUrTXGPaSDemjeTaG7IeGS8aEGUKQw71ucp+Xs/S32qb9eRmnpmcxTmbYcUOfHSOA9fMLsDR+jjWV4bwfmUIp5rNssBA1MBbe4J4a08QRR4V88u9WFDhQcVgJ1ReBeo2njgQkUxkumhAlCkMOdTnWmZyXDnQdMBqM1GKomBUqQOjSotw3bxCVJ/WsL4yhA+qwqgLmoGnMWzg1Z0BvLozgAF+GxaUe7CgwosxA1hm0108cSAiIpITQw71qUBER22i6cCYgZI2HaiVYyZKURSUD3KifJATH1tQhAMnY3i/MoQPq8NoCpszUWcCOl7cFsCL2wIYUmjHggoPFpR7MbLUup8XERERUW8x5FCfqkrpQlRhsVmQrrLyTE5nVEXBhKEuTBjqwi3nF2PP8Sjerwxh48EwglFzXcnJpjie3dyMZzc3Y2SJHQsqvFhQ7sWQIh4GyBpeevF5vP3m6yivGIcbP34ziotLsj0kIqJWimL+yfRrUo/w7Ib6VLa6kvUVs+mA+TkM9NtQ6JGvVMmmKpg6wo2pI9z49GKBHcciWF8ZxqZDYUQ0M/AcrY/j6IYm/GNDE8YOdCQCjwcD/DwkUPZ4PB4UFBYhFArBZpPvZ4/IajZv2oAPP1iPLZs24uJLL8f1N34820Miyhie0VCfSi31qpCwfXRtk45gzAwCMoa0tuw2BbNGezBrtAexuMDWI2Gsrwxjy+EwNLOqEAdPazh4uhGPr2/E+CFOLKjw4rwyD4qz1FVOBuvWvIvv3H0n3njnvWwPJadceNEluPCiS7B1y2b8/W+P4bbPfzHbQ6IOsL26PGbPmYfZc+bhjq98EVd/9NpsDycHKIk/mX5N6gmGHOpTVSlNB4YXy/ftlclNQDPNaVdwXpkX55V5EY4Z2HI4gvcrQ9h+NALdXMKD/Sdj2H8yhkffa8DkYS4sqPBg3lgP/Fx8n7R7104cPXoYs2fPzfZQcs7ad9/Bls2bcPjwIXz281/I9nCoA2yvLp/du3aivGIcnM7c+p1GdC7ynYWSZTVH9GRL47EDHVLu1VIlefvrrvI4VZw/zovzx3kRjBrYeNDcg2dXTRSGAIQAdtVEsasmij+tacC0kW7ML/dg7lhP3p+YvPzSC/D5fNi7dzfefOM1XHTxpdkeUs5YvHQZFi9dlu1hSCWiGWgMGWgI6ag+HYOuA1fM8EFV++fnlO3V5fPnP/4O/++uu7M9DKKMY8ihPlNV29p0oFzCUjWgbWc1OT+H7vK5VCyb6MOyiT40hXV8WG0Gnn0nYhAAdAFsPRLB1iMR/GFNPWaMcmNBuRezxrjhsudf4Pn6v90JANi7ezcDDmVNIKLjiQ+b0JjopJhqbpMHQ4v792eT7dXl8ZP/+Hm2h5Az2HdALgw51GdkL/UyhMDB04mmAwVyNh3orUKPDZdM8eOSKX7UBXV8WBXC+qowKhPhT9OBjQcj2HgwApddwawxbiws92L6KDcctvw6Ev/8vl9lewiUx2I6Ogw4RR4VQ4ry79hFRNQWQw71GdlDzsnGOEKJpgMyjr+vlfpsWD69AMunF+BUUxzrq0JYXxnG4Tpzxi4aF1hfaTYy8DoVzBnrwcJyLyaPcMEuYakikUwK3SoGF9qS+5K1WDHdz01/ifoNGw/IhCGH+kxLqZesTQeqU/b4yZdSta4aVGjHR2YV4iOzClHToCXCTQjHG+MAgFBMYM2+ENbsC6HArWLeWA8WVHgwcahLyrVZRFZW2xTH6u0BnAmmB5zxQ5wYVpy7awmJiLpDvjNRsqSmsI7TAfMXbtkgp5QntrLPRGXK8GIHVs114KNzCnCkTsP7lWF8UBVKNp1ojhh4c08Qb+4JotirYn65uQdPxWAnrzBTUiDSvtSqPz8uFxiGwIaDYbxfGYYhzNK0BRUevLYzCABYPN6b5RES5TguypEKQw71ifSAIOeVxOo86azWVxRFwegBTowe4MQN5xWi6pSG9ZUhrK8KoSFknog2hAy8siOAV3YEMNBvw/xyDxZWeDF6gIOBJ085bApcdgWr7qvq8XO47ErerQFrCOlYvT2QnD2dPtKFpRN8cNoVDPDZIQBL7G31+muv4K03X4ff78fyFVdh1uw52R5SXuBFA6L2GHKoT8jeWc0QAtWJpgODCmzsGtRNiqKgYrATFYOd+PjCIuw7EcP6yhA+rA6jOfFL9HRAx4vbAnhxWwBDi+xYUOHBgnIvRpRYN1DyxKHveZwq3rm7nJtJdpEQAtuPRvHuviA0HfA6FVw21Z9WUjukyDq/yt0uNwLNzYiEIxg6dFi2h5PzeNGAqHPWOTKS1GQv9TrZGEeYTQf6hKoomDTMhUnDXPjEomLsrolifWUIGw6Gk40dTjTG8cymZjyzqRkjSx1YWO7B/AovhhRa45DEE4f+5XGq3COlC4JRA6/uDODgafMi0vghTlw82WfpgLdt6xbc+7P/RnVVJZ5/7ml87vYvZXtIOY0XDTKNjQdkYo0zCpJeS8hxOxQMk7DpQPomoAw5fcWmKpg20o1pI9349BKBHUcjeL8qjE0Hw8kd04/WaXiyTsOTG5pQNsiBBeVezC/3YIA/e99HPHHIXduORKAqwLSR7mwP5az2n4ji9d1BRDQBp13BRZN8mDTM+uvaho8YgV/+z38hGongxo/fnO3h5AVeNCDqmHxno2Q5jSEdZ1KbDlj8l3BH0maiJCy3k4HdpmDWGA9mjfEgGjew7bAZeLYeDkNLNImqPqWh+lQj/ra+EROGOLGgwovzyjwoysJaA5445J7V25vx3X/WAgB+dsMQXDzFn+URtRfRDLy1J4g9x81j0qhSOy6f5pemhPaaVdfhmlXXZXsYRP2CfQfkwpBDvZYbTQdS2kcPlPNzkInLruK8ci/OK/ciHDOw+XAE6ytD2H40Aj2xnGXfyRj2nYzhL+81YPIwFxZUeDFvrAd+N2dHqGc2VIeTb6+vDFsu5Bw+o+HVnQE0RwzYVGDJeC9mjXZbfvaGiMiKGHKo12Rfj2MIgYOJz2FwoQ1+Sa6Y5gqPU8WicV4sGudFIGJg48Ew1leFsKsmCiEAIYBdNVHsqoniT2vqMW2kGwsqPJgzxsNyMOqW1Flmzeh5KWJfi+sCa/aHsOVwBIB5HFoxzY/SLJZsEhHJjkdQ6rWqlFkQGUPOiYY4wpp5wsP1ONnld6u4YJIPF0zyoTGkJ/YECWHfCTOE6gLYeiSCrUci8Dob8M0rB0n5PUfZYU+5fhHvxXqrvnQysbFnXVCHogDzyzyYX+6BTcK9xii/HKvXsP1IBEsm+uB35csFJzYekAlDDvVada15AupxKBgqedMBnjBbR5HXhkum+HHJFD/qAnF8UGXO8LSE6lBMYO/xKP/NMuyRt+vw1MYmXDOnEJ+/sDTbw+kWe0q3u940legLhiHwYXUY66vMjT2LvSqWT/NjWLEc5bJsr57fglEDn/jtUQSjBuaMceOBz4zI9pCI2pHvjJQspSGk40xQ7qYD1Qw5llfqt2PFjAKsmFGA2qY4PqwKIRIXuHiyL9tD6zeGEJb7edp/Ior/e+0MAODXr5/BwgoPpo+Spz2DPWV2JJ7Fc+36oI7VOwI4kdjYc8YoF5aO98Fht9a/d0fYXr3vfFgVwi9Wn8bUEW7cvXKQVGuv9h6PIhg1f4i2HYlkeTQZxM4DUmHIoV6pTmu9LMcVyLZSy+3GMuRY3uBCO66aVZjtYfSrJz9sRFWthi9dXIICj3XWiD38dl3a+7967Qx+e+vILI2m+1JPrLNRriaEwLYj5saecQPwucyNPccOlOe4w/bqfUPTBe5+8iSicYGj9QHMGuPGVTPlOa5FtNarBC4JwjnlJ4Yc6pXK2taQUyFh62XDEDh42vwchhTa86iumKxsT00MMV3gcJ2GqSOsEXJqm+J4fXcg7bb1VWHsOBqx/J4zLbK5JicQ0fHKziAOnzEvqkwYam7s6XbId8xhe/Xee3pjU3KvMAB4ZlOTZCGndewuCb+HKT/wO5N6pVryTTSPN8aTB2tZZ6Io96iJI7OFGoDhL+vqEdfb3/5/r53O/GB6yJGlNTl7j0fx53WNOHxGg8uuYMV0P66cUSBlwKHea47o+NPa+rTb9hyPobI2mqURdV96yMmnmRwlS3+oJ3iEpV6pTJR6eZwKhhbJNzHIpgO56XiDhvteOY139wWzPZRuqToZxl2PVuK5D45if00TDIus0W4K63jiw8YO71tfGcbmQ+EO77OaTK/JiWgGXtzWjJe2BxCNC4we4MAnFhVh0jBX/784Wdaj7zWgMdz+G/Bv6zv+GbOi1HI1d16FHJKJfGelZBkNIR31LU0HBsrZdKCqVu6ZKOrYs5ubUR8y8ObuIM4r81j+ivnx+ih+vfoY/vnBqeTsTX3gDI43DMTM0T0vBRNCQNMFYnEBTTegxVveN6DpIvG+kbhfQEvcnnx84jEHT2sIxzqf+fjZs0cxvBCtz514PkUBLppaglsvHGqJRdWZLFc7dDqGV3YGEIwK2FVg6QQfZoxyWeLrICtDCPxxTQMimoHPXVAqZfOCQMTAkx80dXjfazsD+OJFpRggwf5IqaV2Vj++9iU2kJaL9X+SyLKqJF+PA8hfbkftnQnEcTzRtcoQwHsHQrhosrV2tm9xsjGG7z5ehbV7G6F3MLPw0GtH8ca202bYaBMgWkJL20AS01Mf03cn8k5PIVRb+18ZhqFja3UTtoqOX+vDymaUDXbjoqklfTaWnspEC2lNF1izL4itR8zSoyGFNiyfXoBSnzXWVsnsWH0cH1abs4b7T0YxZbgca8FSNYZ1xDr53tMN4GidJkXISS1X40wOWZX1f5LIsiolDwhm0wGz3G5okR0+Nh3ICWv3h9Lef68yjPnlXsv9+woh8JGfbUNzpIOFLgk7jwSx84g1Su5i4SYoigqXrzjltgAMPdb5ByUEzvI5ZlJ6uVrfh5wTjRpWbw+gPmRAUYAF5R6cV2a9jT2FEFLOKKXOvnW0PkwGI0ocuOPyAVi9PYA9x1vX4BS6Vcyv8KY18dANgUDEQGNYR2PYQKFHxehShyX+7fK2XI0tpKXCkEM9ljoLUjFYvkX7NQ3x5JS7jCGN2msM69hyOH3PhlhcYO3+EC6fZq3ZnGBUP2vAsSIh2k43nT0ouBwKLpteihWzrLFpaHoL6b57Xt0Q+KAqjA+qwxACKPHZsGKaH0MsuE7xV6+dwdYjESys8OC2Zdb4d8kXhhAIRg0srPBiaJEd//7EyeR9V88pQCAi8KNnatEUNoNNIGK0+wn7yqUDcMHE7O8Plj6TY60LSEQtrHcEJmm0lKt5nQqGFMr3rZS+Cah8IY3aqzwZ67Aj2f6TUcuFHL/bjqHFTpxoOPdMSEfsqgJHYlNFp12Fw2a+77SpydsdNhVOe8vj1MRjFThaHm8z33amPN5hTzzG1vqcyeexKfjaX08lF+3/v5WjceFkH5wdvJbdplhuBqM/1uTUBeJ4eUcAtU1mapo12o0l471ppXFWcSYQx9bExo3rK8O4cb6OAjfL6HpKCIGwJtAY0tEUMdAUMmdcmhIzL41hHU3J9823W45Pbb//Xt3ZtRnbprA1LoykdVfjPjlkUfKdmZIl1AV11IfMM52yQU5LTJ93Fzur5Z5Jw1041qDhREMcxxricNoVTBvhsuw+Lqvvnon7Xz2Gpz44hZONWrv7r50/BP9y+VAziNjSw4qapQDhsJ9GPNGEYFChE+WD5dkxpS9bSAshsOVwBGv2h6AbgN+l4vJpPoweYN1jyYtbm5NvCwCrtwdw/XlF2RtQLxw8HcPEoc4+36MlqhlpQaUpEU4aU/5ODS9aDzNH6ndf259kmwoUum0o9Kgo9NhQlPh7zAAHllpgFgcAovE8LVdj6wGpMORQj1TnQEBI/Rxk2nGcOud1qlg5qxBbj0Tw1MYmeBwKrp5t3Q32XA4VX7tyFP51xUi8vqMeD75Wgx2JNTiqApw3vggjB1groDlsCsKJU7T+WNfSn/pqTU5zRMcrO4I4UmcG00nDnLhwkrU39jwTiLdbr/bmniCWT/dLM5sjUppbPL6+EduORvCdlYPP+jGaLtKCSlqACeloiuhoDLWGmNSuYX1FAVDgUVHotqHIawaWqGbgpW3m5rp+t4ofrRqMQo8ZbHwu1fLdSlmuRjJgyKEeSe2sJmPIadt0wGuxRenUOy3nsrKcg9tUBZfPKMVl00vwQWUzHnnrFDwuF0p81vvZSg0KmdxQsy+kd1fr/scLIbDneAxv7gkiFhdwOxRcPNmHCUOtv+/Ni1ub0fafKxYX0szmHKnT8PA76Rto7jwawbt7A2apWLvyMPPv0Flan/eGz6UmZ1ha/i70qChKeb/Io6LQa4PfpbYr3dxYHU4LOZMl6xQXzdfuamw8IBWGHOqRtFIvCdtHH0tpOiBjSKOzaw05cp2EK4qCBeMKse2ojiN1GnQLjt/eT4v3M6E3a3LCMQNv7A5i/0nz2Dd2oAOXTvHD75bjAsnOmmjHtx+LWD7k/Oq103h7bwh2FSjxtZ62xA3gf1+r65PX8DiU9KDiTZ95aQ0wNhS41V6vuYqklntJuKYltbtaX5cMEvUVhhzqNiFEMuT4XAqGFMpR6pAqfRNQNh3INS1XTY0M7GrfH2yJcwYrjt+RGhRkmSpL6Gm5WvWpGF7dGUAoZm7suWyiD9NHyrWx50dmFuDNPUHU1GuIG4DTpmBYiR3Lp1qrIUdbQgi8vTd07ge24bQrZ59h8djS3nZmOGikzoTIGBLydiaHpMKQQ91WH9TRIHnTgerTcs9E0dnJVq7WlpXHn1au1g/rF/pTauMB3Tj3fjGxuMC7+4LYftScBRlaZMfyaX6USLix55IJPiyZ4MMPnjqJYw1xjB7gwF1XDcr2sM5JURRMHOrE3hMddyG8fKoPFYNdKPLaUOg2y8OKPKrl14mkrv2RMSSwuxrJgCGHuq3qVGsXKFlLvVJncth0IPe0nIdbsdyrK1oWHVux3C5trxkrprCzaFtiFDfSZ6ZS1TSYG3s2hg2oCrCwwoN5Yz1Z62qXz+65biiON2h4elNTMnC2uHCyH+OHWH9NVFvp5V7yfU/l7WagJBWGHOo22Vsv64bAoTNmUBtebIfXae0rftR9quTlaqqFy9XsfdiGOdPaBhpNF2mhDTCPD+srw/iw2uwhV+qzYcV0PwZLuBdYLhlW7MCK6QXJkDNpuAtlAx1S/g4C2nQns8v3Oyhfu6spipLx6hUZq2Wsgkdt6jbZO6sdq9cQS5QKlEk4fjo3K5d7dYXNwuN3yNx4oM0sTNvmA2cCcby8PYBTzeYnNnuMG4vHWXNjz3x3zexCzBglV0eyVOlrcuT7/opwTQ5JgCGHuiW96YCKwRI2HajOgXI7OrvUPSYMISy/50RbLTNRugVTjl3mxgNtwkrLTJQQApsPRbD2gLmxZ4FbxeXT/BhVyqYk1D9Su6vJuKYlfTPQ/JnJIbkw5FC31AXN/QcAoHyQQ8pp1NRyO3ZWy01qyu9cwwBUybK4lWeiHBKXq3W0JqcprOOVHQEcrY8DACYPd+HCiV4pO16RPGTuThY3RNo+UzLORPWckviT6deknmDIoW6RvVQNMNvBAuZhg00HclPquawVg8K5JNcUWbDxQFobZslCTts1OQdORrH1SBSxuIDHoeCSKT6Mk3ARO8knvbuaXIE6NaAB8oU0yh8MOdQtaZ3VJGy9rBsCB0+bn8OwYjs8bDqQk9qWq8l2JYwzOf2jJaC57Arml3vwYXUEAFA20IFLp/rhc/F4QJkRkXhNTmpnNUC+kNYrCoBMV7DI9e1hKQw51C2yd1Y7Wq8lT8zYdCB3pZar6RbsUHYuyZBjwbGnrcmRrfGATcHwYjsWVHjhcaqwqcBFk3yYOkKujT2tIq4LbDgYRiwusGyiL9vDkUpUk3dNToQzOSQJhhzqstSmA36XikEFki10QGupGiBnSKOuUdPK1eSabQAAmyzlalacaupELC6wZl8IF072AwBqm+K4/rxCTBspb4eubDrVFMeL2wM4E9BhtwHnj/O2a8dNnZO5BXM0zpBjZS+/9CLeeustHD58CLNmz8add36r3WMaGhrw9a/dgYEDB+K//vvnydvr6urw2wd+g127dsHvL8B111+PSy+9rM/uzzSGHOqyMwEdTS1NBwY7pbzyWVXLzmr5IL1cLYsD6aHkZqYWnMmRsVztWL2G1TsCaAob0A2BbUci2FMTxc0Li7I9NOkYQmBDdQTrDoRgCLMT3YrpfgacbkoNCixXo75UUlqKa6+7Dtu3bcOZujMdPuZ3jzyMsrIyNDc3p91+3y9/gSFDh+Khh3+HI0cO4957fozhw4ZjytSpfXJ/pvE7k7osvVRNzq5kaU0HJP0c6NzadleTTeuaHOuFCLtNnsYDcUNgzb4gnviwCU1hAwP9Nry2sxm7a6IQkCekWUVDSMffP2jCmv1mwJky3IVPLSpiq+0eSC1Xc0tcrqYqgIR7mUopHA4jFAol/2ia1uHjFixYiPnzF6CgsLDD+z/88AMEAgEsW7Ys7fYTJ05gz549uPnmW+B2uzF+/AQsWboMb7z5Rp/cnw2cyaEuq5J8f5m4LnDojBlyhpfYefUph9naNR6QS2t3tSwPpAPpMzlZHMg5nG42N/Y8HTAHOXesG+eP8+K3b9YlHyNTuV02CSGw/WgUb+8NQtPN8qRLp/gwYSg70fVUeuMBuX4XtW1/LWNVR08pSuY/35bX+9IXb0+7/fobbsSNN36sW88VCgbxpz/+AXd/+zvYu2dP2n2HDx1CSUkxiouLk7eNHTsWr6xe3Sf3n8tzzz2HpUuXpn18bzHkUJeltY+WsLPasXoteVImY0ijrkubyZHwPFaaxgMW/OIaQmDTwQjeOxCCLoDCxMaeIxOzDQ6bkiwVkq1xQjYEowZe3RlIXuQqG+TA5exE12vpLaTlCgmp5Wq8WJg59z/wIDweT/J9h6P7M6h/+cufccGFF2HYsOHtQk4kEobPl95AxOfzIRwO98n95/Lf//1zfPazt2Hy5MlYtmwZli1bikWLFsHv93frc0zFkENdktp0oMCtYqBfvqYD6ZuAMuTkstTGA1Zc13IuyTU5FpyFsvKanMaQubHnsQZzY8+pI1xYNtELV0o9TXp3OGuN32r2n4zi1Z1BRDQBhw24YKIP00eyE11fiEjcXS0qcfvr3sveZqAejwder7fHz7J79y7s3bsH//Ef/9Xh/W63B6FQKO22UCiUDFa9vf9c3n77LdTXN2Dt2jV455138P3v/wAHDhzA7Nmz8corXZsNaoshh7rkdEBHcyTRdGCQpE0H2Fktb7TfJ0cuyXI1CwY0K24GKoTArpoo3tpjllN5HAounepHRQczzrJ2h8ukqGbgzT0h7KqJAgCGF9uxYrofxV75Lm5ZVVTicrWIJu8sVD7bvn07Tp48iS984fMAAE3TEIvFcNtnP4P//vkvMHrMGNTV1aOxsRFFRWZTloPV1Rg9ejQA9Pr+rigpKcaECRNw/PgJnDhxEjU1NTB68YuQIYe6JK1UTdIF+9WJcgtFAcYMlPNzoK6RvVzNlmw8kN1xdCS98UAWB5IQihp4bVdrOVX5IAcuneKHt5NyKivPRFnB4TNmJ7rmiAFVARaN82JemTvtwgH1jhAivbuaZDM56bNQcgW0fKDrOnRdh6HrEIZALBaDqij4yEdW4pJLLk0+7r331uGN11/Dt7/zPRQVFkK12TBp0kT89bFHcetnb8ORw4exZs27+OY37wIADB06tFf3n8ttt30Oa9euxYABpbjgggtw000fx69+9X8o7KSBQlcw5FCXpM2CSLgeJ64LHE40HRhRzKYDuS5tnxwrJoVzUC28T46VQkJlbQyv7QwgrAk4bQoumOTFlOFnL6eyWkizCk0XWLs/hE2HIgCAAX4brpjux+BCnib0NU1Pv4DhdsoWcvJ4Jid71Wpd9o9/PIknn/h78v1P3HITpkyZih/88Edp5W5+nw82mx0DBgxI3nbHHV/HAw/cj8/ddiv8fj9u+cQn09o/9/b+s3nzzTdRWFiISy+9DEuXLsWiRef3qjwPYMihLpK9s9qRutamA1yPk/tyZZ8ca5artb6drXKvaNzA2ynlVCNK7Lh8mh9FnnOXU6Wuycl2SLOKk01xvLwtgDPB1k50i8d50wIh9Z1o231mJJsNyeuQI4Ebb/xYl7quXXjRxbjwoovTbisdMAB3f/s7nX5Mb+8/m6qqSuzYsQPvvPMOHn74IXzhC1/AuHHjcMEFy3D33Xf36DkZcuichBDJcrVCj4oBEjYdqOZ6nLxjU82mAzKGHEuXq9mzO5NztK61nMqmAIvGezFnjLvL6wS5JqeVYQh8UB3G+5VhGIlOdCumt3aio/4Riad/38m2eD8az+fuahJM5Uhs2rRpGDt2LMaNG4eysjI8+uij+PDDDxlyqP+catYRiMrddKBa8nI76j5VAXSwXK2vObLUeCCuC7x3IISNiXKqgQU2rJjmx8CC7v0ac0i0mWl/ihsCj3/QhOONrZ3oLpzk5RqLDEidCbFJuJkmZ3KoP/zgBz/EmjVrsHXrVowfPw5Lly7Fr3/9ayxZsrTHz8mQQ+eUC13JWj4HRQHGDOBVynxglqwJyHgem2whbcVytSysaTEMgSc3NOFEYxwKgHllHiys8MCmdv8EK9/X5LT8ONQ2xeFx2uBxKrhsqh/jePEnY2IpMyEuCTfTZMih/tDU1IQvf/nLWLp0CQYOHNgnz8mQQ+cke2c1s+mAuaZoZIlDunad1DMtHdasuK7lXJJrciw4k5O2piWDs2SBiIFir4rLp/oxvKTnxyErrCnKlkDEQFNiKwABoGKwA5edpRMd9Y/0kCDf1z6fu6spif8y/Zr54H/+5+fJt8+cOZPWEKGn8uu7k3pE9lKvI3UaWi6clUkY0qhnWpoPWDEonIuV98nJRrmaqiq4dWkxPr24uFcBB7BWd7hM2nsiij+ta4CWWA9S7LXh6lkFDDhZEJF8M03O5FB/CIfD+NrXvo6hQ4dh3LjxGDp0GL72ta8jGAz2+Dl5dKOzEkKgMtFZrcijotQnX9OBXCi3o+5rnQ3J7jh6wspjt2dpTYtN7ZuynnwrV4toBl7c1owXtgYQ0UTy8/c5VenKpHJFanc1t2R75ABI2+Mn/0KOYta9Z/JPnszk3H33t3HgwH48++wz2Lt3D5577llUVlbiO9/5bo+fk+VqdFanmnUEc6jpANtH5w9b4hKObsWkcA5WnoVKW7hvmBdCZDou2PNoJufQmRhWbw8iEDU70S0e78VzW+LJYzplR/pMjnzXmlPL1WQstyNreumll7Bu3TqUlpYAAAYPHow//vEPOP/8RfjFL/6nR8/JkENnVVkrd6ka0DqTo7LpQF5pCQoWzAnnZLPweiJ7m8ncuA44JPpNkg9rcjRd4N19IWw5bHaiG1Rgw4rpfgwqsOP5LU1ZHh2lzoS4JJzJkb3cjqxJCJEs1W6hKCpEL36JM4LTWck+C6KlNB0YwaYDeSXZoUzC81hZytUA+YJCrreQPtEYx1/ea8CWwxEoAM4rc+OmhUUY1M1W29R/opKvaZF9/GRNy5cvx6c+9Wls2rQZp0+fxsaNm3DrrbdixYoVPX5OHvXorCpTQk6FhIv2j9RpyTa8ss5EUc+0dleT70S25WqWgFmyplqoHMzR5kqbpgt4sjSWnsjVNTm6IbC+Koz1VWEIYa6hXDHdjxG9bNRAfS/SpoW0bNK6q/HCIfWRn/zkXtx1111YsWIFNE2D0+nE9ddfh3vvvafHz8mQQ50SQiRncoo8KkpkbDogeftr6rnWdS1ZHkgPpOYIwwBUC/3otZvJkWg2RAgBVWkdbzCmIxwz4HHKfaJWF9Dx0vZmnGwyU9v0kS5cMNEHp4SlUPkgKn0L6TyeyUk2A8jwa+YBv9+PX//61/jVr36F06dPY+DAgb1e78mQQ5062aQjGDUPZhWDc6DpwEDO5OQTK5d8nYuact5jtfG3DTmyLN7/oCqEHz1di9rm1umbV3YE8dbug7jj8gG4YX5RFkfXM0IIbDkcwTv7QtANwOtUcPlUP2etLS5tTYuEQZTlatSfFEXBoEGD+uS5GHKoU7KvxwHaNB0YyJmcfCJ1uVrKBQWzw5p1TiQc7dbkZGkg3fTX9xvTAk6LmC7w1MYm6UJOc0TH6h3B5JrDcYOduHSqD17JZ6XyQXq5l3V+trtCNwRiutwzUb3BzUD71ujRY7p0Af3QoYM9en6GHOpUame1CgmvDGq6wJE68wRgZKkDzjzbmTnf2SQuV0vNEbrFQkTbHyMtLscXeOJQF9buD3V439QRrgyPpueEENhzPIY3dgcRjQs47QounuzD5GFyzrbno1hc3pAQbfPzzpkc6o3HHnu0X5+fIYc6JftMzuEzKU0HJBw/9Y7c5WptZ3Kso/1MjrXG15mPLyzC4x80ttsjRgHwicXFWRlTd4VjBl7fHcS+E+axeVSpHcun+VHosdCiLTonmcvVUmehAPnGT9by/e//AK+//hoA4Gc/+xm+9a1v9enzy3UJgTJGCJEs9SrxqiiVselAWkhjqVq+aQkKcm4G2vq21fbKkbXxQLHXhk8sKm53+8VTfBgzwPoXQapPxfCndQ3YdyIGmwpcONGL6+cVMuBIKH0zTblCQmpAA+Sbieq1lsYDmf6To/bv3494PA4A+NWvft3nz8+ZHOrQyaY4QjHzYCbjLA6QPhPFmZz8I/VMTmrIsdj42zceyNJAeuCmhUX405p6hFNO1D6zpCSLIzo3LS7wzr4gth6JAgAGF9hwxQw/Bvj561tWUZnL1dqFnNw9Aaf+t3TpEixZshQVFRUIh8O45ZZPdPi4Rx/9S4+en0dJ6lBlrZZ8W9ZOPS0zOTYVGC3BlVrqW60hx2IpoQtsli5XS39flnI1APA6VSyf7sfTm5oBAEMKbZg4zLrrcWoaNLy8PYCGkAEFwPxyDxZWeNK+P0guL2yuw55j4eT7srX5zveZHAWZbwMj13dI9/zud7/DM888g0OHDuGVV17B9OnT+vT5GXKoQ7LPgsTiAkfTmg7k8mGCOtJSrma1cq+usHS5WgebgcrkzisHIhgVONGo4Z7rhmR7OB3SDYH3K8P4oCoMAaDYa27sObyYZbcy23c8jG8+ehBFhX447Obp18aqZlwyxSdNY5zUUjtVaX/Rg6g7XC4XbrzxRgBAQ0Njn6/JYcihDlXWyh1yDp+JtTYd4P44eYnlav2jXeMByUKO3abi3uutGW4A4Ewgjpe2B1Cb2Nhz5igXlk3wwdHDCzWnmuPYUB3G5GEujLX4sTwY0fHu3iY0huId3n8moKPmjNkh77XtCnYflesUZvPBAID0lsBPrD+N5zeewtVzS/H/rhoBp8VnRto2TWBHP+or9957T58/p1xHCMoIQwhUn040HfDZUCJh04HqU63ldmWSlttR79gkLldL7a5mtcYJsm4GanVCCGw+FMG7+82NPX0uc2PP3qyJNITA5393DCebzNAwZ4wbHovuoxPXBW59YD92HO24zXdb+4419fOI+k9aLhBAU1jHX9acwubqAJ74+uSsjasrZG6a0Bey0QeAObLnGHKonZONcYQTTQcqJO1KVpVWbifn50C9kzPlahbLEHbV/NOyCSh/AfdeU1jH6h0BHKkzw8iEoU5cMtnXq0BiCIFDp2PJgAMAmw5FMG6IE26HiupTMUQ0wzJrKoJRvcsBR3apsx8i5SLMgZORbAynS040avjh07XJ9uUAEIga+MZfj+PjC4owv9ybxdERdYwhh9qpknx/HKB1TRGbDuSvlqAg40SDmnLeabWQoygKLptWgJe2NWOg34aZozzZHpK0hBDYXRPDG3uCiMUFXImNPSe12dgzohloDBloDOtoCutoDCfeTt5m/t1yW1PEvO1s3ztNEQP/9tfj+PWnRmTgMz23Qo8Nl08vxivbG7I9lP6XGnLQ+o90wZSibIymSx5f34iNB9NDmKYDa/aFsO1IBKv/39i8aIihKJkv0WNJYM8x5FA7VSmd1SokLPWKxQ0cSTQdGFXqaLeGgPJDciZHwnI1m2LdcjUAuOe6IbhpYRFGlTpR5JWvnDVb4oZAUyKUnGqK4529IRw8E0MsLuB2KBjot+HPa+sTgcVIBppYvH++ByL99Lw9oSgKfvGpMlSejKAxnN6XPBzV8fcPm3AmoCcjgQKg0KPixvOKUCjJ9+C7exrx4Osn07plCQFMHenFFy4ZgkunW7ed+bCzNL3wOdW8CDjUvx566GF8/vOfa3f7HXd8Dffd98sePSdDDrUj+0zO4TNa8gqmjOOnvpFsPCBjuZqFZ3IAs8X1jDyewRFCIBQTaAzpyUDSGNLRFDHQFGqdaWmZZWkK62gMGQhErfPN6LIr+NkN1mrAoCgKxg1t/321/2QUcRFEUQfrQ4v8TswZI8f34tAiBx5+42Talfn7Pl2GS6ZadwanxZUzC3D/G3UIdvA9/KklxZkfEOWcX//61xg8eBCuueaa5G3f+Ma/YefOnT1+ToYcSmMIkSz1KvXZUCzJFbJUVZK3v6a+IfM+OanXRGUcv0xicWEGklBKIEkJKY0hA81pt5mP0bOUV3wuFUUeFUUeGwq9KgrdNhR5zfeLPDYUelQUelpv+9bfT+BASrfMlpntScNcGFQgx3rF8kFODCqw4VRz+gyP361i6nDr7nPU1ohSF/7wLxPwjb/WJm+bX+HP4oi6zu9SsWpuIf6yriHt9jEDHLhmTmF2BpUFipK+ZjJTr5kPnnzyCVx99TUYMGAAlixZgjvvvBObNm3CM8883ePnZMihNCca4sndwOXdBDSlsxpDTt5SFXkbDyiKAptirieyyvhPN4bxzrYajBjox3kTB6d1gOupcMzoVXc2h03pcHH+odMxHK3XUtaxtISX1lmX5oj5d1jLToi0q0Cx14YirxlMzJDSElDSb0sNNG27253LqnmF+O8XT8PjVPDZZaXYdyKKmoaOWzRblU1VcMWMAvxpbUPa7ZdN9cNlkcYJXTV2oDvtfas0fuiKjy0owqPvNSD1ustXLh3Qbu8sop4YN24c/vznP+GWWz6BZcuWYs+evXj22WdQVNTzmU6GHEqTC13J0psOyPk5UO/ZEucOViz36gpVBXTdGuPff7QBH/nOC2gOmxcQRg/24xOXTsRNF43HgEL3OT66Y+GYgWU/qUK0F+tCXHYF79xdnhZ0/rCmHr99s67Hz9ldLWtDCltCijclmHhsKHCrONGo4WhdHE67gkEFNnxkVgHGDnRmZEHxtXOLsHSCD4UeFS67ih88dbLfX7M/nFfmwbObm9AQMlO/26Fg2QT5Onql7jOjKmbYlcWQQjvGDXZi/0nzd+xAvw3LJsr3b9AbioL0qfZMvWaO2rFjR9r7LpcLX/jCF/DAAw/g4YcfwtGjR3H06FFMmzatR8/PkENpZC/1isUNHE00HRjNpgN5TeZyNaBlJkpYYvx/fHVvMuAAwOHaAH7y2Eb81+ObsWDyEHzuysm4fO7obj2npgtE4wJP3VEOv7v7Z3qBiIFV91VB0wVSV2Ssr+x5G2KPQ2kzi9K+/KuoTaApcKvJWcO2TjebG3vGdAWDixyYNdqNpRO8GT8uDSqQ/1e9TVWwdIIPz21pBgDMK/NIN4sDANF469SsyyHfZpr3XDsYX/zTceiGwE9uGCLd+MlalixZCkVR0lqpt1i58moAZmVDfX3PLlzJf+SjPpVa6iVjyDl0urXpgKzldtQ3Wk48s7V2ordamg/0Z7laXDfQEIiivjmKusTf9Ym/GwKtb6/fc6LDj9d0A2t2HMeaHcdx3sTBeOZHV3Z7DH63igJ33639+/SSEpx66RTCMdEukHQUUlJnXZz2vjlhM4TApoMRrN0fgi7M9QzLp/kwZiCPSb1x+VQfdhyNIBoXuG6unOtABhXYoSrmDO1YCb8fyga7sPr/jc32MLImG5Eul2NkQ0N9vz4/Qw51aESJXarWsE1hHduORHDgZDR5G9fj5DdV9nK15D4/5/4EhBAIReNmWEkGlUgypHT8dwRNIe2cz91VH+6txZYDpzFr3MA+e86eWFjhxZNfGZO1128M63h5ewDH6s11L5OGOXHxZJ9Uay+symZT8c0rB2V7GL1S6LHhPz82FBsPhnH1bDmDGpEsGHIozW3LSvDGrgCWTfRleyjd8pvX67D1SPpGZR9UhTCsyI4pI3q2ZoDklmw8YIFyr+5Izq40BlDXHMW67U3YXSkS4SRi/t0msDQEoojFsz9lFYj0XWiSjRACO2uieGt3CDHd3Njz0ik+TBxmre5fhR4bjjXEUehh6MqW+eVezC/Pr7UsROdSU1ODe++9F1u2bEFzcyDtvm3btvboORlyKM2oUgc+vcS6G5J1JhRrf4K37UgUe4+fxoO3DodTptWd1E5cF9h0KIyRpQ4MP8umdKmstk+OYQis23UC+481dGt25fksjbe7hpV6sXjq0GwP46wOn9Fw5IyGwUU2jCh2wOvqm+NCKGrg1V0BVCY2Uh4zwIHLp/n6tAyvr3x8YRHWV4aweLxcF7KIrEBRlIx3AsiXdU+33347PB4vvva1r8Hr7ZuLAAw5lBOmjnAlO76kGuC3sflADvjzuga8uK0ZCoCF47y4bl4hxgw4ezmilbqraXEDq77/IjYdOJ3tofQ5u03BdUsr8NPbFvbZL+O333oD699bh6amRnzyM7dh4sRJffK8f1vfiKZwa+ot9qoYXuzA8BI7hhfbMaLEAV83g8+B2hhe3RlAOCZgtwEXTPBhxiiXZU9Mhhc7sGqu9TefJKL8smXLVlRVVcLp7LulBgw5lBOmj3Tj6U3Nabc5bGYPf6uebFiJEAICgBCJPy1vQ7S/LfX2lNuA1tIwQwAQgIHE34nb054j9TXT/hbtbttdE0l+/HsHQnjvQAiTh7lw4/wiTBvZcTmilcrVXlh/0DIBx+2woaTAhRK/K/3vAjdK/C4U+53Jt1vurzkTwPJvtZ9T+siCMfjep87DyIF9u6Hhq6tfwje++S3s2b0bj/35j/jhPT/tk+ddOsGL9yvDOBMwN5VsCBloCEWxq6Z1LV+RR02EHgdGJP7uqPtbNG7grT0h7DxmfuzQIjuumO5Hic96szdE1DdUBRBsId0vJk2ahJMnT2LUqFF99pwMOZQTxg91wa4CMV0kT7gnD3fh9V2Bs5+cI+WkuqPb0fYkHjDb+qLNSXzK7Wg9ye/oeVrf7uAkv5MA0WHYSB07zjLGNre3f2457T4exQ+fqcVdVw7EvLL2U9vJhfsWKFfri40z21IUoMjrTAkq7g6CS2qYcaOkwAWvq/uH/dICF65dUo5/rqkCAIwbXoR7bl2AZTOG9/WnBQC4/YtfxuOPPYq4Hu/Tq3rnj/Pi/HFeRDQDNQ1x1NTHUdOgoaY+jtOJ4NMYNtAYjmF3TevMcKFHTc70DC+2Q1GAd/aF0BQ2oCrAwgoP5pd5+uXfmYgoH6xcuRI33XQTPve5z2Pw4PQGI1de2f3OnQBDDuUIh01BkUfFyWY9edv2o1FsPxo9y0dRLjhWH8e8sva3t3ZXy36Mu3zuKMydMAgb953q8P7U2RXV7kAwpsLlcsDldMLtcsDrduLj5w/E0BJ38nHFfidsambWmimKgv/98lJ8ceVURGM6Zo0b2K+vHYmaP7fRSASf/fwX+vz53Q4V5YOcaW3yI5qB44ngcywRfM4EdAgATWEDTeEY9hxvDT6KAnidCqaNcKPYa0MwaqDAkx+zOOGYAU3v+c+Vw6akbeBK3cd/A8o1Dz/8MADg5z//edrtiqIw5BCtnFWIh9/t357r/UGBecLUMiVtXgxWkjMRamKH5Q5vT36s0vo8Kc+nQEl5+2y3JZ6j3ce3ee60+83boQAqzjJGBVChpNzfhbGnjlEBNlS3lhi1cNiAReO8WDm7oMOva2u5Wrf+OfqF22nHP76/AlsOnMaJ+tBZZ1fiusB9r5xBY8rakfPHeXDFjI4/z0xRVQXTxg7IyGtNmDAREyZM7JfnPt0UxY//tgPVJwK4fvEofPLiMiiKArdDRdkgZ1rr+ahm4I3dQWw+FEHcAHRDJGcGhQCCUYH1VWGsrwoDAArc5ozP8BI7RiTW+hTmWPAJxwws+0kVovGe/2C57AreubucJ9k9xH+D7FESv9My/pp5YPv2bX3+nAw5lDOWzyjABZN9qD5lXm3t7MS/45Nw8wFtT8LVxAf3Z4CgcwtGTmPNfnMne59LwcpZhbhiRgG8Z/kFbbV9cpx2G+ZPGnLOx9ltCi6c7MMziTVmigIsHs92s33l5//cjWfePwoA2HawAVPHFGPuuNIOH2sIoPKUBnfK95nTDswf60XcEImSNw2nms0Zn+aIgb0nYth7onXGx+9WMSIRfFrW+RS4VWl/9jVdIBoXeOqO8g7XKp1LIGJg1X1V0HQBTz+MLx/w34CoaxhyKKe4HSomD+e+OLnmhvlFUBRgRIkDK6YXdKkDVmsLaYuknG6YNdqNl7Y2I6abG/NaaTYgpum49RfrsLWqDpNGFuHRu5bC5bDO+M7mTFMUb20/mXbbtur6TkPOO/tCiLW5Wq4qCqaPcqVdAY/FBY43aKhpiONYYp3PqSYz+AQ6Cj4uNdnRraW7W5FHruDjd6uWbJGdT/hvkHmcyelby5evwOrVLwMAlixZ2ukx8N133+nR8zPkEJHlDS924KuXDezWx9gsVK7WXTZVwccXFuH9yjCu7qQcL1u+9Kv3sWZnLQDgw/1ncOv/rMNjdy3N8qjOLqLp+PJvPsTrW0+2u+//ntuH6pNBfPtjU9PCWkMonuyclv5cAmeCOkamze4oGDPQiTEDW0vdYnGBE41xHKvX0mZ8DAEEogb2nYhhX0rw8bmUZOAZIWnwISLqjs997rbk2//yL1/q8+dnyCGinGS1crXuGjfEhXFDXNkeRprDp4J4Y+uJtNvW7zmFYCQOn9u6v05e33Kiw4ADAHWBGP70RjWK/U5846Ot+/E4bCrsKgAFGFJox0C/DcVeGwYX2jGi+Nyfq9OuYPQAB0YPaN28NhYXONnY2tigpiGO2qY4jMT6nv0nY2n7fXmdSrKjW0u5W7GXwYeIcsMNN9yQfPvmm2/u8+e37m8lIqJesCXq1SzQXC1n/ORv29uFxrgh8M+1h/DJSyp69JyBSM96fHfn47ryPVB1IpD2vs+l4quX9W2jBaddwagBDoxKCT6abs741NRrOJbo7tYSfEKxjoNPcsaHwYcoo1RFgcjwz1ou/2y/+OKLXXocu6sREaUYVepAxWAnRpbwMNcX3tt9Ci9tONbhfX94rRKfuLi8W7+MHTYFLruCVfdV9XhMLrsCh+3cr7ls2mB4XTaEonqnj7ls1tAej6M3HDYFo0odGFWaHnxOppW6xXEyJfgcqI3hQG1r8PE4leT6npbgU+Jj8CEia7vrrm+d8zFsIU1E1IbDpuCTi4qzPYycoBsCP3x0a6f3H6hpxtpdtVgy9dzd41K98I0xPd7rw2FTUOC2dakFbqHXgesWjcKf3zzY4f0zy4qxcv6IHo2jPzhsCkaWOjCyg+DTsr6npiGOk41x6AIIxwQqazVU1mrJx3scCoa1bGCaaHJQ6rO1Cz5xQ+C5zc0ocKu4cJIP9i6Exo4cPXoEv73/VygtHYCvfu3fcN///Be8Pj+mTZuOJcsu6NkXgros9et/6WXL8YffPYyxZWWYMGESll/RsxNEai8blw1y+VJFf7SNTsWQQ0REZ/Xe7lPYfaTxrI/5yxvVXQ45fbnPR1d9+pLyTkPO926aDlW19qlEevAxG//GdYGTTekbmJ5sikM3gLAmUHVKQ9Wp1uDjdiRmfEocybbWJxvj2HgwAgA4UBvDxxcUodjb/Y5dI0eOwu1f+Bc8+cTjeOvN11FTU4PJU6ZAtbH7Vyakfv2dTifCoSBOHK/BJZdenu2hEWUNQw4REZ1VYzB2zsfsr2nq8vNlY5+PccMLMG1MEXYcSg9rK+cP77SFtNXZbWZjghElDpzXEnwMgdrGeGJ9jznjc6LRDD6RDoKPLeXLf7Qujl+/VocbFxRifC+aXmgxDWVl5bjt81/EN+74MhYtXtLj56Lu27N7F77xzX/H4CGD8fP//Bl+eM9Psz2knMEW0nJhyCEiorO6YPoQTB5VdNbZnItndn9NS6b3+bhp2Rh8+8+t5REKgH+/YWrGXj8T7KqC4SUODC9xAGUpwScx49My63OyMY64Aeht+jeENYE/rmnEsoleXD7N3+XXbWiox18f/TO2bd2CJUsvwDtvv4Hf3v8rTJ8xsy8/PepE6td/4fmL8YffPwS/34+LLrk020MjyhqGHCIiOiu/x4Gnv3cRXvrwGL724Idp9y2eMggr5o3ALRd1vXQsW266YAz+9EY19h5rBgB8bnkFhg/wZnlU/c+uJjqyFTuAMvM23RA42ajh4Xca2214CgAHTsZw+bSuv0ZxcQnu/PfvJN8/b/6C3g67Q4dOxxDTRa9mmnJR26//+YsWZ3E0RNbAkENEROfkdtpw1YKR+Pc/bEI41tql7N5Pz0bZUGttWNoZVVWx+scXo+pEAIUeOwYWubM9pKyxqQqGFDmgpQQcp13BiGI7BhXYcMlUXxZH17HqUzHc8ehxAMCPrh2MWaO7WqxI1DdYriYXhhwiIuoSp13FnTdMxf9v777jG7nL/IF/ZtTde2/r7b1nl/SQHkJI200g9Jo7SgglJDnu7ncHF8oRIHRCOzrpEEoSIKSTsr1397ruTXXK7w/J0oxs79qyLOkrf97JvmzNqHxtydI883yf5/vfv9kPXQfed/lCYQIco/qy6U/DSmcWWcItW3JwekRFfXGwjbUlhRswHOnwhb8/3O5jkENEZ8Qgh4joDDx+LeY2x0CwK9Z02hyL4v1XLMZ1W6vhC2ionAdTvdKNqulo7Q+gttAGSZKwqmr+ZrOIZoqLgYqFQQ7NCg8AKZ3Fs9VxOr3Oi3Lif2BsXOfj1ne8E9//zreQlZWF8y+8mN254uiOX3eia0hBXZENX7u1POb7GfVqZ79SHG9HE/E5IDozBjkUMx4AUrpLRqvj+cq4zsefnvw9bnvXe7Bk6TLc9elPMsiJk4NtXnQNKQCApt4AGnr8qC+2z+g+bBYJDquEGx5oiHkcDqsEW4yLjhKfA6LpYpBDMeMBIM0XiW51TAAkidM04uzhN8wtwB95Ywife0vxjO7DZZfx4r31zOAnEZ+D5GHjAbEwyKFZ4wEgEc2WcZ2PT9z5Gfzmlz9HdnY2brhpW7KHlhYOtnlx2FC4DwA7Gj0xZXNcdpknppKMzwHR2THIISKipIte5+OcLVuTOJr0E53FMW6/e4bZHKL5KhlJFSZyYsdcJRERURrzK/qELM64fS0e6Hrs056IiFIVgxwiohlqa2vFv//b5/CN+7+KkZFhfO0r9+HTd3ws2cMimpTdKuHKVVlwWM3nhJ02CdeszWbtExGlJQY5FFfGg799e/fgO9/6Bu793Kexc8fryR4aUdyMdwIDgOzsHHzmc/cmeUREZ/ahiwvw69urkWEPBjRF2Rb86iPVeNe5+UkeGZE4JAmQE/yP5yBix5ociitjG9i169Zj7br1+Ptfn0ZjYwM2bd6S7OERUQrhOh9ERDRXGOTQnHr5xRdw8OAB3HHnZ5I9FKK4MXYCe+P117B3zy4cO3YEzz/3LC6+5NJkDy/lcZ0Pmgld13Gkw4fjXZG6oqZeP/a1erCq0gmLzNcBJUYyWkiz80DsGORQXBkP/r759f/F3555Cm+74SbseON1dkuitDFZJ7AP3/7RJI5ILFzng2bi2cNj+Nbf+kzbXjvlwWunPHjP+Xm4aVNukkZGRKmMQQ7FVfTB3yc/9dkkjoaIUhXX+aDpGhhTY9o3l/wBFT5FQ7bLlpTHp+SQkIwimZk93tNP/QXPP/88WlqasW79etx1190AgKGhIfz8/36Gw4cPwePxoLS0DNu334JNmzeHb9vf348f/uB7OHz4MLKysnHTzTfjsssuj9v+RGOQQ0RE84au6/D4FGQ4eXAqikuWZ+K3rw9CUYPPn6ppsMgyJEnC5SuzEjoWVdNx10934/FXWqEDOH9FMX712fMSOgaiM8kvKMCNN92EA/v3o68/kgH1ej2oW7AAt73zXcjPz8fu3bvwwDe/gS996Suoqq4GADzwzW+gtKwMP/rxT9Ha2oL/+eIXUFFegRUrV8Zlf6Ix109ERPPC87sasPZd30LlW+/D5R//CdpOT75AJqWWomwr3rw8EwMjbjR29KOxox/tPUM4d5ELtUX2hI2j5fQYrv/CC3gsFOAAwMuHe7DzRN8Zb0cUDx6PB263O/wvEAhMer0tW7binHO2IDsnx7S9tLQM1133NhQWFkKWZWzatBkVFRU4fuI4AKCrqwtHjx7FO95xG5xOJxYvXoLzL7gQ/3juH3HZnwzM5BARUdobHPHg1n//Lbx+BQCw40gb3v/FR/HXb30gySOjM/EGNDz8ag9++1In+keV8HaPL4C1VYnJxum6jodfasZ///YgxrzKhP2tvWPYtLgwIWOh5JKT2HjgX27/sGnzzdu2Y/v2W2K+26GhIbS1taO2thYA0NLcjPz8POTl5YWvU1dXh78+80xc9icDgxwiorNgq2Px/fNASzjAGbfjSBuGx3zIyXQkaVRi8vi1hDSN+MlznfjmUx1Qpnis+37fjG/+pS3mcUyHruvo7OrGyOjYlNf5+p+78IPn4psVLM+345PXVGJdbWKn41Hq+v4PHoTLFalktNliD/KVQADf/MbX8aZzz8XChYsABKezZWZmmq6XmZkJj8cTl/3JwCCHZo0HgJQKdF3H/U/3YkejB7duycUNG2ffcYmtjtPHiNs3YZuuBzMC8znI0XUdHr+OYa+KYY+GYY+GvAwZC0vskCYpsPb4NVx4XwN8SuxBjsMq4cV7688Y6Giajvv/3A79DA/TO6IAmJhZiSfFO4aAe+oABwBOjyiQPRNfX7PR0ufD5x9qwp/uWhXX+6XZSWYLaZfLhYyMjFnfnRII4P77vwaHw4HbP3J7eLvT6YLb7TZd1+12hwOr2e5PBgY5FDMeAFIq+cUrA/jHkeDByM9fHoxLkMNWx+lDn+JoOZ1WEw+oOkY8KoY8GoY9Kka8Wvj74dBXbyD4e+gbUXHTt1sw4lURmKRB2aevKsS163ImbA+oOnyKjifuqEeWc+av61GvhhseaEBA1c/aXU8CEPtfXnzo+jS6t83RiyidXpuUGpRAAF//+v1QFAV3fe5uWA3ZoJraWvT3D2BoaAi5ucHPz6bGRtTU1MRlfzIwyKGY8QCQUsVfD47goTeGw5f9qo5hj4ocl2XW981WxxO1dA+gND8LDrs4HcqmyghIKbjSnqbrcPvGA5RIkDIUClyMQcuQRwtvc/vP/l6cnylDliQomo5B99TZ9IbTkxc1j8tyysh2zv7vayqyLOHu66rxtT+3wT9F1qgsz4ZMx9yNAQB8fgsamkahqlP/rmqLnLDH+W+hIt+OT1xVGdf7pPlBVVWoqgpNVaFrOvx+P2Qp2Pr669+4Hz6fF5+7+94J093KysqwbNlS/PY3v8b73v8BtLa04OWXX8JnP/u5uOxPBgY5NCs8AKRke+2Ue8JCgQBw6rQf62v56oynxvY+XHT7DzA06oUE4LoLV+IX/3Vrsoc1LfokOQFJtuD5Yx6U5AEXLM0IHgjEmS+gRQUowe+HDdmWybZpc5TC8AV0OG2YMN3MZgFyXBbkuGTUFtpx69bkL7D5rgtLccu5xXhiRx9++PdOdA76Tfu/8e6FCalZ+cWzufiPX+2fcv9Dn1yJ/KzEdXmj5Em9UyITPfbYo3j0kYfDl99529uxYsVKbN9+C3bu2AGbzY4PvP994f033HgjbrzxJgDAHXfciR/84Pv44Afeh6ysLNz2zneZ2j/Pdn+iMcghImH1jCj48p96Jj0gbOhhkBNPuq7jso/9CEOj3uBlAH948RC+/dDL+Pgt5yd3cNMQncnJLalB1eJN+N7zIwBG8IUbS3D+ksxJbwsE10cxZ1EMGRavihFTxkXDcGjbbGpXYiEByHbKyHHJyHFZkO2SkeO0INcV2eawSSjOtiLHKYcDG6dNmrQGJ9nsVhm3vKkYN2wuDAY7z3aic8CPC5fnYk311M9XvPgVDT9+5uSU+9fW5zPAoZSyffstU3Zde/iRx85424LCQtz7b5+fs/2JxiCHiITV2OOHf4rpkqdO+yfdTrF5budJ9A5OLMD+9sOv4GPbz0vJA2Sj8ZocR0Yuqpedg+yCctP+3+8exqnT/mDw4lVNQcywR8OoL/GNUpw2KRScWEKBSzAgyQ19Hd82fp0cl4xMhwyLnNrPRSzGg53tW4sw5FGR67Ik5DX36+ca0dJjLqa+9pxKuOwWZDgs+Ohbl875GCh1SKFpXwl+0MQ+XhphkENEwlpf48J167Px1P6RCcXTg+5pFAzTtOi6jvv+77lJ93X3j+LpV4/h6nOXJXhUM6PrQMWijSipXTHpwfGuJi92NXnn5LEtcmgqmCHDEv4atS3XENDYreIc3LS1teKH3/8OCgoKce111+O5Z/+GpsYGFJeU4s5P3xW3x5EkCXkZiTl0GXYH8K0nj5m25WXa8D/vWYvcDGZviFIdgxwiEpbNKuH2SwpxuN2Lk6FC6fJcKxRNx3XrJ3aGotg8u+MkdhxunXL/l3/+HK5601JT8KBpOobdfgyM+uD1q1hUkQubNXlNRnRdR1HVklmf/c90yKapX8GMijmbkhOaIjZ+nQx7ak4Fi6eqqmp8+CP/ikcfeQiLFy/B4sVL8Pl778K73vP+ZA8tZj986gQGRs0Z4Y+9dSkDHCJBMMghIqENutVwgGOzAN99dwWctvTp2KdpOroG3CgvyEjKgbKu6/jiT58943X2Hu/A1Xc9AocrCwOjPgyM+DA46odmKITJcFjxs8++GeevKj/DPc0dXdcx1NuGgrIFk+7Pdcm4YGlmMJsSClCyXebpYNnO9JwKNhd6e3sBXUdRUVGyhxKTrgEPfvLXU6ZtVUUZeNebJ3/90PwgJ3GdHJo5BjlEJLTdTZHVlFdVOYUOcFRNDx9Ea5qOh54/ia89sgddAx4sKMvBr+6+FHVlsWeojNmVgRHfmb+Gvu/u6cNQT/tZ7/v1fceRUVA95X63T8HnfvQqXnngxpjHPxu6DjQffAndTQdQWLEYBeX1sNoii4DWFdnx6avEPCBPBYODA/jtr3+J/fv2YtfON/DC88/hXe/9QLKHFbNvPHEUXr95yutnblwOh21uW1YTUfwwyCEioe0yBDmb6sTsptY/quDO33Ri1KfhvpvL4HWP4N9++jr2nOoNX6exaxj3P7oP3/7YBQAAr1/FwKj37MHKiA+DY5NnV6bDNzoyretpAR90TYUkT30QOORObDOIgKqjqdePpp4AhlUnAMA7Ooj24zvQcXI38ssW4Io3X4RBt4ZbtiS/ZbLI8vLycdc9ka5KGzedk8TRzM7x9mE88nKzadvKmlxct6UqSSOiVCExkyMUBjlEJCxN17GrORLkbBQ0yHli9zA6BhUAwD2/PIg3dh+cdKX3P73WhNeOdGNg1AePT0nM4GbwAatDP+PV/+XauV8vYcit4u+HR3F6WEHnoAIl3BStEJIkhbus6ZqK/o6T+Not25DlYo0FRXzlkUMT2tLfs30lZE5VJBIKgxyaV7wBDTaLxHn1aeJkd7DlLwCU5FhQXRDfVccTZWdDJFA70tg9aYADBNfs6Oib2MZ5LlmdOQh4hicuNBN9PUcWsjOcyM9yID/bYfpakO3EJesqsX7R3E8H+/EL/egbm9juWYaOwoIC9A8MQNMi+/lOQEavHe3Fs/u6TdsuXFWC81eWJGlERBQrBjk0L7T2B/D4zmHsaPRgcakd//G24rTvdjQf7Gw0Z3FEfE77RxWcDK3po+s6xoYHkjwiwGqRkJcVClSyHIBWivaOLhxraJtw3YriXLzjyvW48x0XpERGpK7Ijr6xia2gNcjYvm0bVFVFX18fenp6cLq3F13DKmodOqw88THv6bqOLz1yyLRNkoC7tyVvxXZKLZyuJhYGOZTW2gcCeGLXMF4/5QmfHT/R7ceAW0N+hgwdwRPUug7D93rkewA4w77IVz18olszfdWDXye7/hSPbbwP8/5JHtv4GNGPrQenD5nuY7KfY7Lxmu5j6sc23v/EcZ/5dzXx59cjt53mz/7yidHwcz00pqFrKICyXLGyOTsNNUUe9whUNb7T0LJcNnN2xfB93iRZl/xsB7JdtgkB45jHj4prvjDh/t9+xVr8+wcujeuYZ+OmzblYVGrH47uGo9ZO0gFIsFgsKCkpQUlJCVYC+MlLw7DIwyjLtaIiz4aKfCsq82woy7XCauHRxXzyl50d2NdgPslww5uqsaJG7HotX0DFT/96Al0DXtx28QIsqRL75yGaLgY5lLa+9bc+vGGYBmT0iV91Jng0FG+armPQHZl2dKTTh0d3DONjlxUmcVQzt8PwGp1OFqeuNAul+RmRTMskQUrwqxN5WXbYrfHpBqVPMYkuFesU1ta4UJ5nw69fHUTPSDDSKZZ78J2HXkBxURGKi4tRXFyMosJCWK1WqBrQPqCgfUABGoP3YZGA0lwrKvJtqMyzojLfhtJcK2wMfAAAo96JUwLn8nZzza9o+N9HD5u22a0yPnXD8iSNKD50XcdHv/sa/rYn+Jn3uxca8cr9V6Mox5nkkYlJBlM5ImGQQ2lrb/PkAQ6lh4AaOei2yhKcNhlra8T64FY13dQd7n/etQKPPqvh5YOdcE/RWODx/3c1SvMzEjXEMC26EjtEStEP4JIcK/710gL89eAoPH4d/W1u9PX1oa+vD0ePBVexlyQJ+35zF3rGdLQPBNAxoKBzKICACqg60DGooGNQwc7QfcqhwKcyLxT85AczPvMp8LFZJDisEm54oCHm+3BYpZh/Z029fox4NayqdMR1eupvn29C02lzvdt7L6tHVVHi/9bi6R/7usIBDhDsyvjakR5cu2Xqdu9E6YJBDqWtGzbm4LGdw4buShFLy+zB9VSk4DkSacJXybzNuD20DaZ90iT3Yb5+9H5MuU+auC3qMSAB8vjX0GDO9jMAoYXMELqN6T7Gfx5pkp9h8p99fFE0OfRLDN+H8Wef9Pdr/vkwyf1P+Ts0fP3ec3144agbAHDr1lxs25wr3MHmsS4fRkJntrOdMq5aV4y3bHgzvH4Vf3qtCb/42zHsOtETvv6l66tQkpecDnJT9R1I5TIoh1XGW9cF1xX6wSRL/ei6jrI8G2qKLeHOfKqmo2dERcdAAO2DAbQPKOgcDAY+mg50Dga7tqEpWPcjS0BpjjU4zS3fFpzqlpe+gY/LLuPFe+tNJxlmymaR4LLPfD2rIbeKL/6hB6oOfObqQqysjM9JjRFPAN968qhpW26mDR+9dklc7j9ZVE3Hlx8+MGH7itq8xA8mTbAmRywMcihtvXV9Dq5cnY3nj47hj3uGMWCY2vTxywuRl8FF3USl6Tr2t/rCl9+0MEPIg0pjV7WNda5w1z+n3YKbL1yImy9ciINN/fjnoU7kZtpx3bkLktZcYarpaqI0e9CniNKih2+RJZTlWlGWa8UGBAMfTdfRM6yGgp5gxqfDGPgMKegcUrDLEPiU5FhREZrmVplvRVmuDXarGL+rs3HZZSQj1O4ZUTAeW3UMKFhZGZ/7ffCpE+gbMa/h9NG3LEFuZvIbaczGoy834Xj7sGnbWzZXob4sO0kjIkosBjmU1uxWCVesysLFyzLx4rExvHzcjUWldgY4gmvs8WNgLFhrUZhpQV2RWM0Gxu0wdIc7p37yw8ZVdQVYVVeQqCFNScRMjtGU0+2m8QPIkoTSXCtKc63YUGsIfMYzPgMK2gcC6BxU4FeDzTu6hhR0DSnY3RwJfIqzrajMj9T5lOclPvBRNQ2H2/1YVmGHzTLzbEoyGZ+r2PNIZt0DHvz4mVOmbZWFLrz7svo4PUJyeHwK7n/M3CnOapFw17ZVSRoRUeIxyKF5wW6VcNnKLFy2MivZQ6E4MHYkE7V19JBbxbHOSDZq04LUnvs/ZSZEkLkUUx0Uxzp6WZJQmmNFaY4V62uD2zRdR++IGs72tA8G0DGowK8EA5/uYQXdw5HARwJQnGMJT3OrzLeiLM8Kh3Xugo8v/7kXTb0BFGVZ8KVtZXP2OHPB+FydZdmmafvmH47C4ze14cOnb1wOp03sE2E//etJdA+aW6nfdkk96kr5GTgbnK4mFgY5aWrMp+KpfcO4dEU28rP4NFN62WXIgGxakJwaldna1RRpa7641I78zBQ/qBI8kzP1dLX4/QCyJKEkx4qSqMCnb9QQ+AwEAx+fEpwAeHpYxelhFXsMgU9RtiU8zW28rXU8Ap/uIQVNvQEAQO+oihPdPiwudcz6fhPG9FTNPso52TGCh15sNm1bXp2D67eKXZTfP+LD9/9srjHKdFrxibeJ3SmOaKZ49JuGOgcDuPZrp+BXdXzpj914/t7FyHal+AEU0TSN+TQc7ghmQGQJWCdYR7VxOwQL1ESvyUlWkCZLEoqzrSjOtmJdTXCbpuvoDwU+7eMZn4FI4NMzoqJnRMXeltAYEQl8xut8KvKscNhmFvj8Zf+I6fKTe0bw6avECXKM3cqnmH04I1959NCE+7ln+6qUbIs+E99+8ghGPObujLdfs5Rto+OAmRyxMMhJMx6/hg/9pAX+UHWmX9Hx1P4hbN+S/Dn9RPGwt8UTPjBZXuFAllO8AF7TdexsdIcvb07xqWrAGaYHCfIBnIhMznTJkoSibCuKsq1YGxX4dAwq4eCnYzAAb2DqwKcw24JKwwKmFfnWYNfISfSMKHjtlNu07WinD8e6fFhaJk6gEy87jvfhb3u6TNvOX1GMC1eVJGlE8dFyehS/fNZcY1SS58QHr1qcpBERJQ+DnDSiaTr+7ZEONPeau8S09gWSNCKi+NsVVY8jopPd/vBCppkOGSsqU/8gM11rclKFMfBZUx08467rOvrH1GDAMxBAeygAGg98ekdU9I6o2NcauZ/CLAsqw0FPcMqb0ybj6QMjk2Y//rR3BEsFyeYYEyyzqcnRdR33PXxwwva7t6+M/U5TxP8+emhCe+87r1+BDAcP92j+4as+jXzzmR787eDIhO2H272TXJtIPLquY6dxmpegQY5xqtqGWme4dXQqE7272mRBWqqPXZIkFGZZUZhlDnwGxtRwwDNe5+MJBH++vlEVfaOqqcV6YZYFnYOTn+yaantqik93tad3dWDPqQHTtuu3VmGV4OvH7G/sx5Ovt5q2LSzPxvYL65IzoDQUXP8tsW8ceqq/UaUwBjlpYk+TGz97sW/SfQfaPFBUHVYB1xEhMmrpC6B3NNgJKS9DRn2JmOtY7GgwTFWrT/2paoD4NTmTBWmijN1IkiQUZFlRkGXF6qpI4DPo1kLT3ALhKW9ufyTwkSQJTpsUrPvRg+HCsgoH3rJGnDVTpDhkcgKKhq8+eti0zW6V8embxC7K13Ud9z00ceHPu7evhlWwVuFE8cIgJ00c7Zw6W+Px6zjZ7cOyChYdktiMraM31LogC3iQOuJVcaTD2DpajGxUWmZykjCOuSBJEvIzLcjPtGBVdOAzGMn2jAdAAVWHJAE2i4Sl5WJMVQPi00L6dy82obF7zLTt3ZcuQHVRZuwDSwHP7+/Cq0d6TNs2LynE5evLkzSi9CRJSXjPk1J/um2qYpCTJq5YnYOn9w9jt+Eg0GjEq066nUgkxnocUYKDaLubvOHaiLoiG4qzxXgbTseaHBEzOdNlCnwqg9t0Xcf9T/fiWJcfTpuEGzfmJHeQM2TK5MRw2DfqCeCBPxwzbct2WfHRa5fOdmhJpWo6vvTwxCzOPbesSevXONHZMIeZJgqzrPi/D9dieUXkrJwtND1t04IMrKwS54Cwb1TBYzuHcOq0/+xXpnnD49dwsD2ylsj4yvOiMXZVO0eQqWrAmTI5YhxEiViTE2+SJMFuDf7QdquEynxbkkc0M7PN5PzomZPoHfaZtn302qXIzxJz2uu4x19pxrG2YdO2qzdVYuOiwiSNiCg1iHEKkabFE9BxoivyBv6eC/LxL5cWwz6Hq2fHm6bp+NdfdOB4lx9ZThlP3lGb+oskUkLsb/VCCSUkl5TZkSPg2k+6rgu3Ps64qWtyEjyQGE12UCzidMd4mU13smQxZ3Jm5vSQFz96+qRpW3m+C++9rH72A0sir1/F/Y8fMm2zyBLu2rYqSSNKb8lYJgfgdLVYiXP0S2e1r8UDRYtc3lyfKVSAAwCnevw43hXM4Ix6NfSNKme5Bc0XO9OgdXRjTwB9ocYJTpsUrp8QgTbF6ouiZHK0STM5Yow9nkT+mWfTeOCBPxyF22eetv3pG5fDaRfvZInRz/52Ap395mnqb794AerLxGkoQTRXmMlJIzsaIsWUVhlYVyvOVJhxxvbALruE2iKxpxFQfOi6HlWPI95rGwB2GKaqra91haeUimCqg0pRsiGcrhY0/iNPEbOmuNiesFOdI/jdC82mbcuqcnDDudXxGFTSDIz68L0/mWuMMhwWfPL6FUkaUfqTk9B4QJcA7exXo0mIdZqfzminoS3tqmoXMuziPb3Gs/Xra8Q6CKS50z6ooGsomNXLccpYXCpm8LujIfL63izQVDUgPaeriZzViJXIP7JxOamZBGlfffQw1KgbfG7bSiHWpzqTbz95FMNu8zpHH7l6KYpzxckQE80lZnLShMev4UCb2Ge6NU03dYfbUMc3agoyZvjW17qEPDhx+yKNEwCx6nGAMzQeEKa7Wvq2kJ6J8Z9ZxJock2n+ADtP9OGZ3Z2mbecuL8LFq0vmYlQJ09Izhl8+e8q0rTjXgQ9dvSRJI5ofkrEYqNBnJpJMvFP9NKl9LZ5wUTYAbBYwyGno8WPQHUnKirqaPcVfOrSO3tvigRp6eVcX2FCeJ1ZnqylbSAvy+ctMTtD4jxxLC+Zkk2fYeEDXdXzp4UMTtt+zfZXwz/3XHjsIv2KexPTJ61cg08lz10TjGOSkibSoxzEcyDptElZUMpNDgC+g4UBrJAMiauvoNwSeqgawhXS6CAc54sU4JtMZ/1/3dGLXyX7Ttuu2VGF1Xd7cDCpBDjQN4A+vtpq2LSzPxi0XLkjSiIhSE0P+NGFce2NFpQsZDvHiV+PZ+nU1TtbjEADgQJsXfjV4RLOoxC5kS3Fd101T7jbVCxjkCF6TM9nwRZlqF1/Bn1nEGGcmLaQVVcNXHjls2mazSPjsTcvjP7AE0nUdX3po4sKfd928CjbBuqmKSEpC44F5+TYVJ/yLSAMev/lM92aBFhgcN+EgkFPVKGRXGrSObukPoHs42DjBYZWwtlrALGUa1uQIMvS4Ck/5EjDKMWYNz5bJeejFZjR0jZq2vfPNC1BdnDkXQ0uYFw9245XDp03bNi4qxJUbK5I0IqLUxUxOGtjf6kFAjbzjixjkRNfjbBRwOg/NjZ1pUI+z0zBVbU21U7j1q4Cpa3JECRRYk2MmYgtp47N1piBnzKvgG78/atqW7bLi429dOjcDSxBV0/Hlhydmce65ZfW8fi0nUrJaSFNsxPukpQmMraMtMrBOwJqFXU2RTJTTJmFlhYBnuinuOgcDaB8IZkAyHRKWlTuSPKLYvGGYTrpZwKlqwJkaD4jxCcyanKBI4wHxmKerTf0T/PiZk+gd9pm23X7NEhRki/n+Me73/2zB4ZYh07YrN1Rg85KiJI2IKLUxyEkDxgUGV1Y6kekQr2bBOFVtbbUTNus8PPqgCXZFrZskYuvoCdNJBex8CEx9UCxKoDBpJkeUNFQchX9iAaOc6TxbPUNe/PCpE6ZtZflOvP/y+rkZVIJ4/Sq+9thB0zaLLOGubauSNCKi1MfpaoLzBjTsbzEWNIs333jiavZinumm+EuHepz9rV4EQu3dy/OsqMwX8213ykyOIIHCpOvkiDH0uBK5hbTx+Zpqut23njwGt081bfvU9cvhcoj5dzfu//5+Eh39HtO2Wy9agEUVOUka0fwkQZgZugRmcoR3IKoeR8RFQBt7A+gfi3woiXowS/EVUHTsM2RARH1d7Gg0t44WZXpXtKlbSCd2HLFiTU6QwH0HzCb5ARq6RvHbF5pM25ZUZuOm82sSM6Y5Mjjqx3f/aK4xynBY8MnrVyRpRERiEPvUBmFHVD3OegHrcYxT1Zw2CSu5Pg4BONThhTcQPJKpK7KhKFvMtyvj36ioU9UA1uSITtN0yIaqaRHXyTlbC+n/fewwFNW85+5tK4Wc5mr03T8dxbA7YNr2oauWoCSPn5WJFmwhneDXk9gv36QS86iBwowHUCsqnMhyilePY5ySFOw8xb9oAnY1ij9VrX0ggI7BYOMEmwVYWyPuQYnINTmHGrqx/2TXhO1en4KX9jZh66pq2KzivXdOh67r+PxDjXhyZx8Wl7uwflGoSF3EIMdwtBcdpO0+1Y+ndnaYtm1ZWohL1pQmYmhzpq13DP/3t5OmbUU5Dnz46iVJGhGRODhdTWC+gIb9rcZ6HPHOEkfX44h6MEvxZ2odLejrwjhVbXWVEy67uG+5otbkfP/x13Deh3+AF/Y0Ttg36vHjrZ/5OW79/G/h9StJGN3cO9zuxuNv9ELRdBxpd+ONk8MAAFXHhKxHqpsqkxNcIPPQhOvfs32VMJnGqdz/2CH4Fc207Y7rVyDLZUvSiIjEwUyOwPa3euBXjPU44jUdaOoNoG80Uo8j6sEsxVfPiILmvuD0DJdNwgpBpzCapqoJeBLCSLSanICqoaXHgy/+/BVY7KHfvSRFgjIpVEIsAS8e6sWDfz6M89ctgKYHp3ZpOqDpuuF7w/ZJ94/vi3yvajp03Xyb4DaY9qt68EBd0wBVD+4fv54aup2u61AN962Frq9F3X/04/SO+Cf9/ei6js337sKnrq3Cuy4oS8yTMkumIMfwgvz73i7sONFnuu5bNldiXX1+ooY2Jw41D+KJV1tM2xaUZuHtFy1I0ohISsI6OSl+HimlMcgRmHF9HFkCNggYIBjP1jusElZViXkwS/FlnKq2tsYJmyW57/J66MBTR+RgP9jdybw9tAk6gpnWfS3e8AfisnI7Bt2q4fp66L4nu33ofvXIGWs9dKCrI3K98Q5TumH/We9zws9guN+on0EP3Q46cLLN3Nlp3J/2jeDirQFUF6TOmeXXTgzjzl+cxOCYgpyFF2A6/ae+/5IX33/pyJyPLVVIkgRvQMN9T7Tg5i3FcNlTf7qeaTHQ0FdF1fDlR8xZHJtFwl03i1+U/+WHD0w4uXDXtlWwCbiYMFEyMMgR2E7D+jjLWY9DaWRnCk1h7BwM4Kt/6UXX0MynM2W7In+T//PH3ngOK+GGBwYn3d4xoOCeR7rwiw9XQU6RtM6Dz3ZgcCw9p5/N1mQZuYCqQ4RTZNIkUc4jL7fgVOeo6Xq3XbIAtSXizWwweulgN1482G3atn5hAa7eVJmkEREQrPFI9NucWJNKUwtPBwgqeJbY0JpWwKkwuq6nRXE5xZei6tjbkjr1OIfafTEFOOlmyg9aSQoeOKfQJ3FdMTPCU4s8URKAW95UjByXGOc7jceWmg64fQq+8Xtza+UspxUff+vSxA4szjRNx30PHZiw/d5bVgtfY0SUSGK8s9EEB9q88BnqcUQMcpr7Aug11uNwEVACcKTTB7c/+NquLrChNDe506C2LspAc68fnUNK8CBLQjhjISEyR3v80GO8xejuJg88/mDB8IpKJ4qzLaEzgBJkQ1mIZPgarBkx32/kcaTI5Qm3A+RQfYkUtR+Qoi4bxyyFbz/xdoafUwIaW7145W8Tfz8lOVb8v+tLgu2JU8Rnrq1GdaEDJ7s80HUdTzx/EGOe8doUPVLPEYrOtl26GrVleZBDz60sA5bQ79siB58vSZJgkce/Sqbrhr+XAFmWor6PfB1vZWwxbLeE7nt8v2T4KpseM3hZkkJjC43ROLbIeCL3c6BlFG//1uTT8J77z3UozbXP/RMSL1EvsZ88cwqnB72mbbdfsxiFOY4EDir+fv9qCw63DJq2Xb6+HOcsLU7OgCiMNTliYZAjqJ0NY+HvZQlYXydekGOcqma3SlhVKfYHE8VHqnXby3LI+MBFBTO6TddQAE/vHwEQXL/qnmuLkekQO3G+2zE86fbt5+RicVlq/e1mOCx438Xl4cs1zl7c/d2nJ73ueWtq8fX3rUrU0BJuTU0WVlRl4HCbGzaLhMVlLoyGllwpzE6dOqrpkA1He6NuPx586oRpf0meE++/YmGihxVXXr+K+x831xjJEnDXttVJGhGRuMT+1J3HjPU4yyqcyBawHse4COiaKiccNr4cyfy6SPZUtVjtaIj8DCsrncIHOIC4LaQB4D3XbECGc/ID+nvec3FiB5Ngsizhd3eswG8+vhzP/+c6bF4UacMg0oKgTb1+/PVgpPbmL280YtRrnkb6qeuXIcMh9rnbX/7jFNp63aZtt1y4AEsqp9M+g4iMxH43mKf8ioa9zeLX45jWQeFUNQrpHAyeZg5220utDMF0GQO1zfVp8toWrIW0kcthw/UXrsBv/rrPtL20IAvnr61LzqASyGaRsX5BNoComS+CBDluv4Yv/ak3vGSC2+PFsSZzUf6iimzcfH5NMoYXN0Njfnz7SfPUQqfdgjtvEL9TXLqQICXhxI4Ab7IpSvzTi/PQwah6nE0LxAtyWvoD6B2J1ONsrGOhMAVdsyYbmQ4J7z0/H3YBW6UGVB17jCch0iSAnzKTI0KUA+Cbd74VtWV54cs2q4xH7ntH8gaUJManSxMkyrFbgjVH4xqa2ya8Hj938wpYLeK9Xxh9709HMTQWMG370FWLUZqfHu8hRInGTI6AjAsMShKwQcR6nEZzPc5qro9DIR+4qGDGNTCp5FCbF55A8ACsINOC+mKBCrvPYOruaokcRezsNgv2/eoOvLKvCS1dg7jxklVw2OffR6CImRyrRcIVq7Lwh90jGB4ZRU/fgGn/OUsKcdk6MRY0nUp7nxs/+9tJ07aCbDs+co3YneLSjZyExgO6IO+xqUjs0x7z1A5D04Fl5U7kuASsxzFMVVtd5WA9DglP03V4Axp2RE1VEyXTcTYi1+QYnbe2Dm+/ct28DHAAmKIcQWIcAMAVq7LgsgGnmtom7Lt7+0rh/86+/vgh+AKaadsn3rYC2S6xmkMQpZJ5+i4vroCim9bHEXGqmq7rKddBi2g2xnwa7vhVB5r7ArAZzjlsqE2f1/ZUReqCH1vOO8YOZSI1Hsiwy6jO9mNweMS0/ZpNFdiwUNzMLwAcbhnEY680m7bVlmTitkvqkzQiovTAIEcwB9s88AbEXh+ntT+A08OG9XEY5JDgGk770dwXnEsfiLy08Y1neuFTdFy9JjtJI4sf5xRdqzKc6TEdb94wZnIECnIUVcPfdzaYtlktEj57k/hF+V9++MCE5+Kum1cJWZOY9jhdTSj8CxLMjsaoehwBMznGqWo2C7C6mvU4JLai7MmnjHoDOn7x8sCk+0Szsr4UuVnmv1WLLOOcldVJGhHFwni8JFCMg8deacGpTnMW5x0X1WFBWVaSRhQfLx/qxgsHzJ3i1i7Ix1vOqUrSiIjSB4McwRibDiwtcyBXwHqc3U2RFapXVTnhZD0OCa4s1zrlWjjnCJhtnYzVYsHP/9+tyM4ItvV22Kx48N9uQkFOevx884VkyuSIEeZ4fAq+/sRR07ZMpxWfeNuyJI0oPjRNx5ceOjBh+723rhG+xihdSVJy/lFsOF1NIAFFx77mSJCzqT4ziaOJja7rabHYI5GRJEmoL7bhQJvPtH1NtRMfvUzsegGjSzYuRMPv78aRptNYXF3EqWoCynYGg3G7RYLNKsbR00//dgrdg17Tto9cvQhFOWKuozXuj6+34mDzoGnbpevKsXVZcXIGRJRmGOQI5FC7J9yaFhCzHqdtQEH3cGSVai4CSukiP9MKIBLk1Bfb8N83lqbdvHq7zYq1iyuSPQyK0XmLMzHk0VBfbIdDgNdm/4gPP/jLCdO24lwHPnjloiSNKD58ARVfffSgaZssAXdvW5WkERGlHwY5AoleH2ejiOvjGOpxrBZwfRxKG3VFNrx4LPi9yy7hS9vKppzCRpQsmQ4Z2zbnzvp+PH4NATX26W42iwSX/ex/H9/+4zGMeBTTtk++bRkypmiEIYpf/aMBbb1u07abL6jDkqrZPzc0dyRJSvhUQk5djJ3Y7xLzzE5D04ElZQ7kZohXj2Ocqra60jmtDzmis0nUAdeZvH1rLnY3ezAwpuLz15WgIItvr1NJheeLYufxa7jwvgb4lNifQ4dVwov31p/xeWw5PYZf/aPRtK2+LAu3XFgb8+OmgqExP771hyOmbU67BZ+6QfxOcUSphJ/CggioOvY0RYKczQJ2VZuwPg6nqlEcJOqA62ysFhnfeAencZ1NqjxfFLuAqsOn6HjijnpkOWf+HIx6NdzwQAMCqo4zfQr87+OHJwTDn9u2AlaL2M/7D/58DINjftO2D1yxCOUF4n2uzzeyFPyXUEzkxIxBjiAOtZnrcTYJWI/TMaigaygy7YCLgFI8JOqAi+KDz1f6yHLKyHbOzYyCfQ0D+OPr7aZtmxYX4Ir15XPyeInS2e/GT/5qrjHKz7Lj9reI3SmOKBUxyBGEcaoaIGY9jnGqmtUCrOX6OBRHc3nARfHH54umous6vvTIoQnb79m2Uvj6hPsfPwxfQDNt+8TbliMnw5akEdFMSEh8YmWmj/f0U3/B888/j5aWZqxbvx533XV3eJ/b7caPHvwhdu/eBbvdjiuvuho337wtYfsTjUGOIHY2mOtx8jLFe+qMi4CuYj0OERFN4vn93XjtaK9p21Uby7FxcWGSRhQfR1uH8NjLTaZtNcWZeOebFyZnQJSW8gsKcONNN+HA/v3o6+8z7fvpT3+C0dFRfO/7P8TQ0BC+8N//heLiYlx00cUJ2Z9oPMoUQEDVsduwPo6IraMBc2c1TlUjIqJoqqbjy48cNm2zyBI+e5P4RflffuQAtKhStM/evCrt2szT3PB4PHC73eF/gUBg0utt2bIV55yzBdk5OabtPp8P/3zlZdz69rcjMzMTFRUVuPrqq/GPZ59NyP5kEC8dMA8daffC4zfU4wjYdKBjIIDOQcP6OAxyiIjSRltbK374/e+goKAQV151DR59+HeQJAmXXn4lzj3v/Gnfz+P/bMGx9mHTtlsvqsXC8ux4Dzmh/nnkNJ7b12XatrouH9eeU5WkEVEsJCn4L9GPCQD/cvuHTdtv3rYd27ffMu376ehoh6IoqKtbEN5WV7cATzzxeEL2JwODHAHsaBwzXd4oYJBjnKpmlYG1NazHIaII40Hy5Vdche888HVs2LQZV7/lraiurkn28Ogsqqqq8eGP/CsefeQhvPjC83jbDTehoLAQ//n5e6Yd5Hj9Kr7++FHTtgyHBXe8TeyifE3T8aWHDkzYfu+tqyEnvFUXier7P3gQLlfkBLHNNrM6Lq/XC4fDCYslUguZkZkJj8eTkP3JwBypAIyLgC4uc4RWVheLcaraCtbj0Bxra2vFv//b5/CN+78KADh65DCuueISdHS0n+WWlCzjB8kAYLPbUVBYiNHRUVit4r3fzXfbb307XnnpRfz5j08iPy9/2rf72d9OoXPAfED0oasWoSRX7JNif97Rhv2NA6ZtF68pw7nLS5I0IoqVLElJ+QcALpcLGRkZ4X8zDXKcTif8fh9UVQ1vc7vHwoHTXO9PBh5ppjhF1bHHECCIOFUNMHdW41Q1mmvGA+bOzg48/9w/8OZLL0/yqGi6li5dhvu+cj/e+/4P4off+06yh0PTMDg4gN/++pfYteMNnDp5EkDwAOeDH/mXad1+YNSP7/35uGlbUY4DH7pyUdzHmkh+RcNXHzlo2iZJwD3bVydpRDRfVVRUwmKxoLmpKbytqakJNTU1CdmfDDxFluKOdHjh9kfaTYrYdKBjMIAOYz0OFwGlBHr6L38CAOzatQNl5RV457vfm9wB0aTGD5L379uLnTtex+uvvorOrg5c85brkj00moa8vHzcdc/nw5c3n7NlRrf/zh+PYcSjmLbd8bZlyHKJ3Vr51/84hZYe85Tzm8+rxbLq3CSNiNKdqqpQVRWaqkLXdPj9fsiSBIfDgXPPPQ8PPfRb3HHHnRgaHsLTT/0Ft9z6dgCY8/3JwCAnxRmnqgFiro9jnKpmkbk+Ds094wHznZ+5Cxs3nYPRkWG8+TJmc1JV9EHyps0zO0gmcbX2jOEXzzaYttWXZeHWC2uTNKL4GHYH8K0nj5i2OWwyPnXjyiSNiGYrmY0Hpuuxxx7Fo488HL78ztvejhUrVuL//dd/4/0f+CAefPAHuP32D8Nut+Oqq642tXee6/2JxiAnxe00NB1YVOpAQZZ4T9kuw1S1FRUOZDg4S5LmVvQBMwB85nP3Jmk0RHQmX3v8CAKqubfyXTetgE3w1so/+Msx9I/4Tdvef8ViVBSKd7KSxLF9+y1Tdl3LyMjAJz/5qSlvO9f7E028I+Z5RFF17E6HehzTz8CpakREFHSwaRB/eK3NtG3DwgJcubE8SSOKj65+D37yzAnTtrxMO/7lLUuTNCKKBxEyORQh9mmSNHe0w4sxn9j1OJ2DAbQPROZZcxFQIiICAF3X8aVHDk3Yfs/2lZAEP7L7+hOH4PWrpm0fv24ZcjPtSRoR0fzDTE4K29kYVY8jYCYnuh5nXQ2DHCKidDDq1c5+pTPc7p9HevDK4R7TvsvXl2HzksJZjy2ZjrcP45GXmkzbqooy8K5LFyZnQETzFIOcFGZsOrCwxI5CAetxjFPVVlQ4kMl6HJojsz3gosTi8yUum0WCwyrhhgcazn7lKdgtwDd/by7Kt8gSPrdN/KL8rzx8AJq5xAifvXkVHDbL5DcgYcjgFCiRiHfUPE+omo7dTZEgZ1N9ZhJHE7vdTd7w95yqRnMhHgdcDqsEm0Xs6TGi4PMlPpddxov31k9oFjATf36jDff837Bp2/YLarGoPHu2w0uq14/24O97O03bVtXm4bot1UkaEdH8xSAnRR3t9GLUUI8jYtOBrqEAWvsD4csMcmguxOOAy2aR4LLz/Fwi8PlKDy67jFjf0b0BFd9+8mjU/Vlw5/XLpnl7DU5b6j3/uq7jvof2T9h+zy2rIcsMytMBGw+IhUFOitoZtT6OiEHOLkMWh/U4NJdmc8BFiZes58uvaPjeU0042eXGbRdW4k1L85MwCvr53xvQ0e8xbfvQVYtQknf2NdT+fmgUj+8cxrXrsnHN2tTK+vxlRzv2NgyYtl20uhTnryxN0oiI5rfUOxVCAMz1OPUldhRlixePGpsOLCt3IMvJlxull4Cq40S3b1ZZCUqcnz3biu8+1Yxn9vTg/d/eh/5R/9lvRHE1OOrHd/903LStMNuOD1+1aFq3P9DmhQ5gb4v3rNdNJL+i4auPHjRtkyTg7u2rkzQiIuJRZwqaUI8jYBYHAHYaFgHdxKlqlIYe3zmMb/+tH0/uGT77lSnp9jRGnidF07G3kc9bon33T8cx7A6Ytt3xtmXIctmmdfvxmTs6UuvEwm+ea0BT96hp243n1mJFTV5yBkRzQpKkpPyj2IiXHpgHjnV6MeI1ro8jXtOB08OKuR6Hi4BSGuoeDq4B1TWknOWalAqiyyICSmodKCeC26fii0/2QpaAf39bMRwJrG1p7R3Dz581N5yoK8nE2y+qm/Z9jB/v6Sn01I14AvjWH8yd4hw2GZ++SfxOcUQiYyYnBe1Ii3qcSBZHloD1rMehKYx4VXh8YrYFllPwgIumZomKctToPr/zwCM7htE/pqJ3VMXjuxKbyfr640fgV8x/65+9eQVs1ukfioyf1U6lp+7Bp46jb8Rn2vbeyxehslC8z246s/HGA4n+R7FhkJOCjIuA1hWLWY9jnKrGehyaSmOPD59/7DTufawbg2Pq2W+QYsY/e1LpgGuudQ/58O+/PYaf/qM12UOZMWtU2+mAKmZwHStvQMPu5kgtyxunPPAGEvM7ONg8iN+/1mbatrY+H9dsqpjR/aTaiYXuQQ9+9JS5xig304aPXju9TnFENHfEO3pOc6qmY5chyNksYBYHMC8CuolT1WgKf9obnMOu6cCf943gtnPzkjugGRo/q5wqB1xzzRdQcfn/ex0ef/DAeG/DML71QXGm5Ngs5pMtyjxrGPHC0TH4ApGf2RPQ8dyRMVy9Zu67lH3lkUMT/k7u3b5yxvUGqTZd7ZtPHIbHbz5B89FrlyE3056kEdFckqWJ017nHDM5MePp9RRzvMsXVY8jXpBzelhBSx/Xx6EzOz2s4NTpSHer3c0eDHvEyuZEziqnyBHXHPvF8+3hAAcAntnbg74RcTqUzefpan5Fw98PjU3Y/reDo6bndC68dOg0XjrUY9p22boybFlaNOP7SqXGAyc6hvG7FxpN2yoLM/Cey6bXKY6I5haDnBSTHuvjRNfjnH3tA5p//n5o1HSYomjA3w6NTnn9VDR+Vnk+HCurmo5fv9hh2qbpwA+eaUnSiGZu4nS1efDEhRzt9JtOoI1z+3UcavdNcov40DQdX3r4kGmbLAGfu3lFTPcnj9fkpMBMw68+cnDC3/5nbloJp92SnAERkQmDnBSzozFypq2uyI7inOm11UwlxiBnabkD2S6+4ZNZ/5iKHY2eCdtfOeEWKpsTnjqT3GEkxDN7etDeP3Ftkl+/1I6OSbanIlOQI8n4xYvdOP/fd+LbT4lXXzRTtYU2VORZYazxt1sl1BTasLh07qZW/eG1NhxuGTJt235BLRZX5sR0f6nyN7fjeC/+utsc9K+oycX1b6pJ0ogoIZLRdIDT1WLGmpwUokXV42wScKoaYA5yOFWNJtM7okya/VA1YGBMRY4ggbEEHQFVR9dgAANjKvIzxRj3TOm6ju8/0zzpvoCi47tPNeN/blua4FHNnNUiAZIM2WKFJMto7g1mML77TBuu21SE2uLUeL/SdR2aHsye6aGvmh7cHt6m69C00DY9+Pmh6YAW2q7pxtsEL1+/3oW2AQVP7g2+R1+w2I7qfCsOtY6Er7u8KhNF2fEJerwBFV97/LBpm9NuwZ3Xx16UnwqNB3Rdx//8bv+E7fdsXw054QUbRDQVBjkp5ES3D8OeSA5exKlqPSMKmnoj9ThcBJQms7jUjm2bc3DqtD/c7WlLvQtLyx2oKUz97KWu69jX6sXeFh/cfg1uP/DwG0P4yCUFyR7anNh5aghH2yfWc4x77LVO3H3jQmS7Uvcj5cXDA3h8Rz8stskP4O/5zUkUZNlMwYUxYFCjAorxQCMShJgDEi36qyn4CH4/fvvox5lLuZkOrF9cBgB44C+t6B0yZ1QlCfjeB5fhkpX5s36sXz7bgPY+8/1/4IqFKM2P/XMhMkU0eVHO07s6sOdUv2nbBStLcOHqsiSNiBJFCv2X6Mek2KTuJ9I8lG7r40gSsKGW9Tg0kSRJOH9JJsrzbOEgZ+vCDNSXpH5HopeOjeGJ3cPoGzVPqzt52oe/7B8BQmfEdYSm1OiRmh0dwTPQOnSE/g9djpyZDt82dDl82/BlPXzZeHuE7td82bhfn+LxIreb6vGOtw2e8XeiasAXft+JnEwHFhTbceuW3AlF/sk04gng9h8dPWPt1O5GserBYmWMDSY7eNJ14PdvnJ51kDM05sd3/mRurVyQZcdHrl48q/tNdkfDgKLhKw8fmLD97ltWJ2E0RHQmDHJSyI6GyJnS2kI7SnNT/4x2NFM9ThnrcejMjMfByZ5jPx3NvX78+MWBSfedHlbx0OtDk+4TnaLaYbdZ4Q8ok+4vys9C96iE7lE/TnT7sbHOhWXljgSPcmrt/f550RxiOkxdyaaIQzcsiK1exuh7fz6OobGAadvHr1uKnIzZfa4le7ra715oRGO3OSC+/k01WFU7+8wXEcUXg5wUEazHMawtI2o9TqOxHodZHDoz4xIZIrRhdtlTJzsx1ySECl8BWGwWnLOyFgMjbhw61Rm+jsUiY8uKGmS4ggeukgQsKLJjQXFqnaBZVpmJ2mInmnvi2yBBkgCLJAW/yhJkKZhpsMiRr7IkQR7/KgGy8XpT7DPdZpL9FlmCJBm/j4xDliVYJPPjS4brKbqM06HzaZeszEeuM880ptU1Wbhoed6sfi/tfW787G8Npm01xRm47ZIFs7pfILkdDUc9AXzz9+YaI7tVxmduEmetKJqdZKyTo8+fj524Y5CTIk50+zBk6Col4lS13hEFjcZ6HAF/BkosY5Ajwpn2khwb/uuGEjzyxhAOdfhMZ5OrC2x417l5ka44oe3Bn1EKfzCO75PClyVTQAHJGGBIUZcNtwvdmWy4bH5sacJYZGn8/qWoy8bbT/2J6guoWPXJSJCTYZfw89vrZvAbTJ6n712HT/70KJ7e1w9JnthY9L63L8R5S3NDB/xRQYdsDijG9890IctU0Nzrx5f+1AsAeMuGImxZGP/36a8/cQR+xVxc9NmbVsBunX1D1/F7SMY6OT96+jh6h83ttt992UJUF2cmfCxEdHYMclLEhPVxBMzk7G5mPQ7NjGw4SBQgkQMg2Nr9s9cUo3tYwTef6UXHYHAK16ISO5am0BStuWC1mA9SFYHWmQlmKTLxl11dpg5rAJCbYcWV6wqR6Uj/6bVz/Td3uGUIj//T3JJ77YI8vGVzZVzuXwpF9Yk+KXJ60IsHnzLXGOVk2PDxty5P7EAoqcJtnRP8mBQbBjkpYqehdXR1gQ1lAtbj7DRMVVtSahemDTAlj/G9W5zD5aDSHCtWVTox4nEj0ynjtnPzkj2kORc9TUMRIf1mEF4nR9egKX5cvbEEF64swkUr8udFgAPMffb0K48emhA83b19ZdxaK4czOQl+6T3w+8Nw+8zNRj567TLkZaV+sxSi+YpBTgrQNN0U5GwWMIsDADsNTQc2LWDraDo70wGXYAfMAMI1EBl2GTZL+p9ukyQJNouEQCiDI1ImBwBsUZmovAwrbt5amqTRJMdc1sG9crgHLxw4bdp2yZpSvGlZcdweI7wYaAJfeqc6R/DbFxpN28oLXHjv5YsSNwgimjEGOSng5GkfBt2Gepx68eb39o8qaOyJ1ONwEVCaDtG6q0VLdqenZLDIkSBHD60DI8oCiJaoQFQVMLCeLeNTFc8leTRNx5cePjjhse7eFt+i/GQ0HvjKIwcmvFY+c9NKOO3zI/tHEZyuJpbZVwHSrEXX42wWsGB/V1Oka1GwHodBDp2d+axy8sYRq8iaHQIOPkbWqEAhIFA2R+Sxx4s0RzU5f3y9DQebzS3UbzqvBkurZt+O2khO8N/czhO9eGZXh2nbsqpc3HBubUIen4hix0xOCjBOVasqsKEsT8B6HMNUtcWlduRm8AwXnZ3xgEvEk+rhs8rJHUZCRU/LU1QNDpsY58usURkndV4GOZHv4/U35wuo+N/Hj5i2OWwyPnVD/IvyE5nJ0XUd9/1u4sKf99yyOqUWu6XEkSAlvKviZIv20vSI8cmUxnQ9PepxjIuAcqoaTZc8h/UBiTBfp6sZiTTlKzqTI1pNUTzIc5A9/dVzjWjrNc9IeP/lC1FeEP/PgvDfXNzveaK/7u7ArpN9pm3nrijGRavnVx0XkaiYyUmyU6f9GBgTe32c/lEFp077w5c3McihaRK5uxoQGf98CnKi20iLNOVrQpAjUIAWL6a/uTi8cIfcfnz7yWOmbXmZNtz+lsWzvu/JGP/mdF2fs7PqiqrhK48cnLD93u1rhFwfieJDRuKzA/PvXSp+mMlJsh0NY6bLmxaI13RgV7N5FfENDHJomszd1ZI3jliNH+zMp2NlkbMh0dPVFFXAF90syXGervaDP5/A4FjAtO3j1y1FbsbctFY21fHNySMEPfRiE051jpi2Xbe1GqsX5M/hoxJRPDHISbIdhqYDlfk2VOSLV4+zK6oeJ4/1ODRNpoUJkziOWEWmq4k4+thEBzliTVcTdzHTeIln44GOPjd++rdTpm1VRRl45yULZnfHZ5CIBYTHvAq+8cRh0zabRcJnb141Nw9IRHOC09WSSNd17DLU42wStR6nkfU4FBvxu6sFv4o49lhFZ0NEmq4WXU80H6erxbNt+zd+fxS+gDkb9tmbVsBhm7sTXdGNE+bikX789HH0DJlnKLz70oWoKRZvpgXFF1tIi4WZnCRqOO1Hv6EeR8TW0QNjKk4a63G4CCjNgPmARbwDzvnYXU3kTM7EznDijD1e4rUAb2PXKB59pcW0bXVdHt56TmXM9zkdc92spHfYix8+ddy0Ldtlxceui3+nOCKaW8zkJNGEehwBMzm7mz2my1wfh2ZiLjo9JdJ87K42sSZHnBAvejFQkcYeL/HK5LxxvHfC6/6ebSvnfGHYuc7+PvD7IxjzKqZt/3rtMhRkO+L/YCQcZnLEwkxOEhlbR1fk2VCZPzeFmnNpp2Gq2qISO/IzWY9D02fs/y9inDA+/vlVk8PuaiKL19pUK2ryTJcvW1eGc1cUx36H0zSXa2s1do3gN883mLaV5bvw/ivmplMcEc0tZnKSRNd17EiHehzj+jicqkYzNBcLEyZSIhcmTBUTFtQU6Ie3sfFAVAvp2O9ndV0evvnhjXj4pWYsLM/GvdtXznps0xHPmqJoX3304ITXxKdvXAmnnSfviETEICdJGnv86B811OMIGOQMulWc6I7U47DpAM2UHKf6gGSZl40HBK5rmbCQqUBjjxfZEOfNNgN5/Zuqcf2bqmc5opmZq+lqu0/24S872k3bllbl4Kbza+P3ICQ8WZJMHf4SQed8tZhxulqSGKeqAWIuArq7yVyPs7HWmaSRkKhEf+9mTY7Y09VEGnu8xCuTkyzG8cerWYmu6/jSQwcmbP/cttUTAmMiEgczOUliXB+nPM+KSgHXx9lpCHIWlthRkMWXE82M+NPVQjU5mNvV11OJyNmQCd3VRHzRzdJc1rQkwlysk/P3PZ1443ivadvWZcV489qy+DwApQ02HhALMzlJoOu6qbPa5gWZQh4cmepxOFWNYpCIhf3mUqJWX08lE9swi9OhTOQALV5E72gY7xMjiqrhy49MzOLce8tqIT+XiSiCQU4SNPX60WeoxxGx6cBQVD3OJgY5FAPT1JmkjSJ2xjdQEQ8YYxHdXU2kbIjI7a/jxRQkCPhXF+8g7ZGXmnGyY8S07a1bqrC2vmD2d05EScX5RUlgnKoGiBnk7G72mD5gNtaxHodmLl0WAwXmbvX1VBOdDRGp8cCE7moCBWjxMtfrzMw18/hn9wO4fQq+/sQh0zabRcJnb1o1q/ul9MXpamJhJicJdhqCnLJcK6oErMcxTlVbUGxjPQ7FRPypM2JPt4vFxOlq4vzgIgdo8SILXpMTz5qinzxzAqcHvaZtt715IWpLs2Z3x0SUEnhkmmC6rps6q21akCHkvF/jIqCcqkaxEj1IkCecVRbvb3mmJgQKAh0pi9z+Op4kKfj3Jv7fXOz30zfsww/+fMy0LctpxSeuWx77nVLak5H47ICAf6Ypg0FOgjX3+tEzooQvb67PTOJoYjPsUXHcWI/DRUBpFsYPuAQ6Vg4TvTtcLEQOFCaMfb48aVEkBA+cRJ8iOtPRdw948NO/noCq6ega9GLUq5j23/6WpSjMccx+kESUEhjkJNiOqPVxRFwEdHez13QGbUMtgxyKnSwBqj77+fXJwO5qYhXvixygxZMsBYNyAf/kYl4nR9d13PbVl3CiY3jS/aV5TnzwysWzHB2lO0mSEj77RsTZPqmCNTkJZmw6UJJjRVWBePU4xul2C4psKMpmrEyxG3/7FvB4a152V7MInA2xRreQ1nQhg+vZaOkLhIM9EX/0WNvOn+ocmTLAAYCPXLMULgc/y4jSCYOcBNJ1HbsMAcLmejHrcXY1RQo1N3KqGs3S+J+AQMfKYeYiaAF/gBhY5agOZQJlQyRJErqmaLYUVcePXuiH0y4jxyXj9IgCX0CcTBwQ+xTRYXfgjPt/9tcT6Or3nPE6RCQWnrZIoJa+AE4PG+txxJuqNuJRcazLF77MRUBptoJnZnUhzyqL3o43FlaLhIIcFzJcdnT1jkAVLEiwWiTTmBVVh02w3t+6rkPVg5koVYt8VaIuq5oOJXxZh9evIxBaok2WJXQPq/jiH3uwuNSBW87JgcOW+uc9Y2084A2oZ9zf2uvGY68046NvXRbjyGheSEIL6XnQz2bOMMhJoB0NY6bLmxaI13Qguh6HQQ7N1vgHhojThkRvgR0LWZawfmklZFnG4uoitAxKGPNpyHSk/gEyEAxyfIaT+sZMlKbr0CYEB9HBg3nf5AFF9G1ncpszXFcNXY7jay2gAoc7fPjTvhHctCk3fnc8R2I9seD1nznIAYAMJw+JiNIJ/6ITyFjLUpJjRU2hgPU4hvVx6opsKGY9Ds2SCNPVNF3H0U4fekfMB0pNvf7wNLVXT7qRIciB/mwM+SyQQ1PWrBYLukeBex7pwspKJ959Xh5c9tT5HTx3ZAwnun2mgOKCdXXQIUGWJMiyhK893Q9NDwYSqfwanEsWCVhTLcaCzrFOEXX7zhzkbF5SiLdftCDmcdH8wMVAxcIj1ATRdd3UdEDU9XGMi4Ayi0PxIIczOckdx5kcavfh+//oP+N1ntw7kqDRJNvEjw1FA/a1evG9f/Th01cVJ2FME/kUDX89ODqhoUWmyxF1vfi88CxScA0hixz5ao26bPxqHf9qmXpfZPtk28z3bzVcd+r7AT7/2OlwMCdLwJWrs3DuoowJXfNS0elhBR0DkTTciS4/HDYZZblnP5Q5NUXTAVkCPnbdcnziuuWwWVMnQCei2WOQkyCtUfU4m0Stx+lkPQ7FlxRatSOFYxwUZFrgtEnwBlJ5lMlXnps62WmHVcb2c3LQ1BuA16/isVc7oWg6NE0PTUvToWla+Ptbz6/AOYvzJglOpg5YrJbQZSk127xquo7TwyryMuRwELOy0oH9rV74AjqWVzhw0VIxpk0f7/LhG8/0mbY9tmsYj+8axr9dV4zK/DO/9rIzJu6vKHThu/+6FRsWFcZ1rESUGhjkJMjO6PVxFogX5Oxp8ZqmczDIoXgQYbpaZb4NX7q5FKM+cyeqg+1ePPpG8AzxJ64oREGmYBXsMfjNy104ctp8xntRiR1Xrc7CisrUmvK0vtaF9bUudPZ78R+/7D7jdctyKoWZsjVde1u8ePFY8LOnINOC8jwrFhbbcKDNC29AN9WUpTr/FBk3HdPLAr/zknp8749H0TMcPFF3ztIi/N+nzkcm63BoBmQJCf+7EenvNNXwrztBjE0HirOtqC2yJ3E0sTFOVasptKEkhy8fmj1ZkMYDDpsc7j7lV3Q8fWAEp077w2fw/3pgFPWhg/1UPKsfL7lOCR5fAC6HDb2DY1hRZsGnrqpI9rDOqCzfgfULcrCncfIpS9kuKy5amX5n840z0PrHVPSPBetSSrKtGBzzp/QU0WgrKhwoz7Wic0gxbV9SZp/WenN2mwVvPHAt/rG/E1VFGVhWlTdHIyWiVMGj1ATQdR07DJmcTYKuj7OzMRLkbGIWh+JEEqAmJ9rBNi/+fsjcLfFYlx/HuvxYU+0869QZkdmtEl470AyrRYbXr2BVWWWyh3RWkiTh02+rxzu/uXfS/e+8qBLZLvE/DhVVR9eQgvaBANoGzPUrRv5Qe7ZUzp5Gk2UJ167Lxo9eGDBtv3pN9ozu47J1qR2QU2qTQv8l+jEpNuK/qwugbSCAbsPZp00CTlUb8ao4aqjH2cRFQClOxt/ARTrgqim0QZYmjjnbKad9x0GLLEFRNShqcOqeKOvkbFmSj/OW5eOVo+aDZLtVxnsuqUrSqGYnoOjoDAc1AXQNKVCj1vYMVryFvpeAS5dn4nevDQEQ68QCAKyrdaIwy4K+0WBGqjzPiqVl4s2KIKLESO9P4xSxs8FcjyNikLOX9Tg0R0LdiIU64CrKtuKcehdeO2VeIf3NyzNht6b3WbfoLlxKPBdtmWN3XlePV47uMm27Yl0RCrPFOFD2KRo6BhS0DwbQ3q+ge1iZEGgXZFpQmW9FZb4NVflWvHDMjRPdfjisEt6yNhs1hTZIUjDImUkL5lQgSxIuX5mJ370enHZ46YpMIWdFEFFiMMhJAGPr6KJsCxYUi/GBarTLMFWtuoD1OBQ/44coqd1fbaKrVmfhjQZP+CDTZZNw/hLxTmDMlDUqyAlEpw5S2Nq6HNQWu9DcE3k/++RbU3dtFG9AQ/tAMFPTPhDA6WF1wl9JUZYFVQW2YGCTZ5uwVtOWehccVgkb6lzhxhjhOrgE/AzxdtGyLAx5NEgAzlssRmc4Sh9cJ0csPFKdY7quY2djZO7+pgVinnkyLgLKqWoUTyJ0V5tMQZYVyyscONQenMa5aYEr3JggnVmiWv2IMl1t3K8+uQ4f/O5+9I368dGr61BbnDqBqduvhQIaBW0DgQmLz0oASnMsqMy3hf5Z4TzLa64o24rLVmaZ7yf0RydYIifsuvU5yR4CEQmAQc4cax8IoHMwUo+zWcD1cUa9mqkeh1PVKJ5EWAx0KjduzMbRTh8ssoRr1mad/QZpwGYxH1SLNF0NAMrynfjT589J9jAAAGM+DW39wXqa9gEl3P1snCwBpTnW8PSzinwrHHFYsNJpC/7RpfvUSqJ4YwtpsTDImWM70qIex2MqZt1Yl15rSVByiXxWuTjHhq+/vQxAai4GOReip6spgmVykmnYo4azNO0DAQy6zVP9LDJQlmtFVShLU55rg20OApHr1mfj+aNjuGLV/AjMiWh+YpAzx4yLgBZmCVqP02SuxylLoVXNSXzjh3CiFUGPmy/BzTiLwI0HEknXdQx5gtPP2vqDgc2I1xzUWGWgPC/YIKAy34ayXOuEIHIurKh0ptzCrUQiEKUmp7+vDz/+yY9w9MgRSJKElatW4YMf+BBycnOhKAp+/n8/w8svvwRAwgUXXID3vPd9sFiCNXuz3Z9KGOTMMWNntU0LxFwfxxjkcKoaxVt9iR2dQ4qQJwDmo5pC88Fxeb4jSSNJLbquY2BMRdtApKXzmM8cANotEsrzrOFGAaU51gk1TkREs/Xjn/wIAPC97/0AOoBvPfBN/PRnP8EnP/kpPP7Yozh69Ci+/o0HAAD3/c8X8cTjj+HmbdsBYNb7UwmDnDnUPuBHx2BkMbbN9eJ1ghnzaTjcYazH4dk/iq9tm3Nw2cqscOcnSm21JRn4wKVV+MmzbVhQ4sJ7LhZzjZnZ0nUdvaNqOFPTPhCAJ2AOahxWydDO2YbibAvkNAlqPH4NgVlk8WwWCS57+jfqIIoXj8e8ZIHNZoPNNvnMmtPd3bj++hvhdAVPTJ973nn4/ROPAwCee+4feM973of8/HwAwI033YRf/uLn4SBltvtTCYOcOZQe6+NE1+Mwk0PxJUkSAxzB3H3jItx1/cK0OWCfDk3T0TOqot3QKMCnmA/yXTYp3PWsqsCGoiyLkNn7s/H4NVx4X8OEn38mHFYJL95bz0CHhCJJUsL/pscf719u/7Bp+83btmP79lsmvc21174Vr776T2zYsAE6gFdefhkbN27C6Ogo+vr6UFdXF75uXV0dent74R4bg6brs9qfkZlaJ/MZ5MyhHYZ6nIJMC+pLxJuOY5yqVpVvRXke63GICGkf4KiajtPDSnj6WceAAn9U5iLTIYWzNJX5VhRkpmdQEy2g6vApOp64ox5ZzpkHKaNeDTc80ICAqoOnzYim5/s/eBAuV+QvZqosDgAsXbYMzz77d7zvfe8BACxZsgTX33Aj3O7gcakxGMnMCH7v8Xqhh2pjY93PIGceMdXj1ItZj7OzkfU4lPo4dUZMqfS8KaqOriEF7YMBtPcr6BgMQIla5zTbKYebBFQV2JDrkoV8X4+XLKeMbCezsDR/SIg0y0nkYwKAy+VCRsbZZwRpmoYvfuG/8aY3nYvP//t/AgAeefgh/M8X/xv33Pt5AIDb7UZOTk74ewBwOZ3hBkCx7k81DHLmSEeoReg4EaequaPrcbgIKKUgTp0RU7Kft4Cqo3Mw0iSga0gxTc0FgLwMObzwZlW+FTkuHtATUWobHR1FT08Prr7mLXA4go1hrrr6Gjz55B+gaRoKCwvR1NSIsrLg8gdNTU0oLCwKZ2Fmuz+VMMiZIzsbx0yXRWw6sK/Vy3ocSnmcOiOmRD9vfkVHx2ConqZfQfewguglfgoyLYZGAVZkMUtBRILJyclBWVkZnnn6qXAzgGeefgqFhYXIycnBxRdfgicefwzLli4DADzxxGO49NJLw7ef7f5UwiBnjhgXAc3PtGChgPU4xqlqFXlWVLAeh1IYp86Iaa6eN29AQ4dh4c3Twyqic0ZFWZZgO+e8YGCT4WAmj4imJkvBf4l+zJm666678fOf/wy3f+RD0HUddXULcNfn7gYA3HTzNoyMjuLOO+8AAFxwwYW44cabwred7f5UwiBnjhgXARV1fZydhqYDmzhVjYhSXP+Yiv2tXrQNBNA7opr2SQBKciyhJgHBRgFOG4OaeHrpxeexb+8eNDY04P0f/DCeeOwR6LqOW97xTixZsjTZwyOaN6qqq/Fvn/+PSfdZrVZ88IMfwgc/+KE52Z9KGOTMgc7BANr6xa7H8fg1HG73hi9zqhoRpbpnD4+ifUABEDz7WZJjDTcKqMi3wmFlUDOXLrjwYlxw4cX42U8exH/829345W8ehqIq+Ob9/4v/+K8vJnt4RLMmScF/iX5Mig2DnDkQvT7O5nrxgpx9LV5TZ6FNDHKIKMWdtzgDbf0BlOVaUZ5rg83Ko4NE+8MTj8FisWLlqtXJHgoRzXMMcuaAselAXoYFC0scSRxNbIxT1crzrKjIZz0OiSV66szLL72A9rY23Pau92DpsuXJHh5Nwvicbdy0Gf39fWhsaMDH77gTdQvqz3r7ijwbaweT6OGHfoPHHn4Il15+BW55+234xv1fBQDcetu7kjwyIpqPGOTMAWPTgU0LMoRcNM+4CCizOCQi49SZkZERlJdX4LVX/wmrlW97qcr4nNUvXIR3vPPd+NlPHkRXV9e0ghxKru23vAPbb3lH+DKzOZRuJElKeI21iDXdqYKf9nHWNRRAq7EeR8Cpah6/hoOsx6E0MD51ZuubzgUA1C9chP379mLhosVJHhlNxficRT9/RERE08UqzDiLrscRsenAvlYvFENjInZWIxE9/NBv8Jtf/QJerwc/+uH38N1vfRO/+sXPGOCkMONzdv9XvxT+/sjhQ3F9nIExFd/9ex9eOeE++5WJiELGW0gn+h/FhpmcODO2js51WbC4VLx6HONUtbJcKyry+DIh8URPnaHUl6jnrH0ggAG3hgNtXpy3WLwTUUREdHbM5MTZjoZI04FN9YLW4xgWAd1Y5+J8UCJKK45Q1zVfIHp5UCIiShc8RR9H3UMBtPSJvz7OAUM9DqeqEVG6cdiCQY43oJ3lmnQmo97Yfn+x3o4o2SQkYZ2cxD5cWmGQE0fGqWqAmOvjHGiLqsdh0wGisxp0qzje5cO6GhfsXJsl5Y0vChpQAU3Thcy4J5PNIsFhlXDDAw0x34fDKsFm4e+diOYOg5w4MraOznHJQtbj7DRMVSvNsaIyny8RorN5ev8oDnf44Fd0nL8kM9nDSYh9rR7884QbN27KRWmOWO8TTlvk4Nqn6HDZebA9Ey67jBfvrUdAjX26n80iwWXnjHkSD98txCHWJ1OK22XI5GwUdH0c4yKgmxawHofEkcypM5bQsVrnoDLr+0olAUXHqE9DpkM2Zag0Xccf94wgoAIPvz6Ej19eGPNjJON5cxiCHG9Ah8se813NWy67DOb5iSiVMciJk9PDATT1+sOXNy8Q72yuN6DhYBvXxyGxpMLUmYIsCwCgb1Q9yzXFMebT8NU/98DtD56tt1mCv2sdwPJyOwKhH7V3VMXJbh8WzTBzncznzWE1ZnI0AJaYx0BE84csSZATfPI30Y+XThjkxEn0+jhC1uO0esMHLgCwsc6ZvMEQTVMqTJ0pDAU5/WMqdF1PiwyoounhAAcI1q+M/473tfrgsEV+X08fGMW/FNthmUH2OpnPmyQFAyyfosPLDmtERGmJQU6cGJsOZDtlLC4TsB7HMFWtJMeC6gJbEkdDNH3JnjpTmBV8K/UGdIz5dGQ5xQ5yvAENh9t9sFsl+JWJQUB0LNMzomJHowdbF87s5E4ynzeHLRjkjHo0+BWdDSOIiNIMg5w42RFVjzOTM5qpwrgI6Cauj0M0beOZHADoG1OQ5RSzyKOtP4DXTrqxp8U7aXADAGtrnDjR7Z+w/Vinb8ZBTjLsbPTg1VNujHiCNT2/3zMCae8IbntTLuqKxHzeiCgxJCkJLaR5KBYzBjlx0DMcQFOPoR5HwKlqvoCGA22+8GXW4xBNX4ZdhssuwePX0T+qojb2OvyE8wU07G3x4rWTbrQNmBsn1BVa0TmkwhcKeC5flYWVlQ64/RpGPBqGvRqcVgkrKh3CvGcc6/RhyG1uWqDrXBiUiCjdMMiJA2MGBBBzEdADbeYztxu5CCjRjBRmWdDWrwjTfKB9IJS1afaGgxgAcNkkbFzgwpaFLpTl2vDy8TH8YfcIzlucgctXZkKSJHz44gLsavLgyT0jcNklvG1DThJ/kpnZuigDjb1Dpm3ZThmLSpnFIaIzYyZHLAxy4mBHw1j4+2ynjKXl4hXs72qKdFUrzraghvU4lASt/X6U51phtYi3fkZhljXlgxy/omFvsxevnfKgtT9g2ldbaMPWRRlYU+001aecvyQT59RnTKhZGV9rRrTC/YUldiwutZum3G2ocwo5xZiIiKbGICcOjIuAilqPY1wEdCPrcSgJXj4+hpdPeJCXIeMjF+cL9xoszEzdNtIdAwG8dsqN3U3mrI3TJmFjXTBrU5439YmNyYrynaHuaj5Fn1VHOY9fS3iHtctXZuJktx86ggv7bahl5pqIKN0wyJml3hEFjYZ6HBGnqvkCGvYb1sfZxKlqlATjZ9YH3Rr2tfqwrkasjGhheK0cJSXaSPsVHftaPHjtlActfeasTU2hDVsXurC2xgm7Nbas2XgmR9MBv6qb1p6ZLo9fw4X3NZgCr5lyWCW8eG/9jAKdgiwrFhTb0NATQEmOBZkO8TKHRJR4nK4mFgY5s2RsHQ0AmwRsOnCw3Weqx9kkSAExpQ9vQEPPSCQD8uzhUdQW2pCfKc4ijeNBTkAFRrwaclzJGXvnYACvn/JgV5PHNJXMYZWwoc6JrQszUJE/++mopgU1AzocMXyaBFQdPkXHE3fUI8s580Bj1KvhhgcaEFD1GbeivmVLDva3+rCiQrx2/0REdHYMcmZpp6EeJ8shY5mA9TjGqWpFWRbUFLIehxLrZLcfmuFkfkAF/rh3BO98Uy5kQaZ/mtpIj6oJDXICio59rcEOac1RWZvqgmDWZl1t7FmbyTgNi4F6AzpyZnFuJMspI9uZ2KDQIstYz2lqRDQDcuhfoh+TYsMgZ5aMmZwNdWLW4xi7w21cwHocSryjXRPXXekYVNA+qAizKK3dKiHLIWPUp6FvVMWC4rl/zO4hBa+dcmNXoweeqKzN+lonti7KQGUcsjaTcdgi7xOiNR8AAE3TcbTLh0y7jFquj0NElHYY5MxC36iCU6fFXh/Hr+jY32qox+FUNUoCNarwPNclY2GJHWW5qf0WFVB1vHhsDE/vH0FA1bGs3BkOcubsMUN/s6+fcqOx15y1qcy3YuvCDKyrdZoyLXPBZpFglQFFC9b1iULXdRzu8OHp/aPoHlZgkYH/eFvJjJsXxELTdWgaoGg6VA1QQ1+DlyduU9Txy5F9iuE6wcuT3Vdonzr1vsked/y+K/JsuP3NBbBZeMKLiMSV2kcQKS66HkfEIOdgm7nbkigL+lF6uX5DNvrHVLzR4MGRTj+WlTtwyfLMZA9rSuPBzZ/3jqB/LBLQqHrwb6lvVJnqpjE7PazgtZNu7GzywOOP/M3arRLW1wSzNlUJznplOWUMusUJcPY2e/D3Q6M4baj/UjXgnyfHkGG3mA70Jw8Qpg42oq9jvP34dTVBEl5t/QGM+TTkZYhTE0eUCJIkJXy2C2fXxI5BzizsNLSOznSIuT7OTsNUtcIsC+qKxJgaROnFYZNRniejJCeAI51+U+CQao50eHH/U71QJjm2P9ntR7bTgkPtPnziVx1xeTxZAiyyBDnqg07TgwfUPgV48fgYXjw+NsU9zJ3xg/hv/73PtL0oy4IPXVxwxrbUZ/LSi89j3949aGxowE3bbsFTf/kjCgoKceen74p5rLubPPjd60OT7nvmQOJ/d7GQAFgsgFWWYJGDmTSLLMFi+Go1XZ54nfHLVov5dsZ9lfk2BjhEJDwGObNgrsdxwSpgat9Uj8P1cSjJxrupDaRwkPO3g6OTBjhAsEtcttMCWQKGPbFnOCwS4LTLcFolU+MFXdfhDejwBrQpx5AM0TU5wx4Ne5q9MQc5F1x4MS648GL87CcPQpZlfPgj/4pHH3loVmPMcEz93iYBsFqmDgjCwYDhOhOve+ZgI7zNMv1AJPq+Et2EQ9N19AyrwcyOX8PWhRMXhSWaT9hCWiwMcmLUP6rgZLcvfHlzfepOrZlKdD0Op6pRshWMBzluNSXWmpnMtnNycbLbj2HvxCgjO9QGWZIkLCqxYybHpLquI6AGF9eMDmAsUnBamsOa+KkSsSjMtuJNi2Y3ffcPTzwGi8WKrW86F60tzbMe07JyJz59VRFeODaGvS0eKIY4+qOXFaCmkM0HVE3H6WEFrf0K2voDaB9QTNOZS3OsWFrOlttEJAYGOTHa1RS1Po6Ai4AeaveazsByEVBKtvFMjqoFswG5KThlpjzPhgfeWY7DHT48sWsYJ7sjzUeuXJWFF44Fs6O3bs3DotKzHzj3jCh4/ZQHOxvdGDPU2tgswNoaF7YudKGm0CZEcBMvDz/0Gzz28EO49PIr8Nqr/8SLz/8D+/ftxa6db2DjpnNivt/SXCu2n5OLa9Zk45UTY/jnCTesFgnF2fPzo1BRdXQNKWgbCKCtX0H7QACBqCSqwyqhMt+KumIbFk/j9UyUzmQJMzp5Fa/HpNjMz3f2ONhhqMfJsMtYXiFePY5xqlpBpgULWI9DSWazSMh2yhjxaugfU1MyyAGCmZqVlU6sqHDgcIcPT+0fgaIGT3bsbfFhyKOhf1QBpjgoVFQdh9q9eO2kBydPm9tnl+VasXWhCxvqXAnp+JWKtt/yDmy/5R3hy1vfdG5c7z/LKePK1dm4fGUWNB1CTjWORUDV0TmooLU/gLb+ADoHlQlZQ5dNQlWBDVUFVlQX2FCUbZlQD0ZEJAIGOTEyBjmi1uMYFwFlPQ6livxMC0a8GgbGErPWzGyMBzsrKyMnOQqyLBjyaOidpI1074iCNxo82NHgwagvcnRptQBrq4Md0mrnWdYmmWRZSuuF9vyKjo6BAFoHgtPPugYVRHVrR6YjFNTk21BdYEVhloWvPyJKCwxyYjAwZq7H2SRg6+jxFdLHcaoapYqCTAta+gLod6du84EzKcyyoLEnEF4rR9V0HGr34bWTbpzoNmdtSnIs2LowAxvrXMhwpPPhNiWCL6ChLRTQtPYr6B5WoEcFNdlOGdUF1lC2xob8DJlBDdE0sfGAWBjkxGBX9Po4C8RrOnCow1yPw6YDlCryM4MH+wNzuKDmXCrMCr6tnh5W8NS+EbzR6MGooUmBVQbWhLI2dUXM2lDsPH5jUBNAz7CK6KV4cl0yqg3Tz3JcDGqIaH5gkBODCfU4lQLW4ximquVnWlBfzHocSg3jHdZEzOSomo4RrwpfQEOXX0PXUGRR0OJsC7YuCmZtMpm1oRiM+bRwPU1bvzLplMiCTEs4oKnKtyLblZp1bUQi4mKgYmGQEwPj+jjra12wiViPY1ofx8k/IkoZ+aFmA0NuDaqmwyJAa5mBMRWvn3JjR4PH1FraIgOrq4JZm/piZm2mMjpJO+65vJ0oRjxqsJ3zQDCw6R+b+PMWZVtQlR8KagpsDKCJiEIY5MzQ4JiC412C1+OoOva2GOpxOFWNUkhehgUSAE0HhjxaOLOTalRNx5EOH14/5cGxTp9pmlBwZXoJb9+SgzU1/Puais0SXPvnhgcaYr4Ph1US8kRTNF3XMeTRwvU0bf0BDEUtKCshWMc1Xk9TlW+dtx34iIjOhkHODEWvjyPiIqCH21mPQ6nLapGQ45Ix5Al2WEu1IGdwTMXrDcGsjfEg1CIDq6qc2LrQhSf3DGPQrWPUH10hQUYuu4wX761HILrl1wzYLJKQB/q6rmNgTEPbQCA0BU3BSFRmSpKAshxrePpZZb4VDpt4PytRupBC/xL9mBQbBjkztNNQj+OyS1ghYD2OcapaXoaM+mIu8EappSAz2Ia5f0zFwmQPBoCm6Tja6cNrpzw42ukzdawqzLJgy0IXNi9wIcsZDMiKsmwYdPvRL2jzhERy2WXMh9Msuq6jd1RFWyhL0zYQwJjPHNxZJKAszxpuFFCRZ4PdykMcIqJYMMiZoR2mepwMIadJ7G6KTFXbWOeCLEDNA80v+ZkWNPYGMDCWGkHCT14cwPGuSPtnWYpkbRaW2icslliYZcHJ00DfqBJ9VzRPaLqOnmE1FNAEAxtPwBzUWGWgIt+Kqvzg9LPyPKuQnylE84UsBf8l+jEpNgxyZmDIrZrqcTYLWo+zp8W8CChRqgl3WEuRIGd8zZuCzFDWpt6FbOfU0+gKsy2m21H6UzUdp4eVcD1N+4ACn2IOamwWoDI/0s65LNcqRGMNIiIRMciZgV1NbtM0lU0LxAtyjnT44DHUCXARUEpF+aEgJ1UyOf96aQGGPRoq8q0TsjaTKcyMdIgLqDrPzqchRdXRPayE62naBwIIRL1cHVYJlfnBhTerC6wozbEyc05ElCAMcmbAuD6OyyZhZaV4AcKuqHqchazHoRQ0nskZ8mhQVB3WJAcJOS4Lcmaw3khhVvC6OoKBWkkO32pFoOs6djZ60T2s4MrVWabgNKDq6ByMLLzZOahAiero7LJJ4a5nVQU2FOdYphUUE5EYJCn4L9GPSbHhJ+8M7GwYC3+/rjYDNgELQncaFgHdUMt6HEpNuS4ZshRsIz3oVlGULdZbVW6GBRYJUPXglDUGOalPUXU8fWAURzuDtVd1RT5kOWS0DQSzNV2DCqKbwGXYpfD6NFUFVhRlWbgWEhFRiuAn7zQNeVQcE3x9HEXVsddYj8OpapSiZFlCXoYF/WMq+sfEC3IssoT8TAt6R9VQ8wFHsodEZzDm0/DErmF0DUXmmz19YGzC9bKdcriepirfhvxMmUEN0TwiSVLC/+b5HhM7sY4ckmh3o7keZ7OA9ThHO31wG+tx2HSAUlh+poz+MTVl6nJmqiBrPMgRc/zzxZBbwU9fGoKqTdyX65LD9TRVBTbkuhjUEBGJgkHONBnrcZw2CauqxAsQjFPVcl0yFpWwHodSV0GmBacQSJkOazM1XpfTO6JgYExFpkPmmicpqHtYnTTAAYDbzs1FhoALjRLR3JCS0EKa51VixyBnmnYa1sdZW+MSsx7H0HRgA9fHoRQX6bA2xRFoilI1HS8fd+PU6WBtR3Ofgm8804fCLAvuuKIwyaOjaEvKHLhxo4TOIQW9IyraBwJw+3XIEqBGF+EQEZEwGORMw7BHxdHOyAKam+szkzia2ETX43CqGqW68Q5rA26xMjktfQE8e3hiPYc3IFawNp/Ul9hRH8ps67qOIU/wucqeQUc9IiJKLQxypmF31Po4Ii4CeqzLhzFf5IfgIqCU6sYzOSNeDX5FF2aqV0W+FXkZMgbd5qBmeQWbD4hAkoJNL4iIokmhf4l+TIoNJxtPg3GqmsMqYVWVM4mjiY2xHifHJWNxKetxKLXlOGVYQ+9QImVzHFYZN27KmbB9ZaV47xtERESiYpAzDcamA+tqXbBbxfu1GRcB5fo4JALjGXXROqzVFdlx/pJIxtdmAeqKbEkcERERzdb4YqCJ/kexEe9oPcFGvCqOdkTqcTYJ2DpaUXXsaY78DJyqRqII1+UIFuQAwJuXZ8JpC346FWdbYeGJBSIiooRhTc5Z7GlyQzPUM8UoBgAAH/FJREFU42wSsOnAsS4fRn2R+oBNXASU5khLnx+H230oybWirtCG/MzZrQA/XpcjYhtpq0XC+y/Mw0vH3LhilXjvG0RERCJjkHMWxqlqDquE1QLW4xinqmU7WY9Dc0PXdXzxyR6MGQLqTLuELKcF9SU2/MslBbBYZpY8FjmTAwBluTZsOyc32cMgIqI4kCUJcoLnjyX68dIJg5yzMAY5a2tccNjEm+G3y9B0YH2tk9NmaE7oADTNvK7ImF/HmF9B97CC6vxRvG3jxIL8MxE5k0Nn1zkYwIE2L6rybVjBxgxERBRHDHLOYNSr4ojg9TiqpmO3oR6H6+NQPCmqjpOn/djX4sH+Vi88gakXT1xSNvMM4ngmx+3X4Q1ocAp4koHM/IqO/a0evHbKg5a+AADAZZPwXzcyyCGi1JaMRgBM5MSOQc4Z7G7yRNXjiBfkHGc9DsVZ36iCfS1e7G/14mC7Fx7/mVeFt1slfPyyAiyP4Ux9pkOC3SLBr+oYGFNRnscgR1RdgwG83uDBriYPvIZg2GmTcPmqrCSOjIiI0hGDnDPY2RhZtdxulbCmWrwAwbg+TpZTxpIyLkhIMxNQdRzr9GFfqxf7WzxoG1AmvZ4sBdskN/QEwtvyMmR87i3FqCmMrQ5MkiTkZ8roHlYxMKahPC+mu6EkCSg69rd68dopN5r7AqZ91QU2bF3owtoap5Bt+YmIKLUxyDmDnYZ6nDXVYtbj7DSuj1PDehyanu4hBftaPdjX4sWRDh98yuTZmvxMC9ZWO7G2xomVlU5kOmR84Q+ncbTTh9IcK+6+thglObN7m8nPtKB7WEW/QAuCznfdQwpeP+XGrmaPKdPnsEpYX+vE1oUZqMjnukFEJBZOVxMLg5wpjHpVHDbU42wWcKqaqkWtj8OpajQFb0DDkQ4f9rd6sa/Fi+7hybM1FhlYVu7A2mon1tQ4UZVvm9Ai+pNXFuJYpw8rK51w2Wd/YiDcYW109kGOx68hoJ55et2Z2CxSXH6mdBRQdRwIZW2aes1Zm8p8K7YuzMC6GqeQJ4uIiEg8DHKmsKfZAzVSyiJkkHOi248Rb+SH4CKgNE7XdbQPKMGgptWDY50+BKaIIYqzLVhb48LaaidWVDrOWvyf7bTEtUnHeIe1Ye/sghyPX8OF9zVMmZWaDodVwov31jPQMTg9HMraNHngNmRt7FYJ62uc2LIwA1UFzNoQkfgkJCGTk9iHSysMcqawszEyVc1mkbBa9Hoch4ylrMeZ19x+DYfavdjf4sW+Vi/6psiM2CwSVlQ4sKbGiXXVTpTmWme1oOdsLSmz40SXHcvKZ/f6Dag6fIqOJ+6oR5Zz5kHKqFfDDQ80IKDqEO/dIL4UVceBNi9eP+U21WABQEVeKGtT62Q3PCIiShoGOVPY2RBpOrCmxiXkh7VxEdD1tU5YLTwfMJ/ouo7mvkC4E9qJbp8pO2lUkW8NTkGrdmFZuT2lCsEdVhk3bprZ+jpnkuWUke20xO3+5pOekWDWZmejOWtjswRrbbbUZ6CqILlBMRHRXJEhQU5wbiXWx9u5Ywceeuh36OrqREZGBm66eRuuuOJKuN1u/OjBH2L37l2w2+248qqrcfPN28K3m+3+VMIgZxJjPhWH2g31OAKuj6NpOnY3R4IcTlWbH0a8Kg62+bCvxYMDbV4MuiePapw2Casqg3U1a6qcKJ5lcwBKX4qq42C7F6+f8uDUab9pX3koa7OeWRsiopSxd88e/PjHD+Ljn7gDy5cth9vjwdDQIADgpz/9CUZHR/G97/8QQ0ND+MJ//xeKi4tx0UUXx2V/KuGRzST2RtXjiLg+zoluP4Y9XB8n3WmajoYeP/aFGgY0nPZjqoqTmkJbuBPa4lIHM3t0Rr0jCl5v8GBnowdjhrW2bBZgbY0LWxe6UF0wsfEEERHFn8fjMV222Wyw2Savd3zood/i5pu3YeXKVQCArKwsZGVlwefz4Z+vvIwvfPF/kJmZiczMTFx99dX4x7PP4qKLLp71/lTDIGcSOxrM9Tgiro9jnKqW6ZBYj5NGBt0q9rcGp6AdaPWaFns1ynTIWF3lwJpqF9ZUO8MF/ERTUVQdhzt8eO2UGye7zVmbslwrtix0YUOti40XiGheSmYL6X+5/cOm7Tdv247t22+ZcH2v14uGhgasX9+POz7xMbjdHixfvhzve/8HMDg4AEVRUFe3IHz9uroFeOKJxwEAHR3ts9qfahjkTMIY5Kyujk8b3EQzro+zrsbFs/YCU1QdJ7p94cAmuj3vOAlAfYkda6qdWFvtRH2JnesincVLLz6PfXv3oLGhAR+/4050tLfj8/fehX+8+Gqyh5ZQfaMKXj8VzNoYg2arBVhbHVzXpqaQWRsiomT5/g8ehMsVOek+VRZnbGwMuq5jx4438Pl//w9kZ2XjwR89iG9/6wFs274dDocTFkvkpGdGZmY4S+T1eme1P9UwyIni9mk43B55suLZCjdRNE3HbkOQs4n1OMLpHVHCQc3Bdq9pQUWjHJeMNdXO4L8qJ7JdzNbMxAUXXowLLrwYP/vJg+jq6kJbWwvWr9+Y7GElhKrpONwezNqciMralOaEsjZ1LmQIeJKHiGguJDOT43K5kJFx9mNSp9MJALj66mtQXFwCANi+/Rbc8YmPYbt0K/x+H1RVDQcqbvdYOHhyOp2z2p9qGORE2dvshmJaHyczeYOJ0cnTfgyxHkcofkXHsU4f9rV6sL/Vi/aByRfjlCVgcVloMc5qJ2qLbJB5dn1W/vDEY7BYrHj1ny8jMzMTx44dwXP/+DsuefNlyR7anOgfU/DGKQ92NHpM62hZZWBNdXBdm7oiZm2IiESUmZmJoqKiSffV1NTAYrGguakJ9QsXAgCamppQU1MDAKioqJzV/lTDICfKDsP6ONZQga1ojFPVMuzSrNcXobnRNRQILsbZ4sWRDt+Ui1QWZFqCU9BqnFhZ6USmg2fW4+Xhh36Dxx5+CJdefgWuuvotWL5iJY4dOZJ2AY6q6TjS4cPrp9w43mVuTlGSbcGWhRnYUOfia4uIKA1cdtnleOqpp7Bu3XpkZWXh0UcfwapVq5GRkYFzzz0PDz30W9xxx50YGh7C00/9Bbfc+nYAgMPhmNX+VMMgJ4pxEdDVVWIW2O5qZD1OKvIGNBzp8IUDm+7hybM1VhlYWu4IdUJzoTKf647Mle23vAPbb3mHadv9D3wnSaOJv4ExFW80uPFGgzlrY5GB1VXBWpsFxczaEBFNhywF/yX6MWfq+utvwOjoKD772U8DAFauXIWPf/wTAID3f+CDePDBH+D22z8Mu92Oq6662tQZbbb7UwmDHAO3X8PBVkMti4Cto6PXx+FUteTRdR3tA0ooqPHgaKfPNBXSqCTHgrXVLqypcWJFhYNrjlDMVE3H0U4fXj/lwbFOnylrU5RtwZb6DGxawKwNEVG6ki0WvPs978W73/PeCfsyMjLwyU9+asrbznZ/KmGQY5AO9TinevymBSC5CGhiuX0aDrV7sS/UNKBvVJ30enarhBUVjnAntNJcZmtodgbdwazNjgaPqSbPIgOrqpzYutCF+mI7X2dERDEKNh5I7Hso37JjxyDHwDhVzSoLWo9jmKrmsktYXsF6nLmk6Tpa+gLY1xIMak50+0wLyRpV5FtDDQNcWFbugN3Kdy6aHU3TcbQrmLU52umDbkjbFGYFa2021bmQ5WTWhoiI5hcGOQY7DevjrKoWs3WqcRHQ9TUu2FiPE3cjXhUHQpma/a1e01lzI6dNwqqqYKZmdbUTxdn8c6P4GHKreKPRgx0NblPmVpaCWZstC11YWGJn5z0iIpq3eNQV4vFrONAWCRA2C7o+jjHI2VDnTOJo0oem6TjV48f+luA0tIbT5u5URrWFNqypCQY2i0sdbPqQgka9U6Ta5uh28aJpOo51+fH6KTeORGVtCjIt2LLQhU0LXMh2cq0kIqK5IIX+JfoxKTYMckL2tXigGMonRFwEtCGqHoeLgMZu0K2GMzUHWr2mVeCNMh0yVlc5sKbahTXVTuRn8gAzVdksEhxWCTc80BDzfTisUsKzo0MeFTsbPHijwY2BqKzNykoHtizMwKJSZm2IiIiMGOSE7GgYC39vlYF1teIFOcYsjtMmYUUlMznTpag6TnT7gg0DWrxo7gtMej0JQH2JPVhbU+PEwmI75ET3k6SYuOwyXry3HgF1qjzc2dksUtzbynv8Gk50+7Gs3A67NXjfmq7jRChrc7jDB80w5PxMC7bUu7B5gQvZLgbVRESJEmw8kPjHpNgwyAkxNh1YWeVChoDtVY2LgK6rcbIe5yx6R0LtnVu9ONjmhTcw+cFvjksONQxwYnWVkweWAnPZZaRSftPj1/C9Z/vRPazgnHoXrlyVhR2NHrze4MHAWCS1LEvAiopg1mZxGbM2REREZ8MgB6F6nFZv+LKIU9V0XceuJsPPwKlqE/gVHcc6fdjX6sH+Vi/aByZfjFOWgMVl44txOlFTaONBJcWdour4+csD4UVhdzR4sKPBY6r3ysuQg+va1LuQy+CaiIho2hjkANjf6jFNYdks4CKgDT0B05nfjVwEFADQNRRp73y4wwe/Mnm2piDTgrWhhgErK51CZvJIHJqu41evDqKhJzItcvyVKRmyNktKOR2SiChVSFLwRGiiH5NiwyAHwA5D62iLDKxPg3qclRXzsx7HG9BwuMOH/aHAZvwseTSrDCwrd4Q6oblQmc/FOClxfvHyIA53+CZsz3RIuOPyQuRl8q2ZiIhoNvhJiqh6HEHP4hsXAV1b7YRtniw0qes62geU4BS0Fi+OdvqgTNHptyTHgrXVLqytcWJ5hQNOm3jPM6WHpj7/pNvHfLqpyQAREaUOSZISfkKUJ2BjN++DHG9Aw/6WSICwqT4ziaOJTbAex/AzpPlUNbdPw6F2L/aGsjX9hml6RnarhBUVDqytCTYNKMu1JXikRJN7/wX5eOHoGBw2GYqqY8ynYcynoSTHitwM1t4QERHN1rwPcva3RNXjCNh0oLE3YDrQ35hmTQc0XUdzbyDcCe1El2/Ks92V+VasqQ5OQVta7oB9nmS0SCw1hXa86zx7sodBREQzwBbSYpn3QY5xqppFBtYLGCAYp6o5bRJWpsH6OCMeFQfavOEFOYc8k89Bc9okrKpyhls8F2XP+5c0ERER0bw3748IjU0HVlQ4kekQb6qIcarammqnkNkLTdNxqscf7oTWcNqPqUoTagtt4Sloi0sdsHI9ICIiIiIymNdBji+gYX9retXjiDRVbWBMDWVqPDjQ5sOYb/JsTZZDxmrDYpz5meIFokRERCQ2OfQv0Y9JsZnXQc7+Vo9p3RQRFwFt6g2gbzRSj5PKi4Aqqo4T3T7sa/ViX4sXLX2BSa8nAagvsYcX46wv5lohRERERDR98zrI2WmYqiZLwIYUDhCmYsziOKzB+pRU0jOiBLM1LV4cbPfCG5h8ElquSw42DKhxYVWVA9lOZmuIiIgodbDxgFjmdZCzw9B0YEWlE1kCHljvTLF6HL+i42inD/tbPdjX6kXHwOSLccoSsKTMEQpsnKgptEHmXzIRERERxcG8DXJ80evjCDhVTdd17GpMbj2OruvoHlLCU9COdPpMUwCNCrMs4aBmZYWYi64SERERUeqbt0HOgTYvfIaD8c314gU5LX0B9BrrcRK0CKg3oOFwhy/UCc2D08OTL8ZplYFlFQ6srXZhTbUTlflWrtxLREREQpIkKeHHMTxuit28DXJ2NIyFv5clYH2deEGOcaqa3SphVaVjTh5H13W0DQSwvyW4GOexTh+UyRuhoTTHGm7vvLzCAaeN2RoiIiIiSqx5G+TsMtTjLKtwClnoblwEdE2VE444BhRjPg2H2r3hdWv6xybP1jisEpZXOMKBTVmuLW5jICIiIkoVshT8l+jHpNjMyyDHr2jY2xwJEEScqha9Ps5sp6ppuo7m3kB4CtqJbj+0KVbjrMq3Yk2NC2urnVhS5kh6swMiIiIiIqN5GeQcaI2qxxGw6UBLfwA9I5Hsysa6mbeOHvGo2N/mDS3I6cWwZ/I5aC67hFWVwUzNmmonirLn5cuGiIiIiAQxL49WdxqmqkmC1uMYu6rZrRJWT2N9HE3Tceq0P9wJrbHHjymSNagrsoXXrVlUYofVwmwNERERzV9cJ0cs8zLIOXXaF/5+WbkTOS7x6nGMU9VWVzmmrMcZGFPDa9YcbPNhzDd5tibLIWN1tRNrq51YXe1EXoZ4vxNKL0NuFXtbvDja6UN1gQ3XrM1O9pCIiIhIEPMyyNlYl4Gn9g0DALZtyUvuYGKg67qps5pxfRxF1XG8y4f9rcFOaC19gUnvQwKwsNQezNZUO1FfbIfM6jZKIlXTcaLbjz3NHuxu8qLhtDnTuLTcgYUl9qSNj4iI5jdmcsQyL4Oc7VvysKTMAUkC1tYkfgHNWB3r8uHuh7sw7NFM3c4Wl9jw7OFR7G/x4mC7F97A5JPQ8jLkUF2NC6uqHEJ2lKP00j+qYE+zF3uavdjX6sGYb/LXbmmOBUVZfL0SERHR9MzLIEeSJCHrcB56fQhNvQFIADIdErIcMrIcMn728tCk17fIwJJSB9aE2jvXFNog85QAJVFA1XG0w4c9LR7safaiuXfyTCMAFGZZsL7WifW1LqyrccJl55pLRESUPFLov0Q/JsVmXgY5otF1HV1DCka9KqoLrMi0y1NOLSvMsmBttRNrapxYWeFEhoMHhpRcp4eV8BS0A21TZxqtMrCi0oF1tS5sqHWiusDGlZ6JiIgoJgxyUtiRDi9eO+XBvhZPuF109BQzTdfh9ukozbXgP68vRUWelQeGlFQ+RcOhNh/2tHixt9mD9gFlyuuW5lixoS6YrVlZ6WC2hoiIiOKCQU6K2tviwf/+pXfSfT5Fw6hXw5hPx5hfQ3G2BV+8qRIlOXw6KfF0XUfHYDBbs6fZi0NtPvjVybM1dquEVVUOrK91YX2tE+W5DMqJiEgMshT8l+jHpNjwqDhFqYZOzw6rhBWVDqypduLLf+7BwFhkp8sm4Vu3VTDAoYTy+DUcaPOGmgZ4cHpYnfK6VfnWcFCzotIJu5Xv2ERERDS3eGScojbWufAfbyuBoulYUuaALbQY5/f/0W8Kcr6yvQxLyx3JGibNE7quo6UvgN2hoOZohw/K5EsuwWWTsKYm0jCAATgREaUDtpAWC48+Uthkwcu7zs3DF57sAQBs25yDC5ZmJnpYNE+MejXsb/WGp6EZ25ZHW1BkC2drlpRHgnIiIiKiZGCQI5gbN+Xi3EUZGPFqWFzGDA7Fj6braDjtx55mL3Y3e3Ciyw9t8tIaZDlkrK1xYkOdE2trXCjI5Bo2RESU3nxez9mvlAaPmS4Y5AioLM+GsmQPgtLCkFvF3pZgtmZvsxfD3snnoEkAFpXaw+vWLCq1w8JqSCIimgesVivy8vLwwH99LCmPn5eXB6uVh+wzJSnKFItWEFHaUTUdx7v84SloDaf9mOoNINclh6egra1xIsfFbA0REc1Pfr8fijL1kghzyWq1wm63J+WxRcYghyjN9Y0q2BuagravxQu3f/I/eVkClpU7sK7WiQ21LtQV2yCz4pGIiIgExNwXUZoJqDqOdvjC2ZrmvsCU1y3MsmBDaAra6monMh1cjJOIiIjExyCHKA10D0UW4zzQ5oV3igStVQZWVDpDtTVOVBfYuBgnERERpR0GOUQC8ikaDrX5sKfFiz1NHnQMTj1PuDTHig11wWzNqioHnDZma4iIiCi9McghEoCu6+gYVLC7KZitOdzug1+dPFtjt0pYVeXAhlDTgPI8W4JHS0RERJRcDHKIUpTHr+FAqzeYrWn24PTw1ItxVhfYsC40BW1FhRN2K6egERER0fzFIIcoRei6jua+APY0B6egHe30QZl82Rq4bBLW1DjDLZ6Ls/mnTERERDSOR0ZESTTq1bCvxRPK1ngxMDZ1tmZBkQ3r64JBzdIyB6wWZmuIiIiIJsMghyiBNF3HqdP+YLam2YMTXX5oU6xUleWUsa7GGVqM04WCTC7GSURERDQdDHKI5tigW8W+UF3N3mYvhr2Tz0GTACwqtWN9rRMb6lxYWGKHRWa2hoiIiGimGOQQxZmq6Tje5Qtla7w4ddo/5XXzMuRwXc3aaieyXczWEBEREc0WgxyiOOgdUbA3lK3Z1+KF2z/5HDRZApaVO0KLcbpQV2yDzMU4iYiIiOKKQQ5RDAKKjqOdPuxp9mB3sxctfYEpr1uUZQkHNaurnch0cDFOIiIiornEIIdomrqGFOxpDi7GebDNC29g8myNVQZWVDqxIRTYVBVYITFbQ0RERJQwDHKIpuALaDjU7gsHNh2DypTXLc+1hhbjdGFVlQNOG7M1RERERMnCIIcoRNd1tA9EsjWH2r0ITLFsjcMqYVWVA+tqXdhQ60R5ni2xgyUiIiKiKTHIoXnN49ewv9UbXremZ2TqxTirC2zh2prlFQ7YrZyCRkRERJSKGORMwePXEFCnWKVxGmwWCS47pyylGl3X0dQbwJ5mL/Y2e3Ck0wd18mVrkGGXsKY6GNSsq3WiOJt/LkREREQi4FHbJDx+DRfe1wCfEnuQ47BKePHeegY6KWDEq2J/ixd7WoIZm4GxqbM1C4pt4XVrlpY5YLUwW0NEREQkGgY5kwioOnyKjifuqEeWc+ZByqhXww0PNCCg6nDNwfjozDRdx6luf3gK2oluP7Qp4tUsp4z1NU6sq3ViXY0L+ZlcjJOIiIhIdAxyziDLKSPbyYNeEQy6Vext9mJPiwf7mr0Y9k4+B00CsLjMHs7WLCyxwyIzW0NERESUThjkkJBUTcfxLh92NwWzNQ09Uy/GmZchh4OatdVOZLsYuBIRERGlMwY5JIzeESU8BW1/qxdu/+Rz0CwysLTMgfW1Tmyoc6G2yAaZi3ESERERzRsMcihlBRQdRzoji3G29E2drSnKsmB9XTBbs7rKiUwHGz4QERERzVcMcmagra0VP/z+d1BQUIibt9+Kp/78R/T29uKCCy/CBRdenOzhpYWuIQV7mjzY0+zBgTbflB3urDKwstIZXremqsAKidkaIiIiIgKDnBmpqqrGhz/yr3j0kYdQXV2DJUuXYeeOX+Cyy69M9tCE5QtoONgeydZ0DipTXrc814p1oSloKysdcNqYrSEiIiKiiRjkzMLFl1yKdes34Fe/+D+cs2VrsocjBF3X0T6gYE+zB7ubvDjc4UVgimVrHFYJq6sc4cU4y/NsiR0sEREREQmJQc4MDA4O4Le//iX279uLN15/DW+8/ip6e3pwwUUXJ3toKc3t07C/zRtuGtA7MvVinNUFtvAUtOUVDtitnIJGRERERDPDIGcG8vLycdc9nw9fZvZmcrquo6k3EJ6CdrTTB3XyZWuQYZewptoZbvFclM2XJBERERHNDo8oKS5GvCr2tUSyNYPuKaIaAPXFtnBQs6TMAauF2RoiIiIiih8GORQTVdPRcNqP3aGg5mS3H9rkjdCQ5ZSxvsaJdbVOrKtxIT+Ti3ESERER0dxhkEPTNuhWsafZg73NXuxt8WLEO3m2RgKwuMweztYsLLHDIjNbQ0RERESJwSCHpqSoOo53+bCn2YvdzR409ky9GGdehhwOatZWO5HtYraGiIiIiJKDQc4ZjE6RqZir26WC3hElXFezv9ULt3/yOWgWGVhW7gh3QqstskHmYpxERERElAIY5EzCZpHgsEq44YGGmO/DYZVgS6GC+pePj+GfJ9x46/psLK9whrcHFB2HOyKLcbb2T52tKcqyYH1dMFuzpsqJDAcX4yQiIiKi1CMpSmCKcvH5zePXEFBj/9XYLBJc9uQHAbqu46HXh/DwG8MAgNIcK/7jbUXY2+LD7mYPDrb54FMm/zmtMrCy0okNdcFsTWW+FRKzNURERESU4hjkpDFV0/HjFwbwzIHRad+mPM8anoK2stIBpy35gRoRERER0Uxwulqa8isa7n2kGw1naBYABKfVra5yhJsGlOXZEjRCIiIiIqK5wSAnTX3n7/1TBjhOq4Qr12Rhfa0Ly8sdsFk5BY2IiIiI0geDnDSVeYamABqA95yfn7jBEBERERElEIOcNPXhi/NRlW/FydMBDLtVNPb6MegOtrauKeSUNCIiIiJKX2w8MI8MjKnoGVFQXWBLic5vRERERERzgUEOERERERGlFZ7OJyIiIiKitMIgh4iIiIiI0gqDHCIiIiIiSisMcoiIiIiIKK0wyCEiIiIiorTCIIeIiIiIiNIKgxwiIiIiIkorDHKIiIiIiCitMMghIiIiIqK0wiCHiIiIiIjSCoMcIiIiIiJKKwxyiIiIiIgorTDIISIiIiKitMIgh4iIiIiI0gqDHCIiIiIiSisMcoiIiIiIKK0wyCEiIiIiorTCIIeIiIiIiNIKgxwiIiIiIkorDHKIiIiIiCitMMghIiIiIqK0wiCHiIiIiIjSCoMcIiIiIiJKKwxyiIiIiIgorTDIISIiIiKitMIgh4iIiIiI0gqDHCIiIiIiSisMcoiIiIiIKK0wyCEiIiIiorTCIIeIiIiIiNIKgxwiIiIiIkorDHKIiIiIiCitMMghIiIiIqK0wiCHiIiIiIjSCoMcIiIiIiJKKwxyiIiIiIgorTDIISIiIiKitMIgh4iIiIiI0gqDHCIiIiIiSisMcoiIiIiIKK0wyCEiIiIiorTCIIeIiIiIiNIKgxwiIiIiIkorDHKIiIiIiCitMMghIiIiIqK0wiCHiIiIiIjSCoMcIiIiIiJKKwxyiIiIiIgorTDIISIiIiKitMIgh4iIiIiI0gqDHCIiIiIiSisMcoiIiIiIKK0wyCEiIiIiorTCIIeIiIiIiNIKgxwiIiIiIkorDHKIiIiIiCitMMghIiIiIqK0wiCHiIiIiIjSCoMcIiIiIiJKKwxyiIiIiIgorTDIISIiIiKitPL/AfpTn1Axs/HiAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "display(viz.plot_network_flows(sc.network, v_impl))\n", "display(viz.plot_flow_scatter((\"bfw (converged)\", v_bfw), {\"implicit-ue-nn\": v_impl}))" ] }, { "cell_type": "markdown", "id": "df1b3c79", "metadata": {}, "source": [ "## Takeaways & pointers\n", "\n", "- **Feasibility is architectural, not trained toward.** A4 holds at RANDOM\n", " weights — the layer's output is always a route-flow vector summing to demand,\n", " by construction, before a single gradient step.\n", "- **Feasible is not equilibrium quality.** The held-out story's headline: a\n", " demand-feasible learned flow still needs a certified gap, and a converged\n", " classical solver still wins it — at matched wall-clock. The learned layer's\n", " answer is that it buys a better certificate PER shortest-path call, not per\n", " wall-clock second.\n", "- **The identifiability caveat is a result, not a bug.** Training fits\n", " equilibrium flows, not cost parameters, so a head that halves the in-family\n", " loss need not beat an untrained baseline on a held-out net in a different\n", " congestion regime. This notebook does not claim otherwise.\n", "- **Where next.** `het-gnn` ([02-het-gnn.ipynb](02-het-gnn.ipynb)) completes the\n", " feasibility-mechanism gradient with a soft-conservation-trained, explicitly\n", " decoded alternative; the full derivation and every measured anchor in\n", " [docs/design/adr-025-implicit-ue-nn.md](../../docs/design/adr-025-implicit-ue-nn.md)." ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.10.12" }, "tabench": { "covers": [], "requires_extra": "torch", "track": "learned", "unit": "implicit-ue-nn" } }, "nbformat": 4, "nbformat_minor": 5 }