diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..2deaa7f --- /dev/null +++ b/.gitattributes @@ -0,0 +1,3 @@ +# keep text files with LF endings in the repository on every platform +* text=auto eol=lf +*.png binary diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index a7caccc..d086564 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -25,4 +25,4 @@ jobs: - name: Fast tests (unit + regression) run: pytest -q - name: Validation tests - run: pytest -q --runslow tests/test_validation.py tests/test_joint_validation.py + run: pytest -q --runslow tests/test_validation.py tests/test_joint_validation.py tests/test_notebook.py diff --git a/README.md b/README.md index 1b22267..d9e8254 100644 --- a/README.md +++ b/README.md @@ -252,6 +252,25 @@ pytest -q # fast tests; add --runslow for the validation tes The scripts can also be run directly with `python maxcal_poisson.py ...`. +**Demo notebook.** `notebooks/demo.ipynb` walks through the method interactively, +using the test datasets: +- attempt counting as Q‡ moves; +- the reweighting weights, their saturation, and the resulting CV and N_eff; +- stitching and the emergence of Poisson statistics; +- validation against a simulated higher barrier, including what goes wrong with Q‡ + on the barrier top; +- the joint-mode checks (kinetic ΔG, transition-path symmetry across temperatures). + +```bash +pip install -e ".[demo]" +jupyter lab notebooks/demo.ipynb +``` + +The committed copy is rendered with static figures, so it can be read on GitHub. +The sliders appear when you run it live with `ipywidgets` installed. To refresh the +committed outputs: +`MAXCAL_DEMO_STATIC=1 jupyter nbconvert --to notebook --execute --inplace notebooks/demo.ipynb`. + ```bash python maxcal_poisson.py "runs/q_*.xvg" --qu 0.3 --qf 0.8 \ --qts 0.40 --qtse 0.55 --out results @@ -277,6 +296,16 @@ Lines starting with `#` or `@` are ignored, so GROMACS `.xvg` files work directl KS p-values, λ* with bootstrap CI, N_eff, stitching threshold, and `cv_stitch0`/`ksp_stitch0` (stitching at λ = 0). - `tse_frames_*.csv`: TSE frame per completed trajectory, with its weight. + +**Status columns.** Every NaN in `summary.csv` comes with a reason code, so it can be +told apart from a failure of the code. + +| column | values | +|---|---| +| `geom_status` | `ok`; `too_few_trajectories` (fewer than 10 completed); `too_few_bins` (too few distinct k for the χ² test) | +| `lag1_status` | `ok`; `too_few_pairs` (fewer than 10 consecutive failure cycles); `constant_cycles` (correlation undefined) | +| `reweight_status` | `ok`; `no_root` (weighted CV never reaches 1, §2.4); `low_neff` (N_eff below `--neff-min`); `cv_ge_1_at_lambda0` (already over-dispersed: a missing barrier does not explain the deviation) | +| `stitch_status` | `ok`; `ok_pool_fallback` (initial segments had to be used); `no_pass` (Poisson criterion never met in the scan); `empty_pool` (no failed attempts past this Q‡, typically at or beyond the barrier) | - `survival.png`, `lambda_scan.png`, `robustness_qts.png`. **Reading the results** @@ -294,8 +323,8 @@ Lines starting with `#` or `@` are ignored, so GROMACS `.xvg` files work directl ## 5. Tests ```bash -pytest -q tests/ # 41 fast tests (~8 s) -pytest -q tests/ --runslow # + 13 validation tests against known answers (~15 s) +pytest -q tests/ # 46 fast tests (~8 s) +pytest -q tests/ --runslow # + 13 validation tests and the demo notebook (~25 s) MAXCAL_UPDATE_REF=1 pytest tests/test_regtest.py # regenerate the reference ``` @@ -306,6 +335,17 @@ MAXCAL_UPDATE_REF=1 pytest tests/test_regtest.py # regenerate the reference trajectories, compared with `tests/regtest/reference_summary.csv`. Deterministic columns use rtol 1e-5; RNG-dependent stitching columns use loose absolute tolerances. +- **`test_reweight_path.py`**: end-to-end test of the path where reweighting + succeeds, which the Langevin data never reach. It uses hand-built trajectories + (`tests/synthetic.py`) in which the weighted CV crosses 1 at λ* ≈ 1.1 with + N_eff ≈ 115. It checks that: + - λ* is finite and bracketed by its bootstrap confidence interval; + - N_eff and the KS p-value at λ* are finite; + - the weighted CV equals 1 at λ*; + - the TSE weight ratio between trajectories with 3 and 0 failures is exactly c³; + - every NaN has the right reason code. +- The regression test also checks that every NaN in the summary has a non-`ok` + reason code, and it compares the reason codes with the reference. - **`test_validation.py`**: low-barrier and high-barrier Langevin runs; the high barrier is the low one plus a Gaussian bump of 2 or 3 kT on the barrier top. It checks four things. diff --git a/maxcal_joint.py b/maxcal_joint.py index 98a8d6d..0abce1c 100644 --- a/maxcal_joint.py +++ b/maxcal_joint.py @@ -51,9 +51,7 @@ import numpy as np from scipy import stats -import matplotlib -matplotlib.use("Agg") -import matplotlib.pyplot as plt +import matplotlib.pyplot as plt # backend set to Agg in main(), not at import import maxcal_poisson as mp @@ -507,6 +505,7 @@ def report(res): def main(argv=None): + plt.switch_backend("Agg") # command-line use: files only, no display args = parse_args(argv) res, F, B, feat_table, pplot, rng = analyse(args) write_outputs(args, res, F, B, feat_table, pplot, rng) diff --git a/maxcal_poisson.py b/maxcal_poisson.py index d62e930..3402eb2 100644 --- a/maxcal_poisson.py +++ b/maxcal_poisson.py @@ -48,9 +48,7 @@ from scipy import stats from scipy.special import logsumexp -import matplotlib -matplotlib.use("Agg") -import matplotlib.pyplot as plt +import matplotlib.pyplot as plt # backend set to Agg in main(), not at import # ----------------------------------------------------------------------------- I/O @@ -290,6 +288,41 @@ def stitch_scan(lams, p, A, n_sub_size, args, rng): return lam_pass, res +# ------------------------------------------------------------------ status flags +# Every NaN in summary.csv comes with a reason in one of these columns. +def geom_status(n, pval): + if n < 10: + return "too_few_trajectories" + return "too_few_bins" if not np.isfinite(pval) else "ok" + + +def lag1_status(pairs): + """pairs: (n, 2) array of consecutive failure-cycle durations within trajectories.""" + if len(pairs) < 10: + return "too_few_pairs" + if np.ptp(pairs[:, 0]) == 0 or np.ptp(pairs[:, 1]) == 0: + return "constant_cycles" # correlation undefined + return "ok" + + +def reweight_status(cv0, lam_star, neff, neff_min): + if cv0 >= 1: + return "cv_ge_1_at_lambda0" # already over-dispersed: a missing barrier can't explain it + if not np.isfinite(lam_star): + return "no_root" # CV never reaches 1: observed attempt counts too few + if not neff >= neff_min: + return "low_neff" + return "ok" + + +def stitch_status(lam_stitch, n_fail_pool, n_succ_pool, pool_note): + if n_fail_pool == 0 or n_succ_pool == 0: + return "empty_pool" # no failed attempts past this Q‡ (at/after the barrier?) + if not np.isfinite(lam_stitch): + return "no_pass" + return "ok_pool_fallback" if pool_note else "ok" # fallback: initial segments were used + + # --------------------------------------------------------------------------- main def analyse(trajs, qts, args, rng, lams, full=False): A = attempts(trajs, qts, args.t0, args.include_initial, args.qtse) @@ -299,9 +332,11 @@ def analyse(trajs, qts, args, rng, lams, full=False): frac_k0=float(np.mean(k[done] == 0)) if done.any() else np.nan, p=p, note=A["note"]) out["geom_p"], out["geom_bins"] = geometric_test(k[done]) + out["geom_status"] = geom_status(int(done.sum()), out["geom_p"]) pr = A["pairs"] + out["lag1_status"] = lag1_status(pr) out["lag1_rho"], out["lag1_p"] = (stats.spearmanr(pr[:, 0], pr[:, 1]) - if len(pr) >= 10 else (np.nan, np.nan)) + if out["lag1_status"] == "ok" else (np.nan, np.nan)) cv, neff = cv_curve(lams, k, T, done, p) lam_star = first_crossing(lams, cv) @@ -332,9 +367,12 @@ def analyse(trajs, qts, args, rng, lams, full=False): out["lam_lo"], out["lam_hi"] = (np.percentile(fin, [2.5, 97.5]) if fin.size else (np.nan, np.nan)) out["boot_noroot"] = float(np.mean(~np.isfinite(boots))) if boots.size else np.nan + out["reweight_status"] = reweight_status(out["cv0"], lam_star, out["neff_star"], args.neff_min) lam_st, st_res = stitch_scan(lams, p, A, k.size, args, rng) out["lam_stitch"] = lam_st + out["stitch_status"] = stitch_status(lam_st, A["fail_pool"].size, A["succ_pool"].size, + A["note"]) out["cv_stitch0"], out["ksp_stitch0"] = (st_res[0][1], st_res[0][2]) if st_res else (np.nan, np.nan) out["cv_lammax"] = cv[-1] out["kmax"] = int(k.max()) if k.size else 0 @@ -345,6 +383,7 @@ def analyse(trajs, qts, args, rng, lams, full=False): def main(): + plt.switch_backend("Agg") # command-line use: files only, no display ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("files", nargs="+", help="trajectory files or glob patterns") @@ -399,9 +438,10 @@ def main(): cols = ["qts", "N", "n_done", "sum_k", "frac_k0", "p", "geom_p", "lag1_rho", "lag1_p", "cv0", "ks_p0", "lam_star", "lam_lo", "lam_hi", "boot_noroot", "neff_star", "ks_p_star", "reweight_ok", "cv_lammax", "kmax", "cv_stitch0", "ksp_stitch0", - "lam_stitch", "p_stitch", "note"] + "lam_stitch", "p_stitch", "geom_status", "lag1_status", "reweight_status", + "stitch_status", "note"] with open(os.path.join(args.out, "summary.csv"), "w", newline="") as fh: - wr = csv.writer(fh) + wr = csv.writer(fh, lineterminator="\n") wr.writerow(cols) for r in results: wr.writerow([r[c] if isinstance(r[c], str) else f"{r[c]:.6g}" for c in cols]) @@ -415,7 +455,9 @@ def main(): f"{r['lam_stitch']:8.2f}" + (" *ref" if r is ref else "")) # ---- warnings for the reference surface - print(f"\nReference Q‡ = {qref:.3f}") + print(f"\nReference Q‡ = {qref:.3f} [geometric test: {ref['geom_status']}, " + f"lag-1: {ref['lag1_status']}, reweighting: {ref['reweight_status']}, " + f"stitching: {ref['stitch_status']}]") if ref["note"]: print(" " + ref["note"]) if np.isfinite(ref["geom_p"]) and ref["geom_p"] < args.alpha: @@ -445,7 +487,7 @@ def main(): A, w = ref["A"], ref["w"] pos = {i: j for j, i in enumerate(A["idx"])} with open(os.path.join(args.out, f"tse_frames_qts{qref:.3f}_qtse{(args.qtse or qref):.3f}.csv"), "w", newline="") as fh: - wr = csv.writer(fh) + wr = csv.writer(fh, lineterminator="\n") wr.writerow(["trajectory", "frame", "time", "k_failed", "weight_at_lambda_star"]) for i, fr in A["tse"]: j = pos[i] diff --git a/notebooks/demo.ipynb b/notebooks/demo.ipynb new file mode 100644 index 0000000..89198d9 --- /dev/null +++ b/notebooks/demo.ipynb @@ -0,0 +1,650 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "8502d09c", + "metadata": {}, + "source": [ + "# MaxCal barrier tilt: interactive demo\n", + "\n", + "This notebook uses the test datasets to show, step by step, what `maxcal_poisson.py` does:\n", + "\n", + "1. **Attempts.** Trajectories are decomposed into failed and successful attempts at an interface Q‡.\n", + "2. **Reweighting.** Each trajectory gets the MaxCal weight $w \\propto c^{k}$; you can see what that does to the folding-time distribution, and why it saturates.\n", + "3. **Stitching.** The same tilted ensemble is sampled generatively, and Poisson statistics emerge.\n", + "4. **Validation.** Stitched model data are compared with a ground truth that has a higher barrier, including where Q‡ must be placed.\n", + "5. **Joint mode.** Forward and backward runs: kinetic ΔG and transition-path time-reversal symmetry.\n", + "\n", + "Sliders need `ipywidgets` (`pip install -e \".[demo]\"`). Without it, each interactive cell shows a static figure for a few parameter values instead. See the README for the derivations (§ numbers below refer to it)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "060fdbe1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:20:57.421101Z", + "iopub.status.busy": "2026-09-18T17:20:57.420967Z", + "iopub.status.idle": "2026-09-18T17:20:58.269043Z", + "shell.execute_reply": "2026-09-18T17:20:58.268182Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "widgets: False\n" + ] + } + ], + "source": [ + "%matplotlib inline\n", + "import os, sys\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy import stats\n", + "\n", + "ROOT = os.path.abspath(os.path.join(os.getcwd(), os.pardir)) if os.path.basename(os.getcwd()) == \"notebooks\" else os.getcwd()\n", + "sys.path[:0] = [ROOT, os.path.join(ROOT, \"tests\")]\n", + "import maxcal_poisson as mp\n", + "import maxcal_joint as mj\n", + "import langevin as L\n", + "import synthetic as S\n", + "\n", + "# MAXCAL_DEMO_STATIC=1 forces static figures (used to render the committed copy)\n", + "try:\n", + " import ipywidgets as W\n", + " HAVE_WIDGETS = not os.environ.get(\"MAXCAL_DEMO_STATIC\")\n", + "except ImportError:\n", + " HAVE_WIDGETS = False\n", + "\n", + "def explore(fn, static, **sliders):\n", + " # Interactive sliders if ipywidgets is available, otherwise static calls.\n", + " if HAVE_WIDGETS:\n", + " W.interact(fn, **sliders)\n", + " else:\n", + " for kw in static:\n", + " fn(**kw)\n", + "\n", + "plt.rcParams.update({\"figure.dpi\": 100, \"axes.grid\": True, \"grid.alpha\": 0.3})\n", + "QU, QF = 0.3, 0.8\n", + "print(\"widgets:\", HAVE_WIDGETS)" + ] + }, + { + "cell_type": "markdown", + "id": "568c9cc9", + "metadata": {}, + "source": [ + "## 1. Data\n", + "\n", + "We use two datasets.\n", + "- **`langevin`**: 100 overdamped Langevin trajectories on a low-barrier double well (barrier 0.8 kT at Q = 0.55), started below the unfolded minimum and stopped at folding. This is the same data as the regression test.\n", + "- **`synthetic`**: hand-built trajectories from `tests/synthetic.py`, in which pure reweighting succeeds (§2.4). They exist only to exercise the code, not as a physical model." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "265227e5", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:20:58.270888Z", + "iopub.status.busy": "2026-09-18T17:20:58.270249Z", + "iopub.status.idle": "2026-09-18T17:20:58.452770Z", + "shell.execute_reply": "2026-09-18T17:20:58.451866Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "langevin : 100 trajectories, all folded: True\n", + "synthetic : 240 trajectories, all folded: True\n" + ] + } + ], + "source": [ + "def to_trajs(Qs, dt):\n", + " out = []\n", + " for i, q in enumerate(Qs):\n", + " fold, fails = mp.parse_traj(q, QU, QF)\n", + " out.append(dict(path=str(i), q=q, dt=dt, n=q.size, fold=fold, fails=fails))\n", + " return out\n", + "\n", + "# Langevin regression data (same generator and seeds as tests/test_regtest.py)\n", + "lang_Q = [L.run_one(np.random.default_rng([2024, i]))[0] for i in range(100)]\n", + "lang_dt = L.run_one(np.random.default_rng([2024, 0]))[1]\n", + "\n", + "# synthetic data where reweighting reaches CV = 1\n", + "import tempfile, glob\n", + "tmp = tempfile.mkdtemp()\n", + "S.write_reweight_set(tmp)\n", + "syn_Q = [np.loadtxt(f)[:, 1] for f in sorted(glob.glob(os.path.join(tmp, \"*.xvg\")))]\n", + "\n", + "DATA = {\"langevin\": to_trajs(lang_Q, lang_dt), \"synthetic\": to_trajs(syn_Q, 1.0)}\n", + "DEFAULT_QTS = {\"langevin\": 0.45, \"synthetic\": 0.45}\n", + "for k, v in DATA.items():\n", + " print(f\"{k:10s}: {len(v)} trajectories, all folded: {all(t['fold'] is not None for t in v)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "e7842f50", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:20:58.454498Z", + "iopub.status.busy": "2026-09-18T17:20:58.453984Z", + "iopub.status.idle": "2026-09-18T17:20:58.555033Z", + "shell.execute_reply": "2026-09-18T17:20:58.554292Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwAAAAFMCAYAAAB8hNuwAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4VFX6x7/Te8+kNxIIAUJREARELBT7omtZdS3osvayuuuuFXV/u65lXXftYl0rYndVRCkKiIIgPZCQXmYymd7rPb8/JplkMpNkUmcmOZ/n4dGce++577nn3rn3PW9jEUIIKBQKhUKhUCgUyriAnWwBKBQKhUKhUCgUyuhBFQAKhUKhUCgUCmUcQRUACoVCoVAoFAplHEEVAAqFQqFQKBQKZRxBFQAKhUKhUCgUCmUcQRUACoVCoVAoFAplHEEVAAqFQqFQKBQKZRxBFQAKhUKhUCgUCmUcQRUACoVCoVAoFAplHEEVAAolDSkuLsbVV1+dbDHSlquvvhrFxcXJFiNhTjnlFJxyyinJFmNQbNmyBSwWC1u2bEm2KOOWBx98ECwWK6kyPP744ygpKQGHw8GsWbMGdGyi93+8ey3dnnUKZbSgCgCFkkIcOHAAF154IYqKiiAUCpGXl4elS5fi6aefHrFz1tfXg8Vi4Yknnhixc4x1Dh8+jAcffBD19fXJFmVQPPfcc3j99deTLUbSSfd5HC2+/PJLPPjggwnvv2HDBtx1111YuHAhXnvtNfz9738fOeEoFEpCcJMtAIVCCfPDDz/g1FNPRWFhIVatWoXs7Gw0NTXhxx9/xL///W/ccsstkX2PHj0KNpvq74NlzZo1YBhm2Po7fPgwHnroIZxyyikjstq4YcOGYe+zO8899xwyMjJGxKp08sknw+PxgM/nD3vfw81Iz+NY4csvv8Szzz6bsBKwadMmsNlsvPLKK6N+Hwz3s06hjBWoAkChpAh/+9vfoFAosGvXLiiVyqhtBoMh6m+BQDCKko09eDxe0s5NCIHX64VIJEr4mHT4eO6J1+sFn88Hm82GUChMtjiUJGIwGCASiZJyHyfzWadQUhm6hEihpAg1NTWYNm1azMc/AGRmZkb93T0GgBCCU089FVqtNkpR8Pv9mD59OkpLS+FyuYYs32uvvYbTTjsNmZmZEAgEmDp1Kp5//vmY/YqLi3HOOedg27ZtmDt3LoRCIUpKSvDf//43Zt/9+/dj8eLFEIlEyM/Px//93//htddeA4vFinHD+Oqrr7Bo0SJIJBLIZDKcffbZOHToUGT7E088ARaLhYaGhpjz3H333eDz+bBYLABi/YK7u0G99NJLKC0thUAgwAknnIBdu3b1eV1ef/11XHTRRQCAU089FSwWK8oPufN6fP3115gzZw5EIhFefPHFAV3TeD7QPp8Pq1evxsSJEyEQCFBQUIC77roLPp8v5vi33noLc+fOhVgshkqlwsknnxyxKhQXF+PQoUP47rvvIrJ3P1dtbS0uuugiqNVqiMVinHjiifjiiy+i+u/0vX7vvfdw3333IS8vD2KxGHa7vdcYgJ9++glnnHEGFAoFxGIxFi9ejO3bt0ft43A4cPvtt6O4uBgCgQCZmZlYunQp9uzZ0+ec9MZ7772H2bNnQyaTQS6XY/r06fj3v/8NoP95BMKWkmnTpkEgECA3Nxc33XQTrFZr1DlOOeUUVFRUYPfu3ViwYAFEIhEmTJiAF154Ie41W7t2Le655x5kZ2dDIpHgvPPOQ1NTU4zsiVwvANi2bRtOOOEECIVClJaWRu61RNi6dSsuuugiFBYWRu6pP/zhD/B4PJF9rr76ajz77LMAELlGfcUXsFgsvPbaa3C5XJF9O93NgsEg/vrXv0aet+LiYtxzzz1x7+GeNDc3Y8WKFZBIJMjMzMQf/vCHuMcN9Vlft24dpk6dCqFQiIqKCnz88cc0roAyJqAWAAolRSgqKsKOHTtw8OBBVFRUJHwci8XCq6++ihkzZuD666/HRx99BABYvXo1Dh06hC1btkAikQxZvueffx7Tpk3DeeedBy6Xi88//xw33ngjGIbBTTfdFLXvsWPHcOGFF+Laa6/FVVddhVdffRVXX301Zs+ejWnTpgEAWlpaIh9ad999NyQSCV5++eW41o0333wTV111FZYvX45HH30Ubrcbzz//PE466ST88ssvKC4uxsUXX4y77roL77//Pv70pz9FHf/+++9j2bJlUKlUfY7xnXfegcPhwHXXXQcWi4XHHnsMF1xwAWpra3tdSTz55JNx66234j//+Q/uueceTJkyBQAi/wXCLluXXnoprrvuOqxatQqTJ08e8DXtDsMwOO+887Bt2zb8/ve/x5QpU3DgwAH861//QlVVFT755JPIvg899BAefPBBLFiwAA8//DD4fD5++uknbNq0CcuWLcNTTz2FW265BVKpFPfeey8AICsrCwDQ1taGBQsWwO1249Zbb4VGo8Ebb7yB8847Dx988AHOP//8KLn++te/gs/n449//CN8Pl+vK76bNm3CmWeeidmzZ2P16tVgs9kRZWjr1q2YO3cuAOD666/HBx98gJtvvhlTp06FyWTCtm3bUFlZieOPP76vqYzhm2++waWXXorTTz8djz76KACgsrIS27dvx2233dbvPD744IN46KGHsGTJEtxwww04evQonn/+eezatQvbt2+Puj8sFgvOOussXHzxxbj00kvx/vvv44YbbgCfz8c111wTJdff/vY3sFgs/PnPf4bBYMBTTz2FJUuWYO/evRErUaLX68CBA1i2bBm0Wi0efPBBBINBrF69OjKf/bFu3Tq43W7ccMMN0Gg02LlzJ55++mk0Nzdj3bp1AIDrrrsOra2t+Oabb/Dmm2/22+ebb76Jl156CTt37sTLL78MAFiwYAEA4He/+x3eeOMNXHjhhbjzzjvx008/4ZFHHkFlZSU+/vjjXvv0eDw4/fTT0djYiFtvvRW5ubl48803sWnTpoTGCST2rH/xxRe45JJLMH36dDzyyCOwWCy49tprkZeXl/B5KJSUhVAolJRgw4YNhMPhEA6HQ+bPn0/uuusu8vXXXxO/3x+zb1FREbnqqqui2l588UUCgLz11lvkxx9/JBwOh9x+++39nreuro4AII8//nif+7nd7pi25cuXk5KSkhjZAJDvv/8+0mYwGIhAICB33nlnpO2WW24hLBaL/PLLL5E2k8lE1Go1AUDq6uoIIYQ4HA6iVCrJqlWros6j1+uJQqGIap8/fz6ZPXt21H47d+4kAMh///vfSNtVV11FioqKYq6BRqMhZrM50v7pp58SAOTzzz/v48oQsm7dOgKAbN68OWZb5/VYv359zLZEr+nixYvJ4sWLI3+/+eabhM1mk61bt0bt98ILLxAAZPv27YQQQqqrqwmbzSbnn38+CYVCUfsyDBP5/2nTpkX138ntt99OAESdx+FwkAkTJpDi4uJIn5s3byYASElJScyYOrd1XhuGYcikSZPI8uXLo2Rwu91kwoQJZOnSpZE2hUJBbrrpphi5BsNtt91G5HI5CQaDve7T2zwaDAbC5/PJsmXLoq7jM888QwCQV199NdK2ePFiAoD885//jLT5fD4ya9YskpmZGXmeO69LXl4esdvtkX3ff/99AoD8+9//JoQM7HqtWLGCCIVC0tDQEGk7fPgw4XA4JJHXfbz78ZFHHiEsFiuqz5tuuimh/jq56qqriEQiiWrbu3cvAUB+97vfRbX/8Y9/JADIpk2bIm097/+nnnqKACDvv/9+pM3lcpGJEyfGzN9QnvXp06eT/Px84nA4Im1btmwhAKL6pFDSEeoCRKGkCEuXLsWOHTtw3nnnYd++fXjsscewfPly5OXl4bPPPuv3+N///vdYvnw5brnlFlxxxRUoLS0d1mwb3X3WbTYbjEYjFi9ejNraWthstqh9p06dikWLFkX+1mq1mDx5MmprayNt69evx/z586NSAqrValx++eVRfX3zzTewWq249NJLYTQaI/84HA7mzZuHzZs3R/a95JJLsHv3btTU1ETa1q5dC4FAgF/96lf9jvGSSy6JshJ0jqG73INhwoQJWL58eUz7QK5pd9atW4cpU6agvLw86pqcdtppABC5Jp988gkYhsEDDzwQEzSeSFrIL7/8EnPnzsVJJ50UaZNKpfj973+P+vp6HD58OGr/q666qt/Yhr1796K6uhqXXXYZTCZTRHaXy4XTTz8d33//fSRoU6lU4qeffkJra2u/svaHUqmEy+XCN998M+Bjv/32W/j9ftx+++1R13HVqlWQy+UxLlFcLhfXXXdd5G8+n4/rrrsOBoMBu3fvjtr3yiuvhEwmi/x94YUXIicnB19++SWAxK9XKBTC119/jRUrVqCwsDDS35QpU+Lee/HoPnculwtGoxELFiwAIQS//PJLQn0kSuf47rjjjqj2O++8EwBirmnPY3NycnDhhRdG2sRiMX7/+98nfP7+nvXW1lYcOHAAV155JaRSaWS/xYsXY/r06Qmfh0JJVagCQKGkECeccAI++ugjWCwW7Ny5E3fffTccDgcuvPDCmI+teLzyyitwu92orq7G66+/PqBA0/7Yvn07lixZAolEAqVSCa1Wi3vuuQcAYj5Wu3+AdKJSqSI++ADQ0NCAiRMnxuzXs626uhoAcNppp0Gr1Ub927BhQ1Tcw0UXXQQ2m421a9cCCMdHrFu3DmeeeSbkcnm/Y+wpd+cHQne5B8OECRPitg/kmnanuroahw4dirkeZWVlALqCxmtqasBmszF16tRByd3Q0BBxV+pOp1tMz3iL3sbZU3YgrCz0lP/ll1+Gz+eLjP2xxx7DwYMHUVBQgLlz5+LBBx8ctDJ24403oqysDGeeeSby8/NxzTXXYP369Qkd2znOnteCz+ejpKQk5jrk5ubGuN11zk3P2JZJkyZF/c1isTBx4sTIfoler/b2dng8npj+4sndG42Njbj66quhVqshlUqh1WqxePFiAH3fj4OhoaEBbDY75nnPzs6GUqmMG8vT/diJEyfGKLGJjhPo/1nvPH8iv1EUSjpCYwAolBSEz+fjhBNOwAknnICysjKsXLkS69atw+rVq/s8bsuWLZFAuAMHDmD+/PnDIk9NTQ1OP/10lJeX48knn0RBQQH4fD6+/PJL/Otf/4pJs8fhcOL2QwgZ8Lk7+37zzTeRnZ0ds53L7foZy83NxaJFi/D+++/jnnvuwY8//ojGxsaIz3d/DKfc3YmniA30mnaHYRhMnz4dTz75ZNztBQUFQ5J3sCSicHaO6/HHH++1IFTniuvFF1+MRYsW4eOPP8aGDRvw+OOP49FHH8VHH32EM888c0CyZWZmYu/evfj666/x1Vdf4auvvsJrr72GK6+8Em+88caA+hpNEr1eiQTO9kUoFMLSpUthNpvx5z//GeXl5ZBIJGhpacHVV189Yqk0k1WgbKSedQolXaAKAIWS4syZMwcAoNPp+txPp9PhlltuwbJlyyKBmMuXL0dRUdGQZfj888/h8/nw2WefRa2cdXe/GShFRUU4duxYTHvPttLSUgDhD7glS5b02+8ll1yCG2+8EUePHsXatWshFotx7rnnDlrORBjMR8xQrmlpaSn27duH008/vc9zl5aWgmEYHD58uM/qq731UVRUhKNHj8a0HzlyJLJ9oHTOp1wuT2g+c3JycOONN+LGG2+EwWDA8ccfj7/97W8DVgCAsGJ97rnn4txzzwXDMLjxxhvx4osv4v7774+7otxJ5ziPHj2KkpKSSLvf70ddXV3MOFpbW+FyuaKsAFVVVQAQkz2mc4W/E0IIjh07hhkzZgBI/HpptVqIRKKY/jrl7o8DBw6gqqoKb7zxBq688spIezyXqeH4aC8qKgLDMKiuro4KmG9ra4PVau3z3ioqKsLBgwdBCImSJZFxDkQ+IPb3qLc2CiXdoC5AFEqKsHnz5rirT52+sv2Zt1etWgWGYfDKK6/gpZdeApfLxbXXXjssK1qdq2Xd+7LZbHjttdcG3efy5cuxY8cO7N27N9JmNpvx9ttvx+wnl8vx97//HYFAIKaf9vb2qL9//etfg8Ph4N1338W6detwzjnnDEsWpL7o7L9nSsi+GMo1vfjii9HS0oI1a9bEbPN4PJG0rytWrACbzcbDDz8cs4Lb/bwSiSSu7GeddRZ27tyJHTt2RNpcLhdeeuklFBcXD8q1aPbs2SgtLcUTTzwBp9MZs71zPkOhUIzbSWZmJnJzcwe12m0ymaL+ZrPZkY/szv56m8clS5aAz+fjP//5T9R1e+WVV2Cz2XD22WdH7R8MBqPSb/r9frz44ovQarWYPXt21L7//e9/4XA4In9/8MEH0Ol0EQUn0evF4XCwfPlyfPLJJ2hsbIxsr6ysxNdff93HlUHkeCD6viCERNKkdmcw93tPzjrrLADAU089FdXeadXqeU17Htva2ooPPvgg0uZ2u/HSSy8NWp6e5ObmoqKiAv/973+jrvt3332HAwcODNt5KJRkQS0AFEqKcMstt8DtduP8889HeXk5/H4/fvjhB6xduxbFxcVYuXJlr8e+9tpr+OKLL/D6668jPz8fAPD000/jt7/9LZ5//nnceOON/Z5/48aN8Hq9Me0rVqyIWBXOPfdcXHfddXA6nVizZg0yMzP7tUz0xl133YW33noLS5cuxS233BJJA1pYWAiz2RxZ2ZPL5Xj++edxxRVX4Pjjj8dvfvMbaLVaNDY24osvvsDChQvxzDPPRPrNzMzEqaeeiieffBIOhwOXXHLJoOQbCLNmzQKHw8Gjjz4Km80GgUAQye/fG0O5pldccQXef/99XH/99di8eTMWLlyIUCiEI0eO4P3334/UHJg4cSLuvfde/PWvf8WiRYtwwQUXQCAQYNeuXcjNzcUjjzwCIPyR+fzzz+P//u//MHHiRGRmZuK0007DX/7yF7z77rs488wzceutt0KtVuONN95AXV0dPvzww0FVo2az2Xj55Zdx5plnYtq0aVi5ciXy8vLQ0tKCzZs3Qy6X4/PPP4fD4UB+fj4uvPBCzJw5E1KpFN9++y127dqFf/7zn5H+tmzZglNPPRWrV6/uszLt7373O5jNZpx22mnIz89HQ0MDnn76acyaNSuyAt3XPN5999146KGHcMYZZ+C8887D0aNH8dxzz+GEE07Ab3/726hz5ebm4tFHH0V9fT3Kysqwdu1a7N27Fy+99FJMOlm1Wo2TTjoJK1euRFtbG5566ilMnDgRq1atGtD1AsIpX9evX49FixbhxhtvRDAYxNNPP41p06Zh//79fc5LeXk5SktL8cc//hEtLS2Qy+X48MMP48a/dCoxt956K5YvXw4Oh4Pf/OY3ffbfk5kzZ+Kqq67CSy+9BKvVisWLF2Pnzp144403sGLFCpx66qm9Hrtq1So888wzuPLKK7F7927k5OTgzTffhFgsHpAM/fH3v/8dv/rVr7Bw4UKsXLkSFosFzzzzDCoqKuIqYxRKWpGEzEMUCiUOX331FbnmmmtIeXk5kUqlhM/nk4kTJ5JbbrmFtLW1Re3bPQ1oU1MTUSgU5Nxzz43p8/zzzycSiYTU1tb2et7OtHi9/XvzzTcJIYR89tlnZMaMGUQoFJLi4mLy6KOPkldffTUqZWenbGeffXbMeXqm8iOEkF9++YUsWrSICAQCkp+fTx555BHyn//8hwAger0+at/NmzeT5cuXE4VCQYRCISktLSVXX301+fnnn2POtWbNGgKAyGQy4vF4Yrb3lhowXipUAGT16tW9Xr/u5ywpKYmkXOxMRdjb9SAk8Wsa79r5/X7y6KOPkmnTphGBQEBUKhWZPXs2eeihh4jNZova99VXXyXHHXdcZL/FixeTb775JrJdr9eTs88+m8hkMgIg6lw1NTXkwgsvJEqlkgiFQjJ37lzyv//9L6r/zpSW69atixljzzSgnfzyyy/kggsuIBqNhggEAlJUVEQuvvhisnHjRkJIOHXmn/70JzJz5kwik8mIRCIhM2fOJM8991xUP59//jkBQF544YW417iTDz74gCxbtoxkZmYSPp9PCgsLyXXXXUd0Ol3Ufr3NIyHhtJ/l5eWEx+ORrKwscsMNNxCLxRJ1/OLFi8m0adPIzz//TObPn0+EQiEpKioizzzzTNzr8u6775K7776bZGZmEpFIRM4+++yolJuJXq9OvvvuOzJ79mzC5/NJSUkJeeGFF8jq1asTStt5+PBhsmTJEiKVSklGRgZZtWoV2bdvHwFAXnvttch+wWCQ3HLLLUSr1RIWi9Vv3/HSgBJCSCAQIA899BCZMGEC4fF4pKCggNx9993E6/VG7Rfv/m9oaCDnnXceEYvFJCMjg9x2221k/fr1CacBTfRZf++990h5eTkRCASkoqKCfPbZZ+TXv/41KS8v73PMFEqqwyKERrxQKJTU4fbbb8eLL74Ip9PZa6DeeGPRokUQCAT49ttvky1KynHXXXfh3XffxbFjx+IWkRttTjnlFBiNRhw8eLDP/TotF+vWrYtKZ0lJfWbNmgWtVjuolLIUSqpAYwAoFErS8Hg8UX+bTCa8+eabOOmkk+jHfzd0Oh0yMjKSLUZKsnnzZtx///0p8fFPGVsEAgEEg8Goti1btmDfvn045ZRTkiMUhTJM0BgACoWSNObPn49TTjkFU6ZMQVtbG1555RXY7Xbcf//9yRYtJfjhhx/w0UcfoaamBn/+85+TLU5KsmvXrmSLQBmjtLS0YMmSJfjtb3+L3NxcHDlyBC+88AKys7Nx/fXXJ1s8CmVIUAWAQqEkjbPOOgsffPABXnrpJbBYLBx//PF45ZVXcPLJJydbtJRgzZo1+Oqrr3D77bf3GQROoVCGH5VKhdmzZ+Pll19Ge3s7JBIJzj77bPzjH/+ARqNJtngUypCgMQAUCoVCoVAoFMo4gsYAUCgUCoVCoVAo4wiqAFAoFAqFQqFQKOOIcRcDwDAMWltbIZPJhqWcOYVCoVAoFAqFkgoQQuBwOJCbm9tnscZxpwC0traioKAg2WJQKBQKhUKhUCgjQlNTE/Lz83vdPu4UAJlMBiB8YeRy+aifn2EYtLe3Q6vV9qmZUZILnaf0gM5TekDnKT2g85Q+0LlKD5IxT3a7HQUFBZHv3d4YdwpAp9uPXC5PmgLg9Xohl8vpQ5vC0HlKD+g8pQd0ntIDOk/pA52r9CCZ89Sfmzu9aygUCoVCoVAolHEEVQAoFAqFQqFQKJRxBFUAKBQKhUKhUCiUcQRVACgUCoVCoVAolHEEVQAoFAqFQqFQKJRxBFUAKBQKhUKhUCiUcQRVACgUCoVCoVAolHEEVQAoFAqFQqFE4Q/5EWSCyRaDQqGMEFQBoFAoFAqFEsW6qnW4Y8sdyRaDQqGMEFQBoFAoFAqFEoXZa4ZaqE62GBQKZYSgCgCFQqFQKJQoLF4LVQAolDEMVQAoFAqFQqFEYfaaoRKqki0GJc0hDEm2CJReoAoAhUKhUCiUKKgFgDIc7PqiDt+9czTZYlDiQBUACoVCoVAoUVALAGU4cFl9EEp5yRaDEgeqAFAoFAqFQonC7DVDI9QkWwxKmuOy+SFR8JMtBiUOVAGgUCgUCoUSIRAKwO63UwsAZcg4rT5IlIJki0GJA1UAKJR4eKxgeczJloJCoVBGHYvPAgBQCagCQBkabhtVAFIVqgBQKPHY8wbk2/6abCkoFApl1LF4LZDz5eBxqO82ZfCEAgw8jsC4UwCaDu3H0R3bki1Gv1AFgEKJA8vVDkZE/V8pFMr4gxYBowwHLpsPLDYLItn4igHY+81XMDbVJ1uMfqEKAIUSD2cbGLE22VJQKBTKqGPx0RSglKHjsvkhlvPBZrOSLcqoEfT7UffLz5h4wvxki9IvVAGgUOLhagcjphYACoUy/qApQCnDgWscBgA3HtwHkUyGzOKSZIvSL1QBoFDi4WxDSJT6FgBCCFrvuw9BMw1YpqQvDSYX/vbF4WSLQemAFgGjDAcuq2/cpQCt3rkDE0+YDxYr9a0eVAEYQ7jdbvz617+GXC4Hi8WC1WpNtkjpS5pYAILt7bB98CHYIlGyRaFQBs3P9Rb80mhNthiUDqgFgDIcuKw+SMeRBYBhQqjZ/RMmpYH7D0AVgLShqakJ11xzDXJzc8Hn81FUVITbbrsNJpMpss8bb7yBrVu34ocffoBOp4NCoUiixGlMKACW2wQmDSwA/rp6cHNzqAJASWsOtNgwPZ/+XqUK1AJAGQ6cVh/E40gBaD1SCQDILZ+SZEkSgyoAaUBtbS3mzJmD6upqvPvuuzh27BheeOEFbNy4EfPnz4e5w/2jpqYGU6ZMQUVFBbKzs9PCBJWSuIwAAEaU+i9Af10dBMUTki0GhTIk9jdbMYMqACmD2UezAFGGjts2viwA1bt2oHT2PLDZnGSLkhDcZAtA6Z+bbroJfD4fGzZsgKhjpbewsBDHHXccSktLce+996KyshLfffcdAIDFYmHx4sXYsmVLEqVOY5xtICIVkAY5sP11deBPoAoAJX0JhhgcarVjep4y2aJQOqBpQCnDgdPqg0QxPhQAQgiO7dqB06+5IdmiJAy1AKQ4ZrMZX3/9NW688cbIx38n2dnZuPzyy7F27Vp8+OGHWLVqFebPnw+dToePPvooSRKPAVztgDQr2VIkhK+eKgCU9Kba4ASXzUJJhiTZolA6sHgtNAaAMmA+eXIPmo6EPRIIIeMqC5DN0Aan2YzCipnJFiVhqAKQ4lRXV4MQgilT4vuUTZkyBRaLBaFQCGKxGHw+H9nZ2VCr6erNoHG2AZLU9/8HwjEA/AnFyRaDQhk0B5ptqMhTjKtc4amMn/HDGXBSCwBlQDAhBrpaG5oOhxUAvzeEoJ+BRDU+FACP3QaRXA4uP32yHlEFIE0ghPS5nZ9GN13K4zQA0sxkS9EvjN+PQHMzBNQCQElj9rdQ//9Uwua3gQUWlAJlskWhpBFWgwdMkEBfYwMAuCw+cPls8IXp4Q8/VLwuJ4QSabLFGBBUAUhxJk6cCBaLhcrKyrjbKysrodVqoVQqR1ewsYzTAEhSXwEINDaCxeeDm52dbFEolEFzoNmG6fnKZItB6cDqt0IhUIDLpiGClMQxt7oglPJgaHAgFGDgsoXdf8ZLMhKv0wGhlCoAA+LZZ59FcXExhEIh5s2bh507d/a5/1NPPYXJkydDJBKhoKAAf/jDH+D1ekdJ2tFHo9Fg6dKleO655+DxeKK26fV6vP3227j66quTI9xYxWUASQMLgK+uDvziYrDYSX+MKZRB4Q8yqNQ5MCOPWgBSBavfSt1/KAPG1OpEUYUGPCEH7U2OjiJg48P9B+hUAGTJFmNAJPXLYe3atbjjjjuwevVq7NmzBzNnzsTy5cthMBji7v/OO+/gL3/5C1avXo3Kykq88sorWLt2Le65555Rlnx0eeaZZ+Dz+bB8+XJ8//33aGpqwvr167F06VKUlZXhgQceSLaIY4s0sQBQ/39KulPV5oCAx0aRRpxsUSgdWP1WqAQ0AJgyMMytLmhypcguUUBXYwtnABonAcAA4HU6IZRQBSBhnnzySaxatQorV67E1KlT8cILL0AsFuPVV1+Nu/8PP/yAhQsX4rLLLkNxcTGWLVuGSy+9tF+rQbozadIk7Nq1CyUlJbj44otRVFSEM888E2VlZdi+fTukaWZ2SnnSJAbAX1dH/f8pac3+Zhtm5CvGjZtAOmDz26gFgDJgzK0uqPMkyClVQF9jg3vcKQDUBShh/H4/du/ejSVLlnQJw2ZjyZIl2LFjR9xjFixYgN27d0c++Gtra/Hll1/irLPOGhWZk0lxcTFef/116PV6MAyDBx54ABs2bMD+/fsj+zz11FM09/9w4GxLEwsATQFKSW8OtFhp/v8Uw+q30hSglAER9IdgM7ihyZUgu1QBXW3YAjCeioB5Xc60cwFKWpSP0WhEKBRCVlZ0vvWsrCwcOXIk7jGXXXYZjEYjTjrpJBBCEAwGcf311/fpAuTz+eDz+SJ/2+12AIDVagXDMAAAHo8HkUgEj8eDQCAQ2VcgEEAgEMDlciEUCkXahUIh+Hw+nE5npA8AEIvF4HK5kXN0IpFIwGaz4XA4wDAM7HY7+Hw+FAoFGIaBy+WK2l8ulyMYDMLtdkfa2Gw2pFIp/H4/vF4v/vCHPyAzMxNbtmzBnDlzEAgEosY5mmPqjkwmG/SYOuFwOJBIJDFzNypjYgJw2SwIBgWwu4Y+TyM5JtOxaggzMkCs1vE3T8P8PKXSmLoz1udp97FW/G5hMaxWa9qNaazOU5ulDYWqQoRCoTExpu6MlXkCEHmmNBoNQqFQUsdkbHYgyPKCIyTIKJDAZrXDU+lEdrkI1nHyfjIZ2yHNyUcgEEj6PPW8zr1CkkRLSwsBQH744Yeo9j/96U9k7ty5cY/ZvHkzycrKImvWrCH79+8nH330ESkoKCAPP/xwr+dZvXo1AdDnv8suu4zodDpy2WWXRbXfeeedRKfTkcWLF0e1P/HEE0Sn05GysrKo9nfeeYfodDoilUqj2rds2UKqqqpizltVVUW2bNkS1SaVSolOpyPvvPNOVHtZWRnR6XTkiSeeiGpfvHgx0el05M4776RjGoYxHdvzfXqMqXTiuJ4nOiY6JjomOiY6JpAjR46k3JjytBPoPKXAPNlstj6/w1mE9JNgfoTw+/0Qi8X44IMPsGLFikj7VVddBavVik8//TTmmEWLFuHEE0/E448/Hml766238Pvf/x5OpxPsONlQ4lkACgoK0NDQALlcDmD0V1iMRiMyMjLoimUqjkm/D87XLkLo5t0pPU+Gbdug+8vdmPDlF/2PaSzOE32e0mpM8ebpaHM7znvmB/x0z2ngcdhpN6axOk8rv1qJK6ddiRXTV4yJMXVnrMwTgMgzNaHDDTSZY9r5eR383hCWXFEBPp+Pb9/eh/2bm3HxvXMg14jGxTy9c88dOOmyqzBl3oKkz5PdbkdRURFsNlvkOzceSXMB4vP5mD17NjZu3BhRABiGwcaNG3HzzTfHPcbtdsd85HM44SITvekxnZPaE6VSGXNhJJL4pehlsvh+Xb1d2N5y8iuVSjAMA7/fD6VSCTabDQ6HE3d/Pp8ft7iXUCiEUCiMaReJRBCJRDHtozGmnqT1mNxGKDKywSiVKT1PwvZ2qCdNipFp3MwT6POUTmOKN09GPxfFuRnQaroCTtNpTD0ZK/Pk5rmRn5kPDoczJsbUk7Eyps5nisPhgM1mJ3VMfhsbRRXaSJ+lFXmo3m5BXmEWOLyub7axPE+soB+ZObng8XhR7cmYp3iL4fFIahagO+64A2vWrMEbb7yByspK3HDDDXC5XFi5ciUA4Morr8Tdd98d2f/cc8/F888/j/feew91dXX45ptvcP/99+Pcc8+NKAIUypBwpU8GIJoClJLqVLU5EAwxcbfVGV0oyYj/EqYkD1oHgDJQTC1OqHO7nuX8cjVmn1EU9fE/liGEpGUdgKSW+rvkkkvQ3t6OBx54AHq9HrNmzcL69esjgcGNjY1Rmsx9990HFouF++67Dy0tLdBqtTj33HPxt7/9LVlDoIw10iUDUEMjRMcfn2wxKJRe8QZCuOC5H/D0pcdhcVlGzPbadhdKtOmVNm+s4w164Q15aRYgSsL4PEE4Lb4oBUAg4uLEFaVJlGr4qNm9EzkTyyBWKHvdJ+DzggmF0i4NaNJrfd988829uvz0TGnJ5XKxevVqrF69ehQko4xLnO1pYQEI6HSQ5+QkWwwKpVe2HG2H0xdEg8kFIFYBqDO6cPYMeg+nEkaPEWwWGwq+ItmiUNIEc6sLYjkfImmsC0u689PH72Pbe//FaSuvw3FnnNvrfl6nA2CxIBClV0HD8WGfoVASxdmWNgoAL5d+PFFSl//tbwWPw0Kj2RN3e227k7oApRjtnnZoBBpw2NSllpIYpmZH1Or/WIAQgq3vvI7dX36KwumzYGs39Ll/uAqwFKwEfe9ThfSSlkIZaVztKe8CxPj9CJlM4GZnJ1sUCiUubn8QGysNWDErD00Wd8x2jz+EVpsXE7Rj68Mh3elUACiURAiFGOzb1IzS41P7nTlQqn7chkPfbcRvHnoUE2bNhr29rc/907EKMEAVAAolmjSwAAT1eoDHAzcj1q2CQkkFNh0xIEcpxLJp2WgyxyoAdUYXZAIutNLxUyk0HWh3UwWAkjiHvm8BiwVMXTi2rNGW1hYUTp8FdW4+FNos2Pu1AKRfADBAFQAKJZo0iAEItOrAy8pKO3MjZfzwv306nDMjFwVqEZrM7pg0zXVGFyZoJWCxWEmSkBIPg8cAtYBmAKL0j88dwK7/1WPBryeCzRlb7yK3wwaxPBwHI9dm9u8C5HJSBYBCSWsCXsBnA6RZyZakTwJ6HXjU/YfSDYYhuPLVnbB5Av3vPAIQQrC7wQyPPwSnL4jNRw04d0YOClRiuPwhWNzRclH//9TE4DYgQ0gti5T++fmrBmQUSFFUMfYsRh67HaJOBSAzC16HHX5PrCWzk84YgHQj6VmAKJSUwWUAwALEqf2DFtTpwKUBwJRu2L0BfF/VjmMGB2YXjf4K7v5mG379/A4IuGxMypKiWCPBpKzwiphGwkeT2Y2cbt4+tUYXJmSk3wtzrNPubsdU7dRki0FJcbyuAA5sbsaFf5k9Jq14bps1YgEQSqTgi0SwtRugLSyOuz+NAaBQ0h2XMfzxn+IZMAI6PXjZVAGgdGF2+QEADabeV6mGAiEEB5ptvW4/ordjfokG/7vlJJw9PRd/Oas8sq1ALUaTJToTUK3RhRIaAJxy0CBgSiK4rD5weGxk5Kef20sieOw2iBVhBYDFYkGuzeozEJjGAFAo6Y7LCEi0yZaiXwJ6mgKUEk2nAtAYJ+B2ONhYacB5z26D3RvfxeiI3oHJ2TJMypLhhlNKcerkrjiasALQJRchJOwCRBWAlIMqAJRE8LoCEErGrgOJ22GHSNZVC0OuzYTN0HscQNgFiCoAFEr64moHJKnv/xrU6WgKUEoUI60AvLS1FoQAR3SOuNur2sIKQDwKVCI0dasFYHL54fAGMYHGAKQUroALroCLKgCUfvG5ghCIeckWY0QghIQtAPIuBUCRmYgFgLoAUSjpi6s9PSwAOj14ObnJFoOSQkQUgBFwAdrbZMWhFhvmFKlwuDW+G9BRvQNlWfEVgMIeFoDadhdyFEKI+WN3BTEdaXe3g8/mQ8ZLv5VMyujidY9dC4DP5QITCkVcgAD0mwo0nAWIKgAUSvqSBgpAyOEA43SCl0MtAJQuzG4/8lWiEbEArNlai0tOKMSJJRoc1tljthudPhidfpRlxX8BFqjFUbUA6oxOuvqfgrR72qEVa8dkUCdleAm7AI1NC4DbbgOHxwNPKIq0hVOB9mUBoC5AFEp6kwYxAAGdDmyxGGxZ+v3YUEYOs9OPWQVKGBw+ePyhYeu3yezGN4fasHJhMabmyuMqAFV6B/KUIsiE8T8ICtVitFq9CDHhWgCVOgdKtem3WjbWaXO3QStK7d8/SmrgcwUhGLMKgBUiuSJKEZZrs2A30CBgCmXskgYxAEG9HtzcHLpKR4nC7PKjLEsGMZ8T5W4zVF7ZVoflFdkoUIsxNUeOKr0TgRATtc/RNgfKe/H/B4AchRAEgMHpRyDE4H/7W7F8GrVgpRrt7nZkilO7CCIlNQi7AI1NBaCn/z8QdgHyupzwuV0x+wcDAQR8XuoCRKGkNWngAhRo1dEUoJQYzG4/1BI+CtXiYY0D2FFjwnkzw/EmhWoxeBwWatqdUftUtTlQ1ocCwOWwkaMQotXmx5aj7RBwOVhQSgNNUw2D24BMEVUAKP3jcwUgEI/NGACP3R6jAAgkEvBF4rhxAD5X+PeQKgAUSjqTDi5Aeh14OVQBoERjdvmhkfBRoBajYRjjAHQ2D/KUYV9YNpuFKTlyHG6NdgM6ou/bAgAABSoxWu0+fLC7Gb+enQ82m1qwUo3OGAAKpT+8ruCYtQC4bdZIFeBOWCwWFNpM2OIoAF6nEzyBEBxu+l0PqgBQKABASHq4AOl04NIAYEoPzK4uC0DTMCkALl8Qdm8QOQphpG1qrhyHuikAhBBU9ZEBqJMCtQgHdC5sqWrHRbPzh0U+yvDS7m6nMQCUhPC6AmM3BsAR6wIEAPLM7LipQNPV/x+gCgCFEsZrA5hA6lsAaBVgShw6FYAijXjYMgHp7V4IuGwou+X7ntrDAtBs8cAXZPoN6i1Qi/HlYRPmFKlRoBYPi3yU4cXgNlALACUhfK4AhGPYBainBQAAFNrM+AqAKz1rAABUAaBQwriMAEcACFJbkw/o9bQKMCUKbyAEtz8EdacLkCk2UG0w6G1e5CiEUQHnnZmACAln9Klqc2BChgR8bt+vkgKVCEGG4KLZecMiG2V4IYSg3dNOYwAoCeF1j+UsQL1YALRZkWrAwUAAfk94ocXrdFILAIWS1nQGAKdwdh3CMAjqdODRKsDjErs3ELfd7PKDxQKUYj6K1GI0WTxgOlJuDgWdzYssuTCqrSxLBqcviFabF0DY/7+3CsDdmaiVQi7k0Ow/KYrdb4cv5KMWAEq/hAIMgr7QmI0B8NisUUXAOpFnhmsB6KqP4r933YL3H74XhJC0rQIMUAWAQgmTBv7/IbMZJBAAlyoA4w5fMIQFj2xCbY8MPEBYAVCKeOCwWchTiRAIMTA4fEM+Z5vdG+X/DwBCHgcTtdKIG1BVmwOT+/H/B8KWg0+vnQ4RnzNkuSjDj8FtgJgrhoRHC7RR+sbrDi9EjNUsQG6HHSJZPBegLJiaGvD+w/dg6kmnwGk24tjPP3ZUAU5PC8DYnEEKZaCkQwpQnQ4ctRpsobD/nSljigPNNjh9QdS2u1DSw9/e7PJDJeEDAARcDnIVIjSYXMhWDO0+0dk8yFaIYtqn5sqxdlcTPv6lGRsrDXjlqhMS6k/Eox//qQqtAUBJFJ8rCJ6AA04/bn/pCCEkbh0AAFDl5mHqyafh+LN+BW1hMfhiCX54/23kTZ4KoYRaACiU9IFhgFA3lwqXMeUtAAHq/jNu+bnBAgBxA3w7U4B2UqAWDUsgcGcMQE8Wl2lhcHhRliXDRzcuwEmTUvu5ofSPwWOgCgAlIbzuAASS9F47rt+3B1/85/GYdp/LBSYUihsEzOMLsPz626AtLAYAzDh9ObwuJ47+uI1aACiUtGLfO8DRr4DfvB3+250GCkBrK3h5uckWg5IEfq63QMTj9KoAqMRdCsBwpQLV2bxxrQgrjsvDiuNoMO9Yot1NawBQEsPnSv8qwIb6Whz7+UcwoRDYnC7LpNtuA4fHA18Ua/nsCZfPx4nnX4JvX36WxgBQKGmF6RjQ+GM4/z+QHi5Ara3g5VIFYLxBCMGeRguWT8uK+2FvdvmhkXYpAEUaybAUA+vNAkAZe9AqwJRE8bqCEIjTWwFwmNoR9PnQ3lgf1e6x2yCSK6Iyn/VFxalLoMzOgVSdnpXNqQJAGZ/YdeFVf4cu/Hc6VAGmCsC4pNbogssXxJnTc+JbANzhGgCdFGnEqG0fWipQbyAEk8s/5DgCSuri8Dvw/tH38frB1/Fz28/UAkBJCJ87AGGauwA5TCYAgK7qSFS7226FOE4AcG9wuDxc9fizmDBrzrDKN1pQBYAyPnG0hv+r2x/+b5pYALhUARjz7G+24uz/bEUgxAAAfq43Y2a+EqVaKRrN7kgO/k7MzmgXoIpcBY7qHfAHmUHLYLD7wGWzkCERDLoPSmrz3N7n8ObhN3HQdBAztDOwKG9RskWipAFjoQqww9SOjIIitFZHKwAeuz1uCtC+4PL5CVsMUo30VuMolMFi1wHiDEC/H5h8RlqkAQ226qgFYBxwuNWOQ612fLynBRefUICf6y2YXaxCvkoEX5BBu8OHzG75+WNdgMQQ8NioanOgIm9gL7NOdDYPsuRCsNnp+WKj9I0/5MfntZ/jX6f8Cydkd2VxYpjBK42U8YHPFYQwzV2AnGYTZi07G4e/3xTV7u5wARovUAsAZXzi0AGTlgG6fUAoCLjNKW0BYNxuhKxWqgCMA5osbmhlAjy9uRqBEIPdDRbMKVJByOMgSy5AkyXaDcjsjrYAsFgsTM9T4ECLbdAy6OPUAKCMHTY1boJSoMScrPR0XaAkTijIwGH2Dlt/6Z4FKBgIwG2zouzEhbAa9HDbrJFtbrsVYrk8ecKNMlQBoIw/vHbA7wTKloctAB4zABK2CKQogdZWsEQicJTKZItCGWGazB5ccWIReGw2Xt5ahzqTC7OLVADCGX56xgGE04BGu+pMz1dgf/PgFYDeMgBR0pMD7QfQ7GiO/P1B9Qe4YNIFaeu6QEmcXV/UYf1LB4etv3TPAuQ0m8DmcKDOzYc6Jw+t1Ucj2zx2O0RyZfKEG2WoAkAZfzh0AE8MTDgZsDYCxmpAIAd4qfvB0xkATF/YY59mixtFGjFuOX0i/rnhKCZqpVB2rPAXqMVoNHki+4YYAqvbD1WPF/KMPCUOtFgHLYPe5kW2PHWfB8rA+MfOf+Cq9Veh1dmKJkcT9rTtwXml5yVbLMoI43H6sX9T8/BaANLcBchhaodUrQGLzUZOWTl0VZWRbe5eioCNVagCQBl/2FsAWQ4gVgPyfKBmU8r7/9MMQOOHJosH+Soxzp2Ri0K1GHOKVZFtPS0ANk8ADEGMBWBGfjgQ2BsIDUqGcBVgqgCMBUJMCFWWKpSry7Fqwyq8cuAVLM5fjAxRav/mUYbO3m8aocwSw2P3IxQYnvgOX5q7ADlNRsg04Xs/t6w8KhDYY7PSGAAKZUxj1wHyjo/pnBlAzcaU9v8HgEALVQDGA95ACO0OHwrUInA5bKy5ag5uO70ssr1nkS+zyw8hjw0RnxPVT75KBImAi6N6x6DkCNcA6L8YDiX1qbfXAwCeOvUpTNdOx4fVH+KCSRckVyjKiOO2+7F/SwtO/k0Z2GwWnFbfsPTrdQXT2gXIbjJCqu5QACaVQ19TDSYUXihxO+zUAkChjGkcrWELAABkzwBa96a+AqCjGYDGA80WD4Q8NrTS8Ip+qVYatRJf0MMCEM//H+gKBN4/yEBgGgMwdjhiPoIyVRl4bB7+uvCv+Meif2BB7oJki0UZYX7Z0ID8MiWySxSQKAVwWobuBsSEGPg96V0IzGnusgBo8gvBZnPQcuQQXFZLOA3oOFIA0teOQ6EMFrsOkHcoADkzAJC0cAGSLj452WJQRpgmixv5KnGvsR6FajH0di+8gRCEPA7MLl9UEbDuTM9T4ECzFUDRgGQIhBi0O300C9AY4Yj5CMrV5QAAHpuHs0vOTrJElJEm4A/h4HctWHHn8QAAqVoAp2XoFgCfJwgAaV0IzGEyobBiBgCAxWajYNoMvP/wPQAAvkgEiVLV1+FjivSdRQplsDh0QMbi8P9nh38IUt4CQGMAxgXNZjfyVb273milAgi4bDRbPJiYKYXZFYCqFwVgRr4CT31bPWAZDA4fWAC0MloEbCxQaa7E8uLlyRaDMorojlkhlPGQWSQDAEhVwmGxAPhcQXB4bHB7uBymEw5Te8QCAADn3Xk3QoEA2Bwu2Gw2WOzx4xgzfkZKoXRib+2yACjyAZEqpRUAEgggaDBQBWAc0GTxoEAl7nU7m81CgVocqQVgdvmg6c0CkK9EtcE54EBgvc0LrUwAHoe+HtIdQkjYAqAqT7YolFGk+YgF+eXqiCVRqhweC4DXFYBQnN7rxk6zCTJ1lwLAZnPAEwjB4XLH1cc/QBUAynjEoQNkHR/TLBYw8zIgZ1ZSReqLQFsbwGaDm5mZbFEoI0yzxY0Cdd/Bt90Dgc2uQFQRsO7kKoRQing4rLMPSAa9zYtsGgA8JtC79HD6nZikmpRsUSijSPMRC/Ind7myDJcLkNcVgCCNA4A7i4DJMlJ3wW80oQoAZXwRCgBOQ5cFAADO+DtQOC95MvVDoKUVvKwssDjpa3alJEaTuW8LAAAUqERoNLlhsHuxs97Uq6sOi8VCRZ4CBwcYCNxkcSNPSf3/xwJHzEcwQTEBQi6dz/GC1xWAsckRrQAMlwuQO70zAIWLgHHHVaBvX1AFgDK+cLaF/yvNSq4cAyCgawUvJ6f/HSkDZneDGa9tr0u2GBE6g4D7okAtxreVbVj6r+9RkiHFZfMKe913crYM1W3OAclQqbOjPFs+oGMoqUn3AGDK+KC1ygpllhgSZdfCgFQ1TBYAZwCCNHYB6l4EjJICCsCzzz6L4uJiCIVCzJs3Dzt37uxzf6vViptuugk5OTkQCAQoKyvDl19+OUrSUtIeuy788c9Jn1WMQGsreHnU/38k2FptxP/264alL7c/OKTjHd4ArO5Avy5AFXkKBEIEj184A/+59DgoRL3fyxO1UlQbBlYL4HCrHVNzqAIwFqg0V1IFYJzRfMSM/HJ1VJtUJYTXGUDQP7jCgJ143YH0tgCYjJBpNMkWI2VIqgKwdu1a3HHHHVi9ejX27NmDmTNnYvny5TAYDHH39/v9WLp0Kerr6/HBBx/g6NGjWLNmDfLy8kZZckra4miNdv9JAwKtreDSAOARodXqgdE59JWxRpMb8x/ZhA2H9IPuo9nigUzA7fODHgBOLNFg+19Ow7Jp2f32OTFLimOGxC0A3kAINe1OTM2lCsBY4Ij5CKaopyRbDMoo0nzUgvzy6FSWIikPbC5ryFYAnyuY1jEAdpMRMg31/+8kqQrAk08+iVWrVmHlypWYOnUqXnjhBYjFYrz66qtx93/11VdhNpvxySefYOHChSguLsbixYsxc+bMUZackrbYuwUApwlBmgJ0xGixemB0DO2l6A2EcMPbu8Fls/D1obZB99NkdiNf3XsNgMEwMVMKo9MPi8uf0P5H9Q7IRTxaA2AMYPVaoXPpMFk9OdmiUEYJp8UHa5sbeWXKqHYWm9WRCWhocQBeVyCtawA4zUZI1dQC0EnSZtLv92P37t24++67I21sNhtLlizBjh074h7z2WefYf78+bjpppvw6aefQqvV4rLLLsOf//xncHoJkPT5fPD5ul7wdns4IwbDMGAYZhhHlBgMw4AQkpRzUwCWrRmQZYP0c/1TaZ78La3g5uSkhCypxlDnqcXigcsfgssbgGiQua0f+PQgBFw2nrpkJm5fuw+BYAgc9sA/4hvNLhSoRMM6z1I+B1lyAara7DihWB2z/Z2fGnFcoRJTOlx+DrXaMCVbDkIICCHDJkcqPU/jhUpTJXIluZDxZAlfdzpP6YOuxgqWJPo7pumICdpCGXhCTswcSlUCOMzeIc2t1xUAX8RN2/vDbmxHYcXMUZU/Gc9UoudKmgJgNBoRCoWQlRUdjJmVlYUjR47EPaa2thabNm3C5Zdfji+//BLHjh3DjTfeiEAggNWrV8c95pFHHsFDDz0U097e3g6vd+hR8QOFYRjYbDYQQsCmgSijjqK9DkH1JLh6cTPrJFXmiRCCQGsr7AJBvzKPR4YyT4QQtFo9AICjDa3IVQy88NWmagu+OaTHG5dNgVoSQiAYwncH6lCRIx1wX1UtZqgF6NUFcrAUKvn4pUaHInF0jEIwRPDo+iNYUqbCn08PVwveXdOGYiVn2GVIledpPPF93fcok5UNaC7pPKUHhBB89tQRVJylBI5DZK6O/aKDqoAfd845QqCt2QSVYfDzamt3IUAkw/77MFpY2/TInzlnVOVPxjPlcCQW95VWthyGYZCZmYmXXnoJHA4Hs2fPRktLCx5//PFeFYC7774bd9xxR+Rvu92OgoICaLVayOWj7+fKMAxYLBa0Wi39gU0CrIAFJGcSJP3k1E+VeQq2t8MaCCCrogJsAa3M2pOhzFO7wwd/iEAm5AJCGTIzlQM+/4HtBlwytxAVpfkAgMWTM7HXEMRpMwdes8Hsa8KCUg0yh7new7Q8I9q8rJh+tx8zwh1g8EODAxkZWrDZLNRba3DZvMJhlyFVnqfxxN6f9+KSyZcMaC7pPKUHAX8ITIjAUh9C5vJMsNlsBHwh6I4exa/+MAvaTFnMMRk5TvjcgUE/2z53AHajD2WzCiCWx689kup47DbklZQO++9bXyTjmRIKE3PhTJoCkJGRAQ6Hg7a2aJ/ZtrY2ZGfHD27LyckBj8eLcveZMmUK9Ho9/H4/+PzYm1IgEEAQ58OJzWYn7QeOxWIl9fzjGocOLHkukMC1T4V5Cun14GRkgCuihZl6Y7DzpLeHq+hqZQKYXIFBzXOt0YULZ+dHjl0yNQsvfleLPy4PZ16p1NkRYggq8vrPO91s8aBQLRn2+21ilgxfH9LH9PttpQG/Pj4PXx3U47DegYpcBSr1DkzLU4zIPZ8Kz9N4weq14rD5MBbmLRzw9abzlPoEfQEAQOsRB0JBAq6Qjfr9Bsg0QmQWyePGEcnUQphbXYOeV0O9E/IMEaRpWiPE63LCY7dBmZU96vf2aD9TiZ4naU84n8/H7NmzsXHjxkgbwzDYuHEj5s+fH/eYhQsX4tixY1H+TVVVVcjJyYn78U+hREFIOAhYnj4BtQEaADxitFo9yFOJwgrAIDMB1RldKNF2ufssLtPiaJsDOpsHLVYPLn/5J9z49h74g337ZIYYggaTG0WavmsADIZJmbGZgAgh+OZwG86anoNTJmfim8NtaDC7EQwRlGoH7r5ESS126HZgknIStGKa8WQs4nMHweWxIVbw0HDABAA4skOHySdm95pEQKoeWjEwXY0VOaXpW0CrufIQVLn5tAhYN5Kq4t9xxx1Ys2YN3njjDVRWVuKGG26Ay+XCypUrAQBXXnllVJDwDTfcALPZjNtuuw1VVVX44osv8Pe//x033XRTsoZASSe8NiDoAWT9p09MFQItLbQGwAjRYvUgVyFChlQwqFSgDm8ABocPJRmSSJtSzMfxhUp8eUCP3//3ZyyflgUBl433djX22VeDyYUQIZjQra/hYlKWDDqbFw5vINJ2qNUOuzeI+aUaLJkSVgAqdXaUZUvB49CV33Rne8t2LMxbmGwxKCOE3xOEQMxFfoUCx342wGnxorXKislze3+3hbMADT7jmb7GltYKQNOh/SicNiPZYqQUSf2lv+SSS/DEE0/ggQcewKxZs7B3716sX78+Ehjc2NgIna6rSE9BQQG+/vpr7Nq1CzNmzMCtt96K2267DX/5y1+SNQRKOuE2AWweIEifHOfUAjBytFg9yFWKkCHlw+hMLE1md+qMLqjEPKgk0dbH08qz8MiXlRDzOXjovAr8aflk/GdjNVy+3guFHdE7UJYlBXcEPr7VEj7UEj5q2l2Rtg2H9Fg8WQsBl4NTJmfimMGJDYf0tADYGIAQgh9af8DC3NRTABgmhLq9u9FceRDGpgYEA4H+D6LE4PMEwRdzUVAhR+MhEw5saUF+uSqq+m9PpGoBfO4gAr6BFwMLhRi01duRXZLGCsDBfSisoApAd5IeBHzzzTfj5ptvjrtty5YtMW3z58/Hjz/+OMJSUcYkHgsgVgPDmGd9pAm0tEJy8qJkizEmabV6MHeCBoEQgwMttgEfX2d0xV2xP2t6NjZWtuG5y2eDz2Vj6dQsvPh9LV7eWofblkyK21elzo7y7JH7+J6YKUV1mwOzCpQAgA2H23DDKaUAAIWIh3klany2rxUPnDN1xGSgjA5Vlio4A04cl3lcskWJQVd1FJ8+/ldIVGq4rVbMXHYWTrnyd8kWK+3wu4PgC7mQZQigypHgl28asWRl3wXfhBIeODw2nBYvVNkDszSamp3gcNlQ5wy/hXI0cNttMDY1In/q9GSLklJQWy9l/OA2A6LYXOipTKC1hVoARogWqwd5SiEypIOLAahpj/b/76RII8EHNyyAVhZejWOxWPjLmeVYs7UW5l4KclXq7JFc/CNB9ziAJrMbNe1OnDK5KxPGkilZYAgwNTd9V/goYba3bse87HngcVKvYqu9vQ3ZE8uw6plXseiyq2AzDL5y9njG1+ECBAATZ2eCy2djwsy+4z1YrI5iYOaB/9bpjtmQNUEB1iDqm6QCTYcOIKOwiPr/94AqAJTxQ6cFIE0ghCDQ0gpeXl6yRRmTtFq9Q3YBKtEmtiJ2QrEaxRlibD9mjLu9UufAlJzY1H3DRacC4PGH8MCnB7G4TAuFqOsDcenULMgEXJSPoAyU0eGHlh9S1v/fbmyHTBP+UJVqMuAwmZIsUXri9wTBF4UVgIpT8vCr248DL4FChlK1AI5BBALr0t7/n7r/xIMqAJTxg8cMiFTJliJhGJsNjNsNXi5VAIYbjz8Es8uPPOXgg4Br251RAcD9MSNfiYNxXI1s7gBarJ4R9b+fmCnDoVY7Lnv5R7j8Ifzz4llR2/NVYuy6bwnkwtRbNaYkTpAJYo9hD+blzEu2KHGxtxsg14YtTzJ1Bpzm+AoxpW987i4FgMfnIKs4sd8OqVIIl3Vgv3WEEOjTPANQ48H9KJg2M9lipBxUAaCMH9zppQAEWlvBVijAkaan32Uq02L1QMBlQ91RB8DqDiAQik3V+d7ORvxp3b6YdkJITArQ/piRp8D+5lgF4IjejhyFEErxyKUynpQlhd7uRZZMiP9eMzdq9b8TIa//FURKamPymBBkgsiX5SdblLjYTe2QZ3RaADRw2awIBWkg8EDxeYIQiAYewilRCeAcoALgMHnhcQSQOSE9EwQ4TEZY23TIn1KRbFFSDqoAUMYPHnNauQD5aQrQEaPV6kGeUgQWiwV1RxafeP75P9WZ8fUhPYI9lIM2uw+eQAiF6sTz9lfkKXCwxQaGIVHt4QDgkXW9yZIL8f518/Hs5cfTD/0xjMFtgFqoBo+dmpYce7sB8oywBUCiVIHFYsFlsSRZqvTD7w5EYgAGglQpGLAFQF9rQ0aBNCEXo9HC43SgeucPCe3bdGg/sksmQSAe/hor6Q5VACjjhzQLAg7SFKAjRmcRMADgcdhQinlod8S+GCt14Xz5+3qs3Ne2O5GvEg3oY7osSwZfiEGD2d3jHI4RDQDuZO4ENThpGsRHSQyD24BMcWb/OyYBQggcxvaICxCbzYFEpYbDRN2ABorPEwJfOPAPcskgagFY29xQ56aWFXrr26/hs3/+HQe3fNvnfqFgAIe+34QC6v8fF6oAUMYPaWYBoDUARo7OImCdxIsD8AVDOGZwYmaBElur26O21RhdmJAxsIq5fC4bU7Jl2N9sjWqv1I9sBiDK+KHN3YYscVayxYiL1+lAwOeFLKMrW41MpYGDxgEMGL8nAP5gLACqgVsAnBYfpCrhgM81Uhjqa1G5dQuW/v4WbHz1eTQd2h93P7/Xg48ffRhepwOzz14xqjKmC1QBoIwf0swC4G+hKUBHipZuFgAAcTMBHTM4IeJxcNncAmytjv5IqWt3DSgAuJPp+YqoQOBgiMFR/ehYAChjn1S2ANiN7RBKZeALu547qUYDJ7UADBife5AxAEoBvM4AgoHEi4E5zF5IVb0XGBtNCCH47s1XMOuMczDj9OU49arf47N//h0WXUvUfl6nE+sevgeEYXDxA4/Q9J+9QBUAyvghzdKABlppCtCRorWjCnAn8SwAna45J5dpsbfJCpunK1ix1uhEaYIpQLszvUcgcL3JDRYLcQuKUSgDJbUVgC7//05k6gw4zDQV6EDpngZ0IIhlfLDZLLisiac9dlp8kKpTwwJQu2cXDA11mHf+xQCAGacvx+QFi7D1nTei9tv12QfgCYQ4/y8PUt//PqAKAGX8kGYWgGDLyLkAfV/VjlarZ0T6TgdarB7kKrteavGKgYWLc8mQoxChJEOCHTVdK5V1g3ABAoDpeUocarVHAoErdXZMzpJR33zKsJDKCoCj3RDl/gOEawFQC8DAGWwWIBabBbGSD5c1sVoAhBA4LalhAWBCIXz/1qtYcNFlEEq6fnvnrrgItXt2wqrXAQACXi/2f7se8y+6DFxeagbDpwpUAaCMD4I+IOBKGwtAyOlCyGYbMQXgsa+P4NVtdSPSd6pyRG/Huzsb8f6uJuhtXuQru1aG4rkAHW7t8s1fNEmL7zvcgHzBEJrM7oSLgHVnUpYU/hCDOpMLAPBzvRnl2dT9hzI8pHIMgN3YDrk2WgGQqTVwWKgFYCCEQgyCfmZQMQBAuBZAoqlAfe4ggn4GshSIAajctgWhUBAzTj8jql2ekYmJcxdgz/rPAACHvtsIuTaLpv1MAKoAUMYHbnP4v2lSByDQ2gKWWAyOUjki/Tea3Fh/SA9CSP87jwEYhuDa13/Gup+b8Nm+VpxWnomcHhaA7i5AhJCo4NxFZRn4vqodVrcff1q3H1qZANnygb8UeRw2pubIcaDZhm3VRqzb3Ywr5hcNfYAUCkbOAvDFs/vQcHBoH+p2owFyTTwLAFUABoLfEwSAQVkAgIFlAnJavOCLuINyNxpOQsEgdnz4Lub/+lJwuLGyzDnnfBzc9A08Tgf2fPUpZp+zAiwWtar2R3JnlUIZLTxmQCAHOOlhEgy0toKflzsiP2I2dwB2bxD+EINDrXZU5I39AKkfa03wBkJYe9188Dix6x4ZUkFUGlC93Qu7J4DJHfn5T5yggcHuw2n//A7HFSjx+c0ngT1It53peQpsOKzHjhoTHjpv2ri4/pSRx+l3wh10I1My/AqAWe+GqcWJogrNoPtwGNshX3ByVJtMnQGnxQSGCYHNTp0886mMzx0Em8MChze49duBZAJymn0p4f5z+PtNYLM5mHLSKXG3Z5dOQuaEUvzvX/9AwOvF5Pknja6AaQq1AFDGB2lYBZg7Qu4/jWY3VGIelkzJwvqD+hE5R6rxwe5mrDguL+7HPwBopHyYuhUCq9TZMSFDEsnzL+JzcMMppbjnrCl4+ao5yBzE6n8n0/MV+PKAHmdOz8FFcwoG3Q+F0h2D2wARVwQZb/iLynkcfjhMifmN94bd2B4TBCxVq0EYBm6rdUh9jyf8niAEYu6gF4ckSgFcA7AAJDsFaCgYwI8fvYf5F14KNqd3JXH2OSvQeHAfZi0/Bxxueiz0JRuqAFDGB+lWA2AQKUCbzG68/VNDv/s1mt0oVItxZkUO1h8a+wqAwxvAlwd1uHB2fq/7ZEgFMLv83YJzY1Nz/mFpGS6cnT9kq8zJk7S4dG4hVp87dUj9UCjdaXO3IVOcOexWw2AghIA3BPsQFICA3we3zRoTBMzh8iBWKGktgAHgG2QGoE6kKkHCMQAOiw9SdXItAIe2bARPIMTkBYv63K909lzMXXERZi49a5QkS3+oAkAZH4xCBiBCCPwN/X+AJ0JQ3wZeds6AjvloTwvu/fggdjdY+tyv0exGgVqMUyZr0Wh245jBMRRRU54vD+hQqpX2mWtfKxMgxBBY3GErwGHdyBXnylYI8cgF0yHgUpcHyvAxUv7/Hkc4/a3DPHgFwGE0gsMLf+z3REbjAAaEf5A1ADqRKAfgAmTxQpZkF6DmyoMoX7i4XxcxNpuDRZdeBaF04NnZxitUAaCMDzyWEXcB8lVWonbF+SCBQP8790PQZAI3I2NAx/zSZEFJhgT3f3IQIab34N5OC4BEwMXJk7Rj3g3og93NuKiP1X8AEPI4kAq4kUxAlTo7ptLiXJQ0YuQUgPAz4TB5Bp00IFwDQBvXOiFVZ1ALwAAYsgVAKYDL1mXt7ItwDEByXYCcZhNkmoG9CymJQRUAyvhgFFyAgkYjiMcDX03NkPsKmYzgZiQecMcwBL80WvHohTPgCYTw1o+9WyKaLWEFAADOrMge025AdUYX9jXZcN6s/guqZUj52Ndsxfs/N6He6KLVeSnDhqHBDn2drf8dh0CnC9Bw43EEIFULEPQz8LoGt7jhMLZDlhFfNplGAwetBZAwnTEAg0WiFIAwBB57/8XAUqEGgNNihkSVPu676QRVANKEpqYmXHPNNcjNzQWfz0dRURFuu+02mHqYTrds2ULTX8XDbRlxF6BQRyCb9+DBIfcVbDeCM4BVjzqTC95ACDPzlXjwvGl4YsPRqKw23el0AQKA06dkolLngM42NouC7agx4YQJKqgl/H73zVGIcO/HB7B2VxP+fEY5suTJz35BGRtsXVuF/ZuaR/QcBrcBmaIRUACcfsg1IgilvEEHAserAtyJVJ0BJ60GnDA+99AsABwuGyIZr99UoIQhKVEF2GkxQ0oVgBGBKgBpQG1tLebMmYPq6mq8++67OHbsGF544QVs3LgR8+fPh9lsTraIqc8oWABClrDvvefQoSH1QwIBhKxWcLWJKwC/NFoxPU8BPpeNxWVanDQxA498VRmzXzDEoMXiiVgAlGI+ZuQrsK16bK7A6W0e5ClFCe37whWzsX/1cnx4wwJct7iUKtJJosnRBLN37PymtTc6oK+1DzmLTn+MmAuQPQCRjA+ZWjjoMTiM7ZD3CADuRKbJoBaAATDYKsDdSSQOwO3wgwmRpFoA/B43Al4PpKrBp5+l9A6tA5AG3HTTTeDz+diwYQNEovDHTGFhIY477jiUlpbi3nvvRWVlJb777rvIMZ0fL6+99hquvvrqZIidWoxCEHDQYgFbJoP34NAUgKA5rEhw1YnLu6fRguMKlZG/7z9nKpY++R12nmDG3Ald/ehsXhAAOYquVZ1Fk7TYWm0ckykp2+y+hAt2KUQ0ddxo833z93AH3cgWZ8MVcOHdI+9ia8tWFMuL8eZZb0LOT383rAPfNUOTJxlSEG0ijGQMgFjGAyEEVoMDjQd1KKyYOaA+7O0GFEybEXebVKWBk8YAJIzfHYQyK7FFjd6QqoRwWvu+H50WH0QyHri85CUrcFrM4PL4EEgGXnWd0j/UApDimM1mfP3117jxxhsjH/+dZGdn4/LLL8fatWvx4YcfQqfT4cMPPwQA6HQ66HQ6XHLJJckQO/XwmAHxyAYBhyxWSObPh+/oURB///6VvRE0toOjUIDFS/yD9JdGK44v7BpfrlKEW06fhPs/OYhAiIm0N5ndyFOKwO2WD//kSRnYdsyYUFBYuqG3e4eUs58ycoSYEO7ccide3v8y7txyJ+7ddi/KVGX4+tdfo0BWgD9s/gMCoaEH1CcTryuA6p1tOHFFKVw2H0JBpv+DBkGQCcLkNSFLnDXsfXucfghlfHB5Nvz00T+w7q/3wmZoG1AfDpOx10BOmUYDp9kEwozMtRlrDDUIGIi2APg8QZhanDH7pEINAKfZDIlaTa2xIwRVAFKc6upqEEIwZcqUuNunTJkCi8WCUCiE7OxsqDtWjbOzs5GdnR2jNIxbRsECELJaIZo5Eyw+H75jxwbfj8kEzgDcf5y+II7q7TiuMFrBuWbhBIQIwevb6yNtnRmAujOzQAl/kMFhnX3QMqcqbXZvwhYAyujS7GxGiITw3jnvYePFG7Hlki249fhbkS3JxmMnPwaH34EHdzw46MwzqcCRHTpoi2QonKYBm8Xq1+96sBg9RhBCkCEe/mwpHkcAVt0eHNr4L4jkZcifUoGa3T8NqA+XzQqJMv4CjFStQSgYhMcx9n5/RgL/MLgASZWCyL245e0jWPePn6GvjQ5ST4UqwC6Libr/jCBUAUgT+nsJ8vn9BzmOWwgJpwEdhRgAjloN4bRpQ4oDCBpN4A4gAHh/sxXZciGyFdEfunwuG3/9VQWe+rYKlo4qt02WrgDgTngcNuaXarB1DMYBtNm9MdeFkhocsxxDiaIEXHbsx4yYJ8Yzpz+DTY2bcMg0NJe6ZEEYggPftWD64nyw2SxIVIIRcwMyuA1QC9XgsYffjc1t8+DItvcx59xrIVIsxqR5C1Dzc+IKQMDnRcDriVsDAAB4AiGEUhnsxvZhknhs43MHwRcPbZ47LQBNR8xoPGjC8csK8cWz+2Ftc0f2SQULgMNsogHAIwhVAFKciRMngsViobIyNqATACorK6HVaqFUKkdXsBQkxBBc/vKPsHt7uA14bQAJjbwFwGIBR6WEcNq0IcUBBI1GcDWJr3r80miNWf3vZH6pBhV5Cqzb3QQAaDR7YiwAQNgNaGv12HoBewMhWNwBZNJsPilJlbUKk1STet2eKc5ERUYFKs3xf/tSnfqDJgR9IZQcFw5+HUoQbX+MlP8/AFgNRzoqsS6Ew+xF6ex5aK48CK8r1m0kHm6bDSw2G0JJ7wWaMgqL0N5QN1wij2mGxQKgEsBu9GLre1WYe24J5p5bgikLc/D503vh7kgP6rSkggXADOkAYuEoA2NICoDRaITdTs12I4lGo8HSpUvx3HPPweOJTtWo1+vx9ttv4+qrr8aZZ54JqVSKM888EwAglUohlUrx9ttvJ0PspGDzBLD9mAm/NFqjN3jMAJsLCGQjev6g1QKuSgVRxTR4h2ABCJmMA8wAFB0A3JMr5hfhrR8bwTCkIwVorFvYokla/FxvgccfGozIKYnB7gOHzUKGhCoAqcgxyzFMVE7sc59ydTmOmo+OkkTDByEEe9bXY+aSAnC44desTCMcMQtAm7ttRPz/CSHwWA6hdM5CyDPE8HuCEErV0OQVoO6XnxPqw22zQqxQgsXu/XMju7QM+pqq4RJ7TDNcMQAOsxdsDgvTTwnXSJm/ohRZExT44tl9CPhCYQuAOhVqAFAXoJFiwAqA1WrFTTfdhIyMDGRlZUGlUiE7Oxt333033G53/x1QBswzzzwDn8+H5cuX4/vvv0dTUxPWr1+PpUuXoqysDA888ABefvll7N27Fy+//DIAYO/evdi7dy/OO++8EZcvGAgg4B8Z39aBYPeEV/73NVmjN3TWABjBQCJCCEJWGzjKDgvA0aNgBhkIHDSaEq4BEOooANabBQAAlk3NhicQwvfV7WiKEwMAAEUaMTLlAvxUN3bycbc5vMiUCcBm0wCyVKTaWt2nBQAAJqsnp6UFoLXaCovejYqTuwrQydQjpwCMlAXAbXcj6DuGKScthkDMA1/EDVsBTjixXzcgnycIt90Pt90KsVzR577ZpZOgr6keTtHTnrY6e8z9QhgCv3dohcCAsAWAw2Xj5N9MBrsjIQSLzcLpV04BT8DB1y8fhMPkhSzZQcC0BsCIMqC7yGw2Y/78+WhpacHll18eCUw9fPgwnn76aXzzzTfYtm0b9u/fjx9//BG33nrriAg93pg0aRJ27dqFBx98EBdffDEMBgMIIbjgggvw5ptvQiwWQyoNm1ebm8PFZiZO7HtlbTj56eP34XU6cPo114/aOePR6foTowCMQg0AxuUCAgFwVCqwZTKwhUL4qqohqpg24L6CRiMkCxYktO+He5ohFnAwI7/3Fyyfy8alJxTg+S01MLv8cRUAFouFRZO0+L7KiFMmj4wrwWijt3mRRQOAUxJfyIdGeyMmKftWAKaop6DaUo0QEwKHnbx0hL3RW0723esbMP2UfPCFXdtkGiF0NSNTDdjgNqBYXjzs/R7dsQMsthR5k8Pz1OnGVDp7HtZ9eS9CwQA43Pj+6Hu/acShrS2YOt/Sq/9/J1klk2BsrEfQ7weXxrMBAD5/Zi98riA0+VJMX5yHaYvy4PeFAIIhuwDxhVysfGwhBD1iCTg8Ns68fjo+emIPXDZ/0ouAhYOAqQIwUgzIAvDwww+Dz+ejpqYGL774Im6//XbcfvvteOmll3Ds2DH4/X5cccUVWLp0KRSKvjV+ysAoLi7G66+/Dr1eD4Zh8MADD2DDhg3Yv39/skWDqbkhJfI42z1BsFjAvmZrdND0aGQAslgADgdsmQwsFitsBRikG1AwQRcgbyCEJzdU4U/Ly8Hj9P0oXzqvED83WCATcnvNd39cgRKVYygTEM0AlLrU2eog4oqQLcnuc78ieREYwqDR0ThKkiWOw+zF63/eBp87OubI0GCH7pgVM07Lj2ofSQuAyWNChmj4MwBV/7QNQtm0yCqxTCOE3eRFVslE8EUiNB3uveq52+EHh8fG7vWV4PD6zuOuyMwCXyxBeyONAwAAhiHwuYK45L65mHFqPr5/rwo+TzB8r7EAnmDoynDPj//u7efcPBNTT8qFRJE8ZYwQQl2ARpgBqZGffPIJXnzxRWRlxfoaZmdn47HHHsNZZ52F1atX46qrrho2IUeC7rELPB4PIpEIHo8HgUDXj7lAIIBAIIDL5UIo1OUbLRQKwefz4XQ6wXTLXSwWi8HlcmPiIiQSCdhsNhwOBxiGgcPhgFAohEKhAMMwcLlcUfvL5XIEg8Eolyo2mw2pVAq/3w+v14s777wTWVlZ+P777zF37lwEAgH4fD5UVFSgqqoKHo9nUGNqOFoJqUoDnlCY8Jh0DQ3giYSw2+2QyWSDHlMnHA4HEokEPp8PPl+Xa1F/89RmsqFUwUZtuw1HGttQmqMOF1DbdQDlPj6UHWMYiXnyNDXBI5PB5XJBKpWCM20a9N9tAefMMwY8Jpu+DRpZOF6hr3vvxe+qoeQGcXKRBMFgsM8xSVgBnFwsRovVC4fDEXeelNwgWm2eEZ+n0XqeGvRGKLnh/tJpTN1J5vM0kvN0xHgEhfzCqPH2NqZJykk4qD8IDavrQyAVxmRoscPhdODAjjrMPm1SZJ62fnIIRcfLEWC8EIEfGRPh+dHeZoLD7oBMLhvWedKb9RDmh3+Dh2ueBFwOmit/gazgisgxbFEQDrM3nHZ66gxs+3AtJJk5EHXEnHUfk7ndgrL5GtT/zEZ9pR2tDe2RoNJ4Y5LnFqCx8jByJk4e989T0Evg8bvAEgaQP10KgZKgbp8BmjwpGLYPDmfXXGm1WoRCoeEdExeYfV4ufH5f0n73XHYbXG43mG7Hpdo8JTKmEZ2nXsaUcGwuGQB8Pp80NTX1ur2pqYlwOJyBdDnq2Gw2AiDq37XXXksIIeTaa6+Nal+9ejUhhJBly5ZFta9Zs4YQQsjUqVOj2tevX08IIUQmk0W1Hzx4MO55bTYbOXjwYFSbTCYjhBCyfv36qPapU6cSQghZs2ZNVPuyZcsIIYSsXr16yGMKBgIkR6lI2zFNn3dyzJgc3gDJzlCO+pie/8c/hjSm++68s897b3L5lGEfk1QqI5Pu+ZJ8+eVXo37vjdTzJBRLkvY8jcXfiOEa05/W/inhMa3evppcfN/FKT+mROepvHxKWszTT19+Rh78TfR1l4il5KsX9seMaVJJSdwxLZy7mHz+r3+Qc+ctT2hMl5+1LGXmKZnPk0XvIkKeOKr9hQc/Jkf21MeMyWKxpMWYBjpP33/z9ZgaUzLmyWazkb5gEZJ4lZW8vDysXbsWJ510UtztW7duxSWXXILW1tZEuxx17HY7FAoFmpqaIJeHy8yP9kpYe3s7tFrtkCwAnQynltuw92es+8fDOP6sX2HBxZcnNCZ9UyNevf33EErlWPXMK0ldYfnP+gM42GyBXMSDiM/B/b+ahf8dNKD9vZsxOT8Tx1/9xIjNk+2LL2D75BMUv/JKZEzHrrsewinlyLj++oTHFDAYUHvmWZj+yx4IpdJe773VH/6M6jY7XvjtnITH1J148+QNhDD38R/ww12LIeV23depvMLS1zxd9cpO/Hp2Hn578pS0WzXqa56A9FsJ6zlPN2y4AXPUc3Dx5Iv7HdP/mv+HjbUb8c+T/plSY6rd247tHx6DzxPAjf9aBp6Qgy1rD8Cid2PZ7yrijumtB3Zg+bUVKJ2eB2OrDT99UY1Fl5TFHZPPE0RLlQWT5+T2OSa7w44F7yzAB+d+gFxp7rDN0+6P30NbnR2izMU4/cpwvF/t3nZUbTPjgruOC1s1GAYHt3yL7WvfxGWr/47MkkmRe++Dx37GvHNKcWjDiwixJkJbejzmnlPS6zzV7PkZP3+8Fqv+/eKYep4CbmDzG1WYviQLArEDoWAA2qIJfY7J1OTGh0/twG//Oh8AYGxyYMOLR3H6ldOw9ZNDuPCuOZG5KikJX9N0/Y0wtzTB4XAgo6Aoap5q9+zC16+8gN/+46m0G1NPC8Boz5PdbkdBQQFsNlvkOzceA3IBWr58Oe6991588803MYWnfD4f7r//fpxxxhkD6TJpyOXymAsjEoniVs6VSOL7L3YG3sbru7d2hmHg9Xohl8vBYrHA4XDi7s/lcuO28/n8uEW/Om/engxkTAc3fwN1Zib8NkvMuXsbU8jthFgoAvH7IJNKkzomH4uHDI0KswqU+ODnZvD5fHz8Swt+I/QhJNIkPKbBzFPA5wMrMytyT/D5fBReey1a//xnSG+/HeyO8fU3Jk9TExQaDYQd/cSbp2CIwReVFvznN8cNaEw96TkmOYAMqQBtzgBy42QVGsl7Dxj+58kc5GBCbjgHezKep8GOqSep9BsBDM881ThqcO3Ma2OOiTemcnU5Xtj3Qtz+kzkmPseJ/AmZ8LmDqN9vwqQ5WWj4xYGlK6dFHdd9TJk5GjDe8Gu37hczmvY7IftdOG6o55iOHNJhz+c6zFpU2ueYAtwAWEIWijOLIeR2xbwMdZ7MzU0QSiYjI1MVOSa3CNj9WWvUmBauuBCGqsMw1NUgv3xa5N7jhARQa5Vw26zIr8iB38bu8507aeYsbHrhX/B73GPqeapvMMKid+O7/9ZCJPoBYnkAZ978F5AQu9cxed0BKNXKiDyyqTKIJPWo22eESqWMmisWiwU2O/bajuSYOhmOedq34QsEAwGU3HB7VLvHboM2Jzuh3wggtcbUvT0V5qk3BhwEfPToUUyaNAmPPfYYPvvsM3z66af4xz/+gUmTJqGyshIPPvjgQLqkpAgOsxH1+37BiedfAouuJeHjrHodMieUgBAGXrer/wNGEJsnAIWIh1kFShxosUFn82BHjQkT5UFYmNjMN8NJyGIFRxX90SxZMB8cuRyOr75KvB+jEZyMvoOefqgxgc1iYV7J8AdH5alEaLWOTKDiaEIIoVmAUhSH3wG9S99vBqBOylRlMHvNMHqSn2igO50FmUqP1+LYHgOO7TGAL+Iiv7z3lLzdawHU7DEgFGDg98avvdFWb4fH7kewn9ocZq8ZEp4k6uN/ODA2NYDN1UAk6/oAkWmE8DoDCPiiZVJm5cDapotq87oCEEq4cNus0BZkwqLvO024VKWGVKVGW13N8A0iBXCavcgukeOS++bCZbOg/kAlXrtrG17+w/dob3TEPcbXce06YbFYmDBLi9q97UNOAZpquKwWOM2x6adpAPDIMyAFID8/Hzt27MDUqVNx9913Y8WKFTj//PNx7733YurUqdi+fTsKCwtHSlbKCHL4u00orJiBwumzYNG3gnQzdfWFVd8KbWExuDw+PEkuCmf3BCEX8lCqlYLDZuHJDVU4oVgNBccPW2hkC5qErFZwelRjZrHZUP32cpjffAuJetoFjSZwM7R97vPp3lacOzMXnBHIb5+nFKLFmv71PGyeAHxBBtkKqgCkGsesx6AVaaEUKhPaX8wTo0hehCPmIyMr2ADpLMg0cXYmmg6b8cs3jZi+OB+sPp7LzjSaFr0LljY3OFw23Lb4NVQM9eHf0/4yB5m8JmiEw/eh5HMF4bHb4bZZQaCGuJsCIJTwwOWx4bREy6TMyoatTR/5OxgIIehnwBOw4XE6kFWSDZvBjVCg7/dKdukktI2xegAOsxcytRAKrQjyDAZgHLjqkeOhyZPAaY0/915XMCZLT8nMDIQCzJBTgKYafSkANAXoyDLgQmATJkzAV199BaPRiB9//BE//vgj2tvbsX79+lHNPU8ZPgjD4ODmbzD9tGVQZGaBCYXgMCW22mbR66DMzoVQJoPHkWQFwBuAXMQFh83C9DwFPtjTjBXH5UJAfLCFRvZHM2SxxFgAAEDxqxXw19XBe/hwQv0ETSZwNb2/zL2BEDYc0uO8mbmDlrUvchVjwwLQZvdBwudAKhhbL8uxQLWlut8KwD2ZrJ6ccgqAv0MBUGjF0ORJYWtzo3x+32lNO1OB1vzSjsKpGkiUfLhssQUDg4EQjM1O8IUc2E39KAAeEzSioSsADEPww4fH8MUTVWg6fAxSTQb8Xg6E0q4PURaLBWmcdKbKrBxY9V0WAJ8rGO4z5AIIQUaBFlw+B1ZD34sLWSVjryCYw+SFTBNeiHBZzAAAY0MNBGIe/J5g3GN87gCEPVb6cyYpIRBzh1wFONVwWa1wWmIVAFoDYOQZsALQiUqlwty5czF37lyo1XSS0pnmyoPwuV0onTMPHC4XyqxsmBN0A7LqW6HKzoVIJk+6AmDzBCAXhl9WMwuU4HHYOKMiBzzGA2sgfs7j4SKsAChj2jlSCcQnngj3jh0J9RM0toPbhwvQlqMGqKX8Pgt/DYU8lQgtVs+I9D2a6O1eZNHV/5SkylLVbwXgnpSry1NSAeh0x5h5Wj6OW17Ua271TjpdgGp/aUfpcVpIFIK4FgBjsxN8ERfZpQo4ElAA1MKhvYN9niC+eHYfGg6aocoT4eiPh5BRUASP3Q+xPNoHWaoSwGmOllmRlQNbe1vEcux1BcAXcuB12iGUSMHl8aHKFsOs69tNNKtkIgz1tUMaS6rRaQEghMBlMSNzQina6mrAF3Hhc/eiALiCEEh6FOnisFE6OzOiTIwFCCFwWc3wuVwIeKPvc+oCNPIMWgGgjB2O7foRk+YtiFR0VOXkJRQHQAiBVa+DMjsHIpkc3mFUAFqrrfjg0Z8HdIy9IwYAAM6syMYtp06EQsQDj/HCHBhhC4DVAm4cCwAAiE+YA/euxMYSMprAyei9oM+ne1vxq5m5UUGDw0muUoQWS/orAG02WgQsVamyVGGyevKAjpmknIQaa2r5hvs9oUil38kn5mDuORP6PUamFsKqd8PU4kTxjAyIFfEtAIZ6O7KK5ZBrRHCY+n4eE3EBOrB5A3TVR3vdvvm/lSAEuOCu41E6V43Wqlpo8grgcQYgkkV/iMYraKbIzAQTDMHR4crhdQUglPLgtlkh6qgCrM6RwNKPAiBVqeG2W/vcJ91wmMIKgNfpQCgYRMnxc9FWewx8EadXC4DXHR0D0Mkpl03GrCVjx83a53YhFAiAxWJH7p1OnGYTpGqqAIwkKaEAPPvssyguLoZQKMS8efOwc+fOhI577733wGKxsGLFipEVcIzTdGg/CitmRv5WZucmpAB4HHb4PW4os3KG3QJgNbhhNw7sQ9TuDUIu6rIA3HJ6eJWRE/TA7B965cS+CMaJAehEPOcEuPfswZH2w7j0f5f23Y/JBK4mvgLg8Aaw6YgB580aGfcfAMhTitBqGwMKgJ0GAKciDGHCCoBqYAqARqSB2WseIakGR2cMwECQaYRgGIL8ySoIJTyI5fEtAG31dmQWyyOVd/siERegfRu+xJEfvu91u7HFieOWFEIg4iK3XAavsw0cvhZMiEQFAQOAVC2Es4cCwOHyIMvIgK0jENjX4cPuttsg6VAAVDmSfgOBBRIpfC4XGKbvwOd0IRRk4LL7IdMI4bSYwReJkT9lGtrqjkEg6ssFKDYGAMCILfwkC5fVAi5fAHlmJpzmLrdjhgnBZbVQF6ARJukKwNq1a3HHHXdg9erV2LNnD2bOnInly5fDYDD0eVx9fT3++Mc/YtGiRaMk6djg8PebYGpuivztttvQ3tSAgqnTI21hC0D/tRys+lZIVGrwhEIIh1kBcNv88DgDYJiEy1TA7glALox9IbNDXrR7R84CQAiJmwWoE+GUcoBhULnzKxw0HYQ70PtLMGg0xrgAeZ3hXMVv/FCPydkyTMyUDZ/wPchTimB1B+DyxX8xpQt6qgCkJK3OVvhCPpQoSgZ0nFKghM1nSziYfjTozAI0EPhCLgRiLkqPzwQAiBV8uO3xLAAOZHUoAP25AJm95j4tAIQQWHQtaKuN71tPGBJ2U+lwLeHwWGDBDEMDDxwuGzxB9OKJTC2AwxKrtCizsmHtCASOZACyWiCWh90VVTmSfl2ARNLwb5vPnf6JCADAafGCzWJBrBDAZTFDolIja8JE2NsNYLG98PWmALgCEMSxAIw13FYLJEolZOqMqEBgj90OwjCQUAVgREm6AvDkk09i1apVWLlyJaZOnYoXXngBYrEYr776aq/HhEIhXH755XjooYcixRUoibH7i0+x+4uPI383Vx6EJq8A4o5VGgBQ5SRmAbDqdVBm5QDAsFsA3HY/QLo+fvvDGwjBF2QiFoAITAjskA/2EA/ewMisKjFOJxAM9qoAsDgciGYfD1eHG1C9vb7XvkJGI7g9XIDevH8Hdu3V45nNx/DXX1UMm9zxUIp5EPE4aI0TB9Du8KHemNxUr4kStgCMbOYnysA5ajmKEkUJeJyBxeQoBUqESAiOQPy0ickgHAQ8cMvi8t9VoGxuFgBAEscFyOsKwNrmRmaxDHKNqH8LgLdvC4DbZoXf44Ghrjbuyrrb4QcTJJCqw8+L12FHKOCGro4DkYwXs+oczwIAdMQBGLorAGELgLjDMqrOEcPa5gYT6j0TEFcgAJvDhdeZOvM8FBwmL6RqAdhsViSrjVAqhSIrGz5Xa+8uQK4AhP3Ek4wFXFYLxEoVpGpNlAuQ02yCUCYHlzf2r0EySaoC4Pf7sXv3bixZsiTSxmazsWTJEuzoI2jy4YcfRmZmJq699trREHNM4TAbUfXTdgQ7KuA1HTqAgmkzovZR5eTBbjAgFOz749vS4f8PjIAC0GEW9zhiV8fiYfeGZe0MAo7QsdrugQAO78isaocsFoDLBbuXQiEAID7hBIgOhoPb6mx1UdtcO3eCcblA/H6EbDZwurkABQMh+D1BvPzJUaxaVIKZBcoRGUMnLBYLuUph3EDgf31bhSc29O5HnEq02X1jNgbAH/Jjf/t+hNLQTWIw7j8AIOFJwGVxYfPaRkCqweH3DtwFCAAKpqrB5YcVB3GcIOD2BgfkGUKIpHzINMJ+awH0FwRsaW2BVKUOWwJaYy27DpMXIjkfXF5YJpuuFXJtFsQycYz7DwDIVEI4LT6QHtZZRWZ2JBOQ1xWAQBKOARDLleHjNCKwWCzYjb0rNCwWC0KpdOwoAB0BwEA4A5BEGV4kypowER5bC/yeIDwOO6p3RX/veN2xQcBjEZfVCokirAB0dwGytumg0GYlUbLxQVJtTEajEaFQCFlZ0ROdlZWFI0fiZ3zYtm0bXnnlFezduzehc/QsmdxZtplhmKiyzqMFwzAghCTl3MFAAB67DQKJFHW//IzSOfPQdGg/5l94WZQ8EqUKHB4XFp0O6rz8Xvuz6luhyS8AwzAQSqXwOOzDNi6XPTxnLpsPqpz+i3jZXH6IeBxw2YiWwecEG0CIK4LN44cmwR/VgcxTwGwGR6EAIaRXFwXerJkoeM6O2dq5qLPVRfoNGo1ovHol+BMnIuveewAWC2ylIrLd6worNkovg5tOKR2V+yZPKUKLxR11LoYh2FjZhkmZ0qTcu73R2zzp7V5kyvgpJetwsaVpC+787k6ohWosKVyC62dcPyxpIIcLp8WMUDAQ9QLvnKej5qM4Luu4Qc2LUqiEyWNCnjRvOMUdND5PEDwBe0j3mEjKhcvmj+pDX2dDZnG40qtAwgGXx4at3Q1VTmyFUkIIzF4zVAJVr3KYWpqgzitAwOeDvqYKqtzw9XOY2mHRtcLvzYFMLYi8Ey26ZmgKCqEpzITd6InpV6zgdfi2+6IyBCkys1D90/Zw5VNXAGI5H8Y6C7InTo70ocwWwdTigFzbu3IulMrgcTjGxLNrN3og7bi2TrMJEpUaDMNAW1yC2j2HwBVX4H//fgxttcdQOnsegPCc+twB8IV931vJ/JYYLpxWM8QKJSQqNZoPH4yMpb2xIfJtke4kY54SPVdaOZk5HA5cccUVWLNmDTL6yJTSnUceeQQPPfRQTHt7ezu83tHPd84wDGy2sC8rmz26BhinyQgWm43SE0/Cvs3fgKfSwNTSBIE2KybmQpqRifojhxHk8SNy95S3vbkRGZPKYTAY4AsxcFos/cZuJIrDHF6Bbmsxgq/u3w2oQeeElM+OOT/H3owMNhd8Ph+NrQZImfhlvnsykHkK1NeDyGR9jv2Y2A1pEFjoKsI+w5HIvt4PPwRn6lSwysvR9LtVYMnlaLdYIsdVHgsrrGUcLqzm0amEqhIAVS0mGAxdL+nDehfa7D5oRJxhm+PhIN48BUMERocPHL8LBkNiLmTpRG1bLU7IOAEXF1+MF46+gLfIW7i0pO/g8tHkx/fegN/lwsnX3hhp65ynSlMlzsg+Y1D3kJQjRYOhAdmk71z7o0EowIAJEthdVvgMzkH34w0E4fcEoWvRg8ML379NVe3QFksi10ik4KKpVo8AJzb2xxFwIMAEwDgZGLzxr2lL7TEIlGoIWSzUHzoAzeRpAICfP3oPpsY6FM9ZBb6EBYPBAIZh0N5QD6lKg+K5EvjcwrhzJZBw0FijgzpPFGljeAJY9K0wGAywmZ3gScWwm4wIgBXpQ6zkoOmYAZLc3mM52Hw+DK0tEOf0vviULrS3WiFW8GAwGGDS66AtmQiDwQCBSgOLvh5szrcgTD18bhf0ej3YbDaC/vC95XDb+ry3kvktMVyY9TpINVowHC4sbfrIfdJaU42Mogkp9a4ZLMmYJ4cjMQtaUhWAjIwMcDgctLW1RbW3tbUhOzv2R76mpgb19fU499xzI22dmg6Xy8XRo0dRWloadczdd9+NO+64I/K33W5HQUEBtFot5HL5cA4nIRiGAYvFglarHfWHNmA2QqJUY/ays/DuA3/C5BNOREZBEQpLSmP21RYUgvG4kJmZiQ0v/gdsDgdLfndT1D4ukxGFZeXIzMwEcTngd4f3Hw587iNQZIrAY4kS6pNtYUElEcTuS9oBnhgKLh9csQyZmYkpjgOZJxshCGm1fcq53b4djglyVLSxsV6gi+zb8N33yLjw11BefDFsc2bDu39/ZBshBPe/W4OZLMBnCUCl1IDHH9lsRgBQmm1HrTF6Lt/aVwWtTAB3EMM2x8NBvHmqN7nA5bAwrSRvRKolJxt/qx/5ynwsm7IMP9p+BEfASak5aT92FISQKJkYhoE75Ibeo8fcCXMHlbdeI9YAotS4/zrddnILssHhDv53nGQQsNhVkAgVkGvCH9M23THMO3siMjOVAABVlh7skDDuuN02NwQcAYpzinvNEOOzWVAwbQYEYgkObfkm/HvNMGg5sBccHhfEx0VGjgKZmZlgGAYesxFT581HwYTes43JNU3gQYzMzK6q5QqpBH63G3KxGAiykZGlwmG3CzmFhRHZs4vdsBk8fc6hTKWGgJNa9/RgCbhbkVWhQWZmJoIeN7ILwtdCJhJi0/P/Ali7cdn//QPv3HsHFGIxRHJ5OL6CBeQWZoPdx+9XMr8lhouQ1wNtXh60hcXY47BH5txlNGD28rPHxD2QjHkSChNzf02qAsDn8zF79mxs3LgxksqTYRhs3LgRN998c8z+5eXlOHDgQFTbfffdB4fDgX//+98oKCiIOUYgEEAgiA0GZLPZSXtoWCxWUs7vspohU2uQWVwChTYLP6x7G2XzFsaVQ52bD6u+FUe3f4dDW75FZnFp1H4epwNepwPqnFyw2WxIFAp4XU4ABGw2Bz63G5VbN2PW8rMHLKffG0TQxyAjXwqvMxB13mO7DSiZlQE2J1pmhy+cAjRmLCEfwBNDLuTB6QsN6JonOk+M1QauStXnfkctRzGlohTqo3o0KBtAQBBqaoavshKKM14Em82GasUKoFtK2y/269Bm8kCRIUHAF4K52YWcicqE5R8s+WoxttWYosbzbaUB5x+Xhw93N6fcy6bnPDVZvChQicHjjryylAzMXjMyRBlgs9kQ88TwhDwpMyfWNj2cZhOYUAhehz0quUC9sx5akRYZ4sSU8J6ohCrYfLaUGGvAx4DDY4PHH+IrlA2IZXx4HUEotWy47X647X5oC+WRcco1IjjNvrjjNvvCGYA4nN7vdYuuFbOWnQ2pWoPNr70IgKCt9hicFhN4grA/f1GFBmw2G4QQ2PStyCgs7vM6yzRCuCzRMomkMghlctjb2+BzBzvqANggVaoj+2lypajfb+qzb5FECp/LmRLzPFScZi/kGSKw2eyO929Gx/tSiZxJFbC0TUDOxDJw+QJ4XQ5IlEr4vSEIRFxwE/j9Sta3xHDhtlkhVWkg02jhslk6CskRWPWtyCgoSttx9WS05ynR8yT96t5xxx1Ys2YN3njjDVRWVuKGG26Ay+XCypUrAQBXXnkl7r77bgBhraaioiLqn1KphEwmQ0VFBfj82IAlShdOkxFSTdhXuHzhYjjNppgA4E5UOXloPnwQ377yPBZddjXMuuZIlUcgHFgmVighEIddakQyOUAIfK5wlpimQ/ux+Y2X+g0kjofb7gebw4IySxwVBBzwhfD1moNoqbbGHNO9BkAUfhfAF0Mm5MLhHRl3kFAfNQA6OWI+Asn8E4Ef90BjCkDn0sH2xReQLFoU91i3P4i/fXEYF8/Mg1DCQ1aRDIaG0QmM61kMrMnsxjGDE+fNzIXNE0ipVIzxaDS5UKjpP24kXeme9UXIEcIbGn1Xxt5oPLgXOZPKocrJg75H2skaRw3KVGWD7lshUMDqsw5RwuHB7wkNKgA4HmKFAK4Oi4Kp2Ql5hjBSYAxAn6lATd6+A4CZUAi2Nh1UOXnQ5BVEAoGrftqOCbNmI+D1wNbuiKQAddusCHg9UOf2HWcRrxow0JkKVBdeuOEEwISCECu6qpYrMsWwtfddZ0QolXUsJo0OplYnPnzsZwT6CLQeDIQhcFp8kKm6qgBLumWK+9WfHgI4kxAKMRDKZPB2uG2EayiklXf2oHF1pAHtDI52WS2wtLaAw+VBnqHt52jKUEm6AnDJJZfgiSeewAMPPIBZs2Zh7969WL9+fSQwuLGxETqdLslSjg2clq7KeuULF0MgliB/Svy0kp2pQKctPh3Hn/UrhPyBqDRdxqYGZBR0VSTkCYTg8gWRTECm5kYwoVBC9QR64u4oPy+WC+B2dH20d1afbK60xBzTWw0ABDwRC8BIZgHqLQUoEC5+dMR8BMUnnQHFihX4y4dAfcsh2D//HxTnxLeQvLqtDlkKIWZlyyEQcZBZLEdb/fBlWeqLPKUIersXoY4sH98cbsO8EjXyVSIEGQLPCKVTHS4aTG4UqceuAmD2dOV9F/PE8ARTp3Bb44F9KJo+C1klE6E/Fq0A1Dpqh6QAKAXKFFIABl4DoDfECj7cHalAjc1OZORH+/r3VQysvyJgtvY2sFgsyLVasDkcaIuK0VZbjeqftmPGkjPBYrNhN5oimWqcFjMEEim4/L5T6MrUQjgssTIps3Jga9PD6w6ChNzg8gXgCbviBMRyPvyeIEKB3oMUBRIpvM7RUQC8rgC+fP4A9LV2OPrITjQY3HY/mFA4vWpnFeDuee077x+/JxjOoteR+ShcBXjsZwBimBA8djskSjU4XC4kShWcZhOMzY3Q5BeANUZW/1OZlLjCN998MxoaGuDz+fDTTz9h3rx5kW1btmzB66+/3uuxr7/+Oj755JORF3IM4DCHTZBAeKXmhjVvQdhL6kptcQnmnX8xTr58Jbg8HhSZWbC0dtUGMDU1QFNQFHWMSCaHpyPLkrGpIbxfc+OA5XTbwgqASMaLsgB0KgBNlbEVQe2eABTxLAABF8ALWwDsI6oAKHvd3mBvAEMYlChKkPXnu+DPkEH4h0cQbGuD9NRT4x6zt8mK82bmIuAJgS/iIbNYDsMoKQDZCiEYQtBmD1/vbyvbsHRKFmQdKVbtveSuHmlqbbVod7dHtVVbqvF2zdtRbQ1mNwo1iQV7pyMxFoBgalgACMOgsaOqeHZpWUzhqVpH7aBSgHaiEqpSRgEYTBXg3pDI+RELgLHFAU1+9G+yPEMEhym+ktdfDQBLawuU2blgs8PuJFklE7Hv2/XwOp0onnk8RDIFgr4uC4DLYoZIrui1v06kqvi1AJRZ2TC3tiIUYBAKOCBWKKJiE4QSLsAK1x7ojdGyADAhBhteOQR1jgTKLHHk/TIUTK1ONB8NL1A5zF6IO9KrdlYB5ndThjg8NtgcFnzuIERSGTyOcIpbn2vspgCt+nFbZG7dNhsIYSJuglJVOBWoqbkJmvzCPnqhDBcpoQBQRgenyRixAADh8u29weMLcNJvrgS3w61KlZsHs645sj1sAYhWAIQyWZQFQCiVwdg0CAXA7oNYIYBYxo9WAExeaPKkMDY5YgqE2b2B+C5AAQ/AE0Em5I2cC5DF0qcL0BHzEUxSTgKXzQWLy0XVH85F0OeBbNkysEWiuMfobF7kKETwe4NhC0CRDLZ2TyQt6EjC47CRJRPik70tePzrI9hZZ8aSqVngsFmQCbiRmgujSSAUwI3f3ogndz8Z1b62ai02tG6IamswucasBYAQEl717bAAiLiilLEAGJsaEPT7kT2xDFmlE9FWeyziLhZiQqhz1A3ZBcjmS406AJ3P5XAgVggi1YBNzU5k9FQANEJ4HIG4Lird74V4WHQtUOV0BfNmTZiI1qOHUTpnHrg8HgRiObh8X8TlyGkxQdQtbqM3ZGph3A9mRVZOxOob8LuiYkAAgM1hQyTl9VnfZTTqAAQDIXz3bhWcZi+WrpwKeUb88QyUozv0+Pqlg/C6AnCYvFGKVc+qtiwWC3wRF35PEEKZPOIC5HUFxqQLEMOEsP65p1C98wcAYXcfoVQWKfYl02jgNJtgam6gCsAoQRWAcUR3F6CBos7Ng7mlSwEwNTfGKACdxcAYJgRzazMmnjAf5sFaABR8iGT8KBcgp9mLrAlyqHIkkVWWTuyeYGwRMADwuwG+pCMGYGRWroNWC7h9uABVmitRrimP/F2QMxmv3jYZ2Q/c3+sxepsXOQpheKVRzINIyoc8Q4j2UYoDmJGvwAe7m9Fm9+Gp38xCvir8QS0X8WDzjL4C8GH1h/AEPdjUuCnywRtkgtjYuBEWX9e9QAhBo9mNQlV8xSrdcQfd8Ia8XRYAbupYABoP7kP+lGngcLnIKi6F22bD1esuxUnvnYQLPr8ABARF8qL+O+oFlUAVNdfJxD+cFoAOF6BQkIFF54YmL1oBEEp54PLZceMAzF5z3xYAXQtUOV3+/FklEwEAZfMWAgB4Qin4wq7n2WUxJ6QASNUCeByBmAJlYQtAE9isWpia6iGOY00QyfgRhSceQmk4CHik0NXYsPb/dsHY5MDZN80EX8QNKzT9VFxOBKfVB58niJ3/q4sqAtZZBbgngg4FoHshTZ87OKAqwE2HD2DtQ38ZsuwjjbmlGQGfFy2VhwEAbqsl4vsPIFIN2NTUCE0BVQBGA6oAjBNIRyGSTheggaLOLYBFF3YBctttcFkt0OTHVwCs+nA5+NI582AcjALQEQMgkvMQ9IUQ8IVfMp0/qAXlajQfiXYDClsA4sUAuCMWAKfLjQ///kCkCvJwETKaoqr39uQX/SGUq6ZE/p6gmIAqbyPY4vir1N5ACCaXHzlKIfzurpXGzCI52hpGxw3opSvnYNOdp+CJi2binBldK4gyIRf2UVYAPEEPXtr/Eu478T5kijPxffP3AIDdbbvhC/ngCXng7qj4bHD4EAww2P7U/riuYumOyWMCl82FnB9OYSzkClPGAtB4cB8KK2YCAHhCIdT5+TDX1+ORkx7BHbPvwP8d/3/gsgf/0awQKIalEnDA7wMzxCrKw+kCJJaHg4Atehc4fDbkmugUfiwWCzKNKO4Harwg4OYjh8CEwuMzt7ZECn8BgCa/ELPPOR/FM48HALA5EvB4Xf26rJaEXIDEMj7YXBacluhA4MwJpcgtOw4+53b89PH7kMep5iqS8eFx9P4bIpSMnAWgpcqCz/79C6YsyMGv75oNhTa8UCDTDI8FwGnx4vhlhTi8rRUNB01RVYDjKQB8ERc+TxAiWbj4GRCOARBIEr+32hvqoK+pjkrSkYq01R4Dh8dDy9FDALoCgDuRqjSwGfSw6FuRkT/4hQJK4lAFYJzgttvAhEKQqAeefxvocAHqsACYmhsh02gh6PEB26kAmJoboM7Nh7awGFZ964AzAbntfkjkfAjFPLDYrIi52GEOm1Tzp6jQdCR6JdDWawyAOxID4LWaUb9vD+ztw1dchPj9CFmt4GrjZyyweCzYa9gLtr840lYsL4bJa+rVnaHN7gWXzUKGRBD1oTGacQC9IRfxRt0F6L0j70Er1mJJ4RKcNeEsfFn7JQBgQ/0GnD3hbHBZXBg94SJpDSY3JoiFcNv82PDKoWF5qacSnR98nX7VqeICFAoG0XT4YEQBAABJQQ4y7EIszFuIxfmLcZzmuCGdozMIeKhZqL56+p84/N2mIfUxnBaAziBgY7MTGXlSsOLkfpdrhHHjAHq6AAV8Xqxd/WdsW/smgFgLAJvDwSlXXBtx7QRLDBan6xlxJmgBYLFZkKpiA4H5QhFmLrsaeVNvxK1vfIBTr1oVO15Zfy5AshELAja3upBfrsbxy4uiUkkPlwXAZfWhYIoaFYvy0FptjbgAOeO4AAGIuACJpDJ4nR0WANfAgoDthjYEfT44Lam94KGvqUL5gsWwtunhslrgslogVnRZAGSaDDQfPggujw9ZHwtqlOGDKgDjBKfZBKFMDl4/2R16Q52bD4epHQGvNyYDUCcRBaCpEZr8QsgztGBzuQPOBBS2AAjAYrM6/EXDH5wOU9gCkDtJCafJC7ux64UYzgLUuwIgF3IRcNo6+mmP3W+QBM1mgMUCVx3fBejFfa8h6C4CJ9i1iq4QKKAWqlFvr497TKvViyy5EGw2KyrbSEaBFKaW0UuPFw+FiAebe/QUAKffiVcOvoJbj7sVLBYLZ044E1tbtsLqteLbxm+xrGgZVAIVjN5OBcCFYokAUpUAJcdpsf7FA31mHEk3en7wibiilEgDam4NLw5oC4sjbSRLijynDGzW8LxmVEIV/Ix/yAqP02qOWDMHy3BnAfI4/GhvjA0A7kSuEcZNn9nTBchlsYDN4WDfhi9QuXUznGYT1Dm9p/RkQkKAuLsdb4ZYrkxIbplaEDcQ2NvxAcvl88GOU59AJOf3HQQskSIY8CPgj00zOlTCCyqxMvUW0zAQCCFwWn2QKAU44ZxiiGQ8KDPDi2S9WQAEYi78nlCUC5B3gGlAbe3hQqpDvadHmraaYyiaPhPagiK0HDkEly3WBcjjsNMMQKMIvcrjBIfZBFmcH6BEESuU4IvEsOhbO3z0Yk10oo4gYGNHfACLzYYmr3DAmYDcNh/ECn5Hn+GXRSjEwGX1QaoWgC/kIqtEHuXi0XsdADfAD6cBZVwdCoBxGBWAdiM4KhVYvNhz23w2fHhsLXzGJdDbo18uRbJiHDXVxO1Tb/cgVxleOepuAVBmiuEweREKJu+DVi7kjVg2pXg8s/cZTFZNxoLcBQCAYkUxJion4tFdj4IFFo7PPB5qvhomTzhFbaPZjTwBHxKlACdfHA443fFp/OucjvT84EsVC4DHboNEoYx6cdvVgMLMGra6ETJ+WJmIlwnI1OrEz1/VJ9RPwOOBfYi/AX5PKCpX/1CQyAUgBGg+Yonx/+9EmS2Gtc0d1eYOuOEJeqIUQqc1vNK8/PrbsP75pyCQSPp06QkEBAgFXJG/XRYLRIr+XYAAQKYSwhGnFoDXFegzi41IxoenjxgAgSR8DXwjYAUIK26xssk0QrhsviH9tnqdATBBAolKAIGYh9/+dT7yp4Q/cJ1Wc9THbid8ERc+dwBCmTziAuRzByAYQAyA3dAGNoeb0gpAKBiAoaEWWaVlyJsyDc1HDsFltfZQAMKr/j1diykjB1UAxglOswnSIZjVWCwW1Hn5MLc0xc0ABHR3AWqMRPFnFBQOKBMQYQjcjgDE8k4FIGwudll8AIsFqTJswSiYokZTRz0AQkgfLkCeDhcgHuAO/8AO9eXfnWB7O7gZ8a/rfw//F1mCMjCeIhjs0S9Kq02Nd375Ke5xOpsX2Yqwb2p3VwOpUgA2lx1l+Rht5KLRiwHYa9iLj6o/wv0n3g8Wi4X/7W/FHe/vBd87G/+r/R9OL1wCDpsDlUCFdk94TutNbmg5XEhVAnB4bMxaUoi22tTIHDMc9LQApEoaUI/DHi4G2I1moQXsAIG9Y4VyqLBZbMj58riBwFU/6VG5PTFLo8/jhsNkHJIsPk9g2FyAODw2BBIuzK2umAxAnSizxLD0UABMHhO4LC7kgq7r7rKYIVWqUXbiSTjuzPOQWVwalYYzZhxuPgLe8O8iEwrBbbNClKAFQNrLqrnPFezThaVndreecLhc8ISiEUkF2psFQKwQgM1iwRmntkGiOC0+CCRc8Pjh/vlCbuTahy0AscHaAmGHBUAqi8Q99Hf9ukMIgd1oQN7kKSmtABibGsHh8qDKzkHe5KloOXI4JghY1pGghAYAjx5UAUgTmpqacM011yA3Nxd8Ph9FRUW47bbbYDKZ+j8YgNNsHHQGoE7UOXkwt7bA1KsCoIDbZoWltTnyEGvyCweUCcjjDIAwpJsCEH5ZOC1eSJT8iN+mtkAGa1t45crtDyHEkF5cgLrqAHA6XnRDffl3J2iMrwDYfDa8U/kOijkrwOeyobdFv1jY3imo8/wUd3VUZ/UiVxG2APg9XeZgFpsFhVYEqyGJCoBwdGIAfCEfHvjhAVw/8/r/Z++8oyS7qnP/u5VzTp3j5Dya0SiigAISiCQJMAYeOZlgMLYfYMDCBmMM2IAIRsATGSRAIEBZKKPJOXfOlXNO9/1xu6u7uqq6e4JmJHu+tXqtrpvPPfeEffbe30enuROA3+2bIJLK06y8BEQBt0LSC7Gr7bMegFAKoyignzYUlRp5JYn8fwLm875rFVpypRylM0xqPVNk4nG0pmoDYCQ9hspjY6r/5Fm7j0VtqZsIPHYsQiqaX5K3IX8WDIB8pnTWQoBASgRGoKEHwOrREw9We/9C2RBWjbUqxCoZno01v/qt7+L1n7yj4T3z2SLFvJrctGc0HYsiimU0S0gChmmjZCpVs13yADR+N1II0MJ9yAtFBdrIAyCTCRhs6jPKA0hGcxgsmprtFRXgOvl3Kp2CXLaI1iQtnomiKCUBLzEEKJ9Okc9k6Fi/6bREN88VfAN9eHp6EWQyWlauITA8RMQ7id4y+06UGg1qvR57a9t5fNL/XbhgALwEMDg4yJYtW+jr6+MXv/gF/f39fPe73+Xxxx/n0ksvJRxePPnnTBiAZmBtbmXs6EGy6RS2ltbK9gNjUZ4fCKE1mYj5vAiCDLNLYn+wt7afEhNQOp5HpVWgmF5F0RlVZOKFSvz/DDQGZUULYGZCamioBKzFqFGgLaYw2B1nNwcgGEThrH2vv+n7Davtq4mGW9nSYcWXqB5YUtFuSiR5anhvzbmSB0CDWBYlD8CccllcOmL+dM055wrmc0QD+r2D30Mj1/C21W+rbAskcty+pY0vv/YqXm76N4bGpG/MqrbOJgGH06gLzBoAqv9hBsB8D4BiOlSsdPbjpU8F9TwAI/ERnN09ePtPnLX71FMDziTzBMcSlIrlRXUyRFEkn8mQDIfOiAlIouc9ewaA3qzC7NSiVNfXFjBY1MjlQlUewGBskCZ9U9VxqWh1sqmiTmjiDBKhLEqNkVw6RalYqDAAyRVLK5ej1UBoMoVYrja6sosksWqNygVDgGCaCShVa1ycKfLp+h4AOPM8gFQki8Fam2M3owJssNTJAdAqyKeLaAwmxHKZdCJBIVtasgcgGQqiMRhxd/e+qD0A3oGTuLuXAVKyr9HhlIyiefo5t3zsk3Ss23juH/B/KS4YAC8B/M3f/A0qlYpHHnmEq666ivb2dm666SYee+wxJiYm+PSnPw1IYTrzVZEtFgt33303ifDpawDMwNbcwsSxo1jcHpTq2cn4L3eN8vOdo5UJgK2lraI8aW9tPyUmoB/suBuNcbaD1pqUpBP5CgPQDDQGJZlUQXKBZooY1QrkddgzZnUAlOiKaWydvWc1BKgUDNZlABqIDrDFs4V+f5LLex345ngARFFkMlJEyKzll0f/WHOuN56hyayhkCshilStBpld59kDoFW+4ErA+VKeHx35EZ+55DNVtJGBRA6nURpgb1u3jceP+SmXRSkHIBsilikQTRcQMqVKqNj/dA+ATiElGaaL588oBMkA0MwxAFKFFIFMgJ5VG5nqO7segPkhQOPHI9iaDai0ClLRhQ2hYj6HWC5TLhVJR6On/RxnMwkYpERgR4PVf5j2/rmr8wDu67uPm7tvrjquEd98PSRCWUxOGwgC6ViMZCRUN069ESxuHeVimfi8VfPFDACdUVXx9DaCZk5IzNlELlNsGF9/ukxAmUSc3/7b54gHk5WFh7kITYyh0RtQamq9AzM0oCqtFplcTiIQBViyByAZCmJ2ubE2tRD1eSkVz49K+2LwDvbj6VlW+d26cjUAunnfW8e6jQsKlF7A2cUFA+BFjnA4zMMPP8wHP/hBtPNUYz0eD3/913/Nr371q0Vd38lQsBJjd7qwNbciiuWa8J9+f5JAIovGaASqY/hMDidyhXJJ7klvysvOob3k1bMT3JkQoBoPgF5JuShSyJWIZRqoAENFB0ClkGEopzG29ZAIBc5aYmIxEORgqrcmQc+b8mJROvHGs1ze68CfyFGeHvDimSKpfIltrmvYG3qq5lmmopIKcG56oq2c5wGYf69zCZPmhVcCPho6il6pZ61jbWWbKIoEkjmcBmmA3dZtI1MocWgihk1tI5AJMBpKY9EpycRzlZU4pfp/mAGQqTYAFDIFckF+3vMA5nsARuIjmNVmuldtwj80cMpUwI1g0Vhq6HPHj4VpW2XFYFXX8NLPRz4j9S0aveG0w4AkL0LjleTTQe9FblZe1rTgMVaPjohXWhXvi/RxLHyMV3W/quqYVCS0ZAMgFsxgdujQGoykY1GS4aUbDwByhQyrR1/DTJZLLxzDrjWpEMtSqEsjvFBiYAvVm+E0tQBCY6MM7d/D+NHn63oA9j7we9Zc/fK6584IgQmCgNZoIhYIo1DKKh7wxZAKBzE5XRgdDmRyOTH/2cm3OZso5HMER4crHgCAlpVrkMnlaA3G8/hkF3DBAHiRo6+vD1EUWbVqVd39q1atIhKJEAgsvKp9JirAM7B4mkEQagyAgUAKfyKHUqVGoVZXyXgLMhm2ljZ8g/0cfvIxfv2FzzTk4d8f2I8ubyShmF3hm0kYm6uqCFLHKcgEssmCRAG6oAGgB0BfSqNq6qSYy5211aViMMhgwMjIkepcDG/KS6lgwaZXsdJjpFgWCaUkt/dENINJo+DN668jU0pwJHikcl5FBMysIZ8potTIkc3xbJhd2iWFAE32RV8QDvxzoQS8z7+PDc4NVcmLsUyBQkmseACUchnXrnTx6DE/VrWVUCbESDhFh1VLOpqvrMQpVHKK+fKCq40vJYSy1SFAgiC8KJiA5hsAw7FhOkwd2JpakCuVBEaGz8p95ocAiaLI2LEIrats6C3qRT0A+UwauVKJ2d102qGApUKZckk8a0nAAF3rHXSuWzhE0zLHA/Cbvt9wQ8cNmNXV8frJSKQu33w9RL1pLB49OrOFVCzSkKt+Idhbaw2AbHLhHAClSo5SLScTP/diYLkGOQBw+iFAsYDEwuPtfxKdufraoYkxBvfu4qJXvq7uuSqtvLLQozEYSYZjp0QBmgwFMTndyGRyLO6mF1UYUDzgp1wuERgeQqM3YHK6Kvs6N17EqiuuvkD3eZ5x4e2/RLDYirVqRtilDgq5HPlM5oxYgAAUKhUWtwfHHK7vcCpPOJUnkJAGXr3ZUsUFDhIT0EPf+S923f8bIlOTjB4+UPf6B/wHaAtCsDSbMyDRgBZIhHNVBoAgE9DoFWRTBUkFuBEl37QHoFgooC5lKRsdaPSGsxYGlAknKBQFAqOzg5UoivjSPpIpA71OAxqlHItOiW+aCnQymqHZouXSLg+l5GruPT4bBuSP5yQRMIN6erCqLpfFpSMZyVHML7yq/eTPT9C36+yvBpm1yhecBWiffx+bXNWiUYFEDp1Kjl49+z6uX+3msaM+bGob4WyYoWCCLpOOcllEb571AAAUFnlfLwVki1lShVSVBwCkPIAXhQfAVO0B6DR1IshkeHqX4x04vTCgI89MVNWdWW0mmo1WfscCGVLxHM3LLOgtapKLGgAZVBotRrvjtD0AMxO2s2kALAXWaQMgW8zyh4E/cNvy22qOacQ3Xw8RbwqrR4fObCEdjUr5A3Xi1BeCvdlAaHzWAJhJYtUsQmOpNSoX1gIwGF8QFqAFcwDspxcCFA/4WbbtMkrFPHH/0ap9u//wW1ZdcXVDYSu1Tkl++nvSGk0kI9EFKVTnIxkOVvLtrE0tLxoDIDw5zl0feid3vuNNPHjnV3H3LKta0DE5nLzigx87j094AXDBAHjRo7e3F0EQOHbsWN39x44dw+l0YrFYEIRazu1CoUAulUKhVqPW6c/4eVrf9BFca7dUfg8GkmiVchLZItlCiVs/9Xk6N26uOmfb697A7f/0Bd7+1W/Tu/USfEP9iKKIP13tCTg8vh/7xADFif2VCY3WqCRbJwcApDCgRT0A0zoA6VgEEYGsXHdGg/9ciKJIMiG977kGQCQXIVfKEYxq6HVLcb1uo2bWAIhlaLFo0arkdGgu4/GxRyv1NhnLVImAzZ9k6MwqFGp5XVGgGSQjWSJTqUUnQ6cDk1ZJIleshDOdbYiiyIHAgboGwMzq/wyuWu5kOJQindFREkvsHR+nTaNCrZ9NIp8xAIr5l74YWCgbQi7IsagtVds1cs2LzwMQlzwAAE3LVuA9DSag4HiCJ392gqm+aGWbVW2t8gCMHwvT1GNGqZJjWKIHQKXTYXQ4TnsRIJ8polDKkMvP7fBp9eiJeNM8MvwoDq2jpo0Uclly6dSSV/Ej3jS2phkPQPSUjIcZ2FsNBOd4AIr5MuWiiMaw8CRWZ1qYClStN5x1NeBSsUyxUF4wByAZyS3oLQxNJBk+VD12xIN+LJ4mFNqL6Nv+YKUvT4SCHHv2Sbbc8vqG11Np5eQzRURRRGs0kY7FTkkFODXtAQCwNr94DIBEMIjZ7eGvPv9lttzyei699a/O9yNdQB1cMABe5LDb7Vx//fV8+9vfJpOpHuS9Xi8/+9nPePvb3w6A0+lkamqqsr+vr490Ok02lcBosy/IB70U+ONZPvzHcR48OjtwDgSSbGgzI5cJBBI5rE0tlQTgGVibWmhfux5BEHB39+Ib6Oep8ad4/f2vr7CXZItZQkNDyORa7OEouw4/CUgeAFGU3O4G2zwDwKAkmyoQyxTrawBARQcgFYlQVOlI5ksYHU4SwfphSKeCcipFWmZAa1AQmUpVVip9KR8mlYnhQIFe57QBYNZUxMAmIpIHAOC6zitIFpIcDB4EwBvL0jRNAZpL1ypCCoKAxaUltkAi8IxA2mKTodOBSaNAFCGZf2GSzUYToyTyCVbbV1dtnxv/PwOjRskl3Xbu3RdBJuo4EZxkm8dSSQAGKU5ZJhco5F6cyXGnglCmlvYRQKs8/2rA9XIAKgZA7+kZAEeelvKGgnNWmOeHAI0di9C2Spq06i1qSS9kAeQyGWRqJVqr9bRDgPKZ0jlf/U8X0owK/eTSRX65/x5uW35bTX8uqQArlhRXnUsXSMfzWNw69GZLJQfgVEOAHC0GYoFMJc8mmyqAsLh3RGtUkV6ACUj7AngA8hXPTQMPgFVDuSSSijV+roG9fvY+PFK1LR7woTc7EORrifkn6Nv5FyZOHOOZX/yI7k1bsbc0prVUaRWUSyLFQhmN0Ug6Hl9yCJBELxrCPGMANDW/aKhA0/EoerMVZ0cXG66/ieblK8/3I11AHVwwAF4CuPPOO8nlctx44408/fTTjI2N8dBDD3H99dezfPlyPvvZzwJw7bXXcuedd7Jv3z52797N+9//fpRKJblUqq4Iyanih88NUyyX2Ts6G6Pf70+yzGXEYVDhTyw+CXF39xIYGeLZsWeI5WI8Pf40ICV+tiSNqPRd5Ds97P3lPYiiiFwBYvkYKnW0IrAyA41eSSY5EwJUxwAQxekQIB3JaJiyxkg8W8Bod57S6t/QgUDd1apiIEDW4Kap14par6y4wr0pLx69h35/kl7XjAdAjW9aDGwiOmsAXNnbhJhczx8G/kDfLh8TT03SZKkVAZsLs1NHdIE8gLGjYawe3QtiABjUCmQCxBZI4FsM+VKer+7+alUoxwz2+fexxr4Glbw6pC2QyOEy1SbY3bjGzf2HgxgUVv711k4sCOjncXGf60TgYCbIJ5/55FlLNJ9BKBPCpqmdoGnl5zcHoJDLUszlKgaAKIqVECAAT+9yIlMT5NJSAms8GFjUA5fPFjmxw0vXBgeBsVnvmkUzawBkknnGj4crBoBhSSFAaSbzPg7lTp6SF3Bw7y72PvD76WvUb5cvJP5l+7/w0ec+TE6ToldYw2t6X1NzTDISQm+1LimuOuJNozWp0OiVUghQTAoBOlUPgM6sQqNTEp7WA5gaiGJx6arylupBu4gYmPoFyAHIpYvIFTIUyvoGgFwpQ29WLZgHkIrna0gYYgE/Sq0VlUbLxa+9nT99/T/44399icjUBJfd/uYFn2nmO8pnimiNJrLJRCUE6A9f+zei3qmG56aiEUqFQiW2/sUUApSORdGZLef7MS5gEVwwAF4CWLZsGbt27aK7u5s3vOENdHR0cNNNN7F8+XKee+45DAZpkvnVr36VtrY2rrzySt785jfziU98Ap1ORyGXRXOG2fbxbIGfbR/h/Vf1sHdk1gAYCKTodRlwGTWVPICFYGtqQZDLOXRiB2vta7l/4H5ASgDuSNsAF66rLiM3FeQv9/6cn/7fj5KLPUipVBsCNaMFIIUA1RmQi1lArHgA0JlIZIuSB+AUBv9n7+1jcH+twVAKBslZWjA5NLjajZUwIG/ai0vrZjScrhgAHrOmQgU6Gc3QYpUm+RvbLJTDFxF6UM3jPz5GuS9J0/REN5+t1gCYgcWlbWgAiGUpKXLlZU2kojkK2Sx/+K9/p5hfmHd7qRAEQaICPU0mIFEUueP5O7j7yN0cDR+t2b/fv78mtAGmQ4AMtQbAG7a0cd8717Hc0US8EJoW46k2HiQD4NyFAB3wH+CPg39kJD6y+MGngPkJwDM410nAu7y7+MPAHyq/M4kECAKa6X4olA2RLCRpN0lkADqTGbPLQ2hkiHQ8xi8/+w/suO+eBe/Rt8uHxa1j9RXNBMdqPQCiKPLnHx2jbZUNZ7vUt+mtSwkBypCTlxgRvafUBxx49AEG9+0GZtRkz60BsNu3m69e9VV6Olt5k/ttmFSmmmOS0yrAS0HEm8LqlihkdRYLyUiIVCyK3rp0GlCQ+oO5icCHn5pg9RXNi56nM6kW1AJ4IYTA8tnFmZuMdg2JcOO2lI7lySQKFQ2acrlEIhhAJjdjsKrZ9trb+duf3cf7vvMj/voLX6vKl6sHuVyGQiWTDACDkWwqgVavJBkJc3LHcxx+8rGG58YDPrQmM4rp/D9bUwvJcIh89vyGA8KMAbA0QbkLOH84t73YiwjxeLzyv1KpRKvVkslkKBRmJzZqtRq1Wk0qlaJUml1B1Gg0qFQqkskk5fLsxEKn06FQKKquDaDX65HJZCQSCcrlMolEAo1Gg9lsplwuk5oneGIymSgWi6TTs5M8h8PB3XffTT6fJ5vN8sUvfpFvfetb7Nixg2uuuYZcLofBYODee++tKtPU1BTP3vMz4qEg8Xj8tMt01+OH6bHIeOMGB9965BCBeAaHUcOJMR9v3ODArCgw4g0irvEsWia120l2cA+fffkdvPupd+OL+9g5uIP2iSwpwci6tuV8b3UKxR9+w9pXvIqBoIJ8eoxMJlNVT2VZllAgTVDMsabZVFumUgoVkMyX8U9OUFCoSYSj6Dw2Ent2VuqpWCojlwkYDIaaelIqVcRDWQITceLxeUZUMEhKY8OpLaJzwNCJKbq2WPCmvKjKFlTlLHohTzxewKwscyiRJZfLMeoNYZa3EI/HUSqVvCO5mkD+OPbbo4zcLcdcspDL5cili5Rl+arvSaPRYHbpGDw6RTwep1wWOfrsBJuu6SGXjLD7kadIZUw4utUE74lw6MnHOfGXp1n98lfg7OiqXMdoNC7525PJZBgMhsq3pyPPlD9Cp1mBXq+XnjU3O/FaqD399ORPeW7oOdqUbYwHxokb4lXf3s7hnXxgwweIx+NV7WnMF6LLoScej9e0Jy05TGUTgXQAXTiNQleubt9qOZlUlnhcaFimGcjl8lMu0/z2dHjiMOVimeennschd5xyHzEXc+tpPDCOoWwgHo9X1ZMsJyMcDZNMJl+wMsFsH/HwiYcZiY1wlfMqABKRMBq9gWRS+pYO+w7jEByoBBWiKJJIJDC1tjN89BAHHnmAXDpFIhqueQczZUqlUux85ASrL29GaxOI+tMk42nKFJHlZCQTSZ7741GC40le+/cbKu+sLMuTiEuheMVSvm6ZYpEw8WKGoXgfuoBAJp1Cq9Mv2JcXsllO7N2FrbmVUqlELl2gJGSqnv9M2tNi9RTMBQmkA/TqewkZhxkf8tG63lBTT76JCQStjnw+v+j4ND7gQ2UWicfjaAwmAsNDZPN5ioKcRCJySuOTxgpj/T7cnSYmB8Nc8ebOyrtpVCZBVSKdKDT89kqCjEgkWrnOmYy5lffoD6PSKiiVSg3LJNMWmRoN4Fmhq1tPQV+IXCFD2JvC3qYlMDlBJpcnniij0Ekev2w2e0rtqSzPE/SFKcrkhINBLM0avP0nyZVK7P3zI6y76dUIglBTpomhQWR6I6IoUiqVKCBQVqgY6zuJs6PrrHx7p9tHBH0+9FZbpV7OpN+rV0/no0yn++3NzCWcTueC397ZLNP8Z2oI8X8ZYrGYCFT9vetd7xJFURTf9a53VW3/3Oc+J4qiKN5www1V2++66y5RFEVx9erVVdsfeughURRF0Wg0Vm0/fPhw3fvGYjHx8OHDVduMRqMoiqL40EMPVW1fvXq1KIqieNddd1VtX7FihVgqlcTPfe5zL1iZMvmiKFPrqrZ///dPir5g+IzL9NYH3iq++/Pvrtp+3fXXiRt/vFH86D98ZEll6n3F28WHDk/Vlunr/y6KnzPXlOkn3/uu+N0P/J8l19N/vON+8Zv/99c1ZQr96MfiJ27+bE2Z/uGpfxCv/9vbq7ZfdNnV4o3/+ZT4T5+pPv6d73yneOf7HhcdWzbU1NMTPz0mXrzxipp6muyLiM32zqrt//6Pd4k7f/9rUa1QVG3/17e9SfzX19/4gnx7N9xwgyiK4pK/vVvef4t48U8vFi+/5vK6397KVSvPqD398+P/LH7zH++tKdM9X9wp/vDOX74gZWrUnnrf0yt++PEPvyj6iLNVppl6snXYqrbf/e07xR989L1LLtMzv71X/I8PvnPJZfrB3z8j/scXvlG1fVX7FnGiL1JTpstW3SxGvKmGZdq6fm3V9m989Sun3Jc/fd/hmjK9kPV0wxtuEN/4hze+YOPTkw/8SfzX191wRmVqc3eLT/38uPjxt9+xpDLd9po3i/d+aVfDMl179dVnVKZG397dn/3zGdfT6vat4pFnJmrKdNPLbj2t9tTi7Kra/ptf/V58+ud3i1q1ekllikQiL7o+otXlPKN6ejH2e2f67Z2PeorFYuJCEETxLAeqvsgRj8cxm82MjY1hmqatO9cegEAggNPpPCUPwJlYhA/99zfRW6xc8vo3nlaZ7t07yfcfP8JvP3gZgiDwT/cdotlh4bWb23jNfz3Kzk9dx51/7ieYzPG1t1y6aJn+9e6PYD2e4cNf/gEPTj7Id/d8F1VfnJsm16E2/BVvueMy3vvUe9li38JPDv6EW2O3UNi3h3/8/r1V9XRixxT9e/x8KR3jZ++7ki6LorpMiRFUd99I8qMn+f1Xv4DP0MEBw0r+89XLuftj7+ed3/kRgkzG5V/6M+++sosP37iupp6yIQVP/b9B9BYlt356Y1WZMt/7Pr8+uZpX/t0GFCoZ93xhF+/8jyv56PaPoE1vQx5fz7/duh6AY94kH/jVEe559xau/8rj7P3M9chlAtlEiV//6z4eXxvmhPzzvHL/HVx6fTc3vWolT/6kD4NTzrprWqrqqZiF737sUd7wmS3c9x972XJzJwcensTmeJ7+g9tx927i9k/9PT/8xL2QeYiujRvROdxse90bKtc5nRWWXeO7GI+M84snTdy8ronbt3Ys+u2FU2E+99zn2OndyYamDXxo64dYa1rLF5//IiaViQ9s/EDl23vw+IN8fc/XueeWeyrf3kx7et23nuNvr1/GVctd0j1TRYrkKvX0cPBhhnJDbHriVjbe1Ez76tlQiMfv6mf5Nidt681npT0t1ke85963snmPmvsvHeNPr3kQ2ZxIyzNZCfvUM59itX01b1n9lur2tP1f8eg8vHfje8/JStjtv76dcDrMfa+9D4CRfbs4/NhDvPLvPwPAnXvvJF1Kc8fVd1TK5B8e5Pdf+zdu/dQdlJMJnvzJD7jtji9XlXWmTI/+6AClssjL3rgcmUzGEz/sp2WVid5tEpXi5//5B1y6bjO3vuOqmjLd+4U9vOKdG7G1a+qW6Y/f/Tq/OnkP+1fEeduOVdz6kU/SvXFTVb/3wDe/wurLXsb6a64jHo/z6F3fJpuMMX7sCJ/42X3s+uMwQV+Yl71pRd16qlemM+nLv7r3q+h0Oj6y7iMMHvLxl9/088ZPX1xTT4989xtYm1u48g1/vej49Kt/3cllt/XSttJGKZPiBx9+N8amVt54x7+f8vgUGI3zwHcOo1ZqecUHVmNpmpOE36BM/qEkz987zG2f3lS3nsIBP99531t577fvRq3TnxUPwPHtU0wdTfGqD29oWKY9j/UzsC/Aq/5mQ009iaLIDz7xDG0r7DR1Oth6SzsHnniUw08+iqv7LRiteq66ffUpt6effP5p1r6smUxynCd/9E3+/ue/5Hdf+mea120mMDqIIAhc83/eW1Omx37wHUSlktd+4KMApFIp6Rtoambra247r6vl3/+7v2Hzza+md+ulp1xP8D/PAxAIBOju7gY4Zx6AtrY2YrFYZZ5bD/9rQ4BMJlPNi9FqtTVquyBVaD3MxN7Xu3aj7eVymWw2i8lkQhAE5HJ53eMVCkXd7SqVqi7n/8zHOx9arRaFWMZmt1dd71TK9Mudo7zr2jWYp2P6LlvVxn37JljXlmJ5qxuz2Uy7x87AicCiZTIYDRzWDnN9zIJWo+GGjhv40o4vca3QiadlOXK1Db1ezwbnBn549Ie8ad2beJlhK9v37EYzXb6ZenK4cvQXosTyAs0WLXr9vPeSKIBSi8FgoJxJ41jeQi6hxjydNCUrFSgozSRFFfGSCrlcig+dW0+Z8QLuLjP+4Tgapa4q9jcUiIFMRUuXC4VShslsIhcV8KV9uHIWLu5wV95DFyrCqTyTiSLNThtWi/Qu08EYOpOKD157JR97ppuUPoVFpkOtVpPPFDFbrTXvUqkUMZqM7LhnjO41LVz6ylXY7BYeuPPHGEzXkBh7lmIygYo+WjZciafbQ3BspOY6p/rtfefIdxiJjbDM8iWKck3lG1ro2xsIDTBeHOeRtzyCR++p7Gt2NONP+6vuczJ9ki0dW2rubTKZiBQVdHqcUmeZL/HjTz/PLR/eQFOvmWw2S5vQxu7+3WRiBTytDkym2e9YqZEjloSz1p4W6iNK5RK5cBBFyEr3mI7h7DAbXRurjg1nw9w/ej9vX/v2muvUe8aZekrKk7Q6WyvHKBQK9DoDFqMFlLNt92yXaT6C5SAJWQKj0YggCBTSabRz+lNv2cvFTRdXtSfD2vW8+d/+C7fbjX+wn1wq2fDbi02V2HpzZ2W/o81IzJvDZDKRjufpyKzFeamqbpmsThPJaI6WFda6ZaKYR9QJbGzbiLpPTi4RBWbfXWhijImDe4mODrHq0iswGPT4jh3k+vd8CO/RQ5RLRQrZElab5Yzb01Lr6Uj8CO/tfC9arZa2HjeFxBB6nQG5QjIsZ+pJzKVxt7RWrtlofNJrDRQSMtp7PRhNGooaDYIg4PR4MJlMpzw+aZfrkZdPYnZqaVvuqMs2N79MRZecdKLQ8NuzOpxo1WpUsup2ezpj7gxUsihqXX7BMi3b0Mb+P3nRaw3IldL7namnbLKAWq6jZ10zk31R1Go15VQST2s7pZwKu1vq00+1PVksJlRyLZmsHo28hEIuxzvQx1VvfRcdK1bw+698Af0HtFXtCaCYiNG8bhOCICCTyTCZTLR09xD1Tlb1Eeei35uPciaNq7mlbl9eDwv1e/Nxvsp0ut/ezFxibj3Nxwtdpka4kAT8vwAz3Neng+PeOCd8CV61YVamfnOHlYPjMU544/Q4pcbiNKqXlAR8PHycsC6LXKkkND6KWW3m5e0vx5PQoTW1VhRcL/ZcjE1j40ObPkRXy0pkZYF4tFptV2NQkU7k0ShlWOtxOxcyoJLKnY5GMFptxDNF5AoFequVRDDIYFCyxhsxGMWDGdydJrRGJWFvteUeD+fQKMsoVXJpAG0z4h+N4Uv7CEQ0dDlmOwy7QY1cJrBvNFpJAAZIRnLoLWquWeFCl7uYpGGY4rRCZi5dKwQGs1SggbEkV75Bklfv2mSlXAhjdq1l9cuu4YkffY9s/Bie3suwNrcQnhhfsF4Ww1hijH3+fRTFInnlceLZpdFqjiXGWGZZVjX5B7BpbIQz4Zpjeyw9NdcolMqEU/mKDkBgLEmpUK6i43NoHEQTcfLZUhUNKEjKo+cqCXgyNYkuJUOl07F2yMRfJp6rOeaeE/fwtT1fI5aLndK1Q5naJOBHf3gE/dH2c5YEnC/lCWaC5Eo50kVpxWohCtC5mJkYak1mMok4Yrm2TvLZIuGJJO6uWW+No81QoQId2OsnaQmQ0dSPcV1MCyCTTlJQlNnq2UpSU6xhAzv8xKMsv/RKTA4Xu/90H1MnTyAC3RdtBSCbSJxTFqBEPsHJyMlKYrzRKmmE1BOsWiqNZ9SfRq6SY7DOqGWrUOv06E+TKU6pkmNt0rPu6tYlU03rjCqKuVJDdi5BEM66FkCj/nQurB4dKp0C72Bt20zFcig1cpwdRiLTY0Es4MfsdJGKZmv6naVCpVOQyxSJ+EVEsYhvsJ9yqYSjrYOWFatRabUM7d9bc1484MdgqxYYezFQgYqiSDp+gQXopYALBsD/AuTSqdMWAbt39zg3r22qotnsdRpQyAX+eGiKnmmee6dRvSQa0Ocnn2dr01bcXT34BvsBuOPSf0YVyKHUNFc60avbrubB1z+IWW3GY24mqyoxOtlXdS2NXkEuVaTFoq0/8ExTgJbLJVKxKGa7jUROmlwbHU7ioQADfmmA8cfrTxpigQxmp1YS4ZmqZt5JJEQMxtn7ujqMjA+FKJaLjAdVdDpmjS65TMBpULNvLEKLZdYASEUlA0AmE3jjuqtIGIaJT4t85TNFVA04odtW2bj0tT2YHNK1wmOjaAwGXvPxK7nk9W9i9NABDPZuRMGKrbmV8NR43QnXUnH/wP1c2XIlr+19LT7xmSWrAY8nxmk1ttZst2kk9d65CKQDOHXOmmNDSYktxG6QVkL8w3HcXSYmT0YrE0OH1kE6lkeukKHWV78ziQXo3OgADEYHaS5YWf/yV6CWqTn+/DNV+8timfv67kMuk7Pbt3vJ1y2LZYKZYJUKcLFQYuRwCMWY9ZwZAL60D4WgQCFTVAy4uQZAqVxiNDFaoQCtB63JhFgu1+V59w/H0VvUlckpgLPNSGgiRalUpm+3j2THZF0KWWBRNeBMOoGgUrLWsZaAIl7FBFQqFjn69J9Zd+0NvOyt72TX/b/l0J8fpmfzVuQKJRq9gUwifk5ZgA4EDtBiaKm0C0EmoJ5WQJ+P5BKFvCLeNFa3rqrP1JktGGynRgE6F6/7u82suqxp8QOnodYpkMmEBalAtYazawAsxXATBIHWlVbGjodr9qVjeXQmFVa3nngoSzFfIh7wYXK6pYUc62kaAFoF+UyRwFgeQRAY2r8Hd3cPMrkcQSZj1RVXc+yZJ6rOKRYKxIN+DI7q/tLa1CL19ecxsjufSVMqFC4YAC8BXDAA/hcgn8mg0p66ByBfLHPfvglu31ItZCKTCWxqtzI4TQEK4DJqCCbziyrEPj/1PJc2XYq7q7diAGSCYUqFAqJoq3gAAHRK6ZkVMgV5nYzxyYGqa2kNKsSSSKuxmve9gmkDIBOXVhvtTgeJ6ZVro91JIhhgIJCk26lvaLzMGAC2Jj2RqWoPQConw2ibM1FpN+EfiWNRW0lkBDrt1UaX26xh32iU5jk89cloDoNV+v2By7eS0oaJBKRBL59pvGJ1yWt72PDy2Xrxjwzi6uzG4tJhcrp4+TvfT8+WV5OK5rB4minlCyTCobrXWgxlscz9/ffz2t7X8pqe1zCR300oHV3SuWOJsYYGQChb/Tz+tB+X1lVzbCCRw6ZXoZxWXvWPxGlfY2flZU3sf3QUkAwAIa1CZ1HWGIPnUgdgIDaALaPB2tTChptfhXFfmGR+dhKzfXI7uVKO1/W+jh1TO5Z83f3+/cgEGT3mWQ/J5MmoFAbi01REjs42ppJTFEqzk01vyotb766qv7kGwGRSWn1sMjSeDCrVGhRKFZlE7Sq+dyhetfoPYHZqEeQCY0fD+AbjaJYX2OHdUXeSs5gYWC6TRqFVs9q+mglZiGjQV9k3tG83cqWSjrUbaF25ho51Gzjy1OP0XLQNkAyXTDxOPrv4SvLZwj7/Pja7q5XV1VppxXguCtks+Ux6SR6AiDeFtal6PDBYbWekFaPR17a7hSDIBDRG5YJiYGq94ayKgeUytcKK9dC20sb48UjN9nQ8h96sRm9RoVTLifrTxAN+9FYHuXSxymg9Fag1CiLeNKloHrXewOC+XXh6llf292zZxuih/VXfe2RqAoVSVVPf1qZmcqlU3bZ1rpCKRpErFKe96HgB5w4XDID/BZA8AKduAPz5uA+DWsG2rtpB5aJ2iS+6xzXrASiVRcLpxh16vpRnv38/lzRdgru7l+GDexnYs5OxI4dwdXaTjhfRW2vj3QAwqgj4x6o2qXQKRKBV16DjzUsGQCoaQa3XYzHqSGQl2XWTw0kiFGAwkOLSbjv+RK5mQiGKIolgFpNTi7VJXxUCJJZKpMtazO7ZMB9Hm4Gkr4BF7sZtUqNXVw82bqOaWKZQEQEDSEWy6Kd56zVKFRaXjmysRLFQklYa6+gA1IN/eAhnZ3fl9/rrXoGndzmpaA6FUonZ5SYyeXoiMTu9O8mWslzZeiXdlm5cmm6Gc7WhLfUwlhijzVirhDnfAyCKIoFMfQ9AIJmt0gDwjyRwdRjZeF07g/sCpCJ5zGozprwNlam2S1Oo5RTy5yYEaCA6gCYpYvU0ccUrbsOQU/Lnp39d2f+bvt/wmt7XcHnz5eyc2rnk6/5p8E/c2HkjSvmsJ27kcIjeLW7klhKyqTPT+WiEv/nz3/DA0AOV31OpKTx6D3aNvWIAZBOxigEwHB+mzdiGQtb4uxUEAa3JTDpeG2bhG4zh6a6OhRVkAo4WA9t/P0jLSisfuPQ9HPAf4CdHf1JzvsGqWdADkM9kUGq0uHVuMKoJ+WfbxKEnHmHt1ddVhLSu+Kv/g7Oji44NUviNxmgik4gTD2bRmRr0U2cZ+/z7anJI1DoF+XS1AZCMhpesAix5AKonZze8/6OsuvLqM33cU4LOtLAYmMZgPKtaAEsN3WpdacU/kqgxslLTHgBBELC6dYSnksSDAUpFA0qNHI2+gRr9IlDpFIwfj2Br0qM1mfEO9NG0bDbB3NHWQS6dJhmZXTAJjY1gb22vEX1TaXXorbbzGgaUjkfRmi2nZBBewPnBBQPgfwACYwl2PzDccH8+kz4tD8C9u8e5/aLWuqqOF3VYkQnQYZeuq1HKMWoUdfMAor/5Dd7P/wsHx3djUBroMnfRs2Ub3Zu28uSP7uKx73+Lpt4V0yJO9SfzSrORaMBXtU0mEygrBdyaBoNxIQ0qHalIGL3FhkWrolQWiWeKmJwuot4pBgJJLutxkM6XSM4LE8kmihSLZUwODdYmXZUHoBSJkFHbMbfOCueYHVqQidjSHXQ5alc/PGZppX+uATDXAwDQ5moCRZmYP0MxX16yLHxgWPIAzIUUDiENsNZmyTV8Ovh9/+95VferUMqkAW6L/Qa85WcXPa8slplITtQYAOWyyLFfxZCl1KQLUlhVPB8nV8rh0tX3AMzE/+fSBaK+NO5OE2anlq6NTo4+EUAsgkNsQtDXrvSfyxCgodAAYjyL2d2EUq1BtraZHU//kXg+Tjgb5omxJ3j9stezxbOFofgQwcziYlSFUoGHRx7mld2vrGwTRZHhwyE61trRdpXRTJ250vd8ZIoZBqIDnIicqGybSk7RpG+qMuAy8Tja6QS2RvH/86GdnkzPhSiKeIfieLrNNcc72wyExpMs2+LGoXXwtWu+xp3776zxougXyQEoZrJodHoEQaDJ00kqHKZcLhH1TjG8fy9rr76+cqy9pY23ffmbqDTayjP7hn3kM0Valp+aYNbpoFAucChwiM2uag+ASqusnZxGwqegAlzrAbC4PZVynitojaoFPQCas+0BWEIOAEhGpNmpZfJktRcgHc+jM0tjjbVJj29winK5xPChLCu2eU57wqueDgHydJkkA04UqzwASrUGS1MzwZHhyrbg2Cj21tqFFenZms+rInA6FkV/IfznJYELBsD/AEyciHD4qfqTO7FcJp/JnLI7biyc5um+ALdeVBu+AXBJt43/946LUStmlRWlPIDawTf+8MPE7r+f8vv/L9co1iAIAiqNlmvf8T7e9Y27eNc3vs+lt72ZdDRfFQI0F3qbjXSk1i2bk4FD2aBTL6RBqSUZDWOwWjHrlHTadewaDtO6ai3jx48wEYyzsd2CWiGrefZUJI/erEahlGNrkuI+J7/8VcrpNMVAgKzOidk9u+ImyATK1gz6WHNdA8Btkib6rXVyAGbQbe2moE8TGJNWvpayYiWWywRGhqqEvkCaDKVjUplsza2nlQicLqR5bOQxXtP7msq2yzzXkhXGGIwNLnhuIB0gX8rTYmip2n5iu5eRfVFc6XYiuUjlWJ1Ch15Z+94CiRyuaQPAP5LAaNOgNUoD8dZXdhKZyvLzO3bQEVxDSVcbyqVUySmegyRgURTxekeQyeUYbdKE/IpV16HOCrzxD2/kG3u/wUbXRjpMHZjVZlbaVi4pDOjZiWfRK/RVCslRX5pUJEfrCivGHhkGn2eBK5weToRPUBbL9Ef6K9u8aS9N+ibsWnvdHIDh+DBdpq6615sLKZym2gMQC2TIZ4s422pXsR1tRmQKge6NUtLjBucG/nHrP/L3T/19VYiV3iJNKsul+vVdyuXR6CSvXVfHasrZPP/5V6/hBx99Dz1bLsbkrDVAK89sMDF50kvPJmeFIeaFxInwCVRyFV3m6vep1inIpatzAJaqAlwui0R9tR6A8wGtUUkm0TiXSGMwntVQlny2iKoeWUQdSHkA8wyAWK7i+bF6dATGJtFbrAzsDbPuqvrj5FIw08e7u8xojEZ0ZkvNd+hs7yQwOlz5HRqXPAD1YG1qOc8GQOxC/P9LBBcMgP8BSISypGL5ijz5XMzIgp+qB+DfHzrOaza2VK1Wz4VCLuOq5dXhGq4GTEC5Y8dp/eY3GGiW8fovPU/B663ab3F7KJdVlMsienN9A8DqbKIQq10NSiFiljeQdy9kQKknFYmgnx4cr1jm4Nn+II62DhRaPR0FH00mDS6TuiYROBkuYHZKk3adSYVKKTB+z0OMf/RvyU9OkVVbMTqq8w9SphDamKMm/h9mDYCm6XcqimKN16PH3ENcEyQ4mkQmE1CoFm+iUd8U5VIRW3P1IGSwqMmlixTyJWzNrac1KIwlxlDIFCy3zq5INRltyLMr+fPonxc91613o5LPemiKhRI7/zCISiPHVWomkpUGWX/GX3f1H6o9AP6ROK7O2Qmixa3j+g90c8lrulGKanKW2gmDUnNuPADelBdNQsTibqqsxNptHnpVHby297X8tu+33Lrs1srx2zzb2OldPAzoT0N/4ubum5EJs9/CyOEQLcstKNVybF1q1Bk9sUB6gaucOo6Fj2FRW+iPzhoAMyFAMzkAoiiSSSYqBsApeQDm8Wf7BmM424x1J9ddGxy8/P+sQj1nAnfr8lsplotMJGe/a71ZPc1CUtsXiqKImCug00nfz+rm9ex7rYb3fuduPvyje7nlY59s+Lyj8VFisjSh8QDLLz77xlY99Ef7WW5dXlXvMLNiXO3pkjwAixsAI4eCqLQKzO5zu9pfDwaLmkSocfK6zmyuMRLPBJIHoMFYMQ+tK601eQDpeL4yPlk9eqJTPuRKC54eM7bm0zeo1BUDwITWaMLTs6zGm+Bs7yQwMlT5HRofxd5Wv52dfwMggs5kOW/3v4Cl44IB8D8AibC06hmaqJ0g59JpEARUmgaJsnWwZyTMn4/7+fsbVyx+8Bw4jZoaA6AYClEMBJCtXs5Xr0mibG8jvauW/SQVzaHWKVCo6nfQbnc7wpx40an+E/zpm18hXipiaPQZ51Og1JKKzg6OV/Q6eK4/KMUhd61hTXkSmUzAZdTUJAKnIvkKy44gCJj1RXK9mykGg4x86euIyDDaqt9rUDuBJm6sHwJk0mDWKjFM5wZkkwXKRbGKPaLb3I1PPo5/LI5Kq1iSW9k/PIS9rQO5otpboDEokSkEUpGc5AGYPHUPQCQXwaqpDncwaZQUkst5rg7F5VzUi/8//NQEar2S5ds82IqeShhJIwYgAP9cA2A4gaujNkZ82VY36dcdJto+UnP+uUoCHogN0F5yYPHMJsDqzBYy8Rjv2/A+/vT6P3Fz182VfRc3XbyoByCZT/Lk2JO8suuVVdtHDofoWCd5GfQ6HWHLOGNHa5lLzgRHQ0e5qesmAplAhXXHm/RWDIBwNkwhl6VUKKA1SmE7w/HhJRkAOpOZTKJ6cucdiuPpqg3/ASlcZPnW2om3SW0ikZ+NE5crZGiNqrphQIWc1L71Bukeq+2rOZofQGU2otI0YBKbxo+P/pijUyOIYobmZZZFy3c2MBofrfsuZ2gj5yK5RAPgwONjrL+mFbn8/A/9TT0WJk5GG+7XmSx180ROF1IOwNI8AC3LrUS9qarvKBWbEwLk0ZEMB8iltay/+vRX/0Hqp1UaiUp12cWXsv66m2qOcbR3Epz2ABTyOSLeqUU8AOcxByAWRWexnLf7X8DScf57gQs4YyTCWeQKGcE6BkA+nZIGtyXEhoLkIv78H4/x/qt6KivWS4WrDhVo9vhxlG1tHMkMYVAaMK/dSPb4sZpz54fCzEdrcw+qjEh5WqHv5PbnOP7sk8hzx1CWGjAPTesApKIR9BZpEntpt4OBQBJvLEvStYymxDCFqSmadUKNByAVzmNyzq6UGYUkWVcv7d/7b7JqG1pZtiLGM4Mx1QDGtK6uAbCt28b3/8+Wyu/ktNGjnDZ6Cvkc6f2DyBMDTB5/FrliaQlwgZHa+H+QjBa9WYqJtja3kAgGKGQXp2qdi0i2jgGgVZKO9bLfv78q/GI+5hsAuUyRPQ+OcOlrezDaNZjyNkIZKbHNnz4VD0B94RWP3oM35a3ZvpAOQGgySf8ef8MynAoGogN48mascw0Ak5l0PApAm7GtapK52bUZX8rHeKKxYfbY6GN0mjrptfZWtuWzRSb7onSslcJhtAotk9Z+Rs+yAXAsdIyLPRfj0Xvoi/YhiiJTqeocgEw8jiCTodbpyBQzeFNeOs2di167ngfAOxjD3V2/bhvBqDISz1dfp5EWQH5aadMwbQC0GFowqowcC9X2R/Oxy7sLecyG1lBGqJMT9UKgkTGl1irIpwtkkgmeu+dn/P4rX+DIk49hctQ3oGcQGE3gG46z5sqWBY87V2heZiEeylYWsOZDZzaTjkbPyr1EUZw2AJbmAdDolTjbjYyfmPUCpON5dCapHzI5tZRLMWQKM53rzyz/xt1p4vZPbkUmE+i5aBs9F11cc4yzo5Pw5DilYoHwxDhqrQ6Drf59rU3NRKcmz4j2+UyQjsUu5AC8RHDBAPgfgEQoS8sKa30PQCZzSiJg9x+YxB/P8p4rayeUi6GeGFju+Ak0K1ewy7eLrZ6taFauJHf8RM25CyUAA3S1rEBeFpgIDAMwceIo9tWbcSSfI1snNAiAQgqUepKhUIUf26xTsq7VwnP9QUbUzSjTEU58/ONsHtxXY7wkI3kpsXca+lyApMqBwulE/9FPYW6rXnErlosMyY9jLClx11lpUsplbO2cPScVqTZ6hvbu4pmf/BBbMk0+uYds/PmG72Mu/MODODvq15dhmhddZ7ag1umJeE9tZSicDWNTV5fTrFUiFmw0G1rZPrW94bnjyfEqA+DwU+PYmvW0r7FhtGnQZc0VD0AjClCAQDKH06AmFcuRjOZwtddnOmloACyQBLz/kVH2PDTcsAyngsHYIKa0Eou7ubJNZ7aQz2Qo5GsnpDqljvXO9QuGAe2Y2sG17ddWbRs7Fsbk0GKeNk41cg1j5mOMn4hQahD7fqrIlXIMRAdYbV9Nr6WXk75j/OGbXyZTSFdyAEKZUCX+X5DJGI2Polfqa8TK6kFrMpOeE99dyJUITaTqJgAvBJOq2gMAUu5LvUllLpOmrBAwayyAZCCvd67nQODAgvcIpAOMhscxJtuQKxYXO3xo+KGGOgWngtH4KO2m2lVe9bQHYGjvLo489RgtK1Zx04f+jk033bLg9fY/PsrKS5tOm63mbEOlVeDuNDJeh3MfQGe2VoznM0UhV0IUqQohWwyeHjO+aUGwYr5EPlNEP+0BkMtlyBUp2tZ0IjtDb4ogE7C4Fx6jTQ4XCpWK8MS4FP7T2t7QY2VxeygViyTCixMMvBBIxaLoTKfWji/g/OCCAfASRz5TJJcu0rXeTmgiVbs/nUKt1VEolfHFsxz3xskXG08SvvvUAB+7fjnaBqE4C8FpqE0Czp44jnrlSnZ7d7PVsxX1ipVkT9QaAIt5AAw6MzlVmdGJPgr5HL6BfoxX3UpR62R0z73gP157UiEDSi2JUKAqqeqKXjvP9Qfpj5bQtvUyGQvhzMXw1XgACpics14QXXSESN7In39yjB2P+nB2V090gpkgWUWStFwk6Vt8pV1iAJotc2h8jO7NW0m/YiUK3VXkUkMLnD0LiQGofuLlDCuKIAjTicBjdY+L5WL84NAPuH/g/qrt0Vy0xgOgVshQyWVsclzCsxON2YDmi4D5hxN0bXAgCAJGmwZlWjcbAtSAAhRmPQD+kQRWt65hYnRDA0BTPwSoWCgxuD9AeCp1VibOA9EBlIkiFvdsqIrGaARBIBOrH8qw1rF2wRXoqdRUjY7C4L4A3Rtn35VWqWVCM0i5KNHWng30RfrQq/Q06ZtYZl3GUP8h+p57ho6EFYPKMOsBmJMAPBP/v5SwtflJwP7hODqj8pS51Ot5AGxNesJTtX1hIZOhrBQwqmYNyA3ODYsaALu8u7godQ1pVZ5cZnGv3Be3f5E/jy2cH7MYRFFsKKim0irIpYtEfVO0r1nPllteT9fGi1CqGr+7ZCTHwJ4AG66tzxxzvtDagHMfpj0AsdhZEbXKpYsggEq99HHN02XGOyR9W+l4HplMqDKeNLo0a69cecbPthQIMhmONikRODg2gr2tfvgPgFwxQ/t8fsKAMvEoOvMLz5J1AWeOCwbASxyJcBalRk7TMgvhySTiPCGuXCZNGiXLPv0g2774ODd//Rl+t79+glAwmeOkL8H1q9yn9Swuk5rgfA/AsePIl/dwIHCALZ4tqJcvpxQMUgxWr04sZgAAFPUKJr1DePtPojWZmBJVlLquIew9yMS9n6s9IZ+mJNeSjEYw2qUJU9Sf5vJeKRF40J+kff1F+IQSlmyCQCxVESfLZYrkM6XKKiuAfvIoJqsclVbBdW9fzeW39lbdbiI5gUFhJ2dQ1PXGzMf8MofGR7G1ttPW7EZQtFDMJ4j6aie0cxEaHyWbTOLq6qm7fyYECKapQOdpAZTFMv+x6z+4/tfX84vjv+B3/b+r2l8vBEgQBExaBSvNW3l24tnKAP3g0INVBsRYYow2w+yEI+JLV1a6jDYNsoyKcGqWBaieAZDKFUnnS5IBMByvif+fC4/egz/tp1SunuwrVPV1AEaPhKU8CbmMqPfMEmgT+QRHg0cohhNYPLMeAJlMjtZoIh2L1j3PpXPVCKLNhTflxaObNShKhTLDB4N0b5p9Vxq5hjIltIsIK50KjoaOstq2GkEQWGZZhn9KElzrDVkAScchmouSikWqDICFFIDnQmc0VzG8TPZHaV526tzh9TwAjlZDRSF6LnKZNEWFeMoGwM6JXWwYvZaB5qNkF2GlCWfDRHIRDgUPnUIpauFP+8kWs3VF9NQ6iTYy5vNidi8tIfnwU+O0rbYtutJ8rjGTbFtvkq8zWSiXiuTStcbcqSI/ralyKuFb7i4TofEkhXyJVCyP1qSqnF8ul0iGA1ibmxe5ytmDs0NKBA6NjeBokAA8g/NJBZqKRtGZL3gAXgq4YAC8xJEIZTHaNFjcOsplkViwmlUhn0mTRcmr1jdx8l9v4tbNrUxE6jMvbB8MscJjwqo/PZGb+TSg5VyO3NAQQw5R4v83dSE36FF2tJOdFwa0FANAZtIS9E8wcewItJi5d+Kf2KwewGzayK+fifPk979BPjNnIldIk8yKUiy81UoskOFnn91Oj1pNPFsgkSuyYcN6gjo1uZiX5du/z08/9TEK2SzxQAalRlZxGYvlMsL4AK9+ZzdX3LaMttW2GraSodgQOsGDyqZekgEwP+wpNDGGvbWdHns3BW0evbWd0cP7F7zG8b88Q9emLQ05vOfyotdLBPamvPz02E+5+xV3c8dldxBIB6r2h7NhbJra5EKTRkmzZg3xfJz+aD9Hgkf49LOf5j/3/CeFcoFEPkE0F61MYMqlMjF/GqtHmoDoTCqQiSSnVVv9mcYqwEq5gFmrJOJNY2tpzLbh1rkpisWaCbVSLaeYK9UYx327fSzb4sberF9SfS2E5yaeY4WiE1EUMc6LxdabGyczzoTS1ENZLONP+3HrZw3y8RMRVFoFro7ZSaxWIdW92ig/qwbAKvsqAHotvaT8AWR6Na7JaXaj6TCfcMSHZlp8ajg+vGQDQGsyVb2Tyb7oaSXX1vMA2FsNhCeSNark+WyGwjwDYK1jLcFMsK7naAaB3UW0Gg3RXi+lQqGSTFwPA1FJrfxI8Mgpl2UuRuIjNBuaUctr+0S1VjntAfBicS3NAJgaiFUoVF9M8HSZyWeKdT02Kq0WuVLZ0Hg+FeROIf5/Bka7Bo1BSWA0UUUBCpAMSQxYRvu5e6eO9i6Co8OVEKCFcL6YgIr5PPlM+gIN6EsEFwyAFxEmoxne8v0d/GLn6JLPiYeymOwa5HIZVk/tRCaXTpMVlLTZdKgUMprMGryx6gHsnhP38OlnP83zAyEu7T79hCaXUUMyVySdl+Ktc/39yLRadgnDbPFsqazuaVasJDcvETi5BANAYzETDwUYP36EvaoBIsUBViceQmG9mrdcLsd3dBd3f+JvKtSnFNIk0mWMdgcymbwSazq8L8DFXXZaLFqceh2qYolDaT8nDctRKFXEQwHiwQwG2xz6ykAQsVBA0dRU58kkDMeGoeDCssQJpaQCLJW5XCoRmRzH0dpOt6WbqDqAxb2ckUONVydFUeTE88+w4rIrGx6jt6oqyqj21nbC49XfViQbwaq0sNq+GofWUTMZrecBADBqFOTyMrZ6tvLg0IP83VN/xwc2fACVTMVTY08xnhjHpDJhVksrQfFgFgQw2qdZlWQCSpNANlqiLJYJpoMNVICl+H9BEMgk8ugXUGBVyVXYNfaayZxy2u1fLMx6AQq5EsMHgyzb6sbeajhjA+DPY39mm2Y9Zqe7ho1JCmWI1j3PoXU09ACEs2EK5YKkWjuNgX1+ujc5q1bKNQopTE1lkL0gBkCXuQt1UiSxwogyWSI8OY5SrsSoMhKJBCoiYEtlAAIpB6CYy0ksQsUy3oEYTadhAJhUJuK5agPA4tIiAjF/tVcnn06TkxerDACdUsdy6/KGXoDRwATdA9u48rblOCxuECCTaBwGNBQbotPUSV+kj1xp8XyBRljoXc7kAMT8Xszuxv3RXKSiOQyWUyN1OBeQK2U0LbPUDQMSBAGd2XJWDIB8poh6iQxAc+/v7jLhHYxNU4DO9j1RnxeTw1nT1l9IONs78Q70EfP7luABOD8GQDoeBUGo9AkX8OLGBQPgRYI/H/dx8zeeoc+f4OD40qnPEuFshYrS0WKoyQPIZ9KkUeCZZvTxmLVMxasNgD8N/ok9vj08Pxjisp7TNwAsWiUKmVBJBM4dP4FmxQoG40OstM3GSqpXrqjrAVgoCRjAaHeQC0UZO3GYkL2ESoQRm51sVob9qrfxhq7jFHM5wuPTce6FDPFUobJKM348gqPNQN9OH1cvd7CqyUQ5FGLzsI+r42WeN2xAb7OTCAWJB7PoLLMdfmFiAoXLhUzVeAI6FB8ilbTR1mUmNJGqWXGej2Q0X1EBjvqmEAQZJpeLTlMnfu0ops5uxg4faMjmEBgZIhEK0L1pa8N7GCxS8ixIVHKhCYlJYgZe/yg3/clIJpnAqXOSKCTIFme/j0g2glVdawAYNAoSuSKXN1/OXYfuotvczWXxm3lt6l3ce/LeGgagqC+NxaWrUpXWWRWU4gKRbISiWMSprTUAIqk8Fp30ztPxfEUArBGa9E1Mpaaqts0YAHPzAIYPBjHatdia9ThaDATHTz/MoFAu8Oz4s6wQ2qsoQGegXYDO0KFxNFQD9qV8WNXWygS/XCozdCBIz6ZqT4lMkKGWq1HoIZM4cwOgUCrQF+1jjW0NIBkYjpyeo7IRlF0uBvZISct2jZ1ELFSdA2Be3AAYOxbGN5STciMScQKjCRQqOTbPqXOpz6cBBZDJZdib9TVhQLl0mqy8gElZPTlZKAzoid8dImMNsWJDKx5jE6iVC4pTDUQHuKLlCowqI8fDdfKSlojR+CjtxvqrvCqtgmI+Ryoaqco3aQRRFEnFFl9gOV9oXVHLuT+Ds0UFmkufugcAwNNtxjcUJzXPAxALeDG7Ti9U9nThaO8gm0ygMZoWXWE/X1Sg6WgUrdGETHbq7/oCzj0uGAAvAhwaj/HBn+3lc7es5mObbUS9gcVPmkYilMVglyYItpZ6HoAUibIC9zR9mcesxhubDQEKZ8McCBxgIjnBcDjIxd2Lc0k3gkwm4DSqGZ8OMcqeOI561SomEhNVarCalSvJnZgdHIv5Erl0cdEByu5qRjWeIl8u8Lott7M6l+XEss0U82WKPTcjJH1YbabZlY98ikQyi9HuRCyLjJ+IcNmtvaQTeW5qsXPnmzdRDIWwIkMbCqGUC6jMNhLBwPRkc3Z1pzAxgbJlYfq8odgQ4aiFFb1WSoVyQ3q7Gcz1AITGR7G2tCKTydEoNIyu24X55WaKhUKVAuRcnHj+GXo2X4xyAY0HvUVNOppHLIuYnS7kSmVVHoBvsB9FAcaPHcaitqAQFAQys99fJBepGwJkUCtIZotc234tlzdfzhev+CKD+wJYp9rZ6d3J9qntVfHLEW8a67z4Y5NNC0kV/rQfk8pUmejORTpfqugmZBJSHO5CqJcILFfIkMmFKiYgKfzHhSAI2FvOzAOwx7cHjUKDNkXdFdmFPAB2rZ1UIUW6UJuD4E1JnPszmOyPIQgSO8l8aBVa5Hoqys9ngr5oH1q5tqr+DCk5PlUc+9oVDOyWtAtsGhupRAyt0UQ0GyWWi9FhXNwAOLnDy19+O4jGYCATjzPZF6Wp13xa9Jr1QoBACgOabwCk0wly8lKVBwAaGwDZVIHEPgWGl0l149F7KGlkCxoAg7FBeiw9rHGs4XDw8JLLsc+/r+oZRuIjDelUVVo5YjmKUq1BuwS2lXymSDFfrtIbeTGhdaWVyZORuurNM4nAZ4p8pnhKDEAz8HRPewBieXRzRCpjPh/mJYZfnS2odXpMTjeOBRiAZmBtbibm91Ut9pwKivk8D337vygVT01AMR2/QAH6UsIFA+BFgKFQitVNJl63qZVl9/2ILY/+csnnJkKZeR4AadAr5ksceWaCfDpNrCjHNeMBMGmZmhMC9NTYU6yyrcKkdNDTGsekOTOKuPXLJvjR89Lqfu7YcTQrVzCeHKfVMDuZ0KxcSW5wiHJOmqykYjlkcgGtYeF7ezydKPMQshW4uaimJadk0iR1UNm8AtbfjlUWmaW6LGRIxDOYHE5Ck0lKhTLNyyz0bHTy6GPb+eLOOygGgqiXL6Mcj9OslSMYLCRCkgGgOQUDIF/KM5GYoJRz0u7UY23S1U1ErByfLZLPliqsJ6HxMewtsyvmPZYe+mL9tK5aw+jh2snJUsJ/AAwWDTKFgH8kMc0k0V4RlAGIjUrekrHDB5EJMmxaW2VFuiyW67IAARjUSpK5Ih69h+9e/13MKjPewTjxqRxXtVzFfX33zfMApGoSEG1OE/qsmcHYYEMNgFS+iE4tp1Qok0sXq1bh6mFhKlBpglHMlxg5EqL3Iume9hY9qWiurpL2Yshn0jy5549c5bqCmNdbpQEwg4VWMc1qMwpBUTcMyJv2VoX/zLD/yOpMlDUKDehKpBOnN+DPxYnwCVbaV1YmGflsBnmmREJXpGvTFiZPHiMdj2HX2skmJBXgI6EjtBhaMKgMi14/EckS9aVRqY1k4rFKAvDpwKQy1TUAHK0GQvPaXzIZpaAQa55xg3MDx0LHyJfyiKLIfx/4b76868s8cvAJ8vIMF6/eAEjfVk5VXjAReDA6SLe5m7WOtaeUB/DfB/6bb+z9RuX3SGKkoQdAoZQjCAkMdteSkqaT0RwKtRyV5sW5KutoMyKTy/AO1rYRnenshACdTg4AgLPdRCZRwD8Sr/YA+L3n3AAAyQvQSAF4Low2ByqtFv/w4GndJx4McOSpx6rGiqUgFYtciP9/CeGCAfAiQDSdxzadeKuNBlg9tH/JIh6JcBbTdFy1vcVALJAhmyrwwHcP8eTPTpCIxIkU5ZUQoCazhkS2SHJ6NfSJsSe4pv0aNOU2Wpz13bBLRVkssz/3bZ6eeI6T3jjZEycQezsJZ8O0GGcnz4qmJmR6Pbk+iXEnFc2hM6sWXQFsb14GQOuKNRTDAcx5EwOJE6h1CjLJAmx6K5Z0H5GJ6Tj3Qpp4LInR7mT8eITmZRbkchnLtrqJHC1xwH+QYiiIurcXZDK65DmKWguJUJB0LI/GsHQDYDQ+ilymYrW7HYVchq154VXlVDSHXClDrZPuERofrYrrvKXnFu46dBeWZV11DQDfYD/pWIzOjRct+M7kShmrr2hm36OSQq6zvavKo5Ae91NqNjJ25KC0X+usGACxXIyyWMaittRc16hRVL4hkFb4y8UypWKZVztvoygWqwyAiG82AXgGVocBU97O8fDxhgZAOldCr1KQSeZBYHEjUe/Bl/bVbJ+rBjyTeDxjkKh1Sgw2NUef2UEqemptYOf9v0Hxk30YvrOX/t3bsTbVfiMLeQBmjK56icC+lK8qAXjoQDX951xoFVrQFs+KByCUDeHQziY3xnxeZBoVOWWZztYVuDp7eP7XP8fzoI/ieBBHeyc7pnZwsadWwKgeEuEcjjYDxaKKVDzOVH/sBTEA6nkARJUMhaw6brvN2IZBaeBo6Chf2/M1ftv3W3LFHA8eeoyUJsZG10ZASjJPKwsNPQCJfAJ/xi8ZAPa1HA7NegDGjx9h+OC+uucVygX2+vey27ebYCZIsVxkLDG2YEK1TBbHYK3fZuZjJrzyVBmWzhVk00rex56bqtmns5y/HACQ+g17i57QRAp9lQdg6QxMZxOX3fZmNi+i9wASbWjH+k0M7dtzWvdJx6R+0Dtw8tTOi0YvGAAvIbwoDIBvfetbdHZ2otFo2LZtGzt3NhbGueuuu7jyyiuxWq1YrVauu+66BY9/KSA8J85ZEQ5iySaI7qk/WMxFMV8ikyhgnA4B0plVaHRK7vvqXkm0xKImGUuSF1QVJVWLTolaIcMby5IpZnh+8nmuabuGeMyFUlefCSORT9Sww9TDeGKcdDHF2o4sP/n9DsqpFAG3Bp1CVxVHLggCmhUrKmFAi4mAzcDjkSbIN1zxBpKhSRxlFycjJ1HrFWRTBWjagNWsJDIqGRYU0iSiMYwOyQBoXSk9Q/MKM8VikeK4kkIggMLlQm630SGkySgNxKdDgNQ1BkBjyreh+BDqsptrlkuDstmlJR5qHAKUnDcoSxSgsxPmGzpv4MbOG/l55kHGjx2uccWe3P4svVu2NeT+PhI6Uqmzjde1M3QwSNSXxtHeUbWqU/bG0FzSS2h8jFQ0glPrrJwXyUbQyDXolLXUgQa1gkR29pm8gzFcnSasTXra8stYY19TlfcR8aaxuKtjvE12bcUAqBf/D9MeAJXEbqPRKxcV3fHoPUwlaycSc8XAUrEcelP1hMjWpOHZX3yT/l1LE1+bwejIcQ6uSvHu7/2It/37N+jcuLnmmMXimB3a+nkAc0OASoUyyUgOe2v9FXaNXENZmyd9FnIA0oU0euVsXUV9U5hcbrRKLS6di5WXXUn/ru2o21zE3r4Gd1cP26e2s61p26LXFssiyUiWba/uJpdW4O2fQhRFHG31xd0WQz0aUJAWQ+Z7dTKpBDJ1rQdJEAQ2ODfwhR1f4P6B+/neDd/jM5d+hvf3fJgtPRsq379H7yEuz5CO1xoAyUiYIwO7sWvsWDQW1jjWMBwbrihlH3/uaXb/4bd1y3AkeAS1XM0G5wYeHXlUymERocnQOMFXII7WtLDy7wxS0eoE1hcj1lzZTP8eP7l0tQdrrpL2mWAxD8BCWgMz4nS6uUnA/nOfAwDg7u7F1lxLDVsP3Zu3MrRv12ndJzWtwDzVv7gBEPN7GT8mGbvpeOyCAfASwnk3AH71q1/x8Y9/nM997nPs3buXDRs2cOONN+L3++se/+STT/JXf/VXPPHEEzz//PO0tbVxww03MDFxfjhvzwYiKckDIIoi5UCAk9Z2Ag8+suh5iXAWuVKG1iitbAiCgKPNgEIp45aPbMTi1pFJplDrdCinJ06CINBk1uCLZ9k+uR2H1oFGbCYWcxIuDte9zw8O/YDP/aWaZz+RT/Cd/d+p2jaT9NbsTOB9djuy3uVM5P20GFtqVp/UK1dWEoFTkfySEtRUag2v/vin6Fi5mYHBAVY7exAEAUFTlgZ6QcDas55oIIBYyEG5SCISRW+zM9kXrRgA/fF+hp2H6ApuJO2fROFwoHA4aSpniMsNkgcgfmoegIHoIMmkjatXSIOy1qBaMKRkrgpwuSwxq9hbql3+/7D1H4gY8xRKBSLz6DtD46M0LVvR8Pqfe+5z3PH8HYDEub/sIjf7Hxut8gCkohFkqQK25b04OjoZO3oIu9ZemYyGs+G64T8Ayl2/JxeYbXNTgzE8PWacrQbCEyl++apfstq+GoBsskA2WcAyzwNgtGnQ5UycCJ1s7AHIl9CrFUtKAIbpEKB0rSGrUMkpTocASQmR1deSCSMUcimSkfqqpI3gnxihubUHs9mOs6OrbvKbzmwms8AqZj32JZBCgGYMgExSmtg38oBoFVqKmizpeP60hJPioQx//NYBsqkCqUIKvWKuAeDF1dTOo7c9ilKmZMstr+d93/kRnusuISiLE8vFOBE5sSQDIJ3IUy6KtK60orOY6ds1TFOPpW5Y01JgVBnJFDMUytVtTa1TYrRpCI7PGgfZdAqFpn4/s9G1kfHEOP99/X9X2HcS4WyVMJlH7yGlyBOPVRtr6XiMX37uH9j7k1/QbZEUuR1aB269m6OhowAcGd3L6MnDdT27u7ySSvorOl/Bw8MPMxIfodXYWuOpmItyKYpavzTChqVQLJ9v2FsM2FsNnNxZ7b2TWIDOQg5AurEHIJ9J8933vZWYv9ZzCODpkpLGZ0KA8tkMmXjsvIQAnQq6Nl6Eb3DglL2aII0NCqUK7xIMgKd//iN+dccn2fvg/aQvqAC/pHDeDYCvfe1rvOc97+Ed73gHq1ev5rvf/S46nY4f/vCHdY//2c9+xgc/+EE2btzIypUr+f73v0+5XObxxx8/x09+9hBOF7DqVJTjccRslufWXk3+yT8vOpDPaADMnVxf/8413PiRlTw8+QD9paPkM2kMxupVQ49Zw1QsyxNjT3Bt+7XsGIqw3LqcodgAhVLtpPVA4AD7/PuqBJaem3iObx/4Nr7UbKd5PHwcs9qMPzvGq/Jj7G9ayURyoir+fwby3pUc7Zfzl9/0c3KXt8q9uhCWbbuMbz05hFWMsW3tKlZYV5BTpclMxz5b1l5DLl8mE/aSK8nJZTLkkhrkShn2Zuk97JjagbFNjjvbTs7vQ2F3oHA4cBWShNCRCEorUTMGgFguU5icRLWAAbBv6iRC0c36VgsAWqNyQUaWuSrAMb8PRLGG0UOj0PCVq79KUpnn5OTRqn1zFVjnI5qN0hftY6d3J/v9+wHYdEM7x7d70VmaSIaCZJNJfEP9ZE0yrBo37WvWM3bkIE6ds5IEHMnVpwAVy2WKx7aDdza+1DcYo6nbXDf5MuJLozOpUM9T8DVY1cjKCrLJQkMV4FRO8gBkEnl0psVd+B6dh2AmSL5U/e7negDmJ/QBRKf2IsjUJMONRbnmQxRFCuE47e2NDTGY9QA0as8OrYNgttYD4Ev5KjkAmURhQQ+IVqElr85QLorkM6eWuFculXns/x1l4niEPQ+NkCwkqzwAMd8UZk9ThdJ1BjatpAa807uTbnN3VdhQIyTDEpuKQinH0+0hm0zQvOz0JwwmtdQG6noB5n2L+WwaZQO9jL9e9df89tW/rfJaJcNZDLbZxHS9Ug8aJdHIrDe0kM/xuy9/HqPdQWbYS7duNoxvJgzoNyd/w4RvCDFbqNHhANjp3clWz1au77ie/f797PbuXpROtVSIotb9zzEAAFZf0czR5yar2onkATg7ScCNPACxgJ90LMqeP/2u7n5PjwW5QlYxAGJ+HyqttmH/+2KBzmzB3d3D0P5TDwNKxyK0r9tAaGKsWltnHjLJBAO7t/OKD/wt23/7K/p3bUdnsZzBU1/AucR5NQDy+Tx79uzhuuuuq2yTyWRcd911PP/80lzx6XSaQqGAzVafvSaXyxGPx6v+AMrl8nn7E0Wx6ncklcOiVZCfmkKm1zOx/hKEgJ9sf/+C14mHMhht6qptf5z8HTf8/np+eOiHHMsfpJTPYDIaqo7xmDRMRBI8OfYkV7dezeHxKBc196CUKRmIDlQdWygWOBI6QqqQ4kT4RGX7jimJCWS3d3dl2/Hwca5ru46R2BC9o0f4rayVscQYLfqWmmf3yzwMyFeRzxXpWGtn1RVNS3p3+0cjfP/ZQdaYMwgGFyttK4nrAgRG45TLZRTLr0GvyBHqP0iioEap0eAdztKy3IKIWHn23pYODHkLpVAYmd2G3G7HmkswWdBQzOcRyKLSyqR34PcjFgrIPJ6Gz3UyPMAqew/C9D3UeiluvdHx4ckkRruGcrlMcHQEa3MrCELNcR3GDtR6PTsGn6nankkkUBuMda+907uTLlMXb1n1Fr6+9+uUSiWsTTpaV1g4viOCwebAPzKIb6CfhFFg5FsqPL2rGT18ELvGTjAdpFwuE8qEsKqtNdePeCehmEdIhCiXy6QTOSK+NM5OA7YWPcHxxLzjk9NCddXXkSkESpo8xpwVh8ZRtyypXBGtSk4qlkNrVC3anmxqGwpBgTfprTpGoZKRzxYpl8skI1l0ptlrJaMR/EOHUGg2kAgFl9yO07EYsnyZro7VCx6nMRopl0pkEom6+21qG4F0oKbd+dN+3Fq39IyxLFqTsvE9FBqyQhq5UkYyml1yGcrlMrsfHCaTKHDL327g8JPj5CIiOsVsfUW8U5id7przrCor4WyY7ZPb2ereuuh9RFEkHspgmO6zPN1u5MocrStrv7Gl/ikFJWq5mmg2WrPPPu9bLGQyqLTautdRyVS4ddVlTESyGKzV35zGaCQRD1MulykVizzwza+CIPC6f/xnCjqB5vDse1ttX83v+n7Hl3Z+CadopiyDiRNHq66XLWTZ79/PFtcW7Bo7m1yb+NWJX9FubG9Y5mKxQDEbQaa0LOkdJaNZdOb6bWex9nQu/3o2OYj5M/iGY5VtWpOZdCxS9/hSqbTka2fTBVRaed198YAflVbHoSceIRWt/Y6MdjVv+cIlyBRS/xz1TmJ2ec7bezqVuurcuIXBvTtP+bqpaARnZzdGm52pgb6Gxx179klcXT2suvIa3vT5/8DZ0YWjrfO8v5cX29/5+FaWgnOnYlEHwWCQUqmE210dS+d2uzl+fGkcyv/4j/9Ic3NzlRExF//2b//GHXfcUbM9EAiQzS5M0/hCoFwuE4tJq4EymWR/+WNpZIUMwRMnwW5Hb9DgX7YO3f33o/3rv254Le9oCLlWZHLKRzhTwGVQcd+J+3hb99t4Xcfr+JfxbyCWcmi1qqqQKpOizBHvCVJiimaxmUNjA9y40kYXXewa3oWlYKkcO5gYBBE22Tfx1MBT2IqSobV9YjvN2mb+MvIXLtJLiahHgkd41bpXsWfiNwgZBXsMLegDe7nYuaUmpMsXKmCN9bHyWilxsEgKv39hLvayKPJ39xzjbVs8qE4EiBSUtChb2KU+iO1Ex/Q9BCw6Ad+eR7CV9egsNgb2+ei6yIrf76dYLrLbu5vbVryZo9kssmiSmCAjp9Wi9gaYsBS4WK1FoU4Ri8dAgPLRowgOB8HpuMj5EEWRUH6cGz3tlXJmclky8XzdULZCrsTg/gBXv6sLv9/P6Ilj6B2uhmFvJqOd3aP78Pl8FW9POh4lUyjWPeeZoWdYa17Lzc6b+eWxX/LQsYe4yHERTWt0HH3Ch8nTxNCRw3hPHiOl1CCmoSC3EvN7MQYLTCWm8Pv9jIfG0aKtucfYISlhWJYI4ff7mTqZwGBTkUhHEdVFkuEc4yNTlRW3icEgarNQ91lFXQ5D3ooiq6i7P5JIUzbLCfnKIKfmmHrtya62c2ziGKo5Qm5likRCMfx+JWF/HJNTXbnW8Scfw97RQyzYTHhqZ8N6mA//UD9ZVQmb3LngOaIoIlcqGR8axFQncVBdVDMZnay6RjAbpCgWISWpJPsnoijUteWvoACheBCrvovJUT8F2dI49UNjafY+PMLV7+xEps/RssaIb18PpaZS5V7hyQlEtabm3mJaJJQJ8Zfxv/CeFe9Z8B3M1JN/tIhSJ5WjJBMwu0VETQa/v746+VKgl+sZ9Y6iy1aHmCmNJbz7YpXnKmSyyBSWJddvPJihQLrqeLXOQGpQuubkscOMHzvMK//vHYSjUaYcedwDkcrxrfJWhuJDfGLtJwg//Du8rhKDB/fjWrOxcr1DkUNo5VoMOQN+v59LbZey27cbq2Bt+JypcAhRLJPNypdUllgwhXtFbTuuh3rt6Vyida2JvY8NsvkWKd8qky+QS6WYmpxErlBQyJbo3x4mOJYmMp6hc7OF9TfOtqnQ2DD9f3mGbW98a9V1M8kc6WySeq9gYmgQR2c35VKJ5+67h/U3vbpqfy6d4pkffJur3/cRFCo14wP9aMxL/45eKCylriydPez50+/wTk0iky99uhf2+dDaXVhaO+g/sBe1o36+w4FHH2TZFVdL70KQce2HPgEs0E/9L8T5aFOJBcQK5+K8GgBnii996Uv88pe/5Mknn0TTgAv9k5/8JB//+Mcrv+PxOG1tbTidTkznQa2uXC4jCAJOp7PyMSTyR+hsdqCfOkS5uZlOt5nh1RfTuf1ZXB/7GOHJFCd3ernktT3V18oFcbWY+NnBKDuHI9z7vkuIFqNsbt+M2+3G5tQjiEVamly4XLMx1t1NGQ717aLL1oXH7WEwfISty5vxT65lsjRZdewzsWdY41jDpU2XSmwtLhf+tJ/JzCT/tO2f+OWJX+JyuQhlQoRzYa7ouYLDEwaKmztRqFV4c35WNK2ouibAgeIYusQkTqdzyewUz/YHiWZKfPwVa5DtD2NtXcE2sYMfHr6b1ZEbMajN6MxqbG4XmYk+EmUjOrODqD+DfbP0Dg4GDqJWqLl83cUcE5+lJNPjXrGc6OFDZMcmCaeL6Ex2FJosFosFp9PJsSd/j661uaYMMzgZnKBMnjdffCkuixTOoFfnKOQGsdscyBXVjf7481NY3DqWr5di/vdEwzT39Da8fltTN7tCfQTkAdY61lIulchnMrR0dGC014bOHN5xmA9s+ADdLd28c907+cnwT3jFqlegU5nZcc84qy7pJRcNEZscQzRJYRtapQ13dy/GSJFoIYrL5SI/nKfJ3FTzXIPxKAqtHm1OOm5oe5KWZdbKcXrLCEJOg6tDCh/KJ3w0L7fVLZ/aKsOQs7GiZQUufe3+ojCM225GmExga9LXXKNee2o2NZNT5aqONZjCqJVqXC4XpdwkrpbZ53l030423vBKDj6RJTwWqzrvyFOPM7x/D6/86D/UPFvfwWdJ6Ips7NyIUrZweJLObEGjlNd9B52ZTp4KPFW1zxvwYtfYafVI4XMTQhaTrbb8M7AarMjVcgwWDWp54+NAMkj8wwkOPz3BwN4Al7ymh+UbpPu87HYTg58NYs2VpXdVLJKKhOhcsQqTs/qamryGfDnPZGaSa5dfi0nVuD+dqSdfPoajSaqHdEsrx7OZBZ91KbBoLcgNte9WjYGdv5kg7ZVha9ZDvojJYl3S/UqFMtnkUdq6m6rCZ+yOJsrZIVwuFzt/vpN111xPe3cPmWKGAWuYtaOByvWvd17PTxw/YbV5Bd/M38ugK87KsZGq+/d5+7i46eLKIthrja/lW8e/xdrmtQ2fcyzgRa23opTrllSWXKqf5g4nLtfioVb12tO5xJYbddz3lb1c+uoVmJ1aStOefaNGjcFm56mfn8A/kmHVZc2YXqHhke8fZcWWVtpWScf5jxxgaNdfuOn9H0GhnG2TpXw/rmYHLlftN9pXyGFvbmHZxZfxwDe/wlVvfEuVtsrQ/j34+k+QGB1ixWUv40g6hbO1/Yy/2zPFUurK6XDwtFpNIRykbc36JV+7mEnjbm1DrVTgHeirW9bAyBDxgI+Lrr8Zta6WKOICJJyPNtVoPjwf5zUEyOFwIJfL8fmqk298Ph8ez8IJNl/5ylf40pe+xCOPPML69Y0/bLVajclkqvoDKdTofP0JglD1O5ouYDeoKfn9KN1ums1a9rauI3vsGIWBAXxDcY4/75WOTwWQlXLIZDKS4RzoFdz9lxECiRyCIBDMBHHpXchkMjxWCwBum6Xqfk0WLYHsGN3mbkKpAtFMgZUeM6tsq+iL9FUdezh0mPXO9VzkuYi9/r0IgsBu/25W2lZyTfs19EX6SBaTnIyepN3YjkljYuMQ+NY24TFr8KWnaDe117yDaKSIPjWFkM8v+b3du2eC2y5qRVOMI4glZEY3vbZekrI4RrcK72ACmUyGtXMVkVCUPegZCAQYchzk/c+8l4nkBLt8UsKdWqNCri6T1FuRGwwonU6UsQjxbBGl1oJcnq7U00Pbf4zfJDZ8rgdOHEQh2mi3WSvbdNPCa/l0iaF9uykVZst5coeP3ous+IcGmDh+BP9gP462jobXN5is9GraeXjkYWQymRSTKYroTOba95qPMhgbZKtnKzKZjDevejNHQ0cJZAMYrRq0RhVqQxPjRw+RCAXRlaWkxUQoR/ua9WSHvISzYcpIGgA2ra3mHqGxEVxrNqHLxaRJ3VB8OpFT2u9sMxCeSM8+ky+DrclQt2xaixJjzopT76y7P50vYdAoySQK6MzqJbWnJn0T/oy/aptSo6BYkOowHctL+ggyGaHxUcKTE6y49EocHU0UsilKxULlPP9QPye3P4u3/0TNfcfH+yhbNKgV9Z9r7p/ebCGbiNfd59Q5CWVDVdsC2QBuvbvyO5ssNiy/TCZDq9SSLWXRmdRkEoUFn2XkYJj7v3EAtVbJGz65lY3XzbZPk13HWPshUnuk95MKhySFamdt/ZjVZhQyBWvsa7BoLAvec6aeUtEcRrtWeicWK5kG7+RU/owqI8lCsma7xaVn9RXNbP/9EL/4552QKWPQ17aZut9dPI9MLlS+k5k/h82DmM6TTSYY3LOTddfegEwmYzQxSrxJQdLvJxkOIpPJUMgVbHRvJBOPI8hkjDhShCfHyWdm28Zu324ubrq48tuld3HntXeyxbOl4bPF/D50Jif5bGnRciBCJp7HaNMu+X3Ob0/n8s/VbmLFJU08e08fgiCgVKnQGIxkEnFC4ylO7vBx43vWsv6aNjrXObns1l6e/OkJCtPvIpdOUSoUCI4MVl03nymi0Snr3jMRCmJyuOjcsBmTw8WRpx6v2u8f7Ecml3P8uaek9x/wYfE0nbd3dCp1JVco6Nq0heEDe0/puul4FIPVRvOyFfgG+uoec/TpP7N82+VoDfX79gt/S6+nF+JvKTivBoBKpeKiiy6qSuAtl6WE3ksvvbTheV/+8pf5l3/5Fx566CG2bNlyLh71BUMmXyJTKGHVqSj6/CjcbjxmLcMFJfZ3vpPxj/4tCV+cTKJA/q5Xw1eXw5NfAiAeyvLgUIA2m5ZQMkeikCBbyuLSStZ6i8UBCNiU1QlgTWYNifIE3ZZujnkTdNh0aFVyVtpWcjxyvCoJ62DgIJsybnonysTzcUbiI+zy7uJiz8U4tA7ajG3s9+/nePg4K2wrKKfTNA/GOdarxmkqkC9naTZU02eKZZFoIIcu7aWcXJoCazSd5+EjXm7f0gZJP6iMoNKhlClZbl2O0JRhaiAKgGXVJQyV9BwuqjDlu/jIm9/GTV038e5H3s2jI4+yzSOxlei0IhGTlBugcDgRImHkMgEUJgSk54rlYqj9McYNjRN6nx87hltTzeAjl8tQaSV9gge/9VVGD0thM/FghqmBGKGRR7nn85/i4e/8F3KViqbexomkWqOJVoWbh4YfoiyWySTiKFQq5KpaVpzd3t30Wnorybs6pQ6H1oEvLYUPuTpNiGUbkalJdA47zmwPnm4T8UAGW0sb2VAEEZFINtJQBTgwNkLHxotRlgskwmF8w4kKVR5MJ19OayCUSmXigUyNCvAMTHYttqK74Qr6jA5AOp5HtwQWIKimAo3lYgxEB6p0ANKx2aTIsSMHaV+7HrVOh6fLDYKMVHiWCSjm82JyunjuVz+puU9wcgyNoz5L0nwsxGYywwI0t915U148utlFkEw8j87Y2MugkWvIFDPozCoy8YWpQMNTKbo3OnjZm5ZLK+PzENJNUE5JQ0PUN4XZ5aYeu5EgCNg0tiXz/4OUBDwjXKg1mcgkE5TnkAucDhpRgQoygav+agVv/tw2bv7QOigXMRgsS35Og1Vdo03idrQilEQOPvYQTctWVnQfBmIDtDu6aFq2guEDe6vOSUUlcSSFSYfWZq0wq+RKOQ74D9S8vytbr0Qpr67rI089ztFnngAk2kW91UUuvXiyt8QKVU1h+WLHJa/pJjCaoH+PFEaiM1tIR6M8/csTbHh5GxbXbF+y5spmbM16nrmnD4BcSup3Jk4cqxyTjucpFssNWcQSwQBGuwNBENh886s5+nQ1oYh34CQbrr+Z4QP7yCTixPw+LC9yBqC56Nq4hZF53+RCEMtl0tEoeosVd3cviXCwhh2tVCxw7JknWHt1/dDrC3hp4LyzAH384x/nrrvu4kc/+hHHjh3jAx/4AKlUine84x0AvO1tb+OTn/xk5fh///d/5zOf+Qw//OEP6ezsxOv14vV6SS5xIvliQySdRxDArFVS9PlQuF00TbP0OD/yYRQuF8GH/wxArPVWeM234PBvKeVLpGI5fn/Sx+dfs5ZUvsRE3IdWoa0weHhUdkRBibFUXc0es4aCzEuboZMT3jgrPZJXpMfSQzKfxJf2USyU2P5AH8OhIZq/8ksiX/s66xzr2Ovfy84pibUCYLN7M3t9ezkePs4q2yrSu3ZRsps5rA5iNMXRyiySSNEcJKM5SoUy+mKUcmrhuP8Z/H7/JOtazPS6DJD0gWE29OWy5ss4ptrLVL80wbK295LLqelOWNAbHbQus/GJLZ/g8pbLORY+xtYm6dmNKpGY3kIgHUDhdFAMhXDolRQxUCpKyeLHw8dxR+GEujGV2kBkiFX2nprtWoOSeChOLpUi5pMmpCd2eGlbbSMemOTqt72bd3/zB7zt37+B0d6YQUVjNGEoasiX8uzz72PX4F9IyHP84NAPao6dYRSZC7fOXVHHdXUYSUS1yOQK1G4nuryJ7o0u4sEMequNTCyKRW0hkAkQyUaq9BtAkoiPTk3SunIlKbmOp36xC5Vajq1pdiLpaDUSHJMmZN7+GIJMqGJTmYtVHb30KlY1LPuMDkAmkUe7iArwDGaoQMtimU889Qk++9xnUarkFHMlCrkS+WypMiHKJOLozFIZHW0mZHJDFRNQ1O/jZX/9DnxDAzWCbOlgCFsd4a96kJIZo3X3ObQO8uU8icLsJHauBoD0nAvToOqUOskDYFSRXsQASMfzFQ9VPSSEKOWsNPGN+rxY3FLC48Befw217VWtV3FD5w0L3q/q2uHsrAFgNIEokj3DvtuoMtYVA5sL7fTnadQvzWCTEoBrv9lmezuiILL3wftZe831le37/ftZaVtJ5/rNNQZAOiaJI7m0LrTtbiZPSvltR0NHMagMizL+lEslnv3Fj3j4O//Fye3PEvV5MTpc5DOLqz6nonm0RiXyRfQzXkzQ6JVccfsynr23j1ymiM5sZmDfMMlIjotu6qw6VhAErnnLKgb2BQiMJsgmEyjVGiaOz7KmDez109xrQaOvb0AnQgFMDmk86Vi/Cf/QYOWbFEUR70Afyy+9AndPLyeef5a433deRMBOFy0rVhEcGyWXbszmMxfZVJJyqYjOYkGl1WFvacM70Fd1zFT/SQSZjNZVa1+IR76Ac4Tz3iu88Y1v5Ctf+Qqf/exn2bhxI/v37+ehhx6qxESOjo4yNTUr7POd73yHfD7PbbfdRlNTU+XvK1/5yvkqwhkhks5j0ihRyGUU/H6UHg9NZg3BZI4CMlq++hVSKWkwjrtvgnVvgFyM6KFdlGVwzaYmtnbaEAQYiEzi1M7G1JtEE2WZnFK6eoC16ZTI1H5M8laOexOs8EgiPBqFhi5zF7u8u5jqj7Hn/jHedOBWxCk/2UOH2WLfyJ8G/8RUaoqL3FLi72bXZvb691Y8AMlnn0PYtomhxDBqTQQNtTHqkakUJqcWhV5LKbk0A+Ce3WO8Ycs0nWgqAIbZpKQ3rXwTz5QeJjCWIJ8t0i9OICsJ5FMlujZ2SVoBgsA/XfJP/PDGH9Jl6gJAJ2TJ6x2MJkZR2O2ImQxtGoFiSUcxLxkT0R//BEXBxl6DxHc+H4FEjgxTXNS8vGaf1qgkOiWtYkX9XkRR5MR2LysvaZqeWDUW+qm+jolsMsF1HdfxqWc+xfd2fguFTssDQw/UHDvDKT4Xbr27QtfqbDcSGs9ga2lF1FnJ6GM42iQFaYPVRjISqQhTRbIRTHIDz/3qJxX+8tDEGCqtFoPOgkqw4B0Y5fV/v7lqpdTRaiA8leLYX6b447cPsu013TTiebc7TZQTjQV60vkSOqWcTLJQoeFbDB6dB2/Ky0+P/pR9/n34M/6KByAVyyGTC5XJQCaRQGuUvn97ix5R1BPxSTSPYrlM3O/F1dXD1ltu5dlf/rhqlV6MpGlt7V3SM0kegGj9fQodGrmmSgzMl/ZVGQDpRQwAjVxDppBBZ1ItKgYmGQD1ryWKInEhQikjlTPqm8LsbiLmz/DQ9w5z9/99jkd/eISIV2q3n730sxW9h8VQyJXIpYsVA0Cp1qBQq8nME9b6y70/b0jJWA+N1IDnQqWWvAx6lmYASBSgtUaSx9BETlmmVCiw/JLLAcgUMzww+ACv6n4VnRs2M3roAOXSrFcjHYuiN1skrYtmE1N9kgEwEh+h29y9aA7U8MG9IAjc8rFP8uC3/5Pxo4ewuJqqPNkM/R0AAG6ISURBVACD+wP4hmvfwUuFAnQ+lm11Y28x8MO/ewbvQJ4jzwxw2a29KNW1fYXBqqZrvYP+PX4yySQd6zcxefJYpa327fKxbEv9eH2xXCYRClVyqQxWG9bmFsaOHQIgEQqSicdxd/aw6oqr2fvA7ygWC5gc5zf+/1RgsNkx2O0NOf0njh9l+29+WfmdikZQqjWopilzPb3La86dPHGM5uWrEJYYanIBL068KGrvQx/6ECMjI+RyOXbs2MG2bbOCMk8++SR333135ffw8DCiKNb8/fM///O5f/CzgEiqgE0vDcZFnw+Fy43doEYhE/DFsyjsdkpON/JSluhUAhQqWHULgT3P46PMh1++DLlMwKpTMRr1VvGpx2M5SnIZkWA1t7k/40MQSsiKDo5PJVjVNKvC+fY1b+dre77G8EkfMlcGc3oz+Xd/FplWy9aYnZ3enayxr6l4GTa7N3M4eJiR+AgrrStJPv0UjqtejjflpSifRCjVclVHvGmsHj0yvX5JHoDDEzGGgileuX46lCjpA/1sOV06Fy9beSklfRbvYIxfD/0WwaBBFEusvmI2tEYmyNjq2VoZcDXFOCWtk7HEGDKTCZRKtMJDFEt68qkImR//GOt9zzPstGBTN3MoeKjus6m0AVY7aw0AjUFFbJoNIebzEhxLkknkaVttIhEMYFkkz2UGWqORbCLBG1e8kfXO9Xxs9Yfo9PQylhhjMDrLxR/MBBmOD7PFXR0W59F78KUlA8DVYSLqS/Oyt7yXsqmLgi2ByaElEcqiM1spZDO45BItZTgXRhHJs/23v2LsqKT0GBwdxtHeweN3HSWnMONZp8DsrA7vMTu1yOQynvt1H69471o2XV8dHjUXBpuaXKpIPls/nCGZK6IsASIVwbvF0GRoYiQ+wp377+Szl36WYCaIQi2jkCuSjuXQmVWVbyCbiKMxSN+/1qBCqTbhH5EWHJKRMOVSGZPDyaabbiHq8zJycB/xYIaffvYplFmR5d0bl/RMCymaCoKAXWuvEgPzprwVDQCYDgFawADSKmZyAFSkY4sZALmG18qX86TkCQoZyeCL+aawuJvIJAvoLWre8Omt5LMldtw/tOA96iETK6JQyVDrZ7kntEYTmUS1YR2aGKtZcVwIJrWJeG5hA6BUzIGgRJ2rVhwOT6YoFmpDkBLhHMY6HgCP3kNWWabrkm0o1dL+R0cexa13s8G5AXd3L4JcjndgdsKUikkhQE6dk5RTwVT/CcRymdH4KO2mxm1jBkeeeIw1V72c3q2X8PJ3foB0LIq1uZncHL2H/Y+Ncvz5WgXspaqsv9ggCAKv/OB6/uqft7Hs4i5WXWZh2ZbGyru9m13THqoEHes2ks+kiUxNkghn8Q3F6d5Uf8KeikUpl4oY5nhg29duYPSQ5O3zDfRhb2tHqdGw4tIrifq8GKw2FHXCL1/MaF62ksm+Y3X3ndz+LEfmhD2lY1L4z9xzJ44fqTpn4sRRWlY09txewEsDLwoD4H8zwuk8Vp2Scj5PKRxG4XYhlwm4jGq8cYmmNFPWYs2MEDw4PeiueT2RwTGSKpF2mzT5sulVTCR9OLWzE+NQOE5BISccrI6PHYwNohKdeGNF+v1JVnhmmRFe3fNq1jrWsmP/QRSx7XRF/sSOowbKG6+gfThdmUTPoN3YjkllwqqxYjgxQSkcwX3tTZhUJsay+8hnLbVl9qawNemQGQyUU4u7/3+7d4JXrmvCoJ6eOCT9iBoHhcnJyjFvXf1WhrVHOXp4mGcGn0OFtLru7Gi8yq7KRBCVNkbjowiCQMGiJ5t+iGJeTTYZIXvf7/jtDR4QoV3u4UDgQM01to+MUJbHqgSEZiCFAAWQyeVEfV6i/jTWJj2pSAiZXIbBtjQhH2mSFGelbSX/cdV/oM7L0JusXN58OY+OPFo57qmxp1hhXVEj2DQ3BEhnUmGwqVGqW8lFdMiceQw2NSJQyCuQK5U4yxaG48MUy0Vk0wq0h5+U7hMcG8Ha1I5/JM6owUwiWKueKcgErn3LSm7/5FY61ixcRo1eiUI1ndA+D4VSmXyxjCxXQqVVoFA29hTMhUfnIVfK8bbVb+P6jusplovkZVkKuTKpWL5KdC6TiKOdwwamM9uITEhlivm8aKxmnvM+j0qjZfXLruXYs08ydCBIZHKKglxkWdPSVr8b5QCEJyeI+rwVr8sM5oYAiaJIJlFY0ADSKKZzAEyqBQXoYGEPQKqQIqdIUSqIFPMlyVPl8ZBNSUJktiY93RsdZFOLh5/U3DeWrxEu1BqkPIC5yCbixIOB+ac3RKMcgLnIpdOUZXLkqdlJfTqe5xef38EPPv4Mf7zzAGNHZ+Ock5Fs3bA1rULLcG8B91WzRvZvTv6GW5fdKnkaZTJcHZ0Ex0bnlFsKAXLr3ISMWUqFIqHxUcYSY7QZ2xZ87nQ8xsCeHayZjrVee/V1vOM//xtPTw/5aQ+AKIqEJlIEx2r70peqBwBArpBhcemwehyUCwsvFLWvsZGK50mGY+itVtzdy5g8cZT+3X5aVlobfu+JYAC9xVrFGNS+VhJFBCn+39OzDJCM+M71m170CsD10LxiFVMn61OrT/YdJ+bzUSxIbToVjaCbYwB0btjM5Mlj5NJSHYiiyOTJ4zSvWFrfdwEvXlwwAM4zoum8lADsD4BcjsIuTZhm1HqLhRLZgoYmT4HoyPQEoesqInk3TcZIZTC161X4Uv4qD0A4GqeoUJAKV08IBqIDGOUt/GUghEwGTZkI/q9/nclPf5qx972Pj/y/MLpxHSt27sTxnkvp3uRkwH455YNHuaHjBq5tv7ZyLUEQ2OzezCrbKmL33YfplTcj12rpMncxkR4gmaylXYtMpaY9ALqleQAmY1zSPWcimQoQP55m/CMfrWxaaVuJsqXA7j3HeH3/R9Ea3VLinbLxpEmV9CPKzIwmpMHar81jTyoQCnpEUaT4htcjCxRRG404y2YOBg7WXGOP9yBWZXOVcuoMtEYl6WgYd3cvMb+XRCiDwaqRlFVdnrqJlfWgNZokdouiNOBnkwm0RhPXd15fMQBypRz/ffC/eevqt9ac79a5Kx4AAHeHCf9IgnJAhdYjJSwbbWoSwSx6ixVrSUdfpA+FTEExlsLibqJv+3Pk0imCo8OotC5Mdg0Zo42E31v3mZdtdWN21lddnQtBEDDaNCQitZoc6fz0ymy2vOTVfwCLxsKd197J+za8D61Ci1FlJEVCCgGaNyHKJBNoDbPfqMlpJx6U2lnU7yVnlHH3kbsBWHnplfTv2s7wIS9iOUpJo0WrXLyMUF/RVBRFHvzWV9l1/68ricAAxXKRQCZQMQBy6SLlsrhgCJBWoSVbzKI1qaYTPxuriC9mABSVUn+RTRWITYeqZZMFNAapDtQ6Jbn06RgAxZqwGs20d2suMskE8UCtYdkISwkBymfSlGQyxMSs9yEylcJgU3PbJ7dg9eh44mezBAiJ8KxS93wU1rvYkZW8gYPRQQ4HD3NLzy2V/RZPM1Hv7OJEKhpBb7Hi1Dnx54L0br2E/Y8+yFhijHbjwh6A488+iad3BVbPLJGCrbkFlVZBsVCmVCiTiubIZ4oEJ5KI5ep6T8VeugbADBYKn5uBQiWnc52dVDSGxmCkZcUqJk4co2934/AfgPh0AvBctK5eR3hinFQ0gnegr2IAAFz82ttZd+3Sc15eLGhetpKpvhOVUM4ZFPI5/EMDAESnJoDp79VsqRxjcrqwNrUwcmg/AOHJcYrZLO7u2ry3C3hp4YIBcJ4RTuWx6lUU/T4UTidCOQ/FPE1mLd5YhlQ0j4wi7Vf0kMgpKYbDIFfgLfWyQT07IbUbVISywSoPQDyeoKxWU4pVV/NQbAiXpp39RwKscBuJ3/Mrkk8+hdLtwXjttahufCMoNNx9Y4hV196Kp9tMXm0lvW8fX37Zl1nvrKZdffPKN/PmzluJP/AAlte/HoAusxRnn06bSeWqwztmQoDkesOSWIAGA0l6XIbZDUkfWX+Wgq968vnybZdhjTXj1DnZ8PJ1dTny50IZmaBU0jEWH+NY6Bg+TZ7N4mUoUKIulOgzgz2mYsPLX4GxoOZQ4BBlsboDHYidZJmlPoOPRq8iHQ/TsnINpWKR8KQfo01N1DeFxbO0+H+QkoBBmvjD9Kq10chVrVcxGBtkJD7Cr47/CqPKyCu7X1lz/twQIABnh5GxY2HkSQ2mZmlyYHJoiU8bAMa8mpORk1jVVpKhIO3rNuDo6OT4c08THB2mULTi6TEjGu1kQmcu+GKwaUiG6xkA0ndTSheXHP8/g6varqowC7m0LhLl2HQIUB79nGtlEwk0xtmwEHuLm3RcSviO+aYoGOWMxEcAcPcsQ2M0MXbkAIIliEK5NA8OSJOYzLxJzOTJ43j7TxL1TlV5AIKZIKIoVoz5TCKPQimrG/88g7kegHJJbMgQU8iXKMxJgp6PdCGNVqVBpZET8QYp5LKYXG7JAJjOm9DolafpASjUJNZqpyke5yKbTJCMhCkVl3YPo8q4qAcglYpTlIsU47Peh6g/jdWtw95sYNtruskkCwTHk4iiSHJOsvJ8fPbSz3LPiXv4xt5v8Ju+33Bdx3VVXjerp5nI1KwBUMkB0LoIpANse+3tHH7iUfy+sUoIUGh8lAOPPsjx555ieP8e4gE/oihy+IlHq5KNZ6DWSYZMLlMkNJHC5NAglkRigWpBtZeyB2AGOrOZ1CIGAEhhQPlMCrXeQMvK1YwdPUJoMkn3xsbjQCIUwOio3q81GHF1dTN6aD++wX48PbPhna2r1rLmqpefdlnOF5ydXRTzecLTk/wZ+Ab70UyXNzQxDkx7rCzVuTJdm7YwtG83IMX/u3uWIVcsfVHmAl6cuGAAnGdEUnlselWFAYgHPgHP/mfFA5AKpdDJIzg3rSSnshD5wwOUS2XSeQubCo9ASRro7Xo1sXyoygOQTCSR6/TIMxrKpemJazbGYHSAblkvr/MJrLLpyRw6jPVNb8L5kQ9jfdObSHX9//bOO0yysszb96mcc3VV5zg5MwmGLCAgQVAwLAoq6rofKGF1RVdljax+6y5mRJdVP0V0VYIKKAxIkjAwM8wMMKm7Z6anU3V15ZzO98fpqu6arg4zhGbo976uuaBPnTr1Vr0V3ud9fs/vWYe/08V3Pv8oJq0Jg0VLFj3FaJR8X9+k57DOv45VL6fQ1PsxrFgBjAcAmpKHwej44i6dyJFJ5HH4TbOqAYim8gQTOTq8E3bYEyPkhuMUR0PIE4rtzlp1Cvaz0rz3+k0sO/1M3vbhf5z22trAIeSSiuFQkN/s+Q12fwttchMlchi1Wg5u3UqqyYCnpQ1VMk++lKc3Oq59Ho5lyKgOsrFxVc3rG61asskwDl89VreH8OAgVreByPDQUblIaLRatAZjZaGUjscxWqxYdVY2NWzi7n13c/vO27n+hOtRSZM/0j6zj5HUCMUxu8W6VhuHd4fJGhO4x3pF2LxGoiNpzA4XpqyakfQIToOTeEgpkFt+xtlsvf9eEuEQibCZ+g47KpuHYiqu9CV4FVhdBuKjkwOAZLaIUasmm8zP2gK0Fh6Th6gcIZ8rkYxmMVVlAGJVGYC6tgZy6ahiVTs8RMosE0gFSOWVvhD1XWuhtJeMth8dsy8ENNnsZJKJqkXt1j/fg79zAeGhAdxGdyUAGEwqAUE5gCk7AE1XLGrSmCCaQatXo9GppqwDSMdySCoJg6n2j3cin8CitaA3awn192NxudHq9IoEqJwBMGtmZUF5JKlIHuukDICtEtiWycTjIMvEg0Fmw0wZAFmW2fvcU6QNEtnoeAAfHk7h8CnfKxqtmtZlLnq3j5BNFchni1MGAEvdS/nZ+T/j3u57+eUrv+TdC95ddbujvpHI8LgeX5EAOakzKU0UPS1tNK1cSes+Nc3WZmIjAX7zbzfxypN/Y+sD9/HIz27np5/6KD/4yPuIBIYrxcYT0WjVqDWKv/3oQAJvsxVXg5mRvurX8i0RANgck7JntWha4kAuZUknVNR3LSY6PEDjAgP6Kd7rULYAnRwgNC9byYsPP0ghn8PT0vZqhv+mQK3R4uvsYmBvdR3A4N7dNCxcjKuxmdCA8tuuZKwcVee1r15H7/YXkGVZ6P/fQogAYI4Jp/I4TFryQ8No63wwuAMCL1NvNzAUzZAYDmJRjWJqaEKthqEHHicWzFCSwakZgIBSnOMy60gWQlUZgHQyidnmAlkmFlJ2huTfXEl3aDetUisSEp0aLZmXXsK4YtzOa7gnir/djlVXLo7UkkkVMS5dSmprbT/hyB/uxnHpuyqLlDZbGxqVhnqLn6EJAUB4KIXZrkNv1KCyWCjOkAHoDibwWvXYDBO+xBPDZA8HoVSiGB6351Sr1Hzg8gswm42YbHYaFk7W5ZeRSyUIDqHTS6hSOu7rvo/OjrUY0yo0+TiS00xpJIZlVSdmu5NUNMIyz7IqGdDOw1F0pkFW1S2r+RgGi5Z8JoLV7cFR5ycWHMbiNCgZgFk6AJUxTpBKZBIxxUIROKf1HO7YdQcLnQs5pfGUmvetM9ZRkkuVBaa3RZnXiHWo0i/A7jESC6axuFxoxwpAnQanskPm9rBo02nERgJY3R6CfXn8nXaMViuSzkhkuLYMaLZYXfopJEAFzHo1qdjsLUBrUWesI1IcHXMBymEe2/3O57IUstmKCxCAv6sBuZggGkwpsi2jstDtiys/jhrdIvLp/WTjw6jynkpvgZko1xmUHW+igWG6X3iWM678GPHRIC61g2BGmZ8/df+JjfXjRgip2PT6fwBNQeK0B3VjTaKmdgJKjfUTONLfvkwyn8SsNWMwawkPjr9PlRoAZdfZYNaSzxQpFks1rzEV6Wh+kq7eaLWSniABKuTz5LMZdEYj0VnKgGbKAOx85C/079pFd5e+Sg4ZGU7h8I1LuDpWe+nZHiQRzqIzatAZNbUup5xr7+AX5/+Cq5dfPcl1y+mvJzI0WJFbJCMRTA6lCDiUCZEv5fGftZHFh6wUI0nu+Y+vsfDEk3nfl7/JP3zt23zk1h/zqZ//jsu/+HXee/MtFTeWI9GZNGTTBUL9SVwNZrzNFoKHq79Pj9ci4ImY7HbS0ci0sjaAYl75jduxeYT7vrsHldaFv2P6zYlYcNwCdCKty1fRv/sl6lo7UGumfh8cTzQsnFwHMLB3N/ULFuNqaCI0lgEoS9Ym0rh4Cbl0mpGDvYoDkND/vyUQAcAcE07lcJnGMgB1dRDcB6Pd4xmAwCiFQi93f/sWZZd2MEHfln2MqmTwL4chRYvqNmvJlCJVGYBcKoXL4SOpj9J7WPlwj0Z6iBUzNMjKed5QDDmbRb9gXOc41BurauxktOpIJ3IYVq8hvXXbpOeQO3yY1Nat2C8e18Gu9a3lk2s+Sb3NxEB0PC0dHkziHPOMVzIA039BdwcSdHgm7P6XipRio+SHRkCjoTAy+2LBiRSjUSgWMTsNNNLGEtcSfC2LKY1GsaQiDHmhqIaF6zZhdjpJhsOs8KyoKgR+ru8wJXWoZgEwKK4yhVwMq9uD3VdPOjaiZACGjiUAsI1nAGKxiizojOYzcBqc3HDCDVPuEGvVWtxGd0UGZDBrsXuNBEyHKgGAbSwAMDtcSGPyDpfeRWJ0FKvbg8FsYcHGTdjqmkACV4MFi0ELNnfVbuexMF0GwKTTzOiAMxNek5fRQpBCbqwGYKwIuBxQlV2AAGweD1BkcH+AaGAYKerllJ530xtV3McCh/WY7C6Mozl0Zicjh6bXnpdRa7QYzBYG9ik6820P/pHOdSfSsHAxGq0Oa1rDaHqUYDrIvd338qFlH6rcdzY9EPLBKCpZIjLYrxQCT9ELIBXLYbJPvSBM5VOYtCb0Jg3RwHimKpPIY7QoY6jIT5JHlwVIRfOTnHWMFiuZxPhrWM4GeFs7iAVnJy+z6ZUi4CMXiMVSkVsf+CqP/Ox2ll51GTlXkcSEQDMylMIxoUFd6woP4aEk/XvDU+r/J9JoaeRTJ3xq0ufOXuenkM+RCIfI57Lk0inMdgceo6I1H02PEnEWSfm1/PJz16M3mjjzQx+vuoZGp8PX0YWvY2qbWb1RQy6lZADcjRY8zdaqQuBcpkA+U6wqej8eMdmdFAsFRvsO8vTvfs3ffvGTmudlEglUai2RkTzLTm1g+RkbCfe/VPPcMvHRYM0eLI2Ll6FSq/FN0P8f79QvXFzpQQFKZmxwn5IBcDc2M9qvbHKkIuFKb5Qyao2W1hWreemxzYSHBmgQGYC3BCIAmGOqagDsOiikIdRDvU3PUDRDqL+fwche+nbtQKsPUFi2nr6/v0xcB9qGlUrGADAbi5SkXFUGIJ9N47TbyZtSHBoYglKR3swoDZIefUqiiIw0FEO/ZDHSWLFsNl0gNJjE1zEuizBYtJQKMpqVa0hvmxwAxO5/AMvJJ6Pxjj+2XW/nI8s/Qr3DMCkD4PSPBQAW84w1AN0jyWr9f2qUbFSFymZD19pKYZYygSMpjIygMpuxuows0C3lymVXovF4yASi5MixzTbI3tYEy/wrsThdFHJZVliXVAUAzw/swK7xT3LdKaPW5EHOYXF6sLrryGdCWBw6ooGho6oBgLEAYGyhlB4rAgbldd58+WZWeFdMe/+JTkAAGy9pZ5fzKVx6pdOvvSwBcjopxpWAzal3EA8FsbiUH8jTrvgwbaveib/dhkolYTFoKFpcRIZeXQCg1ABMdgFKjTUBm8kDfybqTHWM5IdBhthourIATsdj6M1mVOpxbb3OYESlMdC/u4dUNELTgVPpDK+hd3OcaCBNMpqj4yRld76uo5nh3um15xNZcfbF/OVHt/LLm65n5yN/Ye0F70RSqXD469HHlQzNna/cyXr/eha5xutKUvGZuyBnhpUC4vDwIMZpmoGlYtO/lsl8ErPGjN6kJT46XDMDoNGq0WhVR1UIXCqWSMfyNYqAbVUZgEw8hs5oxFnfQGxklgGAzkZRLpI8winm7/1/J/K/T/FiR4TH1TtR2ZQ+BLl0gWKhRGw0UxUA6I0amhY52fno4SnlP7NBo9Nh83gJDw6QikSQJBUGqxWNSlMJxPvifcib2nH46rnoxs8dk55ab9KQTuYID6aUAKDJUmnAB4r8R62ptl09HtEZjWi0On7x2U8x1L2XFx96kMCBnknnZRJxjDYrH/zqSaw4o4kVZ5zNnqefIJ+ZvLlQplYNAIDWYKBt1Qm0LF9Z417HJw0LFjPa30dmzHkvNhIgHY/h61yAq7GZ8EA/cqlEMhqZJAECpQ7gxYfux9XQhNFinXS74PhDBABzTCSl9AHIDwfQ6vPgbIN8igZNjJFYir07/orP5eGEd1xMfOQZsrZGIqE8aocOqX4VDCkBgEobg5IOi1ZZLMuyjJxN43LaUNtKjATCkAjQo5Fol9XkIznquhzERgsYl48vHod7o9jchqpdI71Jg0olIXUtJbt/P8UjGvdk9+zBuHp1zedX7mpcJjyUxOlXfnRnUwPQM3JEBiARIJuyou/qQuP1Uhg5tgCgODqK2uPG7NRzft1FnNt2LhqPl5zOxqjBxEBjiReXJWmxtaAzmtBodSzUtdEX72NveC+yLNMT28sCZ+0CYIB8NgpoQaVHZ3IBMfLZGMVCAZt3ak/rWhgsVtKxGHKpRGZC8yoAjWrmH/gjnYDcy3REDcHxDIDXSDZVQGewkYnGMGqMOEpmivk81jFnKovLTTxsqmSHLHotOaOL6KuWABlIRLLjdSpjJHNFzHrNmGzlVWQAjF4CeWWMpYKM2aFcK3OEA1AZg8VB/56XkVR6Xmp6jtDZ2ym8aOOxX++hcYED1Uo/KbNM6+LWms2XjqRUknnujz3sfMLPxZ/+HqvOOZ9V57yDhoXKLprDV48UyRDKhLh7131cqv4gPdvGM1uKBej0zz851rxsdLgfk10/dQAQzWK0acnnJgdcMFECpCEZGcFRzgAk8+gndFLVm7VkjiIDkIrmkGUwH7GzrmQAJgQAiQQGiw2bp27WAYBZa0ZCmiQD+uOu32NNavjAlZ/j4UMPYzLr0erVxEMZYsE0arU0KSPRvtqrNMV7FQEAjDkBDQ+M6f/tFccvr9HLSGqEvlgfDQsW8Q9f/zYmW+0NhJnQGzUEDsZBUj6/7iYLqXiOZFSZW0X/P33tyPGAJElcetO/8bEf3MGln72ZJaeewbYH/zTpvEwyjsE8vlnk61yA3VvH3mefqnndQi5HKhqZsqnXpZ+9mQUbNr02T+JNgNnhxO6tY3DfHkCx//S2dqDV6XH46ykVC0QDw6RjsUkSIID2NWsp5vNC//8WQgQAc0woqfQBKAwPo9FEoX4V2JvxZvtYHX2RXC7FqmWLWX3ehUSGdhMplkjn9Nh8JqhfCUO7oFRCVkWRi9bKl30klUdTzOFx2TC7dIRHksRD+9iv09KRyxEJpFi1qZ54zoB26bj+f6gnhq+9+gdJkiRFz661om1qIv1itR1m7sABdG1tNZ+f325kcEwCVCiW2L0nRHRsHaEyzyYDcIQDUDJALmVRAgCP55glQIVgEI3Hi8WhJxFRfjA1dUoAEHTXsci2jg5rBypJhSRJmJ1O1KkC7+x8J3fsuoOhWIas6iAb6qfeIUrHQ0hqK5lEHrXWhVyKEA0MYXV7prUnrYXRpkiAsqkUslyqZABmi9/sr3QDBghnwhg1RgwaZaGjN2rGdgrNJCMhPEYP1pwOg8VaaXgEMNQTxd+pvD+sBg0pg+NVS4DMTj3IMskjCldTWSUDkI7nX1UNgNfkZTg7hEolTeoCPNEBqIzF6SLUvw+N3smzTfeztKuTPWsfoX9PmJZlbvZJ/cSvWoav3cHwgemLExPhLPfduo39LwSwe41kkrDy7PM47YoPV85x+OvJj8Z4x0uf4N1//xzDj0g8/LOXKwGRUgQ8/fslPjBE0lAgMjyIyaolFau9wE/F88QDW/jV526o2MpOJFlIKhIgs5ZMfGQ8AzDBBhTAYNaQPQonoPBwCpNDi1pd/ZNjsFa7AKUTisOVzTv7AEAlqbDqrFWFwNFslK3dT6Mzmzir8xx+f9Hv+dcT/xWr20A8lCE8lMJeZ5pUC9G+ygMSk4qVj5ayE1ByrAdAGZ/JRyAV4FD80IwWoDOhM2kY3B/FVW9GpZLQGTTYvUZGx+oA+vdGKkXOxzsty1diHctErjnvInY/+bdJhcFK8Dj+eZYkiWVnnF3pYXIk8VAQlVpzzAHY8ciik05l8x0/IjI0ONbNV5GvqjUa7L56Du9+CVkuTZIAAVhdHnwdC2he9tbJisx3RAAwh2TyRdL5Ig6jlkIggKYUAO9icHeQH9zNxvAWjNYzsdfZsLo8NC9bTzC0i5zaTmOLFTyLoJCBcC9ZIhTzVtJj3uk9wSQm8jjsNpoa64gFMmx67BrusllZGE8RG83QuMCGupghUz9uczbUHanS/5cxWrWkE3kMixeR3Tve5VKWZXK9veja22s+xwb7uATose2D6AsyO1JKQKC2WKbNAOSLJQ6OpujyTrQADZCNatF3dSoZgGOVAAVG0Hg8WJwGkmO6YG1jI+r1p1L02Flleycf6PxA5XyTw0kiEuZDyz/EQwce4tHu3ejNg6yqWz7VQ5AIBdHobGQSecCGXEwT6O0+av0/KA2TMok46XgUlVqDdorCwKnwmX0MpcZ36sOZME599Ze83WOkkDeSTSY5tW4T/qIL64RmZclolthophIgWvQa4jr7qy4CVqtVmB164kdYgSZzRcxaNel4DpPt2C3nvEYvo+lRNHp1VRfgdDxWM5XtrK+D0gCeTj9IMiu8K9hpfJp3fWYty05tZGdwJyu9K6lrtZEIZys7rhORZZmXnxzg1195FqvbwGU3rcPbbCUZmXyu099A8EA/dckWuq6TueLLJyKppEpBZ3oWEqjwQD9DvjyRwJBSBDxNBiAytItQ/2FefOj+ybfnU5i1ZjSaIoVcEru/HlmWx2oAJmQATFoyRyEBGuyO4m42TTpuGMsAlPX76Xgcg0UJAGZbBAxMCgAe6H2Ahbo2bC5F3uEz+1jkWoTFqVjOHlkAXMZs19OyxIWrwTLptqPB4a8nMjRAaqwLcBmvyUsgFVB6AMyiC/B06I0agofiuBvGF/meJisjfXHioQzbHz7E+gvbXtVjvBnxtrRRv3AxOx/5a9XxIwMAgKWnnsnAnt01ZYrx4AhWjwdJNX+WQae870q61p3Ir7/0GXq2bqkyynA3NnH45Z3ozeYpN6je+2+3sHjTaW/UcAWvM/Pnnf8mJJzKIUlgzSaRczm0+QPgXQSuTva8sBXJ00RBbsVcp+i0Tzj/nWQSL1GkwMJ2G2h0ULcEhnaSKoahYOPZ+//IjocfpDsQRy/n0RlNnLV+E42ZDp5s/QgPy42cEtIovuLBPiypQaKysqDLJPP0743Qssw1aawGi5ZMIoeuq4vs/v2V44WREUqpFLrW2j9mfruBgYiy4H/yycMEtbDlsOLcozKbKU7TCbgvlEKlkmhwTPihTgTIhkroOjtfVQYgPzyE1u/H7NCTCCuLMkmSyJT0ym5zrp71nnF3D4vDRSoSptnazDlt53DXvh9TVAdZ7J7aaSg+OorW4CCdyJNJqVFrjRzcsa0iqzgaykXA6TH5z9Gm9f2mIzIA2XBF/lPG5jWSSalRqdX804KP4ilYqvSxQz1R3A1m9GPuKBa9hojaQnx0hFJpdm44U1FemE0klS1gUasoFadvgjUTXpOXolxErZeqpG2ZeKxmJsVe56VUzGDw27Dr7bTZ2ghlQpiaJDQ6FTtGdrDSuxK9UYPTZyJwhAwoEc5w763b2fLnXs75yFLOumopOoMGs0NfM1hw+OsJDwywaG0D5y4+C5VKor7TzuB+ZYdzusZdAMVCnsjwILlWK4mREXztdgb2RYgF05POTYTjRAb3ccZVH+Pp/71zUhfesgSoWAijUhswWqzkM0VKJbmSOQGlkPxoioCHuqN4WiYvuI0WG6VikVxaGWsmoQQAdq+PRGiUUnF276sjrUDv2X8P6y0rMTurv8vKGQAlAJgckABc9KnVtK+cXBh6NDjrxzIARzRVqjPV0RPtIZQJzdgFeCb0Jg2lklwVrHjGnICe/sN+OtfU4W9/a+5urzn/Irb/9c9V7w/lvVMduJnsDjpOWM9Ljz086RpTFQC/lZFUKk7/4NWc8I53Eg+OVBXzuhqbOfTSDsw1dv/LaPWGeRUwvdURMzmHhJI5bAYtsf4eimYDqsi+sQxAFy+/Mkjb2lOQ0WD2KxrF9tVLUWm8qFLP0zXWrVORAe0gmB5Bh4N9T2xm8x23cfB3t6EpZtGZTNjrjGj1GtIDWXy+1cTkduwuNZldu3AYs4weVnbhe7aP4Gmy4Kib/MNotOhIx/PojwgAcr0H0DTUozLU1sw22I3EMgXCyRyjvXFaljh5/kCYYklGZbFM6wLUPZKkw2NG/chX4KnvAlAK9ZOPZNF3LUDj9VAIHqMEaGgYjc+HxTkuAQJIxbJYHXoC8eqFmtnpJBEOAXD18qvpzTyFWe3BZZgcLJWJj45gMDtIx3MkQhmMNg99L+/CMaGr52wpS4AyEwqAj4aaGYAjAwCPkVgwi8nuIBkOER8dwTIhAzDUHcXf6aj8bTFoCGNALpVIRSJHPaaJWF21MwAWWYVGp0JnOPZCRr1aj11vR9KUqgKAdCJecVOaSOU524049A7sejtOvZNDsUP0xftI5pMV5ydfm42e7SMUxjJvA/si/PYbW7A69bz/SxtpWzG+wDDb9SQjk3fm7XV+sqkwS9c1VAK7+i47A/sjyjhnqAEIDw6g1moxdzRSTGexuiQWrPPx5P/um3RuNLAPs8PDCedfhL9rIc/87tdVt5cDgHwmhFqnvD8yyTySSqqyxdSbNbNuBlYslhjujeFumfy9ojeZkCRVxQmoHACU5yA+OsteAGNOQAD7wvvYH9lPu6oBi7O6WZvyPssSGVaagL1eOPwNRIeHxixAxz9ndaY6tgW2YdPZpjQPmC3l+XA3jmcAvM1WDu0apXfnKCde8tbt1Nq5dgMqlZr9zz9TOZZJxidlAACWn3k2Lz32yCTJWywYwDZDs8i3IpIksfGSy/nE7f+vqv7B1dBEPDhSU/8veGsiAoA5JJxUCoC3PnMPB60Z/qgD3F2EZBeBSAFLlxe9FKdPVj6QKrUKnbUdOT+ANTymj/UrTkDBdBCzxklyNMAl//JF0skUUqmI3mRGkiT8HTaGBmSwNxHRLMJhz5PZuQtPg6kiNdi3ZZiudbWLU40WRQKkX7CA7P79FY/r3IED6Ntqy38AHCYteo2Ku7Ycojmv4pwzWkGClwdiM9YA9IwklAZge/8Cj34Dov3kDvahMujQ1HnReL0Uj7EIWMkA+DA79OQzRXLpguJUksjjdpsYOTIAsDtJRZTMxQLnAizFVTSbpreIi48GMdrcZJJ54qEMVrePQi57TBkAw1jH1HQ8VlO3PhM+U3UzsFAmNCl4sY515DU7XCQjoUoTsDJDPVHqJ7hDWfUaEnkJo81OIjR61GOqemy3gfgRTkCpXAGTzKuyAC3jNXqRtdUdcDNTSIAsY7vGeZumEiS12Fo4GDvIiyMvssS9BJ1auc6y0xoZPhDnZzc9xV9/uos/fm87Gy5s521XLZnkI2926EjVyAAkwhpAhdU5HhzUdzkY3B+hmC+RSxemrQEI9ffhamiiwd2CbFDsO0+6tJOBfREO7Bz/fMiyTCq8j+blawA4/YNXs+PhBwkNHK6ck8qnMGlMZFNBVGqH8jqNOQBNzDoZTNpZ1wAEDyVQa1TYvJN19ZJKhcFiqTgBlTNcKrUaq9szeytQnY1YVgki7t5/N2e1nEU+lsTimvwej49miARSr6s+3l7np1goEOjdXy0BMnqJZCOvWv8PVBpcuRurMwC5TJG157bOysr0eEWlUtO5bgP9u1+uHMskElVFwGXaV6/DaLXx5+9+qyoIiI8GazoAzReOrH1wNyoZqYnvV8FbGxEAzCHJ0cM4jRrkR/9O/3I3X/e42P7KAZ5/YYCcO84Pnv8pWk2Ivw2MLyQkWz0FouT7x1p6+1fC0E4CqQAu7BTTSeq7FvFkxyUs+NgXKx9yX4edoaAV7E1E5RYcpjiZXbuoW9pA8HCCZDTLwN4IXWtrOyIYrDoy8Rz6tjbkfJ78gNLqfroCYFB2G+rtBn7/2AGMMjR2OVjf5uLZ3lFUZqUGYKoGL90jCRa6tRDcAw1r4JGvkj00iL7JiyRJr64IeDiAxu9Hb9Kg0amIjWZ44cGDaDQq6rwmAvHq3Wiz00UiMt50TB65jA8vuX7ax4iPBjE73aTjSgBQtv60H0sNgNVGJh5XdOvHkgEw+SjKRUYzY3aRNWoAyg2kytmOchMwgEK+SOBQvFIADEoGIJ4pjLkDVQcA1921je6R6Qu8J1JLApTMFjEmSzWlGolwaMbGQBOpM9VRUOWnzQD0J/rJFDKV3eeMRcKhdwDQamvlYOygIv/xjBfB+TvsvP9LG7jg/6zEaNNx8adWs/z0ppoSLbO9tgRo/9YgBquH6Mh4hsbXaiOXLjLYHQGJKv39kYz29+FubKbJ2kTOqiIaGMJo1XHiJZ088Zu9FPJK0JdLFyhke+hatwEAT3Mr7WvWse/Zv1eulSwksegspKNBZHmseVkiXyX/gbEMwCy7AQ+O1RVN1XzMYLWRiY9nAMpB2dEUAtt0NuL5OCOpEX6393dcseQKEuHRyRIgl4HQQIJ0PF+zBuC1QqPVYvV4Ge7prtpRrTMp36/Ntlcn/4Gxwn2TpiqoNdl0nP3hpaw+59Vf/82Ow1dfZUBQzh4diUqt5rIvfJXI0CD3f/f/kkkkePbu37L3mSfxNLe+kUN+U+NqbAIQGYB5hAgA5pAzNl/Mubm/0bBriBNOWsOlGg9/+vUz7HzmWV5uSuAv+pC1MR7tGdfpxhe1UpCSZA4dUg74l0NiiGByGF9JDzojWpOZA6E0y1eNd6it77AzFK9XMgB5H3b1MJm9e/GdtJRCtsiLD/fh67BN6X9dzgBIOh261lay+xR5wXQFwKWSskCrtxsxRQo4my1ouh/g5GYDz/aGUJlNioNRerJWGRQJ0Cr9MOjMcOlt8NI9ZHv70LcpX1Qar5dSKjWjleiRyIUChZERtD4fkiRhcRq477vb2fd8gHfeuAafw1BTApQckwDlCiUCES2r66fOfMiyTGI0iM3tIRXNkozk8DQ3AhxbEbDVRiaZIBkJ17SunAmtWovb4K70AqglASoXj1ocLpLhUKUJGMDIwTh6owabZ3zRZNFrSGTzWF3uqgyALMv85aUhdh6e3iFnImVt9kRSuQKa0RwNCxxVx4uFPD/95NVs/8tkK8Cp8Bg95H0xfO3jr93EYCpbzPLB+z/IA70PYK/zY3G6iBlyldeoEgAEFf3/RCRJor7LwanvWUh9V/VYJ2J2KBKgiYFLqViie2sAd2MjkcGBynG1VkVdm5XubSMYzFpU6qm/qkcP9+FuaqHR0kjMmK8UZS89pQGdUcMrTymLpP493SCnaVs1Pv76hYsZ6h4v6i/3AUiGA5RkG8ViaZIDEJRrAGaXARjcH6W+a2q5i9FirdQiTFzEHY0VqFVnJZaN8cMXf8gpjaew0ruSRDhUyeaUsbgM5DJFjFZtZQf99cJZ30CpWKjaUS0HAK9FBsDXbmPteW1VwaYkSSza6EejVU9zz7cG9jp/lQVxrRqAMkarjcu+8DXCg/386OMfoGfrFi687rMsEgWtFXRGExaXu0qyJnhrIwKAuSITRZ+PcuLuuxh0SSy3FLmu7nQsIwUolrhJasKXdVAypHmuN0QmX2QwmuZ3gwVUkprRciMUvRXZ1c5IeoS6opqSxcVAJE2pJNPsGt85rWvSkyraiJfqiKQdaA/sRNfcjLG1GYffxI6/HWbBFPIfKHcDVn7wyzIgmDoDMDqQ4Oc3PUUsmKbebmCZRs+CduA3V3B+8h62HAghGZXxTbWA7xlJ0FXqVrIczlY48RNkQwV0XUp3TJXdDlrtjE5AcqFQtegqjI5CqVRpXNa+ysOyUxt47+fX42+3U2czEIxnq+5jtjtJRiMADEUzqCQJn21qr/BsMkk+m8HuqyPYnwRZxt/ZhtnpQm86eu1xWfYTGRrEaDv6AACUOoDh1DC5Yo7d4d2VxUgZo1Wp8zA7XEoGYEITsMGeqLKLO2GxYTFoyORLmBwuEhO02uFUnky+RH+kdmBXi7I0Y+JrnswWkAMZGhdW/yDFRgLIpRKP3/mzqs6W01FnqmN0xSs0LxlfEE7sp/CHfX9gJD1CX7wPk83OP972C6KFWCUD0GJrYW94L3tDeycFALPFZNdRLJTITtg5798bQZIkfB0thCc4lciyTH2Xg57tIzMWQIf6+3A1NtFkaWJElyAaUBZFKpXEwg1+Du5SgrOebc+jM7Wj1Y9nQeo7FzK0vzoAMGlNxEaHkVQOcqnCmAToiAyASTurDIAsywx2R6jvnDoAUKxAyxKgcYmbzeubtROQTWdjZ3An9+2/j0+t+ZTyXMKhSTUAZoceSSVNWQD8WlKu9ZlYBOzQO9CqtK/aAQiUmp01b3/11zlecfjqiQaGK98ZtVyAJmKy2bn85lt4z5e+wfu+8i3aVp1w3PdIeK1pWbYST/P8fU/NN0QAMFfE+smqjKQOFuhdYccQ3E9UWomq2Etdxwn0xi/GmjKQM2fxWPT8bc8IH/vF85y1xIfH7SY4PL5bmPQtJ13K4crLZI0OeoJJWlwmtBN2DbXZIdzag/QdVJPK6JBf2I7jPe9BkiQ8zRZKhRKdJ9SW/8C4CxCAvquL3P79yPk8ucOHa2YARvsTpGI5/vrfL3HOYh8tBRVNiXvAv5L63f+DqpBmXySLpNNRrFEHEErmCKfy+FL7wK80KpNPvkFpArZsLcC4DGiGAODQhz5M9N57K38XhoZQe9xIOmVhteldXWy8qAO1Vnm96qx6ckWZWHbcYcLsdJGJxygW8hwOp2hwGFFPIWkApQBYZzRhdduIDCUxO/Q0L13GB77xX9OOdSq0Oj1avYHwYP+0P3LTUXYC+q8X/guTxsR5bedV3W6y6ZBLMjqzjWDfwaomYEoBcPUizqpXFoU6u7MqA1B2fTraACCfLVYtjonloSjjbal+vpHhIRy+ek5575X8+TvfrMhHpqPcgGki6UQMg8VKvpjnjl13sMS1hP5Ef+X2iTKpNlsb+yP7sevtNJiPvogbQGfQoDWoq6xAD+wI0rHai7O+oSJn2PW3h/l/N12Hv8NKKprDVEP/X67BKZWKhAf6cTU202BpIGLIEBwa1/S3LHXRvzdMMV/i8MvbsLgXVl2nrqOTZCRCPKR8hpL5JEZJT2I0iEbvJJPM1wwAZtsHIDKcIpcuTprDiSgWt2MSoGSikuGyH4UEyKI2s6//JS7puoQ2exulYlHpaOqsDh5VKgmLQ/+6FgCXcY4FABMzAJIkcULdCSx1LX3dH/+tjq2ujkIuS3JMmqm8d6b/bjRarDQuXioW/lNw/rX/TOfajXM9DMEbhAgA5opoP6GSF0ufCnVzEkZ2MxhvQKdLsPjE5RwMt2KOt5EypjltoYcbf7sdk07DV965HG9TC6H4uLwi4GnHgIQlHSWhtY0Xzx7xeH5zP7ufHUKvK1I8FMR+yTsB8LfbaVnmnrbY0mjRko6PZQC6usjs20eq9xCSSoW2fnJRa2wkQ+caL/lsEemZIKpCCd/Az+A9v0CyNXKD62me7QmhsljYfzBAIFYt/+geSeCz6dGNvIRct4zYX/7KgQ9+lJJkw7D2xMp5M3UDTu/cRer558m8PF4slh8aRls3dbbDrNdg1qkZnbDAMdntSJKKZCRMXzhFs2t6/XDZYs5o0SLLygJXkqQqV52jxWC1Eh4cOKYaAFAyAPd238u9++/l/572f9Gqqxd1Wr0ajV6NRmsleOhApQmYLMtjBcDVAYBBq0KtklBZHCQm1ACUF/4DRxEA6IwadEYNifD4+8AUKWCsN6HWVH9NRYeHsPv8nPCOi2lYuIQtv/vVjNevM9URSI8vJkvFItlkEqPVxn3d92FQG7hy2ZVVAUAkGxkvAh6TbKz0rnxVi4cj6wBCg0m8LdaKb/xwz3423/EjEqNBkqGXFf3/EZ/Lgzu289/Xf5xkJExsRLFgdfjqMWlN4DASnqCLdo3Ztu59bg+h/v04G6oXnjqDEXdTM0PdiqQvmU8ixbKoNGqMFifZVKGmBEhvnl0fgMH9UXzttkpwXYtyBkCWZTLxWEXGYfPWzboIWNoX5Nwtfj6x6hMApKIRkOWaemar2/CGNMhy1jcgSapJGbufnvtTupxdr/vjv9XR6vRYnEoncqVXxdQSIIFAMBkRAMwVsX6C/RYGPRoWW2TIxBgcNiDLCTzN9SzoTKLK+YiaUpy/vJ5Gh5HbPrAWnUZF3cIlRIt55JyyIx9sWounJOE98BeWFl5kaGiAdo950uP53TEG90cxl2JYWwtoxnbHlp/WyPn/uOzIEVZhtOrIZ4sU8kX0C7oIDyS483sHULV1IKkn602jwTTOBjNv/+gyDu4axW8PoF72DnC1w6n/zCXpP3DvC72MFNV87v89w22P9VTd/9BoijanEYZ2Mvz7bQx/4xvYLryArof+Whk3MGMhcPhXv0Jtt5PrPVA5VhgeQuOf3onHa9UTnBAAqFRqjDYbyUiYw+E0TY7pdxDLDhMGi7J4s0xRW3E0GK02SsXCsQcAJh+7Q7v50qYvTVmEaLJqUanNlIrFiv4/FkyTTRfwtlbvrkmShEWvQTLZiYdCleP94TRGrfqoAgAYlwGVsSdL2Fsm/6BHhgdx+OqRJIk151/ESM/+SecciddUnQHIjPWf0JqN/HTnT/n4yo/TbG2uzgBM6JVg0prwGr3HLP8pY3boqqxAw4NJnH4TTn8D0cAw9/3nNzjp3e9n46Xv5cWH7sPVYJ4kATr8yk7iwSB//K9bGDnYg7O+EbVGMQqweX2kQ+FKXwZJkmha4uCJO3+Iv+tk7L7Jga+vcwHD3fsoySXShTSFUAK714fBopsyA6A3acimCsil6QuxB/dPL/8BZVc2k4iTz2YoFgqVwmyb10c8OLseE96EEVfSgGvMujQRDmG02VFrJmdPTv+HRSw5+ejrcI4Wf9dCVrzt7ahUb309/lxh99UTDQyRS6eRSyX0NVyABAJBbUQAMEdIsX5SBwo8tajE6o3XIbs6GeyJk0tHsLo9rD5F+REc1cc4baGXv95wGi6zshDwL19B3KgnN+bEM6RRUedfTVDTSpuqj8UHfkWH94gvwmgffr/yQ6of7sXRGoGc4sEvbf0f1L95L0zjqmIwKwuMdDyPrqWFuKmRXF4i0lw7XRgbSWP3GHE3WHj7B5o4gZ/AKTcoNy65CJ3BzInJR9HZrLxnmYvD4ep+AAORNCstYSjmyOw/TN1nPoP7Qx9CZa4ObCZKgORcjoHPfpZcXx8AhVCI2P334/nUJ8n1jAcY+aFhtDUWQhOps+qrMgCgyICS4bEAwDl9BiAWDGB1uSv2jVMVVx8N5YX/sUqATm86nX9Z/y+TpD8TMdl0yJLyGpcDgMHuKHUt1pqFhRa9hpLJTmI0WNHiDkTSrGlx0B9OH5VTT9mjHRTtuCcl4+mYHOxEA0PY65QAzuGrJx2Lks9kJp03Ea/Ry2hmtGKDmo7F0Oj13H3gPgDObz+fRksjwXSQTEG5ViQTqdQAAFy17CrOaT1n1s+nFhMzALl0gWQ0h9NvVjqSSirq2jpZf/G7WfG2cwgP9NPQkaLhiMLiwIEeNr3nCnKZDJvvuK3i3gHg9TVBqVQlycqnt5KKRfB2nFszy1fftZDB/XtJ5ZXPYGowgKO+QSn0nSIDYDBrQYZseuo6gHgow4Fdo5NqOI6k3OQuk4iDJGEwld9/bkqlEokJweWUjzU4jFwsVjq+1ioALuOqN08KaF4PTDY753z82tf9ceYzDp+fyPAgmUQcSVKhN77+0i6B4K2CCADmCDlyGONgkoFVrVjXXU30nX8mm0xRyGawery4F3XRVf8l+kyKnnei7MDb2kFOrSKyRymA7I320m5rIx2P86h6HS2JFydnAKL92PxODDoZi5TAVC9BbKyOYOfvYf/DsH/zlONVqVWK9V8ij6TVkq5fjCQXGTLW9sKPBdOKY8zQLtpfuV4pvvQtK18M/ek38C+OR/D6nLQaJuvF+yNpVqgPgXcxuUN9U3Ya1ni9lWZgqa3biN57H4c++lEKoRCR3/4vxrUnYD3nHPIDA5TG3IYKQ0efAQDFHi0ZCdEXStE0gwQoeOgAnpY2xWlEUha3r5ZyAHCsRcBdzi4+uPSDMzyGjlLRCJJUCQCGupUC4FpYDRryeiv5bIZcWllADkTTrGtzkcwViU2zQDwSd5OF/c8PUyqWiAbS6Evga5v8uJHhIRxj82e02dHoDVV2gLXwGD2U5BKhjLKYTCdiqI16/uuF/+IrJ38FjUqD2+DGoDYwkBhAlmUlAzDBKvWqZVfRant1toFmu57UWA1AeDiFwaLFYNGiUqm5+J8/z3n/5wYkSUJnNLHirHOJDD41yZp3uLebxsVLueTTX6BUKOBuGv9sNNmbKVl1FXeU0EA/e/9+L2r9OUSGcphqFBT7Oxcy3LOPRC4BMux57G8sPvl09CbNlBkArV6NSiWRnUIGlE3l+dP3X6RjtZemJdMHAAarkgFIx+MYzJZKp1G1RovV5SEWmLkQONR/CElSMXr4IADJ8OiUAYDgrYPdpzgBZRJx9BaL6FIrEBwF4tMyR+T7D6IuytQv3giSxMDhEk5/EZ3RiN5kBlsTrdYhgsXJDjlagwGLSsPw7lcA6In00KKqp1Qs8hRLWFraS4friB2u6GEkRyPtmRdpP7kDyd4AsX5IR6DvGdj4Cdj8ZRgrLqyF0aIjPVYInHK04Bt6jsG0o9IFtUwxXyIRyWJ77ovw07PAtxwu+VH1xdpPg8ArqM1mXFK+ZgDQUeyh6FhCMRxG1zJVADAuAUo++QT2d74Tw9Kl9P3jJwjfdReuK65A4/WiMpnIHVQWB/nAMFr/9BkAb60MgMNZkQA1O6ffaQr0dlPX3olKJWEwa18zCRBwTDags8Vk05FJFDHZ7BUHoKGeyQXAZSx6DSlJh0avr+w690cyLPJZsRk0HI5M3en5SNae10Y2XeCZe3s4vDfMgLqE7YidZ1mWlRqAsQyAJElYvXUzBgA6tQ6n3lmpA+gL9DAsh/js+s+y3r++cq0GSwOHE4dJ5pMUSgUcBsesxz8bzA49yajyGYoMKfKfMp1rN1Q5RJ1w/sX0bn+B8OC4LCkZCZOMhKlrbcfmreMDt9zK2gsuqdzeaGkkbYZIYIhsKsWfvvNNVp59Hr6OJQQOxqs848t4Wlop5HIEBg7QPmqjkMmwcOOmitVnpkYfAEmSxroBTw7wivkS9/9oJza3gdPfv3DGmgmjRakBmOjKVKa8wzsdhXyeyNAQTUuWEexTPuOJcAiz89jrbQTHB446P5HAMJlEAqPQ/wsER4UIAOaI9MEBRmwqTu3cBCgyC5unWFl0oVLh+djjxPIJcsXcpPu7LDaCh3oB6In24M/bsLrcdKtayaDHG99TfYdYP7K1kcZtd9F09lqwNSoZgO5HwLMQzv43SAbh5bunHPPEQuC42ok/sAWjWc2hl6tT9PFQBrVKxjz4MFz7PJz/72A+4sfY3gySGpUWbKUckVSeZHaCPWI4TX16HzmaUDscqO21F6BKBkCRACUefwLLGafT8M1vojKZkFQqLGeeqeyodnSQ61Ver8LQMJoZuvHW2w0Mxqpfd4vTRSwUYjieoWmaACAZCZMYW6QBnHHFohllELPBYLEqae5jsBGdLcaxZmAWlxubx0suXWB0IDllBsBi0JDMFrG63MTLAUA4TYPDQIPDyEBkemnORLR6Ned9fDm7Hu9n20OH6NOUMOmqu+mmohHFXnVCEbfVW1eRfkyH1+TlicNPcMeuO/jpcz/Cbvfw7oXvrjqn0dJIf6KfcDaMRtJg0b62iwqTXVeRAIWHUtO60VjdHhZs2MSOzX+pHAsc6MHpr0c3JnWweeuqup82WhuJGDKE+g9z7398DbPdwWlXfIiWpcpuuMk2OROl1mipa+1gaP8+lhywsuqcd6DWaMcKfcdsQGs0IpuqF8D2zYfIZ4u8/aPLp+1fULmOVXEByiQnN3Ky++orfQ2mIjzYj0avp3XVCYz2Kf1REqHQpC7AgrceSgZgUHnvmI9NGikQzFdEADAXyDLp4TD9HpmVXsXicnB/BKM5W5FdADjNPlSSitH06KRLuL0+RkdHyBfz9MX7sKV12Ov8OE169uqXIh16uvoO0cPkYirkXA7DwoVgG8sA7PsrLHg7aI1wxmfhka9DsXZaX7ECzZPPFknmdJiTg3Su8bL/hWqnjmgwjc2SR/IvA8cUHSlVanB1oFLn0ecymHTqShZAlmX6I2ns0d3ksla0U8h/YLwIOD80RLa7G/NJJ6HS6Wi+7Ue0/uqXlQJlfUc72Z4e5FKJwvAwWt/UlqcAp3R5eO5QjEx+PLthsjsJjYyiVamos04t6Qn0duP0N1QWaZ1r6tDqX30hoNFmw2C1vq5pbpNVRzqW44JPfYYFJ55MaCiJ0aKt6qA7kXIzMItTaQaWyRcJJrI0Oo00OY30h2efAQBw+s2c+YHFxAJpDmtKmHTVr1s0MITZ6UKrH8+oWD2zCwA67Z38ds9v2TGygw32NSxsmFz43mhppD/er+j/DY7X3C5QaQY2HgA4/NO70Sw88WS6X3iu8negt5u6ts4pz2+0NBLQxXnhz/dQyGa5+MbPo9Zoaa4EANUL+e9v+z5bh7fi71rI4Wefxx1Us/JspUbEYNaQimQp5Eo1NfNKL4DJ3xXBvgRda2f/njdarOTSaZKR8KQAwOGvnzEDMHr4EO7GJrwtbQQPKwGAkADNDxy+emXDJTQqHIAEgqNEBABzgJQJE0qoGXY50ETN9O8NEx1Jo1Insbq9lfPUKjVOvZNgerLNpbetg3A6waH4IXRqHVI0g73Oj9usY8i+Bg49M35yJgrZGJmDIQxLlyJptUoAED0M+x6Checq563+AJQKsPfBmuNWGkXlCA8l0ZvUOE9azYJNzRzYGaQwYaEcG0ljM8QUx5/pcHeiIk0pmaTRYaQ/rAQAo8kclkIYTXKIXBR0rVPrrjUeD8XREInHHse4ciVqhwMAldGItn7c6UPX3kGup5diOIycz6OZoQh4sd+K26zlsb3jzjEWp5NYaJRGp5F8JkU2VbuB2fCY/Oe1xmi1zehz/WopdwN2NTSh1emJBtI46qbZpTZoSGQKWMa6AQ9FM+jUKvr/vplGQ5GB6OwzAGUWrPNx0seXMmigqpcFlHsAVGdvrJ6ZJUAA3zztm2y+fDO3nnkrS0xdmGyOSec0WZsYSA4QzoarCoBfK8x2PaloDrkkEz5CAlSL1pVriI0MV2RAgRneW36zn6Ajh7O1hUtvuhmtQQmU/J12VpzRhMU5HjiV5BK/3v1rnhp4Cn/nAsK7uwm3airWmXqTlkhA+UyWTQAmovQCmCwBigRS075nJl1nTNoWHhyY9P52+OpnDO5C/UonZHdTC5GhAYqFvCIBcogA4K2O0WZHqzcw3LP/mM0RBIL5iggA5gB1coh4Qo/W/Hl+9+/P8+Dtu2hb4SEdC1dlAEApXqwVAPiWLiMul9g/soc2WxuxwDB2nw+3RUe2YSMcenpczx/tB52F9Cv7Ma5UMg7YGpWFfqkATRvGBqaBlhNh+OVJjwdjEqBEntH+JO46Da3LX8DbZMZo0dL3SrhyXjSYxqYeBlfH9C+EuwuVHFcCAKex4gTUH05zkqkPnO3k+4fRtUwdAKi9XiiViN53H5bTTp3yPF1HO9neHvJDQ6jtdlTG6Yt4JUnibV1O7t85Lj8wO1ykRgNs6nuQ2z7+Qf70nW/VvG+gtxvf6xAAtK06gbd95BOv+XUnYrQpQV6Z6Egau3fq18qi1xDPjgcAA5E0TVYVf/v57XiDe46qGdhEdD4j5ho7yJGhwYr+v8xsJUCSJFV29NM19Oag7KAfjh+u6gHwWmK26yiVZJLRHNGRNM4ZMgA6g5HmZSsrWYDhA93UtU39udKqtNDqZNl1V1bZxarVKk5738Kqngr7wvuI5WJ0R7rxdykNwiLLxndRDWYt0UAKnVFTU8qjN2vJHCEBkksykeHUUXXa1Wi1403ujrC4dYxJPKZj9HAfrsZmbB4vao2W8EA/yUhYZADmAZIk4fD5GereJyxABYKjRAQAc4A6MUgu24Ak6fjYf53G1f9xKhf8n5XER0dqBwCZyQGAc8kyrJkc3ff/lQ5HB9GRYex1fq47awGbTn0b5NMQ3KucHOsHexPpnTsxrBjzMbc1QHwQus5WFv5l3AtgdF/NcRutOjKJPKHBJC5DAEb3IYV76VxTR8/WcRlQbCSNTT4wuwCgEKGUSNDkNHJ4QgfZ87UvQtdZ5A4enDYDoNLpUNntpF94AfMpUwcA+o4Ocr0HKAwOzugAVOZtC508sjtQkQE56xsoGSwY7A4uvelm+na9WFOfHDgwvUzjWDGYLbSuWP2aX3ciJqtSA1C274wGUtjrpgsAtGMZAA/xUJDDkTQLSiOUikV0wQOVrA7Ak3f9gifu/NmsxpHKFSfp/5XxKF2AJ2L11JEIBcnnspPOn4pMIlYzm1KpAci8PhkAjU6N3qRhsDuiFDC7Zy4O7zxhA90vPEs2lSQ6PDRjdqn8HCaSyqe46oGriGbHGwhuGdqCWWumO9KNq6EJ70fPQ9XgqNyuN2ko5Es19f8ABpN2UgYgGc1SzJemDRprXstqJTI0MEnG4fDXk0kmyNToFl5m9PAh3E3NSCoV7qZmAgd7SUUjmEUNwLzA7vO/qg7pAsF8RQQAc4A02kdO3YbKlavaWYuHRicFAG6ju2YGQON2s7qxncLjezj1gcHKzujGDjdNHgc0rVOyALIMO35DydFFZvdujKsmBAAwLv8p4+mCYO0AwGDRkk7kCA0kcMljRcaD22lb5eHArlFKY02BYsE0ttwr4JxJAtSFKj86JgEyVRaLA+EkmwrPwuILyB06NKUFaOW18HhQu90Yli2d8hxtSwtyLkf6xR1oZnAAKrPIa8Rl1vH4mAzIZHfQd+a1uM68jJblq+hYu4Edm6vlUplEgmhgmLr2GYKfNykmm45SQSabUhZ2SgZg6t1ci0FDIlvAOiED0JA6jKuhiWzfXgYm1ADsefoJ9m15ZsprTSSZK2DWq8ll0vS9vLNyPDLWBXgiBpsdjV5fsb6cDel4fNJuM0CDpYFYLkZfvK/KAvS1xOzQ078njMNnRKWaucagY+16Bva8wqGXdmBxezDZpm+s1Whp5HDicNWxJ/qfYGtgK48ceqRy7Pnh57mw40IOxQ+RLWbJ+42YNeMZibLufyrPfL1ZM8kGNDycwuo2TNv5txZGi43oSGCSw5XeZMZgtU0p8SoVi4QHB3A3Kt8R7qZWDu18ESQJs/31mT/Bm4tyRlC4AAkER4cIAOaAZM9+Io42/AvHd6hkWR7LAHirznUb3TWLgCVJYv0Pf0zCpSK9N0gyEq5yRqHlJCUAePhm6HuObMdHUZvNaJvGmgY520BvVzIAE/EshNH9NZuClV2AQgNJXMm/g7sLBrfjb7chyzKBAzFkWSY2ksLOYXDO4Jnu7kJdDFGMx2h0GitykVL/NoxkKLpWUQyFps0AgOIEZDnl5GmLY1U6HdqmRpLPPIN2BgegMpIkcf4KPw/sGl9Y9oVSlSZgq85+B7sefYhCfnwRFDjQjc1bd8zdeucarUGNWquqyICigfS0GQCrXgkAJkqALKM9bLjkcgrpFLlwgGyhSGign3hwhMjQALFgYMrrlUlllQzAvmf/zh++cTOpWHRsPJNrABQZwMxa8Ymk47UzAHa9HavWykvBl15zC9AyZruOw7vDOHzTy3/K2Dx1uJtaeO7u385KWtZkbZqUAdh8cDMeo4cHDygBa0ku8cLwC1zYcSFGjZED0QMk80lM2vFgT29SMjBTBQCGMZegiUSPUv5TuZbVCrKs/PcIprMCjQwPIqkkbHVKUb+7uYWDO7ZitjtQ1ehQLnjrUc4IigyAQHB0iABgDhg9eICwo43FS8d3tjPJBIVsFqu72i7TY/DUDAAAZGSeWBHmkEaFqlTCqJvg1NJ6Erx0N2z7FXzwbtL7+zGsXDHuamJywWf2K/+diKsDcklFHnQERquORChDIpzFld8B666Gge2o1Cpal7vp3RFUXIJyMjaXBjQzNL8ye1CZTJRikaoi4MbhR+j3nkquX9HrT2UBWsbxrktxvv/90z8WoG/vILNrF5oZHIAmcv5yPw+/PEy2oMiAlC7AygKnZflK9CYT+5/7e+X84RlcWt7sSJKkyIBiuUoTqGlrAAwa4mNFwKlYlMDwCIQHaV+zjoYFi2jJDjAUzdC77Xmalq6gvmsRB3dsn3Ec5QzAyMEeCvkc2//yZ/LZDMlwaFINAIDD30BkaGDWzzOTiE8ZpDVaG9kT3vP6ZQDs+jH9/+wXyp1rNzDUvW9a/X+ZNlsbLwVfoiQrNUC5Yo7H+x/nCxu/wHODzxHKhOiOdJMtZlnmWUanvZPuSDepQgqztkYGwDJZigVjGYDk5AzA0RQAlykHY7UWcQ5f/ZTZndHDh3A1NKFSKYt9T1PLWA8AIf+ZL5QzgiIAEAiODhEAzAHhkRg5fQPNneNyn3hwBL3JXLGOLDNVETDAQGKAIUeatjXrMJcg8+KL4zc2bVA6717xW3B3kt65A2NZ/19GM7kpEFqjYt1ZQwZksGgp5EsYjUWMTR3QugkGd4As07bCw8GdQaLBNEZjEa2nceYXQpJQeRopJWI0OY0E4lky+SLLY08SazuX/KGDaGfY/QewX3wxxtWrZzxP19EBsox2ljUAACsb7TjNOj7ysy38+rlDBOJZmscyAJJKxcqzz+fFhx+onK+4tByf8p8yxjEnoOhIGoNFq3QzngLLWAbA7HAiIaHu2YbR14TJZqdp6Qo6isP0R9L0bNtCxwnraV25hoM7tlXuf/jlXfy/m64jm6q2C01lC5h0GgK9PSw66VS2/+VPjPYdQqs3YLI7Jo1jNnaRZWRZJpOoLQECRUKTL+VftwyAyaEExkcTAHSsVQr1ZxNcnt58Oql8ikf7HgXgmcFnsOlsvK3lbSzzLOPhgw/z/PDzrPKuQqvS0unoZH9kP8l8sioA0BrUSCoJo7nG9wRjNqBHBACR4fQxZgDKTe5qBADTzO3o4b6qTsjuZuX7QhQAzx/KGwLCBlQgODpEADAHxJN1yHKSlx//Y6W4LVFD/w/TBwA90R5abC2c9eF/ZGV9C8ktW8Zv1Fvg43+DxrUAZF7cMa7/n4kpCoGNY8WAbtOoIjGqWwqFNIR6aFnqIjyYon9PGLsxObP+fwyVt5VSKoPXokenVjFy4CXqSwPoF719xgLgo0XfoYxppiZgE5Ekibs+fiKnLvBy15Y+PBYdHst4ZmPZ6WcxuG8Pe55+ElmWGe7txtfe9ZqNeS4wjTkBRUdSMxZzWsZsQFVqNSaHA19gJw1LFKep5qUr8CX76RsOc/jlXbSvWacEALteRB5zqHr6D3cRGjg8qTg4mSti1qoIHOxh/cXvxuJ08ff//RV2n7+mN7/DV094cOYMgCzL7Hj4AUDCNEVmqdGiBK+vZwYAmNEBaCL+jgUsPvl0GhYtmfFcvVrPVcuu4ic7foIsy2w+tJmzWs5CkiTOazuPvx74K88PPc863zoAOh1KBuDIAECSJAxmzZQZAINpsgQoEjg2CVDZkalWVsbhqw4ABva+wuFXdgGKBairsalym9XtQWc0YRFdgOcN9ro6VGoNxhlqYwQCQTUiAHijkUtkSy2U1Ht58tc/Z/ffHweo6QAESgAwmhmtuLJMpDfaS4e9A3udn8VnnE1qYgAwgWIkQu7gQQwrVsxujJ6FENw//nepBKUiGp0ajV6Ni73K7r9GpwQBgy+iN2mpX2Bn12P92LQjMzsAjaHyd1DK5JAkaHAYSD74PzyZX0Z9nZfcwUPoWqYvAD4adB3KmLSzLAIu0+Aw8onTO7n3mpPZ8q9nVxVummx23v7xT/LI/9zGXV/6F8KD/a9LD4A3EpNVq2QAZtD/A3jMekLJHH2hFAaHC3cuxOK1StBZv3AR2nyKgWcexV5Xx893JfhLQEupUCBwoIfhnv0M7H2F93zpG7z8+CP0vbSjct1UroClECefyeBubmXdRe+id/sLk/T/ZabaJc5nMxzatYPAgR5CA/3c9+1v8PTv7+Jdn/s3dIbaz63BohTIv241AA5lR/1oFsqSSsUFn/rMjAXAZS5beBkDiQGe6H+CRw89ylktZwFwTus5vDD8Ak8PPM16/3oAuhxddEe7SeVTVTUAoOzyT1sEnMxXvpuK+RLx4LFlAMYlQJN3ce0+f6W+Q5Zl/vrj7/Hbr3yeP976TYa691ZlACRJwt3UjNkpCoDnC2qNlqv+4wc4/Q1zPRSB4LhCBABvMHIiQE7VjlzsxuL2sH+L0rE3PhrEUiMAcBvdpAtpUoXJHVW7I92025VdbdP69WRe3EEpozRekotFQr/4BSPf/wGBW29F29yMZrY/ip6ucQtRgCe/DT89C3IpjGYVrvxOJQMA0LAaBrcD0LbCQyKcxSYdnn0A0LAQZJDTaTqNJeQfPsjIbicOk1bJALS9hhmAzk5Udjsaf/3MJ09Brd3npae9jau/czutK9fQtnLNcS8/MNqUbsAzOQABtLhNvHd9M5/89TYkk50SKjrGpGZanR7J20ph60MUGxfzw79184O/9dK0bCUHdmxjy32/Z/kZ51DftYhT3n8lf/nxd8mPvX+T2SLmxDDuxmY0Wi2LNp2GxeWuqf8HZZc4FhypKsguFvLc862v8qfvfJP//crn+Z8b/hFZlrnyW9+b1k61yaLsKL9eGQBXvZmGBY7XpDv0VJi0Jj649IPc/PebkSSJNXVrAPCZfaz0riRXyrHcsxxQMgB98T5CmRAWbfUC3N1omXJBbzBrKRVl8lmlPiYaTKPWqLA4Zqj9qXUtqw2VWoO2RlDm8NWTCI2Sz2UJHOghNhLgI//1Y7Q6HZGhIbwtbVXnr3/nZXStP+moxyA4fnE1zEJyKhAIqhABwBtMeN+LxEwuiolhLrzus/S9tIN0Ik48WDsDYNPZ0Kq0NWVAPdEeOhxju9otLagdDtIvKruosQceJPiTn5AfGKAUT+C++urZD/JICdDO3yldg++9hrWrE7Q1hMeLh+tXwcB2QAkAAGz5vTN3AR5D3ahYdxbjCS7sexC1vsTi3b1k9+5TLEBfwwyA2m5n4VNPorbMXnoxW3RGE5su/wfe/fmvvObXfqMx2XSk4nmlB8As/Nz/9YIlZPJFto3KxG0NVTvr1vZFqPJpfjNk4fYPrlU6B7s7ePnxR9i/5WnWXXgpAGvOvRCz3cmWP/4BUDIAuuhgJZui1mg4/5p/ZvkZZ08eAIrmW6PREg0oxaKyLPPQ7d8nk0jw0e/+hGvuuIsbfn0vl3zmC7Oy0QRelz4AoEh/Lv3nE16Xa0/kfYvfR7aQ5czmM1GrxoONd3a9kw3+DejUSibCZ/Jh0pjYF9lXJQECOO/jy2laXDug1Rk1IFGxjI0Mp7D7TEizsDY9EqPFitFqrRlgmx1ONHo9scAwrzzxCAs2bsLhr+e8/3MD//TTX+Gsr178LVh/0qyKpQUCgWA+U1vcKXjd2PHM06TlPAs2nkzjoiV4WtroeeE54qFRmpevmnS+JEmVOoBWWysvBV/iqYGnSBfS7Avvo8PeUTnPtH49qS1bMK1bS/CHP8R77Sdxvvc9Rz9IzwKI9CnNxKL9EOqFa56Fn1/EMvk5WHDO+Ln1q+HhL4Ms4/CZaFlkpS64a9Y1AJJvEZJKphToZc1Lf2ZbSzsh1wqsn/40xdHR17QGAEDSiLf8TBjHXIDio+lZOboYtGq+/w8n8JFv9bB2cXUvhsalK9jx7MO8+4LTOWNRHf+wMc7DW1Os7O9j8cmno3N42HYozJoWJ+sufheP/eKnnHTZ+0nmiqjDA9St3FS5VsvyqWtYJJUKh7+e4e59IMu89PgjHNq1g3/42n9UCutVqtntuLfb2/n3U/99khzmeMOqs/Ifp/8HLbbqIPrSrku5tOvSyt+SJNHh6GDHyA5Mmtk/Z5VKQm/UkEnmsboMSgfgY3AAAmhcvJQzrvpYzdskScJR5yc02M8rTz7GO679dOW2WkXDAoFAIJgZkQF4g+nfE6aYe5kNF78LUHar9m95esoaABgvBM4Vc1z36HXsHNlJLBvjA0s/wALngsp5pg1KABC7/wHkTAbHpZcc2yCt9aAzQ6gHdv8ROs5QdvTfdyekQ9B2yvi5vmWKbWj4AAAXXQZuR0YpQp4NegsqnUTpgS+T7Yefe8+l9x3vQy6VUNntqB2OY3sOgmPGZNMRHUmRjudnrAEo01Vn4d8+ej4XnH9m1fEzz9hE68e/zCfOXAjAZWubeXpEovGEk1h78WVce+dWLr/tafYHErSvXkcmmWBg725S2QJysP+oLFU9LW088IP/5Fefv5Hu55/lXTfdjMV19MWgapWaCzouOOr7vRnZ1LiJJmtT1TFJkibttHc5lML1IzMAM6E3a8kkFNmVUgB8dB2Ay+iMJhZvOm3K2x3+enY8/CAqlYrm5bOsZRIIBALBlIjt0DeYWDiNRmXF26rskC/YuIln7/4tMvKUAUC5G/B93fdh1pr5ztu+g0qaHLuZ1q9n+JZ/pzA8jPufPoGkq23fNyOSpDT5Cu6FV/4Iaz+kHK9fCZ98ASwTdNgaPdQtgcEXlSAh1DNr/X8ZlUFDatuLFGUvu9wdnOO10/Ctb5J8/PFjG7/gVWGy6cgmC+hNmikLQGvxtsWTi6tNeg3/8LbxnXuXWccFKxvYY2pl57YEh0IpLlnTyNf+/DI/+/AGFp54Cq88+TeyqQWUEhG8bbPLJAGcf82NvP0Tn0KrO3oN+nyn064EWkcbADQtcvLsfT3Ud9qJDKdoXOB4HUYHdl89L/zpbtZd9K5ZZ3IEAoFAMDVvigzAD37wA9ra2jAYDGzcuJHnnntu2vP/93//l8WLF2MwGFixYgX333//GzTSV0/dyna8y8dtIl2NzVi9dRTz+WkzAMOpYX6686d8bOXHai7+QXG5UVksyIUCjksueXUD9SyA3scVff+id4wftzXAkR13G1ZD9yNK9+Bw79EHABYr8XAbmg0nUVBpaHIaMS5bhuef/unVPQfBMWG0KoHjbPT/x8IVG1v4xdMHeejlYX72kQ184YIlbO+L8OjuAEtOOYM9Tz+BJnQYrdOL3jT7BalKrRaL/2Ok06EEAEcrezr1vQuQJInNP3+lUgPwelDu9rr01DNnOFMgEAgEs2HOA4Df/OY33Hjjjdx8881s3bqVVatWce655xIIBGqe//e//533v//9XH311Wzbto1LLrmESy65hF27dr3BIz823v3pz/G2qz9R+VuSJBasPxGDxYpWb6h5H4/Rwz377kEtqTmv7bwpry1JEs73vQ/fTZ9F0s5+57Ym7gWw/U7F7cdcOzCpsOHjsOd+uP8zSgOxWRYAl1H5OkgfCOE683RUkmK7KZg79CYNKo2E/Rj13DOxttXJFRtbuOND62l0GHGYdNxw9kK++ueX8S1Yglanp6nvGSwNr239h2BqFjoXYtQYseqOTlOv0ap5xz+tIHAwRjqeP+YagJmo71pIxwnrK5lTgUAgELw65jwA+M///E8+9rGP8eEPf5ilS5dy2223YTKZuOOOO2qe/53vfIfzzjuPz3zmMyxZsoSvfvWrnHDCCXz/+99/g0f+2rHsjHNYfuY5U97uMXgIZ8N8dMVH0aimV215P3kt1rNrO6UcFZ4FUMjAkgtnPte/Aj66GQ48Cbt+d9QZAPWY97f9jNP51mWrWNEoGrrMJZIkYbLqZq3/P5brf+Wdy1k+YZ6v2NiCRiXx8V9updS+Gnf8MM7mttfl8QWT8Zq8PHTZQ+jVR59BMVp1XHDNKpaf3nhUkrGjwdfRxaWfvfl1ubZAIBDMR+Y0AMjlcrzwwgucPWHBqlKpOPvss3n66adr3ufpp5+uOh/g3HPPnfL84wFXQyOnf+AjU97eaG2kydLEhZ2zWIy/VniUok0Wz7IY0tkKV/9FyQa0bpr5/AmozGb0C7rQ1tdz2domDFqh8Z1rLE4DTv8b54KjUav46ZXrWdXk4GmVsvPf2Hl8d1Q+3rDrjz3wdtWbOf39i17D0QgEAoHg9WROi4CDwSDFYhGfr7p40OfzsXv37pr3GRoaqnn+0NBQzfOz2SzZbLbydywWA6BUKlEqlV7N8I+JUqmELMtH9dgn+U/i9xf9HjXqN27M3iVw1Z/A1qR0Ap4NOiuc903l/49inOq6OszNTXMyH1NxLPP0VuK8f1yG3qR5Q59/k9PAdWd1wVldPHtPlpVrV8/4+PN9no4XxDwdH4h5On4Qc3V8MBfzNNvHesu7AN1yyy18+ctfnnR8ZGSEzFjX0TeSUqlENBpFlmVURxbTzkCM2Os0qikwLoApajFeS+SrrkSW5SnrPuaCVzNPbxXi6bl77PZNpxOJJyCemPY8MU/HB2Kejg/EPB0/iLk6PpiLeYrH47M6b04DAI/Hg1qtZnh4uOr48PAwfr+/5n38fv9Rnf+5z32OG2+8sfJ3LBajubkZr9eLzWZ7lc/g6CmVSkiShNfrFR/aNzFino4PxDwdH4h5Oj4Q83T8IObq+GAu5slgqG0ocyRzGgDodDrWrl3L5s2buWTMtrJUKrF582auvfbamvc56aST2Lx5M9dff33l2EMPPcRJJ51U83y9Xo9eP7mwTaVSzdmHRpKkOX18wewQ83R8IObp+EDM0/GBmKfjBzFXxwdv9DzN9nHmXAJ04403ctVVV7Fu3To2bNjArbfeSjKZ5MMf/jAAV155JY2Njdxyyy0AXHfddZx++ul8+9vf5oILLuCuu+7i+eef5/bbb5/LpyEQCAQCgUAgEBwXzHkA8N73vpeRkRG+9KUvMTQ0xOrVq3nwwQcrhb6HDh2qimY2bdrEnXfeyRe+8AU+//nPs2DBAu655x6WL18+V09BIBAIBAKBQCA4bpjzAADg2muvnVLy87e//W3Sscsvv5zLL7/8dR6VQCAQCAQCgUDw1kMIxwQCgUAgEAgEgnmECAAEAoFAIBAIBIJ5hAgABAKBQCAQCASCeYQIAAQCgUAgEAgEgnnEm6II+I1ElmVAaQg2F5RKJeLxOAaDQXj3vokR83R8IObp+EDM0/GBmKfjBzFXxwdzMU/l9W15vTsV8y4AKLdIbm5unuORCAQCgUAgEAgErz3xeBy73T7l7ZI8U4jwFqNUKjEwMIDVakWSpDf88WOxGM3NzfT19WGz2d7wxxfMDjFPxwdino4PxDwdH4h5On4Qc3V8MBfzJMsy8XichoaGabMO8y4DoFKpaGpqmuthYLPZxIf2OEDM0/GBmKfjAzFPxwdino4fxFwdH7zR8zTdzn8ZIRwTCAQCgUAgEAjmESIAEAgEAoFAIBAI5hEiAHiD0ev13Hzzzej1+rkeimAaxDwdH4h5Oj4Q83R8IObp+EHM1fHBm3me5l0RsEAgEAgEAoFAMJ8RGQCBQCAQCAQCgWAeIQIAgUAgEAgEAoFgHiECAIFAIBAIBAKBYB4hAoA3kB/84Ae0tbVhMBjYuHEjzz333FwPSXAEt9xyC+vXr8dqtVJXV8cll1zCnj175npYghn493//dyRJ4vrrr5/roQiOoL+/nw984AO43W6MRiMrVqzg+eefn+thCSZQLBb54he/SHt7O0ajkc7OTr761a8iSgTnlscff5yLLrqIhoYGJEninnvuqbpdlmW+9KUvUV9fj9Fo5Oyzz2bfvn1zM9h5zHTzlM/n+exnP8uKFSswm800NDRw5ZVXMjAwMHcDHkMEAG8Qv/nNb7jxxhu5+eab2bp1K6tWreLcc88lEAjM9dAEE3jssce45ppreOaZZ3jooYfI5/O8/e1vJ5lMzvXQBFOwZcsWfvzjH7Ny5cq5HorgCMLhMCeffDJarZYHHniAl19+mW9/+9s4nc65HppgAt/85jf50Y9+xPe//31eeeUVvvnNb/Ktb32L733ve3M9tHlNMplk1apV/OAHP6h5+7e+9S2++93vctttt/Hss89iNps599xzyWQyb/BI5zfTzVMqlWLr1q188YtfZOvWrfzhD39gz549XHzxxXMw0mqEC9AbxMaNG1m/fj3f//73ASiVSjQ3N/PJT36Sm266aY5HJ5iKkZER6urqeOyxxzjttNPmejiCI0gkEpxwwgn88Ic/5Gtf+xqrV6/m1ltvnethCca46aabeOqpp3jiiSfmeiiCabjwwgvx+Xz893//d+XYu9/9boxGI7/85S/ncGSCMpIkcffdd3PJJZcAyu5/Q0MD//zP/8ynP/1pAKLRKD6fj5/97Ge8733vm8PRzl+OnKdabNmyhQ0bNnDw4EFaWlreuMEdgcgAvAHkcjleeOEFzj777MoxlUrF2WefzdNPPz2HIxPMRDQaBcDlcs3xSAS1uOaaa7jggguqPluCNw/33Xcf69at4/LLL6euro41a9bwk5/8ZK6HJTiCTZs2sXnzZvbu3QvAiy++yJNPPsn5558/xyMTTEVvby9DQ0NV3312u52NGzeKdcWbnGg0iiRJOByOOR2HZk4ffZ4QDAYpFov4fL6q4z6fj927d8/RqAQzUSqVuP766zn55JNZvnz5XA9HcAR33XUXW7duZcuWLXM9FMEU9PT08KMf/Ygbb7yRz3/+82zZsoVPfepT6HQ6rrrqqrkenmCMm266iVgsxuLFi1Gr1RSLRb7+9a9zxRVXzPXQBFMwNDQEUHNdUb5N8OYjk8nw2c9+lve///3YbLY5HYsIAASCKbjmmmvYtWsXTz755FwPRXAEfX19XHfddTz00EMYDIa5Ho5gCkqlEuvWreMb3/gGAGvWrGHXrl3cdtttIgB4E/Hb3/6WX/3qV9x5550sW7aM7du3c/3119PQ0CDmSSB4jcjn87znPe9BlmV+9KMfzfVwhATojcDj8aBWqxkeHq46Pjw8jN/vn6NRCabj2muv5U9/+hOPPvooTU1Ncz0cwRG88MILBAIBTjjhBDQaDRqNhscee4zvfve7aDQaisXiXA9RANTX17N06dKqY0uWLOHQoUNzNCJBLT7zmc9w00038b73vY8VK1bwwQ9+kBtuuIFbbrllrocmmILy2kGsK44Pyov/gwcP8tBDD8357j+IAOANQafTsXbtWjZv3lw5ViqV2Lx5MyeddNIcjkxwJLIsc+2113L33XfzyCOP0N7ePtdDEtTgrLPOYufOnWzfvr3yb926dVxxxRVs374dtVo910MUACeffPIkG929e/fS2to6RyMS1CKVSqFSVS8H1Go1pVJpjkYkmIn29nb8fn/VuiIWi/Hss8+KdcWbjPLif9++fTz88MO43e65HhIgJEBvGDfeeCNXXXUV69atY8OGDdx6660kk0k+/OEPz/XQBBO45ppruPPOO7n33nuxWq0VLaXdbsdoNM7x6ARlrFbrpLoMs9mM2+0W9RpvIm644QY2bdrEN77xDd7znvfw3HPPcfvtt3P77bfP9dAEE7jooov4+te/TktLC8uWLWPbtm3853/+Jx/5yEfmemjzmkQiwf79+yt/9/b2sn37dlwuFy0tLVx//fV87WtfY8GCBbS3t/PFL36RhoaGaR1oBK89081TfX09l112GVu3buVPf/oTxWKxsq5wuVzodLq5GjbIgjeM733ve3JLS4us0+nkDRs2yM8888xcD0lwBEDNf//zP/8z10MTzMDpp58uX3fddXM9DMER/PGPf5SXL18u6/V6efHixfLtt98+10MSHEEsFpOvu+46uaWlRTYYDHJHR4f8r//6r3I2m53roc1rHn300Zq/R1dddZUsy7JcKpXkL37xi7LP55P1er181llnyXv27JnbQc9Dppun3t7eKdcVjz766JyOW/QBEAgEAoFAIBAI5hGiBkAgEAgEAoFAIJhHiABAIBAIBAKBQCCYR4gAQCAQCAQCgUAgmEeIAEAgEAgEAoFAIJhHiABAIBAIBAKBQCCYR4gAQCAQCAQCgUAgmEeIAEAgEAgEAoFAIJhHiABAIBAIBAKBQCCYR4gAQCAQCAQCgUAgmEeIAEAgEAgErxtnnHEG119//VwPQyAQCAQTEAGAQCAQCAQCgUAwj5BkWZbnehACgUAgeOvxoQ99iJ///OdVx3p7e2lra5ubAQkEAoEAEAGAQCAQCF4notEo559/PsuXL+crX/kKAF6vF7VaPccjEwgEgvmNZq4HIBAIBIK3Jna7HZ1Oh8lkwu/3z/VwBAKBQDCGqAEQCAQCgUAgEAjmESIAEAgEAoFAIBAI5hEiABAIBALB64ZOp6NYLM71MAQCgUAwAREACAQCgeB1o62tjWeffZYDBw4QDAYplUpzPSSBQCCY94gAQCAQCASvG5/+9KdRq9UsXboUr9fLoUOH5npIAoFAMO8RNqACgUAgEAgEAsE8QmQABAKBQCAQCASCeYQIAAQCgUAgEAgEgnmECAAEAoFAIBAIBIJ5hAgABAKBQCAQCASCeYQIAAQCgUAgEAgEgnmECAAEAoFAIBAIBIJ5hAgABAKBQCAQCASCeYQIAAQCgUAgEAgEgnmECAAEAoFAIBAIBIJ5hAgABAKBQCAQCASCeYQIAAQCgUAgEAgEgnmECAAEAoFAIBAIBIJ5xP8H7/DwAEy+vPwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(9, 3.2))\n", + "for q in lang_Q[:6]:\n", + " ax.plot(np.arange(q.size) * lang_dt, q, lw=0.8)\n", + "for y, lab in [(QU, \"Qu\"), (0.45, \"Q‡\"), (QF, \"Qf\")]:\n", + " ax.axhline(y, color=\"k\", ls=\"--\", lw=0.8); ax.text(0.2, y + 0.01, lab)\n", + "ax.set_xlabel(\"t\"); ax.set_ylabel(\"Q\"); ax.set_title(\"Six Langevin trajectories, stopped at folding\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "8781f3ea", + "metadata": {}, + "source": [ + "## 2. Attempts at Q‡\n", + "\n", + "An **attempt** is an excursion out of U (Q < Qu) that gets past Q‡; it **fails** if it returns to U before reaching Qf. Moving Q‡ changes what counts as an attempt:\n", + "- the success probability per attempt, p, grows as Q‡ approaches Qf;\n", + "- independent attempts give a **geometric** distribution of the number of failures k (§2.1)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "e62af638", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:20:58.556870Z", + "iopub.status.busy": "2026-09-18T17:20:58.556333Z", + "iopub.status.idle": "2026-09-18T17:20:58.914838Z", + "shell.execute_reply": "2026-09-18T17:20:58.913989Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAFJCAYAAABtkfX5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAlGtJREFUeJzs3XdYU/fbBvA7QQjIRnZlawXFgbO4wFEBrdbRuveqFve2rVWsilq1Vq1SWyu21dZRbW2tWrXu0Z8D90YQF4LKEJSZ8/7Bm0hMGMGEBHJ/rotLc3LGk4eQk+ec7xAJgiCAiIiIiIiIiLRCrOsAiIiIiIiIiCozFt5EREREREREWsTCm4iIiIiIiEiLWHgTERERERERaRELbyIiIiIiIiItYuFNREREREREpEUsvImIiIiIiIi0iIU3ERERERERkRax8CYiIiIiIiLSIhbeRKRVgwcPhqenp67DICKicpSRkYHhw4fD2dkZIpEIEyZMUGt7kUiEOXPmyB9HR0dDJBIhPj5eo3FWJIaUg1u3bqFDhw6wtraGSCTC77//XuptDx06BJFIhEOHDpW4bnBwMIKDg+WP4+PjIRKJEB0drXbM2vR6nFQxsfAmXLlyBf3798dbb70FiUQCV1dX9O/fH1evXi1ymzlz5milmFq3bh38/PxgamqKmjVrYuXKlWXaz/z58yESieDv76/y+RMnTqBly5aoWrUqnJ2dMW7cOGRkZLxJ6JXeixcvMGfOnFKdyLRl06ZNWL58uVaP8fDhQ8yZMwfnz5/X6nG0JTU1FSNHjoSDgwPMzc3Rpk0bnDt3Tu395Obmonbt2hCJRFiyZInCc3PmzIFIJCry5/jx4wrrb9myBe+88w5sbGxQrVo1BAUFYdeuXW/0OolIvy1YsADR0dEYPXo0fvrpJwwYMEDXIVEFMmjQIFy6dAnz58/HTz/9hMaNG+s6JK27evUq5syZYxAXVgxVFV0HQLq1fft29OnTB3Z2dhg2bBi8vLwQHx+PdevWYdu2bdi8eTPef//9conl22+/xahRo9CjRw9MmjQJR48exbhx4/DixQtMnz691Pu5f/8+FixYAHNzc5XPnz9/Hu3atYOfnx+WLVuG+/fvY8mSJbh16xZ2796tqZdT6bx48QIREREAoNZV1++++w5SqVQjMWzatAmXL19W+86JOh4+fIiIiAh4enqiQYMGWjuONkilUnTq1AkXLlzA1KlTYW9vj9WrVyM4OBhnz55FzZo1S72vlStXIiEhQeVz3bt3R40aNZSWf/LJJ8jIyECTJk0U9jNu3Dh06tQJCxcuRFZWFqKjo/Hee+/ht99+Q/fu3dV/oUSk9/7991+88847mD17dpm2f/nyJapU4ddUQ/Ty5UucPHkSn376KcaMGVOux/bw8MDLly9hbGxcrscFCgrviIgIBAcHK93c+ueff8o9HtI8fqIZsNjYWAwYMADe3t44cuQIHBwc5M+NHz8erVq1Qv/+/XHx4kV4eXlpNZaXL1/i008/RadOnbBt2zYAwIgRIyCVSvHFF19g5MiRsLW1LdW+pkyZgnfeeQf5+fl48uSJ0vOffPIJbG1tcejQIVhZWQEAPD09MWLECPzzzz/o0KGD5l6YAcvMzIS5ublOTl6Gatu2bThx4gS2bt2KDz74AADQs2dPvP3225g9ezY2bdpUqv0kJSVh7ty5mD59Oj7//HOl5+vVq4d69eopLLt37x7u37+P4cOHw8TERL585cqVaNKkCf7880+IRCIAwNChQ/HWW29hw4YNLLyJ9ExeXh6kUqnC33FZJCUloXbt2mXe3tTU9I2OXxLZOYp0o7j8JycnAwBsbGzKMaICIpFI6++9snjTv0fSD2xqbsC+/PJLvHjxAmvXrlUougHA3t4e3377LTIyMvDll18CUGxeGhERgbt378ofv2mz84MHD+Lp06f4+OOPFZaHh4cjMzOz1M1Sjxw5gm3bthXZHDk9PR379u1D//795UU3AAwcOBAWFhbYsmWLwvrXr18v8q7f6w4dOoTGjRvD1NQUPj4++Pbbb+U5e93PP/+MRo0awczMDHZ2dujduzfu3buntN7WrVvl69nb26N///548OCBwjqDBw+GhYUFEhIS8N5778HCwgJvvfUWvvnmGwDApUuX0LZtW5ibm8PDw0Nl8ZWamooJEybAzc0NEokENWrUwKJFi+R3quPj4+XvkYiICPnvXdb/ThZDbGwsOnbsCEtLS/Tr10/+3OvvD6lUiq+//hp169aFqakpHBwcEBoaijNnzhSZ3+DgYOzatavI9112djZmz56NGjVqQCKRwM3NDdOmTUN2drbCfvbt24eWLVvCxsYGFhYWqFWrFj755BMABb9D2d3aIUOGyI9TXF8v2e/4+vXr6NmzJ6ysrFCtWjWMHz8eWVlZRW6nDdu2bYOTk5NCMevg4ICePXvijz/+UMpFUWbMmIFatWqhf//+pT72L7/8AkEQ5L93mfT0dDg6Oir8HVhZWcHCwgJmZmal3j+RIZF9rty8eRP9+/eHtbU1HBwcMGvWLAiCgHv37uH999+HlZUVnJ2dsXTpUqV9JCUlYdiwYXBycoKpqSnq16+PDRs2KKwj68+6ZMkSLF++HD4+PpBIJPKuZtevX8cHH3wAOzs7mJqaonHjxti5c2exscv618bFxWHXrl3yz9H4+Hjk5OTg888/R6NGjWBtbQ1zc3O0atUKBw8eVNrP6328VSlqHU9PTwwePFj+WNY3+vDhw/j444/h6OiI6tWry5/fvXs3WrVqBXNzc1haWqJTp064cuWKwj4TExMxZMgQVK9eHRKJBC4uLnj//ff1olnw6tWrUadOHXl3wfDwcKSmpiqsExwcDH9/f1y9ehVt2rRB1apV8dZbb2Hx4sVK+7t79y66dOkCc3NzODo6YuLEidi7d6/KftP//fcfQkNDYW1tjapVqyIoKEipu5Hs/Xz16lX07dsXtra2aNmypcrXMmfOHHh4eAAApk6dqnSuj4mJQVhYmPw80q5dO5w6dapUeVq7di18fHxgZmaGpk2b4ujRo0rrqOrjLfuO8+DBA3Tt2hUWFhZwcHDAlClTkJ+fr7D906dPMWDAAFhZWcHGxgaDBg3ChQsXSvwuER0djQ8//BAA0KZNG/nfjSzfr/fxlv2dbdmyBREREXjrrbdgaWmJDz74AGlpacjOzsaECRPg6OgICwsLDBkyROV3gNJ8H7116xZ69OgBZ2dnmJqaonr16ujduzfS0tJKyDi9jne8Ddiff/4JT09PtGrVSuXzrVu3hqenJ/7880+sXr1aoXnp9u3bcfToUXz11VcAAAsLC/l2KSkpSh9EqlStWhVVq1YFUPBBCkCpD0+jRo0gFosRExNTYhGQn5+PsWPHYvjw4ahbt67KdS5duoS8vDyl45iYmKBBgwbyOGT8/PwQFBRUYr/mmJgYhIaGwsXFBREREcjPz8fcuXOVLmgABf3PZ82ahZ49e2L48OFITk7GypUr0bp1a8TExMiv8EZHR2PIkCFo0qQJIiMj8fjxY3z99dc4fvy4wnqy1x4WFobWrVtj8eLF2LhxI8aMGQNzc3N8+umn6NevH7p3746oqCgMHDgQgYGB8lYML168QFBQEB48eICPPvoI7u7uOHHiBGbOnIlHjx5h+fLlcHBwwJo1azB69Gh069ZNXtgVvuuZl5eHkJAQtGzZEkuWLJH/blUZNmwYoqOjERYWhuHDhyMvLw9Hjx7FqVOniuzH9emnnyItLQ33799Xet9JpVJ06dIFx44dw8iRI+Hn54dLly7hq6++ws2bN+WDsly5cgXvvfce6tWrh7lz50IikeD27dvyLwl+fn6YO3cuPv/8c4wcOVL+t9G8efNif/9AwZ1lT09PREZG4tSpU1ixYgVSUlLw448/Frvdixcv8OLFixL3b2RkVGKrj5iYGDRs2BBiseI11aZNm2Lt2rW4efNmkX8bMv/73/+wYcMGHDt2TOVFo6Js3LgRbm5uaN26tcLy4OBgbNu2DStXrkTnzp2RlZWFlStXIi0tDePHjy/1/okMUa9eveDn54eFCxdi165dmDdvHuzs7PDtt9+ibdu2WLRoETZu3IgpU6agSZMm8r+/ly9fIjg4GLdv38aYMWPg5eWFrVu3YvDgwUhNTVX621u/fj2ysrIwcuRISCQS2NnZ4cqVK2jRogXeeustzJgxA+bm5tiyZQu6du2K3377Dd26dVMZs5+fH3766SdMnDgR1atXx+TJkwEUXARMT0/H999/jz59+mDEiBF4/vw51q1bh5CQEPzvf//Teveejz/+GA4ODvj888+RmZkJAPjpp58waNAghISEYNGiRXjx4gXWrFmDli1bIiYmRl709ejRA1euXMHYsWPh6emJpKQk7Nu3DwkJCaW6+TBx4kQ0adIEffv2lS+TSqX46KOP0LVrV3Tq1KlMr2nOnDmIiIhA+/btMXr0aNy4cQNr1qzB6dOncfz4cYVWZykpKQgNDUX37t3Rs2dPbNu2DdOnT0fdunURFhYGoOBOdNu2bfHo0SOMHz8ezs7O2LRpk8qLI//++y/CwsLQqFEjzJ49G2KxGOvXr0fbtm1x9OhRNG3aVGH9Dz/8EDVr1sSCBQsgCILK19O9e3fY2Nhg4sSJ6NOnDzp27Cg/11+5cgWtWrWClZUVpk2bBmNjY3z77bcIDg7G4cOH0axZsyLztG7dOnz00Udo3rw5JkyYgDt37qBLly6ws7ODm5tbiXnOz89HSEgImjVrhiVLlmD//v1YunQpfHx8MHr0aAAFv8/OnTvjf//7H0aPHg1fX1/88ccfGDRoUIn7b926NcaNG4cVK1bgk08+gZ+fHwDI/y1KZGQkzMzMMGPGDNy+fRsrV66EsbExxGIxUlJSMGfOHJw6dQrR0dHw8vJSaMVWmu+jOTk5CAkJQXZ2NsaOHQtnZ2c8ePAAf/31F1JTU2FtbV3ia6NCBDJIqampAgDh/fffL3a9Ll26CACE9PR0heWzZ88WPDw8VG7j4eEhACjxZ/bs2fJtwsPDBSMjI5X7c3BwEHr37l3ia1q1apVgbW0tJCUlCYIgCEFBQUKdOnUU1tm6dasAQDhy5IjS9h9++KHg7OyssAyAEBQUVOKxO3fuLFStWlV48OCBfNmtW7eEKlWqCIX/zOLj4wUjIyNh/vz5CttfunRJqFKlinx5Tk6O4OjoKPj7+wsvX76Ur/fXX38JAITPP/9cvmzQoEECAGHBggXyZSkpKYKZmZkgEomEX3/9Vb78+vXrSrn/4osvBHNzc+HmzZsKMc2YMUMwMjISEhISBEEQhOTkZKVtX49hxowZKp8r/F75999/BQDCuHHjlNaVSqVKywrr1KmTyvfdTz/9JIjFYuHo0aMKy6OiogQAwvHjxwVBEISvvvpKACAkJycXeYzTp08LAIT169cXG4vM7NmzBQBCly5dFJZ//PHHAgDhwoULpdq+pJ+i/t4KMzc3F4YOHaq0fNeuXQIAYc+ePcVuL5VKhaZNmwp9+vQRBEEQ4uLiBADCl19+Wex2ly9fFgAI06ZNU3ru8ePHQrt27RRei729vXDixIkSXw+RoZJ9LowcOVK+LC8vT6hevbogEomEhQsXypfLPu8HDRokX7Z8+XIBgPDzzz/Ll+Xk5AiBgYGChYWF/Jwu+xu3srKSnztl2rVrJ9StW1fIysqSL5NKpULz5s2FmjVrlvgaPDw8hE6dOiksy8vLE7KzsxWWpaSkCE5OTkqfXa+fb9avXy8AEOLi4opcp/CxC+dDtm3Lli2FvLw8+fLnz58LNjY2wogRIxS2T0xMFKytreXLU1JSSvVZWJRJkyYJAISoqCiF5bm5uUK3bt0EiUQi7N27t8T9vJ6DpKQkwcTEROjQoYOQn58vX2/VqlUCAOGHH36QLwsKChIACD/++KN8WXZ2tuDs7Cz06NFDvmzp0qUCAOH333+XL3v58qXg6+srABAOHjwoCELBe6FmzZpCSEiIwrn7xYsXgpeXl/Duu+/Kl8nez7JzS0mKOvd07dpVMDExEWJjY+XLHj58KFhaWgqtW7eWLzt48KBCrLLvVA0aNFB4/61du1bpe57s2IW/A8i+48ydO1chnoCAAKFRo0byx7/99psAQFi+fLl8WX5+vtC2bdtSfa+QfUeVxV1YUFCQQpyy1+jv7y/k5OTIl/fp00cQiURCWFiYwvaBgYEK3yNK+300JiZGACBs3bq12NipdNjU3EA9f/4cAGBpaVnserLnZeuXxsaNG7Fv374SfwYOHCjf5uXLl0X2XzE1NcXLly+LPebTp0/x+eefY9asWSrvMhc+DgBIJJJSHUcQhBLvdufn52P//v3o2rUrXF1d5ctr1Kghv4Iss337dkilUvTs2RNPnjyR/zg7O6NmzZryK8pnzpxBUlISPv74Y4W+Rp06dYKvr6/KpvfDhw+X/9/Gxga1atWCubk5evbsKV9eq1Yt2NjY4M6dO/JlW7duRatWrWBra6sQU/v27ZGfn48jR44U+/oLk131Lc5vv/0GkUikcsAdde6wFrZ161b4+fnB19dX4TW0bdsWAOR5lbUS+OOPPzQ24JtMeHi4wuOxY8cCAP7+++9itxs4cGCp/l42btxYYgwvX74s8r0te7440dHRuHTpEhYtWlTisQqTxfZ6M3OgoGVLrVq1MGjQIGzduhU//PADXFxc0L17d9y+fVut4xAZmsKf60ZGRmjcuDEEQcCwYcPky2Wf94U/1//++284OzujT58+8mXGxsbyGTwOHz6scJwePXoonDufPXuGf//9Fz179sTz58/ln6lPnz5FSEgIbt26pdTtqTSMjIzk53qpVIpnz57JW6GVZfYFdY0YMQJGRkbyx/v27UNqair69OmjcO4wMjJCs2bN5OcOMzMzmJiY4NChQ0hJSVHrmDNmzMCyZcuwePFiDBo0CFlZWfKfvLw8bNiwAUFBQejatavKu8rF2b9/P3JycjBhwgSFlk4jRoyAlZWV0ncFCwsLhdaDJiYmaNq0qcJ7Z8+ePXjrrbfQpUsX+TJTU1OMGDFCYV/nz5/HrVu30LdvXzx9+lSeu8zMTLRr1w5HjhxROs+OGjVKrddXWH5+Pv755x907doV3t7e8uUuLi7o27cvjh07hvT0dJXbyr5TjRo1SuG75uDBg9W6Y/t6/K1atVLKnbGxsUKuxGKx0vcDTRo4cKBCq4ZmzZpBEAQMHTpUYb1mzZrh3r17yMvLA1D676Oy/Ozdu7dUrfOoeGxqbqBKW1A/f/4cIpEI9vb2pd53ixYt1I7HzMwMOTk5Kp/LysoqsS/oZ599Bjs7O3mxU9xxAKjs51Ka46iSlJSEly9fqhzl+fVlt27dgiAIRY4uLfvwvHv3LoCCQvl1vr6+OHbsmMIyWT/pwqytrVG9enWlYtba2lrhi8OtW7dw8eLFIi9YJCUlqVz+uipVqij0mStKbGwsXF1dYWdnV6r9lsatW7dw7dq1El9Dr1698P3332P48OGYMWMG2rVrh+7du+ODDz5Qap6trtd/pz4+PhCLxSX2//P29lb4EvEmzMzMinxvy54vSnp6OmbOnImpU6eWqtmdjCAI2LRpE/z9/ZUGXAMKmhZWqVIFf/75p3zZ+++/j5o1a+LTTz/F5s2bS30sIkPj7u6u8Nja2hqmpqZK52Rra2s8ffpU/vju3buoWbOm0uearNmq7Bwj8/oAqrdv34YgCJg1axZmzZqlMrakpCS89dZb6r0gABs2bMDSpUtx/fp15ObmFhmDNrx+jFu3bgGA/CLt62RjwUgkEixatAiTJ0+Gk5MT3nnnHbz33nsYOHAgnJ2dizzevn375Bcyp02bhmnTphUbX+fOndWa2rSo7womJibw9vZW+j2r+k5ga2uLixcvKuzTx8dHaT1V32cAFNuMOi0tTaGL1Jv8jpOTk/HixQuV34v8/PwglUpx79491KlTR+l5WR5eP08bGxuX+vyr6nuWra2twvepu3fvwsXFRamrnarvh5qi6jMCgNJ53NraGlKpFGlpaahWrVqpv496eXlh0qRJWLZsGTZu3IhWrVqhS5cu8rEnSD0svA2UtbU1XF1dFT5sVbl48SKqV68OExMThb6oL168gFQqlY8aXrj/aXJycqn6eFtYWMj77bi4uCA/Px9JSUlwdHSUr5OTk4OnT58q3El+3a1bt7B27VosX74cDx8+lC/PyspCbm4u4uPjYWVlBTs7O7i4uAAAHj16pLSfR48eFXscTZBKpRCJRNi9e7fCVXeZwn3l1aFqX8UtFwr1rZJKpXj33XeL/ELw9ttvlyoGiUTyxsVrWUmlUtStWxfLli1T+bzsBGRmZoYjR47g4MGD2LVrF/bs2YPNmzejbdu2+Oeff4rMV1mU9u59RkZGqb5oGRkZFduaAyj4OyrqvQ2g2Pf3kiVLkJOTg169eskvFty/fx9AQb/A+Ph4uLq6KrVMOX78OO7evYvIyEilfd65cwd79uzB2rVrFZbb2dmhZcuWSgPwEJEiVZ9JpflcV9frF+VkdyqnTJmCkJAQlduUpZj4+eefMXjwYHTt2hVTp06Fo6MjjIyMEBkZidjYWPUDL0JR30GKep0//fSTygK68HRmEyZMQOfOnfH7779j7969mDVrFiIjI/Hvv/8iICBA5fGaNGmChg0b4ty5c5gyZYrKohAoaDW0f/9+jBw5slSvr6w0+d6R5e7LL78ssm/+699pKvKAmpr8fqBJZf3+p8730aVLl2Lw4MH4448/8M8//2DcuHHy8WxKc8OFXmHhbcA6d+6Mb7/9FseOHVM5uuTRo0cRHx+PSZMmAQAWL14sn8dZRlYIeHh4yL+sN2nSROkqqyqzZ8+Wj0Yq+9A+c+YMOnbsKF/nzJkzkEqlxQ648uDBA0ilUowbNw7jxo1Tet7Lywvjx4/H8uXL4e/vjypVquDMmTMKTbBzcnJw/vx5hWWl5ejoCFNTU5XNZl9f5uPjA0EQ4OXlVWxBKxvR88aNG0pX4m/cuCF/XhN8fHyQkZGB9u3bF7teWZuBqzre3r178ezZM7XvehcVg4+PDy5cuIB27dqVGKdYLEa7du3Qrl07LFu2DAsWLMCnn36KgwcPon379mV+nbdu3VK4mn/79m1IpdISB91ZsmSJ0t+VKoX/xorSoEEDHD16FFKpVOEiyH///YeqVasW+55LSEhASkqKyi+GCxYswIIFCxATE6P0t7hx40aIRCKFAYNkHj9+DED1l+Dc3Fx5kzci0iwPDw9cvHhR6bPg+vXr8ueLI7sLaGxsXOK5QR3btm2Dt7c3tm/frvBZW9a5vm1tbZVG787JyVF5AVIVHx8fAAXn8dK8Th8fH0yePBmTJ0/GrVu30KBBAyxduhQ///yzyvVtbGywb98+tG3bFj/99BMOHz6sdMd2w4YNOHDgAMaMGVPkxeOiFP6uUPjObU5ODuLi4sr0u/Pw8MDVq1chCILC70jV9xmgoFWAJt8jRXFwcEDVqlVx48YNpeeuX78OsVhcZGstWZ5u3bql8J0qNzcXcXFxqF+/vkZi9PDwwMGDB/HixQuFu96l7Valqe9ZpVHa76MydevWRd26dfHZZ5/hxIkTaNGiBaKiojBv3rxyiLbyYB9vAzZlyhRUrVoVH330kUITNaCgf9eoUaNgZWWFMWPGAFDsizpgwAA4OTmp7H9alj7ebdu2hZ2dHdasWaMQx5o1a1C1alWF0T6fPHmC69evy++++/v7Y8eOHUo/derUgbu7O3bs2CHvD2dtbY327dvj559/Vmhm/9NPPyEjI0M+lYNMaaYTMzIyQvv27fH7778r3HG/ffs2du/erbBu9+7dYWRkhIiICKUrzIIgyH8PjRs3hqOjI6KiohSaDu/evRvXrl0r8+inqvTs2RMnT57E3r17lZ5LTU2VF0eyk8jrX3LU1aNHDwiCoLLYLOmqu7m5ucrpK3r27IkHDx7gu+++U3ru5cuX8tFrnz17pvS8rJCU5Vk2r6i6r1M2fZvMypUrAUCpn//rNNnH+4MPPsDjx4+xfft2+bInT55g69at6Ny5s0L/79jYWIU7TOPGjVP6G/r2228BFPSD27Fjh1IzwdzcXGzduhUtW7ZUau4GFNwRE4vF2Lx5s8Lv9v79+zh69GiRd4mI6M107NgRiYmJCl058vLysHLlSlhYWCAoKKjY7R0dHREcHIxvv/1WZRErm2dZXbI7a4U/D/777z+cPHmyTPvz8fFRGodk7dq1pWp1BwAhISGwsrLCggULFJq9y8he54sXL5Smh/Tx8YGlpWWJ0zTa2dlh//79sLe3l58XZHJycjBv3jyMGDECK1asKFXMhbVv3x4mJiZYsWKFQk7XrVuHtLS0Mn1XCAkJwYMHDxSmjcvKylI6vzZq1Ag+Pj5YsmSJylZbZX2PFMXIyAgdOnTAH3/8oXAR+vHjx9i0aRNatmypME1sYY0bN4aDgwOioqIUujVGR0e/8XeawkJCQpCbm6uQK6lUqvT9oChl/f5RFqX9Ppqenq50kbxu3boQi8WlnqKUXuEdbwNWo0YN/Pjjj+jTpw/q1q2LYcOGwcvLC/Hx8Vi3bh1SUlLw66+/yr9sF+6LeuzYMZiamqq8ylnWPt5ffPEFwsPD8eGHHyIkJARHjx7Fzz//jPnz5yvcGV21ahUiIiJw8OBBBAcHw97eHl27dlXap2wu79efmz9/Ppo3b46goCCMHDkS9+/fx9KlS9GhQweEhoYqrFva6cTmzJmDf/75By1atMDo0aORn5+PVatWwd/fH+fPn5ev5+Pjg3nz5mHmzJmIj49H165dYWlpibi4OOzYsQMjR47ElClTYGxsjEWLFmHIkCEICgpCnz595NOJeXp6YuLEieqkt1hTp07Fzp078d5772Hw4MFo1KgRMjMzcenSJWzbtg3x8fGwt7eHmZkZateujc2bN+Ptt9+GnZ0d/P394e/vr9bx2rRpgwEDBmDFihW4desWQkNDIZVKcfToUbRp00Z+oUeVRo0aYfPmzZg0aRKaNGkCCwsLdO7cGQMGDMCWLVswatQoHDx4EC1atEB+fj6uX7+OLVu2YO/evWjcuDHmzp2LI0eOoFOnTvDw8EBSUhJWr16N6tWry1t9+Pj4wMbGBlFRUbC0tIS5uTmaNWtWYt+0uLg4dOnSBaGhoTh58iR+/vln9O3bt8Qr6Zrs4/3BBx/gnXfewZAhQ3D16lXY29tj9erVyM/PV7rQ0a5dOwCQf4Fp2LAhGjZsqLCO7Lk6deqo/Bvbu3cvnj59qnJQNaDgDsXQoUPx/fffy/vTP3/+HKtXr8bLly8xc+bMN3vBRKTSyJEj8e2332Lw4ME4e/YsPD09sW3bNhw/fhzLly8vcWBVoOBiYsuWLVG3bl2MGDEC3t7eePz4MU6ePIn79+/jwoULasf13nvvYfv27ejWrRs6deqEuLg4REVFoXbt2mr1bZYZPnw4Ro0ahR49euDdd9/FhQsXsHfv3lKPS2NlZYU1a9ZgwIABaNiwIXr37g0HBwckJCRg165daNGiBVatWoWbN2+iXbt26NmzJ2rXro0qVapgx44dePz4MXr37l3icezt7XH48GGlPrEmJiY4fvw4HBwcynS308HBATNnzkRERARCQ0PRpUsX3LhxA6tXr0aTJk1KnIZVlY8++girVq1Cnz59MH78eLi4uGDjxo3yQTplcYrFYnz//fcICwtDnTp1MGTIELz11lt48OABDh48CCsrK4WxPTRh3rx52LdvH1q2bImPP/4YVapUwbfffovs7GyV85HLGBsbY968efjoo4/Qtm1b9OrVC3FxcVi/fr3Gzr9AwffNpk2bYvLkybh9+zZ8fX2xc+dO+UX/kn7HDRo0gJGRERYtWoS0tDRIJBK0bdtWoQumppT2++i///6LMWPG4MMPP8Tbb7+NvLw8/PTTTzAyMkKPHj00HlelV44jqJOeunTpktC3b1/B2dlZEIvFAgDB1NRUuHLlSpHbFDed2JtYu3atUKtWLcHExETw8fERvvrqK6UppmTTUqiabqEwVdOJyRw9elRo3ry5YGpqKjg4OAjh4eFKU6YJQumnExMEQThw4IAQEBAgj/37778XJk+eLJiamiqt+9tvvwktW7YUzM3NBXNzc8HX11cIDw8Xbty4obDe5s2bhYCAAEEikQh2dnZCv379hPv37yusM2jQIMHc3LzUr1/VFC/Pnz8XZs6cKdSoUUMwMTER7O3thebNmwtLlixRmKbixIkTQqNGjQQTExOFaVyKikH23Ovvlby8POHLL78UfH19BRMTE8HBwUEICwsTzp49q3IfMhkZGULfvn0FGxsbpSm2cnJyhEWLFgl16tQRJBKJYGtrKzRq1EiIiIgQ0tLSBEEo+B29//77gqurq2BiYiK4uroKffr0UZpK7Y8//hBq164tnw6uuClAZO/Hq1evCh988IFgaWkp2NraCmPGjFGYCq68PHv2TBg2bJhQrVo1oWrVqkJQUJBw+vRppfU8PDxK/BsuaTqx3r17C8bGxsLTp0+L3Edubq6wcuVKoUGDBoKFhYVgYWEhtGnTRvj333/Vel1EhkT2ufL61IfqfN4/fvxYGDJkiGBvby+YmJgIdevWVfosK+lvPDY2Vhg4cKDg7OwsGBsbC2+99Zbw3nvvCdu2bSvxNag610ilUmHBggWCh4eHIJFIhICAAOGvv/5SeZ4ofI4RBNXTieXn5wvTp08X7O3thapVqwohISHC7du3i5xOTNVnoSAUTM0UEhIiWFtbC6ampoKPj48wePBg4cyZM4IgCMKTJ0+E8PBwwdfXVzA3Nxesra2FZs2aCVu2bCkxD5qkKgeCUDB9mK+vr2BsbCw4OTkJo0ePFlJSUhTWKeo7garc37lzR+jUqZNgZmYmODg4CJMnT5ZPlXXq1CmFdWNiYoTu3bsL1apVEyQSieDh4SH07NlTOHDggHydot7PRSnufXnu3DkhJCREsLCwEKpWrSq0adNGaXrK16cTk1m9erXg5eUlSCQSoXHjxsKRI0eUpukqajoxVX93stdVWHJystC3b1/B0tJSsLa2FgYPHiwcP35cAKAwvWtRvvvuO8Hb21swMjJSeA1FTSf2+jRfRb3Xi/odlPR99M6dO8LQoUMFHx8fwdTUVLCzsxPatGkj7N+/v8TXQspEgvAGo3FQpfTjjz9i8ODB6N+/P3788UeV66xYsQLbt28v8U6woevatSuuXLkiH/2TKp85c+YgIiICycnJao3+T0REVFEsX74cEydOxP3798s0mr0h+/3339GtWzccO3asTK1CqfJgH29SMnDgQERGRuKnn37CJ598onKdcePGseh+zetzJN+6dQt///03goODdRMQERERkZpe/z6TlZWFb7/9FjVr1mTRXYLXc5efn4+VK1fCyspKqTsXGR728SaVpk+fjunTp+s6jArF29sbgwcPls+duWbNGpiYmJQ4bycRERGRvujevTvc3d3RoEEDpKWl4eeff8b169dLNcinoRs7dixevnyJwMBAZGdnY/v27Thx4gQWLFhQoadTI81g4U2kIaGhofjll1+QmJgIiUSCwMBALFiwADVr1tR1aERERESlEhISgu+//x4bN25Efn4+ateujV9//RW9evXSdWh6r23btli6dCn++usvZGVloUaNGli5cmWxA8eS4WAfbyIiIiIiIiItYh9vIiIiIiIiIi2q9E3NpVIpHj58CEtLyzLNkUhERFTeBEHA8+fP4erqCrHYMK6R83xNREQVjTrn60pfeD98+BBubm66DoOIiEht9+7dQ/Xq1XUdRrng+ZqIiCqq0pyvdVp4r1mzBmvWrEF8fDwAoE6dOvj8888RFhYGoGD6gsmTJ+PXX39FdnY2QkJCsHr1ajg5OZX6GJaWlgAKkmFlZaXx11AaUqkUycnJcHBwMJg7F6owDwWYh1eYiwLMQwHm4ZX09HS4ubnJz2GGoDzO13yPKWNOVGNelDEnypgT1QwpL+qcr3VaeFevXh0LFy5EzZo1IQgCNmzYgPfffx8xMTGoU6cOJk6ciF27dmHr1q2wtrbGmDFj0L17dxw/frzUx5A1V7OystJp4Z2VlQUrK6tK/+YrDvNQgHl4hbkowDwUYB6U6UuT68jISGzfvh3Xr1+HmZkZmjdvjkWLFqFWrVrydYKDg3H48GGF7T766CNERUWV6hjlcb7me0wZc6Ia86KMOVHGnKhmiHkpzflap4V3586dFR7Pnz8fa9aswalTp1C9enWsW7cOmzZtQtu2bQEA69evh5+fH06dOoV33nlHFyETEREZnMOHDyM8PBxNmjRBXl4ePvnkE3To0AFXr16Fubm5fL0RI0Zg7ty58sdVq1bVRbhERER6R2/6eOfn52Pr1q3IzMxEYGAgzp49i9zcXLRv316+jq+vL9zd3XHy5MkiC+/s7GxkZ2fLH6enpwMouPIilUq1+yKKIJVKIQiCzo6vL5iHAszDK8xFAeahAPPwir7lYM+ePQqPo6Oj4ejoiLNnz6J169by5VWrVoWzs3N5h0dERKT3dF54X7p0CYGBgcjKyoKFhQV27NiB2rVr4/z58zAxMYGNjY3C+k5OTkhMTCxyf5GRkYiIiFBanpycjKysLE2HXypSqRRpaWkQBMFgmluowjwUYB5eYS4KMA8FmIdXnj9/rusQipWWlgYAsLOzU1i+ceNG/Pzzz3B2dkbnzp0xa9asIu966+JCOS/uKGNOVGNelDEnypgT1QwpL+q8Rp0X3rVq1cL58+eRlpaGbdu2YdCgQUp9xNQxc+ZMTJo0Sf5Y1uHdwcFBp328RSKRQQwwUBzmoQDz8Iq6ucjPz0dubm45RFa+pFIp8vLyDKovlCqGlAdjY2MYGRkV+bypqWk5RqMeqVSKCRMmoEWLFvD395cv79u3Lzw8PODq6oqLFy9i+vTpuHHjBrZv365yP7q4UM6LO8qYE9WYF2XMiTLmRDVDyos6F8p1XnibmJigRo0aAIBGjRrh9OnT+Prrr9GrVy/k5OQgNTVV4a7348ePi23GJpFIIJFIlJaLxWKd/uJFIpHOY9AHzEMB5uGV0uRCEAQkJiYiNTW1/AIrR7KrwhkZGXozmJYuGFoebGxs4OzsrPK16vNnQ3h4OC5fvoxjx44pLB85cqT8/3Xr1oWLiwvatWuH2NhY+Pj4KO1HFxfKeeFTGXOiGvOijDlRxpyoZkh5UedCuc4L79dJpVJkZ2ejUaNGMDY2xoEDB9CjRw8AwI0bN5CQkIDAwEAdR0lE5UlWdDs6OqJq1aqVrigTBAF5eXmoUqVKpXtt6jCUPAiCgBcvXiApKQkA4OLiouOISm/MmDH466+/cOTIkRLnK23WrBkA4Pbt2yoLb11dKOeFT2XMiWrMizLmRFnhnMQkpCDuSSa87M0R4G6r69B0ylDeK+q8Pp0W3jNnzkRYWBjc3d3x/PlzbNq0CYcOHcLevXthbW2NYcOGYdKkSbCzs4OVlRXGjh2LwMBAjmhOZEDy8/PlRXe1atV0HY5WGErBWRJDyoOZmRkAICkpCY6OjsU2O9cHgiBg7Nix2LFjBw4dOgQvL68Stzl//jyAinVhgYiorBbuvoaow3fkj0cFeWNGmJ8OIyJ9o9PCOykpCQMHDsSjR49gbW2NevXqYe/evXj33XcBAF999RXEYjF69OiB7OxshISEYPXq1boMmYjKmaxPN6clospG9p7Ozc3V+8I7PDwcmzZtwh9//AFLS0v5IKfW1tYwMzNDbGwsNm3ahI4dO6JatWq4ePEiJk6ciNatW6NevXo6jp6ISLvO30tVKLoBIOrwHYTUcTb4O9/0ik4L73Xr1hX7vKmpKb755ht888035RQREemryn4HlAxPRXpPr1mzBgAQHByssHz9+vUYPHgwTExMsH//fixfvhyZmZlwc3NDjx498Nlnn+kgWiKi8hX/JFPl8rgnmSy8SU7v+nhXWpt6AekXAagxrP6cNK2FQ0REVFqCIBT7vJub2xvNSEJEVJF52purXO5VxHIyTJW7tzsREREREZEWNXCzwaggb4Vlo4O8ebebFPCONxFVSJ4zdpXr8eIXdtLo/g4dOoQ2bdogJSUF1tbWGt23LhR+PYWngCQiIjIEM8L8EFLHmaOaU5FYeBMREREREb2hAHdbFtxUJDY1JyIyEDk5OboOgYiIiMggsfAmItKS7OxsjBs3Do6OjjA1NUXLli1x+vRphXWOHz+O+vXrw9LSEoGBgbh8+bL8ubt376Jz586wtbWFubk56tSpg7///lv+/OXLlxEWFgYLCws4OTlhwIABePLkifz54OBgjBkzBhMmTIC9vT1CQkLQt29f9OrVSyGG3Nxc2Nvb48cffwQASKVSREZGwsvLC2ZmZqhfvz62bdumsM3ff/+Nt99+G2ZmZmjTpg3i4+M1lTYiIiKiSoeFNxGRlkybNg2//fYbNmzYgHPnzqFGjRoICQnBs2fP5OtMnToVS5YswYkTJ+Dg4IDOnTvL5y4PDw9HdnY2jhw5gkuXLmHRokWwsLAAAKSmpqJt27YICAjAmTNnsGfPHjx+/Bg9e/ZUiGHDhg0wMTHB8ePHERUVhX79+uHPP/9ERkaGfJ29e/fixYsX6NatGwAgMjISP/74I6KionDlyhVMnDgR/fv3l49afe/ePXTv3h2dO3fG+fPnMXz4cMyYMUOruSQiKk/n76XiROwTnL+XqutQiKiSYB9vIiItyMzMxJo1axAdHY2wsDAAwHfffYd9+/Zh3bp1aNKkCQBg9uzZePfdd5GXl4fo6Gi4ublhx44d6NmzJxISEtCjRw/UrVsXAODt/WrE1FWrViEgIAALFiyQL/vhhx/g5uaGmzdv4u233wYA1KxZE4sXL5av4+PjA3Nzc+zYsQMDBgwAAGzatAldunSBpaUlsrOzsWDBAuzfvx+BgYHy4x47dgzffvstgoKCsGbNGvj4+GDp0qUAgFq1askvDBARVXQLd1/D2sOx8LMVcC0lHiODfDAjzE/XYRFRBcc73kREWhAbG4vc3Fy0aNFCvszY2BhNmzbFtWvX5MtkxS0A2NnZoVatWvLnx40bh3nz5qFFixaYPXs2Ll68KF/3woULOHjwICwsLOQ/vr6+8mPLNGrUSCGuKlWqoGfPnti4cSOAggsEf/zxB/r16wcAuH37Nl68eIF3331XYd8//vijfL/Xrl1Ds2bNFPZb+HUQEVVUMQkpiDp8R2FZ1OE7iElI0VFERFRZ8I43EZGeGj58OEJCQrBr1y78888/iIyMxNKlSzF27FhkZGSgc+fOKu8yu7i4yP9vbm6u9Hy/fv0QFBSEpKQk7Nu3D2ZmZggNDQUAeRP0Xbt24a233lLYTiKRaPLlERHpnbgnmUUu52jVRPQmeMebiEgLfHx85H2rZXJzc3H69GnUrl1bvuzUqVPy/6ekpODmzZvw83vVpNHNzQ2jRo3C9u3bMXnyZHz33XcAgIYNG+LKlSvw9PREjRo1FH5UFduFNW/eHG5ubti8eTM2btyIDz/8EMbGxgCA2rVrQyKRICEhQWm/bm5uAAA/Pz/873//U9hn4ddBRFRRedmr/vwsajkRUWmx8CYi0gJzc3OMHj0aU6dOxZ49e3D16lWMGDECL168wLBhw+TrzZ07FwcOHMDly5cxZMgQ2Nvbo2vXrgCACRMmYO/evYiLi8O5c+dw8OBBeVEeHh6OZ8+eoU+fPjh9+jRiY2Oxd+9eDBkyBPn5+SXG17dvX0RFRWHfvn3yZuYAYGlpiSlTpmDixInYsGEDYmNjce7cOaxcuRIbNmwAAIwaNQq3bt3C1KlTcePGDWzatAnR0dGaSx4RkY4EuNtiVJC3wrLRQd68201Eb4xNzYmoQopf2EnXIZRo4cKFkEqlGDBgAJ4/f47GjRtj7969sLW1VVhnwoQJuHXrFho0aIA///wTJiYmAID8/HyEh4fj/v37sLKyQmhoKL766isAgKurK44fP47p06ejQ4cOyM7OhoeHB0JDQyEWl3xNtV+/fpg/fz48PDwU+qEDwBdffAEHBwdERkbizp07sLGxQcOGDfHJJ58AANzd3fHbb79h4sSJWLlyJZo2bYoFCxZg6NChmkodEZHOzAjzQ4faToi//xCe1V3R0MNO1yERUSUgEgRB0HUQ2pSeng5ra2ukpaXByspKJzFIpVIkLW8Dx/SLEENa+g3npGkvKB2QSqVISkqCo6NjqQqDyop5eKU0ucjKykJcXBy8vLxgampazhGWD0EQkJeXhypVqkAkEuk6HJ0xtDwU997Wh3NXeSuP18zPX2XMiWrMizLmRBlzopoh5UWdc1flzgQRERERERGRjrHwJiIiIiIiItIiFt5EREREREREWsTCm4iIiIiIiEiLWHgTERERERERaRGnEyMiIiIiIlJDTEIK4pIz4GSSDUdHR12HQxUAC28iIiIiIqJSWrj7GqIO34EYAvxsBbS6l4MZHWvrOiwqQkxCCuKeZMLL3hwB7rY6i4OFNxERERERUSnEJKQg6vAdhWVrj9xBiL+LTos6Uk12kURmVJA3ZoT56SQW9vEmIiIiIiIqhbgnmWotJ91RdZEk6vAdxCSk6CQe3vEmooppjnU5Hy+tfI9XgQwePBipqan4/fffS73NunXrsHnzZvzzzz/aC0xH9uzZgxkzZuDcuXMQi3l9m4ioMvGyN1drOelOcRdJdNE6gd8IiIhIiaenJ5YvX16qdb/++mtER0eXet9ZWVmYNWsWZs+eXbbgSunZs2fo168frKysYGNjg2HDhiEjI6PY9ceOHYtatWrBzMwM7u7uGDduHNLSFC+6HDhwAM2bN4elpSWcnZ0xffp05OXlyZ8PDQ2FsbExNm7cqLXXRkREuhHgbotRQd4Kyz5q7c1m5npI3y6SsPAmIqIyyc/Ph1QqhbW1NWxsbEq93bZt22BlZYUWLVpoLzgA/fr1w5UrV7Bv3z789ddfOHLkCEaOHFnk+g8fPsTDhw+xZMkSXL58GdHR0dizZw+GDRsmX+fChQvo2LEjQkNDERMTg82bN2Pnzp2YMWOGwr4GDx6MFStWaO21ERGR7swI88OOj5tjyYf18UlHP0wN9dV1SKSCqosko4N0d5GEhTcRkZY8f/4c/fr1g7m5OVxcXPDVV18hODgYEyZMAABkZ2djypQpqF69OmxsbPDOO+/g0KFDCvv47bffUKdOHUgkEnh6emLp0qUKz3t6emLevHkYOHAgLCws4OHhgZ07dyI5ORnvv/8+LCwsUK9ePZw5c0Zhu2PHjqFVq1YwMzODm5sbxo0bh8zMgiZZwcHBuHv3LiZOnAiRSASRSAQAiI6Oho2NDXbu3InatWtDIpEgISEBgwcPRteuXeX7lkqlWLx4MWrUqAGJRAJ3d3fMnz9f/vyvv/6Kzp07K8QzePBgdOvWDV988QUcHR1hZWWFUaNGIScnp0y5v3btGvbs2YPvv/8ezZo1Q8uWLbFy5Ur8+uuvePjwocpt/P398dtvv6Fz587w8fFB27ZtMX/+fPz555/yO9qbN29GvXr18Pnnn6NGjRoICgrC4sWL8c033+D58+fyfXXu3BlnzpxBbGxsmeInIiL9FuBui64Bb8HHwULXoVAxZBdJlvWsjx0fN8d0HQ2sBrDwJiLSmkmTJuH48ePYuXMn9u3bh6NHj+LcuXPy58eMGYOTJ0/il19+wdmzZ/HBBx8gNDQUt27dAgCcPXsWPXv2RO/evXHp0iXMmTMHs2bNUmrW/dVXX6FFixaIiYlBp06dMGDAAAwcOBD9+/fHuXPn4OPjg4EDB0IQBABAbGwsQkND0aNHD1y8eBGbN2/GsWPHMGbMGADA9u3bUb16dcydOxePHj3Co0eP5Md68eIFFi1ahO+//x5XrlxROXfpzJkzsXDhQsyaNQtXr17Fpk2b4OTkJH/+2LFjaNy4sdJ2Bw4cwPXr13Hw4EH88ssv2L59OyIiIuTPL1iwABYWFsX+JCQkAABOnjwJGxsbheO0b98eYrEY//33X6l/h2lpabCyskKVKgVDomRnZ8PU1FRhHTMzM2RlZeHs2bPyZe7u7nBycsLRo0dLfSwiIiLSvAB3W3RvWF3n3QE4uBoRkRY8f/4cGzZswKZNm9CuXTsAwPr16+Hq6goASEhIwPr165GQkAAXFxfk5eVhypQp2Lt3L9avX48FCxZg2bJlaNeuHWbNmgUAePvtt3H16lV8+eWXGDx4sPxYHTt2xEcffQQA+Pzzz7FmzRo0adIEH374IQBg+vTpCAwMxOPHj+Hs7IzIyEj069dPfue9Zs2aWLFiBYKCgrBmzRrY2dnByMhI3oe5sNzcXKxevRr169cv8nV//fXXWLVqFQYNGgQA8PHxQcuWLQEAqampSEtLk+ehMBMTE3z33XewsrKCv78/5s6di6lTp+KLL76AWCzGqFGj0LNnz2LzLttvYmKi0kWBKlWqwM7ODomJicXuQ+bJkyf44osvFJqnh4SEYPny5fjll1/Qs2dPJCYmYu7cuQCgcIFCFsvdu3dLdSwiIiKq3HR6xzsyMhJNmjSBpaUlHB0d0bVrV9y4cUNhneDgYHlTR9nPqFGjdBQxEVHp3LlzB7m5uWjatKl8mbW1NWrVqgUAuHTpEvLz8/H222/D0tIStra2sLS0xOHDh+XNk69du6bUD7pFixa4desW8vPz5cvq1asn/7/sznLdunWVliUlJQEo6KccHR2tcKc4JCQEUqkUcXFxxb4uExMTheO97tq1a8jOzpZfbHjdy5cvAUDprjEA1K9fH1WrVpU/DgwMREZGBu7duwcAsLOzQ40aNYr9kd2ZflPp6eno1KkTateujTlz5siXd+jQAV9++SVGjRoFiUSCt99+Gx07dgQApRHMzczM8OLFC43EQ0RERBWbTu94Hz58GOHh4WjSpAny8vLwySefoEOHDrh69SrMzV+NNjdixAj5HQUACl/MiIgqooyMDBgZGeHs2bMQi8XIy8tDlSpVIBKJYGGhXn8xY2Nj+f9l/bFVLZNKpfJjf/TRRxg3bpzSvtzd3Ys9lpmZmXx/RT1fnGrVqkEkEiElRf05NBcsWIAFCxYUu87Vq1fh7u4OZ2dn+YUGmby8PDx79kzpLv7rnj9/jtDQUFhaWmLHjh0KuQQKuhBMnDgRjx49gq2tLeLj4zFz5kx4eysO4PLs2TM4ODio8QqJiIiostJp4b1nzx6Fx9HR0XB0dMTZs2fRunVr+fKqVauW+EWJiEifeHt7w9jYGKdPn5YXs2lpabh58yZat26NgIAA5OfnIykpCS1btlQovGX8/Pxw/Phxhf0eP34cb7/9NoyMjMocW8OGDXH16lXUqFGjyHVMTEwU7qqXVs2aNWFmZoYDBw5g+PDhKvdbu3ZtXL16FR06dFB47sKFC3j58iUsLS0BAKdOnYKFhQXc3NwAQK2m5oGBgUhNTcXZs2fRqFEjAMC///4LqVSKZs2aFbl9eno6QkJCIJFIsHPnTpV35oGCixmyY/3yyy9wc3NDw4YN5c9nZWUhNjYWAQEBxcZLREREhkGv+njL5kq1s7NTWL5x40b8/PPPcHZ2RufOnTFr1qwi73pnZ2cjOztb/jg9PR1AwZ0e2d2e8iaVSiFABKm6Lft1FK+2SKVSCIKgs9+DvmAeXilNLmTryH5kir7nqh2Fj10aFhYWGDhwIKZOnQpbW1s4Ojpizpw58ubINWvWRL9+/TBw4EAsWbIE/v7+SE1NxYEDB1CvXj106tQJkyZNQtOmTTF37lz06tULJ0+exKpVq/DNN98oxPN6bl5fVvhfQRAwbdo0BAYGIjw8HMOHD4e5uTmuXr2Kffv2YdWqVQAKRks/cuQIevXqBYlEAnt7e6X9qcqRRCLBtGnTMG3aNBgbG6NFixZITk7GlStX5NNydejQAceOHcP48eMVts/JycHIkSMxa9YsxMfHY/bs2QgPD4dIJIIgCLC1tYWtbckDowiCAF9fX4SGhmLEiBFYs2YNcnNzMWbMGPTu3RsuLi4QBAEPHjxA+/btsWHDBjRt2lRedL948QI//fQT0tLS5OclBwcH+cWOL7/8EqGhoRCLxdi+fTsWLlyIzZs3QywWy3Nz8uRJSCQSvPPOO8XmS/b+f/1vgJ8PRERElYveFN5SqRQTJkxAixYt4O/vL1/et29feHh4wNXVFRcvXsT06dNx48YNbN++XeV+IiMjFUbBlUlOTkZWVpbW4i+OVCpFWlUvCBBBDDW+TL3WTLKik0qlSEtLgyAISn0hDQnz8EppcpGbmwupVIq8vDz5lE4AgE+flFOU/6/wsUtp8eLFCA8PR+fOnWFlZYXJkycjISEBJiYmyMvLw9q1a7FgwQJMnjwZDx8+hL29PZo2bYrQ0FDk5eWhXr162LRpEyIiIjBv3jy4uLhg9uzZ6N+/v0IuZPkpLD8/X76s8L95eXmoXbs2Dhw4gM8//xytW7eGIAjw9vbGhx9+KF/3888/x8cff4waNWogOzsbOTk58mLw9WPJCkfZ8pkzZ0IsFmP27Nl4+PAhXFxcMGLECPnzgwYNQmBgIJ4+fQpra2v5Ptq0aQNvb28EBQUhOzsbvXr1wmeffaZ0vNKKjo7G+PHj5aOZd+vWDV999ZV8fy9fvsSNGzfw/Plz5OXl4fTp0/IRz2vWrKmwr5s3b8LT0xMAsHv3bixYsADZ2dmoV68efvvtN/nvTGbTpk3o06eP/HetSl5eHqRSKZ4+farUnL3w1GRERERU8YkEdW/jaMno0aOxe/duHDt2DNWrVy9yvX///Rft2rXD7du34ePjo/S8qjvebm5uSElJgZWVlVZiL4lUKkXyivZwSL+kXuH9+VPtBaUDUqkUycnJcHBwMOiCk3l4pTS5yMrKQnx8PLy8vIps9ltRZGZmonr16liyZIn87q9Mbm6uUvFVmfXs2RMBAQGYOXMmAGDIkCFITU3Fli1bKnwenjx5Al9fX5w+fRpeXl5FrpeVlYW4uDh4enoqvbfT09Nha2srn87MEKSnp8Pa2lqrr1kqlSIpKQmOjo4G//krw5yoxrwoY06UMSeqGVJe1Dl36cUd7zFjxuCvv/7CkSNHii26Acj75hVVeEskEkgkEqXlYrFYp794EQSIIVWv8K6Eb1SRSKTz34U+YB5eKSkXYrFYYVaDiiQmJgbXr19H06ZNkZaWJh8ksmvXrgqvRRAE+eOK9hrL6ssvv8Sff/6p9HorQx7u3r2L1atXKw229jrZe1rV+5+fDURERJWLTgtvQRAwduxY7NixA4cOHSr2zoDM+fPnAQAuLi5ajo6I6M0tWbIEN27cgImJCRo1aoSjR4/C3t5e12HpnKenJ8aOHavrMLSicePGaNy4sa7DICIiIj2i00vq4eHh+Pnnn7Fp0yZYWloiMTERiYmJ8nleY2Nj8cUXX+Ds2bOIj4/Hzp07MXDgQLRu3brYeWSJiPRBQEAAzp49i4yMDDx79gz79u1TmF+bXomOjsaOHTt0HQYVITIyEk2aNIGlpSUcHR3RtWtX3LhxQ2GdrKwshIeHo1q1arCwsECPHj3w+PFjHUVMRNoWk5CC7efuIyZB/ekhiQyRTgvvNWvWIC0tDcHBwXBxcZH/bN68GUDBtDP79+9Hhw4d4Ovri8mTJ6NHjx74888/dRk2ERGRQTl8+DDCw8Nx6tQp7Nu3D7m5uejQoQMyMzPl60ycOBF//vkntm7disOHD+Phw4fo3r27DqMmIm1ZuPsauq0+gUlbLqDb6hNYuPuarkPSmdjkDPwe84AXIKhEOm9qXhw3NzccPny4nKIhIn3G6ZWosqlI7+k9e/YoPI6OjoajoyPOnj2L1q1bIy0tDevWrcOmTZvQtm1bAMD69evh5+eHU6dO4Z133tFF2ESkBefvpSLq8B2FZVGH7yCkjjMC3Eue8rEyWbznOo5eisW1FBGkEGFUkDdmhPnpOizSU3oxuBoRUVFMTEwgFovx8OFDODg4wMTEpEIPvKWKIAjIy8tDlSpVKt1rU4eh5EEQBOTk5CA5ORlisRgmJia6DkltsvnN7ezsAABnz55Fbm4u2rdvL1/H19cX7u7uOHnypMrCW9UsJABUzmuuKVKpVD53OhVgTlRjXpTJchKfnAExlG+exSVnoH51ax1Ephvn76Xi+yOx8LUV5E2I1x6ORYfaTmjgZqPL0HTOkP5+1HmNLLzV5Dljl9rbiCHghKMWgiEyAGKxGF5eXnj06BEePnyo63C0QnZyko3gbqgMLQ9Vq1aFu7t7hRvBXCqVYsKECWjRogX8/f0BAImJiTAxMYGNjY3Cuk5OTkhMTFS5n8jISERERCgtT05ORlZWlsbjBgpiT0tLgyAIFS7v2sKcqMa8KJPlxMmkCvxslQtvJ5NsJCUl6SAy3Yi//wR+tkB1C0AEQPr/FyPi7z+EqyRHt8HpmCH9/Tx//rzU67LwJiK9Z2JiAnd3d+Tl5SE/P1/X4WicVCrF06dPUa1atUp/giqOIeXByMiowt7ZDw8Px+XLl3Hs2LE32s/MmTMxadIk+eP09HS4ubnBwcFBq/N4i0QiODg4VPr3WGkxJ6oxL8pkOanp4IBW93Ox9sir5uYftfZGYJ3ip1CsbDyzTXAtJQ4CgOspgBQFn+ee1V3h6Gij09h0zZD+fkxNTUu9LgtvIqoQRCIRjI2NYWxsrOtQNE4qlcLY2BimpqaV/gRVHOZB/40ZMwZ//fUXjhw5gurVq8uXOzs7IycnB6mpqQp3vR8/fgxnZ2eV+5JIJJBIJErLVc1rrklFzZ1uyJgT1ZgXZbKczOhYGyH+Loh7kgkve3OD69sNAA097DC8tQ+OXoqFFAV9vEcHeaOhh52uQ9MLhvL3o87rY+FNRERExRIEAWPHjsWOHTtw6NAheHl5KTzfqFEjGBsb48CBA+jRowcA4MaNG0hISEBgYKAuQiYiLQtwtzXIgruwaaG+aOVmgsc5Eng5WBh8Pqh4LLyJiIioWOHh4di0aRP++OMPWFpayvttW1tbw8zMDNbW1hg2bBgmTZoEOzs7WFlZYezYsQgMDOSI5kRUqfk4WCDQ0bHS39mlN8fCm4iIiIq1Zs0aAEBwcLDC8vXr12Pw4MEAgK+++gpisRg9evRAdnY2QkJCsHr16nKOlIgqs5iEFINu3q6P+DspPRbeREREVCxBUB7B+HWmpqb45ptv8M0335RDRERkaBbuvqYwfzjnzNY9/k7UwzYRRERERESkt2ISUhQKPACIOnwHMQkpOoqI+DtRHwtvIiIiIiLSW3FPMtVaTtrH34n6WHgTEREREZHe8rI3V2s5aR9/J+pj4U1ERERERHorwN0Wo4K8FZaNDvLmYF46xN+J+ji4GhERERER6bUZYX4IqePMEbT1CH8n6mHhTUREREREei/A3ZbFnZ7h76T02NSciIiIiIiISItYeBMRERERERFpEQtvIiIiIiIiIi1i4U1ERERERESkRSy8iYiIiIiIiLSIhTcRERERERGRFrHwJiIiIiIiItIiFt5EREREREREWsTCm4iIiIiIiEiLWHgTERERERERaRELbyIiokrmxx9/RHZ2tq7DICIiov9XRdcBUNl4ztil9jbxCztpIRIiItI3Q4YMQWhoKBwdHXUdChEREYF3vImIiCodQRB0HQIREREVwsKbiIioEhKJRLoOgYiIiP4fm5obkjnWZdgmTfNxEBGR1rVr1w5VqhR/mj937lw5RUNERGTYdFp4R0ZGYvv27bh+/TrMzMzQvHlzLFq0CLVq1ZKvk5WVhcmTJ+PXX39FdnY2QkJCsHr1ajg5OekwciIiIv0WEhICCwsLXYdBRERE0HHhffjwYYSHh6NJkybIy8vDJ598gg4dOuDq1aswNzcHAEycOBG7du3C1q1bYW1tjTFjxqB79+44fvy4LkMnIiLSa1OnTuXgakRERHpCp4X3nj17FB5HR0fD0dERZ8+eRevWrZGWloZ169Zh06ZNaNu2LQBg/fr18PPzw6lTp/DOO+/oImwiIiK9xv7dRERE+kWv+ninpRX0J7azswMAnD17Frm5uWjfvr18HV9fX7i7u+PkyZMqC+/s7GyFuUvT09MBAFKpFFKp9I1jFEP9kWLFECBABKm6Y9kVE29Z4lD7+CXEoP6upBAEQSO/h4qMeXiFuSjAPBRgHl550xxwVHMiIiL9ojeFt1QqxYQJE9CiRQv4+/sDABITE2FiYgIbGxuFdZ2cnJCYmKhyP5GRkYiIiFBanpycjKysrDeO08+2LIU3kFrVCwJEEEONL1NJSRqNI8m4ntrbFBeDuqRSKdLS0iAIAsRiwx1Qn3l4hbkowDwUYB5eef78+RttHxcXBwcHBw1FQ0RERG9K7cL73r17EIlEqF69OgDgf//7HzZt2oTatWtj5MiRZQ4kPDwcly9fxrFjx8q8DwCYOXMmJk2aJH+cnp4ONzc3ODg4wMrK6o32DQDXUtRvvieGABvjODikX1Kv8C6mb15Z4nA0vaj2NsXFoC6pVAqRSAQHBweD/lLNPLzCXBRgHgowD6+Ympq+0fYeHh4aioTIsMQkpCDuSSY8q1WFq0TX0RBRZaJ24d23b1+MHDkSAwYMQGJiIt59913UqVMHGzduRGJiIj7//HO1gxgzZgz++usvHDlyRF7QA4CzszNycnKQmpqqcNf78ePHcHZ2VrkviUQCiUT5k1IsFmvki5wUZes3J4IAMaTqFd7FxFuWONQ6diliKAuRSKSx30VFxjy8wlwUYB4KMA8FDP31E+nCwt3XEHX4DoCCmyaTWjnh4zAOUEhEmqH2mf3y5cto2rQpAGDLli3w9/fHiRMnsHHjRkRHR6u1L0EQMGbMGOzYsQP//vsvvLy8FJ5v1KgRjI2NceDAAfmyGzduICEhAYGBgeqGTkRERESkJCYhRV50y+y+nIjz91J1ExARVTpq3/HOzc2V31Hev38/unTpAqBg0LNHjx6pta/w8HBs2rQJf/zxBywtLeX9tq2trWFmZgZra2sMGzYMkyZNgp2dHaysrDB27FgEBgZyRHMiIiIi0oi4J5kql8c/yURDD7tyjoZeJ+sC4GVvjgB3W12HQ1Qmat/xrlOnDqKionD06FHs27cPoaGhAICHDx+iWrVqau1rzZo1SEtLQ3BwMFxcXOQ/mzdvlq/z1Vdf4b333kOPHj3QunVrODs7Y/v27eqGTUREZJCOHj2K/v37IzAwEA8ePAAA/PTTT288pgpRZeJlb65yuWcRy6n8LNx9Dd1Wn8CkLRfQbfUJLNx9TdchEZWJ2oX3okWL8O233yI4OBh9+vRB/fr1AQA7d+6UN0EvLUEQVP4MHjxYvo6pqSm++eYbPHv2DJmZmdi+fXuR/buJiIjold9++w0hISEwMzNDTEyMfLrNtLQ0LFiwQMfREemPAHdbjAryVljW0d8ZDdxsdBMQAVDdBSDq8B3EJKToKCKislO7qXlwcDCePHmC9PR02Nq+auoxcuRIVK1aVaPBERERUdnNmzcPUVFRGDhwIH799Vf58hYtWmDevHk6jIxI/8wI80NIHedCo5rn6Dokg1dUF4C4J5lsck4VTpnm8RYEAWfPnkVsbCz69u0LS0tLmJiYsPA2MJ4zdqm1vhgCTkxorKVoiIjodTdu3EDr1q2VlltbWyM1NbX8AyLScwHutghwt4VUKkVSUpKuwzF4RXUBKGo5kT5Tu6n53bt3UbduXbz//vsIDw9HcnIygIIm6FOmTNF4gERERFQ2zs7OuH37ttLyY8eOwdvbW8UWRKRvYhJSsP3cfYNsXq2qC8DoIG/e7aYKSe073uPHj0fjxo1x4cIFhcHUunXrhhEjRmg0OCIiIiq7ESNGYPz48fjhhx8gEonw8OFDnDx5ElOmTMGsWbN0HR4RlaDw3OIAMCrIGzPC/HQYUfkr3AWAo5pTRab2He+jR4/is88+g4mJicJyT09P+WipREREpHszZsxA37590a5dO2RkZKB169YYPnw4PvroI4wdO1atfR05cgSdO3eGq6srRCIRfv/9d4XnBw8eDJFIpPAjm/mEiNTHgcVeCXC3RfeG1Vl0U4WmduEtlUqRn5+vtPz+/fuwtLTUSFBERET05kQiET799FM8e/YMly9fxqlTp5CcnIwvvvhC7X1lZmaifv36+Oabb4pcJzQ0FI8ePZL//PLLL28SPpFBK25gMSKqeNRuat6hQwcsX74ca9euBVBwUs/IyMDs2bPRsWNHjQdIREREb8bExAS1a9d+o32EhYUhLCys2HUkEgmn/CTSEA4sRlS5qF14L126FCEhIahduzaysrLQt29f3Lp1C/b29ryyTUREpEeysrKwcuVKHDx4EElJSZBKpQrPnzt3TqPHO3ToEBwdHWFra4u2bdti3rx5CuPBFJadnS2fVxwA0tPTARS0rHs9Tk2RSqUQBEFr+6+ImBPV9CEv9atbY1RrL6w98qq5+UetvVG/urVO4tKHnOgb5kQ1Q8qLOq9R7cK7evXquHDhAn799VdcvHgRGRkZGDZsGPr16wczMzN1d0dERERaMmzYMPzzzz/44IMP0LRpU4hEIq0dKzQ0FN27d4eXlxdiY2PxySefICwsDCdPnoSRkZHS+pGRkYiIiFBanpycjKysLK3EKJVKkZaWBkEQIBar3duuUmJOVNOXvAxuaIdWbiZ4nJ4FJytT+DhY6GyaM33JiT5hTlQzpLw8f/681OuWaR7vKlWqoH///mXZlIiIiMrJX3/9hb///hstWrTQ+rF69+4t/3/dunVRr149+Pj44NChQ2jXrp3S+jNnzsSkSZPkj9PT0+Hm5gYHBwdYWVlpJUapVAqRSAQHB4dK/2WwtJgT1fQpL46Ojjo9vow+5URfMCeqGVJeTE1NS71uqQrvnTt3IiwsDMbGxti5c2ex63bp0qXUByciIiLteeutt3Q28Km3tzfs7e1x+/ZtlYW3RCKBRCJRWi4Wi7X6RU0kEmn9GBUNc6Ia86KMOVHGnKhmKHlR5/WVqvDu2rUrEhMT4ejoiK5duxa5nkgkUjniOREREZW/pUuXYvr06YiKioKHh0e5Hvv+/ft4+vQpXFxcyvW4RERE+qhUhXfhTuOG0EmeiIioMmjcuDGysrLg7e2NqlWrwtjYWOH5Z8+elXpfGRkZuH37tvxxXFwczp8/Dzs7O9jZ2SEiIgI9evSAs7MzYmNjMW3aNNSoUQMhISEaez1EREQVlVp9vHNzcxEaGoqoqCjUrFlTWzERERGRBvTp0wcPHjzAggUL4OTk9EaDq505cwZt2rSRP5b1zx40aBDWrFmDixcvYsOGDUhNTYWrqys6dOiAL774QmVzciIiIkOjVuFtbGyMixcvaisWIiIi0qATJ07g5MmTqF+//hvvKzg4GIIgFPn83r173/gYRERElZXavd379++PdevWaSMWIiIi0iBfX1+8fPlS12EQEREZPLWnE8vLy8MPP/yA/fv3o1GjRjA3N1d4ftmyZRoLjoiIiMpu4cKFmDx5MubPn4+6desq9fHW1rRdREREpEjtwvvy5cto2LAhAODmzZsKz71J3zEiIiLSrNDQUABQms5LEATOREJERFSO1C68Dx48qI04iIiISMN4zqaKLiYhBXFPMuFlb44Ad1tdh0NEVGZqF96F3b9/HwBQvXp1jQRDREREmhMUFKTrEIjKbOHua4g6fEf+eFSQN2aE+ekwIiKislO78JZKpZg3bx6WLl2KjIwMAIClpSUmT56MTz/9FGKx2uO1ERERkYZcvHgR/v7+EIvFJc5EUq9evXKKikg9MQkpCkU3AEQdvoOQOs68801EFZLahfenn36KdevWYeHChWjRogUA4NixY5gzZw6ysrIwf/58jQdJREREpdOgQQMkJibC0dERDRo0gEgkUjkNGPt4kz6Le5JZ5HIW3kRUEaldeG/YsAHff/89unTpIl9Wr149vPXWW/j4449ZeBMREelQXFwcHBwc5P8nqoi87M3VWk5EVBq6HDdC7cL72bNn8PX1VVru6+uLZ8+eaSQoIiIiKhsPDw/5/+/evYvmzZujShXF031eXh5OnDihsC6RPglwt8WoIG+F5uajg7x5t5uIykzX40aoXXjXr18fq1atwooVKxSWr1q1CvXr19dYYERERPRm2rRpg0ePHsHR0VFheVpaGtq0acOm5qTXZoT5IaSOM0c1J6I3pg/jRqhdeC9evBidOnXC/v37ERgYCAA4efIk7t27h7///lvjARIREVHZyObrft3Tp09hbs4mu6T/AtxtWXAT0RvTh3Ej1C68g4KCcPPmTXzzzTe4fv06AKB79+74+OOP4erqqvEAiYiISD3du3cHUDCA2uDBgyGRSOTP5efn4+LFi2jevLmuwiOiCio2OQMnHuTCy8GCF0SoQtGHcSPULrwTEhLg5uamchC1hIQEuLu7ayQwIiIiKhtra2sABXe8LS0tYWZmJn/OxMQE77zzDkaMGKGr8IioAlq85zqOXorFtRQRpBBxXnWqUPRh3Ai1C28vLy+V/cWePn0KLy8v9hcjIiLSsfXr1wMAPD09MWXKFDYrJ6I3EpOQgrVH7sCvUI3CedWpotH1uBFidTcoqr9YRkYGTE1N1drXkSNH0LlzZ7i6ukIkEuH3339XeH7w4MEQiUQKP6GhoeqGTEREZJBmz57NopuogohJSMH2c/cRk5Ci61CUFNc/lqgiCXC3RfeG1XVywajUd7wnTZoEoKC/2KxZs1C1alX5c/n5+fjvv//QoEEDtQ6emZmJ+vXrY+jQofL+aK8LDQ2VX7kHoNBPjYiIiIiootP1NEcl0Yf+sUQVXakL75iYGAAFd7wvXboEExMT+XMmJiaoX78+pkyZotbBw8LCEBYWVuw6EokEzs7Oau2XiIiIiKgi0IdpjkoS4G6Lka29cfRSrHwZ51UnUk+pC++DBw8CAIYMGYKvv/4aVlZWWguqsEOHDsHR0RG2trZo27Yt5s2bh2rVqhW5fnZ2NrKzs+WP09PTAQBSqRRSqfSN4xFDKNM2AkSQqtuyv5h4yxKH2sfXcAxiCBAEQSO/h4pMKpUyD/+PuSjAPBRgHl5hDogMhz5Mc1Qa00J90crNBI9zJBzVnKgM1B5cbfny5cjLy1Na/uzZM1SpUkWjBXloaCi6d+8OLy8vxMbG4pNPPkFYWBhOnjwJIyMjldtERkYiIiJCaXlycjKysrLeOCY/27IU3kBqVS8IEEEMNb5MJSVpNI4k43pqb6PJGMQAUlNTIQgCxOIyXASoJKRSKdLS0gw+DwBzIcM8FGAeXnn+/LmuQyCiclKRmnH7OFgg0NHR4D+jicpC7cK7d+/e6Ny5Mz7++GOF5Vu2bMHOnTvx999/ayy43r17y/9ft25d1KtXDz4+Pjh06BDatWuncpuZM2fK+6MDBXe83dzc4ODgoJGLAtdSlAeWK4kYAmyM4+CQfkm9wvu1kePfNA5H04tqb6PJGMQQYGNjAwcHB4P+wJZKpRCJRAafB4C5kGEeCjAPr6g7WGlRVqxYoXK5SCSCqakpatSogdatWxd5MZuICsQkpGhtJGR9mOaIiLRP7cL7v//+w7Jly5SWBwcH49NPP9VIUEXx9vaGvb09bt++XWThLZFIVA7AJhaLNfJFTgr1C14AEEGAGFL1Cu9i4i1LHGodW0sxiEQijf0uKjLm4RXmogDzUIB5KKCp1//VV18hOTkZL168gK1twZf4lJQUVK1aFRYWFkhKSoK3tzcOHjwINzc3jRyTqLIpj4HPdD3NERFpn9qFd3Z2tsqm5rm5uXj58qVGgirK/fv38fTpU7i4uGj1OKRFm3oB6RcBdS4CzEnTWjhERJXZggULsHbtWnz//ffw8fEBANy+fRsfffQRRo4ciRYtWqB3796YOHEitm3bpuNoifTP+Xup5TbwWYC7LQtuokpM7UvqTZs2xdq1a5WWR0VFoVGjRmrtKyMjA+fPn8f58+cBAHFxcTh//jwSEhKQkZGBqVOn4tSpU4iPj8eBAwfw/vvvo0aNGggJCVE3bCIiIoPz2Wef4auvvpIX3QBQo0YNLFmyBDNnzkT16tWxePFiHD9+XIdREumveM5fTUQaovYd73nz5qF9+/a4cOGCvLn3gQMHcPr0afzzzz9q7evMmTNo06aN/LGsb/agQYOwZs0aXLx4ERs2bEBqaipcXV3RoUMHfPHFF5zLm4iIqBQePXqkspVaXl4eEhMTAQCurq4czI2oCJ4VaOAzItJvahfeLVq0wMmTJ7F48WJs2bIFZmZmqFevHtatW4eaNWuqta/g4GAIQtEjY+/du1fd8IiIiOj/tWnTBh999BG+//57BAQEAABiYmIwevRotG3bFgBw6dIleHl56TJMIr0Um5yBxzkSdAtwxY6Yh/LlHPiMiMpC7cIbABo0aIBNmzZpOhYiIiLSoHXr1mHAgAFo1KgRjI2NARTc7W7Xrh3WrVsHALCwsMDSpUt1GSaR3lm85zqOXorFtRQRpBChW4ArWtV04MBnRFRmZSq8Y2NjsX79ety5cwfLly+Ho6Mjdu/eDXd3d9SpU0fTMRIREVEZODs7Y9++fbh+/Tpu3rwJAKhVqxZq1aolX6dwly8iKpg6bO2RO/ArVF/viHmIgYGeLLqJqMzUHlzt8OHDqFu3Lv777z/89ttvyMjIAABcuHABs2fP1niARERE9GZ8fX3RpUsXdOnSRaHoJiJlRQ2cxgHViOhNqH3He8aMGZg3bx4mTZoES0tL+fK2bdti1apVGg2OiIiIyi4/Px/R0dE4cOAAkpKSIJUqTuX477//6igyIv1V1MBpHFCNiN6E2oX3pUuXVPbvdnR0xJMnTzQSFBEREb258ePHIzo6Gp06dYK/vz9EIpGuQyJSS0xCCuKeZJZr3+oAd1uMbO2No5di5cs4oBoRvSm1C28bGxs8evRIaQTUmJgYvPXWWxoLjIiIiN7Mr7/+ii1btqBjx466DoVIbQt3X0PU4Tvyx6OCvDEjzK9cjj0t1Bet3EzwOEcCLwcLFt2v0cUFEaKKTu3Cu3fv3pg+fTq2bt0KkUgEqVSK48ePY8qUKRg4cKA2YiQiIqIyMDExQY0aNXQdBpHaYhJSFIpuAIg6fAchdZzLrdDzcbBAoKMjxGK1h0Sq1BbvuY6oI3Hyx+V5QYSoIlP7k2TBggXw9fWFm5sbMjIyULt2bbRu3RrNmzfHZ599po0YiYiIqAwmT56Mr7/+GoIg6DoUIrWsOHBL5XIOcKZbsckZWHtE+YJITEKKjiIiqjjUvuNtYmKC7777DrNmzcLly5eRkZGBgIAA1KxZUxvxERERURkdO3YMBw8exO7du1GnTh35XN4y27dv11FkREWLSUjBwRvJKp/jAGe69Tg9S+XyuCeZbHJOVIIyzeMNAO7u7nB3d9dkLERERKRBNjY26Natm67DIFJLUXe12/o6aL24k/Vd9qxWFa4SrR6qQnKyMlW5nBdEiEpWqsJ70qRJ+OKLL2Bubo5JkyYVu66FhQXq1KmDDz74AEZGRhoJkoiIiNS3fv16XYdApLaiirixbbXburLwYG5iCBjayBaf9HDU6jErGh8HC4xs7a3Qx5sjvhOVTqkK75iYGOTm5sr/X5zs7Gx8/fXX+Pvvv7Fhw4Y3j5CIiIh07siRI/jyyy9x9uxZPHr0CDt27EDXrl3lzwuCgNmzZ+O7775DamoqWrRogTVr1rArGqktwN0Wo4K8FQZX03Zxp2owt5N3nmHK1vNY1quh1o5bEU0L9UWIvwtHNSdSU6kK74MHD6r8f1HOnDmDdu3alT0qIiIiKpOGDRviwIEDsLW1RUBAQLFzd587d67U+83MzET9+vUxdOhQdO/eXen5xYsXY8WKFdiwYQO8vLwwa9YshISE4OrVqzA1Vd08lagoM8L8EFLHudyKu6Kat/8e8xADAr1YXL4mwN2WOSFSU5n7eBenXr16+PHHH7WxayIiIirG+++/D4mkoHNq4TvSbyosLAxhYWEqnxMEAcuXL8dnn32G999/HwDw448/wsnJCb///jt69+6tsTjIcJRncVdcH2UOHEZEmlCmwvv+/fvYuXMnEhISkJOTo/DcsmXLYGJiIj/xEhERUfmZPXu2yv9rU1xcHBITE9G+fXv5MmtrazRr1gwnT55UWXhnZ2cjOztb/jg9PR0AIJVKIZVKtRKnVCqFIAha239FxJwUqF/dGt0DXPB7zEMABX28RRAgBuBZrarB5wfge0UV5kQ1Q8qLOq9R7cL7wIED6NKlC7y9vXH9+nX4+/sjPj4egiCgYUP2gSEiIjI0iYmJAAAnJyeF5U5OTvLnXhcZGYmIiAil5cnJycjKUj1l0ZuSSqVIS0uDIAgQi8VaOUZFw5y8Mi3IFXbilzh55xnEAKpbACIAJy7HwlXipuvwdI7vFWXMiWqGlJfnz5+Xel21C++ZM2diypQpiIiIgKWlJX777Tc4OjqiX79+CA0NVXd3REREpEG2trbF9usu7NmzZ1qOpmgzZ85UmCklPT0dbm5ucHBwgJWVlVaOKZVKIRKJ4ODgUOm/DJYWc6KoY1MT/HD2BMQQIAC4ngJcOfoYzf190MDNRtfh6ZTsvfIw2wR3n76Ap705c8K/H5UMKS/qjGGiduF97do1/PLLLwUbV6mCly9fwsLCAnPnzsX777+P0aNHq7tLIiIi0pDly5fL///06VPMmzcPISEhCAwMBACcPHkSe/fuxaxZszR2TGdnZwDA48eP4eLiIl/++PFjNGjQQOU2EolE3he9MLFYrNUvaiKRSOvHqGiYk1fin76AFAUXrgQAUogghQjxT1+goYedboPTA7+du49lRx/LczQqyBszwvx0HJVu8e9HNUPJizqvT+3C29zcXN6v28XFBbGxsahTpw4A4MmTJ+rujoiIiDRo0KBB8v/36NEDc+fOxZgxY+TLxo0bh1WrVmH//v2YOHGiRo7p5eUFZ2dnHDhwQF5op6en47///uMFeapQihpkrbjB1wzF+Xup2H05EcCrFjVRh+8gpI4zB58jKgW1L0G88847OHbsGACgY8eOmDx5MubPn4+hQ4finXfe0XiAREREVDZ79+5V2Q0sNDQU+/fvV2tfGRkZOH/+PM6fPw+gYEC18+fPIyEhASKRCBMmTMC8efOwc+dOXLp0CQMHDoSrq6tGR1Yn0jbZHOKFdQ9wRdyTTMQkpOgoKv0QX8SUa0VNxUZEitS+471s2TJkZGQAACIiIpCRkYHNmzejZs2aWLZsmcYDJCIiorKpVq0a/vjjD0yePFlh+R9//IFq1aqpta8zZ86gTZs28sey/tmDBg1CdHQ0pk2bhszMTIwcORKpqalo2bIl9uzZwzm8qcKZEeaHDrWdEH//IY7dz8H2mIfY/v+jnRty02pPtgYgeiNqFd75+fm4f/8+6tWrB6Cg2XlUVJRWAiMiIqI3ExERgeHDh+PQoUNo1qwZAOC///7Dnj178N1336m1r+DgYAiCUOTzIpEIc+fOxdy5c98oZkMTk5CCuCeZ8LI315vmuvoYU3lr4GaDl+nP8HtMPNi0ukADNxuE+Tvj2tHH8mWjg7wNMhdEZaFW4W1kZIQOHTrg2rVrsLGx0VJIREREpAmDBw+Gn58fVqxYge3btwMA/Pz8cOzYMXkhTrqzcPc1RB2+I3+sD3dT9TEmXXmcrnpau7gnmQZbbH7QyA3N/X0Q//SFQV+YISoLtZua+/v7486dO/Dy8tJGPERERKRBzZo1w8aNG3UdBr0mJiFFocAFyuduanF3s3UVk75yslLdTcLQm1Y3cLPhCO9EZaB24T1v3jxMmTIFX3zxBRo1agRzc8UPH23NvUlEREQlS09PL/W6PGfrTlEDUmnzbqqqu9nTQmrpNCZ95uNggZGtvRF1JE6+jE2riais1C68O3bsCADo0qULRKJXfV4EQYBIJEJ+fr7moiOqADxn7FJrfTEEnJjQWEvREJGhs7GxUTg/q8Jztu6V97RVRd3N7lDbCa4S3cRUEUwL9UWIv4vB93knojenduG9fv16uLm5wcjISGG5VCpFQkKCxgIjIiIi9R08eFDXIVApyKatKlwMa/NualF3s+OfZML1LWOdxFRRBLjbGnwOiOjNqV14Dx06FI8ePYKjo6PC8qdPn6J9+/YYNGiQxoIjIiIi9QQFBek6BCqlGWF+CKnjXC53U4u6a10wRVSOTmJShSOqE1FlpXbhLWue9rqMjAzO1UlERKRnUlNTsW7dOly7dg0AUKdOHQwdOhTW1tY6joyA8rubWtTd7AZuNkhKStJJTK/jiOpEVJmVuvCeNGkSgIJ5OmfNmoWqVavKn8vPz8d///2HBg0aqHXwI0eO4Msvv8TZs2fx6NEj7NixA127dpU/LwgCZs+eje+++w6pqalo0aIF1qxZg5o1a6p1HCIiIkN05swZhISEwMzMDE2bNgUALFu2DPPnz8c///yDhg0b6jhCKk8zwvzgZW+OC/dSUd/NBr2auEMqleo6LAAcUZ2IKr9SF94xMTEACorhS5cuwcTERP6ciYkJ6tevjylTpqh18MzMTNSvXx9Dhw5F9+7dlZ5fvHgxVqxYgQ0bNsDLywuzZs1CSEgIrl69yrvrVHZzyniXZ06aZuMgItKyiRMnokuXLvjuu+9QpUrBKT8vLw/Dhw/HhAkTcOTIER1HSOWp8B3lTf+7h7gnmQqjmpen15uUc0R1IqrsSl14ywZrGTJkCL7++muNTEESFhaGsLAwlc8JgoDly5fjs88+w/vvvw8A+PHHH+Hk5ITff/8dvXv3fuPjExERVWZnzpxRKLoBoEqVKpg2bRoaN+bsCoakNKOalxdVTcpD6jirXNeQR1QnosqlTKOal4e4uDgkJiaiffv28mXW1tZo1qwZTp48WWThnZ2djezsbPlj2XymUqlUI82pxBDKtI0AEaQQq7dhMfGWJQ61j6/hGLSRh7IpQx6AIuMoUx4EQW+a9+mSVCplLsA8yDAPr2gqB1ZWVkhISICvr6/C8nv37sHS0lIjx6CKoTSjmpfHwGbFNSnniOpEVJmpXXiXl8TERACAk5OTwnInJyf5c6pERkYiIiJCaXlycjKysrLeOC4/27IU3kBqVS8IEEEMNb5MvTbYyZvGkWRcT+1tNBmDNvJQJlZlyEMxcZQpD6mpEAQBYnEZLwJUElKpFGlpaQafC+ahAPPwyvPnzzWyn169emHYsGFYsmQJmjdvDgA4fvw4pk6dij59+mjkGFQxlDSq+eI91xF1JE6+vFuAK77qFaDxOIprUq7rEdX1BUd2J6qc9LbwLquZM2fKB4IDCu54u7m5wcHBQSPN46+lKI/oXhIxBNgYx8Eh/ZJ6BedrU7a9aRyOphfV3kaTMWgjD2WSXoY8FBNHmfJgYwMHBweDLy6kUilEIpHB54J5KMA8vKKpcUyWLFkCkUiEgQMHIi8vDwBgbGyM0aNHY+HChRo5BlUMxY1qfvLKHaw9cgfAq/PZjpiHAKDx4ruoCwC5+VJ5nIZcbHJkd6LKS28Lb2fngr4+jx8/houLi3z548ePix09XSKRQCJR7qwkFos18kVOCvULXgAQQYAYUvUKzmLiLUscah1bSzFoOg9lU8YmnEXEUaY8iEQae09WdMxFAeahAPNQ4E1e/8WLF+Hv7w+xWAwTExN8/fXXiIyMRGxsLADAx8dHYWYSMhyq7ihLpVI8TlfdInBHzEMMDPTUaCGs6gIAAEz/7ZL8rreh4sjuRJWb3n6z8fLygrOzMw4cOCBflp6ejv/++w+BgYE6jIyIiEh/BQQE4MmTJwAAb29vPH36FFWrVkXdunVRt25dFt0GLsDdFt0bVlco5Jysim5hUVTT8DcxI8wPi3rUVVoedfgOYhJSNH68iqK4ZvhEVPHptPDOyMjA+fPncf78eQAFA6qdP38eCQkJEIlEmDBhAubNm4edO3fi0qVLGDhwIFxdXRXm+iYiIqJXbGxsEBdX0Fc3Pj6eg9VRiXwcLNA1wFXlc9oaVdzYSPVXUEMuMovKNUd2J6ocdNrU/MyZM2jTpo38saxv9qBBgxAdHY1p06YhMzMTI0eORGpqKlq2bIk9e/ZwDm8iIqIi9OjRA0FBQXBxcYFIJELjxo1hZGSkct07d+6oXE7aoc+DZi35sAEEiOR9uwHtjipeXJGpz3nSpqL64RtSDogqM50W3sHBwRCEokeEFolEmDt3LubOnVuOUREREVVca9euRffu3XH79m2MGzcOI0aM4NRheqAiDJr1Va8ADAz0LJeit6gic++VRL3PkzZxZHeiyktvB1cjIiKisgkNDQUAnD17FuPHj2fhrWMVadCs8hxV/PUiEwC6rT6hsI6+5kmbDH1kd6LKioU3VWieM3apvU08eyoQkYFYv369rkMgFD9olqEXWIWLzO3n7qtcpzzzJGvm7lmtKlyVJ8khIiozFt5EREREWsRBs0pH13kq3B1ADAGTWjnh4zDHcjk2EVV+ejudGBEREVFlIOvPXJg+DpoVk5CC7efu62xKL13mSVV3gN2XE3H+XqrWj01EhoF3vImIiIi0TN8HzVq85zqijsTJH+tqUDNd5amo7gDxTzLR0MOuXGIgosqNhTcRERFROdDXQbNikzOw9sgdACL5Ml0OaqaLPBXVnN2zHLsDGOo0akSGgoU3ERERkQF7nJ6lcrkhDf6manqzjv7OaOBmUy7HrwjTzRHRm2HhTURERGTAnKxUT/dhaIO/FW7mXjCqeU65HLciTTdHRGXHwdWIiIiIDJiPgwW6BrgqLNPHwd/KQ4C7Lbo3rF5ud7qB4qebI6LKg3e8iYiIiAzU+Xup2HrsJn6/lA5ZH+9uAa6YzmbO5UbX06gRUfngHW8iIiIiA7Rw9zV8sOYELt5PU1i+I+Yhvtp3Q2fTihmaijLdHBG9Gd7xJiIiIjIwsn7FRd2B+frAbXx94DYH+Son+j7dHBG9ORbeRERERAamtP2HOchX+dHX6eaISDPY1JyIiIjIwKjTf5iDfBERvTne8SbShU29gPSLAKTqbTcnreR1iIhIr8QkpFToJsQc5IuI6M2x8CYiIiLSkoW7rynM0awvfaZLexe7ra9DhbxYQESkb1h4ExEREWmBbACzwmR9pgHo9C54ae9ij21bU8uREBEZBhbeREREVOnoQ/Puou4qr/z3Fv69nix/rIu74LIprNYejpUva+BmjfP3XnVp0tWUVvrwuyMi0jQW3kRERPTG5syZg4iICIVltWrVwvXr18s9Fn1p3l3UXeXCRTegu5HDZ4T5oUNtJ8TffwjP6q5o6GGn86JXX353RESaxsKbiIiINKJOnTrYv3+//HGVKuX/NaO45t2CICD+/hN4ZpugoYed1mOR3VV+PR5V4p5k6qTQbeBmA1dJDhwdbQDodkqr4n53vPNNRBUdC28iIiLSiCpVqsDZ2VmnMRTXvPvQ9ST42Qq4lhKPkUE+5XInNaSOc6kKb44cXvTvTlcXJYiINImFNxEREWnErVu34OrqClNTUwQGBiIyMhLu7u4q183OzkZ2drb8cXp6OgBAKpVCKlVzqsVCPKtVhRiC0vJD15MghgARBIgBrD0ciw61ndDAzabMxyqNuOQMlfEU1sbXAfWrW7/R6y4rqVQKQRB0cuzXFfW786xWtdzj06e86AvmRBlzopoh5UWd18jCm4iIiN5Ys2bNEB0djVq1auHRo0eIiIhAq1atcPnyZVhaWiqtHxkZqdQnHACSk5ORlZVV5jhcJcCkVk7YfTlRvqxedWtcvJ8GMYDqFoAIgBQC4u8/hKskp8zHKg0nk2z42RZfeA9tVA1JSUlajaMoUqkUaWlpEAQBYrFYJzHIqPrddfR3hqskp9zzo0950RfMiTLmRDVDysvz589LvS4LbyIiInpjYWFh8v/Xq1cPzZo1g4eHB7Zs2YJhw4YprT9z5kxMmjRJ/jg9PR1ubm5wcHCAlZXVG8XycZgjmvunIv5JJjz/vwn35jUnIIYAAcD1FEAKEXKNLXHiQS487c21dufb0dERre7lYO0R1c3NP2rtjcA63jh/71W82r4LX5hUKoVIJIKDg4NefEF+/XdXnrkoTN/yog+YE2XMiWqGlBdTU9NSr8vCm4iIiDTOxsYGb7/9Nm7fvq3yeYlEAolEorRcLBZr5ItaQw87hQHURgb5YO3hWAgoKLrrudlg+vbL8ue1OXr2jI61EeLvgkM3Cu7autqYwdhILB85XNcjeYtEIo3lXRNe/93pir7lRR8wJ8qYE9UMJS/qvD4W3kRERKRxGRkZiI2NxYABA3QdCgDFqbNyjS0Vim5A+6NnFzVaOEfyrhh0Pc0aEVV8LLyJiIjojU2ZMgWdO3eGh4cHHj58iNmzZ8PIyAh9+vTRdWhysqmzTjzIVfm8LkbP1tVI3jEJKQV34AUBTV2qwNHRUWvHqmhiElIQl5wBJ5NsODo66rxFAhFVDiy8iYiI6I3dv38fffr0wdOnT+Hg4ICWLVvi1KlTcHBw0HVoSjyLmLpLF1N65earHhFXm7EULiTFEOBnK6DVvRzM6Fhba8esKGS5keWl1tV0bI95pLAOWyQQUVmw8CYiIqI39uuvv+o6hFJr4GaDUUHeCncxRwd5l3sh9fqd1PKIRVXTdgBYe+QOQvxdDLqYVJWb32MeomAcfEWcW5yI1KXXhfecOXOUphqpVasWrl+/rqOIiIiIqDKYEeaHkDrOOuu3W1QBvKhHXfRqonruc00oqmm77DlDLiaLy83rdNE6gogqNr0uvAGgTp062L9/v/xxlSp6HzIRERFVAEUNeFYeZCOcv+5h6kutHre4gtHQi8miXn+3AFfsiHkof6yL1hFEVPHpfRVbpUoVODs76zoMosppjnUZtknTfBxERFQuAtxtlZrZAwXziRt6MakqNx+19sb0jrUxMNCTo5oT0RvR+8L71q1bcHV1hampKQIDAxEZGQl396KbYGVnZyM7O1v+OD09HUDBRO5SqeoBTNQhhlCmbQSIIIWa89gVE29Z4lD7+BqOoULnoZg4yi0PxcRQdrqNQSqVQhAEjfxtVmTMQwHm4RXmoPILruWIrw8oz3EeXEv7o4vLmtkXHtU8sI631o9bEn2YskveBeH/RzWX5UWXrSOIqHLQ68K7WbNmiI6ORq1atfDo0SNERESgVatWuHz5MiwtLVVuExkZqdQvHACSk5ORlZX1xjH52Zal8AZSq3pBgAhiqPFlKkl1M7SyxpFkXE/tbTQZQ4XOQzFxlFseiomhzKw0+55Ql1QqRVpaGgRBgFhcxgsilQDzUIB5eOX58+e6DoG0LMDdVqdNmGXHiUvOAJBd/MrlQJ+m7Apwt0X96tZI0vQ5l4gMml4X3mFhYfL/16tXD82aNYOHhwe2bNmCYcOGqdxm5syZmDRpkvxxeno63Nzc4ODgACsrqzeO6VqK8siWJRFDgI1xHBzSL6lXaBUzp2ZZ4nA0vaj2NpqMoULnoZg4yi0PxcRQZumafU+oSyqVQiQSwcHBwaALLeahAPPwiqmpqa5DIC1buPuaQtHdLcAV08ux0Hx92ixdTiemaqA5TtlFRJWNXhfer7OxscHbb7+N27eVm2bJSCQSSCQSpeVisVgjX+SkKqaUKA0RBIghVa/QKibessShdpGnhRgqbB6KiaPc8lBMDGWn2fdEWYhEIo39fVZkzEMB5qGAob9+TZE1Xc7NlxYMWvb/zaodNX0RswxxvV5o7oh5CHe7qgiu5aj1YlPV8QtPJ1beTb6LGk3c0EdZJ6LKpUIV3hkZGYiNjcWAAQN0HQoRERHpMVVzZMvu7ta6mo6WNR111pe4qBHNvz5wG18fuK31ZtbFFbp7rySWe5PvokYTN/RR1omoctHrS+pTpkzB4cOHER8fjxMnTqBbt24wMjJCnz59dB0aERER6ami5siW+T3mISZtuYBuq09g4uaYcoys4IKAqkHVCos6fAcxCSlaOX5MQgruPlVdeOfmS1U2+dZWLDKy0cQL45RdRFTZ6PUd7/v376NPnz54+vQpHBwc0LJlS5w6dQoODg66Do2IiIj0VFF3dFXZEfMQzzJzsGFoMy1GVKCkCwKFaaOZtapWADIftfaGsZHq+zHl0eRbPpo4p+wiokpKrwvvX3/9VdchEBERUQWjbhPlwzefYOLmGHzVK0BLERVQ54KApptZF1X0j21bQz6d2IX7aeUSS1E4ZRcRVWZ63dSciIiISF17rySqvc2OmIdab1Jd2gK2e4CrxgvQoop+j2rm8HGwAMAm30RE2qTXd7yJqHQ8Z+wq03bxGp6xSN04xBBwYkJjzQZBRAZNnebcr9N2k2pZYVtcfMFv22OZFu68F1X0e9qbA8iRP2aTbyIi7WDhTURERJWGOs25X6etJtWFp+cqXNgevZWsMJd39wBXrRTdQNFF/z9XEjG4oZ3Suiy4iYg0i4U3EenWpl5A+kWoNaf4HNX9EImIylo8a6tJ9esDmsmm5wpwt0X3htUxMNBTPte4sZEYMQkpWit6Q+o4q5y/u5Wbic7nNiciquxYeBMREVGlUZrm3IU18rBByxr2CK6l+cJTVbP3qMN3IKkiRnAtR3mB/dfFh/j3erJ8HW3NnV1Ua4DH6VkaPxYRESli4U1ERESVyowwP0iqiEucLxsAzt5Nxdm7qfj6wG2NF7xFFbpfH7iNrw/cRgM3a5y/p9yCJ+rwHYTUcdb4ne+iWgM4WZni/L1UxD99wX7dRERawlHNiYiIqNIpyx3sqMN3NDqyeUnN3lUV3TJv0le9KKpGLf+otTdiElLwwZoTmLTlArqtPoGJm2Ow/dx9rY/yTkRkSHjHm4iIiCodVU3Og962R1JycjFbaXZkc3WbvRemrYHeXh+1XBAEzPr1OACRfJ0dMQ/lg75pq9k7EZGh4R1vIiIiqpRmhPmhW4Cr/PHhm0/gXUJBq+mCd0aYH3Z83Bzj29Uo9TbanjtbNrBbgLst4ku4s67pVgBERIaKd7yJiDSM85kT6YeYhBSF6boA4M6TTER2rwfjKkZK03lpq+CVTc91+GayQvNyG7MqSH2ZJ3/c1tcBY9vWLNc+1p6luNCg7fnNiYgMAe94ExERUaVUVD9pYyMxujesDicrU4XlghZjiUlIUerTXbjo7hbgih8GNy33AreBmw3C/J2LXUdbzd6JiAwJC28iIiKqlIoqGD3tzbH5dILKqb601ay6pMHSdsQ81FmT7g8auWHb6OZY1rO+QtN8QPvN3omIDAWbmhMRzbEuwzZFj0ZMRPph75VEpWUd/Z3xz5VERB2JU7mNtppVl+ausS6bdDdws0FDDzt0b1gdAwM95YOvsegmItIM3vEmIiKiSicmIUXlaOKOVqZYe6ToUca11axa1VRe5XVsdRUefI2IiDSDd7yJiIio0imqaXdcctFNvtv6Omi12Cw8lVd5DexGRET6gYU3ERERVTpF3T32cjAH8ETlc9ZmxlqMqIBshHM26SYiMixsak5ERESVToC7rdJAYR+19karmg4Y2Vp1k+/yHuCMTbqJiAwH73gTUaWi7hzaABBvWvI6VDGV5f0AAPELO2k4EipvC3dfU2jK3S3AFVNDfZGUlIRpob6QGBvh6wO3lbbjnNVERKQNLLyJiPTBpl5A+kUA0tJvw5HViVRSNbDajpiHGPCOB16mZ+DEg1y42pip3FZfBjgjIqLKhYU3ERERVSpFDay24O+reJmegmspIkghKueoiIjIkLGPNxEREVUqRd21Pnc3tcRtiyraiYiI3gQLbyIiIqpUSjNndlHY1JyIiLSBTc2JiKjAHOsybse+5qR/Cs+ZffdppsqB1F7HubSJiEhbWHgTERFRpSSbMzsmIUVl4d09wBUDOJc2ERGVAxbeREREVKnJmp6vPRwrX9Y9wBXLegXInyciItImFt5ERKQV6s6hLYaAE45fqj+tGsDm7nrkm2++wZdffonExETUr18fK1euRNOmTXUdFmaE+aFDbSfE338Iz+quaOhhp+uQiIjIgHBwNSIiItKIzZs3Y9KkSZg9ezbOnTuH+vXrIyQkBElJSboODQDQwM0GzX3s0cDNRtehEBGRgeEdbyIioteVZaA53nXHsmXLMGLECAwZMgQAEBUVhV27duGHH37AjBkzdBwdERGR7rDwJiIiojeWk5ODs2fPYubMmfJlYrEY7du3x8mTJ5XWz87ORnZ2tvxxeno6AEAqlUIqVbOrQSlJpVIIgqC1/VdEzIlqzIsy5kQZc6KaIeVFnddYIQpvfe0vRkRERAWePHmC/Px8ODk5KSx3cnLC9evXldaPjIxERESE0vLk5GRkZWVpJUapVIq0tDQIggCxmL3tAOakKMyLMuZEGXOimiHl5fnz56VeV+8Lb1l/saioKDRr1gzLly9HSEgIbty4AUdHR12HR0RERGUwc+ZMTJo0Sf44PT0dbm5ucHBwgJWVlVaOKZVKIRKJ4ODgUOm/DJYWc6Ia86KMOVHGnKhmSHkxNTUt9bp6X3izvxgREZH+s7e3h5GRER4/fqyw/PHjx3B2dlZaXyKRQCKRKC0Xi8Va/aImEom0foyKhjlRjXlRxpwoY05UM5S8qPP69LrwVre/GKDcZywtrWCwm9TUVM30M8jOLMNGAtKz8mGSLYIYotJvlpqq0ThSRWocWysxVOA8FBdHeeVBozH8/+74nijYXWXMQ1lk829DvjtNvyfUJOvvLAiCxvapbSYmJmjUqBEOHDiArl27Aii463HgwAGMGTOmxO1lr1X22rVBKpXi+fPnMDU1rfRfBkuLOVGNeVHGnChjTlQzpLyodb4W9NiDBw8EAMKJEycUlk+dOlVo2rSpym1mz54tAOAPf/jDH/7wp8L/3Lt3rzxOtxrz66+/ChKJRIiOjhauXr0qjBw5UrCxsRESExNL3PbevXs6zzd/+MMf/vCHP2X5Kc35Wq/veJfF633GpFIpnj17hmrVqkFU1judb0jWb+3evXta67dWETAPBZiHV5iLAsxDAebhFUEQ8Pz5c7i6uuo6FLX06tULycnJ+Pzzz5GYmIgGDRpgz549SgOuqeLq6op79+7B0tJSa+drvseUMSeqMS/KmBNlzIlqhpQXdc7Xel14q9tfDFDdZ8zGxkZbIarFysqq0r/5SoN5KMA8vMJcFGAeCjAPBaytrXUdQpmMGTOmVE3LXycWi1G9enUtRKSM7zFlzIlqzIsy5kQZc6KaoeSltOdrvW50X7i/mIysv1hgYKAOIyMiIiIiIiIqHb2+4w0AkyZNwqBBg9C4cWM0bdoUy5cvR2ZmpnyUcyIiIiIiIiJ9pveF95v0F9MXEokEs2fPVjltiiFhHgowD68wFwWYhwLMA2kb32PKmBPVmBdlzIky5kQ15kU1kSBUoLlKiIiIiIiIiCoYve7jTURERERERFTRsfAmIiIiIiIi0iIW3kRERERERERaxMKbiIiIiIiISItYeGvZN998A09PT5iamqJZs2b43//+p+uQyl1kZCSaNGkCS0tLODo6omvXrrhx44auw9K5hQsXQiQSYcKECboOpdw9ePAA/fv3R7Vq1WBmZoa6devizJkzug6r3OXn52PWrFnw8vKCmZkZfHx88MUXX6Cyj3l55MgRdO7cGa6urhCJRPj9998VnhcEAZ9//jlcXFxgZmaG9u3b49atW7oJlioVnpNf4bm5ZIZ8nn4dz9uKDPX8XRjP5epj4a1FmzdvxqRJkzB79mycO3cO9evXR0hICJKSknQdWrk6fPgwwsPDcerUKezbtw+5ubno0KEDMjMzdR2azpw+fRrffvst6tWrp+tQyl1KSgpatGgBY2Nj7N69G1evXsXSpUtha2ur69DK3aJFi7BmzRqsWrUK165dw6JFi7B48WKsXLlS16FpVWZmJurXr49vvvlG5fOLFy/GihUrEBUVhf/++w/m5uYICQlBVlZWOUdKlQnPyYp4bi6eIZ+nX8fztjJDPX8XxnN5GQikNU2bNhXCw8Plj/Pz8wVXV1chMjJSh1HpXlJSkgBAOHz4sK5D0Ynnz58LNWvWFPbt2ycEBQUJ48eP13VI5Wr69OlCy5YtdR2GXujUqZMwdOhQhWXdu3cX+vXrp6OIyh8AYceOHfLHUqlUcHZ2Fr788kv5stTUVEEikQi//PKLDiKkyoLn5OIZ+rm5MEM/T7+O521lPH8r4rm8dHjHW0tycnJw9uxZtG/fXr5MLBajffv2OHnypA4j0720tDQAgJ2dnY4j0Y3w8HB06tRJ4b1hSHbu3InGjRvjww8/hKOjIwICAvDdd9/pOiydaN68OQ4cOICbN28CAC5cuIBjx44hLCxMx5HpTlxcHBITExX+PqytrdGsWTOD/+yksuM5uWSGfm4uzNDP06/jeVsZz9/F47lctSq6DqCyevLkCfLz8+Hk5KSw3MnJCdevX9dRVLonlUoxYcIEtGjRAv7+/roOp9z9+uuvOHfuHE6fPq3rUHTmzp07WLNmDSZNmoRPPvkEp0+fxrhx42BiYoJBgwbpOrxyNWPGDKSnp8PX1xdGRkbIz8/H/Pnz0a9fP12HpjOJiYkAoPKzU/Yckbp4Ti6eoZ+bC+N5WhnP28p4/i4ez+WqsfCmchUeHo7Lly/j2LFjug6l3N27dw/jx4/Hvn37YGpqqutwdEYqlaJx48ZYsGABACAgIACXL19GVFSUwZ3At2zZgo0bN2LTpk2oU6cOzp8/jwkTJsDV1dXgckFEumPI5+bCeJ5WjedtZTx/U1mwqbmW2Nvbw8jICI8fP1ZY/vjxYzg7O+soKt0aM2YM/vrrLxw8eBDVq1fXdTjl7uzZs0hKSkLDhg1RpUoVVKlSBYcPH8aKFStQpUoV5Ofn6zrEcuHi4oLatWsrLPPz80NCQoKOItKdqVOnYsaMGejduzfq1q2LAQMGYOLEiYiMjNR1aDoj+3zkZydpEs/JRTP0c3NhPE+rxvO2Mp6/i8dzuWosvLXExMQEjRo1woEDB+TLpFIpDhw4gMDAQB1GVv4EQcCYMWOwY8cO/Pvvv/Dy8tJ1SDrRrl07XLp0CefPn5f/NG7cGP369cP58+dhZGSk6xDLRYsWLZSmrLl58yY8PDx0FJHuvHjxAmKx4sewkZERpFKpjiLSPS8vLzg7Oyt8dqanp+O///4zuM9O0hyek5Xx3KyM52nVeN5WxvN38XguV41NzbVo0qRJGDRoEBo3boymTZti+fLlyMzMxJAhQ3QdWrkKDw/Hpk2b8Mcff8DS0lLet8Pa2hpmZmY6jq78WFpaKvWdMzc3R7Vq1QyqT93EiRPRvHlzLFiwAD179sT//vc/rF27FmvXrtV1aOWuc+fOmD9/Ptzd3VGnTh3ExMRg2bJlGDp0qK5D06qMjAzcvn1b/jguLg7nz5+HnZ0d3N3dMWHCBMybNw81a9aEl5cXZs2aBVdXV3Tt2lV3QVOFx3OyIp6blfE8rRrP28oM9fxdGM/lZaDrYdUru5UrVwru7u6CiYmJ0LRpU+HUqVO6DqncAVD5s379el2HpnOGOk3Jn3/+Kfj7+wsSiUTw9fUV1q5dq+uQdCI9PV0YP3684O7uLpiamgre3t7Cp59+KmRnZ+s6NK06ePCgys+EQYMGCYJQMA3JrFmzBCcnJ0EikQjt2rUTbty4odugqVLgOfkVnptLx1DP06/jeVuRoZ6/C+O5XH0iQRCE8iz0iYiIiIiIiAwJ+3gTERERERERaRELbyIiIiIiIiItYuFNREREREREpEUsvImIiIiIiIi0iIU3ERERERERkRax8CYiIiIiIiLSIhbeRERERERERFrEwpuIiIiIiIhIi1h4E2mBIAgYOXIk7OzsIBKJcP78+RK3iY+PV1j30KFDEIlESE1NfaNYPD09sXz58jfah6F4/XdARERUkQUHB2PChAm6DoOIwMKbSCv27NmD6Oho/PXXX3j06BH8/f1L3MbNza3U65Y3kUiE33//XWHZnDlz0KBBA53EowqLZiIiIiLSV1V0HQBRZRQbGwsXFxc0b9681NsYGRnB2dlZi1EREREREZEu8I43kYYNHjwYY8eORUJCAkQiETw9PQEU3AVv2bIlbGxsUK1aNbz33nuIjY2Vb1eaO7bHjh1Dq1atYGZmBjc3N4wbNw6ZmZny55OSktC5c2eYmZnBy8sLGzduLDHe06dP491334W9vT2sra0RFBSEc+fOyZ+Xxd+tWzf564mOjkZERAQuXLgAkUgEkUiE6OhoAEBqaiqGDx8OBwcHWFlZoW3btrhw4YJ8f7I75T/88APc3d1hYWGBjz/+GPn5+Vi8eDGcnZ3h6OiI+fPnK8QpEomwZs0ahIWFwczMDN7e3ti2bZv8eS8vLwBAQEAARCIRgoODARQ02W/atCnMzc1hY2ODFi1a4O7duyXmBQDy8/MxdOhQ+Pr6IiEhoVTbEBER6atdu3b9X3v3GhLltsYB/D+jFgpmO0lxMBXMSyWGVpSQTaWhTDdLTEVKoxiTzEw/hGSKEUSEiCGCiQpdvJAlEaVo3vA6pqUGmWNhZjBqmpWWGeo6HzZnOLPt6Li3lzb9f9/edXufNV9mnnetdw3MzMz0+n1ARPOLiTfRPEtNTcWlS5dgbW0NjUaDp0+fAgC+fv2KmJgYNDc3o7y8HFKpFIcOHcLU1JRe47558wa+vr7w9/dHe3s7CgoKUFtbi8jISG2bsLAw9Pb2orKyEoWFhUhPT8fAwMCM446MjCA0NBS1tbVobGyEg4MDFAoFRkZGAEAbf05OjnY+gYGBiI2NxYYNG6DRaKDRaBAYGAgACAgIwMDAAIqLi9HS0gJ3d3d4eXnh48ePOnMpLi5GSUkJ8vLykJWVhb179+L9+/eorq7G1atXER8fD5VKpRPrxYsX4e/vj7a2NoSEhCAoKAgdHR0AgKamJgDAkydPoNFocP/+fUxMTMDPzw9yuRzt7e1oaGiAUqmERCKZ9fMeHx9HQEAAWltbUVNTAxsbm1n7EBER/apyc3MRHByMO3fuICQkZKnDIfr9CCKadykpKcLW1nbGNh8+fBAAxIsXL4QQQnR3dwsA4vnz50IIISorKwUAMTw8LIQQ4sSJE0KpVOqMUVNTI6RSqRgbGxOdnZ0CgGhqatLWd3R0CAAiJSVF79gnJyeFqampePjwobYMgCgqKtJpl5iYKDZu3DgtnhUrVojv37/rlNvb24uMjAxtPxMTE/HlyxdtvY+Pj7CzsxOTk5PaMicnJ3HlyhWdGE6dOqUz7tatW0VERIQQYvrnJ4QQQ0NDAoCoqqrSa+7/HaOmpkZ4eXmJ7du3i0+fPunVl4iI6Fcjl8vF2bNnRVpamjAzM9P7+5CI5h/f8SZaJF1dXUhISIBKpcLg4KB2pfvdu3d6HajW1taG9vZ2ne1hQghMTU2hu7sbarUahoaG2LRpk7be2dkZK1eunHHc/v5+xMfHo6qqCgMDA5icnMS3b9/+1tbqtrY2jI6OwtzcXKd8bGxMZ1u9nZ0dTE1NtdeWlpYwMDCAVCrVKfvrar2Hh8e065m25q9atQphYWHw8fHBnj174O3tjSNHjsDKymrGeQQHB8Pa2hoVFRUwNjaesS0REdGvrLCwEAMDA6irq8OWLVuWOhyi3xYTb6JFsn//ftja2iIzMxMymQxTU1NwcXHBjx8/9Oo/OjqK8PBwREVFTauzsbGBWq3+W3GFhoZiaGgIqampsLW1xfLly+Hh4aF3XH+N0crKClVVVdPq/vcBgJGRkU6dRCL5aZm+2/BnkpOTg6ioKJSUlKCgoADx8fEoKyvDtm3b/m8fhUKB27dvo6GhAbt37/7HMRARES0VNzc3PHv2DNnZ2di8ebNer1sR0fxj4k20CIaGhtDZ2YnMzEx4enoC+POgtLlwd3fHy5cvsXbt2p/WOzs7Y2JiAi0tLdon2p2dnbP+D3hdXR3S09OhUCgAAL29vRgcHNRpY2RkhMnJSZ2yZcuWTStzd3dHX18fDA0NtYeyzafGxkYcO3ZM59rNzU0bD4BpMQF//uhwc3NDXFwcPDw8kJubO2PiHRERARcXFxw4cACPHj2CXC6f55kQEREtDnt7eyQnJ2Pnzp0wMDBAWlraUodE9Fvi4WpEi+CPP/6Aubk5bty4gdevX6OiogIxMTFzGuP8+fOor69HZGQkWltb0dXVhQcPHmgPV3NycoKvry/Cw8OhUqnQ0tKCkydPzrpV2sHBAbdu3UJHRwdUKhVCQkKm9bGzs0N5eTn6+vowPDysLevu7kZraysGBwcxPj4Ob29veHh4wM/PD6WlpXj79i3q6+tx4cIFNDc3z2m+P3P37l1kZ2dDrVYjMTERTU1N2vlbWFjA2NgYJSUl6O/vx+fPn9Hd3Y24uDg0NDSgp6cHpaWl6Orqwrp162a915kzZ3D58mXs27dvzg9JiIiIfiWOjo6orKzEvXv3EB0dvdThEP2WmHgTLQKpVIr8/Hy0tLTAxcUF586dw7Vr1+Y0hqurK6qrq6FWq+Hp6Qk3NzckJCRAJpNp2+Tk5EAmk0Eul+Pw4cNQKpWwsLCYcdysrCwMDw/D3d0dR48eRVRU1LQ+ycnJKCsrw5o1a7QrzP7+/vD19cWuXbuwevVq5OXlQSKR4PHjx9ixYweOHz8OR0dHBAUFoaenB5aWlnOa788kJSUhPz8frq6uuHnzJvLy8rB+/XoAgKGhIa5fv46MjAzIZDIcPHgQJiYmePXqFfz9/eHo6AilUonTp08jPDxcr/tFR0cjKSkJCoUC9fX1/zh+IiKipeLk5ISKigrk5eUhNjZ2qcMh+u1IhBBiqYMgIpqNRCJBUVER/Pz8ljoUIiIiIqI54Yo3ERERERER0QJi4k1ERERERES0gHiqORH9K/CtGCIiIiL6t+KKNxEREREREdECYuJNREREREREtICYeBMREREREREtICbeRERERERERAuIiTcRERERERHRAmLiTURERERERLSAmHgTERERERERLSAm3kREREREREQL6D+IVTF2XeG/lgAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def show_attempts(dataset=\"langevin\", qts=0.45):\n", + " A = mp.attempts(DATA[dataset], qts, 0.0, False)\n", + " k, done = A[\"k\"], A[\"done\"]\n", + " p = mp.success_prob(k, done)\n", + " gp, _ = mp.geometric_test(k[done])\n", + " fig, axs = plt.subplots(1, 2, figsize=(10, 3.4))\n", + " kk = np.arange(k.max() + 1)\n", + " axs[0].bar(kk - 0.2, np.bincount(k, minlength=kk.size), width=0.4, label=\"observed\")\n", + " axs[0].bar(kk + 0.2, k.size * p * (1 - p) ** kk, width=0.4, label=f\"geometric(p={p:.2f})\")\n", + " axs[0].set_xlabel(\"failed attempts k\"); axs[0].set_ylabel(\"trajectories\")\n", + " axs[0].set_title(f\"Q‡={qts:.2f}: geometric test p = {gp:.3f}\" if np.isfinite(gp) else\n", + " f\"Q‡={qts:.2f}: too few distinct k to test\")\n", + " axs[0].legend()\n", + " axs[1].scatter(k + np.random.default_rng(0).uniform(-0.15, 0.15, k.size), A[\"T\"], s=10)\n", + " axs[1].set_xlabel(\"k\"); axs[1].set_ylabel(\"folding time T\")\n", + " axs[1].set_title(\"more failures ↔ longer folding times\")\n", + " plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_attempts,\n", + " static=[dict(dataset=\"langevin\", qts=q) for q in (0.4, 0.55)],\n", + " dataset=[\"langevin\", \"synthetic\"],\n", + " qts=(0.32, 0.78, 0.01) if HAVE_WIDGETS else None)" + ] + }, + { + "cell_type": "markdown", + "id": "f1b49990", + "metadata": {}, + "source": [ + "## 3. Reweighting: $w \\propto c^{k}$\n", + "\n", + "The MaxCal tilt multiplies the odds of every attempt by $e^{-\\lambda}$. For a trajectory with k failures this gives the weight $w \\propto c^{k+1}e^{-\\lambda}$ with $c = 1/[1-p(1-e^{-\\lambda})]$ (§2.3). Move λ and watch four things:\n", + "- **Weights.** They grow geometrically with k but **saturate** at $(1-p)^{-k}$ (dashed line).\n", + "- **N_eff.** It drops as the weight concentrates on a few trajectories.\n", + "- **CV on the Langevin data.** It *falls*: upweighting sums of more cycles makes the times more regular (§2.4).\n", + "- **CV on the synthetic data.** It crosses 1 at a finite λ*." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "dfe13647", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:20:58.916826Z", + "iopub.status.busy": "2026-09-18T17:20:58.916220Z", + "iopub.status.idle": "2026-09-18T17:20:59.803730Z", + "shell.execute_reply": "2026-09-18T17:20:59.802893Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "LAMS = np.linspace(0, 8, 161)\n", + "\n", + "def show_reweight(dataset=\"langevin\", qts=0.45, lam=1.0):\n", + " A = mp.attempts(DATA[dataset], qts, 0.0, False)\n", + " k, T, done = A[\"k\"], A[\"T\"], A[\"done\"]\n", + " p = mp.success_prob(k, done)\n", + " cv, neff = mp.cv_curve(LAMS, k, T, done, p)\n", + " lam_star = mp.first_crossing(LAMS, cv)\n", + " w = np.exp(mp.log_weights(lam, k, done, p)[0])\n", + "\n", + " fig, axs = plt.subplots(1, 3, figsize=(13, 3.6))\n", + " kk = np.arange(k.max() + 1)\n", + " wk = np.array([w[k == j].mean() / w[k == 0].mean() if np.any(k == j) else np.nan for j in kk])\n", + " axs[0].semilogy(kk, wk, \"o-\", label=f\"λ = {lam:.2f}\")\n", + " axs[0].semilogy(kk, (1 - p) ** -kk, \"k--\", lw=1, label=\"saturation (1−p)^−k\")\n", + " axs[0].set_xlabel(\"k\"); axs[0].set_ylabel(\"weight relative to k=0\"); axs[0].legend(fontsize=8)\n", + " axs[0].set_title(f\"p = {p:.2f}\")\n", + "\n", + " x = np.linspace(0, 5, 200)\n", + " for wt, lab in [(np.full(k.size, 1 / k.size), \"λ = 0\"), (w / w.sum(), f\"λ = {lam:.2f}\")]:\n", + " ts, Sv, _ = mp.weighted_km(T, done, wt)\n", + " tau = np.sum(wt * T) / np.sum(wt * done)\n", + " axs[1].step(np.r_[0, ts / tau], np.r_[1, Sv], where=\"post\", label=lab)\n", + " axs[1].semilogy(x, np.exp(-x), \"k--\", lw=1, label=\"exponential\")\n", + " axs[1].set_ylim(1e-2, 1.05); axs[1].set_xlim(0, 5)\n", + " axs[1].set_xlabel(\"t / ⟨t⟩\"); axs[1].set_ylabel(\"survival\"); axs[1].legend(fontsize=8)\n", + " axs[1].set_title(\"weighted Kaplan–Meier\")\n", + "\n", + " axs[2].plot(LAMS, cv, label=\"weighted CV\"); axs[2].axhline(1, color=\"k\", ls=\"--\", lw=1)\n", + " ax2 = axs[2].twinx(); ax2.plot(LAMS, neff, color=\"C2\", label=\"N_eff\"); ax2.set_ylabel(\"N_eff\", color=\"C2\")\n", + " axs[2].axvline(lam, color=\"C3\", lw=1)\n", + " if np.isfinite(lam_star):\n", + " axs[2].axvline(lam_star, color=\"C1\", ls=\":\", label=f\"λ* = {lam_star:.2f}\")\n", + " axs[2].set_xlabel(\"λ (kT)\"); axs[2].set_ylabel(\"CV\"); axs[2].legend(fontsize=8, loc=\"upper left\")\n", + " axs[2].set_title(\"λ* where CV = 1\" if np.isfinite(lam_star) else \"no root: CV never reaches 1\")\n", + " plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_reweight,\n", + " static=[dict(dataset=\"langevin\", lam=2.0), dict(dataset=\"synthetic\", lam=1.14)],\n", + " dataset=[\"langevin\", \"synthetic\"],\n", + " qts=(0.32, 0.78, 0.01) if HAVE_WIDGETS else None,\n", + " lam=(0.0, 8.0, 0.05) if HAVE_WIDGETS else None)" + ] + }, + { + "cell_type": "markdown", + "id": "d2774f64", + "metadata": {}, + "source": [ + "## 4. Stitching: sampling the tilted ensemble\n", + "\n", + "Instead of reweighting the observed trajectories, stitching builds new folding times. Each one is a geometric(p′) number of resampled failure cycles plus one resampled success segment (§2.5). Because the number of attempts is no longer limited to what was observed, the geometric tail of a higher barrier appears. By Rényi's theorem, CV → 1 as p′ → 0.\n", + "\n", + "The median KS p-value is computed on subsamples of the original size, so the test has the same power as on the data. Note that Poisson statistics emerge for *any* model with independent attempts once λ is large enough. That is why the Poisson threshold is only a lower bound on the tilt (§2.6)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f087cd9b", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:20:59.805272Z", + "iopub.status.busy": "2026-09-18T17:20:59.805120Z", + "iopub.status.idle": "2026-09-18T17:21:00.514206Z", + "shell.execute_reply": "2026-09-18T17:21:00.513407Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def show_stitch(dataset=\"langevin\", qts=0.45, lam=1.0, seed=0):\n", + " A = mp.attempts(DATA[dataset], qts, 0.0, False)\n", + " k, done = A[\"k\"], A[\"done\"]\n", + " p = mp.success_prob(k, done); pp = mp.tilted_p(p, lam)\n", + " rng = np.random.default_rng(seed)\n", + " if A[\"fail_pool\"].size == 0:\n", + " print(\"empty failure pool at this Q‡ (no failed attempts get past it)\"); return\n", + " t = mp.stitch(pp, A[\"fail_pool\"], A[\"succ_pool\"], 20000, rng)\n", + " sub = rng.choice(t, size=(200, k.size))\n", + " null = mp.null_D(k.size)\n", + " pv = (np.sum(null[None, :] >= mp.D_rows(sub)[:, None], axis=1) + 1) / (null.size + 1)\n", + "\n", + " fig, axs = plt.subplots(1, 2, figsize=(10, 3.6))\n", + " x = np.linspace(0, 5, 200)\n", + " T = A[\"T\"][done]; Ts = np.sort(T) / T.mean()\n", + " axs[0].step(Ts, 1 - np.arange(1, Ts.size + 1) / Ts.size, where=\"post\", label=\"original data\")\n", + " ts = np.sort(t) / t.mean()\n", + " axs[0].step(ts, 1 - np.arange(1, ts.size + 1) / ts.size, where=\"post\", label=f\"stitched, λ={lam:.2f}\")\n", + " axs[0].semilogy(x, np.exp(-x), \"k--\", lw=1, label=\"exponential\")\n", + " axs[0].set_ylim(1e-3, 1.05); axs[0].set_xlim(0, 5); axs[0].legend(fontsize=8)\n", + " axs[0].set_xlabel(\"t / ⟨t⟩\"); axs[0].set_ylabel(\"survival\")\n", + " axs[0].set_title(f\"p′ = {pp:.3f} CV = {t.std() / t.mean():.2f} median KS p = {np.median(pv):.2f}\")\n", + " kk = np.arange(0, 40)\n", + " axs[1].bar(kk, pp * (1 - pp) ** kk, label=\"tilted: geometric(p′)\")\n", + " axs[1].plot(kk, p * (1 - p) ** kk, \"k.-\", label=f\"model: geometric(p={p:.2f})\")\n", + " axs[1].set_xlabel(\"failed attempts k\"); axs[1].set_ylabel(\"probability\"); axs[1].legend(fontsize=8)\n", + " axs[1].set_title(\"number of attempts per folding event\")\n", + " plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_stitch,\n", + " static=[dict(lam=0.0), dict(lam=1.5)],\n", + " dataset=[\"langevin\", \"synthetic\"],\n", + " qts=(0.32, 0.78, 0.01) if HAVE_WIDGETS else None,\n", + " lam=(0.0, 6.0, 0.05) if HAVE_WIDGETS else None,\n", + " seed=(0, 20, 1) if HAVE_WIDGETS else None)" + ] + }, + { + "cell_type": "markdown", + "id": "bbfdfa1d", + "metadata": {}, + "source": [ + "## 5. Validation against a known answer\n", + "\n", + "Now the higher barrier is actually simulated. The **truth** is the same double well plus a Gaussian bump of height ΔB on the barrier top, so the basins are unchanged. This is exactly the assumption behind the tilt: correct sampling, underestimated barrier.\n", + "\n", + "For each Q‡, the **true** p′ is taken from the truth's own attempt statistics. Stitching the *model's* segments with that p′ should reproduce the truth's folding-time distribution. Move Q‡ to see where this works:\n", + "- **At the foot of the barrier (Q‡ ≈ 0.4):** stitched and true distributions agree.\n", + "- **On the barrier top (Q‡ ≈ 0.55):** the missing barrier also changes how often Q‡ is reached, and the prediction fails (§2.8).\n", + "\n", + "The panel title also shows the true λ next to ΔB. λ is an effective log-odds shift, not the barrier height (§2.7)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "849f8223", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:21:00.515910Z", + "iopub.status.busy": "2026-09-18T17:21:00.515358Z", + "iopub.status.idle": "2026-09-18T17:21:04.058030Z", + "shell.execute_reply": "2026-09-18T17:21:04.057198Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "KW = dict(dt=0.002, sigma=0.06, stride=10)\n", + "Qm, dtv = L.run_many(200, seed=1, dB=0.0, **KW)\n", + "VAL = {\"model\": to_trajs(Qm, dtv)}\n", + "for dB in (2.0, 3.0):\n", + " Qt, _ = L.run_many(200, seed=2, dB=dB, **KW)\n", + " VAL[dB] = to_trajs(Qt, dtv)\n", + "qq = np.linspace(0, 1, 400)\n", + "plt.figure(figsize=(5, 3))\n", + "for dB in (0.0, 2.0, 3.0):\n", + " plt.plot(qq, L.F_total(qq, dB=dB, sigma=0.06), label=f\"ΔB = {dB:g} kT\" if dB else \"model\")\n", + "plt.ylim(-0.5, 4.5); plt.xlabel(\"Q\"); plt.ylabel(\"F / kT\"); plt.legend(fontsize=8)\n", + "plt.title(\"model and ground-truth free energies\"); plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "b3e40b68", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:21:04.059717Z", + "iopub.status.busy": "2026-09-18T17:21:04.059230Z", + "iopub.status.idle": "2026-09-18T17:21:04.424379Z", + "shell.execute_reply": "2026-09-18T17:21:04.423532Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "def show_validation(dB=3.0, qts=0.40):\n", + " Am = mp.attempts(VAL[\"model\"], qts, 0.0, False)\n", + " At = mp.attempts(VAL[dB], qts, 0.0, False)\n", + " pm, pt = mp.success_prob(Am[\"k\"], Am[\"done\"]), mp.success_prob(At[\"k\"], At[\"done\"])\n", + " lam_true = np.log(pm / (1 - pm)) - np.log(pt / (1 - pt))\n", + " ts = mp.stitch(pt, Am[\"fail_pool\"], Am[\"succ_pool\"], 20000, np.random.default_rng(0))\n", + " Tt = At[\"T\"][At[\"done\"]]\n", + " fig, ax = plt.subplots(figsize=(6, 3.8))\n", + " for data, lab in [(Tt, f\"truth (ΔB = {dB:g} kT)\"), (ts, \"model stitched with true p′\")]:\n", + " s = np.sort(data)\n", + " ax.step(s, 1 - np.arange(1, s.size + 1) / s.size, where=\"post\", label=lab)\n", + " Tm = np.sort(Am[\"T\"][Am[\"done\"]])\n", + " ax.step(Tm, 1 - np.arange(1, Tm.size + 1) / Tm.size, where=\"post\", color=\"0.6\", label=\"model, uncorrected\")\n", + " ax.set_yscale(\"log\"); ax.set_ylim(1e-2, 1.05); ax.set_xlim(0, 1.2 * Tt.max())\n", + " ax.set_xlabel(\"folding time\"); ax.set_ylabel(\"survival\")\n", + " ax.set_title(f\"Q‡ = {qts:.2f}: mean ratio stitched/truth = {ts.mean() / Tt.mean():.2f}, \"\n", + " f\"KS p = {stats.ks_2samp(ts, Tt).pvalue:.2f}\\ntrue λ = {lam_true:.2f} kT \"\n", + " f\"(ΔB = {dB:g} kT)\", fontsize=9)\n", + " ax.legend(fontsize=8); plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_validation,\n", + " static=[dict(dB=3.0, qts=0.40), dict(dB=3.0, qts=0.55)],\n", + " dB=[2.0, 3.0],\n", + " qts=(0.32, 0.70, 0.01) if HAVE_WIDGETS else None)" + ] + }, + { + "cell_type": "markdown", + "id": "4adb747f", + "metadata": {}, + "source": [ + "## 6. Joint mode: forward and backward at the same temperature\n", + "\n", + "Here the double well is asymmetric (ΔG ≈ −0.6 kT). Forward runs start in A and stop in B; backward runs do the reverse. Two relations hold at equilibrium (README §6):\n", + "- **Kinetic ΔG equals equilibrium ΔG**: $-kT\\ln(M_{BA}/M_{AB}) = \\Delta G$.\n", + "- **Transition paths are time-reversal symmetric**: forward and backward durations have the same distribution.\n", + "\n", + "The temperature of the backward set is adjustable. At `Tr = 1` both relations hold. At `Tr > 1` the durations separate, which is how the script detects data wrongly declared as \"same temperature\"." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "a9918d1a", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-18T17:21:04.425819Z", + "iopub.status.busy": "2026-09-18T17:21:04.425616Z", + "iopub.status.idle": "2026-09-18T17:21:05.837482Z", + "shell.execute_reply": "2026-09-18T17:21:05.836363Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "POT = dict(B=1.0, tilt=-1.0, sigma=0.06)\n", + "KWJ = dict(dt=0.002, stride=10, **POT)\n", + "_Qf, dtj = L.run_many(150, 1, q0=0.2, **KWJ)\n", + "FWD = mj.direction(mj.build([(str(i), q, dtj, None) for i, q in enumerate(_Qf)], QU, QF, 1),\n", + " QU, QF, 0.4, 0.55, type(\"a\", (), dict(t0=0.0, include_initial=False))())\n", + "_BWD_CACHE = {}\n", + "\n", + "def show_joint(Tr=1.0):\n", + " key = round(Tr, 2)\n", + " if key not in _BWD_CACHE:\n", + " Qb, _ = L.run_many(150, 2, q0=0.9, stop_below=0.25, Tr=Tr, **KWJ)\n", + " _BWD_CACHE[key] = mj.direction(mj.build([(str(i), q, dtj, None) for i, q in enumerate(Qb)],\n", + " -QF, -QU, -1), -QF, -QU, -0.7, -0.55,\n", + " type(\"a\", (), dict(t0=0.0, include_initial=False))())\n", + " B = _BWD_CACHE[key]\n", + " dG_kin = -np.log(B[\"M0\"] / FWD[\"M0\"])\n", + " dG_eq = L.delta_G_eq(QU, QF, **POT)\n", + " ks = stats.ks_2samp(FWD[\"tp_dur\"], B[\"tp_dur\"]).pvalue\n", + " fig, ax = plt.subplots(figsize=(6, 3.6))\n", + " for D, lab in [(FWD, \"forward A→B\"), (B, f\"backward B→A (T×{Tr:g})\")]:\n", + " d = np.sort(D[\"tp_dur\"]); ax.step(d, np.arange(1, d.size + 1) / d.size, where=\"post\", label=lab)\n", + " ax.set_xlabel(\"transition-path duration\"); ax.set_ylabel(\"CDF\"); ax.legend(fontsize=8)\n", + " title = f\"TP symmetry KS p = {ks:.3f}\"\n", + " if Tr == 1.0:\n", + " title += f\"\\nkinetic ΔG = {dG_kin:.2f} kT, equilibrium ΔG = {dG_eq:.2f} kT\"\n", + " else:\n", + " title += \"\\n(different T: kinetic ΔG not defined)\"\n", + " ax.set_title(title, fontsize=9); plt.tight_layout(); plt.show()\n", + "\n", + "explore(show_joint, static=[dict(Tr=1.0), dict(Tr=1.5)],\n", + " Tr=[1.0, 1.25, 1.5, 2.0])" + ] + }, + { + "cell_type": "markdown", + "id": "d411ccfe", + "metadata": {}, + "source": [ + "## Where to go from here\n", + "\n", + "- Run the command-line tools on these datasets and compare their `summary.csv` or `joint_summary.json` with what you see here:\n", + " ```bash\n", + " python maxcal_poisson.py \"data/*.xvg\" --qu 0.3 --qf 0.8 --qts 0.4\n", + " ```\n", + "- Replace the Langevin trajectories with your own `Q(t)` files by loading them with `mp.load_traj` and `to_trajs`." + ] + } + ], + "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.12.3" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/pyproject.toml b/pyproject.toml index 44e10c1..2e141b2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -11,7 +11,8 @@ requires-python = ">=3.9" dependencies = ["numpy>=1.22", "scipy>=1.8", "matplotlib>=3.5"] [project.optional-dependencies] -test = ["pytest>=7"] +test = ["pytest>=7", "nbformat", "nbclient", "ipykernel"] +demo = ["jupyterlab", "ipywidgets>=8"] [project.scripts] maxcal-poisson = "maxcal_poisson:main" diff --git a/tests/regtest/reference_summary.csv b/tests/regtest/reference_summary.csv index ccc5623..6811836 100644 --- a/tests/regtest/reference_summary.csv +++ b/tests/regtest/reference_summary.csv @@ -1,6 +1,6 @@ -qts,N,n_done,sum_k,frac_k0,p,geom_p,lag1_rho,lag1_p,cv0,ks_p0,lam_star,lam_lo,lam_hi,boot_noroot,neff_star,ks_p_star,reweight_ok,cv_lammax,kmax,cv_stitch0,ksp_stitch0,lam_stitch,p_stitch,note -0.383333,100,100,286,0.21,0.259067,0.241822,-0.0816005,0.329201,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.540971,12,0.938403,0.0847288,0,0.259067, -0.466667,100,100,123,0.44,0.44843,0.914989,-0.0628215,0.70789,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.464694,8,0.884336,0.0366158,0.4,0.352741, -0.55,100,100,57,0.62,0.636943,0.475826,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.495261,4,0.876319,0.0228693,0.6,0.490531, -0.633333,100,100,25,0.77,0.8,nan,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.618446,2,0.765308,0.000249938,2.3,0.286242,failure pool <10: initial segments included -0.716667,100,100,11,0.89,0.900901,nan,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.649382,1,0.551963,0.000249938,3.35,0.24182,failure pool <10: initial segments included +qts,N,n_done,sum_k,frac_k0,p,geom_p,lag1_rho,lag1_p,cv0,ks_p0,lam_star,lam_lo,lam_hi,boot_noroot,neff_star,ks_p_star,reweight_ok,cv_lammax,kmax,cv_stitch0,ksp_stitch0,lam_stitch,p_stitch,geom_status,lag1_status,reweight_status,stitch_status,note +0.383333,100,100,286,0.21,0.259067,0.241822,-0.0816005,0.329201,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.540971,12,0.938403,0.0847288,0,0.259067,ok,ok,no_root,ok, +0.466667,100,100,123,0.44,0.44843,0.914989,-0.0628215,0.70789,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.464694,8,0.884336,0.0366158,0.4,0.352741,ok,ok,no_root,ok, +0.55,100,100,57,0.62,0.636943,0.475826,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.495261,4,0.876319,0.0228693,0.6,0.490531,ok,too_few_pairs,no_root,ok, +0.633333,100,100,25,0.77,0.8,nan,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.618446,2,0.765308,0.000249938,2.3,0.286242,too_few_bins,too_few_pairs,no_root,ok_pool_fallback,failure pool <10: initial segments included +0.716667,100,100,11,0.89,0.900901,nan,nan,nan,0.805936,0.00124969,nan,nan,nan,1,nan,nan,0,0.649382,1,0.551963,0.000249938,3.35,0.24182,too_few_bins,too_few_pairs,no_root,ok_pool_fallback,failure pool <10: initial segments included diff --git a/tests/synthetic.py b/tests/synthetic.py new file mode 100644 index 0000000..de53804 --- /dev/null +++ b/tests/synthetic.py @@ -0,0 +1,42 @@ +"""Hand-built first-passage trajectories with a controlled attempt structure. + +Used to exercise the reweighting path end to end: the population is chosen so that the +weighted CV of folding times starts below 1 and crosses 1 at a finite lambda with a +healthy effective sample size (lambda* ≈ 1.1 kT, N_eff ≈ 115 for the defaults), which +does not happen for the Langevin regression data. + + n0 trajectories with no failed attempt, folding time ≈ T0 + n3 trajectories with 3 failed attempts, folding time ≈ TS (short) or TL (long, fraction f) + +Up-weighting trajectories with more failures (the MaxCal tilt) shifts weight to the +over-dispersed k = 3 group, so the CV rises through 1. The construction is a test of +the code path, not a physical model. +""" +import os +import numpy as np + +Q_U, Q_EXC, Q_F = 0.1, 0.5, 0.9 # U basin, excursion level (fails), folded + + +def trajectory(k, T, b=2): + """Q(t) folding exactly at frame T with k failed excursions to Q_EXC. + Each failure is 2 frames at Q_EXC followed by b frames back in U.""" + a = T - 1 - k * (2 + b) + if a < 1: + raise ValueError("folding time too short for k failures") + q = [Q_U] * a + ([Q_EXC, Q_EXC] + [Q_U] * b) * k + [Q_EXC, Q_F] + return np.array(q) + + +def write_reweight_set(outdir, n0=200, n3=40, f=0.25, T0=50, TS=20, TL=200, seed=0): + rng = np.random.default_rng(seed) + os.makedirs(outdir, exist_ok=True) + nl = int(round(f * n3)) + specs = ([(0, T0 + int(rng.integers(-5, 6))) for _ in range(n0)] + + [(3, TS + int(rng.integers(-3, 4))) for _ in range(n3 - nl)] + + [(3, TL + int(rng.integers(-20, 21))) for _ in range(nl)]) + for i, (k, T) in enumerate(specs): + q = trajectory(k, T) + np.savetxt(os.path.join(outdir, f"s_{i:03d}.xvg"), + np.column_stack([np.arange(q.size, dtype=float), q]), fmt="%.6f") + return specs diff --git a/tests/test_notebook.py b/tests/test_notebook.py new file mode 100644 index 0000000..717dd7f --- /dev/null +++ b/tests/test_notebook.py @@ -0,0 +1,24 @@ +"""The demo notebook must run top to bottom (slow: pytest --runslow). +Executed in static mode (MAXCAL_DEMO_STATIC=1), exactly as the committed copy is rendered.""" +import os + +import pytest + +pytestmark = pytest.mark.slow + +nbformat = pytest.importorskip("nbformat") +nbclient = pytest.importorskip("nbclient") +pytest.importorskip("ipykernel") + +HERE = os.path.dirname(os.path.abspath(__file__)) +NB = os.path.join(HERE, os.pardir, "notebooks", "demo.ipynb") + + +def test_demo_notebook_executes(monkeypatch): + monkeypatch.setenv("MAXCAL_DEMO_STATIC", "1") + nb = nbformat.read(NB, as_version=4) + nbclient.NotebookClient(nb, timeout=600, kernel_name="python3", + resources={"metadata": {"path": os.path.dirname(NB)}}).execute() + n_fig = sum(1 for c in nb.cells if c.cell_type == "code" for o in c.outputs + if "data" in o and "image/png" in o["data"]) + assert n_fig >= 10 diff --git a/tests/test_regtest.py b/tests/test_regtest.py index a1f6a17..f97bf3b 100644 --- a/tests/test_regtest.py +++ b/tests/test_regtest.py @@ -25,6 +25,22 @@ "lam_star", "neff_star", "cv_lammax", "kmax"] # stochastic but seeded columns: loose tolerance, robust to RNG-algorithm changes LOOSE = {"cv_stitch0": 0.08, "lam_stitch": 0.5} +# reason codes for NaNs: must match exactly +STATUS = ["geom_status", "lag1_status", "reweight_status"] +# stitch_status depends on the stochastic pass/fail near the threshold only through +# "ok" vs "no_pass"; pool availability is deterministic +POOL_STATUS = "stitch_status" + + +def check_nan_reasons(row): + """Every NaN in a summary row must come with a non-ok reason code.""" + nan = lambda c: row[c] in ("", "nan") + assert nan("geom_p") == (row["geom_status"] != "ok"), row + assert nan("lag1_rho") == (row["lag1_status"] != "ok"), row + if nan("lam_star"): + assert row["reweight_status"] == "no_root", row + if nan("lam_stitch"): + assert row["stitch_status"] in ("empty_pool", "no_pass"), row def read(path): @@ -65,6 +81,8 @@ def test_physics_sanity(run): assert np.all(np.diff(p) > 0), "success probability must grow as Q‡ approaches Qf" ref = rows[len(rows) // 2] assert np.isfinite(as_float(ref["lam_stitch"])), "stitching must reach Poisson statistics" + for r in rows: + check_nan_reasons(r) tse = read(next(out.glob("tse_frames_qts*.csv"))) assert len(tse) == 100 assert sum(float(t["weight_at_lambda_star"]) for t in tse) == pytest.approx(1.0, abs=1e-4) @@ -84,6 +102,9 @@ def test_against_reference(run): for c in EXACT: np.testing.assert_allclose(as_float(g[c]), as_float(e[c]), rtol=1e-5, atol=1e-9, equal_nan=True, err_msg=f"{c} @ Q‡={e['qts']}") + for c in STATUS: + assert g[c] == e[c], f"{c} @ Q‡={e['qts']}: {g[c]} != {e[c]}" + assert (g[POOL_STATUS] == "empty_pool") == (e[POOL_STATUS] == "empty_pool") for c, tol in LOOSE.items(): np.testing.assert_allclose(as_float(g[c]), as_float(e[c]), atol=tol, equal_nan=True, err_msg=f"{c} @ Q‡={e['qts']}") diff --git a/tests/test_reweight_path.py b/tests/test_reweight_path.py new file mode 100644 index 0000000..3ae22e2 --- /dev/null +++ b/tests/test_reweight_path.py @@ -0,0 +1,81 @@ +"""End-to-end test of the reweighting path (finite lambda*), on hand-built trajectories +where the weighted CV crosses 1 (see synthetic.py). The Langevin regression data never +reach CV = 1, so without this test the finite-lambda* branch (bootstrap CI, N_eff, +KS at lambda*, TSE weights) would not be exercised end to end.""" +import csv +import subprocess +import sys + +import numpy as np +import pytest + +import maxcal_poisson as m +from synthetic import write_reweight_set +from test_regtest import SCRIPT, check_nan_reasons + +QU, QF, QTS = 0.3, 0.8, 0.45 + + +@pytest.fixture(scope="module") +def run(tmp_path_factory): + d = tmp_path_factory.mktemp("reweight") + specs = write_reweight_set(str(d / "data")) + out = d / "out" + r = subprocess.run([sys.executable, SCRIPT, str(d / "data" / "s_*.xvg"), + "--qu", str(QU), "--qf", str(QF), "--qts", str(QTS), "--nqts", "1", + "--boot", "100", "--nstitch", "1000", "--nsub", "50", "--seed", "3", + "--out", str(out)], capture_output=True, text=True) + assert r.returncode == 0, r.stderr + with open(out / "summary.csv") as fh: + rows = {round(float(x["qts"]), 3): x for x in csv.DictReader(fh)} + return out, rows, specs, d + + +def test_reweighting_succeeds(run): + _, rows, _, _ = run + r = rows[QTS] + assert r["reweight_status"] == "ok" and float(r["reweight_ok"]) == 1 + lam, lo, hi = float(r["lam_star"]), float(r["lam_lo"]), float(r["lam_hi"]) + assert 0.5 < lam < 2.0 + assert lo <= lam <= hi # bootstrap CI brackets the estimate + assert float(r["neff_star"]) >= 30 + assert 0.0 < float(r["ks_p_star"]) <= 1.0 + + +def test_weighted_cv_is_one_at_lambda_star(run): + _, rows, _, d = run + lam = float(rows[QTS]["lam_star"]) + trajs = [] + for path in sorted((d / "data").glob("s_*.xvg")): + q, dt = m.load_traj(str(path), None) + fold, fails = m.parse_traj(q, QU, QF) + trajs.append(dict(path=str(path), q=q, dt=dt, n=q.size, fold=fold, fails=fails)) + A = m.attempts(trajs, QTS, 0.0, False) + cv, _ = m.cv_curve(np.array([lam]), A["k"], A["T"], A["done"], + m.success_prob(A["k"], A["done"])) + assert cv[0] == pytest.approx(1.0, abs=0.02) # grid interpolation error only + + +def test_tse_weights_follow_the_tilt(run): + out, rows, _, _ = run + lam = float(rows[QTS]["lam_star"]) + with open(next(out.glob(f"tse_frames_qts{QTS:.3f}*.csv"))) as fh: + tse = list(csv.DictReader(fh)) + w = np.array([float(t["weight_at_lambda_star"]) for t in tse]) + k = np.array([int(t["k_failed"]) for t in tse]) + assert w.sum() == pytest.approx(1.0, abs=1e-4) + p = rows[QTS]["p"] + c = 1.0 / (1.0 - float(p) * (1.0 - np.exp(-lam))) + assert w[k == 3].mean() / w[k == 0].mean() == pytest.approx(c ** 3, rel=1e-3) + + +def test_statuses_explain_nans_beyond_attempts(run): + _, rows, _, _ = run + r = rows[0.55] # no excursion reaches 0.55: no attempts + assert r["geom_status"] == "too_few_bins" + assert r["lag1_status"] == "too_few_pairs" + assert r["reweight_status"] == "no_root" + assert r["stitch_status"] == "empty_pool" + assert rows[QTS]["lag1_status"] == "constant_cycles" # identical cycles by construction + for row in rows.values(): + check_nan_reasons(row) diff --git a/tests/test_unit.py b/tests/test_unit.py index 1ab37e0..f6df1a9 100644 --- a/tests/test_unit.py +++ b/tests/test_unit.py @@ -213,3 +213,21 @@ def test_load_one_column_needs_dt(tmp_path): with pytest.raises(SystemExit): m.load_traj(str(f), None) assert m.load_traj(str(f), 2.0)[1] == 2.0 + + +# ---------------------------------------------------------------- status flags +def test_status_flags(): + assert m.geom_status(5, 0.3) == "too_few_trajectories" + assert m.geom_status(50, np.nan) == "too_few_bins" + assert m.geom_status(50, 0.3) == "ok" + assert m.lag1_status(np.zeros((3, 2))) == "too_few_pairs" + assert m.lag1_status(np.ones((20, 2))) == "constant_cycles" + assert m.lag1_status(np.random.default_rng(0).random((20, 2))) == "ok" + assert m.reweight_status(1.2, 0.0, 100, 30) == "cv_ge_1_at_lambda0" + assert m.reweight_status(0.8, np.nan, np.nan, 30) == "no_root" + assert m.reweight_status(0.8, 1.0, 10, 30) == "low_neff" + assert m.reweight_status(0.8, 1.0, 100, 30) == "ok" + assert m.stitch_status(0.5, 0, 10, "") == "empty_pool" + assert m.stitch_status(np.nan, 10, 10, "") == "no_pass" + assert m.stitch_status(0.5, 10, 10, "success pool <10") == "ok_pool_fallback" + assert m.stitch_status(0.5, 10, 10, "") == "ok"