From 0c154cc10df0be28ea79e6af0734467d79708583 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 03:50:12 +0800 Subject: [PATCH 01/35] ci: qualify the frozen Linux consumer on a hosted runner --- .../openclaw-hosted-linux-consumer.yml | 187 ++++++++++++++++++ 1 file changed, 187 insertions(+) create mode 100644 .github/workflows/openclaw-hosted-linux-consumer.yml diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml new file mode 100644 index 0000000000000..c056060e1333e --- /dev/null +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -0,0 +1,187 @@ +name: OpenClaw hosted Linux consumer qualification + +on: + pull_request: + paths: + - .github/workflows/openclaw-hosted-linux-consumer.yml + workflow_dispatch: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-hosted-linux-consumer-${{ github.head_ref || github.ref }} + cancel-in-progress: true + +env: + SYNC_COMMIT: 42e4245f4180941634b482a7e8ef7fca47467de5 + CARRIER_COMMIT: ${{ github.event.pull_request.head.sha || github.sha }} + +jobs: + linux-native: + runs-on: ubuntu-24.04 + timeout-minutes: 360 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 42e4245f4180941634b482a7e8ef7fca47467de5 + fetch-depth: 1 + persist-credentials: false + sparse-checkout-cone-mode: false + sparse-checkout: | + /* + !/LayoutTests/ + !/JSTests/* + !/PerformanceTests/ + !/Websites/ + !/ManualTests/ + !/WebDriverTests/ + /JSTests/stress/ + /JSTests/modules/ + /JSTests/*.yaml + /JSTests/BUN-TEST-DIFFERENCES.md + - name: Make room for both independent cold builds + shell: bash + run: | + set -euo pipefail + export ARTIFACT_DIR="$RUNNER_TEMP/linux-artifact" QUALIFICATION_DIR="$RUNNER_TEMP/qualification" + echo "ARTIFACT_DIR=$ARTIFACT_DIR" >> "$GITHUB_ENV" + echo "QUALIFICATION_DIR=$QUALIFICATION_DIR" >> "$GITHUB_ENV" + sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc /usr/local/.ghcup /opt/hostedtoolcache /usr/local/share/boost /usr/share/swift /opt/microsoft + df -h / + python3 - <<'PY' + import json, os, shutil + from pathlib import Path + capacity = dict(cpus=os.cpu_count(), disk_free_bytes=shutil.disk_usage('.').free) + assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'paired cold builds need 40 GiB free' + Path(os.environ['QUALIFICATION_DIR']).mkdir() + Path(os.environ['QUALIFICATION_DIR'], 'carrier.json').write_text(json.dumps(dict( + carrier=os.environ['CARRIER_COMMIT'], sync=os.environ['SYNC_COMMIT'], + engine_artifact=13050907884, engine_run=41213533216, engine_attempt=2, + capacity=capacity), indent=2) + '\n') + PY + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.3.0' + - name: Admit the exact retained engine artifact + env: + GH_TOKEN: ${{ github.token }} + shell: bash + run: | + set -euo pipefail + gh api repos/openclaw/WebKit/actions/artifacts/13050907884 > "$RUNNER_TEMP/engine-artifact.json" + gh api repos/openclaw/WebKit/actions/artifacts/13050907884/zip > "$RUNNER_TEMP/engine.zip" + python3 - <<'PY' + import hashlib, json, os, shutil, stat, zipfile + from pathlib import Path, PurePosixPath + root = Path(os.environ['RUNNER_TEMP']) + artifact = json.loads((root / 'engine-artifact.json').read_text()) + digest = 'da8bbf2a08a5bff8d566b213a7e329f4103da4e627e05ff5c64c1576e9c06385' + assert artifact['id'] == 13050907884 and not artifact['expired'] + assert artifact['name'] == 'bun-webkit-linux-amd64' + assert artifact['workflow_run']['id'] == 41213533216 + assert artifact['workflow_run']['head_sha'] == os.environ['SYNC_COMMIT'] + assert artifact['size_in_bytes'] == (root / 'engine.zip').stat().st_size == 709332920 + assert artifact['digest'] == 'sha256:' + digest + with (root / 'engine.zip').open('rb') as stream: + assert hashlib.file_digest(stream, 'sha256').hexdigest() == digest + target = Path(os.environ['ARTIFACT_DIR']) + target.mkdir() + with zipfile.ZipFile(root / 'engine.zip') as archive: + entries = archive.infolist() + assert 0 < len(entries) <= 32 and sum(e.file_size for e in entries) <= 8 * 1024**3 + seen = set() + for entry in entries: + name = PurePosixPath(entry.filename) + assert len(name.parts) == 1 and name.name not in ('', '.', '..') and not name.is_absolute() + assert not entry.is_dir() and not stat.S_ISLNK(entry.external_attr >> 16) and name.name not in seen + seen.add(name.name) + with archive.open(entry) as source, (target / name.name).open('xb') as output: + shutil.copyfileobj(source, output) + from sys import path + path.insert(0, '.github/openclaw/qualification') + from consumer_identity import engine_input + engine_input(target / 'bun-webkit-linux-amd64.tar.gz', target / 'bun-webkit-linux-amd64.manifest.json', os.environ['SYNC_COMMIT']) + shutil.copyfile(root / 'engine-artifact.json', Path(os.environ['QUALIFICATION_DIR']) / 'engine-artifact.json') + (root / 'engine.zip').unlink() + PY + - name: Install the frozen Bun and JSC test tools + shell: bash + run: | + set -euo pipefail + curl -fsSL --retry 5 https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null + echo 'deb https://apt.llvm.org/noble/ llvm-toolchain-noble-23 main' | sudo tee /etc/apt/sources.list.d/llvm.list + sudo apt-get update -qq + sudo apt-get install -y --no-install-recommends cmake ninja-build nasm ccache golang-go clang-23 lld-23 llvm-23 unzip ruby ruby-highline libjson-pp-perl + rustup toolchain install nightly-2026-09-15 --profile minimal --component rust-src + echo 'RUSTUP_TOOLCHAIN=nightly-2026-09-15' >> "$GITHUB_ENV" + echo '/usr/lib/llvm-23/bin' >> "$GITHUB_PATH" + curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bun.zip" + unzip -q "$RUNNER_TEMP/bun.zip" -d "$RUNNER_TEMP/bootstrap" + echo "$RUNNER_TEMP/bootstrap/bun-linux-x64" >> "$GITHUB_PATH" + - name: Verify the unchanged pipeline contracts + shell: bash + run: | + set -euo pipefail + test "$(git rev-parse HEAD)" = "$SYNC_COMMIT" + python3 .github/openclaw/test_artifacts.py + python3 .github/openclaw/test_compare_fork_ci.py + python3 .github/openclaw/test_release.py + python3 .github/openclaw/test_consumer_identity.py + python3 .github/openclaw/test_verify_jsc_results.py + bash .github/openclaw/preflight.sh + - name: Qualify the exact frozen Bun pair with live build progress + shell: bash + run: | + set -euo pipefail + export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" + tail -n +1 -F "$QUALIFICATION_DIR/build-baseline.log" "$QUALIFICATION_DIR/build-candidate.log" & + tail_pid=$! + (while sleep 60; do date -u; free -m; df -h /; done) & + monitor_pid=$! + trap 'kill "$tail_pid" "$monitor_pid" 2>/dev/null || true' EXIT + bash .github/openclaw/qualify-engine.sh + bash .github/openclaw/qualify.sh + export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" + export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" + bash .github/openclaw/qualify-sync-compatibility.sh + bash .github/openclaw/qualify-sync.sh + - name: Retain the exact qualified Bun executables + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: hosted-linux-bun-executables + path: | + ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun + ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts + ${{ runner.temp }}/qualification/*.sha256 + compression-level: 0 + if-no-files-found: warn + retention-days: 3 + - name: Retain terminal or partial qualification evidence + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: hosted-linux-native-proof + path: | + ${{ runner.temp }}/qualification/*.json + ${{ runner.temp }}/qualification/*.log + ${{ runner.temp }}/qualification/*.sha256 + ${{ runner.temp }}/qualification/*.patch + ${{ runner.temp }}/qualification/candidate-input/artifacts.json + ${{ runner.temp }}/qualification/baseline/*.json + ${{ runner.temp }}/qualification/baseline/*.log + ${{ runner.temp }}/qualification/candidate/*.json + ${{ runner.temp }}/qualification/candidate/*.log + ${{ runner.temp }}/qualification/compatibility/*.log + ${{ runner.temp }}/qualification/sync/*.json + ${{ runner.temp }}/qualification/sync/*.xml + ${{ runner.temp }}/qualification/sync/*.log + ${{ runner.temp }}/qualification/jsc-*/results + ${{ runner.temp }}/qualification/jsc-stack/*.log + ${{ runner.temp }}/qualification/jsc-stack/*.json + ${{ runner.temp }}/qualification/sync/runtime-cache/*.json + if-no-files-found: error + retention-days: 7 From 4f3c924c6e29be27b902e285b1e82801dca81b21 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 03:58:46 +0800 Subject: [PATCH 02/35] fix(ci): admit wrapped retained engine artifacts --- .../openclaw-hosted-linux-consumer.yml | 19 +++++++++++++++---- 1 file changed, 15 insertions(+), 4 deletions(-) diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index c056060e1333e..16c6a91e91a7a 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -91,12 +91,23 @@ jobs: with zipfile.ZipFile(root / 'engine.zip') as archive: entries = archive.infolist() assert 0 < len(entries) <= 32 and sum(e.file_size for e in entries) <= 8 * 1024**3 - seen = set() + (Path(os.environ['QUALIFICATION_DIR']) / 'engine-zip-entries.json').write_text(json.dumps([ + {'path': e.filename, 'bytes': e.file_size, 'mode': e.external_attr >> 16, 'directory': e.is_dir()} + for e in entries + ], indent=2) + '\n') + seen_paths, seen_files = set(), set() for entry in entries: name = PurePosixPath(entry.filename) - assert len(name.parts) == 1 and name.name not in ('', '.', '..') and not name.is_absolute() - assert not entry.is_dir() and not stat.S_ISLNK(entry.external_attr >> 16) and name.name not in seen - seen.add(name.name) + parts = entry.filename.rstrip('/').split('/') + assert not name.is_absolute() and not any(p in ('', '.', '..') for p in parts) + assert '\\' not in entry.filename and '\x00' not in entry.filename and name not in seen_paths + seen_paths.add(name) + mode = stat.S_IFMT(entry.external_attr >> 16) + if entry.is_dir(): + assert mode in (0, stat.S_IFDIR) and entry.file_size == 0 + continue + assert mode in (0, stat.S_IFREG) and name.name not in seen_files + seen_files.add(name.name) with archive.open(entry) as source, (target / name.name).open('xb') as output: shutil.copyfileobj(source, output) from sys import path From 957180b67679841706f6aaa66ccf1794fcd77ef4 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 10:14:00 +0800 Subject: [PATCH 03/35] test(ci): diagnose retained Bun driver shutdown --- .../diagnose-retained-consumer.py | 222 ++++++++++++++++++ .../openclaw-retained-linux-diagnostic.yml | 79 +++++++ 2 files changed, 301 insertions(+) create mode 100644 .github/openclaw/qualification/diagnose-retained-consumer.py create mode 100644 .github/workflows/openclaw-retained-linux-diagnostic.yml diff --git a/.github/openclaw/qualification/diagnose-retained-consumer.py b/.github/openclaw/qualification/diagnose-retained-consumer.py new file mode 100644 index 0000000000000..9fbe4a2ad40f2 --- /dev/null +++ b/.github/openclaw/qualification/diagnose-retained-consumer.py @@ -0,0 +1,222 @@ +#!/usr/bin/env python3 +"""Diagnose the frozen consumer driver; this never emits a qualification gate.""" +import hashlib +import json +import os +from pathlib import Path, PurePosixPath +import shutil +import signal +import stat +import subprocess +import sys +import time +import zipfile + +SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" +CARRIER = "4f3c924c6e29be27b902e285b1e82801dca81b21" +RUN = 41236713193 +ARTIFACTS = { + "proof": (13065898437, 146231, "dee1f3532c401e3db86272aa0e8acace8dd0264b6b48ffa6f1617b53ebf8046c"), + "binaries": (13065868636, 181870231, "c66ce8b9176f6bb7bd71a35d879e1a9b9e8d800707aef79c3cce1fd7515b2275"), +} + + +def sha(path): + with path.open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +def unpack(root, name): + artifact, size, digest = ARTIFACTS[name] + metadata = read(root / (name + ".metadata.json")) + archive = root / (name + ".zip") + assert metadata["id"] == artifact and not metadata["expired"] + assert metadata["size_in_bytes"] == archive.stat().st_size == size + assert metadata["digest"] == "sha256:" + digest and sha(archive) == digest + assert metadata["workflow_run"]["id"] == RUN + assert metadata["workflow_run"]["head_sha"] == CARRIER + destination = root / name + destination.mkdir() + with zipfile.ZipFile(archive) as bundle: + entries = bundle.infolist() + assert 0 < len(entries) <= 128 and sum(x.file_size for x in entries) < 512 * 1024**2 + assert len({x.filename for x in entries}) == len(entries) + for entry in entries: + path = PurePosixPath(entry.filename) + assert not path.is_absolute() and "\\" not in entry.filename + assert all(p not in ("", ".", "..") for p in entry.filename.rstrip("/").split("/")) + mode = stat.S_IFMT(entry.external_attr >> 16) + assert mode in (0, stat.S_IFDIR if entry.is_dir() else stat.S_IFREG) + target = destination / path + if entry.is_dir(): + target.mkdir(parents=True, exist_ok=True) + else: + target.parent.mkdir(parents=True, exist_ok=True) + with bundle.open(entry) as source, target.open("xb") as output: + shutil.copyfileobj(source, output) + target.chmod(0o600) + return destination + + +def bounded(command, output, seconds, **kwargs): + with output.open("xb") as stream: + process = subprocess.Popen(command, stdout=stream, stderr=subprocess.STDOUT, + start_new_session=True, **kwargs) + try: + return process.wait(timeout=seconds) + except subprocess.TimeoutExpired: + return None + finally: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait(timeout=5) + + +def instrument(path): + text = path.read_text() + def replace(before, after): + nonlocal text + assert text.count(before) == 1, before + text = text.replace(before, after) + replace("readFileSync, rmSync, statfsSync, writeFileSync", "readFileSync, rmSync, statfsSync, writeFileSync, writeSync") + marker = "function diagnostic(stage: string, facts: unknown = null) { writeSync(2, JSON.stringify({diagnostic: stage, facts}) + \"\\n\"); }\n" + replace("// In 50 trials,", marker + "// In 50 trials,") + replace(" const kibibytes = Number.parseInt(usage.stdout, 10);", " diagnostic(\"du-return\", {name, pid: usage.pid, status: usage.status, signal: usage.signal, code: usage.error?.code, message: usage.error?.message});\n const kibibytes = Number.parseInt(usage.stdout, 10);") + replace(" writeFileSync(`build/openclaw-ci/disk-${stage}-tests.json`, JSON.stringify(snapshot, null, 2) + \"\\n\");", " diagnostic(\"before-disk-write\", stage);\n writeFileSync(`build/openclaw-ci/disk-${stage}-tests.json`, JSON.stringify(snapshot, null, 2) + \"\\n\");\n diagnostic(\"after-disk-write\", stage);") + replace(' { stdio: "inherit" },\n );', ' { stdio: "inherit" },\n );\n diagnostic("grouped-return", {pid: result.pid, status: result.status, signal: result.signal, code: result.error?.code, message: result.error?.message});') + replace(' direct = spawnSync(process.execPath, ["test", netTest], { encoding: "utf8" });', ' direct = spawnSync(process.execPath, ["test", netTest], { encoding: "utf8" });\n diagnostic("net-return", {pid: direct.pid, status: direct.status, signal: direct.signal, code: direct.error?.code, message: direct.error?.message});') + replace(' reportDiskUsage("after");', ' reportDiskUsage("after");\n diagnostic("before-terminal-write");') + replace(' if (ownerExitFailed) throw new Error', ' diagnostic("after-terminal-write");\n if (ownerExitFailed) throw new Error') + replace(' if (result.error) throw result.error;', ' diagnostic("before-error-check", {hasError: !!result.error});\n if (result.error) throw result.error;') + replace(' if (result.status !== 0) process.exit(result.status ?? 1);', ' if (result.status !== 0) { diagnostic("before-exit", result.status); process.exit(result.status ?? 1); diagnostic("exit-returned"); }') + replace(' assertSelectedTestResults(selected, results);', ' diagnostic("before-result-check");\n assertSelectedTestResults(selected, results);\n diagnostic("after-result-check");') + path.write_text(text) + return sha(path) + + +def main(): + root, frozen, repo, inspector = map(lambda x: Path(x).resolve(), sys.argv[1:]) + for key in ("GH_TOKEN", "GITHUB_TOKEN", "ACTIONS_RUNTIME_TOKEN", "ACTIONS_ID_TOKEN_REQUEST_TOKEN"): + os.environ.pop(key, None) + assert subprocess.check_output(["git", "-C", str(frozen), "rev-parse", "HEAD"], text=True).strip() == SYNC + inputs = frozen / ".github/openclaw/qualification" + sys.path.insert(0, str(inputs)) + import consumer_identity as identity + proof, binaries = unpack(root, "proof"), unpack(root, "binaries") + baseline, candidate = read(proof / "baseline-identity.json"), read(proof / "candidate-identity.json") + identity.validate_baseline_evidence(baseline, binaries, proof) + identity.validate_evidence(candidate, SYNC, candidate["engine"], binaries, proof) + identity.validate_invocation(proof, "baseline") + carrier = read(proof / "carrier.json") + assert carrier["carrier"] == CARRIER and carrier["sync"] == SYNC + pin = identity.CONFIG["candidate"] + assert subprocess.check_output(["git", "-C", str(repo), "rev-parse", "HEAD", "HEAD^{tree}"], text=True).splitlines() == [pin["commit"], pin["tree"]] + subprocess.run(["git", "-C", str(repo), "diff", "--exit-code", "HEAD"], check=True) + overlay = proof / "candidate-manifest.patch" + subprocess.run(["git", "-C", str(repo), "apply", "--check", str(overlay)], check=True) + subprocess.run(["git", "-C", str(repo), "apply", str(overlay)], check=True) + actual_overlay = subprocess.check_output(["git", "-C", str(repo), "diff", "--binary", "HEAD"]) + assert hashlib.sha256(actual_overlay).hexdigest() == candidate["overlay"]["patch_sha256"] + fixture = repo.parent / candidate["fixture"]["path"] + assert not fixture.exists() + shutil.copyfile(binaries / candidate["fixture"]["path"], fixture) + spec = identity.adapter_spec("candidate", "test") + for path, record in spec["files"].items(): + assert sha(repo / path) == record["before"] + patch = inputs / spec["patch"] + assert sha(patch) == spec["sha256"] + subprocess.run(["git", "-C", str(repo), "apply", "--check", str(patch)], check=True) + subprocess.run(["git", "-C", str(repo), "apply", str(patch)], check=True) + for path, record in spec["files"].items(): + assert sha(repo / path) == record["after"] + run = root / "diagnostic" + run.mkdir() + state = repo.parent / "candidate" + state.mkdir() + for name in ("home", "tmp", "bin"): + (state / name).mkdir(mode=0o700) + executable = repo.parent / candidate["executable"]["path"] + executable.parent.mkdir(parents=True) + shutil.copyfile(binaries / candidate["executable"]["path"], executable) + assert sha(executable) == candidate["executable"]["sha256"] + executable.chmod(0o700) + (state / "bin/bun").symlink_to(executable) + selection = inputs / "selected.json" + assert selection.read_bytes() == (proof / "candidate/selected.json").read_bytes() + target = repo / "build/openclaw-ci" + target.mkdir(parents=True) + shutil.copyfile(selection, target / "selected.json") + driver = repo / "scripts/openclaw-ci/tests.ts" + before, after = sha(driver), instrument(driver) + env = os.environ.copy() + for key in ("GH_TOKEN", "GITHUB_TOKEN", *identity.BUILD_ENV): + env.pop(key, None) + env.update(HOME=str(state / "home"), TMPDIR=str(state / "tmp"), CI="1", PUPPETEER_SKIP_DOWNLOAD="1", + PATH=str(state / "bin") + os.pathsep + str(inspector.parent) + os.pathsep + env["PATH"], + OPENCLAW_CI_PLATFORM="linux") + assert not any(key in env for key in ("GH_TOKEN", "GITHUB_TOKEN")) + status = {"qualification": False, "source": SYNC, "reused_run": RUN, + "binary": candidate["executable"], "driver_before_sha256": before, + "driver_instrumented_sha256": after, "deadline_seconds": 600} + bootstrap = read(proof / "candidate-build-tools.json")["bootstrap"] + assert inspector.stat().st_size == bootstrap["size"] and sha(inspector) == bootstrap["sha256"] + # The installed inspector only prepares dependencies; the retained candidate runs the failing driver. + install_env = os.environ.copy() + install_env.update(CI="1", PUPPETEER_SKIP_DOWNLOAD="1", + PATH=str(inspector.parent) + os.pathsep + install_env["PATH"]) + for folder in (repo, repo / "test"): + assert bounded([str(inspector), "install", "--frozen-lockfile"], + run / ("install-root.log" if folder == repo else "install-test.log"), + 180, cwd=folder, env=install_env) == 0 + assert identity.runtime(executable) == candidate["runtime"] + log = run / "driver.log" + with log.open("xb") as stream: + process = subprocess.Popen([str(executable), "scripts/openclaw-ci/tests.ts", "test"], + cwd=repo, env=env, stdout=stream, stderr=subprocess.STDOUT, + start_new_session=True) + started = time.monotonic() + try: + while process.poll() is None and time.monotonic() - started < 600: + if log.stat().st_size >= 32 * 1024**2: + status["output_limit_reached"] = True + break + if int(time.monotonic() - started) % 10 == 0: + print(json.dumps({"elapsed_seconds": int(time.monotonic() - started), "log_bytes": log.stat().st_size}), flush=True) + time.sleep(1) + status.update(pid=process.pid, elapsed_seconds=round(time.monotonic() - started, 2), + returncode=process.poll(), timed_out=process.poll() is None) + if process.poll() is None: + rows = subprocess.check_output(["ps", "-eo", "pid,ppid,pgid,stat,wchan:32,comm"], text=True) + owned = [line for line in rows.splitlines()[1:] if line.split()[2] == str(process.pid)] + (run / "processes.txt").write_text("\n".join(owned) + "\n") + bounded(["sudo", "-n", "gdb", "--nx", "--nh", "--batch", "-iex", "set auto-load off", + "-iex", "set debuginfod enabled off", "-ex", "attach " + str(process.pid), + "-ex", "thread apply all bt 20", "-ex", "detach"], run / "stacks.log", 20) + if process.poll() is None: + bounded(["sudo", "-n", "strace", "-tt", "-T", "-p", str(process.pid), + "-e", "trace=process,futex,write,exit,exit_group"], run / "syscalls.log", 10) + finally: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait(timeout=5) + status["cleanup_returncode"] = process.returncode + for name in ("results.json", "runner-terminal.json", "net-direct.json", "disk-before-tests.json", "disk-after-tests.json"): + path = target / name + if path.exists(): + assert path.is_file() and not path.is_symlink() and path.stat().st_size <= 16 * 1024**2 + shutil.copyfile(path, run / name) + (run / "diagnostic.json").write_text(json.dumps(status, indent=2) + "\n") + print(json.dumps(status), flush=True) + return int(status["timed_out"] or status["returncode"] != 0) + + +if __name__ == "__main__": + raise SystemExit(main()) diff --git a/.github/workflows/openclaw-retained-linux-diagnostic.yml b/.github/workflows/openclaw-retained-linux-diagnostic.yml new file mode 100644 index 0000000000000..ae9d7fd6824f6 --- /dev/null +++ b/.github/workflows/openclaw-retained-linux-diagnostic.yml @@ -0,0 +1,79 @@ +name: OpenClaw retained Linux consumer diagnostic + +on: + pull_request: + paths: + - .github/workflows/openclaw-retained-linux-diagnostic.yml + - .github/openclaw/qualification/diagnose-retained-consumer.py + workflow_dispatch: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-retained-linux-diagnostic-${{ github.head_ref || github.ref }} + cancel-in-progress: true + +jobs: + retained-driver: + runs-on: ubuntu-24.04 + timeout-minutes: 35 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: ${{ github.event.pull_request.head.sha || github.sha }} + path: carrier + persist-credentials: false + sparse-checkout: .github/openclaw/qualification/diagnose-retained-consumer.py + sparse-checkout-cone-mode: false + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 42e4245f4180941634b482a7e8ef7fca47467de5 + path: frozen + persist-credentials: false + sparse-checkout: .github/openclaw + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.3.0' + - name: Prepare the isolated diagnostic tools and frozen source + timeout-minutes: 10 + shell: bash + run: | + set -euo pipefail + sudo apt-get update -qq + sudo apt-get install -y --no-install-recommends gdb strace unzip + curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bootstrap.zip" + unzip -q "$RUNNER_TEMP/bootstrap.zip" -d "$RUNNER_TEMP/bootstrap" + mkdir "$RUNNER_TEMP/qualification" + git clone --depth=1 --filter=blob:none --no-checkout https://github.com/openclaw/bun.git "$RUNNER_TEMP/qualification/bun" + git -C "$RUNNER_TEMP/qualification/bun" fetch --depth=1 origin 7b573c05d0c52dffc67d4d25daf108bed5930cf2 + git -C "$RUNNER_TEMP/qualification/bun" checkout --detach 7b573c05d0c52dffc67d4d25daf108bed5930cf2 + mkdir "$RUNNER_TEMP/retained" + - name: Download the exact retained build evidence + timeout-minutes: 5 + env: + GH_TOKEN: ${{ github.token }} + shell: bash + run: | + set -euo pipefail + gh api repos/openclaw/WebKit/actions/artifacts/13065898437 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13065898437/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13065868636 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13065868636/zip > "$RUNNER_TEMP/retained/binaries.zip" + - name: Diagnose the original driver with an external deadline + timeout-minutes: 18 + shell: bash + run: | + set -euo pipefail + python3 carrier/.github/openclaw/qualification/diagnose-retained-consumer.py \ + "$RUNNER_TEMP/retained" "$GITHUB_WORKSPACE/frozen" "$RUNNER_TEMP/qualification/bun" \ + "$RUNNER_TEMP/bootstrap/bun-linux-x64/bun" + - name: Retain diagnostic facts and raw driver reports + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: retained-linux-consumer-diagnostic + path: ${{ runner.temp }}/retained/diagnostic/ + if-no-files-found: error + retention-days: 7 From aacd6676856b956693633f9d96c123e9454bd0db Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 10:42:14 +0800 Subject: [PATCH 04/35] fix(ci): qualify synced Bun with aligned JSC type tags --- .../qualification/consumer-repair.json | 10 + .../qualification/harness-adapters.json | 15 +- .../harness-adapters/candidate-build.patch | 400 +++++++++++++++++- .../harness-adapters/candidate-test.patch | 35 ++ .../qualification/harness_adapters.py | 22 +- .../openclaw/qualification/resume-consumer.py | 116 +++++ .../openclaw-hosted-linux-consumer.yml | 43 +- 7 files changed, 628 insertions(+), 13 deletions(-) create mode 100644 .github/openclaw/qualification/consumer-repair.json create mode 100644 .github/openclaw/qualification/resume-consumer.py diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json new file mode 100644 index 0000000000000..9b813c08309d5 --- /dev/null +++ b/.github/openclaw/qualification/consumer-repair.json @@ -0,0 +1,10 @@ +{ + "source": "6e0c032a394820b65278943bd3a4e793718a97ca", + "engine": "42e4245f4180941634b482a7e8ef7fca47467de5", + "files": { + "harness-adapters.json": "6f2b04e36ceecae3b28616ab55a283a99c5d213e04bb427e8ef29e1fdf7ec623", + "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", + "harness-adapters/candidate-build.patch": "6d67a4027df0f3081443c2348ac27efd73f786035ea38c02f2b41eeb0138e928", + "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7" + } +} diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index 8822f8c3d63d0..245b925dee7a7 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -55,7 +55,7 @@ "build": { "kind": "source-compatibility", "patch": "harness-adapters/candidate-build.patch", - "sha256": "0482c437365d3606b14c9b35222515a6cf3ad95fa0b16d71e4829280e7c1bf53", + "sha256": "6d67a4027df0f3081443c2348ac27efd73f786035ea38c02f2b41eeb0138e928", "compiled_inputs": [ "src/codegen/bindgen-lib-internal.ts", "src/codegen/bundle-functions.ts", @@ -87,9 +87,9 @@ }, "src/jsc/JSType.rs": { "before": "03b74867c3243546a3acd61973f2134ff825e0157f3b5ce4de35b893e9afcccb", - "after": "3fedf23e63bbcc52553e787bae0d88a97c6d1fa52215191549df7970a76863a6", + "after": "e9badcd3834d1a2137e53699d2e3b335a0cd7d2ef6b42b7ce1c10de61f11b4bc", "base_blob": "3c21ec7b288db26eafad93dd9077d42cc9bfec46", - "adapted_blob": "c8fae978d69b55f9c63a7bbb7ea23642ce6e05fc", + "adapted_blob": "ee36a5470003064084496fb262a1daabb032f907", "mode": "100644" }, "src/jsc/JSValue.rs": { @@ -166,7 +166,7 @@ }, "test": { "patch": "harness-adapters/candidate-test.patch", - "sha256": "016e80ad52598b03184070789eb9cfa44321c74cbd03a0089042c11325a1457b", + "sha256": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", "files": { "scripts/buildkite.ts": { "before": "cf1999381cf38d34b9892118266614ae2b81a28066d47a455aa15794fb2c1c3e", @@ -188,6 +188,13 @@ "base_blob": "6507f885c1cdfdf8937574946d6959fa898a4345", "adapted_blob": "5ce950bee35def7156a1ee7f5d1ac6230c812d2f", "mode": "100644" + }, + "test/js/node/child_process/child-process-stdio.test.js": { + "before": "bab89f856c2ccc709474b47854fc85c6b54e3091e0cebdf7a2e841f2efd7d767", + "after": "bd621b307c23839d594d961ccb5e591731c451111f5244bfdf696fde11d9f893", + "base_blob": "361d675936e9694835956eebbd9b4256f8b9e5e3", + "adapted_blob": "7e448388ceb3dc10781b55f1df4e72d10f8637c3", + "mode": "100644" } } } diff --git a/.github/openclaw/qualification/harness-adapters/candidate-build.patch b/.github/openclaw/qualification/harness-adapters/candidate-build.patch index 75a89704e80be..7de50462b519c 100644 --- a/.github/openclaw/qualification/harness-adapters/candidate-build.patch +++ b/.github/openclaw/qualification/harness-adapters/candidate-build.patch @@ -53,7 +53,7 @@ index 9c991a68c09a9f9d36238805efc9d19ece9b70cd..91a4ac13a680ec4207a2ac19fb9d8f35 WEBCORE_FOREACH_${basename.toUpperCase()}_BUILTIN_CODE(DECLARE_BUILTIN_GENERATOR) #undef DECLARE_BUILTIN_GENERATOR diff --git a/src/jsc/JSType.rs b/src/jsc/JSType.rs -index 3c21ec7b288db26eafad93dd9077d42cc9bfec46..c8fae978d69b55f9c63a7bbb7ea23642ce6e05fc 100644 +index 3c21ec7b288db26eafad93dd9077d42cc9bfec46..ee36a5470003064084496fb262a1daabb032f907 100644 --- a/src/jsc/JSType.rs +++ b/src/jsc/JSType.rs @@ -36,7 +36,7 @@ @@ -65,6 +65,404 @@ index 3c21ec7b288db26eafad93dd9077d42cc9bfec46..c8fae978d69b55f9c63a7bbb7ea23642 //! • null/undefined → immediate values //! //! JavaScript Objects → JSType: +@@ -100,6 +100,7 @@ use crate::array_buffer::TypedArrayType; + #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, core::marker::ConstParamTy)] + pub struct JSType(pub u8); + ++// These discriminants must match JavaScriptCore/runtime/JSType.h in the selected engine. + #[allow(non_upper_case_globals)] + impl JSType { + /// Base type for all JavaScript values that are heap-allocated. +@@ -210,15 +211,15 @@ impl JSType { + /// {} + /// new Object() + /// ``` +- pub const Object: JSType = JSType(33); ++ pub const Object: JSType = JSType(34); + + /// Optimized object type for object literals with fixed properties. + /// ```js + /// { a: 1, b: 2 } + /// ``` +- pub const FinalObject: JSType = JSType(34); ++ pub const FinalObject: JSType = JSType(35); + +- pub const JSCallee: JSType = JSType(35); ++ pub const JSCallee: JSType = JSType(36); + + /// JavaScript function object created from JavaScript source code. + /// ```js +@@ -228,7 +229,7 @@ impl JSType { + /// method() {} + /// } + /// ``` +- pub const JSFunction: JSType = JSType(36); ++ pub const JSFunction: JSType = JSType(37); + + /// Built-in function implemented in native code. + /// ```js +@@ -237,21 +238,21 @@ impl JSType { + /// parseInt + /// console.log + /// ``` +- pub const InternalFunction: JSType = JSType(37); ++ pub const InternalFunction: JSType = JSType(39); + + /// Boxed Boolean object. + /// ```js + /// new Boolean(true) + /// new Boolean(false) + /// ``` +- pub const BooleanObject: JSType = JSType(39); ++ pub const BooleanObject: JSType = JSType(41); + + /// Boxed Number object. + /// ```js + /// new Number(42) + /// new Number(3.14) + /// ``` +- pub const NumberObject: JSType = JSType(40); ++ pub const NumberObject: JSType = JSType(42); + + /// JavaScript Error object and its subclasses. + /// ```js +@@ -259,9 +260,9 @@ impl JSType { + /// new TypeError() + /// throw new RangeError() + /// ``` +- pub const ErrorInstance: JSType = JSType(41); ++ pub const ErrorInstance: JSType = JSType(43); + +- pub const GlobalProxy: JSType = JSType(42); ++ pub const GlobalProxy: JSType = JSType(44); + + /// Arguments object for function parameters. + /// ```js +@@ -270,10 +271,10 @@ impl JSType { + /// console.log(arguments.length); + /// } + /// ``` +- pub(crate) const DirectArguments: JSType = JSType(43); ++ pub(crate) const DirectArguments: JSType = JSType(45); + +- pub(crate) const ScopedArguments: JSType = JSType(44); +- pub(crate) const ClonedArguments: JSType = JSType(45); ++ pub(crate) const ScopedArguments: JSType = JSType(46); ++ pub(crate) const ClonedArguments: JSType = JSType(47); + + /// JavaScript Array object. + /// ```js +@@ -282,94 +283,94 @@ impl JSType { + /// new Array(10) + /// Array.from(iterable) + /// ``` +- pub const Array: JSType = JSType(46); ++ pub const Array: JSType = JSType(48); + + /// Array subclass created through class extension. + /// ```js + /// class MyArray extends Array {} + /// const arr = new MyArray(); + /// ``` +- pub const DerivedArray: JSType = JSType(47); ++ pub const DerivedArray: JSType = JSType(49); + + /// ArrayBuffer for binary data storage. + /// ```js + /// new ArrayBuffer(1024) + /// ``` +- pub const ArrayBuffer: JSType = JSType(48); ++ pub const ArrayBuffer: JSType = JSType(50); + + /// Typed array for 8-bit signed integers. + /// ```js + /// new Int8Array(buffer) + /// new Int8Array([1, -1, 127]) + /// ``` +- pub const Int8Array: JSType = JSType(49); ++ pub const Int8Array: JSType = JSType(51); + + /// Typed array for 8-bit unsigned integers. + /// ```js + /// new Uint8Array(buffer) + /// new Uint8Array([0, 255]) + /// ``` +- pub const Uint8Array: JSType = JSType(50); ++ pub const Uint8Array: JSType = JSType(52); + + /// Typed array for 8-bit unsigned integers with clamping. + /// ```js + /// new Uint8ClampedArray([0, 300]) // 300 becomes 255 + /// ``` +- pub const Uint8ClampedArray: JSType = JSType(51); ++ pub const Uint8ClampedArray: JSType = JSType(53); + + /// Typed array for 16-bit signed integers. + /// ```js + /// new Int16Array(buffer) + /// ``` +- pub const Int16Array: JSType = JSType(52); ++ pub const Int16Array: JSType = JSType(54); + + /// Typed array for 16-bit unsigned integers. + /// ```js + /// new Uint16Array(buffer) + /// ``` +- pub const Uint16Array: JSType = JSType(53); ++ pub const Uint16Array: JSType = JSType(55); + + /// Typed array for 32-bit signed integers. + /// ```js + /// new Int32Array(buffer) + /// ``` +- pub const Int32Array: JSType = JSType(54); ++ pub const Int32Array: JSType = JSType(56); + + /// Typed array for 32-bit unsigned integers. + /// ```js + /// new Uint32Array(buffer) + /// ``` +- pub const Uint32Array: JSType = JSType(55); ++ pub const Uint32Array: JSType = JSType(57); + + /// Typed array for 16-bit floating point numbers. + /// ```js + /// new Float16Array(buffer) + /// ``` +- pub const Float16Array: JSType = JSType(56); ++ pub const Float16Array: JSType = JSType(58); + + /// Typed array for 32-bit floating point numbers. + /// ```js + /// new Float32Array(buffer) + /// ``` +- pub const Float32Array: JSType = JSType(57); ++ pub const Float32Array: JSType = JSType(59); + + /// Typed array for 64-bit floating point numbers. + /// ```js + /// new Float64Array(buffer) + /// ``` +- pub const Float64Array: JSType = JSType(58); ++ pub const Float64Array: JSType = JSType(60); + + /// Typed array for 64-bit signed BigInt values. + /// ```js + /// new BigInt64Array([123n, -456n]) + /// ``` +- pub const BigInt64Array: JSType = JSType(59); ++ pub const BigInt64Array: JSType = JSType(61); + + /// Typed array for 64-bit unsigned BigInt values. + /// ```js + /// new BigUint64Array([123n, 456n]) + /// ``` +- pub const BigUint64Array: JSType = JSType(60); ++ pub const BigUint64Array: JSType = JSType(62); + + /// DataView for flexible binary data access. + /// ```js +@@ -377,7 +378,7 @@ impl JSType { + /// view.getInt32(0) + /// view.setFloat64(8, 3.14) + /// ``` +- pub const DataView: JSType = JSType(61); ++ pub const DataView: JSType = JSType(63); + + /// Global object containing all global variables and functions. + /// ```js +@@ -385,12 +386,12 @@ impl JSType { + /// window // in browsers + /// global // in Node.js + /// ``` +- pub const GlobalObject: JSType = JSType(62); ++ pub const GlobalObject: JSType = JSType(64); + +- pub const GlobalLexicalEnvironment: JSType = JSType(63); +- pub const LexicalEnvironment: JSType = JSType(64); +- pub const ModuleEnvironment: JSType = JSType(65); +- pub const StrictEvalActivation: JSType = JSType(66); ++ pub const GlobalLexicalEnvironment: JSType = JSType(65); ++ pub const LexicalEnvironment: JSType = JSType(66); ++ pub const ModuleEnvironment: JSType = JSType(67); ++ pub const StrictEvalActivation: JSType = JSType(68); + + /// Scope object for with statements. + /// ```js +@@ -398,16 +399,16 @@ impl JSType { + /// prop; // looks up prop in obj first + /// } + /// ``` +- pub const WithScope: JSType = JSType(67); ++ pub const WithScope: JSType = JSType(69); + + /// Namespace object for ES6 modules. + /// ```js + /// import * as ns from 'module'; + /// ns.exportedFunction() + /// ``` +- pub const ModuleNamespaceObject: JSType = JSType(70); ++ pub const ModuleNamespaceObject: JSType = JSType(72); + +- pub(crate) const ShadowRealm: JSType = JSType(71); ++ pub(crate) const ShadowRealm: JSType = JSType(73); + + /// Regular expression object. + /// ```js +@@ -415,7 +416,7 @@ impl JSType { + /// new RegExp('pattern', 'flags') + /// /abc/gi + /// ``` +- pub const RegExpObject: JSType = JSType(72); ++ pub const RegExpObject: JSType = JSType(74); + + /// JavaScript Date object for date/time operations. + /// ```js +@@ -423,7 +424,7 @@ impl JSType { + /// new Date('2023-01-01') + /// Date.now() + /// ``` +- pub const JSDate: JSType = JSType(73); ++ pub const JSDate: JSType = JSType(75); + + /// Proxy object that intercepts operations on another object. + /// ```js +@@ -431,7 +432,7 @@ impl JSType { + /// get(obj, prop) { return obj[prop]; } + /// }) + /// ``` +- pub const ProxyObject: JSType = JSType(74); ++ pub const ProxyObject: JSType = JSType(76); + + /// Generator object created by generator functions. + /// ```js +@@ -439,7 +440,7 @@ impl JSType { + /// const g = gen(); + /// g.next() + /// ``` +- pub(crate) const Generator: JSType = JSType(75); ++ pub(crate) const Generator: JSType = JSType(77); + + /// Async generator object for asynchronous iteration. + /// ```js +@@ -447,17 +448,17 @@ impl JSType { + /// yield await promise; + /// } + /// ``` +- pub(crate) const AsyncGenerator: JSType = JSType(77); ++ pub(crate) const AsyncGenerator: JSType = JSType(79); + + /// Iterator for Array objects. + /// ```js + /// [1,2,3][Symbol.iterator]() + /// for (const x of array) {} + /// ``` +- pub(crate) const JSArrayIterator: JSType = JSType(78); ++ pub(crate) const JSArrayIterator: JSType = JSType(80); + +- pub(crate) const Iterator: JSType = JSType(79); +- pub(crate) const IteratorHelper: JSType = JSType(80); ++ pub(crate) const Iterator: JSType = JSType(81); ++ pub(crate) const IteratorHelper: JSType = JSType(82); + + /// Iterator for Map objects. + /// ```js +@@ -466,30 +467,30 @@ impl JSType { + /// map.entries() + /// for (const [k,v] of map) {} + /// ``` +- pub(crate) const MapIterator: JSType = JSType(81); ++ pub(crate) const MapIterator: JSType = JSType(83); + + /// Iterator for Set objects. + /// ```js + /// set.values() + /// for (const value of set) {} + /// ``` +- pub(crate) const SetIterator: JSType = JSType(82); ++ pub(crate) const SetIterator: JSType = JSType(84); + + /// Iterator for String objects. + /// ```js + /// 'hello'[Symbol.iterator]() + /// for (const char of string) {} + /// ``` +- pub(crate) const StringIterator: JSType = JSType(83); ++ pub(crate) const StringIterator: JSType = JSType(85); + +- pub(crate) const WrapForValidIterator: JSType = JSType(84); ++ pub(crate) const WrapForValidIterator: JSType = JSType(86); + + /// Iterator for RegExp string matching. + /// ```js + /// 'abc'.matchAll(/./g) + /// for (const match of string.matchAll(regex)) {} + /// ``` +- pub(crate) const RegExpStringIterator: JSType = JSType(85); ++ pub(crate) const RegExpStringIterator: JSType = JSType(87); + + /// JavaScript Promise object for asynchronous operations. + /// ```js +@@ -497,7 +498,7 @@ impl JSType { + /// Promise.resolve(42) + /// async function foo() { await promise; } + /// ``` +- pub const JSPromise: JSType = JSType(87); ++ pub const JSPromise: JSType = JSType(89); + + /// JavaScript Map object for key-value storage. + /// ```js +@@ -505,7 +506,7 @@ impl JSType { + /// map.set(key, value) + /// map.get(key) + /// ``` +- pub const Map: JSType = JSType(88); ++ pub const Map: JSType = JSType(90); + + /// JavaScript Set object for unique value storage. + /// ```js +@@ -513,33 +514,33 @@ impl JSType { + /// set.add(value) + /// set.has(value) + /// ``` +- pub const Set: JSType = JSType(89); ++ pub const Set: JSType = JSType(91); + + /// WeakMap for weak key-value references. + /// ```js + /// new WeakMap() + /// weakMap.set(object, value) + /// ``` +- pub const WeakMap: JSType = JSType(90); ++ pub const WeakMap: JSType = JSType(92); + + /// WeakSet for weak value references. + /// ```js + /// new WeakSet() + /// weakSet.add(object) + /// ``` +- pub const WeakSet: JSType = JSType(91); ++ pub const WeakSet: JSType = JSType(93); + +- pub(crate) const WebAssemblyModule: JSType = JSType(92); +- pub(crate) const WebAssemblyInstance: JSType = JSType(93); +- pub(crate) const WebAssemblyGCObject: JSType = JSType(94); ++ pub(crate) const WebAssemblyModule: JSType = JSType(94); ++ pub(crate) const WebAssemblyInstance: JSType = JSType(95); ++ pub(crate) const WebAssemblyGCObject: JSType = JSType(96); + + /// Boxed String object. + /// ```js + /// new String("hello") + /// ``` +- pub const StringObject: JSType = JSType(95); ++ pub const StringObject: JSType = JSType(100); + +- pub const DerivedStringObject: JSType = JSType(96); ++ pub const DerivedStringObject: JSType = JSType(101); + + pub const Event: JSType = JSType(0b11101111); + pub const DOMWrapper: JSType = JSType(0b11101110); diff --git a/src/jsc/JSValue.rs b/src/jsc/JSValue.rs index 32d856923b3cd0778f006d4e99ccc5e7e7053f47..41955485d630a6daf561b877fa74658a1cfc44b7 100644 --- a/src/jsc/JSValue.rs diff --git a/.github/openclaw/qualification/harness-adapters/candidate-test.patch b/.github/openclaw/qualification/harness-adapters/candidate-test.patch index 9dd37619d299d..884596f752708 100644 --- a/.github/openclaw/qualification/harness-adapters/candidate-test.patch +++ b/.github/openclaw/qualification/harness-adapters/candidate-test.patch @@ -681,3 +681,38 @@ index c9ff165f351dd1345732d8426f2013d1bd8d27fc..11f00085169a54bcc16d241993ec5bc9 if (outcome === "fail") { return 2; } +diff --git a/test/js/node/child_process/child-process-stdio.test.js b/test/js/node/child_process/child-process-stdio.test.js +index 361d675936e9694835956eebbd9b4256f8b9e5e3..7e448388ceb3dc10781b55f1df4e72d10f8637c3 100644 +--- a/test/js/node/child_process/child-process-stdio.test.js ++++ b/test/js/node/child_process/child-process-stdio.test.js +@@ -1,6 +1,6 @@ + import { describe, expect, it } from "bun:test"; + import { bunEnv, bunExe, isPosix, isWindows } from "harness"; +-import { execSync, spawn } from "node:child_process"; ++import { execSync, spawn, spawnSync } from "node:child_process"; + import { once } from "node:events"; + import { readSync, writeSync } from "node:fs"; + import { join } from "node:path"; +@@ -8,6 +8,22 @@ import { join } from "node:path"; + const CHILD_PROCESS_FILE = import.meta.dir + "/spawned-child.js"; + const OUT_FILE = import.meta.dir + "/stdio-test-out.txt"; + ++it("spawnSync accepts an array subclass for stdio", () => { ++ class Stdio extends Array {} ++ const result = spawnSync(bunExe(), ["-e", 'console.log("stdout"); console.error("stderr")'], { ++ env: bunEnv, ++ stdio: new Stdio("ignore", "pipe", "pipe"), ++ encoding: "utf8", ++ }); ++ expect({ ++ error: result.error, ++ status: result.status, ++ signal: result.signal, ++ stdout: result.stdout, ++ stderr: result.stderr, ++ }).toEqual({ error: undefined, status: 0, signal: null, stdout: "stdout\n", stderr: "stderr\n" }); ++}); ++ + describe("process.stdout", () => { + it("should allow us to write to it", done => { + const child = spawn(bunExe(), [CHILD_PROCESS_FILE, "STDOUT"], { diff --git a/.github/openclaw/qualification/harness_adapters.py b/.github/openclaw/qualification/harness_adapters.py index 6c93196bf81fc..469110a450f75 100644 --- a/.github/openclaw/qualification/harness_adapters.py +++ b/.github/openclaw/qualification/harness_adapters.py @@ -7,6 +7,7 @@ from pathlib import Path import re import stat +import signal import subprocess if __package__: from . import consumer_identity as identity @@ -145,6 +146,23 @@ def restore(root, name, phase, engine, inspector, status, active, completed): identity.write_once(receipt, record) +def run_with_deadline(command, *, cwd, env, stream, seconds): + process = subprocess.Popen(command, cwd=cwd, env=env, stdout=stream, + stderr=subprocess.STDOUT, start_new_session=True) + try: + return process.wait(timeout=seconds) + except subprocess.TimeoutExpired: + stream.write('Fixed qualification command exceeded its external deadline\n') + stream.flush() + return 124 + finally: + try: + os.killpg(process.pid, signal.SIGKILL) + except ProcessLookupError: + pass + process.wait(timeout=5) + + def run(root, name, phase, engine, inspector, prefix=None): arm = 'baseline' if name == 'baseline' else 'candidate' repo = root / ('bun-baseline' if arm == 'baseline' else 'bun') @@ -189,7 +207,9 @@ def run(root, name, phase, engine, inspector, prefix=None): str(repo / 'scripts/buildkite.ts')], cwd=repo, env=env, stdout=stream, stderr=subprocess.STDOUT, check=True) try: - status = subprocess.run(command, cwd=repo, env=env, stdout=stream, stderr=subprocess.STDOUT).returncode + status = (run_with_deadline(command, cwd=repo, env=env, stream=stream, seconds=1800) + if phase == 'test' else subprocess.run(command, cwd=repo, env=env, stdout=stream, + stderr=subprocess.STDOUT).returncode) except OSError as error: stream.write('Failed to start fixed qualification command: ' + type(error).__name__ + '\n') if phase == 'test': diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py new file mode 100644 index 0000000000000..0e2ac719fe5df --- /dev/null +++ b/.github/openclaw/qualification/resume-consumer.py @@ -0,0 +1,116 @@ +#!/usr/bin/env python3 +"""Admit prior proof and prepare a candidate-only run of the frozen gates.""" +import hashlib +import importlib.util +import json +from pathlib import Path +import shutil +import subprocess +import sys + +SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" +SOURCE = "6e0c032a394820b65278943bd3a4e793718a97ca" +DIAGNOSTIC_SHA = "f8b39dc04c29c8482c8a0537b1ab44c6c6f98c240538e65f119c407f489ed994" + + +def sha(path): + with path.open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +def main(): + pipeline, carrier, retained, root, artifacts = [Path(p).resolve() for p in sys.argv[1:]] + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC + frozen = pipeline / ".github/openclaw/qualification" + reviewed = carrier / ".github/openclaw/qualification" + # Validate old receipts with the original policy before installing new adapters. + sys.path.insert(0, str(frozen)) + import consumer_identity as identity + diagnostic = reviewed / "diagnose-retained-consumer.py" + assert sha(diagnostic) == DIAGNOSTIC_SHA + spec = importlib.util.spec_from_file_location("retained_diagnostic", diagnostic) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + proof, binaries = module.unpack(retained, "proof"), module.unpack(retained, "binaries") + baseline, candidate = read(proof / "baseline-identity.json"), read(proof / "candidate-identity.json") + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), + artifacts / (identity.LANE + ".manifest.json"), SYNC) + identity.validate_baseline_evidence(baseline, binaries, proof) + identity.validate_invocation(proof, "baseline") + identity.validate_evidence(candidate, SYNC, engine, binaries, proof) + assert (proof / "baseline/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() + assert (proof / "candidate/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() + assert len(read(frozen / "selected.json")) == 44 + old_carrier = read(proof / "carrier.json") + assert old_carrier["carrier"] == module.CARRIER and old_carrier["sync"] == SYNC + engine_gate = read(proof / "engine-gate.json") + assert engine_gate["passed"] is True and engine_gate["source"] == SYNC + assert engine_gate["stress_counts"]["jsc-stress"] >= 1400 + assert engine_gate["stress_counts"]["jsc-modules"] >= 1600 + for name, count in engine_gate["stress_counts"].items(): + lines = (proof / name / "results").read_text().splitlines() + assert len(lines) == count and all(line.endswith(": PASS") for line in lines), name + + shutil.copytree(proof / "baseline", root / "baseline") + for name in ("baseline-identity.json", "baseline-build-tools.json", "baseline-adapters.patch", + "bun-baseline.sha256", "vm-test-baseline.sha256"): + shutil.copyfile(proof / name, root / name) + executable = root / identity.BASELINE_EXECUTABLE + executable.parent.mkdir(parents=True) + shutil.copyfile(binaries / identity.BASELINE_EXECUTABLE, executable) + assert sha(executable) == baseline["executable"]["sha256"] + executable.chmod(0o700) + # Preserve original engine evidence; the engine and historical baseline are unchanged. + for path in proof.rglob("*"): + relative = path.relative_to(proof) + if not path.is_file(): + continue + name = relative.parts[0] + if name.startswith(("jsc-", "sampling-", "accounting-")) or name in ("engine-gate.json", "stack-visitor.log"): + destination = root / relative + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, destination) + engine_directory = root / "engine" + engine_directory.mkdir() + subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), + "-C", str(engine_directory)], check=True) + + source_manifest = read(reviewed / "consumer-repair.json") + assert source_manifest["source"] == SOURCE and source_manifest["engine"] == SYNC + expected_paths = {"harness-adapters.json", "harness_adapters.py", + "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch"} + assert set(source_manifest["files"]) == expected_paths + new_adapters = read(reviewed / "harness-adapters.json") + assert new_adapters["arms"]["baseline"] == identity.ADAPTERS["arms"]["baseline"] + assert new_adapters["origins"] == identity.ADAPTERS["origins"] + for name, digest in source_manifest["files"].items(): + assert sha(reviewed / name) == digest, name + shutil.copyfile(reviewed / name, frozen / name) + + # Preserve every gate; omit only the admitted historical build/test arm. + source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) + assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() + anchor = b"for arm in baseline candidate; do" + assert source.count(anchor) == 1 + source = source.replace(anchor, b"for arm in candidate; do") + driver = root / "qualify-candidate-reuse.sh" + driver.write_bytes(source) + (root / "reuse.json").write_text(json.dumps({ + "previous_run": module.RUN, "previous_carrier": module.CARRIER, + "sync": SYNC, "candidate_repair_source": SOURCE, + "proof_artifact": module.ARTIFACTS["proof"][0], + "binary_artifact": module.ARTIFACTS["binaries"][0], + "baseline_identity_sha256": sha(root / "baseline-identity.json"), + "baseline_invocation_sha256": sha(root / "baseline/invocation.json"), + "engine_gate_sha256": sha(root / "engine-gate.json"), + "candidate_driver_sha256": sha(driver), + "repair": source_manifest, + }, indent=2) + "\n") + + +if __name__ == "__main__": + main() diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 16c6a91e91a7a..dda61ef8111a3 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -4,6 +4,11 @@ on: pull_request: paths: - .github/workflows/openclaw-hosted-linux-consumer.yml + - .github/openclaw/qualification/resume-consumer.py + - .github/openclaw/qualification/consumer-repair.json + - .github/openclaw/qualification/harness-adapters.json + - .github/openclaw/qualification/harness_adapters.py + - .github/openclaw/qualification/harness-adapters/** workflow_dispatch: permissions: @@ -21,7 +26,7 @@ env: jobs: linux-native: runs-on: ubuntu-24.04 - timeout-minutes: 360 + timeout-minutes: 180 steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: @@ -41,7 +46,13 @@ jobs: /JSTests/modules/ /JSTests/*.yaml /JSTests/BUN-TEST-DIFFERENCES.md - - name: Make room for both independent cold builds + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: ${{ github.event.pull_request.head.sha || github.sha }} + persist-credentials: false + path: carrier + sparse-checkout: .github/openclaw/qualification + - name: Make room for the candidate cold build shell: bash run: | set -euo pipefail @@ -54,7 +65,7 @@ jobs: import json, os, shutil from pathlib import Path capacity = dict(cpus=os.cpu_count(), disk_free_bytes=shutil.disk_usage('.').free) - assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'paired cold builds need 40 GiB free' + assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'candidate build and retained artifacts need 40 GiB free' Path(os.environ['QUALIFICATION_DIR']).mkdir() Path(os.environ['QUALIFICATION_DIR'], 'carrier.json').write_text(json.dumps(dict( carrier=os.environ['CARRIER_COMMIT'], sync=os.environ['SYNC_COMMIT'], @@ -131,7 +142,24 @@ jobs: curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bun.zip" unzip -q "$RUNNER_TEMP/bun.zip" -d "$RUNNER_TEMP/bootstrap" echo "$RUNNER_TEMP/bootstrap/bun-linux-x64" >> "$GITHUB_PATH" - - name: Verify the unchanged pipeline contracts + - name: Download the admitted historical build and baseline observation + timeout-minutes: 5 + env: + GH_TOKEN: ${{ github.token }} + shell: bash + run: | + set -euo pipefail + mkdir "$RUNNER_TEMP/retained" + gh api repos/openclaw/WebKit/actions/artifacts/13065898437 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13065898437/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13065868636 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13065868636/zip > "$RUNNER_TEMP/retained/binaries.zip" + - name: Admit retained proof and install the reviewed consumer repair + shell: bash + run: | + set -euo pipefail + python3 carrier/.github/openclaw/qualification/resume-consumer.py "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" + - name: Verify contracts with the reviewed adapters shell: bash run: | set -euo pipefail @@ -142,18 +170,18 @@ jobs: python3 .github/openclaw/test_consumer_identity.py python3 .github/openclaw/test_verify_jsc_results.py bash .github/openclaw/preflight.sh - - name: Qualify the exact frozen Bun pair with live build progress + - name: Qualify the corrected candidate against the retained baseline shell: bash run: | set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" tail -n +1 -F "$QUALIFICATION_DIR/build-baseline.log" "$QUALIFICATION_DIR/build-candidate.log" & tail_pid=$! (while sleep 60; do date -u; free -m; df -h /; done) & monitor_pid=$! trap 'kill "$tail_pid" "$monitor_pid" 2>/dev/null || true' EXIT - bash .github/openclaw/qualify-engine.sh - bash .github/openclaw/qualify.sh + bash "$QUALIFICATION_DIR/qualify-candidate-reuse.sh" export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" bash .github/openclaw/qualify-sync-compatibility.sh @@ -181,6 +209,7 @@ jobs: ${{ runner.temp }}/qualification/*.log ${{ runner.temp }}/qualification/*.sha256 ${{ runner.temp }}/qualification/*.patch + ${{ runner.temp }}/qualification/qualify-candidate-reuse.sh ${{ runner.temp }}/qualification/candidate-input/artifacts.json ${{ runner.temp }}/qualification/baseline/*.json ${{ runner.temp }}/qualification/baseline/*.log From e3df8cfa54c394697bcfa45cbe4f9fd33d08f1f3 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 10:54:32 +0800 Subject: [PATCH 05/35] fix(ci): adapt consumer receipt tests to bounded execution --- .github/openclaw/qualification/consumer-repair.json | 3 ++- .github/openclaw/qualification/resume-consumer.py | 9 ++++++--- .github/openclaw/test_consumer_identity.py | 5 ++++- 3 files changed, 12 insertions(+), 5 deletions(-) diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index 9b813c08309d5..f55b54940ae12 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -5,6 +5,7 @@ "harness-adapters.json": "6f2b04e36ceecae3b28616ab55a283a99c5d213e04bb427e8ef29e1fdf7ec623", "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", "harness-adapters/candidate-build.patch": "6d67a4027df0f3081443c2348ac27efd73f786035ea38c02f2b41eeb0138e928", - "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7" + "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", + "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc" } } diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 0e2ac719fe5df..bf698f5cbd4d4 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -82,14 +82,17 @@ def main(): source_manifest = read(reviewed / "consumer-repair.json") assert source_manifest["source"] == SOURCE and source_manifest["engine"] == SYNC expected_paths = {"harness-adapters.json", "harness_adapters.py", - "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch"} + "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch", + "test_consumer_identity.py"} assert set(source_manifest["files"]) == expected_paths new_adapters = read(reviewed / "harness-adapters.json") assert new_adapters["arms"]["baseline"] == identity.ADAPTERS["arms"]["baseline"] assert new_adapters["origins"] == identity.ADAPTERS["origins"] for name, digest in source_manifest["files"].items(): - assert sha(reviewed / name) == digest, name - shutil.copyfile(reviewed / name, frozen / name) + source = reviewed.parent / name if name == "test_consumer_identity.py" else reviewed / name + target = frozen.parent / name if name == "test_consumer_identity.py" else frozen / name + assert sha(source) == digest, name + shutil.copyfile(source, target) # Preserve every gate; omit only the admitted historical build/test arm. source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) diff --git a/.github/openclaw/test_consumer_identity.py b/.github/openclaw/test_consumer_identity.py index 6ef3830a0e4bf..a33a9830df205 100644 --- a/.github/openclaw/test_consumer_identity.py +++ b/.github/openclaw/test_consumer_identity.py @@ -408,7 +408,10 @@ def dispatch(argv,*args,**kwargs): self.dispatch=dispatch def run_owner(self,phase='test'): - with patch.object(harness.subprocess,'run',side_effect=self.dispatch): + def run_test_command(argv,*,cwd,env,stream,seconds): + return self.dispatch(argv,cwd=cwd,env=env,stdout=stream,stderr=subprocess.STDOUT).returncode + with patch.object(harness.subprocess,'run',side_effect=self.dispatch), \ + patch.object(harness,'run_with_deadline',side_effect=run_test_command): return harness.run(self.root,'candidate',phase,self.engine,self.inspector) def assert_restored(self,final=False,pending=False): From e3dc9d3be7d3a6cff1996ab68da3057e14e006ad Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 11:36:48 +0800 Subject: [PATCH 06/35] fix(ci): resume native proof with the required Node version --- .../diagnose-retained-consumer.py | 8 +-- .../openclaw/qualification/resume-consumer.py | 49 +++++++++++++++---- .../openclaw-hosted-linux-consumer.yml | 24 ++++----- 3 files changed, 56 insertions(+), 25 deletions(-) diff --git a/.github/openclaw/qualification/diagnose-retained-consumer.py b/.github/openclaw/qualification/diagnose-retained-consumer.py index 9fbe4a2ad40f2..9af386838b90a 100644 --- a/.github/openclaw/qualification/diagnose-retained-consumer.py +++ b/.github/openclaw/qualification/diagnose-retained-consumer.py @@ -30,15 +30,15 @@ def read(path): return json.loads(path.read_text()) -def unpack(root, name): - artifact, size, digest = ARTIFACTS[name] +def unpack(root, name, *, expected=None, run=RUN, carrier=CARRIER): + artifact, size, digest = ARTIFACTS[name] if expected is None else expected metadata = read(root / (name + ".metadata.json")) archive = root / (name + ".zip") assert metadata["id"] == artifact and not metadata["expired"] assert metadata["size_in_bytes"] == archive.stat().st_size == size assert metadata["digest"] == "sha256:" + digest and sha(archive) == digest - assert metadata["workflow_run"]["id"] == RUN - assert metadata["workflow_run"]["head_sha"] == CARRIER + assert metadata["workflow_run"]["id"] == run + assert metadata["workflow_run"]["head_sha"] == carrier destination = root / name destination.mkdir() with zipfile.ZipFile(archive) as bundle: diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index bf698f5cbd4d4..c7b56e912cc4f 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -1,5 +1,5 @@ #!/usr/bin/env python3 -"""Admit prior proof and prepare a candidate-only run of the frozen gates.""" +"""Admit successful builds and rerun the candidate through the frozen gates.""" import hashlib import importlib.util import json @@ -10,7 +10,14 @@ SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" SOURCE = "6e0c032a394820b65278943bd3a4e793718a97ca" -DIAGNOSTIC_SHA = "f8b39dc04c29c8482c8a0537b1ab44c6c6f98c240538e65f119c407f489ed994" +DIAGNOSTIC_SHA = "18857aa910f38803aca4f9578fac86d7e42b83792931d582272b3ffeebcb3144" +PREVIOUS_RUN = 41267060695 +PREVIOUS_CARRIER = "e3df8cfa54c394697bcfa45cbe4f9fd33d08f1f3" +RETAINED = { + "proof": (13068660557, 146302, "ddea8c8cd0522ca98356108ca2a3217e9cf0f7df4d0d9b08991ff54d8a226097"), + "binaries": (13067819853, 181870231, "4a5b5d1063ef2a6d337e982556a5d1afd953a91625cdafdd5a88cf1846816232"), +} +CANDIDATE_SHA = "afab308b7280bda93a116d4f5208e201b7ee09ccc537d61ea8399ef7ce87090f" def sha(path): @@ -35,18 +42,19 @@ def main(): spec = importlib.util.spec_from_file_location("retained_diagnostic", diagnostic) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) - proof, binaries = module.unpack(retained, "proof"), module.unpack(retained, "binaries") + proof, binaries = [module.unpack(retained, name, expected=RETAINED[name], + run=PREVIOUS_RUN, carrier=PREVIOUS_CARRIER) + for name in ("proof", "binaries")] baseline, candidate = read(proof / "baseline-identity.json"), read(proof / "candidate-identity.json") engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), artifacts / (identity.LANE + ".manifest.json"), SYNC) identity.validate_baseline_evidence(baseline, binaries, proof) identity.validate_invocation(proof, "baseline") - identity.validate_evidence(candidate, SYNC, engine, binaries, proof) assert (proof / "baseline/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() assert (proof / "candidate/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() assert len(read(frozen / "selected.json")) == 44 old_carrier = read(proof / "carrier.json") - assert old_carrier["carrier"] == module.CARRIER and old_carrier["sync"] == SYNC + assert old_carrier["carrier"] == PREVIOUS_CARRIER and old_carrier["sync"] == SYNC engine_gate = read(proof / "engine-gate.json") assert engine_gate["passed"] is True and engine_gate["source"] == SYNC assert engine_gate["stress_counts"]["jsc-stress"] >= 1400 @@ -94,23 +102,46 @@ def main(): assert sha(source) == digest, name shutil.copyfile(source, target) - # Preserve every gate; omit only the admitted historical build/test arm. + # The baseline uses its original policy; this build used the admitted repaired adapter. + identity = importlib.reload(identity) + identity.validate_evidence(candidate, SYNC, engine, binaries, proof) + identity.validate_invocation(proof, "candidate") + assert candidate["executable"]["sha256"] == CANDIDATE_SHA + for name in ("candidate-build-tools.json", "candidate-identity.json", "build-candidate.log"): + shutil.copyfile(proof / name, root / name) + retained_candidate = root / "retained-candidate-bun" + shutil.copyfile(binaries / identity.EXECUTABLE, retained_candidate) + assert sha(retained_candidate) == CANDIDATE_SHA + + # Preserve source preparation and every test gate; reuse only the admitted builds. source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() anchor = b"for arm in baseline candidate; do" assert source.count(anchor) == 1 source = source.replace(anchor, b"for arm in candidate; do") + build = (b' python3 "$inputs/harness_adapters.py" build --name "$arm" --root "$QUALIFICATION_DIR" \\\n' + b' --inspector-runtime "$INSPECTOR_RUNTIME" --source "$SOURCE_SHA" --artifacts "$ARTIFACT_DIR"\n') + assert source.count(build) == 1 + source = source.replace(build, + b' install -D -m 700 "$QUALIFICATION_DIR/retained-candidate-bun" "$repo/build/qualify-$arm/bun"\n') + create = b' python3 "$inputs/consumer_identity.py" create --root ' + assert source.count(create) == 1 + source = source.replace(create, b' python3 "$inputs/consumer_identity.py" verify --root ') driver = root / "qualify-candidate-reuse.sh" driver.write_bytes(source) (root / "reuse.json").write_text(json.dumps({ - "previous_run": module.RUN, "previous_carrier": module.CARRIER, + "previous_run": PREVIOUS_RUN, "previous_carrier": PREVIOUS_CARRIER, "sync": SYNC, "candidate_repair_source": SOURCE, - "proof_artifact": module.ARTIFACTS["proof"][0], - "binary_artifact": module.ARTIFACTS["binaries"][0], + "proof_artifact": RETAINED["proof"][0], + "binary_artifact": RETAINED["binaries"][0], "baseline_identity_sha256": sha(root / "baseline-identity.json"), "baseline_invocation_sha256": sha(root / "baseline/invocation.json"), "engine_gate_sha256": sha(root / "engine-gate.json"), "candidate_driver_sha256": sha(driver), + "candidate_identity_sha256": sha(root / "candidate-identity.json"), + "candidate_build_tools_sha256": sha(root / "candidate-build-tools.json"), + "candidate_executable_sha256": CANDIDATE_SHA, + "candidate_build_reused": True, "repair": source_manifest, }, indent=2) + "\n") diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index dda61ef8111a3..61d506546b8e7 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -52,7 +52,7 @@ jobs: persist-credentials: false path: carrier sparse-checkout: .github/openclaw/qualification - - name: Make room for the candidate cold build + - name: Make room for retained qualification shell: bash run: | set -euo pipefail @@ -65,7 +65,7 @@ jobs: import json, os, shutil from pathlib import Path capacity = dict(cpus=os.cpu_count(), disk_free_bytes=shutil.disk_usage('.').free) - assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'candidate build and retained artifacts need 40 GiB free' + assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'retained artifacts and qualification need 40 GiB free' Path(os.environ['QUALIFICATION_DIR']).mkdir() Path(os.environ['QUALIFICATION_DIR'], 'carrier.json').write_text(json.dumps(dict( carrier=os.environ['CARRIER_COMMIT'], sync=os.environ['SYNC_COMMIT'], @@ -74,7 +74,9 @@ jobs: PY - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: - node-version: '26.3.0' + node-version: '26.12.1' + - name: Verify the frozen candidate Node version + run: test "$(node --version)" = v26.12.1 - name: Admit the exact retained engine artifact env: GH_TOKEN: ${{ github.token }} @@ -142,7 +144,7 @@ jobs: curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bun.zip" unzip -q "$RUNNER_TEMP/bun.zip" -d "$RUNNER_TEMP/bootstrap" echo "$RUNNER_TEMP/bootstrap/bun-linux-x64" >> "$GITHUB_PATH" - - name: Download the admitted historical build and baseline observation + - name: Download the admitted successful builds and baseline observation timeout-minutes: 5 env: GH_TOKEN: ${{ github.token }} @@ -150,10 +152,10 @@ jobs: run: | set -euo pipefail mkdir "$RUNNER_TEMP/retained" - gh api repos/openclaw/WebKit/actions/artifacts/13065898437 > "$RUNNER_TEMP/retained/proof.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13065898437/zip > "$RUNNER_TEMP/retained/proof.zip" - gh api repos/openclaw/WebKit/actions/artifacts/13065868636 > "$RUNNER_TEMP/retained/binaries.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13065868636/zip > "$RUNNER_TEMP/retained/binaries.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13068660557 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13068660557/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13067819853 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13067819853/zip > "$RUNNER_TEMP/retained/binaries.zip" - name: Admit retained proof and install the reviewed consumer repair shell: bash run: | @@ -170,17 +172,15 @@ jobs: python3 .github/openclaw/test_consumer_identity.py python3 .github/openclaw/test_verify_jsc_results.py bash .github/openclaw/preflight.sh - - name: Qualify the corrected candidate against the retained baseline + - name: Qualify the retained corrected candidate against the retained baseline shell: bash run: | set -euo pipefail unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" - tail -n +1 -F "$QUALIFICATION_DIR/build-baseline.log" "$QUALIFICATION_DIR/build-candidate.log" & - tail_pid=$! (while sleep 60; do date -u; free -m; df -h /; done) & monitor_pid=$! - trap 'kill "$tail_pid" "$monitor_pid" 2>/dev/null || true' EXIT + trap 'kill "$monitor_pid" 2>/dev/null || true' EXIT bash "$QUALIFICATION_DIR/qualify-candidate-reuse.sh" export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" From d9029f5da18963149b1b61d823b1473487f3d530 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 11:53:12 +0800 Subject: [PATCH 07/35] fix(ci): resume remaining native gates with internal VM access --- .../openclaw/qualification/resume-consumer.py | 49 ++++++++++++++++--- .../openclaw-hosted-linux-consumer.yml | 12 ++--- 2 files changed, 49 insertions(+), 12 deletions(-) diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index c7b56e912cc4f..7b3dfc969e614 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -1,8 +1,9 @@ #!/usr/bin/env python3 -"""Admit successful builds and rerun the candidate through the frozen gates.""" +"""Admit completed native proof and run the remaining frozen gates.""" import hashlib import importlib.util import json +import re from pathlib import Path import shutil import subprocess @@ -11,11 +12,11 @@ SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" SOURCE = "6e0c032a394820b65278943bd3a4e793718a97ca" DIAGNOSTIC_SHA = "18857aa910f38803aca4f9578fac86d7e42b83792931d582272b3ffeebcb3144" -PREVIOUS_RUN = 41267060695 -PREVIOUS_CARRIER = "e3df8cfa54c394697bcfa45cbe4f9fd33d08f1f3" +PREVIOUS_RUN = 41269886896 +PREVIOUS_CARRIER = "e3dc9d3be7d3a6cff1996ab68da3057e14e006ad" RETAINED = { - "proof": (13068660557, 146302, "ddea8c8cd0522ca98356108ca2a3217e9cf0f7df4d0d9b08991ff54d8a226097"), - "binaries": (13067819853, 181870231, "4a5b5d1063ef2a6d337e982556a5d1afd953a91625cdafdd5a88cf1846816232"), + "proof": (13068952583, 149694, "b6097d6a0b6ceb8267228c5a90e6355742d22c1b75303040366d022d9ab46cb8"), + "binaries": (13068828135, 181870231, "ecd304f17a76299f15d1dcd65843af4ca6b5fe075c26f10ea82394f9c52e314f"), } CANDIDATE_SHA = "afab308b7280bda93a116d4f5208e201b7ee09ccc537d61ea8399ef7ce87090f" @@ -107,13 +108,32 @@ def main(): identity.validate_evidence(candidate, SYNC, engine, binaries, proof) identity.validate_invocation(proof, "candidate") assert candidate["executable"]["sha256"] == CANDIDATE_SHA + # Admit the completed selection with the same comparison policy used by the driver. + import compare_fork_ci + faith = compare_fork_ci.compare(proof / "baseline", proof / "candidate") + assert faith == read(proof / "faithfulness.json") + assert faith["policy"] == compare_fork_ci.POLICY and faith["passed"] + assert faith["candidate_all_passed"] and faith["selected_files"] == 44 and faith["result_files"] == 46 + assert read(proof / "candidate/runner-terminal.json") == {"status": 0, "signal": None, "spawnError": False} + assert read(proof / "candidate/wrapper-terminal.json") == {"status": 0} + shutil.copytree(proof / "candidate", root / "candidate") + # This exact set-e driver reached the next, failing proxy command after these checks. + assert sha(proof / "qualify-candidate-reuse.sh") == "f29d4aab64002dedbc13f1111292aa95e02d93e7287e06bafcf8be41e9c139de" + proxy = (proof / "proxy.log").read_text() + assert 'ENOENT reading "bun:internal-for-testing"' in proxy + for name, count in (("namespace", 44), ("stack-positions", 99)): + text = (proof / (name + ".log")).read_text() + assert re.search(rf"\b{count} pass\b", text) and re.search(r"\b0 fail\b", text) + shutil.copyfile(proof / (name + ".log"), root / (name + ".log")) + assert (proof / "segmenter.log").stat().st_size == 0 + shutil.copyfile(proof / "segmenter.log", root / "segmenter.log") for name in ("candidate-build-tools.json", "candidate-identity.json", "build-candidate.log"): shutil.copyfile(proof / name, root / name) retained_candidate = root / "retained-candidate-bun" shutil.copyfile(binaries / identity.EXECUTABLE, retained_candidate) assert sha(retained_candidate) == CANDIDATE_SHA - # Preserve source preparation and every test gate; reuse only the admitted builds. + # Preserve source preparation and remaining gates; retain admitted native results. source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() anchor = b"for arm in baseline candidate; do" @@ -127,6 +147,20 @@ def main(): create = b' python3 "$inputs/consumer_identity.py" create --root ' assert source.count(create) == 1 source = source.replace(create, b' python3 "$inputs/consumer_identity.py" verify --root ') + test_start = b' if python3 "$inputs/harness_adapters.py" test --name "$arm"' + test_end = b' case "$selection_exit" in 0|2) ;; *) exit "$selection_exit" ;; esac\n' + assert source.count(test_start) == source.count(test_end) == 1 + start = source.index(test_start) + end = source.index(test_end, start) + len(test_end) + source = source[:start] + b' # Completed 44-file native results were admitted before this driver.\n' + source[end:] + for name in ("namespace", "stack-positions", "segmenter"): + lines = [line for line in source.splitlines(keepends=True) + if line.endswith(('$QUALIFICATION_DIR/' + name + '.log" 2>&1\n').encode())] + assert len(lines) == 1, name + source = source.replace(lines[0], b'# Retained native ' + name.encode() + b' proof was admitted before this driver.\n') + proxy_command = b'"$candidate" test test/js/node/vm/vm.test.ts' + assert source.count(proxy_command) == 1 + source = source.replace(proxy_command, b'"$candidate" test --expose-internals test/js/node/vm/vm.test.ts') driver = root / "qualify-candidate-reuse.sh" driver.write_bytes(source) (root / "reuse.json").write_text(json.dumps({ @@ -142,6 +176,9 @@ def main(): "candidate_build_tools_sha256": sha(root / "candidate-build-tools.json"), "candidate_executable_sha256": CANDIDATE_SHA, "candidate_build_reused": True, + "candidate_selection_reused": True, + "candidate_invocation_sha256": sha(root / "candidate/invocation.json"), + "post_compare_reused": {name: sha(root / (name + ".log")) for name in ("namespace", "stack-positions", "segmenter")}, "repair": source_manifest, }, indent=2) + "\n") diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 61d506546b8e7..69c66978485f5 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -152,11 +152,11 @@ jobs: run: | set -euo pipefail mkdir "$RUNNER_TEMP/retained" - gh api repos/openclaw/WebKit/actions/artifacts/13068660557 > "$RUNNER_TEMP/retained/proof.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13068660557/zip > "$RUNNER_TEMP/retained/proof.zip" - gh api repos/openclaw/WebKit/actions/artifacts/13067819853 > "$RUNNER_TEMP/retained/binaries.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13067819853/zip > "$RUNNER_TEMP/retained/binaries.zip" - - name: Admit retained proof and install the reviewed consumer repair + gh api repos/openclaw/WebKit/actions/artifacts/13068952583 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13068952583/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13068828135 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13068828135/zip > "$RUNNER_TEMP/retained/binaries.zip" + - name: Admit completed native proof and install the reviewed consumer repair shell: bash run: | set -euo pipefail @@ -172,7 +172,7 @@ jobs: python3 .github/openclaw/test_consumer_identity.py python3 .github/openclaw/test_verify_jsc_results.py bash .github/openclaw/preflight.sh - - name: Qualify the retained corrected candidate against the retained baseline + - name: Finish qualification with the admitted native selection shell: bash run: | set -euo pipefail From 324b3bc977d4a70ff02e6f3b8ad996cc0d64e66f Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 12:19:27 +0800 Subject: [PATCH 08/35] test(tls): compare the exact shipped session baseline --- .../openclaw-retained-linux-diagnostic.yml | 119 +++++++++++------- 1 file changed, 74 insertions(+), 45 deletions(-) diff --git a/.github/workflows/openclaw-retained-linux-diagnostic.yml b/.github/workflows/openclaw-retained-linux-diagnostic.yml index ae9d7fd6824f6..2d987a38c704e 100644 --- a/.github/workflows/openclaw-retained-linux-diagnostic.yml +++ b/.github/workflows/openclaw-retained-linux-diagnostic.yml @@ -4,76 +4,105 @@ on: pull_request: paths: - .github/workflows/openclaw-retained-linux-diagnostic.yml - - .github/openclaw/qualification/diagnose-retained-consumer.py workflow_dispatch: permissions: contents: read - actions: read concurrency: group: openclaw-retained-linux-diagnostic-${{ github.head_ref || github.ref }} cancel-in-progress: true jobs: - retained-driver: + tls-session-baseline: runs-on: ubuntu-24.04 - timeout-minutes: 35 + timeout-minutes: 15 steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: - ref: ${{ github.event.pull_request.head.sha || github.sha }} - path: carrier + repository: openclaw/bun + ref: 191755ec115ece3dd642eba3cb0143cecb5e5d7a persist-credentials: false - sparse-checkout: .github/openclaw/qualification/diagnose-retained-consumer.py - sparse-checkout-cone-mode: false - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 - with: - ref: 42e4245f4180941634b482a7e8ef7fca47467de5 - path: frozen - persist-credentials: false - sparse-checkout: .github/openclaw - - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 - with: - node-version: '26.3.0' - - name: Prepare the isolated diagnostic tools and frozen source - timeout-minutes: 10 - shell: bash - run: | - set -euo pipefail - sudo apt-get update -qq - sudo apt-get install -y --no-install-recommends gdb strace unzip - curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bootstrap.zip" - unzip -q "$RUNNER_TEMP/bootstrap.zip" -d "$RUNNER_TEMP/bootstrap" - mkdir "$RUNNER_TEMP/qualification" - git clone --depth=1 --filter=blob:none --no-checkout https://github.com/openclaw/bun.git "$RUNNER_TEMP/qualification/bun" - git -C "$RUNNER_TEMP/qualification/bun" fetch --depth=1 origin 7b573c05d0c52dffc67d4d25daf108bed5930cf2 - git -C "$RUNNER_TEMP/qualification/bun" checkout --detach 7b573c05d0c52dffc67d4d25daf108bed5930cf2 - mkdir "$RUNNER_TEMP/retained" - - name: Download the exact retained build evidence - timeout-minutes: 5 + - name: Download the exact shipped baseline env: GH_TOKEN: ${{ github.token }} shell: bash run: | set -euo pipefail - gh api repos/openclaw/WebKit/actions/artifacts/13065898437 > "$RUNNER_TEMP/retained/proof.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13065898437/zip > "$RUNNER_TEMP/retained/proof.zip" - gh api repos/openclaw/WebKit/actions/artifacts/13065868636 > "$RUNNER_TEMP/retained/binaries.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13065868636/zip > "$RUNNER_TEMP/retained/binaries.zip" - - name: Diagnose the original driver with an external deadline - timeout-minutes: 18 + mkdir diagnostics + gh api repos/openclaw/bun/releases/assets/679971474 -H 'Accept: application/octet-stream' > diagnostics/manifest.json + gh api repos/openclaw/bun/releases/assets/679971203 -H 'Accept: application/octet-stream' > baseline.zip + - name: Verify shipping identity and replay the unchanged TLS context file shell: bash run: | set -euo pipefail - python3 carrier/.github/openclaw/qualification/diagnose-retained-consumer.py \ - "$RUNNER_TEMP/retained" "$GITHUB_WORKSPACE/frozen" "$RUNNER_TEMP/qualification/bun" \ - "$RUNNER_TEMP/bootstrap/bun-linux-x64/bun" - - name: Retain diagnostic facts and raw driver reports + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 - <<'PY' + import hashlib, json, os, stat, subprocess, sys, zipfile + from pathlib import Path, PurePosixPath + from xml.etree import ElementTree + + def sha(path): + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() + + commit = '191755ec115ece3dd642eba3cb0143cecb5e5d7a' + webkit = 'b82bc917e99110b61c3a21202d6def7457aa194c' + assert subprocess.check_output(['git', 'rev-parse', 'HEAD', 'HEAD^{tree}'], text=True).splitlines() == [commit, '656ed5260b61d9063f546f837238661a19514c1f'] + assert not subprocess.check_output(['git', 'status', '--porcelain', '--untracked-files=no'], text=True) + report = Path('diagnostics').resolve() + manifest = report / 'manifest.json' + assert sha(manifest) == '8c3a9d87f37832fa07173635af52d53b813e29470afa4afdb49a83033fed039e' + data = json.loads(manifest.read_text()) + assert data['bun']['commit'] == commit and data['webkit']['version'] == webkit + assets = [a for a in data['assets'] if a['target'] == 'linux-x64'] + assert len(assets) == 1 + asset = assets[0] + archive = Path('baseline.zip') + assert archive.stat().st_size == asset['size'] == 51053995 + assert sha(archive) == asset['sha256'] == 'a59df8273c232782c16a6c0e680511becd9a49ba08fa6a1adc7baea1a632de0b' + executable = asset['executable']['path'] + with zipfile.ZipFile(archive) as bundle: + entries = bundle.infolist() + path = PurePosixPath(executable) + assert not path.is_absolute() and '..' not in path.parts and '\\' not in executable + directory = str(path.parent) + '/' + assert len(entries) == 2 and {e.filename for e in entries} == {directory, executable} + folder = bundle.getinfo(directory) + assert folder.is_dir() and folder.file_size == 0 and stat.S_IFMT(folder.external_attr >> 16) in (0, stat.S_IFDIR) + entry = bundle.getinfo(executable) + assert stat.S_IFMT(entry.external_attr >> 16) in (0, stat.S_IFREG) + assert entry.file_size == asset['executable']['size'] < 256 * 1024**2 + bundle.extract(entry, 'baseline') + exe = (Path('baseline') / executable).resolve() + assert sha(exe) == asset['executable']['sha256'] + exe.chmod(0o700) + facts = json.loads(subprocess.check_output([str(exe), '-e', 'console.log(JSON.stringify({commit:Bun.revision,webkit:process.versions.webkit,platform:process.platform,arch:process.arch}))'], text=True, timeout=30)) + assert facts == {'commit': commit, 'webkit': webkit, 'platform': 'linux', 'arch': 'x64'} + fixture = Path('test/js/node/tls/node-tls-context.test.ts') + digest = sha(fixture) + assert digest == '0f6ba03e222d53279f9fa553cc3390bdd9707fc7ab382294f18d292ec8ad0bb3' + env = dict(os.environ, CI='1', BUN_RUNTIME_TRANSPILER_CACHE_PATH='0') + with (report / 'stdout.log').open('xb') as stdout, (report / 'stderr.log').open('xb') as stderr: + result = subprocess.run([str(exe), 'test', '--expose-internals', str(fixture), '--reporter=junit', '--reporter-outfile=' + str(report / 'result.xml')], + env=env, stdout=stdout, stderr=stderr, timeout=120) + tree = ElementTree.parse(report / 'result.xml') + cases = list(tree.iter('testcase')) + failures = [{'name': c.get('name'), 'classname': c.get('classname')} for c in cases if c.find('failure') is not None or c.find('error') is not None] + outcome = {'qualification': False, 'identity': facts, 'executable_sha256': sha(exe), 'fixture_sha256': digest, + 'exitCode': result.returncode, 'cases': len(cases), 'skipped': sum(c.find('skipped') is not None for c in cases), 'failures': failures} + (report / 'outcome.json').write_text(json.dumps(outcome, indent=2) + '\n') + print(json.dumps(outcome), flush=True) + assert len(cases) == 83 and outcome['skipped'] == 0, 'baseline file did not execute completely' + assert result.returncode in (0, 1) and bool(failures) == (result.returncode == 1) + assert sha(fixture) == digest and sha(exe) == asset['executable']['sha256'] + sys.exit(result.returncode) + PY + - name: Retain the baseline result and unchanged assertions if: always() uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a with: - name: retained-linux-consumer-diagnostic - path: ${{ runner.temp }}/retained/diagnostic/ + name: tls-session-baseline-linux-x64 + path: diagnostics if-no-files-found: error retention-days: 7 From 4946801051a621181b86b77b23272992b280cbfa Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 12:35:15 +0800 Subject: [PATCH 09/35] fix(ci): qualify synced WebKit with landed Bun TLS fixes --- .../qualification/consumer-repair.json | 9 +- .../qualification/harness-adapters.json | 2 +- .../openclaw/qualification/resume-consumer.py | 88 +++++-------------- .github/openclaw/qualification/verify-sync.py | 5 +- .github/openclaw/qualify-sync.sh | 3 +- .github/openclaw/variants.json | 4 +- .../openclaw-hosted-linux-consumer.yml | 24 +++-- 7 files changed, 50 insertions(+), 85 deletions(-) diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index f55b54940ae12..eebe2e4ba9f04 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -1,11 +1,14 @@ { - "source": "6e0c032a394820b65278943bd3a4e793718a97ca", + "source": "f9fc80dfd52005470484c5a58332c0496db5d203", "engine": "42e4245f4180941634b482a7e8ef7fca47467de5", "files": { - "harness-adapters.json": "6f2b04e36ceecae3b28616ab55a283a99c5d213e04bb427e8ef29e1fdf7ec623", + "harness-adapters.json": "fda290ac941d0963d5152b4a763f8f5c253b2051499484e6a50dcc062fa7e039", "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", "harness-adapters/candidate-build.patch": "6d67a4027df0f3081443c2348ac27efd73f786035ea38c02f2b41eeb0138e928", "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", - "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc" + "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc", + "variants.json": "a181182de15f50d6c30d4d185a9d21cdea2093236dc17aa66628e65008c57bc7", + "qualify-sync.sh": "880ba11d8eda8f4cf38af3c1f4f47b31211457c71255c9435a775773c373431e", + "verify-sync.py": "8a2dfca07f4a18d0f755f5c7b315304af11983361f1caccb84c6fd645ca1ffa0" } } diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index 245b925dee7a7..b62bfa07a6299 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -51,7 +51,7 @@ } }, "candidate": { - "pin": "7b573c05d0c52dffc67d4d25daf108bed5930cf2", + "pin": "d9be087429c21e563bb5ac29f8a11805e64b56a3", "build": { "kind": "source-compatibility", "patch": "harness-adapters/candidate-build.patch", diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 7b3dfc969e614..d335b9675316b 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -1,16 +1,15 @@ #!/usr/bin/env python3 -"""Admit completed native proof and run the remaining frozen gates.""" +"""Retain unchanged baseline/engine evidence and rebuild the integrated consumer.""" import hashlib import importlib.util import json -import re from pathlib import Path import shutil import subprocess import sys SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" -SOURCE = "6e0c032a394820b65278943bd3a4e793718a97ca" +SOURCE = "f9fc80dfd52005470484c5a58332c0496db5d203" DIAGNOSTIC_SHA = "18857aa910f38803aca4f9578fac86d7e42b83792931d582272b3ffeebcb3144" PREVIOUS_RUN = 41269886896 PREVIOUS_CARRIER = "e3dc9d3be7d3a6cff1996ab68da3057e14e006ad" @@ -18,7 +17,6 @@ "proof": (13068952583, 149694, "b6097d6a0b6ceb8267228c5a90e6355742d22c1b75303040366d022d9ab46cb8"), "binaries": (13068828135, 181870231, "ecd304f17a76299f15d1dcd65843af4ca6b5fe075c26f10ea82394f9c52e314f"), } -CANDIDATE_SHA = "afab308b7280bda93a116d4f5208e201b7ee09ccc537d61ea8399ef7ce87090f" def sha(path): @@ -46,13 +44,12 @@ def main(): proof, binaries = [module.unpack(retained, name, expected=RETAINED[name], run=PREVIOUS_RUN, carrier=PREVIOUS_CARRIER) for name in ("proof", "binaries")] - baseline, candidate = read(proof / "baseline-identity.json"), read(proof / "candidate-identity.json") + baseline = read(proof / "baseline-identity.json") engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), artifacts / (identity.LANE + ".manifest.json"), SYNC) identity.validate_baseline_evidence(baseline, binaries, proof) identity.validate_invocation(proof, "baseline") assert (proof / "baseline/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() - assert (proof / "candidate/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() assert len(read(frozen / "selected.json")) == 44 old_carrier = read(proof / "carrier.json") assert old_carrier["carrier"] == PREVIOUS_CARRIER and old_carrier["sync"] == SYNC @@ -92,76 +89,38 @@ def main(): assert source_manifest["source"] == SOURCE and source_manifest["engine"] == SYNC expected_paths = {"harness-adapters.json", "harness_adapters.py", "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch", - "test_consumer_identity.py"} + "test_consumer_identity.py", "variants.json", "qualify-sync.sh", "verify-sync.py"} assert set(source_manifest["files"]) == expected_paths new_adapters = read(reviewed / "harness-adapters.json") assert new_adapters["arms"]["baseline"] == identity.ADAPTERS["arms"]["baseline"] assert new_adapters["origins"] == identity.ADAPTERS["origins"] + variants = read(reviewed.parent / "variants.json") + original_variants = identity.CONFIG + assert {k: v for k, v in variants.items() if k != "candidate"} == { + k: v for k, v in original_variants.items() if k != "candidate"} + assert variants["candidate"] == { + "commit": "d9be087429c21e563bb5ac29f8a11805e64b56a3", + "tree": "980068aa5aa9f51f40fc4125114a68fccd9bc9dc", + "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218"} + assert new_adapters["arms"]["candidate"]["pin"] == variants["candidate"]["commit"] + parent_files = {"test_consumer_identity.py", "variants.json", "qualify-sync.sh"} for name, digest in source_manifest["files"].items(): - source = reviewed.parent / name if name == "test_consumer_identity.py" else reviewed / name - target = frozen.parent / name if name == "test_consumer_identity.py" else frozen / name + source = reviewed.parent / name if name in parent_files else reviewed / name + target = frozen.parent / name if name in parent_files else frozen / name assert sha(source) == digest, name shutil.copyfile(source, target) - # The baseline uses its original policy; this build used the admitted repaired adapter. - identity = importlib.reload(identity) - identity.validate_evidence(candidate, SYNC, engine, binaries, proof) - identity.validate_invocation(proof, "candidate") - assert candidate["executable"]["sha256"] == CANDIDATE_SHA - # Admit the completed selection with the same comparison policy used by the driver. - import compare_fork_ci - faith = compare_fork_ci.compare(proof / "baseline", proof / "candidate") - assert faith == read(proof / "faithfulness.json") - assert faith["policy"] == compare_fork_ci.POLICY and faith["passed"] - assert faith["candidate_all_passed"] and faith["selected_files"] == 44 and faith["result_files"] == 46 - assert read(proof / "candidate/runner-terminal.json") == {"status": 0, "signal": None, "spawnError": False} - assert read(proof / "candidate/wrapper-terminal.json") == {"status": 0} - shutil.copytree(proof / "candidate", root / "candidate") - # This exact set-e driver reached the next, failing proxy command after these checks. - assert sha(proof / "qualify-candidate-reuse.sh") == "f29d4aab64002dedbc13f1111292aa95e02d93e7287e06bafcf8be41e9c139de" - proxy = (proof / "proxy.log").read_text() - assert 'ENOENT reading "bun:internal-for-testing"' in proxy - for name, count in (("namespace", 44), ("stack-positions", 99)): - text = (proof / (name + ".log")).read_text() - assert re.search(rf"\b{count} pass\b", text) and re.search(r"\b0 fail\b", text) - shutil.copyfile(proof / (name + ".log"), root / (name + ".log")) - assert (proof / "segmenter.log").stat().st_size == 0 - shutil.copyfile(proof / "segmenter.log", root / "segmenter.log") - for name in ("candidate-build-tools.json", "candidate-identity.json", "build-candidate.log"): - shutil.copyfile(proof / name, root / name) - retained_candidate = root / "retained-candidate-bun" - shutil.copyfile(binaries / identity.EXECUTABLE, retained_candidate) - assert sha(retained_candidate) == CANDIDATE_SHA - - # Preserve source preparation and remaining gates; retain admitted native results. + # Candidate receipts and executables are deliberately not copied across source changes. + # Keep the normal build, identity creation, selection and every later gate. source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() anchor = b"for arm in baseline candidate; do" assert source.count(anchor) == 1 source = source.replace(anchor, b"for arm in candidate; do") - build = (b' python3 "$inputs/harness_adapters.py" build --name "$arm" --root "$QUALIFICATION_DIR" \\\n' - b' --inspector-runtime "$INSPECTOR_RUNTIME" --source "$SOURCE_SHA" --artifacts "$ARTIFACT_DIR"\n') - assert source.count(build) == 1 - source = source.replace(build, - b' install -D -m 700 "$QUALIFICATION_DIR/retained-candidate-bun" "$repo/build/qualify-$arm/bun"\n') - create = b' python3 "$inputs/consumer_identity.py" create --root ' - assert source.count(create) == 1 - source = source.replace(create, b' python3 "$inputs/consumer_identity.py" verify --root ') - test_start = b' if python3 "$inputs/harness_adapters.py" test --name "$arm"' - test_end = b' case "$selection_exit" in 0|2) ;; *) exit "$selection_exit" ;; esac\n' - assert source.count(test_start) == source.count(test_end) == 1 - start = source.index(test_start) - end = source.index(test_end, start) + len(test_end) - source = source[:start] + b' # Completed 44-file native results were admitted before this driver.\n' + source[end:] - for name in ("namespace", "stack-positions", "segmenter"): - lines = [line for line in source.splitlines(keepends=True) - if line.endswith(('$QUALIFICATION_DIR/' + name + '.log" 2>&1\n').encode())] - assert len(lines) == 1, name - source = source.replace(lines[0], b'# Retained native ' + name.encode() + b' proof was admitted before this driver.\n') proxy_command = b'"$candidate" test test/js/node/vm/vm.test.ts' assert source.count(proxy_command) == 1 source = source.replace(proxy_command, b'"$candidate" test --expose-internals test/js/node/vm/vm.test.ts') - driver = root / "qualify-candidate-reuse.sh" + driver = root / "qualify-candidate-fresh.sh" driver.write_bytes(source) (root / "reuse.json").write_text(json.dumps({ "previous_run": PREVIOUS_RUN, "previous_carrier": PREVIOUS_CARRIER, @@ -172,13 +131,8 @@ def main(): "baseline_invocation_sha256": sha(root / "baseline/invocation.json"), "engine_gate_sha256": sha(root / "engine-gate.json"), "candidate_driver_sha256": sha(driver), - "candidate_identity_sha256": sha(root / "candidate-identity.json"), - "candidate_build_tools_sha256": sha(root / "candidate-build-tools.json"), - "candidate_executable_sha256": CANDIDATE_SHA, - "candidate_build_reused": True, - "candidate_selection_reused": True, - "candidate_invocation_sha256": sha(root / "candidate/invocation.json"), - "post_compare_reused": {name: sha(root / (name + ".log")) for name in ("namespace", "stack-positions", "segmenter")}, + "candidate_build_reused": False, + "candidate_selection_reused": False, "repair": source_manifest, }, indent=2) + "\n") diff --git a/.github/openclaw/qualification/verify-sync.py b/.github/openclaw/qualification/verify-sync.py index 2c109c091472b..205ebae6d1ab0 100644 --- a/.github/openclaw/qualification/verify-sync.py +++ b/.github/openclaw/qualification/verify-sync.py @@ -14,14 +14,15 @@ assert observed['all_passed'],'sync CI failures' assert {'test/js/web/atomics.test.ts','test/js/bun/wasm/compile-rss.test.ts'}<=set(selected) counts={} -for name,minimum in [('memory-release',3),('webkit-upgrade',11),('proxy',4),('resource-limits',16),('namespace',41),('inspector',78),('als-suites',223),('stack-positions',343),('stack-minifier',68),('arraybuffer',19),('worker-statistics',7),('arraybuffer-native',1),('arraybuffer-serializer',60),('inspection-idle',1),('sqlite-bigint',6),('bake-builtin',1),('bigint-matchers',2),('lazy-process-builtins',3),('bigint-serialization',18),('untrimmed-collator',1)]: +for name,minimum in [('quic-sni',19),('memory-release',3),('webkit-upgrade',11),('proxy',4),('resource-limits',16),('namespace',41),('inspector',78),('als-suites',223),('stack-positions',343),('stack-minifier',68),('arraybuffer',19),('worker-statistics',7),('arraybuffer-native',1),('arraybuffer-serializer',60),('inspection-idle',1),('sqlite-bigint',6),('bake-builtin',1),('bigint-matchers',2),('lazy-process-builtins',3),('bigint-serialization',18),('untrimmed-collator',1)]: text=(out/(name+'.log')).read_text() passes=re.findall(r'(\d+) pass',text) assert passes and int(passes[-1])>=minimum,name+' incomplete' assert re.search(r'\b0 fail\b',text),name+' failed' + if name=='quic-sni':assert int(passes[-1])==19,'QUIC SNI selection drift' if name=='webkit-upgrade':assert int(passes[-1])==11,'WebKit upgrade selection drift' if name=='untrimmed-collator':assert int(passes[-1])==1,'collator selection drift' - if name in ('memory-release','webkit-upgrade','bigint-matchers','bigint-serialization','lazy-process-builtins','untrimmed-collator'):assert not re.search(r'\b[1-9]\d* skip\b',text),name+' tests skipped' + if name in ('quic-sni','memory-release','webkit-upgrade','bigint-matchers','bigint-serialization','lazy-process-builtins','untrimmed-collator'):assert not re.search(r'\b[1-9]\d* skip\b',text),name+' tests skipped' counts[name]=int(passes[-1]) assert (out/'untrimmed-getters.log').read_text().strip()=='native URL getters passed','native URL getter smoke incomplete' for name in ['als-plugin','als-native','als-gc']: diff --git a/.github/openclaw/qualify-sync.sh b/.github/openclaw/qualify-sync.sh index c4f8a2eb9dc14..31735951523da 100644 --- a/.github/openclaw/qualify-sync.sh +++ b/.github/openclaw/qualify-sync.sh @@ -32,6 +32,7 @@ else selection_exit=$? fi if test "$selection_exit" -ne 0; then exit "$selection_exit"; fi +"$candidate" test --expose-internals test/js/node/quic/quic-sni.test.ts > "$results/quic-sni.log" 2>&1 "$candidate" test --expose-gc test/js/node/sqlite/node-sqlite.test.ts test/js/node/test/parallel/test-sqlite-statement-sync.js \ -t "rejects oversized BigInt with ERR_INVALID_ARG_VALUE|bind error messages match node's exactly|database-level defaults flow to prepared statements|BigInts support can be toggled|BigInt is required for reading large integers|BigInts are returned when input is true" \ > "$results/sqlite-bigint.log" 2>&1 @@ -58,7 +59,7 @@ python3 "$inputs/compile_cache.py" /tmp "$junit_prefix" "$results/module-junit.x "$candidate" test test/bundler/bundler_minify.test.ts > "$results/stack-minifier.log" 2>&1 python3 "$inputs/stack/check-runtime-cache.py" --baseline "$QUALIFICATION_DIR/bun-baseline/build/qualify-baseline/bun" --candidate "$candidate" --fixture "$inputs/stack/observe-regressions.js" --output "$results/runtime-cache" --expected-version 45 > "$results/stack-cache.json" "$candidate" "$inputs/segmenter.js" > "$results/segmenter.log" 2>&1 -"$candidate" test test/js/node/vm/vm.test.ts -t 'a Proxy in the prototype chain' > "$results/proxy.log" 2>&1 +"$candidate" test --expose-internals test/js/node/vm/vm.test.ts -t 'a Proxy in the prototype chain' > "$results/proxy.log" 2>&1 "$candidate" test test/js/node/worker_threads/openclaw-resource-limits.test.ts -t resourceLimits > "$results/resource-limits.log" 2>&1 "$candidate" test test/js/bun/resolve/esModule.test.ts test/js/bun/namespace-prototype-pollution.test.ts test/js/bun/resolve/require-esm-evaluating-cycle.test.ts test/js/bun/import-attributes/import-attributes.test.ts test/js/node/module/require-extensions.test.ts > "$results/namespace.log" 2>&1 "$candidate" test test/js/node/process/process.test.js -t 'ArrayBuffer memory ownership' > "$results/arraybuffer.log" 2>&1 diff --git a/.github/openclaw/variants.json b/.github/openclaw/variants.json index 5e708d64b4482..9f3eef6bf9190 100644 --- a/.github/openclaw/variants.json +++ b/.github/openclaw/variants.json @@ -55,8 +55,8 @@ "manifest_sha256": "df16ba1dcaad70daa014fbc70c7005842fb2bf5099a1df00a83e1075ceef7462" }, "candidate": { - "commit": "7b573c05d0c52dffc67d4d25daf108bed5930cf2", - "tree": "50dbaef36882f6185b619ecf08b0663590cd0e5b", + "commit": "d9be087429c21e563bb5ac29f8a11805e64b56a3", + "tree": "980068aa5aa9f51f40fc4125114a68fccd9bc9dc", "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218" } } diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 69c66978485f5..045e2279c298e 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -9,6 +9,9 @@ on: - .github/openclaw/qualification/harness-adapters.json - .github/openclaw/qualification/harness_adapters.py - .github/openclaw/qualification/harness-adapters/** + - .github/openclaw/variants.json + - .github/openclaw/qualify-sync.sh + - .github/openclaw/qualification/verify-sync.py workflow_dispatch: permissions: @@ -51,8 +54,8 @@ jobs: ref: ${{ github.event.pull_request.head.sha || github.sha }} persist-credentials: false path: carrier - sparse-checkout: .github/openclaw/qualification - - name: Make room for retained qualification + sparse-checkout: .github/openclaw + - name: Make room for an independent candidate build shell: bash run: | set -euo pipefail @@ -65,7 +68,7 @@ jobs: import json, os, shutil from pathlib import Path capacity = dict(cpus=os.cpu_count(), disk_free_bytes=shutil.disk_usage('.').free) - assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'retained artifacts and qualification need 40 GiB free' + assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'candidate build and retained baseline need 40 GiB free' Path(os.environ['QUALIFICATION_DIR']).mkdir() Path(os.environ['QUALIFICATION_DIR'], 'carrier.json').write_text(json.dumps(dict( carrier=os.environ['CARRIER_COMMIT'], sync=os.environ['SYNC_COMMIT'], @@ -144,7 +147,7 @@ jobs: curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bun.zip" unzip -q "$RUNNER_TEMP/bun.zip" -d "$RUNNER_TEMP/bootstrap" echo "$RUNNER_TEMP/bootstrap/bun-linux-x64" >> "$GITHUB_PATH" - - name: Download the admitted successful builds and baseline observation + - name: Download unchanged engine and baseline evidence timeout-minutes: 5 env: GH_TOKEN: ${{ github.token }} @@ -156,7 +159,7 @@ jobs: gh api repos/openclaw/WebKit/actions/artifacts/13068952583/zip > "$RUNNER_TEMP/retained/proof.zip" gh api repos/openclaw/WebKit/actions/artifacts/13068828135 > "$RUNNER_TEMP/retained/binaries.metadata.json" gh api repos/openclaw/WebKit/actions/artifacts/13068828135/zip > "$RUNNER_TEMP/retained/binaries.zip" - - name: Admit completed native proof and install the reviewed consumer repair + - name: Admit baseline proof and install the integrated consumer controls shell: bash run: | set -euo pipefail @@ -172,16 +175,18 @@ jobs: python3 .github/openclaw/test_consumer_identity.py python3 .github/openclaw/test_verify_jsc_results.py bash .github/openclaw/preflight.sh - - name: Finish qualification with the admitted native selection + - name: Build and qualify the integrated consumer from source shell: bash run: | set -euo pipefail unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" + tail -n +1 -F "$QUALIFICATION_DIR/build-candidate.log" & + tail_pid=$! (while sleep 60; do date -u; free -m; df -h /; done) & monitor_pid=$! - trap 'kill "$monitor_pid" 2>/dev/null || true' EXIT - bash "$QUALIFICATION_DIR/qualify-candidate-reuse.sh" + trap 'kill "$tail_pid" "$monitor_pid" 2>/dev/null || true' EXIT + bash "$QUALIFICATION_DIR/qualify-candidate-fresh.sh" export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" bash .github/openclaw/qualify-sync-compatibility.sh @@ -194,6 +199,7 @@ jobs: path: | ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts ${{ runner.temp }}/qualification/*.sha256 compression-level: 0 @@ -209,7 +215,7 @@ jobs: ${{ runner.temp }}/qualification/*.log ${{ runner.temp }}/qualification/*.sha256 ${{ runner.temp }}/qualification/*.patch - ${{ runner.temp }}/qualification/qualify-candidate-reuse.sh + ${{ runner.temp }}/qualification/qualify-candidate-fresh.sh ${{ runner.temp }}/qualification/candidate-input/artifacts.json ${{ runner.temp }}/qualification/baseline/*.json ${{ runner.temp }}/qualification/baseline/*.log From 0ecb41fd7524b751b648fd99502d4c6a75a6d92c Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 13:20:20 +0800 Subject: [PATCH 10/35] fix(ci): qualify Bun loop-header coverage adaptation --- .../qualification/consumer-repair.json | 6 +- .../qualification/harness-adapters.json | 10 ++- .../harness-adapters/candidate-build.patch | 61 +++++++++++++++++++ .../openclaw/qualification/resume-consumer.py | 2 +- 4 files changed, 74 insertions(+), 5 deletions(-) diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index eebe2e4ba9f04..82cae64e688e2 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -1,10 +1,10 @@ { - "source": "f9fc80dfd52005470484c5a58332c0496db5d203", + "source": "4fd77cbea9fc9a63220941c1af5e283ca455d075", "engine": "42e4245f4180941634b482a7e8ef7fca47467de5", "files": { - "harness-adapters.json": "fda290ac941d0963d5152b4a763f8f5c253b2051499484e6a50dcc062fa7e039", + "harness-adapters.json": "bb1ee92f7924e6f6d515979e097aa608c357b5272772ae17f8b298c50cf14a70", "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", - "harness-adapters/candidate-build.patch": "6d67a4027df0f3081443c2348ac27efd73f786035ea38c02f2b41eeb0138e928", + "harness-adapters/candidate-build.patch": "a83d29b694c0ae06158eb8412ed664913257cfe730418f164f37c52bd91fd0a6", "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc", "variants.json": "a181182de15f50d6c30d4d185a9d21cdea2093236dc17aa66628e65008c57bc7", diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index b62bfa07a6299..c7a2e8c420236 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -55,13 +55,14 @@ "build": { "kind": "source-compatibility", "patch": "harness-adapters/candidate-build.patch", - "sha256": "6d67a4027df0f3081443c2348ac27efd73f786035ea38c02f2b41eeb0138e928", + "sha256": "a83d29b694c0ae06158eb8412ed664913257cfe730418f164f37c52bd91fd0a6", "compiled_inputs": [ "src/codegen/bindgen-lib-internal.ts", "src/codegen/bundle-functions.ts", "src/jsc/JSType.rs", "src/jsc/JSValue.rs", "src/jsc/bindings/BunProcess.cpp", + "src/jsc/bindings/CodeCoverage.cpp", "src/jsc/bindings/JSBuffer.cpp", "src/jsc/bindings/JSCTestingHelpers.cpp", "src/jsc/bindings/bindings.cpp", @@ -161,6 +162,13 @@ "base_blob": "9fd38a5d2be4570d105fb1612003537c2794c4dc", "adapted_blob": "06be1374e4b23348297e6f3e74af844c220d10e9", "mode": "100644" + }, + "src/jsc/bindings/CodeCoverage.cpp": { + "before": "e92545d56f26db1e95ae61437a44aa6e61461f68586f4b2d41a465fe0785af07", + "after": "49e6095309ca2f57fe84c25b226d736cc88683da15f314ba3c09438aa6e9938b", + "base_blob": "eb829838e3c35cf318ffa5df574bb813eb1b8233", + "adapted_blob": "85581c9f25f9ad8c54907d2bc98409fe21a72f91", + "mode": "100644" } } }, diff --git a/.github/openclaw/qualification/harness-adapters/candidate-build.patch b/.github/openclaw/qualification/harness-adapters/candidate-build.patch index 7de50462b519c..62b29554d693f 100644 --- a/.github/openclaw/qualification/harness-adapters/candidate-build.patch +++ b/.github/openclaw/qualification/harness-adapters/candidate-build.patch @@ -836,3 +836,64 @@ index 9fd38a5d2be4570d105fb1612003537c2794c4dc..06be1374e4b23348297e6f3e74af844c v.to_int64() & 1 == 1 } else if v.is_int32() { v.to_int32().rem_euclid(2) == 1 +diff --git a/src/jsc/bindings/CodeCoverage.cpp b/src/jsc/bindings/CodeCoverage.cpp +index eb829838e3c35cf318ffa5df574bb813eb1b8233..85581c9f25f9ad8c54907d2bc98409fe21a72f91 100644 +--- a/src/jsc/bindings/CodeCoverage.cpp ++++ b/src/jsc/bindings/CodeCoverage.cpp +@@ -4,6 +4,48 @@ + + using namespace JSC; + ++// JSC counts the condition, the increment and the left side in a loop header by themselves. A line is counted here by the basic block that the loop is in: ++// each part of a loop header goes back into that basic block, which is then in as many pieces as it would be without them. ++static void foldLoopHeadersIntoBasicBlocksAroundThem(VM& vm, SourceID sourceID, Vector& pieces) ++{ ++ if (!pieces.containsIf([](const BasicBlockRange& piece) { return piece.m_isInLoopHeader; })) ++ return; ++ ++ // Whole basic blocks lie in one another or apart. ++ auto blocks = vm.controlFlowProfiler()->getBasicBlocksForSourceIDWithoutFunctionRange(sourceID, vm, ControlFlowProfiler::Gaps::With); ++ blocks.removeAllMatching([](const BasicBlockRange& block) { return block.m_isInLoopHeader; }); ++ std::ranges::sort(blocks, [](const BasicBlockRange& a, const BasicBlockRange& b) { ++ return a.m_startOffset != b.m_startOffset ? a.m_startOffset < b.m_startOffset : a.m_endOffset > b.m_endOffset; ++ }); ++ std::ranges::sort(pieces, {}, &BasicBlockRange::m_startOffset); ++ ++ constexpr size_t none = std::numeric_limits::max(); ++ Vector open; ++ size_t nextBlock = 0; ++ size_t blockOfLastPiece = none; ++ size_t kept = 0; ++ for (BasicBlockRange piece : pieces) { ++ while (nextBlock < blocks.size() && blocks[nextBlock].m_startOffset <= piece.m_startOffset) ++ open.append(nextBlock++); ++ while (!open.isEmpty() && blocks[open.last()].m_endOffset < piece.m_startOffset) ++ open.removeLast(); ++ size_t block = open.isEmpty() ? none : open.last(); ++ if (piece.m_isInLoopHeader) { ++ if (block == none) ++ continue; ++ piece.m_isInLoopHeader = false; ++ piece.m_hasExecuted = blocks[block].m_hasExecuted; ++ piece.m_executionCount = blocks[block].m_executionCount; ++ } ++ if (kept && block != none && block == blockOfLastPiece && pieces[kept - 1].m_endOffset + 1 == piece.m_startOffset) ++ pieces[kept - 1].m_endOffset = piece.m_endOffset; ++ else ++ pieces[kept++] = piece; ++ blockOfLastPiece = block; ++ } ++ pieces.shrink(kept); ++} ++ + extern "C" bool CodeCoverage__withBlocksAndFunctions( + JSC::VM* vmPtr, + JSC::SourceID sourceID, +@@ -15,6 +57,7 @@ extern "C" bool CodeCoverage__withBlocksAndFunctions( + + auto basicBlocks = vm.controlFlowProfiler()->getBasicBlocksForSourceIDWithoutFunctionRange( + sourceID, vm); ++ foldLoopHeadersIntoBasicBlocksAroundThem(vm, sourceID, basicBlocks); + + if (basicBlocks.isEmpty()) { + blockCallback(ctx, nullptr, 0, 0); diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index d335b9675316b..db5b944d99f0d 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -9,7 +9,7 @@ import sys SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" -SOURCE = "f9fc80dfd52005470484c5a58332c0496db5d203" +SOURCE = "4fd77cbea9fc9a63220941c1af5e283ca455d075" DIAGNOSTIC_SHA = "18857aa910f38803aca4f9578fac86d7e42b83792931d582272b3ffeebcb3144" PREVIOUS_RUN = 41269886896 PREVIOUS_CARRIER = "e3dc9d3be7d3a6cff1996ab68da3057e14e006ad" From bf6e21076fbaf4b442347f64b64b61917bd07c47 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 14:08:22 +0800 Subject: [PATCH 11/35] fix(ci): qualify inspector coverage and all SQLite BigInt cases --- .../qualification/consumer-repair.json | 10 +++---- .../qualification/harness-adapters.json | 10 ++++++- .../harness-adapters/candidate-build.patch | 14 +++++++++ .../openclaw/qualification/resume-consumer.py | 2 +- .github/openclaw/qualification/verify-sync.py | 29 ++++++++++++++++++- .github/openclaw/qualify-sync.sh | 10 +++++-- 6 files changed, 65 insertions(+), 10 deletions(-) diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index 82cae64e688e2..cbef3f972c8ca 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -1,14 +1,14 @@ { - "source": "4fd77cbea9fc9a63220941c1af5e283ca455d075", + "source": "2323913322dfdfed96ecf20163d62f5ff2796ecc", "engine": "42e4245f4180941634b482a7e8ef7fca47467de5", "files": { - "harness-adapters.json": "bb1ee92f7924e6f6d515979e097aa608c357b5272772ae17f8b298c50cf14a70", + "harness-adapters.json": "4ba71d03cac2a000b8f49c6f4f0954462bf3b275968395455bd9130fb1f17523", "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", - "harness-adapters/candidate-build.patch": "a83d29b694c0ae06158eb8412ed664913257cfe730418f164f37c52bd91fd0a6", + "harness-adapters/candidate-build.patch": "414c02660faa9dcc48c383458dbe13dea5c9a26a7f3abc62265ea637ec074769", "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc", "variants.json": "a181182de15f50d6c30d4d185a9d21cdea2093236dc17aa66628e65008c57bc7", - "qualify-sync.sh": "880ba11d8eda8f4cf38af3c1f4f47b31211457c71255c9435a775773c373431e", - "verify-sync.py": "8a2dfca07f4a18d0f755f5c7b315304af11983361f1caccb84c6fd645ca1ffa0" + "qualify-sync.sh": "65d3d21f0b944e06c10b9b5521182048d6988f81f15859f29cf9a07464cf90cd", + "verify-sync.py": "e9aeb350b0de5e5b5962af9934985805985a2291b3e90ff0302fd6c427a1db23" } } diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index c7a2e8c420236..b88ca083da267 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -55,7 +55,7 @@ "build": { "kind": "source-compatibility", "patch": "harness-adapters/candidate-build.patch", - "sha256": "a83d29b694c0ae06158eb8412ed664913257cfe730418f164f37c52bd91fd0a6", + "sha256": "414c02660faa9dcc48c383458dbe13dea5c9a26a7f3abc62265ea637ec074769", "compiled_inputs": [ "src/codegen/bindgen-lib-internal.ts", "src/codegen/bundle-functions.ts", @@ -65,6 +65,7 @@ "src/jsc/bindings/CodeCoverage.cpp", "src/jsc/bindings/JSBuffer.cpp", "src/jsc/bindings/JSCTestingHelpers.cpp", + "src/jsc/bindings/JSInspectorProfiler.cpp", "src/jsc/bindings/bindings.cpp", "src/jsc/bindings/sqlite/NodeSqlite.cpp", "src/jsc/bindings/webcore/SerializedScriptValue.cpp", @@ -169,6 +170,13 @@ "base_blob": "eb829838e3c35cf318ffa5df574bb813eb1b8233", "adapted_blob": "85581c9f25f9ad8c54907d2bc98409fe21a72f91", "mode": "100644" + }, + "src/jsc/bindings/JSInspectorProfiler.cpp": { + "before": "71861391d4bb8f67a388800b4bfcb7bac4e41eb748f60540273235ab51fe2fbc", + "after": "c22d6f527e1ebddacb3557c4eeafc1d23fd7c7d3cd6ed77912000fb594d603dd", + "base_blob": "e5e626d17fd55645606a079bac7c45de997494be", + "adapted_blob": "af15ac268434f7b60fc07f0f64b2d328de586a5d", + "mode": "100644" } } }, diff --git a/.github/openclaw/qualification/harness-adapters/candidate-build.patch b/.github/openclaw/qualification/harness-adapters/candidate-build.patch index 62b29554d693f..8e7ef470e72b0 100644 --- a/.github/openclaw/qualification/harness-adapters/candidate-build.patch +++ b/.github/openclaw/qualification/harness-adapters/candidate-build.patch @@ -897,3 +897,17 @@ index eb829838e3c35cf318ffa5df574bb813eb1b8233..85581c9f25f9ad8c54907d2bc98409fe if (basicBlocks.isEmpty()) { blockCallback(ctx, nullptr, 0, 0); +diff --git a/src/jsc/bindings/JSInspectorProfiler.cpp b/src/jsc/bindings/JSInspectorProfiler.cpp +index e5e626d17fd55645606a079bac7c45de997494be..af15ac268434f7b60fc07f0f64b2d328de586a5d 100644 +--- a/src/jsc/bindings/JSInspectorProfiler.cpp ++++ b/src/jsc/bindings/JSInspectorProfiler.cpp +@@ -199,6 +199,9 @@ JSC_DEFINE_HOST_FUNCTION(jsFunction_collectPreciseCoverage, (JSGlobalObject * gl + // JSC's ranges include their last character; V8's end after it. + auto blockArray = JSON::Array::create(); + for (const auto& block : blocks) { ++ // V8 has no range for the condition, the increment or the left side in a loop header. The basic block that the loop is in has their text. ++ if (block.m_isInLoopHeader) ++ continue; + auto range = JSON::Array::create(); + range->pushInteger(block.m_startOffset); + range->pushInteger(block.m_endOffset + 1); diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index db5b944d99f0d..2f5af2f80075f 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -9,7 +9,7 @@ import sys SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" -SOURCE = "4fd77cbea9fc9a63220941c1af5e283ca455d075" +SOURCE = "2323913322dfdfed96ecf20163d62f5ff2796ecc" DIAGNOSTIC_SHA = "18857aa910f38803aca4f9578fac86d7e42b83792931d582272b3ffeebcb3144" PREVIOUS_RUN = 41269886896 PREVIOUS_CARRIER = "e3dc9d3be7d3a6cff1996ab68da3057e14e006ad" diff --git a/.github/openclaw/qualification/verify-sync.py b/.github/openclaw/qualification/verify-sync.py index 205ebae6d1ab0..2fae062a3f3f9 100644 --- a/.github/openclaw/qualification/verify-sync.py +++ b/.github/openclaw/qualification/verify-sync.py @@ -5,6 +5,7 @@ from compile_cache import evidence as compile_cache_evidence from compare_fork_ci import validate_arm from pathlib import Path +from xml.etree import ElementTree root=Path(sys.argv[1]);out=root/'sync' selected=json.loads((out/'selected.json').read_text()) rows=json.loads((out/'results.json').read_text()) @@ -14,7 +15,7 @@ assert observed['all_passed'],'sync CI failures' assert {'test/js/web/atomics.test.ts','test/js/bun/wasm/compile-rss.test.ts'}<=set(selected) counts={} -for name,minimum in [('quic-sni',19),('memory-release',3),('webkit-upgrade',11),('proxy',4),('resource-limits',16),('namespace',41),('inspector',78),('als-suites',223),('stack-positions',343),('stack-minifier',68),('arraybuffer',19),('worker-statistics',7),('arraybuffer-native',1),('arraybuffer-serializer',60),('inspection-idle',1),('sqlite-bigint',6),('bake-builtin',1),('bigint-matchers',2),('lazy-process-builtins',3),('bigint-serialization',18),('untrimmed-collator',1)]: +for name,minimum in [('quic-sni',19),('memory-release',3),('webkit-upgrade',11),('proxy',4),('resource-limits',16),('namespace',41),('inspector',78),('als-suites',223),('stack-positions',343),('stack-minifier',68),('arraybuffer',19),('worker-statistics',7),('arraybuffer-native',1),('arraybuffer-serializer',60),('inspection-idle',1),('bake-builtin',1),('bigint-matchers',2),('lazy-process-builtins',3),('bigint-serialization',18),('untrimmed-collator',1)]: text=(out/(name+'.log')).read_text() passes=re.findall(r'(\d+) pass',text) assert passes and int(passes[-1])>=minimum,name+' incomplete' @@ -24,6 +25,32 @@ if name=='untrimmed-collator':assert int(passes[-1])==1,'collator selection drift' if name in ('quic-sni','memory-release','webkit-upgrade','bigint-matchers','bigint-serialization','lazy-process-builtins','untrimmed-collator'):assert not re.search(r'\b[1-9]\d* skip\b',text),name+' tests skipped' counts[name]=int(passes[-1]) +sqlite_cases = { + 'sqlite-bigint.xml': ('test/js/node/sqlite/node-sqlite.test.ts', { + 'rejects oversized BigInt with ERR_INVALID_ARG_VALUE', + "bind error messages match node's exactly (trailing period)", + 'database-level defaults flow to prepared statements', + }), + 'sqlite-bigint-node.xml': ('test/js/node/test/parallel/test-sqlite-statement-sync.js', { + 'BigInts support can be toggled', + 'BigInt is required for reading large integers', + 'BigInts are returned when input is true', + }), +} +sqlite_count = 0 +for report, (file, expected) in sqlite_cases.items(): + cases = list(ElementTree.parse(out/report).iter('testcase')) + assert cases and all(case.find('failure') is None and case.find('error') is None for case in cases),report+' failed' + selected_cases = [case for case in cases if case.get('name') in expected] + assert len(selected_cases)==len(expected)==3 and {case.get('name') for case in selected_cases}==expected,report+' selection drift' + assert all(case.find('skipped') is not None for case in cases if case.get('name') not in expected),report+' unexpected case' + for case in selected_cases: + assert case.find('skipped') is None,report+' selected case skipped' + location = Path(case.attrib['file']) + assert location == (root/'bun'/file if location.is_absolute() else Path(file)),report+' wrong source file' + sqlite_count += len(selected_cases) +assert sqlite_count==6,'SQLite BigInt qualification incomplete' +counts['sqlite-bigint']=sqlite_count assert (out/'untrimmed-getters.log').read_text().strip()=='native URL getters passed','native URL getter smoke incomplete' for name in ['als-plugin','als-native','als-gc']: matrix=json.loads((out/(name+'.json')).read_text())['results'] diff --git a/.github/openclaw/qualify-sync.sh b/.github/openclaw/qualify-sync.sh index 31735951523da..ddf6f44ec0914 100644 --- a/.github/openclaw/qualify-sync.sh +++ b/.github/openclaw/qualify-sync.sh @@ -33,9 +33,15 @@ else fi if test "$selection_exit" -ne 0; then exit "$selection_exit"; fi "$candidate" test --expose-internals test/js/node/quic/quic-sni.test.ts > "$results/quic-sni.log" 2>&1 -"$candidate" test --expose-gc test/js/node/sqlite/node-sqlite.test.ts test/js/node/test/parallel/test-sqlite-statement-sync.js \ - -t "rejects oversized BigInt with ERR_INVALID_ARG_VALUE|bind error messages match node's exactly|database-level defaults flow to prepared statements|BigInts support can be toggled|BigInt is required for reading large integers|BigInts are returned when input is true" \ +"$candidate" test --expose-gc test/js/node/sqlite/node-sqlite.test.ts \ + -t "rejects oversized BigInt with ERR_INVALID_ARG_VALUE|bind error messages match node's exactly|database-level defaults flow to prepared statements" \ + --reporter=junit --reporter-outfile="$results/sqlite-bigint.xml" \ > "$results/sqlite-bigint.log" 2>&1 +"$candidate" test --expose-gc --config="$repo/bunfig.node-test.toml" \ + "$repo/test/js/node/test/parallel/test-sqlite-statement-sync.js" \ + -t 'BigInts support can be toggled|BigInt is required for reading large integers|BigInts are returned when input is true' \ + --reporter=junit --reporter-outfile="$results/sqlite-bigint-node.xml" \ + > "$results/sqlite-bigint-node.log" 2>&1 "$candidate" test test/bake/dev/production.test.ts \ -t 'builds a framework without server components and keeps its client entry point' \ > "$results/bake-builtin.log" 2>&1 From 9e9f49a9e2e628cb4ac3d8afbffa78d81fb77b77 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 15:11:49 +0800 Subject: [PATCH 12/35] fix(ci): link retained consumer probes with the allocator hook --- .../qualification/consumer-repair.json | 6 +- .../qualification/continue-consumer.py | 253 ++++++++++++++++++ .../qualification/probe-allocator.cpp | 8 + .../openclaw/qualification/resume-consumer.py | 66 +++-- .github/openclaw/qualify-sync.sh | 19 +- .../openclaw-hosted-linux-consumer.yml | 41 +-- 6 files changed, 346 insertions(+), 47 deletions(-) create mode 100644 .github/openclaw/qualification/continue-consumer.py create mode 100644 .github/openclaw/qualification/probe-allocator.cpp diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index cbef3f972c8ca..65857a7f7d0f1 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -8,7 +8,9 @@ "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc", "variants.json": "a181182de15f50d6c30d4d185a9d21cdea2093236dc17aa66628e65008c57bc7", - "qualify-sync.sh": "65d3d21f0b944e06c10b9b5521182048d6988f81f15859f29cf9a07464cf90cd", - "verify-sync.py": "e9aeb350b0de5e5b5962af9934985805985a2291b3e90ff0302fd6c427a1db23" + "qualify-sync.sh": "b124b19863695fbd67564e82531459ced2470b9000a6a4f04ae3dc40534ab33d", + "verify-sync.py": "e9aeb350b0de5e5b5962af9934985805985a2291b3e90ff0302fd6c427a1db23", + "continue-consumer.py": "a55846cee405937df5249ef56614ca81b0328dfa19d7398604523c7be9332a4a", + "probe-allocator.cpp": "d8d650722503c009a39a8a36e3c25b6a9c6c2a15e535377c39e30cea27455ba1" } } diff --git a/.github/openclaw/qualification/continue-consumer.py b/.github/openclaw/qualification/continue-consumer.py new file mode 100644 index 0000000000000..a079ef49feac0 --- /dev/null +++ b/.github/openclaw/qualification/continue-consumer.py @@ -0,0 +1,253 @@ +#!/usr/bin/env python3 +"""Finish only the two native probes for one admitted, already-tested Bun build.""" +import hashlib +import importlib +import json +from pathlib import Path, PurePosixPath +import shutil +import stat +import subprocess +import sys +import zipfile + +SYNC = "42e4245f4180941634b482a7e8ef7fca47467de5" +SOURCE = "2323913322dfdfed96ecf20163d62f5ff2796ecc" +RUN = 41279605249 +CARRIER = "bf6e21076fbaf4b442347f64b64b61917bd07c47" +ARTIFACTS = { + "proof": (13074375041, 409674, "8d09e24016faab6f2b8fa05b027a24321885f71e22c4ccf2855d3a047cfdbfe8"), + "binaries": (13073981057, 183496527, "73b2ed22fbd7b24b366f24edf6f834c5d5582a51ed13c0d25cc8f202e79f996b"), +} +PROOF_INVENTORY = "798eb71db1b9db8547831ae20405a2394c482ce645a4da1225a75af022c2807e" +VERIFIER = "e9aeb350b0de5e5b5962af9934985805985a2291b3e90ff0302fd6c427a1db23" +PROBE_BOUNDARY = "assert len((out/'engine-limits.log').read_text().splitlines())==9\n" +MIMALLOC = "bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o" + + +def sha(path): + with path.open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +def write_once(path, value): + with path.open("x") as stream: + stream.write(json.dumps(value, indent=2) + "\n") + + +def policy(pipeline): + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC + inputs = pipeline / ".github/openclaw/qualification" + sys.path.insert(0, str(inputs)) + return inputs, importlib.import_module("consumer_identity") + + +def unpack(retained, name): + artifact, size, digest = ARTIFACTS[name] + metadata = read(retained / (name + ".metadata.json")) + archive = retained / (name + ".zip") + assert metadata["id"] == artifact and not metadata["expired"] + assert metadata["workflow_run"]["id"] == RUN and metadata["workflow_run"]["head_sha"] == CARRIER + assert metadata["size_in_bytes"] == archive.stat().st_size == size + assert metadata["digest"] == "sha256:" + digest and sha(archive) == digest + destination = retained / name + destination.mkdir() + with zipfile.ZipFile(archive) as bundle: + entries = bundle.infolist() + assert len({entry.filename for entry in entries}) == len(entries) + assert 0 < len(entries) <= (154 if name == "proof" else 128) + assert sum(entry.file_size for entry in entries) <= (3719104 if name == "proof" else 512 * 1024**2) + if name == "proof": + inventory = [{"path": e.filename, "bytes": e.file_size, "mode": e.external_attr >> 16, + "directory": e.is_dir()} for e in entries] + encoded = json.dumps(inventory, separators=(",", ":"), sort_keys=True).encode() + assert len(entries) == 154 and hashlib.sha256(encoded).hexdigest() == PROOF_INVENTORY + for entry in entries: + path = PurePosixPath(entry.filename) + assert not path.is_absolute() and "\\" not in entry.filename and "\x00" not in entry.filename + assert all(part not in ("", ".", "..") for part in entry.filename.rstrip("/").split("/")) + mode = stat.S_IFMT(entry.external_attr >> 16) + assert mode in (0, stat.S_IFDIR if entry.is_dir() else stat.S_IFREG) + target = destination / path + if entry.is_dir(): + assert entry.file_size == 0 + target.mkdir(parents=True, exist_ok=True) + else: + target.parent.mkdir(parents=True, exist_ok=True) + with bundle.open(entry) as source, target.open("xb") as output: + shutil.copyfileobj(source, output) + target.chmod(0o600) + return destination + + +def runtime_evidence(inputs, root): + # Reuse the authoritative runtime assertions, stopping before either unfinished probe. + # The complete unchanged verifier runs only after both real probes finish. + verifier = inputs / "verify-sync.py" + assert sha(verifier) == VERIFIER + source = verifier.read_text() + assert source.count(PROBE_BOUNDARY) == 1 + previous = sys.argv + try: + sys.argv = [str(verifier), str(root)] + exec(compile(source.split(PROBE_BOUNDARY)[0], str(verifier), "exec"), + {"__file__": str(verifier), "__name__": "__retained_runtime_admission__"}) + finally: + sys.argv = previous + + +def engine_evidence(proof): + gate = read(proof / "engine-gate.json") + assert gate["passed"] is True and gate["source"] == SYNC + assert gate["stress_counts"]["jsc-stress"] >= 1400 and gate["stress_counts"]["jsc-modules"] >= 1600 + for name, count in gate["stress_counts"].items(): + lines = (proof / name / "results").read_text().splitlines() + assert len(lines) == count and all(line.endswith(": PASS") for line in lines), name + + +def receipts(inputs, identity, proof, binaries, engine): + baseline, candidate = [read(proof / (arm + "-identity.json")) for arm in ("baseline", "candidate")] + identity.validate_baseline_evidence(baseline, binaries, proof) + identity.validate_evidence(candidate, SYNC, engine, binaries, proof) + for arm in ("baseline", "candidate", "sync"): + identity.validate_invocation(proof, arm) + from compare_fork_ci import validate_arm + selected = read(proof / "candidate/selected.json") + assert len(selected) == 44 and validate_arm(proof / "candidate", selected)["all_passed"] + assert (proof / "baseline/selected.json").read_bytes() == (inputs / "selected.json").read_bytes() + candidate_sha = sha(proof / "candidate-identity.json") + gate = read(proof / "gate.json") + assert gate["passed"] is True and gate["source"] == SYNC and "upstream_sync" not in gate + assert gate["candidate_identity_sha256"] == candidate_sha + assert gate["baseline_identity_sha256"] == sha(proof / "baseline-identity.json") + assert gate["selected_files"] == 44 and gate["result_files"] == 46 + compatibility = read(proof / "compatibility-gate.json") + assert compatibility["passed"] is True and compatibility["source"] == SYNC + assert compatibility["candidate_identity_sha256"] == candidate_sha + assert compatibility["memory_tests"] == 3 and compatibility["startup"] is True + engine_evidence(proof) + assert not (proof / "sync-gate.json").exists() + failure = (proof / "sync/engine-limit-build.log").read_text() + assert "undefined reference to `Bun__outOfMemory'" in failure + assert not (proof / "sync/engine-limits.log").exists() + assert not (proof / "sync/engine-gc-progress.json").exists() + return candidate, gate + + +def prepare(pipeline, carrier, retained, root, artifacts, checkout, inspector): + inputs, identity = policy(pipeline) + assert subprocess.check_output(["git", "-C", str(carrier), "rev-parse", "HEAD"], text=True).strip() == read(root / "carrier.json")["carrier"] + assert not (root / "continuation.json").exists() and not (root / "bun").exists() + proof, binaries = [unpack(retained, name) for name in ("proof", "binaries")] + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), + artifacts / (identity.LANE + ".manifest.json"), SYNC) + old_carrier = read(proof / "carrier.json") + assert old_carrier["carrier"] == CARRIER and old_carrier["sync"] == SYNC + previous = read(proof / "reuse.json") + assert previous["candidate_repair_source"] == SOURCE and previous["sync"] == SYNC + manifest = read(inputs / "consumer-repair.json") + assert manifest["source"] == SOURCE and manifest["engine"] == SYNC + for name, digest in previous["repair"]["files"].items(): + if name != "qualify-sync.sh": + assert manifest["files"][name] == digest, "reused build/test policy changed: " + name + candidate, gate = receipts(inputs, identity, proof, binaries, engine) + # Retained SQLite reports contain absolute source paths. Preserve their original cwd. + assert Path(read(proof / "candidate-build-tools.json")["cwd"]) == root / "bun" + assert identity.git(checkout, "rev-parse", "HEAD", "HEAD^{tree}").decode().splitlines() == [ + identity.CONFIG["candidate"]["commit"], identity.CONFIG["candidate"]["tree"]] + assert not identity.git(checkout, "status", "--porcelain") + shutil.move(str(checkout), root / "bun") + reused = {} + for source in proof.rglob("*"): + if not source.is_file(): + continue + relative = source.relative_to(proof).as_posix() + target_name = {"carrier.json": "retained-carrier.json", "reuse.json": "retained-reuse.json", + "engine-artifact.json": "retained-engine-artifact.json", + "engine-zip-entries.json": "retained-engine-zip-entries.json", + "sync/engine-limit-build.log": "sync/engine-limit-build.previous.log"}.get(relative, relative) + target = root / target_name + target.parent.mkdir(parents=True, exist_ok=True) + assert not target.exists() + shutil.copyfile(source, target) + reused[target_name] = sha(source) + for name in (identity.BASELINE_EXECUTABLE, identity.EXECUTABLE, identity.FIXTURE, MIMALLOC): + target = root / name + assert not target.exists() + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(binaries / name, target) + target.chmod(0o700 if name in (identity.BASELINE_EXECUTABLE, identity.EXECUTABLE) else 0o600) + repo = root / "bun" + overlay = root / "candidate-manifest.patch" + subprocess.run(["git", "-C", str(repo), "apply", "--check", str(overlay)], check=True) + subprocess.run(["git", "-C", str(repo), "apply", str(overlay)], check=True) + engine_directory = root / "engine" + engine_directory.mkdir() + subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), "-C", str(engine_directory)], check=True) + identity.verify(root, engine, root / "candidate-identity.json", inspector) + runtime_evidence(inputs, root) + controls = {} + for name, digest in manifest["files"].items(): + path = inputs.parent / name if name in ("test_consumer_identity.py", "variants.json", "qualify-sync.sh") else inputs / name + assert sha(path) == digest + controls[name] = digest + write_once(root / "continuation.json", { + "run": RUN, "carrier": CARRIER, "source": SOURCE, "sync": SYNC, + "artifacts": ARTIFACTS, "proof_inventory_sha256": PROOF_INVENTORY, + "candidate_identity_sha256": sha(root / "candidate-identity.json"), + "mimalloc_sha256": sha(root / MIMALLOC), "ordinary_gate": gate, + "reused_files": reused, "controls": controls, + "manifest_sha256": sha(inputs / "consumer-repair.json"), + "continuation_carrier": read(root / "carrier.json"), + "candidate_build_reused": True, "candidate_runtime_evidence_reused": True, + }) + + +def admitted(pipeline, root, artifacts, inspector, *, completed=False): + inputs, identity = policy(pipeline) + record = read(root / "continuation.json") + assert record["run"] == RUN and record["carrier"] == CARRIER and record["source"] == SOURCE and record["sync"] == SYNC + assert record["artifacts"] == {key: list(value) for key, value in ARTIFACTS.items()} + assert record["proof_inventory_sha256"] == PROOF_INVENTORY + assert record["candidate_build_reused"] is True and record["candidate_runtime_evidence_reused"] is True + assert sha(inputs / "consumer-repair.json") == record["manifest_sha256"] + assert record["controls"] == read(inputs / "consumer-repair.json")["files"] + for name, digest in record["controls"].items(): + path = inputs.parent / name if name in ("test_consumer_identity.py", "variants.json", "qualify-sync.sh") else inputs / name + assert sha(path) == digest + for name, digest in record["reused_files"].items(): + if not (completed and name == "gate.json"): + assert sha(root / name) == digest, "reused evidence changed: " + name + assert sha(root / MIMALLOC) == record["mimalloc_sha256"] + assert sha(root / "candidate-identity.json") == record["candidate_identity_sha256"] + assert read(root / "carrier.json") == record["continuation_carrier"] + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), + artifacts / (identity.LANE + ".manifest.json"), SYNC) + identity.verify(root, engine, root / "candidate-identity.json", inspector) + runtime_evidence(inputs, root) + if completed: + gate = read(root / "gate.json") + assert {k: v for k, v in gate.items() if k not in ("upstream_sync", "engine", "compatibility")} == record["ordinary_gate"] + sync_gate = read(root / "sync-gate.json") + assert sync_gate["passed"] is True and sync_gate["source"] == SYNC + assert sync_gate["candidate_identity_sha256"] == record["candidate_identity_sha256"] + assert gate["upstream_sync"] == sync_gate + write_once(root / "continuation-complete.json", { + "passed": True, "continuation_sha256": sha(root / "continuation.json"), + "candidate_identity_sha256": record["candidate_identity_sha256"], + "sync_gate_sha256": sha(root / "sync-gate.json"), "gate_sha256": sha(root / "gate.json"), + }) + + +if __name__ == "__main__": + mode, *args = sys.argv[1:] + paths = [Path(value).resolve() for value in args] + if mode == "prepare": + prepare(*paths) + elif mode in ("admit", "seal"): + admitted(*paths, completed=mode == "seal") + else: + raise SystemExit("unknown fixed-run continuation command") diff --git a/.github/openclaw/qualification/probe-allocator.cpp b/.github/openclaw/qualification/probe-allocator.cpp new file mode 100644 index 0000000000000..04bd4e1616453 --- /dev/null +++ b/.github/openclaw/qualification/probe-allocator.cpp @@ -0,0 +1,8 @@ +#include + +// The standalone probes link Bun's mimalloc object without the executable +// that normally supplies its fatal allocation-failure hook. +extern "C" [[noreturn]] void Bun__outOfMemory() +{ + std::abort(); +} diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 2f5af2f80075f..502333d432380 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -28,6 +28,38 @@ def read(path): return json.loads(path.read_text()) +def install_controls(pipeline, carrier, identity): + frozen = pipeline / ".github/openclaw/qualification" + reviewed = carrier / ".github/openclaw/qualification" + source_manifest = read(reviewed / "consumer-repair.json") + assert source_manifest["source"] == SOURCE and source_manifest["engine"] == SYNC + expected_paths = {"harness-adapters.json", "harness_adapters.py", + "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch", + "test_consumer_identity.py", "variants.json", "qualify-sync.sh", "verify-sync.py", + "continue-consumer.py", "probe-allocator.cpp"} + assert set(source_manifest["files"]) == expected_paths + new_adapters = read(reviewed / "harness-adapters.json") + assert new_adapters["arms"]["baseline"] == identity.ADAPTERS["arms"]["baseline"] + assert new_adapters["origins"] == identity.ADAPTERS["origins"] + variants = read(reviewed.parent / "variants.json") + original_variants = identity.CONFIG + assert {k: v for k, v in variants.items() if k != "candidate"} == { + k: v for k, v in original_variants.items() if k != "candidate"} + assert variants["candidate"] == { + "commit": "d9be087429c21e563bb5ac29f8a11805e64b56a3", + "tree": "980068aa5aa9f51f40fc4125114a68fccd9bc9dc", + "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218"} + assert new_adapters["arms"]["candidate"]["pin"] == variants["candidate"]["commit"] + parent_files = {"test_consumer_identity.py", "variants.json", "qualify-sync.sh"} + for name, digest in source_manifest["files"].items(): + source = reviewed.parent / name if name in parent_files else reviewed / name + target = frozen.parent / name if name in parent_files else frozen / name + assert sha(source) == digest, name + shutil.copyfile(source, target) + + return source_manifest + + def main(): pipeline, carrier, retained, root, artifacts = [Path(p).resolve() for p in sys.argv[1:]] assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC @@ -85,30 +117,7 @@ def main(): subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), "-C", str(engine_directory)], check=True) - source_manifest = read(reviewed / "consumer-repair.json") - assert source_manifest["source"] == SOURCE and source_manifest["engine"] == SYNC - expected_paths = {"harness-adapters.json", "harness_adapters.py", - "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch", - "test_consumer_identity.py", "variants.json", "qualify-sync.sh", "verify-sync.py"} - assert set(source_manifest["files"]) == expected_paths - new_adapters = read(reviewed / "harness-adapters.json") - assert new_adapters["arms"]["baseline"] == identity.ADAPTERS["arms"]["baseline"] - assert new_adapters["origins"] == identity.ADAPTERS["origins"] - variants = read(reviewed.parent / "variants.json") - original_variants = identity.CONFIG - assert {k: v for k, v in variants.items() if k != "candidate"} == { - k: v for k, v in original_variants.items() if k != "candidate"} - assert variants["candidate"] == { - "commit": "d9be087429c21e563bb5ac29f8a11805e64b56a3", - "tree": "980068aa5aa9f51f40fc4125114a68fccd9bc9dc", - "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218"} - assert new_adapters["arms"]["candidate"]["pin"] == variants["candidate"]["commit"] - parent_files = {"test_consumer_identity.py", "variants.json", "qualify-sync.sh"} - for name, digest in source_manifest["files"].items(): - source = reviewed.parent / name if name in parent_files else reviewed / name - target = frozen.parent / name if name in parent_files else frozen / name - assert sha(source) == digest, name - shutil.copyfile(source, target) + source_manifest = install_controls(pipeline, carrier, identity) # Candidate receipts and executables are deliberately not copied across source changes. # Keep the normal build, identity creation, selection and every later gate. @@ -138,4 +147,11 @@ def main(): if __name__ == "__main__": - main() + if len(sys.argv) == 4 and sys.argv[1] == "install": + pipeline, carrier = [Path(p).resolve() for p in sys.argv[2:]] + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC + sys.path.insert(0, str(pipeline / ".github/openclaw/qualification")) + import consumer_identity as identity + install_controls(pipeline, carrier, identity) + else: + main() diff --git a/.github/openclaw/qualify-sync.sh b/.github/openclaw/qualify-sync.sh index ddf6f44ec0914..6ab54657a10b0 100644 --- a/.github/openclaw/qualify-sync.sh +++ b/.github/openclaw/qualify-sync.sh @@ -15,6 +15,17 @@ unset BUN_BUILD_PREFETCH_DIR BUN_BUILD_CACHE_DIR BUN_WEBKIT_ARTIFACT_MANIFEST export CI=1 PUPPETEER_SKIP_DOWNLOAD=1 cd "$repo" results="$QUALIFICATION_DIR/sync" +probe_only=0 +case "${1:-}" in + "") test "$#" -eq 0 ;; + --retained-probes) + test "$#" -eq 1 + python3 "$inputs/continue-consumer.py" admit "$pipeline" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$INSPECTOR_RUNTIME" + probe_only=1 + ;; + *) echo "unknown sync qualification entry point" >&2; exit 2 ;; +esac +if test "$probe_only" -eq 0; then mkdir -p "$results/home" "$results/tmp" "$results/bin" chmod 700 "$results/home" "$results/tmp" "$candidate" --revision > "$results/revision.log" @@ -80,19 +91,23 @@ python3 "$inputs/stack/check-runtime-cache.py" --baseline "$QUALIFICATION_DIR/bu BUN_JSC_collectContinuously=1 "$candidate" "$inputs/module-context.mjs" matrix > "$results/als-gc.json" "$candidate" "$inputs/als/realm-require.mjs" > "$results/als-realm.log" 2>&1 "$candidate" "$inputs/als/retention.mjs" > "$results/als-retention.json" 2>&1 +fi WK="$QUALIFICATION_DIR/engine/bun-webkit" clang++-23 -std=c++23 -O2 -DNDEBUG -DBUILDING_WITH_CMAKE=1 -DHAVE_CONFIG_H=1 \ -I"$WK/include" -I"$WK/include/JavaScriptCore" -I"$WK/include/wtf" -I"$pipeline/Source/JavaScriptCore" \ "$pipeline/Source/JavaScriptCore/aot/runtime/AOTNoFeatureRemoved.cpp" \ - "$inputs/engine-limit-probe.cpp" "$repo/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o" \ + "$inputs/engine-limit-probe.cpp" "$inputs/probe-allocator.cpp" "$repo/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o" \ -Wl,--start-group "$WK"/lib/*.a -Wl,--end-group -lpthread -ldl -lm -latomic \ -o "$results/engine-limit-probe" > "$results/engine-limit-build.log" 2>&1 "$results/engine-limit-probe" > "$results/engine-limits.log" 2>&1 clang++-23 -std=c++23 -O2 -DNDEBUG -DBUILDING_WITH_CMAKE=1 -DHAVE_CONFIG_H=1 \ -I"$WK/include" -I"$WK/include/JavaScriptCore" -I"$WK/include/wtf" -I"$pipeline/Source/JavaScriptCore" \ "$pipeline/Source/JavaScriptCore/aot/runtime/AOTNoFeatureRemoved.cpp" \ - "$inputs/engine-gc-progress-probe.cpp" "$repo/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o" \ + "$inputs/engine-gc-progress-probe.cpp" "$inputs/probe-allocator.cpp" "$repo/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o" \ -Wl,--start-group "$WK"/lib/*.a -Wl,--end-group -lpthread -ldl -lm -latomic \ -o "$results/engine-gc-progress-probe" > "$results/engine-gc-progress-build.log" 2>&1 "$results/engine-gc-progress-probe" > "$results/engine-gc-progress.json" 2> "$results/engine-gc-progress.log" python3 "$inputs/verify-sync.py" "$QUALIFICATION_DIR" "$SOURCE_SHA" "$ARTIFACT_DIR" "$CANDIDATE_RECEIPT" "$INSPECTOR_RUNTIME" +if test "$probe_only" -eq 1; then + python3 "$inputs/continue-consumer.py" seal "$pipeline" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$INSPECTOR_RUNTIME" +fi diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 045e2279c298e..2d13a5659e36f 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -5,6 +5,8 @@ on: paths: - .github/workflows/openclaw-hosted-linux-consumer.yml - .github/openclaw/qualification/resume-consumer.py + - .github/openclaw/qualification/continue-consumer.py + - .github/openclaw/qualification/probe-allocator.cpp - .github/openclaw/qualification/consumer-repair.json - .github/openclaw/qualification/harness-adapters.json - .github/openclaw/qualification/harness_adapters.py @@ -55,7 +57,14 @@ jobs: persist-credentials: false path: carrier sparse-checkout: .github/openclaw - - name: Make room for an independent candidate build + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: openclaw/bun + ref: d9be087429c21e563bb5ac29f8a11805e64b56a3 + fetch-depth: 1 + persist-credentials: false + path: retained-bun-source + - name: Prepare the fixed-run continuation workspace shell: bash run: | set -euo pipefail @@ -68,7 +77,7 @@ jobs: import json, os, shutil from pathlib import Path capacity = dict(cpus=os.cpu_count(), disk_free_bytes=shutil.disk_usage('.').free) - assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'candidate build and retained baseline need 40 GiB free' + assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'retained source, executables and engine need 40 GiB free' Path(os.environ['QUALIFICATION_DIR']).mkdir() Path(os.environ['QUALIFICATION_DIR'], 'carrier.json').write_text(json.dumps(dict( carrier=os.environ['CARRIER_COMMIT'], sync=os.environ['SYNC_COMMIT'], @@ -147,7 +156,7 @@ jobs: curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bun.zip" unzip -q "$RUNNER_TEMP/bun.zip" -d "$RUNNER_TEMP/bootstrap" echo "$RUNNER_TEMP/bootstrap/bun-linux-x64" >> "$GITHUB_PATH" - - name: Download unchanged engine and baseline evidence + - name: Download the exact completed build and runtime evidence timeout-minutes: 5 env: GH_TOKEN: ${{ github.token }} @@ -155,15 +164,15 @@ jobs: run: | set -euo pipefail mkdir "$RUNNER_TEMP/retained" - gh api repos/openclaw/WebKit/actions/artifacts/13068952583 > "$RUNNER_TEMP/retained/proof.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13068952583/zip > "$RUNNER_TEMP/retained/proof.zip" - gh api repos/openclaw/WebKit/actions/artifacts/13068828135 > "$RUNNER_TEMP/retained/binaries.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13068828135/zip > "$RUNNER_TEMP/retained/binaries.zip" - - name: Admit baseline proof and install the integrated consumer controls + gh api repos/openclaw/WebKit/actions/artifacts/13074375041 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13074375041/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13073981057 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13073981057/zip > "$RUNNER_TEMP/retained/binaries.zip" + - name: Install the reviewed continuation and unchanged consumer policy shell: bash run: | set -euo pipefail - python3 carrier/.github/openclaw/qualification/resume-consumer.py "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" + python3 carrier/.github/openclaw/qualification/resume-consumer.py install "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" - name: Verify contracts with the reviewed adapters shell: bash run: | @@ -175,22 +184,18 @@ jobs: python3 .github/openclaw/test_consumer_identity.py python3 .github/openclaw/test_verify_jsc_results.py bash .github/openclaw/preflight.sh - - name: Build and qualify the integrated consumer from source + - name: Admit the retained suites and finish both native probes shell: bash run: | set -euo pipefail unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" - tail -n +1 -F "$QUALIFICATION_DIR/build-candidate.log" & - tail_pid=$! - (while sleep 60; do date -u; free -m; df -h /; done) & - monitor_pid=$! - trap 'kill "$tail_pid" "$monitor_pid" 2>/dev/null || true' EXIT - bash "$QUALIFICATION_DIR/qualify-candidate-fresh.sh" + python3 .github/openclaw/qualification/continue-consumer.py prepare \ + "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" \ + "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$GITHUB_WORKSPACE/retained-bun-source" "$INSPECTOR_RUNTIME" export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" - bash .github/openclaw/qualify-sync-compatibility.sh - bash .github/openclaw/qualify-sync.sh + bash .github/openclaw/qualify-sync.sh --retained-probes - name: Retain the exact qualified Bun executables if: always() uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a From a8d8e9a49c63ac1ea351a1af5f4dfafdccde206d Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 15:20:38 +0800 Subject: [PATCH 13/35] fix(ci): install the verified consumer repair manifest --- .github/openclaw/qualification/resume-consumer.py | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 502333d432380..492506bb9a77b 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -56,6 +56,7 @@ def install_controls(pipeline, carrier, identity): target = frozen.parent / name if name in parent_files else frozen / name assert sha(source) == digest, name shutil.copyfile(source, target) + shutil.copyfile(reviewed / "consumer-repair.json", frozen / "consumer-repair.json") return source_manifest From bfea5fad536fe27d6beb39bdf64106536418428f Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 15:32:49 +0800 Subject: [PATCH 14/35] fix(ci): qualify the full WebKit artifact matrix against integrated Bun --- .github/openclaw/artifacts.py | 19 +++++- .../openclaw/qualification/resume-consumer.py | 41 +++++++----- .github/openclaw/test_artifacts.py | 66 +++++++++++++++++++ .github/workflows/openclaw-artifacts.yml | 65 +++++++++++++++--- 4 files changed, 164 insertions(+), 27 deletions(-) diff --git a/.github/openclaw/artifacts.py b/.github/openclaw/artifacts.py index 81a63ee912213..b0a82f9b1627f 100644 --- a/.github/openclaw/artifacts.py +++ b/.github/openclaw/artifacts.py @@ -83,12 +83,29 @@ def preflight(): if sha != os.environ['INPUT_SHA'] or sha != os.environ['GITHUB_SHA']: raise ValueError('dispatch must use the same reviewed branch head and full input SHA') ref = os.environ['GITHUB_REF'] + carrier_ref = 'refs/heads/claude/hosted-linux-consumer-20261031' qualification_only = ( - ref == 'refs/heads/claude/sync-webkit-upstream-20261014' + ref in ('refs/heads/claude/sync-webkit-upstream-20261014', carrier_ref) and os.environ.get('INPUT_PUBLISH') == 'false' ) if ref not in ('refs/heads/openclaw/main', 'refs/heads/openclaw/batch-1', 'refs/heads/openclaw/release-5718a6ec') and not qualification_only: raise ValueError('only an explicitly permitted owned branch may run this workflow') + engine_sha = os.environ.get('ENGINE_SHA', sha) + if ref == carrier_ref: + expected = '42e4245f4180941634b482a7e8ef7fca47467de5' + if engine_sha != expected: + raise ValueError('qualification engine source mismatch') + run('git', '-C', str(ROOT), 'merge-base', '--is-ancestor', expected, sha) + frozen_config = json.loads(capture('git', '-C', str(ROOT), 'show', + expected + ':.github/openclaw/variants.json')) + frozen_config['candidate'] = { + 'commit': 'd9be087429c21e563bb5ac29f8a11805e64b56a3', + 'tree': '980068aa5aa9f51f40fc4125114a68fccd9bc9dc', + 'manifest_blob': 'e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218'} + if CONFIG != frozen_config: + raise ValueError('qualification matrix/configuration drift') + elif engine_sha != sha: + raise ValueError('engine source must match dispatch head') upstream = {l['label'] for l in lane_definitions()} wanted = [l['label'] for l in CONFIG['lanes']] if len(set(wanted)) != len(wanted) or not set(wanted) <= upstream: diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 492506bb9a77b..a2dc22b4178c7 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -62,7 +62,11 @@ def install_controls(pipeline, carrier, identity): def main(): - pipeline, carrier, retained, root, artifacts = [Path(p).resolve() for p in sys.argv[1:]] + args = sys.argv[1:] + fresh_engine = bool(args and args[0] == "--fresh-engine") + if fresh_engine: + args = args[1:] + pipeline, carrier, retained, root, artifacts = [Path(p).resolve() for p in args] assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC frozen = pipeline / ".github/openclaw/qualification" reviewed = carrier / ".github/openclaw/qualification" @@ -86,12 +90,13 @@ def main(): assert len(read(frozen / "selected.json")) == 44 old_carrier = read(proof / "carrier.json") assert old_carrier["carrier"] == PREVIOUS_CARRIER and old_carrier["sync"] == SYNC - engine_gate = read(proof / "engine-gate.json") + engine_proof = root if fresh_engine else proof + engine_gate = read(engine_proof / "engine-gate.json") assert engine_gate["passed"] is True and engine_gate["source"] == SYNC assert engine_gate["stress_counts"]["jsc-stress"] >= 1400 assert engine_gate["stress_counts"]["jsc-modules"] >= 1600 for name, count in engine_gate["stress_counts"].items(): - lines = (proof / name / "results").read_text().splitlines() + lines = (engine_proof / name / "results").read_text().splitlines() assert len(lines) == count and all(line.endswith(": PASS") for line in lines), name shutil.copytree(proof / "baseline", root / "baseline") @@ -103,20 +108,21 @@ def main(): shutil.copyfile(binaries / identity.BASELINE_EXECUTABLE, executable) assert sha(executable) == baseline["executable"]["sha256"] executable.chmod(0o700) - # Preserve original engine evidence; the engine and historical baseline are unchanged. - for path in proof.rglob("*"): - relative = path.relative_to(proof) - if not path.is_file(): - continue - name = relative.parts[0] - if name.startswith(("jsc-", "sampling-", "accounting-")) or name in ("engine-gate.json", "stack-visitor.log"): - destination = root / relative - destination.parent.mkdir(parents=True, exist_ok=True) - shutil.copyfile(path, destination) - engine_directory = root / "engine" - engine_directory.mkdir() - subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), - "-C", str(engine_directory)], check=True) + if not fresh_engine: + # Preserve original engine evidence; the engine and historical baseline are unchanged. + for path in proof.rglob("*"): + relative = path.relative_to(proof) + if not path.is_file(): + continue + name = relative.parts[0] + if name.startswith(("jsc-", "sampling-", "accounting-")) or name in ("engine-gate.json", "stack-visitor.log"): + destination = root / relative + destination.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, destination) + engine_directory = root / "engine" + engine_directory.mkdir() + subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), + "-C", str(engine_directory)], check=True) source_manifest = install_controls(pipeline, carrier, identity) @@ -140,6 +146,7 @@ def main(): "baseline_identity_sha256": sha(root / "baseline-identity.json"), "baseline_invocation_sha256": sha(root / "baseline/invocation.json"), "engine_gate_sha256": sha(root / "engine-gate.json"), + "engine_evidence_reused": not fresh_engine, "candidate_driver_sha256": sha(driver), "candidate_build_reused": False, "candidate_selection_reused": False, diff --git a/.github/openclaw/test_artifacts.py b/.github/openclaw/test_artifacts.py index ff5f0ae99c70f..738c8ad16e732 100644 --- a/.github/openclaw/test_artifacts.py +++ b/.github/openclaw/test_artifacts.py @@ -1,4 +1,6 @@ +import copy import hashlib +import json import os from pathlib import Path import subprocess @@ -192,5 +194,69 @@ def test_sync_branch_is_qualification_only(self): self.assertFalse(output.exists()) + def test_consumer_carrier_requires_exact_engine_and_frozen_matrix(self): + engine = '42e4245f4180941634b482a7e8ef7fca47467de5' + original = copy.deepcopy(artifacts.CONFIG) + original['candidate'] = {'commit': 'b' * 40, 'tree': 'c' * 40, 'manifest_blob': 'd' * 40} + cases = [ + ('false', engine, None, None), + ('true', engine, None, 'permitted owned branch'), + (None, engine, None, 'permitted owned branch'), + ('false', 'e' * 40, None, 'engine source mismatch'), + ('false', engine, 'baseline', 'matrix/configuration drift'), + ('false', engine, 'lanes', 'matrix/configuration drift'), + ('false', engine, 'candidate', 'matrix/configuration drift'), + ] + with tempfile.TemporaryDirectory() as temporary: + for publish, source, drift, error in cases: + with self.subTest(publish=publish, engine=source, drift=drift): + output = Path(temporary) / 'output' + output.unlink(missing_ok=True) + config = copy.deepcopy(artifacts.CONFIG) + if drift == 'baseline': + config['baseline']['commit'] = 'f' * 40 + elif drift == 'lanes': + config['lanes'][0]['consumer'] = 'changed consumer' + elif drift == 'candidate': + config['candidate']['commit'] = 'f' * 40 + env = {'GITHUB_REF': 'refs/heads/claude/hosted-linux-consumer-20261031', + 'INPUT_SHA': 'a' * 40, 'GITHUB_SHA': 'a' * 40, + 'ENGINE_SHA': source, 'GITHUB_OUTPUT': str(output)} + if publish is not None: + env['INPUT_PUBLISH'] = publish + with patch.dict(os.environ, env, clear=True), patch.object( + artifacts, 'source', return_value={'source': 'a' * 40}), patch.object( + artifacts, 'CONFIG', config), patch.object( + artifacts, 'capture', return_value=json.dumps(original)), patch.object( + artifacts, 'run') as ancestry, patch.object( + artifacts, 'lane_definitions', return_value=config['lanes']) as lanes: + if error: + with self.assertRaisesRegex(ValueError, error): + artifacts.preflight() + lanes.assert_not_called() + self.assertFalse(output.exists()) + else: + artifacts.preflight() + matrix = json.loads(output.read_text().split('=', 1)[1]) + self.assertEqual(matrix['include'], [{'lane': lane['label']} for lane in config['lanes']]) + ancestry.assert_called_once_with('git', '-C', str(artifacts.ROOT), + 'merge-base', '--is-ancestor', engine, 'a' * 40) + + def test_consumer_carrier_rejects_unrelated_history_before_lane_admission(self): + with tempfile.TemporaryDirectory() as temporary: + output = Path(temporary) / 'output' + env = {'GITHUB_REF': 'refs/heads/claude/hosted-linux-consumer-20261031', + 'INPUT_SHA': 'a' * 40, 'GITHUB_SHA': 'a' * 40, 'INPUT_PUBLISH': 'false', + 'ENGINE_SHA': '42e4245f4180941634b482a7e8ef7fca47467de5', 'GITHUB_OUTPUT': str(output)} + with patch.dict(os.environ, env, clear=True), patch.object( + artifacts, 'source', return_value={'source': 'a' * 40}), patch.object( + artifacts, 'run', side_effect=subprocess.CalledProcessError(1, ['git'])), patch.object( + artifacts, 'lane_definitions') as lanes: + with self.assertRaises(subprocess.CalledProcessError): + artifacts.preflight() + lanes.assert_not_called() + self.assertFalse(output.exists()) + + if __name__ == '__main__': unittest.main() diff --git a/.github/workflows/openclaw-artifacts.yml b/.github/workflows/openclaw-artifacts.yml index 60bce5ac775b8..fe03f8c5b490e 100644 --- a/.github/workflows/openclaw-artifacts.yml +++ b/.github/workflows/openclaw-artifacts.yml @@ -12,6 +12,9 @@ on: default: false permissions: contents: read + actions: read +env: + ENGINE_SHA: ${{ github.ref == 'refs/heads/claude/hosted-linux-consumer-20261031' && '42e4245f4180941634b482a7e8ef7fca47467de5' || github.sha }} concurrency: group: openclaw-artifacts-${{ inputs.sha }} cancel-in-progress: false @@ -22,7 +25,8 @@ jobs: (github.ref == 'refs/heads/openclaw/main' || github.ref == 'refs/heads/openclaw/batch-1' || github.ref == 'refs/heads/openclaw/release-5718a6ec' || - (github.ref == 'refs/heads/claude/sync-webkit-upstream-20261014' && + ((github.ref == 'refs/heads/claude/sync-webkit-upstream-20261014' || + github.ref == 'refs/heads/claude/hosted-linux-consumer-20261031') && inputs.publish == false)) runs-on: blacksmith-32vcpu-ubuntu-2404 timeout-minutes: 10 @@ -44,7 +48,7 @@ jobs: !/WebDriverTests/ - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: - node-version: '26.3.0' + node-version: '26.12.1' - name: Test publication integrity gates run: | python3 .github/openclaw/test_artifacts.py @@ -71,6 +75,7 @@ jobs: steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: + ref: ${{ env.ENGINE_SHA }} fetch-depth: 0 persist-credentials: false sparse-checkout-cone-mode: false @@ -84,7 +89,7 @@ jobs: !/WebDriverTests/ - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: - node-version: '26.3.0' + node-version: '26.12.1' - name: Build unchanged upstream lane and record provenance env: LANE: ${{ matrix.lane }} @@ -104,18 +109,20 @@ jobs: steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: + ref: ${{ env.ENGINE_SHA }} persist-credentials: false sparse-checkout-cone-mode: false sparse-checkout: | /.github/ /Tools/ + /Source/JavaScriptCore/ /JSTests/stress/ /JSTests/modules/ /JSTests/*.yaml /JSTests/BUN-TEST-DIFFERENCES.md - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: - node-version: '26.3.0' + node-version: '26.12.1' - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c with: name: bun-webkit-linux-amd64 @@ -135,14 +142,41 @@ jobs: curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bun.zip" unzip -q "$RUNNER_TEMP/bun.zip" -d "$RUNNER_TEMP/bootstrap" echo "$RUNNER_TEMP/bootstrap/bun-linux-x64" >> "$GITHUB_PATH" - - name: Build baseline and candidate Bun, then qualify the same candidate + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + if: github.ref == 'refs/heads/claude/hosted-linux-consumer-20261031' + with: + ref: ${{ github.sha }} + persist-credentials: false + path: carrier + sparse-checkout: .github/openclaw + - name: Download the unchanged historical baseline proof + if: github.ref == 'refs/heads/claude/hosted-linux-consumer-20261031' + env: + GH_TOKEN: ${{ github.token }} + run: | + set -euo pipefail + mkdir "$RUNNER_TEMP/retained" + gh api repos/openclaw/WebKit/actions/artifacts/13068952583 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13068952583/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13068828135 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13068828135/zip > "$RUNNER_TEMP/retained/binaries.zip" + - name: Qualify the new engine archive and build the exact candidate env: ARTIFACT_DIR: ${{ runner.temp }}/linux-artifact QUALIFICATION_DIR: ${{ runner.temp }}/qualification run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" + test "$(node --version)" = v26.12.1 bash .github/openclaw/qualify-engine.sh - bash .github/openclaw/qualify.sh + if test "$GITHUB_REF" = refs/heads/claude/hosted-linux-consumer-20261031; then + python3 carrier/.github/openclaw/qualification/resume-consumer.py --fresh-engine "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" + python3 .github/openclaw/test_consumer_identity.py + bash "$QUALIFICATION_DIR/qualify-candidate-fresh.sh" + else + bash .github/openclaw/qualify.sh + fi export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" bash .github/openclaw/qualify-sync-compatibility.sh @@ -155,6 +189,7 @@ jobs: path: | ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts ${{ runner.temp }}/qualification/*.sha256 compression-level: 0 @@ -191,6 +226,7 @@ jobs: steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: + ref: ${{ env.ENGINE_SHA }} persist-credentials: false sparse-checkout: | .github @@ -201,7 +237,7 @@ jobs: path: ${{ runner.temp }}/windows-artifact - name: Qualify native ARM64 engine shell: pwsh - run: ./.github/openclaw/qualify-windows-arm64.ps1 -ArtifactDirectory "$env:RUNNER_TEMP/windows-artifact" -OutputDirectory "$env:RUNNER_TEMP/windows-proof" -Source $env:GITHUB_SHA + run: ./.github/openclaw/qualify-windows-arm64.ps1 -ArtifactDirectory "$env:RUNNER_TEMP/windows-artifact" -OutputDirectory "$env:RUNNER_TEMP/windows-proof" -Source $env:ENGINE_SHA - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a if: always() with: @@ -218,6 +254,7 @@ jobs: steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: + ref: ${{ env.ENGINE_SHA }} persist-credentials: false sparse-checkout: | .github @@ -227,10 +264,20 @@ jobs: - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c with: path: ${{ runner.temp }}/inputs + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + if: github.ref == 'refs/heads/claude/hosted-linux-consumer-20261031' + with: + ref: ${{ github.sha }} + persist-credentials: false + path: carrier + sparse-checkout: .github/openclaw + - name: Install the exact reviewed consumer policy for assembly + if: github.ref == 'refs/heads/claude/hosted-linux-consumer-20261031' + run: python3 carrier/.github/openclaw/qualification/resume-consumer.py install "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" - name: Assemble complete release and verify checksums run: | - python3 .github/openclaw/release.py assemble --source "$GITHUB_SHA" --inputs "$RUNNER_TEMP/inputs" --directory "$RUNNER_TEMP/release" - python3 .github/openclaw/release.py verify --source "$GITHUB_SHA" --directory "$RUNNER_TEMP/release" + python3 .github/openclaw/release.py assemble --source "$ENGINE_SHA" --inputs "$RUNNER_TEMP/inputs" --directory "$RUNNER_TEMP/release" + python3 .github/openclaw/release.py verify --source "$ENGINE_SHA" --directory "$RUNNER_TEMP/release" - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a with: name: release From fe913cc9c90efd8fdc9c9f5be06ef3450d63cab4 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 17:50:42 +0800 Subject: [PATCH 15/35] fix(ci): replay matrix consumer checks with deterministic cache pressure --- .../qualification/consumer-repair.json | 4 +- .../qualification/harness-adapters.json | 9 +- .../harness-adapters/candidate-test.patch | 19 +++ .../openclaw/qualification/resume-consumer.py | 135 +++++++++++++++++- .../openclaw-hosted-linux-consumer.yml | 86 +++++------ 5 files changed, 209 insertions(+), 44 deletions(-) diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index 65857a7f7d0f1..9ea04320e9988 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -2,10 +2,10 @@ "source": "2323913322dfdfed96ecf20163d62f5ff2796ecc", "engine": "42e4245f4180941634b482a7e8ef7fca47467de5", "files": { - "harness-adapters.json": "4ba71d03cac2a000b8f49c6f4f0954462bf3b275968395455bd9130fb1f17523", + "harness-adapters.json": "b8f26ddac333687c8bbfb8f0f9508822065d4ae7027059fcb4a979af426a321e", "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", "harness-adapters/candidate-build.patch": "414c02660faa9dcc48c383458dbe13dea5c9a26a7f3abc62265ea637ec074769", - "harness-adapters/candidate-test.patch": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", + "harness-adapters/candidate-test.patch": "6a56f290ef1d0b87f50e7c8311913b3f562bae15fd8bf22ab02289fa8005062b", "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc", "variants.json": "a181182de15f50d6c30d4d185a9d21cdea2093236dc17aa66628e65008c57bc7", "qualify-sync.sh": "b124b19863695fbd67564e82531459ced2470b9000a6a4f04ae3dc40534ab33d", diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index b88ca083da267..5d64aea7bd712 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -182,7 +182,7 @@ }, "test": { "patch": "harness-adapters/candidate-test.patch", - "sha256": "a85d6648cff0bd041a19be98a21d1d299da3704198b9c876ff683dd1182162d7", + "sha256": "6a56f290ef1d0b87f50e7c8311913b3f562bae15fd8bf22ab02289fa8005062b", "files": { "scripts/buildkite.ts": { "before": "cf1999381cf38d34b9892118266614ae2b81a28066d47a455aa15794fb2c1c3e", @@ -211,6 +211,13 @@ "base_blob": "361d675936e9694835956eebbd9b4256f8b9e5e3", "adapted_blob": "7e448388ceb3dc10781b55f1df4e72d10f8637c3", "mode": "100644" + }, + "test/js/node/vm/vm.test.ts": { + "before": "12d833538525702ce2fee1e3f76946e8886af26bf368af0abab74241f8ab8433", + "after": "c5c057e5832f4aaf1adbaff5df127ad1f8c4cf8614f436c293d06ac9588aa87f", + "base_blob": "179eb48620280040bd7808653731f6aba7cb81f5", + "adapted_blob": "1be67b432d1121e6978cc9557c78b15326877879", + "mode": "100644" } } } diff --git a/.github/openclaw/qualification/harness-adapters/candidate-test.patch b/.github/openclaw/qualification/harness-adapters/candidate-test.patch index 884596f752708..6f4a80e06b6c1 100644 --- a/.github/openclaw/qualification/harness-adapters/candidate-test.patch +++ b/.github/openclaw/qualification/harness-adapters/candidate-test.patch @@ -716,3 +716,22 @@ index 361d675936e9694835956eebbd9b4256f8b9e5e3..7e448388ceb3dc10781b55f1df4e72d1 describe("process.stdout", () => { it("should allow us to write to it", done => { const child = spawn(bunExe(), [CHILD_PROCESS_FILE, "STDOUT"], { +diff --git a/test/js/node/vm/vm.test.ts b/test/js/node/vm/vm.test.ts +index 179eb48620280040bd7808653731f6aba7cb81f5..1be67b432d1121e6978cc9557c78b15326877879 100644 +--- a/test/js/node/vm/vm.test.ts ++++ b/test/js/node/vm/vm.test.ts +@@ -3775,8 +3775,12 @@ describe("bounded vm compilation cache", () => { + const first = compile(); first(); + const second = compile(); + assert.equal(shared(first, second), true); +- for (let i = 0; i < 80; i++) new Script("(() => " + i + ")", { filename: "churn-" + i + ".js" }).runInThisContext()(); +- assert.ok(stats().evictions > 0); ++ const beforePressure = stats(); ++ assert.equal(beforePressure.entries, 1); ++ // A near-budget entry forces the shared source out regardless of its measured compile cost. ++ new Script("/* " + Buffer.alloc(26 * 1024, "x").toString() + " */ (() => 7)", { filename: "pressure.js" }).runInThisContext()(); ++ assert.equal(stats().evictions, beforePressure.evictions + 1); ++ assert.equal(stats().entries, 1); + assert.ok(stats().bytes <= stats().limit); + Bun.gc(true); + assert.equal(first(), 42); diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index a2dc22b4178c7..6836e42039a9b 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -154,8 +154,141 @@ def main(): }, indent=2) + "\n") +MATRIX_RUN = 41286392252 +MATRIX_CARRIER = "bfea5fad536fe27d6beb39bdf64106536418428f" +MATRIX_ARTIFACTS = { + "proof": (13077667443, 144089, "1b86433996f4e980474eab578aa73c5146064505433080ee7451bc33164e30ba"), + "binaries": (13077208926, 183496528, "01af375c560db6655ec4915f85e206ceb764e8205cf944562f3c6be6c1ec7251"), +} +MIMALLOC = "bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o" + + +def replay_matrix(pipeline, carrier, retained, root, artifacts, checkout, inspector): + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC + assert not (root / "matrix-replay.json").exists() and not (root / "bun").exists() + inputs = pipeline / ".github/openclaw/qualification" + sys.path.insert(0, str(inputs)) + import consumer_identity as identity + diagnostic = carrier / ".github/openclaw/qualification/diagnose-retained-consumer.py" + assert sha(diagnostic) == DIAGNOSTIC_SHA + spec = importlib.util.spec_from_file_location("retained_diagnostic", diagnostic) + module = importlib.util.module_from_spec(spec) + spec.loader.exec_module(module) + proof, binaries = [module.unpack(retained, name, expected=MATRIX_ARTIFACTS[name], + run=MATRIX_RUN, carrier=MATRIX_CARRIER) + for name in ("proof", "binaries")] + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), + artifacts / (identity.LANE + ".manifest.json"), SYNC) + baseline, candidate = [read(proof / (arm + "-identity.json")) for arm in ("baseline", "candidate")] + identity.validate_baseline_evidence(baseline, binaries, proof) + identity.validate_evidence(candidate, SYNC, engine, binaries, proof) + identity.validate_invocation(proof, "baseline") + assert candidate["executable"]["sha256"] == "c6cca50dcf3f5eb7e53550a97a234a93918eb63b74af692d1c7236474da55079" + previous = read(proof / "reuse.json") + assert previous["candidate_repair_source"] == SOURCE and previous["engine_evidence_reused"] is False + engine_gate = read(proof / "engine-gate.json") + assert engine_gate["passed"] is True and engine_gate["source"] == SYNC + assert engine_gate["stress_counts"]["jsc-stress"] >= 1400 and engine_gate["stress_counts"]["jsc-modules"] >= 1600 + for name, count in engine_gate["stress_counts"].items(): + lines = (proof / name / "results").read_text().splitlines() + assert len(lines) == count and all(line.endswith(": PASS") for line in lines), name + assert not (proof / "gate.json").exists() and not (proof / "sync-gate.json").exists() + pin = identity.CONFIG["candidate"] + assert identity.git(checkout, "rev-parse", "HEAD", "HEAD^{tree}").decode().splitlines() == [pin["commit"], pin["tree"]] + assert not identity.git(checkout, "status", "--porcelain") + assert Path(read(proof / "candidate-build-tools.json")["cwd"]) == root / "bun" + bootstrap = read(proof / "candidate-build-tools.json")["bootstrap"] + assert inspector.stat().st_size == bootstrap["size"] and sha(inspector) == bootstrap["sha256"] + shutil.move(str(checkout), root / "bun") + reused = {} + for source in proof.rglob("*"): + if not source.is_file(): + continue + relative = source.relative_to(proof) + name = relative.as_posix() + if relative.parts[0] == "candidate": + name = "previous-candidate/" + "/".join(relative.parts[1:]) + elif name in ("faithfulness.json", "reuse.json"): + name = "previous-" + name + target = root / name + target.parent.mkdir(parents=True, exist_ok=True) + assert not target.exists() + shutil.copyfile(source, target) + reused[name] = sha(source) + for name in (identity.BASELINE_EXECUTABLE, identity.EXECUTABLE, identity.FIXTURE, MIMALLOC): + target = root / name + assert not target.exists() + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(binaries / name, target) + target.chmod(0o700 if name in (identity.BASELINE_EXECUTABLE, identity.EXECUTABLE) else 0o600) + repo = root / "bun" + overlay = root / "candidate-manifest.patch" + subprocess.run(["git", "-C", str(repo), "apply", "--check", str(overlay)], check=True) + subprocess.run(["git", "-C", str(repo), "apply", str(overlay)], check=True) + (root / "engine").mkdir() + subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), "-C", str(root / "engine")], check=True) + identity.verify(root, engine, root / "candidate-identity.json", inspector) + source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) + assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() + begin = b' results="$QUALIFICATION_DIR/$arm"\n' + end = b'done\npython3 "$inputs/compare_fork_ci.py"' + assert source.count(begin) == source.count(end) == 1 + driver = source[:source.index(b"for arm in baseline candidate; do")] + driver += b'arm=candidate\nrepo="$QUALIFICATION_DIR/bun"\ncandidate="$repo/build/qualify-candidate/bun"\ncd "$repo"\n' + driver += b'"$bootstrap" install --frozen-lockfile\n(cd test && "$bootstrap" install --frozen-lockfile)\n' + driver += source[source.index(begin):source.index(end)] + source[source.index(end) + len(b"done\n"):] + proxy = b'"$candidate" test test/js/node/vm/vm.test.ts' + assert driver.count(proxy) == 1 + driver = driver.replace(proxy, b'"$candidate" test --expose-internals test/js/node/vm/vm.test.ts') + (root / "qualify-retained-matrix.sh").write_bytes(driver) + manifest = read(inputs / "consumer-repair.json") + for name, digest in manifest["files"].items(): + target = inputs.parent / name if name in ("test_consumer_identity.py", "variants.json", "qualify-sync.sh") else inputs / name + assert sha(target) == digest, name + with (root / "matrix-replay.json").open("x") as stream: + stream.write(json.dumps({"run": MATRIX_RUN, "carrier": MATRIX_CARRIER, "source": SOURCE, + "sync": SYNC, "artifacts": MATRIX_ARTIFACTS, "reused_files": reused, + "candidate_identity_sha256": sha(root / "candidate-identity.json"), + "candidate_build_reused": True, "candidate_runtime_evidence_reused": False, + "controls": manifest["files"], "manifest_sha256": sha(inputs / "consumer-repair.json"), + "driver_sha256": sha(root / "qualify-retained-matrix.sh"), + "replay_control_sha256": sha(Path(__file__))}, indent=2) + "\n") + + +def seal_matrix(pipeline, root, artifacts, inspector): + inputs = pipeline / ".github/openclaw/qualification" + sys.path.insert(0, str(inputs)) + import consumer_identity as identity + record = read(root / "matrix-replay.json") + assert record["run"] == MATRIX_RUN and record["carrier"] == MATRIX_CARRIER and record["source"] == SOURCE and record["sync"] == SYNC + assert sha(Path(__file__)) == record["replay_control_sha256"] + assert sha(inputs / "consumer-repair.json") == record["manifest_sha256"] + assert sha(root / "qualify-retained-matrix.sh") == record["driver_sha256"] + manifest = read(inputs / "consumer-repair.json") + assert record["controls"] == manifest["files"] + for name, digest in record["controls"].items(): + target = inputs.parent / name if name in ("test_consumer_identity.py", "variants.json", "qualify-sync.sh") else inputs / name + assert sha(target) == digest, name + for name, digest in record["reused_files"].items(): + assert sha(root / name) == digest, name + assert sha(root / "candidate-identity.json") == record["candidate_identity_sha256"] + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), + artifacts / (identity.LANE + ".manifest.json"), SYNC) + identity.verify(root, engine, root / "candidate-identity.json", inspector) + gate = read(root / "gate.json") + assert gate["passed"] is True and gate["upstream_sync"] == read(root / "sync-gate.json") + assert gate["compatibility"] == read(root / "compatibility-gate.json") + with (root / "matrix-replay-complete.json").open("x") as stream: + stream.write(json.dumps({"passed": True, "replay_sha256": sha(root / "matrix-replay.json"), + "gate_sha256": sha(root / "gate.json"), "candidate_identity_sha256": record["candidate_identity_sha256"]}, indent=2) + "\n") + + if __name__ == "__main__": - if len(sys.argv) == 4 and sys.argv[1] == "install": + if sys.argv[1] == "replay-matrix": + replay_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) + elif sys.argv[1] == "seal-matrix": + seal_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) + elif len(sys.argv) == 4 and sys.argv[1] == "install": pipeline, carrier = [Path(p).resolve() for p in sys.argv[2:]] assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC sys.path.insert(0, str(pipeline / ".github/openclaw/qualification")) diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 2d13a5659e36f..05f4262c767be 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -56,6 +56,7 @@ jobs: ref: ${{ github.event.pull_request.head.sha || github.sha }} persist-credentials: false path: carrier + fetch-depth: 1 sparse-checkout: .github/openclaw - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: @@ -68,7 +69,7 @@ jobs: shell: bash run: | set -euo pipefail - export ARTIFACT_DIR="$RUNNER_TEMP/linux-artifact" QUALIFICATION_DIR="$RUNNER_TEMP/qualification" + export ARTIFACT_DIR="$RUNNER_TEMP/linux-artifact" QUALIFICATION_DIR="/home/runner/_work/_temp/qualification" echo "ARTIFACT_DIR=$ARTIFACT_DIR" >> "$GITHUB_ENV" echo "QUALIFICATION_DIR=$QUALIFICATION_DIR" >> "$GITHUB_ENV" sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc /usr/local/.ghcup /opt/hostedtoolcache /usr/local/share/boost /usr/share/swift /opt/microsoft @@ -78,10 +79,10 @@ jobs: from pathlib import Path capacity = dict(cpus=os.cpu_count(), disk_free_bytes=shutil.disk_usage('.').free) assert capacity['disk_free_bytes'] >= 40 * 1024**3, 'retained source, executables and engine need 40 GiB free' - Path(os.environ['QUALIFICATION_DIR']).mkdir() + Path(os.environ['QUALIFICATION_DIR']).mkdir(parents=True) Path(os.environ['QUALIFICATION_DIR'], 'carrier.json').write_text(json.dumps(dict( carrier=os.environ['CARRIER_COMMIT'], sync=os.environ['SYNC_COMMIT'], - engine_artifact=13050907884, engine_run=41213533216, engine_attempt=2, + engine_artifact=13075718771, engine_run=41286392252, engine_attempt=1, capacity=capacity), indent=2) + '\n') PY - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 @@ -95,19 +96,19 @@ jobs: shell: bash run: | set -euo pipefail - gh api repos/openclaw/WebKit/actions/artifacts/13050907884 > "$RUNNER_TEMP/engine-artifact.json" - gh api repos/openclaw/WebKit/actions/artifacts/13050907884/zip > "$RUNNER_TEMP/engine.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13075718771 > "$RUNNER_TEMP/engine-artifact.json" + gh api repos/openclaw/WebKit/actions/artifacts/13075718771/zip > "$RUNNER_TEMP/engine.zip" python3 - <<'PY' import hashlib, json, os, shutil, stat, zipfile from pathlib import Path, PurePosixPath root = Path(os.environ['RUNNER_TEMP']) artifact = json.loads((root / 'engine-artifact.json').read_text()) - digest = 'da8bbf2a08a5bff8d566b213a7e329f4103da4e627e05ff5c64c1576e9c06385' - assert artifact['id'] == 13050907884 and not artifact['expired'] + digest = 'e762b6e8022b4d0f454b1ddc8288f0b3b2ad511b159fe2b8cff7fd4a4eb197d4' + assert artifact['id'] == 13075718771 and not artifact['expired'] assert artifact['name'] == 'bun-webkit-linux-amd64' - assert artifact['workflow_run']['id'] == 41213533216 - assert artifact['workflow_run']['head_sha'] == os.environ['SYNC_COMMIT'] - assert artifact['size_in_bytes'] == (root / 'engine.zip').stat().st_size == 709332920 + assert artifact['workflow_run']['id'] == 41286392252 + assert artifact['workflow_run']['head_sha'] == 'bfea5fad536fe27d6beb39bdf64106536418428f' + assert artifact['size_in_bytes'] == (root / 'engine.zip').stat().st_size == 709340274 assert artifact['digest'] == 'sha256:' + digest with (root / 'engine.zip').open('rb') as stream: assert hashlib.file_digest(stream, 'sha256').hexdigest() == digest @@ -164,10 +165,10 @@ jobs: run: | set -euo pipefail mkdir "$RUNNER_TEMP/retained" - gh api repos/openclaw/WebKit/actions/artifacts/13074375041 > "$RUNNER_TEMP/retained/proof.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13074375041/zip > "$RUNNER_TEMP/retained/proof.zip" - gh api repos/openclaw/WebKit/actions/artifacts/13073981057 > "$RUNNER_TEMP/retained/binaries.metadata.json" - gh api repos/openclaw/WebKit/actions/artifacts/13073981057/zip > "$RUNNER_TEMP/retained/binaries.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13077667443 > "$RUNNER_TEMP/retained/proof.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13077667443/zip > "$RUNNER_TEMP/retained/proof.zip" + gh api repos/openclaw/WebKit/actions/artifacts/13077208926 > "$RUNNER_TEMP/retained/binaries.metadata.json" + gh api repos/openclaw/WebKit/actions/artifacts/13077208926/zip > "$RUNNER_TEMP/retained/binaries.zip" - name: Install the reviewed continuation and unchanged consumer policy shell: bash run: | @@ -184,29 +185,33 @@ jobs: python3 .github/openclaw/test_consumer_identity.py python3 .github/openclaw/test_verify_jsc_results.py bash .github/openclaw/preflight.sh - - name: Admit the retained suites and finish both native probes + - name: Replay the consumer suites against the retained matrix build shell: bash run: | set -euo pipefail unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN export INSPECTOR_RUNTIME="$(realpath "$(command -v bun)")" - python3 .github/openclaw/qualification/continue-consumer.py prepare \ + python3 carrier/.github/openclaw/qualification/resume-consumer.py replay-matrix \ "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" \ "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$GITHUB_WORKSPACE/retained-bun-source" "$INSPECTOR_RUNTIME" export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" - bash .github/openclaw/qualify-sync.sh --retained-probes + bash "$QUALIFICATION_DIR/qualify-retained-matrix.sh" + bash .github/openclaw/qualify-sync-compatibility.sh + bash .github/openclaw/qualify-sync.sh + python3 carrier/.github/openclaw/qualification/resume-consumer.py seal-matrix \ + "$GITHUB_WORKSPACE" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$INSPECTOR_RUNTIME" - name: Retain the exact qualified Bun executables if: always() uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a with: name: hosted-linux-bun-executables path: | - ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun - ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun - ${{ runner.temp }}/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o - ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts - ${{ runner.temp }}/qualification/*.sha256 + /home/runner/_work/_temp/qualification/bun-baseline/build/qualify-baseline/bun + /home/runner/_work/_temp/qualification/bun/build/qualify-candidate/bun + /home/runner/_work/_temp/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o + /home/runner/_work/_temp/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts + /home/runner/_work/_temp/qualification/*.sha256 compression-level: 0 if-no-files-found: warn retention-days: 3 @@ -216,23 +221,24 @@ jobs: with: name: hosted-linux-native-proof path: | - ${{ runner.temp }}/qualification/*.json - ${{ runner.temp }}/qualification/*.log - ${{ runner.temp }}/qualification/*.sha256 - ${{ runner.temp }}/qualification/*.patch - ${{ runner.temp }}/qualification/qualify-candidate-fresh.sh - ${{ runner.temp }}/qualification/candidate-input/artifacts.json - ${{ runner.temp }}/qualification/baseline/*.json - ${{ runner.temp }}/qualification/baseline/*.log - ${{ runner.temp }}/qualification/candidate/*.json - ${{ runner.temp }}/qualification/candidate/*.log - ${{ runner.temp }}/qualification/compatibility/*.log - ${{ runner.temp }}/qualification/sync/*.json - ${{ runner.temp }}/qualification/sync/*.xml - ${{ runner.temp }}/qualification/sync/*.log - ${{ runner.temp }}/qualification/jsc-*/results - ${{ runner.temp }}/qualification/jsc-stack/*.log - ${{ runner.temp }}/qualification/jsc-stack/*.json - ${{ runner.temp }}/qualification/sync/runtime-cache/*.json + /home/runner/_work/_temp/qualification/*.json + /home/runner/_work/_temp/qualification/*.log + /home/runner/_work/_temp/qualification/*.sha256 + /home/runner/_work/_temp/qualification/*.patch + /home/runner/_work/_temp/qualification/qualify-retained-matrix.sh + /home/runner/_work/_temp/qualification/candidate-input/artifacts.json + /home/runner/_work/_temp/qualification/baseline/*.json + /home/runner/_work/_temp/qualification/baseline/*.log + /home/runner/_work/_temp/qualification/candidate/*.json + /home/runner/_work/_temp/qualification/candidate/*.log + /home/runner/_work/_temp/qualification/previous-candidate/* + /home/runner/_work/_temp/qualification/compatibility/*.log + /home/runner/_work/_temp/qualification/sync/*.json + /home/runner/_work/_temp/qualification/sync/*.xml + /home/runner/_work/_temp/qualification/sync/*.log + /home/runner/_work/_temp/qualification/jsc-*/results + /home/runner/_work/_temp/qualification/jsc-stack/*.log + /home/runner/_work/_temp/qualification/jsc-stack/*.json + /home/runner/_work/_temp/qualification/sync/runtime-cache/*.json if-no-files-found: error retention-days: 7 From ba0644d12ae6fc99a98a3166d45e67697e4dff10 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 18:00:57 +0800 Subject: [PATCH 16/35] fix(ci): assemble retained WebKit artifacts with fresh consumer proof --- .../qualification/assemble-retained-matrix.py | 151 ++++++++++++++++++ .../workflows/openclaw-retained-matrix.yml | 61 +++++++ 2 files changed, 212 insertions(+) create mode 100644 .github/openclaw/qualification/assemble-retained-matrix.py create mode 100644 .github/workflows/openclaw-retained-matrix.yml diff --git a/.github/openclaw/qualification/assemble-retained-matrix.py b/.github/openclaw/qualification/assemble-retained-matrix.py new file mode 100644 index 0000000000000..fc4f801006cc6 --- /dev/null +++ b/.github/openclaw/qualification/assemble-retained-matrix.py @@ -0,0 +1,151 @@ +"""Admit fixed-run build artifacts and fresh Linux proof for offline assembly.""" +import hashlib +import json +from pathlib import Path, PurePosixPath +import re +import shutil +import stat +import subprocess +import sys +import zipfile + +REPO = "repos/openclaw/WebKit/" +SOURCE = "42e4245f4180941634b482a7e8ef7fca47467de5" +BUILD_RUN = 41286392252 +BUILD_HEAD = "bfea5fad536fe27d6beb39bdf64106536418428f" +REPLAY_RUN = 41294955235 +REPLAY_HEAD = "fe913cc9c90efd8fdc9c9f5be06ef3450d63cab4" +ORIGINAL = {'bun-webkit-linux-amd64': [13075718771, + 709340274, + 'sha256:e762b6e8022b4d0f454b1ddc8288f0b3b2ad511b159fe2b8cff7fd4a4eb197d4'], + 'bun-webkit-linux-amd64-lto': [13076530203, + 390685186, + 'sha256:6133bb0507c93acf3d1d2231012c3ccb0bb8f077c27293f316e79a2e2f5c43ce'], + 'bun-webkit-linux-amd64-musl-lto': [13076429158, + 283858242, + 'sha256:14457d9621316dccdc6b6eceef32e7f03410a7e7db62e26e30355f90273ac601'], + 'bun-webkit-linux-arm64-lto': [13076480901, + 269297056, + 'sha256:d9419c90be30b7588a11e9607edca4a16b23e39f4363013e0edda11dcb409dce'], + 'bun-webkit-linux-arm64-musl-lto': [13077105948, + 193259412, + 'sha256:cdcdb82ed96e2b4b80e9059acd6e408cbd47b549a7671497f6282de37428daf4'], + 'bun-webkit-macos-amd64-lto': [13076422209, + 184072987, + 'sha256:17c48099e23731b46b3814d09fee6d102d79508f31b3a4bd6d5841cb84dd2da3'], + 'bun-webkit-macos-arm64': [13075372671, + 229404673, + 'sha256:71689535668a18cf61cc4ef8f0dae281b48108b4923ce0b2af4e5ca7a5a8e15a'], + 'bun-webkit-macos-arm64-lto': [13076322480, + 179644957, + 'sha256:e2f0a8e675814af177875eab7e6475e49b3eb0777ffe26b65d468944e7ebb543'], + 'bun-webkit-windows-amd64-lto': [13076798389, + 572218334, + 'sha256:aaf339963631c8b83877fa90fa11809c7e7af59066c20bd7b8e0325d72a77324'], + 'bun-webkit-windows-arm64': [13077561521, + 259571300, + 'sha256:09735badc7ff3faf690c16dee640ce1842c8bc62e10fc6be4819124e86c3c8de'], + 'windows-arm64-qualification': [13077641419, + 1029, + 'sha256:c263cbb260585a610e0c1670cab7530b0efe3e694c3598fde845a50e5795a1a2']} + + +def api(route): + return json.loads(subprocess.check_output(["gh", "api", REPO + route])) + + +def sha(path): + with path.open("rb") as stream: + return hashlib.file_digest(stream, "sha256").hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +def run_identity(run_id, head, workflow): + run = api(f"actions/runs/{run_id}") + assert run["head_sha"] == head and run["run_attempt"] == 1 and run["status"] == "completed" + assert run["head_repository"]["full_name"] == "openclaw/WebKit" + assert run["path"].split("@", 1)[0] == ".github/workflows/" + workflow + jobs = api(f"actions/runs/{run_id}/jobs?filter=latest&per_page=100")["jobs"] + return run, {job["name"]: job for job in jobs} + + +def download(root, label, row, run_id, head): + artifact_id, size, digest = row + assert re.fullmatch(r"sha256:[0-9a-f]{64}", digest) and 0 < size <= 1024**3 + metadata = api(f"actions/artifacts/{artifact_id}") + assert metadata["id"] == artifact_id and metadata["name"] == label and not metadata["expired"] + assert metadata["size_in_bytes"] == size and metadata["digest"] == digest + assert metadata["workflow_run"]["id"] == run_id and metadata["workflow_run"]["head_sha"] == head + archive_path = root / "download.zip" + with archive_path.open("xb") as stream: + subprocess.run(["gh", "api", REPO + f"actions/artifacts/{artifact_id}/zip"], stdout=stream, check=True) + assert archive_path.stat().st_size == size and "sha256:" + sha(archive_path) == digest + target = root / label + target.mkdir() + with zipfile.ZipFile(archive_path) as archive: + entries = archive.infolist() + assert 0 < len(entries) <= 4096 and sum(entry.file_size for entry in entries) <= 8 * 1024**3 + seen = set() + for entry in entries: + name = PurePosixPath(entry.filename) + assert not name.is_absolute() and not any(part in ("", ".", "..") for part in entry.filename.rstrip("/").split("/")) + assert "\\" not in entry.filename and "\x00" not in entry.filename and name not in seen + seen.add(name) + mode = stat.S_IFMT(entry.external_attr >> 16) + if entry.is_dir(): + assert mode in (0, stat.S_IFDIR) and entry.file_size == 0 + (target / name).mkdir(parents=True, exist_ok=True) + else: + assert mode in (0, stat.S_IFREG) + destination = target / name + destination.parent.mkdir(parents=True, exist_ok=True) + with archive.open(entry) as source, destination.open("xb") as output: + shutil.copyfileobj(source, output) + archive_path.unlink() + return metadata + + +def main(root): + root.mkdir() + assert shutil.disk_usage(root).free >= 12 * 1024**3 + build, jobs = run_identity(BUILD_RUN, BUILD_HEAD, "openclaw-artifacts.yml") + assert build["conclusion"] == "failure" + required = {"build (" + label + ")" for label in ORIGINAL if label.startswith("bun-webkit-")} | {"windows-arm64"} + assert len(required) == 11 and all(jobs[name]["conclusion"] == "success" and jobs[name]["run_attempt"] == 1 for name in required) + replay, jobs = run_identity(REPLAY_RUN, REPLAY_HEAD, "openclaw-hosted-linux-consumer.yml") + assert replay["conclusion"] == "success" and jobs["linux-native"]["conclusion"] == "success" + artifacts = api(f"actions/runs/{REPLAY_RUN}/artifacts?per_page=100")["artifacts"] + admitted = [] + for label in ("hosted-linux-native-proof", "hosted-linux-bun-executables"): + matches = [item for item in artifacts if item["name"] == label] + assert len(matches) == 1 + item = matches[0] + assert item["size_in_bytes"] <= (8 * 1024**2 if label.endswith("proof") else 512 * 1024**2) + admitted.append(download(root, label, [item["id"], item["size_in_bytes"], item["digest"]], REPLAY_RUN, REPLAY_HEAD)) + proof = root / "hosted-linux-native-proof" + record, complete = read(proof / "matrix-replay.json"), read(proof / "matrix-replay-complete.json") + assert record["run"] == BUILD_RUN and record["carrier"] == BUILD_HEAD and record["sync"] == SOURCE + assert record["source"] == "2323913322dfdfed96ecf20163d62f5ff2796ecc" + assert record["candidate_build_reused"] is True and record["candidate_runtime_evidence_reused"] is False + assert record["manifest_sha256"] == "96d5eb1558b84d13b09e7ff1c56904a6834f72ad43d5558c92ad42e5ae75feb2" + assert record["replay_control_sha256"] == "73f7154030e02bb01fbf0e2d62c77d17aac5c7a94e05ca022e6b26eebfd1d66d" + assert complete["passed"] is True and complete["replay_sha256"] == sha(proof / "matrix-replay.json") + assert complete["gate_sha256"] == sha(proof / "gate.json") + assert complete["candidate_identity_sha256"] == record["candidate_identity_sha256"] == sha(proof / "candidate-identity.json") + for name, digest in record["reused_files"].items(): + path = PurePosixPath(name) + assert not path.is_absolute() and ".." not in path.parts + assert sha(proof / path) == digest, name + (root / "hosted-linux-native-proof").rename(root / "qualification") + (root / "hosted-linux-bun-executables").rename(root / "linux-bun-executables") + for label, row in ORIGINAL.items(): + admitted.append(download(root, label, row, BUILD_RUN, BUILD_HEAD)) + (root / "assembly-inputs.json").write_text(json.dumps({"source": SOURCE, "build_run": BUILD_RUN, + "replay_run": REPLAY_RUN, "artifacts": admitted}, indent=2) + "\n") + + +if __name__ == "__main__": + main(Path(sys.argv[1]).resolve()) diff --git a/.github/workflows/openclaw-retained-matrix.yml b/.github/workflows/openclaw-retained-matrix.yml new file mode 100644 index 0000000000000..d26b69e374964 --- /dev/null +++ b/.github/workflows/openclaw-retained-matrix.yml @@ -0,0 +1,61 @@ +name: OpenClaw retained matrix assembly + +on: + workflow_dispatch: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-retained-matrix-41286392252 + cancel-in-progress: false + +jobs: + assemble: + runs-on: ubuntu-24.04 + timeout-minutes: 40 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 42e4245f4180941634b482a7e8ef7fca47467de5 + fetch-depth: 1 + persist-credentials: false + sparse-checkout-cone-mode: false + sparse-checkout: | + .github + Source/JavaScriptCore/COPYING.LIB + Source/WTF/wtf/COPYING.LIB + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: ${{ github.sha }} + fetch-depth: 1 + persist-credentials: false + path: carrier + sparse-checkout: .github/openclaw + - name: Admit the fixed builds and completed Linux replay + env: + GH_TOKEN: ${{ github.token }} + run: python3 carrier/.github/openclaw/qualification/assemble-retained-matrix.py "$RUNNER_TEMP/inputs" + - name: Install reviewed controls and assemble checked artifacts + shell: bash + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 carrier/.github/openclaw/qualification/resume-consumer.py install "$GITHUB_WORKSPACE" "$GITHUB_WORKSPACE/carrier" + python3 .github/openclaw/release.py assemble --source 42e4245f4180941634b482a7e8ef7fca47467de5 --inputs "$RUNNER_TEMP/inputs" --directory "$RUNNER_TEMP/assembled" + python3 .github/openclaw/release.py verify --source 42e4245f4180941634b482a7e8ef7fca47467de5 --directory "$RUNNER_TEMP/assembled" + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: retained-matrix-assembly + path: ${{ runner.temp }}/assembled + compression-level: 0 + if-no-files-found: error + retention-days: 7 + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + if: always() + with: + name: retained-matrix-assembly-inputs + path: ${{ runner.temp }}/inputs/assembly-inputs.json + if-no-files-found: warn + retention-days: 7 From 2147aaed0f58651cc987dbbadd1cd6d7645887b1 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 18:08:06 +0800 Subject: [PATCH 17/35] fix(ci): retain compact matrix assembly receipts --- .github/workflows/openclaw-retained-matrix.yml | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/.github/workflows/openclaw-retained-matrix.yml b/.github/workflows/openclaw-retained-matrix.yml index d26b69e374964..c64670467859a 100644 --- a/.github/workflows/openclaw-retained-matrix.yml +++ b/.github/workflows/openclaw-retained-matrix.yml @@ -56,6 +56,9 @@ jobs: if: always() with: name: retained-matrix-assembly-inputs - path: ${{ runner.temp }}/inputs/assembly-inputs.json + path: | + ${{ runner.temp }}/inputs/assembly-inputs.json + ${{ runner.temp }}/assembled/manifest.json + ${{ runner.temp }}/assembled/SHA256SUMS if-no-files-found: warn retention-days: 7 From 5e586e4ce8bd9f3f3703af98983f7f13fb58c242 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 18:13:45 +0800 Subject: [PATCH 18/35] fix(ci): dispatch retained assembly through the registered workflow --- .github/workflows/openclaw-hosted-linux-consumer.yml | 9 +++++++++ .github/workflows/openclaw-retained-matrix.yml | 1 + 2 files changed, 10 insertions(+) diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 05f4262c767be..9d45d7a1fff97 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -15,6 +15,11 @@ on: - .github/openclaw/qualify-sync.sh - .github/openclaw/qualification/verify-sync.py workflow_dispatch: + inputs: + assemble_retained: + description: Assemble the completed fixed-run matrix after Linux replay + type: boolean + default: false permissions: contents: read @@ -30,6 +35,7 @@ env: jobs: linux-native: + if: ${{ !inputs.assemble_retained }} runs-on: ubuntu-24.04 timeout-minutes: 180 steps: @@ -242,3 +248,6 @@ jobs: /home/runner/_work/_temp/qualification/sync/runtime-cache/*.json if-no-files-found: error retention-days: 7 + assemble-retained: + if: ${{ inputs.assemble_retained }} + uses: ./.github/workflows/openclaw-retained-matrix.yml diff --git a/.github/workflows/openclaw-retained-matrix.yml b/.github/workflows/openclaw-retained-matrix.yml index c64670467859a..6538ad7f969e4 100644 --- a/.github/workflows/openclaw-retained-matrix.yml +++ b/.github/workflows/openclaw-retained-matrix.yml @@ -2,6 +2,7 @@ name: OpenClaw retained matrix assembly on: workflow_dispatch: + workflow_call: permissions: contents: read From b34da02565db9103433918be4c6e1837e6b3ea55 Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 18:52:00 +0800 Subject: [PATCH 19/35] fix(ci): retain the lane parser inputs in contract checks --- .github/openclaw/test_artifacts.py | 2 +- .github/workflows/openclaw-hosted-linux-consumer.yml | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/.github/openclaw/test_artifacts.py b/.github/openclaw/test_artifacts.py index 884f496686230..63ee24df3844a 100644 --- a/.github/openclaw/test_artifacts.py +++ b/.github/openclaw/test_artifacts.py @@ -252,7 +252,7 @@ def test_configured_matrix_admits_current_bun_aot_consumers(self): env = {'GITHUB_REF': 'refs/heads/' + branch, 'INPUT_PUBLISH': 'false', 'INPUT_SHA': 'a' * 40, 'GITHUB_SHA': 'a' * 40, 'ENGINE_SHA': 'a' * 40, - 'GITHUB_OUTPUT': str(output)} + 'GITHUB_OUTPUT': str(output), 'PATH': os.environ['PATH']} with patch.dict(os.environ, env, clear=True), patch.object( artifacts, 'source', return_value={'source': 'a' * 40}): artifacts.preflight() diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index 4e9636191515f..aad2e206a14ec 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -46,7 +46,9 @@ jobs: with: ref: ${{ github.event.pull_request.head.sha || github.sha }} persist-credentials: false - sparse-checkout: .github + sparse-checkout: | + .github + icu - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: node-version: '26.12.1' From ea05b810f857234e5d50348947cf3c0dc21e866b Mon Sep 17 00:00:00 2001 From: Vincent Koc Date: Sun, 1 Nov 2026 18:54:56 +0800 Subject: [PATCH 20/35] fix(ci): include cross-toolchain inputs in lane contract checks --- .github/workflows/openclaw-hosted-linux-consumer.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index aad2e206a14ec..45afa0f87850e 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -49,6 +49,7 @@ jobs: sparse-checkout: | .github icu + macos-cross - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: node-version: '26.12.1' From 1e77349e6107954719253015eb851546560ce16c Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Sun, 1 Nov 2026 23:42:45 +0800 Subject: [PATCH 21/35] fix(ci): match consumer fixtures to the synchronized engine --- .../qualification/consumer-repair.json | 14 +- .../qualification/consumer_identity.py | 12 +- .../qualification/harness-adapters.json | 48 ++ .../candidate-current-test.patch | 752 ++++++++++++++++++ .../qualification/harness_adapters.py | 4 +- .../openclaw/qualification/resume-consumer.py | 3 +- .github/openclaw/qualify-sync.sh | 3 + .github/openclaw/qualify.sh | 4 + .github/openclaw/release-notes.md | 2 + .github/openclaw/test_consumer_identity.py | 13 +- .github/workflows/openclaw-checks.yml | 12 + 11 files changed, 851 insertions(+), 16 deletions(-) create mode 100644 .github/openclaw/qualification/harness-adapters/candidate-current-test.patch diff --git a/.github/openclaw/qualification/consumer-repair.json b/.github/openclaw/qualification/consumer-repair.json index 9ea04320e9988..b4991f9f0554d 100644 --- a/.github/openclaw/qualification/consumer-repair.json +++ b/.github/openclaw/qualification/consumer-repair.json @@ -2,15 +2,17 @@ "source": "2323913322dfdfed96ecf20163d62f5ff2796ecc", "engine": "42e4245f4180941634b482a7e8ef7fca47467de5", "files": { - "harness-adapters.json": "b8f26ddac333687c8bbfb8f0f9508822065d4ae7027059fcb4a979af426a321e", - "harness_adapters.py": "b010ff192ebdb91d52b64e0521abfb1d079e8cd34792f0b9bb46570bb9d4ad83", + "harness-adapters.json": "0359c6c59e00cf85022dffa283f5631a1ed2ad6b0363fc9e3fbca23f5c0fdd11", + "harness_adapters.py": "72015429ffd4744d4dbbb7a181165251c3167901fbc64eb60eddbf95885382b4", "harness-adapters/candidate-build.patch": "414c02660faa9dcc48c383458dbe13dea5c9a26a7f3abc62265ea637ec074769", "harness-adapters/candidate-test.patch": "6a56f290ef1d0b87f50e7c8311913b3f562bae15fd8bf22ab02289fa8005062b", - "test_consumer_identity.py": "f6163dea3b0c5111e5df3c9914486cde11befbfad4d9eabd7ef55e194b610afc", - "variants.json": "a181182de15f50d6c30d4d185a9d21cdea2093236dc17aa66628e65008c57bc7", - "qualify-sync.sh": "b124b19863695fbd67564e82531459ced2470b9000a6a4f04ae3dc40534ab33d", + "test_consumer_identity.py": "fe9df28280601b73d8b22cfb6aa2e4267c71395a73ebe7b72023dafd04ebfee3", + "variants.json": "205880797b8b7b980f5c5c4beb6778d40259373a5b73696f857712f70bd0241f", + "qualify-sync.sh": "195d449495d5e615be2deac54d5c2875a69cf21aef0fd5ad33b3006ea2b7b765", "verify-sync.py": "e9aeb350b0de5e5b5962af9934985805985a2291b3e90ff0302fd6c427a1db23", "continue-consumer.py": "a55846cee405937df5249ef56614ca81b0328dfa19d7398604523c7be9332a4a", - "probe-allocator.cpp": "d8d650722503c009a39a8a36e3c25b6a9c6c2a15e535377c39e30cea27455ba1" + "probe-allocator.cpp": "d8d650722503c009a39a8a36e3c25b6a9c6c2a15e535377c39e30cea27455ba1", + "consumer_identity.py": "9a23e12111fd6e9c40c4294b09db45a16e6c24f86104f36eadb799079d034c65", + "harness-adapters/candidate-current-test.patch": "5d47cfaf4dbda0993df01d2eb065bc343fd2d49064ddf2bcc676ca93b889f6ef" } } diff --git a/.github/openclaw/qualification/consumer_identity.py b/.github/openclaw/qualification/consumer_identity.py index 24f18fb737c33..a0808d3521144 100644 --- a/.github/openclaw/qualification/consumer_identity.py +++ b/.github/openclaw/qualification/consumer_identity.py @@ -159,10 +159,12 @@ def baseline_source(root, inspector_runtime): return hashlib.sha256(patch).hexdigest() -def adapter_spec(arm, phase): +def adapter_spec(arm, phase, engine_source=None): spec = ADAPTERS['arms'][arm] require(spec['pin'] == CONFIG[arm]['commit'], 'harness adapter source pin drift') - selected = spec[phase] + selected = (spec['current_test'] if arm == 'candidate' and phase == 'test' + and engine_source is not None and engine_source != '42e4245f4180941634b482a7e8ef7fca47467de5' + else spec[phase]) if selected['patch'] is None: require(arm == 'candidate' and phase == 'build' and selected == {'patch': None, 'sha256': None, 'files': {}}, @@ -225,14 +227,14 @@ def validate_invocation(proof, name): arm = 'baseline' if name == 'baseline' else 'candidate' path = name + '/invocation.json' record = json.loads((proof / path).read_text()) + require(record['identity'] == file_record(proof, arm + '-identity.json'), 'invocation identity mismatch') + consumer = json.loads((proof / (arm + '-identity.json')).read_text()) require(record['schema_version'] == 1 and record['phase'] == 'test' and record['arm'] == arm - and record['source'] == CONFIG[arm] and record['adapter'] == adapter_spec(arm, 'test') + and record['source'] == CONFIG[arm] and record['adapter'] == adapter_spec(arm, 'test', consumer['runtime']['webkit']) and record['restored'] is True and record['before'] == record['after'] and record['before']['index_tree'] == CONFIG[arm]['tree'] and valid_digest(record['before']['other_patch_sha256']) and valid_digest(record['compiled_inputs_sha256']), 'invalid restored test invocation') - require(record['identity'] == file_record(proof, arm + '-identity.json'), 'invocation identity mismatch') - consumer = json.loads((proof / record['identity']['path']).read_text()) if arm == 'baseline': validate_baseline(consumer) else: diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index 5d64aea7bd712..e7c43f7c160c2 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -220,6 +220,54 @@ "mode": "100644" } } + }, + "current_test": { + "patch": "harness-adapters/candidate-current-test.patch", + "sha256": "5d47cfaf4dbda0993df01d2eb065bc343fd2d49064ddf2bcc676ca93b889f6ef", + "files": { + "scripts/buildkite.ts": { + "before": "cf1999381cf38d34b9892118266614ae2b81a28066d47a455aa15794fb2c1c3e", + "after": "a49d5c491cd65f39c2bd35e3ea6cf7fd9f40e52de209417bd9ee5afed5e7ec4a", + "base_blob": "401d5e02728b1966552d6a6357076e50f8203ce9", + "adapted_blob": "bdc41d6881b43969d053381afed744a1d907e657", + "mode": "100644" + }, + "scripts/runner.node.ts": { + "before": "c95dc6ae2ec6cdb63764950b70765a618f9210b548a4b0c188053a9bf0f10b19", + "after": "3ff063681359656080d43f73e4ee0febbda584b8cbba7efe256e570467c0bf9d", + "base_blob": "c9ff165f351dd1345732d8426f2013d1bd8d27fc", + "adapted_blob": "11f00085169a54bcc16d241993ec5bc96ff63cdf", + "mode": "100755" + }, + "scripts/openclaw-ci/tests.ts": { + "before": "51c9680a8a4c1d88c88096d1c4e2c5cb2707610d5c303457474a311f3b8b0a06", + "after": "7d1a06e7298a71342e0237188038591ff90303e31ff986357e527764aadd211e", + "base_blob": "6507f885c1cdfdf8937574946d6959fa898a4345", + "adapted_blob": "5ce950bee35def7156a1ee7f5d1ac6230c812d2f", + "mode": "100644" + }, + "test/js/node/child_process/child-process-stdio.test.js": { + "before": "bab89f856c2ccc709474b47854fc85c6b54e3091e0cebdf7a2e841f2efd7d767", + "after": "bd621b307c23839d594d961ccb5e591731c451111f5244bfdf696fde11d9f893", + "base_blob": "361d675936e9694835956eebbd9b4256f8b9e5e3", + "adapted_blob": "7e448388ceb3dc10781b55f1df4e72d10f8637c3", + "mode": "100644" + }, + "test/js/node/vm/vm.test.ts": { + "before": "12d833538525702ce2fee1e3f76946e8886af26bf368af0abab74241f8ab8433", + "after": "c5c057e5832f4aaf1adbaff5df127ad1f8c4cf8614f436c293d06ac9588aa87f", + "base_blob": "179eb48620280040bd7808653731f6aba7cb81f5", + "adapted_blob": "1be67b432d1121e6978cc9557c78b15326877879", + "mode": "100644" + }, + "test/js/node/module/node-module-module.test.js": { + "before": "83dda3bff94343176a1faa677723f5826dc612e376963192e3ca2400cc6aba45", + "after": "625905b7e00425387b19f17def214fbd648c8ae5ba1969d31a27e032a8f6b3d5", + "base_blob": "5bd4e4d589ec991c0f711e32110e63d59989fd99", + "adapted_blob": "8c38b0c07baa8f4ed5c40039dc895e051a1771bd", + "mode": "100644" + } + } } } } diff --git a/.github/openclaw/qualification/harness-adapters/candidate-current-test.patch b/.github/openclaw/qualification/harness-adapters/candidate-current-test.patch new file mode 100644 index 0000000000000..2f2f43cf0b077 --- /dev/null +++ b/.github/openclaw/qualification/harness-adapters/candidate-current-test.patch @@ -0,0 +1,752 @@ +diff --git a/scripts/buildkite.ts b/scripts/buildkite.ts +index 401d5e02728b1966552d6a6357076e50f8203ce9..bdc41d6881b43969d053381afed744a1d907e657 100644 +--- a/scripts/buildkite.ts ++++ b/scripts/buildkite.ts +@@ -619,27 +619,93 @@ export function parseJunitFileSuites(xml: string): Map { + const attribute = (attributes: string, name: string) => new RegExp(`\\s${name}="([^"]*)"`).exec(attributes)?.[1]; + const keyOf = (file: string) => unescapeXml(file).replaceAll("\\", "/"); + const files = new Map(); +- for (const match of xml.matchAll(/]*)>/g)) { +- const attributes = match[1]!; +- const file = attribute(attributes, "file"); +- if (!file || attribute(attributes, "name") !== file) continue; +- files.set(keyOf(file), { +- failures: Number(attribute(attributes, "failures") ?? 0), +- seconds: Number(attribute(attributes, "time") ?? 0), +- cases: [], +- }); +- } ++ const counts = new Map(); ++ let currentFile: string | undefined; ++ if (!xml.trim()) return files; ++ const document = xml.replace(/^\s*<\?xml[^?]*\?>/, ""); ++ const stack: string[] = []; ++ const parents: Record = { ++ testsuites: [undefined], ++ testsuite: ["testsuites", "testsuite"], ++ testcase: ["testsuite"], ++ failure: ["testcase"], ++ skipped: ["testcase"], ++ properties: ["testsuite"], ++ property: ["properties"], ++ }; ++ let end = 0, ++ root = false; ++ const invalid = () => { ++ throw new Error("invalid native JUnit report"); ++ }; ++ // Only direct children own a file: a describe may itself be named after that file. ++ for (const match of document.matchAll(/<(\/?)([a-z]+)((?:\s+[\w-]+="[^"<]*")*\s*)(\/?)>/g)) { ++ const [, closing, tag, attributes, selfClosing] = match; ++ const text = document.slice(end, match.index); ++ if (text.includes("<") || (text.trim() && stack.at(-1) !== "failure")) invalid(); ++ end = match.index! + match[0].length; ++ if (closing) { ++ if (attributes!.trim() || selfClosing || stack.pop() !== tag) invalid(); ++ if (tag === "testsuite" && stack.length === 1) currentFile = undefined; ++ continue; ++ } ++ const names = [...attributes!.matchAll(/\s([\w-]+)="[^"]*"/g)].map(match => match[1]); ++ if ( ++ new Set(names).size !== names.length || ++ !parents[tag!]?.includes(stack.at(-1)) || ++ (tag === "properties" && stack.length !== 2) ++ ) ++ invalid(); ++ if (!stack.length) { ++ if (root || tag !== "testsuites") invalid(); ++ root = true; ++ } ++ if (tag === "testsuite" && stack.length === 1) { ++ const file = attribute(attributes!, "file"); ++ const tests = attribute(attributes!, "tests"); ++ const failures = attribute(attributes!, "failures"); ++ const seconds = attribute(attributes!, "time"); ++ if ( ++ !file || ++ attribute(attributes!, "name") !== file || ++ tests === undefined || ++ !/^\d+$/.test(tests) || ++ !Number.isSafeInteger(Number(tests)) || ++ failures === undefined || ++ !/^\d+$/.test(failures) || ++ !Number.isSafeInteger(Number(failures)) || ++ seconds === undefined || ++ !/^(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(seconds) || ++ !Number.isFinite(Number(seconds)) || ++ files.has(keyOf(file)) ++ ) ++ invalid(); ++ files.set(keyOf(file!), { failures: Number(failures), seconds: Number(seconds), cases: [] }); ++ currentFile = keyOf(file!); ++ counts.set(currentFile, { declared: Number(tests), observed: 0 }); ++ } ++ if (tag === "testcase") { ++ const file = attribute(attributes!, "file"); ++ if (!file || currentFile === undefined || keyOf(file) !== currentFile) invalid(); ++ counts.get(currentFile!)!.observed++; ++ } ++ if (selfClosing && tag === "testsuite" && stack.length === 1) currentFile = undefined; ++ if (!selfClosing) stack.push(tag!); ++ } ++ if (!root || stack.length || document.slice(end).trim()) invalid(); ++ for (const { declared, observed } of counts.values()) if (declared !== observed) invalid(); + for (const match of xml.matchAll(/]*)>\s*]*)>/g)) { + const caseAttributes = match[1]!; + const failureAttributes = match[2]!; + const file = attribute(caseAttributes, "file"); + const entry = file && files.get(keyOf(file)); +- if (!entry) continue; ++ if (!entry) throw new Error("JUnit failure has no file suite"); + entry.cases.push({ + name: unescapeXml(attribute(caseAttributes, "name") ?? "(unnamed)"), + message: unescapeXml(attribute(failureAttributes, "message") ?? ""), + }); + } ++ for (const entry of files.values()) if (entry.failures !== entry.cases.length) invalid(); + return files; + } + +diff --git a/scripts/openclaw-ci/tests.ts b/scripts/openclaw-ci/tests.ts +index 6507f885c1cdfdf8937574946d6959fa898a4345..5ce950bee35def7156a1ee7f5d1ac6230c812d2f 100644 +--- a/scripts/openclaw-ci/tests.ts ++++ b/scripts/openclaw-ci/tests.ts +@@ -1,5 +1,5 @@ + import { spawnSync, type SpawnSyncReturns } from "node:child_process"; +-import { appendFileSync, existsSync, mkdirSync, readFileSync, statfsSync, writeFileSync } from "node:fs"; ++import { appendFileSync, existsSync, mkdirSync, readFileSync, rmSync, statfsSync, writeFileSync } from "node:fs"; + import { homedir } from "node:os"; + import { basename, dirname, resolve } from "node:path"; + +@@ -275,6 +275,7 @@ if (import.meta.main) { + const command = process.argv[2]; + const selectionPath = "build/openclaw-ci/selected.json"; + const resultsPath = "build/openclaw-ci/results.json"; ++ const terminalPath = "build/openclaw-ci/runner-terminal.json"; + if (command === "select-windows") { + const selected = selectTests([], git("ls-files", "-z", "test"), false, "windows"); + mkdirSync(dirname(selectionPath), { recursive: true }); +@@ -308,6 +309,20 @@ if (import.meta.main) { + } else if (command === "test") { + const selected: string[] = JSON.parse(readFileSync(selectionPath, "utf8")); + if (!selected.length) throw new Error("Refusing an empty test selection"); ++ const reporting = process.argv.slice(3); ++ const junitArgs: string[] = []; ++ if (reporting.length) { ++ if ( ++ reporting.length !== 2 || ++ reporting[0] !== "--junit-prefix" || ++ !/^[a-zA-Z0-9][a-zA-Z0-9._-]*$/.test(reporting[1]!) ++ ) { ++ throw new Error("Usage: tests.ts test [--junit-prefix ]"); ++ } ++ // The native runner uploads by default only on Buildkite; this opt-in keeps reports local. ++ if (process.env.BUILDKITE === "true") throw new Error("Local JUnit reporting does not permit Buildkite uploads"); ++ junitArgs.push("--junit", "--junit-temp-dir", reporting[1]!); ++ } + reportDiskUsage("before"); + // Fresh processes preserve the original owner's GC sequence and expose late frees. + let ownerExitFailed = false; +@@ -340,6 +355,7 @@ if (import.meta.main) { + console.log(`Owner-exit: ${failures}/50 failed`); + } + // CI invokes this script with the built executable; the upstream runner uses it for every test. ++ rmSync(terminalPath, { force: true }); + const result = spawnSync( + "node", + [ +@@ -350,6 +366,7 @@ if (import.meta.main) { + "--retries=0", + "--results-json", + resultsPath, ++ ...junitArgs, + ...selected.flatMap(test => ["--include", test.replace(/^test\//, "")]), + ], + { stdio: "inherit" }, +@@ -382,6 +399,10 @@ if (import.meta.main) { + if (direct.stderr) process.stderr.write(direct.stderr); + } + reportDiskUsage("after"); ++ writeFileSync( ++ terminalPath, ++ JSON.stringify({ status: result.status, signal: result.signal, spawnError: !!result.error }) + "\n", ++ ); + if (ownerExitFailed) throw new Error("Owner-exit stress exceeded the Windows ARM64 limit"); + if (result.error) throw result.error; + if (result.status !== 0) process.exit(result.status ?? 1); +diff --git a/scripts/runner.node.ts b/scripts/runner.node.ts +index c9ff165f351dd1345732d8426f2013d1bd8d27fc..11f00085169a54bcc16d241993ec5bc96ff63cdf 100755 +--- a/scripts/runner.node.ts ++++ b/scripts/runner.node.ts +@@ -764,6 +764,7 @@ async function runTests(): Promise { + title: string, + fn: (index: number) => Promise, + concurrent = parallelism > 1, ++ firstResult?: TestResult, + ): Promise => { + const index = ++i; + +@@ -777,11 +778,13 @@ async function runTests(): Promise { + let grouptitle = `${getAnsi("gray")}[${index}/${total}]${getAnsi("reset")} ${title}`; + if (attempt > 1) grouptitle += ` ${getAnsi("gray")}[attempt #${attempt}]${getAnsi("reset")}`; + ++ // A grouped execution already consumed the first attempt, including on a crash or missing report. ++ const runAttempt = () => (attempt === 1 && firstResult ? Promise.resolve(firstResult) : fn(index)); + if (concurrent) { + console.log(grouptitle); +- result = await fn(index); ++ result = await runAttempt(); + } else { +- result = await startGroup(grouptitle, () => fn(index)); ++ result = await startGroup(grouptitle, runAttempt); + } + + const { ok, stdoutPreview, error } = result; +@@ -932,7 +935,7 @@ async function runTests(): Promise { + } + } + +- const runOneTest = async (testPath: string, concurrent: boolean) => { ++ const runOneTest = async (testPath: string, concurrent: boolean, firstResult?: TestResult) => { + await awaitNapiPrebuild(testPath); + const absoluteTestPath = join(testsPath, testPath); + const title = relative(cwd, absoluteTestPath).replaceAll(sep, "/"); +@@ -1014,25 +1017,26 @@ async function runTests(): Promise { + return runTest( + title, + async index => { +- const { ok, error, stdout, crashes, exitCode, signalCode, duration } = await spawnBun(execPath, { +- cwd: cwd, +- args: [ +- subcommand, +- "--config=" + join(import.meta.dirname, "../bunfig.node-test.toml"), +- ...(subcommand === "run" ? testFlags : []), +- absoluteTestPath, +- ], +- timeout: getNodeParallelTestTimeout(title), +- env: { +- ...env, +- // test/common/tmpdir.js derives `.tmp.${TEST_SERIAL_ID}` from this; +- // a unique value per test file keeps concurrent tmpdir.refresh() +- // calls from wiping each other when parallelSafeWidth > 1. +- TEST_SERIAL_ID: String(index), +- }, +- stdout: concurrent ? () => {} : pipeTestStdout(process.stdout), +- stderr: concurrent ? () => {} : pipeTestStdout(process.stderr), +- }); ++ const { ok, error, stdout, crashes, exitCode, signalCode, spawnError, timedOut, idledOut, duration } = ++ await spawnBun(execPath, { ++ cwd: cwd, ++ args: [ ++ subcommand, ++ "--config=" + join(import.meta.dirname, "../bunfig.node-test.toml"), ++ ...(subcommand === "run" ? testFlags : []), ++ absoluteTestPath, ++ ], ++ timeout: getNodeParallelTestTimeout(title), ++ env: { ++ ...env, ++ // test/common/tmpdir.js derives `.tmp.${TEST_SERIAL_ID}` from this; ++ // a unique value per test file keeps concurrent tmpdir.refresh() ++ // calls from wiping each other when parallelSafeWidth > 1. ++ TEST_SERIAL_ID: String(index), ++ }, ++ stdout: concurrent ? () => {} : pipeTestStdout(process.stdout), ++ stderr: concurrent ? () => {} : pipeTestStdout(process.stderr), ++ }); + const mb = 1024 ** 3; + let stdoutPreview = stdout.slice(0, mb).split("\n").slice(0, 50).join("\n"); + if (crashes) stdoutPreview += crashes; +@@ -1047,10 +1051,14 @@ async function runTests(): Promise { + stdoutPreview: stdoutPreview, + exitCode, + signalCode, ++ spawnError, ++ timedOut, ++ idledOut, + duration, + }; + }, + concurrent, ++ firstResult, + ); + } else { + return runTest( +@@ -1062,6 +1070,7 @@ async function runTests(): Promise { + stderr: concurrent ? () => {} : pipeTestStdout(process.stderr), + }), + concurrent, ++ firstResult, + ); + } + }; +@@ -1087,17 +1096,20 @@ async function runTests(): Promise { + } + if (isAsan) env.BUN_FEATURE_FLAG_NO_ORPHANS = "1"; + +- const byPath = new Map(bucketFiles.map(t => [join("test", t).replaceAll("\\", "/"), t])); +- const norm = (p: string) => +- byPath.get( +- p +- .trim() +- .replace(/:$/, "") +- .replace(/ \(\d+s\)$/, "") +- .replaceAll("\\", "/"), +- ); +- +- const { ok, stdout, crashes } = await startGroup(`${range} ${label}`, () => ++ // An aborted process must not reuse a previous invocation's report. ++ rmSync(junitPath, { force: true }); ++ ++ const { ++ ok, ++ error: processError, ++ stdout, ++ crashes, ++ exitCode, ++ signalCode, ++ spawnError, ++ timedOut, ++ idledOut, ++ } = await startGroup(`${range} ${label}`, () => + spawnBun(execPath, { + args: [ + "test", +@@ -1122,108 +1134,66 @@ async function runTests(): Promise { + ); + if (crashes) process.stderr.write(crashes); + +- let suites = new Map(); // repo-relative path -> { failures, seconds, cases: [{name, message}] } ++ // These terminal facts belong to the shared child, not to an individual file. ++ const groupedProcess = { ++ id: basename(junitPath), ++ memberCount: bucketFiles.length, ++ exitCode, ++ signalCode, ++ spawnError, ++ timedOut, ++ idledOut, ++ }; ++ let suites = new Map(); ++ let reportError: string | undefined; + try { + suites = parseJunitFileSuites(readFileSync(junitPath, "utf-8")); +- } catch {} ++ if (!suites.size) throw new Error("empty file suite report"); ++ const expected = new Set(bucketFiles.map(t => join("test", t).replaceAll("\\", "/"))); ++ if ([...suites.keys()].some(file => !expected.has(file))) throw new Error("unexpected file suite"); ++ } catch (error) { ++ reportError = `invalid parallel JUnit report: ${error}`; ++ } + if (suites.size && isBuildkite) uploadArtifactsToBuildkite(junitPath); + else rmSync(junitPath, { force: true }); + +- const failed = new Set(); // ran and failed (or hung) — a solo pass is a parallel-mode flake +- const incomplete = new Set(); // never finished/started — re-run quietly +- let evidence = suites.size > 0; +- if (!ok && suites.size) { +- for (const t of bucketFiles) { ++ // File-level success cannot explain a failing process, such as an unhandled error after tests. ++ const unexplainedFailure = ++ !ok && ++ bucketFiles.every(t => { + const suite = suites.get(join("test", t).replaceAll("\\", "/")); +- if (suite === undefined) incomplete.add(t); +- else if (suite.failures > 0) failed.add(t); +- } +- } else if (!ok) { +- let list: "running" | "not-started" | null = null; // while inside an interrupt report list +- for (const line of stripAnsi(stdout).split(/\r?\n/)) { +- if (line.startsWith("Interrupted while still running:")) { +- list = "running"; +- continue; +- } +- if (/^\d+ file\(s\) had not started:$/.test(line)) { +- list = "not-started"; +- continue; +- } +- if (list && /^ {2}\S/.test(line)) { +- const testPath = norm(line); +- if (testPath) (list === "running" ? failed : incomplete).add(testPath); +- continue; +- } +- list = null; +- const ended = /^✗ (.+?) \((worker crashed|aborted:|no live workers)/.exec(line); +- // The groups of the pattern are not optional, and testPath is only set when it matched. +- const testPath = ended && norm(ended[1]!); +- if (testPath) (ended![2] === "worker crashed" ? failed : incomplete).add(testPath); +- } +- evidence = failed.size + incomplete.size > 0; +- } +- const rerun = !ok && !evidence ? [...bucketFiles] : [...failed, ...incomplete]; +- const rerunSet = new Set(rerun); +- ++ return suite !== undefined && suite.failures === 0 && suite.cases.length === 0; ++ }); + for (const t of bucketFiles) { +- if (rerunSet.has(t)) continue; + const title = join("test", t).replaceAll("\\", "/"); +- const seconds = suites.get(title)?.seconds; +- const timing = seconds === undefined ? "" : ` ${getAnsi("gray")}(${seconds.toFixed(2)}s)${getAnsi("reset")}`; +- console.log(`${getAnsi("gray")}[${++i}/${total}]${getAnsi("reset")} ${title}${timing}`); +- okResults.push({ ++ const suite = suites.get(title); ++ const error = ++ !ok && isAlwaysFailure(processError) ++ ? processError ++ : (reportError ?? ++ (suite === undefined ++ ? "parallel JUnit report is missing this file" ++ : suite.failures > 0 || suite.cases.length > 0 ++ ? "failed in the parallel batch" ++ : unexplainedFailure ++ ? (processError ?? "parallel batch process failed") ++ : undefined)); ++ const passed = error === undefined; ++ const details = suite?.cases.map(({ name, message }) => `✗ ${name}\n${message}`).join("\n\n") ?? ""; ++ await runOneTest(t, false, { + testPath: title, +- ok: true, +- status: "pass", ++ ok: passed, ++ status: passed ? "pass" : "fail", ++ error, + tests: [], + errors: [], +- stdout: "", +- stdoutPreview: "", ++ stdout: passed ? "" : stdout, ++ stdoutPreview: passed ? "" : [reportError, details, stdout.slice(-8192), crashes].filter(Boolean).join("\n"), ++ duration: suite === undefined ? undefined : suite.seconds * 1000, ++ groupedProcess, ++ groupedReport: { error: reportError, suite: suite ?? null }, + }); + } +- for (const t of bucketFiles) { +- if (!failed.has(t)) continue; +- const title = join("test", t).replaceAll("\\", "/"); +- const suite = suites.get(title); +- if (!suite?.cases.length) continue; +- startGroup( +- `${title} - ${suite.failures} failing in the parallel batch ${getAnsi("gray")}(${suite.seconds.toFixed(2)}s)${getAnsi("reset")}`, +- () => { +- for (const { name, message } of suite.cases) { +- console.log(`${getAnsi("red")}✗${getAnsi("reset")} ${name}`); +- if (message) console.log(message.replace(/^/gm, " ")); +- } +- }, +- ); +- } +- if (rerun.length) { +- console.log( +- `${getAnsi("yellow")}parallel bucket: retrying ${failed.size} failed and ${rerun.length - failed.size} unfinished file(s) one at a time${getAnsi("reset")}`, +- ); +- for (const testPath of rerun) { +- const result = await runOneTest(testPath, false); +- if (result?.ok && failed.has(testPath) && isBuildkite) { +- const title = join("test", testPath).replaceAll("\\", "/"); +- const cases = suites.get(title)?.cases ?? []; +- const first = cases[0]; +- const firstError = first ? `${first.name} — ${first.message.split("\n")[0]}` : ""; +- const reason = firstError +- ? escapeHtml(firstError.length > 100 ? `${firstError.slice(0, 97)}…` : firstError) +- : "failed in the parallel batch"; +- const detail = cases.length +- ? `\n\n\`\`\`terminal\n${cases.map(({ name, message }) => `✗ ${name}\n${message}`).join("\n\n")}\n\`\`\`\n\n` +- : ""; +- const unlisted = !isKnownFlakyTest(title); +- reportAnnotationToBuildkite({ +- context: unlisted ? "flaky-new" : "flaky", +- label: title, +- style: "warning", +- priority: unlisted ? 4 : 3, +- content: `
${title} - ${reason} (in the parallel batch on ${getBuildLabel()}; passed alone)${unlisted ? " (not in test/flaky-tests.txt)" : ""}${detail}
`, +- }); +- } +- } +- } + }; + + const modifiedTests = new Set( +@@ -1231,6 +1201,7 @@ async function runTests(): Promise { + ); + const isModified = (t: string) => modifiedTests.has(t.replaceAll("\\", "/")); + const isBucketCandidate = (t: string) => ++ !cliOptions.junit && + parallelism === 1 && + isTestStrict(t) && + !isNodeTest(t) && +@@ -1503,6 +1474,11 @@ async function runTests(): Promise { + error: r.error, + exitCode: r.exitCode, + signalCode: r.signalCode, ++ spawnError: r.spawnError, ++ timedOut: r.timedOut, ++ idledOut: r.idledOut, ++ groupedProcess: r.groupedProcess, ++ groupedReport: r.groupedReport, + duration: r.duration, + stdoutPreview: r.stdoutPreview?.slice?.(-4000), + })); +@@ -1535,12 +1511,17 @@ interface SpawnOptions { + retries?: number; + } + +-interface SpawnResult { ++interface ProcessFacts { ++ exitCode: number | null; ++ signalCode: NodeJS.Signals | null; ++ spawnError: boolean; ++ timedOut: boolean; ++ idledOut: boolean; ++} ++ ++interface SpawnResult extends ProcessFacts { + ok: boolean; + error: string | undefined; +- spawnError: NodeJS.ErrnoException | undefined; +- exitCode: number | null | undefined; +- signalCode: NodeJS.Signals | null | undefined; + timestamp: number; + duration: number; + stdout: string; +@@ -1564,9 +1545,9 @@ async function spawnWithTimeout(options: SpawnOptions): Promise { + stderr = process.stderr.write.bind(process.stderr), + retries = 0, + }: SpawnOptions = options; +- let exitCode: SpawnResult["exitCode"]; +- let signalCode: SpawnResult["signalCode"]; +- let spawnError: SpawnResult["spawnError"]; ++ let exitCode: SpawnResult["exitCode"] | undefined; ++ let signalCode: SpawnResult["signalCode"] | undefined; ++ let spawnError: NodeJS.ErrnoException | undefined; + let timestamp: number | undefined; + let timedOut = false; + let idledOut = false; +@@ -1824,11 +1805,13 @@ async function spawnWithTimeout(options: SpawnOptions): Promise { + if (timedOut && (!error || error === signalCode || /^code \d+$/.test(error))) + error = idledOut ? "stalled" : "timeout"; + return { +- ok: exitCode === 0 && !signalCode && !spawnError, ++ ok: exitCode === 0 && !signalCode && !spawnError && !timedOut && !idledOut, + error, +- exitCode, +- signalCode, +- spawnError, ++ exitCode: exitCode ?? null, ++ signalCode: signalCode ?? null, ++ spawnError: !!spawnError, ++ timedOut, ++ idledOut, + stdout: buffer, + timestamp: timestamp || Date.now(), + duration: duration || 0, +@@ -2029,7 +2012,7 @@ async function spawnBun( + } + } + +-interface TestResult { ++interface TestResult extends Partial { + testPath: string; + ok: boolean; + status: string; +@@ -2039,8 +2022,8 @@ interface TestResult { + stdout: string; + stdoutPreview: string; + // For --results-json and the JUnit report. +- exitCode?: SpawnResult["exitCode"]; +- signalCode?: SpawnResult["signalCode"]; ++ groupedProcess?: ProcessFacts & { id: string; memberCount: number }; ++ groupedReport?: { error?: string; suite: JunitFileSuite | null }; + duration?: number; + } + +@@ -2129,19 +2112,22 @@ async function spawnBunTest( + env.BUN_FEATURE_FLAG_NO_ORPHANS = "1"; + } + +- const { ok, error, stdout, crashes, exitCode, signalCode, duration } = await spawnBun(execPath, { +- args: isReallyTest ? testArgs : [...args, absPath], +- cwd: opts.cwd, +- // release-asan with debug-assertions on runs every spawned subprocess +- // slower; give each file more headroom so tests with heavy beforeAll +- // setup (napi node-gyp compiles) or many subprocess spawns don't hit +- // the file wall before any individual test times out. Kept below the +- // per-test multiplier so the overall shard stays inside the job timeout. +- timeout: isReallyTest ? Math.ceil(timeout * (isAsan ? 2 : 1)) : 30_000, +- env, +- stdout: opts.stdout ?? pipeTestStdout(process.stdout), +- stderr: opts.stderr ?? pipeTestStdout(process.stderr), +- }); ++ const { ok, error, stdout, crashes, exitCode, signalCode, spawnError, timedOut, idledOut, duration } = await spawnBun( ++ execPath, ++ { ++ args: isReallyTest ? testArgs : [...args, absPath], ++ cwd: opts.cwd, ++ // release-asan with debug-assertions on runs every spawned subprocess ++ // slower; give each file more headroom so tests with heavy beforeAll ++ // setup (napi node-gyp compiles) or many subprocess spawns don't hit ++ // the file wall before any individual test times out. Kept below the ++ // per-test multiplier so the overall shard stays inside the job timeout. ++ timeout: isReallyTest ? Math.ceil(timeout * (isAsan ? 2 : 1)) : 30_000, ++ env, ++ stdout: opts.stdout ?? pipeTestStdout(process.stdout), ++ stderr: opts.stderr ?? pipeTestStdout(process.stderr), ++ }, ++ ); + let { tests, errors, stdout: stdoutPreview } = parseTestStdout(stdout, testPath); + if (crashes) stdoutPreview += crashes; + +@@ -2164,6 +2150,9 @@ async function spawnBunTest( + stdoutPreview, + exitCode, + signalCode, ++ spawnError, ++ timedOut, ++ idledOut, + duration, + }; + } +@@ -2320,20 +2309,23 @@ async function spawnBunInstall( + // image's baked cache when one exists (the `prefetch` tool of + // scripts/build/ci-images/spec.ts sets BUN_INSTALL_CACHE_DIR machine-wide). + const cacheDir = process.env.BUN_INSTALL_CACHE_DIR; +- let { ok, error, stdout, duration, crashes } = await spawnBun(execPath, { +- args: ["install"], +- timeout: testTimeout, +- ...options, +- env: { +- // A puppeteer postinstall reached through these installs would download +- // Chrome into the agent's shared ~/.cache; a half-extracted download left +- // there on a persistent agent fails every later job's install. Tests that +- // need a browser install one into a per-run cache (getPuppeteerInstallEnv). +- PUPPETEER_SKIP_DOWNLOAD: "1", +- ...options.env, +- ...(cacheDir && { BUN_INSTALL_CACHE_DIR: cacheDir }), ++ let { ok, error, stdout, duration, crashes, exitCode, signalCode, spawnError, timedOut, idledOut } = await spawnBun( ++ execPath, ++ { ++ args: ["install"], ++ timeout: testTimeout, ++ ...options, ++ env: { ++ // A puppeteer postinstall reached through these installs would download ++ // Chrome into the agent's shared ~/.cache; a half-extracted download left ++ // there on a persistent agent fails every later job's install. Tests that ++ // need a browser install one into a per-run cache (getPuppeteerInstallEnv). ++ PUPPETEER_SKIP_DOWNLOAD: "1", ++ ...options.env, ++ ...(cacheDir && { BUN_INSTALL_CACHE_DIR: cacheDir }), ++ }, + }, +- }); ++ ); + if (crashes) stdout += crashes; + const relativePath = relative(cwd, options.cwd); + const testPath = join(relativePath, "package.json"); +@@ -2354,6 +2346,11 @@ async function spawnBunInstall( + ], + stdout, + stdoutPreview: stdout, ++ exitCode, ++ signalCode, ++ spawnError, ++ timedOut, ++ idledOut, + duration, + }; + } +@@ -2368,7 +2365,9 @@ async function spawnBunInstall( + */ + async function installCiRemapServer(execPath: string): Promise { + const title = relative(cwd, join(ciRemapServerPath, "package.json")).replaceAll(sep, "/"); +- const { ok, error } = await startGroup(title, () => spawnBunInstall(execPath, { cwd: ciRemapServerPath })); ++ const { ok, error } = await startGroup(title, () => ++ spawnBunInstall(execPath, { cwd: ciRemapServerPath, args: ["install", "--frozen-lockfile"] }), ++ ); + if (!ok) console.warn(`ci-remap server not installed (${title}: ${error}), crash reports will not be remapped`); + return ok; + } +@@ -3018,11 +3017,8 @@ function getExitCode(outcome?: "pass" | "fail" | "cancel"): number { + if (outcome === "pass") { + return 0; + } +- if (!isBuildkite) { +- return 1; +- } +- // On Buildkite, you can define a `soft_fail` property to differentiate +- // from failing tests and the runner itself failing. ++ // Keep test failure, cancellation, and setup failure distinct in every environment. ++ // Buildkite soft_fail uses the same exit codes. + if (outcome === "fail") { + return 2; + } +diff --git a/test/js/node/child_process/child-process-stdio.test.js b/test/js/node/child_process/child-process-stdio.test.js +index 361d675936e9694835956eebbd9b4256f8b9e5e3..7e448388ceb3dc10781b55f1df4e72d10f8637c3 100644 +--- a/test/js/node/child_process/child-process-stdio.test.js ++++ b/test/js/node/child_process/child-process-stdio.test.js +@@ -1,6 +1,6 @@ + import { describe, expect, it } from "bun:test"; + import { bunEnv, bunExe, isPosix, isWindows } from "harness"; +-import { execSync, spawn } from "node:child_process"; ++import { execSync, spawn, spawnSync } from "node:child_process"; + import { once } from "node:events"; + import { readSync, writeSync } from "node:fs"; + import { join } from "node:path"; +@@ -8,6 +8,22 @@ import { join } from "node:path"; + const CHILD_PROCESS_FILE = import.meta.dir + "/spawned-child.js"; + const OUT_FILE = import.meta.dir + "/stdio-test-out.txt"; + ++it("spawnSync accepts an array subclass for stdio", () => { ++ class Stdio extends Array {} ++ const result = spawnSync(bunExe(), ["-e", 'console.log("stdout"); console.error("stderr")'], { ++ env: bunEnv, ++ stdio: new Stdio("ignore", "pipe", "pipe"), ++ encoding: "utf8", ++ }); ++ expect({ ++ error: result.error, ++ status: result.status, ++ signal: result.signal, ++ stdout: result.stdout, ++ stderr: result.stderr, ++ }).toEqual({ error: undefined, status: 0, signal: null, stdout: "stdout\n", stderr: "stderr\n" }); ++}); ++ + describe("process.stdout", () => { + it("should allow us to write to it", done => { + const child = spawn(bunExe(), [CHILD_PROCESS_FILE, "STDOUT"], { +diff --git a/test/js/node/vm/vm.test.ts b/test/js/node/vm/vm.test.ts +index 179eb48620280040bd7808653731f6aba7cb81f5..1be67b432d1121e6978cc9557c78b15326877879 100644 +--- a/test/js/node/vm/vm.test.ts ++++ b/test/js/node/vm/vm.test.ts +@@ -3775,8 +3775,12 @@ describe("bounded vm compilation cache", () => { + const first = compile(); first(); + const second = compile(); + assert.equal(shared(first, second), true); +- for (let i = 0; i < 80; i++) new Script("(() => " + i + ")", { filename: "churn-" + i + ".js" }).runInThisContext()(); +- assert.ok(stats().evictions > 0); ++ const beforePressure = stats(); ++ assert.equal(beforePressure.entries, 1); ++ // A near-budget entry forces the shared source out regardless of its measured compile cost. ++ new Script("/* " + Buffer.alloc(26 * 1024, "x").toString() + " */ (() => 7)", { filename: "pressure.js" }).runInThisContext()(); ++ assert.equal(stats().evictions, beforePressure.evictions + 1); ++ assert.equal(stats().entries, 1); + assert.ok(stats().bytes <= stats().limit); + Bun.gc(true); + assert.equal(first(), 42); +--- a/test/js/node/module/node-module-module.test.js ++++ b/test/js/node/module/node-module-module.test.js +@@ -68,9 +68,9 @@ + // Known divergence: Bun's single import/require registry reuses a completed record. + // Node runs load again for require() and can return distinct CommonJS-request source ("outer"). + ["record-identity-completed-handoff", '{"values":["one","one"],"loads":1}'], +- // Known JSC divergence: hostLoadImportedModule repeats pending cycle edges before loadedModules is populated. +- ["static-cycle-import", '{"answer":42,"leafResolves":2}'], +- ["static-cycle-require", '{"answer":42,"leafResolves":2}'], ++ // Pending static requests reuse their referrer's resolved key. ++ ["static-cycle-import", '{"answer":42,"leafResolves":1}'], ++ ["static-cycle-require", '{"answer":42,"leafResolves":1}'], + // Known JSC divergence: hostLoadImportedModule chooses the registry type before host resolution. + [ + "attributes-static-returned-identity", diff --git a/.github/openclaw/qualification/harness_adapters.py b/.github/openclaw/qualification/harness_adapters.py index 469110a450f75..73cb93c5e7850 100644 --- a/.github/openclaw/qualification/harness_adapters.py +++ b/.github/openclaw/qualification/harness_adapters.py @@ -65,7 +65,7 @@ def prepare(root, name, phase, engine, inspector, command, prefix=None): arm = 'baseline' if name == 'baseline' else 'candidate' identity.require(phase != 'build' or name != 'sync', 'invalid build arm') repo = root / ('bun-baseline' if arm == 'baseline' else 'bun') - spec = identity.adapter_spec(arm, phase) + spec = identity.adapter_spec(arm, phase, engine['source']) receipt = root / (arm + '-build-tools.json' if phase == 'build' else name + '/invocation.json') pending = receipt.with_suffix('.pending.json') identity.require(not receipt.exists() and not pending.exists(), 'adapter receipt already exists') @@ -98,7 +98,7 @@ def prepare(root, name, phase, engine, inspector, command, prefix=None): def restore(root, name, phase, engine, inspector, status, active, completed): arm = 'baseline' if name == 'baseline' else 'candidate' repo = root / ('bun-baseline' if arm == 'baseline' else 'bun') - spec = identity.adapter_spec(arm, phase) + spec = identity.adapter_spec(arm, phase, engine['source']) receipt = root / (arm + '-build-tools.json' if phase == 'build' else name + '/invocation.json') pending = receipt.with_suffix('.pending.json') record, digest, inode = active diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 6836e42039a9b..9281032755b0e 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -36,7 +36,8 @@ def install_controls(pipeline, carrier, identity): expected_paths = {"harness-adapters.json", "harness_adapters.py", "harness-adapters/candidate-build.patch", "harness-adapters/candidate-test.patch", "test_consumer_identity.py", "variants.json", "qualify-sync.sh", "verify-sync.py", - "continue-consumer.py", "probe-allocator.cpp"} + "continue-consumer.py", "probe-allocator.cpp", "consumer_identity.py", + "harness-adapters/candidate-current-test.patch"} assert set(source_manifest["files"]) == expected_paths new_adapters = read(reviewed / "harness-adapters.json") assert new_adapters["arms"]["baseline"] == identity.ADAPTERS["arms"]["baseline"] diff --git a/.github/openclaw/qualify-sync.sh b/.github/openclaw/qualify-sync.sh index 6ab54657a10b0..335977aa1e245 100644 --- a/.github/openclaw/qualify-sync.sh +++ b/.github/openclaw/qualify-sync.sh @@ -31,6 +31,9 @@ chmod 700 "$results/home" "$results/tmp" "$candidate" --revision > "$results/revision.log" "$candidate" -e 'const server=Bun.serve({port:0,fetch(){return new Response("ready")}});try{if(await(await fetch(server.url)).text()!=="ready")throw Error("startup");console.log("build/startup/http passed")}finally{await server.stop(true)}' > "$results/startup.log" 2>&1 ln -s "$candidate" "$results/bin/bun" +reference_node="${CANDIDATE_REFERENCE_NODE:-$(command -v node)}" +test "$("$reference_node" --version)" = v26.12.1 +ln -s "$reference_node" "$results/bin/node" export HOME="$results/home" TMPDIR="$results/tmp" PATH="$results/bin:$PATH" OPENCLAW_CI_PLATFORM=linux # Retain all 82 historical cases and the three additions selected by the frozen candidate. "$candidate" --eval 'import {selectTests} from "./scripts/openclaw-ci/tests.ts"; import{$}from"bun";import{readFileSync,writeFileSync,mkdirSync}from"node:fs";const tracked=(await $`git ls-files -z test`.text()).split("\0").filter(Boolean);const historical=[...new Set(process.argv.slice(1).flatMap(path=>JSON.parse(readFileSync(path,"utf8"))))];if(historical.length!==82)throw Error("historical selection drift");const selected=[...new Set([...historical,...selectTests(["scripts/build/deps/webkit.ts"],tracked,true,"linux")])].sort();for(const file of selected)if(!tracked.includes(file))throw Error("missing historical/current selected test "+file);if(selected.length!==85)throw Error("frozen candidate selection drift");mkdirSync("build/openclaw-ci",{recursive:true});writeFileSync("build/openclaw-ci/selected.json",JSON.stringify(selected,null,2)+"\n");' "$inputs/selected.json" "$inputs/sync/selected.json" diff --git a/.github/openclaw/qualify.sh b/.github/openclaw/qualify.sh index 399fd5e28f2c9..e78a3ea6a5a28 100644 --- a/.github/openclaw/qualify.sh +++ b/.github/openclaw/qualify.sh @@ -60,6 +60,10 @@ for arm in baseline candidate; do mkdir -p "$results" "$results/home" "$results/tmp" "$results/bin" chmod 700 "$results/home" "$results/tmp" ln -s "$candidate" "$results/bin/bun" + if test "$arm" = baseline; then reference_node="${BASELINE_REFERENCE_NODE:?}"; expected_node=v26.3.0; + else reference_node="${CANDIDATE_REFERENCE_NODE:?}"; expected_node=v26.12.1; fi + test "$("$reference_node" --version)" = "$expected_node" + ln -s "$reference_node" "$results/bin/node" mkdir -p build/openclaw-ci cp "$inputs/selected.json" build/openclaw-ci/selected.json cp "$inputs/selected.json" "$results/selected.json" diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index 8c08c7a572bf8..335f95fa14a91 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -1,3 +1,5 @@ +Linux qualification now binds separate Node references for the historical baseline (26.3.0) and current candidate (26.12.1). The synchronized engine expects one resolution of each pending static cycle edge; the immutable engine42 continuation retains its original test recipe. Future Linux proof bundles also retain the matching Bun mimalloc object so post-build native probes can resume without recovering it through a full rebuild. Runtime proof for these CI repairs is still pending. + Native artifact smoke probes now destroy the standalone JSC VM and release the FFI test VM under the API lock. ASan and LeakSanitizer checks cover normal teardown. Artifact builds admit the AOT lanes used by current Bun's release and non-LTO CI builds, including both optional musl targets. Linux x64 Debug ASan AOT supplies the native `bun bd test` gate. The ten existing non-AOT lanes and historical Bun qualification remain selected. Current Bun qualification with the AOT libraries is still pending. diff --git a/.github/openclaw/test_consumer_identity.py b/.github/openclaw/test_consumer_identity.py index a33a9830df205..e14b70cef490d 100644 --- a/.github/openclaw/test_consumer_identity.py +++ b/.github/openclaw/test_consumer_identity.py @@ -73,7 +73,7 @@ def write_invocation(root, name, records): argv = [str(cwd/'build'/('qualify-'+arm)/'bun'), 'scripts/openclaw-ci/tests.ts', 'test'] if name == 'sync': argv += ['--junit-prefix', 'openclaw-sync-junit-'+'1'*32+'-'] invocation = {'schema_version': 1, 'phase': 'test', 'arm': arm, 'source': consumer.CONFIG[arm], - 'adapter': consumer.adapter_spec(arm, 'test'), 'restored': True, 'before': before, 'after': before, + 'adapter': consumer.adapter_spec(arm, 'test', record['runtime']['webkit']), 'restored': True, 'before': before, 'after': before, 'compiled_inputs_sha256': '1'*64, 'cwd': str(cwd), 'argv': argv, 'identity': consumer.file_record(root, arm+'-identity.json'), 'executable': record['executable'], 'selection': consumer.file_record(root, name+'/selected.json'), 'evidence': {}} @@ -185,6 +185,15 @@ def write_binary(self,runtime): def record(self): record=consumer.capture(self.root,self.engine,self.inspector);consumer.write_once(self.receipt,record);return record + def test_cycle_adapter_matches_the_engine_generation(self): + legacy = consumer.adapter_spec('candidate', 'test', '42e4245f4180941634b482a7e8ef7fca47467de5') + current = consumer.adapter_spec('candidate', 'test', self.source) + path = 'test/js/node/module/node-module-module.test.js' + self.assertNotIn(path, legacy['files']) + self.assertEqual(current['files'][path]['before'], '83dda3bff94343176a1faa677723f5826dc612e376963192e3ca2400cc6aba45') + self.assertNotEqual(legacy['sha256'], current['sha256']) + self.assertEqual(consumer.adapter_spec('candidate', 'test'), legacy) + def test_measured_receipt_written_once_and_reused(self): record=self.record() self.assertEqual(consumer.verify(self.root,self.engine,self.receipt,self.inspector),record) @@ -382,7 +391,7 @@ def setUp(self): self.file.write_text('original harness\n') spec={'patch':str(self.adapter),'sha256':consumer.sha(self.adapter), 'files':{'harness.js':{'before':before,'after':after,'mode':'100644'}}} - consumer.ADAPTERS['arms']['candidate']={'pin':pin['commit'],'build':spec,'test':spec} + consumer.ADAPTERS['arms']['candidate']={'pin':pin['commit'],'build':spec,'test':spec,'current_test':spec} (self.root/'candidate-build-tools.json').unlink() _,overlay=consumer.source_identity(self.repo,self.engine,self.inspector) seed_build_tools(self.root,'candidate',{'executable':consumer.file_record(self.root,consumer.EXECUTABLE), diff --git a/.github/workflows/openclaw-checks.yml b/.github/workflows/openclaw-checks.yml index f63683b6fec63..8246900d966e7 100644 --- a/.github/workflows/openclaw-checks.yml +++ b/.github/workflows/openclaw-checks.yml @@ -98,6 +98,17 @@ jobs: - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: node-version: '26.3.0' + - name: Bind the historical baseline Node reference + run: | + test "$(node --version)" = v26.3.0 + echo "BASELINE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.12.1' + - name: Bind the candidate Node reference + run: | + test "$(node --version)" = v26.12.1 + echo "CANDIDATE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" - name: Verify pipeline integrity and runner support run: | python3 .github/openclaw/test_artifacts.py @@ -150,6 +161,7 @@ jobs: path: | ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts ${{ runner.temp }}/qualification/*.sha256 compression-level: 0 From b5e3922ba5eed47b4de5235256fd9d33e42b0840 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Sun, 1 Nov 2026 23:58:29 +0800 Subject: [PATCH 22/35] fix(ci): resume current Linux consumer qualification --- .../openclaw/qualification/resume-consumer.py | 40 ++-- .../openclaw-current-linux-consumer.yml | 185 ++++++++++++++++++ 2 files changed, 212 insertions(+), 13 deletions(-) create mode 100644 .github/workflows/openclaw-current-linux-consumer.yml diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index 9281032755b0e..df889e2d457b7 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -64,11 +64,21 @@ def install_controls(pipeline, carrier, identity): def main(): args = sys.argv[1:] + checkpoint = bool(args and args[0] == "--checkpoint") + if checkpoint: + args = args[1:] + sync = "9f5edfb699e35691497b06572a321b20994ca4e5" if checkpoint else SYNC + previous_run = 41318328617 if checkpoint else PREVIOUS_RUN + previous_carrier = sync if checkpoint else PREVIOUS_CARRIER + retained_inputs = ({ + "proof": (13088932734, 164172, "16a72ee327da468500515bffdc799e9d1a2b9ef0abed825a4500d17a949150ed"), + "binaries": (13089031547, 182136473, "75d9112abe8452be1b8e7f4f5b27f765544011803a9e80dc93f3356f0aebfd24"), + } if checkpoint else RETAINED) fresh_engine = bool(args and args[0] == "--fresh-engine") if fresh_engine: args = args[1:] pipeline, carrier, retained, root, artifacts = [Path(p).resolve() for p in args] - assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == SYNC + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == sync frozen = pipeline / ".github/openclaw/qualification" reviewed = carrier / ".github/openclaw/qualification" # Validate old receipts with the original policy before installing new adapters. @@ -79,21 +89,22 @@ def main(): spec = importlib.util.spec_from_file_location("retained_diagnostic", diagnostic) module = importlib.util.module_from_spec(spec) spec.loader.exec_module(module) - proof, binaries = [module.unpack(retained, name, expected=RETAINED[name], - run=PREVIOUS_RUN, carrier=PREVIOUS_CARRIER) + proof, binaries = [module.unpack(retained, name, expected=retained_inputs[name], + run=previous_run, carrier=previous_carrier) for name in ("proof", "binaries")] baseline = read(proof / "baseline-identity.json") engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), - artifacts / (identity.LANE + ".manifest.json"), SYNC) + artifacts / (identity.LANE + ".manifest.json"), sync) identity.validate_baseline_evidence(baseline, binaries, proof) identity.validate_invocation(proof, "baseline") assert (proof / "baseline/selected.json").read_bytes() == (frozen / "selected.json").read_bytes() assert len(read(frozen / "selected.json")) == 44 - old_carrier = read(proof / "carrier.json") - assert old_carrier["carrier"] == PREVIOUS_CARRIER and old_carrier["sync"] == SYNC + if not checkpoint: + old_carrier = read(proof / "carrier.json") + assert old_carrier["carrier"] == previous_carrier and old_carrier["sync"] == sync engine_proof = root if fresh_engine else proof engine_gate = read(engine_proof / "engine-gate.json") - assert engine_gate["passed"] is True and engine_gate["source"] == SYNC + assert engine_gate["passed"] is True and engine_gate["source"] == sync assert engine_gate["stress_counts"]["jsc-stress"] >= 1400 assert engine_gate["stress_counts"]["jsc-modules"] >= 1600 for name, count in engine_gate["stress_counts"].items(): @@ -129,8 +140,11 @@ def main(): # Candidate receipts and executables are deliberately not copied across source changes. # Keep the normal build, identity creation, selection and every later gate. - source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) - assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() + if checkpoint: + source = (carrier / ".github/openclaw/qualify.sh").read_bytes() + else: + source = subprocess.check_output(["git", "-C", str(pipeline), "show", SYNC + ":.github/openclaw/qualify.sh"]) + assert source == (pipeline / ".github/openclaw/qualify.sh").read_bytes() anchor = b"for arm in baseline candidate; do" assert source.count(anchor) == 1 source = source.replace(anchor, b"for arm in candidate; do") @@ -140,10 +154,10 @@ def main(): driver = root / "qualify-candidate-fresh.sh" driver.write_bytes(source) (root / "reuse.json").write_text(json.dumps({ - "previous_run": PREVIOUS_RUN, "previous_carrier": PREVIOUS_CARRIER, - "sync": SYNC, "candidate_repair_source": SOURCE, - "proof_artifact": RETAINED["proof"][0], - "binary_artifact": RETAINED["binaries"][0], + "previous_run": previous_run, "previous_carrier": previous_carrier, + "sync": sync, "candidate_repair_source": SOURCE, + "proof_artifact": retained_inputs["proof"][0], + "binary_artifact": retained_inputs["binaries"][0], "baseline_identity_sha256": sha(root / "baseline-identity.json"), "baseline_invocation_sha256": sha(root / "baseline/invocation.json"), "engine_gate_sha256": sha(root / "engine-gate.json"), diff --git a/.github/workflows/openclaw-current-linux-consumer.yml b/.github/workflows/openclaw-current-linux-consumer.yml new file mode 100644 index 0000000000000..3108ec83b0573 --- /dev/null +++ b/.github/workflows/openclaw-current-linux-consumer.yml @@ -0,0 +1,185 @@ +name: OpenClaw current Linux consumer continuation + +on: + push: + branches: [claude/hosted-linux-consumer-20261031] + paths: + - .github/workflows/openclaw-current-linux-consumer.yml + - .github/openclaw/qualification/resume-consumer.py + workflow_dispatch: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-current-linux-consumer-${{ github.ref }} + cancel-in-progress: true + +env: + CI: '1' + PUPPETEER_SKIP_DOWNLOAD: '1' + +jobs: + current-consumer: + runs-on: blacksmith-32vcpu-ubuntu-2404 + timeout-minutes: 120 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 9f5edfb699e35691497b06572a321b20994ca4e5 + path: pipeline + persist-credentials: false + sparse-checkout: | + .github/openclaw + Source/JavaScriptCore + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: ${{ github.sha }} + path: carrier + persist-credentials: false + sparse-checkout: .github/openclaw + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.3.0' + - name: Bind the historical Node reference + run: | + test "$(node --version)" = v26.3.0 + echo "BASELINE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.12.1' + - name: Bind the candidate Node reference and workspace + run: | + test "$(node --version)" = v26.12.1 + echo "CANDIDATE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" + echo "QUALIFICATION_DIR=$RUNNER_TEMP/qualification" >> "$GITHUB_ENV" + echo "ARTIFACT_DIR=$RUNNER_TEMP/engine-input" >> "$GITHUB_ENV" + mkdir "$RUNNER_TEMP/qualification" "$RUNNER_TEMP/retained" "$RUNNER_TEMP/engine-input" + - name: Install the existing pinned candidate build tools + run: | + curl -fsSL --retry 5 https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null + echo 'deb https://apt.llvm.org/noble/ llvm-toolchain-noble-23 main' | sudo tee /etc/apt/sources.list.d/llvm.list + sudo apt-get update -qq + sudo apt-get install -y --no-install-recommends cmake ninja-build nasm ccache golang-go clang-23 lld-23 llvm-23 unzip ruby ruby-highline libjson-pp-perl + rustup toolchain install nightly-2026-09-15 --profile minimal --component rust-src + echo 'RUSTUP_TOOLCHAIN=nightly-2026-09-15' >> "$GITHUB_ENV" + echo '/usr/lib/llvm-23/bin' >> "$GITHUB_PATH" + curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bootstrap.zip" + unzip -q "$RUNNER_TEMP/bootstrap.zip" -d "$RUNNER_TEMP/bootstrap" + echo "INSPECTOR_RUNTIME=$RUNNER_TEMP/bootstrap/bun-linux-x64/bun" >> "$GITHUB_ENV" + - name: Download the immutable engine and previous evidence + env: + GH_TOKEN: ${{ github.token }} + run: | + set -euo pipefail + for item in proof:13088932734 binaries:13089031547 engine:13088627389; do + name=${item%%:*} + id=${item#*:} + gh api "repos/openclaw/WebKit/actions/artifacts/$id" > "$RUNNER_TEMP/retained/$name.metadata.json" + gh api "repos/openclaw/WebKit/actions/artifacts/$id/zip" > "$RUNNER_TEMP/retained/$name.zip" + done + - name: Admit the engine and record the exact reference tools + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 - <<'PY' + import hashlib, json, os, shutil, stat, subprocess, zipfile + from pathlib import Path, PurePosixPath + def sha(path): + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() + retained = Path(os.environ['RUNNER_TEMP'], 'retained') + metadata = json.loads((retained / 'engine.metadata.json').read_text()) + archive = retained / 'engine.zip' + digest = '5314f937ae57c5298baedd7bef52242b025f3382ea76155287f4524d6b54d980' + assert metadata['id'] == 13088627389 and not metadata['expired'] + assert metadata['name'] == 'bun-webkit-linux-amd64' + assert metadata['workflow_run']['id'] == 41318328617 + assert metadata['workflow_run']['head_sha'] == '9f5edfb699e35691497b06572a321b20994ca4e5' + assert metadata['size_in_bytes'] == archive.stat().st_size == 716189633 + assert metadata['digest'] == 'sha256:' + digest and sha(archive) == digest + destination = Path(os.environ['ARTIFACT_DIR']) + with zipfile.ZipFile(archive) as bundle: + entries = bundle.infolist() + assert 0 < len(entries) <= 32 and len({e.filename for e in entries}) == len(entries) + assert sum(e.file_size for e in entries) < 2 * 1024**3 and bundle.testzip() is None + for entry in entries: + path = PurePosixPath(entry.filename) + assert not path.is_absolute() and '..' not in path.parts and '\\' not in entry.filename + assert all(part not in ('', '.', '..') for part in entry.filename.rstrip('/').split('/')) + mode = stat.S_IFMT(entry.external_attr >> 16) + assert mode in (0, stat.S_IFDIR if entry.is_dir() else stat.S_IFREG) + target = destination / path + if entry.is_dir(): + assert entry.file_size == 0 + target.mkdir(parents=True, exist_ok=True) + else: + target.parent.mkdir(parents=True, exist_ok=True) + with bundle.open(entry) as source, target.open('xb') as output: + shutil.copyfileobj(source, output) + target.chmod(0o600) + bootstrap = Path(os.environ['INSPECTOR_RUNTIME']).resolve() + assert bootstrap.stat().st_size == 79500640 and sha(bootstrap) == 'a83d263767d839e4d2649ca8e35d07159c7afc99afdc96d731ced29e056dda0c' + references = {} + for arm, key, version in [('baseline', 'BASELINE_REFERENCE_NODE', 'v26.3.0'), ('candidate', 'CANDIDATE_REFERENCE_NODE', 'v26.12.1')]: + executable = Path(os.environ[key]).resolve(strict=True) + actual = subprocess.check_output([str(executable), '--version'], text=True).strip() + assert actual == version + references[arm] = {'path': str(executable), 'version': actual, 'size': executable.stat().st_size, 'sha256': sha(executable)} + references['carrier'] = subprocess.check_output(['git', '-C', 'carrier', 'rev-parse', 'HEAD'], text=True).strip() + references['pipeline'] = subprocess.check_output(['git', '-C', 'pipeline', 'rev-parse', 'HEAD'], text=True).strip() + Path(os.environ['QUALIFICATION_DIR'], 'reference-tools.json').write_text(json.dumps(references, indent=2) + '\n') + PY + - name: Reuse engine and baseline proof, then complete the current candidate gates + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 carrier/.github/openclaw/qualification/resume-consumer.py --checkpoint \ + "$GITHUB_WORKSPACE/pipeline" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" + cd pipeline + bash "$QUALIFICATION_DIR/qualify-candidate-fresh.sh" + export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" + export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" + bash .github/openclaw/qualify-sync-compatibility.sh + bash .github/openclaw/qualify-sync.sh + - name: Retain executables and their matching allocator object + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: current-linux-bun-executables + path: | + ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o + ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts + ${{ runner.temp }}/qualification/*.sha256 + compression-level: 0 + retention-days: 3 + if-no-files-found: warn + - name: Retain current and reused proof with their original identities + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: current-linux-consumer-proof + path: | + ${{ runner.temp }}/qualification/*.json + ${{ runner.temp }}/qualification/*.log + ${{ runner.temp }}/qualification/*.sha256 + ${{ runner.temp }}/qualification/*.patch + ${{ runner.temp }}/qualification/qualify-candidate-fresh.sh + ${{ runner.temp }}/qualification/candidate-input/artifacts.json + ${{ runner.temp }}/qualification/baseline/*.json + ${{ runner.temp }}/qualification/baseline/*.log + ${{ runner.temp }}/qualification/candidate/*.json + ${{ runner.temp }}/qualification/candidate/*.log + ${{ runner.temp }}/qualification/compatibility/*.log + ${{ runner.temp }}/qualification/sync/*.json + ${{ runner.temp }}/qualification/sync/*.xml + ${{ runner.temp }}/qualification/sync/*.log + ${{ runner.temp }}/qualification/sync/runtime-cache/*.json + ${{ runner.temp }}/qualification/jsc-*/results + ${{ runner.temp }}/qualification/jsc-stack/*.log + ${{ runner.temp }}/qualification/jsc-stack/*.json + retention-days: 7 + if-no-files-found: error From 9f03dbd21a64683d1b32e50ace51270248bf92a5 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 00:07:21 +0800 Subject: [PATCH 23/35] fix(ci): expose verified bootstrap to nested builds --- .github/workflows/openclaw-current-linux-consumer.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/openclaw-current-linux-consumer.yml b/.github/workflows/openclaw-current-linux-consumer.yml index 3108ec83b0573..e386956451460 100644 --- a/.github/workflows/openclaw-current-linux-consumer.yml +++ b/.github/workflows/openclaw-current-linux-consumer.yml @@ -121,6 +121,8 @@ jobs: target.chmod(0o600) bootstrap = Path(os.environ['INSPECTOR_RUNTIME']).resolve() assert bootstrap.stat().st_size == 79500640 and sha(bootstrap) == 'a83d263767d839e4d2649ca8e35d07159c7afc99afdc96d731ced29e056dda0c' + with Path(os.environ['GITHUB_PATH']).open('a') as path: + path.write(str(bootstrap.parent) + '\n') references = {} for arm, key, version in [('baseline', 'BASELINE_REFERENCE_NODE', 'v26.3.0'), ('candidate', 'CANDIDATE_REFERENCE_NODE', 'v26.12.1')]: executable = Path(os.environ[key]).resolve(strict=True) From 4430cc2e4caa5720c2f78963be3566c87b958084 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 00:25:28 +0800 Subject: [PATCH 24/35] test(ci): qualify downstream consumers on the synchronized engine --- .../qualification/downstream-consumers.py | 156 ++++++++++++++++++ .../openclaw-current-downstream-consumers.yml | 110 ++++++++++++ 2 files changed, 266 insertions(+) create mode 100644 .github/openclaw/qualification/downstream-consumers.py create mode 100644 .github/workflows/openclaw-current-downstream-consumers.yml diff --git a/.github/openclaw/qualification/downstream-consumers.py b/.github/openclaw/qualification/downstream-consumers.py new file mode 100644 index 0000000000000..1200499b814a7 --- /dev/null +++ b/.github/openclaw/qualification/downstream-consumers.py @@ -0,0 +1,156 @@ +"""Qualify frozen OpenClaw consumers against one admitted, unreleased Bun binary.""" +import hashlib +import importlib.util +import json +import math +import os +from pathlib import Path +import shutil +import subprocess +import sys + +TEMP = Path(os.environ['RUNNER_TEMP']) +WORKSPACE = Path(os.environ['GITHUB_WORKSPACE']) +ROOT = TEMP / 'downstream' +PROOF = TEMP / 'downstream-proof' +SOURCE = '9f5edfb699e35691497b06572a321b20994ca4e5' +BUN = 'd9be087429c21e563bb5ac29f8a11805e64b56a3' +OPENCLAW = '2952110b2a14efac009e1cc5fb758cd8ed15d193' +BIRDCLAW = '59c9ee27f39238654efc93ff7862b27ad474c044' +REPLAY = 41324678688 +CARRIER = '9f03dbd21a64683d1b32e50ace51270248bf92a5' +EXECUTABLE = '2ec7cfd15b846d11d1f45e311fbc10fd7b447f6fcfb579485525ee1233e95513' + + +def sha(path): + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() + + +def read(path): + return json.loads(path.read_text()) + + +def write(name, value): + (PROOF / name).write_text(json.dumps(value, indent=2) + '\n') + + +def head(repo, expected): + assert subprocess.check_output(['git', '-C', str(repo), 'rev-parse', 'HEAD'], text=True).strip() == expected + + +def admit(): + PROOF.mkdir() + ROOT.mkdir() + helper = WORKSPACE / 'carrier/.github/openclaw/qualification/assemble-retained-matrix.py' + spec = importlib.util.spec_from_file_location('retained', helper) + retained = importlib.util.module_from_spec(spec) + spec.loader.exec_module(retained) + run, jobs = retained.run_identity(REPLAY, CARRIER, 'openclaw-current-linux-consumer.yml') + assert run['conclusion'] == 'success' and jobs['current-consumer']['conclusion'] == 'success' + records = {} + for label, row in { + 'current-linux-consumer-proof': (13090894299, 407316, 'sha256:63c674db96939947df3671c2187c39db96bd2f6a43340f10f7edf413fa09148d'), + 'current-linux-bun-executables': (13090653410, 183705425, 'sha256:7b4599e44b1a68ace49cffa533209acb6a255542bb59dc6aa8ff250b15f5099e'), + }.items(): + records[label] = retained.download(ROOT, label, row, REPLAY, CARRIER) + evidence = ROOT / 'current-linux-consumer-proof' + identity = read(evidence / 'candidate-identity.json') + assert identity['candidate']['commit'] == BUN and identity['engine']['source'] == SOURCE + assert identity['runtime'] == {'bun_revision': BUN, 'webkit': SOURCE, 'platform': 'linux', 'architecture': 'x64'} + gate = read(evidence / 'gate.json') + assert gate['passed'] is True and gate['candidate_identity_sha256'] == sha(evidence / 'candidate-identity.json') + build = read(evidence / 'candidate-build-tools.json') + assert sha(evidence / 'candidate-build-tools.json') == identity['build_tools']['sha256'] + assert build['compiled_inputs_sha256'] == '33c6f0b30bf33c45b2aab86ca7bf9692cbb30e2114d2e70e255e9ac43e52f614' + binary = ROOT / 'current-linux-bun-executables' / identity['executable']['path'] + assert binary.stat().st_size == identity['executable']['size'] == 105658384 + assert sha(binary) == identity['executable']['sha256'] == EXECUTABLE + binary.chmod(0o755) + bindir = ROOT / 'bin' + bindir.mkdir() + (bindir / 'bun').symlink_to(binary) + write('admission.json', {'passed': True, 'mode': 'downstream-smoke', 'source': SOURCE, 'bun': BUN, + 'binary': str(binary), 'sha256': EXECUTABLE, 'bytes': binary.stat().st_size, + 'compiled_inputs_sha256': build['compiled_inputs_sha256'], 'inputs': records, + 'controls': {'controller_sha256': sha(Path(__file__)), 'retained_helper_sha256': sha(helper)}}) + with Path(os.environ['GITHUB_ENV']).open('a') as stream: + stream.write('BUN_BIN=' + str(binary) + '\n') + with Path(os.environ['GITHUB_PATH']).open('a') as stream: + stream.write(str(bindir) + '\n') + + +def candidate(): + admission = read(PROOF / 'admission.json') + binary = Path(os.environ['BUN_BIN']) + assert str(binary) == admission['binary'] and binary.is_absolute() + assert binary.stat().st_size == admission['bytes'] and sha(binary) == admission['sha256'] == EXECUTABLE + assert Path(shutil.which('bun')).resolve() == binary + revision = subprocess.check_output([str(binary), '--revision'], text=True).strip() + script = 'console.log(JSON.stringify({bun_revision:Bun.revision,webkit:process.versions.webkit,platform:process.platform,architecture:process.arch}))' + observed = json.loads(subprocess.check_output([str(binary), '--no-env-file', '-e', script], text=True)) + assert observed == {'bun_revision': BUN, 'webkit': SOURCE, 'platform': 'linux', 'architecture': 'x64'} + write('candidate-runtime.json', {'runtime': observed, 'cli_revision': revision, 'binary_sha256': sha(binary)}) + return binary, revision + + +def vitest(path, files): + report = read(path) + assert report['success'] is True + total = sum(files.values()) + assert report['numTotalTests'] == report['numPassedTests'] == total + assert all(report[key] == 0 for key in ('numFailedTests', 'numPendingTests', 'numTodoTests')) + results = report['testResults'] + assert len(results) == len(files) + for suffix, count in files.items(): + rows = [row for row in results if row['name'].endswith('/' + suffix)] + assert len(rows) == 1 and rows[0]['status'] == 'passed' + cases = rows[0]['assertionResults'] + assert len(cases) == count and all(case['status'] == 'passed' for case in cases) + + +def openclaw(): + binary, revision = candidate() + repo = WORKSPACE / 'openclaw' + head(repo, OPENCLAW) + report = read(PROOF / 'openclaw-smoke/report.json') + assert report['ok'] is True and not report.get('fatalError') and report['entry'] + assert Path(report['bun']).resolve() == binary and report['bunRevision'] == revision + assert [row['name'] for row in report['steps']] == [ + 'preconditions', 'install', 'cli', 'gateway', 'node-host', 'agent', 'doctor', 'terminals', 'browser', 'cleanup'] + assert all(row['status'] == 'passed' for row in report['steps']) + assert all(report[key] == [] for key in ('blockers', 'attempts', 'unexpectedAttempts', 'staleBlockers', 'failedSteps')) + vitest(PROOF / 'openclaw-sqlite.json', {'src/infra/sqlite-existing-database.bun.test.ts': 1, + 'src/infra/sqlite-worker-input.bun.test.ts': 1}) + write('openclaw-gate.json', {'passed': True, 'head': OPENCLAW, 'binary_sha256': sha(binary), + 'revision': revision, 'smoke_steps': 10, 'sqlite_cases': 2, + 'report_sha256': sha(PROOF / 'openclaw-smoke/report.json'), + 'package_sha256': sha(TEMP / 'package/candidate.tgz')}) + + +def birdclaw(): + binary, revision = candidate() + repo = WORKSPACE / 'birdclaw' + head(repo, BIRDCLAW) + vitest(PROOF / 'birdclaw-vitest.json', {'src/lib/sqlite.test.ts': 3, + 'src/lib/database-migrations.test.ts': 4, 'src/lib/production-server.test.ts': 5}) + report = read(PROOF / 'birdclaw-runtime.json') + assert report['schemaVersion'] == 1 and report['gitSha'] == BIRDCLAW and report['iterations'] == 1 + assert report['runtime'] == {'executable': str(binary), 'args': ['--no-env-file'], 'identity': revision} + assert Path(report['home']) == TEMP / 'birdclaw-home' + assert report['inputDatabaseLogicalSha256'] == report['finalDatabaseLogicalSha256'] + for key, name in {'launcherSha256': 'bin/birdclaw.mjs', 'cliSha256': 'dist/cli/birdclaw.js', + 'serverSha256': 'dist/server/server.js'}.items(): + assert report['artifacts'][key] == sha(repo / name) + assert len(report['samples']['cliMs']) == len(report['samples']['server']) == 1 + for elapsed in report['samples']['cliMs']: + assert math.isfinite(elapsed) and elapsed >= 0 + for row in report['samples']['server']: + assert all(math.isfinite(row[key]) and row[key] >= 0 for key in ('listeningMs', 'firstResponseMs')) + write('birdclaw-gate.json', {'passed': True, 'head': BIRDCLAW, 'binary_sha256': sha(binary), + 'revision': revision, 'test_cases': 12, 'runtime_iterations': 1, + 'report_sha256': sha(PROOF / 'birdclaw-runtime.json'), 'artifacts': report['artifacts']}) + + +if __name__ == '__main__': + {'admit': admit, 'identity': candidate, 'openclaw': openclaw, 'birdclaw': birdclaw}[sys.argv[1]]() diff --git a/.github/workflows/openclaw-current-downstream-consumers.yml b/.github/workflows/openclaw-current-downstream-consumers.yml new file mode 100644 index 0000000000000..f669e2ae88655 --- /dev/null +++ b/.github/workflows/openclaw-current-downstream-consumers.yml @@ -0,0 +1,110 @@ +name: OpenClaw current downstream Bun consumer qualification + +on: + push: + branches: [claude/hosted-linux-consumer-20261031] + paths: + - .github/workflows/openclaw-current-downstream-consumers.yml + - .github/openclaw/qualification/downstream-consumers.py + workflow_dispatch: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-current-downstream-consumers-${{ github.ref }} + cancel-in-progress: false + +jobs: + consumers: + runs-on: ubuntu-24.04 + timeout-minutes: 90 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + persist-credentials: false + path: controls + sparse-checkout: .github + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 5e586e4ce8bd9f3f3703af98983f7f13fb58c242 + persist-credentials: false + path: carrier + sparse-checkout: .github + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: openclaw/openclaw + ref: 2952110b2a14efac009e1cc5fb758cd8ed15d193 + persist-credentials: false + path: openclaw + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: openclaw/birdclaw + ref: 59c9ee27f39238654efc93ff7862b27ad474c044 + persist-credentials: false + path: birdclaw + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.12.1' + - name: Install the pinned package manager and check smoke prerequisites + run: | + set -euo pipefail + npm install --global pnpm@12.15.0 + test "$(node --version)" = v26.12.1 + test "$(pnpm --version)" = 12.15.0 + test -x /usr/bin/google-chrome + command -v unshare setpriv >/dev/null + sudo -n true + - name: Admit the exact qualified binary and its original receipt + id: admit + env: + GH_TOKEN: ${{ github.token }} + run: python3 controls/.github/openclaw/qualification/downstream-consumers.py admit + - name: Qualify the OpenClaw package, launcher and SQLite boundaries + working-directory: openclaw + env: + OPENCLAW_TEST_BUN_LAUNCHER: '1' + OPENCLAW_BUN_ONLY_SMOKE_HIDE_SYSTEM_NODE: '1' + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 "$GITHUB_WORKSPACE/controls/.github/openclaw/qualification/downstream-consumers.py" identity + pnpm install --frozen-lockfile 2>&1 | tee "$RUNNER_TEMP/downstream-proof/openclaw-install.log" + node scripts/package-openclaw-for-docker.mjs --allow-unreleased-changelog --output-dir "$RUNNER_TEMP/package" --output-name candidate.tgz 2>&1 | tee "$RUNNER_TEMP/downstream-proof/openclaw-package.log" + export OPENCLAW_BUN_ONLY_SMOKE_PACKAGE_TGZ="$RUNNER_TEMP/package/candidate.tgz" + export OPENCLAW_BUN_ONLY_SMOKE_ARTIFACT_DIR="$RUNNER_TEMP/downstream-proof/openclaw-smoke" + /bin/bash scripts/e2e/bun-only-runtime-smoke.sh 2>&1 | tee "$RUNNER_TEMP/downstream-proof/openclaw-smoke.log" + pnpm test src/infra/sqlite-existing-database.bun.test.ts src/infra/sqlite-worker-input.bun.test.ts -- --reporter=json --outputFile="$RUNNER_TEMP/downstream-proof/openclaw-sqlite.json" 2>&1 | tee "$RUNNER_TEMP/downstream-proof/openclaw-sqlite.log" + python3 "$GITHUB_WORKSPACE/controls/.github/openclaw/qualification/downstream-consumers.py" openclaw + - name: Qualify Birdclaw SQLite, migrations, CLI and production server + if: ${{ !cancelled() && steps.admit.outcome == 'success' }} + working-directory: birdclaw + env: + BIRDCLAW_BACKUP_AUTO_SYNC: '0' + BIRDCLAW_DISABLE_LIVE_PROFILE_LOOKUP: '1' + BIRDCLAW_DISABLE_LIVE_WRITES: '1' + DO_NOT_TRACK: '1' + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 "$GITHUB_WORKSPACE/controls/.github/openclaw/qualification/downstream-consumers.py" identity + export BIRDCLAW_HOME="$RUNNER_TEMP/birdclaw-home" + "$BUN_BIN" --no-env-file install --frozen-lockfile 2>&1 | tee "$RUNNER_TEMP/downstream-proof/birdclaw-install.log" + "$BUN_BIN" --no-env-file run --bun build 2>&1 | tee "$RUNNER_TEMP/downstream-proof/birdclaw-build.log" + "$BUN_BIN" --no-env-file scripts/run-vitest.mjs run src/lib/sqlite.test.ts src/lib/database-migrations.test.ts src/lib/production-server.test.ts --reporter=json --outputFile="$RUNNER_TEMP/downstream-proof/birdclaw-vitest.json" 2>&1 | tee "$RUNNER_TEMP/downstream-proof/birdclaw-vitest.log" + "$BUN_BIN" --no-env-file bin/birdclaw.mjs --json init --demo > "$RUNNER_TEMP/downstream-proof/birdclaw-init.json" + "$BUN_BIN" --no-env-file scripts/runtime-perf.mjs --label=current-engine-consumer --runtime="$BUN_BIN" --runtime-arg=--no-env-file --entry=bin/birdclaw.mjs --home="$BIRDCLAW_HOME" --iterations=1 --git-sha=59c9ee27f39238654efc93ff7862b27ad474c044 > "$RUNNER_TEMP/downstream-proof/birdclaw-runtime.json" 2> "$RUNNER_TEMP/downstream-proof/birdclaw-runtime.log" + python3 "$GITHUB_WORKSPACE/controls/.github/openclaw/qualification/downstream-consumers.py" birdclaw + - name: Seal both consumer results + run: | + set -euo pipefail + python3 controls/.github/openclaw/qualification/downstream-consumers.py openclaw + python3 controls/.github/openclaw/qualification/downstream-consumers.py birdclaw + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + if: always() + with: + name: current-downstream-consumer-proof + path: ${{ runner.temp }}/downstream-proof + if-no-files-found: warn + retention-days: 7 From b1b043eab568e09d22aed763db4ccdbfabdda209 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:32:42 +0800 Subject: [PATCH 25/35] fix(ci): bind Node references and resume current matrix qualification --- .../openclaw/qualification/resume-consumer.py | 147 ++++++++++++++++- .github/openclaw/qualify.sh | 2 +- .github/openclaw/release-notes.md | 2 + .github/workflows/openclaw-artifacts.yml | 11 ++ .../openclaw-current-matrix-consumer.yml | 153 ++++++++++++++++++ 5 files changed, 307 insertions(+), 8 deletions(-) create mode 100644 .github/workflows/openclaw-current-matrix-consumer.yml diff --git a/.github/openclaw/qualification/resume-consumer.py b/.github/openclaw/qualification/resume-consumer.py index df889e2d457b7..21c4eb5aff6a9 100644 --- a/.github/openclaw/qualification/resume-consumer.py +++ b/.github/openclaw/qualification/resume-consumer.py @@ -62,6 +62,13 @@ def install_controls(pipeline, carrier, identity): return source_manifest +def expose_proxy(source): + old = b'"$candidate" test test/js/node/vm/vm.test.ts' + new = b'"$candidate" test --expose-internals test/js/node/vm/vm.test.ts' + assert source.count(old) + source.count(new) == 1 + return source.replace(old, new) + + def main(): args = sys.argv[1:] checkpoint = bool(args and args[0] == "--checkpoint") @@ -148,9 +155,7 @@ def main(): anchor = b"for arm in baseline candidate; do" assert source.count(anchor) == 1 source = source.replace(anchor, b"for arm in candidate; do") - proxy_command = b'"$candidate" test test/js/node/vm/vm.test.ts' - assert source.count(proxy_command) == 1 - source = source.replace(proxy_command, b'"$candidate" test --expose-internals test/js/node/vm/vm.test.ts') + source = expose_proxy(source) driver = root / "qualify-candidate-fresh.sh" driver.write_bytes(source) (root / "reuse.json").write_text(json.dumps({ @@ -252,9 +257,7 @@ def replay_matrix(pipeline, carrier, retained, root, artifacts, checkout, inspec driver += b'arm=candidate\nrepo="$QUALIFICATION_DIR/bun"\ncandidate="$repo/build/qualify-candidate/bun"\ncd "$repo"\n' driver += b'"$bootstrap" install --frozen-lockfile\n(cd test && "$bootstrap" install --frozen-lockfile)\n' driver += source[source.index(begin):source.index(end)] + source[source.index(end) + len(b"done\n"):] - proxy = b'"$candidate" test test/js/node/vm/vm.test.ts' - assert driver.count(proxy) == 1 - driver = driver.replace(proxy, b'"$candidate" test --expose-internals test/js/node/vm/vm.test.ts') + driver = expose_proxy(driver) (root / "qualify-retained-matrix.sh").write_bytes(driver) manifest = read(inputs / "consumer-repair.json") for name, digest in manifest["files"].items(): @@ -298,8 +301,138 @@ def seal_matrix(pipeline, root, artifacts, inspector): "gate_sha256": sha(root / "gate.json"), "candidate_identity_sha256": record["candidate_identity_sha256"]}, indent=2) + "\n") + +CURRENT_MATRIX_HEAD = "4430cc2e4caa5720c2f78963be3566c87b958084" +CURRENT_MATRIX_RUN = 41330085617 +CURRENT_MATRIX_INPUTS = { + "qualification": [13100392950, 81556, "sha256:fafbd7145dce9808ae108478cdb94cc5e741e0caeff4c93745f8e88129adb304"], + "linux-bun-executables": [13100835127, 76466682, "sha256:ec3df590339bed2aa45fcf0b58ef0f353b23a31864b0440c841876e07cfadaab"], + "bun-webkit-linux-amd64": [13093547315, 716162784, "sha256:cf8da5e9e6b7dda9733ef9479e116df621470b3fa02cafd88f1711aa5e4734be"], +} + + +def current_matrix_policy(pipeline): + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == CURRENT_MATRIX_HEAD + subprocess.run(["git", "-C", str(pipeline), "diff", "--exit-code", "HEAD"], check=True) + inputs = pipeline / ".github/openclaw/qualification" + sys.path.insert(0, str(inputs)) + import consumer_identity as identity + return inputs, identity + + +def admit_current_matrix(pipeline, retained): + inputs, identity = current_matrix_policy(pipeline) + retained.mkdir(exist_ok=True) + assert not any(retained.iterdir()) + helper = inputs / "assemble-retained-matrix.py" + assert sha(helper) == "038627ababda81af7e34025b9fc9e54857aa94c3592f090f351fd3970b1a972b" + spec = importlib.util.spec_from_file_location("matrix_transport", helper) + transport = importlib.util.module_from_spec(spec) + spec.loader.exec_module(transport) + run, jobs = transport.run_identity(CURRENT_MATRIX_RUN, CURRENT_MATRIX_HEAD, "openclaw-artifacts.yml") + labels = {row["label"] for row in identity.CONFIG["lanes"]} + assert len(labels) == 21 and run["conclusion"] == "failure" + required = {"build (" + label + ")" for label in labels} | {"windows-arm64", "preflight"} + assert all(jobs[name]["conclusion"] == "success" and jobs[name]["run_attempt"] == 1 for name in required) + assert jobs["test"]["conclusion"] == "failure" + admitted = {label: transport.download(retained, label, row, CURRENT_MATRIX_RUN, CURRENT_MATRIX_HEAD) + for label, row in CURRENT_MATRIX_INPUTS.items()} + (retained / "current-matrix-admission.json").write_text(json.dumps({ + "run": CURRENT_MATRIX_RUN, "head": CURRENT_MATRIX_HEAD, + "successful_jobs": {name: jobs[name]["id"] for name in sorted(required)}, + "artifacts": admitted}, indent=2) + "\n") + + +def prepare_current_matrix(pipeline, carrier, retained, root, artifacts, inspector): + inputs, identity = current_matrix_policy(pipeline) + assert not (root / "current-matrix-reuse.json").exists() and not (root / "bun-baseline").exists() and not (root / "bun").exists() + admission = read(retained / "current-matrix-admission.json") + assert admission["run"] == CURRENT_MATRIX_RUN and admission["head"] == CURRENT_MATRIX_HEAD + proof, binaries = retained / "qualification", retained / "linux-bun-executables" + baseline = read(proof / "baseline-identity.json") + identity.validate_baseline_evidence(baseline, binaries, proof) + tools = read(proof / "baseline-build-tools.json") + assert Path(tools["cwd"]) == root / "bun-baseline" + assert inspector == Path(tools["bootstrap"]["path"]) and inspector.stat().st_size == tools["bootstrap"]["size"] and sha(inspector) == tools["bootstrap"]["sha256"] + assert not (proof / "baseline/invocation.json").exists() and not (proof / "candidate-identity.json").exists() + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), artifacts / (identity.LANE + ".manifest.json"), CURRENT_MATRIX_HEAD) + gate = read(proof / "engine-gate.json") + assert gate["passed"] is True and gate["source"] == CURRENT_MATRIX_HEAD + assert gate["stress_counts"]["jsc-stress"] == 1901 and gate["stress_counts"]["jsc-modules"] == 1639 + for name, count in gate["stress_counts"].items(): + lines = (proof / name / "results").read_text().splitlines() + assert len(lines) == count and all(line.endswith(": PASS") for line in lines) + reused = {} + for path in proof.rglob("*"): + if not path.is_file(): + continue + relative = path.relative_to(proof) + target = root / relative + assert not target.exists() + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(path, target) + reused[relative.as_posix()] = sha(path) + assert len(reused) == 67 + (root / "engine").mkdir() + subprocess.run(["tar", "-xzf", str(artifacts / (identity.LANE + ".tar.gz")), "-C", str(root / "engine")], check=True) + source = (pipeline / ".github/openclaw/qualify.sh").read_bytes() + source_sha = sha(pipeline / ".github/openclaw/qualify.sh") + source = expose_proxy(source) + build = b' python3 "$inputs/harness_adapters.py" build --name "$arm" --root "$QUALIFICATION_DIR" \\\n --inspector-runtime "$INSPECTOR_RUNTIME" --source "$SOURCE_SHA" --artifacts "$ARTIFACT_DIR"\n' + assert source.count(build) == 1 + source = source.replace(build, b' if test "$arm" = baseline; then\n install -D -m700 "${RETAINED_BASELINE_EXECUTABLE:?}" "$repo/build/qualify-baseline/bun"\n else\n' + build + b' fi\n') + capture = b' python3 "$inputs/consumer_identity.py" baseline --root "$QUALIFICATION_DIR" --inspector-runtime "$INSPECTOR_RUNTIME"\n' + assert source.count(capture) == 1 + verify = b''' PYTHONPATH="$inputs" python3 -c 'import json,sys;from pathlib import Path;from consumer_identity import capture_baseline;r=Path(sys.argv[1]);assert capture_baseline(r,Path(sys.argv[2]))==json.loads((r/"baseline-identity.json").read_text())' "$QUALIFICATION_DIR" "$INSPECTOR_RUNTIME" +''' + source = source.replace(capture, verify) + driver = root / "qualify-current-matrix.sh" + driver.write_bytes(source) + shutil.copyfile(retained / "current-matrix-admission.json", root / "current-matrix-admission.json") + record = {"run": CURRENT_MATRIX_RUN, "head": CURRENT_MATRIX_HEAD, + "reused_files": reused, "admission_sha256": sha(root / "current-matrix-admission.json"), + "baseline_build_reused": True, "baseline_tests_reused": False, + "candidate_build_reused": False, "candidate_tests_reused": False, + "engine_evidence_reused": True, "pipeline_driver_sha256": source_sha, + "driver_sha256": sha(driver), "controller_sha256": sha(Path(__file__)), + "carrier": subprocess.check_output(["git", "-C", str(carrier), "rev-parse", "HEAD"], text=True).strip(), + "reference_tools_sha256": sha(root / "reference-tools.json")} + (root / "current-matrix-reuse.json").write_text(json.dumps(record, indent=2) + "\n") + + +def seal_current_matrix(pipeline, carrier, root, artifacts, inspector): + inputs, identity = current_matrix_policy(pipeline) + record = read(root / "current-matrix-reuse.json") + assert record["run"] == CURRENT_MATRIX_RUN and record["head"] == CURRENT_MATRIX_HEAD + assert record["controller_sha256"] == sha(Path(__file__)) + assert record["carrier"] == subprocess.check_output(["git", "-C", str(carrier), "rev-parse", "HEAD"], text=True).strip() + assert record["driver_sha256"] == sha(root / "qualify-current-matrix.sh") + assert record["pipeline_driver_sha256"] == sha(pipeline / ".github/openclaw/qualify.sh") + assert record["admission_sha256"] == sha(root / "current-matrix-admission.json") + assert record["reference_tools_sha256"] == sha(root / "reference-tools.json") + for name, digest in record["reused_files"].items(): + assert sha(root / name) == digest, name + engine = identity.engine_input(artifacts / (identity.LANE + ".tar.gz"), artifacts / (identity.LANE + ".manifest.json"), CURRENT_MATRIX_HEAD) + identity.verify(root, engine, root / "candidate-identity.json", inspector) + for arm in ("baseline", "candidate"): + identity.validate_invocation(root, arm) + assert identity.capture_baseline(root, inspector) == read(root / "baseline-identity.json") + gate = read(root / "gate.json") + assert gate["passed"] is True and gate["source"] == CURRENT_MATRIX_HEAD + assert gate["upstream_sync"] == read(root / "sync-gate.json") and gate["compatibility"] == read(root / "compatibility-gate.json") + (root / "current-matrix-complete.json").write_text(json.dumps({"passed": True, + "source": CURRENT_MATRIX_HEAD, "reuse_sha256": sha(root / "current-matrix-reuse.json"), + "gate_sha256": sha(root / "gate.json"), "candidate_identity_sha256": sha(root / "candidate-identity.json")}, indent=2) + "\n") + + if __name__ == "__main__": - if sys.argv[1] == "replay-matrix": + if sys.argv[1] == "admit-current-matrix": + admit_current_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) + elif sys.argv[1] == "prepare-current-matrix": + prepare_current_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) + elif sys.argv[1] == "seal-current-matrix": + seal_current_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) + elif sys.argv[1] == "replay-matrix": replay_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) elif sys.argv[1] == "seal-matrix": seal_matrix(*[Path(p).resolve() for p in sys.argv[2:]]) diff --git a/.github/openclaw/qualify.sh b/.github/openclaw/qualify.sh index e78a3ea6a5a28..d78def1881763 100644 --- a/.github/openclaw/qualify.sh +++ b/.github/openclaw/qualify.sh @@ -81,7 +81,7 @@ unset BUN_WEBKIT_ARTIFACT_MANIFEST BUN_BUILD_CACHE_DIR BUN_BUILD_PREFETCH_DIR "$candidate" test test/js/bun/resolve/esModule.test.ts test/js/bun/namespace-prototype-pollution.test.ts test/js/bun/resolve/require-esm-evaluating-cycle.test.ts test/js/bun/import-attributes/import-attributes.test.ts test/js/node/module/require-extensions.test.ts > "$QUALIFICATION_DIR/namespace.log" 2>&1 "$candidate" test --expose-internals test/js/node/v8/capture-stack-trace.test.js test/js/bun/sourcemap/internal-sourcemap.test.ts > "$QUALIFICATION_DIR/stack-positions.log" 2>&1 "$candidate" "$inputs/segmenter.js" > "$QUALIFICATION_DIR/segmenter.log" 2>&1 -"$candidate" test test/js/node/vm/vm.test.ts -t 'a Proxy in the prototype chain' > "$QUALIFICATION_DIR/proxy.log" 2>&1 +"$candidate" test --expose-internals test/js/node/vm/vm.test.ts -t 'a Proxy in the prototype chain' > "$QUALIFICATION_DIR/proxy.log" 2>&1 "$candidate" test test/js/node/process/process.test.js -t 'ArrayBuffer memory ownership' > "$QUALIFICATION_DIR/arraybuffer.log" 2>&1 "$candidate" test test/js/node/worker_threads/worker_threads.test.ts -t 'getHeapStatistics' > "$QUALIFICATION_DIR/worker-statistics.log" 2>&1 "$candidate" test test/js/node/worker_threads/openclaw-resource-limits.test.ts -t 'resourceLimits' > "$QUALIFICATION_DIR/resource-limits.log" 2>&1 diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index 335f95fa14a91..d94bb90b29e14 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -58,3 +58,5 @@ Rollback by restoring the prior Bun manifest and WebKit pin together, then rebui Consumer comparison and assembly use the same raw-evidence validator. The policy permits baseline unreported suites only after a normally completed failing group with a nonempty valid report. It rejects candidate gaps, malformed or contradictory evidence, cancellation, deadlines, signals, spawn failures and canonical fatal outcomes on either arm. Baseline failed and unreported lists are retained; optional per-file process metadata is never fabricated. This policy does not resolve the historical grouped baseline defect or establish first-attempt equivalence. Fixed tooling adapters do not change the frozen compile pins, and these source changes are not fresh native qualification. The completed historical ten-lane qualification is bound to engine `42e4245f4180941634b482a7e8ef7fca47467de5`, consumer replay41294955235 and assembly41296642691. Historical continuation uses immutable controls `5e586e4ce8bd9f3f3703af98983f7f13fb58c242`; it does not qualify the combined21-lane production configuration or authorize publication. + +Linux qualification now binds the historical and candidate Node references explicitly. A fixed-run continuation reuses admitted current-matrix engine and baseline builds while running baseline and candidate tests fresh. diff --git a/.github/workflows/openclaw-artifacts.yml b/.github/workflows/openclaw-artifacts.yml index 4ccd2499c6de3..e067eb088665c 100644 --- a/.github/workflows/openclaw-artifacts.yml +++ b/.github/workflows/openclaw-artifacts.yml @@ -120,9 +120,20 @@ jobs: /JSTests/modules/ /JSTests/*.yaml /JSTests/BUN-TEST-DIFFERENCES.md + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.3.0' + - name: Bind the historical Node reference + run: | + test "$(node --version)" = v26.3.0 + echo "BASELINE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: node-version: '26.12.1' + - name: Bind the candidate Node reference + run: | + test "$(node --version)" = v26.12.1 + echo "CANDIDATE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" - uses: actions/download-artifact@3e5f45b2cfb9172054b4087a40e8e0b5a5461e7c with: name: bun-webkit-linux-amd64 diff --git a/.github/workflows/openclaw-current-matrix-consumer.yml b/.github/workflows/openclaw-current-matrix-consumer.yml new file mode 100644 index 0000000000000..33c635842779f --- /dev/null +++ b/.github/workflows/openclaw-current-matrix-consumer.yml @@ -0,0 +1,153 @@ +name: OpenClaw current matrix consumer continuation + +on: + push: + branches: [claude/hosted-linux-consumer-20261031] + paths: + - .github/workflows/openclaw-current-matrix-consumer.yml + - .github/openclaw/qualification/resume-consumer.py + workflow_dispatch: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-current-matrix-consumer-${{ github.ref }} + cancel-in-progress: true + +env: + CI: '1' + PUPPETEER_SKIP_DOWNLOAD: '1' + +jobs: + matrix-consumer: + runs-on: blacksmith-32vcpu-ubuntu-2404 + timeout-minutes: 120 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 4430cc2e4caa5720c2f78963be3566c87b958084 + path: pipeline + persist-credentials: false + sparse-checkout: | + .github/openclaw + Source/JavaScriptCore + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: ${{ github.sha }} + path: carrier + persist-credentials: false + sparse-checkout: .github/openclaw + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.3.0' + - name: Bind the historical Node reference + run: | + test "$(node --version)" = v26.3.0 + echo "BASELINE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" + - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 + with: + node-version: '26.12.1' + - name: Bind the candidate Node reference and workspace + run: | + test "$(node --version)" = v26.12.1 + echo "CANDIDATE_REFERENCE_NODE=$(realpath "$(command -v node)")" >> "$GITHUB_ENV" + echo "QUALIFICATION_DIR=$RUNNER_TEMP/qualification" >> "$GITHUB_ENV" + echo "ARTIFACT_DIR=$RUNNER_TEMP/retained/bun-webkit-linux-amd64" >> "$GITHUB_ENV" + mkdir "$RUNNER_TEMP/qualification" "$RUNNER_TEMP/retained" + - name: Install the existing pinned candidate build tools + run: | + curl -fsSL --retry 5 https://apt.llvm.org/llvm-snapshot.gpg.key | sudo tee /etc/apt/trusted.gpg.d/apt.llvm.org.asc > /dev/null + echo 'deb https://apt.llvm.org/noble/ llvm-toolchain-noble-23 main' | sudo tee /etc/apt/sources.list.d/llvm.list + sudo apt-get update -qq + sudo apt-get install -y --no-install-recommends cmake ninja-build nasm ccache golang-go clang-23 lld-23 llvm-23 unzip ruby ruby-highline libjson-pp-perl + rustup toolchain install nightly-2026-09-15 --profile minimal --component rust-src + echo 'RUSTUP_TOOLCHAIN=nightly-2026-09-15' >> "$GITHUB_ENV" + echo '/usr/lib/llvm-23/bin' >> "$GITHUB_PATH" + curl -fSL --retry 5 https://github.com/oven-sh/bun/releases/download/bun-v1.4.2/bun-linux-x64.zip -o "$RUNNER_TEMP/bootstrap.zip" + unzip -q "$RUNNER_TEMP/bootstrap.zip" -d "$RUNNER_TEMP/bootstrap" + echo "INSPECTOR_RUNTIME=$RUNNER_TEMP/bootstrap/bun-linux-x64/bun" >> "$GITHUB_ENV" + - name: Admit the fixed matrix run and retained build artifacts + env: + GH_TOKEN: ${{ github.token }} + run: python3 carrier/.github/openclaw/qualification/resume-consumer.py admit-current-matrix "$GITHUB_WORKSPACE/pipeline" "$RUNNER_TEMP/retained" + - name: Record the exact reference tools + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 - <<'PY' + import hashlib, json, os, subprocess + from pathlib import Path + def sha(path): + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() + bootstrap = Path(os.environ['INSPECTOR_RUNTIME']).resolve() + assert bootstrap.stat().st_size == 79500640 and sha(bootstrap) == 'a83d263767d839e4d2649ca8e35d07159c7afc99afdc96d731ced29e056dda0c' + with Path(os.environ['GITHUB_PATH']).open('a') as path: + path.write(str(bootstrap.parent) + '\n') + references = {} + for arm, key, version in [('baseline', 'BASELINE_REFERENCE_NODE', 'v26.3.0'), ('candidate', 'CANDIDATE_REFERENCE_NODE', 'v26.12.1')]: + executable = Path(os.environ[key]).resolve(strict=True) + actual = subprocess.check_output([str(executable), '--version'], text=True).strip() + assert actual == version + references[arm] = {'path': str(executable), 'version': actual, 'size': executable.stat().st_size, 'sha256': sha(executable)} + references['carrier'] = subprocess.check_output(['git', '-C', 'carrier', 'rev-parse', 'HEAD'], text=True).strip() + references['pipeline'] = subprocess.check_output(['git', '-C', 'pipeline', 'rev-parse', 'HEAD'], text=True).strip() + Path(os.environ['QUALIFICATION_DIR'], 'reference-tools.json').write_text(json.dumps(references, indent=2) + '\n') + PY + - name: Run fresh baseline tests and the exact current candidate gates + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + python3 carrier/.github/openclaw/qualification/resume-consumer.py prepare-current-matrix \ + "$GITHUB_WORKSPACE/pipeline" "$GITHUB_WORKSPACE/carrier" "$RUNNER_TEMP/retained" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$INSPECTOR_RUNTIME" + export RETAINED_BASELINE_EXECUTABLE="$RUNNER_TEMP/retained/linux-bun-executables/bun-baseline/build/qualify-baseline/bun" + cd pipeline + bash "$QUALIFICATION_DIR/qualify-current-matrix.sh" + export CANDIDATE_BUN="$QUALIFICATION_DIR/bun/build/qualify-candidate/bun" + export CANDIDATE_RECEIPT="$QUALIFICATION_DIR/candidate-identity.json" + bash .github/openclaw/qualify-sync-compatibility.sh + bash .github/openclaw/qualify-sync.sh + cd "$GITHUB_WORKSPACE" + python3 carrier/.github/openclaw/qualification/resume-consumer.py seal-current-matrix "$GITHUB_WORKSPACE/pipeline" "$GITHUB_WORKSPACE/carrier" "$QUALIFICATION_DIR" "$ARTIFACT_DIR" "$INSPECTOR_RUNTIME" + - name: Retain executables and their matching allocator object + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: current-matrix-linux-bun-executables + path: | + ${{ runner.temp }}/qualification/bun-baseline/build/qualify-baseline/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/bun + ${{ runner.temp }}/qualification/bun/build/qualify-candidate/obj/vendor/mimalloc/src/static.c.o + ${{ runner.temp }}/qualification/bun/test/js/node/worker_threads/openclaw-resource-limits.test.ts + ${{ runner.temp }}/qualification/*.sha256 + compression-level: 0 + retention-days: 3 + if-no-files-found: warn + - name: Retain current and reused proof with their original identities + if: always() + uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: current-matrix-linux-consumer-proof + path: | + ${{ runner.temp }}/qualification/*.json + ${{ runner.temp }}/qualification/*.log + ${{ runner.temp }}/qualification/*.sha256 + ${{ runner.temp }}/qualification/*.patch + ${{ runner.temp }}/qualification/qualify-current-matrix.sh + ${{ runner.temp }}/qualification/candidate-input/artifacts.json + ${{ runner.temp }}/qualification/baseline/*.json + ${{ runner.temp }}/qualification/baseline/*.log + ${{ runner.temp }}/qualification/candidate/*.json + ${{ runner.temp }}/qualification/candidate/*.log + ${{ runner.temp }}/qualification/compatibility/*.log + ${{ runner.temp }}/qualification/sync/*.json + ${{ runner.temp }}/qualification/sync/*.xml + ${{ runner.temp }}/qualification/sync/*.log + ${{ runner.temp }}/qualification/sync/runtime-cache/*.json + ${{ runner.temp }}/qualification/jsc-*/results + ${{ runner.temp }}/qualification/jsc-stack/*.log + ${{ runner.temp }}/qualification/jsc-stack/*.json + retention-days: 7 + if-no-files-found: error From a092d48b92418d90edeb8bbef734f56bceb7c486 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:49:16 +0800 Subject: [PATCH 26/35] fix(ci): assemble the retained current 21-lane matrix --- .../qualification/assemble-retained-matrix.py | 75 ++++++++++++++++++- .github/openclaw/release-notes.md | 2 + .../openclaw-current-matrix-assembly.yml | 63 ++++++++++++++++ 3 files changed, 137 insertions(+), 3 deletions(-) create mode 100644 .github/workflows/openclaw-current-matrix-assembly.yml diff --git a/.github/openclaw/qualification/assemble-retained-matrix.py b/.github/openclaw/qualification/assemble-retained-matrix.py index fc4f801006cc6..23d88e9e66626 100644 --- a/.github/openclaw/qualification/assemble-retained-matrix.py +++ b/.github/openclaw/qualification/assemble-retained-matrix.py @@ -50,6 +50,16 @@ 'sha256:c263cbb260585a610e0c1670cab7530b0efe3e694c3598fde845a50e5795a1a2']} + +CURRENT_SOURCE = "4430cc2e4caa5720c2f78963be3566c87b958084" +CURRENT_BUILD_RUN = 41330085617 +CURRENT_REPLAY_RUN = 41367738580 +CURRENT_REPLAY_HEAD = "b1b043eab568e09d22aed763db4ccdbfabdda209" +CURRENT_ARTIFACTS = {'windows-arm64-qualification': [13100526385, 1030, 'sha256:e5a1023b3eee615fd425fa9ff0240651756ed5cd49c6f306bfb1faba0bf16d81'], 'bun-webkit-linux-amd64-debug-asan-aot': [13100491403, 1502877343, 'sha256:b42b231c1f93d915fdf2a264cf98c6b5ab72ca557d43913c500b1a817db0ee84'], 'bun-webkit-windows-amd64-lto-aot': [13099053509, 1167505439, 'sha256:d035131aef9997860f5a926833a8cc901738229c714dd31f91a1ec2864d4b34e'], 'bun-webkit-windows-arm64-aot': [13098919990, 509526074, 'sha256:744e004317674127a9df90ec96bac1f91f78a671ab2c0cf73d2fafda45973bcb'], 'bun-webkit-linux-amd64-musl-lto-aot': [13098637413, 460629779, 'sha256:41b99d250cc703f3f577d5e5d87526bbe19fe1a661cabfc4f10ac5e36b616102'], 'bun-webkit-macos-amd64-lto-aot': [13098130771, 367154425, 'sha256:b4d52c5cd93a22b38440864e06a73516a190f2c959289009f0a9c4741f4a0976'], 'bun-webkit-linux-arm64-musl-lto-aot': [13097684412, 360823888, 'sha256:4276ae47b5d02c375a645de81b12cd2ce6b6f63fc30b67c97e7a8f8d10b57866'], 'bun-webkit-linux-amd64-lto-aot': [13097301126, 809941034, 'sha256:99c264399fbccb9ec29c8dbcee91f4788d6d32d870bd13b9de2398c56d1cca5d'], 'bun-webkit-macos-arm64-lto-aot': [13096634579, 365308705, 'sha256:b1d3901fa6eebf599353eb2cce8edec015de49b41eb2a0c598f1cf5f94e1e5ea'], 'bun-webkit-linux-amd64-aot': [13096122278, 1286964541, 'sha256:e2ab6664f6f7018cd482a685eb17cd85afc1398a77d994b5cd0b176a72406c88'], 'bun-webkit-linux-arm64-lto-aot': [13096089459, 673116454, 'sha256:0384ee939b0de577b9af68159b0a8cd64a72fe6847faaa5e859d265b4e41200a'], 'bun-webkit-macos-arm64-aot': [13096006955, 517796721, 'sha256:de9fdeb0bd2f01761fe3be01c2781fc8eec6880a1f63cc806c769095ff260d3a'], 'bun-webkit-windows-amd64-lto': [13095457134, 576373143, 'sha256:4ecf261352922636c098a3b1c18a155273ecc6b8f037f0e4c9a440db38e0aa23'], 'bun-webkit-linux-arm64-musl-lto': [13095256139, 195528802, 'sha256:cc3848bdf9d59d827beaf0beb8d0aadd0d24b9aec8e659da430b8b52c439203e'], 'bun-webkit-linux-amd64-musl-lto': [13095145789, 286895594, 'sha256:7e81bf573529f208ed825f7263d963f53f10e85120ddaf93acb5d43b50dd42cc'], 'bun-webkit-macos-amd64-lto': [13094590399, 186203947, 'sha256:cee63035ac330f8194b20890981427836862cb7642a60719bd02f3bfefdb370d'], 'bun-webkit-windows-arm64': [13094578632, 262415745, 'sha256:416c7002cd2785cfa56264adf95f284d1bbb39f7ae325b8dc1a5a4f37c9d41bd'], 'bun-webkit-linux-arm64-lto': [13093674197, 270916785, 'sha256:9a79d225e19e82926b8b4b85dbfdf3af1e0efae4725fbb767af37cc6b5b38f59'], 'bun-webkit-linux-amd64': [13093547315, 716162784, 'sha256:cf8da5e9e6b7dda9733ef9479e116df621470b3fa02cafd88f1711aa5e4734be'], 'bun-webkit-linux-amd64-lto': [13093273208, 392276872, 'sha256:baeac1a0d61b75c09c55d35d4d0a1ec4deefc37e2694cc2fb42d8fb7130f1f52'], 'bun-webkit-macos-arm64': [13093236334, 231948605, 'sha256:16e9962e7d58dbe747fc6e3fb07f87f8d377d91a427fecd59705add37c521042'], 'bun-webkit-macos-arm64-lto': [13093064757, 181681295, 'sha256:1eb059504f5c0efa9888f0b85137722ce165dcedba352c775d24a8fb603922c8']} +CURRENT_REUSED_FILES = {'accounting-baseline.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'accounting-concurrent.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'accounting-dfg.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'accounting-ftl.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'accounting-interpreter.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'baseline-adapters.patch': 'f71aad14e31d2dbd84178827362721fd486aeb0f11764cd9b39c9353af171e5a', 'baseline-build-tools.json': '5da6181f23deee8cedb8e9a3d53e64351bbe050d56fcf4d6939c983e80bfb0d6', 'baseline-identity.json': '1be4f57cb699a7465b4dd30e3d697b3e727d905773fd5a93664064a63d69b1f8', 'build-baseline.log': 'ff09be1932d5f4de6f3fc301067443e380b36ec2742d4e19d83f3337db2e3615', 'bun-baseline.sha256': 'd1084bf9aafaa4dfec1e8ccb488c5cd2e7433ee35cc15b7332f97ad7320f1163', 'engine-gate.json': '962f28f87c91a0b7a9008f9272ee84b6f52f8886fa834ed9f188f525f56ef099', 'jsc-context.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-modules/results': 'f8642f15db9d5374d7573d84d8ff14a7054b52cdd6617cf7c90e0984eb4a67b8', 'jsc-modules.log': 'ec8b45a9e3c9e2f28c86dbcca4393cb9bf37f43d185b2992dbf4ae998634c24d', 'jsc-stack/baseline-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/baseline-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/baseline-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/baseline-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-files.json': '73440853a5503fe67fa54c9197f8a0f02bbb87c6a3ea2024e170e8d7783365eb', 'jsc-stack/cache-owned-cold-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-cold-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-cold-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-cold-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-warm-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-warm-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-warm-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-owned-warm-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-cold-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-cold-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-cold-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-cold-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-warm-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-warm-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-warm-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/cache-persistent-warm-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/concurrent-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/concurrent-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/concurrent-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/concurrent-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/default-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/default-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/default-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/default-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/dfg-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/dfg-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/dfg-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/dfg-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/eager-ftl-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/eager-ftl-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/eager-ftl-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/eager-ftl-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/interpreter-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/interpreter-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/interpreter-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/interpreter-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/optimizer-callsite-async-position.mjs.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/optimizer-callsite-syntax-positions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/optimizer-stack-position-regressions-cache.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stack/optimizer-stack-position-regressions.js.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'jsc-stress/results': 'b873a5f035cd72211c72b2f5ffe4419cd93e1c014e4ec52b570e53bb151fcdea', 'jsc-stress.log': '5a20f58f45d1e0c304a7a51c56e2d25f668c0992fb81537047ed961b53210750', 'sampling-baseline.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'sampling-default.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'sampling-ftl.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'sampling-interpreter.log': 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855', 'stack-visitor.log': 'd306d58b17e3fd865b753d29b76016c20d079ef3f1bd0a7684f97106e2fcb3b3', 'vm-test-baseline.sha256': '55a16d8f7dc191c830c6520b90eeee02af36cee97dc58b3ae972a96e9dd559d6'} +CURRENT_CONTROLLER_SHA256 = '662568bfe12cea4a5d723720a36a5d659b5e4bc07196fe1d9b21cea8ebc775f5' + + def api(route): return json.loads(subprocess.check_output(["gh", "api", REPO + route])) @@ -72,9 +82,10 @@ def run_identity(run_id, head, workflow): return run, {job["name"]: job for job in jobs} -def download(root, label, row, run_id, head): +def download(root, label, row, run_id, head, *, max_archive_bytes=1024**3): artifact_id, size, digest = row - assert re.fullmatch(r"sha256:[0-9a-f]{64}", digest) and 0 < size <= 1024**3 + assert 0 < max_archive_bytes <= 2 * 1024**3 + assert re.fullmatch(r"sha256:[0-9a-f]{64}", digest) and 0 < size <= max_archive_bytes metadata = api(f"actions/artifacts/{artifact_id}") assert metadata["id"] == artifact_id and metadata["name"] == label and not metadata["expired"] assert metadata["size_in_bytes"] == size and metadata["digest"] == digest @@ -147,5 +158,63 @@ def main(root): "replay_run": REPLAY_RUN, "artifacts": admitted}, indent=2) + "\n") + +def current21(root, pipeline): + assert subprocess.check_output(["git", "-C", str(pipeline), "rev-parse", "HEAD"], text=True).strip() == CURRENT_SOURCE + subprocess.run(["git", "-C", str(pipeline), "diff", "--exit-code", "HEAD"], check=True) + config = read(pipeline / ".github/openclaw/variants.json") + labels = {lane["label"] for lane in config["lanes"]} + assert len(labels) == 21 and set(CURRENT_ARTIFACTS) == labels | {"windows-arm64-qualification"} + root.mkdir() + # Retain one extracted input set and one assembled copy; ZIPs are removed per lane. + assert shutil.disk_usage(root).free >= 32 * 1024**3 + build, jobs = run_identity(CURRENT_BUILD_RUN, CURRENT_SOURCE, "openclaw-artifacts.yml") + assert build["conclusion"] == "failure" + required = {"build (" + label + ")" for label in labels} | {"windows-arm64", "preflight"} + assert all(jobs[name]["conclusion"] == "success" and jobs[name]["run_attempt"] == 1 for name in required) + assert jobs["test"]["conclusion"] == "failure" + replay, replay_jobs = run_identity(CURRENT_REPLAY_RUN, CURRENT_REPLAY_HEAD, "openclaw-current-matrix-consumer.yml") + assert replay["conclusion"] == "success" + assert set(replay_jobs) == {"matrix-consumer"} + assert replay_jobs["matrix-consumer"]["conclusion"] == "success" and replay_jobs["matrix-consumer"]["run_attempt"] == 1 + artifacts = api(f"actions/runs/{CURRENT_REPLAY_RUN}/artifacts?per_page=100")["artifacts"] + admitted = [] + for label in ("current-matrix-linux-consumer-proof", "current-matrix-linux-bun-executables"): + matches = [item for item in artifacts if item["name"] == label] + assert len(matches) == 1 + item = matches[0] + assert item["size_in_bytes"] <= (8 * 1024**2 if label.endswith("proof") else 512 * 1024**2) + admitted.append(download(root, label, [item["id"], item["size_in_bytes"], item["digest"]], CURRENT_REPLAY_RUN, CURRENT_REPLAY_HEAD)) + proof = root / "current-matrix-linux-consumer-proof" + record, complete = read(proof / "current-matrix-reuse.json"), read(proof / "current-matrix-complete.json") + assert record["run"] == CURRENT_BUILD_RUN and record["head"] == CURRENT_SOURCE and record["carrier"] == CURRENT_REPLAY_HEAD + assert record["baseline_build_reused"] is True and record["engine_evidence_reused"] is True + assert all(record[key] is False for key in ("baseline_tests_reused", "candidate_build_reused", "candidate_tests_reused")) + assert record["controller_sha256"] == CURRENT_CONTROLLER_SHA256 + assert record["pipeline_driver_sha256"] == sha(pipeline / ".github/openclaw/qualify.sh") + assert record["driver_sha256"] == sha(proof / "qualify-current-matrix.sh") + assert record["reference_tools_sha256"] == sha(proof / "reference-tools.json") + assert record["admission_sha256"] == sha(proof / "current-matrix-admission.json") + assert record["reused_files"] == CURRENT_REUSED_FILES + for name, digest in CURRENT_REUSED_FILES.items(): + assert sha(proof / name) == digest, name + admission = read(proof / "current-matrix-admission.json") + assert admission["run"] == CURRENT_BUILD_RUN and admission["head"] == CURRENT_SOURCE + assert complete["passed"] is True and complete["source"] == CURRENT_SOURCE + assert complete["reuse_sha256"] == sha(proof / "current-matrix-reuse.json") + assert complete["gate_sha256"] == sha(proof / "gate.json") + assert complete["candidate_identity_sha256"] == sha(proof / "candidate-identity.json") + (root / "current-matrix-linux-consumer-proof").rename(root / "qualification") + (root / "current-matrix-linux-bun-executables").rename(root / "linux-bun-executables") + for label, row in CURRENT_ARTIFACTS.items(): + admitted.append(download(root, label, row, CURRENT_BUILD_RUN, CURRENT_SOURCE, max_archive_bytes=2 * 1024**3)) + (root / "assembly-inputs.json").write_text(json.dumps({"source": CURRENT_SOURCE, + "build_run": CURRENT_BUILD_RUN, "replay_run": CURRENT_REPLAY_RUN, + "replay_head": CURRENT_REPLAY_HEAD, "successful_build_jobs": {name: jobs[name]["id"] for name in sorted(required)}, + "artifacts": admitted}, indent=2) + "\n") + if __name__ == "__main__": - main(Path(sys.argv[1]).resolve()) + if len(sys.argv) == 4 and sys.argv[1] == "current21": + current21(Path(sys.argv[2]).resolve(), Path(sys.argv[3]).resolve()) + else: + main(Path(sys.argv[1]).resolve()) diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index d94bb90b29e14..44eb28023d71f 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -60,3 +60,5 @@ Consumer comparison and assembly use the same raw-evidence validator. The policy The completed historical ten-lane qualification is bound to engine `42e4245f4180941634b482a7e8ef7fca47467de5`, consumer replay41294955235 and assembly41296642691. Historical continuation uses immutable controls `5e586e4ce8bd9f3f3703af98983f7f13fb58c242`; it does not qualify the combined21-lane production configuration or authorize publication. Linux qualification now binds the historical and candidate Node references explicitly. A fixed-run continuation reuses admitted current-matrix engine and baseline builds while running baseline and candidate tests fresh. + +The current 21-lane qualification can assemble the retained build artifacts with a separately admitted fresh Linux consumer proof. The fixed-run continuation keeps the original build and proof identities, verifies all 22 archives through the existing assembly owner, and does not publish a release or update consumer pins. Historical ten-lane assembly retains its original admission limits. diff --git a/.github/workflows/openclaw-current-matrix-assembly.yml b/.github/workflows/openclaw-current-matrix-assembly.yml new file mode 100644 index 0000000000000..093e1d2b4244a --- /dev/null +++ b/.github/workflows/openclaw-current-matrix-assembly.yml @@ -0,0 +1,63 @@ +name: OpenClaw current retained matrix assembly + +on: + workflow_dispatch: + workflow_call: + +permissions: + contents: read + actions: read + +concurrency: + group: openclaw-current-retained-matrix-41330085617 + cancel-in-progress: false + +jobs: + assemble: + runs-on: blacksmith-4vcpu-ubuntu-2404 + timeout-minutes: 60 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 4430cc2e4caa5720c2f78963be3566c87b958084 + path: pipeline + persist-credentials: false + sparse-checkout-cone-mode: false + sparse-checkout: | + .github + Source/JavaScriptCore/COPYING.LIB + Source/WTF/wtf/COPYING.LIB + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: ${{ github.sha }} + path: carrier + persist-credentials: false + sparse-checkout: .github/openclaw + - name: Admit the completed 21 builds and exact fresh Linux proof + env: + GH_TOKEN: ${{ github.token }} + run: python3 carrier/.github/openclaw/qualification/assemble-retained-matrix.py current21 "$RUNNER_TEMP/inputs" "$GITHUB_WORKSPACE/pipeline" + - name: Assemble and verify all 22 immutable archives + run: | + set -euo pipefail + unset GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + cd pipeline + python3 .github/openclaw/release.py assemble --source 4430cc2e4caa5720c2f78963be3566c87b958084 --inputs "$RUNNER_TEMP/inputs" --directory "$RUNNER_TEMP/assembled" + python3 .github/openclaw/release.py verify --source 4430cc2e4caa5720c2f78963be3566c87b958084 --directory "$RUNNER_TEMP/assembled" + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + with: + name: current-retained-matrix-assembly + path: ${{ runner.temp }}/assembled + compression-level: 0 + if-no-files-found: error + retention-days: 7 + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + if: always() + with: + name: current-retained-matrix-assembly-receipts + path: | + ${{ runner.temp }}/inputs/assembly-inputs.json + ${{ runner.temp }}/assembled/manifest.json + ${{ runner.temp }}/assembled/SHA256SUMS + if-no-files-found: warn + retention-days: 7 From 4440efe45cd2dd02836f67c9914923b03a4ba2ad Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 08:54:36 +0800 Subject: [PATCH 27/35] fix(ci): register the retained matrix assembly trigger --- .github/workflows/openclaw-current-matrix-assembly.yml | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.github/workflows/openclaw-current-matrix-assembly.yml b/.github/workflows/openclaw-current-matrix-assembly.yml index 093e1d2b4244a..77a28fddf29a7 100644 --- a/.github/workflows/openclaw-current-matrix-assembly.yml +++ b/.github/workflows/openclaw-current-matrix-assembly.yml @@ -1,6 +1,9 @@ name: OpenClaw current retained matrix assembly on: + push: + branches: [claude/hosted-linux-consumer-20261031] + paths: [.github/workflows/openclaw-current-matrix-assembly.yml] workflow_dispatch: workflow_call: From a807c74e1a24aae28f51fe0183222ab18ba38dd6 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 09:02:40 +0800 Subject: [PATCH 28/35] test(ci): prove the current ordinary VM cache in Debug --- .../qualification/debug-vm-consumer.py | 136 ++++++++++++++++++ .../candidate-debug-local-build.patch | 19 +++ .github/openclaw/release-notes.md | 2 + .../workflows/openclaw-current-vm-debug.yml | 136 ++++++++++++++++++ 4 files changed, 293 insertions(+) create mode 100644 .github/openclaw/qualification/debug-vm-consumer.py create mode 100644 .github/openclaw/qualification/harness-adapters/candidate-debug-local-build.patch create mode 100644 .github/workflows/openclaw-current-vm-debug.yml diff --git a/.github/openclaw/qualification/debug-vm-consumer.py b/.github/openclaw/qualification/debug-vm-consumer.py new file mode 100644 index 0000000000000..cbe8398e733b9 --- /dev/null +++ b/.github/openclaw/qualification/debug-vm-consumer.py @@ -0,0 +1,136 @@ +"""Bind the ordinary consumer source and real VM debug pre-push evidence.""" +import hashlib +import json +from pathlib import Path +import stat +import shlex +import subprocess +import sys +from xml.etree import ElementTree + +SOURCE = Path('/work/source') +ENGINE = Path('/work/engine') +OUT = Path('/work/vm-debug-proof') +CONTROLS = Path(__file__).resolve().parent +BUN = 'd9be087429c21e563bb5ac29f8a11805e64b56a3' +TREE = '980068aa5aa9f51f40fc4125114a68fccd9bc9dc' +WEBKIT = '4430cc2e4caa5720c2f78963be3566c87b958084' + + +def sha(path): + with path.open('rb') as stream: + return hashlib.file_digest(stream, 'sha256').hexdigest() + + +def git(repo, *args): + return subprocess.check_output(['git', '-C', str(repo), *args], text=True).strip() + + +def state(files, adapted): + assert git(SOURCE, 'rev-parse', 'HEAD', 'HEAD^{tree}').splitlines() == [BUN, TREE] + assert git(SOURCE, 'write-tree') == TREE + assert git(ENGINE, 'rev-parse', 'HEAD') == WEBKIT + assert not git(ENGINE, 'status', '--porcelain') + changed = set(git(SOURCE, 'diff', '--name-only', 'HEAD').splitlines()) + changed.update(git(SOURCE, 'ls-files', '--others', '--exclude-standard').splitlines()) + assert changed == (set(files) if adapted else set()) + for name, row in files.items(): + path = SOURCE / name + assert path.is_file() and not path.is_symlink() + assert sha(path) == row['after' if adapted else 'before'], name + assert stat.S_IMODE(path.stat().st_mode) == int(row['mode'], 8) & 0o777, name + assert git(SOURCE, 'hash-object', '--', name) == row['adapted_blob' if adapted else 'base_blob'], name + + +def main(mode): + adapter = CONTROLS / 'harness-adapters.json' + assert sha(adapter) == '0359c6c59e00cf85022dffa283f5631a1ed2ad6b0363fc9e3fbca23f5c0fdd11' + candidate = json.loads(adapter.read_text())['arms']['candidate'] + assert candidate['pin'] == BUN + files = {} + controls = {'harness-adapters.json': sha(adapter), 'debug-vm-consumer.py': sha(Path(__file__))} + for phase in ('build', 'current_test'): + spec = candidate[phase] + assert not set(files).intersection(spec['files']) + files.update(spec['files']) + assert sha(CONTROLS / spec['patch']) == spec['sha256'] + controls[spec['patch']] = spec['sha256'] + files['scripts/build/deps/webkit.ts'] = {'before': '6d9cbc1eda6cea88b185d1956a5947f2ed682ed09ff501617d64c869f3a12af7', 'after': 'ff61c61e17ead2dd9f8c5bb3b557e83b7df41e2f65080c28239b2df384cff622', 'base_blob': '0b631209150b8c2eb7c5020e0c5f0b1e598a3ef7', 'adapted_blob': '8be8d3de7c95c4f151aa07e6715d1785b79f952e', 'mode': '100644'} + controls['harness-adapters/candidate-debug-local-build.patch'] = '8afbba5559780cb1c797b6ae095c1586684b2217ebe860adb56b6349ffefb204' + assert sha(CONTROLS / 'harness-adapters/candidate-debug-local-build.patch') == controls['harness-adapters/candidate-debug-local-build.patch'] + assert len(files) == 22 + OUT.mkdir(exist_ok=True) + if mode == 'prepare': + assert not (OUT / 'proof.json').exists() + state(files, False) + for phase in ('build', 'current_test'): + patch = str(CONTROLS / candidate[phase]['patch']) + subprocess.run(['git', '-C', str(SOURCE), 'apply', '--check', patch], check=True) + subprocess.run(['git', '-C', str(SOURCE), 'apply', patch], check=True) + local_patch = str(CONTROLS / 'harness-adapters/candidate-debug-local-build.patch') + subprocess.run(["git", "-C", str(SOURCE), "apply", "--check", local_patch], check=True) + subprocess.run(["git", "-C", str(SOURCE), "apply", local_patch], check=True) + state(files, True) + tools = {name: subprocess.check_output(command, text=True).strip() + for name, command in {'bun': ['bun', '--version'], 'rust': ['rustc', '--version'], + 'clang': ['clang', '--version']}.items()} + (OUT / 'proof.json').write_text(json.dumps({'passed': False, 'mode': 'vm-debug-prepush', + 'bun': BUN, 'tree': TREE, 'webkit': WEBKIT, 'files': files, 'controls': controls, + 'tools': tools}, indent=2) + '\n') + else: + assert mode == 'verify' + proof = json.loads((OUT / 'proof.json').read_text()) + assert proof['passed'] is False and proof['files'] == files and proof['controls'] == controls + state(files, True) + xml = OUT / 'vm-junit.xml' + cases = list(ElementTree.parse(xml).iter('testcase')) + assert cases and all(not any(case.find(tag) is not None for tag in ('failure', 'error')) for case in cases) + targets = [case for case in cases if 'shared source buffers survive compilation-cache eviction:' in case.get('name', '')] + assert len(targets) == 2 and all(case.find('skipped') is None for case in targets) + for marker in ('é', 'λ🚀'): + assert sum(marker in case.get('name', '') for case in targets) == 1 + binary = SOURCE / 'build/debug-prepush/bun-debug' + build = SOURCE / 'build/debug-prepush' + engine_build = build / 'deps/WebKit' + build_command = ['bun', 'bd', '--webkit=local', '--webkit-version=' + WEBKIT, + '--ci=off', '--buildkite=off', '--build-dir=build/debug-prepush', '-j2'] + cache_path = engine_build / 'CMakeCache.txt' + cache = cache_path.read_text() + assert 'CMAKE_BUILD_TYPE:STRING=Debug' in cache + assert any(line.startswith('ENABLE_SANITIZERS:') and line.endswith('=address') for line in cache.splitlines()) + assert any(line.startswith('CMAKE_CXX_FLAGS:') and '-DENABLE_AOT=0' in line for line in cache.splitlines()) + commands_path = build / 'compile_commands.json' + commands = json.loads(commands_path.read_text()) + actual = [row for row in commands if row.get('output')] + pch = json.loads(subprocess.check_output(build_command + ['-t', 'compdb', 'pch'], cwd=SOURCE, text=True)) + for row in pch: + row['arguments'] = shlex.split(row['command']) + pch_file = build / 'pch/root-pch.h.hxx.pch' + assert pch_file.is_file() and pch_file.stat().st_size > 0 + consumers = [row for row in actual if '-include-pch' in row['arguments']] + assert pch and consumers + for row in pch + consumers: + args = row['arguments'] + assert all(flag in args for flag in ('-DENABLE_AOT=0', '-DBUN_DEBUG=1', '-DASSERT_ENABLED=1', '-fsanitize=address')) + engine_commands_path = engine_build / 'compile_commands.json' + engine_commands = json.loads(engine_commands_path.read_text()) + jsc = [row for row in engine_commands if '/JavaScriptCore/' in row['file'] and row['file'].endswith('.cpp')] + assert jsc + for row in jsc: + args = row.get('arguments') or shlex.split(row['command']) + assert '-DENABLE_AOT=0' in args and any(arg.startswith('-fsanitize=') and 'address' in arg.split('=', 1)[1].split(',') for arg in args) + runtime = json.loads(subprocess.check_output(build_command + ['-p', 'JSON.stringify({revision:Bun.revision,webkit:process.versions.webkit,platform:process.platform,architecture:process.arch})'], cwd=SOURCE, text=True)) + assert runtime == {'revision': BUN, 'webkit': WEBKIT, 'platform': 'linux', 'architecture': 'x64'} + (OUT / 'compile-flags.json').write_text(json.dumps({'bun_compile_commands': {'bytes': commands_path.stat().st_size, 'sha256': sha(commands_path)}, + 'engine_compile_commands': {'bytes': engine_commands_path.stat().st_size, 'sha256': sha(engine_commands_path)}, + 'engine_cache_sha256': sha(cache_path), 'pch_commands': pch, + 'pch_binary': {'bytes': pch_file.stat().st_size, 'sha256': sha(pch_file)}, + 'bun_command_count': len(consumers), 'bun_sample': consumers[0], 'engine_command_count': len(jsc), 'engine_sample': jsc[0]}, indent=2) + '\n') + proof.update(passed=True, runtime=runtime, compile_flags_sha256=sha(OUT / 'compile-flags.json'), testcases=len(cases), target_cases=[case.get('name') for case in targets], + junit_sha256=sha(xml), binary={'bytes': binary.stat().st_size, 'sha256': sha(binary)}) + (OUT / 'proof.json').write_text(json.dumps(proof, indent=2) + '\n') + + +if __name__ == '__main__': + assert len(sys.argv) == 2 + main(sys.argv[1]) diff --git a/.github/openclaw/qualification/harness-adapters/candidate-debug-local-build.patch b/.github/openclaw/qualification/harness-adapters/candidate-debug-local-build.patch new file mode 100644 index 0000000000000..0576c355c5323 --- /dev/null +++ b/.github/openclaw/qualification/harness-adapters/candidate-debug-local-build.patch @@ -0,0 +1,19 @@ +--- a/scripts/build/deps/webkit.ts ++++ b/scripts/build/deps/webkit.ts +@@ -274,6 +274,8 @@ + // (macOS: Homebrew headers + system libs; Linux: libicu-dev) — cmake + // auto-detects. + const optFlags: string[] = computeCpuTargetFlags(cfg); ++ // This frozen ordinary consumer uses the non-AOT engine ABI. ++ optFlags.push("-DENABLE_AOT=0"); + // -fno-pic: match bun's own C++ (flags.ts) so JSC/WTF const-pointer + // tables land in .rodata instead of .data.rel.ro. We link -no-pie, so + // PIC codegen here is pure overhead (GOT indirections + ~550 KB of +@@ -488,6 +490,6 @@ + includes.push(resolve(process.env.BUN_ANDROID_ICU_ROOT ?? "/tmp/icu-android", "include")); + } + +- return { libs, includes }; ++ return { libs, includes, defines: ["ENABLE_AOT=0"] }; + }, + }; diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index 44eb28023d71f..26bd0297717dc 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -62,3 +62,5 @@ The completed historical ten-lane qualification is bound to engine `42e4245f4180 Linux qualification now binds the historical and candidate Node references explicitly. A fixed-run continuation reuses admitted current-matrix engine and baseline builds while running baseline and candidate tests fresh. The current 21-lane qualification can assemble the retained build artifacts with a separately admitted fresh Linux consumer proof. The fixed-run continuation keeps the original build and proof identities, verifies all 22 archives through the existing assembly owner, and does not publish a release or update consumer pins. Historical ten-lane assembly retains its original admission limits. + +The ordinary VM-cache Debug qualification builds its matching non-AOT engine through the frozen Bun local-build owner, with the AOT macro disabled for both engine and consumer. It verifies the real two-case cache-eviction test, Debug/ASAN/assertion compile flags, source receipts and runtime identities rather than substituting an AOT archive. diff --git a/.github/workflows/openclaw-current-vm-debug.yml b/.github/workflows/openclaw-current-vm-debug.yml new file mode 100644 index 0000000000000..9812a7ae82dcb --- /dev/null +++ b/.github/workflows/openclaw-current-vm-debug.yml @@ -0,0 +1,136 @@ +name: OpenClaw current ordinary Bun VM debug proof +on: + push: + branches: [claude/hosted-linux-consumer-20261031] + paths: [.github/workflows/openclaw-current-vm-debug.yml] + workflow_dispatch: +permissions: + contents: read +concurrency: + group: openclaw-current-bun-vm-debug-${{ github.ref }} + cancel-in-progress: true +jobs: + linux-x64: + runs-on: blacksmith-32vcpu-ubuntu-2404 + timeout-minutes: 240 + steps: + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + path: controls + ref: ${{ github.event.pull_request.head.sha || github.sha }} + persist-credentials: false + sparse-checkout: .github/openclaw/qualification + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: openclaw/bun + ref: 7b573c05d0c52dffc67d4d25daf108bed5930cf2 + path: pipeline + persist-credentials: false + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + repository: openclaw/bun + ref: d9be087429c21e563bb5ac29f8a11805e64b56a3 + path: source + persist-credentials: false + - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 + with: + ref: 4430cc2e4caa5720c2f78963be3566c87b958084 + path: engine + persist-credentials: false + - uses: ./pipeline/.github/actions/setup-bun + with: + bun-version: '1.4.4' + - name: Generate the frozen provisioning script + id: provision + shell: bash + run: | + set -euo pipefail + mkdir vm-debug-proof + bun pipeline/scripts/build/ci-images/spec.ts linux-x64-debian + script=$(bun -e ' + import { readFileSync, writeFileSync } from "node:fs"; + import { resolve, join } from "node:path"; + import { provisionScript, sectionsFor } from "./pipeline/scripts/openclaw-release/release.ts"; + const dir = resolve("pipeline/build/ci-images/linux-x64-debian"); + const out = join(dir, "openclaw-provision.sh"); + writeFileSync(out, provisionScript(readFileSync(join(dir, "bootstrap.sh"), "utf8"), sectionsFor([]))); + console.log(out); + ') + test -f "$script" + script_relative=${script#"$GITHUB_WORKSPACE/"} + test "$script_relative" != "$script" + echo "script=/work/$script_relative" >> "$GITHUB_OUTPUT" + - name: Provision the pinned native x64 toolchain + id: container + timeout-minutes: 45 + shell: bash + env: + SCRIPT: ${{ steps.provision.outputs.script }} + run: | + set -euo pipefail + test "$(uname -m)" = x86_64 + test "$(df --output=avail -B1 "$GITHUB_WORKSPACE" | tail -1)" -ge 68719476736 + cat /proc/meminfo > vm-debug-proof/runner-memory.log + df -B1 "$GITHUB_WORKSPACE" > vm-debug-proof/runner-disk.log + container_id=$(docker run --detach --name bun-vm-debug-consumer -e CI=true -v "$GITHUB_WORKSPACE:/work" -w /work \ + docker.io/library/debian:13@sha256:9cc080028c43b27d2074d63a5f9caf7166d731494965616c1a6d2827a004585c sleep infinity) + echo "id=$container_id" >> "$GITHUB_OUTPUT" + docker exec -e SCRIPT bun-vm-debug-consumer sh -euc 'sh "$SCRIPT" d9be087429c21e563bb5ac29f8a11805e64b56a3 openclaw-release' + docker exec bun-vm-debug-consumer sh -euc 'apt-get update; apt-get install --yes --no-install-recommends python3 ruby bison gawk perl libxml2-dev pkg-config libicu-dev' + - name: Run the required VM debug build and test + shell: bash + run: | + set -euo pipefail + docker exec bun-vm-debug-consumer bash -e -lc ' + . /etc/profile.d/bun-ci.sh + for repo in /work/source /work/engine /work/pipeline; do git config --global --add safe.directory "$repo"; done + unset CI BUILDKITE GITHUB_ACTIONS GH_TOKEN GITHUB_TOKEN ACTIONS_RUNTIME_TOKEN ACTIONS_ID_TOKEN_REQUEST_TOKEN + export BUN_WEBKIT_PATH=/work/engine CMAKE_BUILD_PARALLEL_LEVEL=2 CARGO_BUILD_JOBS=2 + python3 /work/controls/.github/openclaw/qualification/debug-vm-consumer.py prepare + cd /work/source + bun install --frozen-lockfile + (cd test && bun install --frozen-lockfile) + bun bd --webkit=local --webkit-version=4430cc2e4caa5720c2f78963be3566c87b958084 --ci=off --buildkite=off --build-dir=build/debug-prepush -j2 test --expose-internals -t "shared source buffers survive compilation-cache eviction:" --reporter=junit --reporter-outfile=/work/vm-debug-proof/vm-junit.xml test/js/node/vm/vm.test.ts > /work/vm-debug-proof/command.log 2>&1 + python3 /work/controls/.github/openclaw/qualification/debug-vm-consumer.py verify + ' + - name: Retain bounded source and native proof + if: always() + shell: bash + env: + CONTAINER_ID: ${{ steps.container.outputs.id }} + run: | + set -euo pipefail + if test -n "$CONTAINER_ID"; then + [[ "$CONTAINER_ID" =~ ^[0-9a-f]{64}$ ]] + docker stop --time 30 "$CONTAINER_ID" > /dev/null + test "$(docker inspect --format '{{.State.Running}}' "$CONTAINER_ID")" = false + fi + python3 - <<'PY' + import hashlib, json, stat, subprocess + from pathlib import Path + out = Path('vm-debug-proof') + out.mkdir(exist_ok=True) + controls = Path('controls/.github/openclaw/qualification') + files = sorted(out.iterdir()) + [controls / name for name in ('debug-vm-consumer.py', 'harness-adapters.json', 'harness-adapters/candidate-build.patch', 'harness-adapters/candidate-current-test.patch', 'harness-adapters/candidate-debug-local-build.patch')] + assert 0 < len(files) <= 112 and all(stat.S_ISREG(p.lstat().st_mode) for p in files) + assert sum(p.stat().st_size for p in files) <= 128 * 1024**2 + def sha(path): + with path.open('rb') as stream: return hashlib.file_digest(stream, 'sha256').hexdigest() + manifest = out / 'archive-manifest.json' + manifest.write_text(json.dumps({str(p): {'bytes': p.stat().st_size, 'sha256': sha(p)} for p in files}, indent=2) + '\n') + files.append(manifest) + archive = Path('bun-vm-debug-proof.tar.gz.partial') + subprocess.run(['tar', '-czf', str(archive), '--', *map(str, files)], check=True) + assert archive.stat().st_size <= 32 * 1024**2 + archive.rename('bun-vm-debug-proof.tar.gz') + Path('bun-vm-debug-SHA256SUMS').write_text(sha(Path('bun-vm-debug-proof.tar.gz')) + ' bun-vm-debug-proof.tar.gz\n') + PY + - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a + if: always() + with: + name: current-bun-vm-debug-proof + path: | + bun-vm-debug-proof.tar.gz + bun-vm-debug-SHA256SUMS + if-no-files-found: error + retention-days: 7 From 0e5b180de777933c359ef7bdb4d4f6d4a3e58522 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 09:10:36 +0800 Subject: [PATCH 29/35] test(ci): refresh downstream proof for the qualified matrix binary --- .../qualification/downstream-consumers.py | 20 +++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/.github/openclaw/qualification/downstream-consumers.py b/.github/openclaw/qualification/downstream-consumers.py index 1200499b814a7..a3d8bab1ab7e7 100644 --- a/.github/openclaw/qualification/downstream-consumers.py +++ b/.github/openclaw/qualification/downstream-consumers.py @@ -13,13 +13,13 @@ WORKSPACE = Path(os.environ['GITHUB_WORKSPACE']) ROOT = TEMP / 'downstream' PROOF = TEMP / 'downstream-proof' -SOURCE = '9f5edfb699e35691497b06572a321b20994ca4e5' +SOURCE = '4430cc2e4caa5720c2f78963be3566c87b958084' BUN = 'd9be087429c21e563bb5ac29f8a11805e64b56a3' OPENCLAW = '2952110b2a14efac009e1cc5fb758cd8ed15d193' BIRDCLAW = '59c9ee27f39238654efc93ff7862b27ad474c044' -REPLAY = 41324678688 -CARRIER = '9f03dbd21a64683d1b32e50ace51270248bf92a5' -EXECUTABLE = '2ec7cfd15b846d11d1f45e311fbc10fd7b447f6fcfb579485525ee1233e95513' +REPLAY = 41367738580 +CARRIER = 'b1b043eab568e09d22aed763db4ccdbfabdda209' +EXECUTABLE = 'ef8548baaa826be1342d2aa38229aac852806161a6c13885426333c7fa241b34' def sha(path): @@ -46,15 +46,15 @@ def admit(): spec = importlib.util.spec_from_file_location('retained', helper) retained = importlib.util.module_from_spec(spec) spec.loader.exec_module(retained) - run, jobs = retained.run_identity(REPLAY, CARRIER, 'openclaw-current-linux-consumer.yml') - assert run['conclusion'] == 'success' and jobs['current-consumer']['conclusion'] == 'success' + run, jobs = retained.run_identity(REPLAY, CARRIER, 'openclaw-current-matrix-consumer.yml') + assert run['conclusion'] == 'success' and jobs['matrix-consumer']['conclusion'] == 'success' records = {} for label, row in { - 'current-linux-consumer-proof': (13090894299, 407316, 'sha256:63c674db96939947df3671c2187c39db96bd2f6a43340f10f7edf413fa09148d'), - 'current-linux-bun-executables': (13090653410, 183705425, 'sha256:7b4599e44b1a68ace49cffa533209acb6a255542bb59dc6aa8ff250b15f5099e'), + 'current-matrix-linux-consumer-proof': (13108580959, 433200, 'sha256:ffcb6eaadd13a54cbe62746ec66eb34d8a8f06762dda747c23abdf5bde8e0ac6'), + 'current-matrix-linux-bun-executables': (13108206293, 183705425, 'sha256:c6e4cdc207253ce43247de6492d0bcec9246b5fb76ae27fdc469b1b8423f1e15'), }.items(): records[label] = retained.download(ROOT, label, row, REPLAY, CARRIER) - evidence = ROOT / 'current-linux-consumer-proof' + evidence = ROOT / 'current-matrix-linux-consumer-proof' identity = read(evidence / 'candidate-identity.json') assert identity['candidate']['commit'] == BUN and identity['engine']['source'] == SOURCE assert identity['runtime'] == {'bun_revision': BUN, 'webkit': SOURCE, 'platform': 'linux', 'architecture': 'x64'} @@ -63,7 +63,7 @@ def admit(): build = read(evidence / 'candidate-build-tools.json') assert sha(evidence / 'candidate-build-tools.json') == identity['build_tools']['sha256'] assert build['compiled_inputs_sha256'] == '33c6f0b30bf33c45b2aab86ca7bf9692cbb30e2114d2e70e255e9ac43e52f614' - binary = ROOT / 'current-linux-bun-executables' / identity['executable']['path'] + binary = ROOT / 'current-matrix-linux-bun-executables' / identity['executable']['path'] assert binary.stat().st_size == identity['executable']['size'] == 105658384 assert sha(binary) == identity['executable']['sha256'] == EXECUTABLE binary.chmod(0o755) From 37daa07523182b6deb2deda43d6bfd41bdf9570a Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 10:02:49 +0800 Subject: [PATCH 30/35] test(ci): reuse the hosted contracts lane for canonical controls --- .github/workflows/openclaw-hosted-linux-consumer.yml | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index afe6dfce5e8d2..f0cae87c7c7eb 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -31,7 +31,7 @@ jobs: steps: - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 with: - ref: 0e5b180de777933c359ef7bdb4d4f6d4a3e58522 + ref: ${{ github.event.pull_request.head.sha || github.sha }} persist-credentials: false sparse-checkout: | .github @@ -40,7 +40,7 @@ jobs: - uses: actions/setup-node@820762786026740c76f36085b0efc47a31fe5020 with: node-version: '26.12.1' - - name: Check the combined packaging and consumer contracts + - name: Check the canonical packaging and consumer contracts shell: bash run: | set -euo pipefail @@ -54,12 +54,12 @@ jobs: from pathlib import Path config = json.loads(Path('.github/openclaw/variants.json').read_text()) assert len(config['lanes']) == 21 - assert config['candidate']['commit'] == 'd9be087429c21e563bb5ac29f8a11805e64b56a3' paths = ['artifacts.py', 'test_artifacts.py', 'release.py', 'test_release.py', 'variants.json'] controls = {name: hashlib.sha256(Path('.github/openclaw', name).read_bytes()).hexdigest() for name in paths} Path(os.environ['RUNNER_TEMP'], 'contracts', 'gate.json').write_text(json.dumps({ 'passed': True, 'head': subprocess.check_output(['git', 'rev-parse', 'HEAD'], text=True).strip(), 'lanes': 21, 'archives': 22, 'controls': controls, + 'candidate_commit': config['candidate']['commit'], }, indent=2) + '\n') PY - uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a @@ -285,5 +285,5 @@ jobs: if-no-files-found: error retention-days: 7 assemble-retained: - if: ${{ inputs.assemble_retained }} + if: ${{ inputs.assemble_retained && !inputs.contracts_only }} uses: ./.github/workflows/openclaw-retained-matrix.yml From 4a01bb332c75639352d555fe057615ef0067ee7d Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:04:41 +0800 Subject: [PATCH 31/35] fix(ci): admit exact Bun snapshot before native qualification --- .../qualification/acquire-bun-snapshot.py | 65 + .../bun-882-qualification.bundle.b64 | 5326 +++++++++++++++++ .github/openclaw/qualify.sh | 13 +- .github/openclaw/release-notes.md | 2 + .github/workflows/openclaw-artifacts.yml | 11 +- .../openclaw-hosted-linux-consumer.yml | 1 + 6 files changed, 5408 insertions(+), 10 deletions(-) create mode 100644 .github/openclaw/qualification/acquire-bun-snapshot.py create mode 100644 .github/openclaw/qualification/bun-882-qualification.bundle.b64 diff --git a/.github/openclaw/qualification/acquire-bun-snapshot.py b/.github/openclaw/qualification/acquire-bun-snapshot.py new file mode 100644 index 0000000000000..ade288ba64928 --- /dev/null +++ b/.github/openclaw/qualification/acquire-bun-snapshot.py @@ -0,0 +1,65 @@ +#!/usr/bin/env python3 +"""Admit the exact signed Bun source snapshot for pre-push native qualification.""" +import base64 +import hashlib +import json +from pathlib import Path +import subprocess +import sys +import tempfile + +COMMIT = "882b3ce222db5f51adde7dce65bf6262aeb7335f" +TREE = "20d3242be73f09e989b136c4584191fc7a8a7e82" +PARENT = "723010451479c1464c6d6c5f2a5ebea2eb92fcbd" +REF = "refs/heads/claude/webkit-bun-882-qualification-20261102" +PREREQUISITES = ( + "dd5eed75f82e5972e3a3928032bbede7eafd2795", + "7b573c05d0c52dffc67d4d25daf108bed5930cf2", + "3f3a9ff87cdccf3d32d7ec6b648c664eddaae840", +) +DIGEST = "264eafa6ff4b7cc14c817cae42ea79b4b34fbe37c52a03802a6eceab6c00f767" +SIZE = 303527 + + +def main(): + assert len(sys.argv) == 2, "expected a new destination directory" + destination = Path(sys.argv[1]).resolve() + assert not destination.exists(), "source destination already exists" + encoded = Path(__file__).with_name("bun-882-qualification.bundle.b64") + assert encoded.is_file() and encoded.stat().st_size < 512 * 1024 + data = base64.b64decode(b"".join(encoded.read_bytes().splitlines()), validate=True) + assert len(data) == SIZE and hashlib.sha256(data).hexdigest() == DIGEST + header = data.split(b"\n\n", 1)[0].decode("ascii").splitlines() + assert header[0] == "# v2 git bundle" + assert {line[1:].split(" ", 1)[0] for line in header[1:] if line.startswith("-")} == set(PREREQUISITES) + assert [line for line in header[1:] if not line.startswith("-")] == [COMMIT + " " + REF] + + def git(*args): + return subprocess.check_output( + ["git", "-c", "gc.auto=0", "-c", "maintenance.auto=false", "-C", str(destination), *args], + timeout=180, text=True, + ).strip() + + destination.mkdir(parents=True) + git("init", "--quiet") + git("remote", "add", "origin", "https://github.com/openclaw/bun.git") + for commit in PREREQUISITES: + git("fetch", "--no-tags", "--no-auto-gc", "--depth=1", "origin", commit) + assert git("rev-parse", commit) == commit + with tempfile.TemporaryDirectory(prefix="bun-source-") as scratch: + bundle = Path(scratch, "source.bundle") + bundle.write_bytes(data) + git("bundle", "verify", str(bundle)) + git("fetch", "--no-tags", "--no-auto-gc", str(bundle), REF) + assert git("rev-parse", COMMIT + "^{tree}") == TREE + assert git("show", "-s", "--format=%P", COMMIT) == PARENT + git("checkout", "--detach", COMMIT) + assert git("rev-parse", "HEAD") == COMMIT + assert not git("status", "--porcelain") + print(json.dumps({"commit": COMMIT, "tree": TREE, "parent": PARENT, + "bundle_sha256": DIGEST, "bundle_bytes": SIZE, + "prerequisites": PREREQUISITES, "qualification_only": True})) + + +if __name__ == "__main__": + main() diff --git a/.github/openclaw/qualification/bun-882-qualification.bundle.b64 b/.github/openclaw/qualification/bun-882-qualification.bundle.b64 new file mode 100644 index 0000000000000..821c279b89166 --- /dev/null +++ b/.github/openclaw/qualification/bun-882-qualification.bundle.b64 @@ -0,0 +1,5326 @@ +IyB2MiBnaXQgYnVuZGxlCi1kZDVlZWQ3NWY4MmU1OTcyZTNhMzkyODAzMmJiZWRlN2VhZmQyNzk1 +IHRlc3QoYnVpbGQpOiBpc29sYXRlIGhhcmRlbmVkIGltcG9ydCB2ZXJpZmllciBjYXNlcwotN2I1 +NzNjMDVkMGM1MmRmZmM2N2Q0ZDI1ZGFmMTA4YmVkNTkzMGNmMiBmaXgocGFyc2VyKToga2VlcCBk +ZWNvcmF0ZWQgcHJpdmF0ZSBhc3NpZ25tZW50IHRhcmdldHMgYXMgcmVmZXJlbmNlcyAoIzIxNykK +LTNmM2E5ZmY4N2NkY2NmM2QzMmQ3ZWM2YjY0OGM2NjRlZGRhYWU4NDAgY2k6IGxvb2sgdXAgTGlu +dXggaW1hZ2VzIHdpdGggYW4gQVdTIHJvbGUgKCM0NzYyNSkKODgyYjNjZTIyMmRiNWY1MWFkZGU3 +ZGNlNjViZjYyNjJhZWI3MzM1ZiByZWZzL2hlYWRzL2NsYXVkZS93ZWJraXQtYnVuLTg4Mi1xdWFs +aWZpY2F0aW9uLTIwMjYxMTAyCgpQQUNLAAAAAgAAAfSaLnicnVHJbtswEL3rK+bYIkiifSnaol6U +RLCl1Fvi+EaJI4kxJSok5SxfX8kBeuqpDyDAeTPvzXCoJSJ4eZFHlm/lkR94ru1jiVaYlzm13JAi +8R2LRARJaHREYquBUg+RBl4Z2uhFgY0OcSI7NB07z5FigKSkdhB5Bul1LSQ8sLYYdQtRwPfTZ3AU +xS+GiFdCVj/BCiLH9V3fDOHCDE3TKETTMK3xv8RVVylWweWIaXybZLDZ3MEmuc0m2906PvMG7Kws +2Zn8bjJiNZx5Ot6WhZOJ5ePDMX3eWen2OHLVW3UsJ4/Uf6WnmRmqjZ7cxG9RpNa/DVgTfbq/cy/u +N9TisbNMRsX8YHNz8heHD3IbD25jbrodmZmTfZCZxQ/zxMq2sWfAeYx41VxfBNm08epp9/DCuM3X +cpGs6mMrZ+GNW07uw7JaykW8r5+423r7U5C+5wt1XbO96RfEAPf58Xmz94Wd+k/Zwkz3yWGV/DA+ +1xFn838twyjZ2xf1wpnGr9+gk6hQnhAoI1UrlGaFAl1L0Vc19J3SEkkDrNVYSaKZaA1jp3CoQFB9 +1wmpkZ7TsiX8shG05whcEDp8J2kpFJwoxcr3s0KiJqwdBO1gNfTs+pwzVQ+ltRDHK0iJLmrIBB3H +UZ1QhEMpRQMvPcr3oWGuCslylOrsTejQWqvBthpeoYbhQKPSV8YfC/nuOuoQgwx4nDXOTUrDQBiA +YQR1kVPMwo0UJN9kJplxZ9W20gaqaBqFLubniw7WSUyn1vYWwQMJHsBziKewG3cvPJv39+Bzfx5a +REJjm1BGNWZJFUuUQmpIUsO4YCChMpkSKkNBo0a16APJaBJDzDiwTBpgKTOpTQ2vqOKoUVHUklZG +225+csiZSIF3XfZf31/luSnuxWsdinKAVwO75Wo02biz99lduR6H69j1nm76sFnWl4sCQGMDMHpZ +TdZ+mE8voMhvIyJpf6tmDqch7o1L+TAcTtb5x8/eUWJqi4/oj0+JRbPYDZOqbp+JV8G9IdErtwjO +76xBb9Ebh8voDyNWVOOUJHicnVBdj5pAFH2fXzGPbTatzIACTdsUZVR2lbUCq/VtPi6IILAwWuOv +L+wmfepTT3Ju7j0n5+bm6hYAG8J0BEyobY+JaXE+5oYQqXSBmESqiaLEMm1HKNTwFiqNgUhqE0XB +IcQlIATvfamkMlxJHWds8d4TAhC/6GPd4pe8kkPuqZb46/V9KGr5IweAz3WbfcfEdk1r0pPgB8Mx +DCTr8znXGv4rnDVZl2f404ApWwQhjqIljoJF6MXJlr3pCCckDBKjXHoDfvb010O3kmZYr3YvxfqU +kHVcDFp2y4rU26nJb3WdGU4XaW/Obq7bbTcIb7m+Pi+th+dIkZKZq2BI+AdaGt5fHO58wfptgzeN +B2Vmhnc+I+XBD0gYszHCb2csYN/SBmK2f43z0bLWomTzwI3v55s1tX0jPU1bmLuN2HinXZmsYbui ++8tjStny8Z5tnkyEq2OdbVji1KNfJ8qpdkeu131D7+9gof+vZyANnf4gLnmpPn7BBUCDj7xVUIHC ++bmpW43T/KYvLXS44fqI80pBA32pNPoDjDywPO8Pgh14nDXOMU7DMBSAYSFVDDmFRyRUEjt27IwR +pZGoAkUMLUgd7Jfn1jRJq8QByi0izsOCmDkHx2gXtn/4hv9n9DVa+RaRQApUcgOgsaRMJ9QyLVBA +ySUDZmJlQHJL02CvW2w8sTLGkiUKACHhscETVBgJJZKSIkNkhltAO6yuzkWcShUNg/yv3+/ltYjv +uyJnbzYLF8Ce+7CYHni5EWGFS8fsThdpltXqqenXr2w7v8xEFFE9fZw0t3XSt4eA3H3MX6I83eRi +Uu0fbgTms2z7+Xc2vnDdrtIeSe26zjVrskAzc57o1jur4TTv3n3fYnAErnBR3Z89eJydU8lu2zAQ +vesr5tiiiaN9KdqijuPERhwlseUE8I0mRxJjiVRJyonz9aVsdDn01AEEcJb3yHkPMgoRsjQkZVKm +YZJGSJIwidk2w9TdhmXiJbQkbpb6UcmcjigUBsI48z3XD7eJG3qul0Q+iZHQLGEYpm7sRVGW2XL8 +az4oA5KVZZpQRmkZsMBnCdJ4G4cpjeMQGSME09B1SG9qqeCJCzrgbiWFL/tTspP0O0fEkVTVN/CS +LIiCxM8y+OSmrutQ2bbcGPwvcNVVmldwPsTl9Gaew2o1g9X8Jh8X6+X0WHdg7eXztdvMxkM82u/q +bjgtaJDLxfPT7u5l7d0Vu6FWvVW7cvzM4le2n7ipXpnx9fQty/TywYElMfv7WfjpfsW8Zhos5gPi +auM37vh3bN7JzdSyDb3LYqhMgvydTLxmczX38mIaOXB8xuLCX3n6cbbT6/I+ou/RjHiTBdZis3rJ +vYv5fhM/RRdaLJb7yYTkN3cXrw+PJJDPb25JX9fTwgFWh7tDviyuX14mt3S5vkz68firc5Jjml/9 +SwyHWp/wgz4I+vEztKgqhL7TRiFp4bIXQP523XEeFGpUewRTI5RS7eBkGNRcG6kO8FrzBoEw2Rku +quNYSwytkf3hVb0wvMURLFHLxpI1kjDrOGfWYm446jNgB0FaToG3nVQGuDC2dwYDTgERDLRhXELD +S6QH2gwQg9oOWkZiuBRnMCuKBx9sj4i+OzuCisUKanvQNdnZHVC1XBynR3CL2EGFAhWxi5xL0Rzs +bqLkVa/wCF72ll/LXlGETqH9J45Q6DXZNjhynNzmdpsfPbHP4vTUVdgSLjR0KNigiC39FmXIn3F7 +a/VDUXFxuqdFou2dDIgyvCTU6JHzE8aSQIWTPHicnZNNc9owEIbv/hV7TwI2/sDutJ1CIEADToIN +NLnJ8tooGMuRxOevrwTT9tJDpzvjGWm97+6j1UoJRLC7Xsf3SEbc3Ot4QejSgjpZ5trUt52o8L2A +OrkbuVZDBNYKaOi7to4rojArfKdwQzvyCCkixMCmkZvbIfrEK37F51GGdqiLRLTjoB+4WeYT2omK +kDhOaPsYeJkfENciO7XmApaspkb3yCl83l83G06/MURscVF+Bacbub7jBU4XbuzQti3Kt1umFP6X +uGxKyUq4M9YfjiYxJMkYksko7qWL+fDit2DhxJOFXY17xl70N5iZ1ZS6MZ+ulpvZ+8KZpRvjK4/l +puit8uCQ7+/tUCaq9zA8RpGcP1swJ2r/NPZunpLcqYbudGIUg7dOZfd+29uZjIY6m/nXT43n3o3P +5N6p3gYTJ06HvgUXjMfooz3qxuXYf6Ebcuo+fq8fJg/LdXs5uuGvNo7SeUGfpyLWANNzu79qzslg +f161m00yzilSC14/9gu5msuueg3eaf/HjTMr+Rfr2o5hPPhbM6wtihI/AasVloIohIrUOeaQThPg +hxqFXLMGCnZEaYI47BqpBJItyFNNLWtm9FBwsYEtYfU/jwgcmB6RnQKBB8EUq0tA7dH3vmZScXFq +wRyVyWhIlCC1bLhQt6AHpKlQMV6DJtVyudtifidRSuPbo2AFo+QScMUmFa/1XOT4hz3meic53aAC +dWpQ3kLvKYWM1bkh2erKOVHkUmHcgeyk8K4iJ8Pbe57IFgyQVvpNgCYGPGpiIxvsNNkRmDTpk2t2 +3lxI9DmYktAItjdNTnXNhArW6DfIa306qlrWT++fM6qclAF4nIVVW5eiOBd951dkrXnpGbtLkYs6 +tzUgSKlVWl5LfQtJwCgQTIJC/fovaFvd1d/0Gh9Yi3jO2fvss0+QnBDQ67ZadhdCC8JeZOmR2YqQ +qbctXTeh3Y0Qwr0Q9TDScshJJkEntDoGalm4haw2jiJkd7CJ2xaGkd7qhgRbPaOForYGC7lnHKxp +huq8MUPgz/Pt5cjQP5QQ8sB4/DfQOz3Daplt2waNlmKjIZamVErCQUDlYxGCPzPGSZ5U/8RU7ovw +QQX8S1qcx4LG4Ev9c/1gOAEvwQtYDIOJs1zN/eu5BjRwEQPkOo7bd5yZOxudLD4b9+d9Hc46RWGt +9onjOJMmmjlDH51H4TFuZyN7GHZenjDVHweFBrJ5RIV7WrjbIkrHr2nu5RszfaYu5EWzgrpXTRu2 +MYLwdfwW9KaVKxlNL8jOod+KMiPWgDMvvbkxOmyx7R7Ty2Z4xIHetDeb/WXc9Aeep58dam5PeegX +iy1dJ2W3IZ+m3i5ebXav8UQDISlba26Udt6diGxqxTNc5N5wsE5FUE6YW26jtT8fr5/ZNpk9tt+M +9QsrS2k0gtOywZe+Bih2DD8dNYdB4AyDXjMhp8O5couw2JmO0WEBNL1xideTJ7TsP+/8/nQt8eTR +85Yjr9QzTwONycg+7njXHhobTw+EWLVHW4GNctui7NHBoknjnW4OsvbG5a8HJcbAeGy01/nUblPb +VzrAeaMvts+vref83Nzt/M5raqDMnNGyhTZTXwzzgB740/CcHTfz4nzZPR167vLtgj3Cwu7iqAHd +s0o63q52ncUjOpjJ6oSzIyyDCJaV5V4cMT+Uob+C1mFztmhpPr4EcmFh33XtpDSHZ6Xk1iRe3ITe +rv/s2iPH9N8m0wJf9FQfNsjaKY+PAz733W6eGGYT45Fg067YGqdyEL7Q6FkDy7c87ZJiOl+boZMF +m5PjbHubVTU4HYJ2ErDVoh/0x/1udwBL4nVtvzeylmlrc2Lu3EsnSklc5vald+wfZ61VGPFwbL28 +Pr1Zp34xcFbj0bNgB2MzdBtu1a2yl9EhNI57r9wiv2T0zcoPGkhSy4oXRVp2ZlE7Jh5PWlIDfylP +GdptJ/yJ9+8boUW0/JQR+evvIOdEEH4mYPm0AJLDTOSMSwAzDNTS5QmRlGWAXTLCxZ7m4NMvbd36 +VdN+A3UNmYjva/x3vqb19wQdc0bVDSH3BHBypuRC8BX/G4zafki58nykLgKggknMoaRZDFDBr9dS +Cmn2ACbq8AOwhEfCzoR//h4eFUIyXH0GYl9IrFDAQREQn680uSpNhLjG1ZkwJkDdfOpcKgjFTLKY +KKr8ASwV4ZgojhRd+aoQReWaCQUBQtIkARkhWIBTARMaUQTrv/8AGQOJArs2kECaAipUB5g81EoK +WSXkk2DoeB2JajmFEmS31j7qkkO5F3WOJEJ+QlSF35Cqa+BFXZf3RE4SUrOCXNIIIineoX4H6hqG +GX27Vf9AFdC01lH8ZMIwSdjXQM6YFGo0dzxMhWKH9h8zM8g5u4ALh3mutLw1CWSVk29t3CIxSVQZ +DnKiHgN1mdfDIWXOVA8RpInKRkn9ooaNbtlIfW/IPZ2hIq2NUWQCRgSoltTwUyKudb5q+l67xv1I +9AKprMPeB4xoroYuSSnvNvzmsruPfqKSakMJqqCQ0iuE6CjAZU+US2rv1x5QgYqskuNmvB+luI8U +qyNeoKvcQn1HIaeslhyTnKhHJpPqh0zEkoQg+f+7d+8hZbhIanN8Uem8+tgAPDNa721e1SRJmssK +FLnaPEzUaRbRWABc8JuLCcwKtc9jQnJQT+5rxAfStfT1li+kcmHttVRt2JcblS93cZQbMbkWvezV +mIE40jy/YyjmLFJ1lPM4gbgCMBT1lBPI4zvkw89EqFSF986vmtdlv0oQcZiSHzJVjKxjGacxzWBy +K/H9nr/fXv8D2Agoo+4Pn2d4nDXKTU6EMBgA0JioC07RhYlxoWnpH7gbxCAOceJEhTGZRVs+RkZC +x1IWegviUbyBB/AcxlPoxt1bvJ+Dj/21dwBIG6oFlZI1wBQjEcM00lGNDeUsJg0xjQEpZBPslIPe +I6mNYjHUf1URSSNpjOa1FoYqgUMjQhzqWNVqWp8dckxELKdJ/uvrs7rmL2mbYzvcXozDHcbZstos +i4eBQ9pv7WObL+IwLzym5SW7snn5tu0WuMySqEocb1kaBuiGFNkqZ93Kj6okCdzPitnz+/fe0bFp +T87Rk+2tQxvowSlv3antu1dUgp63Hg3gx13wC4GvT7bhEKFeeJwlxT1OwzAYAFAhlSWn8M6QOP7L +N4bQFgqiqFQNDB1s14kjgmNSRxBuEXEkZjgH4hQMvOX9nn7N9qE3BlGpiGRYGKKFNBhzASCUJiRj +TGBJkgp4pXQWedkbF5AEqRWjXAhFwUgNFSYpBsINxalKKNMV6EqbaZ/MgKQwTfD/92cZY/pu67ZM +zPOlh8et2I3dW3Ze7LYWd+sb9pKXi03hw521goRDPC+H++WVzS9aoLfrsIoQLvATO1u8Xnv3sFkt +SU/mdf7xc8Ljzoemc7JFoZe6cTWS7oD8oNpGozB6c0TB9t1QW3QcnY7+ANxlUmL5FyCScaV4Sizn +u4AsX6jv0XccjeiheJwBeQGG/qwSrxKQ5RQYgyjAMnVFPv4va2GQ2njSNuQt3LH5MwEUDJHr25NM +YtOGSUucjst9Em3NCL+TQALkTDAwNjQ0IEFHRU5UUy5tZADjMQSM3SyWkkjoU0KF8nS1bmVl+zEw +MDY0NCBDSEFOR0VMT0cubWQA0dCoHBBG1W5pJf5s9HLfMJmq4rOTbQNrFO/Zk+rsKCZnNZegHVAY +NN7oktNFk+wDWhSKmoNfwe9BJrGL/+P5h9PKg/Y7nJNaBH0UoJsMsC9qBBEQv1ob4ZaP4GXjEzmT +6wT4FMAH3OgZD2B92PiT8810xAoXz6RTs/cFrQE2EB1oiyoSrszjjuywTzwIyL9gz1o0MDAwMCBw +YXRjaGVzAKUz9SGfJLIB+I3gtPLQqVO6k+D8k9oHZRRKbFqqRWJRXrHs6W26e8b9ZUYLYpNTCDAy +X0hxn+HGU1CXI0G/SaYKD6E9TDQwMDAwIHRlc3QAugMVwCO5J+CyNmEXyrZ2+m90jLiTtQh3Y3Or +D/QDAVyfz2p7y20RrecN6Vrqxul6dGt4nAE0AMv/xwPHA5CUFEbTmpmp5GMsxJZE6yCePOAI8VAw +sagLARQ51vgKEDK2EI8c/YZw40L/TkRe/IGkGFH1Q39yRYnauzvzFTEzSJyxzrCPLxNCeJxVk8Fu +EzEQhtVj9ylGQoJLs6VBcAEhVaISQqVCarhwimPPbqbx2otn3DZc9sTjICEhHoaHQWK8m7Tkltjj +9f9//+8/P47+/j76+f14eAKLy2v4mo2nhqwRigFc2kLKgavqGgWW0+Z2Jp6XoNsGOhN0bT8HEkGQ +BWSNsMrkBUwSaowVhjuSddmoONoNyiyhYCi3nIDLvR/wfobBTX/0t/WR8QSSuZuW75Lpe3TTOpjg +4P1i8el0XuW+TcYhcCa9u4ZLNLcISzHtErDrZTsOL/u88sTrJTTGM9awUIkOG5NVpJjUDmqQUapi +F4z3wHQPQTHox3pvpImp49fQZfZgYxBDAZNOJoSEN2gFHazQmqzq1CUluIoO6xuuEjaYMFgsiIQ6 +BGIIUfas0dVVdTEYuwbu4gbhJq7ArtFuGGKeYOK9MgSOOelnbOw6khO4xVSOM7QYssp5uHH+qj6b +12egmoEU/V7/SMIku1ZSVnJSvmVltDyUa4rnhjz+l9Y+wGesItBmMSs/8S8HRpmaCoUpeCXTUJvT +WJ9aBSnjXvNT+9uKAouSnaql0qaqKJDicohqJ5Eb6RjnlApcFCZFT8Euu/s1DsNMoa2s4b3SEDVX +8mpJM3JovebiDn2/w1VuT8+vz69mMfgt8IZ61uw6TbK6pYGpGCtGdiA+fA4kOtDHpAy1lVFrpvxY +y+V5dvBSZm9Kh1DeLuuqNCv2MlF5THStBw28eD7rKBQXnjTEUVmJSIYCgwV7HZofDtXVlZrQZ/bw +saK7NHDXtLOXh/Ol3FrD/esFF8e+7Z5A9fgmNQS91pTlp9o+o4bpGyaNUcMwLY4NSuhRSY8P2v0a +jr98/Aff9oal8gnWvUDfUpkRV9tsrZkHstKLAf2pqnicAZIAbf/pC+kLsLUCFGVnVxKLZgqEtOga +VFkkFcWbpGiwk8kCdhSNHABIRdTVwVGLgb+80TgecSpX2pNTAz4+W3MetFwgmGr/pmPNHylnO75h +HYUxMDA2NDQgcnVzdC1saW50cy55bWwAL5USH6F7CocySNDYZp6qeqsd4UCzzwMGAhR9NqY2Vu1v ++S88H+lSjhWC0xHW8DP+PF53TuF+72OMYzetWGF0reeHAKZ1La14nNskvVlkgzEXAAvWAoL+L3Kf +PHrXU79JjvY8xg/AaO5ePCxfeJyNks1OU0EUx3NLIBEsWAmWG1o4wQoFnEohJlppbE1sNCFqA10Y +0pBJO22v3t4p84E2wMKNSxI4D4C6NzG5S8MLmLgw8QHwATQ+glMh8RYb41mdmTkf//mdc3Jsvf5k +fVjpi8Bv29LUdWptolyJRcte0x6oBoP11bWzJ6dClcM9kNpRTILxPHOxzaAq2kSYcCqUU6MVJSHp +cVC0DlxAU0vX+KLOlMRCaNFf6XsXGgo2+zlgB8/+1/71fgJQLOVXHxaebhoBGUjs7IDjtbSSqUAo +ZLOghGa4NRr3bw8lrfQGTCcCidNwGgBlmJkx+upyIZskJNj9fSnrH17cTyNORhPnas92cmc7qcuL +sLsL6Zuwt4ffCwwXhr9h4+5HfDx8wT5Hh2tRYYMdojgSmxjrWRK/PDm58ohXWeqZBMFqTDDvf5Ki ++OOBxnjOxlIs8m/FS38U+yQXtsJdRPFgsgu6IXjVL+ZfWeEufrhxLT4mm/w5+4vb28ujl7hWYHwi +mNSuknN4UB73P9+TITwqD+SJ2Y8my0Cp5XJa7bFIgrW4UHIQzsypnQ6aui9oWybncOpWdLz3B80Y +OjRid2jE9O8qS5DmpqItqhqZoLgb86mXTRePr+f93P039i+wvAIn+AELBII6vANIcA2OwDB0+uac +PRa1M3ice2LRZblBnH/yfRGuyatFtScXcLNt1uG34AUAdPwIC/MDG1wz8XSeEf/xu3+rqUz46y1X +XQR4nLvP28W3QZpRLTPNSiE9sySjNEmvKLUgvzizJL+oUsHWVkE9vyw1T7c4Qz+pNE99sxjjSVYA +zS0RhfNFGIPbxRyCv+ozGACVnW1p87UnpQJ4nF1TvXITMRAeUvIUSwXM2IahpsmQIpAMBBImbfak +9Z1iWVJ2JTuu3FIxMDwFdBS8CiU1j8FK9mWA5u7m7vbb708ffh78/nXw6en2iIxHJrg4PQcTl8lT +djEABguXkRfEQGHlOIYlhQyWEgVLwTgSmEeGwzcXOmYJegrEWGcnbZgpowsQ9NWK4GoZbfE0Y+qd +ZOLjGBfy6PEVbK2ThNkMkAeOpR/AZdE1jZSF3RjEtYLP7t+fwnEMuvVdkQwvXj6UcW3kaQx+A5fU +nbgMQrkkWLs8AIIZyCykLKfJhaCYEgsbAmQzuNVz2rO9JpNHtl1x3kJG7knJqIo84B60kThjEuIV +ffl678F25F2SZCZcjpx9ROtC3+CrS4NKBpUl4ubO7J1aECWwmLFDUUejugvrQS8IUjox7DpNoHoU +6/c80HICqXTeyaC+B1GSxah8QO8aRF2nbzPt8mqT6CFvEskuGSkpRc5g1MS4hPO3py4rXdcxco21 +2hZLhsxoVMDs8+Tj9nAVndWFaVMluYCmGbUrTZi7HhJuqmLNrnD956holW5VMGHQLCRCCWqPGbBT +cySaBWVYM6ZELGAwQEeK5b3mQLbZfGitOpKnLmzHZOrCm6JaRwshRw1PlwiB5Q1wCSqzRV5ZqGFA +t8pW485u3h7CXQX2BdEOFRcIXmuPZ9eieHNi7fiuGspvup07Jf3qfdBuafbFZ/mnCCO9vaxWVxlc +2mUZSHIlo+Qn6p3xpRWjnqR6X7P6r6TVHQsdmkVSVClME5ChZKto2/+PZqcma5WPLy7OnjzT7PRM +1ZUzOKmFaofCmTGDtuAvhF1JbgoVhWgRovd1sdQWqYyx0kzaIUbtEWRCrkzaaI/cYX8Xl0J+/3H+ +7Q+kzpht9gGgC7dIQ86vMRd+Rx1ndhZBgblR6nicO7yO5fo6lg1G+ZPvyMpPPq8puNkv/+tyAHnc +CqP8CXwu95Dx+Dfm5XqAriQKKjQ2bqqFeJyb1ch4rYlxwyNuUY28/BKFnMy87NQUK4WE4qJk/YK8 +9MkurIqTS7mEOYpLkuIzcxPTJzOyiicBVWZk5qUX6wNFNRVQNJZkpCoE+LkrJOenpCYrpGXmpRRD +xBJTSzIUCopSUzKTS/KLFDJLihXKEys1FWoUfD1DFIAiBaVJOZnJCin5uYmZeZs/cK8yAQDCijcw +8QJuSoGUJ845X1RAuOm7eKE5aJIiL3icASEA3v+3DrcOsOACFE+jfZ8D7NLlPr7oZQWrpEnZGFgk +s/QCQwQLDA8o+QPcLMWf8LCwzX7mn9vzxgR8cQIlCXicATkAxv/IBsgGsCsCFFJEQaX08J66HtAd +QzrUEKVYoMuLkz8COBQm0V1XBsO8z6jzTMXCoa7fRl9zEpOLAr3aIBpn9gM08qEeURIAXW59G4cm +HG7jhpj12XicATYAyf/9Af0BkBgUI+3CEQjyAhbCpud1HsasDt2/sqqRLG8U+pBcY4g8IIdubHAk +4ZserMzFskKRr06uexnD+ATcT5g7dR+3SgiI8yE4JpAAS26tKnic2xU2PXyDmQJHUmmeQklqcclk +NgU1PWWF8sySDAVd3YLEosScnNQcHYX8vFSFgqL8tMycVIW0/CKF1MTkDIXy/KLs1KLNpgqs3ACO +ExiO9gvdi+sZQGLa+t41PICl/2v+DOHManicAbYASf/TEdMRkD8UWV0h1ioNoC1yKUqJ2MOqHlRQ +PA+RU2UUxMQ28xBKuBLFDV8SErVItAkgNTCRzGgUGZiJYU07gu5eS8UDD6HvbjC4L0mzSAELARSy +4AnRBXGrhmTDUzcUJ/Dzk8FTuLNnAsECFDOBVUUKi7DApKetjGE9QqylWIx/kzwFZhSArCKAq/vI +DubbQj73ziH4BWlX9bO2BcICFBKKCYlWtqNZeFwnXawh7kl9ub2ck4wIR14VTS73B75vAzZ1D40h +1QgHR3iEKDPuPGp8eJw7fpT511HmDaZL3EIyUhX8C1LznHMSyxXS8ouyFVJS0xJLc0qKFUryFRKU +UjKLE5NyUpUS9BSCU0uAAomlJflKCQqpFQU5mcmZJTmVIHWTe5fJT/Zcoi6qkFJalJmXrpCbn1Ka +k6pQlFqcn1M6ef826833lry0BQCu+i7p/hggb14mlogf0hbaxTwwsLSCtY71rXicTZAxTgNBDEWV +dk+Q0lIakKIcgBKJAgmqRKLMOhmTHZjxLB5PllSpuQ0SDRUHQIKW6+CNspByvv/8/+yfz9HH1+j1 +fby/a4ihFnoqXujsvIaQ0GVAhqs5xORKIOi8NoDg6B5LUKDnNomaxQGn/hX82ivUyyXl28OP+uiZ +gulCWoQtEhgj5RbXQyJD2nc8BeISSXBlVSchF6BSLKqV1JLobgbXmo/B2VIjeobgt2SD2IueN6AN +QbaaAX0o7/UkfuMZwynH3kBSUZujbeQcOYgojyQzuEzG+G9NqwdaW3GDW+p3KSH0aJp019LhGEK9 +448XMGe/4UiseVZVk8kEFqmFQFsKgB16rarF2/f45eYXyOeS/fsNt1AeENYsK59O1ZEJuvN46NMm +c/t4nB3MMU6CQRAF4AYLPcWLlTYWxAsYQkGiMejfw+7P+DPJsrPM7AKdifEGVnoJTfAOVFhbeBgX +upe8977X9973R+9rt+/jQhR5ThDljqMLeBzfgp9Am+SisUSwoUS3chycD3T5ttt/PhPXj8KKt1bZ +kxpihbyUOINlUbIrDEpNiwPImRDYq1Mmgy8cMtaVwLSWo2Y4ub8bNZPm4WYwnFY0JdGMZaHj/DCU +kpGKD2xzjh3OZuy6KJa53b78/J2etLJIvPW/59f/NhFUUfkG0CFMLegPR8nro2NYdXIKoc7dgp54 +nFvEuoh1wz/G2E3XX33YYT8p+/MTlXP/fe0+vOGr3WtiAAQKSaV5uqXF+cnZqSXFDFtvNK2s8xZ4 +bJl/98bGWWsebLSNPYKkrLyYYdOFrDVGWhM644vk/075nN6yMnCLzeRoJncAl0IxSfoDfqvf6xK0 +hfrJjQhKDRrt/fpLzMV4nAE6AMX/pAukC6ABFEb4yXkXDDFclDqxOv6WQ98YohVgsxQB8gEUeHNS +JnlvMi3xG9+Tz94FKgh6svSzGgOKAqR3FznyPeXXPORrAD/eaAqVWXgM4DYKBflMeJyNUj9vEzEU +F82FgQoJhKoWxPCQkIAqTTYGKnWjqGJIQ1JFbOec3zVWHPtk+5JmCipDP0Al7kswFBgyl5Gtgqkd +KvEBEBsSE893l3TpwEk+yc9+P//+vE/fV79crJ48b007hkUDiIVE4GgjIxKnjQWdoEIOI8EgjG3d +b58+C6Gx2LUnKvIVpvgt8N86RFJbpMIEXJ85YAbBOiFlDgbjPv1cH6GrzQAN4IFwtp79uKzeyd79 +DO7fdZ7JnhoyxfaRb3P74TJ4+N61jlzrBq0lWpWZawVfD/a6fc9Xpy5JHQgLCUst8hq8bG7DmBEu +xNpAaNCmQyxZkjwpRmgmoOOch8EhE0qo/RJotvEt+HMz+32xFEzpkHF/tNt5O3/HYwg10gNfDzlz +LKxRIZJpfjM2ekhbKzh5UJ5DxKTskaz63KOmijB/vdme4/bSOCY/KAJpa/lZ1CN9/ImFsREOLfSk +JgjYUf56UavRC4boh7U5skMzFIpJsOgcEaIrnnGhNG6kiv4Q9bUgAhTN8aPP96a75JvnnpBTaEb0 +FKVEHSZvWyAOEBObl3CEyoHUOgHm3aT7PgnveOQ5g0mVXYjd4ThMtKOWTegzC0oDktaIvIwJHFaK +iaGoKLh5VyM7Pa88fv0GrWPGXReEVmSwZB4h57OR83GpUZugqGKKmEhNkUJ2+ipYma5DhwR4mNCP +3lU25DzJLymVTxSTY4u58T5fieqWDoXttJcYHaG1dQ+IPPRtWnobe0gDiCUMTV6CFcVt9utvZW3r +v+253p2P55UHxycvlrPbh9Xlo8ZZMGucVQ/X/gHRJliv8BGNJ9f6wdqApS3jnWEFIitXX/C+53ic +O5J+KnODBVN9Xn5KqlVxYU5mSaqSQjWXgkJyfl5xiYJLYkliUmJxqpVCSWVBan4aXCC4Mi/ZGqgM +JAwXVLDFkIcYE1ySWJKam5pXAjcHLgJRWA81CS4MNApNCdCwzLyS1KK0xORUVDmwe4FW5eQXp2po +WimU5WemWIOFooMrc5Pyc/RSMosLgJKxyLK1XLVcXCmpyTmJRakKk/9rcWy2YOoxBAAhgl0T/AHc +d6kl/wQF56rYJLs5N3f32NFKjnic+8D0gWlDDKPICSGO7p4rxutXsVzZd2qCmO5lh4ooALFRDHf6 +Bwbja78HU57zh1rVeLCcWoAm90C/eJy7znydeYJRRJ/GbY3Nzxl+698oEyhcfvEik5vkRBMDIFBI +LqosKMlnyNprLcmRq3pix640lUxR3S/MDLd9IApSy1LzSjLz0hncVy1fYbFNUur7p/khlhdYd5bM +b2Of2GUpYp8y5eIa9yJuA653Fb37k6IPcjNKLrzOCACuRDCt9AN5ERMi37HNZ3rWeEHaRY4z3Ioh +3XicATQAy/+UA5QDkGsUEM9hiGnlpfMv4qdLIoxSnVsnqIOxfwEBFEbWdqKy9bEJkHQ57RaRz6dW +kCS6Zs4YH/ujAgoMov8cQ7OwTugYKsNk2OhVgwGveJzFV1GLG9cVRi4Ordq0htimxg2cxWGtkSWt +5MTQerNry17ZbLKedSWta2fjDrMzV6vbHd0RM1deqYkZ+lDax4Ie9BToDyghkIKhedj0qaVQ2j9Q +aH9AafIPes69M6MZrVJDKRR2Jc29555z7jnn+86Zv/7tGx/9vPhJ8cTr9hmEEyHtMTh95hyB34Pd +IROdzs7VEBxx3RUhd2/CcZ/JPgvABscfDHwBwh4wCJjthmDjH/T9UOpF1CCPffADGPgBA88+YF5Y +K0J5es49P3v6w8KF/cb1WmPNZcNwzUdbYeil304wGUp/bXyj/oO1Z29awvFFWHOu7Lz5VgPKa8VQ +2pI7wIWEUWh5vn+En/yIWeimRdZLsy9fL1yIuKgoIY8JAz4ognrgYSoGG1Bfx+UeellSe2oFv96m +M/jj2jV9EGCEETgUzMUA2QE4KMjFPn+6rjZ5D0q7D1smxsvioe2J0aDkGBF8+CFJbsBV66qBIROS +ixGbH+G0Vycp9QtNQhUaBgZUjgKhfdOSWkt1qRYHVnCvdlXpQZ/gGjSeknyUXazGi6jklKBSvGA0 +F6UGLT7H/1gos7tefF4srpUz5SIc2qxhpt+6fO61RA7jYh1z2eciTg4tpump0L2wdJods2FtN290 +uu1t8z6UD+yQxanDm9JTdRPFD2VfhS71WjlIIhTDtyErmL+ZutA1jPUjFeysYFbFZm4HVlfjZ9eW +9n79aRJxXCeF+9VGsjT74s6ZC1FSC6EMhIMHncGwVNI3VOVTNvTt82tzE5WFG2yoQl0S6IEtnb6q +Xxu2zI7ypgb37vgBF4daCn3gQ8KmDGzu4TK4vgRbuBiX3ihkuCWAjYced7iEARd8MBoQfOvTxuXX +1lXulJt4XMjQUgQxR5q+gdl80LLu7pqYt+a22e1AWTiV2RevFy4+yeVZ55IhPuAD2DPTE62tCpi7 +Xethq/1gu9ulx/QnPAd9zY38iennH1+OwiPrfststZs7VmfvTrfdalkEPuFUN4csGHApmdsZHciA +sdDIAVo7vnAYyuHoAA0tUfvM9kZsUXGkNeP9jDkgUUV1UydQToaMKgOVWZifZfBV0gN7rMKOyNQQ +MLut+622dchkLKDzYpCyedk/jpAhrUdWq91O/XywbT5oPp7r17HDY2lAjTSeozmOM/jUGVOozFzF +rblmx8QtA26lut7bgpv5xCVMMTeNxZuTmHs/dz7dtB5t7+40u9u75svSy8aON3L/99nN6o3+r8m9 +UY9eltz/LoHLMtB6fHdnbyubALQSZUk/Ft599zQTLcI/Jom7Zg1SKgLVp8GW2dkhBF94E5orBNBk +wbC1gPDJ7Z8wR3676UnymE7ZnkeEFH0FITmiRA5C2WN2L2kny2hJV4jeV1ciIVUZZBGrQy1ibqx4 +SfMcqTVUSIjKWBAg525kY7IwRlQb64lURow6BrX9uWVliQuXja2DiWVub5Vis0iI21uWjpWpORQT +txlRK1g+lJS1cNK0zb2dnbhSNPnimqo/3Vwt6Vt73XvfL61mjlUyjrXMbvuJco9aUineiGKXmZDB +ZO4r+haDJFcYOjeLKYND/gxTPxoCpbyC6efIExw3lJFnLOC9ieWwQGLtDf1AqukSLztkzgrvcebW +aAxMQKB7fgqc2d9vFS5HQFo9lrTzOkU+c9H9eNjS88/7dRyAcKVaXc9pjc8N2MDpB6VcnOoKYEaS +CVgoiUiBas/s7D18uNsmYlMx7Twxuwl+nwNOxCyB8bIpNmdwubVReCq6ChBRpkVjK4ZTqmIf1Gcy +rvSQ7rJGjYWxTxk9jf6+HVqhLSzulihnFSLEs4oRp1+efDei7dQXjVES03dJeJiiQ/BUnJDBIBtj ++V3nsWJCRIJK25PxdajQ9adymKo9Y/OsGvMXu4nKhmolZNGgLK9kHc01k+xGvn0oNXHvIEUEhLgx +bKSNIYlilLusjrY2vz6Pcc6JONQ/iukRiIRopNMhSMjR46FUrJlMgBWFpRzN2kitkUIjsoV9iIWC +9EcqkTm4IKRm4ImnUBW+q0F8KUQfFy+FdQ3oPVIwtIXKe/G0ebcJLnO4y8IryqAqIqWSuhW67TLS +iPR+YDtHVDHfCyW+MlqOHFuZYrTUwdL0n7+7NP3tb8rT0sfnNuaMr9Oi6UOlQ90LYZqWxCnKxpI4 +f6mh3/aSs+rFjU4as381CxejXBks6ybLanWpI9zQ5bsYtFPlq9kHNWNJRiuIb3oLtnIgUr3IeCkH +qKao2yG2vfWld4ir0FkO9UZagLY8zc2uz6jspOrs1P0wq9NvnpSa+HJBxZP4/h/SWaF+rzke65LK +49ieAJ8+Olk9D9pWWhoV1Pnpr06+U6hSaPyjXAC+2tCnP/18LypWgEaQchh6s7/cKrwX4aXeZWyo +TPZGnlfto9Nh3z7CRy5sT+u+qYC04AdOz5N01CMFFNiyBhK67x2plyvBmBtqhI2CALulcsA/Fiwg +LKkd5a9ShaWDIMAZgFotNbfZ6u3C+18vraDDODfOfna7cH72y0uFV6cf3XvjWzjWhZ56K2wYs/Ht +wh+ntd8/mX7y2SvnkvTErhrq4JVk9aCEsanAohClfvrnP7zx4sfNwp++dlZpf1FqFWZnX9F1+YuT +dwovTt4584+LhfGLX9tn6q/+G3fG2/mtBHicMzQwMDMxUUgtyM/Jic8uLE0tTdVLZli8/UNN6rXr +vxeFSD6bLtjaGBTbsMMQojInM6m0DKjE7YXvBFW3NP5fak7/t549f178BNtEAKefIC37A4x+kABL +znE5hAxdHdzpiB9KXuoAeJzre8k05SXThi5OxorNXZz64owVk32nS2++ojA5BCiSXvpMEUj5Tt/B +CKRYZxoLgeWnbT63+gAHAMpIGDv3BPbIWobW0Odvl1RiUz554KQAvJuKeJxbfoDx4QHGDVk2FgoK +pWXxOfn5BfHJ+XlpmemlRakaIK6uHVRcRyE0LN7XNSTI0zk43tPFxzU+xNPXVXNzhs1+ZQDjQRop +/gG8XoVLfN1I4Dp3HXzo29j3xrKrR3ic28+4n3FCvIhVTs2eFJ3de2uapIN/C8wU2lLzcuXEYh8A +xmMNnv0ONDhS5Uq8qgXY41Px2epVCEoT4SV4nB2OsUoDQRiEiWVqwc6MsRAPSSKIhZ3RA0VJ4E6x +c1lu/7tb3Owu+++BnZb26fMKHuQ1bMXXcXW6+Rg+ZvM9+PgZ9P3o6FBRrS3h/nb+WIpyeXWXP4jl +0yIvRJFfXmP2ejpL2X6OnnfephkW0jqmylnFiK1mGOc8WslgTzbCy/BC6gTaVqZT2jaQ/ywB+OCa +QMwTlLKmITLUwa2QjLGlkHSBpJpgniq8kbF2YcUXKDqOqKQxxwwd0dlGRkq7bDrstI3nZyJBFn9H +hFaGhOV1P95bfx3sbvfH7ze/HBxSwvsBUUoQ0av6aOnzyOeG5sO27mebjMl4nOtn7GecUC1Sd9Yw +kSlu7tkD5SWRB9/ymvF7a5YBAJecCtX8AVj0Ay0IbgW7ItQXjZWtHgjFmA7VeJxbxrOMZ4MQm0h2 +5HON5G+n+oI2Pc+J+TLZ4Ok0fXEArpgM8PUTzAZ/PwKWlCDTkswxJuLvpFneK+d4nPspcEpwwoEY +DYUQB0E/xws333Wzcr+LOxMVOfWniQEQKCSVZuakMMxMOXBbfL/ezd+3VRKDE+uWMQbbXzY0MDAz +MYEoyM4sSdUrKWZwkI1jKuqWTAvVzUoOZ88L+KFg83KzDKMus1dBal5yTmK5bnImg9C/nFlxcq2x +2Rd+/4tZE9rYqOq+E2JZPkxVUWpOamJxKkPC8f9zHyqn5bzMMKn+Etor/fmG6+LJTizbRV4FyW2d +prVsb7FE2IULWjk7P31+FT6Zl7VA5DfXRMvOkMVzHq7POOhi/nZiQdSOmskTWR1FKqZKXJ32tW5P +8cSXX09uZA0wizhsOPkZ63mRWsnzMvtKOCUUdttNMfwseeFiUnbB5pNsbowi71L2F+mq/a/Z+7/q +Wn73r/vdu7ryJitzhAEAI3SIOPotoX0Tj7nTL+OY8rU9gISb7ajXCvh4nHWSz2sTQRTH6UGUXuol +SH8cXvZQsrBZ2oKXygqWhlJakpqmFiklbHZfNqOzb9KZ2dbYltCTf0BO/S8KuXny7L/gwX9A8CTo +zd2dTSJV5zTvO2/ee9/PzK/vc99+zN3dlh7Ng1mjTwtPZsFdaenImURwgZ23TO8gofS1kKpBfLAJ +fSkCVMpFOne3jurt49rW3m6rvVOr15ovWo3mYbtR338NnueBtW4V1cafSz8fDFkXKoz6iXb/VdqG +yzw5EKQ0aF9GqBV4QHgBh6grJ1YgQoyQLAesyFzFsKoHfVSZFHBBWH2vdDiLuOA9HXMjbGeKTJSu +prUFbVin9rO8YzZX4TpOWzS6ZkobypmJbsK5BVdXJmP01V4cTiOolNNayk1n7rIokZgZgdVVyFVi +9MZvGSMuR4p0L+eyZs8K/J2oRIwVYx+851AuSLg9XxXyQ9vOb4++rMDwGDt7TEM0ZVkV2QyBTyQ0 +dBLGQxASZEJAvmbnOEGbQrmcvnWPkd4Eq4lnCab0C9IO3OPswIyy2b+aQs66mNM/GDuZmpBKvfz/ +s7iTbwLXxYtcjz8uf3i6EIi4zziG+6wjfTkYb7w8WHkM99Wb+N38byP87Dv2Gf1Af8/LOxj1O2ag +ZhmstdzUWZxHeJx7L/BeQNXQwMDMxETB0d3VLyRYLzeFIXOaxslci4z+jnj7XRU5L0Ud7TcFTFQ9 +KBLqdOz0Mb8vbS+aigInCTBl5TK9PjfxV5eI3Y3Y11XHzhicWCcwYap7RsaK099bJ89g/FxvVCcg +O+ftcZWTb4t/+br2O01nLK6B2pacn5eWmV5alKpXUszAKlxrPPdlxceKP5+rIgwcKjn+fnsJVZeS +WhCWWlScmZ9X7JGamJJaBFLPqa6t/tLOcPNlxcjr67asX6Ua7SZtYgAEIOXFDOV9C0+t6ZsTZrzg +y9FNrwunhjxybZaAmZdfnpeTn5gCMqbHeuuXR9JLqn7PvmoVkX98fSfzptzJtswzRZRLu4wSuCWE +olerSfpxa9+4NJNh6+ZXzFaMIt+eHTy6pSORl9Fv+vbQeNtnFkUf3262YA1jFLlWdvCxd5j/4iIZ +5ZbHk/PfBF36ZDJ5EZu5SH3e7CvTbsqyv3S0CeePDPj9V04sefNbNnlGkROzNPYtsY3piD/LV3Hy +I6fg5/UzJkxW4PAHAN+/rwXyCbNACgfLbjAM+4ObZHnPk1ONgihZeJxruMl4/ybjhhnG9fr6Cs75 +BZmpxQrlmSUZCtl5+eV5Ckn5pXkpxQqZeTmZeakKqWWpeRDZeDf/oBBPt8j4YP/QIGdXWyNrhbT8 +otzEkpLUFIX80pKC0hKFotSSxMw8oOaSYoXkjNTkbKBUcmJOjh6XAhDo6elpJKel6yUmZSrY2toq +TF5hrLH5gfECCwBm3DOH9BIT/t4qLgcIHzjBzu+VnFm8CrnY/HicuzGP9ecC1g3XzLIUnD3VixWK +80uLklN18/NyKhVS89Iz81IVEouSMzLLUq0V0oryq1LzFDLzFJzz89Iy00uLUj3zCkpLFNLyixTy +MvOyEhWKUtNT81KLEksy8/P0FLT0uRQUylOTsjNL3CHC+UXF/nmTD+pJbb5nFlAtp4NFFmixrUJa +Yk5x6ma9TQdlk7CqqKmB6lSwtbVVUCooSk0qzcwpUdJRUApPTfIGiqfDNUA8U5RaWJpZlFoM1WcL +16JpvfnJeX0bEWz2bOflYfR2BgBzzm449gzX2SEVvz6x86yxtWIoh/oqAPM/n3icZY07CsJAFABJ +K5bW8ggIEkRLQYhiIIgoCfhBrMLGPOPi+lbWt0oqb+BZBHvxHOJh/LTWM8O87s7l4Vxf7hmg5XkQ +zKNkEQaj4SwZhFE46c/iyTSJo/ESBANvECRJlkLBStNa5tZgAwzulSgwg5Pkjbb8ZQerWFL+S5CO +0mjaIXETvFYJ4ITpVvIACY1gbQ4xlVXR60CqtUJBt6ebVWqNz2tvufkvqwJ83wc2Fm/ddrX+Bly2 +Rsj0CbURIjITQnjOFZlTkDtS9xcym5h3eJz7xracXdXQwMDMxEQhyNXRxddVLzeFgeWH9T/52NRW +ocl/spcc2s86w6zv6kTVZhGN7oKukP1vZJbPOdcm+lNR/tR1Ca2Ne2KYPHUTi0oy0xKTS4r1sorz +8xhehvhMu3p2Vlx8NpPr25je6/0bF0lAbSlPTcrOLNErKWbQnHgt+hLL5fbT7SvPr9hxWezt5VbL +yQbMbgBPRj6o8gFTgMPIOjo42xSK+nm0jpzWjJ9Vm3ice+X00mnDHUHW4sLSzOTNjwQ7+AFWzghc ++gQWk4cjbhAqlskhoxqYRsrkV4bnx3icmyZ2TWzDEWZbfX2FjMz0jPLEyviCvHS95IIChYLSkmKF +RIWc/Lz01CKFnMziEoXMPIWSjFSFgpzE5FSF/DQgJ7NYIT9v80HmUHYA/Ooa2/qxAUC3yq0hHUXF +KyiI+LZgqWI+UMYneJylVt9vFFUUzlQLYUUDAcXwQw4TbHbr7CxBQNx1IZWCFmybtAiJbWHvzt7Z +HTp772bunda6bCbRv6BMYmOMib76KIl94hGffDCa+CeYmGj0xWc9d37tsnRRYh+azOy555zvO9/5 +5n79/fh3P41/UJqchOstCpQ1HUah4zAgrAHEs1rOGgWrRa1V4bcFvqHgdxpE0gZI3qSyRT3A6HVa +X3VkkXjSsYklhXlHcGbCZCk8ovVOl2GarzOXE0yZJStiFabSEK9OXBdsj7eBdyizXLIe/qq9MpeD +SQDsyeINKqDLhRF1ZEDbF64BDVr3m3ddyfG1IEz9FxQb4AwDLb5GPdKkBrSI16BYKJwaO7rLjHKG +d8eOh1+OvToePz0cm7j/55gxHtAPO9yTiEdSD2FQuEnr1xw5laCaJcyxqZDQzQFgeoGlyiCk57Bm +BV9l6MuwQC3uNd6KfzOgC77nZqEgWuT02XPpM/QuVHK9XI5u/nggmJ2am7lyefF6eVTtKlxdnJ8z +O8QTNI9FPUoaVxyXLm4wK8/oOry/8F5eN0s7TkQ3wGkrjGabSmJiUwUDdF/a5/WCkStUckHMoUos +NzqU23Dz8tvXZq7fTvsyE9xQrVZBjwHoMDEBpVtLpGifKr650j1zqneyZErsNj/iNBYD0GOE0E6h +4ViPylh8YPsoCYu32xiw+O6Urrrb/OF4MCJhJZdTGl6ggrsoWM7cjeS0UmpGQgV8JvyOYgBfrxHP +IUyKWOsuDp2hsFUDAmziYH2XC9pQMs4l0gjbx/cFSTZFkmU3y3CJM9tpKkh49AmDG+odIZX/TRmR +1PoziQoGZjzbGwOTwMIpFUYUl5Kbjgu5VUxLq7XzrlaStQbc6P5EFDFqHumq6yp5UKhEupO+x7LQ +FG6+4+FaOq6cI22ax25RYJihECnc9pklo26GTzGMTlEbT6IRKQv+C2cWuoDMBg8xQxnki+aSqrhS +GWI3i0dBJ/pPX5lxGWQ7GCn8c2cy4Q8dK8RTqc06QqgmUdJFlc3mXgJU+SCSDCe7qrNeTR2IiI6R +oP6opURbBa22+dXB3alR/rH/cEB8yRXpjeLJ7oASeqU02QDOrDHkMJJOmtmA2o6dxNLxBQUHVyUx +7XksfwnLowxciqZBle3UBoWR1okHjzDzMRCVE5DX+fodLGuu0g3xmEtkcyoUdpaK8cgu7cIzWDrc +bP4SLr+89/7ze5Z2P6v0F/6eOxx+e+SFN97BD4BHJPfEPDpDIe1Rr/usmK4Dl0XBfc+iwkQCzOZH +eiX8eN+9XXFsCPtP7U1+qClM4dWDr087NuRPJEhaRMyvs9FYUNbDq1EoIF+hdujFs9H0ph0P3bhB +OwJ9uuYzsoYmROouVWMdPturFcK/X9Ink/ZjmWFg/JyxpUITDX7CD23zQ9rPl4JBySemsoOnJEhu +XF5YnJmfM7Lo/20twWhvUX+RiqK2+oKpPk5eGvV0M1DZxlFW3dzWF69pR4JVhzXK+Ansk633kQK0 +qRB4iyg/xeaOvA5VoOPXXUe0kAhHxF+fY0wCJlLbVUyUWHW5Rdxo/7e+WdaK5wF6KdbeI8wMuNsO +U69sXVjSpouD+95HlnrmkE1t31vS9mhGXw+PLg5cBH1wUXQow9bny9pnx5QRnhh1bPvMinZASx1r +a/aW9vDTuvYgKJVgMUpUjL7Xd3hdAKNr0Y1SKFPCaUl1/+TRdIViqk1WYyGld1OiyMDPr483U4d1 +fGkO6GJUR5EDbP1GtcN7l1YMsPH+JJDl7edua3+NbT+oa+1n/gFrnrft9AGnAUIJrM8geLLjywsh +PNlwh8VdbHicmzGNcfo0xg1mfKzFhaWZyZtt+O7YAABPuAeR+AMU8ImG2SuAc1Vd2M5xvb5xJpjA +dnic+3+OceN5xg1R3HKleYlliZk5iUk5qVYK0Up5ibmpSjoKSrmpxcWJ6amTA7jt2YozEo1MzTZ3 +c3+JBgBnmRSYfhCwgv5QcgjQOn/ohvCk9b0ZXZcZeJz7O4Xl/RSWDXu8N5/y3rwPADvbCA36AT0Y +o0U5p1RKCLVaGjvlHpynn/7/eJzb9JD56kPmDZxTuEvzEssSM3MSk3JSN3+cfDAGAKWvDICuB3ic +MzQwMDMxUShITM5OTE/VLc/MS8kvL9YrKDZkkL+UU5Cw/s73OBujRYkH7szqfl7qYghRXpSak5pY +nKpXUsyg87hvduykNVYlHY/33zTQL5908Fw+UJW5qalCcWZ6nm5uYnJ+sV5xBoNP4ZUXn7ZYnPvE +NDt63ZW9Unvzn08DAGpENgHzkwLIZkWqNUL75lheL8+a8UQlA8pdaHicnVfNc9vGFR+rk2mttHWc +xIo7TadLREkAhQQidyZxRVEcJ1Fjx66SWJokLUkPl8CShAUC8O5CH5EZjptTTz2gf0DvvWSGvfSU +aa85pdde2kNPbabHXPveLkCAlOQ21WiGi7dv33v73u997F9+u/SnPy599tcLT5FWrfYgoYHfP67J +QHTS9SU7vbj0lbOwQWo1ESXcZWTT8/kWfEaJJJucxRGXYkudm65+64dLL8D27nHoVpcJ4Yx6P/MD +VvoOYiqH07tPnGxN2BGeJW4UCklAxftKm+9S6UchHhOkQVpwzJBMSOe+cHpJ6IRMOiJy95mscSZZ +iMw2MthSGNUydxh5zAG5aoF3qHlJHLCjGgu92gGbcLjaNzzpBpEAwpBHh7WE9v/X05weotJ59sn5 +/IecxjHzatk9ldbH6BpKGV/Tp9WylsQDTr3syEid6RAqtKvry8vK8y9I0k9CF/1HDsDzHpVs787u +XBTSO5d/nP7j2UuTKpF0AOEwDGuDHES+R07ADL9PzDjpBb4YkocPkcUiyjkkZIdkm/OImwbIJA/K +QgEGDxKfQ3gp8fgx4UlIDn05REBR2AwYFQyFGVY9U/JkSEdM2CIaMTP98qmVp2nPJ40G2DNKRGBY +FjlJ6Ysrk8foCuH7gKGykHFRJ3gQHSKpjwQypLAbRvlx5pEdcKh9X4CIPuMsdJm2Z7w8Xl521tbI +m0Pm7gu4MCPCDwcBq33QB9QSnROEjXwpQUzvmLyRhFXih26QeMBIPOYGlMOW2PdjYZO9oS8I/IcR +OmDAwB4akI9+fkclEOPp31+7MllMkLtMJIE0j0bBBhGSg1yIzAmJqRDM2yBhMuoxXlcq4oJAxipw +Oud4BAobxLnXFmtmc2Oz3QRprXvNzlq7uQU0q7mJCBKJL9lEtHtm695WZ83acmx2xFxUrRyihblR +EqI0E0M1M4k0tpTCnAuAljDgUqpfeknh5C4bbB/FZrfdFqsneHrcMMx223vFMrqWVsWjeiRb652K +1bThp64kIjAyeYCEMAkCBGFBSUKP9SG4Xvr+c88oaGSRAVePfIExA3cr6JNMsb5F16qXTObK0WDz +jvKgVmkVJlQ03fbFLu2zW6FkA+DSp6xZPqS/fG65bMMQ0pGGAIrH6If6lvAwM0BBr3C3CgwYpQ6Y +qh4IoxSOLO4FBxAmSCkz9akfJJyV5OSUIvUqzmbbmcFAIC5WHVVZFADQ5biwR1S6Q9MpEAOAcQAA +zSZpdSw7YOHgSTkkFQjMejldi5hAgkQjKLOSkYjnqQmhgsv7caBSV+QpqG3TTkCRp0xwoYacMkCq +MpW7plJbPJjtnHHuDIuVxwTxIpW3SgTxgYDaCapfMHbmbLT3VTTEaQuGNVIA3puVVw0r8ysmR0Wh +XXFtQm5mh195qA5YYOF8CLQnNhv55c6wFwqezL2qygTiX9kJQPSw9M0sBPdrw4obZFgsCozWWMsV +VmduBZBCgdStZQIVOBsiwBITcjmvDNBQNsge5QMm4aiaLIqtbKooCAAMqKbF9yHr7Rff5ZY038lW +inpptqSNOdaBK6W//nh1zbi5feOtAud96kpha0UqRNkSnJtWrGe+r2ha7/ndxsWWgH3Mi5go4QJ7 +BOXSRyUvi+y+yu0fst5tX2bKSv7WCYo9HZIT+od9OPQBowZSMqMnmJ34/c2abt7Wrr1mr1+z1wns +vXdj72a5Lsw6Huh+Z/fdHTumXDBTF6Uk1AtyWQ1n+g/NqC6nv9teudBNv7r5/ETt6FYQ88hlQthZ +Z1dRqJIDaLpgV7GdEYStZBGY9c7YAyomJhb7qlIRB1T2Iz4qeBUlHd/6wUTBLSdjH3kPZk/0r2V1 +q5npnXxxMtYrC39mqMjqcOYOZboCgo4DgGOBITNU8dwyMhefwYf3qBRda2E3v5QubdJOv7z0bPrP +29/rWad5KXd1VZV6OWPQozaO3mbBDV6wFPfcvgIRXvu/j1EwnSTQU0+hCMxdRPnsFohztA2aggtV +hBUoH+1nrwUzS/kqVBiertavTFCgmbUpnKqi/tlvBGtuvshqXYPcj/ywENpdPekB9DB8JkqzxjZU +zrzPOg65oYofVC9oyBFKfxsurSpmyCCmIDeBmZTm8vs8wmsRRnngwzaFSW8US1u7flS6Ueq88aNt +8HpVz+xGVd0Gvmo1zcB4434S+rjTLWj4ukLGxuqJJo276d9et9Kf7Fz+EOnjDRgZVGrqEggF1jxn +Qiw/wjKjQD2Ivw5zszXu5kNt+sWbk6dh+bEfY57kxTX9zd7VSwv1N20aV3+KeTIHkibOn/OlvL5Y +yglkWXr99dr087f+dXFf59icEGuhX0CfqM6rsbWKReos1trWvEd8oBPSSj8b3E634z9P//Dug5e/ +W3rYGtOvDz5aujUbJkXLKO92cEpFkQhilfkA69A4RRWjaB+ArRPo+vzTGWYbkcQqsB6U2+AY3wQo +RmVGdlJFYXrneOWJnXNtsc59qJm9xA/g0vqYnT3K1Ktt+otPvl5aK8upkl0VjLOVTLce/f7Cxv9j +Q0v119T55OrzNr4F61lpVTc0Z70i/fevrkyKzoHdYPaV2a9jWDlF1zE9RV8MWXMGxNIsAdUrCg6Y +vlX6+acXVw31NldZAp0XnkYbxZshV5E+elSZvvPpd779H+ysxgb2C9q5aZWoIR8G7aBGwK9Qpy1j +g09seJzbsIrrYx/Xhkts0/P3M4ox6mw+z1bG0dwsu71ZljFj4fSf+xiVDLJTUwsy89IV0jJzUhWS +8/NKUitKFMozSzLyS0sU8lKLS1JTFNKL8ksLivW4FLQUgqfn7GeU1FJIyy9ScPbULS5ITc5My0xW +KM8vyk7LyS8HGpGbm5iXopABJHKABm9v288Yoz197StGLp7c/JTSnFTdjPz87OLpB18xKoKFOVOL +dSEy24Fi+asA/e5G1nzFP613Z12mSJHQuDtEphpzfIoH1nica7KcYrlBj2OzDEeaCAAcOQPA8QFi +QdpVkJUORCQ0W5ALa/u3nZcJDHice8v0lmmCLpuju6tfSPBGYytGADhXBYP+OutQBLojQXPSugG4 +xA7LsPYnjczneJzrVH2iMiFAxcDAzMREwdHd1S8kWC83hcFtl3tXeGXZhvUrTxqfqVwnKf3C137i +zDyRlXKe06/139Ay2nZzhkGR6Zo1IUusN0szXmAUWRfbnLyDvzaOQ/Rbbq3wnYl/8m3nTv7PlCRS +zcb8/cMviW+RkbuXum9eZf1TYO21yaXMZSKzr6xilKrSyA1X2bzgrMfJL4nhmY2T/zMHi9wwa3iU +f3j/3IVbmgU4ZBfmfjIVa52cxmIlskikJ53v5f/Nvsuz64tXa3oz3FsYvnkLiypTTPNNEYdVTxTX +p3VN5eNTknRaVdIZYGIABAoZJSUF8VnFyQyzdIKe/unp2bNi7/rv9dsfWViqvzBDUlJSWZBazKDU +XS1m3LM/0puzp0TbyoPBtkardLIpu47Ilya/uyelaj+ay33K07h9vepxv/qsyaXs4aEWKV+vzS02 +CPnQ8GPz8us2O+oWya6DGJtVzGC4MKagT0TyXcYqD4fXCyxPrD1asB0mGV+QWFScWsSgP/3kowOK +5zoenXUsd9rr4OW1YdLcyYoclkZhtrpvNl6TTjjBJv2xZEry9QLO5n0wzUDvHDBUl0+Wlg7MOc87 +53OujUbuTYnJPRw9Ii83CxdqrPa/VLTMuuBbuZWkbJnG58k6nPEiDtNizILmflBs4tt8XCqv7maa +nsSRyfM5F4kw/JieLSt16kqB2j2JjIbv+sn/K9dMDuUyFfnwOu01840rRcJ9pxn1ZFMSbkff/j15 +Hpe+yIy7WzZqyIYf0J0n8Cndpq59+tIj7pMfcgWIzHp17o9jgWdU8xfjHouVvoe2q7FVTXblviJi +FLk6vczsUfZcEd0eLWF7w9yArfcm6/JYiWjeDf4749rDyS3H2DUkr9SKb23255tczRMr8nuGX1AF +16UHi+8/X79yFtv0DqfjJye/4bEUYZ6y4Gw9t83JTrmjvBXuq1pf96THbrbk1WYUyb1x/ZPHuWgd +43BPg4ZjvN8Xa35ImVzBZ2LhXy96J3LCDeM3v+ZMtK8VePsndwEvJCiLCxLL8+KLK4sZzuc6KJ3Y +WShrnbJ3V9dSNeWrXO+VJj/hOyyyLu2Ag8OhqPyHW3KPxb1vqZ8cVR2yeTe/ImOIgyND/8Z2nxcO +vV8LV+w9/E+I44cNxNjS8mKGE26SKzXOujIkisWr9Ldx9NufKEDIgq0U7m3aK3rfo/qCKa+hEPMr +bfaIJ6snGwj6i7zeeHnF5z1PlJ4/3/mG8XDM9wq2FX6TJwt+AwDc35ux/gg02v/ItrjIO4WkYV+L +Eiuu5IrPUnicFYw9CgIxFAbZ1lN8lYVI9hx2NtYmm83PgyUv5GUJW4jn0UoQvIV3MpbDMPN9DJ/n +8ArqzgWUYKAjhdjMdj0om7MGe1AVcEuYnNDsOh7RItm404kvifym/6kWWyhXGaeVlnlcuyA3qyoa +0QgqYyGpCqd+E+MdWjE5u4LATvC+qfP+B68KM9X0CEFt0jfzKkftFVW9nR1eFndfIMKQeJwBhAB7 +/7YJtgmQbhQatoV0pP2hZTmBHqwlSXJJPIfUdbGCYwEUkV42MdYUH6Mdf1LWf3Nm3+f2RGST+QGM +FFhmV9VKyAriRc3siWji8VVqslHQk5kCpBRSw1gRf5D5eUtRscinQWLit3QG77NRAwQBFByQgwTy +Orcg8wAYAHaUFSu39y8uk2kETY1BOpnwFK8FhLOFIggyd/SiB0j6pvMGJ61TeJxbWfiqaEOZ+GRP +cUHuosTykNTcgpzEktTJ+eK2jJab14r/ZBJWAIIkpfh4ZOn5UpuB0sHSi5m4kETfiatt5pHjY2S0 +nCwtr8poNtlRXspAX18hPj61oiC/qIRLAQqMTHUUwOJFqa6oMpY6k3vlZTevli9gnCyjKM8MVDW5 +UVuYG6HVfHKsotLkBkWFyQsVRSUsoAaVFmfmpcMVGetMPq8YMllFSQVsgJ+uuCzCABOY3QiXb05W ++sEiYWShYGunUJyak6aHKuurrs7GZGQxuUFDDMm7m1N1XbgBBTtc8/sG00JSa3SeNz9TALg4kjBM +KU97oMF4nAFrAJT/iQmJCZCIFKJL5288jV/G3dz0vurfj32VBLS6sZxZARRKRHTkIZFvChjh65Ei +2jIeqm8QOZMJAowULEUuFY8XjQZxf9QIJ88F1bjqZZmzqQKAARSLyFoWHWBFtm5IKxpW1THCluVz +zJM9BEwuFi5A8Ax1hOqz3lYhynTzW/NQaYxJaiipIXicuzGfecJC5g1rnev19RWCCxKTU3WLUwsS +ixJLUlMUnH08FdJyEtOLdRRK8rNT8zKrgIKJeUCck5NfnpNZXKKblplTkloEFM7MK8lXSCxKL1NI +quQCmpWQl5+SGp9fUJKZn1dsZQVRl6CgUZyaqpBQWpKZY2UFUh1flplaHp+Zl6lZkqCpx5WXWq6o +UVCapODn7+Ia7x8Q4unvF2ylUFxSlJmXrqOgBBKevE5fcnKAPevm3c6yPQBzwURW+wELXJgF0Y9m +S104bgEpOLM6uK6zGHic+/mH5+Ifng2LojZviEpmbNaNadeNYdyuG8Pk8wgAxIEMNfgGFfisAi3j +Q3ufAaFGx/CeHeyB/LR4nAFoAJf/8wrzCrBLAxQ4p9Ddf7AaplHITrTB+3C8cjheS7NfA0wBFFN2 +8J2+n8nPHdJfmr2gc+azf9LKk78EQhRxWZzg03iXOMpMJFbouCXgFNfVmJMVBUoUDhtEhUMIpvtl +Z+s9xWoCgSFWfeKIVjIJ9QLuFTsaVoycgpQLgAq8UPNbkBqB/3icm8o9lXuDHrPI+03PzeKP+q94 +a3Uumt1VbE3/8/7gyY3M8psTmU2YADIDD0j+AvSGVkr+oI/muXT0++vtN5xwinMheJx7m7Uie8MS +CdmM1MSU+Jz8ZCuFpNK8+MTiEisrHyDPytU3ICRycqC81OYFEmdlALSvEW/2L0V7xpk/BGQR+6Nh +LgKAmFHqUQf+eJx9kc9r1EAUxynoglEQkVWEPTz3oEl2zQreRmwtWEXogtYKG7TMzmYnZmgyiTMT +d0NbemiP3ubgsf4JSg9e1Yv/gt79A7wJHsRJ9gdLUec08+a9z/t+3/v8qfb7S+3dD0e3XOv0DVnw +QL90G/qodVZfcp+fb8OgmaTDPKazv+5fYg39zb1ZPxFvbj3zvC39+ODi8dXW1zrtdDqwkXPFEgpx +SoZUQJgKINAfEkVQH55urLdhFKWSQvdhdw1UkVFgEpiSkzvJVZQKpgrPyvIBhBzKSpyLGE+Atnqz +3Fhq7A9yjgWVafyKCoTumSTDRigjQlI8YoaSKxxENNi2FR0rx4Lp8dJte+FF+BCriHJ7d9Zod97S +m7Z0FvJzPhIkwxdSYa9XvwhtyrFj7emfd7/vG/9rRlChIsZfAAkVLd1X5kvv1yUEaZKQ0nJGihLf +BsaDOB+W+f2Vvld1YiFIJUxIIhQRiTNBQzbGpjYrZ2vLmAW03EVFbjqwMxF4/H711GWXSTxzAHf+ +C9IrvWubc8rtChJTBUmujD4VmXIjZZG3M5/EfYN8ZHIQYpypauSYk4TKjAQV+NwEbKqajqXfenX9 +sXdLH72u61X/Cvon90lqDJ5ceinGq/Y4Rf3qoTPerEb7fqtWPfYODv0Ph/7S8oM/LlH9u/sGkOdI +08XEo7XPwVTbOY9Ehv1JAuJ4nPv1nOP2C44Nsv8mH3Bn4cktLVEozi8tSk5VsJ2s/s918gVPlukC +5oxsSnoFiSUZenmJuanFBYkgaQVUAWsuoFpxrqSibKgBkx9+lp1+V4uRs7nl3/aWf4xlpgAYjisV ++wHGLMlPuQgrYYnfaZVkXarWe3wVG3ica2RqZJrwVuTI8qjronFXBOdlsv7Zzqxd9mVDxzsApzAN +Cf4BIHbplHmVk9OkYzQhKnsb0NBw0g54nLuym+nKbqYNTaLc+QUlmfl5xfGpeWWTL4pLbl4mqtcB +ANGeDOHxAm21DXexPT06pugBlN4+LSEfQPhMeJy7w3eHb4M5k4jAxVO7X3MqGWzqMHlSYBPEOvH4 +aqXN3kyCrADtqA0O8QLBsv/2zMov/K6F9fIz9cQfjN2INHice8v3lm+DCJtIRN9+o6rYLUqnPhUf +vMextkn/07qYzRpsrowA/s0OsPsDO0mGayLxJXckbkcZQ/OyybQ1lGV4nAE7AMT/ng6eDrC3BBSW +gWHgUOmGgftZ+D6PaQjYQ/hAQbPLBAEBFK9nQRJk+WSV0OZyGlUOImZ88BCqs+AFPgEpZBoP8Qpd +vPCQOBToii5hsHHArw7Bok4VAnicOx9/IXnDdhXf4sKczJJUfb/8lNRgMFMvuaBASUdBKas4OLUE +IhRYmlpUGVCalJNZnJFapKSpo1DNpQAEiUXpxVYK1QoFMKnJAmqBAmApBSRBH6WOyWKq/KIQcYim +6CS9/KSs1OSSyXkyYpOUtViKUhNTJusri01OVPXdvF1FghsABWc1afENKRY39KBp2udHsXO4Oset +h0XXUxt4nFt5hKnzGNMGtizR4vzk7NQS/dCC9KLElNQUl9KCnNSKyXJZ4uzFGaUlKfnlkxmjJSaH +ZQmqQVTGJ+WnVOolZeal6JUUW5VCtEF0heSH+ARPDihUnrwmS3yzQJYeR4hzfkFlZl66QmpemUJi +XopCQWJRMYifmZeRWpRZkpqiUJ5flJ1apJBfUJKZn1eskJRfkqFQlJqYolCSkQpSnppXol4M0p9Z +lJ+XC+TpTVaMUJ7sW8Y12TjNe/K8CLnNv4r09QExAE6Y8AKef1BVngBqChVJGC2yjjdrJylHn3ic +e8/0nmmDHqPIx2snmNc3niq42frQxzu62NDF8sn6yU6MugD/og66+g9C5wDuHLtGDTJAccajUwk+ +0whFd3icu36c6+oprg2ZL0Q8g+ODXH38HV08/dzjA4L8nV2DgydPPKo43WEvI8/kBxd5JjfM5tpc +/GKFn3RxSWJJZrICVh3sSQY+/nkKPpl5pRU6CgmpFanJZakJCrmlxSUKefklCuWJmSUKaflFCokK +OfnJ2QolGYklQCJVIbkosTgjNQXILkpNTFHITaxUyMjPSZn+fx6j/PSGGUwy1pnFQak5+YkpmXnp +AUX5yanFxRqaCrp2Ckn5+TkK1VwKUIDNWVMTmSSmB0xmZG0XMWfcLmLOdDgHAIMOV13xAmplQbHe +/G5dqPhN8DEsz451gF/xeJz7zvKdZYMBo8iJ5h1uxUc3cqrtOLW25cE94WBOxeWbXRiNGQEC+g4h +fjkNnHdxEsnynvzODRlAlH2jKhKGeJy7uIbl1BqWDWxSm3mlXP4AAC+9BebxAlOrm2XSruzqXEfU +JfMalN5rJy9ceJxbLbBaYIMUo8h1Hcm3Yf032Sb/S7Zs3uM9P9Lj1MvNeox/2QDsNA6y/wHYTT56 +dFZcegzk5BONjPqmnl5JwnicAR8A4P+hCqEKkB8UaWzj+CuX5aATg+26YMhS4YKt9YmxM+4E7wcQ +LPsCaAdAtAY6prq2LyCKNg4PfntBVat4nJu0nnXtetYN1/glEvNLdBNzcvLLdZPzU1J104ryc3VT +Mouzmy/zb7/Mz7jfHQCCBRFr9QMLHj151SfZnAucRitfDAtVCFMWYHicATUAyv+0BbQFsCYCFOKU +AO3sTZY0JRzejKb3CCfyzq5rkzoCZhSbE+EQwGU/14AimG4sHM6g9MV/M3OaGAH0KY4nKN/hDtOk +9q9kKOX+tqq5QQTxeJxdkU9r1EAYxg/bQhGxBdmDIvIUZDerafDPbZeUyl7KCoK092S6ebMZmMzE +zMR2bcviN1gZ8DN4VPwsevfmzYsfwMlsq3TnEDLzvr/neeeZr786n393vmz8WIxVI41GzmvKoCTt +6UIZVEoIDXbKuOFyhppYXUY4LmjerwnacCHAJUxBmBxBKFX1NVLZlIknU5w0BlMm+8YrR7fgVtWc +IJfIuHZqlCVTZ71tgp4mkQ+wtw/+4rn9Gd5dtAWDGE9HnmuXIIPSaTbajRmjRaKCv6PVpz2NuKE6 +0WSCwX/stOCCPHykSgq4zOhs4HgPSDpzzTj/131lZC/ebD1Yc6hMnTBzJWCXF/cWWiiXG3NxKCnm +mArG3aVcJLVqZgXSGZmES27SEFqBrSZvIXCNtsCZ4O8pGznEnXgRl3Pmchyrap664EhkOlqfDkEu +2EyLEEwINWVG1YmZV+SvJTXLCecIgsftQwwi3xvieruOXI5uyK+CfxK3LzEc5rUqA1+3y9f3u4hj +vLzmjx0+HE60/Zh1O70e7LNJZHfGm/ZTtuP3Hw5229qG+991xUd2+er2nfCGm3172N30lt/+fI8f +/gUoa9UcoCF4nDM0MDAzMVFwdHf1CwnWy01hePJZUVV66sJj3KkGe1tdZoQUu397bghRFOTq6OLr +ClKU0D3nZxhPV0xIB8dJ+/RdKb2l7YEmBkCgkJiRmpiim5+mW5KZm8qQoa14XvbCBt21i35GZd2Q +sc5kfjIPalhSaWZOSWZesV6KXkkxQ61z3c2+WdE12XNV9LWMOzPknQ5lQwyEqWPQeLwxfI/J5x6W +LP6Tpxn1LoQ8X7MMpiSP4ehs1lUfD/38K8M8j/vQfkvld1dWJUBkU8sScxheTuCxa7nsN3eT//8V +WnNu2Vy/9OcT1CGZeSWpRXmJObpp+UW6JanFQMvSQU56p3rs2UTLdQfYBSxbvHpCaxlcT+RBTITp +YNhzeO2/RKcVZ5dvu/Xu6eXItEWX3PZBlOTlp6QyqJ+J2+m4zfOF2bYNc6Lmbbl1R3f2OqilBUWZ +ZYklqRDPX+R0bin83GhVE20sdvP37z+vulx8IcaUZGQWpRQkFpVUMrxpajV8sXft5d5bS1IvqfKW +B5y+AAvKkuLk/Ly0zHS9rOL8PAb5d2IBzesWrFNJmt/+VJvp9qsNx39BFZYnFmfqFpXm5aUWAdUy +xNVs6bnt3qcj9Uf7kvnHvZXTpuw0AABUiduXogR4nDMxAAKFzLyS1KK8xBwG/U15L5cJRKckrbNU +VVpYxNsgKxdlAlaSl5+SyqDBe9JySdHm0E2KU46eUXCa/Pfw92YA5+wZGqAKeJwzNDAwMzFRyCgp +KdArKWZ4Wl6aeux90t8DASf7tTau28ZTGv3UxAAIwCoYRKzbC12dXPZ8kf2afeDq5Vc3XdSNDREm +GMYXpxaVpRbFpyXm5CQlJmeDjJRxs36b9Pj755wLayV4y1c+Y57q1g3VU1CUmZtflJKZmFOsl1XM +UCQwU19ixvW27tD9my7cKI78vCyBFwCtzELl9xHZO53rzU9bD8/mfXs/0Uz7coVh03icm/+F8c1X +xg057D7Zjkn5RSXO+XklRfk5OalFCrYKwZW5Sfk5emn5RRpK6NJKmtZcyfl5xSUK2Z55JalFeYk5 +wfnJ2aklLokliZMr2O3qFRyLs1NTFIC6FUrKM5NTdRQSixUy8xRKMlIV8oEEUDi1osRKIRFIA43J +TaxUyEgsS1UoSi3ISUwG6kRYrwe1qji1qCy1CCJupVBSWZCan4bNfpDbJ9ewS8mBrMStbPMX9uo8 +fjSPbc4q28oMAMxqZ/v/BWmOgD69BtpFTNOFFpXExWwqk0ypeJwBXwCg/8wCzAKQxj+oFcJiGZL3 +IKdh67nNXAGBt/I3szEwMDY0NCBfaHR0cF9zZXJ2ZXIudHMAARkC34DxbwV93kAUm3Z5YMRUR9iT +BQEzFOEYFv/6xvYm6vONxsLqstB+OK0FzCUreP0FubNjJy8MMK4iWWs016OPauPno1F4nDtyneX8 +dZYJSxwsTEySLJLNDZOSjMxNEs3MDIwMk01TDJPSzE3MLQwtLZIs0wwMTU2TUpMMDCxMDS1TTBMN +zQwtjE2NLCwsTMyMGp9sfcLIrMXunF+UnZqiM/2xFuNDAFyBHQbzIudEd7/6lZSkInkv3dDxG/DI +iNbyeJxlkE1LAkEcxtk1JJTCKImC6O/LQcFWuloi0dVcoXPkuI7rps4sM7PkIuGhQx9gCS/d+gKR +B0+BQR+ga5cunerevW03c7PLvDzPzPPMb24fYq+T2N2btNGHY8Ew6hZ+ZrVZNuoMMdtZia4vc0/j ++Q7WkWY7L5IyyOfhAAjqYnCtBjQZ7ULN7CCD+AE1MDh0KG3jBlim7/uOYjIqqLBNDJQoUKGgUeI2 +WJqgDJhFeAFEyzXdgYHAPQFd1MYcCAX/IdDCA4aVSNMimjAogeqsN5OF/kUkLehhB3GeCTg5SAZ2 +ydw8aXYvYjQh46uQKBb/HQC1foY1oXAsnHYuWg6mz6imwdWp4AZ7hBD4ngIgYkMRCD73Xz/akZ9C +o/2wuhXAGibe5dXYPJKnLnzjeKtNF0W1hE4Noh9hzpH+2zjc/ZDjS3+6vCuXk9R4kpJOes5aeFtW +tHHiRpLupbTzeB0fnn7Ki1elijwuVUKN5y+HNb/s/QZrcIH+k/VRo+7RpPLalOi8T2d/3Xic27eR +ce9GxgmzHVJMEo2SjMzMzFOTkpMMLYwNU81M0ywsE1MsU0ySDc3NDY0TTczTTFKMU0yNEs0NDVMN +DEwMjFIsDc1MUxNTDI033m5hZMssDg3y0dkcx3SblQ/M1kgsSi+ONojV3OzPkR8AAGQjIh7+FQ19 +2IARuMiXFOtjtEleF3R9H8NveJw78ZNx0T/GDVaaYpnFbpl5mSWpGmWJOaWpVgp5pblJqUWTZ5vL +bbbSfCEiqKNQkFiUmldipVCal52XX563Wclultrk+YXqk+1SuDbvSeGRmOyULDGZP559sm4Ee3pA +kH+Aa1BIZHyYo0+oqwaXgkJqRUFqcklqSnxJZQHQguKSosy8dB2gREZ+fnZ8XmIuimBBUX5BalFJ +JbJYYnJJaWJOPNSFiXmVOlyTGSNUNEP9vP38w/3iff1dQn1c4938g3wdQzTS8otyE0vg+hVKi3Im +/40XB7lS3DfAPygk3jEkJMjTKTTENd7XMzjY0899skyJiaInumRIZIBrvKefs79vgGOIp5PP5MR4 +kcn6JYoyGCpD/YJDA0Biri5Ao+QABXt18fEKvbTVar/4DDiW+t2qU05RY1tyTNJ4nJvD9oZtgo3I +06erlt6dPLsgtmrdu3ueF7unHlc9PTHAXuTBzWNsjyZsW/I0qef/j9DtX9wv7l25cfFrRpETTa6n +OG0vq4tvn35DRMw8czpDbPjkRUxVAYYGBmYmJgrFJSmZ+XolxQxL/m265P/Ue2f8xU1frE5fX17I +8lEAqqa0ONUtMTs1JDM3tagYpFbgq5jNM+sjCmHlQqozJPJmTWkLswYAnXJKa/4BssWWlt0FReCv +dd1QQrvHj5nSehh4nNvm/Mh5QxUbc3J5yuYctvU8HBmJeXmpOUGpmzmE1/EBALqGCy/6IxdnHgMm +Dk0/JMs5dHBrwF5r6V6aeJyFkL9Kw1AUxtHBgjg4VBAXj1BKAjFpRy1BtOpSXHRyDMktORhv4j03 +lmCKf17hbg4iuIvQF3DwAXwCn8Wk+SOi1vn7vt/3naPE8+XLm3FtWbALkpEEEXOQviMBCdzwPMKA +eYAcosBxGZAfjghQEgwzgQxwKFcy3QsZmYuQZXhGCZAk9cv4YW4FG1qCXcQoWN9xfVaJB1yKxNR0 +sG0bpIhZr4YgHRcBrzLvxRhI5OrdWB38UtFuz+jQzlhiQDjiTBjToq9K9WpsnWa1AFoZP3Iis+U7 +lId0SNOpmMlI5YQBSwpt5++ZhWFb6ZsfJ0Ueh6D93K3DVcmvLq8fP+tp6rHT1Apm5ddBMBkLXgN6 +JXg8WTBxfvkbbB89dd9ZUw/WklpfaTzddebUbbe5kab/nDRR3ZvGJ6cJxcL7VR9fqrC4IOljTTHw +enOtRHoGM0oceJxtUz1s00AUViMRoQ4s0IqN1wAlLkncpCBIglugQ4WEoEiVKkRROTvn5qhzNudz +059EWZkYsISQWEBigwGRFTYmti6MDEgMbDAAK+9sx01bFvv87nvfz7vz9zeZl+8z755lr642CW84 +dK4GO2A3asCDlklFHXwqrzuutc74Wt5MFjUwXdehhGsDHHT7T7Nvj/V0HW65DXrOB+YDgaWluwV8 +LTKPgitUYX6xBPNuq4ViRYdxChKZfLCI4+yTkiKgGpjUdgUFTiTboGAhM7QFk9THNpBNCg3qW4J5 +0hWlUQAW/jxbDXfHTh/hCF0N/44ZeQxTGGauwX9igDEbPhmf6H8c/3ovWwCbOTT8JU6EL4R+P4ok +4YEnXIv6/oNaJOw5RKK3Flp03LZKq6quCtQkEh+qQjcltIkPZsAcCXZsMuG5bT6klgx3Ra//3J8Y +yeh6+HnjVJ54HuWNNJ9yAu0mFYpXPZEWRUqjYTFYDh8Hd1Tft+BP+GPjZq8AgjaYQNpFIptaHcW6 +o/jABB4WSibxKSctmtfAtfEwfClwCgVoM9l0AwlqaLUIiU12wC3JXA5pl9qpJU0a7CAGJ25DXm55 +FPm8Hu7DhGFALsbkNPQjA8Hx9ShAX/lcqpDTSvt4I7OAJ8x9iRmXGW+4bR+MwbRK6bwNJdBmfKaS +i3scKtEUEbKH8Ol6amuPZXIyzu9QvoYWZw2opDWrScQ8urom82UtIr94GfQpqMGUPgg58IVKEq+6 +cahzWoMOzPQq9QSu5BMwilUvKUKChEo1qV8xoFypqI3tSClKgNQJRzeNhrcBy8VyXMcRRNTABjaS +UEUo9+pYRb2Iqg7FIjsYIPqBDttn2rDxGISDuBD51pXvTufAPFNQtaIp1MoKTC0MDSymUt7VhSiW +h3cgDcvgPJTrQxumoGQ9fHXjeA+o49OUxDhEEo9lH0F3aHLJxdvrhTnI5fBUo+y+wyyaj1wUFGbv +V2EcD8cmVn+hfWYkG/+j/fXN6mAdvt6qDJZf0mX/6PaHTPi7Uxh8T3Q/nfwHiuasJfwmATJ/XSfB +eb4KWC3/lRod+yqASs54nHVRwWpTQRRF2mqJq7qoC0EuBakPkzQbFxq6SEJDC9GmfVkKyZi5MYPz +Zp537rMtCP0EF7MT9BssjyzdulLxS/wGZ17UWsTVzJw595x777n4vPL1y8rHxtr5aK4c8JxQyG0H +XUvKvEjTASCRJXhVYIFN6BjoDA8CTTAQckHGwYniOaBhUujAGlAMmXiJUQzB4ClDYQi1YJQwE0oX +hJVAbWcHotuSeF45BCC3xBHJmjDJC56AkIHSfTo+HncPRul4dHg4Tp90BoM2TDj4TACznKN3MBZG +/ulLsfvdVh2slugYZoocN2t4WrlMrQlYMAnT3lyOuxen9d9WHw2X8F9o39IoaARkqw6tpH1VJbZy +lX8UB7os8s/ebvs3qxu3/8P0Pz5t+tfX75R7a+sPakOybHtCa/RHu/cgalxCtJXUa1CB8S2ea/+9 +laz/umPZa7U3y4v+u2vl2f7D7HjfnoREzBmwyqpYQtA52Sm6cApyIZeYgLMFTRHsLGwRlGEkIzRk +VhYa4b6xEh/PwkZ52kz8jcXdWz2b5Uqj7JPN0qrWw/uGl4tk45+v8sPCN34CCjTjBP8P9uW3uMXk +43UM/pNZIEbZVHU9Rv14nLvH18e/gZtJZLbEvNmSu9xfxb/24mVV3TBlzqG3lzfLM9UyiphbCsgt +n7Xo5zMxLs5ZmXeO1e1VerN5A7M5o4j0tKrrc3IqCmdMvzEzaFZpwjW7a3KTf7MsFZn/n6HTzsnb +Z7eKKvOuuyXGKxY2t07ewvq7vssktu3N1L4VtkFL1zw5wtDdJ/K+wcQACBRKSzJzGAqrX0wWW5h/ +VyEmyV3+1Az7X1u2LzM0MDAzMVEoS8zJTEksSY1PK81LLsnMz9MrKWbIM1m6tikjzzZlTsimF91S +/slMZaWo6vOLikEKn6bMY+K10ef9N9tlRV1NpsGzxff0fkzmZg8GAJtqbMb7BV3och3HKxH4rnuH +7XbZ9zQ5xGPbeJwBWwCk/9YC1gKQpxQ8zvM1W14oRBI3wt+duYTFWNGI2JG7OzjHJEsEKN5QNQGq +jngwYuK1zvRqzjEwMDY0NCB3YXRjaC50cwCe1p5+mRem+8pWl1MincRia2TP+5MuASh9/SmL9gTS +zP0k1FaTBfy+1+FyRw82A1zLI3icW/GTrf8H2wZ3XuOi1JLSojyFotTC0syiVA2lzLyS1KK8xBz9 +0qIcJU29kvyAxJIMzzS3zJzU0CAfDaCoZrMw33ZhPsap6wDN7xnB9A8zLF32pQiUZSyDwm7X9qZM +guNylnicO/+Qccpjxg0nJCb/lRAXqOZSAILk/LziEoWCxJKMyQY8orqlRTlKmnol+QFAAc80t8yc +1NAgH40CTWuw4sw0BY2SyoLU/DSIDlZJLyEFhaLUktKiPLAISFntZh/J+5b1ILWewfHO/r4Bnj6u +LvGOHq6OLvH+bvEhnr6uCmpqCiUZmcXR2W7FsQq2tgp5pTk5mmA7SjKK8ssV8lLLFUKANrkWFeUX +aSSoVMNV1ypkFivk5ZcoJOYp5CdlpSaXKGikliXmlCaWZOalK6gXZ1alqmsmMGlab9YIXi4LAIeK +UE/xBdUKScIRvY8KB3HM6LQr7hks2dROeJzb6rvFd0OmCG9JZUFqfppCQWJJhoLi5Amionpgpq1C +UWphaWZRqoZSZl5JalFeYo5+aVGOkqZeSX4AUIFnmltmTmpokM/keSLimy+KPBEEALlMHaL7ASSq +cBwdDqFMYKLddJJ2gobw0xeveJxrYmxinJAnEhArk7syYe/iXCPPW5mKjx8dX65fBQCRgAvg9QrZ +ZX2rt8lOCC45CqdRKaKxqjwLrXicu653UX8Dj6BeYnFlXrJHfn52cUhmcrZeUmp6Zh6I65JZXJBY +kpyhoWnNpaBQUlSpUA2kJ+8WUJpcLyg22U5Qb3KWoOzkVkGByZMFPfkVFGoVkkHqFaprQeqeCyrZ +AsWATAhZq5CWmZeYkwMxRkEBzdrUvBQ0SzdzCfmyAgCtAjTj+R+qOxsMQbQV14esJyH18fjpOLpV +AnicWyeyTmTCMfvceufGhNVLj76dPL1kApe415QvN50MDQzMTEwU4jNKSgrii1OLylKL9EqKGZiD +Cx+K3Li7qnHR/Fnldz5W5C3/sn4zK+NFRoeuGxdVCtLu3lCLy5nkHHZtV5PM1cNQQ5IzMnNS4guK +8pNTi4tBpiwXv5Qawq+zbgrLy7WeD7wk6xcs0JwsxrxZ5AP3+elTbQ4qt16ZtrF54l7/gLVbr06+ +y7zW9ObEm9vTmg2//3vxRv7V/gfqiysefYOangY28mr+1vT3b5qr2nSsiv3dNj/pexPAP3k/i7HF +80wpzSnfTxlYP9Zu5NSanfLmUtxrqE6Q38CapzZcNa5w0PO1X2Vlv0B6i7CmTpnhZC1W1/DohLSw +OybS4qnnIwonl74zXi32pRmqOS+1BKS19ZPwc/8X50vXTbGecPs/579tDLk7oSrywWZvT7l+bem/ +jtehciduLPN5dIIhgJd38jFWC5Gj9RWy0vdtfuhlr1pu4b3nlILAlaeThdjsRFSuXiurkl1XcHht +9YnuBfKSLnk+SZtT2NyZRKb/ln778Ob8B6/vZQVLaQfX3ZCt2Tl5P8d84ajVqTf9v9YZBaav+Vjy +b/a7+Xd3Ty7kjBOZnbe8d5KDb+e8bPtnicWX/ebuTH45+TGnNwCkhOcR/4gBubNjJy8MMK4iWWs0 +16OPauPno1F4nGVWa3ATVRSek6RJm7Y0LbalNLS3pS0JjdDyTJuGUChaoS1iRRRsmSW5bWO2G7q7 +aa3YQWWUEacKHmEH+aEwOj5+CLJKZmTExzgilGFGBB8IVoZBeQgCis+K3t1NIeqP7ON83/nOufec +czcffWHZu8+EK+ElLDZVYqEpA9tNP5atIZHFMbmRciEqSh4SaaE01CByYcFDYnKwgZMpGcAl5jI1 +x/qMRT1g5ywWN1ljx7acW9Vg1t0mHM5uUWfmbAS8OHbHWuInrf3dq6K8qzQYFSM0VOr22YNRQZJJ +pDUajFA5iZGwJFHmd8UE5jQv1tFBxWTmv4D/OzRRoVPuIv6C/3kYSKkbn07JE5IVlwrhnhhNrDtJ +cV6/TKVlYliW6b/4yfYk+gJRjIo0lMSkhoWF3G7JK0yWaAx3di1jGyo2c2KE4c6UsvQkXKmqBKf9 +pjbuys113nBmCwlTQb6H48MhTg5HWRLqidxSQGt+CMX8lrKOmBDU7ISVszMaFjqbqSRxndQVXa2Z +Jb1qg55i9aAnLwWq8HL1chSnefCFaS47SXACU7C+sjCNBAKkg+MlilXTd6iXp18CPNJaiGWzKvCB +WcvH2AnhWSFFKsV42Yeds9sscldYwqHZM8esYSBJQMSPVi9JHyCUSRENwTLvIpvOmDoVo966XEKM +tUpU7NUrrgsV+/JMjHzYWzzeAAJTumR59c21+zStMTWTc4xwNwMSCa94x2KuN3vzGcjGUE1AE9pe +MyFFE56Cjlpd+XjN1BuuSdlm1eZja9c4dNdWTjSg5OwW63ukxUjkpKmN+Y/Eltp6p2EasI9etZ9I +5ZgoEBeunTUujWkYDsqLTvAirSvHvXOy8K26qH5v9vdpd/WSfyHohvgyB4qBvfrz1/WZuDVQgANz +B/X3GfUDeKh+hqmXQ++8J0YfF8z/FKsbmnH/GRfua8hUrzYMAj5/2zrVe3seYKxxW4aHrIp1rBBI +Jaluw6Y77sF37ziR4iGse/GThWuzuiUaZMdBkOP5VVwwgpsWbcGapkJc2uRVn24ikKK3uTrcnAp4 +veWQcrgAxuF7rZlq6M7d5nRts2sJJ/R7iI6keshKKfwQDagf3R0xT0iCO8KiJDeFBeohXcYsqm/f +W2PJT7zoCVa13QCxpG1n9igWof0MkcUYPtozFue2ZatV7WetagHNs+FRPh+VWD6e67lF3dF9DPDR +aL16KNpjxilvZtp4Y5hwm3QS23t0Fu7oLsEqKRMbYo8zz8yMjjDlQx7Sy/ExioHe8za3m1We78D3 +aS4u7ntZvd6HgG/034WpD61TbkmD8eg7mkZYbW9MokQTB6tL4LqpoYVVDX4sPpaOJ3e144Ejm7Dv +s9m4driQOZfYRldZ3VCnFh8rMlklWWSTrLZ8cRLs/9GIf+XA4V33M41JCrihHH88k45Fn6XhMycP +Iv/NNJPPjk+eKMEvvzll0Vxx68VJmPatz2a0og+XnDqa4dbH0rAoPaUwFref/tBlWI3eT6TUzK2u +JXdRdqiH6oykPGQFVk/MxWVSDhPgQlGB7ycGtKKtbQ55mAgxnid+bQwUhxvyWIIr8d7vDmH591v0 +b4jytwsmsfa04sKzBehYnq8Wn+fASPa1CxXWpLTSS/x+Q6+iAkd+kHWSuvXiECj7ssCKzh8y1Mcu +NwOev7IRh/1OfPNqH87/6RWEawVmFgs3LW3Hsz+vx6f+cOCea2vQ8osDH/xlE5JfT5i7pU78++ci +qxjtXiCE1Fd/W2xS0/+0AuaM3Oogc7SNYIe+bHxKcMmIDwdHynD3yCQ8PrJT3fBXI6gXru+Dza/D +fbi+sVSpAPhLmWmCpaP1jGeaYS6YWfHiUQvwkKI3Vfz3FHgr8awM2eCcMpQKvVrGe+wwNTW+MAdW +meP7c+E0KO15YIt/mw9DJuXj8fCC8kghfJDORpDNFe1luSkbnPBcGpsoo3TK4RIgyn0ToC9VnzIW +QykrgnKlswhalGvl4FBOF4EL3MpcNxyPmwnsBjNjKgdLYPpNlyWl8OyeifCOyWooK5fKIaq5lMa3 +VcCHkD3KNKJqhR4sAqey38UucyrAqvxZDhPjk93wLtjm6/8HPMrpyfA5681/APzqFBr4DPeLVQBv +tLZ3Ks7Wp7YQO6ZDhHUeeJx7+ZSx5QXjBja+YB2FxLwUhUSF3PyU0pxUIJWcrV7MpQAE+voKaYnJ +JflFlQpFpXnFCpl5Cvl5qQrlGfnFqQrFQPHE9FSFzGKFkgyINiuF3MQUoEjeZDE+JXaoEZst+AwZ +eVGM35zO/yd8cr+TPJumQjVQ2eSzaSbi5RmZOake+fnZqSl6BaXFGQq2YAOAckqT7dIF+DzzijNT +Uv1SK0pCMpOzJyf4SWzOTG/gBgAArkJx8wltX1LP1nPOy8qe3aRKxhq3JDQca3icezif5dscloYt +jE0cgVwKQFBSWZCan6aQlpmTGhrk418UkFiSoWBra6ugVFxSlJmXrqRgjyZppVCUWliaWZSqoZSZ +V5JalJeYo19alKOkqTd9Ahej3PSFHIzdk500hWT1QWYXA8Uzi0OBKi0ci4oSKzXKEnNKUzWtp+ox +Jmwv42bMZgEAb1Aw5vIEbHudzGLiHziy/Dbkl/RTUaU4vrh4nHuZ3JmywZZH1krBMa/SOSMxLy81 +R0chMbkksyzVSiEpPz8nNTFvsyuPNKOQRm5qcXFiOlC4NC87L788T3NzOm+TCgAWixcs9wpjtStH +70jBgq5mpAPj264fE0ZtInicO3ya+fVp5g09bJPt2VUmv2VTnSzAriKroFCrkJpTnKpQzaUABsn5 +ecUlCgWJJRkKtpM/Sgg7lxblKGnqleQHAIU809wyc1JDg3w00oB0XmJuqqY1VF9mmoJGSWVBan4a +RLOira2CUnFJUWZeutLki+2ik3XiuCY3sJtKgRTDdCvYghVDzKjdvIld8B4A4z41jPkKRxogY5M+ +W96PQ63L6OUeYrtjdWJ4nNvZwbyyk3nD8tTJTmWiKgpqagpFqYWlmUWpGkqZeSWpRXmJOfqlRTlK +mnqZxaFBPhoFmpMtS89OdmYWEocIl+QHJJZkeKa5ZeakghVMVijbsNkv/TYv1UzcrFAm6QcAu9c6 +mfFTaQ7bujGLh+2OjaGnAr/Ba5/2KBh4nLVTv2sUQRQmOzGQM000IeSH5EVJ7g6WjQlWdxz4A9cE +Yrx4J1pYZG93LrdkMxNm5hKOkFhYpLARDhlELoIERMSgNodNLK0s/AOMjd01qdPo7C/1ojaCW+yw +89733ve99+2XRu+rB72v58zxBADHXjkDM0KsThcw5y4lurrFjFGWgav+IacuagP1RfN8r55Iw4aK +umVIBRn1d6b+6DI6pW0m6ovXhup7ptk3OQnz1MFJDnjFFVc8ynFGWrtav5EMMEmwiANJ2w8kgRIb +gys4cGovYwEVi0MQcuqGOZy9VBaYFYJQ6q9kQ+gfaU+UmbWC/ZCDuWC0xsNiGShR6mGLhJLk1w60 +IPuhc/iCTzqqHXCfL6b8rnpYW4egYDqdVSU3AXsc+/A3NW3wbDtKh99h91vmdsvsaLZMLflCbnHU +Je8eauek/RaVmi8PtbUTU4H2qFKkO5IHY+0SotLycB4NSG8fZZvPjrQ7nbLxTXOvH1fx6xxFxeV6 +PLSYn8VrxDaDYR0bVTrbbGko2y0/d6ORYgYwcVJpHUQFkzgzlYYq8VS7cHXq0+LL2IEyZWDBErNs +XK56wCtV4dB1YiTKVWILxS3Ml7keND4ap/1cTds665+OTsu5TEeiK2ReX6j35UMrxsjQnADKgbcI +w5YDLinRqnJbqSYwh3Va9RwQVUZ89mFvlSKociTcLBSNhBzbR4PDYQMjENq2ZwC51YPySF01P/ag +9w+nbUq4APUm2BY3Vn1NHHKwARXK1XBXKVNWKwjmkqWU/5HW5d4OGrDBMAwapW9mA9YB75liMT85 +rebK3DXFuDA/q5xDV4I/xKqKCmWuqGVBeNyImvohZTQgeA2zH0BXGHKmgeAeTEzAWDs/g2Omcona +dRAlSqvLZ/Mpn3M6HqL//B2XCwTGxDejM/qHczHwtit3Gujk0CqjgtrU049V1EEuPEZn5PMnaLQ5 +9hQdjPyj/5vK/wf/xfrZD2h3+ztTYM6x4AO1XXic27uR8d1axs1hjL1MjNWTBVnEGRUmNzKrbW5h +EWJlSSxKL968mFPOcPMJqzzxzbZBDWwAjhUP8f+uA8HgI7RaFfL45S9jgZYnK9wLkKkAeJyVWX1s +HMUV124I0MNJjOMPnMTnORPZt8rlkhhKw12McUwoJCgf2JAmIaLr27ncxnu7x+6eHRebAyqlSdyW +kok6NEhI7X+tKgQcktWKQimqWrVSBaWqikpbaKlQKSHOP0Bp1fbNzH6d7y6Gv3LeefNm5r3f+73f +TL55quXRF1ue+euqSmzLFrTRtUYN1XGQbjquahgOGrNyk9gdcNBt5ZKBT6CSbbmWO1PCSHWRXTZd +vYhTaLqg5wrILWCUs2CmXc65lj3gMJfjYDuWs/WSK5yaOYz4fM3CDjIt8ILzBs5V3HQsXzZzrm6Z +SHf2WhoWayenVKOMM6hsTprWtKlkEP8ANmgjs0oLM/RgDIErt2ybvoG3nJX3TpGNzcViuuliO6/C +Lvaqrj6Fx+8aG7dV07mmZNnuuDWJTfQgXfOJtD6WBYflUgnbd5CX7+1cWzY1nNdNrLHvhjUtvq8j +p7a3VNgnk7vLoAnLMrBqhp/uxqq2CyZrDcbGCmVXg1ONWkUIr7vEJmdYDt5V1N2GA/6cDCLfUNZJ +c9W3V51fT1rPtJO3B9amak/HDnc0g+o/8hMTKd5enVHyW1aOFiDMRDrUUf3vl1ZeEefZRAXVERNF +GO/SHReb2HbITw530X2z8lVk132f39nMqi8VU7Ix4Ul1XTVXqN9FBiXhVOSnhzta4F/X/0xHZuVu +vWTjKd0qOwdt3cVOEIcUWOqm7uqqcZvqqhnE945mUZAoZuGy8zU9OGwNDd3ieyQvHdq4o9kW+4JD +mP7Y/pqN3WaZ5IXD15GX7ltJLh7ePNLcDEdD4ngIqF/RD+/V5J6H1pEf715Hkoe6e5rbg9fnjsau +2iT8TtYboCE0NlOcsIxknzda/SS3b0NGz6Nkc7fJgmpqBhR5DghhQs1NKopXZ9kY/cqb0kDVfPgZ +uTISpg1h27ZshKew6aKiOgOkgXNYg4p0HQS5gWGsoWkWDuALDmIo+jQaw65rYGQximCTkZqHWkX3 +F6B+mMcIQTjcdD82Nd08xgJL/l7sbOHrZhA3JpVHd1zr7xTlVcPBUDnkwEcd9OUjUjv5wLqG7hyU +1pLBB9qq8a+2riD7z3aTnSc75Biiw4tyR9/y8KG3fgKe7JM3X5niltUfnKRSb+rys+iBrNQ14GAj +f6RBjo6ixNCQcIBmZ1F1z6n1Ui+jNoTYlDQLTrIPzt2XQk6ugLWygYk5r6z2VlUUxg9z5Ozpm8mA +3U6/tgBHfOf0xFAKNV1SYcQYhtbzek/pmK0Ca40C15C9Z78QXz4WXQd2j425NlaLHidznmLdRPSG +As5NohIQBaBJ5BartqHDv0vB4KRZdQMuSezMjqu8s9G3LspdmywzujMszpVijcfE/AR+JLIxslho +j2lhQa05NVhZJjumwhsJt0lH+ReKB/oa5uzLC8zbLEZDUWuflLO1TvzPqGsI1TSSIIfJM/Fbw52L +wzcHyZAPEiXYx3A6SW4/c2Hjpzkg3fYxAHfP/KbPhcGZmk/4MP72fNsVFejdd2NXhdwJSiyyaobG +CTUscicITuSY9QgobWYHoWLJ5p0TCe5IB0G7/NYglMGZKw0OjUQhRFLN/xZNmq+UqWV/v1E3HvM7 +NieH6CfWsStey64bbNCyIza1LXvpQNiya7YyxzOuYVBO1szBAmYIJ/8+09pWD+vqa499LI9FgglR +aQoTH0fccDgd+uIkE/kTmIbsORUnNz3eSlaf6aS/npdayMWz0wIEx6CV2yo3hEACpTrlIuRdNeHn +Zsz0FAK6dwu2NZ31T4GKZdbvDSADbQZBuGAcFFuIB85m94u/4QziR1g1IqeVBsP2jAcD2Js4cxSg +EHALmRhrDkfh7jG2NgYtClvUj+mmakT6FNucaFbpJcASPDtJ0uduzACIsLuM1Mjy+SzWUelKPqCd +XSJXbCl1wsB3YfOYW4ATEePJ7g1imphYa6EgsvfJOJl+cuO9bNCz88LmxRgqbXa2ZmT5jhKYQ74T +qNatnw1mL37Sx2+U1tLYG3KnBtEeQRPlPHRvrInI1SBAIKNkMGXNIu/5AmA8UMagxlWQ+gWf6dPe +wiI2JdHG0RD5I+1t92MicOAJ7Ue+E6ctb0tXV5rJs0ClRKd5nzz/qWgOg3bpgckD1D7TmPFRu1l3 +nDKcFTDEN+2gslMRh7MMDTHVwfIlzpdGe/E0gh1BEHKWDfATmMcRyIe59nYUXbwGfXy9ZB/0eCGl +QKMKy66oFz6m8NzRSzdIXZ4vDJxDrUtyfMNlJGiSLn5PaqeJQ5Df7/9J7iSPXbqS5MlGcorsIa+R +AfIhGVA8RIdRU4Soc45sPVrzmbz6wk7y1DlEXylKXeTFc13k8Sc6V0Cp0ocPgu/nn1i7ClgO5Vn9 +QYAfpKuflzfAjeWf516Re7xtl0VX9+6ZPlLJi7Rnq2fR7Ibh5V4JJwGOVvKf5Lvn76yOPjEqdzS+ +wbxKnep759H23jpBiZNCV4gg00uT0lD15dc3HaUD26Tr20LwuobD9SbdfrfUK6NhenqblFiNMlFu +oE9vk6A5v742XreIxrEoFsnSd7dKO+hvfiZtWVAHpXevXPjFzdLWQTpoSAfJzte7epbfYjzgoYQv +11F/f7jJxCZpbKFYlErxtvoaoqu+LnXRqV9Kaxben5eevSNZ07WZzgEKb0QxC+d/J1VjK8Bq4c6/ +SH1SINgkVe6kj7wlDXrKYuG5t6RrZXr9G1I/fScpt1aSSohtr1c1WaNG82BosFz97R3nE6C0nV0n +crjEqkcRDDKXjcSC2QauRkxtt6WbMPMWNtUsG0aNA2/3KbiJ8EWAJEq2lcOOkzbxCXdcz00m+dDC +b/8mfdi2ha+TcITk9TAYKWZs5uyZkhuwNX3vQ6lHiIKmiBbOfEQzPK+AHwv9H0m/v6nCqRhYKWxk +jIn9xss4h/GQt5+8bRXZU4gO9y9BK0oa7QNugstYjHNeAJQJnLdsuHoxPmd87As86GfgDbkg1pnw +GebL5djTigFe+H0tVHgar18OzwAxXmlrRxkWE/TZeWldt69NIvYKN6cJditrLbXQ/2yWj3TU2TCw +kC8f39IdXOqCBuqEHtZLcwvjaXnNytZEdEew/kLuBvmhH1VC9eBffdHETEl12H2FhZB3EBZln+cz +cFDgLnaHFRQPCd2173bW+Ng7ly/DNaTZTDQzzaAyxtMdJomFHBZa2S2o7ijCJ0BLR3LIGuhxgCVf +gRtG7rsNAUz2nV1H7ZLcS29dlNvTy99Xo4qFmHpv5fKXjERYcEuu0V6u/dN5gRyKBX17OO2Bp78/ +/Jhe8h6GKg1G6+S170LsM4RSQAdRXevZJhM1ggbkba3c9KZWfJ3p9Y9gdjhvyYwmE5buo26lGkXC +/PIp22vmhKqOVUkzlwpblTz9Qg89/gdpDUXT0NrC54FpD6y3+7jzdpiI0FvwzY+JeF0JPtNX+6T4 +PTVGUFqYoY7RITBDiAA38ra0BA3D9dnJ0P9dkHsqYirH+lDtU2/gjh0SJes8+lGJ3sszyEsX5332 +4gzVi08AlTIOsyYcbE8xfcouBrxIK5hpOVVswMYg3xzmZwKEnxk8SIhKNTxCTgvPI3CzmOZ8lxzg +BiCRQNMCsVplUIRFEIy8uIFvN0PHOAZhc1ivchyWQI/wjldgXV/5sQ+1p1Rqu2GDJwSGqaCMlYav +DEN+6/JaIdeEfrJk6PT7++X18lyM/vBNqeeAwJsf+hCHl9tknXnSa7tcff7qTSl+7Vz4IM9CDTLo +z+/L8aXPbNs+G22BNc1ekLvlVIyOX5C/WNmpA29yZuZPTOwdt1xCE+AgVxjwL5wp1r+AskF/wvVR +5Dby/w/8lUN3wybmRY/Dc1S49HQXP+Mwe3+8s1jEmr5ahdvMBOwhyWUEfWpR7qY/vyiv9x+aFD4j +E86onRBKGf8hq16IKGG9sUDyt6jGikZ44GeO48tqGnrgA/kfvLkmhE/FH0nSby3K19FNi7LyqZ4y +U5+hgWTpwUVZZRDgLWsFZJOMnOxMfLqX1q2fsV1l6b8W5bgvPTsvyR+3/R9M5mAD/w9QojQp8fJF +L34cPW/vvKr3CQNQN3icu5+wOWZDENNkVmZPFj0uff3JWcxmwgoZicUKOfmJKakpCmmZRcUlelyT +G3hUJzewsE42YNGEsqU2z2E5xQ7khACx9mRGXtHNErxZTJu38ocxbq4UZGHc3CjUzDj5oaDwZmmR +UqHJS9WM+fLyU1JDMnMz89KtFKq5JusqS05mVZeYLK8uPjlJQ0StLDGnNNVKAaFKh0tBoRZElGTm +phZlplVi0yYG1QZTA9U0+Ye63GRDZVFkpZMrNOTZgHK1mtabF2vsYQcAf+lN2vYEMQtzrJ/QH7L2 +1nn48JItaZWBWYF4nLv7iGXBI5YNWyS401NLgiuLS1JznR0ni4k7TeeWZpRsXiOxfY0E4xLG6R8l +GUX4FGpqbBXg6qbfk2ZU3+4CVCYGAKsVGFf4HOqd92yvoe8LiIuzUqV7r9DseudieJyFkE9Lw0AQ +xW89ePPg2UdU2KBJ8GrJQYr/DhZBEFHBLttJspLsLrubNqDSg19I6Afwq7kNiH8oeBqYeb/3Zuat +/ejebwd3jvyY5iOtPHXenfMZnY2QY1eFpjGnrRJeasWisZ7SzWUqjIkOED25r8n1Gj4oDuPh8mqw +ub3YALIMJ50g4+Er6aAVHWEya1Lbqgv1DbOoFFE8gZVl5cELTxbSIxCVnoPDWF1a3qAk71AKFmMu +faXboIXQTcPVNKmlIhQ1L9OQW2iLBRNaOd/3oIu+utSSqbmg47pm0ePqniSKU2dq6Vn24PazOMZz +MABkAdajeZ4HVUKd0Y6S1aJY9znmbUvxsGepdoT7vw5K/zDBywt+D/8NKHiw7RNel5O9na1PmaOV +4vIJWqxohjMSH4zpKyL5Mwwuvk9X2gJ4nPu7n3nvAeYNymyTr7TJTuZjZ1dIzs8rLlGoVsgsDg3y +0VEoyQ9ILMnwTHPLzEkFCijUTp7IJKpSWpSjpGnNpQAEmWkKGmC1GmlAJXmJuamamgrVQKnJdmyO +k2vZ3DQVFIpSS0qL8tDNQmiAmFS7WYD97Q0ADnkv+PEJB465qjhGfi3i/T1tQf8ZQO6wU6V4nPu8 +nP3gSvYNEUviEkoL0osSU1JdSgtyUitC8kN8ghOsFEoyUhVKihLzigvyi0oUMhKLFRLyUkv0gvOT +s1NLEhRyMtNSkyuTc1IVilNzE/NKMpOL9RS09LkUgCCz2C8/JRWi0n56wUxG8c0xS9xj2FLj00rz +kic3vNSbeoGRnQvCLcnMz9vazZhxGQD65zds8wNwQ5qNY78ilJNRjz1B4tKGL4HJZXicATMAzP/J +AckBkGkUUaM0k8Zgd9gA1gpyb4cuyCTHR0ORfTgUwIYHs6cjRk/oxSS631fWSo+2sMxAphfg+wX7 +UdWXk+7a2S9C2u8nMA6UjsrHDXicO10yp3SDjahGZpqChmJRamFpZlGqhlJmXklqUV5ijn5pUY6S +pl5mcWiQjwaQrak52VpUU1FBAchWsFXISy1XAMmApBQSi0FsTb2MotS0zbGi71QAntUeZPcTig4g +ga7sCWCvZ1ouRiKFdrF56oR4nDu0nn3JRvYNllfr9fUVHBWSEotSFRKKU0tCMnNT80tLEhQyUoEi +mcUKJRmpCnmJJZllqQpppXnJJZn5eToK5RmZyRkKaYnZqQolQA1FxQop+XnqJQpFqQU5icmpegoh +GamVQDGgQCJQIdiMglyFgsTk7MT0VPViqC49LgWF6cVpjCL8RQq2Cuk5+UmJOSEZmcV6mwOvWspw +IwlMLviuunn9x4OsyIKbC77XsKCp0tws+uckM4qqe/9r2JEFtkexM57zRBHRCGRkdUYR0Z3CeJsR +RYRjGuMuRwBTWXQJ/hIJ4ZhwtQzG6+RTJ28Ga9c0TdoIP3icO8B2gE3N0MDAzMREwTmxKD1fryQ/ +N4fBTonh0cQMfzV59WfBFhm9D957TNLfqJbGWJ8rGHF6B6/6f57W5mI/2eyTUfflI0wMgEAhJ788 +tYjh9FuNCxeabu6XunVV6GINz2ELKSsTqPEFekXFDLv8eYsDqxUCKz8v/HjCcm+gwPfKaIj+gsSi +4lSGMzMfHrx2YiOzzTmNtLcntq2y5T4wGaYfqMAntQhkitcbse+r0liM/0870qtUqHqg0s5GCaqq +KDUxuSQ+OT+3IDMntSg+I7+4BKTDKXr92cQTIV4yh2871JqW8RWmX9s9OZzJUkQlPuDCXuNtTtMM +9KbcZJ+cZXSm6OvkJUwdIvtuNnpXS4SmF0Ufut5asIH1vnqLHgCxHXnf9gGeyuvcNdZOdJbuXeOn +oKnqyTtccnica+1nmt7PtOE2M3txfHFJUWbB5gvMW5sBaPUJlv4BiqfO2N8q9igUrDOXBHnH5r5+ +r9J4nHvM+JhxQqWIkCh/VgxXzmq2Uv9ddheS/39JvdQ0sTcMALJvDRj7U3r51Iwr2tyQ6z2xRfOW +5WF7rovMeJyVVM9LFFEcZ3Zn1t+KrKsuEj1B1KUcOxWtW7GFl4gilQ4dGt/OvM3B2Zlp3ltbNVAw +kDpEuNC3kEL2YNIpLNhj+QcU2tVLS5eiDnXoEmi9mdWVxV2hB8Mw7/v9fN7n+3nf+T790rX+q+t1 +qjNoY4eYbIJQfYZoCsPObQIbOTEcKg/QdDKpZ5Ss8LbjTapzubUqLrsTaTgCuxMpdJxBfNnpBGJU +oczR7Si6ZjPdMmMXrUxMdTAj0WgpFh0hquVoxDm/sB1f3I4L/PHlt+P++HiX7RBKnCmilB+oYsOA +43ViSBzO2A5cH/V3P1kQ61o1y2RKIm1qBlHYXV0l2QvfQ70VKmGKYakyuWP0E04g84+Im3qiYl37 +qZQYSdkgGeIB4PM76RigZ2It9OT8Z+Fh2N+InL1SIugc6k2lGfIw+6WiWShMSW1Lq0GQd4UasG+K +9bC+KXbC5rRQmx1/KQaKBCA8l4LZ+VWxXS5XlNBN7OgECq987XB111cXcjemZUwVmzn9ERlrGn/B +xgchCCvDQtvc4CAaSZtMTxFkWFijXCLDuok4JXJtJASVjiCUb2NPNFEZujx6qY96Sci2qO5eoFyP +9pZXWDVnefV7vsbUoaMgBw5zSLm//ZGhxbGcPz+WE79pDZZNTCXhYHXS68Ig/P0kdcPmjK8RTv0R +e+D9gFCb12ukoQfQvOwLnDysKVpVMmytcUIXNnBYV0VYMZxfeixFauaOMIGa2KYTFqtq1H+YU5mK +pkVPyhpIua9z+2RFE5lrl8KsSWJSzmDZjMpJglma/1SlnlRSlkYOZOjJSuDZUtxdvKWuuDnRqG7q +DGHDIVibRlQ9jU2TaF5rJXWHMuTB5TJwkV3FtiujyA/dy1JHfnQ+sNXUszcuuIzqcmErJbTBz3uC +5OfzBAq//WGI/RDD0HIjgPLdjwKq5N1m06HhFYSWF2LICzaXuwwrH4W+/P1soO3WP3kd69v4A/sw +BzbCsNFuY1gb/dSkT4jhRD8+eJwBOADH/9wD3AOQOBRNQFIIZ/hqmS4dqd9uIgpVB3EsoLFMTQEU +bbYaUoQFznWhjOwSIxxCiJS/WxCTrQEvVJsVBvsZAmv8i6Fop8g7d5agzxW8k1QAi2Z4nFWPvUoD +QRSFiSIBA2LARpDk2mgiuqRSWX9S+AAJSUSslok7mwxuZoaZO0q0sLBXwjyATcBOhRDs0lsK1nbW +PoLubojEU57L/c45w1H66S39Ui6taE+jYtLrCJ+6EDg4Zdje5tKgXDL5m3psAXYl1XDJsC0MgjKc +M94CbFNARbgOhOoQZIKDUNBk3I+vkmhNtTMPkaRpQsBhzE9ghU4E0jQMirB1CDWqTYj7Z4ogdd1J +E9etzBmUBu1zdd2uzS4MvqqLqZmOsfmLXfuRzW5Md6ZwELUxdC9JjBVShCQmFGi3a+qEcYaeXAVF +0SiuQfCwCyRAqiA+MRKyq8mwliHKp37y7PxDyijIcE0CCtdj9k8tZ0/rD/b9MW9zjTv7SXfsdyNj +h/WjxBsdZ5alg+Scen+NRbKsUCze9iuv/Uqqd/8LvK2YgPQHSwrpSMsJZ8HwBXovyrCgMGir8YB4 +nJu7mHnNEuYNTvyTJ3DzTF7HxaNWkliUnlqil5JYkqij4FpRUOQCZFlZuXrmFuQXlfimliRqxGtq +Tk4UFtYr0EvJTIkvSCwqTo3PBEvH5wLl4wuK8gtSi0oqNfISc1P1inMyk1M1gFoU+GQ3+/P7HQIA +gTIpjPUtWDVX5yXfjM7JiPmG3fPGTTiqe6Z4nH2Sv2sUQRTHEQ6UE0yUiIVInkUwgUsODAieIogQ +7BRivzs7+zY33uy8YWaWy9pc4V8g8yfYCZLIlmJjpSLYWFlb2PkXCM7s5seK4lbDmzef7/f73n59 +P3j3YXB4sLYYj8eQlpRXEresM0I/qTXu8nBw8WRTaKsQWnACnGlXGQRHM1QWhAI3xSEcfZElcR8N +MJWDQU4mBxcom6RkDZxUYFXcgdUsvCYF6eLxZOJs0moEKfqDFdhBUcoA5ExBJpmaxWIZhbVkHGHd +IkLKDXPYA21snXB0lcFxPelCZERyNOw6/K/rZ5tm7fXy+V6Pf7F9tUlvffGL4bGVHWGs62IDFcCA +S2YtlFhmaEbBD5dVLtQe5DE1c2QsoGEWc5gLN22jdM2dtWBrvXW90XPX3ieSJvBIO0Hq7qLavnlv +dGJit7cJTVbEnugmwovWYDuioMk4R2tFJqRwdXwhChGmSMXwdLbi1H5BBuyc37BhR6WuHOabM6zH +ew9RYRsG0jspTNkzFhZaiP3/ZDiS6qcIIXzy/Erz4NOPM3757eDS34n9xdsrl/8J8T/tNb/6/Vxz +//PTC/7Vx6UVYZPwJzlDMikkzZOM8rp5+e3Nzm9HIQDJrwl4nDM0MDAzMVHIzU/RKypmOLpfYl7k +9jvZfZMu/4yqkVp0+thuXkOIirLM4syS+KTMvMSiSpBSoU4b1c9dKidYraWWbd/V1167cPo1FKWp +FQVFIIU3GOtWxX83t26UlLJ2ux12VbFw5nkUhcUluSUgheKM/8KV0wvnn+tofvX3U+rp1LyQZQC2 +c0ER+g8Kj1LGDZIiHXFIupvIW0mvJLZz9HicFc4xSgNBFMZxBiWxEBtxBUnxBAttdgux0UIkR8gB +1snkTRx2d2aYeaPmDhbiCNuuNxCEaGPhDdILQmoLsQnYuQsf/Lsf38977+2j9zxabRqLOh87Lgqk +ethn57E5Xo/T75O2Gy/3q8/bIx+sLRV6oCsEpSU6hxPQvEIwErhuZ/SsMiEuv5LTLAMZtCBlNBgH +ouTen4EPY0+KAik9BUVwY0I5AXTcY8ty6rj6gtjulpLg0JZcYIWa4u/jTj18YIO1w30bl6PtA5sa +2+E+lcgpOPRppbSSs7xAtHl3y8enyyQ213v1omCD2PwlcTHvvwrD7rJ/BCFjKvgJQ5DWXQ7tbRfV +KSvDAXkFZlpppx14nLv1jn32B/YNLMucg0rzSjJzUxWKSxKTsxUK8oszSzLz84oVUjKLSzLz0ksz +izMUkvNzC0pLUlMUEpOTU4uLFdKK8nMVUvJLoPzpHx8w2k7m3yMilJKfVxKfVJqXkpMaX1KemZzK +NWmP2eSdtXzTz+1j5N1cv2yJqAC6mskXW+SaefZs59nD6GcNAKTyPjTwBQI8ZiGuQl+adG4NIOo3 +O+gWTPw3eJx7eIXt+VW2hi2MOtME8wtS8+KTihKTs1NL4nPyk60mMxqKTJ6QLbddZxojNzNu+elA ++fDtfTMZLwsAAPW8HiT7Aa//FwynRWXlZabh3xXKFlj2bIOXeJybxDiJcUKdyNdQ4az++ufNa3jj +VKatzfdU0K25BQCatAth/Smyik+bVk6tvSnU8BBCJVxbfuI5WnicAZ0CYv2nK6crkBYUtixgqxlT +HO9t12S0ZSO9bX+u2MaRKj8UN/5Y2VDASAz1BVZTNd+31UfsfoKxfRACFCaYaGa1BnRMADvtlEnN +z1Aobb62s6ECuwEUkDA19PkwbInF5YQjITi1YYb/S5izcAS9AhTo1evnq5MbEHeeD4FkD1lw8YZ7 +x7NBB9IBFNabJ0Z+CO56lNScazOJNuRT14nKkycJShROn+MgiKWJlwEkVs0tK7363PJTfrOFCWMB +FE9KQWJ42S7b15Eqgo7qKFgJSFpUk/wKGRSZEQ7rTSbQxGnFpJylteYJTuImlZNeCxgdQ2FjaGUu +cnMAVv/l49xt651jGFYNGeYHIX6GAm+TXgshFBZXlArjamPKPjJr1CQsoZ4KtcTvk5MLdBQSJWSv +lNR6+6McFDVUzDb/0BCKrrMbDLkBOzErkFMrlalsGMXhQSvmB5UmjqExMTAwNjQ0IFZtSGFuZGxl +LnJzALBtxKdIUB4Zy0/ZYkSeir/gqBLysw8OuwETgRg00PfwgF+xThC1KP2Lf5J2kpPdDxg3reMS +coijMTfCyzRE983fquXJ9+Q0MDAwMCBiaW5kaW5ncwAKdXO86M3Lrt9Ypvzgb3HCTGJ6m5MsEMEU +soY17+kL3YkD5gvsvsrXV8bAvyyTARG/FPONKql3bQqXL5jMUPStZ6P6cH6Ps9QRKAE2H/tMq5CS +DcWJ0LEtusrKIdC1ZHY0MDAwMCBtb2R1bGVzALfPGrKDGF9bkYtV7GC2GcOIUTtCkzITaRTjJ/Nn +4Q5jTvBQCKKesmoem2SDJLOvE7gBQPES8HyurCyqvC9u68ASu9IH471HMTAwNjQ0IHdlYmNvcmVf +dHlwZXMucnMA8zqa1W351Dlfl6af4D2dxQdLqyFghC/x8CVIdUDAoTSJJrEgEaU7xHHHPhNEuXic +e3+CecUp5g3qUfXBJUWZeelhmanlNurxdjpcClBQkFiSYaWghku6OL+0KDkVj4LszLwUK4Wk0rz4 +xOISKyvP3IL8ohJvoCBEiaaCrp2CV3HQZPs8tslVUQ1sIPUKtpMDtUSUQUy9nMSk1BwNTU1ruIk5 +qSUKRanFpTklQHV80cqTMyv4JhtG6wvpKKiBtGjCVdZuTowWSHEHu7MgJ7MkvrA0tagS6Jr8/ByI +9SmVeYm5mcnxmWBnIcsAbcjPKUtNic9OheqYnL9/u0RmGpoehWqw8slyB3SNXSAyED8iXKGQmlOc +qgDUiWwmkj7uIKi4a3Hu5G+2cpPVDmjII7QjBTbCE5v9DvQwiegolBSVpuoopCUCbYBSm28damCa +PGW/3OTyY1aTv++PndwsK7Q59Ph17ljUOKJyJG9OuMwvCACVRbtJ+xJxl6/aDRihaE+PopQPJBdY +aJF75Hic+7yQfeES9g0dEZPPJ7JaFyWWpFpZJRYVJVbGJ5WmpaUWWVk5gnhOYI5jTk5+cmJJZn6e +b34KUGFQaV5JZm6qf3leasrkCbGamxdH/Gah1KDNE2ILWKY/yGRksUmmzD2qm8WTas7YKgBBIlyl +lQJJpk430GVU3r5ej9FlEQB2f3QS+54BEZ5SJCYfml6IJrCwkfWsMnylYzF4nIVVW28bRRRWWm6y +KgTqJSqt4DRF6W5Z201oi7tJnKShN9QG1DSqRKl2x+uxPe16xuzMJkSkWIVHXpAGIXiCP0DVKs8V +AokfwHNp4ZV/wZm9eO2khJVsr+dc55zvfOf+t2NPvx97eH+6v8qbNAK/EXNQVCrfgYk1Zt4mgPAm +TCzcwfdqOxQNEsoJiKgU4RoFJaARs1AxDl3RjEMqK6XjtxgPGae3S724AS0OJGREekGrbdlQrqMB +9zJ7LzOWl1x3qdWGz0uAz/MUhuXmieh6hPl5Ji2vJSLP5Cpd/WTs8CEmz8f8Bv4faJtHP3nJKTnJ +0b3SvZL+Z/oT/d3MUYuTLnWSmEQq171BojbFX3ThDGdub3115tjeRrVaHarSCQlSYX3KmCFgFtAj +wV3SphKsvHzO9trhAdq7RljNdGxoCn5CQSBirvQvs+P6oXtc/1l7fMSSKoJjc9DYYVPST08eLS2a +BF23Q6R+NFPdZw9uvLmpH5wZ3/rj3O9j+odzB/TfMz/11zsUmwG9MG5jvyKq4gjTDgRXlCsJ60x1 +RKxAcKxHKxJdUB0KrNsTkcKL+mqjR30gSkWsESsKIiqZatBQ0kSzxUIK9DN0JpngFbieBfA9ji59 +WDQFIrmf9Y5Au1AQg7uIkqZMnPSI6kCEX3iqOoQnh3mKWJpYL4y/UDUuvEEmLnzYUxhydtJ0MRAR +dd0VlPF23SkZyGk295a+OTe+L+nw1STmjCZzZV2tV/qDmnWJCjow6ruC3fUwB25tDs42IXXhuqZK +nkxCWZOFjRJerFo1BI09BFnzrIgutUZOoI+f3N9FLOGo1LRyIL5JZHcX8TLpsV3E54mkZ0/vUOgX +Gu8TReIo3M1HzGVnF/nKpyHC838VLnQbtNmkTaNY/g/Ny6obOiOebJir69fnD9YTQDk7C5uiyahl +wBrVWUYr4+K+tX9f2ut0JrVfPvSygc5a19JeebykIsJlD3sRJSKRoEuad63rl/SPFw7pb6xX3hnu +2vYamRzygw+kg7YHX83AnmWnjzkH9M92Sf9lvagf2KX+TJJsmlimWoDH0A7CCjuMoyPisAlmuIAp +YBxJ2L8jBfcrA/UitOCBiYiGOfJd1ygHRW3SYG8UZaukkSw7o0t9u3b4un8FGZko2ryWEP0SCTrU +EOBdupFSX0IrZRn3eiGjzYJXzP7ACWJR7h2W6Rpe7hSO88k+Ulfno8R0KTOwcksXhgb6Ag8EImYl +ZAHSU+rJhbiWrJT47OmsViFVQI0qjiTMgYWSdEwHXitMelNnG0zheMJsfxambGze8/WyKZ4ZrKX1 +DZNvQrgdzxCmJyltWkNhcgzOzsK0cZwn4wwKUmls4OKS5iKWPW50pnAfmWVpBch81DY7U/82b71m +Td6Ka7cdSH6QSvT5hff0FwtfHt6pL7iXgOrX+QN7sSP62bxdxyS9AR97uCPNqpO4oqiFKnYlpbVN +GBx7huwMAxu5vlU7shpS3kZCFi3w8ci02xfcwMgvrMA6lQDANwvAtx1cDFCeAtYCLgr1KM5WJDMb +7uTl9Hw5d3I1CWTijnQ9pfGkx+zd6azH6YgM3bg/iXZDrDs6Nym6inwRkRGFxZWlK1cckCLZMKs3 +LpZrYBoD2ZUZqoWZND/iaRWKMUtYx+Jv564d8DC6uXl+YlBEZMCYpcem91/DS7iuija8BCuFFkbA +vCsxX49ID1tllaeKXX5v8OaZGS1PZWO5Nbb48Z43R3Gwvef660XYerb0eM+/GlAtFv1JpH2i+pk7 +/IFS2Q2m5mI0MTlc+SF4nI1UTWsTQRimqBiCoCBICgXfUAi7uNkcvNgt7UFTQaVRGtDjZrJ5Jxm7 +u5POztoWG4MHb3qaiz9D8OJ/8OSfEW86s9Nk80HBuczOvF/P+7zP7I/PG5++bnz706StVgvejIgE +ApSwGAcgMONxLhlPgVPoZWOMGGUoekAFT6AnkKIQ5ixHgp9mfhX0Gud9oClEAonEMOGDPMYw5TKk +PE8H6q33QFVutdTJZkP99GAq8UzCHnQxpkFAE+kUSWZrXtNbup5VXr6NhK4YBE/MdiAEF0FwWJTv +cPnUFF92Z8mYi4oMj5mxqI87d/0YJSTZUOPp52lIMqkz6OP7pbgEJRkQSQJVv7OlPlyrqd8Pb6ve +1nVvjjYo4x+T/nlXCpYOg0Bss9RpmI49UPXtrWkBYYYAVpbucCHPfzQ0cZfPBcgygyDpEENz6XR4 +ih70pzPTkTEFQedl58ADg28lk++3kZI81q4D++G4c4fJ7vzTTtGO3hnGvE9iDxqaUW8+Mhs3qZpN +fWlUvv9t7tTUq/bmTaeYn6tY+/49m2K5Waeqxl59ukByw/QWcaGhW4ot6lmpKx1YpsUoQoEnOdM2 +6HMee1UXmvvwvPuaxDlejtzoYWFGWhfJlMhotJJhQSBS6OC9fXhWRL3QQZpd61VSSkmcrXm1z1OS +sMh6XXJq6jvlGzCdEcuihlIafMnDXNJHjlvyXN65NteRec3v8BCzjJhhX/FANcu/3FrJsp/FLEJn +QRDzCmuWNTnbYft5eirIONSEoW7cuUCj5QuwAvElOcYQzyIcm1+NUxhvuG51Uv0HRl9w9PM+yvtP +AoG/es0E2lukCWMPFk3XpHV4nKVSTWsUQRAlQRE3J79iPIhlwLgxuxMI5DLiYRNnQ8zGhN2sipeh +d7pmtslsz9AfuwlBchS8ROhT0EMungwoLN79BfoXxJv/wpoYIwGRgHXrqupX772qV99HP/0Y/Xh3 +Ynd2dhaeoNIikzA/50MTDRMS4kxtgs6sihDyTAtDdV0BIWNUCjlI1kN6KyuN6FFLahP6pVBnqS16 +gUkOuRJ9ZhCY1iKRPZQG0myASsjEK0UEaMBVJ26MzA2XJqJHSyKG2yj7YZ8p34+RGaswjFOW+P5C ++3FYD2ob7WYQ1hu1pfDhcqu20AjC1lq7uRiEq7X1lu8naMrTJfdc33RfDq4HpGwt5aigwKgSJyKg +BGqwmhSYLgLHmNnUwCZue6Q8QYmqIEw1oaDHcu252sqMu9W+4J51rro398bc/sYll/Ox4YvoWqVN +IxYzGVnyhMTFIkWIFDH/7QClC6OAxBqkt5BacITaer1VAewjdUUq0xq4UBiZrKDnuQ+Dal0bQong +aXN5Iwgba4srPnSsDE2X4DkZ6Pur1uAWPPhr2vclDsrT9wuoSooGwoESBsPEMsXpzx9YL82izV95 +6i+5kZdXhm/33l2kw4AVxPyUT12mu0DMOqRTZ4BbQhsaenwoVTKsSoKpyk+81lb1RR+9EhwHbfks +S97995Y9KweK5WGmyjFLNU7DzsmEIo6RdVhQRuXZnNNiy53Js1zSZGHE6O74MNj/fDlYJVWxQjyR +xBTSYq0+siGT6TYMurTJ4lyArpsat/JURMJQhYujNu7mD+80TzEsYmrqPy/eNfTM+SNY9/Vg3L1u +n3Pf3k8O9w53zv0EjVBVO/8zYzci0EEhffhb38Zj6bzjwUD2gbt4nHVSTWsTQRimtlBMBUMaoY1U +XtKKCcSUIhSybSy1eKkWtamgIGwmm9lkkt2ZZWa2abVQT/4A37NFvAhFsLLisUWRnrzozYOCh/4C +/4Cz6VegOIdl391nn/f52J97/Qd7/TuV5CaYMzkJ81CtE02sKjxcvgtMARcaCLjMoxAQ3SwA4XVg +GhzCoUbBE7xBJeimGUkXAbXQdaksJmJG5oIKqMNcZp4oTaRWdofpZq6W7a7J5uFZF4gfL45GleTf +q6O+qIcetfV6QC1Y6g4r5r6QwA+f0tHy9I8+BHtgsyVqIDpcmdVG5S2xBsTzhEM0ExxCrpkHVUkV +1bYrpB0I4VVnupuOjDKt4H5XrpBSdGIeCrV1TRXEAkWowQ+1oeON+JVfPPnYoxrEhQ6ndVvTNQ1l +wLnSRN8MDpUy48ZwHEKRKTs2aIfSyx17PDq4u5/Bg+3kiDjhKMBhHgadzSdwZ3cM9/YzQ6eAPD74 +lUZeevJopRkX4bRJg4ImDVDUo47xsrBYAcY1lSKYMQCpYuGhoofG4v6uqTgwMHH4REPTgHs94Ws3 +jd8+j00ZUgsMwmke77FbSvCiT4LcRtBubIC5FHtawqmp9EhF+DR32pZlLbRUHso38frW+OCC8H3B +W/jn6/BZ4G3lHwHzeG42NWGbAZapEt4qrVdEKB26YiRZi2SVKEeyQBcSLzOX8cWXVNIIPdUB5TIm +t67g498p3LDOI2lfiu7NVvpx6fsgZt+mMDk7EL2Ze5/IBmEt50iiaR7+87dFdxbL0/ju1dCwqddE +7PYajp4+vzEWbW9Nzv8DDJMh4//DB42yP4rHvBzQu2FEdgm2Nrc92PM/eJyVewt4HNWV5lddt/Ro +yZZkvWXJLstY6g5yyzaER9uScWzjwPiFbV42nupSd7VUqLuqXVUtIbDTZr9dWDbDgNPEBzaPjZN8 +wwIhkM8LPYFg7MCwZJeHMwP5YJgQD0lIMkMAz7czSSA2c8691S9ZJjv6PlvdVfeee8655/Gfc6/+ +7v6uNx7rfvzlDTfErte9+IThRKPjhqdN6O5EKBxT7aTqTRhqxjFStp5Q3bhjZjw1nnUcw/JSMyo9 +Na3xSFDFn0x2rDiSE4iq2YtWHX1uw4UN+ae/GcxF1ekJ3VNNV3WyloWz6KOueobrqbaDnyZse5JW +vM6kZ4NuRN2FDBlDqm6phuPgGI8I6Gos49hxw3Vjasp0PcMy8I0+abhIkDMyPDysWrbHWae1DGfQ +HboeySRU3XH0GZdWSZjJpEFiqCnDGvcmkBfHUC1jCqkZ+7J6qiyU6Wo+y9oU503Dac5MVB2z7dTR +X2z7ZTB/5sa63E7DQxENizgcy1pcslhJPi5d0rRMd8IQouFit3hq2ow7tqe7k2rC0U1LnTa9CeRe +vXqnaltcBNfT45MkiMu/8lm2ZZT5Q2VrGaPJoq3QOH+olczRx3ZP1C8NxR3dM8Ikg2lptqU5hmun +poyout5IpdZwCeYl/kfgM9fTurHly018jTNiQ6pjLNczmZRpJEpa1ZOe4Rx9PnljIFd8VJ4ykrYT +2ZThxqKqnkqhrPhZdSdIrciuOp6yx/SUao/dbMS9Ib4bhh6fUNHecOfwnz1tqbHPZa3IFk5nk6Nn +JmJlKTklVxNkojVc+UP51M97ryzaE6046KrjNDGiXoUk48jIGGqP25xqkj7R6OK25aESy6RpopZP +f9y9bagk6vVka6RvO+uN20Xy6rg5hVIRTRQqbnDGHUNPpblhG57pGImIutMwOCH4jhJYtEn3NPEm +jXYT21tet+pFVN2W8UzbWnOdEV/zOfuWNYkZS73S2oarhMKjo6ND8Nhi+TffUm6evxiVpGm7cKOv +JMbJGg2nQmnQ8qjUnTfteYtdPWmoSUvlE7YLr9HIBAxvnTM+RQMX57dN182mmDL0KWMWRRq4sFXw +u8FwUA+JHSS4e/SV6RN2Xn13wQbXszMu+gApilR33RZ13EZ12VaUnGL23qJXcjPIWgnDKSo+//WP +Ooa55xLxQW4WQ0QTTcWnT5bKTYf7Fm4L6IbU1+Nq/sZqFCc0PlgzdCc1kz/27h0BMwn6C6wd3vsO +652n7rTTRsgfDyuPSj1wVpa64fTRQFt+5udNsK1BUo4++KvDBvzsSVmZj36Le4UGqCV0T4d9P5c6 +oPmlgAJff4LNg/XbcP53pqRG+PJPlPaWJJla1fjTr7EOGNkirYB9W6Rr4IUt0iZo2SqNws6t0iq4 +a6sUhe7vSw1w/E62OP/Iiw3wwBNsfqM6Ith0EuHVhWu2Sc/WdRJpdHZ0t6TtpLWUbWc0Pe6Btlvq +u9Y1UslI9Ts744XCEZziIiENlR3aP7FfnaAnOA33MBQOc80fCPJfSJ+iyb6skTUS2rTtTMKzu1HW +K26QNuzm9MU0jSKWq46qK/i04s/+/aqRioh45IcjGhcKzx61BIfNmEYqIQZAb1Dp+uy5sx0jWZxc +zaCZThsJE4OOC4dulBfBwd3SICOi0LcH96J5D2p0226ptcR9N/zkFbYI1Bultku4HHOpkeuD2OMj +5lBEJ6zeLa2DB3dLw2NV48r8VLPLIyQuhWnF8vx1UrhMTMWFK9JE0cInDSNTSpD5Ezu6oeUhua1/ +DgpawnAzmI00nhpdaPmi1NP7aZLlv/H7jua5hBrM/X+Jca2VMieNuaVBP065NgbWrIXxMGvhvg0m +cKOsBOUA8nHPTBsO+rtrUtRE/57B4GyhR5uYKnh0vnpnRUAWu0wcYixKQvMXpYU55GFLFh1+jMeG +BP5GEUWg4RK5Uf55WketEFbggzK26xHMiGNQSmA0MW4xMfl4lKZFNOE8U3inuXxUpGSsS/fEk+Oh +rGXeEt4bhLO7pDqKInc48tIG1MI0ISacCc3L0DDO/DnaWKSG1TXNZTed57GWirmx+xjLCTWpI1X+ +4hCH6L4EIXBjImkdHdvRjJRrhHbxCZuNpBeNJoyknk2hePv5yP1qiP+OCKKkSC+M/r66RFy8iOhO +2s/x0FGQmpcQi/7ehfwhE3Yq4Yodx73NH/l9ey5SMUyzk0mMugYfca63cwwSjcYzmWiUZxqcusFA ++IXJ8npU0Vbb+zM0fNTlRrKszUhkHdlViGtMZPxZgWqYzOHzvoFxXDiNEJBvIvGgJh07Td9Mh+MK +YQ08C9GChoMmG0u6Eb6HiHTRgFVLz5j+QJE3s1acEnKkMvCUBG6okJg7H7z6pFQzj1sQ33dUWyms +LeGCOLbtFXNUBLlyNUSpEzxKUsIihKcJiB0Kw/yHAx3wQqPUBR/+X6ULPphkDfnMv/bn1bOsjfiJ +6NZMaL9PDVeAr8yTenN/guq5scnKprWMnUohmK50YQwgiJa4JikGo9/aqpsd8xyMJVzJhIDNourR +kwc9NG+vz8PMj4zx9YvgnhySMEAE9PXSohXVigwNkGqGfFPUyM5KZiYAdv70h211KcTWlE7hH/+W +9eRCFTaMQqwjEJrRHQR7RiqmCuWjr1+1fT2CQTubwcWxWOHQnhuygNV2fBKpejbHcHHbdjDl6J7t +lP2fViVeK16Sa15Q6ZvIVHV+pSe0HyNPsl50ErQmTSzl0jgrm0pV+SDyb0TGI6WiJuJ6CYScMUL/ +upoxM0axJBBKJS8mpqcdDHPVrCZMl7sy4gZiAt9dUmYU7SVBBmsVOeScc+TL9z+CciIMM5LIHXz4 +3UBXDpOTZtrR6E4UG723SF3jJlIhAS2dNAmbF3kcUc2LVkWj5IOhuTY2rF5YMWKWhuklrbWAFiuv +QmYC37xB6odX7g7My3EUUzLeCBYRmLlHq/k4x9q3oQUsd4yM7XiYLGLZqaqMLKzYuCWeyiZEJBG8 +D5ILiBK1ZGcDVYbGd2kuQ4JTr0tdK+e2eO1TTb4bvnWDtITLunw2YqOQOsHDrw/GTLtEPFy4ZI90 +6cWjxQpGr6iRJxx7mhhMFyuYYnmdoOKlslqGTw5LHb3nqXvVgQE07xP3SxfA1CuB+dCcleth5D5p +GL7xqFwHJzcrDLbcKQfh1vukz4D2oFQHw28EakH9C6kGDpyV58PPoqwOnr1PuhC2X8AYNHezWvjt +fdIgLPwcq2eEKuEKCfMiEl0Cb35VaoLcJUodNN0hD1KubBILPf41pbeQvkf6xV25pXsSvCIJrbcz +M0Pq+hQWnEPqBpEPMXfz+tFzshi8yglTva1kGOt4tbE8nkJHFbvOmxNkgUO8lVBCCbFd+ng0atK2 +ZV1jUmStHHkrVvXlwo5mir0sV5TrEOkIYIS1vZ/oy+VxMdYOYe1AFsgrTkppRFmE2aJ7cSOvKP/t +BZXJWSxb2NwdeCmY21HVNThPW4LXq+qe2HWm42X11BadYA16fBWOL7YVKutXtI5zB0QR//l1Zwj6 +Ph/ogoOXBxoK3RcEdrKBK1EisQPRqD6Gfqi55rilp7gzYNjT+BbAe4OBxbmyNs87MEqLhNXloyoF +qziPU0TezRjxLfgeq02jvAE7KLMLnIcuLDAfZXv04BhnKhrFPYqtxliDOBeGBwO9PQI2ldcpm09B +DwVOXAK/PxqYd6lvONzhLDW2jhjeyfmN+PxSN00EZ8ueFs0c24J1jwYWrjm/eH9KNPU2+N6r6IYn +/zxwSc/5ydzZpQUKXZrcthjmgVR34Xn8ugq10Q/6OfxlTu6D6w/IXfCDg3IjSA9Li4WH33tAjsKp +/ywPALrgWOEvvyCr2gp0JG5YvNvCQ00GE0yCOi+IKBD4c1jmZrHS4e0hePSncrybJ3eCKTSX96nE +4BEI3SNdAoH7WbiXw8Z123ZpGK1TGMbWo/hXIrENpjsJ+zwsr4+9rNTA+C75Mvhohxxq2Yn4JO6V +80cImt+WezoxdM6xVBjCb8tvDOou7rQPVv0+GSXvrBPHB9sdE7FWYp3rFX73tnxI6t3hj9jpD8iI +ASGkMpS/fWErfO12uSf/1QeCBO2Vwg9PyUMSrHlHHv3UmXDoXbkVat6RlxS++I7M5i/VMbSVekNk +C8RldLNNz0eFccMV7wfUwkMfylc3tPLnEdsJpZxIin8JFz7+WC7Uw02uPL8Bcx2lWyxrwrCiT+op +vK0wrw7eOqA09IiCSiOYWlpwYE/2sr2j8OwKqb07nRVwiHxGS2LaovSlj+sm/PgNpRUsUwkWbpjP +XpP7KigVmxhCjZpna2A/oyyCtafkWhhawNZ0LpmTpgUn7lYQVH8bkXXmJH5ShzFVHFvAlh/+I2sc +jE/oZhhpC2At9KnRQ83iHSBbmDbsC0qtcO/rgUa4vIetEqvONLEu8ezUrWwJfHgywOCmIdbLPx3+ +p4CiqESJGLgYYu1sPXxjWu6ADa04ZM2NmIh4NqLBHedh/dB35L4czytJ0Qvj9YnLQZtHpWexClbF +vGKj3UwTNsHvNJjXr+hFGNgn0YeoYVCsajBn8IVE8ubVbPGVSkqnEA2vf8IWLdRdnMsVJfRfsTOw +8s1AN4t4+uRhGSsMroa3DrL6Gj5nP5yYx7rE5zCsvAY97ORSpUMMK25evcLf861qTesz1M50ZjTi +RSxBioDHCkonL2DgYCt770ufsKYxrOPRtVB5GM5SKVhxo9ImtHpwL6srpNpYTLoxxk8ScAzpkOBZ +fMIQ4ZsgDYVv3jgUYB6jopk0ORqjes9N6dRn53ULLSa2YNKYQZhmw6FDcg8XpHUWI4Sd4UQG30Z6 +WYiG1IH6sMTgeEyphY4ONh/sXnaBnDAdWHcB8y3rk3cV/5M9io7+SjsLMvjpD6Xam8u7q6uiO84/ +W4gyjXjW08dSvL1vYVpKcoBZnGARBJ4sbq84Npnm+y5ao9zeHfJG3zxIpkXNostfJg6nNqPqS2Lk +B3qb8sf+23LY8aDULjie5RBcFD7+4JuK0s65oVMD4gaNKE3lMvzDDwN9sKqhKP49lzClhzfdw6qZ +VM/h4Xv/Venn+9rtxwPRoOfVsE8arvkvchtRa+bJJTKmuwZVMWTK5bokkrWmHd77CHmIdVJY0KU0 +2opr2lin4IVmo4EFfXdEGrClhfVzkYYiONaIIzA3ecdCK3pbRWxCTDek0uqw7iVlIBjBuGxr1E+a +xSHcs5rV1mE1qA5gVCST6YZv3iusSuhuPiJGqsR8TuDIq8qyy7HeohLRxIK9uIcRHj6QM9RaEtca +t8g/eVMvZHrF3i1kvoBxsKTu4SRRL+tD9IIwt1XpJUJR0IhTQYfSLBJRjBhkmjoympd6W+HxS1gj +fHAZqm/7I0o9/LSbrVyZrNr1ufVfpbGyKxQwyH4h0IKMVDsW3J5FBFGOH+WojuF1LSH5rsJNfewZ +OScapnxj1NtU3XUN/HBARLd+gVb6Y36cdNV+itP9ETVjZdIYFaxJOkkSWBfLMTFcAHjaSP8s06YD +KIwTFkIIzT+zKvZ4etXz5xIPTk5JfXD/IGtcRllxqFybCm2gyqPqQPkVvPwHZXEzfeI4zs+oEFvE +2hrXDKLfe2Z8dBRB3DUB1juyibe51lOUG0Ko6mLlcq2FEw6UMQx6VynQqUtG1DEhP9aDoJ8K9HQ4 +Bu8KaDcTpsOAIlAOHDmN+x77Cu4A9RibStGjwnjnVZXzIDWzjqAQmnIHrG1iw/DMVqV2L8o4VAUU +x/xdGc5gRamPG5GbXdvqrx4ziVZf/aRCWNFZwEAxFITHNyl98PhpDEnIbhM8fVwKthA69GEqLq6O +BOGIK3fC3qiEgauRNW0QLyMZ3Zug7pqLWHtthLpiYXJ4jbonmufoJiF+jSeGyv4RD2lcwv6LyssM +FXU7JJifk+EwVpAw2cy6oamZ1YV9SDLqny3Rt2qhyevUrQj79w3JXYXuJezFGhk3oHBqkC0KQuS0 +3NaKlVgqWQKfnHd4bDW7EOZdz9pgy3p2Kaw8zfrg5ShbAFoQU+pj69n82qSO/o/6w8K6m/S3OP/1 +Bxrgdxk2r/D1texLDN7/HmvcbtmYT9xpgheEGPBrJpUdR2weT+lm2q1OpFQcmryZj5JY45gZ/bmY +iUSQStDZBOLuXys1TVzJ5dNluGaQ/a6du4aeNjTqe9mamA/aZwM98NEflJXw+lPSAqhfxf5nM9fY +RscJ8bhH8YoiCka6OvjJKrbsXCpUm4hPEWNfKgR/bGPL4PG3AkF49iOlAV4CqZHHF8KKwC5ie+BM +TU2dYiGdMNz+14g26G3hvovYFqkW+SaoUfjVxexj6Ty88OjWcCmTWdOsAWVyxexT2LKaPSfzFWsF +k5WDiMt54lzPLwPESwqCsD0gBWFkAPcazaOhsHoD02U6c3h7EzvBAXx9CcAXHvs8u79jblQPzTpu +/UGN/T8J/uEpqaFebLSLr3M6W1SUGO74CNNC4LMY/l++OzC/8Eud3XVxfvkj9TD8Zda11nS3IMYU +J7b94b2lehxdy3AstX99vyrOI9M4zI+kxe4WQi04MoiK23whyjb0UKB+cPZBJM3aTwNpC7Wsl7ws +lOa4/y4UYMWNMhst9ioc1GKGXyeI4XAspF2OoXgzKmNjaBcGbVJU5zUPr7JB/TIb/Lzp0rH2Rhq7 +nYZ+qiDlYljjdOeUpqt4ylYpNo4QPft5Av/4F2FgGKTupspbMerICNz+UGBxS2iARKcMSpKHw+H8 +kkfaueI3mu4OUZ+LqzCc+U/le65yvvpEcK4RpQWvQMZEgHO3JcWa51+OSh5xJMNBlCiz6IAO9n6o +NMO2B1jdAn8Vfxj1K2HtA6yriz/lPWc/g/v8FMYOMy8A2t2srnROf8VxVruq8s6H368r/pzvTsO9 +PwpcAA+npa7C7+5nb9Q1XM+PH/hxK+ivB7oiMcIGONpLGRH1qqRADJQP47pFt154R4ADCR5+Vxbk +tmbC4VjbZB1L9OLgtyfkziaSRrRMhTsRPhgQBhFVRcsmmcZiHfnK0hUPd82gVizZ+/5CjsD2Xwd2 +BCnB8UPLBOyzpO42+qzphDt8LIfADk4+ifDzG5Zcf/g3gZZ2fpJgWwZBsf2IaNKma+zPt5xpheP3 +YPL87pfkBvjtPwfaYN+32TKMKI/vwjLgsjukxh20GMWu4hkRP064otj0KB/sRqO77MxmWp30t5Ei +XTS6VUyi7hfBAp/plt/gQtVJO/+Vx+fB431K5with2sZBMXPOQY0psw4ghz/VlRCRBo3JLYbczT8 +1VfZ5YFQEKTrmQrbvy+v2XybUO8Bf8uKU4s30W6yaLGoelulfAdu4xwc6K+yH3S4Iy92rdjltwOR +mH8yoNIJMdaN1NwlK9Cn9ZlyeQ37TmOJZD4tL4Djfx9QF/DmlUGQkh+8uF4CXnla7pZWw9PvBlYs +Kb6qPPLxg794UTh2hK2VYPUDrB4ih3GTA/djOL7h2/jfH/45EIF73wl0knaD8NRbgQX5rz7QkSrR +nHVOzH2dW08R+1VaZ4guBKBZ6c64uyTUf9sBxDbl1iK3031Z1FPIj38IpzAoldZvZLQobP9WYGHB +epAtbocPnw6wbgNrpZjoZ5pWudO8JwZfPMYW1cf2hgSi4V9XhsvNWLvYASndr5p9jSqKyoemv2HL +chP6FD+b4PVwxRU/i5fT5N7+zUTOB++MVN0lwPBLfGpV961CBH5VEd/9AVH1nHtXhPF6K6Bx9Z0t +wsbbvssWLYtUPS5vddVjuPso62qKZLKIQP0Vw6vhdllpLdz7AwYS5I6xVK44lc6r6NiSd4kqbraJ +8xqvdI2N31vEotZSE/a0JW4WVt21I5VOGhmv+rCw6jpdsZFGofzmFxAyUfBtrBwBvznGftaFBcgS +d46YDMefZdvh4KNSHbztSQ1w8BG5sbDsOFslg3YqoFRR4mHq3g8kBW56jg3AmQ/YfDg4qDRB+r1A +XeGB51iP1EmFznmWWbjg3Cto8P6zWOPj8o1/8iKb+qNAdz5zhh0eRwae+d+siUStWcZzUlGhpUi1 +Xjy4KoGhb9vWjXD6x/JiePFZ1pp/cbrz8HHWLEQ+1iIHC//6PDsjiQJrlomU0lnNlqo31HkzKksR +ylG+XZAzVQ8udSIQRiVTuucZsO9uqY3R8PzKZzoL//ICa6prnq05kTje+jsWhj8mpXqof40Nwq/3 +y0sL0qtstZKb6/ZmHD3R81ttwuSStmizFS/ciZYmWqQ+hu5L+RQ9r8rl+J1EHxxpnEg5KIkVsbQN +DcAjx1gQzuZZzzxulFgTU+NnAKw3Wff26sqX3kWqzQKrAPG4ev/Ou4H6i4GONUnTcT0e81XX0jPu +hO35sgq4ElE36x6HA6kUBSPX868ZpSNYez4lXQz3LmUs578ogZw58hvZoY+rNG3c8HaIKVf6F0uK +iW7t6qowPotwhPjwhw6pV++8Tk9lcZXma7du2HjlVVs3bhhSB/bsDa+FJf9dai2b9PxqlcBj98hd +qyv0IXq0+nToT1wmLTKZP/RAOzxzl9RRWP0au5r1FhvvnFW+rfyO0q0YlENwimHSGHuTvRHfZBcP +m/3+C41SaVTlaSRuokP5kwBXRI0l0Ak83qrhNyIMayqya3eM+4QwwYTNzZNOrW2b4/z1PiskCB2T +7cYVzo9h5+YbFiek9vwKqIdDb7BNoB6Sa+DRPqVnzA/H61SqH9Wr1l/rZ3x3SOV34vqjw4YXH07Z +uFVEDTNr2tD9k1d3xvUMush6a+nSdoVVL/HdtOFNdmn+h2dbRXdRXSWxmvKbi+Sx/n5ovgVB0Mm2 +QAO8eoTVFtb9PVuRhuZ/kxgc+JdAB6h9slKY2qSsvWUj8rrVoP6bOkXGgulx0syo8SwKjQnWohqf +nNb22cdaigM8usng2BnD8UzDjcCJX0nthx9RtsP24wpCyEeV4TJzkHtC+Qy9QMT5BP43fVxZCL98 +QmkBtZH10YvPia8fXIZVU5FAN5JbCKOPKAvgW3dLnReLm8L89IsAQJoa9dSs8zG4gAdoKWOGwAcE +z2D4JNrW/3pSWRgYGID38HeTZtwSx/yGu+mkTUuHQ/vldjj5cqAOjv8nZWFvYnQPnfNOq9XL7V3j +jPYXDh1Xcpfl/oxfu9SLzT81jTUkKcpMcO3EbMs/souVrpQLRGhaE5iHSvcHMRhyHMnHojpFcAr6 +Vw+2FansjKOW1wzqo8W89ovamt7ctH7OHf3yBQKxebxPTMjMLR/Q+Y1EdU8ZzNHZJwqIpcaBYBAr +rRRf67zLi3AtY2rJr32iI3/iqTaIMXnp3jkYmkpHZv8lQcTfrRAKaczqeJ3LNRJAqtR2PL2edXbN +HuDnxKH8uiNtncS5usGh23yYf0rsQ21DzWc3nMMGVnQhHwHPehWuvkUUqeZheDYPRTA0+7mgcqBQ +9wdlUMqFcAkeYikmuBlUAN3c0HQqPDDzlZ5SoSQ8md/YKXNVzPwUBM6hxe/YzEWuWATn/8/+IBz7 +RGmDCz9SlveHKrjgyB1XFUFcHBQjAL/zI2VRj1iSF2XFCX7LGi78WOmFmrNKd648aCpd5p7Maypd +5BpDTP+UuC8S5ZVWP8FMm/9NTYIaNP3Fp1Z5qdKUfv8KLo2bTcXKVU4gtfRHSgzRZfEKZYzMqXKu +vNI3MlgjnfFmKlinP3Yh4MJP4jwDHd3G4oJHybFszsQgbolryxV3GUuO7+8fBn9+ZBenBvJy/y9e ++NmtnU1RtyCedVw64HWoUp0lwqzd5nIUn+XEw5LNkjSltmyFNJUDQqG55KU31VZAJliSmA6OStNC +A8U1ck743Pv6obk8X9y6w9fVi/BLCtSRJKBmeGXKTqkDSP2uyiuQVyX9OIs0conYeaxGNOuNknEN +zWWDeopO1GbKJ67UZqtSZoWuUobF7w2upBe+ocNLo2ze6jLPayscdZb9EbVz9zN/Yn8r980RlGxX +xbH+oMuPoA067/Wr5X1Zw5nhvSb0BX+cj4MKuY+VhkCt/xCWvMV68m8+1Ai5s0q9XfZRzaVwjiZU +Hd+jUY7kcN/C5bFpbvO8gT5CJxFGSbJZgpVbbX7X/sgZzPfPX4eFTOzngZbGcngbCsIPrsOUj49r +OHtbzipNvIgdKIr9aYdBRfB7oMSI6Or7DS5hw3O5zGwOy4EKSxH47hmlj9jthMytAQXSrynz4cXr +WEuJTWozHlnLOuCZtWxhXj3DgmUrhX3PY1y94kcBVusvB6f/VuGjGAVXej/QUB4fhO/vZ72R/5i8 +cPsZZWmN4D3/j3d2ksE0FV48q7wQKDwRqHlYhn9iNS0dONm4hfqsuhs3TTqVdEIrwnD6r1C+WDtr +GPCF5pc70T0R8JkJ6vHwhqPm47kZuOZ9FGnbTaw+2F/SIew7pXTy8+Tefp3uR1Kgm/ZDI11UVsdm +qCNw+jrWFSzN0qDlHdTr5NcCzdD8PhbvWk1NspPfPzbidsJIiJ0iRWHZ8XxNzQXtld5XegkrL2OL +5vNXpb2ED9ayvsaB0phwEH7cGGiHH+yQg3DyVaVGjUY3bFy3QaiwbNfkVSPcQeHFmpoLy+Ph8tqa +vrr+2w5Eqd8Fdm1Njxz2qeZKy1SSQyIUMObWezl8lUTC6Bdaco7kNDCBYUjY7xyvkXzvp9GHvkBN +52eoU/sf2ODasX6i3g9H2gKtN33anvbPAmr88JQXCxWmGq50zW2TId63xN+on8K9tTXPsX8H29Hc +r/iSAZZf9q5uLYnfiMlJTfA9tWSgv4UTeJxtVXkglPsanhlbNajGZxnrICpkzzIOZgzJPhFCYmYM +M5b5xpixhBwl0iXyWcqxtEhyjvW7FWWLki1pJaE6nEQp+0HoUO49dc/9/fu+z/M+7/t73t/vVD5y +tBBZeYGfQDTs91f/MkDIqkaVHBiddjuX9BGvo61toK+Ps+CxSGRXMgf0ZwbTOZoMRMKXktLnRKLA +q8yO5pX2YkvZrNGP0Gt+LMAdMz6YTswN4tOYHWyTecqxCKrdsRYQl2AglG97iRlPKyxjfMpcj01k +n3U3t34CGwlQUEDk6W2E8n9J7cgoPtqlqa/SWrP1EQOKE5KAW4Tk+eK8Cg5ICZiGJW4Hhy39S7Ti +Y76k8/2tixzMC2Cy1iSVBu4U4Uae+7CIJuF/Ul0cHFHIW/gujQPS6GFhmjQ2G+HRF5GFTVlOxMQr +V/hgb4xRVWO8/pnJQMiN/4ZyCBBNsoWc9qe+OW8XZ1bXYwux0LuBq9XK1IY9R9PLI0MV5lTKDp36 +VV8Teo2Wg9rQDSZeo+/Fno20a4hRMw6LPjpSO6JCpv5N78LlMFkBa+xF0nZDvr6HJRAtd2SzvGqn +QZ0DCfAdYRIS0Ejt9gu2v7tq1b0XfQwnZ/BhELwFS4me5Qf6PVVl5IB9Hb7YzomreOZZq4zUIqge +YwK8e/mJMCuhTh37Q28milRgE6F+2hsSFpMBClMMJGJr1Eauzb9M62FG2WDtrvJDJmJYEnuqemlS +Ix+zsDXbPnNgYLZHeqx5Q6UVhwNyXLgUWtBBDoVG/zqzxgH1/n1PQCamuSnJAT9TNX0KPAnniLUg +gXAjLy0/12ymYK1n8ss3FUmHLvQbwizx35EWjRe6FeV3xZgG93MNEsfFbYdVHgpulLAJYYMcrgOd +S3GiBtJp3LV56KHByXdpb3CcoYwWer7cQy03RDX0VFINrpNsRgKl2zNusAeI3XShANb8fdsOQt8z +acgXK73mq4u3y/pMHnPF3HFtysJ/JL+7yJKmQAtYefg1loTEk2tJvOOKIyNAK2vcgay1p4XdLbIh +wtbFgufv/9XPs2AVx4TUcDtvz/2Vxjr3UzqXez1gb5loFJAzomU55280P5qL8ePWOvz6GS8/Bn2Q +cwRs9l9zMKzw8taJwIWjJlTNuSf3eUOO8tKAm2omVIIes/QZDakd0rnhwMswG4Rj5L1RwBHOzdzM +QuGeitRLTreyyFJ0+mM9aAKnBIhhMBp56MUrWmPnE4O1y0eUZj61wsqKQkhg7x47F2bUZ0J329hs +3dlG97QUDx5kpiQHhOzDJJx5KcXUvsVAHRY9elNttfwhDCq5CTGJU3E4hczey0tcy+G4WpX3JrZ5 +2hsdO4B+vGC6NYfCZqw1bXxCdmirYYKO9WoTKk6i/rhTcz7uh0R7kOK3Np71+08Wua3w+KbQ8j2j +P4mPKqvv+5GSRyFNNQmgI2BFpKrMbKW5Q+hBu+DUjECwvCl8SC0JSXA2XPC/m72vsiXWo4vsGvgg +GeLfvUHvCPrRiWFRLNp+EAxaX7Wm+fIwidNoDwull+05ySdO2HWecYQUNIhAgu/eecvJxERUxJdd +M6qVP2P4hxtgroYBSumbxP8Q8HQ9CwLCL7c/fkT0f75T0If6zGMRLtQUQAKphvofvQPcnoWJW6Xm +lrnlcLRTMFCNlkEcxm6vVz1kJn58Wd7ZUUjV0CBaNvM7fW4Oa7RnwrrM89pqoVl05OAdyW1Tem5P +Fn7IIYEhbGYwhcsEWSQKjfFtWTQb6svfgBVG3qtBMyoUcsenqpEb/0A5/QBjIFY3balQfGAXRxyc +Fw2J3+40r9bI+AH0reGvBcTltcN+G3LmimQLbhaINcru9plKgZy1Q4GK3k2yl8RsIixThqcBj9iD +kEFOEYTUEYPGtb2cNty+TlC4tw53cFCtWCizJCKULXcz/F4o7YdiLiCPQ6P/dz+8HawTwst0zj/1 +u0Gt2mkoZ9Bb2ALr6sQgAV5VT+VZK4H9USYX3lLdaW1Fk1Hv4GbdrUiA7+IO8SRZxuHNx+NfKD4X +6bbeNr4FwhmIQ5r6QjBSv4UfSFX1RIQe3/yLts4mDxupVr5m8Y63UJ8RDuBhX5HCl9V/oV5p8ohG +FmUuWI5ch4WNNfgB7L+jr8uIOL/YcfVF801ZC3Zyzta7sL3pHSTgsyl5DuXu3iE5c9lt9Ojj263o +S52QorkdcIinxEiyAxWdQVCXMMNM8kkTKoAOmEuuPR0GW9TjeEdWGtk8U+nhFM/lO/ja/vUQdNfc +GLjw3iOJQax0f/J71bkuekTxWL1hIbSdIANM1+s1MdUPdEzMX/dEGaGfRe1yiYYIBADoc5T9WL7t +9IzDe5aw4HPiNizasBJiELwAV//oAe+fgKGga/Pdsdai9syazgm4lyCMBNJdGCn6sVNozMruK/RT +JhgTiRQQ/pNYiTS2CmzQ+QANRr1x2VXlqhAvaakcvbRxRQz6+l6u2x55H56bJKsLp4eSa/DnFSbw +qYvh8GsSgQ/oQ7dMhsVLuZZyUwd79Dot8LGepZC+tUmcHzV3ebCeMS5XEGtfvt8HZzaB+XmDl0Vh +M33okVw6h0UJXmMnkRVPRNatruR31UTvqtPVX0p7WPz/Un3Cvn1q687isPGNRaGTVU+XjvkrYHvJ +qcnsPd9jVP8XxEB8GtMcijgc+Fom4Vx5wb3qGIRZyFu43DoDCTR9qcQbJY/nlbk5dgbZBObMURYJ +0EGbDqC0FWpJ9i1vz0/PeKiem+Y2FL2Ag3VtDVEuEj3Tese6hJZolg34W8bqHQonc1P1tdcOLjwE +4TNgYtpjW0b1exUSQmNl2TWUEqq+BSPoVBrIoSM+D/qqLt6VKpZ1mztyKZ+YOFwysBuus+9C/gXd +geTr/wLFE+iEGU8XSyRiV9Y/lGE8HuAdvHic62xgXNXAuGEvi4JyZl5yTmlKqoKSZ3F+TmJJaopv +fkppTqpzYnJGql6G0uY9LL7WAKEJETL4DqHKCa5Z03PtvW0acdd+lCxTcIjBeJxtjjELQWEUhjMr +E6M6xUh2JInBIGVg9bn3cL8c5+h+52PwF2wGkR+hbiaTP+In+A3oTsq7vb1Pb8/jnHleMtdTrug0 +9oFC3wkZxbDPijEbGkjoCZNj7l6YTGeeQdEpVKs25aZAYkIH3eEA1iZYmgU6sKwCGlkHC5KZoQps +IxtEIF7Jbj6ARpj+zC2hO7xKjfy39nhjY+EVso7Q0CpplnfZNnwyxkAlbnY81+v/DVuQGlnh38El +t9q++AY5LFgz90+goOwYljFVxpP7byIUdfTTQtJSOXicnVNLTBNBGM7ukBVbwUSwgMQ6rVK6WIo8 +xISGkmAkPqDy8HUrW3baDmxnYXe2kZhIiInGix42cWK8cDDxqmKyRhM08cBRYzyamHDwoBc9edR9 +gAsmRXSSyT/zP76Z//tmbj6vfbZa+/iVsDejymhElQ0FnVbVGd18IqS60VWKNAKjJ6OwrGIZDhok +m0VEyilo3CAUl9CoYhQwGcG6Po7yGtKL5veDUV5MLX8V7gVboT12UvPtxX5zpa1m+fq+5dC/FrHF ++6DrxqRoTYrc549Ru7Kvr+T2cQ7ND2lqaQgr6OL4cDzvWdE6K/CPqloqJ2pIkSguO+tbkSBvRYLg +brC1cr4zDU1JwFmJFs3Fp/WBaRUTJI/aWxZ+zTWw2Sa+Kuk7YT/8K5r56VRzowOYgNGWaFZ3TNdx +eyGKYoqN3eHqwxqihq1OxAdOYj1jKEpchLGY9SMEJjnW2QXqqmYwka3LjWBA4LotFgZr3G6Dqm3Q +8bMvYRB2M8yxD91s4BAQzbXbsDnquJzzEgG4abhQMxC8qXGhF5y9GLjm5kxQDZMCJC57GamEUoF1 +MbdEnG69CM7DuCt1yX94mQ3u4wVFzUnK+dw0mqLt6ZxBLo3ExQTM2+WiCL0jmZUGnYz0gpA5ulTP +lnpBtQDLkmIgsyMWOprNFhDd9KoHDaxQTLZAryPa3Z/gyubbmsiejevbOpXNscNXhvx7b0hHVa+l +uN+smNpCVN7Ljvm1bO4MF2IrB/hdrD8JhoWEx/+7B1yz9TAJksLCDgmcmEVTOI+R5oU7OuCFIoIa +mjOQTm1LJUx0iKm+ng+xjOxPROchKiPisO7E8phICizatEAZaaiA9bT925Gc/F9pTG61kb1Mg/aK +ejRU0IMdO8I3bSNA4o++t1WB/azmQ3U+9b+rXP6t9z2gp/ALgUqzSPQCkgeDWgXGGFR+I/Nq3d0Y +prGGNlV4nDsf+yx2A5+yuI5Ccn5ecYmCU2lecElRZl66lkJ2Zl7KZj7lg9wA/4UNN/aLAtp8Ll6U +klY0GyOPuXyXtb+MHN2FeJyNV31sG+UZ1300dVyaxKRp0iRt36StayeO3SRtoXaTNKQJSZsmIU5W +BAHvfPc6vuR8591H0tCyEDY2TUWUchLvNgFq2TSEkFBL0AzbGK02jTKQSjZUtLFpsC+2/TFBhTSq +fXTPe/YlTgFt/iO5ez+e79/vee7Nn/q++q7vXKXX0ycrOC6r03a191k7Ur5mjSZOY3PxBe8lT00I +JTVNQSbWM7IqmLKmxuVJVVBsX3WNf0iTcI+WycL9HkFM40RCU8duPBlYvK9y0xr796WVZfT8iK6J +2DDC6UayFOa3krFmvmnx3ZrXtpCzV9kN84YpRaOGqcvqZGJGxrMoq+OUfAx1oMYUqIlGIpHGmBfB +LxJBR2W1vQ0pmiBhHalCBhtZAYQjQcdI1UyUFXQTaSlkpjESJElTdxqISkHjo4NhR4icQoGsYKbD +hglnjcQds7KZDjROwK9rYmJ8qGdiojEYRMedw/TnHNZxRpvBibxpgVuDsZXtG61ttM8+VD1/o5pV +WkDB8v3PUbG7SMXny1ptaZGo+WJZbUWyPtvklf37vfm/27BiYOdZ1FTDxMeyOvrfmQJB27AqySnG +u3j2lu+w9q6zvP1stO6m/MmwId+HA/avoo1rUDNqjdnhWPtQBmfE7FxATAu6IELVGaGC3LAkmEIg +uPzqXA4WfKEvCRPJoHzVtn1q374X9v9mlPxhgQuT1meYGvvjRxrJXwV4OHPKR9DXON5+YGHt4oFT +OGbvu1bpGesdPYJOnEA288/KtQNDY+5ztH98ZCVNt1lqIvH/VX8wtvjEzx8IVhvY7EkLqoqVQRki +qGK9R7NU015o215myarZ3gYOiM7S5c6axZ99XOd7vIRpsJnpDSRdwsQPfY6AzsCkoiUFJQQJAb1i +QhQMc78rsTNgaqaw+kbQPj29mXQd5krskb94yTqOKcvt9TAffosTNckuf6fBVuxScvm7zKaqlAB5 +j6122yC3n2WauRDaZTe8XZM7/DRzemvJKM5qupl77yLzt955IZtVZIChpipzDvYMKwnWUyQODR/s +TQyPjA0MD8VRShEmDSRD3jJZBWewahooYGDswjsJ6kRNx9GoCqFOaFkaVgNKwNDQNMZZpDtaoQAd +LS0tFAqatcNsoedbCuddaTOCYuEYsrJQs1jIkC962N2tSFAl94BgGFYGo5SlKGBxlopGs2msOhYC +cdBYhMmXvOz23Msetrl+Zz7gaEaTJaRbatyUZC2etkxJm1UDR3Gyx7E9Th5lmKpmP4UOIMcMIcgN +SkkhdCjeE40ein+BGoZEQVGSgjgd9B4nZ66yVZnxofF478HESPdo95FASgrGilAI1tLqAzoTUgAS +VymCkgOdBqiiEaXuI6zrGkWRrIqKJdFY9Q4Nj8WHew6jlKajrJzFRthrn9tRax//uq9jpm13uK01 +vCuiyMmIis3wVD6AAeplEADv+kcdiPePjyWOjgZdnJOPbmdqPQU/w/bZSJP93mPryJdv5usIWmL4 +7m5jThV78vt9OhB2NEr9LpTwcHIKixAfNxQhNGWMqxLgWcUShf7x+4mvjWkkrz7JbCVaL+Nd73ru +xJ6c/ojd9Pj7XBVpOc/5SSzIPFaSjzVZOsLVTgnGAEVFoEAa3fF47+gYOII6OlArBXr+0SVIwTK1 +ZVuAWT7DeFpwxcsDqSGMJSyRD9/gtpFrEXYdqQWD+yFf1kzCjR0tlkLmUEYWdUCoMQ0pSmLICHZq +GehEnG7JpgUDAzoyWJIFE/JEFv7MVZLzHFN7W1YzzDG4F7ibZqLIzLipa+rk/nF1WgVdnYGZzMp2 +8J4b69I+9GZV+6eKd7lUi2WHJ7G5zLgkW8M1kAuvcGW597ez7ZXzGtTZbB7tJoBK0CUkYUPU5awJ +ZWamdc2aTCN31IDKNahGBNqwHkYDKQQMYWUBZbJihLwQMB2bgqw6EiVZh8JomdVlE1Mc5l21DCyh +ZJ5hUj4HtY7IPL4Ncmkf+z17/I5y4tvP3lrVZ6kiBUQTEmHbxPmKqTjNhNYVLzwfZbdUu1ZGo1NG +T9Hm9VNMO/m2n62tWHGtEI6WGBsmL/+EuanEgIuog1z0s7cEiyQX4A4x7AEHDtJmVqz3hzF2W+7F +/WyTPd+nWEZ6JeuUQzXa1gysz2Ck6TDsUBjT2nPasQYDjWaZWcsMoxFNUYQkLIwMxwfudLlixVoD +wpqhYVU1NanAnEclAZ06pOdwAaoVBRXNyViRqF4IrqzDJTpiGTn/Emv8OjBOA9+BZjLhNBaywBD9 +8C8ODbdP00ddSgaUkW88x6G6/HaPAKOZbM6tOkIePQYwee85TiTPnOTqSd3z3Cby1EluB8k+D69T +V5jystUyScMT3Pbc3ee4b/rJtSWujMcZ2bSv12wlF+oYT4kznSDi28NsKPXDGDhpUDptvcLdsfPo +WF80OiRMY2nE1Pc7ueg9JmKnR3Qi7D6Su97itpDfXeG8JDfI1AfNtAzIpJJCK4cKGKCT2MpFoZyp +Jg+/zt1avryWRwxp+ACcefIaW5rzvcP9oJncP8H47YN7ax9/ia3faMqmghsTtK1NGXFnnALx9tLV +rbk3WP7f/J2QvyOCKaYRZWRnoJsyokigzU+BaVeC0shP1OKsRPuUlqSF4hSB072gcDTFcnqBCuQE +xIOSAu1kF/7F1lUWxvFEAkwdAeE9sxIdSbzO1A8cIx8jpy+we8h/tvOl5EAJ300quhiedrNZaQg4 +EOogackKZIe+GcA2QWrIiJVUZJEuBUirn20ll5tZDwcbJPEKW0XWbWHKeSqBvO/nw+StHTxPole4 +9eRFmb153oVqZwCOFGLttknwxlLMlfinCmeR34/c55ZO2egHenTlBIKrd+l8NoOLdoH03TjAKXLC +w3u2FI/SeaXgqoNe4GYg+BK+2h55ssbOLvjIgXq+xI68vY4s7eCRd8Vo8skOPkJ++SBXZ7/c32Sv +H82HoLudqScffp/zkOsvQrN6dA88Pf0B27UZNvN0S+kh5Ca20BbJ+TamlgmQjy4yu+2HD3vKwKSw +XCgZqLKlB7nNrpqttBaAQC0dOickHNDekh/V82MQOXOZqyEVaWaj3S/WbHfyXOyw0/qck+B03nvC +7GYHebpmzx7ZPO9shtDOiYmd8Deys+ijwrlsKAKQWEdeSBg6uBT4rFP0EwZOFU53IAel8OnWB4Oq +hLpg7HDuy0ZvJmvOQaq60C4URTPzzrKC1Un4+AmiFtQahGVHTOzTaXOB5fTCvEQ6kubXHBvctlb8 +qbNqAMuHyB10vCRWDZkdeZjbm1vw8L9dz4RIsozfRibK+A0cfCrk7t3IX69cK0sw1EIz8DXx23g6 +YZB7mvhpW7u0vszZChtu9ub/xNaQS038QAVltN4Z2CxMReRiGFTBZ/ICWRtja8nlCLuRSiBPPcR4 +yEt/Z8uCrvWFgmnpvFFGnsGCsdyZEF9fWnpiFPh8GKbz3I/28NNe++QvykjJAb6BnOziy8mRIX5t +bvoAfxe/YfkgiAe2MWE+ydjn/7iJVOwBOrh6kI+tyCItvfy9PgelXhp7KOO53mMyudjO15Bze/kK +8lov/0mR7lf7+H9wa5wLuR8f4h9himQNDvLpotcFi6vKvT7If6Xqv4bKpfHxJZf+WkDW9MneLlM/ +6AdNOK55/rooeJyNkc1KAzEQx2ktgqtSi1bRg01dWpJSF72IrCiotKD4BW0VvC2b7DbYpm029QMV +X6EQ8O7Fo1j26jvUZ/AF9OTZ7KqgoNCchsl/Zn7zn5dO9Pk22unGdeqAwt76xk4Bru+XkXyNzEyr +4IA3moSLiyOrdmJU1zSdMEyd7mM8mYKiSr35NVpv1owz4ajIKwlLUBsicHUFZLc1G0Gy10L+4CQe +uvHCP1BhtNUmuCQ4Ze6Wqs0BZtXJvqMmudyqw+3Spmke7mbBaT0P7AbzBCgwu4FVTY3aJAsEORdI +u9SAegoapoOE0RQ8mHpMXdOkXtlyXYIr5eLi0oHgUCn0UIL+0ix/SYQEiaScdzT5BmIGJ6LNGQhx +lBGm+dMK0xT8okgZ3lPsUJFKOwFnvkEQyoeURo0wcI1WtGu/mnofmA1orbZofK4MVn9vLu/mknJV +n1KmRUYmJNHnRj9dgrlAh/ySrkXlQjOW+r9HgAJ+NMGZ5HCF4jCthDI9Nu7jzO5Of8fze62HWN93 +TvtPp/eJD8U5yDb+BuPlFzWoa2mH5HCn176V9cGlVrueeJxbf5798Xn2DY9Uef1cw1yD4j39fDz9 +XBUmx+uITa5X59iklsmIKbO5Xv0BC6pwc7zO9ngdxgdSaKoTr4pM3+vDyLU91p0xaAEAFKoka/8C +1S5fRTeO6pSlnE+JxK5b2JPrRzF4nJt2jHHxMcYNO205fTLzUp3zc0pzJx+w1eTTUcgsdiyuzEvW +0NS05prsbyC6mdFOVBUAtWoP/vAUy5GzWcKM66J/Bq2aa4cTSf4yiUJ4nFt8iGnDEaYNeqbiaUWJ +ual6yfm5BZk5qSluIJ6Gpo7CZj3TmZG6Sfn5OQqZxZ65BflFJb6pJYmueWVu+UUhqcUlxRpewc5W +Vl7B/klZqcklWprWk32apDc/6ItlDA+zUChKBYkWKyQqBBTlV1QqlOTn6yl4BSuU55fmpCjkpZal +FikUp6YC5ROKSxKTsxMUyosyS0pS84AqFUoyUhWSU3Ny1IsV8svzFIpL8osS01P1JptOmOiZWAyx +UCMfTDkWpWvq2pVUFgBdrWBrqwB2FNhKiLIQoIxCTY0CprbJ1ycY6oOkcPkPi02TbzdobjaY+Jkf +APNwdf76wAFbc9FfkYZwUk3+eUpr48kizphIoXicrVZLbFRVGI61hXYoltCWUtrCmQrjTJ3etmGk +ZAr2OTSt9mE7bbFE6OnMmc6ld+6d3ntup8VgYaMLTYT8FliYyFbDAh0XaiApcaMhwehOXWjcEoks +jBsU/3Mf02lpBRIn8zr/+R/f/d+f3y5Yvltwff/WJbbAma6S+u56Mq1pCpGNLlONMoO3eTwqTTEj +TWOMII286ekf7Q6H+0eHpk+zGG8gMZ1RzvpSaU3nA4zTiDp/TNOFrOGflGfC4V5Fm6aKwx5o85zN +V4kcqDIb2kr2lgeJo3qcKiYjCV1LZaMHXngGXu/YUTOU6DRmmU6OWnRJNka5Lqsz/gBph7uN+8pI +mExEj4XDDhmGS33w65VtrZbKzqEofgn5ocSAFjcVRqg4+WfysAVJmvKkYwduVe3PfuALFsPZnkp4 +7VDlYZ0ZmjLP4rYBxIHeCIdn2eJQwn74rsVhGpulM2ytVvhOqtoZtFDbovifKgZ4myrgXHcRvNVT +XkR8PuKFk1JdtamqyGJjHNBiswY+aSSV5ovgjRwAcrgWPprY3rLe9ERSFuw5oRFTfRRE5aMgWCAA +50PliKMwuyJdKq5vaiJ9KqH4TjIab9QSjVxOMcIWWMzkdBr9BudbqibR61Q1Mkw3guhIorM5U9aZ +5LgIb+Maw6uMzJMkk2Q6IzyJAUWQRKGLgqRalLSuzeg0RTKoZNqUFS7BM+3V0HykCJb0FvjjUKmA +1psXWDKrahnV9b4IWJ8ayaHzG1yX4pTTQBvxWpzovkFTURCSzwf9vtqtFhUfuyVSDStHi/a40Tzt +JtR8KmgbQc9UQUfr4Bbbb9bxTk1IBCH7Z2vB9nw6ooTG7hBMhQphqKsEmnsqYKWlLDsfaS10+TqC +g88KFG9IdUAaK2FZr9rlPhRbRAjUhQAX++qgI9MLPzWG4VTGH3XYZuR5pj555gm1G8W8zUPwBSd5 +FShS2dKmKecPBCxO97WZ+cdmny25CZRqR7ucIH7bgveoQB7wwLn6l8otUsDBfJYwlILfD1Y/Uclc +1GsqqMm1x/kXfmy16uqVp3+yTVyMCda8P9S9vq2i/lOnnCqZwOIYUkeckonouqaLFLb1NGBNGaaC +BuC6v3LJthkkMU01uNDichlpFpMTMtM3uBOogvmEOZPpi+jJPFTzmhy3Ucm5Bv4opLINMA38r5iy +xf1flsCD4yNL6xzh2LTDn5OzxexUtClWwHFYCTZsYlG8xbg7riYyFyeKZ4VyTCi7FYnuIZFoUjas +vzj0iPqixkmKUdUS4Eldy5CUPTAsXSaXNZUwgdGQ4OLOffDz6D91zsjstFoii4sZJbJgtc4kzQ30 +sGLOyKohCQCD7hQUJwxJfuLue3WNvs0Tx+cGZW1e+ih+pvFjeQrut7XCjdqycu+q1gDOXQvf99Fl +mB5rwG5bCO+NTcMF7GH3InugeLwZDneVQ/d4A9DLzbA8HrLuvh0/aP0+GO+1fu/UBOHvyx5Io/y9 +sVrgdAd8Ur8Nrk1UbrGK1gNXL1TCNxO9cHN0LwSO98A1vU6wlORSBW59WAUfHx/tcMK8UT4+2ZN2 +BNuesxklw4zFmGHA7edb4beeilLJoWP4AkAmj4w553mxbkhcx5GWYHpUw3HjLhd2CK0eYqnPDX/r +tKEMXJkcchC43FB3oq3Y6WAemJtoG8lTttptSTtZIxcmKTrr1IE//yaYDwZ7jViq4NNUKHvjROGO +WUz/ETYjG9zKHZyslHSbBtdS1loVJIZGpjgmvXWcElnvjGKu8cW0GNWUk6SmxHMXaaZzbHMq1saU +HRcphYGZkuA+PQgPzxTBX7OfbRcN3OsujrDStBsaLnnh6q7KQivNflHCMFEahK/iVZ1MnXc7ul2y +q+skXrkj5j82S+gIVRRTwxaCmkRtaePLaZP34BYS436gu3bjtuMiF3UWFIqxc82dKYf3F7bB1wt7 +wTtVl42m3vEsOU1jCq1KKSqLGbd+pamXmjT0hi7FThv1gSmC/sSrp1xuctNUuGp1nxm2FhrZGBCm +20lusQ1vsuSI7XmTLcce2LCUaS6yLrJfZH4oKLIiDSsLqezDMzdL1hzHtmTfflfa8y8tGTw5fLZb +Tm36B2j23O9CCwmt6RQE4ejweJz7rvJKecM25s3OLCZ8ACckBM7xAciVySYDdEAuSGzdzJDWR87d +UIKEeJz7Hd4VsUFXkyUtMad4s5LmTSYAQoMGvvWUAQscnojyU7Sh1tLYRt2WJuQtb06MeJyNVV1s +FFUUzkCKS1tpy24pUGhvqdnO1N1taJDaxS7StQWKAna3hURie3f2tjvs7NxlZrb0B6y/URNe9MSM +TQxPxsQXg9kQ4oNBEuODiSkEjQYT1AcTQ4JiDIQHA5752a1bS3BedmfOud855zvfOff8harrX1ed +a6mBY9W+tXGeZv0ql7Mg1Gxdc4TR7N443FzbUWypOR7wE3xSnKskQ40kmzYPTYhWgyj4jwYJNzNM +l4jMNcMkc0RnZkHXSG7M4AVdZpG8qYsS6esjQceRnDpFxJIxHEO4jGt2rBHvPRiEE63+9UvfXX9R +Kr7WenPVfFcXGUrEOwwMmmZEpnKG2YkRdCUFTVW0LEu7Nj5BKHEPE8V0nAzGtAg5lDeVnDKLfkP7 +k65viqlcm0QUjmdckGq7boxWJidEqJaeJ2yKqgVqKtqkE9MLQCepojknDXRzyz2p03weCyAJG3US +3zKYsKq6yXpW/E/NUiyqEUZ1VcHPrjvWoJiYd4bmmYM+z9Ihokw4CCY2gyhoNRVVdZOhORZxwBKm +bmeIB3WWPuKGOsBmdjnGwYImmwrXBqaZXDBpSmWdlZ6kj2gFVcX+uQcwoDiUeI6nCzC7bXh+OSq6 +52iWuTFFJ/NwjE8xXaUzCTt1UQqRjmhHyCE7ktf5lJJmqI1wzKVvZPhZUZLcWKV4Zd47vYZglEmV +p6hqNfUK9bB4q2q/EY7JPJfj2lDCy8aITDJTXJ6gJJG5Mrj90ILJOwkr129delRoDP2Xl5joxsZy +TmpMXzKI1uVmIVBrmKgEeUymhvkUfNrS/HRnTFxCLZUnSv+qWXKU7w1S5zJCJLh0NTC8vBdLiLsq +qrAfj+0sY/l4JRXiVC7kUSfB+MWWlhKzbRX4JWrgy21vwEB7L8y2j0L0TkPx+3a9fnNlKrtx9kZR +/gzVYAlHhQDc6qlbV+ETgis7t9SV248lSSRa3LcjWwO/72z1B4OkbRkm0Cl/bYn6mDihQXfPge4K +EYkVDXyAOuBez8Z6WxCeZZDrcQqH7wY6yvopNTNFDYb/2R7VZLqGLZzCHu2CX6Rmq7VX8NnaYitp +y1hBW2WOK3vzP/uyeGMDvLFQV/xq957VflxsY2M4ZzQ/NqazHBYvWtefEZqfzOHkqWyvDYlUhLw5 +OJQ6zmQzVOpJNMo0u3hRZycKis4QBra/3gmf9/mKr8Z76mCxqQ8+Gy7Ae2831Xk+cXt/og7hYKJN +CEFjMiyGiGfT7Yk8XV3twZPlR27tbrX6k0InXB3dAR8kgjWOtpy6Jbjf3b7GzRLMJFmF5MZG+n1s +WjHszQkLI13W0T6hDr4bCazG0YI/Rl6ocpZ5cXz09iZ7yydxn+FgIGHmjL3ldEbTYa6pSLjBicZx +7XGdERx3g+C2ZRFyBDcpSTND1pUUM5ydz9U07mMy4akLbwgcMzKOfRzHde74pDn6nrQRnBVKZZkZ +ksF1O2aOlu6RMgJ3d6+qpHSqz0Rgu7X53WNr4TSvFxLQ8GIz8vHndCN8wx+Bu9Pr8Lcdziz4isn8 +FwL8dWKTL8FM1JwUAn5zE/DMGuj62Afq5mDxuH7DFzEziuG2NRzLjSnGYdSaZibsStM4fd5SJlHS +X9CiUbg3t6HI53q3wm9n1zcu8+4jpl5g8NH7P7SWb3BbjQbORY7pru8eFaUP79xpW23fu3SqHV6Z +fby1NGQru0tw8XTIJ6t4U9lD8/xL/uKZhdupqoMDowPDxTf/XvVgIcOH9xsjD5OvkWeyMoF3oPPZ +urJN2GItbhQazlcLvfsHV4Be0vvDoLNsxvkgQcO1JuvlQaHWGh8QnrAuD+KFIna3wyfxAGy5Vuua +IvuEx2Drt+uss/gGP/3qh3M/+qyf8eXCW0NCuOEf4K877vwIim/CAVJdEvL8hXstRAUOpFt4NUt4 +nFsUsDhwQ5B0vQIQ6Osr+OQnpqQWKWSnVhYrJCfmAXFRUaVCYWkqkCwuTUvLrEgttlZISU3OT0lN +UQgN8ilWSMxLUUgsLs5MzwOKpGXmpOYl5qYChYtSFQoSSzKK9bhAZifl5+fAZT2LffNTSnNSvVMr +FWwVSopKUzcHSF/iAQB4zTFJ9hcq6LsA8ABRSzkKHCXHtGxOAq/EuXicO9XG/KGNeUMDm2RqRUlq +UZ6CkrOSQlJ+fo5CZrFTaV5IanHJ5jo2K8HJ+eJcnCFRLqk5qSWpKZuviDsYTf7gzcYBE5ksKCWy +ebMXrxKG6OSSTB+goPnmR7k/heuRbCnLz0xRANoRHx/mGx9fBLQpvygVZGFIZm5qVH5eqgZIhZZC +UmlemK+mNReXvr5CApCjUAJUk6CQnp9arJCUmJytUJKvUJKRqlAF1KKQWaJQXJJYBLRboTyzJMNK +QSUkSkchv0ghNMRZITNNAKgysQTotzx1oMLUEr3JiuLCnDDnakxe2C8zmb+Sgz8zTUFDER4CmpMP +tGlO3juZnyU1pzh18v4c7cn8yzjxux3o0M3HGp8KTN7bJsyOHEh+k//oAwAHQoc1/BYNfL31hOul +wYJ03NQ2KSS3qILuU3icm9zGfLWTecOmMvHc/JTSnFSP/PzsYqfSzJySzDznxOSM1MkJZdqbd5bJ +cUqB5YNS01KLilKL3Iryc90yc1LzEnNTNSZfqzdk11FIS8wpTt3M1qDFouMV7JtYoKUApMC63IsS +CzKsrLBbMVkwTrk+KT8/RyG5KDWxJFWTq5pLAQgy0xQ0ICIKamoKirnxOFyoCVYNAjiV6BWnlmik +5+QnJeb4J2WlJpfo2pXlamjqKJRkZBbrAJ05eXYRjxCmgskri9TUilJLSovy8BieDjRcc7N2y1Im +CVyu2HywLcgGAFMcg0j2BpcbjgdbenDNtoPksI0/Nw0dOXTmeJxrSpqQvGE9h7RvYoGWQm5+SmlO +qkd+fnaxU2lmTklmnnNicsbkBVJiIkn5+TkKyUWpiSWpCrYKJUWlqZrWmxdzlLBLewUD9dop5MZj +6p6sKaC0WVzgtQIAkxQk9/n/ASnboHESz+nPiwf4TZP2zUSvMfl7eJylV11wE9cVnmtLspFjwLYs +/8lhbfyjBVlYZQhUxnZlE4Y4cWyQsQihNWvpGm262hW7KzVOYjyePJVkHMgZsrTNEMhkmAQ6hHbb +qqQFDLykk8lMHtLOpJDELU4fOm3TzvSlhXR6765sKbYkSLIv+3P+z/nOuWevLFg+e9F67Nzxnod+ +dulDy5rHpQgelCIJAe+SpO8r+rS1B00rKqfyYWYg2O/3DwSDUkIO437CuIGJZVhDnBLLkNwG8+hg +G5OMeZg9WJGEJI6Y9DZGMe6s/Vk7Qy4uoUrM+KSKFaY7TfKat7EwUeWdVmVOVCawPCKFRnYGVZkX +D7nZroxsQhZWSJJv3gJyozisSvL2BC+q28bUHibCqZxJoU9eLh7HYsRtOOX1KnFO3OZms03GZSnJ +R7BM7BqRhvB4QFFwbFyYhGN/r9lBDPr9MSmJ3VQf6zG5zPiHZP4QL7oNlr17HnMTV1nCQW+mBRmr +CVlk4JMvvPCDeHVxl31K/43tiGsdJY5LkkDMYwXLSTzMqdEdWOBjvIplRd+6vhU589B2t5zthOcW +HHD3u6uYR/Ek8XwCq+EoiQ6H+QkeywNBpjf9TQs1IaaI8WvHnMgDr3N+6LxUr/W2IitsPVcLXXtf +LCYq4PO3ql2mQG6jcHfvZvjtK3a4+4YhXQUHRoXWAgIeZoITFOxh2iAQqoJGv13/2+h+e1mWjyCO +DVLj2jUfqnOsCIGkEK4dDDiHc+o3hNqfUvpIEjEnugs5z+o+bltJx1BCVUilGTWKGWVSDEdlSZQS +Shr6HVGCfSZOBD2UA+LRhhKjhps2wQvRNv3X0XcrtKPlqMrhZ0y0L14URnDgV5vhMakCYr0l2h/L +USuc4frgg2SFNckJCawPPfO7qpevs45gWIpj5nACJ7Dx6E7GWHjp+iB8MrsPnj55EP7wURPM7Vql +L7wklNhMO3Dkcnt9LkETY3D8+izgkzXQeyNilGjgakjHP9pV7OhLiGNjUU7JGgNuOC459Tdf/RRt +4ScYd4ayk+bP0Oz3y/gp0lT9kjgh8GHVfUiQxjlhaJx+BO+briIPA9tPsgOqnMAsu5SKNNafneqy +G9+ofuKB388rO0jnDMl9RA/tkqUah9QJs5fhX/56+PdPn2iYMkXNr8wEL2AiQIvJdEPg5appM+IC +jUN7geKua8mFlda8ZArKqhLi1ai7mdrwb9rUPKawbFZds6bRUncr8e3LVaVLsGiLjipeGeUEPuJm +mbY2psn88nAsrk5q6x5EzkEDYUQrJVDbwUlFxTEahDtL2aJCykzYyABr721nmaa0N6Kk7pQSYgQq +tjgCX8qSof7LeuiVN1m0hvCarxYe/0+p1tqM3GVZ6uDyqd/Xe/IJT8G++V/qj5xW0HBfghdUXjTR +xIybb6YXmZTmwhoTXXzNh7KWXCAeT4ijg2wmXzB3JrjUOVtff7+kMd9QUqhV2P2IQ288p6CGQiP4 +6HmbBXXC7Nt1G78GlEun0uHDp5854cg7Dd+43yxGrWYC9TA7sxoGu0s3fr2MugplVLtgRRwUX2xs +yFd3Opb/mXRo37ahHl26WFP+FabUT65UkCnVAM8HKuDD81Ug3thCJ5Y+cHWu6L7V/NwYdD98/gG4 +9VGDUfE7N9aVFColHD3fr4fee7pgvQ2mB973r85z7MLuljoYuXnWRd0wujA9pZYwQI+ykSb0xJ4I +pttOZCfppOGldiRZTwukycFFucysytNpbW3G6d17P4Nrme3s+aUdd6KNQ2yBsbPcMyJtwF6V0jvX +Mu0UC3GlujN3RFOZJSs7R0Sjtr0Z1e8jz1mL2AYmyctqghOyredJSC/Ttkwj48/YAO/HtfraW1ZL +bT4M69Xz+1Hpoj1o+u/tpRdt3ooc8OMz1eC9U6uf+LOA4MorpbB3wamJ5chlocuxdqoU+V35N+Zk +TPM5kaOIZWH3M9W6fcFt+wqbQ8ki1A9/3AsXv7Boswj5TryGGK18DXLCB3+xwgVfOTguu7TGSuTq +yyyopkc0rcuOEmNlxaKSkHFQ5QUhIPBJvAvLxFW6nUDTJRaG/7EWbE82wv6ZDv3hv95cc4/06N47 +I4hub/obd5Mly+hjb/tQp/Y9C7qcp5m0Oivqr/SsKKN2wIre8+Yrm4csFzlkTjtQjdZjQzPUndSf +bOhJi3bBgb5VSstCewOu3XafuIrs9y5ZqqMMpSyVabRnGUqVr0WeIudKAsk1C+XvfEebd6DVqV9U +oqsol/irDvQ/I10wM9eeuu1EEoKum2X50jNXh5o1tRYNP1hgDJNlCQ6ur9cWatGteyg7nLcVUr56 +VGmvGAiOUiQwSxDSPl+P+qZpfN5DWF0cEuSf0YhtQ4aR/Gt0Z95Ia3JKOv4MHLO7cyB4P0sc/Wnj +Rag9uLkl9/6fdossVyPkWNS6WtD4qozzZ1tQIO8Jxkx1afM1yKXZWlEsS+i5VvRQnhymLraid0u0 +NS2oebWRkzD56ZBpVuBMe3dTPhezuZq0OR/anDrfgVLFWlkHavwG2taOObQXPMijnfKh0/8Hbm6d +tvkQNC7DDQ7M/5d9ByNvDTGLNipGLYh4nPusdUZngw8rk6HBZF9WGyC1uYt1AmO9AhD45qeU5qR6 +p1bqKOjrK4RkpCokJ+bl52UmJ+YoZKdWKuQmViqkZKalpRYppBXl5yqUAFUUJJZkKOSDxFJTFEry +FfLzfPITU/S4FKAgoCi1OLWoLDUAqM4lNSczN7MktahYByxfa80FpktSczersjuwKkKEk/LzcxQK +sOqbnMrzlbCqzVG8KazS+BTsENrNBABJrliC+T9jNbutJYFXei4c5y6iyzzH32yNk3iclVJNaxNR +FKVNi7YpgiDUthRfWoozMjMyod1MJGBTBSvpB2pFUcLLzE3ydDJvePMmtqSpUPEXvIVuFdwHZuFC +cOdOBRERFOkPcKNLd85HmqTVgt7dfe9+nHPu+fpp+NHecPtNOnibDtD0CrVgo3iN+syENUYbxAJm +GCYDzEESv3bmRhb9SgWYpyDxTBlPe3HldUwcLtrK3PoDhl0XrDXqEU6oI8u50VEURjK3QOsusXH0 +U8BmDQzjigUOJ3wLmVHezZqIulGVp4n67tTxbvJ6d7p01KirxLEM47LvmNGj0p1QITY4uL5Px+r9 +uIxavglxv7WEOVZQsyV+bEwMopZYUtUTjm/bLmcdDsK9NRO8U5+mxPcddf4wgFxcEwWpICmmoxHv +YgimAZIsJxPu6tKkVgW+ypJ2kKo2LWN7tXwPTC5e6JniASF6WM0uyB4PYIwyubcYbA9Qs5tGC++o +y+LLwpgAfepUo66ZoXYxWklW8yGOG+JDdlw81+eH4mpNRw/l/v44Ei607AFrQB/tA9gVlFihEG5Q +0H+Q8B2bOPdDyzBaZbgu9rIjT3Bq4LT4pt9c9ni4ySyZ2OMX/mbNc3mptza6Z/wayq3mvRpmkFQX +sRt791jHu+J9dnJQzgktW5qNjpVxk92XNsH0OS7bIB8WMXicHUuFM87UDt9dK29xiHSVjhSg70T7 +/sh0vGctdrr/kD1oLbRfzfIa8RKB1TzxVigvUIfDJicVApYko+1tJE5+nAlu/3TO/mPx+ZdDEwOf +138De5JhUPUEFyIC6e0fFZysMOw9IbgwUjkOX+R4nJvu8c1jw3FeTq/gsMSc0lSF4smKiiIqIfme +uQX5RSWOJSVFmUmlJanFGl7B7jn5SYk5/klZqcklWjoKk2t4pRi1Nh/hDRYDAIc9GHv7Fkk8Wsxb ++zUwNU90EkrHBbu+evWzeJx7+Zqx/ynjhnWWm89YyjJt/mojJT3ZNiJ/89aIe4wyXsH+SVmpySVa +Csn5eSWpFSXWXApAkJmmoKE4eVWUGacOTGKzQvQ6xnpHhbJcPaBIcUliXkmxnou/X0i8M5BwjQjx +dIuEqVUvVshIzEvJSVXILFbILClWyC/PU0jPyU9KzNFRKM5XKCrNU8jMUyjJSCyBaQHyi0tSE1MU +8tMUyosSCwoy89KBWkHKEhXyUssV8vNS9bgm14VLSJYkFqWnljhD9dnCTbCfvCrcUEhHIS0xpzhV +U8FKIa80J6egpGjyghi1yf98Oe1RNdbUKKAI6NpBDcpMy0xNgQSLhqamQjU4RIBgsky8/uTueEkO +WJhMviBjMDkjwWeyRxzf5gsJkqIA5OCCL/gCFg+tRJ7pQIfNOHpWqmiDzHQ9LTB4nHs/m6lrDtOG +BWKSOgrFJYnJ2W5FibmpepnFjsWVeclgzuZ5YoHlAEIXD6P38gMEwfv34xdWvP+8iv3C5KHOgALV +AnicrVl7cFTXeZ97z+qBEEKClQQixEcIxC4sK14FsYIVQiDzkhASL9uN4e7u2d0Ld+9d3XtXDx4R +bgt1x26De1t/cTxN1E6NnaZtYOjMNmlwcPNwp0lsmDKTSWvXpqnHaWdw+KPOTGcy037n3LsPPUix +G/0h3ce53/mev+/3HX3tYsNLf9tw5SfzBxU7vU/XVJ1Z13/wWrPzcktNxV7DOGPdYEv+6bTz9nO1 +zruXq3qGdSVrpQ2bjhnmGWZaNK7oVFNsZtKkkdMTVKHDe3uG9pzcM3CM2iZjYXqAsSy104xaSobV +OHcuLw5kTSNj2EpMY5Tpo9SInWZxmxo6ZaPMnKBZFJg0zEzYuX2pxYld+i4c/A9pwY3I5V1b4faE +5FuzhppsJKeaLEF3UN1aF42bDHUYwA2srBJnfYY55C6Ahpekzc6tn/ichW82Vxe+cv70zsYbb968 +/Jhz+53K1Y8oC25tJkvhxBR5DK59UW6A9x7IVc6D79VXiO9hx0vykhvn3sUXvxYVb7z40ZfWv7po +pbRpS6iGej/7h3sjkR7TVCZ25ZJJZvZomhFXbNXQ+40Ei0SGcrqtZtihMZ0l8ouOS6/WhkP/x0dU +Kb+Fe98kfrjydWl3vj4hKdKS0t7T1rH8CJO+IX1q6YDSr8LqtPSth+/w07T05v58zzel3/8cfOFD +qTr/Ny3y72yp7svpcb4Gfn5Kbs4fOiwvXZ7/S13eVtGcMRI5jYmk3ZVTNVvVe5V4mkFWk3fDV9ql +Cui05SDcPyLPgwcpuQpsW14PBw15IfzIlqvyH1gy00lgNAOtx8kKuPBv8hI42Sa1wdpWqUkKws77 +8sr8gZ/KsYG1NZaNisbpsG2qeoomVY0dHTo4jB5QxwNxQ7dsivftNGdqzvmPWwj+hR8Mk8cmQ/xR +OGkqqQzT7X0J/KUmVWYeV+30QaYkUNpALhNj5rCa0gPBYFfNhZoZm5nMMrRRlugX5h5gE96G7uv2 +4vsQnf7cQu3a1PFgzTnhcTVJA62W0DisWnsyWXsiEKTt7dS5oNEAPVcKS842aBbhARO5IDucs5Od +AdQO6F4SglduEv/htDLKsIYZhwRDV+OKhsvjhomKqHpcy3Hb6Fia6YgR6BzUJ5vVVKwPgQ2uIsVN +uXZw+w3SCFf2kooFdiISian2ybhi2duhez1potEA1ymcUGwF/RQSGoY1pqfsdABv2+HFfeSzzutj +VZMFpbuE9Avid0eHi0uaitCFmq5uWy0kWPQMm0CdNPUMK1QwukVBZMsU/N2H6NXnRrwLDdYm6Oru +1dRCY2wLbXPXcTmuOYe4LarVE0MtcjbjQBsoqCQcXhTMXx10LSgt2F5yumsd3PtzebHz3MfzJ1GB +SMTLPZ5AXKnhCctmmembhC2RAtwtrp+DXQUnDGClrbZogiWVnGbTPcP9uJ2iiXAnVV3R1LOiIrE4 +VcViFm0bF87obhsPHy8ISdt21op0dKRQh1wsHDcyHTrKPW2JPx0xzYh1jG7cEu4Mb+zQ1FiHqqPT +UXaHa7nVwaxMh6dt+LTlTH7cDM/3kJpJLysw/03b4hYGME5B2k1XdK84adEIXYF/yoyaVSslSJhd +J1iI7mV5RRQf8k3hO1sJPXr8SF8kwhMW35Xeey4sVhIv67RiHc5hA3PrqPCob1axY74618f8y3fl +9EhkrrTi2zgN3/XPK24HG/aQxvzNDeSmtIHv6ZoSMwwNu6wSP2P1G/Ez+zJZw7SxTFXLvexFSEVV +YEOULIe/ukMWw/gm8uMlXGHc++RJ1K6/BJoB+MZvkxULRb3r2KdQECYx3NlGDu72QMBEE/Bxq8kQ +6k1s+ufP08I1oshRHRMJKUTikDmQ07QAD9Wwl3s0Av+wjRw9URSPGqAo4QPb8Fbx52WeLdt1rtXu +G2893H9GWgZTUbm2z8zprllDbk651qUwDRXtkOAaiA+eCnhV3CCEvsyxEE0qmsWCTsO3NtVwV2Fm +Ym3AyGbSDINflH1NQq1CdbmoyBego1aW+AFSC99kcdVc6hfrs2Qw/xGLRrHeENpYWXiGRWb32Phx +DHFklkFlWxUkwtEpbGSztcFsQ22mF8dDtMHy7kFExz6aoF5tsUQKATuNXrMEdqtu2p02YuVIr+qW +mihhKJa4FHT+eqB5ZcmkPmbH08NxI4vUxWTcjF5DT2pq3IZv3yVLWkraYo3zFqBjUhlZG8tnw8QS +59r71fDjB9i9/3M7WQbDvaTJWXJ/ARzaTJZtFUVbbJgjOYaomHD7s2ufKB2B2aJk0R089vnEZvIh +2YdGe1QKuWguhabwVsZUbHDcYIx/2uDMzsqyuKhoGmNIWBnmtc0XcbRIYO9LOCO9jc61Z30NhXIb +dMUFUvCLmxJ16vf54EAnqYUvd5IlUP8d4oN5X8JaxWdhGJwi1W0zlEc9p5MNzix6pkhzTckWRxlo +cmUt/BNS5zz9e1X5i51kngR/vIMsls2h/Og2UiNPetE9kmaFvDBpJoeoklAt5E6pnGqlkZ6jFWgp +bwgCExJMUzO8aVo0iYBFUTtTZVYpaVCk6zMvL/jKM94IoJqUjbvS6QnhIBTN7bFE1+L+1DQOvkVp +Bc2GPJDxQrqjiDrug3Iwhvcj6MEfbiUdddMXQUUn2QRqD1ngRCcq4WAXWQjHO5EkYNbkf7eLrPBV +eZvBa93ked4tiz4NTcPUEIK7xdz7fiXLkQJSO8nnG6YhA2/CcH8n6VxpFWI3I5plxKsbQj1keT/2 +tDnTtcwXiTIeVuKA5ZsWOmL+5R5yQq6f2SDy/9NLVlS1e9W8f3gQ46habI0XsKFpsuFeCCHkyh5M +T+N50lQrtMFoDNrmdhi5igRt8Dapg7eHSEvHTMZZcD+fEtxnazzQ4WPQMfjK04io794mUaA5yQe3 +H/P5oPIEaW2f1ZnKoW5dNJbTj/UHgvnPniAnJAgz0pb/6hMkLGUw98R6ZCvIYhITJZfxssVmRseQ +RFDO0xITmM5ovlLEU8FrPCw7o+oJNwlFRDVDSQi/iwtzXZT/hZ1fJS3Qdpc0JzguZW2zNMqco672 +B3Fdn6akIpE9iOg5BPTQrDe7PU0uhIoO67Em9PghM8FdV3jmHL65Ak52++rmF5KM95z1SbKz0r12 +7rzXnHQ1XRfNMpNP0F5oscZ1Tp/2ecSrX42bOH9bZ3DYCdFZTyMRL7WLsRIja8jbNET/8Pt+WHNO +asyvPEBerIb/HsYM+PtxmS6anZdwfQiRPDQDtSwjZ8b5fTCfP0IuSj1ijCwxpGLgSo+6aook7aHc +ZV6RXEAoRVp6Bz4RnSgqNa0srw2RpV1YlqW3BTY9U3JZKu0QxPpYfyRiwQtp4u88YrgufWj7RrVQ +WY6W4RSzi8JLrCb+a2E1vBSPYSZix3WhPVDSOsgpTztsPEweb5xBbz85BeJSnDfeWfypKFDJGYUv +ymZ7wRoGiyt+BQ3iXp1fWMeHVeyoq4uaVQpA2AEbfkv+TNPcXMi59Y6/itoTWeTC8IFG2uD1A1jz +HVNkkdTlfH2g6ZHJTLOfz4OlOYzLdGkMDD5JDsPWqySyUjzswp5rIyHhE4S4WhdNctF7TNPAyQGu +m8Qvt+5wTr7a7jxj+btEMWDLjitmYlp+4PY2G7d/hX+cDc8tht+cQvLEfQJTW8jy5W6NuLDBJ4lp +LYFDXiO8dZdUEz4ZtN4lS6NzYdbsWgmVAz/Pv0J+NzxJOp33n/XBrX2kyvWFflCaDymTNGBjboA/ +2k0+484utw8RP9AoqZRysHMdKrIzStpqS3JDFAaHSYvsFe16LNrC8BEMlh1olPfSMsjZAW+My61R +8SbHZ94wh2wmSnHat2X4+3APzfvcrB3Ki3xurP9kflvr3Pq7+c6Vswtdt31tC1nEzzvgaj9ZXuma +C5uOkQgcGyb+ZhzFZovHoYy7CiaPofN/FpUWcZ/WwVObSGOHR4ln849ynxU7oglv7yeNzuCzFHqP +E+rjn8K9qLS0JLGak1cOQnCPkXVghOUF8NYJqe7FJ0hf34WawmkCJ6S9a9cWzlHcDahujCF35FQG +m/cp3sbDvFxO4ZzBodf7GLJXSdNkgY3HFcEmsfmrFk1jjXIP01OlKODXVmHbAmXgTAFXWAhrLs2h +AQO3xw4fDNP9nB+j7DEsNqQRZRShLB9q506IhTPcB/QpHFQ+ZRo4A9fW8PDDy0OuA/MfP0W+7BNE +an3Z4UBaSZR1SRdNZ/fOkWUydd77/ALnC7+syb9wivxCgkt95ICz/nsV8wX4HClC4H44d4fUhAUo +Pwr4Bc6qqcfhjbuk0V886cBeVBDqPHPb71z7rwpuQuChQkXwxG1J3ORc4kIzDC6Ubvk4KBaXT8B4 +XTYTZjGSzBwV53S7S8OOl7pdRRJSU/w4DLe2Ymv4cCtpqcRb3mhqO0lXdWEjONJJVi1/qFxeKU7d +/WUVYj28ECPNdQL9ixvAgwhpgtZ90mLojpF2uBcjfxacFUXumbloMiBN7s+/GScTxN0i35ciT9dF +yrKE517aNHQj53ZX1Go0Ey576u6DkxDHwy4ESrJ4VckVMz8vA1vomUSFf5kjH60MTW/xc7oD3mc4 ++HJkEEgWGsOx4+YYiVa6xQVT/0oCEB0nlf4SLDEMi3sGB9d/hrU2cBZ7xfkxshYy42QYzj4h1cOu +SULho3Ec+PKE1MOFZbKf5zusmSA1sHOU/MW6R9EuWDhBdgavbQD6iiQ0rIeGs+SpIfc8faYjMY7F +3EVa2RPn5wPu+WCgNWUq2TQ/QnOv1kWxjWcNRB7sOfzY7nGL/MbkzM6FUIV1EvZm7IwyQTXGT94V +nSp8eze/qZLk/5MTR+slnYQuAhZjOBIiZtk5U7fCM+UP5mIaH/752faeoiTFLn4pcFQ3qIUjPA5N +3sQq/hdojOku3maZLs6BxDk4nHpM9sOPVvnmr/JGkignGTbmKY6s7hMxi3jMA/lZI8z7IemAP7gk +L4N/1khtfbHI56YOGAl/SyEjPeLER9yche7eUeRL8HNOLK68ukaQH7ypghunyYrFWTXL+AlsmRYw +8n2C4PTs5tIGzvbnqsVHtUy3cqZ3PAcN55GZvLWZzOfvp3/B23IdXHtdqnRufeCDa1uJb9v/KyPC +zsX35sELyAKdb/97lWwkoPU1yb9IDFA4ZovW0YvEPgrKKwgYG2+R5t5CQL2+qOgGJoY57TwPe5w3 ++/Io8q7Es0hEUkTQuXO5ce/0ZBrhcOAeGSE08mxA0TSZ03DW0/jBjhCBO9KEqmR4ogijMN9gJCw3 +wj+u8tWtfJR08AJxsaLSLutD9F9ISy0uGFUTTHgTJi/Ja0SuzLNFL8D5Zo4YTotIVd44S0YqnP03 +g2K4ztdfJPun8i9RX6YBnqS+7nzlRt+quv8FAXPF4PEbfmPeyNo0KrxVGWnr4p2LStoOnGd4nG2Q +TUsCQQCGqcWiokuXwC4TRKnZB3TKsMhV28QPaPXgQbZxnHRrnNlmZwrpD3QKc26dDIJuUcylY5fu +/onoX0QiZEFe3xee9+W57Rq9B+P50wgiAn0f5FhNEmwxdpbGAjVsxDysP4xOwMzYppNMmdn9o5Rj +Feyiky7lzeJhIR86kRQJl9E8vHDrUDB+gIUFee0ScmwyiiTnmKJWeEfLqc6iAluTlRz0IqA53PIT +0iXCpSZEDRyqMkYA4hgKDOJAcInDADHqC3AFOBaS0592DzSd/xTVfVxeA7GR3WBhvY7F8JggrZD+ +ioxtqGM6rZ7IrHorBZYydqF6ipHYjfYx0G9RNKAU3SbmSdf3YF+Ouj8Pq15tQrfLd+OqXeZ6phJc +nRtxKF5fUd5NVC9cv2xuJySNxUZ5/mvkN+0roJIQT3D9/pqd/wagyqRF8QLpss3w/VwpA1NFYn0N +NfhlD56+A3icO6b2V22DkfAkYSWh4uCMxKJUp8Tk7My89OCS/KLUyfrC4gDUxAvs+SuBWXu2EMyk +X0ogmE3ek8rCPyO+VHicbZHPaxNBFMfprrmEioUUi4j6emvFpicPNsWYhvgjKAopClYJk9mXZuhk +Js7MJqYY46+Sk15y2HtzF8HDggfBW6/+BT0LAW9ectC3iUIP7nH2+77v+/28r78yXyaZT2MvU1I2 +NFhxQsqCFG28jWb4+szFz2Nvcnq+4oK7olZ67gyzw+PzS2/HC4Pxwlw8XvBG2eH39mL04p1/eS4X +vc97T3bW16FgQSgwobpVvAIBsgAUc+QK1jG+B1ZqZ6EZWgdKOzDoGMk5Sjmdcw2kt2chWocBcC0l +cie0yqajycBfjn/kvVEq+j3wL0T5G97ZwWHJiw9L/rlry20tAihXitXqw3vVKtfNlkSHBSnLd7Yf +SKZs9OqDvxgd5b2l6GPKn+8XteKhMagcJGoh0UArEQJnVEBTujaTlIRCMQfMICUGqdUuCcuVNYOM +N1hNYjYN9LWba9cbyFrZ/6xeWc2le+l0QgeawoldIhIdvfQ379c12dI6ZruKN4xWOrT/AIA2UEPX +QZxxSdwTD+HQsAQKDZ5kRPziq33/2NsqnHTraLNHietCMSn2/w5Kq0EhBkk5MbsYSmQWoRYKGdg4 +98b/6fWpoJkecceKfXyamzZ9tH1zY8MiwcPHaPRW16FdSUSrs/+zmtjUpgtc6lqNtjPihlOwgbCc +mQA6hnrQep3UDxXSa4tOLjVnkkLU62iyUW7kX0pNrQe9Az/uHZz6Fv4BgaX8//QiBGL1R7a9QdO2 +QyV1TNgqIwEiKdJ4nIWQvUoDQRSFUSuDpRgshGu3gbjpNyJIIFiIiImIVRh3r9khszPr3NnEKBgs +LQRhH8BXUNLnEQR7Gwt7H8GZXRZsxIEp5ud855z7+bCyeFx5+Qq8C6UEdDSj+IDJSKAeDDidoFAs +4nJ4rFWIRF6jnT8F9fl3sNic4TWGY4QRYkrAgPhQMgEmZgY4QYrSCUFJe2XPJtbIIrBs0EhoCLjd +cenVBFIOkZGTgdI1sKvVcl+zBCs2oTQg1QQmKhOzCEZcOEMEiRPgCRuiDz0LQG3JSkSls1DhyIf9 +KoELWOFD1xcjSNgUmHDP01LITbOIyosuUhmbJMw08TH6hZjMLAoClRqubLLds343CPqFQa8scWhd +Ue9Vncpju9DyS/C2/x91o/hcmP1m+JikgoW47DXmS6fnzS3bo6s0GCRDPhzhGLVNK5ARRn7+erOR +f9zVd/r22dK9Ru224LqR/ZXay9+f1/O3tdX51X3a+QGOacDV/Av8FtktX4cgEbD9SZJpkocRr+lN +HHicm7qA8eRCxg3izJzJOYnFxQqhQT6bRZkDmAQUgCA0yNO1qCi/SMFWwWRzMiuvoSFXeIiblVVw +SVFmXrpCbn5KaU6qd2qlW1F+rltmTipQs0Zyfl5xiQJYGZCrtjnX7BajUGlmXolFfAlUR0hlQepm +R4scRumk/PwchYKi1OLUorLUgMSSDJfUnMzczJLUouLJyy3bGHUmK1iLCcPtAbojrzQnp6CkaLOu +1QtRAME1QJvyAkVNYw6mfoctgA4B5K4IJXiwxFMxeJwBIgDd/5DGAqvGArCJQpNRPxWT31QFk8cH +DZN9KgyTsDwHs6hCaGD+hg3p+ANhtkcPun6VRjiI0FJvhtKLqHibKHicATgAx//4AvgCkPwUSD8C +6ZjsVhvCYjYXuNJVqkAR+H+TEAE1FKao1yYKCV6pWo9hejD0GckYkup0k1kBH8RXF+7/ASB60Jg/ +5lEHR1tzvz7z1TDf67SveJwBHwDg/+cD5wOQcBSeVDHI9XVBFtzOMLWZpuyJkOAvKLGEYwHz3Q84 +9RY/3sgvtpgBWyh1cDnLa49IxfF0Dnic29HJ3dbNveESy+QGFnHFkCBHZ9f4MCMNTQWNnMSqyvji +wpzMklTj+JKixOTU+DKjzUdY+JhASjlgSjefZJsSV6+vrxAc6OMZ4hrv7+sZEg+WVMjJTCpKLMpM +LVYoLsnMyVEoLi0oyC8qUcgvSsnMSyyqVEhJLElMSixOVcgvSC1KLMnMzyvW41IAgsw0BQ1FH8eo +yHioqR6OwfEIx2mCFYFAUWpJaVGe9eaIVAe+yWIHRbgQiibfSJXbvKa4Wmryq5neAU6hfvFBroGh +nkGu8Z5+Ia5Bfo4+8b7+LqE+rhrpOflJiTk6Cp55JalFeYk5wWBP6ygo5eWnpFpBgkAJyC0oTcrJ +LM5ILVKKL55ceF1pukMkI89m9b7D3JuPz1rAN3ntXqHJ75fyTf/gyMjSfHhl++GVjNsPr2T6KgUA +MO197v4QUqWJsBtGuNu+mpQ0seSojeT5Ap14nAEOAfH+rXqterBfEhSGQEXxIGIggjE8HA8pyxnk +7FkfSrNzEi4HFJt89KXEzvqZ8sV+kjHCiT9FNlImk7UZTRTljlPHEpn3dm/qwWPe6Oat+bzptrMW +GhsHFCj0liipMQq9f/Pb7jIt1UUkpPhps0UhQgIUdpoUASHeQdXk9I3+MSnsY+4eS7aTkSQUs68j +WgtEz/4Yelj95efzM8DEWWYQyWNWh+gxMDA2NDQgUGVyZm9ybWFuY2UuaAA+iKU0WFAST99S2uEU +Gx8YY9IzgTEwMDY0NCCTzyMVs2IvSwQURK8iViWRg+qt+8XMXR364HzmCNGzwTOrARTBtA1OOPBu +OYNMCwvdqEEEyZkGXrOANa0HhU94l/wBDqSw/uV6bAjTcC+a93i0SZ3ghCh4nHv2mWfeF56GFsYt +TJcYp6u8YjRoP8XItP0UI7OMBQC65wsV/5wBNZtVEYPFvRJ8kLKqogMKzuTh76p4nJVVXWwUVRTO +Yiuw/FjbAgUKnG0D7LTLFkLUZEtbNNGEn7bWYksiMnN39u7usDNzxzt3tiCQpj74gJqY3MSaSMQm +xkgUhNQYeVIfeDXy4gsh4oPxgQQl0UQxBs+9s9sfQBP3YXfnzr3fPec73/nOF7cafnqj8dLFLrl8 ++8BkEOWB+pEHh1hwkFapO04c8SznjMPJJOCn8yWqntIdo4IFAS10GC/r9dpjZvEmUaaAKL4Al7EA +nBCoF4gTGQgZ+EyUHb8ENvEhpEK4FJwtAoh/wmOc1nGH4l0HaVFkkqfl1CM/z8ruI9vkm9eW7Spw +4vim59icCRJWQpP5Nk1XvQyUXJYnrsnyx6gtMnAstM2qZwzImZG18rOvG9t45JsB9QuIbAoaCjMU +NAjThrxzpVVuHWvu6+npgReoiLgfwkSZYh4crHzkg9ptQZmEQPR/QGbKjFVAMEBU8OlxIQdub5GH +xpqeiAPSeajPNi8SmKpbzMwtVb0cbBtzuIiIO0hsTJVO39uSWCefH+pryDPmyssH1sz+MvJ2orFI +3JDOTo1+uGQSgztU5iwqlcFSeFYOrKpnwQSL3AKGQAvAfAqKRwhJFR85LTmYI1dhski4TpWCKo5N +XBdTybMqzc4FNVxJK9Rs1TM5LaaNLKa7kK7JmK9siYq0Yehjp5P6R9MWIWcKW1GxmKM8LaqQsMTA +NKXC8fAbX+/rGdax5Ildyc5B7VeHiV+AMUfj2GUsOIjBMvVgwhFlCDjznJCGiwTFVQC4L0/FBKX+ +PNww0s+K4CLJ+oAoEwGWTA61P2Np1kLEAJfwEgZV5MSjgPGCIxQaXlXCpTA+RTANvG+BJuQ7n2zv +LPrwL9Kaq72cGuqUNyabpvcsTzTJt86ueDRWqdw33r2k6smp8Rb5x9kWufdwalU/7IJTp2rylUeM +drnz5gp547eVsumDtR1V7/7C1OqC3ZTWapGvTLSsGmUeTSv6QwP6ZPsj6x/DEBXxpl5E0fe/3ib/ +Ptcub99braRl0eMOFtYC3V9hvWpIQ4HanHrYznGBbYZAWewTvFC9Rkopajiueb2aEArHdetYDh6d +b9h5yamPiygpBKccBduH6Jzmch71cjlOA5dgJykS5bUDmxszsNPolZc/bZMj37fKo1ebW7W/6DTx +oC84sYUhH/94XXecevahZTHqOkcZw+leeXGwe6QPaiH0LgrOKUJKb/7/ppO6uaFWs2Y5cGXV7FNj +356ZVHocVxKuq7ZCaaB+FbE6GaKaNAMWiQQzhWNXLGxq9wQEDFtW65doklUbKUkqADQr9GsFE1tB +iJBZ9Ao03tBV72PGg2hNHlCrc9Am0a/lTr52N2a6uPud0NQebqqwTB2WWaAILaipfT6U50balK9O +L12R2ChvHm5YpxHwuKmiis+kjd7k9N1koqNZv4z8Ba/lV9c7J/GeAtqWldEtX8IjIUQBKH7nWMJE +XBwFcca2zlG57v5RICWsy4JeV1RV8eJC7BTY2LiJ+ZrfUKAwc8hfGIVKFKg3m0xqKmPMWLMeqVCw +6mGB4BGt86fpU1ybRJg4+kxXDcv/tHq1UsPKgeMFLjznD0bYaLCjH9Dqu914r37GnopcsSdtZB6c +xP1wUh4df1J+eX51VypWma5RLFuU8rxyJ8oOjtWUulbOXGuVr/5wdcMDeLlcbXjLyxfWy0vvL5e/ +zjRMn1mWaGmoH5zem0wYGx8cChOMV0xVkOnvliXWoIks7UDI9EOuWDDH69c03y+/+fkr+z5aOrvy +x662/aqWFiliaqYSuxW7u14Aq+4xuFqb1Uo5Nb+ab9HYfOQ3pa3yxT+vb1LEzCPO1WJY9bEhu+6+ +RvHOp32gx20aCAc1g6ojLqekgN0Xe4i+aMH9PqbLgRNfNybWeLvAiUEF7lbOGIeHMotQbEWcP4Vs +Ut4519Kg2JLvXUjJ89ZWOeb8Lm/d3Z3olTPFqvw8t2nH4lDTCyqrzJJrkaBVxn9mN//1bu4fCVh3 +9/IC9NnBRckXSJVH8iTRhHIWpPurWHZ4nLt5nLnxBPOGtkrh8MTiXCuF4NScNAVbMKVhvLmwMiML +APDRDP/wCFXeluteCF/Meq9sI6VSu85sugbFeJxr42jjmOAv4nbHcVtblWZk5QXTWYWXpa3swtPO +bkxOYnSK8Nw88aWs9+Xz+6c7nX4+m+HQlV0MhgYGZiYmCn75Kam++SmlOVBSL4Mh8Ez+sgn+zY4F +dZEHpaf8nxYyJeXOZHYmT5H3H14VrqiX/B3Gcn9xpEHyk1lMzy9uTmFaxAgA2VA4lPoTvCl3bfxA +St585uAZuSKkKeVgOsZ4nFvfw3K4l2WDduxkg1qWyVp2gpNtY50m309hS/QKDkvMKU1VSE5MzkhV +sFVwKs2zsipKLSzNLEp1Bon5p2mk5+QnJeb4J2WlJpfoQFSUpBaXuGXmpPrmp5TmpLoXJRZkoCjT +1FHIK83JKSgp2rw5Vpxxsr847+QPZ9kmH5BSmXw2n32zRLyoq5ZTqF98kGtgqGeQa7ynX4hrkJ+j +T7yvv0uojyuanZMnLFEM0lFQystPSbXKBdupV5SanllcklrkkZ+fXaykw6UABUpFpXlBqcX5OWWp +YCmge5Xii3XA4j75iSlIgpMj1ypPlt0uI6qUnloC1ZPiVJqZU5IJlN68YUl9IgBGmXDJ9gFNqDKZ +guBgp6PAQRWJIqWwDtggOnic62lhntzCvGGPKLtGclFiSarm5j2iAWsAYGgIlvpTcoV94Y8lzGsx +wrTHa4hySPaMhOl4nF1UTYgcRRSmNIPLxCy7JNllTMZ9m8XJbGx296AgswQJInr057A/kOmu7n4z +3dmertmq6p0MyWZRCAiiB+vQioeAFw+CuOSwIILmqCDoOUeZsx6DCPF1zc7sbObQTL1673vvfe97 +9e3j0q+D0g+LlbccEBI4tOIEQaQQxmrHAR1xTR8EP4uTECKuIBUaFGLasPYNIXdQgsxSBbF5r7JW +5l0utduSovPw00r+bjlWrsbbGq6DecdfMNJfYuumOXgJOlwHEYyu75Rh4qdlhvn0TVY1P/uXzjun +7lo8UePLF2eKTG5RrWsz183s/pxpD6brtgY3EJ0utRS6XSnakneojqLYoTPUanDHfN582/Rar5Zs +FvPH1kXzKKhec3ezGHXSr5MjptoB1cUgbsUoHaiFQrsq4Spahv31/DBgYP4K52oO8DQEJairMZUt +yxPexiDT3E9wpWyehq+bp3+/YN7ED77wSs/XYNH8Wb+wpimYJyJFt8t11GgQNX6WuurEXiDay3rx +MY/k3JlaEf39oFIh73GvHRFmCVqn5bJ58M+8+XHvrPkOPfOg+Rr16s88251h/vnpU42VzWF4ybyB +lYe/t7+qTo519/6sN3n+bPC1PLNBSsmfBGzxALjaUdCLUCKRcCwQIiSQyDWGxFGEPBwRM7y/qkD0 +UpCoRLKHDkXHpA2JXSF1gUUqJISeFGm7vLq6Cr1YRzY85R1cgY2RTAngoECQoHhfgRZkpcDdDJWO +SdVxoV9fhP2rqgGxhrZA0m1KfhwS0R7qHdNQnWQYxa4UiW3yJfiQt1D37eGGghYtjndcuovmt+AC +8/K1bbY8NWI539om05Ntdtn8569NJaihk2kwl2eW8o+brLpFuT2gQfdHxMW24SzVcWKr6Aqqcshj +lyJ9HuysWL2SlqmYifUpwAnO9ZHqQnNv85X8k4hdND9tzlbIvrx+yrOQCFwvm4/ca/NjoWuS+FgI +jmmGc2ehVhRs4/ODiL1McFMLJ2kmUAtEe9g/gk32fondyP8N2MIBNSbU6CGRPAUfE9EbLkfHxzBE +MguhGzQKiQnX8R6e7Jwd9LESEt6nmdkcNAA7spZIwmIxecEZ/QOPNqdYdM+BYYXVgtIJEKsWSgcR +har8bpNdyese+3J++Gz0SJZx2qaHRWKgheznv3js8OjWTfbNc0f3PXbl3P/ajtKW/gH6EMNNvqwJ +PLI7+ksnvKpxvNtfaHicm844nXFChEjh4Qf/XnD92pe086hNSOFNhg/qMX4Tc7QB5LMOjPQK7Mxy ++TUGFzJUYYCk5oHilxvZwtt4nHu9k33GbvaGLYwnd9WXlqQZmsWX5MeXl6RZaHApQAFY2EpBKzk/ +r7hEodTQTAdVKj4nNc9KIbM4syoVIQMyIr6gpAioL7e0BEIkxydnJBahqQFqhqrjBKkpBRkzPXA/ +o8a044ws2y/sYpRWAgCMVzMY8QIddmWomUGnkvwR5+vi1DS50CPeJnica+Vr5dugwyoSW8R7e8tH +tv98SodrbM4c9t/Kw+q62YH1KCMA17sMz/8B/mB0+dmSYnT5FkYQ8INwadRvuJh4nAEfAOD/mgOa +A5BeFJ6i3KeSYqqTxh7jKF1y5n8uJQDjsXIoAeSJDdb5AyUo0XLyCLr+mZ/uDWDf6HnluizjeJwB +OQDG/7IEsgSwGAEUPvv6Gzt6AAGQ9CEPLVAP5QvJ6DKTLAE7FGsMl+k6+j/2FiPA5W65I+uCDuAb +k3sBt3E7FzT8LJfi4tsjveDX2fjXv+C76p8m/X6xeJyFUc1rE0EUJyUUWaw9FIyi4GsLNcqmiR+H +stVD2K6graGYapFSttPNS7t0dmcyH4mtSMD/QOfmwb9B3LsgePGkJ28eelMQxP/AyTYtWKy+05vh +9/Xee/e98Ppn4c3jkf70mkAuynruyrozvdZCEXex7FOWogs+47suLGCbaKpcWCZCxYQGHReCjoVz +vQmY6gRWmdhBEXQJvc9aCE8dsDUQy4nr+bOuFXPzzmdJwtJ7zfzlgKVoiq7zLFsdweLpXq4VohUL +zavRqf7wgwukjLRCgR0dCwylsmk80DLewwPdQZwTwBHT6Yng3Cqxwb1jg+TI4gBqxsYvZF9G5079 +Ge/HmSn/3/FqB26H9XewuURKM/8L43mDDb4d/3TTyLFStu9/LBvZKL1cLGbv6UTB7DXOm1/JBxPN +TJjPk+fMt3Sx73O9LFh7eJBqtQpNknAap1sQpwqFlbYNJHEkmMSIpS0JvVhtM61go1KJuK5wy68c +gjfmgQxjXZaATzCqi60utAml8shik0Q7oBjEdny1jSBJgtAju7NHe7dGUsFCcKf+cGklvNtYCR48 +qi/Z89y4DrfhWq1WmzdX2Vez7140L9xJM8uds02kbc87zslu8efF305W9fz8AbXGPddIWe8qeApL +B9K2Arace9O1eJzbxbyLecMyRpHqzOZF01ffWW3FtrGiZ7u/UnTJO18AtZUM3681eJwzNDAwMzFR +cE4sSs/XK8nPzWGQijDr5ZrWcaF2xpzlfBlPuDpf75Y0hKhycQ32dPfTy01hOC4ZXBo+3e+O6FKR +hbIGNfzWWS1foIpCA4JDglwdfeMD/INCXF0Y3qRYHbV82H4h+ETjzAe6CopxrpYVUKXJ+Smp6al5 +ekXFDM/PFVqf1Hygtv7RbQX1VE7/jd+F/sFV5eSkJpdk5ucVg1ReO3xN2i6oLfvp+82LTxQWpFfd +XqUMV5lbkJmTGl+UWlyaUwJSfHB+6Z21kufUdH97mkSk/bsfY5XEamIABAopmYnpefnFJZnJxQwZ +dTtdLBZN97c42lq9Q2vz/50tKhIQVRmZRQzWx0q5eX59CLJrsD47cxeX5LK3VdOgFmbmFuQXlYCd +pTV5z88HEscTj5lmFFjmOmd+3SWSAzEjMy8ttSg1LzmVISzmyeHE+sgbXfHu5rW+88/NjP/NCDUp +JzMJZMrZG8f3XVGRZrx9SPZPpOHc81dsrPPgKvLAXprG8VLm7d41cZ8/tYWm1lbrcbYJmkMsyskv +Ty3KzEtnELkgn6DQyD7L+8fEGm7+HbMZb02dDDUlP6k4tagstQhk0v5bE6WdD8s6p5648ei/5/sl +ZoJzH0JMyi8oyczNrEoEBTrDq/pXm92v3Vu9XEPa9eoL/3+WH55fhplWAI8W7bkzmhfJW1TEf5jy +NGMd7xo2ofvnoKoKMgtSga5PBSlb/L/p5JsFfac/u66/Xub6wjzwOstpmLKi/PSixFyQKpmWtiCO +2I1v3/Bf7ZN+eHz7r7XaxRCXFaUmApNCWWp8cXJ+QWoxw7NZ5rcnvfaoe3fX5KB2TJO43OH5zyAq +i4sTGd52+ebFLVG6JeTvxvhG3bxjarmkOES2pLIgFRExO3/sTFIuv72WR0pCZNWVPnaWplX/IOpK +SzJzihm2ex3KtJeu1PVxM7j5+XbJygcGLW8g8mWJOZkpkHCySBZfwqV7PKOj6nCBa/JMm4MKL+IA +zhpdav8R17gC54X0GWffuihh1CVVioOsUXd4nDv1jn3bB/YNM3bU6+srJKTlFyloWFtrJlgplGck +lihkFivkpKaVKOSnKZRkpCoklOalpKZl5qWmJAD5QPmc/PLUosy8dIWC0pJihcw8hYKcxORUkPLE +PCA3syQzMSezKrVITyG0oLikKDUxV6EoNa20OBWouESPSwEJsOYmliRnTN69Q266wQdGlsl7v7BP +jj3Nwa1ga6eQnJ9XkplXOvlhojBcUta1oqBII7NEUyEzTQGsN7VYEcjXK0vMKU2d7N6qwIWqky0e +ZFT1tHRGmcl7d3JsXrDjNttkgQtCk+ekcU22nKQ4mTdXfrLXZaHJB65xNycd2J50gPGFGQDChmqy +9g3c9JyyRw7xF9txA1uzgsdcmb8YjXicAdYAKf+uBd4FkGg7BHfJgw3fww2RbF1raS6Yz0hi8pwx +MDA2NDQgZGlyX2luZm8ucnMApRvwfYj6krx+JwpLMcatEBpZqFuRozEUykH6w1YGXWjV2bzsNhB4 +oRwMvTKR6FoUx1w6jq3qsy0ZSgnlX8nN5fuK9YiTVgE0KW5vZGVfbW9kdWxlX2Vycm9yLnJzALih +C4FXODaimz81X2miz4v8g2T6k4MBPRRnj57jJ+2pLZMTfzImyzwlfzE1FpPUAT8Ul34OSxmy2qAr +iDlLE0QMklVFM4uTJwKH+llaxfNM0YqIu7Xoxw6tkcNB1pvOO6umdjJ4nKVTTWsTQRjGXoSAIkR6 +UJTXlppdjItYKWVjcqkeGhoLVk+hDJPNu8nQ2ZllZjZtLCUHz4KQX6BHT0J+Qf+Of8Crs5vsNons +Rd/LDjvP87xfz/yIv45/jqrT35v3OgE1OJBqDDIEM2QaPr4/qmkQUkWUs0/Yh85h5y2g1igC9Cpg +I056EAqIWITEjGMkucj0S3VncpArXmbgNBKN0EsEGRoTZwzt+x3L/mCPvp8TGgWeo8kzQhMiaoIh +aKOYGFgiE328IDIkwZAqRyMPvaKSOvQmtUbNXcqdxomM0GEuNFvwdJXQ9TwGVNsKba+n9RXWOykw +paylKDBXxcmztUWE6oAxh7urfUSJAS7PUdlRNqH7ItlvwN6r01VQVuACZcvMCd4ADbECjuflC+Ao +HNcF5Hakl5XptzvVYuC+f2yGqG6Ur5aSLAQDGY9JqGRENGcBOgtZ929kRM9w3hLJfgVUo2NxBTBP +ezddCTN5+dNfm48mKhHGDsyK0T4qYFHMme2/N172WKmx5iwnW5ULz1twHBsmxevUQlQb3z/KAK1S +h03KLVYwFq5a2W1hZGfdQTczbtORnYpisUm9kS1urS7fn7S1Wy/hH2hdTrSXpcS2lqKcmd4W1Afz +D0nhqYuXPDur3P/8eH+7G4QDQo1RTsQUqwMb2BefPratgHJu3z81bIRwcth5A2EignT+esudXu8+ +nH1/uXPrnxVm17tPNv4n/7PZ7b3tjT8e/oAA9wK79BbzcfLk+22WMn26msvKXz1naHicO3+Y7elh +tg2TWURy81MUMnML8otK4nNTSxLj03Pyk5onsmyfyMJoNxcAUd0P5vsBqQOQ7qeWZSf5OkLLhfMH +fRNFUxV4nOvsYZ/Sw94whfEJd0FpkkZyUWJJqqbC1ieMqkcBk0IKk/dt5ISUbi2gYigurWLDEYnn +yTFDTgJ4nLVUXWwUVRTOmZn9gf7sdMtut6W0t8WYXWy2/IPoag2CQkytv8QHGWZ37nQnnZ27zMyy +EtdARSUGIcIg58UHY0zkQQmKyRoxEURjTFFabdJYCfTJmKgR8UGMiXpnt9VCjD45ydzce/7ud75z +zv32WuzSM/FXJvdsZBolus0KRDOcEeLmVZdYaoE6RCVFNTeiDlNSzhu5PFfRuo3GuNZiLskzUyPD +1HVqOmbRurt/oE/QXMlVsyatWTnphYR/ukVs6jBzF1VmY3cpTFeKNhu21YKiM1vJcTyKj0fx7/K6 +JjowHBbb8Y/3YTGOr4WA98LETd7xi/2rDJ30cLdiPp1jhaJhUm0uUDJ1Z1o1TVZ2bgw3ei6OZwYD +nV5s+u5AQXVzeXxShu54sZQ1jZxiM+b2EadIc4ZuUBubZYjjBVsM4WYZEjGSuYM8xAo0qfPbFJ+l +VN9CnAgJrf33MTZSKm7YcK+hadQiFTJUz29O/og1YrGy5UcY5EQhWQ+L356UQ0cmm73Xp6K91HLt +3UqRGZZbh1tm9ohhDXPYNs25zN7tnZ9a1nSdDq/8LsS81ETEZyiGJ16VGr3MxXbvtYvrvfj0oVv/ +O2byn/M+NTV9dbX3+HQv/jwixCOGo5hUdxVWch1Do6jeA+0ra0SnucrhhCiqpSUrs+xXyOwmbVJ1 +F3X+8utZBwlMfsyXTyPQ0nx9WO+usUTMtUvUp+g68vC0BN1hXTUdX4dfRuAx3BEBCWf6xACukGHj +7LElIHkzb0hYkWEQyZAY8Hb8FMXlKTFenZHha6nHT1NhVq0VSIbUm2e+EM8y6EAyAUH8IAab8Ohz +whLvzUsJHP8cZFR+EwKds5Zp1VE0alM9mUqXrDKPpDAbf8gLKZS7hA5kWwONePSyGEVyQJKrNA4n +FtVh/rhHCm31e4cwfd6Mca40PkeMi/zu4tNUG7Y02Zbn19QHq6Yoqw6Za/g+4now2RlSLadMbQdH +D/B+JdshgJ/tF0IJPmsl000XVTfPYRbUIq8R31fwuy3QXUfjG0usZGm4Myksjun+Ns2rqfAhtubM +v4pAVyTb29tH/HMf4U2kobpeTOCAAI1NBaaVTJrijHJ3hH5hCcqHQRZIBid2Skk8GYVFgZoRnq0I +BGVD4ixtk9rqEPZugRAueQmWipucAvYcgZtFUslgqRV68fCY2IZ7j0ErHxihBeVfpDBeOMcrO35t +bc2xWrwFng/i+Cg0pG94Wv79ZUmiKMPt+LQILx97VGqofhSFBHjR8/G/++iLZZzNDytCK868JXVi +0z5+tD0/u3kwOvG9DuCZ7IMmPPQsLMB3VsJBXM4TW2BT1zaoRjLVgVUwJOCLQ0LURxoM1jWoVoVE +3fOMv1xZCS3/TyYPMojh2DewEJ9aCmE82Sa04UCGyziFQcmfOLz/oJTA5QPQjt9/Ag37T60B/gvV +U2vE0dMr1KyjZFWHKiXb5GV2nRyzdGM4PV9eQ+b3h5NM3VY9e1XsDuFlNRDGaV5j3P4rhPtNZg1T +x1VqD29qfqCapO6tlA1Ty6m2lsQHpoRF2K1IjXh5nbgaZ04IARw6Ditw7xopWH1YlBqa8N3NUvP+ +rCxVs3IgaP4J0YtxC/AbdqnSiMW9g8rRy5NVGbwnyITqW1F4nG2PPU7EMBCF+1yCVyZSlG3o0CJt +hZDoKCiTSTLYBse2bCe7ElrlKFyBQ3AwnAiyWolm/jTvmzef8vv96+Z2znY7PFGIsAZu9M4GrnCA +4SNCpMgDmwhq7cSQ7BmdJCM4IEqGIx+hTM8n2NcF1NQ1h6EBmX6pnbeDCnzQuilxlKqTm7wdTa8Z +/cztKB57SAqSQ/ULcV5N6fYDx7yqqqKBCiB0pPWKTp2xyRUm0qoHhaCEWY1G8oJjlfHJ2eRtIo+N +9uLJOfbYI7ftW4mBh5ZnXyJwjJyyWHOB/T3yjwzLHHWeboxcYBkAnuPozYX5nBxeYImxbv8hi7sk +OpcpiBX1DyXfHr3CiCv9ORU/vnmRSPwdso07a66lZ+lwQFUVSpgjUDPDzI54nAHcASP+zg7ODpCk +M/I5EeRZPtHUrmyU82o0vP6YIUfxNDAwMDAgYmFrZQC0qrOC2yGqSQ+r+NK6GJu/wM0UzpHXwxRG +BpJWN9TwdBcTD0cmWssnHoAQapOuAaEUPjPKgZMaRu9BKCXZ2h77qpb1Z42TYwJQFPSjj5FVz2Il +OwYtV0qbRyT1uktkk8cCyBRlErV3Cfn67Ca0uHBkM7xe541P1JPaAxuTvgODFFnN0e+EZCeeGQLN +6DY/tTtJ+xYqk1UEPxSxKc9E8iwUsWt1Yvjxpr4jPPezWJOoBEEUMaHwxzq+0/tA/+QuV/+Xfs/g +8guT/QSWVlCWCFXEr4+33uA4iSqaKSAXTIXNMTAwNjQ0IG5vZGUucnMAOhzlYZu5ipjyGirbdJu5 +2vL7V080MDAwMCBub2RlAE1vgz5T1LEs2cgP9FUdcc6qs0W+k+kFOxT6cefCNu2N4P6i0XD7DBYd +ZzRMH5M4Bi1asi6g+Xq+6mOh9SWRXFKXpv2/3HY0MDAwMCB0ZXN0X3J1bm5lcgD4MxTTzp+CWztr +nC8W1hzFr1LemzQwMDAwIHRpbWVyACmKWXqAYI7F1pUKgh5FYp3+b8jKk78GWRSBWgdPd8bkKWX3 +nYyLS2qlEDu2VZMsByJ19ttI/Aata+fyBrEdTdXobN2PHTafS2Jw23icAWwAk/+0ErQSkMYU1r+k +iPP7tJUaRlIOsVK4JEWpEJaR2iIU2pobT+JhtRdmyjgagyzDxZWzp2OzEAGcARS97kKwbJW6+/Hs +/3jRITLHA1LYuLPAAo4CFLCVzvuoDMfnLVuVp4XR/hF978Eos2IF0gNtkTad80Szv6lzHde5SntC +ShkIZPfTp58VZnicfVRBa9RAGAWxxdaDhxaLFsunhyUL2xTxoilRdrXVSmtLt0Vv09lkshnMzqQz +k25rldWzF+t4FPwFgrIXf0AFb549ean/wKvgTHazu/VgIAn5Zr73vffmkTcfx/58Hvs0m3RoBC0e +EvB92CSSJ3tkzXx63ibZzagg/Rr4t+FwEkau9adORFmIJM9EQFCKVYx4hALeSmlCQhSZpyNTEtCI +ElGB0h5OMlJ2M9YWOEVcOHnhTLmsj46m9I/nl/VcstlZWFiAHdGb7Yre8B2gDDCkgjcFbkExAnBM +cAg8AkVbBDCTbSIktGMiCKiYgKUACT6wJZZXCog2ltDIaKIqkLGQCINuUTPVMbAMWzTZX+HMgmGV +99ueEGKzKMxod9KyrYLVbinaHWSfBJnCDTOZSqBKAm+zPjd3MmLwf9POWte0/xbO9bWH+vqVqfH1 +VFHONNqf0cfH88GdxfwoEqIGinwwrzR2B1D9BRdLJEjklPs9RVlwrhBnKFeEWjiIKSODXTTSE19v +zA6Oz1UcZSq66ZRdmdDAbNTVh1PBI2NOr+HFkJA1w4eC/rBzhHPWMCDIUgB/EKpGxpBUmIU4MbAo +l+N5+sOvmU6tWl9CG9u11ZW7aKO69QA9XjGPe0vL1e3VLVTfXl5eeXIqnFZ140AROTp2xHRDsDDi +n6PocXNGKFZg0S4WwguL6rxFnFrG6kpQ1vS8IGedSy2NYOrvhxe7L5PanP72arp74fWX8e75d/c3 +mjbmRjEIc8/PY652TEjCXs3wVkUx5iZweJj54rztZmxyzvho5PKg2nDLmKapcV+vnVzSu7emdfJz +Qj87ubZ0yqZSCa4GAiti6VPPM2QGWcy/5DCagfkrOOVK3t99f/J79y8zt3kZ+QMYyS3dqQekIXle +F1M1aC4oSunx8nicATkAxv/SBdIFsEgBFI4Ml/kPvx/IS0/pNK9YMDCFeqmjk1wB8RRJ+hxYeote ++it8gi9ql+D8YgFVSpNhAnHFOBir+R/t8gbvixnayDytuOiupjlDJEGV3HicfZDBSxtBFMaZtUVM +JBg3UbzoAxETKgl6CYyNl1zaS8BLe1wms09dM5lZZkdDziK9FKQsdI/xTxBSSCn0VHrKsYjH3nqI +0B4EobcOm+jBQw+P95j3vd97811/K4y/F66+zhYlM8EpgggigxI1oDS6N/gxe0nyDJ4044u5ZQrm +CCFSvI0mU61WgTMplQHGOYY2PYq3wLA2RvZF4wEoCUF8M/cpq7q2R6GBQiTkPSkMzjO7ZKPVg8C3 +qwPTs/KOOmUClAaDuhNIW3OhIhz8yr51FlNAJUJTOtqpsMgLTbLtPncH9dxv56VAA6kA6sA1M0jp +5NSH7LWU36O0mX6swYRoMd5+7VP6aifZf0Hc9QleYygYxxJX2iJCoymVJ0J4nRNTKscLjaXkS9+Z +j2v55mp6LnoTqzw+RZZSTnnr45isJD9vSbZc35u6Vvn/RCb+cOHGf/P3+c3oiQHxn8XiWc0d1lxC +Pyf9A5IrTCFdHRj0QpR+IA8Tpp215M6fWX53PCI2HBszw+PRs/abf3UjuiHmBoImeJx7dVTk2WGR +DWeNtJJK8+KT84tSrawycwty4vPy40vzMvMySxQ1gkuKUhNzA4oy84sySyo1rTd/Mk5hZIcqb441 +bY81ZQRiJiBm3h5rymJ7efoiSVah6fwLmbi3H+Bg1ZICAFxUJfHwEY2DR+hiw3wjQHKoMH5LiHcL +wBhYeJzbKfJdbMMd5vri1BLnjMS8vNScoNQ0K4VqhcSi9GIQnZqXmJSTmmKlkKSXlJ+fo5eTn1+c +qlCro1BUWlzil5ibaqWgBNQcnwzRHV+Umqako1BQlFmWWJIaXJmblJ8DUYEwXgmonUsBCJLzgSLJ +JUDTNz9jDmZL4EqtKMgvKgGJF5coAPUEl6Rk5jvl5CdnZ+alK9gC3ZCWp1EN1AtzXRrYYYl5lToK +SVBlUAGIHUWpJaVFecVQsckLONUYFSZ2a0qCXFwMMjwepk1Jh6tW05oLAKL1XgvwAmhUtY5I5acj +FuRPKCPr0XZjIKcYeJz7yfmTc4M8i4jCraCY3+KKdxn3828o1rLtevO06tdkY5ZjAN9uDlz+F1IG +Z99Bq7e+/OzGLeCWBreMYhZ3eJxbIr1EeoKIiPLupjRRnqu+835cef22LuPEs8iAJRs1lBhtXpw+ +cCLUT3i9+sl/HS937t6XoPwixsQACBSSM1KTs+OT83NzE/NSGE7Vu22Zlly6ctHfjWE+YedW/Xxz +8cjkNkYPu3rpnWL+izNeH3r7a++bbbqCDhxHGaEG5OcWZOakwo1gYla+bPpBTLPuc3jTZ+G8ZVtO +fN8xmYdJSsRiez3z9t7AY7yFyzdevMTou6JY1WKzFdNKZpE9CuzB4Rr/1yzSLDtmqGxRLbUp/dvm +76zHWezPLZ56WrYmQEj6jk7UD27TvRLJzkaGBgZmJiYKRaV58VC7U/SKihne71iR/7/3+Q6elrmH +FsRe2JtwtW7a5L9cS+O6XpbVsm92uRiQv7Qi8rjAsbfH7i6EOL0ktbiEwSNPVc1PZ2mSfsqlm9ci +LxizrHd6ALUCJA/zF8iKPMelpyy3TWpbH2q2quRLyQktiV/TN/EsYQQAR/WqCvSzAs6yIogYVjq1 +L/TnITcsKHvcBNL2eJyNWFuMU8cZ1nhhs5hw6+7CZindsSH4GOwDqQhKze4KKAmIlkK4JJEwMsf2 +eH3Y4zPOmTFmm91689LLA2rhPJyqqZSgqlUTSgssyqat1KaV+lK1SagUqQ+N2uShUqVGDX3KQ6X2 +/2eO7bO3Cj8s9sx//f7r8I9f9L33oO+21bM6TuHjWz1PJTL0LBPyafey7XG3xlypD446vGg5IhOf +8T+JPTY313M/1tqzZw99vspklXn0YrHhUgmEF6m0JpmgcEotb6KBImiFe9SidUtWTXrSZVQ0StXu +bU0x4K2gvEItxzHjFZd6zCqLgiUKeFPglQKKF0abLeev+f3mFqhV9yKXs4G4KLjTkKxDlFaO4Wd6 +uqPQFNLypCg0bVk1iklzT/KhyBbTGaXKRCthNG23zJsiTXfupMZKvPl8Mv1/ZSNBOh2ficcR1Q6a +NJut2A4T2YrHa3TUsYUcv2jSpy8zb4o6ttti1BYhtBnqMjiHX8AimWfSQxQZlERURF0eoow8LmWe +x71c94oLW9rchTBHw+k1XEFR8JSs2u6ECo1VrzO3DAFpCVlQBhbQQAPV5ejO842nLmSi8uCs1pD0 +OVYaPcyvjOL9+HiavqTgdJikJe5KgEXQMcgGCcmBcRVTENVnQHouh7mgVXQvyrlcyWyWjXRGudkW +h5+Tk0ZbYpqOjXfE+7/6eEdw8odkPF2xQG6ZSq7SbCHM+JWOFsdfmhn1xoM7fyZbAr41Fu8BLcHB +98lADwAXvLw1tiN4O0E2Be+Nk97WzIGOL0UG6c7AkwgApsNcI61psBggdBA5lwrpAabgjag7tjR2 +tg3N0GIy7yajPqFojB4I7nDBvwi6yx5FBpqXeS+ZPhBc/xHZ1YeibLfBghv7yMDxqC31hqgadmWl +AsNfUcX4UaVru5Ibaf9Z93MXzquyMYFXOHaJYQyQ5IIJWkuWNNIhcUfITOj8jPoLypeAQ8fGQuiC ++78jRzMrBUQFW2DCqgJRZP6ddx/rVUkQDxLXSL9/6w/r/Lc/7fO/Ed849+3eLw/vN5G/ndQopcRr +dWSltoRaKOs0x6YVXpThS9l/sC3l758a8Wniqp+YHfG/3trkn5pN7FdmlW0xCSyWpE1LuCnZYTXp +WRBUbNhOOeyGDncnmOcfojvnbiXObd+g7rJoS7YOjWDub0f+ud7/y+kt/o7ZQT9x7sm5N878YNP6 +hVT+/RfAELZq7gRbu3U4A+F7sWF7gL2y32VN+jz3Jpk3V5797l7/1z/ra2UvNVxbZkXDBhl09MzZ +0+OI/jHehIT3WJ170CbGFBFteoqozETJs4tgvcNLk1C4KRfUs3KKGmVWsRoO1NmEfRkomYVlilQA +ITTupkvz+VGVQqgvnx/fm6GpimPJFK17rGJfwamAIXOtGnxVbQcB1zLw0L82b8z95/aNmP/R3S3+ +qZur/Lfm8sdoPlnj5QbEKp/M0UnG6optQk0kyouXWEmH0OFQycosTIqUoCEbtSoeE1X/zXuPD5Sq +FkRCYOFrASJtqrDk7r0Vi3dzzv9kYLB1GltDJ8vC3qlCr3osy1AOZVxnup6hBJmwy2r2ccHgrp1P +NWUdkJj0GVX8mMA6JTB/oJ8uoIIWOAWytF3/flPG/ON02yNMj2T/4+Gh1pGTJ1Qb6VYABoqXWTdM +GawQoIPKTF0SZV5LUWBIVaF1T2XxJ46H1MHLtkov1p33mu7gpSXHaCKOa9vtD/2nHMaCp1y2/U1H +jUdCSP0P7w61TijwdX2kUEkKLGFX6hCtlAoXgsPV8hCyoQam8AVvoFajOdcQoCSf1Obmk9g7ld9a +vl3DXNahCet5Xz4JInIhOXMEa4IqCFJKy0hpkUCtZpu6VIj7HwUj9hd1JauKhhjjZEKhVc4nI5kL ++QGpF9LCvD3bCUcGUx7zUfNhaAqdbITh4LAKmAkpgB1ms8VltsZq3JvKOnYNTFKl6r883d+CQoXS +h5WIOTmlU9Npt/E39C2VL9hnMpSZEyZ98uhhExYzIChzphpTBUEROls9PuFZNVwBOp0OrgSiYDkm +PaIRVxUiqy2mZqcFWelBQSnrMpggi02xsTAYQ73MVR3CzUCWdItHLzxggjNFFdgowlPri8exx4PQ +JkrKZiVogfFGhTW1RkVIAuxz+Z/v+JL/2wfDwa11ZG3wQQ9Z28KRKKfq4MEYLckr5goDtzt0BWYv +LmHC5HWkFLB8RWd/cvHg62w6SxedzKDeahZp9n/z6VDrsOoE4WKmM6y770Y2NkwOjIrC0MF5DLnS +bANTt4QA57DKdPBRLRzozG/yhqPmFsYPJioS6M2PWk2U4HKpQTYXLBGGgiwTCksvg51aRgowxhVl +BEXQktBswbNVMnQKVl6UeAbq1tCqUZziMqHKPNgDxKRdN55ImxVYk41pW07TxAp7hy3TwWsfkCG1 +oLU6416hpYVrvBbsanq8uoih7r6QL7rLhnAwzNYKd8oAC69ooHHW6IGHW4G5RylKZqKBD/71HbJa +rX29Wndw6H3Sv+Bgdmvs8e4GGNSnSXz+m6vI7m8FI+fAi3evkr7Mggm8ZJ1TuOk7wC14sZ9s++xx +ZDijznI5dLGA1hr4Jx2880dy+vPd0b1wvuveKroTG/u4mr/BOz8hO5Ttq1BOxPJtN6CWfunDtxPX +SXxYySuE8sai9gWHGBkMZvtivfP3rpLK8LqO/ZJdkcGmJBk4v7iNLe+vulJZ51kSVvuSY+dUm87l +NDNmxCVezOWg8QktX3u+L5td0inbTltU2F/FAplk2P/Q9317v7D/xOGI78rSZXwfAamFULeWOhY1 +9UDw1++RkfndPyZrSfC1V8mjKr6nIrNxeUcjBOjuomf18sEFFyNskZDibF9pkj9EeFtRqWNL7Ysu +5/BafE6PSAG11p7NqgyLnEOTcnUdHsbO4zStKdwaobzDR3/IYHbeQ3jQAyfB/WOkPx5e4zPl9itk +sIXQtFl0YRnT6AX0CfUSZCJh7MIDfOEk6TT8lV6D6W8V4GLwcF4O/vZ6F0If/gfGYtiJxn1719EO +5moDQaTDheEhYN7SFjK20Ibgw42xbcHaodhIcPA62RCMDsU29ABFcOMgGZzf9TqZJ3E03BYc6jW4 +MUoGgj+9QXZt1AfMtOGhhQKDz9wkqVZ42tko2o/m8DyCxlewMU5rY9rwaaOS6mGsAOw2vpAulKtJ +Ei4vhIJDwnVtSrW9Bfe3Q2OEnm0GG+6Sdbuz2bYZbSTzoUrYwwDOyDbfRXS1FrWwpcZmDgRPvE42 +Bxu/T1bPj98kf1/9AiTnochOBEMQnzztPJxgEnNWMJxvgof/7xTS2N19CPZFWEOgkUIe8xo0DjO4 +9lMyvL7zm06P0UTw31dAOejtDe74ZOv8xTtkjfM/xWSSdvcBfFr/Ec0Sp4JxhDceG/vTh8IRVXt4 +nJt2kmnKSaYNbnMnu89VZinOz03dnD9XnR0Ae9AJk/cLzy6bdw8dY968EFX0Z6kuYFX9FKR4nOs4 +znb8JNuGKbzuifklurmpuflFlbo5mbmZJQk6Col5KQrlGYklCsUlQGaxQmaeQlp+kUJmiR6XAhAo +RxcklmQo2Coo+YL1+ad55SdNjuWV5IWYE5+fFp+Vn7S5lteRmbUgsaikeDKjoKwKmGUNNgHVlKDU +4tSissSSzPw8kMLJ65PZWMG8zasEEh5O9nslMDnxi+jmbx8nbQQAx1VBO/UdJjrHaFSww6Dn1Tmc +aerrUqCtPsZ4nIWQu0vDUBTGsSpq6wPEtyKHilofDRSHQt3soILt5guE9DbekkBNSnLTFqUodBRE +OIKDkwhuglhf+B+4Krg4OXWzYlOTQdFURQQHz3TO953vB+cUTl3X567jjfx6xOsVEro3oSqxCBB5 +GWxBpCTxpXAQmZNUppN4iAiiJNNAQJF5mpZYBFKqxKgGTKRQ3pXiVOOcCT3qEVTC6BDEZNAYURn/ +7aqaJ7kSgIEVncEPdPfdV1GNXKEbd54vseWgA8ViF86bgIfFZqwq9eKR2YB3RQ5rjX70GX24YAxi +1hjBE3u+N9pw0apHf2kaX/fqcbvktvsevCn5UbI6ceDFh5uPdSi+nNrsdvSbPTZ7DLfMJZvXhG9m +IzZZ3chZg58cyZqpzDgzudX8bc2sLmskRoGmGVVlcAfdsOaEX/Xp2kdO6DLPh5VlOhfieY2yME0F +FZnZOW2KJOlk0JMkcZ0GIKoo8d39GUcrhgqF4TLi/yhTdZrzPQmOzr+/HAWBpYfGs1fWxZVVcfbw +AbSPw6H7AWGV7SDGL+lSGQlH/A8QDLnodTH/eJz7zvidccJjkTv8+SebFMTcbDYenX+lRVjBbdt3 +IwCzIQya/AHbnHDhgWBaefOfLPzwqcPYrOQOB3icu8N0h2mDB6NIcOlE+b7smdxmCg63NK/Yb3ok +lB4HAJogCvb4C7yOo56O1vAUFiAhu97RO4CteCEseJzr6mB+08a84W80d1p+kUJaTmK6QmbeZIEY +BcbiyYzh4pvdYxp0pRWQQE5qiUJmcX5OYklmfp6C7eQL3QaT87r5JN0yc1I9YeJWVsHliQXuOflJ +iTmTY3rVQCrU0VR4p6ZCVXAhm1+7+WjnVEZeEBNuzWSf7g5GxcnVC6Umv+sW2tzU22EGAMHsQBf3 +swF/b4ROyGbGOyzKcFicwNEDWz+OInicrVZdbFRFFM69swHaQlta2kLlZ6pl2610K0QMbFugBCWC +GC0EjaFs796dbi/cvbPMzO0PP2n9eTEahawwkaQICdSARkQN+2DU6pM+gY8aJUEefDD8mGBCIlHP +zG63u22JifE+7O69d8433/nOd87sGzfKL/9RPvqa8Zn587AsfcIIbk75sWabWYKEMPH8JH7KccnT +nLqWcKiHD5ViuLYTktrq0pjlrtL3Owet/P2RUhm1jcWZu8OmvWKdz0mUD3NBklHbimANHInYrhOJ +dLGEnySe4JFI0nK8aNFSeeZtc1HmhXfNe2jTIGX7CYumGHGpFedh26UeifYxmmwODiTDueehdk1F +XfAwF0MGLDcqD3xh1owUhdliqGjJJPasILmXUUYO+A4DksJiAnfiApBZlxRhjTxgpU1971/A9JIH +ZpekcVIcn39cGDMS/l/S+M/05eiYuSITGzOPf5nu5QH5SQ8K6R+V75mBmrzBIpEpL8nV943lsuKG +idNXB+fNWDhlQrVwvSz/zaxTCzN1e5A05MQ6FJK9nxpzMz9E0TtGfq/K6RDywAlUl0la6ELVUpWl +k39f7P3MQoFOBapdIjAjKcqEylWwCG6RVx436xsnH07pxW2aIgnfYvFIJE76CGuQZ1aa9enTqwMj +tuW6hLXSQY/E83iY+sJ1BgjHop9g5nvY8uKYDBA2nAdVV1sbTkEwhBFLYNslluensN4Jx0D9wTDe +ReAG0DFhjDKOLQaAxKYsDvv1OQHGRTh96Zsl8tR2s2SZ73Grj+BDOJj0BW4pzA8fkR9sN5vl6Dxz +vlx5AW2SPc+Yi9KVvwYyF4fQvTkjA8mcDCp0t8OEb7k7LLvf8ZQvB5Lt06l3ASmLucPAR/gMcnQ5 +BUqe5ToHc6n3gfDtmPu2TTjv813seEAnSeIOzI9ivFgb4IBUHFNPY4IanCgUh+HNvreLcLFKbQUz +xvESGt72GYPJgxPaPuEiQFXfSTJRxQN3yq6jZp385XOzumpmSdPXR+u2cDAtJFsUF04Q0RzCweCU +o3BnZ7GnCu2evn69JqCAZMNxVC9vfWguWEOp0BawbAG20LJAKmpcYuUTSIZRP9EP3w7P1l92BY3a +raDykxBmUzCZrTZqI0PE9jWHGOmjYAZlwJhl7+fwywPQVqIk1vJwu5/EfbCnBpPPHTXmN2UZhCDJ +vFeaW2K+FxWgb5QBUeWCkJw4imrky9+BQ6AVc7yzSoRjJAFjXuUAQVl3yoZStFi16qL0xP1KuXGO +MaeDeHFVp5Ql7H6c9LkAxhgoJ6gQJE/fETxXPpBXlRdGTTwsu86b9TK1D62XHa8aJbLidWDz1T60 +Jf3mi2XF4s5vybZgE8e7d+RE5VlVQSQt6LadSmBiZUXdAKKqgaElKiyIKlC+g6cqQjAZcrhQucDR +w+Wlb83aNYAxJTzY3vdsC5YLLKb1q2pj5VYq3zoHEuGTaF564qVA/UCysATZds12oPz9mrlYrvjR +mCs3nDXL5M0e6NW1e9Faeedho0re+gv699pHqGIEMusNNsFsF44NAoterA5F3LsNKhmJQCt5hDWH +eov7Nte7zBpsVUOBcNtKEZWB7ifIz4eixCn0rwee7acumBbHKCQzaO/HLoUP6mnExmmQjlDV1Tgu +pSkIig+HZSVG9Q2zOSwMqgrtouZQuzxWatQW1PXZMVTy2OR7XZhJWCgzkAC3dNuTM4JjOKpsEteV +6QAmcUZTqckZoTLIHWXZQa4mE4XJkpspynTQ/8RTCLpPTo+hsqpZWuLuXtSU/p5X6yNI12djFIXr +Zi0iTNuvz0K9U21mrbz4KCqXJ/82Kk6Mo4U6GopY1pH3msNx0TGSNWKBkR8wHh6CmVTQxYXTPiSX +jaPl1fjw4RkvjFfQcp3Gledr5ehNcNO5cbRK07p6x2yQmzaZlfLOOFqQ2TWKgo80KhHVKaVLkbd3 +9pCaNIq8fQzVaohwDyo5sQS1ytvjkHRrPdIqLciUnkU/GZffR3PNquLpymGmSHoeLe0OzThhujVx ++P864DDqqT+Zs/SXHiPTe1mZi4dlQyOqlr0HUak8fB7tydAL6G0k/+w2yjP+x6jW+AeTw+2r8Avg +D/c9a10s5jV8FMGt6bbzr8HXFnicm7ie9dpG1g3ftk/2C2eb/O+Q3OSV53n4QhLTrazcgsMTS5Iz +UosmJ3rJepdkZBYrlCSmKwCpotT0zOKS1KLUFIXyzJIMhUSFjNTEAt3iksSknFQFuD6F/DyFzJJi +hfzyvMy8dAWvYIWSjKLUxJTJgr5izApqWpPtD0tMlhSRY00tstPQnFz4V5hDLz8vPi0zJ3XyxI0i +7AqJxQqlxkbTHzoyik6+sIdr046J8wF77kHC/wGYSN6M8fiB96jPkIZ0GT+yJisNUHicW8WyimVC +kshhO27uyvV30teWcO44taY2t9rmcM7Gsi2MANEoDen/AbeXnW+Vb3G0ZDlEau7qF/hS62+LeJwB +HwDg/9IE0gSQORTTEIev5zL4CbVlzvaWBv+v+xv84rFNBQL3Jw/e9gJF27/WJWCwyTKaoBFRQbaX +Ov+2Hnic61zG2rWMdUK6WHlqUoFCcn5KanKxjkJCUmlefEFeekJjzdYaxt4gABwVDrn5jQTtKrKP +vFfjyk0VebWA1FtndCaraHic7Vl5bBzXecfM46UlJVKixEvXIyVTu9LukpRkiRqK1GUllqqD1hHZ +lY3Z4e4sOeLszGhmlodFmZKP1EbjSM6g/gBHtexUqR0ktmWw6BappVhBW7hOUShtYKNFYMt2g9Zq +4coFXCeB0fR7b2aXuxTpqMi/JSCK847vfefv+7733v281nur7vLSCm9jxemyXaquT71ScaFqck8m +k3WVAV2lKTWtZHWX2qbpOjRt2tQd0hz6tf091FZPZlUHR23VVTQDJ1TNpuaoQZ0hxVZTOJ5WbdVI +qvEQxR8rOxBO2oqrRvJU5aQiJ00jrQ1KdK/Djt960HI1c5WxdSBryEOua0mS4+j5RdJhTrjftfv6 +prbVfm/NFk64+KedbcyOOpKUdWT2t2Mmh1WXUXDVMVc2GX3Dkb03k01rs44qO+OOq2aQE4mOZOKu +7sglo8EGOAukCV77jtgKiaxYDi98JiyC90+K5eWqbUdDcP0doeHZp0i1t+2hiim6+XsLV80poiQZ +6mj4gGmoU1fvbW8Ou3FbdUx9RLXjI4qupVBBsqUkh5VBNdhJe6lrZ71nlEb4z4Q4f+pT5co2iFh4 +2q0rC7+KandU6iQVXbFpWlP1lENRS1SbtmHW1oxBqptKCv/3jaGrLjegZqOwrmK73k9frm+wbJWt +kktmejzhuZWTPcy+VNdGVDQ+s7Lje8L0McFmmjSzhnv7KaqRQkFKKMcdxc2iRyBXspJKhbOGo6RV +eoq2rx3J0NPxInZCfBcnPfXSi7XiJCOtOXlOkbJG+2aQp+3tOLq1mIOegsN0dNBdpoFad6lCE2lN +V6UEPXpoH4o4rFLFoAktY5m2G44kqGOpSQ1Va0vouUkzhbJOqnZSNdyYioq3VKeYrIKCDquqRY9p +RsocdWjKZlpDhl3VdmjYP6yjo2OX1DGWQCFoYpf04FgiSg3TpQl/OBIvkGSS+sem0DHcIS5Dw21T +WTfd3eP97Z+07tbSeVvIjq5h+HFtOPKo5g6FB9qC49si9FRJ+BSfQXvh5GPCkuasjf7KBuS0bWZk +tlXGsXA7KIbQmiw5JhLpmZUeYwztU0w+7pp8OPwlW+KcaNi7vGnlUMk5hR2ne0LFet99eD9lDDIr +FkAJIcoe5yZJ28pgBk1GtRT+1txxitN7D+83U1ld3YfUMQC9/kt3NbLgUXTHpEFcppjn26p369LK +eGuRy6F3/RY1e+u+u3F5qY6mmaeq7qhT1d/tERq4L3Nvk4c1HiZoQg2e88gyz3yppvKQfyKcf1do +x4E6j/73Mrh6QWyZSvxprVBdtNXrSjXAjbBYOXXhJSrB+U8QJJauqz7qB2xiJINexpSBTFkop6yl +GD6YqsN9D/Wi2qiTeIlRGHfmgKPaIxiASnIo2NUbgk9/ITR5r/yyciFqJYPalt0hW0UEaG+Hn46J +K5YUnxJmMR1Bm3n0w2XeTz7Y38Roo5y3kYaTT5Om9WyPjDz30gIqFEO7bpqWHKwJ848IKA3iYjjz +kVgG10+ScnjtD8XFtabhnx4shfsyQrP3w01LpmIfPrD4//Uzp3682IcHvEe+XTW1//O343D/HnH+ +Ahmzv2xgfMpO0rTgmUZMhhtWCy25N9qFdFV5lCkFHtkmtEB/p1CZO9Ah3Kqc7FdszE4KPWbaw6q9 +BnWsjqnJHfbgSKKHJS2DJavBEZpC/066+jh1NCwYaAJX7EFlb12DQeVqyb4EHTWzegqVrQzzTHT0 +yFdi3ZhrLE114iFEU7qKHkY9uOP8YzdqiyaOwfubhfWwqVtYDce7hTZ4rFuIbWeKVY0RzTYNBggy +MpCUaNbRHla5EAgMGPCai0DEmGXzIxIdME09GorQWJ/3wa+WPugLtDsQJoBSLB0oL3EkKalrkoQ7 +s+wItAmaWleSmNo1hED215CpI+T4+Kca2Qztx/zE8vSpEGw7JTZs3cO8DUuCaMHbDigZdfrrHs32 +P04Xci2mYmriv17G4mQpi5IUlCR50M1vMEyWfE3uS2kEPvW26XRak5PJ2aetgOvePP+SxGobXHQ8 +WGUxF5C1QBpcOIHabD+e7X5ogjpuCis815Yknl94ThiJxM3hcCSOcYgBoxrhCQcXxjmZsD8Xyd23 +RVhFJjOKi2ZOmjYqPKNmCloOtxexFi3lbGbaK5mkvX301OnZ5/cUJOgLSMC/rxZqoqjweNLKypZt +povFLJU7PDDuqo53Uqt/9qZQBvveExfBb/5MXDB/+ny0LnywWmjYXELRwGGkdtjMqOE5nMinHbmd +eE2BODoLp728hDZGXZ40JwEWFVtKSITg+X1CaBIjKh+3lJ3J8JBapqOx4hidQsIQH2CJ0zWHVYPV +NCxGUeysSs00TqZ1ZdAvGLlabA6qxhr0IQQUvTiNhxMxm8Y7grQZP+EgJEuJWAxr4RQ/zqFYHkUp +JmhnWLOohiWmwjI0kseyLXBHdjyDlzgMbxU2w+UeYRn85VZhoLbY27Gqhk29Qk9tsY8Hg209GMwx +vw+IJZW2GV7D1FjSKOT1iNvVCGzuFVbH/28EvGX3N8GOXqFxLZonxswz25a86YoY7cyvj2VSX7ZF +zqSKdk0WduU9dObeWSI7HwI9M8oYlqdYqHMNjERwC3cnrIhszcLD1bQ2hiURGrFw6M6AVO9tdegd +xtMI13LrtBwsUO5ABhZmvzv/7DDO+o65eb+TyB2JzBQDY/IOpMB4/t2FwKPy6t87hwxFCDESR92b +4eIyf/rg1umcCf+zRWiIsd7LSKljrCubmWxLhMOFYbjYKzTA673Cca//QJl3cLwcFvYJzdvZfIRO +TMyVVHldNSajKmXHYuplOVxmWBPg2cqdpJmgQLCtT9jAUOwgdnw2dgCYzrHLyRoFVFF0fVzisIGd +tI5osuPAPRzFMpQV9HyGFWuGi0UMBzbHLwOZunCHOTqNK1xdrQWkCRRmriusLIBNYaU/kl+JDLdu +F7r+4NU+IfdqnzgWAutxsQou9JPbyrAP5pEl0P+EWA9PRkkdfPG2WAe31og1cHmPuALe3CA2edf3 +l+V69oqONEsJR/3FL+wW5+U6nhB/8LK3vbKhJaW4CuvzZJ33RWG/Z1PH3EjuZox8ITazRpm3Vh2F +tsrJogxj8OJmssXToAY2dJHjbdx7sY/iFSzvIxHttYzGOmG/pMp9o4vsI5Otc60qCgW/mGDNKS91 +TzhJlvD9uxP/K8ObOXlYHeddGOpR5lyG/eZr2nH9trCXtvOJ4xY8upEsggfuJjVl7IScdTf5FbkD +7mHhf4hLYGIL+dGm6JxLWVVfWjNxIfwS4un1JA4DElkFb64nDa1s7Cvo2f24BP3b0FwuCccS7uKg +SGR1TZQOtDEjoY3aWIcMhyWyYbobPp37OlJsqCu1txrO/X0/aSPery9Vg/EGqYTPD5N0JduAEQza +XnEpGH8sVsK2K6S8uSg+0fC0F5Xehtm4LQQvElLfxWRweO2GeOQElwTslg37HMc/07eGg0wwqIPX +r2L7sXYnWeAZT1TAwUNkNXzypFBZHRjNHbfU3LEj5L2WFb9F5x0m+ZsFjLVpc8NFgyzPfWaSqdA9 +Q6Y5LDtm1kY8YAWlxL3FLxKP4vdOhgyFxmLaMnwfApWbVdCu/yasyF16mHxNXPZlXpC7NUG+qNzD +AFC34zxMEJPy4ROOMO3xIlV1WsP5FcyWWMiiVqOBTukE+8N12rz7/qseLv+LUAV1e0jZmrx30wEs +hlDNWF75RVThHg5rLdcBpVtsgtglUgO/HsSOtuyzRqA/E+aBWYbe+cbTpBWse8Xly+PcLPnLRe4S +MsKhaTPW4PpXSSP0/hFZXLbWVl24sUlshLZHSfMGXBIuBNwhn6X9quMgkaBuLzK3TxDOGtgH3giL +Fc1R2s6Hon73wERu47/gbAK5vv9jcZFHv18J1x9HIDv4GKmCREaogFctoaLCDxj45HHy196DF3yl +rAzwefoKslQZntW7eDLghZnUkZWky1ZMd8qFOAmH16JQMjbe8ZIdgd79+0baRztZDppjLb/cKSz0 +L3j2FAVP6xz7WPHqt2++C6IPzcI1xAbJxruG8IgB3RwIFdHF0EYH9wGaBw9ce440wMNnyPK1pQcN +sc7ZL5ySquUW/JABOhweJJFFzH5Sm8970NpM/ANphmFDqKkdMNF8o35vxvyk6xVx8W5mmeDsIaSM +ysUpfyCeUazwhD5BdXbNp1gahoHi0Gx3JJ41Rm3FktHh1t+9MdLjfXppMWWs52n4/VwRILBmuPXr +YlNo1wmH9V1dUf69snF9tKSIkNlkJ04Km8R6b+2Gmo0MYvO+4Q7ZZnbQz+HOuJHET8PMOlwAHvY0 +OYSwFYftj2AZ8ksTg+bvTpJ5K5KWJUk70fNlO2tMXxTey9QaDsH1sNgAnbfEBVCdJdX1CENFArYz +FXs7DtRDf7VYUcYkhNbjmKZrs6SyKi+0PxR7HCP05+8IIbi5VQh1F3W+vNCYmFEOoqfwcQY1Wayx +0pqBZRcGHX2eNHjXk2WVB4f5AwOce1dYU3rjUw5PniG1d8/wdnSv4KLdYRcEg+hqih71T4lwe7JC +BZ55GwP2rb2kZqtvKH/5DO7wbF7VhH0IjgZuEmUOi9siEU+YaoTru0gZfKNZnCd0QVc/kl36KNkH +nS1kfjnfB58OC0uhc4VYs3Qa5WeqNwLn6knLt9QqoMvJgoYAmlKH+cFHFCyTjykOLJyPeY0/3fS3 +I7DykqgYcFrg1l8IZatmpg10R/+Ll718CIQOTGGd/yhU38vLR+5PfA11XBMLIdW/PGS+h7VH4Hul +PufaiuFY7JqaYfoonP1noWFJmD9PYUkb5ZtlXmqB/ACWZ7//DrqkdZpUrbXYNUlKdZXkkKxradXV +UMszuea35nDxJ+LKpei3s25hMfzMPiR92cYe/5tUrC/nVKDuzwkOfiw0ep1jZdCxl2yEG4ZQ9exN +dKJH/wmDgn0VPYKdo+Iiwqidvyk01pSkz9duIvyjjWtgxSSpINiMQCJCWsq5L8DZS6j586uRxLVJ +hKzF3yT1sP1fhUXVvltxR2EPdLSLhXUxHPRSPwyP4Ick7YJriA2t67981W7uAo2Vsn+5A0IXhtyN +dqEG3v9YXDA/iJUIn4WLb4tLBPNbU9wh6TKW+vxoiLvKcD5b8t8RuPZz1Endb1CMktzFr0wqvDM/ +qoQr50go98MnyAnCeo8dzA9o0sxYiJ7YcmDC0sfpkOJflrCnC/8yYPq9yX8SYrOqwV9GAjEpC4aZ +XdScJTRbKFCID5IO+L2nyAve8hOVmOIHNTzM9sEs4mMhh0Gq6AwRxil6KrIY8xRjcSOjP0t6yr33 +FNlfzjENwlfJAuh7D12EmTYXPUeuL1o5a/AW5Ivkyr9D9IXw/WeF+WK2G978iGzJXZoiP6uqK7Fn +L+2C1iuksQ3TgJ8zC43njHXr+bqFu51M6TqoGyTLofoHpDp38Q0yUX78SCEOFZp/d01xLcR4RjDz +jSK/vhrIarrL37iLMglr74Pw5yGPhuRGhGsZ0gbmR6Rq3aGs47bRtEFl/hhdCH65SJcB6sLZo9gE +3BgibQECvt6BfooaqVjpI6iEKdTPekUys0G2aF3TqXwV4a/mSutk+fP1ayQMPejN8Hwrqa6SAp7h +fCuLwhayeo2LUElnVngzYDQTDXmJhyPw0C/IIu/Mj2tqpiuAILj7/K/pJ64ii/vva5K01ymazlcH +fv3jnXp6qYhZte7bpAlqVISEt14m9S3tAQjj4iAG/Je0cASaXyV3QfQqCVVjveprJtKTq/8x+ast +/wsInBPo+AcOcy3pMolqHYyM5SSHSkXVDzxQO3icFc2xDcIwFEXRJhUVG/BKG4lEYqHkx36AgTiR +vxOJFbJDBqBDYkFMc7uj+7bb8WOqR9PAjZ5XRpiulEkyfXvXc5QcFtZJOwvxPlGVinwLiv6FkBWX +8ORJMwdEGVjvprk37u8tZiWmNLqCIIpYFu33UK37HyBvKpjyDEKkWQ9wDX/og6E6q3jJM9bxjG9y +eJx7LPJYZEMCs9XTCVY5G6eFTryYx9URfGO97oHrbyIMDQzMTEwU8vJTUuPTivWKihmuHuWoto9j +fZhac2tq/VeHmQ3PGEsmn2UW37yR+TqTyMNI00fPZ2rxs58o6Ghf75O37tO2XZPnsM2ynzV1w+wM +dfN7WlfX8WoHsmnv7TPdg2x4QVF+cmox2IbtZXyr+38eneB+kPdCieMeK48bwl2bS9mtmUR4hB7M +1p8W1fDsStGra8f71l4/zn9z8hHO+QDl2Vee/QIc5G1d4ZRj8wBnlmkoG7//gxKjCHicu7ta+vdq +6YYWxhamFuYtLN2HJ68N5OTMLI4vzi8tSk5trz/MAsSs2+sPs8UJAQDBdhL28gUEN5nmCRgJgNhw +LHFjr7Vt4YHkwnicO6JxS2NDHuPmesaXfDbFVgpexc6pOTlWVnmp5RphqckQhqamDpcCEshLLMks +S40vL8osSY3PL89LLbJSmHxeQHbzLIFVzABrgBr+uhx4nG1QS07DMBDd5xSjrNooOAh2QSzojl1V +DpD6M0kNqacaj4Gq6t1xSItAQrLs0dP7jf3+QCxQgY5goGfaQ6lUk48lhwOGxvjg8nszeqMklg9F +gZ/fGoe9TqOAUXtyacTFCThFWWvZtVBa1oJtG7LLfHcHJosxlnBeZpOmqmB7gVQUR0lUt9PBjagi +ymok++bDsDCXYblVsEFJHCLcAjFoCDho8e8IyBxIQdVcq1kKUSDbvIjzdPWCx9y1D7mn5iG2cILe +tRny93c1XHMmwBCNcK6B57wLZ+79J2FAebJThQ1GSpx3eQ49/eQUADM9/8cqha5bz/t23f/Css6K +X6E6HCfE6oM2fvRyzD6v8ZslO6aPTBJOWBdTsy8ZGZtC9lNfdNLV4YDq0XnMKtq4XZ2PfA6L43ic +jVTPaxNBFIbejFRBKCgUeQVpd+t2Wy0U2dJC1ORU2tAWpHjYTHZnu0M2M3FmNjGNIXryKuxV8OpR +6cX/QfyXxDe7m02qF+cwvH3zfn7ve/vj89Knr0vffq1Ot7e3od2XIqBKuUqHItWuHxMeJtRVVD9P +RNBl/NLqlILdduGIdSkkrJMONhS004GvtKSk56O9P7NrOyCpTiVXsANCAgFOL4lmAwpUSi7cWj/t +WMFUEk1tiDgYZ8zPRBXCikIP2O5TB2YaDzpCJDZsHRo9jGuAp0d0EEMn5b4aKc9L+yGG9LngVZzq +rRl6XiRFz08HGNx2YO2s6quMZs5J17JsGw4OYceplA0pLaw8V29h9iKSUbl5Q3ZhOqlNrn+udu9M +6/0+5aECHVPojDRFSeQfEUsoEI2oEx0jTMOYYf1MQ4AgGrthTCU1pngzBdgJdYAg0pFySR61iSHO +RjxoQyiocmtmiE2SKFr6ElC3Ne1DRFiCz9mH7kp2sPloWnifC+Nv5eWaGjzYDARXGtJnTqX0E8o9 +SBW7ooUy7+Ef00WrfC5mQCWUKdZTQT/GnFPs42Synz9ixWf1ZuP8wstBCUiSUImZlTJIDQXyC6mi ++oSrGURc6BgnBUPJSjjDVBrFLIBblqTBMi04Rc04MUi5IhGdLszYqiRzAiGp56mEBbRkiCRDv0+k +VmWoGSa289+OeXYH5k5Tc9kFTfYXuGvG4XkCZ0P0vK4brA2GobWQOq9pzlfPq7dajeOX8M7Ir05P +jo8uCvnFaaN+PrN8DbAj9vb2iu+/GG9omZPbCG6OsY+YFl3YLlO+6C6WYPbBLxwM8643Hk9a08Wf +SRCHDE18vDnpUbs9JzZEIglx3CIq1iNlSVhQXYPgqEO5RwKcNi3oQd/SINWkg5sTo6vZEdyghIyK +NXHLqh4AsCgnADaEeWmghRwZAmRvxg/v3pjc+nr2+2r3VmWVfWnez1rjteUbrtkTvpKx98vX38cf +7/0Bj0yiz/0MyH9Mrydlqwqa95X5ni2Jb/KiiWZ4nGvfwHJ6C8sG62BWXUOznNTJDwNVN1sHz/X0 +1tdXCMlIVUjOz83Nz1Moyk9MsVJIVCguKcrMS9dRSMxLUcjLV0jLz0lJLVLITwMKKKRWpCaXliQm +5aQqlOQDVSYWlSikFeXn6k0+vSBRIxOopihdL6s4vqSyIFVDU8HWViGrONnKyis4BChgZRUMNppr +8sQ+4clqW7TZ8/LzgMq4Jgf0i02WXKY/2WeZ7OTG9VKTFywQnFy/T5xJ036yoKvo5MXrjCYH7RfZ +fGOOfjUAv9dLbPAClHDLG2smS30/q87v1t04l2IvkoV4nLvHfo99gzuzSEUpl7B+inlOl9qRQ1wG +nGGtRnLfJkczNwMAtxkLJ/MBAPmECYD3KjLaup7LTVnzqg4MwIN4nFvXztMARC2MW5gymrdPa2aS +aAAATHwHZfEMBzwxWbWyXZQW/9WvJTbTwMLnuzF4nAHBAD7/1QjVCJCVFJX63JX8B8/Vxast6fqX +U99IGJPqoakBFLWDBkBCA6rvfrjAaAgha6hrkOnMk70BGRT8S7Lim0vEIH1JVgtlKwjWGLhj8JPq +Afw+ACvTQO1dwrFk10ouChgRuWhELLAxMDA2NDQgc29ja2V0X2JvZHkucnMAOYFQkDezJGmrDoOp +tqayYX+eowaTJANKFK0tTJDVCB2vcH3n35JfE1tRmTb1k4IDvxQHa3ZWAJKvcsn9h76ti1+WKfy1 +PhVeV2j7ErySRovtkuxV5tOsKdfQuz6YxDHEeJxbcIh1x2HWDdfyJYutFLyKnVNzcqys8lLLNcJS +kyEMzcl1FWK85UWZJanx+eV5qUVWCpMflslNvlexY/OFgjPspGrcfK/inKc4Dk2TP2pLTp5gyjG5 +t4IdTevGK7qb/x7iEiFP6+S/h+5tNrvho0uGP2u2O7AxPogCAEbhdPz1FdNOUCPZ0hgNmzGUQIwg +wKSQ+6FueJz7wNbDvSGbmU9HoSSjKL+82EqhpKg0dbIgswhveFFmSapzfm5BTmpJ6uTfjNYJKCJK +OlwKColF6UAt1QqpRUX5RVYKSXqJeZUKtSAZZON0uGo1rblSKwryi0oUkvPziksUUjKLCxJLkjPQ +LbHUxyqDYllxSWJJaTHItkxjo8kJTKI8MD3OOfnFky8wmVkgC6QqKYCsR7U/NS8lpCgxrxgsZAs0 +Ki1Po5pLYfIEJnlHZDkUi/PL81JRfZmcWJCYlJmTWVJppaCUVawE8SkAcZ90fffjBIrLzfpG9x95 +CNnAhPv25Vf8AyS1eJy9WmtsHNd1BhXRJFcSZYlP0bJ4uZbEGWo5JGVHlIYiaZmiFKmUKGkps2ps +r4a7d7kjzs6s5iGJkhiCTuoCrmErPigSA26TFkV/BGgTY3+1RfoC2gJpC9T90QQo0gdgoG0axNaf +Ii2Kouc+ZnZmd6XIRhH+0O7euXPvOeee853vnKsf/ca2j/9723cWnuqzTM+nNnWJYRdI3ilXLOqb +jl299tT3t7U5du62a/qwp2Nwj/xOcwXTqxh+vgQP23vYaN5yvMRo7ya1C6a9KuZ7OpmjlnUy8My7 +dCaTIvjnlQK/4Ny2czcDGtCCnLHiOJacIHYqGqbV7KnvGrZXcVw/lzcsK1egFb8U3yUt5+Ud26d3 +fJ2sBHbuhpfX9Tkxcq5QHen4/ueyWSkHMT1y2zB9FJoUHZf4JUqovWralMhfq8xGZr629bBH8mal +RF22XsxwcG3XNzbZ5mNjYyTr5NeoH6lL8oZNPN+0LLJCScE1TJvtKIwQX84o+ngi19GMinpd47qY +Xs52CjTn8SVRJTRHJrWRSjHd6C1q+znLcSq6bpYr1c5Ov63tlumhEQuw1XNwE6cH7HzRXCtGfo2p +kace1wzlou4U/xrYYppvuKsotkvLKKFHTDvFlGEzvJKBihDPIZZ5ixKfGm6kmE0DJrXpo3JoREqK +LqVMP9vY6bPZnu+4xiqF5d5rLavwQW9Xt0pGZ8hihdnt5Pnsy4YV0Bn4Vu+78O3LfXCub/T44pqC +kuQ8y/GVGx46lFGpUFfV6J0KzftKOm/kS2i6QoDWvxOpl1Zhq++Xr+CBSL2no0faiolGXbWcFcPK +kNqSGXKYGTKPcut61ndRbl2fv3Bp6VqGjGvj+PiLr6qzoPc/18qXBNo/1IHS8R9q9e3+f/xcqhKs +KF7A5Kuu7f+7HR1Fm2B44CHC2wf2w8Jz1+FrX07DccW4lkUL+0sLWekMaEFxFuiwNuqF5sCzwEfM +mDjmBWV+WOilPNgyhB249BLb4MYtUB9tAWtnRwYPHya5NUorOYMdklYyPBlnOY/tCy2ne4EU2+G9 +ggY/Obqz+p5yqaU6M9KxrU0GzLvaAahk9rHwdyrUhnczZyA4+wL8xdgemLI7Ns1iGFpa4FF0TC5C +LooNRSX3uNOGf+g953C+jaEQuLdwrkcYXljohGUcnSJoOgSiUsx5mDks5zYq6PkuNcrcxVw6itPb +qStiAsjoIHy+uC+KdM2l+C2PqBHKhK8WPAXG7B74QWYvpEb/o6bk/OVPrcjP2EeFt6cPwB+PtMJ5 +bQB+bW4PTCudu2NTchUjgFEzDaOjna3o2fjGhDKwxzfWopVwhkdh3Bxkc3a5lFtJKRqWR6uvaXtb +N0+7TkX4ASKCbxbXiWGWMQgMxA10Covts452KuBYpEkGMdCX7ubSVQb6LkJcYdhLxQ6pBmNRwOih +g3Gc8MiNI45p4+ngbhGayCNDWXEnFvEh4MFbLww94zllioZEr/SoVdQQyMLHCvz7CyNfYPIaKxYl +84tnpIQYQ2XT95Ja3i6hvblfRFpx3MZUwV7X4Njxqc0a6HKX90g58HwBteS26ZecgFnJwVVckWRG +eRSNnjl3kVDXdVyNnArBvt6FTwuUYcsQA2XkSY4ZUUptU7pcQLj0hVBULEh8J7QrjQyjJdZmQCXO +a5qgS4ZmiuE9bE12dadDVefZ3LQIgXemn4UHk9v3Rg/PYFLxEBTT8E6lf4DNYRmtgk6DyWUdwZx8 +ke9V/erxH2zrZltH5zhNyjyF//rVA/Cl9Y5WrgXsyfa1cpFgcbkf1pb794rszIBZ4G8mBbnlg4Ni +2IsNx5U8DFvZbvjucnpgmc2bkyZJTAL9ippR1NpYffwh4obSqmR6hsCHV3vhr/UDe7iAcdYA48V+ ++PrkNZidGoK/mW3fwTUtBTaqCaWp7z3iDXuyHd7nb3XDN04OwVuFXdOCxmiomMJfqiTojcbDmBwh +E+pUQtaVoFikLkMEC50n8nkVvQHBnQUnA3TmPjJ+uMcylzIxXDHFGuQGizUEPnRY4qx41MU4NMiq +UUn6j0ydun7x6sIC/Olsd57L2YwmJd6rqdRsalPFLM4LvMDy4Q+nlU1u0EzkQa/GZv4/ijCaEIHv +qVHMii4sH+nhZAujhkk277oKBh26hhSyMQ+dIt66nS+5ju0EXs31y8Z6CJ2Mm4l8qZFzGMsFisfo +MpYhKW48XweIhcnDaO5X709egPfmdrF80FnT1CxYDOoHhHNGyffMZ85LciJbN5aMMNmPJpx1epqM +M0AeahBWTIAHc/t6uQ0k54/x2zcvD06ie/qGHyC1N58/ykncee8KN/hJRZ2JyZaElxBYhpKFRKbR +fhJqep5JzqzHnKGBuucx8AH76hDCDUmHDx8POy0KfJztY/njF5A6idOtEfIQ7H10nGC1JB6XKCpV +QXoVEjIGtEbCvxzXXDVryVRLGkYcGjqr4KPaSrBp526VFVWTj3JOUQSH/B2PAtfwMeJ9TP2urp+y +LF1nyptlpAImPlKS4Ct3QMKLKqCXK+GKSeMzPD0ZwUnRdcqKOOm6ecnd5yxMUrp+hRoWfJLthT9/ +ZW8nkl/hQDyHo9eM7n8C19j9zJM4RbLibHSKuudNnGIgfDjH+fQjnOERh/TzOqO+xxzSieiQrl48 +PY/sZf70pzwh2PviT7uauCPiz/xnxh8RjmI6fPPFbiiOdYKz0FPtOgXbGPjtQOZM2Vo4B35/bjjN +TYeFhokLuLZh5cIJBcM3FPYPjCn798ZeYx+sqNo11xcvWPomurbhaMtUF/xwoRN+Z07fybTKxaYs +zB1FPGyH/3mxs6qcPtbxUvOiuk6pZu2DaBI47fuqty7c3wYbi23wJ4tH2Wcq1g756uJEe+yH0plk +D/Crl/bvrmuHwL9eIjsTGQQHupvlR/Z2aIPqR4v3W/iBJrXKIJj3VsuXf9qCRfeby88wBgfXsw9a +ZtET/j429mdLb/Cxs/DO1fdi44MvP5Dj//kyROO/3TJb3f2LX24ZECWujrQbaX4WT1PXxZBa/cq1 +kZa6Q3gOFs226h/80vvtdTlvf+RwtmXaa/KgFd8NqDoFF/KjsqlCkN9iXXvX4FUKS9tFx8JCEZey +LFk7O0VRJvA2hqeR0w5hDMpE++EM9sx0kTSRPLUsr4bJDL4jRGI8ORl1u9cfwNj6rhorZqmss64n +Vll/dqQRwl6tDxe5Cxj5fbxMvHdThW/l4SAGXrx0bxp88LfHetbQEBdFXeazWsk2ZNFmY4VdqSD5 +8UjYZJgi9E7FMvNYWwes1SGqqkTrQbZxkkQmxF0YUnrCMgP58Ah8aSIFN8ZSGNc74K9mU5AvdlU/ +KvxWS/ZJpG+AjvgbUSDI08eTN8a6cKOd8PHRdvju2XZ4uNF//P79RpYlmU34qC6kJK35YKwnttjT +TydI0QwZh++MdCNbOgE/OdoBb48dgmvP74B37/bAf93d1x/ao35t5Hfd8OO7u6zPUCfUlV8R0JzP +ngls7sy6nsdc0JArWDG1PZ3GhPfBcmYnbrQUuYe69Ozu07RoIBvT9QL/Atdvdl/h0NDAk6M8wlHF +ZgnNN/NruYmo0MqEmSkj1K81zeBfzvbsfCTVvXdzBP65eAoG51rbkiBcza4eaRFxVN0obe04jGIJ +KloybKSurqfl/Tu8BA4sK/IYePhs1yY+IBUsi5CYY2Etm2a+7KSKCv1qZdU1ClSCdaa+ArhdMhmH +D3yLN6J4FVY0qVWI2B3rsDRW6FyH7YwKwOCBQ+d5p0/Xm205gyJvTDVNkGGohR7OA+yTjX7Woar+ +r/ebrU8EMV1NIAa2prqq1fVcC/zb3T1HYr44Xl+UNfivNpA8xZZ73isXMYMMe+geWd5+E00VreBE +LXP0Oa+uG+PYfIA5EWFOlJEtStYRYd1OKVQK/CPq9he0oxPwzSOHhz9/bHRh4tgEb59y1qKSIl8+ +Bhq5/B0YeqO7lTeh4OFWz2V2IvwX+jD/1HwHY0eRykpH50lJ5EHm7Oi6KIfQRdBb9gp/XYVTz/Vu +MvFlOx6TR8Cak8R1HF9oiilDdssFhIqeKxUtH9kmEx6cJPpCANw/sD2jSMk9cnhEjGmGl6v4bugv +18U7UniGBsFtT9fPSW4UCi69rSB8TxHdb6afXFR+cMCRP+IhxD3eqglLbhusyY9EHzNogaysN40j +xBI+KmlFY3zIJnxCSzGm5Q0P3z8pFgT7rR3w7Y2dQJXep8QE+HCjj68nf75ZPNTKfm5UV+99rSNE +D/jexgFWoJ2yw7qKpX9aNsMGH+pgFqhwszF0IHGrkQ+wesdzZB5YtAKvFE997ORMuxLE9DGLHBOa +NyReqiug+cwmeSiZ4/gsvjdLaePDF+CPtro7E6U1hdL96Vd4x1DHanrBwU1PDhszmdSj6mtmcwHM +7H7jjia+NwsAjpcULr0+P7+EBqm7CxL+zQwhnTt5tSOudSROCkoFM0OkTSzqwvW39uFp7kkcEm9o +8ubntOyqJoIzlF5G2jRRMG0/uokgcTtrGxWv5EQ3BOsMs9k9DWt7S4cQm25Gl5qMEJUDrGB5MxZL +tAJtdNwy74yzKhdFGU/iNstMQgPMRrRc8ddFKzvSipUM1LATRw4/PNauRiuO8hs617UdXQ9u5TDV +Xjp3ab62DRhT3WkmmRpZi/lQmHP5o7Q6C1uTfcMiD6GPT/MPLgCu7vELK/mKOousabIHzKmdh5Vb +LLlnSE5VJb1ICDJ/cenKufksn/7J5PZWzWQnevlQF/5qn9CK7K7svpLLILiVqXpf7Elv5gwvb5oK +G2QAtrKOqK6oqsrXeX1y4OlI9xG+v5Dnn050wj+c2A+zx9suYiEqmufyUGK3O3hqBYoKOev8Slre +KtJb1F2X7qfVnxD8eOMIZ6ezU0+1sx4xCjMFNyf6NqPga97MiowsmxzRwhtq3FcbWZP03AYfvehE +XUIU2nlNNArZvV20p0YWqIEBhqglEENe9YUBh8ZmyhIzkUYiRerp1igKx7v21Bti0mViJNKb53Ci +L8kSAd/48Fg3s1IqUobbCU4M98LvTbZBeasLXjs5NLPBNxb/Cnuyq+Zkho76K0kcU3iqHn6prkf4 +JJjVCFjjbdTCRHsvBQ8nu03JqRgWnDozv3RNJ0u1fC1QLWb9Wt4WPEGamREUTOzsMj923WWyPi8D +PhchPAW/e3CgDuDaE4UsotzAwTBRNOX5PEMIuTeFHZvNZfzs0WvU+t7sVkjE1JBYN45PjTkovDXk +1TOB16f2OixYm0EAGw97fNG1epnR+0LtFst20nWXG3GEjxwuu46wW+ZOxy6sNsVGUvIkD2d/LPBF +cyV57c7mm/kcxxe18bUyFrfGatM3kZbZNBf4xeMKpohNjIshJS20uMdW20irccBqXNtb91hefJxU +Yr10k5c1LVl2bbdYzYnhNcifIlZzi+U41bLxeCReM0YwKMOv//mYoWUUEh4DjbREdPkxG8GPNtTt +7CEsnhuEjzYOHX0cNcFnTRaCzPBlxkp2iOYpJmsex+rYpyQf0PL6ONx74y/rw4Uzt0suFZdYiHWW +iTEpY1ccUS0cvTDHM2FE391ktchowTVZoz0SXXsMRsdwny2jRvZuRs5+LrB69FPBqmicD74xsbc5 +l7uw8AieFna+BP1twEXWb4nxPfF/gQo/i9NVr/9Kqv3/AHES4iD4NWCnwwCIckijjh1y52LPTtsf +Jn89eJx1U01rFEEQPSXEwQRE94OIUsxphWFyEC8TjKgbUIkxsAseJIeamd6ddjvdQ3dtTAhhPXnU +Q/8Cb55EzP/w5B/IP7HnYweX7Papu9+rV1Wvuq/3f7/99WNt5kskfsqeE2GSnTBJxg88KFcYhj1j +RH0CeAYfmn2x6tBBNqVUfZJN3AI61ChNrjQN1YTd4KRH01yws3eaj/lNsMJkHwlXYfsyXYTs9dq9 +2XLuS6EMWyX0XnNaAZZQn5scKcmWU0rphtL6n3M831+trz+8083QHFa2qWTC6IAbYpJpY7+2e/a4 +s2m3OqOZt7MDryUxLVHAgDTDkxdoGDiXHTXjOYyUBqlSFpEwuzAuJHgC/bIYZkAzQi7hzaAKrnKF +HjsrJgGJkoYAy5FXxQwPBs2g4OkM4nAkexeuctRjE8EFmFIhAkesxAKgeUAE1dUrlKlgAeSanXI1 +NaVvLjoOY6VEAFxy4iiKcRaXKM+dSPEq6hNcFr650u3n1ob96W/Yb63H9+W8wKMF2b6SzHm2faup +yP7Zaj95tLvYpKkf57I2my7tXueBF0CCQsSYTGze6hbp2wnmGHPB6TwC/2PxMS6dvjWdL7e5OXTu +14m3u7793r57tdn96/0DtYkItfGKDeYMWNS8fn68cFDznb/Uv0LXn9ejeJzVfQtwW9WZ8NwjP+W3 +Lcl2/MiVkzhSsOUksF0qJyGJE5qEkKRxYJehrLiWrm0lsiTrXuXR2BWB0s60ZSF7p5wZKCXs7v93 +Hy0kZDee8oYpZYcsbcL0Rbu7kP7/stt/lhL6b38IaeH/vnPuW5LtQLsz6xmwpXvuOd/53q9z8sKD +Dd/4dtPJoS2jQ0Pi7lxCzskJcVTNydLUzqSiymk5J2YOwf+VyWQ2KkpiIqlkU1IcRm1bO7Rv56iY +Mobl5CkpmVbwd+agNJaSI9qqLUuXK1FxhzIip1Lrbpbj63Zn1WQmvW6XpCYPyiNSKjUmxQ8o2nMj +vjVp9l3sUC6pyjG2ZlRk75V8Z3tiw2lpy3s1hS05tqo6KcN/AHdipSJuzuSS6YnR0Z2inMtlcuJ0 +Xs7LYiYtKvFMVhblw0l1QDw0mYxPygcB8kPSEXzfOwQ44COSipiSx9WIV1Fz+bgqjqRkKbcV5/o0 +ThUay2RS4WGvNznVlU2JW3KZrDgO67iGaYV9K2sVOTUeWS0e9VLJK3Q1bd27NxbHYTEGmnbqbp/2 +wd7q07fc2NNNnz4jRLQ3HqimM+8KTdqTx7zahaSPKF665lWhfYWcVnNJWZkR9T8i2bwyGRrNTMmh +uI6VcJjefop0tY+nRUlVpfhkTMdqIp9NyYe1d77USZ/8qRD0xjNpVT6sRsV+mJv46PQZwUc/nBQa +qXifUFF9KCdls3KOfjoohFanZFXMZTKqIq4XpyQ1PimyPekz83WmAKYYGxQK00c+JL4m9iEsrt/A +36XiCAnQy6JnuWd1+Dr6/AHBX8kfTPcKS2txjWQ6ASBO728vKJEJWQ2FIyk5HQI0i/oPkGdTKpWJ +S6o8hO+KYzJgXRaz+THgwkkgOWODzYCIvfJ4RNzLODEFpJQOygow72QmJQ+IaUZ0GD8OW0omAPKk +iug010GsAwyHkupkbCqvhmaKMJ+TFTl3UA6tCdvAY9sBoqgxtpPQRCozJqUG+L5ESRHzV68dEHXM +R/LZiZyUkCP7lZiO7fB11lxJ7YZLPu1z8cZPFKFZiSmyGovDJzkR0l8dEI3FONqHtUfiA9d8lFe1 +43s7euz0tckjpwr9+jrSqcUu1ddkc/LBZCavaNn9HdqFtzoCxhcR/lJWTieAKNr5I530hIdUhkpM +CQBxFjbfTSZC9PgoWUYfvdHTTDf2ChXl6XHURBj+FMuFS89Eo1uYHITG8ulYVs1FozqvRKNp+VDI +MRn+6LQagAeN1rdh+KEXNwp+7VKhtRNETd+WmpPSSjaTU7lo00cvC51050nhD7QT99XRXX8srKLP +v0j8jZt2jWzduXULckTy6rXaqWPt2o2Xen056RCIi6hk4gdkNcJ/0dX7YI7n/J66TcjZoJrS4kgm +nZbjKmhgPgb1M+o/1FkAhjhiTCHuw+9QJQ5m0qkj2vmwb3lmjDFuToxL6XQGZe5g5oAs7hgVM6jB +AYNyTrvjwXbt6cH6PxyXVJCe9WI+rUjjsnhUzCvA2jAiLaViipKKsQE6OdmeQ7gJTZzxNSTHRf56 +cL24WnvkaLsmrqnucDAAvJHOhNgo7cKaNu2OD1vZVjfjVhVpytivsU/DwOAuh0GKgR3QOhk70qFX +YDMRGhwlvtV2uPkcDGolm0ylYglQ2lkQA4b2WQeY2p0vt9Xt2b5nq0min15FT7xHaulL1aShqxTF +E2iF5IT22NtLVsDW7QLkYotQmK91/oEAU/P01gNCYyWDSXs+1kEfCwqV2j/vq6YX/1aoojes8tS3 +RqakbAzeXD0gzuh8IT0BShuRta70KqKsqBLTisAnUro05wzQi98jYgRYwUCeoVFVB+eIDDod03RX +q6dde+xyTX9JtOoyH+IPALP0368VBrXLGX8Dn2U9bF7s76cXfiQE6epLQlUhqcTkqax6BDDT389R +Z+0mmUjJoTCTzFkv+1UK/YyhQv347oCo+w5uf2FATACrgcW7NX/tbWFxcAOSFu3y7m8KNWvKqTxT +P7GPNnVP3/6/QqcPp3RDpw0l/T1sAYfnsgU8J7SeG8Sj2k+SPfT7O0hfARbK6dszfsC4HHR/NZ4C +JY7G0Pl1GpST+zvglWK1l02mS+JwuxwzXIfY2BFAtoHDZKIYgR9jS2XgHwfTyLX5EW5bj6D2DyOP +JBMfcV895fwStjNtIL6UnnvA5uJc6Bb6yHXD2qZLvWhvV5QwmhNFRlM7ER/sX9TIMF1zhnQWuMtX +GjQT5+gnREGqkp+VwzbTBm7P9UlQufA1aLepvKKKXHUrWZBmlG4plwMX9tBkRpHFOLjMMAo+SymU +4CPipHSwQQbJBg2gHJKzakQL3jWoffNb9TUzM2KQYSW2ZAlN/7HQSx99l9SvMFy3ef082vyW4Ke/ +TQi1bWwYbn1SSoO45sAH1ITHOmj0GbJkpdsr6i/tFtHgI0Ib3btc6LgOiJhPp5LpA07ndT7WHBDH +OYZA9dCH64i/Wv9MH94s+DfvyqCFQ8yIUjwuK4o4nstMgUMYz6RSXCPmkViiTjQIIcYNjHO3UHst +2d1a7ILQ258gfm3X+/XNjHsRZ7oTor0z6K+MoCzQ6WtJu7YnUrGtFL9LSiwnj4Ovm0RlOgV4nk8k +OLPT27d4enHG+lVsBKy6K5OmwW8LzIgOQmSTkk1vKCUpqmt+LsTRKHyXvv8HpKvO9JwyWXq+CkzL +ybWkid4rk7oILuiyaEUuIULHlGRSk37gZ75ea/FY+tCbpIMWqNBC7wsQfzs457JBYkMLhZIJKj0F +wzbWk8YqFkrK2pr9gYFyKskSEwwhpDg+ZzEEbHk8mUJdNMNWn+F2wY7NYce7Ou0BmXwWizSAshj4 +GumQU+tFo+C7c7PgnAmig/ytgOrkODdsJaa0U8M9K0ptLCvlFdkNIsdHAvfnK+UPU+Fq0lbggmVy +YpFXGymhodn32YySRMb4eCx6wBbGGIAbbKqDdCsD8baIKh2Q7QEe/lwp87Y32JgXFM+pgW4f48UQ +W2SAr8099g768Eukdq/rCcClI9YVT/wO2V57dqBR2/125fyGgMHlwgdof5ZfQKeYv8YZWWSemTSO +XhtXl6D7hsWkKnJ/bpA7dHpcoKhcj/mMadH9DXEEDNOWzR5fLbAnRzOVzkGojrtZmZMhBIoDQQyI +kTeVEDK4jb/DdJpCmMI8ZDQgpu0DzBpS5cSsYXwx9teevrshOo4gl1xL1/rA56Jr2aiIaRit5Ve+ +GuSxGDgD9KGnhF5vBtDF16MtASJqb9xZR2Zm6PlHhT4we0u05v4KdPPR/fZrJw7Xs+wDQypKFv1e +TmjWHlte2SDlgMywB07GVTvJgCaqlQVdnYQsfaL7nBGb5IbC4XCxHFg6hr/wUVRMr6XtstlUErjW +SMuoCLA2/X1fIxeA2ICo5vJymN63T+jyu7AHb8FDNBrtjNbaF+9qoD9v87TSQp3QssKcYVxKKXKY +JXKYMOjTMOLQYJ3gGwDbI6OsFC1Q7g36+izp1Q4sb6Ofu0aob3Zzi/bGN/3VDg55cqC1gMkfcQIz +jcm4mMocwhQOy1Myfo+D6zEhMyExE5IQBSUxwwNykGbuUjIhi4w6QxykiFvQRjK5HLpULNbOo/hs +H43t2XTT6NYtO0Qm0lzqDgGlYJAEJMirkxl4wAVT5RzDgUlEisgfz8P8afrODWRJq9vwhb1akxrY +8RGZC9DPJ1dRKZmMgGxerbOJKaSVdOMZ4r26pLyBYZjHzaLB/ye0YzZmpdsalDGx9OGg4O8uI9mM +s8CTXnojoH5zPoeszHPNwEoqxNNIh2TOICCaOyAKx66R6+N2VeSgW66aT49mwB4ZcIa4Jx6Ip8BL +drsdirbmM/7CHtAbegDMlKexCN+VuBdjZAg5AQScg/nY3HCAJznG4efm0CQNN2ZIeodJstK1didb +m91ft3izrlvxSM602jbDiBsOX6kdjuTTKHVlDHL/x7HIvaUssrnKLG15S/AFErrSA/gMBEWySTr9 +IPF7be79p99DN/dYC6jyunlVLKagzNc0ob+NPtDgaaBhn9DTaqwVMfRrSLtwrke77s7KA1dsoZkp +NUnqemask0nHGNeELJDA8E5fI3QurP/oUSo0MfPaN1+aAvVweFhr2b+5lw0rzelA3tM/3D/t147f +0eG19LP25bs662yaWjv1eBd94oywxlGPOP3Xd9QI9Oi7YCCfPPaPLDkrBLXssWCtqSjpsTWertNf +u7NL0J54vBWnWGYa3113icbLDfSe78A3vzjWo3k+P8tmonffKwS95kTh00c/v7IFs20GEmO2jWOB +CbNtnUhzdA4SMuYFc8wcIiaGtVOv+XtAAbjiWBvWtI2ABnciu8ZQHejTVetP6HeXCME2+xLc70tg +4nLVlfmJGLh1wivlk+U4gjkob78rNNKBbwv1ENYF5vcvL66pYAnUzgB82POXPUVz1PCYLuIDL3ih +AK2OMZt2+wMVXiv3hcgRQnTT/xS6fSYmLO06rL3zZ/7ecTsd9F1bRkE7lWxHgDrQTawuuH0dPTmv +Z92RcP3c1T3qNtT7UCunEmJaViOjPDvMzTPLjigqJhqBi0GXoAcAk2D8z3K0Iigskfkngxv4K2NS +DpRVLlJkT/VCjY4ng1wxVrCBF1lu3vQj6ckbPY2MjZv5fkHgdT6lf3KK9GnPnfGdfvKrOyr2APh8 +4+K2ffv2rGUAmZlMcTyVVyZN/ac4nXkcmpBRIzG7pOeCz60W1hnVU56BQQZFxz9STnKAXPS+iBCm +9/d5munFhwSR7gkLrfSOhFCDnta2tRwQWTERyGqoA2DnwOlBbFogI4gc5TgOSLJS0alhqnGvDa9O +SB1Y7+8XQ1MbEWBZCYbYDorcpAHRVtkp4p0YeEbaybO+6iBziWV6Young66uFtpo61M8DaM1H6yk +N50Vmltu4iW4hPkuTcukW6t7oZHe/gVhl3bPA5HTLz4Y9DY5gARldl+fJwBRhZc+GRAaQphFY7CW +zFrbXgseEHwaeaEdVOqKuXRYkIXTf/6N2wr0W/1CjdbwQNOKeb0qYChQEeDGbDoKhANK1dPbFWH9 +3MaVwuEb6FN3g9Q+locnal64aq5dEc4KvWWxtW0t7vZDVfic9WI320MZozH3Sl64tVl7+rXaER6O +GBxWRB+XsJqwY6Y8xNLl1w3T8/1CZu6FLwjXXa0de7+TNlwSappc2KMtrwgBmtriadVO/qaGxp4Q +audWPCHcWEEfrwA/9m/+j9BM1/2nINYyhzfDikgf9LCpGp1TYczRQZ/7DOjBt9s8lRjfNNCN60jd +3I+eEbZ+0jUajUolYx46/XWhzacXnxy7orvPCoGAi32yGVYbw2CrndexeN5Sr5FgAAJApnirArgA +E2k5MSCyMo3srgqLU/LUGOANa3ZbUNlxPwQEW5UmxAOynEXB5PU+bDxgUb4yKaHaHYMgJnNIzKdB +JHVtEfFqD1/u+ITYv0oHMhIHLy4aXefcwgag3mwRF2vHD3d5YxjNYTA5wLzoua73hFWCNvB+DUN4 +s/uduY2XhK7dgkJ/8ymyspSleb7S0057Y6Rm7p5t5Jdgao5WrLD6IoC53B0X+C2rm4HBpeJrQsVc +YS9Z0rSYJSgs8cW5vWPkR4GVGb3FBTtXUJuiCh5aa0SSRuio0OMF8r/pQys9Hf2YjV6wzhWlnwt5 +An/IKiTxWB5wPGzUI+arPdpfXqe/7Hp3gXqrfYbb7DPMer1Wocxeb41nEnKUj7IVwUybB7wH8jS4 +xsbwEIzlc2nt2Mu+VltRlAM5Sy8s9yzD5qERrvMxdmNW4Y9GN2EEftPNbFJlWGTEBExDeKWIo0cA +01NbESJ07+K55BT4xWnV6sLQTjV0C2Ht/Eu9zdt3h/VF9TX3rPCECjhtRBpTzOogbHnZrUBe2HFo +JIXO8G1eOZ2f0s3tPtNg8a3ti2dDe+XxPWpu3b6RPdyL2BAe4M9Sivls56j1bBZbfrIpnLG7xJRm +2412/ral9Wavh9ll886k0E2PzZLOwij4i9EogmAUSjFbwuv2pTp3zGYSwzkacGhZfTqAenHTpeaZ +b9Zr/Z+l5TDCXbC2aoU1PC1nswP0jlmyZN4dlyz3sKXsE1/BnosnjC8wo2vXprfncM4XwAKmIusw +HtGH08/Nku55N14uYlj8ThecgT45QuondIic7oX+5YwBLypYbt2dyFh8dZ2u/6awZGEOL1O/1+nD +nIQrxoBrsqvKzOais61T58qh1vs5Pgao7hna3fDZ+ko+AoD62x8LROccO0ohkdtthvbcAmziVgvN +7v0w92k1RtTz87czuqTnXxA6tJOPVLWVeMEMkDEC7m527/73vSKM+kXVUhNZLK7iWHIjo9ZEBr1q +lUfs5ENLEI/2r/Ks+GTRYxdZlMm8mgB4FrNYkIr1pLa19FL97OGn5jERRn7XUbKZR0suzMvlstNc +Py2en+eZp90xkbGnWS89+2dkOf3tX5Pq7fGcpMph0eZFWPvQ8Qmh1CrMP21be31OmpL3SDnFnFeP +DOA5/fQJEqhAD4Ku/Sz5VFrPYejWVy/gKUb2OSeDRCmokTH6jvO2rWQGMT0eEXex/lXJqAbGj4D8 +Rezrubsb1zHvg2wI09nPEnEVUMxo9GEeYJmNGYwyytEL+5xcyzDrHq8/w2IWrBoKl6SOM7fDg6TU +DGm8Gt83IiiEGTszWFHMCImY8IVZxMLS4uEwfeRGz1I6dJNQGUZTnUwXbcaIdF1bWVF6K464eHIt +fXsraS+UArvkO84hZl8vBmkxCSM0B0YsNvOyipaZ9FbSUlaZzOjtnMlRILzEm52R8LzOa5S3jBgP +zLaCjTTxVJ7Z7x2jvJEPSxA2njVgpaOfJf2NOry6e8tY4waXb1uMwSvkmcLvgWfKzONCP5+wAmdk +kWqjmeC3+r+Y8mFZrpWKyPFgNksx7EM4mElPxFiCowRcLHvCoIEgY5GA639bPeb/dNxLUooWy44M +mcXfGTWlzIjwvwguHTsopfKy3goPNI1xSeD7qrOVAy3vgKfuQOfJgKXBQ8k06H+wOPA/XD+XSYmJ +DERf2D7GXmX6RdcjWaa5ACOm7Z9376x659r8+gV2bwqHTRebJU2+L/r2M0JVtZEMNzY24eYnYB2H +2TUc9MXyUdCV3eVpCwZCkL55lIjWYYh2q6LEsvwGQ9FHnxI66NI2Uk2/OEvaWotBpM2zxN+3SG1Y +pEB0KppBjJE/YxmQ/Ws9TfRLvxaa6O3fEbz02QnhCrsu6NPVxNuCBZ+UauugpLtnSTu9FCB13Y5a +mmPnobAWnPbRL8+SpgMlCJNJF6ebr0xKSk9B1/QKbR+xwYTe+wypJmkmKl2p8ltzEXU/CNQe/bAH +VxfyYdC/uq7duvt6Pb95pYJSjgkwD3admjkgp7EIqiNDP94SK3LNx6W4GurjX+8FUdqaTsiJPuSP +vgWYCaSF9flh62IjW48ldPEPbIKvZH9xPvnnKlKDlaUKzP7RY78G9HwclttYxHJoW8zqqO46LjKb +UIbt+FQfneeKCrVF5pvKXyW/oF8tkNfn7iqQP+0bcdPGPPTm6Jc280UbNvAp9dcyeTWb194a6Sjo +XzDXnu2eTYIocL5RVI0qO9KIAkDZTudlRZUT8wyN62MVVcrNP1IfaOT9y44cl8D3dkw0V/fnZFfN +Kis7uZBjQVfPkMAtZf1E9qrdPbTzFshOSMkzFmX5VFkpEiNQCT2FLbJR57carHNyDpuAwNMG3wvT +kynDVOrpYnUSBkxMiplcciKZ5nXcIRAtSx2UPAeiW3SzcirOzGxzjOQ448PKb6ZkZINle7+rHs2n +Y8Vuey3fXxI4em4HCVbGMX1K391BemqtJ9ITxB82N+EO+uyzYa2X128urvNUtJYAJptltThWPVi6 +AILoV54g3Z3OzdvMNqr0Qskt2zBo/MzMOMfpcrbwyCKBc7wyYL4TtL/E5Nq2HX7MRRNe6PjYlPBt +D1r4KpOtdJOEna+x3jIyOwy/tzrxyyfi7xpK2XF8xtl3jb2XhiktDoDoyW8IvoZS3FhFxe8SX1sx +zviR14I7QxkBRQ1/xZjwK6lkXOYlRVvXDZuL0dUAX39oWRsEwe5fmDtkFZIoFhr4BjuKpZiDT8/5 +ia+ZdVSxqsZ63nn2p3V9BTbHgKgcUaLRfdJENMpWAAc+A6zDFzJRxJPwZt+VbRchxzjjXAWrAeOC +4TLP4+o1hwc4TEUoSaZtToSZG+IJ0A++SzrqbEijFwPEF1wcYZtcsqSte6/HJK0nNMPa1zqGTL5z +N+S4xZ5xPOsz8WOnLj3xLPFr6/+hsSKVyWS1Nb8IzKNPFpRaY2AUBl65/PCeYuP0BULmu/9VEvBa +M9HVzwidG8qdALQ0QRr3GC5SR5y5WGOJbYH2TovRbFDjN3T6NeLHw5b8sXGKkXX4tBfzOae2dA57 +fvW5V2PvM5M5F1105ZWT2Xn/0M1ynJ+SpdOvCj50VOkb15KKxrEUJtqw4wQdXXYIhZ44K1RUcqfm +wvvLcOzVuL7K3FprAxwmN5YHxH6+NIPzd4JLbCDQ91tBb68TltB7fyxU0uZKUuVZBxiTPuhiGBso +xliJCqq+FcRDt3Na3OkgmEXsokOMGEPZKSd2rCsCfkRIxyyebsdJOrosHJovr9OJQoV/F3w0e06o +qQFMsIH01FaDPwDmpU5yWd2jRhEKjYV28bf1CNxSICALeuKZnByNTslT0Shr/jQHnxO6cOrB8gpX +p86tBqiRyG3ma/Po6X62NBtJL1eRZrYnDCzwv5shzrLaa/VCMkYO6YQ4JoNWSfAWhzHWS8kPNvMG +pZxx/Fme0lse0G8EgVaUfI4Gq0jbf2fpDHQbRAeWYH1GdutNv/9vTlACTPLoYz8TKluKXBB68qyw +vBqjnWQ6bx4WC7qwURwumL4a+nJDJcfq4YKpK9ipA0tZfvV2ofqG63ljG28vyqjJ8SMQ5eUUdZhn +NXlDvz4ha62W0/zaDqMBLZ7MArkxVNOOXw60Wpgw3sKItuP3oy9QdgLladzporGhT+ajcZdLIyHl +GkqQt1h3LUDjkJ3G7YaE9VtTO8p1Lu3LlPvScjyh09kUAaZSeIumy0ewbrXQpvsDOG6LkdZg4xaV +0xjV1x3JTEHcBwv36cIBqA2U9mfoBYW0VeunVtjoUikOoI8rxcEMeiVPATnSHoj7pf3hkNudcgcQ +2IB9/0uks9GZt7oSR+qqEsFLuYDF4T9vN+hlTKyjvojlwf0Pzu8ewbRhfTZHNIQ/RSKlxbLheu6u +6dL+/g6y5DrzuUNfLdbHCmvvnF2qZ2sYv8XUlBJC9PGkOC8X4KEC+i/9AkdAS5HTzxA67EjuujJT +fAWrS1d2rkGnE6ggP1+NJ1ErOqzIyBQGy1G+YUH6lmOfYm3LIotNiwhi4lI6LgOfFHn0LMSga4JC +VxjrkkzhRK2GK6bCWHTCPnCfTnvuZZ+s30tSHLs48IaBjMImM7oXnI+TaTVj3y4bFIE3MFUkrteO +f8/fYcDa5xqnvf1jf2HeCMmOBLyxCk9jsS7IbC6TyMdBEWUldVJhncfMZRi2TnIr+s0/xsF5tDv8 +sD7rZ0Z9EPGKf8DRO7+C0uPFtDQlQ0SsqDnzXoHCAurQeaDX0Inw3OwzA4q412TD7JcL8Cq47YAP +hx6swPb5Q0wO8wBs+GYsLvE0GrfXNlpYenAv63jg6tMdRZcOKK1QGtlOX6fofP61wZJiYDaMG54E +P32IWtA40H8hLnQwocfjCQsanzteaF9SHh/0vpdIR9Q8ulOOECZ4bgrQNZLQFt3LqvX88OHBpJLE +6wSMOYvOk0m5sSQQNncEr6nRpuNdVxUZWdciEA8ZzXp4SUIPu1ZB+/JQC83+lPQ0RnAp81YFuuc5 +wVcr9t/K8H8bPS+Qdjy0WhWbEbFy/theoZOmniJtRqZ5sWn3RaR5ytpIbs/QQjJGY6Po635S+Rm9 +DYJ7f5yWRiGWt0TIuuPPi9ridhWv9+HMNcRP4aG88xiAX+GggnODeIzQY33EX2Bn2wwmZaXGcmDa +HErzMFXJgbq7haPMoLgoA6WPbSk+NvLOP/KYwHY2bc+lLjr0LKmuYKpbfAbckeb+il4sBOezCUlF +uy9NKKEZ9gtkAX/R29rJCjwai+fKAwY5pDEpnQCrBsspyYR2/PUO+sJ5mO/pu1sKlhEzkOTK8M1H +fxahWYxua0qxHUTnMaF+bhJGZkCJTrAOBlDEKXaO3UyvIy9JqgiKOeM4H7LYnHlpQ2oIHnoytPlq +UtE1D9Nq977e2W5vFbUVfcxrKCrCtgKCY3AR1phqW76YDTDNUTAuqMNOdDP24YY9xfs+7Md/hq06 +BBYmEMsMmYbEjGFhIhk/cMRZjiwvivQnftLKj949+i5pCC6YoaNvPEt6Bq096b3BxRkcG2+vvjMQ +4Eh3SyI9WU3aP3klkuWQGnoiKPjmCwMq8Pi79nzCR++jQk3HgpyywgjwGEjl/Ctt6E5/73zJVFDT +zwRIz9wtf0P+otrHTwZZ0oIlK7vz3q6fgmNpC3im8PNgeLrLYgjdljBqT2SsS7pAc0rwlatBzC6y +qF0ZypicDcJjcQTV5hCTRdSdB4yr4KT4dD4J0wLH8WPCKDd4kxg7egbWynI2cEtOUeBf6dKl18Nc +ZQ8g5NzFU+SXdfTDZwied6quKlELQKtOv/735I65sWfIubq56bPkf1RpJy5VaLUP1FXZgnRMKuy2 +jAfe72PZg0N4Go1/RiwxyzCsu385mV2GZut8sQKa45cDZi7FWLRYhRsZkWpMIsPG8QxTs1tYaPDX +QoAFyTCanvueUFulZ7ZbXoEgvuoG0hi1RUoLBkr201bJBD3v8/jZ6SjEwzbEg/Ge7QIE1knGOghZ +AA0MMsw+85OQLOaAqEM/PYSxlh0BVXTj94UW7bW/bKUnt3hqafrviG9u66tkrBYx04Xg4JkUYL7x +5IRDveEFIkvw0F0V/dbPyDUYRs9d+Bn5CsGWWDz/yK4bRB6xTtwwtmfwJGzgYqvSIcRNnBPSCGwZ +XzOI81k8I7UZedW0LKjd2aV3eEHgoSQwQT7NToOyo1a8iMzbJkXJOEIla+/8kt3khIZ4kCfVzgoV +2uBbtURNaRt+cC1mYvBP6cft9awza0Zkv+ipW0g7nX2VndJtZT3Gc0f/hQgVvc6S2qSkxPgGeR4F +65aDTNXwb/WA37wCT1IOxIBh06rZfkyHXiF+mv052URnLpQXIdr8c1JJX/470kXXvUJq5l77Obks +0Jl7Sd0yxhESj5iM3lPQCXJOBmXHBZy2PAAvbvtX8kP6J/9K6oPBUFw9PF82jW66BtbEsSuCoaBt +cLFXz+8PbXyTHGPXeYD9H1Ow5M55CDGEZAN1Fdc70o6kMlKC37RhUle/jBDCTMYSwEuATvsZU91S +ICRlGBSEMH4OgL73TdKPN/PM/f2b5Hwl/duLpFELJRubwPGythry0qVnhF69oRjCPTNA4I0OpsC/ +80vi43eIOkVY4c4UHw2GQ01KqRjddEZoH2SBFfaK7MwAktatjG0Y8LI2iB3KXtYnw1smuBtGbzgr +LBFLnzq0bg6lv91Ilhf4mS1x9wE9gtKzB8NG4Dy66fqt+26J8rOI9rOFk5lUwnFEsczRxGFdvfID +hvotUzBxkt3KW3B2MatWqzOILrgBwIMopINc/HR7JqWP6O2rrAiQyek0xcjDWNx2Gel8hxn/yDjN +OGzOYLD7erF85MJCcvNMl3mtjnXKix57i3Q1M4sTRh4Lsj/p82eEbrJ+gzb0hD9o9vjwznY2AByl +8dhEHnxujMFYG9uX3iJNbSkltOi5jLEl5nrtL4Qmeu8MqS/o+7XElNM2FD+sB76svGZ0P+n5g4UO +ujN/zMXS4ZKvFpwxFM8d2PLOLFMYtiNbz3/w9AUvkeuPF5USscXKSNWCM/ofEB375lkMHUNGvsSJ +Gj3x3DdfgoRfVc2kGC8Z0eUZ2xAiBccOgKbmzS9j+fFxLqX6C9iozK5tjPFHdjjsYdd83aD8zQiv +ryF4IzxD42QBd6NOUeer6WKbKfGu1uJUCvs+CgqFF3dmvV40b/oBCdudrKA6XbwSSzC351Se+NpL +aFHcLd16VhA/sZBq0y9F1lW5cTCbPjJDfIXfrSJzKLPF6LLkYpXZR1Rolj6j53cSf2EeJWaYv4Wk +2pVic2bH52vEhWW0M3c30b+6SFqWOtPhnP5u00m/kxF8979NKru50jB7Bh12jz56DwnQbRdJM41e +5VmJ3VF1VVyhXYHlo/l3hdbCf5mhK80bhf8yQ1fazl2/kKFDc2Nut1RTJCuX0Kl3hSWF2fLquFTO +slhzuNSw6Q3qyrK0KTGnvsYc70wgmrszo29Di8GQuTv/g0iVtbF0JjaOp7Lo/3qHXL6KaW4shiVk +41KG9WKGNegqEeeDuZ/8isRb+e0Cy8rdLjAnV3q+YN5qbzU46Y0tvAOYZzEwnUiP1XlW+x2pDmMo +/eBTEEPcWecZcndT0fZ6zzJ6T51neUc5SbaGtJcpK1F/vWcFG+EvohyGItbzslkSa5E6Wy7JfHHF +3H94Pb+prDGwSFueIr56g6ZoY+Z+2uxZ1yTtAbUjYUIcQvEjWKZNJTEoAy+eBVMl/kkHyQgLRxFU +vLjB1nNvXLeaQlLiTSxHaSxFdtJcL6idn6Qwgxf0tNMfpIhP8NKW5wSxeg13xOnTQc8m7cw9zbRu +ijS1hu0+IDPMtKeNLFkNBo99Yq3i7C+rGXxrLsdTPuzhUXPaZXT/g7AyXm7I0rqt+kUgOjowBUSf +/QcSZBdRNg5W7zbOX8uH4zJjRxHCRtbDIitWZsM4KjZstsuLIFKYplLst4Nmk1Rq8bSxDq2N13gq +7v8a8WmnX2xhMa30Gmmjy+qEAH0x6GmjQ72eJv7x8oukSTv5xQoc5cHbhJ/vEtq0ew/39OF9RRBq +QTjKAjR2j7QeseKN8nh32JpufwGv5mNfG8cWx0HFOVvwYSZJ0dWlHIOYPJ9m55GGXRrRSj/xa4US +cko6osAv/q+xAH6Kgr1ESxGK73+crGANhLDTVvqr/xQC1eg6xzN57ZGX2xg2PnxcqCxFnH/7GsFL +J/2lngUeIsvZtHjFy7UGZg7BxnQ2xUQGVh/ZLoZsubks/uMFyPsT+mXN9NwPhcqVSQX/uRl2zyDL +iWA+2Dr4Z6h+doMLzfo97VUJGX1IekePp0ObGwhgGbxa2/OVikreW3JswONb7rJ+4/lU6ojheiYV +DiWNip6Tc54+zyeFLkxOGKLPbyux7kLZvczTS/f1eTYbl0yZ1wIZQTW/iRCI6L6DkJ7q81z10V7r +nGte5nl81f8HpO8aZuUBzHF4nFu+k3/eTv6GFsYWpi3MK8q2byxj/pYKAGZHCXLkAiJ4nJu3k//y +Nv4NTH7Ngv7tgv6M2wX9mSRMJnsGc7cXNDNtL2hm1osEAO+iDBn2Mr7Y7SongW5RrfLUUKrlDoR+ +IRZteJxdUj1oFEEUBkMEY5EggohXPC3MLIS9NCJejL+VCIp4SLq9yezb7GRnd5aZ2TsubrzeShiw +t7dQrhSiiYWIjdhZCTY2gp2NjbN78c7NNLM773vf97733te9uafv5149Ly2XJ+2f12fsj3TRvtxq +2cXthfGH8teNecGzRNve27PjE3vfj43abejGCAyV4RFn1KAG4x5yRAUaMwNUuTDNQh5WwQ4gZTFU +LMAnUJmhu6lZgMPjODcurV4JWIwsCbjWBYZAGcPc6BWXmiDckyEua7jZDcM7VVzdjinPuvL+5jay +BhPRirWZGuZGHl4Bk2kqM58xz58iBRpgFQesg032L19Ya4TSwjRMPEJ21b54d3p0zeFJofkOdjqR +kimpOuFzHWSFEMTzfN+bElXHT2lOSl5CFPFORydB7bRPRYGk1l8B7h1JMTTBYBBzgaScFlHCefed +Tn7+E2ymMimEawjxZnZqotrUQ5ki4Z5zMLPmc4OKeH4uNTdcZqS8OJO0D96cGwmqTVC57IELAPZR +DWcE9bgF7x9ZCTnI3Aw3h9DTWgS5Ub1l3ajUTUqj1k4RiFQ1MtgqqAp7HkTuoVqUQSwFzjstIeyz +Wy37+9OpjamwW4x/hTlH67AKu1OBXQ8eN9Qq9/VeqaZ5hansVz1Zsz/3rx+fQGz74In9+HnJ3v2y +NP52sNP6C1HvDBT4A8uJQmyjNae3n4KPkd4+OIUnOwIheJwBOADH/+cL5wuQkxSzcLaEs0z/VMhI +7X85/ag4Zf5o95GnlhRqdYlkP9E1aHNDakz3AQCqA8t5PLNRAZYEORgaqvgIfeTCiH2pQStNGbf/ +JQNCLbSygZF4nPtxkHnJYeYNcY5O+voKjgrFJYk5qQppmUCiJDM3tUghOTEPyC1KVSjPAAkCeaV5 +OZm5mSWpKQqpeSVFlQqZxQqJySWZZal6kxsbJfgVwaJ6IN3FBanJkycuFZvs6CTJpKY2OcHRAsgU +nVzRwzd5gyrL5ANOHJPlc7k373O0mg8Aa7Ax4f0R7Odjxx+RhuoRXeV7uLtHlaW9JTZ4nB2OMUsD +QRCF2SZChBQSLKwmnYrciW2wSmdpa3Hu7c0l6212zp1dzkIU/4FwxdXiHxAU0sXOwsZ/YWNja+de +phiYNx/vvYe3wedq8FKv79M0hXP0UltA58iB9N7pPHhNFpqFNgjKEGs7BwllPI9AW2VC0StkMTLE +CIZkMYQ4vV8pI1dAjiU5BLxBtbFLYGZ6VkljcqkqhmWYsAdLHhxyWCJoz+CR445NFkQVJ93TTIx3 +cK5t1sdnHqUrqLHto9tt3y9H4wmjKZP4dsFmhqg+mA7bj+/DvY3eSOs5a2SFoYbTWM0wTrvnVJx1 +F8fipP352u5+WYxe79a3V6u/fbF1/Q9vNmoqpxh4nDM0MDAzMVFwSSxJ9UhNTEktCsnMTS3SKypm +eD/jYrZkqk6UNktiwNETJW1n+D5+NISodi1LzSvxyc8vcEnNSaz0zc/LLMkH64laFSNiuqde5PN7 +duv666ncKWVzFKF6PHNzU1Mygdb4J2WlJpeAVPsITcphSm1YHtcmHhwhpN6QG6knBFUNckV+aQlC +bZVrxuyNkcZ3V/VrTZyo097SeNlMFUltkV5SZl6KXkkxg9H6rmM5J21ffTL/Lz8v9N+NAlbBCygK +gYZ1SeebbIzvmtG/LK/4ie0cM3HhPzehasJD3ODKdt+RmqMtft2tcb68X7dL9+mTp0zTocpy81NA +KubM6Zo59WNCZ0PO2wyh5hBm3vfhIlAVJSBT4vPBHojPzCtJLcpLzCkGaXoaJuzyc927XVMLfp3Z +u+Hj/+QZfJ4ATZiXrfYDHaH4OZTLXs1mzssvICVRn+PNXJd4nOvm380/IZDdOSc/OVtHYWOgCaOA +AhAkg/hWCmDhyfWM5zjhgpudmTxYAcdtEFn6AjUzYd2fPmqCRlFFMbebl6nAH0O+eJy7zt8isCGe +kSexuDIvOT4jPz+7OH6yH+MWFIHN/xhvsgIAWWAQyfABgVnWmi5vTZ8diPB63KsJMDsLtDt4nLsg +8ERgw0PWyX6sLpsF2eyZADsQBaDzHz9DMykIWe85tpeOta/VYE2QGtbWeJz7+ovx7z/GDXMULBSg +ICe1RCGxuDIvOT4jPz+7OD4zRcFWITEnRy8vtaIkHlVGQ9Oaa5Je/2RtxYs8yDKT/+tJbmZV+sdo +SLKpk+eqJU+OV3HjQ1U92Vq/ZfJaJaHNuqrlZJi6ea4aNzOGEyezKoluPqaZw0yeMzf36TYyohi6 ++b/eWitDkkNx88rM92gG9WT7ck5Ok+fzzEstxwh0BV07hTQzE4VqLpi7SzJzU4vigebH55aWaGhi +s2VydaXk5rslMzgAUS61K/cCBT6cWCy4c7oTsE1GvqAIWi9Fsb14nDuc/CZ5w1sdKQUgyCyOTylN +jS/PSM2Lz0zJSbVSSEvMKd58T+cpCwBEvRAG/CTUBiu83Uqs3KxhQzKAZ54qpmuXe3icm3Se+eNV +5g2rhHgSiyvzkuMz8vOzi+M3TxQqZZnsOEF08gZxFubkCh04OzMFzuZH1oEkzpqdmYfgTT4rxMGI +4L1B5nElFqWX5qbmlRTDhdiSc/KTsyFcf3HVyfY87PolmbmpRfH5SVmpySXxmXklqUV5iTnFVlap +uZkl8ciOgCicfF9MavJvccXJf8U4QeZgcycb2I1ck+3FlTeXiOvaT/4Vxj25P4yVG0nt5slhfqwC +OYnFKJZsPhstyzz5uyOfZF5qBar1mSkaarmlJQqTNz4Wr0/OzysuUfB1jIgPdnRzjff0C3F1dw2y +Uig1M1GwVdAwVLCxUTA11lTQVTC05lKAguLUnDQ9dBuB5gJ1ZKbhkbXFsEhAoRpuKggYTb67UG5y +QTarMzYDtBUM4aprCTtn8r24dM5HDTNLFMqLEgsmT3wssjkh3qgDAKASzT3/jQE0wvK3R2RzlJAN +7tr9dXI0YQOzA3icnVZNbBtFFFYSx7W3IWnixHbbECYBVbvVYhLchtZ2k7hNaH5MksYBVEG1rO1x +u81619pdB6JgfECVIk4kr6paRGmLxKmAWvYARKpQEAcEEqjiimgvHEBC4oSEED8z/km8W7tB2YPl +fTPvfe/7vjdjr15v+ma96Va0ea+oLylJ4ZyqLuiClAqhE1iWI7nBQ0NmuHm8wZFWNQyrTtR4eBBM +5wxzhAszjJTJymjt5U4T7Uo1PMkg8qQVlJSxqAlJUZYTYnKBPaBjOc0jQ8pgLYQm4y+Icg7z0LLi +h9/8Poh5euFvjxcWj7K+s7KaEGW+sikUmn4+FuN4+J2sB7oegze0DnhuaDe8h93w0VCHt/Z+EOO+ +hjzkXcvdtUiFQgp+le3nzF9dfzQ/S3vWxTSmjR/PKYIQpSnjxQwBZyRjnvYdk9I4uUSIsUWS9Clh +C2riPE4aMHDwGbh20FnYgiLS8Zub8SJWjBDaqm2tOkaXS7uJrHmGefwlDWc1NneEO8NgJZd5eCZa +LqaSlQJWc8aEIhnoGOovFZzIZHBKEg1cDg+UwqNYNzR1iQSe5iliUlV0A0Xjp6dPCOMzM1NxYXQs +Pj83c3pstMiFZqJIBA0Gie/ZXIJNaqQmR2WjKgklpTtK/IteCxIBZBlwr/RCMti5YPdiU6AFSSGv +U+STZ7gylx1YERB1IWtoLMcz0Dbs22PFI8Ffhh+Fjy/6+IdqGQpZBIPbV3rC2yTQYFn2zZbyZTfN +n1ojjUetIpVaSpUMqHM8ypzIXHUVKprQR8YGshIjxtAKAWs0cBYbLJmlSp6UtqcdqG026iWTUwWI +EHw474Kn1lsKlUANuKrtCAV0gm1De702WlWH2zruoJbDPysI7gx7pu3uVjewjV/l0d/K4cLwXVfQ +jLarfS3Vdc1rQa6Rq3+HWFc4c/3wv/sDeqCu1UWPK9YKxjlJ58ybp97xHaqfQfaUrxhrXpiBu1OT +UEhcNXvO39kX3EEFEC944N7UCPS8ucvsu/BpGO5fdBSyGl6U1Jwu7GTK6HRqBFjUDJx6sAIZwnrl +K9PorT2O0PDVJch63GtXWuFyZA+ayylUzLhBjmnA4j1tQUrBjQ/2dyr4NcOGw8L97728jQQdV2Jf +2FInrmYwjdILoG1aVfDW0Q7DQPQ4tG/cgj/zLWHbEBCadRVYtiBIaVi9fAwm3m8rvj7gYNUlCrdn +u2FD7Ya5DT/cm3XB8Cmnq1IW7s56wfllO7x93QmdUh+cGfH31zKL8qyjP6G5tg/kATeMf+aFHz9p +NX/eeNdN+T1SbIMr+w9/TXaD46298MVJ5KS/8FiDyCt++Dy2u4ncvfB17Am4ygcL5LtNz2JD//Nk +1Mm2/a+w5FTtzzMIfrg5Yq5/+6LjP2MNBQP1DlUj3gsb42pWXx67S2z23yjAYYCReJwB5QAa/6EP +oQ+QZRR+R1uCD2JppffenH1hnxi+ZZVxqLF5lAEU/iLUlUZtQekwbc0thFzPXbz/aXeTIQIYOzwY +uwYJ0rilB4rRhZcWKHHGW0U3MTAwNjQ0IEZpbGVTaW5rLnJzAKM99fSMGG30iJHKtRn2868mTMqz +k3QC1hQhyTDiXS5HNeWnzu1i3cSpX01gX5NeA2YUcm49RqOAAN+pU8eQtPHja2G6h2uz2AOAAjTp +WYGSVly+IFnd1ypY+U2Kpkb3UDQwMDAwIGZldGNoANIdr/FaW+OAK/dCahiw9Hjnyn1gs4wGFQE2 +CWhb+QzT/4fSms8upgpOfyk8xyvDFCLkL3ic+7JFaMY2oYYtjLYXJqWxTF7wjtUgsagosTI+qTQt +LbXIysoRxHMCcxxzcvKTE0sy8/N881NSraxcK0pSi/ISpzuyMItPDzBhFpou8JlRYtpURr7peUsZ +eaZXTmQUmnxhB8f22RcYM1ihxhsSbXxQaV5JZm6q//Q8Fxbp6QrfGQUR5r9nZOFt97jGCMRM2z2u +MescAQDFrEyH9QXNNwwDuEO0vFosRAfpEaNGLHKA2nicm3+Tac8tpg0fE+z09RX88ksyMvPSFTKL +FYpSE1MUMvNK8hVKMlIVkkrT0lKLFPLTFBIVCkpzcoCCiSUK5YnFQJxZAtSiN/lDWfxky26+zf8T +FngDAJRAIb7wcH2wgVoYvZ1uTuW8+UlldmVC5csneJyFVE1sG0UYlUNSBbshCQ1VSBM6IUq6Gxwn +CNqiTROSFqhQQQJSKiEarSe7s/E2uzPLzqwdNy2uxKWIC2GQLLVSgXMrFJRDb1AOlcqfBAIh2kqI +Q7lwAK5cEN/MOnZURcIH2zvz7fve996bufNLxx9/dmy81z1SKfkBQRh56keUfI64T1cQiwglLvJY +jLC8IPreQNyJ/UggKFB7eYSpixLqkjiL4DM5OYmKSwlFgnCBJiZ8zgIsSBGl+L7gyGFRFTEPerkk +BQNwn8vvur+ubUG8qBvgFEVROsAt5ASMAxdGHcWQNNZRTHAQqvKYCD8mbh7oBITDACwkMAldVptc ++EEAO5XYF4LQgmarEbld8UXJVq06bIW5+W7PqCfHRa5WoYrEToRhbo6KUcwc6FTgwmWJKAIZpcb2 +ZRLHatllBfT6/4ukptLdgDBwq6lxFTm90dQCnrBAIXaVngX0EvEEEkzVNNE9n+LAP0uApy9QhSWB +i5bIloJLVa0NtAoC4gifUeRT3SP0XRca6GEDfEiQWHdM1Rp50/GWjYT6q+aiXvBoitgSUOsnR5MZ +2VV7sLccmmgGcRJ4hTPcLoeG/OGdqcd8D5XDAub2coyjku0wKsiqMBq/cv7sgPz73oDst3dLmuTG +0trGrq1Gt7lgEbcJjoNq87WeSwM9/H4i64f65Mf/tD+hKeAlFgu7BA7BQJwIm9GgalcwZNIWzF4i +thpG9p7aJ79Kfq+dBDl4hZAolVv33B67FEjFOYRvz4+5mE7zrSRpbMdpIgIM1oW+EzOB+Qpv2QQG +sIouCXG1kVGVUFKYQ/NCtzv1MjQjUKEe9JmEcAQNz70g4SUVRXAZBxVcVbw4WE2o/OzHCXnhdvtI +al5COfZIyzKQMT0vIaGg3p2+Wh45OOHEQpBM+wx3LGteKXZMLZpoTaNoJJiuWbLWqsmjBdDoNYI5 +o+enm+Vg93CIhVMifNhw0sLWS5Z1LDVwYRBejohrtEAs6zmfRyqxpvzt3rj8/FquPjObyT1VaIIH +RKAFMMBIo2Y0plxDY+P6Djtvbkue/KZPA3RNKilj4qEVsJe3hE0oGJAeQtAoiYkWM07k449MydqJ +jvrgYGa3CYGMSQAM7xPROMpWLYuSihGyMkHnzskv83v2ahozGl/lOBKxYU5n5VtH+3vVWhGVWOCq +Wwb41K8dzphyb3lYDt3NdbmMksIyEYapsF49acjZW931ja5Mp3z/013y2b+y8kjU+cHGw7J2o1Ne +PjEov/fa9f9f/Sl54+ds/fTzmV55MXpIb6iFxSMZJP/9qVOim7kHTHN680r54Mgu7Q6SV9cPZ1/B +omTYIOWs3H9pf1s+Kz/5cFR+u/7ocb2YnuWdzvzWOTTzTW9aVwZlIr02zEX5xfpYm23KxY0BOfZ2 +/+bKpbnL/TtdxQq1/tGTmaHrVw9mptvk7Yu5vp1q5NzNoQMvAIMFUNOydgi3oSzQ4ZbFW/vk6YVh +2XW38/qeZzLHn/4PqhV79/QEtHF4am9OOaLMGVIfa7jxStb2G654nAFEALv/kQKRApCmOhV7OgMh +FQajDNtHw2+x/+6vfaS/MTAwNjQ0IHByb2Nlc3MucnMAdF0Sc1oLNW1gkxvheCTVsWDw8xSR4DGB +SxuY9wfBZu9KO97cjFHGDeKAvcwycszAwnicO+q8yWXDXM5g5ejktHSN0rzMCs1YroLSJIXS4lSF +pNK8+OKCxHIgWVlsZVWQX5xZARFA4/g4Brm7BofEB7k6Bri6xDt7ePq4WE/eICixeQtnDxNvSGpx +SUBiUYlTaWZOymYTnomiAHPoK1rzHGhs/9nOWC8rK+0txs0+YafrYVXseJxlkM1LAlEUxVGqhUJF +GH246BJCWjJa7WYRSh+rKLDaROA8Z6758Dmj895kbkqI/gFnYX9GIdauaB0JQYu2rYJW4aaWPSYl +qLu5cO4P7jnnvR50z4OXm+0DkJNIJGDdFDZFDtQEreKggxqUmcNBI7qgR6gpsIa6jSU0BRpgmawG +JC/QBlFAkKJdm+OAx1QA5VC2uKQU9/4qNFYlQi+goUJaWCWq7y0vuRvtt2b9wjcQ/n9TVROr0WQs +7j6dRNxwZLiVuX6cGO+BSh7lzhLDiC7Gofmw4J9pTXf2A43KYCMz8IfiTu6XKr88T53u2g5CtUAZ +AjFr0rmNxJC2dSkZUCBcyj8ZuKCMgbC8JAqkvaRanjCOWtyLrBPGpFZyeJ+Wr/UiUMFBEF4Er0Ql +AL0pO7lRyJuynaxnk5qH0ebHkH/S3focce++grN998wiRnTbNtCWjKruYGWVixisQNJ9vQ2dpbo3 +qa5vvvMNeCGjLfsBF+JVqYRUA2hw2lP+kTS93U37ov94nDvEeIhxwjqROa4LGAwEFt/4L+MQp93s +bjNRUGkVAJe8Cm2oBHicMzQwMDMxUXBOLErP1yvJz81hCKmTKlbu9n8vtFzoxzf2Oad2/b4rbQhR +lZOZpFdUzNDDa3rWcJ6IpVn7k2777Gz2jTMeLQAAqdwbp/oNCR1an7lC/6j0cm1sTCwlb1cXqg94 +nHv7geXLF5YNMYG+CkCgr6+vEJKRqlCQmlqkXqyQnJNfnBqfl1+SmVapkJqXkpqiUAKUTcssKi5R +yEjMSynOSMxO1eNSgIIAoDZnkJ6UyQVhYpNr/YU21wWGRE1ekMoyuW61EAdMfvLU1aqCIDviUzKL +k/Pz8lKTS1JTNh9cvVxystwRjskKu00mK/TKTU64JTRZ76zo5IDrPJP5j/sB+byTHxzQRZgj8FB+ +8oQ7EpMdPrJPzu3TmPzhidTkA7sMNj872l4EANuIV7j1BGuH/TToAPKzPfr1XjAy4Ga67wCreJwB +RQC6//II8ggiMTAwNjQ0IEFwcC5ycwAjL9Rxo9XXQu+LsoqQW7iEZX7wbbEitgIU0uyarvr8tNRZ +ZWOBHAxNO3SBs76z7AKGAQ9KH+L6CkdpnWrGmpf9Yu8NAFLERhmZV/N0eJx7eZmx+yrjhq/c9fr6 +CiEZqQrO2toKxZkpqQqZxQqJOeWJlcXxmXk5mXmpOgrF+QrlmSUZ+aUlCiUZQOnUstSiSoXkxJyc +1CKF9NSSYoVMIM4vz1NIzi+oVMhPAypLVSgCqgeSqemZxSVFiSWZ+Xl6XApQoBwNMVsjL5UVaJhm +7OY33K9NBJCEIaKXHMQ1AcwpPTHzE7W3cvyxoxiirZ4emhZrhe7EWAkxeJwBMwHM/osO5g2QLAww +MDY0NCBBR0VOVFORXdg2wxmNYVpEGxt2rMVXaZjHe2IZSAc0MDAwMCBidW5kbGVyABHSs3MsXo9i +DZvkyVlJ2u0a29swk2sBMRQwz8LQSVBBnTusrLj17FVyLwd1+5OwAVoUzYNFRKgICPQ7SjFF1Owl +hxHlsXSTHgK1FI/P1e8B3dLfY3XZvdlfm6JZq6zTk+cCQRR/4SEJynQxjTPqCQB5A92AHNYdFJM8 +A0QU9ZCa3430j9/Zh58YWtAd4bQrdauTlAMwFMpdx1w6kB2hOYNZhPqtF+Nqq1SJk9gDWBTAIDx9 +CbgXFgFMrPcpxryMCJVqvpNEBLIU4fkZ6IobldC3p0AmCFKX0VNkxDKTCgW+FKqZ0ea86/mPc/pE +jztfivKqCGsPs9wFLwFAU4mw9hJ1HOiZcM1PLtqadaCfvJDkg8wmQXicASYB2f6NMY0xsFMBFDWl +ftt8tntPVsypks7XhKwrfhQDs2cBnAEUxpymhxPcjD8NdLYz0UZyiaymFlyzFwNlARRAQOTACY2q +InulnH3cNaD/+fC4MrOQBDoBFHMsUCei1lLL9w5nljRkvJbuYKALs94FWgIUp2Szanw3b/5qSrt5 +v+AJbg3e8weTTAiKFOylu3AtG3BJuVRuBoZfM7ggzcb4s+oIiQEUSALC5xfoL0VPomzNsEA2Tpvv +rWmTMQsTs5oKlgEUSYy5Z+GDwyqezoX7M9gL8zl7tXizRAxGCBTwSXxf7EAszxAJXnygTQ7TWRUb +1JOeFEQUQ9i/hEMNBiUTixRNZioog9FfYtuz9hS3AhRqjAmCLDWL/mwLIH5DDCEEIYh3UpPBF8x8 +Gn8S/ghI+h4RQIJfrKGLeYzYzWk0v2Om+3icRYwxDsIwDACljrzCYoGpfQoLfUCU2MGitSPH2ZD4 +UiU2ngASAy8iG+PpdPd5Dc/3sPF8nyY4XxAMPbBgAlK7AkrucKgQQ+ySWDJaMRavkJgIDch0Be+y +leqGYf1HWZeEAlGttDruAByrjxR46Z/jHiVq6gdtXtrjNn9PPwlbNbLwBKhUBZywoOSIYuw/tu4c +kxhjlXlEeJwBQAC///kWtRewqAUzaXZhdGUtZGVjb3JhdG9yLWFzc2lnbi50ZXN0LnRzAPYcULy2 +6t9X+Hr+DMqdOxLGElYis58F2gVychvU/Q++QhGaSqpoosyHz1Nbf7n+UPm9M3ic28e/j39DEatp +2ox7r+cs+//rZKr5gmV3E5tYtN2jTAyAQCEtvyg3sYTh0VcFbxEzritJs6O0JIoa+dze2RyavJzV +3Hjjwne5t+u/LJeuufjgisdSp+dbPdIhOjPzMksY7if1qR6pPWMT+TjcIsZ+qStrhNSXyYJsBvVf +uIxrptdZ+HkbXHninfQ++36llThEX05mXglDp1xEo/a+uHNCVgGJNVfzHHXzRRwg0kWleQwbvZsT +rJbej7S/sV2xQXRKgJzlcSmIbElqcQnD7XiBpk/3nCYf9OMxsl54+kqw4mEHQwMDMxMThdKClMSS +1PjMyQfY/gEACUtm7fUCrCof5Z3Q07PEHzj0WYr5b/h8YS94nAElANr/0EjQSLBJDRSqZU+oQxFZ +Gmq+0fHfLEWpwKFoqZPvDSOzgA3QFkSREUX7Ao6BchsOHwHBYbTNt/ZjoQtn+XVbeJwBKwDU/6ru +A/ftA7AgJpNeJmSTjiUTAVuTwiYoBl0gOiBbXZNBHROT/CYhsy0n/c914hCO/AjKeOSLfGusmUoL +xBGVbD7g+gb3wXicAYwAc/+NHo0esCgCFELs0xal7f1l1JsEFzPx3hl7BV7TszwCEQEU1YrjrhkW +1wgPW/rGs324kbcGBGGzYQM+BhTp/fkcDyiKka25NpIDr1mPRZzuV5PvCRazyQkGARSxHFb8vcsD +Hvg5qU4kpj9Z7+JHkrPjCoUDFEM58LsiQILUPBiZJN57fvJzzp+Bk3wOkdOwPmvwbbRwtQ4M+zHJ +gjhutPUjy/sFWUhFeJyVVEGPEzcU1gpWQttWVUBZWq26fZil2GIym02FhGabot0KxAEWVUjtIYqE +d+Jkhk7sdOw0rKJVrhy4+Tdw6wGJExL/Av5HubcHnj0z2WzabctcPH7v8+fn93328xcrz16vvGwe +zHpCx3l6KCg5HEswQhsSAGXQ/h6ma4BfrKQ20E8zAW2gkg9FBNrkqRx40GMPAkiHI5UbmHoKOIZ+ +robgOCPPuVvC+mMZm1RJ2Jo6quOESlZu5L5cmHEuQcJ3bdiB2/gTVUgqoQE7DG6cCrRYxXxcjm47 +SkrMyVlsbfWn2f5YhqnUIxEbWrG0muyEg+0+3l06tcZjT4Hw0BGHTzSJfJiSVN7FcY+wAM95Rnaf +MDieM9orrUvXaS/Nqw4GMMqVwy+2tKjF/kU2GwidQ9w2Y9Nv3CKMhVKhbuGQjyh1vxFweWSnLZjh +Ufz67W14KIVbGwutIR9LDYfKJMWRAsT3YJLivNFItcq4ESB4nEAqITUa1ETCIFOHPAvXqqaGDkA7 +nU63G0CnQ+YryTwwusNznmUia+9gsMsoUUUR3j6qDyYRMEkUTrAiuPYE9eH6SMbQz/hAV6azKzVS +K63o6/UC2V/rzL5bvUTKDO4Xj8YNx46zMAw9Rzdw0J0rm/Yaq9sXFzfs25tfXvDS+sSPgdXr337q +tHfbudH+vv71ZwDiqfeF47PR1sZsHqk8e4BYTR95oZyKbK6N7jS7qIpRPyhpeCoXzFFZ66O5Li+T +7Rdk9v3epizNurZ24njsftn8CBa73ld5Ie1E5b+IvJBeOoTLOEEqk5iEG1yaHUGCGDTBuLwBdu+L +uj1Xg3/WZObd1owKfxW7aPQzx+fAE8YiAK2KIgYC3cU9Qzi/9fGwF0FnPgXAZ+POU0FZsBArZV+M +FAb4pnDA3xMu3hj2ypStXa8/aldNXsZXvWu3zso0eiLjR+3mQv6/vfZ59ZJM8tQYIe2fV4l9Qz45 +XzRvvb5RJkKsyoicLvtydsqXvu9os3v8N3FfyIFJaGvZYf9CGAqU9We89ZSE2BfGzuQqisY12/79 +q/Z2V8w8wFenMhcSn3a0/SP4Kj55s5aLc1Xo/3VRzkIu3IJVfwtebR0k5z8AplANpvkDBZ3tluHn +PGCGLWwEg7qKGbTEl/V4nFsmfU56gz/n5CscQhIFRfkFqUUlmanFColFqQp5+SUKBUWZeSWTOOUm +V/DwT07lFGNJslIw2jyDk48FAF1IEv3wCvWSnH52nTi08iW7OBO8CNyol85xeJybPY3x7TTGDd78 +9VwKQBAdHaujEK2kq5uXr1ueWJSXmZderAQVyswrKC3RLaksSLXNzU8pzUnFIpGcn5ubn5cF1BOr +l5tYoFFQlJqWWaFga6egUQ22QEEhsSi92EohWk9PDyKpo5CWk5iuI6igBDQPrKZWUxPE2NzJP8ka +ADIpMPL4iwS1aexKxudLbMblIHncZUgMnKydnnicxVlbbBxXGVbVi1unba6O0zR1jqcuOxOvx44J +pt2tQ+zIbtpcTOKURnVc++zs2d2JZ2e2c2bsWu6yIPGAVFRazluhUvuCxAuhsuAJBO0LvOE+AKqi +pOUVeCkvSAgJ/nOZ2/oSO6nKSpZ3Z875r9//nf+c892P7n3z3fve+qSDLtcd2114++ODD4SBXSf0 +g0+9h05bnmuFvk/cANn1hucHFDW8RujggCCMfBJSXHIIsrBVIyio+V5YrSElipRRAwc19tcHD7Kp +b+9ip7+3l/3jxq5WJxIfrY5t16xfo1oBzatnCIFCGqC6Vw4dQtEowkvYDtA3fa9uU2Jix9HHfB8v +mxV4oq8gh7jVoFZAIydQM4/0uTyyDTR6Uhmr58xBJWowh/qRDX+5U1xnzjCMYptS7Ng4UZlIEM8H +h+Q0mMQO79FaK4iG9UJkqOmTcmgRXYeHeVQXJsBXUFc3F7ETkjwaMvKI4jopRHpGR6PZM0OzqJnY +M58XX5ryt7Stgctl262CdeNhpUJ8xEPhWfrT6Bg6PjR8Io+01zTDDLzpwIdxusGOdB9ujZwoIru/ +30ArSnTF5urmo5j0rdhN7tb8LAieJ69xj5VCYTU85UOKKPMqsaVv5YXpqQsmFTrtyrKuXhnN4jxY +fz/3opP97vqx8QRHWl5aodxVWJledi39mme7unKgbPsQME1Zqhl59vnq/n5NxA5+IZu+ZLtlb4mi +byDtWuhage25GiogDWZqIJx9ttrHHv397q9Lo/3QBYN1kZlS6F4K3Q3VRZAEfT9Y+to9Bvv7ntxB +merhoeMjUQoDPyTsvb0H7wOxOrux9zC7sNbbYZiUQ4a9s9Z3fuSEkc4fdXGD1ryAxkZAKHwbkFPH +DZ0HREAmwEESCVFUIlrs4defeCYjz3btwMYOSIsl62oA5IpYgS5RrOzrZe/0PMze+8MD49JEg0Nl +4tUQO7qyIzs5JTQZqXSujnb+qPMrMLpMqOXbJaJroIVTBmo4YdV2KaRY+rjC7pm60DIJOKLPKAjO +aLKyYJDGdS+LeOdRTj5WwOPljTRzsEwaxC0T11o2YVQMxDKp4NBRg4u52Xws3CdySCK+peSrqSvx +5OZmWrLyXg1tnyTiLClNAtOUQnlW1UB9nbhXjFjgrKFrZQ94zfUgNSQAtAGLNnyyaHshRZ57iVDP +WQRqdekSFLn+FDVAGaaACUFuwgQAoRf6FlEh/s31gZYMPAxdiTlNa2BrAVcJmACFUUC5FS1YbhCt +oGpKa+by8eAZIXi2oCQDbwHqHOInIzRsCqbOtWVAG4N4XUmNK20ybhzGpYaJSmvjfqRIF3Lky0Cw +D3BXK3ntEKgkQnglV7BDSTE1dTx0TRkGWBZcUaWQPKhrwDMEhpIgbOil0HbKRipK/CMemnHwYTo4 +HxC/gAZfuXrVfOzq1VRG4cE12jcoVhv28ep+sE5ZxDmhmBGMeI5D3wV/+EJYiLzSpZtmHRBggoV5 +gIBnEUpN7FcXZ4ZnIf4aD44RLQLRp2mkfzfh53Tqt6SGGOAFVUvNFDrXMTbAVQN1Iv+GEs8XuCMr +SC1cwr1mermcZ40PD7G/rR7m/Lov0mvVIIwT7iIa5dQ5Fw3P0G8ADhIwTOpPk/HMZmwsyBjJibP5 +WAtDF7vHOLtpWBMcNd3AS67e5p1yosBhKj2R3B35w15Ye+p++e3dNePlyFrOxxxCYHKaiRVVwnJt +ZL3zfBtwJ+jYJ7g8CdMFjUdyjCJ7/+KBBWFuaVvmjm9oLv+E7lbrpahSQ+obu2t97Ic93bBq7OlQ +nrOfTzzxWOyUSfiyQPXIe9b74H52aHL3CQVzimwomcC2IDCKVwTfuWRJdT6oSlziY750sw+Pdn0r +Xi3l6NG7WhRiEmO/vm62Ek13zpIaHkxWrIgrM6+zlqVYsJWmyzRbbi2xtLnEnfHqoYhYASc8efkv +iGEzYb1Tjm1dNTfjWCh7Kpa5NmLdOecqx3Uu0ZSwIrxk4HeLmnzsNth2Z2SruHUDck9lHYTei7bJ +uZ0ZjjXZP1f3AQU/tJAYnmHbJDl3wLjJ5BTrSmIp3TXvijzVNyUxzWC/yB1hP724+9m74TC2d/JA +1H1quETl7kMrEwsolJQ13o5htXeNdrVltGQHNWjA0FMU1TxvAYUUmCyAIdFGWCHKjzszoAqSBmlI ++fYInIEksLXrh1ueD7si7C/fBfWkaWKnrNjakBZTwm9LMm2s5UE4/O3zkfaFNnp2BentJdULm+ko +w+3UsxFteQ0ObOxkSOvsOta6bW94u9ZwS6LawpUYosa2W8gkKRGPpeLZRmXryKy5Y2LLEFh2sgf7 +Iser6mxgz+67bSNnNyQ2XnB3QGl82joyu8gZhr/ZGZvJms/k6v/SVD4nCNJyMOy/y196q3dF0Wc5 +KmgaALfAM8dJb2eXapB7G7bJ2LJIg5Os2uA6BC8qduXwhubWqmG3Ssq8HWQfXddd2UIGbdSZIqz6 +thhrw7PG29KQTITce4g0bFZ7bfZkSmKnLVUr5fKddVTmsS17J846ogsSIecYlh4qDa3M4C35q42b +EqHN9rHNLPts1ViN3BkB8QYqtxXbRGgAbcy99CT71+ojJLWsGgla5jc7Klq3e96Ab9qhYDRZz/QR +1vPLByKqe6aNzXZ8JvnfXz3Wv/2GS9BEclB5bu3JL42cEq1v93TtkF2unH9k9eMDpcut5JhRbo8G +6rgBzZW8eKg4uJocN4KJg4PoPNRlGQe4UIAsiJWiQjAAldC5GqY1dAqNREdoIGqutByQOXmPwF8N +m52Rk5MTY5df3H1pYnruzNj0mbmxy+DtCFtzDPb5J4cPrNuszvetsJM4f7DZWVHn0ajkeXXdKMCW +d5EVb+QG1YMiAMrCgVVDOvF9z5eVl1475XP2xo2BK+nH2tRZDvf5YieMj7XwKKuAlAtcBdCqqw4L +wS6NKzUDGndGsmzZe8e7Wdi950F59pfvZLeOP86+v7Sf/emWVozk8eP14+JcfQgWOHUzIcDQzNgg +D44nfcgnM/98dH8erbOIHbt5sicldxikXj5zaeqluXPPX5hoFuYBNAM3h9h//IfY07eOHYhlCzBO +cCt1Nrn2nQ5FO+yTm4+fjS0JCA1Sp6uWz1Pt8fMG2eDX7EC09uIIogJgqA3IFxTYD1hWy7NXOvrZ +jxudHSql7P3PuthbhfvZqed27Q2WoAoD0UasfzuZqlGUy9wfAVPF4S+i9lex1CK/WWKn/tK9j1dt +pupFUB6NklgYLsSP1Oz4Ud8TZp2jSh+cOjtYFb3AGVhfzwls68Psq7f654xiFCy1MRJrUl6QBd8P +LRDSoABFh6/R5Wh1hzqhAp82DfgWKAU3eUQd/Wa4Q+cxbEVn1OlLC1594lKPnwCdx41nY6iWeOEH +J6MrDCjiy1616ogDoxI0tkie4wIYaJ53Cy6C/RfwHt+nYSsA9hD5rXg+4l4hq+W5Fbsayg2sKYTy +l7piO2AN5FXQTGR2HvUmX6Nvs8mSm0K3zquNC4BUi39ZYlRFtzcNWkm3lZd72L9PP7pP3XDihswL +3yP+pN7HOt3OVjGjTk/GnERDLk/nONF7N1AqaG0UcdIzOR2P29UXn3eDkRPnJnRBYikOi6fyNkBm +xIR/3KUWYCbSzd8ojWoQdAjS795YhHpD1Zu8eCARptI4pqqvblMKvLPk24Ho92xoDwFi4qI5wPUG +lAaqtSCFqiOEb6EbeCFHnxltq8Voscyoe5DjQ/wT/W8LSl1cSY0ml2ryjNsUz8/T4vrUdm2YW9Y7 +8Ph+NUlFRPyCNezJVnI7xoOvLGimr9LS0eOlBmUJ/LQusrz+ZLvSTEpU13yizmEgJhiCU8XWctSV +DCyQrmUFOHFo4XocVgmR9WeLcB2IhTl52ZWy3651PZLBLCMvHwXAPsy8z17svf38qQGNvV8/Cjje +xdCtQ+yPl7tXx+xcOCHvuSgvVZDg2JYdOMvc0AFgYaLs51wTw4MzNa9xwTrY52PYm7dC9vrNn92r +D7mrfZ/evOd/IkFXiPkDW0AscXqU/xvvgCyn312PkJamHW94nAE5AMb/nAucC5BAFA6oYbX32lXN +bUpCNo/L/0rEAJJ+sVRUARST5Zg6szT7GmPN4dbzKcVy9YfKYLO8AeADChkcf/IJFuyzwygaQqAk +TIlgbffiOusvENd4nNt8nX3qDfYNF0Pq9fUV3PKLshVyEzPzFBJzivMVSjKK8suLFUKDPF2LivKL +FNKAuCQjVSEnsyS1KDFHoSC1KDk1r0QBqL4kI7NYIS2zoqS0KFUdxMpJzUvMTdXjUgCCktTiEr20 +xMyczLx0DaXijPzSnBSYZt3UvOT8lFSF3OZ3IdvfhTAenQYAy743YvmJBRVL+rQVT++ilsF/esaJ +xw/iTsZKeJytWmtsHNd1xqwtiqJESrRIkaIo6Wq0qmYl7pBLMQqzJCVTJGU9KJESKdkFteLO7t7l +jjmcWc/MkpLpzVYJ0DRFWzi5aMZJANvqA02dxpBrFEWCFHHdP0nQAgnQ9kd/uDX6wzHgFk4B1yiQ +pj333nntgxTZdP/szsy555x7nt+5sx/8ovmDj3a9/MWdE4aJJ1Zyb1W+1eJ8c1+ko7LegthHUzJY +SyLRwqaqaEg39LimWDbKqxoW+1yiFSOHgSYeVy1DU+zggbGmYxOeKHH2S7axZcu2FTzPAN9VRpKJ +exeUiuzdsaPiUVlZRaP8B9x1Zf5Vq2JRMRVNw9oGunmPxwa3qN7ukH7kf57s3K4+vp2QoSMFrRnm +Mja3pdeLVXpVGtpNqbJblXU9Pc8OwCesayomiUwxGytmDmQgbJqGaSVRlCkv9iFpne+jjynaR1Wq +YLPPl9zHuaNyDI2dc7fO5GMlW5AWRLtgGmvARywoek7DOTGFFAtlDd2yQfgJC+VKpqovoayGFb1U +RCa2FVW3XHvRXVsFtQgMFOu+nkVGyc4+YaxgB10SYqKndpypDUSe6RFaYGtTTvtopMt5ui2CyLkf +7W5SikWs55xFUzjmfP1spLVpzsguY5v88Ku9TyOuFWiQNcwcGkMr2LKUJUz3xdddBJ3mQAtJxKtY +ty3ZvmeDUJeOPDA7nTdtoWmGexg4FE0jCw9lrK/KF25dX5yfmptffHbm5tWpm4uXJ9H5814+iSO+ +4tx8ksj0R0XFshxlZ6SLpH+7CZ5x5STRshXT5vZBIjrtBhUZL3eSq+mzzvRDYQ+ZLreQb6ajAiL/ +rBwlH6bbyCfpHtKqnCSDyqEKbFczLCzFQkYLPp4cRlMnJzbSYIlnPcWCMB9DOl5DU9QttSFmgelU +CCJNbMgm2kgdxBwPfkdjY2PIDaqGdAidd5+7qow0putAKInSNY/Icu5ghSrOw0JqqCD/WIxCNnQI +Bjf42DeNFs94bsi7tMx+kksEu+DqxWI1QuQGUnIQEaZxX3KXhBeQ9HcOF9z7claxIenq9MgqpaUC +dc3zOGur4J2taRJ8PDs5/b1Ct/PrI5FOJzUSOebc/ZLQQr7/6kny3cwZ8ujVZvIfmQ7n8BNCV8uC +Vx82ycBuytINdpeaxTsm7/y4O7Vpynnx7y1jG9p6tsVYrr46HDlFjrwRI/u+t8uZ+i3hgMpLHNRi +ExcN08bm2PMlXWUCg3txCEUa0WPwLd9b0cRUX1B10nJ/dJ2lSzndh/iVq2Q5HRCS/n2nKm7h9G76 +1ueJxPcLiZS3fPYyeCowyfOGqktzNi2fUk41Y6BlyEj0EhQdFmPBcqBdkbzrW3DDKmoqmP+OHuQi +vleEKJFcTrBR2DK/oiHFfsjM+tazql2oqRCxGPnGbeTMXhH2O79MCsmYmkcStWrVkqDXwQK3/BD9 +kyOV2fGb49PTU9PhylCrj57bTJuquggRLdvGNZYU/XfDj+7kTkf7fSFl97tCtWXdjpeZxo07XDC5 +q7gC4KotG43rAgrKK0rRJ1z0KLlX6PM6O3AubJm00Id0ZQWnWOulv9h+p14oKRp0Xi/uaPSyXYtO ++38J+yucw8JAamEwRekvYJfpQoLdqrWKV9dp9MMelTVFpZcvlFQTSyIkwODzlhiTwaUW5tE4axor +KrSWvNUgYIerI9ZLoiBcw10cyp6atZPINkuY/PxId4VtZK6k2tAJXJ0Y3LHoLSv4yQPF4oTnEL8X +lZkzqW8Zn5qM8wy2CfvKlvm7vGpE5BVVK5mYxkqwEyYhq1jYCxzvmnIOntGlFRPXJmqV1lQFV4Tr +WgCndSsaSobtNJQblWlk8YQwOn1QgqnPXVmOckE42EOTp0GXhnRxHq4I+8nLd/eQVxJ7nPwzQk8l +wbtlg0QPaVe/mUSDBWGaS8oqnsb6EuRYYmPKhYFKSo76tWEmQ/siAF26UYDJUkn3OjdTMgYZRB2b +5D6jUBRMThupxcA/YN9NRKW8TdCfUTdBK5Ch68i+X6Typlz84OJIuNMIMEGx3IagRSpowtApmJaq +g72MsPYkONl3S4eTeQZ+/Ojo3vyt6p1v1z0Dj3GPW5p4HdqsWPIAqsFPtAiIsce7+fGMKSA6U4WI +HsOb18Ky8+hnwgHS/o2eiUEx5Y4vBmSzblBeVgkiX2E5DkozH7rDjedKf4yhLZEkhk52cOK4Zii5 +uEfl/MaRyGdJ26koeXSuZUeAl8iXB/Y7f9sa2c361JJmZBRtvqBaMqUAMTPUNZcMY7kW0m8OpTI4 +D0P/uKbx8L4TBgP8AzNZydSRL7G3XqRc5DV/pMVJ9AodZBS3ON9rjbTnN5et5MFFVDQDcJtsiaJ6 +3sQAtgetLQbLRNDY+UpbpLOJj+/kwU+Ok9d/0Ftrvffeax7+FWa7/c63n4rs3lermNP650J0iKPY +lRKUeBYLJepqKRYG4SWdhyeEBqUGDPrT7+4n19JDfFj7/bRE/kU5AmPaHvJp+gDZqxwnQ0pXYqMh +rcGAxt1GfvBnXQt17oHoNLRVXD/R8FEpPKwFEdmgBMVGSDpzyPmrPwIfL33rDAD/BPko0/1rdWwg +wkuQAIyNv5ooxzvJEzsOko+/E691z2hr80T1GGD5Ntw8iLxVLHLJ7PsdZO8bwwDqd5KjZzoyPqYv +mphqMyb3u7/YEcn/He0viHI/izjywyaJdI62k7F9h1toO+AU5P3fO3zKKyGPx8HkhU8ONXsA2PlJ +QRA7GtmQPak8zkktAeSonyN+pSmCzRDz/hBRP0FsuQjX1B2RvPjpUXkLtTsU8HSJ10cAwOB7M3mp +jm+Md6dpyOR56ChSLX1VBm13E0Zmp1uKqC5Dj1/gVzy/hoU2EZOheoQad4g6SPAa7erW1BWacDRs +AOML28fxW4fxVSD+wSsd/28gvu68tmqrG8L5xLYlsVPfauNvGXZvC9ZujNBj5KVPD1caPPBh5Tax +bJ3xfHS5sRLnauGs7PZHbyOb1yUfPs368AkqMQbGFqLHxUyzkxYETE41UNHQNAuB8gjqNTO2RU8B +iyW7CkaxY2fy38PHTkDo5cQUG42z9G46up4txxkzb5PpmPPzD4Uep/J1YV8re+IdkjuJ3cKhBGJ2 +4+M1H3vOoYVQx6T3+kLXafLoL/rI1dd2OW/dFcR9vKMyLMCYk7/+cVfFPwWGWzRN1kwwqSTO3JpP +Rtcpw3IDyBVeBI7zFk3dvLnZIkbFUjQBxrg4mQDiyhaoBxn14MasITTSwb5TMf/Miv9wifv70VWM +iwhaGsobJZP586xFT08MHSP/vYx7Pm4bEGrYzEKJQSq0KA7/kLWmFC2ZtL3xOa+H76B+TpF/HYmS +vaNd0GZPVwKJ84UQ56wBoEjVFdsw4fdKBsLO8sRx87OA4kZFqs7kuoUhXDpYmEHNkNxFFGXqFKPy +lTFn5ajQ29l/VzqfBD++BG556eLkQmIwFUs6349Eeiqcg2wBYyl0KtMShBF0CU2xr4UDLR2KCXp6 +GPI2veT+DF36DkunYq4o1x/Oh68IreQdWSZ/19tGPj+603n9ZwKaloJXcyhnsvcsGSW7TPPLgpTO +uZnHOyhAQwyI7p57BJaFFgChzSxmqfoyedjf6cixSFNX5r7NTjSG0SmUGBgccr9oph2PMo7xsJTQ +axqoQcBbc8ZzQjf56eljt+mV6ygf/K1vkED3ROhKRVBKiq4zFcrQvasiVczEGa3Pf5xtZ4v8p65P +8kQI8SyTByefcWYvCm0HmebBqzYEaJCLIw9/c7/zJxeFbqd0WdjvPJsUDjgvfk3o2AulQV3BICGJ +PjMwMEBb4e68alr2TRgdNZtOEt3Pja4aau6ch9PpBVNPxvdAKYCsBaxLXO/Q0gDe1zR7JTfHQ32M +vJ/tdD7+pfDkZ/zgFv23Tpw8ByNFjr23ojh+Hkw1ye+ANuTBaqfzp/8onKhUjyIus9Nj3mqZf0vZ +QklfBk/T7o+VFd79qw4wOCh2E0XVs1ophy1JlCj2j6FwJMRiwWYvhHcbMCv7v9xh1VOsVi9YQz4u +91QaWq9m3K+uam4pyJdAsRJ0NI0lCOPDaj4qKPS1pa5aBZwbcR9C4tB6hthoyFKOJZB9CBqlXO8q +KoC5apzjs7CW/oRdtU8WHG7g2uAybxNl5+WvCaPdAV+oDaGAcBKDQqcz/TdCc7MXD+StP+ipLNy9 +o6dO3dH7IaBrQQn3lMbORtyGz1P/NBpqSAozmzvp0FzSPSQ+D5EgNVxgIlzUlCwF7zS/mQ4etOAs +yI0LN2gt670KbnkWQJux5uGFEoURFBbAKKobJShtBiCeNahqHAFZsH8FvAKNB26g2Zm5y89xkOH8 +098LxwxomYNVL6dvXwswDBsSGlfLfA6dUH1IAlf+e3Du2s3K4xFeHkPnQ35ppAnv3BAifeTp5FPt +NJLmoOpe1mEg0BXNIkfFwS5Kg9bAwsgd+JEHOzrJx+80VWidppNf7WKZkdFbUDvzueqspIvcGnih +lM9D6kBvNbJ+lQWv3BOr3xXWC2B+nbTnqJx5d3cS5Vy1zn9jB/uQBsLpXFVxEy264f4xRSIP7xxv +p/R+6aVoxHl4UThC1N99qpe++Jucmpu/eWtifvH2tcWZ64tTz12eB7ybEJ3Uu8LZzQtyJafYCjVZ +jk0YCXQ+nGEo6V9BDjWcqxospPU3GWbj15VJrKkZDFGJtfsIgPAqnmN1gylRVIuYVxt6uFJaKvjR +mES6wXIZYjkLoQwBmYXiCiEgxcJFZYGnlSMYwrEmrqEzbgD8pXlfAdBk07/yeLMgFVpVQqpyEwAH +tfpYdJ1+TUAphUCw1CXwNtzjm2NX7NEdHe5x/rKlqVksxYcGPnc2Vk7759JXYYb0Yp0nkp9swC2D ++RlQDnK+CmO6SnnMeTUir/9Dz42GT2pmfxbBNZyqVecLroPZJUf5SBgixrfb3j6/+z8/m52ACYUd +RpfMLEbL0BIs5izDVJcAckK3An5qXsXmCJ9m2BTk9haKmwI/wqpsyTTpoUBRK8Fqi7qtv5/MXu8Y +hqmG0euAjxUOFYtQE/vQWoG2E3FVNe2kXYBsF703jyoF2G+/MPl+Kyl+6cDZnGotx7NcXXWFut3y +9NhEB/Jw7Az5t9l95N25N9sRPSQHBnFPPmmeP9rObxm6dj8JkjMaJsPzw20+bbZgqIywI3SNk64Y +SvsU0HJpNHOTdET76o0Dowuhm6mglV8o6TJ/EAy01VoBmHRe+0Ohhzy6fIicm27fExZM3rzSQ4zp +pu7wHwMmxicuTS1OXJq5PDFFfme6pyXYE5Gv9pLKlVPd/h16lkf/AVWEvgE1ifxi+sQVnlpUAXqO +TGeCK3Mz12WLHYeo+fsSI2bHE9xGIj27ZmInF6+PX5uamx2fmKLH2GT82nnyldPHItF10j7T1cQ3 +TtDUAdF1XhnloelTaFmzbdl2El8QOkl8aleFb7aOlt+mFq17QcK5e421TrX6Nyqcl7ugxpq7AnPy +o9eWtz8//5xAXrrR3IeQLFO6YHQMmz9Jz8m9R2XnvS8LCdJy+zUy/e8Hv/ju7b9897bwxx/8L5EA +D3v5D8xxZ83BPmzlH+kiDxYcjGqu1VsLeJwdjb9Kw0AcxxEcVOzSTaT6BUGt5KQWuvgGIorgKEIu +d79qanIX8vtVzOQuOuUFHDo5KYdP4uzik3jp/vnz0yzmn3+b4aW32AgHW6+riSXliIWsGk9GI1XQ +IxWsLFF1PGPc4Pr87Aq32MM4mbS/g7fwMUhX2n5v51k7i3TGBqpMoTNfC7RA7glF7h7gp2DRtcpi +5xR3JBfezgu61CVxpQ0dDqGZqRaOThQ1yiUAFwmLrEFKT1VXPYpgipyXXbIJurPeNrVnjpppTLRy +6QjnBQ1J+wUVqt3pevt+sha+h/v9f4PDVrj2YZmdUeIpBkz0OyvBsEJDF57tFSayeJxlVEFvG0UU +lgXqwVQoEhEUVVSvBrW7wVm7rcLBlmsg5BCpjVET0YNlxePdt/aU3ZnVzKyd4lgGIaFeOFQR8rUH +fgBSD+XIqRJHfgtXDrwZr+skvXg9M+9973vv+2b++vPK76+v/NHemNdq8HUuQCGLNBx0vtk77nx7 +tN85OGwCE8DSAUdhYMySHEEKMCOEkdQGJjJPIkiQfQ9xwoa6DEBQnlQwYUpwMdTABjI3NiP1gQsj +AceonoLO2ERgBAYJ5qNMyRC1Dij/fPWX9Y1/3j/7ZbrxqZC7UuFuGnlMDccN0EYRerfnr/+evbhx +fW5Pm0sWD7jITyDjGUIokwRDI5UGPhQEBI8e7D/cPzre7Tzaa7p2UpZlBAMxTwwq0Lka8zFqwBMM +wQspx9vxfUswlIIohzJNmYigBVy7SnQCMG/D7TzhKTewHUIdbt2CjNiZmP7fh5pts6YxiWsWMMrT +7LioR4GuUuWzLyu3HVTjLaR1gO1QocmVgG6lNuCipkeVKlS2r4f0KajZ9TYtgyCwU+m9/O/Gr+V5 +ggb0U20wPZARPmRPpGqAyNMBkTiFXEQYc9KlWS7XtrbAnQMJpjnJLmM3qmU62Pzgia4CRdRhMkLn +C5ot1yCkwAAOrcY0ckOeQTA8xWDxfFravCtWpb9bInv+Gw5Tao3H4F3iePa8/eG15eRtMo3dfvZO +0POb5cWLcWnzPbfftj4Ozt75fHcOMz/QJrLua0Cl0nRTvQRLOBlTGveF8YouAyMPnaM8vwp36j6c +nkLdJs/WQ7+E0izP3LjKsAVfQT9CHSo+H2CALBz1wbBBgnZ4/a5gKVadkLnb7fUhJhaMbHdCyDSk +ETOQ5tTmkOy3HDflAHWR5cYWsBIpd1ut/ZarQooAjtbyzItNKwcXVgQnETeavH5eVTqnmnSHtcPv +p1y86awfQN/OtSMecxHJiW5AzBKNfRtvr4fVNrf6QhFQXTV0r+hoQg8FWuBMIQkYcWOL2goQMiGk +gUHO6RGx3ln8uFO6Ns+FtYp+zM3Ihnk09/OcVlap0v4ULrAjOY2iJ2rWuHzSbsBASiItYEZR01m1 +TJ5zeqxeEKcLLT52q16357y49JxynBY//Vb6YG5PWtDtVga5oOtFv86GvV6zsK53kRP55ybXxcq3 +F/lt+8P91oUe/aIi6iDL9cjrVmwOVRMSCtvf7PnnnoFVOFnx52f+q2d+6d+r71oyi793Sp9stlrr +q+0TAr0CuPjhi5J/dXktAJBUfUU7r/F/S2cIff8BY6ODFszvA0ZN3XD0q7U11tFalJJ4nGtjaWOZ +YCqS/Gax75rI5YEXT8iFpE6TqTK1evhzo+deRgDQqQ3HrwR4nDM0MDAzMVFIKs3TLaksSC3WK0kt +LtErKWaI3GpS5rDUT+1KpEpjNIu6u8fdyRImBkCgkJZZUVJalMrwOTxA+ZvDd7/ECp3+K59ba+f8 +a5MBADz5HmbyA5a0fpJIg/MDMeshjSkwut2IpEj6eJybdJKl7RTLhiM2bLn5KaU5qZMPWivyQJjx +Gfn52cUggclHbBwmK9rKb2a27X8OABlmFLHxAgbmtsrtexTh92N6PLlLfRGpS8tUeJybKTJTZMML +NpEXpgIcVekP11UuY9jo9+HxF96qStnNf9hkmQH2hg6J8R0yEIfUdyRzkzVGH5VxnUJOmRIZjHic +bY+9CsIwEMd3ndwdjjrYggRc/UJQcRGX6qIoxPYKBZuEJqgdxFfQR/Fp3HwVbQstiXVL7n7/j3u3 +Xu37Zj+lih6oRKASltzH4t+B4uUmzOuAq6jCCJkqwHKg7TIUrhDEPAKLpdBjPr7prg4J5UAlAnlg ++I9sp1/Di0BPrdKtbQToIiMqV3mcSQVMC+kZh9RhCAzP+ezxad6Ybt0zT8lQTUpEjILGaFvubDGb +rKBrmTVZpWa13w++LgniHblE28l1Jx76//CS3rpJdOBH4odSpLKdqXsm2PgCaA+oRfoLtLCvBPuM +ie7dVfjRAM/I3SD+TgV4nAG6AEX/pBekF7CWARTBbpL1WOwhKE0aQL8mCutNVGO4UrOqAQ0BFEqt +HYROSAy9AW+CQ8VjaK6Hxpkfk8sCXBRKv/j8gthfosyBPJ5hUF3lmU0FprM7A/MCFMJOFcBnDmvt +phP8US6W6wprhtp5s0IGtgIUiacbWeJix2qUNgtCNvl0R4wM30OzDAlkARSZu8VxLhcucWVTQ9Gk +/7o37vndh5OECu0UjafK5AAeZexX6ZaqPdcuhZpr5/OThQsfXQxT5fkWKBKDjoyrms6k5T4BzkD2 +pPRSagh4nFWQwUrDUBBFIVVQNxZUBHFxeVCwkER0Z6SChSBSSaG2FCmlpMm0pISX8t6kWErxIx7u +/Aj/zI0fYGJRcTl37tyZM6/Vj8P3ox1TrRy/DIY2BsJxOFRT4sY4l+K/EmUxTUkKG3/aTEcbF5Pm +sjNJUnLLwmUthsP62R4giilSIWfKyWS6hCbO51A0o4g1ZMjJgnCeKcQ0CfOUQc8U5Zxk0kNtJuwi +ItRLGaHYqdG4wapQzL5VM5eWcwWQXHhYwXXd4mhfLmw0e8Go7zdb993RnR/4ndtuu/M4agcPTx7E +hcC6zDSpdXIKaI5JqUKfJ3P6Xgas69el4c3qmc/KgXG3d70+jVsJ4xdFb1iiUMqMMc6TNEaBoHL5 +Q7R5kRYm3qp/AfhzcUez/Ad4nNU7/XPbNrK/569AeXdTaiLRSS+XN+ec2ufIiuvWsT2Wfemd42Eh +EpQY86sEZdnx+H9/u/ggAYqSZbdzc28m40jAYrHY7wVWcVrkZUXuCbstWFD1ScV4RR5IVOYpcaaL +bBcHnHcvYg0IY+Pspi/+v2V9EvNPcRbmS45r02I/Luvlc1pmjHNzdTBP83BylwV92DHmFZefl2Vc +sQ9xwvBrvT7LQ7YbWeu/5HFmzxe0mgOEQWCc0fJuLM5DqzjPeL3A83bgHw/KuKj4znQRJ+GOBB8w +A96rrD1LxvPkho3yLIpncMq7ghHryyktq5gm1th5nifBnBrUdm0eiCWt/dI4pUmSBxtXhqzgOxqy +hWDJptdx9fhyCddaHLEqmI+S+BT4uhGFABwESWwjeEFIkKfFomL7rPiQ0BnvN0Pt7z/SMmRZnM3q +ifnKCKcRm1Q0uAZ8LIPJIGb2hALdSCyCtE4a0HKWv8fpw+wmD4TsN564XHCbW0LS9wR0HnRHYNq4 +nueLMmASw4tokQVixzQPrmttcfMbVpZxyPiuVqt/1JPfkyG5f+jtGsqF7C5ZtSjlR2BssEucnYhe +s50kuUlRvXeChGYzpy/nb2/XALx8qUDmOa9GgGYBzI7ijIXGMK5ujYvF/2Qlh8MA6u/+6r32XjvG +3BmTBwc22Vsn8VRuvfPdX9UCWq5Shx8GtFQQSdgBEXpJEtYAb98cdUO9fWPAoTSPYG4N6Tg9ueNl +nlcrR8a5H4Ed5yDdhK1M8wrG6/1xazGi6YM9JxaEfVITNkvXAGWpJpPRMJ9+WQOmZhUsfAoX6bp9 +1WyjJ1GcVGtg1ayCDflduqjiZBVYzyhAjCcmW+C7mvnCzxZZFadszTzjwoSsWTWmCQ5oMF+VRZAC +uLVMjOhF6AJW1+Doj3m6ig0Fvyg6p1J+ExzF2TUrV1etGlNGeboy6Hlebf448vDuxYPhKJI4W9zK +IOMW0jfstmOP4IgwNFSjDKNR7SuGLVfTA08i15luxIp2rqBLehbQH3BKjqBCsQ/tNZjD4O3bN83Q +NIaRWbaoRwRR5+ArYfyMJYxyVs/JGIR4wQMn9hI4h/4udq3NsT0LjFMMkSMP8r/66Pi1ZzOTAaPv +MHCcRG4QzTQneiqAZZAF5UvkmRm5EBLwaIDQCEgNpA57NbDtn3cRrxdEOrwplywGwaqa4Rr73WjX +2spabEAhGhvOwgcsvJb7JKExjCq92xkLxQE8lt14o72zgxN/fDw62R/v+2cXk/MPR3sHE48XSVy5 +zufb15HTUw4c8xFa5aCBJ9MvEBYBAWgi465bZytCfAI7odyMnj1P2gMnP/yAkc5LaeEqGbuXGU0h +37yhyYJd9cjwe4ID5CVxhg78FeOShl5jPFJQKBlILkshF5DUJcw7g4hj8jAoyrwCAvISPW+uAqUz +2Pc/nJydH374lz85uTgbjYffqQm1DAIXn+vFwC09C4e9AUUc0EWVD25oOYizuBp+ZWW+EWKQ0tsB +j7+y4ZtXf3+rQbN8EILBVGyQLZJkUED2W7FyAI4uuOYGEBp7UA3Qe0RJvlydoUlMeVwfLuIU9sTd +aFnSu8E0B1fE25ODqqRFF8S+f3B0+H70yy/+3mQyBi6dHE+Gr/Xy08Oxhnt/cez/uHe2Pz4e79cA +8G3v/dHY3zs5909PJoe43D883h+fjuHP8bl/+HHvYCzAr94pCaKo+Z7WrTMIayhH23KH3wP6ll33 +pGOttdID9QpdqWWoQvKTByItKyhkqrnrfDz0D8bn4+N/+ntHRyefgHCnJ9H84PEkDlgniJewbFbN +1X7KMPoOOICdHfIJypuKZSRfVIQSzuBMIcFoR8ATFYuyyDn4RioVuprTihTgvCuuCiMOUxBuAbqE +AgryJRhZIlTMiVAFFpIwh8Esr8iMwXhGpneAmxEWQoJv8vAkmoBk+V4WntKAaVvQpunj36VfzWUa +YIyXLKM+ozNW+mBNaVx1AsBZZsxPF0n3NMQWVt6w1tyMZQyUFPAmCdhSazYF64CPCjVaSAugAKL8 +CMwD0Ffg7NvTYl3IJNV8zWxC7zpn5nnCuteIGcWRxro7gQRxQjE3ACUUP4P15uV2UD4r8mC+iThg +nS8cxo2KrA0YD+gNKCwrpZEpDcFYYPvIUckSFQ4GULmzZFjESgCDAdjXEFI0X9ZsLFTj/2751aHl +V0faSSkvNqxd578XUz12J5heWz+GrpouZyBIgAWfkv7gaz9Df1d/A3pRFvV3ziAzoOBAA6DeWsVu +WSAodZABeM3hwpn0WYAsMotvwKiE4MiIULDZ0cuXRBYzfTUeIHIxV82ZIJSAlkENX8UzeZsAm7oi +XGECsEAnTMK4hJOo6xLXEfGw3nkggjOsggDY5BrAa1hipoD3RK/YJVW5YJD1kIlI+lzA3zPWRop1 +bd+IEPLew7XL7p5X5ePfFjRxrchpLugs4AXWTYsj8GCulimmWBG5lKV50Cfqw+2t/mjkNh1Dt7dX +PZVUKZoQZbO7HPRE+AKWoWtA3thECaosunAfQZeOn5YuCw3C8SIOjM/MAVosKsAVAyVqXxeRiq0e +Gg7KA6HJPUpzbZc9UwQSAarcowhqA+pAUMfGnkEwhrjJeHRxhnHYXNMRiFtS7wgzmHv3aiOjMn8n +Swi3GBEbowONxiAGcQsEAPaUPs92BnkUbWE/v8detlH/yysDJ3AZMKqUWOSqXPK/58F/lds2j1oN +obaxVLaP1U6tEOJbLV1QSFNujU7C7mtV0lKGwFKCTgvYVhveswtd3rq2AuRZcgdSL9lvC8j9B2m4 +ZEMQGYFEF1OdWhuEbL8FDwyeelHRKcQ0IjI1TJsogVI7Y0mtRqdncPJz/+P+p/Ez1QYJaetNkxni +HkMz7MkpX+3vi9UGb0zteYrf7imfYIvLoqP3jG36RPH7I9C5SyKa8LVb/55tf99ppNjsc1h0d3Os +ys/nZb50HQN2KEDVAK+5IYadToUENb4eQL0bQ7qSQtnaKCWCoe4xVq4oKKbaGPuNhc/UPxuDpYZI +Gmz49AygS1wC16qsDdWWIL5J0GPYIG7byETxd3Qy+nm870OpdHh2cvwRqjsdT7AswhoGWRfFZVOl +Q00D7krUPPqyBvwgo8FcRQWSw5+SVMvc2+yJFGmPhSbL72KcQLerr0w22BOiHzccWmNT/VVMHRDt +VKYdejqtaAuBrUco5NXG94jMnuP3rZyny7xX2LjZxAUZTmvRRlvXt389I82fLRAkHGDxyLGOBi1D +R06sCqAvEnsWC30LKFTVDHA3mUujjEv4w8gnNv05lmW51OUQ7yCf6Q0sEtv+QN9gtK5TDi7wsmXf +P907GOONTEu51SWpUPAu53FP1KanuKcev8JbOuue+bJW1/UJU8dtdUukK6n3H1MStIoBrdySY7VC +ruOK4ELb0m2uKDPvZItpJHay9zTe6KywbaLGKZ4c/+ur9qJkqHGVs2plLS9ubLdWjbpU5o9jYpfH +MK77tzpUOzvgatVQvjm0fYNMN9kAs4KBzDfRQUAu8F/mIUxC2w7iUooOGJSX4ZW8NxHe/Wz84WIy +nvjjX6BMOB/7J8dH//In53tn6OX7Zn5bsmjB8Y5LbuPjNjLpxRuTJzoWheQEcEwQxWYN+P/sXdYU ++BoS5fE8L7TKwm39c1fx+Tx/ZB2wo6rs4kMHmMUESSNazKmy4Q3CfpZbM9yluc0Gb9cFvVaSG1zV +GrV/mt+SKU8b1VAakPBJtUeSY91+TuVBG+ndTuf+EPKF8trU21nck4lfy2z5JA2euszjEJycerWm ++P/bN8/lfE1ozoeCEBELYK/hLFvgW0264ElH9rlSQEY0hnoHykh8G8oqcDZMhQsMH5rDOnYsqRE8 +BP8g7ORJCDFGuzh9g0w5ttM96wYN8Q1q4faVO3EytmSlRx3g3jf/QPZ9/zn7aTLyRfbpp7TgB0aY +//yqmZMlP/LwEx7tsOLY7zei2XuG9cPnV+rt3xFbP2ELsc4MfZTLUnlNk4R6KNStB15R5jfYcdFy +M6sa3jcSj46bE6kN+7LyMS6Q7tJpnsiXi/XHwMi7Na9k+NXeFU/bYbk0rwOEUQFDuRVPRRfHFNuv +fqI3dCJ61EZ5yYDp/Zreh962mygjS6rc2nClDmzhahPYgocFUn3rWwDxNuQK+mVzix3kgGlpAWzG +FlHXkE0fj4xtAp6A0JUsXVIwJmkRoAIBrHy/yDxe0GXm6o6XIIWjXspWVxcwmc2RIDFB0UARjSKU +JgqfOomAv4KEmsmeAMNn4ivdygIV/K7usVVDvAohlURNjIumcQZGWVnaow/qbCoFlAv7ClR03IKc +Q4bpoDz+aZmnMWf4BuBeIhc8ucar2G2FB9ZjsN4eQ1wsvFIb6hYXfOEukFaJBriu9xYHR8Vp2n5d +MdZr6MKeDeu6QBIp5V67Hkub9X6OY2yhQ5fEukteWe5BukrNAYVcOx1TUeWY3MGM+5abEu4Y391t +l7yUV1uQ50sXD0qPJQQBf0MOq+a1XtXx25t+Ow7eN8eWFKmv5vnlRMNlk4H1amXFzarXgmtG3Go1 +xGARk7CoEl0NMlzBieZoT1guFVWcxl+BHxAI9yZUmS8XIY1jn4O45Xtm5QN5cxVHK0WPqLR0K1b9 +YuJhqyIrRT6OW4n/vxkOu5t8Nhe7ZivbPsSFmSPLG8pptn0+/vhj7qZYYyXX2zxESbY8dh/YcRu4 +hjsPjVZ4/DouDiO3/hVAz8ObWhfvTy8dGgSsqDiJswQ9JJFii+FTkBexiHqXjtD54NoP5tc+ZkLo +R2EsEy0wEQ47V/2mVVJ4ysumlNcNMIA7pVUlepzWYo0MpHIbe5fVje3NBE5iNn3JrbJVNPbugEio +hZB/z8oBD44vZN/AX4yUzZfNbrLPnPcJeGkuIt4TTEUtbhsJtlDCKkOjmjnsmNQhFOHgKNjLS6L4 +Fhw8k+K3fqwhvSGukyHo1z99Izue5y/QiGg5w24k58//67wDrwcgMdgRfIcJRz6n1ZKV9xjk6h36 +iExgk2wl3/6Ff/6cfQvLPhz+cn5xNvYPP56Cak4ctNX4RZhn7MWvtWusf2TiCrrIq/x//vY345T1 +k1J4KFlEHoCU1d+NPPpshywyH445rG2xT2L1wNrAX3lfOOjMOibiasnEnyYnx57McWBVnY2gToDf +0cKoU4ZbGDX3rKWlIZANfBfOjf3kkid137j8WreGy69197dQiIdmJ2TObt0QTJTVAVEsiWqCBCDy +dVdc/FBccglmUYB9sjLj+K1BCudiDPLgo3gqacS3BblArVXsNjedxiHIQolPANezLdnqiQedItVq +skUG2M7/BJelXXkpq6gH5iMttfMHH1LqA6UDYIq9WiMwXwFmKrpF1icuNvXPq1qKvqtdgUoZP4Ma +6SN15Yer2aF1OfifygxVsJFgMsl3HWkA4Afc2qs1cLmda/06IH++V2APxNWyVdzo/Sp3wWp8LQrn +OwUNy1TebT9mqrMr8tRm5AdIgCB1bF8Om/1hkObIO9Kwlf/UF8G6L+5ZSY7C3fjvNVmJEPi97M4P +abnEFsj2FYe6A6l9rdad+y3uRvB58jnX9NtnNMYV/Zq7IH3FsnJZb8pD/HKGywS8+SlNH4QTB3Ny +zRhMnp77EHD9s/HR2Ukfc1PMwqm4In2mmNTvdTqEhCyUrWTi9xENU41UwGTiZvYJbC3GiSBRaMNa +/2uip137tXbpt343cm/+hMnQqNWLszXCbP3MySRuwzv59mQ0XBlnoWzqrtkglEc/CExLij9NOIdi +bQQK8B5StsOsyptbEXFrM82RBs5FDhnQUt7WJBxOE6hPBbaRwkf+WwLODz9BInoXBIaka52VfaJq +a9ntnWE2LgoiMsUEE5KenBhUoOpiUhRjQlXSOy4boFQjuWxifaby0ogNNAK7lsqe3W+KT2WP99pp +h931807Lf38Fbq2UZaJVHmyre7ndTGH/UNTFVztcbrbqmT+JMHhyZRdNbURRtIrpqutxR1N7Kbr1 +HlW7ftOpbdwqrfEaW5zOCsZm5Zdn6xp3JnsfxvgsOPq51QDaXm48kK1WkJ1MNbGtf5MC5q59BV9L +Y/OUtBeGYKh8ovYvH623zQr+cWWVvO7aCOQlFXYb/nch2NSa0z4xGuz/AcXrMoL/AfvMl235TA8P +orWl98DifVYEfExCeJx7wP2Ae4KZSHS5Q3+B/6Nfe6KO8/6qv79p0e7S4I1e01gB8V8PnPd7pco8 +Jsw8ifBy25fvuSlx+LPmDT94nJ1UzYrUQBDGgx7mARQPQhFEEshmT16y+IPugoKyg7MrwszA9iSd +nbhJd+zu7DrMxryCMk/ik/gCgkfvPoHVnc7PrH/gMJCu7uqqr776un7c/H7v4+lM0bzYTwVUkAie +g7MkglEpnb1RmhdcKFiDoJJn57RzYTymYUHUcugU8SyjkZoootLoiCwyKv1PyZvnaxgLjlYufVCr +gsILmqjDUu3TKCMCnTmzBxNeiohuGfHA6/O3zageJSWLtNXmcwXnKgSpRMpOfUjSjPaW0jBa04P1 +CPAakwriPmz4m1TwwPjCtt8a4sTYVIbgDAp1fFjyLKYCtwvBI01fl3xtMFkTKax8E1mapO0xXoxK +qXi+c06ykm6+XHtUa79qr4NcWBYRG6MXHamu17vkNF9QoT1+0wx3Oihm7mPiA3aaMkytGfThGZeq +WSNEzFY38U14QVUpGF6xGcJ2EeSkcN31kCeoPHjwcLjj+T14LKgajRSVynUYnqKqLGMQE0W0UVCh +UiprnZWkDNSSojxPqVJUAGExyGYpV/mCZ5pp12Tsu9vhHCbuWXFNA6yo3UbAQY7JgjgVPjhBsIv/ +4yBwvKZXjhTR7lsZ7S5SFqOS5O6Tko0b2EFUFI51s5UcLt5iFqsMPDEU0veFTr25vH6nBki4ALcB +O2UkR3k09fm2uDnwBKYm6tQpijTGKtvwY2ui53iwM/etu0qVkWTrf9Ta7YW63TNX5p7VukVoqfMC +xZ9ypjtw8K4kWUNa6xVwU6N1QErctT1v34x5Iy9NLEuP/umhEdZwYqEFd9e6+uqk9zhDivHmPoph +3GhhNbiPHSxzhqH/CAMaVU0acYQwvUIsPtWayIkxQlCixDfptQnalelYNarwa7UqKIl3OMtWNv5V +tcKS4CbjrTi1Tkt2xvgFA6Jw/ixKDISTKM2yGhKSZlu6LSWCB5QfVsPFCrVqx7K7NRd2lB03DduO +MY0CkbLHC4rveYBpxswl0Nhfm9VTE6s2xuUr3D7EimZsQWLj9AS/xw1o4zJjjymLZ8w0oBoMmn89 +sIkZuG5XD06AAda60aZF6Qyfx1/F9y/pGXF1sg9M8Z12BrqqfxHWf8jK6Vh1tKZ6SSUkk72mmu+w +xEJsPly/tfl64/b9FinyH/6qlq1WON4cg+ge/ARqk5gq/AkcMaQvpzXaexZzNXeRQBJqpUirWXic +myx8UXij6n6WmPyC1LzknMRy3eRMvZLU4hK9kmKG0hP3E5UN5QuumG7Z/dHi+Re5jBZrQwMDMxMT +BbjyotSc1MTiVLie1skqs86d1NRr/ifPEbA81f1FgnPT5rss/5lFDm2K04oo12x0yTbh2LGRLevI +/AsrJn/gUBFZmtv//t5e903lmq8arkWf2iDOktY7WYMzGwCfSUJi+ZwB2aS2jmSXao0N2NZmRly+ +zjvjOBl4nJ1Vz2sbRxQmpJDG0EPAbgo99DEUtIu1iuUGE5xKh7YJhYbSNKaX1NDp7pM08e7MZmbW +cmrEkkPuAf0VhR4CObfXHvs/9C/pm9mVvbIsS65A7O7bed/78b337e+nf7y98e7Nze9sap4WPBUD +EXMrlHwsUjTtDYCLL35EU6TWvTkma8ItHjx5Nnfi/eubL248ICu8bJpBGFC5jYSEgdIgyXiMUEjL +h0NMINGvQBfSTH+5vVkGIfT6SwMEecrlAddDtCYIw7Ajle1YdTDSahyEDyk1PMkxtsF1YNpgdYEE +RkCbHonVKcFY2JEqpp99uDX969ZHP62LN+CpQYLlw8dKBwMeWxNW+Evhx59ulamQxUl0snc/ygqT +sjawysJ1NrMdAjcQK2lsCKdU7roFP5c8w8NmDg7OIVkuJGoDI14SKVLNqCNivlcJdl4Y0DhAjTJG +5ls8OW/zpbPjgnzLj/EJyqEdBXtNXiSO4Rle7vg5eRrxGzr/r7D287XCWOmjQarG0Jv+udGZvtvq +lg3Q2Vvn+HVVUcCqMl5FFGn/Zwn1L0ETa5G7kPssXIVhMnWE270gihpoEEVGFd/oGIGu7hJFqrBu +XSLtV8SEq6Gpp/sw/eeTu2WsskxYmExWOrUkERIdE1sufWC7e53ubqfLWuQ4of+GRWMD5vZPY660 +ddS9LIRGQsW4sMRpzo0RcggxN2iAy+Qu5JQ1aiI/wTjlmg6ZI5FPf9jaLCsY6PlJa33p8E0h6AL+ +tsd2mT+cY9JjXUaDL9KC4Hpsh/XPj/dbsN2AcLHBDWSPuXTYvf5Fs8MkgLLGpgP3Zifq2wq3cW/6 +rYfLB7PSrqCqx6/BI0dpcOobgsk+dNuzSugeJp6L0slVUI3gSZaCGsBzXwdj7cWWnDVi52Ij5rKs +PKtMOnRJeYxB66yfrTbMHn69zRMi1zlMn25+XC4pijKbW2xRMcwrNaiYoj0ivV3Y30o1rmzWWYqs +nKvDyRNrqlrVGCFpnvMULQL1rtYXAxkBCjJ7offNW1TrK9OAbSgb7NW1rhXtmpGWclL6py+IkWYK +vrEGEkXaaSHjNh79/4iNXXIxGxNFQct1oi6b2MuWd4dda2bLS0G6qxSgWtoVm7x0Lxp4pe/JuaFb +78aVThd8qEzUWukr3ZeIVElQrFFSjTpXEvOQh+Hip3m95V2QZ/dFrgPdMW7Iq/SZl/z3/37w94P/ +AOH4T23/TyoJFy4001ejyt48RSFZSv+NUY4FeJyVU01rE0EYprWatvmopYUuVMp0FclKskEoKsYe +kpqWVGrRRHsoQSa7k2TqdnbdmY2tVSIeevIgDvTsQcSjkGMviiDeBL3qSTyp/8F3s0k/QrV1D7vs +O8/zvM/7Mc8vvZx5862nfyFzPT+bKxSbn3se9zYf9n3olbdCv5QEqhJGXCxsly8yax1Nowq2OJGZ +/q1j2BbyY/+rk6gL1FwZ4D23d2JJ2ydyIjwH3hYxBEeiRpBDGSMm4rbnGgRh16jROkGUmcQh8GIC +WHalBWVY+GeZbF4+HUrJzbA6C8kvI+F6BD1KtL5aehDBY9iMCyCsEvCqlj2WvE/Kd6lIAiEZ5OK6 +wK5efaCmB2Vt/HSIrDlgKi7fjp9q5O552IqDNR27glYwmF32xUr75B3XrlMTzE+jQF1vR3jcqFTb +0LZsB6tbtMw1XdhBiuXSQbAG4CgzLA+kDsMCFNwIaBS/Sgz4n3OxU9N0ZgtgZkl8T1e6iRVqBQlm +QAFTFlcLrdY0UvO4jguGSx0xY7skBV1LUTeVWSwWjBpZxbpJKup/ih6kWfaoJSjjqfaaENPPkZ0I +wjlWpYxAVRaGMwo911e4zVT5VSmFWrkRklsxffyAoSZa51paKgqSvwe3W2v6IpyQz5QJ+SkWbvib +sLsBu0PtDByGupTLXssX73QuRfcuBCzhrqONthkT9lqQI/Hk+/A5+TNsyoXIRfkkkpbbkTPyW+S8 +jETzshBdkq+jkzGEYHNzaySu+eXIL9G6nItpIb8u/5/HqsN7ywiiP2Jn5cDQlNwcU6qdzNphnqDa +TiTdLobABT9iRXJYGWvOD13pK+67j6pFmbeWxKvmhSnfp1oKprK8gXZwCWQJ+y8UOPFpcmPk5vGE +T5EnRid64fN9RNsJTE53S3PMOtr/sAMon9i8Mfou9Acmqax//wZZem7WtSqaALIdwKfIJFXkApyR +x3icAW8AkP/QAtACHjQwMDAwIGJ1bgDO2T4yvgDxbomhbcEmPNQ/4NgAyJEeMRTU2/WRH4JJ7cEA +nfgfWVW+ekVJS5FjNBSs3GdltHeevbSEjuX+6exfT72HNJGrbxQjRRzsi2vvG3mNnir2ZC8yMejr +nJMuASLrbTPH8hwAfG/gwPS25oZRw+YMhfrRo+OQanicAcIBPf7iEuISkL8UMLsoZ0FMaCdLK0OG +56XarOvBHY6R01IULHrXSuxJiED6Ssj9tgleyGpzcxmzOQHWARSp/IBEpY3AFngQSrIWz1X7EUcr +u5MjAzgUkXufQ4ZqXaGLq0QwgVnpqqUb4xOTbwMnFOJHRs/ksmPyUxwblF1L+pnEEeYck6oDLxQf +UKxkTSfaG8V5KC2bOZ0pc4v+fZPtA8IUVIu9zCJpKRrElylEFtpnSrDWDcWTwwQtMrtJtVyYPoZg +lg3FYMWDbsfFNKzwNDAwMDAgbmV0AIJv/yok9YBVFTKyKmAUycS++rcukyIFcRRfdyo5qczUM/m2 +zGk5MZRYDw6c5pOnBS0Ug9XdBO0BqyeqXbIXo2mitdNlskGz6AUPATT2GEZ3Ok/l9am2xUqYErMH +VCpeMjQwMDAwIHNwYXduAGAPXMi4gow73ie8CMTMe362CPG0kysHmjOx+5Owjp4Vs/XtkSA6c04W +RWGp5zQwMDAwIHRlc3QA5868exlrz9U+4Nrd3RkiVnbo+R6T+AdVFHJAiC3LM29IDbi6tdlf3GGC +PG6tk2EIKRR6j4NOLDCyBSu9aUuClnc/r5IIAZOeCMRNScha+wHhLa4aPqlg4n2ZNT9WPHADVy2O +HnicARsA5P++Ab4BkKoUCtczrcdp852BqGxuknSTpZ9oaui08A3o+wNJH4YPKBiOCQicItlKhH04 +HprH83icATsAxP/aOdo5sLQOFDCQykFYjCyQ82eJhikKX9W0x6vNs8gO4gsU0AhJj5FU7p9n3iv0 +VDcFbVYafu6zvhocAlHvG236AZdjzh9e0HM0KAw2kLsusU8XW6kIeJw78Jv72G/uDceEJ691k2y+ +Kdx+U5hx+01hpucvAbf1DROlA3icMzQwMDMxUcjMLcgvKtFNLCkpykwqLUkt1gPiEr2SYoaG2O7M +21eSjtwp8fvr/5650URlBx8ADmYVg/wFQHNTBpVEXuykl4pjz3FrObxVygp4nGuYwbR1BtOGBDUu +HYXUioLU5JLUlMkJaoosOgrVtZMb1aZAGDWaKmJAhkJ8fGqxb35KaU6qlUJJUWmqAkiN6GY/9TZG +Hj09PZgJOpsva+gmAwClEx88/gH6aWwm3tmR1qfKrnJUMjejwmLLGHicAR4A4f+9A70DkN8UWr8d +vPSy8AZd4NlekzkDV7fW9H+R88rsBhB69gGOBunT1twRtxEBCl2MCf8aU/uW/3ica9nJ0rWTZYNY +w+SEo2yT539l3yzbkD4HAHJACg77A47JHvPmNdUVsYOyITdVvwt6iChxeJwBOwDE/58MnwywGwEU +/vZwZ4MX2UZEyvWEpAqj6BQP7H6zLwFeARSYKLKsvwsswrnf4f+RqbSaiHudgbOhAn4DKS8cLPYD +adv9y5hXirsRnS2hO29dNpVz8Ld4nAE2AMn/5gPmA5CRFGyoESEpnOohNL5B/jQdOk3CdzpTkBSx +uRkBFAfFiNaTNc/rNeEBwvYPf58ZhqNQa6IXY/eHArD276Ev9C3TQ1HZ60PAP9esQN63eJyNV89v +HNUd1+wSp0mIccBeJ0DSl2mUzNSj8ToGgtY1yKRgJUriljgUabWx386+3RmYnVnPe5u145ot4sCp +EtUqPKFeqOBUKRIHJA4BiTugRuKCKALEH0BvPfTSft+PmZ21DaoPnjdv3vf39/N5333zh6Pv/Xn8 +gwvGpIOibrtOkpXmb19Yvhi3O0FI3njK+Ogpw/A+77cS3PEpoj5OCGI+QZ460YBFg6C4iTACoXYc +Xb6O2nGjGxLTQZaNFp9B24cRYoQyyxSCoD0VpiDU7EYeC+JIqBCflSyKI4+ARzGTK/SLZpwggj2f +z/29cHrw1tT0VT9mrvcKNStoHfSrv5Aw5OEwpGgRlRey7cwGyFiRjbbVoZmZBSlBu21+rVN4lN+7 +WjxkwxuaWURWhG6iwEZn0YUFlBDWTSJxcAHtpGo5MopTpZg5SltFRytfOF4zZvnidPHQoWpNH+Cn +lorH+X//bRwxnuaPRcUT/P6mcWrw3WsHLiqFKsdup0t9S67tYQgIchZRBq77OYte3I0Y2oFoLb60 +ZZyrp0mxbbdBmrgbsrwKkURLRBzJ/MDjN+h8Gf5gOTNj6/SMGBV2lEfSlmXzOAbPP1kpTo/JjzZ/ +67ZhDb46/DC//bJxjL/2n8IR/uCx4vjvtRoS3aqA28/duLZ2+frFtYR04oQNW2w1aBOIxJyDdknP +dCm5CGXvJgmJ2OVLq/C5bKId/i41pvqUNeIus10WP0esy9dXrrmUJUHUCppb1lKS4C3radttBmFo +ydBsWwc0O4tWRCu1Y+jgnk8i2W6UQF4bKvWojV+FnhTbaceco8gLY9oFkVs4CXA9rMGJKEZhHLVI +ooqCI0ZdaYNsdojHLHCRJInbxszzrdmbKx0WtIPbgBVI8K9mW237WTckUYv5Koo/BMwPImvOQfP8 +X75RvgbHFKwSghvKoVYY13FIHfmiXRH4Ad+HqKEpiFQ4AUNJN6L83T8axwcTrZP9BumkkAFPoQzU +ZbgFvWDCFyFrohm0urS8sO7o4pnSgz04U70ohBbBx41ukBDLdGdT/bkWUidZLE72TfHMmRnFrezl +Edx6IaYUrUJyWtBB4KolsKvBaDK5n1MHQNjZi3kRgQI9P/SlcdbfVpYk+DEVFqsg7AgfHRGSSAkw +D+kpw5btSsM195UYimQLK9oDKT6DTEc4IJXm2AHxjbeNR8aEdejcv9w2TvZlLoEmrKiiuVYShmpf +u1oTrtRU9CptUidND+9zQDFGBV2V5V8Wb5dkQ3pk5LQEPndqhYcee2IBBQLr24f3kA4/dqBQ4j+i +wvgTS8uAuZaIKxBZtbOKqn6QhGDhHg5SH6pBjb9+r1Dq626xhwzkCplMgYpJaShnuwDOSwqQ4nqo +k2asr5mIbGoTAK6ApkBDqBErX8Cw9WQ509QHaAOrQJKVIfgs2FycALKbK5fXgBPQ2bPo9N7bjlqp +xjTenTyqf1qgDAISyctJn2BGklUfR1l0ENsqRBJDOAkViAQXMUM9TIeXqCiQ5J0goWyES3S+aBh4 +xJqTdp7f6OLQqkJMDkr/1bQxPtYyxvviQhA8l++zkQK2ccey1hxxwUEHrrfObAc7jkanetGMoL+k +UFOvZ7ZHsytM2Tvr2gWy2ZeeDy1JEIAdCcUnJSdnYagwid5fyIeuFLD4RXILMgdH7L3a5vbTNQHb +I3KDI1OmjTVLOkiTn5Nyl6RRSTaSQnntm8JJQZj85feNo/MjLBX9DEPtwj7/6xvGRFN+czLT2qID +F0/YrEDNA5r5s8SuxLhRGboHtxiJcBvKuLaWroGjgiTd1EtNMPMdzHzwTxIVfHKQCVzASJ6T87wh +CILff9AoGc4AHywVbPko2SMUU8UOqsPAMfjUL/G73xpHJjDdijyNSSiDnDwemRa2h5hPK4n5d/cK +J4w6v/uZcaYPatwg8oBMc20876DzDppLG1hSlTL9KtkSPVc1ZQ5hPjCzwdLUeRRLkUnxBM1mbUhs +KWqByK8TZlVxtQ8KYRirV9XTk09whcLdrOeJ+RHg53wJNK1Kh3RK9hpLT7nCJ60y2yP9fJkz6tst +qmJ0dRPsUvKTUuktrMuwr1A/lapmYsOuyrZ0T+VLJJTKvqvl0rMD62ywx9kEBVMLbgIFajoDKvaA +DFvAcclDMIxoUu+B3Obgbx/OjME9DhTP1z8tnBjM3hibN+OImAvrUv2wC/d2tpDSjT342n70l8L8 +vhehPWzSB4Qa/g9ulA7/HAKyR43/6WFjkp+6URgbD6Fmlr7ryrVB+Z9TB2RaBo/fOHHQZL0YnObP +/Lr4+IX8yayt9RzkBwlwF1I3Z/7g+V0q53QeRsSbcTeRedgrP1/jG0eNyect29EzrVhJe2KhJEeB +Jy2ITILvw4fYHMQfT83rH2JM3FXMT6Bk6mbVhqGg4kGhcbKLWv444/dfKh6f9ZO4R3cPm/peX1TT +WtBE1gtLl664Udzj379vTJ5O4nY6zMGclUqpdpJC/NjdQumgbgZ+844xfSWfH6ENPmzDgN4Dbk26 +wIz7056JRax18Q9IQ14rQv3rpcK5shgGpabc4KOBk9XfDdrCOQk3btwxJl9qCudxSrOqQL+DvYAS +F34nAQUxuOit6r4q7LRN0nyAj00Y98lg4+upftpKIxJDqs0quq0Hp4qKTOZNrjMw5dSL7OwX2/nd +ZhJ+4I4x8ayMz/u/49ulpsa/rxSdN9/5wvjonS8K0Xv/A4EVIkf6A1PQe5KsOZ3nSjiReF/zQFc2 +FRqteJwBOgDF/4EMgQywnQIU2I4/p2I33idE8EbOAyp1cxsHzvGzsQKPAhQuz0X84BXZ+xN0VwrP +Uq7X070HqpNUBa3Z9xog+YsCKfk++yc9J+9viEElI7V62w7Dy414nO1XS2/cVBRWoVRoVKmLloiq +D07c0tjUdcMq0QxD1KapKKraqkGwqKLWsc9kTBxf177OJBqNzJpNJfwH2CCxQvQHAIIfwBoJNoWf +wAKJFec+7LHnoYIE6oZu6tzHOd937nce8+lnR37/9sjXrVtRi2PKTeOD25twI4tDPADv0AsxBY+F +IXoc3B7HBFLuJjyLYdAPQgQXEuRuEKEPLAl2ggh2EeMUAp7CIHHjmG64YbCPhg1uehh5YFrQfReG +xdOz3xxlkYfFtXMnP8R9jHhqWJ0W6H8ei1IOHiZkqAsXh+9v3r3jpDwJop2gd2jyMF2nPWs0eYNn +SUQXpJfiq9XVXHntZZHHAxbBnruL99wgMRVuC4aVAYAQyWUYEJbNwEcbUkz2MRHfndop5SilVXIU +IzEkQhEOdNjMukXIiX7IBu+5Ye9ujFEbeJKhXT9BEXR9wjscNZcHScDR9PpZtGsDRh7zibsNHtnb +dr1duiCdm5YTZ2lfHbQ61b5J32TxJYDi86VTFtSIEWyB3lRPMSYpw188PL5werw7vqV2Xft0MAAK +v0NC2WTeLnJzbMEmUEG6Kf/WVMFxHPmM9qxIwMiaDq3ySSiLRVhojREUXTjz1t8xowAVx68ax9Rt +8Xnn6lXYOMDEC1IsNS0U4WdCVKWuO8D7SAdCRoFMaTUIQ61x2Ga8D6nknDrFTysXcnfgBhyEjE3l +yAYjRS9LcJ1FETkwGrjUcSFRs7FO9oVshzBAd7cttfQRfd3HnjbrPOy7kR+iZes0a0tMOYFaqz8s +3c0Iby0rRtWXEHeVrF2NpUoHEcWp9PMTRhk843SPYkPHi1+XzxU/rrTyJjO4nkXOjqdt1iAoqyWI +a6IukO3FxXLFEfwdHxMiPg/Muno5iWqxXJtzsbKra1NXhme8X0ddPFs+L7i88RwuxfevXLg3bJKw +p8DZdCBEN60ttWE2T9KuVcTHfii+a7eKM6+eyhumjbbMImPSQbk+5UZtjJZkGPAgpkUTDwK+zmRF +4+Q1sRzOrqO5TGdE4rR6LAFTRxlzqrLs8DrSIql4j0qaTBPWgwfy2W2ZcVuqcsqe8ciFetcY31FM +VDdgg0j0gsinAkH13MfZbtbgHYPIJ2W70ecMkrbho4hIInoNZZwxejTRU0R9enbxzeKTm6++LL6f +XF6g/4wr1HzEn3+e5S+i41CREpXb/M9bjS6M+YtqNdpY8cXSif/bjfFv9QYplCo/pt0KpI58QCHC +8RvmU4+oU6ROv0q7LvDDGCnHy9eHbrcLRilig/Ky2mlXNjsT4pKpIAJEG3m1PpqhaOQ8lCX8wdY0 +JUXHNA5oaKRqxRKlG3lFKVCurjkECGFtTVZ1qxG1oJeDqSnVaC42SFnU6xM2kAm1ISyahhfEfVIP +HvCKJAzcFCImFmIiSBV2hoZEQRftZdy5c63TqnU34YE5twaOrKl3UjJlqQyZlJQyTpKSy01IMo6e +8K09mBPbSmvKYH1nVPtuzCR2LYh29Xqj4pfV19/mYnSS6lNmq3o3u892WsXPK+dzzUnH+D5jXE4C +0tScbt7sy2Kao2ZC01oZcfnT44r8tQEfs23YlnGVLUrIVpx8nGEm2scgpxbjVJaV1zHFutfJvakh +goDcRpd8CgeVaIJonyZIeUHjKEdOkZSDTsD7LKNZKIuiCXC39vbQD4TTCeb3ErZHs6tTHDl2MhcK +WpwvIbh0SSMv8ybEaIfGV5EBy7OEX+vaboVZNO4KT11kxW8rC/oNFex//oL1AOrppXS7x/yMflwm +eIXKZnIInIG7zwJfDxQ6YKaeKQSXbKcv+NKliIJOj5HGYnBPQyZG9acrS8WXq5d1jxlOzHQJpizc +R9nFrGrGC4cNddo1nnb5lnKomyZcZUi7+QbSvKb9qOyXW3I2OdF+rTDaC8UfN5+cU2EdNhxSVyOY +WciLZcPIq8FOrYlxbuNx5obVPFBH3pwDasjryxXgB/MHM2Nj/dqd9Y3bG/kNQ//S2FL3y3YoRTnH +gFViHtPSY2jtp8fz51Xh7CiNra2/AKZ1SAn8AWdawlom6bKU0XKN+4a/rd97XZeIeJwBHADj//YD +9gOw4gEUStmu6Vf42Nm8hRqzX1aWk0lp1EfdYg8N+vsFnN3xtOO/FmXPI7aV4wnO0AV03ER4nNVa +a2wc13XGjGWKXInUgw+JEiVeDilxR9pdPiRb8jIUJVmW6lhv2Wksci0Od2fJkXZn1zOzohh6sVaL +2rVkJ04n8UUcPyQkatMGbZWordsCRmwDBeo2du0idps4keEfTdMfCfSjRQAXRXvuax67S4qQ86cC +tNy999xzzz2P75x7Zt762xVv/sPK689JxzR7zkyjbMlMO0bBRPqFop52judK04Z50LjglCz9WMkp +lpxoxrCSyHYsw5yOcTI9c8rJFEqOGFfRvPt4cZd7bm61+9pUx92wJBbBPVuk9W7+xb/EA7rU1BJe +ibV/ljdLZfdQunsTEWTGKpiFkp2bQ7mClkGaWXBmdAs9cMo9MbthZbpg2g4y8sWC5eBf/lDuPDg0 +OIjKMRQ9E0OGikb3oEk2i7YhzUbFvnmjjLJWIY8Us5DRk0XNmVFGJtWRCEKM2XktV9Ipr+5aXnR9 +wtaLZIW75k82b7d03XQszXTilm4XciWiMyWG5oEfQgqZm0vkz9pKEvXj4lW5vZLRi3RghIuN5tEU +EjIlBujxOAFohhAE5EKjSEPb0dRIf4xtILglYa8gtQaUQyMKp/KZJitVhFNAOOwRmroNluAcJ+Gw +VEQ7cbZgmFFlwlTU8oRZK5YNTMb75tl3ThwD2tTIJGec1wyTsnV/ORvBrz8iN6G0pWuOflJ/vGRY +OgpZJV/IlHL4/S/IrW7k5e7Ps50sTjkaXhllMibyuqMlSlaOmpL8y+kOYuc5rJvTzgwsHHR7Xt66 +ttZg+P2fS9vcW3/Yvhz0OTGRyOPENblrZ9VqLkAUrBTQk5rgx85ROrz3OWmTG/m4I+LZRnW/9+QG +t/jpuq/vkRrx5pNSowosfNfgHMCuSlKBz+C27k+/sX5g4RA8RaOMRKIaQ8qOJHjshOnuTa/fk9Fz ++jRoKYP8Y8LXLPyaAXtpsMssBBVTZQYBB9iiYM0hw8zoF9w3d7e6ebOr4rGJ03Hfs6d1U7fIxICt +gybSzMWZa9gJ4awKmVQ8b2VnTgf91U6ABBkgNbW8TmJMaJn8ViOME/FP9+PZ9cRxlvdotq2D/wX8 +hY0MEMxJO8oIvnJZutfdnVHco99uqHhhdjuH0xXhOnfmcEyKBFBpuajnLCcSA3V0xW0e4xpSwztT +PYU9zledCk7c154DfnHPavG8np/SLeLHHe7PlkXc93pQw2Omfl633H0XuttKpkBZVDAPA5DCju7x +Q6hl1jIc/aCR008B1kbdYmbdsC8tNXmCbBmrY1ruOmDdrw9J7Z1MQGJMIq7HBMQFF64s1YU5U4I0 +I5Ey/I8YoFEtPRMdVzgYgQ9SOCF/Z41cJq1ZGSWlRpVFXL5CfJ6oDG2xAVYd3bTJZFozM0YGhglT +lvfsGa1I/XDeywh+bIyK6dFRLgMaYx50hnmQPUDtUtTS57RpXUFJHigVpimPpaNZ0wBPowRjPfbl +AarbRN98YBfvhGQnMAVhCTooT/rMiJcAZCwgHRUoGZAoQCQ0Suh6CSFl30v2ZLIoLMtt8mHAU54P +BXj6gNztvvfpch5qdhKCjfNLoqAz8AOepTZk22yrJtmmQM6ljMsq+zseVhI/CnApmJOpJPr8qWNH +E7TcwF2zckslZIEYIoqgW3h7L8RYBCdheudI1rMAlP2/R7K+3Lyv6mkjO0finOQrPz4ggwUgrvxZ +Qa6FmtLzuN8AunXs7qs+BAtFEPb2GLc1gHE1fHgUAqPPCHjZgoWiTEVgTB0Vsmhc4UoiccOMpqRI +PUvJVBqIgJPwK12yLJAy+uCkj4a2ozlGGvXNE3bgLADrpADIgl4g28O3oqWfN1iRnTdsG6TzbTrp +nuhsw6mK3NXvgwCn8vOPBwYBOGi6PRyQMWpuAgecaTUNH6ZkAhl8bKgKxX7m/glqSPc/vtXSxPZV +R/rdnjdb/RIFRGJGFsHD6IDso9nN+NUz0vLdtw1OLgDyC/n8OdAIbn5HSuBffSg1keK1Epheetje +aeB6oevAvWnWjkbVuwCI3BP/2bajjtbB/0Aosj1Sjhw78MjhB84cPfbwmYPHHjl6gKAknrskj21c +xOzuG++uJwGJ8QWp2f39tesbHqN6xIPX5A04dlnujFCVeMXFikBdgPf+i4RwcZ+0DP/xO9JqMj1Y +X8jauOTGUvGTvyffh6+skpsqzL1ZXhPRAnmtvz689EOi69dmNUPcHqPhkry/XKNShobkFgoAJ4CN +e1cEnQ0TF85F01ouZ6M9aHAR6wSzhB8Bt7GLe+vI+rvpxvjiXdLmJUMNWcJwhsQPIA1CAayhDkaK +Ioo3BfMkqaHOU8TRso5uxal2yE+GsfGCmZsjKDQegqFqIArgUDUA8Rwt4kNcRfrmhSjlSfz+30sd ++KleqavPd0NOGCcAFgCeEPSIqOPgY8PiNKsuKLxMWXACD3n82QRL6IkBG1RqZI10FewEgQf289lU +VQwV6qV02qsZ7uwG5JcNVTzq3fo5I82OkVJW8IuG/JxyDbF1fzbbhb+ckJu6bwN5uHBQ7sDXP5RW +4tZ3pCj+0kF5BcE4fOGg3BxdKrq545lYJaTfQIAI4KOZ+2FRJbNACWdzlrfrgYPgTQAiyJk0BFhQ +juIvX5JX4pH9stJR369wolfeQKBtxF9vZFFt2he+qpYZ9ASDA3/VkNvwWFS+2/2op72ZFizxvOak +4TaCH31G2ry6unLBFzV5HV77T3Ir/rNeuYGtBVxtfsxz0omJATx0Te7E1wlB4jLQ33xbbrxvCZKJ +kFaD6o2+sEVu7wthnH7BsB07oGVAD8cq4atb5Tb3zOQG/Iwpr8Cv7JZX4XhUXo3/R5U3VpjdGDyC +FRaC48Xz2J2jdKUaqOsdIqvlbD3kE7ezac9imgtyqoR3Z0LzZMEuxT7M5HQty6/VvrOGxArxoj4b +C+BiraehsQgaBGUNEVzHg2fljiaP8wvTELSlPmnVvqUmCrFSJAuWLuDzxjPSX0/h65elrXAnOd0Z +DFgePEwz7qpXNvTxkUQwwBntOZoARtF82X0+88NWXt7D7dkW9za3VT+0SsQjH2NFxXffkVoGQ5t5 +EFDVKA0U73jsOWlzc1jE7z25yR3TN+aimTmARCP9BPfSjPjC+oPn9SfEX+KlapwI3zdA+sLAxxad +Av8fPdw4mUuQ5nKK4DH5QcZpc7DB8QS4MaYfv2tN4PzH6VHdqzOJe+toRRG4HchBSGjeWxqrVtyN +2ZkRuRkhftCHQBB370wXfui35cgLR6H8evs+uaWZz9LzKURhHUl2FCU0kwq6aTkkCNcb5W+e7XCf +/p0W/NI1ualFaDbAez/nHZ66PXMeiME9tvKpBLdTVKky4MLbhikW3b1m2037S6bYkqKMEmTmam+1 +Emu37/J2XNpOxMlCGjyRkttWKGQ4cI5uztUfDrO88Udnm+WRGsciBSUom5bvEBhs35D/EAoycOM7 +uVGpEvIZmBGewK+gbH3A7EkP6+MEtMIEAdMF6CxRZkaq9Aw0O9g+cXKB1fOA+5xK6CgpLsMBCveT +/O5DXE7kATcwTuvGedr4zuiktM7wjKJbiIQpmjWcmULJQY+cPIzsUjZrXNBt0gXHl74iRZazUgrh +prLctYN0y+xCyUrrqDcH2cDScjQdkd4ZHx8LTQAk9zwj91Ug+5PaIg6Zzqtbx8kIYZ9KoskQjokJ +2DeYJom0CzwailanStbySmtFAvVKC8BHRs9qpZxDnsvgZ/NSJ30UQ2u4A03yOld9eSV+/lGpsVko +J062w9K70gZc+FO50b31buvaiQnBkuFgdB63XJa71tq6biaKJXsmKlbj68ugYrj5cVM36ybGaE1q +Ay5RP2NMMlBf471/DpXS2z+CmutWz5pGMYNPmHKn23xxlbxz2O252KWWy1WpBFQJByehSAR9uEDK +QzAh7fV01SR2oVIV7rbv/Vpar4YUBrwSM5aeJW2sscdLujXXm7W0aepWpP3jvvHp6i8wZSdR+B4o +DnyEFXdJRHWR14pRbps9wkiQuflSTxhEW0aH7yauknJPnOtyf+vFf9/eP68wpSV3DseUqg2U5DgU +ZHqqPGHC7QLvS0ltrvnNLRXeKgcVjSus7aPQ0k1PxcJjtBLigzxawpT+oCANNJyifklEmkdQq9DQ +Kh2EGAKzsdYSmMGmF8wttriMoahAnySMql7TPUogLIbEJL74Fak1FHND9WLOWSDkHJu3rStaiQm0 +eNgptcGURGaJPFAhT1F3eU9Hs4ZlO4T97dbsZE9Ud5JFNsCNmVnSqh1klR+WotAizd+V+Lu7pKa1 +9R393sUcXV3Qp/HnmuC2LEJ+TY2ywmG/nOl5wH210I5/UJaaGmK01nG/erP1Hj/05ymcsilUrlNr +CyOD0396c+sAXZnjj1ghOKilPUVT+3oKVBlQtG+sRgH/IXQKH9subbqf95Eg+UF9rFMQjnnPLMmo +M1ugoyk1UL7xSrZgQuJ08PHXpPYKOYa4QPHgCZxobKF2Yj/ou8okTH0qTPSP9Ad4JBcoXymYP+iB +0+IcvQt9v6/w2ub3TuoSMXFCO2Ad/gybmjCcRsjCZtY04JvgV96SYqf5ieFiQkwYQDzYNU/bDvOo +YBlw1dBySUQGqedSVTLJmZPwOe4vdcHw51IEX/ya3L2T7Zj0gAIMMA7oCJGTAj2OD+2KQbim/HKK +yISHPpTW3TWMyu4nXe0VXyKCdcHCi8lCxQham7hjTZGBFqqFWD2n+l1qEndwjWIDtoMPpaQWgtQ5 +8VDTQ2QPcVNqNIICl044bTEHGZMAbBW+epVKFc7S/Ri00hCVXtpaEVEdF8qLs8XB1j2zS93WknDL ++XJV8cEycNVF3u9XKey2k7j/N8DU/eT1NvzNvBRZAB7d65eWUVAkDTzvKGPC5j7yxapZM5AMg4r3 +jNbUZxHnyg+T/4OnNiTD1J4lAISUMQCdXgpixLBjADa9DMXITyUVBt5WvyKvD71tDWQ46SHvGjz5 +r9KKFh9zaY3GS63GPi73dk+k8SDGxtFQisPoumoY5c+w8cWX5HXD5Nk/eWVmhL0Rgj6HdvCv27fX +giaRkNz67wlgLHk2yNZCELCGTfXzjc+CtTHqJXcEuMHjkvs5xbvK0pB2gdqbP3hiKFzPmTkB8eP6 +ID0CKE3UWBefuWmYvUP4TJaoFJIr8yhj2I5hkvKKOO0p3YmKhQSZxYH3hKQFWLeNLzF1ArYGF/AV +MWZGNbCSngkMFXS2+5i3UdqUWpMXGPrvQVVZgCA+vvhF+TD+wbNyg/uLp5pvHH51hbQf6l9xGiW5 +I6YQ6XjZG/M+UjHyaNmsHSeFMe5JSMOnYxH+FkngoUTd8pVWR0gD/Bc4gYwMfBoOeSkKUBiuJGaw +uOUvSW1FHrQKev/dCKph939/3O7eKjRuWyLOicvZ5iBRAIXYtQ5AqJ08JV9Tsz19nQ1feVbqWCt6 +jvHxoeEUebOtgB//kdzuPtnTfARRUyRR4N4T9YyjeCuHYBF7/SQAayQDBnFNdQemt+Irz0mRCgED +i76OEr6OVjGswh7GZ+FFw/UWadMaWCa8Zk3NTvzu1lnxo4MVmCx2SYuX15gMV3yMghStZ8LURDd0 +22pigbZJcrcg9KDWmGAM31OJe0L3wWDXkJ2mqFk27Z0LU7NqiwD7EJtL2LpmpWfAUPz3jGbPjAQq +D7/wqL1R4p/+m7TqVBAjaLh4p2S/AsdYJI2lgqWNuH5uxHJZ3nIqXLykNdMv1zTyOjHdfhppU/Qd +LR0dP3bqwS/6TRikIX6RQ1Na+pydgyPi178l7XCv/Hck7g0FyxbNcoyslnYmJqxCwRkQ+T7hSj9p +hbhr6hYjingfFQX7YB6duybTin+9Vm5pFAvcj852Di/E3k9o4umb4AjLNq702AMdfj8tDXd7hpoq +mQ9c0KPBR4lxXcGvvih14Cd0GbmbbjaujwtV+Ydm3ZhErxzDz+9n17IDvnRcPtqSUXkFziK8zssq +QjpIuIC/v1LlbTh5VoaK5GmppbeGXpyZ3ieZW0rTcpuUwp88K/8d3vuQFHGP7G/Fe6bl5e7xXEOD +mnAK+3X8XhSKkkf3b5JjkRsN5pP33284pE/qQPzQmvUcf2EH3K5IYZHUsVOapbNGkdeVo47D25lu +z/dj+I3vyMvcY/9FX6dd7r5xKxIhqxJGflpRSbzT12zdH39/xRHR8vKgQ0CLvyDhzOhmIDsScxYg +yeUK03xUMMFXkYTcwX/sdo//TWQV4TBhep/u4F8N3/j2X1xCDw4MoJP6NFiPJBT6KAfktlGhCCBl +jiDYjh0eQlGbyrHKvhAHnThaDtx+DvHtEvjqNWnDSj4xSqjwvp9I3b97+oOnT38gvXb6A/kXy/8P +GLngu/YJCWRsyMT8LPaWwg56TiIdpRV/v0B4nJsm+192QwRLWHpOfpJucmJxarFeSTHDjlVmDEYm +260czjw2rzOy4Vp86DivoYGBmYmJQmZuQX5RiW5uakmiLkiTXklqcQlIT9uyv+HxDMxaL9f5bil9 +sb1l4pcDGye7snwSeR27YLO3epWl3FvldYyt257aKiyt3+zNysoukvfuQYY0N6vMjasC2TuZ7lTM +fv3bcHMKjxETAJMrPZ36MvxgO1RoajienI+Std9dDl1mGJVOeJyFUsGK1EAQBfc2IJ48eXkEZRMJ +PeyIHjYqqHgQBGFhT8Ng2kyNyZJ0j+nK7CxDmI/YiwfBX1C/w7PfY3XPREZY8ZTO66rX79WrH5+P +fn09+jb5uR2Nx3iBfK5Zn+Y4P3uLUjsYi0VVE4xuKIWz0IhUhMqAS0Jj511Nxw5Ma0blzDEH3LFu +GXYBbSA3ZFxljRoxOVakizKejoBppGG65gO1UYr8+vvtuy9P1OMsTyGfWbqvaMhXQBcFOecLq2Zp +hXypucSitQ0iY+d06v+jDJ7mqT8rR0tVk/nIZaAcCA32BF5d8HZAukF3Pf1y705LztYrmssUkn5H ++qRra090cPVHY3DPpWaQmTs/HHXhrBlsPTrJIMPVATzUclNjsXPp+yZDn2D/a+M1D23vhjbB/nJu +JZoWIWCfr6+ndfD9cD/JcOfZxxd6pV3RVktOPed2IslE3v8kZDNLYtGxo9otAS4rCUQwy17QA+9C +uytTIH6fBsUpVrruKMGz59iIpIVtERfWOIbM1ucxzW8UcH/DW4F6ef1fBWQKWYLzszevrCRpyHDs +i5I+nyXhMcgeLqngeAOlVKwvdcX7TYjl9SRBnyi2rz91upaaoFSgTFr7UZ/cyka/ARqNA5n0zQEt +mMjq+QJ2a23F2kPZFn8Tvo3nA3icjVZNbBtFFNYK1B83DUpDfkia9mVbyLp21kkapTSu06qHip82 +CEIpUhroxh7H29g7Zmddx7KC1SNSOdCRWCkqtBy4FbWFG5EQcEOICgTtiQO9VBVSCzdOCN7M/nid +WAUfdtfzZt587+d7793+csv1B1tu3lp3+y4qOxuGBcYio8WKQ4CVSdbMm8TGJVpxwGBQpNaSeBtQ +NpwCLFbyeWKrSdDikJmBegwgSy3mQNEsmQ5kwGRnTCtHqwyOwsGJQ1OH4AAchASMwzTKTppWZQUl +k2OHp3BhfGyiMZlGHakUvF4geIVNLAdypk2yDrVrQFZM5rAkMAoOym2CQC8gvCVKGFALHApGuUys +HBAjW8DtDrGY6QnEAYneMkpED4GGNjJEey7WAAgkNqXSglKZ2o5eIo6hIxLEbpN3KghJUy2aI9PC +D2pcZ6QskLdVO7/gifLUBq1I0DvEWkLvZWB/XTpqFUZhfCqN6w0pOBKRJGAy7R9IJOLSxaEu/y4M +grkCNA/zKoZC1c8z+Sr57yyT75S60DwOEYR6ucIKmjQ30YDjMqS6USzSrOYDHZXO0MN/3o3+f1Sd +RQc4dM6xTWsJMyHhb4in/dtWY8HzXDqGT9PRVJOBhTfmacXKITyD1awsaHz9KrhQUbYPiliNBqk4 +GqLFrXV+9c5QYn+9acFqaJXnEUzWLC0R4fv6ajrGh9e6TzeTGR3VPBp1SXC8atTk0YgAQD1esXQ/ +4+YQqxZXp4HfeNDr6l3KjhHhoHiy9YSfKMEpcYK/MDM80H6bFA/OPHN0g9hLQHmdxzJ/IbSh5drV +NN+z1qvPow3JgCALwuRXFs8ji3QklG0Spgkb44Hx/OL9fr6+FpsKkaZbMEDoUaEX46sGqnPqAmT4 +8JVu/ubD/vG2O1V8El2wLvI3i9QJTu79qIMvvxfj37/Qu9dHuUxqTAs0xfXz1LQ09exZy/0zrfTy +jhen+exXv7qpPmWH+9sVZdvT08CcHO7XWbkokuuspcb5N5/u5TeObXV/1JRtQ/OhQZsDCe7LdWUf +v/1o63Pt4waveV+nCGPGEgF+7/e+Pa2xa7elsyV+zVuekutqELYF9+Ix5flJnxRYgEWMalBGox0s +W4YDAvFixSzmUEtO1DrJHCys/NbVA5IuQ610kRpGpYaAMI3HEaaOjM1mEXoSa+QSg1VMf6NqmNGr +6x4uqZRNRyiURJA2rU5D3igyAquR5PG0I9oTtIE8R62RspM3iw6xm3mMuR3JOoFDZxh/Db9E2uML +q7Dn3UwmAyOnaK5SJLNCudDtRQsrEKgjogSFahMwooLWH/FqfCTCmcvX+/TQesvXFtQ6cVEEsrfK +x2/OtiTgSJBn2zs8Hzh2hWC2/nRSmZprU++gWiAWroJXpfI2LfmNS8A3gg6jhw2MATLCywUR6DDs +SRn2cJuItW+XGnbNFMXWZ2NT4HB/39xm1fOqLjjZUveD7oO1fUWNI1HbQJqXjWbBK6+plvKKolTJ +ZAytkR0oFYIJepCoOArw4Zlu/ssHu/jfl7btCDUkgf9zp4e/8XCA/3Wpsz+y7pWRpFc/+KuX+vnp +u92bykEzGv0hjA305F0/dA9EYG0W97g/n1Qmn0Co7jVH6Xkr5nE5GkRiCseGsRTcjcwq1QLFRECO +khX0kzcumd4AhYcwlJYcSbwJiuvfHe6RsWx6yoslv3ZnN3/7xpZGHUrLKBQVKwlV23TICbMoC5hk +a+tQkmfqJhZuaIqB8LFDiRrgVxt+7gezCBxpGV7ajSiSxSQ6v7WbpnAuwaevPHKyWkDzQAsON2p6 +eLH3Ed/QoJvXJDK+1pacPoUR0EvYSCbGxpIQzjLhseZ4Mx73ZpooHD601tEdRiCEVXMHLygD88Eu +HFxnKbAac0gJsngvOMYyutyR0ywqR3I4BUwDrH1yCA1+ZZuKAqRnC6i5qR0h8M7L/e6Zd5W+rk37 +3IdryiAfWds5sXEETMmHDF7zS9I12vI18bGxG0bc6I9xSXAfrSkDuzdMAmq7EeDZli3/t+3Df7R9 +lWeOnkaO7+Iz397lf3w8iQzvcl+qI9U/f7+bfz25/cNOZc+ToqZ/8cn6Z/f+BRXBKez7A6v9O8Ex +m/oJYG1ogFoqHkqe57nqeJwBOwDE/8keyR6wUwMUJQNOFaGganxkTdIoshr3/emj/uezZwNFCRTC +eUNt02jOLVDAKyV+danhG7KF1bPADIkCD28bJfsYsoXv+7j2VUNGr1FJ7IXFq2NCGyh4nEVQvU7D +MBBWhy5F4gVYTp4cqQp7IpaOvAJiSJNLMLiXyD5DoxDgAdg68CAgsTKxsyKeBWEnbZjO9vdz3+ev +7/nnz/zpbfasj1aO4rVTupDRy6ueiUdwxEpDRpDZlnJotKsUgUV2jYzCZI02XgBoZFjXRZuAZaOo +gnuvLbBUhEXq8bwm6xnBHM7gf1HnMQAkNm1TK2KbwIU4ZWcovraVuFwOeKn8mgQ6mCCRgBDQj/AY +K0iHK0C3nwCUbdBTg0osp9exzaFGt/t4P9n9nh8/hAY+XnaXKQY5jhI5v5IWzS2a2BkdRTHjlmWU +Tnb9wXl/GFL3AwG3DeYsg7HX1SuUor4RAzTaD9+QLgL7D50geT/+BqECtZd1g8Cd5IVIptdBCD3F +6g4keJwBbgCR/7MqsyqwBAwUDvNMUSRTb07ezzGaHIs8hq4b9CqzGAxvBBTw+fTRpJqZpzz5rNeX +vtg42UkmxZObEG4U1/gVnV09/WQGm4+9exIHmrq0E+mzHRF4AhTECzZ/IM1S2ELU0x57LV0tCPHs +tLOpE4oB33UydPACG5cUXH72QitHKFwB99vGiy3VCZZ4nAEgAN//ogOiA7AuARSHm7fJKtmW3PpK +QhWnBM/GZhSx6pNCAWDpJg57+Ba7tc76pJ+KFk85vu2oye4RtIP9JHicm7tA6P0ioYYWxhamFuYt +LDVdXlwKCkrFpQUF+UUlxQoFqUXJqXkluql5yfkpqSkKufkppTmpCnmJuanFCol5KQpFqVmpyUCF +mXlliTmZKQqhIW66FgqpxcmJBamT7a2secD6lXQUqoHmTv/dxWI33bybZR2PkWlKakF+cWaJXknx +ZENp0eksPSzGTEam0817WFpVYKbmJuak5RflpoLsyUksySxLVQgN8oEYP/1iEKP0dLkiFvbJEy6y +Tf4vyc8OdcR0sV4WdcnQIE/XoqL8Ig0lIAthkpLm5MZ74lMXsHCzFKUm5kzP72ORl8tLLVfAqV5z +soGN5PQJ3Sws2w/0sAgzQl2pOP1LL8uR6VmszF7T//SxiE9+4PBEQMFUoSCxuDgmT8FAIS0xM2e6 +Hjuz3GRtOx4ACMR8RPkGr6CTgxeDWKAvAAYreQ0Zf8pcIQp4nAXBsRGDMAwF0IIuC6T9XSqgY5KU +NDoix7oYyyfJG2SPrMAd6zBM3vsu13LQsM4znpmR1D4Px0aljB5kgU1L36vjJSmxQSoii6M3D2Pa +wWZqo/ZoPeCVmmeN6RbsMSWSIvV98vC7/wHxryb5+zz/ok/pzhsilHMBDb1foFcmU6djxnicdVLP +axNBFCYXwVws+CM5eHgsYmcl2SaCaFNaoTVCvSgoeKiRjruvzehmZpmZdFukBPwLlLl79eBF6cVb +zv4l3sSLF0FwZmezSSt9h2Xn/X7f9/2Z1n5/r335uzqhEItRlqLGBBKkSco4QiJQARca3rA0Bcph +zFM2Yi5Ho9LLCuIhS5OgBVQd8RhICOsb8LYOMFaM70PCJKzb1FH2gEkSVNVtV92e1br8BkBQvCMX +il6roAe71m/u9xvm64vLH941l6Awu6Kfumam/cbEFXsrnHbc5phHKqM5JzuZFDEqFeEhxk+oHrYg +aKOdGCjU21yjPKApKZc+bkG30+mEwcBvNDOlE8Z7ELB9LqQtPh16KMb63CBK6WJ8iJLpheBxuFY/ +/WfedxuT6ojIwU2qpJl3zCXukf9qoeCCBHP+9hi3KFc02oPnN97pnCmrSJkUDpCoKeMKmD6fXW8r +K7AlhVKgh7ignlIZlYhy2wRtDlOAXMsjELltTyFlB1heVrQs7qc5ZdpTmCJmxFKygAMeZhjrkrEZ +uQVYvk/GkhZ0wjCymo20eDaUIl8AzMX8Y9eR4QH0E61ezbfta+ZHr3nzjBAHnrg4T3rwVEura2J1 +HZrp3Yb52Lx10YYEt8DtmE+PXpmr9y71WyX5od1hE4kfWu4+j2wJ7pAmwW3IqFLBmSwTPr9eX3gu +bVy54E7F5OTnau1GrWt+DUzxXT75/PJx7R8zrycg/gbamWvPW9fsbKkYxRhnqZLicjFhM3icAW4A +kf/fJ98nsEYGFKsXYnnf0vhdqrFYngQ7WIOGDQuZs1oGDAMU+yC+CotUZfyCou4kftwYPt8MwhiT +egmfFGNSH8MigOewNvIkDVT7Ewe39VMDsy0KjQIUltkVJeIXvlRg7M9/GmeFDpD5KaqzzgwRBzqO +LrP3DVAgzbh8puG0IhhCIF5c9KPwnRGeeJz79pmx5SvjhNx6fX2FkIzU4lSF0oLikqLUxFyF4rzE +guKM/JJihVKgcGJRemlual6JQkF+cWZJZn5esbVCWn5RtkJuYmaeQmJeikJJRqpCcWVeskJRaglI +LDkxJ0e3uCSxqEQhOT+nNDevWI+rJLW4RC8tMTMnMy9dQym1qCi/SC85EWj+xrpuZn6EjCtIZvJH +fZPJ+So8mwNYrrBwwCQnR4nJbXbilOCFi2yOEpuCxHunzBEGAI7GT09+jlAusrqwqhYStTJ9cPN2 +NwekANV4nPv7kPnnQ+YNz2s2v64RKgEARP0IcvQFAPOFlWco3CqCiTF20V8QhG8g+Ht4nFun/1l/ +wgpPfX2FkIxUhbT8omyFotSSxMy8YoXkxJwc3eKSxKISBSCZnK2QnJ9TmguUyMxTKAEqLijKzCtJ +LdLjKkktLtFLS8zMycxL37iGSRwARBYfaKcGeJwzMQAChdK8lMzkTIbV1XOP3Pp8QULxqnbQh6M2 +Knv5GG6bQBSUpOla6JYl5mSmJJakMtz/+MXBtov7iM36uWuTI4xjVZ+U80IUlhczLKi6fk3ava2v +Qfr2RAfz+bc/Sp+9CABFciq++QFtbzFx6P6MS6sJC/1l0AGaWrgL7XicS0iY4CPSVs/47qznpH8y +1xIVvl/51OqpMNcIAJl4DDj8DjWs0YKOvNT+OlyzAFhc7OaLibVfeJxbfpHxy2XGDTzayonZqQqJ +CqFBPgr5aQqJefklGalFCpm5BTmpual5JYklmfl5kw1jRScnsHBJZRSlpukoFBTll+Qn5+co1CrY +KuSlloM0T25gkZpsJiFvXq2AoSixGKRCR6FaobA0tajSCshIy8+3UlBKSixSAsrXalpzTWbkFw5K +yk+p1Msqzs/T0NTUK8n3TSxJzvBPykpNLtGoVigtyrFSSFCpzsgvLgktyqnVT08tsQeaYws0JUFH +IbEovRjT5M0ftLbbAgBL1VAx8wIEyimND5xHBcNG6FcODAot0tpatnice8H5gnOCp0jm24fPJdtv +eTKHimxqMsgW8mBxD5sswCixsbSYBQAO4A1A8CrPg1eH2TH5DiCdUzzr2gDcQtAlHnicmys1V2qC +iGlfYtgli6xAHynJOSILX1y6/Z6Z9aiJARAoJBYXpxaVMJzQ0OB/1M5zJKTIxuia/bl7pdINlRs9 +Y5lFri0StuGO+tCovXjjyzmrPkx+9zhYavIu5hqR2jVGjLnCVdekj2TLu/G+59zRJS++2YvlHKOI +z9/5zz/8WShy2Vnv54UPE9MVrn9ZMVmHLcZExTnp69vozw4ff3ZZ7khi/felN70Z4oqMkpICI4Z/ ++cvFWPn/1D/eHfhm3+bCF1MLrIwm72HrFdms8zyQuz386NKCBP0FDQcXrGlfLjh5I7vJ5ons6xhF +pvzPN3OT88ttuOm/Ro89OsxX6bnx5GBORxHTeXyOPXpzDpwIubGp4Pf76eq6+60mr+AsNP3hcmlS +0Du55e2mB5yP/Agqt21/OAPikOKSotTEXIYFbFOO2pkunu141OWJZfPiNxcruKsm+3H1iSitvcr+ +l/kDr9c/ZqFXQumRDRNuXJv8gSvWaP75a2mKp8RMdN/xeSz9+cw8yoTzP8TIkpxihh+OcsZbvyZa +TvCeVXpUZcGHORPYlCfXc1vVv+AQb6nZU/3k1v8fOU+cOXKKauK4IdpKi3IY/iv+EW9KnP9mnvUD +UVezRVUHNix9BJUtycxhOCx+Jvij4knma3kPGktTG/5atJbNhEiXWTA8u76vTE2pI7o6/c1fxk38 +y9StGC4YGhiYmZgolGUWZyblpOoWZ0y24MmsafqcIrm6Y450oVySxLXd3SEzVrCaQ4wpTyxJzmBY +3TlBJH56mPErpSZl1R+9JXXtjnug8vlF2alF8SUZwEBLKWZQTrySabORJ4orSvB7+4m7ui6P47sg +CqtyMpMY9iwuufe3aUpYdexLhfJff2fs3/H8BACtXSWL8QKO9zc+jj9X9ZDsUeSW7FwCHib9K3ic +28e6j3WDPaPIxQN5dusXRprsf6fw77OsW2PnQs6+zcGM2YwA/MIOe/gR13l+z7hvV+Jr0REsr6qZ +N1S4tE14nNu+l/X9AdYNv0z1k8tTFJIT8xSSUhUSFUKDfBTy0xQS8/JLMlKLFDJzC3JSc1PzShJL +MvPzlHQUNDSnv3dhVM0sKMpPTi0u1gVq1i0tygHKVNdqWnMpAEFyfl5xiUK1QkZRapqOAlBhSX5y +fo6OQkZ+cUleYm4qUCyxJAPEUqhVsFVwKs3TAwmE5Ltl5qQC7dcILinKzEvXSMks0tS0nvzPW2ny +61ShyTqm8pZg84E2lKdYEWtBYjHIT5ML5KUnt8WITW6r5p8+zZJRhBvJkskP3ZWbec2285oxrtIA +AFPSYQf7A+YseekMASRwAqw8Szh518tpHNE4eJwBOwDE//ES8RKw5gMUGi5NYeJzEsZl0qWeX+/H +HMYZVDez+gPkAhSBAMAd7zuGri1DS5n90ip1KbjAqLPyBn8CM08bif9g2oniVtq5v2zxzexkpJ6F +hfBRp9F4nI1U32sUVxRmJ2NposZA0hi1ticXhRlZJ4KIsiFKQhNMCEUSf1BiSG9m7mYn2b13vHPX +NYRlpQg+Ct2HK33rk/RBKaXQB2ubh0IfCmIpfS34B/RB0MfSnjszm50GFR8GZs493znn+8535+V3 +Q9/8MnT7TuF769+f23/9896EZLQWF8GPirBWFatAeQANqvzKTFhloOgGAwpXFuZBlPFMqAqTENai +KqsxrvToH9aIvvSlPdIqC8nCNX6yLqukCFtAqKduKVLCFwJNd7wPoFznvgoFhywXqzqc1lgJYiVD +vubCFmYB+ILHCktUJCsXIZJCCV9Ui1ARsTL5GKOqYt6gCRMwVede1MLIZWFmNlXXRcidxaSoE4TS +LYLJdpMpACRTdcnftQGNDX2DbOLDbkXMV85UvVxm0sNJfaoc2qCnQwU+aqnYAqMBtkZZnRzPTA7X +9ZSYlJJuOq6rv54qDNkEp9Iv9tmH+ySLRfUmg4nzevT9nsFWHr7agTMe4BdKnGWnpMqx50eLm9x/ +Xc9iXnDiZ5XGu2wQbXaf4MmJ5BxXOAN+Iyj9D0tcXKUXC6mchMn0jTqtOktZoyJkY+JL2mUZu7Rv +0OH24/uDhVV975V1cM8qyQd9ExxpkQ6LHeu9nojjojqw1eyk1/lbAZhmUvtC5ZA42UmcGNyPIBCA +bs4MXnqjw2li2AY6g3VNEcYJlhrf6p8qtvdhzv0nO2lGQ9Ndj/7Yc1x/6xRO6PVf7SF94CPrQKvj +cgSghVMr4l0pI5HS2NjYGdL1ZSdMugbFEOmatARnoJlae6dszGJTNwtC5s1rMlTMmLOX1kqpmHr0 +Uc/wHI7heoI7hEkpJMkJnRqugUDFOK5gV8Wu2zv1Wr9bH7TeXC9XIDFsBss5GLHGQCLa7LbboYdC +g5NyTFfBE65ujqqSmzp6aO/fbw6WTNay447ryWf2wf70dhMlxAaESj96aI/oP7+yBvT8M3vfQHqa +jIxXO2D6xWLhkL76m92vTz21Dw3jjMg0wD9KelU8dBhWfvzAPqfn1qwvznbkN2CUP4yvhTwQjRgu +AJleWFiZ/fTq5PzsJyszs/PTK2i5lUuTly8S0IW/C4N6e6+1Rw9M2Uf1x3ft3vbeJ/1zu7ZGa3Bs +y9RuXue75c+dJDJ2v5eWr/PP28+PHGuvP+m727tt4dPzQ++2vfHZfykw9mn8BfUs3M2a0nMYSY1g +K6IzPMcvTEgEeJwBXACj/54+nj6wAxAUq71Suv5ylxhVwLApM14WcE4qXV6TjhAXsy4QDAUU7Bnj +uYOgJBkDQDx7ldCi9lk0PJqTzxUYs2YVdgkUCtXZ72O+V7gB7AbWY+SH3e6gXqKT8B4uzJ4oDPlG +fJNBWLqWx46YE2K8qw9ZZynj5SF4nJVTzWsTQRQ/2No2Fw9ii9jqc6Q6W5YkFgTRNLbVglj8AI+h +yHb31Y5sZ9KZSWIQDV4EPYjw7oInjwqePAhCT94E8ar9AxQKelEvzmyiJZJoPezs8Ob9Pt6beRvf +dr28N/D868RAoQBz9PDpOG2ODLbQ1rTEBKwCu4qAdZQWUqWqeViQiZDXs7BGU1XSIAhpLEYJNFQt +dSBM0+w8ToXHseliES4vsnwuQRNrsYycuZ3VqumZom2eZVxRGiE6KZt21Z8JA8ZTuCUxIFUWZSHw +AGbKcCsHEDugBW8XZoDToxtHqDQ3RvNjo7lSxWm4/BBo9thUK4Nc0WpNGCzVlUjKS2VecRQAFeYs +5DueeOAEItOUMfBroTeXIXnUiERbiQcheALoQgVLYS8yiFYsami0tLB43nWJTxeP95HwwEZXnkvb +qWy2AvRUNzZq2Zo5qxJ0bTpRLLKwk97DRWbDIboAO3HS5uzjZypLQq2VDv6m7ja0eWa09U89iQ1Y +8HS/XxMmLPjThZNf73GzLtr/Uj3gXP/2bvP1rOYXtfv7QrBPIev/U8hSwNmk6Xo0qXAzJ1G3J4Fe +3z1MB5+t0Y+PI3RoY5jufDpF7w7spzcXCvRgPEcXP++l2aE99D3aR6/MUbq0uPuqF+4MhG+7Suvo +ydpjm1eSszhVBll2O/40CE53SsWbVYytQ8Uo6pgEeavm3VgzenJ/krYeD9PW+8Ehl33bfS++TLz9 +8BNHMWtP+ganxzQQSBeHhJVHOCeRN7jkiyqvTnicAWoAlf/3CfcJkB4UDu/5cFDv5RfatV8vD94F +OyadPNOxMgoEFCdfibzmv4sqydr56WCHHtdhxgqRk1AEIxT+z+Jjj/1ImJbEQyIxgDB975Yc9pOH +BC4UwIlucw0c5nxZtn0ZHDmRUXhf26CTyQQuZNMw7vcifTR6DmNqSGGEejHUn8tKxJKhGL14nGu4 +wd55m31Duehkh3be6Qu6GVknCzkqb54vuk4eJiK8OcF0Uevk/kowT2izyO5PBnC5yQmmKybvfOsw +yY97ssMhls0Cb/llkCUVpv+1ZxSbPGGjyOQFccbb13MyejCjaJ50Tn36X0lGhckBfhyTDVYITg7Y +LDz9wQNGiUkX2Sd37FObziPKqLq9n4/xFwtMH/vkIFP17duFGUtYkY3KmLxLx23ygn2C24HmhUsh +S0lubzBh3KPMWlycmZ83/SIbo9z0B+2MopPn9HFO3vBKeHpYBKPJ5NkmnNN7IhjllK25FMCgOBWs +3rWoKL9Iryi1OD+nLFUjVS85PyV1sqCv2OR8E9bpBRGMbNuPRDB6MyrroGiwQtVeUJSfm1k8nS+K +sRXF+9P9ohlf8KFqne7YyCg23SeGcYNQYnliZgmK5PYvMYy+Kmg6tgN1GDNiU53TxKjJiMV8r+33 +mxnzsWmZDtTiN11qPiP/dPvbjKzbV7QyRqQBAEIrzVb1E8z4O/7gOskBwEfdxGyV8tv1O7/3eJz7 +E7Q9ZIOzok5afpGCRnJ+XnGJQklRYl5xQX5RiUJ+mkK0UohzgJKOglKIT7BSrKZCNZeCwmRHRRlm +BYWEyXGKDjwq1XD1tZPnKsqwJuiAlOxRlJh8SdFrspSS9+RkJU0tBYXk3BQrhWigHAIklea5VqRq +aOogi06ereTqgSKioKenp4Fwla2tLcQ5CvZA5+nqluQUK8UqAM2ORTEoFuyOx0pFk4OVpYD84pKU +1KIiKwWlgsyCVCWEylpNa5DCduXKyf+UrSabqWhNjlNREAZKQNSApWu5gMomV7OobF6rcp4FADmW +Ujr0VxVSVyf3EW352AHXuJzotu+DjOBYeJxtVM1u20YQRtsEAVTf294mbICShbKSBecHFJw0cYwm +iJEGkAMDuSQrcmhus9pVdod2XYFQ30GnvkWAoC+QU1+gb9Dc8gA9dpakbMcJBYjLndlvvvnmI//9 +7t33b/67tEvag/SQoSMPNRTOziAqpTPofTTuqdncOuIMzwld1Ngc03Zn4MmpjFYfLr1bZpVD2Ia5 +sxmfFdIdHgllMl3l6OPo+nWuFCXjXmaNJ+DDR+g43WM41wO4CyXRfCQyh5Jw0mxPmqx4AUKIhmGf +84mUOfQpLEAZRUrqA2Vye7ycqN8xhc3haAt+bG811AkjpxeQG0xmogqI2/JJx0dYE0ee2StrolCr +WcH2nfVScPk9m61rhpJxV/FyuCdv/7588sXTa4sWl5uKQm0fMYlmFdXpYLA5uiWG/NtMry2CvPXL +Pnfj8FfM6JmRFZXWMXKeQiG1R6hXz6/8ND1Pd8FtDQawXyLMWQ24t/MYCqu1PfZAvNm284OHye7+ +/qMnP08GB4+ePPjl4MWzpw/u7e8CN9WkyRn/EesyE4y4+mPj22Xs0Ft9hP2OUBLaz7RCQyLUitE5 +68Jmt7rbJbaPCXfaIcQJX2PGbb0SdyCeeArC4cwSnsl4Fe5sh6ltrKfHJ+u3f17568ulRnaecp52 +pNZTmb1i2zTCjHshxJpYk38+VshK045G6TA/iwTl9iZQ6MqXyN5X85L54W8EU0lZ2JIEm6Pb8Fjd +F7A8UFSCZj+zYWU+U0QM9nAExw153w94VCoPx04R6zlXml+qKRaWHRDsXs3CjJggzLVUpqkkTQ7M +64iLMVRgPmfZPE9X9By+Fg1WzOLdX1ZFwdbk4zaLT321NRyubZ6Gh+GwD5GMkj4fOX2nwlsVNwNc +NE/huqgkuQrHXbRu7ilUJsdCGcz7vWS8cr1/lhfNdzrU8won4/ORqx8Ppgt+Mq11/VCb3EmH3nmF +Px3k7Em8evn1+6+CQwcb3yzbjE8ZnXE632Iy/jj4eVrrsMDXldTxegJyqnEPzSGVfbi51ebe6GS6 +4K0zHZuAyEIkbo7UPJXVq42T/wHOVsNfrgJ4nDM0MDAzMVEoSC1Ki8/Iz88u1itJLS7RKylmyBOu +LRVMnB+sKv71nkDSGZfcQwaBAGVnEJv3VO1bqpBPx3s9srtdhF3z+dj+pe0OeJyNVEFr1EAYpaUW +uyvF0rVat+DXRW0G49b1JFtjRRBsYXUrrbQU0elm0gazM0sy21pKLJ492e+kVz0pglBvXtSz+Bv8 +AYL4AwRnMtvdlG2puSR533tvvu9NJt9/9vz63fNxII+VfAW/ZYbxTX4CX+ezfbENMX7OF/BdHtrA +rjW2M35MskhaOGiPXLdIkXG6EjCLgCtYxCckhCxiEiis+ZEUqyGtg1yjciICGoSMuptgFC4OTQ7j +s5l+fHV8CDcyI/g+GFwsQUymMgDsaYPVpNX2aC9DilLcYpYMmywhynATttQdYGPNDxikJDXR5BIc +x4ErZGcqt80iEawzcG6AanDerzPRlFZoUBtKJPEDqAkeSdgCI4/B6UxiCEf15tEgYqSLm011hY+y +o1eTp4QXg+dzGgR7o3SsXT8y3glt95Pz9tJ0En9Bxw1c6LypCw0WeiKsU15jQLkLvoygFtAoUiQv +FHVYDcQKDeaVs8r9Md6t9N/hVPrrqu6oYVN6G6qHvNzmKu19SIWGT2z8MptbgNgMrC5VBMukyGmd +gc+htRRJtbGsaw/V4kmbsNXRG6nuCMeDi/hh+gTeK53E+wuntssJXExPq/e3ZZ/G7T03SPfb0lcP +0VeP0G+bCLpdEvgwKxPbgf3o/LrdNHqg2cBe5Bm8PDfWU8bnZ8/0aTF+nR0eJPs0GsKZuewDLlym +vnafr3anV+wU1TZFUmPC+58h8GZvbqAMcrOhBTjZe+F0qirV6Qp9z2duGfAvGR2x1A9CHbwSsUib +FhPMLp5Hcu0F/ljMobNE3EZ6q/QZN+TqkXBrXw6smZDbJf25FtLUdEAdVA94rgwFr8lr0he8YOD0 +ZCV86di7y/6f/n9GE76F/wM9L9f5diSnpraEwdapxLwGe6hrlXicAT8AwP+uGK4YsJoEFAouUvhJ +vzN2vww3fTAb2E8kVKxGs64EHgUU4mbLO72LE9xw9BGrGmzKkJo6YtyTcQolswUKKQIePhjQ/UhF +Dsb9KQV5WOwnR8aR6PS9dcpziHicdVRBTxNBFA6JGC0hEoioGJPnpoZZXZYWY9BiLRI06gEPHDg0 +DSzdWXZgu7PMzEpJ0+CJs8lc/AN6lph41p/g0ZsXL578AR58013aErVJ09m3733zve99r9/ejrx7 +P/Lm+KIDiraSVSZOjndnjzZCT0GTt1pe7M9FLKagOI8k+By2acAFhdhT7BXFHJ8CD0CFlAkJB4Ip +KjHZBMCnsilYorhwYYOpkKcKmAIvSwOpeCLBM4EgjSJIWELdAuBnCUGUS71mSOqWVD4WWg6YExXC +aoAn8eJYKpv00gGsRPAmldK9JfXnwmV9aWz0CFrenuGCRAwybEe8ucfiHcvJizx5GDexkRaF6iPo +5FHIoKEe+A5wrBZP/QZU87xqFU4JQQ3qZQcWGlCB+oID5cZSH8I78PTPKujRxSk9vTitf4xPjJr4 +ll6+g+wK5PnwVSGqHCE4nHZR7Jjbuu5m9maAO6gRVKaRwhr9u3A1/leGEVnRGFN6cq9js6TYCfyu +AytpEFDhehFKQsqbpVLJfFHhtmXbZ7GGa3M1uro8P7Uc+JWcuGuUyvg4/Vu7Z4G2nKGHhnnQJ3dv +6HsXZvSn0sz5bi9Z31x9pr+fmz8amgIqnaTK4CdcqP8OIjs6kFmkN5Ls2Avhq6Hh0HZCm4q8WH+5 +5iaekJRk4LbtKv5kP/XqEenAoKkKlPp9VaAvF3TtvzAztm5E4x0VGrgVOtA363HzQfE+QDfTA0O9 +X+N3YuEeMPRBiPaOOeTDd4zbWQxruGn6S+2Km0o0MfhMoBb5zpJcijlTP5fV4cJ0kKH+WntcE3Q/ +ZYISK0aQSiAt2x3MFa2rDhOKS3xqvwzs1H32ln5dIndW0tg18CTxVOjuchaTdSWQCkEqNnrHlKi2 +QgfpZOm2vlYe12J1cjJXwUpjnwb4T+JbeqI8PWbucmkbSfj6w8PrH3/NsuIfpcxsEK8CeJwzNDAw +MzFRyMtPSdUtLszJLEnVK0ktLtErKWZIv/xRzWsS89/E08U7xRx4kpcutIsAAIdBEd7xMdDG1PEZ +aFIlVvJqkdODyt48AOIPeJyFksFrE0EUxtlCElOTGpuSiof2ZW1lV5atFpTS2lIRz5X2opRQJtmX +dnQzu87Mpm1C7EEPghTBOezBu0e1FPSodz30IgiCR6/2P9DJbqvSSxd298335nv85r15/TX/7Uf+ +XXtg0SOS1IlA8KgIA0F8oExQD4GAiOqiwWkdOfhI2ihAbiA0AsawIWnAIAiRqb0xv6g1IYGjiHwp +Xn6vxDvXjaw6LJ4dtmF+4TjhhpHYsNSnGyMFB7y6S8WSLmCrpfFp9WsoF//+YpTVs/MFtTtkq9bF +3OSRz3ZlcOdRRHxrNWIeNilDzwHJI6zZc4PqTaaipsYuq1c/86pHCurgfS4uPTUyGeLTNsZ7NWPk +TBLOwrX44KpRiadmjOz+44Hb4/vD5oV78eh9o7Rzlwdb26YDVkLMcBMSxepCk3IhZ8EMGOq8QH1Y +Ty/lZmBCz4Fuz645g6CfVZO2woBLt4WSuMjaf8ud0IEIWNZ1uHdTSE7ZugM7abCQlKrZllmnzEsb +zkgLPQgJ13+JXEDQBKKbX3+gx6B3EAk+FVIA1W/I9VC4pJgs0W/OwqToc6w5R44EqJsAp2PrA80v +9p0NFKLPN5dk/xNgHk7pw1xcNYxptfu8ELO1gaz6XMyrjzOVSxOJC26tpHYHJlJjX0kjU1WrZbW8 +fWUFALdCTah77rqukERiC5l011FaKbtl29D7dx1OYTq+HA9flMonj6O/6u250SdO54PTMTqHfwD7 +Zgh49gPAV4G9IxdRUAdfLY5QYnj+RBe7GHicATYAyf/HAscCkDMU1JcSZRowlY3tsYJgpJeNtMG+ +vjyRR30Ueq7rHj/Fd3MfxFfE3c9liksq3ciR2G/BDhtA8QIIs3/Rrof1C2IJtK6rm0gH6/CxY3ic +a+Vr5dtwgkmkzuBlzIROGZE5r6/Mn7mrsuizn6rc5jtMmiwA9MMOa6awbXicrJ13IJXv//9JJA2r +ZCVlJDmZGSVSdiGrklHHcXA4yxlGlDTIKkWaRkoZpYFSZGU1bElIhVT2TqF+932fc4y6D33e399f +pOvxvO/7uq/r9Xpdr2vcigoKqioq4hQ0mYJAOhJIFDLGBY/EIpB4n004NzKLUObeawY+1dejgvob +yazDCvfD1PUUZzJYMsIJ7YykYimeSCwVjSCQMC4YQGETAIv8kriSV4n5eX/RYiN0I8Jn+2atpLlg +kJFCX9Kqv6+pxZ662Oq6kXfGBUGJC7MYEg6BQ1JcERgsFu0C3CkGT6aQqCgKhoAH+aJb3axPT8tc +3u5xY1CubihvRJclcRZPJqNJ4A8fPAosnzP0Zu+6LNSdO1sdhDmyRDy/yu00ginvSMVgKcClEHgC +BUFCI50QziQCDuGMwaLJPmQKGgdqHfbYsummUsGl4Ed5NdzFy2V3qCwqgtFCIbFYCgmJckeToN/J +IOtLHvr1czRVbuLjk9sqLKIXayy2w933TNYFTdnJwK8mJ/2y4Cpq+c53+8TjJYVCorvNx+fBSWgi +8L5BOKhvye9VE0v6C04eVSi/L8/t1WsZPQ/siSZhnH1AmPfswu+b1x9j667c4Lq/Fm3pjVvKBQe7 +olHuFKQLiGS5ibT4L8a1vj+tue98q5T28ChqIRyCBX4BGgjt/VJJGDxE3zmeuh/Fh2lYfWL5XflX +3keX8D/tZkaD5V+/Piyv+vuHj7eObDRiUam7jM3ECZjyTmg0EeGFAVoWmkQikEByNMcOZVP5ddlY +Me9+zpeyLEnbnr+FIdFkHALlRkbg0GQy0gU9o24kik6znNcKitnZXvLqyZOQBRNjxRIwAs5IDBa4 +PpGERiEZ7ThV8f7ZC9q/F8uLIVSWohrq9h3himGCgsWVeNvVbyQqp13Jexocumffrwd7HVNhimOc +p5/u8wPRqxEvo9Ixu81YblI3yXceFWCDQYDax6CAh/TGkClQfe4pDzG6zZWYJXRszUSJuCj+MOKx +KQxH8SGinZAkEtIHqlq0B5VmFPwfhAkGPj1Xl6gvzbGj+eqCMIEfJ//GwZI9rQc5uvhKdF9vCWnq +jco1EFC4xzu7JNCHEa4EgjuZ9jsJTSZQSSg0AkWgGwXak4buMb59O3ZxZ6tor3WffHXg/eMId2ZC +f6CO3ad0OL81P4l8lajqOrlWNzH/Ti4zFI1HOmLRTtA/gOqi1RYv+Qja0HabwuUqDLu81tP9q9PN ++JgJAO+fSiJjPNFApQPdDEGi4o3wOmABSxSBCJnHHOMyvL/o9Ystuxvqrm2JIG4JXMDJVI6KB6wj +/U9kUAHowlQXV/BlotBERktrC+urWW7W3SHUu3FxtKBz6p18fq7/QZLiigGqnwR1zURWXPKbidrE +5CD5RJke0Y9XxqVPMJOiPSIB6CzOWIIXAg/8P9pp2i57xYVT08TPXjyV8ToiLTRJzfaMcv4/SlFI +PsCDUlCuoI6e4qffX/u/G/QnCl96Yyox9FvV6Mu/6YA0MafUgCcmw2VVl+zT70jjaxofHfYyoz1x +CBfo1hsvtO2LeX2zKcAvhvd71OCwwtWWz8wgLwIJNKfQn5zxCAqahAO8JwWNUASVugScbPg5b5hu +HX07GWNxt9UaeZJpJTBVUgKVFp53qv2aNpJb+lh+TOuq+PpR31L2/1lJGVTaXtqwf3OarhumlPxx +v8fg1aTi50w7E1MlFVCpeN1iHo7KA1y7+ZIah7tQGgeD3sv9rYQlAH4HeDUEEmhbHTF4J5BtqCuy +uST9w1Lo55tLPZv9Xx6z3HRsPhbo2hS0N61bXkGt51eLGr3NIe7f+elkvzXP3u2/5uMhDwG1EVAh +89PC8KibPULvhoJK+BzWPxCiuofPp4AGboAEORkoPMLnIz/efKaTVWVpFuzXGn1BHd02rwJgVxBO +BDQtEMGikdC9IG9okLZzvsnJ4CDw+b1NGAmxIqvNp+RKoRARwC94yNaGsZz1aDx/4NGB0k9XjMKv +W/JZB2r/kwIOCN4wKCwG0IEqVojtzXF76tMcdZzxr4m00byWyecG/yRERJIAwz/1SBvON/mRR6hX +3yvsc425JZSfbYxjm08HQyZgpxxoZ5BrKHLVQ0frBVlH1A0fFw/JkXzmEwDNG5lhaoXb2o3vjipv +c5fxDstdefv31iBi83wCZDySSHYlQFWKave9UcGV/+Pb7pRfNeigmkPPbxf8zXuRkMQ/nc4p9Usp +XB+EDbnPviSFW6+LthFUgOkYEEnBkskEICKjTHlANHRxcw3ei6GrazdwN3rFNnS7NO5w1OT4S2LK +XzJ61d3E9TITYeJPiieij69reSd1odL21iyKQsBhUEC/RrpDVcStTmT1NEkgi8iR2tmHBy6T5a4I +zSzvCMTJVDwGRXCCimdMvObQXf62t4zH+PaG0w7OuZJ2s4JUR7QzgYSGmjjaE2hQUGsHwR08dxc+ +OnakaK9xKlvII0y9/JG04lkgcP9AdEirRyS9JT7DW6oLWA8+Tw19UXVnBwlTnVh4ehaEJTgigDoA +7BHB0Q0NRphQgILcFdJ+615/agla59tRs6bH48FY7B8cyh0LRENAiEnAQw+2wymdYPVSbOhW+Q/T +etfJXDOWFatgEbDwjaVJAly3jj/xqC2q684VLh/hvv5+VmESAemEQpIBB4bE49FYBIoKNC8cONAh +AncJ2eALrK8E9onV8lelORgl4Cr3bc9OniVBISDBl+UIRZL9B1r6eHZQSSTE6HMOyUMEhaxZPsyR +6uwMGmkscJNg+aVnG559LOPnyG2pU+opXE7co3setjwY2tF+B6nsdVk+kVIeuI9K/uv66rrGWFZQ +ZeEoMgqDAcvf63ksJZfVbLLoClf/Ofsvirn3Lm2GKe8IWFvwzf5xNa2IXo3QHRFrr7S6mlrcWKx8 +M8AmF5Z2ckV7Qy+V09nmpy8+O+VUObk2uRK9e1K2Fw4AB68UVcg91ZyrrF+wZHVKjc71y7nCeGGD +4W+74RAfChqLxrvQbPqvYs7fGQtD7k7klBzW7As4qf9d+TkMhCLgAHsHjJadnekdNo5A3mygha62 +GVK9zrfohKND3NAn5iBIGIsJv351Zf9lZfeOBf6U9NQSG7M1sAQeCIZA4Il1hXDoaLeQ9/GT+27x +aumO1vnKwAPTnUiu0E+hfWm787Put5xjFTYDe8xzxpgxNAM2cyAzPdjAasSxfWpbHmpv9e7NnZs8 +n7If5ODn0cEDVgOBIzhRgSE24B0ortANJV3k77J8ViTwmvVLIenzryNVLdrS/4MQ1PRu+siT6xa1 +OuwZfLt6h8mx0B/7zOaRIFApZAyg8qfUkXRTuY/XBB+UH/CK+125JrTBf30DrBQRGg9ecprws161 +Ui88rn1d26dF6plav21gikNjJUj/0WUl/TEeoXNkZf4s26dnfx+yeNUHA4CjQDB4BrswbeBF6zCQ +xh3zmI3fr6eKcWFuLqp89ThvS8tTO1gNd9ozNXr/4rzQkS0ymBD/raHX/GTAD/slcOUxWMhcxlmV +JnCnoX4HWUunZKpKfzgrbi8MV5xEgHIkWcOJNQm3fFVCpIsujn8TC47t+NgCUxyDR2GpTrQb2oZU +//kyQFvUVbf7M7oorilrA+k6LOKE9iY4g4THyO/PjXvX1dmwmtevc1UpLFt6PQ6WcAWG6kBbR0Ed +yiBqxGUVIuz028Qa34fNdz9tXsMPZ1Rm2OFl1Q4HLtZ+23/Gl4Ld4GHLmWJjvxyOIE+ZvSf6YdeV +bTp0ua6oaaxz4Oddskb1JyyBxgNek57x+LGSxfr1Frvljoup2gNRMYZRa3IcYSEqxVkdBMRN0jsS +f0lhxf0WPZLI+y51ZsEJeTgAiEaR9JgDO2rAlz9scPD7JhleQ16HLT7dl6NhEDwaGhdxn715avBy +RCbp7OfaGxhO7ObNbHDWG08AABfAFABDWqhxTkVn7eHXqHpUex8RDZayL6cD9EZrxCNhBYhoyLUD +RgWBQxJBtMxe0CyHTz9qwUB+fvEiq/LbZXvqYVCCM3j5P7IqVXeoGTdUB4a1ih5u3P5obV5ZGkoP +jgWGgMDlvBHTht3ho++KmtTM0YSHkiEf9h7+crZCCu7FgcYZCFyIJODGSRSo00uWp7TsHBd7tcTe +K0S00eS0OHr9PjiS9qB/3nE+9lP99V8N2Jh9pOP37xrv9nHd5gpHEwhYINSikJB4MvBvMBEB5Xg+ +qPT1j5cavfCxt9IX0VP7Fr5JB44mESgE0G7MbNxnhMp5GipXljxpLeALOXyiSPYUBQPDgslQaAQh +jUQNm+5U7idXxC1dIi46EKjPx6S4E4FKv789JmPPNCTG48JWDwo6NKrUN+hyFDKBgCE5zY2VLr6A +X2BHVK6/0frEoEh6D5fnxTomDIY2uAnaj94oc/Nmh8qHUxcTvS2rKmSf3WdCUOmIYtvG5x9WNOmY +t9dklVL1haOvS16BRciYw4zK5lfiKEUNpwZrNMl47v2mpzjcvgQFw5CRzmjgVYE/IPsZ6k7hyRof +ariRuK2e88w9uR8LBeEoIMSnvxyoZYJhB2QdL9odD+D93L3bvciz7XD5Q41RwaAKON4VaJlOf4RR +FhUl34rLhT/i7zpXmt/pvn5EKx7ONZCxGJqFtCAtyfLV7MzKlwp3NbOwXY0j/eiCLU/LnuTxGOeZ +3f9p8rTyMfXR44jeGt+zlXDFvWgd+3jmHp/lJKV18exdJzA95dXjWWgjmOIUghuZ1jfe3UxyCJAb +r+0Nq1xbY3icz2BPchIsAOYwga4FdA4X6DlYjm19bu9vuv7yDQ1k7E4LDf73CRvmBadimXSz3Uhp +wX0aw9IJ2zNTSaaBzxfLzUFDMX9j1QocVfUM+6dkg9OBpc/Gra/5wyBegDdCA56YNlDAX05d2iH6 +hge76pzwuZKgSh309qvMILD8bh+iTeZ5Wxc2lud8P71YeBc67ocLCKHyM7qgdJkgRSE97UAvZZ3x +De/L2JJnOGbUVB8M9EwSmvDCqb7LxnmgzSNG3vQK3mQG0XtU+xOBB5WD/mkKrZHYtaS8l8dXWlQx +Qxi9sO9O0+GMsK2dBOuDdo7bLl5d8nghXFc/jCYRoHgEGJFBXlYI5Vh8kGOwIiu7IoTvnse+4LCq +1XNyU+NmZdNPjwSfCPkmlSlKSJZ0aB4L+0iei4SmfeKW8u1ZGCD6MuBmmd6PsC8vstYvm8mggGCM +1leXKTV4NB9SPy1cEX9km9HJiPTqaK1ZJV0xWCfQGqPQZDIC6eQJhiZOQN8nYZBYwNBAMTUWSXJB +T/dh02M57ezEH9/zl0sRV72Pyd1n1hb9P2uSiVgMBcy/0hwe8GhoLGTVrRYlEozszqp/shlOPrE6 +rjDToL/uf1WHIrL4IuOFCMXklHPkjFL1l0vHf6pSmeuAeQMyxQlDAFEx27p7Raa6dodj439HZe9T +D14VW8YcRSHx9G5EIYAaQOQOinDELhoXWHC8oHTj7wHvxU8KRkTX588hMjsf471zYW13Vkal+RqT +heMWL+K7NjmNzwF7QTX31VNVRMB/vGbs8m2nJVdj8HVHCHM8MX0aFEGA0vJQY9H4sayz63HK0sqD +fL92e6tutwma2DiXAHDHBCjg2OO59b6ig72ndNK7CzsXmXC8T1mHnQukIFGuaOien9SrXogdDkMf +fRUXm6uplOLo8uvDHKQLCYkDug6VPDWTaNrJXyyVk4XkO1HWgdEiqH3QKiuZQwBDBmoaT483xkMQ +VZ3r+BveNruEBcZTrrHk/f4xBwsZMAQRQ0vWHd6JUD9/Z6Ipx/4XW6nJkqepN68lMofROHDiFgpy +Ot5btHHdRiwghRhH1X3sHDjV+GkODu8JxeMBB/tXmh3BRGCXjn40jxRkD86UmQPyRqNoc+tgAppE +wGJpERcOQ8YA/Qyq+FVI6Z6YTnKGckiL1Ovglvh80VaX+RTxPoBTR2OxZIQXMPQheEGNxk4lx0sh +7PnF2hviQfE+2TKXNn68PY8Qvb0afcaPmK8J05KUMs3WVml0OkowuToPOXOMwh6rsNzUc3nFo+DH +ImUB1JpQdaz9vDhUmyMrnVSF4kYnj901NUqhdu9y0PmJno9kuOJyvaFFohvE39/k+JnvaX5E7rya +pM48rDto7ymuJHqFjb9w8bfkcbXiEP+Q9/yUz6lwk/6YeRSA8AswvyBcrWJVY7uUarSg9klm4Tj+ +wotifaV5YMAkzaq3nj17Ppk0bTHVU7py8fmYcJjsplc980sAVg38AdQDwglJQSKmI401z8bH2m1N +bv9uW3G0dOS62oYWTMc8ehQMDg0Kor2JGFpqibtuzC4nVkumJ9zfVDvcJXDvMtmwfxRxpztFI/WK +pASJk3e3p3Z8ezXx+VZn+uwR4hwS4MwG7V6ghrlsKbfBj8b8I2M795rn6fcMTHTL1s6tpI8BLcN0 +D6P1vp1TvQ9UVS/w6lJWv1a7ouN1aq+++MLoQ3Ztc6uCJmPGu183ft6pM8wSoadfPRn/2vpQhv6C +eSqaYXOKmm6l/9AnsMUcfx/nNKkRtTqyZw6fyiChnP/05VFjr6W7MmpFfmV2Kmvq8KIO14yMzC3y +h8A+lirZR14NFR+KQlo3dxSrya+KWjKXAAb4Ez2P7+9glbtj9NpOyr7dg/WVcpvzos+PMUedsVSy +67Q7970iu/DawyUuAkHBkpc4fTeezj4XPgdMILnTXh+CtjIJclMoBcKD3NoiiwA3U2m3RqNLctfn +aJ40CUZk4goM8qDh1B8ByileNxF7gY+chCuxZ6NzeInG2cpc82nigSiFiPSC+NMdKk9D2de9jf+V +29sk9qaphzP283w8yQUyQZtq19z8VqHYc+CNx+czDyeOEENDkudBUVgCGXoVeSnPtsmbsp2Rjgu6 +Uqopcqj6rNumf2GdEIzZBTLaBQo9oAxYV1DRwSq9KA5zy0adFzU7mg45Ts6jNjN8CCowJ8uY5IpI +7g6OVvIaE05wlp2vDmmujOQCeYKBtuyc/d3OAeXrOBuVgl84BHvxG/8LDyaHQV5l1fUFJZd3Pgha +I/ujnXdZTPrhA/7z8HhgWA20BU+aUfi80STXsuMwdWlLln0Rvxo5Mk7G/V8EoBk4UECmMWq4b697 +SDD54K6Oasknqx++ezKfAIHmxkE8oCIVOSmu7SkY/Fbq2CLs7rZX+fXz4CQ01Juzh3fKjnE67zpw +NntLV0YLK0Yvu3R+EloacHb957P3yxSXmJHU0Ql+k7x8CEe9eVCoM9OdDsITCXQl2njNTcPd/N0z +ufb98SXfHpZxGOohdh2cR2qm35jRxfs46x7IPjFe8io6WvHoMaMD320Pys2jBE7fgUsWzyOzqKgz +5472r9bT2seZrS3kYxM1NwpesDemdiLOQN+75erhSFvr7/eGzcTmiFxBCloNQT6gK7Rnx9auQnvD +h0MWqSo7+azjmWMYcP6f/oQq9kbmFIlIglC38PNMmfqQSgdb0zlIIgpoat4UoL5oyw8ebukrs+dt +WNE9Hhr+pD/VR7np7b45cRB66/nDZlfGkkjRlLIHnPwi0THB66qYQwxXziNVcvX6HRmbvL6juaKl +rQc7rYXmoMAOMWtMYKEQ+15k66dtdU02HedYS6RY83zmeB9/52yrN9melkdRrc7zf0jh4Nuut6xA +WYM5/0dgLX7mM6fA+CWnBSrvEAlO554PjWbO4San86AUJI6IhmIqsEm9Vih4VBaDt+yavHq82Unx +xu7jAhHMVUhocDYZgacCLXoqTZcpce198/tFhYYnrtjrfkF7v99y9C1zCTIa8C1IZ3C1yJSpd+QL +9RW55CmGW0npOpd40DFDfHPnPAooaAK4sfvtOkvtfTXYd7YeVYWV/hYOg+nzgO7gUhcw9w5duMzx +U4a6eN+i8NtDCS3kAc8by27Ow0N1OBWlo0vE329Ir8nyT8JerOSObXR+lx05jwBjJkN68ftlOFTk +smfex+2+nXHBfGvuz5gLpc+104NhXGWyoo6fPaut59YdIcPmacGL+uZwCGQgyqLZsWA5vfUvWhOO +jIsuuqBB/uQVmKbBPQcHxgBT3rx77/Din4PJns8+CD1aI5VK4e/Tbv4nFmxouCUv2F2C35tbO7LI +B9zR98wW5FrzD7CnApS7MoyOipbIHbE+8+nbIdWmCK9VE1nzwahZQbH4z1eL0ylvlrlzsNiNhxwf +eEr94TWfwtRb7hE9eyfuYo95zI37GiXfrfQyrwbdnRf2pNd4vlSDY2DA12MndG2qsdqcVzzPmWjO +B0+5zXfI9S6htQqF40fTNRMtJ1eYWu3CzQcz8Ts2yZSqjxmGuHWj+Mon2A3pgeq/533zYGOfqgUr +h00btxgK9tztnCSnFPJfFLDW3D+fAH38jnAEFy0iGMMEE4V9Ow+hqs59FcgyyULWrn3rcXqOlAak +BIX4jIZoin4oj9cL2o72W7aWiki12KzoveNfePqwvOyTyB6X0mqvjJGdkyILFy5kNddY9C84Bk+k +pdwc0wzcPvmlpG06Xb1pxcO910Ois3f/i8Afb8SrtuTyz/A7BQ2Lc3cNnw68Z4CyX/0vMtMjHW09 +WZ0OrPSATmVB1q0vcsd1nCMq/kUBDyZGaTEOo04PFJgcX+PL7XCgM7Dp6dYVWXWfd83hi6alpppq +9TPVg5cr/WIUNdzP9J//aR3j25f3LwL05gpKqA5aHyjT3eR3hcXR5ZeMJ7lNhdD+LxKewHjHacay +DOiB4i93j6OS+O52bt4evvXFAtffkmov/0EMRGMLpDqDBYK/IvPeuoV4phU0lH5omgMFQkY8Iw6J +sjn05CrpNXuK75aIs/vkLBV+VeXOg0IzqbdjHNX5rxepZx30W2teGHquYd9cfQsKUh0xLvR8MJq2 +xu1UR1L6Ws6zklJ3dsdGI8sEXQQKj88nQl8oAOJsxouIAqEvqvjOv5mM4/NzOfj5/O/5cHA6GYsk +EmkhiZ3hl16efefbYnljPSu2xu0v0f4yMY8CiK0s9OJKiBHWXfzu1ebdzhPfbnub750TA60bbezN +WEYX8V3/eexo7b6m6KHaNV27TXNP2j/7NwmQzrGKezTE2/2T2rvyPfvGD71xQmZC89L0F/5CIPfC +Y+38XLfQG/L84+ihlC2hc0xSUDFOCBcMVFmU4ys27O4a2yu7bbeHm/AO/OSldwLMQXoTR0/Xmu2t +/kk+zQJ/h7Njvy5OkA7Y70dimPMMQ+yKoSU6vgh/8BwKjG7l9QjxNhP7bBHf8HR2ogGLAVwYEjvt +xz5sxu+p9XV+rtL+9LvLniV3LT1Nx/8k6Dl+BBjlop3Q9NUnSsdMBP1fPzfZEiLluGw716BiIG/8 +HyS4soCE9qCC/5yR75fXmhjjW5heUF9GKTAqoibyxv+cHWADbxCMJJEocNX/1JaRIUufe6kmwmP9 +plsKbPFdR1T8TuyFxZhO6vx+ueXsxfUv97RhFnS/PLX9ydlC3DCcgiOSjIGagapuX6ltZ1tHx1GV +qGB58R5DxfgVsADwHoDqwXgCrtAFuDJjKLHlOXpngm+S0gXvSZTp6MMrH74FqcPx4E4lKD0zs5YG +l/ZvWYB5UjTcdIalRSr2zpiGKCwLtQhoMRFthgPKQX7PWWUb1L/jxnPOENUNe37juKp/zQfjaSmB +hucCOJE0zRx/1nae5W+rV7KfOsANixLwKCoJWj0ye15kL/GI5uBPSqnEHkyK0GCI27lNFvdhBWh5 +/OK6o2TWXVU9fd6r1troS7Hg3LI14IrTZm+gbQYSLz54ZL5denR92OG8Zq8bkmKXuwaZI1DS4LzJ +PtlAvwkXl+Y8ZQf5kMwbNvvMmSPQ+3SGbm9MODLZIr2VZ6Oax3MdueqvS8ouwr4GGogheqoS8Fjo +Bd6S0Y6qy5vAZHjkxv5IjRN0lmqRYE5CQ1AQy+r8fJxQaxSbdCE0kXWjAflOs9aXeTBGc2s8HKHs +d/b71tSPzugl3M6Gcl/bm2HRqfdFX8I8ZXF/HOQ/+eaXu8zYx0d3dPZ56GOID1/OowCiaCcdcOyn +O/1XEpJmJQKe5evFLOEbv6Z58rTvCvbChqUrz80jiHHCouk7MaDmREDx8wUVqX/K8+XjtQvy9rxn +dWgeBcaa/Nabqz6Xb7lk+CD5lcq9x4a4M0FeLPOgjPuuiNV0yzO/zq5Xl3DJJlz0ZU7YUOc8KBVP +W7OCoKCg5SGkAtSvMnW7w3b5OS8GXp9b9O2snMK/SlCdIAmLrv0L3Eavxj1adu7Qq9PhEovZ3pnN +IwHtCMQT6BUIxUw3TBde1LxjMHmp08LegbuvCb9vtGJuFZBiTRA4krPpk3KzfaKV8dHallhLfzQc +hQbNNG3norzllorrn9OD1RZ8/s3iPCJGWXlbGB5xcgLCVHqDL/z2foW3lNGNUgVyzBVJsUs/tW9L +wlG0/Ckt2I/I2Psg2rW8v8T8VM+pse5zHxJVfjJl6F7SkO4kHxt7cnwjcoXpijtIKn734hlQ6rwL +x9J2edDna581/Aoz4z+Y1XX/IL+q3FnqnVXSSXAQBg/5dMbeShC9KW9xsum6yrqtXobBu70NZPuV +rmXCokQUbZ4PCkCcuCQmfj8q2qtfsX9Jv7//UKzKZTgIGnzMfnFaa+Q5dVw0hKnVe7lPRelJT749 +pcgUxeCdMXgw2sQSCFCT2+ctgiG9bLqvyH+CdVnakxVyq4tL4WhwdwAaD9UPtBANXFQGBa6M1WV1 +j/ffoIwSP77dab3i9oF6/Yk3+VXMhcBBC8OM5Z9T+dQSiysTblrKhhxqfSZvNuYPR86o4/1VSWHB +a0e9WHacDtqWI6UqvxqtDYeAyT76nYMr9bEEKO2ymN1iUkysa2v0b/0iWzGRkb1mRjLz0AxDD0Qn +WFoztsg915fmKqoTtyAgfpvVh4MpJ7/umkeEhMbS1poyJgQEavLsTrhbfk1Yr7TAAfGuv7Pn8vjc +GiAVl0xNuecRunH1Z4PLVXYtrr7sxn3MqFn+IotqtAz588mthckr7krdKbBYucBMixlIpg9HSFnh +1WP+z8Zk7qVjduCvj8c6b//EnAEnKhBOJAK0ZQhsoPRIjBq/OLnz5xkB//EfVMTBoWoOwSTY/gvE +VDgkyWc6aTMceLzRNFVA+GTslXLE15ObakS+w5p0BsjICXOWHotmi9N+ZYUr3m+kEuup/jmPCs/B +LfVQCzMdNBmLPp0Zbi8Q72CyLdLj2jM4GpzeJuCQwMBx+u0c2mlpv/X2wDIDTdlXE+pDqt+/1R9l +wroCISDQi6YyqONnLm6vRz9exNlqZLce272uTuwmrGWcRqE8KNiVEYAV8oREnovk2uU8SdxkiPFG +PRVr9OEVic+dW4SEdgY8EX2iZvvW3EmT+qs8VyVfNelnl8nXBlnBNi4SiTG1cz7bRbO8RM5EcgHe ++IWVqMmDRLdIOALKmzoBpgNMgELzig2eOdv6f6YZurXjYiLk0xYdRx1nCtJ3kVEYno5mrqenxowu +b17xvll1YePNVrWcE1k63SmVQfBiUBslAX9DksC5fNoOqayJW1ERpmJOsiHf9rK+X3RONVPI9h9w +EnTtuOxRbVsP0cTcvsjRhMCMBerdTjh4mEIlTjVVxqzibn3bx7Lh+eQXg4VWaQ+7dChJx6/MT6Oo +OCrNmoAalY4bxGJ2f0wS0rHmevLkKJrF8t6r+TXQOFoUyKljYrt2Mjm8J6c3OFLxtY9W9q9789PQ +zkoizfhzN+RHae4fveORrR5a/DQiy+pGAWxQP0sBGlU+OzF+4Hv21R17WpS11NWWynE9CoYFaXES +vcVC8fqUjfAZOd3Qsix340t21sPHsrX3Zvr+qPxHDZgxnMPCst7rSZfT1rzXQIo1fItuOFQBOwak +qzFiT8N8P798k5HxckF9U+PBdfKRmuMOcBgVD7fH/Vh1N1LworPp6nip8AePdj7LO1dyHY6mt/0/ +1v8VCHSs+1z1szikJ01xW+jlxNKswHVz0EAfpLkf4tI0PwsWUemrT4x2JK8N7OCXv39gTm5qsHqu +97PwAUF35Be7E23nc5PFPR7ZwI4bGOR0vDpz0xUfQvHWJqdGNZ3coLzA8+NLja92bfgnFWiCMYz7 +2Vn72H5hI8/FW/habuRd/QLrmOgwlAGBotYfTbXXT1IVN+0MrA5Y4BZXlcAjmD0XSB8qrWRT3uoe +xFmZ3BSfejZwm4qrnrDnHBgQiYI5CQaN2zg8omZQv12UOi52TErm48BYy/s56D89g0HS8oHyNcIF +dl8Wj6hFXj/na+H7fA4cDPFATPa1dYHhy5usg9YrlfwHb6x58kgGNr5gYIz6pSUCqR9c46qKTI89 +3vfOKdT8WtexiN8f5qSd6FstJDXsb4rrPbrVJK/smCEX8XtCKMRmDvCPhLplGzn2qYAPq03S8mvy +eYUcNdl7YN3CDBrEFqXqK5gFcV8eOSLYvqvuIF6SrdRiDgwYMjHejcI5Vtuf6/x1ZPNL+85EsQoV +ZHHADmPopBcSMxXqTL2g4THplXl77Z4NWSMqNrTIxlsefjhrBzCKgMMRwOksKp4CDE6gTl+b3zhy +2WWpeuvNNu/ipxLrr3y6OAbDoL2hTRVeSBKePm34YUhcbTzzwcbRzm/xcZqTnwmmW8xhQNppD1ap +bRi757mkS+cWjliurn0x3lFyG6YwDnhGaGUbmJsCufQXxhIRvx/d7d9tsjhe4vDhzH45gz84Irji +DAUur0EgiZjpfp34XlbEs7b8udtPq4stZU9j9RGXeOZGp5K4R50f/PrE1iR3dOG9B4UvJE5Srogc +nxsF7TZjDKLpdzJ93YJqfPr71pRk2eaEitzTi+emydSp0SzCJGoSH6Mc7duSdE3ZzcQq7ccx/blh +Co7ohIGeuMMzeCvryFrM0oyktIhHUR7Ri9d0Mmeh5eM+eAoS2vqLGlXbJaf+aleQwAbvgkdljq2U +rRLMWcAIMp5WtUqA+oJ96NOYPMdbH0vjhdlHG/9sBjNBHzwSh0EhMDiGp2Mlry45LoWqGapWytol +EeokfumAPHMeTYYyjdHbvuakJrTz69zgPMIbZiqAGXJPmwMCT+WBdo1hSGjQXUHeg7uE+4Lum2+J +wfXiT+r5w4S+qh1TZK7BeMGMOxD0dHfl6Xxg2fdLYfL0/gWriivWzfGSZzaPzIuhtksdP48nm9vn +PNUyFnmun3SNOTmjaeTLOu6UwZCazHO7dq+S/cbxccdJb+YglQjm+J2mJkpdB7kwEa+TXrqTOiLM +DiW+lY3EHZtNA4NyFwS4awhBBgRwSJDqvZi1S2c4pab8N+/iZWQ3hdsHSBv/oMgE4JpIMmg6gbjC +CQ0M7WmW2992+UKSp0+vctWO1S8kj+0ekP9EhGdpBzVA00+M3pvrWXZJaZR3cU+/2EmTm3GWTSwq +OXAw4OFwSIoVBgc9JPbjY2TJ3nhl68dDL6wN0q8pWucGwlEuJAIVSjwMrDe+WuGsJhFT8szVkB15 +YpL9/Hs4AAPt9qZl6dicbq3dWiptvvfsd8XM51LYvGspLbAMmUxFI1SUFTQ2g5iTv/HgB7NopP/9 +eLEcx8otctsDTOEwLMGFMStHIrgDA3Yw4oGyQdWPo9brbYkcbK/Rmay/82iDvgXsuwAFoJQOFOJi +GNH59eSXUiS3J4pDz9RGl7G9LG++7oqBw3FoiivBCWpxteqv1xzzlzu1UKLoZ+yKsuQvbYfl4BBw +dZ4XuHXVC+Z0oFM8P6JOJ+559uxOs91rh6tv9YKeXYEXoZl9YHRlObVQm5sgLVk8thM7GFOGuLRo +s6TK+ywSHExGY53pjRDE9H/kRNYN5hWfvDSuEBDGf8+3VAcBi8G0vLxzhJEs0/BtndX8RyJVf4cn +7l6VAcdSKMD4h4AlkMgIIhiJU0ho2jSIoWJBTZ+nNMdzye5n/FtibPiqECvnFgApls1X3rzVj1Mr +EPfZXBescyXw55FdcBSUanUmEQ6D+SA8WFFkDApSWJ1wK3E8NkUzP6L9xTOiSMrrgptVfypMHVlg +vmDr3rrm6y8lNytzXLq4wDWtxcZvdmHgFYKHtUDXo++pJJAYlh/q4INPF3HaWBw9XP1ccGCBtMuW +TjWR2QsxiURXNBI6DYh20cfeBodkk2TGFFmffv5wdyDngJHw7BZM8iECY2skmgyd2wIiF8Qi38q0 +bUzzse3edMUv1tm3v+0mHEJyIeCVEG60wzxUmhz0DxWI3hUetCreeUU36fP63nKmEAisVctTsTf+ +tjv2lAw71YCE7/38zhcOoC1TAC3d9PF1uV+17oV/XOdgKSnDWeO3Wi3+Ny4bjqVSXIHgH4OCrPJ0 +azF/ItOtmrvmgnVgo61E1asbyu2vLs6HQ1G1qexK8RuWlx0r20t+dEf+Pn6vZgMM50gAuxKZDM6+ +EhGM01W0V8hJDob47T9/+bKgV3j1l9iXbBgYGIUmUTDO0DVBaoVo8YPAV1RKq19hxmaVG0E8+7ec +haMwRHAhgCdguBi/gjRezUuf6zl64cobO/QjwxQfbhoyc4CjwRMJaasBd1x9sVqXL/fZkkW3laVV +hU+y1jovhSEYu8KAsbA7mr43jwwM8dCMM4aMf58O4zF9eIY9IOVnTjdq1DviHPJfdUA+aKHrq2bU +h1eHMPp9I5xlthoFqidgeaKCkgK04DWZrCBS/une2ENLE9Pv3eO9d4lvZZgS0DkqG8pNjq9JjUpt +8fDMSTx5I5ydErseliArT/UNq4abRazGOfEnM8vVllvJlogH9qrAMa5/DtW7AimRkid7xMoFzdgu +4OIw9SfNS5mAVGCEAVXC+zedkV4d2uaua7M2nDetki5BtcD1XSfXGetm3locOY48OlEeuYa78DtL +apArqaADnnFB48FTFsBcIv08ju+tVVc3nsgR55MISNU58p7yYfwFExT05WBOh0KfeVKrummyXIxn +04FLkeVnDKOJe7b7ecKjjLTJB5Gki2olQlFF4iq1vvd60vHiblfhCRzBiaiE8MSgafuiEs4gbf03 +lw5P4Eu+30fvsVTtGFOaA4TqXlpe4uDQkpHmS2EiKuxyl/YOVwfCIwQncIkpZGPG2ze2S/WI+rVy +HLlnVH54dfD25kp4iIh0Ymya4jyTtL772n6NhabfBWSKl66M8bh9Hx6iZZEga2TFzmbief+r0P0a +iW/sVjvU1VR5mTCAUUdj6aFp3fVzPw/nbn6XOXJF+4FlnI+R53lxWAwsHLKt13bR3uo3K1fLnURm +ubrVf9mOgisM5bRBwLE1dze3RqHKj7oIVh7Mya4FXrwkGABNW8jLUXactDOE/WDiOcsivW/Vv6RV +x31gS9P6hSd4DCe9mvMXHrr8ITa/9IbWu6cJfEeSjIJ4WJmhQIMjUh2xGBTA/rkYW9Fvbdwe4Xtr +Xd8LH4tR3JxaabkI9oadnMhIxs4AqB4xK1UGtG3d2e7i+4u6Si4tTXKccIED6Vvj/lqtBmosPy9c +GChv1KlrvTXxY+SDJuHrF3/BaDhjiNAlFyYfTJxUexGYM0R8x8Yq5XpjZEIIrjh4kK8jBk/PmG7V +dAvoczPO88N3HVp2RMhOzK2ABYZyQeHAzAFQS2C2whXcoEQ/3bZ7GVF3d/ERz2gPvbPdH64pfly9 +UJKJADBWhBFQGug8oPH0eeA11hNb/f2rfc+UNjrCCaApdCeEd4bWOr2xOZWi6e+ueV7mnqCYY7pu +gsEnONvnioS2Y4Feemo69s4pAf1kweAfhXGYCynXu9U3Dg4fY4JCGeHC5bdtTrx563F8aeCZDl8f +3ocf98MVd3eCZjAkN60PWvQ24ALp+tLeoJT1dixP/XLhiuOQUEblXub33XmL3Dc90uyLXtLMitji +jYdzSmDrpB3cRganLab/CmrYKRo6kSXvI4vSzfwfmkU4uuIOqM+tAQ2+Dz8qau3R/T1g18eSnP3y +5GWtO6PwFGDV6TET2NCnZUCVzs0/XzUfFRcvj3tMzKovDrvWlVT4DyqQWynbV+uwdtcPm/fej5c/ +uz1CGW2CiwlnoWgsFkMEwieaR0O4ebkD3RgUux9l//pEQvk+rZst/P3tn/O6cS/gwpL5xEi0W9ON +Eb74YzR0xcX7lyccZBW8VjjI1v/vaqASWejQ/TduHJnnb/ceGrjdU9bE+kJzXiU89Fc0bUqB7k4B +4wTZBSW2D5/wjyI6BcgfvcxMaqNS/Nsu/CdBaELW73XJUN/IRbGNfWovmnAnNO/q8c0rxjAEfzzw +jIsobVaFugI21776zqd4DePlCbyrreqcDj2O/z+rA8JQqD+UIrKs8ouqNK5EwnV8n1ePJYXzP2pD +cyYnyyeWbB2YHPn8MCSWOLInM0Cndz45PBIHJuXnq4XdvNtXcxcLeLRZ7DApdLfTLF2wH85//w/S +oCo722+Kt79aYswKnT0H3wid8s+u3vFfVKGUwoemijUSh1iE2bcGtV5I2lL9IXDNfFr0jlK27Iiy +0QaJg7sijXR/ccUUvHm12YY56oihzDhlil9CLzixvkX8Q5avtYe++/r79g27mbOgmwfHFLTFlbr3 +vBT43H71oJYgeErxWB5XjjZl5izkoUGMi3/d5k6Zp5kPRuMsTusdi2k+zTlHb0TjiMDYnghclOhK +QpKhBMn0IX8+6j9iRR7Z9y548GGdsKcwT8fXORognBS4e4sIGdFXQdr9BoaPe0uGK23fSRsFtaYt +3MVci7FMiIgkAS8UWhPFCCTojxkR2Po1ceCpCNftNY2B/DUBKMEaOK88vx7NtmbczQznTj1QlH1F +TGW4RlIQeZcdx1xu2j9ASQdos/2MMwBSy2VkPB6pl8Uv0kIcKjmfJRPT0/4vYrQV/APPBnMye+QP +oF63jdb5fuNjO7ONOYzDAM0FeAoCbXm1mJnC+fNdBqmrb/g1fI3Uei+GsXjIHAZeENDGyYDDI4Kb +5cC6gW7B+hqBq98cZfj1qM5CVlXfDYbia03nUgG3VSDxTkgSUMFQoAmaIWBUS1tCPWIcG4K7ame/ +ajT8c5RnlT1R9socD8TY7wfZ7nLs7fq2Djvb/Deen0yEUR+X1JmuYo6SkFAW77OdNk9vQ5u2Bk+z +QCP1UvXp+vpbc0DOKHUFRTWEBm3p7Hjfg4zRHRkKrQJsYx0/VnhymrfADeT/gJEIJdph2jnRb45W +lYvwHCbmmR2s/xKjNKDENQdOq3loJuZj3fJwEUTKoe3rlntvSV9glbCrkTnI2LJxnUUtdu3AY6/j +ypcKz+466eC6oi2VKQVNUfJs+HRerAnr4f6is7G3JmRP91ZheIDevB1J4LJr6GMPIP97Em98+pR9 +2YKOa9y8J4rutmh8ZGIR6Dx0pC6CcYwdlPtzbX9yTpjrYK7SWHrcDscTmg33574FoJUSwN1hPjhH +Au0UzQHLa27chzMlE9baYfw15A2WZ1bywEhgkYd96JcmkHCzFt+xLHWOLEtbJvQ0TdFNM2n9tuLK +fLh+AlwaiXUhAKArbTJHwu2iW3Cf0jajO94iTY9V6s8qSMFgBCSaSDtSatoTmEdVSOkZWa8PP78q +3FHf0GdvReoYHErLBdGCevrplxmqmoo261ES5gLviInD9rtHt7WR50FBbPRO4N4Xpj5XJoN7ODZN +ZCd2qyT0wWFEhBP0LY5ZZ0OAAu2h6i973kXf3pPFmdFy9WyBM89HPRgB+jgezIXSwwEBEw6dLUdW +qOks6r3gaqq9csy4HW7gMiMBgD/s/7t3f8MPgdKSwzH9US6bFtfYwhGOwAgEyk14P9aqL/pYZRMt +pUdZIX9XtGHrU0M4wGNWZOiOIkO7UDOuZwbWrObZybu4/9i1E8djVuV+6mFCzxyV4LAM7zN4/eLl +4pU66kt92HYZHLqoGbjIHs6bwQi40z4tE7B5q/nK96q3sNz11c4S2g9PXHNyYi4AWfqpi3dY7r4U +ZrrxYSWGc9vjVqVn6VHtOvOy9Os6cqOfJ1Xvnejehd4auLbGCkN8AZf+mMGSsa6MCye1HwsIq1b5 +oneg83Jy47ozjp2kn0zgGZnnGXdu6eCm/Ob1fXbnW7gTHoKkAYXds49gZwiQ6JNkhJ1t8Xl5Gy4V +14blG7aLX1b7vDkYvjwU8TuhoT8gXFyVlZRUoD20a0Yy0fVvhvv4NYwI7xdnS2K6fd/AKZB9UK4Y +2m0jKVT68W5f14VK544ppYyM7SxHrdm3Z0POtSg4GPJ5uvSLg9txyAhnDIlMgXb5QTbP6WOweMnW +jAuLtAR2fx4IadSs0YURAm0t7VTdipRTV5azCYTt+5K5etHSZT5eK1dKMwXAc+toASvaBbhzMj21 +s8SvPnIlpn3rlgQFxU0TqzJlPnyBG/jQNKhUWgCh0Ocuwcm95sg67pVCMcFnwsc7heDGM9OQpxqI +Xa6yGNpLEr0gsO/N59rn17w+BpDh0lGgw6M3BTmZwrC1l8h1/HIP1naqbShRUGlLYEJA5hTn4gw5 +aN/bA3HudjcGb2lJ8nEqqaDKrQvhPBDdtU5nypHYmXH5RGDmBsUJimqpaNfggVJxN9NA9AMYFTL0 +E0rwi7VXnFWJcLkmE1D2KfK17ZmNLivgADQKuIonGloRwnokvQ35NU9UIT+P7d1aoqNk3U1VeIaE +psxw0kvqDqK19Gs8PO4+UU0sLZd01iVXwHNAQwUPwIFS7Op6w1cMDLO0LEpvHjh16hdHLlc9XND5 +x5TQqn5/m5oDg1Qbg0Vu1GWa2SO6j+Di3ulJoJ7FAvdVk+9JNLCzHH126DK594IunDMiUx0p4AQ/ +iQAdoIDEQjC7s98prtqvNuHn7SWlv2jKGoZYmjOH//CgP7l/sh56y9oW8cohxOVB1iNVn6VnYGDa +aoJZ8finjqoNKQ4K7Yi6rPt7K0W/VQWv6IQh6eYK7MBU2rlZd4/YmwW+2cilZzSUsvZMWV6Kw0Qc +DOiFdmTMfaHJU1aIgnRBUAjA0+DoK4TkOfiaNhZapqLiO5NrD7mNxClnR8Cp0ZZNUVwZJ/G+Y1tm +N8Hb2pjqu3anmuZviyV3HatgOO/NChpg8eafNtYa+g2XJdkEnipKSh/VdeWfPYvtBZ5YRgA3pmFw +gM/3RM/ajtEe4Oj79EObs5cG6VaMeWDFjU/3ypjgRBIaS6Dd4+2TYpdMlqe2f7muuz+47SRfwpVW +GSYUCU2EqmPifhiLmYqdnEaALPL5/Q3Vga2JC+ERsPTLUH3OzXUHXlSLOyLL39wr2XP/6azJR/Cl +g+YWOgfJBZqjpzdxsUjegVrRt0cwXbmsBthXlY6bXsxKAjqhHalTwQ8ILOO57rCpL37fxTvaP/ZK +yi3aUfPg2l+AC5r2MQMKY0fUKLZgNTFZsKawNe7iGPdOid4QGUdYCjziCHKGeFaZTtmTW/y899Z1 +JCmfSFgwqAYLMAav0DG54KkS7VRj/YOVB1FHXi3S2sZ6rxktVvwUlgSXOUyZI8VRb6MRA8PY5vyd +aqUmDmSpp6TXsBQRPD0VzMY4Ai3QnTblD7iiZe5+VdbfDbdYfPthsmL7g0lYFni5aCRgaelH3l65 +eqa72WOZx+o487hvR95Ikm9VpTHhaAvEZzZEFhGDXsTw4/i4J+JLjyovGw5bqDmbxSJ9gLYL7qCl +n3O32X7PNuk9Nc8O/5Z1yo0wZL3y+N3G2Qi0IpexOB7ch0AguNPW15jpOcqVnv+12nf4WnpEzGqR +U9wOs9YA0fYT0o4uox25BVIo/cxfaVYaAq8RgxKezYauho2n5GEoJycSvXHJ6lAdRDfdOpvpd7Qk +ZAfWulT4kgcMQEsiY8hEcL0k+M7PXS1T2sci5bZta0SsXYAP0kog9sPfHLRIm+HzZlyVfxly936+ +TAuPJP+UrauuVJE58m8yoaHsD/090mZdMKuLgjeF2Ib7JCk4pr4ev8vdygR1nrHIPCnZtsq/JGkj ++wHXHATXudNR6zfrM8VAoPH7GMeuRj3vMQVMW4XKY+tCBQ5DJgD99UFvgbFDc2qfBWBdoG5vHC61 +ymJLTq3mmBV+hWDZt2UPyTf+B73phhH90uN5S5fpV6zM+fs7SMhsYdFf3vBC0JThp7Wa/jqnX22Q +4iq7vlOw9XLaUm6Y0jM/IMPdvGcotHbhwRorHkN3Ve6NRod102AQ8OShGe6wmbNN/WMSpxanv9dY +WnUfb2SiHdvfFO2Z6AM8xj3uWohcrqPTfPvlqYO8W46vFRL5wCnBDJ3aq0P3pWlbHq8+Kvfb+6xe ++uqq4zy9ug+Ke5my5KmlUo70r2zl3c+pyQ6sW7+dO+5V/4MngfZvLy5mhk8vcZZuUc9c+N6YY2J4 +5OFwCuqddHaNKBMKLL7lHMc1BfxPbunljwclPRcRTHQkJuGKz9icPtVun/ansfYiykNMIq10z97V +Mszwb8EzZ2Grl+Ngf9TA2ffKKeoDZ/d6NYwEY4ID5pP4s5rDKqwWeDh1LTW5uPvCF8E+B6PnZn0w +GvRNArTDoejVzDjTerqpkLauV2/tW21n8E7uZehh5YU8Vr+H/jcxUKW+b4350oq1VI1KAZ4U66/D +SPRZzn9Vgfa+zNBqmSBj/NYc81DfZH35Totv+IurJOt5tBhWzZVA6zU35d+IftzGhiklFuhcTbHU +kH5ZfGkeCVqGGjozH1TwWt+uoDNw8ovm2v3d/nEJjwRFOrn+SWH6OXLayzbZBeGzimp8xQcOPrwq +ihY6/U8SRCTjiMFVKxXcHTco+FqoxmYdw6TWNB8LdZhHYmZtTn2LhtMmvjJwGD3SU/Xtwdd83LJN +elZv/0ln6kgcerUcZUFvty0ObiKJBgxzWJge9RBZLsBUCBozfl01pHtTbs2JxRPhTkIjGw7Wrl0K +A0Bf5mLYWvqGDZrp7/F/kiZyvjLvmEtfU/2CI78IJxY/ZCZgSd/X5kOb6H7Kpq5Rzs8xvvS5mm7/ +5+E1cVEu62FQ2he3Zjj7Y3qiFs5S1qOJwjbW9ifQrPUqmn9jsF8+KtZNXnV/4wmdoVAj4eP2Cj/E +Ok8E/o3SvCjjC7IzPHGlpFbN171coXF6Wbpx+4xiU1YetYLBvUHzAG59nVpSwLAuB7FBb+qiipVx +9+MOpsSzBxRntAX9LfAXlpmyPqCCL3HljRPvWXOqSFd/3RKthcFmnM/AGzTEaVw/Ul3O8d2x/i6n +bnzGeYW/CfpWXdrZdoyLJR5LUHc/E6+5eStl/65Dxf6trpoGf6M4NM4RTSK7YqBX0jWZcu2R0kFz +5ZYNVeFH+H/tVNvRA8OQXciYw9CrF8CqWWECvjhLHXq9KO6zsBHO72IGDAB9zxAIR6Ftnww3VNDb +XP0imKV3z/L9uhL5GfIBETst52JpX+sAHtGZHu1vYHkVTD5z/FthdUr4Jqvon+nsZTbzCFhZ7YZS +8DhUWYSebwebmQXrEq2CQuGA8x1/kwSC4wwzI+YRYLP+6Uv5Bg6FbV6F+IUVfXJ3/2aAtuo53U65 +Ow5K47uvVVZGl1tIeui6a4tnm8IxUIp5qRXlgeAzdwGxS8PKnN9RP9fgnl2FKzxjc/TnSQw6IHx3 +2C523ZJss3enl1990vk3Qjv4kNb8oU4LdQLdTfnN26peu7502JeNGdVryhi8JMyEBfd+IEkuVBxj +O1r6YvM6nVc1uwbXtbGHFXrt/Hr0+Skm7J8ekW7/pzvjqJRpkVZE/XaK7CACw7kl+LV7BIzhmcO7 +/i2ZvEewetc6Lg6seyzbpJQD2hP3GvU/SUJTZsTuh8se86zXkXfdpV5cxTuQf3nvv4lAHXdMPPwb +X/ZNzRXpdSIDQ4aKPO9hYizmDvrvh1L79nG3rmNluzapr4vV5btmOs+GN/+LIqixuH8NPqT5tZhA +lAPCcMUjbXmZ09rzaUx9QBkUEN7td3JivRA1OZbf9fTyOj7WI1SYsIp+TibCg4rGolyBiHmqQ/Dg +ZIiFkztcr37OqPm5KOT0gXPBtkz4P2ONvGDeErND+ObxC9cFLO9abea7VYtjgv4RY6wKJWXzkd5r +FVdiBMl+cZnX1t44NCc5XWHplTaP96MWl71oCNccb+b3bWm7mzgnOh1TPFpWH7xdr/jjaBOnYaz2 +y/y6L9Q1zFBG9ex8YLLXNedGMeH5DnlbUfvIKw8CYfwaxEwd4kF2mXLEh0/p2X1zclJI3jaISEYM +Cm9g37WECQ4bvmz6Som6L6Oa/DIVZzey8YzjE64Hw3Pyf4Yt4eRb1SfiXh24+PZj6qKs8jVG12MS +mAgAbYMKhty0ZXaLHh5/GPf6uHellyw6ySbFZOXRfYLwIAUqH314nbp2asNdmbMrl6zAevdJJQjC +xK6Awd/B+PAnSA1X+Pe7NbWbpRVOLvBKzcI8dfeJhaXobmKHxfB9VsPbaZEixsFZqe68KyU4RWDK +06IhxoeX6J5xouh88v61djK32dUDvY/9JBS9XH7vb5bqRITWc5f2qjws4LQt51q7aUvSgEkeSrsU +xrkApVUBZ493p38hd4Z1sFvM9do9lpf1Wu+JtnRBCbGLKjiYIRMkANu77ntzSqYHHBC98uSqL+uY +4zu5LJFyGB48cQEcJ9EHTiC5/cQWvpigpjcCjWo27vecWxXse9uYkGDxyKV5i+0Ohlk0Ue8Vemic +kX9QLTHryB4nDNIFD9wUuHCIfpo6dGoC44w2WgQKRTgIw51eE52in31epmTdDpA5IuIi6gcvRZ7S +ouUaKARaripgfMM1eZSfz/ujEZwJaUvszkVUTsyn4Iokg8lxMoqEcaQvIW9Rk6Zac8ZekQ6ySQpW +Mh6Oin4ZOq8M8FBKjAPo6CtHHQlO00cU0BsUmXYkPtTRoIttOJWb+eqztG66+oEOkUYV6nLNEff/ +bxcDL/A+PbGPRUTOI3nr0+zVwxZywopZHv/5AngCUIaKp2UweSzfXrOkpkff+XW3rbRHOPdJjo7c +f1YGl9xM3ThkPKvkvmo8rlobyzfaeqKVImGOEcD/X9WnvwHi+S7DKEjs2eEy58uXjYbYWF+9eaL9 +X9RpqYYpi//4IWvvPXVK8dD5vMLOmIjI22qjTf9ZFsozjH/jvVA6/LD+1bXw2qf2UUmD99//J8Hp +fmbZlvFADLn1aZ9rW9zu9J4Ayxtbev6L5NRDr/iil5/OXtghjdU2bUGOSmNalpL+iyB4LBRtnUXZ +QyeP1uOLtQ97TDYGBvpdX/dlIv6/KEIJcFBQ9Uli0+6CYZtfItSX3Ka1b22Cb9z4N0H6Lnv4101s +rPkhM7xuTKmsbEGfxKnHWUecBP6zLDT2TmlzK2iLyPd8ZCKwIi9GgzyxoOQ/CdJeN60CwDlzRg6M +vcTo/FmnnXnmvErlV1h1Yh9cjf4/6EMxVebEO66ujuSjn0rqG4mfV5zeU9n5XySnKrXTzKiVpSxU +83ITq8IKFQEJw69ti/+L4HRzclv/egXnXa8KvltbairPZy57vYDr4n9RnGpOj0hsR7ou3Io36z9l +H6dnPLrymWTYfIKM1Vv0fxKpjqDfAdWiLulcPYZN2h8b/cQRsznV1X317/751GbgtyVkM8O+Jur1 +EVHv8s9h41/uXF03Hw59YHPa7c3YtXW/OFXyWBvlJf61LvnEZe+Clswt3vOqQevIaAuFoXDuF3fi +5ujWnyycOtETPPJrTG6GPp5fA48CDyNk3BOoE5SnKxl3sGh9fhs1/YukkJPs5Ldb8+mAk4fQd+4Z +X4ZnDHym2peLFMsXV6XVza2/yrVPvSkUUvs99vs/q5KoeFr8QdsrqKvcV/PKOGhy524v//ViF6SS +0u78V2lQr5ajf0TEb1+w/ejTJiMt1QPJW+NY/lc92urPGUZrYARBGmPR04y263xXzn7qRUfcEfv/ +Kjr78S3O3/q12D2t+L3MludRMgOCB77ZztvPmCiDcuLBcje5bcTTZETfnguJ5GoQNVJ1/l/laCv4 +GY++GJ2nnXGh30zxcmfrXsPMAn6LZzH/SXH2c2v/cnARz28//NBpuXWBSvcnI3sB2/8iC2o9DDWQ +cqfaP1+H9Fi3cu2k2eCSkt75tOhHd/oEXsMd85EOPn5Q6aRmbaG49XnT9fOhs1ZGQA/j7e7VuGpx +rduBMHU3QrRr4gafyNlDB9oecHAqiUomQQuIPlUfkOpFs/P9DhQWHh00WXlGfGnRLAQPfXQShQa/ +IgrYU/LMucCPr0wErTJS8aXPvz7/bNEceOcRu99f8FTfgERmtBFcr5abV2AQQvar1pVlZQXrP6LS +0uamoUGOrWL7ayH+e3w4x8gl4peWVmTELmNGzThWfuUvYzPtyw53Oqntaycz3D888Une/ic29ZVK +khN0wKYnNCDs3NZb9P0rFe3/dv2bH+lqah2ve2XmJaGFn2kPmzfKFgxzWNxPcAlhQb14n+TTPDcJ +VLAjErhrkN67bs9Lwx0j412D8q8j3vF/+v2dw/JP2mXW953Mkk8U7hzU/6zS1WSc4/L2aTYH+7c/ +CdrLY7wG8tRp3YzkPs0LRBpEC4U+qxz5Lb1vlWpJj/u2Ck9ReCWwdO4I6sOhIMfCkofrzaKvt5+0 +Jfeqwpe2BO4Vg0JPXR5KBbBvMzRJunlskdIDq9HSHP4frre75qSh1RDt4V+za8XWvYyO1Va8uawm +RIFX60+IlhihtwUQWoAfNlWOPeVZELqpxqd7j9YZjiGPP6GpioHOnoFusOFMxc/kUy87VcZyNxs8 +sgqzOHHL9k8MsCYErOfsB3sSvXfFnXG2/QnaOeRd/LZFYt/yVzHhwK9dQqldPHTEE0gPvQ9Q7L/Z ++NDuU6DVq3Jv0gbhRl7mNJS+Ncl7oYVIIn1NiprIOMcTLqPMt4IJgSfP/qxHQW/C+y6nH46TbzW9 +eLVi1E67Yj4wQckkTwQanO4ioZ2p9GUf8XdGNQlpCjJZW3pGlv+o57IMb37LHAcJufe+kR+2I1Ka +K4rdMtRTxgxrvvD8SYCzDLO6Bwga5HB2PDgy/pyY9FNTotR66fJ2PywMCGVlZiRlpHIrlM4aU7zu +P2vaYWb+IZXQKOQOg9FjRi9XNB5Mi5F86LG3MAti+JIz5tkW7lXrBUR6NCRd87iY4rS6nd4lcFio +2eG+S41i+wGU39UytpsjrqEv/4Ch+H4j9xnD5fGbcshfVURq3VYKJYTNHjTTjgqlLW+DqqJL+TtX +ml7p06+XDAbGxX0KeVkoMACaHj/Q56Zo1YhZKEqVeLAjFPvUU9477vyqrnXad2BYPPA7eEQ145zh +bla3RtKp8JdyR5ou5E5MttvbFZJhME/cVJSBAd761PZqobstlT/HfnWs0DZpfO2yZ+2CwUuL/8Cn +zjUETD79xOdVsaM1fGn8/oGWDeqLd1VXOAqvY59NQd/KpWDJM2zh69qD69xGDYa42RZ95PPL3LRP +69nsBTdkJLSTeip7S98fuW1EZLxn86pAvquWqLg1SnVNX07NXu1GJWLR3tNhycvyR4iDjTGfmt9E +J/fvoJ7I0rGeFeaBh2TSpwPhz27cw3Zx0+WTKcsLP/DohFrkhO+8xz9rQREa7wnuNIcO6aad4Qa1 +loqP2FPRtXcqhbjDzw9ri3Ssl3hfMwsjkaCg/s8d7ge1H57l4UBplzaGb9b89vV8wQOFhj84ArTm +jYgkoemHAk0t6hOuiR0XCI189GvvdraBd8bW1/dxFsyCyVgMMIJHYomuSEc0BXMYPWN0Ivg8rfae +bI4zRwn33YjtfHfWtN8QmwcGV74DPR+DpG100UZ96n620LWGRdk1fXV8i8/RVwWlcAq0D/VgnKE9 +d1Tw4HBwWRyZ/hXIOMqj/a5Xf7ztbnntPrhPpc887lY7nIonAeM045NpRAIWS2XUYsn9X6hA6/by +guZiTeWaDSE9EjrlMBqMk1EYlmCj3FJE9TpnruMOEd8lN1e7VnK788BgTgQUNMGHdpo15w5+nxSq +h+ZtRe5HCcsVdu11qw9yNqhofffOY26Z6bewyqY0cJIb05Bbj5fPdWb1qMbr98OxVHDCHFyhQF9P +CMGqRdtiBES0L1LYijoG3OW7Nm8wwcDAjKdnPPZLFSM/JcFLZidZy3NxdZEjyYPkxzDY9FlFU2TJ +skpOign6zP5OLuN7bBlSiKtb98GQWIIXmoSCNlmCTd6ZQJp9gtbYghi/UHdhvM+l1LKEmCwr71hX +DhgZcH8TOH9CWxhJRVGojJSj9lU8S1TWZykW609iSt93HAqobifDC1ABk4lCEqEW54L2JgJvAWp1 +er6eCRMPKysPnONe0uJzSdvlhg4FVgHcbovCQHEL0O3omX2Ex2SCT2x1cCC38Uqx5aEXOrdrasHQ +QFsBJz7Ac3hIQH06T39I+qz+Clx7ZaWBAGLhshXHLF8b9JXMy884T+y2/yRr3dfuiptOrSYnxhSW +lV8aWM6cn3EmJJ5AYZwImcSeXpT2rvrJjh3fCnQvnN342XvH/+PsuuOpfN+/rOhTyahUZlbIJlJ2 +VkYDUUrWwcl2HDsltJCZjEJGGcmWmchMCiGlyCpkZUf4eZ7nnOM4Q31//3w+r1ev+/32nHtc97Xu +6+r8Jw6wkh6kaNBrBZRR+J684cDU4hlhdkRappJ+P3EOSLc1sQHmEo5OJds+TJp9t6bYlCJjMRr5 +6SsZxQF5TeIUOBKo0Ow41eCVsHMG4ZOtux8iy28Jk9FvBraHbmrvMK9Iz9sjz2eGa78qiLd9kyJj +ZScOW5MyNqjyeFgHV3wXt1F8X2l+y+PFxKBwZ9dZzfpeAhyo44qeP/DhDQD/GLX951hFUQDFcwfb +j5l11Ara5knE4eZA2RukDXTqVcn3SEupst1+T3tGMTdN4p4Ky60N5czBFkGAaQnWkQOkFLoqECC1 +wPojWEGThle1/7keH6r/4eDTVyv0R8Cd/bosHhswHmivAcwH0EEIs5EfTOUYJozJcJ7j4lJptDLR +ulRyLQ4XDYxTSX5Ro3InR4cR/paVdOrXtVvp/uobxwGu5rWDCrxuQrW0BOwgMIakCI/8NitlmcxR +Y9Tw8TXZM9XOVXwscLFD/YPMMZoVZM8IsHLe8vN9NbHwXl6R62F977GWVOJwUNRhCMDCRlB1lwmZ +zznZnR5qgxKhnAvb/mhOWF8jzgJqGUCzQ5gb9Fax7nhmzfmSKwXBclMrGmenBR2pZDZBQ9lZ9nZw +VJmpG7p/THWfNtm+vyy3YvG4zO+Dx43jf4GDHz0l9LrcoCpHMWvgRA+iamphQveME3EcYLzamrht +nD2l35PvyjT6eZOtvTn0/6gdj9+jSkGcAq28Yau2+8v9ep/VcQytegtc2UI11Meg0uFBnAEz8xjD +i/aq1Czys/Xe9ktLlbZOUw+DdFvi/44H+muubXyYhQX65bqsopfmIe1Efc6kW4kdjxUophnlaP+B +B4CepMoUr0I0se9fvMoaaCbsPZ5jPEscumEO0UoieAkCPVrB4Or7BnulJAG6qYNL9HnRnXbR//ks +/3/4IGcxwMguFJ+T67HtqmJcqDWLzMyN0+cY0v5HRjA0zyGhoz7hTks/bP8nuN+Do79FN/MfaQB4 +7EO+5vY2Mh2SQdGSJ7ZDq9na1GybwMH7DFQRQLSVPGczj6nJEYPibkOux3Q6/UfnFzdB25sDz6EA +gwpV937lTVla9/TQrYBDT8RLPJKe7XFJ3kscj64kAdwKLmtbxRyo6gP9C6a92kXhAmUxepme4pP/ +sXbe3GnS+F5IZxNGpC2mc2NALo8S2fHk2WcXUsd1NGxdkRY294kj7VEFUaPkTBSKv2iy7xS738g+ +c9fw8Kv7lsRRgFGAauuxOqSrTnvk4hTrro+KQtKVk3Mt6WeIA51gtvYuMAGgROiG5atl912mqiIr +5y14E3koczLxZKCfz19ZNjAMDzw9aWgmq/3pfXGh5heRpReHn7AQZ0DgChy8M3vPYjg6RTOjdWJy +//APjUxOlgPpZJvwramrcHR7vPV9NX0qI00lsKriicrrkQp62N5A87Hfm5AgTcEqJwDyyYTu4KLz +luv1lVG3HfN3xX5N8/m4CXK9BEBU26npRb6lHu+B6UzRhZM/pBpTNfGBzmu7BcqIouO03v3c/6Ey +o+Jha7L/7HTTWIRk8cZjbjjAngLcN0gnaNt8qZh5N6jbg7wfXSOoUlCMeBg7FY6HRoA3I/RACCOe +gac7C90sgoqPm8nF212mDq4eVVfPIcWfYwQqSRlzNLZPX0ljqrGUKBH+7H7jD91re1fxcgKotd+3 +tsIb9ghF/g9DJ8YlsheUVYqwvTvlpi7uvEEAiX5+om0Qu3WqY/tpnxeR+QWaXvJjD+zxtzYC596A +iq1i30J7IhuZQg4X0zwrdIreskcipvHAK3cCNPbo6jpwZ0Bhgq5f3oDdD7rsvl154Eqy7UWNngOZ +Vwy+YEFgTnH7SPezhOEY3biGuHZ+Lu6+6UvqcgSGA3X/4GbADIH/sGGOJPL7lbhSC2QYB1Vqb28v +iiDPTrlJgALfgwF5CAAKSsPyuxp9z9LjuFwrpJ5/1l9yYbPCpwD30IZatJkDs8zRQ6mewrfPOk/s +z5z0Tpb5goeDdi46cR1lKK6ZVjDoSQ3GP0V7ytvfVGlhRnHhCkURsmlIuJfqKDEyYPoEnF1RDmUx +g5LinUi4mIH6p/8G7tyZ8r+m4EYECcYunkX1PRw8QfmDlzJdqy9Oi6E0eeOmwkwQlNoP+Yq43nZM +/ElPPZPNzib5gJnbMUjg66YgsLbD8/ttZ5Vd6zNHkWN+2qnbY+4XU2yI+1uYIJyBfuKoQDdWm43y +mS3TwhNMuosRPxsfkncwvv9kObMJEiXbjSXfxt66Md/HyxKU/XtektNTy69lExTUg9XW3gzSWy/d +27fEGlZ9gKZG09XMqeJbdqXug7+i0QG05KBn96iGEawVqu5Mw7A9d4qLPMn/Bgb9ipeMfBvqKD3v +U2m39efFtI3TdedvhkP/vfwiN5tvPhPbLkd++1EOsye3exd4axOcLdxuPSlZ+I5TvWVgLfVvDpmv +1fbSLvJ+FEWbYe2hdnIXpqQPHC3u2vbqWcWFS2Z8z6zu12RvAnMwcXIGrhio1DW6bbz0uT/z+z1P +tC8aD/+Q6Ljw5QDT3OnNSGBO8DXtxQwzX/OkMewSpL5sPj/bpqYvXZ7pLpLbtgneCWbvAL3F/0j5 +VLKqqTmZw64t+Nzj8h/W7pVJmwKdoaqTYj4NL5+R2FSfs93xbkKzSrX4BE3eJjj0+miPTNsPpPMm +WnCIJ+8cYircP1NqvgkMnCQwHnHweeb5tPe0RfJnx2ueX+DZorq4ISneAgZ0IrdFNZLK13e+zKQZ +MvCITDcvu8v3cKV24Be80eDVVdrlKDzGwXnBQfmeuz/XPlOKC8kbEtGBkv1ge7s1qQTGjwB6p3Ba +uYOPE3LDI7ZRTWrnWj4mS1zEA2Fa+wL7ZG1jQ6UyTdMmDicmnGeeTr23EqCVRGH/4wYdHhTaGusl +CfSPt1F3yTZ2ip+geClrs/DY5Inq5KYgUMq8OUtv9N7ml7xpM6M4xWP1vYoHrtJvigILPEWMxDY2 +7OradVy0iIIqZNtLzoW9+L8NGwVGVK2lTBcdtbxCDs5JSNUlUwZdZSsW2hQFluFvqi8Q/NkWJGVI +OaRef0IynaGDlQIXhXpHZYJ0tofysoBVO7Bv2Gqeoe5yznbOn/IzvoEHCiaOEAFikrns9KYnbff9 +2HPxOd0udqc2m6TxuZ1EMOh2husroJKpk0jCmORlLFnbY6igGvYllyl1I9gO02gYcBOubRQndwGE +FRLT26XvdufK26ffq2RLGkYp9Vhn7M6Gv9vI4AZDJW6Dgd/YM9IlfqE+TVSBRXsnsjimqKc3+Dct +nGAwtH7zU0k46OX5t1ZG6cnCr0x/OuuPVmxoFWmBEFhv0TnwLiSzMi3wo9m2ye/njGsvPGjQHMMd +7AAYBdCaYQRM0fO4g2lsSUoLSwE2DRldsVvn865tgkOf92l+ZX8JZZNFd32WoQ7vdyO9cLty4jBw +U7yVLxD6aXs7/N1t5iPvu4aHkj9m4iIgb+Z6hTu0Lyn24DfFmkMj1tYPuWKfx44+oI529sfBrqe0 +alzvbQ1rGLENeUzrhggrtE764HeG4GAwWABuXvSvOqeeQAFPXJywV9Hz71x5I0tZzfYVB2pmtXbu +12wTBCiQdH6FHxhonFjKkYPrDcyevf182r2SEAA0GQ3Ye1TsH1F4DlvPC5zVG5vQjjTAGwsUDLOD +WULdI1Et66gFVG+07D5lZsGLHOcQCbY9EDj5nSBwYzBz+9O7qXZpPmm7dZHnJNLL335XFKDHha0n +WoKbiJY/HBHnpjnqxFtfShKhajSzQDlNCAKM/bxjx3K9aOd8/NmPvu6jLZ772a6x4Y7F7oagXpbR +SYXIbzpQJYaMnhc1JvW4W4833sEdJZghtXHtOgTrBKLcffMsdw+2LHfd2McsHl1bqcPwju+ILREK +0JGvMOGS3Xjt2/2x1WTRjArxwrz2PbjDHVBKPfTfNSTYXHZNewbjR2D9ghwPmtsc3SrOahqyx8Z9 +j3E29pETYwH+OhgYwHTBAUw/4PEBSJVCeTLGMRE+XKcqMqvuy5zt1fGpiBiVOQzjUoVajEENSdfs +YBvAQAR7pwOc28Pyfpq61Og4UvfDxyTZk2JSZzn+hRP7u7y/BARalNZWu8158VZvM6dc+VijSZxj +7R9QYAEHe7gdVPQY4YROAAMIPwcZw80qdB6Gt1jc+sGF7NzBeAz3CK4Twp1QGRwoHwvYCQsQgQBT +yNOWh0KVauK6v8KfhkR45Eg/PHxjMyaw6rYNdJvs+fTOfjvHVNIZt5J3SIcPgqLGfcvEsAT+dG2P +ctc1kb3Wi61qL4o+XC5CMs80EYODuxYoqA6HJiDiyz65i2djlr5LTnLqvWAseuN0L+NvWMx3L66G +fk8sDQz7/E6Ma0SnARZpmoQnhTaAkU7QXtBkebzcbh10jVUZrlX7iMF8lfVCzibA9T7xFvY25iib +P+fnaArDgJR/iFAs66uCvvu/hozwjrXDJsel1Ec5W6LIJ7XrIbuzodOfEwqHezyJ4eHmULsNG3D7 +gD14AAq2l+2/uf1dduXY5HxK1m08Mu5aSkaUAv2iC1DGnIACOiAF3csr9pmtfmrzku/JWgvt627D +rO/9jQKdXwU+DANIvPza567T87doczSegNdLj3K35C0RI0GlXwDLgUBNJwIkeVhFa1j5x/tzjBFz +5Bu+il2XpDPliZKg3IwI7BMPshg/oEwVtvfisdt5f2cIf+A+Gr+B55uwrD8/BMDLBuM+7ffSE78X +Fz+mILVi3rLgG04MDLSkga5E1Dc4OyEhFubTlFxXPOgcprubSLyc5H++/a15lxgLphAPkNa3dgXY +OoC1tMyhxsrofb461Rv9p/mo+PKWbWIKffQc+wzPvP8fGEGOe3qTXk9ItVeKfr26heTTelpTP0NU +/CHAJAtASICuhP9VeiKs4Q7Y3QDA1CPoCMDMQTZVtzIOkVCD9vgz8j6e1NNv2w+LjBNlAx/AgTDt +snNv5SxOPRYk14zYkVGGaOunVSQKQ5qu3y32FmBTJpDEyi/3axM86mrA2GOB1V8Ugr5ZS21ESVDi +G5TlG2Q4JL2La5x+f2xJHf9vhZ7bvktlKrcy7W9UwL5ZX9mb/kkdtF+mrkuW7WGLNLg6AvvKUPE3 +hvXvwAiChe80vYv8ghSXymFSr79uva0T3/iTGA3o1sOYZNDmiJ4rWKH+tKfvUeZpg9LZPHOeLG9W +fDwmjxDrJgDhL3y8lq8jupU9BO1nlj9pwtQNRD9uAt8givUEH/7HIxSjVLCT5US2Y0DvqtZ7Alc9 +BostxkC8INvOc1nfyie7RJDlj/UdHvLvMZbZBI/zwwvMpAd/zFBP5zGdvWkX+EHw69WcuU3QaOEF +ii0c4cHedCCtVf+JO83nIzmXt3z2XtY9/XQTKrQQXT8nIEvi+0zlswO8Za23M++Kvbzh1eP3jYAS +BWliDg6QkMC7Wkh/nLDRFxx+xdurkMQyo/PA8FhDKDES7PtpfUX/y/0u6BLwctKZxovTzfMOdS99 +500iDKAqt37UUPczFhe5VLCIRZFn1w0B40K91B2qUrcHCUhVQlzoytuYicZipZW/88DdeaFvuf72 +DsfzXHcmGr4HbMaKpXig2Ne5InsXj2nztWSZSt5Qsc49p9wuW8L7L1zg/8HO9aA24tF26caz+Ko5 +bSphqw/NPDmM/MabsaBe9q5/hk+CTRXn8153JmuD0e9mg4ZT/U9GNiVACQTAXQwKBcAUBD5rXUlZ +NKp92lXPnhQenJs3J/KSGqmKILadNlBipBTW570PpjCsUuTzu1L7kzHsUWO0V7xlyT9wgZIK0/US +/Y8gY6rWKzfEy3HrsIiEl8jM440ZBtZ8mzFChSMJrSCZpu7EKFf6Z8R15bJfFD0VR4qSCchRPN1+ +vQcnQELTdQOxpaVCx+32gXI+9TkPuXaqgX8gwQjzI7u/Dqdnls7qtqmI1QnvflH5Z4DxH/Drl2zY +AViIEJPv8yOfAk+kvvX4fTiucfXvBIAF17NkuJdJi3m3BYKlZKn/mMpMRN0XokgEFNgDc3Pgbmsm +OtoXqHOQMVi8a9ecgLU4yS8SHW6azL0EFPl1FiCf0o4YmQa9WdR33YZcdv5to3LWW3l3/OQjINjR +9ghqRYGtDO4VrLUVTMxOn5OOMjHcecDh5xtKVZvRXmKzQsA4cdh5tj+v3u5VrPQ+2C3VAQrlwD2/ +iaA33EtBT0MLXrvUZcToOB/6kZsIS1r9gGeFY+HAOQBqgdrYY/wx4J6Q9suzmI8y7B+yke4renO1 +RLYhlQgN3A5omrp2FQCZv+jrYZ3J9FHKp56OirCP5DR/0rSkNHwlfZiIMOFccrqOT0j82XK0tSfd ++n54a98JKDPcshkSdcdCk1/aqkQn9ceQnNvrpderOo3VykpDIliimr1kQIGUuV5ECbVS9+uTUQ3b +fM1VBIhx2K8r1ni6PdxW7cNYTY3H3siTMarST2Wsd08TE7Do6UOrC6DDZ30uP3a+TApelS27Emmm +7x+U82glet6HGBPO52DU/Kb4u3n94/GZXyPabzHeZfmkaXJQkAgH6pwQ1yaxPu3sSpYP2x4j5PYd +CRWhJ3p5vHNftxKj3cR4gCYsuVvplDOVlcOnFZH2i3ad3FdSB/+dC6SQy7soaHY+f49heD+fiXx6 +H1Pf1AIRCvR7ESeYDeSVw1wAqBcPkK3ocnBM/nQuM+9Wk8sRhxJO2jjzElD9/0K4vieesbxibS6c +aLv5LbUmQ+WS/r3fNcR+Itp0xrKmse7ej71/CmVzO1ujzrEydOacL2WfvrQJD2pF1+wKkHGdR2+g +bouG84N6Vk8LHrXeInLxSg1igviftoPBTr7PO3muV3zN7jxSNFqkK2/91PcvfBvtAywuhr1Rv1qv +audJF3Kk7+x4mkz6X4Y6ES6kHRxMesRYGJRSxT7Xaz7TvdFZ/jxFYr54g1qfgLdjAxalJUM5JACH +Wfjz3EqD84YqPpGXFw7J1Am/CJ4hwoF+NLa+5NhCSSbHRe2a4yXOfNctaVRR6cUz/Nuz/pkIc4CH +mrds2bdY0389/lS5v3HLEvlDbzUcFqjqDnCmdDCREK+XWqcpLrS9bdhrwZq6ONgTWaCMq+dvKA0H +OmR5thUjoiZ/Xf/sWbFrKKT6rJSrBq7luv44y/+aHPdeZXVkZxrH5+cswqc7k2WMCA6Gbh/wLKzB +lIa4383C74kfkmM9adlxI9t2UdENB2aB8bEX32SUSzGN/rq4hdLj5e/vNWlU39LxBxNysg8FSHMe +WqbmQ2wP/jZSkvjrmKmVEkEkMHjX9zTXNzuu1ZCf9Dt4bWTvLZORE3dwB6+HnZAIGOpdCcZ5zshu +fUpB97tM1dd2gz7d3TpfLtzB1SIsbKHy6NW8wTt2HgrQa257J6AxnixA8SuWE3coOn5hYvUqyJAh +aFt5T8KXCZ9GKT3+Q7hTbGljb4rKwgB2y/yieYdAhvaP4/sTjJD0uTQ5zWYXCSDAsef+03YayBx9 +9LZk6ZDKluNPua5y4+q1YKk5II8bCuVg1zIPaH4SwJEq3xSnx7618uk2d8WFQiQO2gazjm1HHUlD +1U+Q+SSQCR5TiRD0G5Tywh9MaB07fKYHePNav+uWhiLk1CXijzgK48azbDDr2JrmeNM/nLGszmQ7 +TMZda6TeXcQddzDgJAdU0cvGttufkFrczO+66ca/bH5I/DId7lBARwLtprXxw2TjiYOyfMdzWrXm +9msX5T4Pf497DG2BHrjYD9E/ie/Ptg95O2r1OuAzA9vSA8a6QtzPATA6QK9nJSzcfblXsCE1nYwB +J2M6ytOHnK3tdWC4OGvA8QXqQejY1dvEwJTV/Kr5kmOUoiOD7+VEWW+bEkRh2anr8UZZUnlWEmHu +/lDq1Jma84FSM1yl/YTRtoBTfA1xLUlVjum679GH5/blnzw+891iz7V3hBBgwmd1PCxm/JT2h3Jy +BQ7nugIfymVcdWFtrPOaIENr6JiwV9bFwoyr2Vd3eMe26h70UfO7L0zzgDAUTKFpfH/9AtKrxqnT +JeNhibfj7o7npwiPPgHWtAbCxzqo07a7bVXh0mM4/VfHpu2dVom1uqX5z3CwQCzIDglUi1yvBbie +A9X1rta3KeFxmU/wynTRpXOspQokuIYJkBcMVVAGM1kEJPfZk9+vttZs9aqTEdxGJf0ZVy0A8j9Q +SjJwb6veUJ1TQ4hfNFX9Nvx1B/N+p10NhAAbNsbT+6GvnqeaPTJqDjnJY0lLM5FGhqsCgiCgTBFa +oCkUBBvNP/hIufuugvavfe7JDIYjFAQxa3PgBDdb/0JRyVwX7aPZDTPX+21TY7pDfhlLVBEAAkMF +wpTuG1kI0D0+5j4WlFT46KPtG1yvFjAUtYWMpMM+5wsJlVW/aiar+Z35caz+La6KsTYaevqAgNyH +COTaDWcJ5HY4mMChiGibBcdQFdXzXxF0CZbm/Xoci9RBqngsKKXc1haJ6dO0ujz65dZ7xvw8SqvC +0LHG93EhP3Ed9gTeLxeXjvd2P1j2dH1+aTz53dOBH/G0uPHXje5GdBbFxlB7SKndUa49M40ih8x1 +yWupTBsvKOC6DQjSrIeqnRnScnLEY780+e9mvno3JCyrC9fxSpAAXfd9jULeXHh8JpH8mohrjLOu +a9HHR2fu6/wLhQMqEV6uRqRknj5gkIQ10DgooElS8O0e3Gg5UTz6OmSr5n3Ahei4UVj80yZllytt +xYxbz79wgHlBUM0GgCbc4iFPvG+9Z1s1f/rivVk9bhHL4X+lAfCKcnvdKsyC96xyNx/bUdgfr91Z +/c94FdSSBnPbeEtcY3YQYBrjZldGUBYrvX3zrxyacDuUqlq+27VPbqutZ/jk/JUqklRDYa8gXFcQ +QRYgIRX4ioY71RQ1dSdjzqeM+78zzl/9eeLKP+3P9YQbx2m6wt8fA5cWko4qv9XXDzyumx7/Twyo +JX0mxDhcKhRn+q39JlXmVRrEkSMvcP2jBPFr6rEd8EgSvFyuBfJwMV86q3RdsP3Osy1f9Yz28v8L +ByZp7ZoMXZuPg6LqPNKlVSWW07no/FPcu504AXpFD++/PjAroP5H2Iu+bIxPS++K11D7P5OA+3I1 +xNGcZEJyqubgtYsjX3XrTuu8vkqMAe8SAzfVmRQat2jTMQO2J0bM7DNC24QscK06DAGwkSDPKWA8 +gNkYu/Qf7/kuFPnCN0PjVreK8WfqKlx1EB8NylmoeHZBS5WJFZ3dwVb9OesHpfJOC31+HX/Dgzlb +ErelP3BVDZfabv0uKi0qrWzTiWt0YHDAxrVArOfsobUz8zB/9lny6l12pmNJWj2nimOiI/OIcbgC +vj8BuKUd0F1hQ0AiMe/G6Zwl9oWdai1ftWxvv7uTx132TywYlXrhDJXrR00Gg8R+g8uXp6/+PH94 +CffaJMyAbTeevzb6upS8XLZNfYKMNzvvR5xxP8k/kdgCuWlQiHj7mHq511jo8GJfjydprVtkWDfP +P1FAT2dBjqsB80cEz2QpMPofL4+epi1VO1oy/xcOrEx6zRafjCwH809517uypPifHaT+hueY3IgG +QHDBDzJlLciBlV9+iVOqbk8G+uzFiYJAbxfmoel601BEFLLxsHpNAvMye99XQXLjC+2PcCP0G0mg +OIm7A8wcU8NV9NP7RQ47fWZKT/FSUprDdT5NSjF/58A6DF7F46NpaVMKT10R0/+N/4lMXArV/SsB +AOTqMcnN92PYPdTwOd5lKjUYobAYTAQIDN86SXtrKNZxKs3gVqQhXUZnVmieK8HhcAs4qlGMEo15 +qkvLrOIQ99cek0sHchn+4GpA4H2JWwU4Lun5LvufJfqtM7Z8p8ZaE/6MDb4lhANnAifzD8C7Nu2U +zuFMlKM98Y0q8ZuU2+uVW7g3xToedBkAZVkBtwyAPh+vVvj2z0ryNT0zk3sPe+5vp+C/tSkatNku +RrZUt17QjRTdvnqQTfp+0f553LQlEGRvYQE8UEK/2VMgX2GgFYm+uzf5LCzyyf7lS0NTNgRh+Htv +KP7m+OXjzEw974Yudr8ak/gVI4+bAgFC14Q2HEw6wImrnj5F+lpSs2NQ8sCPvfVHaLVbKnfiOgcg +/Mb47IZv+E3iAS9x5Fs6Z3v5riyj9lPxVne5TTmIfUxAldSHKfjM8W1bku2pucPM2QcjcJMpQCJU +DjiQ+quEqcAZdMpo/Ndqwg+3i7ecm+ut6oYEcGOV2Fgze7s1m9QJ6sqFKqlVYHnC76ZNHdceZW7F +wWLDbdVSJjs2oUDVIsFYMKK0HttYIkinb8O+Uqal1xeXvzqJa55iw7G3anfNda9qw5/nRFybK6t+ +Hy95mfkC1wO4AeoEHhC1jO8LPmH75ymate63aSyFeH2g/m8TlIU5+OQYQPo4Cky40MvfM4pvyzLi +l0DSrOZ/3hQJgGZ2SBRb0lE2UGmSfn/CFM6q77lLdDPQusoBrk989WyAg1NySZcEq9cHykucZ0s3 +Wx+4ndWamQfqjErKowLzTiN9o70yuVKPOOI4cvfpbYJ0AG8GtMm39OaUfpDm5M3U3cuD36mzLpwI +OIB7p2wA24M74a4B3QLLVGScbHjFsWST3zrbtzonbIICCo5AUuNIfyd105xksaszTH+mpX/aeLi2 +bhMgaMhjB2HWKDwLWx/YRsloe4hcUJ6+tyh+J9S7kDgFgAjSMGhzPdgYG0tTZhmyGDJAe2cPbrof +iEAXLPeTeMy9f95RlWbPt6QDF8NM2Xf/OkhoPE4XwgPPvFt3iTx0qPR1fD6vJpVplu1USwAGDG08 +MybmF7c97+Wknbrp2ZWYOwfkEwkM1VkPSW0QKNcqM5ZDU7z87vwevmRs9YZXznr5CTE4MVkibCTp +GhTz7FqR+A4BvtmTkqJn7uBaKgAH4GBav3J0X0gcz8nLNUnumHfWd+kuntonEkIE5ACHJvO8oIeM +Lkl8xcqstPmwgUuo4KNDuGnzaMiGmv5ef6jJFhPyy5Wnm5//XLQqukQWGUYEB1XmAQJuFjaQ32eS +f/tj6pdzrjDh315sdE+bdPR8cLUtNBjsPLGeXgD4t7q69hzRJKMiLxF9wXdvbtLoZhWuqrEBDDoW +3/rrH9rjc3ZvPTKsdnBOSnxM8ygRDNIMAb4y4VYzGL0y9Dlj4eYbGoWOL7nFI9dws8dREGD0lb4Q +5aaPSYFMUeTfDKckf95zbsTNzMY3IOaEJV1zw/3KubouBs1WBbYyOUSnEAVBHaVPs3VtiXiQMjc3 +Vrr0W8lQNtjTez9RCPpIXqA03BPQf/hd9I1XJDWxgm98Yx+bEQNBsrLOwvE+i2y08R9WvT9XTEmj +75nGE7pWUS8pUJ4sp+Jdz3+qdWynvS6d5ZZLOz2K7MRNW8WAgO0nYAO8UQSQ2mR6p2ek3g42jVxW +elqpODmeokb0A9Eb1+0gbOidaoGkUv6vll7j3ZdIrJ9QE8Mg7dBe7D23z13r8HjLzOB45fLucNXF +S45lJ4minC2kwHdbGKuJsbnTrydZ7ywXH/X7tqIDpEuPinFTFjBoUPoAjksBG7gJuAxJJUf9Mz6d +t5BOkCiXoVM833V/G7H5Af13U9dNO0IsqORMHc9J7NNc1N4/QEVkOJQkgem4WbJw7XdIGSKSiWSB +3FT+c8kLslxcX8kG5MbFMK770rT/zZRWJ/fyVqOFFPZQnpopAmgwJrnxwYVBm4hwoEvOhxMnYGoy +8q5OGkol1gSQLhsU8qY/MsfYfzPejDoqtCyb7aHb2z6Im5KGDUK1BuWbYSyrauEndVv6EPDeJPd6 +M+d/5wmi0KqtbrBuY3F/rle7evEyNfcVp8Mna0sJAcBXIHv3PZ0opTmpxRMaxFnN02VQzIzr2gfG +uqPeqq/fZBVMCe4XzDQl55lTpMTdHC6PVUUREE02wHbCdGzBUqO6psoT665yBPc+WWrtoi2RuEUb +hZt3ioHbmaArRv135vvbO4u+jYhesb4LkvEMWbzyuN4cDAp4BY00BfM5zJ1Q+OcpcuZCshOn8pC5 +7/enu8qfSn8qRAyPPnxzkuaHE5ktI1ObKV9+kvXL5tbiIXBr2KDPzZVm56PeeeaGDX5TGQ8qmqr2 +/qw+jjccSrXZsKGoSbQaTY/ZXMlemddIztxOt0LqihsFcQInno8zregSZ5AIh2I3B8lv7znp3QyA +MJCUkMAaCN636EIIQM0qAEnykVIgYJcre27mSIXtk1m3/uodcLw/Ad4lgK4DveG2sEdC7489A0pz +dNK3RFvJpI/5XcwSzd/PgTcN2GCwyhF0uj9dM5UeZAzpTv+pVRJ5Wa1O4+M9PDXJFn2Hrc+IA8M7 +noV+5exxs5zXvwU7FZ0d9+Om5CPWQKgMdhMbqKLXVXYZG/v62F0B3sundknyxzNf5cW9/gBHEaoE +AvBP4KTySyyQ7bjWE1KeSJeg/17OgqcB160CokzhlnBI8DwPktLvrn/W7PPoXdZwC0enl2ZKMiEE +4IoCtRy1h21/2JYfGpHfJpe/US8aqiKFJCUEAFx39k4mUAqX5Qm51zYRI6bnGBy+ckjbPySZCMPN +vUL7a1loB2D5awLwbcTTxj0z8o+6vlpZEBhqAUqiyx9OsRu+PvlIrERMW0adjFVQsh33kd269QVV +XROAUrswrVch9fE/pwcp8Qc++u/WPORAA6Ozjblciutc25wI42jNdxGtajAS0mPTyWao6Di5W1zD +IvcfmSyBSogWSBsB6MeNs5CMWRorNtmc9Dp+od6WwSG7G9cfQIzJ3gZ4JAy9CS+/MGoVP/3CYOme +weGYpkdvjb6/xw2wb3zcD9V7wqgi4tcqPl1LqP441i16iJ715I+VVnZce4aIeRpIIpmrRLd61yVp +oVosfDWs0fs2kb+8HpICcP7TJ9/6OGf3u8GHg17LF1plMnHh6hYoHBYo3eX9mcxk4YVvBt5bHCh1 +FSJ8+HA1M/RDbridOXC01y1F3hiT26Tvc46fClavsXuScrvGfh733kan9KDuALSYHM0kYTb6dfbA +HqaeQScP/kMDkWO44VBMctHaIb+CcsViEqkAji0TgQFfmObornclGlTanWQ1lh3HFbWEOACo1qW8 +/BM/z19o/GxQ6xTFk6n9/g1u4BgLCrofd4qRjkW/ZeeKiAubnzyUnou0wM2uQiOA3AD075w2MNtb +5d1tE7Yyr48I3Hlw3lMJ71SiXucBzgU6NrbJz/YMu2admQZ9TpLYMSq+whttZwaJPMxV7B6rgRjf ++84t46pjSlduY3YdzAxXeGFS4gDTDbHhvW3esixHz1sJ6ulICa3ys2IzklSDuJFtdEBlbYfCTFBJ +1YDOB8A5tGGD1yXDkzoyhI82GB02LUrajhs+xMAhhds8y3LX8Pj95i/fEs0be3ZEUy6qDxFDoFWa +Gt5F+6Pqf/JphqVUbg778j9Vn9xNBAPav0snFD5VSJKl7aM/7Cagta0QYXoaZzikJ+NcOSR2MR/F +/ZW8y1zzwoMfJL8+JzOIuyvBMoDoGAPkHFy3u8sTaW5aSXKU3BLMeUHhdfF1nkrMJwJ4qEI4kDKM +ei+rRyX4PWqa+aLLG/83cyv+omqiWyTxcWtLKOAuqiEGFpuIUxym+cnaEf2MZ17S0dGNKnohVpkg +BBj8/TmyrV/6sqrc2aQ7KchHC+dpWi7gDIa89NCtuN7TWCzcVkCdNWDfcADTtz1/npjt/iGDG1WF +gNDrYvCZFEoaQh7lrBRhby2mlL5m29OiLKyF8MqoAxEECbCVQ2SgDfdLnqJ4pFaseP5Y3ffsDlHc +/Cw0CG0HTBy3ZiAJevjNYPvZs0ujRTzdoUdw/bIQBDIXQRwqUcscZgNDy4WBkt80LZ4RO5f3qH3t +JmO6w5jlg3tJEw4RAfpKY2D63LnXhdesghCIhmfdKjd7cdNC8QNDa7hM/9uZRc389aKLspedZK+l +CEQK4zrNCIaD1qCDbV0JfXJzHSLkXA+To8RWizxqcV/JEAgCAY5+5GE2S7tt25nIynxfRHfn779l +hvsQAif0g04LAnPKsJ4wwKEdpnTV8VvDxLvHPJpLuiZ6dosZhgm4uWWbEAIMkXQyruNMpp8UvboV +pwzNd81oc+GmZxJhwPwqltvN8kN6hp1diw7h1knHYwxFY3BfghKhQIW2AP19gPwFm+jPOOvrqpbf +FMsWRum0r2zOgUbe3XYl/MuzbZd1Wu8f1gp9dvlBTH0cQeT6nwVqcaFf4qy/L0Gaop6/AI7uSvF6 +vXPTmg8/GYkW+DIKWdlpe/8PpHYwV4F1sp7zpw4JMU+GMS125/4nelbW2jCL8CEhQAbGr4CXBWs8 +pSeY9h5jOF3ue/Fh145vxv6F2nw0/8gD2gODfsfCbbeuVA+9Tpzfz8xnKxFV/S9wzO/QPn2XwWs+ +1fRXKhvMrt38qntWDW4sG48ACjphCnnO3t8p9e7gFiZWiiMFvDae8cUU07gvunApQDkBtTnIpNni +EBK6EPv70pvrUW4WbzpFcW0hXPDaZYN0A/2mNjZg0w6gah7AxWAoxjClcZ5JwGKmf68RrbBLZBSu +lYPLhdWso5Ek6VKu816SqznG8h4mbIz+7W1Bf0FjqRs5WauF59tuqOh1UzyuN6vwi4p8I/FXNPD+ +Eq2zf/Uw752kdN76HwuPftaywleec8y4nlFcAqQDGJxH74U+D03JgbnXyQoPHujLuO748eXoBK7r +EZcBffmCVvPoWwHvi5pG24f4grp2cnyw/cTs8hf4+jUAENzuuvLuyaCmMlcUt6V6dKvXxIkjuGF9 +NIHFeo/GQZY3s7l/KqkSenLl9kxZkF3gNMS9ryEUwtke9WgVgB29/GUHY8giu3l16qP9ph+2ZXcH +ZxOHoVHXqG4M3FnIY/UtuSkeakb7vkqBClfDwgTJz0R8O/Vud0hYLNKK3JfVMrr725lmQmPBI71u +zNYWk7XZd4zF87a9uSKiKShX7SeNq6WuwzbMxMkqOEvaR9L9x7MPabJx9RSY77x7mBgSGN+7LKcp +LvbBsC1lK5LhpYv4SYUJXNvM1crE2dUSLWsEzpk30W25uDp5XifuyimeYN8hI1w7G4r2o/sTo317 +ci0+CzvMJGC11lzjtWQOgisTto6bAAFIlbF53ePbZRXJlDxk+0Zvi1WvzOKda+gdDXxDY0WOL2pU ++z0ns1UyeCukfgc6iikv4CZ9YeEw5Xh4G5kZ7vVN1UYM2tgFZnh3OFKMRBGHod8BoS2L9KcjTYP1 +6nDlC4KxFfAMVy3yN8LE0ejNNLjUL5hhy+BNWUaXc3vHAOeFSgtcex0LtZ74AArNBB1/8rttwb/t +d5f02nrcbCZDzOM6kNbBAIDuv7iGCRsmmaO1odRiVjYDH3z6cJOVIQA6sxtSqAFov+rpCzfD1clf +WIYOj/JGSfgvueHJeAhqj7Ir9M312WThd/bOGwyqwot+e3SZqBP+OgJhLNnPoQrjpJ8F+A4JmfGM +6IbX37En/KFgd/ENidz11KSDCmR/HMKzBhnERg5UW2UmzxKErmnVbhYIDwDDaS6SaCg1Z6SfnP9J +8w7sqBr3D7wbEKvQ1nrlLNS3AxwriOuh5TZW1fNfZedPpBy0MXwag5tAvoED6LhjCcNEWwv5Gts+ +znF/qReVPqHz42TSwg8x3LDHRjik4KOeM2NPgOfC8U5qayOnUd5Sl6O8dw6zbM/GdTdvYML1dojZ +jIyfPrHI/kTravZEQMGLb4kseFobNh5mYmkChyKH4RcvbPte7Sby4aKu6X7kzqWXC/a4Dwo3QrGM +jMWblc8DXBn/bN+i0YeQ8FTumdyBW9UKBwvusmvba/Xkty5fnX6+vL3WaSz0NMNPXJfHRhiUAKCk +VKq5pf28epiI+4vMMr2+XpuZE5vBsLMAwRjd8v49rqF2Z3dI0NPu23E4RTkggU/kHwkAeMwvm5bi +rTRMrxRZFP20PH7OX7TR2hSOFlKBB4zHWoIX7rwJ9NR3/3BO/KdQDmExivFIAai2NK2O75R0Gr3/ +lSP4uCNMLC98xk0r34DamAlwu7pL5dGlvq9hMZFbFhJcCvLZwvw2QxOKzfO/vJEqofd4dSfH66WY +xkIJnY9Mmx0x0Arnz2tZTJGWO114nvNU1I53u/9L6yMMIRIMN3m6/5VX57PGqz/LfMI0HFLswxJx +CxitEwAAhFTYa6NjzvZK+sYjx/y2BNc1XcR9loHRtTo94oJkpYdDJgqsC9+ENSb80bmG+x6AYLYZ ++U4xqwTRADPPZcoX6TyTl9pyVwleahjP4JoJj/mj80cejC1EOhTQKfkv6F5VJ6PK/KJNEAw+cHcy +gfbMJyXjzrDM02T/yReK2yNGUysnqLYSQm2Mjr2ULzrC9vzYBJlHq+SswqDwQmYAwZO1Huga2Bsp +6RF/oNtl7hK9AEkTe+9SMq4DEEIAg+W97gT1JTDPWB8RurnkcG78dLK0FPZgSzOwVxHMDfWqyXZN +RYfKZKr9t+tmwVGjapejj1kvM1DEupz12ZAVB1iwQJhlY2nkjHcnP5H6H7rglk6GnD9fJjBYe3yc +AAq7uRIAa4m9YHSK6xFVrvrk96GCVeYPxk/uEYCBkgzSPnZGlV23SSlTMmFJfljQHMsgcCbvHAGE +K8x0vUlVXE5gWksT77aFV7l2tfM0Qq4ubHKEMdC2ABcog63f5QVjhlgY4pdGxdyPObrI7xsSWDFJ +yyYOqOsCdCcB0GLWRx/UEb6pQ0+V2NUiK+tukvdvMGOtYCZgYRELAVMTBBxcXPHOrBg3eYQwte0x +VlXSx2ERK+wmhCFozQhddb1fx4Xs3tvw0ISfj/PfGllyHH9WuyFBAWyXLiIoLGANg61p5zYod7It +rYNESh2Py+Xf7ymvXNBxipL7HEsIBvpPYlsP9ZCk1SofPuPEadz0w/nrByu8sZAzzRRmAfgJUNeH +nuvUuTeCDVXcIT9vPctC7KZvvRhFBAg1XgY9CyoWPUyHXmdTPWotaxgNFeeP48D/MggEFp8E/9JI +qpmiiN6EusgZl7ZzvN2ySmRnpYiANt5w/i+PkIR9fepHzSkzdibJQP4M13IpYSD0h/oEvZLfitHU +V0ycL3e+1CJcVv/uD/54oOkb1KAetwmckVbC/vxEgQhlEQmaYbFft68yMNfg46E3lfZ2djAzcE5a +qevZfL8flR+0zqqIlChp4jUKZMVHWYJuPmg67e2cnextUEWf+RcfzlMJDLqyPeTpVz1vSsHz9Acl +EThGUfEbM9KvWbrZ4fjQ1oaF5jDJU7dLL4lgMD5QdO2nNbgqnWzHa/PcE44ZPm8PBzkpSzjnJROB +Y4pAwFHXt0amezxZOm22oNzRzN5M8fqQi2fTiWAxj2mFlCkmLCZkDW4xicVqMvZKsFK/ViOGcYLB +0MVc1kxrEwFLpIkTuLiHu5t9A3uT5Zg96+oKSexKsl498iJCYgnDZOQ66tyJqQkq1WkwqWJsCnpp +y8X5g4MIav0MovuCYhlWH0cv/S6yERGLd3yj9eizCkcPS9bbTXggGnOYDZSovTfh1XbqywfbSrrO +TY2TfJdzpLMi/RsavPQUVcR7DrQLybSGcY6q5ySpJ16PIYKzNXGDpg2BrmMJnYkzXd5C6hymp2mG +bt0So33PFKnyOO2vFGBgSlHoZEj+b2uB3YV9vClakaukv5qIA53tnddWex3906WQgXp2ycwj1PWM +re9RUrNceCQR9JrZBDZCMoM6h7SMTCmm7CL/k7p8q3vqevFK4/KRCGJIVCo0za3mKHqN02/bJwoy +ESfzZSit4ohN77q7K4jz6n4LkWDSrcGIFx5uY/vI94jfIQoCTC1zpzVlH3OOBMDCEID5cvXw0a5D +XXTXc3plhjrJ3dVffqMiwoMws4KZI21Qar/40y+ldF3PhlnSou/nC76YXyFdlSACRO/HdZtrOLjh +hO5Rszjz2w3MKmThlAenjfk3B4MCLjdjuNQbzs6nmJ36Xs7qi/PJNGKnAWkHt4MDpcXhHmu/GdTi +1nV418m9jgjNWwo7GwvH3z/4cOmcdtr8v/AA2K68e8doolSZojpY52+oyVPszNtDRPgAoyuknF4+ +l6oyEXo1JCyR12t57xXnGfzRqMZSds7AX4SCYAJiwmAt6VTaHN1xcnq7MqGb3KtzHeeV6St2EyFY +uxZQ0l1UWFwA1dLO7+stuH/f93vHV/VVLxrnOEqnatXj49esYluwe8KaLmCO6plgFP1r/OhX67oL +/Wf0an9ueSQq8gdOEImA2awdVwsTWzi0o96bHN5u5DgixD+/i8fCoXA0ISDCBA9oCrczX+9OcNpX +s6aRNOCZQ8nB3U9vUbmJWyyW4UNsTOysUV8IgODWe2aiDfUjTiwuCMnnP/PYeeTsRXwQ5MxCmKyt +Ivh1iRLT7tKnylodlN7UHt92Qqr012lGfBTwdhjQeJ0hO0pU/Rx91hP7repXRs83Fs6QlLxCHMQD +mYGmF7qHxAZdlN6isM8u6VrllUWKVI7SLknfoCdt+Hgr5NrvA9RmO7B4r4ANHNWJZ9/i1ybhyccM +TiLMvPVs0UENNtUCROBrosjUBgZaYdMRMnEqgd6PqmGqVzsCxxrKZn0QhFFrJwS13XwPmQvVSdYk +z77VCtaJf5OSTErlQxSDsEVaWqLFQVemcu9LkfgPRwwLnR1lEj6PTW4ZJIYEd0mStvRKlzN//f17 +qYUW4uMDHsgB/PGg5obSO7A6Pxx6qKNSSap5NtC9sYMNWRE+K5i8ujkYY02QhVFuiZS/OPqspO/C +6uM8PwXl5e7NoVgXKzo/BXW4SD0j8ji/c3dzCyZ9+zNZo2Sepkr2z1yQgingDFQnwag2DSantrzu +kvvcoih2Rkncz+aYGNn1/5VxTWS5YVGm0vc/f2NKM1iRe/b1aYfs4Noq9nObUwJ9ItECTCj+c2Rb +LOxxb3V8ZDAdPZOuw4D+5mjg+l7bvbD1Ka9PpdG/fepFuvnHZj+5ArlP+6nUcjbnwPkJpc/kqB63 +jJMdjzv86GvnK8kgcY6tmxKAyoclY1xae7jcLrMe6lCmnKhH92XINwWB3qEyjZ3yvgFHHneLV0Tn ++wcnvh4R3rYpCuwTcOpF83JJkPW5Lgu9P6Qkv+pmxb9vPktAz1L09OTI095yuNCoZxDw5s2tW/wn +2uaM7ImCsfVwqA45mgaeHJQo+hpeINTh/1TZ4d5dR88g5c1pgNfvOCTv2IS0hA4dP0jddufqKovu +gVxxteFNSUCf72t4hsQ9v9OXGVePzWQe1mFP2ZdKDAT1AwT/xdneGpKuE5zKoxaDbE6e7dse5F5M ++2TUPXWUKH7j9zo8SFT1jze6rt1/pRt2bvxQRndg2OZQUBVAt93G/ATN9JRPyJgC18GcVsFOhgL2 +3rHbt4jxoMGou1IA0wnj/ZTkNhHONy2ZtPJl2c434GYX5Pv/QgKF/BUeMS/brHbm7wi9G3L1t6pb +4EmiOxXb8ZrswNTVnJEj5nArqHBpm4fC8TiLSqI4KNnQxBVTFmP7vaXAB5YZmhKPWMtGRu7bT+7l +x7eFUWiLNSUIYQUJ7qTaG99aF7PdI8w7qDnOsD2yG7arIoYDsnNQ4adj1PudxpLDfxVeKFiqTmNK +PgBjw9e5UDD0zGJeis6mKf0najLFKRn0KVHddkkmLLPN7W9g4GHjOoNO7vkzCmKkl/I1VGeqWpoZ +ZS/9ZiLGABbfW5tjVNEm7Isn69jUsFSurJn2tSrZUtm0P+P6W74Qp3FY03mxE1ukhcLTdy4/D7fl +NL365U6c88SVMQ3iaAQQaYVB/wgkm2GKsgJuYd/OvZPv3Lfbe7Y5kP1ibsmOE9MjzrQx3lXfslIZ +HK1iHMp5Oq/E13T8TPzOd8SwWLeLFSrE+eV59/BqMtmzoCuqISGiJ3afirEjOgVYcKc1LRHoYIzy +4kA7CuD7/q2ksvSZ5AjzQIMat0j/9sWdB/EVahQfkHXgjjrCUPADfdsATCnwvFKRl2P1vpH1evs/ +RUeMTI11EGMCS8Ssd7/GSuM82Jv7ZZRG+nyQfKjuF1PGh2RpxobEWID3SU5Ajz2Umw8jT+Z6s688 +/Nwt3d7ZqCz1vE/2Ui490TkG13Z9aav2eKSXLSxzHm8Y8+f/sMiQ/iiY6F0C5tevmZ7O9kgwDoos +OSLDzfDuyY//7Pqkn0lTBM9fIQoF3m+gHFVXzWh/9zwp/uLNPF/o+kJLZbj2WzAxHJAhDAVS7h+4 +t8M5zKRX9dRL7cMJln6piFx8AwELBWCMC/MfSB72vBHl23rmaFhasnFmO76pi8YA7/GAfpTomTGS +GnjIat+9rBbTc5pKfIEygfsx0fVFd60BcK8v5J6fusw/a9LMSzLB2INwZjLgIo4DWuViVFxwq220 +zMA9QuUSCedcION6uZe2jIbsj5Bc9KG/MYItMm3AWL8kJTmPptwCSUbwrNVjQfjyt3102X+BI+1g +bpBXZH2T3as9bXW7lGK5KeptrGK6J33t5VZz4jSOqDvA3B64fqDTYwF3Amcox7SHrKNHre+H19OJ +82Qqxx7wtUxuwgR5HzFdJtEvbN3i5t54X6clqZIMnuHazc0dQerj+zcWrIP3ikzNjMb5+fTOhF7z +uw+3sj/SqmwhDkdsTI9kvJtts1tfZMGPR7dI+VeAX4qlNb4feR0Maajma1YvHJTMQrZBRVkBr/wW +Kq5zWCsGz8TUlwb9FY7lmfA+0SntS6vEVjarpVfH4ejQlO+L721C4YFX8GiPCGSvo47hHEmMjOOH +8EnqRNW9e0jjB1xhgy7/QAIGNd1+jd0OdeBRnFX/ddJn6w3msB0LRKEOSCe4PRKB7XrWNyOTeeG/ +erBg8twQ30qVAqxNcZwYHvPt6H1o8erVXPHeoaM6A0JBS18aTc68buH+GxjlgN7QU3KEOmuesV3f +aPhmoZjMfNt/8NpVfBcpDg9GE3zEv4c8dbbH3ZUlKdEuhfQcrY0Nvh8LB2xvh+0IVy1evP7fIE+j ++oW7R8OiBv+7q65IVLxs9GhtbNpKe3BkPk5lgewNH8L/iNrVCbaSwLx/5AHFDWZef43HiRgacRnN +0Lvc7I+WVd5TncPwb0QAOtYzJMpawXSu5tv5eO2Xgb803yk1/g0N3awmziYAQXpEbus300vvLS3a +/8t9QiG6I/Ch7F8IAFiBtmeXpo9QiVdN9INc6+hZinv2RI/SmlRDmJk4wNaVk/DcWflfWyt+fpm6 +r+C9O5z1TUfyNFG0g4392hVhigSFKhPS5PB1N+dGa6kx7nCDMwerG22JTjuEBB0e2yU/35u1vB7a +Fvqz/Vg5q+a9IHxHJAoFXQZrNwuQwA/tG9Rcc9FL6tXql0nr7pGdRZQJv+bilKrAZwFb1gPD9/D6 +2wxepU7NF9d8mzsweFRx5gmBK37tLwCyBjKB+xhLl98lzYc3bvdeETT7/lhMsR3fqYY+VICwR7ko +yP8YmK2GZDtyfda4uz/R90bIleByYjjQHUxxLK3tzC3T0tGa8enqc03h4akEbJiNrkpbOMIWnTeX +3RZFyhhXnXvw4m/DH3Dn6pHOkhN/wQOwHyLZQxNh6T7lt5y7zv3SD3MS+o+A2Q3BNEEUGD18YMT3 +8vb+mtRR5Tly5GnPnnaN3moCMCcgw3pDpZNaD1v1qR8Xv5DF7mM6ntQwa1d/+zE+EFxqpQ0rnd51 +2iO7Mfrre+7Oxre3+veL+1rswgOCiZnrjkqJ1Z8V0xGvRWt359XfzR/TSdlpiW97mMNMkaBVd3Sr +wkGyD9k7BjOFyhppD6sY9dHjX4PmMCBqbQ74X8H522pDYapTqOnhU6jcsY/WR5/iJx/+BkQbrtg2 +5PYd367fHapaSAg+thLL6FghOx2O71pEAx1QrhU2CjUk6cqpbsE4c2at8udjiu7G+PsXN3IHZRCA +mqPWasj3AvKu5KsyWdlf2T6/W/IyJIDHVDwH/mKvEOfSzPzE5buh0k4M59/8+aGAbzmBmg1wMeJa +6FCdQpgz1pqULD/Xc+w/LvJjvqeCklKE8o7HMr6j46+EavaQ5d+X3P+Qs0gyfbBORXJHsl8yc1xQ +7z+zAQRyiEqWM3Tjkde2SajNTor23Q78OEqAAMr3wjs9O2lfip42e0xxaMmmUynkiJ3fERr8IJk5 +0tbWHXzCarKmRgLNwbHdt8/s/Y1/cFmWe3sPTSq7rHa+fdCMf4fDTJxs3EFDEIGdKwBW6ARIxubo +TTTq2GUTby6yPy1MJPH4KrZ/MxIAY5m1vPr1k5F5doZgk3O3DJni2B87fAwQLABzk1B7CYzloD49 +TsOFTie+jj2QxX97qyfHmd2//X/gM9hb4Fz3RrcNi/c/Sk8+xRt3d2zwt8H1rVb4/g+MFx/8VrL+ +/yx7A/QTHxh+e16cMH/4QfUH/MsC0tPBVYLbIdGJjmgDqN1sX/P3kpzDtPy9FsPWtbSisSfx9VQc +ClC94UzjCboxMmFwkpfyUNhHxLWQOyXEcNiTo1pdI35r1xzDaXVZueYVlfC4kOgbBHDOTiYbTOmr +QctIEqFL4zciGkjPP/wo5fUtGj9KAjU3xtrF6avXHzCpOowLD+fd+1V11e0DXQW+Fw1CYZRoLLi9 +zITBseKwHM5ZVWV9GfEpf9/f+HePBWC4Y39qu6pSYWiE9h/5WpoBuWPV52d/mjjioSwB7QxuJoCV +hHOAv4q6wZF9/JScsz3bh5XG8rtI/I0HOLAAS3ltOmHYsZWiHBZv16oYwXoNPnMFB/MnBWrFS3hg +4KehDR0AxN0W8kH/y/IOPam2pyZizxiEtWfwzWwUCD07JsDrcQFTe6BwwNohgNs62MDN4Btkh1F5 +/N2Q8rA60SDvAy2Oe4+yxKvj2x6b0gIsN04eyOpP6TcYyc1xGZViEWeLHxb/dxaAoTzy454DHqeS +uny1nj5uLGAU2k5hSpgBOsrgI1QUFfglmGS5rZ+bTIU4mwpiTlabkp8PL5BVqs4lyLRmO5mamGNN +MYt9YT+7efTZOvavvW85U30SPyTjO29QSHugpoEbCNOVPscvingvGTz6e1p0V/DdMzuTXYnCsGrS +HLozOUfhafbwqHwHWZch07dYugxBojhXzJ8ro1aQTIwzipOiH2pqWJ4sKXE/tUIMhn4fXtmptmN/ +YMbX2JJCMdN83q916Ud+EsOgHnag+pPeef9AK+Ggqkv/+euiql4fX9Cf7O3ZBImEmiygXoI1kxZR +RUo6biOnhL89vTdJ7+AjrUdEwAigku2awAJakAKONXBPaBbxd3zPs7vtGeP5wU2HsW8xGT+5yArm +tr72SY2j1kdeZS4umwb/zlOZ1nty5L0/PgJuaeW6pmQ52Zo4ga4H6alDkhJNp14rdwiOkyW2Hgi/ +E7uIjwI8wqgfCndwOQL1A11DL76isNC1lVOwXuU1Tkth5Gn3e4J/f2KhIWmFfLb3bOgKYiiyMq4l +uo2H6ebTvQRBmBoVYOwDJZeP3LL4dmuLxtilCeOkAE566o5+rWg8NBwoYOAMJg9iYmGnuTvOUE1K +J7uz2YbPbOmkS1Fs9MYHojzYUAseDTt7VzsVOMwGKvl2gvTtmZhAl1DvA09YFI47HlHQopXchAHl +BF83eAAdBlVM9Qa17H73o5OGTKziJrFVXyMZHmax/Z0Ky5+uqDB676r/xHK9+EXa03KUR/npHfBv +VDwCLKeRSa/bT9Xnn2vpThfcTNuWUXtKoh8/OQ9DgBblGJ0U61Nep9/842zo2Sv+ylGZ/hJ/k8EC +Fb4YhdtZ2DvZQq0MsfZCyu8j0WJ7YCfsFEznhZB1DMzd8fjuF2zs2gEBasKjNoNmR/7zuuN5lzkc +ok4W9A4e+zWrgJ8PhwkIoGIBDkBaAybl+jRnsfR0S8RL9snr9JP0o9yG9DJmf6MAcGdNX3NQOfjt ++L31t6ndMHfh78vt+PYMdgQB1CDBH30OeTk90PdSzQHkpexRWuuGyzZZU0Sh0OE+d2ZY4WbifE3E +Sui1V6nl54Qs5pyJQpBONuDfSdouWzBnIOXOxWUb1Th7AGl1PtGGGAhaEwtgr4ORyU+i28cblE5E +V5U3yXCTFn8O349vjeJDQSOlesf367QJxwx672VaaziKv7rX/9MID4sV4EA9K7HDMjIqnGl0m/Zx +MAeRlvpISvy6Yl6wdHszCnMnewe0wgD+9CcRDxIqE3ZtrVgdeKPCwsxX9f4E/nxhEUDlRIEdDr7q +qKM2jjyxg5TUfSqMMoNOztmv5LDDZnBbE7cNf14vYKTneQD5wytp37eucIxGsF78iK90YuExmhIu +UQo/Xemp8Mu3rc1j+K7K7HPzQ7Dh35ObJjCuDCXaWzyRNNmhfky19OQ5tyl+OaF/YYByyQGGpydT +Euk8/R8tXyQRg9P7OkROIuX/hQEMeKxJP3M42gdAtejHbZiuzlgYdedIu1rWk1ivfHz3PT4TAI1Y +yKzuNHa5yb6iu0hHtaf7eiQfflxoYzZ1+dazwi22ORw0+rOlFcL122Nmv+Jb6OtJm+vJznx8vN3l +1q+MOtvpHkw5sl2KT/4ktwkQSF0FYAF2gVb8pfvopGW73Q163Hx2Ik5e3gSGDoEB0NbLr/c5e7S+ +D+ozWo1R3M936pI9vrGxDsXS2744b5vRDr4lVa8hzn2tlrSp+fynV3hIyMuKkplyn+RkBf/jpgnd +fXMyinbgjvonKXy1HztDGko5W4+gljuV9LZ3fWt47NG628Nv63jjvc5N8QBosnLIInCu+fXWrECn +wC85LBpOr6TxQLYmNoCgh23Q/VmFRiv3nn4p2h6lrypUo7D3y7dr+LndtiZ2oD4O+ENRRwn8s1cm +te8+5A7OlTyrulh23MXkSRsbBQGwG1q5QcA9YDj3Q9x8xA9GqbgXUscYOP603+HTyhLDzwLCoQBw +OuUG1b/cC+VPlYYr2Mgqir94boaf4rSOA3rJI1GBUbSSDD9zvzSJKyo645PQnrdHNU6qMggH/p0C +QBrCshvvVIxsRc6OlZW0TXAwJfCxE0ZiaaGgU2G0vhqmIU8aWPng2sD227frjJsITxhWyu9olFvk +D7LKzIFWkYMjLne5mNXYCPwxmLOVPaRGeYYpRUdJjE8cfqBy+j9Bv72PKN/V4Y+Hg5c8ZlZhwBun +NcVcwAzchLS8o9qf7G7FZLaQ3y9uMLgRLPKq+d85oGDitcqrVQ2OXb87T/7p/xShyHRqd89XfA6k +jTMcvBiwp4nDp9LJlLNjjpb5XpZcyHERj3vD+I5JEOpgswGIdLdjTY82Douojom5zPzidTvlsBIB +INjYAxv3Zcun1dhDGg3LTb1XqWHvERePs2zBwwEdUvBcXEkpTFuM6u3Vq64V1Hn2dxg+72bANyTA +Jt4mQOEpwNsF1pLIY+Ea4PueEUy9hcVmssw+2cFp9TABHCbV3ZMrFlFFtSM6w+6WimCcT+cRRWP8 +pNI1YW5pDyzJ+v1UsotfiksxR4i16Tff6Uvqb4QQr3cQx2Gpnartw2oZ7g4y+/ReGu48PPqxd6sU +/vLhAiHbrPA/WEQdbLXfbSVqCyuZ0Wh90Qn8TIx1KJD/DdpZ4KqsT+3R0m0Rqpa2LVGnRIfr9OJv +a1tp4V8wGBowacwesroUCl6HmT9lvnva+AW30b3pRH0+cvzUjQ1I9GYC5YK50u+j25s5Ey+2u+le +OPXDd785fq7jBjSmNCtbvlLFVOUs76elqeUiF96g7uPRH4lDoVwTzE8HCPrrHfZoPDNInBs5+M7j +ceWfwDda+IohDgGAo3F827SwK6uErs/5/fK83+qgfAvz33DQYnWWmajXNxedVih+9TN4/gtPuMZh +982QTghUFoIAcPhtYGBVUGzPvZM6x/bFrheP7nxfCiw8680tRH7mOXFCTI8x6DSCjfgA7xbKkLt2 +QD8w7gtPW7siffX3R5fnVDh0Qv9HsnWr8HKERGRP9u6wQL3ZM3dteS5r7srCjzwSIwPX9xZt9WKg +fpHnc6OeuaNzq2Y851cDiDNgTFQTB2ckWEnmynrARuQtuXdi/z4fcbdWn4vuo/ufy7njv2HDo0KV +4jZBtdRt/qxp9Zo2+Nv3Z5LxImQfQpzNwvF9xXgk0BNV7Bfe0qKHLqev6rmRfT82GdB+gdY5vUOY +OM+akbh2iTujCgP51xSeT7I1jzlQMJ5Jy3vxVyVb175NsZAHRoD7oucTdavf2fyjDi/GKqRbP0p8 +IA5zArQPJ7X1lVgUGDr/XoP0hn/2662U1R7lj07U4yfsYODAHlhXdoVhNXK0+/aTLtcEFcmE3Npy +IPgVftY7Bos+nipYh8be7xOLo2oIsotf3f9YC9nio5WSoc0ZYOtCwlS/yHvkXs7SzuqZ8+NvDz3z +WFAtwgOjjGlT0K8J3qf98rqjTxzM6imPP44IJdE3rVwKTiQGQ0kWjFJJ6YEUPiXzQJ6kerfg0gQf +hRNP0UOiWJS+re48FuK8NfBbiJhnehm8+iiVGgN+PiUWxhydQod0sHQygRTv5l/y8cz8SpcUo1sS +nE1OjF2Z6sF/DLSBwxzpBEpVN5gZErLN64wNkZ8upNzldLMZXE4VQdLp7rpLjMPGxGPNzLRf++vg +MrFz6G0z8RxXF0tnuPzDvJR6xmP7PWJQLB0T7Be2dj7MrMAP+HLXeNqaJsH+5Dnk7FGaLXwrOU34 +Hmg0C/imeG3JADUBfdItH6y8HsmKNf1Wy0099RJ+uPsiL1E8WqnBmoDmCw8kzx69UCc0NCwSIVJx +kJlUYJkIHhjOP8fDItAzel/PjJJFr1syJVp/ET9lxsEECP5g6SMvIsw01cK54/kitjmSakQauvbv +sCaCgirsAy0a0T568YpjA26TD30fK8P+NOwzeD0Y+iSOMBgUGNIXnmUgn2aYHr/yIVhzKfHwG3l8 +hXZNwFhctrK3h4o5xbzXrTHx7Gz++fGZZTus2PPmh2F8rySYOQhVJ3hRmcDLeC9J786bq3tHohzN +H9Sn4ztrMV4BqHTU2mpBiWjrt6ore+O1kWNIh6ZyjQ8JxSbt/W2Z+KnrGJo1uwJquHYi+JcZnCJd +7uU4w+c/4p/+E/Mkwc+XwsAIKV+a+UNkZC4VOykYaopUS1/45pPz4GdQYxjQHg1sXyg69+192cSN +3FdM9I4vy9mFm1iXbML+j7Irj4fqX8PaI0IiRWTJGtl3WUrZUkr2ZDAY2zAziBZZ2pA1a5ZQSkgq +hCKSshQtdtJGWbJkSYg758xixjlTv/vP/dzbnecxc5bv9/2+7/M+Lxc0lCYzEbOPxIcRWLHIS8jH +GHaDBF6GwvGHC9U+FwfHb3BkQbNd+NX9pB9ZQ0fxdfBrGP7uE8YTVUYOlC0KT51xNw3h1OEIi9rX +Jwyt4VEzAf+EJfwbSOFsoTCv8pQt7OfQ+0j3pOpvhxqloGESNQUpewekCQH1JilXC9CV6xx39brS +OKsbK2imgvmYFuTyCJpi/TsdaSR73U7DSHqjt9dH9mO6wo8fcE90F4KWmmlQYZDg0GeEG+FbiYu+ +bzpmZ7atwjNOzU9o7rB81A5olgueaulKRScMTZ12XWGur3T3nVXkYAerC2/cfyQh/ST2T9LBmrw1 +TMjrwgOuv53O3X0WCZU+LaPw9FEAsQXC2QcuqvdYnZosySyVyRK0tgk99Q8s5fEXoMi1c1vt9JtJ ++mF8xif14N870sdmoWdRagpC6yv+HxBYfAyHwrqCRKmoDuaGdSPvtUd7GXLaaoPUD4+Z/1cioiIT +oOG0n3h89f58tkpm/EcpN4MSYzo3aOciDRoUYbhWWkdQ3bpz6WX26B/7r+ZfZ7UYnIAeE2hQgJUX +0PjbEWUPsrmsa6p8p7puo/45fVc+hu7+qc8G/7rGJDYQv2mdufxK95xbt95/jjx2ShurPPcTWh+l +xhP+F1CmAuJaeSkpkMjsfSE6XLXw/ZlprETo8Hn9Y/fQ0H4RaiLigkORWQSIOh5fCPtpZ2a3w3aS +6+6xmNXtnQPQ7hkqIhAWKn8Hh3gW8O5nbv3IivUdK6w0FGD2MPB34z/NL/FHhP5G7Z6N745NrJrH +tnbXHM+GfBqD8KWM/2vrT1j7i1mql83mi0c98Lft2b0nH4ohSrwJjfZkIegleqYjJjjDxq6GS6Hm +hSrrjG1O3oLBAn3UlCsnKSbBfwMU9RoPkHqdeJptwVGy6RBqv06m2CjaX2MXVEZHJCXlaXAIPyzx +38DtSmrbiSsRhu9zXj9wv9cimPk44KAXdIsgSveWvBJCGdIsH8zHszz7feGn3tfIXflvW6DVOtJt +JktHdVSenWuOijy4nbPhvW55quiRB2s+00aRhuwCSOse40Mta8/nS+NSSk+vvN83Wd6oShMJSprI +TRAUZTnkqIeH/ObVOYpm7NhGKcX7pVZ6cNeLwIKkbAX2vMnt3X67cuWQpVMd74eYm2lGnd5/Q4Kn +V+2uUZOb7vXeDjqWVhIeL1xyF6DJTfIet1THBbDnLIZGm2NdGXoSUzyFVxmgttKXQEXry5dsQhqQ +Qp52OWB9tE/wx5k23m+o2V/B9eEj0AZFEokLPgoBhXtoDMofUkpE171387ZaafhlR/mKq4c5djyf +UoKm38kafMCjDx9G+JHkrKqf6Eo0tQJyfCs5mcZMVDnN0hagsrYl/xC0q7cnsS0A7F4mpUcEd7u8 +tzymcV+1u0pzyFtYXO3K1QSaNMSLQXD1pPwyi6Nt7z3bbwxwiH0Sj6Nf56nKlw9NsVOzgJdAXua9 +tf1ppkAO5TuTmxv9RAKEx6FN89RLpCdwU/GxlA9wwCEsl+BStYD1W9fZoni0oq2bUWiXw4x95GmY +xQdCBWKtbPrLj3GeaH6frBcX2mU88F1hFFo/IS+wZKfnkro/L9KCkeV3nxlZxhbhlAfm2Gj/arIG +Dyblqf/lWuzknaQTO3OdFKWtfQ+YmS0KwxCRrLCoWglELJReLhwMf2ml3PX+p6te5vFHKYN/wQJv +IPgu44Dp6uSmubCh+c1fH0sksfVK9rNuWDiNuMkArc6TNTyAtSxx7SN8FyxxMcrp3sktZdn5Y+aW +FVfHiBYqdZEN2i1Dpllyibki7R7a+815aLXtzsjr6Kqv0sr0f4ERc5JDvxfPjHFFx6Y80P4RNZk2 +8mm+B1qcW+oAAZOiJCyn00Xd0uobjwp4knfm+ATElvUwQOvwZCwhpw69byp9GnNnG/4Yr0uu1cjk +8pE0O0sf9Q8WivdfOYTxI8pseFtoEl2dgvKKOw2No9CsBRmNDzAosPyeFgofg0zWP9oqeHnt3m3y +s0YFULEOGUvZIlXUYBcT9+mGzLmM5/rxvx5v51fxrf8bknKjo77ZVrPI32NHSn7yBkplrBMZLo7m +ewQN28hMWPxbv/T9Px7fI/HsQkdTZl8W6mq8upqDSTg0j7CE9XRD4XDEbOjJbzkGOxWnv003O6i2 +b+tNvC1qCz25LkFxCJw3lpSoA/Ar2AV0P2Ql9na9lhl0O3rlwt0rj6GHpWV4e+J8C/2DLzlLd24/ +1VB57qn4CwUP17kLf3lNwDeOKKTDeWM8gNH2KPDnPzTCxM9/q+wpKEpk2s8ux1ec+6oIwkNc5EAr +XMrR4aHj2xtOMarp6tlzdG2QU5D78KzfkBYYkigF/3whB2c2eyoy0kzjxkkLyRXlF1RToDoxEgM4 +vwDI9REG4twq/bXHqvWF0ppxqfPrNldv17sGTeWToUsNyeBNr7do45INmXDSeyevZP7yoHOiLVQV +ScaCZmgE2xyHo0xK169stU4sfti1PplzILFsAapuoAKS7BsocpSFbBFf3C2jymVMduyOsuEzeILy +8v87CcrBjTJwBI7LVKXsnM3iW+Quo8aLD1R3MIbWmIw22kHbZqCMvgjUUmsZwPO8rLd1htfePLW6 +/vj8R5Yyzs8oaK4YwgMgPcJ9+bs5p15uUGzomH2WPaPsGL+RJpIilYGPewmDB8hL8E2pEpaaKI0V +MzVvp97GupakxvNCO7IgTFgJktKNnB5R6r4tvbJpUMgrCKuXcHKHquubN9BEwhIRkPhyoLxN7+RH +DfgWnyCM+s4sXt5g/qRAE/OMFt4BSW7fxOGXd6JPWfxr1yN5rnSF3HbN7XsPzS/O3YiAKi/IDMRQ +hpTr02Yf2Z36y8hEv7bd6GSTBs+ZI9n7aYMJDxnZZwnyxIdsfHv2RdfJP2qGe6WfXsu7WCMXDW3e +JrEBkiDKSwtsV27eWGKpRY8p99S23HpelId8v4hxZOaI0QhNKlJ5nSRsAWueSAfKDQQpirorY9ib +9Oisn/7P+PnZt7UVUCcGGnRgHQfj7YmjprwgZdYtsnWqylH5UYuge8bpfPnnUAEBDUoqMzE9NSxj +SU4hIuiq+GBJTsnTuSFFaDWBBhEx8UbcK866OQrNzkvenivAIcPC6+WvtiZCmy2ITH/xAhjOahhx +L+6Jn0RY3Bx4yel/8so2aLc1kYbKQ2bJ+SGcpVzxgMjFY7PB0lmGrg0/mGMUob5CUApKeRXZRczl +2tp4xumxP/krGq/ducO50WyPM7QeCOWieMlUbA2sQnXWeppbPTlwQ0VsjxfDBWgCioKBqDkjRJyp +XE8rn77hYKULSm1MSHxrc6+qC3pug4CB464T6FL5UvjV1nwMv1ifQ9DC9ymrVZFXXkIL70Q84awg +ib8ABF/Rmds9pd0tW7bmJATyVyc9C+0WPQyNG0jYZfHWwm39K/pnrym7X+Pwtni08nQlD/fkf8GC +GsHV6wsyCveUPpoqyWjaxLrpcQm76VtaYA/8SgBOh1w6e3L+knzrFe4SxDzKJnu359mH7m04aG2O +CAcO1+6Aroeg8aNU10m2+KIP/1GPa5l1LTins6jAtLMPmlaloAGWEYiCOiro2Fq/Tqnw55HOOY+2 +/rpXwesG9WNaRrJcmAuu9E8V2IQU4q72p35fgcjIvaezjx4qRF3GQ/yflLvfHouoZ8wBAkctp08z +rMYIaecce8NFi+a/9ezTl23X7/66P/XH48WWX6e2PbLTfA219FvGSNGz/0f6TqGeMg97fv31CzN2 +n2IeWtCr04YTTnfLV1pSp4R4bZElusGnsb0Om5zWsNa7fFMHtJT7Dy7KsPn9VZs64U8/mdCKzQee +R5z0c9xL8ylcTke5apO+XsLHzO1H2w7oq2zwHm7okWFU2PASevD6D3yUgiE+0x8bOzrPln4R31eW +1fz04kQbtMGCBiXVLvAYG1Ikx+rAkhHes4o1bK5ocZND/38lot4FpB5dtHqBmxH/YLeImFqwts2M +vQQV/dNgoii95h+qsLZJXtVgEPfux4DXw/bzi3VQHeKyBxw4P3g4INzQHoTfdPom+rLBhylWpgzJ +ulvvEOmO3dDEMJECj6S0fLdl3e15QWRPzUYrt0d5YsnjYrFiUGsLIpT45bGUU6OBGs+2sGd8zGVD +NWV7V1xyzPmgvWIR2nVFpPD2IAZnpCANPDrJ77ApNOr4oHFxQWUo+KTJ9ah2mis/TKqiTMSXbZPw +HcUz135pF1meN7Pc5wRNFVLBgWwFFcXKGTSCmytiX3+V3+FrinwtZ6o0oL3/BArg446rGIZaBmK0 +inYeUS0dstfKcRmgg/k4UFhDuxLVF/zXqr3yXonsF3lXkVzemSQzIKUETYsCGKITDDFzj0EDbsA+ +Eo5IcMoWOMQZyC3dqG08cWRuaKRHI2hwfEZJdye/DlRI+i86quqC1JRKj+0fYyW6H+rfBCaLh/NO +M8OtT7QYqdO6hBCFUFlifhUfvWXROr4hu17jU5CPyTURaJH1P/Iu/f6U7Qxx3oV8xxVEx5UNprpN +9qcyQPOU/5EV/1bh0MR8X8UHFq2tCTscX/n6yBjabCx/aPICqiH4b7wg38Zgg8cS+5jUHt9DHNzP +MxYiKBXJ/H/yYakIkcVn3oc7T1z5ZvptpjjF/0yAxC1oqpo2IbmdAhhrD/BlP9D9xqrVmxWeftGn +0iw00kkqEtoh8G8+Ug3yXNxqtewx9Vmrsl+6sTIjLEniatCmB9p0VE/krLzz4i/WlUqvnhRn2dV+ +joitdrz5f3CRywrA50DC66miwVzmtdJnoqd7Gpra9vNU7YQ78JOy+0DNmODuwpt4RdA9ZwsuKi8q +OG1u+FZzwEgnLBAIrMHTOKGERT7/dcgHqXDl7B9kcN4yaWHR9EAIcQaa36f0dVlabPSVeOp2Nb9V +/Rl8+OnhLQJWH3yOQ5PZy9xcVhgUl0rmsTNVc86J2rjPx75l3ALVrIEYwvkWXKF6xs9rBXEHZR/d +/tLASX637iupdGjzLdYZ7e3msKzDIE8jc/cuw+1Sf0653NYJ7TzUf/4+DJJwnCUpEJdOs4wDIZfd +VQZ/Xsg+4oK+vhqLOPEMZkcmosFSA5VbyrGwB+ZBxfk/L593kjnMcnMH5ycBmDQHIV9HSrh9Fv/A +tS/9c+duzewkb7GyMs/KUzAxOyTHZyvwpS6kT//Hx5APJfeLY3+WFeTARIAEGAaJwAK24RTyA/Dr +vl6/GHL9mva9fK+FZN3Ih7yYmnPQ9PLSbC+S5xJBbUXZ0H2x/Dl7sJrwwbMLVT0qmceRa+gcoY4G +5C4WogEJAkOKXsbZ2UtPfNE03MV8NLnCwTZZKKQZGkKSTWEo1PgMlpqXBHl+Rqz8UMWpzKiqeaOC +HdrwRfEsPhvr0377XDG8oWaOteB4NDZwAxfUeAT/HHpgKSeT46+fJ2Ce4UBp+XrTmeG3uatfz+R+ +UaP+pzbVUacR0OZcKBWVT0EU4+EhsRbD+0HYx/Uiqyfrdq0Sgr6JJA9ewmJClslQCDGtveMubLkc +ufVzwrfxnrXhd27n+UHFDhQupMveGCW68Aa3ypY9/mv6uE55nt98XjsO6rS/zMS0je7r3voZy2bF +jd9d62Uqh2N6ZaC5FWJgKYFw8AGkUoQgz32VapbLcVuTkifT7+4OYcVsTQ2hSjMyklQCfhsfx79X +vXB8UrEntzo7bNq7ayu0pYaEskN5IAhnaTqxuucO+TycgUeRaS/Ki1mxYrugQnYSbKnZaG5wLHzX +sSC5wUshdbeF3KTy+BCC/4CBJ+jzfLdzD8xJl/5ijLCKntDKvCzgDY3+SDgMkhR+LjW2fNs06HBK +pWMl2u3kjNH8/NYNw/pQ32ESATn/vfQk/Ez33nQ5NeR2fUM1U5N/ptvZP58U/oUHT5hgyzoCaCkC +3BMIGhqZD1ty/c1uHbFgbzMbY0JoOa22hCbhaZIRllRQd/WxuC4yT6VM0oOXHYM7kBR8ThD6ktLi +ARkExpgwHeoRRmXSk7f8ViauyOuv0P5PDISSMvh9gNl0CIKW7LBPrHaU2ZrIe957VDhdxNWC419C +60N/pwN57iQ/zwyXeJGs5t9i4F+iGfJ+JhGax6XmAZV+l9fl2m5pmrtvdb3m/s1VpsFt66A6PWoY ++HRtO6ipdJM57MyJ9eirX/McxtePKEPDNyD2IXgwAkV5olc8sUvcgzKzP2gWO8J5d2qWp4dJIPhq +j3jdTjpo1ws1G3jaL5Jmv6BzvSnkUT/mJYueAqLlGTQOWoKR57Y0V0sleJ1cfyKxPWNFh5V5wSfE +HLRhcQkHxpqSFF93MTC5WzzE74HSESaMyZos1mT6KugxZwkPDASQwHp7gsIn8P8jRK+Uww00HGXX +WbsMJ0wUHpAse6eapMCPCfkLJcnUa+fX4HD92WkJz8kmmcg3J2QWbW2hpicUMKKrTpfNt8j+oc+2 +CoEPF6qmOKXFRD2gwfwSDItEYAgmVOssXvi9W7yXS+f/4cub/NUiFSkV0IEdvk6EdXlX//R04pTS +pZ8Y1ltRZ1pUtKc1oO1p5LYZHMabdH4lH8JtUgTonhdeey5nc7F0z3MDNw4XMx5YhqVmADCW4I3q +Y7PqXxl83545+cj56/VVKSpQpRIxjACTfvhVj7gNXhodi/RxTOK56PlUN8zSyieyag1UJUKAgqVG +8G1oNQiyGNvEfgljK9KqdElm9jDCCuayLIFIhV0cRcpyRTLDTYadmgKm1kKc0j3sUpvORv3tD4On +85NvyvkcMTaJP/oXg8u2Z56he6tHA0LRIg8gU7bY7ppp1VlUzju1/k3pj4fvRh2hFUlgfjrJiYzs +ItF751TM3Jk1dF+Yhyx2djwzVWwRgI5NAJAE4FIf1/P0qsD11aUT2P497GK3Hol+El2EiLSAzx03 +WJt7nun8undxdd8jf0ePlZ/ZC+kwlCEOZgD+uzRYbMybaS/dxvDxVbqEouz9GcG++EDIJgmAPMFf +r4G4cvql6tUCE4akEVvLow7SI9GQnhzg0zisD2G0e+68rNBRqRRzxcuNnMcv0tt/0oekkWSIhWOw +sRWYjoohxsb8P7yUrlis2f2gAZPXf55N6V2YFkQsLkMx7oFqWch9d9zglqWSJab0rIJ7UHmX+fQR +yBFARgJ47j2BTlpvgumoTOpr203v4o6uc3h2UGi4K5kn/hcjDAq8NaR2VOfyvex/1oaVT6RPd5x9 ++/TBFIYDYlMlQzW+gWIXkfJ1DqhMVi28KeBZ8WrxzPQzUxOIzFwG/4p62CPdJHydUW6kSAWUShDf +vBqeqipjvS7Veo1S+YM72CVHG9ogW4oMfCuS8sLwyUPq+htrH2a4yB2O67r3KdgSBuqGRHgAanVP +QgAe/qS13V1WDakaaru6olDm4oTsc4jDhQzZ43ypnIvzxv9XN1Lc7LF6E/ctntu8ei+mNlZtD8jD +Wp+DZDvJLARBJSG3xld1gq69JJtRTmCr9s7SH1+zqxrgLhrJ1ZxcHfOU+x1a7qyQGu2Ci1cXdWBw +X9sP6cYg48A3hPLQfPo0wxmLV3m45KcJ9SyMd3ObsBBRHhnsgiXNw1z662tqeOZYdLFx3m/KLHQN +2bjuWptDygdkAnDHUwINBTMvdE3f2tn+c2WyKFvaokHt+vceEFn5Eg6DQuMfMj9SQw6Fudh91q84 +dfvnWfFj/ZXXbCKLgtXnIJNqKHiA2X0oRz+ygSP5cG34fjLCMKzSKAPpNYr4oE3Xa30PEt3S5gEL +KVoVX68VPXO8eH2TbT9vLQNPPAZSuqZkOOkHHhcJ/w4G2HpVX4UiUpsMtkrgjpY8UxKxG4ScW2SW +XpTl5sAUZ9bzRnHyf84mfZLO7OXIbWluYLV8B0lWQ5hINSLwkoDbpuHkdqPwcxNDuJy7/fPMdwpy +ORkhY9WWaLA44tMBvUlPi+KM3wfJZN2cid2XIhGOcBI+BHGlIBNhAbsWNFEbQSKjHOkKRgKP249I +zGkd1kErci5s2vv2qaQARPpFwbj0CAHgzXRxRzLYA5872T/iChX7YFIqpAPRKlKCDYE13Azl4YD2 +PUpcHiNUzX4wbnMd3L4yX8497+qvzHJGSMhHSWGEP7scBX+D3j6KK/w1wLl28eJkqKlaocD8h99X +n5omQNrYKGkAERYW5gLX8t08UUlnf4oZnfTlTe3Ny4LdqZAxLUs8zt44/E/xgOE567LtWNV7Bp3h +na4xMgozjYMShRA5+BIPxNmHm/nmIdZnQtdUDM0H9tSdGPaJMYHZ20hwqrUE5svEGqtGXV3NoGTd +vcr73NeBxDXrLx+gyQY1uK1fy/3qRkjxBcvjbz+mlb205ayrgIghl+AEh1vCLgKgnTJOd2WvClb2 +TKsP3rb527n3R2MhgxCWocGjBPbV1f6ReLuuMUlbP46U089ejXLQhBGHeUN+uMfCvLnntxMjWocR +TNWNDw76CPps+gfJ8rB1bOzR2CY9h/M3E/k5Cpq626R0dsjCUYCDOsANGOAhgp9et9a/krnN7JuY +l4SINTaTfdxaDQaMdsdfakpv643N7XR7Tyhttfc/Wbzof4PVOXgjpNZCxtG68AInR4V7swVT+Hpe +O0cwehtVbDkGEdSTSZbeJM5uJRP+GxHsKg+DFsR/FXj+OGoDqYYvwZY5R4IqKoCFWan/Lu+UNtMp +DeVVTPLPz+xwo4foBGixgLf/Q8NmTM4npyNv/OnNjJOLh76/6foXntJE0vensLmc9eKjrJpFvsUG +cTbrF3cgM5PIeKIcnOLB4csXGBDPtrqbqDt5+/XbQ9Z7PL9CpFdkOCEIWCbwf903eyD/wL7bHZNe +GmxyjEYaBZWQsVQ0GCiK0DtE+jG3xrGmmlcrPBhigtTiPi9CeplpsRCPpH0W6kM8byuCP54SiOIJ +aH6dxH0UYnhGg4Lclyn2OE39ht74SsV105uOS+/O/ozVhAw7o8WB8gQpHCqKD4gnKEy9+HViJGPo +mVGq1HWIGxINCuoW7UrWc2bzBU1+2a2XiytXSLzZarQDkpugQURZe7Bj6I8SzfIelhY7hdNJ0XVn +eGgP8SyGpwGrKxLZ26+qlbxtG1MJQ+S63JjteQFJdEDQy9XisYGP6or0zh98M7E9RCssqHryQjBE +RkqTBDR69vTGOlNKUGImrTe8++p5xWBLQ8i3h7zj0c3PSv4rI8Xuw2pSnDrJrjuYlRTD74Z7GDnE +dw/ieUKTBkOsYJ1uKJx8u4n+IOefsutKoZatR+6EQyoetEiWyuWE2gYSS54+T1J8vA6vsGUMa3eX +D8NeStx6MFBJ+uLR/4MeoFj1rGuXxyV6uq6tYkj1qfx9XiMTEBdeWhSUPhk3JDT5T2ep/nTkN3M0 +LdIfQU6XZP1nHsBaluKF97WtDD9z912A6PWDO9ZIlA6wjdRAEh60uMgziMArR3E/5xNuMWt3mAqp +9DMXSW+0OVfTKwHpef4XKRZsuEAQchX3xXmxq1dF8Es+YJGTfjkw5pGuCcmO/YMQoInT1mhOjTB7 +toHuBn9d5YhZhX7Uhf9KQ70olAko5nexVOXSbzto0XkKm9RpfDTgPzNRKeNtHW7GekjyBCa5ruvI +akzyvdCbDJkM9ncmku6S6IXhJ0H0w/e9QOdr8/BEFdvEi/QvGzefMTS7S3tL+0/MYIZ3sZH1lbT3 +czah61N5AQbltcXf4MKrf7MCZB8GON7cHTW5bWjQLX54OxK5Q/EbJFlKi4xycTWcu7uh8/eRbVK7 +EmLUjsublV7+A/GcocVDTog5PDgbyia57U+h4DexqtdvBXMKdU3+LxJCRpDUGXS9Afm+soQ5sixS ++W768Xjd+wdX/fi/6QCiQLPuih7m3YF7LDt11G8mJJ+xy4J0DtAgAstOH8xRqmtu2R8VfLhYfvKG +SXIj9i8/y5liRjf59ELKOYTwJSr5Bpu3JO7ff6JdxuHdKmnOg7SpqA4ZJFEeuBVqHj7QLuRhNFGv +FBeJaH+DSDeGOy5T0RCf6e+PVp+/gnxikem6idln1uBlPOc1yJzEZVDwxX+szblxZuCpZscnTOCl +shm7Sz4QdQMZRozL/2LkTtCW4HmvVdggYt+U6DJmulu90jx6OJk5FDIP5f/hBb2FAWJNs1F/lqLc +2zJxBg+aeodSY6ctIW46/4F4KSnNvysi6fQchjeJ5+ELa25Z3/HjtZBOPdqEAMObn+6nd5Q/5aoV +3ppmb7yKr3rWIu8fDBQpcnIQYrIVO9X1vNbm+S+R24xlDLIiqZEQW3A4GipbrxDxsYHcxXsxbxbc +6kuUWCOm126ECPKWkSzLmycP6tIlfr8aWqMw5bXZ30JzanOkFhwDIdlEamYFBs8C1oP2COAh8MZ4 +SKAdQemrjkvGa5ZW4VWRWWtCkDLTkX9kcyD6Ypp0AEG5tiF2LDP/pMMO/4yJjeklZkd/QNSfywnA +jcgwwXF90JXLm9KrjsWwRLInzqhCep+XcBTtx4FYy+cSyoN0hrw6uU1GD9JtfklDfIOWgDg3LGks +JNEFTuvhCYPjSbyB/Fdeea/S8EZ7i1b8pokHY/pW0ZHtfzb6aD66M2p2/5PA7xY/2KCArCfM9Kxq +U+XK2MyqVho826LT8TGFF9KqJ0MeNkOV3AXgiRYLLE5ex5zWjmBHHSvndT4fPwe3UVHBid6/xEQW +wCK8Qhdnt2Xd+lNPjOu10aKSmmt94aLKZSxk+JqOutwfD825c/qHazfX7b2LRb2GOOiT4IQ/Tq37 +BjiEYpTnf1402iAnex7dsJq74MF6Roh+bYljOfrS5s9daZdEovRNmmRGHmuvR3SaQryaSGjwTcGf +OkBFhfi6lpDkZnVehf6v0fp8i7GH42FSGcvGuIjbfyq5nCz57El/9onJP7137StPQQQVMuQtgbAy +kPdfzdkvMlVhdwo7/NCHfvO3NfF5YyHmETKEHlxCqxpxCNOzGty9c5wz+Q83yY7bMv3+biwlBCme +yVD34YO1o4ufDD7lG++i6/5ldY7jyWsDs0WYQwchPeOIAQzKSUcCJBp85305ZBzyJs23DMviskvP +bDgr5ugGc0jFv+Hg76QIQ/eGF6h+5TrJxcI7g9Suw83mYnogzTUyRFkUGkO8tEa3uMebGW9Iqe/q +ODIZyGaOuHMbpqgCDONAOpDbBYgxEtmqdI/+mzi3KAOOh8O8K/VP8dg3yk7CVBzwCyUw1AFcsh0o +50E84nDexDVGz38HedH52q9fh2vZSiEjiGSWD5IAI3lHFKHvrrNoi03st31PJuSDT785szXjQ68b +xP4WwgAmxgvmX+7XjipZe/9wpv/mTvXVqHWscECcJwK/6TuQMq4A9K3SUPgZrvHV/bY6yl6XQ7ne +qHLCHB6c0AhfBDlModQ0TNXeq0Nmhv0W73zf8LhdYmPmyw3pNPFoTwQeSHo0DRJV1ynVBb9pqLj6 +k+G1WOTaHH+Y87ET4J/s6O22tEl6GJ87N33HS3tkXVNhHFvzVaOzIZChTTKQ4Rn7dRVq2z8b2O8/ +Jqtu0Jbwds9QK0xFB/hPrIQjscpOKPNClw3RcsE3TW+1JS92PMnq9crMMVLdIfMvLnAF2BKUhAo9 +ZGh44+ps4dzNhxunJyGNETLgZkw120fs8OqdgddXnXrD3far5meA/z7o/AUZclTjhsCSY1QUuAvW +fv12ZS7oh+njFgXt+2zIJrUddBDZHBmPj7ZAAzyKHOSJTa5rGdL1ZBU5sImazz8xT1rchZgpkvHL +DNST/LxvbI8YVJHTP3lq3f7NOnwDuyBD1eCwWAppWFO9m9T9Kw926Z/kjHrz/Nl5q744iHwNz+Ep +QTJqJiXbnqKSL3NEH7398e6ZdIarVpXqDI2Q5kYZosKIKK8gPWO/P3wxa+085fYdYVb6WH8v683d +LhBPJ2ooxQm/KMWxfLW3lYcs88Uilfy0+2o3sBAHB2ow2U6Osi3rcflmuYbh6NvNVn9+6dfcvbB/ +9W9IwyIVDZZcZCLa25G6Zx22Cjx1i5bdPPXq0MgpRj+fMHUzSGO4DIXv9JImoGn+YkGKVlIFm06H +YUaYwXGLVAaY0A30nSZ+BUDRRnEtjIdZr9nFPYvosZO8E/DLKmg06g5MRAvopvHRCX6LxyzVUMCL +gK0SOb6yL3tUmLEFGYXhTnWJ64NMRiDgSS8AuB2B2A3pM/PqFS6qeZbhJxp01knHMWXBvDigjxX8 +dTvgZmsW/JJ7RSS2Uva2OKtCZSIHzLmAQLC0pPaN2ViZJ765Jff1iW3yykX0ue5siHeGDKVfSayL +kFHS+r0/zxbaP1Gna5UUrP51HQaAwtohnRE+oL0rIAsBMvQYtBshMQy+baXXWxoCh1veN85FI27F +b2ttd0LDBAm0iMDzMLM/D3Py4umTr9b1oH/+Uru++jdEmErNQHp0TwJwyae/VL8XFAtt/ZHvZuF8 +s4SObwGiXwTh9hLeOMLslLdaLrOFL63M6nRDHxjxvWm8eF0eIsgFIcCPlPDEIr0d0BSL46J+n5a2 ++munfVG32zZwc7xn3mAFGWsjQ9Nq42RLeHdRI/dajXtXmcbTvr8/aroeQwNNSr1hEKAM2ksYe7Q7 +5Pb8LsNNHC4h1irc7cUQP2kZSLOoYvJx21W3vIROfxusfBCT++2Lf3YHDRTpkhqyn9n4YdhLNf1S +omJb4YrWFb4YiKCICFlWegTt/IBpSYQxGNENw64Sdd78hnkj3TkROZce2uXCaCI80BLuS5VpEMj0 +8AyTyKj6I8Ukvjhft91PYz+VQlwjQaAv/uBHSjxRDWalF9XYGXJjtPET9lDpran4ppkHP2DqT2gP +T2K9yJqbbbj2/W3mPUP96lw+2mlD71bCXFxSZZ/S+t3ODY3ftpduMIOQTk1jHd/2Ap7ubBmVl2uy +atbAhL+UTMRDBlVol6RaWPKg94faqQ0fvl8s+lAb0NUCmTcoA+1GJccezPkv6+2Tm46Mib+yOet1 +9ztv/AJMGvMv3azobZ8ubedvr/TJ/SyXHC3EE/CeByKixxNgUE6EdL/rG6FUF7NikZhjM8Vn1zjL +ttd+hqkxU3t38mDOsR64Nc2gMZ/et2bxp1PavnQY7QGAwW8S5EZ5/HKPdUa4gt8yZcRCSCA016q8 +S//Nl74ruOaXYjDlek+y0S9Q9MffOE+St6mtQNH0I+TPjRL2b5VtESvdm7mPwxTHQLy3BxYNDjID +ditCcGWpIsR9L7Gwnc84mN3K6/iD2QwkTGEcNB8FDKcdyMWwoWtcpuGcV174obhitu99tIs+cQPM +YZ/06ca9G1TTUFkeNw9Mi5TUNMw8aOGB2O3KAJ4e7ghQwUUOKXqlakQ5w1CmXHexZaEl07oN301b +4IBETZC9nz0+HgCAp7wFeYKedPY6t9osRPNG+6Q+egmxGKEAko3sZDgOdHvrBhYoX4qbKh3KY9lV +eAL2m+KjcifgpEraBEnrBykJb27N9+Be6eUP2U/XNu7rE3ldHSkCU5yjcOCjsiiYxQmtuS6WLKT3 +am8or/Xo5ypJTZgAYJl/362Az13GFnaSBdcNVw3KbXCtVFoB8SOWIXnj0TTMG3rPdTHKc5HRfH5U +/w294dr0sjiY89RSGyClpR/V+oX4sJmR33hfwguB1k96tnmMk3lHYE7DFP2EhEQ12UNbr/D4vKcs +JkMqX1PMe+feugy5BpggBrTtQ2OIzS6FL6292tN2tW2KOGqw54rQHjvHNkd4DFlbTO33bT2yMzTd +TNx9oPmN3Av+lx47mZJh5J/ggOAlS9xMes8LO6Lrh+U5XtWKZd1xEq9uhMmYEX4hPtQCFBYyUnJg +kb4eabcxyy6VrW7UqrlZ+GeDXBJkrtgypCwBaZa3Pse8L2mLnN0FzPA+cXaRp/IwNWQqpBwB2XfC +gLmYPzY7JV3a4PW99nGN1ycgIzSWIQlpT/ACI8TLRU+KF1uMBL95cqsd4SIrCmkhXQYmNmOhwIei +r7np+7nqPw3rHzl8EGtv4w55/xXm+AqDB5cgtKMjMWtP17nvuEfHlckK9auXGPdII367r4M4T8Hx +EG6ynODPx3Ihyjba74+ptxSHJSeawezNVGBHB8qz3VmzQSOdt7kajT6mKoJjOezNN2HWiOV4YqgN +EPwpf1Mj/Vm4OCIgw0XUpr5g/ttpmAPCcgJSgK3zie88XajOh8yEhTnurOca+03rYLSpy9EYhAeh +QiZafNmF+2jpHwFTv8yjAg1d6uFNMBm1ZXAAeE+azjhM9UWBk4LGtYEQDZcjfj0w+VlqIP4/QE0L +oeX+1NwX08WYjAljVWt5G89FBRs9iDPsMgJAHgAWG/xZjzD45XGat7TE5l55uyJ34SBk1OAyKPkH +3zyvU+37WN6/6fqTIY5nAr+8b8bBBCJUWDAxTdq8JsYO1LAjGp62mRxIYbycL+HJFQBTo6LEAyhu +ltcP5dcJCMu/cys76fm7US84ESZtQUIBZuXEDE8c5slin57wTeaPCZO3vUYe6F6oG6cNBL8p8SUl +q5BBHRbAxZVbKmZTY/1RZFK82yumGze/fgYmPIE3d/vNIuRpoJ6wPTxxNevq6wqvs869gkyakwFS +cVgUDuVDVRWns/VslT2tZzBfbvzpwGRMtMQBVmlYKI4ShalcGzriMtC6e+XqqZtn6TsF75yHEQ6A +MRT5Kud/Hdz0PFiCMXVm/IRHaVl3wEAmjACFln3bgaBPklpnhJ8+TnzaeQajVJ7IqQ9z9KOy+6Ls +Yvv6SvD1joSgnWVvBhl3N2doByXsh9kq/+ZjBrCY5hwSvnB/Y4fdE/XPm8QMVBL0vSGORmSWpUUo +LrX71YvqUOuwXa89LgSWeNwbdYJ5vkgRJw6Qei9lh7ahUqSvFl0rKUl3La2Ibmo8/Li5jiYYeAeB +qwZslwRPXbdohwQhjfaqZ7vNzT548vMlvYPZ7yjRxEMW4dsDxUnwJ1zVkRk2VjY/zjM/eubnbKAA +d1kAxDwJlodUx350dnGW4cFGgY93q4cSP91YcRT1DmJzBUcAVg1L42cdJBebGzyqWX4cMSga/FIH +8WsjYzGO9hLK0tKyFJfw7kiy9M2bknunJZGNOW+a18/d7pj6N36p8h3F9Y6vQu+S+Jhy1dxr80ZF +5h+aMEkDEh7/D0RtKPHFByhajF9s4rU6/d1wqO4CT7qupZ5YC8zBmIJi6denK772OiBwdEenWteT +Vq+rbQ9dK2FKWST7E+oYF8AXZPXIJnbdLg/3zNGaPdJXOpAYAKMppcaT9fUzfS5fPp21me8Tvmvh +Lv+ep8m3EUbpTAbjKMpBqdlo4QiR6pgJQ99V/PpBQ1dkYmFEkUtQGLl2ZMO1VKbAe/bSW4tN6aXp +21G4VohTOiUFqZ8bmJBF8fI3y+9wKnmysiVo+2PDM1PntzowM8GucQSaZTJriptY6Ozl/lV4S+9J +1wHRrz5D34o7z8M0LSzngQr0LXdli7lFSHMrKA/zfO0tThqOdIGY/UF5MEgHbw8HBOGRZt56rTWU +U1HxjKBS4CW5y4ZPmi1hNA0kCoji2yhZw/KB99N6ubSEti2BzBE35L/B1AWXLHUwOG/wBFun/2QX +/48ujm/H70dvO1ApYnf/AaQpnwIHrgAwj6SRyUZpPUfnkT8H1jFMlTycLHX+CJPUorblAW+AsY1X +aN9WnYSXct/XqPYJyPntxNLEeXu4AnN9qRqxwiNC3WOfFCu9kHqpOWy73nmVyxOY0spSKwMS4eHt +CSSaPJwoCz1gqGGGTrd4XIkosd5y1DPtlu9JBJMRbSonewq9Nn73tnfG303iGh0f++HNaQbOyp9D +33/e2jXf1XeRF0Z+T2aC1Iu2GN1T7O57OJYSUbZFfeCu/E31NpgaBAlPmcn9bcxt8CHe7ovRdI/U +L5lQMR2/n5BuYwok8X7iiLo8xO6h8PHP9eNVZ0Yyc2p2dGJxXrm00RS3sarzVYOOjUhSPNu9L40f +PN6n1blAeq+XgECXNVhyNdBqaajOXvlqbadXrg0iVaM5QBUmJiVnXmBSKKcv/jkQ2a57TPXudavN +ehMl1hv5YcLiv8ugSg5fMrE9rPXNbcWrU4XCacxNvFfhFhNwJhk5YbDkKEW1OxtldwY7SWkyJo6v +3pcVfDvmq24ApDH2L1wAhUJ+uKpWulH87kcjO8RsVaUrgjAwDVnEFYD8yLSHs9zl7LdTTizUKK3P +1LrydW4fZIA8GUVoeiKcDTBAfRgYbA+w3O6t/Ogv2BcdmCgY335UU7DqZiCMopLCm4TyYJWz9sXa +trY+t4KJ4qZ3q9icQ5TrYHIGy4xN3jmIHxrjC6jJNx6TSOPnttvw+BhMowvVrQNgl2963T87zy95 +/ucp+tcvropzfkyH6RJbll4G80xLJfjIhrIKtYHVjS7f2G4r3DfrCG4bhtHdEjkIuZalJq9lMihv +OaexmRAleokJoe/imvNT8gLZMBVHkh8ZgKgMEUkbFe5U6WFcVfVEm+2r32IApK1YBhTq4J8vCh2M +9vPwUCN6748T6bvkElam+q9p/wrT3YZDo4l1NooYX3Ihf8PoqoWx7Xm/ZbW5VI54+F23gIeC5TEK +5K+zPn5tGrUfz4SsQY2H5juKZayCyQSSkZQrUudxc6SfWLDycJgNX/OI6pVtYUgY3eQSdCmHzbfP +qSgOUxOP1cxDsqEWuGVEdA/BIEnpe1LvNkXTGvjVXyidvcd2DhMQNbDTnuf7oVZPRTHaLADCXSNh ++KHEohu/Mb/f58wF0cYtUTDFUG8POzR+96Z6pQA0rn4Fap/LHO8xLjtr1xbe0gkJ018waE8HQgJz +6UIlFmb5MSoGdp25F/G9u/XKnNeuCZhKFFCEIo6VkiBO5KEoMIEphhoef8vggS8DDoyf1SrfJKWr +yx35Kw/411nqs3mbneIiRLoM0D+Kzodwu/TDPFYgirhzkiNKycNMzIrNwQhDzEyJsDpiINdXAmLG +KIM/KwNxIFm60nxXV4FnUlw22bgroeKzyIaytj6YsyMRRLxalKY+Wrqhv+9FNjFpbK2SFdtDp3XI +vlseBg+1IBi+Nbbx1ucYge1hHkd61zWas1WvWaAFXN7MNWjB6nMDY+z3y0Hh9YeLqDu6C5UQ+wIS +lqjwJz+XkIbdytTvv0W3bim0k9Y7wN4q8cBFPBum4kHZ6790j7dsCGNm53sQ7fhEjvuewpbhP7vp +YBrfYX0CNhz2OiqVUbNz1USn6BbbNA125BWI6yyWkMQgVlmJdtKtyd937S7oWZg4EnNUZoq11v1g +JqQZDUsw4yHAJajxsdiG1r6IpByWJpbOzwMV0R0jiZAlkox3IMweR7hRiljoGEvfNVeHRKKd4nL2 +9PHuelevi6TFANjm4DDe9jjCM4pid70+fXBAqfhUxqbVeUrvfV6fgxh+kaFE9R91omDA6YBbmIpC +EHOw6rtxIcd7mhcgzhwkAmJAQF6LMEhiH9SDZpkAi8L8HyUOr/NtFesP9oTMQ6RLJBInJA4o+gCw +iPzz4tunur2tkpNsE5KObfr4IQ3S40qCEcIaElLCMN7jrt9mD6mQVWtMe/IXT2s1jdFGEr4t0gdF +/tUfhKM+NmftPo2OEdmLS7bb2z4nDjnxLcejPCgMABJRR2+m97eWX362X2y3SONwoW4j3NNGRUC+ +XM9LSsIiVmK4/RlYvgrUpHXeKuOFpNnJYA8UAHGm/6mYOSdZFTgem72YIsWbxqxHG0IYBUZO7bJr +psp2tbtIZOikpj/ewjpcPCQISSqQsGAIS6FIz0vITXy/4+Wjc21/mBAn+/ScV9yFtBNhl5yqvlR9 +phv4cEIUfa93V5Ms744tC55wHyfpyNGOhIeSuAx9bL48w8rCY43OvvGFmd0xWPbe6BkYNNm5whHh +jnID1xwzuZY7Z2Il5MrQGLE7kbal7rMPIAJ3LJWZBIA6YqysopzXejjAnv4gbiI53X4jVFKDJUt2 +gRbOo+BTqAcOnSP0mXBmV/E1mAh0P2cq3dcc1h7/MeAp5GBC5gDkioDLDR43F31j/FtDqGR8hAbP +NJflaWUJf0hekowjGygS/RXJ1/si7tup0uOKu/IfGxfZxhRMa41eh8zvIrMstcBqY3KZtrk/MWxB +POHS3hSJmMLNQQouFDAPpBMah0IQRwu4o0AOTLRPSdUdPnchAQ6ll7fDP4aEPYZEmRQcJIvZy6s/ +a517IHpV18Q3KKB9FrfizG9IjodiZpYoi8HP3+KtnkKXBeJSLr49JfNdCRJlkSd8kWVnSw8G8pWF +tAbLNa/g0WMJ65xR2qErueZp4oFyNg4N/huA3Wr5LuK9vnSg7a82qeLzXPQsefGQUyN2qbHv+Knf +WAfzqNheb7N7OwdQIhZe6RD7MSwgygUPJkg0mDK7P34Sech94NPoRdfpEuWCpIxRU4iRCBbSTgyu +JBLA8RrgaPTe51ty6VmHtrPgem4vNmFVfhSkbIW/JmiEIxYLPnutPQP+Wp0pO8+Lq8ZmNw2YJHgL +VEIBFNO1wF1Kxu6qqBTngzx0oBVfZOI+iZ5+B4i7Eh7lC/6ujvZA6wdrftMluNKLTFiZqwkyDUJ0 +JkD/B1HJTnSLIscTAIUVX12clFNrnO1I1dqSm6K8trk6kB4aLJUdPzBggVK218R/IzNwGw/6cvbn +hzIdf951pvrB7MyggQ7pybFDeVAMAzP72rPm4MnXRkhUj+W7OqOt4+bKkOCRmgBAPdFJnd5cNJJW +f+KClFaK6um3MTsg054otTJg7LjsxyuLcsT71evmGVbVGFzs0zi2Wt/D6W8cwDPsTVgTuvb4hsqJ +TVy6kTuhUqaasd8vaxCipMKSc312aDToUkPuUJ9dmYF8xMyiPbNHxtoVe24nt/OfzVC4pyMoiVJj +uC2uXvG20lDM6nyf0IGUba98IAkd7LIBhqA1G+VkrzVSI6vkr/B82dco6+X3/GfELtkRSMfFchIa +g1LHn364XBbnn6G9+UP8ipdKXT8CZSBGRMupyMIZqi+1czuby2x21evzJ7XrG1ujkzg22sCsz3+f +uVq+8crYYLyXSBSzs4rA5ozidrOXkCTgcg7QiN8THFpCevfA+ZfbCstX3xsIeu8ubuFp+3SjHNtz +iA4LSkV7fmvG58dbzS/tCTI68fihkXgcwxk/Cchs2n/xkZ2GX1ToSb8yM7yazPZDaIKz7Y37J0h+ +kSbXsgmu21eVKv9+lMSi+Uh0n9sxNuF7E6cL/isXkFOg/I1rTXy6P2PP3R4uX/lIN8Bve06JDqTW +SIuL9NssBM69kD+3OfmJiXzG09C0IIuaU5BhUhAO0ijX6rLhGflwy7Qnu3z93Pf8/KJ6UQFicbUc +vHyWa4pedVLtz/itRTIHmLVZr5zkc0yEHPOXc1B5N385wcL3/VGDzpc15dXJeY9N12ulQSStywng +Z4yqMXq0jsqyjz7wr5aovPq5naF3M8T0ZzkTwbqKbF9LCFwAMrri2N9ZuufSfHGV4nGolacStz+E +aGL+TgbSYI7F8Rt3rlgn/Jh1tuWSUNvInTWQNP8yGsKrqd64ryNmN2L9GFcJt836fbxvz0MmhGOX +lizKsZqpL+muVjDt6rYMUjgoHnKWI2PRfZo2dNkkwvM2LAIudYUqZ90zpLk0Q+NdzjFCqiGA7tDN +ERhDiARr+K5IP3sgnYH/B7BehEEQ5AuOpz6qm7+er5VB66wrfiGbpbY9HqLnImsYIWXq2KIGXHkn +q8V5idX3L8g4Pj7n3wupWJHRVNO6bi7m/6oLx7hN2gRNrHDaPpVzaxYiCVuGhBnX9d0Hw4ugd7gl +eYXj8bnBz8Zfmc5DrESWsZCmYqVUOpXi1qp3IKr4RYJjeTb1mt6ANOYuQf82zOpXtN6oZ05uTISU +zZ+wCsfOgN0KkFQcmWnZKCJQNaNzVlnbWDiH84nJWvoV+3f33eGC9DyT8X+btVKb/mGN7wW5dwk7 +UxKMQ51ibeUMIX6CECIYeaqeqfTqts33a+uVO0J0dee+PI+POEyTZ9ksDDAVUfZyUDl6Nt6d3nxT +2Ltpk1S38lA4PJw/+qdHsohtvIhTnxmbt6zVlTxhTW8Ah0UB2xvw+XumYtwdgbhMPtTb0j1D8bqb +tCIuwXyeOHxrKV3ykMWk5c56wWDtuZ6NojqfzN4Wb4b4jGPB7BbhtHOLz1kk1aSc2+LLmlB/XkaT +jHFtyOgzqrvaPi7ShTn64PoTJymU62jx9yNKNpB2DyzgH+phTywwVfxQeHV6/Va1Skwryy92z3OC +hd8g1ToslQs18IpLEN5xMJ+ADLhmXyX5sbtiOrIjnq2mR6OMavIGyt4bsNIHn7nShdtd7S97bTp4 +xUf6dnd23RzYtfyjnt4efqRKhOj3yGvJdnaW5xPHNim0tX/ujA0QWP55QirQF+VA0Gprjvprv1rj +clVaogf9JfW1yVB1dd5yCOjuTfobF4/HGbjlBjbtbkgsyT8U4+VF50KlpMIH+uAJhmRKC5yAPPDY +ExS3dU256i7ta8JfdogzG3TjVMsO2NJLwnCgMUvdvkBuHR+I4JwxRO1GzL7bJ/gKLU2Vt28wGLo2 +JPRz9UA4PIczAkvxvxzx8Qf4Q0xvrl5fHpGxnTPGVvSebZTaqrgGQ3gCtCcwXg84mRNfYdmpDfMa +R2sWajqi+a1CmVcLtetJ/AUKXgdgxo4T8EZTZIAzimo1a6qunPL78fvClhle1/Fh5ChtHrBYKNa9 +GRc6iZu5kDY9cCxmseuH10p4BBaHxj+H+E2EJHVKe5peeDz24QMRUZtxlZvbWqSzxDjgob6AHha/ ++jm6IQiSXPDVKgooZ5BXVb+cXhXa0c9ic+C4av0yOA4w4SR0olqGmUec2TD6i/Ht3KT02bwpyf58 +J+pP44AUnxtxswKbRE7iiF2tSA9yMZI7aVHbODWiRXaLz8/Z7rbfZtHCr2B5HMEHS3v1Zcbe4x97 +g98/Se+N8vv8ZNCCAfbj7mig0g0uiyiCsanKys/WzdvYFaxc+daN42oqZcbehcJCQctl4PBITGVd +rLpnfR7TWGklrtA07hVwlC7aowwWiI8P7EkHTyKW/ssES3xQHsLmzL2ZjJkd77P6+lfAYolLCTjt +EYO0RxIt7b/16160ZbY4GLGgst/FWmrS87C84D/xWKL5j1bv+SmGa5zPmO8rX4xu0/Tbqax1FBZM +UWjZi/HzJMirszMQTDouRzaqKJp2q61QDEecRQbRRjshcXv19h0BN+IeNdarxZmzWkLG2eUlM7w9 +9uHbaAOdkW6exKzEioHUI9pMmrWKq1bb6t/IGfD9JPSWNhCFxT+RKPyJA7/2EO42SNIx8srGoGnz +txv7RSXFJDrFDJzseWiTeAAGDW74MztprgFAwXHyXCti0XBROUtjcF/spU2HXj7F0KZA2wGpOPBv +49ZGGJqdatXqWfuxlZvtsHYPr3k0baAvPnDBH3iRGPzfBm/2xte/TW/oP9x+h8G3+sZiwe64wrpA +WDixGI9eqssj0R7EF1O1wdXzEv2ZzLNb7Pg9DO69GhAcpv+vJJ5EVeiNOvErj3NEO9uPj/RunwqI +S7+Q3Q7L4Yu0wwdyRDdg/DPojSH8krQjEmdOhXo8F1URyUd+KN1f01GU9jcC/PIATFbAoVGEvIfh +DpnuYJM3br2L8anzzLPnOZkFGP+CBzM16x3O61WcbB3yDtu659XVGDl/p6ZlEPxvVtLGby+ueng0 +glh12XnGVcwnKtiyuE2261B5/jbOMIPZ5Tjgc7uurJ3USZk8G8G+MjX3G8No1OZRqtfBFeWGfwuR +TmCPBn6dQyLtsOBb+OkUHY6r445fuXJbfZ2dfdUNAwUq9QChXg8osB2QOAQg0cH/TWckhpCaFYvw +HPutLVUnW6I4dKRLRb1+4qPL39FgRjrHhXX35XvaBz5bn/790dhyt+z6jfAopB3CAXxu5NnpKkQE +xx2+1Rz3/8LY+ouhOoSq290dYY/GSiA8PSWwCA8HOzSYM7LNd3rQpRj1+PXQDuO9xs0L9R9D86lB +OGdAZ+1AyJBWZsmeCHjepTR7FZ20M9GpJaO57A7VxwmNot6gAxTSnbSxrSncNMC56o36PY2mclb9 +y0iDlh8/qGFg7G3vjADOlADiUEzMwTuHdS2vHzmfuzaqbMWe3i8uMAiC2MIO+ILknNmWnyXrG02x +rhmydejbvENrdFnuUj0P7ih7DBqHwLpK4ANubyRh28eQlTGoliNHM4/EaWMCJ9z2PzetQHA/7P0b +HB94SqDc3ZEOKGL4aYaNTlJtRHbeOcCR7fRI8FewJGfOPwjA+kdgwyE1ybeDgrNPGyYygkJOH95s +QA3D77sIT7AAJSUsaZl9cKqvd+4pu1n2mpaJOy2ikM/6OiNwvuByWMzjbsdQIn/JQS5076Bv+h3G +RyxUsb070BwIDp0m1mSBUBjhRhmFC+56QK9o+gkZIiW0Xe5El8rh+4JB1BTgbm3njXLDETLwSglt +PE371ggV0/+xYjlYyxc17tELg7AHHnlwk45WwzTme37w8+ShK6mUaZxAqB6F+7wzys0BQwi1Pr/T +NZqTkPWNduR1EZNfuTbv+CwDHASFsfd2QwBuc56Ad46HvR+lfXLoD2X84TmW/5hqHurBZckxjtvy +B/7GgvVzd0N5EOr839vXavZu2KJpbnNE7ekRpz/bT5xOgcMSir3EWIbQlQrUvwCK3zXFcsefp9Xv +OPGua9Eqpnhe9t3IPynAh2Dot+MRZaZorpmgK2UbhhUHXikrwQAJVSrAJhcLRvkkw9waPT5U/tnA +FWPuJzV+NcTdPf6i+xAMHIXVXrqntwItr8xzcyYVMfX2tyCEPNf0Np+GwQAer8CRGv/H8JEQgugX +22hy7dZbvdZsq/PfNV0m1Tkf0Es9+QuYnPeXi7/BcnAsakth0Wo11uPHij5teK4JgwMPH6A7Eljf +dUOjXQniU/O2CPrCrWknvgaKJ9C7yO4SjhyopoUHks7gHrxx8m3LlvCrqJGJzBqLT1b9ZtFoWhhP +Ymss+cEgs2yfbniInNwb/5FemD674UblXJQP3OUidGGTvzrBU9VyFaPZ9zsnThc2PJ61O7PC320Y +AwNdCp3AGwwgeeTNgz5OtCEVzVRNlLk5CtLvST6DQXoiMARnecItIi5+IX/Mx5r5hPXMFBMr2e4b +NH9fEdRFGwwIi0ATRyoOpfdDC52cteV5uOr06lda43cP3jCH4wD0tYCnBv7348jg5s1xurbMjL7Y +fXVPIzICVlvZm7DBgIEjJhDlA5D89MozfOUNR0XomTMtozTo48ylF2Ah+LMSUJlaejJ8CsRVpao/ +ms9u9YsWSRyQ+3y0QBYOiV/hwTvtjvZwRfoBltOEeSh145dziy/xXelMdbirI8p6jzVR/iQMHhAj +Ah9nKNaI6I3D7n0k991+boXLhw8OfelwHyc8RkAnLhIYjrwUGc+tvJ1z8LjjwInHg+fua/kpPbw/ +9BSGwAeY60C4nAxhgsK13x/q3na3EjBbKxhhrPbeHwbhi0GAF0QBu+7rrZhjdrVenztnPrzkfz69 +E24NBj7uSUgzKfe3yU2OodIv2I3Nd52VtY7BtVItnh74Iw3CnnCoWlbw77RvjXRrZbMTTbbhYZh8 +Y+F0Sa0cAqUWQGrtifROkhjgP3v47Z8PHc+/7ZW9+gsCIcwGQbg5ko/kL2ZEcy58PbBRwc30iGa/ +kL5zIXY1BLZMyCCBwH9Pd08c5aw4Yt4LrGZuORsf/q3zMqcoc2VPaOBevh3PnvzflMR+4CUHv5P8 +PnHC668zv/r5rr/cTGYxJi5C/Z+s9mh3d4KpNJLiC5rY+W9y/FGwUhKhh8yzbpdk8adv+icVaUAp +kA98yFuy6szuLduiXkSM/dk/fu2l28F/4lGePnKOKAwhHfFbf6xjZCiwarqRf/cw6vzsjQMdbv9i +AHDMndUqaI/krMo9PKa+3Pfaa1PC2pbj7AgrD6FxlBgLkrwVyJbwK8ckknWFpkaEnNC/bacZXlXf +uH77/yECOO5sz3xvJ9+yplaXsePkyi554/sWV/4bB+lbxN78Epm34/zp4dvjygn3m5l/yMRp/EcG +cGIUGkuWaKnV9V2+qCxcUcJUJzPXf4jJc7/pJggVeeJc00V2re3MAU4xiaVGDjUYztZARBHMpx0k +cL4owqFvKpEz43tWCJOY/tgXEY0UTIKl4BEIAnCSIGWcoriSD86dWtmcaaDumnKsLXfO/xgaAqAa +NIPZ2cYwwXk94IHk1W92gqHIxbs5UxAEsFBIkLKILai2kFWfWuxeNMmsv2J8W6zgRfQXeASwzoLr +pOYs23v2hW2vtMoFdWqiJdmrrnw7BA8hDbMBVcwA1C8nYdhSafzukVVfNz6d1lyRiECuWw61R3gQ ++8MpAuQXknMnZFMSi8S/CJrezlJP5WBiOgsBArErOclESpyCVAAFf9jtH2bzjedivZz5Xvjp0ic9 +GRyCUBAkPNT3rf5s0cp2q5vbx7R0Ix/tF6jYJvF2HwRIUuXAiCZTdqY8m9/Fvn2dFr/p85n9TaFj +Soo08ct9mx0TmiJkZr6uOuGwle1aysP+vP6dgbTAS/OgcGkjxkmrp9r0G8TubrIQkpEWHN77dxQ4 +NCVWWuvxRXHLzh/7VrC6bRTd5bczJJUWDBDkkjsYlqTtl45xXl7YqSY5rDCorIzUWbdw2AKycpMp +vLE4tDsxYsAHWx7E3DxJ2wRWEds3yTQIGtWHsszLOe8RwIb3Hdb9TIuQ4rph/5Re+l0fnMDPtls3 +0i0sZ/xAzWZaMPL5kpJA7Wa4vOu+Ny+3T2zpZi476+man9nybwKCYhhM3NbMHjL69v7A40n3OK3c +o9Mmp779poX3QANlV/A5jxsN8Cgrvh0WpyG310XYd0PJYcgasYQiO386s3xR/lxco6KpkJPwfFCX +a3Oh2nVaMFJFDdzJgY2ctI8Ljef1SdIXPx/cpHZ58lpcqH3q8LZ/kVC0jhx9fbm+7k79prQF1t5P +ew5VDrb63/8nHJAP4LFsSiy4sv0lxvNjr4Qs4zf5cFiGaf4LS9oBhtZeeO/uEZX1YrBtjd9jCdxZ +7gSaTxwZS0zkFe8e0DmprVv6MiPNLV4ioJlDIG2MFpZgeLVMUnyOq4x76n7FkYKkqEhPm7i7RWOv +IAsu1UoEfcMvf7XgTy58EsD56cHbL3m9JuqTra//TkE95IRw/NteXRoY/Fr69CHT2bOz/jinLZn3 +aV59Aou3B5BkpSJJEYwdLFiTqBgpYrn1xx/9VoaJLzZ/JQFAvHvOueRcw22eZp5PLfdgSik+5/di +OWjpqAqcarAo4EyG8MAv7lggevUk7Cs97sPdr4010lOCNnxWGnrnZ1B3JAZCBFS2KZcNMIP4dWdu +c8WjpAHWak2DtSpyJjEekA3JgdTrCW6TMqMsQw+PqZmF3Tj3TMokU7RgHeTdBADElQnrigL/ztqu +lljxXevvXd7QapPX/sBHuDaFnzYMQESMKYl9us2x5SKK8+Uv5Koj0xHaNyAI4pRlUhSu4PkjRVh5 +R9Ew2iWHP+YPv7WmU9ZyDBJYIVEeRI11WFsUe4RC3aIXinXlftU34uKTrJ0QhMcyv2YOz6pScb65 +1ZH7GOTQ1uW1h2JwTnAgksMqxRqv01x04Oxb4bV160ctV5/k/F1x4b42BAoGW+Q99L5r0HGOqhOv +kKPbxs+tPLJvzcXdkBcchSVc5hDmBZ+CZKmno8anK52cTRnvFlwWhfusD+jGsutAhEvtyZJt13Zx +JJU1H55HsSnEwX4aXGi6HrVvOMXxpCqYnrk2c2G3yaEkm9rlnwakQOSZyR08tTtngvZPWS9k8SJU +bqvo9j92XA4gNGkttZjEPn3PsSmDvd9159SLWpTKwVvcz3IgGEIwTbUagBZVOAdCMujQwrPVFU/X +n0i3LKhk9o5wevaH7SgNEoJiZNmUYPyPxu8QOAlHbw/yaqWTktWntE9nvXyW9sOC9WX9CV0c5/8D +J5jP0ua9vzOqx2rlAaNeNzVNeYmvYnQ0oOTXbF/mE1TQ1+fWOTPSHXdWxBY9rJNtp4U5ae/mjQXy +B4RsOLhCg6uCY29R4g6jU1zev17qRF/sZLqXdT+ABomjAzgNr67MtOjumLx9/+ltF3yDuyX3GJQy +0UAQ2icBgR/w54FbAU68XPdxZaXY3fI3Ut1r9sQ0vNwzwloAiYOIDCQRHWlHCdE9ucpxf491ulG8 +fdo1zm7/Iv/9tKD4Z5KUZckSXcHVGCqQ+M6Il0e/zrgh/3EOJMohwIjPWKTIuXuVP6p/frrpbnP+ +ZuyuLb3rHSAAcFwmSe5L+oZNtdM8E5btEuIbccdqnNkuZkeG+MEiyfcxhv6oprHE+a2xse8c1zBj +psQLJEeWI8iFQrI5BbIF1dLyZ9NrtY9bO3PKqm/Y75M0XI4i7cdLK2ay/z2mAXRZV755T5FZyfbV +jsUvTy5HgTsxUWdPoWcHv+oa/hJbHdPh9pWVTxVuJDEZ3LGExNrUBnRrH0W0fftWmpu3m21P1aFL +/gGh099hEFjw4i9bHO4b2yV5cDVjfyZaidasuy5fobbCDoLFfzNPNOHbqVasczXgMNfh50nCxPtv +OIFqmzCFft5zyQ5syZ1goWbnNbkrc0i9lW43O6a4wprf1UnCQgnzq/F/kBwgfTnxPuNj/Z7WVfG2 +U6y9k4+zwli3LoeCM8pJ67uAhtWKvn2WW+OGii5ydR2virDj3AgFuKNxSMjDhTjBn5Cy+7dJyJWg +fc/VzNf75Hpu+DsUQGVwNCS9e5z7+cChfN9Lz4/nuGWVQDZWsA+A9GdUA6roKs70rKFT8cdim+9+ +745LZV0OgBUDAieK9T42KV4pOSa3/uxZGB289cnJb9SeBpjqOB4pvaF1p5Ty2aJKLalTLk1RycUy +lTRw4OGI+JqTXXaB4yz4c7+Z1VYfqLHKe657uokx43pt2VkmBE0imImshaZG1c64Av8Tf+5YYa8f +ZH8vqg05kFKJCUkBIwIcrEoKayjNOBi17eMERCJDLh7zu5AVci/pSX0LJJsBR4nytKfS5H23qvPo +38G4zvaPnnL3w28T66KvWv2NB8AERf9aLTOcsGc9s4N/YYeOeoFkGORgTsSAbQ8UKkcAvodl3h4t +NcnoMzCRvS1hYWQg5QFkSyfCiXeErCkE63BgnfZb5HXGw+eUdzn2SjStqG4fbvsC2WRgOQDwWSmX +mdz1u83vdOYNW0WHu7FXqc78HUx6M8NTd1xT15/tZ3EdOfSlrDOobVvk5N+RJLtAilt3G0ef/uhF +EGJQPDjwrdNoZm5SlAQNEqLh8ZJGFLyV7ghXJJbgv4rwQaDcAO0RQDy97mc4y2Cm5NotfZIG9lvS +ckoUIasbPDGAHky+Ijow/sO64QtDYNHi7O/doj6Q9CARTXGQvTW+2Tv3c5tR121+zqa2mcFKw+5B +GiiKO3CFL3DL9sB6/Vl5Rdyb+prrBk0cl2igCHsH0Fy+tN5ZPEu7xNFo/Wq9luXelxiDUhmjsqc0 +4ORTT5pHis4fzUKH0C8/q+yfMS24W9NN08BQHnckiOcdIE3l4G2PJFVK8d+IECgrc0u+vuWsVSv7 +P9LOPBCq7/3jtrITSR8ttCBrhJRK1mizL2UpBoNhGI0ZSylkTSRLtpBKWhSSJcqWULayZI+yloqS +rZDf3HtnGO6M+v1+//Stz/e83nOXc895nuec8zwDvPvQk4JXHbv5Yqno4rCei2YS96fPGz865b3d +9nH72DOmAyd62tcVU+Ggc4+LcxqA52M9ttL8LMCM7XWRdr7V6jzTGfh0JRw0c83utCjMHJ5fRRfU +UyKEFflS2VsGZ8hLdJ3k3/FV5ryVYbX8pvFXRwvvVjclOsAIKKS0fDkjPz/zUu+6Tt2Hk3MhnZVh +2urZUauooMQN3KBlTdzptbrEaDrJWRetmxDvZhTQWoZIHdpIjSbFdEiFgCjE0BPvpZub2eTQyJ89 +z5J+jSXkN0vj1v+jHHHRguwhcb5a67Hp2tcBp/Vq+WmjSdjVYq6wiN8y8QUfzQoQ2KHs90WUo/qq +au8VvWETdYWER5bhKwsQjaetD4S5IsvOv3x8IFqczydCJaH/dgt1kPxotiYty+0nHwb7L2+99/aH +sbTo+g8pl6mQpO3xpE14nZ5iLU0FW7nKlKvoHpXa/5ZpYb/0F3TBq1wj2podx3Gr5SiOQVp2C6N1 +2mTsdios4MrCi8M2s1214lAxiDxe5BJlmRSTMDccrbCCAPmwe0dixC56ur/+m6Kkv3HGVnG8UinM +liNtOiS3w8HvwMZg27geTadJcsSvtOxL330uC8MNAIh1xkiSYnSESyBcvzXkjylO5LUWvKrJSn68 +qtKuN1n0nOixZCoSQKjfc1kfEe2w/+haFtVfP37fjJP+xXfG2wYwM3sBd0Uu7pnML5hEFyhaXg/g +u9p04D2PfEV9rduK4MLLoous6Es3PIxj8S/79CqDrti8N8eQCkngyOaE2Dfx4rw7M0r35yf2vtkc +nHaoFBlKBSQt/S2MURmO3UfSLeu+JZStqn6AO5zhxlsDC6YsZQFK6nXOR9Uyfp32xw/jd4jXVXr6 +3YbZoyQKA9VCWfNJueMO/XHu902SXwxzpTpci2DeOpGAUkssW3o9gNwTdV5kIChK1v/5SLH9u59/ +YmBBzCX8gnM2GJYXyn5EoZRO21RBnKYowl87EmbdL561fOOEMIoYxvM3/bl5JwzF4mV++uJXWGto +QzIW7Obq3qrVEUP2zauYx9KupKik87tXFCwHcPZYDA4HGQ1zyeKfM+pVtmcGmB6+weu4KcF6HSxO +QJYQbjG3aV7hdESm8FHvg2LVutxlDjrfH/jKLgdJOYfBMJlJYPJM/rpCh5z9d1AJ+HfMB3MOUWoP +e9Q3hOJ3j0f88BkcQ3s8ntT9raD1ChZeIgeBDx+aJJ8XBL4QjPGz/NETmbIhB9ETc/UFrDMRSfJD +VDvF7hjKrNp/N1yT7+XAs2SD/8qrYAYaMcmJlSRZJmz4cBU/mmcph9bZ8t/dkffNGi9zP8l6w4wD +ohJpZiClDBFgztJZPyp8sJKji1Vrk8HP6d4/MBOJmPQEjwYW08FesLiiFMV4/MCRlryZ8xWXeKb8 +cxIjjeRn/87bIz3I4mI7+B45mln4xHWhdOpqG14P0KeG61HWcCWeD3gjeeJq+y5ciOChOuP4vM3c +kR5NcUsJD6A7WTtK2mCQrs7gAVfwp+TLcKwlnHi/n3+mAtOvbKqitR18QA10Ih5qP2g0KiM0q/wu +7/iZ0azygGjFzM48ysyiW45562ll+ru30uQTl3BYbkvzAd7XoZQZW5QH0oa0JxFph10sSCbwSZLu +MTPjGM5RvbVxgyu3v5QilWtFgZUkoJwqQP4/t4WNPd92e2XLing/krlkl8xtz6jxR5/jFWUNMHUW +8YWEHRw8HMr8WFwAn3Zs1zGuUjubb29XpsBlQrRq0ZUTGn09LwPH2z7Omu28xyubTxlztwdjewvF +0OW7RG01hPfdvr3er1LTqdPD4ZBxJEUSNCouKh16PtXbc6vGJm5NeD8Hg1jQkkw9wKqZjQ3gxxAe +JgaNB09IEzo+lHYGnDkYv4fFx+lmWdahWX/pHzuyPfcazTIFYJ6RdHVGuLjaY8BvLE2egeX4pnth +PD8bU9b8DNupxhv9npxZOEy+eIjBPILe8i1n6sXPqDLJmmwBr9WfWpZsgcMAqRBAP1Nlh95NvYJb +3p4KCj03Jp4qoTNG6Ze1tMcAa4mAUwQcgnJDgF+f1PWNmncZ3M+jwrECJmGnLqT3sm1ZxpHWvUkZ ++cGRp6PEoOenrFgG7eO3akwyoam7SvYuwwjeEBYq/QSOxK7AQYWFzRJgF68+Z0zDjbNoE2jfos/K +8GWvemIOy1IR0B65MVCWxrEz71fD2+/rrIuTZw3wS/KZEMZ7OwzZQUDyFTCOodxxjl+/Pf+7Om24 ++ceF57SMwxUrsqTE0gzXVV4/uE/fznTW4ZJb0WN9nx1LiwdDqRbAgCQQ+BmKliuqfFZimYV3ukxf +od4XZcnwG94c/Cvh0YO3pbs5J/9kN037Dmst/IbqYBXL+4fpqCDgsRgSx5H59UyUUKdiru/x1VeE +s48a3q8xW8rh7CWtEASrirj55DEm+ZT1/WM71272jixnd98S/przIwwg9AtSe/aj/4n4P2JL2O6H +96P9zqvzUPa2Iaw94WsitS82tebNqioPf1svZ/vZ9zW6M+u7Aaw9sJkV/PJsLnB7aJt2p/+RYeT3 +csvSZezugjUGEiSBnx2ob5vzY0Rvzb46Lpm2hHhsVjgqm4cdhjhgoJG2pcEvPoad1YAp9Q+Kpkd5 +vICDsR/WGAhLoImB07OaftcOhHdflMHXbatLsuLP/HDRCQYshKDBQKTN79vuzR8qo+ZOBfHjuKWU +uE/CXwD09qAipGBX5+Fm2JY9UsW34dap0DpG99WCJzFwCOOK8gAGNWLmjS7ub06ZdN4l726f2re/ +6cmfTA6eCSrQwiZJwkAFpUWDSm49qL78381RpPT2W4bSjbZ6+zApnTAFEgtGZu5P2IqhBcPWfpbM +Z1g1Hnkzu+ExBYDwdqD2P7Uf1bLVz9HK0Uvbrv1le5id9ak5rD3hgmRlyO7r9ehdraLzF/mvjD7E +KlUbXHbUy+WAQeTpyaCJHmQn9TDz06Y1qMyyMyd2Xa6SrbgpMr2cBcOOuadUH4jGb7mIUHvV7rDx +6iGOjCXLHkCoHsjSunAOvN3n8wapHfEXRK8jxtsL97yu43wjCQPA2L6kPeFGMHZYyO4d3KPRys3F +HxbJZJfVckWO/dy9kXNUOHCnPsrWE/g8UWA5snJFv8dvtpYVWbVaih1SHQxks+oR+hu8zEFGZqj+ +dL0zMOIRn9R7r7kr6mBX3fDfJBZM/NaANVgus4B2KcnTDMr+xWxGcYdD/gYv3D1kiYHjn1Rl3q3+ +GJS0aspHFtUOo+H+/XlW/66zIJPtoDxyoAOZljEp89r7VHPl7fnLZn+TISurDH00QceVH7lyBmN3 +xkkruXhfbnzpFvo3jYVAOrhBljj3TjiUMd1c78fVfeXXQ23DsNfR06/Y/yaERYJ1ghf2haqX1z1+ +2bLr05GAejaerIl7al4bflLRgE6GQh7MQt2ju292d17Vac/c9u1z14sC1o+TL/ollvPAGONsjVxY +jiW+FgL9IoHJ4tITxfMJHRFsa2qS1mjkl89Qo6HTBmDQvEnhS/Sl8fCk/FaV4Tor9aise7CXQKLA +pJxOCCy04EVr3LTe5w0zXZv7rKb+5P3C36eMj1ElkQhXYPkBODsFbbrfONthK6DW/P5p07WDN50M +Atd5m1b+hQaw6MiTv5w3SmqNMfnUz3lhDPPM9yVRw4CHC2y3hVJ6ZB5R9wpkGFDq/LE118HXFVtG +y0AFxFgRI5R24HP9ExVrvUlSdbOs8MSnwfhYXo129eU/6YQiJsEGlhWAxXKyg7d68ZLzNnEn9/IY +Vbpx3dWRRX7p5KCC27qSDntDaInejtH2DSE987MaUkHO6TKyPQeXxCrBdTrC5InDIqwX3HpSJi6n +/V/UG3rdRxAjTW7bO04FmXYKvofDi7Ek90d3A126S91Sn7105ZSykvFiNGSBtQfrW5Cl+5ovzBY4 +M5d0TMDf7ICHVuHFPzHZETCIVCTge55DktpJJsSM2qVug1+dbkaWG8RgjeH2HQKHkEQ6AQFcm0VP +GnpAo02NZ4Y0hp3yArumuiI5b6jWnZqCKS5+pQAydnfC9et0iYRgVJG7+fMQLbwM+g8MWYxzBBhz +zsblvGc9V5WhGSOg+5GR/t4hWHPQ1wTzDJw2Ux28Gxa850iOe8E5AZZa0dmqJcWmXAizLwYBbC4l +uGALpjZhMAPppB246dQngxE38hq4ZqKi7H8c+u8JJRrMg0A80QqkAQJYe/u1MrFX0jZa1Agf2vq+ +YL0+8sxFSiw08ACEkXDci9n+xHdrrcN6G+31znYMFS2d/LFA2jrAygAHvIX8Hyl/diA/ikimSH+q ++T7oWfzly9srS41l0l2Rap/I7d4/miWmbplsypAaxh50nenRIBdFgPAYJMGdF1tzVgcpMT++WN/v +xH30iOQjVfdGbooEeJQaIKaUm1rZvDg9cve8f/9SQ9/6an3YOooEaWGKeAYSYO26zU6zZtGs/7CK +QcTJVfn4qXW3/CmxUBwF8ELBSJU76JCCFo5dU9oO7rtPPHG/ihQtDWm1d/NOriwAUB+O4dGPPj0/ +VzV172vMw/ntx5MVGihSkIO4UHLynpyd86riQ5+Z9C/pDW8pZGXCyW1YgQOQVc84HFLOq7g1cHvx +tpq95Jn/2K9ECbG2BzxG0F4gy7OCPbt2clKJV4QXUep64MJI692C9f1UaQBQbUxju1J5MMfjncQ+ +jXzm48+MzxtSBDDOtijwArd8KXeItw6Yu6ssU1p74rdxWDHnTyoEkBwBB2xJQgDdEoCLNvhfaX2A +Y97yXGu6s9yThrsjyZ4qDGQeJAwki2+f/td1Xgy22oiz4ux2b9YTmvYmxmUUaRe8EemJ/DjJbsEs +jpV9i8u+wnlIY1a1Ly+WEkN2UCOtvkPs54jQSV56bYnfCnGNz3XnjCkiaChET37GYNFsrY36sKHI +t2fnyfLgaxYspR8KRpMlVlDBEwZKW/B+kR4LK3x7bO/uO5R+TqeGZd3o/O3rjJab9f0oaoABrYWj +1gDqQXNDI6ity/FXSOPlNY9Yfk2jvSneN5KY7zJUrAX/JtSqWWgV4+Y1u66y+6UijlNrT3bU82OV +plLII8X+L3SFH6pkbJ3ZNArQFDFnN2j3MeEGbdEIyCJ0P/v8GnZr2+r4tU0ydJw9vvOlv9ypwTZI +IGkcGFAyuKnAteO0cJeFp+OJ/pRvCmqJZtSpJQfpTru/SmIoef9IY7UUx9BQ+EUH9MAYNRRl5wyE +YomxEehgHnjHF/boBzj78up4HfITPB7AcoVZV5SahqunkxUGKooaYO65iTNL9kpSYu0lxYgLA44a +TszUMNxZcNmlxJUl4fdeWUVc7dZZy4+I9zQVjtQIomdJ7IsLK9bBm1OcRIWbpH1Nv60vvJGtqVh5 ++BoVCaB5iFAkY91F7utHCg7bZaS+jZ/z15al2BxPMOuRdtAe8NUBx25P4P7skxEMuxEUnDht9cy8 +jSLkAayCg/E64gaXxXjTladCwl4/5aev58btqMJsjTogO/323zRc7TF4tA3xDAZYo8IagbezB9eT +wH5mi8U4LYaju3nWnzuUxmxRdrZVWUiuxapU9lf6/++HwAUQnNo6JdsNttoWl9o1ODIQs9se6v6T +KgDv3yvoaiKhNu0W+PDWk51+EXE1zBQHNaQH0prkQ3PW7+61OW3GYo/k0Q+vujrjHPSkghrjhiSe +NYCcMDn/FLnvI2wy3dMhiWIiu/4TtT6/AolxXpg552mzcjmEfIWFVnGrjiu8/qxzTMB8BZLMVia4 +ks5EM3m8ycnv+1nRffPj1aZNafN3e5MyKlcQWUzU3LB28mpKQkFAUJt97a6Zvaccgo8KrACCkz4U +0hBhufWaZzatmv9t6H9VPjTtqr8pTsFEcGlND08jIYs/DDJP6GenxFq++nEE7uOJWQEmeYpgvibw +140EMGfLV0e0v9jeFlzpufb9cH2IAXUBgMhqfr5qXbgVUyIP01gX4/7IH9nGwZQJFA4q5bH0kvGH +u7r2Ombx7L+fFqAzNiV6dcA/b0Ue7MCTJ46b34kZnlSZvaU48zX/caLeN6oQ8EWRFqpIncN7ywsp +1psb6KQnNxK8ud1nvGo1dagKEAuYAJyQxgPLO28uVST01c5XvJrijH6TTuV7RIEbFvFYV2I8DHs2 +NX1ou0RfpC3CEqflPDwtHStGjQTa11maHMnU+2SSbGkygQhu/TPjIlZLuT0pexDOBoUh7Yl2QbiD +T3dqZM9LDdG6I/Wr1M04OFI13W8URv6rCugTn+DdNPEwIsFm7Hx9zpXpwf7u86qUeFskWNMX7ENi +4z6X0SYGs7nnWQO2Mk8+PLeWvYUig3IGQqFQTwD86FMy2x5U2zVftJJgRW1o4LCqq4rjoQQCabtJ +aSYAji0Ja/LwzJR4qvP+szyvOHXRxic8qXB2WAzeBbxKkZ61WyzUZ6fWC1Z/O8lq6/GWKeALJcge +C9iCBIvXjpjXZqBe+X502zrD8Vulqzv59iRVnakaog6CTsqo3tGH0teVB84JFqpbZ5Ztzc2woESg +nFFkF6hvcoEZgf/8yWGV1l4DnYCbc9PJNylRYNIaZzyUCzJ41g5n+FqFySBMV8Mz7rP2N6P5fVQh +F2hCHFAJ37UpTKJWyL+w1vwDdpLv6nGKlhfo4wGTNymnS7GuTbBfvsNHjvLxMXb75/yrb1nQUwKX +rJjZRuwfKZE6p6bUc8AqeF30axapEopDFFAsc6kx9LwjvltoddI3jd7J6AsfOMVoj7acoUS6EO+r +9crPW+8ThlpL26o26gbSXhOnv0xxLFtIQwBAzjmqczH9LVvqw1SST+lcSujqEUVQgoCyzDZIKzw4 +SzvEVXRbBvZdVS5Wlk8+laYvbOPrQxFCIoB1Z9In7n+ocUt1cD7NzMm9z9s30EokDc+XUsYIzg+4 +Ug7ZsQv2D/8J89925bq0z08NmNCZTI6umWAv/CcBcDXszIzY84F4vvEw+aRhG3WuwvCobMqw7eJe +FT7bE/Rv+lRy7/6Z7p42VnBnNUM2U4YILj00hGQcpXsQwBHUny6J/x1vEOXoXcmVQBkBt42CRzah +5DMLVZAAmcx3uI4HwgWIi/W313Bailzo2bNnGyUZV/KP/IXjqcIfb0rFK+mqjioK3lc5NWN9hQoE +Jb5yQri4kgXYsFxvnjwNHeviOu768BGeuf2WlrURJR6aQdWIbtzyLIg/Gaqj6X5uEaEt05o4yhe2 +JeuZtPY/qMBn58xezwCu7mO7KxHX9Hk73t+OQk45UBRC4YB8MWgwU1Dckw4aJffK6OZXATnRbWGo +I3VrH1GCABuZaCJzXOG4lPI04ZKjRNHey3NG87897UcpIk5ADiPgDzAGl3YunOfTtSKLkV3cNZYF +fbtYY02oUgBgooP/8uWbeHLTYfn+zzT9A8WNySwUAZKNvGiPOmEIYyW08vBKQUvB6YdDTPivq9k5 +vieNECyzFP0bvAtpPB5+hh6z3RQ0tVbRqR13HF++9XANRUeFzG0smylxt8g57eLzzLpOTVUnJHTI +lOJQt/CBAfMSvj/O0fd8mdsEY02dsp/7h45P93iXQQSTE0m0L2wWN9ADgx/Zjwd7tHinp2WtSgmV +E9+01rfXJ/p+KiUdoAABKf8WKaLWSZOprT3xaz27eHyr7KfxTBftETVKLN6ZdBVkgYVHKtaPYxPf +r5WYOqY2vPORsYmK1ZqV4YX1ICMs1k558/HNfBwTaLmNdNuUfRGvV0YB7wcgMUJWbtVN6D7rCNy3 +nq8Kslk3RRlWJglmOx4pKScrv3s3IKDTWHaX690dZUeRfuxQS3WaAM58uZe+TMCVMKE5Q3u9MBjw +sUllBX/DTIRp3pNsTHEf69xV2fx5uYdEUQNgv01w8WeUFmbwqItt7SpirkAbhl1dmYVCfmRmpvDN +xmnzzXQO9WJJ8xoHon7E4PvF/0ECXK7UF2lb86LSUfz0R/qxoaPKO1nLrFdGgZ5Gfu8BnDLnOOnp +0tRdfkgYbxv9eSD/+fJ5E1BwJZMgJfR2INtc7z72DLl//4OeoSdTEojI+fYca0VKr4FcZqmAG9/2 +ilrpSkcdn/F3DYd3b+nZW+/xFwEofrFMZ5BdQBh1Q/sjEw/T+Ce6H4NJTKlJFHUW97lTuiZAit0B +F6C6/lXHjPn52dcJI7wXtp1eusZPlufXGKs+5GpqeFtR+bJ+WyZOJUVxZMlpqDN4JNaTmEwA6Upw +sEHK4uDtjC6tVcHb9LsEXjTjhst0WZOoUU4Ij2NIT1cwKwFwqJ9YXJNNuuq2dWqaC87H+BDtIR51 +Zzw9VQVguRKsH+CKdEEs5FPEMso+7k3Odp69ItAhHL365sMLDWJUJIDm2doVuagi+veyPtmsdBuf +xCoE0Z1a1pzwfS4kvQO9PgZ/RdkPyVxmhnW2eX1X6y0fpHktRVDWCwe3yBxGYFh1/GAvMB5P58af +Wp9uQqt8xXDrPVY4i3ZxlrSXBYHPj6pNGjKqL5cyTR3T0mcoYA9zCKQMEPqBE5jaCcBs2j5+p7H2 +EUKkdanJ6lrWcg7T+FDEwNZ0nMOK0iGB707Ku/wWu//Jkf7DhyhY68WzWgBiqqgdt4vzGKO5lI/l +YVW0aOz12EwYsnBWFgqVYZxBDWJ9jU5Euce4w1vEZ/kjB8f1t7IXTm1y/LsCsOy1bNl9+3A3I+8m +Cfl8+tqbCaGn02rNopX+XQiUQDWoczQnpb21Gh6KpWsIwbxM5eb6dwmoXCcoVHrgYfcMfc6jgYtD +Fk5t/QZHfYtF/i5E/F+XhW7ydSRRyfcb4+BJfGRutSy/fcLWul3/KrOsx41rhR6WfmTk/ZoxJd55 +p10Db/Ctz/8oBfLWq5sc3lhwj0yp4ytoT6iImdD+1vo7v1AIBdTwQhVboEbiRuh2bIlqwnfUD/kP +df1dwxnpjsM4IqHbCN6h/6h0c/qktpnEJeWqTz/fq13R/rsEEMNb9jxaaGT7RvsYOGodDYye7Rjm +2+R3/tffhaAoL8B7hkU4Do4NnjLgzrHuq0r6nXuuef7vPLFuG+BIEnVq9VQD5yw+sI252N4pe3Em +Zs34uZh/0IFKJC52/nWrbA6i7sq+WmOm8VvI2iGOY8xz9l9lQAEux13ys87ajxqakDmW7BObv2Oj +aP8mQLwK8m6iV3Mp7/FkJMOfiJrrYaHXTtXeDHz/Vxm8C5B9EMj6sXhDP05cYhpqeRqQWtNwh9fX +Ra7sFMe7fxcCJfZ+lhnzne0q9JKc6zR5R7dR4I7WEFwCGP/sgK2c9tCDkP+Mliozq6Hl45h2zEJK +fJuOGoYPmWS1ggh/tcZjsaQiJOgqi4YA6WSTjJ6kwEcI2tuORR8lV8LB4mfQoHFe6hgj141zxyab +4srkZR2kzPCK8M9jceCzAk7wOxPv9XPi/na8Jl2AyI0iDpkWyd36G+TgP7vAQhsxkO5I4iiOFRpO +fHuFxdVbTOyybodS4sHS1B1/oTFoGxIdedCnxFWD5XmmzREvthrF/w4KfPClTiOt7TEglhLEmpo4 +dPbpw3xt4cOy37tD1mbfXwGzARb6CP449Kw2lNzwqfrJxVq87VPRf8wyeskFpVLUYSjdO1gTa9kw +kFc3bNvnnZgbZrnacZL7smN+d40NdR3S1igQjfnk+DUkfij9aZ95ip9nfsAB/0x36igYCwIyI4Ns +Xc2AfESLx4nKNW/vm4l/p2ub19OnzoIXTtZR6JzGazYVP1BWPGWXndp+rJO14EnoCjQYFYBII24p +g93HBQruxVbeztvmklEzEnZgBXJxQosbLDGu/xzId6At0CLkkJCIeOC5/dRBPM52LzQPrhKYnCw4 +LXE6GWc7yls0MVjHXkQVA4mHjW1+xtsTtFrn0XosjkduB8dEdcIJYspB4gBE9mha+MJ0lfedtXyp +rtlR++6nn5rWN044jkLYOWNcCaMwsCoPZmuWtMK7QsWNeuxZ7mw221DucwZ5hVn63JEDyfi4f1Kg +9NhcEYwaqZ62pYW1Jx0e6tAk/SpuSfpfiYEqJySKDzLfcDjv9t8j7x1x2DvqlnRv/0llcVw+YqM9 +vuetxbTo0die6L2NIwnzSIt/kgCXv0ADQFpXaHC05Ejf7LBBQYoQdvh02dl/UiDOeaCIIpe9N7/L +6pfC//VWsuec47o6G2v7byKLM1WSkzZT9ufLwps+2lT8qjGi3xLlCzc5KWksWhG3cuoqDjucpIsM +dw0/fKRv65pCcQqfLlwChN3tS3d6pnxIeDcac2jPhT1vb+uZ3YDDwEYKwD1xQWJRGGiM1kjRsUPR +vW5lVS3ZZF5K5xW5d3ULDITGOTTGFfTiXKBu5Ctx7OO7deW+huz9NS3WSjKHZ8UCqJALsxFxAQTA +uVmyajOLDCWD4ozP0XFO1MZL8m+hjC+kLlr46RtP79XPzuZ9ta6ku27tLJXFVJgCtxtBFuls4wIk +zl84WIWwxpHqfFV4so9i/vMeNA7f8mnTIylbT3TITcoqKBukkwsGR5pOQ3MO/67VFYjCtA4bb9Cy +3xtmvvsKZXBJNXOyXOaAyu654lPCol1ltTKCDiy8O/qCRncEr6xCuoelOp3HSw5+y6xK9HojzckU +1++8aXv+HFwHjL1KIhFYIBcp4TuGFngCfYQEOUu0jiht/xl75yJeIZIrlgJKfITwbBqfPdc9vNN7 +cjzefO6B+LD/1amss3CPYoEHMyuS1x60fJ/3PvJaAdN6Z9zqeBaPJKEGbbizugQHsa6I2g7afKXr +9Gvp0/FFJ38/Fkh/vAJGGkNPTYQOBCNVG4+sy2Qt76hRlztsVEIdW1LPC+RFvqy+ps/kFJYfl1cx +dHSX5LD+02fU+YX+RnYAEVCx/TgmVluU7qXnXvjNxJ3nzl4eEbg7C1Mh2BjWCBsk8apAywF6gRPX +805vYWzHyxt6pQQ9PVH+uHaUuhpQV2xJVbmrDYmpRiqb3o0MhM51u41Z5h/lEqCOL3gKpFV1QMI7 +wdDvIiezzUhm+xquvTknk1vdB6hLQKWhAW726K9gE/Nj6yM0Tthj1DI3q9Z6wl2VBQ6YvZBQKSbU +YuFDk9hp7oww7FCxjsIJiWf368YbHP3hGqAVbo1GkHJKft+ELrIT3NrrL1c7pHYzPDjrCdyUhiDS +04dCVa4LAS1Q59NXRs79D1ZblvtJFQ1pJRrt7m+Ph+tAW7gW98CBaAc3Cqvkw/RqUOE69+BnjeQ5 +fUEJaigInP1Aw9/nci1uvV+Mh9Rusd477W7HYQBQV4mUfRQIiFiB6If6/36K7eXfmqbA+rWiQF/4 +8gND3r+iBOeFWMkYND4CpYPwl+7euHL5pKZhHENi/JH1p1eWAEJeTtClY/+oCe8LbdpG/9PTxTf6 +wO9Mv+OTK8N4ZxTk/NmfoGnp4L9lXVBWGf00yWP1m7Vwz8Nedpm/Bf3qNgclx5iZd61Z9DKhH633 +fnPyoj1GkSXms7FHuKGIRgndkyOHmLB2chmIxHWF3reevysMqaCILk5qC7V4AR7DcofVmy5D7GqP +f75JvUnkV2nefkr8EmNqmKb+pfircY1+zdHzbdHHPAuGFbZRgoidGWND7IS/Mgq7At40Cpp4ZykY +aSt05u8acKXE2WEQ7ghPMKBJjN19eH+pkc4zpT/9C0au0pw+7gwC7U2dhJZdVP1v7B75dnpevtCq +VvZrRd4TEXi4j4BQLjRrw3nB8CUdc9i+U26ponlM9JaVPIMUaahW8DKXSM3uIFspJ3/8i4D2/KBH +IXlxUrTd1OmFPflQeIbxUbfzmFsO7f66sKzHJ8XPxMfDLVUCCxyFBE6DQWdsyavSYu7r5j+vadHx +LXJr1CgIjjcTNoYPNAQF4rEQANER6NEdCHOyQu5+2zEw/yX/jTd9KSUEKJsB5f5bsCXnhJNtPhju +e2Dq860wjDPe88lcKDzgB6BA4WpgzwDxID1ozvWx+7m11NUbn39XszZXOSIoem0zVZa8UOhNwZOj +a3qk1zzAdxh16avdNeO7mksRJB0xBQdxr1u7vrfsO6E1ebVNoF3YquZ7Xz0l6IwL8H2C+WBIa3jo +O3b8EwUCW1F13AWM0QnVsru44LEBAkqq3biQaAqAeddMd3/drCL3Rj/aNcArVtPNlf8DJXjJL8rv +ux/wYt/FkAtVL4fmM+ervl4OgweTAAjy30iDP5hTjbwz2Ik4JZi23G/6GXz16M2wNRxd8rxwo2dR +BzbpmgdsepgqiBz5E23yh0c54X06Qyh8RCbwwLZnMGUX+Y+robPVnryPf3Na3ettb3f61uSmdl1K +MHg2D4sjmD8YO7yrJFlsb0gwL+voYTP+P+I8B1V2XovzXy9GcXxaUIBmPyh76+LTVJk6a33zl8+g +eBTnRZ6zYUo0GpUU+wtJBoS09a6FeQUePWWQLqj0+dYZ8eBvszlwaGH4AJIkgkdrQXj/AQexlBDV +60G3JtjoPK2PnMI1W60Akz9yPc9LunXvOKLZqrfpj5dKdV7MOQw32JeGhTeEXG34KcR7YVrdzbY4 +xIheI6SPAYYslNpaMFSIqbqIsQBiCK2DBSPShrxmcupFuz23b5uiVVbBP0iRl3jeHCm+aeiMfKy/ +2ChigxT6jf10V8Y/SIBp2yHjCZSRGNCR0DZCXs/1FEoqW3Pc8UI0pyl1GcL7Js2t0FXcH1NlzBhp +PfLCSe/pHFuAoq+MvScMX0ySCCAD/cdbdjMrVJlyzmIC7uzsXR+OQFFAPCXxLkCRNbAuBwjy4BoM +gwItRGXum2oxG7I8Yb0aCo+lLYIgs6nL1uv0ql2TBl0CbzWNbjfW6GfC3RkgXZkLwhM6lAMcGAbI +qg1RW5zo625OSc5knedifprfFTpDkYT2V0OdylBLmUdyW/qR0itGRhrJl/NmilzgDFTWg9yY23hM +PtSyHtGFKUhVeqotLmjAcSodxjkj3clCAwYMv21reyq+pPh6dtslXeKReMf9HYYsnlQEmcO7Ja98 +K3h0VX9DR9OGZ4VVRa2oDXAGPJGEBYLcxDVBaLc7qDC9+oItq6nHUdNR08jQVVabz2YJZsEUzqAx +dtDqYb6tk0GfZXdI08YXLBNtBaxqV5lgrUkOBMLFBY2CdqAt6ecC5onMwj6hLur9O/ZIKVqhc2oK +NlIVgYy3RZMI8vLoI0vWCAXgvTlrq+gyU8+HSgzBvbylCnbA/g5bPBRI+TOxVyMmhqPg3M9ttN8N +51c99M46+RceSI/kSuaUKSoECZ80YxVi12h7HdK7kwU95Aafg5dIQFduLYNhKB2UqvY9/qX59H/7 +2IZS4P1ieSgAiyQYoMC2amjBpala5M3RV0PqiCjRy+WlR95fdoPbWMslSAUOl7yIJl+xc3ICvJ57 +1tG6OyoPDuX8fpL8NyUQpNe4ohrhUfUiRDP8YKCpgH7C1Be4kUgCYXPjgEUCC+/crSeloesfTQhj +7quPJOKp084o4CTdwuyiq15rca4ul+b7vp5p3wrL6xJcD/KowsBZG2BfDRQQIbuBxE1F3md+fogK +1FIrowveonNQ9oHd31QAyxEKiBh+9zwklscl9qs01JGt2GgItdbyb/AyS/euUkOQXOe8fllb1OdQ +2tT5ygN6OKoSK36/EzeOsr/i6ec63Nd4dg2vUWHykZbh/40SkDYbvKmxA/snDN+duJitOWJ7S1j/ +Q3M5PNpGVQeUeHnndH+zOM772YW3ermXD75hTft6fQUJwpPB4lBEH6e+YcO591j1PQa08xffs/Fv +qD2FFaLKQjPeEt/K/cjnKw7Y1tqeS06PnDITT+6Zi1D7Gw8eeSauYl1iMty9pT962xn1F+seew+y +uq2yFl6ZB7E3yA4NG4G3ttqlKc0iV4JtdXdEwA2IRYy4ZmCLtPa0JtryqUUiXl1Odd345KHisbuP +8+gO16ZRVQBjI2BZGzLnu45dzy9M8K3F7ez5S/gLKYbXir/CI9sEmwd4XWRGA3gtiwMT34D0AGty +qQqu52rW7BmzqMgjX7/BVZxRS3d5dGZ3H6fdIM2aUR3qUlIpK6R25zncBQcpqEYbYRiDPsDth1+p +z8a0cFxP7LzXkhG8/ZT6ZBtFELBPoNLJ0N2atiDrhl9bcnBeebFhp8un9ix5M2NKIDTORwmz1D+e +6DJxKxY4F4jAdN08KQNvDFhOaGgTLWmNfd/4bNWpuR6R0Q3YYG6jeCEH1C0+iiDB6sY4uILjFFhb +GqQDWelefGNOmeibTxF1ntb21TpfxE+BBt+AFcoGRUxEAaDdZy5xBIe8voHCPLp5H6lrl/+i9MGK +6LJFYEHOPefPG61dlYWZie/We7D37urowyvyC4uina8keW0wwhrdJw3W0QXEe/3RTJNfkQSyFi72 +H4voRt/dp8SLpE5H7l1lYGj67ukquMdBjkMlgwBUJqmCr8hF7GKat7zYHVf6Ev1ro/+tiBKzAEBT +A474BUvLhM8NMH3lnDwpOYh/++zrqcaXFEaAJSo4K4wN1B0DrLhm5etuPzO3j+dIujBbI8R3Cb7M +QQ67IbDW9nhnRzTReLsXGer1Ta7rWOcDI+GD1+Lp5OpH7FcUAI+mQ1ZwrMQeqxNfY6Qq+YpOG5af +exz4Qhm+VEliCVdMjNEvLrE91fqle/tIrKG4ZYoyty52Os91lIJVBhMALgBMtgdo5B+YY8zDqcx9 +S8wfnxtR24BHqwStqLH485aH2u5JaV17p7ZpNoq3mP3h3KEd1B8egC4LZ9y/+vPWvo86Nj7b9mnq +T5cUKj1LwqzIk3ZhLl5CX335n+ghp1s/2HUnMXdqLnapSN39JwnI74WCFc0faXSKH7YLvHiVyRfA +qtJzTbruXzRAmIEeO1YeLLPqt8Dz8sfnuyd2ZvjBt4CRw8C2dHC1hiwmdGp7/hHNhueruF8Lv7Nz +eDd24F7T8xVFyBfYVz+tbv1qPEq7VT10tZhraajF3L5TK8MLHmPYGye03ZnR76FHuozrJ75ljlg+ +pWBTLUHBDZCu9oSpCHiR0CMwODWKt5/5z6M8+LTcHK/uCckIuAcMV4H8CqWYkXPs2xlF9u7LtXvj +kyTxQ/7LyiysA3/f1nPdtLVr00VldH2EyJjR7bOFX6lJgMOWzZIXKCGdqpPP+qR6do+Ve6D19fL2 +Z75UByEiTlwxAPEHnAeY9p85zV/zUim3hMcY/X6/SQo1nGSTA4erySedAeTE5/lz4T8U+H70Hk70 +77HSjkX/m4YrDuMCeiik56mZ1vYj4ILO9RKv7LvmMxl8xnvE4V7dMilS3rsFL+vxnAtt2CFH/jIa +NokrD1gVirWn4WEoKiIkfwMUKvSx4d4Qt5U7Ii8+0NMiUut0weAUNSHI0yN5a2QGynxbqK6whvhA +1dcJ4Zo8v8H7LJKUpmRiOG4xCyLAjvgc5nxRd6boTOsu+pfou+LrmpSpjjAwd+W6uHzOhiuaWQ/2 +/qLdzrJHoeD0pQ6qMFhXHTDVrAAbifT7zFI76BnmuduaVG+qfsTJP9W0/gyPE8MlgErtkLX0p8Rv +o3DLNMos64AMW05ltA/a+e/8YjUgQINJKIsture1dNtql7v8KiK5H+RPUzDwYRoYPOkDG7R7F8E6 +RfvUxffix86NcmdQ2s1P/y7gDGxdhIY6KDL5fV7rRZlYlaK988/dN3z0eopM4NueYCpANhccZKfc +RI01ZR7T2b7GkS+4+160vU5qIjyyChcAjvgBOKrLZTK/WWHLb30/dqWh1FmHHib6v+OLH+k5dkYX +mwprE+GjOPodn23YwjC/4cvZy3mQLN932MqtNL5QQy9RjG6/nK7zO3kKnhr5viLSugFky7bToJwi +Kp78uBfv5WO3b+2zrPVUxzciTlpkO6yX5XCg5w+vc9Su7SGKpr8Fbpn9oYaCqaSwCOAUIOhXPfiu +JijdVWIlNZ/FYacufnXg+Dg1dOnu6t0yrZwV5WLbMfc+dk0mxfoNFNP1UCPJ7/O6/9mEwXma9bql +/JG99wUlrF/xUr3PJesUxQ1zqy16Xr9h3VD8PPXlcY9UHh/40j0RxCKt3QgDHYJg9luTfpgj2/f4 +ZnZhewfuCqEtt4NaUqN691LnySq9kTZa4H8iWSX2ie2RM2+PdUi/Xvfw7rqPKwsQz1UvKNSIhozu +8+64JCVS4Hrhyfo9H5IwVJ82pOBEGOpAr9CWaExukrkzIjKMu8l+/MS9Mef8Oo+yHLqVJYDJA1rz +UOkoGTU7990pL+9o8X0EOzu6+ww1lGg8ky/HHlN5eDzP+bZJwxTzwYvPR7/KWV9vp4oT14KB5Wfo +uuOaLXA4HocT3vV9uibZtlnzoqzw9WcSveB/h9GIVwmGt8fu1TilpXEU1T/05xBVm418koTi3wjr +hY+z6ikDnTB7Zd78/J7tDwPTdjPTHYNHlSkIgTCrePJ7fOfZ4YeHy8//4PWLvL95/iU1mPBNkrl7 +R3PK+ZlV9e/xT6Czaf3XpLlp0CJWIil6Ph4GUYHCiPNrtBH7wzxskxuurrkGX2UjikDZl10QWDCo +5oZCQmHu2SedJ2v9n59703JeV7jilb9XnyF8Ryy5BFaSMERA1j+95m7/is0MwdukO3L02iYCZLoS +/oKS7y7aGz82FisvL3j7YKfSfR7Mn+LkmK1/wYEF5+UR4fkD/00mnqLfz5BvFHgwuc6W8doH+KIH +UYYspSXIsuxt7mE2cIjujXLorS1O4/b9cBse+gD/BlWPBaGQ8LkWb5d+rS71dV/rz/sp3N3CAD9H +A/6NWGINgPw75x0lUbcJvyhmFH9jHBMl9AS+6ItDE2wwaDwwZufP4U49mB33pUbMPH+kXc1gHdym +B9tjiYFt01LGB90z8yN0d0q3H37WP8y5Gx5aBQBHpCcppn+xIevB5dc0Pz4dE76dEKJ2jeX8Trhh +ADDkoePP9NNpx6qbtETUDS/c/ZLsFXhNZTNFCEiBB72i3C8NiLqTKS+mzx7ryGINx9hqNRlSRNyI +CTYXH/apS0qfLiWIz53tTdngwVf8RbvtMnxpHlxJAfoWDuVMdOlq/Gjl/F2Q64peszTs2SCdLjdc +Dt+DA3FIDxcUlvhB6Z/Lqn5or5m9xz8vfX4yo7FhIxs8lABhi3udLNPZRG+Hfjkuqa+dO2nwfV7k +VRU8kAdBrkhrLNGceMdRruZ/OajO6c0g85zEs0qxJ+kn4NSysN/yaPJj7+0FRazZeg+/7GRPxyqo +uJ0XfA0TIVa1l3RG2mGAwYMEjxmlB5XHKiuE2EZj1vo0JTV27DSnBkPLlD8u7BfgVeoJLzJW4OLn ++Hr7/hlVGEAaJMAEOsQyTACcwmHCMOnScP1k1X1tHeUX3MxT/nAfhwSTb0Uk5hYEHU1ZV7XhoN01 +4XiGMuRG/bWaMyW7qWkA65rgyQzSDhUt3HfRyGSDLOONEYbxAyzotQEdhdRg2ED/2uY31/OBlhqd +eoGngoneI/veucEnVyIMjbTkPmKgqkbBJw6XJPt8Vas3a41TpG3ED8HohRX5JeFt8zl3Z71bq2xP +H0i21hrHlbe8On5xBRTI3AwcvyT7hDZ5h35pn3v4HX3tteu7dk9WhZsX4NYnXIFs8Aq6rmjnuVbs +3X6+LNqKdHb6DrHT8PX1v2woMLGJ/6GvykjT9Whkd1wo3ugayyb4tooluwlGN8gZqTCYFVncsZAN +rx812f3p/RLXaSGOAiaqgSxuDJa0jxk4LUknJPXHOOC4+G+MIAsmU/n3nf+WFkZYquCOtCJ0NejQ +Jc6eVCcT0PnsNMWWXNCAyXT8r9YuHR9SbjiNoKoDAE/VT2i97tP0zqmIZTLcq9EufJ5RjSIAlRe1 +dwepdyVCzzkQZfvDLVpV1bUb3UMT33JQpID7QyNJBZCYUc0JqVfi9Pckc0i0T7hYr6fNHlyOATlX +yWN/hAfluvQLIQh9Glcb3yurcfzPIYHNCJWUvpa2pVmQqAqR5XtnUcr676rjd2mme1O9rYc7rl3m +eqrzLxpgFsVQIzbG0QzX/l+lKg5HO3RsP3InU2StEVgsCkj1QMwjaoXEuSOBFwbEZaGMD9+5u02T +zc2+XKR3rusuTxJzVg+nLOUKJnuIeWCA1H+jYjiySbfbYyqJdUdJRAjF9kDUBZhCwecmiXQjFQK5 +P9+0A62SyMh6PwC/W0+QdjJ8bTpFAZSzCx63cHwNiFCUFM7NDYSLiEdYsyp3CP9J5AngokISHpYt +kKsAOvYMWEBkhW1SSoe8nnbsLhrbax611nIntmC4Efa5LNNxxizuQnJGuoOJeQlKCpcD/EIvn3mI +m3vmqKZp1OfSeGf1X5QWUjZBgx9UJU7xR0wYU1sMFm266dF1O7GfngEPKcoQHieUWijX30k7N3yn +Po/efLAM/lvw9nQeigD4x8LJa5DFR0ywed/0EN2MmTiIOTR1/ghz62WKLJCtnXQs/aFU//49KbFJ +ebG9YtLuLx9ZxKe+owyRjroD3QUYm/J+4W5o5LF2meDvM5T54h3ZaSbTViZxCCuCzerkQspueE3D +9ZecMiPDMPeB9ybh5h7/5e+kfLNYJKmI+5y0xcjB4CqGjIcHNl8z2qhTaaZRQBEBfDsg0Y4T8Uh9 +t2bDMfruEAY9hRC/K+/fcwv3eFL+sJdfZFvOq1X+pULPrkXdG0t+kKK3szwggCK4mNXSGoPGO0EJ +BFppWHjfB98NSqw/Wrna73tW7xjyCSUaTL8w4R4tui4tvk7sqrPWeHHzqHD47qVtidl0iN88mCHn +xfxE/bYzgfgLPz1EjH6mcMo6py5lSKVYJDFWDmCdd/KURTtvFgaEhJmyl3pzpkVeN9ceiHPLWIq7 +oCUJIw3Cc5GTBCq6LdRYuXrWOubL8KjO9kuP7lypmDlgr1CgC1eABjqULfijHyeqPbhDmuOkT7tV +q0c5+21j4BWGI3gchvw1GF+5W5B+POWBQ1LBZ+Urlc0THK6sFCE0ygp88k3pljcfv62a42UqRPx+ +t7ZX+VLaExhgjUYisIuHTRYzmgrt/B0/aLSlmSW2g7HWqThz1w5OSQo0ijD8EUtsom4xnygSumRo +zyOZb7v57XjKvocUAOJsyrHl/cyq9bO9roPhWW0dErp2ohdewFtj0MQv20mjcvRq+PnSjZ3bPAyP +hrX6nJEyo9AcfFrgq3Ym5vJ0XbBlAJlbehiOtxxV9umTfe20zicrNpmgmSjIgOvNQPtY/7MPnZ5w +s8yyrLY8uYnTP+reU0V4e6hcPek58HFsOrHvZvhL17YHzC9Pdq/N+M70BsZAHwrhgp0Q0PydqxN/ +R09gx7B6YmKyw7XyMG7hO2/hlKczwgnYvedEqpObota3cSL7LWe2gaTD4+TnWlL3lThgGOHVEnNT +hKs8aR5ioL2xZ0tTx73TfKOrGsw2wZs7uUDVZWLbXpesqt/W4yX8df8RGS26zZFChvDWzjbEVQhS +Zq4NgfGyXWbRm3wlevakaThOHNzo30gBA0rfgO+2UKt//5ZfQeXN2ISd6/VbtfHyAvB+CjxdotO/ +rNwXq4bfXGpJh4b8x7Wa2BOcjo+unfkEwxey8oMPHhz7Fw/2Airaru3P3ws/H5CuytpUJ6wswrKx +owumYo/AOmGcwWeTX67Kdci975rDOkWxDetSaZsfvKaDtwdqK2CBrUc2eBdoDwRpqKPvYrqRxqNV +a85WK+LTjHnHXtzlS5UHrhgKe5AyE7lsQPA3/gzQ33g1KjHN2F+IRWsC3jFJOJCdE4AEZF/8njCt +/5n4TGNeM4B19Ch3cSoMIm5kWNzdChhGzr38pUmTvxv7c9NzYt6INFtmT8JANHIhkxPAbMs9m/ss +9kLD6R+hObGxe7bzGXCVwBlgg+bCc4EscOJVAxonefp8k25GsETNHD5xzULQ6OYUj/nfNKiYM3ln +FMpGq834t4oPXP/OLr+NY0/uu79IgTnQSox3V26Sjg5+Ucg30fPfKV7++moYRvbjCDeUHbRk4G4P +pORH2JBSfcsqMB7pZx++M+OfkXtdvo02oXXU/Z+UAPhc/XSQCf6a+8bX6WI880N8GmnHPlKHwax6 +X/NcuNT9EdsL9V2duDI8DrWNx1MmgIIbKPDkEuHVLdlbQJB5/+rOcG1XdUUYjeYf58MPh5TT1Xph +MsAjBxLAAvuJCXMtDohpL+Q9JE9Dx1as+KF4IOm2qejlwhbkVTav+Ht6K6kBjM+By3o3UFM27aWr +i+kzdLfUb91aC2fwaDR0YA18XIMSe1Z/EP+UoXvvAGKezVa3/NP+xxQZoPF/NNdOfkvNrXx8wTXW +itZa0GUmLwXWmKwWMdvwZrP+b+/T/gTdK9GXRb7yaVIvh7UnS4gL2F/gD/G6CU5oPODh4qsqa/tW +LSkS/MmCjxJIqkRP9iEwMd5kYbqX9nFfRnP5y75pBa/uaho4SviTlMMO40L4Ht2QBIPAHQGNyi+j +/Abc953L42znjWCrO5M+MKN2ipIEDgduDbB2JM1rxJ0qBIk+HsvO1wdn3gUhrz6bKh6VqrbZRk9J +Aggrk1fbfCMleNxXc63oj8mNmqczf4X6Fn+GW0gkjlTGlDgOQd3QjpklMvxL6g8P7vvf3u3bOGab +0gjv/4SbBwImwOEe64Wxj2AFE4ZeskdpqKMQPSq70fv7L/tV1137ZyW3xPz5JylwOHiGDh7Y2b6+ +oPnG5q6p/SKf89emwWCCG4RxI+5MIDC4rnc9JSdPyWEmmjZqpDfiY/7zMqLAnMGjsKSKlAtFHcc3 +3tuZNBUTYlYYsvNnNluC6I4QdaqsNcLaHqSe/tmH32PiVnrDfG3V1jIjrateT85TpxatHUaOqh0G +3ib29w7OT9ee/aXjpP3xJVWOUq2L3p0Sf4IV18b/orv2UmOHdpDJ4VcxFAQAzwR0mkFzyWLC948H +ff+XutGXU8eyZGO8R2/CGFcEwamEUqiCtsyCU+N3x6vjjqn7h4K3M8WG0u0pyqIPsCvQpCpFwH8B +bVb65IHHpvuqnue4WhxP241tkrBdtQIO/kGspbClJEPNITGnPv2WnOyV/J/FVaIlX/+GOkMZtheK +cvMY73Lo10xM5GC8G8h7JsNt3dzOtX/TIH0fpLpvueLee2hN475aCORtzfIXwne95hpfQQP823KN +hp0Wks0mSV7C+gdfZl5EYxJfZJVR1wB9QuVNkqoeUfd6TW35XmWzfcSXCBvDCSQO8HxdoNKmtNO/ +cJMaVaPqI/nsfeUhaKP8K3ACTBRMmLddgdAhyaJuXSu4i5OVcct0c/yMzQ3Nz5EqCDUqKNB8glXj +vLC1yxHlbwzHMuX8D6+vfjYIb44jTMySLnhX+4WJwKDwxlT5LltBmiQJnyOXKypmHNaxwTlPZxzC +g2iJgpvYiPN7xD2E1uYvUQdxxgmx1TvC7fyfGGxbmQZHWXBiKNnx9tBz911othtKtT+3ew+E7siF +oeReOVnZVqE7XZjBV5mOo18bHFnZW4+GbD9usDIL/AWPg7Y/QYleVcIqViVHyGx2uskb4/ThWq5K +xPj9v2iQvETRKV2RoofR7B/jj9nsUEl84dIkBR9Nl6LQrEL6N3gT6+JlBcTEJUTy9td/eyZGg2Ud +epi1sgqwhRC89vdPehjXO35Myq/hF+A6wB1mh7ukvzJK7FzA/wEqHHhIN7bK6vl+ydeWcd/Yj/Bo +seQc/psCUGLGhazC66jwDfV81OXKw6onPyqnvXQxOdPH+xcNKEkpAPfEmxY6aDeNFilVb88RtOv4 +wJ/a/jfYFWWDRBL6gDVkoBsa75TaLGoYJ2mNDLp5dhdfxXDVXyRA/2fJUOq8czrXjj2H9fpYoIVI +YVGSKd8luKlL0ADanuGsvpEhyX/ktIJSg9qvXXmfSmbs4W3BxJygaUb4mYXgEMDv1zhRH1f688X6 +U07CpuGbffw47srCeAqZa6HpEYqeLhSb4pe453CDMRGt+2G75waOd6NGAUyx/yIGDC/kBd/9depR +1x6knTTVYRX2HJjV3z0lZPIvOoDpbINAYyDD+7nBr0rO5FS6R+Mh2RG/xBsYBq83/YMKgNJKeJt8 +eXUv1+OiR5L5vrjkV6Fl8J6IdyZ0PWhphbQEucTcqJURjdr58s1Txg+B30dUbh7lb3CBmwx4V/JS +c6vr7uhoYW7VffXYzeG9NSfJ4o3Kl6XIMgPjnFX6CZsQqdcPGi6gK9qKFHp361pSAqAyLsTwGSnK +D/ZXwdHL+I4k7f+UXcO1VbYym3O/16AoAJXsPXNoMLgZf2Ok/fGJw0q0cecsGpVyKTUHIxeSpHLP +rj9UGn4Nh59wR3R7F/uiR5nDdXsoUs4YwNwmzus7LRmEAtQYPieMHe3tYYsuK2Fg302RIr058AN0 +aXkqe9RBzEjOI6lla9HYAXXuD1jKFGHuh4KRbuBOCCxo44LGZcOU8gVFjuILfHqtKndsHV+i722y +W1HDdeFWeWceoacynTVfb/3O5mH667KHTGb0X1BXIDEZMIwCRgDB7QOuZdFzdkUTB/gNe+Y2Gj5v +q2Q/IH3U5m3rlE9Aw35KyiTLCszeDZQ2XqxrdH2gdI3hEGu3ls3m/eavLlbYVe/LWkkCOEdOrOek +2Sv2WUH9QnCFnxnjrh6v5IinohWUUOAIBtC+sr6iRVdZ/FADh+CDGFv0E1tj88eU2gNlZxdqlKZX +6bk9P0E/+VN6y37LqOL7G/naUyhBYCVp4OgTygOM3Xul/9j3hesoP67IcG+6wtmI205RFDE8+JEZ +in7H4K+zsqiUDoh1T3A3OjqZYCg1JwuhnMhcx/SdRW7W/1mMXNaJ8m/n22y3UEKIhWDJHiDOHhQY +/Sz6tpxpXEflq5Rgn7RlR3XyO7WVBAheritES5JXo13bcF7zMl6R9lTEmODnG5E2jecL7qwgAw5l +vsEsu3VjL1ru0t7vo8Yww0l7RoES4urpROhv4PCbeEftU8vx1ALpDGPxfIn7hwXZUzwpIXhnFClL +sPzOysNnr52LEmxtm4jeeiagnP/IsrgUtEOeMN4RO1Qzpj8j/2EZ6vcf9+0d+lKJm+d6lqTwwuKd +nZHEECOSMNwB/wEsYeHqiAILK551vDWcWNSjy4y8cxpzMXswjc20kJIAGgVmDCQQNE8bjyGeZk53 +3TW1vGSplI5L6zhLiVgomddZov896SSX3k2mPU7pt9QZGM7vMqMAEA0piCONQ84KfgqZH8e/2Kvc +8wxHNyV2V9ZQujxoCiHaoVZ4YGMJ1OX6aPJXqe281CUyTc9c8b4t3XjLhtm/8ACGCHi9efyAsCt7 +TIHnqMKxQlq3P2soYMBwA/4bjVmsTMGqxheCU/SoubfBiWZ1Pm9EtOS57ZRZ0DVezOzOGTcV0/6j +qkl8qOrm5O1VEfiTkvUUQKDgCfhvMk+X//Sv9b9mHmJLDgWJlJzIlxaZZ/WjgDoBSXLAIovgcUOw +B63OCF7/mK45z2TSdOhStpgPq+mv239BXQnTJnBCHHxUv2kjt84G/9n6fi2doJaIy3+NeRruK/MA +9chaTuc8ncw1hSR37zccsi7VVrffU6GIT8d0Y6tSEXO2Vs12iVeNQSj0nxpncQoEFNhaVlYoiVZU +SH7t2DqDMVOXrgNb0PzV+zdRYLEYDGkTLJhAA4gG2JDqzAM6W4+86Lwl/+apYX8x0+pqt+6gLzvX +U9AhfqRA+YiFMYw0outekVTbun4KhxvMG0gyXz1x5CbjGUoSeCvwn9DVkJKxjwWnjwgq9t7i4nvr +bza2e7vcWflrFGAcAqgK4gEs6TkRLAEEeqGXgbvBJKp8vx08dWz0xzHOAaGOp6kJwsepiaCc7Qki +YCgVZOkCHsXmeXzZdpHvzTdXR/HOxoTAP9TYZZu6tOmOaMbsoFmLNBQrrczMLsfF02+khAJ/B74r +0mx2LrBNL/XtSUHMLllB+wvmCvKX936nyhFsc1IMoPqJ6dkoowebZzaLZvbNXq81HUD7UOIwNhhw +MAQVIAcqfeDE9lz9s2vEM74FcNxnOYESbKJEehLGDHvkQgf9bId4nGJY5Dwc2KRZRSeVILC6h44C +BsQvgQru4PIVv8gPEfv+ak7aQz07/f3i6IwGl1SjdEXYgjX8SCVeaItstme/CjZv6rurxGk3/WF1 +4NElWxuBQBTKmeATkde1hTKxAHhCqanv3uZDfl90RT+znf20RnM97chyfLGipBWeYFIQl+W6WI5d +jWUXdeF9dLb99rGgtgS6J0uCQ672CBuCbwSUtHECyp9DGSTAiJR7CT2PU9DXZ+5mzPe8rqAC7xuU +rkCCRk/3UZl74Q9m2Vvc5m9sz5cUjD+bTxVZ/KXnbBIMkzfEP0xd2X3ApFjqSu9wwDqqGKlK7SL+ +pTFx09HLPjXG5UHl4pwXK9/u6ApZCXdBANM9GFiG9oQSNAQtv68fiXjyw0Xx+duf/o/7Lohy0VPT +AKeKLcJGe2bM+Sa8fnI+8cHj/7vpsiT9LDF8hHKGEvoTphkMOGlLf4n7+vQWsumS4le/kOjZAf4a +BfplHLB2QSqbJ5Li/rWsqv30yR8dKmVneXuzt048otCcWHJCklh7h6x63qagI2ewgw43uL9q33ou +yLquXzChkroAGLLV2mJ9K7hT1QGhUqL3+3jFMaZt7hQIYPODHRA/BCEJrV2iqo7PBNVKcRP+e6Ni +FDwilsTViYWnyWpJ185XSLMW81XrPh5hNvqtL3DS5fpOCgTpFBdxMAZImRKmNZXGkZ7aJ1Ejenk+ +iFuRVWIUSGjXIzQKE17CooXAsT8+/SEeG2v883mMFnp9b8PHvR5/58EIl17ThA5SwFV8/oXc3Cqc +1GrzzmxqJKmUL2jPgB4yuKN4sbLgvM7r1MC6aw/1eURnyhWeaDvcMmKDi5E9sdDfnFf8LzwZO2Qo +cP05r6PP5/JzW5YCpLlrYerCY0GD/749A6sOv6Jno+LqAVGTiAuFXJ1Lzo2BZeYkrZ1swDCsDXjG +CeBKyuuPKvzZpfbS6GP+AbYLGUU3LZe+ozNo8BnZ2RH6ArBlg7S2DW2V5h7JPoZBZZ3XkZW3lLII +s/52fZwSjcfZg3VHxcfs/b2aXMaz5varocRoErxNW7dRaA/ESPDQMRGf1fyDlpuxtENpxhMqw9wz +dv0sSRSIxRrCKhuTNv0erveeuvQlt2Lrnpwvc4dVKAGQPUu6G/DpO1rEandfOqhI35v8TZDJDNmp +oxBBAQVLkQPzCwgJZ667694od0ndpDY7zMD/jmfTBkYqkBUCSO0CZH4ncA/3HbBt0Uiw5zDT6hbc +qFqZwXV8MyVuITvvQnJeYDiMRvzc8w57Yf2HaKlZuXxtPWXF8xRgYsJowLGmD/tueGgj70atVton +qII3J97d+UQBIPYNYN83EC0F0c5wjcG8elPPhwqD9G0DA5KK2q1ICijBL0ABNQLBXnUim23PbJO/ +kyArCmN5QzVOwvUAmiKzENOsv33ce/DdhpSdfKZbMhtFRy/t4N5PiQCOEQNmE3Qml2znV0r5TKua +ZreGGre5+tymG47dj2kG/ioAgA/O7nPNsD3CX083/5R1xD3nbrrzAwogsAsLDaYMhWofsVmL9O0b +m4y/eVRqrK+w0zIy9/osJWxxYfKBUsegG+PMdvqehKuhHn1jXwpe3qZEAPvvEYu9UjfHQ/RhCvf4 +sWe0vIgtp+NO6p49RwkjdEgbYvCLMNJDvRQ8cgOEtFof+95uPc2ptE+QZcq/cW3YXMwbuAYYFsoc +OMTdWFjSMrLL8YUUTq/hrYPckpbgSoa1PQoNhvTBJ/gs71Ziq+BrfFhM/4Y8g6KBtev9C+AMuN0C +sB0XS17ulX7IfXRziKP+r53MeMtqWZrDJndWAAHklbTAuImPMlu/bXPOscz8151fNqbDEcKXApXj +8t41l2/ag+A/7csnF6+Xkc5ctRne2gWBBw/nA+fDFrqFUoZcwpPjXe+3Gguw20jZbJ6ervixMgpQ +hyKNmZO3vJFcJ/pKKudxFoMZk+lbChRh8CWmpCAwFkel1rx672Tu2boV/Z+Llb+Ft0EbFWbxhz7T +MMve9votcLrpaVy5Mme8jdtqUThEvCfwKgFqpHSzAsc29Qe3XyHT6a8ctWhunbGAU67WWJQLjviS +MQsBYyPhFoySCCPSPfs0n5FQmJxI7oEXK8PgyMP2tTZLlCemX//iDvxVkasfJtSYllPEKqZge0WJ +pyGaGFH9l24Gpj8vnWDUGKZ9DW8PPg2ENSl25Tj5mLGSIzIIp1aTLuhbx3r86KsaKhDhrwQzAYBe +8wS5WL0UGv/EUXxBdBvvbKRDVB4cAlYSFraa5wrZSWZ7mabge7d6KdNxcWK1VWKXIcBKpzVhoMYA +By5Jh/cXvxewiiVx7vVqLmCjCZFSWiuTanPT6h3yqgTCgIIa0BzcpUN2IaLrPN+gmpp9inpnL+Sh +rFIFg+6XUkChmwVMWtLGoBMl87ewmRrvhyMOdSrKPXXTf7X6InVwYWuAj1LVKvmnw7y3VPpR3xhH +vsdm7X1AASNYQKQP1W2T8PSWLq1KPLN0h71LzdNYrITEUgIq7WJjs/TcDmBAu6894zYf4y16d+/r +3ecOJkgnmoZRQqGolySaYJhYg09FIuj7I87U1JipSxwVX17697ixaKZQAvE4DPnDFNugd7X72Yle +5In+/4ZUubQ+fy0wpoSBziGY8Z64TQWwWcEBwx6LccbgXdFApg1wVzrGefHZcbFrPLuxvTZaDy2y +cdaYVT4ILUHpqpYfjaB//kL2ldf3PuxI9jvfYDfxHxecOClirkiyzcLQNwGckEA6A8ddEVYoNAra +YImTVw2R9qhkktq+8Z3sZ3d7XvmlybsWEsbYgUFxyITtSA0svfuEO/jOs9gtGbU+M83Hqu5Tg/BQ +ED9++ypPmRnal4xCLfz6rxIZX9hFy1BArIGcBZJL67/5qnrtxnvde5o/JXfhCO7SBwX+/lWUUIwT +eEoLSOpFWuTRGc1imLg5sDm+9dhIUVaYQ1HkIKW7I6Lgp5DXh4zST9f4H87OOxDq/3/gJDOjUHZF +9spIkeyEkIyiCIfDhTvuzkyRrAYJmUUlq6GkRINEVFZ29k4TLZT1u/f7huPep8/398fnE/V+PO99 +7/drPNfr+Qwvc/j1PcjCKDuOuRWSAPoH+TqDj0PN7DddNVyb/VT73Uan4PZ3Ro9QIVQYX6I3Lf/T +66t1r3vbiuaSx+/cKi4IKJMUh2BcwNMVaELeODFOamK9/ZuHqy1859HvnahPwtGNM35OkDChQgeQ +6IIvRwHQeRcXw9i+lXa+pLPf2K0cu9D80jOTOg0ayZedQ3gY7zXq3I/OCeg1/yb8Ve03FAH0xsEC +lU2BMcLcrDtZFV/UJxOi+4qd2cfh+w0pKMbX2xMeQP5hdhm8Ycx2aSWZmR6Lu9wluC78xj6gDhLO +Hsn6M3AjS8Lq6VktztqzWB3XTVt3nTpEPB41KJa60BTMvenLwX7mD06eyhr2khuoU6RkhVse2ziP +Xr0q94HmPHbkS/aVuiNPjKhjpNNShFtVFzIVbmBRi6/8+Ger87u4al+2pnX/gQZWDmKA1XJ7Bu8U +/2GF8qyFb7sXQ6pq0p4jqIsgkmCPQYw7fkf9EFgjdQx2oAjFHz5Yb7GnEyXeyk5VBAD0uUmxnPKr +F+xnh4nsyJn74l1Y+5Aq4A3DRzI1BRT29j7eY546oyDEeahqD63svBwEBCRwo1wJv4GPODTrKr3M +zEPt0ZnNrGaH2fjE3OnNqICgHoPv09shmZRqnoaFf86SGsv/woXa7oeBgnB7GCntlFTVnTSjCYpN +WNrPxTFxB4OHFRpi5469Pz88xAS13xC7ieG9ST4/3Btv+l2/kB5zylvFsD1pZ5KDCxQETkjArgK/ +7KfPD2mijfQLLDbTlOpztF+o2e+ZSI3CgI4swlAKXei/WDDqbVu4u6fvQbrozZGTU+oQID5uAXqv +vCsvvb5YSKcxwSeVxMWaX5TKBLW6EQcKIRUXCJUA6UooNCGEVfx+Ci1DXzm+uCdSwm3N+oHPW2J3 +ryYGaKmhA4iyIEbDiK7isD4pg5fpl1ozq7Xavc9vL9ngKfB9NUnE5kdE/liqdLH1zVv82RzN5wyF +7cQHxWCfVuHByIJr7Wj6hp+Xs7C+bl+sFXNhzm7boRCcXWcKA3137Ic2ZAb5nczvOiOxUzGL87qS +U3E5FIFC6wM9rgAnV7347n4T76zuvVMl108fO3TmQVcWBEHuq8dR8PPNZcoXA0RrFZJ+uEoECsgU +JqdDUZilIZ8dKPlnx6XEd6+Dvd5/ldjk8+38m29QCHgQGY2CuTjDcH+7UqtoGnGtvLO30UD3NZeZ +lHRRIsvnPKhhSyEFqCGBw2/LnlY48PJOiqOd4Lh3vJ6jVM53pn/j+JQR/IAKyl3vdJvvRJXR1TF5 +Gi5h48YKt73/lkBcxtfQiW0XF0kL2Xs21aL64rOMabnELmo0aROWcwrE4qffiP2nS21R89HqJ0L4 +LweMIjjkXx38N477H/7eH/tnjW91uHv9Z+1mzZjJAdoa9tSJf+NY/NAq1Ur4IiojG3hWg79mS3no +F3MPdqi9eCVMiCFumsvR0b2p68LxbNPxJMOctVfp8jqp0mgUoYM9+MyOI+N54i2/On+1Ou899WrP +oE+7bDA1lPz40oUI1cWCePdkxQKHzv1/Lnh/XWCZosqRNo8zr4+dGGDaZJ42qXmb4YzVLr2PI3XU +KNCyhxEt7tDQx9n1kW93hsY652aMmXH3as7tXJUkH1ZffMuqwpwY6JokjG+WBe3YdvtrJZSetAQT +P7Ulu9Ft8/r36+8Hjadde+UuHCkHD10VJO2xYIISea6+2wdMJQq1vfmL425vOhXXDNUXExupiQJ3 +BG9CZKKB71REuNfCYIDKDtVu9aj9rz6Mb6MG4otTgceJQDcFc1V/qxzNT+TT0XOJ48ec9rt6//oH +umRobdQczGOH+THPzetL3//YlCV+YzjyHzBo1YDhLp+cS72uEo9tdjjm56Vs+y4OPzrSvDoMxoFQ ++a0pusr6HDb0v2gewrPXse0toEoByXyk4dEtlqUWHrrhAttpKfrLm/0P1CscyFmVJIJVQR5a8cps +d76KG245fLpNZ/ZIkjl1EONOsWbmSIuOezjtkbDB+nNmaBSHdnTZD/xDAGG5fI7Y+8lIzHdLu8vk +01jpEBZRkRqxVcml4w+TwbXW9q+8F/VUCkbE8xd+chQM8FJDSZojeDoap5mTT+PI13XcXFH1XKne +nqEtrY5Hzp7/WvpfBYE2Gc0jHfeyqKmDrH2bKx9Fj8wzpfdQ48HCv0uv7JQgQ7HSRT73gZ9ZPZuZ +JcW3jm3ZujpKPqUNI5Gwvtvp3Q9VStfpeQujhENFFVenibvETpmF6Yv88tmH8sbk/AWk6c0HhKg+ +OzxJvOOUu9gFM0E03L1uh4EA4v36OhaDTauSLqDHdSlDOmhxq+206353ngM2isjo+PPS8WwW1ATg +phPxgQPoe0nvnWNjC3XFHbVCpenzU4E9AVTXaXwVLhQab9DCwC2iiJdDp/Pi9Qd1N2nOKHnvsV0X +1kB1/STnl554E6Prk17Talm0WqjUjsf+H6QNvYL+LYFQlQvHO2VVBNxxsJHNU65V+LzVNeJq4evN +/+ZRvlhvvIc8K3gy5k2b1vbXw9vnAnTnErb0MB/4N49G+SJdsGh8xlS/s6GGZ4SKqdXjzF/hokpJ +jhstc/8tgvj627EvPd+uZ/Hw29hu0/HueqIB6+M4avTyJBa++kFE+6+kTQI6WcIGJma+tnfZvKmR +S1YaYbya9+yz1W8ytBgTf9jnLBatKj/hTXVzJ8FkU3SsZPdLSZ0GXVtz6V1T0U5rsi4zQJlQpHol +7nBPb7xygcEq7VQiJFeAJVOezb+C983CeOM9zsW99Xo13XrVEUKSF16lERa3UVSN+C7iPaJzZNo9 +0z7l/neoq5c8Gsvzsl1KHf/IGF22n5AT0qi7wSu+NjsoHApHgtUeCCsT0Xn68dcnXbmHtKFhIZ84 +GKSUdktpsQ9CwEBoFkgN93Vzx7vuQCeH8QyWcZfy2Y9jEhkTHl9qxsqj70OxoJMZjA4TrLC1xyQG +IiyxzNOpmbDtyQMl9g3HoMxOPEjmLvSCIX3xxxUJ7vv8o/b0BfkTikXxvbt+sJTx3ED/kfkvgvCb +BHjYk+RfZEp22+SZ+oiVt1tUp+WbEyw3MxhKJ14pC0CvDIzARbX6Dk/E+sfukGbeG5V0GvIhAihw +dh/p670UTNjTVbrPsBVuYsxSHdj7Up5bgX3r23/AAFb/sI2uXVfa+VrZl0k3jSC/K9ZMUHsiiLkA +5RpQ+IT5ct+9Nv5PJm7offl+cYbnQ09yze3X1DjKAzONu3emvks+5tZxyXb6VQui18BJzmd12heJ +z5gAX7xuRYP/gmEASozDoIBFwa/VokuWhSpOPGzW4S83dd3J+LMSOtC34goqLfaiDpSxD0Jgvzr8 +WPNFEsf42vOnskcVnVMu64ZZ14h7bFmTqiGxmgDQwxAxOVPQGfaqwl0l+HTOdsm2vO1C1BiKYckk +ntbYcn9jhY9dG4aneqr41IxkGFWY6FcBfgOX/7OsEsZXM80Pa9ZKYhYGr4vT6sc/pUYj4XCXvcRh +GHJPXyfIYb+4nrGm8O6/pw7eXhtoRQ0kW0xw+yeSVGiD6DD1mf2uIxp+bizyL8fusfVihb4RP/dT +kwVmpQP+SAQSf4wa64/Aa+SLPs6Xoz8bTWgzw3VOGXB+brqO7aYmBf++yF1a2CoVtQSV5i0Zlo1t +tE9u8EomtzlTo4mn44hHl/Vwuxk4el4+3oMtzC0yzlIcu5fzZscXjoXybCpCIKobARIYbnzzzPOf +Uco9le8FK+dDV7HFQu1mS/ElkhHH9lwil8f0zWjxqw9ldQUyXSqKHtOrke5YrLcSAFbatSc933yI +7vRB7lz7hM/CcnqnoUwgErjswLY+6nsTp+7BJAGBGI69w9ZSDmpP/64Gk5//56xZs5juo7d1yAwd +elCqcaIuGsqtQULBkltghwoghEPmkjZktw1B2/w47s8pW5arWCVYfgE1u5og4tkagD13vepESEth +oEicGve7kLn1YQwTL1ZjwTRW/CkSDJZY4OXY98WM/kt0k8KmfPzx5puyfET6tFcRAiDRFj/2+9Jz +/JpM3Wr2MEFFZ1TvziEohHRiG4BaZbe3a/7ejlToj6n19dyc2fXxApQbndSgFIckG9bOIDfyNJzX +Uvf6PFI1jTqYfQoKAfYoUghiUrzW9ty6jXG/1JGfnMQckvY7z/BTg/BPAfwsh69j+zfY/byXPpF8 +Q/QyHXPnnBVUEImkFoAxRPxazZg0GCcYPKJHm/gkX/7d9zlrHhSUibmEurjgy3jhJgBYaR6skIsT +5LlTJTnOWfOZcon/uuiT/neuvgiAsjiXBFHWFws9XWR+6bo2b3vRXpGI97Kx8RaGUD4Ukgiy8FSR +wLEofsdpI+WNtgzFWKNTXBsjHVZHCV5t4LAnUKwXjltYXMC7EMhcm1R66astMqXh6DGb7mg6kfGv +q4kiPgCJoN7eDyrhpqmXhav6ttax/TTshop2LXEEly0c6YwiBpwvm23Se3LXxPxhr4CvNDtv2+fr +XHyryyDNxdmTOUrT961N4KLb9X9HMLxK3M3uuSqKcLGA408M7/t4x0Mq8t5BH9fcT0o6Dwfa70Zy +rY5iiM99w4UzhbNieimjRq213cMBbTaTqqKroWB5NtJvYJcCwjWgUVdiPDsmhGyx3nbubFn174M5 +2/82/UsabhxbkNmFi/eEbBOVdwwF8u35y5zF/F7ia9GXVUUA2T/4p4ifEMaO5fu4/Vkelr3p39tm +xM94MGv9qg+DdNbxIvLbvv0HJNw2TYTv+lnsecNmt7zrqiCoOBF05Yeojp+yHp0pTOXiTtxDPEk1 +W3v3rAoT1aYep0ejrkVX6haHND7ySVjZhWsMVqwGgqoTKe4OSHhSrRtyP3lUc+iUZbNgxyWz7g+z +UKGGJQnEWoyEUiBEo87920kEQvtsexzc48BWuXMn+E5pM64mx93fS05hyf0R6WFhmNCmoLf1xYOS +iJ33r8SY74cyM1bgSBT+GxEn4fM/V7nrsMyxr1ikk2dt+D6qaMZD6b3LpQCgbWFAWHcy9x+x6U3x +Z1819bS/TVh15pESmdGESXRVrXDOs9t945XynRz5vUbvDet3eqwuAJ+SCi6mgACOOr8CzN9h3k4B +v58pTgc12dhGoFxPJAGAUkg+8rXEuwMFTxR5mFye7Tr/c/8Pu1HlxdX5ACzw/Ihn7H1ThyPfeiOZ +x36MjgTmP5k9UP8cKgdliQfSfYCbAE9sL93HVmYZ604bn00sp19umB9ObEarHrVZTQ6h9Bu+DRW4 +s5HGhHr3SIt5sKGe6i/vB7N//SPylNfOrCYKn2AGJPQtaemWIhmVyhl2BcZC98/s6hUrDjDkqFlN +xtJ94fWF079NNgQMF7k+NRBm9TzAJrQYe3XVTYn0A1iidOk+nLsrGcbUfhTc26j9tZg/IyNuMsT/ +v8gBWCR/SJG8QqhXDtOXy4m1mTJ0D65A+euXscDeTPjTFIV3zdqrvfaqzXbrvsRPZ/xC9tXd1/et +rVcXAybEEaqfaq170qx3/waPDqeum+zR43GMH05DxSpW0JaEA1bgHLllsUmq+Mi9b0YNV4Mf2Eo9 +tC6sgAoYLu0PcKw+YXfEF+cAfsC7DzH4OIb4ujtz+rMwC4Oyz2kzn2Y/ia461MjlEYd9qa3400Br +Sc0d/JVvlWhFR0d8H676XnC/w7Bwt0CyXL9ik3vtZyPuPLWZjUxmUlM5a14mR7uaCCAygFs/nQJR +4In9WIf1E+MCQ1vLGwO3raXf6Oj83eDef8DJll+SqPNbYnh5XmTbfQv82XDod8+GH0cWoVwuq4gC +VfONf7Ucunm90K/Oz3y+vCf8+Mgehn9LAdeQnehHzBWY8YZR7XDWUkxf5GfImN9KEnCmXfzzY3bT +N0FE6OQ316kj32mnTg5AJX6RUIIhuTTBHnKgjevmzrgzpk1nxp1+47vD9PqZ1QVg3BGu4CZaV3fG +rCLxBPbD9UChH6O8N+5ybmJeDQVtEV8kAijYAKRH41ZAB+I+EPFxd1ax0DWmhuN3nWK5D3VghWVW +04NNQJsO34GccIzRXsHn70/v0Z4J5jvVrYGsKl/D+1sgJbj44u3v1DWZqDPr2zY+prs8WPEhRk80 +mgVKYwX0XKLSSZjTGgFxJ7C/s1/LxFUGBoa8CVG+dwnKrsGgwAPpQDlBPzihTSADz3qZKp/htHIs +YiBipzztmLMwVDgMi9IBfP7Ah+nFCqMPaDuqhIvVJi0eeH9313OrOUjCGjckYZ64bR1D7KpA6j6O +EzMfxN2WZMVTv+0PzU1lxoGAiz2vBKHELDntiaksJIdFuWx9/YhtRu5Dx9tqRv6i8lMRylBhdXK/ +P1Vz4QYLP2PjwsegV1c0nL8zHtPidY6zXVUWmc4+osO+4yWqqrR009H6Uxh5q0ALaygbfol1BQu5 +EbdHu9eMdON+FYM5c8+KhuwSDnN2tK7+NVyJldswCaLRRhufCO+bM4sdDVUXZ4lCs61OegIbM1HL +Uo3mqH0v3p2273nsw+ZHydJz0U6rf2fccAO1rNizPj+23ERLdP98rQtr8uIc6I6D8hSRhTuWHFiu +ME8MHGyX6wu+xIBvo0008I08oxluKv3nTpZGWx2D8t2RxS28PRFA6TY3d38YsOLB0KDeJcV68nLw +y46GhXD22iavt5cf6pUk/Ac5yx1p33dwxjXPwSS6tz+pi6mS935cevAnlBDg3AGMOCEOdUpnbe6y +WuiYcDoYyvVuZ7XoIAwC8kUgsaokyGH+6TOrh0MphSe1AuBY7+TxyzpQgSvC8kiyE/bIuzWnxY+/ +rQ3a1PGHdmPDhZvhUMkchEWR4Ggh6aaHfDsjsFbNaBt+w0Mhb7bdEmktgvp6RBpY3OSIJwkLCsPC +7qLHVWk+5/cHm9Rc5PEXh/LvkUI1ZM4J2nbVDbZNDAYtG95avS1k6ova1gcVr19KMgCOMkBb1l1/ +N9mwx5pdR+fu1xI5MP1UR2X25KqiwOK7S6HKqo6Cjfyqs5xzdz4KHmQISnFoMz26Kk99xdgxn/et +K7Oi7qbSz8OnM2knXPg1obRakih8rqvLsq+Dcn71IWob57T2mEe8mrmU6+sr7lATmEwGadFR/HRH +29WsX0rzdc3Q41K2z9Z1pzVWQwEL2dlp6bjgd+1OtWdrTM5W5jG3/719XXSHcz+UY2slT+77W2Pj +od+Ztp1DMu9B3/ktdhtefPaDSoxaJoLoQQd4Gg5bxt+JU58ru6Jp+R7rVRhbYqF8HeQ80O6AuMF2 +d5rx5zG7qqQabfvzmTOMS/Y6N1TKJnl+KIwst6LiRLiyiIj8zhTh33ohR8yPWNp3QiVPr8DJ3kCM ++rTsWU4Ue9cj8wrR6W8fI4WK2/4tAKzZBAYwe4VvV9Z4BnzEvghzCxeX+aaRDGWorUhvXe7lEIEH +8XDQROmbCZaejM7SemaWbPDo3zLIH+Kj2I2Hk1TWhSieD/K3lVn796m4MlSOMGSSbYpPZ1eetVLu +ft20DybNCQHJaSI8q7EUtjIznSzjq/hD5lkdpzdd6/vz9IyAju5qAgAzFR8TJN0/O/q90jOtSeeh +319zZzii+48w5BauKoJgL+ytKFS4cS+S07+JbcFi4XbJu995UDFzEkfWTRsIjRk/ilp/5kb3yYjp +rNTqV3H7RjdAxfNINBB0wU0efEMJLAIf3EuwzoarFJeV5NDwHvFGsIeMwfZDZUqThJCnSE9YWfVY +TKhIrL11peUzfYH5xe8BAv9i4cvmP7pb4JTWgvfeh3Kv0n2NMTpY2g3y/0kCSf0S3ZfySsRy+sLw +ZvbDG79d+j4VI/Ls3xJIN+A3nTwr0HbG9IBdcrHmGzb12bMO5/6N43OxCMMQEJPZoOhwXp4/hmUq +/0ldW+AdVeEuKOORKMYSGDhyhI4zOLyFtuVQHTdPlD+/WPIZuC9XIXcB1DmY5ThuEUShPYDMX3Bj +ARw4Pr64q0lxrMe7bDNvPBlQEaZvEaoYPareq/wEyomI/0pkS0rrztKL4e/Sq20LT1sqGnvfihq/ +AhWxJXDEUOJzeMX803MbU7Jxu5No8LWFwLtPqL0I+JLyeNjyRMffT6aPbmtpnjwVNRT89VgelKNp +KfntYV9grJ6xfcORYBbT++KMPdHuUhBp+Urg6ZydO4jdU3CbOT7HiugjjdT7oP5iekK09mKOAX9U +q6la0TaI1DSlpYSy3+uZRYWykWmHHMudpkxEbx/ZNgHhsVAiZAUhlg7/PLrQZha6GMu6Y+6N8q9u +WFlyoACEmqpE2JmJPdtAL2DakMBCTUE0X/s+1cm6rientC0VoEjCmrwUQQfgHLpBq9KzMLPX64JE +1/BOvglX2KX8Dxi0F6UQt1p/HElSUzQRu1jDLx5ZpwmJAXFHfNshkj1FfLT8VyfPKQT8lPPrYdzu +Wscarpp5C8IAViK0wwFfCm4hxS+IDod5GzDctMWXiqfKXRKaVbDbnthDsXiFGVwFjzyI3Z8geEB6 +s+Gkjcu9u8NGtusgYt9K1NITWn6dOU2v9OzP2eRfV/ppnZzqOjUg7N1lOJgWQ4yfgiqEZsAHM/fG +RmtltMpO2JqJnMTlXcFJMgjntCrH4ntfva/Ll4BlzSa13XMIeXoXwrOihH82uEkOFI/D7Rle+HRq +IG7qi3VVBSQZoNZu1tKO4ng03i6j8dvE4W6zyFWqksAgGaka6Yfsz6csNm3fL1235i/ndH1v1sF7 +EIkwSuQBEkCNxy82YOk3lCsg58RQpc147+V6xSCX0xovvjE5i09ArKBkcvCnBpcWjrIiuL8fbBf/ +rnlMS8F4ffOWMEkITyKZALC8LngzhBGnEyKrzh4/LPn+ulhM/6nvY0fbiiGy18gk+KNh3uQr3vD6 +AuYPi5YNPRkG3+Mbrli/OaMBsZGtFEBqoKDxtCv/0b3yc6iQXacKvUKbTsTYQSQMUODEqSonKz70 +tmff8+Nb3qbZz13mffn6dOo/cQA8NUtrf9OK67Ga928BS54PT6O0dSAnK1iImUzhl1MphJXT6u25 +fLzc+jJf50GHqQWIAKfSkpkKQLnvfuzsiIq1Mt32OiextsLJtPoDxFatRDQWSa/XRFJjKtRzf6Uz +5wDiy26L0hePTSDUKxJH7HxgUeHs/jvr5IbNNp1IXpV3G955RtRCYeT6iLBlakVL5nGJ944bj1yV +F5N6NOcKcYROGZhSHsSxM3iV/kE4o7fzU93gtq9SfE1hPfUQ+wmBwW+5AMYlWds1ycji2HbgOkf8 +TG47Y8cBiDwNZUIUgeC+xzv1iuPfSDjdf98g9ORQT+eDNzfSUT8gzsYor5ZfolkWN1J6yZmBm69E +0KUpbZtxlwnEgMdQ+ieSz1leUm/b3qX8qSSSjtE0/bOQ8sqAJBiHJ5yIJDyjo3vsarYGXN380dYq +ZeQw5uWPF4Ylq1CuvkFgzZHdMKaPc6kaZ7bcOH1n8eUjrEBi/cooFhkG6vJnhzgXB9isjew17J6F +IVx0mpuEKQn8KgjUuEQTtIh2Pc7fYtq5mjSWWS7bE9gdkuUrVo4xnPXsi9OR9ID6rXIuKK9lFVn3 +6dedoxE/VflqVsHqV+9P2+Dq5mUV0cEXAJyvJr7DMJRT89YZFb1b6hum/Z7LPf16C+O1HAD3ptzc +E7GCN88bjjNrhtRwqVhK5pstcyMD//MGljE/OT+cguKHgAH6gxfBzbJwYyx6EFuidsFXFlnZyjc7 +gniwrComoewczBsBlGQDPzAnWydJcf3TeyKfu1Fs2m802zVrG6AQQgUkgZum5xt3usx5BTM3mPkx +DyXWV9lCXI73X4AVfl1QuEcPHLHHV/0lrWFnW5UrLt0evMzPsUlasN7MLUBGhJOqJEKUjpqsZIvf +u58zHvKeUJFBnKY3HBRTXN5ic5ksQpkPfFIu2DzGxxeB+5PwDBNhAt7eSeySmtfUj9s6tFXWvj3w +jposI1J3JBi+ZHS5THVJ23VfV9s7H/LNdm6L/GOj9vOfMBgD6AzzuF8jJm5Es+tjcrktZ9ab3awQ +4DIrunBLQuniAdmwRLry3YYwDQ4xA3F6KGYpXyL3yKaHvPvMb8Ho78sPzBZ3Fe5l2wtBLDV9wqcU +IVwR+E8882uua+PQ+20NcNmSyPZnot5a1mGr8sR2iQTfwS3xS/PRjvxirSdof7zjKJSc5wt9/W8e +nK8nUm4q/rD94C86FurCquFPH6wZuCqJ7wZGKOlNPAhKM9GQXvu6ZXuI77FR9TcSQa5rTkj+BykY +MNQCCPj78a5mQR5tbtFdaaSQZ1vF7xlLzX8LAMnMzluHqmF6kVKH1yrBZdncEnn2rUaCjiqJ4di/ +6VsHRyadrUTZ1pk03+Fgh2KIA3nF29r927hkFMF/yFG+qlUoRAsx/WQ742o46TVFodhGj944Ne1r +G5e0N0Hku7zvPXtIkOAXAUYzaD6+2xdocmzcYGFkq1VnEOZOzGRxIQQH1HXFvRRAHwb16f1bHaPr +3XJ+7MmM3V8+FxNn2nENgvKCBQBJX4QeOkvFPusuX1680jDpYC6pc4NNOXOz3/O/nhA4EoZcwsE8 +IFAp9wZO8yxl2pk2j7fdGcXyp3DI1VdE7j61+Idp4V/CCPeyLP1OOrjswexJ9r3nLBiHcuuk5NXq +UqEWYig5AD7zdOooE0rchLWW4Xxu5sJtDrPZMigcKPMFdFWkuBeqX1D2J5//2bkSDasbSIMZ/2q+ +A7HvoFZdqpIBGQe2Ifn/VN8Ytkjq3q/1UiBe6JtDNaQMDMGRvj05pjPq0u975T3iyKe/cqwyt/tx +QQIBwM94Y8O1u1Z9SLXn/GNeWie6BIw229AA1OIGaPbAAHYDDjbCPfFBCqYrW8bPJ77o8JF4ijn7 +KW2zdmdEHCSLxT8o0pcEGswCAqqzBcWKmKdiuRrdhV+kjprZH8mYhxQATpfatUPbeTQ3Hq/aceuE +6kXJ0ZpDV59AXA2mWRIeYcnQ7hud+36n5q55wZRfTJ8sXXRjDgIhde2BkbUVjFQae4O6Fnl3gktc +6W5pV8edBadJaBbfWnJZkdnge/HzU7mmyIyzwws/hpMvpN4OZ14FBufETMdeA65IBvYB2lCnsd7R +htjqbggEt87h7Hp3wNYkr53f72QuXe9YeD18nzsy7ohs2d94xdPUaYCYnn+87bvAldvb6hKZOSw7 +T/CY9gVDEGBCOHEv90cDdbuBFYVQWh4cd5PidHejqxi4d3/qpHPts7k/KuckDiUJ6JNKXLApSkQa +3a2M+3vikT6DyLsm35cbPmhx7L8MJQRfbJB4Q/jSj7iXjlPk0cR/xO8mIADGl5p3nui25pHObR5L +jB8VSh+m21UPIRnrjsCHeq9JzjJs/VOkcXCHeVpKlvTEPCYb8nJANfIHOxQ7gWOcVAYQeLh60j+U +X79UXVAT2kHPUm1R2xp5H0oI4Wus2FGKOk5HpBXwBemob8vjbX+ndEW5/PMqNBZF2lwA2uPM0EDG +juwrdjuPlI+g8g1M0MWGq9BgmgPZ/AZEJE1UZxxMmt9NO+p7Supu/sRegR1QewXug73RQEE9Qp1y ++HeBS4YK2t8t/ELT7z2FiZl9yYJScqGbL5xvRA97YjhKbUdjiqY+lKy7EvL0EiQMR6JRnp6Et0z+ +xSc/waVQiQ9tL448vXws/NRXmlNJdJASwOEBvj+C/QeqDkJt8+/uSkR+nc7xlE4s+dbSii5UpYaD +Eb4cWA3selSNbvlfl+2KPKbNfx2OUbveZWn7x2ARuLt3RaDx0z6FR4732R3tIK2zBk/HKz98Pnvf +s5KaFDiYmo+vsEksdZp1/lC5flvq5SvcFzDhgxseRDLscF2dJ1827n3ZxdC//w3HA4mIlkeNqX5r +vm69AkVjgDP0BFeg2Y8D7uePZvFe2HigWG9qW81TTPsYBAN2ESer9QfLfsAlcNeavaFFf4NKUaxk +14RuGyUGXLmhepDho7VjnvmO7xX9MD13sZj3yzdPT4ycgpwLEmcueWKJ5ZNHa2M1DIO+b1j/Mjul +eqeFqW5kqfpKCExrXypC3nlHaFOBxne7X/xXjmWa+GZrzP40hkCcwWyI/KuWv49pjainquycCQto +5RWRabtNcTFu9ccuc2I+j+ROf3VH5BzcxkNlmw1rYd0AdzQkBVzs8piJXe2JWKLbBocdkez1Ygvv +fpZSXuyNJObLELrL48j4/taEiPWHGZnfcp66IbJ28y6jpA8rSdBhTnZEE3zUa/cVF/zgm/8U6p4h +W8xY1cfpi/1MAeJT8Qh1LD/3mhSOsGbMlF9I6911WGVLbYrAvpWEM2At4yY5eG+qOTf7v+66eD9o +GtPqxPFDvE/Bn5USwC1ACKDOCv7I6u+btwqDtmpKvdzocrYyT8bLoSjnEQUDPGtndxgCNw6WPm3x +wZXft4ZqKm6aJtyOe3rm8+X178+uRoLzAQAFk3sidL9sroQxKxQN2xrXlbmE1EOCgPZE7rNry4xn +uDa8Ls1jfl00s98Iasso43tIcKkRMoAdu71Nm2vNN95tny4ocFt6fqnjkuajwIBq3cS3jXAB+rzh +/ZpDW9Tqapx1TrJ91Ir74iNZP1VRc5EC9kSAyrwfHF98TVEePI6U/ixz8uvdusKWdKXGwffafgwO +XyhfBwWqDKAv9KwW9r+5rmFseG74lxs8V8ewZzMkCh7vDAAr0Hoi8FXCxgVPybDaGt9/3DSv2nJZ +jWeCUTKHGrv0sWA6kbWvU4B8w/gFpcUta7tqS0bfvk9K/zeqCJpmP4ou76uSTltz3M/yYUxzZy3D +zR3/RsHndCbi8/N1t691oMUPnuhIF3L/O6Dk/28UfE4CdS+n6pX5r12xkDeW2EVf0V6peRQCBUI0 +YBoMwBx8c7NIdNdc02dNHabYupffZcz6BFdjwHt8YPkB4elht9jfwPv0w64iRp86cRtqEJBpR4xh +yWHRvhjCFAAnTc6DQrfgBN219XyOLlk5xxI+H1ugIodYVQ2Dwg9jIaMcZuOOD8KMEccupkuqTUo7 +LtRSQd1w+qK3OxyowOfpAQ/EaYCgEdD0gle3YHr0onWTvCYD66Hsj2GTElQk4CvjySmCX3765D6t +vT0+t/4q2OpufVGqanxu259VOQBqnLz17GwutqbMebZv9JaZ/8+TTnFUIZx1hsI9LtBkUQTfbGiV +rwaDfYVJS7HA8zYvgfiYSOYN/wkHyw6D0y/EKdJW2Svkl9y1pt7fgXX3DiOEqEoAE7Px39bfraVX +2u4Nl0A8c8P8wPk83zfNN1flAOjk5iTT2JcVclvZwhmwZxPLht+0qFKBcEMY4Yrvz+kjkai8Id5C +OFlDmjNeduPG520XoCFgVYMj3QBPONFHAUO7yRE7u5/erLSOMXqPob+hd0CensnjrMQHOykFAUUL +SQ5Gz0+IIzQnCuxHNskaPR8+cTPPS6eMCgIWEVvRrVPR3K4NdS6P52LPqSinK3uFZ2HHN1HgSNxG +A5wXx8KJnpHUu2vGBV3LBg4+CNAVNxZ5bmsLG6HAUEgkMPbwhTkBJQJQQvHaMnLgx1P3825D2Trn +lVlmrpeMm98QocrjK5vLucK8EJ54K1qJqU5o9/1Tr7aXYLl2zzwx2OZ5lRrthlO0kWTV1H/Y/bKR +O1KYsMb6B93LGrObM0IHKTcRAuuOAOqnLeWzH3/2PXHNRO0jOulPR4roSptuNoZTKDQk1t+LjGyI +HFINTb+p1pA1q3BYwtecOWxdADUSiZJzR+Efc3KppVJVsLyCgv+PjHnt8o1PRHx9qWHEqHf02Pkg +GfkjVZKOt3efflc3eJXjohY1BgOcd1rWT/VaJw/r1jizDG+pXguLPvmK7Bt3h6jSJOcjgudK46iR +v3mR9oiuR8jaOguXCy1UKbIsCHyzoS2fIkI5JI8bHQyXyy5TTk/a0kehiRFhogW29GT36El2ml46 +xeSZWel3t2frpFzU7qSVNOh+AarTYbFAfyTS3EFkOdBuzsX2c7qdSaWjyUxKdb3qsToLUK+ZbL4X +nmL4GFWW4K807ntgMe37fkqKsObjvyx+QUJE8ro3bitOf7uZrc/m0/zOc0PDFEr6chDcGnfDhgP7 +nmSdYP7j1gZLzDWsmL5BjQJqOmCwS7O7ybqmXCvs0UmJ3qo9jZNq9EWP3MMpWHx/vMfRTZZSqqmP +rTizn3z01O9QfYn5SnkpWNQdX/oWN6uBY7YYfKewH3xs/IknJFk+99Fy6jRZ1u2Op1AFCeWEli/z +ABye87k1e6+gW9i8UN+dDZfe3O4647AShju7uIOfC1o7r6Lf37kw2HE/zufugeRKTK3pMYpBCgLk +uZG23/l+nb9z98IpQUW19PnP2k+eSd+CgoBrL0RlRrCmx2izD8aKtv9lLP7yvo6L8lrcmAQbA4O6 +D9PrONPUxYkBn2vVa4/+GfK5WHCPgsAf0kYiyCccsn52vHb4zY28IZqhev71mrDDflkUIBJ8cDgN +wBPlBuwkAOi+K4bVi+1viQU2i4brsFBBaP5XCoUfCMY5AYlCAVg0jKC1s9sHmN1nfbWJK+D0VrZL +rR+EkllSoDgiA6xHzuhAb/yjR0m/PWi/a2BjUPzVr+t3HzeR8q+1WJUGfSVk5c0uru1rdGO915N+ +DDtzG27p+kyHKXg1AQAT9OrtnsjRR/lMN+waWBwV1w2UYLEUDL4/Laj4Ew3cIydCpG4ymASfLK8o +yw2NsvHLVqiiwhEzSdasEWBgrz3zlSZN7XTykN7b0tEJCqUS3ycQ1MfcvICINCHHyUHp9GLVjPEW +/pcORad+HkpOT7vIRMniI72kEsugyVvFa3z4kYyx5G7JHmajd2aGtEeHV4KuMMLEJthQo2mCEnVN +jXmNtoEXgg//fvL+s0cjBUOWWvpAXd+t+VS1s/OHpsDfi0Hse97a21Ncj8bpKC6egYSHQuguBE5R +A6GbUQ8+fTlVYavvcsTTm/+d2NhKGmhiBJixQFKnK84yxQKtTXzB4idAryvCRCld0CuFd3/6qv7Z +0lk8LvdEfGS02f8gCbQDy8SM3z4/mqz5XpDukZgMhyHSJ+O/iCCkvwMipGalpfJqlfcr3RwuMG26 +zWz4idbwv4ggbR1d2iXzvwa3HkTlTn//EL7n3O19FRSqNKQAcFiTsm0mU6+pOR1I+f18ovKE0aFj +Ze6lJRTaCHUxS0/VoaXL4LktV3OZc8DaE+dyJlmZrjz+z3IAAVumstcHStnbDXt4MArmV4QhmVr+ +0wsGG0z6gh1JMFi4F2HCns6uvdnlPzQkdUtI3s5vv7O6Y0rIf5FGEEKsZuLqie+SsQa5d66gq5kh +T88/YTBTBq59/+34fxcHSGBbeM/yR/aLWJtqrPWAxonH7g79B/+LBH8gKxXMEKP4jpu+bf2U9/r1 +y+1mEr9EnAPv5LG+oXCbrCKSQt61YLOFhNZ3W2/RrB9vS27e/FZCg8KIwMkjkyUXoKKgBqDe+7M0 +kf23u7/M370ZNPZQN5yHxx0KReBsSXzOzeOHR9YpfmzoHvws1LUj+6cXPYJC5XIDO6FjUc4ocHGT +0l9MfXQjztAmpnvzqY4dFTaLR+pWIoAbD+MO8yAzTxJv8HMn2x7j59sTGpaxVyEmxE7v1yoYuXdb +zT7c/VJgT63Vu6rsWvn3W++KPllLgcJxRjpgowPeVlcYwpNQbJHR3+t9RrzEM/ZxRc1UQcZb61lk +7lOwKCQKjX8mpDoj748fuWXS43Wxu1voh/Jo6cT+nZ35KzkEkuwmza24wxIn2u7v7K0slAuu2BJ9 +zyGBEsCt+Z5wGN7jf82nZ13Hgi1cUEu1zhIh1eufVpdGSRC6orqChXQq3G0mp6Mx40+sdTcYePcG +LcR68EIgKA9iSRoAMpQuMVCRSJBZY6ToPGXiZV/QWENhSyK8yXZMoB6xE8LFBQ5+MRdHqYPcG46l +HCmoUMqXZfrR1ze/biV+HEOmp0qFWSTJ5NeL3kaeiKcVfp2jfTr5JQUA1EcBrVHiCUbQnHvZcsV9 +75Q7/RMtgbRb2RcsU74MQJJLSPHinuabbj923acrSdp+rdT6mNrtLSsR3AYt54XAeAEdAgAmMDiY +R+jVouzc9Jqb8f6Zc3MPNnVCMKuY5+gFC697f8NEqkalb6mPyhjItfNSjA6Ckob70Q/vAGEfWpv0 +xmWPGTJzsiiCUT0C5ulFMUIIaaSE123OIOzP293jkiYwyFgrfGD07mv0+ZUE0WFI8KMB2O3ep1/Y +nwgcvZEsZBjG8ER67G+fDAUGFhPA3SMAnP2TsNm2179Z/VWuD/2T9iSFD7xh0ADhxiw8/AsNTVra +1ub5XWbt3HvQfOe3XkgAXygdA7RoxpBqErld9fA06dFF0b4+vPC8J5mnNXh5KQ+ARsKxSwYtEH5B +kyp3i+y5PIKVC5H0mcroD4pKsaxhv+UJhRMimh5wuDfuBfoRvUHNs9sYk0Ytu3avF2sqvyR41oY7 +Y+K/4AC7v/ZAqMiBT9dcihXE+C/ZNRnPqBRTsCiiyxps+QtOQaO0B/1NB5oTaR717neqPuBYKxDd +CsGhMTDiK+EtuJ3LIFslwo76eOjnJmlBm7TEQQgCZ3X5KYGj6/sTN45JPxeJGz1uA6eGMKi3+T8v +UwHA66tyBhdDtj5dSNn//hf9BGJbz4taimUc5YzxXhbyWpvDwhT3iuGO+rtdHVsqX7+qvifqRgG5 +ggFCMMsbeA5A60UwI5KsiOzLEde5AqFHNhIOX/K2HTUN42XIpZg/pHzoJZdNVBv/6acDsb98ijTq +1LovLbyD74mlwAjt/5xQKKBIID4OAMBxLGqTFfW6RlxmVbLnp9d69p8/7kgBA8EC4BSAHNaX2Bzt +yUTQ4ano/buKPfr7M8Qn+OrZpHRXckBZSG93NAyfwqaH7hJNf8R8beHa+x0CXacSr+VwlFMShLKH +f2Ji0rF2w9f7F5/Qi16MpmErbNakuBgORKzI9nvyGMpGE8UX11U9pt3MZQYw3CZNb3flaP9TAGn6 +g6ZYw342bVTG9VE9+7J9g0UsRdtbkil8nStFgC7HvewjxhdmnHKfJSXbt9Fd/5WuTOFYxa0YYMM+ +FBoRBBr6JI3Acu5FoYdt+29WZbPHdYd9hgU37qMI2XljPPBhO9IRdZJmsCxWWP8lU11xZqEsUMFj +IXOW7rjsd1kK5w8gyxmBdvbFe5PfvNGwVKGFa9x7cJancI/VhbFvFSehkKW9BiF2cE6Q7zxi65oK +m5puCZFopI/VSgJfc8BFzlJfz0T/sL4JGCQjqVt1N7a6XVvgY7w+XP6O+bh1R+nzxSBKCeCBJ/Lw +r8fTcKXf39aVjTfkWLaG7Wt7/vV7ByWGhSEIDwUsPUMKj8B9bhXlWwub8R9q1FCU099Owxq+lZIG +1FDA20goZ06ac/z+9J0bijMEU5F3X/5hR6IMe4dNKGiglzK5bgtaIkE3ee/QZ31JQ+kJFLgZYu+f +4DFYCS53O+I7nS/VejNiqbr0YODxoehD3rW+lUE20/0XKSJQBAlkrf8eljqfk60LkphSivglH+ZQ +vkNe7xg0BfQaIXu9AfWZaCvab9cuTZ0R9DOr528U0KJQFYnRY5g3kHi91G4InMnPlbcO0k6yftbY +eO4A80OM1tNFNmo8fmcDRvHS54c8tZn0zH8jP3Fb1o7rWsodKe61FIY8gQcUXEK3aoK+DHRmJIQW +SBPsikJK2uS9IruDkWzttO7bft0QfveGisClEIZehhLXeoWjV87QJPoovXflPG2dTOFSIzxtfMl6 +ABr5+kgpbLYg1MgPnph+mqHJ4JU9xSAhQkTP7VKdZ+ThfZzBoQ/zfE3WdYykFx38cKhqFyWNJcwj +Mtv7cXob5+Jg97SPZlzY0cvyM5Jv1E1XAQEk7Hp66SeOlz8elzvyJfUHWPtp+VD4J8nLgKw02mDe +QAsVcI8gTVVAbkfWk77WrX0+8lcWbkonlv0W4Tp26n+SC3ZaXDpNz57FKDwarKRUIrInRbKsfM6R +5wuF8341eaQjflP+wutHD+zcFbgtka+vWpCt7fAuipyD1QSRHraQRVqy+FFubjfm14poZLd+SUkc +7f8kCPRUADssGoEvCdHoHzf67oxDs9Nx28vslpseYbQOUQQLVpPohQgA2uQSW6duF/kWW6mn86s0 +O/llvZ9PTIbo1Nz/Ig6nZuJWbjiQkUrmY8qHn+u+v/lKY3d86qY/cb5tAlHdFNvEf5RKcvZsvvNM +kbn5naDMmow4K/uHDgwR9yv+F5k4kSiwzAxO1mdUSps7ki6T7kkKZ72OKaKyWp/CJFxdFvCvFOMZ +c/Zto5drmPP6haHIM4l1ArFzOwqgxJJrIvUTk80XpieP87OyMusfvq91lFNTA4rBINxgnvizGoPl +5xNmsnT763V9xFx67T+WP7mJpECQCLIwT4r1o93z+jSLPZn3LP5wv8X+pfOgyAoCCIo8nyT3tWtt +HykihFiseHyEEnXCGk3lqINEz7GxpuOZ8k0TSccEduT3y/OETw3KU2hXGDD9hqCeEKfLrZrazCTv +/QYYKy6aHwL6ibYO9yj848Qe12B+gTvM0xVoQYck+7IeiZXJBlmC4fQ/1sBVMJ90xvNjf1ARAhrT +oI4uOevM9e166eM7XX2Dx8VbeQIVKQcsgSErwQFqWUTlGfCjEF6qO8pl78TV7W5ZyY7xjae23GCT +Pk7hcieIIw4xMid/zPwlkYie0RBp9rJyiaYRITcpc4o0MRJNOrmIEjLWiXxs1iFbcEErwp3pKObI +oS9UKCo7Iek1VJvub71VFqPdyU3jIeh3YA/2ubYzhSgsDI11Bmo2ooBmJssD3G5RUtHnrEt3/Y2I +uOSmEprynlcOWsDSbgpgnddfbH8dzCHGFeFBV/O78gWNrADlYgS6TMBjk8vzxAxFHn9RsxjeeqO3 +odGJz29H9ZOj5ithIAkdfO2+xI7q38880hJ9Ucrgd9L5+xj9aF4Z11UKs4NAkfk0APIQ956erM3+ +47HFwiLvdzGa+yge/wtNghGuTb8/dsVcbHafDFhfubOFIctiXRHl1fhNnjAL8Yb34r3AOKbFzH2n +Pv0wULvW1ynGfmd1DqCC8xy4OwqUGwY3jGlqNd9qfyg2KUpBeWLAp4iBu+FHIPh5rT8LZVLn2zZd +q5J9nvughDctRJgiIWIlCXDtV9ryX88InJYbHFm4Ajulv8crjyIFCTxECvZvhrKL+jYcPsF1fmOw +TgtDhEvSQc79jtvnISUA4SNSzBafkIHyR8q5gTv3szuyyOdDJTDWG9xetKLin5KnmA6slAJWc8Q3 +nEfD4SvS5MzPOLxQjhs9wxZk0fR3V5jTtwtOFNEk/KFdUgQT37GNrIX8I6FuqSfnD9Eha+n+OORG +bFhjQBl0XimDmIDwI/GHlhDNG+xjhoJjGzSuWTLdFnz2L3bJ8PiqYBtgT6+ftMtPXcmEyVRVchx9 +5h80qEw2u4+5Tq8d1M4IK7hNF7b4sCSRCgZmwcC9vIgtcgwSNHKwzxLaEenOr6VnS6OfdglSaJMr +Cm2ciwljYa7LP8YXt23T9Ldb56/O9FEYZmAuL/5YHz5j7IdZ8Z/4sWNuL0QUutc10GPzPxguO5eN +BepCgaFPUjBSPaI85MfTqH0D67ml0gxc4nedbPSBRMAg6YnQvybrE2m2i4U7WR+2LBOee/wL4mJ8 +T0BCXnI6vdF4SdmkuOSc/nBWEg8m+2+dB3XGG0EMXpA7dXxy6qUu6Tka5rJ9L9QUrb9ac/AZ7Woy +wM9dLHp8wTjrj2PlnT1MV22r1ewbuqgz4IlVdxTKAyPnEojbofEa7um9ztI+qoL8To7rmRuTTm7+ +Ipsv8p9k4L8D6M9cm82uufHKfccAgdZxhhgvNosS3f8iAvQrtc6+fnzrmpVTgKmzc1Iyn9jGDFaq +LNDPkLCxcnDDjBKZ7C3+0LBa/2kvUc3s2G1OncNZ2EBdTTDDl6WzUpWmI7WPI/dTz3rN3QenbQJr +qJLAmuSGQgfKERv/adgYb5GO6FXBzurSXR8s1+fL3Z5Gncbt4yh82gTWLjfENtFT1pSvLwQjLWD/ +4ESjIVWO8HqICQv4J41ZNlyctXn+HH1nPvnQ/OBLr61KAw8182/8R3kAXg6fYZ+wZCm1Fr1meF3m +Tn3jNaEWqjhuZiDQKCTxDDIXZ/DDxN47efzuj1KY0n4q2m9Jc6XKgj3mvWFYIFwPwE33ZeWNKpy/ +J2msLeDS855VyLeqog5jlqpihcewOxyK9ra2TVJMmOHsdoUJj1B/8K4YUhHDvJxbG2rgynKjM0UH +Bzou5FbfSEdR5fCBRsIrxz8tFzKzUoGn5ENPVIeHjZ9twosuvpc37T5+pioLMArAGFrOg4vZDzCe +L9fNj98vvP1jRsN2lCrkBcfCiFUQd0ciYrecLDb9euy2sOoBV8amZy1nqIKAzx3mBAxyZ/JtoHnQ +yk3vjU3DgJFEyO4HR7TPXV6gvqog8cz1fHU+pnXnJic/lQ5ISKuqTjWIe1JnCGWMLTn5a/rpUTWK +F+Gl77uMPnnDT+pRhYin3ognSeZOV3wJHnHdMmTN0rMl309xVv7Xu9Vg0sm1S8NVc10+a49deJKW +Xrfmy5GuBU52qiDere6NwgdiLdpy7BxVsoZyrF5fTb/WgvrctiKPiRz1Ayur/ESbfOjfWz0VkO1R +/lxF5tcvP04l6gi+4vxR2Yl2/XvmBywP2s7OcybYdJYpUkUIuwJxDBDORxFMqXLkevpb+he1n4r3 +/9jbxWVhW5k++18lgfPHeBeiYasgzFbu1q08u5h3/Fyvv0PwuDeC3ziXEoff7LobdvGFkijN4K0a +mR4Vz/ghTnpoErzPEc5Xs/k1cnHzLGc91i8kVq+dn6O8GmcpIJCAJk22jXwLzoqLDc4ugfX3f9vW +PVSSoeNA8UbAyspAIhUMf5RQ/phuMcOJx4ipd3JqOXSsjPlW4sstYKA8De7b+MPQLqRtkzko21il +TlclYN0cAi1xu2CyN957JYTB4nYaYrGLmos2e73oPtG885nxa+fGWtQmPBuDBojKW0biRiUGuvCj +ERvSa3pGzzDcemJXsYLAa85EHSV9t7DtlElDluzF7O/tPNrHD2z9u7zsQhB5jBJpzD14hze0nCWG +c8xIEJnEcGDLsjWF8pwbwbVNSNECHUlgYXsUcsXfAOL5tj3+YZp6bH6Be+R8eFcUE/fcdOf/Szwg +jJ71Xbzm5xP98Qyt3Ahvh5rwqVaj5cIIrZ3IpIEjnzCIEUhCrMfg5VbRY4e4BmMkv/5NnIvQjhh7 +sayzii/aEzjOcxDIYsBZoTCsP/6UzOK4t2XupkmDqKd/v0/qJioYmhWsxFxQXoD7H4ZxRiCAwsvO +hLKrGHTiS53ZBafNtk1HG8zfPJQJVdJfyQI7HO5PLIoYYR3QHbzlKSJ7MubbJ/ofjedyxFLXZlJA +KLQXbMmSRCAJTffuaEi+1unhsqMRGjayRfhLfY86cJIKu/QNyzNjb1Ur7RuSiESx7JmcYNv2bPo+ +NARcHa3BwPLyuoVnU5QWSpHDzOD0yyNdK68m3he4ewN/AXy3pbv8dfJnaMfEz6nsNcLeHb1ys6EO +D/ZRiMAQJC2VZGGlT3bo2NLl+PG8nq7jlGSuQP3W6pUYmINCdrczfhu5s9ahB1V1Fs9aV2w+qvHI +dD00Q/Esm4wbktrDH2UeiGKy4uP/+mZEvvsnNOrjS3AHXnnAHVkhruPuMSczxKWzLrhuZm0GJYJ1 +x6IIbx2AaJtDZDBevl92zEna7tnz2m1oQvDrSggN94QRz6pKmH9VNxcLz3+ZC3/PESCWcafJY4Dy +eiANBV8UhfAxXZ9Cq94xmsjL/e1lHaAZoNsSynh4JQaOQzIHUp2h6vjX+xzHYTU2weqHut6wtU/P +r2DIdLOkKsXfJSGI9pag0tJA+9rf77ReLDtNDVQYk8M4oxHe+DJrxr/v19tu1vCq7dz14uzEhadP +7tkLL78e4UkKPRICJEUh5XILXeWS267XCXzLs4YdKpMXoGRQSD8g+I1vjgsc9gX3JXBWArXBDwte +3Hz0U1Z23mit0po+w/HeZ8t7H4FCXOCA8xh/4ptQxoIwq0+5V0TzvHh7Qeyns6P2kC03/Ybr16nj +ACGw397PaZde321kau0ORhaDt27h+ygIsNIAPAA4xw+oyrgbJyup4HFc/yvdg7OHXa7lZb9mO60j ++Fezn0ICkFyGe1wYBMH1jRudcHBBxRKLHTfsf6nJfJyJ6+ffyKNvLE4XfrtY/pZCDKG9OfiOeKQK +MaZ03QM77uTGzR/uWGPwx2IQAsB4g4c84MBYwBCSaoG9lng0PfXCe7mSX0VpaI1Lzx/7+dBVlTx9 +SFWMJ3BUH+2LJH73TSHoJy7O/MgIowbJ4feqLvQOh4qpwst6MYvquP48naIg5W/z9fFLOu6r0xlT +DVRJnGIYAI4x+v1Wpk7bEGXvXH9f5nFHXvnInt1LlULD3XDvDMB4fRs4mmy1OFKxQ3MijRuPwtcf +qoXAltYziUFjGbtRZumX5/xfeFt7jJQZPeihBDB74XBvSywa4YzV9/HFk/ox3PsKslsff9F5V22q +XXODQ6j/CAWJX5sIbonQ2xivltObGCQVbrWUtKC+WIq/2EBJ4EYeCu0CnLPzQiE94IHeQNIW4S2U +S0pzckqiw9ZOHccoXx4x5uNSfwEhAV8OIFDO2ReDRXnhXwc46bQmj8WdOOiYsMGCNxPNy5TjxuQe +SJ0HPnGrukb7TMxVHf0Z5+sqsDfscqbPFygIgiboD9ypCwq80xP6HwQ0CvdGHn2iou7poQD7M/M1 +kpLzxD1W4GqVeDNk5m9u0e2XYgUWhIZ2wz8ES1NeDbSk9cMSTk8BpT9xdhIhqHmDtuas34s7aLSC +6QfmoOeD1WUD7RACAoGqE/jDBhr3Bb4K7q7XfiT3GyHjvd2qa7/3PQoCjMmTFTLT2pFRrc4Isxo0 +vNCTm6t7P/xARB8lBITj8L1IwHs77loWNatq3NrXghzqrT2sKHWINg4aAq72tWCmQ218+2dOfd0l ++oQfLA7yP3esvBrU6FNjjtYht7XZu24Mu9nGgnjsE7WsQrivH+CkI/SVPc7oa16s4R9nsEPlFsPf +KqzCcyk7youR4LEGwWvjnr5X33G/mpSenj/zunWu125ZOM1PFbcIe3qCa40zMFhABQNc3PG1BXDP +GV+U48AvbdptTszIpG74/NEvtpfRN48e/rckX2Lc5cDaCMMfKe66yvK7syvtROrUd/BI/hMHQO+8 +a+91JzICGnavSfiScKk0WvZM7wrQBY4BzyogguBkvoFI8UbufPGuvi2zNCFtLVHSwT9VpVeAQB62 +HGB/ygGhCnxfKIeADzRIpp2dqqaWJQzYuMqHd+1DoDDgHS9lY414Mj9OFqtJTTBb634ubSDscFcQ +cgWFW8vd4TBvDBL3nztQUI1YHXlhsTPoGm1WcGDx+pA3Dju5Xv3p9V7JeqKcgHoR4HYAvtf7Z2Nh +2Q//MMm+EzsYl3rlAILVbwWz9EyI5RqTzBvT3w7txuRm7LzfLcpzRpUmQmIlBIR+fHFmEPEuCRZa +JebsBiuOCpMoNKtlyNhCl8TAOR9KFD9F7EdeFRTx96+dnppq3ndBxHhG4mYHxbVgVUEEkBYHByum +ygHtF3HvEbdNE6OFT5DjCsLvEZYdJ0vltnhL5naIRK5dIYd42hqLz6f/al2y/Y7XQf3CN6Wn+4af +Gu+oMl6mLfp5EXbSJYcHfjGvLox9s8bzXaXYlqObz0btjnhlim1dCXojCDYVhrAtk6V8oEZkT130 +CqpLr7rLMyqq/mZeZt5gJY/FfWcnX7wiAVYIDwRLxQD2Hk6sEwrMRFXU6Nhs8N6xRRWmeDjOR9/b +dPQSaoUgUipE4/yw2JWznrfcnzPZ+sS8P+PdsVVhxbVgRosLqY2HWoFW/Z13Vplrd6F+H3q48+JP +gTmflQRudXTDZ0rHFQVj+QXd7USOXxJSvHtpRDqGPZ7ianymE96HjNdEATQqYePwiaKB3GRWbTcO +uPpDQS/aHiqoC+5P4i+Ebaogs9iPITAVuy+RxczyJ9PbT1dqnlKhSY8St1YBLgXCamPZcoHbLfvG +RmPOCLWWxF0b9/XE8UJLAK6+d2zXeS1nmWl9r4tMbWdZ8oKFVWArr0bDwZqDQKcxXySYBbfEK+4v +tbDW69lxze/xNo881kWL0xnl0DzpeREOSYGDR23O7sDX48MHHHPMaFgGzrY2NhWb/QPHxzlfeAfW +emqiMy53lpfRi8inBOwPkVsdBPMFPcEy20A1ckKNvlM3JE4/fxHVqq4ojrHmfVKx/6hQMaQc/HAi +jqYnplLpV5wPKV7b9x7++HJe1rC49UcKDIXBkD+q2/19SnnvDfQtXd6cSdGnnw65tmV6BQN62kjv +lbx0LE1C0Ajnt667g2fnIn6MVzVxd9WkrISBUlSE0nCgAFBX3n/t3h8zufFzJhH0mz05Pb1US86v +4IgFmwD9APd8SGuQH9K+5vz6z4+O2Ruovk+GxzA9trxIDUXDwe7tCCL7V6h3+KzogbhbWmxdz290 +qlyZYhpawRL0e3AQSoyPu2grWQzv6DnyaL5so12H4covR9gFYBjADCM6/7WKDNaZSOvRpngwRtln +31CXuU+38i0QOKAGB8LNFw3RpWCv5JjB52Gv5IarzX3wQ2Mtr7IQK2fckhDgXfqC1YsIbeb4x/Z3 +WwnYHE8dNPzYs6g2UMx15wE0jW9vv+zlrEsznY2uXeOt7i5ovYl2NFAq1ukvNAzEAlD+4KPts2dJ +4rsHl5nkH0gZUHY96fWbdeVrIUDkpVLOPQyKFzy1G02rpC+azYQuLK4otYSmgBpYVBo6TLywyxpX +W5+iult3J0uZTcddTuFwaCGkMQxH+not1QXmXncPIavRyh9g2XdR4/qz60xTCs3/EADaOIArjrBi +ZOxc11cpFFcifF770fzva248/ZZU3jlJBHjkiXjegyXCRC+vKfyx3fOIfLcRy8VHmYf3Q/NLGkcV +45ZN/LR97cLXtoe0nlhUT+G49HwFg1PicVZOoBwm0MsJha/OemTnmoPe+yY2iZj63lSJ/1h9/i5i +wwoKgXSBA4lvyx/zjomYNeuET8vTd6ZKWrCIXmyk9eWkAEGrGu7isBxlEWKo7WdWP9Fa1LJGzrKC +hsWq68lKdNmitKYn6IjXQ+du2JR96H3uPQZhaz2sVwCAZxbvSSWZwseN8s+0mdkHm0qZFbQ89nNk +eXDi8ArKCw7DAHm1XnAvIH7lCQsCx+GzbAu2+ecxzBosbjMn3+yNvcAmRrc6ic9vJ7vlZ/QvnSct +X1333vPN8OqIJIuY8xHmVUUAkPQ1x1tI20/PGE7JJBX1sV2lORzgvhJCAXULCTkYcKD1FsHhcufV +5xls2PljmzexWPaa2fJ5VRSu3KQILEk/QVSHBAtueUUz8Hr6z6XavhMfXmWxQyMr1JSFqXMXeOM0 +GAO2d8rvscq2WnfG1xQaJMZREV5g6gkhEgXIcDZS4qxXiTg7knl47+COM+sCLovM/RcZAJtPw/XT +zWPjxb9MN0eUQl03yZYyrlwnVrDLfCThCcEdMSP3zvotJHx4tj0h0l+DFwONLymQJs3jvWmnT0g5 +536f+cX2rWpeP5ViMBEYwkuRw6B8cWsC3qrF/xsgyEniQ4fG3uSW5y6o1jUpw/LCOh45/xIUiMRZ +Jlh33Pcg/NOyPPC7J7bHb3/2zY3ZP+foRJ3WiW3Dy3uN/xeJoMnS9OxudSh/zBqztp59Uc9EDmrO +9/9DDlD2gfQrQbXboe72Yb2yTP8Qc/BwwUdeWLobRwK0GHcYBtRL3dAwbzAO0OD2Lk5b/gSP1YYv +W40cBL9umKv2p4rizF5PuB/cE+YPw8fRXoaWmzT3xkVZG1okqfgdq1hvUoaEpgmjEQj2AaDZjYh8 +BiavYnRdqIriBVuNqnDjleolEUTi1hgklliM+NPxgLwpvdZxO4NdfWvY/obl3l7euX4JBOr7ymFw +6y8wi+De+CKixgViu3W9Xkyk+PLknRPQqCxyQVOnAaL0cYmqXY6F8j4jP62fnS09TwvPrdxVyQj8 +j4QcWwxJtQQETafK/7z+RTYw7MhuaaUO3WM618ZZ/rMgF4IbqUb96Hx/Effav68jpT4IlXBXCuWw +QgtBw8lXqlEDNXbWGbO0fW1cWNqtXVvO9a1Zqe2ROJwSjAa7TcI8vUCf2jrH6RJLoUSYx87R9ph2 +udain9bZ0DBhjOOXukrp1G+Dsn83WMVeuF4xu3BSzFv2yAoMCfcnGEjk6/gwLa99SnRWrLJo9olB +1MfADL7T96iDwI9k8EMRodOdMbXJlaViY+kOF/zh2H5h6jDgOSanFR5sHW698RK5YfDSc9cvJo1R +Sns1V9KolSss+ek5lUeWbVHVI/59sVZTUtUFaNojbOYUAvD9APAVt86hN547x/EiD8Wqb/Be28ap +6ShtywqAmLG7VJsQAIXWzHyJK783qrLIed3vfp1Zp+S2leYcTjEkHv8ySDjH41Gu7nwG2y9UfUQl +MHJicqWVi7uaqBnh/ak4bNKPz8LaErWw1u+vbrRdcQrn34hb1DEyHeePXomjkVF9yrBBd6Fxv4u9 +uTYr3woQ7znGF4zCqZbQVU9dnj7sNatNQTmaVTr88rvjRXPYyXulHMBFgvYj8yEAINO+ebPA096S +Pl5Xiuutvj2XFDn6mgIk6IF4DRy9pFISPjzjSOdiO93QFqOXh5Hq10JUkEhYPTUZlG6LTPj2Y43N +6jxjNds/xyZwPla7NQBxBwEEBU3bAUPvX6ZgdJJzjFkgSr0FWfTLD+LqQOLBdzm9gwCWsMbX7719 +KNunpv6942ab3K3vGuquwAi2+Yp5Uj0zO5PwNu0Zh6UrTzPWO4XhooPLCpAwRyj1nkdOGUYBiz0W +Jj+U1HI0jr6P3Ou/UjckzS+giizu07GopbPBW8dyDwYW7WESnKV5Yc73hdmg+03nShyOXaam40Mm +8koJ5U6Jwcoxfvel6NT+VivuHleDBrH4ju7AG8Er7cQQUeQl0b+RTb890nae+b/SzjwQqu/949Ei +e4UQhVAi+5KIpEKSnVKUwWAwYx1rZcu+byUq+x4S0kIfskabiBSRFmTLmq185947Y8kd9Pv9k6X7 +ept77znPec45z/Mc86n4oS1H33if/lsCWutfOGobHzQA9qJvvVQOQpz6Q8FaTqVNPnK8ldq3YWng +YtNRvkznmM2U6QZlYqdrgyivS9QE/H0x5K6gETb8+P3Tvf9V66h/1fXjDjYZ96iyb+Wdz/7bpQTW +FHHGh3BH45cpDag3W3hLNFjlPPrj7+R24xTpCgKwNvg5Mrh+7KV07dk05kvPRiq5cx2BPr8Tfh+C +ZwhHuxbcFzU9kxP/dtOUkkqO4aVXquw9f/vWS3r/t9S+Ht1G+x30RxBBXJ5D0QEvBtVXXI1xQDiv +LD5TlTCZVxB5seM/llOiz+Np9mqwSbCthto7mOC+AS2piH5vzu1dOz9VSOdPH6rfolhXP/0XuZCX +Zm+MsCEcK4GEQsk/yr0ZZn2h2K8w4b5DeqBoNNB1uGB9+KI7d5oEleF8u6jJMkSh8OnN2+YmHDV/ +T9BW10D/f0SATyCRYUiSLxZoQZfFLPbyZSrzNraO8/AwcLU8es+WSB36+3bx23tPo5g+5RbL/D0r +BPdugEnaX3PRIKqkAieOq4KsiKv6bnPijpzKocuCe4Bd5cXyb9Amjbcrxp8yvcW5eHf88UbhmFP3 +HMI9VzBAPDVwlgy47gTtbuPN8YZX+8KzdB0r5z9+zqA8v3e7wraie7A4/pSsZbDW3B6UN+1N/3yv +/XsFbNgPvWZ9M7Qctoe8nRmXA8cSP+7VSAoYbXA9yhIQJLs8hA3cAwT7Bb8lUKkav/1PqDcESFSL +iHg/DSpOj+8P/BRp8k31UdDIrnVI4CMAQInuMb4s5+5tdDUUZdz18XO76XZwOK9DYiH1DtCoP1Xk +TxuewqYfUXHblJf02LxAz7LS2U5IhCW+Vne9g092eipVhHXTnzpyw76aybHB9OWXGkFlwfgRQNK/ +CRL8CffVAZqlLu4wCaNtMG4uSuHMJL6DHFpJQiqiuTbwSksyk8AW5bwXOfgs2jcAtSuozjUOZdnw +PPIwERL8ApT8MAZPRYKO+8InFHt/Li9L2Rqg2UzfZd9gcUqC+s2ntVTMwUIo/PZW1tBmjQvvLr2q +6v6kIi26LxbVBuXnrlRpraWBcwuBtI4lRvDEl2MyjPXSbxsFUkgPKxsectwft3EtFXwQNYDrX0+3 +No4gz/qd9q1B7/xPzNZwuofwOHCegyPSCMiJQtiZWWNAc9ZdhMxhtxzQCZD3usVyLYp7i8IJnTVx +Y1NoER172XM/t4TRD4FoihjninG17sDsnDVhQj09y9qsnGuoYwlU7j6qMgJRcszVPTNrwuaWJmBD +fLv5CpuzgHv/VGVWhqBTv/AOCf/WtWCAUw/g65GjUSbdOHAlhsK6yOiFuFL9ahzYePB3W51WMKYR +NlxrZq2rbFXkkRlYVvBgLZZws4jkaw1hIT+S1dTLflkOxAXVFbVuWIMFMJGaLNnZUtULqudnUlTL +vpwJwbTJEsFQZkgoS02Z533IS7vKF0zNR5TF7iju5z56uwGeQeJcacAAAv+irfgtobJYYz7UL39y +Kwg9cr1NH8KTR7Vj5wZNojy+e0NfEZDJb81oTz+nsvPL3bYjSumUfp4koUkD6xMwNseZCYSIEL+N +tZWLsKiQOCBnd/QtJs0m6GZuoBe1u2Wc9Pz+r/rrk7OzB9cQXryt0tUgf+6Alst+MbkpjEJD3HTP +ugRAP6Ne01ewK9pt5+MNspqvy4/u+/zxHBEYrAC4MNnDNxr6cewco8uTWym5tYEF5r/jOakyrqyH +R0IZ2wxu83yoFm/G/ovRwpiaVkGU2q/10Li3aQLdPHuzuc1XoZHf3wWuGspqu+VslOzZv04FfHtI +KSj84yQUrkye8f2pkeWeUSW1b2rrUcA/ff+tc08t2Vo/7igtkxHH+tKiVKln14EDqFWYRLrAi8Jr +H/i5Q5pqGEiZW/kPwaNmSAdNnPttjdbFzT7wU9LZ77vYBX5I1fSg95+6/CWXh4E0Hx4mREHhDTsw +JEbpt4o8bhCKqq5/dNaXP4S3decRBDyM66hmuDHBEo0AX5gQYuSWl/VEAzWVnk5qrcFNMclpcngQ +f8Y9OCFcyAupVHej2ibucesB7eTxvceVuk9Zs7vA43bg7QJMoUAxdYwU0xGjsRnxpNZXex1OZREZ +D8GMVqi8A2CYoPfT70w/nKYba+lRp8SLHjKaLn53ymcduAke3/1bpsMxPdGK5b/68ogCvrwLGtji +tXFz/OO6K3lspjXuYVga474vKeRPtHOU8inXpgkPe4OHojGZ1n22ICWL6NTOK2aR5ZdI1qYX+0bB +HmRuT4TPqEsaveCv2X21nEwzTWvyAMjCJ8cg6P+2JcuuQO5BdOGFLsH5EHiQEKR0w/jurG1XrO7r +2UZ2N1nJnGPFNb3wBOiUYjEEX/hDz58N5ttd6H0fbnMlaSA/bob5HfcXuJggo7zpCvv3qKmm3leV +hhqDoYJOV2mU/74YcrUJufqEyEFwz+G5Yn9NW7gbXeXU1nMN4xsVaMoE4OmFg1qBAjHgthEV6ngt +t650e/nLHtqgrPkSlsi/bTQexUev4INOYinYleNJN+1qMj9+IFN08JR0Me8oLGcPWzHcpClwxFxW +zojGsjHeJjctV4eGVYIYboKwAcNBwWiLv3I3HcLMOZFDUTnBqdfObU49NCrPxHNwLZ2FLU78gcHQ +HB2KLzV4dNXB3mRn3+bix7KnprqxzLPXicgBp2njk/Wf11xqUOz4ZEyfejSBhYzJbKpVMmoVCp/c +C5byNTbHYqAMROXglNdTye7Ox7EKY6VqnB/qU5lL1iOy9B4AHdFNmd/VhLEGE2Zv9N9jf16S0TiZ +R0QHiApcVMKfLYBztVGEgkyyczfOhsr/kvv5eaeglp4plaMQayAxLayNFdIZbFa43xKOoV9Mqli2 +uaJldj/xDpv8y3vJP+9Q/uB/c68yj5OI7tKityVlj0VuldY5W1iYt1e03jtvLB4aTgQjnFALYKn/ +nU24tL1Va6aYPEyCw/vlw2eo5U8WzGBY7Fj4kFMg9Anc1QNfj22xfWbndYGqH/yGR14k6z3I0+u8 +uA4RU4QDGDMAfCpCGLKc/34q2XDtk5131ZxHRqrEjMWF16EELOsRjrEFPhohmtwKYQSVONO9xfh4 +/jQmGiOn/bX9Ssep4D45yn/UBT8toOXnPEMSOnP4RqngxazY71yKccdTCv5RC2d3re2QRpCViZ4T +ZWocuWhVVcvL/Hrbh/n7kzSf/lVvebUD/cDYQ5Nh0rU1DxGoLESzl7YYtvsfFZe9lQOxJQNd8oF7 +haJtDB6GmkZxZMrR/KMe1sFUWILfHouzTWaE+lnJKbtGg6lU0RqeMfNCpDLV/ReD9FaTBQJHrZBA +aCDozQRkXza6rqJN8U6+XuO7rCpJ1LT0dTgcn9NsYoJPiCccAb+kFgiuk0N5HzdiT7flT/HwXZdp +uJDvMt9epvRO4f+kCa1IAJIK1AJfRh01la6L3vPehkI/EY9zOUFcEnp04A/gPHZPkvPRgFhB7WJJ +2SJH+yex319pEIehz7JiZcGjYMPxr0bhvOl7pLRuf5XZqS7jv4aGA64hIfH7Q9amC3cH9tAh+j85 +fU9F7jSIm0yEBss4epjHwqgRxlLw0GdojARMOr4KCBg154hCOoEfMHNyvlbr4vV8Or0Rkd5had68 +zIm5dUmC09fKsb1hoQkM6erUHs4p9mG0lD0h64KNXKyNAAGDp0p0H6smT71/8RT5he/V2EXVbYGr +COD/MtAAz/YPGp6UT/k+FMybYi11ccJik9xNGHLhOHb8czBGYIyRVvjBmpA0oi+SfCFSYdrktn7g +T+O4qVSXxLEOGC18/hy4eQRgD8J3zr5FN9Sn3n41NzRIzcjprc9CDIM6JbCXiiTkOESoF+iyXHa6 +Xy1Fv0XUY1Cz0BHtvgYOZuFBBfJjHI42mUxL9fPQeF/nrnvz9cI49sDqNLQbATaj4c7Mzu0OOy2m +PtuT3bVv0LPGiK3OmkOHAJvgHBxcG4J8O6HrVxJ+DGtveKgsEHF0hinowdnZ76urLHEMczuw8Wrj +k7xe5bZHYnjEbKem2WRWh5cUDXo5mHZngCoW+X5T1A47jo6wuEwWOEOxFF62gFyE/jRygM8zpzXC +bM857XldG2p16tV5eyTCzhg6lYJQpA1c+ik96ZQ8lxZluvkZedrzoTGul6fXaAHLhKCDOgEhD4H4 +RJZkneAcIbGElDCGfUxxf6z+QQhnNezw9/ZTI6ZU7FPbhsgrjV7Vbt2Zke5G5/5BCcgxwJ8/QkY6 +fMJ4Sw+1k43wiGqxjUhbCAnnPyiZQfOHViY/K8GQKrLtuWolnCG0R8n2x/r9mwq+hsjJy3Edatr8 +Hoqk/9V8NRkwkLpvYvwPQuYI8PFMRVOX5WeQDHc3XLepNB/fUHqL/NU/qBD2tLd6P7H0jDtWRtsh +aRLflne4DsuV/Q8y+GIymZH397mGVanSUagF2n7O6jO8IPrmX1Twaxpd96orBndMMrSo80+o+PR4 +B1C0tv+LDDh9Ak44BceYR+k/PCTDnbULShNS7mIuXWY667rrH9QcF1ZLhC5xH+jqLDC/lTm6/bPU +r97J57SF6xcCFGYGfLsYkweqeDZRCx6866Ux12GktZbCQgDvo6CJ902FUbe1UwN6r03fYzG6W7BG +JydsFOMnktrffCjCyB7dkxlnzE5NVPJ476eJJiKAdwEJ+6JxdrvcO7lqNct2CBi++979weHciCER +krBrAhZHJZQyQHw5dtDSTavG6ICDcGqE0U71TRJORHgHazAnG6By3J/fSMhn3pvu+0HxpMCzYpNe +R3EYCm7iCSz+LB9igVUckpTbIRXmPx5X/ugx2xdkIhtQifh3PcKcFqiGCqg2fNucE2NxQVQrfq76 +5/MKKbPPBnD2gIgq9DtoSgeo3YpMdQrc8Ft5cr/UVb1C4QbLk7np/6q2NKS98Jh+J1Mz7/apYfZx +u98NTtjWKjgHi4geQWnxGRqWawVS7Zm99CA/qxmpMuZ7KGPLx9X1lkx8AYER88T6a9bnjn5KHsnr +Q42wb/VOH19LANek8DvaCTG0Z435xTk6chrlM39fOtFds/Hl6vTSgotzvysmOd/UhvYknfyVIyA1 +LOWdErA6veBtEbZf0Ui0Eb4/hmeJmwtpNXPYFZ3lOkZ+Q/FJRW0TnNqyZ7hYd5Al9vLPKvq8KSuS +g4cmmxVLA225lkWCOaEwJtZOhDUdIGOOkM3c/f0sFasn85uuw9wpm97QDXoli5XDkYRaf0iEDVgz +cXED9xGTyOFksf8SOLO9dKX3bBb00sBkLFOACjGsEU+EZWrCao6evms06tV8DrEL+S1F2Q1OBSjV +il88AYp7maKg8a+s1IsROzdmwq9t9T19I8XQnKFWPAy+eAQxPgKGUHeEN1lnyCs/MHz055Op7fOV +H5P9sqRgeGMLQnUUQvhvdPj2P72Msnln7UlIRKvR7+57p2nAgUA9dPDvgsUpLCBPy+7iAVc6stO8 +yduMMLf6e7+xG5GtzUIRCUBld0BjtDfX2XqX/5uAgnk6BnL1SxyDfKzENLA2hKQwgKRpqlX0cBOi +iui99qlumjOU6bTXeTgSqkK1MNMC2QRqjBLX4NXH7RRMI6bdlY5bqXwS4Vgb7NLsyF8l4Q/6A8ZY +Qpvfeyqyz9xyCbLwIEJhCWEn6k0WqidjyLmsJ3T2HXZQuWMxjZyGY5YsGxN2ncEDJaGygvW62EZ5 +K8M4Z/nnnu6bkCFHU+htYFRMUPbg4iAwhXKiinjHmvE4vogV4y9Uluyw9Rs2Cg7BzahxFg6NwgAx +wCZYcLF1oSKE06cEJbXWt8LJmlx5W7r3PAn2neBZSwRchL6tfUSasjtcqpBs39QXlbu/tyrVwXBL +SmsR2uP8jm6zPgvWLo3MJslDvO9uu1cww7XHJQduERIEwQ4Bvt1tYSkT9DJMR/pZRAd6/Lv1XprZ +HobTsEcv9J9gyZmxEsEQ3wB+sWKafl6NwIlmBBEEjYKKA6Dxh7hS7jjZuPVlpu+TqDc06s2Mdlzp +W4Lg0YVwnp7pMtcfVoF7f4RTtSXPhT++J2wbCYcQ1ipI+i7meu9s8CRrvHgNEx+T1zdwpRDuemek +McLOzHEh4AOHbqk8YhZSWvjhKxVvvEx6ZFo7o+NpWJRQYQJYWH54xo1VLMSQb3qfx3Q8lfTVqGPd +xBh8JUTCwni3/OUr83aWmP3uWaE7+582jGhGpRNDwWLx8Nb00VTe0I2mP6nYAVE6csz1LOGuJCwx +maV5vgCbUXIfUz/c+tHFR/hb3V2ZydkDl5/CsKZg6VUHKOAFco5rlFx4f+l8fbNblXVfLSPFa9dE +fxIYEjfZwEe3RFnQn+5/rMFxrDJP9uiW0OQPhj/gPiY46CyxI7wK6Gcjvp91o+lCOzvTshVsxYZj +iWFL70zr3OjwXNrWP1HXXirtKgjFHpb2PkmUA4L57B3wy8iPhZHZXDmJE3fcs0LCguJyG94WZRIh +TbBom6WHIFW/VWmfPJdcyRvvc4ZXpJjum4zNRjjUwcFGBNcVcRYWZcy/4DIsNQqcCjdmz+xrFz3K +JFe4zWz2+WutmJdElfAewjKBHYEulUxoAaHu6p6zNK8ODoYqoxVhBBa2Z6EOB23QGl7N7dU3OOm6 +/0XcDxGJVhZmtu93YFlouXf5ILn1t3NZ+UR1vIGrU5IOG8b+0B89VRgYGNOgokHgQAec0ocB9zis +HcxBA4XA4EdOg/oDWMdHzjJnJuKm3lD3bBi7nWQII4gPXwTCHIATRfBJB0t8CEAL882pWXHghrB3 +1t1Bx0YDCrMrhRfW1gK3YrHq2MMiPcNTTcmPRKfcPcIehLCvQi6Yo7PmGmq254U2NG2erjyoyWYi +ld6vtgqHRthZAof44Lo6EFVF8MYF6kTFSRJVKjrmRx5O0XJXPidz711FBdzq/+vWUzY6mykL744z +88U4YlIu7+kdDUlYSwI6xhhKdgHKq6Mc8Q5xy68j+SOzpiiVXQfMSsY/BF0cd2xZlxgAI428zljc +aWL+vD97milGuFUyeXjvmvDiajIgofMEMVCoraJUV1d+U9Rz/w/rIdU9a0mY2OEHIUw93ZeSbTxW +tXz2rY6mRo4tsvxOa8EoDJhAi1z4rZU1VH3iXeSZW9JvfJuVVRTUtjw38ur6IZe8lhjhB3whi4UH +c7Vzi06OfxbGVJWPU6X9WI6cmG3OerXAHwjeECHIu2jCzhRJf8UkM2Ve1tp3akxSigLOeC4XJBwn +taIDQVmmA+4k4W+/NTfw8FFfeKZl45MStGEtSajpIJdGGD+ea/qVsUkw6aiSWu+WG07mUfF5KWvJ +LLpeC14foXh4Wm2Kis6g3atb70XKtQ7r8G3mjfdbU44gAj5/0AF4P7Cp4a3606jMMENbdNOM2fFn +Vqt18uUywFx8oTJ1LgV/YD0bSdVXK6WbZr8N9tKxF25at5I90gocMveqjnTy+qGUIySHxr4f9r4+ +87CtZN0i0OYJIGPsE0F6tLAgP/pGo4bWTOmJzA7f++uXWTqodHRGfBmLsyzmpedplzf/wJZc59u4 +lhIQ07skOrsgW5O/6t2W7cz8wXZBfjWl6bS+c+uSgGpygm3wj80+ttb7/ezH6rKkrCXcDoXk/nm2 +hgbY5vLuS/lScp45VYKme/utpiZTrIV2FWzhEUDdYsEwE35PsM3RearBl94e8tyaVmF7n2UXh3f+ +AJynAckCzjCUXLk0pSE1MW+jTLgw63BdIpnJswHroll9uIndCoklvuu3i2I+fZsqdTWdcoraxaoj +XHkOd65HYkkg+k/UBv1j2/Yrzz1Qtrv5+p5ZTlHku9UkQB828tzTJKEW10P7Zy8zcjr82fv4oC0c +s2IufS/9ooCH/p59IsK5g55daQn89vScMCBhIbDKzPqElbyK4tcc4ZETvtt3DB44VAx3Oe57pAmw +8vB34dhsbbUUnrjtfVJhHH77EqcLPhkfpyEuQPC0AXLDE3MRdjF5r7E5z+ZH4UwlHmNeAbCkswNQ +u395j+F28mIMxgTaGEj7z5S//61yNmrrMTgYN51FgPuAfVaxDtcyWlp++LGqYx9+yxTXMtxJBADL +iOL+BZIQQD8OsRC94VT+Z+BD/dZuVPDbql+ynjKMo6T1sComyKWnSNj/Yjl715Gs7XVujyVpMlsw +A2U9nNMIFCGAoibgZyQknTpDFUXOdx5+a/XtupfspmobBOcCwrylAVbl+cYX1gdbGPg5i22tnMmo +wuAmCcA0GOqkYIDfQqULQKKTTFwI+1NVH/nA+E/sVXmDodlbcA7XggTAyDaS6bx6xSMr0Xg5hM9g +NM7iR54nDAMU2cNN4PBjGmiiK3riE7JDMFfJUfFfa+lGfmY5xjHCkfj7BGac4HqMNutJWS7mr6WV +sXU/G/38Lf64B6+CgTXqweEYgIVVtbbPMB9Vv1oyY3YzMWkz5bks9GowMPGD6uAsmmHJ5lyH2jKf +lnsMyc3UXSlzPnvcZmE0gM1Oawzh7XA9l5uq64z6+Kcn7mtBsl3L1cgYuD6LfzQml8pnc0MPZfxO +FghNsf9sSrrdNwv2aqjeJVQ4FNeYgbAvE2gS52tzmSFcicbD6PoZ1sRY8586GFK5tSTAdtx+QeJQ +hCDnrrvxr7NUh7Ob/lzjgOHsEabIpZVOkgUjC8WVT4tn5WRutK3rEonK4uSGw/52jKDZOf5/oXEK +kHt1bdtkhwxWuID/fr7u1q3qDKn/wS35Af3Ymt/UCmsP1E01tULh7U7aTt36PXUeJyq4KVlkclMl +DDxfDq+Og+OAgB1bTbT3sEk5D4MfSwZd9Jy3NjEKuN7r2WCutqoLne6c60yXVrTR5ne1cIupy9K9 +CHNziYcRkjGdydN2Fdx8Q6yC/iz0ORFrsAB2s3/UIiGDvkHzCG3oEOUue9Sv4z0w2KK7B81y7ZD2 +NtYYE2i+SPgItzxaAhUqxX09PRSot7cz5zDY8MO5E4taaJSxnbUDwt5ywYO/L85qQHlPg+2Me4CO +2tsJ8bRWJNxq9KIENEYA6GEuzeAfrA2Wd54d4Uhq+Zr7C4mAWzdcggL5kEsG/ojt567ePXkGffPD +FPPDuScO4XsQ5asKAB3SBtdFUMYLbo0yf49PihH7xGCPfA2pit5EIduua6tqLCY8AnidzodH2Kck +aJp8L9kcZ6q371tM4RrMEucb5zFA/cVIgsLq4xzTnbGXR3Q5jdpIuRUZ4DyfRRSLATLbwUeXO/lk +5KTxS3HRMhp+DR96zFTedQo4FjrglOAGaDMiirobSyjvb6Y6/qX+xsanyfq8cNSyEnhxtiEzb3SK +VES7UNk53JqG3R8/wU2eYUpVL4SOO+f6t3WES+s3dR2gUCeRlW/mPH1lXRIAzOHoFKHHfmHWMkGu +XUyK47wu4jzcLAx8OJApIYxu+CVmgv2VRVlL3Dnm0h4l/u5UcbID883AOllYIXusDdA6gELZjggw +ARfIbAWWdt7NW/govf10exffjwxE8Het59XCmDUkCEb13udf5Zc76xj8h+vaShtGey2aNr9YA3UA +KoqCTSWmTYbr0/ORaLmILKzDT9boFsYXp2BgR2srnIONsENZueDXPa2BM7uA5DYXIM5toYRVAgPf +uxo+qixttN0L2+yhbac28s78qx64CA6IRVa907Mq63x2iTH8s4Rlo9T+L1dGYcQWHVjCCyJ0wRQK +J49LNConKg64+z+ZpPuVkKk7uLoA7OqUGosoF4KHlobnAllfeIB645FuUZglGtBuaGcn8eV9zpNq +JDtAhZltiOeag9ldAd+46pdf7ddnVIylmHSE9pSc23FitGaZP+RqhTLiN8LZRCsUv7CEojwgHx9w +nL1vTxlzGfqEuWjM++vSTBnpxBgTFOh6IaBNEMaNaV2Km3Y15niKpvj12/VX86jtJ0YShjxoFdES +BUUS5QceNGtsS/VhrO5ksjr8cMefqYPnV1UAoN/2lDMvhQMG5Tbsk3M0Vr6lu68qiSgE9DDoe3DR +xXL22B3ejG/js4UytEnTAxzVtbmroos59EJPT2i4Uv6yGvhj0dj3WmpYkDScmxhqiUY4WyExZrix +Czd/NEMujIYWerli95IcptgYyu8UpSEPuLAXqhMRAddfhD/KtChXvYsx2kIhdvk4+bswkq8rLofW +7fA1Awh/yLiZ6Sl5NDrDlJyrN5z1k0DuFcaAVUkwNBA0YHRM7edbXtSiGNG9uV9GPNtf7IshQuJm +JLgxGj/HO9F2XXh3Pd2ZyJeu7G0vNsqLcQodXckBK3vA1RfidrjTZJPOmJNrevTfPK1DQ3NwEu5q +RyQGBR7ziE/yAdhpyaTJDN367HNiWfMfJHOswpnCnq9k7YxFwbTM2ZBT5waMUZtrGM8/vEXGGhx6 +078S5mqwQKEdAjIR3Qwnv5Jv3kr3yfkXWlNP+6BIq80KxARpaoUvargs9FXFXt/5zQbr952hHfGM +F+NEmMoMBIjCuD+4rCy32H/CmwN3W8rqnDnqFsg5ft8spewjDAwdbUY4VMLMaxfHAzeSraoXq8z0 +4r5sHW8JaSMGgfPFCzbsRQO/U409RegeycrdjdAwFl15/UJPB/c8QLOuEKN0bLzgmJLyHupQxX2h +4zNCW1fhAORU4u7zG4dO/6xJ3u3c2FEZdeSAV94KBDqQfNEy5msVksj2Cm7yOrzDj0ODxmCvO+OT +FRA+bAFYpwU/2zhJim2YkCfPi77SmuOhFXkiveiVDGiDwKVhsBi5kZU15DR0T2BqjSL/y95WIq1v +8cHX45Ekw47VaIBBRb19/gcZ/av/vJ1GwQdyzQ73r4+IMEClXvD1yoQaxn00QjVTPEk+bNZDtiPG +oo+TCAOF6oITOXC6b4VEOELOlF99wue+5NNDPq72P2Ub7zBt8RN5AS8CLp47Yd+R71JwidtZI2Uk +5zAVymZAvvJqwNThGjKwoAn4bib8Zq4o0GHc/QV9d/qSzLsdVfq0Ma7RSfYC6DJ4HCAgd52QscJv +hrAzwk+6FV2ttNUOkgUP3699oJwqu+PocLQDcR2AmJr9bGZyJ6rvgyjiC6vA3lM8mytc4IlFGx35 +YMpUwTTxgUWHF/nEgz0jWzZPVaxgliQuQGF7BKtNiEEClMwDX3bsTJIIlPzN1VjTPXNBk+P1SaJK +4NESSyrc3bX1jvnw+ZoO/105D5rrXrGZYTHSq8MARc985YYviaX/9HHaLWghub2IbXe8VlBER5bY +jcak9P0Sbp/cElOi9bgaIm5016ygcbAa1gH391RACdBf/llob+3PcPNlCf/GA+QekrtL9EpWcBhC +0Bj4aD7si3s4cVXysF3yxU7zcsYbB138YAgHQoIabg652LfF+1D27pH6psciB9DOooMjgb43hVbA +0PkWi0MS37fBnADstt5HiWlzQn5nxDv/m7+8AlqMn2Taz9a1Nwt9YHtbXPZZxyankvmesysvt0Oi +EeBx4/igZsYTVuFX2ul8+Fm3ifxm/ZnWq3B4wwoKyhWFSkUD5hf8e5IHbcpvF0f5tYd7uFvay/m5 +tLZ9X0mCBzHiN4EW7iw/mWzkIIvQZ9+KMiqhEGTqboaZTiIofnqwgIpX1Wl9+6Hn3ZRfvO3KRmGu +K4k911agoP3Avb2FHcqeUf1rjkOqsbSho0wTLjdYzzVw7llB4YYz0BSAzyW6lIajwfXSE81SVZum +vHH1CBMRyZUEMAdbaIsRfHq/b2VxnpEODxuPnmSJCwxKMl6BYDGAwVgovL2YeKeRr6GV2qEkQrWR +Q287ufzIoTilwhU0ZB4h12VhS60/bFz8sHGzQveR8FuJciKYnAlyxlVJ/KvnE54XaveJmGA30fN/ +0zqC8VY6tLLBLOUWrOvZWM+IKZWzRxWiq2h9WO/FGxT7q6wgwbMqwRQiYDOVUT2Cj8TP0M1Ho8cI +G3/atK+LDp6AAvTk8Z5BsnuLvbI2d4X6G2Vf22q+t4eaZRNWcvYOJn+NwDwd3cH3dEryLOK0uMtp +oy5d1bzlC88t3FRZN6mv2wT6ugVH/WseBXoEbZTRaSLIcvOrGCrdu2/TYCl64kqpa32Zw/xF7ZXD +2yIIfAeuLIQ8neVuUJVm2+/ivL329lwj4mw+PEbU+p3LDRt9HvLjbdmtGy3v5YaoZHO65OAlbHBe +gxlugLO3M+YnnAxc8EWAPs+ed8pMsNbc+gUpBWXRlghYGriYWbUtaFouR4xFVSOUR/L8d2rDgyt8 +BeA6aX/nNobyG8/cEjTqTrUpu43N+Yn9D0K4s7TwDEKw695UUnqtFXV03AGO+bQ2aXPMeJwBwAA/ +/8MXwxewaQEU1o2XKJdbuDPH0loadxwwbWtP7MWTfQGqFPlGu2o/rnt0nmrVV2CWA/qBTAs5k78C +F5NSAhMUdnuQlVvomFqqI5x3lNMcS//o53yTvwIXs5ACNgcUJ64djTYbnmJX8S8MLPvfKq6lc6aT +2gkwFGiHtVNpTBPgwQ6sIbmqNnX11DyQkx4KLBRJrPljR7RXjfcNsPx+3pVn4DFnsLNeChwBFHHz +OXZ6mZWTTHNhOQszhbiUjW2uk44LNSfFVXv+mwFrh5bWR3o7h7dtbQKUQZbd66EnXHicnVVvbBRF +FM/slgpNS2krCGjhcVC4i9eDamLwsKZKj0CFUtsGMKXAdneut7K3s+zMtlxIuYKJfDKpXsIkxBgF +izQmWoTkEjWVDyQmYFT46p/40a8maGJiom/37tq79vyDm1wyM2/m9977/d57d/+tprvvNs3+NqmY +4kbm3L3v21+i1AENHEszbRh3TUHhlEc9aoCmu4xzECkKg/sH0KY5+TeOka0b14fwPqUu7NnXC7rF +OOWI4NsdeXuCbFFCUVl3loDsOUp2NuvM5gLBdOoIavThu1zH3LoGm4rYANNPUvF8OCI3fqS2SphW +m+SnLyrr5A9Z0izFMjUi/zhKTm2Giucxl3JmjdGwH0NkVx34n3y5S10jv+Vqh/xpmbJcHvBIvfxy +mDTI2deVVfK7n9UeueKC0iDZObJc9nepq+XUOdIqsx+rtdkgmU7QxjWzMtKY47K0yWnRCWzfDg/F +VwwGcZc4uAfSHpKgszSFJEIuwPm3V/v+4+B4PBW2PcuKALOtjLw3p7Ss2cahRxvTBnTXdAS4VDO0 +EYtK1OGidAQJydr3lUY/2xXym/MkIr1JZO6z05g3pEmL/NNGwwdjZJvcdYIwWX9RXSlvzZKa/K+v +kckN8sPDZOUGE9nUMOF2M52mhonLUBQ6hqNBkENydpo8Vle2/3qabKmDp+b3v+O+ubgfBo1DIDhG +cpk82xaHNo5oGs/YOoS5Tm3NNVkU6GmH6uhzt4bFI68fwVDvXib5I8hIQtNTgLzrFMkcpYKDiT82 +boOgyOGIZ+DhrsAL1T1hjlFgDnU1YeIJcKFlAJXxeeUa0q2nTMuIyU1Pq/HcTOZROTWjPCLvXyEb +10Yh1N5eCgmDLC3zv1whb5P60nYYS0y+eZW0bOVDO4Zjuh9xJCbYXm2M7qf2qEiFK7LJG1fJLaWt +9Lwdq9WzRBl+FByN8zgI17vQO0PyvTPKO5ueQfaSzIVwoV2YJ4JiYUkYCnFP98lAiBB1Xeb6CwO5 +cFlGvmeoLVLMKaviJ15lpl0ovxS1jEJjHreZMJOZYqEipGNRn6g4bDlT9DFxIqcdeiJn7WyUyh2l +rXvhEvop3il1WUFbGEdO6V7fSSecKVoAqI0EWBZmtkNO3VbWZE2eov4uOn9FuJrNHeaK3cHUqG5L ++DlW2nTLpLbYY9pLIQumKnj6c4GlClox0BFNP1lp8Fny2ythG3LVJwpkMfc0syuytNhoHIaGyx6V +yFgcU+B5NzNoHPyu/rtMq90oRtjlh7jUPlFSw0xCuFQpnZ2dMF8pkWLAuevnN8u+G2pNNhaLFZJZ +cAJl9TDouVgTVVLB0ZsU1O2nFsXijpcR4X+IWvVNeTF0+AZ56hppGVkQsKPy9mJ9O6qCFQVbZCwT +jRq5S4db5dyTpC47AdTidClFhQ6KlCWCM6cXOYZk0X3QQp6DM2Ueu0AC8JQnDH8SpbRg0rjY81Gc +SMJ/Uo4n3J6ixBD4K4x/LkzLKvQljDCRwgMc6GkO46ZIYZB+nqY9Gvi32Dj+/VSK2LhIRPnVtLK2 +NtG3ry8RkuwaWZ8o1EqocPR/RQy0aih11Lx8j2cfTrTKxqxqLPXmf5M7d+1wY6Bt7tKPTfLzm0pT +T0XoSzwuHTd4tgi81Ez/0ikjFIcznScw0PAfumSpvcxtSaT+/uMDg/2JFw4c707g4uAriW7ULKd2 +NcvetTW1uR2HauQXN9X6Cw/uKPkHd9RjZ/8CSdMM8/qKAZhXqJSweIHP39ggRGv/m50rERBCeJyV +Vc+LHEUUvmZXQwiGVfwBz2YP1djpVaOX2UwkRsFINIsjeAjBqal5vdNsT1Wnqnomw9AMCB48Sl/9 +FwQh/gP+GeLdixf/AvFV18x09+wsaLOw0/Xqfe+r9776+o+v/sJfvr+2SpQGJpQ0FvIJNwgqgSeB +sVzbIg8iCISa5hnaVMngaQjLQ6DHorGxQZ3yjA0t6mkquU3lOXCYK32BGjRmSGgGnhVY4Bi+fjSA +42VdoRxGwM1CCmAhHPfvrTEBPAsPMFCFFgh9GFKw+uHgdvXrwe0VQHvnEpSkPSXt0visSDWyQKox +9nCG0pogPD3cTci5ptCZ0jZaF/qEW74Hwge/tRONfLyBeqnGYjX56rc3X2HUF+ARjJpCm1ImHTv2 +OVIv+veqv28cveWCPMvU/DOeJY9zlD2wusCozq3+ufFG9eetWx+qMfUxAkE7R1xchI40gbAwzgsz +YWJSyIvwdBtn9LuMqp+vv0rN4VTRFWbUWOrrKGzzGnWDPNxDGvXM8QWJc7CZiWlqAyUu0LJRRERS +M6h3rIlDHMdNE+/GArU1UO4BFllKbSdgB0pLEoVlSzA1do9aWD16+fXVTqpnEyvJAtRaaRJj/d+x +XwJNRs39wuluzbra/06kBqYJsOZEsb8Q/X6/cwvCrWD9w+c8tbUUma9Ml8agKDQ+8CcNOuw2Ca7H +Z1pNU4NMo1HZaoaOoUH7cDrFccrtOjDDcAfB6a5h1I2N4rlOrROfFwsdXopLqmpdu+35G0Q3qUWO +ZAWbXN+FpJCi7gF81ER6W9jTHUSNttCyFks3VHZf/aQPPHEWPK9+PDqq77qbx5pIi9zbHSrheqKu +n5+6qbKAemocM5HmE9IkPm93a3caTYS1I6TG1raTExhYlVOp1EAqZ0rwmsoIyT+RYmSXdFlO7ATb +TLeDpBZJ0IWMW5iNF8W5MvYLNIaf40Z/q60AO3zvW1KMMLGTEHNHfijtnffva80X9etgQqjj+v3j +IknIOD4Iwwjepb8WThmSn9ARxIRddTNWzdUYbn544dIx2PCSs37jff8/Omknda+Lr662cW5IMPZS +Ib98YqxOu3eu/V1Zm5tny46Xnw8efxm7FHmeJgvWfHxWAsMy6lwSnPGs7dn+afyi57zaTawHl4D9 +JAmwNsk9G8gZH1AoLMnOHXr14vrNldWLDgN/kieuk4undJSW9XgaZD1Tr6OuzH1vYuoXfbHr9OhK +jk3iO7uZvp4vFW+++8hIYO9VP73GzkpIaCXLuqyvymrpcaO09ZrnUB6++O7a7/AvQVekHOgBhl54 +nHudujB1g4Xm5ABNHabU4s01mtIsm0/rKrACAHxjCMHwxQQPVygFpPpaq/xbPpU8InDWAHnNenic +5VpbbBzVGdZp7CQ4TpzE3jhOHPt4CWaGrCexoSlyYocQQgMCEoilqLWWZHbnrHfweGaZS5yVsx1Q +H/qEihilI6qqIlR9q9RQIdKHijaqhFRUlfJUVVVpUd8qVQIkGtGL2v/c5rIXqCr61H3Irufc/tv5 +/u//J7dv9934Tf+Lt/dtYMeuEtzCNddZw0XbMcg8uUxs33vtL1f7o5d+V9Bc4jUc2/CwXvOJixsE +/ll67Dz26oFvOOs21m0D+65uwzTXj67/8MDgskVqfgm75krdj6/NIRzjA2hb/NOjaKqfPYxm/oHj +t/cidRPMjE9OoTt3VB3b87Grr5+G7Raik08Mx3+eR9uG2HyNSqkUiW1E+Fej/c5awyKxNYnGpy87 +prGoqMcGMLYIrGfCegQv4GKRPqxaJmgTv1ZAe0MxdGgBV+uBvar5znnfNe0VRVXVdG56VrGEq+wo +nxjUDI51mXSZ6LqO2zb1GVL12UyPuJeJy2ee+fSpuU1rpm16dZiqqHhhEVN7aiCRwgSNJzahieiD +M5ujoWBLdPZHA4+KY0DGYI0oHScLZfheGzCIMbWbsLbm14mtiMHo8Hv7HhFr113Th8XSpjMsAGZo +AMyAfMmGYjYXj52NcYt9t6ITNwtbpbbRV24enOJblXDPXeN3j6HR6JWb++Nfz6KhMaa5QTzfdZqK +2JyFxLfmUOHr5uab5mb0+77Fs4HfCHy8FkAMeb5pWbhC8LMBCYiBPWeNrNeJS7BpY9AVU73A7SyK +q3XdtOOfbEOHDnDD8A+PRovYK37dg2BS4he3oJF49yDaHWprekPxnOoqxBtVn/1ixtIrFnmMrRGS +8o/ugYnAs6tK5iGWu2tUPsWmW9l4ER9RS7lZj54/+4TmsTg1a01lA895pgEGNEjDr5fkJnDZSJWY +l4kBj5wVsH92l2hXqXDzoUF0vW80VTKnYvzPITQWfpYqXRX5T9ToUEJaNiuneoc8qXVzbBd6755o +x4Nbw4ZLZoLGiqsbBDcscBZeOnWOuxabHvOnrfugOSCTbcABMyxssVOhcQkjjo0DD8Kg0sQU3mZs +0NCHgNJ8Txs4fBhfMG2AMQ9XdTu5mGzbs+chUk7SvSqk5kD4wARzbY0Ypk5n6KvEgbgvQQBg06fL +bcfHDRZjIFjFCWxDd5tafGMCKSHYjltcZReQCsCNeElIL/ebxzo+uEF93MKrhDQ82NzDgc0RAfTg +RuBK6nWiG9ip0VC+xC25gb1VszGPG65TJZ6nwXS/5hB3DS8sACium/a9c0V89SpWpkzvwcDG09P4 +iWCtQlxFLgEpPDCbp1F7aV7DMn2lqBXV5SNlFR/Hc/epuMUP072mXcW+hJW4PIkWo+c/GY5/MIl2 +RUdujEU//2QyOvHakEpn+xq76wJqLNPziQ3AUbUcjygSOaLrr+5jyB/vxpA43jmERscAp04xdISb +SN0HhrQBNpWNyP7bZHT2jd2oFD85j/bv6TyFLo2eOzwSpiG/DM/OM8wqw376ug7eOwfpz/SIpluW +sqxXq3C5AJ0b/GmJJUklkQLQS0hQVMvJ9eg4l58hwOv+ZqKhlINlA28en6bfy1SW5XJ+Rk03rXht +Eh1QYKNFJVnPwJsOpjJqVd2v1pX4j0NoNFwJdBeSKD6+tKiIWzEvVYRnTECpsauDastiVqlt13Kb +yI7NhKWAyKQXwmfyCv3Mc820RuDV+bwMhogDeOJrG20di58bQQdGMpZO7BjrY2jPtBCgTaxldhvg +KtIsAoaMv7kF7dG67VLG8xn/swE+pxz/rB8VQgyA8BjR4T5WHL8ukUV4Gxum16BmJp6EBNPzAppK +KF5kLqaWEw8gTF8DPAWzPRjUahATEGZOVTl6H74Hzx6Zk18lfO+RK0dnE+UooanC1IpeXaVJ6Ehe +a3oS3KDYmQTozvAg+uEGERlcnl/iIZd3VnLAoUOpk8yacLAqT+nuMIyJ5dGE2s8mRd/5cDwECy5R +AGS5uEHTksHxlEntBlUfRKC4UXcd2wk8qzkPwIwZ65yxHKeB/cC1GRwbri5SNsPijGFFJgLEpRSu +6p9+NtAthU4pCLXTBFaCZBR/s4T235XoSh+1XTXThX8XKIi9XER4E8Ynold+O7qZGzJ6/+UD02om +oYHIZB37lqcB8p5naVMRU4Hafrk7JrAzUjKTSMCfO3bKJUWYR08P3fkS2RxKl0zxmeBOg6oH3A3y +AUC5eC7VflikCrXtslGR2b5KkVEfiruGjGSeXyCWi6lglMXBzzL9DW49BZYCfgnSWU3mlVWb8n8W +9z65wrxdM69ojFhVmpDjgIvpTVxhQQ9HwUE8YYMgCfzHg1vRZJjcFNiA67WQ46vSBJLmQB6SYa1x +MvEp2qYS5nVOdQj5yVnd5Q+KKTkanRFS7TKJHdFj2nodJOymRJhq0c7QWK0C1mBHUNcrj+t+XVsz +baXNAngmwwKT6Rkmp1IWwiEIX8V2YFlSsH3cuuIsIAp0kMsST42i/WFuuyTw2FMR0PTQmm4xcp8a +nLCpHfaW5s7RZJaJWe5SmCnp7qxS0I2QHpvxjjAP0PiApM9aXZgqL/UIxQcvNZgXVHTX1ZtKarDE +KYdEeSgcwg59QOybTlrIzUqiJgcqHoFvI0UVsPKJLsBB9aSwMZgFGIo+fWwEsCe+OIW2XGjHE759 +F0ARA10QpXNKlUToqT0pxIiBTowRA/8TkMHR0x9t271cFenak+yMJfKQoVtJiMwyOP9Z4siZkKZs +AOUIHYsmuXkRFgcuOSUZnGB3nmAEYpg+F6kvTNlQW9IQygFxy5/AIaBjZ/G4nM3vLkQmoZlH9CvS +50kjYyI/ArFzKksK4u8V0PQQ30VGpRq9+NeR+I0CGt7Mt4nfKaCxfpcAl6eEcn87X+jVLUgiMlPk +F+k2zbZ+Av9kZcvyCXpx4Oi0jbJdyVzlVlyeRnsPEwH7eVtSYdrMzm3G+j9LbXqIJooQkxmli6C9 +xBQrom9/OHGuZzAxMUuJQkmNIBZnH2kaL24MiBzGQOLjo2hgZ3viYkPbM+Rklj0aH8qIWcJzfN6w +OIcBI1eQD+ySIcNGqIeiHW9NhYyKl6C0kJ0ZWrnB79bAACtCi4Lj2kx2lrobOhTMHuvr8Y6Shykc +eHjd9OtOwEmpZL2Wsw7ZhCMZXiMwwfDA5LwyVNR4cB6dnJjjHS7ecWALFoSrPCgqow9fHR6Qf86W +o1uvDx/l8Ub/TFf2KpjaiqUwLZZ6F0oiJFoZwT6vqqmflU3xrYNoNFr++9hL6t5zHby7d4XUuz5q +pW3CaHVoPOxGdHTW6ugEXtpDaOhNy9GNtPtYFO06320KwYDknQRf+5C9Ya1wqmLaVSugitIOyJml +pXOH57DnhGwQVL7SVBlbd2keAi7ODwsqllkF/kdjXcaFJg9ZgsAJGg3eSb7g6g0MpMCT5VYNQoRl +d9exeH8abmIdqAvtkfB6oK7boWGJcoDSSoX7kB9EOyLL3BhF3mqEIC6WJYE/W6F2g7wJ6YiAR0EO +v6mwuCyJHUp5GlYzVwKXZr15MFZAWPPjDBtcgfyt5jEQ6pp1nDrlEg94YZCDG/yAFl4Hhai3LkU3 +Ph659l10R8ixi4ktEU3QYuG5tvrxi7NzSeUIhSPJrZEJvANQ5UAxNx1yXV+PajLXDRaiZEpJHqNA +bLpWipCt0+cM+tMmcRZipVRsKD46i0aeynA4bpk8m8WLEkOSgTPmSv2CDgTpcd1dbbMG5W0s9e3n +NlzMm5ilTS/64KPCPppkBaFOau70NUIherO0dTOffm0XGnlGTO1BCCmnkpsBrRbmS8i+5JOJcYSD +QSjAKU5ePWmv+GtjaOKriVWUvP3ERgLmVDXhvPzIbkaXnhFrolsPTAyQJGFET/6psPQUqVn8slDI +aL8s4o6JrT9jrriG6rH4/WNoD22LDobixtP7KmoHer/KvZqkFNhokxTrcPGgeIQLxW9X8v6J9ww8 +uGdiyQksMtwMYAZARhEisigu44WjgswWW+AJcLDbbOuiik2mp7HolrL0GT27PHJc8jRYRru2IqPQ +m6NCcRXYHF6MPHWhrzPm8UORs3NsEzyMZm+MoFLU+JeKLkZvvjt+7RLq42/IILTGHmFL9CrrYS/I +o/Ksij2CwY7zmK/Z0hOacm0cnRH7PoOO70xuBX3yGeL0UZFBmvP8ByyPf4yRkr7H62M3dtsU0uTL +vLtCeQDgFGwfQLq5wvN15sUgsOMAZJctOvaHaNL9N31SRh1Feo6bk2jX/1XPdDz+xd1oMH57BO5U +e6mXpvf2+99ZJOVc0qNSyngqUy4lxdEXIBrCvehg/MIUOhI9/9Bw1HhhR/yHKfSlcXa+ZXEl88We +Gk09XIgfoK+JF8fQji0CAqKpj4ajnerW4XalKBzeuB/tiTaGBo93YUL8Ouu234UMCQLEy1D6bmzl +860cy9k+RUf+Ocjfgy1mKyCKJBXHaCZlYPz9ApqCTDMAV4kNyPSSvd40t9BBLZNgiqwkFrgAFK93 +pqErs0VYh8ysINkExUeEP9i7PdcoZSxhqK32il5+fTo83vYwg5KuSXJd7Cx8dZaSyZJ8HUl15qCc +Z12MVp6+Epoee7VLoVpgN39TdvLcI7jSbFBOwV8ayhQgMgB/ozjP392x1rXeoBccGwH1FnBSiNmL +fEstdy43i6H7Oq3VRf6m/51CBCFzg8zgrJcmAoo243S7qWoXeWYSDIvuBKFFv6TzjuUOTDo0gk7l +R4G9B66dfdbK/KYnh7afvtqXAnZ9N8BWyAqU39pOnbKeEZwvkbDrK4NR+g97b5DXJLr+8f4wE4Sc +2wlJWdj1krJdRj5ZbY8bIZ1soncTrihFk5M6bNyKJ0bRRPip3KvUcQ2zL9F7YQ0/MmkeCON09p5o +dzM+NIqGh8QNoQ0DOhjdunrgWKaNkDCgZWER1jtLTJlxJc9Z0a63JrZK+hc9ensi/sYIKmyniO0S +Wo2DIeJf3o327Wy1tRL+DRb5fX/2CbMx6SLMo1Z4b8YmlDrxy8M/2jU5eJw7HrLLY4L4Ro9Cps3d +HO8UzPRyUvPSSzIUFG1tFUwUamoUCoryk1OLi/USi9LLoo1iwRJKurrFyal5iUWZ+UogNYqTJ2rq +u5dkFOWXK+Slliu4FhXlF2kouVYUpCaXpKYoIJQrlGcCDc/PS1XIzssvz1OAi+cl5qYqaVpz1XJN +PqApAQB1TDPf9wj8DrZ9ZiwgAObb4bMqej66rvU4nXicOxFw1mfDdUYhp9I8vaTSzJyUBIXMYoXy +jMSSyfe5xCaLMzlurmbawDL5JbsBm5VCZolC0WRHdme15Py84hKFktKiPAVbBQ1NBVs7LgWFsvzM +FAW4QRrVXJP9OJQnF3PIT57CYcdUq7n5Jkc12+Y0gbWcbMX5ydmpJZsNpVy5NternGQGAG5lLW24 +nQR4nMVaSXPcNha++1dAPKTIcotanOTQiqKyZaWSKY+dieyZg0blgkhQzYhNdLhI6ij93+ctAAgu +LcnOYS6JGnjvewveBtB7e+K9TpU4/HYukkLX6nOpmzxbC1WmtWgWSlRKpvKqUGIhi+xI1A0sLMVK +F3myFvquZKq7Km8cVfwiaGuFpHnSBEcvEl3WjchqcQxof7R5pcKgBKnzrA4iu72SzWJEgIsdSVOM +IWCtI3gQb9tVoe7FZkTHeiNpoRqxlHn5k8yLtlJAWbZFYSF028DKrSxa2PkRlI7RNHW+LpPwYCb+ +cf7hfYyGldfgpZDoIvFSBP8tOzWy/L5h5DBCkPDhhRA3aj1HOPTnT3nBiGhf/LvOy/Dz5zSvSrlU +MxEY/npPXquyOdgF1nilQPloBkCJqpqvRUJeB7VxCt+qqs51CQo/iGVe/pt/zkXw8d357UF8GMzA +Y/fjZbGxCHcyb85uQQYarZZ506hqJhSukAtKdSd+rfQyr1UI+ujiltxrKGNdJiok6pkI4ziW1XVN +fIY2pIUIFJY1WCuytkwa1DhZ5EUaorWRQC+bQKlkgu6/uDyCNTzwRC8hMBpczGRRK7uu8ARl458V +YmT5NbgtnTOxQE8xfTYIGitRWdshI5zl7+kQUtlI9OyG8FFJx1Q21Zqc3qxXCvxKXODsRNbwk8+w +Vn/M2aC4UOU1JMlLAYHoy5n74sB7JHFzRJKYc9XWi5DEkSUbT3FYzFU9pTrpy/xZXsAxhfe4ch8T +oTg+PmYtxDffwKLxACx2AJ2YRLfT/iEhRonxpjG5w9Gl2opCMqa2QKeDDmKlt1u7VZGL/cuTGI6i +g7lSmeYclzNxBWcGJ00YoCItRegX/ME78AMkm50f6G/a6BBL/alU9yuVNCo9qypd1TYq6SR3+Chq +vVQhLQhxb/foh3cEgUL+QPz11/Q2VM3TIoefZ4/TQZrJ9nrRnN0naoUJ9xjpQpZpodLf1O+KkjOY +EaVnob6qVXVLTuN67OL4waaJSbhhwoCvReilGh6K0Jm4CKBRBVTpyrxe4F/UxoLLyKjJgqDChF6S +uPpOaxNJ2wkh4xhTnICeC8mHMzcgJydUCkDlOaoccdp1Us1RACT+fyTTbWPdgT7FZDH+baGh+Kq6 +hgpuN81P4aTlmQjRf5EvFxewliza8mYs1uxC6VH3UECIKm70ObU2CDqHXSnoIKUBdsVjVekEtCBB +4yDxjDXH58qmEUD7RgIrFhhIPMIpxIfOCz0MU5z5v321xgH5t/WagPxCxaDRBVw7zu5zLPbhqC8k +C5XcYPLb7hQajeykVOPmjlUeKsuOP9DA7w9XqF9MEQp1hvAizNZqHb7RulCy3GpkT7mHrnNuDAdM +SOGDSS5UZWb+toT2t1Fv7pwM4eyp6ZOp9JRUnFvFYeLp1DbNB9bQUTu8fAE/LyMLAk0vJLdAhlIi +ct+yjbOGYVWFu99/G0HBoZEj/YgbNLGA1H/i8AQTTrg/67faXQE8YDnLsR6wh6nAR6eYqMfCCN8H +2QfdqbsxpVKJrtKP0OXr8KrNMlVFvROHMactGjex8Kyhs6xWuLjPa3cw6yhoXLz8UnwnfjgWjGb0 +taCuo0BuA7/H8dIy4PD46ReYCb9/c9ZBvjIWckkh9h+HIkxBsPMP1whUn6cMpr5gyEuH54xBUF7c ++PXF7h8PTAKnGufMnUhkJP1cfS7UtUzWuyuZUzOj0QnGdFk19X/yZgHFkO4FuzD39vzOfKjVJJQN +r0renUGz8ckMoNLZLl559EqVu03VKsdD14bXGUTuWZlOsRLBrkSKXWpihhHhPgDcFE9fFFpqVIO/ +egK7KCpU1jg7ciiqTo4qUm+OdaEo7z5QzcUaY/zjskoWhb772Sg471TdWHkZxRu3eTul4OzP9zJX +NyhjO0kzt4xhCQXxYdMtkV0hNSio3yUMTclVF+h+DmGO8Q2xyzbic1HoVbyE5h9wpCzrla6w2AUk +iqqeBdv0WDHozM5JnJdJ0aYg4vAAouoRVFnArSvoAdFBcL6MFUyuQu+35wmYcWQRDq1/RDIxbJWM +J/8cwRtXZieEdCOewf4/nD8eC0fzMcdzRJG4zb8KJ0yf3+XCG648EE+JbMILXDUD1GUPwY8EDjMk +jU5i4No94BsHRMVAiLs5tFWNbkKeowHFKClH51ypQq6pTyOMH6zzQZuB7WgQwE51qhpjBa2KOB1y +2eKWAVD9jvFqBDtWkOI+Tiu9Wqn0CUXjur2SVSXXoREdTakuvHMdsO3PhOMcsm2mjnwCbcz4Ytuv +zd/OV0qR6sl87VT8inQdy/DT1T2qfXW9ZwSWMp33gB5/fHd+rpMb1YTcf0SvCnTyO8fl9Tlh4vzW +qm69VglMjqe65EsLgicQlo069zfCB8Q1T19hRE8i9oWrc87ITa4B812UZVu32msdUU5er6xRmF6j +2xT18GsdRBYBGn4YFLL2+gIy9ocGGOSnkRqYmQM/qkxMydUKJl1pLiZEBmmbqPxWpTHP9THflx/c +iy0Iwocuruxxb7WXgYYAFXerm95YbC4vRDeOBjosXZYw3vMBeQcvaoqPOQ8rUB3wEvCplG2z0FX+ +p3uI23KUpi095wCNFXQvJ0f4t69tfuxMj41R5ELnmkGWGPLeahfDLhlf97ko0bfwPOOsurD248km +rB8rozjrl6e9PfFOyVtFz/ol+OAWvwFQDIkE9LuSyY19/EIYCMsjQVEhli29YjUiK6BgEQCGID3e +tHXsCYFR/5flUqU5Xm75CDyj4IbMEe6Xt3ENf/KwUF3vjYNBB23FC2sj1JM5GeYTT8Zuci/TeiFv +4N6J734uLLHCmPqE4R+4wKWuY4gHfZ0eDAdfG+zr5Ij2Yv8yNr3VVIiLw1ezw4NLlxJYat5SUgw0 +ozJGwhz6cBPRG7pJ0v0Ii5aFRYI3/F5QQmByWIwQZsJbwbRzDuB+868W5CYw2qm58/2OaUVwsQn5 +YdfD4Oc4NnWf3j/cKwXWTJ98chRnRqeFZU7nopM6fM6o1KpYU8qwHzvKp6yeVMHCgjvYgado0+Ow +5qlz5AcXTrpZfMSXXVjt2RIODt36zzxQuwbodnqQv8m7xyH7Bk6DT9I4MZh5b1UBNYa+uuy4QQMk +ubjstOS45Kdw802iC1DOYh+5i9AuvPqd1nvUZsOe20nRTL8kWV2fzY/J1W+6aAR1O2cDT+tsxWsM +H88Od/8fGLBlCh/o+2SBGXBPFRqoMn3QfuD2D74XwpOJ4ay2XsE4eN1QfZmOi2d0a/5+s8XPVmCp ++avLfOJLTDh4ApT4wbP76hmy0HGl7z2ybusH3SyxqnSjE124Hn+tml/NWug88wXzxpdOG8NZDtPe +3QsM5smU3SajDcncfuxFGeGFFxzbWWeTVJz0T1Hx3Pg4jbl8jIns3b7/CIDOScL9/txophOc5P04 +YD9Zz7kvzTh/+h9R+O1y84I/WttXZFld314cXkYwrjTJIux9oej/O4XRN4qJh+iDI/qu/z8jwDWy ++q8CVvvU9ZUew0Bz0haWQdU3pWvmmC54nK1YzW/cRBRXKig0oV+ChjSIamLSyKauk7ZEbbNKljYN +alGhKSlwiKrWsWe7Jt7xymMnjaKV75xAc6vEGQmpp3JA4tQDHLgg/gxuXDjDmy9/pyoSOSS7M/Pe +/N7n/F7++Hrs+5/Gvvmxd6+PEaaJuxUGtI99RPtp4ke7BA0iH1P46sYYJXCIJjF2B+Pz8yiJXUKH +UZygLRxGu8glPgooTUER8U0Lub0Ex0KmD1ugYRs/mxn7e/GMFw2GIU6CiBgW2h9HyIsITVCUJrCD +2e8rk1nQQ+bMpkFTz8OUGjYycBxHMf8AcJI42jPuOwHxwhS+mkrSsuC2GJAQvIvW+HnTSMk24WYU +d+p7DKuTX91zgzAFA5fRehwNAsqmF09latEZiiXseG7i9U0wbHkF7Y9K0rtukICoOse315VI7HrY +3FQbNqppvC90ACo07LtcEBkUJ+nQEKozoTsl+PEQewn2V8NInKFRGnviFu46hLirpPzM8rL2E5qb +Q6VF7bPashdil8B9llKFcoQx/iqDW83Ckw9n9+XNI+RxJD5EvReppNAYS25+aAnrEBrB71HhrMIg +oRcMMqVeGwnolrYseznTXmjDgSbwM9hfQrP7QqnjQZajbldCcIg7wKN3DrKgj0N2YhFNiC9eGGCS +sJnu3FGvtLDK3licZb9eOsZ32C+Xjo+JldfEkSFmv13+IPOilCQUHCCBQ9GsumFIl9CCLRby+voo +ILwoW3ZETrSsC3uLdYmppibT6zUlcrGmQYHbcr1tvTjSyVsSWOVuXEYkDUO9W8VUOpDpEyXdLfJD +jGP9OXZ3G2qrKPKTGNKC4uIrTcOkCCHF8Q6buDjJpq6sX7fRwH38BY4pZO0SMu7d3ti54Fw00Eia +TiNvG1Tk9YYEJFGIfIMrZc57b7PO2SNf1pLbNPhRQ2e2Siet0omIaYhaghOyrdSqXclb7Lsr6BBk +zfMr1z+HxrvqDpNUVZ4LDXLIK0/BLBVl3nVREkU2HECiu+j6oIi3dOiN2HfYt6+8+SF3Co4lqogQ +gME7tF1ygJnfpq2XNklJ5pydPFUrPmk4+/ni+zcavpFSBcyqn5J4TzncFf2V/zJZd37lsHQju3t1 +6VXEU4LfmzW0w0aRJPUQwObLeL+qQwuX8EQE+jucstmTqxOHrA570rXYe6sm++fqCvvTOsqeLp3M +dNrIenfK9XXunE6JZhFVG5MuCf7TsFUK50aqrqX+smOd6fOtGHRDqKNgJ68hNr94uh25bBd1GbHq +Q9hpFO5g02piVT5VWGsgcy87kl+I6LCn46/zsqrjqLW5Akprr/kPfmzmizh6+kCY7Pn5ty4dhK7p +3nyLezhrtbmakQeprseguvEyYUjiLM/raijq6S0DZnNu4kFlr8rWIKpBvheSA8VBwr3dMOqB2Glx +32SxC3K9lIh+g9jtI7Pz/OH3+sDdNhfui2d+4fGFRQvaOPQ9Iu8COhaGZtIPqI3YJ0emM20qNMgb +OAx2FPcEECGCno6gpyM3xDGYspUm8Cy4OxgF8AAXPFaCAX4IRJj4AXnkKJ2NGwU4SBICeQXn4FMm +2UwRM0lfFKdRyIE6+NXW2MlPqycLfOGp17DYU3K1oOqIiZc405GA57QtDrB8QKlJgTwApuM4bvyI +WvXs0wSlSDtlFWw4bjYchnvKO0K8hC1/dok7pP2Ik2WZ3+Y+gtukflt4GQYQvEZ8zs0aQCv7ufUy +P52MDx24HoQqdEFfCvhN4iHkuy3NoqU4REwUk4fd47VteKpOZ8mtwQD7gZvAKyGjZ+lXRJVNH3jo +TdDEX1TlHR3gMH/OPyvYjCI7Oc2+BwHo5HOAGm3QsiT9ZyXrLyKZzxl6IBDsZX1qOqtg1+MLz/fN +Sn/PR5l6x8lHmjw7K9BbzBuVUWcFbD3zFaihou+mOOWsJqCa4chygdoTVS4LFH28sSFSZUNSFuUm +oDpgWUBgQi005pHp8Hq7E3JNcm6le8SDMZJEKQ33UA8ME1foqoQZlxMqhN043HPyPBMT7JbiNMvs ++ZmpDOhWEX+Z8LqGC2dYhcdUBygKvBpm8GG5N6u78sON+GWVAKrXqC2EzS1OOzfcXRHbT6Mk6O01 +AjxCOIS41jNLZaDqSIVNlcxUg1wX3dnirdBxKQ0ekdKkZvDiajRmObQZlo32ES9RIOtr67fW14Cq +W2gJ3jgf9wKgswph1lIT8mbrf0/2kj5uhdDJbs6feFEHkAUgR5N8CkRFS7DbCsluTQ29Kv7lok4u +8YrLVJblYlWaqZebxMlu75F20dRhiA4IbGmanvcWPZHzQw/0lV1HtRyzTqW6ur3XDgCtbgjxvKws +sh8Ov8suW7OzgjcVLhYAx7l3+RWmdDK7NjfF/lqYeDZ5uXPsX9oeHI78AeZEwNYQU9X/QdL4M1Rk +lF1i5u9AeJz7wPyBecMdRpGWtS9bGJqeSmxpyWw0b/rKeMJHYhsAxbENWPkay7Dprho1OJJbvc97 +i0huli4Zy5N4nG1PO07DQBAVJRSUgIgihi2IrRiLnygSUSCUgoaG0qzE2pkQE2fW7CcSiiwqLsDS +UHIDJKQchANwBypaTH6kYDTFvJn33sx8fi09fy+9jXi9h5hriKXpQiIz2ycQWSo0apCEu3FZtVkA +Qt9T4l6v12rSqgThBKIVmEYtkaQNDOEGzZnIssvUoHZyY/OhFsxJrGMpMakkSERurELPLxUTZUeJ +/q/lot7b96M93gSFJZkgGnPCLCW8sP0YVTBRhZOb/+vx5ioUbOECV3Qr2/Ptvt+cD3l4K1Py2BUx +/6m648Lq+pEeP8oDQBo0ILbUokEA2rSlNQ1geZojG2NUaobdS/XxdDglzYZQ+KGRrTsrMm/4ZxAd +BIfHZfJy6YIPg8J9bNVd73z5fcS9yg8i7otC9wNeVyp8kx6ZzkvQqdSmw/F7t/FX33icATcAyP+Q +BJAEkOYUucMbPaODse9+Gk0thyiI7Bo2qu+R+s4Uq5xEvo8V2AklMmkdTHpsOWUhu9uT3AE0wUMY +rvBKuOwroXhAMtpXDsw1mnRQ8wFgTQ14nIVTQWsUMRilh/bQg0X0YCvVjwE1I+P0IqgtFYtUKIir +ULyU0mZnvunGziZrJrNtWYbFfyDkXIvgXxAPXvQ/2KOg/6Hg1WSS3U6r4mEgeXn5vve+vPl2PPn5 +x+TbX3dZtyekggEkEqnCx4Ir3FcRyJKvcb+DCjIpuhBwkeJiv/vm5OPJxFQyjJEmHbIxDbARUHgu +xf5BEAEJYfkhcNxzCBlUEQyqcDNq8kBkQDmsSinkX+7YVX1GAkXlDqogbBQxH0BAhyCxL3YxHbWu +cVdqUK8BEsEL665nGZG/YPwsuzuxBRLaznEkc8lfdEzS2KtSclfHYdU929DbcmOMu6hojLw/tnQO +N+zNUK8czz1QHSn2CsiEhBtFBLSAl/chFeigxjS3IhDtV5go70vPfL99x2xJGIaxEuu2DqkF4X7P +4LFj26ejjDO+Q/TP+PoVxvs0Z+mWmWbZRa4CqEIrXV88vKnfHV2AAlSHKqAS+S1l1tgtMO8bPV6L +/vrhUivxgVg+GxfiB+emzXgHJVOFYbVqLbEjkz8yoY/0/PyIXlfISp4oJjhk3AxwUOn3+uow4/WZ +80fc0y4swFNmnvKZiWRkksOMYgkJzXPwo6U8HeM5Umdlu1A02d2279hDqQ6gjR3G07iuuZOLNs1b +mXf1xGR+jRdsxoS++T/oR8dzL4gjr3eYEQ7qoIcm0adYXPcx7+cnFkb/6tAqVcFMB72yNDts/nUm ++qZQo4SvMZrX4qjrCHA9HSnj4+OMnx5UNjKrr0ua+zGeFTQce7aWg5KnmDGOafBf9TDmnhcZFEqa +FAanupqIzY39phUWiuhrh7OfLqcTX6Z+Az5MiTDwcJfsvVFbFNlmgFu1SZFX2QJ0FJ+UeJyVVV1r +2zAUfS8rjL3sZQNhGMjgqH3sMrqylpZ1D91DBx0LYVHsG9erLbmSnKQLxT8if2HQ1439wV1ZdtrU +brcFElu69x6d+6GTm8Hvbz9veu83ItChSsZAvV4P5rnU0ItDLyDUJ7tvyWKDEK6vREgmhQhNIgVR +haCMMa5i3SfaqETEg6G//LX5/Ay0JrtkvxBM53wm6IKEWdQng3EhDudA/YDUgcOAgJj2iTWIaYAw +kSxMn3h5koNXrUGpZr28fLZXIhH7yZUM8RjmIpiBuUHcthHDHzDCPDEQud2h/6Z6KjCFEmSxItLA +qySztLVZ/njytLTO1xv4Y0AbFkoRFkqBMNSb7jAN5ijlsT5SMjutyoIljJMpaBKH+GokMedAMMry +0rjghggZQX+akYxfoB+fGFAzriKNNXBlv20DISXGakNsv3KDhR7Vmbnt6Q5uKbgsEoXNdMA7HpJH ++JYh8+rMm+hzblvnTptmDJt8LE5gduDYUs9c5VDKCaZyP3IME6kAgzEsVMANNEGL63uuqYzRb4Bn +UX/YmLpLtzaNNUxJLALLC31OK4yAWFqWVSrHPP10nmgWh8EqgTX2jnxQ8/WDzjTtYdT3u7mVd8gJ +2eZ3n94DMK0Uv/4jRNmJIeT/oXSCaMPDi55OvsPu6+1t0lF8xDzuBrW9lSkwPJN+OP14wpwoJJMr +iluN38g93CAs+asXJY4Cn/HEVIri9ap7X412HYEUIDTUXWafGbmP49vQ2doiZ/YCneA449VOhNHs +blRFJOdKA3V32bcIh5cFT+mgmSavEBFMEgGR16iE1+jc7U6HU3tLFGn6WEQb9t3fvYbrlbDKdYD5 +1rXYXu5tvvyMiuxkJcu4iEiKgI+pDt6CRnOMlJ0y81CLGpJr/xOrzXz1PmprTbee1HIycoEdXf/S +avut1ba0Nq6q9ni5KquVJPv9A1uSISb8BO4WWd8GNX2YsVxcuwUP9BiFROzueJwBTACz/8wEzASQ +FBQeV7MiReSlT8/ua/oCYHKsnU5JWZEoURQ0JP+TtSh6485qRKMnN67bOWtW5LGNqwEU/h+txLQ4 +5WDMbT3xvXYvUnAA1BYnWyNH/awKF560hiAoAEC9eAhlNzH2q6fLgfV4nK08bXAcxZXVG4wtYcs2 +liVb/qA92GgXjddaSf6SLEDYBgzBBtuEgCSk0e6sNHg1u56Z1QdCGZtcKC4pcoQJNBxXIVd3qbpU +Kjmo++EilzvgflyoXD6cqlSKy0ddSO5+pC4Xkrur/Ejlknuvu2emZ3ZlAxVXWdrtef369evX73v0 +j//R+tOvr33lHqLdTA2X1gxv5qQxa7o1o2jSslOdpZpdLZmD+CAYIX+SsdyPf5Vc+iohbw0H3/5u +66Vf3E70QwdbKfVM18tq3oxJHdOrO7ZZotWpR82iRy2X4nCxanvmgtft0ulKdcqonJ2xGHmY3L9p +CWbjP7foWDUPht1B9ot7SNc2Ojw8TIvegi4BonkA8OrDZCv7r3NktZ+GcivVWm3xjrpd9KyqzaGp +U7dP2EcFAVktW5YPaTZHlyS9QKPlDtHlXDan6Ygvl0Zs2a5VMs/OmBKRQMt2jpHdD0YwbvQw+phF +ZCFA0TENL8QwMm1Y9mByLKsuzZ55hGz1FcZQz6mbTfiRGG/GAfV540YST93UcPfKlMfzlnNDwVK5 +f9VA/4GDBXafRbJbmshBuVq3S+wzFtHZ395J1rJ9j5LHr5lyDJu9+ig50oafSkAenTMqdZPRl0gX ++3CZDLAPnyMjqyUb2KfPkaeiL50Vso/NjpLW3SWzWDEcA7fsUsMx6Tmz5tEp05s3TVsKFwrc3exC +maxinxoj646LOWbpI4ZDh2n/EI0kI3wSclGVFHVWDy2w18bIzqMV04sefBg+D9P9Qyjzbjx8lH8b +pgfgQcVwXXosfMC/LbG/HyM960zYvKDnYHeOfW2MbLvemq1VrKLl3ckPHJ4cYpfKZMeNYlMC+LCW +yyfEHOVoqJWtK5EtbHoTWe9Tqo0qpOtN9qirW9CThOvUW6yZ1XKSap1KenWapFKnEXXj+Uerlr0B +L5aUMcqF+7xJNm273cxq/fqAvl8/oIfc1w/qh/TDGrt8P9nsnzMXXb6ZvFt1vGwul/eqx8/XjUp2 +VGLT0huJ1tGU/caDkuJ4IEl5PI472Me3IMfGgaP421yogURnQ82lrDLIzr9AOthN58nGe9XFIwWQ +pnUQWZFvchQSXhKr4A2HYpxJ+hXQ9amdsZEi6fJVckGq+WUbpP06nXcsz5iqmPJiU9Ouz5qOOgIC +Xbam63KsbFRcky6vvLWB9C5wuZxY7+DV12P7Pkk6jq2wy5jyQ+8R0yqOif3kRuDOy3OkjaburNT7 +KGBnZ5zqfDa4/KGuzTbYw0GqnVm0PWPhuONUHY0us0/OkRsZ+TjpuDYGvUuCnjbLpmPaRTOEznGx +ARXZmjCUQn/TGTC8dhXUnmc6RdBZVYerqeuFXACNuA244YUhdnGMdPp21TumDkuyhWQKjeMuzk5V +UVGc4R+ymhjQJBBeJzT3hr2YGxWPxgG4T6LwFkZ7x7k+bCbs66fqVsUDGzLimKfmbSFtPvcaxDW1 +7GKlXoJv2ojjGIuq6APVZmmQjibtsRhXzFm8bbk3nWrxEBoIGBwP0SI/3jtqlXsx9sRoegHBoUHK +7n+ObGZbzpO204KvbjZGHHoNnHVgvcWk2OSWzIW0H4IeB4CLieJqpnibMMzxHoWM89uX4EIEwB/p +fHbDLpKeACerP7ThQfbRdezFedJ2Pfp+9zlVr4pKHy4yiPx5j2xnrzhgO6c9soHZNbJ5QwIMNsI+ +9wTJsonnyGr2mxfIeqORP3i7QOfXwkmNV+P2ug0y5HKhy9GaAxfDpRb8jy81jFZrpuNZJnch2c8e +I+070ZIsLYcyjrcH7JM1jR4I3BL2/cfIrr0cZsymNHw0SAv6mM1nKfdHKAX25ilwVG6Zgc1ELoOf +dBn6htJKBO+NFpvOpMFQtxZBSI4IuhK6uS9BGsfREiEJCu9s8lGEkLEJD3Ip9LWtsoU7HEANlFwm +BRCukzoJkKkZy56mRcMGRyqijYJ/ZGB08FjGtNnnfdLOfnmSHImY1MIFoLfsmOZjZpMromoqFAGu +JulwUPjitk1ShZ4Nh1HXohvQYrl3wIKmnWW1h0B/+8fhVF6cI+3ZOTiI5KEUGhQ5rhKQQ1u52u+/ +opO3vNLkTaxtgbTtazzuwtAKRgS4XQh2XdMZ/OQPq9nFLOnMZ4sYTFHXA6Ge1sNTGERFrNNqjfuu +t/KvEALcwpYN0tWGENHDHPtUjhT63x8eapvzlD2yK7Njh4SM8Um/Bn+Ns8pW0rVXiqrUEKCxshqy +2BA7jXg3xZnFzpbIza3cv+NxE5ssk64ugTQUOK5w4OpOmY7O3vgU6dweh0YcfSwhIQY2Mka6OrOc +eA6C/kO2u9AdrrGVfdmAH1t2k3XsW1NkdRuKeHRircGGNdSXonQcpkaGWFImb9S+fXSEHjt18uzE +Ufhx/KNnT9zxUMjM0Cy7EJJMVRfCIMargq9h1MC7rQptftKcDzeTw5Ew2C1tNNGOeDOGF6Jkt5XJ +UV+wMyWxzdRIX+K6yGNRnUWYG4pZEoizbAWZZJUnyMYPAQR75xxcXPs4uZaN3Al27bVpsr4V9uAZ +50zQt+zn02R8I6xmhQYL6SywxeNkB5ucIWtaogds6x3khi3ZSOaT1ATvHNsS7Ni5uguv5ei4Dn5b +zXBcENwozuQn2iI9ErjwA7vJwzsjLTRbLdUrQBLKQB3UHLLVYu/8AagfexDUzqfrsIXSqszOoHpp +TfD6f69hjx0j29bTpfheoH39yqrM9uBfT+xkh39H2q7hniAMdbDfrsps6JOMy4q18naUA5FeEvC8 +bNQrntwi4Lu0fok8v25N3jSKMxCJsJ6L5ETnqGYkVKuUGnbLRfDblpZzcM/Gc1kAmsIAFYJwm8M5 +uKU9KP3ZCZ3OwgFI1vALgI4XSOq9FgqxSx91S9VZ8HhnrOKMVPzCPBrFoum6CIJRNFjlhUUhgSat +1j3TdyB+NSowFQZRc4A0w3bNPKCPbrVjFk1rznTQnctatm2CFRJ70KNng7Run7Or83aOCp/QKtNs ++JD7PnxiLgyX5f32+QUfaj5DMRLRtJBwR3kq54cpGxGQhpi4/Yqtl4NHY0Z8WQWMqdrsay7Ew7c5 +5Nqt85Y3o6DGo55EezrJ3jlJtrG1T5Ctq/hO2F9eIBr7WYVsDD47s5G9WYVv6AoeqCmej3Ako1wW +5+9g9J3SaRMVBH5nj8ySzj4NBqhGe5qwXOe5qJy8RdwzQ73F7psFw1eaJRs1zb3aZPadnRA7JzNC +KXIGaWT3omEIemt1d0YJ1GFEcjuZNUOwLF9qiC4r8LlsdLKDo7GkoCKXw26ez9UEUfRKfAjHwHsJ +V5DR5jKreWTHBgkXHQT72BjpeEBwfyiUj/CrWHCIpvJ/3XUIYgVM91AEjInA8JsIvio22dHZJPuA +G2D0GGm/Jvp0nbK31KMH8ehUi6ckFhLOVw1cVNNNCajIr8qLA7bIkPdcEexV7Hi9UXxbpLvlGMEz +M5uZe4Hs9Wt86jB3DziarGc405j4CeUEhTYcO2cuKgeiiBJeZslpgOHXWROeiZbDBWvywCeRB7uX +AGYZfjmmf4XzXp5UpF/KH4TVFVBE+ZWJGkrKCMh9GpRnDOQMP7UPlVSXk3qG7yILM3OC5A9IcXMy +RlemfFkOgNo/CycuMmmYt/WMSkVIQSTyaAkgIrI87n3oKCWWzW79O9J9w0Bff39BKFykNi8RwJFz +14q9AYpop9zIKa7l88KgZLlo5BL5w3sonZQIsspW0ZlxTBdsowt4R2VAuLA4HoMInKXbF894VQdT +FodZ7c9J54bkODh2EDZ05bTksKbqwQg7z4EikuuiITl/rRaNaDk28iWyqV14p5ONyUcf3dOD+mGd +u6iH+C8t6UpxoVAuPb/tMRkJ15Vr5dRmGwGUydfFD8fZ/k+Qgz7XANwtLS4W4VTnq/VKiXsEcNVn +LRfdpr3ondBKtXquXsNfNVqGlebwEMEpRZUs/FALozS3PgVniQaQcntnUM+aNcGs5ltRzeRBLRTr +jgOOCChk84DnYbxnNCvWuIrIgeaBNWcREMkMyj/bw974J9LKagOZ9c+tAVfsvl+tYs/8G7l2neF5 +5mwNVShsPli/vatVXg74yn7dSton0K1R76F8buI498SiyyHuhho+8uVR8MLpGnhCZqWsDQqRD6V8 +QEq59EwiJ0VXptEiXKRSeuZdTe+HwLMSommsYzTF5jfF1hR3M+QTE/wMJiYUvHSuapWomJWPAIAl +zbDuiOyoJpWTiolNzF9lw9FsXhsUhSQVg6CCR2saexP9lX9+knQdUty7XMrfi9ODnHUQGoAshihZ +7Xim/Voxxi60AbpvXCDrQ5UlxhvULmf07eJh4sTFUIORiI+syeLXKQ9iCvqb8kgBzTUaA87csgKz +Aosb6fMgqK1Pw93FfAzwWV5OoDO0Qnw8ChbAVXz9AunamXjYnJ57+cOQS2krpN40UPvVeZ5Ki66a +YcvYIMGxG8TuEBBGAbvFc5KFEB2njV75COkoe/cF0lFqODw9smQSsZ4QuWhYy43LpEQjO+16paLe +y1++QDq5rN4uiUIARdTnMYSfN0SQJTcnF3JFjdxKcmBjzIFoz1WImjEjulblNGdFezNW8Cer5ZNg +44X21eqp3ZIU7ubHBgqaZmU5IMxhlOno3Gyeh9u7wMtbHo/1roDkliZ0DyZuI1vZ0RGy8XjoSEs8 +3MWTR09vBTx0MHwWy69AyCnknsF4cPmhdt9VuJKgcRQ1vY5WYRzplFcDdulYpptdovl8Xih7HT+G +0ricS3iifDHhwuFOsslrCE5Kn+fyhbC8IS1TVqSZ0EeT8w0vu7eQE4F4Nhdc/PbO4GNvr18jvZwc +u/wWxH4SdtaoZSPtJ9kkJFJa65yUQ0EJmySZ7PNvklVB7y87WO/XSBub+Bw5uJGGZnmQHuid6O3t +Dd55etEXnIm9K7HT2MQpaVI9ehSZseZPE7apEUS1MH7j49hoiBJDaxNj0HzdSLdegawIRiD3W6+i +/lQaVGUkUo4FvRCuIK88/pIj7+VS+1pcLeEiK85DeF54Hry+FVpvXqcOZSRfMe1pbyaXL1vgLmt1 +u2SWLRv1kqKWJDoYR2SuV0K3zK1VLPDFxmwtdx+XLnyOwsU/5MH/djz3QXDlstoSxFe30rvPnDqZ +x4yaySFycBf5b75EWLsTqzDyhcwNweUnVu3jX7FaJujVw03ptHFEA+f014czeTbzNtl4FOsusskC +Amh5Fq7Ic2JSC/CC/gUPsUpLplmrLFI8v3lwFU8b9jQ/eDZygLSzyYHMDQlX0VdQK1YGHO5GD2PK +cKMiFnrVK/lDCIep1JwKDLRgyIt6QJ3nqxPLwIeZ5ExxhCCGUaZNnR3GegLqPlGfWgwNtBZNwfyn +zAUtJ+vpbPiTpOXOhuVEsPg+lhLNMz/4Nhl4IHZxbBWBJnUTr3QmPUwg7dS8HeI8ZorQM7FVUfCN +H0ULh1hjls0YLmBTl5aXRTyIZuIxhdOkccB8uJwFHEMAxYfYt8+HEKkCQU8FjQXPFKJucGX2uoLx +jnwAN6Z4DuUTFATwE0a5SOl0qu5h1VSI7my9OMOn5aPVRzGmgrCyYs1aHhqM0UKvTk/AgdmWVwoD +XG7CRPK+5s2E5SD8eGRYTKU33URVHRGLeagm5IyentiY8a0Hn6lvYrXbyBq0wlvuCm0ZJlzEEnso +pzHH76Fl180mhpVHi3DO8bLsle2Z7R3xd2ERxWGwi0+TzX46JBNr7srymEzkIewimrroTmMwJC46 +hxlSpsoafHq9oRR2Tif3LKazcD65Jvznm9Yle2+mfb3Bxokutu8l0sK6DmVaD6MSx/wGHvu8sUhL +1Xl7UNNX5D5XxRiXB5P/c9rnYbc7iwiEzPCFeVBdBnURqboqkFUG9wMsRJ6OKIwVkuSes2quInnF +GRN+ngNdCFauiuF1zUDHyBOSZtpz2MqSzwcvPb1xeNZYuM90zs5ARFA6g9MfcI1pE5sJj5lT9Wn6 ++OPwceTMyElQ/NrAfnAUejVQ+FoffmI/eiHz4875plyg7MKRzC5WfBsimNeOZNYPDKqKrDtMfWOT +nhLxg9jwQ6B3nzgLHgp79W0yxZ56kuxhz7xGrmE/fgtE8zvvwg99hKzxxyYTWaF5pwqbHaa9yWRR +uKai4/Gf1IlUi7Ox2pDILSIlu1JFAo68p2coDBjg1p1Z1hV87gfEpyABZcN+PUR2KgVKkBXgJohM +uAvFX9/Gvv4k2epLYYuSJXoyDoq2v6w6p8mUtLINfpGRbRbnJPw6Qgt42PBR1RfiH9C2l/bEyw2l +n9Lh+CF+ZsPDpLM9pyb0OCfGJtnICNn0IRktdFlA7KRSKxYVKa5rPct09tZrdMao1UwQKTSvZWsB +8MMi8mKgxgCJRuU7P2PaJs9eg3hyseLCDk4XqFV3Jh88/bQWtAYbMr1aUPjfP2Of/xFZzdr6M92M +fiHTSnq5HMd5MjdOVulUaaoSibMpk/t3uPEmZTleJxPyLbNpYlZ0waNLnE6WHU50cPGrAltL1f7C +QrLlcjMjvPZg3cYd7FeLmXuja3Qt++hthPI4ix2+jWzi4cV+YHxcJU9lBhTl7tRtHtWJGIbZI+SG +NgGtUzn249tIV2e6OVTAjKMlyLKHljIbgne/tYV9c3tm7bVmHpsLWGEYNMXjRqaF/eT7RGPf+ApQ +9syfZs5vCIMS5CAKEXt1gHQOYppaU7d/SoaHhjNdn0WVNFt3sR0X1Q5sThIyZk+yC4czffxwt3J/ +HjxfXg2S+PlH9hdfydwYHfpxfmTCtQUI7u8gl7lPfxJLmo+6Ui+AOS9xR2XKDCu1lI5qPBsrktxh +fZMzi49wAR/VEtEAgvuN8M2S5ivWeFHy1U74hCjuccNaDi7lmBV+cXQVNl+KMjzSsmPLFw8rMGQX +7Q6i8IKAwd4v3uA370iE0BZ0EDcsk7uXEGY5lFIZp0wma1EydYwVnEleJ9HlveFGG1zlamUOVYGM +1HCTCKUFzul2f5p3M2Qn4koyGOKQUvq4bEzje8tGBSTDdueB5BLmFwb6KNacJWm5hvQGuHalCjAY +LwJ3rkGJCy9bh2c+xDniKoTtqvGz6BGGeVRNhyjoRZkMkceFMvTd5bJw0+LxJhCtHASL/7ngu6O5 +dvX0wzpLQF7cfLRkOcAda477qKMa+iWJ0qQ2nlT3yUYd/o8Zm8hmM/wGZxvhXKajIUujRu54oG43 +PGwyxMPdcWkGgi8tbDuJH3Kq1VUqJQN92FfJ2340PT4+GIyj4cSXcXbeyGz1l9OFUBQ+iIxT8sdb +NELRw4IEFzpeZOt24/5AftGVzOhKYhNKxaAfkxqJisgcYGVNmC4+rkiPFKzm4iNo4qtEjILZZkUk +RWPuCWVyR6hNFBiFxYqAKThiWQwB2XefJNt2NoGIQIQ45hLi2FgJjqZxGfX/CDKabIJNySgSHMlb +4osx5Zq27yWFUVctMOoN9O1AQkO1uZJsFlTRTMpjOXqHQLTP5lQfij07R7qGkzRzwjxlzbgPLVbQ +YA84mJbjQn6sQciLWNhFHLM1fEdG9qei4eQl3egL91lERIWtrx2+OKhBetosVp3SkbAlUDZe3MKj +5yKg9LBxB/btzVtF0PtZG4UaOSA6BDGcSib8r9AdEJanAZB1LZN1zXTaUPDmyRtbwqzwUFxHBvU0 +mSoac5qyA+izJFszks572PXDoffnRI+GWmcW26Q92O6LxeFtciTXANPTwwF2rgiAgXzvijCixisa +4hDmiBzRw2C34XsDDrl90KbBlxc62aJJrscXGTDFAIqzX3wqFHT5QgOXxecXyA5fyn+0gkTN28gV +CZSSnszc56NZ0YCcnap685MOH8qmNzHFF+l/IR23ApVgm8OGP/DNzoiGGXQhadWuLMLpVR10Daor +uT7dwj+PNXY+8uE8pDZyjFD/zhh75tBrsKu2KeJnjOjCusSukLBccLFHvOOxNdndE5/u/uD+j2z2 +1RsqnykNB2ntlWzfV3BdpadIFcyhWASHqC+6jMKVG/WWZP1BSdJya9qICUajLhYKhnfhys98vfhr +T0+Dut4otRdvmh7PAXL26TmyM/iy03brldVYUl7CYd5aKA6D+fOkq4V7idgvw94ZJe2FZpYmNr3S +mir2N8ffs7kx9kX49iKkqVd1HmrSPN7k1RtYyjNll2TsUbjUNc2VZDQ4f3oz+3mF7PnolDlj2aU7 +OQrgWkLxtaZNdGzvk4kOOmcZAkUU7WNT4O7gLX9dpjAUFHZ3bFccg6Xos5QL1AOnIxyRSYxGxhte +CVDJzuWaW8Jx5thkv58EVTRJrIeSL0tw7kVNoaPjozxXN67aEoHzLABelWfBD9p23YvJoIkrtJzh +P6VdazQByPVTvOJ48LrfoUWBhSyegepSiBqkfZzr16c5LcxYawzKVTAw+ix3QmPG85Waq2DFD06r +2VRzkVx7VJMItdQrPPLBbPrJeKx/z64QXwrHtWIa5zCrl9TGeXoCA3pMwkxhxlL2GQrXKs9GniBd +vmBb5GOldgoqCslpIhenAS1c7HSw10RGQnd8uPECLS2zH7aQ60tSLBBxUhqipYQ8cADVbws9By6A +PMVs8sq1UDj9anjJLu8k7TR6TyAtw3cJKrk6O7KSOoudZoEgJk/k+zGVx8gC2TYdH3QCfcjU/iby +wvGUrQpqD7GhW1Iby6X61bB+d560n+RQPEfNM/Vgdx065XCRMDBHB16ZZWBbgQEMm6ueM8MuctSU +htL+JZq+QCf6HJEtzywuBmQ1+WBqMU4GJN/7wef8tNXojMoagpg9pNaD4nzXMI1ef+kUzm5DYiZ4 +2dl8OPlWfZOo+0ovIvnNbIn6IlbYN8DftVBjEk1fKUiTVi7c+nJOfcmI7zg+7tHoPY7RlQKevIyP +wo/jV1qZR6ty5eAPx7ew7z1CNviFULMUmr7fLB8iGdFl0q4Wo6VCtHFt5eB1r8qYpmVHlVvYstnl +v5fQLWWgyvzFsbgjTr6YtiQIFBF24/szjYeJeHzTTrkrhfAgG9/DUSSkObYGZH0pqQilL9qQz3e0 +FIq8vKe6/ECXYZccfR4HilhWTklCuFUxIbsiwSmRlgvlOpoTx2oXSEchWqehRXOFOJI38fvhdw7Z +5CQaJY5bWg69givzXreFSNam/cjwle9Yn+HlZ9+5PaOxvX1kdVV092u8NUJI96gmo1SdTiaC1knx +al0uq+1xhbMuDC0vLcjKrEilYh0FC0vuol3k7wFFOYbAuHiAPfIkuR9LlKdsUxYpeesvJrUHseIS +hh9cv1surSBTdVTxmFOwKqDMDfyjHdQoo+tqyPLcdN3EP+JgmyYQNYsdy1HVhgdt6K1Kb6Fi+Kgn +gcy8Ei1HQcgwHZtcsYylZkzU6lb83hEw5S442WzazcNUAY+PYIHh3qHEs2bFMV4JDatjYiKEQSg0 +wRv+Zp+PqFiaksOzMcDpK1LzfonBSHWbRffQAwPcVvcq9EE4m0U/9T3Sh1J8qnxVfr1/CvtpVqUQ +WxeUaydcDHnHJPU9Pe+Dr4LuERmp/hEpH0TmrkB5GOIi7Uoj1gcgn0vpFaiPsGNWq1cXrRDue9jO +Len9JHGLLAdur9DbFwlPDMPO785sYb97ObNmHwIqG+YtTQAbU9bTo9ISGHdvZ799OdPKqp/LrNqd +j5swUiWjnNxMTw8b/3zmSPBNv8VXtttDNSVuxwKe3Ds+SKFaic1h66+iC3TlJuoJqYdvexPCpCdP +R0kLYo5lbBLT17ubp/zVN4vo8rP+5oHG3GdkRHW8q4rtj7z94NVPdLHL75LVvBniGl5ExRq6jy8O +iXKejEBdbRliD7HGYPMXb5Jdo2Ib0QssUTz4nmrw/R+kCE9/cFOwNmgLnnpyfdD2m2vZxJtkPVv+ +68xfBZefaPNjZ1AIrd5f6Nuv/OhVZKFw+EBKAHiB92oocFqMpDeBIlN1nv3CUeN9VliT3Z0GFa/6 +0vhVX9k+GteLgsIDdHvqeNQ/kAYe6WfBIw0ddDyxq7nCzfIDnBVK3UF8VzzbJgDjcXcnW/os2ZDF +xRuD8gS5XKQuPfcU+X29H/+GBP6tEbQfnlU8JxwS7lGAIrQqGO5V6tOW3Y15Ma9ey+Yu/cPviUWi +bs3nHsrcFXT8dP3DWoxriWK/9mKtin+yY5COduf3LeQfdbvHdYkNB5eocK+6uQR26wJ/eKNkgW0c +bq3GXvl3ckOHCAXwrsJCegjAXv0hab9ESOaxv+F9qXfVbScUkaj1QvwdsGnDmTKmUSgqFd4xgH3z ++CdqMCMhHBvwYbA3EA85qP5s+wrvMgXd38teH7s4oj2cLrHzPyS7gx/8Sys2baT/EocVxRbcSKQB +ZH8NZbu/R7asLfDuUDGFXdyd6WQ0R1rYi/eR67qSqOSrULxxh735FulgW0bI2uDh7+/owOT5R+4V +fyRJCC+99Vb6/H+S27DfvIW9dDPpZ5ffIXMrdNXwThelV0JpS4j+mESoE8uW44L+1IB5Gh4k8L2E +7dfzVU0GG2EzxWyt6nj5WdMz8qY9FyFLjPv2nGyeUBp55B998czotUdZJuAdN+A8L1RBgJvd+MH4 +lXqlZSNunwA6KK8XYEMWUnUIuat857WzK24RJ4DAB6+f3LNNrJFNZhUqFnZDs4lNZAvJPr8709Ei +6tbDdPTZFzv8sDdT7UTjACKPhR8b341ZwryoO5joalQQ6FhOuYdDhHZNDiShwAnpPIFVQE5Q9EoG +yhT7v/UQlsm0V5Xnq0QklTdQj6HwQiSBr8aOapw/4t1GZE069BIMiLVdSDyiVSgVX4EkpIgvudwj +MvdoksAHWJTuTvJ44CcHulT/YuZEy/8DXZss5/ACLA6FVf6EYRjqgBxcG5eL+JUNeTB4nLvFdItp +gxijCPP/I3Fe7xrcXt+NnNCT7Sh5f//TH5O1GA0A8aMPIfQZ4ZbC1RNkSB6kviDsSrz5WFmFHD94 +nH2QPUsDQRCGEQxqAkI0mEIDkxMhF4+zliSFCEGioChWYrFc9twje7fxdkOUGNTWTgbUKq2FFoL/ +QsE2tUW01MpS3EsMdk4zn8+8wzzdxL46sYeV3o5NicNye8bu9oZhQeRAuEACoRgNwfPrnPo0UER5 +IjD2zZwhmWjwKjRFWIOmpxgQWJAaJfI4cKDmBVU8qyylGiG31ZEyzEIctHGqoIGvlbnTQe65kItm +IVsq9VUNE1r9DoAjAqmgBSykrgX1UCjhCG4BE1IFxKe6RhSLImhDCbRS4ZfUoS78S6b/UCJBCw/Y +NmZnitgpJyYZ5VwMz27j5UsKu29J/HweT7vS1jt9T1JpN4nSf9OCpnmdWR9Jj9h4vzaPU+/TeLU1 +Oxo18DyVwZPlPOYXE3h3EZ8whk/BD6uIt4dJ/C5nsLuZfFztjR38ABezh138AT+qHkMRxcx+KHA2 ++E5yJyUM/QcCeJz7yPeRb0Msu0hK4eJQnZCY4J9BL4Lq3m00vrzkiggAtMsNV/sRqoH11ml3+8VH +1LWCrR4Y+2CfjM14nI2OsUrDUBSGqd1KwaXuP4FiAodOThUdnZwUp1Lk9PbGG0juKclZQikOIj5A +BlcXcdTNUQo+hg8gdPUBepMncP34/4/vbTt8/x5+LGg0sWxcPBsAsyjNcjuNCM2Ojg/n1LElK3ds ++Yr7wOZJHKmzaLeeCwvDHgsLxrjCzdUlJAV7CZMSWbHKbWG9smbig4Sr2hvEt4Q1XGlTwqoUFSM5 +wUmlrTAwVtepNwnOzrEOHUZ8pWhe+qOL/zwJKtdaZv5uiriTtB9sQkDbmJwOGvxEzePJ+Pnrt3f0 +UNNTTb3Pmg4mf3s6fl4K/Qvq9WxqhGgVc+YEfH9DEmukX1XQHHicAb0AQv/6B/oHkGIUGQWvIf+H +Xg4O7NS212IR/vqieb6RdjwU3GwnBLum8yVd/KvirE+8N/btOPmRxpAULayPArroLxB4j66Lk3Cn +ew61Y0WTagEqFCy5nYfwOlBtWEnuHk1URdWEAssuk6gB2xQVUBrz/0kGV/RS7TOTcPuHwX3L/JMc +AhizrwIVATYqxny/uRVh5DMgyOyTcCkmrcvOXzQwMDAwIHdvcmtlcnMAkkYf9W7MlPFabiwFVicn +1hUa0uZw7Vbp/Qcg9v4kXGH+BxRkFcdygPaK5bD2g3icAX0Agv/QMNAwsIIBPALTER65i/QupRLG +HpN+di5z8JGYMTAwNjQ0IGJsb2IudGVzdC50cwAcuQxW1U1gG2HPG8a3eg8DuvCxlrO+AYQGFA++ +GoOg6t/nA2r3sElL1nSyUwIJs1YIKgkUa6WWQ+pdz0BjKg/qQ/tFYsSfcq6zlBG8BrnoNSv1ApJu +6T85LarsjMUL2SKwDMs+AB6zeJwBJQDa/8YTxhOwQgcUAX7b1Ru7j/C93uR8oGTlhDl+sTCTzwcY +s24HWAJUJRFH/QO1AJgxSgbQ1x+skB1czyDMguwI4nicAT0Awv+1vwPvvwOwWC6Tv14Mk4V0F5Mg +nBOTlCQwkyxqCpOfnCuTSWoMk3AnEJP/LhKTQrYcAndzkxxjGbMeL5ewEnwYKv4BOwqf9SlVAH4N +NEaZhAhk/hRZ3kF4nAEeAOH/pgGmAZBkFKXJIgEmzOvGutIiqTeq4iwXdtlQkXguzmANvvcFAZCA +rI5TwpRqcx1bVIolWKZyWBJ4nAFXAKj/xpoBxpoBsM8GFAKye80SC+GdA/XwTRGZpnpHB2ues+MG +tQUUeF9h75UKNgsnWFl1mORRXHcydIyzrAyKKRQRqaxmveHVpccgaTHm48oraW1A0bNKNvwWkhEn +WukFkLZGeJwBWQCm/68SrxKwXAMUBATYX2EqD8eydIsyNssgdupDVGCzcAMVBTPOeuu9Pog5RXlR +fr/fJ6d21S9/5DQwMDAwIHRlc3QAh9LL57Pn8QPlECHhpM0xWndMf2KTuAh3ZDAmp2yQp1Z4nHtx +j2nXXaYJBhvvda0DAC16BunrA4/GdnicATsAxP/kJOQksC0EFLlB6eDbLVIv5cYwLMAOycHm3yiJ +s0EEEgQUOO07KJMFLGMbwVIV/FD/7UqZsHCzZwj9CScgGp7xAm21DXexPT06pugBlN4+LSEfQPhM +eJy7w3eHb4M5k4hxZ8zuqBRh+3Apr4WvnK6nf71+c+dmbyZBVgDlIw3v8QLBsv/2zMov/K6F9fIz +9cQfjN2INHice8v3lm+DCJvIJZeErTHOsef3HbVs4dvd0XTodvDbzRpsrowA/vgO4vECO0mGayLx +JXckbkcZQ/OyybQ1lGV4nJvHN49vw3YWkWmNiQ8CXrY1/o78YdefyXHD+YeD4+bTLMFMAAnXD2Xh +Ao6mWXicW669XHuDnLDI++objWY+N5dbmn3NzLWSP79aXr90s5FwKRMA9HwNnuECjJhreJxr42jj +2HCUUeTC5289v+09z6VUX/1bH+f6pvyJ1sXNNxl1mQAiLxEO6geMl3x4nDvcy3K1h2VD8JLk9Jz8 +pMQc/6Ss1OQSXbvMvJLUorzEHN/8lNKc1KDU9MzikqJKDU1du6LUwtLMolTPFA1kHToKZbk6Cp5Y +dVlZuWWm5qRYWU2uXaI4eWOo9uaCpcGJAIxTL8HhAonSFnice8b7jHdDNLOIT+nbcxPEzlVHR9+7 +rJTk8+KP9t7Dm/OZy5kBDQEP2eECiPYReJxbIr5EfIMem8jvM9Nzf/rw8y/auvT7gUe1YSw1Pk6b +ndiSWAEA1g514AKENHicASAA3/+vEq8SsKQIFIqCVe2bA3td5VagZjs44OU3++DNk7gId/KhD9nh +AonTI3icASEA3v/mDeYNsFsDFB7LrmEdk/hv1vg+HHmauciiPqgks28DdwMGWw8f4AKAD3icWyK+ +RHxDIbeIai1XU8GxazduSd378tXjQ8TGN5Yhk1u55QH0SA+A4AKIyAp4nLsofFF4gxSnyKxHwtcd +OJrkz/e1/mRly1XvLHZYPlmPczEA1eMMyeAGiL9geJxb4rzTYcNdxsk/Obk3/2as5p2sLqA4uVlU +dHK8gO9kAzHJyccFZCYfFZs3uVPQePJhcXeu3NTi4sT0VE1rrsmCQsqTzYQEJnsIFUzeJaTODBJ7 +IVQ1OUVYaXKHsNFmZ5FEXgCodiDY/wtzhBupSSyn1AizflNsTADQLFFsm3icAb8AQP+vEq8SsCwC +FK3+i9lO3ie2C0NT6v4WW3h8izzTs0ACHAEUBATYX2EqD8eydIsyNssgdupDVGCzcAN2AhQx5euO +ur8gWlNJvXRz+b1W/ICU37P6Ba0BFOyaF7BrqfzHFENb6g69s7yshfKdk7sHhxT9nnefJrTk5jBF +NAjFeTFjMuz2IJNWCC8zyiCbn9/mq+Gj9+BSdlu+s/qSqz80MDAwMCB0ZXN0AEfKxXgLphib9JYj +ANz7xuYnuBpWk7gIdy7AWursAZC8aXicO858nHnDZkYR9gOzPF9xBjK3/2gJevtA48X/szeKAbPC +Dkf6A9a9QN9SmRFX22ytmQey0osB/amqeJwBOgDF/+kL6QuwPwMUjRwASEXU1cFRi4G/vNE4HnEq +V9qTUwNoFC+VEh+hewqHMkjQ2GaeqnqrHeFAs88DGgLK8hg18AIYq5wWOuxO3u64VmNCc7QKOm4P +pnicASAA3//IBsgGsHcCFApcXbW/gX7mImf3aZNdlOnOZ9X8k4sCvfBOEC/xAlkxoaoRqlw3oGXu +bmo6Z75in68seJwBIQDe/9MR0xGwogUUgKwigKv7yA7m20I+984h+AVpV/WztgUdAxUnD+X3BPOp +TCi0mzO235vg3ueMmFba+kBLeJxbxLqIdcM/RusJkXE8l+9uKl2WdkzB9G8oS65k3UsTAyBQSCrN +0y0tzk/OTi0pZqhU82GI/5HrY9gg8FOt5vSXNe1OUpMtmTIBG/UcoPECEHQFCjPuUg43Xrj+YbWq +5ZBOEoh4nDvHdY5rAxuzSEVxkFplvpHuR+n7k8/fY9XiqNr0ZbMUswkTANgzDLD8Adx3qSX/BAXn +qtgkuzk3d/fY0UqOeJz7wPSBaUMMowjP4lflmlzTV6gvKp65zmKizqTQg7UAqh8MJf8BBuNrvwdT +nvOHWtV4sJxagCb3QL94nAEfAOD/1wPXA5BTFOmNyYKWr7PyAGgl9jWhbJfmFomZsWdwAfr0D1r/ +AXkREyLfsc1netZ4QdpFjjPciiHdeJwBHwDg/5QDlAOQaxToJHBygbz5oaAn3cSU7vXHGE68mbF/ +FQHycQ+q4AaQmXp4nJvbyjXtIecGrv2MjpMXXtBQzixWKEotyC8qSU1RKMlIVShPrFSIMDWwjC9L +LcpMq4xPTi2azHVRTYRLQUsBIqSQnJiTk5SYnK2z2eUiP2Pz0kvbl15iPL5oe24pkwEvAO57JPn5 +BRch4eGxADGOAerZej8olArIdctFeJwBWQCm/5cRlxGQwDSHQqXnsYrh4y/wn+I13fqnRegnKDQw +MDAwIGJ1aWxkAPTKPCx5rPNk1ERlQC4oCRtM+jqssfRYAxRgx/+d4SNmbOloNHv0VY0b89hFo7Ng +BDcEg1opxO4CkIQGeJwBLgDR/+z1AYr1AbCLHJOZHHSTazkZBT09PSAwk0Qd2rMqHts1syNUQRyT +0nMjs5hwVArCWBJG8gbkjdpy9YLllX7WWnQqr0MPuyL5MHicAWIAnf+6ELoQsIsCPL44M5xRVL7D +JXZwn6sAYlRaQyhtMTAwNjQ0IGNvbmZpZ3VyZS50cwAFE30znel48Xj883pYMEB5CP326ZPHAjsU +1AYJMmXaYlmtRr+vlJCFssbptoezFgMkBZqZKXDjB4/9EHic+7mA9ek01g2Z6pPzpTk2b9G8zMZt +pZCSk1+QmqehqTN5jYGMEJeCgoKWglewc2JOTlJicraG5uQ3BoaTW/TlJjsYCrCCpScHGDpPfqMv +vXmzoZLa5k/h7qWbS89KsG1uvMpuOvlTuMj2jVyMVXbbMz0ZBdgBG6koOfAC43Pk7OyYwyMlKpKm +RiGxIqE72MN4nDvLfpZ9QzGzyMnXrkWSpjaKPTv2eqndUfZYZHrNaHI7sxsA2gYM8/sWuIJDQ7P4 +T1mjYwNiXDGkaPENBat4nGtbw3p4HeuGNaKTN4ixOCanpeuVpyZlZ5a4p+alFiWW5BcV++flVGoq +FKWWlBblKSgllebpQlToJuaX6BbnlxYlpxbrlSQW6aVXKVk3rxTdvlKU8ayZDi6jFOwVlJC1KilY +KUwv82GcKaugpqagiEvbdn5fxvuM0+8EMu6t19dXCAZr1s0HGZiVn1SskJdallqkkJlXXJCaXKKQ +l1iSWZaqkJ+UBeQVK+QXKeQmZqcqlGSkKiQWJWeA5BIVkvPz0jLTS4tSgdoKSkv0uBTAIDNNQQNv +OKiBAqJaISczqdhKITpWB6g9Oac0JRXKS8vMSS1WqLXe/tyP8SvTdCkrRpXte4MYPZkB0fyCav4G +r8fn9XtBjJmziGEqKZTq2QdKAAB4nAFuAJH/xiTGJLAtBBRCpfeAQXEx5fzOmEIWn+ql4onwkLNB +BIMDFBxfuM2XX4yFcDmOyL95Lw+CsvH0k9gHexQk2UGIDi6fAcwvgUqnxfRCpOtsULNnCHsEFET6 +oCOaUeoEqIfNxhDwzQRGlnx7s/YMUAVyKzQ/8QIewdYGslfp0+gGjd5WIYXao/2cQXicASEA3v/c +DtwOsDcCFLeGkeSJboHaqyL9oZw01hbV7wCRs0sCEQUTSQ9o8QJeRevoiRmpTHj3uAttoyHiPfOG +Hnice8v3lm+DCJuIhGWsetGhaf7T5jbwLXQtrHu2du6xzRpsrowA4IkNdvEC7HKvYg5yWy52vjgy +zztpK+rz93N4nHvO+5x3QwOLCIOkQe6i7t8Rpp4KF9wu3TqnIJ/csXkKSzATAOUNDV/nBY/EcHic +u5D8IGHDJVbBtNSS5Ay9gqLU5Py8vNTkEp3JF1l/Tv7AJssKlpnMzG4EZemzl2w+zp6nOFlWq37y +Ay2FzWzac5nY8pOygLomx0qbbv6ne4kZAAxGIez5A8FnxuHgQtc5awa9YqixEY9GKoxXeJwBOQDG +/5AEkASwXAEUa33prPVX2MGx7pJmuGItdMvPr7STcAEUFDYSQt61bi3XAAcBO9mimQsFcSwWk5gB +eP6OGHT7A8O7pxE4KFbUzTRXTXNaASPLPC+seJwBOwDE/64UrhSwyQMU8AvPl5U8wSOF1Jaxg5G9 +T1CttdWz3QO0ARSF8hPnT+jPda6UO5Db/wn+tgBtubOlBYkEhzkebuEBjtlUeJw7uJL9yQr2hi2M +IozbCxkZAy4DAEJgBpzxArKKT5tWTq29KdTwEEIlXFt+4jlaeJxbrr1ce4OEgIhdZMRz1u/zpR4X +JNo4z7b2CpBubNmsI1DNCgDY1AxO8wKOncCsPO0e38PZ4KXksA9VHLICCHicASMA3P/2nAH2nAGw +DEoUqsaTw4lgrsmdkJLPK5qPVt57+CCzIEpWBElfEYfxBdn3D6CbpqQRmAazAJWCbd/jzBraeJwB +UQCu/84Ozg6QpBQMWFXLjBo7/jvQg/wSBmEuWZKZRrG4HQUUxu/QIEVMLQCy6FSaynZ1d+jXKp2T +6QV8FEPOeWqh5ge4yp6kzXxxbUPRC/Cqk3kG1d1rJrnxAuDzvaSkm00vNaLsuPrV0tCfBBzqeJzb +IrRFaIMfq8i1wA6ZoKfSvcotLwwfSF3e6fYu5fjmJNZLzADv8A7i8QIYyS3dqQekIXleF1M1aC4o +Sunx8nicu8R6iXWDB6NIH8/0n/z75U94+780WR9hYNBatXLx5hjGMkYA6G0Ni/ECQqRZD3ANf+iD +oTqreMkz1vGMb3J4nAEhAN7/4xTjFLCIBhThWTXi55kqDwfIcIiHr0xurvK2urOcBscDDQEQMegG +i5RReJwBaACX/9UI1Qiw1gEURLK7uo5/TwPEVsqBvK3zVRu/4Dyz6gEmARSh0oH4TarkXPLlPg6W +lelMuH9EDZMkA0oUvtjtKieBblGt8tRQquUOhH4hFm2TggO/FOqqiYzYF5VAUQIV6uindyqXSzcB +dtUxWekDi5BoeJx7/4vp00+mDbxekyUzeDY7eBkyTd7gKS2rkJyYk5OUmJyto+AVHJaYU5pqZRXq +5+Lq5unn6rL5v09BAQCERxVL8wUuzxi+8pvB7cucteuILCiDNe7R6XicAVMArP/mDeYNsAMDFGu6 +wj+Pmlj5g38fTHEjuiMY5t6QkxcDRBRhb4UnKeXydnw7X8HpzhjAMBvQvJNvAzAU3sLawNUFpCib +UXNbHfYTYdVL9PKzswMzAw/PJd7/AWOjgxbM7wNGTd1w9Ku1NdbRWpSSeJxrY2ljmWAqkrRKLXSx +0iO/R0/yHDZU5c8vW8BvuNFzLyMAyKANJK8EeJwzNDAwMzFRSCrN0y2pLEgt1itJLS7RKylmEO97 +8ID77V452wWrt3x6KGG7I9rhlIkBECikZVaUlBalMvTpZPk4RgTulU22fFCY8YM7vy7cHQCsSB7l +8QIcCfU+0K3aKUM6w9Q6pEg4ieMNhHicaxJuEt6wk03khakAR1X6w3WVyxg2+n14/IW3qlJ281m2 +rUwA69cOkv8GWctsh4ummSEBEe5icLt8CaJyG494nAFvAJD/8hXyFbBVARTBbpL1WOwhKE0aQL8m +CutNVGO4UrNpAX0BFFNe834Mg9Pc+/nUjv5MowiPj4QBs/oCxQcz9XpEuUAUr5qwn+EQG58QxGyV +ZiY0MDAwMCB0cmltAJE0KM2dUZ4uZ9yEqP5TB6gH+XSv8Fsx4OcBiY93eJw7XL+xfkOi9eYsa2cm +Rs3JN230Nz+zvcsIAH7CChH6A1//sUiz8uioG8ZqHGNAQb2zCs99eJwBOgDF/5kTmROwBwUUhZMk +ms7JKS6D/h8IUKdlR+hgQ4KzGwXHAxSa4hPXQAiCH8+OhfkFBm0niXNAp5P2CKOkFBfW/gPVp/07 +vcB/jm/RO6U1Ci6hZYl/l3icu8B0gUnOxAAIFJJK8xjSpzx+fe3cjixf5qWxjwznzVeVUnWbKFcp +otD4XuJx+IGLkx5sc9ld2mTxLtxvzsTVSwEh9BwM8QIEoUn8qQHOn0HjcpV1eHM36dAuqHicASEA +3v/iEuISsA4FFKjnoFMVNyW3tze/k8Ktr0GcWLdBsyIFQAT4bA4T8QI1U/Oaa7JAf1tg+v0O8TUc +5wXwO3ica+Rp5Nkwl0nkRp/98iTze+ouH9zOMWuVFkuzn/u4eSNTADMA4oENX/UFz4NXh9kx+Q4g +nVM869oA3ELQJR54nAFVAKr/nRqdGrCoBhSmjGG3cr3Y+6mN+npWPAO9JWpYPrO8Bl0DFIJmBZn0 +KOaM2Vwf+nlLeIq0g+E5sy0KPgEUS8PCWHca8XSF16aY9n3nECfwkYOzfwueAa7gKBb5AxV5yfBS +5Upobk+xZUwM91f84OkaeJwBOQDG//cJ9wmwPAQUJ1+JvOa/iyrJ2vnpYIce12HGCpGTUARlFMCJ +bnMNHOZ8WbZ9GRw5kVF4X9ugk8kELg/qGh6vAnicMzQwMDMxUcjLT0nVLS7MySxJ1StJLS7RKylm +qMq8WdDp/ejvg0+blGeY7+B7c7ldDwCdLRRH4gGHuWl4nLtxj3PZTc4NWjXNd+q236ljrPkAAF7p +CfnvA4DXVHicAT8AwP/DF8MXsCcCFNlp/fXiW6gngQyStuZKy9sXPAr8k78CF7NSArgHFPwOtn1m +LCAA5tvhsyp6Prqu9Tidsx4KpQGzFx0E9QpQ267zaIL2GFthns8IsGY1kM0OW3icAaUAWv+vEq8S +sCwCFOOT8n/7NRpKPo7ikuekv2m5z5/hs0ACHAEUOvXuZJQIc4naxDq9wCaHshZ+1n6zcAM3BBSr +pSBspajVxN3DTPUMPGJD9yYhKJO7B4cUQpBUoNBm7nKoUouIJ59W53dEYCCTVggvM2qHMK0k38v7 +9m/t8eGVsy+C4Bl2NDAwMDAgdGVzdAAg5zon3FkSRpFW5vlwhX7jJyVXUZO4CHd0Lkzh9APLhSRM +EOohYpS8fMoWoWMMl4dtPnicATQAy//HA8cDkJQURtOamankYyzElkTrIJ484AjxUDCxqAsBFKcH +khzLPyd6E9yE+17zEfY3PkcHfbcXGvECXFhfGK5XPkqDmJ3hwOEX4ouRq/Z4nDvLc5Zngz2zSK8M +g4frlasHA7sb9++5aCFXqBV+a3Mw8y8mAOgzDiltkNIieJx7cY9p/k2mCQabfzLlrwEAMj0GzPAC +YfJVeiHfYZgsD6kNROKYf20iral4nFvEuoh1gyqTiGaTn1Zhpu4Cv+Osma8bpm3M/CI/bbIlUyYA +vakMgvwB3HepJf8EBeeq2CS7OTd399jRSo54nPvA9IFpQwyjiLnu/tD+hXWb3v69wPXeZolGp/MF +bQC7jg1g/wETErc6WNbPn6AoXaOK4TtWTYOt/3icAR8A4P/XA9cDkFMU6Y3Jgpavs/IAaCX2NaFs +l+YWiZmxZ3AB+vQPWvEC+fPfy+KfutHLWwpLYkBafGSvWoN4nHsv8F5ggw+LSMLx/3MfKqflvMww +qf4S2iv9+Ybr4s0JLPwsABS3D3r7A43UH2lWmu7CL3X13kW3w1whJLQBeJwBOwDE/4QihCKwEQcU +yuf79KBCzjBVRh79SlJ0KuCGb8OzJQe4BBQERA9opl6RidjM+fFckBmR/mGjQ7PxCxMFHMwa7fAC +u+HUGwK5bLaVLZB8DDbDSUgwyS94nHvB/IJ5gwmjiPtin966T7yvF9eXzTI0nR2gfGuZ8WQPxgUA +5JYN0PECGXp8CNAUlwlt3cRXCNFuYHamCR14nAEhAN7/rhSuFLCRBRTmJwueY/UchMKi4tDg+tR0 +x0Nkk7OlBYkEEQoQsP76Atlhx6bY1gyMj5yiwP+KvKskcwlneJylWF1sFNcV1l2oQwzYUPwLhtx1 +ib2DzRqSpqI2i00NaXHAxn+gitgwO3PXO3h2Zjsza+OAtVHaSm2jPqBbaVI1NTjtQ57aqFuwVFUK +rapWapS/PvJQiFQ1qdpEQQp9qFrRc++duzNre0l/nryec+65557znXO+e39wt/YfL25+baS+2NOD +93r2oKm6LjYs11NN08XjtjZLvE4XHyvkTXIJ5x3bs72FPMGqh52C5Rk50o3ns4aWxV6WYM2GlU5B +82yn060FkxOgO645Rt4TRi2NYL5et4mLLRuskIxJNC+TrM0ULM0zbAsb7rCtE7F3Yk41C6QXF6xZ +y563lF7MP4BO4NwJafZyLQZjXsGxpEogsTOBal/tYulUPW5ryarusOoZc8EeJw3XIxZxXBrft7e6 +UOua2MMPCIf3VC0rtCZOjk84quXmbcdj6w9XE7YrfbViuSVlpx0yZ9gF96xjeMQ9ZlsU73u8v7qY +hDbcbMHTISDrO9FaVVz6WddQzVZhY1ZI6ZsHW2rEz9LfDj7XesjI4ER1+4msaukmpF0DiKRVbVZR +griX0s/8OlY8ij2pionj2A4mc8TycE5dAPwQjeiQGs/FOsmAmOh4nh0PoJMDiLH8J/E48TyTYJul +lS3GasYjDj6fVfXjzGIEKy5XPU0s3bBmWKC2k4RLzEy32FsBWNAHV7vowC830sNffpTe7W/xsxht +pyjVVidPkOC6dPRIc2nvsLKhpht79iyhJ0cHgp+lF0e70CHx21I41HiQYKNzs2tDNIXjqZRQxleu +4NKtsV3oMbYIY7YkyQ6WaAef27uxq2WJXjAJ/e2kUid3gDRjvEhrJn5+sBtX3QW0FiORkIZentij +VrgKdTg0Pu45RM0JTGPNtF3C6lxUbZZoszgPwIesilAT1TEN+Ls6N24yODq9Pr2TvjTR/kiwk791 +OdbcbVuT+RlH1Yk+yHYQvneztmAR7qX0Czynt841PBqi9vpYU7HCa/4zyT09njM8D5ACMXUKhMVG +ADjwi+BUVHsw+NpXaWQwVC5YAD7DIjpTkXGbzNOlibaB0MNPy3FK5lgpO9KfTNBfTLwrAfSdyWOR +E741GZdw+mjy9xtYxx0jngpJEC0jx6oko2pQGyIJohGIZGHIDpQM04NAsKwV8nnQEcWYLIdEgC71 +UL95eHExmhaOTW7xK9xgbxgjITPt+aoy4Wcv+G5CziOfxggULOjq68jGzwYdRualUima97UCuWaV +K4ssa/TCZJeM83tfzcYGKgNTNS4y4VyxPxkGh7491kx/M7aT7ju3jf54upVmnn1eJG8GZoOj8uqD +yEAXdAs5yJdqwc/9kE3ID7Q/L+vY832QPFC2F3CuwCaICdWoL2A4P8hhmIV55B3ivPgf/BU/QiyL +JBXXETsLIrGs3sX5osCCCNrYIkR3OXqGxtneBMY0uGjMGJZqRvo2c0400KQIejkYonfN0p9MfX4C +UEHYXDc8QzWPqZ7ax5VZECtGeLhaUQIXJVzZRmraJCeJNeNl4Tz0rtba2xfoMEuVGkp0O1CPOMYU +E/Sv2t4zbFlgIQhnEHuonCtXKiSf3r3L6vTWWLyr0qzMEtMXPwM5O6b/qyxq8u88QJt0SMhRnC5k +YOARXQS3AiQCPHlTZewoSwJbDDtfKxBgMioQpazsxsmKAObF5MMpf+QGeqxBRk5gRRQtff38nqIM +ZzV2Up7q0ZXBp2CP7mjsy5OqnFCOuxHLXJDg3m+4bgHOC1CbL3IKgwuuOKBt6pgNa5ZYccYkHibz +GDyCQGi2AygVpUEilRGCIvAounkFSHmgEu3tAQuA6Ly6iLbUyeWCGtBFtaUuXE6gxfgXXontOfAQ +AhaESemL7LtIl+/t8H+XRdvo+Ztb6J+f3Us3TT1DR6c66dxUZyIoiDB0iiBE7rkDU9HPdOSbg3TP +NKYD9xqRQlPTLXRcb6oRZU0P3myk31U3bYXtcIZVK8T5sn/7YqwNLZZmp3fFLgYeFcQADgh7Gb9Q +kGqO6KeNvKzK4CShSjXiu0aTQ21zrQQ6fIjfRA20R+sp7VLvoMb16fOrF9zStKY+9dk1lI34byZR +Mz30Xp3/fBI97r+9Ge0qXf2+fs6/ORqrp/33G/x3XkAb/TujsZrNnukeFznF/ravo7Ye3I+hugFJ +hgujEbLGxQmdgzQggZE54d9Oog4f9aDmPavdqFjTRz/+5DAdv99Tuvj392tK7/xr6YB/dzeqod+6 +/5j/VhI9wW1se/hRmsoNMS65Ju7owCvf7kE/3b1jndbj3x1FDStfOIXefzqxeqSzObFev1rZ+T20 +WLsBtFboEmpHkn0c8Zv9N66hJ4L/V/55DW2P+bmXUMdZYdi2OEtjbEHBqSPlYuJTsMpmFbSHwHzm +JoYn+AL/42uo8URf5NBMWF571NKHbMPiqt3YKpgmtBT3+CWN5CPcsFv6pfijB9COz/D/Vtp+hD7Z +XuSW464gsQEcI2VPLM1ZyHthm1+LerG2jOWqmF+rN2ll/DM3UMsG+LBi3UCfe7LI+zq0t3BwsrYu +Bz1rXqyhBe5mHDvH7qQG3H9Ef1KSeASaHFyGBEkvQyRNMrYDVx82HFhzl0QQRipYwx6wc8ac9vHt +NHbHNcEKvy+FTFDnHYCDEvpf8jJq9bedQk0NkudE5Ir/+mnU4t/+EG3xr36AztdFZdBmtiyj3f4d +qOwGwcTCDAPlCRZf+xPahBZX/vIBemFjfTy6eUcH02hcKX6I/vBaMSQn8oqJ0wt51WX3ERYxPnlY +UOV86IVzQbNjV0YxGiC9x0eeZkOTvTBI6q1j3WFcmlESlbVI3g4CliwotJdVvUFMLgHFjqSMDd+L +AEu+A1eMXC/XBbA/uxRrK64C639zKZQX5jCaImXS6yBAqdryKO9PBhjo6Ag+FtmYXkWzQ2koHF9N +s6WS8DMYF3qkriPUV+om4hV8B+60brqCppbXRu4QSrg6XPefLRAi/91LqGGyrBnhJMxSYrWzEZYH +PTa+Rhw4q7Bt6NWPdispcZ+MBiQp6WZFPOnITOMh+U880rLK32R4xPtExWcf/xC1nqnUhLIhDE0M +OlDgIQJCWKZWo6F/bXZ6/aFrsd1FsZRjOFX5eFY2x86ME2ssxiP3Y3nJ7sXxCMlhb3hQleQSdEbW +iuy0S5w5xlnZfYIXX5EwaqcKBxwCdM5ldtJABK3yQ4KoQDPor0lh+ShcSOZ520p0coVOBQPPhf5o +F4Ah5oBA8qKFtrk/79gzEDaXDR3XZfkM6u1iEfaVTJB9qDylUjnW1nsPSEVeBJQqTwZBmYvOt8jJ +okzWkOMFLzp8UXvYE/grjrxWljMbj+4noFp+I/jjYFP9Kv/pg2zLU4KeYjUNSiFnD9Mrdwr6CktF +X60/vBT74kZ2Hv8bS7F08UsGtDreTPmrj0lUq5DHaTCiZTvlFbSbTRjossAxgXmKtEUea/l7heGF +YyYkEYY7KEwGfIiHqp+90J3IwRA26lW4vKTBh4QY/f7t67Ene+RFgmv3htqrlCXV8O9djzUlwyea +EPv8fah6v66r7Nf+y9dibzRykiIWK1KS8AeWY/tS/8tjn+zrfX5uOfZc//9lohb7w8uxNkneHnkl +1lD3b5pUIqfxBc7K4uhWq2IFA6fJXTbCnUF767vreJwBUQCu//EM8QyQpBTPii3hvZdrvQoOWccL +jB5X+Svzy7G4bgQU4oVCvNyje9oLxiKruXSjzZ3syyGTOgVOFOV9gP4aWPujOOTA2srtnBBWchHl +k5wF1Z1dKijxAp+4VaYvA8LS4Gffw42yImkEs+0BeJz7KPBRYIMUq8i7HJc+n5DeYr6YZbyZdn57 +OjTWTdusx+rMDADjyQyg8QLCnVMWeXzNoZhZxfvacxKA+Ev/QXicu8R6iXWDB6OIlNaG1j9qVV+f +xmdP+S/49l2EkPjTzTGMZYwA+7AO4fECuOHGME9FlmbTRkE0NVuUf9ur56p4nFsnvE54gzGbyMNI +00fPZ2rxs58o6Ghf75O37tO2XZvd2dKZAfQUDrv0CUznzrulGNUshcdG/2Vnq/V5Mb/AeJwBlABr +/9UI1QiQlRSV+tyV/AfP1cWrLen6l1PfSBiT6qGpARS1gwZAQgOq7364wGgIIWuoa5DpzJO9ARkU +RLK7uo5/TwPEVsqBvK3zVRu/4DyT6gH8PrwgkLDNA+E8soz/oMiXvvs9nawdMTAwNjQ0IHNvY2tl +dF9ib2R5LnJzAF+l1ZBCogClAQZBUyW49tG0JV+DsyQDMQHfe0Zj5CSLmRV4nNvke8llgtXEok+S +uaklGfkpCrYK1QpFqSWlRXnFVgpJeol5lZNjmaUmz2eUmpzAzsquo5CcmJyROtmbUVK0vCizJBWk +gUtBQU9PD2LA5C+MIZNzmWSlwbJOpWlpqUWpEGMRah4zmW4+xTybeXILu9rkbezqk1+yb2K3UgBr +mTybQ5kNqu4kR8hkQ86MyYVSIpP/8nNMvsApIA+R0gHaCQLpqSXOmQUZqUVWClA9nFyyMO3RXLLc +CFt1JvdzyU6eLcQ1+R+XCkyJLrd8KoaJwanFxZn5eTAjkWUyEoG+Cc5MT8xJL8YiH+IT7JaZl1mc +kZriCzQkMT0V7i4+HmUlbOpDMpOzU0vgymJ5xGFuW8kTAmNy8IYCA0Ju8jxeY1ZwpGy+zWvGCGVK +889nlIUarZBYBHJYtUJxZlUqNAIVajf/EOhkgpm1g09l8nVheVZIaP8UtuBFiarJcSImqCKbT4qw +cExml9VACUwrWWNGhc2vZY9zAACKIsIC/Rwuzxi+8pvB7cucteuILCiDNe7R6XicAc0BMv7mDaEN +kJWRs38U30BJIQLDX1thgg8knoxb58iXPhmTRgExNWBVhhHzbXuQbjovuH1LvWFpMmRaNDAwMDAg +Y29uZmlnAH8vG+nlhMS0ZA/YgxIU2taVrqdlk6wBORTa4vd1Ak4DEJobU+G7J6T72SjwWpP5AR8U +x18b0Ck723lbgoK4dZTLiYZBsDuTLAKCFLrid1GojMH2Na7CJnIwEQnWN4RIk8ICQRQAkfgAYANq +0ZAuBXdlAjMnI1TNX5MXA0RZuznjqaWFRPGqce4wy+F0Bu0Ff7s0MDAwMCBqcwD/2tzA1RFgQhPz +2EcJRSIuntCaVjEwMDY0NCBsZWFrc2FuLnN1cHAAFAPVfJqfqCQ66OZMiLlAHuiUO82T2wMwFOBO +W6YsGEedqKuGQKolwCajmyA3kx8EIhS5lw46OgDvaP+lGI1muYejnwSAJ5NVBB8Uw41ZplIh6SKR +Q1T4jEty72MnspyTiASfFLdGOZ9+4NbFvkTsUDqwXzTI0tv3kzsFHRStLSO1nYQjyKO4AbLdnvGs +rUVpBpNsBTcUg3uDtKC+jaSqKkndX8Ywuajsij6TtwWgFFqmnH0N38qXkqrvrbwbsi8+vshVk2sG +e57LzAX8AfcPYdNaJMeG+vimnW0J4rbIWpUoeJy7xXOLZ4Mbmwhrov4nuZ5fm+L71gg8+iFneK9j +qTAArP8MqvECNev4dbQvFnu4SPJHu0sqxDol4Mx4nDsueFxww2wWkdbJKrPOndTUa/4nzxGwPNX9 +RYJz0+b1LBIsAPPODbL+A8tjHXwk7s+Tu7Sji7ZO3jBVme0zeJy7wHSBSc7EAAgUkkrzGPR0XK6e +/TuL+5jPftkPF9uORqn+8pkoVyny5cQE/Y4yswbLXM3Yg/97G4X1fJ5NXL0UABpOG3bxAs9zVDa4 +HWzI9Q21tP/rx2D/2F1PeJwBIQDe/7kSuRKw5QQUqOegUxU3Jbe3N7+Twq2vQZxYt0Gz+QRABAj9 +D237A945FdRekIPVYOCJiIIAJCO/RST3eJwBOwDE/+IW4hawgAYUpoxht3K92Pupjfp6VjwDvSVq +WD6zlAaNAxRLw8JYdxrxdIXXppj2fecQJ/CRg7M1Ci0BYbUcBuUKyT94nAGlAFr/rxKvErAsAhRE +i8lVzfPjmHgf4Y/tYIE/2+q7ILNAAhwBFCnEUdNBaOqoQL8kFtsFD+0Bs+YJs3ADNwQUD3iz47Gc +ypgMUMc+c6i3mOlY0Q6TuweHFFjkFVZwhk5UcejCs1dMU+jMRepNk1YILzPZl66rhAu7jNUthr3h +gGnzuxsMwjQwMDAwIHRlc3QA5PIQwygdOTvywO9tTBNT4ZwC1xaTuAh3lVNLjvwBAVyfz2p7y20R +recN6Vrqxul6dGt4nAEcAOP/xwPHA7CzARRP+GXR/57JkI3NfaNkFmqrn5ma/NAcD1fxAta9QN9S +mRFX22ytmQey0osB/amqeJx7yf2Se8NuZhH9qULyC6u52o08LtxIm7eqarXsQ4fN55mlmADtsg3h +4QGQ+zp4nHtxj2nmTaYJBhvvSTNtlmL1WwUATDAHc/AC86lMKLSbM7bfm+De54yYVtr6QEt4nFvE +uoh1wz9GkQmRcTyX724qXZZ2TMH0byhLrmTdy8lCTBMA6KgN3eECxRt4nAEhAN7/lxGXEbBMBBS7 +4lEU7uVt9olNk/KZtWS8z+tvdbNgBDcEEYsQVusDvy54nAE7AMT/xiTGJLDEBxQClkdwRpE17tGr +Qe5E+zYWtXfz27PYBwoFFNn3D6CbpqQRmAazAJWCbd/jzBras/YMUAVHARxo8ALBZ8bh4ELXOWsG +vWKosRGPRiqMV3icm8AygWVDDKNIltusmOsr6y+saY5/eWCFzlsmiQy7yQWMCwDiXg4b8QLDu6cR +OChW1M00V01zWgEjyzwvrHicASEA3v+uFK4UsMkDFPALz5eVPMEjhdSWsYORvU9QrbXVs90DUQYR +jBBc8wUuzxi+8pvB7cucteuILCiDNe7R6XicAVMArP/mDeYNsAMDFGu6wj+Pmlj5g38fTHEjuiMY +5t6QkxcDRBTR4jJM9fBYI9154FUpEwf61dhwD5NvAzAUgM41ErUD+uxEth0CLqMSh5K2+9SzswMz +AwsQJNrrA7UoeJz7JPpJdMN+LuMHvwICuqbOzPV6LLP678K9cm+abv83MQAChZKizFyGiSYaZ+cG +ztNLv9Oy4l8w+wr2nyXrAXhwHOXwAl//sUiz8uioG8ZqHGNAQb2zCs99eJybKTxTeMMjDpFZj4Sv +O3A0yZ/va/3Jypar3lnssHzyN47FAN+nDef+AdWn/Tu9wH+Ob9E7pTUKLqFliX+XeJy7wHSBacJ0 +EQ6uc79ljKQKK2eKPK3waN9izLto28TVSwG8VA0T8QLPg1eH2TH5DiCdUzzr2gDcQtAlHnicmys1 +V2qDJJdIUxrrzC8az3puxsj/qvSu6NrS/NBysy7XByYA7U8Oq+0GhwJ4nAFtAJL/rxKvErAsAhQB +XJ/PanvLbRGt5w3pWurG6Xp0a7NAAhwBFFzqeN2qEckWmpARHZAgxZdatmtWs3AD0gQUFyHh4bEA +MY4B6tl6PyiUCsh1y0WTVghOFKnJeEnLlo18suhGlkChXBob+JcKk7gIdzrTMBniAZGCB3ice3GP +aeoNpgkGm5MYpzNulmL1WwUAUJAHcOECgxR4nHvG+4x3QzSzSL5ubXvajyPuq4OcV3se7tC9ktk9 +f3M+czkzAPzdDsTxAlnLbIeLppkhARHuYnC7fAmichuPeJwBIQDe//IV8hWw5gIUU17zfgyD09z7 ++dSO/kyjCI+PhAGz+gL4By/AEbfgAoEMeJxbL7ReaMMSDpHWF983C9SIC+dNdDJcE3/qvrWs5OXJ +OzjKAeZDDfThAoQxeJx7xvuMd0M0s0jk6Zz27mUzFRkF3yUV7K7hXFQk3b85n7mcGQDwNg16+QVz +hBupSSyn1AizflNsTADQLFFsm3icWy+0XmhDDLPIxE6fi0H7TLgLzipGv5ITf3lm7lfdzQXMoqzG +X7+15XnoKbpUnAytsnhm0e37rO+biQEQKJSkFpcw9CoUfvQWFWTtNmrVyzk5XUPpT4Lz5B0c5QCQ +oiSV6wKRhGp4nHtxj2nndaYJBpOTGNOYE/NSJh9nNOPNTSxJzsjMS1fwy09JnZzF1L9ZitVvFQCB +1BCU4QKHW3icO6ZyTGVDMIeI8HRlhlh3zdVmN0VkPniEiFWVXfy2OZ3jPicAy/QM2/ECsopPm1ZO +rb0p1PAQQiVcW37iOVp4nFuuvVx7g4SAyAsnxc32lUvdlp6VZQ+QuX30/5vQzM06AtWsAOhdDezz +Ao6dwKw87R7fw9ngpeSwD1UcsgIIeJwBIwDc//acAfacAbAMShTlLjbc56aIa05IR1qt+HDDienG +7LMgSlYEO68RkP8BIHrQmD/mUQdHW3O/PvPVMN/rtK94nHvO/Jx5QoHIv6TNH3uu1kpUsX2d91FJ +pFb727KHG1uSGQEBMQ/b6gONh0J4nAE6AMX/hosL7IgLsNIEoxgFArNAB4tes09mOw6T0JQIk9xm +DLPGdHsaswqQwwuTQY/Kg86bh86bAbfOmwK4KdVOGgLxAi7PGL7ym8Hty5y164gsKIM17tHpeJx7 +xvuMd8N8ZhHL1z8fymUkpvZK2fZWZx6qd2nd5LN5M7MxMwAFYA6T/gHVp/07vcB/jm/RO6U1Ci6h +ZYl/l3icAR4A4f/QAtACkJcUq9n/bkXikZB28pVZw85w9TTUHu6Rq6UAbhFa8QLPg1eH2TH5DiCd +Uzzr2gDcQtAlHnicmys1V2qDJJfIoSsXwzlmlPYZ7p8tFcCb+vRii7rXZl2uD0wA59UNpa8CeJwz +NDAwMzFRyMtPSdUtLszJLEnVK0ktLtErKWbgvRAz7zSLtnZtfbfuXLnVSx6xJ0sBAHZNENjmBof0 +Z3icu3GP8/tNzg1CKn6ZeSWpRWmJyakKwSWJJam5qXklwZV5yQrVXApAkJyTX5yqoWmlUJafmWIN +FooOrsxNys/RS8ksLgBKxiLL1m7mV5GOaL5Tt/1OHWPNBwB5mCSzaI+LPQzaBIgt50dp73Oluq1m +4LI= diff --git a/.github/openclaw/qualify.sh b/.github/openclaw/qualify.sh index 5a4182c929599..bdc3555df2b36 100644 --- a/.github/openclaw/qualify.sh +++ b/.github/openclaw/qualify.sh @@ -18,10 +18,15 @@ for arm in baseline candidate; do commit=$(python3 -c 'import json,sys;print(json.load(open(sys.argv[1]))[sys.argv[2]]["commit"])' "$pipeline/.github/openclaw/variants.json" "$arm") tree=$(python3 -c 'import json,sys;print(json.load(open(sys.argv[1]))[sys.argv[2]]["tree"])' "$pipeline/.github/openclaw/variants.json" "$arm") if test "$arm" = baseline; then repo="$QUALIFICATION_DIR/bun-baseline"; else repo="$QUALIFICATION_DIR/bun"; fi - git clone --depth=1 --filter=blob:none --no-checkout https://github.com/openclaw/bun.git "$repo" - cd "$repo" - git fetch --depth=1 origin "$commit" - git checkout --detach "$commit" + if test "$arm" = candidate; then + python3 "$inputs/acquire-bun-snapshot.py" "$repo" > "$QUALIFICATION_DIR/candidate-source.json" + cd "$repo" + else + git clone --depth=1 --filter=blob:none --no-checkout https://github.com/openclaw/bun.git "$repo" + cd "$repo" + git fetch --depth=1 origin "$commit" + git checkout --detach "$commit" + fi test "$(git rev-parse HEAD^{tree})" = "$tree" git diff --exit-code HEAD if test "$arm" = baseline; then diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index 40b82c5c791e3..43287c7bc98fa 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -72,3 +72,5 @@ Linux qualification now binds the historical and candidate Node references expli The current 21-lane qualification can assemble the retained build artifacts with a separately admitted fresh Linux consumer proof. The fixed-run continuation keeps the original build and proof identities, verifies all 22 archives through the existing assembly owner, and does not publish a release or update consumer pins. Historical ten-lane assembly retains its original admission limits. The ordinary VM-cache Debug qualification builds its matching non-AOT engine through the frozen Bun local-build owner, with the AOT macro disabled for both engine and consumer. It verifies the real two-case cache-eviction test, Debug/ASAN/assertion compile flags, source receipts and runtime identities rather than substituting an AOT archive. + +The frozen Bun candidate is admitted from a checksum-bound Git bundle for native qualification before its source branch is published. The snapshot preserves its exact commit, tree, signed history and three public prerequisite boundaries. Linux and Darwin use the same acquisition owner; this does not publish a Bun runtime or promote a consumer pin. Remove the snapshot transport after the qualified commit is available from the Bun fork. diff --git a/.github/workflows/openclaw-artifacts.yml b/.github/workflows/openclaw-artifacts.yml index eca58722c9eea..d1db6eb28f4fb 100644 --- a/.github/workflows/openclaw-artifacts.yml +++ b/.github/workflows/openclaw-artifacts.yml @@ -240,12 +240,11 @@ jobs: - name: Read the frozen Bun candidate id: consumer run: python3 -c 'import json,os; p=json.load(open(".github/openclaw/variants.json"))["candidate"]; print("commit="+p["commit"],file=open(os.environ["GITHUB_OUTPUT"],"a"))' - - uses: actions/checkout@3d3c42e5aac5ba805825da76410c181273ba90b1 - with: - repository: openclaw/bun - ref: ${{ steps.consumer.outputs.commit }} - path: consumer/bun - persist-credentials: false + - name: Admit the exact Bun source snapshot for native qualification + run: | + mkdir -p consumer + python3 .github/openclaw/qualification/acquire-bun-snapshot.py consumer/bun > consumer/candidate-source.json + test "$(git -C consumer/bun rev-parse HEAD)" = "${{ steps.consumer.outputs.commit }}" - uses: ./consumer/bun/.github/actions/setup-bun with: bun-version: "1.4.4" diff --git a/.github/workflows/openclaw-hosted-linux-consumer.yml b/.github/workflows/openclaw-hosted-linux-consumer.yml index f0cae87c7c7eb..de0a13e50b7ac 100644 --- a/.github/workflows/openclaw-hosted-linux-consumer.yml +++ b/.github/workflows/openclaw-hosted-linux-consumer.yml @@ -49,6 +49,7 @@ jobs: for suite in test_artifacts.py test_release.py test_consumer_identity.py test_compare_fork_ci.py test_verify_jsc_results.py; do python3 ".github/openclaw/$suite" 2>&1 | tee "$RUNNER_TEMP/contracts/${suite%.py}.log" done + python3 .github/openclaw/qualification/acquire-bun-snapshot.py "$RUNNER_TEMP/bun-source" > "$RUNNER_TEMP/contracts/candidate-source.json" python3 - <<'PY' import hashlib, json, os, subprocess from pathlib import Path From 097247bced3ff346a39e6b699ba707ad63a9cd07 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 11:36:07 +0800 Subject: [PATCH 32/35] fix(ci): qualify the repaired Bun sync snapshot --- .../qualification/acquire-bun-snapshot.py | 10 +- .../bun-882-qualification.bundle.b64 | 11850 +++++++++------- .../qualification/harness-adapters.json | 2 +- .github/openclaw/release-notes.md | 4 +- .github/openclaw/variants.json | 4 +- 5 files changed, 6540 insertions(+), 5330 deletions(-) diff --git a/.github/openclaw/qualification/acquire-bun-snapshot.py b/.github/openclaw/qualification/acquire-bun-snapshot.py index ade288ba64928..b9a691d8bbd6a 100644 --- a/.github/openclaw/qualification/acquire-bun-snapshot.py +++ b/.github/openclaw/qualification/acquire-bun-snapshot.py @@ -8,17 +8,17 @@ import sys import tempfile -COMMIT = "882b3ce222db5f51adde7dce65bf6262aeb7335f" -TREE = "20d3242be73f09e989b136c4584191fc7a8a7e82" -PARENT = "723010451479c1464c6d6c5f2a5ebea2eb92fcbd" +COMMIT = "c6a7bf9d8dc4d44db9f826e47a5ae7645ea6e8c9" +TREE = "ef814c1b5ef7731d6373cfacb8c88b0227a670aa" +PARENT = "04e10be52c3632ded738bc7c71e34d74babcd04e" REF = "refs/heads/claude/webkit-bun-882-qualification-20261102" PREREQUISITES = ( "dd5eed75f82e5972e3a3928032bbede7eafd2795", "7b573c05d0c52dffc67d4d25daf108bed5930cf2", "3f3a9ff87cdccf3d32d7ec6b648c664eddaae840", ) -DIGEST = "264eafa6ff4b7cc14c817cae42ea79b4b34fbe37c52a03802a6eceab6c00f767" -SIZE = 303527 +DIGEST = "d6e34e289b33399b0cf1e1cb40a3f3c6ac977685e7730b7b58d5572cef5f7249" +SIZE = 372405 def main(): diff --git a/.github/openclaw/qualification/bun-882-qualification.bundle.b64 b/.github/openclaw/qualification/bun-882-qualification.bundle.b64 index 821c279b89166..7ac9a40555d20 100644 --- a/.github/openclaw/qualification/bun-882-qualification.bundle.b64 +++ b/.github/openclaw/qualification/bun-882-qualification.bundle.b64 @@ -3,5324 +3,6532 @@ IHRlc3QoYnVpbGQpOiBpc29sYXRlIGhhcmRlbmVkIGltcG9ydCB2ZXJpZmllciBjYXNlcwotN2I1 NzNjMDVkMGM1MmRmZmM2N2Q0ZDI1ZGFmMTA4YmVkNTkzMGNmMiBmaXgocGFyc2VyKToga2VlcCBk ZWNvcmF0ZWQgcHJpdmF0ZSBhc3NpZ25tZW50IHRhcmdldHMgYXMgcmVmZXJlbmNlcyAoIzIxNykK LTNmM2E5ZmY4N2NkY2NmM2QzMmQ3ZWM2YjY0OGM2NjRlZGRhYWU4NDAgY2k6IGxvb2sgdXAgTGlu -dXggaW1hZ2VzIHdpdGggYW4gQVdTIHJvbGUgKCM0NzYyNSkKODgyYjNjZTIyMmRiNWY1MWFkZGU3 -ZGNlNjViZjYyNjJhZWI3MzM1ZiByZWZzL2hlYWRzL2NsYXVkZS93ZWJraXQtYnVuLTg4Mi1xdWFs -aWZpY2F0aW9uLTIwMjYxMTAyCgpQQUNLAAAAAgAAAfSaLnicnVHJbtswEL3rK+bYIkiifSnaol6U -RLCl1Fvi+EaJI4kxJSok5SxfX8kBeuqpDyDAeTPvzXCoJSJ4eZFHlm/lkR94ru1jiVaYlzm13JAi -8R2LRARJaHREYquBUg+RBl4Z2uhFgY0OcSI7NB07z5FigKSkdhB5Bul1LSQ8sLYYdQtRwPfTZ3AU -xS+GiFdCVj/BCiLH9V3fDOHCDE3TKETTMK3xv8RVVylWweWIaXybZLDZ3MEmuc0m2906PvMG7Kws -2Zn8bjJiNZx5Ot6WhZOJ5ePDMX3eWen2OHLVW3UsJ4/Uf6WnmRmqjZ7cxG9RpNa/DVgTfbq/cy/u -N9TisbNMRsX8YHNz8heHD3IbD25jbrodmZmTfZCZxQ/zxMq2sWfAeYx41VxfBNm08epp9/DCuM3X -cpGs6mMrZ+GNW07uw7JaykW8r5+423r7U5C+5wt1XbO96RfEAPf58Xmz94Wd+k/Zwkz3yWGV/DA+ -1xFn838twyjZ2xf1wpnGr9+gk6hQnhAoI1UrlGaFAl1L0Vc19J3SEkkDrNVYSaKZaA1jp3CoQFB9 -1wmpkZ7TsiX8shG05whcEDp8J2kpFJwoxcr3s0KiJqwdBO1gNfTs+pwzVQ+ltRDHK0iJLmrIBB3H -UZ1QhEMpRQMvPcr3oWGuCslylOrsTejQWqvBthpeoYbhQKPSV8YfC/nuOuoQgwx4nDXOTUrDQBiA -YQR1kVPMwo0UJN9kJplxZ9W20gaqaBqFLubniw7WSUyn1vYWwQMJHsBziKewG3cvPJv39+Bzfx5a -REJjm1BGNWZJFUuUQmpIUsO4YCChMpkSKkNBo0a16APJaBJDzDiwTBpgKTOpTQ2vqOKoUVHUklZG -225+csiZSIF3XfZf31/luSnuxWsdinKAVwO75Wo02biz99lduR6H69j1nm76sFnWl4sCQGMDMHpZ -TdZ+mE8voMhvIyJpf6tmDqch7o1L+TAcTtb5x8/eUWJqi4/oj0+JRbPYDZOqbp+JV8G9IdErtwjO -76xBb9Ebh8voDyNWVOOUJHicnVBdj5pAFH2fXzGPbTatzIACTdsUZVR2lbUCq/VtPi6IILAwWuOv -L+wmfepTT3Ju7j0n5+bm6hYAG8J0BEyobY+JaXE+5oYQqXSBmESqiaLEMm1HKNTwFiqNgUhqE0XB -IcQlIATvfamkMlxJHWds8d4TAhC/6GPd4pe8kkPuqZb46/V9KGr5IweAz3WbfcfEdk1r0pPgB8Mx -DCTr8znXGv4rnDVZl2f404ApWwQhjqIljoJF6MXJlr3pCCckDBKjXHoDfvb010O3kmZYr3YvxfqU -kHVcDFp2y4rU26nJb3WdGU4XaW/Obq7bbTcIb7m+Pi+th+dIkZKZq2BI+AdaGt5fHO58wfptgzeN -B2Vmhnc+I+XBD0gYszHCb2csYN/SBmK2f43z0bLWomTzwI3v55s1tX0jPU1bmLuN2HinXZmsYbui -+8tjStny8Z5tnkyEq2OdbVji1KNfJ8qpdkeu131D7+9gof+vZyANnf4gLnmpPn7BBUCDj7xVUIHC -+bmpW43T/KYvLXS44fqI80pBA32pNPoDjDywPO8Pgh14nDXOMU7DMBSAYSFVDDmFRyRUEjt27IwR -pZGoAkUMLUgd7Jfn1jRJq8QByi0izsOCmDkHx2gXtn/4hv9n9DVa+RaRQApUcgOgsaRMJ9QyLVBA -ySUDZmJlQHJL02CvW2w8sTLGkiUKACHhscETVBgJJZKSIkNkhltAO6yuzkWcShUNg/yv3+/ltYjv -uyJnbzYLF8Ce+7CYHni5EWGFS8fsThdpltXqqenXr2w7v8xEFFE9fZw0t3XSt4eA3H3MX6I83eRi -Uu0fbgTms2z7+Xc2vnDdrtIeSe26zjVrskAzc57o1jur4TTv3n3fYnAErnBR3Z89eJydU8lu2zAQ -vesr5tiiiaN9KdqijuPERhwlseUE8I0mRxJjiVRJyonz9aVsdDn01AEEcJb3yHkPMgoRsjQkZVKm -YZJGSJIwidk2w9TdhmXiJbQkbpb6UcmcjigUBsI48z3XD7eJG3qul0Q+iZHQLGEYpm7sRVGW2XL8 -az4oA5KVZZpQRmkZsMBnCdJ4G4cpjeMQGSME09B1SG9qqeCJCzrgbiWFL/tTspP0O0fEkVTVN/CS -LIiCxM8y+OSmrutQ2bbcGPwvcNVVmldwPsTl9Gaew2o1g9X8Jh8X6+X0WHdg7eXztdvMxkM82u/q -bjgtaJDLxfPT7u5l7d0Vu6FWvVW7cvzM4le2n7ipXpnx9fQty/TywYElMfv7WfjpfsW8Zhos5gPi -auM37vh3bN7JzdSyDb3LYqhMgvydTLxmczX38mIaOXB8xuLCX3n6cbbT6/I+ou/RjHiTBdZis3rJ -vYv5fhM/RRdaLJb7yYTkN3cXrw+PJJDPb25JX9fTwgFWh7tDviyuX14mt3S5vkz68firc5Jjml/9 -SwyHWp/wgz4I+vEztKgqhL7TRiFp4bIXQP523XEeFGpUewRTI5RS7eBkGNRcG6kO8FrzBoEw2Rku -quNYSwytkf3hVb0wvMURLFHLxpI1kjDrOGfWYm446jNgB0FaToG3nVQGuDC2dwYDTgERDLRhXELD -S6QH2gwQg9oOWkZiuBRnMCuKBx9sj4i+OzuCisUKanvQNdnZHVC1XBynR3CL2EGFAhWxi5xL0Rzs -bqLkVa/wCF72ll/LXlGETqH9J45Q6DXZNjhynNzmdpsfPbHP4vTUVdgSLjR0KNigiC39FmXIn3F7 -a/VDUXFxuqdFou2dDIgyvCTU6JHzE8aSQIWTPHicnZNNc9owEIbv/hV7TwI2/sDutJ1CIEADToIN -NLnJ8tooGMuRxOevrwTT9tJDpzvjGWm97+6j1UoJRLC7Xsf3SEbc3Ot4QejSgjpZ5trUt52o8L2A -OrkbuVZDBNYKaOi7to4rojArfKdwQzvyCCkixMCmkZvbIfrEK37F51GGdqiLRLTjoB+4WeYT2omK -kDhOaPsYeJkfENciO7XmApaspkb3yCl83l83G06/MURscVF+Bacbub7jBU4XbuzQti3Kt1umFP6X -uGxKyUq4M9YfjiYxJMkYksko7qWL+fDit2DhxJOFXY17xl70N5iZ1ZS6MZ+ulpvZ+8KZpRvjK4/l -puit8uCQ7+/tUCaq9zA8RpGcP1swJ2r/NPZunpLcqYbudGIUg7dOZfd+29uZjIY6m/nXT43n3o3P -5N6p3gYTJ06HvgUXjMfooz3qxuXYf6Ebcuo+fq8fJg/LdXs5uuGvNo7SeUGfpyLWANNzu79qzslg -f161m00yzilSC14/9gu5msuueg3eaf/HjTMr+Rfr2o5hPPhbM6wtihI/AasVloIohIrUOeaQThPg -hxqFXLMGCnZEaYI47BqpBJItyFNNLWtm9FBwsYEtYfU/jwgcmB6RnQKBB8EUq0tA7dH3vmZScXFq -wRyVyWhIlCC1bLhQt6AHpKlQMV6DJtVyudtifidRSuPbo2AFo+QScMUmFa/1XOT4hz3meic53aAC -dWpQ3kLvKYWM1bkh2erKOVHkUmHcgeyk8K4iJ8Pbe57IFgyQVvpNgCYGPGpiIxvsNNkRmDTpk2t2 -3lxI9DmYktAItjdNTnXNhArW6DfIa306qlrWT++fM6qclAF4nIVVW5eiOBd951dkrXnpGbtLkYs6 -tzUgSKlVWl5LfQtJwCgQTIJC/fovaFvd1d/0Gh9Yi3jO2fvss0+QnBDQ67ZadhdCC8JeZOmR2YqQ -qbctXTeh3Y0Qwr0Q9TDScshJJkEntDoGalm4haw2jiJkd7CJ2xaGkd7qhgRbPaOForYGC7lnHKxp -huq8MUPgz/Pt5cjQP5QQ8sB4/DfQOz3Daplt2waNlmKjIZamVErCQUDlYxGCPzPGSZ5U/8RU7ovw -QQX8S1qcx4LG4Ev9c/1gOAEvwQtYDIOJs1zN/eu5BjRwEQPkOo7bd5yZOxudLD4b9+d9Hc46RWGt -9onjOJMmmjlDH51H4TFuZyN7GHZenjDVHweFBrJ5RIV7WrjbIkrHr2nu5RszfaYu5EWzgrpXTRu2 -MYLwdfwW9KaVKxlNL8jOod+KMiPWgDMvvbkxOmyx7R7Ty2Z4xIHetDeb/WXc9Aeep58dam5PeegX -iy1dJ2W3IZ+m3i5ebXav8UQDISlba26Udt6diGxqxTNc5N5wsE5FUE6YW26jtT8fr5/ZNpk9tt+M -9QsrS2k0gtOywZe+Bih2DD8dNYdB4AyDXjMhp8O5couw2JmO0WEBNL1xideTJ7TsP+/8/nQt8eTR -85Yjr9QzTwONycg+7njXHhobTw+EWLVHW4GNctui7NHBoknjnW4OsvbG5a8HJcbAeGy01/nUblPb -VzrAeaMvts+vref83Nzt/M5raqDMnNGyhTZTXwzzgB740/CcHTfz4nzZPR167vLtgj3Cwu7iqAHd -s0o63q52ncUjOpjJ6oSzIyyDCJaV5V4cMT+Uob+C1mFztmhpPr4EcmFh33XtpDSHZ6Xk1iRe3ITe -rv/s2iPH9N8m0wJf9FQfNsjaKY+PAz733W6eGGYT45Fg067YGqdyEL7Q6FkDy7c87ZJiOl+boZMF -m5PjbHubVTU4HYJ2ErDVoh/0x/1udwBL4nVtvzeylmlrc2Lu3EsnSklc5vald+wfZ61VGPFwbL28 -Pr1Zp34xcFbj0bNgB2MzdBtu1a2yl9EhNI57r9wiv2T0zcoPGkhSy4oXRVp2ZlE7Jh5PWlIDfylP -GdptJ/yJ9+8boUW0/JQR+evvIOdEEH4mYPm0AJLDTOSMSwAzDNTS5QmRlGWAXTLCxZ7m4NMvbd36 -VdN+A3UNmYjva/x3vqb19wQdc0bVDSH3BHBypuRC8BX/G4zafki58nykLgKggknMoaRZDFDBr9dS -Cmn2ACbq8AOwhEfCzoR//h4eFUIyXH0GYl9IrFDAQREQn680uSpNhLjG1ZkwJkDdfOpcKgjFTLKY -KKr8ASwV4ZgojhRd+aoQReWaCQUBQtIkARkhWIBTARMaUQTrv/8AGQOJArs2kECaAipUB5g81EoK -WSXkk2DoeB2JajmFEmS31j7qkkO5F3WOJEJ+QlSF35Cqa+BFXZf3RE4SUrOCXNIIIineoX4H6hqG -GX27Vf9AFdC01lH8ZMIwSdjXQM6YFGo0dzxMhWKH9h8zM8g5u4ALh3mutLw1CWSVk29t3CIxSVQZ -DnKiHgN1mdfDIWXOVA8RpInKRkn9ooaNbtlIfW/IPZ2hIq2NUWQCRgSoltTwUyKudb5q+l67xv1I -9AKprMPeB4xoroYuSSnvNvzmsruPfqKSakMJqqCQ0iuE6CjAZU+US2rv1x5QgYqskuNmvB+luI8U -qyNeoKvcQn1HIaeslhyTnKhHJpPqh0zEkoQg+f+7d+8hZbhIanN8Uem8+tgAPDNa721e1SRJmssK -FLnaPEzUaRbRWABc8JuLCcwKtc9jQnJQT+5rxAfStfT1li+kcmHttVRt2JcblS93cZQbMbkWvezV -mIE40jy/YyjmLFJ1lPM4gbgCMBT1lBPI4zvkw89EqFSF986vmtdlv0oQcZiSHzJVjKxjGacxzWBy -K/H9nr/fXv8D2Agoo+4Pn2d4nDXKTU6EMBgA0JioC07RhYlxoWnpH7gbxCAOceJEhTGZRVs+RkZC -x1IWegviUbyBB/AcxlPoxt1bvJ+Dj/21dwBIG6oFlZI1wBQjEcM00lGNDeUsJg0xjQEpZBPslIPe -I6mNYjHUf1URSSNpjOa1FoYqgUMjQhzqWNVqWp8dckxELKdJ/uvrs7rmL2mbYzvcXozDHcbZstos -i4eBQ9pv7WObL+IwLzym5SW7snn5tu0WuMySqEocb1kaBuiGFNkqZ93Kj6okCdzPitnz+/fe0bFp -T87Rk+2tQxvowSlv3antu1dUgp63Hg3gx13wC4GvT7bhEKFeeJwlxT1OwzAYAFAhlSWn8M6QOP7L -N4bQFgqiqFQNDB1s14kjgmNSRxBuEXEkZjgH4hQMvOX9nn7N9qE3BlGpiGRYGKKFNBhzASCUJiRj -TGBJkgp4pXQWedkbF5AEqRWjXAhFwUgNFSYpBsINxalKKNMV6EqbaZ/MgKQwTfD/92cZY/pu67ZM -zPOlh8et2I3dW3Ze7LYWd+sb9pKXi03hw521goRDPC+H++WVzS9aoLfrsIoQLvATO1u8Xnv3sFkt -SU/mdf7xc8Ljzoemc7JFoZe6cTWS7oD8oNpGozB6c0TB9t1QW3QcnY7+ANxlUmL5FyCScaV4Sizn -u4AsX6jv0XccjeiheJwBeQGG/qwSrxKQ5RQYgyjAMnVFPv4va2GQ2njSNuQt3LH5MwEUDJHr25NM -YtOGSUucjst9Em3NCL+TQALkTDAwNjQ0IEFHRU5UUy5tZADjMQSM3SyWkkjoU0KF8nS1bmVl+zEw -MDY0NCBDSEFOR0VMT0cubWQA0dCoHBBG1W5pJf5s9HLfMJmq4rOTbQNrFO/Zk+rsKCZnNZegHVAY -NN7oktNFk+wDWhSKmoNfwe9BJrGL/+P5h9PKg/Y7nJNaBH0UoJsMsC9qBBEQv1ob4ZaP4GXjEzmT -6wT4FMAH3OgZD2B92PiT8810xAoXz6RTs/cFrQE2EB1oiyoSrszjjuywTzwIyL9gz1o0MDAwMCBw -YXRjaGVzAKUz9SGfJLIB+I3gtPLQqVO6k+D8k9oHZRRKbFqqRWJRXrHs6W26e8b9ZUYLYpNTCDAy -X0hxn+HGU1CXI0G/SaYKD6E9TDQwMDAwIHRlc3QAugMVwCO5J+CyNmEXyrZ2+m90jLiTtQh3Y3Or -D/QDAVyfz2p7y20RrecN6Vrqxul6dGt4nAE0AMv/xwPHA5CUFEbTmpmp5GMsxJZE6yCePOAI8VAw -sagLARQ51vgKEDK2EI8c/YZw40L/TkRe/IGkGFH1Q39yRYnauzvzFTEzSJyxzrCPLxNCeJxVk8Fu -EzEQhtVj9ylGQoJLs6VBcAEhVaISQqVCarhwimPPbqbx2otn3DZc9sTjICEhHoaHQWK8m7Tkltjj -9f9//+8/P47+/j76+f14eAKLy2v4mo2nhqwRigFc2kLKgavqGgWW0+Z2Jp6XoNsGOhN0bT8HEkGQ -BWSNsMrkBUwSaowVhjuSddmoONoNyiyhYCi3nIDLvR/wfobBTX/0t/WR8QSSuZuW75Lpe3TTOpjg -4P1i8el0XuW+TcYhcCa9u4ZLNLcISzHtErDrZTsOL/u88sTrJTTGM9awUIkOG5NVpJjUDmqQUapi -F4z3wHQPQTHox3pvpImp49fQZfZgYxBDAZNOJoSEN2gFHazQmqzq1CUluIoO6xuuEjaYMFgsiIQ6 -BGIIUfas0dVVdTEYuwbu4gbhJq7ArtFuGGKeYOK9MgSOOelnbOw6khO4xVSOM7QYssp5uHH+qj6b -12egmoEU/V7/SMIku1ZSVnJSvmVltDyUa4rnhjz+l9Y+wGesItBmMSs/8S8HRpmaCoUpeCXTUJvT -WJ9aBSnjXvNT+9uKAouSnaql0qaqKJDicohqJ5Eb6RjnlApcFCZFT8Euu/s1DsNMoa2s4b3SEDVX -8mpJM3JovebiDn2/w1VuT8+vz69mMfgt8IZ61uw6TbK6pYGpGCtGdiA+fA4kOtDHpAy1lVFrpvxY -y+V5dvBSZm9Kh1DeLuuqNCv2MlF5THStBw28eD7rKBQXnjTEUVmJSIYCgwV7HZofDtXVlZrQZ/bw -saK7NHDXtLOXh/Ol3FrD/esFF8e+7Z5A9fgmNQS91pTlp9o+o4bpGyaNUcMwLY4NSuhRSY8P2v0a -jr98/Aff9oal8gnWvUDfUpkRV9tsrZkHstKLAf2pqnicAZIAbf/pC+kLsLUCFGVnVxKLZgqEtOga -VFkkFcWbpGiwk8kCdhSNHABIRdTVwVGLgb+80TgecSpX2pNTAz4+W3MetFwgmGr/pmPNHylnO75h -HYUxMDA2NDQgcnVzdC1saW50cy55bWwAL5USH6F7CocySNDYZp6qeqsd4UCzzwMGAhR9NqY2Vu1v -+S88H+lSjhWC0xHW8DP+PF53TuF+72OMYzetWGF0reeHAKZ1La14nNskvVlkgzEXAAvWAoL+L3Kf -PHrXU79JjvY8xg/AaO5ePCxfeJyNks1OU0EUx3NLIBEsWAmWG1o4wQoFnEohJlppbE1sNCFqA10Y -0pBJO22v3t4p84E2wMKNSxI4D4C6NzG5S8MLmLgw8QHwATQ+glMh8RYb41mdmTkf//mdc3Jsvf5k -fVjpi8Bv29LUdWptolyJRcte0x6oBoP11bWzJ6dClcM9kNpRTILxPHOxzaAq2kSYcCqUU6MVJSHp -cVC0DlxAU0vX+KLOlMRCaNFf6XsXGgo2+zlgB8/+1/71fgJQLOVXHxaebhoBGUjs7IDjtbSSqUAo -ZLOghGa4NRr3bw8lrfQGTCcCidNwGgBlmJkx+upyIZskJNj9fSnrH17cTyNORhPnas92cmc7qcuL -sLsL6Zuwt4ffCwwXhr9h4+5HfDx8wT5Hh2tRYYMdojgSmxjrWRK/PDm58ohXWeqZBMFqTDDvf5Ki -+OOBxnjOxlIs8m/FS38U+yQXtsJdRPFgsgu6IXjVL+ZfWeEufrhxLT4mm/w5+4vb28ujl7hWYHwi -mNSuknN4UB73P9+TITwqD+SJ2Y8my0Cp5XJa7bFIgrW4UHIQzsypnQ6aui9oWybncOpWdLz3B80Y -OjRid2jE9O8qS5DmpqItqhqZoLgb86mXTRePr+f93P039i+wvAIn+AELBII6vANIcA2OwDB0+uac -PRa1M3ice2LRZblBnH/yfRGuyatFtScXcLNt1uG34AUAdPwIC/MDG1wz8XSeEf/xu3+rqUz46y1X -XQR4nLvP28W3QZpRLTPNSiE9sySjNEmvKLUgvzizJL+oUsHWVkE9vyw1T7c4Qz+pNE99sxjjSVYA -zS0RhfNFGIPbxRyCv+ozGACVnW1p87UnpQJ4nF1TvXITMRAeUvIUSwXM2IahpsmQIpAMBBImbfak -9Z1iWVJ2JTuu3FIxMDwFdBS8CiU1j8FK9mWA5u7m7vbb708ffh78/nXw6en2iIxHJrg4PQcTl8lT -djEABguXkRfEQGHlOIYlhQyWEgVLwTgSmEeGwzcXOmYJegrEWGcnbZgpowsQ9NWK4GoZbfE0Y+qd -ZOLjGBfy6PEVbK2ThNkMkAeOpR/AZdE1jZSF3RjEtYLP7t+fwnEMuvVdkQwvXj6UcW3kaQx+A5fU -nbgMQrkkWLs8AIIZyCykLKfJhaCYEgsbAmQzuNVz2rO9JpNHtl1x3kJG7knJqIo84B60kThjEuIV -ffl678F25F2SZCZcjpx9ROtC3+CrS4NKBpUl4ubO7J1aECWwmLFDUUejugvrQS8IUjox7DpNoHoU -6/c80HICqXTeyaC+B1GSxah8QO8aRF2nbzPt8mqT6CFvEskuGSkpRc5g1MS4hPO3py4rXdcxco21 -2hZLhsxoVMDs8+Tj9nAVndWFaVMluYCmGbUrTZi7HhJuqmLNrnD956holW5VMGHQLCRCCWqPGbBT -cySaBWVYM6ZELGAwQEeK5b3mQLbZfGitOpKnLmzHZOrCm6JaRwshRw1PlwiB5Q1wCSqzRV5ZqGFA -t8pW485u3h7CXQX2BdEOFRcIXmuPZ9eieHNi7fiuGspvup07Jf3qfdBuafbFZ/mnCCO9vaxWVxlc -2mUZSHIlo+Qn6p3xpRWjnqR6X7P6r6TVHQsdmkVSVClME5ChZKto2/+PZqcma5WPLy7OnjzT7PRM -1ZUzOKmFaofCmTGDtuAvhF1JbgoVhWgRovd1sdQWqYyx0kzaIUbtEWRCrkzaaI/cYX8Xl0J+/3H+ -7Q+kzpht9gGgC7dIQ86vMRd+Rx1ndhZBgblR6nicO7yO5fo6lg1G+ZPvyMpPPq8puNkv/+tyAHnc -CqP8CXwu95Dx+Dfm5XqAriQKKjQ2bqqFeJyb1ch4rYlxwyNuUY28/BKFnMy87NQUK4WE4qJk/YK8 -9MkurIqTS7mEOYpLkuIzcxPTJzOyiicBVWZk5qUX6wNFNRVQNJZkpCoE+LkrJOenpCYrpGXmpRRD -xBJTSzIUCopSUzKTS/KLFDJLihXKEys1FWoUfD1DFIAiBaVJOZnJCin5uYmZeZs/cK8yAQDCijcw -8QJuSoGUJ845X1RAuOm7eKE5aJIiL3icASEA3v+3DrcOsOACFE+jfZ8D7NLlPr7oZQWrpEnZGFgk -s/QCQwQLDA8o+QPcLMWf8LCwzX7mn9vzxgR8cQIlCXicATkAxv/IBsgGsCsCFFJEQaX08J66HtAd -QzrUEKVYoMuLkz8COBQm0V1XBsO8z6jzTMXCoa7fRl9zEpOLAr3aIBpn9gM08qEeURIAXW59G4cm -HG7jhpj12XicATYAyf/9Af0BkBgUI+3CEQjyAhbCpud1HsasDt2/sqqRLG8U+pBcY4g8IIdubHAk -4ZserMzFskKRr06uexnD+ATcT5g7dR+3SgiI8yE4JpAAS26tKnic2xU2PXyDmQJHUmmeQklqcclk -NgU1PWWF8sySDAVd3YLEosScnNQcHYX8vFSFgqL8tMycVIW0/CKF1MTkDIXy/KLs1KLNpgqs3ACO -ExiO9gvdi+sZQGLa+t41PICl/2v+DOHManicAbYASf/TEdMRkD8UWV0h1ioNoC1yKUqJ2MOqHlRQ -PA+RU2UUxMQ28xBKuBLFDV8SErVItAkgNTCRzGgUGZiJYU07gu5eS8UDD6HvbjC4L0mzSAELARSy -4AnRBXGrhmTDUzcUJ/Dzk8FTuLNnAsECFDOBVUUKi7DApKetjGE9QqylWIx/kzwFZhSArCKAq/vI -DubbQj73ziH4BWlX9bO2BcICFBKKCYlWtqNZeFwnXawh7kl9ub2ck4wIR14VTS73B75vAzZ1D40h -1QgHR3iEKDPuPGp8eJw7fpT511HmDaZL3EIyUhX8C1LznHMSyxXS8ouyFVJS0xJLc0qKFUryFRKU -UjKLE5NyUpUS9BSCU0uAAomlJflKCQqpFQU5mcmZJTmVIHWTe5fJT/Zcoi6qkFJalJmXrpCbn1Ka -k6pQlFqcn1M6ef826833lry0BQCu+i7p/hggb14mlogf0hbaxTwwsLSCtY71rXicTZAxTgNBDEWV -dk+Q0lIakKIcgBKJAgmqRKLMOhmTHZjxLB5PllSpuQ0SDRUHQIKW6+CNspByvv/8/+yfz9HH1+j1 -fby/a4ihFnoqXujsvIaQ0GVAhqs5xORKIOi8NoDg6B5LUKDnNomaxQGn/hX82ivUyyXl28OP+uiZ -gulCWoQtEhgj5RbXQyJD2nc8BeISSXBlVSchF6BSLKqV1JLobgbXmo/B2VIjeobgt2SD2IueN6AN -QbaaAX0o7/UkfuMZwynH3kBSUZujbeQcOYgojyQzuEzG+G9NqwdaW3GDW+p3KSH0aJp019LhGEK9 -448XMGe/4UiseVZVk8kEFqmFQFsKgB16rarF2/f45eYXyOeS/fsNt1AeENYsK59O1ZEJuvN46NMm -c/t4nB3MMU6CQRAF4AYLPcWLlTYWxAsYQkGiMejfw+7P+DPJsrPM7AKdifEGVnoJTfAOVFhbeBgX -upe8977X9973R+9rt+/jQhR5ThDljqMLeBzfgp9Am+SisUSwoUS3chycD3T5ttt/PhPXj8KKt1bZ -kxpihbyUOINlUbIrDEpNiwPImRDYq1Mmgy8cMtaVwLSWo2Y4ub8bNZPm4WYwnFY0JdGMZaHj/DCU -kpGKD2xzjh3OZuy6KJa53b78/J2etLJIvPW/59f/NhFUUfkG0CFMLegPR8nro2NYdXIKoc7dgp54 -nFvEuoh1wz/G2E3XX33YYT8p+/MTlXP/fe0+vOGr3WtiAAQKSaV5uqXF+cnZqSXFDFtvNK2s8xZ4 -bJl/98bGWWsebLSNPYKkrLyYYdOFrDVGWhM644vk/075nN6yMnCLzeRoJncAl0IxSfoDfqvf6xK0 -hfrJjQhKDRrt/fpLzMV4nAE6AMX/pAukC6ABFEb4yXkXDDFclDqxOv6WQ98YohVgsxQB8gEUeHNS -JnlvMi3xG9+Tz94FKgh6svSzGgOKAqR3FznyPeXXPORrAD/eaAqVWXgM4DYKBflMeJyNUj9vEzEU -F82FgQoJhKoWxPCQkIAqTTYGKnWjqGJIQ1JFbOec3zVWHPtk+5JmCipDP0Al7kswFBgyl5Gtgqkd -KvEBEBsSE893l3TpwEk+yc9+P//+vE/fV79crJ48b007hkUDiIVE4GgjIxKnjQWdoEIOI8EgjG3d -b58+C6Gx2LUnKvIVpvgt8N86RFJbpMIEXJ85YAbBOiFlDgbjPv1cH6GrzQAN4IFwtp79uKzeyd79 -DO7fdZ7JnhoyxfaRb3P74TJ4+N61jlzrBq0lWpWZawVfD/a6fc9Xpy5JHQgLCUst8hq8bG7DmBEu -xNpAaNCmQyxZkjwpRmgmoOOch8EhE0qo/RJotvEt+HMz+32xFEzpkHF/tNt5O3/HYwg10gNfDzlz -LKxRIZJpfjM2ekhbKzh5UJ5DxKTskaz63KOmijB/vdme4/bSOCY/KAJpa/lZ1CN9/ImFsREOLfSk -JgjYUf56UavRC4boh7U5skMzFIpJsOgcEaIrnnGhNG6kiv4Q9bUgAhTN8aPP96a75JvnnpBTaEb0 -FKVEHSZvWyAOEBObl3CEyoHUOgHm3aT7PgnveOQ5g0mVXYjd4ThMtKOWTegzC0oDktaIvIwJHFaK -iaGoKLh5VyM7Pa88fv0GrWPGXReEVmSwZB4h57OR83GpUZugqGKKmEhNkUJ2+ipYma5DhwR4mNCP -3lU25DzJLymVTxSTY4u58T5fieqWDoXttJcYHaG1dQ+IPPRtWnobe0gDiCUMTV6CFcVt9utvZW3r -v+253p2P55UHxycvlrPbh9Xlo8ZZMGucVQ/X/gHRJliv8BGNJ9f6wdqApS3jnWEFIitXX/C+53ic -O5J+KnODBVN9Xn5KqlVxYU5mSaqSQjWXgkJyfl5xiYJLYkliUmJxqpVCSWVBan4aXCC4Mi/ZGqgM -JAwXVLDFkIcYE1ySWJKam5pXAjcHLgJRWA81CS4MNApNCdCwzLyS1KK0xORUVDmwe4FW5eQXp2po -WimU5WemWIOFooMrc5Pyc/RSMosLgJKxyLK1XLVcXCmpyTmJRakKk/9rcWy2YOoxBAAhgl0T/AHc -d6kl/wQF56rYJLs5N3f32NFKjnic+8D0gWlDDKPICSGO7p4rxutXsVzZd2qCmO5lh4ooALFRDHf6 -Bwbja78HU57zh1rVeLCcWoAm90C/eJy7znydeYJRRJ/GbY3Nzxl+698oEyhcfvEik5vkRBMDIFBI -LqosKMlnyNprLcmRq3pix640lUxR3S/MDLd9IApSy1LzSjLz0hncVy1fYbFNUur7p/khlhdYd5bM -b2Of2GUpYp8y5eIa9yJuA653Fb37k6IPcjNKLrzOCACuRDCt9AN5ERMi37HNZ3rWeEHaRY4z3Ioh -3XicATQAy/+UA5QDkGsUEM9hiGnlpfMv4qdLIoxSnVsnqIOxfwEBFEbWdqKy9bEJkHQ57RaRz6dW -kCS6Zs4YH/ujAgoMov8cQ7OwTugYKsNk2OhVgwGveJzFV1GLG9cVRi4Ordq0htimxg2cxWGtkSWt -5MTQerNry17ZbLKedSWta2fjDrMzV6vbHd0RM1deqYkZ+lDax4Ie9BToDyghkIKhedj0qaVQ2j9Q -aH9AafIPes69M6MZrVJDKRR2Jc29555z7jnn+86Zv/7tGx/9vPhJ8cTr9hmEEyHtMTh95hyB34Pd -IROdzs7VEBxx3RUhd2/CcZ/JPgvABscfDHwBwh4wCJjthmDjH/T9UOpF1CCPffADGPgBA88+YF5Y -K0J5es49P3v6w8KF/cb1WmPNZcNwzUdbYeil304wGUp/bXyj/oO1Z29awvFFWHOu7Lz5VgPKa8VQ -2pI7wIWEUWh5vn+En/yIWeimRdZLsy9fL1yIuKgoIY8JAz4ognrgYSoGG1Bfx+UeellSe2oFv96m -M/jj2jV9EGCEETgUzMUA2QE4KMjFPn+6rjZ5D0q7D1smxsvioe2J0aDkGBF8+CFJbsBV66qBIROS -ixGbH+G0Vycp9QtNQhUaBgZUjgKhfdOSWkt1qRYHVnCvdlXpQZ/gGjSeknyUXazGi6jklKBSvGA0 -F6UGLT7H/1gos7tefF4srpUz5SIc2qxhpt+6fO61RA7jYh1z2eciTg4tpump0L2wdJods2FtN290 -uu1t8z6UD+yQxanDm9JTdRPFD2VfhS71WjlIIhTDtyErmL+ZutA1jPUjFeysYFbFZm4HVlfjZ9eW -9n79aRJxXCeF+9VGsjT74s6ZC1FSC6EMhIMHncGwVNI3VOVTNvTt82tzE5WFG2yoQl0S6IEtnb6q -Xxu2zI7ypgb37vgBF4daCn3gQ8KmDGzu4TK4vgRbuBiX3ihkuCWAjYced7iEARd8MBoQfOvTxuXX -1lXulJt4XMjQUgQxR5q+gdl80LLu7pqYt+a22e1AWTiV2RevFy4+yeVZ55IhPuAD2DPTE62tCpi7 -Xethq/1gu9ulx/QnPAd9zY38iennH1+OwiPrfststZs7VmfvTrfdalkEPuFUN4csGHApmdsZHciA -sdDIAVo7vnAYyuHoAA0tUfvM9kZsUXGkNeP9jDkgUUV1UydQToaMKgOVWZifZfBV0gN7rMKOyNQQ -MLut+622dchkLKDzYpCyedk/jpAhrUdWq91O/XywbT5oPp7r17HDY2lAjTSeozmOM/jUGVOozFzF -rblmx8QtA26lut7bgpv5xCVMMTeNxZuTmHs/dz7dtB5t7+40u9u75svSy8aON3L/99nN6o3+r8m9 -UY9eltz/LoHLMtB6fHdnbyubALQSZUk/Ft599zQTLcI/Jom7Zg1SKgLVp8GW2dkhBF94E5orBNBk -wbC1gPDJ7Z8wR3676UnymE7ZnkeEFH0FITmiRA5C2WN2L2kny2hJV4jeV1ciIVUZZBGrQy1ibqx4 -SfMcqTVUSIjKWBAg525kY7IwRlQb64lURow6BrX9uWVliQuXja2DiWVub5Vis0iI21uWjpWpORQT -txlRK1g+lJS1cNK0zb2dnbhSNPnimqo/3Vwt6Vt73XvfL61mjlUyjrXMbvuJco9aUineiGKXmZDB -ZO4r+haDJFcYOjeLKYND/gxTPxoCpbyC6efIExw3lJFnLOC9ieWwQGLtDf1AqukSLztkzgrvcebW -aAxMQKB7fgqc2d9vFS5HQFo9lrTzOkU+c9H9eNjS88/7dRyAcKVaXc9pjc8N2MDpB6VcnOoKYEaS -CVgoiUiBas/s7D18uNsmYlMx7Twxuwl+nwNOxCyB8bIpNmdwubVReCq6ChBRpkVjK4ZTqmIf1Gcy -rvSQ7rJGjYWxTxk9jf6+HVqhLSzulihnFSLEs4oRp1+efDei7dQXjVES03dJeJiiQ/BUnJDBIBtj -+V3nsWJCRIJK25PxdajQ9adymKo9Y/OsGvMXu4nKhmolZNGgLK9kHc01k+xGvn0oNXHvIEUEhLgx -bKSNIYlilLusjrY2vz6Pcc6JONQ/iukRiIRopNMhSMjR46FUrJlMgBWFpRzN2kitkUIjsoV9iIWC -9EcqkTm4IKRm4ImnUBW+q0F8KUQfFy+FdQ3oPVIwtIXKe/G0ebcJLnO4y8IryqAqIqWSuhW67TLS -iPR+YDtHVDHfCyW+MlqOHFuZYrTUwdL0n7+7NP3tb8rT0sfnNuaMr9Oi6UOlQ90LYZqWxCnKxpI4 -f6mh3/aSs+rFjU4as381CxejXBks6ybLanWpI9zQ5bsYtFPlq9kHNWNJRiuIb3oLtnIgUr3IeCkH -qKao2yG2vfWld4ir0FkO9UZagLY8zc2uz6jspOrs1P0wq9NvnpSa+HJBxZP4/h/SWaF+rzke65LK -49ieAJ8+Olk9D9pWWhoV1Pnpr06+U6hSaPyjXAC+2tCnP/18LypWgEaQchh6s7/cKrwX4aXeZWyo -TPZGnlfto9Nh3z7CRy5sT+u+qYC04AdOz5N01CMFFNiyBhK67x2plyvBmBtqhI2CALulcsA/Fiwg -LKkd5a9ShaWDIMAZgFotNbfZ6u3C+18vraDDODfOfna7cH72y0uFV6cf3XvjWzjWhZ56K2wYs/Ht -wh+ntd8/mX7y2SvnkvTErhrq4JVk9aCEsanAohClfvrnP7zx4sfNwp++dlZpf1FqFWZnX9F1+YuT -dwovTt4584+LhfGLX9tn6q/+G3fG2/mtBHicMzQwMDMxUUgtyM/Jic8uLE0tTdVLZli8/UNN6rXr -vxeFSD6bLtjaGBTbsMMQojInM6m0DKjE7YXvBFW3NP5fak7/t549f178BNtEAKefIC37A4x+kABL -znE5hAxdHdzpiB9KXuoAeJzre8k05SXThi5OxorNXZz64owVk32nS2++ojA5BCiSXvpMEUj5Tt/B -CKRYZxoLgeWnbT63+gAHAMpIGDv3BPbIWobW0Odvl1RiUz554KQAvJuKeJxbfoDx4QHGDVk2FgoK -pWXxOfn5BfHJ+XlpmemlRakaIK6uHVRcRyE0LN7XNSTI0zk43tPFxzU+xNPXVXNzhs1+ZQDjQRop -/gG8XoVLfN1I4Dp3HXzo29j3xrKrR3ic28+4n3FCvIhVTs2eFJ3de2uapIN/C8wU2lLzcuXEYh8A -xmMNnv0ONDhS5Uq8qgXY41Px2epVCEoT4SV4nB2OsUoDQRiEiWVqwc6MsRAPSSKIhZ3RA0VJ4E6x -c1lu/7tb3Owu+++BnZb26fMKHuQ1bMXXcXW6+Rg+ZvM9+PgZ9P3o6FBRrS3h/nb+WIpyeXWXP4jl -0yIvRJFfXmP2ejpL2X6OnnfephkW0jqmylnFiK1mGOc8WslgTzbCy/BC6gTaVqZT2jaQ/ywB+OCa -QMwTlLKmITLUwa2QjLGlkHSBpJpgniq8kbF2YcUXKDqOqKQxxwwd0dlGRkq7bDrstI3nZyJBFn9H -hFaGhOV1P95bfx3sbvfH7ze/HBxSwvsBUUoQ0av6aOnzyOeG5sO27mebjMl4nOtn7GecUC1Sd9Yw -kSlu7tkD5SWRB9/ymvF7a5YBAJecCtX8AVj0Ay0IbgW7ItQXjZWtHgjFmA7VeJxbxrOMZ4MQm0h2 -5HON5G+n+oI2Pc+J+TLZ4Ok0fXEArpgM8PUTzAZ/PwKWlCDTkswxJuLvpFneK+d4nPspcEpwwoEY -DYUQB0E/xws333Wzcr+LOxMVOfWniQEQKCSVZuakMMxMOXBbfL/ezd+3VRKDE+uWMQbbXzY0MDAz -MYEoyM4sSdUrKWZwkI1jKuqWTAvVzUoOZ88L+KFg83KzDKMus1dBal5yTmK5bnImg9C/nFlxcq2x -2Rd+/4tZE9rYqOq+E2JZPkxVUWpOamJxKkPC8f9zHyqn5bzMMKn+Etor/fmG6+LJTizbRV4FyW2d -prVsb7FE2IULWjk7P31+FT6Zl7VA5DfXRMvOkMVzHq7POOhi/nZiQdSOmskTWR1FKqZKXJ32tW5P -8cSXX09uZA0wizhsOPkZ63mRWsnzMvtKOCUUdttNMfwseeFiUnbB5pNsbowi71L2F+mq/a/Z+7/q -Wn73r/vdu7ryJitzhAEAI3SIOPotoX0Tj7nTL+OY8rU9gISb7ajXCvh4nHWSz2sTQRTH6UGUXuol -SH8cXvZQsrBZ2oKXygqWhlJakpqmFiklbHZfNqOzb9KZ2dbYltCTf0BO/S8KuXny7L/gwX9A8CTo -zd2dTSJV5zTvO2/ee9/PzK/vc99+zN3dlh7Ng1mjTwtPZsFdaenImURwgZ23TO8gofS1kKpBfLAJ -fSkCVMpFOne3jurt49rW3m6rvVOr15ovWo3mYbtR338NnueBtW4V1cafSz8fDFkXKoz6iXb/VdqG -yzw5EKQ0aF9GqBV4QHgBh6grJ1YgQoyQLAesyFzFsKoHfVSZFHBBWH2vdDiLuOA9HXMjbGeKTJSu -prUFbVin9rO8YzZX4TpOWzS6ZkobypmJbsK5BVdXJmP01V4cTiOolNNayk1n7rIokZgZgdVVyFVi -9MZvGSMuR4p0L+eyZs8K/J2oRIwVYx+851AuSLg9XxXyQ9vOb4++rMDwGDt7TEM0ZVkV2QyBTyQ0 -dBLGQxASZEJAvmbnOEGbQrmcvnWPkd4Eq4lnCab0C9IO3OPswIyy2b+aQs66mNM/GDuZmpBKvfz/ -s7iTbwLXxYtcjz8uf3i6EIi4zziG+6wjfTkYb7w8WHkM99Wb+N38byP87Dv2Gf1Af8/LOxj1O2ag -ZhmstdzUWZxHeJx7L/BeQNXQwMDMxETB0d3VLyRYLzeFIXOaxslci4z+jnj7XRU5L0Ud7TcFTFQ9 -KBLqdOz0Mb8vbS+aigInCTBl5TK9PjfxV5eI3Y3Y11XHzhicWCcwYap7RsaK099bJ89g/FxvVCcg -O+ftcZWTb4t/+br2O01nLK6B2pacn5eWmV5alKpXUszAKlxrPPdlxceKP5+rIgwcKjn+fnsJVZeS -WhCWWlScmZ9X7JGamJJaBFLPqa6t/tLOcPNlxcjr67asX6Ua7SZtYgAEIOXFDOV9C0+t6ZsTZrzg -y9FNrwunhjxybZaAmZdfnpeTn5gCMqbHeuuXR9JLqn7PvmoVkX98fSfzptzJtswzRZRLu4wSuCWE -olerSfpxa9+4NJNh6+ZXzFaMIt+eHTy6pSORl9Fv+vbQeNtnFkUf3262YA1jFLlWdvCxd5j/4iIZ -5ZbHk/PfBF36ZDJ5EZu5SH3e7CvTbsqyv3S0CeePDPj9V04sefNbNnlGkROzNPYtsY3piD/LV3Hy -I6fg5/UzJkxW4PAHAN+/rwXyCbNACgfLbjAM+4ObZHnPk1ONgihZeJxruMl4/ybjhhnG9fr6Cs75 -BZmpxQrlmSUZCtl5+eV5Ckn5pXkpxQqZeTmZeakKqWWpeRDZeDf/oBBPt8j4YP/QIGdXWyNrhbT8 -otzEkpLUFIX80pKC0hKFotSSxMw8oOaSYoXkjNTkbKBUcmJOjh6XAhDo6elpJKel6yUmZSrY2toq -TF5hrLH5gfECCwBm3DOH9BIT/t4qLgcIHzjBzu+VnFm8CrnY/HicuzGP9ecC1g3XzLIUnD3VixWK -80uLklN18/NyKhVS89Iz81IVEouSMzLLUq0V0oryq1LzFDLzFJzz89Iy00uLUj3zCkpLFNLyixTy -MvOyEhWKUtNT81KLEksy8/P0FLT0uRQUylOTsjNL3CHC+UXF/nmTD+pJbb5nFlAtp4NFFmixrUJa -Yk5x6ma9TQdlk7CqqKmB6lSwtbVVUCooSk0qzcwpUdJRUApPTfIGiqfDNUA8U5RaWJpZlFoM1WcL -16JpvfnJeX0bEWz2bOflYfR2BgBzzm449gzX2SEVvz6x86yxtWIoh/oqAPM/n3icZY07CsJAFABJ -K5bW8ggIEkRLQYhiIIgoCfhBrMLGPOPi+lbWt0oqb+BZBHvxHOJh/LTWM8O87s7l4Vxf7hmg5XkQ -zKNkEQaj4SwZhFE46c/iyTSJo/ESBANvECRJlkLBStNa5tZgAwzulSgwg5Pkjbb8ZQerWFL+S5CO -0mjaIXETvFYJ4ITpVvIACY1gbQ4xlVXR60CqtUJBt6ebVWqNz2tvufkvqwJ83wc2Fm/ddrX+Bly2 -Rsj0CbURIjITQnjOFZlTkDtS9xcym5h3eJz7xracXdXQwMDMxEQhyNXRxddVLzeFgeWH9T/52NRW -ocl/spcc2s86w6zv6kTVZhGN7oKukP1vZJbPOdcm+lNR/tR1Ca2Ne2KYPHUTi0oy0xKTS4r1sorz -8xhehvhMu3p2Vlx8NpPr25je6/0bF0lAbSlPTcrOLNErKWbQnHgt+hLL5fbT7SvPr9hxWezt5VbL -yQbMbgBPRj6o8gFTgMPIOjo42xSK+nm0jpzWjJ9Vm3ice+X00mnDHUHW4sLSzOTNjwQ7+AFWzghc -+gQWk4cjbhAqlskhoxqYRsrkV4bnx3icmyZ2TWzDEWZbfX2FjMz0jPLEyviCvHS95IIChYLSkmKF -RIWc/Lz01CKFnMziEoXMPIWSjFSFgpzE5FSF/DQgJ7NYIT9v80HmUHYA/Ooa2/qxAUC3yq0hHUXF -KyiI+LZgqWI+UMYneJylVt9vFFUUzlQLYUUDAcXwQw4TbHbr7CxBQNx1IZWCFmybtAiJbWHvzt7Z -HTp772bunda6bCbRv6BMYmOMib76KIl94hGffDCa+CeYmGj0xWc9d37tsnRRYh+azOy555zvO9/5 -5n79/fh3P41/UJqchOstCpQ1HUah4zAgrAHEs1rOGgWrRa1V4bcFvqHgdxpE0gZI3qSyRT3A6HVa -X3VkkXjSsYklhXlHcGbCZCk8ovVOl2GarzOXE0yZJStiFabSEK9OXBdsj7eBdyizXLIe/qq9MpeD -SQDsyeINKqDLhRF1ZEDbF64BDVr3m3ddyfG1IEz9FxQb4AwDLb5GPdKkBrSI16BYKJwaO7rLjHKG -d8eOh1+OvToePz0cm7j/55gxHtAPO9yTiEdSD2FQuEnr1xw5laCaJcyxqZDQzQFgeoGlyiCk57Bm -BV9l6MuwQC3uNd6KfzOgC77nZqEgWuT02XPpM/QuVHK9XI5u/nggmJ2am7lyefF6eVTtKlxdnJ8z -O8QTNI9FPUoaVxyXLm4wK8/oOry/8F5eN0s7TkQ3wGkrjGabSmJiUwUDdF/a5/WCkStUckHMoUos -NzqU23Dz8tvXZq7fTvsyE9xQrVZBjwHoMDEBpVtLpGifKr650j1zqneyZErsNj/iNBYD0GOE0E6h -4ViPylh8YPsoCYu32xiw+O6Urrrb/OF4MCJhJZdTGl6ggrsoWM7cjeS0UmpGQgV8JvyOYgBfrxHP -IUyKWOsuDp2hsFUDAmziYH2XC9pQMs4l0gjbx/cFSTZFkmU3y3CJM9tpKkh49AmDG+odIZX/TRmR -1PoziQoGZjzbGwOTwMIpFUYUl5Kbjgu5VUxLq7XzrlaStQbc6P5EFDFqHumq6yp5UKhEupO+x7LQ -FG6+4+FaOq6cI22ax25RYJihECnc9pklo26GTzGMTlEbT6IRKQv+C2cWuoDMBg8xQxnki+aSqrhS -GWI3i0dBJ/pPX5lxGWQ7GCn8c2cy4Q8dK8RTqc06QqgmUdJFlc3mXgJU+SCSDCe7qrNeTR2IiI6R -oP6opURbBa22+dXB3alR/rH/cEB8yRXpjeLJ7oASeqU02QDOrDHkMJJOmtmA2o6dxNLxBQUHVyUx -7XksfwnLowxciqZBle3UBoWR1okHjzDzMRCVE5DX+fodLGuu0g3xmEtkcyoUdpaK8cgu7cIzWDrc -bP4SLr+89/7ze5Z2P6v0F/6eOxx+e+SFN97BD4BHJPfEPDpDIe1Rr/usmK4Dl0XBfc+iwkQCzOZH -eiX8eN+9XXFsCPtP7U1+qClM4dWDr087NuRPJEhaRMyvs9FYUNbDq1EoIF+hdujFs9H0ph0P3bhB -OwJ9uuYzsoYmROouVWMdPturFcK/X9Ink/ZjmWFg/JyxpUITDX7CD23zQ9rPl4JBySemsoOnJEhu -XF5YnJmfM7Lo/20twWhvUX+RiqK2+oKpPk5eGvV0M1DZxlFW3dzWF69pR4JVhzXK+Ansk633kQK0 -qRB4iyg/xeaOvA5VoOPXXUe0kAhHxF+fY0wCJlLbVUyUWHW5Rdxo/7e+WdaK5wF6KdbeI8wMuNsO -U69sXVjSpouD+95HlnrmkE1t31vS9mhGXw+PLg5cBH1wUXQow9bny9pnx5QRnhh1bPvMinZASx1r -a/aW9vDTuvYgKJVgMUpUjL7Xd3hdAKNr0Y1SKFPCaUl1/+TRdIViqk1WYyGld1OiyMDPr483U4d1 -fGkO6GJUR5EDbP1GtcN7l1YMsPH+JJDl7edua3+NbT+oa+1n/gFrnrft9AGnAUIJrM8geLLjywsh -PNlwh8VdbHicmzGNcfo0xg1mfKzFhaWZyZtt+O7YAABPuAeR+AMU8ImG2SuAc1Vd2M5xvb5xJpjA -dnic+3+OceN5xg1R3HKleYlliZk5iUk5qVYK0Up5ibmpSjoKSrmpxcWJ6amTA7jt2YozEo1MzTZ3 -c3+JBgBnmRSYfhCwgv5QcgjQOn/ohvCk9b0ZXZcZeJz7O4Xl/RSWDXu8N5/y3rwPADvbCA36AT0Y -o0U5p1RKCLVaGjvlHpynn/7/eJzb9JD56kPmDZxTuEvzEssSM3MSk3JSN3+cfDAGAKWvDICuB3ic -MzQwMDMxUShITM5OTE/VLc/MS8kvL9YrKDZkkL+UU5Cw/s73OBujRYkH7szqfl7qYghRXpSak5pY -nKpXUsyg87hvduykNVYlHY/33zTQL5908Fw+UJW5qalCcWZ6nm5uYnJ+sV5xBoNP4ZUXn7ZYnPvE -NDt63ZW9Unvzn08DAGpENgHzkwLIZkWqNUL75lheL8+a8UQlA8pdaHicnVfNc9vGFR+rk2mttHWc -xIo7TadLREkAhQQidyZxRVEcJ1Fjx66SWJokLUkPl8CShAUC8O5CH5EZjptTTz2gf0DvvWSGvfSU -aa85pdde2kNPbabHXPveLkCAlOQ21WiGi7dv33v73u997F9+u/SnPy599tcLT5FWrfYgoYHfP67J -QHTS9SU7vbj0lbOwQWo1ESXcZWTT8/kWfEaJJJucxRGXYkudm65+64dLL8D27nHoVpcJ4Yx6P/MD -VvoOYiqH07tPnGxN2BGeJW4UCklAxftKm+9S6UchHhOkQVpwzJBMSOe+cHpJ6IRMOiJy95mscSZZ -iMw2MthSGNUydxh5zAG5aoF3qHlJHLCjGgu92gGbcLjaNzzpBpEAwpBHh7WE9v/X05weotJ59sn5 -/IecxjHzatk9ldbH6BpKGV/Tp9WylsQDTr3syEid6RAqtKvry8vK8y9I0k9CF/1HDsDzHpVs787u -XBTSO5d/nP7j2UuTKpF0AOEwDGuDHES+R07ADL9PzDjpBb4YkocPkcUiyjkkZIdkm/OImwbIJA/K -QgEGDxKfQ3gp8fgx4UlIDn05REBR2AwYFQyFGVY9U/JkSEdM2CIaMTP98qmVp2nPJ40G2DNKRGBY -FjlJ6Ysrk8foCuH7gKGykHFRJ3gQHSKpjwQypLAbRvlx5pEdcKh9X4CIPuMsdJm2Z7w8Xl521tbI -m0Pm7gu4MCPCDwcBq33QB9QSnROEjXwpQUzvmLyRhFXih26QeMBIPOYGlMOW2PdjYZO9oS8I/IcR -OmDAwB4akI9+fkclEOPp31+7MllMkLtMJIE0j0bBBhGSg1yIzAmJqRDM2yBhMuoxXlcq4oJAxipw -Oud4BAobxLnXFmtmc2Oz3QRprXvNzlq7uQU0q7mJCBKJL9lEtHtm695WZ83acmx2xFxUrRyihblR -EqI0E0M1M4k0tpTCnAuAljDgUqpfeknh5C4bbB/FZrfdFqsneHrcMMx223vFMrqWVsWjeiRb652K -1bThp64kIjAyeYCEMAkCBGFBSUKP9SG4Xvr+c88oaGSRAVePfIExA3cr6JNMsb5F16qXTObK0WDz -jvKgVmkVJlQ03fbFLu2zW6FkA+DSp6xZPqS/fG65bMMQ0pGGAIrH6If6lvAwM0BBr3C3CgwYpQ6Y -qh4IoxSOLO4FBxAmSCkz9akfJJyV5OSUIvUqzmbbmcFAIC5WHVVZFADQ5biwR1S6Q9MpEAOAcQAA -zSZpdSw7YOHgSTkkFQjMejldi5hAgkQjKLOSkYjnqQmhgsv7caBSV+QpqG3TTkCRp0xwoYacMkCq -MpW7plJbPJjtnHHuDIuVxwTxIpW3SgTxgYDaCapfMHbmbLT3VTTEaQuGNVIA3puVVw0r8ysmR0Wh -XXFtQm5mh195qA5YYOF8CLQnNhv55c6wFwqezL2qygTiX9kJQPSw9M0sBPdrw4obZFgsCozWWMsV -VmduBZBCgdStZQIVOBsiwBITcjmvDNBQNsge5QMm4aiaLIqtbKooCAAMqKbF9yHr7Rff5ZY038lW -inpptqSNOdaBK6W//nh1zbi5feOtAud96kpha0UqRNkSnJtWrGe+r2ha7/ndxsWWgH3Mi5go4QJ7 -BOXSRyUvi+y+yu0fst5tX2bKSv7WCYo9HZIT+od9OPQBowZSMqMnmJ34/c2abt7Wrr1mr1+z1wns -vXdj72a5Lsw6Huh+Z/fdHTumXDBTF6Uk1AtyWQ1n+g/NqC6nv9teudBNv7r5/ETt6FYQ88hlQthZ -Z1dRqJIDaLpgV7GdEYStZBGY9c7YAyomJhb7qlIRB1T2Iz4qeBUlHd/6wUTBLSdjH3kPZk/0r2V1 -q5npnXxxMtYrC39mqMjqcOYOZboCgo4DgGOBITNU8dwyMhefwYf3qBRda2E3v5QubdJOv7z0bPrP -29/rWad5KXd1VZV6OWPQozaO3mbBDV6wFPfcvgIRXvu/j1EwnSTQU0+hCMxdRPnsFohztA2aggtV -hBUoH+1nrwUzS/kqVBiertavTFCgmbUpnKqi/tlvBGtuvshqXYPcj/ywENpdPekB9DB8JkqzxjZU -zrzPOg65oYofVC9oyBFKfxsurSpmyCCmIDeBmZTm8vs8wmsRRnngwzaFSW8US1u7flS6Ueq88aNt -8HpVz+xGVd0Gvmo1zcB4434S+rjTLWj4ukLGxuqJJo276d9et9Kf7Fz+EOnjDRgZVGrqEggF1jxn -Qiw/wjKjQD2Ivw5zszXu5kNt+sWbk6dh+bEfY57kxTX9zd7VSwv1N20aV3+KeTIHkibOn/OlvL5Y -yglkWXr99dr087f+dXFf59icEGuhX0CfqM6rsbWKReos1trWvEd8oBPSSj8b3E634z9P//Dug5e/ -W3rYGtOvDz5aujUbJkXLKO92cEpFkQhilfkA69A4RRWjaB+ArRPo+vzTGWYbkcQqsB6U2+AY3wQo -RmVGdlJFYXrneOWJnXNtsc59qJm9xA/g0vqYnT3K1Ktt+otPvl5aK8upkl0VjLOVTLce/f7Cxv9j -Q0v119T55OrzNr4F61lpVTc0Z70i/fevrkyKzoHdYPaV2a9jWDlF1zE9RV8MWXMGxNIsAdUrCg6Y -vlX6+acXVw31NldZAp0XnkYbxZshV5E+elSZvvPpd779H+ysxgb2C9q5aZWoIR8G7aBGwK9Qpy1j -g09seJzbsIrrYx/Xhkts0/P3M4ox6mw+z1bG0dwsu71ZljFj4fSf+xiVDLJTUwsy89IV0jJzUhWS -8/NKUitKFMozSzLyS0sU8lKLS1JTFNKL8ksLivW4FLQUgqfn7GeU1FJIyy9ScPbULS5ITc5My0xW -KM8vyk7LyS8HGpGbm5iXopABJHKABm9v288Yoz197StGLp7c/JTSnFTdjPz87OLpB18xKoKFOVOL -dSEy24Fi+asA/e5G1nzFP613Z12mSJHQuDtEphpzfIoH1nica7KcYrlBj2OzDEeaCAAcOQPA8QFi -QdpVkJUORCQ0W5ALa/u3nZcJDHice8v0lmmCLpuju6tfSPBGYytGADhXBYP+OutQBLojQXPSugG4 -xA7LsPYnjczneJzrVH2iMiFAxcDAzMREwdHd1S8kWC83hcFtl3tXeGXZhvUrTxqfqVwnKf3C137i -zDyRlXKe06/139Ay2nZzhkGR6Zo1IUusN0szXmAUWRfbnLyDvzaOQ/Rbbq3wnYl/8m3nTv7PlCRS -zcb8/cMviW+RkbuXum9eZf1TYO21yaXMZSKzr6xilKrSyA1X2bzgrMfJL4nhmY2T/zMHi9wwa3iU -f3j/3IVbmgU4ZBfmfjIVa52cxmIlskikJ53v5f/Nvsuz64tXa3oz3FsYvnkLiypTTPNNEYdVTxTX -p3VN5eNTknRaVdIZYGIABAoZJSUF8VnFyQyzdIKe/unp2bNi7/rv9dsfWViqvzBDUlJSWZBazKDU -XS1m3LM/0puzp0TbyoPBtkardLIpu47Ilya/uyelaj+ay33K07h9vepxv/qsyaXs4aEWKV+vzS02 -CPnQ8GPz8us2O+oWya6DGJtVzGC4MKagT0TyXcYqD4fXCyxPrD1asB0mGV+QWFScWsSgP/3kowOK -5zoenXUsd9rr4OW1YdLcyYoclkZhtrpvNl6TTjjBJv2xZEry9QLO5n0wzUDvHDBUl0+Wlg7MOc87 -53OujUbuTYnJPRw9Ii83CxdqrPa/VLTMuuBbuZWkbJnG58k6nPEiDtNizILmflBs4tt8XCqv7maa -nsSRyfM5F4kw/JieLSt16kqB2j2JjIbv+sn/K9dMDuUyFfnwOu01840rRcJ9pxn1ZFMSbkff/j15 -Hpe+yIy7WzZqyIYf0J0n8Cndpq59+tIj7pMfcgWIzHp17o9jgWdU8xfjHouVvoe2q7FVTXblviJi -FLk6vczsUfZcEd0eLWF7w9yArfcm6/JYiWjeDf4749rDyS3H2DUkr9SKb23255tczRMr8nuGX1AF -16UHi+8/X79yFtv0DqfjJye/4bEUYZ6y4Gw9t83JTrmjvBXuq1pf96THbrbk1WYUyb1x/ZPHuWgd -43BPg4ZjvN8Xa35ImVzBZ2LhXy96J3LCDeM3v+ZMtK8VePsndwEvJCiLCxLL8+KLK4sZzuc6KJ3Y -WShrnbJ3V9dSNeWrXO+VJj/hOyyyLu2Ag8OhqPyHW3KPxb1vqZ8cVR2yeTe/ImOIgyND/8Z2nxcO -vV8LV+w9/E+I44cNxNjS8mKGE26SKzXOujIkisWr9Ldx9NufKEDIgq0U7m3aK3rfo/qCKa+hEPMr -bfaIJ6snGwj6i7zeeHnF5z1PlJ4/3/mG8XDM9wq2FX6TJwt+AwDc35ux/gg02v/ItrjIO4WkYV+L -Eiuu5IrPUnicFYw9CgIxFAbZ1lN8lYVI9hx2NtYmm83PgyUv5GUJW4jn0UoQvIV3MpbDMPN9DJ/n -8ArqzgWUYKAjhdjMdj0om7MGe1AVcEuYnNDsOh7RItm404kvifym/6kWWyhXGaeVlnlcuyA3qyoa -0QgqYyGpCqd+E+MdWjE5u4LATvC+qfP+B68KM9X0CEFt0jfzKkftFVW9nR1eFndfIMKQeJwBhAB7 -/7YJtgmQbhQatoV0pP2hZTmBHqwlSXJJPIfUdbGCYwEUkV42MdYUH6Mdf1LWf3Nm3+f2RGST+QGM -FFhmV9VKyAriRc3siWji8VVqslHQk5kCpBRSw1gRf5D5eUtRscinQWLit3QG77NRAwQBFByQgwTy -Orcg8wAYAHaUFSu39y8uk2kETY1BOpnwFK8FhLOFIggyd/SiB0j6pvMGJ61TeJxbWfiqaEOZ+GRP -cUHuosTykNTcgpzEktTJ+eK2jJab14r/ZBJWAIIkpfh4ZOn5UpuB0sHSi5m4kETfiatt5pHjY2S0 -nCwtr8poNtlRXspAX18hPj61oiC/qIRLAQqMTHUUwOJFqa6oMpY6k3vlZTevli9gnCyjKM8MVDW5 -UVuYG6HVfHKsotLkBkWFyQsVRSUsoAaVFmfmpcMVGetMPq8YMllFSQVsgJ+uuCzCABOY3QiXb05W -+sEiYWShYGunUJyak6aHKuurrs7GZGQxuUFDDMm7m1N1XbgBBTtc8/sG00JSa3SeNz9TALg4kjBM -KU97oMF4nAFrAJT/iQmJCZCIFKJL5288jV/G3dz0vurfj32VBLS6sZxZARRKRHTkIZFvChjh65Ei -2jIeqm8QOZMJAowULEUuFY8XjQZxf9QIJ88F1bjqZZmzqQKAARSLyFoWHWBFtm5IKxpW1THCluVz -zJM9BEwuFi5A8Ax1hOqz3lYhynTzW/NQaYxJaiipIXicuzGfecJC5g1rnev19RWCCxKTU3WLUwsS -ixJLUlMUnH08FdJyEtOLdRRK8rNT8zKrgIKJeUCck5NfnpNZXKKblplTkloEFM7MK8lXSCxKL1NI -quQCmpWQl5+SGp9fUJKZn1dsZQVRl6CgUZyaqpBQWpKZY2UFUh1flplaHp+Zl6lZkqCpx5WXWq6o -UVCapODn7+Ia7x8Q4unvF2ylUFxSlJmXrqOgBBKevE5fcnKAPevm3c6yPQBzwURW+wELXJgF0Y9m -S104bgEpOLM6uK6zGHic+/mH5+Ifng2LojZviEpmbNaNadeNYdyuG8Pk8wgAxIEMNfgGFfisAi3j -Q3ufAaFGx/CeHeyB/LR4nAFoAJf/8wrzCrBLAxQ4p9Ddf7AaplHITrTB+3C8cjheS7NfA0wBFFN2 -8J2+n8nPHdJfmr2gc+azf9LKk78EQhRxWZzg03iXOMpMJFbouCXgFNfVmJMVBUoUDhtEhUMIpvtl -Z+s9xWoCgSFWfeKIVjIJ9QLuFTsaVoycgpQLgAq8UPNbkBqB/3icm8o9lXuDHrPI+03PzeKP+q94 -a3Uumt1VbE3/8/7gyY3M8psTmU2YADIDD0j+AvSGVkr+oI/muXT0++vtN5xwinMheJx7m7Uie8MS -CdmM1MSU+Jz8ZCuFpNK8+MTiEisrHyDPytU3ICRycqC81OYFEmdlALSvEW/2L0V7xpk/BGQR+6Nh -LgKAmFHqUQf+eJx9kc9r1EAUxynoglEQkVWEPTz3oEl2zQreRmwtWEXogtYKG7TMzmYnZmgyiTMT -d0NbemiP3ubgsf4JSg9e1Yv/gt79A7wJHsRJ9gdLUec08+a9z/t+3/v8qfb7S+3dD0e3XOv0DVnw -QL90G/qodVZfcp+fb8OgmaTDPKazv+5fYg39zb1ZPxFvbj3zvC39+ODi8dXW1zrtdDqwkXPFEgpx -SoZUQJgKINAfEkVQH55urLdhFKWSQvdhdw1UkVFgEpiSkzvJVZQKpgrPyvIBhBzKSpyLGE+Atnqz -3Fhq7A9yjgWVafyKCoTumSTDRigjQlI8YoaSKxxENNi2FR0rx4Lp8dJte+FF+BCriHJ7d9Zod97S -m7Z0FvJzPhIkwxdSYa9XvwhtyrFj7emfd7/vG/9rRlChIsZfAAkVLd1X5kvv1yUEaZKQ0nJGihLf -BsaDOB+W+f2Vvld1YiFIJUxIIhQRiTNBQzbGpjYrZ2vLmAW03EVFbjqwMxF4/H711GWXSTxzAHf+ -C9IrvWubc8rtChJTBUmujD4VmXIjZZG3M5/EfYN8ZHIQYpypauSYk4TKjAQV+NwEbKqajqXfenX9 -sXdLH72u61X/Cvon90lqDJ5ceinGq/Y4Rf3qoTPerEb7fqtWPfYODv0Ph/7S8oM/LlH9u/sGkOdI -08XEo7XPwVTbOY9Ehv1JAuJ4nPv1nOP2C44Nsv8mH3Bn4cktLVEozi8tSk5VsJ2s/s918gVPlukC -5oxsSnoFiSUZenmJuanFBYkgaQVUAWsuoFpxrqSibKgBkx9+lp1+V4uRs7nl3/aWf4xlpgAYjisV -+wHGLMlPuQgrYYnfaZVkXarWe3wVG3ica2RqZJrwVuTI8qjronFXBOdlsv7Zzqxd9mVDxzsApzAN -Cf4BIHbplHmVk9OkYzQhKnsb0NBw0g54nLuym+nKbqYNTaLc+QUlmfl5xfGpeWWTL4pLbl4mqtcB -ANGeDOHxAm21DXexPT06pugBlN4+LSEfQPhMeJy7w3eHb4M5k4jAxVO7X3MqGWzqMHlSYBPEOvH4 -aqXN3kyCrADtqA0O8QLBsv/2zMov/K6F9fIz9cQfjN2INHice8v3lm+DCJtIRN9+o6rYLUqnPhUf -vMextkn/07qYzRpsrowA/s0OsPsDO0mGayLxJXckbkcZQ/OyybQ1lGV4nAE7AMT/ng6eDrC3BBSW -gWHgUOmGgftZ+D6PaQjYQ/hAQbPLBAEBFK9nQRJk+WSV0OZyGlUOImZ88BCqs+AFPgEpZBoP8Qpd -vPCQOBToii5hsHHArw7Bok4VAnicOx9/IXnDdhXf4sKczJJUfb/8lNRgMFMvuaBASUdBKas4OLUE -IhRYmlpUGVCalJNZnJFapKSpo1DNpQAEiUXpxVYK1QoFMKnJAmqBAmApBSRBH6WOyWKq/KIQcYim -6CS9/KSs1OSSyXkyYpOUtViKUhNTJusri01OVPXdvF1FghsABWc1afENKRY39KBp2udHsXO4Oset -h0XXUxt4nFt5hKnzGNMGtizR4vzk7NQS/dCC9KLElNQUl9KCnNSKyXJZ4uzFGaUlKfnlkxmjJSaH -ZQmqQVTGJ+WnVOolZeal6JUUW5VCtEF0heSH+ARPDihUnrwmS3yzQJYeR4hzfkFlZl66QmpemUJi -XopCQWJRMYifmZeRWpRZkpqiUJ5flJ1apJBfUJKZn1eskJRfkqFQlJqYolCSkQpSnppXol4M0p9Z -lJ+XC+TpTVaMUJ7sW8Y12TjNe/K8CLnNv4r09QExAE6Y8AKef1BVngBqChVJGC2yjjdrJylHn3ic -e8/0nmmDHqPIx2snmNc3niq42frQxzu62NDF8sn6yU6MugD/og66+g9C5wDuHLtGDTJAccajUwk+ -0whFd3icu36c6+oprg2ZL0Q8g+ODXH38HV08/dzjA4L8nV2DgydPPKo43WEvI8/kBxd5JjfM5tpc -/GKFn3RxSWJJZrICVh3sSQY+/nkKPpl5pRU6CgmpFanJZakJCrmlxSUKefklCuWJmSUKaflFCokK -OfnJ2QolGYklQCJVIbkosTgjNQXILkpNTFHITaxUyMjPSZn+fx6j/PSGGUwy1pnFQak5+YkpmXnp -AUX5yanFxRqaCrp2Ckn5+TkK1VwKUIDNWVMTmSSmB0xmZG0XMWfcLmLOdDgHAIMOV13xAmplQbHe -/G5dqPhN8DEsz451gF/xeJz7zvKdZYMBo8iJ5h1uxUc3cqrtOLW25cE94WBOxeWbXRiNGQEC+g4h -fjkNnHdxEsnynvzODRlAlH2jKhKGeJy7uIbl1BqWDWxSm3mlXP4AAC+9BebxAlOrm2XSruzqXEfU -JfMalN5rJy9ceJxbLbBaYIMUo8h1Hcm3Yf032Sb/S7Zs3uM9P9Lj1MvNeox/2QDsNA6y/wHYTT56 -dFZcegzk5BONjPqmnl5JwnicAR8A4P+hCqEKkB8UaWzj+CuX5aATg+26YMhS4YKt9YmxM+4E7wcQ -LPsCaAdAtAY6prq2LyCKNg4PfntBVat4nJu0nnXtetYN1/glEvNLdBNzcvLLdZPzU1J104ryc3VT -Mouzmy/zb7/Mz7jfHQCCBRFr9QMLHj151SfZnAucRitfDAtVCFMWYHicATUAyv+0BbQFsCYCFOKU -AO3sTZY0JRzejKb3CCfyzq5rkzoCZhSbE+EQwGU/14AimG4sHM6g9MV/M3OaGAH0KY4nKN/hDtOk -9q9kKOX+tqq5QQTxeJxdkU9r1EAYxg/bQhGxBdmDIvIUZDerafDPbZeUyl7KCoK092S6ebMZmMzE -zMR2bcviN1gZ8DN4VPwsevfmzYsfwMlsq3TnEDLzvr/neeeZr786n393vmz8WIxVI41GzmvKoCTt -6UIZVEoIDXbKuOFyhppYXUY4LmjerwnacCHAJUxBmBxBKFX1NVLZlIknU5w0BlMm+8YrR7fgVtWc -IJfIuHZqlCVTZ71tgp4mkQ+wtw/+4rn9Gd5dtAWDGE9HnmuXIIPSaTbajRmjRaKCv6PVpz2NuKE6 -0WSCwX/stOCCPHykSgq4zOhs4HgPSDpzzTj/131lZC/ebD1Yc6hMnTBzJWCXF/cWWiiXG3NxKCnm -mArG3aVcJLVqZgXSGZmES27SEFqBrSZvIXCNtsCZ4O8pGznEnXgRl3Pmchyrap664EhkOlqfDkEu -2EyLEEwINWVG1YmZV+SvJTXLCecIgsftQwwi3xvieruOXI5uyK+CfxK3LzEc5rUqA1+3y9f3u4hj -vLzmjx0+HE60/Zh1O70e7LNJZHfGm/ZTtuP3Hw5229qG+991xUd2+er2nfCGm3172N30lt/+fI8f -/gUoa9UcoCF4nDM0MDAzMVFwdHf1CwnWy01hePJZUVV66sJj3KkGe1tdZoQUu397bghRFOTq6OLr -ClKU0D3nZxhPV0xIB8dJ+/RdKb2l7YEmBkCgkJiRmpiim5+mW5KZm8qQoa14XvbCBt21i35GZd2Q -sc5kfjIPalhSaWZOSWZesV6KXkkxQ61z3c2+WdE12XNV9LWMOzPknQ5lQwyEqWPQeLwxfI/J5x6W -LP6Tpxn1LoQ8X7MMpiSP4ehs1lUfD/38K8M8j/vQfkvld1dWJUBkU8sScxheTuCxa7nsN3eT//8V -WnNu2Vy/9OcT1CGZeSWpRXmJObpp+UW6JanFQMvSQU56p3rs2UTLdQfYBSxbvHpCaxlcT+RBTITp -YNhzeO2/RKcVZ5dvu/Xu6eXItEWX3PZBlOTlp6QyqJ+J2+m4zfOF2bYNc6Lmbbl1R3f2OqilBUWZ -ZYklqRDPX+R0bin83GhVE20sdvP37z+vulx8IcaUZGQWpRQkFpVUMrxpajV8sXft5d5bS1IvqfKW -B5y+AAvKkuLk/Ly0zHS9rOL8PAb5d2IBzesWrFNJmt/+VJvp9qsNx39BFZYnFmfqFpXm5aUWAdUy -xNVs6bnt3qcj9Uf7kvnHvZXTpuw0AABUiduXogR4nDMxAAKFzLyS1KK8xBwG/U15L5cJRKckrbNU -VVpYxNsgKxdlAlaSl5+SyqDBe9JySdHm0E2KU46eUXCa/Pfw92YA5+wZGqAKeJwzNDAwMzFRyCgp -KdArKWZ4Wl6aeux90t8DASf7tTau28ZTGv3UxAAIwCoYRKzbC12dXPZ8kf2afeDq5Vc3XdSNDREm -GMYXpxaVpRbFpyXm5CQlJmeDjJRxs36b9Pj755wLayV4y1c+Y57q1g3VU1CUmZtflJKZmFOsl1XM -UCQwU19ixvW27tD9my7cKI78vCyBFwCtzELl9xHZO53rzU9bD8/mfXs/0Uz7coVh03icm/+F8c1X -xg057D7Zjkn5RSXO+XklRfk5OalFCrYKwZW5Sfk5emn5RRpK6NJKmtZcyfl5xSUK2Z55JalFeYk5 -wfnJ2aklLokliZMr2O3qFRyLs1NTFIC6FUrKM5NTdRQSixUy8xRKMlIV8oEEUDi1osRKIRFIA43J -TaxUyEgsS1UoSi3ISUwG6kRYrwe1qji1qCy1CCJupVBSWZCan4bNfpDbJ9ewS8mBrMStbPMX9uo8 -fjSPbc4q28oMAMxqZ/v/BWmOgD69BtpFTNOFFpXExWwqk0ypeJwBXwCg/8wCzAKQxj+oFcJiGZL3 -IKdh67nNXAGBt/I3szEwMDY0NCBfaHR0cF9zZXJ2ZXIudHMAARkC34DxbwV93kAUm3Z5YMRUR9iT -BQEzFOEYFv/6xvYm6vONxsLqstB+OK0FzCUreP0FubNjJy8MMK4iWWs016OPauPno1F4nDtyneX8 -dZYJSxwsTEySLJLNDZOSjMxNEs3MDIwMk01TDJPSzE3MLQwtLZIs0wwMTU2TUpMMDCxMDS1TTBMN -zQwtjE2NLCwsTMyMGp9sfcLIrMXunF+UnZqiM/2xFuNDAFyBHQbzIudEd7/6lZSkInkv3dDxG/DI -iNbyeJxlkE1LAkEcxtk1JJTCKImC6O/LQcFWuloi0dVcoXPkuI7rps4sM7PkIuGhQx9gCS/d+gKR -B0+BQR+ga5cunerevW03c7PLvDzPzPPMb24fYq+T2N2btNGHY8Ew6hZ+ZrVZNuoMMdtZia4vc0/j -+Q7WkWY7L5IyyOfhAAjqYnCtBjQZ7ULN7CCD+AE1MDh0KG3jBlim7/uOYjIqqLBNDJQoUKGgUeI2 -WJqgDJhFeAFEyzXdgYHAPQFd1MYcCAX/IdDCA4aVSNMimjAogeqsN5OF/kUkLehhB3GeCTg5SAZ2 -ydw8aXYvYjQh46uQKBb/HQC1foY1oXAsnHYuWg6mz6imwdWp4AZ7hBD4ngIgYkMRCD73Xz/akZ9C -o/2wuhXAGibe5dXYPJKnLnzjeKtNF0W1hE4Noh9hzpH+2zjc/ZDjS3+6vCuXk9R4kpJOes5aeFtW -tHHiRpLupbTzeB0fnn7Ki1elijwuVUKN5y+HNb/s/QZrcIH+k/VRo+7RpPLalOi8T2d/3Xic27eR -ce9GxgmzHVJMEo2SjMzMzFOTkpMMLYwNU81M0ywsE1MsU0ySDc3NDY0TTczTTFKMU0yNEs0NDVMN -DEwMjFIsDc1MUxNTDI033m5hZMssDg3y0dkcx3SblQ/M1kgsSi+ONojV3OzPkR8AAGQjIh7+FQ19 -2IARuMiXFOtjtEleF3R9H8NveJw78ZNx0T/GDVaaYpnFbpl5mSWpGmWJOaWpVgp5pblJqUWTZ5vL -bbbSfCEiqKNQkFiUmldipVCal52XX563Wclultrk+YXqk+1SuDbvSeGRmOyULDGZP559sm4Ee3pA -kH+Aa1BIZHyYo0+oqwaXgkJqRUFqcklqSnxJZQHQguKSosy8dB2gREZ+fnZ8XmIuimBBUX5BalFJ -JbJYYnJJaWJOPNSFiXmVOlyTGSNUNEP9vP38w/3iff1dQn1c4938g3wdQzTS8otyE0vg+hVKi3Im -/40XB7lS3DfAPygk3jEkJMjTKTTENd7XMzjY0899skyJiaInumRIZIBrvKefs79vgGOIp5PP5MR4 -kcn6JYoyGCpD/YJDA0Biri5Ao+QABXt18fEKvbTVar/4DDiW+t2qU05RY1tyTNJ4nJvD9oZtgo3I -06erlt6dPLsgtmrdu3ueF7unHlc9PTHAXuTBzWNsjyZsW/I0qef/j9DtX9wv7l25cfFrRpETTa6n -OG0vq4tvn35DRMw8czpDbPjkRUxVAYYGBmYmJgrFJSmZ+XolxQxL/m265P/Ue2f8xU1frE5fX17I -8lEAqqa0ONUtMTs1JDM3tagYpFbgq5jNM+sjCmHlQqozJPJmTWkLswYAnXJKa/4BssWWlt0FReCv -dd1QQrvHj5nSehh4nNvm/Mh5QxUbc3J5yuYctvU8HBmJeXmpOUGpmzmE1/EBALqGCy/6IxdnHgMm -Dk0/JMs5dHBrwF5r6V6aeJyFkL9Kw1AUxtHBgjg4VBAXj1BKAjFpRy1BtOpSXHRyDMktORhv4j03 -lmCKf17hbg4iuIvQF3DwAXwCn8Wk+SOi1vn7vt/3naPE8+XLm3FtWbALkpEEEXOQviMBCdzwPMKA -eYAcosBxGZAfjghQEgwzgQxwKFcy3QsZmYuQZXhGCZAk9cv4YW4FG1qCXcQoWN9xfVaJB1yKxNR0 -sG0bpIhZr4YgHRcBrzLvxRhI5OrdWB38UtFuz+jQzlhiQDjiTBjToq9K9WpsnWa1AFoZP3Iis+U7 -lId0SNOpmMlI5YQBSwpt5++ZhWFb6ZsfJ0Ueh6D93K3DVcmvLq8fP+tp6rHT1Apm5ddBMBkLXgN6 -JXg8WTBxfvkbbB89dd9ZUw/WklpfaTzddebUbbe5kab/nDRR3ZvGJ6cJxcL7VR9fqrC4IOljTTHw -enOtRHoGM0oceJxtUz1s00AUViMRoQ4s0IqN1wAlLkncpCBIglugQ4WEoEiVKkRROTvn5qhzNudz -059EWZkYsISQWEBigwGRFTYmti6MDEgMbDAAK+9sx01bFvv87nvfz7vz9zeZl+8z755lr642CW84 -dK4GO2A3asCDlklFHXwqrzuutc74Wt5MFjUwXdehhGsDHHT7T7Nvj/V0HW65DXrOB+YDgaWluwV8 -LTKPgitUYX6xBPNuq4ViRYdxChKZfLCI4+yTkiKgGpjUdgUFTiTboGAhM7QFk9THNpBNCg3qW4J5 -0hWlUQAW/jxbDXfHTh/hCF0N/44ZeQxTGGauwX9igDEbPhmf6H8c/3ovWwCbOTT8JU6EL4R+P4ok -4YEnXIv6/oNaJOw5RKK3Flp03LZKq6quCtQkEh+qQjcltIkPZsAcCXZsMuG5bT6klgx3Ra//3J8Y -yeh6+HnjVJ54HuWNNJ9yAu0mFYpXPZEWRUqjYTFYDh8Hd1Tft+BP+GPjZq8AgjaYQNpFIptaHcW6 -o/jABB4WSibxKSctmtfAtfEwfClwCgVoM9l0AwlqaLUIiU12wC3JXA5pl9qpJU0a7CAGJ25DXm55 -FPm8Hu7DhGFALsbkNPQjA8Hx9ShAX/lcqpDTSvt4I7OAJ8x9iRmXGW+4bR+MwbRK6bwNJdBmfKaS -i3scKtEUEbKH8Ol6amuPZXIyzu9QvoYWZw2opDWrScQ8urom82UtIr94GfQpqMGUPgg58IVKEq+6 -cahzWoMOzPQq9QSu5BMwilUvKUKChEo1qV8xoFypqI3tSClKgNQJRzeNhrcBy8VyXMcRRNTABjaS -UEUo9+pYRb2Iqg7FIjsYIPqBDttn2rDxGISDuBD51pXvTufAPFNQtaIp1MoKTC0MDSymUt7VhSiW -h3cgDcvgPJTrQxumoGQ9fHXjeA+o49OUxDhEEo9lH0F3aHLJxdvrhTnI5fBUo+y+wyyaj1wUFGbv -V2EcD8cmVn+hfWYkG/+j/fXN6mAdvt6qDJZf0mX/6PaHTPi7Uxh8T3Q/nfwHiuasJfwmATJ/XSfB -eb4KWC3/lRod+yqASs54nHVRwWpTQRRF2mqJq7qoC0EuBakPkzQbFxq6SEJDC9GmfVkKyZi5MYPz -Zp537rMtCP0EF7MT9BssjyzdulLxS/wGZ17UWsTVzJw595x777n4vPL1y8rHxtr5aK4c8JxQyG0H -XUvKvEjTASCRJXhVYIFN6BjoDA8CTTAQckHGwYniOaBhUujAGlAMmXiJUQzB4ClDYQi1YJQwE0oX -hJVAbWcHotuSeF45BCC3xBHJmjDJC56AkIHSfTo+HncPRul4dHg4Tp90BoM2TDj4TACznKN3MBZG -/ulLsfvdVh2slugYZoocN2t4WrlMrQlYMAnT3lyOuxen9d9WHw2X8F9o39IoaARkqw6tpH1VJbZy -lX8UB7os8s/ebvs3qxu3/8P0Pz5t+tfX75R7a+sPakOybHtCa/RHu/cgalxCtJXUa1CB8S2ea/+9 -laz/umPZa7U3y4v+u2vl2f7D7HjfnoREzBmwyqpYQtA52Sm6cApyIZeYgLMFTRHsLGwRlGEkIzRk -VhYa4b6xEh/PwkZ52kz8jcXdWz2b5Uqj7JPN0qrWw/uGl4tk45+v8sPCN34CCjTjBP8P9uW3uMXk -43UM/pNZIEbZVHU9Rv14nLvH18e/gZtJZLbEvNmSu9xfxb/24mVV3TBlzqG3lzfLM9UyiphbCsgt -n7Xo5zMxLs5ZmXeO1e1VerN5A7M5o4j0tKrrc3IqCmdMvzEzaFZpwjW7a3KTf7MsFZn/n6HTzsnb -Z7eKKvOuuyXGKxY2t07ewvq7vssktu3N1L4VtkFL1zw5wtDdJ/K+wcQACBRKSzJzGAqrX0wWW5h/ -VyEmyV3+1Az7X1u2LzM0MDAzMVEoS8zJTEksSY1PK81LLsnMz9MrKWbIM1m6tikjzzZlTsimF91S -/slMZaWo6vOLikEKn6bMY+K10ef9N9tlRV1NpsGzxff0fkzmZg8GAJtqbMb7BV3och3HKxH4rnuH -7XbZ9zQ5xGPbeJwBWwCk/9YC1gKQpxQ8zvM1W14oRBI3wt+duYTFWNGI2JG7OzjHJEsEKN5QNQGq -jngwYuK1zvRqzjEwMDY0NCB3YXRjaC50cwCe1p5+mRem+8pWl1MincRia2TP+5MuASh9/SmL9gTS -zP0k1FaTBfy+1+FyRw82A1zLI3icW/GTrf8H2wZ3XuOi1JLSojyFotTC0syiVA2lzLyS1KK8xBz9 -0qIcJU29kvyAxJIMzzS3zJzU0CAfDaCoZrMw33ZhPsap6wDN7xnB9A8zLF32pQiUZSyDwm7X9qZM -guNylnicO/+Qccpjxg0nJCb/lRAXqOZSAILk/LziEoWCxJKMyQY8orqlRTlKmnol+QFAAc80t8yc -1NAgH40CTWuw4sw0BY2SyoLU/DSIDlZJLyEFhaLUktKiPLAISFntZh/J+5b1ILWewfHO/r4Bnj6u -LvGOHq6OLvH+bvEhnr6uCmpqCiUZmcXR2W7FsQq2tgp5pTk5mmA7SjKK8ssV8lLLFUKANrkWFeUX -aSSoVMNV1ypkFivk5ZcoJOYp5CdlpSaXKGikliXmlCaWZOalK6gXZ1alqmsmMGlab9YIXi4LAIeK -UE/xBdUKScIRvY8KB3HM6LQr7hks2dROeJzb6rvFd0OmCG9JZUFqfppCQWJJhoLi5Amionpgpq1C -UWphaWZRqoZSZl5JalFeYo5+aVGOkqZeSX4AUIFnmltmTmpokM/keSLimy+KPBEEALlMHaL7ASSq -cBwdDqFMYKLddJJ2gobw0xeveJxrYmxinJAnEhArk7syYe/iXCPPW5mKjx8dX65fBQCRgAvg9QrZ -ZX2rt8lOCC45CqdRKaKxqjwLrXicu653UX8Dj6BeYnFlXrJHfn52cUhmcrZeUmp6Zh6I65JZXJBY -kpyhoWnNpaBQUlSpUA2kJ+8WUJpcLyg22U5Qb3KWoOzkVkGByZMFPfkVFGoVkkHqFaprQeqeCyrZ -AsWATAhZq5CWmZeYkwMxRkEBzdrUvBQ0SzdzCfmyAgCtAjTj+R+qOxsMQbQV14esJyH18fjpOLpV -AnicWyeyTmTCMfvceufGhNVLj76dPL1kApe415QvN50MDQzMTEwU4jNKSgrii1OLylKL9EqKGZiD -Cx+K3Li7qnHR/Fnldz5W5C3/sn4zK+NFRoeuGxdVCtLu3lCLy5nkHHZtV5PM1cNQQ5IzMnNS4guK -8pNTi4tBpiwXv5Qawq+zbgrLy7WeD7wk6xcs0JwsxrxZ5AP3+elTbQ4qt16ZtrF54l7/gLVbr06+ -y7zW9ObEm9vTmg2//3vxRv7V/gfqiysefYOangY28mr+1vT3b5qr2nSsiv3dNj/pexPAP3k/i7HF -80wpzSnfTxlYP9Zu5NSanfLmUtxrqE6Q38CapzZcNa5w0PO1X2Vlv0B6i7CmTpnhZC1W1/DohLSw -OybS4qnnIwonl74zXi32pRmqOS+1BKS19ZPwc/8X50vXTbGecPs/579tDLk7oSrywWZvT7l+bem/ -jtehciduLPN5dIIhgJd38jFWC5Gj9RWy0vdtfuhlr1pu4b3nlILAlaeThdjsRFSuXiurkl1XcHht -9YnuBfKSLnk+SZtT2NyZRKb/ln778Ob8B6/vZQVLaQfX3ZCt2Tl5P8d84ajVqTf9v9YZBaav+Vjy -b/a7+Xd3Ty7kjBOZnbe8d5KDb+e8bPtnicWX/ebuTH45+TGnNwCkhOcR/4gBubNjJy8MMK4iWWs0 -16OPauPno1F4nGVWa3ATVRSek6RJm7Y0LbalNLS3pS0JjdDyTJuGUChaoS1iRRRsmSW5bWO2G7q7 -aa3YQWWUEacKHmEH+aEwOj5+CLJKZmTExzgilGFGBB8IVoZBeQgCis+K3t1NIeqP7ON83/nOufec -czcffWHZu8+EK+ElLDZVYqEpA9tNP5atIZHFMbmRciEqSh4SaaE01CByYcFDYnKwgZMpGcAl5jI1 -x/qMRT1g5ywWN1ljx7acW9Vg1t0mHM5uUWfmbAS8OHbHWuInrf3dq6K8qzQYFSM0VOr22YNRQZJJ -pDUajFA5iZGwJFHmd8UE5jQv1tFBxWTmv4D/OzRRoVPuIv6C/3kYSKkbn07JE5IVlwrhnhhNrDtJ -cV6/TKVlYliW6b/4yfYk+gJRjIo0lMSkhoWF3G7JK0yWaAx3di1jGyo2c2KE4c6UsvQkXKmqBKf9 -pjbuys113nBmCwlTQb6H48MhTg5HWRLqidxSQGt+CMX8lrKOmBDU7ISVszMaFjqbqSRxndQVXa2Z -Jb1qg55i9aAnLwWq8HL1chSnefCFaS47SXACU7C+sjCNBAKkg+MlilXTd6iXp18CPNJaiGWzKvCB -WcvH2AnhWSFFKsV42Yeds9sscldYwqHZM8esYSBJQMSPVi9JHyCUSRENwTLvIpvOmDoVo966XEKM -tUpU7NUrrgsV+/JMjHzYWzzeAAJTumR59c21+zStMTWTc4xwNwMSCa94x2KuN3vzGcjGUE1AE9pe -MyFFE56Cjlpd+XjN1BuuSdlm1eZja9c4dNdWTjSg5OwW63ukxUjkpKmN+Y/Eltp6p2EasI9etZ9I -5ZgoEBeunTUujWkYDsqLTvAirSvHvXOy8K26qH5v9vdpd/WSfyHohvgyB4qBvfrz1/WZuDVQgANz -B/X3GfUDeKh+hqmXQ++8J0YfF8z/FKsbmnH/GRfua8hUrzYMAj5/2zrVe3seYKxxW4aHrIp1rBBI -Jaluw6Y77sF37ziR4iGse/GThWuzuiUaZMdBkOP5VVwwgpsWbcGapkJc2uRVn24ikKK3uTrcnAp4 -veWQcrgAxuF7rZlq6M7d5nRts2sJJ/R7iI6keshKKfwQDagf3R0xT0iCO8KiJDeFBeohXcYsqm/f -W2PJT7zoCVa13QCxpG1n9igWof0MkcUYPtozFue2ZatV7WetagHNs+FRPh+VWD6e67lF3dF9DPDR -aL16KNpjxilvZtp4Y5hwm3QS23t0Fu7oLsEqKRMbYo8zz8yMjjDlQx7Sy/ExioHe8za3m1We78D3 -aS4u7ntZvd6HgG/034WpD61TbkmD8eg7mkZYbW9MokQTB6tL4LqpoYVVDX4sPpaOJ3e144Ejm7Dv -s9m4driQOZfYRldZ3VCnFh8rMlklWWSTrLZ8cRLs/9GIf+XA4V33M41JCrihHH88k45Fn6XhMycP -Iv/NNJPPjk+eKMEvvzll0Vxx68VJmPatz2a0og+XnDqa4dbH0rAoPaUwFref/tBlWI3eT6TUzK2u -JXdRdqiH6oykPGQFVk/MxWVSDhPgQlGB7ycGtKKtbQ55mAgxnid+bQwUhxvyWIIr8d7vDmH591v0 -b4jytwsmsfa04sKzBehYnq8Wn+fASPa1CxXWpLTSS/x+Q6+iAkd+kHWSuvXiECj7ssCKzh8y1Mcu -NwOev7IRh/1OfPNqH87/6RWEawVmFgs3LW3Hsz+vx6f+cOCea2vQ8osDH/xlE5JfT5i7pU78++ci -qxjtXiCE1Fd/W2xS0/+0AuaM3Oogc7SNYIe+bHxKcMmIDwdHynD3yCQ8PrJT3fBXI6gXru+Dza/D -fbi+sVSpAPhLmWmCpaP1jGeaYS6YWfHiUQvwkKI3Vfz3FHgr8awM2eCcMpQKvVrGe+wwNTW+MAdW -meP7c+E0KO15YIt/mw9DJuXj8fCC8kghfJDORpDNFe1luSkbnPBcGpsoo3TK4RIgyn0ToC9VnzIW -QykrgnKlswhalGvl4FBOF4EL3MpcNxyPmwnsBjNjKgdLYPpNlyWl8OyeifCOyWooK5fKIaq5lMa3 -VcCHkD3KNKJqhR4sAqey38UucyrAqvxZDhPjk93wLtjm6/8HPMrpyfA5681/APzqFBr4DPeLVQBv -tLZ3Ks7Wp7YQO6ZDhHUeeJx7+ZSx5QXjBja+YB2FxLwUhUSF3PyU0pxUIJWcrV7MpQAE+voKaYnJ -JflFlQpFpXnFCpl5Cvl5qQrlGfnFqQrFQPHE9FSFzGKFkgyINiuF3MQUoEjeZDE+JXaoEZst+AwZ -eVGM35zO/yd8cr+TPJumQjVQ2eSzaSbi5RmZOake+fnZqSl6BaXFGQq2YAOAckqT7dIF+DzzijNT -Uv1SK0pCMpOzJyf4SWzOTG/gBgAArkJx8wltX1LP1nPOy8qe3aRKxhq3JDQca3icezif5dscloYt -jE0cgVwKQFBSWZCan6aQlpmTGhrk418UkFiSoWBra6ugVFxSlJmXrqRgjyZppVCUWliaWZSqoZSZ -V5JalJeYo19alKOkqTd9Ahej3PSFHIzdk500hWT1QWYXA8Uzi0OBKi0ci4oSKzXKEnNKUzWtp+ox -Jmwv42bMZgEAb1Aw5vIEbHudzGLiHziy/Dbkl/RTUaU4vrh4nHuZ3JmywZZH1krBMa/SOSMxLy81 -R0chMbkksyzVSiEpPz8nNTFvsyuPNKOQRm5qcXFiOlC4NC87L788T3NzOm+TCgAWixcs9wpjtStH -70jBgq5mpAPj264fE0ZtInicO3ya+fVp5g09bJPt2VUmv2VTnSzAriKroFCrkJpTnKpQzaUABsn5 -ecUlCgWJJRkKtpM/Sgg7lxblKGnqleQHAIU809wyc1JDg3w00oB0XmJuqqY1VF9mmoJGSWVBan4a -RLOira2CUnFJUWZeutLki+2ik3XiuCY3sJtKgRTDdCvYghVDzKjdvIld8B4A4z41jPkKRxogY5M+ -W96PQ63L6OUeYrtjdWJ4nNvZwbyyk3nD8tTJTmWiKgpqagpFqYWlmUWpGkqZeSWpRXmJOfqlRTlK -mnqZxaFBPhoFmpMtS89OdmYWEocIl+QHJJZkeKa5ZeakghVMVijbsNkv/TYv1UzcrFAm6QcAu9c6 -mfFTaQ7bujGLh+2OjaGnAr/Ba5/2KBh4nLVTv2sUQRQmOzGQM000IeSH5EVJ7g6WjQlWdxz4A9cE -Yrx4J1pYZG93LrdkMxNm5hKOkFhYpLARDhlELoIERMSgNodNLK0s/AOMjd01qdPo7C/1ojaCW+yw -89733ve99+2XRu+rB72v58zxBADHXjkDM0KsThcw5y4lurrFjFGWgav+IacuagP1RfN8r55Iw4aK -umVIBRn1d6b+6DI6pW0m6ovXhup7ptk3OQnz1MFJDnjFFVc8ynFGWrtav5EMMEmwiANJ2w8kgRIb -gys4cGovYwEVi0MQcuqGOZy9VBaYFYJQ6q9kQ+gfaU+UmbWC/ZCDuWC0xsNiGShR6mGLhJLk1w60 -IPuhc/iCTzqqHXCfL6b8rnpYW4egYDqdVSU3AXsc+/A3NW3wbDtKh99h91vmdsvsaLZMLflCbnHU -Je8eauek/RaVmi8PtbUTU4H2qFKkO5IHY+0SotLycB4NSG8fZZvPjrQ7nbLxTXOvH1fx6xxFxeV6 -PLSYn8VrxDaDYR0bVTrbbGko2y0/d6ORYgYwcVJpHUQFkzgzlYYq8VS7cHXq0+LL2IEyZWDBErNs -XK56wCtV4dB1YiTKVWILxS3Ml7keND4ap/1cTds665+OTsu5TEeiK2ReX6j35UMrxsjQnADKgbcI -w5YDLinRqnJbqSYwh3Va9RwQVUZ89mFvlSKociTcLBSNhBzbR4PDYQMjENq2ZwC51YPySF01P/ag -9w+nbUq4APUm2BY3Vn1NHHKwARXK1XBXKVNWKwjmkqWU/5HW5d4OGrDBMAwapW9mA9YB75liMT85 -rebK3DXFuDA/q5xDV4I/xKqKCmWuqGVBeNyImvohZTQgeA2zH0BXGHKmgeAeTEzAWDs/g2Omcona -dRAlSqvLZ/Mpn3M6HqL//B2XCwTGxDejM/qHczHwtit3Gujk0CqjgtrU049V1EEuPEZn5PMnaLQ5 -9hQdjPyj/5vK/wf/xfrZD2h3+ztTYM6x4AO1XXic27uR8d1axs1hjL1MjNWTBVnEGRUmNzKrbW5h -EWJlSSxKL968mFPOcPMJqzzxzbZBDWwAjhUP8f+uA8HgI7RaFfL45S9jgZYnK9wLkKkAeJyVWX1s -HMUV124I0MNJjOMPnMTnORPZt8rlkhhKw12McUwoJCgf2JAmIaLr27ncxnu7x+6eHRebAyqlSdyW -kok6NEhI7X+tKgQcktWKQimqWrVSBaWqikpbaKlQKSHOP0Bp1fbNzH6d7y6Gv3LeefNm5r3f+73f -TL55quXRF1ue+euqSmzLFrTRtUYN1XGQbjquahgOGrNyk9gdcNBt5ZKBT6CSbbmWO1PCSHWRXTZd -vYhTaLqg5wrILWCUs2CmXc65lj3gMJfjYDuWs/WSK5yaOYz4fM3CDjIt8ILzBs5V3HQsXzZzrm6Z -SHf2WhoWayenVKOMM6hsTprWtKlkEP8ANmgjs0oLM/RgDIErt2ybvoG3nJX3TpGNzcViuuliO6/C -Lvaqrj6Fx+8aG7dV07mmZNnuuDWJTfQgXfOJtD6WBYflUgnbd5CX7+1cWzY1nNdNrLHvhjUtvq8j -p7a3VNgnk7vLoAnLMrBqhp/uxqq2CyZrDcbGCmVXg1ONWkUIr7vEJmdYDt5V1N2GA/6cDCLfUNZJ -c9W3V51fT1rPtJO3B9amak/HDnc0g+o/8hMTKd5enVHyW1aOFiDMRDrUUf3vl1ZeEefZRAXVERNF -GO/SHReb2HbITw530X2z8lVk132f39nMqi8VU7Ix4Ul1XTVXqN9FBiXhVOSnhzta4F/X/0xHZuVu -vWTjKd0qOwdt3cVOEIcUWOqm7uqqcZvqqhnE945mUZAoZuGy8zU9OGwNDd3ieyQvHdq4o9kW+4JD -mP7Y/pqN3WaZ5IXD15GX7ltJLh7ePNLcDEdD4ngIqF/RD+/V5J6H1pEf715Hkoe6e5rbg9fnjsau -2iT8TtYboCE0NlOcsIxknzda/SS3b0NGz6Nkc7fJgmpqBhR5DghhQs1NKopXZ9kY/cqb0kDVfPgZ -uTISpg1h27ZshKew6aKiOgOkgXNYg4p0HQS5gWGsoWkWDuALDmIo+jQaw65rYGQximCTkZqHWkX3 -F6B+mMcIQTjcdD82Nd08xgJL/l7sbOHrZhA3JpVHd1zr7xTlVcPBUDnkwEcd9OUjUjv5wLqG7hyU -1pLBB9qq8a+2riD7z3aTnSc75Biiw4tyR9/y8KG3fgKe7JM3X5niltUfnKRSb+rys+iBrNQ14GAj -f6RBjo6ixNCQcIBmZ1F1z6n1Ui+jNoTYlDQLTrIPzt2XQk6ugLWygYk5r6z2VlUUxg9z5Ozpm8mA -3U6/tgBHfOf0xFAKNV1SYcQYhtbzek/pmK0Ca40C15C9Z78QXz4WXQd2j425NlaLHidznmLdRPSG -As5NohIQBaBJ5BartqHDv0vB4KRZdQMuSezMjqu8s9G3LspdmywzujMszpVijcfE/AR+JLIxslho -j2lhQa05NVhZJjumwhsJt0lH+ReKB/oa5uzLC8zbLEZDUWuflLO1TvzPqGsI1TSSIIfJM/Fbw52L -wzcHyZAPEiXYx3A6SW4/c2Hjpzkg3fYxAHfP/KbPhcGZmk/4MP72fNsVFejdd2NXhdwJSiyyaobG -CTUscicITuSY9QgobWYHoWLJ5p0TCe5IB0G7/NYglMGZKw0OjUQhRFLN/xZNmq+UqWV/v1E3HvM7 -NieH6CfWsStey64bbNCyIza1LXvpQNiya7YyxzOuYVBO1szBAmYIJ/8+09pWD+vqa499LI9FgglR -aQoTH0fccDgd+uIkE/kTmIbsORUnNz3eSlaf6aS/npdayMWz0wIEx6CV2yo3hEACpTrlIuRdNeHn -Zsz0FAK6dwu2NZ31T4GKZdbvDSADbQZBuGAcFFuIB85m94u/4QziR1g1IqeVBsP2jAcD2Js4cxSg -EHALmRhrDkfh7jG2NgYtClvUj+mmakT6FNucaFbpJcASPDtJ0uduzACIsLuM1Mjy+SzWUelKPqCd -XSJXbCl1wsB3YfOYW4ATEePJ7g1imphYa6EgsvfJOJl+cuO9bNCz88LmxRgqbXa2ZmT5jhKYQ74T -qNatnw1mL37Sx2+U1tLYG3KnBtEeQRPlPHRvrInI1SBAIKNkMGXNIu/5AmA8UMagxlWQ+gWf6dPe -wiI2JdHG0RD5I+1t92MicOAJ7Ue+E6ctb0tXV5rJs0ClRKd5nzz/qWgOg3bpgckD1D7TmPFRu1l3 -nDKcFTDEN+2gslMRh7MMDTHVwfIlzpdGe/E0gh1BEHKWDfATmMcRyIe59nYUXbwGfXy9ZB/0eCGl -QKMKy66oFz6m8NzRSzdIXZ4vDJxDrUtyfMNlJGiSLn5PaqeJQ5Df7/9J7iSPXbqS5MlGcorsIa+R -AfIhGVA8RIdRU4Soc45sPVrzmbz6wk7y1DlEXylKXeTFc13k8Sc6V0Cp0ocPgu/nn1i7ClgO5Vn9 -QYAfpKuflzfAjeWf516Re7xtl0VX9+6ZPlLJi7Rnq2fR7Ibh5V4JJwGOVvKf5Lvn76yOPjEqdzS+ -wbxKnep759H23jpBiZNCV4gg00uT0lD15dc3HaUD26Tr20LwuobD9SbdfrfUK6NhenqblFiNMlFu -oE9vk6A5v742XreIxrEoFsnSd7dKO+hvfiZtWVAHpXevXPjFzdLWQTpoSAfJzte7epbfYjzgoYQv -11F/f7jJxCZpbKFYlErxtvoaoqu+LnXRqV9Kaxben5eevSNZ07WZzgEKb0QxC+d/J1VjK8Bq4c6/ -SH1SINgkVe6kj7wlDXrKYuG5t6RrZXr9G1I/fScpt1aSSohtr1c1WaNG82BosFz97R3nE6C0nV0n -crjEqkcRDDKXjcSC2QauRkxtt6WbMPMWNtUsG0aNA2/3KbiJ8EWAJEq2lcOOkzbxCXdcz00m+dDC -b/8mfdi2ha+TcITk9TAYKWZs5uyZkhuwNX3vQ6lHiIKmiBbOfEQzPK+AHwv9H0m/v6nCqRhYKWxk -jIn9xss4h/GQt5+8bRXZU4gO9y9BK0oa7QNugstYjHNeAJQJnLdsuHoxPmd87As86GfgDbkg1pnw -GebL5djTigFe+H0tVHgar18OzwAxXmlrRxkWE/TZeWldt69NIvYKN6cJditrLbXQ/2yWj3TU2TCw -kC8f39IdXOqCBuqEHtZLcwvjaXnNytZEdEew/kLuBvmhH1VC9eBffdHETEl12H2FhZB3EBZln+cz -cFDgLnaHFRQPCd2173bW+Ng7ly/DNaTZTDQzzaAyxtMdJomFHBZa2S2o7ijCJ0BLR3LIGuhxgCVf -gRtG7rsNAUz2nV1H7ZLcS29dlNvTy99Xo4qFmHpv5fKXjERYcEuu0V6u/dN5gRyKBX17OO2Bp78/ -/Jhe8h6GKg1G6+S170LsM4RSQAdRXevZJhM1ggbkba3c9KZWfJ3p9Y9gdjhvyYwmE5buo26lGkXC -/PIp22vmhKqOVUkzlwpblTz9Qg89/gdpDUXT0NrC54FpD6y3+7jzdpiI0FvwzY+JeF0JPtNX+6T4 -PTVGUFqYoY7RITBDiAA38ra0BA3D9dnJ0P9dkHsqYirH+lDtU2/gjh0SJes8+lGJ3sszyEsX5332 -4gzVi08AlTIOsyYcbE8xfcouBrxIK5hpOVVswMYg3xzmZwKEnxk8SIhKNTxCTgvPI3CzmOZ8lxzg -BiCRQNMCsVplUIRFEIy8uIFvN0PHOAZhc1ivchyWQI/wjldgXV/5sQ+1p1Rqu2GDJwSGqaCMlYav -DEN+6/JaIdeEfrJk6PT7++X18lyM/vBNqeeAwJsf+hCHl9tknXnSa7tcff7qTSl+7Vz4IM9CDTLo -z+/L8aXPbNs+G22BNc1ekLvlVIyOX5C/WNmpA29yZuZPTOwdt1xCE+AgVxjwL5wp1r+AskF/wvVR -5Dby/w/8lUN3wybmRY/Dc1S49HQXP+Mwe3+8s1jEmr5ahdvMBOwhyWUEfWpR7qY/vyiv9x+aFD4j -E86onRBKGf8hq16IKGG9sUDyt6jGikZ44GeO48tqGnrgA/kfvLkmhE/FH0nSby3K19FNi7LyqZ4y -U5+hgWTpwUVZZRDgLWsFZJOMnOxMfLqX1q2fsV1l6b8W5bgvPTsvyR+3/R9M5mAD/w9QojQp8fJF -L34cPW/vvKr3CQNQN3icu5+wOWZDENNkVmZPFj0uff3JWcxmwgoZicUKOfmJKakpCmmZRcUlelyT -G3hUJzewsE42YNGEsqU2z2E5xQ7khACx9mRGXtHNErxZTJu38ocxbq4UZGHc3CjUzDj5oaDwZmmR -UqHJS9WM+fLyU1JDMnMz89KtFKq5JusqS05mVZeYLK8uPjlJQ0StLDGnNNVKAaFKh0tBoRZElGTm -phZlplVi0yYG1QZTA9U0+Ye63GRDZVFkpZMrNOTZgHK1mtabF2vsYQcAf+lN2vYEMQtzrJ/QH7L2 -1nn48JItaZWBWYF4nLv7iGXBI5YNWyS401NLgiuLS1JznR0ni4k7TeeWZpRsXiOxfY0E4xLG6R8l -GUX4FGpqbBXg6qbfk2ZU3+4CVCYGAKsVGFf4HOqd92yvoe8LiIuzUqV7r9DseudieJyFkE9Lw0AQ -xW89ePPg2UdU2KBJ8GrJQYr/DhZBEFHBLttJspLsLrubNqDSg19I6Afwq7kNiH8oeBqYeb/3Zuat -/ejebwd3jvyY5iOtPHXenfMZnY2QY1eFpjGnrRJeasWisZ7SzWUqjIkOED25r8n1Gj4oDuPh8mqw -ub3YALIMJ50g4+Er6aAVHWEya1Lbqgv1DbOoFFE8gZVl5cELTxbSIxCVnoPDWF1a3qAk71AKFmMu -faXboIXQTcPVNKmlIhQ1L9OQW2iLBRNaOd/3oIu+utSSqbmg47pm0ePqniSKU2dq6Vn24PazOMZz -MABkAdajeZ4HVUKd0Y6S1aJY9znmbUvxsGepdoT7vw5K/zDBywt+D/8NKHiw7RNel5O9na1PmaOV -4vIJWqxohjMSH4zpKyL5Mwwuvk9X2gJ4nPu7n3nvAeYNymyTr7TJTuZjZ1dIzs8rLlGoVsgsDg3y -0VEoyQ9ILMnwTHPLzEkFCijUTp7IJKpSWpSjpGnNpQAEmWkKGmC1GmlAJXmJuamamgrVQKnJdmyO -k2vZ3DQVFIpSS0qL8tDNQmiAmFS7WYD97Q0ADnkv+PEJB465qjhGfi3i/T1tQf8ZQO6wU6V4nPu8 -nP3gSvYNEUviEkoL0osSU1JdSgtyUitC8kN8ghOsFEoyUhVKihLzigvyi0oUMhKLFRLyUkv0gvOT -s1NLEhRyMtNSkyuTc1IVilNzE/NKMpOL9RS09LkUgCCz2C8/JRWi0n56wUxG8c0xS9xj2FLj00rz -kic3vNSbeoGRnQvCLcnMz9vazZhxGQD65zds8wNwQ5qNY78ilJNRjz1B4tKGL4HJZXicATMAzP/J -AckBkGkUUaM0k8Zgd9gA1gpyb4cuyCTHR0ORfTgUwIYHs6cjRk/oxSS631fWSo+2sMxAphfg+wX7 -UdWXk+7a2S9C2u8nMA6UjsrHDXicO10yp3SDjahGZpqChmJRamFpZlGqhlJmXklqUV5ijn5pUY6S -pl5mcWiQjwaQrak52VpUU1FBAchWsFXISy1XAMmApBQSi0FsTb2MotS0zbGi71QAntUeZPcTig4g -ga7sCWCvZ1ouRiKFdrF56oR4nDu0nn3JRvYNllfr9fUVHBWSEotSFRKKU0tCMnNT80tLEhQyUoEi -mcUKJRmpCnmJJZllqQpppXnJJZn5eToK5RmZyRkKaYnZqQolQA1FxQop+XnqJQpFqQU5icmpegoh -GamVQDGgQCJQIdiMglyFgsTk7MT0VPViqC49LgWF6cVpjCL8RQq2Cuk5+UmJOSEZmcV6mwOvWspw -IwlMLviuunn9x4OsyIKbC77XsKCp0tws+uckM4qqe/9r2JEFtkexM57zRBHRCGRkdUYR0Z3CeJsR -RYRjGuMuRwBTWXQJ/hIJ4ZhwtQzG6+RTJ28Ga9c0TdoIP3icO8B2gE3N0MDAzMREwTmxKD1fryQ/ -N4fBTonh0cQMfzV59WfBFhm9D957TNLfqJbGWJ8rGHF6B6/6f57W5mI/2eyTUfflI0wMgEAhJ788 -tYjh9FuNCxeabu6XunVV6GINz2ELKSsTqPEFekXFDLv8eYsDqxUCKz8v/HjCcm+gwPfKaIj+gsSi -4lSGMzMfHrx2YiOzzTmNtLcntq2y5T4wGaYfqMAntQhkitcbse+r0liM/0870qtUqHqg0s5GCaqq -KDUxuSQ+OT+3IDMntSg+I7+4BKTDKXr92cQTIV4yh2871JqW8RWmX9s9OZzJUkQlPuDCXuNtTtMM -9KbcZJ+cZXSm6OvkJUwdIvtuNnpXS4SmF0Ufut5asIH1vnqLHgCxHXnf9gGeyuvcNdZOdJbuXeOn -oKnqyTtccnica+1nmt7PtOE2M3txfHFJUWbB5gvMW5sBaPUJlv4BiqfO2N8q9igUrDOXBHnH5r5+ -r9J4nHvM+JhxQqWIkCh/VgxXzmq2Uv9ddheS/39JvdQ0sTcMALJvDRj7U3r51Iwr2tyQ6z2xRfOW -5WF7rovMeJyVVM9LFFEcZ3Zn1t+KrKsuEj1B1KUcOxWtW7GFl4gilQ4dGt/OvM3B2Zlp3ltbNVAw -kDpEuNC3kEL2YNIpLNhj+QcU2tVLS5eiDnXoEmi9mdWVxV2hB8Mw7/v9fN7n+3nf+T790rX+q+t1 -qjNoY4eYbIJQfYZoCsPObQIbOTEcKg/QdDKpZ5Ss8LbjTapzubUqLrsTaTgCuxMpdJxBfNnpBGJU -oczR7Si6ZjPdMmMXrUxMdTAj0WgpFh0hquVoxDm/sB1f3I4L/PHlt+P++HiX7RBKnCmilB+oYsOA -43ViSBzO2A5cH/V3P1kQ61o1y2RKIm1qBlHYXV0l2QvfQ70VKmGKYakyuWP0E04g84+Im3qiYl37 -qZQYSdkgGeIB4PM76RigZ2It9OT8Z+Fh2N+InL1SIugc6k2lGfIw+6WiWShMSW1Lq0GQd4UasG+K -9bC+KXbC5rRQmx1/KQaKBCA8l4LZ+VWxXS5XlNBN7OgECq987XB111cXcjemZUwVmzn9ERlrGn/B -xgchCCvDQtvc4CAaSZtMTxFkWFijXCLDuok4JXJtJASVjiCUb2NPNFEZujx6qY96Sci2qO5eoFyP -9pZXWDVnefV7vsbUoaMgBw5zSLm//ZGhxbGcPz+WE79pDZZNTCXhYHXS68Ig/P0kdcPmjK8RTv0R -e+D9gFCb12ukoQfQvOwLnDysKVpVMmytcUIXNnBYV0VYMZxfeixFauaOMIGa2KYTFqtq1H+YU5mK -pkVPyhpIua9z+2RFE5lrl8KsSWJSzmDZjMpJglma/1SlnlRSlkYOZOjJSuDZUtxdvKWuuDnRqG7q -DGHDIVibRlQ9jU2TaF5rJXWHMuTB5TJwkV3FtiujyA/dy1JHfnQ+sNXUszcuuIzqcmErJbTBz3uC -5OfzBAq//WGI/RDD0HIjgPLdjwKq5N1m06HhFYSWF2LICzaXuwwrH4W+/P1soO3WP3kd69v4A/sw -BzbCsNFuY1gb/dSkT4jhRD8+eJwBOADH/9wD3AOQOBRNQFIIZ/hqmS4dqd9uIgpVB3EsoLFMTQEU -bbYaUoQFznWhjOwSIxxCiJS/WxCTrQEvVJsVBvsZAmv8i6Fop8g7d5agzxW8k1QAi2Z4nFWPvUoD -QRSFiSIBA2LARpDk2mgiuqRSWX9S+AAJSUSslok7mwxuZoaZO0q0sLBXwjyATcBOhRDs0lsK1nbW -PoLubojEU57L/c45w1H66S39Ui6taE+jYtLrCJ+6EDg4Zdje5tKgXDL5m3psAXYl1XDJsC0MgjKc -M94CbFNARbgOhOoQZIKDUNBk3I+vkmhNtTMPkaRpQsBhzE9ghU4E0jQMirB1CDWqTYj7Z4ogdd1J -E9etzBmUBu1zdd2uzS4MvqqLqZmOsfmLXfuRzW5Md6ZwELUxdC9JjBVShCQmFGi3a+qEcYaeXAVF -0SiuQfCwCyRAqiA+MRKyq8mwliHKp37y7PxDyijIcE0CCtdj9k8tZ0/rD/b9MW9zjTv7SXfsdyNj -h/WjxBsdZ5alg+Scen+NRbKsUCze9iuv/Uqqd/8LvK2YgPQHSwrpSMsJZ8HwBXovyrCgMGir8YB4 -nJu7mHnNEuYNTvyTJ3DzTF7HxaNWkliUnlqil5JYkqij4FpRUOQCZFlZuXrmFuQXlfimliRqxGtq -Tk4UFtYr0EvJTIkvSCwqTo3PBEvH5wLl4wuK8gtSi0oqNfISc1P1inMyk1M1gFoU+GQ3+/P7HQIA -gTIpjPUtWDVX5yXfjM7JiPmG3fPGTTiqe6Z4nH2Sv2sUQRTHEQ6UE0yUiIVInkUwgUsODAieIogQ -7BRivzs7+zY33uy8YWaWy9pc4V8g8yfYCZLIlmJjpSLYWFlb2PkXCM7s5seK4lbDmzef7/f73n59 -P3j3YXB4sLYYj8eQlpRXEresM0I/qTXu8nBw8WRTaKsQWnACnGlXGQRHM1QWhAI3xSEcfZElcR8N -MJWDQU4mBxcom6RkDZxUYFXcgdUsvCYF6eLxZOJs0moEKfqDFdhBUcoA5ExBJpmaxWIZhbVkHGHd -IkLKDXPYA21snXB0lcFxPelCZERyNOw6/K/rZ5tm7fXy+V6Pf7F9tUlvffGL4bGVHWGs62IDFcCA -S2YtlFhmaEbBD5dVLtQe5DE1c2QsoGEWc5gLN22jdM2dtWBrvXW90XPX3ieSJvBIO0Hq7qLavnlv -dGJit7cJTVbEnugmwovWYDuioMk4R2tFJqRwdXwhChGmSMXwdLbi1H5BBuyc37BhR6WuHOabM6zH -ew9RYRsG0jspTNkzFhZaiP3/ZDiS6qcIIXzy/Erz4NOPM3757eDS34n9xdsrl/8J8T/tNb/6/Vxz -//PTC/7Vx6UVYZPwJzlDMikkzZOM8rp5+e3Nzm9HIQDJrwl4nDM0MDAzMVHIzU/RKypmOLpfYl7k -9jvZfZMu/4yqkVp0+thuXkOIirLM4syS+KTMvMSiSpBSoU4b1c9dKidYraWWbd/V1167cPo1FKWp -FQVFIIU3GOtWxX83t26UlLJ2ux12VbFw5nkUhcUluSUgheKM/8KV0wvnn+tofvX3U+rp1LyQZQC2 -c0ER+g8Kj1LGDZIiHXFIupvIW0mvJLZz9HicFc4xSgNBFMZxBiWxEBtxBUnxBAttdgux0UIkR8gB -1snkTRx2d2aYeaPmDhbiCNuuNxCEaGPhDdILQmoLsQnYuQsf/Lsf38977+2j9zxabRqLOh87Lgqk -ethn57E5Xo/T75O2Gy/3q8/bIx+sLRV6oCsEpSU6hxPQvEIwErhuZ/SsMiEuv5LTLAMZtCBlNBgH -ouTen4EPY0+KAik9BUVwY0I5AXTcY8ty6rj6gtjulpLg0JZcYIWa4u/jTj18YIO1w30bl6PtA5sa -2+E+lcgpOPRppbSSs7xAtHl3y8enyyQ213v1omCD2PwlcTHvvwrD7rJ/BCFjKvgJQ5DWXQ7tbRfV -KSvDAXkFZlpppx14nLv1jn32B/YNLMucg0rzSjJzUxWKSxKTsxUK8oszSzLz84oVUjKLSzLz0ksz -izMUkvNzC0pLUlMUEpOTU4uLFdKK8nMVUvJLoPzpHx8w2k7m3yMilJKfVxKfVJqXkpMaX1KemZzK -NWmP2eSdtXzTz+1j5N1cv2yJqAC6mskXW+SaefZs59nD6GcNAKTyPjTwBQI8ZiGuQl+adG4NIOo3 -O+gWTPw3eJx7eIXt+VW2hi2MOtME8wtS8+KTihKTs1NL4nPyk60mMxqKTJ6QLbddZxojNzNu+elA -+fDtfTMZLwsAAPW8HiT7Aa//FwynRWXlZabh3xXKFlj2bIOXeJybxDiJcUKdyNdQ4az++ufNa3jj -VKatzfdU0K25BQCatAth/Smyik+bVk6tvSnU8BBCJVxbfuI5WnicAZ0CYv2nK6crkBYUtixgqxlT -HO9t12S0ZSO9bX+u2MaRKj8UN/5Y2VDASAz1BVZTNd+31UfsfoKxfRACFCaYaGa1BnRMADvtlEnN -z1Aobb62s6ECuwEUkDA19PkwbInF5YQjITi1YYb/S5izcAS9AhTo1evnq5MbEHeeD4FkD1lw8YZ7 -x7NBB9IBFNabJ0Z+CO56lNScazOJNuRT14nKkycJShROn+MgiKWJlwEkVs0tK7363PJTfrOFCWMB -FE9KQWJ42S7b15Eqgo7qKFgJSFpUk/wKGRSZEQ7rTSbQxGnFpJylteYJTuImlZNeCxgdQ2FjaGUu -cnMAVv/l49xt651jGFYNGeYHIX6GAm+TXgshFBZXlArjamPKPjJr1CQsoZ4KtcTvk5MLdBQSJWSv -lNR6+6McFDVUzDb/0BCKrrMbDLkBOzErkFMrlalsGMXhQSvmB5UmjqExMTAwNjQ0IFZtSGFuZGxl -LnJzALBtxKdIUB4Zy0/ZYkSeir/gqBLysw8OuwETgRg00PfwgF+xThC1KP2Lf5J2kpPdDxg3reMS -coijMTfCyzRE983fquXJ9+Q0MDAwMCBiaW5kaW5ncwAKdXO86M3Lrt9Ypvzgb3HCTGJ6m5MsEMEU -soY17+kL3YkD5gvsvsrXV8bAvyyTARG/FPONKql3bQqXL5jMUPStZ6P6cH6Ps9QRKAE2H/tMq5CS -DcWJ0LEtusrKIdC1ZHY0MDAwMCBtb2R1bGVzALfPGrKDGF9bkYtV7GC2GcOIUTtCkzITaRTjJ/Nn -4Q5jTvBQCKKesmoem2SDJLOvE7gBQPES8HyurCyqvC9u68ASu9IH471HMTAwNjQ0IHdlYmNvcmVf -dHlwZXMucnMA8zqa1W351Dlfl6af4D2dxQdLqyFghC/x8CVIdUDAoTSJJrEgEaU7xHHHPhNEuXic -e3+CecUp5g3qUfXBJUWZeelhmanlNurxdjpcClBQkFiSYaWghku6OL+0KDkVj4LszLwUK4Wk0rz4 -xOISKyvP3IL8ohJvoCBEiaaCrp2CV3HQZPs8tslVUQ1sIPUKtpMDtUSUQUy9nMSk1BwNTU1ruIk5 -qSUKRanFpTklQHV80cqTMyv4JhtG6wvpKKiBtGjCVdZuTowWSHEHu7MgJ7MkvrA0tagS6Jr8/ByI -9SmVeYm5mcnxmWBnIcsAbcjPKUtNic9OheqYnL9/u0RmGpoehWqw8slyB3SNXSAyED8iXKGQmlOc -qgDUiWwmkj7uIKi4a3Hu5G+2cpPVDmjII7QjBTbCE5v9DvQwiegolBSVpuoopCUCbYBSm28damCa -PGW/3OTyY1aTv++PndwsK7Q59Ph17ljUOKJyJG9OuMwvCACVRbtJ+xJxl6/aDRihaE+PopQPJBdY -aJF75Hic+7yQfeES9g0dEZPPJ7JaFyWWpFpZJRYVJVbGJ5WmpaUWWVk5gnhOYI5jTk5+cmJJZn6e -b34KUGFQaV5JZm6qf3leasrkCbGamxdH/Gah1KDNE2ILWKY/yGRksUmmzD2qm8WTas7YKgBBIlyl -lQJJpk430GVU3r5ej9FlEQB2f3QS+54BEZ5SJCYfml6IJrCwkfWsMnylYzF4nIVVW28bRRRWWm6y -KgTqJSqt4DRF6W5Z201oi7tJnKShN9QG1DSqRKl2x+uxPe16xuzMJkSkWIVHXpAGIXiCP0DVKs8V -AokfwHNp4ZV/wZm9eO2khJVsr+dc55zvfOf+t2NPvx97eH+6v8qbNAK/EXNQVCrfgYk1Zt4mgPAm -TCzcwfdqOxQNEsoJiKgU4RoFJaARs1AxDl3RjEMqK6XjtxgPGae3S724AS0OJGREekGrbdlQrqMB -9zJ7LzOWl1x3qdWGz0uAz/MUhuXmieh6hPl5Ji2vJSLP5Cpd/WTs8CEmz8f8Bv4faJtHP3nJKTnJ -0b3SvZL+Z/oT/d3MUYuTLnWSmEQq171BojbFX3ThDGdub3115tjeRrVaHarSCQlSYX3KmCFgFtAj -wV3SphKsvHzO9trhAdq7RljNdGxoCn5CQSBirvQvs+P6oXtc/1l7fMSSKoJjc9DYYVPST08eLS2a -BF23Q6R+NFPdZw9uvLmpH5wZ3/rj3O9j+odzB/TfMz/11zsUmwG9MG5jvyKq4gjTDgRXlCsJ60x1 -RKxAcKxHKxJdUB0KrNsTkcKL+mqjR30gSkWsESsKIiqZatBQ0kSzxUIK9DN0JpngFbieBfA9ji59 -WDQFIrmf9Y5Au1AQg7uIkqZMnPSI6kCEX3iqOoQnh3mKWJpYL4y/UDUuvEEmLnzYUxhydtJ0MRAR -dd0VlPF23SkZyGk295a+OTe+L+nw1STmjCZzZV2tV/qDmnWJCjow6ruC3fUwB25tDs42IXXhuqZK -nkxCWZOFjRJerFo1BI09BFnzrIgutUZOoI+f3N9FLOGo1LRyIL5JZHcX8TLpsV3E54mkZ0/vUOgX -Gu8TReIo3M1HzGVnF/nKpyHC838VLnQbtNmkTaNY/g/Ny6obOiOebJir69fnD9YTQDk7C5uiyahl -wBrVWUYr4+K+tX9f2ut0JrVfPvSygc5a19JeebykIsJlD3sRJSKRoEuad63rl/SPFw7pb6xX3hnu -2vYamRzygw+kg7YHX83AnmWnjzkH9M92Sf9lvagf2KX+TJJsmlimWoDH0A7CCjuMoyPisAlmuIAp -YBxJ2L8jBfcrA/UitOCBiYiGOfJd1ygHRW3SYG8UZaukkSw7o0t9u3b4un8FGZko2ryWEP0SCTrU -EOBdupFSX0IrZRn3eiGjzYJXzP7ACWJR7h2W6Rpe7hSO88k+Ulfno8R0KTOwcksXhgb6Ag8EImYl -ZAHSU+rJhbiWrJT47OmsViFVQI0qjiTMgYWSdEwHXitMelNnG0zheMJsfxambGze8/WyKZ4ZrKX1 -DZNvQrgdzxCmJyltWkNhcgzOzsK0cZwn4wwKUmls4OKS5iKWPW50pnAfmWVpBch81DY7U/82b71m -Td6Ka7cdSH6QSvT5hff0FwtfHt6pL7iXgOrX+QN7sSP62bxdxyS9AR97uCPNqpO4oqiFKnYlpbVN -GBx7huwMAxu5vlU7shpS3kZCFi3w8ci02xfcwMgvrMA6lQDANwvAtx1cDFCeAtYCLgr1KM5WJDMb -7uTl9Hw5d3I1CWTijnQ9pfGkx+zd6azH6YgM3bg/iXZDrDs6Nym6inwRkRGFxZWlK1cckCLZMKs3 -LpZrYBoD2ZUZqoWZND/iaRWKMUtYx+Jv564d8DC6uXl+YlBEZMCYpcem91/DS7iuija8BCuFFkbA -vCsxX49ID1tllaeKXX5v8OaZGS1PZWO5Nbb48Z43R3Gwvef660XYerb0eM+/GlAtFv1JpH2i+pk7 -/IFS2Q2m5mI0MTlc+SF4nI1UTWsTQRimqBiCoCBICgXfUAi7uNkcvNgt7UFTQaVRGtDjZrJ5Jxm7 -u5POztoWG4MHb3qaiz9D8OJ/8OSfEW86s9Nk80HBuczOvF/P+7zP7I/PG5++bnz706StVgvejIgE -ApSwGAcgMONxLhlPgVPoZWOMGGUoekAFT6AnkKIQ5ixHgp9mfhX0Gud9oClEAonEMOGDPMYw5TKk -PE8H6q33QFVutdTJZkP99GAq8UzCHnQxpkFAE+kUSWZrXtNbup5VXr6NhK4YBE/MdiAEF0FwWJTv -cPnUFF92Z8mYi4oMj5mxqI87d/0YJSTZUOPp52lIMqkz6OP7pbgEJRkQSQJVv7OlPlyrqd8Pb6ve -1nVvjjYo4x+T/nlXCpYOg0Bss9RpmI49UPXtrWkBYYYAVpbucCHPfzQ0cZfPBcgygyDpEENz6XR4 -ih70pzPTkTEFQedl58ADg28lk++3kZI81q4D++G4c4fJ7vzTTtGO3hnGvE9iDxqaUW8+Mhs3qZpN -fWlUvv9t7tTUq/bmTaeYn6tY+/49m2K5Waeqxl59ukByw/QWcaGhW4ot6lmpKx1YpsUoQoEnOdM2 -6HMee1UXmvvwvPuaxDlejtzoYWFGWhfJlMhotJJhQSBS6OC9fXhWRL3QQZpd61VSSkmcrXm1z1OS -sMh6XXJq6jvlGzCdEcuihlIafMnDXNJHjlvyXN65NteRec3v8BCzjJhhX/FANcu/3FrJsp/FLEJn -QRDzCmuWNTnbYft5eirIONSEoW7cuUCj5QuwAvElOcYQzyIcm1+NUxhvuG51Uv0HRl9w9PM+yvtP -AoG/es0E2lukCWMPFk3XpHV4nKVSTWsUQRAlQRE3J79iPIhlwLgxuxMI5DLiYRNnQ8zGhN2sipeh -d7pmtslsz9AfuwlBchS8ROhT0EMungwoLN79BfoXxJv/wpoYIwGRgHXrqupX772qV99HP/0Y/Xh3 -Ynd2dhaeoNIikzA/50MTDRMS4kxtgs6sihDyTAtDdV0BIWNUCjlI1kN6KyuN6FFLahP6pVBnqS16 -gUkOuRJ9ZhCY1iKRPZQG0myASsjEK0UEaMBVJ26MzA2XJqJHSyKG2yj7YZ8p34+RGaswjFOW+P5C -+3FYD2ob7WYQ1hu1pfDhcqu20AjC1lq7uRiEq7X1lu8naMrTJfdc33RfDq4HpGwt5aigwKgSJyKg -BGqwmhSYLgLHmNnUwCZue6Q8QYmqIEw1oaDHcu252sqMu9W+4J51rro398bc/sYll/Ox4YvoWqVN -IxYzGVnyhMTFIkWIFDH/7QClC6OAxBqkt5BacITaer1VAewjdUUq0xq4UBiZrKDnuQ+Dal0bQong -aXN5Iwgba4srPnSsDE2X4DkZ6Pur1uAWPPhr2vclDsrT9wuoSooGwoESBsPEMsXpzx9YL82izV95 -6i+5kZdXhm/33l2kw4AVxPyUT12mu0DMOqRTZ4BbQhsaenwoVTKsSoKpyk+81lb1RR+9EhwHbfks -S97995Y9KweK5WGmyjFLNU7DzsmEIo6RdVhQRuXZnNNiy53Js1zSZGHE6O74MNj/fDlYJVWxQjyR -xBTSYq0+siGT6TYMurTJ4lyArpsat/JURMJQhYujNu7mD+80TzEsYmrqPy/eNfTM+SNY9/Vg3L1u -n3Pf3k8O9w53zv0EjVBVO/8zYzci0EEhffhb38Zj6bzjwUD2gbt4nHVSTWsTQRimtlBMBUMaoY1U -XtKKCcSUIhSybSy1eKkWtamgIGwmm9lkkt2ZZWa2abVQT/4A37NFvAhFsLLisUWRnrzozYOCh/4C -/4Cz6VegOIdl391nn/f52J97/Qd7/TuV5CaYMzkJ81CtE02sKjxcvgtMARcaCLjMoxAQ3SwA4XVg -GhzCoUbBE7xBJeimGUkXAbXQdaksJmJG5oIKqMNcZp4oTaRWdofpZq6W7a7J5uFZF4gfL45GleTf -q6O+qIcetfV6QC1Y6g4r5r6QwA+f0tHy9I8+BHtgsyVqIDpcmdVG5S2xBsTzhEM0ExxCrpkHVUkV -1bYrpB0I4VVnupuOjDKt4H5XrpBSdGIeCrV1TRXEAkWowQ+1oeON+JVfPPnYoxrEhQ6ndVvTNQ1l -wLnSRN8MDpUy48ZwHEKRKTs2aIfSyx17PDq4u5/Bg+3kiDjhKMBhHgadzSdwZ3cM9/YzQ6eAPD74 -lUZeevJopRkX4bRJg4ImDVDUo47xsrBYAcY1lSKYMQCpYuGhoofG4v6uqTgwMHH4REPTgHs94Ws3 -jd8+j00ZUgsMwmke77FbSvCiT4LcRtBubIC5FHtawqmp9EhF+DR32pZlLbRUHso38frW+OCC8H3B -W/jn6/BZ4G3lHwHzeG42NWGbAZapEt4qrVdEKB26YiRZi2SVKEeyQBcSLzOX8cWXVNIIPdUB5TIm -t67g498p3LDOI2lfiu7NVvpx6fsgZt+mMDk7EL2Ze5/IBmEt50iiaR7+87dFdxbL0/ju1dCwqddE -7PYajp4+vzEWbW9Nzv8DDJMh4//DB42yP4rHvBzQu2FEdgm2Nrc92PM/eJyVewt4HNWV5lddt/Ro -yZZkvWXJLstY6g5yyzaER9uScWzjwPiFbV42nupSd7VUqLuqXVUtIbDTZr9dWDbDgNPEBzaPjZN8 -wwIhkM8LPYFg7MCwZJeHMwP5YJgQD0lIMkMAz7czSSA2c8691S9ZJjv6PlvdVfeee8655/Gfc6/+ -7v6uNx7rfvzlDTfErte9+IThRKPjhqdN6O5EKBxT7aTqTRhqxjFStp5Q3bhjZjw1nnUcw/JSMyo9 -Na3xSFDFn0x2rDiSE4iq2YtWHX1uw4UN+ae/GcxF1ekJ3VNNV3WyloWz6KOueobrqbaDnyZse5JW -vM6kZ4NuRN2FDBlDqm6phuPgGI8I6Gos49hxw3Vjasp0PcMy8I0+abhIkDMyPDysWrbHWae1DGfQ -HboeySRU3XH0GZdWSZjJpEFiqCnDGvcmkBfHUC1jCqkZ+7J6qiyU6Wo+y9oU503Dac5MVB2z7dTR -X2z7ZTB/5sa63E7DQxENizgcy1pcslhJPi5d0rRMd8IQouFit3hq2ow7tqe7k2rC0U1LnTa9CeRe -vXqnaltcBNfT45MkiMu/8lm2ZZT5Q2VrGaPJoq3QOH+olczRx3ZP1C8NxR3dM8Ikg2lptqU5hmun -poyout5IpdZwCeYl/kfgM9fTurHly018jTNiQ6pjLNczmZRpJEpa1ZOe4Rx9PnljIFd8VJ4ykrYT -2ZThxqKqnkqhrPhZdSdIrciuOp6yx/SUao/dbMS9Ib4bhh6fUNHecOfwnz1tqbHPZa3IFk5nk6Nn -JmJlKTklVxNkojVc+UP51M97ryzaE6046KrjNDGiXoUk48jIGGqP25xqkj7R6OK25aESy6RpopZP -f9y9bagk6vVka6RvO+uN20Xy6rg5hVIRTRQqbnDGHUNPpblhG57pGImIutMwOCH4jhJYtEn3NPEm -jXYT21tet+pFVN2W8UzbWnOdEV/zOfuWNYkZS73S2oarhMKjo6ND8Nhi+TffUm6evxiVpGm7cKOv -JMbJGg2nQmnQ8qjUnTfteYtdPWmoSUvlE7YLr9HIBAxvnTM+RQMX57dN182mmDL0KWMWRRq4sFXw -u8FwUA+JHSS4e/SV6RN2Xn13wQbXszMu+gApilR33RZ13EZ12VaUnGL23qJXcjPIWgnDKSo+//WP -Ooa55xLxQW4WQ0QTTcWnT5bKTYf7Fm4L6IbU1+Nq/sZqFCc0PlgzdCc1kz/27h0BMwn6C6wd3vsO -652n7rTTRsgfDyuPSj1wVpa64fTRQFt+5udNsK1BUo4++KvDBvzsSVmZj36Le4UGqCV0T4d9P5c6 -oPmlgAJff4LNg/XbcP53pqRG+PJPlPaWJJla1fjTr7EOGNkirYB9W6Rr4IUt0iZo2SqNws6t0iq4 -a6sUhe7vSw1w/E62OP/Iiw3wwBNsfqM6Ith0EuHVhWu2Sc/WdRJpdHZ0t6TtpLWUbWc0Pe6Btlvq -u9Y1UslI9Ts744XCEZziIiENlR3aP7FfnaAnOA33MBQOc80fCPJfSJ+iyb6skTUS2rTtTMKzu1HW -K26QNuzm9MU0jSKWq46qK/i04s/+/aqRioh45IcjGhcKzx61BIfNmEYqIQZAb1Dp+uy5sx0jWZxc -zaCZThsJE4OOC4dulBfBwd3SICOi0LcH96J5D2p0226ptcR9N/zkFbYI1Bultku4HHOpkeuD2OMj -5lBEJ6zeLa2DB3dLw2NV48r8VLPLIyQuhWnF8vx1UrhMTMWFK9JE0cInDSNTSpD5Ezu6oeUhua1/ -DgpawnAzmI00nhpdaPmi1NP7aZLlv/H7jua5hBrM/X+Jca2VMieNuaVBP065NgbWrIXxMGvhvg0m -cKOsBOUA8nHPTBsO+rtrUtRE/57B4GyhR5uYKnh0vnpnRUAWu0wcYixKQvMXpYU55GFLFh1+jMeG -BP5GEUWg4RK5Uf55WketEFbggzK26xHMiGNQSmA0MW4xMfl4lKZFNOE8U3inuXxUpGSsS/fEk+Oh -rGXeEt4bhLO7pDqKInc48tIG1MI0ISacCc3L0DDO/DnaWKSG1TXNZTed57GWirmx+xjLCTWpI1X+ -4hCH6L4EIXBjImkdHdvRjJRrhHbxCZuNpBeNJoyknk2hePv5yP1qiP+OCKKkSC+M/r66RFy8iOhO -2s/x0FGQmpcQi/7ehfwhE3Yq4Yodx73NH/l9ey5SMUyzk0mMugYfca63cwwSjcYzmWiUZxqcusFA -+IXJ8npU0Vbb+zM0fNTlRrKszUhkHdlViGtMZPxZgWqYzOHzvoFxXDiNEJBvIvGgJh07Td9Mh+MK -YQ08C9GChoMmG0u6Eb6HiHTRgFVLz5j+QJE3s1acEnKkMvCUBG6okJg7H7z6pFQzj1sQ33dUWyms -LeGCOLbtFXNUBLlyNUSpEzxKUsIihKcJiB0Kw/yHAx3wQqPUBR/+X6ULPphkDfnMv/bn1bOsjfiJ -6NZMaL9PDVeAr8yTenN/guq5scnKprWMnUohmK50YQwgiJa4JikGo9/aqpsd8xyMJVzJhIDNourR -kwc9NG+vz8PMj4zx9YvgnhySMEAE9PXSohXVigwNkGqGfFPUyM5KZiYAdv70h211KcTWlE7hH/+W -9eRCFTaMQqwjEJrRHQR7RiqmCuWjr1+1fT2CQTubwcWxWOHQnhuygNV2fBKpejbHcHHbdjDl6J7t -lP2fViVeK16Sa15Q6ZvIVHV+pSe0HyNPsl50ErQmTSzl0jgrm0pV+SDyb0TGI6WiJuJ6CYScMUL/ -upoxM0axJBBKJS8mpqcdDHPVrCZMl7sy4gZiAt9dUmYU7SVBBmsVOeScc+TL9z+CciIMM5LIHXz4 -3UBXDpOTZtrR6E4UG723SF3jJlIhAS2dNAmbF3kcUc2LVkWj5IOhuTY2rF5YMWKWhuklrbWAFiuv -QmYC37xB6odX7g7My3EUUzLeCBYRmLlHq/k4x9q3oQUsd4yM7XiYLGLZqaqMLKzYuCWeyiZEJBG8 -D5ILiBK1ZGcDVYbGd2kuQ4JTr0tdK+e2eO1TTb4bvnWDtITLunw2YqOQOsHDrw/GTLtEPFy4ZI90 -6cWjxQpGr6iRJxx7mhhMFyuYYnmdoOKlslqGTw5LHb3nqXvVgQE07xP3SxfA1CuB+dCcleth5D5p -GL7xqFwHJzcrDLbcKQfh1vukz4D2oFQHw28EakH9C6kGDpyV58PPoqwOnr1PuhC2X8AYNHezWvjt -fdIgLPwcq2eEKuEKCfMiEl0Cb35VaoLcJUodNN0hD1KubBILPf41pbeQvkf6xV25pXsSvCIJrbcz -M0Pq+hQWnEPqBpEPMXfz+tFzshi8yglTva1kGOt4tbE8nkJHFbvOmxNkgUO8lVBCCbFd+ng0atK2 -ZV1jUmStHHkrVvXlwo5mir0sV5TrEOkIYIS1vZ/oy+VxMdYOYe1AFsgrTkppRFmE2aJ7cSOvKP/t -BZXJWSxb2NwdeCmY21HVNThPW4LXq+qe2HWm42X11BadYA16fBWOL7YVKutXtI5zB0QR//l1Zwj6 -Ph/ogoOXBxoK3RcEdrKBK1EisQPRqD6Gfqi55rilp7gzYNjT+BbAe4OBxbmyNs87MEqLhNXloyoF -qziPU0TezRjxLfgeq02jvAE7KLMLnIcuLDAfZXv04BhnKhrFPYqtxliDOBeGBwO9PQI2ldcpm09B -DwVOXAK/PxqYd6lvONzhLDW2jhjeyfmN+PxSN00EZ8ueFs0c24J1jwYWrjm/eH9KNPU2+N6r6IYn -/zxwSc/5ydzZpQUKXZrcthjmgVR34Xn8ugq10Q/6OfxlTu6D6w/IXfCDg3IjSA9Li4WH33tAjsKp -/ywPALrgWOEvvyCr2gp0JG5YvNvCQ00GE0yCOi+IKBD4c1jmZrHS4e0hePSncrybJ3eCKTSX96nE -4BEI3SNdAoH7WbiXw8Z123ZpGK1TGMbWo/hXIrENpjsJ+zwsr4+9rNTA+C75Mvhohxxq2Yn4JO6V -80cImt+WezoxdM6xVBjCb8tvDOou7rQPVv0+GSXvrBPHB9sdE7FWYp3rFX73tnxI6t3hj9jpD8iI -ASGkMpS/fWErfO12uSf/1QeCBO2Vwg9PyUMSrHlHHv3UmXDoXbkVat6RlxS++I7M5i/VMbSVekNk -C8RldLNNz0eFccMV7wfUwkMfylc3tPLnEdsJpZxIin8JFz7+WC7Uw02uPL8Bcx2lWyxrwrCiT+op -vK0wrw7eOqA09IiCSiOYWlpwYE/2sr2j8OwKqb07nRVwiHxGS2LaovSlj+sm/PgNpRUsUwkWbpjP -XpP7KigVmxhCjZpna2A/oyyCtafkWhhawNZ0LpmTpgUn7lYQVH8bkXXmJH5ShzFVHFvAlh/+I2sc -jE/oZhhpC2At9KnRQ83iHSBbmDbsC0qtcO/rgUa4vIetEqvONLEu8ezUrWwJfHgywOCmIdbLPx3+ -p4CiqESJGLgYYu1sPXxjWu6ADa04ZM2NmIh4NqLBHedh/dB35L4czytJ0Qvj9YnLQZtHpWexClbF -vGKj3UwTNsHvNJjXr+hFGNgn0YeoYVCsajBn8IVE8ubVbPGVSkqnEA2vf8IWLdRdnMsVJfRfsTOw -8s1AN4t4+uRhGSsMroa3DrL6Gj5nP5yYx7rE5zCsvAY97ORSpUMMK25evcLf861qTesz1M50ZjTi -RSxBioDHCkonL2DgYCt770ufsKYxrOPRtVB5GM5SKVhxo9ImtHpwL6srpNpYTLoxxk8ScAzpkOBZ -fMIQ4ZsgDYVv3jgUYB6jopk0ORqjes9N6dRn53ULLSa2YNKYQZhmw6FDcg8XpHUWI4Sd4UQG30Z6 -WYiG1IH6sMTgeEyphY4ONh/sXnaBnDAdWHcB8y3rk3cV/5M9io7+SjsLMvjpD6Xam8u7q6uiO84/ -W4gyjXjW08dSvL1vYVpKcoBZnGARBJ4sbq84Npnm+y5ao9zeHfJG3zxIpkXNostfJg6nNqPqS2Lk -B3qb8sf+23LY8aDULjie5RBcFD7+4JuK0s65oVMD4gaNKE3lMvzDDwN9sKqhKP49lzClhzfdw6qZ -VM/h4Xv/Venn+9rtxwPRoOfVsE8arvkvchtRa+bJJTKmuwZVMWTK5bokkrWmHd77CHmIdVJY0KU0 -2opr2lin4IVmo4EFfXdEGrClhfVzkYYiONaIIzA3ecdCK3pbRWxCTDek0uqw7iVlIBjBuGxr1E+a -xSHcs5rV1mE1qA5gVCST6YZv3iusSuhuPiJGqsR8TuDIq8qyy7HeohLRxIK9uIcRHj6QM9RaEtca -t8g/eVMvZHrF3i1kvoBxsKTu4SRRL+tD9IIwt1XpJUJR0IhTQYfSLBJRjBhkmjoympd6W+HxS1gj -fHAZqm/7I0o9/LSbrVyZrNr1ufVfpbGyKxQwyH4h0IKMVDsW3J5FBFGOH+WojuF1LSH5rsJNfewZ -OScapnxj1NtU3XUN/HBARLd+gVb6Y36cdNV+itP9ETVjZdIYFaxJOkkSWBfLMTFcAHjaSP8s06YD -KIwTFkIIzT+zKvZ4etXz5xIPTk5JfXD/IGtcRllxqFybCm2gyqPqQPkVvPwHZXEzfeI4zs+oEFvE -2hrXDKLfe2Z8dBRB3DUB1juyibe51lOUG0Ko6mLlcq2FEw6UMQx6VynQqUtG1DEhP9aDoJ8K9HQ4 -Bu8KaDcTpsOAIlAOHDmN+x77Cu4A9RibStGjwnjnVZXzIDWzjqAQmnIHrG1iw/DMVqV2L8o4VAUU -x/xdGc5gRamPG5GbXdvqrx4ziVZf/aRCWNFZwEAxFITHNyl98PhpDEnIbhM8fVwKthA69GEqLq6O -BOGIK3fC3qiEgauRNW0QLyMZ3Zug7pqLWHtthLpiYXJ4jbonmufoJiF+jSeGyv4RD2lcwv6LyssM -FXU7JJifk+EwVpAw2cy6oamZ1YV9SDLqny3Rt2qhyevUrQj79w3JXYXuJezFGhk3oHBqkC0KQuS0 -3NaKlVgqWQKfnHd4bDW7EOZdz9pgy3p2Kaw8zfrg5ShbAFoQU+pj69n82qSO/o/6w8K6m/S3OP/1 -Bxrgdxk2r/D1texLDN7/HmvcbtmYT9xpgheEGPBrJpUdR2weT+lm2q1OpFQcmryZj5JY45gZ/bmY -iUSQStDZBOLuXys1TVzJ5dNluGaQ/a6du4aeNjTqe9mamA/aZwM98NEflJXw+lPSAqhfxf5nM9fY -RscJ8bhH8YoiCka6OvjJKrbsXCpUm4hPEWNfKgR/bGPL4PG3AkF49iOlAV4CqZHHF8KKwC5ie+BM -TU2dYiGdMNz+14g26G3hvovYFqkW+SaoUfjVxexj6Ty88OjWcCmTWdOsAWVyxexT2LKaPSfzFWsF -k5WDiMt54lzPLwPESwqCsD0gBWFkAPcazaOhsHoD02U6c3h7EzvBAXx9CcAXHvs8u79jblQPzTpu -/UGN/T8J/uEpqaFebLSLr3M6W1SUGO74CNNC4LMY/l++OzC/8Eud3XVxfvkj9TD8Zda11nS3IMYU -J7b94b2lehxdy3AstX99vyrOI9M4zI+kxe4WQi04MoiK23whyjb0UKB+cPZBJM3aTwNpC7Wsl7ws -lOa4/y4UYMWNMhst9ioc1GKGXyeI4XAspF2OoXgzKmNjaBcGbVJU5zUPr7JB/TIb/Lzp0rH2Rhq7 -nYZ+qiDlYljjdOeUpqt4ylYpNo4QPft5Av/4F2FgGKTupspbMerICNz+UGBxS2iARKcMSpKHw+H8 -kkfaueI3mu4OUZ+LqzCc+U/le65yvvpEcK4RpQWvQMZEgHO3JcWa51+OSh5xJMNBlCiz6IAO9n6o -NMO2B1jdAn8Vfxj1K2HtA6yriz/lPWc/g/v8FMYOMy8A2t2srnROf8VxVruq8s6H368r/pzvTsO9 -PwpcAA+npa7C7+5nb9Q1XM+PH/hxK+ivB7oiMcIGONpLGRH1qqRADJQP47pFt154R4ADCR5+Vxbk -tmbC4VjbZB1L9OLgtyfkziaSRrRMhTsRPhgQBhFVRcsmmcZiHfnK0hUPd82gVizZ+/5CjsD2Xwd2 -BCnB8UPLBOyzpO42+qzphDt8LIfADk4+ifDzG5Zcf/g3gZZ2fpJgWwZBsf2IaNKma+zPt5xpheP3 -YPL87pfkBvjtPwfaYN+32TKMKI/vwjLgsjukxh20GMWu4hkRP064otj0KB/sRqO77MxmWp30t5Ei -XTS6VUyi7hfBAp/plt/gQtVJO/+Vx+fB431K5with2sZBMXPOQY0psw4ghz/VlRCRBo3JLYbczT8 -1VfZ5YFQEKTrmQrbvy+v2XybUO8Bf8uKU4s30W6yaLGoelulfAdu4xwc6K+yH3S4Iy92rdjltwOR -mH8yoNIJMdaN1NwlK9Cn9ZlyeQ37TmOJZD4tL4Djfx9QF/DmlUGQkh+8uF4CXnla7pZWw9PvBlYs -Kb6qPPLxg794UTh2hK2VYPUDrB4ih3GTA/djOL7h2/jfH/45EIF73wl0knaD8NRbgQX5rz7QkSrR -nHVOzH2dW08R+1VaZ4guBKBZ6c64uyTUf9sBxDbl1iK3031Z1FPIj38IpzAoldZvZLQobP9WYGHB -epAtbocPnw6wbgNrpZjoZ5pWudO8JwZfPMYW1cf2hgSi4V9XhsvNWLvYASndr5p9jSqKyoemv2HL -chP6FD+b4PVwxRU/i5fT5N7+zUTOB++MVN0lwPBLfGpV961CBH5VEd/9AVH1nHtXhPF6K6Bx9Z0t -wsbbvssWLYtUPS5vddVjuPso62qKZLKIQP0Vw6vhdllpLdz7AwYS5I6xVK44lc6r6NiSd4kqbraJ -8xqvdI2N31vEotZSE/a0JW4WVt21I5VOGhmv+rCw6jpdsZFGofzmFxAyUfBtrBwBvznGftaFBcgS -d46YDMefZdvh4KNSHbztSQ1w8BG5sbDsOFslg3YqoFRR4mHq3g8kBW56jg3AmQ/YfDg4qDRB+r1A -XeGB51iP1EmFznmWWbjg3Cto8P6zWOPj8o1/8iKb+qNAdz5zhh0eRwae+d+siUStWcZzUlGhpUi1 -Xjy4KoGhb9vWjXD6x/JiePFZ1pp/cbrz8HHWLEQ+1iIHC//6PDsjiQJrlomU0lnNlqo31HkzKksR -ylG+XZAzVQ8udSIQRiVTuucZsO9uqY3R8PzKZzoL//ICa6prnq05kTje+jsWhj8mpXqof40Nwq/3 -y0sL0qtstZKb6/ZmHD3R81ttwuSStmizFS/ciZYmWqQ+hu5L+RQ9r8rl+J1EHxxpnEg5KIkVsbQN -DcAjx1gQzuZZzzxulFgTU+NnAKw3Wff26sqX3kWqzQKrAPG4ev/Ou4H6i4GONUnTcT0e81XX0jPu -hO35sgq4ElE36x6HA6kUBSPX868ZpSNYez4lXQz3LmUs578ogZw58hvZoY+rNG3c8HaIKVf6F0uK -iW7t6qowPotwhPjwhw6pV++8Tk9lcZXma7du2HjlVVs3bhhSB/bsDa+FJf9dai2b9PxqlcBj98hd -qyv0IXq0+nToT1wmLTKZP/RAOzxzl9RRWP0au5r1FhvvnFW+rfyO0q0YlENwimHSGHuTvRHfZBcP -m/3+C41SaVTlaSRuokP5kwBXRI0l0Ak83qrhNyIMayqya3eM+4QwwYTNzZNOrW2b4/z1PiskCB2T -7cYVzo9h5+YbFiek9vwKqIdDb7BNoB6Sa+DRPqVnzA/H61SqH9Wr1l/rZ3x3SOV34vqjw4YXH07Z -uFVEDTNr2tD9k1d3xvUMush6a+nSdoVVL/HdtOFNdmn+h2dbRXdRXSWxmvKbi+Sx/n5ovgVB0Mm2 -QAO8eoTVFtb9PVuRhuZ/kxgc+JdAB6h9slKY2qSsvWUj8rrVoP6bOkXGgulx0syo8SwKjQnWohqf -nNb22cdaigM8usng2BnD8UzDjcCJX0nthx9RtsP24wpCyEeV4TJzkHtC+Qy9QMT5BP43fVxZCL98 -QmkBtZH10YvPia8fXIZVU5FAN5JbCKOPKAvgW3dLnReLm8L89IsAQJoa9dSs8zG4gAdoKWOGwAcE -z2D4JNrW/3pSWRgYGID38HeTZtwSx/yGu+mkTUuHQ/vldjj5cqAOjv8nZWFvYnQPnfNOq9XL7V3j -jPYXDh1Xcpfl/oxfu9SLzT81jTUkKcpMcO3EbMs/souVrpQLRGhaE5iHSvcHMRhyHMnHojpFcAr6 -Vw+2FansjKOW1wzqo8W89ovamt7ctH7OHf3yBQKxebxPTMjMLR/Q+Y1EdU8ZzNHZJwqIpcaBYBAr -rRRf67zLi3AtY2rJr32iI3/iqTaIMXnp3jkYmkpHZv8lQcTfrRAKaczqeJ3LNRJAqtR2PL2edXbN -HuDnxKH8uiNtncS5usGh23yYf0rsQ21DzWc3nMMGVnQhHwHPehWuvkUUqeZheDYPRTA0+7mgcqBQ -9wdlUMqFcAkeYikmuBlUAN3c0HQqPDDzlZ5SoSQ8md/YKXNVzPwUBM6hxe/YzEWuWATn/8/+IBz7 -RGmDCz9SlveHKrjgyB1XFUFcHBQjAL/zI2VRj1iSF2XFCX7LGi78WOmFmrNKd648aCpd5p7Maypd -5BpDTP+UuC8S5ZVWP8FMm/9NTYIaNP3Fp1Z5qdKUfv8KLo2bTcXKVU4gtfRHSgzRZfEKZYzMqXKu -vNI3MlgjnfFmKlinP3Yh4MJP4jwDHd3G4oJHybFszsQgbolryxV3GUuO7+8fBn9+ZBenBvJy/y9e -+NmtnU1RtyCedVw64HWoUp0lwqzd5nIUn+XEw5LNkjSltmyFNJUDQqG55KU31VZAJliSmA6OStNC -A8U1ck743Pv6obk8X9y6w9fVi/BLCtSRJKBmeGXKTqkDSP2uyiuQVyX9OIs0conYeaxGNOuNknEN -zWWDeopO1GbKJ67UZqtSZoWuUobF7w2upBe+ocNLo2ze6jLPayscdZb9EbVz9zN/Yn8r980RlGxX -xbH+oMuPoA067/Wr5X1Zw5nhvSb0BX+cj4MKuY+VhkCt/xCWvMV68m8+1Ai5s0q9XfZRzaVwjiZU -Hd+jUY7kcN/C5bFpbvO8gT5CJxFGSbJZgpVbbX7X/sgZzPfPX4eFTOzngZbGcngbCsIPrsOUj49r -OHtbzipNvIgdKIr9aYdBRfB7oMSI6Or7DS5hw3O5zGwOy4EKSxH47hmlj9jthMytAQXSrynz4cXr -WEuJTWozHlnLOuCZtWxhXj3DgmUrhX3PY1y94kcBVusvB6f/VuGjGAVXej/QUB4fhO/vZ72R/5i8 -cPsZZWmN4D3/j3d2ksE0FV48q7wQKDwRqHlYhn9iNS0dONm4hfqsuhs3TTqVdEIrwnD6r1C+WDtr -GPCF5pc70T0R8JkJ6vHwhqPm47kZuOZ9FGnbTaw+2F/SIew7pXTy8+Tefp3uR1Kgm/ZDI11UVsdm -qCNw+jrWFSzN0qDlHdTr5NcCzdD8PhbvWk1NspPfPzbidsJIiJ0iRWHZ8XxNzQXtld5XegkrL2OL -5vNXpb2ED9ayvsaB0phwEH7cGGiHH+yQg3DyVaVGjUY3bFy3QaiwbNfkVSPcQeHFmpoLy+Ph8tqa -vrr+2w5Eqd8Fdm1Njxz2qeZKy1SSQyIUMObWezl8lUTC6Bdaco7kNDCBYUjY7xyvkXzvp9GHvkBN -52eoU/sf2ODasX6i3g9H2gKtN33anvbPAmr88JQXCxWmGq50zW2TId63xN+on8K9tTXPsX8H29Hc -r/iSAZZf9q5uLYnfiMlJTfA9tWSgv4UTeJxtVXkglPsanhlbNajGZxnrICpkzzIOZgzJPhFCYmYM -M5b5xpixhBwl0iXyWcqxtEhyjvW7FWWLki1pJaE6nEQp+0HoUO49dc/9/fu+z/M+7/t73t/vVD5y -tBBZeYGfQDTs91f/MkDIqkaVHBiddjuX9BGvo61toK+Ps+CxSGRXMgf0ZwbTOZoMRMKXktLnRKLA -q8yO5pX2YkvZrNGP0Gt+LMAdMz6YTswN4tOYHWyTecqxCKrdsRYQl2AglG97iRlPKyxjfMpcj01k -n3U3t34CGwlQUEDk6W2E8n9J7cgoPtqlqa/SWrP1EQOKE5KAW4Tk+eK8Cg5ICZiGJW4Hhy39S7Ti -Y76k8/2tixzMC2Cy1iSVBu4U4Uae+7CIJuF/Ul0cHFHIW/gujQPS6GFhmjQ2G+HRF5GFTVlOxMQr -V/hgb4xRVWO8/pnJQMiN/4ZyCBBNsoWc9qe+OW8XZ1bXYwux0LuBq9XK1IY9R9PLI0MV5lTKDp36 -VV8Teo2Wg9rQDSZeo+/Fno20a4hRMw6LPjpSO6JCpv5N78LlMFkBa+xF0nZDvr6HJRAtd2SzvGqn -QZ0DCfAdYRIS0Ejt9gu2v7tq1b0XfQwnZ/BhELwFS4me5Qf6PVVl5IB9Hb7YzomreOZZq4zUIqge -YwK8e/mJMCuhTh37Q28milRgE6F+2hsSFpMBClMMJGJr1Eauzb9M62FG2WDtrvJDJmJYEnuqemlS -Ix+zsDXbPnNgYLZHeqx5Q6UVhwNyXLgUWtBBDoVG/zqzxgH1/n1PQCamuSnJAT9TNX0KPAnniLUg -gXAjLy0/12ymYK1n8ss3FUmHLvQbwizx35EWjRe6FeV3xZgG93MNEsfFbYdVHgpulLAJYYMcrgOd -S3GiBtJp3LV56KHByXdpb3CcoYwWer7cQy03RDX0VFINrpNsRgKl2zNusAeI3XShANb8fdsOQt8z -acgXK73mq4u3y/pMHnPF3HFtysJ/JL+7yJKmQAtYefg1loTEk2tJvOOKIyNAK2vcgay1p4XdLbIh -wtbFgufv/9XPs2AVx4TUcDtvz/2Vxjr3UzqXez1gb5loFJAzomU55280P5qL8ePWOvz6GS8/Bn2Q -cwRs9l9zMKzw8taJwIWjJlTNuSf3eUOO8tKAm2omVIIes/QZDakd0rnhwMswG4Rj5L1RwBHOzdzM -QuGeitRLTreyyFJ0+mM9aAKnBIhhMBp56MUrWmPnE4O1y0eUZj61wsqKQkhg7x47F2bUZ0J329hs -3dlG97QUDx5kpiQHhOzDJJx5KcXUvsVAHRY9elNttfwhDCq5CTGJU3E4hczey0tcy+G4WpX3JrZ5 -2hsdO4B+vGC6NYfCZqw1bXxCdmirYYKO9WoTKk6i/rhTcz7uh0R7kOK3Np71+08Wua3w+KbQ8j2j -P4mPKqvv+5GSRyFNNQmgI2BFpKrMbKW5Q+hBu+DUjECwvCl8SC0JSXA2XPC/m72vsiXWo4vsGvgg -GeLfvUHvCPrRiWFRLNp+EAxaX7Wm+fIwidNoDwull+05ySdO2HWecYQUNIhAgu/eecvJxERUxJdd -M6qVP2P4hxtgroYBSumbxP8Q8HQ9CwLCL7c/fkT0f75T0If6zGMRLtQUQAKphvofvQPcnoWJW6Xm -lrnlcLRTMFCNlkEcxm6vVz1kJn58Wd7ZUUjV0CBaNvM7fW4Oa7RnwrrM89pqoVl05OAdyW1Tem5P -Fn7IIYEhbGYwhcsEWSQKjfFtWTQb6svfgBVG3qtBMyoUcsenqpEb/0A5/QBjIFY3balQfGAXRxyc -Fw2J3+40r9bI+AH0reGvBcTltcN+G3LmimQLbhaINcru9plKgZy1Q4GK3k2yl8RsIixThqcBj9iD -kEFOEYTUEYPGtb2cNty+TlC4tw53cFCtWCizJCKULXcz/F4o7YdiLiCPQ6P/dz+8HawTwst0zj/1 -u0Gt2mkoZ9Bb2ALr6sQgAV5VT+VZK4H9USYX3lLdaW1Fk1Hv4GbdrUiA7+IO8SRZxuHNx+NfKD4X -6bbeNr4FwhmIQ5r6QjBSv4UfSFX1RIQe3/yLts4mDxupVr5m8Y63UJ8RDuBhX5HCl9V/oV5p8ohG -FmUuWI5ch4WNNfgB7L+jr8uIOL/YcfVF801ZC3Zyzta7sL3pHSTgsyl5DuXu3iE5c9lt9Ojj263o -S52QorkdcIinxEiyAxWdQVCXMMNM8kkTKoAOmEuuPR0GW9TjeEdWGtk8U+nhFM/lO/ja/vUQdNfc -GLjw3iOJQax0f/J71bkuekTxWL1hIbSdIANM1+s1MdUPdEzMX/dEGaGfRe1yiYYIBADoc5T9WL7t -9IzDe5aw4HPiNizasBJiELwAV//oAe+fgKGga/Pdsdai9syazgm4lyCMBNJdGCn6sVNozMruK/RT -JhgTiRQQ/pNYiTS2CmzQ+QANRr1x2VXlqhAvaakcvbRxRQz6+l6u2x55H56bJKsLp4eSa/DnFSbw -qYvh8GsSgQ/oQ7dMhsVLuZZyUwd79Dot8LGepZC+tUmcHzV3ebCeMS5XEGtfvt8HZzaB+XmDl0Vh -M33okVw6h0UJXmMnkRVPRNatruR31UTvqtPVX0p7WPz/Un3Cvn1q687isPGNRaGTVU+XjvkrYHvJ -qcnsPd9jVP8XxEB8GtMcijgc+Fom4Vx5wb3qGIRZyFu43DoDCTR9qcQbJY/nlbk5dgbZBObMURYJ -0EGbDqC0FWpJ9i1vz0/PeKiem+Y2FL2Ag3VtDVEuEj3Tese6hJZolg34W8bqHQonc1P1tdcOLjwE -4TNgYtpjW0b1exUSQmNl2TWUEqq+BSPoVBrIoSM+D/qqLt6VKpZ1mztyKZ+YOFwysBuus+9C/gXd -geTr/wLFE+iEGU8XSyRiV9Y/lGE8HuAdvHic62xgXNXAuGEvi4JyZl5yTmlKqoKSZ3F+TmJJaopv -fkppTqpzYnJGql6G0uY9LL7WAKEJETL4DqHKCa5Z03PtvW0acdd+lCxTcIjBeJxtjjELQWEUhjMr -E6M6xUh2JInBIGVg9bn3cL8c5+h+52PwF2wGkR+hbiaTP+In+A3oTsq7vb1Pb8/jnHleMtdTrug0 -9oFC3wkZxbDPijEbGkjoCZNj7l6YTGeeQdEpVKs25aZAYkIH3eEA1iZYmgU6sKwCGlkHC5KZoQps -IxtEIF7Jbj6ARpj+zC2hO7xKjfy39nhjY+EVso7Q0CpplnfZNnwyxkAlbnY81+v/DVuQGlnh38El -t9q++AY5LFgz90+goOwYljFVxpP7byIUdfTTQtJSOXicnVNLTBNBGM7ukBVbwUSwgMQ6rVK6WIo8 -xISGkmAkPqDy8HUrW3baDmxnYXe2kZhIiInGix42cWK8cDDxqmKyRhM08cBRYzyamHDwoBc9edR9 -gAsmRXSSyT/zP76Z//tmbj6vfbZa+/iVsDejymhElQ0FnVbVGd18IqS60VWKNAKjJ6OwrGIZDhok -m0VEyilo3CAUl9CoYhQwGcG6Po7yGtKL5veDUV5MLX8V7gVboT12UvPtxX5zpa1m+fq+5dC/FrHF -+6DrxqRoTYrc549Ru7Kvr+T2cQ7ND2lqaQgr6OL4cDzvWdE6K/CPqloqJ2pIkSguO+tbkSBvRYLg -brC1cr4zDU1JwFmJFs3Fp/WBaRUTJI/aWxZ+zTWw2Sa+Kuk7YT/8K5r56VRzowOYgNGWaFZ3TNdx -eyGKYoqN3eHqwxqihq1OxAdOYj1jKEpchLGY9SMEJjnW2QXqqmYwka3LjWBA4LotFgZr3G6Dqm3Q -8bMvYRB2M8yxD91s4BAQzbXbsDnquJzzEgG4abhQMxC8qXGhF5y9GLjm5kxQDZMCJC57GamEUoF1 -MbdEnG69CM7DuCt1yX94mQ3u4wVFzUnK+dw0mqLt6ZxBLo3ExQTM2+WiCL0jmZUGnYz0gpA5ulTP -lnpBtQDLkmIgsyMWOprNFhDd9KoHDaxQTLZAryPa3Z/gyubbmsiejevbOpXNscNXhvx7b0hHVa+l -uN+smNpCVN7Ljvm1bO4MF2IrB/hdrD8JhoWEx/+7B1yz9TAJksLCDgmcmEVTOI+R5oU7OuCFIoIa -mjOQTm1LJUx0iKm+ng+xjOxPROchKiPisO7E8phICizatEAZaaiA9bT925Gc/F9pTG61kb1Mg/aK -ejRU0IMdO8I3bSNA4o++t1WB/azmQ3U+9b+rXP6t9z2gp/ALgUqzSPQCkgeDWgXGGFR+I/Nq3d0Y -prGGNlV4nDsf+yx2A5+yuI5Ccn5ecYmCU2lecElRZl66lkJ2Zl7KZj7lg9wA/4UNN/aLAtp8Ll6U -klY0GyOPuXyXtb+MHN2FeJyNV31sG+UZ1300dVyaxKRp0iRt36StayeO3SRtoXaTNKQJSZsmIU5W -BAHvfPc6vuR8591H0tCyEDY2TUWUchLvNgFq2TSEkFBL0AzbGK02jTKQSjZUtLFpsC+2/TFBhTSq -fXTPe/YlTgFt/iO5ez+e79/vee7Nn/q++q7vXKXX0ycrOC6r03a191k7Ur5mjSZOY3PxBe8lT00I -JTVNQSbWM7IqmLKmxuVJVVBsX3WNf0iTcI+WycL9HkFM40RCU8duPBlYvK9y0xr796WVZfT8iK6J -2DDC6UayFOa3krFmvmnx3ZrXtpCzV9kN84YpRaOGqcvqZGJGxrMoq+OUfAx1oMYUqIlGIpHGmBfB -LxJBR2W1vQ0pmiBhHalCBhtZAYQjQcdI1UyUFXQTaSlkpjESJElTdxqISkHjo4NhR4icQoGsYKbD -hglnjcQds7KZDjROwK9rYmJ8qGdiojEYRMedw/TnHNZxRpvBibxpgVuDsZXtG61ttM8+VD1/o5pV -WkDB8v3PUbG7SMXny1ptaZGo+WJZbUWyPtvklf37vfm/27BiYOdZ1FTDxMeyOvrfmQJB27AqySnG -u3j2lu+w9q6zvP1stO6m/MmwId+HA/avoo1rUDNqjdnhWPtQBmfE7FxATAu6IELVGaGC3LAkmEIg -uPzqXA4WfKEvCRPJoHzVtn1q374X9v9mlPxhgQuT1meYGvvjRxrJXwV4OHPKR9DXON5+YGHt4oFT -OGbvu1bpGesdPYJOnEA288/KtQNDY+5ztH98ZCVNt1lqIvH/VX8wtvjEzx8IVhvY7EkLqoqVQRki -qGK9R7NU015o215myarZ3gYOiM7S5c6axZ99XOd7vIRpsJnpDSRdwsQPfY6AzsCkoiUFJQQJAb1i -QhQMc78rsTNgaqaw+kbQPj29mXQd5krskb94yTqOKcvt9TAffosTNckuf6fBVuxScvm7zKaqlAB5 -j6122yC3n2WauRDaZTe8XZM7/DRzemvJKM5qupl77yLzt955IZtVZIChpipzDvYMKwnWUyQODR/s -TQyPjA0MD8VRShEmDSRD3jJZBWewahooYGDswjsJ6kRNx9GoCqFOaFkaVgNKwNDQNMZZpDtaoQAd -LS0tFAqatcNsoedbCuddaTOCYuEYsrJQs1jIkC962N2tSFAl94BgGFYGo5SlKGBxlopGs2msOhYC -cdBYhMmXvOz23Msetrl+Zz7gaEaTJaRbatyUZC2etkxJm1UDR3Gyx7E9Th5lmKpmP4UOIMcMIcgN -SkkhdCjeE40ein+BGoZEQVGSgjgd9B4nZ66yVZnxofF478HESPdo95FASgrGilAI1tLqAzoTUgAS -VymCkgOdBqiiEaXuI6zrGkWRrIqKJdFY9Q4Nj8WHew6jlKajrJzFRthrn9tRax//uq9jpm13uK01 -vCuiyMmIis3wVD6AAeplEADv+kcdiPePjyWOjgZdnJOPbmdqPQU/w/bZSJP93mPryJdv5usIWmL4 -7m5jThV78vt9OhB2NEr9LpTwcHIKixAfNxQhNGWMqxLgWcUShf7x+4mvjWkkrz7JbCVaL+Nd73ru -xJ6c/ojd9Pj7XBVpOc/5SSzIPFaSjzVZOsLVTgnGAEVFoEAa3fF47+gYOII6OlArBXr+0SVIwTK1 -ZVuAWT7DeFpwxcsDqSGMJSyRD9/gtpFrEXYdqQWD+yFf1kzCjR0tlkLmUEYWdUCoMQ0pSmLICHZq -GehEnG7JpgUDAzoyWJIFE/JEFv7MVZLzHFN7W1YzzDG4F7ibZqLIzLipa+rk/nF1WgVdnYGZzMp2 -8J4b69I+9GZV+6eKd7lUi2WHJ7G5zLgkW8M1kAuvcGW597ez7ZXzGtTZbB7tJoBK0CUkYUPU5awJ -ZWamdc2aTCN31IDKNahGBNqwHkYDKQQMYWUBZbJihLwQMB2bgqw6EiVZh8JomdVlE1Mc5l21DCyh -ZJ5hUj4HtY7IPL4Ncmkf+z17/I5y4tvP3lrVZ6kiBUQTEmHbxPmKqTjNhNYVLzwfZbdUu1ZGo1NG -T9Hm9VNMO/m2n62tWHGtEI6WGBsmL/+EuanEgIuog1z0s7cEiyQX4A4x7AEHDtJmVqz3hzF2W+7F -/WyTPd+nWEZ6JeuUQzXa1gysz2Ck6TDsUBjT2nPasQYDjWaZWcsMoxFNUYQkLIwMxwfudLlixVoD -wpqhYVU1NanAnEclAZ06pOdwAaoVBRXNyViRqF4IrqzDJTpiGTn/Emv8OjBOA9+BZjLhNBaywBD9 -8C8ODbdP00ddSgaUkW88x6G6/HaPAKOZbM6tOkIePQYwee85TiTPnOTqSd3z3Cby1EluB8k+D69T -V5jystUyScMT3Pbc3ee4b/rJtSWujMcZ2bSv12wlF+oYT4kznSDi28NsKPXDGDhpUDptvcLdsfPo -WF80OiRMY2nE1Pc7ueg9JmKnR3Qi7D6Su97itpDfXeG8JDfI1AfNtAzIpJJCK4cKGKCT2MpFoZyp -Jg+/zt1avryWRwxp+ACcefIaW5rzvcP9oJncP8H47YN7ax9/ia3faMqmghsTtK1NGXFnnALx9tLV -rbk3WP7f/J2QvyOCKaYRZWRnoJsyokigzU+BaVeC0shP1OKsRPuUlqSF4hSB072gcDTFcnqBCuQE -xIOSAu1kF/7F1lUWxvFEAkwdAeE9sxIdSbzO1A8cIx8jpy+we8h/tvOl5EAJ300quhiedrNZaQg4 -EOogackKZIe+GcA2QWrIiJVUZJEuBUirn20ll5tZDwcbJPEKW0XWbWHKeSqBvO/nw+StHTxPole4 -9eRFmb153oVqZwCOFGLttknwxlLMlfinCmeR34/c55ZO2egHenTlBIKrd+l8NoOLdoH03TjAKXLC -w3u2FI/SeaXgqoNe4GYg+BK+2h55ssbOLvjIgXq+xI68vY4s7eCRd8Vo8skOPkJ++SBXZ7/c32Sv -H82HoLudqScffp/zkOsvQrN6dA88Pf0B27UZNvN0S+kh5Ca20BbJ+TamlgmQjy4yu+2HD3vKwKSw -XCgZqLKlB7nNrpqttBaAQC0dOickHNDekh/V82MQOXOZqyEVaWaj3S/WbHfyXOyw0/qck+B03nvC -7GYHebpmzx7ZPO9shtDOiYmd8Deys+ijwrlsKAKQWEdeSBg6uBT4rFP0EwZOFU53IAel8OnWB4Oq -hLpg7HDuy0ZvJmvOQaq60C4URTPzzrKC1Un4+AmiFtQahGVHTOzTaXOB5fTCvEQ6kubXHBvctlb8 -qbNqAMuHyB10vCRWDZkdeZjbm1vw8L9dz4RIsozfRibK+A0cfCrk7t3IX69cK0sw1EIz8DXx23g6 -YZB7mvhpW7u0vszZChtu9ub/xNaQS038QAVltN4Z2CxMReRiGFTBZ/ICWRtja8nlCLuRSiBPPcR4 -yEt/Z8uCrvWFgmnpvFFGnsGCsdyZEF9fWnpiFPh8GKbz3I/28NNe++QvykjJAb6BnOziy8mRIX5t -bvoAfxe/YfkgiAe2MWE+ydjn/7iJVOwBOrh6kI+tyCItvfy9PgelXhp7KOO53mMyudjO15Bze/kK -8lov/0mR7lf7+H9wa5wLuR8f4h9himQNDvLpotcFi6vKvT7If6Xqv4bKpfHxJZf+WkDW9MneLlM/ -6AdNOK55/rooeJyNkc1KAzEQx2ktgqtSi1bRg01dWpJSF72IrCiotKD4BW0VvC2b7DbYpm029QMV -X6EQ8O7Fo1j26jvUZ/AF9OTZ7KqgoNCchsl/Zn7zn5dO9Pk22unGdeqAwt76xk4Bru+XkXyNzEyr -4IA3moSLiyOrdmJU1zSdMEyd7mM8mYKiSr35NVpv1owz4ajIKwlLUBsicHUFZLc1G0Gy10L+4CQe -uvHCP1BhtNUmuCQ4Ze6Wqs0BZtXJvqMmudyqw+3Spmke7mbBaT0P7AbzBCgwu4FVTY3aJAsEORdI -u9SAegoapoOE0RQ8mHpMXdOkXtlyXYIr5eLi0oHgUCn0UIL+0ix/SYQEiaScdzT5BmIGJ6LNGQhx -lBGm+dMK0xT8okgZ3lPsUJFKOwFnvkEQyoeURo0wcI1WtGu/mnofmA1orbZofK4MVn9vLu/mknJV -n1KmRUYmJNHnRj9dgrlAh/ySrkXlQjOW+r9HgAJ+NMGZ5HCF4jCthDI9Nu7jzO5Of8fze62HWN93 -TvtPp/eJD8U5yDb+BuPlFzWoa2mH5HCn176V9cGlVrueeJxbf5798Xn2DY9Uef1cw1yD4j39fDz9 -XBUmx+uITa5X59iklsmIKbO5Xv0BC6pwc7zO9ngdxgdSaKoTr4pM3+vDyLU91p0xaAEAFKoka/8C -1S5fRTeO6pSlnE+JxK5b2JPrRzF4nJt2jHHxMcYNO205fTLzUp3zc0pzJx+w1eTTUcgsdiyuzEvW -0NS05prsbyC6mdFOVBUAtWoP/vAUy5GzWcKM66J/Bq2aa4cTSf4yiUJ4nFt8iGnDEaYNeqbiaUWJ -ual6yfm5BZk5qSluIJ6Gpo7CZj3TmZG6Sfn5OQqZxZ65BflFJb6pJYmueWVu+UUhqcUlxRpewc5W -Vl7B/klZqcklWprWk32apDc/6ItlDA+zUChKBYkWKyQqBBTlV1QqlOTn6yl4BSuU55fmpCjkpZal -FikUp6YC5ROKSxKTsxMUyosyS0pS84AqFUoyUhWSU3Ny1IsV8svzFIpL8osS01P1JptOmOiZWAyx -UCMfTDkWpWvq2pVUFgBdrWBrqwB2FNhKiLIQoIxCTY0CprbJ1ycY6oOkcPkPi02TbzdobjaY+Jkf -APNwdf76wAFbc9FfkYZwUk3+eUpr48kizphIoXicrVZLbFRVGI61hXYoltCWUtrCmQrjTJ3etmGk -ZAr2OTSt9mE7bbFE6OnMmc6ld+6d3ntup8VgYaMLTYT8FliYyFbDAh0XaiApcaMhwehOXWjcEoks -jBsU/3Mf02lpBRIn8zr/+R/f/d+f3y5Yvltwff/WJbbAma6S+u56Mq1pCpGNLlONMoO3eTwqTTEj -TWOMII286ekf7Q6H+0eHpk+zGG8gMZ1RzvpSaU3nA4zTiDp/TNOFrOGflGfC4V5Fm6aKwx5o85zN -V4kcqDIb2kr2lgeJo3qcKiYjCV1LZaMHXngGXu/YUTOU6DRmmU6OWnRJNka5Lqsz/gBph7uN+8pI -mExEj4XDDhmGS33w65VtrZbKzqEofgn5ocSAFjcVRqg4+WfysAVJmvKkYwduVe3PfuALFsPZnkp4 -7VDlYZ0ZmjLP4rYBxIHeCIdn2eJQwn74rsVhGpulM2ytVvhOqtoZtFDbovifKgZ4myrgXHcRvNVT -XkR8PuKFk1JdtamqyGJjHNBiswY+aSSV5ovgjRwAcrgWPprY3rLe9ERSFuw5oRFTfRRE5aMgWCAA -50PliKMwuyJdKq5vaiJ9KqH4TjIab9QSjVxOMcIWWMzkdBr9BudbqibR61Q1Mkw3guhIorM5U9aZ -5LgIb+Maw6uMzJMkk2Q6IzyJAUWQRKGLgqRalLSuzeg0RTKoZNqUFS7BM+3V0HykCJb0FvjjUKmA -1psXWDKrahnV9b4IWJ8ayaHzG1yX4pTTQBvxWpzovkFTURCSzwf9vtqtFhUfuyVSDStHi/a40Tzt -JtR8KmgbQc9UQUfr4Bbbb9bxTk1IBCH7Z2vB9nw6ooTG7hBMhQphqKsEmnsqYKWlLDsfaS10+TqC -g88KFG9IdUAaK2FZr9rlPhRbRAjUhQAX++qgI9MLPzWG4VTGH3XYZuR5pj555gm1G8W8zUPwBSd5 -FShS2dKmKecPBCxO97WZ+cdmny25CZRqR7ucIH7bgveoQB7wwLn6l8otUsDBfJYwlILfD1Y/Uclc -1GsqqMm1x/kXfmy16uqVp3+yTVyMCda8P9S9vq2i/lOnnCqZwOIYUkeckonouqaLFLb1NGBNGaaC -BuC6v3LJthkkMU01uNDichlpFpMTMtM3uBOogvmEOZPpi+jJPFTzmhy3Ucm5Bv4opLINMA38r5iy -xf1flsCD4yNL6xzh2LTDn5OzxexUtClWwHFYCTZsYlG8xbg7riYyFyeKZ4VyTCi7FYnuIZFoUjas -vzj0iPqixkmKUdUS4Eldy5CUPTAsXSaXNZUwgdGQ4OLOffDz6D91zsjstFoii4sZJbJgtc4kzQ30 -sGLOyKohCQCD7hQUJwxJfuLue3WNvs0Tx+cGZW1e+ih+pvFjeQrut7XCjdqycu+q1gDOXQvf99Fl -mB5rwG5bCO+NTcMF7GH3InugeLwZDneVQ/d4A9DLzbA8HrLuvh0/aP0+GO+1fu/UBOHvyx5Io/y9 -sVrgdAd8Ur8Nrk1UbrGK1gNXL1TCNxO9cHN0LwSO98A1vU6wlORSBW59WAUfHx/tcMK8UT4+2ZN2 -BNuesxklw4zFmGHA7edb4beeilLJoWP4AkAmj4w553mxbkhcx5GWYHpUw3HjLhd2CK0eYqnPDX/r -tKEMXJkcchC43FB3oq3Y6WAemJtoG8lTttptSTtZIxcmKTrr1IE//yaYDwZ7jViq4NNUKHvjROGO -WUz/ETYjG9zKHZyslHSbBtdS1loVJIZGpjgmvXWcElnvjGKu8cW0GNWUk6SmxHMXaaZzbHMq1saU -HRcphYGZkuA+PQgPzxTBX7OfbRcN3OsujrDStBsaLnnh6q7KQivNflHCMFEahK/iVZ1MnXc7ul2y -q+skXrkj5j82S+gIVRRTwxaCmkRtaePLaZP34BYS436gu3bjtuMiF3UWFIqxc82dKYf3F7bB1wt7 -wTtVl42m3vEsOU1jCq1KKSqLGbd+pamXmjT0hi7FThv1gSmC/sSrp1xuctNUuGp1nxm2FhrZGBCm -20lusQ1vsuSI7XmTLcce2LCUaS6yLrJfZH4oKLIiDSsLqezDMzdL1hzHtmTfflfa8y8tGTw5fLZb -Tm36B2j23O9CCwmt6RQE4ejweJz7rvJKecM25s3OLCZ8ACckBM7xAciVySYDdEAuSGzdzJDWR87d -UIKEeJz7Hd4VsUFXkyUtMad4s5LmTSYAQoMGvvWUAQscnojyU7Sh1tLYRt2WJuQtb06MeJyNVV1s -FFUUzkCKS1tpy24pUGhvqdnO1N1taJDaxS7StQWKAna3hURie3f2tjvs7NxlZrb0B6y/URNe9MSM -TQxPxsQXg9kQ4oNBEuODiSkEjQYT1AcTQ4JiDIQHA5752a1bS3BedmfOud855zvfOff8harrX1ed -a6mBY9W+tXGeZv0ql7Mg1Gxdc4TR7N443FzbUWypOR7wE3xSnKskQ40kmzYPTYhWgyj4jwYJNzNM -l4jMNcMkc0RnZkHXSG7M4AVdZpG8qYsS6esjQceRnDpFxJIxHEO4jGt2rBHvPRiEE63+9UvfXX9R -Kr7WenPVfFcXGUrEOwwMmmZEpnKG2YkRdCUFTVW0LEu7Nj5BKHEPE8V0nAzGtAg5lDeVnDKLfkP7 -k65viqlcm0QUjmdckGq7boxWJidEqJaeJ2yKqgVqKtqkE9MLQCepojknDXRzyz2p03weCyAJG3US -3zKYsKq6yXpW/E/NUiyqEUZ1VcHPrjvWoJiYd4bmmYM+z9Ihokw4CCY2gyhoNRVVdZOhORZxwBKm -bmeIB3WWPuKGOsBmdjnGwYImmwrXBqaZXDBpSmWdlZ6kj2gFVcX+uQcwoDiUeI6nCzC7bXh+OSq6 -52iWuTFFJ/NwjE8xXaUzCTt1UQqRjmhHyCE7ktf5lJJmqI1wzKVvZPhZUZLcWKV4Zd47vYZglEmV -p6hqNfUK9bB4q2q/EY7JPJfj2lDCy8aITDJTXJ6gJJG5Mrj90ILJOwkr129delRoDP2Xl5joxsZy -TmpMXzKI1uVmIVBrmKgEeUymhvkUfNrS/HRnTFxCLZUnSv+qWXKU7w1S5zJCJLh0NTC8vBdLiLsq -qrAfj+0sY/l4JRXiVC7kUSfB+MWWlhKzbRX4JWrgy21vwEB7L8y2j0L0TkPx+3a9fnNlKrtx9kZR -/gzVYAlHhQDc6qlbV+ETgis7t9SV248lSSRa3LcjWwO/72z1B4OkbRkm0Cl/bYn6mDihQXfPge4K -EYkVDXyAOuBez8Z6WxCeZZDrcQqH7wY6yvopNTNFDYb/2R7VZLqGLZzCHu2CX6Rmq7VX8NnaYitp -y1hBW2WOK3vzP/uyeGMDvLFQV/xq957VflxsY2M4ZzQ/NqazHBYvWtefEZqfzOHkqWyvDYlUhLw5 -OJQ6zmQzVOpJNMo0u3hRZycKis4QBra/3gmf9/mKr8Z76mCxqQ8+Gy7Ae2831Xk+cXt/og7hYKJN -CEFjMiyGiGfT7Yk8XV3twZPlR27tbrX6k0InXB3dAR8kgjWOtpy6Jbjf3b7GzRLMJFmF5MZG+n1s -WjHszQkLI13W0T6hDr4bCazG0YI/Rl6ocpZ5cXz09iZ7yydxn+FgIGHmjL3ldEbTYa6pSLjBicZx -7XGdERx3g+C2ZRFyBDcpSTND1pUUM5ydz9U07mMy4akLbwgcMzKOfRzHde74pDn6nrQRnBVKZZkZ -ksF1O2aOlu6RMgJ3d6+qpHSqz0Rgu7X53WNr4TSvFxLQ8GIz8vHndCN8wx+Bu9Pr8Lcdziz4isn8 -FwL8dWKTL8FM1JwUAn5zE/DMGuj62Afq5mDxuH7DFzEziuG2NRzLjSnGYdSaZibsStM4fd5SJlHS -X9CiUbg3t6HI53q3wm9n1zcu8+4jpl5g8NH7P7SWb3BbjQbORY7pru8eFaUP79xpW23fu3SqHV6Z -fby1NGQru0tw8XTIJ6t4U9lD8/xL/uKZhdupqoMDowPDxTf/XvVgIcOH9xsjD5OvkWeyMoF3oPPZ -urJN2GItbhQazlcLvfsHV4Be0vvDoLNsxvkgQcO1JuvlQaHWGh8QnrAuD+KFIna3wyfxAGy5Vuua -IvuEx2Drt+uss/gGP/3qh3M/+qyf8eXCW0NCuOEf4K877vwIim/CAVJdEvL8hXstRAUOpFt4NUt4 -nFsUsDhwQ5B0vQIQ6Osr+OQnpqQWKWSnVhYrJCfmAXFRUaVCYWkqkCwuTUvLrEgttlZISU3OT0lN -UQgN8ilWSMxLUUgsLs5MzwOKpGXmpOYl5qYChYtSFQoSSzKK9bhAZifl5+fAZT2LffNTSnNSvVMr -FWwVSopKUzcHSF/iAQB4zTFJ9hcq6LsA8ABRSzkKHCXHtGxOAq/EuXicO9XG/KGNeUMDm2RqRUlq -UZ6CkrOSQlJ+fo5CZrFTaV5IanHJ5jo2K8HJ+eJcnCFRLqk5qSWpKZuviDsYTf7gzcYBE5ksKCWy -ebMXrxKG6OSSTB+goPnmR7k/heuRbCnLz0xRANoRHx/mGx9fBLQpvygVZGFIZm5qVH5eqgZIhZZC -UmlemK+mNReXvr5CApCjUAJUk6CQnp9arJCUmJytUJKvUJKRqlAF1KKQWaJQXJJYBLRboTyzJMNK -QSUkSkchv0ghNMRZITNNAKgysQTotzx1oMLUEr3JiuLCnDDnakxe2C8zmb+Sgz8zTUFDER4CmpMP -tGlO3juZnyU1pzh18v4c7cn8yzjxux3o0M3HGp8KTN7bJsyOHEh+k//oAwAHQoc1/BYNfL31hOul -wYJ03NQ2KSS3qILuU3icm9zGfLWTecOmMvHc/JTSnFSP/PzsYqfSzJySzDznxOSM1MkJZdqbd5bJ -cUqB5YNS01KLilKL3Iryc90yc1LzEnNTNSZfqzdk11FIS8wpTt3M1qDFouMV7JtYoKUApMC63IsS -CzKsrLBbMVkwTrk+KT8/RyG5KDWxJFWTq5pLAQgy0xQ0ICIKamoKirnxOFyoCVYNAjiV6BWnlmik -5+QnJeb4J2WlJpfo2pXlamjqKJRkZBbrAJ05eXYRjxCmgskri9TUilJLSovy8BieDjRcc7N2y1Im -CVyu2HywLcgGAFMcg0j2BpcbjgdbenDNtoPksI0/Nw0dOXTmeJxrSpqQvGE9h7RvYoGWQm5+SmlO -qkd+fnaxU2lmTklmnnNicsbkBVJiIkn5+TkKyUWpiSWpCrYKJUWlqZrWmxdzlLBLewUD9dop5MZj -6p6sKaC0WVzgtQIAkxQk9/n/ASnboHESz+nPiwf4TZP2zUSvMfl7eJylV11wE9cVnmtLspFjwLYs -/8lhbfyjBVlYZQhUxnZlE4Y4cWyQsQihNWvpGm262hW7KzVOYjyePJVkHMgZsrTNEMhkmAQ6hHbb -qqQFDLykk8lMHtLOpJDELU4fOm3TzvSlhXR6765sKbYkSLIv+3P+z/nOuWevLFg+e9F67Nzxnod+ -dulDy5rHpQgelCIJAe+SpO8r+rS1B00rKqfyYWYg2O/3DwSDUkIO437CuIGJZVhDnBLLkNwG8+hg -G5OMeZg9WJGEJI6Y9DZGMe6s/Vk7Qy4uoUrM+KSKFaY7TfKat7EwUeWdVmVOVCawPCKFRnYGVZkX -D7nZroxsQhZWSJJv3gJyozisSvL2BC+q28bUHibCqZxJoU9eLh7HYsRtOOX1KnFO3OZms03GZSnJ -R7BM7BqRhvB4QFFwbFyYhGN/r9lBDPr9MSmJ3VQf6zG5zPiHZP4QL7oNlr17HnMTV1nCQW+mBRmr -CVlk4JMvvPCDeHVxl31K/43tiGsdJY5LkkDMYwXLSTzMqdEdWOBjvIplRd+6vhU589B2t5zthOcW -HHD3u6uYR/Ek8XwCq+EoiQ6H+QkeywNBpjf9TQs1IaaI8WvHnMgDr3N+6LxUr/W2IitsPVcLXXtf -LCYq4PO3ql2mQG6jcHfvZvjtK3a4+4YhXQUHRoXWAgIeZoITFOxh2iAQqoJGv13/2+h+e1mWjyCO -DVLj2jUfqnOsCIGkEK4dDDiHc+o3hNqfUvpIEjEnugs5z+o+bltJx1BCVUilGTWKGWVSDEdlSZQS -Shr6HVGCfSZOBD2UA+LRhhKjhps2wQvRNv3X0XcrtKPlqMrhZ0y0L14URnDgV5vhMakCYr0l2h/L -USuc4frgg2SFNckJCawPPfO7qpevs45gWIpj5nACJ7Dx6E7GWHjp+iB8MrsPnj55EP7wURPM7Vql -L7wklNhMO3Dkcnt9LkETY3D8+izgkzXQeyNilGjgakjHP9pV7OhLiGNjUU7JGgNuOC459Tdf/RRt -4ScYd4ayk+bP0Oz3y/gp0lT9kjgh8GHVfUiQxjlhaJx+BO+briIPA9tPsgOqnMAsu5SKNNafneqy -G9+ofuKB388rO0jnDMl9RA/tkqUah9QJs5fhX/56+PdPn2iYMkXNr8wEL2AiQIvJdEPg5appM+IC -jUN7geKua8mFlda8ZArKqhLi1ai7mdrwb9rUPKawbFZds6bRUncr8e3LVaVLsGiLjipeGeUEPuJm -mbY2psn88nAsrk5q6x5EzkEDYUQrJVDbwUlFxTEahDtL2aJCykzYyABr721nmaa0N6Kk7pQSYgQq -tjgCX8qSof7LeuiVN1m0hvCarxYe/0+p1tqM3GVZ6uDyqd/Xe/IJT8G++V/qj5xW0HBfghdUXjTR -xIybb6YXmZTmwhoTXXzNh7KWXCAeT4ijg2wmXzB3JrjUOVtff7+kMd9QUqhV2P2IQ288p6CGQiP4 -6HmbBXXC7Nt1G78GlEun0uHDp5854cg7Dd+43yxGrWYC9TA7sxoGu0s3fr2MugplVLtgRRwUX2xs -yFd3Opb/mXRo37ahHl26WFP+FabUT65UkCnVAM8HKuDD81Ug3thCJ5Y+cHWu6L7V/NwYdD98/gG4 -9VGDUfE7N9aVFColHD3fr4fee7pgvQ2mB973r85z7MLuljoYuXnWRd0wujA9pZYwQI+ykSb0xJ4I -pttOZCfppOGldiRZTwukycFFucysytNpbW3G6d17P4Nrme3s+aUdd6KNQ2yBsbPcMyJtwF6V0jvX -Mu0UC3GlujN3RFOZJSs7R0Sjtr0Z1e8jz1mL2AYmyctqghOyredJSC/Ttkwj48/YAO/HtfraW1ZL -bT4M69Xz+1Hpoj1o+u/tpRdt3ooc8OMz1eC9U6uf+LOA4MorpbB3wamJ5chlocuxdqoU+V35N+Zk -TPM5kaOIZWH3M9W6fcFt+wqbQ8ki1A9/3AsXv7Boswj5TryGGK18DXLCB3+xwgVfOTguu7TGSuTq -yyyopkc0rcuOEmNlxaKSkHFQ5QUhIPBJvAvLxFW6nUDTJRaG/7EWbE82wv6ZDv3hv95cc4/06N47 -I4hub/obd5Mly+hjb/tQp/Y9C7qcp5m0Oivqr/SsKKN2wIre8+Yrm4csFzlkTjtQjdZjQzPUndSf -bOhJi3bBgb5VSstCewOu3XafuIrs9y5ZqqMMpSyVabRnGUqVr0WeIudKAsk1C+XvfEebd6DVqV9U -oqsol/irDvQ/I10wM9eeuu1EEoKum2X50jNXh5o1tRYNP1hgDJNlCQ6ur9cWatGteyg7nLcVUr56 -VGmvGAiOUiQwSxDSPl+P+qZpfN5DWF0cEuSf0YhtQ4aR/Gt0Z95Ia3JKOv4MHLO7cyB4P0sc/Wnj -Rag9uLkl9/6fdossVyPkWNS6WtD4qozzZ1tQIO8Jxkx1afM1yKXZWlEsS+i5VvRQnhymLraid0u0 -NS2oebWRkzD56ZBpVuBMe3dTPhezuZq0OR/anDrfgVLFWlkHavwG2taOObQXPMijnfKh0/8Hbm6d -tvkQNC7DDQ7M/5d9ByNvDTGLNipGLYh4nPusdUZngw8rk6HBZF9WGyC1uYt1AmO9AhD45qeU5qR6 -p1bqKOjrK4RkpCokJ+bl52UmJ+YoZKdWKuQmViqkZKalpRYppBXl5yqUAFUUJJZkKOSDxFJTFEry -FfLzfPITU/S4FKAgoCi1OLWoLDUAqM4lNSczN7MktahYByxfa80FpktSczersjuwKkKEk/LzcxQK -sOqbnMrzlbCqzVG8KazS+BTsENrNBABJrliC+T9jNbutJYFXei4c5y6iyzzH32yNk3iclVJNaxNR -FKVNi7YpgiDUthRfWoozMjMyod1MJGBTBSvpB2pFUcLLzE3ydDJvePMmtqSpUPEXvIVuFdwHZuFC -cOdOBRERFOkPcKNLd85HmqTVgt7dfe9+nHPu+fpp+NHecPtNOnibDtD0CrVgo3iN+syENUYbxAJm -GCYDzEESv3bmRhb9SgWYpyDxTBlPe3HldUwcLtrK3PoDhl0XrDXqEU6oI8u50VEURjK3QOsusXH0 -U8BmDQzjigUOJ3wLmVHezZqIulGVp4n67tTxbvJ6d7p01KirxLEM47LvmNGj0p1QITY4uL5Px+r9 -uIxavglxv7WEOVZQsyV+bEwMopZYUtUTjm/bLmcdDsK9NRO8U5+mxPcddf4wgFxcEwWpICmmoxHv -YgimAZIsJxPu6tKkVgW+ypJ2kKo2LWN7tXwPTC5e6JniASF6WM0uyB4PYIwyubcYbA9Qs5tGC++o -y+LLwpgAfepUo66ZoXYxWklW8yGOG+JDdlw81+eH4mpNRw/l/v44Ei607AFrQB/tA9gVlFihEG5Q -0H+Q8B2bOPdDyzBaZbgu9rIjT3Bq4LT4pt9c9ni4ySyZ2OMX/mbNc3mptza6Z/wayq3mvRpmkFQX -sRt791jHu+J9dnJQzgktW5qNjpVxk92XNsH0OS7bIB8WMXicHUuFM87UDt9dK29xiHSVjhSg70T7 -/sh0vGctdrr/kD1oLbRfzfIa8RKB1TzxVigvUIfDJicVApYko+1tJE5+nAlu/3TO/mPx+ZdDEwOf -138De5JhUPUEFyIC6e0fFZysMOw9IbgwUjkOX+R4nJvu8c1jw3FeTq/gsMSc0lSF4smKiiIqIfme -uQX5RSWOJSVFmUmlJanFGl7B7jn5SYk5/klZqcklWjoKk2t4pRi1Nh/hDRYDAIc9GHv7Fkk8Wsxb -+zUwNU90EkrHBbu+evWzeJx7+Zqx/ynjhnWWm89YyjJt/mojJT3ZNiJ/89aIe4wyXsH+SVmpySVa -Csn5eSWpFSXWXApAkJmmoKE4eVWUGacOTGKzQvQ6xnpHhbJcPaBIcUliXkmxnou/X0i8M5BwjQjx -dIuEqVUvVshIzEvJSVXILFbILClWyC/PU0jPyU9KzNFRKM5XKCrNU8jMUyjJSCyBaQHyi0tSE1MU -8tMUyosSCwoy89KBWkHKEhXyUssV8vNS9bgm14VLSJYkFqWnljhD9dnCTbCfvCrcUEhHIS0xpzhV -U8FKIa80J6egpGjyghi1yf98Oe1RNdbUKKAI6NpBDcpMy0xNgQSLhqamQjU4RIBgsky8/uTueEkO -WJhMviBjMDkjwWeyRxzf5gsJkqIA5OCCL/gCFg+tRJ7pQIfNOHpWqmiDzHQ9LTB4nHs/m6lrDtOG -BWKSOgrFJYnJ2W5FibmpepnFjsWVeclgzuZ5YoHlAEIXD6P38gMEwfv34xdWvP+8iv3C5KHOgALV -AnicrVl7cFTXeZ97z+qBEEKClQQixEcIxC4sK14FsYIVQiDzkhASL9uN4e7u2d0Ld+9d3XtXDx4R -bgt1x26De1t/cTxN1E6NnaZtYOjMNmlwcPNwp0lsmDKTSWvXpqnHaWdw+KPOTGcy037n3LsPPUix -G/0h3ce53/mev+/3HX3tYsNLf9tw5SfzBxU7vU/XVJ1Z13/wWrPzcktNxV7DOGPdYEv+6bTz9nO1 -zruXq3qGdSVrpQ2bjhnmGWZaNK7oVFNsZtKkkdMTVKHDe3uG9pzcM3CM2iZjYXqAsSy104xaSobV -OHcuLw5kTSNj2EpMY5Tpo9SInWZxmxo6ZaPMnKBZFJg0zEzYuX2pxYld+i4c/A9pwY3I5V1b4faE -5FuzhppsJKeaLEF3UN1aF42bDHUYwA2srBJnfYY55C6Ahpekzc6tn/ichW82Vxe+cv70zsYbb968 -/Jhz+53K1Y8oC25tJkvhxBR5DK59UW6A9x7IVc6D79VXiO9hx0vykhvn3sUXvxYVb7z40ZfWv7po -pbRpS6iGej/7h3sjkR7TVCZ25ZJJZvZomhFXbNXQ+40Ei0SGcrqtZtihMZ0l8ouOS6/WhkP/x0dU -Kb+Fe98kfrjydWl3vj4hKdKS0t7T1rH8CJO+IX1q6YDSr8LqtPSth+/w07T05v58zzel3/8cfOFD -qTr/Ny3y72yp7svpcb4Gfn5Kbs4fOiwvXZ7/S13eVtGcMRI5jYmk3ZVTNVvVe5V4mkFWk3fDV9ql -Cui05SDcPyLPgwcpuQpsW14PBw15IfzIlqvyH1gy00lgNAOtx8kKuPBv8hI42Sa1wdpWqUkKws77 -8sr8gZ/KsYG1NZaNisbpsG2qeoomVY0dHTo4jB5QxwNxQ7dsivftNGdqzvmPWwj+hR8Mk8cmQ/xR -OGkqqQzT7X0J/KUmVWYeV+30QaYkUNpALhNj5rCa0gPBYFfNhZoZm5nMMrRRlugX5h5gE96G7uv2 -4vsQnf7cQu3a1PFgzTnhcTVJA62W0DisWnsyWXsiEKTt7dS5oNEAPVcKS842aBbhARO5IDucs5Od -AdQO6F4SglduEv/htDLKsIYZhwRDV+OKhsvjhomKqHpcy3Hb6Fia6YgR6BzUJ5vVVKwPgQ2uIsVN -uXZw+w3SCFf2kooFdiISian2ybhi2duhez1potEA1ymcUGwF/RQSGoY1pqfsdABv2+HFfeSzzutj -VZMFpbuE9Avid0eHi0uaitCFmq5uWy0kWPQMm0CdNPUMK1QwukVBZMsU/N2H6NXnRrwLDdYm6Oru -1dRCY2wLbXPXcTmuOYe4LarVE0MtcjbjQBsoqCQcXhTMXx10LSgt2F5yumsd3PtzebHz3MfzJ1GB -SMTLPZ5AXKnhCctmmembhC2RAtwtrp+DXQUnDGClrbZogiWVnGbTPcP9uJ2iiXAnVV3R1LOiIrE4 -VcViFm0bF87obhsPHy8ISdt21op0dKRQh1wsHDcyHTrKPW2JPx0xzYh1jG7cEu4Mb+zQ1FiHqqPT -UXaHa7nVwaxMh6dt+LTlTH7cDM/3kJpJLysw/03b4hYGME5B2k1XdK84adEIXYF/yoyaVSslSJhd -J1iI7mV5RRQf8k3hO1sJPXr8SF8kwhMW35Xeey4sVhIv67RiHc5hA3PrqPCob1axY74618f8y3fl -9EhkrrTi2zgN3/XPK24HG/aQxvzNDeSmtIHv6ZoSMwwNu6wSP2P1G/Ez+zJZw7SxTFXLvexFSEVV -YEOULIe/ukMWw/gm8uMlXGHc++RJ1K6/BJoB+MZvkxULRb3r2KdQECYx3NlGDu72QMBEE/Bxq8kQ -6k1s+ufP08I1oshRHRMJKUTikDmQ07QAD9Wwl3s0Av+wjRw9URSPGqAo4QPb8Fbx52WeLdt1rtXu -G2893H9GWgZTUbm2z8zprllDbk651qUwDRXtkOAaiA+eCnhV3CCEvsyxEE0qmsWCTsO3NtVwV2Fm -Ym3AyGbSDINflH1NQq1CdbmoyBego1aW+AFSC99kcdVc6hfrs2Qw/xGLRrHeENpYWXiGRWb32Phx -DHFklkFlWxUkwtEpbGSztcFsQ22mF8dDtMHy7kFExz6aoF5tsUQKATuNXrMEdqtu2p02YuVIr+qW -mihhKJa4FHT+eqB5ZcmkPmbH08NxI4vUxWTcjF5DT2pq3IZv3yVLWkraYo3zFqBjUhlZG8tnw8QS -59r71fDjB9i9/3M7WQbDvaTJWXJ/ARzaTJZtFUVbbJgjOYaomHD7s2ufKB2B2aJk0R089vnEZvIh -2YdGe1QKuWguhabwVsZUbHDcYIx/2uDMzsqyuKhoGmNIWBnmtc0XcbRIYO9LOCO9jc61Z30NhXIb -dMUFUvCLmxJ16vf54EAnqYUvd5IlUP8d4oN5X8JaxWdhGJwi1W0zlEc9p5MNzix6pkhzTckWRxlo -cmUt/BNS5zz9e1X5i51kngR/vIMsls2h/Og2UiNPetE9kmaFvDBpJoeoklAt5E6pnGqlkZ6jFWgp -bwgCExJMUzO8aVo0iYBFUTtTZVYpaVCk6zMvL/jKM94IoJqUjbvS6QnhIBTN7bFE1+L+1DQOvkVp -Bc2GPJDxQrqjiDrug3Iwhvcj6MEfbiUdddMXQUUn2QRqD1ngRCcq4WAXWQjHO5EkYNbkf7eLrPBV -eZvBa93ked4tiz4NTcPUEIK7xdz7fiXLkQJSO8nnG6YhA2/CcH8n6VxpFWI3I5plxKsbQj1keT/2 -tDnTtcwXiTIeVuKA5ZsWOmL+5R5yQq6f2SDy/9NLVlS1e9W8f3gQ46habI0XsKFpsuFeCCHkyh5M -T+N50lQrtMFoDNrmdhi5igRt8Dapg7eHSEvHTMZZcD+fEtxnazzQ4WPQMfjK04io794mUaA5yQe3 -H/P5oPIEaW2f1ZnKoW5dNJbTj/UHgvnPniAnJAgz0pb/6hMkLGUw98R6ZCvIYhITJZfxssVmRseQ -RFDO0xITmM5ovlLEU8FrPCw7o+oJNwlFRDVDSQi/iwtzXZT/hZ1fJS3Qdpc0JzguZW2zNMqco672 -B3Fdn6akIpE9iOg5BPTQrDe7PU0uhIoO67Em9PghM8FdV3jmHL65Ak52++rmF5KM95z1SbKz0r12 -7rzXnHQ1XRfNMpNP0F5oscZ1Tp/2ecSrX42bOH9bZ3DYCdFZTyMRL7WLsRIja8jbNET/8Pt+WHNO -asyvPEBerIb/HsYM+PtxmS6anZdwfQiRPDQDtSwjZ8b5fTCfP0IuSj1ijCwxpGLgSo+6aook7aHc -ZV6RXEAoRVp6Bz4RnSgqNa0srw2RpV1YlqW3BTY9U3JZKu0QxPpYfyRiwQtp4u88YrgufWj7RrVQ -WY6W4RSzi8JLrCb+a2E1vBSPYSZix3WhPVDSOsgpTztsPEweb5xBbz85BeJSnDfeWfypKFDJGYUv -ymZ7wRoGiyt+BQ3iXp1fWMeHVeyoq4uaVQpA2AEbfkv+TNPcXMi59Y6/itoTWeTC8IFG2uD1A1jz -HVNkkdTlfH2g6ZHJTLOfz4OlOYzLdGkMDD5JDsPWqySyUjzswp5rIyHhE4S4WhdNctF7TNPAyQGu -m8Qvt+5wTr7a7jxj+btEMWDLjitmYlp+4PY2G7d/hX+cDc8tht+cQvLEfQJTW8jy5W6NuLDBJ4lp -LYFDXiO8dZdUEz4ZtN4lS6NzYdbsWgmVAz/Pv0J+NzxJOp33n/XBrX2kyvWFflCaDymTNGBjboA/ -2k0+484utw8RP9AoqZRysHMdKrIzStpqS3JDFAaHSYvsFe16LNrC8BEMlh1olPfSMsjZAW+My61R -8SbHZ94wh2wmSnHat2X4+3APzfvcrB3Ki3xurP9kflvr3Pq7+c6Vswtdt31tC1nEzzvgaj9ZXuma -C5uOkQgcGyb+ZhzFZovHoYy7CiaPofN/FpUWcZ/WwVObSGOHR4ln849ynxU7oglv7yeNzuCzFHqP -E+rjn8K9qLS0JLGak1cOQnCPkXVghOUF8NYJqe7FJ0hf34WawmkCJ6S9a9cWzlHcDahujCF35FQG -m/cp3sbDvFxO4ZzBodf7GLJXSdNkgY3HFcEmsfmrFk1jjXIP01OlKODXVmHbAmXgTAFXWAhrLs2h -AQO3xw4fDNP9nB+j7DEsNqQRZRShLB9q506IhTPcB/QpHFQ+ZRo4A9fW8PDDy0OuA/MfP0W+7BNE -an3Z4UBaSZR1SRdNZ/fOkWUydd77/ALnC7+syb9wivxCgkt95ICz/nsV8wX4HClC4H44d4fUhAUo -Pwr4Bc6qqcfhjbuk0V886cBeVBDqPHPb71z7rwpuQuChQkXwxG1J3ORc4kIzDC6Ubvk4KBaXT8B4 -XTYTZjGSzBwV53S7S8OOl7pdRRJSU/w4DLe2Ymv4cCtpqcRb3mhqO0lXdWEjONJJVi1/qFxeKU7d -/WUVYj28ECPNdQL9ixvAgwhpgtZ90mLojpF2uBcjfxacFUXumbloMiBN7s+/GScTxN0i35ciT9dF -yrKE517aNHQj53ZX1Go0Ey576u6DkxDHwy4ESrJ4VckVMz8vA1vomUSFf5kjH60MTW/xc7oD3mc4 -+HJkEEgWGsOx4+YYiVa6xQVT/0oCEB0nlf4SLDEMi3sGB9d/hrU2cBZ7xfkxshYy42QYzj4h1cOu -SULho3Ec+PKE1MOFZbKf5zusmSA1sHOU/MW6R9EuWDhBdgavbQD6iiQ0rIeGs+SpIfc8faYjMY7F -3EVa2RPn5wPu+WCgNWUq2TQ/QnOv1kWxjWcNRB7sOfzY7nGL/MbkzM6FUIV1EvZm7IwyQTXGT94V -nSp8eze/qZLk/5MTR+slnYQuAhZjOBIiZtk5U7fCM+UP5mIaH/752faeoiTFLn4pcFQ3qIUjPA5N -3sQq/hdojOku3maZLs6BxDk4nHpM9sOPVvnmr/JGkignGTbmKY6s7hMxi3jMA/lZI8z7IemAP7gk -L4N/1khtfbHI56YOGAl/SyEjPeLER9yche7eUeRL8HNOLK68ukaQH7ypghunyYrFWTXL+AlsmRYw -8n2C4PTs5tIGzvbnqsVHtUy3cqZ3PAcN55GZvLWZzOfvp3/B23IdXHtdqnRufeCDa1uJb9v/KyPC -zsX35sELyAKdb/97lWwkoPU1yb9IDFA4ZovW0YvEPgrKKwgYG2+R5t5CQL2+qOgGJoY57TwPe5w3 -+/Io8q7Es0hEUkTQuXO5ce/0ZBrhcOAeGSE08mxA0TSZ03DW0/jBjhCBO9KEqmR4ogijMN9gJCw3 -wj+u8tWtfJR08AJxsaLSLutD9F9ISy0uGFUTTHgTJi/Ja0SuzLNFL8D5Zo4YTotIVd44S0YqnP03 -g2K4ztdfJPun8i9RX6YBnqS+7nzlRt+quv8FAXPF4PEbfmPeyNo0KrxVGWnr4p2LStoOnGd4nG2Q -TUsCQQCGqcWiokuXwC4TRKnZB3TKsMhV28QPaPXgQbZxnHRrnNlmZwrpD3QKc26dDIJuUcylY5fu -/onoX0QiZEFe3xee9+W57Rq9B+P50wgiAn0f5FhNEmwxdpbGAjVsxDysP4xOwMzYppNMmdn9o5Rj -Feyiky7lzeJhIR86kRQJl9E8vHDrUDB+gIUFee0ScmwyiiTnmKJWeEfLqc6iAluTlRz0IqA53PIT -0iXCpSZEDRyqMkYA4hgKDOJAcInDADHqC3AFOBaS0592DzSd/xTVfVxeA7GR3WBhvY7F8JggrZD+ -ioxtqGM6rZ7IrHorBZYydqF6ipHYjfYx0G9RNKAU3SbmSdf3YF+Ouj8Pq15tQrfLd+OqXeZ6phJc -nRtxKF5fUd5NVC9cv2xuJySNxUZ5/mvkN+0roJIQT3D9/pqd/wagyqRF8QLpss3w/VwpA1NFYn0N -NfhlD56+A3icO6b2V22DkfAkYSWh4uCMxKJUp8Tk7My89OCS/KLUyfrC4gDUxAvs+SuBWXu2EMyk -X0ogmE3ek8rCPyO+VHicbZHPaxNBFMfprrmEioUUi4j6emvFpicPNsWYhvgjKAopClYJk9mXZuhk -Js7MJqYY46+Sk15y2HtzF8HDggfBW6/+BT0LAW9ectC3iUIP7nH2+77v+/28r78yXyaZT2MvU1I2 -NFhxQsqCFG28jWb4+szFz2Nvcnq+4oK7olZ67gyzw+PzS2/HC4Pxwlw8XvBG2eH39mL04p1/eS4X -vc97T3bW16FgQSgwobpVvAIBsgAUc+QK1jG+B1ZqZ6EZWgdKOzDoGMk5Sjmdcw2kt2chWocBcC0l -cie0yqajycBfjn/kvVEq+j3wL0T5G97ZwWHJiw9L/rlry20tAihXitXqw3vVKtfNlkSHBSnLd7Yf -SKZs9OqDvxgd5b2l6GPKn+8XteKhMagcJGoh0UArEQJnVEBTujaTlIRCMQfMICUGqdUuCcuVNYOM -N1hNYjYN9LWba9cbyFrZ/6xeWc2le+l0QgeawoldIhIdvfQ379c12dI6ZruKN4xWOrT/AIA2UEPX -QZxxSdwTD+HQsAQKDZ5kRPziq33/2NsqnHTraLNHietCMSn2/w5Kq0EhBkk5MbsYSmQWoRYKGdg4 -98b/6fWpoJkecceKfXyamzZ9tH1zY8MiwcPHaPRW16FdSUSrs/+zmtjUpgtc6lqNtjPihlOwgbCc -mQA6hnrQep3UDxXSa4tOLjVnkkLU62iyUW7kX0pNrQe9Az/uHZz6Fv4BgaX8//QiBGL1R7a9QdO2 -QyV1TNgqIwEiKdJ4nIWQvUoDQRSFUSuDpRgshGu3gbjpNyJIIFiIiImIVRh3r9khszPr3NnEKBgs -LQRhH8BXUNLnEQR7Gwt7H8GZXRZsxIEp5ud855z7+bCyeFx5+Qq8C6UEdDSj+IDJSKAeDDidoFAs -4nJ4rFWIRF6jnT8F9fl3sNic4TWGY4QRYkrAgPhQMgEmZgY4QYrSCUFJe2XPJtbIIrBs0EhoCLjd -cenVBFIOkZGTgdI1sKvVcl+zBCs2oTQg1QQmKhOzCEZcOEMEiRPgCRuiDz0LQG3JSkSls1DhyIf9 -KoELWOFD1xcjSNgUmHDP01LITbOIyosuUhmbJMw08TH6hZjMLAoClRqubLLds343CPqFQa8scWhd -Ue9Vncpju9DyS/C2/x91o/hcmP1m+JikgoW47DXmS6fnzS3bo6s0GCRDPhzhGLVNK5ARRn7+erOR -f9zVd/r22dK9Ru224LqR/ZXay9+f1/O3tdX51X3a+QGOacDV/Av8FtktX4cgEbD9SZJpkocRr+lN -HHicm7qA8eRCxg3izJzJOYnFxQqhQT6bRZkDmAQUgCA0yNO1qCi/SMFWwWRzMiuvoSFXeIiblVVw -SVFmXrpCbn5KaU6qd2qlW1F+rltmTipQs0Zyfl5xiQJYGZCrtjnX7BajUGlmXolFfAlUR0hlQepm -R4scRumk/PwchYKi1OLUorLUgMSSDJfUnMzczJLUouLJyy3bGHUmK1iLCcPtAbojrzQnp6CkaLOu -1QtRAME1QJvyAkVNYw6mfoctgA4B5K4IJXiwxFMxeJwBIgDd/5DGAqvGArCJQpNRPxWT31QFk8cH -DZN9KgyTsDwHs6hCaGD+hg3p+ANhtkcPun6VRjiI0FJvhtKLqHibKHicATgAx//4AvgCkPwUSD8C -6ZjsVhvCYjYXuNJVqkAR+H+TEAE1FKao1yYKCV6pWo9hejD0GckYkup0k1kBH8RXF+7/ASB60Jg/ -5lEHR1tzvz7z1TDf67SveJwBHwDg/+cD5wOQcBSeVDHI9XVBFtzOMLWZpuyJkOAvKLGEYwHz3Q84 -9RY/3sgvtpgBWyh1cDnLa49IxfF0Dnic29HJ3dbNveESy+QGFnHFkCBHZ9f4MCMNTQWNnMSqyvji -wpzMklTj+JKixOTU+DKjzUdY+JhASjlgSjefZJsSV6+vrxAc6OMZ4hrv7+sZEg+WVMjJTCpKLMpM -LVYoLsnMyVEoLi0oyC8qUcgvSsnMSyyqVEhJLElMSixOVcgvSC1KLMnMzyvW41IAgsw0BQ1FH8eo -yHioqR6OwfEIx2mCFYFAUWpJaVGe9eaIVAe+yWIHRbgQiibfSJXbvKa4Wmryq5neAU6hfvFBroGh -nkGu8Z5+Ia5Bfo4+8b7+LqE+rhrpOflJiTk6Cp55JalFeYk5wWBP6ygo5eWnpFpBgkAJyC0oTcrJ -LM5ILVKKL55ceF1pukMkI89m9b7D3JuPz1rAN3ntXqHJ75fyTf/gyMjSfHhl++GVjNsPr2T6KgUA -MO197v4QUqWJsBtGuNu+mpQ0seSojeT5Ap14nAEOAfH+rXqterBfEhSGQEXxIGIggjE8HA8pyxnk -7FkfSrNzEi4HFJt89KXEzvqZ8sV+kjHCiT9FNlImk7UZTRTljlPHEpn3dm/qwWPe6Oat+bzptrMW -GhsHFCj0liipMQq9f/Pb7jIt1UUkpPhps0UhQgIUdpoUASHeQdXk9I3+MSnsY+4eS7aTkSQUs68j -WgtEz/4Yelj95efzM8DEWWYQyWNWh+gxMDA2NDQgUGVyZm9ybWFuY2UuaAA+iKU0WFAST99S2uEU -Gx8YY9IzgTEwMDY0NCCTzyMVs2IvSwQURK8iViWRg+qt+8XMXR364HzmCNGzwTOrARTBtA1OOPBu -OYNMCwvdqEEEyZkGXrOANa0HhU94l/wBDqSw/uV6bAjTcC+a93i0SZ3ghCh4nHv2mWfeF56GFsYt -TJcYp6u8YjRoP8XItP0UI7OMBQC65wsV/5wBNZtVEYPFvRJ8kLKqogMKzuTh76p4nJVVXWwUVRTO -Yiuw/FjbAgUKnG0D7LTLFkLUZEtbNNGEn7bWYksiMnN39u7usDNzxzt3tiCQpj74gJqY3MSaSMQm -xkgUhNQYeVIfeDXy4gsh4oPxgQQl0UQxBs+9s9sfQBP3YXfnzr3fPec73/nOF7cafnqj8dLFLrl8 -+8BkEOWB+pEHh1hwkFapO04c8SznjMPJJOCn8yWqntIdo4IFAS10GC/r9dpjZvEmUaaAKL4Al7EA -nBCoF4gTGQgZ+EyUHb8ENvEhpEK4FJwtAoh/wmOc1nGH4l0HaVFkkqfl1CM/z8ruI9vkm9eW7Spw -4vim59icCRJWQpP5Nk1XvQyUXJYnrsnyx6gtMnAstM2qZwzImZG18rOvG9t45JsB9QuIbAoaCjMU -NAjThrxzpVVuHWvu6+npgReoiLgfwkSZYh4crHzkg9ptQZmEQPR/QGbKjFVAMEBU8OlxIQdub5GH -xpqeiAPSeajPNi8SmKpbzMwtVb0cbBtzuIiIO0hsTJVO39uSWCefH+pryDPmyssH1sz+MvJ2orFI -3JDOTo1+uGQSgztU5iwqlcFSeFYOrKpnwQSL3AKGQAvAfAqKRwhJFR85LTmYI1dhski4TpWCKo5N -XBdTybMqzc4FNVxJK9Rs1TM5LaaNLKa7kK7JmK9siYq0Yehjp5P6R9MWIWcKW1GxmKM8LaqQsMTA -NKXC8fAbX+/rGdax5Ildyc5B7VeHiV+AMUfj2GUsOIjBMvVgwhFlCDjznJCGiwTFVQC4L0/FBKX+ -PNww0s+K4CLJ+oAoEwGWTA61P2Np1kLEAJfwEgZV5MSjgPGCIxQaXlXCpTA+RTANvG+BJuQ7n2zv -LPrwL9Kaq72cGuqUNyabpvcsTzTJt86ueDRWqdw33r2k6smp8Rb5x9kWufdwalU/7IJTp2rylUeM -drnz5gp547eVsumDtR1V7/7C1OqC3ZTWapGvTLSsGmUeTSv6QwP6ZPsj6x/DEBXxpl5E0fe/3ib/ -Ptcub99braRl0eMOFtYC3V9hvWpIQ4HanHrYznGBbYZAWewTvFC9Rkopajiueb2aEArHdetYDh6d -b9h5yamPiygpBKccBduH6Jzmch71cjlOA5dgJykS5bUDmxszsNPolZc/bZMj37fKo1ebW7W/6DTx -oC84sYUhH/94XXecevahZTHqOkcZw+leeXGwe6QPaiH0LgrOKUJKb/7/ppO6uaFWs2Y5cGXV7FNj -356ZVHocVxKuq7ZCaaB+FbE6GaKaNAMWiQQzhWNXLGxq9wQEDFtW65doklUbKUkqADQr9GsFE1tB -iJBZ9Ao03tBV72PGg2hNHlCrc9Am0a/lTr52N2a6uPud0NQebqqwTB2WWaAILaipfT6U50balK9O -L12R2ChvHm5YpxHwuKmiis+kjd7k9N1koqNZv4z8Ba/lV9c7J/GeAtqWldEtX8IjIUQBKH7nWMJE -XBwFcca2zlG57v5RICWsy4JeV1RV8eJC7BTY2LiJ+ZrfUKAwc8hfGIVKFKg3m0xqKmPMWLMeqVCw -6mGB4BGt86fpU1ybRJg4+kxXDcv/tHq1UsPKgeMFLjznD0bYaLCjH9Dqu914r37GnopcsSdtZB6c -xP1wUh4df1J+eX51VypWma5RLFuU8rxyJ8oOjtWUulbOXGuVr/5wdcMDeLlcbXjLyxfWy0vvL5e/ -zjRMn1mWaGmoH5zem0wYGx8cChOMV0xVkOnvliXWoIks7UDI9EOuWDDH69c03y+/+fkr+z5aOrvy -x662/aqWFiliaqYSuxW7u14Aq+4xuFqb1Uo5Nb+ab9HYfOQ3pa3yxT+vb1LEzCPO1WJY9bEhu+6+ -RvHOp32gx20aCAc1g6ojLqekgN0Xe4i+aMH9PqbLgRNfNybWeLvAiUEF7lbOGIeHMotQbEWcP4Vs -Ut4519Kg2JLvXUjJ89ZWOeb8Lm/d3Z3olTPFqvw8t2nH4lDTCyqrzJJrkaBVxn9mN//1bu4fCVh3 -9/IC9NnBRckXSJVH8iTRhHIWpPurWHZ4nLt5nLnxBPOGtkrh8MTiXCuF4NScNAVbMKVhvLmwMiML -APDRDP/wCFXeluteCF/Meq9sI6VSu85sugbFeJxr42jjmOAv4nbHcVtblWZk5QXTWYWXpa3swtPO -bkxOYnSK8Nw88aWs9+Xz+6c7nX4+m+HQlV0MhgYGZiYmCn75Kam++SmlOVBSL4Mh8Ez+sgn+zY4F -dZEHpaf8nxYyJeXOZHYmT5H3H14VrqiX/B3Gcn9xpEHyk1lMzy9uTmFaxAgA2VA4lPoTvCl3bfxA -St585uAZuSKkKeVgOsZ4nFvfw3K4l2WDduxkg1qWyVp2gpNtY50m309hS/QKDkvMKU1VSE5MzkhV -sFVwKs2zsipKLSzNLEp1Bon5p2mk5+QnJeb4J2WlJpfoQFSUpBaXuGXmpPrmp5TmpLoXJRZkoCjT -1FHIK83JKSgp2rw5Vpxxsr847+QPZ9kmH5BSmXw2n32zRLyoq5ZTqF98kGtgqGeQa7ynX4hrkJ+j -T7yvv0uojyuanZMnLFEM0lFQystPSbXKBdupV5SanllcklrkkZ+fXaykw6UABUpFpXlBqcX5OWWp -YCmge5Xii3XA4j75iSlIgpMj1ypPlt0uI6qUnloC1ZPiVJqZU5IJlN68YUl9IgBGmXDJ9gFNqDKZ -guBgp6PAQRWJIqWwDtggOnic62lhntzCvGGPKLtGclFiSarm5j2iAWsAYGgIlvpTcoV94Y8lzGsx -wrTHa4hySPaMhOl4nF1UTYgcRRSmNIPLxCy7JNllTMZ9m8XJbGx296AgswQJInr057A/kOmu7n4z -3dmertmq6p0MyWZRCAiiB+vQioeAFw+CuOSwIILmqCDoOUeZsx6DCPF1zc7sbObQTL1673vvfe97 -9e3j0q+D0g+LlbccEBI4tOIEQaQQxmrHAR1xTR8EP4uTECKuIBUaFGLasPYNIXdQgsxSBbF5r7JW -5l0utduSovPw00r+bjlWrsbbGq6DecdfMNJfYuumOXgJOlwHEYyu75Rh4qdlhvn0TVY1P/uXzjun -7lo8UePLF2eKTG5RrWsz183s/pxpD6brtgY3EJ0utRS6XSnakneojqLYoTPUanDHfN582/Rar5Zs -FvPH1kXzKKhec3ezGHXSr5MjptoB1cUgbsUoHaiFQrsq4Spahv31/DBgYP4K52oO8DQEJairMZUt -yxPexiDT3E9wpWyehq+bp3+/YN7ED77wSs/XYNH8Wb+wpimYJyJFt8t11GgQNX6WuurEXiDay3rx -MY/k3JlaEf39oFIh73GvHRFmCVqn5bJ58M+8+XHvrPkOPfOg+Rr16s88251h/vnpU42VzWF4ybyB -lYe/t7+qTo519/6sN3n+bPC1PLNBSsmfBGzxALjaUdCLUCKRcCwQIiSQyDWGxFGEPBwRM7y/qkD0 -UpCoRLKHDkXHpA2JXSF1gUUqJISeFGm7vLq6Cr1YRzY85R1cgY2RTAngoECQoHhfgRZkpcDdDJWO -SdVxoV9fhP2rqgGxhrZA0m1KfhwS0R7qHdNQnWQYxa4UiW3yJfiQt1D37eGGghYtjndcuovmt+AC -8/K1bbY8NWI539om05Ntdtn8569NJaihk2kwl2eW8o+brLpFuT2gQfdHxMW24SzVcWKr6Aqqcshj -lyJ9HuysWL2SlqmYifUpwAnO9ZHqQnNv85X8k4hdND9tzlbIvrx+yrOQCFwvm4/ca/NjoWuS+FgI -jmmGc2ehVhRs4/ODiL1McFMLJ2kmUAtEe9g/gk32fondyP8N2MIBNSbU6CGRPAUfE9EbLkfHxzBE -MguhGzQKiQnX8R6e7Jwd9LESEt6nmdkcNAA7spZIwmIxecEZ/QOPNqdYdM+BYYXVgtIJEKsWSgcR -har8bpNdyese+3J++Gz0SJZx2qaHRWKgheznv3js8OjWTfbNc0f3PXbl3P/ajtKW/gH6EMNNvqwJ -PLI7+ksnvKpxvNtfaHicm844nXFChEjh4Qf/XnD92pe086hNSOFNhg/qMX4Tc7QB5LMOjPQK7Mxy -+TUGFzJUYYCk5oHilxvZwtt4nHu9k33GbvaGLYwnd9WXlqQZmsWX5MeXl6RZaHApQAFY2EpBKzk/ -r7hEodTQTAdVKj4nNc9KIbM4syoVIQMyIr6gpAioL7e0BEIkxydnJBahqQFqhqrjBKkpBRkzPXA/ -o8a044ws2y/sYpRWAgCMVzMY8QIddmWomUGnkvwR5+vi1DS50CPeJnica+Vr5dugwyoSW8R7e8tH -tv98SodrbM4c9t/Kw+q62YH1KCMA17sMz/8B/mB0+dmSYnT5FkYQ8INwadRvuJh4nAEfAOD/mgOa -A5BeFJ6i3KeSYqqTxh7jKF1y5n8uJQDjsXIoAeSJDdb5AyUo0XLyCLr+mZ/uDWDf6HnluizjeJwB -OQDG/7IEsgSwGAEUPvv6Gzt6AAGQ9CEPLVAP5QvJ6DKTLAE7FGsMl+k6+j/2FiPA5W65I+uCDuAb -k3sBt3E7FzT8LJfi4tsjveDX2fjXv+C76p8m/X6xeJyFUc1rE0EUJyUUWaw9FIyi4GsLNcqmiR+H -stVD2K6graGYapFSttPNS7t0dmcyH4mtSMD/QOfmwb9B3LsgePGkJ28eelMQxP/AyTYtWKy+05vh -9/Xee/e98Ppn4c3jkf70mkAuynruyrozvdZCEXex7FOWogs+47suLGCbaKpcWCZCxYQGHReCjoVz -vQmY6gRWmdhBEXQJvc9aCE8dsDUQy4nr+bOuFXPzzmdJwtJ7zfzlgKVoiq7zLFsdweLpXq4VohUL -zavRqf7wgwukjLRCgR0dCwylsmk80DLewwPdQZwTwBHT6Yng3Cqxwb1jg+TI4gBqxsYvZF9G5079 -Ge/HmSn/3/FqB26H9XewuURKM/8L43mDDb4d/3TTyLFStu9/LBvZKL1cLGbv6UTB7DXOm1/JBxPN -TJjPk+fMt3Sx73O9LFh7eJBqtQpNknAap1sQpwqFlbYNJHEkmMSIpS0JvVhtM61go1KJuK5wy68c -gjfmgQxjXZaATzCqi60utAml8shik0Q7oBjEdny1jSBJgtAju7NHe7dGUsFCcKf+cGklvNtYCR48 -qi/Z89y4DrfhWq1WmzdX2Vez7140L9xJM8uds02kbc87zslu8efF305W9fz8AbXGPddIWe8qeApL -B9K2Arace9O1eJzbxbyLecMyRpHqzOZF01ffWW3FtrGiZ7u/UnTJO18AtZUM3681eJwzNDAwMzFR -cE4sSs/XK8nPzWGQijDr5ZrWcaF2xpzlfBlPuDpf75Y0hKhycQ32dPfTy01hOC4ZXBo+3e+O6FKR -hbIGNfzWWS1foIpCA4JDglwdfeMD/INCXF0Y3qRYHbV82H4h+ETjzAe6CopxrpYVUKXJ+Smp6al5 -ekXFDM/PFVqf1Hygtv7RbQX1VE7/jd+F/sFV5eSkJpdk5ucVg1ReO3xN2i6oLfvp+82LTxQWpFfd -XqUMV5lbkJmTGl+UWlyaUwJSfHB+6Z21kufUdH97mkSk/bsfY5XEamIABAopmYnpefnFJZnJxQwZ -dTtdLBZN97c42lq9Q2vz/50tKhIQVRmZRQzWx0q5eX59CLJrsD47cxeX5LK3VdOgFmbmFuQXlYCd -pTV5z88HEscTj5lmFFjmOmd+3SWSAzEjMy8ttSg1LzmVISzmyeHE+sgbXfHu5rW+88/NjP/NCDUp -JzMJZMrZG8f3XVGRZrx9SPZPpOHc81dsrPPgKvLAXprG8VLm7d41cZ8/tYWm1lbrcbYJmkMsyskv -Ty3KzEtnELkgn6DQyD7L+8fEGm7+HbMZb02dDDUlP6k4tagstQhk0v5bE6WdD8s6p5648ei/5/sl -ZoJzH0JMyi8oyczNrEoEBTrDq/pXm92v3Vu9XEPa9eoL/3+WH55fhplWAI8W7bkzmhfJW1TEf5jy -NGMd7xo2ofvnoKoKMgtSga5PBSlb/L/p5JsFfac/u66/Xub6wjzwOstpmLKi/PSixFyQKpmWtiCO -2I1v3/Bf7ZN+eHz7r7XaxRCXFaUmApNCWWp8cXJ+QWoxw7NZ5rcnvfaoe3fX5KB2TJO43OH5zyAq -i4sTGd52+ebFLVG6JeTvxvhG3bxjarmkOES2pLIgFRExO3/sTFIuv72WR0pCZNWVPnaWplX/IOpK -SzJzihm2ex3KtJeu1PVxM7j5+XbJygcGLW8g8mWJOZkpkHCySBZfwqV7PKOj6nCBa/JMm4MKL+IA -zhpdav8R17gC54X0GWffuihh1CVVioOsUXd4nDv1jn3bB/YNM3bU6+srJKTlFyloWFtrJlgplGck -lihkFivkpKaVKOSnKZRkpCoklOalpKZl5qWmJAD5QPmc/PLUosy8dIWC0pJihcw8hYKcxORUkPLE -PCA3syQzMSezKrVITyG0oLikKDUxV6EoNa20OBWouESPSwEJsOYmliRnTN69Q266wQdGlsl7v7BP -jj3Nwa1ga6eQnJ9XkplXOvlhojBcUta1oqBII7NEUyEzTQGsN7VYEcjXK0vMKU2d7N6qwIWqky0e -ZFT1tHRGmcl7d3JsXrDjNttkgQtCk+ekcU22nKQ4mTdXfrLXZaHJB65xNycd2J50gPGFGQDChmqy -9g3c9JyyRw7xF9txA1uzgsdcmb8YjXicAdYAKf+uBd4FkGg7BHfJgw3fww2RbF1raS6Yz0hi8pwx -MDA2NDQgZGlyX2luZm8ucnMApRvwfYj6krx+JwpLMcatEBpZqFuRozEUykH6w1YGXWjV2bzsNhB4 -oRwMvTKR6FoUx1w6jq3qsy0ZSgnlX8nN5fuK9YiTVgE0KW5vZGVfbW9kdWxlX2Vycm9yLnJzALih -C4FXODaimz81X2miz4v8g2T6k4MBPRRnj57jJ+2pLZMTfzImyzwlfzE1FpPUAT8Ul34OSxmy2qAr -iDlLE0QMklVFM4uTJwKH+llaxfNM0YqIu7Xoxw6tkcNB1pvOO6umdjJ4nKVTTWsTQRjGXoSAIkR6 -UJTXlppdjItYKWVjcqkeGhoLVk+hDJPNu8nQ2ZllZjZtLCUHz4KQX6BHT0J+Qf+Of8Crs5vsNons -Rd/LDjvP87xfz/yIv45/jqrT35v3OgE1OJBqDDIEM2QaPr4/qmkQUkWUs0/Yh85h5y2g1igC9Cpg -I056EAqIWITEjGMkucj0S3VncpArXmbgNBKN0EsEGRoTZwzt+x3L/mCPvp8TGgWeo8kzQhMiaoIh -aKOYGFgiE328IDIkwZAqRyMPvaKSOvQmtUbNXcqdxomM0GEuNFvwdJXQ9TwGVNsKba+n9RXWOykw -paylKDBXxcmztUWE6oAxh7urfUSJAS7PUdlRNqH7ItlvwN6r01VQVuACZcvMCd4ADbECjuflC+Ao -HNcF5Hakl5XptzvVYuC+f2yGqG6Ur5aSLAQDGY9JqGRENGcBOgtZ929kRM9w3hLJfgVUo2NxBTBP -ezddCTN5+dNfm48mKhHGDsyK0T4qYFHMme2/N172WKmx5iwnW5ULz1twHBsmxevUQlQb3z/KAK1S -h03KLVYwFq5a2W1hZGfdQTczbtORnYpisUm9kS1urS7fn7S1Wy/hH2hdTrSXpcS2lqKcmd4W1Afz -D0nhqYuXPDur3P/8eH+7G4QDQo1RTsQUqwMb2BefPratgHJu3z81bIRwcth5A2EignT+esudXu8+ -nH1/uXPrnxVm17tPNv4n/7PZ7b3tjT8e/oAA9wK79BbzcfLk+22WMn26msvKXz1naHicO3+Y7elh -tg2TWURy81MUMnML8otK4nNTSxLj03Pyk5onsmyfyMJoNxcAUd0P5vsBqQOQ7qeWZSf5OkLLhfMH -fRNFUxV4nOvsYZ/Sw94whfEJd0FpkkZyUWJJqqbC1ieMqkcBk0IKk/dt5ISUbi2gYigurWLDEYnn -yTFDTgJ4nLVUXWwUVRTOmZn9gf7sdMtut6W0t8WYXWy2/IPoag2CQkytv8QHGWZ37nQnnZ27zMyy -EtdARSUGIcIg58UHY0zkQQmKyRoxEURjTFFabdJYCfTJmKgR8UGMiXpnt9VCjD45ydzce/7ud75z -zv32WuzSM/FXJvdsZBolus0KRDOcEeLmVZdYaoE6RCVFNTeiDlNSzhu5PFfRuo3GuNZiLskzUyPD -1HVqOmbRurt/oE/QXMlVsyatWTnphYR/ukVs6jBzF1VmY3cpTFeKNhu21YKiM1vJcTyKj0fx7/K6 -JjowHBbb8Y/3YTGOr4WA98LETd7xi/2rDJ30cLdiPp1jhaJhUm0uUDJ1Z1o1TVZ2bgw3ei6OZwYD -nV5s+u5AQXVzeXxShu54sZQ1jZxiM+b2EadIc4ZuUBubZYjjBVsM4WYZEjGSuYM8xAo0qfPbFJ+l -VN9CnAgJrf33MTZSKm7YcK+hadQiFTJUz29O/og1YrGy5UcY5EQhWQ+L356UQ0cmm73Xp6K91HLt -3UqRGZZbh1tm9ohhDXPYNs25zN7tnZ9a1nSdDq/8LsS81ETEZyiGJ16VGr3MxXbvtYvrvfj0oVv/ -O2byn/M+NTV9dbX3+HQv/jwixCOGo5hUdxVWch1Do6jeA+0ra0SnucrhhCiqpSUrs+xXyOwmbVJ1 -F3X+8utZBwlMfsyXTyPQ0nx9WO+usUTMtUvUp+g68vC0BN1hXTUdX4dfRuAx3BEBCWf6xACukGHj -7LElIHkzb0hYkWEQyZAY8Hb8FMXlKTFenZHha6nHT1NhVq0VSIbUm2e+EM8y6EAyAUH8IAab8Ohz -whLvzUsJHP8cZFR+EwKds5Zp1VE0alM9mUqXrDKPpDAbf8gLKZS7hA5kWwONePSyGEVyQJKrNA4n -FtVh/rhHCm31e4cwfd6Mca40PkeMi/zu4tNUG7Y02Zbn19QHq6Yoqw6Za/g+4now2RlSLadMbQdH -D/B+JdshgJ/tF0IJPmsl000XVTfPYRbUIq8R31fwuy3QXUfjG0usZGm4Myksjun+Ns2rqfAhtubM -v4pAVyTb29tH/HMf4U2kobpeTOCAAI1NBaaVTJrijHJ3hH5hCcqHQRZIBid2Skk8GYVFgZoRnq0I -BGVD4ixtk9rqEPZugRAueQmWipucAvYcgZtFUslgqRV68fCY2IZ7j0ErHxihBeVfpDBeOMcrO35t -bc2xWrwFng/i+Cg0pG94Wv79ZUmiKMPt+LQILx97VGqofhSFBHjR8/G/++iLZZzNDytCK868JXVi -0z5+tD0/u3kwOvG9DuCZ7IMmPPQsLMB3VsJBXM4TW2BT1zaoRjLVgVUwJOCLQ0LURxoM1jWoVoVE -3fOMv1xZCS3/TyYPMojh2DewEJ9aCmE82Sa04UCGyziFQcmfOLz/oJTA5QPQjt9/Ag37T60B/gvV -U2vE0dMr1KyjZFWHKiXb5GV2nRyzdGM4PV9eQ+b3h5NM3VY9e1XsDuFlNRDGaV5j3P4rhPtNZg1T -x1VqD29qfqCapO6tlA1Ty6m2lsQHpoRF2K1IjXh5nbgaZ04IARw6Ditw7xopWH1YlBqa8N3NUvP+ -rCxVs3IgaP4J0YtxC/AbdqnSiMW9g8rRy5NVGbwnyITqW1F4nG2PPU7EMBCF+1yCVyZSlG3o0CJt -hZDoKCiTSTLYBse2bCe7ElrlKFyBQ3AwnAiyWolm/jTvmzef8vv96+Z2znY7PFGIsAZu9M4GrnCA -4SNCpMgDmwhq7cSQ7BmdJCM4IEqGIx+hTM8n2NcF1NQ1h6EBmX6pnbeDCnzQuilxlKqTm7wdTa8Z -/cztKB57SAqSQ/ULcV5N6fYDx7yqqqKBCiB0pPWKTp2xyRUm0qoHhaCEWY1G8oJjlfHJ2eRtIo+N -9uLJOfbYI7ftW4mBh5ZnXyJwjJyyWHOB/T3yjwzLHHWeboxcYBkAnuPozYX5nBxeYImxbv8hi7sk -OpcpiBX1DyXfHr3CiCv9ORU/vnmRSPwdso07a66lZ+lwQFUVSpgjUDPDzI54nAHcASP+zg7ODpCk -M/I5EeRZPtHUrmyU82o0vP6YIUfxNDAwMDAgYmFrZQC0qrOC2yGqSQ+r+NK6GJu/wM0UzpHXwxRG -BpJWN9TwdBcTD0cmWssnHoAQapOuAaEUPjPKgZMaRu9BKCXZ2h77qpb1Z42TYwJQFPSjj5FVz2Il -OwYtV0qbRyT1uktkk8cCyBRlErV3Cfn67Ca0uHBkM7xe541P1JPaAxuTvgODFFnN0e+EZCeeGQLN -6DY/tTtJ+xYqk1UEPxSxKc9E8iwUsWt1Yvjxpr4jPPezWJOoBEEUMaHwxzq+0/tA/+QuV/+Xfs/g -8guT/QSWVlCWCFXEr4+33uA4iSqaKSAXTIXNMTAwNjQ0IG5vZGUucnMAOhzlYZu5ipjyGirbdJu5 -2vL7V080MDAwMCBub2RlAE1vgz5T1LEs2cgP9FUdcc6qs0W+k+kFOxT6cefCNu2N4P6i0XD7DBYd -ZzRMH5M4Bi1asi6g+Xq+6mOh9SWRXFKXpv2/3HY0MDAwMCB0ZXN0X3J1bm5lcgD4MxTTzp+CWztr -nC8W1hzFr1LemzQwMDAwIHRpbWVyACmKWXqAYI7F1pUKgh5FYp3+b8jKk78GWRSBWgdPd8bkKWX3 -nYyLS2qlEDu2VZMsByJ19ttI/Aata+fyBrEdTdXobN2PHTafS2Jw23icAWwAk/+0ErQSkMYU1r+k -iPP7tJUaRlIOsVK4JEWpEJaR2iIU2pobT+JhtRdmyjgagyzDxZWzp2OzEAGcARS97kKwbJW6+/Hs -/3jRITLHA1LYuLPAAo4CFLCVzvuoDMfnLVuVp4XR/hF978Eos2IF0gNtkTad80Szv6lzHde5SntC -ShkIZPfTp58VZnicfVRBa9RAGAWxxdaDhxaLFsunhyUL2xTxoilRdrXVSmtLt0Vv09lkshnMzqQz -k25rldWzF+t4FPwFgrIXf0AFb549ean/wKvgTHazu/VgIAn5Zr73vffmkTcfx/58Hvs0m3RoBC0e -EvB92CSSJ3tkzXx63ibZzagg/Rr4t+FwEkau9adORFmIJM9EQFCKVYx4hALeSmlCQhSZpyNTEtCI -ElGB0h5OMlJ2M9YWOEVcOHnhTLmsj46m9I/nl/VcstlZWFiAHdGb7Yre8B2gDDCkgjcFbkExAnBM -cAg8AkVbBDCTbSIktGMiCKiYgKUACT6wJZZXCog2ltDIaKIqkLGQCINuUTPVMbAMWzTZX+HMgmGV -99ueEGKzKMxod9KyrYLVbinaHWSfBJnCDTOZSqBKAm+zPjd3MmLwf9POWte0/xbO9bWH+vqVqfH1 -VFHONNqf0cfH88GdxfwoEqIGinwwrzR2B1D9BRdLJEjklPs9RVlwrhBnKFeEWjiIKSODXTTSE19v -zA6Oz1UcZSq66ZRdmdDAbNTVh1PBI2NOr+HFkJA1w4eC/rBzhHPWMCDIUgB/EKpGxpBUmIU4MbAo -l+N5+sOvmU6tWl9CG9u11ZW7aKO69QA9XjGPe0vL1e3VLVTfXl5eeXIqnFZ140AROTp2xHRDsDDi -n6PocXNGKFZg0S4WwguL6rxFnFrG6kpQ1vS8IGedSy2NYOrvhxe7L5PanP72arp74fWX8e75d/c3 -mjbmRjEIc8/PY652TEjCXs3wVkUx5iZweJj54rztZmxyzvho5PKg2nDLmKapcV+vnVzSu7emdfJz -Qj87ubZ0yqZSCa4GAiti6VPPM2QGWcy/5DCagfkrOOVK3t99f/J79y8zt3kZ+QMYyS3dqQekIXle -F1M1aC4oSunx8nicATkAxv/SBdIFsEgBFI4Ml/kPvx/IS0/pNK9YMDCFeqmjk1wB8RRJ+hxYeote -+it8gi9ql+D8YgFVSpNhAnHFOBir+R/t8gbvixnayDytuOiupjlDJEGV3HicfZDBSxtBFMaZtUVM -JBg3UbzoAxETKgl6CYyNl1zaS8BLe1wms09dM5lZZkdDziK9FKQsdI/xTxBSSCn0VHrKsYjH3nqI -0B4EobcOm+jBQw+P95j3vd97811/K4y/F66+zhYlM8EpgggigxI1oDS6N/gxe0nyDJ4044u5ZQrm -CCFSvI0mU61WgTMplQHGOYY2PYq3wLA2RvZF4wEoCUF8M/cpq7q2R6GBQiTkPSkMzjO7ZKPVg8C3 -qwPTs/KOOmUClAaDuhNIW3OhIhz8yr51FlNAJUJTOtqpsMgLTbLtPncH9dxv56VAA6kA6sA1M0jp -5NSH7LWU36O0mX6swYRoMd5+7VP6aifZf0Hc9QleYygYxxJX2iJCoymVJ0J4nRNTKscLjaXkS9+Z -j2v55mp6LnoTqzw+RZZSTnnr45isJD9vSbZc35u6Vvn/RCb+cOHGf/P3+c3oiQHxn8XiWc0d1lxC -Pyf9A5IrTCFdHRj0QpR+IA8Tpp215M6fWX53PCI2HBszw+PRs/abf3UjuiHmBoImeJx7dVTk2WGR -DWeNtJJK8+KT84tSrawycwty4vPy40vzMvMySxQ1gkuKUhNzA4oy84sySyo1rTd/Mk5hZIcqb441 -bY81ZQRiJiBm3h5rymJ7efoiSVah6fwLmbi3H+Bg1ZICAFxUJfHwEY2DR+hiw3wjQHKoMH5LiHcL -wBhYeJzbKfJdbMMd5vri1BLnjMS8vNScoNQ0K4VqhcSi9GIQnZqXmJSTmmKlkKSXlJ+fo5eTn1+c -qlCro1BUWlzil5ibaqWgBNQcnwzRHV+Umqako1BQlFmWWJIaXJmblJ8DUYEwXgmonUsBCJLzgSLJ -JUDTNz9jDmZL4EqtKMgvKgGJF5coAPUEl6Rk5jvl5CdnZ+alK9gC3ZCWp1EN1AtzXRrYYYl5lToK -SVBlUAGIHUWpJaVFecVQsckLONUYFSZ2a0qCXFwMMjwepk1Jh6tW05oLAKL1XgvwAmhUtY5I5acj -FuRPKCPr0XZjIKcYeJz7yfmTc4M8i4jCraCY3+KKdxn3828o1rLtevO06tdkY5ZjAN9uDlz+F1IG -Z99Bq7e+/OzGLeCWBreMYhZ3eJxbIr1EeoKIiPLupjRRnqu+835cef22LuPEs8iAJRs1lBhtXpw+ -cCLUT3i9+sl/HS937t6XoPwixsQACBSSM1KTs+OT83NzE/NSGE7Vu22Zlly6ctHfjWE+YedW/Xxz -8cjkNkYPu3rpnWL+izNeH3r7a++bbbqCDhxHGaEG5OcWZOakwo1gYla+bPpBTLPuc3jTZ+G8ZVtO -fN8xmYdJSsRiez3z9t7AY7yFyzdevMTou6JY1WKzFdNKZpE9CuzB4Rr/1yzSLDtmqGxRLbUp/dvm -76zHWezPLZ56WrYmQEj6jk7UD27TvRLJzkaGBgZmJiYKRaV58VC7U/SKihne71iR/7/3+Q6elrmH -FsRe2JtwtW7a5L9cS+O6XpbVsm92uRiQv7Qi8rjAsbfH7i6EOL0ktbiEwSNPVc1PZ2mSfsqlm9ci -LxizrHd6ALUCJA/zF8iKPMelpyy3TWpbH2q2quRLyQktiV/TN/EsYQQAR/WqCvSzAs6yIogYVjq1 -L/TnITcsKHvcBNL2eJyNWFuMU8cZ1nhhs5hw6+7CZindsSH4GOwDqQhKze4KKAmIlkK4JJEwMsf2 -eH3Y4zPOmTFmm91689LLA2rhPJyqqZSgqlUTSgssyqat1KaV+lK1SagUqQ+N2uShUqVGDX3KQ6X2 -/2eO7bO3Cj8s9sx//f7r8I9f9L33oO+21bM6TuHjWz1PJTL0LBPyafey7XG3xlypD446vGg5IhOf -8T+JPTY313M/1tqzZw99vspklXn0YrHhUgmEF6m0JpmgcEotb6KBImiFe9SidUtWTXrSZVQ0StXu -bU0x4K2gvEItxzHjFZd6zCqLgiUKeFPglQKKF0abLeev+f3mFqhV9yKXs4G4KLjTkKxDlFaO4Wd6 -uqPQFNLypCg0bVk1iklzT/KhyBbTGaXKRCthNG23zJsiTXfupMZKvPl8Mv1/ZSNBOh2ficcR1Q6a -NJut2A4T2YrHa3TUsYUcv2jSpy8zb4o6ttti1BYhtBnqMjiHX8AimWfSQxQZlERURF0eoow8LmWe -x71c94oLW9rchTBHw+k1XEFR8JSs2u6ECo1VrzO3DAFpCVlQBhbQQAPV5ejO842nLmSi8uCs1pD0 -OVYaPcyvjOL9+HiavqTgdJikJe5KgEXQMcgGCcmBcRVTENVnQHouh7mgVXQvyrlcyWyWjXRGudkW -h5+Tk0ZbYpqOjXfE+7/6eEdw8odkPF2xQG6ZSq7SbCHM+JWOFsdfmhn1xoM7fyZbAr41Fu8BLcHB -98lADwAXvLw1tiN4O0E2Be+Nk97WzIGOL0UG6c7AkwgApsNcI61psBggdBA5lwrpAabgjag7tjR2 -tg3N0GIy7yajPqFojB4I7nDBvwi6yx5FBpqXeS+ZPhBc/xHZ1YeibLfBghv7yMDxqC31hqgadmWl -AsNfUcX4UaVru5Ibaf9Z93MXzquyMYFXOHaJYQyQ5IIJWkuWNNIhcUfITOj8jPoLypeAQ8fGQuiC -+78jRzMrBUQFW2DCqgJRZP6ddx/rVUkQDxLXSL9/6w/r/Lc/7fO/Ed849+3eLw/vN5G/ndQopcRr -dWSltoRaKOs0x6YVXpThS9l/sC3l758a8Wniqp+YHfG/3trkn5pN7FdmlW0xCSyWpE1LuCnZYTXp -WRBUbNhOOeyGDncnmOcfojvnbiXObd+g7rJoS7YOjWDub0f+ud7/y+kt/o7ZQT9x7sm5N878YNP6 -hVT+/RfAELZq7gRbu3U4A+F7sWF7gL2y32VN+jz3Jpk3V5797l7/1z/ra2UvNVxbZkXDBhl09MzZ -0+OI/jHehIT3WJ170CbGFBFteoqozETJs4tgvcNLk1C4KRfUs3KKGmVWsRoO1NmEfRkomYVlilQA -ITTupkvz+VGVQqgvnx/fm6GpimPJFK17rGJfwamAIXOtGnxVbQcB1zLw0L82b8z95/aNmP/R3S3+ -qZur/Lfm8sdoPlnj5QbEKp/M0UnG6optQk0kyouXWEmH0OFQycosTIqUoCEbtSoeE1X/zXuPD5Sq -FkRCYOFrASJtqrDk7r0Vi3dzzv9kYLB1GltDJ8vC3qlCr3osy1AOZVxnup6hBJmwy2r2ccHgrp1P -NWUdkJj0GVX8mMA6JTB/oJ8uoIIWOAWytF3/flPG/ON02yNMj2T/4+Gh1pGTJ1Qb6VYABoqXWTdM -GawQoIPKTF0SZV5LUWBIVaF1T2XxJ46H1MHLtkov1p33mu7gpSXHaCKOa9vtD/2nHMaCp1y2/U1H -jUdCSP0P7w61TijwdX2kUEkKLGFX6hCtlAoXgsPV8hCyoQam8AVvoFajOdcQoCSf1Obmk9g7ld9a -vl3DXNahCet5Xz4JInIhOXMEa4IqCFJKy0hpkUCtZpu6VIj7HwUj9hd1JauKhhjjZEKhVc4nI5kL -+QGpF9LCvD3bCUcGUx7zUfNhaAqdbITh4LAKmAkpgB1ms8VltsZq3JvKOnYNTFKl6r883d+CQoXS -h5WIOTmlU9Npt/E39C2VL9hnMpSZEyZ98uhhExYzIChzphpTBUEROls9PuFZNVwBOp0OrgSiYDkm -PaIRVxUiqy2mZqcFWelBQSnrMpggi02xsTAYQ73MVR3CzUCWdItHLzxggjNFFdgowlPri8exx4PQ -JkrKZiVogfFGhTW1RkVIAuxz+Z/v+JL/2wfDwa11ZG3wQQ9Z28KRKKfq4MEYLckr5goDtzt0BWYv -LmHC5HWkFLB8RWd/cvHg62w6SxedzKDeahZp9n/z6VDrsOoE4WKmM6y770Y2NkwOjIrC0MF5DLnS -bANTt4QA57DKdPBRLRzozG/yhqPmFsYPJioS6M2PWk2U4HKpQTYXLBGGgiwTCksvg51aRgowxhVl -BEXQktBswbNVMnQKVl6UeAbq1tCqUZziMqHKPNgDxKRdN55ImxVYk41pW07TxAp7hy3TwWsfkCG1 -oLU6416hpYVrvBbsanq8uoih7r6QL7rLhnAwzNYKd8oAC69ooHHW6IGHW4G5RylKZqKBD/71HbJa -rX29Wndw6H3Sv+Bgdmvs8e4GGNSnSXz+m6vI7m8FI+fAi3evkr7Mggm8ZJ1TuOk7wC14sZ9s++xx -ZDijznI5dLGA1hr4Jx2880dy+vPd0b1wvuveKroTG/u4mr/BOz8hO5Ttq1BOxPJtN6CWfunDtxPX -SXxYySuE8sai9gWHGBkMZvtivfP3rpLK8LqO/ZJdkcGmJBk4v7iNLe+vulJZ51kSVvuSY+dUm87l -NDNmxCVezOWg8QktX3u+L5td0inbTltU2F/FAplk2P/Q9317v7D/xOGI78rSZXwfAamFULeWOhY1 -9UDw1++RkfndPyZrSfC1V8mjKr6nIrNxeUcjBOjuomf18sEFFyNskZDibF9pkj9EeFtRqWNL7Ysu -5/BafE6PSAG11p7NqgyLnEOTcnUdHsbO4zStKdwaobzDR3/IYHbeQ3jQAyfB/WOkPx5e4zPl9itk -sIXQtFl0YRnT6AX0CfUSZCJh7MIDfOEk6TT8lV6D6W8V4GLwcF4O/vZ6F0If/gfGYtiJxn1719EO -5moDQaTDheEhYN7SFjK20Ibgw42xbcHaodhIcPA62RCMDsU29ABFcOMgGZzf9TqZJ3E03BYc6jW4 -MUoGgj+9QXZt1AfMtOGhhQKDz9wkqVZ42tko2o/m8DyCxlewMU5rY9rwaaOS6mGsAOw2vpAulKtJ -Ei4vhIJDwnVtSrW9Bfe3Q2OEnm0GG+6Sdbuz2bYZbSTzoUrYwwDOyDbfRXS1FrWwpcZmDgRPvE42 -Bxu/T1bPj98kf1/9AiTnochOBEMQnzztPJxgEnNWMJxvgof/7xTS2N19CPZFWEOgkUIe8xo0DjO4 -9lMyvL7zm06P0UTw31dAOejtDe74ZOv8xTtkjfM/xWSSdvcBfFr/Ec0Sp4JxhDceG/vTh8IRVXt4 -nJt2kmnKSaYNbnMnu89VZinOz03dnD9XnR0Ae9AJk/cLzy6bdw8dY968EFX0Z6kuYFX9FKR4nOs4 -znb8JNuGKbzuifklurmpuflFlbo5mbmZJQk6Col5KQrlGYklCsUlQGaxQmaeQlp+kUJmiR6XAhAo -RxcklmQo2Coo+YL1+ad55SdNjuWV5IWYE5+fFp+Vn7S5lteRmbUgsaikeDKjoKwKmGUNNgHVlKDU -4tSissSSzPw8kMLJ65PZWMG8zasEEh5O9nslMDnxi+jmbx8nbQQAx1VBO/UdJjrHaFSww6Dn1Tmc -aerrUqCtPsZ4nIWQu0vDUBTGsSpq6wPEtyKHilofDRSHQt3soILt5guE9DbekkBNSnLTFqUodBRE -OIKDkwhuglhf+B+4Krg4OXWzYlOTQdFURQQHz3TO953vB+cUTl3X567jjfx6xOsVEro3oSqxCBB5 -GWxBpCTxpXAQmZNUppN4iAiiJNNAQJF5mpZYBFKqxKgGTKRQ3pXiVOOcCT3qEVTC6BDEZNAYURn/ -7aqaJ7kSgIEVncEPdPfdV1GNXKEbd54vseWgA8ViF86bgIfFZqwq9eKR2YB3RQ5rjX70GX24YAxi -1hjBE3u+N9pw0apHf2kaX/fqcbvktvsevCn5UbI6ceDFh5uPdSi+nNrsdvSbPTZ7DLfMJZvXhG9m -IzZZ3chZg58cyZqpzDgzudX8bc2sLmskRoGmGVVlcAfdsOaEX/Xp2kdO6DLPh5VlOhfieY2yME0F -FZnZOW2KJOlk0JMkcZ0GIKoo8d39GUcrhgqF4TLi/yhTdZrzPQmOzr+/HAWBpYfGs1fWxZVVcfbw -AbSPw6H7AWGV7SDGL+lSGQlH/A8QDLnodTH/eJz7zvidccJjkTv8+SebFMTcbDYenX+lRVjBbdt3 -IwCzIQya/AHbnHDhgWBaefOfLPzwqcPYrOQOB3icu8N0h2mDB6NIcOlE+b7smdxmCg63NK/Yb3ok -lB4HAJogCvb4C7yOo56O1vAUFiAhu97RO4CteCEseJzr6mB+08a84W80d1p+kUJaTmK6QmbeZIEY -BcbiyYzh4pvdYxp0pRWQQE5qiUJmcX5OYklmfp6C7eQL3QaT87r5JN0yc1I9YeJWVsHliQXuOflJ -iTmTY3rVQCrU0VR4p6ZCVXAhm1+7+WjnVEZeEBNuzWSf7g5GxcnVC6Umv+sW2tzU22EGAMHsQBf3 -swF/b4ROyGbGOyzKcFicwNEDWz+OInicrVZdbFRFFM69swHaQlta2kLlZ6pl2610K0QMbFugBCWC -GC0EjaFs796dbi/cvbPMzO0PP2n9eTEahawwkaQICdSARkQN+2DU6pM+gY8aJUEefDD8mGBCIlHP -zG63u22JifE+7O69d8433/nOd87sGzfKL/9RPvqa8Zn587AsfcIIbk75sWabWYKEMPH8JH7KccnT -nLqWcKiHD5ViuLYTktrq0pjlrtL3Owet/P2RUhm1jcWZu8OmvWKdz0mUD3NBklHbimANHInYrhOJ -dLGEnySe4JFI0nK8aNFSeeZtc1HmhXfNe2jTIGX7CYumGHGpFedh26UeifYxmmwODiTDueehdk1F -XfAwF0MGLDcqD3xh1owUhdliqGjJJPasILmXUUYO+A4DksJiAnfiApBZlxRhjTxgpU1971/A9JIH -ZpekcVIcn39cGDMS/l/S+M/05eiYuSITGzOPf5nu5QH5SQ8K6R+V75mBmrzBIpEpL8nV943lsuKG -idNXB+fNWDhlQrVwvSz/zaxTCzN1e5A05MQ6FJK9nxpzMz9E0TtGfq/K6RDywAlUl0la6ELVUpWl -k39f7P3MQoFOBapdIjAjKcqEylWwCG6RVx436xsnH07pxW2aIgnfYvFIJE76CGuQZ1aa9enTqwMj -tuW6hLXSQY/E83iY+sJ1BgjHop9g5nvY8uKYDBA2nAdVV1sbTkEwhBFLYNslluensN4Jx0D9wTDe -ReAG0DFhjDKOLQaAxKYsDvv1OQHGRTh96Zsl8tR2s2SZ73Grj+BDOJj0BW4pzA8fkR9sN5vl6Dxz -vlx5AW2SPc+Yi9KVvwYyF4fQvTkjA8mcDCp0t8OEb7k7LLvf8ZQvB5Lt06l3ASmLucPAR/gMcnQ5 -BUqe5ToHc6n3gfDtmPu2TTjv813seEAnSeIOzI9ivFgb4IBUHFNPY4IanCgUh+HNvreLcLFKbQUz -xvESGt72GYPJgxPaPuEiQFXfSTJRxQN3yq6jZp385XOzumpmSdPXR+u2cDAtJFsUF04Q0RzCweCU -o3BnZ7GnCu2evn69JqCAZMNxVC9vfWguWEOp0BawbAG20LJAKmpcYuUTSIZRP9EP3w7P1l92BY3a -raDykxBmUzCZrTZqI0PE9jWHGOmjYAZlwJhl7+fwywPQVqIk1vJwu5/EfbCnBpPPHTXmN2UZhCDJ -vFeaW2K+FxWgb5QBUeWCkJw4imrky9+BQ6AVc7yzSoRjJAFjXuUAQVl3yoZStFi16qL0xP1KuXGO -MaeDeHFVp5Ql7H6c9LkAxhgoJ6gQJE/fETxXPpBXlRdGTTwsu86b9TK1D62XHa8aJbLidWDz1T60 -Jf3mi2XF4s5vybZgE8e7d+RE5VlVQSQt6LadSmBiZUXdAKKqgaElKiyIKlC+g6cqQjAZcrhQucDR -w+Wlb83aNYAxJTzY3vdsC5YLLKb1q2pj5VYq3zoHEuGTaF564qVA/UCysATZds12oPz9mrlYrvjR -mCs3nDXL5M0e6NW1e9Faeedho0re+gv699pHqGIEMusNNsFsF44NAoterA5F3LsNKhmJQCt5hDWH -eov7Nte7zBpsVUOBcNtKEZWB7ifIz4eixCn0rwee7acumBbHKCQzaO/HLoUP6mnExmmQjlDV1Tgu -pSkIig+HZSVG9Q2zOSwMqgrtouZQuzxWatQW1PXZMVTy2OR7XZhJWCgzkAC3dNuTM4JjOKpsEteV -6QAmcUZTqckZoTLIHWXZQa4mE4XJkpspynTQ/8RTCLpPTo+hsqpZWuLuXtSU/p5X6yNI12djFIXr -Zi0iTNuvz0K9U21mrbz4KCqXJ/82Kk6Mo4U6GopY1pH3msNx0TGSNWKBkR8wHh6CmVTQxYXTPiSX -jaPl1fjw4RkvjFfQcp3Gledr5ehNcNO5cbRK07p6x2yQmzaZlfLOOFqQ2TWKgo80KhHVKaVLkbd3 -9pCaNIq8fQzVaohwDyo5sQS1ytvjkHRrPdIqLciUnkU/GZffR3PNquLpymGmSHoeLe0OzThhujVx -+P864DDqqT+Zs/SXHiPTe1mZi4dlQyOqlr0HUak8fB7tydAL6G0k/+w2yjP+x6jW+AeTw+2r8Avg -D/c9a10s5jV8FMGt6bbzr8HXFnicm7ie9dpG1g3ftk/2C2eb/O+Q3OSV53n4QhLTrazcgsMTS5Iz -UosmJ3rJepdkZBYrlCSmKwCpotT0zOKS1KLUFIXyzJIMhUSFjNTEAt3iksSknFQFuD6F/DyFzJJi -hfzyvMy8dAWvYIWSjKLUxJTJgr5izApqWpPtD0tMlhSRY00tstPQnFz4V5hDLz8vPi0zJ3XyxI0i -7AqJxQqlxkbTHzoyik6+sIdr046J8wF77kHC/wGYSN6M8fiB96jPkIZ0GT+yJisNUHicW8WyimVC -kshhO27uyvV30teWcO44taY2t9rmcM7Gsi2MANEoDen/AbeXnW+Vb3G0ZDlEau7qF/hS62+LeJwB -HwDg/9IE0gSQORTTEIev5zL4CbVlzvaWBv+v+xv84rFNBQL3Jw/e9gJF27/WJWCwyTKaoBFRQbaX -Ov+2Hnic61zG2rWMdUK6WHlqUoFCcn5KanKxjkJCUmlefEFeekJjzdYaxt4gABwVDrn5jQTtKrKP -vFfjyk0VebWA1FtndCaraHic7Vl5bBzXecfM46UlJVKixEvXIyVTu9LukpRkiRqK1GUllqqD1hHZ -lY3Z4e4sOeLszGhmlodFmZKP1EbjSM6g/gBHtexUqR0ktmWw6BappVhBW7hOUShtYKNFYMt2g9Zq -4coFXCeB0fR7b2aXuxTpqMi/JSCK847vfefv+7733v281nur7vLSCm9jxemyXaquT71ScaFqck8m -k3WVAV2lKTWtZHWX2qbpOjRt2tQd0hz6tf091FZPZlUHR23VVTQDJ1TNpuaoQZ0hxVZTOJ5WbdVI -qvEQxR8rOxBO2oqrRvJU5aQiJ00jrQ1KdK/Djt960HI1c5WxdSBryEOua0mS4+j5RdJhTrjftfv6 -prbVfm/NFk64+KedbcyOOpKUdWT2t2Mmh1WXUXDVMVc2GX3Dkb03k01rs44qO+OOq2aQE4mOZOKu -7sglo8EGOAukCV77jtgKiaxYDi98JiyC90+K5eWqbUdDcP0doeHZp0i1t+2hiim6+XsLV80poiQZ -6mj4gGmoU1fvbW8Ou3FbdUx9RLXjI4qupVBBsqUkh5VBNdhJe6lrZ71nlEb4z4Q4f+pT5co2iFh4 -2q0rC7+KandU6iQVXbFpWlP1lENRS1SbtmHW1oxBqptKCv/3jaGrLjegZqOwrmK73k9frm+wbJWt -kktmejzhuZWTPcy+VNdGVDQ+s7Lje8L0McFmmjSzhnv7KaqRQkFKKMcdxc2iRyBXspJKhbOGo6RV -eoq2rx3J0NPxInZCfBcnPfXSi7XiJCOtOXlOkbJG+2aQp+3tOLq1mIOegsN0dNBdpoFad6lCE2lN -V6UEPXpoH4o4rFLFoAktY5m2G44kqGOpSQ1Va0vouUkzhbJOqnZSNdyYioq3VKeYrIKCDquqRY9p -RsocdWjKZlpDhl3VdmjYP6yjo2OX1DGWQCFoYpf04FgiSg3TpQl/OBIvkGSS+sem0DHcIS5Dw21T -WTfd3eP97Z+07tbSeVvIjq5h+HFtOPKo5g6FB9qC49si9FRJ+BSfQXvh5GPCkuasjf7KBuS0bWZk -tlXGsXA7KIbQmiw5JhLpmZUeYwztU0w+7pp8OPwlW+KcaNi7vGnlUMk5hR2ne0LFet99eD9lDDIr -FkAJIcoe5yZJ28pgBk1GtRT+1txxitN7D+83U1ld3YfUMQC9/kt3NbLgUXTHpEFcppjn26p369LK -eGuRy6F3/RY1e+u+u3F5qY6mmaeq7qhT1d/tERq4L3Nvk4c1HiZoQg2e88gyz3yppvKQfyKcf1do -x4E6j/73Mrh6QWyZSvxprVBdtNXrSjXAjbBYOXXhJSrB+U8QJJauqz7qB2xiJINexpSBTFkop6yl -GD6YqsN9D/Wi2qiTeIlRGHfmgKPaIxiASnIo2NUbgk9/ITR5r/yyciFqJYPalt0hW0UEaG+Hn46J -K5YUnxJmMR1Bm3n0w2XeTz7Y38Roo5y3kYaTT5Om9WyPjDz30gIqFEO7bpqWHKwJ848IKA3iYjjz -kVgG10+ScnjtD8XFtabhnx4shfsyQrP3w01LpmIfPrD4//Uzp3682IcHvEe+XTW1//O343D/HnH+ -Ahmzv2xgfMpO0rTgmUZMhhtWCy25N9qFdFV5lCkFHtkmtEB/p1CZO9Ah3Kqc7FdszE4KPWbaw6q9 -BnWsjqnJHfbgSKKHJS2DJavBEZpC/066+jh1NCwYaAJX7EFlb12DQeVqyb4EHTWzegqVrQzzTHT0 -yFdi3ZhrLE114iFEU7qKHkY9uOP8YzdqiyaOwfubhfWwqVtYDce7hTZ4rFuIbWeKVY0RzTYNBggy -MpCUaNbRHla5EAgMGPCai0DEmGXzIxIdME09GorQWJ/3wa+WPugLtDsQJoBSLB0oL3EkKalrkoQ7 -s+wItAmaWleSmNo1hED215CpI+T4+Kca2Qztx/zE8vSpEGw7JTZs3cO8DUuCaMHbDigZdfrrHs32 -P04Xci2mYmriv17G4mQpi5IUlCR50M1vMEyWfE3uS2kEPvW26XRak5PJ2aetgOvePP+SxGobXHQ8 -WGUxF5C1QBpcOIHabD+e7X5ogjpuCis815Yknl94ThiJxM3hcCSOcYgBoxrhCQcXxjmZsD8Xyd23 -RVhFJjOKi2ZOmjYqPKNmCloOtxexFi3lbGbaK5mkvX301OnZ5/cUJOgLSMC/rxZqoqjweNLKypZt -povFLJU7PDDuqo53Uqt/9qZQBvveExfBb/5MXDB/+ny0LnywWmjYXELRwGGkdtjMqOE5nMinHbmd -eE2BODoLp728hDZGXZ40JwEWFVtKSITg+X1CaBIjKh+3lJ3J8JBapqOx4hidQsIQH2CJ0zWHVYPV -NCxGUeysSs00TqZ1ZdAvGLlabA6qxhr0IQQUvTiNhxMxm8Y7grQZP+EgJEuJWAxr4RQ/zqFYHkUp -JmhnWLOohiWmwjI0kseyLXBHdjyDlzgMbxU2w+UeYRn85VZhoLbY27Gqhk29Qk9tsY8Hg209GMwx -vw+IJZW2GV7D1FjSKOT1iNvVCGzuFVbH/28EvGX3N8GOXqFxLZonxswz25a86YoY7cyvj2VSX7ZF -zqSKdk0WduU9dObeWSI7HwI9M8oYlqdYqHMNjERwC3cnrIhszcLD1bQ2hiURGrFw6M6AVO9tdegd -xtMI13LrtBwsUO5ABhZmvzv/7DDO+o65eb+TyB2JzBQDY/IOpMB4/t2FwKPy6t87hwxFCDESR92b -4eIyf/rg1umcCf+zRWiIsd7LSKljrCubmWxLhMOFYbjYKzTA673Cca//QJl3cLwcFvYJzdvZfIRO -TMyVVHldNSajKmXHYuplOVxmWBPg2cqdpJmgQLCtT9jAUOwgdnw2dgCYzrHLyRoFVFF0fVzisIGd -tI5osuPAPRzFMpQV9HyGFWuGi0UMBzbHLwOZunCHOTqNK1xdrQWkCRRmriusLIBNYaU/kl+JDLdu -F7r+4NU+IfdqnzgWAutxsQou9JPbyrAP5pEl0P+EWA9PRkkdfPG2WAe31og1cHmPuALe3CA2edf3 -l+V69oqONEsJR/3FL+wW5+U6nhB/8LK3vbKhJaW4CuvzZJ33RWG/Z1PH3EjuZox8ITazRpm3Vh2F -tsrJogxj8OJmssXToAY2dJHjbdx7sY/iFSzvIxHttYzGOmG/pMp9o4vsI5Otc60qCgW/mGDNKS91 -TzhJlvD9uxP/K8ObOXlYHeddGOpR5lyG/eZr2nH9trCXtvOJ4xY8upEsggfuJjVl7IScdTf5FbkD -7mHhf4hLYGIL+dGm6JxLWVVfWjNxIfwS4un1JA4DElkFb64nDa1s7Cvo2f24BP3b0FwuCccS7uKg -SGR1TZQOtDEjoY3aWIcMhyWyYbobPp37OlJsqCu1txrO/X0/aSPery9Vg/EGqYTPD5N0JduAEQza -XnEpGH8sVsK2K6S8uSg+0fC0F5Xehtm4LQQvElLfxWRweO2GeOQElwTslg37HMc/07eGg0wwqIPX -r2L7sXYnWeAZT1TAwUNkNXzypFBZHRjNHbfU3LEj5L2WFb9F5x0m+ZsFjLVpc8NFgyzPfWaSqdA9 -Q6Y5LDtm1kY8YAWlxL3FLxKP4vdOhgyFxmLaMnwfApWbVdCu/yasyF16mHxNXPZlXpC7NUG+qNzD -AFC34zxMEJPy4ROOMO3xIlV1WsP5FcyWWMiiVqOBTukE+8N12rz7/qseLv+LUAV1e0jZmrx30wEs -hlDNWF75RVThHg5rLdcBpVtsgtglUgO/HsSOtuyzRqA/E+aBWYbe+cbTpBWse8Xly+PcLPnLRe4S -MsKhaTPW4PpXSSP0/hFZXLbWVl24sUlshLZHSfMGXBIuBNwhn6X9quMgkaBuLzK3TxDOGtgH3giL -Fc1R2s6Hon73wERu47/gbAK5vv9jcZFHv18J1x9HIDv4GKmCREaogFctoaLCDxj45HHy196DF3yl -rAzwefoKslQZntW7eDLghZnUkZWky1ZMd8qFOAmH16JQMjbe8ZIdgd79+0baRztZDppjLb/cKSz0 -L3j2FAVP6xz7WPHqt2++C6IPzcI1xAbJxruG8IgB3RwIFdHF0EYH9wGaBw9ce440wMNnyPK1pQcN -sc7ZL5ySquUW/JABOhweJJFFzH5Sm8970NpM/ANphmFDqKkdMNF8o35vxvyk6xVx8W5mmeDsIaSM -ysUpfyCeUazwhD5BdXbNp1gahoHi0Gx3JJ41Rm3FktHh1t+9MdLjfXppMWWs52n4/VwRILBmuPXr -YlNo1wmH9V1dUf69snF9tKSIkNlkJ04Km8R6b+2Gmo0MYvO+4Q7ZZnbQz+HOuJHET8PMOlwAHvY0 -OYSwFYftj2AZ8ksTg+bvTpJ5K5KWJUk70fNlO2tMXxTey9QaDsH1sNgAnbfEBVCdJdX1CENFArYz -FXs7DtRDf7VYUcYkhNbjmKZrs6SyKi+0PxR7HCP05+8IIbi5VQh1F3W+vNCYmFEOoqfwcQY1Wayx -0pqBZRcGHX2eNHjXk2WVB4f5AwOce1dYU3rjUw5PniG1d8/wdnSv4KLdYRcEg+hqih71T4lwe7JC -BZ55GwP2rb2kZqtvKH/5DO7wbF7VhH0IjgZuEmUOi9siEU+YaoTru0gZfKNZnCd0QVc/kl36KNkH -nS1kfjnfB58OC0uhc4VYs3Qa5WeqNwLn6knLt9QqoMvJgoYAmlKH+cFHFCyTjykOLJyPeY0/3fS3 -I7DykqgYcFrg1l8IZatmpg10R/+Ll718CIQOTGGd/yhU38vLR+5PfA11XBMLIdW/PGS+h7VH4Hul -PufaiuFY7JqaYfoonP1noWFJmD9PYUkb5ZtlXmqB/ACWZ7//DrqkdZpUrbXYNUlKdZXkkKxradXV -UMszuea35nDxJ+LKpei3s25hMfzMPiR92cYe/5tUrC/nVKDuzwkOfiw0ep1jZdCxl2yEG4ZQ9exN -dKJH/wmDgn0VPYKdo+Iiwqidvyk01pSkz9duIvyjjWtgxSSpINiMQCJCWsq5L8DZS6j586uRxLVJ -hKzF3yT1sP1fhUXVvltxR2EPdLSLhXUxHPRSPwyP4Ick7YJriA2t67981W7uAo2Vsn+5A0IXhtyN -dqEG3v9YXDA/iJUIn4WLb4tLBPNbU9wh6TKW+vxoiLvKcD5b8t8RuPZz1Endb1CMktzFr0wqvDM/ -qoQr50go98MnyAnCeo8dzA9o0sxYiJ7YcmDC0sfpkOJflrCnC/8yYPq9yX8SYrOqwV9GAjEpC4aZ -XdScJTRbKFCID5IO+L2nyAve8hOVmOIHNTzM9sEs4mMhh0Gq6AwRxil6KrIY8xRjcSOjP0t6yr33 -FNlfzjENwlfJAuh7D12EmTYXPUeuL1o5a/AW5Ivkyr9D9IXw/WeF+WK2G978iGzJXZoiP6uqK7Fn -L+2C1iuksQ3TgJ8zC43njHXr+bqFu51M6TqoGyTLofoHpDp38Q0yUX78SCEOFZp/d01xLcR4RjDz -jSK/vhrIarrL37iLMglr74Pw5yGPhuRGhGsZ0gbmR6Rq3aGs47bRtEFl/hhdCH65SJcB6sLZo9gE -3BgibQECvt6BfooaqVjpI6iEKdTPekUys0G2aF3TqXwV4a/mSutk+fP1ayQMPejN8Hwrqa6SAp7h -fCuLwhayeo2LUElnVngzYDQTDXmJhyPw0C/IIu/Mj2tqpiuAILj7/K/pJ64ii/vva5K01ymazlcH -fv3jnXp6qYhZte7bpAlqVISEt14m9S3tAQjj4iAG/Je0cASaXyV3QfQqCVVjveprJtKTq/8x+ast -/wsInBPo+AcOcy3pMolqHYyM5SSHSkXVDzxQO3icFc2xDcIwFEXRJhUVG/BKG4lEYqHkx36AgTiR -vxOJFbJDBqBDYkFMc7uj+7bb8WOqR9PAjZ5XRpiulEkyfXvXc5QcFtZJOwvxPlGVinwLiv6FkBWX -8ORJMwdEGVjvprk37u8tZiWmNLqCIIpYFu33UK37HyBvKpjyDEKkWQ9wDX/og6E6q3jJM9bxjG9y -eJx7LPJYZEMCs9XTCVY5G6eFTryYx9URfGO97oHrbyIMDQzMTEwU8vJTUuPTivWKihmuHuWoto9j -fZhac2tq/VeHmQ3PGEsmn2UW37yR+TqTyMNI00fPZ2rxs58o6Ghf75O37tO2XZPnsM2ynzV1w+wM -dfN7WlfX8WoHsmnv7TPdg2x4QVF+cmox2IbtZXyr+38eneB+kPdCieMeK48bwl2bS9mtmUR4hB7M -1p8W1fDsStGra8f71l4/zn9z8hHO+QDl2Vee/QIc5G1d4ZRj8wBnlmkoG7//gxKjCHicu7ta+vdq -6YYWxhamFuYtLN2HJ68N5OTMLI4vzi8tSk5trz/MAsSs2+sPs8UJAQDBdhL28gUEN5nmCRgJgNhw -LHFjr7Vt4YHkwnicO6JxS2NDHuPmesaXfDbFVgpexc6pOTlWVnmp5RphqckQhqamDpcCEshLLMks -S40vL8osSY3PL89LLbJSmHxeQHbzLIFVzABrgBr+uhx4nG1QS07DMBDd5xSjrNooOAh2QSzojl1V -DpD6M0kNqacaj4Gq6t1xSItAQrLs0dP7jf3+QCxQgY5goGfaQ6lUk48lhwOGxvjg8nszeqMklg9F -gZ/fGoe9TqOAUXtyacTFCThFWWvZtVBa1oJtG7LLfHcHJosxlnBeZpOmqmB7gVQUR0lUt9PBjagi -ymok++bDsDCXYblVsEFJHCLcAjFoCDho8e8IyBxIQdVcq1kKUSDbvIjzdPWCx9y1D7mn5iG2cILe -tRny93c1XHMmwBCNcK6B57wLZ+79J2FAebJThQ1GSpx3eQ49/eQUADM9/8cqha5bz/t23f/Css6K -X6E6HCfE6oM2fvRyzD6v8ZslO6aPTBJOWBdTsy8ZGZtC9lNfdNLV4YDq0XnMKtq4XZ2PfA6L43ic -jVTPaxNBFIbejFRBKCgUeQVpd+t2Wy0U2dJC1ORU2tAWpHjYTHZnu0M2M3FmNjGNIXryKuxV8OpR -6cX/QfyXxDe7m02qF+cwvH3zfn7ve/vj89Knr0vffq1Ot7e3od2XIqBKuUqHItWuHxMeJtRVVD9P -RNBl/NLqlILdduGIdSkkrJMONhS004GvtKSk56O9P7NrOyCpTiVXsANCAgFOL4lmAwpUSi7cWj/t -WMFUEk1tiDgYZ8zPRBXCikIP2O5TB2YaDzpCJDZsHRo9jGuAp0d0EEMn5b4aKc9L+yGG9LngVZzq -rRl6XiRFz08HGNx2YO2s6quMZs5J17JsGw4OYceplA0pLaw8V29h9iKSUbl5Q3ZhOqlNrn+udu9M -6/0+5aECHVPojDRFSeQfEUsoEI2oEx0jTMOYYf1MQ4AgGrthTCU1pngzBdgJdYAg0pFySR61iSHO -RjxoQyiocmtmiE2SKFr6ElC3Ne1DRFiCz9mH7kp2sPloWnifC+Nv5eWaGjzYDARXGtJnTqX0E8o9 -SBW7ooUy7+Ef00WrfC5mQCWUKdZTQT/GnFPs42Synz9ixWf1ZuP8wstBCUiSUImZlTJIDQXyC6mi -+oSrGURc6BgnBUPJSjjDVBrFLIBblqTBMi04Rc04MUi5IhGdLszYqiRzAiGp56mEBbRkiCRDv0+k -VmWoGSa289+OeXYH5k5Tc9kFTfYXuGvG4XkCZ0P0vK4brA2GobWQOq9pzlfPq7dajeOX8M7Ir05P -jo8uCvnFaaN+PrN8DbAj9vb2iu+/GG9omZPbCG6OsY+YFl3YLlO+6C6WYPbBLxwM8643Hk9a08Wf -SRCHDE18vDnpUbs9JzZEIglx3CIq1iNlSVhQXYPgqEO5RwKcNi3oQd/SINWkg5sTo6vZEdyghIyK -NXHLqh4AsCgnADaEeWmghRwZAmRvxg/v3pjc+nr2+2r3VmWVfWnez1rjteUbrtkTvpKx98vX38cf -7/0Bj0yiz/0MyH9Mrydlqwqa95X5ni2Jb/KiiWZ4nGvfwHJ6C8sG62BWXUOznNTJDwNVN1sHz/X0 -1tdXCMlIVUjOz83Nz1Moyk9MsVJIVCguKcrMS9dRSMxLUcjLV0jLz0lJLVLITwMKKKRWpCaXliQm -5aQqlOQDVSYWlSikFeXn6k0+vSBRIxOopihdL6s4vqSyIFVDU8HWViGrONnKyis4BChgZRUMNppr -8sQ+4clqW7TZ8/LzgMq4Jgf0i02WXKY/2WeZ7OTG9VKTFywQnFy/T5xJ036yoKvo5MXrjCYH7RfZ -fGOOfjUAv9dLbPAClHDLG2smS30/q87v1t04l2IvkoV4nLvHfo99gzuzSEUpl7B+inlOl9qRQ1wG -nGGtRnLfJkczNwMAtxkLJ/MBAPmECYD3KjLaup7LTVnzqg4MwIN4nFvXztMARC2MW5gymrdPa2aS -aAAATHwHZfEMBzwxWbWyXZQW/9WvJTbTwMLnuzF4nAHBAD7/1QjVCJCVFJX63JX8B8/Vxast6fqX -U99IGJPqoakBFLWDBkBCA6rvfrjAaAgha6hrkOnMk70BGRT8S7Lim0vEIH1JVgtlKwjWGLhj8JPq -Afw+ACvTQO1dwrFk10ouChgRuWhELLAxMDA2NDQgc29ja2V0X2JvZHkucnMAOYFQkDezJGmrDoOp -tqayYX+eowaTJANKFK0tTJDVCB2vcH3n35JfE1tRmTb1k4IDvxQHa3ZWAJKvcsn9h76ti1+WKfy1 -PhVeV2j7ErySRovtkuxV5tOsKdfQuz6YxDHEeJxbcIh1x2HWDdfyJYutFLyKnVNzcqys8lLLNcJS -kyEMzcl1FWK85UWZJanx+eV5qUVWCpMflslNvlexY/OFgjPspGrcfK/inKc4Dk2TP2pLTp5gyjG5 -t4IdTevGK7qb/x7iEiFP6+S/h+5tNrvho0uGP2u2O7AxPogCAEbhdPz1FdNOUCPZ0hgNmzGUQIwg -wKSQ+6FueJz7wNbDvSGbmU9HoSSjKL+82EqhpKg0dbIgswhveFFmSapzfm5BTmpJ6uTfjNYJKCJK -OlwKColF6UAt1QqpRUX5RVYKSXqJeZUKtSAZZON0uGo1rblSKwryi0oUkvPziksUUjKLCxJLkjPQ -LbHUxyqDYllxSWJJaTHItkxjo8kJTKI8MD3OOfnFky8wmVkgC6QqKYCsR7U/NS8lpCgxrxgsZAs0 -Ki1Po5pLYfIEJnlHZDkUi/PL81JRfZmcWJCYlJmTWVJppaCUVawE8SkAcZ90fffjBIrLzfpG9x95 -CNnAhPv25Vf8AyS1eJy9WmtsHNd1BhXRJFcSZYlP0bJ4uZbEGWo5JGVHlIYiaZmiFKmUKGkps2ps -r4a7d7kjzs6s5iGJkhiCTuoCrmErPigSA26TFkV/BGgTY3+1RfoC2gJpC9T90QQo0gdgoG0axNaf -Ii2Kouc+ZnZmd6XIRhH+0O7euXPvOeee853vnKsf/ca2j/9723cWnuqzTM+nNnWJYRdI3ilXLOqb -jl299tT3t7U5du62a/qwp2Nwj/xOcwXTqxh+vgQP23vYaN5yvMRo7ya1C6a9KuZ7OpmjlnUy8My7 -dCaTIvjnlQK/4Ny2czcDGtCCnLHiOJacIHYqGqbV7KnvGrZXcVw/lzcsK1egFb8U3yUt5+Ud26d3 -fJ2sBHbuhpfX9Tkxcq5QHen4/ueyWSkHMT1y2zB9FJoUHZf4JUqovWralMhfq8xGZr629bBH8mal -RF22XsxwcG3XNzbZ5mNjYyTr5NeoH6lL8oZNPN+0LLJCScE1TJvtKIwQX84o+ngi19GMinpd47qY -Xs52CjTn8SVRJTRHJrWRSjHd6C1q+znLcSq6bpYr1c5Ov63tlumhEQuw1XNwE6cH7HzRXCtGfo2p -kace1wzlou4U/xrYYppvuKsotkvLKKFHTDvFlGEzvJKBihDPIZZ5ixKfGm6kmE0DJrXpo3JoREqK -LqVMP9vY6bPZnu+4xiqF5d5rLavwQW9Xt0pGZ8hihdnt5Pnsy4YV0Bn4Vu+78O3LfXCub/T44pqC -kuQ8y/GVGx46lFGpUFfV6J0KzftKOm/kS2i6QoDWvxOpl1Zhq++Xr+CBSL2no0faiolGXbWcFcPK -kNqSGXKYGTKPcut61ndRbl2fv3Bp6VqGjGvj+PiLr6qzoPc/18qXBNo/1IHS8R9q9e3+f/xcqhKs -KF7A5Kuu7f+7HR1Fm2B44CHC2wf2w8Jz1+FrX07DccW4lkUL+0sLWekMaEFxFuiwNuqF5sCzwEfM -mDjmBWV+WOilPNgyhB249BLb4MYtUB9tAWtnRwYPHya5NUorOYMdklYyPBlnOY/tCy2ne4EU2+G9 -ggY/Obqz+p5yqaU6M9KxrU0GzLvaAahk9rHwdyrUhnczZyA4+wL8xdgemLI7Ns1iGFpa4FF0TC5C -LooNRSX3uNOGf+g953C+jaEQuLdwrkcYXljohGUcnSJoOgSiUsx5mDks5zYq6PkuNcrcxVw6itPb -qStiAsjoIHy+uC+KdM2l+C2PqBHKhK8WPAXG7B74QWYvpEb/o6bk/OVPrcjP2EeFt6cPwB+PtMJ5 -bQB+bW4PTCudu2NTchUjgFEzDaOjna3o2fjGhDKwxzfWopVwhkdh3Bxkc3a5lFtJKRqWR6uvaXtb -N0+7TkX4ASKCbxbXiWGWMQgMxA10Covts452KuBYpEkGMdCX7ubSVQb6LkJcYdhLxQ6pBmNRwOih -g3Gc8MiNI45p4+ngbhGayCNDWXEnFvEh4MFbLww94zllioZEr/SoVdQQyMLHCvz7CyNfYPIaKxYl -84tnpIQYQ2XT95Ja3i6hvblfRFpx3MZUwV7X4Njxqc0a6HKX90g58HwBteS26ZecgFnJwVVckWRG -eRSNnjl3kVDXdVyNnArBvt6FTwuUYcsQA2XkSY4ZUUptU7pcQLj0hVBULEh8J7QrjQyjJdZmQCXO -a5qgS4ZmiuE9bE12dadDVefZ3LQIgXemn4UHk9v3Rg/PYFLxEBTT8E6lf4DNYRmtgk6DyWUdwZx8 -ke9V/erxH2zrZltH5zhNyjyF//rVA/Cl9Y5WrgXsyfa1cpFgcbkf1pb794rszIBZ4G8mBbnlg4Ni -2IsNx5U8DFvZbvjucnpgmc2bkyZJTAL9ippR1NpYffwh4obSqmR6hsCHV3vhr/UDe7iAcdYA48V+ -+PrkNZidGoK/mW3fwTUtBTaqCaWp7z3iDXuyHd7nb3XDN04OwVuFXdOCxmiomMJfqiTojcbDmBwh -E+pUQtaVoFikLkMEC50n8nkVvQHBnQUnA3TmPjJ+uMcylzIxXDHFGuQGizUEPnRY4qx41MU4NMiq -UUn6j0ydun7x6sIC/Olsd57L2YwmJd6rqdRsalPFLM4LvMDy4Q+nlU1u0EzkQa/GZv4/ijCaEIHv -qVHMii4sH+nhZAujhkk277oKBh26hhSyMQ+dIt66nS+5ju0EXs31y8Z6CJ2Mm4l8qZFzGMsFisfo -MpYhKW48XweIhcnDaO5X709egPfmdrF80FnT1CxYDOoHhHNGyffMZ85LciJbN5aMMNmPJpx1epqM -M0AeahBWTIAHc/t6uQ0k54/x2zcvD06ie/qGHyC1N58/ykncee8KN/hJRZ2JyZaElxBYhpKFRKbR -fhJqep5JzqzHnKGBuucx8AH76hDCDUmHDx8POy0KfJztY/njF5A6idOtEfIQ7H10nGC1JB6XKCpV -QXoVEjIGtEbCvxzXXDVryVRLGkYcGjqr4KPaSrBp526VFVWTj3JOUQSH/B2PAtfwMeJ9TP2urp+y -LF1nyptlpAImPlKS4Ct3QMKLKqCXK+GKSeMzPD0ZwUnRdcqKOOm6ecnd5yxMUrp+hRoWfJLthT9/ -ZW8nkl/hQDyHo9eM7n8C19j9zJM4RbLibHSKuudNnGIgfDjH+fQjnOERh/TzOqO+xxzSieiQrl48 -PY/sZf70pzwh2PviT7uauCPiz/xnxh8RjmI6fPPFbiiOdYKz0FPtOgXbGPjtQOZM2Vo4B35/bjjN -TYeFhokLuLZh5cIJBcM3FPYPjCn798ZeYx+sqNo11xcvWPomurbhaMtUF/xwoRN+Z07fybTKxaYs -zB1FPGyH/3mxs6qcPtbxUvOiuk6pZu2DaBI47fuqty7c3wYbi23wJ4tH2Wcq1g756uJEe+yH0plk -D/Crl/bvrmuHwL9eIjsTGQQHupvlR/Z2aIPqR4v3W/iBJrXKIJj3VsuXf9qCRfeby88wBgfXsw9a -ZtET/j429mdLb/Cxs/DO1fdi44MvP5Dj//kyROO/3TJb3f2LX24ZECWujrQbaX4WT1PXxZBa/cq1 -kZa6Q3gOFs226h/80vvtdTlvf+RwtmXaa/KgFd8NqDoFF/KjsqlCkN9iXXvX4FUKS9tFx8JCEZey -LFk7O0VRJvA2hqeR0w5hDMpE++EM9sx0kTSRPLUsr4bJDL4jRGI8ORl1u9cfwNj6rhorZqmss64n -Vll/dqQRwl6tDxe5Cxj5fbxMvHdThW/l4SAGXrx0bxp88LfHetbQEBdFXeazWsk2ZNFmY4VdqSD5 -8UjYZJgi9E7FMvNYWwes1SGqqkTrQbZxkkQmxF0YUnrCMgP58Ah8aSIFN8ZSGNc74K9mU5AvdlU/ -KvxWS/ZJpG+AjvgbUSDI08eTN8a6cKOd8PHRdvju2XZ4uNF//P79RpYlmU34qC6kJK35YKwnttjT -TydI0QwZh++MdCNbOgE/OdoBb48dgmvP74B37/bAf93d1x/ao35t5Hfd8OO7u6zPUCfUlV8R0JzP -ngls7sy6nsdc0JArWDG1PZ3GhPfBcmYnbrQUuYe69Ozu07RoIBvT9QL/Atdvdl/h0NDAk6M8wlHF -ZgnNN/NruYmo0MqEmSkj1K81zeBfzvbsfCTVvXdzBP65eAoG51rbkiBcza4eaRFxVN0obe04jGIJ -KloybKSurqfl/Tu8BA4sK/IYePhs1yY+IBUsi5CYY2Etm2a+7KSKCv1qZdU1ClSCdaa+ArhdMhmH -D3yLN6J4FVY0qVWI2B3rsDRW6FyH7YwKwOCBQ+d5p0/Xm205gyJvTDVNkGGohR7OA+yTjX7Woar+ -r/ebrU8EMV1NIAa2prqq1fVcC/zb3T1HYr44Xl+UNfivNpA8xZZ73isXMYMMe+geWd5+E00VreBE -LXP0Oa+uG+PYfIA5EWFOlJEtStYRYd1OKVQK/CPq9he0oxPwzSOHhz9/bHRh4tgEb59y1qKSIl8+ -Bhq5/B0YeqO7lTeh4OFWz2V2IvwX+jD/1HwHY0eRykpH50lJ5EHm7Oi6KIfQRdBb9gp/XYVTz/Vu -MvFlOx6TR8Cak8R1HF9oiilDdssFhIqeKxUtH9kmEx6cJPpCANw/sD2jSMk9cnhEjGmGl6v4bugv -18U7UniGBsFtT9fPSW4UCi69rSB8TxHdb6afXFR+cMCRP+IhxD3eqglLbhusyY9EHzNogaysN40j -xBI+KmlFY3zIJnxCSzGm5Q0P3z8pFgT7rR3w7Y2dQJXep8QE+HCjj68nf75ZPNTKfm5UV+99rSNE -D/jexgFWoJ2yw7qKpX9aNsMGH+pgFqhwszF0IHGrkQ+wesdzZB5YtAKvFE997ORMuxLE9DGLHBOa -NyReqiug+cwmeSiZ4/gsvjdLaePDF+CPtro7E6U1hdL96Vd4x1DHanrBwU1PDhszmdSj6mtmcwHM -7H7jjia+NwsAjpcULr0+P7+EBqm7CxL+zQwhnTt5tSOudSROCkoFM0OkTSzqwvW39uFp7kkcEm9o -8ubntOyqJoIzlF5G2jRRMG0/uokgcTtrGxWv5EQ3BOsMs9k9DWt7S4cQm25Gl5qMEJUDrGB5MxZL -tAJtdNwy74yzKhdFGU/iNstMQgPMRrRc8ddFKzvSipUM1LATRw4/PNauRiuO8hs617UdXQ9u5TDV -Xjp3ab62DRhT3WkmmRpZi/lQmHP5o7Q6C1uTfcMiD6GPT/MPLgCu7vELK/mKOousabIHzKmdh5Vb -LLlnSE5VJb1ICDJ/cenKufksn/7J5PZWzWQnevlQF/5qn9CK7K7svpLLILiVqXpf7Elv5gwvb5oK -G2QAtrKOqK6oqsrXeX1y4OlI9xG+v5Dnn050wj+c2A+zx9suYiEqmufyUGK3O3hqBYoKOev8Slre -KtJb1F2X7qfVnxD8eOMIZ6ezU0+1sx4xCjMFNyf6NqPga97MiowsmxzRwhtq3FcbWZP03AYfvehE -XUIU2nlNNArZvV20p0YWqIEBhqglEENe9YUBh8ZmyhIzkUYiRerp1igKx7v21Bti0mViJNKb53Ci -L8kSAd/48Fg3s1IqUobbCU4M98LvTbZBeasLXjs5NLPBNxb/Cnuyq+Zkho76K0kcU3iqHn6prkf4 -JJjVCFjjbdTCRHsvBQ8nu03JqRgWnDozv3RNJ0u1fC1QLWb9Wt4WPEGamREUTOzsMj923WWyPi8D -PhchPAW/e3CgDuDaE4UsotzAwTBRNOX5PEMIuTeFHZvNZfzs0WvU+t7sVkjE1JBYN45PjTkovDXk -1TOB16f2OixYm0EAGw97fNG1epnR+0LtFst20nWXG3GEjxwuu46wW+ZOxy6sNsVGUvIkD2d/LPBF -cyV57c7mm/kcxxe18bUyFrfGatM3kZbZNBf4xeMKpohNjIshJS20uMdW20irccBqXNtb91hefJxU -Yr10k5c1LVl2bbdYzYnhNcifIlZzi+U41bLxeCReM0YwKMOv//mYoWUUEh4DjbREdPkxG8GPNtTt -7CEsnhuEjzYOHX0cNcFnTRaCzPBlxkp2iOYpJmsex+rYpyQf0PL6ONx74y/rw4Uzt0suFZdYiHWW -iTEpY1ccUS0cvTDHM2FE391ktchowTVZoz0SXXsMRsdwny2jRvZuRs5+LrB69FPBqmicD74xsbc5 -l7uw8AieFna+BP1twEXWb4nxPfF/gQo/i9NVr/9Kqv3/AHES4iD4NWCnwwCIckijjh1y52LPTtsf -Jn89eJx1U01rFEEQPSXEwQRE94OIUsxphWFyEC8TjKgbUIkxsAseJIeamd6ddjvdQ3dtTAhhPXnU -Q/8Cb55EzP/w5B/IP7HnYweX7Papu9+rV1Wvuq/3f7/99WNt5kskfsqeE2GSnTBJxg88KFcYhj1j -RH0CeAYfmn2x6tBBNqVUfZJN3AI61ChNrjQN1YTd4KRH01yws3eaj/lNsMJkHwlXYfsyXYTs9dq9 -2XLuS6EMWyX0XnNaAZZQn5scKcmWU0rphtL6n3M831+trz+8083QHFa2qWTC6IAbYpJpY7+2e/a4 -s2m3OqOZt7MDryUxLVHAgDTDkxdoGDiXHTXjOYyUBqlSFpEwuzAuJHgC/bIYZkAzQi7hzaAKrnKF -HjsrJgGJkoYAy5FXxQwPBs2g4OkM4nAkexeuctRjE8EFmFIhAkesxAKgeUAE1dUrlKlgAeSanXI1 -NaVvLjoOY6VEAFxy4iiKcRaXKM+dSPEq6hNcFr650u3n1ob96W/Yb63H9+W8wKMF2b6SzHm2faup -yP7Zaj95tLvYpKkf57I2my7tXueBF0CCQsSYTGze6hbp2wnmGHPB6TwC/2PxMS6dvjWdL7e5OXTu -14m3u7793r57tdn96/0DtYkItfGKDeYMWNS8fn68cFDznb/Uv0LXn9ejeJzVfQtwW9WZ8NwjP+W3 -Lcl2/MiVkzhSsOUksF0qJyGJE5qEkKRxYJehrLiWrm0lsiTrXuXR2BWB0s60ZSF7p5wZKCXs7v93 -Hy0kZDee8oYpZYcsbcL0Rbu7kP7/stt/lhL6b38IaeH/vnPuW5LtQLsz6xmwpXvuOd/53q9z8sKD -Dd/4dtPJoS2jQ0Pi7lxCzskJcVTNydLUzqSiymk5J2YOwf+VyWQ2KkpiIqlkU1IcRm1bO7Rv56iY -Mobl5CkpmVbwd+agNJaSI9qqLUuXK1FxhzIip1Lrbpbj63Zn1WQmvW6XpCYPyiNSKjUmxQ8o2nMj -vjVp9l3sUC6pyjG2ZlRk75V8Z3tiw2lpy3s1hS05tqo6KcN/AHdipSJuzuSS6YnR0Z2inMtlcuJ0 -Xs7LYiYtKvFMVhblw0l1QDw0mYxPygcB8kPSEXzfOwQ44COSipiSx9WIV1Fz+bgqjqRkKbcV5/o0 -ThUay2RS4WGvNznVlU2JW3KZrDgO67iGaYV9K2sVOTUeWS0e9VLJK3Q1bd27NxbHYTEGmnbqbp/2 -wd7q07fc2NNNnz4jRLQ3HqimM+8KTdqTx7zahaSPKF665lWhfYWcVnNJWZkR9T8i2bwyGRrNTMmh -uI6VcJjefop0tY+nRUlVpfhkTMdqIp9NyYe1d77USZ/8qRD0xjNpVT6sRsV+mJv46PQZwUc/nBQa -qXifUFF9KCdls3KOfjoohFanZFXMZTKqIq4XpyQ1PimyPekz83WmAKYYGxQK00c+JL4m9iEsrt/A -36XiCAnQy6JnuWd1+Dr6/AHBX8kfTPcKS2txjWQ6ASBO728vKJEJWQ2FIyk5HQI0i/oPkGdTKpWJ -S6o8hO+KYzJgXRaz+THgwkkgOWODzYCIvfJ4RNzLODEFpJQOygow72QmJQ+IaUZ0GD8OW0omAPKk -iug010GsAwyHkupkbCqvhmaKMJ+TFTl3UA6tCdvAY9sBoqgxtpPQRCozJqUG+L5ESRHzV68dEHXM -R/LZiZyUkCP7lZiO7fB11lxJ7YZLPu1z8cZPFKFZiSmyGovDJzkR0l8dEI3FONqHtUfiA9d8lFe1 -43s7euz0tckjpwr9+jrSqcUu1ddkc/LBZCavaNn9HdqFtzoCxhcR/lJWTieAKNr5I530hIdUhkpM -CQBxFjbfTSZC9PgoWUYfvdHTTDf2ChXl6XHURBj+FMuFS89Eo1uYHITG8ulYVs1FozqvRKNp+VDI -MRn+6LQagAeN1rdh+KEXNwp+7VKhtRNETd+WmpPSSjaTU7lo00cvC51050nhD7QT99XRXX8srKLP -v0j8jZt2jWzduXULckTy6rXaqWPt2o2Xen056RCIi6hk4gdkNcJ/0dX7YI7n/J66TcjZoJrS4kgm -nZbjKmhgPgb1M+o/1FkAhjhiTCHuw+9QJQ5m0qkj2vmwb3lmjDFuToxL6XQGZe5g5oAs7hgVM6jB -AYNyTrvjwXbt6cH6PxyXVJCe9WI+rUjjsnhUzCvA2jAiLaViipKKsQE6OdmeQ7gJTZzxNSTHRf56 -cL24WnvkaLsmrqnucDAAvJHOhNgo7cKaNu2OD1vZVjfjVhVpytivsU/DwOAuh0GKgR3QOhk70qFX -YDMRGhwlvtV2uPkcDGolm0ylYglQ2lkQA4b2WQeY2p0vt9Xt2b5nq0min15FT7xHaulL1aShqxTF -E2iF5IT22NtLVsDW7QLkYotQmK91/oEAU/P01gNCYyWDSXs+1kEfCwqV2j/vq6YX/1aoojes8tS3 -RqakbAzeXD0gzuh8IT0BShuRta70KqKsqBLTisAnUro05wzQi98jYgRYwUCeoVFVB+eIDDod03RX -q6dde+xyTX9JtOoyH+IPALP0368VBrXLGX8Dn2U9bF7s76cXfiQE6epLQlUhqcTkqax6BDDT389R -Z+0mmUjJoTCTzFkv+1UK/YyhQv347oCo+w5uf2FATACrgcW7NX/tbWFxcAOSFu3y7m8KNWvKqTxT -P7GPNnVP3/6/QqcPp3RDpw0l/T1sAYfnsgU8J7SeG8Sj2k+SPfT7O0hfARbK6dszfsC4HHR/NZ4C -JY7G0Pl1GpST+zvglWK1l02mS+JwuxwzXIfY2BFAtoHDZKIYgR9jS2XgHwfTyLX5EW5bj6D2DyOP -JBMfcV895fwStjNtIL6UnnvA5uJc6Bb6yHXD2qZLvWhvV5QwmhNFRlM7ER/sX9TIMF1zhnQWuMtX -GjQT5+gnREGqkp+VwzbTBm7P9UlQufA1aLepvKKKXHUrWZBmlG4plwMX9tBkRpHFOLjMMAo+SymU -4CPipHSwQQbJBg2gHJKzakQL3jWoffNb9TUzM2KQYSW2ZAlN/7HQSx99l9SvMFy3ef082vyW4Ke/ -TQi1bWwYbn1SSoO45sAH1ITHOmj0GbJkpdsr6i/tFtHgI0Ib3btc6LgOiJhPp5LpA07ndT7WHBDH -OYZA9dCH64i/Wv9MH94s+DfvyqCFQ8yIUjwuK4o4nstMgUMYz6RSXCPmkViiTjQIIcYNjHO3UHst -2d1a7ILQ258gfm3X+/XNjHsRZ7oTor0z6K+MoCzQ6WtJu7YnUrGtFL9LSiwnj4Ovm0RlOgV4nk8k -OLPT27d4enHG+lVsBKy6K5OmwW8LzIgOQmSTkk1vKCUpqmt+LsTRKHyXvv8HpKvO9JwyWXq+CkzL -ybWkid4rk7oILuiyaEUuIULHlGRSk37gZ75ea/FY+tCbpIMWqNBC7wsQfzs457JBYkMLhZIJKj0F -wzbWk8YqFkrK2pr9gYFyKskSEwwhpDg+ZzEEbHk8mUJdNMNWn+F2wY7NYce7Ou0BmXwWizSAshj4 -GumQU+tFo+C7c7PgnAmig/ytgOrkODdsJaa0U8M9K0ptLCvlFdkNIsdHAvfnK+UPU+Fq0lbggmVy -YpFXGymhodn32YySRMb4eCx6wBbGGIAbbKqDdCsD8baIKh2Q7QEe/lwp87Y32JgXFM+pgW4f48UQ -W2SAr8099g768Eukdq/rCcClI9YVT/wO2V57dqBR2/125fyGgMHlwgdof5ZfQKeYv8YZWWSemTSO -XhtXl6D7hsWkKnJ/bpA7dHpcoKhcj/mMadH9DXEEDNOWzR5fLbAnRzOVzkGojrtZmZMhBIoDQQyI -kTeVEDK4jb/DdJpCmMI8ZDQgpu0DzBpS5cSsYXwx9teevrshOo4gl1xL1/rA56Jr2aiIaRit5Ve+ -GuSxGDgD9KGnhF5vBtDF16MtASJqb9xZR2Zm6PlHhT4we0u05v4KdPPR/fZrJw7Xs+wDQypKFv1e -TmjWHlte2SDlgMywB07GVTvJgCaqlQVdnYQsfaL7nBGb5IbC4XCxHFg6hr/wUVRMr6XtstlUErjW -SMuoCLA2/X1fIxeA2ICo5vJymN63T+jyu7AHb8FDNBrtjNbaF+9qoD9v87TSQp3QssKcYVxKKXKY -JXKYMOjTMOLQYJ3gGwDbI6OsFC1Q7g36+izp1Q4sb6Ofu0aob3Zzi/bGN/3VDg55cqC1gMkfcQIz -jcm4mMocwhQOy1Myfo+D6zEhMyExE5IQBSUxwwNykGbuUjIhi4w6QxykiFvQRjK5HLpULNbOo/hs -H43t2XTT6NYtO0Qm0lzqDgGlYJAEJMirkxl4wAVT5RzDgUlEisgfz8P8afrODWRJq9vwhb1akxrY -8RGZC9DPJ1dRKZmMgGxerbOJKaSVdOMZ4r26pLyBYZjHzaLB/ye0YzZmpdsalDGx9OGg4O8uI9mM -s8CTXnojoH5zPoeszHPNwEoqxNNIh2TOICCaOyAKx66R6+N2VeSgW66aT49mwB4ZcIa4Jx6Ip8BL -drsdirbmM/7CHtAbegDMlKexCN+VuBdjZAg5AQScg/nY3HCAJznG4efm0CQNN2ZIeodJstK1didb -m91ft3izrlvxSM602jbDiBsOX6kdjuTTKHVlDHL/x7HIvaUssrnKLG15S/AFErrSA/gMBEWySTr9 -IPF7be79p99DN/dYC6jyunlVLKagzNc0ob+NPtDgaaBhn9DTaqwVMfRrSLtwrke77s7KA1dsoZkp -NUnqemask0nHGNeELJDA8E5fI3QurP/oUSo0MfPaN1+aAvVweFhr2b+5lw0rzelA3tM/3D/t147f -0eG19LP25bs662yaWjv1eBd94oywxlGPOP3Xd9QI9Oi7YCCfPPaPLDkrBLXssWCtqSjpsTWertNf -u7NL0J54vBWnWGYa3113icbLDfSe78A3vzjWo3k+P8tmonffKwS95kTh00c/v7IFs20GEmO2jWOB -CbNtnUhzdA4SMuYFc8wcIiaGtVOv+XtAAbjiWBvWtI2ABnciu8ZQHejTVetP6HeXCME2+xLc70tg -4nLVlfmJGLh1wivlk+U4gjkob78rNNKBbwv1ENYF5vcvL66pYAnUzgB82POXPUVz1PCYLuIDL3ih -AK2OMZt2+wMVXiv3hcgRQnTT/xS6fSYmLO06rL3zZ/7ecTsd9F1bRkE7lWxHgDrQTawuuH0dPTmv -Z92RcP3c1T3qNtT7UCunEmJaViOjPDvMzTPLjigqJhqBi0GXoAcAk2D8z3K0Iigskfkngxv4K2NS -DpRVLlJkT/VCjY4ng1wxVrCBF1lu3vQj6ckbPY2MjZv5fkHgdT6lf3KK9GnPnfGdfvKrOyr2APh8 -4+K2ffv2rGUAmZlMcTyVVyZN/ac4nXkcmpBRIzG7pOeCz60W1hnVU56BQQZFxz9STnKAXPS+iBCm -9/d5munFhwSR7gkLrfSOhFCDnta2tRwQWTERyGqoA2DnwOlBbFogI4gc5TgOSLJS0alhqnGvDa9O -SB1Y7+8XQ1MbEWBZCYbYDorcpAHRVtkp4p0YeEbaybO+6iBziWV6Young66uFtpo61M8DaM1H6yk -N50Vmltu4iW4hPkuTcukW6t7oZHe/gVhl3bPA5HTLz4Y9DY5gARldl+fJwBRhZc+GRAaQphFY7CW -zFrbXgseEHwaeaEdVOqKuXRYkIXTf/6N2wr0W/1CjdbwQNOKeb0qYChQEeDGbDoKhANK1dPbFWH9 -3MaVwuEb6FN3g9Q+locnal64aq5dEc4KvWWxtW0t7vZDVfic9WI320MZozH3Sl64tVl7+rXaER6O -GBxWRB+XsJqwY6Y8xNLl1w3T8/1CZu6FLwjXXa0de7+TNlwSappc2KMtrwgBmtriadVO/qaGxp4Q -audWPCHcWEEfrwA/9m/+j9BM1/2nINYyhzfDikgf9LCpGp1TYczRQZ/7DOjBt9s8lRjfNNCN60jd -3I+eEbZ+0jUajUolYx46/XWhzacXnxy7orvPCoGAi32yGVYbw2CrndexeN5Sr5FgAAJApnirArgA -E2k5MSCyMo3srgqLU/LUGOANa3ZbUNlxPwQEW5UmxAOynEXB5PU+bDxgUb4yKaHaHYMgJnNIzKdB -JHVtEfFqD1/u+ITYv0oHMhIHLy4aXefcwgag3mwRF2vHD3d5YxjNYTA5wLzoua73hFWCNvB+DUN4 -s/uduY2XhK7dgkJ/8ymyspSleb7S0057Y6Rm7p5t5Jdgao5WrLD6IoC53B0X+C2rm4HBpeJrQsVc -YS9Z0rSYJSgs8cW5vWPkR4GVGb3FBTtXUJuiCh5aa0SSRuio0OMF8r/pQys9Hf2YjV6wzhWlnwt5 -An/IKiTxWB5wPGzUI+arPdpfXqe/7Hp3gXqrfYbb7DPMer1Wocxeb41nEnKUj7IVwUybB7wH8jS4 -xsbwEIzlc2nt2Mu+VltRlAM5Sy8s9yzD5qERrvMxdmNW4Y9GN2EEftPNbFJlWGTEBExDeKWIo0cA -01NbESJ07+K55BT4xWnV6sLQTjV0C2Ht/Eu9zdt3h/VF9TX3rPCECjhtRBpTzOogbHnZrUBe2HFo -JIXO8G1eOZ2f0s3tPtNg8a3ti2dDe+XxPWpu3b6RPdyL2BAe4M9Sivls56j1bBZbfrIpnLG7xJRm -2412/ral9Wavh9ll886k0E2PzZLOwij4i9EogmAUSjFbwuv2pTp3zGYSwzkacGhZfTqAenHTpeaZ -b9Zr/Z+l5TDCXbC2aoU1PC1nswP0jlmyZN4dlyz3sKXsE1/BnosnjC8wo2vXprfncM4XwAKmIusw -HtGH08/Nku55N14uYlj8ThecgT45QuondIic7oX+5YwBLypYbt2dyFh8dZ2u/6awZGEOL1O/1+nD -nIQrxoBrsqvKzOais61T58qh1vs5Pgao7hna3fDZ+ko+AoD62x8LROccO0ohkdtthvbcAmziVgvN -7v0w92k1RtTz87czuqTnXxA6tJOPVLWVeMEMkDEC7m527/73vSKM+kXVUhNZLK7iWHIjo9ZEBr1q -lUfs5ENLEI/2r/Ks+GTRYxdZlMm8mgB4FrNYkIr1pLa19FL97OGn5jERRn7XUbKZR0suzMvlstNc -Py2en+eZp90xkbGnWS89+2dkOf3tX5Pq7fGcpMph0eZFWPvQ8Qmh1CrMP21be31OmpL3SDnFnFeP -DOA5/fQJEqhAD4Ku/Sz5VFrPYejWVy/gKUb2OSeDRCmokTH6jvO2rWQGMT0eEXex/lXJqAbGj4D8 -Rezrubsb1zHvg2wI09nPEnEVUMxo9GEeYJmNGYwyytEL+5xcyzDrHq8/w2IWrBoKl6SOM7fDg6TU -DGm8Gt83IiiEGTszWFHMCImY8IVZxMLS4uEwfeRGz1I6dJNQGUZTnUwXbcaIdF1bWVF6K464eHIt -fXsraS+UArvkO84hZl8vBmkxCSM0B0YsNvOyipaZ9FbSUlaZzOjtnMlRILzEm52R8LzOa5S3jBgP -zLaCjTTxVJ7Z7x2jvJEPSxA2njVgpaOfJf2NOry6e8tY4waXb1uMwSvkmcLvgWfKzONCP5+wAmdk -kWqjmeC3+r+Y8mFZrpWKyPFgNksx7EM4mElPxFiCowRcLHvCoIEgY5GA639bPeb/dNxLUooWy44M -mcXfGTWlzIjwvwguHTsopfKy3goPNI1xSeD7qrOVAy3vgKfuQOfJgKXBQ8k06H+wOPA/XD+XSYmJ -DERf2D7GXmX6RdcjWaa5ACOm7Z9376x659r8+gV2bwqHTRebJU2+L/r2M0JVtZEMNzY24eYnYB2H -2TUc9MXyUdCV3eVpCwZCkL55lIjWYYh2q6LEsvwGQ9FHnxI66NI2Uk2/OEvaWotBpM2zxN+3SG1Y -pEB0KppBjJE/YxmQ/Ws9TfRLvxaa6O3fEbz02QnhCrsu6NPVxNuCBZ+UauugpLtnSTu9FCB13Y5a -mmPnobAWnPbRL8+SpgMlCJNJF6ebr0xKSk9B1/QKbR+xwYTe+wypJmkmKl2p8ltzEXU/CNQe/bAH -VxfyYdC/uq7duvt6Pb95pYJSjgkwD3admjkgp7EIqiNDP94SK3LNx6W4GurjX+8FUdqaTsiJPuSP -vgWYCaSF9flh62IjW48ldPEPbIKvZH9xPvnnKlKDlaUKzP7RY78G9HwclttYxHJoW8zqqO46LjKb -UIbt+FQfneeKCrVF5pvKXyW/oF8tkNfn7iqQP+0bcdPGPPTm6Jc280UbNvAp9dcyeTWb194a6Sjo -XzDXnu2eTYIocL5RVI0qO9KIAkDZTudlRZUT8wyN62MVVcrNP1IfaOT9y44cl8D3dkw0V/fnZFfN -Kis7uZBjQVfPkMAtZf1E9qrdPbTzFshOSMkzFmX5VFkpEiNQCT2FLbJR57carHNyDpuAwNMG3wvT -kynDVOrpYnUSBkxMiplcciKZ5nXcIRAtSx2UPAeiW3SzcirOzGxzjOQ448PKb6ZkZINle7+rHs2n -Y8Vuey3fXxI4em4HCVbGMX1K391BemqtJ9ITxB82N+EO+uyzYa2X128urvNUtJYAJptltThWPVi6 -AILoV54g3Z3OzdvMNqr0Qskt2zBo/MzMOMfpcrbwyCKBc7wyYL4TtL/E5Nq2HX7MRRNe6PjYlPBt -D1r4KpOtdJOEna+x3jIyOwy/tzrxyyfi7xpK2XF8xtl3jb2XhiktDoDoyW8IvoZS3FhFxe8SX1sx -zviR14I7QxkBRQ1/xZjwK6lkXOYlRVvXDZuL0dUAX39oWRsEwe5fmDtkFZIoFhr4BjuKpZiDT8/5 -ia+ZdVSxqsZ63nn2p3V9BTbHgKgcUaLRfdJENMpWAAc+A6zDFzJRxJPwZt+VbRchxzjjXAWrAeOC -4TLP4+o1hwc4TEUoSaZtToSZG+IJ0A++SzrqbEijFwPEF1wcYZtcsqSte6/HJK0nNMPa1zqGTL5z -N+S4xZ5xPOsz8WOnLj3xLPFr6/+hsSKVyWS1Nb8IzKNPFpRaY2AUBl65/PCeYuP0BULmu/9VEvBa -M9HVzwidG8qdALQ0QRr3GC5SR5y5WGOJbYH2TovRbFDjN3T6NeLHw5b8sXGKkXX4tBfzOae2dA57 -fvW5V2PvM5M5F1105ZWT2Xn/0M1ynJ+SpdOvCj50VOkb15KKxrEUJtqw4wQdXXYIhZ44K1RUcqfm -wvvLcOzVuL7K3FprAxwmN5YHxH6+NIPzd4JLbCDQ91tBb68TltB7fyxU0uZKUuVZBxiTPuhiGBso -xliJCqq+FcRDt3Na3OkgmEXsokOMGEPZKSd2rCsCfkRIxyyebsdJOrosHJovr9OJQoV/F3w0e06o -qQFMsIH01FaDPwDmpU5yWd2jRhEKjYV28bf1CNxSICALeuKZnByNTslT0Shr/jQHnxO6cOrB8gpX -p86tBqiRyG3ma/Po6X62NBtJL1eRZrYnDCzwv5shzrLaa/VCMkYO6YQ4JoNWSfAWhzHWS8kPNvMG -pZxx/Fme0lse0G8EgVaUfI4Gq0jbf2fpDHQbRAeWYH1GdutNv/9vTlACTPLoYz8TKluKXBB68qyw -vBqjnWQ6bx4WC7qwURwumL4a+nJDJcfq4YKpK9ipA0tZfvV2ofqG63ljG28vyqjJ8SMQ5eUUdZhn -NXlDvz4ha62W0/zaDqMBLZ7MArkxVNOOXw60Wpgw3sKItuP3oy9QdgLladzporGhT+ajcZdLIyHl -GkqQt1h3LUDjkJ3G7YaE9VtTO8p1Lu3LlPvScjyh09kUAaZSeIumy0ewbrXQpvsDOG6LkdZg4xaV -0xjV1x3JTEHcBwv36cIBqA2U9mfoBYW0VeunVtjoUikOoI8rxcEMeiVPATnSHoj7pf3hkNudcgcQ -2IB9/0uks9GZt7oSR+qqEsFLuYDF4T9vN+hlTKyjvojlwf0Pzu8ewbRhfTZHNIQ/RSKlxbLheu6u -6dL+/g6y5DrzuUNfLdbHCmvvnF2qZ2sYv8XUlBJC9PGkOC8X4KEC+i/9AkdAS5HTzxA67EjuujJT -fAWrS1d2rkGnE6ggP1+NJ1ErOqzIyBQGy1G+YUH6lmOfYm3LIotNiwhi4lI6LgOfFHn0LMSga4JC -VxjrkkzhRK2GK6bCWHTCPnCfTnvuZZ+s30tSHLs48IaBjMImM7oXnI+TaTVj3y4bFIE3MFUkrteO -f8/fYcDa5xqnvf1jf2HeCMmOBLyxCk9jsS7IbC6TyMdBEWUldVJhncfMZRi2TnIr+s0/xsF5tDv8 -sD7rZ0Z9EPGKf8DRO7+C0uPFtDQlQ0SsqDnzXoHCAurQeaDX0Inw3OwzA4q412TD7JcL8Cq47YAP -hx6swPb5Q0wO8wBs+GYsLvE0GrfXNlpYenAv63jg6tMdRZcOKK1QGtlOX6fofP61wZJiYDaMG54E -P32IWtA40H8hLnQwocfjCQsanzteaF9SHh/0vpdIR9Q8ulOOECZ4bgrQNZLQFt3LqvX88OHBpJLE -6wSMOYvOk0m5sSQQNncEr6nRpuNdVxUZWdciEA8ZzXp4SUIPu1ZB+/JQC83+lPQ0RnAp81YFuuc5 -wVcr9t/K8H8bPS+Qdjy0WhWbEbFy/theoZOmniJtRqZ5sWn3RaR5ytpIbs/QQjJGY6Po635S+Rm9 -DYJ7f5yWRiGWt0TIuuPPi9ridhWv9+HMNcRP4aG88xiAX+GggnODeIzQY33EX2Bn2wwmZaXGcmDa -HErzMFXJgbq7haPMoLgoA6WPbSk+NvLOP/KYwHY2bc+lLjr0LKmuYKpbfAbckeb+il4sBOezCUlF -uy9NKKEZ9gtkAX/R29rJCjwai+fKAwY5pDEpnQCrBsspyYR2/PUO+sJ5mO/pu1sKlhEzkOTK8M1H -fxahWYxua0qxHUTnMaF+bhJGZkCJTrAOBlDEKXaO3UyvIy9JqgiKOeM4H7LYnHlpQ2oIHnoytPlq -UtE1D9Nq977e2W5vFbUVfcxrKCrCtgKCY3AR1phqW76YDTDNUTAuqMNOdDP24YY9xfs+7Md/hq06 -BBYmEMsMmYbEjGFhIhk/cMRZjiwvivQnftLKj949+i5pCC6YoaNvPEt6Bq096b3BxRkcG2+vvjMQ -4Eh3SyI9WU3aP3klkuWQGnoiKPjmCwMq8Pi79nzCR++jQk3HgpyywgjwGEjl/Ctt6E5/73zJVFDT -zwRIz9wtf0P+otrHTwZZ0oIlK7vz3q6fgmNpC3im8PNgeLrLYgjdljBqT2SsS7pAc0rwlatBzC6y -qF0ZypicDcJjcQTV5hCTRdSdB4yr4KT4dD4J0wLH8WPCKDd4kxg7egbWynI2cEtOUeBf6dKl18Nc -ZQ8g5NzFU+SXdfTDZwied6quKlELQKtOv/735I65sWfIubq56bPkf1RpJy5VaLUP1FXZgnRMKuy2 -jAfe72PZg0N4Go1/RiwxyzCsu385mV2GZut8sQKa45cDZi7FWLRYhRsZkWpMIsPG8QxTs1tYaPDX -QoAFyTCanvueUFulZ7ZbXoEgvuoG0hi1RUoLBkr201bJBD3v8/jZ6SjEwzbEg/Ge7QIE1knGOghZ -AA0MMsw+85OQLOaAqEM/PYSxlh0BVXTj94UW7bW/bKUnt3hqafrviG9u66tkrBYx04Xg4JkUYL7x -5IRDveEFIkvw0F0V/dbPyDUYRs9d+Bn5CsGWWDz/yK4bRB6xTtwwtmfwJGzgYqvSIcRNnBPSCGwZ -XzOI81k8I7UZedW0LKjd2aV3eEHgoSQwQT7NToOyo1a8iMzbJkXJOEIla+/8kt3khIZ4kCfVzgoV -2uBbtURNaRt+cC1mYvBP6cft9awza0Zkv+ipW0g7nX2VndJtZT3Gc0f/hQgVvc6S2qSkxPgGeR4F -65aDTNXwb/WA37wCT1IOxIBh06rZfkyHXiF+mv052URnLpQXIdr8c1JJX/470kXXvUJq5l77Obks -0Jl7Sd0yxhESj5iM3lPQCXJOBmXHBZy2PAAvbvtX8kP6J/9K6oPBUFw9PF82jW66BtbEsSuCoaBt -cLFXz+8PbXyTHGPXeYD9H1Ow5M55CDGEZAN1Fdc70o6kMlKC37RhUle/jBDCTMYSwEuATvsZU91S -ICRlGBSEMH4OgL73TdKPN/PM/f2b5Hwl/duLpFELJRubwPGythry0qVnhF69oRjCPTNA4I0OpsC/ -80vi43eIOkVY4c4UHw2GQ01KqRjddEZoH2SBFfaK7MwAktatjG0Y8LI2iB3KXtYnw1smuBtGbzgr -LBFLnzq0bg6lv91Ilhf4mS1x9wE9gtKzB8NG4Dy66fqt+26J8rOI9rOFk5lUwnFEsczRxGFdvfID -hvotUzBxkt3KW3B2MatWqzOILrgBwIMopINc/HR7JqWP6O2rrAiQyek0xcjDWNx2Gel8hxn/yDjN -OGzOYLD7erF85MJCcvNMl3mtjnXKix57i3Q1M4sTRh4Lsj/p82eEbrJ+gzb0hD9o9vjwznY2AByl -8dhEHnxujMFYG9uX3iJNbSkltOi5jLEl5nrtL4Qmeu8MqS/o+7XElNM2FD+sB76svGZ0P+n5g4UO -ujN/zMXS4ZKvFpwxFM8d2PLOLFMYtiNbz3/w9AUvkeuPF5USscXKSNWCM/ofEB375lkMHUNGvsSJ -Gj3x3DdfgoRfVc2kGC8Z0eUZ2xAiBccOgKbmzS9j+fFxLqX6C9iozK5tjPFHdjjsYdd83aD8zQiv -ryF4IzxD42QBd6NOUeer6WKbKfGu1uJUCvs+CgqFF3dmvV40b/oBCdudrKA6XbwSSzC351Se+NpL -aFHcLd16VhA/sZBq0y9F1lW5cTCbPjJDfIXfrSJzKLPF6LLkYpXZR1Rolj6j53cSf2EeJWaYv4Wk -2pVic2bH52vEhWW0M3c30b+6SFqWOtPhnP5u00m/kxF8979NKru50jB7Bh12jz56DwnQbRdJM41e -5VmJ3VF1VVyhXYHlo/l3hdbCf5mhK80bhf8yQ1fazl2/kKFDc2Nut1RTJCuX0Kl3hSWF2fLquFTO -slhzuNSw6Q3qyrK0KTGnvsYc70wgmrszo29Di8GQuTv/g0iVtbF0JjaOp7Lo/3qHXL6KaW4shiVk -41KG9WKGNegqEeeDuZ/8isRb+e0Cy8rdLjAnV3q+YN5qbzU46Y0tvAOYZzEwnUiP1XlW+x2pDmMo -/eBTEEPcWecZcndT0fZ6zzJ6T51neUc5SbaGtJcpK1F/vWcFG+EvohyGItbzslkSa5E6Wy7JfHHF -3H94Pb+prDGwSFueIr56g6ZoY+Z+2uxZ1yTtAbUjYUIcQvEjWKZNJTEoAy+eBVMl/kkHyQgLRxFU -vLjB1nNvXLeaQlLiTSxHaSxFdtJcL6idn6Qwgxf0tNMfpIhP8NKW5wSxeg13xOnTQc8m7cw9zbRu -ijS1hu0+IDPMtKeNLFkNBo99Yq3i7C+rGXxrLsdTPuzhUXPaZXT/g7AyXm7I0rqt+kUgOjowBUSf -/QcSZBdRNg5W7zbOX8uH4zJjRxHCRtbDIitWZsM4KjZstsuLIFKYplLst4Nmk1Rq8bSxDq2N13gq -7v8a8WmnX2xhMa30Gmmjy+qEAH0x6GmjQ72eJv7x8oukSTv5xQoc5cHbhJ/vEtq0ew/39OF9RRBq -QTjKAjR2j7QeseKN8nh32JpufwGv5mNfG8cWx0HFOVvwYSZJ0dWlHIOYPJ9m55GGXRrRSj/xa4US -cko6osAv/q+xAH6Kgr1ESxGK73+crGANhLDTVvqr/xQC1eg6xzN57ZGX2xg2PnxcqCxFnH/7GsFL -J/2lngUeIsvZtHjFy7UGZg7BxnQ2xUQGVh/ZLoZsubks/uMFyPsT+mXN9NwPhcqVSQX/uRl2zyDL -iWA+2Dr4Z6h+doMLzfo97VUJGX1IekePp0ObGwhgGbxa2/OVikreW3JswONb7rJ+4/lU6ojheiYV -DiWNip6Tc54+zyeFLkxOGKLPbyux7kLZvczTS/f1eTYbl0yZ1wIZQTW/iRCI6L6DkJ7q81z10V7r -nGte5nl81f8HpO8aZuUBzHF4nFu+k3/eTv6GFsYWpi3MK8q2byxj/pYKAGZHCXLkAiJ4nJu3k//y -Nv4NTH7Ngv7tgv6M2wX9mSRMJnsGc7cXNDNtL2hm1osEAO+iDBn2Mr7Y7SongW5RrfLUUKrlDoR+ -IRZteJxdUj1oFEEUBkMEY5EggohXPC3MLIS9NCJejL+VCIp4SLq9yezb7GRnd5aZ2TsubrzeShiw -t7dQrhSiiYWIjdhZCTY2gp2NjbN78c7NNLM773vf97733te9uafv5149Ly2XJ+2f12fsj3TRvtxq -2cXthfGH8teNecGzRNve27PjE3vfj43abejGCAyV4RFn1KAG4x5yRAUaMwNUuTDNQh5WwQ4gZTFU -LMAnUJmhu6lZgMPjODcurV4JWIwsCbjWBYZAGcPc6BWXmiDckyEua7jZDcM7VVzdjinPuvL+5jay -BhPRirWZGuZGHl4Bk2kqM58xz58iBRpgFQesg032L19Ya4TSwjRMPEJ21b54d3p0zeFJofkOdjqR -kimpOuFzHWSFEMTzfN+bElXHT2lOSl5CFPFORydB7bRPRYGk1l8B7h1JMTTBYBBzgaScFlHCefed -Tn7+E2ymMimEawjxZnZqotrUQ5ki4Z5zMLPmc4OKeH4uNTdcZqS8OJO0D96cGwmqTVC57IELAPZR -DWcE9bgF7x9ZCTnI3Aw3h9DTWgS5Ub1l3ajUTUqj1k4RiFQ1MtgqqAp7HkTuoVqUQSwFzjstIeyz -Wy37+9OpjamwW4x/hTlH67AKu1OBXQ8eN9Qq9/VeqaZ5hansVz1Zsz/3rx+fQGz74In9+HnJ3v2y -NP52sNP6C1HvDBT4A8uJQmyjNae3n4KPkd4+OIUnOwIheJwBOADH/+cL5wuQkxSzcLaEs0z/VMhI -7X85/ag4Zf5o95GnlhRqdYlkP9E1aHNDakz3AQCqA8t5PLNRAZYEORgaqvgIfeTCiH2pQStNGbf/ -JQNCLbSygZF4nPtxkHnJYeYNcY5O+voKjgrFJYk5qQppmUCiJDM3tUghOTEPyC1KVSjPAAkCeaV5 -OZm5mSWpKQqpeSVFlQqZxQqJySWZZal6kxsbJfgVwaJ6IN3FBanJkycuFZvs6CTJpKY2OcHRAsgU -nVzRwzd5gyrL5ANOHJPlc7k373O0mg8Aa7Ax4f0R7Odjxx+RhuoRXeV7uLtHlaW9JTZ4nB2OMUsD -QRCF2SZChBQSLKwmnYrciW2wSmdpa3Hu7c0l6212zp1dzkIU/4FwxdXiHxAU0sXOwsZ/YWNja+de -phiYNx/vvYe3wedq8FKv79M0hXP0UltA58iB9N7pPHhNFpqFNgjKEGs7BwllPI9AW2VC0StkMTLE -CIZkMYQ4vV8pI1dAjiU5BLxBtbFLYGZ6VkljcqkqhmWYsAdLHhxyWCJoz+CR445NFkQVJ93TTIx3 -cK5t1sdnHqUrqLHto9tt3y9H4wmjKZP4dsFmhqg+mA7bj+/DvY3eSOs5a2SFoYbTWM0wTrvnVJx1 -F8fipP352u5+WYxe79a3V6u/fbF1/Q9vNmoqpxh4nDM0MDAzMVFwSSxJ9UhNTEktCsnMTS3SKypm -eD/jYrZkqk6UNktiwNETJW1n+D5+NISodi1LzSvxyc8vcEnNSaz0zc/LLMkH64laFSNiuqde5PN7 -duv666ncKWVzFKF6PHNzU1Mygdb4J2WlJpeAVPsITcphSm1YHtcmHhwhpN6QG6knBFUNckV+aQlC -bZVrxuyNkcZ3V/VrTZyo097SeNlMFUltkV5SZl6KXkkxg9H6rmM5J21ffTL/Lz8v9N+NAlbBCygK -gYZ1SeebbIzvmtG/LK/4ie0cM3HhPzehasJD3ODKdt+RmqMtft2tcb68X7dL9+mTp0zTocpy81NA -KubM6Zo59WNCZ0PO2wyh5hBm3vfhIlAVJSBT4vPBHojPzCtJLcpLzCkGaXoaJuzyc927XVMLfp3Z -u+Hj/+QZfJ4ATZiXrfYDHaH4OZTLXs1mzssvICVRn+PNXJd4nOvm380/IZDdOSc/OVtHYWOgCaOA -AhAkg/hWCmDhyfWM5zjhgpudmTxYAcdtEFn6AjUzYd2fPmqCRlFFMbebl6nAH0O+eJy7zt8isCGe -kSexuDIvOT4jPz+7OH6yH+MWFIHN/xhvsgIAWWAQyfABgVnWmi5vTZ8diPB63KsJMDsLtDt4nLsg -8ERgw0PWyX6sLpsF2eyZADsQBaDzHz9DMykIWe85tpeOta/VYE2QGtbWeJz7+ovx7z/GDXMULBSg -ICe1RCGxuDIvOT4jPz+7OD4zRcFWITEnRy8vtaIkHlVGQ9Oaa5Je/2RtxYs8yDKT/+tJbmZV+sdo -SLKpk+eqJU+OV3HjQ1U92Vq/ZfJaJaHNuqrlZJi6ea4aNzOGEyezKoluPqaZw0yeMzf36TYyohi6 -+b/eWitDkkNx88rM92gG9WT7ck5Ok+fzzEstxwh0BV07hTQzE4VqLpi7SzJzU4vigebH55aWaGhi -s2VydaXk5rslMzgAUS61K/cCBT6cWCy4c7oTsE1GvqAIWi9Fsb14nDuc/CZ5w1sdKQUgyCyOTylN -jS/PSM2Lz0zJSbVSSEvMKd58T+cpCwBEvRAG/CTUBiu83Uqs3KxhQzKAZ54qpmuXe3icm3Se+eNV -5g2rhHgSiyvzkuMz8vOzi+M3TxQqZZnsOEF08gZxFubkCh04OzMFzuZH1oEkzpqdmYfgTT4rxMGI -4L1B5nElFqWX5qbmlRTDhdiSc/KTsyFcf3HVyfY87PolmbmpRfH5SVmpySXxmXklqUV5iTnFVlap -uZkl8ciOgCicfF9MavJvccXJf8U4QeZgcycb2I1ck+3FlTeXiOvaT/4Vxj25P4yVG0nt5slhfqwC -OYnFKJZsPhstyzz5uyOfZF5qBar1mSkaarmlJQqTNz4Wr0/OzysuUfB1jIgPdnRzjff0C3F1dw2y -Uig1M1GwVdAwVLCxUTA11lTQVTC05lKAguLUnDQ9dBuB5gJ1ZKbhkbXFsEhAoRpuKggYTb67UG5y -QTarMzYDtBUM4aprCTtn8r24dM5HDTNLFMqLEgsmT3wssjkh3qgDAKASzT3/jQE0wvK3R2RzlJAN -7tr9dXI0YQOzA3icnVZNbBtFFFYSx7W3IWnixHbbECYBVbvVYhLchtZ2k7hNaH5MksYBVEG1rO1x -u81619pdB6JgfECVIk4kr6paRGmLxKmAWvYARKpQEAcEEqjiimgvHEBC4oSEED8z/km8W7tB2YPl -fTPvfe/7vjdjr15v+ma96Va0ea+oLylJ4ZyqLuiClAqhE1iWI7nBQ0NmuHm8wZFWNQyrTtR4eBBM -5wxzhAszjJTJymjt5U4T7Uo1PMkg8qQVlJSxqAlJUZYTYnKBPaBjOc0jQ8pgLYQm4y+Icg7z0LLi -h9/8Poh5euFvjxcWj7K+s7KaEGW+sikUmn4+FuN4+J2sB7oegze0DnhuaDe8h93w0VCHt/Z+EOO+ -hjzkXcvdtUiFQgp+le3nzF9dfzQ/S3vWxTSmjR/PKYIQpSnjxQwBZyRjnvYdk9I4uUSIsUWS9Clh -C2riPE4aMHDwGbh20FnYgiLS8Zub8SJWjBDaqm2tOkaXS7uJrHmGefwlDWc1NneEO8NgJZd5eCZa -LqaSlQJWc8aEIhnoGOovFZzIZHBKEg1cDg+UwqNYNzR1iQSe5iliUlV0A0Xjp6dPCOMzM1NxYXQs -Pj83c3pstMiFZqJIBA0Gie/ZXIJNaqQmR2WjKgklpTtK/IteCxIBZBlwr/RCMti5YPdiU6AFSSGv -U+STZ7gylx1YERB1IWtoLMcz0Dbs22PFI8Ffhh+Fjy/6+IdqGQpZBIPbV3rC2yTQYFn2zZbyZTfN -n1ojjUetIpVaSpUMqHM8ypzIXHUVKprQR8YGshIjxtAKAWs0cBYbLJmlSp6UtqcdqG026iWTUwWI -EHw474Kn1lsKlUANuKrtCAV0gm1De702WlWH2zruoJbDPysI7gx7pu3uVjewjV/l0d/K4cLwXVfQ -jLarfS3Vdc1rQa6Rq3+HWFc4c/3wv/sDeqCu1UWPK9YKxjlJ58ybp97xHaqfQfaUrxhrXpiBu1OT -UEhcNXvO39kX3EEFEC944N7UCPS8ucvsu/BpGO5fdBSyGl6U1Jwu7GTK6HRqBFjUDJx6sAIZwnrl -K9PorT2O0PDVJch63GtXWuFyZA+ayylUzLhBjmnA4j1tQUrBjQ/2dyr4NcOGw8L97728jQQdV2Jf -2FInrmYwjdILoG1aVfDW0Q7DQPQ4tG/cgj/zLWHbEBCadRVYtiBIaVi9fAwm3m8rvj7gYNUlCrdn -u2FD7Ya5DT/cm3XB8Cmnq1IW7s56wfllO7x93QmdUh+cGfH31zKL8qyjP6G5tg/kATeMf+aFHz9p -NX/eeNdN+T1SbIMr+w9/TXaD46298MVJ5KS/8FiDyCt++Dy2u4ncvfB17Am4ygcL5LtNz2JD//Nk -1Mm2/a+w5FTtzzMIfrg5Yq5/+6LjP2MNBQP1DlUj3gsb42pWXx67S2z23yjAYYCReJwB5QAa/6EP -oQ+QZRR+R1uCD2JppffenH1hnxi+ZZVxqLF5lAEU/iLUlUZtQekwbc0thFzPXbz/aXeTIQIYOzwY -uwYJ0rilB4rRhZcWKHHGW0U3MTAwNjQ0IEZpbGVTaW5rLnJzAKM99fSMGG30iJHKtRn2868mTMqz -k3QC1hQhyTDiXS5HNeWnzu1i3cSpX01gX5NeA2YUcm49RqOAAN+pU8eQtPHja2G6h2uz2AOAAjTp -WYGSVly+IFnd1ypY+U2Kpkb3UDQwMDAwIGZldGNoANIdr/FaW+OAK/dCahiw9Hjnyn1gs4wGFQE2 -CWhb+QzT/4fSms8upgpOfyk8xyvDFCLkL3ic+7JFaMY2oYYtjLYXJqWxTF7wjtUgsagosTI+qTQt -LbXIysoRxHMCcxxzcvKTE0sy8/N881NSraxcK0pSi/ISpzuyMItPDzBhFpou8JlRYtpURr7peUsZ -eaZXTmQUmnxhB8f22RcYM1ihxhsSbXxQaV5JZm6q//Q8Fxbp6QrfGQUR5r9nZOFt97jGCMRM2z2u -MescAQDFrEyH9QXNNwwDuEO0vFosRAfpEaNGLHKA2nicm3+Tac8tpg0fE+z09RX88ksyMvPSFTKL -FYpSE1MUMvNK8hVKMlIVkkrT0lKLFPLTFBIVCkpzcoCCiSUK5YnFQJxZAtSiN/lDWfxky26+zf8T -FngDAJRAIb7wcH2wgVoYvZ1uTuW8+UlldmVC5csneJyFVE1sG0UYlUNSBbshCQ1VSBM6IUq6Gxwn -CNqiTROSFqhQQQJSKiEarSe7s/E2uzPLzqwdNy2uxKWIC2GQLLVSgXMrFJRDb1AOlcqfBAIh2kqI -Q7lwAK5cEN/MOnZURcIH2zvz7fve996bufNLxx9/dmy81z1SKfkBQRh56keUfI64T1cQiwglLvJY -jLC8IPreQNyJ/UggKFB7eYSpixLqkjiL4DM5OYmKSwlFgnCBJiZ8zgIsSBGl+L7gyGFRFTEPerkk -BQNwn8vvur+ubUG8qBvgFEVROsAt5ASMAxdGHcWQNNZRTHAQqvKYCD8mbh7oBITDACwkMAldVptc -+EEAO5XYF4LQgmarEbld8UXJVq06bIW5+W7PqCfHRa5WoYrEToRhbo6KUcwc6FTgwmWJKAIZpcb2 -ZRLHatllBfT6/4ukptLdgDBwq6lxFTm90dQCnrBAIXaVngX0EvEEEkzVNNE9n+LAP0uApy9QhSWB -i5bIloJLVa0NtAoC4gifUeRT3SP0XRca6GEDfEiQWHdM1Rp50/GWjYT6q+aiXvBoitgSUOsnR5MZ -2VV7sLccmmgGcRJ4hTPcLoeG/OGdqcd8D5XDAub2coyjku0wKsiqMBq/cv7sgPz73oDst3dLmuTG -0trGrq1Gt7lgEbcJjoNq87WeSwM9/H4i64f65Mf/tD+hKeAlFgu7BA7BQJwIm9GgalcwZNIWzF4i -thpG9p7aJ79Kfq+dBDl4hZAolVv33B67FEjFOYRvz4+5mE7zrSRpbMdpIgIM1oW+EzOB+Qpv2QQG -sIouCXG1kVGVUFKYQ/NCtzv1MjQjUKEe9JmEcAQNz70g4SUVRXAZBxVcVbw4WE2o/OzHCXnhdvtI -al5COfZIyzKQMT0vIaGg3p2+Wh45OOHEQpBM+wx3LGteKXZMLZpoTaNoJJiuWbLWqsmjBdDoNYI5 -o+enm+Vg93CIhVMifNhw0sLWS5Z1LDVwYRBejohrtEAs6zmfRyqxpvzt3rj8/FquPjObyT1VaIIH -RKAFMMBIo2Y0plxDY+P6Djtvbkue/KZPA3RNKilj4qEVsJe3hE0oGJAeQtAoiYkWM07k449MydqJ -jvrgYGa3CYGMSQAM7xPROMpWLYuSihGyMkHnzskv83v2ahozGl/lOBKxYU5n5VtH+3vVWhGVWOCq -Wwb41K8dzphyb3lYDt3NdbmMksIyEYapsF49acjZW931ja5Mp3z/013y2b+y8kjU+cHGw7J2o1Ne -PjEov/fa9f9f/Sl54+ds/fTzmV55MXpIb6iFxSMZJP/9qVOim7kHTHN680r54Mgu7Q6SV9cPZ1/B -omTYIOWs3H9pf1s+Kz/5cFR+u/7ocb2YnuWdzvzWOTTzTW9aVwZlIr02zEX5xfpYm23KxY0BOfZ2 -/+bKpbnL/TtdxQq1/tGTmaHrVw9mptvk7Yu5vp1q5NzNoQMvAIMFUNOydgi3oSzQ4ZbFW/vk6YVh -2XW38/qeZzLHn/4PqhV79/QEtHF4am9OOaLMGVIfa7jxStb2G654nAFEALv/kQKRApCmOhV7OgMh -FQajDNtHw2+x/+6vfaS/MTAwNjQ0IHByb2Nlc3MucnMAdF0Sc1oLNW1gkxvheCTVsWDw8xSR4DGB -SxuY9wfBZu9KO97cjFHGDeKAvcwycszAwnicO+q8yWXDXM5g5ejktHSN0rzMCs1YroLSJIXS4lSF -pNK8+OKCxHIgWVlsZVWQX5xZARFA4/g4Brm7BofEB7k6Bri6xDt7ePq4WE/eICixeQtnDxNvSGpx -SUBiUYlTaWZOymYTnomiAHPoK1rzHGhs/9nOWC8rK+0txs0+YafrYVXseJxlkM1LAlEUxVGqhUJF -GH246BJCWjJa7WYRSh+rKLDaROA8Z6758Dmj895kbkqI/gFnYX9GIdauaB0JQYu2rYJW4aaWPSYl -qLu5cO4P7jnnvR50z4OXm+0DkJNIJGDdFDZFDtQEreKggxqUmcNBI7qgR6gpsIa6jSU0BRpgmawG -JC/QBlFAkKJdm+OAx1QA5VC2uKQU9/4qNFYlQi+goUJaWCWq7y0vuRvtt2b9wjcQ/n9TVROr0WQs -7j6dRNxwZLiVuX6cGO+BSh7lzhLDiC7Gofmw4J9pTXf2A43KYCMz8IfiTu6XKr88T53u2g5CtUAZ -AjFr0rmNxJC2dSkZUCBcyj8ZuKCMgbC8JAqkvaRanjCOWtyLrBPGpFZyeJ+Wr/UiUMFBEF4Er0Ql -AL0pO7lRyJuynaxnk5qH0ebHkH/S3focce++grN998wiRnTbNtCWjKruYGWVixisQNJ9vQ2dpbo3 -qa5vvvMNeCGjLfsBF+JVqYRUA2hw2lP+kTS93U37ov94nDvEeIhxwjqROa4LGAwEFt/4L+MQp93s -bjNRUGkVAJe8Cm2oBHicMzQwMDMxUXBOLErP1yvJz81hCKmTKlbu9n8vtFzoxzf2Oad2/b4rbQhR -lZOZpFdUzNDDa3rWcJ6IpVn7k2777Gz2jTMeLQAAqdwbp/oNCR1an7lC/6j0cm1sTCwlb1cXqg94 -nHv7geXLF5YNMYG+CkCgr6+vEJKRqlCQmlqkXqyQnJNfnBqfl1+SmVapkJqXkpqiUAKUTcssKi5R -yEjMSynOSMxO1eNSgIIAoDZnkJ6UyQVhYpNr/YU21wWGRE1ekMoyuW61EAdMfvLU1aqCIDviUzKL -k/Pz8lKTS1JTNh9cvVxystwRjskKu00mK/TKTU64JTRZ76zo5IDrPJP5j/sB+byTHxzQRZgj8FB+ -8oQ7EpMdPrJPzu3TmPzhidTkA7sMNj872l4EANuIV7j1BGuH/TToAPKzPfr1XjAy4Ga67wCreJwB -RQC6//II8ggiMTAwNjQ0IEFwcC5ycwAjL9Rxo9XXQu+LsoqQW7iEZX7wbbEitgIU0uyarvr8tNRZ -ZWOBHAxNO3SBs76z7AKGAQ9KH+L6CkdpnWrGmpf9Yu8NAFLERhmZV/N0eJx7eZmx+yrjhq/c9fr6 -CiEZqQrO2toKxZkpqQqZxQqJOeWJlcXxmXk5mXmpOgrF+QrlmSUZ+aUlCiUZQOnUstSiSoXkxJyc -1CKF9NSSYoVMIM4vz1NIzi+oVMhPAypLVSgCqgeSqemZxSVFiSWZ+Xl6XApQoBwNMVsjL5UVaJhm -7OY33K9NBJCEIaKXHMQ1AcwpPTHzE7W3cvyxoxiirZ4emhZrhe7EWAkxeJwBMwHM/osO5g2QLAww -MDY0NCBBR0VOVFORXdg2wxmNYVpEGxt2rMVXaZjHe2IZSAc0MDAwMCBidW5kbGVyABHSs3MsXo9i -DZvkyVlJ2u0a29swk2sBMRQwz8LQSVBBnTusrLj17FVyLwd1+5OwAVoUzYNFRKgICPQ7SjFF1Owl -hxHlsXSTHgK1FI/P1e8B3dLfY3XZvdlfm6JZq6zTk+cCQRR/4SEJynQxjTPqCQB5A92AHNYdFJM8 -A0QU9ZCa3430j9/Zh58YWtAd4bQrdauTlAMwFMpdx1w6kB2hOYNZhPqtF+Nqq1SJk9gDWBTAIDx9 -CbgXFgFMrPcpxryMCJVqvpNEBLIU4fkZ6IobldC3p0AmCFKX0VNkxDKTCgW+FKqZ0ea86/mPc/pE -jztfivKqCGsPs9wFLwFAU4mw9hJ1HOiZcM1PLtqadaCfvJDkg8wmQXicASYB2f6NMY0xsFMBFDWl -ftt8tntPVsypks7XhKwrfhQDs2cBnAEUxpymhxPcjD8NdLYz0UZyiaymFlyzFwNlARRAQOTACY2q -InulnH3cNaD/+fC4MrOQBDoBFHMsUCei1lLL9w5nljRkvJbuYKALs94FWgIUp2Szanw3b/5qSrt5 -v+AJbg3e8weTTAiKFOylu3AtG3BJuVRuBoZfM7ggzcb4s+oIiQEUSALC5xfoL0VPomzNsEA2Tpvv -rWmTMQsTs5oKlgEUSYy5Z+GDwyqezoX7M9gL8zl7tXizRAxGCBTwSXxf7EAszxAJXnygTQ7TWRUb -1JOeFEQUQ9i/hEMNBiUTixRNZioog9FfYtuz9hS3AhRqjAmCLDWL/mwLIH5DDCEEIYh3UpPBF8x8 -Gn8S/ghI+h4RQIJfrKGLeYzYzWk0v2Om+3icRYwxDsIwDACljrzCYoGpfQoLfUCU2MGitSPH2ZD4 -UiU2ngASAy8iG+PpdPd5Dc/3sPF8nyY4XxAMPbBgAlK7AkrucKgQQ+ySWDJaMRavkJgIDch0Be+y -leqGYf1HWZeEAlGttDruAByrjxR46Z/jHiVq6gdtXtrjNn9PPwlbNbLwBKhUBZywoOSIYuw/tu4c -kxhjlXlEeJwBQAC///kWtRewqAUzaXZhdGUtZGVjb3JhdG9yLWFzc2lnbi50ZXN0LnRzAPYcULy2 -6t9X+Hr+DMqdOxLGElYis58F2gVychvU/Q++QhGaSqpoosyHz1Nbf7n+UPm9M3ic28e/j39DEatp -2ox7r+cs+//rZKr5gmV3E5tYtN2jTAyAQCEtvyg3sYTh0VcFbxEzritJs6O0JIoa+dze2RyavJzV -3Hjjwne5t+u/LJeuufjgisdSp+dbPdIhOjPzMksY7if1qR6pPWMT+TjcIsZ+qStrhNSXyYJsBvVf -uIxrptdZ+HkbXHninfQ++36llThEX05mXglDp1xEo/a+uHNCVgGJNVfzHHXzRRwg0kWleQwbvZsT -rJbej7S/sV2xQXRKgJzlcSmIbElqcQnD7XiBpk/3nCYf9OMxsl54+kqw4mEHQwMDMxMThdKClMSS -1PjMyQfY/gEACUtm7fUCrCof5Z3Q07PEHzj0WYr5b/h8YS94nAElANr/0EjQSLBJDRSqZU+oQxFZ -Gmq+0fHfLEWpwKFoqZPvDSOzgA3QFkSREUX7Ao6BchsOHwHBYbTNt/ZjoQtn+XVbeJwBKwDU/6ru -A/ftA7AgJpNeJmSTjiUTAVuTwiYoBl0gOiBbXZNBHROT/CYhsy0n/c914hCO/AjKeOSLfGusmUoL -xBGVbD7g+gb3wXicAYwAc/+NHo0esCgCFELs0xal7f1l1JsEFzPx3hl7BV7TszwCEQEU1YrjrhkW -1wgPW/rGs324kbcGBGGzYQM+BhTp/fkcDyiKka25NpIDr1mPRZzuV5PvCRazyQkGARSxHFb8vcsD -Hvg5qU4kpj9Z7+JHkrPjCoUDFEM58LsiQILUPBiZJN57fvJzzp+Bk3wOkdOwPmvwbbRwtQ4M+zHJ -gjhutPUjy/sFWUhFeJyVVEGPEzcU1gpWQttWVUBZWq26fZil2GIym02FhGabot0KxAEWVUjtIYqE -d+Jkhk7sdOw0rKJVrhy4+Tdw6wGJExL/Av5HubcHnj0z2WzabctcPH7v8+fn93328xcrz16vvGwe -zHpCx3l6KCg5HEswQhsSAGXQ/h6ma4BfrKQ20E8zAW2gkg9FBNrkqRx40GMPAkiHI5UbmHoKOIZ+ -robgOCPPuVvC+mMZm1RJ2Jo6quOESlZu5L5cmHEuQcJ3bdiB2/gTVUgqoQE7DG6cCrRYxXxcjm47 -SkrMyVlsbfWn2f5YhqnUIxEbWrG0muyEg+0+3l06tcZjT4Hw0BGHTzSJfJiSVN7FcY+wAM95Rnaf -MDieM9orrUvXaS/Nqw4GMMqVwy+2tKjF/kU2GwidQ9w2Y9Nv3CKMhVKhbuGQjyh1vxFweWSnLZjh -Ufz67W14KIVbGwutIR9LDYfKJMWRAsT3YJLivNFItcq4ESB4nEAqITUa1ETCIFOHPAvXqqaGDkA7 -nU63G0CnQ+YryTwwusNznmUia+9gsMsoUUUR3j6qDyYRMEkUTrAiuPYE9eH6SMbQz/hAV6azKzVS -K63o6/UC2V/rzL5bvUTKDO4Xj8YNx46zMAw9Rzdw0J0rm/Yaq9sXFzfs25tfXvDS+sSPgdXr337q -tHfbudH+vv71ZwDiqfeF47PR1sZsHqk8e4BYTR95oZyKbK6N7jS7qIpRPyhpeCoXzFFZ66O5Li+T -7Rdk9v3epizNurZ24njsftn8CBa73ld5Ie1E5b+IvJBeOoTLOEEqk5iEG1yaHUGCGDTBuLwBdu+L -uj1Xg3/WZObd1owKfxW7aPQzx+fAE8YiAK2KIgYC3cU9Qzi/9fGwF0FnPgXAZ+POU0FZsBArZV+M -FAb4pnDA3xMu3hj2ypStXa8/aldNXsZXvWu3zso0eiLjR+3mQv6/vfZ59ZJM8tQYIe2fV4l9Qz45 -XzRvvb5RJkKsyoicLvtydsqXvu9os3v8N3FfyIFJaGvZYf9CGAqU9We89ZSE2BfGzuQqisY12/79 -q/Z2V8w8wFenMhcSn3a0/SP4Kj55s5aLc1Xo/3VRzkIu3IJVfwtebR0k5z8AplANpvkDBZ3tluHn -PGCGLWwEg7qKGbTEl/V4nFsmfU56gz/n5CscQhIFRfkFqUUlmanFColFqQp5+SUKBUWZeSWTOOUm -V/DwT07lFGNJslIw2jyDk48FAF1IEv3wCvWSnH52nTi08iW7OBO8CNyol85xeJybPY3x7TTGDd78 -9VwKQBAdHaujEK2kq5uXr1ueWJSXmZderAQVyswrKC3RLaksSLXNzU8pzUnFIpGcn5ubn5cF1BOr -l5tYoFFQlJqWWaFga6egUQ22QEEhsSi92EohWk9PDyKpo5CWk5iuI6igBDQPrKZWUxPE2NzJP8ka -ADIpMPL4iwS1aexKxudLbMblIHncZUgMnKydnnicxVlbbBxXGVbVi1unba6O0zR1jqcuOxOvx44J -pt2tQ+zIbtpcTOKURnVc++zs2d2JZ2e2c2bsWu6yIPGAVFRazluhUvuCxAuhsuAJBO0LvOE+AKqi -pOUVeCkvSAgJ/nOZ2/oSO6nKSpZ3Z875r9//nf+c892P7n3z3fve+qSDLtcd2114++ODD4SBXSf0 -g0+9h05bnmuFvk/cANn1hucHFDW8RujggCCMfBJSXHIIsrBVIyio+V5YrSElipRRAwc19tcHD7Kp -b+9ip7+3l/3jxq5WJxIfrY5t16xfo1oBzatnCIFCGqC6Vw4dQtEowkvYDtA3fa9uU2Jix9HHfB8v -mxV4oq8gh7jVoFZAIydQM4/0uTyyDTR6Uhmr58xBJWowh/qRDX+5U1xnzjCMYptS7Ng4UZlIEM8H -h+Q0mMQO79FaK4iG9UJkqOmTcmgRXYeHeVQXJsBXUFc3F7ETkjwaMvKI4jopRHpGR6PZM0OzqJnY -M58XX5ryt7Stgctl262CdeNhpUJ8xEPhWfrT6Bg6PjR8Io+01zTDDLzpwIdxusGOdB9ujZwoIru/ -30ArSnTF5urmo5j0rdhN7tb8LAieJ69xj5VCYTU85UOKKPMqsaVv5YXpqQsmFTrtyrKuXhnN4jxY -fz/3opP97vqx8QRHWl5aodxVWJledi39mme7unKgbPsQME1Zqhl59vnq/n5NxA5+IZu+ZLtlb4mi -byDtWuhage25GiogDWZqIJx9ttrHHv397q9Lo/3QBYN1kZlS6F4K3Q3VRZAEfT9Y+to9Bvv7ntxB -merhoeMjUQoDPyTsvb0H7wOxOrux9zC7sNbbYZiUQ4a9s9Z3fuSEkc4fdXGD1ryAxkZAKHwbkFPH -DZ0HREAmwEESCVFUIlrs4defeCYjz3btwMYOSIsl62oA5IpYgS5RrOzrZe/0PMze+8MD49JEg0Nl -4tUQO7qyIzs5JTQZqXSujnb+qPMrMLpMqOXbJaJroIVTBmo4YdV2KaRY+rjC7pm60DIJOKLPKAjO -aLKyYJDGdS+LeOdRTj5WwOPljTRzsEwaxC0T11o2YVQMxDKp4NBRg4u52Xws3CdySCK+peSrqSvx -5OZmWrLyXg1tnyTiLClNAtOUQnlW1UB9nbhXjFjgrKFrZQ94zfUgNSQAtAGLNnyyaHshRZ57iVDP -WQRqdekSFLn+FDVAGaaACUFuwgQAoRf6FlEh/s31gZYMPAxdiTlNa2BrAVcJmACFUUC5FS1YbhCt -oGpKa+by8eAZIXi2oCQDbwHqHOInIzRsCqbOtWVAG4N4XUmNK20ybhzGpYaJSmvjfqRIF3Lky0Cw -D3BXK3ntEKgkQnglV7BDSTE1dTx0TRkGWBZcUaWQPKhrwDMEhpIgbOil0HbKRipK/CMemnHwYTo4 -HxC/gAZfuXrVfOzq1VRG4cE12jcoVhv28ep+sE5ZxDmhmBGMeI5D3wV/+EJYiLzSpZtmHRBggoV5 -gIBnEUpN7FcXZ4ZnIf4aD44RLQLRp2mkfzfh53Tqt6SGGOAFVUvNFDrXMTbAVQN1Iv+GEs8XuCMr -SC1cwr1mermcZ40PD7G/rR7m/Lov0mvVIIwT7iIa5dQ5Fw3P0G8ADhIwTOpPk/HMZmwsyBjJibP5 -WAtDF7vHOLtpWBMcNd3AS67e5p1yosBhKj2R3B35w15Ye+p++e3dNePlyFrOxxxCYHKaiRVVwnJt -ZL3zfBtwJ+jYJ7g8CdMFjUdyjCJ7/+KBBWFuaVvmjm9oLv+E7lbrpahSQ+obu2t97Ic93bBq7OlQ -nrOfTzzxWOyUSfiyQPXIe9b74H52aHL3CQVzimwomcC2IDCKVwTfuWRJdT6oSlziY750sw+Pdn0r -Xi3l6NG7WhRiEmO/vm62Ek13zpIaHkxWrIgrM6+zlqVYsJWmyzRbbi2xtLnEnfHqoYhYASc8efkv -iGEzYb1Tjm1dNTfjWCh7Kpa5NmLdOecqx3Uu0ZSwIrxk4HeLmnzsNth2Z2SruHUDck9lHYTei7bJ -uZ0ZjjXZP1f3AQU/tJAYnmHbJDl3wLjJ5BTrSmIp3TXvijzVNyUxzWC/yB1hP724+9m74TC2d/JA -1H1quETl7kMrEwsolJQ13o5htXeNdrVltGQHNWjA0FMU1TxvAYUUmCyAIdFGWCHKjzszoAqSBmlI -+fYInIEksLXrh1ueD7si7C/fBfWkaWKnrNjakBZTwm9LMm2s5UE4/O3zkfaFNnp2BentJdULm+ko -w+3UsxFteQ0ObOxkSOvsOta6bW94u9ZwS6LawpUYosa2W8gkKRGPpeLZRmXryKy5Y2LLEFh2sgf7 -Iser6mxgz+67bSNnNyQ2XnB3QGl82joyu8gZhr/ZGZvJms/k6v/SVD4nCNJyMOy/y196q3dF0Wc5 -KmgaALfAM8dJb2eXapB7G7bJ2LJIg5Os2uA6BC8qduXwhubWqmG3Ssq8HWQfXddd2UIGbdSZIqz6 -thhrw7PG29KQTITce4g0bFZ7bfZkSmKnLVUr5fKddVTmsS17J846ogsSIecYlh4qDa3M4C35q42b -EqHN9rHNLPts1ViN3BkB8QYqtxXbRGgAbcy99CT71+ojJLWsGgla5jc7Klq3e96Ab9qhYDRZz/QR -1vPLByKqe6aNzXZ8JvnfXz3Wv/2GS9BEclB5bu3JL42cEq1v93TtkF2unH9k9eMDpcut5JhRbo8G -6rgBzZW8eKg4uJocN4KJg4PoPNRlGQe4UIAsiJWiQjAAldC5GqY1dAqNREdoIGqutByQOXmPwF8N -m52Rk5MTY5df3H1pYnruzNj0mbmxy+DtCFtzDPb5J4cPrNuszvetsJM4f7DZWVHn0ajkeXXdKMCW -d5EVb+QG1YMiAMrCgVVDOvF9z5eVl1475XP2xo2BK+nH2tRZDvf5YieMj7XwKKuAlAtcBdCqqw4L -wS6NKzUDGndGsmzZe8e7Wdi950F59pfvZLeOP86+v7Sf/emWVozk8eP14+JcfQgWOHUzIcDQzNgg -D44nfcgnM/98dH8erbOIHbt5sicldxikXj5zaeqluXPPX5hoFuYBNAM3h9h//IfY07eOHYhlCzBO -cCt1Nrn2nQ5FO+yTm4+fjS0JCA1Sp6uWz1Pt8fMG2eDX7EC09uIIogJgqA3IFxTYD1hWy7NXOvrZ -jxudHSql7P3PuthbhfvZqed27Q2WoAoD0UasfzuZqlGUy9wfAVPF4S+i9lex1CK/WWKn/tK9j1dt -pupFUB6NklgYLsSP1Oz4Ud8TZp2jSh+cOjtYFb3AGVhfzwls68Psq7f654xiFCy1MRJrUl6QBd8P -LRDSoABFh6/R5Wh1hzqhAp82DfgWKAU3eUQd/Wa4Q+cxbEVn1OlLC1594lKPnwCdx41nY6iWeOEH -J6MrDCjiy1616ogDoxI0tkie4wIYaJ53Cy6C/RfwHt+nYSsA9hD5rXg+4l4hq+W5Fbsayg2sKYTy -l7piO2AN5FXQTGR2HvUmX6Nvs8mSm0K3zquNC4BUi39ZYlRFtzcNWkm3lZd72L9PP7pP3XDihswL -3yP+pN7HOt3OVjGjTk/GnERDLk/nONF7N1AqaG0UcdIzOR2P29UXn3eDkRPnJnRBYikOi6fyNkBm -xIR/3KUWYCbSzd8ojWoQdAjS795YhHpD1Zu8eCARptI4pqqvblMKvLPk24Ho92xoDwFi4qI5wPUG -lAaqtSCFqiOEb6EbeCFHnxltq8Voscyoe5DjQ/wT/W8LSl1cSY0ml2ryjNsUz8/T4vrUdm2YW9Y7 -8Ph+NUlFRPyCNezJVnI7xoOvLGimr9LS0eOlBmUJ/LQusrz+ZLvSTEpU13yizmEgJhiCU8XWctSV -DCyQrmUFOHFo4XocVgmR9WeLcB2IhTl52ZWy3651PZLBLCMvHwXAPsy8z17svf38qQGNvV8/Cjje -xdCtQ+yPl7tXx+xcOCHvuSgvVZDg2JYdOMvc0AFgYaLs51wTw4MzNa9xwTrY52PYm7dC9vrNn92r -D7mrfZ/evOd/IkFXiPkDW0AscXqU/xvvgCyn312PkJamHW94nAE5AMb/nAucC5BAFA6oYbX32lXN -bUpCNo/L/0rEAJJ+sVRUARST5Zg6szT7GmPN4dbzKcVy9YfKYLO8AeADChkcf/IJFuyzwygaQqAk -TIlgbffiOusvENd4nNt8nX3qDfYNF0Pq9fUV3PKLshVyEzPzFBJzivMVSjKK8suLFUKDPF2LivKL -FNKAuCQjVSEnsyS1KDFHoSC1KDk1r0QBqL4kI7NYIS2zoqS0KFUdxMpJzUvMTdXjUgCCktTiEr20 -xMyczLx0DaXijPzSnBSYZt3UvOT8lFSF3OZ3IdvfhTAenQYAy743YvmJBRVL+rQVT++ilsF/esaJ -xw/iTsZKeJytWmtsHNd1xqwtiqJESrRIkaIo6Wq0qmYl7pBLMQqzJCVTJGU9KJESKdkFteLO7t7l -jjmcWc/MkpLpzVYJ0DRFWzi5aMZJANvqA02dxpBrFEWCFHHdP0nQAgnQ9kd/uDX6wzHgFk4B1yiQ -pj333nntgxTZdP/szsy555x7nt+5sx/8ovmDj3a9/MWdE4aJJ1Zyb1W+1eJ8c1+ko7LegthHUzJY -SyLRwqaqaEg39LimWDbKqxoW+1yiFSOHgSYeVy1DU+zggbGmYxOeKHH2S7axZcu2FTzPAN9VRpKJ -exeUiuzdsaPiUVlZRaP8B9x1Zf5Vq2JRMRVNw9oGunmPxwa3qN7ukH7kf57s3K4+vp2QoSMFrRnm -Mja3pdeLVXpVGtpNqbJblXU9Pc8OwCesayomiUwxGytmDmQgbJqGaSVRlCkv9iFpne+jjynaR1Wq -YLPPl9zHuaNyDI2dc7fO5GMlW5AWRLtgGmvARywoek7DOTGFFAtlDd2yQfgJC+VKpqovoayGFb1U -RCa2FVW3XHvRXVsFtQgMFOu+nkVGyc4+YaxgB10SYqKndpypDUSe6RFaYGtTTvtopMt5ui2CyLkf -7W5SikWs55xFUzjmfP1spLVpzsguY5v88Ku9TyOuFWiQNcwcGkMr2LKUJUz3xdddBJ3mQAtJxKtY -ty3ZvmeDUJeOPDA7nTdtoWmGexg4FE0jCw9lrK/KF25dX5yfmptffHbm5tWpm4uXJ9H5814+iSO+ -4tx8ksj0R0XFshxlZ6SLpH+7CZ5x5STRshXT5vZBIjrtBhUZL3eSq+mzzvRDYQ+ZLreQb6ajAiL/ -rBwlH6bbyCfpHtKqnCSDyqEKbFczLCzFQkYLPp4cRlMnJzbSYIlnPcWCMB9DOl5DU9QttSFmgelU -CCJNbMgm2kgdxBwPfkdjY2PIDaqGdAidd5+7qow0putAKInSNY/Icu5ghSrOw0JqqCD/WIxCNnQI -Bjf42DeNFs94bsi7tMx+kksEu+DqxWI1QuQGUnIQEaZxX3KXhBeQ9HcOF9z7claxIenq9MgqpaUC -dc3zOGur4J2taRJ8PDs5/b1Ct/PrI5FOJzUSOebc/ZLQQr7/6kny3cwZ8ujVZvIfmQ7n8BNCV8uC -Vx82ycBuytINdpeaxTsm7/y4O7Vpynnx7y1jG9p6tsVYrr46HDlFjrwRI/u+t8uZ+i3hgMpLHNRi -ExcN08bm2PMlXWUCg3txCEUa0WPwLd9b0cRUX1B10nJ/dJ2lSzndh/iVq2Q5HRCS/n2nKm7h9G76 -1ueJxPcLiZS3fPYyeCowyfOGqktzNi2fUk41Y6BlyEj0EhQdFmPBcqBdkbzrW3DDKmoqmP+OHuQi -vleEKJFcTrBR2DK/oiHFfsjM+tazql2oqRCxGPnGbeTMXhH2O79MCsmYmkcStWrVkqDXwQK3/BD9 -kyOV2fGb49PTU9PhylCrj57bTJuquggRLdvGNZYU/XfDj+7kTkf7fSFl97tCtWXdjpeZxo07XDC5 -q7gC4KotG43rAgrKK0rRJ1z0KLlX6PM6O3AubJm00Id0ZQWnWOulv9h+p14oKRp0Xi/uaPSyXYtO -+38J+yucw8JAamEwRekvYJfpQoLdqrWKV9dp9MMelTVFpZcvlFQTSyIkwODzlhiTwaUW5tE4axor -KrSWvNUgYIerI9ZLoiBcw10cyp6atZPINkuY/PxId4VtZK6k2tAJXJ0Y3LHoLSv4yQPF4oTnEL8X -lZkzqW8Zn5qM8wy2CfvKlvm7vGpE5BVVK5mYxkqwEyYhq1jYCxzvmnIOntGlFRPXJmqV1lQFV4Tr -WgCndSsaSobtNJQblWlk8YQwOn1QgqnPXVmOckE42EOTp0GXhnRxHq4I+8nLd/eQVxJ7nPwzQk8l -wbtlg0QPaVe/mUSDBWGaS8oqnsb6EuRYYmPKhYFKSo76tWEmQ/siAF26UYDJUkn3OjdTMgYZRB2b -5D6jUBRMThupxcA/YN9NRKW8TdCfUTdBK5Ch68i+X6Typlz84OJIuNMIMEGx3IagRSpowtApmJaq -g72MsPYkONl3S4eTeQZ+/Ojo3vyt6p1v1z0Dj3GPW5p4HdqsWPIAqsFPtAiIsce7+fGMKSA6U4WI -HsOb18Ky8+hnwgHS/o2eiUEx5Y4vBmSzblBeVgkiX2E5DkozH7rDjedKf4yhLZEkhk52cOK4Zii5 -uEfl/MaRyGdJ26koeXSuZUeAl8iXB/Y7f9sa2c361JJmZBRtvqBaMqUAMTPUNZcMY7kW0m8OpTI4 -D0P/uKbx8L4TBgP8AzNZydSRL7G3XqRc5DV/pMVJ9AodZBS3ON9rjbTnN5et5MFFVDQDcJtsiaJ6 -3sQAtgetLQbLRNDY+UpbpLOJj+/kwU+Ok9d/0Ftrvffeax7+FWa7/c63n4rs3lermNP650J0iKPY -lRKUeBYLJepqKRYG4SWdhyeEBqUGDPrT7+4n19JDfFj7/bRE/kU5AmPaHvJp+gDZqxwnQ0pXYqMh -rcGAxt1GfvBnXQt17oHoNLRVXD/R8FEpPKwFEdmgBMVGSDpzyPmrPwIfL33rDAD/BPko0/1rdWwg -wkuQAIyNv5ooxzvJEzsOko+/E691z2hr80T1GGD5Ntw8iLxVLHLJ7PsdZO8bwwDqd5KjZzoyPqYv -mphqMyb3u7/YEcn/He0viHI/izjywyaJdI62k7F9h1toO+AU5P3fO3zKKyGPx8HkhU8ONXsA2PlJ -QRA7GtmQPak8zkktAeSonyN+pSmCzRDz/hBRP0FsuQjX1B2RvPjpUXkLtTsU8HSJ10cAwOB7M3mp -jm+Md6dpyOR56ChSLX1VBm13E0Zmp1uKqC5Dj1/gVzy/hoU2EZOheoQad4g6SPAa7erW1BWacDRs -AOML28fxW4fxVSD+wSsd/28gvu68tmqrG8L5xLYlsVPfauNvGXZvC9ZujNBj5KVPD1caPPBh5Tax -bJ3xfHS5sRLnauGs7PZHbyOb1yUfPs368AkqMQbGFqLHxUyzkxYETE41UNHQNAuB8gjqNTO2RU8B -iyW7CkaxY2fy38PHTkDo5cQUG42z9G46up4txxkzb5PpmPPzD4Uep/J1YV8re+IdkjuJ3cKhBGJ2 -4+M1H3vOoYVQx6T3+kLXafLoL/rI1dd2OW/dFcR9vKMyLMCYk7/+cVfFPwWGWzRN1kwwqSTO3JpP -Rtcpw3IDyBVeBI7zFk3dvLnZIkbFUjQBxrg4mQDiyhaoBxn14MasITTSwb5TMf/Miv9wifv70VWM -iwhaGsobJZP586xFT08MHSP/vYx7Pm4bEGrYzEKJQSq0KA7/kLWmFC2ZtL3xOa+H76B+TpF/HYmS -vaNd0GZPVwKJ84UQ56wBoEjVFdsw4fdKBsLO8sRx87OA4kZFqs7kuoUhXDpYmEHNkNxFFGXqFKPy -lTFn5ajQ29l/VzqfBD++BG556eLkQmIwFUs6349Eeiqcg2wBYyl0KtMShBF0CU2xr4UDLR2KCXp6 -GPI2veT+DF36DkunYq4o1x/Oh68IreQdWSZ/19tGPj+603n9ZwKaloJXcyhnsvcsGSW7TPPLgpTO -uZnHOyhAQwyI7p57BJaFFgChzSxmqfoyedjf6cixSFNX5r7NTjSG0SmUGBgccr9oph2PMo7xsJTQ -axqoQcBbc8ZzQjf56eljt+mV6ygf/K1vkED3ROhKRVBKiq4zFcrQvasiVczEGa3Pf5xtZ4v8p65P -8kQI8SyTByefcWYvCm0HmebBqzYEaJCLIw9/c7/zJxeFbqd0WdjvPJsUDjgvfk3o2AulQV3BICGJ -PjMwMEBb4e68alr2TRgdNZtOEt3Pja4aau6ch9PpBVNPxvdAKYCsBaxLXO/Q0gDe1zR7JTfHQ32M -vJ/tdD7+pfDkZ/zgFv23Tpw8ByNFjr23ojh+Hkw1ye+ANuTBaqfzp/8onKhUjyIus9Nj3mqZf0vZ -QklfBk/T7o+VFd79qw4wOCh2E0XVs1ophy1JlCj2j6FwJMRiwWYvhHcbMCv7v9xh1VOsVi9YQz4u -91QaWq9m3K+uam4pyJdAsRJ0NI0lCOPDaj4qKPS1pa5aBZwbcR9C4tB6hthoyFKOJZB9CBqlXO8q -KoC5apzjs7CW/oRdtU8WHG7g2uAybxNl5+WvCaPdAV+oDaGAcBKDQqcz/TdCc7MXD+StP+ipLNy9 -o6dO3dH7IaBrQQn3lMbORtyGz1P/NBpqSAozmzvp0FzSPSQ+D5EgNVxgIlzUlCwF7zS/mQ4etOAs -yI0LN2gt670KbnkWQJux5uGFEoURFBbAKKobJShtBiCeNahqHAFZsH8FvAKNB26g2Zm5y89xkOH8 -098LxwxomYNVL6dvXwswDBsSGlfLfA6dUH1IAlf+e3Du2s3K4xFeHkPnQ35ppAnv3BAifeTp5FPt -NJLmoOpe1mEg0BXNIkfFwS5Kg9bAwsgd+JEHOzrJx+80VWidppNf7WKZkdFbUDvzueqspIvcGnih -lM9D6kBvNbJ+lQWv3BOr3xXWC2B+nbTnqJx5d3cS5Vy1zn9jB/uQBsLpXFVxEy264f4xRSIP7xxv -p/R+6aVoxHl4UThC1N99qpe++Jucmpu/eWtifvH2tcWZ64tTz12eB7ybEJ3Uu8LZzQtyJafYCjVZ -jk0YCXQ+nGEo6V9BDjWcqxospPU3GWbj15VJrKkZDFGJtfsIgPAqnmN1gylRVIuYVxt6uFJaKvjR -mES6wXIZYjkLoQwBmYXiCiEgxcJFZYGnlSMYwrEmrqEzbgD8pXlfAdBk07/yeLMgFVpVQqpyEwAH -tfpYdJ1+TUAphUCw1CXwNtzjm2NX7NEdHe5x/rKlqVksxYcGPnc2Vk7759JXYYb0Yp0nkp9swC2D -+RlQDnK+CmO6SnnMeTUir/9Dz42GT2pmfxbBNZyqVecLroPZJUf5SBgixrfb3j6/+z8/m52ACYUd -RpfMLEbL0BIs5izDVJcAckK3An5qXsXmCJ9m2BTk9haKmwI/wqpsyTTpoUBRK8Fqi7qtv5/MXu8Y -hqmG0euAjxUOFYtQE/vQWoG2E3FVNe2kXYBsF703jyoF2G+/MPl+Kyl+6cDZnGotx7NcXXWFut3y -9NhEB/Jw7Az5t9l95N25N9sRPSQHBnFPPmmeP9rObxm6dj8JkjMaJsPzw20+bbZgqIywI3SNk64Y -SvsU0HJpNHOTdET76o0Dowuhm6mglV8o6TJ/EAy01VoBmHRe+0Ohhzy6fIicm27fExZM3rzSQ4zp -pu7wHwMmxicuTS1OXJq5PDFFfme6pyXYE5Gv9pLKlVPd/h16lkf/AVWEvgE1ifxi+sQVnlpUAXqO -TGeCK3Mz12WLHYeo+fsSI2bHE9xGIj27ZmInF6+PX5uamx2fmKLH2GT82nnyldPHItF10j7T1cQ3 -TtDUAdF1XhnloelTaFmzbdl2El8QOkl8aleFb7aOlt+mFq17QcK5e421TrX6Nyqcl7ugxpq7AnPy -o9eWtz8//5xAXrrR3IeQLFO6YHQMmz9Jz8m9R2XnvS8LCdJy+zUy/e8Hv/ju7b9897bwxx/8L5EA -D3v5D8xxZ83BPmzlH+kiDxYcjGqu1VsLeJwdjb9Kw0AcxxEcVOzSTaT6BUGt5KQWuvgGIorgKEIu -d79qanIX8vtVzOQuOuUFHDo5KYdP4uzik3jp/vnz0yzmn3+b4aW32AgHW6+riSXliIWsGk9GI1XQ -IxWsLFF1PGPc4Pr87Aq32MM4mbS/g7fwMUhX2n5v51k7i3TGBqpMoTNfC7RA7glF7h7gp2DRtcpi -5xR3JBfezgu61CVxpQ0dDqGZqRaOThQ1yiUAFwmLrEFKT1VXPYpgipyXXbIJurPeNrVnjpppTLRy -6QjnBQ1J+wUVqt3pevt+sha+h/v9f4PDVrj2YZmdUeIpBkz0OyvBsEJDF57tFSayeJxlVEFvG0UU -lgXqwVQoEhEUVVSvBrW7wVm7rcLBlmsg5BCpjVET0YNlxePdt/aU3ZnVzKyd4lgGIaFeOFQR8rUH -fgBSD+XIqRJHfgtXDrwZr+skvXg9M+9973vv+2b++vPK76+v/NHemNdq8HUuQCGLNBx0vtk77nx7 -tN85OGwCE8DSAUdhYMySHEEKMCOEkdQGJjJPIkiQfQ9xwoa6DEBQnlQwYUpwMdTABjI3NiP1gQsj -AceonoLO2ERgBAYJ5qNMyRC1Dij/fPWX9Y1/3j/7ZbrxqZC7UuFuGnlMDccN0EYRerfnr/+evbhx -fW5Pm0sWD7jITyDjGUIokwRDI5UGPhQEBI8e7D/cPzre7Tzaa7p2UpZlBAMxTwwq0Lka8zFqwBMM -wQspx9vxfUswlIIohzJNmYigBVy7SnQCMG/D7TzhKTewHUIdbt2CjNiZmP7fh5pts6YxiWsWMMrT -7LioR4GuUuWzLyu3HVTjLaR1gO1QocmVgG6lNuCipkeVKlS2r4f0KajZ9TYtgyCwU+m9/O/Gr+V5 -ggb0U20wPZARPmRPpGqAyNMBkTiFXEQYc9KlWS7XtrbAnQMJpjnJLmM3qmU62Pzgia4CRdRhMkLn -C5ot1yCkwAAOrcY0ckOeQTA8xWDxfFravCtWpb9bInv+Gw5Tao3H4F3iePa8/eG15eRtMo3dfvZO -0POb5cWLcWnzPbfftj4Ozt75fHcOMz/QJrLua0Cl0nRTvQRLOBlTGveF8YouAyMPnaM8vwp36j6c -nkLdJs/WQ7+E0izP3LjKsAVfQT9CHSo+H2CALBz1wbBBgnZ4/a5gKVadkLnb7fUhJhaMbHdCyDSk -ETOQ5tTmkOy3HDflAHWR5cYWsBIpd1ut/ZarQooAjtbyzItNKwcXVgQnETeavH5eVTqnmnSHtcPv -p1y86awfQN/OtSMecxHJiW5AzBKNfRtvr4fVNrf6QhFQXTV0r+hoQg8FWuBMIQkYcWOL2goQMiGk -gUHO6RGx3ln8uFO6Ns+FtYp+zM3Ihnk09/OcVlap0v4ULrAjOY2iJ2rWuHzSbsBASiItYEZR01m1 -TJ5zeqxeEKcLLT52q16357y49JxynBY//Vb6YG5PWtDtVga5oOtFv86GvV6zsK53kRP55ybXxcq3 -F/lt+8P91oUe/aIi6iDL9cjrVmwOVRMSCtvf7PnnnoFVOFnx52f+q2d+6d+r71oyi793Sp9stlrr -q+0TAr0CuPjhi5J/dXktAJBUfUU7r/F/S2cIff8BY6ODFszvA0ZN3XD0q7U11tFalJJ4nGtjaWOZ -YCqS/Gax75rI5YEXT8iFpE6TqTK1evhzo+deRgDQqQ3HrwR4nDM0MDAzMVFIKs3TLaksSC3WK0kt -LtErKWaI3GpS5rDUT+1KpEpjNIu6u8fdyRImBkCgkJZZUVJalMrwOTxA+ZvDd7/ECp3+K59ba+f8 -a5MBADz5HmbyA5a0fpJIg/MDMeshjSkwut2IpEj6eJybdJKl7RTLhiM2bLn5KaU5qZMPWivyQJjx -Gfn52cUggclHbBwmK9rKb2a27X8OABlmFLHxAgbmtsrtexTh92N6PLlLfRGpS8tUeJybKTJTZMML -NpEXpgIcVekP11UuY9jo9+HxF96qStnNf9hkmQH2hg6J8R0yEIfUdyRzkzVGH5VxnUJOmRIZjHic -bY+9CsIwEMd3ndwdjjrYggRc/UJQcRGX6qIoxPYKBZuEJqgdxFfQR/Fp3HwVbQstiXVL7n7/j3u3 -Xu37Zj+lih6oRKASltzH4t+B4uUmzOuAq6jCCJkqwHKg7TIUrhDEPAKLpdBjPr7prg4J5UAlAnlg -+I9sp1/Di0BPrdKtbQToIiMqV3mcSQVMC+kZh9RhCAzP+ezxad6Ybt0zT8lQTUpEjILGaFvubDGb -rKBrmTVZpWa13w++LgniHblE28l1Jx76//CS3rpJdOBH4odSpLKdqXsm2PgCaA+oRfoLtLCvBPuM -ie7dVfjRAM/I3SD+TgV4nAG6AEX/pBekF7CWARTBbpL1WOwhKE0aQL8mCutNVGO4UrOqAQ0BFEqt -HYROSAy9AW+CQ8VjaK6Hxpkfk8sCXBRKv/j8gthfosyBPJ5hUF3lmU0FprM7A/MCFMJOFcBnDmvt -phP8US6W6wprhtp5s0IGtgIUiacbWeJix2qUNgtCNvl0R4wM30OzDAlkARSZu8VxLhcucWVTQ9Gk -/7o37vndh5OECu0UjafK5AAeZexX6ZaqPdcuhZpr5/OThQsfXQxT5fkWKBKDjoyrms6k5T4BzkD2 -pPRSagh4nFWQwUrDUBBFIVVQNxZUBHFxeVCwkER0Z6SChSBSSaG2FCmlpMm0pISX8t6kWErxIx7u -/Aj/zI0fYGJRcTl37tyZM6/Vj8P3ox1TrRy/DIY2BsJxOFRT4sY4l+K/EmUxTUkKG3/aTEcbF5Pm -sjNJUnLLwmUthsP62R4giilSIWfKyWS6hCbO51A0o4g1ZMjJgnCeKcQ0CfOUQc8U5Zxk0kNtJuwi -ItRLGaHYqdG4wapQzL5VM5eWcwWQXHhYwXXd4mhfLmw0e8Go7zdb993RnR/4ndtuu/M4agcPTx7E -hcC6zDSpdXIKaI5JqUKfJ3P6Xgas69el4c3qmc/KgXG3d70+jVsJ4xdFb1iiUMqMMc6TNEaBoHL5 -Q7R5kRYm3qp/AfhzcUez/Ad4nNU7/XPbNrK/569AeXdTaiLRSS+XN+ec2ufIiuvWsT2Wfemd42Eh -EpQY86sEZdnx+H9/u/ggAYqSZbdzc28m40jAYrHY7wVWcVrkZUXuCbstWFD1ScV4RR5IVOYpcaaL -bBcHnHcvYg0IY+Pspi/+v2V9EvNPcRbmS45r02I/Luvlc1pmjHNzdTBP83BylwV92DHmFZefl2Vc -sQ9xwvBrvT7LQ7YbWeu/5HFmzxe0mgOEQWCc0fJuLM5DqzjPeL3A83bgHw/KuKj4znQRJ+GOBB8w -A96rrD1LxvPkho3yLIpncMq7ghHryyktq5gm1th5nifBnBrUdm0eiCWt/dI4pUmSBxtXhqzgOxqy -hWDJptdx9fhyCddaHLEqmI+S+BT4uhGFABwESWwjeEFIkKfFomL7rPiQ0BnvN0Pt7z/SMmRZnM3q -ifnKCKcRm1Q0uAZ8LIPJIGb2hALdSCyCtE4a0HKWv8fpw+wmD4TsN564XHCbW0LS9wR0HnRHYNq4 -nueLMmASw4tokQVixzQPrmttcfMbVpZxyPiuVqt/1JPfkyG5f+jtGsqF7C5ZtSjlR2BssEucnYhe -s50kuUlRvXeChGYzpy/nb2/XALx8qUDmOa9GgGYBzI7ijIXGMK5ujYvF/2Qlh8MA6u/+6r32XjvG -3BmTBwc22Vsn8VRuvfPdX9UCWq5Shx8GtFQQSdgBEXpJEtYAb98cdUO9fWPAoTSPYG4N6Tg9ueNl -nlcrR8a5H4Ed5yDdhK1M8wrG6/1xazGi6YM9JxaEfVITNkvXAGWpJpPRMJ9+WQOmZhUsfAoX6bp9 -1WyjJ1GcVGtg1ayCDflduqjiZBVYzyhAjCcmW+C7mvnCzxZZFadszTzjwoSsWTWmCQ5oMF+VRZAC -uLVMjOhF6AJW1+Doj3m6ig0Fvyg6p1J+ExzF2TUrV1etGlNGeboy6Hlebf448vDuxYPhKJI4W9zK -IOMW0jfstmOP4IgwNFSjDKNR7SuGLVfTA08i15luxIp2rqBLehbQH3BKjqBCsQ/tNZjD4O3bN83Q -NIaRWbaoRwRR5+ArYfyMJYxyVs/JGIR4wQMn9hI4h/4udq3NsT0LjFMMkSMP8r/66Pi1ZzOTAaPv -MHCcRG4QzTQneiqAZZAF5UvkmRm5EBLwaIDQCEgNpA57NbDtn3cRrxdEOrwplywGwaqa4Rr73WjX -2spabEAhGhvOwgcsvJb7JKExjCq92xkLxQE8lt14o72zgxN/fDw62R/v+2cXk/MPR3sHE48XSVy5 -zufb15HTUw4c8xFa5aCBJ9MvEBYBAWgi465bZytCfAI7odyMnj1P2gMnP/yAkc5LaeEqGbuXGU0h -37yhyYJd9cjwe4ID5CVxhg78FeOShl5jPFJQKBlILkshF5DUJcw7g4hj8jAoyrwCAvISPW+uAqUz -2Pc/nJydH374lz85uTgbjYffqQm1DAIXn+vFwC09C4e9AUUc0EWVD25oOYizuBp+ZWW+EWKQ0tsB -j7+y4ZtXf3+rQbN8EILBVGyQLZJkUED2W7FyAI4uuOYGEBp7UA3Qe0RJvlydoUlMeVwfLuIU9sTd -aFnSu8E0B1fE25ODqqRFF8S+f3B0+H70yy/+3mQyBi6dHE+Gr/Xy08Oxhnt/cez/uHe2Pz4e79cA -8G3v/dHY3zs5909PJoe43D883h+fjuHP8bl/+HHvYCzAr94pCaKo+Z7WrTMIayhH23KH3wP6ll33 -pGOttdID9QpdqWWoQvKTByItKyhkqrnrfDz0D8bn4+N/+ntHRyefgHCnJ9H84PEkDlgniJewbFbN -1X7KMPoOOICdHfIJypuKZSRfVIQSzuBMIcFoR8ATFYuyyDn4RioVuprTihTgvCuuCiMOUxBuAbqE -AgryJRhZIlTMiVAFFpIwh8Esr8iMwXhGpneAmxEWQoJv8vAkmoBk+V4WntKAaVvQpunj36VfzWUa -YIyXLKM+ozNW+mBNaVx1AsBZZsxPF0n3NMQWVt6w1tyMZQyUFPAmCdhSazYF64CPCjVaSAugAKL8 -CMwD0Ffg7NvTYl3IJNV8zWxC7zpn5nnCuteIGcWRxro7gQRxQjE3ACUUP4P15uV2UD4r8mC+iThg -nS8cxo2KrA0YD+gNKCwrpZEpDcFYYPvIUckSFQ4GULmzZFjESgCDAdjXEFI0X9ZsLFTj/2751aHl -V0faSSkvNqxd578XUz12J5heWz+GrpouZyBIgAWfkv7gaz9Df1d/A3pRFvV3ziAzoOBAA6DeWsVu -WSAodZABeM3hwpn0WYAsMotvwKiE4MiIULDZ0cuXRBYzfTUeIHIxV82ZIJSAlkENX8UzeZsAm7oi -XGECsEAnTMK4hJOo6xLXEfGw3nkggjOsggDY5BrAa1hipoD3RK/YJVW5YJD1kIlI+lzA3zPWRop1 -bd+IEPLew7XL7p5X5ePfFjRxrchpLugs4AXWTYsj8GCulimmWBG5lKV50Cfqw+2t/mjkNh1Dt7dX -PZVUKZoQZbO7HPRE+AKWoWtA3thECaosunAfQZeOn5YuCw3C8SIOjM/MAVosKsAVAyVqXxeRiq0e -Gg7KA6HJPUpzbZc9UwQSAarcowhqA+pAUMfGnkEwhrjJeHRxhnHYXNMRiFtS7wgzmHv3aiOjMn8n -Swi3GBEbowONxiAGcQsEAPaUPs92BnkUbWE/v8detlH/yysDJ3AZMKqUWOSqXPK/58F/lds2j1oN -obaxVLaP1U6tEOJbLV1QSFNujU7C7mtV0lKGwFKCTgvYVhveswtd3rq2AuRZcgdSL9lvC8j9B2m4 -ZEMQGYFEF1OdWhuEbL8FDwyeelHRKcQ0IjI1TJsogVI7Y0mtRqdncPJz/+P+p/Ez1QYJaetNkxni -HkMz7MkpX+3vi9UGb0zteYrf7imfYIvLoqP3jG36RPH7I9C5SyKa8LVb/55tf99ppNjsc1h0d3Os -ys/nZb50HQN2KEDVAK+5IYadToUENb4eQL0bQ7qSQtnaKCWCoe4xVq4oKKbaGPuNhc/UPxuDpYZI -Gmz49AygS1wC16qsDdWWIL5J0GPYIG7byETxd3Qy+nm870OpdHh2cvwRqjsdT7AswhoGWRfFZVOl -Q00D7krUPPqyBvwgo8FcRQWSw5+SVMvc2+yJFGmPhSbL72KcQLerr0w22BOiHzccWmNT/VVMHRDt -VKYdejqtaAuBrUco5NXG94jMnuP3rZyny7xX2LjZxAUZTmvRRlvXt389I82fLRAkHGDxyLGOBi1D -R06sCqAvEnsWC30LKFTVDHA3mUujjEv4w8gnNv05lmW51OUQ7yCf6Q0sEtv+QN9gtK5TDi7wsmXf -P907GOONTEu51SWpUPAu53FP1KanuKcev8JbOuue+bJW1/UJU8dtdUukK6n3H1MStIoBrdySY7VC -ruOK4ELb0m2uKDPvZItpJHay9zTe6KywbaLGKZ4c/+ur9qJkqHGVs2plLS9ubLdWjbpU5o9jYpfH -MK77tzpUOzvgatVQvjm0fYNMN9kAs4KBzDfRQUAu8F/mIUxC2w7iUooOGJSX4ZW8NxHe/Wz84WIy -nvjjX6BMOB/7J8dH//In53tn6OX7Zn5bsmjB8Y5LbuPjNjLpxRuTJzoWheQEcEwQxWYN+P/sXdYU -+BoS5fE8L7TKwm39c1fx+Tx/ZB2wo6rs4kMHmMUESSNazKmy4Q3CfpZbM9yluc0Gb9cFvVaSG1zV -GrV/mt+SKU8b1VAakPBJtUeSY91+TuVBG+ndTuf+EPKF8trU21nck4lfy2z5JA2euszjEJycerWm -+P/bN8/lfE1ozoeCEBELYK/hLFvgW0264ElH9rlSQEY0hnoHykh8G8oqcDZMhQsMH5rDOnYsqRE8 -BP8g7ORJCDFGuzh9g0w5ttM96wYN8Q1q4faVO3EytmSlRx3g3jf/QPZ9/zn7aTLyRfbpp7TgB0aY -//yqmZMlP/LwEx7tsOLY7zei2XuG9cPnV+rt3xFbP2ELsc4MfZTLUnlNk4R6KNStB15R5jfYcdFy -M6sa3jcSj46bE6kN+7LyMS6Q7tJpnsiXi/XHwMi7Na9k+NXeFU/bYbk0rwOEUQFDuRVPRRfHFNuv -fqI3dCJ61EZ5yYDp/Zreh962mygjS6rc2nClDmzhahPYgocFUn3rWwDxNuQK+mVzix3kgGlpAWzG -FlHXkE0fj4xtAp6A0JUsXVIwJmkRoAIBrHy/yDxe0GXm6o6XIIWjXspWVxcwmc2RIDFB0UARjSKU -JgqfOomAv4KEmsmeAMNn4ivdygIV/K7usVVDvAohlURNjIumcQZGWVnaow/qbCoFlAv7ClR03IKc -Q4bpoDz+aZmnMWf4BuBeIhc8ucar2G2FB9ZjsN4eQ1wsvFIb6hYXfOEukFaJBriu9xYHR8Vp2n5d -MdZr6MKeDeu6QBIp5V67Hkub9X6OY2yhQ5fEukteWe5BukrNAYVcOx1TUeWY3MGM+5abEu4Y391t -l7yUV1uQ50sXD0qPJQQBf0MOq+a1XtXx25t+Ow7eN8eWFKmv5vnlRMNlk4H1amXFzarXgmtG3Go1 -xGARk7CoEl0NMlzBieZoT1guFVWcxl+BHxAI9yZUmS8XIY1jn4O45Xtm5QN5cxVHK0WPqLR0K1b9 -YuJhqyIrRT6OW4n/vxkOu5t8Nhe7ZivbPsSFmSPLG8pptn0+/vhj7qZYYyXX2zxESbY8dh/YcRu4 -hjsPjVZ4/DouDiO3/hVAz8ObWhfvTy8dGgSsqDiJswQ9JJFii+FTkBexiHqXjtD54NoP5tc+ZkLo -R2EsEy0wEQ47V/2mVVJ4ysumlNcNMIA7pVUlepzWYo0MpHIbe5fVje3NBE5iNn3JrbJVNPbugEio -hZB/z8oBD44vZN/AX4yUzZfNbrLPnPcJeGkuIt4TTEUtbhsJtlDCKkOjmjnsmNQhFOHgKNjLS6L4 -Fhw8k+K3fqwhvSGukyHo1z99Izue5y/QiGg5w24k58//67wDrwcgMdgRfIcJRz6n1ZKV9xjk6h36 -iExgk2wl3/6Ff/6cfQvLPhz+cn5xNvYPP56Cak4ctNX4RZhn7MWvtWusf2TiCrrIq/x//vY345T1 -k1J4KFlEHoCU1d+NPPpshywyH445rG2xT2L1wNrAX3lfOOjMOibiasnEnyYnx57McWBVnY2gToDf -0cKoU4ZbGDX3rKWlIZANfBfOjf3kkid137j8WreGy69197dQiIdmJ2TObt0QTJTVAVEsiWqCBCDy -dVdc/FBccglmUYB9sjLj+K1BCudiDPLgo3gqacS3BblArVXsNjedxiHIQolPANezLdnqiQedItVq -skUG2M7/BJelXXkpq6gH5iMttfMHH1LqA6UDYIq9WiMwXwFmKrpF1icuNvXPq1qKvqtdgUoZP4Ma -6SN15Yer2aF1OfifygxVsJFgMsl3HWkA4Afc2qs1cLmda/06IH++V2APxNWyVdzo/Sp3wWp8LQrn -OwUNy1TebT9mqrMr8tRm5AdIgCB1bF8Om/1hkObIO9Kwlf/UF8G6L+5ZSY7C3fjvNVmJEPi97M4P -abnEFsj2FYe6A6l9rdad+y3uRvB58jnX9NtnNMYV/Zq7IH3FsnJZb8pD/HKGywS8+SlNH4QTB3Ny -zRhMnp77EHD9s/HR2Ukfc1PMwqm4In2mmNTvdTqEhCyUrWTi9xENU41UwGTiZvYJbC3GiSBRaMNa -/2uip137tXbpt343cm/+hMnQqNWLszXCbP3MySRuwzv59mQ0XBlnoWzqrtkglEc/CExLij9NOIdi -bQQK8B5StsOsyptbEXFrM82RBs5FDhnQUt7WJBxOE6hPBbaRwkf+WwLODz9BInoXBIaka52VfaJq -a9ntnWE2LgoiMsUEE5KenBhUoOpiUhRjQlXSOy4boFQjuWxifaby0ogNNAK7lsqe3W+KT2WP99pp -h931807Lf38Fbq2UZaJVHmyre7ndTGH/UNTFVztcbrbqmT+JMHhyZRdNbURRtIrpqutxR1N7Kbr1 -HlW7ftOpbdwqrfEaW5zOCsZm5Zdn6xp3JnsfxvgsOPq51QDaXm48kK1WkJ1MNbGtf5MC5q59BV9L -Y/OUtBeGYKh8ovYvH623zQr+cWWVvO7aCOQlFXYb/nch2NSa0z4xGuz/AcXrMoL/AfvMl235TA8P -orWl98DifVYEfExCeJx7wP2Ae4KZSHS5Q3+B/6Nfe6KO8/6qv79p0e7S4I1e01gB8V8PnPd7pco8 -Jsw8ifBy25fvuSlx+LPmDT94nJ1UzYrUQBDGgx7mARQPQhFEEshmT16y+IPugoKyg7MrwszA9iSd -nbhJd+zu7DrMxryCMk/ik/gCgkfvPoHVnc7PrH/gMJCu7uqqr776un7c/H7v4+lM0bzYTwVUkAie -g7MkglEpnb1RmhdcKFiDoJJn57RzYTymYUHUcugU8SyjkZoootLoiCwyKv1PyZvnaxgLjlYufVCr -gsILmqjDUu3TKCMCnTmzBxNeiohuGfHA6/O3zageJSWLtNXmcwXnKgSpRMpOfUjSjPaW0jBa04P1 -CPAakwriPmz4m1TwwPjCtt8a4sTYVIbgDAp1fFjyLKYCtwvBI01fl3xtMFkTKax8E1mapO0xXoxK -qXi+c06ykm6+XHtUa79qr4NcWBYRG6MXHamu17vkNF9QoT1+0wx3Oihm7mPiA3aaMkytGfThGZeq -WSNEzFY38U14QVUpGF6xGcJ2EeSkcN31kCeoPHjwcLjj+T14LKgajRSVynUYnqKqLGMQE0W0UVCh -UiprnZWkDNSSojxPqVJUAGExyGYpV/mCZ5pp12Tsu9vhHCbuWXFNA6yo3UbAQY7JgjgVPjhBsIv/ -4yBwvKZXjhTR7lsZ7S5SFqOS5O6Tko0b2EFUFI51s5UcLt5iFqsMPDEU0veFTr25vH6nBki4ALcB -O2UkR3k09fm2uDnwBKYm6tQpijTGKtvwY2ui53iwM/etu0qVkWTrf9Ta7YW63TNX5p7VukVoqfMC -xZ9ypjtw8K4kWUNa6xVwU6N1QErctT1v34x5Iy9NLEuP/umhEdZwYqEFd9e6+uqk9zhDivHmPoph -3GhhNbiPHSxzhqH/CAMaVU0acYQwvUIsPtWayIkxQlCixDfptQnalelYNarwa7UqKIl3OMtWNv5V -tcKS4CbjrTi1Tkt2xvgFA6Jw/ixKDISTKM2yGhKSZlu6LSWCB5QfVsPFCrVqx7K7NRd2lB03DduO -MY0CkbLHC4rveYBpxswl0Nhfm9VTE6s2xuUr3D7EimZsQWLj9AS/xw1o4zJjjymLZ8w0oBoMmn89 -sIkZuG5XD06AAda60aZF6Qyfx1/F9y/pGXF1sg9M8Z12BrqqfxHWf8jK6Vh1tKZ6SSUkk72mmu+w -xEJsPly/tfl64/b9FinyH/6qlq1WON4cg+ge/ARqk5gq/AkcMaQvpzXaexZzNXeRQBJqpUirWXic -myx8UXij6n6WmPyC1LzknMRy3eRMvZLU4hK9kmKG0hP3E5UN5QuumG7Z/dHi+Re5jBZrQwMDMxMT -BbjyotSc1MTiVLie1skqs86d1NRr/ifPEbA81f1FgnPT5rss/5lFDm2K04oo12x0yTbh2LGRLevI -/AsrJn/gUBFZmtv//t5e903lmq8arkWf2iDOktY7WYMzGwCfSUJi+ZwB2aS2jmSXao0N2NZmRly+ -zjvjOBl4nJ1Vz2sbRxQmpJDG0EPAbgo99DEUtIu1iuUGE5xKh7YJhYbSNKaX1NDp7pM08e7MZmbW -cmrEkkPuAf0VhR4CObfXHvs/9C/pm9mVvbIsS65A7O7bed/78b337e+nf7y98e7Nze9sap4WPBUD -EXMrlHwsUjTtDYCLL35EU6TWvTkma8ItHjx5Nnfi/eubL248ICu8bJpBGFC5jYSEgdIgyXiMUEjL -h0NMINGvQBfSTH+5vVkGIfT6SwMEecrlAddDtCYIw7Ajle1YdTDSahyEDyk1PMkxtsF1YNpgdYEE -RkCbHonVKcFY2JEqpp99uDX969ZHP62LN+CpQYLlw8dKBwMeWxNW+Evhx59ulamQxUl0snc/ygqT -sjawysJ1NrMdAjcQK2lsCKdU7roFP5c8w8NmDg7OIVkuJGoDI14SKVLNqCNivlcJdl4Y0DhAjTJG -5ls8OW/zpbPjgnzLj/EJyqEdBXtNXiSO4Rle7vg5eRrxGzr/r7D287XCWOmjQarG0Jv+udGZvtvq -lg3Q2Vvn+HVVUcCqMl5FFGn/Zwn1L0ETa5G7kPssXIVhMnWE270gihpoEEVGFd/oGIGu7hJFqrBu -XSLtV8SEq6Gpp/sw/eeTu2WsskxYmExWOrUkERIdE1sufWC7e53ubqfLWuQ4of+GRWMD5vZPY660 -ddS9LIRGQsW4sMRpzo0RcggxN2iAy+Qu5JQ1aiI/wTjlmg6ZI5FPf9jaLCsY6PlJa33p8E0h6AL+ -tsd2mT+cY9JjXUaDL9KC4Hpsh/XPj/dbsN2AcLHBDWSPuXTYvf5Fs8MkgLLGpgP3Zifq2wq3cW/6 -rYfLB7PSrqCqx6/BI0dpcOobgsk+dNuzSugeJp6L0slVUI3gSZaCGsBzXwdj7cWWnDVi52Ij5rKs -PKtMOnRJeYxB66yfrTbMHn69zRMi1zlMn25+XC4pijKbW2xRMcwrNaiYoj0ivV3Y30o1rmzWWYqs -nKvDyRNrqlrVGCFpnvMULQL1rtYXAxkBCjJ7offNW1TrK9OAbSgb7NW1rhXtmpGWclL6py+IkWYK -vrEGEkXaaSHjNh79/4iNXXIxGxNFQct1oi6b2MuWd4dda2bLS0G6qxSgWtoVm7x0Lxp4pe/JuaFb -78aVThd8qEzUWukr3ZeIVElQrFFSjTpXEvOQh+Hip3m95V2QZ/dFrgPdMW7Iq/SZl/z3/37w94P/ -AOH4T23/TyoJFy4001ejyt48RSFZSv+NUY4FeJyVU01rE0EYprWatvmopYUuVMp0FclKskEoKsYe -kpqWVGrRRHsoQSa7k2TqdnbdmY2tVSIeevIgDvTsQcSjkGMviiDeBL3qSTyp/8F3s0k/QrV1D7vs -O8/zvM/7Mc8vvZx5862nfyFzPT+bKxSbn3se9zYf9n3olbdCv5QEqhJGXCxsly8yax1Nowq2OJGZ -/q1j2BbyY/+rk6gL1FwZ4D23d2JJ2ydyIjwH3hYxBEeiRpBDGSMm4rbnGgRh16jROkGUmcQh8GIC -WHalBWVY+GeZbF4+HUrJzbA6C8kvI+F6BD1KtL5aehDBY9iMCyCsEvCqlj2WvE/Kd6lIAiEZ5OK6 -wK5efaCmB2Vt/HSIrDlgKi7fjp9q5O552IqDNR27glYwmF32xUr75B3XrlMTzE+jQF1vR3jcqFTb -0LZsB6tbtMw1XdhBiuXSQbAG4CgzLA+kDsMCFNwIaBS/Sgz4n3OxU9N0ZgtgZkl8T1e6iRVqBQlm -QAFTFlcLrdY0UvO4jguGSx0xY7skBV1LUTeVWSwWjBpZxbpJKup/ih6kWfaoJSjjqfaaENPPkZ0I -wjlWpYxAVRaGMwo911e4zVT5VSmFWrkRklsxffyAoSZa51paKgqSvwe3W2v6IpyQz5QJ+SkWbvib -sLsBu0PtDByGupTLXssX73QuRfcuBCzhrqONthkT9lqQI/Hk+/A5+TNsyoXIRfkkkpbbkTPyW+S8 -jETzshBdkq+jkzGEYHNzaySu+eXIL9G6nItpIb8u/5/HqsN7ywiiP2Jn5cDQlNwcU6qdzNphnqDa -TiTdLobABT9iRXJYGWvOD13pK+67j6pFmbeWxKvmhSnfp1oKprK8gXZwCWQJ+y8UOPFpcmPk5vGE -T5EnRid64fN9RNsJTE53S3PMOtr/sAMon9i8Mfou9Acmqax//wZZem7WtSqaALIdwKfIJFXkApyR -x3icAW8AkP/QAtACHjQwMDAwIGJ1bgDO2T4yvgDxbomhbcEmPNQ/4NgAyJEeMRTU2/WRH4JJ7cEA -nfgfWVW+ekVJS5FjNBSs3GdltHeevbSEjuX+6exfT72HNJGrbxQjRRzsi2vvG3mNnir2ZC8yMejr -nJMuASLrbTPH8hwAfG/gwPS25oZRw+YMhfrRo+OQanicAcIBPf7iEuISkL8UMLsoZ0FMaCdLK0OG -56XarOvBHY6R01IULHrXSuxJiED6Ssj9tgleyGpzcxmzOQHWARSp/IBEpY3AFngQSrIWz1X7EUcr -u5MjAzgUkXufQ4ZqXaGLq0QwgVnpqqUb4xOTbwMnFOJHRs/ksmPyUxwblF1L+pnEEeYck6oDLxQf -UKxkTSfaG8V5KC2bOZ0pc4v+fZPtA8IUVIu9zCJpKRrElylEFtpnSrDWDcWTwwQtMrtJtVyYPoZg -lg3FYMWDbsfFNKzwNDAwMDAgbmV0AIJv/yok9YBVFTKyKmAUycS++rcukyIFcRRfdyo5qczUM/m2 -zGk5MZRYDw6c5pOnBS0Ug9XdBO0BqyeqXbIXo2mitdNlskGz6AUPATT2GEZ3Ok/l9am2xUqYErMH -VCpeMjQwMDAwIHNwYXduAGAPXMi4gow73ie8CMTMe362CPG0kysHmjOx+5Owjp4Vs/XtkSA6c04W -RWGp5zQwMDAwIHRlc3QA5868exlrz9U+4Nrd3RkiVnbo+R6T+AdVFHJAiC3LM29IDbi6tdlf3GGC -PG6tk2EIKRR6j4NOLDCyBSu9aUuClnc/r5IIAZOeCMRNScha+wHhLa4aPqlg4n2ZNT9WPHADVy2O -HnicARsA5P++Ab4BkKoUCtczrcdp852BqGxuknSTpZ9oaui08A3o+wNJH4YPKBiOCQicItlKhH04 -HprH83icATsAxP/aOdo5sLQOFDCQykFYjCyQ82eJhikKX9W0x6vNs8gO4gsU0AhJj5FU7p9n3iv0 -VDcFbVYafu6zvhocAlHvG236AZdjzh9e0HM0KAw2kLsusU8XW6kIeJw78Jv72G/uDceEJ691k2y+ -Kdx+U5hx+01hpucvAbf1DROlA3icMzQwMDMxUcjMLcgvKtFNLCkpykwqLUkt1gPiEr2SYoaG2O7M -21eSjtwp8fvr/5650URlBx8ADmYVg/wFQHNTBpVEXuykl4pjz3FrObxVygp4nGuYwbR1BtOGBDUu -HYXUioLU5JLUlMkJaoosOgrVtZMb1aZAGDWaKmJAhkJ8fGqxb35KaU6qlUJJUWmqAkiN6GY/9TZG -Hj09PZgJOpsva+gmAwClEx88/gH6aWwm3tmR1qfKrnJUMjejwmLLGHicAR4A4f+9A70DkN8UWr8d -vPSy8AZd4NlekzkDV7fW9H+R88rsBhB69gGOBunT1twRtxEBCl2MCf8aU/uW/3ica9nJ0rWTZYNY -w+SEo2yT539l3yzbkD4HAHJACg77A47JHvPmNdUVsYOyITdVvwt6iChxeJwBOwDE/58MnwywGwEU -/vZwZ4MX2UZEyvWEpAqj6BQP7H6zLwFeARSYKLKsvwsswrnf4f+RqbSaiHudgbOhAn4DKS8cLPYD -adv9y5hXirsRnS2hO29dNpVz8Ld4nAE2AMn/5gPmA5CRFGyoESEpnOohNL5B/jQdOk3CdzpTkBSx -uRkBFAfFiNaTNc/rNeEBwvYPf58ZhqNQa6IXY/eHArD276Ev9C3TQ1HZ60PAP9esQN63eJyNV89v -HNUd1+wSp0mIccBeJ0DSl2mUzNSj8ToGgtY1yKRgJUriljgUabWx386+3RmYnVnPe5u145ot4sCp -EtUqPKFeqOBUKRIHJA4BiTugRuKCKALEH0BvPfTSft+PmZ21DaoPnjdv3vf39/N5333zh6Pv/Xn8 -gwvGpIOibrtOkpXmb19Yvhi3O0FI3njK+Ogpw/A+77cS3PEpoj5OCGI+QZ460YBFg6C4iTACoXYc -Xb6O2nGjGxLTQZaNFp9B24cRYoQyyxSCoD0VpiDU7EYeC+JIqBCflSyKI4+ARzGTK/SLZpwggj2f -z/29cHrw1tT0VT9mrvcKNStoHfSrv5Aw5OEwpGgRlRey7cwGyFiRjbbVoZmZBSlBu21+rVN4lN+7 -WjxkwxuaWURWhG6iwEZn0YUFlBDWTSJxcAHtpGo5MopTpZg5SltFRytfOF4zZvnidPHQoWpNH+Cn -lorH+X//bRwxnuaPRcUT/P6mcWrw3WsHLiqFKsdup0t9S67tYQgIchZRBq77OYte3I0Y2oFoLb60 -ZZyrp0mxbbdBmrgbsrwKkURLRBzJ/MDjN+h8Gf5gOTNj6/SMGBV2lEfSlmXzOAbPP1kpTo/JjzZ/ -67ZhDb46/DC//bJxjL/2n8IR/uCx4vjvtRoS3aqA28/duLZ2+frFtYR04oQNW2w1aBOIxJyDdknP -dCm5CGXvJgmJ2OVLq/C5bKId/i41pvqUNeIus10WP0esy9dXrrmUJUHUCppb1lKS4C3radttBmFo -ydBsWwc0O4tWRCu1Y+jgnk8i2W6UQF4bKvWojV+FnhTbaceco8gLY9oFkVs4CXA9rMGJKEZhHLVI -ooqCI0ZdaYNsdojHLHCRJInbxszzrdmbKx0WtIPbgBVI8K9mW237WTckUYv5Koo/BMwPImvOQfP8 -X75RvgbHFKwSghvKoVYY13FIHfmiXRH4Ad+HqKEpiFQ4AUNJN6L83T8axwcTrZP9BumkkAFPoQzU -ZbgFvWDCFyFrohm0urS8sO7o4pnSgz04U70ohBbBx41ukBDLdGdT/bkWUidZLE72TfHMmRnFrezl -Edx6IaYUrUJyWtBB4KolsKvBaDK5n1MHQNjZi3kRgQI9P/SlcdbfVpYk+DEVFqsg7AgfHRGSSAkw -D+kpw5btSsM195UYimQLK9oDKT6DTEc4IJXm2AHxjbeNR8aEdejcv9w2TvZlLoEmrKiiuVYShmpf -u1oTrtRU9CptUidND+9zQDFGBV2V5V8Wb5dkQ3pk5LQEPndqhYcee2IBBQLr24f3kA4/dqBQ4j+i -wvgTS8uAuZaIKxBZtbOKqn6QhGDhHg5SH6pBjb9+r1Dq626xhwzkCplMgYpJaShnuwDOSwqQ4nqo -k2asr5mIbGoTAK6ApkBDqBErX8Cw9WQ509QHaAOrQJKVIfgs2FycALKbK5fXgBPQ2bPo9N7bjlqp -xjTenTyqf1qgDAISyctJn2BGklUfR1l0ENsqRBJDOAkViAQXMUM9TIeXqCiQ5J0goWyES3S+aBh4 -xJqTdp7f6OLQqkJMDkr/1bQxPtYyxvviQhA8l++zkQK2ccey1hxxwUEHrrfObAc7jkanetGMoL+k -UFOvZ7ZHsytM2Tvr2gWy2ZeeDy1JEIAdCcUnJSdnYagwid5fyIeuFLD4RXILMgdH7L3a5vbTNQHb -I3KDI1OmjTVLOkiTn5Nyl6RRSTaSQnntm8JJQZj85feNo/MjLBX9DEPtwj7/6xvGRFN+czLT2qID -F0/YrEDNA5r5s8SuxLhRGboHtxiJcBvKuLaWroGjgiTd1EtNMPMdzHzwTxIVfHKQCVzASJ6T87wh -CILff9AoGc4AHywVbPko2SMUU8UOqsPAMfjUL/G73xpHJjDdijyNSSiDnDwemRa2h5hPK4n5d/cK -J4w6v/uZcaYPatwg8oBMc20876DzDppLG1hSlTL9KtkSPVc1ZQ5hPjCzwdLUeRRLkUnxBM1mbUhs -KWqByK8TZlVxtQ8KYRirV9XTk09whcLdrOeJ+RHg53wJNK1Kh3RK9hpLT7nCJ60y2yP9fJkz6tst -qmJ0dRPsUvKTUuktrMuwr1A/lapmYsOuyrZ0T+VLJJTKvqvl0rMD62ywx9kEBVMLbgIFajoDKvaA -DFvAcclDMIxoUu+B3Obgbx/OjME9DhTP1z8tnBjM3hibN+OImAvrUv2wC/d2tpDSjT342n70l8L8 -vhehPWzSB4Qa/g9ulA7/HAKyR43/6WFjkp+6URgbD6Fmlr7ryrVB+Z9TB2RaBo/fOHHQZL0YnObP -/Lr4+IX8yayt9RzkBwlwF1I3Z/7g+V0q53QeRsSbcTeRedgrP1/jG0eNyect29EzrVhJe2KhJEeB -Jy2ITILvw4fYHMQfT83rH2JM3FXMT6Bk6mbVhqGg4kGhcbKLWv444/dfKh6f9ZO4R3cPm/peX1TT -WtBE1gtLl664Udzj379vTJ5O4nY6zMGclUqpdpJC/NjdQumgbgZ+844xfSWfH6ENPmzDgN4Dbk26 -wIz7056JRax18Q9IQ14rQv3rpcK5shgGpabc4KOBk9XfDdrCOQk3btwxJl9qCudxSrOqQL+DvYAS -F34nAQUxuOit6r4q7LRN0nyAj00Y98lg4+upftpKIxJDqs0quq0Hp4qKTOZNrjMw5dSL7OwX2/nd -ZhJ+4I4x8ayMz/u/49ulpsa/rxSdN9/5wvjonS8K0Xv/A4EVIkf6A1PQe5KsOZ3nSjiReF/zQFc2 -FRqteJwBOgDF/4EMgQywnQIU2I4/p2I33idE8EbOAyp1cxsHzvGzsQKPAhQuz0X84BXZ+xN0VwrP -Uq7X070HqpNUBa3Z9xog+YsCKfk++yc9J+9viEElI7V62w7Dy414nO1XS2/cVBRWoVRoVKmLloiq -D07c0tjUdcMq0QxD1KapKKraqkGwqKLWsc9kTBxf177OJBqNzJpNJfwH2CCxQvQHAIIfwBoJNoWf -wAKJFec+7LHnoYIE6oZu6tzHOd937nce8+lnR37/9sjXrVtRi2PKTeOD25twI4tDPADv0AsxBY+F -IXoc3B7HBFLuJjyLYdAPQgQXEuRuEKEPLAl2ggh2EeMUAp7CIHHjmG64YbCPhg1uehh5YFrQfReG -xdOz3xxlkYfFtXMnP8R9jHhqWJ0W6H8ei1IOHiZkqAsXh+9v3r3jpDwJop2gd2jyMF2nPWs0eYNn -SUQXpJfiq9XVXHntZZHHAxbBnruL99wgMRVuC4aVAYAQyWUYEJbNwEcbUkz2MRHfndop5SilVXIU -IzEkQhEOdNjMukXIiX7IBu+5Ye9ujFEbeJKhXT9BEXR9wjscNZcHScDR9PpZtGsDRh7zibsNHtnb -dr1duiCdm5YTZ2lfHbQ61b5J32TxJYDi86VTFtSIEWyB3lRPMSYpw188PL5werw7vqV2Xft0MAAK -v0NC2WTeLnJzbMEmUEG6Kf/WVMFxHPmM9qxIwMiaDq3ySSiLRVhojREUXTjz1t8xowAVx68ax9Rt -8Xnn6lXYOMDEC1IsNS0U4WdCVKWuO8D7SAdCRoFMaTUIQ61x2Ga8D6nknDrFTysXcnfgBhyEjE3l -yAYjRS9LcJ1FETkwGrjUcSFRs7FO9oVshzBAd7cttfQRfd3HnjbrPOy7kR+iZes0a0tMOYFaqz8s -3c0Iby0rRtWXEHeVrF2NpUoHEcWp9PMTRhk843SPYkPHi1+XzxU/rrTyJjO4nkXOjqdt1iAoqyWI -a6IukO3FxXLFEfwdHxMiPg/Muno5iWqxXJtzsbKra1NXhme8X0ddPFs+L7i88RwuxfevXLg3bJKw -p8DZdCBEN60ttWE2T9KuVcTHfii+a7eKM6+eyhumjbbMImPSQbk+5UZtjJZkGPAgpkUTDwK+zmRF -4+Q1sRzOrqO5TGdE4rR6LAFTRxlzqrLs8DrSIql4j0qaTBPWgwfy2W2ZcVuqcsqe8ciFetcY31FM -VDdgg0j0gsinAkH13MfZbtbgHYPIJ2W70ecMkrbho4hIInoNZZwxejTRU0R9enbxzeKTm6++LL6f -XF6g/4wr1HzEn3+e5S+i41CREpXb/M9bjS6M+YtqNdpY8cXSif/bjfFv9QYplCo/pt0KpI58QCHC -8RvmU4+oU6ROv0q7LvDDGCnHy9eHbrcLRilig/Ky2mlXNjsT4pKpIAJEG3m1PpqhaOQ8lCX8wdY0 -JUXHNA5oaKRqxRKlG3lFKVCurjkECGFtTVZ1qxG1oJeDqSnVaC42SFnU6xM2kAm1ISyahhfEfVIP -HvCKJAzcFCImFmIiSBV2hoZEQRftZdy5c63TqnU34YE5twaOrKl3UjJlqQyZlJQyTpKSy01IMo6e -8K09mBPbSmvKYH1nVPtuzCR2LYh29Xqj4pfV19/mYnSS6lNmq3o3u892WsXPK+dzzUnH+D5jXE4C -0tScbt7sy2Kao2ZC01oZcfnT44r8tQEfs23YlnGVLUrIVpx8nGEm2scgpxbjVJaV1zHFutfJvakh -goDcRpd8CgeVaIJonyZIeUHjKEdOkZSDTsD7LKNZKIuiCXC39vbQD4TTCeb3ErZHs6tTHDl2MhcK -WpwvIbh0SSMv8ybEaIfGV5EBy7OEX+vaboVZNO4KT11kxW8rC/oNFex//oL1AOrppXS7x/yMflwm -eIXKZnIInIG7zwJfDxQ6YKaeKQSXbKcv+NKliIJOj5HGYnBPQyZG9acrS8WXq5d1jxlOzHQJpizc -R9nFrGrGC4cNddo1nnb5lnKomyZcZUi7+QbSvKb9qOyXW3I2OdF+rTDaC8UfN5+cU2EdNhxSVyOY -WciLZcPIq8FOrYlxbuNx5obVPFBH3pwDasjryxXgB/MHM2Nj/dqd9Y3bG/kNQ//S2FL3y3YoRTnH -gFViHtPSY2jtp8fz51Xh7CiNra2/AKZ1SAn8AWdawlom6bKU0XKN+4a/rd97XZeIeJwBHADj//YD -9gOw4gEUStmu6Vf42Nm8hRqzX1aWk0lp1EfdYg8N+vsFnN3xtOO/FmXPI7aV4wnO0AV03ER4nNVa -a2wc13XGjGWKXInUgw+JEiVeDilxR9pdPiRb8jIUJVmW6lhv2Wksci0Od2fJkXZn1zOzohh6sVaL -2rVkJ04n8UUcPyQkatMGbZWordsCRmwDBeo2du0idps4keEfTdMfCfSjRQAXRXvuax67S4qQ86cC -tNy999xzzz2P75x7Zt762xVv/sPK689JxzR7zkyjbMlMO0bBRPqFop52judK04Z50LjglCz9WMkp -lpxoxrCSyHYsw5yOcTI9c8rJFEqOGFfRvPt4cZd7bm61+9pUx92wJBbBPVuk9W7+xb/EA7rU1BJe -ibV/ljdLZfdQunsTEWTGKpiFkp2bQ7mClkGaWXBmdAs9cMo9MbthZbpg2g4y8sWC5eBf/lDuPDg0 -OIjKMRQ9E0OGikb3oEk2i7YhzUbFvnmjjLJWIY8Us5DRk0XNmVFGJtWRCEKM2XktV9Ipr+5aXnR9 -wtaLZIW75k82b7d03XQszXTilm4XciWiMyWG5oEfQgqZm0vkz9pKEvXj4lW5vZLRi3RghIuN5tEU -EjIlBujxOAFohhAE5EKjSEPb0dRIf4xtILglYa8gtQaUQyMKp/KZJitVhFNAOOwRmroNluAcJ+Gw -VEQ7cbZgmFFlwlTU8oRZK5YNTMb75tl3ThwD2tTIJGec1wyTsnV/ORvBrz8iN6G0pWuOflJ/vGRY -OgpZJV/IlHL4/S/IrW7k5e7Ps50sTjkaXhllMibyuqMlSlaOmpL8y+kOYuc5rJvTzgwsHHR7Xt66 -ttZg+P2fS9vcW3/Yvhz0OTGRyOPENblrZ9VqLkAUrBTQk5rgx85ROrz3OWmTG/m4I+LZRnW/9+QG -t/jpuq/vkRrx5pNSowosfNfgHMCuSlKBz+C27k+/sX5g4RA8RaOMRKIaQ8qOJHjshOnuTa/fk9Fz -+jRoKYP8Y8LXLPyaAXtpsMssBBVTZQYBB9iiYM0hw8zoF9w3d7e6ebOr4rGJ03Hfs6d1U7fIxICt -gybSzMWZa9gJ4awKmVQ8b2VnTgf91U6ABBkgNbW8TmJMaJn8ViOME/FP9+PZ9cRxlvdotq2D/wX8 -hY0MEMxJO8oIvnJZutfdnVHco99uqHhhdjuH0xXhOnfmcEyKBFBpuajnLCcSA3V0xW0e4xpSwztT -PYU9zledCk7c154DfnHPavG8np/SLeLHHe7PlkXc93pQw2Omfl633H0XuttKpkBZVDAPA5DCju7x -Q6hl1jIc/aCR008B1kbdYmbdsC8tNXmCbBmrY1ruOmDdrw9J7Z1MQGJMIq7HBMQFF64s1YU5U4I0 -I5Ey/I8YoFEtPRMdVzgYgQ9SOCF/Z41cJq1ZGSWlRpVFXL5CfJ6oDG2xAVYd3bTJZFozM0YGhglT -lvfsGa1I/XDeywh+bIyK6dFRLgMaYx50hnmQPUDtUtTS57RpXUFJHigVpimPpaNZ0wBPowRjPfbl -AarbRN98YBfvhGQnMAVhCTooT/rMiJcAZCwgHRUoGZAoQCQ0Suh6CSFl30v2ZLIoLMtt8mHAU54P -BXj6gNztvvfpch5qdhKCjfNLoqAz8AOepTZk22yrJtmmQM6ljMsq+zseVhI/CnApmJOpJPr8qWNH -E7TcwF2zckslZIEYIoqgW3h7L8RYBCdheudI1rMAlP2/R7K+3Lyv6mkjO0finOQrPz4ggwUgrvxZ -Qa6FmtLzuN8AunXs7qs+BAtFEPb2GLc1gHE1fHgUAqPPCHjZgoWiTEVgTB0Vsmhc4UoiccOMpqRI -PUvJVBqIgJPwK12yLJAy+uCkj4a2ozlGGvXNE3bgLADrpADIgl4g28O3oqWfN1iRnTdsG6TzbTrp -nuhsw6mK3NXvgwCn8vOPBwYBOGi6PRyQMWpuAgecaTUNH6ZkAhl8bKgKxX7m/glqSPc/vtXSxPZV -R/rdnjdb/RIFRGJGFsHD6IDso9nN+NUz0vLdtw1OLgDyC/n8OdAIbn5HSuBffSg1keK1Epheetje -aeB6oevAvWnWjkbVuwCI3BP/2bajjtbB/0Aosj1Sjhw78MjhB84cPfbwmYPHHjl6gKAknrskj21c -xOzuG++uJwGJ8QWp2f39tesbHqN6xIPX5A04dlnujFCVeMXFikBdgPf+i4RwcZ+0DP/xO9JqMj1Y -X8jauOTGUvGTvyffh6+skpsqzL1ZXhPRAnmtvz689EOi69dmNUPcHqPhkry/XKNShobkFgoAJ4CN -e1cEnQ0TF85F01ouZ6M9aHAR6wSzhB8Bt7GLe+vI+rvpxvjiXdLmJUMNWcJwhsQPIA1CAayhDkaK -Ioo3BfMkqaHOU8TRso5uxal2yE+GsfGCmZsjKDQegqFqIArgUDUA8Rwt4kNcRfrmhSjlSfz+30sd -+KleqavPd0NOGCcAFgCeEPSIqOPgY8PiNKsuKLxMWXACD3n82QRL6IkBG1RqZI10FewEgQf289lU -VQwV6qV02qsZ7uwG5JcNVTzq3fo5I82OkVJW8IuG/JxyDbF1fzbbhb+ckJu6bwN5uHBQ7sDXP5RW -4tZ3pCj+0kF5BcE4fOGg3BxdKrq545lYJaTfQIAI4KOZ+2FRJbNACWdzlrfrgYPgTQAiyJk0BFhQ -juIvX5JX4pH9stJR369wolfeQKBtxF9vZFFt2he+qpYZ9ASDA3/VkNvwWFS+2/2op72ZFizxvOak -4TaCH31G2ry6unLBFzV5HV77T3Ir/rNeuYGtBVxtfsxz0omJATx0Te7E1wlB4jLQ33xbbrxvCZKJ -kFaD6o2+sEVu7wthnH7BsB07oGVAD8cq4atb5Tb3zOQG/Iwpr8Cv7JZX4XhUXo3/R5U3VpjdGDyC -FRaC48Xz2J2jdKUaqOsdIqvlbD3kE7ezac9imgtyqoR3Z0LzZMEuxT7M5HQty6/VvrOGxArxoj4b -C+BiraehsQgaBGUNEVzHg2fljiaP8wvTELSlPmnVvqUmCrFSJAuWLuDzxjPSX0/h65elrXAnOd0Z -DFgePEwz7qpXNvTxkUQwwBntOZoARtF82X0+88NWXt7D7dkW9za3VT+0SsQjH2NFxXffkVoGQ5t5 -EFDVKA0U73jsOWlzc1jE7z25yR3TN+aimTmARCP9BPfSjPjC+oPn9SfEX+KlapwI3zdA+sLAxxad -Av8fPdw4mUuQ5nKK4DH5QcZpc7DB8QS4MaYfv2tN4PzH6VHdqzOJe+toRRG4HchBSGjeWxqrVtyN -2ZkRuRkhftCHQBB370wXfui35cgLR6H8evs+uaWZz9LzKURhHUl2FCU0kwq6aTkkCNcb5W+e7XCf -/p0W/NI1ualFaDbAez/nHZ66PXMeiME9tvKpBLdTVKky4MLbhikW3b1m2037S6bYkqKMEmTmam+1 -Emu37/J2XNpOxMlCGjyRkttWKGQ4cI5uztUfDrO88Udnm+WRGsciBSUom5bvEBhs35D/EAoycOM7 -uVGpEvIZmBGewK+gbH3A7EkP6+MEtMIEAdMF6CxRZkaq9Aw0O9g+cXKB1fOA+5xK6CgpLsMBCveT -/O5DXE7kATcwTuvGedr4zuiktM7wjKJbiIQpmjWcmULJQY+cPIzsUjZrXNBt0gXHl74iRZazUgrh -prLctYN0y+xCyUrrqDcH2cDScjQdkd4ZHx8LTQAk9zwj91Ug+5PaIg6Zzqtbx8kIYZ9KoskQjokJ -2DeYJom0CzwailanStbySmtFAvVKC8BHRs9qpZxDnsvgZ/NSJ30UQ2u4A03yOld9eSV+/lGpsVko -J062w9K70gZc+FO50b31buvaiQnBkuFgdB63XJa71tq6biaKJXsmKlbj68ugYrj5cVM36ybGaE1q -Ay5RP2NMMlBf471/DpXS2z+CmutWz5pGMYNPmHKn23xxlbxz2O252KWWy1WpBFQJByehSAR9uEDK -QzAh7fV01SR2oVIV7rbv/Vpar4YUBrwSM5aeJW2sscdLujXXm7W0aepWpP3jvvHp6i8wZSdR+B4o -DnyEFXdJRHWR14pRbps9wkiQuflSTxhEW0aH7yauknJPnOtyf+vFf9/eP68wpSV3DseUqg2U5DgU -ZHqqPGHC7QLvS0ltrvnNLRXeKgcVjSus7aPQ0k1PxcJjtBLigzxawpT+oCANNJyifklEmkdQq9DQ -Kh2EGAKzsdYSmMGmF8wttriMoahAnySMql7TPUogLIbEJL74Fak1FHND9WLOWSDkHJu3rStaiQm0 -eNgptcGURGaJPFAhT1F3eU9Hs4ZlO4T97dbsZE9Ud5JFNsCNmVnSqh1klR+WotAizd+V+Lu7pKa1 -9R393sUcXV3Qp/HnmuC2LEJ+TY2ywmG/nOl5wH210I5/UJaaGmK01nG/erP1Hj/05ymcsilUrlNr -CyOD0396c+sAXZnjj1ghOKilPUVT+3oKVBlQtG+sRgH/IXQKH9subbqf95Eg+UF9rFMQjnnPLMmo -M1ugoyk1UL7xSrZgQuJ08PHXpPYKOYa4QPHgCZxobKF2Yj/ou8okTH0qTPSP9Ad4JBcoXymYP+iB -0+IcvQt9v6/w2ub3TuoSMXFCO2Ad/gybmjCcRsjCZtY04JvgV96SYqf5ieFiQkwYQDzYNU/bDvOo -YBlw1dBySUQGqedSVTLJmZPwOe4vdcHw51IEX/ya3L2T7Zj0gAIMMA7oCJGTAj2OD+2KQbim/HKK -yISHPpTW3TWMyu4nXe0VXyKCdcHCi8lCxQham7hjTZGBFqqFWD2n+l1qEndwjWIDtoMPpaQWgtQ5 -8VDTQ2QPcVNqNIICl044bTEHGZMAbBW+epVKFc7S/Ri00hCVXtpaEVEdF8qLs8XB1j2zS93WknDL -+XJV8cEycNVF3u9XKey2k7j/N8DU/eT1NvzNvBRZAB7d65eWUVAkDTzvKGPC5j7yxapZM5AMg4r3 -jNbUZxHnyg+T/4OnNiTD1J4lAISUMQCdXgpixLBjADa9DMXITyUVBt5WvyKvD71tDWQ46SHvGjz5 -r9KKFh9zaY3GS63GPi73dk+k8SDGxtFQisPoumoY5c+w8cWX5HXD5Nk/eWVmhL0Rgj6HdvCv27fX -giaRkNz67wlgLHk2yNZCELCGTfXzjc+CtTHqJXcEuMHjkvs5xbvK0pB2gdqbP3hiKFzPmTkB8eP6 -ID0CKE3UWBefuWmYvUP4TJaoFJIr8yhj2I5hkvKKOO0p3YmKhQSZxYH3hKQFWLeNLzF1ArYGF/AV -MWZGNbCSngkMFXS2+5i3UdqUWpMXGPrvQVVZgCA+vvhF+TD+wbNyg/uLp5pvHH51hbQf6l9xGiW5 -I6YQ6XjZG/M+UjHyaNmsHSeFMe5JSMOnYxH+FkngoUTd8pVWR0gD/Bc4gYwMfBoOeSkKUBiuJGaw -uOUvSW1FHrQKev/dCKph939/3O7eKjRuWyLOicvZ5iBRAIXYtQ5AqJ08JV9Tsz19nQ1feVbqWCt6 -jvHxoeEUebOtgB//kdzuPtnTfARRUyRR4N4T9YyjeCuHYBF7/SQAayQDBnFNdQemt+Irz0mRCgED -i76OEr6OVjGswh7GZ+FFw/UWadMaWCa8Zk3NTvzu1lnxo4MVmCx2SYuX15gMV3yMghStZ8LURDd0 -22pigbZJcrcg9KDWmGAM31OJe0L3wWDXkJ2mqFk27Z0LU7NqiwD7EJtL2LpmpWfAUPz3jGbPjAQq -D7/wqL1R4p/+m7TqVBAjaLh4p2S/AsdYJI2lgqWNuH5uxHJZ3nIqXLykNdMv1zTyOjHdfhppU/Qd -LR0dP3bqwS/6TRikIX6RQ1Na+pydgyPi178l7XCv/Hck7g0FyxbNcoyslnYmJqxCwRkQ+T7hSj9p -hbhr6hYjingfFQX7YB6duybTin+9Vm5pFAvcj852Di/E3k9o4umb4AjLNq702AMdfj8tDXd7hpoq -mQ9c0KPBR4lxXcGvvih14Cd0GbmbbjaujwtV+Ydm3ZhErxzDz+9n17IDvnRcPtqSUXkFziK8zssq -QjpIuIC/v1LlbTh5VoaK5GmppbeGXpyZ3ieZW0rTcpuUwp88K/8d3vuQFHGP7G/Fe6bl5e7xXEOD -mnAK+3X8XhSKkkf3b5JjkRsN5pP33284pE/qQPzQmvUcf2EH3K5IYZHUsVOapbNGkdeVo47D25lu -z/dj+I3vyMvcY/9FX6dd7r5xKxIhqxJGflpRSbzT12zdH39/xRHR8vKgQ0CLvyDhzOhmIDsScxYg -yeUK03xUMMFXkYTcwX/sdo//TWQV4TBhep/u4F8N3/j2X1xCDw4MoJP6NFiPJBT6KAfktlGhCCBl -jiDYjh0eQlGbyrHKvhAHnThaDtx+DvHtEvjqNWnDSj4xSqjwvp9I3b97+oOnT38gvXb6A/kXy/8P -GLngu/YJCWRsyMT8LPaWwg56TiIdpRV/v0B4nJsm+192QwRLWHpOfpJucmJxarFeSTHDjlVmDEYm -260czjw2rzOy4Vp86DivoYGBmYmJQmZuQX5RiW5uakmiLkiTXklqcQlIT9uyv+HxDMxaL9f5bil9 -sb1l4pcDGye7snwSeR27YLO3epWl3FvldYyt257aKiyt3+zNysoukvfuQYY0N6vMjasC2TuZ7lTM -fv3bcHMKjxETAJMrPZ36MvxgO1RoajienI+Std9dDl1mGJVOeJyFUsGK1EAQBfc2IJ48eXkEZRMJ -PeyIHjYqqHgQBGFhT8Ng2kyNyZJ0j+nK7CxDmI/YiwfBX1C/w7PfY3XPREZY8ZTO66rX79WrH5+P -fn09+jb5uR2Nx3iBfK5Zn+Y4P3uLUjsYi0VVE4xuKIWz0IhUhMqAS0Jj511Nxw5Ma0blzDEH3LFu -GXYBbSA3ZFxljRoxOVakizKejoBppGG65gO1UYr8+vvtuy9P1OMsTyGfWbqvaMhXQBcFOecLq2Zp -hXypucSitQ0iY+d06v+jDJ7mqT8rR0tVk/nIZaAcCA32BF5d8HZAukF3Pf1y705LztYrmssUkn5H -+qRra090cPVHY3DPpWaQmTs/HHXhrBlsPTrJIMPVATzUclNjsXPp+yZDn2D/a+M1D23vhjbB/nJu -JZoWIWCfr6+ndfD9cD/JcOfZxxd6pV3RVktOPed2IslE3v8kZDNLYtGxo9otAS4rCUQwy17QA+9C -uytTIH6fBsUpVrruKMGz59iIpIVtERfWOIbM1ucxzW8UcH/DW4F6ef1fBWQKWYLzszevrCRpyHDs -i5I+nyXhMcgeLqngeAOlVKwvdcX7TYjl9SRBnyi2rz91upaaoFSgTFr7UZ/cyka/ARqNA5n0zQEt -mMjq+QJ2a23F2kPZFn8Tvo3nA3icjVZNbBtFFNYK1B83DUpDfkia9mVbyLp21kkapTSu06qHip82 -CEIpUhroxh7H29g7Zmddx7KC1SNSOdCRWCkqtBy4FbWFG5EQcEOICgTtiQO9VBVSCzdOCN7M/nid -WAUfdtfzZt587+d7793+csv1B1tu3lp3+y4qOxuGBcYio8WKQ4CVSdbMm8TGJVpxwGBQpNaSeBtQ -NpwCLFbyeWKrSdDikJmBegwgSy3mQNEsmQ5kwGRnTCtHqwyOwsGJQ1OH4AAchASMwzTKTppWZQUl -k2OHp3BhfGyiMZlGHakUvF4geIVNLAdypk2yDrVrQFZM5rAkMAoOym2CQC8gvCVKGFALHApGuUys -HBAjW8DtDrGY6QnEAYneMkpED4GGNjJEey7WAAgkNqXSglKZ2o5eIo6hIxLEbpN3KghJUy2aI9PC -D2pcZ6QskLdVO7/gifLUBq1I0DvEWkLvZWB/XTpqFUZhfCqN6w0pOBKRJGAy7R9IJOLSxaEu/y4M -grkCNA/zKoZC1c8z+Sr57yyT75S60DwOEYR6ucIKmjQ30YDjMqS6USzSrOYDHZXO0MN/3o3+f1Sd -RQc4dM6xTWsJMyHhb4in/dtWY8HzXDqGT9PRVJOBhTfmacXKITyD1awsaHz9KrhQUbYPiliNBqk4 -GqLFrXV+9c5QYn+9acFqaJXnEUzWLC0R4fv6ajrGh9e6TzeTGR3VPBp1SXC8atTk0YgAQD1esXQ/ -4+YQqxZXp4HfeNDr6l3KjhHhoHiy9YSfKMEpcYK/MDM80H6bFA/OPHN0g9hLQHmdxzJ/IbSh5drV -NN+z1qvPow3JgCALwuRXFs8ji3QklG0Spgkb44Hx/OL9fr6+FpsKkaZbMEDoUaEX46sGqnPqAmT4 -8JVu/ubD/vG2O1V8El2wLvI3i9QJTu79qIMvvxfj37/Qu9dHuUxqTAs0xfXz1LQ09exZy/0zrfTy -jhen+exXv7qpPmWH+9sVZdvT08CcHO7XWbkokuuspcb5N5/u5TeObXV/1JRtQ/OhQZsDCe7LdWUf -v/1o63Pt4waveV+nCGPGEgF+7/e+Pa2xa7elsyV+zVuekutqELYF9+Ix5flJnxRYgEWMalBGox0s -W4YDAvFixSzmUEtO1DrJHCys/NbVA5IuQ610kRpGpYaAMI3HEaaOjM1mEXoSa+QSg1VMf6NqmNGr -6x4uqZRNRyiURJA2rU5D3igyAquR5PG0I9oTtIE8R62RspM3iw6xm3mMuR3JOoFDZxh/Db9E2uML -q7Dn3UwmAyOnaK5SJLNCudDtRQsrEKgjogSFahMwooLWH/FqfCTCmcvX+/TQesvXFtQ6cVEEsrfK -x2/OtiTgSJBn2zs8Hzh2hWC2/nRSmZprU++gWiAWroJXpfI2LfmNS8A3gg6jhw2MATLCywUR6DDs -SRn2cJuItW+XGnbNFMXWZ2NT4HB/39xm1fOqLjjZUveD7oO1fUWNI1HbQJqXjWbBK6+plvKKolTJ -ZAytkR0oFYIJepCoOArw4Zlu/ssHu/jfl7btCDUkgf9zp4e/8XCA/3Wpsz+y7pWRpFc/+KuX+vnp -u92bykEzGv0hjA305F0/dA9EYG0W97g/n1Qmn0Co7jVH6Xkr5nE5GkRiCseGsRTcjcwq1QLFRECO -khX0kzcumd4AhYcwlJYcSbwJiuvfHe6RsWx6yoslv3ZnN3/7xpZGHUrLKBQVKwlV23TICbMoC5hk -a+tQkmfqJhZuaIqB8LFDiRrgVxt+7gezCBxpGV7ajSiSxSQ6v7WbpnAuwaevPHKyWkDzQAsON2p6 -eLH3Ed/QoJvXJDK+1pacPoUR0EvYSCbGxpIQzjLhseZ4Mx73ZpooHD601tEdRiCEVXMHLygD88Eu -HFxnKbAac0gJsngvOMYyutyR0ywqR3I4BUwDrH1yCA1+ZZuKAqRnC6i5qR0h8M7L/e6Zd5W+rk37 -3IdryiAfWds5sXEETMmHDF7zS9I12vI18bGxG0bc6I9xSXAfrSkDuzdMAmq7EeDZli3/t+3Df7R9 -lWeOnkaO7+Iz397lf3w8iQzvcl+qI9U/f7+bfz25/cNOZc+ToqZ/8cn6Z/f+BRXBKez7A6v9O8Ex -m/oJYG1ogFoqHkqe57nqeJwBOwDE/8keyR6wUwMUJQNOFaGganxkTdIoshr3/emj/uezZwNFCRTC -eUNt02jOLVDAKyV+danhG7KF1bPADIkCD28bJfsYsoXv+7j2VUNGr1FJ7IXFq2NCGyh4nEVQvU7D -MBBWhy5F4gVYTp4cqQp7IpaOvAJiSJNLMLiXyD5DoxDgAdg68CAgsTKxsyKeBWEnbZjO9vdz3+ev -7/nnz/zpbfasj1aO4rVTupDRy6ueiUdwxEpDRpDZlnJotKsUgUV2jYzCZI02XgBoZFjXRZuAZaOo -gnuvLbBUhEXq8bwm6xnBHM7gf1HnMQAkNm1TK2KbwIU4ZWcovraVuFwOeKn8mgQ6mCCRgBDQj/AY -K0iHK0C3nwCUbdBTg0osp9exzaFGt/t4P9n9nh8/hAY+XnaXKQY5jhI5v5IWzS2a2BkdRTHjlmWU -Tnb9wXl/GFL3AwG3DeYsg7HX1SuUor4RAzTaD9+QLgL7D50geT/+BqECtZd1g8Cd5IVIptdBCD3F -6g4keJwBbgCR/7MqsyqwBAwUDvNMUSRTb07ezzGaHIs8hq4b9CqzGAxvBBTw+fTRpJqZpzz5rNeX -vtg42UkmxZObEG4U1/gVnV09/WQGm4+9exIHmrq0E+mzHRF4AhTECzZ/IM1S2ELU0x57LV0tCPHs -tLOpE4oB33UydPACG5cUXH72QitHKFwB99vGiy3VCZZ4nAEgAN//ogOiA7AuARSHm7fJKtmW3PpK -QhWnBM/GZhSx6pNCAWDpJg57+Ba7tc76pJ+KFk85vu2oye4RtIP9JHicm7tA6P0ioYYWxhamFuYt -LDVdXlwKCkrFpQUF+UUlxQoFqUXJqXkluql5yfkpqSkKufkppTmpCnmJuanFCol5KQpFqVmpyUCF -mXlliTmZKQqhIW66FgqpxcmJBamT7a2secD6lXQUqoHmTv/dxWI33bybZR2PkWlKakF+cWaJXknx -ZENp0eksPSzGTEam0817WFpVYKbmJuak5RflpoLsyUksySxLVQgN8oEYP/1iEKP0dLkiFvbJEy6y -Tf4vyc8OdcR0sV4WdcnQIE/XoqL8Ig0lIAthkpLm5MZ74lMXsHCzFKUm5kzP72ORl8tLLVfAqV5z -soGN5PQJ3Sws2w/0sAgzQl2pOP1LL8uR6VmszF7T//SxiE9+4PBEQMFUoSCxuDgmT8FAIS0xM2e6 -Hjuz3GRtOx4ACMR8RPkGr6CTgxeDWKAvAAYreQ0Zf8pcIQp4nAXBsRGDMAwF0IIuC6T9XSqgY5KU -NDoix7oYyyfJG2SPrMAd6zBM3vsu13LQsM4znpmR1D4Px0aljB5kgU1L36vjJSmxQSoii6M3D2Pa -wWZqo/ZoPeCVmmeN6RbsMSWSIvV98vC7/wHxryb5+zz/ok/pzhsilHMBDb1foFcmU6djxnicdVLP -axNBFCYXwVws+CM5eHgsYmcl2SaCaFNaoTVCvSgoeKiRjruvzehmZpmZdFukBPwLlLl79eBF6cVb -zv4l3sSLF0FwZmezSSt9h2Xn/X7f9/2Z1n5/r335uzqhEItRlqLGBBKkSco4QiJQARca3rA0Bcph -zFM2Yi5Ho9LLCuIhS5OgBVQd8RhICOsb8LYOMFaM70PCJKzb1FH2gEkSVNVtV92e1br8BkBQvCMX -il6roAe71m/u9xvm64vLH941l6Awu6Kfumam/cbEFXsrnHbc5phHKqM5JzuZFDEqFeEhxk+oHrYg -aKOdGCjU21yjPKApKZc+bkG30+mEwcBvNDOlE8Z7ELB9LqQtPh16KMb63CBK6WJ8iJLpheBxuFY/ -/WfedxuT6ojIwU2qpJl3zCXukf9qoeCCBHP+9hi3KFc02oPnN97pnCmrSJkUDpCoKeMKmD6fXW8r -K7AlhVKgh7ignlIZlYhy2wRtDlOAXMsjELltTyFlB1heVrQs7qc5ZdpTmCJmxFKygAMeZhjrkrEZ -uQVYvk/GkhZ0wjCymo20eDaUIl8AzMX8Y9eR4QH0E61ezbfta+ZHr3nzjBAHnrg4T3rwVEura2J1 -HZrp3Yb52Lx10YYEt8DtmE+PXpmr9y71WyX5od1hE4kfWu4+j2wJ7pAmwW3IqFLBmSwTPr9eX3gu -bVy54E7F5OTnau1GrWt+DUzxXT75/PJx7R8zrycg/gbamWvPW9fsbKkYxRhnqZLicjFhM3icAW4A -kf/fJ98nsEYGFKsXYnnf0vhdqrFYngQ7WIOGDQuZs1oGDAMU+yC+CotUZfyCou4kftwYPt8MwhiT -egmfFGNSH8MigOewNvIkDVT7Ewe39VMDsy0KjQIUltkVJeIXvlRg7M9/GmeFDpD5KaqzzgwRBzqO -LrP3DVAgzbh8puG0IhhCIF5c9KPwnRGeeJz79pmx5SvjhNx6fX2FkIzU4lSF0oLikqLUxFyF4rzE -guKM/JJihVKgcGJRemlual6JQkF+cWZJZn5esbVCWn5RtkJuYmaeQmJeikJJRqpCcWVeskJRaglI -LDkxJ0e3uCSxqEQhOT+nNDevWI+rJLW4RC8tMTMnMy9dQym1qCi/SC85EWj+xrpuZn6EjCtIZvJH -fZPJ+So8mwNYrrBwwCQnR4nJbXbilOCFi2yOEpuCxHunzBEGAI7GT09+jlAusrqwqhYStTJ9cPN2 -NwekANV4nPv7kPnnQ+YNz2s2v64RKgEARP0IcvQFAPOFlWco3CqCiTF20V8QhG8g+Ht4nFun/1l/ -wgpPfX2FkIxUhbT8omyFotSSxMy8YoXkxJwc3eKSxKISBSCZnK2QnJ9TmguUyMxTKAEqLijKzCtJ -LdLjKkktLtFLS8zMycxL37iGSRwARBYfaKcGeJwzMQAChdK8lMzkTIbV1XOP3Pp8QULxqnbQh6M2 -Knv5GG6bQBSUpOla6JYl5mSmJJakMtz/+MXBtov7iM36uWuTI4xjVZ+U80IUlhczLKi6fk3ava2v -Qfr2RAfz+bc/Sp+9CABFciq++QFtbzFx6P6MS6sJC/1l0AGaWrgL7XicS0iY4CPSVs/47qznpH8y -1xIVvl/51OqpMNcIAJl4DDj8DjWs0YKOvNT+OlyzAFhc7OaLibVfeJxbfpHxy2XGDTzayonZqQqJ -CqFBPgr5aQqJefklGalFCpm5BTmpual5JYklmfl5kw1jRScnsHBJZRSlpukoFBTll+Qn5+co1CrY -KuSlloM0T25gkZpsJiFvXq2AoSixGKRCR6FaobA0tajSCshIy8+3UlBKSixSAsrXalpzTWbkFw5K -yk+p1Msqzs/T0NTUK8n3TSxJzvBPykpNLtGoVigtyrFSSFCpzsgvLgktyqnVT08tsQeaYws0JUFH -IbEovRjT5M0ftLbbAgBL1VAx8wIEyimND5xHBcNG6FcODAot0tpatnice8H5gnOCp0jm24fPJdtv -eTKHimxqMsgW8mBxD5sswCixsbSYBQAO4A1A8CrPg1eH2TH5DiCdUzzr2gDcQtAlHnicmys1V2qC -iGlfYtgli6xAHynJOSILX1y6/Z6Z9aiJARAoJBYXpxaVMJzQ0OB/1M5zJKTIxuia/bl7pdINlRs9 -Y5lFri0StuGO+tCovXjjyzmrPkx+9zhYavIu5hqR2jVGjLnCVdekj2TLu/G+59zRJS++2YvlHKOI -z9/5zz/8WShy2Vnv54UPE9MVrn9ZMVmHLcZExTnp69vozw4ff3ZZ7khi/felN70Z4oqMkpICI4Z/ -+cvFWPn/1D/eHfhm3+bCF1MLrIwm72HrFdms8zyQuz386NKCBP0FDQcXrGlfLjh5I7vJ5ons6xhF -pvzPN3OT88ttuOm/Ro89OsxX6bnx5GBORxHTeXyOPXpzDpwIubGp4Pf76eq6+60mr+AsNP3hcmlS -0Du55e2mB5yP/Agqt21/OAPikOKSotTEXIYFbFOO2pkunu141OWJZfPiNxcruKsm+3H1iSitvcr+ -l/kDr9c/ZqFXQumRDRNuXJv8gSvWaP75a2mKp8RMdN/xeSz9+cw8yoTzP8TIkpxihh+OcsZbvyZa -TvCeVXpUZcGHORPYlCfXc1vVv+AQb6nZU/3k1v8fOU+cOXKKauK4IdpKi3IY/iv+EW9KnP9mnvUD -UVezRVUHNix9BJUtycxhOCx+Jvij4knma3kPGktTG/5atJbNhEiXWTA8u76vTE2pI7o6/c1fxk38 -y9StGC4YGhiYmZgolGUWZyblpOoWZ0y24MmsafqcIrm6Y450oVySxLXd3SEzVrCaQ4wpTyxJzmBY -3TlBJH56mPErpSZl1R+9JXXtjnug8vlF2alF8SUZwEBLKWZQTrySabORJ4orSvB7+4m7ui6P47sg -CqtyMpMY9iwuufe3aUpYdexLhfJff2fs3/H8BACtXSWL8QKO9zc+jj9X9ZDsUeSW7FwCHib9K3ic -28e6j3WDPaPIxQN5dusXRprsf6fw77OsW2PnQs6+zcGM2YwA/MIOe/gR13l+z7hvV+Jr0REsr6qZ -N1S4tE14nNu+l/X9AdYNv0z1k8tTFJIT8xSSUhUSFUKDfBTy0xQS8/JLMlKLFDJzC3JSc1PzShJL -MvPzlHQUNDSnv3dhVM0sKMpPTi0u1gVq1i0tygHKVNdqWnMpAEFyfl5xiUK1QkZRapqOAlBhSX5y -fo6OQkZ+cUleYm4qUCyxJAPEUqhVsFVwKs3TAwmE5Ltl5qQC7dcILinKzEvXSMks0tS0nvzPW2ny -61ShyTqm8pZg84E2lKdYEWtBYjHIT5ML5KUnt8WITW6r5p8+zZJRhBvJkskP3ZWbec2285oxrtIA -AFPSYQf7A+YseekMASRwAqw8Szh518tpHNE4eJwBOwDE//ES8RKw5gMUGi5NYeJzEsZl0qWeX+/H -HMYZVDez+gPkAhSBAMAd7zuGri1DS5n90ip1KbjAqLPyBn8CM08bif9g2oniVtq5v2zxzexkpJ6F -hfBRp9F4nI1U32sUVxRmJ2NposZA0hi1ticXhRlZJ4KIsiFKQhNMCEUSf1BiSG9m7mYn2b13vHPX -NYRlpQg+Ct2HK33rk/RBKaXQB2ubh0IfCmIpfS34B/RB0MfSnjszm50GFR8GZs493znn+8535+V3 -Q9/8MnT7TuF769+f23/9896EZLQWF8GPirBWFatAeQANqvzKTFhloOgGAwpXFuZBlPFMqAqTENai -KqsxrvToH9aIvvSlPdIqC8nCNX6yLqukCFtAqKduKVLCFwJNd7wPoFznvgoFhywXqzqc1lgJYiVD -vubCFmYB+ILHCktUJCsXIZJCCV9Ui1ARsTL5GKOqYt6gCRMwVede1MLIZWFmNlXXRcidxaSoE4TS -LYLJdpMpACRTdcnftQGNDX2DbOLDbkXMV85UvVxm0sNJfaoc2qCnQwU+aqnYAqMBtkZZnRzPTA7X -9ZSYlJJuOq6rv54qDNkEp9Iv9tmH+ySLRfUmg4nzevT9nsFWHr7agTMe4BdKnGWnpMqx50eLm9x/ -Xc9iXnDiZ5XGu2wQbXaf4MmJ5BxXOAN+Iyj9D0tcXKUXC6mchMn0jTqtOktZoyJkY+JL2mUZu7Rv -0OH24/uDhVV975V1cM8qyQd9ExxpkQ6LHeu9nojjojqw1eyk1/lbAZhmUvtC5ZA42UmcGNyPIBCA -bs4MXnqjw2li2AY6g3VNEcYJlhrf6p8qtvdhzv0nO2lGQ9Ndj/7Yc1x/6xRO6PVf7SF94CPrQKvj -cgSghVMr4l0pI5HS2NjYGdL1ZSdMugbFEOmatARnoJlae6dszGJTNwtC5s1rMlTMmLOX1kqpmHr0 -Uc/wHI7heoI7hEkpJMkJnRqugUDFOK5gV8Wu2zv1Wr9bH7TeXC9XIDFsBss5GLHGQCLa7LbboYdC -g5NyTFfBE65ujqqSmzp6aO/fbw6WTNay447ryWf2wf70dhMlxAaESj96aI/oP7+yBvT8M3vfQHqa -jIxXO2D6xWLhkL76m92vTz21Dw3jjMg0wD9KelU8dBhWfvzAPqfn1qwvznbkN2CUP4yvhTwQjRgu -AJleWFiZ/fTq5PzsJyszs/PTK2i5lUuTly8S0IW/C4N6e6+1Rw9M2Uf1x3ft3vbeJ/1zu7ZGa3Bs -y9RuXue75c+dJDJ2v5eWr/PP28+PHGuvP+m727tt4dPzQ++2vfHZfykw9mn8BfUs3M2a0nMYSY1g -K6IzPMcvTEgEeJwBXACj/54+nj6wAxAUq71Suv5ylxhVwLApM14WcE4qXV6TjhAXsy4QDAUU7Bnj -uYOgJBkDQDx7ldCi9lk0PJqTzxUYs2YVdgkUCtXZ72O+V7gB7AbWY+SH3e6gXqKT8B4uzJ4oDPlG -fJNBWLqWx46YE2K8qw9ZZynj5SF4nJVTzWsTQRQ/2No2Fw9ii9jqc6Q6W5YkFgTRNLbVglj8AI+h -yHb31Y5sZ9KZSWIQDV4EPYjw7oInjwqePAhCT94E8ar9AxQKelEvzmyiJZJoPezs8Ob9Pt6beRvf -dr28N/D868RAoQBz9PDpOG2ODLbQ1rTEBKwCu4qAdZQWUqWqeViQiZDXs7BGU1XSIAhpLEYJNFQt -dSBM0+w8ToXHseliES4vsnwuQRNrsYycuZ3VqumZom2eZVxRGiE6KZt21Z8JA8ZTuCUxIFUWZSHw -AGbKcCsHEDugBW8XZoDToxtHqDQ3RvNjo7lSxWm4/BBo9thUK4Nc0WpNGCzVlUjKS2VecRQAFeYs -5DueeOAEItOUMfBroTeXIXnUiERbiQcheALoQgVLYS8yiFYsami0tLB43nWJTxeP95HwwEZXnkvb -qWy2AvRUNzZq2Zo5qxJ0bTpRLLKwk97DRWbDIboAO3HS5uzjZypLQq2VDv6m7ja0eWa09U89iQ1Y -8HS/XxMmLPjThZNf73GzLtr/Uj3gXP/2bvP1rOYXtfv7QrBPIev/U8hSwNmk6Xo0qXAzJ1G3J4Fe -3z1MB5+t0Y+PI3RoY5jufDpF7w7spzcXCvRgPEcXP++l2aE99D3aR6/MUbq0uPuqF+4MhG+7Suvo -ydpjm1eSszhVBll2O/40CE53SsWbVYytQ8Uo6pgEeavm3VgzenJ/krYeD9PW+8Ehl33bfS++TLz9 -8BNHMWtP+ganxzQQSBeHhJVHOCeRN7jkiyqvTnicAWoAlf/3CfcJkB4UDu/5cFDv5RfatV8vD94F -OyadPNOxMgoEFCdfibzmv4sqydr56WCHHtdhxgqRk1AEIxT+z+Jjj/1ImJbEQyIxgDB975Yc9pOH -BC4UwIlucw0c5nxZtn0ZHDmRUXhf26CTyQQuZNMw7vcifTR6DmNqSGGEejHUn8tKxJKhGL14nGu4 -wd55m31Duehkh3be6Qu6GVknCzkqb54vuk4eJiK8OcF0Uevk/kowT2izyO5PBnC5yQmmKybvfOsw -yY97ssMhls0Cb/llkCUVpv+1ZxSbPGGjyOQFccbb13MyejCjaJ50Tn36X0lGhckBfhyTDVYITg7Y -LDz9wQNGiUkX2Sd37FObziPKqLq9n4/xFwtMH/vkIFP17duFGUtYkY3KmLxLx23ygn2C24HmhUsh -S0lubzBh3KPMWlycmZ83/SIbo9z0B+2MopPn9HFO3vBKeHpYBKPJ5NkmnNN7IhjllK25FMCgOBWs -3rWoKL9Iryi1OD+nLFUjVS85PyV1sqCv2OR8E9bpBRGMbNuPRDB6MyrroGiwQtVeUJSfm1k8nS+K -sRXF+9P9ohlf8KFqne7YyCg23SeGcYNQYnliZgmK5PYvMYy+Kmg6tgN1GDNiU53TxKjJiMV8r+33 -mxnzsWmZDtTiN11qPiP/dPvbjKzbV7QyRqQBAEIrzVb1E8z4O/7gOskBwEfdxGyV8tv1O7/3eJz7 -E7Q9ZIOzok5afpGCRnJ+XnGJQklRYl5xQX5RiUJ+mkK0UohzgJKOglKIT7BSrKZCNZeCwmRHRRlm -BYWEyXGKDjwq1XD1tZPnKsqwJuiAlOxRlJh8SdFrspSS9+RkJU0tBYXk3BQrhWigHAIklea5VqRq -aOogi06ereTqgSKioKenp4Fwla2tLcQ5CvZA5+nqluQUK8UqAM2ORTEoFuyOx0pFk4OVpYD84pKU -1KIiKwWlgsyCVCWEylpNa5DCduXKyf+UrSabqWhNjlNREAZKQNSApWu5gMomV7OobF6rcp4FADmW -Ujr0VxVSVyf3EW352AHXuJzotu+DjOBYeJxtVM1u20YQRtsEAVTf294mbICShbKSBecHFJw0cYwm -iJEGkAMDuSQrcmhus9pVdod2XYFQ30GnvkWAoC+QU1+gb9Dc8gA9dpakbMcJBYjLndlvvvnmI//9 -7t33b/67tEvag/SQoSMPNRTOziAqpTPofTTuqdncOuIMzwld1Ngc03Zn4MmpjFYfLr1bZpVD2Ia5 -sxmfFdIdHgllMl3l6OPo+nWuFCXjXmaNJ+DDR+g43WM41wO4CyXRfCQyh5Jw0mxPmqx4AUKIhmGf -84mUOfQpLEAZRUrqA2Vye7ycqN8xhc3haAt+bG811AkjpxeQG0xmogqI2/JJx0dYE0ee2StrolCr -WcH2nfVScPk9m61rhpJxV/FyuCdv/7588sXTa4sWl5uKQm0fMYlmFdXpYLA5uiWG/NtMry2CvPXL -Pnfj8FfM6JmRFZXWMXKeQiG1R6hXz6/8ND1Pd8FtDQawXyLMWQ24t/MYCqu1PfZAvNm284OHye7+ -/qMnP08GB4+ePPjl4MWzpw/u7e8CN9WkyRn/EesyE4y4+mPj22Xs0Ft9hP2OUBLaz7RCQyLUitE5 -68Jmt7rbJbaPCXfaIcQJX2PGbb0SdyCeeArC4cwSnsl4Fe5sh6ltrKfHJ+u3f17568ulRnaecp52 -pNZTmb1i2zTCjHshxJpYk38+VshK045G6TA/iwTl9iZQ6MqXyN5X85L54W8EU0lZ2JIEm6Pb8Fjd -F7A8UFSCZj+zYWU+U0QM9nAExw153w94VCoPx04R6zlXml+qKRaWHRDsXs3CjJggzLVUpqkkTQ7M -64iLMVRgPmfZPE9X9By+Fg1WzOLdX1ZFwdbk4zaLT321NRyubZ6Gh+GwD5GMkj4fOX2nwlsVNwNc -NE/huqgkuQrHXbRu7ilUJsdCGcz7vWS8cr1/lhfNdzrU8won4/ORqx8Ppgt+Mq11/VCb3EmH3nmF -Px3k7Em8evn1+6+CQwcb3yzbjE8ZnXE632Iy/jj4eVrrsMDXldTxegJyqnEPzSGVfbi51ebe6GS6 -4K0zHZuAyEIkbo7UPJXVq42T/wHOVsNfrgJ4nDM0MDAzMVEoSC1Ki8/Iz88u1itJLS7RKylmyBOu -LRVMnB+sKv71nkDSGZfcQwaBAGVnEJv3VO1bqpBPx3s9srtdhF3z+dj+pe0OeJyNVEFr1EAYpaUW -uyvF0rVat+DXRW0G49b1JFtjRRBsYXUrrbQU0elm0gazM0sy21pKLJ492e+kVz0pglBvXtSz+Bv8 -AYL4AwRnMtvdlG2puSR533tvvu9NJt9/9vz63fNxII+VfAW/ZYbxTX4CX+ezfbENMX7OF/BdHtrA -rjW2M35MskhaOGiPXLdIkXG6EjCLgCtYxCckhCxiEiis+ZEUqyGtg1yjciICGoSMuptgFC4OTQ7j -s5l+fHV8CDcyI/g+GFwsQUymMgDsaYPVpNX2aC9DilLcYpYMmywhynATttQdYGPNDxikJDXR5BIc -x4ErZGcqt80iEawzcG6AanDerzPRlFZoUBtKJPEDqAkeSdgCI4/B6UxiCEf15tEgYqSLm011hY+y -o1eTp4QXg+dzGgR7o3SsXT8y3glt95Pz9tJ0En9Bxw1c6LypCw0WeiKsU15jQLkLvoygFtAoUiQv -FHVYDcQKDeaVs8r9Md6t9N/hVPrrqu6oYVN6G6qHvNzmKu19SIWGT2z8MptbgNgMrC5VBMukyGmd -gc+htRRJtbGsaw/V4kmbsNXRG6nuCMeDi/hh+gTeK53E+wuntssJXExPq/e3ZZ/G7T03SPfb0lcP -0VeP0G+bCLpdEvgwKxPbgf3o/LrdNHqg2cBe5Bm8PDfWU8bnZ8/0aTF+nR0eJPs0GsKZuewDLlym -vnafr3anV+wU1TZFUmPC+58h8GZvbqAMcrOhBTjZe+F0qirV6Qp9z2duGfAvGR2x1A9CHbwSsUib -FhPMLp5Hcu0F/ljMobNE3EZ6q/QZN+TqkXBrXw6smZDbJf25FtLUdEAdVA94rgwFr8lr0he8YOD0 -ZCV86di7y/6f/n9GE76F/wM9L9f5diSnpraEwdapxLwGe6hrlXicAT8AwP+uGK4YsJoEFAouUvhJ -vzN2vww3fTAb2E8kVKxGs64EHgUU4mbLO72LE9xw9BGrGmzKkJo6YtyTcQolswUKKQIePhjQ/UhF -Dsb9KQV5WOwnR8aR6PS9dcpziHicdVRBTxNBFA6JGC0hEoioGJPnpoZZXZYWY9BiLRI06gEPHDg0 -DSzdWXZgu7PMzEpJ0+CJs8lc/AN6lph41p/g0ZsXL578AR58013aErVJ09m3733zve99r9/ejrx7 -P/Lm+KIDiraSVSZOjndnjzZCT0GTt1pe7M9FLKagOI8k+By2acAFhdhT7BXFHJ8CD0CFlAkJB4Ip -KjHZBMCnsilYorhwYYOpkKcKmAIvSwOpeCLBM4EgjSJIWELdAuBnCUGUS71mSOqWVD4WWg6YExXC -aoAn8eJYKpv00gGsRPAmldK9JfXnwmV9aWz0CFrenuGCRAwybEe8ucfiHcvJizx5GDexkRaF6iPo -5FHIoKEe+A5wrBZP/QZU87xqFU4JQQ3qZQcWGlCB+oID5cZSH8I78PTPKujRxSk9vTitf4xPjJr4 -ll6+g+wK5PnwVSGqHCE4nHZR7Jjbuu5m9maAO6gRVKaRwhr9u3A1/leGEVnRGFN6cq9js6TYCfyu -AytpEFDhehFKQsqbpVLJfFHhtmXbZ7GGa3M1uro8P7Uc+JWcuGuUyvg4/Vu7Z4G2nKGHhnnQJ3dv -6HsXZvSn0sz5bi9Z31x9pr+fmz8amgIqnaTK4CdcqP8OIjs6kFmkN5Ls2Avhq6Hh0HZCm4q8WH+5 -5iaekJRk4LbtKv5kP/XqEenAoKkKlPp9VaAvF3TtvzAztm5E4x0VGrgVOtA363HzQfE+QDfTA0O9 -X+N3YuEeMPRBiPaOOeTDd4zbWQxruGn6S+2Km0o0MfhMoBb5zpJcijlTP5fV4cJ0kKH+WntcE3Q/ -ZYISK0aQSiAt2x3MFa2rDhOKS3xqvwzs1H32ln5dIndW0tg18CTxVOjuchaTdSWQCkEqNnrHlKi2 -QgfpZOm2vlYe12J1cjJXwUpjnwb4T+JbeqI8PWbucmkbSfj6w8PrH3/NsuIfpcxsEK8CeJwzNDAw -MzFRyMtPSdUtLszJLEnVK0ktLtErKWZIv/xRzWsS89/E08U7xRx4kpcutIsAAIdBEd7xMdDG1PEZ -aFIlVvJqkdODyt48AOIPeJyFksFrE0EUxtlCElOTGpuSiof2ZW1lV5atFpTS2lIRz5X2opRQJtmX -dnQzu87Mpm1C7EEPghTBOezBu0e1FPSodz30IgiCR6/2P9DJbqvSSxd298335nv85r15/TX/7Uf+ -XXtg0SOS1IlA8KgIA0F8oExQD4GAiOqiwWkdOfhI2ihAbiA0AsawIWnAIAiRqb0xv6g1IYGjiHwp -Xn6vxDvXjaw6LJ4dtmF+4TjhhpHYsNSnGyMFB7y6S8WSLmCrpfFp9WsoF//+YpTVs/MFtTtkq9bF -3OSRz3ZlcOdRRHxrNWIeNilDzwHJI6zZc4PqTaaipsYuq1c/86pHCurgfS4uPTUyGeLTNsZ7NWPk -TBLOwrX44KpRiadmjOz+44Hb4/vD5oV78eh9o7Rzlwdb26YDVkLMcBMSxepCk3IhZ8EMGOq8QH1Y -Ty/lZmBCz4Fuz645g6CfVZO2woBLt4WSuMjaf8ud0IEIWNZ1uHdTSE7ZugM7abCQlKrZllmnzEsb -zkgLPQgJ13+JXEDQBKKbX3+gx6B3EAk+FVIA1W/I9VC4pJgs0W/OwqToc6w5R44EqJsAp2PrA80v -9p0NFKLPN5dk/xNgHk7pw1xcNYxptfu8ELO1gaz6XMyrjzOVSxOJC26tpHYHJlJjX0kjU1WrZbW8 -fWUFALdCTah77rqukERiC5l011FaKbtl29D7dx1OYTq+HA9flMonj6O/6u250SdO54PTMTqHfwD7 -Zgh49gPAV4G9IxdRUAdfLY5QYnj+RBe7GHicATYAyf/HAscCkDMU1JcSZRowlY3tsYJgpJeNtMG+ -vjyRR30Ueq7rHj/Fd3MfxFfE3c9liksq3ciR2G/BDhtA8QIIs3/Rrof1C2IJtK6rm0gH6/CxY3ic -a+Vr5dtwgkmkzuBlzIROGZE5r6/Mn7mrsuizn6rc5jtMmiwA9MMOa6awbXicrJ13IJXv//9JJA2r -ZCVlJDmZGSVSdiGrklHHcXA4yxlGlDTIKkWaRkoZpYFSZGU1bElIhVT2TqF+932fc4y6D33e399f -pOvxvO/7uq/r9Xpdr2vcigoKqioq4hQ0mYJAOhJIFDLGBY/EIpB4n004NzKLUObeawY+1dejgvob -yazDCvfD1PUUZzJYMsIJ7YykYimeSCwVjSCQMC4YQGETAIv8kriSV4n5eX/RYiN0I8Jn+2atpLlg -kJFCX9Kqv6+pxZ662Oq6kXfGBUGJC7MYEg6BQ1JcERgsFu0C3CkGT6aQqCgKhoAH+aJb3axPT8tc -3u5xY1CubihvRJclcRZPJqNJ4A8fPAosnzP0Zu+6LNSdO1sdhDmyRDy/yu00ginvSMVgKcClEHgC -BUFCI50QziQCDuGMwaLJPmQKGgdqHfbYsummUsGl4Ed5NdzFy2V3qCwqgtFCIbFYCgmJckeToN/J -IOtLHvr1czRVbuLjk9sqLKIXayy2w933TNYFTdnJwK8mJ/2y4Cpq+c53+8TjJYVCorvNx+fBSWgi -8L5BOKhvye9VE0v6C04eVSi/L8/t1WsZPQ/siSZhnH1AmPfswu+b1x9j667c4Lq/Fm3pjVvKBQe7 -olHuFKQLiGS5ibT4L8a1vj+tue98q5T28ChqIRyCBX4BGgjt/VJJGDxE3zmeuh/Fh2lYfWL5XflX -3keX8D/tZkaD5V+/Piyv+vuHj7eObDRiUam7jM3ECZjyTmg0EeGFAVoWmkQikEByNMcOZVP5ddlY -Me9+zpeyLEnbnr+FIdFkHALlRkbg0GQy0gU9o24kik6znNcKitnZXvLqyZOQBRNjxRIwAs5IDBa4 -PpGERiEZ7ThV8f7ZC9q/F8uLIVSWohrq9h3himGCgsWVeNvVbyQqp13Jexocumffrwd7HVNhimOc -p5/u8wPRqxEvo9Ixu81YblI3yXceFWCDQYDax6CAh/TGkClQfe4pDzG6zZWYJXRszUSJuCj+MOKx -KQxH8SGinZAkEtIHqlq0B5VmFPwfhAkGPj1Xl6gvzbGj+eqCMIEfJ//GwZI9rQc5uvhKdF9vCWnq -jco1EFC4xzu7JNCHEa4EgjuZ9jsJTSZQSSg0AkWgGwXak4buMb59O3ZxZ6tor3WffHXg/eMId2ZC -f6CO3ad0OL81P4l8lajqOrlWNzH/Ti4zFI1HOmLRTtA/gOqi1RYv+Qja0HabwuUqDLu81tP9q9PN -+JgJAO+fSiJjPNFApQPdDEGi4o3wOmABSxSBCJnHHOMyvL/o9Ystuxvqrm2JIG4JXMDJVI6KB6wj -/U9kUAHowlQXV/BlotBERktrC+urWW7W3SHUu3FxtKBz6p18fq7/QZLiigGqnwR1zURWXPKbidrE -5CD5RJke0Y9XxqVPMJOiPSIB6CzOWIIXAg/8P9pp2i57xYVT08TPXjyV8ToiLTRJzfaMcv4/SlFI -PsCDUlCuoI6e4qffX/u/G/QnCl96Yyox9FvV6Mu/6YA0MafUgCcmw2VVl+zT70jjaxofHfYyoz1x -CBfo1hsvtO2LeX2zKcAvhvd71OCwwtWWz8wgLwIJNKfQn5zxCAqahAO8JwWNUASVugScbPg5b5hu -HX07GWNxt9UaeZJpJTBVUgKVFp53qv2aNpJb+lh+TOuq+PpR31L2/1lJGVTaXtqwf3OarhumlPxx -v8fg1aTi50w7E1MlFVCpeN1iHo7KA1y7+ZIah7tQGgeD3sv9rYQlAH4HeDUEEmhbHTF4J5BtqCuy -uST9w1Lo55tLPZv9Xx6z3HRsPhbo2hS0N61bXkGt51eLGr3NIe7f+elkvzXP3u2/5uMhDwG1EVAh -89PC8KibPULvhoJK+BzWPxCiuofPp4AGboAEORkoPMLnIz/efKaTVWVpFuzXGn1BHd02rwJgVxBO -BDQtEMGikdC9IG9okLZzvsnJ4CDw+b1NGAmxIqvNp+RKoRARwC94yNaGsZz1aDx/4NGB0k9XjMKv -W/JZB2r/kwIOCN4wKCwG0IEqVojtzXF76tMcdZzxr4m00byWyecG/yRERJIAwz/1SBvON/mRR6hX -3yvsc425JZSfbYxjm08HQyZgpxxoZ5BrKHLVQ0frBVlH1A0fFw/JkXzmEwDNG5lhaoXb2o3vjipv -c5fxDstdefv31iBi83wCZDySSHYlQFWKave9UcGV/+Pb7pRfNeigmkPPbxf8zXuRkMQ/nc4p9Usp -XB+EDbnPviSFW6+LthFUgOkYEEnBkskEICKjTHlANHRxcw3ei6GrazdwN3rFNnS7NO5w1OT4S2LK -XzJ61d3E9TITYeJPiieij69reSd1odL21iyKQsBhUEC/RrpDVcStTmT1NEkgi8iR2tmHBy6T5a4I -zSzvCMTJVDwGRXCCimdMvObQXf62t4zH+PaG0w7OuZJ2s4JUR7QzgYSGmjjaE2hQUGsHwR08dxc+ -OnakaK9xKlvII0y9/JG04lkgcP9AdEirRyS9JT7DW6oLWA8+Tw19UXVnBwlTnVh4ehaEJTgigDoA -7BHB0Q0NRphQgILcFdJ+615/agla59tRs6bH48FY7B8cyh0LRENAiEnAQw+2wymdYPVSbOhW+Q/T -etfJXDOWFatgEbDwjaVJAly3jj/xqC2q684VLh/hvv5+VmESAemEQpIBB4bE49FYBIoKNC8cONAh -AncJ2eALrK8E9onV8lelORgl4Cr3bc9OniVBISDBl+UIRZL9B1r6eHZQSSTE6HMOyUMEhaxZPsyR -6uwMGmkscJNg+aVnG559LOPnyG2pU+opXE7co3setjwY2tF+B6nsdVk+kVIeuI9K/uv66rrGWFZQ -ZeEoMgqDAcvf63ksJZfVbLLoClf/Ofsvirn3Lm2GKe8IWFvwzf5xNa2IXo3QHRFrr7S6mlrcWKx8 -M8AmF5Z2ckV7Qy+V09nmpy8+O+VUObk2uRK9e1K2Fw4AB68UVcg91ZyrrF+wZHVKjc71y7nCeGGD -4W+74RAfChqLxrvQbPqvYs7fGQtD7k7klBzW7As4qf9d+TkMhCLgAHsHjJadnekdNo5A3mygha62 -GVK9zrfohKND3NAn5iBIGIsJv351Zf9lZfeOBf6U9NQSG7M1sAQeCIZA4Il1hXDoaLeQ9/GT+27x -aumO1vnKwAPTnUiu0E+hfWm787Put5xjFTYDe8xzxpgxNAM2cyAzPdjAasSxfWpbHmpv9e7NnZs8 -n7If5ODn0cEDVgOBIzhRgSE24B0ortANJV3k77J8ViTwmvVLIenzryNVLdrS/4MQ1PRu+siT6xa1 -OuwZfLt6h8mx0B/7zOaRIFApZAyg8qfUkXRTuY/XBB+UH/CK+125JrTBf30DrBQRGg9ecprws161 -Ui88rn1d26dF6plav21gikNjJUj/0WUl/TEeoXNkZf4s26dnfx+yeNUHA4CjQDB4BrswbeBF6zCQ -xh3zmI3fr6eKcWFuLqp89ThvS8tTO1gNd9ozNXr/4rzQkS0ymBD/raHX/GTAD/slcOUxWMhcxlmV -JnCnoX4HWUunZKpKfzgrbi8MV5xEgHIkWcOJNQm3fFVCpIsujn8TC47t+NgCUxyDR2GpTrQb2oZU -//kyQFvUVbf7M7oorilrA+k6LOKE9iY4g4THyO/PjXvX1dmwmtevc1UpLFt6PQ6WcAWG6kBbR0Ed -yiBqxGUVIuz028Qa34fNdz9tXsMPZ1Rm2OFl1Q4HLtZ+23/Gl4Ld4GHLmWJjvxyOIE+ZvSf6YdeV -bTp0ua6oaaxz4Oddskb1JyyBxgNek57x+LGSxfr1Frvljoup2gNRMYZRa3IcYSEqxVkdBMRN0jsS -f0lhxf0WPZLI+y51ZsEJeTgAiEaR9JgDO2rAlz9scPD7JhleQ16HLT7dl6NhEDwaGhdxn715avBy -RCbp7OfaGxhO7ObNbHDWG08AABfAFABDWqhxTkVn7eHXqHpUex8RDZayL6cD9EZrxCNhBYhoyLUD -RgWBQxJBtMxe0CyHTz9qwUB+fvEiq/LbZXvqYVCCM3j5P7IqVXeoGTdUB4a1ih5u3P5obV5ZGkoP -jgWGgMDlvBHTht3ho++KmtTM0YSHkiEf9h7+crZCCu7FgcYZCFyIJODGSRSo00uWp7TsHBd7tcTe -K0S00eS0OHr9PjiS9qB/3nE+9lP99V8N2Jh9pOP37xrv9nHd5gpHEwhYINSikJB4MvBvMBEB5Xg+ -qPT1j5cavfCxt9IX0VP7Fr5JB44mESgE0G7MbNxnhMp5GipXljxpLeALOXyiSPYUBQPDgslQaAQh -jUQNm+5U7idXxC1dIi46EKjPx6S4E4FKv789JmPPNCTG48JWDwo6NKrUN+hyFDKBgCE5zY2VLr6A -X2BHVK6/0frEoEh6D5fnxTomDIY2uAnaj94oc/Nmh8qHUxcTvS2rKmSf3WdCUOmIYtvG5x9WNOmY -t9dklVL1haOvS16BRciYw4zK5lfiKEUNpwZrNMl47v2mpzjcvgQFw5CRzmjgVYE/IPsZ6k7hyRof -ariRuK2e88w9uR8LBeEoIMSnvxyoZYJhB2QdL9odD+D93L3bvciz7XD5Q41RwaAKON4VaJlOf4RR -FhUl34rLhT/i7zpXmt/pvn5EKx7ONZCxGJqFtCAtyfLV7MzKlwp3NbOwXY0j/eiCLU/LnuTxGOeZ -3f9p8rTyMfXR44jeGt+zlXDFvWgd+3jmHp/lJKV18exdJzA95dXjWWgjmOIUghuZ1jfe3UxyCJAb -r+0Nq1xbY3icz2BPchIsAOYwga4FdA4X6DlYjm19bu9vuv7yDQ1k7E4LDf73CRvmBadimXSz3Uhp -wX0aw9IJ2zNTSaaBzxfLzUFDMX9j1QocVfUM+6dkg9OBpc/Gra/5wyBegDdCA56YNlDAX05d2iH6 -hge76pzwuZKgSh309qvMILD8bh+iTeZ5Wxc2lud8P71YeBc67ocLCKHyM7qgdJkgRSE97UAvZZ3x -De/L2JJnOGbUVB8M9EwSmvDCqb7LxnmgzSNG3vQK3mQG0XtU+xOBB5WD/mkKrZHYtaS8l8dXWlQx -Qxi9sO9O0+GMsK2dBOuDdo7bLl5d8nghXFc/jCYRoHgEGJFBXlYI5Vh8kGOwIiu7IoTvnse+4LCq -1XNyU+NmZdNPjwSfCPkmlSlKSJZ0aB4L+0iei4SmfeKW8u1ZGCD6MuBmmd6PsC8vstYvm8mggGCM -1leXKTV4NB9SPy1cEX9km9HJiPTqaK1ZJV0xWCfQGqPQZDIC6eQJhiZOQN8nYZBYwNBAMTUWSXJB -T/dh02M57ezEH9/zl0sRV72Pyd1n1hb9P2uSiVgMBcy/0hwe8GhoLGTVrRYlEozszqp/shlOPrE6 -rjDToL/uf1WHIrL4IuOFCMXklHPkjFL1l0vHf6pSmeuAeQMyxQlDAFEx27p7Raa6dodj439HZe9T -D14VW8YcRSHx9G5EIYAaQOQOinDELhoXWHC8oHTj7wHvxU8KRkTX588hMjsf471zYW13Vkal+RqT -heMWL+K7NjmNzwF7QTX31VNVRMB/vGbs8m2nJVdj8HVHCHM8MX0aFEGA0vJQY9H4sayz63HK0sqD -fL92e6tutwma2DiXAHDHBCjg2OO59b6ig72ndNK7CzsXmXC8T1mHnQukIFGuaOien9SrXogdDkMf -fRUXm6uplOLo8uvDHKQLCYkDug6VPDWTaNrJXyyVk4XkO1HWgdEiqH3QKiuZQwBDBmoaT483xkMQ -VZ3r+BveNruEBcZTrrHk/f4xBwsZMAQRQ0vWHd6JUD9/Z6Ipx/4XW6nJkqepN68lMofROHDiFgpy -Ot5btHHdRiwghRhH1X3sHDjV+GkODu8JxeMBB/tXmh3BRGCXjn40jxRkD86UmQPyRqNoc+tgAppE -wGJpERcOQ8YA/Qyq+FVI6Z6YTnKGckiL1Ovglvh80VaX+RTxPoBTR2OxZIQXMPQheEGNxk4lx0sh -7PnF2hviQfE+2TKXNn68PY8Qvb0afcaPmK8J05KUMs3WVml0OkowuToPOXOMwh6rsNzUc3nFo+DH -ImUB1JpQdaz9vDhUmyMrnVSF4kYnj901NUqhdu9y0PmJno9kuOJyvaFFohvE39/k+JnvaX5E7rya -pM48rDto7ymuJHqFjb9w8bfkcbXiEP+Q9/yUz6lwk/6YeRSA8AswvyBcrWJVY7uUarSg9klm4Tj+ -wotifaV5YMAkzaq3nj17Ppk0bTHVU7py8fmYcJjsplc980sAVg38AdQDwglJQSKmI401z8bH2m1N -bv9uW3G0dOS62oYWTMc8ehQMDg0Kor2JGFpqibtuzC4nVkumJ9zfVDvcJXDvMtmwfxRxpztFI/WK -pASJk3e3p3Z8ezXx+VZn+uwR4hwS4MwG7V6ghrlsKbfBj8b8I2M795rn6fcMTHTL1s6tpI8BLcN0 -D6P1vp1TvQ9UVS/w6lJWv1a7ouN1aq+++MLoQ3Ztc6uCJmPGu183ft6pM8wSoadfPRn/2vpQhv6C -eSqaYXOKmm6l/9AnsMUcfx/nNKkRtTqyZw6fyiChnP/05VFjr6W7MmpFfmV2Kmvq8KIO14yMzC3y -h8A+lirZR14NFR+KQlo3dxSrya+KWjKXAAb4Ez2P7+9glbtj9NpOyr7dg/WVcpvzos+PMUedsVSy -67Q7970iu/DawyUuAkHBkpc4fTeezj4XPgdMILnTXh+CtjIJclMoBcKD3NoiiwA3U2m3RqNLctfn -aJ40CUZk4goM8qDh1B8ByileNxF7gY+chCuxZ6NzeInG2cpc82nigSiFiPSC+NMdKk9D2de9jf+V -29sk9qaphzP283w8yQUyQZtq19z8VqHYc+CNx+czDyeOEENDkudBUVgCGXoVeSnPtsmbsp2Rjgu6 -Uqopcqj6rNumf2GdEIzZBTLaBQo9oAxYV1DRwSq9KA5zy0adFzU7mg45Ts6jNjN8CCowJ8uY5IpI -7g6OVvIaE05wlp2vDmmujOQCeYKBtuyc/d3OAeXrOBuVgl84BHvxG/8LDyaHQV5l1fUFJZd3Pgha -I/ujnXdZTPrhA/7z8HhgWA20BU+aUfi80STXsuMwdWlLln0Rvxo5Mk7G/V8EoBk4UECmMWq4b697 -SDD54K6Oasknqx++ezKfAIHmxkE8oCIVOSmu7SkY/Fbq2CLs7rZX+fXz4CQ01Juzh3fKjnE67zpw -NntLV0YLK0Yvu3R+EloacHb957P3yxSXmJHU0Ql+k7x8CEe9eVCoM9OdDsITCXQl2njNTcPd/N0z -ufb98SXfHpZxGOohdh2cR2qm35jRxfs46x7IPjFe8io6WvHoMaMD320Pys2jBE7fgUsWzyOzqKgz -5472r9bT2seZrS3kYxM1NwpesDemdiLOQN+75erhSFvr7/eGzcTmiFxBCloNQT6gK7Rnx9auQnvD -h0MWqSo7+azjmWMYcP6f/oQq9kbmFIlIglC38PNMmfqQSgdb0zlIIgpoat4UoL5oyw8ebukrs+dt -WNE9Hhr+pD/VR7np7b45cRB66/nDZlfGkkjRlLIHnPwi0THB66qYQwxXziNVcvX6HRmbvL6juaKl -rQc7rYXmoMAOMWtMYKEQ+15k66dtdU02HedYS6RY83zmeB9/52yrN9melkdRrc7zf0jh4Nuut6xA -WYM5/0dgLX7mM6fA+CWnBSrvEAlO554PjWbO4San86AUJI6IhmIqsEm9Vih4VBaDt+yavHq82Unx -xu7jAhHMVUhocDYZgacCLXoqTZcpce198/tFhYYnrtjrfkF7v99y9C1zCTIa8C1IZ3C1yJSpd+QL -9RW55CmGW0npOpd40DFDfHPnPAooaAK4sfvtOkvtfTXYd7YeVYWV/hYOg+nzgO7gUhcw9w5duMzx -U4a6eN+i8NtDCS3kAc8by27Ow0N1OBWlo0vE329Ir8nyT8JerOSObXR+lx05jwBjJkN68ftlOFTk -smfex+2+nXHBfGvuz5gLpc+104NhXGWyoo6fPaut59YdIcPmacGL+uZwCGQgyqLZsWA5vfUvWhOO -jIsuuqBB/uQVmKbBPQcHxgBT3rx77/Din4PJns8+CD1aI5VK4e/Tbv4nFmxouCUv2F2C35tbO7LI -B9zR98wW5FrzD7CnApS7MoyOipbIHbE+8+nbIdWmCK9VE1nzwahZQbH4z1eL0ylvlrlzsNiNhxwf -eEr94TWfwtRb7hE9eyfuYo95zI37GiXfrfQyrwbdnRf2pNd4vlSDY2DA12MndG2qsdqcVzzPmWjO -B0+5zXfI9S6htQqF40fTNRMtJ1eYWu3CzQcz8Ts2yZSqjxmGuHWj+Mon2A3pgeq/533zYGOfqgUr -h00btxgK9tztnCSnFPJfFLDW3D+fAH38jnAEFy0iGMMEE4V9Ow+hqs59FcgyyULWrn3rcXqOlAak -BIX4jIZoin4oj9cL2o72W7aWiki12KzoveNfePqwvOyTyB6X0mqvjJGdkyILFy5kNddY9C84Bk+k -pdwc0wzcPvmlpG06Xb1pxcO910Ois3f/i8Afb8SrtuTyz/A7BQ2Lc3cNnw68Z4CyX/0vMtMjHW09 -WZ0OrPSATmVB1q0vcsd1nCMq/kUBDyZGaTEOo04PFJgcX+PL7XCgM7Dp6dYVWXWfd83hi6alpppq -9TPVg5cr/WIUNdzP9J//aR3j25f3LwL05gpKqA5aHyjT3eR3hcXR5ZeMJ7lNhdD+LxKewHjHacay -DOiB4i93j6OS+O52bt4evvXFAtffkmov/0EMRGMLpDqDBYK/IvPeuoV4phU0lH5omgMFQkY8Iw6J -sjn05CrpNXuK75aIs/vkLBV+VeXOg0IzqbdjHNX5rxepZx30W2teGHquYd9cfQsKUh0xLvR8MJq2 -xu1UR1L6Ws6zklJ3dsdGI8sEXQQKj88nQl8oAOJsxouIAqEvqvjOv5mM4/NzOfj5/O/5cHA6GYsk -EmkhiZ3hl16efefbYnljPSu2xu0v0f4yMY8CiK0s9OJKiBHWXfzu1ebdzhPfbnub750TA60bbezN -WEYX8V3/eexo7b6m6KHaNV27TXNP2j/7NwmQzrGKezTE2/2T2rvyPfvGD71xQmZC89L0F/5CIPfC -Y+38XLfQG/L84+ihlC2hc0xSUDFOCBcMVFmU4ys27O4a2yu7bbeHm/AO/OSldwLMQXoTR0/Xmu2t -/kk+zQJ/h7Njvy5OkA7Y70dimPMMQ+yKoSU6vgh/8BwKjG7l9QjxNhP7bBHf8HR2ogGLAVwYEjvt -xz5sxu+p9XV+rtL+9LvLniV3LT1Nx/8k6Dl+BBjlop3Q9NUnSsdMBP1fPzfZEiLluGw716BiIG/8 -HyS4soCE9qCC/5yR75fXmhjjW5heUF9GKTAqoibyxv+cHWADbxCMJJEocNX/1JaRIUufe6kmwmP9 -plsKbPFdR1T8TuyFxZhO6vx+ueXsxfUv97RhFnS/PLX9ydlC3DCcgiOSjIGagapuX6ltZ1tHx1GV -qGB58R5DxfgVsADwHoDqwXgCrtAFuDJjKLHlOXpngm+S0gXvSZTp6MMrH74FqcPx4E4lKD0zs5YG -l/ZvWYB5UjTcdIalRSr2zpiGKCwLtQhoMRFthgPKQX7PWWUb1L/jxnPOENUNe37juKp/zQfjaSmB -hucCOJE0zRx/1nae5W+rV7KfOsANixLwKCoJWj0ye15kL/GI5uBPSqnEHkyK0GCI27lNFvdhBWh5 -/OK6o2TWXVU9fd6r1troS7Hg3LI14IrTZm+gbQYSLz54ZL5denR92OG8Zq8bkmKXuwaZI1DS4LzJ -PtlAvwkXl+Y8ZQf5kMwbNvvMmSPQ+3SGbm9MODLZIr2VZ6Oax3MdueqvS8ouwr4GGogheqoS8Fjo -Bd6S0Y6qy5vAZHjkxv5IjRN0lmqRYE5CQ1AQy+r8fJxQaxSbdCE0kXWjAflOs9aXeTBGc2s8HKHs -d/b71tSPzugl3M6Gcl/bm2HRqfdFX8I8ZXF/HOQ/+eaXu8zYx0d3dPZ56GOID1/OowCiaCcdcOyn -O/1XEpJmJQKe5evFLOEbv6Z58rTvCvbChqUrz80jiHHCouk7MaDmREDx8wUVqX/K8+XjtQvy9rxn -dWgeBcaa/Nabqz6Xb7lk+CD5lcq9x4a4M0FeLPOgjPuuiNV0yzO/zq5Xl3DJJlz0ZU7YUOc8KBVP -W7OCoKCg5SGkAtSvMnW7w3b5OS8GXp9b9O2snMK/SlCdIAmLrv0L3Eavxj1adu7Qq9PhEovZ3pnN -IwHtCMQT6BUIxUw3TBde1LxjMHmp08LegbuvCb9vtGJuFZBiTRA4krPpk3KzfaKV8dHallhLfzQc -hQbNNG3norzllorrn9OD1RZ8/s3iPCJGWXlbGB5xcgLCVHqDL/z2foW3lNGNUgVyzBVJsUs/tW9L -wlG0/Ckt2I/I2Psg2rW8v8T8VM+pse5zHxJVfjJl6F7SkO4kHxt7cnwjcoXpijtIKn734hlQ6rwL -x9J2edDna581/Aoz4z+Y1XX/IL+q3FnqnVXSSXAQBg/5dMbeShC9KW9xsum6yrqtXobBu70NZPuV -rmXCokQUbZ4PCkCcuCQmfj8q2qtfsX9Jv7//UKzKZTgIGnzMfnFaa+Q5dVw0hKnVe7lPRelJT749 -pcgUxeCdMXgw2sQSCFCT2+ctgiG9bLqvyH+CdVnakxVyq4tL4WhwdwAaD9UPtBANXFQGBa6M1WV1 -j/ffoIwSP77dab3i9oF6/Yk3+VXMhcBBC8OM5Z9T+dQSiysTblrKhhxqfSZvNuYPR86o4/1VSWHB -a0e9WHacDtqWI6UqvxqtDYeAyT76nYMr9bEEKO2ymN1iUkysa2v0b/0iWzGRkb1mRjLz0AxDD0Qn -WFoztsg915fmKqoTtyAgfpvVh4MpJ7/umkeEhMbS1poyJgQEavLsTrhbfk1Yr7TAAfGuv7Pn8vjc -GiAVl0xNuecRunH1Z4PLVXYtrr7sxn3MqFn+IotqtAz588mthckr7krdKbBYucBMixlIpg9HSFnh -1WP+z8Zk7qVjduCvj8c6b//EnAEnKhBOJAK0ZQhsoPRIjBq/OLnz5xkB//EfVMTBoWoOwSTY/gvE -VDgkyWc6aTMceLzRNFVA+GTslXLE15ObakS+w5p0BsjICXOWHotmi9N+ZYUr3m+kEuup/jmPCs/B -LfVQCzMdNBmLPp0Zbi8Q72CyLdLj2jM4GpzeJuCQwMBx+u0c2mlpv/X2wDIDTdlXE+pDqt+/1R9l -wroCISDQi6YyqONnLm6vRz9exNlqZLce272uTuwmrGWcRqE8KNiVEYAV8oREnovk2uU8SdxkiPFG -PRVr9OEVic+dW4SEdgY8EX2iZvvW3EmT+qs8VyVfNelnl8nXBlnBNi4SiTG1cz7bRbO8RM5EcgHe -+IWVqMmDRLdIOALKmzoBpgNMgELzig2eOdv6f6YZurXjYiLk0xYdRx1nCtJ3kVEYno5mrqenxowu -b17xvll1YePNVrWcE1k63SmVQfBiUBslAX9DksC5fNoOqayJW1ERpmJOsiHf9rK+X3RONVPI9h9w -EnTtuOxRbVsP0cTcvsjRhMCMBerdTjh4mEIlTjVVxqzibn3bx7Lh+eQXg4VWaQ+7dChJx6/MT6Oo -OCrNmoAalY4bxGJ2f0wS0rHmevLkKJrF8t6r+TXQOFoUyKljYrt2Mjm8J6c3OFLxtY9W9q9789PQ -zkoizfhzN+RHae4fveORrR5a/DQiy+pGAWxQP0sBGlU+OzF+4Hv21R17WpS11NWWynE9CoYFaXES -vcVC8fqUjfAZOd3Qsix340t21sPHsrX3Zvr+qPxHDZgxnMPCst7rSZfT1rzXQIo1fItuOFQBOwak -qzFiT8N8P798k5HxckF9U+PBdfKRmuMOcBgVD7fH/Vh1N1LworPp6nip8AePdj7LO1dyHY6mt/0/ -1v8VCHSs+1z1szikJ01xW+jlxNKswHVz0EAfpLkf4tI0PwsWUemrT4x2JK8N7OCXv39gTm5qsHqu -97PwAUF35Be7E23nc5PFPR7ZwI4bGOR0vDpz0xUfQvHWJqdGNZ3coLzA8+NLja92bfgnFWiCMYz7 -2Vn72H5hI8/FW/habuRd/QLrmOgwlAGBotYfTbXXT1IVN+0MrA5Y4BZXlcAjmD0XSB8qrWRT3uoe -xFmZ3BSfejZwm4qrnrDnHBgQiYI5CQaN2zg8omZQv12UOi52TErm48BYy/s56D89g0HS8oHyNcIF -dl8Wj6hFXj/na+H7fA4cDPFATPa1dYHhy5usg9YrlfwHb6x58kgGNr5gYIz6pSUCqR9c46qKTI89 -3vfOKdT8WtexiN8f5qSd6FstJDXsb4rrPbrVJK/smCEX8XtCKMRmDvCPhLplGzn2qYAPq03S8mvy -eYUcNdl7YN3CDBrEFqXqK5gFcV8eOSLYvqvuIF6SrdRiDgwYMjHejcI5Vtuf6/x1ZPNL+85EsQoV -ZHHADmPopBcSMxXqTL2g4THplXl77Z4NWSMqNrTIxlsefjhrBzCKgMMRwOksKp4CDE6gTl+b3zhy -2WWpeuvNNu/ipxLrr3y6OAbDoL2hTRVeSBKePm34YUhcbTzzwcbRzm/xcZqTnwmmW8xhQNppD1ap -bRi757mkS+cWjliurn0x3lFyG6YwDnhGaGUbmJsCufQXxhIRvx/d7d9tsjhe4vDhzH45gz84Irji -DAUur0EgiZjpfp34XlbEs7b8udtPq4stZU9j9RGXeOZGp5K4R50f/PrE1iR3dOG9B4UvJE5Srogc -nxsF7TZjDKLpdzJ93YJqfPr71pRk2eaEitzTi+emydSp0SzCJGoSH6Mc7duSdE3ZzcQq7ccx/blh -Co7ohIGeuMMzeCvryFrM0oyktIhHUR7Ri9d0Mmeh5eM+eAoS2vqLGlXbJaf+aleQwAbvgkdljq2U -rRLMWcAIMp5WtUqA+oJ96NOYPMdbH0vjhdlHG/9sBjNBHzwSh0EhMDiGp2Mlry45LoWqGapWytol -EeokfumAPHMeTYYyjdHbvuakJrTz69zgPMIbZiqAGXJPmwMCT+WBdo1hSGjQXUHeg7uE+4Lum2+J -wfXiT+r5w4S+qh1TZK7BeMGMOxD0dHfl6Xxg2fdLYfL0/gWriivWzfGSZzaPzIuhtksdP48nm9vn -PNUyFnmun3SNOTmjaeTLOu6UwZCazHO7dq+S/cbxccdJb+YglQjm+J2mJkpdB7kwEa+TXrqTOiLM -DiW+lY3EHZtNA4NyFwS4awhBBgRwSJDqvZi1S2c4pab8N+/iZWQ3hdsHSBv/oMgE4JpIMmg6gbjC -CQ0M7WmW2992+UKSp0+vctWO1S8kj+0ekP9EhGdpBzVA00+M3pvrWXZJaZR3cU+/2EmTm3GWTSwq -OXAw4OFwSIoVBgc9JPbjY2TJ3nhl68dDL6wN0q8pWucGwlEuJAIVSjwMrDe+WuGsJhFT8szVkB15 -YpL9/Hs4AAPt9qZl6dicbq3dWiptvvfsd8XM51LYvGspLbAMmUxFI1SUFTQ2g5iTv/HgB7NopP/9 -eLEcx8otctsDTOEwLMGFMStHIrgDA3Yw4oGyQdWPo9brbYkcbK/Rmay/82iDvgXsuwAFoJQOFOJi -GNH59eSXUiS3J4pDz9RGl7G9LG++7oqBw3FoiivBCWpxteqv1xzzlzu1UKLoZ+yKsuQvbYfl4BBw -dZ4XuHXVC+Z0oFM8P6JOJ+559uxOs91rh6tv9YKeXYEXoZl9YHRlObVQm5sgLVk8thM7GFOGuLRo -s6TK+ywSHExGY53pjRDE9H/kRNYN5hWfvDSuEBDGf8+3VAcBi8G0vLxzhJEs0/BtndX8RyJVf4cn -7l6VAcdSKMD4h4AlkMgIIhiJU0ho2jSIoWJBTZ+nNMdzye5n/FtibPiqECvnFgApls1X3rzVj1Mr -EPfZXBescyXw55FdcBSUanUmEQ6D+SA8WFFkDApSWJ1wK3E8NkUzP6L9xTOiSMrrgptVfypMHVlg -vmDr3rrm6y8lNytzXLq4wDWtxcZvdmHgFYKHtUDXo++pJJAYlh/q4INPF3HaWBw9XP1ccGCBtMuW -TjWR2QsxiURXNBI6DYh20cfeBodkk2TGFFmffv5wdyDngJHw7BZM8iECY2skmgyd2wIiF8Qi38q0 -bUzzse3edMUv1tm3v+0mHEJyIeCVEG60wzxUmhz0DxWI3hUetCreeUU36fP63nKmEAisVctTsTf+ -tjv2lAw71YCE7/38zhcOoC1TAC3d9PF1uV+17oV/XOdgKSnDWeO3Wi3+Ny4bjqVSXIHgH4OCrPJ0 -azF/ItOtmrvmgnVgo61E1asbyu2vLs6HQ1G1qexK8RuWlx0r20t+dEf+Pn6vZgMM50gAuxKZDM6+ -EhGM01W0V8hJDob47T9/+bKgV3j1l9iXbBgYGIUmUTDO0DVBaoVo8YPAV1RKq19hxmaVG0E8+7ec -haMwRHAhgCdguBi/gjRezUuf6zl64cobO/QjwxQfbhoyc4CjwRMJaasBd1x9sVqXL/fZkkW3laVV -hU+y1jovhSEYu8KAsbA7mr43jwwM8dCMM4aMf58O4zF9eIY9IOVnTjdq1DviHPJfdUA+aKHrq2bU -h1eHMPp9I5xlthoFqidgeaKCkgK04DWZrCBS/une2ENLE9Pv3eO9d4lvZZgS0DkqG8pNjq9JjUpt -8fDMSTx5I5ydErseliArT/UNq4abRazGOfEnM8vVllvJlogH9qrAMa5/DtW7AimRkid7xMoFzdgu -4OIw9SfNS5mAVGCEAVXC+zedkV4d2uaua7M2nDetki5BtcD1XSfXGetm3locOY48OlEeuYa78DtL -apArqaADnnFB48FTFsBcIv08ju+tVVc3nsgR55MISNU58p7yYfwFExT05WBOh0KfeVKrummyXIxn -04FLkeVnDKOJe7b7ecKjjLTJB5Gki2olQlFF4iq1vvd60vHiblfhCRzBiaiE8MSgafuiEs4gbf03 -lw5P4Eu+30fvsVTtGFOaA4TqXlpe4uDQkpHmS2EiKuxyl/YOVwfCIwQncIkpZGPG2ze2S/WI+rVy -HLlnVH54dfD25kp4iIh0Ymya4jyTtL772n6NhabfBWSKl66M8bh9Hx6iZZEga2TFzmbief+r0P0a -iW/sVjvU1VR5mTCAUUdj6aFp3fVzPw/nbn6XOXJF+4FlnI+R53lxWAwsHLKt13bR3uo3K1fLnURm -ubrVf9mOgisM5bRBwLE1dze3RqHKj7oIVh7Mya4FXrwkGABNW8jLUXactDOE/WDiOcsivW/Vv6RV -x31gS9P6hSd4DCe9mvMXHrr8ITa/9IbWu6cJfEeSjIJ4WJmhQIMjUh2xGBTA/rkYW9Fvbdwe4Xtr -Xd8LH4tR3JxaabkI9oadnMhIxs4AqB4xK1UGtG3d2e7i+4u6Si4tTXKccIED6Vvj/lqtBmosPy9c -GChv1KlrvTXxY+SDJuHrF3/BaDhjiNAlFyYfTJxUexGYM0R8x8Yq5XpjZEIIrjh4kK8jBk/PmG7V -dAvoczPO88N3HVp2RMhOzK2ABYZyQeHAzAFQS2C2whXcoEQ/3bZ7GVF3d/ERz2gPvbPdH64pfly9 -UJKJADBWhBFQGug8oPH0eeA11hNb/f2rfc+UNjrCCaApdCeEd4bWOr2xOZWi6e+ueV7mnqCYY7pu -gsEnONvnioS2Y4Feemo69s4pAf1kweAfhXGYCynXu9U3Dg4fY4JCGeHC5bdtTrx563F8aeCZDl8f -3ocf98MVd3eCZjAkN60PWvQ24ALp+tLeoJT1dixP/XLhiuOQUEblXub33XmL3Dc90uyLXtLMitji -jYdzSmDrpB3cRganLab/CmrYKRo6kSXvI4vSzfwfmkU4uuIOqM+tAQ2+Dz8qau3R/T1g18eSnP3y -5GWtO6PwFGDV6TET2NCnZUCVzs0/XzUfFRcvj3tMzKovDrvWlVT4DyqQWynbV+uwdtcPm/fej5c/ -uz1CGW2CiwlnoWgsFkMEwieaR0O4ebkD3RgUux9l//pEQvk+rZst/P3tn/O6cS/gwpL5xEi0W9ON -Eb74YzR0xcX7lyccZBW8VjjI1v/vaqASWejQ/TduHJnnb/ceGrjdU9bE+kJzXiU89Fc0bUqB7k4B -4wTZBSW2D5/wjyI6BcgfvcxMaqNS/Nsu/CdBaELW73XJUN/IRbGNfWovmnAnNO/q8c0rxjAEfzzw -jIsobVaFugI21776zqd4DePlCbyrreqcDj2O/z+rA8JQqD+UIrKs8ouqNK5EwnV8n1ePJYXzP2pD -cyYnyyeWbB2YHPn8MCSWOLInM0Cndz45PBIHJuXnq4XdvNtXcxcLeLRZ7DApdLfTLF2wH85//w/S -oCo722+Kt79aYswKnT0H3wid8s+u3vFfVKGUwoemijUSh1iE2bcGtV5I2lL9IXDNfFr0jlK27Iiy -0QaJg7sijXR/ccUUvHm12YY56oihzDhlil9CLzixvkX8Q5avtYe++/r79g27mbOgmwfHFLTFlbr3 -vBT43H71oJYgeErxWB5XjjZl5izkoUGMi3/d5k6Zp5kPRuMsTusdi2k+zTlHb0TjiMDYnghclOhK -QpKhBMn0IX8+6j9iRR7Z9y548GGdsKcwT8fXORognBS4e4sIGdFXQdr9BoaPe0uGK23fSRsFtaYt -3MVci7FMiIgkAS8UWhPFCCTojxkR2Po1ceCpCNftNY2B/DUBKMEaOK88vx7NtmbczQznTj1QlH1F -TGW4RlIQeZcdx1xu2j9ASQdos/2MMwBSy2VkPB6pl8Uv0kIcKjmfJRPT0/4vYrQV/APPBnMye+QP -oF63jdb5fuNjO7ONOYzDAM0FeAoCbXm1mJnC+fNdBqmrb/g1fI3Uei+GsXjIHAZeENDGyYDDI4Kb -5cC6gW7B+hqBq98cZfj1qM5CVlXfDYbia03nUgG3VSDxTkgSUMFQoAmaIWBUS1tCPWIcG4K7ame/ -ajT8c5RnlT1R9socD8TY7wfZ7nLs7fq2Djvb/Deen0yEUR+X1JmuYo6SkFAW77OdNk9vQ5u2Bk+z -QCP1UvXp+vpbc0DOKHUFRTWEBm3p7Hjfg4zRHRkKrQJsYx0/VnhymrfADeT/gJEIJdph2jnRb45W -lYvwHCbmmR2s/xKjNKDENQdOq3loJuZj3fJwEUTKoe3rlntvSV9glbCrkTnI2LJxnUUtdu3AY6/j -ypcKz+466eC6oi2VKQVNUfJs+HRerAnr4f6is7G3JmRP91ZheIDevB1J4LJr6GMPIP97Em98+pR9 -2YKOa9y8J4rutmh8ZGIR6Dx0pC6CcYwdlPtzbX9yTpjrYK7SWHrcDscTmg33574FoJUSwN1hPjhH -Au0UzQHLa27chzMlE9baYfw15A2WZ1bywEhgkYd96JcmkHCzFt+xLHWOLEtbJvQ0TdFNM2n9tuLK -fLh+AlwaiXUhAKArbTJHwu2iW3Cf0jajO94iTY9V6s8qSMFgBCSaSDtSatoTmEdVSOkZWa8PP78q -3FHf0GdvReoYHErLBdGCevrplxmqmoo261ES5gLviInD9rtHt7WR50FBbPRO4N4Xpj5XJoN7ODZN -ZCd2qyT0wWFEhBP0LY5ZZ0OAAu2h6i973kXf3pPFmdFy9WyBM89HPRgB+jgezIXSwwEBEw6dLUdW -qOks6r3gaqq9csy4HW7gMiMBgD/s/7t3f8MPgdKSwzH9US6bFtfYwhGOwAgEyk14P9aqL/pYZRMt -pUdZIX9XtGHrU0M4wGNWZOiOIkO7UDOuZwbWrObZybu4/9i1E8djVuV+6mFCzxyV4LAM7zN4/eLl -4pU66kt92HYZHLqoGbjIHs6bwQi40z4tE7B5q/nK96q3sNz11c4S2g9PXHNyYi4AWfqpi3dY7r4U -ZrrxYSWGc9vjVqVn6VHtOvOy9Os6cqOfJ1Xvnejehd4auLbGCkN8AZf+mMGSsa6MCye1HwsIq1b5 -oneg83Jy47ozjp2kn0zgGZnnGXdu6eCm/Ob1fXbnW7gTHoKkAYXds49gZwiQ6JNkhJ1t8Xl5Gy4V -14blG7aLX1b7vDkYvjwU8TuhoT8gXFyVlZRUoD20a0Yy0fVvhvv4NYwI7xdnS2K6fd/AKZB9UK4Y -2m0jKVT68W5f14VK544ppYyM7SxHrdm3Z0POtSg4GPJ5uvSLg9txyAhnDIlMgXb5QTbP6WOweMnW -jAuLtAR2fx4IadSs0YURAm0t7VTdipRTV5azCYTt+5K5etHSZT5eK1dKMwXAc+toASvaBbhzMj21 -s8SvPnIlpn3rlgQFxU0TqzJlPnyBG/jQNKhUWgCh0Ocuwcm95sg67pVCMcFnwsc7heDGM9OQpxqI -Xa6yGNpLEr0gsO/N59rn17w+BpDh0lGgw6M3BTmZwrC1l8h1/HIP1naqbShRUGlLYEJA5hTn4gw5 -aN/bA3HudjcGb2lJ8nEqqaDKrQvhPBDdtU5nypHYmXH5RGDmBsUJimqpaNfggVJxN9NA9AMYFTL0 -E0rwi7VXnFWJcLkmE1D2KfK17ZmNLivgADQKuIonGloRwnokvQ35NU9UIT+P7d1aoqNk3U1VeIaE -psxw0kvqDqK19Gs8PO4+UU0sLZd01iVXwHNAQwUPwIFS7Op6w1cMDLO0LEpvHjh16hdHLlc9XND5 -x5TQqn5/m5oDg1Qbg0Vu1GWa2SO6j+Di3ulJoJ7FAvdVk+9JNLCzHH126DK594IunDMiUx0p4AQ/ -iQAdoIDEQjC7s98prtqvNuHn7SWlv2jKGoZYmjOH//CgP7l/sh56y9oW8cohxOVB1iNVn6VnYGDa -aoJZ8finjqoNKQ4K7Yi6rPt7K0W/VQWv6IQh6eYK7MBU2rlZd4/YmwW+2cilZzSUsvZMWV6Kw0Qc -DOiFdmTMfaHJU1aIgnRBUAjA0+DoK4TkOfiaNhZapqLiO5NrD7mNxClnR8Cp0ZZNUVwZJ/G+Y1tm -N8Hb2pjqu3anmuZviyV3HatgOO/NChpg8eafNtYa+g2XJdkEnipKSh/VdeWfPYvtBZ5YRgA3pmFw -gM/3RM/ajtEe4Oj79EObs5cG6VaMeWDFjU/3ypjgRBIaS6Dd4+2TYpdMlqe2f7muuz+47SRfwpVW -GSYUCU2EqmPifhiLmYqdnEaALPL5/Q3Vga2JC+ERsPTLUH3OzXUHXlSLOyLL39wr2XP/6azJR/Cl -g+YWOgfJBZqjpzdxsUjegVrRt0cwXbmsBthXlY6bXsxKAjqhHalTwQ8ILOO57rCpL37fxTvaP/ZK -yi3aUfPg2l+AC5r2MQMKY0fUKLZgNTFZsKawNe7iGPdOid4QGUdYCjziCHKGeFaZTtmTW/y899Z1 -JCmfSFgwqAYLMAav0DG54KkS7VRj/YOVB1FHXi3S2sZ6rxktVvwUlgSXOUyZI8VRb6MRA8PY5vyd -aqUmDmSpp6TXsBQRPD0VzMY4Ai3QnTblD7iiZe5+VdbfDbdYfPthsmL7g0lYFni5aCRgaelH3l65 -eqa72WOZx+o487hvR95Ikm9VpTHhaAvEZzZEFhGDXsTw4/i4J+JLjyovGw5bqDmbxSJ9gLYL7qCl -n3O32X7PNuk9Nc8O/5Z1yo0wZL3y+N3G2Qi0IpexOB7ch0AguNPW15jpOcqVnv+12nf4WnpEzGqR -U9wOs9YA0fYT0o4uox25BVIo/cxfaVYaAq8RgxKezYauho2n5GEoJycSvXHJ6lAdRDfdOpvpd7Qk -ZAfWulT4kgcMQEsiY8hEcL0k+M7PXS1T2sci5bZta0SsXYAP0kog9sPfHLRIm+HzZlyVfxly936+ -TAuPJP+UrauuVJE58m8yoaHsD/090mZdMKuLgjeF2Ib7JCk4pr4ev8vdygR1nrHIPCnZtsq/JGkj -+wHXHATXudNR6zfrM8VAoPH7GMeuRj3vMQVMW4XKY+tCBQ5DJgD99UFvgbFDc2qfBWBdoG5vHC61 -ymJLTq3mmBV+hWDZt2UPyTf+B73phhH90uN5S5fpV6zM+fs7SMhsYdFf3vBC0JThp7Wa/jqnX22Q -4iq7vlOw9XLaUm6Y0jM/IMPdvGcotHbhwRorHkN3Ve6NRod102AQ8OShGe6wmbNN/WMSpxanv9dY -WnUfb2SiHdvfFO2Z6AM8xj3uWohcrqPTfPvlqYO8W46vFRL5wCnBDJ3aq0P3pWlbHq8+Kvfb+6xe -+uqq4zy9ug+Ke5my5KmlUo70r2zl3c+pyQ6sW7+dO+5V/4MngfZvLy5mhk8vcZZuUc9c+N6YY2J4 -5OFwCuqddHaNKBMKLL7lHMc1BfxPbunljwclPRcRTHQkJuGKz9icPtVun/ansfYiykNMIq10z97V -Mszwb8EzZ2Grl+Ngf9TA2ffKKeoDZ/d6NYwEY4ID5pP4s5rDKqwWeDh1LTW5uPvCF8E+B6PnZn0w -GvRNArTDoejVzDjTerqpkLauV2/tW21n8E7uZehh5YU8Vr+H/jcxUKW+b4350oq1VI1KAZ4U66/D -SPRZzn9Vgfa+zNBqmSBj/NYc81DfZH35Totv+IurJOt5tBhWzZVA6zU35d+IftzGhiklFuhcTbHU -kH5ZfGkeCVqGGjozH1TwWt+uoDNw8ovm2v3d/nEJjwRFOrn+SWH6OXLayzbZBeGzimp8xQcOPrwq -ihY6/U8SRCTjiMFVKxXcHTco+FqoxmYdw6TWNB8LdZhHYmZtTn2LhtMmvjJwGD3SU/Xtwdd83LJN -elZv/0ln6kgcerUcZUFvty0ObiKJBgxzWJge9RBZLsBUCBozfl01pHtTbs2JxRPhTkIjGw7Wrl0K -A0Bf5mLYWvqGDZrp7/F/kiZyvjLvmEtfU/2CI78IJxY/ZCZgSd/X5kOb6H7Kpq5Rzs8xvvS5mm7/ -5+E1cVEu62FQ2he3Zjj7Y3qiFs5S1qOJwjbW9ifQrPUqmn9jsF8+KtZNXnV/4wmdoVAj4eP2Cj/E -Ok8E/o3SvCjjC7IzPHGlpFbN171coXF6Wbpx+4xiU1YetYLBvUHzAG59nVpSwLAuB7FBb+qiipVx -9+MOpsSzBxRntAX9LfAXlpmyPqCCL3HljRPvWXOqSFd/3RKthcFmnM/AGzTEaVw/Ul3O8d2x/i6n -bnzGeYW/CfpWXdrZdoyLJR5LUHc/E6+5eStl/65Dxf6trpoGf6M4NM4RTSK7YqBX0jWZcu2R0kFz -5ZYNVeFH+H/tVNvRA8OQXciYw9CrF8CqWWECvjhLHXq9KO6zsBHO72IGDAB9zxAIR6Ftnww3VNDb -XP0imKV3z/L9uhL5GfIBETst52JpX+sAHtGZHu1vYHkVTD5z/FthdUr4Jqvon+nsZTbzCFhZ7YZS -8DhUWYSebwebmQXrEq2CQuGA8x1/kwSC4wwzI+YRYLP+6Uv5Bg6FbV6F+IUVfXJ3/2aAtuo53U65 -Ow5K47uvVVZGl1tIeui6a4tnm8IxUIp5qRXlgeAzdwGxS8PKnN9RP9fgnl2FKzxjc/TnSQw6IHx3 -2C523ZJss3enl1990vk3Qjv4kNb8oU4LdQLdTfnN26peu7502JeNGdVryhi8JMyEBfd+IEkuVBxj -O1r6YvM6nVc1uwbXtbGHFXrt/Hr0+Skm7J8ekW7/pzvjqJRpkVZE/XaK7CACw7kl+LV7BIzhmcO7 -/i2ZvEewetc6Lg6seyzbpJQD2hP3GvU/SUJTZsTuh8se86zXkXfdpV5cxTuQf3nvv4lAHXdMPPwb -X/ZNzRXpdSIDQ4aKPO9hYizmDvrvh1L79nG3rmNluzapr4vV5btmOs+GN/+LIqixuH8NPqT5tZhA -lAPCcMUjbXmZ09rzaUx9QBkUEN7td3JivRA1OZbf9fTyOj7WI1SYsIp+TibCg4rGolyBiHmqQ/Dg -ZIiFkztcr37OqPm5KOT0gXPBtkz4P2ONvGDeErND+ObxC9cFLO9abea7VYtjgv4RY6wKJWXzkd5r -FVdiBMl+cZnX1t44NCc5XWHplTaP96MWl71oCNccb+b3bWm7mzgnOh1TPFpWH7xdr/jjaBOnYaz2 -y/y6L9Q1zFBG9ex8YLLXNedGMeH5DnlbUfvIKw8CYfwaxEwd4kF2mXLEh0/p2X1zclJI3jaISEYM -Cm9g37WECQ4bvmz6Som6L6Oa/DIVZzey8YzjE64Hw3Pyf4Yt4eRb1SfiXh24+PZj6qKs8jVG12MS -mAgAbYMKhty0ZXaLHh5/GPf6uHellyw6ySbFZOXRfYLwIAUqH314nbp2asNdmbMrl6zAevdJJQjC -xK6Awd/B+PAnSA1X+Pe7NbWbpRVOLvBKzcI8dfeJhaXobmKHxfB9VsPbaZEixsFZqe68KyU4RWDK -06IhxoeX6J5xouh88v61djK32dUDvY/9JBS9XH7vb5bqRITWc5f2qjws4LQt51q7aUvSgEkeSrsU -xrkApVUBZ493p38hd4Z1sFvM9do9lpf1Wu+JtnRBCbGLKjiYIRMkANu77ntzSqYHHBC98uSqL+uY -4zu5LJFyGB48cQEcJ9EHTiC5/cQWvpigpjcCjWo27vecWxXse9uYkGDxyKV5i+0Ohlk0Ue8Vemic -kX9QLTHryB4nDNIFD9wUuHCIfpo6dGoC44w2WgQKRTgIw51eE52in31epmTdDpA5IuIi6gcvRZ7S -ouUaKARaripgfMM1eZSfz/ujEZwJaUvszkVUTsyn4Iokg8lxMoqEcaQvIW9Rk6Zac8ZekQ6ySQpW -Mh6Oin4ZOq8M8FBKjAPo6CtHHQlO00cU0BsUmXYkPtTRoIttOJWb+eqztG66+oEOkUYV6nLNEff/ -bxcDL/A+PbGPRUTOI3nr0+zVwxZywopZHv/5AngCUIaKp2UweSzfXrOkpkff+XW3rbRHOPdJjo7c -f1YGl9xM3ThkPKvkvmo8rlobyzfaeqKVImGOEcD/X9WnvwHi+S7DKEjs2eEy58uXjYbYWF+9eaL9 -X9RpqYYpi//4IWvvPXVK8dD5vMLOmIjI22qjTf9ZFsozjH/jvVA6/LD+1bXw2qf2UUmD99//J8Hp -fmbZlvFADLn1aZ9rW9zu9J4Ayxtbev6L5NRDr/iil5/OXtghjdU2bUGOSmNalpL+iyB4LBRtnUXZ -QyeP1uOLtQ97TDYGBvpdX/dlIv6/KEIJcFBQ9Uli0+6CYZtfItSX3Ka1b22Cb9z4N0H6Lnv4101s -rPkhM7xuTKmsbEGfxKnHWUecBP6zLDT2TmlzK2iLyPd8ZCKwIi9GgzyxoOQ/CdJeN60CwDlzRg6M -vcTo/FmnnXnmvErlV1h1Yh9cjf4/6EMxVebEO66ujuSjn0rqG4mfV5zeU9n5XySnKrXTzKiVpSxU -83ITq8IKFQEJw69ti/+L4HRzclv/egXnXa8KvltbairPZy57vYDr4n9RnGpOj0hsR7ou3Io36z9l -H6dnPLrymWTYfIKM1Vv0fxKpjqDfAdWiLulcPYZN2h8b/cQRsznV1X317/751GbgtyVkM8O+Jur1 -EVHv8s9h41/uXF03Hw59YHPa7c3YtXW/OFXyWBvlJf61LvnEZe+Clswt3vOqQevIaAuFoXDuF3fi -5ujWnyycOtETPPJrTG6GPp5fA48CDyNk3BOoE5SnKxl3sGh9fhs1/YukkJPs5Ldb8+mAk4fQd+4Z -X4ZnDHym2peLFMsXV6XVza2/yrVPvSkUUvs99vs/q5KoeFr8QdsrqKvcV/PKOGhy524v//ViF6SS -0u78V2lQr5ajf0TEb1+w/ejTJiMt1QPJW+NY/lc92urPGUZrYARBGmPR04y263xXzn7qRUfcEfv/ -Kjr78S3O3/q12D2t+L3MludRMgOCB77ZztvPmCiDcuLBcje5bcTTZETfnguJ5GoQNVJ1/l/laCv4 -GY++GJ2nnXGh30zxcmfrXsPMAn6LZzH/SXH2c2v/cnARz28//NBpuXWBSvcnI3sB2/8iC2o9DDWQ -cqfaP1+H9Fi3cu2k2eCSkt75tOhHd/oEXsMd85EOPn5Q6aRmbaG49XnT9fOhs1ZGQA/j7e7VuGpx -rduBMHU3QrRr4gafyNlDB9oecHAqiUomQQuIPlUfkOpFs/P9DhQWHh00WXlGfGnRLAQPfXQShQa/ -IgrYU/LMucCPr0wErTJS8aXPvz7/bNEceOcRu99f8FTfgERmtBFcr5abV2AQQvar1pVlZQXrP6LS -0uamoUGOrWL7ayH+e3w4x8gl4peWVmTELmNGzThWfuUvYzPtyw53Oqntaycz3D888Une/ic29ZVK -khN0wKYnNCDs3NZb9P0rFe3/dv2bH+lqah2ve2XmJaGFn2kPmzfKFgxzWNxPcAlhQb14n+TTPDcJ -VLAjErhrkN67bs9Lwx0j412D8q8j3vF/+v2dw/JP2mXW953Mkk8U7hzU/6zS1WSc4/L2aTYH+7c/ -CdrLY7wG8tRp3YzkPs0LRBpEC4U+qxz5Lb1vlWpJj/u2Ck9ReCWwdO4I6sOhIMfCkofrzaKvt5+0 -Jfeqwpe2BO4Vg0JPXR5KBbBvMzRJunlskdIDq9HSHP4frre75qSh1RDt4V+za8XWvYyO1Va8uawm -RIFX60+IlhihtwUQWoAfNlWOPeVZELqpxqd7j9YZjiGPP6GpioHOnoFusOFMxc/kUy87VcZyNxs8 -sgqzOHHL9k8MsCYErOfsB3sSvXfFnXG2/QnaOeRd/LZFYt/yVzHhwK9dQqldPHTEE0gPvQ9Q7L/Z -+NDuU6DVq3Jv0gbhRl7mNJS+Ncl7oYVIIn1NiprIOMcTLqPMt4IJgSfP/qxHQW/C+y6nH46TbzW9 -eLVi1E67Yj4wQckkTwQanO4ioZ2p9GUf8XdGNQlpCjJZW3pGlv+o57IMb37LHAcJufe+kR+2I1Ka -K4rdMtRTxgxrvvD8SYCzDLO6Bwga5HB2PDgy/pyY9FNTotR66fJ2PywMCGVlZiRlpHIrlM4aU7zu -P2vaYWb+IZXQKOQOg9FjRi9XNB5Mi5F86LG3MAti+JIz5tkW7lXrBUR6NCRd87iY4rS6nd4lcFio -2eG+S41i+wGU39UytpsjrqEv/4Ch+H4j9xnD5fGbcshfVURq3VYKJYTNHjTTjgqlLW+DqqJL+TtX -ml7p06+XDAbGxX0KeVkoMACaHj/Q56Zo1YhZKEqVeLAjFPvUU9477vyqrnXad2BYPPA7eEQ145zh -bla3RtKp8JdyR5ou5E5MttvbFZJhME/cVJSBAd761PZqobstlT/HfnWs0DZpfO2yZ+2CwUuL/8Cn -zjUETD79xOdVsaM1fGn8/oGWDeqLd1VXOAqvY59NQd/KpWDJM2zh69qD69xGDYa42RZ95PPL3LRP -69nsBTdkJLSTeip7S98fuW1EZLxn86pAvquWqLg1SnVNX07NXu1GJWLR3tNhycvyR4iDjTGfmt9E -J/fvoJ7I0rGeFeaBh2TSpwPhz27cw3Zx0+WTKcsLP/DohFrkhO+8xz9rQREa7wnuNIcO6aad4Qa1 -loqP2FPRtXcqhbjDzw9ri3Ssl3hfMwsjkaCg/s8d7ge1H57l4UBplzaGb9b89vV8wQOFhj84ArTm -jYgkoemHAk0t6hOuiR0XCI189GvvdraBd8bW1/dxFsyCyVgMMIJHYomuSEc0BXMYPWN0Ivg8rfae -bI4zRwn33YjtfHfWtN8QmwcGV74DPR+DpG100UZ96n620LWGRdk1fXV8i8/RVwWlcAq0D/VgnKE9 -d1Tw4HBwWRyZ/hXIOMqj/a5Xf7ztbnntPrhPpc887lY7nIonAeM045NpRAIWS2XUYsn9X6hA6/by -guZiTeWaDSE9EjrlMBqMk1EYlmCj3FJE9TpnruMOEd8lN1e7VnK788BgTgQUNMGHdpo15w5+nxSq -h+ZtRe5HCcsVdu11qw9yNqhofffOY26Z6bewyqY0cJIb05Bbj5fPdWb1qMbr98OxVHDCHFyhQF9P -CMGqRdtiBES0L1LYijoG3OW7Nm8wwcDAjKdnPPZLFSM/JcFLZidZy3NxdZEjyYPkxzDY9FlFU2TJ -skpOign6zP5OLuN7bBlSiKtb98GQWIIXmoSCNlmCTd6ZQJp9gtbYghi/UHdhvM+l1LKEmCwr71hX -DhgZcH8TOH9CWxhJRVGojJSj9lU8S1TWZykW609iSt93HAqobifDC1ABk4lCEqEW54L2JgJvAWp1 -er6eCRMPKysPnONe0uJzSdvlhg4FVgHcbovCQHEL0O3omX2Ex2SCT2x1cCC38Uqx5aEXOrdrasHQ -QFsBJz7Ac3hIQH06T39I+qz+Clx7ZaWBAGLhshXHLF8b9JXMy884T+y2/yRr3dfuiptOrSYnxhSW -lV8aWM6cn3EmJJ5AYZwImcSeXpT2rvrJjh3fCnQvnN342XvH/+PsuuOpfN+/rOhTyahUZlbIJlJ2 -VkYDUUrWwcl2HDsltJCZjEJGGcmWmchMCiGlyCpkZUf4eZ7nnOM4Q31//3w+r1ev+/32nHtc97Xu -6+r8Jw6wkh6kaNBrBZRR+J684cDU4hlhdkRappJ+P3EOSLc1sQHmEo5OJds+TJp9t6bYlCJjMRr5 -6SsZxQF5TeIUOBKo0Ow41eCVsHMG4ZOtux8iy28Jk9FvBraHbmrvMK9Iz9sjz2eGa78qiLd9kyJj -ZScOW5MyNqjyeFgHV3wXt1F8X2l+y+PFxKBwZ9dZzfpeAhyo44qeP/DhDQD/GLX951hFUQDFcwfb -j5l11Ara5knE4eZA2RukDXTqVcn3SEupst1+T3tGMTdN4p4Ky60N5czBFkGAaQnWkQOkFLoqECC1 -wPojWEGThle1/7keH6r/4eDTVyv0R8Cd/bosHhswHmivAcwH0EEIs5EfTOUYJozJcJ7j4lJptDLR -ulRyLQ4XDYxTSX5Ro3InR4cR/paVdOrXtVvp/uobxwGu5rWDCrxuQrW0BOwgMIakCI/8NitlmcxR -Y9Tw8TXZM9XOVXwscLFD/YPMMZoVZM8IsHLe8vN9NbHwXl6R62F977GWVOJwUNRhCMDCRlB1lwmZ -zznZnR5qgxKhnAvb/mhOWF8jzgJqGUCzQ5gb9Fax7nhmzfmSKwXBclMrGmenBR2pZDZBQ9lZ9nZw -VJmpG7p/THWfNtm+vyy3YvG4zO+Dx43jf4GDHz0l9LrcoCpHMWvgRA+iamphQveME3EcYLzamrht -nD2l35PvyjT6eZOtvTn0/6gdj9+jSkGcAq28Yau2+8v9ep/VcQytegtc2UI11Meg0uFBnAEz8xjD -i/aq1Czys/Xe9ktLlbZOUw+DdFvi/44H+muubXyYhQX65bqsopfmIe1Efc6kW4kdjxUophnlaP+B -B4CepMoUr0I0se9fvMoaaCbsPZ5jPEscumEO0UoieAkCPVrB4Or7BnulJAG6qYNL9HnRnXbR//ks -/3/4IGcxwMguFJ+T67HtqmJcqDWLzMyN0+cY0v5HRjA0zyGhoz7hTks/bP8nuN+Do79FN/MfaQB4 -7EO+5vY2Mh2SQdGSJ7ZDq9na1GybwMH7DFQRQLSVPGczj6nJEYPibkOux3Q6/UfnFzdB25sDz6EA -gwpV937lTVla9/TQrYBDT8RLPJKe7XFJ3kscj64kAdwKLmtbxRyo6gP9C6a92kXhAmUxepme4pP/ -sXbe3GnS+F5IZxNGpC2mc2NALo8S2fHk2WcXUsd1NGxdkRY294kj7VEFUaPkTBSKv2iy7xS738g+ -c9fw8Kv7lsRRgFGAauuxOqSrTnvk4hTrro+KQtKVk3Mt6WeIA51gtvYuMAGgROiG5atl912mqiIr -5y14E3koczLxZKCfz19ZNjAMDzw9aWgmq/3pfXGh5heRpReHn7AQZ0DgChy8M3vPYjg6RTOjdWJy -//APjUxOlgPpZJvwramrcHR7vPV9NX0qI00lsKriicrrkQp62N5A87Hfm5AgTcEqJwDyyYTu4KLz -luv1lVG3HfN3xX5N8/m4CXK9BEBU26npRb6lHu+B6UzRhZM/pBpTNfGBzmu7BcqIouO03v3c/6Ey -o+Jha7L/7HTTWIRk8cZjbjjAngLcN0gnaNt8qZh5N6jbg7wfXSOoUlCMeBg7FY6HRoA3I/RACCOe -gac7C90sgoqPm8nF212mDq4eVVfPIcWfYwQqSRlzNLZPX0ljqrGUKBH+7H7jD91re1fxcgKotd+3 -tsIb9ghF/g9DJ8YlsheUVYqwvTvlpi7uvEEAiX5+om0Qu3WqY/tpnxeR+QWaXvJjD+zxtzYC596A -iq1i30J7IhuZQg4X0zwrdIreskcipvHAK3cCNPbo6jpwZ0Bhgq5f3oDdD7rsvl154Eqy7UWNngOZ -Vwy+YEFgTnH7SPezhOEY3biGuHZ+Lu6+6UvqcgSGA3X/4GbADIH/sGGOJPL7lbhSC2QYB1Vqb28v -iiDPTrlJgALfgwF5CAAKSsPyuxp9z9LjuFwrpJ5/1l9yYbPCpwD30IZatJkDs8zRQ6mewrfPOk/s -z5z0Tpb5goeDdi46cR1lKK6ZVjDoSQ3GP0V7ytvfVGlhRnHhCkURsmlIuJfqKDEyYPoEnF1RDmUx -g5LinUi4mIH6p/8G7tyZ8r+m4EYECcYunkX1PRw8QfmDlzJdqy9Oi6E0eeOmwkwQlNoP+Yq43nZM -/ElPPZPNzib5gJnbMUjg66YgsLbD8/ttZ5Vd6zNHkWN+2qnbY+4XU2yI+1uYIJyBfuKoQDdWm43y -mS3TwhNMuosRPxsfkncwvv9kObMJEiXbjSXfxt66Md/HyxKU/XtektNTy69lExTUg9XW3gzSWy/d -27fEGlZ9gKZG09XMqeJbdqXug7+i0QG05KBn96iGEawVqu5Mw7A9d4qLPMn/Bgb9ipeMfBvqKD3v -U2m39efFtI3TdedvhkP/vfwiN5tvPhPbLkd++1EOsye3exd4axOcLdxuPSlZ+I5TvWVgLfVvDpmv -1fbSLvJ+FEWbYe2hdnIXpqQPHC3u2vbqWcWFS2Z8z6zu12RvAnMwcXIGrhio1DW6bbz0uT/z+z1P -tC8aD/+Q6Ljw5QDT3OnNSGBO8DXtxQwzX/OkMewSpL5sPj/bpqYvXZ7pLpLbtgneCWbvAL3F/0j5 -VLKqqTmZw64t+Nzj8h/W7pVJmwKdoaqTYj4NL5+R2FSfs93xbkKzSrX4BE3eJjj0+miPTNsPpPMm -WnCIJ+8cYircP1NqvgkMnCQwHnHweeb5tPe0RfJnx2ueX+DZorq4ISneAgZ0IrdFNZLK13e+zKQZ -MvCITDcvu8v3cKV24Be80eDVVdrlKDzGwXnBQfmeuz/XPlOKC8kbEtGBkv1ge7s1qQTGjwB6p3Ba -uYOPE3LDI7ZRTWrnWj4mS1zEA2Fa+wL7ZG1jQ6UyTdMmDicmnGeeTr23EqCVRGH/4wYdHhTaGusl -CfSPt1F3yTZ2ip+geClrs/DY5Inq5KYgUMq8OUtv9N7ml7xpM6M4xWP1vYoHrtJvigILPEWMxDY2 -7OradVy0iIIqZNtLzoW9+L8NGwVGVK2lTBcdtbxCDs5JSNUlUwZdZSsW2hQFluFvqi8Q/NkWJGVI -OaRef0IynaGDlQIXhXpHZYJ0tofysoBVO7Bv2Gqeoe5yznbOn/IzvoEHCiaOEAFikrns9KYnbff9 -2HPxOd0udqc2m6TxuZ1EMOh2husroJKpk0jCmORlLFnbY6igGvYllyl1I9gO02gYcBOubRQndwGE -FRLT26XvdufK26ffq2RLGkYp9Vhn7M6Gv9vI4AZDJW6Dgd/YM9IlfqE+TVSBRXsnsjimqKc3+Dct -nGAwtH7zU0k46OX5t1ZG6cnCr0x/OuuPVmxoFWmBEFhv0TnwLiSzMi3wo9m2ye/njGsvPGjQHMMd -7AAYBdCaYQRM0fO4g2lsSUoLSwE2DRldsVvn865tgkOf92l+ZX8JZZNFd32WoQ7vdyO9cLty4jBw -U7yVLxD6aXs7/N1t5iPvu4aHkj9m4iIgb+Z6hTu0Lyn24DfFmkMj1tYPuWKfx44+oI529sfBrqe0 -alzvbQ1rGLENeUzrhggrtE764HeG4GAwWABuXvSvOqeeQAFPXJywV9Hz71x5I0tZzfYVB2pmtXbu -12wTBCiQdH6FHxhonFjKkYPrDcyevf182r2SEAA0GQ3Ye1TsH1F4DlvPC5zVG5vQjjTAGwsUDLOD -WULdI1Et66gFVG+07D5lZsGLHOcQCbY9EDj5nSBwYzBz+9O7qXZpPmm7dZHnJNLL335XFKDHha0n -WoKbiJY/HBHnpjnqxFtfShKhajSzQDlNCAKM/bxjx3K9aOd8/NmPvu6jLZ772a6x4Y7F7oagXpbR -SYXIbzpQJYaMnhc1JvW4W4833sEdJZghtXHtOgTrBKLcffMsdw+2LHfd2McsHl1bqcPwju+ILREK -0JGvMOGS3Xjt2/2x1WTRjArxwrz2PbjDHVBKPfTfNSTYXHZNewbjR2D9ghwPmtsc3SrOahqyx8Z9 -j3E29pETYwH+OhgYwHTBAUw/4PEBSJVCeTLGMRE+XKcqMqvuy5zt1fGpiBiVOQzjUoVajEENSdfs -YBvAQAR7pwOc28Pyfpq61Og4UvfDxyTZk2JSZzn+hRP7u7y/BARalNZWu8158VZvM6dc+VijSZxj -7R9QYAEHe7gdVPQY4YROAAMIPwcZw80qdB6Gt1jc+sGF7NzBeAz3CK4Twp1QGRwoHwvYCQsQgQBT -yNOWh0KVauK6v8KfhkR45Eg/PHxjMyaw6rYNdJvs+fTOfjvHVNIZt5J3SIcPgqLGfcvEsAT+dG2P -ctc1kb3Wi61qL4o+XC5CMs80EYODuxYoqA6HJiDiyz65i2djlr5LTnLqvWAseuN0L+NvWMx3L66G -fk8sDQz7/E6Ma0SnARZpmoQnhTaAkU7QXtBkebzcbh10jVUZrlX7iMF8lfVCzibA9T7xFvY25iib -P+fnaArDgJR/iFAs66uCvvu/hozwjrXDJsel1Ec5W6LIJ7XrIbuzodOfEwqHezyJ4eHmULsNG3D7 -gD14AAq2l+2/uf1dduXY5HxK1m08Mu5aSkaUAv2iC1DGnIACOiAF3csr9pmtfmrzku/JWgvt627D -rO/9jQKdXwU+DANIvPza567T87doczSegNdLj3K35C0RI0GlXwDLgUBNJwIkeVhFa1j5x/tzjBFz -5Bu+il2XpDPliZKg3IwI7BMPshg/oEwVtvfisdt5f2cIf+A+Gr+B55uwrD8/BMDLBuM+7ffSE78X -Fz+mILVi3rLgG04MDLSkga5E1Dc4OyEhFubTlFxXPOgcprubSLyc5H++/a15lxgLphAPkNa3dgXY -OoC1tMyhxsrofb461Rv9p/mo+PKWbWIKffQc+wzPvP8fGEGOe3qTXk9ItVeKfr26heTTelpTP0NU -/CHAJAtASICuhP9VeiKs4Q7Y3QDA1CPoCMDMQTZVtzIOkVCD9vgz8j6e1NNv2w+LjBNlAx/AgTDt -snNv5SxOPRYk14zYkVGGaOunVSQKQ5qu3y32FmBTJpDEyi/3axM86mrA2GOB1V8Ugr5ZS21ESVDi -G5TlG2Q4JL2La5x+f2xJHf9vhZ7bvktlKrcy7W9UwL5ZX9mb/kkdtF+mrkuW7WGLNLg6AvvKUPE3 -hvXvwAiChe80vYv8ghSXymFSr79uva0T3/iTGA3o1sOYZNDmiJ4rWKH+tKfvUeZpg9LZPHOeLG9W -fDwmjxDrJgDhL3y8lq8jupU9BO1nlj9pwtQNRD9uAt8givUEH/7HIxSjVLCT5US2Y0DvqtZ7Alc9 -BostxkC8INvOc1nfyie7RJDlj/UdHvLvMZbZBI/zwwvMpAd/zFBP5zGdvWkX+EHw69WcuU3QaOEF -ii0c4cHedCCtVf+JO83nIzmXt3z2XtY9/XQTKrQQXT8nIEvi+0zlswO8Za23M++Kvbzh1eP3jYAS -BWliDg6QkMC7Wkh/nLDRFxx+xdurkMQyo/PA8FhDKDES7PtpfUX/y/0u6BLwctKZxovTzfMOdS99 -500iDKAqt37UUPczFhe5VLCIRZFn1w0B40K91B2qUrcHCUhVQlzoytuYicZipZW/88DdeaFvuf72 -DsfzXHcmGr4HbMaKpXig2Ne5InsXj2nztWSZSt5Qsc49p9wuW8L7L1zg/8HO9aA24tF26caz+Ko5 -bSphqw/NPDmM/MabsaBe9q5/hk+CTRXn8153JmuD0e9mg4ZT/U9GNiVACQTAXQwKBcAUBD5rXUlZ -NKp92lXPnhQenJs3J/KSGqmKILadNlBipBTW570PpjCsUuTzu1L7kzHsUWO0V7xlyT9wgZIK0/US -/Y8gY6rWKzfEy3HrsIiEl8jM440ZBtZ8mzFChSMJrSCZpu7EKFf6Z8R15bJfFD0VR4qSCchRPN1+ -vQcnQELTdQOxpaVCx+32gXI+9TkPuXaqgX8gwQjzI7u/Dqdnls7qtqmI1QnvflH5Z4DxH/Drl2zY -AViIEJPv8yOfAk+kvvX4fTiucfXvBIAF17NkuJdJi3m3BYKlZKn/mMpMRN0XokgEFNgDc3Pgbmsm -OtoXqHOQMVi8a9ecgLU4yS8SHW6azL0EFPl1FiCf0o4YmQa9WdR33YZcdv5to3LWW3l3/OQjINjR -9ghqRYGtDO4VrLUVTMxOn5OOMjHcecDh5xtKVZvRXmKzQsA4cdh5tj+v3u5VrPQ+2C3VAQrlwD2/ -iaA33EtBT0MLXrvUZcToOB/6kZsIS1r9gGeFY+HAOQBqgdrYY/wx4J6Q9suzmI8y7B+yke4renO1 -RLYhlQgN3A5omrp2FQCZv+jrYZ3J9FHKp56OirCP5DR/0rSkNHwlfZiIMOFccrqOT0j82XK0tSfd -+n54a98JKDPcshkSdcdCk1/aqkQn9ceQnNvrpderOo3VykpDIliimr1kQIGUuV5ECbVS9+uTUQ3b -fM1VBIhx2K8r1ni6PdxW7cNYTY3H3siTMarST2Wsd08TE7Do6UOrC6DDZ30uP3a+TApelS27Emmm -7x+U82glet6HGBPO52DU/Kb4u3n94/GZXyPabzHeZfmkaXJQkAgH6pwQ1yaxPu3sSpYP2x4j5PYd -CRWhJ3p5vHNftxKj3cR4gCYsuVvplDOVlcOnFZH2i3ad3FdSB/+dC6SQy7soaHY+f49heD+fiXx6 -H1Pf1AIRCvR7ESeYDeSVw1wAqBcPkK3ocnBM/nQuM+9Wk8sRhxJO2jjzElD9/0K4vieesbxibS6c -aLv5LbUmQ+WS/r3fNcR+Itp0xrKmse7ej71/CmVzO1ujzrEydOacL2WfvrQJD2pF1+wKkHGdR2+g -bouG84N6Vk8LHrXeInLxSg1igviftoPBTr7PO3muV3zN7jxSNFqkK2/91PcvfBvtAywuhr1Rv1qv -audJF3Kk7+x4mkz6X4Y6ES6kHRxMesRYGJRSxT7Xaz7TvdFZ/jxFYr54g1qfgLdjAxalJUM5JACH -Wfjz3EqD84YqPpGXFw7J1Am/CJ4hwoF+NLa+5NhCSSbHRe2a4yXOfNctaVRR6cUz/Nuz/pkIc4CH -mrds2bdY0389/lS5v3HLEvlDbzUcFqjqDnCmdDCREK+XWqcpLrS9bdhrwZq6ONgTWaCMq+dvKA0H -OmR5thUjoiZ/Xf/sWbFrKKT6rJSrBq7luv44y/+aHPdeZXVkZxrH5+cswqc7k2WMCA6Gbh/wLKzB -lIa4383C74kfkmM9adlxI9t2UdENB2aB8bEX32SUSzGN/rq4hdLj5e/vNWlU39LxBxNysg8FSHMe -WqbmQ2wP/jZSkvjrmKmVEkEkMHjX9zTXNzuu1ZCf9Dt4bWTvLZORE3dwB6+HnZAIGOpdCcZ5zshu -fUpB97tM1dd2gz7d3TpfLtzB1SIsbKHy6NW8wTt2HgrQa257J6AxnixA8SuWE3coOn5hYvUqyJAh -aFt5T8KXCZ9GKT3+Q7hTbGljb4rKwgB2y/yieYdAhvaP4/sTjJD0uTQ5zWYXCSDAsef+03YayBx9 -9LZk6ZDKluNPua5y4+q1YKk5II8bCuVg1zIPaH4SwJEq3xSnx7618uk2d8WFQiQO2gazjm1HHUlD -1U+Q+SSQCR5TiRD0G5Tywh9MaB07fKYHePNav+uWhiLk1CXijzgK48azbDDr2JrmeNM/nLGszmQ7 -TMZda6TeXcQddzDgJAdU0cvGttufkFrczO+66ca/bH5I/DId7lBARwLtprXxw2TjiYOyfMdzWrXm -9msX5T4Pf497DG2BHrjYD9E/ie/Ptg95O2r1OuAzA9vSA8a6QtzPATA6QK9nJSzcfblXsCE1nYwB -J2M6ytOHnK3tdWC4OGvA8QXqQejY1dvEwJTV/Kr5kmOUoiOD7+VEWW+bEkRh2anr8UZZUnlWEmHu -/lDq1Jma84FSM1yl/YTRtoBTfA1xLUlVjum679GH5/blnzw+891iz7V3hBBgwmd1PCxm/JT2h3Jy -BQ7nugIfymVcdWFtrPOaIENr6JiwV9bFwoyr2Vd3eMe26h70UfO7L0zzgDAUTKFpfH/9AtKrxqnT -JeNhibfj7o7npwiPPgHWtAbCxzqo07a7bVXh0mM4/VfHpu2dVom1uqX5z3CwQCzIDglUi1yvBbie -A9X1rta3KeFxmU/wynTRpXOspQokuIYJkBcMVVAGM1kEJPfZk9+vttZs9aqTEdxGJf0ZVy0A8j9Q -SjJwb6veUJ1TQ4hfNFX9Nvx1B/N+p10NhAAbNsbT+6GvnqeaPTJqDjnJY0lLM5FGhqsCgiCgTBFa -oCkUBBvNP/hIufuugvavfe7JDIYjFAQxa3PgBDdb/0JRyVwX7aPZDTPX+21TY7pDfhlLVBEAAkMF -wpTuG1kI0D0+5j4WlFT46KPtG1yvFjAUtYWMpMM+5wsJlVW/aiar+Z35caz+La6KsTYaevqAgNyH -COTaDWcJ5HY4mMChiGibBcdQFdXzXxF0CZbm/Xoci9RBqngsKKXc1haJ6dO0ujz65dZ7xvw8SqvC -0LHG93EhP3Ed9gTeLxeXjvd2P1j2dH1+aTz53dOBH/G0uPHXje5GdBbFxlB7SKndUa49M40ih8x1 -yWupTBsvKOC6DQjSrIeqnRnScnLEY780+e9mvno3JCyrC9fxSpAAXfd9jULeXHh8JpH8mohrjLOu -a9HHR2fu6/wLhQMqEV6uRqRknj5gkIQ10DgooElS8O0e3Gg5UTz6OmSr5n3Ahei4UVj80yZllytt -xYxbz79wgHlBUM0GgCbc4iFPvG+9Z1s1f/rivVk9bhHL4X+lAfCKcnvdKsyC96xyNx/bUdgfr91Z -/c94FdSSBnPbeEtcY3YQYBrjZldGUBYrvX3zrxyacDuUqlq+27VPbqutZ/jk/JUqklRDYa8gXFcQ -QRYgIRX4ioY71RQ1dSdjzqeM+78zzl/9eeLKP+3P9YQbx2m6wt8fA5cWko4qv9XXDzyumx7/Twyo -JX0mxDhcKhRn+q39JlXmVRrEkSMvcP2jBPFr6rEd8EgSvFyuBfJwMV86q3RdsP3Osy1f9Yz28v8L -ByZp7ZoMXZuPg6LqPNKlVSWW07no/FPcu504AXpFD++/PjAroP5H2Iu+bIxPS++K11D7P5OA+3I1 -xNGcZEJyqubgtYsjX3XrTuu8vkqMAe8SAzfVmRQat2jTMQO2J0bM7DNC24QscK06DAGwkSDPKWA8 -gNkYu/Qf7/kuFPnCN0PjVreK8WfqKlx1EB8NylmoeHZBS5WJFZ3dwVb9OesHpfJOC31+HX/Dgzlb -ErelP3BVDZfabv0uKi0qrWzTiWt0YHDAxrVArOfsobUz8zB/9lny6l12pmNJWj2nimOiI/OIcbgC -vj8BuKUd0F1hQ0AiMe/G6Zwl9oWdai1ftWxvv7uTx132TywYlXrhDJXrR00Gg8R+g8uXp6/+PH94 -CffaJMyAbTeevzb6upS8XLZNfYKMNzvvR5xxP8k/kdgCuWlQiHj7mHq511jo8GJfjydprVtkWDfP -P1FAT2dBjqsB80cEz2QpMPofL4+epi1VO1oy/xcOrEx6zRafjCwH809517uypPifHaT+hueY3IgG -QHDBDzJlLciBlV9+iVOqbk8G+uzFiYJAbxfmoel601BEFLLxsHpNAvMye99XQXLjC+2PcCP0G0mg -OIm7A8wcU8NV9NP7RQ47fWZKT/FSUprDdT5NSjF/58A6DF7F46NpaVMKT10R0/+N/4lMXArV/SsB -AOTqMcnN92PYPdTwOd5lKjUYobAYTAQIDN86SXtrKNZxKs3gVqQhXUZnVmieK8HhcAs4qlGMEo15 -qkvLrOIQ99cek0sHchn+4GpA4H2JWwU4Lun5LvufJfqtM7Z8p8ZaE/6MDb4lhANnAifzD8C7Nu2U -zuFMlKM98Y0q8ZuU2+uVW7g3xToedBkAZVkBtwyAPh+vVvj2z0ryNT0zk3sPe+5vp+C/tSkatNku -RrZUt17QjRTdvnqQTfp+0f553LQlEGRvYQE8UEK/2VMgX2GgFYm+uzf5LCzyyf7lS0NTNgRh+Htv -KP7m+OXjzEw974Yudr8ak/gVI4+bAgFC14Q2HEw6wImrnj5F+lpSs2NQ8sCPvfVHaLVbKnfiOgcg -/Mb47IZv+E3iAS9x5Fs6Z3v5riyj9lPxVne5TTmIfUxAldSHKfjM8W1bku2pucPM2QcjcJMpQCJU -DjiQ+quEqcAZdMpo/Ndqwg+3i7ecm+ut6oYEcGOV2Fgze7s1m9QJ6sqFKqlVYHnC76ZNHdceZW7F -wWLDbdVSJjs2oUDVIsFYMKK0HttYIkinb8O+Uqal1xeXvzqJa55iw7G3anfNda9qw5/nRFybK6t+ -Hy95mfkC1wO4AeoEHhC1jO8LPmH75ymate63aSyFeH2g/m8TlIU5+OQYQPo4Cky40MvfM4pvyzLi -l0DSrOZ/3hQJgGZ2SBRb0lE2UGmSfn/CFM6q77lLdDPQusoBrk989WyAg1NySZcEq9cHykucZ0s3 -Wx+4ndWamQfqjErKowLzTiN9o70yuVKPOOI4cvfpbYJ0AG8GtMm39OaUfpDm5M3U3cuD36mzLpwI -OIB7p2wA24M74a4B3QLLVGScbHjFsWST3zrbtzonbIICCo5AUuNIfyd105xksaszTH+mpX/aeLi2 -bhMgaMhjB2HWKDwLWx/YRsloe4hcUJ6+tyh+J9S7kDgFgAjSMGhzPdgYG0tTZhmyGDJAe2cPbrof -iEAXLPeTeMy9f95RlWbPt6QDF8NM2Xf/OkhoPE4XwgPPvFt3iTx0qPR1fD6vJpVplu1USwAGDG08 -MybmF7c97+Wknbrp2ZWYOwfkEwkM1VkPSW0QKNcqM5ZDU7z87vwevmRs9YZXznr5CTE4MVkibCTp -GhTz7FqR+A4BvtmTkqJn7uBaKgAH4GBav3J0X0gcz8nLNUnumHfWd+kuntonEkIE5ACHJvO8oIeM -Lkl8xcqstPmwgUuo4KNDuGnzaMiGmv5ef6jJFhPyy5Wnm5//XLQqukQWGUYEB1XmAQJuFjaQ32eS -f/tj6pdzrjDh315sdE+bdPR8cLUtNBjsPLGeXgD4t7q69hzRJKMiLxF9wXdvbtLoZhWuqrEBDDoW -3/rrH9rjc3ZvPTKsdnBOSnxM8ygRDNIMAb4y4VYzGL0y9Dlj4eYbGoWOL7nFI9dws8dREGD0lb4Q -5aaPSYFMUeTfDKckf95zbsTNzMY3IOaEJV1zw/3KubouBs1WBbYyOUSnEAVBHaVPs3VtiXiQMjc3 -Vrr0W8lQNtjTez9RCPpIXqA03BPQf/hd9I1XJDWxgm98Yx+bEQNBsrLOwvE+i2y08R9WvT9XTEmj -75nGE7pWUS8pUJ4sp+Jdz3+qdWynvS6d5ZZLOz2K7MRNW8WAgO0nYAO8UQSQ2mR6p2ek3g42jVxW -elqpODmeokb0A9Eb1+0gbOidaoGkUv6vll7j3ZdIrJ9QE8Mg7dBe7D23z13r8HjLzOB45fLucNXF -S45lJ4minC2kwHdbGKuJsbnTrydZ7ywXH/X7tqIDpEuPinFTFjBoUPoAjksBG7gJuAxJJUf9Mz6d -t5BOkCiXoVM833V/G7H5Af13U9dNO0IsqORMHc9J7NNc1N4/QEVkOJQkgem4WbJw7XdIGSKSiWSB -3FT+c8kLslxcX8kG5MbFMK770rT/zZRWJ/fyVqOFFPZQnpopAmgwJrnxwYVBm4hwoEvOhxMnYGoy -8q5OGkol1gSQLhsU8qY/MsfYfzPejDoqtCyb7aHb2z6Im5KGDUK1BuWbYSyrauEndVv6EPDeJPd6 -M+d/5wmi0KqtbrBuY3F/rle7evEyNfcVp8Mna0sJAcBXIHv3PZ0opTmpxRMaxFnN02VQzIzr2gfG -uqPeqq/fZBVMCe4XzDQl55lTpMTdHC6PVUUREE02wHbCdGzBUqO6psoT665yBPc+WWrtoi2RuEUb -hZt3ioHbmaArRv135vvbO4u+jYhesb4LkvEMWbzyuN4cDAp4BY00BfM5zJ1Q+OcpcuZCshOn8pC5 -7/enu8qfSn8qRAyPPnxzkuaHE5ktI1ObKV9+kvXL5tbiIXBr2KDPzZVm56PeeeaGDX5TGQ8qmqr2 -/qw+jjccSrXZsKGoSbQaTY/ZXMlemddIztxOt0LqihsFcQInno8zregSZ5AIh2I3B8lv7znp3QyA -MJCUkMAaCN636EIIQM0qAEnykVIgYJcre27mSIXtk1m3/uodcLw/Ad4lgK4DveG2sEdC7489A0pz -dNK3RFvJpI/5XcwSzd/PgTcN2GCwyhF0uj9dM5UeZAzpTv+pVRJ5Wa1O4+M9PDXJFn2Hrc+IA8M7 -noV+5exxs5zXvwU7FZ0d9+Om5CPWQKgMdhMbqKLXVXYZG/v62F0B3sundknyxzNf5cW9/gBHEaoE -AvBP4KTySyyQ7bjWE1KeSJeg/17OgqcB160CokzhlnBI8DwPktLvrn/W7PPoXdZwC0enl2ZKMiEE -4IoCtRy1h21/2JYfGpHfJpe/US8aqiKFJCUEAFx39k4mUAqX5Qm51zYRI6bnGBy+ckjbPySZCMPN -vUL7a1loB2D5awLwbcTTxj0z8o+6vlpZEBhqAUqiyx9OsRu+PvlIrERMW0adjFVQsh33kd269QVV -XROAUrswrVch9fE/pwcp8Qc++u/WPORAA6Ozjblciutc25wI42jNdxGtajAS0mPTyWao6Di5W1zD -IvcfmSyBSogWSBsB6MeNs5CMWRorNtmc9Dp+od6WwSG7G9cfQIzJ3gZ4JAy9CS+/MGoVP/3CYOme -weGYpkdvjb6/xw2wb3zcD9V7wqgi4tcqPl1LqP441i16iJ715I+VVnZce4aIeRpIIpmrRLd61yVp -oVosfDWs0fs2kb+8HpICcP7TJ9/6OGf3u8GHg17LF1plMnHh6hYoHBYo3eX9mcxk4YVvBt5bHCh1 -FSJ8+HA1M/RDbridOXC01y1F3hiT26Tvc46fClavsXuScrvGfh733kan9KDuALSYHM0kYTb6dfbA -HqaeQScP/kMDkWO44VBMctHaIb+CcsViEqkAji0TgQFfmObornclGlTanWQ1lh3HFbWEOACo1qW8 -/BM/z19o/GxQ6xTFk6n9/g1u4BgLCrofd4qRjkW/ZeeKiAubnzyUnou0wM2uQiOA3AD075w2MNtb -5d1tE7Yyr48I3Hlw3lMJ71SiXucBzgU6NrbJz/YMu2admQZ9TpLYMSq+whttZwaJPMxV7B6rgRjf -+84t46pjSlduY3YdzAxXeGFS4gDTDbHhvW3esixHz1sJ6ulICa3ys2IzklSDuJFtdEBlbYfCTFBJ -1YDOB8A5tGGD1yXDkzoyhI82GB02LUrajhs+xMAhhds8y3LX8Pj95i/fEs0be3ZEUy6qDxFDoFWa -Gt5F+6Pqf/JphqVUbg778j9Vn9xNBAPav0snFD5VSJKl7aM/7Cagta0QYXoaZzikJ+NcOSR2MR/F -/ZW8y1zzwoMfJL8+JzOIuyvBMoDoGAPkHFy3u8sTaW5aSXKU3BLMeUHhdfF1nkrMJwJ4qEI4kDKM -ei+rRyX4PWqa+aLLG/83cyv+omqiWyTxcWtLKOAuqiEGFpuIUxym+cnaEf2MZ17S0dGNKnohVpkg -BBj8/TmyrV/6sqrc2aQ7KchHC+dpWi7gDIa89NCtuN7TWCzcVkCdNWDfcADTtz1/npjt/iGDG1WF -gNDrYvCZFEoaQh7lrBRhby2mlL5m29OiLKyF8MqoAxEECbCVQ2SgDfdLnqJ4pFaseP5Y3ffsDlHc -/Cw0CG0HTBy3ZiAJevjNYPvZs0ujRTzdoUdw/bIQBDIXQRwqUcscZgNDy4WBkt80LZ4RO5f3qH3t -JmO6w5jlg3tJEw4RAfpKY2D63LnXhdesghCIhmfdKjd7cdNC8QNDa7hM/9uZRc389aKLspedZK+l -CEQK4zrNCIaD1qCDbV0JfXJzHSLkXA+To8RWizxqcV/JEAgCAY5+5GE2S7tt25nIynxfRHfn779l -hvsQAif0g04LAnPKsJ4wwKEdpnTV8VvDxLvHPJpLuiZ6dosZhgm4uWWbEAIMkXQyruNMpp8UvboV -pwzNd81oc+GmZxJhwPwqltvN8kN6hp1diw7h1knHYwxFY3BfghKhQIW2AP19gPwFm+jPOOvrqpbf -FMsWRum0r2zOgUbe3XYl/MuzbZd1Wu8f1gp9dvlBTH0cQeT6nwVqcaFf4qy/L0Gaop6/AI7uSvF6 -vXPTmg8/GYkW+DIKWdlpe/8PpHYwV4F1sp7zpw4JMU+GMS125/4nelbW2jCL8CEhQAbGr4CXBWs8 -pSeY9h5jOF3ue/Fh145vxv6F2nw0/8gD2gODfsfCbbeuVA+9Tpzfz8xnKxFV/S9wzO/QPn2XwWs+ -1fRXKhvMrt38qntWDW4sG48ACjphCnnO3t8p9e7gFiZWiiMFvDae8cUU07gvunApQDkBtTnIpNni -EBK6EPv70pvrUW4WbzpFcW0hXPDaZYN0A/2mNjZg0w6gah7AxWAoxjClcZ5JwGKmf68RrbBLZBSu -lYPLhdWso5Ek6VKu816SqznG8h4mbIz+7W1Bf0FjqRs5WauF59tuqOh1UzyuN6vwi4p8I/FXNPD+ -Eq2zf/Uw752kdN76HwuPftaywleec8y4nlFcAqQDGJxH74U+D03JgbnXyQoPHujLuO748eXoBK7r -EZcBffmCVvPoWwHvi5pG24f4grp2cnyw/cTs8hf4+jUAENzuuvLuyaCmMlcUt6V6dKvXxIkjuGF9 -NIHFeo/GQZY3s7l/KqkSenLl9kxZkF3gNMS9ryEUwtke9WgVgB29/GUHY8giu3l16qP9ph+2ZXcH -ZxOHoVHXqG4M3FnIY/UtuSkeakb7vkqBClfDwgTJz0R8O/Vud0hYLNKK3JfVMrr725lmQmPBI71u -zNYWk7XZd4zF87a9uSKiKShX7SeNq6WuwzbMxMkqOEvaR9L9x7MPabJx9RSY77x7mBgSGN+7LKcp -LvbBsC1lK5LhpYv4SYUJXNvM1crE2dUSLWsEzpk30W25uDp5XifuyimeYN8hI1w7G4r2o/sTo317 -ci0+CzvMJGC11lzjtWQOgisTto6bAAFIlbF53ePbZRXJlDxk+0Zvi1WvzOKda+gdDXxDY0WOL2pU -+z0ns1UyeCukfgc6iikv4CZ9YeEw5Xh4G5kZ7vVN1UYM2tgFZnh3OFKMRBGHod8BoS2L9KcjTYP1 -6nDlC4KxFfAMVy3yN8LE0ejNNLjUL5hhy+BNWUaXc3vHAOeFSgtcex0LtZ74AArNBB1/8rttwb/t -d5f02nrcbCZDzOM6kNbBAIDuv7iGCRsmmaO1odRiVjYDH3z6cJOVIQA6sxtSqAFov+rpCzfD1clf -WIYOj/JGSfgvueHJeAhqj7Ir9M312WThd/bOGwyqwot+e3SZqBP+OgJhLNnPoQrjpJ8F+A4JmfGM -6IbX37En/KFgd/ENidz11KSDCmR/HMKzBhnERg5UW2UmzxKErmnVbhYIDwDDaS6SaCg1Z6SfnP9J -8w7sqBr3D7wbEKvQ1nrlLNS3AxwriOuh5TZW1fNfZedPpBy0MXwag5tAvoED6LhjCcNEWwv5Gts+ -znF/qReVPqHz42TSwg8x3LDHRjik4KOeM2NPgOfC8U5qayOnUd5Sl6O8dw6zbM/GdTdvYML1dojZ -jIyfPrHI/kTravZEQMGLb4kseFobNh5mYmkChyKH4RcvbPte7Sby4aKu6X7kzqWXC/a4Dwo3QrGM -jMWblc8DXBn/bN+i0YeQ8FTumdyBW9UKBwvusmvba/Xkty5fnX6+vL3WaSz0NMNPXJfHRhiUAKCk -VKq5pf28epiI+4vMMr2+XpuZE5vBsLMAwRjd8v49rqF2Z3dI0NPu23E4RTkggU/kHwkAeMwvm5bi -rTRMrxRZFP20PH7OX7TR2hSOFlKBB4zHWoIX7rwJ9NR3/3BO/KdQDmExivFIAai2NK2O75R0Gr3/ -lSP4uCNMLC98xk0r34DamAlwu7pL5dGlvq9hMZFbFhJcCvLZwvw2QxOKzfO/vJEqofd4dSfH66WY -xkIJnY9Mmx0x0Arnz2tZTJGWO114nvNU1I53u/9L6yMMIRIMN3m6/5VX57PGqz/LfMI0HFLswxJx -CxitEwAAhFTYa6NjzvZK+sYjx/y2BNc1XcR9loHRtTo94oJkpYdDJgqsC9+ENSb80bmG+x6AYLYZ -+U4xqwTRADPPZcoX6TyTl9pyVwleahjP4JoJj/mj80cejC1EOhTQKfkv6F5VJ6PK/KJNEAw+cHcy -gfbMJyXjzrDM02T/yReK2yNGUysnqLYSQm2Mjr2ULzrC9vzYBJlHq+SswqDwQmYAwZO1Huga2Bsp -6RF/oNtl7hK9AEkTe+9SMq4DEEIAg+W97gT1JTDPWB8RurnkcG78dLK0FPZgSzOwVxHMDfWqyXZN -RYfKZKr9t+tmwVGjapejj1kvM1DEupz12ZAVB1iwQJhlY2nkjHcnP5H6H7rglk6GnD9fJjBYe3yc -AAq7uRIAa4m9YHSK6xFVrvrk96GCVeYPxk/uEYCBkgzSPnZGlV23SSlTMmFJfljQHMsgcCbvHAGE -K8x0vUlVXE5gWksT77aFV7l2tfM0Qq4ubHKEMdC2ABcog63f5QVjhlgY4pdGxdyPObrI7xsSWDFJ -yyYOqOsCdCcB0GLWRx/UEb6pQ0+V2NUiK+tukvdvMGOtYCZgYRELAVMTBBxcXPHOrBg3eYQwte0x -VlXSx2ERK+wmhCFozQhddb1fx4Xs3tvw0ISfj/PfGllyHH9WuyFBAWyXLiIoLGANg61p5zYod7It -rYNESh2Py+Xf7ymvXNBxipL7HEsIBvpPYlsP9ZCk1SofPuPEadz0w/nrByu8sZAzzRRmAfgJUNeH -nuvUuTeCDVXcIT9vPctC7KZvvRhFBAg1XgY9CyoWPUyHXmdTPWotaxgNFeeP48D/MggEFp8E/9JI -qpmiiN6EusgZl7ZzvN2ySmRnpYiANt5w/i+PkIR9fepHzSkzdibJQP4M13IpYSD0h/oEvZLfitHU -V0ycL3e+1CJcVv/uD/54oOkb1KAetwmckVbC/vxEgQhlEQmaYbFft68yMNfg46E3lfZ2djAzcE5a -qevZfL8flR+0zqqIlChp4jUKZMVHWYJuPmg67e2cnextUEWf+RcfzlMJDLqyPeTpVz1vSsHz9Acl -EThGUfEbM9KvWbrZ4fjQ1oaF5jDJU7dLL4lgMD5QdO2nNbgqnWzHa/PcE44ZPm8PBzkpSzjnJROB -Y4pAwFHXt0amezxZOm22oNzRzN5M8fqQi2fTiWAxj2mFlCkmLCZkDW4xicVqMvZKsFK/ViOGcYLB -0MVc1kxrEwFLpIkTuLiHu5t9A3uT5Zg96+oKSexKsl498iJCYgnDZOQ66tyJqQkq1WkwqWJsCnpp -y8X5g4MIav0MovuCYhlWH0cv/S6yERGLd3yj9eizCkcPS9bbTXggGnOYDZSovTfh1XbqywfbSrrO -TY2TfJdzpLMi/RsavPQUVcR7DrQLybSGcY6q5ySpJ16PIYKzNXGDpg2BrmMJnYkzXd5C6hymp2mG -bt0So33PFKnyOO2vFGBgSlHoZEj+b2uB3YV9vClakaukv5qIA53tnddWex3906WQgXp2ycwj1PWM -re9RUrNceCQR9JrZBDZCMoM6h7SMTCmm7CL/k7p8q3vqevFK4/KRCGJIVCo0za3mKHqN02/bJwoy -ESfzZSit4ohN77q7K4jz6n4LkWDSrcGIFx5uY/vI94jfIQoCTC1zpzVlH3OOBMDCEID5cvXw0a5D -XXTXc3plhjrJ3dVffqMiwoMws4KZI21Qar/40y+ldF3PhlnSou/nC76YXyFdlSACRO/HdZtrOLjh -hO5Rszjz2w3MKmThlAenjfk3B4MCLjdjuNQbzs6nmJ36Xs7qi/PJNGKnAWkHt4MDpcXhHmu/GdTi -1nV418m9jgjNWwo7GwvH3z/4cOmcdtr8v/AA2K68e8doolSZojpY52+oyVPszNtDRPgAoyuknF4+ -l6oyEXo1JCyR12t57xXnGfzRqMZSds7AX4SCYAJiwmAt6VTaHN1xcnq7MqGb3KtzHeeV6St2EyFY -uxZQ0l1UWFwA1dLO7+stuH/f93vHV/VVLxrnOEqnatXj49esYluwe8KaLmCO6plgFP1r/OhX67oL -/Wf0an9ueSQq8gdOEImA2awdVwsTWzi0o96bHN5u5DgixD+/i8fCoXA0ISDCBA9oCrczX+9OcNpX -s6aRNOCZQ8nB3U9vUbmJWyyW4UNsTOysUV8IgODWe2aiDfUjTiwuCMnnP/PYeeTsRXwQ5MxCmKyt -Ivh1iRLT7tKnylodlN7UHt92Qqr012lGfBTwdhjQeJ0hO0pU/Rx91hP7repXRs83Fs6QlLxCHMQD -mYGmF7qHxAZdlN6isM8u6VrllUWKVI7SLknfoCdt+Hgr5NrvA9RmO7B4r4ANHNWJZ9/i1ybhyccM -TiLMvPVs0UENNtUCROBrosjUBgZaYdMRMnEqgd6PqmGqVzsCxxrKZn0QhFFrJwS13XwPmQvVSdYk -z77VCtaJf5OSTErlQxSDsEVaWqLFQVemcu9LkfgPRwwLnR1lEj6PTW4ZJIYEd0mStvRKlzN//f17 -qYUW4uMDHsgB/PGg5obSO7A6Pxx6qKNSSap5NtC9sYMNWRE+K5i8ujkYY02QhVFuiZS/OPqspO/C -6uM8PwXl5e7NoVgXKzo/BXW4SD0j8ji/c3dzCyZ9+zNZo2Sepkr2z1yQgingDFQnwag2DSantrzu -kvvcoih2Rkncz+aYGNn1/5VxTWS5YVGm0vc/f2NKM1iRe/b1aYfs4Noq9nObUwJ9ItECTCj+c2Rb -LOxxb3V8ZDAdPZOuw4D+5mjg+l7bvbD1Ka9PpdG/fepFuvnHZj+5ArlP+6nUcjbnwPkJpc/kqB63 -jJMdjzv86GvnK8kgcY6tmxKAyoclY1xae7jcLrMe6lCmnKhH92XINwWB3qEyjZ3yvgFHHneLV0Tn -+wcnvh4R3rYpCuwTcOpF83JJkPW5Lgu9P6Qkv+pmxb9vPktAz1L09OTI095yuNCoZxDw5s2tW/wn -2uaM7ImCsfVwqA45mgaeHJQo+hpeINTh/1TZ4d5dR88g5c1pgNfvOCTv2IS0hA4dP0jddufqKovu -gVxxteFNSUCf72t4hsQ9v9OXGVePzWQe1mFP2ZdKDAT1AwT/xdneGpKuE5zKoxaDbE6e7dse5F5M -+2TUPXWUKH7j9zo8SFT1jze6rt1/pRt2bvxQRndg2OZQUBVAt93G/ATN9JRPyJgC18GcVsFOhgL2 -3rHbt4jxoMGou1IA0wnj/ZTkNhHONy2ZtPJl2c434GYX5Pv/QgKF/BUeMS/brHbm7wi9G3L1t6pb -4EmiOxXb8ZrswNTVnJEj5nArqHBpm4fC8TiLSqI4KNnQxBVTFmP7vaXAB5YZmhKPWMtGRu7bT+7l -x7eFUWiLNSUIYQUJ7qTaG99aF7PdI8w7qDnOsD2yG7arIoYDsnNQ4adj1PudxpLDfxVeKFiqTmNK -PgBjw9e5UDD0zGJeis6mKf0najLFKRn0KVHddkkmLLPN7W9g4GHjOoNO7vkzCmKkl/I1VGeqWpoZ -ZS/9ZiLGABbfW5tjVNEm7Isn69jUsFSurJn2tSrZUtm0P+P6W74Qp3FY03mxE1ukhcLTdy4/D7fl -NL365U6c88SVMQ3iaAQQaYVB/wgkm2GKsgJuYd/OvZPv3Lfbe7Y5kP1ibsmOE9MjzrQx3lXfslIZ -HK1iHMp5Oq/E13T8TPzOd8SwWLeLFSrE+eV59/BqMtmzoCuqISGiJ3afirEjOgVYcKc1LRHoYIzy -4kA7CuD7/q2ksvSZ5AjzQIMat0j/9sWdB/EVahQfkHXgjjrCUPADfdsATCnwvFKRl2P1vpH1evs/ -RUeMTI11EGMCS8Ssd7/GSuM82Jv7ZZRG+nyQfKjuF1PGh2RpxobEWID3SU5Ajz2Umw8jT+Z6s688 -/Nwt3d7ZqCz1vE/2Ui490TkG13Z9aav2eKSXLSxzHm8Y8+f/sMiQ/iiY6F0C5tevmZ7O9kgwDoos -OSLDzfDuyY//7Pqkn0lTBM9fIQoF3m+gHFVXzWh/9zwp/uLNPF/o+kJLZbj2WzAxHJAhDAVS7h+4 -t8M5zKRX9dRL7cMJln6piFx8AwELBWCMC/MfSB72vBHl23rmaFhasnFmO76pi8YA7/GAfpTomTGS -GnjIat+9rBbTc5pKfIEygfsx0fVFd60BcK8v5J6fusw/a9LMSzLB2INwZjLgIo4DWuViVFxwq220 -zMA9QuUSCedcION6uZe2jIbsj5Bc9KG/MYItMm3AWL8kJTmPptwCSUbwrNVjQfjyt3102X+BI+1g -bpBXZH2T3as9bXW7lGK5KeptrGK6J33t5VZz4jSOqDvA3B64fqDTYwF3Amcox7SHrKNHre+H19OJ -82Qqxx7wtUxuwgR5HzFdJtEvbN3i5t54X6clqZIMnuHazc0dQerj+zcWrIP3ikzNjMb5+fTOhF7z -uw+3sj/SqmwhDkdsTI9kvJtts1tfZMGPR7dI+VeAX4qlNb4feR0Maajma1YvHJTMQrZBRVkBr/wW -Kq5zWCsGz8TUlwb9FY7lmfA+0SntS6vEVjarpVfH4ejQlO+L721C4YFX8GiPCGSvo47hHEmMjOOH -8EnqRNW9e0jjB1xhgy7/QAIGNd1+jd0OdeBRnFX/ddJn6w3msB0LRKEOSCe4PRKB7XrWNyOTeeG/ -erBg8twQ30qVAqxNcZwYHvPt6H1o8erVXPHeoaM6A0JBS18aTc68buH+GxjlgN7QU3KEOmuesV3f -aPhmoZjMfNt/8NpVfBcpDg9GE3zEv4c8dbbH3ZUlKdEuhfQcrY0Nvh8LB2xvh+0IVy1evP7fIE+j -+oW7R8OiBv+7q65IVLxs9GhtbNpKe3BkPk5lgewNH8L/iNrVCbaSwLx/5AHFDWZef43HiRgacRnN -0Lvc7I+WVd5TncPwb0QAOtYzJMpawXSu5tv5eO2Xgb803yk1/g0N3awmziYAQXpEbus300vvLS3a -/8t9QiG6I/Ch7F8IAFiBtmeXpo9QiVdN9INc6+hZinv2RI/SmlRDmJk4wNaVk/DcWflfWyt+fpm6 -r+C9O5z1TUfyNFG0g4392hVhigSFKhPS5PB1N+dGa6kx7nCDMwerG22JTjuEBB0e2yU/35u1vB7a -Fvqz/Vg5q+a9IHxHJAoFXQZrNwuQwA/tG9Rcc9FL6tXql0nr7pGdRZQJv+bilKrAZwFb1gPD9/D6 -2wxepU7NF9d8mzsweFRx5gmBK37tLwCyBjKB+xhLl98lzYc3bvdeETT7/lhMsR3fqYY+VICwR7ko -yP8YmK2GZDtyfda4uz/R90bIleByYjjQHUxxLK3tzC3T0tGa8enqc03h4akEbJiNrkpbOMIWnTeX -3RZFyhhXnXvw4m/DH3Dn6pHOkhN/wQOwHyLZQxNh6T7lt5y7zv3SD3MS+o+A2Q3BNEEUGD18YMT3 -8vb+mtRR5Tly5GnPnnaN3moCMCcgw3pDpZNaD1v1qR8Xv5DF7mM6ntQwa1d/+zE+EFxqpQ0rnd51 -2iO7Mfrre+7Oxre3+veL+1rswgOCiZnrjkqJ1Z8V0xGvRWt359XfzR/TSdlpiW97mMNMkaBVd3Sr -wkGyD9k7BjOFyhppD6sY9dHjX4PmMCBqbQ74X8H522pDYapTqOnhU6jcsY/WR5/iJx/+BkQbrtg2 -5PYd367fHapaSAg+thLL6FghOx2O71pEAx1QrhU2CjUk6cqpbsE4c2at8udjiu7G+PsXN3IHZRCA -mqPWasj3AvKu5KsyWdlf2T6/W/IyJIDHVDwH/mKvEOfSzPzE5buh0k4M59/8+aGAbzmBmg1wMeJa -6FCdQpgz1pqULD/Xc+w/LvJjvqeCklKE8o7HMr6j46+EavaQ5d+X3P+Qs0gyfbBORXJHsl8yc1xQ -7z+zAQRyiEqWM3Tjkde2SajNTor23Q78OEqAAMr3wjs9O2lfip42e0xxaMmmUynkiJ3fERr8IJk5 -0tbWHXzCarKmRgLNwbHdt8/s/Y1/cFmWe3sPTSq7rHa+fdCMf4fDTJxs3EFDEIGdKwBW6ARIxubo -TTTq2GUTby6yPy1MJPH4KrZ/MxIAY5m1vPr1k5F5doZgk3O3DJni2B87fAwQLABzk1B7CYzloD49 -TsOFTie+jj2QxX97qyfHmd2//X/gM9hb4Fz3RrcNi/c/Sk8+xRt3d2zwt8H1rVb4/g+MFx/8VrL+ -/yx7A/QTHxh+e16cMH/4QfUH/MsC0tPBVYLbIdGJjmgDqN1sX/P3kpzDtPy9FsPWtbSisSfx9VQc -ClC94UzjCboxMmFwkpfyUNhHxLWQOyXEcNiTo1pdI35r1xzDaXVZueYVlfC4kOgbBHDOTiYbTOmr -QctIEqFL4zciGkjPP/wo5fUtGj9KAjU3xtrF6avXHzCpOowLD+fd+1V11e0DXQW+Fw1CYZRoLLi9 -zITBseKwHM5ZVWV9GfEpf9/f+HePBWC4Y39qu6pSYWiE9h/5WpoBuWPV52d/mjjioSwB7QxuJoCV -hHOAv4q6wZF9/JScsz3bh5XG8rtI/I0HOLAAS3ltOmHYsZWiHBZv16oYwXoNPnMFB/MnBWrFS3hg -4KehDR0AxN0W8kH/y/IOPam2pyZizxiEtWfwzWwUCD07JsDrcQFTe6BwwNohgNs62MDN4Btkh1F5 -/N2Q8rA60SDvAy2Oe4+yxKvj2x6b0gIsN04eyOpP6TcYyc1xGZViEWeLHxb/dxaAoTzy454DHqeS -uny1nj5uLGAU2k5hSpgBOsrgI1QUFfglmGS5rZ+bTIU4mwpiTlabkp8PL5BVqs4lyLRmO5mamGNN -MYt9YT+7efTZOvavvW85U30SPyTjO29QSHugpoEbCNOVPscvingvGTz6e1p0V/DdMzuTXYnCsGrS -HLozOUfhafbwqHwHWZch07dYugxBojhXzJ8ro1aQTIwzipOiH2pqWJ4sKXE/tUIMhn4fXtmptmN/ -YMbX2JJCMdN83q916Ud+EsOgHnag+pPeef9AK+Ggqkv/+euiql4fX9Cf7O3ZBImEmiygXoI1kxZR -RUo6biOnhL89vTdJ7+AjrUdEwAigku2awAJakAKONXBPaBbxd3zPs7vtGeP5wU2HsW8xGT+5yArm -tr72SY2j1kdeZS4umwb/zlOZ1nty5L0/PgJuaeW6pmQ52Zo4ga4H6alDkhJNp14rdwiOkyW2Hgi/ -E7uIjwI8wqgfCndwOQL1A11DL76isNC1lVOwXuU1Tkth5Gn3e4J/f2KhIWmFfLb3bOgKYiiyMq4l -uo2H6ebTvQRBmBoVYOwDJZeP3LL4dmuLxtilCeOkAE566o5+rWg8NBwoYOAMJg9iYmGnuTvOUE1K -J7uz2YbPbOmkS1Fs9MYHojzYUAseDTt7VzsVOMwGKvl2gvTtmZhAl1DvA09YFI47HlHQopXchAHl -BF83eAAdBlVM9Qa17H73o5OGTKziJrFVXyMZHmax/Z0Ky5+uqDB676r/xHK9+EXa03KUR/npHfBv -VDwCLKeRSa/bT9Xnn2vpThfcTNuWUXtKoh8/OQ9DgBblGJ0U61Nep9/842zo2Sv+ylGZ/hJ/k8EC -Fb4YhdtZ2DvZQq0MsfZCyu8j0WJ7YCfsFEznhZB1DMzd8fjuF2zs2gEBasKjNoNmR/7zuuN5lzkc -ok4W9A4e+zWrgJ8PhwkIoGIBDkBaAybl+jRnsfR0S8RL9snr9JP0o9yG9DJmf6MAcGdNX3NQOfjt -+L31t6ndMHfh78vt+PYMdgQB1CDBH30OeTk90PdSzQHkpexRWuuGyzZZU0Sh0OE+d2ZY4WbifE3E -Sui1V6nl54Qs5pyJQpBONuDfSdouWzBnIOXOxWUb1Th7AGl1PtGGGAhaEwtgr4ORyU+i28cblE5E -V5U3yXCTFn8O349vjeJDQSOlesf367QJxwx672VaaziKv7rX/9MID4sV4EA9K7HDMjIqnGl0m/Zx -MAeRlvpISvy6Yl6wdHszCnMnewe0wgD+9CcRDxIqE3ZtrVgdeKPCwsxX9f4E/nxhEUDlRIEdDr7q -qKM2jjyxg5TUfSqMMoNOztmv5LDDZnBbE7cNf14vYKTneQD5wytp37eucIxGsF78iK90YuExmhIu -UQo/Xemp8Mu3rc1j+K7K7HPzQ7Dh35ObJjCuDCXaWzyRNNmhfky19OQ5tyl+OaF/YYByyQGGpydT -Euk8/R8tXyQRg9P7OkROIuX/hQEMeKxJP3M42gdAtejHbZiuzlgYdedIu1rWk1ivfHz3PT4TAI1Y -yKzuNHa5yb6iu0hHtaf7eiQfflxoYzZ1+dazwi22ORw0+rOlFcL122Nmv+Jb6OtJm+vJznx8vN3l -1q+MOtvpHkw5sl2KT/4ktwkQSF0FYAF2gVb8pfvopGW73Q163Hx2Ik5e3gSGDoEB0NbLr/c5e7S+ -D+ozWo1R3M936pI9vrGxDsXS2744b5vRDr4lVa8hzn2tlrSp+fynV3hIyMuKkplyn+RkBf/jpgnd -fXMyinbgjvonKXy1HztDGko5W4+gljuV9LZ3fWt47NG628Nv63jjvc5N8QBosnLIInCu+fXWrECn -wC85LBpOr6TxQLYmNoCgh23Q/VmFRiv3nn4p2h6lrypUo7D3y7dr+LndtiZ2oD4O+ENRRwn8s1cm -te8+5A7OlTyrulh23MXkSRsbBQGwG1q5QcA9YDj3Q9x8xA9GqbgXUscYOP603+HTyhLDzwLCoQBw -OuUG1b/cC+VPlYYr2Mgqir94boaf4rSOA3rJI1GBUbSSDD9zvzSJKyo645PQnrdHNU6qMggH/p0C -QBrCshvvVIxsRc6OlZW0TXAwJfCxE0ZiaaGgU2G0vhqmIU8aWPng2sD227frjJsITxhWyu9olFvk -D7LKzIFWkYMjLne5mNXYCPwxmLOVPaRGeYYpRUdJjE8cfqBy+j9Bv72PKN/V4Y+Hg5c8ZlZhwBun -NcVcwAzchLS8o9qf7G7FZLaQ3y9uMLgRLPKq+d85oGDitcqrVQ2OXb87T/7p/xShyHRqd89XfA6k -jTMcvBiwp4nDp9LJlLNjjpb5XpZcyHERj3vD+I5JEOpgswGIdLdjTY82Douojom5zPzidTvlsBIB -INjYAxv3Zcun1dhDGg3LTb1XqWHvERePs2zBwwEdUvBcXEkpTFuM6u3Vq64V1Hn2dxg+72bANyTA -Jt4mQOEpwNsF1pLIY+Ea4PueEUy9hcVmssw+2cFp9TABHCbV3ZMrFlFFtSM6w+6WimCcT+cRRWP8 -pNI1YW5pDyzJ+v1UsotfiksxR4i16Tff6Uvqb4QQr3cQx2Gpnartw2oZ7g4y+/ReGu48PPqxd6sU -/vLhAiHbrPA/WEQdbLXfbSVqCyuZ0Wh90Qn8TIx1KJD/DdpZ4KqsT+3R0m0Rqpa2LVGnRIfr9OJv -a1tp4V8wGBowacwesroUCl6HmT9lvnva+AW30b3pRH0+cvzUjQ1I9GYC5YK50u+j25s5Ey+2u+le -OPXDd785fq7jBjSmNCtbvlLFVOUs76elqeUiF96g7uPRH4lDoVwTzE8HCPrrHfZoPDNInBs5+M7j -ceWfwDda+IohDgGAo3F827SwK6uErs/5/fK83+qgfAvz33DQYnWWmajXNxedVih+9TN4/gtPuMZh -982QTghUFoIAcPhtYGBVUGzPvZM6x/bFrheP7nxfCiw8680tRH7mOXFCTI8x6DSCjfgA7xbKkLt2 -QD8w7gtPW7siffX3R5fnVDh0Qv9HsnWr8HKERGRP9u6wQL3ZM3dteS5r7srCjzwSIwPX9xZt9WKg -fpHnc6OeuaNzq2Y851cDiDNgTFQTB2ckWEnmynrARuQtuXdi/z4fcbdWn4vuo/ufy7njv2HDo0KV -4jZBtdRt/qxp9Zo2+Nv3Z5LxImQfQpzNwvF9xXgk0BNV7Bfe0qKHLqev6rmRfT82GdB+gdY5vUOY -OM+akbh2iTujCgP51xSeT7I1jzlQMJ5Jy3vxVyVb175NsZAHRoD7oucTdavf2fyjDi/GKqRbP0p8 -IA5zArQPJ7X1lVgUGDr/XoP0hn/2662U1R7lj07U4yfsYODAHlhXdoVhNXK0+/aTLtcEFcmE3Npy -IPgVftY7Bos+nipYh8be7xOLo2oIsotf3f9YC9nio5WSoc0ZYOtCwlS/yHvkXs7SzuqZ8+NvDz3z -WFAtwgOjjGlT0K8J3qf98rqjTxzM6imPP44IJdE3rVwKTiQGQ0kWjFJJ6YEUPiXzQJ6kerfg0gQf -hRNP0UOiWJS+re48FuK8NfBbiJhnehm8+iiVGgN+PiUWxhydQod0sHQygRTv5l/y8cz8SpcUo1sS -nE1OjF2Z6sF/DLSBwxzpBEpVN5gZErLN64wNkZ8upNzldLMZXE4VQdLp7rpLjMPGxGPNzLRf++vg -MrFz6G0z8RxXF0tnuPzDvJR6xmP7PWJQLB0T7Be2dj7MrMAP+HLXeNqaJsH+5Dnk7FGaLXwrOU34 -Hmg0C/imeG3JADUBfdItH6y8HsmKNf1Wy0099RJ+uPsiL1E8WqnBmoDmCw8kzx69UCc0NCwSIVJx -kJlUYJkIHhjOP8fDItAzel/PjJJFr1syJVp/ET9lxsEECP5g6SMvIsw01cK54/kitjmSakQauvbv -sCaCgirsAy0a0T568YpjA26TD30fK8P+NOwzeD0Y+iSOMBgUGNIXnmUgn2aYHr/yIVhzKfHwG3l8 -hXZNwFhctrK3h4o5xbzXrTHx7Gz++fGZZTus2PPmh2F8rySYOQhVJ3hRmcDLeC9J786bq3tHohzN -H9Sn4ztrMV4BqHTU2mpBiWjrt6ore+O1kWNIh6ZyjQ8JxSbt/W2Z+KnrGJo1uwJquHYi+JcZnCJd -7uU4w+c/4p/+E/Mkwc+XwsAIKV+a+UNkZC4VOykYaopUS1/45pPz4GdQYxjQHg1sXyg69+192cSN -3FdM9I4vy9mFm1iXbML+j7Irj4fqX8PaI0IiRWTJGtl3WUrZUkr2ZDAY2zAziBZZ2pA1a5ZQSkgq -hCKSshQtdtJGWbJkSYg758xixjlTv/vP/dzbnecxc5bv9/2+7/M+Lxc0lCYzEbOPxIcRWLHIS8jH -GHaDBF6GwvGHC9U+FwfHb3BkQbNd+NX9pB9ZQ0fxdfBrGP7uE8YTVUYOlC0KT51xNw3h1OEIi9rX -Jwyt4VEzAf+EJfwbSOFsoTCv8pQt7OfQ+0j3pOpvhxqloGESNQUpewekCQH1JilXC9CV6xx39brS -OKsbK2imgvmYFuTyCJpi/TsdaSR73U7DSHqjt9dH9mO6wo8fcE90F4KWmmlQYZDg0GeEG+FbiYu+ -bzpmZ7atwjNOzU9o7rB81A5olgueaulKRScMTZ12XWGur3T3nVXkYAerC2/cfyQh/ST2T9LBmrw1 -TMjrwgOuv53O3X0WCZU+LaPw9FEAsQXC2QcuqvdYnZosySyVyRK0tgk99Q8s5fEXoMi1c1vt9JtJ -+mF8xif14N870sdmoWdRagpC6yv+HxBYfAyHwrqCRKmoDuaGdSPvtUd7GXLaaoPUD4+Z/1cioiIT -oOG0n3h89f58tkpm/EcpN4MSYzo3aOciDRoUYbhWWkdQ3bpz6WX26B/7r+ZfZ7UYnIAeE2hQgJUX -0PjbEWUPsrmsa6p8p7puo/45fVc+hu7+qc8G/7rGJDYQv2mdufxK95xbt95/jjx2ShurPPcTWh+l -xhP+F1CmAuJaeSkpkMjsfSE6XLXw/ZlprETo8Hn9Y/fQ0H4RaiLigkORWQSIOh5fCPtpZ2a3w3aS -6+6xmNXtnQPQ7hkqIhAWKn8Hh3gW8O5nbv3IivUdK6w0FGD2MPB34z/NL/FHhP5G7Z6N745NrJrH -tnbXHM+GfBqD8KWM/2vrT1j7i1mql83mi0c98Lft2b0nH4ohSrwJjfZkIegleqYjJjjDxq6GS6Hm -hSrrjG1O3oLBAn3UlCsnKSbBfwMU9RoPkHqdeJptwVGy6RBqv06m2CjaX2MXVEZHJCXlaXAIPyzx -38DtSmrbiSsRhu9zXj9wv9cimPk44KAXdIsgSveWvBJCGdIsH8zHszz7feGn3tfIXflvW6DVOtJt -JktHdVSenWuOijy4nbPhvW55quiRB2s+00aRhuwCSOse40Mta8/nS+NSSk+vvN83Wd6oShMJSprI -TRAUZTnkqIeH/ObVOYpm7NhGKcX7pVZ6cNeLwIKkbAX2vMnt3X67cuWQpVMd74eYm2lGnd5/Q4Kn -V+2uUZOb7vXeDjqWVhIeL1xyF6DJTfIet1THBbDnLIZGm2NdGXoSUzyFVxmgttKXQEXry5dsQhqQ -Qp52OWB9tE/wx5k23m+o2V/B9eEj0AZFEokLPgoBhXtoDMofUkpE171387ZaafhlR/mKq4c5djyf -UoKm38kafMCjDx9G+JHkrKqf6Eo0tQJyfCs5mcZMVDnN0hagsrYl/xC0q7cnsS0A7F4mpUcEd7u8 -tzymcV+1u0pzyFtYXO3K1QSaNMSLQXD1pPwyi6Nt7z3bbwxwiH0Sj6Nf56nKlw9NsVOzgJdAXua9 -tf1ppkAO5TuTmxv9RAKEx6FN89RLpCdwU/GxlA9wwCEsl+BStYD1W9fZoni0oq2bUWiXw4x95GmY -xQdCBWKtbPrLj3GeaH6frBcX2mU88F1hFFo/IS+wZKfnkro/L9KCkeV3nxlZxhbhlAfm2Gj/arIG -Dyblqf/lWuzknaQTO3OdFKWtfQ+YmS0KwxCRrLCoWglELJReLhwMf2ml3PX+p6te5vFHKYN/wQJv -IPgu44Dp6uSmubCh+c1fH0sksfVK9rNuWDiNuMkArc6TNTyAtSxx7SN8FyxxMcrp3sktZdn5Y+aW -FVfHiBYqdZEN2i1Dpllyibki7R7a+815aLXtzsjr6Kqv0sr0f4ERc5JDvxfPjHFFx6Y80P4RNZk2 -8mm+B1qcW+oAAZOiJCyn00Xd0uobjwp4knfm+ATElvUwQOvwZCwhpw69byp9GnNnG/4Yr0uu1cjk -8pE0O0sf9Q8WivdfOYTxI8pseFtoEl2dgvKKOw2No9CsBRmNDzAosPyeFgofg0zWP9oqeHnt3m3y -s0YFULEOGUvZIlXUYBcT9+mGzLmM5/rxvx5v51fxrf8bknKjo77ZVrPI32NHSn7yBkplrBMZLo7m -ewQN28hMWPxbv/T9Px7fI/HsQkdTZl8W6mq8upqDSTg0j7CE9XRD4XDEbOjJbzkGOxWnv003O6i2 -b+tNvC1qCz25LkFxCJw3lpSoA/Ar2AV0P2Ql9na9lhl0O3rlwt0rj6GHpWV4e+J8C/2DLzlLd24/ -1VB57qn4CwUP17kLf3lNwDeOKKTDeWM8gNH2KPDnPzTCxM9/q+wpKEpk2s8ux1ec+6oIwkNc5EAr -XMrR4aHj2xtOMarp6tlzdG2QU5D78KzfkBYYkigF/3whB2c2eyoy0kzjxkkLyRXlF1RToDoxEgM4 -vwDI9REG4twq/bXHqvWF0ppxqfPrNldv17sGTeWToUsNyeBNr7do45INmXDSeyevZP7yoHOiLVQV -ScaCZmgE2xyHo0xK169stU4sfti1PplzILFsAapuoAKS7BsocpSFbBFf3C2jymVMduyOsuEzeILy -8v87CcrBjTJwBI7LVKXsnM3iW+Quo8aLD1R3MIbWmIw22kHbZqCMvgjUUmsZwPO8rLd1htfePLW6 -/vj8R5Yyzs8oaK4YwgMgPcJ9+bs5p15uUGzomH2WPaPsGL+RJpIilYGPewmDB8hL8E2pEpaaKI0V -MzVvp97GupakxvNCO7IgTFgJktKNnB5R6r4tvbJpUMgrCKuXcHKHquubN9BEwhIRkPhyoLxN7+RH -DfgWnyCM+s4sXt5g/qRAE/OMFt4BSW7fxOGXd6JPWfxr1yN5rnSF3HbN7XsPzS/O3YiAKi/IDMRQ -hpTr02Yf2Z36y8hEv7bd6GSTBs+ZI9n7aYMJDxnZZwnyxIdsfHv2RdfJP2qGe6WfXsu7WCMXDW3e -JrEBkiDKSwtsV27eWGKpRY8p99S23HpelId8v4hxZOaI0QhNKlJ5nSRsAWueSAfKDQQpirorY9ib -9Oisn/7P+PnZt7UVUCcGGnRgHQfj7YmjprwgZdYtsnWqylH5UYuge8bpfPnnUAEBDUoqMzE9NSxj -SU4hIuiq+GBJTsnTuSFFaDWBBhEx8UbcK866OQrNzkvenivAIcPC6+WvtiZCmy2ITH/xAhjOahhx -L+6Jn0RY3Bx4yel/8so2aLc1kYbKQ2bJ+SGcpVzxgMjFY7PB0lmGrg0/mGMUob5CUApKeRXZRczl -2tp4xumxP/krGq/ducO50WyPM7QeCOWieMlUbA2sQnXWeppbPTlwQ0VsjxfDBWgCioKBqDkjRJyp -XE8rn77hYKULSm1MSHxrc6+qC3pug4CB464T6FL5UvjV1nwMv1ifQ9DC9ymrVZFXXkIL70Q84awg -ib8ABF/Rmds9pd0tW7bmJATyVyc9C+0WPQyNG0jYZfHWwm39K/pnrym7X+Pwtni08nQlD/fkf8GC -GsHV6wsyCveUPpoqyWjaxLrpcQm76VtaYA/8SgBOh1w6e3L+knzrFe4SxDzKJnu359mH7m04aG2O -CAcO1+6Aroeg8aNU10m2+KIP/1GPa5l1LTins6jAtLMPmlaloAGWEYiCOiro2Fq/Tqnw55HOOY+2 -/rpXwesG9WNaRrJcmAuu9E8V2IQU4q72p35fgcjIvaezjx4qRF3GQ/yflLvfHouoZ8wBAkctp08z -rMYIaecce8NFi+a/9ezTl23X7/66P/XH48WWX6e2PbLTfA219FvGSNGz/0f6TqGeMg97fv31CzN2 -n2IeWtCr04YTTnfLV1pSp4R4bZElusGnsb0Om5zWsNa7fFMHtJT7Dy7KsPn9VZs64U8/mdCKzQee -R5z0c9xL8ylcTke5apO+XsLHzO1H2w7oq2zwHm7okWFU2PASevD6D3yUgiE+0x8bOzrPln4R31eW -1fz04kQbtMGCBiXVLvAYG1Ikx+rAkhHes4o1bK5ocZND/38lot4FpB5dtHqBmxH/YLeImFqwts2M -vQQV/dNgoii95h+qsLZJXtVgEPfux4DXw/bzi3VQHeKyBxw4P3g4INzQHoTfdPom+rLBhylWpgzJ -ulvvEOmO3dDEMJECj6S0fLdl3e15QWRPzUYrt0d5YsnjYrFiUGsLIpT45bGUU6OBGs+2sGd8zGVD -NWV7V1xyzPmgvWIR2nVFpPD2IAZnpCANPDrJ77ApNOr4oHFxQWUo+KTJ9ah2mis/TKqiTMSXbZPw -HcUz135pF1meN7Pc5wRNFVLBgWwFFcXKGTSCmytiX3+V3+FrinwtZ6o0oL3/BArg446rGIZaBmK0 -inYeUS0dstfKcRmgg/k4UFhDuxLVF/zXqr3yXonsF3lXkVzemSQzIKUETYsCGKITDDFzj0EDbsA+ -Eo5IcMoWOMQZyC3dqG08cWRuaKRHI2hwfEZJdye/DlRI+i86quqC1JRKj+0fYyW6H+rfBCaLh/NO -M8OtT7QYqdO6hBCFUFlifhUfvWXROr4hu17jU5CPyTURaJH1P/Iu/f6U7Qxx3oV8xxVEx5UNprpN -9qcyQPOU/5EV/1bh0MR8X8UHFq2tCTscX/n6yBjabCx/aPICqiH4b7wg38Zgg8cS+5jUHt9DHNzP -MxYiKBXJ/H/yYakIkcVn3oc7T1z5ZvptpjjF/0yAxC1oqpo2IbmdAhhrD/BlP9D9xqrVmxWeftGn -0iw00kkqEtoh8G8+Ug3yXNxqtewx9Vmrsl+6sTIjLEniatCmB9p0VE/krLzz4i/WlUqvnhRn2dV+ -joitdrz5f3CRywrA50DC66miwVzmtdJnoqd7Gpra9vNU7YQ78JOy+0DNmODuwpt4RdA9ZwsuKi8q -OG1u+FZzwEgnLBAIrMHTOKGERT7/dcgHqXDl7B9kcN4yaWHR9EAIcQaa36f0dVlabPSVeOp2Nb9V -/Rl8+OnhLQJWH3yOQ5PZy9xcVhgUl0rmsTNVc86J2rjPx75l3ALVrIEYwvkWXKF6xs9rBXEHZR/d -/tLASX637iupdGjzLdYZ7e3msKzDIE8jc/cuw+1Sf0653NYJ7TzUf/4+DJJwnCUpEJdOs4wDIZfd -VQZ/Xsg+4oK+vhqLOPEMZkcmosFSA5VbyrGwB+ZBxfk/L593kjnMcnMH5ycBmDQHIV9HSrh9Fv/A -tS/9c+duzewkb7GyMs/KUzAxOyTHZyvwpS6kT//Hx5APJfeLY3+WFeTARIAEGAaJwAK24RTyA/Dr -vl6/GHL9mva9fK+FZN3Ih7yYmnPQ9PLSbC+S5xJBbUXZ0H2x/Dl7sJrwwbMLVT0qmceRa+gcoY4G -5C4WogEJAkOKXsbZ2UtPfNE03MV8NLnCwTZZKKQZGkKSTWEo1PgMlpqXBHl+Rqz8UMWpzKiqeaOC -HdrwRfEsPhvr0377XDG8oWaOteB4NDZwAxfUeAT/HHpgKSeT46+fJ2Ce4UBp+XrTmeG3uatfz+R+ -UaP+pzbVUacR0OZcKBWVT0EU4+EhsRbD+0HYx/Uiqyfrdq0Sgr6JJA9ewmJClslQCDGtveMubLkc -ufVzwrfxnrXhd27n+UHFDhQupMveGCW68Aa3ypY9/mv6uE55nt98XjsO6rS/zMS0je7r3voZy2bF -jd9d62Uqh2N6ZaC5FWJgKYFw8AGkUoQgz32VapbLcVuTkifT7+4OYcVsTQ2hSjMyklQCfhsfx79X -vXB8UrEntzo7bNq7ayu0pYaEskN5IAhnaTqxuucO+TycgUeRaS/Ki1mxYrugQnYSbKnZaG5wLHzX -sSC5wUshdbeF3KTy+BCC/4CBJ+jzfLdzD8xJl/5ijLCKntDKvCzgDY3+SDgMkhR+LjW2fNs06HBK -pWMl2u3kjNH8/NYNw/pQ32ESATn/vfQk/Ez33nQ5NeR2fUM1U5N/ptvZP58U/oUHT5hgyzoCaCkC -3BMIGhqZD1ty/c1uHbFgbzMbY0JoOa22hCbhaZIRllRQd/WxuC4yT6VM0oOXHYM7kBR8ThD6ktLi -ARkExpgwHeoRRmXSk7f8ViauyOuv0P5PDISSMvh9gNl0CIKW7LBPrHaU2ZrIe957VDhdxNWC419C -60N/pwN57iQ/zwyXeJGs5t9i4F+iGfJ+JhGax6XmAZV+l9fl2m5pmrtvdb3m/s1VpsFt66A6PWoY -+HRtO6ipdJM57MyJ9eirX/McxtePKEPDNyD2IXgwAkV5olc8sUvcgzKzP2gWO8J5d2qWp4dJIPhq -j3jdTjpo1ws1G3jaL5Jmv6BzvSnkUT/mJYueAqLlGTQOWoKR57Y0V0sleJ1cfyKxPWNFh5V5wSfE -HLRhcQkHxpqSFF93MTC5WzzE74HSESaMyZos1mT6KugxZwkPDASQwHp7gsIn8P8jRK+Uww00HGXX -WbsMJ0wUHpAse6eapMCPCfkLJcnUa+fX4HD92WkJz8kmmcg3J2QWbW2hpicUMKKrTpfNt8j+oc+2 -CoEPF6qmOKXFRD2gwfwSDItEYAgmVOssXvi9W7yXS+f/4cub/NUiFSkV0IEdvk6EdXlX//R04pTS -pZ8Y1ltRZ1pUtKc1oO1p5LYZHMabdH4lH8JtUgTonhdeey5nc7F0z3MDNw4XMx5YhqVmADCW4I3q -Y7PqXxl83545+cj56/VVKSpQpRIxjACTfvhVj7gNXhodi/RxTOK56PlUN8zSyieyag1UJUKAgqVG -8G1oNQiyGNvEfgljK9KqdElm9jDCCuayLIFIhV0cRcpyRTLDTYadmgKm1kKc0j3sUpvORv3tD4On -85NvyvkcMTaJP/oXg8u2Z56he6tHA0LRIg8gU7bY7ppp1VlUzju1/k3pj4fvRh2hFUlgfjrJiYzs -ItF751TM3Jk1dF+Yhyx2djwzVWwRgI5NAJAE4FIf1/P0qsD11aUT2P497GK3Hol+El2EiLSAzx03 -WJt7nun8undxdd8jf0ePlZ/ZC+kwlCEOZgD+uzRYbMybaS/dxvDxVbqEouz9GcG++EDIJgmAPMFf -r4G4cvql6tUCE4akEVvLow7SI9GQnhzg0zisD2G0e+68rNBRqRRzxcuNnMcv0tt/0oekkWSIhWOw -sRWYjoohxsb8P7yUrlis2f2gAZPXf55N6V2YFkQsLkMx7oFqWch9d9zglqWSJab0rIJ7UHmX+fQR -yBFARgJ47j2BTlpvgumoTOpr203v4o6uc3h2UGi4K5kn/hcjDAq8NaR2VOfyvex/1oaVT6RPd5x9 -+/TBFIYDYlMlQzW+gWIXkfJ1DqhMVi28KeBZ8WrxzPQzUxOIzFwG/4p62CPdJHydUW6kSAWUShDf -vBqeqipjvS7Veo1S+YM72CVHG9ogW4oMfCuS8sLwyUPq+htrH2a4yB2O67r3KdgSBuqGRHgAanVP -QgAe/qS13V1WDakaaru6olDm4oTsc4jDhQzZ43ypnIvzxv9XN1Lc7LF6E/ctntu8ei+mNlZtD8jD -Wp+DZDvJLARBJSG3xld1gq69JJtRTmCr9s7SH1+zqxrgLhrJ1ZxcHfOU+x1a7qyQGu2Ci1cXdWBw -X9sP6cYg48A3hPLQfPo0wxmLV3m45KcJ9SyMd3ObsBBRHhnsgiXNw1z662tqeOZYdLFx3m/KLHQN -2bjuWptDygdkAnDHUwINBTMvdE3f2tn+c2WyKFvaokHt+vceEFn5Eg6DQuMfMj9SQw6Fudh91q84 -dfvnWfFj/ZXXbCKLgtXnIJNqKHiA2X0oRz+ygSP5cG34fjLCMKzSKAPpNYr4oE3Xa30PEt3S5gEL -KVoVX68VPXO8eH2TbT9vLQNPPAZSuqZkOOkHHhcJ/w4G2HpVX4UiUpsMtkrgjpY8UxKxG4ScW2SW -XpTl5sAUZ9bzRnHyf84mfZLO7OXIbWluYLV8B0lWQ5hINSLwkoDbpuHkdqPwcxNDuJy7/fPMdwpy -ORkhY9WWaLA44tMBvUlPi+KM3wfJZN2cid2XIhGOcBI+BHGlIBNhAbsWNFEbQSKjHOkKRgKP249I -zGkd1kErci5s2vv2qaQARPpFwbj0CAHgzXRxRzLYA5872T/iChX7YFIqpAPRKlKCDYE13Azl4YD2 -PUpcHiNUzX4wbnMd3L4yX8497+qvzHJGSMhHSWGEP7scBX+D3j6KK/w1wLl28eJkqKlaocD8h99X -n5omQNrYKGkAERYW5gLX8t08UUlnf4oZnfTlTe3Ny4LdqZAxLUs8zt44/E/xgOE567LtWNV7Bp3h -na4xMgozjYMShRA5+BIPxNmHm/nmIdZnQtdUDM0H9tSdGPaJMYHZ20hwqrUE5svEGqtGXV3NoGTd -vcr73NeBxDXrLx+gyQY1uK1fy/3qRkjxBcvjbz+mlb205ayrgIghl+AEh1vCLgKgnTJOd2WvClb2 -TKsP3rb527n3R2MhgxCWocGjBPbV1f6ReLuuMUlbP46U089ejXLQhBGHeUN+uMfCvLnntxMjWocR -TNWNDw76CPps+gfJ8rB1bOzR2CY9h/M3E/k5Cpq626R0dsjCUYCDOsANGOAhgp9et9a/krnN7JuY -l4SINTaTfdxaDQaMdsdfakpv643N7XR7Tyhttfc/Wbzof4PVOXgjpNZCxtG68AInR4V7swVT+Hpe -O0cwehtVbDkGEdSTSZbeJM5uJRP+GxHsKg+DFsR/FXj+OGoDqYYvwZY5R4IqKoCFWan/Lu+UNtMp -DeVVTPLPz+xwo4foBGixgLf/Q8NmTM4npyNv/OnNjJOLh76/6foXntJE0vensLmc9eKjrJpFvsUG -cTbrF3cgM5PIeKIcnOLB4csXGBDPtrqbqDt5+/XbQ9Z7PL9CpFdkOCEIWCbwf903eyD/wL7bHZNe -GmxyjEYaBZWQsVQ0GCiK0DtE+jG3xrGmmlcrPBhigtTiPi9CeplpsRCPpH0W6kM8byuCP54SiOIJ -aH6dxH0UYnhGg4Lclyn2OE39ht74SsV105uOS+/O/ozVhAw7o8WB8gQpHCqKD4gnKEy9+HViJGPo -mVGq1HWIGxINCuoW7UrWc2bzBU1+2a2XiytXSLzZarQDkpugQURZe7Bj6I8SzfIelhY7hdNJ0XVn -eGgP8SyGpwGrKxLZ26+qlbxtG1MJQ+S63JjteQFJdEDQy9XisYGP6or0zh98M7E9RCssqHryQjBE -RkqTBDR69vTGOlNKUGImrTe8++p5xWBLQ8i3h7zj0c3PSv4rI8Xuw2pSnDrJrjuYlRTD74Z7GDnE -dw/ieUKTBkOsYJ1uKJx8u4n+IOefsutKoZatR+6EQyoetEiWyuWE2gYSS54+T1J8vA6vsGUMa3eX -D8NeStx6MFBJ+uLR/4MeoFj1rGuXxyV6uq6tYkj1qfx9XiMTEBdeWhSUPhk3JDT5T2ep/nTkN3M0 -LdIfQU6XZP1nHsBaluKF97WtDD9z912A6PWDO9ZIlA6wjdRAEh60uMgziMArR3E/5xNuMWt3mAqp -9DMXSW+0OVfTKwHpef4XKRZsuEAQchX3xXmxq1dF8Es+YJGTfjkw5pGuCcmO/YMQoInT1mhOjTB7 -toHuBn9d5YhZhX7Uhf9KQ70olAko5nexVOXSbzto0XkKm9RpfDTgPzNRKeNtHW7GekjyBCa5ruvI -akzyvdCbDJkM9ncmku6S6IXhJ0H0w/e9QOdr8/BEFdvEi/QvGzefMTS7S3tL+0/MYIZ3sZH1lbT3 -czah61N5AQbltcXf4MKrf7MCZB8GON7cHTW5bWjQLX54OxK5Q/EbJFlKi4xycTWcu7uh8/eRbVK7 -EmLUjsublV7+A/GcocVDTog5PDgbyia57U+h4DexqtdvBXMKdU3+LxJCRpDUGXS9Afm+soQ5sixS -+W768Xjd+wdX/fi/6QCiQLPuih7m3YF7LDt11G8mJJ+xy4J0DtAgAstOH8xRqmtu2R8VfLhYfvKG -SXIj9i8/y5liRjf59ELKOYTwJSr5Bpu3JO7ff6JdxuHdKmnOg7SpqA4ZJFEeuBVqHj7QLuRhNFGv -FBeJaH+DSDeGOy5T0RCf6e+PVp+/gnxikem6idln1uBlPOc1yJzEZVDwxX+szblxZuCpZscnTOCl -shm7Sz4QdQMZRozL/2LkTtCW4HmvVdggYt+U6DJmulu90jx6OJk5FDIP5f/hBb2FAWJNs1F/lqLc -2zJxBg+aeodSY6ctIW46/4F4KSnNvysi6fQchjeJ5+ELa25Z3/HjtZBOPdqEAMObn+6nd5Q/5aoV -3ppmb7yKr3rWIu8fDBQpcnIQYrIVO9X1vNbm+S+R24xlDLIiqZEQW3A4GipbrxDxsYHcxXsxbxbc -6kuUWCOm126ECPKWkSzLmycP6tIlfr8aWqMw5bXZ30JzanOkFhwDIdlEamYFBs8C1oP2COAh8MZ4 -SKAdQemrjkvGa5ZW4VWRWWtCkDLTkX9kcyD6Ypp0AEG5tiF2LDP/pMMO/4yJjeklZkd/QNSfywnA -jcgwwXF90JXLm9KrjsWwRLInzqhCep+XcBTtx4FYy+cSyoN0hrw6uU1GD9JtfklDfIOWgDg3LGks -JNEFTuvhCYPjSbyB/Fdeea/S8EZ7i1b8pokHY/pW0ZHtfzb6aD66M2p2/5PA7xY/2KCArCfM9Kxq -U+XK2MyqVho826LT8TGFF9KqJ0MeNkOV3AXgiRYLLE5ex5zWjmBHHSvndT4fPwe3UVHBid6/xEQW -wCK8Qhdnt2Xd+lNPjOu10aKSmmt94aLKZSxk+JqOutwfD825c/qHazfX7b2LRb2GOOiT4IQ/Tq37 -BjiEYpTnf1402iAnex7dsJq74MF6Roh+bYljOfrS5s9daZdEovRNmmRGHmuvR3SaQryaSGjwTcGf -OkBFhfi6lpDkZnVehf6v0fp8i7GH42FSGcvGuIjbfyq5nCz57El/9onJP7137StPQQQVMuQtgbAy -kPdfzdkvMlVhdwo7/NCHfvO3NfF5YyHmETKEHlxCqxpxCNOzGty9c5wz+Q83yY7bMv3+biwlBCme -yVD34YO1o4ufDD7lG++i6/5ldY7jyWsDs0WYQwchPeOIAQzKSUcCJBp85305ZBzyJs23DMviskvP -bDgr5ugGc0jFv+Hg76QIQ/eGF6h+5TrJxcI7g9Suw83mYnogzTUyRFkUGkO8tEa3uMebGW9Iqe/q -ODIZyGaOuHMbpqgCDONAOpDbBYgxEtmqdI/+mzi3KAOOh8O8K/VP8dg3yk7CVBzwCyUw1AFcsh0o -50E84nDexDVGz38HedH52q9fh2vZSiEjiGSWD5IAI3lHFKHvrrNoi03st31PJuSDT785szXjQ68b -xP4WwgAmxgvmX+7XjipZe/9wpv/mTvXVqHWscECcJwK/6TuQMq4A9K3SUPgZrvHV/bY6yl6XQ7ne -qHLCHB6c0AhfBDlModQ0TNXeq0Nmhv0W73zf8LhdYmPmyw3pNPFoTwQeSHo0DRJV1ynVBb9pqLj6 -k+G1WOTaHH+Y87ET4J/s6O22tEl6GJ87N33HS3tkXVNhHFvzVaOzIZChTTKQ4Rn7dRVq2z8b2O8/ -Jqtu0Jbwds9QK0xFB/hPrIQjscpOKPNClw3RcsE3TW+1JS92PMnq9crMMVLdIfMvLnAF2BKUhAo9 -ZGh44+ps4dzNhxunJyGNETLgZkw120fs8OqdgddXnXrD3far5meA/z7o/AUZclTjhsCSY1QUuAvW -fv12ZS7oh+njFgXt+2zIJrUddBDZHBmPj7ZAAzyKHOSJTa5rGdL1ZBU5sImazz8xT1rchZgpkvHL -DNST/LxvbI8YVJHTP3lq3f7NOnwDuyBD1eCwWAppWFO9m9T9Kw926Z/kjHrz/Nl5q744iHwNz+Ep -QTJqJiXbnqKSL3NEH7398e6ZdIarVpXqDI2Q5kYZosKIKK8gPWO/P3wxa+085fYdYVb6WH8v683d -LhBPJ2ooxQm/KMWxfLW3lYcs88Uilfy0+2o3sBAHB2ow2U6Osi3rcflmuYbh6NvNVn9+6dfcvbB/ -9W9IwyIVDZZcZCLa25G6Zx22Cjx1i5bdPPXq0MgpRj+fMHUzSGO4DIXv9JImoGn+YkGKVlIFm06H -YUaYwXGLVAaY0A30nSZ+BUDRRnEtjIdZr9nFPYvosZO8E/DLKmg06g5MRAvopvHRCX6LxyzVUMCL -gK0SOb6yL3tUmLEFGYXhTnWJ64NMRiDgSS8AuB2B2A3pM/PqFS6qeZbhJxp01knHMWXBvDigjxX8 -dTvgZmsW/JJ7RSS2Uva2OKtCZSIHzLmAQLC0pPaN2ViZJ765Jff1iW3yykX0ue5siHeGDKVfSayL -kFHS+r0/zxbaP1Gna5UUrP51HQaAwtohnRE+oL0rIAsBMvQYtBshMQy+baXXWxoCh1veN85FI27F -b2ttd0LDBAm0iMDzMLM/D3Py4umTr9b1oH/+Uru++jdEmErNQHp0TwJwyae/VL8XFAtt/ZHvZuF8 -s4SObwGiXwTh9hLeOMLslLdaLrOFL63M6nRDHxjxvWm8eF0eIsgFIcCPlPDEIr0d0BSL46J+n5a2 -+munfVG32zZwc7xn3mAFGWsjQ9Nq42RLeHdRI/dajXtXmcbTvr8/aroeQwNNSr1hEKAM2ksYe7Q7 -5Pb8LsNNHC4h1irc7cUQP2kZSLOoYvJx21W3vIROfxusfBCT++2Lf3YHDRTpkhqyn9n4YdhLNf1S -omJb4YrWFb4YiKCICFlWegTt/IBpSYQxGNENw64Sdd78hnkj3TkROZce2uXCaCI80BLuS5VpEMj0 -8AyTyKj6I8Ukvjhft91PYz+VQlwjQaAv/uBHSjxRDWalF9XYGXJjtPET9lDpran4ppkHP2DqT2gP -T2K9yJqbbbj2/W3mPUP96lw+2mlD71bCXFxSZZ/S+t3ODY3ftpduMIOQTk1jHd/2Ap7ubBmVl2uy -atbAhL+UTMRDBlVol6RaWPKg94faqQ0fvl8s+lAb0NUCmTcoA+1GJccezPkv6+2Tm46Mib+yOet1 -9ztv/AJMGvMv3azobZ8ubedvr/TJ/SyXHC3EE/CeByKixxNgUE6EdL/rG6FUF7NikZhjM8Vn1zjL -ttd+hqkxU3t38mDOsR64Nc2gMZ/et2bxp1PavnQY7QGAwW8S5EZ5/HKPdUa4gt8yZcRCSCA016q8 -S//Nl74ruOaXYjDlek+y0S9Q9MffOE+St6mtQNH0I+TPjRL2b5VtESvdm7mPwxTHQLy3BxYNDjID -ditCcGWpIsR9L7Gwnc84mN3K6/iD2QwkTGEcNB8FDKcdyMWwoWtcpuGcV174obhitu99tIs+cQPM -YZ/06ca9G1TTUFkeNw9Mi5TUNMw8aOGB2O3KAJ4e7ghQwUUOKXqlakQ5w1CmXHexZaEl07oN301b -4IBETZC9nz0+HgCAp7wFeYKedPY6t9osRPNG+6Q+egmxGKEAko3sZDgOdHvrBhYoX4qbKh3KY9lV -eAL2m+KjcifgpEraBEnrBykJb27N9+Be6eUP2U/XNu7rE3ldHSkCU5yjcOCjsiiYxQmtuS6WLKT3 -am8or/Xo5ypJTZgAYJl/362Az13GFnaSBdcNVw3KbXCtVFoB8SOWIXnj0TTMG3rPdTHKc5HRfH5U -/w294dr0sjiY89RSGyClpR/V+oX4sJmR33hfwguB1k96tnmMk3lHYE7DFP2EhEQ12UNbr/D4vKcs -JkMqX1PMe+feugy5BpggBrTtQ2OIzS6FL6292tN2tW2KOGqw54rQHjvHNkd4DFlbTO33bT2yMzTd -TNx9oPmN3Av+lx47mZJh5J/ggOAlS9xMes8LO6Lrh+U5XtWKZd1xEq9uhMmYEX4hPtQCFBYyUnJg -kb4eabcxyy6VrW7UqrlZ+GeDXBJkrtgypCwBaZa3Pse8L2mLnN0FzPA+cXaRp/IwNWQqpBwB2XfC -gLmYPzY7JV3a4PW99nGN1ycgIzSWIQlpT/ACI8TLRU+KF1uMBL95cqsd4SIrCmkhXQYmNmOhwIei -r7np+7nqPw3rHzl8EGtv4w55/xXm+AqDB5cgtKMjMWtP17nvuEfHlckK9auXGPdII367r4M4T8Hx -EG6ynODPx3Ihyjba74+ptxSHJSeawezNVGBHB8qz3VmzQSOdt7kajT6mKoJjOezNN2HWiOV4YqgN -EPwpf1Mj/Vm4OCIgw0XUpr5g/ttpmAPCcgJSgK3zie88XajOh8yEhTnurOca+03rYLSpy9EYhAeh -QiZafNmF+2jpHwFTv8yjAg1d6uFNMBm1ZXAAeE+azjhM9UWBk4LGtYEQDZcjfj0w+VlqIP4/QE0L -oeX+1NwX08WYjAljVWt5G89FBRs9iDPsMgJAHgAWG/xZjzD45XGat7TE5l55uyJ34SBk1OAyKPkH -3zyvU+37WN6/6fqTIY5nAr+8b8bBBCJUWDAxTdq8JsYO1LAjGp62mRxIYbycL+HJFQBTo6LEAyhu -ltcP5dcJCMu/cys76fm7US84ESZtQUIBZuXEDE8c5slin57wTeaPCZO3vUYe6F6oG6cNBL8p8SUl -q5BBHRbAxZVbKmZTY/1RZFK82yumGze/fgYmPIE3d/vNIuRpoJ6wPTxxNevq6wqvs869gkyakwFS -cVgUDuVDVRWns/VslT2tZzBfbvzpwGRMtMQBVmlYKI4ShalcGzriMtC6e+XqqZtn6TsF75yHEQ6A -MRT5Kud/Hdz0PFiCMXVm/IRHaVl3wEAmjACFln3bgaBPklpnhJ8+TnzaeQajVJ7IqQ9z9KOy+6Ls -Yvv6SvD1joSgnWVvBhl3N2doByXsh9kq/+ZjBrCY5hwSvnB/Y4fdE/XPm8QMVBL0vSGORmSWpUUo -LrX71YvqUOuwXa89LgSWeNwbdYJ5vkgRJw6Qei9lh7ahUqSvFl0rKUl3La2Ibmo8/Li5jiYYeAeB -qwZslwRPXbdohwQhjfaqZ7vNzT548vMlvYPZ7yjRxEMW4dsDxUnwJ1zVkRk2VjY/zjM/eubnbKAA -d1kAxDwJlodUx350dnGW4cFGgY93q4cSP91YcRT1DmJzBUcAVg1L42cdJBebGzyqWX4cMSga/FIH -8WsjYzGO9hLK0tKyFJfw7kiy9M2bknunJZGNOW+a18/d7pj6N36p8h3F9Y6vQu+S+Jhy1dxr80ZF -5h+aMEkDEh7/D0RtKPHFByhajF9s4rU6/d1wqO4CT7qupZ5YC8zBmIJi6denK772OiBwdEenWteT -Vq+rbQ9dK2FKWST7E+oYF8AXZPXIJnbdLg/3zNGaPdJXOpAYAKMppcaT9fUzfS5fPp21me8Tvmvh -Lv+ep8m3EUbpTAbjKMpBqdlo4QiR6pgJQ99V/PpBQ1dkYmFEkUtQGLl2ZMO1VKbAe/bSW4tN6aXp -21G4VohTOiUFqZ8bmJBF8fI3y+9wKnmysiVo+2PDM1PntzowM8GucQSaZTJriptY6Ozl/lV4S+9J -1wHRrz5D34o7z8M0LSzngQr0LXdli7lFSHMrKA/zfO0tThqOdIGY/UF5MEgHbw8HBOGRZt56rTWU -U1HxjKBS4CW5y4ZPmi1hNA0kCoji2yhZw/KB99N6ubSEti2BzBE35L/B1AWXLHUwOG/wBFun/2QX -/48ujm/H70dvO1ApYnf/AaQpnwIHrgAwj6SRyUZpPUfnkT8H1jFMlTycLHX+CJPUorblAW+AsY1X -aN9WnYSXct/XqPYJyPntxNLEeXu4AnN9qRqxwiNC3WOfFCu9kHqpOWy73nmVyxOY0spSKwMS4eHt -CSSaPJwoCz1gqGGGTrd4XIkosd5y1DPtlu9JBJMRbSonewq9Nn73tnfG303iGh0f++HNaQbOyp9D -33/e2jXf1XeRF0Z+T2aC1Iu2GN1T7O57OJYSUbZFfeCu/E31NpgaBAlPmcn9bcxt8CHe7ovRdI/U -L5lQMR2/n5BuYwok8X7iiLo8xO6h8PHP9eNVZ0Yyc2p2dGJxXrm00RS3sarzVYOOjUhSPNu9L40f -PN6n1blAeq+XgECXNVhyNdBqaajOXvlqbadXrg0iVaM5QBUmJiVnXmBSKKcv/jkQ2a57TPXudavN -ehMl1hv5YcLiv8ugSg5fMrE9rPXNbcWrU4XCacxNvFfhFhNwJhk5YbDkKEW1OxtldwY7SWkyJo6v -3pcVfDvmq24ApDH2L1wAhUJ+uKpWulH87kcjO8RsVaUrgjAwDVnEFYD8yLSHs9zl7LdTTizUKK3P -1LrydW4fZIA8GUVoeiKcDTBAfRgYbA+w3O6t/Ogv2BcdmCgY335UU7DqZiCMopLCm4TyYJWz9sXa -trY+t4KJ4qZ3q9icQ5TrYHIGy4xN3jmIHxrjC6jJNx6TSOPnttvw+BhMowvVrQNgl2963T87zy95 -/ucp+tcvropzfkyH6RJbll4G80xLJfjIhrIKtYHVjS7f2G4r3DfrCG4bhtHdEjkIuZalJq9lMihv -OaexmRAleokJoe/imvNT8gLZMBVHkh8ZgKgMEUkbFe5U6WFcVfVEm+2r32IApK1YBhTq4J8vCh2M -9vPwUCN6748T6bvkElam+q9p/wrT3YZDo4l1NooYX3Ihf8PoqoWx7Xm/ZbW5VI54+F23gIeC5TEK -5K+zPn5tGrUfz4SsQY2H5juKZayCyQSSkZQrUudxc6SfWLDycJgNX/OI6pVtYUgY3eQSdCmHzbfP -qSgOUxOP1cxDsqEWuGVEdA/BIEnpe1LvNkXTGvjVXyidvcd2DhMQNbDTnuf7oVZPRTHaLADCXSNh -+KHEohu/Mb/f58wF0cYtUTDFUG8POzR+96Z6pQA0rn4Fap/LHO8xLjtr1xbe0gkJ018waE8HQgJz -6UIlFmb5MSoGdp25F/G9u/XKnNeuCZhKFFCEIo6VkiBO5KEoMIEphhoef8vggS8DDoyf1SrfJKWr -yx35Kw/411nqs3mbneIiRLoM0D+Kzodwu/TDPFYgirhzkiNKycNMzIrNwQhDzEyJsDpiINdXAmLG -KIM/KwNxIFm60nxXV4FnUlw22bgroeKzyIaytj6YsyMRRLxalKY+Wrqhv+9FNjFpbK2SFdtDp3XI -vlseBg+1IBi+Nbbx1ucYge1hHkd61zWas1WvWaAFXN7MNWjB6nMDY+z3y0Hh9YeLqDu6C5UQ+wIS -lqjwJz+XkIbdytTvv0W3bim0k9Y7wN4q8cBFPBum4kHZ6790j7dsCGNm53sQ7fhEjvuewpbhP7vp -YBrfYX0CNhz2OiqVUbNz1USn6BbbNA125BWI6yyWkMQgVlmJdtKtyd937S7oWZg4EnNUZoq11v1g -JqQZDUsw4yHAJajxsdiG1r6IpByWJpbOzwMV0R0jiZAlkox3IMweR7hRiljoGEvfNVeHRKKd4nL2 -9PHuelevi6TFANjm4DDe9jjCM4pid70+fXBAqfhUxqbVeUrvfV6fgxh+kaFE9R91omDA6YBbmIpC -EHOw6rtxIcd7mhcgzhwkAmJAQF6LMEhiH9SDZpkAi8L8HyUOr/NtFesP9oTMQ6RLJBInJA4o+gCw -iPzz4tunur2tkpNsE5KObfr4IQ3S40qCEcIaElLCMN7jrt9mD6mQVWtMe/IXT2s1jdFGEr4t0gdF -/tUfhKM+NmftPo2OEdmLS7bb2z4nDjnxLcejPCgMABJRR2+m97eWX362X2y3SONwoW4j3NNGRUC+ -XM9LSsIiVmK4/RlYvgrUpHXeKuOFpNnJYA8UAHGm/6mYOSdZFTgem72YIsWbxqxHG0IYBUZO7bJr -psp2tbtIZOikpj/ewjpcPCQISSqQsGAIS6FIz0vITXy/4+Wjc21/mBAn+/ScV9yFtBNhl5yqvlR9 -phv4cEIUfa93V5Ms744tC55wHyfpyNGOhIeSuAx9bL48w8rCY43OvvGFmd0xWPbe6BkYNNm5whHh -jnID1xwzuZY7Z2Il5MrQGLE7kbal7rMPIAJ3LJWZBIA6YqysopzXejjAnv4gbiI53X4jVFKDJUt2 -gRbOo+BTqAcOnSP0mXBmV/E1mAh0P2cq3dcc1h7/MeAp5GBC5gDkioDLDR43F31j/FtDqGR8hAbP -NJflaWUJf0hekowjGygS/RXJ1/si7tup0uOKu/IfGxfZxhRMa41eh8zvIrMstcBqY3KZtrk/MWxB -POHS3hSJmMLNQQouFDAPpBMah0IQRwu4o0AOTLRPSdUdPnchAQ6ll7fDP4aEPYZEmRQcJIvZy6s/ -a517IHpV18Q3KKB9FrfizG9IjodiZpYoi8HP3+KtnkKXBeJSLr49JfNdCRJlkSd8kWVnSw8G8pWF -tAbLNa/g0WMJ65xR2qErueZp4oFyNg4N/huA3Wr5LuK9vnSg7a82qeLzXPQsefGQUyN2qbHv+Knf -WAfzqNheb7N7OwdQIhZe6RD7MSwgygUPJkg0mDK7P34Sech94NPoRdfpEuWCpIxRU4iRCBbSTgyu -JBLA8RrgaPTe51ty6VmHtrPgem4vNmFVfhSkbIW/JmiEIxYLPnutPQP+Wp0pO8+Lq8ZmNw2YJHgL -VEIBFNO1wF1Kxu6qqBTngzx0oBVfZOI+iZ5+B4i7Eh7lC/6ujvZA6wdrftMluNKLTFiZqwkyDUJ0 -JkD/B1HJTnSLIscTAIUVX12clFNrnO1I1dqSm6K8trk6kB4aLJUdPzBggVK218R/IzNwGw/6cvbn -hzIdf951pvrB7MyggQ7pybFDeVAMAzP72rPm4MnXRkhUj+W7OqOt4+bKkOCRmgBAPdFJnd5cNJJW -f+KClFaK6um3MTsg054otTJg7LjsxyuLcsT71evmGVbVGFzs0zi2Wt/D6W8cwDPsTVgTuvb4hsqJ -TVy6kTuhUqaasd8vaxCipMKSc312aDToUkPuUJ9dmYF8xMyiPbNHxtoVe24nt/OfzVC4pyMoiVJj -uC2uXvG20lDM6nyf0IGUba98IAkd7LIBhqA1G+VkrzVSI6vkr/B82dco6+X3/GfELtkRSMfFchIa -g1LHn364XBbnn6G9+UP8ipdKXT8CZSBGRMupyMIZqi+1czuby2x21evzJ7XrG1ujkzg22sCsz3+f -uVq+8crYYLyXSBSzs4rA5ozidrOXkCTgcg7QiN8THFpCevfA+ZfbCstX3xsIeu8ubuFp+3SjHNtz -iA4LSkV7fmvG58dbzS/tCTI68fihkXgcwxk/Cchs2n/xkZ2GX1ToSb8yM7yazPZDaIKz7Y37J0h+ -kSbXsgmu21eVKv9+lMSi+Uh0n9sxNuF7E6cL/isXkFOg/I1rTXy6P2PP3R4uX/lIN8Bve06JDqTW -SIuL9NssBM69kD+3OfmJiXzG09C0IIuaU5BhUhAO0ijX6rLhGflwy7Qnu3z93Pf8/KJ6UQFicbUc -vHyWa4pedVLtz/itRTIHmLVZr5zkc0yEHPOXc1B5N385wcL3/VGDzpc15dXJeY9N12ulQSStywng -Z4yqMXq0jsqyjz7wr5aovPq5naF3M8T0ZzkTwbqKbF9LCFwAMrri2N9ZuufSfHGV4nGolacStz+E -aGL+TgbSYI7F8Rt3rlgn/Jh1tuWSUNvInTWQNP8yGsKrqd64ryNmN2L9GFcJt836fbxvz0MmhGOX -lizKsZqpL+muVjDt6rYMUjgoHnKWI2PRfZo2dNkkwvM2LAIudYUqZ90zpLk0Q+NdzjFCqiGA7tDN -ERhDiARr+K5IP3sgnYH/B7BehEEQ5AuOpz6qm7+er5VB66wrfiGbpbY9HqLnImsYIWXq2KIGXHkn -q8V5idX3L8g4Pj7n3wupWJHRVNO6bi7m/6oLx7hN2gRNrHDaPpVzaxYiCVuGhBnX9d0Hw4ugd7gl -eYXj8bnBz8Zfmc5DrESWsZCmYqVUOpXi1qp3IKr4RYJjeTb1mt6ANOYuQf82zOpXtN6oZ05uTISU -zZ+wCsfOgN0KkFQcmWnZKCJQNaNzVlnbWDiH84nJWvoV+3f33eGC9DyT8X+btVKb/mGN7wW5dwk7 -UxKMQ51ibeUMIX6CECIYeaqeqfTqts33a+uVO0J0dee+PI+POEyTZ9ksDDAVUfZyUDl6Nt6d3nxT -2Ltpk1S38lA4PJw/+qdHsohtvIhTnxmbt6zVlTxhTW8Ah0UB2xvw+XumYtwdgbhMPtTb0j1D8bqb -tCIuwXyeOHxrKV3ykMWk5c56wWDtuZ6NojqfzN4Wb4b4jGPB7BbhtHOLz1kk1aSc2+LLmlB/XkaT -jHFtyOgzqrvaPi7ShTn64PoTJymU62jx9yNKNpB2DyzgH+phTywwVfxQeHV6/Va1Skwryy92z3OC -hd8g1ToslQs18IpLEN5xMJ+ADLhmXyX5sbtiOrIjnq2mR6OMavIGyt4bsNIHn7nShdtd7S97bTp4 -xUf6dnd23RzYtfyjnt4efqRKhOj3yGvJdnaW5xPHNim0tX/ujA0QWP55QirQF+VA0Gprjvprv1rj -clVaogf9JfW1yVB1dd5yCOjuTfobF4/HGbjlBjbtbkgsyT8U4+VF50KlpMIH+uAJhmRKC5yAPPDY -ExS3dU256i7ta8JfdogzG3TjVMsO2NJLwnCgMUvdvkBuHR+I4JwxRO1GzL7bJ/gKLU2Vt28wGLo2 -JPRz9UA4PIczAkvxvxzx8Qf4Q0xvrl5fHpGxnTPGVvSebZTaqrgGQ3gCtCcwXg84mRNfYdmpDfMa -R2sWajqi+a1CmVcLtetJ/AUKXgdgxo4T8EZTZIAzimo1a6qunPL78fvClhle1/Fh5ChtHrBYKNa9 -GRc6iZu5kDY9cCxmseuH10p4BBaHxj+H+E2EJHVKe5peeDz24QMRUZtxlZvbWqSzxDjgob6AHha/ -+jm6IQiSXPDVKgooZ5BXVb+cXhXa0c9ic+C4av0yOA4w4SR0olqGmUec2TD6i/Ht3KT02bwpyf58 -J+pP44AUnxtxswKbRE7iiF2tSA9yMZI7aVHbODWiRXaLz8/Z7rbfZtHCr2B5HMEHS3v1Zcbe4x97 -g98/Se+N8vv8ZNCCAfbj7mig0g0uiyiCsanKys/WzdvYFaxc+daN42oqZcbehcJCQctl4PBITGVd -rLpnfR7TWGklrtA07hVwlC7aowwWiI8P7EkHTyKW/ssES3xQHsLmzL2ZjJkd77P6+lfAYolLCTjt -EYO0RxIt7b/16160ZbY4GLGgst/FWmrS87C84D/xWKL5j1bv+SmGa5zPmO8rX4xu0/Tbqax1FBZM -UWjZi/HzJMirszMQTDouRzaqKJp2q61QDEecRQbRRjshcXv19h0BN+IeNdarxZmzWkLG2eUlM7w9 -9uHbaAOdkW6exKzEioHUI9pMmrWKq1bb6t/IGfD9JPSWNhCFxT+RKPyJA7/2EO42SNIx8srGoGnz -txv7RSXFJDrFDJzseWiTeAAGDW74MztprgFAwXHyXCti0XBROUtjcF/spU2HXj7F0KZA2wGpOPBv -49ZGGJqdatXqWfuxlZvtsHYPr3k0baAvPnDBH3iRGPzfBm/2xte/TW/oP9x+h8G3+sZiwe64wrpA -WDixGI9eqssj0R7EF1O1wdXzEv2ZzLNb7Pg9DO69GhAcpv+vJJ5EVeiNOvErj3NEO9uPj/RunwqI -S7+Q3Q7L4Yu0wwdyRDdg/DPojSH8krQjEmdOhXo8F1URyUd+KN1f01GU9jcC/PIATFbAoVGEvIfh -DpnuYJM3br2L8anzzLPnOZkFGP+CBzM16x3O61WcbB3yDtu659XVGDl/p6ZlEPxvVtLGby+ueng0 -glh12XnGVcwnKtiyuE2261B5/jbOMIPZ5Tjgc7uurJ3USZk8G8G+MjX3G8No1OZRqtfBFeWGfwuR -TmCPBn6dQyLtsOBb+OkUHY6r445fuXJbfZ2dfdUNAwUq9QChXg8osB2QOAQg0cH/TWckhpCaFYvw -HPutLVUnW6I4dKRLRb1+4qPL39FgRjrHhXX35XvaBz5bn/790dhyt+z6jfAopB3CAXxu5NnpKkQE -xx2+1Rz3/8LY+ouhOoSq290dYY/GSiA8PSWwCA8HOzSYM7LNd3rQpRj1+PXQDuO9xs0L9R9D86lB -OGdAZ+1AyJBWZsmeCHjepTR7FZ20M9GpJaO57A7VxwmNot6gAxTSnbSxrSncNMC56o36PY2mclb9 -y0iDlh8/qGFg7G3vjADOlADiUEzMwTuHdS2vHzmfuzaqbMWe3i8uMAiC2MIO+ILknNmWnyXrG02x -rhmydejbvENrdFnuUj0P7ih7DBqHwLpK4ANubyRh28eQlTGoliNHM4/EaWMCJ9z2PzetQHA/7P0b -HB94SqDc3ZEOKGL4aYaNTlJtRHbeOcCR7fRI8FewJGfOPwjA+kdgwyE1ybeDgrNPGyYygkJOH95s -QA3D77sIT7AAJSUsaZl9cKqvd+4pu1n2mpaJOy2ikM/6OiNwvuByWMzjbsdQIn/JQS5076Bv+h3G -RyxUsb070BwIDp0m1mSBUBjhRhmFC+56QK9o+gkZIiW0Xe5El8rh+4JB1BTgbm3njXLDETLwSglt -PE371ggV0/+xYjlYyxc17tELg7AHHnlwk45WwzTme37w8+ShK6mUaZxAqB6F+7wzys0BQwi1Pr/T -NZqTkPWNduR1EZNfuTbv+CwDHASFsfd2QwBuc56Ad46HvR+lfXLoD2X84TmW/5hqHurBZckxjtvy -B/7GgvVzd0N5EOr839vXavZu2KJpbnNE7ekRpz/bT5xOgcMSir3EWIbQlQrUvwCK3zXFcsefp9Xv -OPGua9Eqpnhe9t3IPynAh2Dot+MRZaZorpmgK2UbhhUHXikrwQAJVSrAJhcLRvkkw9waPT5U/tnA -FWPuJzV+NcTdPf6i+xAMHIXVXrqntwItr8xzcyYVMfX2tyCEPNf0Np+GwQAer8CRGv/H8JEQgugX -22hy7dZbvdZsq/PfNV0m1Tkf0Es9+QuYnPeXi7/BcnAsakth0Wo11uPHij5teK4JgwMPH6A7Eljf -dUOjXQniU/O2CPrCrWknvgaKJ9C7yO4SjhyopoUHks7gHrxx8m3LlvCrqJGJzBqLT1b9ZtFoWhhP -Ymss+cEgs2yfbniInNwb/5FemD674UblXJQP3OUidGGTvzrBU9VyFaPZ9zsnThc2PJ61O7PC320Y -AwNdCp3AGwwgeeTNgz5OtCEVzVRNlLk5CtLvST6DQXoiMARnecItIi5+IX/Mx5r5hPXMFBMr2e4b -NH9fEdRFGwwIi0ATRyoOpfdDC52cteV5uOr06lda43cP3jCH4wD0tYCnBv7348jg5s1xurbMjL7Y -fXVPIzICVlvZm7DBgIEjJhDlA5D89MozfOUNR0XomTMtozTo48ylF2Ah+LMSUJlaejJ8CsRVpao/ -ms9u9YsWSRyQ+3y0QBYOiV/hwTvtjvZwRfoBltOEeSh145dziy/xXelMdbirI8p6jzVR/iQMHhAj -Ah9nKNaI6I3D7n0k991+boXLhw8OfelwHyc8RkAnLhIYjrwUGc+tvJ1z8LjjwInHg+fua/kpPbw/ -9BSGwAeY60C4nAxhgsK13x/q3na3EjBbKxhhrPbeHwbhi0GAF0QBu+7rrZhjdrVenztnPrzkfz69 -E24NBj7uSUgzKfe3yU2OodIv2I3Nd52VtY7BtVItnh74Iw3CnnCoWlbw77RvjXRrZbMTTbbhYZh8 -Y+F0Sa0cAqUWQGrtifROkhjgP3v47Z8PHc+/7ZW9+gsCIcwGQbg5ko/kL2ZEcy58PbBRwc30iGa/ -kL5zIXY1BLZMyCCBwH9Pd08c5aw4Yt4LrGZuORsf/q3zMqcoc2VPaOBevh3PnvzflMR+4CUHv5P8 -PnHC668zv/r5rr/cTGYxJi5C/Z+s9mh3d4KpNJLiC5rY+W9y/FGwUhKhh8yzbpdk8adv+icVaUAp -kA98yFuy6szuLduiXkSM/dk/fu2l28F/4lGePnKOKAwhHfFbf6xjZCiwarqRf/cw6vzsjQMdbv9i -AHDMndUqaI/krMo9PKa+3Pfaa1PC2pbj7AgrD6FxlBgLkrwVyJbwK8ckknWFpkaEnNC/bacZXlXf -uH77/yECOO5sz3xvJ9+yplaXsePkyi554/sWV/4bB+lbxN78Epm34/zp4dvjygn3m5l/yMRp/EcG -cGIUGkuWaKnV9V2+qCxcUcJUJzPXf4jJc7/pJggVeeJc00V2re3MAU4xiaVGDjUYztZARBHMpx0k -cL4owqFvKpEz43tWCJOY/tgXEY0UTIKl4BEIAnCSIGWcoriSD86dWtmcaaDumnKsLXfO/xgaAqAa -NIPZ2cYwwXk94IHk1W92gqHIxbs5UxAEsFBIkLKILai2kFWfWuxeNMmsv2J8W6zgRfQXeASwzoLr -pOYs23v2hW2vtMoFdWqiJdmrrnw7BA8hDbMBVcwA1C8nYdhSafzukVVfNz6d1lyRiECuWw61R3gQ -+8MpAuQXknMnZFMSi8S/CJrezlJP5WBiOgsBArErOclESpyCVAAFf9jtH2bzjedivZz5Xvjp0ic9 -GRyCUBAkPNT3rf5s0cp2q5vbx7R0Ix/tF6jYJvF2HwRIUuXAiCZTdqY8m9/Fvn2dFr/p85n9TaFj -Soo08ct9mx0TmiJkZr6uOuGwle1aysP+vP6dgbTAS/OgcGkjxkmrp9r0G8TubrIQkpEWHN77dxQ4 -NCVWWuvxRXHLzh/7VrC6bRTd5bczJJUWDBDkkjsYlqTtl45xXl7YqSY5rDCorIzUWbdw2AKycpMp -vLE4tDsxYsAHWx7E3DxJ2wRWEds3yTQIGtWHsszLOe8RwIb3Hdb9TIuQ4rph/5Re+l0fnMDPtls3 -0i0sZ/xAzWZaMPL5kpJA7Wa4vOu+Ny+3T2zpZi476+man9nybwKCYhhM3NbMHjL69v7A40n3OK3c -o9Mmp779poX3QANlV/A5jxsN8Cgrvh0WpyG310XYd0PJYcgasYQiO386s3xR/lxco6KpkJPwfFCX -a3Oh2nVaMFJFDdzJgY2ctI8Ljef1SdIXPx/cpHZ58lpcqH3q8LZ/kVC0jhx9fbm+7k79prQF1t5P -ew5VDrb63/8nHJAP4LFsSiy4sv0lxvNjr4Qs4zf5cFiGaf4LS9oBhtZeeO/uEZX1YrBtjd9jCdxZ -7gSaTxwZS0zkFe8e0DmprVv6MiPNLV4ioJlDIG2MFpZgeLVMUnyOq4x76n7FkYKkqEhPm7i7RWOv -IAsu1UoEfcMvf7XgTy58EsD56cHbL3m9JuqTra//TkE95IRw/NteXRoY/Fr69CHT2bOz/jinLZn3 -aV59Aou3B5BkpSJJEYwdLFiTqBgpYrn1xx/9VoaJLzZ/JQFAvHvOueRcw22eZp5PLfdgSik+5/di -OWjpqAqcarAo4EyG8MAv7lggevUk7Cs97sPdr4010lOCNnxWGnrnZ1B3JAZCBFS2KZcNMIP4dWdu -c8WjpAHWak2DtSpyJjEekA3JgdTrCW6TMqMsQw+PqZmF3Tj3TMokU7RgHeTdBADElQnrigL/ztqu -lljxXevvXd7QapPX/sBHuDaFnzYMQESMKYl9us2x5SKK8+Uv5Koj0xHaNyAI4pRlUhSu4PkjRVh5 -R9Ew2iWHP+YPv7WmU9ZyDBJYIVEeRI11WFsUe4RC3aIXinXlftU34uKTrJ0QhMcyv2YOz6pScb65 -1ZH7GOTQ1uW1h2JwTnAgksMqxRqv01x04Oxb4bV160ctV5/k/F1x4b42BAoGW+Q99L5r0HGOqhOv -kKPbxs+tPLJvzcXdkBcchSVc5hDmBZ+CZKmno8anK52cTRnvFlwWhfusD+jGsutAhEvtyZJt13Zx -JJU1H55HsSnEwX4aXGi6HrVvOMXxpCqYnrk2c2G3yaEkm9rlnwakQOSZyR08tTtngvZPWS9k8SJU -bqvo9j92XA4gNGkttZjEPn3PsSmDvd9159SLWpTKwVvcz3IgGEIwTbUagBZVOAdCMujQwrPVFU/X -n0i3LKhk9o5wevaH7SgNEoJiZNmUYPyPxu8QOAlHbw/yaqWTktWntE9nvXyW9sOC9WX9CV0c5/8D -J5jP0ua9vzOqx2rlAaNeNzVNeYmvYnQ0oOTXbF/mE1TQ1+fWOTPSHXdWxBY9rJNtp4U5ae/mjQXy -B4RsOLhCg6uCY29R4g6jU1zev17qRF/sZLqXdT+ABomjAzgNr67MtOjumLx9/+ltF3yDuyX3GJQy -0UAQ2icBgR/w54FbAU68XPdxZaXY3fI3Ut1r9sQ0vNwzwloAiYOIDCQRHWlHCdE9ucpxf491ulG8 -fdo1zm7/Iv/9tKD4Z5KUZckSXcHVGCqQ+M6Il0e/zrgh/3EOJMohwIjPWKTIuXuVP6p/frrpbnP+ -ZuyuLb3rHSAAcFwmSe5L+oZNtdM8E5btEuIbccdqnNkuZkeG+MEiyfcxhv6oprHE+a2xse8c1zBj -psQLJEeWI8iFQrI5BbIF1dLyZ9NrtY9bO3PKqm/Y75M0XI4i7cdLK2ay/z2mAXRZV755T5FZyfbV -jsUvTy5HgTsxUWdPoWcHv+oa/hJbHdPh9pWVTxVuJDEZ3LGExNrUBnRrH0W0fftWmpu3m21P1aFL -/gGh099hEFjw4i9bHO4b2yV5cDVjfyZaidasuy5fobbCDoLFfzNPNOHbqVasczXgMNfh50nCxPtv -OIFqmzCFft5zyQ5syZ1goWbnNbkrc0i9lW43O6a4wprf1UnCQgnzq/F/kBwgfTnxPuNj/Z7WVfG2 -U6y9k4+zwli3LoeCM8pJ67uAhtWKvn2WW+OGii5ydR2virDj3AgFuKNxSMjDhTjBn5Cy+7dJyJWg -fc/VzNf75Hpu+DsUQGVwNCS9e5z7+cChfN9Lz4/nuGWVQDZWsA+A9GdUA6roKs70rKFT8cdim+9+ -745LZV0OgBUDAieK9T42KV4pOSa3/uxZGB289cnJb9SeBpjqOB4pvaF1p5Ty2aJKLalTLk1RycUy -lTRw4OGI+JqTXXaB4yz4c7+Z1VYfqLHKe657uokx43pt2VkmBE0imImshaZG1c64Av8Tf+5YYa8f -ZH8vqg05kFKJCUkBIwIcrEoKayjNOBi17eMERCJDLh7zu5AVci/pSX0LJJsBR4nytKfS5H23qvPo -38G4zvaPnnL3w28T66KvWv2NB8AERf9aLTOcsGc9s4N/YYeOeoFkGORgTsSAbQ8UKkcAvodl3h4t -NcnoMzCRvS1hYWQg5QFkSyfCiXeErCkE63BgnfZb5HXGw+eUdzn2SjStqG4fbvsC2WRgOQDwWSmX -mdz1u83vdOYNW0WHu7FXqc78HUx6M8NTd1xT15/tZ3EdOfSlrDOobVvk5N+RJLtAilt3G0ef/uhF -EGJQPDjwrdNoZm5SlAQNEqLh8ZJGFLyV7ghXJJbgv4rwQaDcAO0RQDy97mc4y2Cm5NotfZIG9lvS -ckoUIasbPDGAHky+Ijow/sO64QtDYNHi7O/doj6Q9CARTXGQvTW+2Tv3c5tR121+zqa2mcFKw+5B -GiiKO3CFL3DL9sB6/Vl5Rdyb+prrBk0cl2igCHsH0Fy+tN5ZPEu7xNFo/Wq9luXelxiDUhmjsqc0 -4ORTT5pHis4fzUKH0C8/q+yfMS24W9NN08BQHnckiOcdIE3l4G2PJFVK8d+IECgrc0u+vuWsVSv7 -P9LOPBCq7/3jtrITSR8ttCBrhJRK1mizL2UpBoNhGI0ZSylkTSRLtpBKWhSSJcqWULayZI+yloqS -rZDf3HtnGO6M+v1+//Stz/e83nOXc895nuec8zwDvPvQk4JXHbv5Yqno4rCei2YS96fPGz865b3d -9nH72DOmAyd62tcVU+Ggc4+LcxqA52M9ttL8LMCM7XWRdr7V6jzTGfh0JRw0c83utCjMHJ5fRRfU -UyKEFflS2VsGZ8hLdJ3k3/FV5ryVYbX8pvFXRwvvVjclOsAIKKS0fDkjPz/zUu+6Tt2Hk3MhnZVh -2urZUauooMQN3KBlTdzptbrEaDrJWRetmxDvZhTQWoZIHdpIjSbFdEiFgCjE0BPvpZub2eTQyJ89 -z5J+jSXkN0vj1v+jHHHRguwhcb5a67Hp2tcBp/Vq+WmjSdjVYq6wiN8y8QUfzQoQ2KHs90WUo/qq -au8VvWETdYWER5bhKwsQjaetD4S5IsvOv3x8IFqczydCJaH/dgt1kPxotiYty+0nHwb7L2+99/aH -sbTo+g8pl6mQpO3xpE14nZ5iLU0FW7nKlKvoHpXa/5ZpYb/0F3TBq1wj2podx3Gr5SiOQVp2C6N1 -2mTsdios4MrCi8M2s1214lAxiDxe5BJlmRSTMDccrbCCAPmwe0dixC56ur/+m6Kkv3HGVnG8UinM -liNtOiS3w8HvwMZg27geTadJcsSvtOxL330uC8MNAIh1xkiSYnSESyBcvzXkjylO5LUWvKrJSn68 -qtKuN1n0nOixZCoSQKjfc1kfEe2w/+haFtVfP37fjJP+xXfG2wYwM3sBd0Uu7pnML5hEFyhaXg/g -u9p04D2PfEV9rduK4MLLoous6Es3PIxj8S/79CqDrti8N8eQCkngyOaE2Dfx4rw7M0r35yf2vtkc -nHaoFBlKBSQt/S2MURmO3UfSLeu+JZStqn6AO5zhxlsDC6YsZQFK6nXOR9Uyfp32xw/jd4jXVXr6 -3YbZoyQKA9VCWfNJueMO/XHu902SXwxzpTpci2DeOpGAUkssW3o9gNwTdV5kIChK1v/5SLH9u59/ -YmBBzCX8gnM2GJYXyn5EoZRO21RBnKYowl87EmbdL561fOOEMIoYxvM3/bl5JwzF4mV++uJXWGto -QzIW7Obq3qrVEUP2zauYx9KupKik87tXFCwHcPZYDA4HGQ1zyeKfM+pVtmcGmB6+weu4KcF6HSxO -QJYQbjG3aV7hdESm8FHvg2LVutxlDjrfH/jKLgdJOYfBMJlJYPJM/rpCh5z9d1AJ+HfMB3MOUWoP -e9Q3hOJ3j0f88BkcQ3s8ntT9raD1ChZeIgeBDx+aJJ8XBL4QjPGz/NETmbIhB9ETc/UFrDMRSfJD -VDvF7hjKrNp/N1yT7+XAs2SD/8qrYAYaMcmJlSRZJmz4cBU/mmcph9bZ8t/dkffNGi9zP8l6w4wD -ohJpZiClDBFgztJZPyp8sJKji1Vrk8HP6d4/MBOJmPQEjwYW08FesLiiFMV4/MCRlryZ8xWXeKb8 -cxIjjeRn/87bIz3I4mI7+B45mln4xHWhdOpqG14P0KeG61HWcCWeD3gjeeJq+y5ciOChOuP4vM3c -kR5NcUsJD6A7WTtK2mCQrs7gAVfwp+TLcKwlnHi/n3+mAtOvbKqitR18QA10Ih5qP2g0KiM0q/wu -7/iZ0azygGjFzM48ysyiW45562ll+ru30uQTl3BYbkvzAd7XoZQZW5QH0oa0JxFph10sSCbwSZLu -MTPjGM5RvbVxgyu3v5QilWtFgZUkoJwqQP4/t4WNPd92e2XLing/krlkl8xtz6jxR5/jFWUNMHUW -8YWEHRw8HMr8WFwAn3Zs1zGuUjubb29XpsBlQrRq0ZUTGn09LwPH2z7Omu28xyubTxlztwdjewvF -0OW7RG01hPfdvr3er1LTqdPD4ZBxJEUSNCouKh16PtXbc6vGJm5NeD8Hg1jQkkw9wKqZjQ3gxxAe -JgaNB09IEzo+lHYGnDkYv4fFx+lmWdahWX/pHzuyPfcazTIFYJ6RdHVGuLjaY8BvLE2egeX4pnth -PD8bU9b8DNupxhv9npxZOEy+eIjBPILe8i1n6sXPqDLJmmwBr9WfWpZsgcMAqRBAP1Nlh95NvYJb -3p4KCj03Jp4qoTNG6Ze1tMcAa4mAUwQcgnJDgF+f1PWNmncZ3M+jwrECJmGnLqT3sm1ZxpHWvUkZ -+cGRp6PEoOenrFgG7eO3akwyoam7SvYuwwjeEBYq/QSOxK7AQYWFzRJgF68+Z0zDjbNoE2jfos/K -8GWvemIOy1IR0B65MVCWxrEz71fD2+/rrIuTZw3wS/KZEMZ7OwzZQUDyFTCOodxxjl+/Pf+7Om24 -+ceF57SMwxUrsqTE0gzXVV4/uE/fznTW4ZJb0WN9nx1LiwdDqRbAgCQQ+BmKliuqfFZimYV3ukxf -od4XZcnwG94c/Cvh0YO3pbs5J/9kN037Dmst/IbqYBXL+4fpqCDgsRgSx5H59UyUUKdiru/x1VeE -s48a3q8xW8rh7CWtEASrirj55DEm+ZT1/WM71272jixnd98S/przIwwg9AtSe/aj/4n4P2JL2O6H -96P9zqvzUPa2Iaw94WsitS82tebNqioPf1svZ/vZ9zW6M+u7Aaw9sJkV/PJsLnB7aJt2p/+RYeT3 -csvSZezugjUGEiSBnx2ob5vzY0Rvzb46Lpm2hHhsVjgqm4cdhjhgoJG2pcEvPoad1YAp9Q+Kpkd5 -vICDsR/WGAhLoImB07OaftcOhHdflMHXbatLsuLP/HDRCQYshKDBQKTN79vuzR8qo+ZOBfHjuKWU -uE/CXwD09qAipGBX5+Fm2JY9UsW34dap0DpG99WCJzFwCOOK8gAGNWLmjS7ub06ZdN4l726f2re/ -6cmfTA6eCSrQwiZJwkAFpUWDSm49qL78381RpPT2W4bSjbZ6+zApnTAFEgtGZu5P2IqhBcPWfpbM -Z1g1Hnkzu+ExBYDwdqD2P7Uf1bLVz9HK0Uvbrv1le5id9ak5rD3hgmRlyO7r9ehdraLzF/mvjD7E -KlUbXHbUy+WAQeTpyaCJHmQn9TDz06Y1qMyyMyd2Xa6SrbgpMr2cBcOOuadUH4jGb7mIUHvV7rDx -6iGOjCXLHkCoHsjSunAOvN3n8wapHfEXRK8jxtsL97yu43wjCQPA2L6kPeFGMHZYyO4d3KPRys3F -HxbJZJfVckWO/dy9kXNUOHCnPsrWE/g8UWA5snJFv8dvtpYVWbVaih1SHQxks+oR+hu8zEFGZqj+ -dL0zMOIRn9R7r7kr6mBX3fDfJBZM/NaANVgus4B2KcnTDMr+xWxGcYdD/gYv3D1kiYHjn1Rl3q3+ -GJS0aspHFtUOo+H+/XlW/66zIJPtoDxyoAOZljEp89r7VHPl7fnLZn+TISurDH00QceVH7lyBmN3 -xkkruXhfbnzpFvo3jYVAOrhBljj3TjiUMd1c78fVfeXXQ23DsNfR06/Y/yaERYJ1ghf2haqX1z1+ -2bLr05GAejaerIl7al4bflLRgE6GQh7MQt2ju292d17Vac/c9u1z14sC1o+TL/ollvPAGONsjVxY -jiW+FgL9IoHJ4tITxfMJHRFsa2qS1mjkl89Qo6HTBmDQvEnhS/Sl8fCk/FaV4Tor9aise7CXQKLA -pJxOCCy04EVr3LTe5w0zXZv7rKb+5P3C36eMj1ElkQhXYPkBODsFbbrfONthK6DW/P5p07WDN50M -Atd5m1b+hQaw6MiTv5w3SmqNMfnUz3lhDPPM9yVRw4CHC2y3hVJ6ZB5R9wpkGFDq/LE118HXFVtG -y0AFxFgRI5R24HP9ExVrvUlSdbOs8MSnwfhYXo129eU/6YQiJsEGlhWAxXKyg7d68ZLzNnEn9/IY -Vbpx3dWRRX7p5KCC27qSDntDaInejtH2DSE987MaUkHO6TKyPQeXxCrBdTrC5InDIqwX3HpSJi6n -/V/UG3rdRxAjTW7bO04FmXYKvofDi7Ek90d3A126S91Sn7105ZSykvFiNGSBtQfrW5Cl+5ovzBY4 -M5d0TMDf7ICHVuHFPzHZETCIVCTge55DktpJJsSM2qVug1+dbkaWG8RgjeH2HQKHkEQ6AQFcm0VP -GnpAo02NZ4Y0hp3yArumuiI5b6jWnZqCKS5+pQAydnfC9et0iYRgVJG7+fMQLbwM+g8MWYxzBBhz -zsblvGc9V5WhGSOg+5GR/t4hWHPQ1wTzDJw2Ux28Gxa850iOe8E5AZZa0dmqJcWmXAizLwYBbC4l -uGALpjZhMAPppB246dQngxE38hq4ZqKi7H8c+u8JJRrMg0A80QqkAQJYe/u1MrFX0jZa1Agf2vq+ -YL0+8sxFSiw08ACEkXDci9n+xHdrrcN6G+31znYMFS2d/LFA2jrAygAHvIX8Hyl/diA/ikimSH+q -+T7oWfzly9srS41l0l2Rap/I7d4/miWmbplsypAaxh50nenRIBdFgPAYJMGdF1tzVgcpMT++WN/v -xH30iOQjVfdGbooEeJQaIKaUm1rZvDg9cve8f/9SQ9/6an3YOooEaWGKeAYSYO26zU6zZtGs/7CK -QcTJVfn4qXW3/CmxUBwF8ELBSJU76JCCFo5dU9oO7rtPPHG/ihQtDWm1d/NOriwAUB+O4dGPPj0/ -VzV172vMw/ntx5MVGihSkIO4UHLynpyd86riQ5+Z9C/pDW8pZGXCyW1YgQOQVc84HFLOq7g1cHvx -tpq95Jn/2K9ECbG2BzxG0F4gy7OCPbt2clKJV4QXUep64MJI692C9f1UaQBQbUxju1J5MMfjncQ+ -jXzm48+MzxtSBDDOtijwArd8KXeItw6Yu6ssU1p74rdxWDHnTyoEkBwBB2xJQgDdEoCLNvhfaX2A -Y97yXGu6s9yThrsjyZ4qDGQeJAwki2+f/td1Xgy22oiz4ux2b9YTmvYmxmUUaRe8EemJ/DjJbsEs -jpV9i8u+wnlIY1a1Ly+WEkN2UCOtvkPs54jQSV56bYnfCnGNz3XnjCkiaChET37GYNFsrY36sKHI -t2fnyfLgaxYspR8KRpMlVlDBEwZKW/B+kR4LK3x7bO/uO5R+TqeGZd3o/O3rjJab9f0oaoABrYWj -1gDqQXNDI6ity/FXSOPlNY9Yfk2jvSneN5KY7zJUrAX/JtSqWWgV4+Y1u66y+6UijlNrT3bU82OV -plLII8X+L3SFH6pkbJ3ZNArQFDFnN2j3MeEGbdEIyCJ0P/v8GnZr2+r4tU0ydJw9vvOlv9ypwTZI -IGkcGFAyuKnAteO0cJeFp+OJ/pRvCmqJZtSpJQfpTru/SmIoef9IY7UUx9BQ+EUH9MAYNRRl5wyE -YomxEehgHnjHF/boBzj78up4HfITPB7AcoVZV5SahqunkxUGKooaYO65iTNL9kpSYu0lxYgLA44a -TszUMNxZcNmlxJUl4fdeWUVc7dZZy4+I9zQVjtQIomdJ7IsLK9bBm1OcRIWbpH1Nv60vvJGtqVh5 -+BoVCaB5iFAkY91F7utHCg7bZaS+jZ/z15al2BxPMOuRdtAe8NUBx25P4P7skxEMuxEUnDht9cy8 -jSLkAayCg/E64gaXxXjTladCwl4/5aev58btqMJsjTogO/323zRc7TF4tA3xDAZYo8IagbezB9eT -wH5mi8U4LYaju3nWnzuUxmxRdrZVWUiuxapU9lf6/++HwAUQnNo6JdsNttoWl9o1ODIQs9se6v6T -KgDv3yvoaiKhNu0W+PDWk51+EXE1zBQHNaQH0prkQ3PW7+61OW3GYo/k0Q+vujrjHPSkghrjhiSe -NYCcMDn/FLnvI2wy3dMhiWIiu/4TtT6/AolxXpg552mzcjmEfIWFVnGrjiu8/qxzTMB8BZLMVia4 -ks5EM3m8ycnv+1nRffPj1aZNafN3e5MyKlcQWUzU3LB28mpKQkFAUJt97a6Zvaccgo8KrACCkz4U -0hBhufWaZzatmv9t6H9VPjTtqr8pTsFEcGlND08jIYs/DDJP6GenxFq++nEE7uOJWQEmeYpgvibw -140EMGfLV0e0v9jeFlzpufb9cH2IAXUBgMhqfr5qXbgVUyIP01gX4/7IH9nGwZQJFA4q5bH0kvGH -u7r2Ombx7L+fFqAzNiV6dcA/b0Ue7MCTJ46b34kZnlSZvaU48zX/caLeN6oQ8EWRFqpIncN7ywsp -1psb6KQnNxK8ud1nvGo1dagKEAuYAJyQxgPLO28uVST01c5XvJrijH6TTuV7RIEbFvFYV2I8DHs2 -NX1ou0RfpC3CEqflPDwtHStGjQTa11maHMnU+2SSbGkygQhu/TPjIlZLuT0pexDOBoUh7Yl2QbiD -T3dqZM9LDdG6I/Wr1M04OFI13W8URv6rCugTn+DdNPEwIsFm7Hx9zpXpwf7u86qUeFskWNMX7ENi -4z6X0SYGs7nnWQO2Mk8+PLeWvYUig3IGQqFQTwD86FMy2x5U2zVftJJgRW1o4LCqq4rjoQQCabtJ -aSYAji0Ja/LwzJR4qvP+szyvOHXRxic8qXB2WAzeBbxKkZ61WyzUZ6fWC1Z/O8lq6/GWKeALJcge -C9iCBIvXjpjXZqBe+X502zrD8Vulqzv59iRVnakaog6CTsqo3tGH0teVB84JFqpbZ5Ztzc2woESg -nFFkF6hvcoEZgf/8yWGV1l4DnYCbc9PJNylRYNIaZzyUCzJ41g5n+FqFySBMV8Mz7rP2N6P5fVQh -F2hCHFAJ37UpTKJWyL+w1vwDdpLv6nGKlhfo4wGTNymnS7GuTbBfvsNHjvLxMXb75/yrb1nQUwKX -rJjZRuwfKZE6p6bUc8AqeF30axapEopDFFAsc6kx9LwjvltoddI3jd7J6AsfOMVoj7acoUS6EO+r -9crPW+8ThlpL26o26gbSXhOnv0xxLFtIQwBAzjmqczH9LVvqw1SST+lcSujqEUVQgoCyzDZIKzw4 -SzvEVXRbBvZdVS5Wlk8+laYvbOPrQxFCIoB1Z9In7n+ocUt1cD7NzMm9z9s30EokDc+XUsYIzg+4 -Ug7ZsQv2D/8J89925bq0z08NmNCZTI6umWAv/CcBcDXszIzY84F4vvEw+aRhG3WuwvCobMqw7eJe -FT7bE/Rv+lRy7/6Z7p42VnBnNUM2U4YILj00hGQcpXsQwBHUny6J/x1vEOXoXcmVQBkBt42CRzah -5DMLVZAAmcx3uI4HwgWIi/W313Bailzo2bNnGyUZV/KP/IXjqcIfb0rFK+mqjioK3lc5NWN9hQoE -Jb5yQri4kgXYsFxvnjwNHeviOu768BGeuf2WlrURJR6aQdWIbtzyLIg/Gaqj6X5uEaEt05o4yhe2 -JeuZtPY/qMBn58xezwCu7mO7KxHX9Hk73t+OQk45UBRC4YB8MWgwU1Dckw4aJffK6OZXATnRbWGo -I3VrH1GCABuZaCJzXOG4lPI04ZKjRNHey3NG87897UcpIk5ADiPgDzAGl3YunOfTtSKLkV3cNZYF -fbtYY02oUgBgooP/8uWbeHLTYfn+zzT9A8WNySwUAZKNvGiPOmEIYyW08vBKQUvB6YdDTPivq9k5 -vieNECyzFP0bvAtpPB5+hh6z3RQ0tVbRqR13HF++9XANRUeFzG0smylxt8g57eLzzLpOTVUnJHTI -lOJQt/CBAfMSvj/O0fd8mdsEY02dsp/7h45P93iXQQSTE0m0L2wWN9ADgx/Zjwd7tHinp2WtSgmV -E9+01rfXJ/p+KiUdoAABKf8WKaLWSZOprT3xaz27eHyr7KfxTBftETVKLN6ZdBVkgYVHKtaPYxPf -r5WYOqY2vPORsYmK1ZqV4YX1ICMs1k558/HNfBwTaLmNdNuUfRGvV0YB7wcgMUJWbtVN6D7rCNy3 -nq8Kslk3RRlWJglmOx4pKScrv3s3IKDTWHaX690dZUeRfuxQS3WaAM58uZe+TMCVMKE5Q3u9MBjw -sUllBX/DTIRp3pNsTHEf69xV2fx5uYdEUQNgv01w8WeUFmbwqItt7SpirkAbhl1dmYVCfmRmpvDN -xmnzzXQO9WJJ8xoHon7E4PvF/0ECXK7UF2lb86LSUfz0R/qxoaPKO1nLrFdGgZ5Gfu8BnDLnOOnp -0tRdfkgYbxv9eSD/+fJ5E1BwJZMgJfR2INtc7z72DLl//4OeoSdTEojI+fYca0VKr4FcZqmAG9/2 -ilrpSkcdn/F3DYd3b+nZW+/xFwEofrFMZ5BdQBh1Q/sjEw/T+Ce6H4NJTKlJFHUW97lTuiZAit0B -F6C6/lXHjPn52dcJI7wXtp1eusZPlufXGKs+5GpqeFtR+bJ+WyZOJUVxZMlpqDN4JNaTmEwA6Upw -sEHK4uDtjC6tVcHb9LsEXjTjhst0WZOoUU4Ij2NIT1cwKwFwqJ9YXJNNuuq2dWqaC87H+BDtIR51 -Zzw9VQVguRKsH+CKdEEs5FPEMso+7k3Odp69ItAhHL365sMLDWJUJIDm2doVuagi+veyPtmsdBuf -xCoE0Z1a1pzwfS4kvQO9PgZ/RdkPyVxmhnW2eX1X6y0fpHktRVDWCwe3yBxGYFh1/GAvMB5P58af -Wp9uQqt8xXDrPVY4i3ZxlrSXBYHPj6pNGjKqL5cyTR3T0mcoYA9zCKQMEPqBE5jaCcBs2j5+p7H2 -EUKkdanJ6lrWcg7T+FDEwNZ0nMOK0iGB707Ku/wWu//Jkf7DhyhY68WzWgBiqqgdt4vzGKO5lI/l -YVW0aOz12EwYsnBWFgqVYZxBDWJ9jU5Euce4w1vEZ/kjB8f1t7IXTm1y/LsCsOy1bNl9+3A3I+8m -Cfl8+tqbCaGn02rNopX+XQiUQDWoczQnpb21Gh6KpWsIwbxM5eb6dwmoXCcoVHrgYfcMfc6jgYtD -Fk5t/QZHfYtF/i5E/F+XhW7ydSRRyfcb4+BJfGRutSy/fcLWul3/KrOsx41rhR6WfmTk/ZoxJd55 -p10Db/Ctz/8oBfLWq5sc3lhwj0yp4ytoT6iImdD+1vo7v1AIBdTwQhVboEbiRuh2bIlqwnfUD/kP -df1dwxnpjsM4IqHbCN6h/6h0c/qktpnEJeWqTz/fq13R/rsEEMNb9jxaaGT7RvsYOGodDYye7Rjm -2+R3/tffhaAoL8B7hkU4Do4NnjLgzrHuq0r6nXuuef7vPLFuG+BIEnVq9VQD5yw+sI252N4pe3Em -Zs34uZh/0IFKJC52/nWrbA6i7sq+WmOm8VvI2iGOY8xz9l9lQAEux13ys87ajxqakDmW7BObv2Oj -aP8mQLwK8m6iV3Mp7/FkJMOfiJrrYaHXTtXeDHz/Vxm8C5B9EMj6sXhDP05cYhpqeRqQWtNwh9fX -Ra7sFMe7fxcCJfZ+lhnzne0q9JKc6zR5R7dR4I7WEFwCGP/sgK2c9tCDkP+Mliozq6Hl45h2zEJK -fJuOGoYPmWS1ggh/tcZjsaQiJOgqi4YA6WSTjJ6kwEcI2tuORR8lV8LB4mfQoHFe6hgj141zxyab -4srkZR2kzPCK8M9jceCzAk7wOxPv9XPi/na8Jl2AyI0iDpkWyd36G+TgP7vAQhsxkO5I4iiOFRpO -fHuFxdVbTOyybodS4sHS1B1/oTFoGxIdedCnxFWD5XmmzREvthrF/w4KfPClTiOt7TEglhLEmpo4 -dPbpw3xt4cOy37tD1mbfXwGzARb6CP449Kw2lNzwqfrJxVq87VPRf8wyeskFpVLUYSjdO1gTa9kw -kFc3bNvnnZgbZrnacZL7smN+d40NdR3S1igQjfnk+DUkfij9aZ95ip9nfsAB/0x36igYCwIyI4Ns -Xc2AfESLx4nKNW/vm4l/p2ub19OnzoIXTtZR6JzGazYVP1BWPGWXndp+rJO14EnoCjQYFYBII24p -g93HBQruxVbeztvmklEzEnZgBXJxQosbLDGu/xzId6At0CLkkJCIeOC5/dRBPM52LzQPrhKYnCw4 -LXE6GWc7yls0MVjHXkQVA4mHjW1+xtsTtFrn0XosjkduB8dEdcIJYspB4gBE9mha+MJ0lfedtXyp -rtlR++6nn5rWN044jkLYOWNcCaMwsCoPZmuWtMK7QsWNeuxZ7mw221DucwZ5hVn63JEDyfi4f1Kg -9NhcEYwaqZ62pYW1Jx0e6tAk/SpuSfpfiYEqJySKDzLfcDjv9t8j7x1x2DvqlnRv/0llcVw+YqM9 -vuetxbTo0die6L2NIwnzSIt/kgCXv0ADQFpXaHC05Ejf7LBBQYoQdvh02dl/UiDOeaCIIpe9N7/L -6pfC//VWsuec47o6G2v7byKLM1WSkzZT9ufLwps+2lT8qjGi3xLlCzc5KWksWhG3cuoqDjucpIsM -dw0/fKRv65pCcQqfLlwChN3tS3d6pnxIeDcac2jPhT1vb+uZ3YDDwEYKwD1xQWJRGGiM1kjRsUPR -vW5lVS3ZZF5K5xW5d3ULDITGOTTGFfTiXKBu5Ctx7OO7deW+huz9NS3WSjKHZ8UCqJALsxFxAQTA -uVmyajOLDCWD4ozP0XFO1MZL8m+hjC+kLlr46RtP79XPzuZ9ta6ku27tLJXFVJgCtxtBFuls4wIk -zl84WIWwxpHqfFV4so9i/vMeNA7f8mnTIylbT3TITcoqKBukkwsGR5pOQ3MO/67VFYjCtA4bb9Cy -3xtmvvsKZXBJNXOyXOaAyu654lPCol1ltTKCDiy8O/qCRncEr6xCuoelOp3HSw5+y6xK9HojzckU -1++8aXv+HFwHjL1KIhFYIBcp4TuGFngCfYQEOUu0jiht/xl75yJeIZIrlgJKfITwbBqfPdc9vNN7 -cjzefO6B+LD/1amss3CPYoEHMyuS1x60fJ/3PvJaAdN6Z9zqeBaPJKEGbbizugQHsa6I2g7afKXr -9Gvp0/FFJ38/Fkh/vAJGGkNPTYQOBCNVG4+sy2Qt76hRlztsVEIdW1LPC+RFvqy+ps/kFJYfl1cx -dHSX5LD+02fU+YX+RnYAEVCx/TgmVluU7qXnXvjNxJ3nzl4eEbg7C1Mh2BjWCBsk8apAywF6gRPX -805vYWzHyxt6pQQ9PVH+uHaUuhpQV2xJVbmrDYmpRiqb3o0MhM51u41Z5h/lEqCOL3gKpFV1QMI7 -wdDvIiezzUhm+xquvTknk1vdB6hLQKWhAW726K9gE/Nj6yM0Tthj1DI3q9Z6wl2VBQ6YvZBQKSbU -YuFDk9hp7oww7FCxjsIJiWf368YbHP3hGqAVbo1GkHJKft+ELrIT3NrrL1c7pHYzPDjrCdyUhiDS -04dCVa4LAS1Q59NXRs79D1ZblvtJFQ1pJRrt7m+Ph+tAW7gW98CBaAc3Cqvkw/RqUOE69+BnjeQ5 -fUEJaigInP1Aw9/nci1uvV+Mh9Rusd477W7HYQBQV4mUfRQIiFiB6If6/36K7eXfmqbA+rWiQF/4 -8gND3r+iBOeFWMkYND4CpYPwl+7euHL5pKZhHENi/JH1p1eWAEJeTtClY/+oCe8LbdpG/9PTxTf6 -wO9Mv+OTK8N4ZxTk/NmfoGnp4L9lXVBWGf00yWP1m7Vwz8Nedpm/Bf3qNgclx5iZd61Z9DKhH633 -fnPyoj1GkSXms7FHuKGIRgndkyOHmLB2chmIxHWF3reevysMqaCILk5qC7V4AR7DcofVmy5D7GqP -f75JvUnkV2nefkr8EmNqmKb+pfircY1+zdHzbdHHPAuGFbZRgoidGWND7IS/Mgq7At40Cpp4ZykY -aSt05u8acKXE2WEQ7ghPMKBJjN19eH+pkc4zpT/9C0au0pw+7gwC7U2dhJZdVP1v7B75dnpevtCq -VvZrRd4TEXi4j4BQLjRrw3nB8CUdc9i+U26ponlM9JaVPIMUaahW8DKXSM3uIFspJ3/8i4D2/KBH -IXlxUrTd1OmFPflQeIbxUbfzmFsO7f66sKzHJ8XPxMfDLVUCCxyFBE6DQWdsyavSYu7r5j+vadHx -LXJr1CgIjjcTNoYPNAQF4rEQANER6NEdCHOyQu5+2zEw/yX/jTd9KSUEKJsB5f5bsCXnhJNtPhju -e2Dq860wjDPe88lcKDzgB6BA4WpgzwDxID1ozvWx+7m11NUbn39XszZXOSIoem0zVZa8UOhNwZOj -a3qk1zzAdxh16avdNeO7mksRJB0xBQdxr1u7vrfsO6E1ebVNoF3YquZ7Xz0l6IwL8H2C+WBIa3jo -O3b8EwUCW1F13AWM0QnVsru44LEBAkqq3biQaAqAeddMd3/drCL3Rj/aNcArVtPNlf8DJXjJL8rv -ux/wYt/FkAtVL4fmM+ervl4OgweTAAjy30iDP5hTjbwz2Ik4JZi23G/6GXz16M2wNRxd8rxwo2dR -BzbpmgdsepgqiBz5E23yh0c54X06Qyh8RCbwwLZnMGUX+Y+robPVnryPf3Na3ettb3f61uSmdl1K -MHg2D4sjmD8YO7yrJFlsb0gwL+voYTP+P+I8B1V2XovzXy9GcXxaUIBmPyh76+LTVJk6a33zl8+g -eBTnRZ6zYUo0GpUU+wtJBoS09a6FeQUePWWQLqj0+dYZ8eBvszlwaGH4AJIkgkdrQXj/AQexlBDV -60G3JtjoPK2PnMI1W60Akz9yPc9LunXvOKLZqrfpj5dKdV7MOQw32JeGhTeEXG34KcR7YVrdzbY4 -xIheI6SPAYYslNpaMFSIqbqIsQBiCK2DBSPShrxmcupFuz23b5uiVVbBP0iRl3jeHCm+aeiMfKy/ -2ChigxT6jf10V8Y/SIBp2yHjCZSRGNCR0DZCXs/1FEoqW3Pc8UI0pyl1GcL7Js2t0FXcH1NlzBhp -PfLCSe/pHFuAoq+MvScMX0ySCCAD/cdbdjMrVJlyzmIC7uzsXR+OQFFAPCXxLkCRNbAuBwjy4BoM -gwItRGXum2oxG7I8Yb0aCo+lLYIgs6nL1uv0ql2TBl0CbzWNbjfW6GfC3RkgXZkLwhM6lAMcGAbI -qg1RW5zo625OSc5knedifprfFTpDkYT2V0OdylBLmUdyW/qR0itGRhrJl/NmilzgDFTWg9yY23hM -PtSyHtGFKUhVeqotLmjAcSodxjkj3clCAwYMv21reyq+pPh6dtslXeKReMf9HYYsnlQEmcO7Ja98 -K3h0VX9DR9OGZ4VVRa2oDXAGPJGEBYLcxDVBaLc7qDC9+oItq6nHUdNR08jQVVabz2YJZsEUzqAx -dtDqYb6tk0GfZXdI08YXLBNtBaxqV5lgrUkOBMLFBY2CdqAt6ecC5onMwj6hLur9O/ZIKVqhc2oK -NlIVgYy3RZMI8vLoI0vWCAXgvTlrq+gyU8+HSgzBvbylCnbA/g5bPBRI+TOxVyMmhqPg3M9ttN8N -51c99M46+RceSI/kSuaUKSoECZ80YxVi12h7HdK7kwU95Aafg5dIQFduLYNhKB2UqvY9/qX59H/7 -2IZS4P1ieSgAiyQYoMC2amjBpala5M3RV0PqiCjRy+WlR95fdoPbWMslSAUOl7yIJl+xc3ICvJ57 -1tG6OyoPDuX8fpL8NyUQpNe4ohrhUfUiRDP8YKCpgH7C1Be4kUgCYXPjgEUCC+/crSeloesfTQhj -7quPJOKp084o4CTdwuyiq15rca4ul+b7vp5p3wrL6xJcD/KowsBZG2BfDRQQIbuBxE1F3md+fogK -1FIrowveonNQ9oHd31QAyxEKiBh+9zwklscl9qs01JGt2GgItdbyb/AyS/euUkOQXOe8fllb1OdQ -2tT5ygN6OKoSK36/EzeOsr/i6ec63Nd4dg2vUWHykZbh/40SkDYbvKmxA/snDN+duJitOWJ7S1j/ -Q3M5PNpGVQeUeHnndH+zOM772YW3ermXD75hTft6fQUJwpPB4lBEH6e+YcO591j1PQa08xffs/Fv -qD2FFaLKQjPeEt/K/cjnKw7Y1tqeS06PnDITT+6Zi1D7Gw8eeSauYl1iMty9pT962xn1F+seew+y -uq2yFl6ZB7E3yA4NG4G3ttqlKc0iV4JtdXdEwA2IRYy4ZmCLtPa0JtryqUUiXl1Odd345KHisbuP -8+gO16ZRVQBjI2BZGzLnu45dzy9M8K3F7ez5S/gLKYbXir/CI9sEmwd4XWRGA3gtiwMT34D0AGty -qQqu52rW7BmzqMgjX7/BVZxRS3d5dGZ3H6fdIM2aUR3qUlIpK6R25zncBQcpqEYbYRiDPsDth1+p -z8a0cFxP7LzXkhG8/ZT6ZBtFELBPoNLJ0N2atiDrhl9bcnBeebFhp8un9ix5M2NKIDTORwmz1D+e -6DJxKxY4F4jAdN08KQNvDFhOaGgTLWmNfd/4bNWpuR6R0Q3YYG6jeCEH1C0+iiDB6sY4uILjFFhb -GqQDWelefGNOmeibTxF1ntb21TpfxE+BBt+AFcoGRUxEAaDdZy5xBIe8voHCPLp5H6lrl/+i9MGK -6LJFYEHOPefPG61dlYWZie/We7D37urowyvyC4uina8keW0wwhrdJw3W0QXEe/3RTJNfkQSyFi72 -H4voRt/dp8SLpE5H7l1lYGj67ukquMdBjkMlgwBUJqmCr8hF7GKat7zYHVf6Ev1ro/+tiBKzAEBT -A474BUvLhM8NMH3lnDwpOYh/++zrqcaXFEaAJSo4K4wN1B0DrLhm5etuPzO3j+dIujBbI8R3Cb7M -QQ67IbDW9nhnRzTReLsXGer1Ta7rWOcDI+GD1+Lp5OpH7FcUAI+mQ1ZwrMQeqxNfY6Qq+YpOG5af -exz4Qhm+VEliCVdMjNEvLrE91fqle/tIrKG4ZYoyty52Os91lIJVBhMALgBMtgdo5B+YY8zDqcx9 -S8wfnxtR24BHqwStqLH485aH2u5JaV17p7ZpNoq3mP3h3KEd1B8egC4LZ9y/+vPWvo86Nj7b9mnq -T5cUKj1LwqzIk3ZhLl5CX335n+ghp1s/2HUnMXdqLnapSN39JwnI74WCFc0faXSKH7YLvHiVyRfA -qtJzTbruXzRAmIEeO1YeLLPqt8Dz8sfnuyd2ZvjBt4CRw8C2dHC1hiwmdGp7/hHNhueruF8Lv7Nz -eDd24F7T8xVFyBfYVz+tbv1qPEq7VT10tZhraajF3L5TK8MLHmPYGye03ZnR76FHuozrJ75ljlg+ -pWBTLUHBDZCu9oSpCHiR0CMwODWKt5/5z6M8+LTcHK/uCckIuAcMV4H8CqWYkXPs2xlF9u7LtXvj -kyTxQ/7LyiysA3/f1nPdtLVr00VldH2EyJjR7bOFX6lJgMOWzZIXKCGdqpPP+qR6do+Ve6D19fL2 -Z75UByEiTlwxAPEHnAeY9p85zV/zUim3hMcY/X6/SQo1nGSTA4erySedAeTE5/lz4T8U+H70Hk70 -77HSjkX/m4YrDuMCeiik56mZ1vYj4ILO9RKv7LvmMxl8xnvE4V7dMilS3rsFL+vxnAtt2CFH/jIa -NokrD1gVirWn4WEoKiIkfwMUKvSx4d4Qt5U7Ii8+0NMiUut0weAUNSHI0yN5a2QGynxbqK6whvhA -1dcJ4Zo8v8H7LJKUpmRiOG4xCyLAjvgc5nxRd6boTOsu+pfou+LrmpSpjjAwd+W6uHzOhiuaWQ/2 -/qLdzrJHoeD0pQ6qMFhXHTDVrAAbifT7zFI76BnmuduaVG+qfsTJP9W0/gyPE8MlgErtkLX0p8Rv -o3DLNMos64AMW05ltA/a+e/8YjUgQINJKIsture1dNtql7v8KiK5H+RPUzDwYRoYPOkDG7R7F8E6 -RfvUxffix86NcmdQ2s1P/y7gDGxdhIY6KDL5fV7rRZlYlaK988/dN3z0eopM4NueYCpANhccZKfc -RI01ZR7T2b7GkS+4+160vU5qIjyyChcAjvgBOKrLZTK/WWHLb30/dqWh1FmHHib6v+OLH+k5dkYX -mwprE+GjOPodn23YwjC/4cvZy3mQLN932MqtNL5QQy9RjG6/nK7zO3kKnhr5viLSugFky7bToJwi -Kp78uBfv5WO3b+2zrPVUxzciTlpkO6yX5XCg5w+vc9Su7SGKpr8Fbpn9oYaCqaSwCOAUIOhXPfiu -JijdVWIlNZ/FYacufnXg+Dg1dOnu6t0yrZwV5WLbMfc+dk0mxfoNFNP1UCPJ7/O6/9mEwXma9bql -/JG99wUlrF/xUr3PJesUxQ1zqy16Xr9h3VD8PPXlcY9UHh/40j0RxCKt3QgDHYJg9luTfpgj2/f4 -ZnZhewfuCqEtt4NaUqN691LnySq9kTZa4H8iWSX2ie2RM2+PdUi/Xvfw7rqPKwsQz1UvKNSIhozu -8+64JCVS4Hrhyfo9H5IwVJ82pOBEGOpAr9CWaExukrkzIjKMu8l+/MS9Mef8Oo+yHLqVJYDJA1rz -UOkoGTU7990pL+9o8X0EOzu6+ww1lGg8ky/HHlN5eDzP+bZJwxTzwYvPR7/KWV9vp4oT14KB5Wfo -uuOaLXA4HocT3vV9uibZtlnzoqzw9WcSveB/h9GIVwmGt8fu1TilpXEU1T/05xBVm418koTi3wjr -hY+z6ikDnTB7Zd78/J7tDwPTdjPTHYNHlSkIgTCrePJ7fOfZ4YeHy8//4PWLvL95/iU1mPBNkrl7 -R3PK+ZlV9e/xT6Czaf3XpLlp0CJWIil6Ph4GUYHCiPNrtBH7wzxskxuurrkGX2UjikDZl10QWDCo -5oZCQmHu2SedJ2v9n59703JeV7jilb9XnyF8Ryy5BFaSMERA1j+95m7/is0MwdukO3L02iYCZLoS -/oKS7y7aGz82FisvL3j7YKfSfR7Mn+LkmK1/wYEF5+UR4fkD/00mnqLfz5BvFHgwuc6W8doH+KIH -UYYspSXIsuxt7mE2cIjujXLorS1O4/b9cBse+gD/BlWPBaGQ8LkWb5d+rS71dV/rz/sp3N3CAD9H -A/6NWGINgPw75x0lUbcJvyhmFH9jHBMl9AS+6ItDE2wwaDwwZufP4U49mB33pUbMPH+kXc1gHdym -B9tjiYFt01LGB90z8yN0d0q3H37WP8y5Gx5aBQBHpCcppn+xIevB5dc0Pz4dE76dEKJ2jeX8Trhh -ADDkoePP9NNpx6qbtETUDS/c/ZLsFXhNZTNFCEiBB72i3C8NiLqTKS+mzx7ryGINx9hqNRlSRNyI -CTYXH/apS0qfLiWIz53tTdngwVf8RbvtMnxpHlxJAfoWDuVMdOlq/Gjl/F2Q64peszTs2SCdLjdc -Dt+DA3FIDxcUlvhB6Z/Lqn5or5m9xz8vfX4yo7FhIxs8lABhi3udLNPZRG+Hfjkuqa+dO2nwfV7k -VRU8kAdBrkhrLNGceMdRruZ/OajO6c0g85zEs0qxJ+kn4NSysN/yaPJj7+0FRazZeg+/7GRPxyqo -uJ0XfA0TIVa1l3RG2mGAwYMEjxmlB5XHKiuE2EZj1vo0JTV27DSnBkPLlD8u7BfgVeoJLzJW4OLn -+Hr7/hlVGEAaJMAEOsQyTACcwmHCMOnScP1k1X1tHeUX3MxT/nAfhwSTb0Uk5hYEHU1ZV7XhoN01 -4XiGMuRG/bWaMyW7qWkA65rgyQzSDhUt3HfRyGSDLOONEYbxAyzotQEdhdRg2ED/2uY31/OBlhqd -eoGngoneI/veucEnVyIMjbTkPmKgqkbBJw6XJPt8Vas3a41TpG3ED8HohRX5JeFt8zl3Z71bq2xP -H0i21hrHlbe8On5xBRTI3AwcvyT7hDZ5h35pn3v4HX3tteu7dk9WhZsX4NYnXIFs8Aq6rmjnuVbs -3X6+LNqKdHb6DrHT8PX1v2woMLGJ/6GvykjT9Whkd1wo3ugayyb4tooluwlGN8gZqTCYFVncsZAN -rx812f3p/RLXaSGOAiaqgSxuDJa0jxk4LUknJPXHOOC4+G+MIAsmU/n3nf+WFkZYquCOtCJ0NejQ -Jc6eVCcT0PnsNMWWXNCAyXT8r9YuHR9SbjiNoKoDAE/VT2i97tP0zqmIZTLcq9EufJ5RjSIAlRe1 -dwepdyVCzzkQZfvDLVpV1bUb3UMT33JQpID7QyNJBZCYUc0JqVfi9Pckc0i0T7hYr6fNHlyOATlX -yWN/hAfluvQLIQh9Glcb3yurcfzPIYHNCJWUvpa2pVmQqAqR5XtnUcr676rjd2mme1O9rYc7rl3m -eqrzLxpgFsVQIzbG0QzX/l+lKg5HO3RsP3InU2StEVgsCkj1QMwjaoXEuSOBFwbEZaGMD9+5u02T -zc2+XKR3rusuTxJzVg+nLOUKJnuIeWCA1H+jYjiySbfbYyqJdUdJRAjF9kDUBZhCwecmiXQjFQK5 -P9+0A62SyMh6PwC/W0+QdjJ8bTpFAZSzCx63cHwNiFCUFM7NDYSLiEdYsyp3CP9J5AngokISHpYt -kKsAOvYMWEBkhW1SSoe8nnbsLhrbax611nIntmC4Efa5LNNxxizuQnJGuoOJeQlKCpcD/EIvn3mI -m3vmqKZp1OfSeGf1X5QWUjZBgx9UJU7xR0wYU1sMFm266dF1O7GfngEPKcoQHieUWijX30k7N3yn -Po/efLAM/lvw9nQeigD4x8LJa5DFR0ywed/0EN2MmTiIOTR1/ghz62WKLJCtnXQs/aFU//49KbFJ -ebG9YtLuLx9ZxKe+owyRjroD3QUYm/J+4W5o5LF2meDvM5T54h3ZaSbTViZxCCuCzerkQspueE3D -9ZecMiPDMPeB9ybh5h7/5e+kfLNYJKmI+5y0xcjB4CqGjIcHNl8z2qhTaaZRQBEBfDsg0Y4T8Uh9 -t2bDMfruEAY9hRC/K+/fcwv3eFL+sJdfZFvOq1X+pULPrkXdG0t+kKK3szwggCK4mNXSGoPGO0EJ -BFppWHjfB98NSqw/Wrna73tW7xjyCSUaTL8w4R4tui4tvk7sqrPWeHHzqHD47qVtidl0iN88mCHn -xfxE/bYzgfgLPz1EjH6mcMo6py5lSKVYJDFWDmCdd/KURTtvFgaEhJmyl3pzpkVeN9ceiHPLWIq7 -oCUJIw3Cc5GTBCq6LdRYuXrWOubL8KjO9kuP7lypmDlgr1CgC1eABjqULfijHyeqPbhDmuOkT7tV -q0c5+21j4BWGI3gchvw1GF+5W5B+POWBQ1LBZ+Urlc0THK6sFCE0ygp88k3pljcfv62a42UqRPx+ -t7ZX+VLaExhgjUYisIuHTRYzmgrt/B0/aLSlmSW2g7HWqThz1w5OSQo0ijD8EUtsom4xnygSumRo -zyOZb7v57XjKvocUAOJsyrHl/cyq9bO9roPhWW0dErp2ohdewFtj0MQv20mjcvRq+PnSjZ3bPAyP -hrX6nJEyo9AcfFrgq3Ym5vJ0XbBlAJlbehiOtxxV9umTfe20zicrNpmgmSjIgOvNQPtY/7MPnZ5w -s8yyrLY8uYnTP+reU0V4e6hcPek58HFsOrHvZvhL17YHzC9Pdq/N+M70BsZAHwrhgp0Q0PydqxN/ -R09gx7B6YmKyw7XyMG7hO2/hlKczwgnYvedEqpObota3cSL7LWe2gaTD4+TnWlL3lThgGOHVEnNT -hKs8aR5ioL2xZ0tTx73TfKOrGsw2wZs7uUDVZWLbXpesqt/W4yX8df8RGS26zZFChvDWzjbEVQhS -Zq4NgfGyXWbRm3wlevakaThOHNzo30gBA0rfgO+2UKt//5ZfQeXN2ISd6/VbtfHyAvB+CjxdotO/ -rNwXq4bfXGpJh4b8x7Wa2BOcjo+unfkEwxey8oMPHhz7Fw/2Airaru3P3ws/H5CuytpUJ6wswrKx -owumYo/AOmGcwWeTX67Kdci975rDOkWxDetSaZsfvKaDtwdqK2CBrUc2eBdoDwRpqKPvYrqRxqNV -a85WK+LTjHnHXtzlS5UHrhgKe5AyE7lsQPA3/gzQ33g1KjHN2F+IRWsC3jFJOJCdE4AEZF/8njCt -/5n4TGNeM4B19Ch3cSoMIm5kWNzdChhGzr38pUmTvxv7c9NzYt6INFtmT8JANHIhkxPAbMs9m/ss -9kLD6R+hObGxe7bzGXCVwBlgg+bCc4EscOJVAxonefp8k25GsETNHD5xzULQ6OYUj/nfNKiYM3ln -FMpGq834t4oPXP/OLr+NY0/uu79IgTnQSox3V26Sjg5+Ucg30fPfKV7++moYRvbjCDeUHbRk4G4P -pORH2JBSfcsqMB7pZx++M+OfkXtdvo02oXXU/Z+UAPhc/XSQCf6a+8bX6WI880N8GmnHPlKHwax6 -X/NcuNT9EdsL9V2duDI8DrWNx1MmgIIbKPDkEuHVLdlbQJB5/+rOcG1XdUUYjeYf58MPh5TT1Xph -MsAjBxLAAvuJCXMtDohpL+Q9JE9Dx1as+KF4IOm2qejlwhbkVTav+Ht6K6kBjM+By3o3UFM27aWr -i+kzdLfUb91aC2fwaDR0YA18XIMSe1Z/EP+UoXvvAGKezVa3/NP+xxQZoPF/NNdOfkvNrXx8wTXW -itZa0GUmLwXWmKwWMdvwZrP+b+/T/gTdK9GXRb7yaVIvh7UnS4gL2F/gD/G6CU5oPODh4qsqa/tW -LSkS/MmCjxJIqkRP9iEwMd5kYbqX9nFfRnP5y75pBa/uaho4SviTlMMO40L4Ht2QBIPAHQGNyi+j -/Abc953L42znjWCrO5M+MKN2ipIEDgduDbB2JM1rxJ0qBIk+HsvO1wdn3gUhrz6bKh6VqrbZRk9J -Aggrk1fbfCMleNxXc63oj8mNmqczf4X6Fn+GW0gkjlTGlDgOQd3QjpklMvxL6g8P7vvf3u3bOGab -0gjv/4SbBwImwOEe64Wxj2AFE4ZeskdpqKMQPSq70fv7L/tV1137ZyW3xPz5JylwOHiGDh7Y2b6+ -oPnG5q6p/SKf89emwWCCG4RxI+5MIDC4rnc9JSdPyWEmmjZqpDfiY/7zMqLAnMGjsKSKlAtFHcc3 -3tuZNBUTYlYYsvNnNluC6I4QdaqsNcLaHqSe/tmH32PiVnrDfG3V1jIjrateT85TpxatHUaOqh0G -3ib29w7OT9ee/aXjpP3xJVWOUq2L3p0Sf4IV18b/orv2UmOHdpDJ4VcxFAQAzwR0mkFzyWLC948H -ff+XutGXU8eyZGO8R2/CGFcEwamEUqiCtsyCU+N3x6vjjqn7h4K3M8WG0u0pyqIPsCvQpCpFwH8B -bVb65IHHpvuqnue4WhxP241tkrBdtQIO/kGspbClJEPNITGnPv2WnOyV/J/FVaIlX/+GOkMZtheK -cvMY73Lo10xM5GC8G8h7JsNt3dzOtX/TIH0fpLpvueLee2hN475aCORtzfIXwne95hpfQQP823KN -hp0Wks0mSV7C+gdfZl5EYxJfZJVR1wB9QuVNkqoeUfd6TW35XmWzfcSXCBvDCSQO8HxdoNKmtNO/ -cJMaVaPqI/nsfeUhaKP8K3ACTBRMmLddgdAhyaJuXSu4i5OVcct0c/yMzQ3Nz5EqCDUqKNB8glXj -vLC1yxHlbwzHMuX8D6+vfjYIb44jTMySLnhX+4WJwKDwxlT5LltBmiQJnyOXKypmHNaxwTlPZxzC -g2iJgpvYiPN7xD2E1uYvUQdxxgmx1TvC7fyfGGxbmQZHWXBiKNnx9tBz911othtKtT+3ew+E7siF -oeReOVnZVqE7XZjBV5mOo18bHFnZW4+GbD9usDIL/AWPg7Y/QYleVcIqViVHyGx2uskb4/ThWq5K -xPj9v2iQvETRKV2RoofR7B/jj9nsUEl84dIkBR9Nl6LQrEL6N3gT6+JlBcTEJUTy9td/eyZGg2Ud -epi1sgqwhRC89vdPehjXO35Myq/hF+A6wB1mh7ukvzJK7FzA/wEqHHhIN7bK6vl+ydeWcd/Yj/Bo -seQc/psCUGLGhazC66jwDfV81OXKw6onPyqnvXQxOdPH+xcNKEkpAPfEmxY6aDeNFilVb88RtOv4 -wJ/a/jfYFWWDRBL6gDVkoBsa75TaLGoYJ2mNDLp5dhdfxXDVXyRA/2fJUOq8czrXjj2H9fpYoIVI -YVGSKd8luKlL0ADanuGsvpEhyX/ktIJSg9qvXXmfSmbs4W3BxJygaUb4mYXgEMDv1zhRH1f688X6 -U07CpuGbffw47srCeAqZa6HpEYqeLhSb4pe453CDMRGt+2G75waOd6NGAUyx/yIGDC/kBd/9depR -1x6knTTVYRX2HJjV3z0lZPIvOoDpbINAYyDD+7nBr0rO5FS6R+Mh2RG/xBsYBq83/YMKgNJKeJt8 -eXUv1+OiR5L5vrjkV6Fl8J6IdyZ0PWhphbQEucTcqJURjdr58s1Txg+B30dUbh7lb3CBmwx4V/JS -c6vr7uhoYW7VffXYzeG9NSfJ4o3Kl6XIMgPjnFX6CZsQqdcPGi6gK9qKFHp361pSAqAyLsTwGSnK -D/ZXwdHL+I4k7f+UXcO1VbYym3O/16AoAJXsPXNoMLgZf2Ok/fGJw0q0cecsGpVyKTUHIxeSpHLP -rj9UGn4Nh59wR3R7F/uiR5nDdXsoUs4YwNwmzus7LRmEAtQYPieMHe3tYYsuK2Fg302RIr058AN0 -aXkqe9RBzEjOI6lla9HYAXXuD1jKFGHuh4KRbuBOCCxo44LGZcOU8gVFjuILfHqtKndsHV+i722y -W1HDdeFWeWceoacynTVfb/3O5mH667KHTGb0X1BXIDEZMIwCRgDB7QOuZdFzdkUTB/gNe+Y2Gj5v -q2Q/IH3U5m3rlE9Aw35KyiTLCszeDZQ2XqxrdH2gdI3hEGu3ls3m/eavLlbYVe/LWkkCOEdOrOek -2Sv2WUH9QnCFnxnjrh6v5IinohWUUOAIBtC+sr6iRVdZ/FADh+CDGFv0E1tj88eU2gNlZxdqlKZX -6bk9P0E/+VN6y37LqOL7G/naUyhBYCVp4OgTygOM3Xul/9j3hesoP67IcG+6wtmI205RFDE8+JEZ -in7H4K+zsqiUDoh1T3A3OjqZYCg1JwuhnMhcx/SdRW7W/1mMXNaJ8m/n22y3UEKIhWDJHiDOHhQY -/Sz6tpxpXEflq5Rgn7RlR3XyO7WVBAheritES5JXo13bcF7zMl6R9lTEmODnG5E2jecL7qwgAw5l -vsEsu3VjL1ru0t7vo8Yww0l7RoES4urpROhv4PCbeEftU8vx1ALpDGPxfIn7hwXZUzwpIXhnFClL -sPzOysNnr52LEmxtm4jeeiagnP/IsrgUtEOeMN4RO1Qzpj8j/2EZ6vcf9+0d+lKJm+d6lqTwwuKd -nZHEECOSMNwB/wEsYeHqiAILK551vDWcWNSjy4y8cxpzMXswjc20kJIAGgVmDCQQNE8bjyGeZk53 -3TW1vGSplI5L6zhLiVgomddZov896SSX3k2mPU7pt9QZGM7vMqMAEA0piCONQ84KfgqZH8e/2Kvc -8wxHNyV2V9ZQujxoCiHaoVZ4YGMJ1OX6aPJXqe281CUyTc9c8b4t3XjLhtm/8ACGCHi9efyAsCt7 -TIHnqMKxQlq3P2soYMBwA/4bjVmsTMGqxheCU/SoubfBiWZ1Pm9EtOS57ZRZ0DVezOzOGTcV0/6j -qkl8qOrm5O1VEfiTkvUUQKDgCfhvMk+X//Sv9b9mHmJLDgWJlJzIlxaZZ/WjgDoBSXLAIovgcUOw -B63OCF7/mK45z2TSdOhStpgPq+mv239BXQnTJnBCHHxUv2kjt84G/9n6fi2doJaIy3+NeRruK/MA -9chaTuc8ncw1hSR37zccsi7VVrffU6GIT8d0Y6tSEXO2Vs12iVeNQSj0nxpncQoEFNhaVlYoiVZU -SH7t2DqDMVOXrgNb0PzV+zdRYLEYDGkTLJhAA4gG2JDqzAM6W4+86Lwl/+apYX8x0+pqt+6gLzvX -U9AhfqRA+YiFMYw0outekVTbun4KhxvMG0gyXz1x5CbjGUoSeCvwn9DVkJKxjwWnjwgq9t7i4nvr -bza2e7vcWflrFGAcAqgK4gEs6TkRLAEEeqGXgbvBJKp8vx08dWz0xzHOAaGOp6kJwsepiaCc7Qki -YCgVZOkCHsXmeXzZdpHvzTdXR/HOxoTAP9TYZZu6tOmOaMbsoFmLNBQrrczMLsfF02+khAJ/B74r -0mx2LrBNL/XtSUHMLllB+wvmCvKX936nyhFsc1IMoPqJ6dkoowebZzaLZvbNXq81HUD7UOIwNhhw -MAQVIAcqfeDE9lz9s2vEM74FcNxnOYESbKJEehLGDHvkQgf9bId4nGJY5Dwc2KRZRSeVILC6h44C -BsQvgQru4PIVv8gPEfv+ak7aQz07/f3i6IwGl1SjdEXYgjX8SCVeaItstme/CjZv6rurxGk3/WF1 -4NElWxuBQBTKmeATkde1hTKxAHhCqanv3uZDfl90RT+znf20RnM97chyfLGipBWeYFIQl+W6WI5d -jWUXdeF9dLb99rGgtgS6J0uCQ672CBuCbwSUtHECyp9DGSTAiJR7CT2PU9DXZ+5mzPe8rqAC7xuU -rkCCRk/3UZl74Q9m2Vvc5m9sz5cUjD+bTxVZ/KXnbBIMkzfEP0xd2X3ApFjqSu9wwDqqGKlK7SL+ -pTFx09HLPjXG5UHl4pwXK9/u6ApZCXdBANM9GFiG9oQSNAQtv68fiXjyw0Xx+duf/o/7Lohy0VPT -AKeKLcJGe2bM+Sa8fnI+8cHj/7vpsiT9LDF8hHKGEvoTphkMOGlLf4n7+vQWsumS4le/kOjZAf4a -BfplHLB2QSqbJ5Li/rWsqv30yR8dKmVneXuzt048otCcWHJCklh7h6x63qagI2ewgw43uL9q33ou -yLquXzChkroAGLLV2mJ9K7hT1QGhUqL3+3jFMaZt7hQIYPODHRA/BCEJrV2iqo7PBNVKcRP+e6Ni -FDwilsTViYWnyWpJ185XSLMW81XrPh5hNvqtL3DS5fpOCgTpFBdxMAZImRKmNZXGkZ7aJ1Ejenk+ -iFuRVWIUSGjXIzQKE17CooXAsT8+/SEeG2v883mMFnp9b8PHvR5/58EIl17ThA5SwFV8/oXc3Cqc -1GrzzmxqJKmUL2jPgB4yuKN4sbLgvM7r1MC6aw/1eURnyhWeaDvcMmKDi5E9sdDfnFf8LzwZO2Qo -cP05r6PP5/JzW5YCpLlrYerCY0GD/749A6sOv6Jno+LqAVGTiAuFXJ1Lzo2BZeYkrZ1swDCsDXjG -CeBKyuuPKvzZpfbS6GP+AbYLGUU3LZe+ozNo8BnZ2RH6ArBlg7S2DW2V5h7JPoZBZZ3XkZW3lLII -s/52fZwSjcfZg3VHxcfs/b2aXMaz5varocRoErxNW7dRaA/ESPDQMRGf1fyDlpuxtENpxhMqw9wz -dv0sSRSIxRrCKhuTNv0erveeuvQlt2Lrnpwvc4dVKAGQPUu6G/DpO1rEandfOqhI35v8TZDJDNmp -oxBBAQVLkQPzCwgJZ667694od0ndpDY7zMD/jmfTBkYqkBUCSO0CZH4ncA/3HbBt0Uiw5zDT6hbc -qFqZwXV8MyVuITvvQnJeYDiMRvzc8w57Yf2HaKlZuXxtPWXF8xRgYsJowLGmD/tueGgj70atVton -qII3J97d+UQBIPYNYN83EC0F0c5wjcG8elPPhwqD9G0DA5KK2q1ICijBL0ABNQLBXnUim23PbJO/ -kyArCmN5QzVOwvUAmiKzENOsv33ce/DdhpSdfKZbMhtFRy/t4N5PiQCOEQNmE3Qml2znV0r5TKua -ZreGGre5+tymG47dj2kG/ioAgA/O7nPNsD3CX083/5R1xD3nbrrzAwogsAsLDaYMhWofsVmL9O0b -m4y/eVRqrK+w0zIy9/osJWxxYfKBUsegG+PMdvqehKuhHn1jXwpe3qZEAPvvEYu9UjfHQ/RhCvf4 -sWe0vIgtp+NO6p49RwkjdEgbYvCLMNJDvRQ8cgOEtFof+95uPc2ptE+QZcq/cW3YXMwbuAYYFsoc -OMTdWFjSMrLL8YUUTq/hrYPckpbgSoa1PQoNhvTBJ/gs71Ziq+BrfFhM/4Y8g6KBtev9C+AMuN0C -sB0XS17ulX7IfXRziKP+r53MeMtqWZrDJndWAAHklbTAuImPMlu/bXPOscz8151fNqbDEcKXApXj -8t41l2/ag+A/7csnF6+Xkc5ctRne2gWBBw/nA+fDFrqFUoZcwpPjXe+3Gguw20jZbJ6ervixMgpQ -hyKNmZO3vJFcJ/pKKudxFoMZk+lbChRh8CWmpCAwFkel1rx672Tu2boV/Z+Llb+Ft0EbFWbxhz7T -MMve9votcLrpaVy5Mme8jdtqUThEvCfwKgFqpHSzAsc29Qe3XyHT6a8ctWhunbGAU67WWJQLjviS -MQsBYyPhFoySCCPSPfs0n5FQmJxI7oEXK8PgyMP2tTZLlCemX//iDvxVkasfJtSYllPEKqZge0WJ -pyGaGFH9l24Gpj8vnWDUGKZ9DW8PPg2ENSl25Tj5mLGSIzIIp1aTLuhbx3r86KsaKhDhrwQzAYBe -8wS5WL0UGv/EUXxBdBvvbKRDVB4cAlYSFraa5wrZSWZ7mabge7d6KdNxcWK1VWKXIcBKpzVhoMYA -By5Jh/cXvxewiiVx7vVqLmCjCZFSWiuTanPT6h3yqgTCgIIa0BzcpUN2IaLrPN+gmpp9inpnL+Sh -rFIFg+6XUkChmwVMWtLGoBMl87ewmRrvhyMOdSrKPXXTf7X6InVwYWuAj1LVKvmnw7y3VPpR3xhH -vsdm7X1AASNYQKQP1W2T8PSWLq1KPLN0h71LzdNYrITEUgIq7WJjs/TcDmBAu6894zYf4y16d+/r -3ecOJkgnmoZRQqGolySaYJhYg09FIuj7I87U1JipSxwVX17697ixaKZQAvE4DPnDFNugd7X72Yle -5In+/4ZUubQ+fy0wpoSBziGY8Z64TQWwWcEBwx6LccbgXdFApg1wVzrGefHZcbFrPLuxvTZaDy2y -cdaYVT4ILUHpqpYfjaB//kL2ldf3PuxI9jvfYDfxHxecOClirkiyzcLQNwGckEA6A8ddEVYoNAra -YImTVw2R9qhkktq+8Z3sZ3d7XvmlybsWEsbYgUFxyITtSA0svfuEO/jOs9gtGbU+M83Hqu5Tg/BQ -ED9++ypPmRnal4xCLfz6rxIZX9hFy1BArIGcBZJL67/5qnrtxnvde5o/JXfhCO7SBwX+/lWUUIwT -eEoLSOpFWuTRGc1imLg5sDm+9dhIUVaYQ1HkIKW7I6Lgp5DXh4zST9f4H87OOxDq/3/gJDOjUHZF -9spIkeyEkIyiCIfDhTvuzkyRrAYJmUUlq6GkRINEVFZ29k4TLZT1u/f7huPep8/398fnE/V+PO99 -7/drPNfr+Qwvc/j1PcjCKDuOuRWSAPoH+TqDj0PN7DddNVyb/VT73Uan4PZ3Ro9QIVQYX6I3Lf/T -66t1r3vbiuaSx+/cKi4IKJMUh2BcwNMVaELeODFOamK9/ZuHqy1859HvnahPwtGNM35OkDChQgeQ -6IIvRwHQeRcXw9i+lXa+pLPf2K0cu9D80jOTOg0ayZedQ3gY7zXq3I/OCeg1/yb8Ve03FAH0xsEC -lU2BMcLcrDtZFV/UJxOi+4qd2cfh+w0pKMbX2xMeQP5hdhm8Ycx2aSWZmR6Lu9wluC78xj6gDhLO -Hsn6M3AjS8Lq6VktztqzWB3XTVt3nTpEPB41KJa60BTMvenLwX7mD06eyhr2khuoU6RkhVse2ziP -Xr0q94HmPHbkS/aVuiNPjKhjpNNShFtVFzIVbmBRi6/8+Ger87u4al+2pnX/gQZWDmKA1XJ7Bu8U -/2GF8qyFb7sXQ6pq0p4jqIsgkmCPQYw7fkf9EFgjdQx2oAjFHz5Yb7GnEyXeyk5VBAD0uUmxnPKr -F+xnh4nsyJn74l1Y+5Aq4A3DRzI1BRT29j7eY546oyDEeahqD63svBwEBCRwo1wJv4GPODTrKr3M -zEPt0ZnNrGaH2fjE3OnNqICgHoPv09shmZRqnoaFf86SGsv/woXa7oeBgnB7GCntlFTVnTSjCYpN -WNrPxTFxB4OHFRpi5469Pz88xAS13xC7ieG9ST4/3Btv+l2/kB5zylvFsD1pZ5KDCxQETkjArgK/ -7KfPD2mijfQLLDbTlOpztF+o2e+ZSI3CgI4swlAKXei/WDDqbVu4u6fvQbrozZGTU+oQID5uAXqv -vCsvvb5YSKcxwSeVxMWaX5TKBLW6EQcKIRUXCJUA6UooNCGEVfx+Ci1DXzm+uCdSwm3N+oHPW2J3 -ryYGaKmhA4iyIEbDiK7isD4pg5fpl1ozq7Xavc9vL9ngKfB9NUnE5kdE/liqdLH1zVv82RzN5wyF -7cQHxWCfVuHByIJr7Wj6hp+Xs7C+bl+sFXNhzm7boRCcXWcKA3137Ic2ZAb5nczvOiOxUzGL87qS -U3E5FIFC6wM9rgAnV7347n4T76zuvVMl108fO3TmQVcWBEHuq8dR8PPNZcoXA0RrFZJ+uEoECsgU -JqdDUZilIZ8dKPlnx6XEd6+Dvd5/ldjk8+38m29QCHgQGY2CuTjDcH+7UqtoGnGtvLO30UD3NZeZ -lHRRIsvnPKhhSyEFqCGBw2/LnlY48PJOiqOd4Lh3vJ6jVM53pn/j+JQR/IAKyl3vdJvvRJXR1TF5 -Gi5h48YKt73/lkBcxtfQiW0XF0kL2Xs21aL64rOMabnELmo0aROWcwrE4qffiP2nS21R89HqJ0L4 -LweMIjjkXx38N477H/7eH/tnjW91uHv9Z+1mzZjJAdoa9tSJf+NY/NAq1Ur4IiojG3hWg79mS3no -F3MPdqi9eCVMiCFumsvR0b2p68LxbNPxJMOctVfp8jqp0mgUoYM9+MyOI+N54i2/On+1Ou899WrP -oE+7bDA1lPz40oUI1cWCePdkxQKHzv1/Lnh/XWCZosqRNo8zr4+dGGDaZJ42qXmb4YzVLr2PI3XU -KNCyhxEt7tDQx9n1kW93hsY652aMmXH3as7tXJUkH1ZffMuqwpwY6JokjG+WBe3YdvtrJZSetAQT -P7Ulu9Ft8/r36+8Hjadde+UuHCkHD10VJO2xYIISea6+2wdMJQq1vfmL425vOhXXDNUXExupiQJ3 -BG9CZKKB71REuNfCYIDKDtVu9aj9rz6Mb6MG4otTgceJQDcFc1V/qxzNT+TT0XOJ48ec9rt6//oH -umRobdQczGOH+THPzetL3//YlCV+YzjyHzBo1YDhLp+cS72uEo9tdjjm56Vs+y4OPzrSvDoMxoFQ -+a0pusr6HDb0v2gewrPXse0toEoByXyk4dEtlqUWHrrhAttpKfrLm/0P1CscyFmVJIJVQR5a8cps -d76KG245fLpNZ/ZIkjl1EONOsWbmSIuOezjtkbDB+nNmaBSHdnTZD/xDAGG5fI7Y+8lIzHdLu8vk -01jpEBZRkRqxVcml4w+TwbXW9q+8F/VUCkbE8xd+chQM8FJDSZojeDoap5mTT+PI13XcXFH1XKne -nqEtrY5Hzp7/WvpfBYE2Gc0jHfeyqKmDrH2bKx9Fj8wzpfdQ48HCv0uv7JQgQ7HSRT73gZ9ZPZuZ -JcW3jm3ZujpKPqUNI5Gwvtvp3Q9VStfpeQujhENFFVenibvETpmF6Yv88tmH8sbk/AWk6c0HhKg+ -OzxJvOOUu9gFM0E03L1uh4EA4v36OhaDTauSLqDHdSlDOmhxq+206353ngM2isjo+PPS8WwW1ATg -phPxgQPoe0nvnWNjC3XFHbVCpenzU4E9AVTXaXwVLhQab9DCwC2iiJdDp/Pi9Qd1N2nOKHnvsV0X -1kB1/STnl554E6Prk17Talm0WqjUjsf+H6QNvYL+LYFQlQvHO2VVBNxxsJHNU65V+LzVNeJq4evN -/+ZRvlhvvIc8K3gy5k2b1vbXw9vnAnTnErb0MB/4N49G+SJdsGh8xlS/s6GGZ4SKqdXjzF/hokpJ -jhstc/8tgvj627EvPd+uZ/Hw29hu0/HueqIB6+M4avTyJBa++kFE+6+kTQI6WcIGJma+tnfZvKmR -S1YaYbya9+yz1W8ytBgTf9jnLBatKj/hTXVzJ8FkU3SsZPdLSZ0GXVtz6V1T0U5rsi4zQJlQpHol -7nBPb7xygcEq7VQiJFeAJVOezb+C983CeOM9zsW99Xo13XrVEUKSF16lERa3UVSN+C7iPaJzZNo9 -0z7l/neoq5c8Gsvzsl1KHf/IGF22n5AT0qi7wSu+NjsoHApHgtUeCCsT0Xn68dcnXbmHtKFhIZ84 -GKSUdktpsQ9CwEBoFkgN93Vzx7vuQCeH8QyWcZfy2Y9jEhkTHl9qxsqj70OxoJMZjA4TrLC1xyQG -IiyxzNOpmbDtyQMl9g3HoMxOPEjmLvSCIX3xxxUJ7vv8o/b0BfkTikXxvbt+sJTx3ED/kfkvgvCb -BHjYk+RfZEp22+SZ+oiVt1tUp+WbEyw3MxhKJ14pC0CvDIzARbX6Dk/E+sfukGbeG5V0GvIhAihw -dh/p670UTNjTVbrPsBVuYsxSHdj7Up5bgX3r23/AAFb/sI2uXVfa+VrZl0k3jSC/K9ZMUHsiiLkA -5RpQ+IT5ct+9Nv5PJm7offl+cYbnQ09yze3X1DjKAzONu3emvks+5tZxyXb6VQui18BJzmd12heJ -z5gAX7xuRYP/gmEASozDoIBFwa/VokuWhSpOPGzW4S83dd3J+LMSOtC34goqLfaiDpSxD0Jgvzr8 -WPNFEsf42vOnskcVnVMu64ZZ14h7bFmTqiGxmgDQwxAxOVPQGfaqwl0l+HTOdsm2vO1C1BiKYckk -ntbYcn9jhY9dG4aneqr41IxkGFWY6FcBfgOX/7OsEsZXM80Pa9ZKYhYGr4vT6sc/pUYj4XCXvcRh -GHJPXyfIYb+4nrGm8O6/pw7eXhtoRQ0kW0xw+yeSVGiD6DD1mf2uIxp+bizyL8fusfVihb4RP/dT -kwVmpQP+SAQSf4wa64/Aa+SLPs6Xoz8bTWgzw3VOGXB+brqO7aYmBf++yF1a2CoVtQSV5i0Zlo1t -tE9u8EomtzlTo4mn44hHl/Vwuxk4el4+3oMtzC0yzlIcu5fzZscXjoXybCpCIKobARIYbnzzzPOf -Uco9le8FK+dDV7HFQu1mS/ElkhHH9lwil8f0zWjxqw9ldQUyXSqKHtOrke5YrLcSAFbatSc933yI -7vRB7lz7hM/CcnqnoUwgErjswLY+6nsTp+7BJAGBGI69w9ZSDmpP/64Gk5//56xZs5juo7d1yAwd -elCqcaIuGsqtQULBkltghwoghEPmkjZktw1B2/w47s8pW5arWCVYfgE1u5og4tkagD13vepESEth -oEicGve7kLn1YQwTL1ZjwTRW/CkSDJZY4OXY98WM/kt0k8KmfPzx5puyfET6tFcRAiDRFj/2+9Jz -/JpM3Wr2MEFFZ1TvziEohHRiG4BaZbe3a/7ejlToj6n19dyc2fXxApQbndSgFIckG9bOIDfyNJzX -Uvf6PFI1jTqYfQoKAfYoUghiUrzW9ty6jXG/1JGfnMQckvY7z/BTg/BPAfwsh69j+zfY/byXPpF8 -Q/QyHXPnnBVUEImkFoAxRPxazZg0GCcYPKJHm/gkX/7d9zlrHhSUibmEurjgy3jhJgBYaR6skIsT -5LlTJTnOWfOZcon/uuiT/neuvgiAsjiXBFHWFws9XWR+6bo2b3vRXpGI97Kx8RaGUD4Ukgiy8FSR -wLEofsdpI+WNtgzFWKNTXBsjHVZHCV5t4LAnUKwXjltYXMC7EMhcm1R66astMqXh6DGb7mg6kfGv -q4kiPgCJoN7eDyrhpqmXhav6ttax/TTshop2LXEEly0c6YwiBpwvm23Se3LXxPxhr4CvNDtv2+fr -XHyryyDNxdmTOUrT961N4KLb9X9HMLxK3M3uuSqKcLGA408M7/t4x0Mq8t5BH9fcT0o6Dwfa70Zy -rY5iiM99w4UzhbNieimjRq213cMBbTaTqqKroWB5NtJvYJcCwjWgUVdiPDsmhGyx3nbubFn174M5 -2/82/UsabhxbkNmFi/eEbBOVdwwF8u35y5zF/F7ia9GXVUUA2T/4p4ifEMaO5fu4/Vkelr3p39tm -xM94MGv9qg+DdNbxIvLbvv0HJNw2TYTv+lnsecNmt7zrqiCoOBF05Yeojp+yHp0pTOXiTtxDPEk1 -W3v3rAoT1aYep0ejrkVX6haHND7ySVjZhWsMVqwGgqoTKe4OSHhSrRtyP3lUc+iUZbNgxyWz7g+z -UKGGJQnEWoyEUiBEo87920kEQvtsexzc48BWuXMn+E5pM64mx93fS05hyf0R6WFhmNCmoLf1xYOS -iJ33r8SY74cyM1bgSBT+GxEn4fM/V7nrsMyxr1ikk2dt+D6qaMZD6b3LpQCgbWFAWHcy9x+x6U3x -Z1819bS/TVh15pESmdGESXRVrXDOs9t945XynRz5vUbvDet3eqwuAJ+SCi6mgACOOr8CzN9h3k4B -v58pTgc12dhGoFxPJAGAUkg+8rXEuwMFTxR5mFye7Tr/c/8Pu1HlxdX5ACzw/Ihn7H1ThyPfeiOZ -x36MjgTmP5k9UP8cKgdliQfSfYCbAE9sL93HVmYZ604bn00sp19umB9ObEarHrVZTQ6h9Bu+DRW4 -s5HGhHr3SIt5sKGe6i/vB7N//SPylNfOrCYKn2AGJPQtaemWIhmVyhl2BcZC98/s6hUrDjDkqFlN -xtJ94fWF079NNgQMF7k+NRBm9TzAJrQYe3XVTYn0A1iidOk+nLsrGcbUfhTc26j9tZg/IyNuMsT/ -v8gBWCR/SJG8QqhXDtOXy4m1mTJ0D65A+euXscDeTPjTFIV3zdqrvfaqzXbrvsRPZ/xC9tXd1/et -rVcXAybEEaqfaq170qx3/waPDqeum+zR43GMH05DxSpW0JaEA1bgHLllsUmq+Mi9b0YNV4Mf2Eo9 -tC6sgAoYLu0PcKw+YXfEF+cAfsC7DzH4OIb4ujtz+rMwC4Oyz2kzn2Y/ia461MjlEYd9qa3400Br -Sc0d/JVvlWhFR0d8H676XnC/w7Bwt0CyXL9ik3vtZyPuPLWZjUxmUlM5a14mR7uaCCAygFs/nQJR -4In9WIf1E+MCQ1vLGwO3raXf6Oj83eDef8DJll+SqPNbYnh5XmTbfQv82XDod8+GH0cWoVwuq4gC -VfONf7Ucunm90K/Oz3y+vCf8+Mgehn9LAdeQnehHzBWY8YZR7XDWUkxf5GfImN9KEnCmXfzzY3bT -N0FE6OQ316kj32mnTg5AJX6RUIIhuTTBHnKgjevmzrgzpk1nxp1+47vD9PqZ1QVg3BGu4CZaV3fG -rCLxBPbD9UChH6O8N+5ybmJeDQVtEV8kAijYAKRH41ZAB+I+EPFxd1ax0DWmhuN3nWK5D3VghWVW -04NNQJsO34GccIzRXsHn70/v0Z4J5jvVrYGsKl/D+1sgJbj44u3v1DWZqDPr2zY+prs8WPEhRk80 -mgVKYwX0XKLSSZjTGgFxJ7C/s1/LxFUGBoa8CVG+dwnKrsGgwAPpQDlBPzihTSADz3qZKp/htHIs -YiBipzztmLMwVDgMi9IBfP7Ah+nFCqMPaDuqhIvVJi0eeH9313OrOUjCGjckYZ64bR1D7KpA6j6O -EzMfxN2WZMVTv+0PzU1lxoGAiz2vBKHELDntiaksJIdFuWx9/YhtRu5Dx9tqRv6i8lMRylBhdXK/ -P1Vz4QYLP2PjwsegV1c0nL8zHtPidY6zXVUWmc4+osO+4yWqqrR009H6Uxh5q0ALaygbfol1BQu5 -EbdHu9eMdON+FYM5c8+KhuwSDnN2tK7+NVyJldswCaLRRhufCO+bM4sdDVUXZ4lCs61OegIbM1HL -Uo3mqH0v3p2273nsw+ZHydJz0U6rf2fccAO1rNizPj+23ERLdP98rQtr8uIc6I6D8hSRhTuWHFiu -ME8MHGyX6wu+xIBvo0008I08oxluKv3nTpZGWx2D8t2RxS28PRFA6TY3d38YsOLB0KDeJcV68nLw -y46GhXD22iavt5cf6pUk/Ac5yx1p33dwxjXPwSS6tz+pi6mS935cevAnlBDg3AGMOCEOdUpnbe6y -WuiYcDoYyvVuZ7XoIAwC8kUgsaokyGH+6TOrh0MphSe1AuBY7+TxyzpQgSvC8kiyE/bIuzWnxY+/ -rQ3a1PGHdmPDhZvhUMkchEWR4Ggh6aaHfDsjsFbNaBt+w0Mhb7bdEmktgvp6RBpY3OSIJwkLCsPC -7qLHVWk+5/cHm9Rc5PEXh/LvkUI1ZM4J2nbVDbZNDAYtG95avS1k6ova1gcVr19KMgCOMkBb1l1/ -N9mwx5pdR+fu1xI5MP1UR2X25KqiwOK7S6HKqo6Cjfyqs5xzdz4KHmQISnFoMz26Kk99xdgxn/et -K7Oi7qbSz8OnM2knXPg1obRakih8rqvLsq+Dcn71IWob57T2mEe8mrmU6+sr7lATmEwGadFR/HRH -29WsX0rzdc3Q41K2z9Z1pzVWQwEL2dlp6bjgd+1OtWdrTM5W5jG3/719XXSHcz+UY2slT+77W2Pj -od+Ztp1DMu9B3/ktdhtefPaDSoxaJoLoQQd4Gg5bxt+JU58ru6Jp+R7rVRhbYqF8HeQ80O6AuMF2 -d5rx5zG7qqQabfvzmTOMS/Y6N1TKJnl+KIwst6LiRLiyiIj8zhTh33ohR8yPWNp3QiVPr8DJ3kCM -+rTsWU4Ue9cj8wrR6W8fI4WK2/4tAKzZBAYwe4VvV9Z4BnzEvghzCxeX+aaRDGWorUhvXe7lEIEH -8XDQROmbCZaejM7SemaWbPDo3zLIH+Kj2I2Hk1TWhSieD/K3lVn796m4MlSOMGSSbYpPZ1eetVLu -ft20DybNCQHJaSI8q7EUtjIznSzjq/hD5lkdpzdd6/vz9IyAju5qAgAzFR8TJN0/O/q90jOtSeeh -319zZzii+48w5BauKoJgL+ytKFS4cS+S07+JbcFi4XbJu995UDFzEkfWTRsIjRk/ilp/5kb3yYjp -rNTqV3H7RjdAxfNINBB0wU0efEMJLAIf3EuwzoarFJeV5NDwHvFGsIeMwfZDZUqThJCnSE9YWfVY -TKhIrL11peUzfYH5xe8BAv9i4cvmP7pb4JTWgvfeh3Kv0n2NMTpY2g3y/0kCSf0S3ZfySsRy+sLw -ZvbDG79d+j4VI/Ls3xJIN+A3nTwr0HbG9IBdcrHmGzb12bMO5/6N43OxCMMQEJPZoOhwXp4/hmUq -/0ldW+AdVeEuKOORKMYSGDhyhI4zOLyFtuVQHTdPlD+/WPIZuC9XIXcB1DmY5ThuEUShPYDMX3Bj -ARw4Pr64q0lxrMe7bDNvPBlQEaZvEaoYPareq/wEyomI/0pkS0rrztKL4e/Sq20LT1sqGnvfihq/ -AhWxJXDEUOJzeMX803MbU7Jxu5No8LWFwLtPqL0I+JLyeNjyRMffT6aPbmtpnjwVNRT89VgelKNp -KfntYV9grJ6xfcORYBbT++KMPdHuUhBp+Urg6ZydO4jdU3CbOT7HiugjjdT7oP5iekK09mKOAX9U -q6la0TaI1DSlpYSy3+uZRYWykWmHHMudpkxEbx/ZNgHhsVAiZAUhlg7/PLrQZha6GMu6Y+6N8q9u -WFlyoACEmqpE2JmJPdtAL2DakMBCTUE0X/s+1cm6rientC0VoEjCmrwUQQfgHLpBq9KzMLPX64JE -1/BOvglX2KX8Dxi0F6UQt1p/HElSUzQRu1jDLx5ZpwmJAXFHfNshkj1FfLT8VyfPKQT8lPPrYdzu -Wscarpp5C8IAViK0wwFfCm4hxS+IDod5GzDctMWXiqfKXRKaVbDbnthDsXiFGVwFjzyI3Z8geEB6 -s+Gkjcu9u8NGtusgYt9K1NITWn6dOU2v9OzP2eRfV/ppnZzqOjUg7N1lOJgWQ4yfgiqEZsAHM/fG -RmtltMpO2JqJnMTlXcFJMgjntCrH4ntfva/Ll4BlzSa13XMIeXoXwrOihH82uEkOFI/D7Rle+HRq -IG7qi3VVBSQZoNZu1tKO4ng03i6j8dvE4W6zyFWqksAgGaka6Yfsz6csNm3fL1235i/ndH1v1sF7 -EIkwSuQBEkCNxy82YOk3lCsg58RQpc147+V6xSCX0xovvjE5i09ArKBkcvCnBpcWjrIiuL8fbBf/ -rnlMS8F4ffOWMEkITyKZALC8LngzhBGnEyKrzh4/LPn+ulhM/6nvY0fbiiGy18gk+KNh3uQr3vD6 -AuYPi5YNPRkG3+Mbrli/OaMBsZGtFEBqoKDxtCv/0b3yc6iQXacKvUKbTsTYQSQMUODEqSonKz70 -tmff8+Nb3qbZz13mffn6dOo/cQA8NUtrf9OK67Ga928BS54PT6O0dSAnK1iImUzhl1MphJXT6u25 -fLzc+jJf50GHqQWIAKfSkpkKQLnvfuzsiIq1Mt32OiextsLJtPoDxFatRDQWSa/XRFJjKtRzf6Uz -5wDiy26L0hePTSDUKxJH7HxgUeHs/jvr5IbNNp1IXpV3G955RtRCYeT6iLBlakVL5nGJ944bj1yV -F5N6NOcKcYROGZhSHsSxM3iV/kE4o7fzU93gtq9SfE1hPfUQ+wmBwW+5AMYlWds1ycji2HbgOkf8 -TG47Y8cBiDwNZUIUgeC+xzv1iuPfSDjdf98g9ORQT+eDNzfSUT8gzsYor5ZfolkWN1J6yZmBm69E -0KUpbZtxlwnEgMdQ+ieSz1leUm/b3qX8qSSSjtE0/bOQ8sqAJBiHJ5yIJDyjo3vsarYGXN380dYq -ZeQw5uWPF4Ylq1CuvkFgzZHdMKaPc6kaZ7bcOH1n8eUjrEBi/cooFhkG6vJnhzgXB9isjew17J6F -IVx0mpuEKQn8KgjUuEQTtIh2Pc7fYtq5mjSWWS7bE9gdkuUrVo4xnPXsi9OR9ID6rXIuKK9lFVn3 -6dedoxE/VflqVsHqV+9P2+Dq5mUV0cEXAJyvJr7DMJRT89YZFb1b6hum/Z7LPf16C+O1HAD3ptzc -E7GCN88bjjNrhtRwqVhK5pstcyMD//MGljE/OT+cguKHgAH6gxfBzbJwYyx6EFuidsFXFlnZyjc7 -gniwrComoewczBsBlGQDPzAnWydJcf3TeyKfu1Fs2m802zVrG6AQQgUkgZum5xt3usx5BTM3mPkx -DyXWV9lCXI73X4AVfl1QuEcPHLHHV/0lrWFnW5UrLt0evMzPsUlasN7MLUBGhJOqJEKUjpqsZIvf -u58zHvKeUJFBnKY3HBRTXN5ic5ksQpkPfFIu2DzGxxeB+5PwDBNhAt7eSeySmtfUj9s6tFXWvj3w -jposI1J3JBi+ZHS5THVJ23VfV9s7H/LNdm6L/GOj9vOfMBgD6AzzuF8jJm5Es+tjcrktZ9ab3awQ -4DIrunBLQuniAdmwRLry3YYwDQ4xA3F6KGYpXyL3yKaHvPvMb8Ho78sPzBZ3Fe5l2wtBLDV9wqcU -IVwR+E8882uua+PQ+20NcNmSyPZnot5a1mGr8sR2iQTfwS3xS/PRjvxirSdof7zjKJSc5wt9/W8e -nK8nUm4q/rD94C86FurCquFPH6wZuCqJ7wZGKOlNPAhKM9GQXvu6ZXuI77FR9TcSQa5rTkj+BykY -MNQCCPj78a5mQR5tbtFdaaSQZ1vF7xlLzX8LAMnMzluHqmF6kVKH1yrBZdncEnn2rUaCjiqJ4di/ -6VsHRyadrUTZ1pk03+Fgh2KIA3nF29r927hkFMF/yFG+qlUoRAsx/WQ742o46TVFodhGj944Ne1r -G5e0N0Hku7zvPXtIkOAXAUYzaD6+2xdocmzcYGFkq1VnEOZOzGRxIQQH1HXFvRRAHwb16f1bHaPr -3XJ+7MmM3V8+FxNn2nENgvKCBQBJX4QeOkvFPusuX1680jDpYC6pc4NNOXOz3/O/nhA4EoZcwsE8 -IFAp9wZO8yxl2pk2j7fdGcXyp3DI1VdE7j61+Idp4V/CCPeyLP1OOrjswexJ9r3nLBiHcuuk5NXq -UqEWYig5AD7zdOooE0rchLWW4Xxu5sJtDrPZMigcKPMFdFWkuBeqX1D2J5//2bkSDasbSIMZ/2q+ -A7HvoFZdqpIBGQe2Ifn/VN8Ytkjq3q/1UiBe6JtDNaQMDMGRvj05pjPq0u975T3iyKe/cqwyt/tx -QQIBwM94Y8O1u1Z9SLXn/GNeWie6BIw229AA1OIGaPbAAHYDDjbCPfFBCqYrW8bPJ77o8JF4ijn7 -KW2zdmdEHCSLxT8o0pcEGswCAqqzBcWKmKdiuRrdhV+kjprZH8mYhxQATpfatUPbeTQ3Hq/aceuE -6kXJ0ZpDV59AXA2mWRIeYcnQ7hud+36n5q55wZRfTJ8sXXRjDgIhde2BkbUVjFQae4O6Fnl3gktc -6W5pV8edBadJaBbfWnJZkdnge/HzU7mmyIyzwws/hpMvpN4OZ14FBufETMdeA65IBvYB2lCnsd7R -htjqbggEt87h7Hp3wNYkr53f72QuXe9YeD18nzsy7ohs2d94xdPUaYCYnn+87bvAldvb6hKZOSw7 -T/CY9gVDEGBCOHEv90cDdbuBFYVQWh4cd5PidHejqxi4d3/qpHPts7k/KuckDiUJ6JNKXLApSkQa -3a2M+3vikT6DyLsm35cbPmhx7L8MJQRfbJB4Q/jSj7iXjlPk0cR/xO8mIADGl5p3nui25pHObR5L -jB8VSh+m21UPIRnrjsCHeq9JzjJs/VOkcXCHeVpKlvTEPCYb8nJANfIHOxQ7gWOcVAYQeLh60j+U -X79UXVAT2kHPUm1R2xp5H0oI4Wus2FGKOk5HpBXwBemob8vjbX+ndEW5/PMqNBZF2lwA2uPM0EDG -juwrdjuPlI+g8g1M0MWGq9BgmgPZ/AZEJE1UZxxMmt9NO+p7Supu/sRegR1QewXug73RQEE9Qp1y -+HeBS4YK2t8t/ELT7z2FiZl9yYJScqGbL5xvRA97YjhKbUdjiqY+lKy7EvL0EiQMR6JRnp6Et0z+ -xSc/waVQiQ9tL448vXws/NRXmlNJdJASwOEBvj+C/QeqDkJt8+/uSkR+nc7xlE4s+dbSii5UpYaD -Eb4cWA3selSNbvlfl+2KPKbNfx2OUbveZWn7x2ARuLt3RaDx0z6FR4732R3tIK2zBk/HKz98Pnvf -s5KaFDiYmo+vsEksdZp1/lC5flvq5SvcFzDhgxseRDLscF2dJ1827n3ZxdC//w3HA4mIlkeNqX5r -vm69AkVjgDP0BFeg2Y8D7uePZvFe2HigWG9qW81TTPsYBAN2ESer9QfLfsAlcNeavaFFf4NKUaxk -14RuGyUGXLmhepDho7VjnvmO7xX9MD13sZj3yzdPT4ycgpwLEmcueWKJ5ZNHa2M1DIO+b1j/Mjul -eqeFqW5kqfpKCExrXypC3nlHaFOBxne7X/xXjmWa+GZrzP40hkCcwWyI/KuWv49pjainquycCQto -5RWRabtNcTFu9ccuc2I+j+ROf3VH5BzcxkNlmw1rYd0AdzQkBVzs8piJXe2JWKLbBocdkez1Ygvv -fpZSXuyNJObLELrL48j4/taEiPWHGZnfcp66IbJ28y6jpA8rSdBhTnZEE3zUa/cVF/zgm/8U6p4h -W8xY1cfpi/1MAeJT8Qh1LD/3mhSOsGbMlF9I6911WGVLbYrAvpWEM2At4yY5eG+qOTf7v+66eD9o -GtPqxPFDvE/Bn5USwC1ACKDOCv7I6u+btwqDtmpKvdzocrYyT8bLoSjnEQUDPGtndxgCNw6WPm3x -wZXft4ZqKm6aJtyOe3rm8+X178+uRoLzAQAFk3sidL9sroQxKxQN2xrXlbmE1EOCgPZE7rNry4xn -uDa8Ls1jfl00s98Iasso43tIcKkRMoAdu71Nm2vNN95tny4ocFt6fqnjkuajwIBq3cS3jXAB+rzh -/ZpDW9Tqapx1TrJ91Ir74iNZP1VRc5EC9kSAyrwfHF98TVEePI6U/ixz8uvdusKWdKXGwffafgwO -XyhfBwWqDKAv9KwW9r+5rmFseG74lxs8V8ewZzMkCh7vDAAr0Hoi8FXCxgVPybDaGt9/3DSv2nJZ -jWeCUTKHGrv0sWA6kbWvU4B8w/gFpcUta7tqS0bfvk9K/zeqCJpmP4ou76uSTltz3M/yYUxzZy3D -zR3/RsHndCbi8/N1t691oMUPnuhIF3L/O6Dk/28UfE4CdS+n6pX5r12xkDeW2EVf0V6peRQCBUI0 -YBoMwBx8c7NIdNdc02dNHabYupffZcz6BFdjwHt8YPkB4elht9jfwPv0w64iRp86cRtqEJBpR4xh -yWHRvhjCFAAnTc6DQrfgBN219XyOLlk5xxI+H1ugIodYVQ2Dwg9jIaMcZuOOD8KMEccupkuqTUo7 -LtRSQd1w+qK3OxyowOfpAQ/EaYCgEdD0gle3YHr0onWTvCYD66Hsj2GTElQk4CvjySmCX3765D6t -vT0+t/4q2OpufVGqanxu259VOQBqnLz17GwutqbMebZv9JaZ/8+TTnFUIZx1hsI9LtBkUQTfbGiV -rwaDfYVJS7HA8zYvgfiYSOYN/wkHyw6D0y/EKdJW2Svkl9y1pt7fgXX3DiOEqEoAE7Px39bfraVX -2u4Nl0A8c8P8wPk83zfNN1flAOjk5iTT2JcVclvZwhmwZxPLht+0qFKBcEMY4Yrvz+kjkai8Id5C -OFlDmjNeduPG520XoCFgVYMj3QBPONFHAUO7yRE7u5/erLSOMXqPob+hd0CensnjrMQHOykFAUUL -SQ5Gz0+IIzQnCuxHNskaPR8+cTPPS6eMCgIWEVvRrVPR3K4NdS6P52LPqSinK3uFZ2HHN1HgSNxG -A5wXx8KJnpHUu2vGBV3LBg4+CNAVNxZ5bmsLG6HAUEgkMPbwhTkBJQJQQvHaMnLgx1P3825D2Trn -lVlmrpeMm98QocrjK5vLucK8EJ54K1qJqU5o9/1Tr7aXYLl2zzwx2OZ5lRrthlO0kWTV1H/Y/bKR -O1KYsMb6B93LGrObM0IHKTcRAuuOAOqnLeWzH3/2PXHNRO0jOulPR4roSptuNoZTKDQk1t+LjGyI -HFINTb+p1pA1q3BYwtecOWxdADUSiZJzR+Efc3KppVJVsLyCgv+PjHnt8o1PRHx9qWHEqHf02Pkg -GfkjVZKOt3efflc3eJXjohY1BgOcd1rWT/VaJw/r1jizDG+pXguLPvmK7Bt3h6jSJOcjgudK46iR -v3mR9oiuR8jaOguXCy1UKbIsCHyzoS2fIkI5JI8bHQyXyy5TTk/a0kehiRFhogW29GT36El2ml46 -xeSZWel3t2frpFzU7qSVNOh+AarTYbFAfyTS3EFkOdBuzsX2c7qdSaWjyUxKdb3qsToLUK+ZbL4X -nmL4GFWW4K807ntgMe37fkqKsObjvyx+QUJE8ro3bitOf7uZrc/m0/zOc0PDFEr6chDcGnfDhgP7 -nmSdYP7j1gZLzDWsmL5BjQJqOmCwS7O7ybqmXCvs0UmJ3qo9jZNq9EWP3MMpWHx/vMfRTZZSqqmP -rTizn3z01O9QfYn5SnkpWNQdX/oWN6uBY7YYfKewH3xs/IknJFk+99Fy6jRZ1u2Op1AFCeWEli/z -ABye87k1e6+gW9i8UN+dDZfe3O4647AShju7uIOfC1o7r6Lf37kw2HE/zufugeRKTK3pMYpBCgLk -uZG23/l+nb9z98IpQUW19PnP2k+eSd+CgoBrL0RlRrCmx2izD8aKtv9lLP7yvo6L8lrcmAQbA4O6 -D9PrONPUxYkBn2vVa4/+GfK5WHCPgsAf0kYiyCccsn52vHb4zY28IZqhev71mrDDflkUIBJ8cDgN -wBPlBuwkAOi+K4bVi+1viQU2i4brsFBBaP5XCoUfCMY5AYlCAVg0jKC1s9sHmN1nfbWJK+D0VrZL -rR+EkllSoDgiA6xHzuhAb/yjR0m/PWi/a2BjUPzVr+t3HzeR8q+1WJUGfSVk5c0uru1rdGO915N+ -DDtzG27p+kyHKXg1AQAT9OrtnsjRR/lMN+waWBwV1w2UYLEUDL4/Laj4Ew3cIydCpG4ymASfLK8o -yw2NsvHLVqiiwhEzSdasEWBgrz3zlSZN7XTykN7b0tEJCqUS3ycQ1MfcvICINCHHyUHp9GLVjPEW -/pcORad+HkpOT7vIRMniI72kEsugyVvFa3z4kYyx5G7JHmajd2aGtEeHV4KuMMLEJthQo2mCEnVN -jXmNtoEXgg//fvL+s0cjBUOWWvpAXd+t+VS1s/OHpsDfi0Hse97a21Ncj8bpKC6egYSHQuguBE5R -A6GbUQ8+fTlVYavvcsTTm/+d2NhKGmhiBJixQFKnK84yxQKtTXzB4idAryvCRCld0CuFd3/6qv7Z -0lk8LvdEfGS02f8gCbQDy8SM3z4/mqz5XpDukZgMhyHSJ+O/iCCkvwMipGalpfJqlfcr3RwuMG26 -zWz4idbwv4ggbR1d2iXzvwa3HkTlTn//EL7n3O19FRSqNKQAcFiTsm0mU6+pOR1I+f18ovKE0aFj -Ze6lJRTaCHUxS0/VoaXL4LktV3OZc8DaE+dyJlmZrjz+z3IAAVumstcHStnbDXt4MArmV4QhmVr+ -0wsGG0z6gh1JMFi4F2HCns6uvdnlPzQkdUtI3s5vv7O6Y0rIf5FGEEKsZuLqie+SsQa5d66gq5kh -T88/YTBTBq59/+34fxcHSGBbeM/yR/aLWJtqrPWAxonH7g79B/+LBH8gKxXMEKP4jpu+bf2U9/r1 -y+1mEr9EnAPv5LG+oXCbrCKSQt61YLOFhNZ3W2/RrB9vS27e/FZCg8KIwMkjkyUXoKKgBqDe+7M0 -kf23u7/M370ZNPZQN5yHxx0KReBsSXzOzeOHR9YpfmzoHvws1LUj+6cXPYJC5XIDO6FjUc4ocHGT -0l9MfXQjztAmpnvzqY4dFTaLR+pWIoAbD+MO8yAzTxJv8HMn2x7j59sTGpaxVyEmxE7v1yoYuXdb -zT7c/VJgT63Vu6rsWvn3W++KPllLgcJxRjpgowPeVlcYwpNQbJHR3+t9RrzEM/ZxRc1UQcZb61lk -7lOwKCQKjX8mpDoj748fuWXS43Wxu1voh/Jo6cT+nZ35KzkEkuwmza24wxIn2u7v7K0slAuu2BJ9 -zyGBEsCt+Z5wGN7jf82nZ13Hgi1cUEu1zhIh1eufVpdGSRC6orqChXQq3G0mp6Mx40+sdTcYePcG -LcR68EIgKA9iSRoAMpQuMVCRSJBZY6ToPGXiZV/QWENhSyK8yXZMoB6xE8LFBQ5+MRdHqYPcG46l -HCmoUMqXZfrR1ze/biV+HEOmp0qFWSTJ5NeL3kaeiKcVfp2jfTr5JQUA1EcBrVHiCUbQnHvZcsV9 -75Q7/RMtgbRb2RcsU74MQJJLSPHinuabbj923acrSdp+rdT6mNrtLSsR3AYt54XAeAEdAgAmMDiY -R+jVouzc9Jqb8f6Zc3MPNnVCMKuY5+gFC697f8NEqkalb6mPyhjItfNSjA6Ckob70Q/vAGEfWpv0 -xmWPGTJzsiiCUT0C5ulFMUIIaaSE123OIOzP293jkiYwyFgrfGD07mv0+ZUE0WFI8KMB2O3ep1/Y -nwgcvZEsZBjG8ER67G+fDAUGFhPA3SMAnP2TsNm2179Z/VWuD/2T9iSFD7xh0ADhxiw8/AsNTVra -1ub5XWbt3HvQfOe3XkgAXygdA7RoxpBqErld9fA06dFF0b4+vPC8J5mnNXh5KQ+ARsKxSwYtEH5B -kyp3i+y5PIKVC5H0mcroD4pKsaxhv+UJhRMimh5wuDfuBfoRvUHNs9sYk0Ytu3avF2sqvyR41oY7 -Y+K/4AC7v/ZAqMiBT9dcihXE+C/ZNRnPqBRTsCiiyxps+QtOQaO0B/1NB5oTaR717neqPuBYKxDd -CsGhMTDiK+EtuJ3LIFslwo76eOjnJmlBm7TEQQgCZ3X5KYGj6/sTN45JPxeJGz1uA6eGMKi3+T8v -UwHA66tyBhdDtj5dSNn//hf9BGJbz4taimUc5YzxXhbyWpvDwhT3iuGO+rtdHVsqX7+qvifqRgG5 -ggFCMMsbeA5A60UwI5KsiOzLEde5AqFHNhIOX/K2HTUN42XIpZg/pHzoJZdNVBv/6acDsb98ijTq -1LovLbyD74mlwAjt/5xQKKBIID4OAMBxLGqTFfW6RlxmVbLnp9d69p8/7kgBA8EC4BSAHNaX2Bzt -yUTQ4ano/buKPfr7M8Qn+OrZpHRXckBZSG93NAyfwqaH7hJNf8R8beHa+x0CXacSr+VwlFMShLKH -f2Ji0rF2w9f7F5/Qi16MpmErbNakuBgORKzI9nvyGMpGE8UX11U9pt3MZQYw3CZNb3flaP9TAGn6 -g6ZYw342bVTG9VE9+7J9g0UsRdtbkil8nStFgC7HvewjxhdmnHKfJSXbt9Fd/5WuTOFYxa0YYMM+ -FBoRBBr6JI3Acu5FoYdt+29WZbPHdYd9hgU37qMI2XljPPBhO9IRdZJmsCxWWP8lU11xZqEsUMFj -IXOW7rjsd1kK5w8gyxmBdvbFe5PfvNGwVKGFa9x7cJancI/VhbFvFSehkKW9BiF2cE6Q7zxi65oK -m5puCZFopI/VSgJfc8BFzlJfz0T/sL4JGCQjqVt1N7a6XVvgY7w+XP6O+bh1R+nzxSBKCeCBJ/Lw -r8fTcKXf39aVjTfkWLaG7Wt7/vV7ByWGhSEIDwUsPUMKj8B9bhXlWwub8R9q1FCU099Owxq+lZIG -1FDA20goZ06ac/z+9J0bijMEU5F3X/5hR6IMe4dNKGiglzK5bgtaIkE3ee/QZ31JQ+kJFLgZYu+f -4DFYCS53O+I7nS/VejNiqbr0YODxoehD3rW+lUE20/0XKSJQBAlkrf8eljqfk60LkphSivglH+ZQ -vkNe7xg0BfQaIXu9AfWZaCvab9cuTZ0R9DOr528U0KJQFYnRY5g3kHi91G4InMnPlbcO0k6yftbY -eO4A80OM1tNFNmo8fmcDRvHS54c8tZn0zH8jP3Fb1o7rWsodKe61FIY8gQcUXEK3aoK+DHRmJIQW -SBPsikJK2uS9IruDkWzttO7bft0QfveGisClEIZehhLXeoWjV87QJPoovXflPG2dTOFSIzxtfMl6 -ABr5+kgpbLYg1MgPnph+mqHJ4JU9xSAhQkTP7VKdZ+ThfZzBoQ/zfE3WdYykFx38cKhqFyWNJcwj -Mtv7cXob5+Jg97SPZlzY0cvyM5Jv1E1XAQEk7Hp66SeOlz8elzvyJfUHWPtp+VD4J8nLgKw02mDe -QAsVcI8gTVVAbkfWk77WrX0+8lcWbkonlv0W4Tp26n+SC3ZaXDpNz57FKDwarKRUIrInRbKsfM6R -5wuF8341eaQjflP+wutHD+zcFbgtka+vWpCt7fAuipyD1QSRHraQRVqy+FFubjfm14poZLd+SUkc -7f8kCPRUADssGoEvCdHoHzf67oxDs9Nx28vslpseYbQOUQQLVpPohQgA2uQSW6duF/kWW6mn86s0 -O/llvZ9PTIbo1Nz/Ig6nZuJWbjiQkUrmY8qHn+u+v/lKY3d86qY/cb5tAlHdFNvEf5RKcvZsvvNM -kbn5naDMmow4K/uHDgwR9yv+F5k4kSiwzAxO1mdUSps7ki6T7kkKZ72OKaKyWp/CJFxdFvCvFOMZ -c/Zto5drmPP6haHIM4l1ArFzOwqgxJJrIvUTk80XpieP87OyMusfvq91lFNTA4rBINxgnvizGoPl -5xNmsnT763V9xFx67T+WP7mJpECQCLIwT4r1o93z+jSLPZn3LP5wv8X+pfOgyAoCCIo8nyT3tWtt -HykihFiseHyEEnXCGk3lqINEz7GxpuOZ8k0TSccEduT3y/OETw3KU2hXGDD9hqCeEKfLrZrazCTv -/QYYKy6aHwL6ibYO9yj848Qe12B+gTvM0xVoQYck+7IeiZXJBlmC4fQ/1sBVMJ90xvNjf1ARAhrT -oI4uOevM9e166eM7XX2Dx8VbeQIVKQcsgSErwQFqWUTlGfCjEF6qO8pl78TV7W5ZyY7xjae23GCT -Pk7hcieIIw4xMid/zPwlkYie0RBp9rJyiaYRITcpc4o0MRJNOrmIEjLWiXxs1iFbcEErwp3pKObI -oS9UKCo7Iek1VJvub71VFqPdyU3jIeh3YA/2ubYzhSgsDI11Bmo2ooBmJssD3G5RUtHnrEt3/Y2I -uOSmEprynlcOWsDSbgpgnddfbH8dzCHGFeFBV/O78gWNrADlYgS6TMBjk8vzxAxFHn9RsxjeeqO3 -odGJz29H9ZOj5ithIAkdfO2+xI7q38880hJ9Ucrgd9L5+xj9aF4Z11UKs4NAkfk0APIQ956erM3+ -47HFwiLvdzGa+yge/wtNghGuTb8/dsVcbHafDFhfubOFIctiXRHl1fhNnjAL8Yb34r3AOKbFzH2n -Pv0wULvW1ynGfmd1DqCC8xy4OwqUGwY3jGlqNd9qfyg2KUpBeWLAp4iBu+FHIPh5rT8LZVLn2zZd -q5J9nvughDctRJgiIWIlCXDtV9ryX88InJYbHFm4Ajulv8crjyIFCTxECvZvhrKL+jYcPsF1fmOw -TgtDhEvSQc79jtvnISUA4SNSzBafkIHyR8q5gTv3szuyyOdDJTDWG9xetKLin5KnmA6slAJWc8Q3 -nEfD4SvS5MzPOLxQjhs9wxZk0fR3V5jTtwtOFNEk/KFdUgQT37GNrIX8I6FuqSfnD9Eha+n+OORG -bFhjQBl0XimDmIDwI/GHlhDNG+xjhoJjGzSuWTLdFnz2L3bJ8PiqYBtgT6+ftMtPXcmEyVRVchx9 -5h80qEw2u4+5Tq8d1M4IK7hNF7b4sCSRCgZmwcC9vIgtcgwSNHKwzxLaEenOr6VnS6OfdglSaJMr -Cm2ciwljYa7LP8YXt23T9Ldb56/O9FEYZmAuL/5YHz5j7IdZ8Z/4sWNuL0QUutc10GPzPxguO5eN -BepCgaFPUjBSPaI85MfTqH0D67ml0gxc4nedbPSBRMAg6YnQvybrE2m2i4U7WR+2LBOee/wL4mJ8 -T0BCXnI6vdF4SdmkuOSc/nBWEg8m+2+dB3XGG0EMXpA7dXxy6qUu6Tka5rJ9L9QUrb9ac/AZ7Woy -wM9dLHp8wTjrj2PlnT1MV22r1ewbuqgz4IlVdxTKAyPnEojbofEa7um9ztI+qoL8To7rmRuTTm7+ -Ipsv8p9k4L8D6M9cm82uufHKfccAgdZxhhgvNosS3f8iAvQrtc6+fnzrmpVTgKmzc1Iyn9jGDFaq -LNDPkLCxcnDDjBKZ7C3+0LBa/2kvUc3s2G1OncNZ2EBdTTDDl6WzUpWmI7WPI/dTz3rN3QenbQJr -qJLAmuSGQgfKERv/adgYb5GO6FXBzurSXR8s1+fL3Z5Gncbt4yh82gTWLjfENtFT1pSvLwQjLWD/ -4ESjIVWO8HqICQv4J41ZNlyctXn+HH1nPvnQ/OBLr61KAw8182/8R3kAXg6fYZ+wZCm1Fr1meF3m -Tn3jNaEWqjhuZiDQKCTxDDIXZ/DDxN47efzuj1KY0n4q2m9Jc6XKgj3mvWFYIFwPwE33ZeWNKpy/ -J2msLeDS855VyLeqog5jlqpihcewOxyK9ra2TVJMmOHsdoUJj1B/8K4YUhHDvJxbG2rgynKjM0UH -Bzou5FbfSEdR5fCBRsIrxz8tFzKzUoGn5ENPVIeHjZ9twosuvpc37T5+pioLMArAGFrOg4vZDzCe -L9fNj98vvP1jRsN2lCrkBcfCiFUQd0ciYrecLDb9euy2sOoBV8amZy1nqIKAzx3mBAxyZ/JtoHnQ -yk3vjU3DgJFEyO4HR7TPXV6gvqog8cz1fHU+pnXnJic/lQ5ISKuqTjWIe1JnCGWMLTn5a/rpUTWK -F+Gl77uMPnnDT+pRhYin3ognSeZOV3wJHnHdMmTN0rMl309xVv7Xu9Vg0sm1S8NVc10+a49deJKW -Xrfmy5GuBU52qiDere6NwgdiLdpy7BxVsoZyrF5fTb/WgvrctiKPiRz1Ayur/ESbfOjfWz0VkO1R -/lxF5tcvP04l6gi+4vxR2Yl2/XvmBywP2s7OcybYdJYpUkUIuwJxDBDORxFMqXLkevpb+he1n4r3 -/9jbxWVhW5k++18lgfPHeBeiYasgzFbu1q08u5h3/Fyvv0PwuDeC3ziXEoff7LobdvGFkijN4K0a -mR4Vz/ghTnpoErzPEc5Xs/k1cnHzLGc91i8kVq+dn6O8GmcpIJCAJk22jXwLzoqLDc4ugfX3f9vW -PVSSoeNA8UbAyspAIhUMf5RQ/phuMcOJx4ipd3JqOXSsjPlW4sstYKA8De7b+MPQLqRtkzko21il -TlclYN0cAi1xu2CyN957JYTB4nYaYrGLmos2e73oPtG885nxa+fGWtQmPBuDBojKW0biRiUGuvCj -ERvSa3pGzzDcemJXsYLAa85EHSV9t7DtlElDluzF7O/tPNrHD2z9u7zsQhB5jBJpzD14hze0nCWG -c8xIEJnEcGDLsjWF8pwbwbVNSNECHUlgYXsUcsXfAOL5tj3+YZp6bH6Be+R8eFcUE/fcdOf/Szwg -jJ71Xbzm5xP98Qyt3Ahvh5rwqVaj5cIIrZ3IpIEjnzCIEUhCrMfg5VbRY4e4BmMkv/5NnIvQjhh7 -sayzii/aEzjOcxDIYsBZoTCsP/6UzOK4t2XupkmDqKd/v0/qJioYmhWsxFxQXoD7H4ZxRiCAwsvO -hLKrGHTiS53ZBafNtk1HG8zfPJQJVdJfyQI7HO5PLIoYYR3QHbzlKSJ7MubbJ/ofjedyxFLXZlJA -KLQXbMmSRCAJTffuaEi+1unhsqMRGjayRfhLfY86cJIKu/QNyzNjb1Ur7RuSiESx7JmcYNv2bPo+ -NARcHa3BwPLyuoVnU5QWSpHDzOD0yyNdK68m3he4ewN/AXy3pbv8dfJnaMfEz6nsNcLeHb1ys6EO -D/ZRiMAQJC2VZGGlT3bo2NLl+PG8nq7jlGSuQP3W6pUYmINCdrczfhu5s9ahB1V1Fs9aV2w+qvHI -dD00Q/Esm4wbktrDH2UeiGKy4uP/+mZEvvsnNOrjS3AHXnnAHVkhruPuMSczxKWzLrhuZm0GJYJ1 -x6IIbx2AaJtDZDBevl92zEna7tnz2m1oQvDrSggN94QRz6pKmH9VNxcLz3+ZC3/PESCWcafJY4Dy -eiANBV8UhfAxXZ9Cq94xmsjL/e1lHaAZoNsSynh4JQaOQzIHUp2h6vjX+xzHYTU2weqHut6wtU/P -r2DIdLOkKsXfJSGI9pag0tJA+9rf77ReLDtNDVQYk8M4oxHe+DJrxr/v19tu1vCq7dz14uzEhadP -7tkLL78e4UkKPRICJEUh5XILXeWS267XCXzLs4YdKpMXoGRQSD8g+I1vjgsc9gX3JXBWArXBDwte -3Hz0U1Z23mit0po+w/HeZ8t7H4FCXOCA8xh/4ptQxoIwq0+5V0TzvHh7Qeyns6P2kC03/Ybr16nj -ACGw397PaZde321kau0ORhaDt27h+ygIsNIAPAA4xw+oyrgbJyup4HFc/yvdg7OHXa7lZb9mO60j -+Fezn0ICkFyGe1wYBMH1jRudcHBBxRKLHTfsf6nJfJyJ6+ffyKNvLE4XfrtY/pZCDKG9OfiOeKQK -MaZ03QM77uTGzR/uWGPwx2IQAsB4g4c84MBYwBCSaoG9lng0PfXCe7mSX0VpaI1Lzx/7+dBVlTx9 -SFWMJ3BUH+2LJH73TSHoJy7O/MgIowbJ4feqLvQOh4qpwst6MYvquP48naIg5W/z9fFLOu6r0xlT -DVRJnGIYAI4x+v1Wpk7bEGXvXH9f5nFHXvnInt1LlULD3XDvDMB4fRs4mmy1OFKxQ3MijRuPwtcf -qoXAltYziUFjGbtRZumX5/xfeFt7jJQZPeihBDB74XBvSywa4YzV9/HFk/ox3PsKslsff9F5V22q -XXODQ6j/CAWJX5sIbonQ2xivltObGCQVbrWUtKC+WIq/2EBJ4EYeCu0CnLPzQiE94IHeQNIW4S2U -S0pzckqiw9ZOHccoXx4x5uNSfwEhAV8OIFDO2ReDRXnhXwc46bQmj8WdOOiYsMGCNxPNy5TjxuQe -SJ0HPnGrukb7TMxVHf0Z5+sqsDfscqbPFygIgiboD9ypCwq80xP6HwQ0CvdGHn2iou7poQD7M/M1 -kpLzxD1W4GqVeDNk5m9u0e2XYgUWhIZ2wz8ES1NeDbSk9cMSTk8BpT9xdhIhqHmDtuas34s7aLSC -6QfmoOeD1WUD7RACAoGqE/jDBhr3Bb4K7q7XfiT3GyHjvd2qa7/3PQoCjMmTFTLT2pFRrc4Isxo0 -vNCTm6t7P/xARB8lBITj8L1IwHs77loWNatq3NrXghzqrT2sKHWINg4aAq72tWCmQ218+2dOfd0l -+oQfLA7yP3esvBrU6FNjjtYht7XZu24Mu9nGgnjsE7WsQrivH+CkI/SVPc7oa16s4R9nsEPlFsPf -KqzCcyk7youR4LEGwWvjnr5X33G/mpSenj/zunWu125ZOM1PFbcIe3qCa40zMFhABQNc3PG1BXDP -GV+U48AvbdptTszIpG74/NEvtpfRN48e/rckX2Lc5cDaCMMfKe66yvK7syvtROrUd/BI/hMHQO+8 -a+91JzICGnavSfiScKk0WvZM7wrQBY4BzyogguBkvoFI8UbufPGuvi2zNCFtLVHSwT9VpVeAQB62 -HGB/ygGhCnxfKIeADzRIpp2dqqaWJQzYuMqHd+1DoDDgHS9lY414Mj9OFqtJTTBb634ubSDscFcQ -cgWFW8vd4TBvDBL3nztQUI1YHXlhsTPoGm1WcGDx+pA3Dju5Xv3p9V7JeqKcgHoR4HYAvtf7Z2Nh -2Q//MMm+EzsYl3rlAILVbwWz9EyI5RqTzBvT3w7txuRm7LzfLcpzRpUmQmIlBIR+fHFmEPEuCRZa -JebsBiuOCpMoNKtlyNhCl8TAOR9KFD9F7EdeFRTx96+dnppq3ndBxHhG4mYHxbVgVUEEkBYHByum -ygHtF3HvEbdNE6OFT5DjCsLvEZYdJ0vltnhL5naIRK5dIYd42hqLz6f/al2y/Y7XQf3CN6Wn+4af -Gu+oMl6mLfp5EXbSJYcHfjGvLox9s8bzXaXYlqObz0btjnhlim1dCXojCDYVhrAtk6V8oEZkT130 -CqpLr7rLMyqq/mZeZt5gJY/FfWcnX7wiAVYIDwRLxQD2Hk6sEwrMRFXU6Nhs8N6xRRWmeDjOR9/b -dPQSaoUgUipE4/yw2JWznrfcnzPZ+sS8P+PdsVVhxbVgRosLqY2HWoFW/Z13Vplrd6F+H3q48+JP -gTmflQRudXTDZ0rHFQVj+QXd7USOXxJSvHtpRDqGPZ7ianymE96HjNdEATQqYePwiaKB3GRWbTcO -uPpDQS/aHiqoC+5P4i+Ebaogs9iPITAVuy+RxczyJ9PbT1dqnlKhSY8St1YBLgXCamPZcoHbLfvG -RmPOCLWWxF0b9/XE8UJLAK6+d2zXeS1nmWl9r4tMbWdZ8oKFVWArr0bDwZqDQKcxXySYBbfEK+4v -tbDW69lxze/xNo881kWL0xnl0DzpeREOSYGDR23O7sDX48MHHHPMaFgGzrY2NhWb/QPHxzlfeAfW -emqiMy53lpfRi8inBOwPkVsdBPMFPcEy20A1ckKNvlM3JE4/fxHVqq4ojrHmfVKx/6hQMaQc/HAi -jqYnplLpV5wPKV7b9x7++HJe1rC49UcKDIXBkD+q2/19SnnvDfQtXd6cSdGnnw65tmV6BQN62kjv -lbx0LE1C0Ajnt667g2fnIn6MVzVxd9WkrISBUlSE0nCgAFBX3n/t3h8zufFzJhH0mz05Pb1US86v -4IgFmwD9APd8SGuQH9K+5vz6z4+O2Ruovk+GxzA9trxIDUXDwe7tCCL7V6h3+KzogbhbWmxdz290 -qlyZYhpawRL0e3AQSoyPu2grWQzv6DnyaL5so12H4covR9gFYBjADCM6/7WKDNaZSOvRpngwRtln -31CXuU+38i0QOKAGB8LNFw3RpWCv5JjB52Gv5IarzX3wQ2Mtr7IQK2fckhDgXfqC1YsIbeb4x/Z3 -WwnYHE8dNPzYs6g2UMx15wE0jW9vv+zlrEsznY2uXeOt7i5ovYl2NFAq1ukvNAzEAlD+4KPts2dJ -4rsHl5nkH0gZUHY96fWbdeVrIUDkpVLOPQyKFzy1G02rpC+azYQuLK4otYSmgBpYVBo6TLywyxpX -W5+iult3J0uZTcddTuFwaCGkMQxH+not1QXmXncPIavRyh9g2XdR4/qz60xTCs3/EADaOIArjrBi -ZOxc11cpFFcifF770fzva248/ZZU3jlJBHjkiXjegyXCRC+vKfyx3fOIfLcRy8VHmYf3Q/NLGkcV -45ZN/LR97cLXtoe0nlhUT+G49HwFg1PicVZOoBwm0MsJha/OemTnmoPe+yY2iZj63lSJ/1h9/i5i -wwoKgXSBA4lvyx/zjomYNeuET8vTd6ZKWrCIXmyk9eWkAEGrGu7isBxlEWKo7WdWP9Fa1LJGzrKC -hsWq68lKdNmitKYn6IjXQ+du2JR96H3uPQZhaz2sVwCAZxbvSSWZwseN8s+0mdkHm0qZFbQ89nNk -eXDi8ArKCw7DAHm1XnAvIH7lCQsCx+GzbAu2+ecxzBosbjMn3+yNvcAmRrc6ic9vJ7vlZ/QvnSct -X1333vPN8OqIJIuY8xHmVUUAkPQ1x1tI20/PGE7JJBX1sV2lORzgvhJCAXULCTkYcKD1FsHhcufV -5xls2PljmzexWPaa2fJ5VRSu3KQILEk/QVSHBAtueUUz8Hr6z6XavhMfXmWxQyMr1JSFqXMXeOM0 -GAO2d8rvscq2WnfG1xQaJMZREV5g6gkhEgXIcDZS4qxXiTg7knl47+COM+sCLovM/RcZAJtPw/XT -zWPjxb9MN0eUQl03yZYyrlwnVrDLfCThCcEdMSP3zvotJHx4tj0h0l+DFwONLymQJs3jvWmnT0g5 -536f+cX2rWpeP5ViMBEYwkuRw6B8cWsC3qrF/xsgyEniQ4fG3uSW5y6o1jUpw/LCOh45/xIUiMRZ -Jlh33Pcg/NOyPPC7J7bHb3/2zY3ZP+foRJ3WiW3Dy3uN/xeJoMnS9OxudSh/zBqztp59Uc9EDmrO -9/9DDlD2gfQrQbXboe72Yb2yTP8Qc/BwwUdeWLobRwK0GHcYBtRL3dAwbzAO0OD2Lk5b/gSP1YYv -W40cBL9umKv2p4rizF5PuB/cE+YPw8fRXoaWmzT3xkVZG1okqfgdq1hvUoaEpgmjEQj2AaDZjYh8 -BiavYnRdqIriBVuNqnDjleolEUTi1hgklliM+NPxgLwpvdZxO4NdfWvY/obl3l7euX4JBOr7ymFw -6y8wi+De+CKixgViu3W9Xkyk+PLknRPQqCxyQVOnAaL0cYmqXY6F8j4jP62fnS09TwvPrdxVyQj8 -j4QcWwxJtQQETafK/7z+RTYw7MhuaaUO3WM618ZZ/rMgF4IbqUb96Hx/Effav68jpT4IlXBXCuWw -QgtBw8lXqlEDNXbWGbO0fW1cWNqtXVvO9a1Zqe2ROJwSjAa7TcI8vUCf2jrH6RJLoUSYx87R9ph2 -udain9bZ0DBhjOOXukrp1G+Dsn83WMVeuF4xu3BSzFv2yAoMCfcnGEjk6/gwLa99SnRWrLJo9olB -1MfADL7T96iDwI9k8EMRodOdMbXJlaViY+kOF/zh2H5h6jDgOSanFR5sHW698RK5YfDSc9cvJo1R -Sns1V9KolSss+ek5lUeWbVHVI/59sVZTUtUFaNojbOYUAvD9APAVt86hN547x/EiD8Wqb/Be28ap -6ShtywqAmLG7VJsQAIXWzHyJK783qrLIed3vfp1Zp+S2leYcTjEkHv8ySDjH41Gu7nwG2y9UfUQl -MHJicqWVi7uaqBnh/ak4bNKPz8LaErWw1u+vbrRdcQrn34hb1DEyHeePXomjkVF9yrBBd6Fxv4u9 -uTYr3woQ7znGF4zCqZbQVU9dnj7sNatNQTmaVTr88rvjRXPYyXulHMBFgvYj8yEAINO+ebPA096S -Pl5Xiuutvj2XFDn6mgIk6IF4DRy9pFISPjzjSOdiO93QFqOXh5Hq10JUkEhYPTUZlG6LTPj2Y43N -6jxjNds/xyZwPla7NQBxBwEEBU3bAUPvX6ZgdJJzjFkgSr0FWfTLD+LqQOLBdzm9gwCWsMbX7719 -KNunpv6942ab3K3vGuquwAi2+Yp5Uj0zO5PwNu0Zh6UrTzPWO4XhooPLCpAwRyj1nkdOGUYBiz0W -Jj+U1HI0jr6P3Ou/UjckzS+giizu07GopbPBW8dyDwYW7WESnKV5Yc73hdmg+03nShyOXaam40Mm -8koJ5U6Jwcoxfvel6NT+VivuHleDBrH4ju7AG8Er7cQQUeQl0b+RTb890nae+b/SzjwQqu/949Ei -e4UQhVAi+5KIpEKSnVKUwWAwYx1rZcu+byUq+x4S0kIfskabiBSRFmTLmq185947Y8kd9Pv9k6X7 -ept77znPec45z/Mc86n4oS1H33if/lsCWutfOGobHzQA9qJvvVQOQpz6Q8FaTqVNPnK8ldq3YWng -YtNRvkznmM2U6QZlYqdrgyivS9QE/H0x5K6gETb8+P3Tvf9V66h/1fXjDjYZ96iyb+Wdz/7bpQTW -FHHGh3BH45cpDag3W3hLNFjlPPrj7+R24xTpCgKwNvg5Mrh+7KV07dk05kvPRiq5cx2BPr8Tfh+C -ZwhHuxbcFzU9kxP/dtOUkkqO4aVXquw9f/vWS3r/t9S+Ht1G+x30RxBBXJ5D0QEvBtVXXI1xQDiv -LD5TlTCZVxB5seM/llOiz+Np9mqwSbCthto7mOC+AS2piH5vzu1dOz9VSOdPH6rfolhXP/0XuZCX -Zm+MsCEcK4GEQsk/yr0ZZn2h2K8w4b5DeqBoNNB1uGB9+KI7d5oEleF8u6jJMkSh8OnN2+YmHDV/ -T9BW10D/f0SATyCRYUiSLxZoQZfFLPbyZSrzNraO8/AwcLU8es+WSB36+3bx23tPo5g+5RbL/D0r -BPdugEnaX3PRIKqkAieOq4KsiKv6bnPijpzKocuCe4Bd5cXyb9Amjbcrxp8yvcW5eHf88UbhmFP3 -HMI9VzBAPDVwlgy47gTtbuPN8YZX+8KzdB0r5z9+zqA8v3e7wraie7A4/pSsZbDW3B6UN+1N/3yv -/XsFbNgPvWZ9M7Qctoe8nRmXA8cSP+7VSAoYbXA9yhIQJLs8hA3cAwT7Bb8lUKkav/1PqDcESFSL -iHg/DSpOj+8P/BRp8k31UdDIrnVI4CMAQInuMb4s5+5tdDUUZdz18XO76XZwOK9DYiH1DtCoP1Xk -TxuewqYfUXHblJf02LxAz7LS2U5IhCW+Vne9g092eipVhHXTnzpyw76aybHB9OWXGkFlwfgRQNK/ -CRL8CffVAZqlLu4wCaNtMG4uSuHMJL6DHFpJQiqiuTbwSksyk8AW5bwXOfgs2jcAtSuozjUOZdnw -PPIwERL8ApT8MAZPRYKO+8InFHt/Li9L2Rqg2UzfZd9gcUqC+s2ntVTMwUIo/PZW1tBmjQvvLr2q -6v6kIi26LxbVBuXnrlRpraWBcwuBtI4lRvDEl2MyjPXSbxsFUkgPKxsectwft3EtFXwQNYDrX0+3 -No4gz/qd9q1B7/xPzNZwuofwOHCegyPSCMiJQtiZWWNAc9ZdhMxhtxzQCZD3usVyLYp7i8IJnTVx -Y1NoER172XM/t4TRD4FoihjninG17sDsnDVhQj09y9qsnGuoYwlU7j6qMgJRcszVPTNrwuaWJmBD -fLv5CpuzgHv/VGVWhqBTv/AOCf/WtWCAUw/g65GjUSbdOHAlhsK6yOiFuFL9ahzYePB3W51WMKYR -NlxrZq2rbFXkkRlYVvBgLZZws4jkaw1hIT+S1dTLflkOxAXVFbVuWIMFMJGaLNnZUtULqudnUlTL -vpwJwbTJEsFQZkgoS02Z533IS7vKF0zNR5TF7iju5z56uwGeQeJcacAAAv+irfgtobJYYz7UL39y -Kwg9cr1NH8KTR7Vj5wZNojy+e0NfEZDJb81oTz+nsvPL3bYjSumUfp4koUkD6xMwNseZCYSIEL+N -tZWLsKiQOCBnd/QtJs0m6GZuoBe1u2Wc9Pz+r/rrk7OzB9cQXryt0tUgf+6Alst+MbkpjEJD3HTP -ugRAP6Ne01ewK9pt5+MNspqvy4/u+/zxHBEYrAC4MNnDNxr6cewco8uTWym5tYEF5r/jOakyrqyH -R0IZ2wxu83yoFm/G/ovRwpiaVkGU2q/10Li3aQLdPHuzuc1XoZHf3wWuGspqu+VslOzZv04FfHtI -KSj84yQUrkye8f2pkeWeUSW1b2rrUcA/ff+tc08t2Vo/7igtkxHH+tKiVKln14EDqFWYRLrAi8Jr -H/i5Q5pqGEiZW/kPwaNmSAdNnPttjdbFzT7wU9LZ77vYBX5I1fSg95+6/CWXh4E0Hx4mREHhDTsw -JEbpt4o8bhCKqq5/dNaXP4S3decRBDyM66hmuDHBEo0AX5gQYuSWl/VEAzWVnk5qrcFNMclpcngQ -f8Y9OCFcyAupVHej2ibucesB7eTxvceVuk9Zs7vA43bg7QJMoUAxdYwU0xGjsRnxpNZXex1OZREZ -D8GMVqi8A2CYoPfT70w/nKYba+lRp8SLHjKaLn53ymcduAke3/1bpsMxPdGK5b/68ogCvrwLGtji -tXFz/OO6K3lspjXuYVga474vKeRPtHOU8inXpgkPe4OHojGZ1n22ICWL6NTOK2aR5ZdI1qYX+0bB -HmRuT4TPqEsaveCv2X21nEwzTWvyAMjCJ8cg6P+2JcuuQO5BdOGFLsH5EHiQEKR0w/jurG1XrO7r -2UZ2N1nJnGPFNb3wBOiUYjEEX/hDz58N5ttd6H0fbnMlaSA/bob5HfcXuJggo7zpCvv3qKmm3leV -hhqDoYJOV2mU/74YcrUJufqEyEFwz+G5Yn9NW7gbXeXU1nMN4xsVaMoE4OmFg1qBAjHgthEV6ngt -t650e/nLHtqgrPkSlsi/bTQexUev4INOYinYleNJN+1qMj9+IFN08JR0Me8oLGcPWzHcpClwxFxW -zojGsjHeJjctV4eGVYIYboKwAcNBwWiLv3I3HcLMOZFDUTnBqdfObU49NCrPxHNwLZ2FLU78gcHQ -HB2KLzV4dNXB3mRn3+bix7KnprqxzLPXicgBp2njk/Wf11xqUOz4ZEyfejSBhYzJbKpVMmoVCp/c -C5byNTbHYqAMROXglNdTye7Ox7EKY6VqnB/qU5lL1iOy9B4AHdFNmd/VhLEGE2Zv9N9jf16S0TiZ -R0QHiApcVMKfLYBztVGEgkyyczfOhsr/kvv5eaeglp4plaMQayAxLayNFdIZbFa43xKOoV9Mqli2 -uaJldj/xDpv8y3vJP+9Q/uB/c68yj5OI7tKityVlj0VuldY5W1iYt1e03jtvLB4aTgQjnFALYKn/ -nU24tL1Va6aYPEyCw/vlw2eo5U8WzGBY7Fj4kFMg9Anc1QNfj22xfWbndYGqH/yGR14k6z3I0+u8 -uA4RU4QDGDMAfCpCGLKc/34q2XDtk5131ZxHRqrEjMWF16EELOsRjrEFPhohmtwKYQSVONO9xfh4 -/jQmGiOn/bX9Ssep4D45yn/UBT8toOXnPEMSOnP4RqngxazY71yKccdTCv5RC2d3re2QRpCViZ4T -ZWocuWhVVcvL/Hrbh/n7kzSf/lVvebUD/cDYQ5Nh0rU1DxGoLESzl7YYtvsfFZe9lQOxJQNd8oF7 -haJtDB6GmkZxZMrR/KMe1sFUWILfHouzTWaE+lnJKbtGg6lU0RqeMfNCpDLV/ReD9FaTBQJHrZBA -aCDozQRkXza6rqJN8U6+XuO7rCpJ1LT0dTgcn9NsYoJPiCccAb+kFgiuk0N5HzdiT7flT/HwXZdp -uJDvMt9epvRO4f+kCa1IAJIK1AJfRh01la6L3vPehkI/EY9zOUFcEnp04A/gPHZPkvPRgFhB7WJJ -2SJH+yex319pEIehz7JiZcGjYMPxr0bhvOl7pLRuf5XZqS7jv4aGA64hIfH7Q9amC3cH9tAh+j85 -fU9F7jSIm0yEBss4epjHwqgRxlLw0GdojARMOr4KCBg154hCOoEfMHNyvlbr4vV8Or0Rkd5had68 -zIm5dUmC09fKsb1hoQkM6erUHs4p9mG0lD0h64KNXKyNAAGDp0p0H6smT71/8RT5he/V2EXVbYGr -COD/MtAAz/YPGp6UT/k+FMybYi11ccJik9xNGHLhOHb8czBGYIyRVvjBmpA0oi+SfCFSYdrktn7g -T+O4qVSXxLEOGC18/hy4eQRgD8J3zr5FN9Sn3n41NzRIzcjprc9CDIM6JbCXiiTkOESoF+iyXHa6 -Xy1Fv0XUY1Cz0BHtvgYOZuFBBfJjHI42mUxL9fPQeF/nrnvz9cI49sDqNLQbATaj4c7Mzu0OOy2m -PtuT3bVv0LPGiK3OmkOHAJvgHBxcG4J8O6HrVxJ+DGtveKgsEHF0hinowdnZ76urLHEMczuw8Wrj -k7xe5bZHYnjEbKem2WRWh5cUDXo5mHZngCoW+X5T1A47jo6wuEwWOEOxFF62gFyE/jRygM8zpzXC -bM857XldG2p16tV5eyTCzhg6lYJQpA1c+ik96ZQ8lxZluvkZedrzoTGul6fXaAHLhKCDOgEhD4H4 -RJZkneAcIbGElDCGfUxxf6z+QQhnNezw9/ZTI6ZU7FPbhsgrjV7Vbt2Zke5G5/5BCcgxwJ8/QkY6 -fMJ4Sw+1k43wiGqxjUhbCAnnPyiZQfOHViY/K8GQKrLtuWolnCG0R8n2x/r9mwq+hsjJy3Edatr8 -Hoqk/9V8NRkwkLpvYvwPQuYI8PFMRVOX5WeQDHc3XLepNB/fUHqL/NU/qBD2tLd6P7H0jDtWRtsh -aRLflne4DsuV/Q8y+GIymZH397mGVanSUagF2n7O6jO8IPrmX1Twaxpd96orBndMMrSo80+o+PR4 -B1C0tv+LDDh9Ak44BceYR+k/PCTDnbULShNS7mIuXWY667rrH9QcF1ZLhC5xH+jqLDC/lTm6/bPU -r97J57SF6xcCFGYGfLsYkweqeDZRCx6866Ux12GktZbCQgDvo6CJ902FUbe1UwN6r03fYzG6W7BG -JydsFOMnktrffCjCyB7dkxlnzE5NVPJ476eJJiKAdwEJ+6JxdrvcO7lqNct2CBi++979weHciCER -krBrAhZHJZQyQHw5dtDSTavG6ICDcGqE0U71TRJORHgHazAnG6By3J/fSMhn3pvu+0HxpMCzYpNe -R3EYCm7iCSz+LB9igVUckpTbIRXmPx5X/ugx2xdkIhtQifh3PcKcFqiGCqg2fNucE2NxQVQrfq76 -5/MKKbPPBnD2gIgq9DtoSgeo3YpMdQrc8Ft5cr/UVb1C4QbLk7np/6q2NKS98Jh+J1Mz7/apYfZx -u98NTtjWKjgHi4geQWnxGRqWawVS7Zm99CA/qxmpMuZ7KGPLx9X1lkx8AYER88T6a9bnjn5KHsnr -Q42wb/VOH19LANek8DvaCTG0Z435xTk6chrlM39fOtFds/Hl6vTSgotzvysmOd/UhvYknfyVIyA1 -LOWdErA6veBtEbZf0Ui0Eb4/hmeJmwtpNXPYFZ3lOkZ+Q/FJRW0TnNqyZ7hYd5Al9vLPKvq8KSuS -g4cmmxVLA225lkWCOaEwJtZOhDUdIGOOkM3c/f0sFasn85uuw9wpm97QDXoli5XDkYRaf0iEDVgz -cXED9xGTyOFksf8SOLO9dKX3bBb00sBkLFOACjGsEU+EZWrCao6evms06tV8DrEL+S1F2Q1OBSjV -il88AYp7maKg8a+s1IsROzdmwq9t9T19I8XQnKFWPAy+eAQxPgKGUHeEN1lnyCs/MHz055Op7fOV -H5P9sqRgeGMLQnUUQvhvdPj2P72Msnln7UlIRKvR7+57p2nAgUA9dPDvgsUpLCBPy+7iAVc6stO8 -yduMMLf6e7+xG5GtzUIRCUBld0BjtDfX2XqX/5uAgnk6BnL1SxyDfKzENLA2hKQwgKRpqlX0cBOi -iui99qlumjOU6bTXeTgSqkK1MNMC2QRqjBLX4NXH7RRMI6bdlY5bqXwS4Vgb7NLsyF8l4Q/6A8ZY -Qpvfeyqyz9xyCbLwIEJhCWEn6k0WqidjyLmsJ3T2HXZQuWMxjZyGY5YsGxN2ncEDJaGygvW62EZ5 -K8M4Z/nnnu6bkCFHU+htYFRMUPbg4iAwhXKiinjHmvE4vogV4y9Uluyw9Rs2Cg7BzahxFg6NwgAx -wCZYcLF1oSKE06cEJbXWt8LJmlx5W7r3PAn2neBZSwRchL6tfUSasjtcqpBs39QXlbu/tyrVwXBL -SmsR2uP8jm6zPgvWLo3MJslDvO9uu1cww7XHJQduERIEwQ4Bvt1tYSkT9DJMR/pZRAd6/Lv1XprZ -HobTsEcv9J9gyZmxEsEQ3wB+sWKafl6NwIlmBBEEjYKKA6Dxh7hS7jjZuPVlpu+TqDc06s2Mdlzp -W4Lg0YVwnp7pMtcfVoF7f4RTtSXPhT++J2wbCYcQ1ipI+i7meu9s8CRrvHgNEx+T1zdwpRDuemek -McLOzHEh4AOHbqk8YhZSWvjhKxVvvEx6ZFo7o+NpWJRQYQJYWH54xo1VLMSQb3qfx3Q8lfTVqGPd -xBh8JUTCwni3/OUr83aWmP3uWaE7+582jGhGpRNDwWLx8Nb00VTe0I2mP6nYAVE6csz1LOGuJCwx -maV5vgCbUXIfUz/c+tHFR/hb3V2ZydkDl5/CsKZg6VUHKOAFco5rlFx4f+l8fbNblXVfLSPFa9dE -fxIYEjfZwEe3RFnQn+5/rMFxrDJP9uiW0OQPhj/gPiY46CyxI7wK6Gcjvp91o+lCOzvTshVsxYZj -iWFL70zr3OjwXNrWP1HXXirtKgjFHpb2PkmUA4L57B3wy8iPhZHZXDmJE3fcs0LCguJyG94WZRIh -TbBom6WHIFW/VWmfPJdcyRvvc4ZXpJjum4zNRjjUwcFGBNcVcRYWZcy/4DIsNQqcCjdmz+xrFz3K -JFe4zWz2+WutmJdElfAewjKBHYEulUxoAaHu6p6zNK8ODoYqoxVhBBa2Z6EOB23QGl7N7dU3OOm6 -/0XcDxGJVhZmtu93YFlouXf5ILn1t3NZ+UR1vIGrU5IOG8b+0B89VRgYGNOgokHgQAec0ocB9zis -HcxBA4XA4EdOg/oDWMdHzjJnJuKm3lD3bBi7nWQII4gPXwTCHIATRfBJB0t8CEAL882pWXHghrB3 -1t1Bx0YDCrMrhRfW1gK3YrHq2MMiPcNTTcmPRKfcPcIehLCvQi6Yo7PmGmq254U2NG2erjyoyWYi -ld6vtgqHRthZAof44Lo6EFVF8MYF6kTFSRJVKjrmRx5O0XJXPidz711FBdzq/+vWUzY6mykL744z -88U4YlIu7+kdDUlYSwI6xhhKdgHKq6Mc8Q5xy68j+SOzpiiVXQfMSsY/BF0cd2xZlxgAI428zljc -aWL+vD97milGuFUyeXjvmvDiajIgofMEMVCoraJUV1d+U9Rz/w/rIdU9a0mY2OEHIUw93ZeSbTxW -tXz2rY6mRo4tsvxOa8EoDJhAi1z4rZU1VH3iXeSZW9JvfJuVVRTUtjw38ur6IZe8lhjhB3whi4UH -c7Vzi06OfxbGVJWPU6X9WI6cmG3OerXAHwjeECHIu2jCzhRJf8UkM2Ve1tp3akxSigLOeC4XJBwn -taIDQVmmA+4k4W+/NTfw8FFfeKZl45MStGEtSajpIJdGGD+ea/qVsUkw6aiSWu+WG07mUfF5KWvJ -LLpeC14foXh4Wm2Kis6g3atb70XKtQ7r8G3mjfdbU44gAj5/0AF4P7Cp4a3606jMMENbdNOM2fFn -Vqt18uUywFx8oTJ1LgV/YD0bSdVXK6WbZr8N9tKxF25at5I90gocMveqjnTy+qGUIySHxr4f9r4+ -87CtZN0i0OYJIGPsE0F6tLAgP/pGo4bWTOmJzA7f++uXWTqodHRGfBmLsyzmpedplzf/wJZc59u4 -lhIQ07skOrsgW5O/6t2W7cz8wXZBfjWl6bS+c+uSgGpygm3wj80+ttb7/ezH6rKkrCXcDoXk/nm2 -hgbY5vLuS/lScp45VYKme/utpiZTrIV2FWzhEUDdYsEwE35PsM3RearBl94e8tyaVmF7n2UXh3f+ -AJynAckCzjCUXLk0pSE1MW+jTLgw63BdIpnJswHroll9uIndCoklvuu3i2I+fZsqdTWdcoraxaoj -XHkOd65HYkkg+k/UBv1j2/Yrzz1Qtrv5+p5ZTlHku9UkQB828tzTJKEW10P7Zy8zcjr82fv4oC0c -s2IufS/9ooCH/p59IsK5g55daQn89vScMCBhIbDKzPqElbyK4tcc4ZETvtt3DB44VAx3Oe57pAmw -8vB34dhsbbUUnrjtfVJhHH77EqcLPhkfpyEuQPC0AXLDE3MRdjF5r7E5z+ZH4UwlHmNeAbCkswNQ -u395j+F28mIMxgTaGEj7z5S//61yNmrrMTgYN51FgPuAfVaxDtcyWlp++LGqYx9+yxTXMtxJBADL -iOL+BZIQQD8OsRC94VT+Z+BD/dZuVPDbql+ynjKMo6T1sComyKWnSNj/Yjl715Gs7XVujyVpMlsw -A2U9nNMIFCGAoibgZyQknTpDFUXOdx5+a/XtupfspmobBOcCwrylAVbl+cYX1gdbGPg5i22tnMmo -wuAmCcA0GOqkYIDfQqULQKKTTFwI+1NVH/nA+E/sVXmDodlbcA7XggTAyDaS6bx6xSMr0Xg5hM9g -NM7iR54nDAMU2cNN4PBjGmiiK3riE7JDMFfJUfFfa+lGfmY5xjHCkfj7BGac4HqMNutJWS7mr6WV -sXU/G/38Lf64B6+CgTXqweEYgIVVtbbPMB9Vv1oyY3YzMWkz5bks9GowMPGD6uAsmmHJ5lyH2jKf -lnsMyc3UXSlzPnvcZmE0gM1Oawzh7XA9l5uq64z6+Kcn7mtBsl3L1cgYuD6LfzQml8pnc0MPZfxO -FghNsf9sSrrdNwv2aqjeJVQ4FNeYgbAvE2gS52tzmSFcicbD6PoZ1sRY8586GFK5tSTAdtx+QeJQ -hCDnrrvxr7NUh7Ob/lzjgOHsEabIpZVOkgUjC8WVT4tn5WRutK3rEonK4uSGw/52jKDZOf5/oXEK -kHt1bdtkhwxWuID/fr7u1q3qDKn/wS35Af3Ymt/UCmsP1E01tULh7U7aTt36PXUeJyq4KVlkclMl -DDxfDq+Og+OAgB1bTbT3sEk5D4MfSwZd9Jy3NjEKuN7r2WCutqoLne6c60yXVrTR5ne1cIupy9K9 -CHNziYcRkjGdydN2Fdx8Q6yC/iz0ORFrsAB2s3/UIiGDvkHzCG3oEOUue9Sv4z0w2KK7B81y7ZD2 -NtYYE2i+SPgItzxaAhUqxX09PRSot7cz5zDY8MO5E4taaJSxnbUDwt5ywYO/L85qQHlPg+2Me4CO -2tsJ8bRWJNxq9KIENEYA6GEuzeAfrA2Wd54d4Uhq+Zr7C4mAWzdcggL5kEsG/ojt567ePXkGffPD -FPPDuScO4XsQ5asKAB3SBtdFUMYLbo0yf49PihH7xGCPfA2pit5EIduua6tqLCY8AnidzodH2Kck -aJp8L9kcZ6q371tM4RrMEucb5zFA/cVIgsLq4xzTnbGXR3Q5jdpIuRUZ4DyfRRSLATLbwUeXO/lk -5KTxS3HRMhp+DR96zFTedQo4FjrglOAGaDMiirobSyjvb6Y6/qX+xsanyfq8cNSyEnhxtiEzb3SK -VES7UNk53JqG3R8/wU2eYUpVL4SOO+f6t3WES+s3dR2gUCeRlW/mPH1lXRIAzOHoFKHHfmHWMkGu -XUyK47wu4jzcLAx8OJApIYxu+CVmgv2VRVlL3Dnm0h4l/u5UcbID883AOllYIXusDdA6gELZjggw -ARfIbAWWdt7NW/govf10exffjwxE8Het59XCmDUkCEb13udf5Zc76xj8h+vaShtGey2aNr9YA3UA -KoqCTSWmTYbr0/ORaLmILKzDT9boFsYXp2BgR2srnIONsENZueDXPa2BM7uA5DYXIM5toYRVAgPf -uxo+qixttN0L2+yhbac28s78qx64CA6IRVa907Mq63x2iTH8s4Rlo9T+L1dGYcQWHVjCCyJ0wRQK -J49LNConKg64+z+ZpPuVkKk7uLoA7OqUGosoF4KHlobnAllfeIB645FuUZglGtBuaGcn8eV9zpNq -JDtAhZltiOeag9ldAd+46pdf7ddnVIylmHSE9pSc23FitGaZP+RqhTLiN8LZRCsUv7CEojwgHx9w -nL1vTxlzGfqEuWjM++vSTBnpxBgTFOh6IaBNEMaNaV2Km3Y15niKpvj12/VX86jtJ0YShjxoFdES -BUUS5QceNGtsS/VhrO5ksjr8cMefqYPnV1UAoN/2lDMvhQMG5Tbsk3M0Vr6lu68qiSgE9DDoe3DR -xXL22B3ejG/js4UytEnTAxzVtbmroos59EJPT2i4Uv6yGvhj0dj3WmpYkDScmxhqiUY4WyExZrix -Czd/NEMujIYWerli95IcptgYyu8UpSEPuLAXqhMRAddfhD/KtChXvYsx2kIhdvk4+bswkq8rLofW -7fA1Awh/yLiZ6Sl5NDrDlJyrN5z1k0DuFcaAVUkwNBA0YHRM7edbXtSiGNG9uV9GPNtf7IshQuJm -JLgxGj/HO9F2XXh3Pd2ZyJeu7G0vNsqLcQodXckBK3vA1RfidrjTZJPOmJNrevTfPK1DQ3NwEu5q -RyQGBR7ziE/yAdhpyaTJDN367HNiWfMfJHOswpnCnq9k7YxFwbTM2ZBT5waMUZtrGM8/vEXGGhx6 -078S5mqwQKEdAjIR3Qwnv5Jv3kr3yfkXWlNP+6BIq80KxARpaoUvargs9FXFXt/5zQbr952hHfGM -F+NEmMoMBIjCuD+4rCy32H/CmwN3W8rqnDnqFsg5ft8spewjDAwdbUY4VMLMaxfHAzeSraoXq8z0 -4r5sHW8JaSMGgfPFCzbsRQO/U409RegeycrdjdAwFl15/UJPB/c8QLOuEKN0bLzgmJLyHupQxX2h -4zNCW1fhAORU4u7zG4dO/6xJ3u3c2FEZdeSAV94KBDqQfNEy5msVksj2Cm7yOrzDj0ODxmCvO+OT -FRA+bAFYpwU/2zhJim2YkCfPi77SmuOhFXkiveiVDGiDwKVhsBi5kZU15DR0T2BqjSL/y95WIq1v -8cHX45Ekw47VaIBBRb19/gcZ/av/vJ1GwQdyzQ73r4+IMEClXvD1yoQaxn00QjVTPEk+bNZDtiPG -oo+TCAOF6oITOXC6b4VEOELOlF99wue+5NNDPq72P2Ub7zBt8RN5AS8CLp47Yd+R71JwidtZI2Uk -5zAVymZAvvJqwNThGjKwoAn4bib8Zq4o0GHc/QV9d/qSzLsdVfq0Ma7RSfYC6DJ4HCAgd52QscJv -hrAzwk+6FV2ttNUOkgUP3699oJwqu+PocLQDcR2AmJr9bGZyJ6rvgyjiC6vA3lM8mytc4IlFGx35 -YMpUwTTxgUWHF/nEgz0jWzZPVaxgliQuQGF7BKtNiEEClMwDX3bsTJIIlPzN1VjTPXNBk+P1SaJK -4NESSyrc3bX1jvnw+ZoO/105D5rrXrGZYTHSq8MARc985YYviaX/9HHaLWghub2IbXe8VlBER5bY -jcak9P0Sbp/cElOi9bgaIm5016ygcbAa1gH391RACdBf/llob+3PcPNlCf/GA+QekrtL9EpWcBhC -0Bj4aD7si3s4cVXysF3yxU7zcsYbB138YAgHQoIabg652LfF+1D27pH6psciB9DOooMjgb43hVbA -0PkWi0MS37fBnADstt5HiWlzQn5nxDv/m7+8AlqMn2Taz9a1Nwt9YHtbXPZZxyankvmesysvt0Oi -EeBx4/igZsYTVuFX2ul8+Fm3ifxm/ZnWq3B4wwoKyhWFSkUD5hf8e5IHbcpvF0f5tYd7uFvay/m5 -tLZ9X0mCBzHiN4EW7iw/mWzkIIvQZ9+KMiqhEGTqboaZTiIofnqwgIpX1Wl9+6Hn3ZRfvO3KRmGu -K4k911agoP3Avb2FHcqeUf1rjkOqsbSho0wTLjdYzzVw7llB4YYz0BSAzyW6lIajwfXSE81SVZum -vHH1CBMRyZUEMAdbaIsRfHq/b2VxnpEODxuPnmSJCwxKMl6BYDGAwVgovL2YeKeRr6GV2qEkQrWR -Q287ufzIoTilwhU0ZB4h12VhS60/bFz8sHGzQveR8FuJciKYnAlyxlVJ/KvnE54XaveJmGA30fN/ -0zqC8VY6tLLBLOUWrOvZWM+IKZWzRxWiq2h9WO/FGxT7q6wgwbMqwRQiYDOVUT2Cj8TP0M1Ho8cI -G3/atK+LDp6AAvTk8Z5BsnuLvbI2d4X6G2Vf22q+t4eaZRNWcvYOJn+NwDwd3cH3dEryLOK0uMtp -oy5d1bzlC88t3FRZN6mv2wT6ugVH/WseBXoEbZTRaSLIcvOrGCrdu2/TYCl64kqpa32Zw/xF7ZXD -2yIIfAeuLIQ8neVuUJVm2+/ivL329lwj4mw+PEbU+p3LDRt9HvLjbdmtGy3v5YaoZHO65OAlbHBe -gxlugLO3M+YnnAxc8EWAPs+ed8pMsNbc+gUpBWXRlghYGriYWbUtaFouR4xFVSOUR/L8d2rDgyt8 -BeA6aX/nNobyG8/cEjTqTrUpu43N+Yn9D0K4s7TwDEKw695UUnqtFXV03AGO+bQ2aXPMeJwBwAA/ -/8MXwxewaQEU1o2XKJdbuDPH0loadxwwbWtP7MWTfQGqFPlGu2o/rnt0nmrVV2CWA/qBTAs5k78C -F5NSAhMUdnuQlVvomFqqI5x3lNMcS//o53yTvwIXs5ACNgcUJ64djTYbnmJX8S8MLPvfKq6lc6aT -2gkwFGiHtVNpTBPgwQ6sIbmqNnX11DyQkx4KLBRJrPljR7RXjfcNsPx+3pVn4DFnsLNeChwBFHHz -OXZ6mZWTTHNhOQszhbiUjW2uk44LNSfFVXv+mwFrh5bWR3o7h7dtbQKUQZbd66EnXHicnVVvbBRF -FM/slgpNS2krCGjhcVC4i9eDamLwsKZKj0CFUtsGMKXAdneut7K3s+zMtlxIuYKJfDKpXsIkxBgF -izQmWoTkEjWVDyQmYFT46p/40a8maGJiom/37tq79vyDm1wyM2/m9977/d57d/+tprvvNs3+NqmY -4kbm3L3v21+i1AENHEszbRh3TUHhlEc9aoCmu4xzECkKg/sH0KY5+TeOka0b14fwPqUu7NnXC7rF -OOWI4NsdeXuCbFFCUVl3loDsOUp2NuvM5gLBdOoIavThu1zH3LoGm4rYANNPUvF8OCI3fqS2SphW -m+SnLyrr5A9Z0izFMjUi/zhKTm2Giucxl3JmjdGwH0NkVx34n3y5S10jv+Vqh/xpmbJcHvBIvfxy -mDTI2deVVfK7n9UeueKC0iDZObJc9nepq+XUOdIqsx+rtdkgmU7QxjWzMtKY47K0yWnRCWzfDg/F -VwwGcZc4uAfSHpKgszSFJEIuwPm3V/v+4+B4PBW2PcuKALOtjLw3p7Ss2cahRxvTBnTXdAS4VDO0 -EYtK1OGidAQJydr3lUY/2xXym/MkIr1JZO6z05g3pEmL/NNGwwdjZJvcdYIwWX9RXSlvzZKa/K+v -kckN8sPDZOUGE9nUMOF2M52mhonLUBQ6hqNBkENydpo8Vle2/3qabKmDp+b3v+O+ubgfBo1DIDhG -cpk82xaHNo5oGs/YOoS5Tm3NNVkU6GmH6uhzt4bFI68fwVDvXib5I8hIQtNTgLzrFMkcpYKDiT82 -boOgyOGIZ+DhrsAL1T1hjlFgDnU1YeIJcKFlAJXxeeUa0q2nTMuIyU1Pq/HcTOZROTWjPCLvXyEb -10Yh1N5eCgmDLC3zv1whb5P60nYYS0y+eZW0bOVDO4Zjuh9xJCbYXm2M7qf2qEiFK7LJG1fJLaWt -9Lwdq9WzRBl+FByN8zgI17vQO0PyvTPKO5ueQfaSzIVwoV2YJ4JiYUkYCnFP98lAiBB1Xeb6CwO5 -cFlGvmeoLVLMKaviJ15lpl0ovxS1jEJjHreZMJOZYqEipGNRn6g4bDlT9DFxIqcdeiJn7WyUyh2l -rXvhEvop3il1WUFbGEdO6V7fSSecKVoAqI0EWBZmtkNO3VbWZE2eov4uOn9FuJrNHeaK3cHUqG5L -+DlW2nTLpLbYY9pLIQumKnj6c4GlClox0BFNP1lp8Fny2ythG3LVJwpkMfc0syuytNhoHIaGyx6V -yFgcU+B5NzNoHPyu/rtMq90oRtjlh7jUPlFSw0xCuFQpnZ2dMF8pkWLAuevnN8u+G2pNNhaLFZJZ -cAJl9TDouVgTVVLB0ZsU1O2nFsXijpcR4X+IWvVNeTF0+AZ56hppGVkQsKPy9mJ9O6qCFQVbZCwT -jRq5S4db5dyTpC47AdTidClFhQ6KlCWCM6cXOYZk0X3QQp6DM2Ueu0AC8JQnDH8SpbRg0rjY81Gc -SMJ/Uo4n3J6ixBD4K4x/LkzLKvQljDCRwgMc6GkO46ZIYZB+nqY9Gvi32Dj+/VSK2LhIRPnVtLK2 -NtG3ry8RkuwaWZ8o1EqocPR/RQy0aih11Lx8j2cfTrTKxqxqLPXmf5M7d+1wY6Bt7tKPTfLzm0pT -T0XoSzwuHTd4tgi81Ez/0ikjFIcznScw0PAfumSpvcxtSaT+/uMDg/2JFw4c707g4uAriW7ULKd2 -NcvetTW1uR2HauQXN9X6Cw/uKPkHd9RjZ/8CSdMM8/qKAZhXqJSweIHP39ggRGv/m50rERBCeJyV -Vc+LHEUUvmZXQwiGVfwBz2YP1djpVaOX2UwkRsFINIsjeAjBqal5vdNsT1Wnqnomw9AMCB48Sl/9 -FwQh/gP+GeLdixf/AvFV18x09+wsaLOw0/Xqfe+r9776+o+v/sJfvr+2SpQGJpQ0FvIJNwgqgSeB -sVzbIg8iCISa5hnaVMngaQjLQ6DHorGxQZ3yjA0t6mkquU3lOXCYK32BGjRmSGgGnhVY4Bi+fjSA -42VdoRxGwM1CCmAhHPfvrTEBPAsPMFCFFgh9GFKw+uHgdvXrwe0VQHvnEpSkPSXt0visSDWyQKox -9nCG0pogPD3cTci5ptCZ0jZaF/qEW74Hwge/tRONfLyBeqnGYjX56rc3X2HUF+ARjJpCm1ImHTv2 -OVIv+veqv28cveWCPMvU/DOeJY9zlD2wusCozq3+ufFG9eetWx+qMfUxAkE7R1xchI40gbAwzgsz -YWJSyIvwdBtn9LuMqp+vv0rN4VTRFWbUWOrrKGzzGnWDPNxDGvXM8QWJc7CZiWlqAyUu0LJRRERS -M6h3rIlDHMdNE+/GArU1UO4BFllKbSdgB0pLEoVlSzA1do9aWD16+fXVTqpnEyvJAtRaaRJj/d+x -XwJNRs39wuluzbra/06kBqYJsOZEsb8Q/X6/cwvCrWD9w+c8tbUUma9Ml8agKDQ+8CcNOuw2Ca7H -Z1pNU4NMo1HZaoaOoUH7cDrFccrtOjDDcAfB6a5h1I2N4rlOrROfFwsdXopLqmpdu+35G0Q3qUWO -ZAWbXN+FpJCi7gF81ER6W9jTHUSNttCyFks3VHZf/aQPPHEWPK9+PDqq77qbx5pIi9zbHSrheqKu -n5+6qbKAemocM5HmE9IkPm93a3caTYS1I6TG1raTExhYlVOp1EAqZ0rwmsoIyT+RYmSXdFlO7ATb -TLeDpBZJ0IWMW5iNF8W5MvYLNIaf40Z/q60AO3zvW1KMMLGTEHNHfijtnffva80X9etgQqjj+v3j -IknIOD4Iwwjepb8WThmSn9ARxIRddTNWzdUYbn544dIx2PCSs37jff8/Omknda+Lr662cW5IMPZS -Ib98YqxOu3eu/V1Zm5tny46Xnw8efxm7FHmeJgvWfHxWAsMy6lwSnPGs7dn+afyi57zaTawHl4D9 -JAmwNsk9G8gZH1AoLMnOHXr14vrNldWLDgN/kieuk4undJSW9XgaZD1Tr6OuzH1vYuoXfbHr9OhK -jk3iO7uZvp4vFW+++8hIYO9VP73GzkpIaCXLuqyvymrpcaO09ZrnUB6++O7a7/AvQVekHOgBhl54 -nHudujB1g4Xm5ABNHabU4s01mtIsm0/rKrACAHxjCMHwxQQPVygFpPpaq/xbPpU8InDWAHnNenic -5VpbbBzVGdZp7CQ4TpzE3jhOHPt4CWaGrCexoSlyYocQQgMCEoilqLWWZHbnrHfweGaZS5yVsx1Q -H/qEihilI6qqIlR9q9RQIdKHijaqhFRUlfJUVVVpUd8qVQIkGtGL2v/c5rIXqCr61H3Irufc/tv5 -/u//J7dv9934Tf+Lt/dtYMeuEtzCNddZw0XbMcg8uUxs33vtL1f7o5d+V9Bc4jUc2/CwXvOJixsE -/ll67Dz26oFvOOs21m0D+65uwzTXj67/8MDgskVqfgm75krdj6/NIRzjA2hb/NOjaKqfPYxm/oHj -t/cidRPMjE9OoTt3VB3b87Grr5+G7Raik08Mx3+eR9uG2HyNSqkUiW1E+Fej/c5awyKxNYnGpy87 -prGoqMcGMLYIrGfCegQv4GKRPqxaJmgTv1ZAe0MxdGgBV+uBvar5znnfNe0VRVXVdG56VrGEq+wo -nxjUDI51mXSZ6LqO2zb1GVL12UyPuJeJy2ee+fSpuU1rpm16dZiqqHhhEVN7aiCRwgSNJzahieiD -M5ujoWBLdPZHA4+KY0DGYI0oHScLZfheGzCIMbWbsLbm14mtiMHo8Hv7HhFr113Th8XSpjMsAGZo -AMyAfMmGYjYXj52NcYt9t6ITNwtbpbbRV24enOJblXDPXeN3j6HR6JWb++Nfz6KhMaa5QTzfdZqK -2JyFxLfmUOHr5uab5mb0+77Fs4HfCHy8FkAMeb5pWbhC8LMBCYiBPWeNrNeJS7BpY9AVU73A7SyK -q3XdtOOfbEOHDnDD8A+PRovYK37dg2BS4he3oJF49yDaHWprekPxnOoqxBtVn/1ixtIrFnmMrRGS -8o/ugYnAs6tK5iGWu2tUPsWmW9l4ER9RS7lZj54/+4TmsTg1a01lA895pgEGNEjDr5fkJnDZSJWY -l4kBj5wVsH92l2hXqXDzoUF0vW80VTKnYvzPITQWfpYqXRX5T9ToUEJaNiuneoc8qXVzbBd6755o -x4Nbw4ZLZoLGiqsbBDcscBZeOnWOuxabHvOnrfugOSCTbcABMyxssVOhcQkjjo0DD8Kg0sQU3mZs -0NCHgNJ8Txs4fBhfMG2AMQ9XdTu5mGzbs+chUk7SvSqk5kD4wARzbY0Ypk5n6KvEgbgvQQBg06fL -bcfHDRZjIFjFCWxDd5tafGMCKSHYjltcZReQCsCNeElIL/ebxzo+uEF93MKrhDQ82NzDgc0RAfTg -RuBK6nWiG9ip0VC+xC25gb1VszGPG65TJZ6nwXS/5hB3DS8sACium/a9c0V89SpWpkzvwcDG09P4 -iWCtQlxFLgEpPDCbp1F7aV7DMn2lqBXV5SNlFR/Hc/epuMUP072mXcW+hJW4PIkWo+c/GY5/MIl2 -RUdujEU//2QyOvHakEpn+xq76wJqLNPziQ3AUbUcjygSOaLrr+5jyB/vxpA43jmERscAp04xdISb -SN0HhrQBNpWNyP7bZHT2jd2oFD85j/bv6TyFLo2eOzwSpiG/DM/OM8wqw376ug7eOwfpz/SIpluW -sqxXq3C5AJ0b/GmJJUklkQLQS0hQVMvJ9eg4l58hwOv+ZqKhlINlA28en6bfy1SW5XJ+Rk03rXht -Eh1QYKNFJVnPwJsOpjJqVd2v1pX4j0NoNFwJdBeSKD6+tKiIWzEvVYRnTECpsauDastiVqlt13Kb -yI7NhKWAyKQXwmfyCv3Mc820RuDV+bwMhogDeOJrG20di58bQQdGMpZO7BjrY2jPtBCgTaxldhvg -KtIsAoaMv7kF7dG67VLG8xn/swE+pxz/rB8VQgyA8BjR4T5WHL8ukUV4Gxum16BmJp6EBNPzAppK -KF5kLqaWEw8gTF8DPAWzPRjUahATEGZOVTl6H74Hzx6Zk18lfO+RK0dnE+UooanC1IpeXaVJ6Ehe -a3oS3KDYmQTozvAg+uEGERlcnl/iIZd3VnLAoUOpk8yacLAqT+nuMIyJ5dGE2s8mRd/5cDwECy5R -AGS5uEHTksHxlEntBlUfRKC4UXcd2wk8qzkPwIwZ65yxHKeB/cC1GRwbri5SNsPijGFFJgLEpRSu -6p9+NtAthU4pCLXTBFaCZBR/s4T235XoSh+1XTXThX8XKIi9XER4E8Ynold+O7qZGzJ6/+UD02om -oYHIZB37lqcB8p5naVMRU4Hafrk7JrAzUjKTSMCfO3bKJUWYR08P3fkS2RxKl0zxmeBOg6oH3A3y -AUC5eC7VflikCrXtslGR2b5KkVEfiruGjGSeXyCWi6lglMXBzzL9DW49BZYCfgnSWU3mlVWb8n8W -9z65wrxdM69ojFhVmpDjgIvpTVxhQQ9HwUE8YYMgCfzHg1vRZJjcFNiA67WQ46vSBJLmQB6SYa1x -MvEp2qYS5nVOdQj5yVnd5Q+KKTkanRFS7TKJHdFj2nodJOymRJhq0c7QWK0C1mBHUNcrj+t+XVsz -baXNAngmwwKT6Rkmp1IWwiEIX8V2YFlSsH3cuuIsIAp0kMsST42i/WFuuyTw2FMR0PTQmm4xcp8a -nLCpHfaW5s7RZJaJWe5SmCnp7qxS0I2QHpvxjjAP0PiApM9aXZgqL/UIxQcvNZgXVHTX1ZtKarDE -KYdEeSgcwg59QOybTlrIzUqiJgcqHoFvI0UVsPKJLsBB9aSwMZgFGIo+fWwEsCe+OIW2XGjHE759 -F0ARA10QpXNKlUToqT0pxIiBTowRA/8TkMHR0x9t271cFenak+yMJfKQoVtJiMwyOP9Z4siZkKZs -AOUIHYsmuXkRFgcuOSUZnGB3nmAEYpg+F6kvTNlQW9IQygFxy5/AIaBjZ/G4nM3vLkQmoZlH9CvS -50kjYyI/ArFzKksK4u8V0PQQ30VGpRq9+NeR+I0CGt7Mt4nfKaCxfpcAl6eEcn87X+jVLUgiMlPk -F+k2zbZ+Av9kZcvyCXpx4Oi0jbJdyVzlVlyeRnsPEwH7eVtSYdrMzm3G+j9LbXqIJooQkxmli6C9 -xBQrom9/OHGuZzAxMUuJQkmNIBZnH2kaL24MiBzGQOLjo2hgZ3viYkPbM+Rklj0aH8qIWcJzfN6w -OIcBI1eQD+ySIcNGqIeiHW9NhYyKl6C0kJ0ZWrnB79bAACtCi4Lj2kx2lrobOhTMHuvr8Y6Shykc -eHjd9OtOwEmpZL2Wsw7ZhCMZXiMwwfDA5LwyVNR4cB6dnJjjHS7ecWALFoSrPCgqow9fHR6Qf86W -o1uvDx/l8Ub/TFf2KpjaiqUwLZZ6F0oiJFoZwT6vqqmflU3xrYNoNFr++9hL6t5zHby7d4XUuz5q -pW3CaHVoPOxGdHTW6ugEXtpDaOhNy9GNtPtYFO06320KwYDknQRf+5C9Ya1wqmLaVSugitIOyJml -pXOH57DnhGwQVL7SVBlbd2keAi7ODwsqllkF/kdjXcaFJg9ZgsAJGg3eSb7g6g0MpMCT5VYNQoRl -d9exeH8abmIdqAvtkfB6oK7boWGJcoDSSoX7kB9EOyLL3BhF3mqEIC6WJYE/W6F2g7wJ6YiAR0EO -v6mwuCyJHUp5GlYzVwKXZr15MFZAWPPjDBtcgfyt5jEQ6pp1nDrlEg94YZCDG/yAFl4Hhai3LkU3 -Ph659l10R8ixi4ktEU3QYuG5tvrxi7NzSeUIhSPJrZEJvANQ5UAxNx1yXV+PajLXDRaiZEpJHqNA -bLpWipCt0+cM+tMmcRZipVRsKD46i0aeynA4bpk8m8WLEkOSgTPmSv2CDgTpcd1dbbMG5W0s9e3n -NlzMm5ilTS/64KPCPppkBaFOau70NUIherO0dTOffm0XGnlGTO1BCCmnkpsBrRbmS8i+5JOJcYSD -QSjAKU5ePWmv+GtjaOKriVWUvP3ERgLmVDXhvPzIbkaXnhFrolsPTAyQJGFET/6psPQUqVn8slDI -aL8s4o6JrT9jrriG6rH4/WNoD22LDobixtP7KmoHer/KvZqkFNhokxTrcPGgeIQLxW9X8v6J9ww8 -uGdiyQksMtwMYAZARhEisigu44WjgswWW+AJcLDbbOuiik2mp7HolrL0GT27PHJc8jRYRru2IqPQ -m6NCcRXYHF6MPHWhrzPm8UORs3NsEzyMZm+MoFLU+JeKLkZvvjt+7RLq42/IILTGHmFL9CrrYS/I -o/Ksij2CwY7zmK/Z0hOacm0cnRH7PoOO70xuBX3yGeL0UZFBmvP8ByyPf4yRkr7H62M3dtsU0uTL -vLtCeQDgFGwfQLq5wvN15sUgsOMAZJctOvaHaNL9N31SRh1Feo6bk2jX/1XPdDz+xd1oMH57BO5U -e6mXpvf2+99ZJOVc0qNSyngqUy4lxdEXIBrCvehg/MIUOhI9/9Bw1HhhR/yHKfSlcXa+ZXEl88We -Gk09XIgfoK+JF8fQji0CAqKpj4ajnerW4XalKBzeuB/tiTaGBo93YUL8Ouu234UMCQLEy1D6bmzl -860cy9k+RUf+Ocjfgy1mKyCKJBXHaCZlYPz9ApqCTDMAV4kNyPSSvd40t9BBLZNgiqwkFrgAFK93 -pqErs0VYh8ysINkExUeEP9i7PdcoZSxhqK32il5+fTo83vYwg5KuSXJd7Cx8dZaSyZJ8HUl15qCc -Z12MVp6+Epoee7VLoVpgN39TdvLcI7jSbFBOwV8ayhQgMgB/ozjP392x1rXeoBccGwH1FnBSiNmL -fEstdy43i6H7Oq3VRf6m/51CBCFzg8zgrJcmAoo243S7qWoXeWYSDIvuBKFFv6TzjuUOTDo0gk7l -R4G9B66dfdbK/KYnh7afvtqXAnZ9N8BWyAqU39pOnbKeEZwvkbDrK4NR+g97b5DXJLr+8f4wE4Sc -2wlJWdj1krJdRj5ZbY8bIZ1soncTrihFk5M6bNyKJ0bRRPip3KvUcQ2zL9F7YQ0/MmkeCON09p5o -dzM+NIqGh8QNoQ0DOhjdunrgWKaNkDCgZWER1jtLTJlxJc9Z0a63JrZK+hc9ensi/sYIKmyniO0S -Wo2DIeJf3o327Wy1tRL+DRb5fX/2CbMx6SLMo1Z4b8YmlDrxy8M/2jU5eJw7HrLLY4L4Ro9Cps3d -HO8UzPRyUvPSSzIUFG1tFUwUamoUCoryk1OLi/USi9LLoo1iwRJKurrFyal5iUWZ+UogNYqTJ2rq -u5dkFOWXK+Slliu4FhXlF2kouVYUpCaXpKYoIJQrlGcCDc/PS1XIzssvz1OAi+cl5qYqaVpz1XJN -PqApAQB1TDPf9wj8DrZ9ZiwgAObb4bMqej66rvU4nXicOxFw1mfDdUYhp9I8vaTSzJyUBIXMYoXy -jMSSyfe5xCaLMzlurmbawDL5JbsBm5VCZolC0WRHdme15Py84hKFktKiPAVbBQ1NBVs7LgWFsvzM -FAW4QRrVXJP9OJQnF3PIT57CYcdUq7n5Jkc12+Y0gbWcbMX5ydmpJZsNpVy5NternGQGAG5lLW24 -nQR4nMVaSXPcNha++1dAPKTIcotanOTQiqKyZaWSKY+dieyZg0blgkhQzYhNdLhI6ij93+ctAAgu -LcnOYS6JGnjvewveBtB7e+K9TpU4/HYukkLX6nOpmzxbC1WmtWgWSlRKpvKqUGIhi+xI1A0sLMVK -F3myFvquZKq7Km8cVfwiaGuFpHnSBEcvEl3WjchqcQxof7R5pcKgBKnzrA4iu72SzWJEgIsdSVOM -IWCtI3gQb9tVoe7FZkTHeiNpoRqxlHn5k8yLtlJAWbZFYSF028DKrSxa2PkRlI7RNHW+LpPwYCb+ -cf7hfYyGldfgpZDoIvFSBP8tOzWy/L5h5DBCkPDhhRA3aj1HOPTnT3nBiGhf/LvOy/Dz5zSvSrlU -MxEY/npPXquyOdgF1nilQPloBkCJqpqvRUJeB7VxCt+qqs51CQo/iGVe/pt/zkXw8d357UF8GMzA -Y/fjZbGxCHcyb85uQQYarZZ506hqJhSukAtKdSd+rfQyr1UI+ujiltxrKGNdJiok6pkI4ziW1XVN -fIY2pIUIFJY1WCuytkwa1DhZ5EUaorWRQC+bQKlkgu6/uDyCNTzwRC8hMBpczGRRK7uu8ARl458V -YmT5NbgtnTOxQE8xfTYIGitRWdshI5zl7+kQUtlI9OyG8FFJx1Q21Zqc3qxXCvxKXODsRNbwk8+w -Vn/M2aC4UOU1JMlLAYHoy5n74sB7JHFzRJKYc9XWi5DEkSUbT3FYzFU9pTrpy/xZXsAxhfe4ch8T -oTg+PmYtxDffwKLxACx2AJ2YRLfT/iEhRonxpjG5w9Gl2opCMqa2QKeDDmKlt1u7VZGL/cuTGI6i -g7lSmeYclzNxBWcGJ00YoCItRegX/ME78AMkm50f6G/a6BBL/alU9yuVNCo9qypd1TYq6SR3+Chq -vVQhLQhxb/foh3cEgUL+QPz11/Q2VM3TIoefZ4/TQZrJ9nrRnN0naoUJ9xjpQpZpodLf1O+KkjOY -EaVnob6qVXVLTuN67OL4waaJSbhhwoCvReilGh6K0Jm4CKBRBVTpyrxe4F/UxoLLyKjJgqDChF6S -uPpOaxNJ2wkh4xhTnICeC8mHMzcgJydUCkDlOaoccdp1Us1RACT+fyTTbWPdgT7FZDH+baGh+Kq6 -hgpuN81P4aTlmQjRf5EvFxewliza8mYs1uxC6VH3UECIKm70ObU2CDqHXSnoIKUBdsVjVekEtCBB -4yDxjDXH58qmEUD7RgIrFhhIPMIpxIfOCz0MU5z5v321xgH5t/WagPxCxaDRBVw7zu5zLPbhqC8k -C5XcYPLb7hQajeykVOPmjlUeKsuOP9DA7w9XqF9MEQp1hvAizNZqHb7RulCy3GpkT7mHrnNuDAdM -SOGDSS5UZWb+toT2t1Fv7pwM4eyp6ZOp9JRUnFvFYeLp1DbNB9bQUTu8fAE/LyMLAk0vJLdAhlIi -ct+yjbOGYVWFu99/G0HBoZEj/YgbNLGA1H/i8AQTTrg/67faXQE8YDnLsR6wh6nAR6eYqMfCCN8H -2QfdqbsxpVKJrtKP0OXr8KrNMlVFvROHMactGjex8Kyhs6xWuLjPa3cw6yhoXLz8UnwnfjgWjGb0 -taCuo0BuA7/H8dIy4PD46ReYCb9/c9ZBvjIWckkh9h+HIkxBsPMP1whUn6cMpr5gyEuH54xBUF7c -+PXF7h8PTAKnGufMnUhkJP1cfS7UtUzWuyuZUzOj0QnGdFk19X/yZgHFkO4FuzD39vzOfKjVJJQN -r0renUGz8ckMoNLZLl559EqVu03VKsdD14bXGUTuWZlOsRLBrkSKXWpihhHhPgDcFE9fFFpqVIO/ -egK7KCpU1jg7ciiqTo4qUm+OdaEo7z5QzcUaY/zjskoWhb772Sg471TdWHkZxRu3eTul4OzP9zJX -NyhjO0kzt4xhCQXxYdMtkV0hNSio3yUMTclVF+h+DmGO8Q2xyzbic1HoVbyE5h9wpCzrla6w2AUk -iqqeBdv0WDHozM5JnJdJ0aYg4vAAouoRVFnArSvoAdFBcL6MFUyuQu+35wmYcWQRDq1/RDIxbJWM -J/8cwRtXZieEdCOewf4/nD8eC0fzMcdzRJG4zb8KJ0yf3+XCG648EE+JbMILXDUD1GUPwY8EDjMk -jU5i4No94BsHRMVAiLs5tFWNbkKeowHFKClH51ypQq6pTyOMH6zzQZuB7WgQwE51qhpjBa2KOB1y -2eKWAVD9jvFqBDtWkOI+Tiu9Wqn0CUXjur2SVSXXoREdTakuvHMdsO3PhOMcsm2mjnwCbcz4Ytuv -zd/OV0qR6sl87VT8inQdy/DT1T2qfXW9ZwSWMp33gB5/fHd+rpMb1YTcf0SvCnTyO8fl9Tlh4vzW -qm69VglMjqe65EsLgicQlo069zfCB8Q1T19hRE8i9oWrc87ITa4B812UZVu32msdUU5er6xRmF6j -2xT18GsdRBYBGn4YFLL2+gIy9ocGGOSnkRqYmQM/qkxMydUKJl1pLiZEBmmbqPxWpTHP9THflx/c -iy0Iwocuruxxb7WXgYYAFXerm95YbC4vRDeOBjosXZYw3vMBeQcvaoqPOQ8rUB3wEvCplG2z0FX+ -p3uI23KUpi095wCNFXQvJ0f4t69tfuxMj41R5ELnmkGWGPLeahfDLhlf97ko0bfwPOOsurD248km -rB8rozjrl6e9PfFOyVtFz/ol+OAWvwFQDIkE9LuSyY19/EIYCMsjQVEhli29YjUiK6BgEQCGID3e -tHXsCYFR/5flUqU5Xm75CDyj4IbMEe6Xt3ENf/KwUF3vjYNBB23FC2sj1JM5GeYTT8Zuci/TeiFv -4N6J734uLLHCmPqE4R+4wKWuY4gHfZ0eDAdfG+zr5Ij2Yv8yNr3VVIiLw1ezw4NLlxJYat5SUgw0 -ozJGwhz6cBPRG7pJ0v0Ii5aFRYI3/F5QQmByWIwQZsJbwbRzDuB+868W5CYw2qm58/2OaUVwsQn5 -YdfD4Oc4NnWf3j/cKwXWTJ98chRnRqeFZU7nopM6fM6o1KpYU8qwHzvKp6yeVMHCgjvYgado0+Ow -5qlz5AcXTrpZfMSXXVjt2RIODt36zzxQuwbodnqQv8m7xyH7Bk6DT9I4MZh5b1UBNYa+uuy4QQMk -ubjstOS45Kdw802iC1DOYh+5i9AuvPqd1nvUZsOe20nRTL8kWV2fzY/J1W+6aAR1O2cDT+tsxWsM -H88Od/8fGLBlCh/o+2SBGXBPFRqoMn3QfuD2D74XwpOJ4ay2XsE4eN1QfZmOi2d0a/5+s8XPVmCp -+avLfOJLTDh4ApT4wbP76hmy0HGl7z2ybusH3SyxqnSjE124Hn+tml/NWug88wXzxpdOG8NZDtPe -3QsM5smU3SajDcncfuxFGeGFFxzbWWeTVJz0T1Hx3Pg4jbl8jIns3b7/CIDOScL9/txophOc5P04 -YD9Zz7kvzTh/+h9R+O1y84I/WttXZFld314cXkYwrjTJIux9oej/O4XRN4qJh+iDI/qu/z8jwDWy -+q8CVvvU9ZUew0Bz0haWQdU3pWvmmC54nK1YzW/cRBRXKig0oV+ChjSIamLSyKauk7ZEbbNKljYN -alGhKSlwiKrWsWe7Jt7xymMnjaKV75xAc6vEGQmpp3JA4tQDHLgg/gxuXDjDmy9/pyoSOSS7M/Pe -/N7n/F7++Hrs+5/Gvvmxd6+PEaaJuxUGtI99RPtp4ke7BA0iH1P46sYYJXCIJjF2B+Pz8yiJXUKH -UZygLRxGu8glPgooTUER8U0Lub0Ex0KmD1ugYRs/mxn7e/GMFw2GIU6CiBgW2h9HyIsITVCUJrCD -2e8rk1nQQ+bMpkFTz8OUGjYycBxHMf8AcJI42jPuOwHxwhS+mkrSsuC2GJAQvIvW+HnTSMk24WYU -d+p7DKuTX91zgzAFA5fRehwNAsqmF09latEZiiXseG7i9U0wbHkF7Y9K0rtukICoOse315VI7HrY -3FQbNqppvC90ACo07LtcEBkUJ+nQEKozoTsl+PEQewn2V8NInKFRGnviFu46hLirpPzM8rL2E5qb -Q6VF7bPashdil8B9llKFcoQx/iqDW83Ckw9n9+XNI+RxJD5EvReppNAYS25+aAnrEBrB71HhrMIg -oRcMMqVeGwnolrYseznTXmjDgSbwM9hfQrP7QqnjQZajbldCcIg7wKN3DrKgj0N2YhFNiC9eGGCS -sJnu3FGvtLDK3licZb9eOsZ32C+Xjo+JldfEkSFmv13+IPOilCQUHCCBQ9GsumFIl9CCLRby+voo -ILwoW3ZETrSsC3uLdYmppibT6zUlcrGmQYHbcr1tvTjSyVsSWOVuXEYkDUO9W8VUOpDpEyXdLfJD -jGP9OXZ3G2qrKPKTGNKC4uIrTcOkCCHF8Q6buDjJpq6sX7fRwH38BY4pZO0SMu7d3ti54Fw00Eia -TiNvG1Tk9YYEJFGIfIMrZc57b7PO2SNf1pLbNPhRQ2e2Siet0omIaYhaghOyrdSqXclb7Lsr6BBk -zfMr1z+HxrvqDpNUVZ4LDXLIK0/BLBVl3nVREkU2HECiu+j6oIi3dOiN2HfYt6+8+SF3Co4lqogQ -gME7tF1ygJnfpq2XNklJ5pydPFUrPmk4+/ni+zcavpFSBcyqn5J4TzncFf2V/zJZd37lsHQju3t1 -6VXEU4LfmzW0w0aRJPUQwObLeL+qQwuX8EQE+jucstmTqxOHrA570rXYe6sm++fqCvvTOsqeLp3M -dNrIenfK9XXunE6JZhFVG5MuCf7TsFUK50aqrqX+smOd6fOtGHRDqKNgJ68hNr94uh25bBd1GbHq -Q9hpFO5g02piVT5VWGsgcy87kl+I6LCn46/zsqrjqLW5Akprr/kPfmzmizh6+kCY7Pn5ty4dhK7p -3nyLezhrtbmakQeprseguvEyYUjiLM/raijq6S0DZnNu4kFlr8rWIKpBvheSA8VBwr3dMOqB2Glx -32SxC3K9lIh+g9jtI7Pz/OH3+sDdNhfui2d+4fGFRQvaOPQ9Iu8COhaGZtIPqI3YJ0emM20qNMgb -OAx2FPcEECGCno6gpyM3xDGYspUm8Cy4OxgF8AAXPFaCAX4IRJj4AXnkKJ2NGwU4SBICeQXn4FMm -2UwRM0lfFKdRyIE6+NXW2MlPqycLfOGp17DYU3K1oOqIiZc405GA57QtDrB8QKlJgTwApuM4bvyI -WvXs0wSlSDtlFWw4bjYchnvKO0K8hC1/dok7pP2Ik2WZ3+Y+gtukflt4GQYQvEZ8zs0aQCv7ufUy -P52MDx24HoQqdEFfCvhN4iHkuy3NoqU4REwUk4fd47VteKpOZ8mtwQD7gZvAKyGjZ+lXRJVNH3jo -TdDEX1TlHR3gMH/OPyvYjCI7Oc2+BwHo5HOAGm3QsiT9ZyXrLyKZzxl6IBDsZX1qOqtg1+MLz/fN -Sn/PR5l6x8lHmjw7K9BbzBuVUWcFbD3zFaihou+mOOWsJqCa4chygdoTVS4LFH28sSFSZUNSFuUm -oDpgWUBgQi005pHp8Hq7E3JNcm6le8SDMZJEKQ33UA8ME1foqoQZlxMqhN043HPyPBMT7JbiNMvs -+ZmpDOhWEX+Z8LqGC2dYhcdUBygKvBpm8GG5N6u78sON+GWVAKrXqC2EzS1OOzfcXRHbT6Mk6O01 -AjxCOIS41jNLZaDqSIVNlcxUg1wX3dnirdBxKQ0ekdKkZvDiajRmObQZlo32ES9RIOtr67fW14Cq -W2gJ3jgf9wKgswph1lIT8mbrf0/2kj5uhdDJbs6feFEHkAUgR5N8CkRFS7DbCsluTQ29Kv7lok4u -8YrLVJblYlWaqZebxMlu75F20dRhiA4IbGmanvcWPZHzQw/0lV1HtRyzTqW6ur3XDgCtbgjxvKws -sh8Ov8suW7OzgjcVLhYAx7l3+RWmdDK7NjfF/lqYeDZ5uXPsX9oeHI78AeZEwNYQU9X/QdL4M1Rk -lF1i5u9AeJz7wPyBecMdRpGWtS9bGJqeSmxpyWw0b/rKeMJHYhsAxbENWPkay7Dprho1OJJbvc97 -i0huli4Zy5N4nG1PO07DQBAVJRSUgIgihi2IrRiLnygSUSCUgoaG0qzE2pkQE2fW7CcSiiwqLsDS -UHIDJKQchANwBypaTH6kYDTFvJn33sx8fi09fy+9jXi9h5hriKXpQiIz2ycQWSo0apCEu3FZtVkA -Qt9T4l6v12rSqgThBKIVmEYtkaQNDOEGzZnIssvUoHZyY/OhFsxJrGMpMakkSERurELPLxUTZUeJ -/q/lot7b96M93gSFJZkgGnPCLCW8sP0YVTBRhZOb/+vx5ioUbOECV3Qr2/Ptvt+cD3l4K1Py2BUx -/6m648Lq+pEeP8oDQBo0ILbUokEA2rSlNQ1geZojG2NUaobdS/XxdDglzYZQ+KGRrTsrMm/4ZxAd -BIfHZfJy6YIPg8J9bNVd73z5fcS9yg8i7otC9wNeVyp8kx6ZzkvQqdSmw/F7t/FX33icATcAyP+Q -BJAEkOYUucMbPaODse9+Gk0thyiI7Bo2qu+R+s4Uq5xEvo8V2AklMmkdTHpsOWUhu9uT3AE0wUMY -rvBKuOwroXhAMtpXDsw1mnRQ8wFgTQ14nIVTQWsUMRilh/bQg0X0YCvVjwE1I+P0IqgtFYtUKIir -ULyU0mZnvunGziZrJrNtWYbFfyDkXIvgXxAPXvQ/2KOg/6Hg1WSS3U6r4mEgeXn5vve+vPl2PPn5 -x+TbX3dZtyekggEkEqnCx4Ir3FcRyJKvcb+DCjIpuhBwkeJiv/vm5OPJxFQyjJEmHbIxDbARUHgu -xf5BEAEJYfkhcNxzCBlUEQyqcDNq8kBkQDmsSinkX+7YVX1GAkXlDqogbBQxH0BAhyCxL3YxHbWu -cVdqUK8BEsEL665nGZG/YPwsuzuxBRLaznEkc8lfdEzS2KtSclfHYdU929DbcmOMu6hojLw/tnQO -N+zNUK8czz1QHSn2CsiEhBtFBLSAl/chFeigxjS3IhDtV5go70vPfL99x2xJGIaxEuu2DqkF4X7P -4LFj26ejjDO+Q/TP+PoVxvs0Z+mWmWbZRa4CqEIrXV88vKnfHV2AAlSHKqAS+S1l1tgtMO8bPV6L -/vrhUivxgVg+GxfiB+emzXgHJVOFYbVqLbEjkz8yoY/0/PyIXlfISp4oJjhk3AxwUOn3+uow4/WZ -80fc0y4swFNmnvKZiWRkksOMYgkJzXPwo6U8HeM5Umdlu1A02d2279hDqQ6gjR3G07iuuZOLNs1b -mXf1xGR+jRdsxoS++T/oR8dzL4gjr3eYEQ7qoIcm0adYXPcx7+cnFkb/6tAqVcFMB72yNDts/nUm -+qZQo4SvMZrX4qjrCHA9HSnj4+OMnx5UNjKrr0ua+zGeFTQce7aWg5KnmDGOafBf9TDmnhcZFEqa -FAanupqIzY39phUWiuhrh7OfLqcTX6Z+Az5MiTDwcJfsvVFbFNlmgFu1SZFX2QJ0FJ+UeJyVVV1r -2zAUfS8rjL3sZQNhGMjgqH3sMrqylpZ1D91DBx0LYVHsG9erLbmSnKQLxT8if2HQ1439wV1ZdtrU -brcFElu69x6d+6GTm8Hvbz9veu83ItChSsZAvV4P5rnU0ItDLyDUJ7tvyWKDEK6vREgmhQhNIgVR -haCMMa5i3SfaqETEg6G//LX5/Ay0JrtkvxBM53wm6IKEWdQng3EhDudA/YDUgcOAgJj2iTWIaYAw -kSxMn3h5koNXrUGpZr28fLZXIhH7yZUM8RjmIpiBuUHcthHDHzDCPDEQud2h/6Z6KjCFEmSxItLA -qySztLVZ/njytLTO1xv4Y0AbFkoRFkqBMNSb7jAN5ijlsT5SMjutyoIljJMpaBKH+GokMedAMMry -0rjghggZQX+akYxfoB+fGFAzriKNNXBlv20DISXGakNsv3KDhR7Vmbnt6Q5uKbgsEoXNdMA7HpJH -+JYh8+rMm+hzblvnTptmDJt8LE5gduDYUs9c5VDKCaZyP3IME6kAgzEsVMANNEGL63uuqYzRb4Bn -UX/YmLpLtzaNNUxJLALLC31OK4yAWFqWVSrHPP10nmgWh8EqgTX2jnxQ8/WDzjTtYdT3u7mVd8gJ -2eZ3n94DMK0Uv/4jRNmJIeT/oXSCaMPDi55OvsPu6+1t0lF8xDzuBrW9lSkwPJN+OP14wpwoJJMr -iluN38g93CAs+asXJY4Cn/HEVIri9ap7X412HYEUIDTUXWafGbmP49vQ2doiZ/YCneA449VOhNHs -blRFJOdKA3V32bcIh5cFT+mgmSavEBFMEgGR16iE1+jc7U6HU3tLFGn6WEQb9t3fvYbrlbDKdYD5 -1rXYXu5tvvyMiuxkJcu4iEiKgI+pDt6CRnOMlJ0y81CLGpJr/xOrzXz1PmprTbee1HIycoEdXf/S -avut1ba0Nq6q9ni5KquVJPv9A1uSISb8BO4WWd8GNX2YsVxcuwUP9BiFROzueJwBTACz/8wEzASQ -FBQeV7MiReSlT8/ua/oCYHKsnU5JWZEoURQ0JP+TtSh6485qRKMnN67bOWtW5LGNqwEU/h+txLQ4 -5WDMbT3xvXYvUnAA1BYnWyNH/awKF560hiAoAEC9eAhlNzH2q6fLgfV4nK08bXAcxZXVG4wtYcs2 -liVb/qA92GgXjddaSf6SLEDYBgzBBtuEgCSk0e6sNHg1u56Z1QdCGZtcKC4pcoQJNBxXIVd3qbpU -Kjmo++EilzvgflyoXD6cqlSKy0ddSO5+pC4Xkrur/Ejlknuvu2emZ3ZlAxVXWdrtef369evX73v0 -j//R+tOvr33lHqLdTA2X1gxv5qQxa7o1o2jSslOdpZpdLZmD+CAYIX+SsdyPf5Vc+iohbw0H3/5u -66Vf3E70QwdbKfVM18tq3oxJHdOrO7ZZotWpR82iRy2X4nCxanvmgtft0ulKdcqonJ2xGHmY3L9p -CWbjP7foWDUPht1B9ot7SNc2Ojw8TIvegi4BonkA8OrDZCv7r3NktZ+GcivVWm3xjrpd9KyqzaGp -U7dP2EcFAVktW5YPaTZHlyS9QKPlDtHlXDan6Ygvl0Zs2a5VMs/OmBKRQMt2jpHdD0YwbvQw+phF -ZCFA0TENL8QwMm1Y9mByLKsuzZ55hGz1FcZQz6mbTfiRGG/GAfV540YST93UcPfKlMfzlnNDwVK5 -f9VA/4GDBXafRbJbmshBuVq3S+wzFtHZ395J1rJ9j5LHr5lyDJu9+ig50oafSkAenTMqdZPRl0gX -+3CZDLAPnyMjqyUb2KfPkaeiL50Vso/NjpLW3SWzWDEcA7fsUsMx6Tmz5tEp05s3TVsKFwrc3exC -maxinxoj646LOWbpI4ZDh2n/EI0kI3wSclGVFHVWDy2w18bIzqMV04sefBg+D9P9Qyjzbjx8lH8b -pgfgQcVwXXosfMC/LbG/HyM960zYvKDnYHeOfW2MbLvemq1VrKLl3ckPHJ4cYpfKZMeNYlMC+LCW -yyfEHOVoqJWtK5EtbHoTWe9Tqo0qpOtN9qirW9CThOvUW6yZ1XKSap1KenWapFKnEXXj+Uerlr0B -L5aUMcqF+7xJNm273cxq/fqAvl8/oIfc1w/qh/TDGrt8P9nsnzMXXb6ZvFt1vGwul/eqx8/XjUp2 -VGLT0huJ1tGU/caDkuJ4IEl5PI472Me3IMfGgaP421yogURnQ82lrDLIzr9AOthN58nGe9XFIwWQ -pnUQWZFvchQSXhKr4A2HYpxJ+hXQ9amdsZEi6fJVckGq+WUbpP06nXcsz5iqmPJiU9Ouz5qOOgIC -Xbam63KsbFRcky6vvLWB9C5wuZxY7+DV12P7Pkk6jq2wy5jyQ+8R0yqOif3kRuDOy3OkjaburNT7 -KGBnZ5zqfDa4/KGuzTbYw0GqnVm0PWPhuONUHY0us0/OkRsZ+TjpuDYGvUuCnjbLpmPaRTOEznGx -ARXZmjCUQn/TGTC8dhXUnmc6RdBZVYerqeuFXACNuA244YUhdnGMdPp21TumDkuyhWQKjeMuzk5V -UVGc4R+ymhjQJBBeJzT3hr2YGxWPxgG4T6LwFkZ7x7k+bCbs66fqVsUDGzLimKfmbSFtPvcaxDW1 -7GKlXoJv2ojjGIuq6APVZmmQjibtsRhXzFm8bbk3nWrxEBoIGBwP0SI/3jtqlXsx9sRoegHBoUHK -7n+ObGZbzpO204KvbjZGHHoNnHVgvcWk2OSWzIW0H4IeB4CLieJqpnibMMzxHoWM89uX4EIEwB/p -fHbDLpKeACerP7ThQfbRdezFedJ2Pfp+9zlVr4pKHy4yiPx5j2xnrzhgO6c9soHZNbJ5QwIMNsI+ -9wTJsonnyGr2mxfIeqORP3i7QOfXwkmNV+P2ug0y5HKhy9GaAxfDpRb8jy81jFZrpuNZJnch2c8e -I+070ZIsLYcyjrcH7JM1jR4I3BL2/cfIrr0cZsymNHw0SAv6mM1nKfdHKAX25ilwVG6Zgc1ELoOf -dBn6htJKBO+NFpvOpMFQtxZBSI4IuhK6uS9BGsfREiEJCu9s8lGEkLEJD3Ip9LWtsoU7HEANlFwm -BRCukzoJkKkZy56mRcMGRyqijYJ/ZGB08FjGtNnnfdLOfnmSHImY1MIFoLfsmOZjZpMromoqFAGu -JulwUPjitk1ShZ4Nh1HXohvQYrl3wIKmnWW1h0B/+8fhVF6cI+3ZOTiI5KEUGhQ5rhKQQ1u52u+/ -opO3vNLkTaxtgbTtazzuwtAKRgS4XQh2XdMZ/OQPq9nFLOnMZ4sYTFHXA6Ge1sNTGERFrNNqjfuu -t/KvEALcwpYN0tWGENHDHPtUjhT63x8eapvzlD2yK7Njh4SM8Um/Bn+Ns8pW0rVXiqrUEKCxshqy -2BA7jXg3xZnFzpbIza3cv+NxE5ssk64ugTQUOK5w4OpOmY7O3vgU6dweh0YcfSwhIQY2Mka6OrOc -eA6C/kO2u9AdrrGVfdmAH1t2k3XsW1NkdRuKeHRircGGNdSXonQcpkaGWFImb9S+fXSEHjt18uzE -Ufhx/KNnT9zxUMjM0Cy7EJJMVRfCIMargq9h1MC7rQptftKcDzeTw5Ew2C1tNNGOeDOGF6Jkt5XJ -UV+wMyWxzdRIX+K6yGNRnUWYG4pZEoizbAWZZJUnyMYPAQR75xxcXPs4uZaN3Al27bVpsr4V9uAZ -50zQt+zn02R8I6xmhQYL6SywxeNkB5ucIWtaogds6x3khi3ZSOaT1ATvHNsS7Ni5uguv5ei4Dn5b -zXBcENwozuQn2iI9ErjwA7vJwzsjLTRbLdUrQBLKQB3UHLLVYu/8AagfexDUzqfrsIXSqszOoHpp -TfD6f69hjx0j29bTpfheoH39yqrM9uBfT+xkh39H2q7hniAMdbDfrsps6JOMy4q18naUA5FeEvC8 -bNQrntwi4Lu0fok8v25N3jSKMxCJsJ6L5ETnqGYkVKuUGnbLRfDblpZzcM/Gc1kAmsIAFYJwm8M5 -uKU9KP3ZCZ3OwgFI1vALgI4XSOq9FgqxSx91S9VZ8HhnrOKMVPzCPBrFoum6CIJRNFjlhUUhgSat -1j3TdyB+NSowFQZRc4A0w3bNPKCPbrVjFk1rznTQnctatm2CFRJ70KNng7Run7Or83aOCp/QKtNs -+JD7PnxiLgyX5f32+QUfaj5DMRLRtJBwR3kq54cpGxGQhpi4/Yqtl4NHY0Z8WQWMqdrsay7Ew7c5 -5Nqt85Y3o6DGo55EezrJ3jlJtrG1T5Ctq/hO2F9eIBr7WYVsDD47s5G9WYVv6AoeqCmej3Ako1wW -5+9g9J3SaRMVBH5nj8ySzj4NBqhGe5qwXOe5qJy8RdwzQ73F7psFw1eaJRs1zb3aZPadnRA7JzNC -KXIGaWT3omEIemt1d0YJ1GFEcjuZNUOwLF9qiC4r8LlsdLKDo7GkoCKXw26ez9UEUfRKfAjHwHsJ -V5DR5jKreWTHBgkXHQT72BjpeEBwfyiUj/CrWHCIpvJ/3XUIYgVM91AEjInA8JsIvio22dHZJPuA -G2D0GGm/Jvp0nbK31KMH8ehUi6ckFhLOVw1cVNNNCajIr8qLA7bIkPdcEexV7Hi9UXxbpLvlGMEz -M5uZe4Hs9Wt86jB3DziarGc405j4CeUEhTYcO2cuKgeiiBJeZslpgOHXWROeiZbDBWvywCeRB7uX -AGYZfjmmf4XzXp5UpF/KH4TVFVBE+ZWJGkrKCMh9GpRnDOQMP7UPlVSXk3qG7yILM3OC5A9IcXMy -RlemfFkOgNo/CycuMmmYt/WMSkVIQSTyaAkgIrI87n3oKCWWzW79O9J9w0Bff39BKFykNi8RwJFz -14q9AYpop9zIKa7l88KgZLlo5BL5w3sonZQIsspW0ZlxTBdsowt4R2VAuLA4HoMInKXbF894VQdT -FodZ7c9J54bkODh2EDZ05bTksKbqwQg7z4EikuuiITl/rRaNaDk28iWyqV14p5ONyUcf3dOD+mGd -u6iH+C8t6UpxoVAuPb/tMRkJ15Vr5dRmGwGUydfFD8fZ/k+Qgz7XANwtLS4W4VTnq/VKiXsEcNVn -LRfdpr3ondBKtXquXsNfNVqGlebwEMEpRZUs/FALozS3PgVniQaQcntnUM+aNcGs5ltRzeRBLRTr -jgOOCChk84DnYbxnNCvWuIrIgeaBNWcREMkMyj/bw974J9LKagOZ9c+tAVfsvl+tYs/8G7l2neF5 -5mwNVShsPli/vatVXg74yn7dSton0K1R76F8buI498SiyyHuhho+8uVR8MLpGnhCZqWsDQqRD6V8 -QEq59EwiJ0VXptEiXKRSeuZdTe+HwLMSommsYzTF5jfF1hR3M+QTE/wMJiYUvHSuapWomJWPAIAl -zbDuiOyoJpWTiolNzF9lw9FsXhsUhSQVg6CCR2saexP9lX9+knQdUty7XMrfi9ODnHUQGoAshihZ -7Xim/Voxxi60AbpvXCDrQ5UlxhvULmf07eJh4sTFUIORiI+syeLXKQ9iCvqb8kgBzTUaA87csgKz -Aosb6fMgqK1Pw93FfAzwWV5OoDO0Qnw8ChbAVXz9AunamXjYnJ57+cOQS2krpN40UPvVeZ5Ki66a -YcvYIMGxG8TuEBBGAbvFc5KFEB2njV75COkoe/cF0lFqODw9smQSsZ4QuWhYy43LpEQjO+16paLe -y1++QDq5rN4uiUIARdTnMYSfN0SQJTcnF3JFjdxKcmBjzIFoz1WImjEjulblNGdFezNW8Cer5ZNg -44X21eqp3ZIU7ubHBgqaZmU5IMxhlOno3Gyeh9u7wMtbHo/1roDkliZ0DyZuI1vZ0RGy8XjoSEs8 -3MWTR09vBTx0MHwWy69AyCnknsF4cPmhdt9VuJKgcRQ1vY5WYRzplFcDdulYpptdovl8Xih7HT+G -0ricS3iifDHhwuFOsslrCE5Kn+fyhbC8IS1TVqSZ0EeT8w0vu7eQE4F4Nhdc/PbO4GNvr18jvZwc -u/wWxH4SdtaoZSPtJ9kkJFJa65yUQ0EJmySZ7PNvklVB7y87WO/XSBub+Bw5uJGGZnmQHuid6O3t -Dd55etEXnIm9K7HT2MQpaVI9ehSZseZPE7apEUS1MH7j49hoiBJDaxNj0HzdSLdegawIRiD3W6+i -/lQaVGUkUo4FvRCuIK88/pIj7+VS+1pcLeEiK85DeF54Hry+FVpvXqcOZSRfMe1pbyaXL1vgLmt1 -u2SWLRv1kqKWJDoYR2SuV0K3zK1VLPDFxmwtdx+XLnyOwsU/5MH/djz3QXDlstoSxFe30rvPnDqZ -x4yaySFycBf5b75EWLsTqzDyhcwNweUnVu3jX7FaJujVw03ptHFEA+f014czeTbzNtl4FOsusskC -Amh5Fq7Ic2JSC/CC/gUPsUpLplmrLFI8v3lwFU8b9jQ/eDZygLSzyYHMDQlX0VdQK1YGHO5GD2PK -cKMiFnrVK/lDCIep1JwKDLRgyIt6QJ3nqxPLwIeZ5ExxhCCGUaZNnR3GegLqPlGfWgwNtBZNwfyn -zAUtJ+vpbPiTpOXOhuVEsPg+lhLNMz/4Nhl4IHZxbBWBJnUTr3QmPUwg7dS8HeI8ZorQM7FVUfCN -H0ULh1hjls0YLmBTl5aXRTyIZuIxhdOkccB8uJwFHEMAxYfYt8+HEKkCQU8FjQXPFKJucGX2uoLx -jnwAN6Z4DuUTFATwE0a5SOl0qu5h1VSI7my9OMOn5aPVRzGmgrCyYs1aHhqM0UKvTk/AgdmWVwoD -XG7CRPK+5s2E5SD8eGRYTKU33URVHRGLeagm5IyentiY8a0Hn6lvYrXbyBq0wlvuCm0ZJlzEEnso -pzHH76Fl180mhpVHi3DO8bLsle2Z7R3xd2ERxWGwi0+TzX46JBNr7srymEzkIewimrroTmMwJC46 -hxlSpsoafHq9oRR2Tif3LKazcD65Jvznm9Yle2+mfb3Bxokutu8l0sK6DmVaD6MSx/wGHvu8sUhL -1Xl7UNNX5D5XxRiXB5P/c9rnYbc7iwiEzPCFeVBdBnURqboqkFUG9wMsRJ6OKIwVkuSes2quInnF -GRN+ngNdCFauiuF1zUDHyBOSZtpz2MqSzwcvPb1xeNZYuM90zs5ARFA6g9MfcI1pE5sJj5lT9Wn6 -+OPwceTMyElQ/NrAfnAUejVQ+FoffmI/eiHz4875plyg7MKRzC5WfBsimNeOZNYPDKqKrDtMfWOT -nhLxg9jwQ6B3nzgLHgp79W0yxZ56kuxhz7xGrmE/fgtE8zvvwg99hKzxxyYTWaF5pwqbHaa9yWRR -uKai4/Gf1IlUi7Ox2pDILSIlu1JFAo68p2coDBjg1p1Z1hV87gfEpyABZcN+PUR2KgVKkBXgJohM -uAvFX9/Gvv4k2epLYYuSJXoyDoq2v6w6p8mUtLINfpGRbRbnJPw6Qgt42PBR1RfiH9C2l/bEyw2l -n9Lh+CF+ZsPDpLM9pyb0OCfGJtnICNn0IRktdFlA7KRSKxYVKa5rPct09tZrdMao1UwQKTSvZWsB -8MMi8mKgxgCJRuU7P2PaJs9eg3hyseLCDk4XqFV3Jh88/bQWtAYbMr1aUPjfP2Of/xFZzdr6M92M -fiHTSnq5HMd5MjdOVulUaaoSibMpk/t3uPEmZTleJxPyLbNpYlZ0waNLnE6WHU50cPGrAltL1f7C -QrLlcjMjvPZg3cYd7FeLmXuja3Qt++hthPI4ix2+jWzi4cV+YHxcJU9lBhTl7tRtHtWJGIbZI+SG -NgGtUzn249tIV2e6OVTAjKMlyLKHljIbgne/tYV9c3tm7bVmHpsLWGEYNMXjRqaF/eT7RGPf+ApQ -9syfZs5vCIMS5CAKEXt1gHQOYppaU7d/SoaHhjNdn0WVNFt3sR0X1Q5sThIyZk+yC4czffxwt3J/ -HjxfXg2S+PlH9hdfydwYHfpxfmTCtQUI7u8gl7lPfxJLmo+6Ui+AOS9xR2XKDCu1lI5qPBsrktxh -fZMzi49wAR/VEtEAgvuN8M2S5ivWeFHy1U74hCjuccNaDi7lmBV+cXQVNl+KMjzSsmPLFw8rMGQX -7Q6i8IKAwd4v3uA370iE0BZ0EDcsk7uXEGY5lFIZp0wma1EydYwVnEleJ9HlveFGG1zlamUOVYGM -1HCTCKUFzul2f5p3M2Qn4koyGOKQUvq4bEzje8tGBSTDdueB5BLmFwb6KNacJWm5hvQGuHalCjAY -LwJ3rkGJCy9bh2c+xDniKoTtqvGz6BGGeVRNhyjoRZkMkceFMvTd5bJw0+LxJhCtHASL/7ngu6O5 -dvX0wzpLQF7cfLRkOcAda477qKMa+iWJ0qQ2nlT3yUYd/o8Zm8hmM/wGZxvhXKajIUujRu54oG43 -PGwyxMPdcWkGgi8tbDuJH3Kq1VUqJQN92FfJ2340PT4+GIyj4cSXcXbeyGz1l9OFUBQ+iIxT8sdb -NELRw4IEFzpeZOt24/5AftGVzOhKYhNKxaAfkxqJisgcYGVNmC4+rkiPFKzm4iNo4qtEjILZZkUk -RWPuCWVyR6hNFBiFxYqAKThiWQwB2XefJNt2NoGIQIQ45hLi2FgJjqZxGfX/CDKabIJNySgSHMlb -4osx5Zq27yWFUVctMOoN9O1AQkO1uZJsFlTRTMpjOXqHQLTP5lQfij07R7qGkzRzwjxlzbgPLVbQ -YA84mJbjQn6sQciLWNhFHLM1fEdG9qei4eQl3egL91lERIWtrx2+OKhBetosVp3SkbAlUDZe3MKj -5yKg9LBxB/btzVtF0PtZG4UaOSA6BDGcSib8r9AdEJanAZB1LZN1zXTaUPDmyRtbwqzwUFxHBvU0 -mSoac5qyA+izJFszks572PXDoffnRI+GWmcW26Q92O6LxeFtciTXANPTwwF2rgiAgXzvijCixisa -4hDmiBzRw2C34XsDDrl90KbBlxc62aJJrscXGTDFAIqzX3wqFHT5QgOXxecXyA5fyn+0gkTN28gV -CZSSnszc56NZ0YCcnap685MOH8qmNzHFF+l/IR23ApVgm8OGP/DNzoiGGXQhadWuLMLpVR10Daor -uT7dwj+PNXY+8uE8pDZyjFD/zhh75tBrsKu2KeJnjOjCusSukLBccLFHvOOxNdndE5/u/uD+j2z2 -1RsqnykNB2ntlWzfV3BdpadIFcyhWASHqC+6jMKVG/WWZP1BSdJya9qICUajLhYKhnfhys98vfhr -T0+Dut4otRdvmh7PAXL26TmyM/iy03brldVYUl7CYd5aKA6D+fOkq4V7idgvw94ZJe2FZpYmNr3S -mir2N8ffs7kx9kX49iKkqVd1HmrSPN7k1RtYyjNll2TsUbjUNc2VZDQ4f3oz+3mF7PnolDlj2aU7 -OQrgWkLxtaZNdGzvk4kOOmcZAkUU7WNT4O7gLX9dpjAUFHZ3bFccg6Xos5QL1AOnIxyRSYxGxhte -CVDJzuWaW8Jx5thkv58EVTRJrIeSL0tw7kVNoaPjozxXN67aEoHzLABelWfBD9p23YvJoIkrtJzh -P6VdazQByPVTvOJ48LrfoUWBhSyegepSiBqkfZzr16c5LcxYawzKVTAw+ix3QmPG85Waq2DFD06r -2VRzkVx7VJMItdQrPPLBbPrJeKx/z64QXwrHtWIa5zCrl9TGeXoCA3pMwkxhxlL2GQrXKs9GniBd -vmBb5GOldgoqCslpIhenAS1c7HSw10RGQnd8uPECLS2zH7aQ60tSLBBxUhqipYQ8cADVbws9By6A -PMVs8sq1UDj9anjJLu8k7TR6TyAtw3cJKrk6O7KSOoudZoEgJk/k+zGVx8gC2TYdH3QCfcjU/iby -wvGUrQpqD7GhW1Iby6X61bB+d560n+RQPEfNM/Vgdx065XCRMDBHB16ZZWBbgQEMm6ueM8MuctSU -htL+JZq+QCf6HJEtzywuBmQ1+WBqMU4GJN/7wef8tNXojMoagpg9pNaD4nzXMI1ef+kUzm5DYiZ4 -2dl8OPlWfZOo+0ovIvnNbIn6IlbYN8DftVBjEk1fKUiTVi7c+nJOfcmI7zg+7tHoPY7RlQKevIyP -wo/jV1qZR6ty5eAPx7ew7z1CNviFULMUmr7fLB8iGdFl0q4Wo6VCtHFt5eB1r8qYpmVHlVvYstnl -v5fQLWWgyvzFsbgjTr6YtiQIFBF24/szjYeJeHzTTrkrhfAgG9/DUSSkObYGZH0pqQilL9qQz3e0 -FIq8vKe6/ECXYZccfR4HilhWTklCuFUxIbsiwSmRlgvlOpoTx2oXSEchWqehRXOFOJI38fvhdw7Z -5CQaJY5bWg69givzXreFSNam/cjwle9Yn+HlZ9+5PaOxvX1kdVV092u8NUJI96gmo1SdTiaC1knx -al0uq+1xhbMuDC0vLcjKrEilYh0FC0vuol3k7wFFOYbAuHiAPfIkuR9LlKdsUxYpeesvJrUHseIS -hh9cv1surSBTdVTxmFOwKqDMDfyjHdQoo+tqyPLcdN3EP+JgmyYQNYsdy1HVhgdt6K1Kb6Fi+Kgn -gcy8Ei1HQcgwHZtcsYylZkzU6lb83hEw5S442WzazcNUAY+PYIHh3qHEs2bFMV4JDatjYiKEQSg0 -wRv+Zp+PqFiaksOzMcDpK1LzfonBSHWbRffQAwPcVvcq9EE4m0U/9T3Sh1J8qnxVfr1/CvtpVqUQ -WxeUaydcDHnHJPU9Pe+Dr4LuERmp/hEpH0TmrkB5GOIi7Uoj1gcgn0vpFaiPsGNWq1cXrRDue9jO -Len9JHGLLAdur9DbFwlPDMPO785sYb97ObNmHwIqG+YtTQAbU9bTo9ISGHdvZ799OdPKqp/LrNqd -j5swUiWjnNxMTw8b/3zmSPBNv8VXtttDNSVuxwKe3Ds+SKFaic1h66+iC3TlJuoJqYdvexPCpCdP -R0kLYo5lbBLT17ubp/zVN4vo8rP+5oHG3GdkRHW8q4rtj7z94NVPdLHL75LVvBniGl5ExRq6jy8O -iXKejEBdbRliD7HGYPMXb5Jdo2Ib0QssUTz4nmrw/R+kCE9/cFOwNmgLnnpyfdD2m2vZxJtkPVv+ -68xfBZefaPNjZ1AIrd5f6Nuv/OhVZKFw+EBKAHiB92oocFqMpDeBIlN1nv3CUeN9VliT3Z0GFa/6 -0vhVX9k+GteLgsIDdHvqeNQ/kAYe6WfBIw0ddDyxq7nCzfIDnBVK3UF8VzzbJgDjcXcnW/os2ZDF -xRuD8gS5XKQuPfcU+X29H/+GBP6tEbQfnlU8JxwS7lGAIrQqGO5V6tOW3Y15Ma9ey+Yu/cPviUWi -bs3nHsrcFXT8dP3DWoxriWK/9mKtin+yY5COduf3LeQfdbvHdYkNB5eocK+6uQR26wJ/eKNkgW0c -bq3GXvl3ckOHCAXwrsJCegjAXv0hab9ESOaxv+F9qXfVbScUkaj1QvwdsGnDmTKmUSgqFd4xgH3z -+CdqMCMhHBvwYbA3EA85qP5s+wrvMgXd38teH7s4oj2cLrHzPyS7gx/8Sys2baT/EocVxRbcSKQB -ZH8NZbu/R7asLfDuUDGFXdyd6WQ0R1rYi/eR67qSqOSrULxxh735FulgW0bI2uDh7+/owOT5R+4V -fyRJCC+99Vb6/H+S27DfvIW9dDPpZ5ffIXMrdNXwThelV0JpS4j+mESoE8uW44L+1IB5Gh4k8L2E -7dfzVU0GG2EzxWyt6nj5WdMz8qY9FyFLjPv2nGyeUBp55B998czotUdZJuAdN+A8L1RBgJvd+MH4 -lXqlZSNunwA6KK8XYEMWUnUIuat857WzK24RJ4DAB6+f3LNNrJFNZhUqFnZDs4lNZAvJPr8709Ei -6tbDdPTZFzv8sDdT7UTjACKPhR8b341ZwryoO5joalQQ6FhOuYdDhHZNDiShwAnpPIFVQE5Q9EoG -yhT7v/UQlsm0V5Xnq0QklTdQj6HwQiSBr8aOapw/4t1GZE069BIMiLVdSDyiVSgVX4EkpIgvudwj -MvdoksAHWJTuTvJ44CcHulT/YuZEy/8DXZss5/ACLA6FVf6EYRjqgBxcG5eL+JUNeTB4nLvFdItp -gxijCPP/I3Fe7xrcXt+NnNCT7Sh5f//TH5O1GA0A8aMPIfQZ4ZbC1RNkSB6kviDsSrz5WFmFHD94 -nH2QPUsDQRCGEQxqAkI0mEIDkxMhF4+zliSFCEGioChWYrFc9twje7fxdkOUGNTWTgbUKq2FFoL/ -QsE2tUW01MpS3EsMdk4zn8+8wzzdxL46sYeV3o5NicNye8bu9oZhQeRAuEACoRgNwfPrnPo0UER5 -IjD2zZwhmWjwKjRFWIOmpxgQWJAaJfI4cKDmBVU8qyylGiG31ZEyzEIctHGqoIGvlbnTQe65kItm -IVsq9VUNE1r9DoAjAqmgBSykrgX1UCjhCG4BE1IFxKe6RhSLImhDCbRS4ZfUoS78S6b/UCJBCw/Y -NmZnitgpJyYZ5VwMz27j5UsKu29J/HweT7vS1jt9T1JpN4nSf9OCpnmdWR9Jj9h4vzaPU+/TeLU1 -Oxo18DyVwZPlPOYXE3h3EZ8whk/BD6uIt4dJ/C5nsLuZfFztjR38ABezh138AT+qHkMRxcx+KHA2 -+E5yJyUM/QcCeJz7yPeRb0Msu0hK4eJQnZCY4J9BL4Lq3m00vrzkiggAtMsNV/sRqoH11ml3+8VH -1LWCrR4Y+2CfjM14nI2OsUrDUBSGqd1KwaXuP4FiAodOThUdnZwUp1Lk9PbGG0juKclZQikOIj5A -BlcXcdTNUQo+hg8gdPUBepMncP34/4/vbTt8/x5+LGg0sWxcPBsAsyjNcjuNCM2Ojg/n1LElK3ds -+Yr7wOZJHKmzaLeeCwvDHgsLxrjCzdUlJAV7CZMSWbHKbWG9smbig4Sr2hvEt4Q1XGlTwqoUFSM5 -wUmlrTAwVtepNwnOzrEOHUZ8pWhe+qOL/zwJKtdaZv5uiriTtB9sQkDbmJwOGvxEzePJ+Pnrt3f0 -UNNTTb3Pmg4mf3s6fl4K/Qvq9WxqhGgVc+YEfH9DEmukX1XQHHicAb0AQv/6B/oHkGIUGQWvIf+H -Xg4O7NS212IR/vqieb6RdjwU3GwnBLum8yVd/KvirE+8N/btOPmRxpAULayPArroLxB4j66Lk3Cn -ew61Y0WTagEqFCy5nYfwOlBtWEnuHk1URdWEAssuk6gB2xQVUBrz/0kGV/RS7TOTcPuHwX3L/JMc -AhizrwIVATYqxny/uRVh5DMgyOyTcCkmrcvOXzQwMDAwIHdvcmtlcnMAkkYf9W7MlPFabiwFVicn -1hUa0uZw7Vbp/Qcg9v4kXGH+BxRkFcdygPaK5bD2g3icAX0Agv/QMNAwsIIBPALTER65i/QupRLG -HpN+di5z8JGYMTAwNjQ0IGJsb2IudGVzdC50cwAcuQxW1U1gG2HPG8a3eg8DuvCxlrO+AYQGFA++ -GoOg6t/nA2r3sElL1nSyUwIJs1YIKgkUa6WWQ+pdz0BjKg/qQ/tFYsSfcq6zlBG8BrnoNSv1ApJu -6T85LarsjMUL2SKwDMs+AB6zeJwBJQDa/8YTxhOwQgcUAX7b1Ru7j/C93uR8oGTlhDl+sTCTzwcY -s24HWAJUJRFH/QO1AJgxSgbQ1x+skB1czyDMguwI4nicAT0Awv+1vwPvvwOwWC6Tv14Mk4V0F5Mg -nBOTlCQwkyxqCpOfnCuTSWoMk3AnEJP/LhKTQrYcAndzkxxjGbMeL5ewEnwYKv4BOwqf9SlVAH4N -NEaZhAhk/hRZ3kF4nAEeAOH/pgGmAZBkFKXJIgEmzOvGutIiqTeq4iwXdtlQkXguzmANvvcFAZCA -rI5TwpRqcx1bVIolWKZyWBJ4nAFXAKj/xpoBxpoBsM8GFAKye80SC+GdA/XwTRGZpnpHB2ues+MG -tQUUeF9h75UKNgsnWFl1mORRXHcydIyzrAyKKRQRqaxmveHVpccgaTHm48oraW1A0bNKNvwWkhEn -WukFkLZGeJwBWQCm/68SrxKwXAMUBATYX2EqD8eydIsyNssgdupDVGCzcAMVBTPOeuu9Pog5RXlR -fr/fJ6d21S9/5DQwMDAwIHRlc3QAh9LL57Pn8QPlECHhpM0xWndMf2KTuAh3ZDAmp2yQp1Z4nHtx -j2nXXaYJBhvvda0DAC16BunrA4/GdnicATsAxP/kJOQksC0EFLlB6eDbLVIv5cYwLMAOycHm3yiJ -s0EEEgQUOO07KJMFLGMbwVIV/FD/7UqZsHCzZwj9CScgGp7xAm21DXexPT06pugBlN4+LSEfQPhM -eJy7w3eHb4M5k4hxZ8zuqBRh+3Apr4WvnK6nf71+c+dmbyZBVgDlIw3v8QLBsv/2zMov/K6F9fIz -9cQfjN2INHice8v3lm+DCJvIJZeErTHOsef3HbVs4dvd0XTodvDbzRpsrowA/vgO4vECO0mGayLx -JXckbkcZQ/OyybQ1lGV4nJvHN49vw3YWkWmNiQ8CXrY1/o78YdefyXHD+YeD4+bTLMFMAAnXD2Xh -Ao6mWXicW669XHuDnLDI++objWY+N5dbmn3NzLWSP79aXr90s5FwKRMA9HwNnuECjJhreJxr42jj -2HCUUeTC5289v+09z6VUX/1bH+f6pvyJ1sXNNxl1mQAiLxEO6geMl3x4nDvcy3K1h2VD8JLk9Jz8 -pMQc/6Ss1OQSXbvMvJLUorzEHN/8lNKc1KDU9MzikqJKDU1du6LUwtLMolTPFA1kHToKZbk6Cp5Y -dVlZuWWm5qRYWU2uXaI4eWOo9uaCpcGJAIxTL8HhAonSFnice8b7jHdDNLOIT+nbcxPEzlVHR9+7 -rJTk8+KP9t7Dm/OZy5kBDQEP2eECiPYReJxbIr5EfIMem8jvM9Nzf/rw8y/auvT7gUe1YSw1Pk6b -ndiSWAEA1g514AKENHicASAA3/+vEq8SsKQIFIqCVe2bA3td5VagZjs44OU3++DNk7gId/KhD9nh -AonTI3icASEA3v/mDeYNsFsDFB7LrmEdk/hv1vg+HHmauciiPqgks28DdwMGWw8f4AKAD3icWyK+ -RHxDIbeIai1XU8GxazduSd378tXjQ8TGN5Yhk1u55QH0SA+A4AKIyAp4nLsofFF4gxSnyKxHwtcd -OJrkz/e1/mRly1XvLHZYPlmPczEA1eMMyeAGiL9geJxb4rzTYcNdxsk/Obk3/2as5p2sLqA4uVlU -dHK8gO9kAzHJyccFZCYfFZs3uVPQePJhcXeu3NTi4sT0VE1rrsmCQsqTzYQEJnsIFUzeJaTODBJ7 -IVQ1OUVYaXKHsNFmZ5FEXgCodiDY/wtzhBupSSyn1AizflNsTADQLFFsm3icAb8AQP+vEq8SsCwC -FK3+i9lO3ie2C0NT6v4WW3h8izzTs0ACHAEUBATYX2EqD8eydIsyNssgdupDVGCzcAN2AhQx5euO -ur8gWlNJvXRz+b1W/ICU37P6Ba0BFOyaF7BrqfzHFENb6g69s7yshfKdk7sHhxT9nnefJrTk5jBF -NAjFeTFjMuz2IJNWCC8zyiCbn9/mq+Gj9+BSdlu+s/qSqz80MDAwMCB0ZXN0AEfKxXgLphib9JYj -ANz7xuYnuBpWk7gIdy7AWursAZC8aXicO858nHnDZkYR9gOzPF9xBjK3/2gJevtA48X/szeKAbPC -Dkf6A9a9QN9SmRFX22ytmQey0osB/amqeJwBOgDF/+kL6QuwPwMUjRwASEXU1cFRi4G/vNE4HnEq -V9qTUwNoFC+VEh+hewqHMkjQ2GaeqnqrHeFAs88DGgLK8hg18AIYq5wWOuxO3u64VmNCc7QKOm4P -pnicASAA3//IBsgGsHcCFApcXbW/gX7mImf3aZNdlOnOZ9X8k4sCvfBOEC/xAlkxoaoRqlw3oGXu -bmo6Z75in68seJwBIQDe/9MR0xGwogUUgKwigKv7yA7m20I+984h+AVpV/WztgUdAxUnD+X3BPOp -TCi0mzO235vg3ueMmFba+kBLeJxbxLqIdcM/RusJkXE8l+9uKl2WdkzB9G8oS65k3UsTAyBQSCrN -0y0tzk/OTi0pZqhU82GI/5HrY9gg8FOt5vSXNe1OUpMtmTIBG/UcoPECEHQFCjPuUg43Xrj+YbWq -5ZBOEoh4nDvHdY5rAxuzSEVxkFplvpHuR+n7k8/fY9XiqNr0ZbMUswkTANgzDLD8Adx3qSX/BAXn -qtgkuzk3d/fY0UqOeJz7wPSBaUMMowjP4lflmlzTV6gvKp65zmKizqTQg7UAqh8MJf8BBuNrvwdT -nvOHWtV4sJxagCb3QL94nAEfAOD/1wPXA5BTFOmNyYKWr7PyAGgl9jWhbJfmFomZsWdwAfr0D1r/ -AXkREyLfsc1netZ4QdpFjjPciiHdeJwBHwDg/5QDlAOQaxToJHBygbz5oaAn3cSU7vXHGE68mbF/ -FQHycQ+q4AaQmXp4nJvbyjXtIecGrv2MjpMXXtBQzixWKEotyC8qSU1RKMlIVShPrFSIMDWwjC9L -LcpMq4xPTi2azHVRTYRLQUsBIqSQnJiTk5SYnK2z2eUiP2Pz0kvbl15iPL5oe24pkwEvAO57JPn5 -BRch4eGxADGOAerZej8olArIdctFeJwBWQCm/5cRlxGQwDSHQqXnsYrh4y/wn+I13fqnRegnKDQw -MDAwIGJ1aWxkAPTKPCx5rPNk1ERlQC4oCRtM+jqssfRYAxRgx/+d4SNmbOloNHv0VY0b89hFo7Ng -BDcEg1opxO4CkIQGeJwBLgDR/+z1AYr1AbCLHJOZHHSTazkZBT09PSAwk0Qd2rMqHts1syNUQRyT -0nMjs5hwVArCWBJG8gbkjdpy9YLllX7WWnQqr0MPuyL5MHicAWIAnf+6ELoQsIsCPL44M5xRVL7D -JXZwn6sAYlRaQyhtMTAwNjQ0IGNvbmZpZ3VyZS50cwAFE30znel48Xj883pYMEB5CP326ZPHAjsU -1AYJMmXaYlmtRr+vlJCFssbptoezFgMkBZqZKXDjB4/9EHic+7mA9ek01g2Z6pPzpTk2b9G8zMZt -pZCSk1+QmqehqTN5jYGMEJeCgoKWglewc2JOTlJicraG5uQ3BoaTW/TlJjsYCrCCpScHGDpPfqMv -vXmzoZLa5k/h7qWbS89KsG1uvMpuOvlTuMj2jVyMVXbbMz0ZBdgBG6koOfAC43Pk7OyYwyMlKpKm -RiGxIqE72MN4nDvLfpZ9QzGzyMnXrkWSpjaKPTv2eqndUfZYZHrNaHI7sxsA2gYM8/sWuIJDQ7P4 -T1mjYwNiXDGkaPENBat4nGtbw3p4HeuGNaKTN4ixOCanpeuVpyZlZ5a4p+alFiWW5BcV++flVGoq -FKWWlBblKSgllebpQlToJuaX6BbnlxYlpxbrlSQW6aVXKVk3rxTdvlKU8ayZDi6jFOwVlJC1KilY -KUwv82GcKaugpqagiEvbdn5fxvuM0+8EMu6t19dXCAZr1s0HGZiVn1SskJdallqkkJlXXJCaXKKQ -l1iSWZaqkJ+UBeQVK+QXKeQmZqcqlGSkKiQWJWeA5BIVkvPz0jLTS4tSgdoKSkv0uBTAIDNNQQNv -OKiBAqJaISczqdhKITpWB6g9Oac0JRXKS8vMSS1WqLXe/tyP8SvTdCkrRpXte4MYPZkB0fyCav4G -r8fn9XtBjJmziGEqKZTq2QdKAAB4nAFuAJH/xiTGJLAtBBRCpfeAQXEx5fzOmEIWn+ql4onwkLNB -BIMDFBxfuM2XX4yFcDmOyL95Lw+CsvH0k9gHexQk2UGIDi6fAcwvgUqnxfRCpOtsULNnCHsEFET6 -oCOaUeoEqIfNxhDwzQRGlnx7s/YMUAVyKzQ/8QIewdYGslfp0+gGjd5WIYXao/2cQXicASEA3v/c -DtwOsDcCFLeGkeSJboHaqyL9oZw01hbV7wCRs0sCEQUTSQ9o8QJeRevoiRmpTHj3uAttoyHiPfOG -Hnice8v3lm+DCJuIhGWsetGhaf7T5jbwLXQtrHu2du6xzRpsrowA4IkNdvEC7HKvYg5yWy52vjgy -zztpK+rz93N4nHvO+5x3QwOLCIOkQe6i7t8Rpp4KF9wu3TqnIJ/csXkKSzATAOUNDV/nBY/EcHic -u5D8IGHDJVbBtNSS5Ay9gqLU5Py8vNTkEp3JF1l/Tv7AJssKlpnMzG4EZemzl2w+zp6nOFlWq37y -Ay2FzWzac5nY8pOygLomx0qbbv6ne4kZAAxGIez5A8FnxuHgQtc5awa9YqixEY9GKoxXeJwBOQDG -/5AEkASwXAEUa33prPVX2MGx7pJmuGItdMvPr7STcAEUFDYSQt61bi3XAAcBO9mimQsFcSwWk5gB -eP6OGHT7A8O7pxE4KFbUzTRXTXNaASPLPC+seJwBOwDE/64UrhSwyQMU8AvPl5U8wSOF1Jaxg5G9 -T1CttdWz3QO0ARSF8hPnT+jPda6UO5Db/wn+tgBtubOlBYkEhzkebuEBjtlUeJw7uJL9yQr2hi2M -IozbCxkZAy4DAEJgBpzxArKKT5tWTq29KdTwEEIlXFt+4jlaeJxbrr1ce4OEgIhdZMRz1u/zpR4X -JNo4z7b2CpBubNmsI1DNCgDY1AxO8wKOncCsPO0e38PZ4KXksA9VHLICCHicASMA3P/2nAH2nAGw -DEoUqsaTw4lgrsmdkJLPK5qPVt57+CCzIEpWBElfEYfxBdn3D6CbpqQRmAazAJWCbd/jzBraeJwB -UQCu/84Ozg6QpBQMWFXLjBo7/jvQg/wSBmEuWZKZRrG4HQUUxu/QIEVMLQCy6FSaynZ1d+jXKp2T -6QV8FEPOeWqh5ge4yp6kzXxxbUPRC/Cqk3kG1d1rJrnxAuDzvaSkm00vNaLsuPrV0tCfBBzqeJzb -IrRFaIMfq8i1wA6ZoKfSvcotLwwfSF3e6fYu5fjmJNZLzADv8A7i8QIYyS3dqQekIXleF1M1aC4o -Sunx8nicu8R6iXWDB6NIH8/0n/z75U94+780WR9hYNBatXLx5hjGMkYA6G0Ni/ECQqRZD3ANf+iD -oTqreMkz1vGMb3J4nAEhAN7/4xTjFLCIBhThWTXi55kqDwfIcIiHr0xurvK2urOcBscDDQEQMegG -i5RReJwBaACX/9UI1Qiw1gEURLK7uo5/TwPEVsqBvK3zVRu/4Dyz6gEmARSh0oH4TarkXPLlPg6W -lelMuH9EDZMkA0oUvtjtKieBblGt8tRQquUOhH4hFm2TggO/FOqqiYzYF5VAUQIV6uindyqXSzcB -dtUxWekDi5BoeJx7/4vp00+mDbxekyUzeDY7eBkyTd7gKS2rkJyYk5OUmJyto+AVHJaYU5pqZRXq -5+Lq5unn6rL5v09BAQCERxVL8wUuzxi+8pvB7cucteuILCiDNe7R6XicAVMArP/mDeYNsAMDFGu6 -wj+Pmlj5g38fTHEjuiMY5t6QkxcDRBRhb4UnKeXydnw7X8HpzhjAMBvQvJNvAzAU3sLawNUFpCib -UXNbHfYTYdVL9PKzswMzAw/PJd7/AWOjgxbM7wNGTd1w9Ku1NdbRWpSSeJxrY2ljmWAqkrRKLXSx -0iO/R0/yHDZU5c8vW8BvuNFzLyMAyKANJK8EeJwzNDAwMzFRSCrN0y2pLEgt1itJLS7RKylmEO97 -8ID77V452wWrt3x6KGG7I9rhlIkBECikZVaUlBalMvTpZPk4RgTulU22fFCY8YM7vy7cHQCsSB7l -8QIcCfU+0K3aKUM6w9Q6pEg4ieMNhHicaxJuEt6wk03khakAR1X6w3WVyxg2+n14/IW3qlJ281m2 -rUwA69cOkv8GWctsh4ummSEBEe5icLt8CaJyG494nAFvAJD/8hXyFbBVARTBbpL1WOwhKE0aQL8m -CutNVGO4UrNpAX0BFFNe834Mg9Pc+/nUjv5MowiPj4QBs/oCxQcz9XpEuUAUr5qwn+EQG58QxGyV -ZiY0MDAwMCB0cmltAJE0KM2dUZ4uZ9yEqP5TB6gH+XSv8Fsx4OcBiY93eJw7XL+xfkOi9eYsa2cm -Rs3JN230Nz+zvcsIAH7CChH6A1//sUiz8uioG8ZqHGNAQb2zCs99eJwBOgDF/5kTmROwBwUUhZMk -ms7JKS6D/h8IUKdlR+hgQ4KzGwXHAxSa4hPXQAiCH8+OhfkFBm0niXNAp5P2CKOkFBfW/gPVp/07 -vcB/jm/RO6U1Ci6hZYl/l3icu8B0gUnOxAAIFJJK8xjSpzx+fe3cjixf5qWxjwznzVeVUnWbKFcp -otD4XuJx+IGLkx5sc9ld2mTxLtxvzsTVSwEh9BwM8QIEoUn8qQHOn0HjcpV1eHM36dAuqHicASEA -3v/iEuISsA4FFKjnoFMVNyW3tze/k8Ktr0GcWLdBsyIFQAT4bA4T8QI1U/Oaa7JAf1tg+v0O8TUc -5wXwO3ica+Rp5Nkwl0nkRp/98iTze+ouH9zOMWuVFkuzn/u4eSNTADMA4oENX/UFz4NXh9kx+Q4g -nVM869oA3ELQJR54nAFVAKr/nRqdGrCoBhSmjGG3cr3Y+6mN+npWPAO9JWpYPrO8Bl0DFIJmBZn0 -KOaM2Vwf+nlLeIq0g+E5sy0KPgEUS8PCWHca8XSF16aY9n3nECfwkYOzfwueAa7gKBb5AxV5yfBS -5Upobk+xZUwM91f84OkaeJwBOQDG//cJ9wmwPAQUJ1+JvOa/iyrJ2vnpYIce12HGCpGTUARlFMCJ -bnMNHOZ8WbZ9GRw5kVF4X9ugk8kELg/qGh6vAnicMzQwMDMxUcjLT0nVLS7MySxJ1StJLS7RKylm -qMq8WdDp/ejvg0+blGeY7+B7c7ldDwCdLRRH4gGHuWl4nLtxj3PZTc4NWjXNd+q236ljrPkAAF7p -CfnvA4DXVHicAT8AwP/DF8MXsCcCFNlp/fXiW6gngQyStuZKy9sXPAr8k78CF7NSArgHFPwOtn1m -LCAA5tvhsyp6Prqu9Tidsx4KpQGzFx0E9QpQ267zaIL2GFthns8IsGY1kM0OW3icAaUAWv+vEq8S -sCwCFOOT8n/7NRpKPo7ikuekv2m5z5/hs0ACHAEUOvXuZJQIc4naxDq9wCaHshZ+1n6zcAM3BBSr -pSBspajVxN3DTPUMPGJD9yYhKJO7B4cUQpBUoNBm7nKoUouIJ59W53dEYCCTVggvM2qHMK0k38v7 -9m/t8eGVsy+C4Bl2NDAwMDAgdGVzdAAg5zon3FkSRpFW5vlwhX7jJyVXUZO4CHd0Lkzh9APLhSRM -EOohYpS8fMoWoWMMl4dtPnicATQAy//HA8cDkJQURtOamankYyzElkTrIJ484AjxUDCxqAsBFKcH -khzLPyd6E9yE+17zEfY3PkcHfbcXGvECXFhfGK5XPkqDmJ3hwOEX4ouRq/Z4nDvLc5Zngz2zSK8M -g4frlasHA7sb9++5aCFXqBV+a3Mw8y8mAOgzDiltkNIieJx7cY9p/k2mCQabfzLlrwEAMj0GzPAC -YfJVeiHfYZgsD6kNROKYf20iral4nFvEuoh1gyqTiGaTn1Zhpu4Cv+Osma8bpm3M/CI/bbIlUyYA -vakMgvwB3HepJf8EBeeq2CS7OTd399jRSo54nPvA9IFpQwyjiLnu/tD+hXWb3v69wPXeZolGp/MF -bQC7jg1g/wETErc6WNbPn6AoXaOK4TtWTYOt/3icAR8A4P/XA9cDkFMU6Y3Jgpavs/IAaCX2NaFs -l+YWiZmxZ3AB+vQPWvEC+fPfy+KfutHLWwpLYkBafGSvWoN4nHsv8F5ggw+LSMLx/3MfKqflvMww -qf4S2iv9+Ybr4s0JLPwsABS3D3r7A43UH2lWmu7CL3X13kW3w1whJLQBeJwBOwDE/4QihCKwEQcU -yuf79KBCzjBVRh79SlJ0KuCGb8OzJQe4BBQERA9opl6RidjM+fFckBmR/mGjQ7PxCxMFHMwa7fAC -u+HUGwK5bLaVLZB8DDbDSUgwyS94nHvB/IJ5gwmjiPtin966T7yvF9eXzTI0nR2gfGuZ8WQPxgUA -5JYN0PECGXp8CNAUlwlt3cRXCNFuYHamCR14nAEhAN7/rhSuFLCRBRTmJwueY/UchMKi4tDg+tR0 -x0Nkk7OlBYkEEQoQsP76Atlhx6bY1gyMj5yiwP+KvKskcwlneJylWF1sFNcV1l2oQwzYUPwLhtx1 -ib2DzRqSpqI2i00NaXHAxn+gitgwO3PXO3h2Zjsza+OAtVHaSm2jPqBbaVI1NTjtQ57aqFuwVFUK -rapWapS/PvJQiFQ1qdpEQQp9qFrRc++duzNre0l/nryec+65557znXO+e39wt/YfL25+baS+2NOD -93r2oKm6LjYs11NN08XjtjZLvE4XHyvkTXIJ5x3bs72FPMGqh52C5Rk50o3ns4aWxV6WYM2GlU5B -82yn060FkxOgO645Rt4TRi2NYL5et4mLLRuskIxJNC+TrM0ULM0zbAsb7rCtE7F3Yk41C6QXF6xZ -y563lF7MP4BO4NwJafZyLQZjXsGxpEogsTOBal/tYulUPW5ryarusOoZc8EeJw3XIxZxXBrft7e6 -UOua2MMPCIf3VC0rtCZOjk84quXmbcdj6w9XE7YrfbViuSVlpx0yZ9gF96xjeMQ9ZlsU73u8v7qY -hDbcbMHTISDrO9FaVVz6WddQzVZhY1ZI6ZsHW2rEz9LfDj7XesjI4ER1+4msaukmpF0DiKRVbVZR -griX0s/8OlY8ij2pionj2A4mc8TycE5dAPwQjeiQGs/FOsmAmOh4nh0PoJMDiLH8J/E48TyTYJul -lS3GasYjDj6fVfXjzGIEKy5XPU0s3bBmWKC2k4RLzEy32FsBWNAHV7vowC830sNffpTe7W/xsxht -pyjVVidPkOC6dPRIc2nvsLKhpht79iyhJ0cHgp+lF0e70CHx21I41HiQYKNzs2tDNIXjqZRQxleu -4NKtsV3oMbYIY7YkyQ6WaAef27uxq2WJXjAJ/e2kUid3gDRjvEhrJn5+sBtX3QW0FiORkIZentij -VrgKdTg0Pu45RM0JTGPNtF3C6lxUbZZoszgPwIesilAT1TEN+Ls6N24yODq9Pr2TvjTR/kiwk791 -OdbcbVuT+RlH1Yk+yHYQvneztmAR7qX0Czynt841PBqi9vpYU7HCa/4zyT09njM8D5ACMXUKhMVG -ADjwi+BUVHsw+NpXaWQwVC5YAD7DIjpTkXGbzNOlibaB0MNPy3FK5lgpO9KfTNBfTLwrAfSdyWOR -E741GZdw+mjy9xtYxx0jngpJEC0jx6oko2pQGyIJohGIZGHIDpQM04NAsKwV8nnQEcWYLIdEgC71 -UL95eHExmhaOTW7xK9xgbxgjITPt+aoy4Wcv+G5CziOfxggULOjq68jGzwYdRualUima97UCuWaV -K4ssa/TCZJeM83tfzcYGKgNTNS4y4VyxPxkGh7491kx/M7aT7ju3jf54upVmnn1eJG8GZoOj8uqD -yEAXdAs5yJdqwc/9kE3ID7Q/L+vY832QPFC2F3CuwCaICdWoL2A4P8hhmIV55B3ivPgf/BU/QiyL -JBXXETsLIrGs3sX5osCCCNrYIkR3OXqGxtneBMY0uGjMGJZqRvo2c0400KQIejkYonfN0p9MfX4C -UEHYXDc8QzWPqZ7ax5VZECtGeLhaUQIXJVzZRmraJCeJNeNl4Tz0rtba2xfoMEuVGkp0O1CPOMYU -E/Sv2t4zbFlgIQhnEHuonCtXKiSf3r3L6vTWWLyr0qzMEtMXPwM5O6b/qyxq8u88QJt0SMhRnC5k -YOARXQS3AiQCPHlTZewoSwJbDDtfKxBgMioQpazsxsmKAObF5MMpf+QGeqxBRk5gRRQtff38nqIM -ZzV2Up7q0ZXBp2CP7mjsy5OqnFCOuxHLXJDg3m+4bgHOC1CbL3IKgwuuOKBt6pgNa5ZYccYkHibz -GDyCQGi2AygVpUEilRGCIvAounkFSHmgEu3tAQuA6Ly6iLbUyeWCGtBFtaUuXE6gxfgXXontOfAQ -AhaESemL7LtIl+/t8H+XRdvo+Ztb6J+f3Us3TT1DR6c66dxUZyIoiDB0iiBE7rkDU9HPdOSbg3TP -NKYD9xqRQlPTLXRcb6oRZU0P3myk31U3bYXtcIZVK8T5sn/7YqwNLZZmp3fFLgYeFcQADgh7Gb9Q -kGqO6KeNvKzK4CShSjXiu0aTQ21zrQQ6fIjfRA20R+sp7VLvoMb16fOrF9zStKY+9dk1lI34byZR -Mz30Xp3/fBI97r+9Ge0qXf2+fs6/ORqrp/33G/x3XkAb/TujsZrNnukeFznF/ravo7Ye3I+hugFJ -hgujEbLGxQmdgzQggZE54d9Oog4f9aDmPavdqFjTRz/+5DAdv99Tuvj392tK7/xr6YB/dzeqod+6 -/5j/VhI9wW1se/hRmsoNMS65Ju7owCvf7kE/3b1jndbj3x1FDStfOIXefzqxeqSzObFev1rZ+T20 -WLsBtFboEmpHkn0c8Zv9N66hJ4L/V/55DW2P+bmXUMdZYdi2OEtjbEHBqSPlYuJTsMpmFbSHwHzm -JoYn+AL/42uo8URf5NBMWF571NKHbMPiqt3YKpgmtBT3+CWN5CPcsFv6pfijB9COz/D/Vtp+hD7Z -XuSW464gsQEcI2VPLM1ZyHthm1+LerG2jOWqmF+rN2ll/DM3UMsG+LBi3UCfe7LI+zq0t3BwsrYu -Bz1rXqyhBe5mHDvH7qQG3H9Ef1KSeASaHFyGBEkvQyRNMrYDVx82HFhzl0QQRipYwx6wc8ac9vHt -NHbHNcEKvy+FTFDnHYCDEvpf8jJq9bedQk0NkudE5Ir/+mnU4t/+EG3xr36AztdFZdBmtiyj3f4d -qOwGwcTCDAPlCRZf+xPahBZX/vIBemFjfTy6eUcH02hcKX6I/vBaMSQn8oqJ0wt51WX3ERYxPnlY -UOV86IVzQbNjV0YxGiC9x0eeZkOTvTBI6q1j3WFcmlESlbVI3g4CliwotJdVvUFMLgHFjqSMDd+L -AEu+A1eMXC/XBbA/uxRrK64C639zKZQX5jCaImXS6yBAqdryKO9PBhjo6Ag+FtmYXkWzQ2koHF9N -s6WS8DMYF3qkriPUV+om4hV8B+60brqCppbXRu4QSrg6XPefLRAi/91LqGGyrBnhJMxSYrWzEZYH -PTa+Rhw4q7Bt6NWPdispcZ+MBiQp6WZFPOnITOMh+U880rLK32R4xPtExWcf/xC1nqnUhLIhDE0M -OlDgIQJCWKZWo6F/bXZ6/aFrsd1FsZRjOFX5eFY2x86ME2ssxiP3Y3nJ7sXxCMlhb3hQleQSdEbW -iuy0S5w5xlnZfYIXX5EwaqcKBxwCdM5ldtJABK3yQ4KoQDPor0lh+ShcSOZ520p0coVOBQPPhf5o -F4Ah5oBA8qKFtrk/79gzEDaXDR3XZfkM6u1iEfaVTJB9qDylUjnW1nsPSEVeBJQqTwZBmYvOt8jJ -okzWkOMFLzp8UXvYE/grjrxWljMbj+4noFp+I/jjYFP9Kv/pg2zLU4KeYjUNSiFnD9Mrdwr6CktF -X60/vBT74kZ2Hv8bS7F08UsGtDreTPmrj0lUq5DHaTCiZTvlFbSbTRjossAxgXmKtEUea/l7heGF -YyYkEYY7KEwGfIiHqp+90J3IwRA26lW4vKTBh4QY/f7t67Ene+RFgmv3htqrlCXV8O9djzUlwyea -EPv8fah6v66r7Nf+y9dibzRykiIWK1KS8AeWY/tS/8tjn+zrfX5uOfZc//9lohb7w8uxNkneHnkl -1lD3b5pUIqfxBc7K4uhWq2IFA6fJXTbCnUF767vreJwBUQCu//EM8QyQpBTPii3hvZdrvQoOWccL -jB5X+Svzy7G4bgQU4oVCvNyje9oLxiKruXSjzZ3syyGTOgVOFOV9gP4aWPujOOTA2srtnBBWchHl -k5wF1Z1dKijxAp+4VaYvA8LS4Gffw42yImkEs+0BeJz7KPBRYIMUq8i7HJc+n5DeYr6YZbyZdn57 -OjTWTdusx+rMDADjyQyg8QLCnVMWeXzNoZhZxfvacxKA+Ev/QXicu8R6iXWDB6OIlNaG1j9qVV+f -xmdP+S/49l2EkPjTzTGMZYwA+7AO4fECuOHGME9FlmbTRkE0NVuUf9ur56p4nFsnvE54gzGbyMNI -00fPZ2rxs58o6Ghf75O37tO2XZvd2dKZAfQUDrv0CUznzrulGNUshcdG/2Vnq/V5Mb/AeJwBlABr -/9UI1QiQlRSV+tyV/AfP1cWrLen6l1PfSBiT6qGpARS1gwZAQgOq7364wGgIIWuoa5DpzJO9ARkU -RLK7uo5/TwPEVsqBvK3zVRu/4DyT6gH8PrwgkLDNA+E8soz/oMiXvvs9nawdMTAwNjQ0IHNvY2tl -dF9ib2R5LnJzAF+l1ZBCogClAQZBUyW49tG0JV+DsyQDMQHfe0Zj5CSLmRV4nNvke8llgtXEok+S -uaklGfkpCrYK1QpFqSWlRXnFVgpJeol5lZNjmaUmz2eUmpzAzsquo5CcmJyROtmbUVK0vCizJBWk -gUtBQU9PD2LA5C+MIZNzmWSlwbJOpWlpqUWpEGMRah4zmW4+xTybeXILu9rkbezqk1+yb2K3UgBr -mTybQ5kNqu4kR8hkQ86MyYVSIpP/8nNMvsApIA+R0gHaCQLpqSXOmQUZqUVWClA9nFyyMO3RXLLc -CFt1JvdzyU6eLcQ1+R+XCkyJLrd8KoaJwanFxZn5eTAjkWUyEoG+Cc5MT8xJL8YiH+IT7JaZl1mc -kZriCzQkMT0V7i4+HmUlbOpDMpOzU0vgymJ5xGFuW8kTAmNy8IYCA0Ju8jxeY1ZwpGy+zWvGCGVK -889nlIUarZBYBHJYtUJxZlUqNAIVajf/EOhkgpm1g09l8nVheVZIaP8UtuBFiarJcSImqCKbT4qw -cExml9VACUwrWWNGhc2vZY9zAACKIsIC/Rwuzxi+8pvB7cucteuILCiDNe7R6XicAc0BMv7mDaEN -kJWRs38U30BJIQLDX1thgg8knoxb58iXPhmTRgExNWBVhhHzbXuQbjovuH1LvWFpMmRaNDAwMDAg -Y29uZmlnAH8vG+nlhMS0ZA/YgxIU2taVrqdlk6wBORTa4vd1Ak4DEJobU+G7J6T72SjwWpP5AR8U -x18b0Ck723lbgoK4dZTLiYZBsDuTLAKCFLrid1GojMH2Na7CJnIwEQnWN4RIk8ICQRQAkfgAYANq -0ZAuBXdlAjMnI1TNX5MXA0RZuznjqaWFRPGqce4wy+F0Bu0Ff7s0MDAwMCBqcwD/2tzA1RFgQhPz -2EcJRSIuntCaVjEwMDY0NCBsZWFrc2FuLnN1cHAAFAPVfJqfqCQ66OZMiLlAHuiUO82T2wMwFOBO -W6YsGEedqKuGQKolwCajmyA3kx8EIhS5lw46OgDvaP+lGI1muYejnwSAJ5NVBB8Uw41ZplIh6SKR -Q1T4jEty72MnspyTiASfFLdGOZ9+4NbFvkTsUDqwXzTI0tv3kzsFHRStLSO1nYQjyKO4AbLdnvGs -rUVpBpNsBTcUg3uDtKC+jaSqKkndX8Ywuajsij6TtwWgFFqmnH0N38qXkqrvrbwbsi8+vshVk2sG -e57LzAX8AfcPYdNaJMeG+vimnW0J4rbIWpUoeJy7xXOLZ4Mbmwhrov4nuZ5fm+L71gg8+iFneK9j -qTAArP8MqvECNev4dbQvFnu4SPJHu0sqxDol4Mx4nDsueFxww2wWkdbJKrPOndTUa/4nzxGwPNX9 -RYJz0+b1LBIsAPPODbL+A8tjHXwk7s+Tu7Sji7ZO3jBVme0zeJy7wHSBSc7EAAgUkkrzGPR0XK6e -/TuL+5jPftkPF9uORqn+8pkoVyny5cQE/Y4yswbLXM3Yg/97G4X1fJ5NXL0UABpOG3bxAs9zVDa4 -HWzI9Q21tP/rx2D/2F1PeJwBIQDe/7kSuRKw5QQUqOegUxU3Jbe3N7+Twq2vQZxYt0Gz+QRABAj9 -D237A945FdRekIPVYOCJiIIAJCO/RST3eJwBOwDE/+IW4hawgAYUpoxht3K92Pupjfp6VjwDvSVq -WD6zlAaNAxRLw8JYdxrxdIXXppj2fecQJ/CRg7M1Ci0BYbUcBuUKyT94nAGlAFr/rxKvErAsAhRE -i8lVzfPjmHgf4Y/tYIE/2+q7ILNAAhwBFCnEUdNBaOqoQL8kFtsFD+0Bs+YJs3ADNwQUD3iz47Gc -ypgMUMc+c6i3mOlY0Q6TuweHFFjkFVZwhk5UcejCs1dMU+jMRepNk1YILzPZl66rhAu7jNUthr3h -gGnzuxsMwjQwMDAwIHRlc3QA5PIQwygdOTvywO9tTBNT4ZwC1xaTuAh3lVNLjvwBAVyfz2p7y20R -recN6Vrqxul6dGt4nAEcAOP/xwPHA7CzARRP+GXR/57JkI3NfaNkFmqrn5ma/NAcD1fxAta9QN9S -mRFX22ytmQey0osB/amqeJx7yf2Se8NuZhH9qULyC6u52o08LtxIm7eqarXsQ4fN55mlmADtsg3h -4QGQ+zp4nHtxj2nmTaYJBhvvSTNtlmL1WwUATDAHc/AC86lMKLSbM7bfm+De54yYVtr6QEt4nFvE -uoh1wz9GkQmRcTyX724qXZZ2TMH0byhLrmTdy8lCTBMA6KgN3eECxRt4nAEhAN7/lxGXEbBMBBS7 -4lEU7uVt9olNk/KZtWS8z+tvdbNgBDcEEYsQVusDvy54nAE7AMT/xiTGJLDEBxQClkdwRpE17tGr -Qe5E+zYWtXfz27PYBwoFFNn3D6CbpqQRmAazAJWCbd/jzBras/YMUAVHARxo8ALBZ8bh4ELXOWsG -vWKosRGPRiqMV3icm8AygWVDDKNIltusmOsr6y+saY5/eWCFzlsmiQy7yQWMCwDiXg4b8QLDu6cR -OChW1M00V01zWgEjyzwvrHicASEA3v+uFK4UsMkDFPALz5eVPMEjhdSWsYORvU9QrbXVs90DUQYR -jBBc8wUuzxi+8pvB7cucteuILCiDNe7R6XicAVMArP/mDeYNsAMDFGu6wj+Pmlj5g38fTHEjuiMY -5t6QkxcDRBTR4jJM9fBYI9154FUpEwf61dhwD5NvAzAUgM41ErUD+uxEth0CLqMSh5K2+9SzswMz -AwsQJNrrA7UoeJz7JPpJdMN+LuMHvwICuqbOzPV6LLP678K9cm+abv83MQAChZKizFyGiSYaZ+cG -ztNLv9Oy4l8w+wr2nyXrAXhwHOXwAl//sUiz8uioG8ZqHGNAQb2zCs99eJybKTxTeMMjDpFZj4Sv -O3A0yZ/va/3Jypar3lnssHzyN47FAN+nDef+AdWn/Tu9wH+Ob9E7pTUKLqFliX+XeJy7wHSBacJ0 -EQ6uc79ljKQKK2eKPK3waN9izLto28TVSwG8VA0T8QLPg1eH2TH5DiCdUzzr2gDcQtAlHnicmys1 -V2qDJJdIUxrrzC8az3puxsj/qvSu6NrS/NBysy7XByYA7U8Oq+0GhwJ4nAFtAJL/rxKvErAsAhQB -XJ/PanvLbRGt5w3pWurG6Xp0a7NAAhwBFFzqeN2qEckWmpARHZAgxZdatmtWs3AD0gQUFyHh4bEA -MY4B6tl6PyiUCsh1y0WTVghOFKnJeEnLlo18suhGlkChXBob+JcKk7gIdzrTMBniAZGCB3ice3GP -aeoNpgkGm5MYpzNulmL1WwUAUJAHcOECgxR4nHvG+4x3QzSzSL5ubXvajyPuq4OcV3se7tC9ktk9 -f3M+czkzAPzdDsTxAlnLbIeLppkhARHuYnC7fAmichuPeJwBIQDe//IV8hWw5gIUU17zfgyD09z7 -+dSO/kyjCI+PhAGz+gL4By/AEbfgAoEMeJxbL7ReaMMSDpHWF983C9SIC+dNdDJcE3/qvrWs5OXJ -OzjKAeZDDfThAoQxeJx7xvuMd0M0s0jk6Zz27mUzFRkF3yUV7K7hXFQk3b85n7mcGQDwNg16+QVz -hBupSSyn1AizflNsTADQLFFsm3icWy+0XmhDDLPIxE6fi0H7TLgLzipGv5ITf3lm7lfdzQXMoqzG -X7+15XnoKbpUnAytsnhm0e37rO+biQEQKJSkFpcw9CoUfvQWFWTtNmrVyzk5XUPpT4Lz5B0c5QCQ -oiSV6wKRhGp4nHtxj2nndaYJBpOTGNOYE/NSJh9nNOPNTSxJzsjMS1fwy09JnZzF1L9ZitVvFQCB -1BCU4QKHW3icO6ZyTGVDMIeI8HRlhlh3zdVmN0VkPniEiFWVXfy2OZ3jPicAy/QM2/ECsopPm1ZO -rb0p1PAQQiVcW37iOVp4nFuuvVx7g4SAyAsnxc32lUvdlp6VZQ+QuX30/5vQzM06AtWsAOhdDezz -Ao6dwKw87R7fw9ngpeSwD1UcsgIIeJwBIwDc//acAfacAbAMShTlLjbc56aIa05IR1qt+HDDienG -7LMgSlYEO68RkP8BIHrQmD/mUQdHW3O/PvPVMN/rtK94nHvO/Jx5QoHIv6TNH3uu1kpUsX2d91FJ -pFb727KHG1uSGQEBMQ/b6gONh0J4nAE6AMX/hosL7IgLsNIEoxgFArNAB4tes09mOw6T0JQIk9xm -DLPGdHsaswqQwwuTQY/Kg86bh86bAbfOmwK4KdVOGgLxAi7PGL7ym8Hty5y164gsKIM17tHpeJx7 -xvuMd8N8ZhHL1z8fymUkpvZK2fZWZx6qd2nd5LN5M7MxMwAFYA6T/gHVp/07vcB/jm/RO6U1Ci6h -ZYl/l3icAR4A4f/QAtACkJcUq9n/bkXikZB28pVZw85w9TTUHu6Rq6UAbhFa8QLPg1eH2TH5DiCd -Uzzr2gDcQtAlHnicmys1V2qDJJfIoSsXwzlmlPYZ7p8tFcCb+vRii7rXZl2uD0wA59UNpa8CeJwz -NDAwMzFRyMtPSdUtLszJLEnVK0ktLtErKWbgvRAz7zSLtnZtfbfuXLnVSx6xJ0sBAHZNENjmBof0 -Z3icu3GP8/tNzg1CKn6ZeSWpRWmJyakKwSWJJam5qXklwZV5yQrVXApAkJyTX5yqoWmlUJafmWIN -FooOrsxNys/RS8ksLgBKxiLL1m7mV5GOaL5Tt/1OHWPNBwB5mCSzaI+LPQzaBIgt50dp73Oluq1m -4LI= +dXggaW1hZ2VzIHdpdGggYW4gQVdTIHJvbGUgKCM0NzYyNSkKYzZhN2JmOWQ4ZGM0ZDQ0ZGI5Zjgy +NmU0N2E1YWU3NjQ1ZWE2ZThjOSByZWZzL2hlYWRzL2NsYXVkZS93ZWJraXQtYnVuLTg4Mi1xdWFs +aWZpY2F0aW9uLTIwMjYxMTAyCgpQQUNLAAAAAgAAAxCXJHicnVBdj5swEHznV/ixVdTKxoBJ1VYl +CZfQEPIBuVPyZmxDXHyYAx9J8+sLd1Kf+tSRVtqZnVmt1rRCAFH4yGEod0VBCEbcwwSzgrLcZ76f +Q9sm1COQUquhragNgI5AMBeuzbCHbS44wX7OCCNIYIcTJ6c544PJoq/molvwKGs25taaga/9O6k0 ++yGFEJ91W34HiEyx6xPXR2ACfQgtpp+fpTHiv8JlU3ayBJ9GzMJllIA0XYE0WiZBdjyEb7oFjiiJ +jlCtghH7oRabsYsZTnT89Fhtfh3RJqtGrbyVVRE8ce/K+zn0u9QED+FtOu0OOwscqOm3K2eyTTlS +IY6jMbE42woGf3G+02U4bBtns2xU5ji50zlS50WEkix0LfB2RlzcJTb7OsaH+d5RtF8rhIJ13OxC +G6GpiiXV64b+vN7o6QXF5nTapnQ72G8J61+4rCzA1WEVZDOYeK593U3c6PdDEH2z3t8RJot/PcMy +ojMfZN01ghndfvwCBk5zJbsLULIXoKtp0120AUwJWr82oGkF0zWXRuq6s/4A3HOx9+EQgiB4nBXH +vVLCMAAA4NNj6lNkcCfNf3SiZ3HAwoFai3cMaZpoFQqkKW19Cjnfx8XByffwMdTlu/u+Bh+DlXfG +ACKFZBRBmlOiELYMQyoNwQLzUGBtKMpDyFAY7JQzlQeECWIgV4xDRiW2iBJOBMKcWm20JrYgTEKW +H1fhKWbHt4t/vz+zaLaftAki6jF+eo71Ro7uRJK18Xa4ZtPF1e3DzbIdu004fO3vo76J5ofrbp7G +jC96gl6KNApA0V7O0jEZ+W45qZMsifJpW7//nJyhc+DMTpUOVMqXBwP2jVqXttR/21bAlp1vnKmB +st44UPeVDn4BUElRiZ4keJydUV2PmzAQfOdX+LFV1J4NGEzVVuXrEpSEawOEE2/GNoRCABmT5O7X +N9xJfepTR1ppdlazWs0qKQTgzLKtCuuMlYLiyjR1zlDFMS51TEwOuXVneoW0kUrRK0CRpRMbIhNa +umkxwoiDOEEVrkgJBYK4tGxEMNLorE6DBMemZ4tvOzDw9fLetAP70QghPg+y/g6Q7RiYQIx0sIIE +Qo0N53OjlPgvcz3WU1ODTwu8cB3FIEk2IInWsZtmh/BN10CG4iiD3cZd8OtewX5hO2bEwy4/tvvf +Gdqn7aLVt7qt3JxbV37xIZkS5T6GN8eZDj81cKDq8rQxV08JR11o7KLFERR6B92/KF7pOrxvW2Ze +uii+Eb9SH3VFEKE4DbEG3s7wHT3r3fKWi2Y+HZVP4/Qgj4WTHGprg4gf2Ml2KmrH87DRwk4529md +Rpnkzw+pVzw8Kw2cVl7kIm7mtosfubfLAvMaftPe4wjj4F9haFVz+yDnXjVn8fELGKWYhLwIMFx7 +wcEwqmboJ0B7DiZFpZpHwIZeScrUXa2WN00vPdP+ABL/sW/qEIIleJwlj01SgzAYQMcZVpwiCzeu +DCEkxF2nRaa1o61T8GemixC/FGqhNARLj8F4I933HB5DHN/mbd87O9/O2hoAJDOKuWZv0sNEKSJ8 +P6SCSE96gQ8e50GIQxli7dbSQGVRhiVVVGSYC6oIxhoY41SHHAdEU6EzMQA+9GvsEI+xvhf/Pn89 +T8W2eWhPYzllbcA28ciPr3M23+bdy8oe7p7yx2ByG6ez5L3TSZQGEatXr/FE3McLYuBYL12UjmeL +sul43ZZJUc2tXkbH0efPxSVXu+LqBql9We/AAjJtZYtyMBzawkD51672H2DkZpjWFgxqTpVyfwEV +D1Wb7w+AfXicJcU7TsMwAABQIWXqKTzzkfyN7bUKiACNFBFQGTr4mxoap41DibhFxH0YYOccHIOB +t7zv7DPbjINzgCNmlJceeYwR4goyDZnhmHOBNKVMakMYp2yxV4OLI2BeWCIpwtTnFitjHPK5F5Qz +rAhBXGqBGddi3sCMMCTmWf7/87WuCpuv3pcRNpPGV2+v5WUdu/KsrcJTAT0O1WEqbtMLuXF3Syse +7uM1asyxzh/b0D3nsnILUNrO9nB1gNtJrocSNSnU6eP35PR8cF1/dKDXqd+50YGqtw50IaUQ24tk +hrAfwVZFu3PD4g9f5lFX4hCGEnicHc8xTsMwFABQITrlFB5YUIbGduzY3UC0UmnTtFRQhNThx7Eh +IriRY4LcW0Sch4UD9BwcA8T05ncafY323mmNEloRYQSlilbASZpyTCqcUM45SFaCpJxlIEXUgtPW +I16WApTSmeIyFYJmAjTOEmZYhaWhhCiSANVk2OPzjMthmPxz+n7Mb9h8uokpuw7cSk+LJGblcX73 +YBY184tdXmAR4HnpzdSMWfPyQezt0xWWRR6vQgHtfYRW24a3VejXYbYcN263LtxGff6cXeDuLwNv +lxP03mnU1L1Gs7rR29q+InWwvXZdfbAIjNcOdcGq6Bf5sFFbnCR4nJ1RTY+bMBC9+1f42FXUCmM+ +q7YqCWyCNiEsHxuVmzE2JRBIsSE0v77QXfXU0z5ppHlv5o1GM7JnDBo8N1VLU21OcmwiVacW4Wqh +IKpThRBm2RhTTlRwJT1rJWT2zHKmq7pqa1wziMXn5jzXDZozjmxqU0xRYQIyyJ9dD1+qli6+p47C +L+MrqTv6vWKMfer68htEpo1107B0E64US1EA7S6XSkr2LnN5LUVVwo8L1t7WD2Ac72DsbwMnSSPv +rw5gigI/VZqds+B5DvewZHuKg25/eqkP5xQdknrRyqmsuXMqjFsxbhRLxNJ59CbbFlEIYETkeNxp +q2NcoMbDe39xuJnaKM4/ZHey9eZpS22dLMoGB3eyQU3m+ihIPB3AtzXKHR4UoW/1u9WsT2g1iDSi +vhnufgTST6dUDGfZXg41uR2n+jk6av05YescF+4jGrMbgOGQ4HGPwqeMJG34a8jV0vG+gtdzeIH7 +v2MAXk0feia6ZmQPn+F1Tlk/Mvgm9ZC0BZQ9acW1amZKu3ZmVApI+PIk8bul4A+uSbT94xCCHnic +HcU7TsMwGABgITrlFB5YEAN+x+pIi0RALUkLgqWD4/xOHEKepml7Ciruw8IK9+AYSHzL9z35nGx8 +D4AwFVJgIkFlxFCuiAkNhIRxG1oBTGkIrZSKBK3uofaIhICZVcIKpoDTlGegFUtTE3KBrZI8Y8A0 +NscNPlVSHt+n//18Pc9i+nK7iFVCamEOndrtd7aZFyTq1vdzALcSV5ysy9ZCZKNq9tp4n5VaXd/c +JfuHx8tiDFCq424xLmVJ4+bJr5bb7UWCP35Pzmg5mPMp0pXLa9RWb7mrUeaGVntToNH5AqVN3zcj +ZGjwvavzIfgDfOlUI+kPgHd4nB3HTUrDQBgAUMSucorZShHnL8mMyxIStJJFSxsUuvhm+o2twaSd +TFpyjOBxBBc9gNfwGoqrx/uafE42wSMSyTWHRHLYxloAZUxRqSjlVlKXKksBESTwODqAxyYQMEgV +ZwhUOCOM1JpTmRoRW5BMs1ilCQrqknHDrpVi43j/z/elKk6KDdMuXt5lugS/Pi+Oj2vWtFlaZqsu +Xww5O8n9E6uOg+/Ciy3D61DUs2fr+nS2q8NDRLLCr/Ie9/M3M39vRLEM2fnj52p647ELrUdStb5G +T6DZkgOE3a3pnfu7bZvgwYYu+gXFLFAg5hCGBHicJc87TsMwAIBhIWXKKTywoAz1M3HYkBKRgkrT +RwRU6mA7ThSUmtZx+rpFxIGQmBHn4BhUYvqHb/q/vU9v7azWIA5xSKoQRhWDRLOoggjhEkHMhSIK +RoojrRQO/a2w2jjACBYaIi6YRppxxCHliMaYkkhRLVFJK8kQocMaeuxCwxD/9+frZbJI4yyYreQ0 +hUlSHzbBfbmyMxmPj2S3f8qb50JCOsryJHhdBlk3b4q2fxhjs5BpXr+NJj54nMKzPbfH7G5J57si +z4/ZAX78Xl0T2TdteXMLRNvUBhjhmr0G6t04K5TrgKictqDfdpdrsQHdySj/D9cFUkrhEIgCeJwl +yE1Og0AYANCYsOIULNwYFjLML+7AQjStTRtSo0k3M8w3haZWnIFqewvS47hzbTyHx5DE1Uvet/fp +rTsLEAgRc8ONAc0IZQiDiBWGikeaK27G4CLGGkm/lRb2XQBSEU5jRBBhQBCTiBtijBZVhLQwKGYq +wVoNa+RhJPAwJP/+fD3l6ERnYTHZfESrnL5lXUrzdKHcsQwfS7ppyEPI5XZZPB9naaakrk91g+aU +TfDdNl2uWvCDcmHv8fQQ3U5FViTgxPw9deffi8tr1Tc7fXUTWHh5PcCI662FqgMd9PvejbSyq4Ma +di1Y5/8BGldRJ+AQiXd4nCXKQU6DQBQA0Jiw4hSzcGOMYYAyw7iTiIVKo8QmVpMu5g9/BIIwUEq9 +BvE0bl0bz+ExNHH1Nu/L+rB244BIpOLcX4TS4wXIgPkSPPBDWTAfIWACmWAFBRHaRg7YjkQLpArc +QINmgL7HCiVoACHQBXpUS2CKoqYw76jlck7nWfz7/bmN1XW6rmjGI9fENIirQ3S7ks2NEybtFaiu +zu8yZ/O25A/KeYqf65dhqh95kG5osk3DLMptcp+LJOrFdF7qVf9aLkU/Hbv3n5PTi3IczdklMQPu +cZiQDPJITGWwqVosiGq6PRItq+bwF+xf0ntSW+EQi214nCXPTUrEMBiAYYSueooslYLkt03cKkLF +zTjOTBmYRZp+ETv9GZO0ZbxF8S4ewLV4Do9hwdW7eTbvd/QZHYIDQIpLUqqSS5UJwEoTRkBBJQnF +XFjGgPKU6Qzik3bQBQQUY7wYbixTPGMaUsHtQlIrlhgtickw0/MBR4uT86z++/NV3NpkeEieTu1q +eJmqe7oWRGRV8bi5awY+rvKtH+vzEZr9W+LrvN654Vmp93q9H+FIhexDjDKeB84r6grFrPHlpthO +/uP3Al37cG7g0g1deG3h6gbZ3rU6IL9c6hb1UwcOmb4LTpvg4z9CJ1LE5w+AcnicJcdLSsNAGABg +hKxyilmI4Cr5ZzqZGXcpJEpFrC2JUehinj5a8+qY1GMEb+LCA3gAz+ExFFx9fJ/BR7DxvbVIcsEt +ZkASHGPiQBNGSBJbydnfiZNcCeNiHbayt7VHmMeKaSUcOAYaKCig0lCBMSgFjFjFFRAzmzZxAFTQ +aRL/fn9ViyvWHNbDopxnhUiHLBqya1zMC7ibYXpjV+nycLvsqnqHk+6SrvNo1HR7kZfbdq95ft+l +ITJtU5rxLTrndaSMen6ompG//xydHD96356eIdf0L9KjXo7Iyafda2+RbmrfS+334S+pkU294BCP +T3icJc/BTsIwGADgmOy0p+jBizGEru26zRvgAhkLohNFEg5/u3YOt0lKB+JbLD6NV87G5/AxNPH0 +nb8v59NZW6MU4n4QESKx8EKZEyGAS02xTyDUofQI5SCpzzB1t2BUYxEDzbHggnAlJBW50B4RmgH1 +aa6YjwMaaQ6cdWvs4Iixrov+/T4th8UsTe7E5r1uVptB3yvrZJ8+ZaM4muF83J8Gwd6W2eh+OW5X +fDJs2sX8kU/T5Obt8qgqC8RFRRjfPug0Pl4/z2ERTzLychh8/Jyd93Z/HagvrhBUZdEgAwekoaxa +oxDksLXKIPnaWAPS7txfdqZR9+IQmlR4nC3GS07CQBgA4JjgpqeYvVGmnc6jy0YQMZGkIFpNWPzz +spVmhOkUkVs03kj3nMNjyMLNl+84+BmsgjcGYUKM4QSUhlRqbcAQoCRmmkplcWoJJAonikQb8MYF +xDKSCY6BCWuIsPp0iSnjkpME00QSiUVGqexXw3OWcU77Xvzn+F2Od6Fu8TgvFmo+G8V35ety+xJf +b3Bz85yLSdD1crcvD6NtJ+R6muZ2/gZPF8yqfQaLh+I+jpCeTQ4f1svhZzJ7rNa3he6K6dfv2dWl +rV3dVqh2wXgHDbJQN503CJxG1YnGIPXuggcV2ugPicpTsukPnEd4nCXJz06DMBwA4Jhw4il68mIi +f9r1R4+4QSbESDSCHnZoaVm2AZ2lE9xTuPg63jzrc/gYmnj6Dt+38+GsrFEKKS4j4AETWDRUcCBN +LRWdMSABr/8iiIhU4GN3z43qLQqlwnRGIixEQBrCgPuM+4TTEANmEGJMpZShOq08h0YhnN7Yv1+f +j6k3JbdTMa8X+Qj5Vk9pItd6XZRZmt0dr7simsPD4YK+VhUsgrgTbVUcuqEplruS5sv7Kxc9jS+b +tsy25T72Ejg+m5jHN+8/Z5fnRg1WG4UabXZo01tlet4iPfbKoFr31vDaDu4vjdNQgeMPiEJ4nC3G +TUrDQBQAYIS6ySFkVoK4aDI/771xFxvFSrFgqgahi5nJxB+aJk4Gi94ieA3XHsADeA6P4cZv9X1N +PifrGLxnmqQSHJzgpK1JJdnUeIe1VCi0VBZQ+UYYSnoT/DayJlWNUYjkUEmpRQokAZGbTApjhXSK +A3dWj+vpPkAq1DjSf36+q0UZdqrQjzMBRYb3r/nSRejIhfOYPYu2L282tRkub8uLqsHTlrDX8wrO +sLqabUjqxTxh16vaTflOEx7fvb3bFyjavPv43Ts8iH6IRyes6UJrIsuXKxb8Q/DD8NRth+QPnG9J +newQlxx4nCXPPU7DMBgAUCFlyik8sKAOcWI7ttkQ4WdogSJQaKQOjv05pKROcNKg9hStOBJig3tw +DISY3vy+gs9gOXgAJAin2OBSAI+pjIGXgtrSakkoLhmRTMcJs0qGnfLgBmSpNoYJrVIqwBCiBY4T +i41UxJgYC24lISDVYRkFKUvEYS///f54ynabSXG72F32JcPRXW3vST5PohuZV3maFiMID48RYY5P +yDR6uD7fVhc0NtPRi/bsdeUmIVrxpJ8NPLkqsqxp0s2Cruez95+jY6lbAxW4k1PUeejBj4CGZ0B5 +7Uz71iNwY+1bt/47aNU0pdIvaNh2EP4CyyFVUOgPgH94nCXOTUrDQBiAYYSscorZuBLs/CRfM0u1 +akNtxTRtNdBFZvJNbIzpkMzCeovgcdwJ3fYcHsOA8MKzfY/et7d1LSJRIVUhhAYZaCwQCio4MKo4 +15QJE4UmAJBc+zZvsXGEchEplTM9BJzpQFKukEWMg9SaGwksFAZNv6VeIIKo7+W/p5/nGNz96+dd +ns7K2WGasFEWV5uyun2fLNbUqv3kpqzHDy88WYyquXx7bNYosisjPuKp2yiVxT5J7PWSwUWTxna1 +MnWH4/nT/uv37PK8QF0PiyQ9WFzqdmcd6dyA3TUlQWNQu87/A6FSTxjiEIJweJwlzsFqgzAYwHEG +nnyK3Mu2xGhMjpaOdfbQloHMQw9f4hcJtTo0znVvIXujQa97jj1GCzv94Xf6X4JLcPA9IrGSJ8IK +iHUUgdUGlNEyMlZT4FHKWWy0gAps+A49tp7oSjMhpaRW2whBAVVJIoEapS2oKqGSCkxjOx9owBMa +z7P67+/P21by9UKeJl4XTi9Xblmbbhhx3ezzPH1l5bCyuzOn+wVmnxs+sqL8murducieGvM8DOwY +EnPbzUq7PZaCbUSee6inl++/u4dH7dqKtODdB5JTV40NErhJ1xq8b9zgscWejN41zjscwisvQ1RC +6g+EZHicJcg7TsMwGABgIWXKKbwxRKL57dixR1Ba8RhAUChU6uDHb3AJTpSmjdpbRJyHBYmVc3AM +hJg+6ftKPpJV3yESEErLAgG8KrTjeQkAkpeOytwKr5kBzhnLddrqDmNPpKSGWaSUOsM9B+0cls6i +4MYLKqhGUzLG/bjKE1AKxlH9+/35eE49xbeL/p4BFet9VucvoTWiEXZ59zQNE1uxm+2QXeKsW0AU +4VYu24Vaz2B4qA5ZJa5SciiLeRtEHXeTvjqrsZk+D/L95+jk2NZ6swl+T3zTvZKo+7BD4rfR9qGJ +m78lp9fz9BcZlU8r7Q+GVHicLc49TsMwGABQIZUlp/CKOjSf4yT2SIGmqKnUIkgDUgf/fBEWwQmp +S2hvEXEgJCRWrsE1YGB74/safYy2vkMkNDQRZVRhGlWhQMGFgijRLOYMBFQ6lVymyGnQyg6dJymN +QghZDCwVGljCdGISHVdUxqhQUlSCVlqZYTs5ZTyBeBj4P74/Nxe6uOcvjS/KGV7PzDGW8/xgz982 +d2W/8OvQjh9vpnDYNVd1AaCwBZg/7/PeZcvVJRTL24AIOj3KjcWVD8eLUjxkWd6//5xMzgzq+u9I +qqZ7Ik56+4pE7W3trSMGW3QGnba4C34BAeFQreUQrwh4nC3PMU7DMBSAYSGVJafwwoAYYjt24rBF +lEaiKhQxtCB1sJ+fW9MkrRIHKLeIOA8LCxvn4Bh0YPuHb/m/R5+jVWgRCeTAMmEANFrGdcoc1xIl +WJFx4CZRBjLhWB7tdYtNIC5L0PJUASCkIjF4hAqpVDK1DDkiN8IBumEVnyZ5pugwqP/4+VpeyeSu +m5X81RXxAvhTH88mB2E3Mq5w6bnb6VleFLV6bPr1C9/OLwpJKdOTh3FzU6d9e4jI7fv8mZb5ppTj +an9/LbGcFtuP35Mzanpf2fNL4rtdpQOS2nedb9ZkgWbqA9Ft8E7DccG/hb7F6A+7IVQJnz14nJ1T +yW7bMBC96yvm2KKJo30p2qKO48RGHCWx5QTwjSZHEmOJVEnKifP1pWx0OfTUAQRwlvfIeQ8yChGy +NCRlUqZhkkZIkjCJ2TbD1N2GZeIltCRulvpRyZyOKBQGwjjzPdcPt4kbeq6XRD6JkdAsYRimbuxF +UZbZcvxrPigDkpVlmlBGaRmwwGcJ0ngbhymN4xAZIwTT0HVIb2qp4IkLOuBuJYUv+1Oyk/Q7R8SR +VNU38JIsiILEzzL45Kau61DZttwY/C9w1VWaV3A+xOX0Zp7DajWD1fwmHxfr5fRYd2Dt5fO128zG +Qzza7+puOC1okMvF89Pu7mXt3RW7oVa9Vbty/MziV7afuKlemfH19C3L9PLBgSUx+/tZ+Ol+xbxm +GizmA+Jq4zfu+Hds3snN1LINvctiqEyC/J1MvGZzNffyYho5cHzG4sJfefpxttPr8j6i79GMeJMF +1mKzesm9i/l+Ez9FF1oslvvJhOQ3dxevD48kkM9vbklf19PCAVaHu0O+LK5fXia3dLm+TPrx+Ktz +kmOaX/1LDIdan/CDPgj68TO0qCqEvtNGIWnhshdA/nbdcR4UalR7BFMjlFLt4GQY1FwbqQ7wWvMG +gTDZGS6q41hLDK2R/eFVvTC8xREsUcvGkjWSMOs4Z9ZibjjqM2AHQVpOgbedVAa4MLZ3BgNOAREM +tGFcQsNLpAfaDBCD2g5aRmK4FGcwK4oHH2yPiL47O4KKxQpqe9A12dkdULVcHKdHcIvYQYUCFbGL +nEvRHOxuouRVr/AIXvaWX8teUYROof0njlDoNdk2OHKc3OZ2mx89sc/i9NRV2BIuNHQo2KCILf0W +ZcifcXtr9UNRcXG6p0Wi7Z0MiDK8JNTokfMTxpJAhZM8eJydk01z2jAQhu/+FXtPAjb+wO60nUIg +QANOgg00ucny2igYy5HE56+vBNP20kOnO+MZab3v7qPVSglEsLtex/dIRtzc63hB6NKCOlnm2tS3 +najwvYA6uRu5VkME1gpo6Lu2jiuiMCt8p3BDO/IIKSLEwKaRm9sh+sQrfsXnUYZ2qItEtOOgH7hZ +5hPaiYqQOE5o+xh4mR8Q1yI7teYClqymRvfIKXzeXzcbTr8xRGxxUX4Fpxu5vuMFThdu7NC2Lcq3 +W6YU/pe4bErJSrgz1h+OJjEkyRiSySjupYv58OK3YOHEk4VdjXvGXvQ3mJnVlLoxn66Wm9n7wpml +G+Mrj+Wm6K3y4JDv7+1QJqr3MDxGkZw/WzAnav809m6ektyphu50YhSDt05l937b25mMhjqb+ddP +jefejc/k3qneBhMnToe+BReMx+ijPerG5dh/oRty6j5+rx8mD8t1ezm64a82jtJ5QZ+nItYA03O7 +v2rOyWB/XrWbTTLOKVILXj/2C7may656Dd5p/8eNMyv5F+vajmE8+FszrC2KEj8BqxWWgiiEitQ5 +5pBOE+CHGoVcswYKdkRpgjjsGqkEki3IU00ta2b0UHCxgS1h9T+PCByYHpGdAoEHwRSrS0Dt0fe+ +ZlJxcWrBHJXJaEiUILVsuFC3oAekqVAxXoMm1XK522J+J1FK49ujYAWj5BJwxSYVr/Vc5PiHPeZ6 +JzndoAJ1alDeQu8phYzVuSHZ6so5UeRSYdyB7KTwriInw9t7nsgWDJBW+k2AJgY8amIjG+w02RGY +NOmTa3beXEj0OZiS0Ai2N01Odc2ECtboN8hrfTqqWtZP758zqpyUAXichVVbl6I4F33nV2SteekZ +u0uRizq3NSBIqVVaXkt9C0nAKBBMgkL9+i9oW93V3/QaH1iLeM7Z++yzT5CcENDrtlp2F0ILwl5k +6ZHZipCpty1dN6HdjRDCvRD1MNJyyEkmQSe0OgZqWbiFrDaOImR3sInbFoaR3uqGBFs9o4WitgYL +uWccrGmG6rwxQ+DP8+3lyNA/lBDywHj8N9A7PcNqmW3bBo2WYqMhlqZUSsJBQOVjEYI/M8ZJnlT/ +xFTui/BBBfxLWpzHgsbgS/1z/WA4AS/BC1gMg4mzXM3967kGNHARA+Q6jtt3nJk7G50sPhv3530d +zjpFYa32ieM4kyaaOUMfnUfhMW5nI3sYdl6eMNUfB4UGsnlEhXtauNsiSsevae7lGzN9pi7kRbOC +uldNG7YxgvB1/Bb0ppUrGU0vyM6h34oyI9aAMy+9uTE6bLHtHtPLZnjEgd60N5v9Zdz0B56nnx1q +bk956BeLLV0nZbchn6beLl5tdq/xRAMhKVtrbpR23p2IbGrFM1zk3nCwTkVQTphbbqO1Px+vn9k2 +mT2234z1CytLaTSC07LBl74GKHYMPx01h0HgDINeMyGnw7lyi7DYmY7RYQE0vXGJ15MntOw/7/z+ +dC3x5NHzliOv1DNPA43JyD7ueNceGhtPD4RYtUdbgY1y26Ls0cGiSeOdbg6y9sblrwclxsB4bLTX ++dRuU9tXOsB5oy+2z6+t5/zc3O38zmtqoMyc0bKFNlNfDPOAHvjT8JwdN/PifNk9HXru8u2CPcLC +7uKoAd2zSjrernadxSM6mMnqhLMjLIMIlpXlXhwxP5Shv4LWYXO2aGk+vgRyYWHfde2kNIdnpeTW +JF7chN6u/+zaI8f03ybTAl/0VB82yNopj48DPvfdbp4YZhPjkWDTrtgap3IQvtDoWQPLtzztkmI6 +X5uhkwWbk+Nse5tVNTgdgnYSsNWiH/TH/W53AEvidW2/N7KWaWtzYu7cSydKSVzm9qV37B9nrVUY +8XBsvbw+vVmnfjFwVuPRs2AHYzN0G27VrbKX0SE0jnuv3CK/ZPTNyg8aSFLLihdFWnZmUTsmHk9a +UgN/KU8Z2m0n/In37xuhRbT8lBH56+8g50QQfiZg+bQAksNM5IxLADMM1NLlCZGUZYBdMsLFnubg +0y9t3fpV034DdQ2ZiO9r/He+pvX3BB1zRtUNIfcEcHKm5ELwFf8bjNp+SLnyfKQuAqCCScyhpFkM +UMGv11IKafYAJurwA7CER8LOhH/+Hh4VQjJcfQZiX0isUMBBERCfrzS5Kk2EuMbVmTAmQN186lwq +CMVMspgoqvwBLBXhmCiOFF35qhBF5ZoJBQFC0iQBGSFYgFMBExpRBOu//wAZA4kCuzaQQJoCKlQH +mDzUSgpZJeSTYOh4HYlqOYUSZLfWPuqSQ7kXdY4kQn5CVIXfkKpr4EVdl/dEThJSs4Jc0ggiKd6h +fgfqGoYZfbtV/0AV0LTWUfxkwjBJ2NdAzpgUajR3PEyFYof2HzMzyDm7gAuHea60vDUJZJWTb23c +IjFJVBkOcqIeA3WZ18MhZc5UDxGkicpGSf2iho1u2Uh9b8g9naEirY1RZAJGBKiW1PBTIq51vmr6 +XrvG/Uj0Aqmsw94HjGiuhi5JKe82/Oayu49+opJqQwmqoJDSK4ToKMBlT5RLau/XHlCBiqyS42a8 +H6W4jxSrI16gq9xCfUchp6yWHJOcqEcmk+qHTMSShCD5/7t37yFluEhqc3xR6bz62AA8M1rvbV7V +JEmaywoUudo8TNRpFtFYAFzwm4sJzAq1z2NCclBP7mvEB9K19PWWL6RyYe21VG3YlxuVL3dxlBsx +uRa97NWYgTjSPL9jKOYsUnWU8ziBuAIwFPWUE8jjO+TDz0SoVIX3zq+a12W/ShBxmJIfMlWMrGMZ +pzHNYHIr8f2ev99e/wPYCCij6g+4J3icJcrBToMwGADgmHDiKXowMR6MLS0t9TbEIEq2uKgwkx3a +8jOZhM5SDvoULj6Kj+BV38PH0MTTd/m+go9g7R0A0oZqToVgLTDFSMIwTXTSYENjJklLTGtAcNGG +O+Vg8Ehoo5iE5q8qImgijNFxo7mhiuPI8AhHWqpG7denASZc7t/kv9+f9VX8nHUFtuPN+TTeYpwv +682yvB9jyIatfeiKhYyK0mNaXbBLW1Sv236BqzxN6tTFHcuiEM1Jma8K1q/8pCqSwt2snD29/xwc +Hpnu+Aw92sE6tIEBnPLWndihf0EV6OvOoxH8tAt/AWoFTr3rEMhAeJwtyc9KwzAcwHGEeelT5OLB +U5ukbRJvG3bOqVCkwwq75M+va2vXxiyFsadw7JEUPPkePoY7ePnyhc/35Guy9g4ARYpyBSlhLME0 +ljKRkVKVFoAp1iY1BMeUcWUCKx30HgHWhGFDgGMsMCglz66NNpHQhPMklmdT6rgOL+NU0Pj4wf/n +57O8g9IRC0VWvhdNuBi86rL5vSgO2308Y7dR1c4czIVV+bR96VZP8PxIynFZkWyxPGzyBxqgvh42 +ebbiQ/jaEkm8CMV0d/q9uGJqbDpzfYPeACyqpTPQg0HN1g7Oo6rZ+9HBDlnpa9T0Biyc0/vgD3hT +VqOaLnicnVHJbtswEL3rK+bYIkiifSnaol6URLCl1Fvi+EaJI4kxJSok5SxfX8kBeuqpDyDAeTPv +zXCoJSJ4eZFHlm/lkR94ru1jiVaYlzm13JAi8R2LRARJaHREYquBUg+RBl4Z2uhFgY0OcSI7NB07 +z5FigKSkdhB5Bul1LSQ8sLYYdQtRwPfTZ3AUxS+GiFdCVj/BCiLH9V3fDOHCDE3TKETTMK3xv8RV +VylWweWIaXybZLDZ3MEmuc0m2906PvMG7Kws2Zn8bjJiNZx5Ot6WhZOJ5ePDMX3eWen2OHLVW3Us +J4/Uf6WnmRmqjZ7cxG9RpNa/DVgTfbq/cy/uN9TisbNMRsX8YHNz8heHD3IbD25jbrodmZmTfZCZ +xQ/zxMq2sWfAeYx41VxfBNm08epp9/DCuM3XcpGs6mMrZ+GNW07uw7JaykW8r5+423r7U5C+5wt1 +XbO96RfEAPf58Xmz94Wd+k/Zwkz3yWGV/DA+1xFn838twyjZ2xf1wpnGr9+gk6hQnhAoI1UrlGaF +Al1L0Vc19J3SEkkDrNVYSaKZaA1jp3CoQFB91wmpkZ7TsiX8shG05whcEDp8J2kpFJwoxcr3s0Ki +JqwdBO1gNfTs+pwzVQ+ltRDHK0iJLmrIBB3HUZ1QhEMpRQMvPcr3oWGuCslylOrsTejQWqvBthpe +oYbhQKPSV8YfC/nuOuEQgwx4nCXFPU7DMBgAUCGVJafwzpA4/ss3htAWCqKoVA0MHWzXiSOCY1JH +EG4RcSRmOAfiFAy85f2efs32oTcGUamIZFgYooU0GHMBIJQmJGNMYEmSCnildBZ52RsXkASpFaNc +CEXBSA0VJikGwg3FqUoo0xXoSptpn8yApDBN8P/3Zxlj+m7rtkzM86WHx63Yjd1bdl7sthZ36xv2 +kpeLTeHDnbWChEM8L4f75ZXNL1qgt+uwihAu8BM7W7xee/ewWS1JT+Z1/vFzwuPOh6ZzskWhl7px +NZLugPyg2kajMHpzRMH23VBbdBydjv4A3GVSYvoXIJJxpXhKLOe7gCxfqO/RdxyN6KF4nAF6AYX+ +rBKvEpDlFBiDKMAydUU+/i9rYZDaeNI25C3csfkzARQMkevbk0xi04ZJS5yOy30Sbc0Iv5NAAuRM +MDA2NDQgQUdFTlRTLm1kAOMxBIzdLJaSSOhTQoXydLVuZWX7MTAwNjQ0IENIQU5HRUxPRy5tZAAE +MrlUVHFFJQFtGRl11G1GIALz1pNtA2sU79mT6uwoJmc1l6AdUBg03uiS00WT7ANaFIqag1/B70Em +sYv/4/mH08qD9juck1oEfRSgmwywL2oEERC/Whvhlo/gZeMTOZPrBPgUwAfc6BkPYH3Y+JPzzXTE +ChfPpFOz9wWtATYQHWiLKhKuzOOO7LBPPAjIv2DPWjQwMDAwIHBhdGNoZXMApTP1IZ8ksgH4jeC0 +8tCpU7qT4PyT2gdlFEpsWqpFYlFesezpbbp7xv1lRgtik1MILzOtlb12ljjhrOzyHRPi+VmMjVqM +3TQwMDAwIHRlc3QA2E3mQ5/IM/zBH0q9VVIhlKXHIcGTtQh3dxqrT/QDAVyfz2p7y20RrecN6Vrq +xul6dGt4nAE0AMv/xwPHA5CUFEbTmpmp5GMsxJZE6yCePOAI8VAwsagLARQ51vgKEDK2EI8c/YZw +40L/TkRe/IGkGFH1Q39yRYnauzvzFTEzSJyxzrCPLxNCeJxVk8FuEzEQhtVj9ylGQoJLs6VBcAEh +VaISQqVCarhwimPPbqbx2otn3DZc9sTjICEhHoaHQWK8m7Tkltjj9f9//+8/P47+/j76+f14eAKL +y2v4mo2nhqwRigFc2kLKgavqGgWW0+Z2Jp6XoNsGOhN0bT8HEkGQBWSNsMrkBUwSaowVhjuSddmo +ONoNyiyhYCi3nIDLvR/wfobBTX/0t/WR8QSSuZuW75Lpe3TTOpjg4P1i8el0XuW+TcYhcCa9u4ZL +NLcISzHtErDrZTsOL/u88sTrJTTGM9awUIkOG5NVpJjUDmqQUapiF4z3wHQPQTHox3pvpImp49fQ +ZfZgYxBDAZNOJoSEN2gFHazQmqzq1CUluIoO6xuuEjaYMFgsiIQ6BGIIUfas0dVVdTEYuwbu4gbh +Jq7ArtFuGGKeYOK9MgSOOelnbOw6khO4xVSOM7QYssp5uHH+qj6b12egmoEU/V7/SMIku1ZSVnJS +vmVltDyUa4rnhjz+l9Y+wGesItBmMSs/8S8HRpmaCoUpeCXTUJvTWJ9aBSnjXvNT+9uKAouSnaql +0qaqKJDicohqJ5Eb6RjnlApcFCZFT8Euu/s1DsNMoa2s4b3SEDVX8mpJM3JovebiDn2/w1VuT8+v +z69mMfgt8IZ61uw6TbK6pYGpGCtGdiA+fA4kOtDHpAy1lVFrpvxYy+V5dvBSZm9Kh1DeLuuqNCv2 +MlF5THStBw28eD7rKBQXnjTEUVmJSIYCgwV7HZofDtXVlZrQZ/bwsaK7NHDXtLOXh/Ol3FrD/esF +F8e+7Z5A9fgmNQS91pTlp9o+o4bpGyaNUcMwLY4NSuhRSY8P2v0ajr98/Aff9oal8gnWvUDfUpkR +V9tsrZkHstKLAf2pqnicAZIAbf/pC+kLsLUCFGVnVxKLZgqEtOgaVFkkFcWbpGiwk8kCdhSNHABI +RdTVwVGLgb+80TgecSpX2pNTAz4+W3MetFwgmGr/pmPNHylnO75hHYUxMDA2NDQgcnVzdC1saW50 +cy55bWwAL5USH6F7CocySNDYZp6qeqsd4UCzzwMGAhR9NqY2Vu1v+S88H+lSjhWC0xHW8DP+PF53 +TuF+72OMYzetWGF0reeHAKZ1La14nNskvVlkgzEXAAvWAoL+L3KfPHrXU79JjvY8xg/AaO5ePCxf +eJyNks1OU0EUx3NLIBEsWAmWG1o4wQoFnEohJlppbE1sNCFqA10Y0pBJO22v3t4p84E2wMKNSxI4 +D4C6NzG5S8MLmLgw8QHwATQ+glMh8RYb41mdmTkf//mdc3Jsvf5kfVjpi8Bv29LUdWptolyJRcte +0x6oBoP11bWzJ6dClcM9kNpRTILxPHOxzaAq2kSYcCqUU6MVJSHpcVC0DlxAU0vX+KLOlMRCaNFf +6XsXGgo2+zlgB8/+1/71fgJQLOVXHxaebhoBGUjs7IDjtbSSqUAoZLOghGa4NRr3bw8lrfQGTCcC +idNwGgBlmJkx+upyIZskJNj9fSnrH17cTyNORhPnas92cmc7qcuLsLsL6Zuwt4ffCwwXhr9h4+5H +fDx8wT5Hh2tRYYMdojgSmxjrWRK/PDm58ohXWeqZBMFqTDDvf5Ki+OOBxnjOxlIs8m/FS38U+yQX +tsJdRPFgsgu6IXjVL+ZfWeEufrhxLT4mm/w5+4vb28ujl7hWYHwimNSuknN4UB73P9+TITwqD+SJ +2Y8my0Cp5XJa7bFIgrW4UHIQzsypnQ6aui9oWybncOpWdLz3B80YOjRid2jE9O8qS5DmpqItqhqZ +oLgb86mXTRePr+f93P039i+wvAIn+AELBII6vANIcA2OwDB0+uacPRa1M3ice2LRZblBnH/yfRGu +yatFtScXcLNt1uG34AUAdPwIC/MDG1wz8XSeEf/xu3+rqUz46y1XXQR4nLvP28W3QZpRLTPNSiE9 +sySjNEmvKLUgvzizJL+oUsHWVkE9vyw1T7c4Qz+pNE99sxjjSVYAzS0RhfvSARiD28Ucgr/qMxgA +lZ1tafO1J6UCeJx9VzuPHEUQFhaRJVLidgRIO8dLIrdsLD8OY3xnLDL39NTOtG+mu92P29toSJAQ +AQL5V0AEAX+FiB9BQs5X3T37MDaJfXs701X1varv+z+v/fX3tZ8+mh/TZC9J2DbYkSKJSYegTd8E +5bWLYpCmG/FZeNImetslRZ1otyIOJJIL0ZOcRNgaJTaDHkk4T4H8Jb/y0HbUKDs5GXWLr0LstBE4 +UDz+/NGp6HRwco5qOLl+vREPiJwYSLpm1JOO+TFDPV5Fd7duivUo+yAUevX7BuhqkCnkR3wyUU9c +RPqYHPp9kbSniUwUUXJ5uY7kX+17NiqXfxJIjHwOhr8QUikKwfog1taLO5jrjH+tpFE0jujJljl4 +IisiSd/ZjXl9hVrgUcGFxBqnhW2INHGZl99++vYcUq4nLuWYKKwEzsKMy0TW5Xo4EKDiWy5888tz +oY1LsYlbh9G6TBueioO3qR+Om7h1ei+/1WrTMTFgkvxaomZuDRoI0XoST62/wACAUF0sNJTO+G1P +KWQgwefQtGm9xrPtFppR1oCWXP//IMgUL1O5MfVQg5ETnUIHiooeIAchR90zABsdB9Fa7+2Gujr/ +MkN4U6WXv3337jxJh+NkbyzEoYBZrcYoYQ6cRBXICYoeqRmsvRC6g1h0xHevhxEM2hGD7hiIXprg +wKc/hnRuxAKpKQJmF+hFOK9vnDWdJy8MPScVqWsq+U56duVK0CV6bEZrMSCpUfp8JobpyRA+ACjn +Z5tJW6Baia+/EAFNt/ZKqIHUxfHwo5UdT+X7xHYJBXg0qL1QyXu2EEvSF7m8Mlqb9NgF7t5zlHD3 +czIpoJMn53eajz/LeoG1R4cTjnOkS5nTIywm8j0dW8bLjajfrqUeE4oXq0Ce3mLSMEhOBUYZIaZn +a1aAB68kxfBg2r73OUz4g9OOkGm0EnfPzx+txIbaevxKBKsuKBZ4zs+/gbOkY7ogcbCtYkXugqXM +b4sXiRJOWstxbGGbnDszSuPY4iY1kjTJlfcqZuenZyVZSbB/w7HkC/I7+/8XebpCL2ASwDfOF7J5 +KO7SQDczS+J1OlMS9Bee5FhNjXcUB3dWsMGvc6gt7a/E7YdnC1D7CZqj7l/tej5uO/ue+3gKQdpN +EGQutbcmZ3NPMbe5dcUldVcU70NasYFv18lkIvFER4vU3+yld0re3M4GoZf//HBjxry6q/xXT5XK +ldCN9Nl4hFQDyzn32eKHxuWebMI6QZ246DansJAY6opUYv8Fm7x6RcEzPxrIsV93zrllp8ma+2fV +h1CKrFHLzl1+m6IeSyjxNyALhtVYH8BAbLx02VXAiLuFGHovJ8ykjRpTDvv88MxPV6jz4io/1mkr +WrzyW+LRL5binIs4rTbMevQHi09V0VcMkTIRCt1HNINYuJkrOdxkpc/6wy6lbzVE7bdNgQ9BB4fv +N23MuuVt0e1xqzteaLY9qyk/f8h9dho4nHMu1LPqmjtUYUeODOJfMc577o/EtqqGiTLvrYzIs4LT +CcKFYfZ3Ga/3P3i2X2Zlk8yD0FBViWzacZtNkvu9aw2qPsZlRty6917Yg9RYM27FU2ofYBuDNlxt +sjdkTfI0NU4bs9MdkEQwoLXSLK8RNNvsoxq3IQRszJqJg6yHHsn15S9v3ZiXFbgP5tIzb4vMWF2C +eXVm6eq1VhWpnI/wm2xlAKIW6OJ+iH+kCKktQvMZJBvyuiVkr0stxDpwivEtDtkNSODbfERRHdxT ++MpvIqxyABVmQnLO+oiVhZScxNlXpzrypa6FrHRNqWJfqTDAyc+rH+ebl1bz3nDbsnWR8Es+o4u1 +7rG8tjxxWHbV7QQpXS2pDtBFMoBHDflqVNbH3pe4MYqWg20c8z7PMN/sOs4gBNt8uBBeJMy6QCii +BXsogntp57ecqxgzU74kD12hW9Ad9Tr/YHYSqAKBhhLWXL6Hnzzn1YsbGzRetIH+mpkvo+L+EwNt +gfs01izY5VZtr45VMn3QrnBpYHZuBs0fWpmdxP9vPPBH00AHiYaY4D8NApY3tuyQIt+Y593KrtZs +ATKkzOvmw0/EknPhpOyQbAqtFg5ygYMTikjyQu4KhUs+sYo4v6qkPRFvc+jo4O6OV3ukkOx3dOHI +3/84+/Vfb+jWT/YBoAu3SEPOrzEXfkcdZ3YWQYG5Uep4nDu8juX6OpYNRvmT78jKTz6vKbjZL//r +cgB53Aqj/Al8LveQ8fg35uV6gK4kCio0Nm6qhXicm9XIeK2JccMjblGNvPwShZzMvOzUFCuFhOKi +ZP2CvPTJLqyKk0u5hDmKS5LiM3MT0yczsoonAVVmZOalF+sDRTUVUDSWZKQqBPi5KyTnp6QmK6Rl +5qUUQ8QSU0syFAqKUlMyk0vyixQyS4oVyhMrNRVqFHw9QxSAIgWlSTmZyQop+bmJmXmbP3CvMgEA +woo3MPECbkqBlCfOOV9UQLjpu3ihOWiSIi94nAEhAN7/tw63DrDgAhRPo32fA+zS5T6+6GUFq6RJ +2RhYJLP0AkMECwwPKPkD3CzFn/CwsM1+5p/b88YEfHECJQl4nAE5AMb/yAbIBrArAhRSREGl9PCe +uh7QHUM61BClWKDLi5M/AjgUJtFdVwbDvM+o80zFwqGu30ZfcxKTiwK92iAaZ/YDNPKhHlESAF1u +fRuHJhxu44aY9dl4nAE2AMn//QH9AZAYFCPtwhEI8gIWwqbndR7GrA7dv7KqkSxvFPqQXGOIPCCH +bmxwJOGbHqzMxbJCka9OrnsZw/gE3E+YO3Uft0oIiPMhOCaQAEturSp4nNsVNj18g5kCR1JpnkJJ +anHJZDYFNT1lhfLMkgwFXd2CxKLEnJzUHB2F/LxUhYKi/LTMnFSFtPwihdTE5AyF8vyi7NSizaYK +rNwAjhMYjvYL3YvrGUBi2vreNTyApf9r/gzhzGp4nAG2AEn/0xHTEZA/FFldIdYqDaAtcilKidjD +qh5UUDwPkVNlFMTENvMQSrgSxQ1fEhK1SLQJIDUwkcxoFBmYiWFNO4LuXkvFAw+h724wuC9Js0gB +CwEUsuAJ0QVxq4Zkw1M3FCfw85PBU7izZwLBAhQzgVVFCouwwKSnrYxhPUKspViMf5M8BWYUgKwi +gKv7yA7m20I+984h+AVpV/WztgXCAhQSigmJVrajWXhcJ12sIe5Jfbm9nJOMCEdeFU0u9we+bwM2 +dQ+NIdUIB0d4hCgz7jxqfHicO36U+ddR5g2mS9xCMlIV/AtS85xzEssV0vKLshVSUtMSS3NKihVK +8hUSlFIyixOTclKVEvQUglNLgAKJpSX5SgkKqRUFOZnJmSU5lSB1k3uXyU/2XKIuqpBSWpSZl66Q +m59SmpOqUJRanJ9TOnn/NuvN95a8tAUArvou6f4YIG9eJpaIH9IW2sU8MLC0grWO9a14nE2QMU4D +QQxFlXZPkNJSGpCiHIASiQIJqkSizDoZkx2Y8SweT5ZUqbkNEg0VB0CCluvgjbKQcr7//P/sn8/R +x9fo9X28v2uIoRZ6Kl7o7LyGkNBlQIarOcTkSiDovDaA4OgeS1Cg5zaJmsUBp/4V/Nor1Msl5dvD +j/romYLpQlqELRIYI+UW10MiQ9p3PAXiEklwZVUnIRegUiyqldSS6G4G15qPwdlSI3qG4Ldkg9iL +njegDUG2mgF9KO/1JH7jGcMpx95AUlGbo23kHDmIKI8kM7hMxvhvTasHWltxg1vqdykh9GiadNfS +4RhCveOPFzBnv+FIrHlWVZPJBBaphUBbCoAdeq2qxdv3+OXmF8jnkv37DbdQHhDWLCufTtWRCbrz +eOjTJnP7eJwdzDFOgkEQBeAGCz3Fi5U2FsQLGEJBojHo38Puz/gzybKzzOwCnYnxBlZ6CU3wDlRY +W3gYF7qXvPe+1/fe90fva7fv40IUeU4Q5Y6jC3gc34KfQJvkorFEsKFEt3IcnA90+bbbfz4T14/C +irdW2ZMaYoW8lDiDZVGyKwxKTYsDyJkQ2KtTJoMvHDLWlcC0lqNmOLm/GzWT5uFmMJxWNCXRjGWh +4/wwlJKRig9sc44dzmbsuiiWud2+/PydnrSySLz1v+fX/zYRVFH5BtAhTC3oD0fJ66NjWHVyCqHO +3YKeeJxbxLqIdcM/xthN11992GE/KfvzE5Vz/33tPrzhq91rYgAECkmlebqlxfnJ2aklxQxbbzSt +rPMWeGyZf/fGxllrHmy0jT2CpKy8mGHThaw1RloTOuOL5P9O+ZzesjJwi83kaCZ3AJdCMUn6A36r +3+sStIX6yY0ISg0a7f36S8zFeJwBOgDF/6QLpAugARRG+Ml5FwwxXJQ6sTr+lkPfGKIVYLMUAfIB +FHhzUiZ5bzIt8Rvfk8/eBSoIerL0sxoDigKkdxc58j3l1zzkawA/3mgKlVl4DOA2CgX5THicjVI/ +bxMxFBfNhYEKCYSqFsTwkJCAKk02Bip1o6hiSENSRWznnN81Vhz7ZPuSZgoqQz9AJe5LMBQYMpeR +rYKpHSrxARAbEhPPd5d06cBJPsnPfj///rxP31e/XKyePG9NO4ZFA4iFROBoIyMSp40FnaBCDiPB +IIxt3W+fPguhsdi1JyryFab4LfDfOkRSW6TCBFyfOWAGwTohZQ4G4z79XB+hq80ADeCBcLae/bis +3sne/Qzu33WeyZ4aMsX2kW9z++EyePjetY5c6watJVqVmWsFXw/2un3PV6cuSR0ICwlLLfIavGxu +w5gRLsTaQGjQpkMsWZI8KUZoJqDjnIfBIRNKqP0SaLbxLfhzM/t9sRRM6ZBxf7TbeTt/x2MINdID +Xw85cyysUSGSaX4zNnpIWys4eVCeQ8Sk7JGs+tyjpoowf73ZnuP20jgmPygCaWv5WdQjffyJhbER +Di30pCYI2FH+elGr0QuG6Ie1ObJDMxSKSbDoHBGiK55xoTRupIr+EPW1IAIUzfGjz/emu+Sb556Q +U2hG9BSlRB0mb1sgDhATm5dwhMqB1DoB5t2k+z4J73jkOYNJlV2I3eE4TLSjlk3oMwtKA5LWiLyM +CRxWiomhqCi4eVcjOz2vPH79Bq1jxl0XhFZksGQeIeezkfNxqVGboKhiiphITZFCdvoqWJmuQ4cE +eJjQj95VNuQ8yS8plU8Uk2OLufE+X4nqlg6F7bSXGB2htXUPiDz0bVp6G3tIA4glDE1eghXFbfbr +b2Vt67/tud6dj+eVB8cnL5az24fV5aPGWTBrnFUP1/4B0SZYr/ARjSfX+sHagKUt451hBSIrV1/w +vud4nDuSfipzgwVTfV5+SqpVcWFOZkmqkkI1l4JCcn5ecYmCS2JJYlJicaqVQkllQWp+GlwguDIv +2RqoDCQMF1SwxZCHGBNckliSmpuaVwI3By4CUVgPNQkuDDQKTQnQsMy8ktSitMTkVFQ5sHuBVuXk +F6dqaFoplOVnpliDhaKDK3OT8nP0UjKLC4CSsciytVy1XFwpqck5iUWpCpP/a3FstmDqMQQAIYJd +E/wB3HepJf8EBeeq2CS7OTd399jRSo54nPvA9IFpQwyjyAkhju6eK8brV7Fc2XdqgpjuZYeKKACx +UQx3+gcG42u/B1Oe84da1XiwnFqAJvdAv3icu858nXmCUUSfxm2Nzc8ZfuvfKBMoXH7xIpOb5EQT +AyBQSC6qLCjJZ8jaay3Jkat6YseuNJVMUd0vzAy3fSAKUstS80oy89IZ3FctX2GxTVLq+6f5IZYX +WHeWzG9jn9hlKWKfMuXiGvcibgOudxW9+5OiD3IzSi68zggArkQwrfQDeRETIt+xzWd61nhB2kWO +M9yKId14nAE0AMv/lAOUA5BrFBDPYYhp5aXzL+KnSyKMUp1bJ6iDsX8BARRG1naisvWxCZB0Oe0W +kc+nVpAkumbOGB/7owIKDKL/HEOzsE7oGCrDZNjoVYMBr3icxVdRixvXFUYuDq3atIbYpsYNnMVh +rZElreTE0Hqza8te2WyynnUlrWtn4w6zM1er2x3dETNXXqmJGfpQ2seCHvQU6A8oIZCCoXnY9Kml +UNo/UGh/QGnyD3rOvTOjGa1SQykUdiXNveeec+455/vOmb/+7Rsf/bz4SfHE6/YZhBMh7TE4feYc +gd+D3SETnc7O1RAccd0VIXdvwnGfyT4LwAbHHwx8AcIeMAiY7YZg4x/0/VDqRdQgj33wAxj4AQPP +PmBeWCtCeXrOPT97+sPChf3G9VpjzWXDcM1HW2Hopd9OMBlKf218o/6DtWdvWsLxRVhzruy8+VYD +ymvFUNqSO8CFhFFoeb5/hJ/8iFnopkXWS7MvXy9ciLioKCGPCQM+KIJ64GEqBhtQX8flHnpZUntq +Bb/epjP449o1fRBghBE4FMzFANkBOCjIxT5/uq42eQ9Kuw9bJsbL4qHtidGg5BgRfPghSW7AVeuq +gSETkosRmx/htFcnKfULTUIVGgYGVI4CoX3TklpLdakWB1Zwr3ZV6UGf4Bo0npJ8lF2sxouo5JSg +UrxgNBelBi0+x/9YKLO7XnxeLK6VM+UiHNqsYabfunzutUQO42Idc9nnIk4OLabpqdC9sHSaHbNh +bTdvdLrtbfM+lA/skMWpw5vSU3UTxQ9lX4Uu9Vo5SCIUw7chK5i/mbrQNYz1IxXsrGBWxWZuB1ZX +42fXlvZ+/WkScVwnhfvVRrI0++LOmQtRUguhDISDB53BsFTSN1TlUzb07fNrcxOVhRtsqEJdEuiB +LZ2+ql8btsyO8qYG9+74AReHWgp94EPCpgxs7uEyuL4EW7gYl94oZLglgI2HHne4hAEXfDAaEHzr +08bl19ZV7pSbeFzI0FIEMUeavoHZfNCy7u6amLfmttntQFk4ldkXrxcuPsnlWeeSIT7gA9gz0xOt +rQqYu13rYav9YLvbpcf0JzwHfc2N/Inp5x9fjsIj637LbLWbO1Zn70633WpZBD7hVDeHLBhwKZnb +GR3IgLHQyAFaO75wGMrh6AANLVH7zPZGbFFxpDXj/Yw5IFFFdVMnUE6GjCoDlVmYn2XwVdIDe6zC +jsjUEDC7rfuttnXIZCyg82KQsnnZP46QIa1HVqvdTv18sG0+aD6e69exw2NpQI00nqM5jjP41BlT +qMxcxa25ZsfELQNupbre24Kb+cQlTDE3jcWbk5h7P3c+3bQebe/uNLvbu+bL0svGjjdy//fZzeqN +/q/JvVGPXpbc/y6ByzLQenx3Z28rmwC0EmVJPxbeffc0Ey3CPyaJu2YNUioC1afBltnZIQRfeBOa +KwTQZMGwtYDwye2fMEd+u+lJ8phO2Z5HhBR9BSE5okQOQtljdi9pJ8toSVeI3ldXIiFVGWQRq0Mt +Ym6seEnzHKk1VEiIylgQIOduZGOyMEZUG+uJVEaMOga1/bllZYkLl42tg4llbm+VYrNIiNtblo6V +qTkUE7cZUStYPpSUtXDStM29nZ24UjT54pqqP91cLelbe9173y+tZo5VMo61zG77iXKPWlIp3ohi +l5mQwWTuK/oWgyRXGDo3iymDQ/4MUz8aAqW8gunnyBMcN5SRZyzgvYnlsEBi7Q39QKrpEi87ZM4K +73Hm1mgMTECge34KnNnfbxUuR0BaPZa08zpFPnPR/XjY0vPP+3UcgHClWl3PaY3PDdjA6QelXJzq +CmBGkglYKIlIgWrP7Ow9fLjbJmJTMe08MbsJfp8DTsQsgfGyKTZncLm1UXgqugoQUaZFYyuGU6pi +H9RnMq70kO6yRo2FsU8ZPY3+vh1aoS0s7pYoZxUixLOKEadfnnw3ou3UF41REtN3SXiYokPwVJyQ +wSAbY/ld57FiQkSCStuT8XWo0PWncpiqPWPzrBrzF7uJyoZqJWTRoCyvZB3NNZPsRr59KDVx7yBF +BIS4MWykjSGJYpS7rI62Nr8+j3HOiTjUP4rpEYiEaKTTIUjI0eOhVKyZTIAVhaUczdpIrZFCI7KF +fYiFgvRHKpE5uCCkZuCJp1AVvqtBfClEHxcvhXUN6D1SMLSFynvxtHm3CS5zuMvCK8qgKiKlkroV +uu0y0oj0fmA7R1Qx3wslvjJajhxbmWK01MHS9J+/uzT97W/K09LH5zbmjK/ToulDpUPdC2GalsQp +ysaSOH+pod/2krPqxY1OGrN/NQsXo1wZLOsmy2p1qSPc0OW7GLRT5avZBzVjSUYriG96C7ZyIFK9 +yHgpB6imqNshtr31pXeIq9BZDvVGWoC2PM3Nrs+o7KTq7NT9MKvTb56UmvhyQcWT+P4f0lmhfq85 +HuuSyuPYngCfPjpZPQ/aVloaFdT56a9OvlOoUmj8o1wAvtrQpz/9fC8qVoBGkHIYerO/3Cq8F+Gl +3mVsqEz2Rp5X7aPTYd8+wkcubE/rvqmAtOAHTs+TdNQjBRTYsgYSuu8dqZcrwZgbaoSNggC7pXLA +PxYsICypHeWvUoWlgyDAGYBaLTW32ertwvtfL62gwzg3zn52u3B+9stLhVenH91741s41oWeeits +GLPx7cIfp7XfP5l+8tkr55L0xK4a6uCVZPWghLGpwKIQpX765z+88eLHzcKfvnZWaX9RahVmZ1/R +dfmLk3cKL07eOfOPi4Xxi1/bZ+qv/ht3xtv5rQR4nDM0MDAzMVFILcjPyYnPLixNLU3VS2ZYvP1D +Teq1678XhUg+my7Y2hgU27DDEKIyJzOptAyoxO2F7wRVtzT+X2pO/7eePX9e/ATbRACnnyAt+wOM +fpAAS85xOYQMXR3c6YgfSl7qAHic63vJNOUl04YuTsaKzV2c+uKMFZN9p0tvvqIwOQQokl76TBFI ++U7fwQikWGcaC4Hlp20+t/oABwDKSBg79wT2yFqG1tDnb5dUYlM+eeCkALybinicW36A8eEBxg1Z +NhYKCqVl8Tn5+QXxyfl5aZnppUWpGiCurh1UXEchNCze1zUkyNM5ON7Txcc1PsTT11Vzc4bNfmUA +40EaKf4BvF6FS3zdSOA6dx186NvY98ayq0d4nNvPuJ9xQryIVU7NnhSd3XtrmqSDfwvMFNpS83Ll +xGIfAMZjDZ79DjQ4UuVKvKoF2ONT8dnqVQhKE+EleJwdjrFKA0EYhIllasHOjLEQD0kiiIWd0QNF +SeBOsXNZbv+7W9zsLvvvgZ2W9unzCh7kNWzF13F1uvkYPmbzPfj4GfT96OhQUa0t4f52/liKcnl1 +lz+I5dMiL0SRX15j9no6S9l+jp533qYZFtI6pspZxYitZhjnPFrJYE82wsvwQuoE2lamU9o2kP8s +AfjgmkDME5SypiEy1MGtkIyxpZB0gaSaYJ4qvJGxdmHFFyg6jqikMccMHdHZRkZKu2w67LSN52ci +QRZ/R4RWhoTldT/eW38d7G73x+83vxwcUsL7AVFKENGr+mjp88jnhubDtu5nm4zJeJzrZ+xnnFAt +UnfWMJEpbu7ZA+UlkQff8prxe2uWAQCXnArV/AFY9AMtCG4FuyLUF42VrR4IxZgO1XicW8azjGeD +EJtIduRzjeRvp/qCNj3Pifky2eDpNH1xAK6YDPD1E8wGfz8ClpQg05LMMSbi76RZ3ivneJz7KXBK +cMKBGA2FEAdBP8cLN991s3K/izsTFTn1p4kBECgklWbmpDDMTDlwW3y/3s3ft1USgxPrljEG2182 +NDAwMzGBKMjOLEnVKylmcJCNYyrqlkwL1c1KDmfPC/ihYPNyswyjLrNXQWpeck5iuW5yJoPQv5xZ +cXKtsdkXfv+LWRPa2KjqvhNiWT5MVVFqTmpicSpDwvH/cx8qp+W8zDCp/hLaK/35huviyU4s20Ve +Bcltnaa1bG+xRNiFC1o5Oz99fhU+mZe1QOQ310TLzpDFcx6uzzjoYv52YkHUjprJE1kdRSqmSlyd +9rVuT/HEl19PbmQNMIs4bDj5Get5kVrJ8zL7SjglFHbbTTH8LHnhYlJ2weaTbG6MIu9S9hfpqv2v +2fu/6lp+96/73bu68iYrc4QBACN0iDj6LaF9E4+50y/jmPK1PYCEm+2o1wr4eJx1ks9rE0EUx+lB +lF7qJUh/HF72ULKwWdqCl8oKloZSWpKaphYpJWx2Xzajs2/SmdnW2JbQk39ATv0vCrl58uy/4MF/ +QPAk6M3dnU0iVec07ztv3nvfz8yv73Pffszd3ZYezYNZo08LT2bBXWnpyJlEcIGdt0zvIKH0tZCq +QXywCX0pAlTKRTp3t47q7ePa1t5uq71Tq9eaL1qN5mG7Ud9/DZ7ngbVuFdXGn0s/HwxZFyqM+ol2 +/1Xahss8ORCkNGhfRqgVeEB4AYeoKydWIEKMkCwHrMhcxbCqB31UmRRwQVh9r3Q4i7jgPR1zI2xn +ikyUrqa1BW1Yp/azvGM2V+E6Tls0umZKG8qZiW7CuQVXVyZj9NVeHE4jqJTTWspNZ+6yKJGYGYHV +VchVYvTGbxkjLkeKdC/nsmbPCvydqESMFWMfvOdQLki4PV8V8kPbzm+PvqzA8Bg7e0xDNGVZFdkM +gU8kNHQSxkMQEmRCQL5m5zhBm0K5nL51j5HeBKuJZwmm9AvSDtzj7MCMstm/mkLOupjTPxg7mZqQ +Sr38/7O4k28C18WLXI8/Ln94uhCIuM84hvusI305GG+8PFh5DPfVm/jd/G8j/Ow79hn9QH/PyzsY +9TtmoGYZrLXc1FmcR3icey/wXkDV0MDAzMREwdHd1S8kWC83hSFzmsbJXIuM/o54+10VOS9FHe03 +BUxUPSgS6nTs9DG/L20vmooCJwkwZeUyvT438VeXiN2N2NdVx84YnFgnMGGqe0bGitPfWyfPYPxc +b1QnIDvn7XGVk2+Lf/m69jtNZyyugdqWnJ+XlpleWpSqV1LMwCpcazz3ZcXHij+fqyIMHCo5/n57 +CVWXkloQllpUnJmfV+yRmpiSWgRSz6murf7SznDzZcXI6+u2rF+lGu0mbWIABCDlxQzlfQtPremb +E2a84MvRTa8Lp4Y8cm2WgJmXX56Xk5+YAjKmx3rrl0fSS6p+z75qFZF/fH0n86bcybbMM0WUS7uM +ErglhKJXq0n6cWvfuDSTYevmV8xWjCLfnh08uqUjkZfRb/r20HjbZxZFH99utmANYxS5VnbwsXeY +/+IiGeWWx5Pz3wRd+mQyeRGbuUh93uwr027Ksr90tAnnjwz4/VdOLHnzWzZ5RpETszT2LbGN6Yg/ +y1dx8iOn4Of1MyZMVuDwBwDfv68F8gmzQAoHy24wDPuDm2R5z5NTjYIoWXica7jJeP8m44YZxvX6 ++grO+QWZqcUK5ZklGQrZefnleQpJ+aV5KcUKmXk5mXmpCqllqXkQ2Xg3/6AQT7fI+GD/0CBnV1sj +a4W0/KLcxJKS1BSF/NKSgtIShaLUksTMPKDmkmKF5IzU5GygVHJiTo4elwIQ6OnpaSSnpeslJmUq +2NraKkxeYayx+YHxAgsAZtwzh/QSE/7eKi4HCB84wc7vlZxZvAq52Px4nLsxj/XnAtYN18yyFJw9 +1YsVivNLi5JTdfPzcioVUvPSM/NSFRKLkjMyy1KtFdKK8qtS8xQy8xSc8/PSMtNLi1I98wpKSxTS +8osU8jLzshIVilLTU/NSixJLMvPz9BS09LkUFMpTk7IzS9whwvlFxf55kw/qSW2+ZxZQLaeDRRZo +sa1CWmJOcepmvU0HZZOwqqipgepUsLW1VVAqKEpNKs3MKVHSUVAKT03yBoqnwzVAPFOUWliaWZRa +DNVnC9eiab35yXl9GxFs9mzn5WH0dgYAc85uOPYM19khFb8+sfOssbViKIf6KgDzP594nGWNOwrC +QBQASSuW1vIICBJES0GIYiCIKAn4QazCxjzj4vpW1rdKKm/gWQR78RziYfy01jPDvO7O5eFcX+4Z +oOV5EMyjZBEGo+EsGYRROOnP4sk0iaPxEgQDbxAkSZZCwUrTWubWYAMM7pUoMIOT5I22/GUHq1hS +/kuQjtJo2iFxE7xWCeCE6VbyAAmNYG0OMZVV0etAqrVCQbenm1Vqjc9rb7n5L6sCfN8HNhZv3Xa1 +/gZctkbI9Am1ESIyE0J4zhWZU5A7UvcXMpuYd3ic+8a2nF3V0MDAzMREIcjV0cXXVS83hYHlh/U/ ++djUVqHJf7KXHNrPOsOs7+pE1WYRje6CrpD9b2SWzznXJvpTUf7UdQmtjXtimDx1E4tKMtMSk0uK +9bKK8/MYXob4TLt6dlZcfDaT69uY3uv9GxdJQG0pT03KzizRKylm0Jx4LfoSy+X20+0rz6/YcVns +7eVWy8kGzG4AT0Y+qPIBU4DDyDo6ONsUivp5tI6c1oyfVZt4nHvl9NJpwx1B1uLC0szkzY8EO/gB +Vs4IXPoEFpOHI24QKpbJIaMamEbK5FeG58d4nJsmdk1swxFmW319hYzM9IzyxMr4grx0veSCAoWC +0pJihUSFnPy89NQihZzM4hKFzDyFkoxUhYKcxORUhfw0ICezWCE/b/NB5lB2APzqGtv6sQFAt8qt +IR1FxSsoiPi2YKliPlDGJ3icpVbfbxRVFM5UC2FFAwHF8EMOE2x26+wsQUDcdSGVghZsm7QIiW1h +787e2R06e+9m7p3Wumwm0b+gTGJjjIm++iiJfeIRn3wwmvgnmJho9MVnPXd+7bJ0UWIfmszsueec +7zvf+eZ+/f34dz+Nf1CanITrLQqUNR1GoeMwIKwBxLNazhoFq0WtVeG3Bb6h4HcaRNIGSN6kskU9 +wOh1Wl91ZJF40rGJJYV5R3BmwmQpPKL1Tpdhmq8zlxNMmSUrYhWm0hCvTlwXbI+3gXcos1yyHv6q +vTKXg0kA7MniDSqgy4URdWRA2xeuAQ1a95t3XcnxtSBM/RcUG+AMAy2+Rj3SpAa0iNegWCicGju6 +y4xyhnfHjodfjr06Hj89HJu4/+eYMR7QDzvck4hHUg9hULhJ69ccOZWgmiXMsamQ0M0BYHqBpcog +pOewZgVfZejLsEAt7jXein8zoAu+52ahIFrk9Nlz6TP0LlRyvVyObv54IJidmpu5cnnxenlU7Spc +XZyfMzvEEzSPRT1KGlccly5uMCvP6Dq8v/BeXjdLO05EN8BpK4xmm0piYlMFA3Rf2uf1gpErVHJB +zKFKLDc6lNtw8/Lb12au3077MhPcUK1WQY8B6DAxAaVbS6Ronyq+udI9c6p3smRK7DY/4jQWA9Bj +hNBOoeFYj8pYfGD7KAmLt9sYsPjulK662/zheDAiYSWXUxpeoIK7KFjO3I3ktFJqRkIFfCb8jmIA +X68RzyFMiljrLg6dobBVAwJs4mB9lwvaUDLOJdII28f3BUk2RZJlN8twiTPbaSpIePQJgxvqHSGV +/00ZkdT6M4kKBmY82xsDk8DCKRVGFJeSm44LuVVMS6u1865WkrUG3Oj+RBQxah7pqusqeVCoRLqT +vsey0BRuvuPhWjqunCNtmsduUWCYoRAp3PaZJaNuhk8xjE5RG0+iESkL/gtnFrqAzAYPMUMZ5Ivm +kqq4UhliN4tHQSf6T1+ZcRlkOxgp/HNnMuEPHSvEU6nNOkKoJlHSRZXN5l4CVPkgkgwnu6qzXk0d +iIiOkaD+qKVEWwWttvnVwd2pUf6x/3BAfMkV6Y3iye6AEnqlNNkAzqwx5DCSTprZgNqOncTS8QUF +B1clMe15LH8Jy6MMXIqmQZXt1AaFkdaJB48w8zEQlROQ1/n6HSxrrtIN8ZhLZHMqFHaWivHILu3C +M1g63Gz+Ei6/vPf+83uWdj+r9Bf+njscfnvkhTfewQ+ARyT3xDw6QyHtUa/7rJiuA5dFwX3PosJE +AszmR3ol/HjfvV1xbAj7T+1NfqgpTOHVg69POzbkTyRIWkTMr7PRWFDWw6tRKCBfoXboxbPR9KYd +D924QTsCfbrmM7KGJkTqLlVjHT7bqxXCv1/SJ5P2Y5lhYPycsaVCEw1+wg9t80Paz5eCQcknprKD +pyRIblxeWJyZnzOy6P9tLcFob1F/kYqitvqCqT5OXhr1dDNQ2cZRVt3c1hevaUeCVYc1yvgJ7JOt +95ECtKkQeIsoP8XmjrwOVaDj111HtJAIR8Rfn2NMAiZS21VMlFh1uUXcaP+3vlnWiucBeinW3iPM +DLjbDlOvbF1Y0qaLg/veR5Z65pBNbd9b0vZoRl8Pjy4OXAR9cFF0KMPW58vaZ8eUEZ4YdWz7zIp2 +QEsda2v2lvbw07r2ICiVYDFKVIy+13d4XQCja9GNUihTwmlJdf/k0XSFYqpNVmMhpXdTosjAz6+P +N1OHdXxpDuhiVEeRA2z9RrXDe5dWDLDx/iSQ5e3nbmt/jW0/qGvtZ/4Ba5637fQBpwFCCazPIHiy +48sLITzZcIfFXWx4nJsxjXH6NMYNZnysxYWlmcmbbfju2AAAT7gHkfgDFPCJhtkrgHNVXdjOcb2+ +cSaYwHZ4nPt/jnHjecYNUdxypXmJZYmZOYlJOalWCtFKeYm5qUo6Ckq5qcXFiempkwO47dmKMxKN +TM02d3N/iQYAZ5kUmH4QsIL+UHII0Dp/6IbwpPW9GV2XGXic+zuF5f0Ulg17vDef8t68DwA72wgN ++gE9GKNFOadUSgi1Who75R6cp5/+/3ic2/SQ+epD5g2cU7hL8xLLEjNzEpNyUjd/nHwwBgClrwyA +rgd4nDM0MDAzMVEoSEzOTkxP1S3PzEvJLy/WKyg2ZJC/lFOQsP7O9zgbo0WJB+7M6n5e6mIIUV6U +mpOaWJyqV1LMoPO4b3bspDVWJR2P99800C+fdPBcPlCVuampQnFmep5ubmJyfrFecQaDT+GVF5+2 +WJz7xDQ7et2VvVJ7859PAwBqRDYB85MCyGZFqjVC++ZYXi/PmvFEJQPKXWh4nJ1XzXPbxhUfq5Np +rbR1nMSKO02nS0RJAIUEIncmcUVRHCdRY8eukliaJC1JD5fAkoQFAvDuQh+RGY6bU089oH9A771k +hr30lGmvOaXXXtpDT22mx1z73i5AgJTkNtVohou3b997+97vfexffrv0pz8uffbXC0+RVq32IKGB +3z+uyUB00vUlO7249JWzsEFqNREl3GVk0/P5FnxGiSSbnMURl2JLnZuufuuHSy/A9u5x6FaXCeGM +ej/zA1b6DmIqh9O7T5xsTdgRniVuFApJQMX7SpvvUulHIR4TpEFacMyQTEjnvnB6SeiETDoicveZ +rHEmWYjMNjLYUhjVMncYecwBuWqBd6h5SRywoxoLvdoBm3C42jc86QaRAMKQR4e1hPb/19OcHqLS +efbJ+fyHnMYx82rZPZXWx+gaShlf06fVspbEA0697MhInekQKrSr68vLyvMvSNJPQhf9Rw7A8x6V +bO/O7lwU0juXf5z+49lLkyqRdADhMAxrgxxEvkdOwAy/T8w46QW+GJKHD5HFIso5JGSHZJvziJsG +yCQPykIBBg8Sn0N4KfH4MeFJSA59OURAUdgMGBUMhRlWPVPyZEhHTNgiGjEz/fKpladpzyeNBtgz +SkRgWBY5SemLK5PH6Arh+4ChspBxUSd4EB0iqY8EMqSwG0b5ceaRHXCofV+AiD7jLHSZtme8PF5e +dtbWyJtD5u4LuDAjwg8HAat90AfUEp0ThI18KUFM75i8kYRV4odukHjASDzmBpTDltj3Y2GTvaEv +CPyHETpgwMAeGpCPfn5HJRDj6d9fuzJZTJC7TCSBNI9GwQYRkoNciMwJiakQzNsgYTLqMV5XKuKC +QMYqcDrneAQKG8S51xZrZnNjs90Eaa17zc5au7kFNKu5iQgSiS/ZRLR7ZuveVmfN2nJsdsRcVK0c +ooW5URKiNBNDNTOJNLaUwpwLgJYw4FKqX3pJ4eQuG2wfxWa33RarJ3h63DDMdtt7xTK6llbFo3ok +W+uditW04aeuJCIwMnmAhDAJAgRhQUlCj/UhuF76/nPPKGhkkQFXj3yBMQN3K+iTTLG+Rdeql0zm +ytFg847yoFZpFSZUNN32xS7ts1uhZAPg0qesWT6kv3xuuWzDENKRhgCKx+iH+pbwMDNAQa9wtwoM +GKUOmKoeCKMUjizuBQcQJkgpM/WpHyScleTklCL1Ks5m25nBQCAuVh1VWRQA0OW4sEdUukPTKRAD +gHEAAM0maXUsO2Dh4Ek5JBUIzHo5XYuYQIJEIyizkpGI56kJoYLL+3GgUlfkKaht005AkadMcKGG +nDJAqjKVu6ZSWzyY7Zxx7gyLlccE8SKVt0oE8YGA2gmqXzB25my091U0xGkLhjVSAN6blVcNK/Mr +JkdFoV1xbUJuZodfeagOWGDhfAi0JzYb+eXOsBcKnsy9qsoE4l/ZCUD0sPTNLAT3a8OKG2RYLAqM +1ljLFVZnbgWQQoHUrWUCFTgbIsASE3I5rwzQUDbIHuUDJuGomiyKrWyqKAgADKimxfch6+0X3+WW +NN/JVop6abakjTnWgSulv/54dc24uX3jrQLnfepKYWtFKkTZEpybVqxnvq9oWu/53cbFloB9zIuY +KOECewTl0kclL4vsvsrtH7LebV9mykr+1gmKPR2SE/qHfTj0AaMGUjKjJ5id+P3Nmm7e1q69Zq9f +s9cJ7L13Y+9muS7MOh7ofmf33R07plwwUxelJNQLclkNZ/oPzagup7/bXrnQTb+6+fxE7ehWEPPI +ZULYWWdXUaiSA2i6YFexnRGErWQRmPXO2AMqJiYW+6pSEQdU9iM+KngVJR3f+sFEwS0nYx95D2ZP +9K9ldauZ6Z18cTLWKwt/ZqjI6nDmDmW6AoKOA4BjgSEzVPHcMjIXn8GH96gUXWthN7+ULm3STr+8 +9Gz6z9vf61mneSl3dVWVejlj0KM2jt5mwQ1esBT33L4CEV77v49RMJ0k0FNPoQjMXUT57BaIc7QN +moILVYQVKB/tZ68FM0v5KlQYnq7Wr0xQoJm1KZyqov7ZbwRrbr7Ial2D3I/8sBDaXT3pAfQwfCZK +s8Y2VM68zzoOuaGKH1QvaMgRSn8bLq0qZsggpiA3gZmU5vL7PMJrEUZ54MM2hUlvFEtbu35UulHq +vPGjbfB6Vc/sRlXdBr5qNc3AeON+Evq40y1o+LpCxsbqiSaNu+nfXrfSn+xc/hDp4w0YGVRq6hII +BdY8Z0IsP8Iyo0A9iL8Oc7M17uZDbfrFm5OnYfmxH2Oe5MU1/c3e1UsL9TdtGld/inkyB5Imzp/z +pby+WMoJZFl6/fXa9PO3/nVxX+fYnBBroV9An6jOq7G1ikXqLNba1rxHfKAT0ko/G9xOt+M/T//w +7oOXv1t62BrTrw8+Wro1GyZFyyjvdnBKRZEIYpX5AOvQOEUVo2gfgK0T6Pr80xlmG5HEKrAelNvg +GN8EKEZlRnZSRWF653jliZ1zbbHOfaiZvcQP4NL6mJ09ytSrbfqLT75eWivLqZJdFYyzlUy3Hv3+ +wsb/Y0NL9dfU+eTq8za+BetZaVU3NGe9Iv33r65Mis6B3WD2ldmvY1g5RdcxPUVfDFlzBsTSLAHV +KwoOmL5V+vmnF1cN9TZXWQKdF55GG8WbIVeRPnpUmb7z6Xe+/R/srMYG9gvauWmVqCEfBu2gRsCv +UKctY4NPbHic27CK62Mf14ZLbNPz9zOKMepsPs9WxtHcLLu9WZYxY+H0n/sYlQyyU1MLMvPSFdIy +c1IVkvPzSlIrShTKM0sy8ktLFPJSi0tSUxTSi/JLC4r1uBS0FIKn5+xnlNRSSMsvUnD21C0uSE3O +TMtMVijPL8pOy8kvBxqRm5uYl6KQASRygAZvb9vPGKM9fe0rRi6e3PyU0pxU3Yz8/Ozi6QdfMSqC +hTlTi3UhMtuBYvmrAP3uRtZ8xT+td2ddpkiR0Lg7RKYac3yKB9Z4nGuynGK5QY9jswxHmggAHDkD +wPEBYkHaVZCVDkQkNFuQC2v7t52XCQx4nHvL9JZpgi6bo7urX0jwRmMrRgA4VwWD/jrrUAS6I0Fz +0roBuMQOy7D2J43M53ic61R9ojIhQMXAwMzERMHR3dUvJFgvN4XBbZd7V3hl2Yb1K08an6lcJyn9 +wtd+4sw8kZVyntOv9d/QMtp2c4ZBkemaNSFLrDdLM15gFFkX25y8g782jkP0W26t8J2Jf/Jt507+ +z5QkUs3G/P3DL4lvkZG7l7pvXmX9U2DttcmlzGUirPOu8WVJ6LrrrN3G2X+H996SndxFk/8zB4t0 +R5xKte9Z0dPw/Z+NwZHn7XraR2snp7FYiSwS6Unne/l/s+/y7Pri1ZreDPcWhm/ewqLKFNN8U8Rh +1RPF9WldU/n4lCSdVpV0BpgYAIFCRklJQXxWcTLDLJ2gp396evas2Lv+e/32RxaW6i/MkJSUVBak +FjModVeLGffsj/Tm7CnRtvJgsK3RKp1syq4j8qXJ7+5JqdqP5nKf8jRuX6963K8+a3Ipe3ioRcrX +a3OLDUI+NPzYvPy6zY66RbLrIMZmFTPYioYKB6S3bOYs3M80TUtubop0vwFMMr4gsag4tYhBf/rJ +RwcUz3U8OutY7rTXwctrw6S5kxU5LI3CbHXfbLwmnXCCTfpjyZTk6wWczftgmpMZkh40XnmV68K8 +zeYWg/LG8sDJWm8UJ/dw9Ii83CxcqLHa/1LRMuuCb+VWkrJlGp8n63DGizhMizELmvtBsYlv83Gp +vLqbaXoSRybP51wkwvBjeras1KkrBWr3JDIavusn/69cMzmUy1Tkw+u018w3rhQJ951m1JNNSbgd +ffv35Hlc+iIz7m7ZqCEbfkB3nsCndJu69ulLj7hPfsgVIMI937ZJ8F/bz98C7/6zefc9FtwWcW6y +K/cVEaPI1ellZo+y54ro9mgJ2xvmBmy9N1mXx0pEVOgQz6r2mYIXn61/tU7yeVPFKqUDk6t5YkV+ +z/ALquC69GDx/efrV85im97hdPzk5Dc8liK7/z5V8zDtuRfHvev7KrF3ru/OSPNstuTVZhTJvXH9 +k8e5aB3jcE+DhmO83xdrfkiZXMFnYuFfL3oncsIN4ze/5ky0rxV4+yd3AS8kKIsLEsvz4osrixnO +5zoondhZKGudsndX11I15atc75UmP+E7LLIu7YCDw6Go/Idbco/FvW+pnxxVHbJ5N78iY4iDI0P/ +xnafFw69XwtX7D38T4jjhw3E2NLyYoYTbpIrNc66MiSKxav0t3H0258oQMiCrZy/6h37ZU6RV5kb +uNSKL77yjBU8YjXZQNBf5PXGyys+73mi9Pz5zjeMh2O+V7Ct8Js8WfAbALwMnU3+CDTa/8i2uMg7 +haRhX4sSK67kis9SeJwVjD0KAjEUBtnWU3yVhUj2HHY21iabzc+DJS/kZQlbiOfRShC8hXcylsMw +830Mn+fwCurOBZRgoCOF2Mx2PSibswZ7UBVwS5ic0Ow6HtEi2bjTiS+J/Kb/qRZbKFcZp5WWeVy7 +IDerKhrRCCpjIakKp34T4x1aMTm7gsBO8L6p8/4Hrwoz1fQIQW3SN/MqR+0VVb2dHV4Wd18gwpB4 +nAGEAHv/tgm2CZBuFBq2hXSk/aFlOYEerCVJckk8h9R1sYJjARSRXjYx1hQfox1/UtZ/c2bf5/ZE +ZJP5AYwUWGZX1UrICuJFzeyJaOLxVWqyUdCTmQKkFFLDWBF/kPl5S1GxyKdBYuK3dAbvs1EDBAEU +HJCDBPI6tyDzABgAdpQVK7f3Ly6TaQRNjUE6mfAUrwWEs4UiCDJ39KIHSPqm8wYnrVN4nFtZ+Kpo +Q5n4ZE9xQe6ixPKQ1NyCnMSS1Mn54raMlpvXiv9kElYAgiSl+Hhk6flSm4HSwdKLmbiQRN+Jq23m +keNjZLScLC2vymg22VFeykBfXyE+PrWiIL+ohEsBCoxMdRTA4kWprqgyljqTe+VlN6+WL2CcLKMo +zwxUNblRW5gbodV8cqyi0uQGRYXJCxVFJSygBpUWZ+alwxUZ60w+rxgyWUVJBWyAn664LMIAE5jd +CJdvTlb6wSJhZKFga6dQnJqTpocq66uuzsZkZDG5QUMMybubU3VduAEFO1zz+wbTQlJrdJ43P1MA +uDiSMEwpT3ugwXicAWsAlP+JCYkJkIgUokvnbzyNX8bd3PS+6t+PfZUEtLqxnFkBFEpEdOQhkW8K +GOHrkSLaMh6qbxA5kwkCjBQsRS4VjxeNBnF/1AgnzwXVuOplmbOpAoABFIvIWhYdYEW2bkgrGlbV +McKW5XPMkz0ETC4WLkDwDHWE6rPeViHKdPNb81BpjElqKKkheJy7MZ95wkLmDWud6/X1FYILEpNT +dYtTCxKLEktSUxScfTwV0nIS04t1FErys1PzMquAgol5QJyTk1+ek1lcopuWmVOSWgQUzswryVdI +LEovU0iq5AKalZCXn5Ian19QkpmfV2xlBVGXoKBRnJqqkFBakpljZQVSHV+WmVoen5mXqVmSoKnH +lZdarqhRUJqk4Ofv4hrvHxDi6e8XbKVQXFKUmZeuo6AEEp68Tl9ycoA96+bdzrI9AHPBRFb7AQtc +mAXRj2ZLXThuASk4szq4rrMYeJz7+Yfn4h+eDYuiNm+ISmZs1o1p141h3K4bw+TzCADEgQw1+AYV ++KwCLeNDe58BoUbH8J4d7IH8tHicAWgAl//zCvMKsEsDFDin0N1/sBqmUchOtMH7cLxyOF5Ls18D +TAEUU3bwnb6fyc8d0l+avaBz5rN/0sqTvwRCFHFZnODTeJc4ykwkVui4JeAU19WYkxUFShQOG0SF +Qwim+2Vn6z3FagKBIVZ94ohWMgn1Au4VOxpWjJyClAuACrxQ81uQGoH/eJybyj2Ve4Mes8j7Tc/N +4o/6r3hrdS6a3VVsTf/z/uDJjczymxOZTZgAMgMPSP4C9IZWSv6gj+a5dPT76+03nHCKcyF4nHub +tSJ7wxIJ2YzUxJT4nPxkK4Wk0rz4xOISKysfIM/K1TcgJHJyoLzU5gUSZ2UAtK8Rb/YvRXvGmT8E +ZBH7o2EuAoCYUepRB/54nH2Rz2vUQBTHKeiCURCRVYQ9PPegSXbNCt5GbC1YReiC1gobtMzOZidm +aDKJMxN3Q1t6aI/e5uCx/glKD17Vi/+C3v0DvAkexEn2B0tR5zTz5r3P+37f+/yp9vtL7d0PR7dc +6/QNWfBAv3Qb+qh1Vl9yn59vw6CZpMM8prO/7l9iDf3NvVk/EW9uPfO8Lf344OLx1dbXOu10OrCR +c8USCnFKhlRAmAog0B8SRVAfnm6st2EUpZJC92F3DVSRUWASmJKTO8lVlAqmCs/K8gGEHMpKnIsY +T4C2erPcWGrsD3KOBZVp/IoKhO6ZJMNGKCNCUjxihpIrHEQ02LYVHSvHgunx0m174UX4EKuIcnt3 +1mh33tKbtnQW8nM+EiTDF1Jhr1e/CG3KsWPt6Z93v+8b/2tGUKEixl8ACRUt3VfmS+/XJQRpkpDS +ckaKEt8GxoM4H5b5/ZW+V3ViIUglTEgiFBGJM0FDNsamNitna8uYBbTcRUVuOrAzEXj8fvXUZZdJ +PHMAd/4L0iu9a5tzyu0KElMFSa6MPhWZciNlkbczn8R9g3xkchBinKlq5JiThMqMBBX43ARsqpqO +pd96df2xd0sfva7rVf8K+if3SWoMnlx6Kcar9jhF/eqhM96sRvt+q1Y99g4O/Q+H/tLygz8uUf27 ++waQ50jTxcSjtc/BVNs5j0SG/UkC4nic+/Wc4/YLjg2y/yYfcGfhyS0tUSjOLy1KTlWwnaz+z3Xy +BU+W6QLmjGxKegWJJRl6eYm5qcUFiSBpBVQBay6gWnGupKJsqAGTH36WnX5Xi5GzueXf9pZ/jGWm +ABiOKxX7AcYsyU+5CCthid9plWRdqtZ7fBUbeJxrZGpkmvBWZHHbok8S23Krj13Lcf8bZvKO9X7Q +JwC1wA338QUgdumUeZWT06RjNCEqexvQ0HDSDnicu7Kb6cpupg1Notz5BSWZ+XnF8al5ZZMviktu +XiY6j5kHSVBj8kQX8cmSagKTHyiwTNYTFd7cJ/mhAVnb5s5Z3swASiMgQvECbbUNd7E9PTqm6AGU +3j4tIR9A+Ex4nLvDd4dvgzmTiEvrwyeSyctkhNMFlrKpf9mix6/LsNmbSZAVANctCyLxAsGy//bM +yi/8roX18jP1xB+M3Yg0eJx7y/eWb4MIm4hlSLeLpgD3zeZ5Glvkr/qy5iVd2btZg82VEQDPvAwZ +8RA7SYZrIvEldyRuRxlD87LJtDWUZXicAQEB/v6eDp4OsIQBFORcq78UVUvsCCQcN0FsNjBARVOi +k5gBtxRTOyPuG+QKcMDyzkwDAMdT0OR9fZNjAskUHxEI3yp9kNO7j0Sw4heqQmG2Ji6TQAOJFFsF +hS/nkPcubGSYlWGofmzS1T+lk90DTRQu2WEGPOOUwMJNNaVSONXXS2uI3JM+BEEUuFs17/eZFOXU +9iPWA6NJ3Gq8X86TkwQkFM0TRzZNRmPkLNfkfpmzikKZUAgpk8sExRSDsInU38eghzSe2WAwMMEd +2Ou0uJOkBSgU4XeQoSTOehir5inhT738/LuwAh+T4AWNFLIppKrC/KkaSjLWLnpxBTiVx8Jpk4EG +nUGPdxL5Bo2QTJSyI28WHIzb5a6N2TVRZtgxeJy7bL7ecsN1lslO7MKinnklqUV5iTlu+UUhqcUl +mXnpSjoKk2VZEiZrSQqZ+eWnpIb5OufnFmTmJJZk5uc5JyZnpOolFxQAVSllFQeV5kGUBOeXFiWn +Qg2ZnC8tvfkZy1sxAMmbJiz1Bs52bgK2znupgudqAT8+sy0dF3HfeJy71s3ytI1lw31Gvszc3NSU +zMSS1JDM3NSiyfE/JQR0FIqTM1JTSnNSU8CCm78yBjJufsLCysgD5muUAMlizckTHSomL+Bg25zH +9vw7mjmbo/9XswEAFAIovrOBAnicpVddb+I4FH3vr7DQItEVDQ/z1tWsBGw/qEqpCtp5qCpknBtw +cWyv7dCi0fz3vU4gQHBgZveJ4HNzfH197kd4qpVx5HdCLZmRxKiUNGaZvJplXDgu7ZWjMwGNPy54 +YfidMEGtBfuNu8VAWg3MDcEtVEx+bF6POhuTqw+0ueKF0VWaW0XOItkFU9I6klKzhJh8JS3/dE1m +Ua/Ydoh/20RTt7DXxACNlRTrHfyMwOvbJfn65wUprKJEUDekuuX/4TrawqcDGecLbXTb74Bkr/73 +jfy4vEQv4DM/UwwJzYTDd2JA1w11HN1rIXfhYKsxsN04hri3HmmPNdrkFVFCGr+t0ka7eHxUNAaz +/Tedxtz60I1pqgWX82ejEi5CBpkGk1sdgFmquzLuC6CmSlEY250xyNM7bfDgRpbPpVbWjR01LrSs +9G7VGcrgWXFZNd8Hdi/M2fZJG8XA2kiqv0AbYLQIYxV8Lp6+USPxILZqoPFCcf0EhVsY9XEK936e +w0NevF229/Rws6Iiow7sBFU2kHdCzagYM6VhJ43mE+6wgttMslxPzehJxfD3sK9SzUW+e5+yBfS1 +frAvmSzQscoMg1tlJmBR6fOtg80C7vE8As1ozAzXrg4dqjjDrK1BWe5B6VngfPdKxHYr6PJABesL +/JNxA0jjvS/3OAAxgk65ta5aSXTkOs0to2no/dHsHWtFMzIFT+g9veU+ZfRhqA5uKvBQQcCAVQKv +CwMjaQp7Qel0SFH8WpdEJYSSOZJjTaEyJm4BZIEPmFKWZBLjhfXv3TZKUPAlXGN9y3dpk2RD72sX +iaK9kL9glfMRt330qrd+yn3Yhr6Xyc2d3vm9w0FvFiXPerGdvZZj04NoVOBDdQzsSxEsM1lQV8ik +T4Ww3uHTUT0myh07x3N851WisV7vwoUN7BqT00VWr0dljper7/XQioeBzorXE27Bet6txTn6o12q +x3xS7kZmKZi8K/sw+U6qfKiti1WGFYEcLIExgaBrgWUO29kYnCtSvGFBJBXLrrQfqOunTIiuHThb +yid/oTnIkwKbP202AuXDN+lRMqTYzTfVCF/yQk5x6cgnf+8Q+6ECD5E3l0zn6bB5LUnA7MlgM1RU +aXCooBJr9z1dQTGV7HgrpHVjzDblN0GcaoNNbWoy6XgKU5XXJywEXBJrWGez3nm3bLpQamkjY4vK +UOdyFPK363MT9ykjMFkAN3f57di9Cuznn7hrHE+or5J6dyGlgfQphSIKoYM0hZhj3wqB4y8+S0PI +BE+IPgWgHja+wGrl6Lt19H6InZXOIYTKqGvYAntmGBx/6QsO0h2j3vHj1XvwBcUeA5sIhYC8WtW6 +iLhGWVSRsk3grVnAedVrhEiqOU5eq1wN+R8/NIBXDiV+vKIuM0Bahfk0t/CUdoo5q4y3SxI+nal4 +jaK6jMjIz8CMofgoY6Cd9Q0m3ddT2T82KnoYd5mfZE4NJbcJ94PBxD5yuXzkM0PNejc41FoP6fJw +gDhtPsLRrULur/T2dhCxpEKzBWKB89TRKk64y/E6nSkRak04R+Hcxv3k9KBm+we/+fTZ19yn8/W6 +FMtk+PgCH4a73XDsqzMmdhQbX8Q4w0undmmrxbummJfe4U/5NVIOmtvD4ZeJH0kwnqh8Cf7yuviZ +UrXDD5b2Ac+JWPdZPa33EVUVMXZMWY37OY4614I3dY5s37iWcU8q5/j6pTh/JXQHMv2v5//ZHPtf +Ifnp1PzFQOFn8b/CkUS790DD4000TCgpbWEZIhxJJ0AgVvsPf3icrVNBaxNBFD4IpghS0QqSbM10 +JTaRdHtPUYRQsWIMmhQPIcLs7kt26+7MMjPbNJSSn9DD/ABv0pMIPXjyJ/gnPHtQvHnyzSYbNurR +HMK8N+9773vffHtx+Gv4sVeZ7e6SDvfTCEgoCSUejSLqYgQnCRdqj4RKEo8zqUTqKfBJm8cxZ896 +JM5QkgT0GBAoIaGCKiCMqhAzXkSldK4R4jqmZ3fUzptwUbcZ96FlOuh++ZZ+V7H050pZdx/c0T8r +Nf14rao/1K9uLOeGnOUY/bJsaWo19blV0dPqdX1ju6a/Wjv6du3e5d7mxZUDAeNQKhBPOX8r7SY5 +RRKEUDGWLXJKApNtISvKpuSsmd0JUKlgWZa7R+ApZyRABnpz3dLn1Zt6Z7s0ywpJDh8sQrOeSJms +uw6jMfh1G4E8Ogaca0ec+naj0SzU4kYKmJI9VAH8A5bhjF4diLmYFmodxxkUms3m3YZOTJO6GUUe +PlrWms4xxC6INkqNLAamYpivnv/oCFWZUOHjAnafp14Assui6euAqld88gIxqNcKRIWYw+rnM3xa +8edlEGaapcyHUcjAX72eKz5wHXzDkI2bS3WbC08Ynw1XMbhwGikcuC89mhTovDF/ZwV9lsdFh+VT +UrPewN4/QcKMRj2FzO1F0USECv51rddrDf2FfOtIjEOvYNAIMv5Jf5pAz8ODMqe/feUZwNxWDk+M +Y2mk79pb+n3pyf0F1bwmZDIB8zXlO8wB+ntpYyR5Kjzo0MQ4aB4cisgEyAbQTv9t38tPWz/WfgPz +7Dzgs7EDeJzVWV1v2zoSfc+vIIxerLNwlH1Y7IN7WyBN3U321kkQu7d7EQQtLdEWG4nSilQcb5D/ +vmf4IckfcYN2X+6LEdPD4czwzJkZ5viYTVPBitk3ERvNTMoNPgRLC20YV3opKs3mRcW+vorLsj+X +mRgwvcpnRXb4dcAEj1M2r4rcboqLBKrm9u95rWIjC+W+Q6viuYhYUYqKq+QoTrlaCB3NapkZqXSE +wzVfabZMJVTOpEqkWjQWuFWvOhi7hJHtQZo5ndgTTokOZF4WlWF/ZVyzmTO0N6vVUTj2yPBZJnqv +g+Ajg45EJJf3omJPfkN0rLiR9+KI/IOhED+IcaBh4sGISvFsYrgR7A276Y26K73b117wXorlmeCl +tkLTVSmSk6riq4kpKr4QvQHrLI4ykQuFc5rt3p9TnH+pshWUPLKYl3wmM2lWQ9b7pqHCpFWx1ENm +qhqXVNVKk/Blu9f9BL8QDas46McnHDYiIfNmEW3t96bFVSVzSZ73DmHKwfExO0FsK9wMr1b+GjYg +k/M74QBDS3mR1JlwIlzf6QFbSpMyF87OzeFiJS60WKrIWzTji8v5h0bgDeuX3KRDNoveuau7wtcB +y0U+Az6G7FrwpIC3v16LGBb+qk0F/Awg/0GKLHn79pC9ectuDhiLomgWERh1yWNh1TZ6BoirjhFt +hHRsbUdYM6mNPsmycTjLBfFwEJRJlYoK9ntdvUsbmKisClMY3GoPorcNZgKk4ZJH+ZZXToSWpwRP +QgaZj/NmkQawZBy2ksELYQxJu12DdWCkAB18ALwdqDjFkzQvhILRMfxoLDNm1Y1475d3tZpO/2jW +fukFvKTGlOuiF4DX2XR6da4c/t85+9otuczFaca1Fm7D+Hw82hK6z/1So/P38ZZQjQSNM16JJJgA +6VlUAHDVUmrxbtVv3INzx47hkByiC7lMCiYVkQWnnIvYRREQjRCrpAVxWmQJxRWLju9Sru0PBKLA +bRbQlv8W+EuvUWDAdF1l20H7dP1xLcDrGanfFzmX5OCjQ9sGExAGebUAKB9ZYkWHFiME/igrwI/Y +Qbp5xp5IuBKmrpRupWjxWXQMDp7AykbquYRPyCVvqc0pxwgXHdfvhCid61pUMP8vCGLGF9qGLiMu +0RE7N2wuKb6tHJuJFEt2ZVnxsgzhdoxmb4KrlUkJGSKDU3QyFFXIeu2ow8VFW4Ipaks3JJ0WS3CS +WjGkhmAl4S+J2hjP5aKuhJ44M5CSQc/zjFL5dYTjkxaTUsQ3t45eEMk+XVO4Es8DVERGCruF7vul +O7HSzVGHUc7LvgUTURT9QbwFo28PLcms3RqhH/ETiftlqwrY1bVKYFdq5N2wiZJbW4K0aHWtirmf +9iCCgTL2gkI82FIKM3mdgckjl65Wk+4Tia1xe79LOwPmAihxALnkvj2H/DbUj2yeDF3QNgC/Eb5Z +UWRh2cXEbW0rYGcXT3ZH5zvxYUEHQHqp2GdAm1AswbC2OnKbFYxnhUJHNAKelymhk+A/W+FKLOWE +AurWYUMuyamUJ0gXZASSgM7Qwlzz5dhW95+J1sCetb1K9WZreWdo5//4+67IUn3UyBLENpzRBLtR +T00Hhfu0QP1A69M/pBRwAG3Xbrcu5wauNr3VgBxfu67bIB6gfrOrzdqz78X3fG4Bj7zUvhPO6lxp +T2KCWRrzZWMuKyq2ywJU5iwIja2tRAPf7EqitzlFkklqj5ATTKfILFFF7J/gXFQunKnjSpboIp08 +97xqNW1yIVBGNZIBdmwJYwIbkgtoIhxOJ/K/P4Yk3KXdar/8WO4FFS9Dw8DWMCRC8m71m6CiDwfE +A/7UAwfHHYD5iWyuXJrZnRPvKno8hMfQ4XSeY0f69F1HMwXh8mKeZeAX8NpEGNIEd9FzUCmhCtbt +IYzIMj+MuYtH6dN0b5HtAckJlfS/vnrscudT1HLB10CkwQBXeNwQ8OgHOFQMdHjD4TeNLs/bhGRA +y5hQP9m7qopYaO0bMMh8Rm2O0l4ISCbUgnryv7Vub1D7Wp8YTAoNGRKAQjLj8R1yA/znA0TV3vZZ +MXo0hSGrqmz9990X0KKE76s8AbryfVoDDfmlpSg93Kru/YBp13MMO5Nei5H/1LISZxhkznwQuuzV +QneCah6bMdKpSH7nmUwa4GxJI0jkxRlFgnqhLty9SM4f3HEOVVu/F+rURmJEgdhlNwSaoOz6na4B +A0yxPOPZHPPgLkuffKvRhPOk7Bj8J4nkDzk6DuEHt9TK7PJ3l6fttXX2hR7Cn5FU6MjHMsYkSOMv +pd7OVu67w/ye+a1NPj9Z9nuOSoanZTkMc1kU40sMEjTimVGtR6Tp30XWE5e6UMs77dTsesrOPOP8 +DUPItDjRsZTDjTFm0Pz8Scm42wo0AjJRHLsnp+fnmz8G2nn5iE7yjpYiUyOAzuyeH7sav+3qTW/N +dHqR2TCWljrm9W7X+vY2dqDlbmSeolePJPT01XXzLpieBO0gUtUxypjrAogU/ZSMr64TsP0fPQS4 +FzJVdAYhfEMYayMz5vpuW//zaJuLOwM4mNgh5qZHY/gVmvOcMGe/UYME39CimvGaf9Yu8q6jqXVu +YN/O9FV49BiyOYeBgOaz2PzXpD29g0+3vAuVnYMP/b1qIVRoTZCnblanRq8je2vzwwVdV/HxNx0f ++/cTfeweGej4iNWK1Llnvu7DJNWeCikOlUeJAK0kQsVy+/Vy7ZkyZ+KeZzU9DHIU9Adj1aDfxWzE +qR3Jdt1S8wISqqWLie16HsAx248ffmDT3xWJi7yUmQiL+3S5xLoI6e6ah+c33H2U6k4kzzRE+H3k +I7FPhIrbHoH3lxfTL6f4GP17ev7hjw05/yLtRD9NRl/GJ+cXQfzL+9GHk08fp18+Xp68H10/vzUk +xcT21DYhHMPsTYfmyn4qGVocDm1T1nJ18wS2lgvNqQ07+5fBbaWn9uJt5ThFByU2asG2ALW4+kNR +TYU27tzHMCQYV8qpVSNGiuaokumOpwj37vj9twRmu7524OiUxyI8nzQnPH/GrieP/T3/nsePlw0E +T4GB/m9hvyoyGa8o6H/aiL80cI6MP/uBlApc6YYNO5hakkQbZf9ZcHSEwgYVVmt2hHIpeH4kaQze +k0oucd1nJ/ATu/scm0eKoplQJ+nyqrAkcPj64H8O0RBJv0x4nH1UwW7bMAy99ysIn+LBde8pOqAo +VizYsAJbgR6GYZUtJtYqS4ZI1w2K/PsoKc6SDltuoh4f33uUY/rBB4Z3oAgaWAffQ9GM7rwZjWXj +6JxVY7G4PDMZ+ApsegzXYTP26Jhu0Noq126UtY1qn2IJdnuu+sIpNs943kqVaiahOsOXxNV6Rwyd +chr13TMGuIKm/nO8PMX55he2/PEYfYy9uICHzlgE5cTL1rWxjfGFwRAQcgVZiJQ1whPiQKCg3WsG +sWqkrmAKahiE3a/BMIGfXCWUWm42yCwX3CmWCk0YCKZ4kAFPOGQn0jGyYHAmWkZBWXtudR6oDSbh +CXqlsT412qvtdaJ/yAyfhHvlxO4iZrgE4mDcpoSr9xJXG1Ax6pVbNHWeUkk1W42LSD1lKaFLQI8/ +vbuXVYnEx2gwykyrO/iJlTmTN7Ko7VCPFvV96hA5sZWWMm7efLyhJGzxegYHoiV8lxMIkNiHvdgj +iX+9nrKs9g2RAnViiz+1lg1MKmgZW9z7USTRnbPbBwn2q5++KJlfVHtwkjcfVNhIz/cfh8vOJOkB +abQ8V2mQOPV1wkqeEr6sdFEMigh1Uc6w3CQSVhsXDe1H7hIgjcgdMvC/nk++orKUzl359vMwfY/a +yI7n2GMW2c3rUcI5qvitVofhTa3cNjpk2EVRAXkMLlmT587KtbgoVjN/UdZrwXZV2tygGmMNb8Vk +h2pIDrkLfpJ2DiPG80hx/afvYlF8Fq6Qs4phxtSLDy9Sc8p+4zgoJTQFw/ivS/mzsRiTkcC8i4I7 +TxyfiEQEJFVaG5R/rPp2dG3E3Bq0+vLsNySlncHycYDS3Rq0Im2AT8UxUV5PVTmWYxUGeJyVVc9v +G0UUFmkhbSUICBKqOCKDHTe26zhSVXFwQBUxNKkqp2nX6qEtUmZ339rT7M64M7N2rSrqlSMwgIQ4 +cOWKckEc4A+AA/8BAiH1iBAXLlS82R+JE7eI+mCv33vzve99772dX+58Pfjo0QqL+kJq8oCwKAKf +UQ0dFoEkeySQIiLFxiqnmg1gxRM+fPPrnyfN78//PVduCz8O4Qbci5mEbSm00KO++emFFXNqumLW +pvlTQva/nH68cFXdC5mG1S2EdJLHhtfvF+ukeFc5oFPT9RjkaDt2Q6Z6IIvVOnlwhuCHyq5qIt9+ +6jL/zJfNjyszZrq8+HISQHIXSNMofmhmz83Mpvb06G23Idy74GmzvTBnfivWTkqgvnmlNGda5fb+ +F0t7Uw9XV0mnB6Qrab9HOIBPuNDEBSI4EN2jGr+YIn0pMCQiPapIRH1okiFmtRGQ+xQRAaFEg9JE +xpyoHsUASjBnGNWTyJC5ksoRQUDGkwxAuY+1IIsdDkOyHvNGquaGJVSp7thAipQwW4M4IoGhXA2x +cYhCESWpEOkIGKDRVqiO45jNyiVzffk983Pl9JqHIRr8K7ySy1MnbiPtfQvCsBIdHlTWUK3WM7nN +Z8vEvF2d2f9++dOpczFnwoK4MQs145WiG/OmLd+2MMeumufKr5rdmtxCTjgbHih1OAOXY+5pRHF6 +sfbFkDvaZ2JyAgK/iYDBWxfrxKNh6FJv13z75pr56sRp81f9NRMVXpoKfPPD4uypA382EKa1UJpo +/Rk7j6k+n7x+djF92hRiV7UE15RxlZqcEf67bz4u1apKxNIDS0NpyXi3EQqhwLZViuE1nka+L6Uw +j+eXllwhwlS0WEFSwkScNJ/Xrl662W6JqM9CalVoUa83tiCW5M22kyRug6Y+1fSykB1UGAkkKhl+ +tvRiogu2AXNWU7lzXdpL2w//K8ONmI8nOQY+3oJsAJ6iQubVEoVHq/VTPkrMd+yWShjQELged1g0 +jaQ85wBzzIUzeNS0l/5I0LHkKnNls1WYT6beQThYh0BIwDbiMiis2OwUCjSnjS8EyyS28/+u6sB9 +/cEkdy85ixG5a4z+hC8rwXy3OJ9xPhZywPtw+jrjmq/HQYCr/cSmpz5bljpsyJgC6YY1Agn4dhzr ++5FZd54tWyfb3/+dzCyXLty+xboboXBpeC2NyhKgudkMsh3fogPWpVrIDdCbVPpDmvTJi6UE7o2e +mBRHG3O9kRe0+Q5HwsltktxdB2+SPAfeKVfy280CHr3qTOF8ef+PWv/Evy2zZtT1Dh2DFINHZZa1 +mYGP9kReB3QN6wpYeJzbsJ/x0yHGDWeFJrMKKk5+I8w5OUpAkFmhVmeygJwkS2JepeZkRRGzyfsF +BCc/4BebzC/AWq+vr+CokJ+XnKpQXpRYUJBapJCcWFBSWpRarJBZUqyQmptZUpJaZA0UTc7IzEsH +Ciok5hTnKyQWF2em5xUr6OVkFpek5gH1lWQU5ZemZygk5inkF6Vk5iUWVSoUFOUDjSwBMkpL9LiS +8/OKSxRAGoqDEst9QBon/xPQwO3QJEkhoENNNmsIL/BiBmrZfCL2BSMA1aJQrvoiKRY39KBp2udH +sXO4Oseth0XXUxt4nG1RTUtbQRSlLqpICy1FDQgyjaUaDK8QMYXYRUFtCyoKPj9ARN97c00myZs7 +zsxLfD9D717oUuiikL8gLtT+lYJbQXCGrCLOYjhn7jn3XuZcXg093gz9/Vei/2HhjY66a8JYkKAN +fa9UP610QNqVVFgLekMmUCyzYqIhsuDZro6UArqolGlx5gPNVcvnP18vlFkcZFKgnI0DY7WQdf9i +8jTGdslDGVnRgXVIUeeex4ht+jY/2bstnb0d11D3K+hfiC1TrLH9UeYO3VcrR4Ml16sokUMtRZ61 +IXhedb4Dfw2I/EIqzBVsJQ5YjwaH1F5UPJ/1oojuqoXewdfLypjBpAX2y7aq64gDX85UG05pqjkx +bBqZ5dilV/sF2mm+/9xXHsbI8yAWkgfW1LK+re8KMVzbos2TafrTnOi9awYj4RKq3P0qA9lhkeRM +Rdp4LmQDtLDAWRd1CzRDZV0MhsVoG8ylxpltgJe7UGeM9wuNMnUsoI9707TeGaX541W62JvqPei7 +YORHJhPfgq5/J09kDsuFvaYEeJytWl9v2zgSf++nEAIEaA+pA2xfFl7sAYmTNC7iJI2cDa6HwqAl +2mJLkypJ2dEu7rvfDKk/lEQ77XZfGvM3w+GQnBnOjMo2uVQm+ldEdLSMVkpuoqNlId4uC8YNE/qt +IUtOj3579er0NJqRJGOCRolMacR0JIhh22pIRBoJGRn6bCKTEQODpUzLKAPBmlIxepVIoU20cTIm +MOdGkpQqHf0e/fdVFB2dF2J0dTU9OsEB6DBerdhoclWIxDApuvCHeEI4X5LkaxdPku445TKnvbmc +ia9xuVlKrh3BbWN8zkS6po5nCb9HRo9reQdYUNwNWyqiyhd5N+Qr7Sr+AnN39weYcZsdLXIlE6p1 +ewKf4Q6rK5Bpwfunfzyz6AP9VjBFj52QHjiCy6VCgz46RL9X0khT5iHGe8W2xND3XC4J18ejRFEY +ToWhShDuxJyX03QPO9Ub1DcuRbKHQzkdJnKzkeJD7LjQpJzs94rkWQuieaftMOfFmtWHDJY5dkc0 +WvT30SFy0GgIq0LMSC2svoU1NefOo5w6nftAn7ncEl4QI9sLqS77lu4meV7bwfgWVvpjBrvMGSeI +TMCf6CjJ8/EX/VAIR49loRJ6JdWcalhzXZ2ZI6L5AHY8alQJ0OJEsdyEaYldPWyboGulo9UJDnc8 +dnfdEdLZf0ZJfimKDVXNAVhn/aITPDg0K5oYmt4tv8BffdTOLASGFowll8IoRu3c0WjUsfCTCJDu +GVuot+xnF+POop1UX6mygYtY3SK5ipjRkdwJG+a0IQqGO2YyGEcUli6jXDJhkNNkNLLmNbY/uVWi +FgEnwTfw76rQoCzdUlUaCIfriHJN6xAZ2FPwhINW4B92nyE2xOi+Vfy82HvJWVKi0I7EH7Fc32xn +1JCUGLJH0aBYN/O8WK2oCoh0BLv9f0jWS7sFw7+vfN+JqClxVpgULCk2KZMvKeM81P3bk+PAaym/ +6okUBiKOdhDESEOeD0n+xNYubDqHsoIBG49XFcct2bI1OsV7aq6JSncEA6tICqWoSMpDsjESnqLq +cwaO5TZfi42pmW42NGVgSVYGeuogHQiHHGt+uFHw43BUYvoFsjueW7KhOicJdZtv34C5IkJjXFMO +e7JhoE0dMBpZz3+gGwhIF3RZrNc1Q8+JBvfm9I8N/NlM4c27FJhWpVecDL3QLdzzOgdOMD6oIoGr ++ZFp8wyAVLex95DZ1hvr2dsi4VJbmVM4JjpQ4fsFYT7yT8jJpTYdOXj/SvK/KW5HmIGQ05co6PCR ++15fn2oIOSIFD7orTF4Yd/9/S9QDxTz9USSkWGfm8jmh+UtqeYnPQK8rBW5wt4qNzHOaDlKkHxXo +USrJ9s9PC/sOOS+EyamuU1Qt+ZZegX8LkBhzubsnJqv88OVHoR/FqUE2F3D0NdnS95NDQjznbIXc +gwHP4KrJurvDOr8XJGcLLKKaLN84RyarJvm6gQkTWQjTzTeXoTQLlqtSKJtiga0dnURHSJSYBkZH +a/sqzDOmcZRTtZJqQ0RiiZVoL/tKONGQxjxBHuQFpqagOFMQ2rdNKXGmFCmrhxhKpho+Z2uoAuzT +3ECghvc7gfJKmwbA1Ko6tRqbqDI3sh5d3lxcwwS5BtNpsGd06O5oDpXK3arGrqhJshjkwqE2GFiL +r6sdl9rQzYMsIIo3OBoppo37GK5/sSz3RGkPnM9uHuhOMZ+xr/h04+2zeT1r4NYazDkkyJx1sU+c +LXuINmmDUIPq+nv7WLDkUqQ2ja2xB5pIlaKHDPR6AEX0hDPqc38rqPaG1uN6VwVoDrbSjON3XSHx +OzSFZkQh56if/RZUkDc/0WUMpkFb2I7O0lTBii1oM0qSN4BvaHOqNgzKz3b8bC4otjOaC8E0Bq7y +uONJeV3oWtsHctD8DWTvS7ACfO8xmToeNfM8Q69L4AdwbDxp90Y4vQMz0PrPlGErAuYcIIv6Foa0 +0lD9Y6thMY13MyQoqLHBSQeEi9u4uvfAdu3Lez2f38fuCg9x7GOQaKRBfG4bD0OCaDouQ+olp+EN +wiJzsg7gNnKcifIAyRZ0e+kYBauE/QDbBJOtudxLLsAdN2e6hPsBK0tmBIJX6Lwce0Wu/egw16Nh +2E8J87j342X90c1Ysp+qYO73SEE+q1eQ6+pqGgDjp32ngeH5xzwAYzQ4Vcr30Or4bYsHfC1DbAcM +/pCt46tHRYjibiq1b0yAWsYfb9rMdQ/Dx4KqgBVjtoNKNXE6yPEhvoqHFPu8pXFGOXftowAL5CBr +CNAvaOix7dETn6v6tQ4T7b0Oac29w9tXFQw8dMYYxtAmHu3rNSDH79CYAngC5U2dnAXcyJ6OtcFc +URNaGF1nrwXHxbLKw4a0+eS+ehGHpJt4LwkiwiQrRCA6Pl4EBfYbyU1F3XSqyBJqlbdJc7ptEa2/ +cVYV/3ZsmjZKPTrdsha0fdVFZky+gFsQQzSxycMQtl3gAcwEENoKuCWAI61liKCtb/qwtna1SIuc +0+cAIYecGNJ0CWVagKoq6wuQTB1CArQdFENBmJm+NMN1YPuI9oRg7q7MADjV+KB08VIkiww7TR66 +tJm8B0CM5umirhI8nMNj1eWsK44OApWy6cyzSb0HpJh/+mNG1gICBUtgxxmBaMJ9aqdlD6NTUG3D +oF7xYbkhnb4/3dKuFqvuICQEDaU3/KU39tkF9Q9X+qQcKtLe8DSXmj33wR0T7/w1sFQb3FBeiBJz +WQ/6hsFU21fVQ9EoORM0AIX26/uwA/y2Rguc4q1ie10PSSGxjrKjyy4Iui5Sl5R7BMN6gh0QEmx4 +Z6QgUi0G92xM6Y0K5ZtSARlRb3hqs38P3BHNvOGfUH65ISQPLKlIhVm9/fXtlnCW1i3Qo53uhFTX +AsC3pYmmmL7GcOLYPXBz6hym7ZAPaXXbYw1ZhCo9OrgeLF71fJoevCN+iCeVwGvK86p/W5Mu8czm +RK2p2QNjauCTmj7avZIr7Kz6xNl0dgkZA9l0FoEXHx9Am5b7eFPuteCtvMtDJ4BanGHMss3xLm6r +/C6E2U4XgdeyCzw+3PQAMAGsN3Tbc2qJf/zajqtmXtV5nc//8wRBuCXHtmiEEjeFhF94cnBTl2LL +oM7qnsSjNSdvDJpUx9yCn9jaJbSw/Jal/rkvXW9pgW9s3VZyFOdjjw9T/EQDyggTT2cX7cyMrbMd +KRfOJbWV0Dl3NPyFi9qLqv/UEp1361NIpl1mNqmDQ4cH5jyx1HhX9PycEZ296y2HDkOf7X9dSOmK +FNxEyxHsgINB2czrNcwdfB0crcD0ZyR/jUE0+v3fMMd+4E0tcBL9FSmY89hMG0dwPzT635s3qMpP +C1sRrhtpDbf9+GDzjKPQpOVol1FxB85IRHpNNFwp/Dbl6yNpO8C2VUfgUN6AZCe4nnwnePn6L4Ci +KJMcv62M7ddRrxFoP4SG+3iWdKjTYRn6KeDnE7ueF8YQQM3e/Pbq/4L6gM/wAp5/UFWeAGoKFUkY +LbKON2snKUefeJx7z/SeaYMeo8jHayeY1zeeKrjZ+tDHO7rY0MXyyfrJToy6AP+iDrr6D0LnAO4c +u0YNMkBxxqNTCT7TCEV3eJy7fpzr6imuDZkvRDyD44NcffwdXTz93OMDgvydXYODJ088qjjdYS8j +z+QHF3kmN8zm2lz8YoWfdHFJYklmsgJWHexJBj7+eQo+mXmlFToKCakVqcllqQkKuaXFJQp5+SUK +5YmZJQpp+UUKiQo5+cnZCiUZiSVAIlUhuSixOCM1BcguSk1MUchNrFTIyM9Jmf5/HqP89IYZTDLW +mcVBqTn5iSmZeekBRfnJqcXFGpoKunYKSfn5OQrVXApQgM1ZUxOZJKYHTGZkbRcxZ9wuYs50OAcA +gw5XXfECamVBsd78bl2o+E3wMSzPjnWAX/F4nPvO8p1lgwGjyInmHW7FRzdyqu04tbblwT3hYE7F +5ZtdGI0ZAQL6DiF+OQ2cd3ESyfKe/M4NGUCUfaMqEoZ4nLu4huXUGpYNbFKbeaVc/gAAL70F5vEC +U6ubZdKu7OpcR9Ql8xqU3msnL1x4nFstsFpggxSjyHUdybdh/TfZJv9Ltmze4z0/0uPUy816jH/Z +AOw0DrL/AdhNPnp0Vlx6DOTkE42M+qaeXknCeJwBHwDg/6EKoQqQHxRpbOP4K5floBOD7bpgyFLh +gq31ibEz7gTvBxAs+wJoB0C0BjqmurYvIIo2Dg9+e0FVq3icm7Sede161g3X+CUS80t0E3Ny8st1 +k/NTUnXTivJzdVMyi7ObL/Nvv8zPuN8dAIIFEWv1AwsePXnVJ9mcC5xGK18MC1UIUxZgeJwBNQDK +/7QFtAWwJgIU4pQA7exNljQlHN6MpvcIJ/LOrmuTOgJmFJsT4RDAZT/XgCKYbiwczqD0xX8zc5oY +AfQpjico3+EO06T2r2Qo5f62qrlBBPF4nF2RT2vUQBjGD9tCEbEF2YMi8hRkN6tp8M9tl5TKXsoK +grT3ZLp5sxmYzMTMxHZty+I3WBnwM3hU/Cx69+bNix/AyWyrdOcQMvO+v+d555mvvzqff3e+bPxY +jFUjjUbOa8qgJO3pQhlUSggNdsq44XKGmlhdRjguaN6vCdpwIcAlTEGYHEEoVfU1UtmUiSdTnDQG +Uyb7xitHt+BW1Zwgl8i4dmqUJVNnvW2CniaRD7C3D/7iuf0Z3l20BYMYT0eea5cgg9JpNtqNGaNF +ooK/o9WnPY24oTrRZILBf+y04II8fKRKCrjM6GzgeA9IOnPNOP/XfWVkL95sPVhzqEydMHMlYJcX +9xZaKJcbc3EoKeaYCsbdpVwktWpmBdIZmYRLbtIQWoGtJm8hcI22wJng7ykbOcSdeBGXc+ZyHKtq +nrrgSGQ6Wp8OQS7YTIsQTAg1ZUbViZlX5K8lNcsJ5wiCx+1DDCLfG+J6u45cjm7Ir4J/ErcvMRzm +tSoDX7fL1/e7iGO8vOaPHT4cTrT9mHU7vR7ss0lkd8ab9lO24/cfDnbb2ob733XFR3b56vad8Iab +fXvY3fSW3/58jx/+BShr1RygIXicMzQwMDMxUXB0d/ULCdbLTWF48llRVXrqwmPcqQZ7W11mhBS7 +f3tuCFEU5Oro4usKUpTQPednGE9XTEgHx0n79F0pvaXtgSYGQKCQmJGamKKbn6ZbkpmbyuBpuqhM +7NztHXEL3yuu61gWITo//T7UsKTSzJySzLxivRS9kmKGWue6m32zomuy56roaxl3Zsg7HcqGGAhT +x9C/xUpgXc5FuZQQ0znb87esZZ+iEwVTksdwdDbrqo+Hfv6VYZ7HfWi/pfK7K6sSILKpZYk5DC8n +8Ni1XPabu8n//wqtObdsrl/68wnqkMy8ktSivMQc3bT8It2S1GKgZekgJ71TPfZsouW6A+wCli1e +PaG1DK4n8iAmwnQw+Em7PxWev8volKzV/7yzfU/iVl4PhijJy09JZTDblCnHyLtL/uVK9mjJs5UB +52MMvKGWFhRlliWWpEI8XyT6Nkd3n8aWyyldYdmMs2Xfrsp9BTGmJCOzKKUgsaikkmGDiYztlduH +HHaxeDSoeih+6Utgng81rKQ4OT8vLTNdL6s4P49B/p1YQPO6BetUkua3P9Vmuv1qw/FfUIXlicWZ +ukWleXmpRUC1DHE1W3puu/fpSP3RvmT+cW/ltCk7DQBTENA0ogR4nDMxAAKFzLyS1KK8xByGxYmt +/+6o7P7kPzkgh/2ZxEHu8g4TE7CSvPyUVAYZXi9RK+EHGRUFi55su8n1dYrwjK0AOt8aD6AKeJwz +NDAwMzFRyCgpKdArKWbYvtDDceI39u/LnZkecb7f+Pde2RM/EwMgAKtgELFuL3R1ctnzRfZr9oGr +l1/ddFE3NkSYYBhfnFpUlloUn5aYk5OUmJwNMnJhzEIuzzUWC4IVNyUfYJ/7rMLnvAxUT0FRZm5+ +UUpmYk6xXlYxQ5HATH2JGdfbukP3b7pwozjy87IEXgAxMUFU9xHZO53rzU9bD8/mfXs/0Uz7coVh +03icm/+F8c1Xxg057D7Zjkn5RSXO+XklRfk5OalFCrYKwZW5Sfk5emn5RRpK6NJKmtZcyfl5xSUK +2Z55JalFeYk5wfnJ2aklLokliZMr2O3qFRyLs1NTFIC6FUrKM5NTdRQSixUy8xRKMlIV8oEEUDi1 +osRKIRFIA43JTaxUyEgsS1UoSi3ISUwG6kRYrwe1qji1qCy1CCJupVBSWZCan4bNfpDbJ9ewS8mB +rMStbPMX9uo8fjSPbc4q28oMAMxqZ/vqBYBXeJx785Xx+FfGDYVSLApqCtWTD4pJMdZuLpRKY2Yv +zcvOyy/Pm/xedjsSW3nzQzlTTV7XoqL8IufEnJykxOTszSYe03nham5GKGxmDnupAgBgrSPK5QdY +eJw7/pVx+1fGDY7i7KV52Xn55Xmb3cR72NSLU3PSrBRU/PJTUvVcy1LzSlxzM0tKUot0FFKLiqwU +oGp1JslJTJaSKyNB+eYbcu+jAfnHKwT6CRxGO+1i4/fzbNCtGA13qeYDlUaLeJx7/Jdx83/GDcFc +MkmZeSlBqYWlqcUlwfnJ2aklGlwKCkUQgcn/7MQnr7CTE9W0UkgsLk4tKimGSSlkFk/+byfGoqCm +UD15tZ2knEKtQjVCp14x2CwFWwUIY7Mrl7qLPKZdQOWKOlA1mpsb/JINAIQOOEvjAoAKeJzb/J9x +AxA1s7KX5mXn5Zfnbe5gdVeAc26r3ogEABetD1X/CGmOgD69BtpFTNOFFpXExWwqk0ypeJwBjwBw +/8wCzAKQQRS+Ywe9rTwcy0ORfXF9WH/96R6tUpFVRBSE1JVg4K3CPUxfnRNEdTUFK/sCQJGtGT+Y +N3nMStX1/Qc3FoQRyz3Ds6UG8TEwMDY0NCBfaHR0cF9zZXJ2ZXIudHMAxrOUugFxaMuU33XZYSvQ +yFLKtUWTBQEzFOEYFv/6xvYm6vONxsLqstB+OK0FyVdCS/sb5nHUIhmeSw8B4GTS/MyOHbgfaIN4 +nDt/n2nKQ6YJixwMzBKTDFKTTUzSTE0sUixMktMM0kxNU01NUswTzRMTTZONUo3NDA2N0yxTDIyM +01INTJJNDM2SDdISDUzNTIySNj7ayFjvn5SVmlzinJ9XXFJUmlySX2SloFGWmFOaaqVQmpedl1+e +p6lga6eQD1amYKsAUW/NlQzSoRCUmpYD5LqnlgC1lSQWpYMYELU6CtmplVYKAUX5BalFJZXeqZU6 +CkWpyamZZalF9nDDpcGmQzlA46EG6gENst7cw2TIIQh3RTWXgkJmmoLG5H9cMptfcBlNZYdKTTZa +8E4f4RINDC9ppBYVaeooKCXnp6Qq6SiAeJs1FvYywgzYfHZRBlMclKMDtAbZhTpcCKtTixQUbRXy +SnNyFNTUFAhYiWKj5uaypZFcAJapmEXiBYFLeJyb8pCp4SHTBtHFk11jJCbfnqIw+f0ckckKmiyc +Vgqledl5+eV5m8sXKzBN1p8ClpbRUUgtKoLLgXj2CJXfls7jAgBW8SCS9Rbt2ZWSQ1RCQUKKrLMX +wXWwKvXLS3icu7iIuXkJ84QlDpbGSSmJKUbG5hbGaanmloaJKalJJuYmxoaW5uZJiaZGhqYmqcZJ +BiZpxmYGKcnGpuamiYmmaWZpxqmmxqamZkYbn1xkrPdPykpNLnHOzysuKSpNLskvslLQKEvMKU21 +UijNy87LL8/TVLC1U8gHK1OwVYCot+ZKBulQCEpNywFy3VNLgNpKEovSQQyIWh2F7NRKK4WAovyC +1KKSSu/USh2FotTk1Myy1CJ7uOHSYNOhHKDxUAP1gAZZb17H1BXIDpXb7BLixA7jTJ4UrewNZetw +aSpUcykoZKYpaKQqKNoq5JXm5CioqSG5TQPDkxqpmjoKSsn5KalKOgqpmpuvROuWwG2SvGDBCACT +03k66AGBL3ica17C/Gsx84ZNIZM3mckypRZNPnhBczFzaC0AjAwKt/0FubNjJy8MMK4iWWs016OP +auPno1F4nDtyneX8dZYJSxwsTEySLJLNDZOSjMxNEs3MDIwMk01TDJPSzE3MLQwtLZIs0wwMTU2T +UpMMDCxMDS1TTBMNzQwtjE2NLCwsTMyMGp9sfcLIrMXunF+UnZqiM/2xFuNDAFyBHQbmAXx4nDt/ +neXUdZYNe7zYS/Oy8/LL8zaf8GJ/CACAmQrK/ooB50R3v/qVlKQieS/d0PEb8MiI1vJ4nH1Ue2hT +VxjnnFzbJNWYtrbpg9aTWG1iY2xi27Q3xlg6dAPXVB34KJreJidtvLf3ZvdhbdNQhYEwB1Mv7sBw +D+xgfw6XzTCYoDD2gI3pwME2ZDjGYMKc/7h/t3NvkjatusDNuff7fa/fd77vW7rpvHLHefHa3skU +HtrVz4UGh8IY9/Ul04PJoXD/rvBAKIR7ByfTQ6HBdDAUCg8MBNMDof4B3D/UF+QGe0Ph3vBgcFff +9d8AaM2hw6qMuRm2fMbTBzKTMifP6fV1LodiypSdAp7iknP6TyCwuHMnGkYiN4MRhVIoLUszaCIr +cBmx5GACZRQkSBKPU0jLlvASEsjKkiqpc1mMJDGARiWUlEQaQUuqkoxkTVRYpE5TkP7JSMVnVDTD +8VhBooRKiaBpvCjjgD2tiUk1I4lobCWu14dyeXuXKo0InKJ4qxA/8lR9efxrmfoi9kwaeUtS5I5G +n1JA8clTOKkGFKzqvL/uQLX3FVYVx2MVAXVsMkRV5WERJ86hKBLxbCn7wg74haWwuybeUUWLuP+E +jc61lEwpY9Ax39oolbimTkkZceplrCjc1HJEEnwImzasimWaFG5tsTTUsui0lElF9GP93frNPgd5 +Y86yvoEGi+4xAd8KHoZogVw/Y3EDb+Gz/ofb9fsXWwr6hGeT/pfmILEgtBZ82qP5BoSMCrozSkLL +TslcCvvIv/OwSR993FN4+/FH63T2cayw/x+xTee/aSl+6gTvvmR7AatcRlBQjvyaAO7LvzOEsTFb +CBwHmDGqR95ftLRAFDVPT0V7mx0hL30QWkA5xGfEFIs8Mjfrieh3j7RszK+GyPnjwEuB7bXIQHwR +EjwOWouL4+AN2G524mEpyWP1oIY1nDqElSytHqYxOQ9otmxDOf3csWZ97J06GLGTR0ugndw5arEy +EXs+QmwnwYiHpVNQNqJt/yxn5OIMcJGrp4CTKCfBH/rYtXVk7yW4nnynACsREuCs91lmfppuIBAY +N2j4UUbMaurIFTfT4j7BlimOm7T9qGtUSuHAi6qaHZnWRN5PNtiYdoi8pN5hcenxo7WNvtiJio15 +0p9RmG6bf/nzvpXp1v++UEMcNqbDeAEr9j5frKJ4wk5bkr4LWEVJIxrtrlJuxkeEvF7HtBHpiaWl ++PME6GZqT3OCRsup39rjCxv2pXFI4aTAyXQ/RFFZgc6cJqZwOiNSaQyNcqOIRT0mWAxiwNfYpCyW +OWM4yHuLltYOFDUzMqpjWpu1KCcZI7d50GJly5mRezzYbS1jrIGNkcs86GlcdulHSU4QJrkkT7YI +4O766vu4MQOuO8hb+2Bn8eMc4JG+qWYzDCSL7qvg2zRIkPj3sLnZjxJYTEopOoissaroSUVk4hbo +aKtMk5lAYlbOqNibMGtnMGnbWm1qdKSURvwRQyu+kl7JlbXiqvgAwr4aK11VSNQEodhkg5/XNrG0 +hLwozYpUTTEZ0JbUL424ij844Smob/6ytTjWCOc7Os3G31emXGm4Q/hVDdPLiZLhD4Cr3PsdkPaG +MwJbYYwlY6ctbe1G69tNB882dKweUNPYFWOrrje/GgQlxyBCzvVaNpE7C7BmnTmr5KteOLxxTZRi +RxAea3pKemEfJLWgS799pYkknkBrMTYKz/Ywk7Q9iHM/bO4yMpJLyuzzqBPfPPQG6dJUFCyrSkXf +GOznFWvbGhYQ5cnBedhbl7cvb3PS28m4yL05+Apj6K/QBHkj4o69paHQxBlO5o0F8P9Z0qEpJ2a0 +1DLDem9Z6kfTnJgS6AZenIcjG9e4NZMlH/4InHr8oONGDm6A5LVfYAN5cwbUFDvz8Out9NrbSXDQ +4t6aUYbFZAaLNJlJSRIwJ/rtvur6KLQ25qpkzELUf0IXxoMFF8ifDyzBYmDJouX+A65M1C/nBIor +eJybekGg44JAQwvjFiaRDZyledl5+eV5CrbTN+xlUthuvYFpCSs7VLD9yVam7U+2MvsawESmC7Yw +i2yPfca8wxEABu8cn/0Ga3CB/pP1UaPu0aTy2pTovE9nf914nNu3kXHvRsYJsx1STBKNkozMzMxT +k5KTDC2MDVPNTNMsLBNTLFNMkg3NzQ2NE03M00xSjFNMjRLNDQ1TDQxMDIxSLA3NTFMTUwyNN95u +YWTLLA4N8tHZHMd0m5UPzNZILEovjjaI1dzsz5EfAABkIyIe/hUNfdiAEbjIlxTrY7RJXhd0fR/D +b3icO/GTcdE/xg1WmmKZxW6ZeZklqRpliTmlqVYKeaW5SalFk2eby2220nwhIqijUJBYlJpXYqVQ +mpedl1+et1nJbpba5PmF6pPtUrg270nhkZjslCwxmT+efbJuBHt6QJB/gGtQSGR8mKNPqKsGl4JC +akVBanJJakp8SWUB0ILikqLMvHQdoERGfn52fF5iLopgQVF+QWpRSSWyWGJySWliTjzUhYl5lTpc +kxkjVDRD/bz9/MP94n39XUJ9XOPd/IN8HUM00vKLchNL4PoVSotyJv+NFwe5Utw3wD8oJN4xJCTI +0yk0xDXe1zM42NPPfbJMiYmiJ7pkSGSAa7ynn7O/b4BjiKeTz+TEeJHJ+iWKMhgqQ/2CQwNAYq4u +QKPkAAV7dfHxCr201Wq/+Aw4lvrdqlNOUWNbckzSeJybw/aGbYKNyNOnq5benTy7ILZq3bt7nhe7 +px5XPT0xwF7kwc1jbI8mbFvyNKnn/4/Q7V/cL+5duXHxa0aRiOgX2/f0BBXdqgg2Ov3rX4rV81PN +kxcxVQUYGhiYmZgoFJekZObrlRQzLPm36ZL/U++d8Rc3fbE6fX15IctHAaia0uJUt8Ts1JDM3NSi +YpBaga9iNs+sjyiElQupzpDImzWlLcwaAAJ4Tkr+AbLFlpbdBUXgr3XdUEK7x4+Z0noYeJzb5vzI +eUMVG3NyecrmHLb1PBwZiXl5qTlBqZs5hNfxAQC6hgsv+iMXZx4DJg5NPyTLOXRwa8Bea+lemnic +hZC/SsNQFMbRwYI4OFQQF49QSgIxaUctQbTqUlx0cgzJLTkYb+I9N5Zgin9e4W4OIriL0Bdw8AF8 +Ap/FpPkjotb5+77f952jxPPly5txbVmwC5KRBBFzkL4jAQnc8DzCgHmAHKLAcRmQH44IUBIMM4EM +cChXMt0LGZmLkGV4RgmQJPXL+GFuBRtagl3EKFjfcX1WiQdcisTUdLBtG6SIWa+GIB0XAa8y78UY +SOTq3Vgd/FLRbs/o0M5YYkA44kwY06KvSvVqbJ1mtQBaGT9yIrPlO5SHdEjTqZjJSOWEAUsKbefv +mYVhW+mbHydFHoeg/dytw1XJry6vHz/raeqx09QKZuXXQTAZC14DeiV4PFkwcX75G2wfPXXfWVMP +1pJaX2k83XXm1G23uZGm/5w0Ud2bxienCcXC/3AfX6qwuCDpY00x8HpzrUR6BjNKHHicbVU9jBtF +FFbuhEEmCkV+RMU9O5ewe3jt2ElIbs0mgBWdkOA4dCedIIku491xPHg94+zM2rnkLIuOioKRAIkK +FAkJChAWHXRU6dJQUiCloIMCaHmzu97zXeJiZ+bNe99873tvxo+/W/j6p4UfPiu8vtMlPAjpVRfu +Qydwgcf9No2aIKl6MxR+j/HbVjubuNAWIqSE2zM/GOtPC9+zrS7FYCekUkKHSOUMiOqCL7hUUewr +EQHDKQlDiQi406eqKwL0NTtKAgkjSoJdRwwoB8l4rwortSLjikYd4lPYVAETm2jXUDgxSVbbEVN0 +U2FcH+4XAXZGxjC0/G7Me9KF5XUR0GrLrLZS5+s3K+Ajhzbxe7P9a1EkolZmxKyGggVNg9ZhnITW +U91fOOQ/vfzsncWlJFnoyJSSu085Jaq/LZZfQmDzI7ESrVBI6qJYoaSV1K5/Ly4tpfOx3UxGmebn +5bg/Pv/B4iIu9PVjZ5Lxo3ScfnPs88KkVgND82UJDDWFra33KzhssAEFFBoNrY0qtES/jyV3QsYp +KKynTFQ5UHCsGrWhTbE+FDhRbEixmgGFRGSJYaCw5AGVfsQGWN8q0mX6rzOr+tHJ089wdN3R/530 +LOyKyjyyC09pJvCu6E9Olaa/nHrw6nG1i2zXqNrskogG1/gQPN1aL+mddx4fnTdPg/VLy4UKdFhI +9d/RCf1lVLuZCKDg1iASPvbiLTehOQiJwkz6mFAoRkYbYxUm/S5R+DEWelfBiGB/xixUpjFNShnO +u+0Pqa/0o2gy/UKWjizUavrhcMkiA2zXIFfDMIFRl0YG13wRFg+pFrUTb+uP4/dM3B/xv/rP4duT +CmAaLELYDbwqSbnHRfxgBubuVNtEUk761LJBdLB02AmoWQVGDG9OrMBI7CaeGNSJua+Y4JBHmR03 +C7KT+4H16YBl1EW8wcTcz5LnQTn1KdvIR8URx+FOjLyscn5C2a4ewM16M214JrcZD8RIYpNmalVz +vT1zwIjx841yGhNShaRIpCbofq6Z09pHOXs2zT+k/DZSvOJBI7f5WPsWsnpDWXU7Ab94GWor4OJj +MUtyxgtPwsfDkDoUec6GPTg/aTQzd3N85oyHrV4ygAQBzamZ/TUP6o2G2biXnJRkgNAZxjhPDbsB +zU49tZvHzUADm9HIknKgPmmiFc9LoJrgOOxwAsl1e5I+s+eJp04oxIWEd83w3ts7pGfutNqwjdeN +G7CyNidYCmW4m4Zw6vM7kCfL4BWoN+c22vge9fRXbx2fAMVHLAfxngBJZTkAMJ5TLmu8/Vi4CuUy +VjXJXYbMp1bComJ89q/K7O9hujZaPlJI7+i0d3d1NtcPdhuz6W/5dPrcvZ8X9D97ldm6NP71xf8B ++i9AHfwmATJ/XSfBeb4KWC3/lRod+yqASs54nHVRwWpTQRRF2mqJq7qoC0EuBakPkzQbFxq6SEJD +C9GmfVkKyZi5MYPzZp537rMtCP0EF7MT9BssjyzdulLxS/wGZ17UWsTVzJw595x777n4vPL1y8rH +xtr5aK4c8JxQyG0HXUvKvEjTASCRJXhVYIFN6BjoDA8CTTAQckHGwYniOaBhUujAGlAMmXiJUQzB +4ClDYQi1YJQwE0oXhJVAbWcHotuSeF45BCC3xBHJmjDJC56AkIHSfTo+HncPRul4dHg4Tp90BoM2 +TDj4TACznKN3MBZG/ulLsfvdVh2slugYZoocN2t4WrlMrQlYMAnT3lyOuxen9d9WHw2X8F9o39Io +aARkqw6tpH1VJbZylX8UB7os8s/ebvs3qxu3/8P0Pz5t+tfX75R7a+sPakOybHtCa/RHu/cgalxC +tJXUa1CB8S2ea/+9laz/umPZa7U3y4v+u2vl2f7D7HjfnoREzBmwyqpYQtA52Sm6cApyIZeYgLMF +TRHsLGwRlGEkIzRkVhYa4b6xEh/PwkZ52kz8jcXdWz2b5Uqj7JPN0qrWw/uGl4tk45+v8sPCN34C +CjTjBPAV9uW3uMXk43UM/pNZIEbZVHU9Rv14nLvH18e/oYpRxJl9WVNr6evqQCfGy1tP9rfu2L3U +f3IfY62IxMHwxMtzGUPV6zq7D/4KND7AXxy9WZ6pllHE3FJAbvmsRT+fiXFxzsq8c6xur9KbzRuY +zRlFpKdVXZ+TU1E4Y/qNmUGzShOu2V2Tm/ybpc1YNz+Pp/vfnqDf3ux3DBdNqJKO6Rc3MQAChZLU +4hKG+f8ZOu2cvH12q6gy77pbYrxiYXPr5C2sv+u7TGLb3kztW2EbtHTNkyMM3X0i7xsg+kpLMnMY +CqtfTBZbmH9XISbJXf7UDPtfW7YvMzQwMDMxUShLzMlMSSxJjU8rzUsuyczP0yspZsgzWbq2KSPP +NmVOyKYX3VL+yUxlpajq84uKQQqfpsxj4rXR5/0322VFXU2mwbPF9/R+TOZmlxOxcjOfEMjTZ/wj +77fRusS0T5+uNe6bbMuuCAAiYo7JtUZ4nJVTTW/bMAy9+1dwRhHYgOHck6VDMQxD0UOLbrdhQFSH +drU6kkvJzYw2/32UbMfy0ktPoki+p8cPFVoZC6/wQ5R4RSS6a4skrCY4wgYIn1tJmMRSsVuJetmQ +3GvaSVGbOF1HUeHxPdL4g2H+zGV/X4c5d6Sttl2Dd615PGU2ozdv2D0Cbh/+YGG/OpvagiWtIHkR +dYsraNWT0geVwuYStE9jrj5/RN9jWfP1O1qGWUGVM/rcDJ6wWwFraZBsd4NdxpUWKF+QvszJB5vZ +B76cebjsslWFlVqBqCrCSlj8edDfiDSZRCqF5O0TVwa6tf8705MFrxGALCGAwmIRYNwtiH3abIJg +6uEAfd2T30yquQvJWTuTgCKDGD0mDqXygB2xUxZOOACadHwdYLmE6xK2U3AL0oCoCcWuA6FgezU2 +qw/nA/B8M/KLQtR1+E4W1D/IAh6abUkFgvvAMWgHV7WC2720n+ePc8GF3mF8CQvefmdOk/err/AA +c0gyvOoiZ98l+TWpCLX+TrMB9oFR7NEYUeF8Fj3PUDuXlTvRHxuxr/idAQ99ZFJ3d+0bPMHOvb3N ++nyMIvzbaLKww1K0tfVrcP4bsui4jv4BO7mDdPsFXehyHccrEfiue4ftdtn3NDnEY9t4nAFbAKT/ +1gLWApCnFDhvKTyVWAbNwyRjJqspz+kwq4Clkbs7ODnzFdP/Nzmt29JVf0ISi6mR0L3YMTAwNjQ0 +IHdhdGNoLnRzAJ7Wnn6ZF6b7ylaXUyKdxGJrZM/7ky4BKF9rKYDwC9LM/STUVpMF/L7X4XJHDzYD +XMsjeJxb8ZPt9Q+2De68xkWpJaVFeQpFqYWlmUWpGkqZeSWpRXmJOfqlRTlKmnol+QGJJRmeaW6Z +OamhQT4aQFHNzcJ8gbUGVgrRvpl5mbmJJckZCjUKpXkpqWmZeakpOgpYhWMnp3RbTt5mLzz9nx0j +h0B5Zl5KfnmxlUJSfn5OamLe5vXdt9gFChJLQLZbKRSXFGXmpVs3t03e3jaZUUkTABJdQuT0DzMs +XfalCJRlLIPCbtf2pkyC43KWeJw7/5BxymPGDSckJv+VEBeo5lIAguT8vOIShYLEkozJBjyiuqVF +OUqaeiX5AUABzzS3zJzU0CAfjQJNa7DizDQFjZLKgtT8NIgOVkkvIQWFotSS0qI8sAhIWe1mH8n7 +lvUgtZ7B8c7+vgGePq4u8Y4ero4u8f5u8SGevq4KamoKJRmZxdHZbsWxCra2CnmlOTmaYDtKMory +yxXyUssVQoA2uRYV5RdpJKhUw1XXKmQWK+Tllygk5inkJ2WlJpcoaKSWJeaUJpZk5qUrqBdnVqWq +ayYwaVpv1gheLgsAh4pQT+UDgHh4nAE1AMr/lOMB3uIBsIkHCyB8IEZpbGVTaW5ro4kHBLO1Cykx +s+E8yCGTw14dCCA/PyBudWxss+BetBI+ahUc7ApEeJy794jx7UPGDbcZhVX88lNS9VyLivKLnBNz +cpISk7M3/2T8qjfZ20hqcqmB8mYTw7ds7KV52Xn55Xmb36W9YoRxJj/J8N9cZJWDEHiXJrmZ3yab +CUVgtR2L/OQvacKbz8RKsk6+ES+6mTn5PjNWEzc/yTBnR9HsX8DPCAByHke78QXVCknCEb2PCgdx +zOi0K+4ZLNnUTnic2+q7xXdDpghvSWVBan6aQkFiSYaC4uQJoqJ6YKatQlFqYWlmUaqGUmZeSWpR +XmKOfmlRjpKmXkl+AFCBZ5pbZk5qaJDP5Hki4psvijwRBAC5TB2i+wEkqnAcHQ6hTGCi3XSSdoKG +8NMXr3ica2JsYpyQJxIQK5O7MmHv4lwjz1uZio8fHV+uXwUAkYAL4PUK2WV9q7fJTgguOQqnUSmi +sao8C614nLuud1F/A4+gXmJxZV6yR35+dnFIZnK2XlJqemYeiOuSWVyQWJKcoaFpzaWgUFJUqVAN +pCfvFlCaXC8oNtlOUG9ylqDs5FZBgcmTBT35FRRqFZJB6hWqa0Hqngsq2QLFgEwIWauQlpmXmJMD +MUZBAc3a1LwUNEs3cwn5sgIArQI04/wYcd9a+AIu7j4RaT+iEDgURtQjlph4nDvKdpRtgqNVjr5U +0nbJ8KOzQ598/P6lLMX/rMMHQwMDMxMThZTU4pKi/Eq9kmKGyrkvI7M2xH9dFlDQXvyA/Vveu4Bv +E6stbSUXJEZscV77JfLxLB/Zmk3dRo8nK8N0lxbkpFYUJGYWgQx4ejdKPre2uHiC/qbpFxr1K5IX +a66f+FFCpPzi81mqLY6V5xk1xbjLTKvkJV7JTJZltBMx03blqY9uesh1u1jXNuqFx2MpC/nN+Yws +jPWHjq5TE9ywlvU2Z/nGkLz0UocI3W6onUWpiSmJSTmpIBunH0nJCUpREt8ZEurR+9X8g++pehuo +suKSxBKwmj0N3gdezN7i/0zSlOFK+cMi+0rxWVA1JUWJecVp+UW5IHXuD+ax8awLNTs1I+Bs8Ims +91nfA7cHQhWWlmTmFIMU3bgw8cJDyam72mfIfWGS7Py5S6L7LlRNeVFmCcxdW13lN0ycl7P+4Eoj +n5kzn7N51O85CQAM1qUv9QKiizWzl6j73UD7ZvU4HcADecsWKnice6J1VmuDCTt7aV52Xn553mYH +9k62yQqi7JNv8j4A0ZtP8s1mAwAOLQ2z+ybmWCTIKuxcL8Ra0V6T4oN9lNteg3icex17LW6DJkt9 +cn5ecYmCf1JWanKJM4hdVJpckl9kpaBRlphTmmqlUJqXnZdfnqepYGunkA9WpmALVW/NBdEdlJqW +A+S6p5YAtZUkFqWDGBC1OgrZqZVWCgFF+QWpRSWV3qmVOgpFqcmpmWWpRfZAwxWQTIfaBDQeaqAe +0KDJ6izVEfpaWgrBJUWpibkKGfn52cUKaflF5YlFKQolGUUgHWCnFiuUZ5Zk5JeWKOTlF+Um5mRW +ZealA1Wk5ipk5pXkKyS4FhXlFyVAHVasp6ClP3kuizI71NrNZ1j0GWGcyf5sapt12W4iBIQ4LJEl +J9dy7IfzPTjDOKBsncmF6rKTr3AuMkQEigZG6GqkFhVp6igoFZckJmcr6SiAuNabN3Ithdu3OYkn +kRluwW1+PVawqskCAqcmzxVhn/xJIBouu1pNZjKbus/k/4Ksk3XFBCdnqWts/i9oxzTZTaRo8kGR +C0ANvJvniH5BGD5V/BcrnLNc1oyVDNdKKLfDHbh5tdo/hGvXaW2DSxRoVzMDAOMg4aDyBL3v+rkH +wJhHHYrpmoyE7u3L+iLKeJx77HHDY8NMFiYuhckzWRwnb2QR3vya5Rgve2ledl5+ed7mvUKrWWCc +yZ5iypuniyfABTYzyyRwAABeXRiQ9AF7ojZKJa1sW2EVkAXkXJnEPpDqvnic28y/jn9DGgt7aV52 +Xn553uYiFkdmAE9cBx75CaPIdJ9MUTuCwtHRlUSUoBvHD3YzeJz7mPssd8NudvbSvOy8/PK8zcfZ +I5ngHB0uPf6AxLxKhfySjNQihbLEnNJUKwUgW6G4pCg1MVe9WCEtMTOntCgVIseloKCgpQ8kc1JL +FDJzc1NTMhNLUoNSi0tzSqwUYKaukGzmgVkxWVFOeLKtCt/mQLVkuODmA0aGLAAnmzcm/wKS4Coa +RPti5FSwJwLdMYoOWjWeyHicO6kxRWNDDid7aV52Xn553uYWznKWyYJCJpst+AoZN2/iD2PaLCj0 +iBEopDRZTkQbAJSPD0fxMeXXVBEWPYTztkZabIA6NTBpuaeReJx7lL+4aEMEs6B/UlZqcolzfl5x +SVFpckl+0WQ5VrH6fLCogq0CRNqaKxmkQCEoNS0HyHVPLbFS0ChJLEoHMSBqdRSyUyutFAKK8gtS +i0oqvVMrdRSKUpNTM8tSi+ytFErzsvPyy/M0FWztYGyg6VDz9IDmwKwIrsxNyt8cy9zAyA5VN/kl +izoTl8JkAVZHmNDmMNb5cPnNjOyZLHDF1dwecInz3LnM7JoKVgqpRUWbw/nPME3WEVLfHCOUj1D+ +WMwIzlYUd4GzC8WjkNgSk9+La9ZD+ToKaZl5iTlATyXl5+ekJgI9Vc2lAASZaQoaYIYCyEIFNTUo +R0MRyM0vUqipgQooIAWkBkYEaIBVa+ooKCXnp6Qq6ShA+AqT4ySUg0k0IS8xF8kEW1tbBSXHpPyi +EleQgJIm2LTJD7nVNh+RqGCph0dSNdwaJD9h+IsYZ6A6QlNBEc0JyKYZEmccIlQ0J0+QVeSE69+8 +UTZOTJ9UI2IllDZbmqxkBgATUfvg9QKq6ETFkd4Q9Bm4pWz8Hpf+sjoEKHice/WC+eoL5g1M0Zu5 +o7m1N8u3xVmxl+Zl5+WX521uOMDPtHnaoSuGADE7EA3+BYetUtGodM9nqZEs9n1Xdu9g4R6beJw7 ++JXx+FfGDfv52EvzsvPyy/Mmn+b7DWcHCkltfsOvzw8T2Cwn38YK5yxXcVKEc964XobLTF6uor75 +pfcNPQBh4idp9AEmZrThGFGcf1p05adjPhgbD4xTwXicW2wzz2ZDIDd7aV52Xn553uZY7mNCAFNR +B9D4BCUZuntHsmnI8TDLnJaJo/QIkCeJeJxbWTS1aAMr5+RmduHJspyn2EvzsvPyy/Mmf+Z0VYey +rbkUwCAltbikKL/SXiO1qCi/yN5KASq/OZPrgB4AuxcaE/oYK2PKbG2hV5v1+qLe3nra3vOaKzt4 +nOtuZHrRxLRBjb3ePykrNbnEOT+vuKSoNLkkv8hKQaMsMac01UqhNC87L788T1PB1k4hH6xMwVYB +ot6aKxmkQyEoNS0HyHVPLQFqK0ksSgcxIGp1FLJTK60UAoryC1KLSiq9Uyt1FIpSk1Mzy1KL7OGG +S4FNh3KAxkMN1AMatFmO3Y6DXaFGIa80J2dzDP8jQTjHTlFQlBNuxmZ/s7mMSNw35u5MBgiXaWB4 +USO1SFNHQam4JDE5W0lHAciz5prMbys/ub6Cc/M0q2kO7DCjLKq3MsI4k+PUpTYL135lsuVSAIPU +oiIFNTUFAjaBrcpLzE0F21SkOVmyQZ9NB2zEZM8GJwD7fIZ39CUpbd5jHXlX4oB7Tu4UnVh9LvrY +7HicZZA9SwNBEIY5jBoiqPgJojDGJoHjOo1ciAoWIhZ+JPjReblMkkvO3bC3pwTRdGq/6A+wF4Tt +/Qe2oo29hWJnY+HmEs+o1e4w7/u8M3P1qN09abfnkcZ6voI2X6bE48y3OWUmJA4t10cTfFIl9Igk +IbMANJBBBlr6dMxuOmALi64qV5ArG7dYqflpaXWoYt2EDUZryHh9Des6MLTROUS2GMInAnq7UPg2 +0FAg0YhMrzaxZccL9Tp4aDG7nOXMISUTvODVoUY9hzuUKDLxD/LIAm6eUhctxY2BvI489PS2KfKk +rxQJi/eBna7vQuwNfzS+Fw9T4TgG0NrYtnwPl2kB1bDBHzIZFem6sKjUBSw6BAtgdlwm8e/EicCY +1CFuK1Bcb4GSaRXiHTlc3ox8jofTGXOXmswauz8jGnOb4nk/JpbMMbG9PypqBhEX1obcxldNDJa7 +xVtqSEZnJ7RfDJE1pppd+ZYSMx2dM028OP0yZ+z8TRgX95XejoTTfy6RMyYVc1g+2/PRL1Xi15v0 +J6o7GwxBtBXXh6wnIfXx+Ok4ulUCeJxbJ7JOZIKjiEhSnITV56vBBQt2Gou+b/rjxdH0e2Koi4hB +0tyDC+evWCJY8n3VwYU+Hz63VOdOXCtpn1vv3JiweunRt5Onl0zgEvea8uWmk6GBgZmJiUJ8RklJ +QXxxalFZapFeSTGDReylJSXCxbKizltSPtv0Lpxfej58MyvjRUaHrhsXVQrS7t5Qi8uZ5Bx2bVeT +zNXDUEOSMzJzUuILivKTU4uLQaZYXTlqFS48y3ve7uVH33ysvOSQKhw0WYzZQuRXYpLPWpUlEstc +hCrLHT681fb46jA5iTld5AP3+elTbQ4qt16ZtrF54l7/gLVbr06+y2wpEi2TuziaQeNnwJrev9m/ +f2R/LWRMmKzFkmB6c+LN7WnNht//vXgj/2r/A/XFFY++Qd2TBnbE1fyt6e/fNFe16VgV+7ttftL3 +JoB/8n4WY4vnmVKaU76fMrB+rN3IqTU75c2luNdQnaDQAGue2nDVuMJBz9d+lZX9Auktwpo6ZYaT +tVhdw6MT0sLumEiLp56PKJxc+s54tdiXZqjmvNQSkFaun19v5k1jDKlP0WCb3siftL+fNQaqIh9s +9vaU69eW/ut4HSp34sYyn0cnGAJ4eScfY7UQOVpfISt93+aHXvaq5Rbee04pCFx5OlmIzU5E5eq1 +sirZdQWH11af6F4gL+mS55O0OYXNnUlk+m/ptw9vzn/w+l5WsJR2cN0N2Zqdk/dzWIrUuEZU/Trc +V6Q1acFZlYDE3IT1v8Mm83AGCUetTr3p/7XOKDB9zceSf7Pfzb+7e3IhZ5zI7wfHdjQXqk8QNs76 +v67VWJxl02HtyY85vQExMhjx5ULMAHicTVNdbBRVFM7M7LLQwi7YbonraqcGw65MdxsQg5S/tItU +o7i0xVhtl87O3G6H3c4MM7NAa1qIqQnRbhC++kAbQqOl7dq0gPeFRNDog0TjgyZGo4nG4oPEpz4p +xge9M8san+75+87J+b5zz67w42We9nF+4SFRzHflNTNNdFXTcynZkdHvk0L5o7p2okg6iKwSy5Yw +dvhhzPr2IODXkjUM81LRqeZc9zAhasqSNd3z0pZxerjd0Ae0HPNh+usF9z0SaOSlGpxd24C/fEH6 +ZeCkUCOJxLIMKy6+jrHOBlyv3UDfru3lNsr6sJeSRNtQ8sShLRt+4NZIoi4PEbo99CcXZRWtbJhi +6LZjFRXHsGLOsEkk0SInqLXpHkeNulHeX/Efb3jMBxIR6fnITY6zkY4mMRm9hEVlHVqlYFjTzaKz +XxIN09FYQ2Yp2f3Y0tz+ZKy9oBHd6SSMDdsRZVtkg+MxD/BfvVsep+ebAxyOJTf6vSRCyX6YyTBm +ky8g2PIBvdMyLdDxp9I+urqrLcLZtLVrH4eL3Vv9J+VCkdCV7nVcIyOCLcXYzRlMjheJbcs5kjAt +wzHc7ejelw/ymH7lO7zVc0Ng/NDBV3/h0NfbjFWlDfd6E9jet8zsDqQyBzCT2UN/yrzJQ5HfwxWy +mT6aXeR4YuEb7TnsUg+6HbyiFTXGe6ihXAsLxLFvKoz7ud3YMegCt2FHthkJbZRTvarI8Z3Mmsk8 +Qi8cLwto1e2gJKqSaMqWTTwxP1G30DrjNSaC2RPAF6f+wJ3Tq36LMKrwz0QYc5m6QKIiLT5Wn6DK +yBmB/jp6q4Z1DePpiRAGRoL0t3NrhEiFEk9nV0txr+gManaCmchMNqJt4mc0ldLoKK3HWGkze4OY +LdXhZqmJ/lj6kPeI+f2dNkhT22BfuE/HLy5zODR5Jly9rf8PMGnk3W6fh/nqUophTuGjqaOCu9Lf +56JY6AnSzuljXG0F6Z0ojVx+XsDIXIiz6OcznTxG59YzU3//LocjVw9sqo55cM+M/btXvxXYFaF/ +IRz1ZmsDYmyIOIOGGq8s94CZpvmuaiE+m6/H9/N92LkwW43RreXdfGjIJop7gXKhkJWVPC0vjrs/ +xW2BrqVnoS+txadLXwd0I0UK8jBuL79RT3Q5W2B/RdM1R5ML1UQjytcGeCWLZ64f+hetcZL+6tkB +0i94nG1WX2wcRxmX7SSkl8RJmuDaTuxOXKu+S/fOsR1COOdwXNepTVzbjR0lNDFmbnfOO729nfPs +rK9Hapk2pUJIVJSvUlUkHhBVHhCVWh0PIKFQhMRjCBJ9pCgCqUKoUishhIoq8c3s3h8fPJy9++3M +9+f3/b7fzO23u370fkdtveOnnTsJW/iBIrcShNC8kIo5K9VSXngWGpgozPvLUmxIFgTaUJyjvuOx +xqMoFK6woIweYhujDpMrIpS2MfjiSeFUWxyWuJqVUshF9oJa5XZxHu5ePwL/3jcAE1/oh7/c+SLc +X91zpDitM5kRvpLC85iEzX29+1ylykMpePzADHzQm9t/KfRtxYUPp/rYzugomaG2y0jgCUUKQhKl +X5jcYpI4PChThV/lSECKjJXT1ONbjDjM5gF6IMlA0VKZOUT4NkugrzLukmwzZAgM98m6Dr0eecuo +IDWpt3pU4g78ipGmiQFRhrbC0IGIomun2pvPdBaBS8ssrST1A67zDsyiOEoG7if6B0mORFAlh4pX +2OaKK0LPuYwJT+t8ay/3/arjOVUtMzLv26LE/Y1nsC10g+E+XiojYskhXzgsGyGVaVs1mUgUYsww +LHVWFMUdgbCLTKWw/3Dmei+89c5J+PwxCxaHb8K7w649eppM57EyaiuSpwEjWHcQGIRXDB5XYpiQ +DGTG48xXdUJkyOnRZsS2ZFrjfjzeC/94fEY38ZJHN4zzist8Uol65DCEiir8wwNSiku2qe9jq8si +CHjeq5I8Q3qhB10ZyVcNuCG2zIrbIRk23xe4gftKt0txP8R8iBLENaTeQzj24YmRl2AseQwejFj4 +/8eHojxJLpdDdsPvrw7uFGig0kgoN0uS9XkgofQszE25wrGIa6YgsIiklbn6sxuvdGmgZ0LnZRDA +tIkpLYM+sJNUboQlhDG4MbY22fwY+cbvO80F4/ECLLtpnFhDbKTkzJQbp0JE/nlmR11qLj27ppc0 +k6w7E4bUxKdKj4mul+h6cXe1JM5Ilo2oSyuxe8RbYTgkfBVjl1UozSzF7uCls8d2dGDkeqYZjIwa +Qz1BnCZSoopJjsP5LaZ7WE8Hg3FJqG1j64Wuxcd+G4LoBmMvHWbabiaqlGlgdqMpR8dQj9Z2gful +NRhM9RzcZbiYOtmC7rlW+Os0aPHw5Sb6i5hC5vmAsBeQjyyabKSYzyLu08CUapvx0G8V5nkkyRFW +RAqLbiCPurhZj6UhC0SJRQUGiuMeLBN1LJo/rlLNWuvO2xKE6ScG9Vwt8CIzWeIQtE1i3ExEiuY9 +jKPHjfs4MFy1F1LPMkoQXbl8w72mm/YMlUWSrLjcdhvss9GnYitsXctE8lbb4u1UnP2VOHJm2Kae +l9TFWLuKIFOkbXN213dYsnp2yDbJktB3WIH7zEnpzmwT5qFg3WprUjpQVY81BVs3qCBFiVAUapVZ +icBPIrUaOjK3urpMIoAb86YHya9itighjvwm3zJagos9T8svDozU5FSuFOGGS4wuR+cIol8Sfly9 +h7EwD0ZLS2VzKqBKazsvkBaJJAQGrZNw3proxroi2m3rhSCtkcH/w9LowfiC96wh+CP+PrUG4GC6 +vxNNv93pg6l0AtnRP9GgXizkyeicS5kxaxenoSEdHDbTPbnmvkjuSTJCqH0jqoIKgxnN4RzxQ88z +Hn6SfhTupnthOtUPH6cf6txOwPu3H4FEZrHWObrUCd7YeNcW9eCvY6/CK+NZ83zz6iDsnfhnF+Je +6z77dudeNIYMPjxH4c/TY/DJ5BmYvHAawgtTmvKrTQWLpJfkQ+6hSFSiswSFTXjYYuaJCipPERkr +CkSTviFhRtasSGrMCcSD5kZu5McyhUZANKVtB0We6OMpz1h02NaHQ5lA2olxjmChsuERtoGstUik +ktTRXEJ1qOjzP5p5s6Uugc2YeGPbwgmmJAjz5mS29HMlT8v6OlOWQglzYYgvRBw5T/GOo09PEs2K +qVhUfF0mj+OY+pQbpx5k4niak/EjdvCXFwb219/ggwvDzZe75x/bo1sPH50/dSC2moPez/UcbxNm +rctT8L1cP9zJXax9kjvSYVo9OfU6fDT1dTj61XH4wcUHxvbO9A/hxadO1MInB6NF92YADTdw0QA8 +PPtZbOuBb1x6HRJP5+D60/+qLc0d6jhcCpiNyGh9yVO7CHfmL59IGqMRCsmw3b5h62QCpwuWR0/0 +rZuu5UjjAmMMyXUffrE4BL+7fRy52g3fXzoAx0YehneXLtY6l+c6YPg5Cz5bPtp9qzHFBgl5OQu/ +vjz/UKNzsHdhtuXtawtPtby9tjC7Y9qLVymUudbDOI9XB5xujRveayXqMp6Fuq2YXKbJixVaYuaQ +oI25pvqk1RSnpMzLzNM6SWaWFhdnZ1azeoozzHeSKeKEpXJAepF+tKBYxBs3uurrAPCHhfFzuqZU +LEOtKkv+92JZFyv81eizHZ3w4M7xo3mOoRpOthPbUFu5B8+O9g+vO5irFNVdyMe2JJN4nbPztc9X +v9IJxWvp7hbRQ4LVPr32Yhf87Mapk9qe1fps6UuJwltXvBUf4OrN78KHN984bD43rmp+7b213+zt +tgjKAZM2XnWdqVTtTfvnfY+YhQXOPJxQIzkW0RnV3ty2u+A/3/77oV1mGHj5T7WDt7Mduh449Or+ +wy2FILZJ2H7lHpS/cxteu99zwGQmorL+dv/Rjv8C3gif7OaEAd5PeJxlVHtsU2UUz+ljKx3bYKwb +sLF9K3uVlbHx7NZtZcB0aDeQ8VBwzrv2a1fa3W733o6MQcAQJRJA5Cg3apBAMMa/GFxjE4kY0KAC +Ij4IESmPIGiMKAio6EC/e7tH0b/ud8/vd37nnO+c8504Zzh8RIdtsB/zdWWYoxuNz+h+LewjwUUR +qZFyXiqIdhJsptS7QOACvJ1EJM8CTqJkPT6hL1Qykl4yKJ+ZOYPBRvrM2JoxVfGkL9XhpbHNyqyM +HYA3xu3bQGpJS29nezhUavWEhSD1Wm1OsyfMixIJtoQ9QSolMAYtCZT5HRGeOc2L+HxUSGQ+BPzf +wU15v9RBaif8zyOOWG243ZjFJyou4wPdETpYd4LivF6JiiuEgCTRh/iJ9gR6gyCEBepNYNK4hYXc +a8jKSZRoDPg7VrALFZo4IcjwXGNhSgKOZ+7nmkeksd9iyR32ZXUEKC8t50IBLycFwiwH5YLFCpiU +7UUhu7nQF+E9qp2wbvrDAd7fREWR89PScJdqFrWmbbPnKyfsWUaowJuVK1GYbsc900vNZJDjKsf6 +spxRxOUiPi4kUqyYsU+5OeMXwFcW5WDh7GJcPXtlmpmQEOujQMVISHKif06rQeoIiHhyzqy0PgaS +QYjUYpKDpKwnlEkRFcFCx+PJGmPaNAw7aiyExGsVqdCjNVwTyndm6Rj5tCN/YhxwlXdIUtdI7U5V +K61qSkY83EhAIuItxzi0OMai5fhY9Fa5VKG9VZOMqnA5jqnOwob30vGHKuuwb0K66dXZmPm0BYur +yyfHocT0FmmXpAYZTEqVS/uPxK7qemzZk2kSqBQReFKKG2aPH8V84gT5jVxwIK0pwsN16fhuTVj7 +7vnNiEtqhcFzKvK3TYq+bhYMg37Xce38XX0qvuaagOvnbtP+Z9avx1P1M3U9HDrmvTB0bJj/JVYu +aMJj10rR9WMSmi+blbsLtgC+/sgmxfFoFmCk8Y3RdtIe8a3iSRmpbEX3wuX4wcILRjth04sfPbYh +vVOkHvYceLhQqJ3zBHHr47twpjsHF7sdyotuAkZtzJXzTSbAe82ncF9LkdK2+JA+Rb3oasLxvXaC +V5aPN9lJmxhYS13Kh0uD+kkJqC8giJI7wFM76YhvodL/ZJUhe/BHS62idRjE3NYDyUPE+61ZyUom +zUrGL0LZuDOSjd93Z+LYSIG8sQwMyrHOfsB14Xrlk3C3Hi8dSU0OxdcHd4kx/Ly7jFGVCSIN+exE +lNhGqtnQkNdOerhQhGJ1z09Yvuaocm8Ngp4tDv4Ty8VPe2egfu0m/Hr+RBBx45k8PBwbjdfPNOPl +/uX48Vcv442DRSh/nYFrL+Xg7G8KhrJlzahRJp7N0yWJksAWU1l4LgbJPNfJwvbglTNzU7muLspr +TyVhj+25/jYmV4KGy1W4JXYC/RenK/0XDWBQXTB2qX1UfLicZjN2rRyPvivva0luvHqx1KbtWXxq +B8M3cV3VZAllz7G3Jp6AnazCyskWdB9In0zWsdHkvGE+1Evi6KrW1jpm5SOhEKlVdwSfjRXg3WtL +seX6KSQ/7NKCwWV1uPLBqRh+WjOcWiE+d7VQV1yMf/wsDdlKlMM39oMSvNkGeO3WDtzxG2Ld7bdx +4M4ETWnrsmfw6p3N+MJfY/Dg3T6TNoNs8jD4+2uY88cFfafox7/u5I0Rwp0NvDdeYcBHSuW8FMhT +Tv5ZolOS/k4CTB2YOobUqcWzJ1qKP/zoHnDqSBkWDIzD3QPpclcaGPHQgBXPDhxQnr/fCMr1B0fg +1bfgKdzcaJUbAdLlCoBf5AodLBtqYNSkh7mgZ92KrjZACIzalETvGOFdwHe6M+WzyXBePm6CHrWo +6N+jYJop2pAB7froMQtcBRCjZ7PhS518dCLskfty4GiKVmIb7WGJys/nwit6thJy+STYbdJ2gwWQ +8/OgSI5aIROPVCbJ6/Jgpnw6Dxxgk502OB99kA+HQHVjF5opf1sA+SOubivs1DnNsssGU6Ilk2G7 +LoVh8Ztj/VwUK5EtxTBfFbLKNXoYLVMb9MtrDTBOpiVwe0RpdynU4xOxomiBDd7UMc1/AYvfBon2 +vgznRHe/+pWUpCJ5L93Q8RvwyIjW8nic7Xx5fFRFvu+nqjp7QgLZQ0hOwpIOJJ0EASUhhLCD7AER +WUKn+yRp6XSHPt2EgBgddcbrriX8VFDcddw1auvoDDou744Kirsgiuu4gfuCCLxfVZ3T3Qk49953 +31/3PT/S6T6nTi2/+v2+v7XOLX/NuO9gCl9JaotrtWB3p+5v1Twdnf5A0F7q87v1Wn2d7gsapeUO +fjE5PWWjtmZpwBPU53fqcMM2MoQfsuVyT9yFvRPiN9DeDxLfInxgSi7fk+zv2ZisaWtm+YJ6wOf0 +Nvlda/TgVGfQWYGXDT2wTg80dXe0+L3qd7BJd4UC+hQ/tl8fjN5ZM9Ppc3t1+XW+b5HudC9wBgzd +Hbnnb21dpBudfp9hNTKvrmp0BT3rdLOhsTCkh3S36MCQl/Cbd47HCOo+8TPoNaJj+juDHuwveqEd +n8LpBp1BPXIRGvfTrNWyqwW6z+3xtU1xer0tTtcaq/8OvaNFDyzQ9YB5YW1IN4Ly+xSv39Ct9tEr +7qWeYPsSXInPohR88ADNKRMtXNj6uMf0Dk9QXpy3WDTePZEMJhV8bUpmisdYbC2Jn5NSAi1Bks2v +T9kwodW5RlebEUPk+aHgTLlGOXe/T4w+y+fyd+Cy5uqG4WyTdIRzB9syaUUyz4jPiW8PBjtLy7kx +5E5aoV2Vn8UPFOXxMUWDThX7jh22+fs+vGaKP7DG3LhpgYA/YG2ip619KVI2MNcZULRQ05MDOhtp +Yba8uMTnQfpFZ8kv/ixfTOVA0Uj+TukEhozJU4vs/Ov4ZP7s0IG9BcNG0972EbmUGPxC+9je1+xX +Eb595CpePWoCv23Qmdw76o/87IrTeWZlaW9DJbCkJsmUFVobP1K9JubX5TUruWts9tgKuQeC9OWa +WKOnVbNbV7T6+nrkYm/r8r57uxLO/TeakyeanuguLx93HqvQDKjaTHNh5/U0pffYuGmk94xTLmMQ +aCaFfMyET+AVnaQntAb8HdN8bu6qP6l33sQyGynnd03+NKlCC+hrG3BCcN95NI/vn9IInTWsgC+b ++kDv8Gn7SEaF1u43gj5nh16hCanunTPjKhJXoemBQO/Rmc2st3vODhpZrdG7cn5+7M+tC9+KUsbg +Wxc28S+WNA2wrmAv4rLvtPkrBHZo8xAxZi5evEDd1+r7QoliGYe6WZfsEdjQ6nTpmtkcJR9Fyejf +y8Zk3t4ylT/QMon/0NLAU9zD+Rj3KO5yj+Oz9SL+D72IOPkuPX9Mixc5Rwh1Q23fgX16EMedbN2u +S96U3BryuYSY8/1nFyTVauv8HjcOBK11tIi/dvYLSYZkQq1+Ipx7Ic3v/bSn0kYcfPsDRfyk86fx +ay8p5VvPX4h/S/iAC46J373Vf9yTDq1ns/Teqi020jsB4ghz+rp7F14zlPSGrl1Jet+97lHCb992 +PV9+fYh/en0n997Q00u2ZxKmOQ3YfTXJjlu+EveSv3/LCF5/46xEi716997oJpxsL+j138yireny +lTxwy3sDFWA5vRZfNfRedeuyuEy5ORK+KzSHw+EMtBl82l2ze1+7K4fyY/dMKrOX1wnsa/cYDpfg +S7tFFM0un7UeWn/v+XzQfRcRf++u+0rj+MFnxvCnH97AVzxSUoDcF/IEdJPOLm8IETVQiv0m80sf +KeOPPrKGD3102DDzhqNLYEDAYQgoRe4o9UoERqAorUvmax8dya9/dC7/6tFJ3BHOy3Z1uGu10nnz +p05rnjJnSdPiaYtKUeCbw0W8Jzwr1Y0YVav5Ql6EMP52eC4ve2wJ24TdnPdYQ9wmOYMXH5tNNvGa +GzJ55eOZ/LTH9+YpaRCr9uLmqj1e4Ay29172l4XJ/IPHhuQH9JChL0DWqTC11DwUnZn4EH/suV5i +9Aafn0/4k/9uwD0ZxAMlA8nd8GIuSYaDA4mRgv2q/6qqwDmINMZe4HUvTIVPB5ERiRXmVXiwmGTB +pEz86MzE3axIhhV5JA9ey0TMuuHHBP7Ki6l8z4uuOE3bhKv5el8uFGaRRL7ypVQ48A+SxLe95D1Z +Q2SRy1i+ZoGnU/d6fELLKYVorNQaGuo15ClHZ8hot7dLXSo3ndfuXM93f+egm5KhegfJhqceZvH8 +5511vHrXHL5hVyN/fJeDb/gOh901gme+XM0bXy6BYYdoJkx4iOTCKakkn29/eTb/58uzuOOVhXzT +K7P4s68UwbXxNA22ppJB/DBemby7KEHOHkd07Z4I+zNYDr9pt8Z37C7my/am8IajKfy73YPM76m8 +6Gg8L3411fw9EDqPklx++qtT+XWvzuWfvDqHV712Kl//mp3fgH//+dp8PuZ1L5QlkzR+9+uafOr1 +14fCrF9JKj/2up0Pf2MEn/XGDL7rl2S+5Y2R/G9vTOPkzZP46Dd1vvnNEfzxNyeIp4fwjLcKuP2t +GbzjrUZ+z1vj+R3fVUBjmGbxkrcn8OVvL+B/fnseoEQX86x3CmBXHKnkS9+Zy29+p4G//85YPmhP +Cw/smcJ791TyGT+l8wN7JvCyvWPgiWTcpvoPU7lvbwY/a+9CovG1U4r5l3tzr3q3Td31vTuE/9u7 +WXzruxP4G+8W8W/fbQF+F83k7n0lcF0KyeBX7mvlP+4bzvPem8td7y3gD743g//03ih4JYHU8xXv +Z8POJJrE178/EGpTkVrb3l8iZprOj+IV3I5Unrs/Q5Hkz9/l85n70/mS/aeBcygpGXECRe9o8fjc +dgHVzSjcilk+2t8I7rtZNj/5gww+7QMNPk4ixbBxD03hl34wBck+nH/7QT1cNIwm8zEf2vkZH87n +d3x4Kv/mw7m87iP7ICVuZp+G7JJ+PJWv+7iAr8J/6z5uxH95fOfHJ8trhZ+cCn+hJJn7P2k0GyXD +XW+STLguFT+epCgE/k8SOPt0GB/+aTGf/Ol43v3pPIacBucOQ9IV/nMiP/2f8/lt+O+7f87l9Z/N +4X/6bC5/9bPZvODzuVz/fBy/9vN5/JPPZ/GKL+byri/m8We+mM1Tvpxik7LqPJLDW7+s5lfjv79/ +Wa1m8+uXZXDqr/hl8VcL+M1fNfHvv1rCpx8Yw9cfGM63Hqjnbx4o4AcPlMAFXcg4xQcH81MOlvPm +g0P5Ofj3joPp+C+DlMMDFG2x9vJ0/snB4oh0JHzt58Gvs8stwBAE61SG5QJU/R5Dr9XMLxOEsprI +Gz1ZBaqd2+Oe7vF5jHaE1Fan19DrJFzkQ8UAnC0KcdEJoKHB0envVBqA7/p6ltq8p36O59OO5BIN +jm2g2XzeN6Oi1w/vS1MdXvfNfH7d+6n8+28m8Zpv5/Ozv53Bn/m2SLBzMv/829E8/7uRggPHw0tx +pIrf9p0DkaaaH/uuW3BqIi/enwgQTwfwy/fF8c3fn8EPfL+Kz/phsmwV/mE+t/04m8/5cV6CsrFK +4MEttIrv+rGSH/pxhAQYbv+pBCb8O0rPgp+m86t/ms8/+Gksz/r5FMgsIqNtElwbi8gY4PF0EE7e +wb/6eQN3/zJaSIjGH/rFxKnqAE2aF1F6fp+0zuzKvLP+iyVuMBDS62Luien13aRyPn3MohR1V23s +nl9K+a+/VMElw3DpV3wfx52HpvCbDyFuHKqHk3eQAdD8LIvjlb+O4c2/zuZ3/NqQpDoWD3/562g+ ++HA+rM9GQJ16eA6cnIuAsHxvEr/tcLFNDMHv+2EY/+zwct74W1m8YgdoJCSLn/NbBn/khyH87t/q ++Me/reQNR4bABJwDdHTSXN59ZHi8GoZfgeDz8JFiMcZg/hW2krCUcXSE9WUAn/RqHF9wNE2N7jka +5HuPDuNHjq7hrccm89uP1YiWKXz/sVM255D18sdmIAs3f0qmSzrbBCHgZEJGwqFkkg4+glKAIpUC +NxLUd/JbTyoZyH/eN1CyGHxOyCIYT/FDMpWQPIFt8HYtKVBbV8yQSesZmQ8XMbIA3mZkHgyz4Uen +jZwKj9vwRnwcWQhL4shUyYy84p0qftZ3ifzAW6UwNB67NuLJaLglniyH3+LJHJiegA+OF3O5LgGn +cHMCqebF79dDWiIp4P73k8CRSHJgciKuwpp7MvQkkrLIAtL5JS9nws5EMhMyk8hkaErCbq9PIrME +Xk4TiqYRDqegut+QjG7anxC5w8loVG59Nx0ODsPO3kxFVL0mBSEunIKkw6aNstXjyWQQNIv1C9JK +UgnNMAAmpKLm3pFKToZt8VQQ6r4fBsOmNOKHL9JIDSqNTEXOMQPIXOgZQBYKVWBBDnwwgAxJj7C3 +4npYmI4UToujqRJm4ex0MgJuTidLxJNZ5pPqP5Px4cEEks/Eo2dnkBI4bT1ND7+TRxYSUgdXbCa5 +4SkFZCwF/wjyRHhMGZnI4KyR5Df4wyjyc5rlRqxzekN6+NoKcg0J1znI9QT+WUWeg0erycv92txd +QwaS8POjyfMkVRiutabvACWDSdaACtOkU0GDcNJYsjoufGYtsbH0DkN3GVEXDl6sJwZDnwUWNpDC +wTGeiseMWFSZ3gpvTC3ApdRPJMPh1atx89ZPJGPhlatJTvjeiYTG89KXBsHhqaQwIeRb4/N3+aBm +GpmZjDa6ObVw9zRyJUk3zTRxHb2C8nDGDPJdWrhgCTmJ8F8KUqH5NHJ7uGQpeZGC7QziCO9aTh4l +sGUl2Q6fFdpSYWsHSYVtZ5IMMFaRN2BVMzkXiB8Z5pw/sGQmPMCLUmwF4P+R5YX3rCaHUwDlbBh6 +ly74ykc6YKWfDKOV9eE7/SSBwQ3fs8HxyiqElwLkcz582iB4x8DNPv8slgtVP7KB0HsVLQlPDpJn +SbhoHbmYhJ/oIr0UTjqKknpppj3csYHUUn5f5oSEqiptabvug2//SLPDz5yF2whrzyavJ0W0DSzo +IdmZkZ/CQXDhN8Sqb26g2eLuQb4quzE88RzSbUtA+gjXMvz2+aSEhcmFpJ2Fz72YXBoHQ64kF8Ad +15OM8J4ryXsE3uTk1/i6ZOF7So+oBDdyFvbr9Ln0xXhxwiI9GAr45FcV3OJFz+f1TJyontHm6UEV +bUD4DvrFpUaXC+0gf8DQ6pGnz9JKW0KtrXqgybNBLzUvdAd1QwTB0HMxL6Fj6fQ2ut1o3Bixl6Y7 +Ozze7tgrwrMo7VEXTAEybwd0p7tbxpgiFzr8Qb1vr+pan27VJdlv/0X197+VG9zkjxM368C7hZRM +XeBxrZkQeaLiX1FkYsxdbeOmqP8OjdsQh17bQrKcJxxPPDBFbHcg5Ar6A/M7g4Y2ou/U8J7u7MDW +U0OdXn39fBWCK6+NjjjZKeyaTTB+KxkKbBAdCJdtJfWweyvC4uRtKJdfbyWlcNU2FE4pppdtJ2fC +4BuxyYYb8Ub+FYihV46l+fDQLfjEe7eQwRSdxZrOvMwTxChg7V70dL65mSTB0Vuxs65bSZp4Jg92 +3Ypi6PozHQQZt5FNeVYsQwBis3jWtKLh49vIQWLn21rzwLgRe8jYS/JYrRZz5dDtouM7yIh49fiW +d0lW+lDcbFxxqFNMSXdD5p3k1p7mLuQ2Z4tXl+xRq22MBv5qtRa/36s7fXWaW3fhApqCAeQpI3Jd +26R6x7teZ0DXmgWf/Qd99XsGHr2TjCtR3rCFt+hIq8Cspvtcge5OMVeE4OzwFX8m57PwafeR4TaY +k0yHwdMPkVMgr4GmhVN7STwRXzPC9ofJeBu88yQK8ubHyFKaE42kIT5ONy2yctjxDMmHtCdIclKF +5nUaQQFzExMRllY9QT62geczkp7RUKvJeKJltkFGA82D8FNkSjjnabLVBjufw/0Xw4qLmeG850lK +HH/2cEa46UVycfoQy4KbcqIZhA/sIZW00tUn8irCXuagKIEhn1tvFba1RZPwNftIG310P1lEB1cg +V/iNYAP+RcDz6a6gCjrrgQaofoBlQ9Vh5Ky7PiSpaX3ii+HEj8g0Am0XMzSXLkK9evQznPoDH5NP +GPzlL6jS2y4i9jBeDCWGN35LvoiDVb8Q5wCHU8EFSj7qS/jiZ7Ja3khxCH4yr770C2mVV9McrRJJ +1PXwo4fIUzQlOo2G8ObfUM9KnwcmEdoMnx4l32bq63EFSK/Fng494Gj24Irhw2PkGgHOozY/TFdE +HtgBCZR+Cr9QWigV1AuM1sLdCTQlvtnVjtoyXGujGdT8AU3x1Gnd+Gs8bYmvEjthKlXx9UTZiViI +CRen0c0Etm0lQ8J/yKB/obz4+fzwgkzaxsTw4a9y6Hj5DQ4U0IPw0WD6UyQMqDUDKaFZQ0Q81Wn4 +fRWav+VM8UNpLNM4mpNm02BWEXLSz8V0BFRpdD5cptFkyLqDZcBojWZBdgnqs5xiuhJCxXSQCK9c +WkxPgq9LaKUwncwO4fKf2ZDw8lL6JQsvGEE/IEk43HKfNkqrgadH0sFQp2OvHXa6GLaV00fg9pF0 +OKxJY8nw/kiq2crFIkpG0WOw6gKaBNfV0cK+McwFQ+qOj8I7homdtaPZBJ9MpzNgzkRaDtpk+mgZ +6m9hTGn4f4cz6GrHZzRB3jJDa9Hbnes8/lBAuCO755U1ulpPcY0bP36MXt168rgxztbq0W7nmFbn +ydUtrrHjx42uGTO65pSaltaTqryelioJic0KOhxnGkPn1IwfDWQmLWJiFiUzaRUsnEkLIXUKnZoe +0Nc6VKrFaHAEdeiaQkdD0iz054dvS882szLLzYzQyjppw1bvZlnQex8pguFvoWdxYy21weP3IUTP +m01Le4S9qqJv2uJ2XfP4KtVUtE5nsB0/DLRF1MrXeZz4RdcMmRTR1ujdImKvS3A0MzfTRCS1vM7q +0KmFsDMpLIJcq316l4mNlpljj8cVVeBOrT3ACntqpfeobSpfbfUQGR+Hlagth/3wnKu1rnaPq13e +6LeFmiuqRjWnV9oMkQl1dno9ulsL+lWXzg78aEf8dotVFYplib4Nv+b2+8qCGmJaSwuuwBN0wKpZ +9GJwNCJcp85Gbn3kPjQzkYJlcMl41JjaVFoqN+yB2fRU6JxKs1fheMIuELivhTrbArhrhiAI2raa +ZUFrnWbUQev0opXQ7ve6heLo8gTb/aGgaCmC/BEZ07yeVt3V7fLqDkg9lTbCvlqaAC9MpQ3QM4+G +wn9toqexITjwIj1kCA2mCZASZHMGAs5urdUfgAeZLavHITfb5xTpP02oTpk2SsYnBfVCHSbN1VNG +t8/VHvD7/CHD2y38B6QHbqoPGV+TsWC35nQF/AipAcUGRl2yFBccPmTgqF5nG/aL2y5aVCKL9ATQ ++kT2MRkk6Fcq2V6uIcw4zWSicmdET26P0WnJnNPnx44DMbCDvK7p6wWhBUgJtkWR7EbNLEguHsHd +dopuWvGZdrmmHlyGYiDka3290xVEhBfz7QzoQpIjMh1wmEa44QqIGUz3Oq00YK3JkctXaiJ+XJcs +w+XHNZssKBCNOSkw7cGJBnS0Iwx9EWpWHRnQbG5HYgWjyTPxSyXOjuu4/D8cbFNyFLsNn7PTaPcH +leBB0ZkkM7VCMzNm0jNaSstSVLIj0C0g8ul0W1bWRrF5wVr56TC8HpduL4eq0+k82Hg6HZWhginS +2pe+ADx0Ou2G83pJDjQsQ4g+fRldEK8QBrxnUDu8ugyhX347GqDpUHgG2qjy55wQgvlK82cA3j2D +LoKK5fRMuHo59QNZQR1WPzUrUIU8sIFm5f8u/aDxLDRNF66gxfDHFbQGjVhozGXZW7JZXPj1FXQH +y0JuQNio7HQGEAKCgjH9rVIyZknt5hYM5EETXECXuOvxRQBDsjZ6BJrd59dmN0lBCISESCPTBLt0 +3VfuELwAT61B3L1rNR2eFNkGMURej9pe7GaKv6MzJOABn5WujyGZuTPU4vUY7VGc6vC7QyjLfmvG +OFsfMqwzqLoJSAcOzU4lRFJsynEyXn9XZHYxctYjBU0Ywth5tA8hl2KpEuutCVfICZ1VL+RSEsAE +S68fidPlD3ndGlo4baInXXXkQ/nHFgG5LUI5CjIi3Plx+gHDIXewjVafrsTK1GVznZ3Itiiey2Py +7CutHJRiQUva6kzRODH3o1vSTrN6Nmk6ioBp7f6unERjlcc3cXh1X1tQRDSrVRMliidoKW5vMqfa +7jSmos+QGRXCyHXIGEtzEqwfl0+h2VVK0qwoaQwtSlDiRdpOGzEihkSwexbNExiu2RX1hC5E1om2 +EJwFXyazIaPwx3K8vTIailWPiCw3Tg73OtC9vFrehl3/QKU22U1zsszp9yENdLjpqB7xDe9OUQa6 +QJTjQ71C4fkQTlHHulBDrI42rtWkd7A6qshMiO8I4ZyQUH7VwGSjmA6DqCnwkR60zJ2tyJ9aWasM +xZVpdpECR4OpzDTI1G6IOhlDaxaOUIXozde3Oxx/vs+MVaM6Dgb83aZ1Ic3jcke/yPWiac1T5s+b +1wzPuelsFTS/gpIK2BpPU4QBquUjUU7V9c5Gr9Ckfej2yQFaArXDaHKRlMg5Fj/JXyZ7SfrX7CC5 +Pc0G2itm8UatqXhlS6GLXH7cNb9P6H/80J2u9gpT5fVdXqnL71/j0Uul1JpsockEstuCsFBskYhZ +x4PKsEdqQxTuvh2KOhsZjtMMFD6vOYEz/cKXk1aKVlqnlTqOI/LyvsUoK4WelZglzQuvmI/g4w78 +6qkUy+zRIxMWFkb/DhGRPQIt0DtH8RP6H6FLpCNcqLOlNeCTdMNGHjHbTisyU+lqd3r6MUGHB00V +MbyOJkm34skewZRd7YIHTfvXjZ4C2hqCobTVfai2uj+XxPzUtNjNnlivjUYZ7nPfLqRWqPTIZp11 +lmZvPBHRSqIocILbjmHIe6K38vJyyUa5JKdU4ZSKWqqKFsVuYsvsYq9Qfaeir39BL8mKV1OF4pE0 +x0yq9X84VqUs96wsRwMBrkgheUoARA57yL96pFzkGrPgnCdJXJkZFhf0wsU4kLPcEmtwcSUm7kj4 +2hegJT1TGxdPU2JkPiZs2ulTtNHjasahuPvczqA0URGSR1ePkex+Ev614MXQ5i5pWqzNm78YQQvl +0qm1+N3dDq3R6ku60MhyiwW8tOqBymk+VIjCWBS2UqhVyEIUrFxS0SHrtgrzPSDYxtAjLkrAv96j +S65F6VijCnwQl5T9i8OileUUyWPBmUaos1MEH4TJ7HPDTQ/T3B6PZEaXp0WIh6xxM6FOdGDNwWEN +F6MlTOdGE16Dcbz2RIl36+tlL8Euf2QWZgdWf8j5LuH2IUagkPlbhSUgupWGc9TbE0LmatfR7JF2 +hZqOaRoL4HJblIwQsr6PcrcUWkM0FqTVyhY9qsny0qC1F7rZRampvWKHkdWPvmAETP9zY1hDuNTT +lQp8Vf/QcSYtLzRtihMuRepdeORMmkkDOtyba8uF1QvRjn3/TFpLsYMhfpqX0V8dCj1hJ5vAexgd +71mn0VT0biVg+o7bCsu46vIEdGF+dvjX4d2IV34ci3Y415j+WZRDBd9UutGVRGccl20Xd0tb0FVS +/eluGVGXHUrlqLUIF6y9XPpBXj0yqkJpk8qVJpnRlPGKAQP+UFu7MEpN8bF6tDZMyuEa1IZqdq6o +seD0enrW6Q5tqu7yoN3ZoiPHS22vRY2EvhwupCVg2vZCtKQ76kbJC3qEhEh4UYrfpIVpKQSCijeF +oSWpMtUkCpy1hqbBn9bQogVymOnCPpNqQLjYVTWOahHOEN6MNXkrioBeaQDJpJsKVIY00PcQE/PI +0eCWNXRSj+x1ngoJoauFkNGE848YB7URr94CHz2KOcKajzGd+tHfK2yafhRFgTRQsUcFEf65hg7N +OZGUlNRzclJ23QkFCGUmKiwIxb8jAQ1Ztjxo8sp4kVznzGmNU7UqCb5VEnqrtJr162vFLHFjce+Q +zSX4IbeYbCkRMsJnsZae9M37ioQ0DIX6jdiFavEtZvGdSedYqym2OwlVhlbSjJplspiGyXHSp+sn +K8JTqDTFQe7mWi8dWR67m7GjxBiYiidgYT4trBYgLhiq9nj5rohqAvTERLg26PHyGxpziAMG+ND3 +FUgBEztoLls8rRxSfXRk5FKpQJyvdzDLaYws8EQz+z0xlXbT8RGfAPpq6ySsY6tKMWeUJEsWKpTM +OQXuOtFGzu1HNcsEgo3DWL4yjPfvRY9/Ugst5POPxsWb4eCPOuhQfuRoEr/i/VTI9dFiqqBxJAx+ +imTInHi7jw7r+b1F1WqrZfGlIni9ViJ/KfGKiNZqrRLJnhwhToyXEgWTLpWOVNAohdhERmSK8qUV +WgtKZtQTiHZm4G55FdMY/X0QyQD9JqN1OQ0LHxzwdBA3+F4fTTbXbYc/H6QDi0v6+FLRvTWtScjx +42MT/EjQJX6aE6dpJcgHx+rRobjcT5Pgo5k0J104iZLnlIUJR/x0ZKKmmYQf1UkngN5JJ0HWWpqb +YVpZkVlCtTDMFq7FRuMDNJ2efTZf+GU29AQQIy8K0GXwgfhI6mDpMMNA7SdKSwYII0wkyGRo2C4e +WGWIhKhfSAWKp1uhlMlkhkB6l9MnpDiIKqu81gR0Teol4UnIwMrspgrhYojNR2PK41NY1yFF8RKD +1sFzBs2Hdw1aCD8ZtE0Q8rJ4nJKwPuGjAErLwKdIJlz+As2A8TtIes8JwLdK8Y9MPqFk1pqh6Upz +n2Ilq/922tsCTpfeGvJWGu2hoFskWtp1r4Bf6RogWvtF8Key1etpaxd80xjjt5jmaHmMo4vTiuGz +fhylxAou9NHh8HmQDo5Ii8wX4WK17Clz5jdNs+yMTaaNDPO8tEwJUaPWoaOecVe2OIWi9PkrFfRY +poJdQHd57XE7JZWQSCQZUd5HeK8S4C7ihGYQ3hkMGXLvJEIYnjYRxVaD9HRHNJhXGNu+7mhPktqC +Xv2BXvCTErGodo8KY6z9HO0MUVz3oqQ4QwhyUV3ZI1Ra1fH2ktOkOBIa+3EG+/Ql0a+8r21e0ceQ +R0RaHdEjKEcmqlrdr4705dXahENTicwl1WOE5LJi36lW1OoJICfoHZ3BbuVMdyHIShyONczNZaL4 +BALoXGh24fyMr6kZrY1znKS01E0hqvVE/CN50iLW3HFHQcVM7cxbMqdSuGhu6dXj0GjVOz3oZuhK +bRyfD4hugSdmWjGaoE0MVBuB1oCzS+Uu+hsr/d2aaGdRtlSuuwAL4XkhUyl6RBabn1BTKuPTkLcO +PUTF6xbLRFQd8qS5ClOhRZcQdXEE31SKSQvu6GtrOaJTm4dTMYMmMvYnYzK1ppKa3Ff1ihyYGTpV +i4yCe0XM01qbH6ckWcChPF2+tHBgT/OUmUvmnTptquXx4j/ceTRtNbtubSNOqG9819mCyutE8V0Z +3pWqW5gCXUadlWqIUF6gnApjmtkQy8D26euDFkibmyFcU6SrX0RwowmUbumzWp2pzIlf1MDIDFXQ +02E6rP+pHEbZv0piiF7kOjQdOtbRVp6YWQ+vraMjxMGRcFoXPZ8wdJrCT6+n2aTIyitOQbg3Kqx8 +lFV1AAs20Geh6CxUo7CRvia/kXKYOJ/WhGdvokuJzHyP7KGDHZI11zpMkDaTXZbVjy6CKsaRV3yh +Tjh4JyvMktFt01m1iotgyHm0AII9dHieYZYPqb8NDhVnKq/bci5tHyoG61t30uBAaoc69Ca0ZUX4 +3w2XnkuLYPp59AtYeD4tSjC7Ad/5tBJuOp8OgYztNDfP3rd/a7zy8Ow/0mFEtM5ICwiVZOWYhILJ +D59zIb2awNPX0zw6YgQ8OJRkJwgDA1uK81n5ELqIXpV9wgMUMPhitDIShpKB8MqnzAYbylgO/Oli +OjFBxL+qtQZ48GK0NT68mJbD9jI2GMouoSsKzHsCMyK6drKsIwtvv4S+TdMUIQUrBbT6LSWksKIu +wlLqakl/5yUYLbcIX3g5vZPIMqfw9CvpRCKqAXPDvVdRPw2P2UydBPAzD3ZsobeA4y2aCFd0YNNt +QCeQhAqV0gofuoYuZfyr75Jg7GY6UBw+y4W7t9FFsPku/NkofhZfTyfJ42mXXE9XnZg+4aPX040k +Th7ihNu308pUbYJWI6J+Ig7Gq1/NTsTfFcmC9zw30hdgwS04HddN9DxYdDO9LkOWWFSgPDb6XB5E +Kqi8hdYV/qsjLVB9K70fvr2VFvzOjIpvo+0kSRbpoO1WDxMfphr843Y65Hd2+NfbqfN3bvnvoM3h +l++g2xi/caEdbrubXo/00MF3Dz0T3rmHzkxe7lm5/CQZauE33TQCNu1GblpzLx0Nky6g6SlWLgw1 +FL/xmxHhMffRS8jvTPv1++liygRLVrWzYni+lw4N//EhuiAppUJbKw+vihqWqiepi9pEOAz2/43m +JK40w/LhI3+jT8bcSFppoUzY/nc6X2y7jKfBjc/QM2DaepYLgfVsOPz6DM0L25+lRTZY8e/0Gpgy +mOaES/5Bn7L1yaBunmQrgic8JA8m76I7k+WeyUnB7jUkC1a7WJJNLBZ27KSl4UMv0wPsP2r0yuu0 +Mw4e2kMfSpdlElGNCmPfp8XhD/fSchbGrykkvGQ//TOBPR/SIYloTqtGQz6i1bnyUOVxx3NXwuqP +6DgwfsLNqP2MpsKwj2lmSkzEGH77HO//cozlg/1TOgxWfI4AY3xGh/dvNALSPqeZquXYz6meYNox +MR3M+IK6bOIx1f6XL6z22pf0qDgPmAEzv6JDUkzNJjhiyxd0VPjBA/Q8qu6v+oaOTIrchwVluCfv +fUOfI+r2zu9obpwqfy76nm4yrz73Ax0FqT/Sc9XP8I/0dInwU3+iTtjxE72rf8lz+KGf6ekECg+h +43XKIToqBUE0KIq4/KEgdB5CvTHMhtM+fIj+xLdn18CHhxBCkg7Tu+WhxniVCID78myDNzfbcuGc +/SjID+TZ8uWvK15miUWyhTRjNpmnuu0xqxaPFsLdv6HTc/B5ZL3UIzQH1v6B5adE4boEPjhEssPP +HqGb45PahbuE828JP2tjOgkvj2dU6MN10JPAenOVuT4FLZaKaHYFGz+YyLBT8wrKZ+Tuck+0vmru +13RA+MpU1kyoqwXsA9iZ4i8+OjecnM6eoT1SakUBhc9t+hwy+eIKhpCc3VZUs395TiQ1I4wr08QW +OfXJaPJ36WbhTZfTJ10rEZ6TBpiONgKaNRFzETWbzRA8vh/3KkPMoF6LHs0UNNMqtPrYwkM/umxO +lYxEyyH2nuQo8gArhad62EnhK5tZHKmNhiOkOdyMg7sDfiuyKaxNaUlaWUSZ8lZz4+dOyM9SiXOc +Fz4njT4cl7+87eRsv0kOWeo1fmxN5Zzx48bA34+woTDvXqYBO8qWyUKiVUeZHZaFWFq8WbM54GyS +M6hWGZkROngM2P4sLRzV35yu1FRRtpyumoaMOyFR4d6tNNcmzeqnk205UJqOOnn/y8xmnnaBxBRb +SYKmygpg92s0W85nRorNAc9dwNJBb8GPG1NtGtzewtbA+gvx5wMTiQ3sD7E0eCQDV/FqBxkGpePo +IIbIC6eNo0XzowRV0zGNUsPMwkViny5/YA1qO5/LG5Lem1lQYFlieFdVERT7yIgCzbzuwK3HO/Zy +y2D0wBk+MhwWhNAWObaLjYHlbSxVcOysDnOcdjO+1H+XZYyu2WM2UzYpXrareiH8gYZKJHsS8Qv7 +e8iivEKQXERFPOrosbe7JzYMGYlNWn25PQa6e24ZywpKV9JtyZDkNxlnEVFi6TsqP1LO2izEaPV6 +OmMtcjP0pQ4Sy9hzD4qYXICga2TqglGdmle8X0B5SqrToD9axmfFAdRAAZGAjmQsYuOH7kiKw/K1 +RQWVFQLorBdpu5nmsDLeoAKQwqw2IhMyQ4+q1tLjxuX6hYPmgCfOZ2dBQStrE9a5z8yynSkCK542 +H5JVyaaavXTcPKKAx0C/oZUU9Ui3KjnZyql4vCJi6tFF6szpdouUgkem/ER9sHnfwH2X8QmZBY/k +5PrGEbC76lhAsDzRiChKmtp7Ih78yY4ax+hyGY/tVu5VTD4lGgo3yaCblBKli90q4Cgq4MQOdnp8 +wvCV+GhGVeSmqQhobAIBt7inX8IIGUkEF7rN3ChynZW3jMBchyYz5yLBI0VUFd4JiqJfeuJURUVM +AFl0W+kVPqFgwfiQiIM54IZWZlcsETQ3wcyPqzBvNM4iL8pw7xY3KUyJaQbnrmTDmfklk596NDXF +8pLFxX0r2Vj4MY4NTGwyz9DD6pfRmPuW2Grg3DZWAHXU1pIvHGozBGfmUdv8Pr1W84K2nOlWnsMK +SR+HBwEkYMgnlxfVCCL0K8jXKYIdwj+3NlEKo8gji+im01AcJYNMpoQj/3aIclARWRUZ1pSuqAMN +z1JbLaxuYwnCPqgWZoUNVl7BEvNNmilBr9dKtVIzhADF42h2vMpIwpV30WzYv45lJ4j2IoV/V4CJ +UzGibEzS3SphMp1XnJwkHUy6iBW3CiqokIoF3OI5Q6u0myVSaDGUm2nETmcgKMQgJnBkRvfcuNvi +LQZ1MdFzp8BBoeJFfe1d7awqIzK0uaFw/2VsFEUXMuNVVM/3M1tusbkGFaaRWb7YjFYdnPM9yxZA +P98XCWjJ4lQhHmIsoSdwytEg1yhpwNgjFxp9brTo+2SThNIxOxOiGMB9dKsodme7U/J1bJkVEq7O +y5Jhuc1WQjRY+Fc2OLGhQTE4LOxAjbTorywL3v+ZJTKtoQHe76LFcE4HmwQVa/HmgDh0JE67lGXC +xDhbOux9Fbt66XKWLb5VcMcziX1yQb9TRhro+7u8LnY9cz3S7xOb5Ec8D3b5K4UFjBrE34XMbtqC +TYJHDb0DTTGPy6hVziLuV6DH3xHbWwR0KyWTS4qoLEuLCPdgh6FOVI8+pdPQMAq0hTpE32j4etzS +JKuI7c8cvtIUy0rBE+W406KQQ2rYHinWqKb1YJ2w5RQaWvjsDMZ21om2lgyE6V1KN0XizqbQ98m9 +W6XAQjL7TEmGjxwqdB9o8HdFBzRvRdnJCLlcuu6OpsgssZIVl/UInXDyMnbSYHWrX/mQbFMCwWVM +S44WDkHFGaxCpAIWn8HKxN+uM9ioYnWvxK6qN8RxPhS8RU5fmy6P3UBVLvqi6H0UJEUFuvFXkjNZ +BtP6ZhD+i3wk/ZS0SLcyKvukD03Yb33oHo3xsoHgi7flwwX7STpcGW8rhd6/0JyeWa0qP1wm08Pi +7SQy0N/tD0W2QxbcSsNZle+Jm2UB6RZEa2CWKv2ltL6s+fKpgKfQTQ5ttSg4N1ZLNJalYypU6umJ +FvHKCl6rO1HIayGFEINoJa9Sk+2CpiJLaGawRRGQQC6ztNUKK0cKgpzdUhV3+bUOMT+z6zY9PSgY +xgIjxIIn4m0H+4v75wm2TNiylo3qMcP2puGLQCrKmdx60CkCgjKnW9snTyHjRFbEUmVtnYZI0FiG +hXIA+pgBESzucIryelkOJ+xfFN8ePVJ3L6rh1Li4XqtgWGS7TBlw9j0iUKk6FZOUwhGwVIa0YIWZ +JQhnDa2685pHvpSR0eUx9HGK3GYXhtwKpUqU/RmzWDULqZ0c8Le1LJ8v3JfZV+PdE0C9n9XFcnui +6swl8+XyPJssJIxVWuim1QnvTm5lTCbDXJqhDH4R9reXyuxGqakDxIDLrfedqUpTEWeKnN1LQE0g +qpTg+q04o9e6WJ60ZA50sXJYsREF52CqLQEq16Oy/9vT+FE3kaQCrEex+monS6HaRnhlkK2UN4nX +AHSz8mJcTpmcQJmYtoqCxdTX8JIvMxnuKb/xiyEJKEVItGQYWMKKoHgTG8DEi6MErTpPRv1yZB1q +mu+62bUitA7bN7AlNrEaEeAogqM4UzHBN8SNXFh1FquXkTh5c/cgW0k4eRO7lIgASVHa/2VnHGYc +Q/HoTLYVSFpdkmw7+b/vFCs/4b/kFENZiq2onzN86jF00yc+hjt1fwaLhwLKykA7jy1UNmcYH4Dd +5+E3ZwvLjBcJdH8I9j/F7D2avUOqYcFgknXLIl6lQHO30ysKflsj5x2FLMTkTCO1UcJ9U9an5QSY +p5ys3kxmiChKKT56j3nCx0QIy4/WlpppsaDfrLxQNyInstyoKKWOVL6gkAAFKc4uJTzqNIiz3cy1 +xXii8t1jFoj3SHDD5bd5RAZZrSBy3EuVsODm+EMC7Wqj7jlaFxI+/F2RgrFolY/pQqvgi3QrZd1l +UKwmmimQJUq1av7BQNRptsZA9aR8WhmlilopFtbD/qN0BDyVakuFZeezFHiiBXnlnPORBdjLrPr/ +Rxr+H480wDWtiAtTqW3Z4t/1MS21LVxL2c0iZ5e9XGhweQhZlfUIcglvUm2MCQQOuOk1mgtPJduS +IO9SVhyxH4aUme5qxEGThymjde4WseGpV+iwUuXvNMujR5FTqDHBSdSknZeyYVCSbjslU2pRrTYq +Q6hRf9uFgz/hIYWw5TI2tY+PFq+0rnTFID/DVigcnoL/lA80GPa9yhKj/g5cVEsG9ciyFpkFFvwU +tbXtpgxEZbQ8WjkY4zG0H1fkE5P+7kbjR7x20zys6I8UXkc82Wlmcjtq0f8XvS71Mpnia9nQuX1D +3LGuFmJUiy5risSxL9y7mFqEJr+IjZv1RrKcL2KHR+MBO2D+INtAaLiSnQJP/oUkWhakKboInEr9 +4VLdIV2Ohwwla15CgdjRlopKAHX8DPfb1JcRCyZqRqqOIwF/Gec2sVtqUm08HZyjzgZEzu1bAQrJ +xQ9eyaoSIy8l+OFa1pCiArky/ARTr2NVwt2p2Yp8MXsrGw1FV7F6KB1P82NezDIJ7niMpMH3L6GB +IhOz+/exxCqVYzHjfXP6mMly2kqLOl0yJqO7of45nM+Nt5O4FfJ9kDLSlhxBuEhxsXhCHemVAbI+ +dm9tjBkplaCwXQW0trZakTTY/xCr7tHEWVix9eUxCNeOBrUasEsCpGBKc64y6CJGN/rsmASIMhlY +KRMoLdbUZ0Kqu8ikpMOF0CeUA66w1RsSRrpS+fKYkTgwKM8b4tCaFR4SIOL0mS6EVPcIutaosg7X +BFhZAmPdsBwDE3SEc6Y6RDlMVWFOgXGIMh1XsQsh92qWnijBoU0PQuNLNB8mZdlyTxGhTDOealk3 +Fu1qtQnt+npNxaAmrgis8E2Q+kF+hQVZtoZ58p07qrq902t6ZRbbylNCVo45JlhrSUhEfwrBUXv3 +wFaaM8tY41GAjBZspaSQyUOyrDCyGxJF/IZ5KNIc0WOY7owoIYH07TS/sCq28Eo+HIP0GVezEXHS +oZAJa3gpC0F/0dUs1ybfUDDpJuT4+Gx0Gk/Ktg2B/VezpB6L4xst7a0MK4t9VF1WSKKNv7avupDq +2zr2OEHyY+Slw/3VSLTSJUKwehl8XXI1ujDnZtuGwqItbAipg6Ib2EPQ9DrLJ13wzg3o5IjvcYiT +dcn888xucGyjSZC/nRXIzGx1MasMH9rO9hK44GbWlRxTpbJ2OzotebeyVDipmJWYsU3pvHwwBDXJ +FbcyxIDfaAHsu5WVyM6ev43VwC+3MResuB2N9AtuZ6/AaXewEiixsUK4+g6WZZPehvQN99/BbCq7 +O/hOlh+vrF74w51sh00O//JQkkPK4b6xuITAOpILlXehdnwIr8LXY1lyuOsuVkVUzx/djR8PJrLC +XEXaOrUlk4JGpTIfYMI9bDhM+pFOgBvuwbl3XogOgpVBaw3PvZc9RyJbPFhQsgCm3c+2qel+ECYj +wsMfYBcTeOFBVhPOfog9RlKtKFKUMz7qZYviVb4ZFn5H62HYYpYzoEJSFKVMvsOPf7AzJ/z8w2yZ +mTGf9SibbBM4AQNbWE56s8AxFViN+GXhf4TZEgI3XIZw/NivLOt/mrKf/t9X9ser5kTY8DjSa8oh +mi2+TeTtWevEQpvUgZPIIu3lKsUjUt8B/wa9T3LHsniViFZFj4+0CjNf5NBFcbJ4gYXlHugnPCeA +q/V71+lpRswZAQfflzXJmpGK5atov1t6IcIb8LeIijL5VonIfE0IsaxbWT4ciaOIGZlwIsN+0TMF +MswW2bvWgK7LpULzHpZEHLwwe7IorciHzx5H3vnDYTY4UlSCYjUNjuTY8iGlhCbDJYfZwLRIZYOM +Vix7kn0k+K0K3sm1jYPf/sqOQmae7Y2w8RRjBBx/Z8U5yrGNFEds0oZtFGLj/DvLr7EyUTEUMzlv +jqx6VgGemIN2cO/TLI9X35AEI20sE37DTkjM68r5sXEzwvc+w243K1k2Pc9GJlo1H9AwhhbB58+z +iSl6IGC9pgmW/C9EmduOoBuxoIUNDD/6v9gWqsBp4wtsYJx8YTX87QVsVFiLDuijG1DcL3iRjYAp +YToIdr/I5sVEbtLjaDwYL7EGYR1lw9MvsdkDj3tVPmg7WXZGk6xqdERKNGDSTqaBcyerTI55L+Cu +nSwk3xaELsBlVISYHZLRxXsWHryMFSVFJAde2c2G/492DU75P0ULTiZlhZteYzMIpAylaeHnXmfr +Kcx/i72aJ5Ja883AyFJrQdN9FXD/3SwXVWrx26w81yrZkQH4SB1aA/C32e3wzjtsLgzbwxZBcA+b +m2nW4VqlaqIiDKp+Qp7ZsIuK929b7yGAsXtZ3XBRfdzqkWGEPudSTvD8/l00FZouoFnA3mU5Uumi +ST8Ulr3LZiSY5YXht95lg0i5rDJqdXq8aLiatjnaKidYJix4nRWmRDYSeeqBu5HxhdmQ0S9YUgdH +9zGHjFZOeI/NJf7wE++x1IEQzLddEr69wJZEYcsQWy9sLbRl8QGZuVlr5iIHKL6PltLNKLItRNb9 +3835NrT4DPeLVQBvtLZ3Ks7Wp7YQO6ZDhHUeeJx7+ZSx5QXjBja+YB2FxLwUhUSF3PyU0pxUIJWc +rV7MpQAE+voKaYnJJflFlQpFpXnFCpl5Cvl5qQrlGfnFqQrFQPHE9FSFzGKFkgyINiuF3MQUoEje +ZDE+JXaoEZst+AwZeVGM35zO/yd8cr+TPJumQjVQ2eSzaSbi5RmZOake+fnZqSl6BaXFGQq2YAOA +ckqT7dIF+DzzijNTUv1SK0pCMpOzJyf4SWzOTG/gBgAArkJx8wltX1LP1nPOy8qe3aRKxhq3JDQc +a3icezif5dscloYtjE0cgVwKQFBSWZCan6aQlpmTGhrk418UkFiSoWBra6ugVFxSlJmXrqRgjyZp +pVCUWliaWZSqoZSZV5JalJeYo19alKOkqTd9Ahej3PSFHIzdk500hWT1QWYXA8Uzi0OBKi0ci4oS +KzXKEnNKUzWtp+oxJmwv42bMZgEAb1Aw5uQQgCB4nPs2h+XVHJYNajM2/5nhwzi5fg7bZJ0ZnLz+ +SVmpySWOxcWZ6Xkak+3eyE8OmSFlpamjUM2lgAKKUhNTEpNyUq0U0hJzilN10KTjMxLzUoCyk6MW +SU++P4OfH03B5NhZ4pP1p7NNrpglNdlvNtfkWbPEJq+bJTu5a7bQ5AmzWCbHT2edvBjIzp0ryKKg +UJo3OQ6oAKTBfLYkUIMiUDHH5NLZ4lg0KE62X8K++fTsXM7NpUtdGSeHLBXefHiZc/jk7g6ZyWz/ +HEH0Zvd/+gIABsReLbYLeJxljrEKAjEQRPt8xRQiCuIHJIWF2Npa5y6jHCxZ2eQ4Rfx3w4nXCMuw +vIGZSewlGtFrLnVWFXocvw/WeDnAGJNmef6wnymQOWFTatKxeqzOmri/2FBjJ9yhcZod/o3hltV4 +MlMrze60Jca8XUpDy34H187xcVerSLzGUZZ5wX0AH+09jfIEbHudzGLiHziy/Dbkl/RTUaU4vrh4 +nHuZ3JmywZZH1krBMa/SOSMxLy81R0chMbkksyzVSiEpPz8nNTFvsyuPNKOQRm5qcXFiOlC4NC87 +L788T3NzOm+TCgAWixcs+QcsE27SEosKd7DfZuGHdLBNyLD8VHicm/aG8es7xg3aipPvyYrzqylU +KyTm5FgplBSVpirUTl6hpcSemJJSlFpcPHl+oARfWX5mig6XppUCiGE9+YOC9eQExQh2BH+7ckBi +UWJuaklqUbFNSWVBan6aQnppYlGKM9DYpMTkbLtog9jNWxUTQwCszSz+9wpjtStH70jBgq5mpAPj +264fE0ZtInicO3ya+fVp5g09bJPt2VUmv2VTnSzAriKroFCrkJpTnKpQzaUABsn5ecUlCgWJJRkK +tpM/Sgg7lxblKGnqleQHAIU809wyc1JDg3w00oB0XmJuqqY1VF9mmoJGSWVBan4aRLOira2CUnFJ +UWZeutLki+2ik3XiuCY3sJtKgRTDdCvYghVDzKjdvIld8B4A4z41jPkKRxogY5M+W96PQ63L6OUe +YrtjdWJ4nNvZwbyyk3nD8tTJTmWiKgpqagpFqYWlmUWpGkqZeSWpRXmJOfqlRTlKmnqZxaFBPhoF +mpMtS89OdmYWEocIl+QHJJZkeKa5ZeakghVMVijbsNkv/TYv1UzcrFAm6QcAu9c6mfFTaQ7bujGL +h+2OjaGnAr/Ba5/2KBh4nLVTv2sUQRQmOzGQM000IeSH5EVJ7g6WjQlWdxz4A9cEYrx4J1pYZG93 +LrdkMxNm5hKOkFhYpLARDhlELoIERMSgNodNLK0s/AOMjd01qdPo7C/1ojaCW+yw89733ve99+2X +Ru+rB72v58zxBADHXjkDM0KsThcw5y4lurrFjFGWgav+IacuagP1RfN8r55Iw4aKumVIBRn1d6b+ +6DI6pW0m6ovXhup7ptk3OQnz1MFJDnjFFVc8ynFGWrtav5EMMEmwiANJ2w8kgRIbgys4cGovYwEV +i0MQcuqGOZy9VBaYFYJQ6q9kQ+gfaU+UmbWC/ZCDuWC0xsNiGShR6mGLhJLk1w60IPuhc/iCTzqq +HXCfL6b8rnpYW4egYDqdVSU3AXsc+/A3NW3wbDtKh99h91vmdsvsaLZMLflCbnHUJe8eauek/RaV +mi8PtbUTU4H2qFKkO5IHY+0SotLycB4NSG8fZZvPjrQ7nbLxTXOvH1fx6xxFxeV6PLSYn8VrxDaD +YR0bVTrbbGko2y0/d6ORYgYwcVJpHUQFkzgzlYYq8VS7cHXq0+LL2IEyZWDBErNsXK56wCtV4dB1 +YiTKVWILxS3Ml7keND4ap/1cTds665+OTsu5TEeiK2ReX6j35UMrxsjQnADKgbcIw5YDLinRqnJb +qSYwh3Va9RwQVUZ89mFvlSKociTcLBSNhBzbR4PDYQMjENq2ZwC51YPySF01P/ag9w+nbUq4APUm +2BY3Vn1NHHKwARXK1XBXKVNWKwjmkqWU/5HW5d4OGrDBMAwapW9mA9YB75liMT85rebK3DXFuDA/ +q5xDV4I/xKqKCmWuqGVBeNyImvohZTQgeA2zH0BXGHKmgeAeTEzAWDs/g2OmconadRAlSqvLZ/Mp +n3M6HqL//B2XCwTGxDejM/qHczHwtit3Gujk0CqjgtrU049V1EEuPEZn5PMnaLQ59hQdjPyj/5vK +/wf/xfrZD2h3+ztTYM6x4AOA2zl4nNu7kfHdWsbNYYy9TIzVkwVZxBkVJjcyq21uYRFiZUksSi/e +vJhTznDzCas88c22QQ1sAI4VD/H2twPB4CO0WhXy+OUvY4GWJyvcC5CpAHiclVl9bBzFFddu+Oph +EuM4dp3E5zlj2bfK5ZIYSsMZYxwTPhKUD2xIQxrR9e2cb+O93WN3z46LzdFWSkPclpKJOjRISK36 +T6sKAYdktaJUFFWtilRBqaqi0hZUKlRKwPkHKK3avvnY2z3fnQ1/5bzz5s3Me7/3e7+ZfOt0y0vP +tzy1t+XaA7pvzuCJO8dv123DwmgYjTvZaezLP/tR3x7TNqawnQYbMVS5qeUHSjm2Ywfq850xS/c8 +ZNqer1uWJycPeOiWUtHCJ1HRdXzHnytipPvILdm+WcApNJs3s3nk5zHKOjDTLWV9xx3wmMsJsB3P +umbRF07tLEZ8vuFgD9kOeME5C2fLfjqWK9lZ33RsZHoHHAOLtZMzulXCGVSyp21n1tYyiH8AG9TH +rNLCDD0QQ+DKL7l2YCCXc3LyFEOxhVjMtH3s5nTYRTVSE65ue1cWHdefcKaxjR6gGz5WtsSGwGGp +WMTu7eSFezo2lmwD50wbG+y75cyK75vJ6d0tZfbJ5u4yaNJxLKzb4ae7sG7shclGg7HxfMk34FRj +TgHC66+wyVqOh/cWTL/hQDAng8g3tc3KQuXNq85vIa1n2smbAxtTtadjhzueQfUf+YmJEm+vzGm3 +7RhYgZ4UwjPY9r0MOpbM5iEDGTTG/iHK0U2V/37h0kviPN8or3tipgj0nabnYxu7HvnZvZ304Lx6 +Odn7xc+Zzax6UzFtKCY86b6vZ/P1+8ygJJzb4xMzDTCcglE/MKaj82qXWXTxjOmUvCOu6WOvGj9m +adqmb+rWLbqvyxOheVRNMPfF4tI0YLBhNHxT4JH8/Gjfvc023ls9mh2MHarZ2C2ODSlMNj8aeefe +wdFVJkfD50k81e8jSMUV5O4HN5Of7ttMkke7upvbg9dnjscu3yb8TtcbMGaZK0w6VrJXjlY+zh7c +mjFzcJimbpN5Caws0Muknp3WNFm1QzH65deVgYr90FNqeTRMJsKu67gCiKigzwEF4Sw2oL59D0HG +YBgbaJaFA9iHlwRQSBqNY98HwnMY4bDJSM9B5aP78lCNzGOEbjxuegjbhmlPscCSvxc6Wvi6GcSN +SfmrN14d7BTldMvDUIfk8Ieb6AvHlHbynnMl3TOobCSD97dV4l9rXUcOne0ie05tUmOIjiyrm3rX +BhW9+WPw5J664bIUt6z86BRVelKrz6KHh5TOAQ9buWMNcnQcJYaHhQM0P48q+09vUXoYUUIpwZQ0 +C06yF87dm0JeNo+NkoWJvaitl6tqGmObBXL24RvIgNtOv74ER3zr4cnhFGq6pMZoNgyt9Hp3ccrV +gQPHgLnIgbOfj68di87D+8bHfRfrBcnwnPVYbxKdJo+z06gIpAJoErnFumuZ8O9KMHhpVvOASxI7 +c+Pl8mz0jffVzm2OHd0ZFudKsTZmY36CIBJDMbKcb48ZYUFtOD1YXiM7tsbbErdJR9kcige6JOZc +zgtMbpb164h1QPFDtU6Cz6hzGNW0pWoOk2fiN4c7F4dvDpLhACRadR8j6SS59cyFvk9yQLrrIwDu +/sVtnwmDM7OYCGD8ncW2S8qgBO7Cvg65E0RZYNUMbRhqWOROEJzIMesnUNrMDkLFks37MBLcka4G +bfWtQSirZy43ODQShRBJNf9btHy+Uqa2JwRtv/FY0P85OUQ/sf5flgKgbrCBAIjY1AqAlQOhAKjZ +ygLPuIFBhzlzR/KYIZz8+0xrWz2sK6888pE6HgkmRKUpTAIcccORdOiLk0zkT2Aasv90nFz/aCtZ +f6aDvrSotJD3z84KEExB23d1bgiBBEr1SgXIu27Dz+2YqTMEdO/nXWd2KDgFKpSYNrCADIw5BOGC +cdB/IR44m92XDySv+BFWjchpucGwOydhAHsTZ44CFALuIBtjw+Mo3DfO1sagbGGL5pRp61akT7HN +iWaVXgEswbPTJH3uugyACPtrCJAhPp/FOiqEyXu0o1Pkii2lT1r4TmxP+Xk4EbEe79oqpomJtRYa +Igcej5PZx/vuYYPSToZNxhgqbX6+ZmTtjlI1h3wnUK3bIBvMXvykj16nbKSx19QOA6I9iiZLOeje +2BCRq0GAQEbRYjqdRV76AmDcX8Kg7XW4OOQDpk/LhUVsiqKNo2HyJ9rTHsRE4EDK9q98N05b3lSu +KDcTbVWVEp0mP0n/qWgOq+1SgkkC6qBtzQWo3W56XgnOChjim/ZQySuLwzmWgZjqYPkS50ujA3gW +wY4gCFnHBfgJzOMI5MNcyx1FF69BH18v2Qs9XkgpUK7CsjPqhY9pPHf04rVKp/SFgXOoc1GNb11F +gibp8veVdpo4Cvn94Z/VDvLIxctIjvSR02Q/eYUMkA/IgCYRHUZNk7eLYzuP13wmLz+3hzxxDtEX +C0onef5cJ3n0sY51UKr0oSPg+9nHNl4FLIdyrP4gwA/Q9c+qW+H+889zL6rdctsl0dXlrTVAKnme +du+UFs1uIzL3WjgJcHQp/0m+d/6OythjY+qmxredl6lXeec82t1TJyhxUugKEWR6cVoZrrzw6rbj +dGCXck1bCF7f8rjepLvvUnpUNEIf3qUk1qNMlBvok7sUaM6vbozXLWJwLIpFhujbO5Ub6W9/oexY +0geVty9b+tUNys5BOmgpR8ieVzu7195ivMpDiUCuo/7+cJOJbcr4UqGgFONt9TVEr/qG0klnfq1s +WHp3UXn69mRN12Y6Byi8EcUsnf+9UomtA6ulO/6q9CpVwaboagf9yhvKoFQWS8+8oVyt0mteU/rp +W0m1tZzUQmzLXtVkjRrNg6HBcvV3YIJPgNL29p7M4iKrHk0wyMJQJBbMtupq1Db2OaYNM29iU+2S +ZdU4kLtPwU2ELwIkUXSdLPa8tI1P+hNmdjrJh5Z+9zflg7YdfJ2EuA4GGIwUM7az7lzRr7I1fecD +pVuIgqaIFs4CRDM8r4MfS/0fKn+4vsypGFgpbGSMiYPGyziH8ZDcT851CuxhxYT7l6AVLY0OAjfB +ZSzGOa8KlEmcc1y4ejE+Z3wcCDzoZ+AN+SDWmfAZ4ctl2UONBV74fS1UeAavXw7PKmJkaRvHGRYT +9OlFZXNXoE0i9ho3pwl2K2stttD/bFePbaqzYWAhXzqxo6t6qas2UC/0sEVZWJpIqxsubU1EdwTr +L2WvVR/8STlUD8HVF03OFXWP3VdYCHkHYVEOeD4DBwXuYndYQfGQ0L0Hb2WNj72aBTLcQIbLRDPT +DDpjPNNjkljIYaGV/bzujyF8ErR0JIesgZ4AWPIVuGHkvtsQwOTg2c3ULao99OZltT299n01qliI +bfaUV79kJMKCW3GNlrkOTicDORyr9u2RtARPf3/4Mb3idQ2VG4zWyevAhdhnCKUqHUR1rbRNJmoE +DcjbWrkpp5YDnSn7R3V2OG/FjCYTVu6jbqUaRcL88im7a+aEqo5VSTOXGluVPPlcNz3xR2UDRbPQ +2sLngVkJ1lsD3MkdJiL0Vv0WxES8rlQ/05d7lfjdNUZQWpihjtEhMEOIAD/ytrQCDSP12cnQ/11Q +u8tiKsf6cO3DcdUdOyRK1nkMohK9l2eQTBfnffZ+DdWLTwKVMg5zJj3szjB9yi4GvEjLmGk5XWzA +xSDfPOZnEoSfXX2QEJVqSUJOC8+jcLOY5XyXHOAGIJFA0wKxOiVQhAUQjLy4gW+3Q8eYgrB5rFd5 +HkugJLwTZVg3UH7sQ+0ptdpu2OAJgWGqWsZaw1eG4aB1yVbINWGQLBU6/aF+dYu6EKM/fl3pPizw +FoQ+xOFqm6wzT8q2y9Xnb15X4lcvhM/7LNQgg/7yrhpf+cy269PRFljToQtql5qK0YkL6m1l9vgq +mJk/MbHX3VIRTYKDbH4guHCmWP8Cygb9CddHkdvI/2bwVw7TD5uYjB6H55hwKXUXP+MIe3+8o1DA +hrleh9vMJOwhyWUEfWJZ7aK/fF/dEjw0aXxGJpxROyGUMsFDVr0Q0cJ6Y4Hkb1GNFY3wwM8cx6tq +Gnr4PfUfvLkmhE8tGEnSby+rn6XbllXtEz1lpj5FAxmiR5ZVnUGAt6x1kE0yeqoj8cleWnd+ynY1 +RP+1rMYD6dlxUf2o7f+Ygo2m5gWXBHicO72PZ9s+ng23eIVV/PJTUvVci4ryi5wTc3KSEpOzN//g +9VjHXpqXnZdfnjc5eI/T5P267M1T92yfuofxoDpcQrFFfvr/b4xS7bOfMG6f/YRpgxUARhwl4f8P +UKI0KfHyRS9+HD1v77yq9wkDUDd4nLufsDlmQxDTZFZmTxY9Ln39yVnMZsIKGYnFCjn5iSmpKQpp +mUXFJXpckxt4VCc3sLBONmDRhLKlNs9hOcUO5IQAsfZkRl7RzRK8WUybt/KHMW6uFGRh3Nwo1Mw4 ++aGg8GZpkVKhyUvVjPny8lNSQzJzM/PSrRSquSbrKktOZlWXmCyvLj45SUNErSwxpzTVSgGhSodL +QaEWRJRk5qYWZaZVYtMmBtUGUwPVNPmHutxkQ2VRZKWTKzTk2YBytZrWmxdr7GEHAH/pTdr2BDEL +c6yf0B+y9tZ5+PCSLWmVgVmBeJy7+4hlwSOWDVskuNNTS4Iri0tSc50dJ4uJO03nlmaUbF4jsX2N +BOMSxukfJRlF+BRqamwV4Oqm35NmVN/uAlQmBgCrFRhX/gPdLPtLGmRnb1PLO19otvzrOupzinic +6wr8GrBBnUVYxS8/JVXPtagov8g5MScnKTE5e7Mry2kB9tK87Lz88rzJByRlNluI1rDABDYfkDzF +BwDWcBdv+Bzqnfdsr6HvC4iLs1Kle6/Q7HrnYnichZBPS8NAEMVvPXjz4NlHVNigSfBqyUGK/w4W +QRBRwS7bSbKS7C67mzag0oNfSOgH8Ku5DYh/KHgamHm/92bmrf3o3m8Hd478mOYjrTx13p3zGZ2N +kGNXhaYxp60SXmrForGe0s1lKoyJDhA9ua/J9Ro+KA7j4fJqsLm92ACyDCedIOPhK+mgFR1hMmtS +26oL9Q2zqBRRPIGVZeXBC08W0iMQlZ6Dw1hdWt6gJO9QChZjLn2l26CF0E3D1TSppSIUNS/TkFto +iwUTWjnf96CLvrrUkqm5oOO6ZtHj6p4kilNnaulZ9uD2szjGczAAZAHWo3meB1VCndGOktWiWPc5 +5m1L8bBnqXaE+78OSv8wwcsLfg//DSh4sO0TXpeTvZ2tT5mjleL0JlqsaIYzEh+M6Ssi+TMMLr5P +V9oCeJz7u5+5/RDzhh9MMv5JWanJJc5FqYklqQq2ChCuXjKYv/kDkzHz5CttspP52NkVkvPziksU +qhUyi0ODfHQUSvIDEksyPNPcMnNSgQIKtZMnMomqlBblKGlacykAQWaaggZYrUYaUEleYm6qpqZC +NVBqsh2b4+RaNjdNBYWi1JLSojx0sxAaICbVbhZg7+at98xLzs/NzEt3LUvNKwG6FUKrAZ0EdG1K +fl5OpUJKYkmivZVCaV52Xn55njWSRGpJYmYOQkqh1pqrpLIgFWKIT2ZxSWpeahHQUI1UkICVAopl +mgq2dgqbd4scYeGEi08OlJKYPF9yGzeSWqBYBZqKD1INwhpFpXlWqDZNniNtwotix+aL0gs50IQq +VTSieVT88lNS9cACxZsP1m8NqYfEBNihxVYKyPLwGIREqEZeaU4ONBBhAKJNLy+1HMnXJRmZxXrK +RalpHvn52VjVF6Xm5pelgrWIIespzYPpmpx5RYYNonrz1Ssa3ADuSNPg8xcHjrmqOEZ+LeL9PW1B +/xlA7rBTpXic+7yc/c1q9glPhTPzSlKL0hKTUxUc09OLUtMTS1InT9ASjc5LLVfQSC0qyi8qtlLw +BKpJTMpJtSnNy87LL8+z01HITS0uTkxPtbdSgIrpKOQXlGTm5xUDhVxB+vwhXE0rhMlgcevJH81k +Jy8plJx+U5FRYPrCJYziTLVcG3/HLo5LKC1IL0pMSXUpLchJrQjJD/EJTrBSKMlIVSgpSswrLsgv +KlHISCxWSMhLLdELzk/OTi1JUMjJTEtNrkzOSVUoTs1NzCvJTC7WU9DS51IAgsxiv/yUVIhK++kF +MxnFN8csEWMXjA6uzE3Kz9FLyQQaWpwaq7E5ebVDKFtqfFppXvLkhpd6Uy8wsnNBuCBfbO1mjFME +O3W6XScj2/bPiowfZ4upFKeWOGck5uWl5gSlpmmk5oHCKGXywQUik/W3q0xfHcvIMz2qkVF8u+Y+ +xlOiAIUSjDHzA3BDmo1jvyKUk1GPPUHi0oYvgclleJwBMwDM/8kByQGQaRRB2gJd8QxKk24DnQCq +hRE+bIiHUZF9OBSRHL9x3LIJqhvZCwrpx+AQfAGzVQ3mFPT/CvtR1ZeT7trZL0La7ycwDpSOyscN +eJw7XXK+dIONqEZmmoKGYlFqYWlmUaqGUmZeSWpRXmKOfmlRjpKmXmZxaJCPBpCtqTnZWlRTUUEB +yFawVchLLVcAyYCkFBKLQWxNvYyi1LTNsaJZ3NL2VgrFJUWZeek6CvkFJZn5ecVAEdeiovwi/8mn +FH5zwuUnP1DSnPxO8RNCZPMDJSVGVAWbtVUUxACp2zzS9xOKDiCBruwJYK9nWi5GIoV2sXnqhHic +O7SefclG9g2WV+v19RUcFZISi1IVEopTS0Iyc1PzS0sSFDJSgSKZxQolGakKeYklmWWpCmmleckl +mfl5OgrlGZnJGQppidmpCiVADUXFCin5eeolCkWpBTmJyal6CiEZqZVAMaBAIlAh2IyCXIWCxOTs +xPRU9WKoLj0uBYXpxWmMIvxFCrYK6Tn5SYk5IRmZxXqbA69aynAjCUwu+K66ef3Hg6zIgpsLvtew +oKnS3Cz65yQziqp7/2vYkQW2R7EznvNEEdEIZGR1RhHRncJ4mxFFhGMa4y5HAFNZdAnmA4B1eJxb +spG9ayP7hjpeYRW//JRUPdeiovwi58ScnKTE5OzNs3jztrCV5mXn5ZdP/nhcuNno0HajQ4xFYgBL +FRYJ/hIJ4ZhwtQzG6+RTJ28Ga9c0TdoIP3icO8B2gE3N0MDAzMREwTmxKD1fryQ/N4fBTonh0cQM +fzV59WfBFhm9D957TNLfqJbGWJ8rGHF6B6/6f57W5mI/2eyTUfflI0wMgEAhJ788tYjh9FuNCxea +bu6XunVV6GINz2ELKSsTqPEFekXFDLv8eYsDqxUCKz8v/HjCcm+gwPfKaIj+gsSi4lSGMzMfHrx2 +YiOzzTmNtLcntq2y5T4wGaYfqMAntQhkitcbse+r0liM/0870qtUqHqg0s5GCaqqKDUxuSQ+OT+3 +IDMntSg+I7+4BKTDKXr92cQTIV4yh2871JqW8RWmX9s9OZzJUkQlPuDCXuNtTtMM9KbcZJ+cZXSm +6OvkJUwdIvtuNnpXS4SmF0Ufut5asIH1vnqLHgCxHXnf9gGeyuvcNdZOdJbuXeOnoKnqyTtccnic +a+1nmt7PtOE2M3txfHFJUWbB5gvMW5sBaPUJlv4BiqfO2N8q9igUrDOXBHnH5r5+r9J4nHvM+Jhx +QqWIkCh/VgxXzmq2Uv9ddheS/39JvdQ0sTcMALJvDRj7U3r51Iwr2tyQ6z2xRfOW5WF7rovMeJyV +VM9LFFEcZ3Zn1t+KrKsuEj1B1KUcOxWtW7GFl4gilQ4dGt/OvM3B2Zlp3ltbNVAwkDpEuNC3kEL2 +YNIpLNhj+QcU2tVLS5eiDnXoEmi9mdWVxV2hB8Mw7/v9fN7n+3nf+T790rX+q+t1qjNoY4eYbIJQ +fYZoCsPObQIbOTEcKg/QdDKpZ5Ss8LbjTapzubUqLrsTaTgCuxMpdJxBfNnpBGJUoczR7Si6ZjPd +MmMXrUxMdTAj0WgpFh0hquVoxDm/sB1f3I4L/PHlt+P++HiX7RBKnCmilB+oYsOA43ViSBzO2A5c +H/V3P1kQ61o1y2RKIm1qBlHYXV0l2QvfQ70VKmGKYakyuWP0E04g84+Im3qiYl37qZQYSdkgGeIB +4PM76RigZ2It9OT8Z+Fh2N+InL1SIugc6k2lGfIw+6WiWShMSW1Lq0GQd4UasG+K9bC+KXbC5rRQ +mx1/KQaKBCA8l4LZ+VWxXS5XlNBN7OgECq987XB111cXcjemZUwVmzn9ERlrGn/BxgchCCvDQtvc +4CAaSZtMTxFkWFijXCLDuok4JXJtJASVjiCUb2NPNFEZujx6qY96Sci2qO5eoFyP9pZXWDVnefV7 +vsbUoaMgBw5zSLm//ZGhxbGcPz+WE79pDZZNTCXhYHXS68Ig/P0kdcPmjK8RTv0Re+D9gFCb12uk +oQfQvOwLnDysKVpVMmytcUIXNnBYV0VYMZxfeixFauaOMIGa2KYTFqtq1H+YU5mKpkVPyhpIua9z ++2RFE5lrl8KsSWJSzmDZjMpJglma/1SlnlRSlkYOZOjJSuDZUtxdvKWuuDnRqG7qDGHDIVibRlQ9 +jU2TaF5rJXWHMuTB5TJwkV3FtiujyA/dy1JHfnQ+sNXUszcuuIzqcmErJbTBz3uC5OfzBAq//WGI +/RDD0HIjgPLdjwKq5N1m06HhFYSWF2LICzaXuwwrH4W+/P1soO3WP3kd69v4A/swBzbCsNFuY1gb +/dSkT4jhRD8+eJwBOADH/9wD3AOQOBRNQFIIZ/hqmS4dqd9uIgpVB3EsoLFMTQEUbbYaUoQFznWh +jOwSIxxCiJS/WxCTrQEvVJsVBvsZAmv8i6Fop8g7d5agzxW8k1QAi2Z4nFWPvUoDQRSFiSIBA2LA +RpDk2mgiuqRSWX9S+AAJSUSslok7mwxuZoaZO0q0sLBXwjyATcBOhRDs0lsK1nbWPoLubojEU57L +/c45w1H66S39Ui6taE+jYtLrCJ+6EDg4Zdje5tKgXDL5m3psAXYl1XDJsC0MgjKcM94CbFNARbgO +hOoQZIKDUNBk3I+vkmhNtTMPkaRpQsBhzE9ghU4E0jQMirB1CDWqTYj7Z4ogdd1JE9etzBmUBu1z +dd2uzS4MvqqLqZmOsfmLXfuRzW5Md6ZwELUxdC9JjBVShCQmFGi3a+qEcYaeXAVF0SiuQfCwCyRA +qiA+MRKyq8mwliHKp37y7PxDyijIcE0CCtdj9k8tZ0/rD/b9MW9zjTv7SXfsdyNjh/WjxBsdZ5al +g+Scen+NRbKsUCze9iuv/Uqqd/8LvK2YgPQHSwrpSMsJZ8HwBXovyrCgMGir8YB4nJu7mHnNEuYN +TvyTJ3DzTF7HxaNWkliUnlqil5JYkqij4FpRUOQCZFlZuXrmFuQXlfimliRqxGtqTk4UFtYr0EvJ +TIkvSCwqTo3PBEvH5wLl4wuK8gtSi0oqNfISc1P1inMyk1M1gFoU+GQ3+/P7HQIAgTIpjPUtWDVX +5yXfjM7JiPmG3fPGTTiqe6Z4nH2Sv2sUQRTHEQ6UE0yUiIVInkUwgUsODAieIogQ7BRivzs7+zY3 +3uy8YWaWy9pc4V8g8yfYCZLIlmJjpSLYWFlb2PkXCM7s5seK4lbDmzef7/f73n59P3j3YXB4sLYY +j8eQlpRXEresM0I/qTXu8nBw8WRTaKsQWnACnGlXGQRHM1QWhAI3xSEcfZElcR8NMJWDQU4mBxco +m6RkDZxUYFXcgdUsvCYF6eLxZOJs0moEKfqDFdhBUcoA5ExBJpmaxWIZhbVkHGHdIkLKDXPYA21s +nXB0lcFxPelCZERyNOw6/K/rZ5tm7fXy+V6Pf7F9tUlvffGL4bGVHWGs62IDFcCAS2YtlFhmaEbB +D5dVLtQe5DE1c2QsoGEWc5gLN22jdM2dtWBrvXW90XPX3ieSJvBIO0Hq7qLavnlvdGJit7cJTVbE +nugmwovWYDuioMk4R2tFJqRwdXwhChGmSMXwdLbi1H5BBuyc37BhR6WuHOabM6zHew9RYRsG0jsp +TNkzFhZaiP3/ZDiS6qcIIXzy/Erz4NOPM3757eDS34n9xdsrl/8J8T/tNb/6/Vxz//PTC/7Vx6UV +YZPwJzlDMikkzZOM8rp5+e3Nzm9HIQDJrwl4nDM0MDAzMVHIzU/RKypmOLpfYl7k9jvZfZMu/4yq +kVp0+thuXkOIirLM4syS+KTMvMSiSpBSoU4b1c9dKidYraWWbd/V1167cPo1FKWpFQVFIIU3GOtW +xX83t26UlLJ2ux12VbFw5nkUhcUluSUgheKM/8KV0wvnn+tofvX3U+rp1LyQZQC2c0ER+g8Kj1LG +DZIiHXFIupvIW0mvJLZz9HicFc4xSgNBFMZxBiWxEBtxBUnxBAttdgux0UIkR8gB1snkTRx2d2aY +eaPmDhbiCNuuNxCEaGPhDdILQmoLsQnYuQsf/Lsf38977+2j9zxabRqLOh87Lgqkethn57E5Xo/T +75O2Gy/3q8/bIx+sLRV6oCsEpSU6hxPQvEIwErhuZ/SsMiEuv5LTLAMZtCBlNBgHouTen4EPY0+K +Aik9BUVwY0I5AXTcY8ty6rj6gtjulpLg0JZcYIWa4u/jTj18YIO1w30bl6PtA5sa2+E+lcgpOPRp +pbSSs7xAtHl3y8enyyQ213v1omCD2PwlcTHvvwrD7rJ/BCFjKvgJQ5DWXQ7tbRfVKSvDAXkFZlpp +px14nLv1jn32B/YNLMucg0rzSjJzUxWKSxKTsxUK8oszSzLz84oVUjKLSzLz0kszizMUkvNzC0pL +UlMUEpOTU4uLFdKK8nMVUvJLoPzpHx8w2k7m3yMilJKfVxKfVJqXkpMaX1KemZzKNWmP2eSdtXzT +z+1j5N1cv2yJqAC6mskXW+SaefZs59nD6GcNAKTyPjTwBQI8ZiGuQl+adG4NIOo3O+gWTPw3eJx7 +eIXt+VW2hi2MOtME8wtS8+KTihKTs1NL4nPyk60mMxqKTJ6QLbddZxojNzNu+elA+fDtfTMZLwsA +APW8HiT7Aa//FwynRWXlZabh3xXKFlj2bIOXeJybxDiJcUKdyNdQ4az++ufNa3jjVKatzfdU0K25 +BQCatAth/Smyik+bVk6tvSnU8BBCJVxbfuI5WnicAZ0CYv2nK6crkBYUtixgqxlTHO9t12S0ZSO9 +bX+u2MaRKj8UN/5Y2VDASAz1BVZTNd+31UfsfoKxfRACFCaYaGa1BnRMADvtlEnNz1Aobb62s6EC +uwEUkDA19PkwbInF5YQjITi1YYb/S5izcAS9AhTo1evnq5MbEHeeD4FkD1lw8YZ7x7NBB9IBFNab +J0Z+CO56lNScazOJNuRT14nKkycJShROn+MgiKWJlwEkVs0tK7363PJTfrOFCWMBFE9KQWJ42S7b +15Eqgo7qKFgJSFpUk/wKGRSZEQ7rTSbQxGnFpJylteYJTuImlZNeCxgdQ2FjaGUucnMAVv/l49xt +651jGFYNGeYHIX6GAm+TXgshFBZXlArjamPKPjJr1CQsoZ4KtcTvk5MLdBQSJWSvlNR6+6McFDVU +zDb/0BCKrrMbDLkBO7HB6B9XjuM8148rejByMRZkJpoJMTAwNjQ0IFZtSGFuZGxlLnJzALBtxKdI +UB4Zy0/ZYkSeir/gqBLysw8OuwETgRg00PfwgF+xThC1KP2Lf5J2kpPdDxg3reMScoijMTfCyzRE +983fquXJ9+Q0MDAwMCBiaW5kaW5ncwC3b6Cb/o+VDliGOL3TiqfBoSP4AZMsEMEUsoY17+kL3YkD +5gvsvsrXV8bAvyyTARG/FPONKql3bQqXL5jMUPStZ6P6cH6Ps9QRKAE2H/tMq5CSDcWJ0LEtusrK +IdC1ZHY0MDAwMCBtb2R1bGVzALfPGrKDGF9bkYtV7GC2GcOIUTtCkzITaRTEDzSHIRMju9/4NnmI +3jZ32/btD7OvE7gBQID3UMl/lL3HXoWpTjGSYEl8H0vxMTAwNjQ0IHdlYmNvcmVfdHlwZXMucnMA +8zqa1W351Dlfl6af4D2dxQdLqyH0wS7j8CVIdUDAoTSJJrEgEaU7xHHHPhNEuXice3+CecUp5g3q +UfXBJUWZeelhmanlNurxdjpcClBQkFiSYaWghku6OL+0KDkVj4LszLwUK4Wk0rz4xOISKyvP3IL8 +ohJvoCBEiaaCrp2CV3HQZPs8tslVUQ1sIPUKtpMDtUSUQUy9nMSk1BwNTU1ruIk5qSUKRanFpTkl +QHV80cqTMyv4JhtG6wvpKKiBtGjCVdZuTowWSHEHu7MgJ7MkvrA0tagS6Jr8/ByI9SmVeYm5mcnx +mWBnIcsAbcjPKUtNic9OheqYnL9/u0RmGpoehWqw8slyB3SNXSAyED8iXKGQmlOcqgDUiWwmkj7u +IKi4a3Hu5G+2cpPVDmjII7QjBTbCE5v9DvQwiegolBSVpuoopCUCbYBSm28damCaPGW/3OTyY1aT +v++PndwsK7Q59Ph17ljUOKJyJG9OuMwvCACVRbtJ+xJxl6/aDRihaE+PopQPJBdYaJF75Hic+7yQ +feES9g0dEZPPJ7JaFyWWpFpZJRYVJVbGJ5WmpaUWWVk5gnhOYI5jTk5+cmJJZn6eb34KUGFQaV5J +Zm6qf3leasrkCbGamxdH/Gah1KDNE2ILWKY/yGRksUmmzD2qm8WTas7YKgBBIlyllQJJpk430GVU +3r5ej9FlEQB2f3QS+54BEZ5SJCYfml6IJrCwkfWsMnylYzF4nIVVW28bRRRWWm6yKgTqJSqt4DRF +6W5Z201oi7tJnKShN9QG1DSqRKl2x+uxPe16xuzMJkSkWIVHXpAGIXiCP0DVKs8VAokfwHNp4ZV/ +wZm9eO2khJVsr+dc55zvfOf+t2NPvx97eH+6v8qbNAK/EXNQVCrfgYk1Zt4mgPAmTCzcwfdqOxQN +EsoJiKgU4RoFJaARs1AxDl3RjEMqK6XjtxgPGae3S724AS0OJGREekGrbdlQrqMB9zJ7LzOWl1x3 +qdWGz0uAz/MUhuXmieh6hPl5Ji2vJSLP5Cpd/WTs8CEmz8f8Bv4faJtHP3nJKTnJ0b3SvZL+Z/oT +/d3MUYuTLnWSmEQq171BojbFX3ThDGdub3115tjeRrVaHarSCQlSYX3KmCFgFtAjwV3SphKsvHzO +9trhAdq7RljNdGxoCn5CQSBirvQvs+P6oXtc/1l7fMSSKoJjc9DYYVPST08eLS2aBF23Q6R+NFPd +Zw9uvLmpH5wZ3/rj3O9j+odzB/TfMz/11zsUmwG9MG5jvyKq4gjTDgRXlCsJ60x1RKxAcKxHKxJd +UB0KrNsTkcKL+mqjR30gSkWsESsKIiqZatBQ0kSzxUIK9DN0JpngFbieBfA9ji59WDQFIrmf9Y5A +u1AQg7uIkqZMnPSI6kCEX3iqOoQnh3mKWJpYL4y/UDUuvEEmLnzYUxhydtJ0MRARdd0VlPF23SkZ +yGk295a+OTe+L+nw1STmjCZzZV2tV/qDmnWJCjow6ruC3fUwB25tDs42IXXhuqZKnkxCWZOFjRJe +rFo1BI09BFnzrIgutUZOoI+f3N9FLOGo1LRyIL5JZHcX8TLpsV3E54mkZ0/vUOgXGu8TReIo3M1H +zGVnF/nKpyHC838VLnQbtNmkTaNY/g/Ny6obOiOebJir69fnD9YTQDk7C5uiyahlwBrVWUYr4+K+ +tX9f2ut0JrVfPvSygc5a19JeebykIsJlD3sRJSKRoEuad63rl/SPFw7pb6xX3hnu2vYamRzygw+k +g7YHX83AnmWnjzkH9M92Sf9lvagf2KX+TJJsmlimWoDH0A7CCjuMoyPisAlmuIApYBxJ2L8jBfcr +A/UitOCBiYiGOfJd1ygHRW3SYG8UZaukkSw7o0t9u3b4un8FGZko2ryWEP0SCTrUEOBdupFSX0Ir +ZRn3eiGjzYJXzP7ACWJR7h2W6Rpe7hSO88k+Ulfno8R0KTOwcksXhgb6Ag8EImYlZAHSU+rJhbiW +rJT47OmsViFVQI0qjiTMgYWSdEwHXitMelNnG0zheMJsfxambGze8/WyKZ4ZrKX1DZNvQrgdzxCm +JyltWkNhcgzOzsK0cZwn4wwKUmls4OKS5iKWPW50pnAfmWVpBch81DY7U/82b71mTd6Ka7cdSH6Q +SvT5hff0FwtfHt6pL7iXgOrX+QN7sSP62bxdxyS9AR97uCPNqpO4oqiFKnYlpbVNGBx7huwMAxu5 +vlU7shpS3kZCFi3w8ci02xfcwMgvrMA6lQDANwvAtx1cDFCeAtYCLgr1KM5WJDMb7uTl9Hw5d3I1 +CWTijnQ9pfGkx+zd6azH6YgM3bg/iXZDrDs6Nym6inwRkRGFxZWlK1cckCLZMKs3LpZrYBoD2ZUZ +qoWZND/iaRWKMUtYx+Jv564d8DC6uXl+YlBEZMCYpcem91/DS7iuija8BCuFFkbAvCsxX49ID1tl +laeKXX5v8OaZGS1PZWO5Nbb48Z43R3Gwvef660XYerb0eM+/GlAtFv1JpH2i+pk7/IFS2Q2m5mI0 +MTlc+SF4nI1UTWsTQRimqBiCoCBICgXfUAi7uNkcvNgt7UFTQaVRGtDjZrJ5Jxm7u5POztoWG4MH +b3qaiz9D8OJ/8OSfEW86s9Nk80HBuczOvF/P+7zP7I/PG5++bnz706StVgvejIgEApSwGAcgMONx +LhlPgVPoZWOMGGUoekAFT6AnkKIQ5ixHgp9mfhX0Gud9oClEAonEMOGDPMYw5TKkPE8H6q33QFVu +tdTJZkP99GAq8UzCHnQxpkFAE+kUSWZrXtNbup5VXr6NhK4YBE/MdiAEF0FwWJTvcPnUFF92Z8mY +i4oMj5mxqI87d/0YJSTZUOPp52lIMqkz6OP7pbgEJRkQSQJVv7OlPlyrqd8Pb6ve1nVvjjYo4x+T +/nlXCpYOg0Bss9RpmI49UPXtrWkBYYYAVpbucCHPfzQ0cZfPBcgygyDpEENz6XR4ih70pzPTkTEF +Qedl58ADg28lk++3kZI81q4D++G4c4fJ7vzTTtGO3hnGvE9iDxqaUW8+Mhs3qZpNfWlUvv9t7tTU +q/bmTaeYn6tY+/49m2K5Waeqxl59ukByw/QWcaGhW4ot6lmpKx1YpsUoQoEnOdM26HMee1UXmvvw +vPuaxDlejtzoYWFGWhfJlMhotJJhQSBS6OC9fXhWRL3QQZpd61VSSkmcrXm1z1OSsMh6XXJq6jvl +GzCdEcuihlIafMnDXNJHjlvyXN65NteRec3v8BCzjJhhX/FANcu/3FrJsp/FLEJnQRDzCmuWNTnb +Yft5eirIONSEoW7cuUCj5QuwAvElOcYQzyIcm1+NUxhvuG51Uv0HRl9w9PM+yvtPAoG/es0E2luk +CWMPFk3XpHV4nKVSTWsUQRAlQRE3J79iPIhlwLgxuxMI5DLiYRNnQ8zGhN2sipehd7pmtslsz9Af +uwlBchS8ROhT0EMungwoLN79BfoXxJv/wpoYIwGRgHXrqupX772qV99HP/0Y/Xh3Ynd2dhaeoNIi +kzA/50MTDRMS4kxtgs6sihDyTAtDdV0BIWNUCjlI1kN6KyuN6FFLahP6pVBnqS16gUkOuRJ9ZhCY +1iKRPZQG0myASsjEK0UEaMBVJ26MzA2XJqJHSyKG2yj7YZ8p34+RGaswjFOW+P5C+3FYD2ob7WYQ +1hu1pfDhcqu20AjC1lq7uRiEq7X1lu8naMrTJfdc33RfDq4HpGwt5aigwKgSJyKgBGqwmhSYLgLH +mNnUwCZue6Q8QYmqIEw1oaDHcu252sqMu9W+4J51rro398bc/sYll/Ox4YvoWqVNIxYzGVnyhMTF +IkWIFDH/7QClC6OAxBqkt5BacITaer1VAewjdUUq0xq4UBiZrKDnuQ+Dal0bQongaXN5Iwgba4sr +PnSsDE2X4DkZ6Pur1uAWPPhr2vclDsrT9wuoSooGwoESBsPEMsXpzx9YL82izV956i+5kZdXhm/3 +3l2kw4AVxPyUT12mu0DMOqRTZ4BbQhsaenwoVTKsSoKpyk+81lb1RR+9EhwHbfksS97995Y9KweK +5WGmyjFLNU7DzsmEIo6RdVhQRuXZnNNiy53Js1zSZGHE6O74MNj/fDlYJVWxQjyRxBTSYq0+siGT +6TYMurTJ4lyArpsat/JURMJQhYujNu7mD+80TzEsYmrqPy/eNfTM+SNY9/Vg3L1un3Pf3k8O9w53 +zv0EjVBVO/8zYzci0EEhffhb38Zj6bzjwUD2gbt4nHVSTWsTQRimtlBMBUMaoY1UXtKKCcSUIhSy +bSy1eKkWtamgIGwmm9lkkt2ZZWa2abVQT/4A37NFvAhFsLLisUWRnrzozYOCh/4C/4Cz6VegOIdl +391nn/f52J97/Qd7/TuV5CaYMzkJ81CtE02sKjxcvgtMARcaCLjMoxAQ3SwA4XVgGhzCoUbBE7xB +JeimGUkXAbXQdaksJmJG5oIKqMNcZp4oTaRWdofpZq6W7a7J5uFZF4gfL45GleTfq6O+qIcetfV6 +QC1Y6g4r5r6QwA+f0tHy9I8+BHtgsyVqIDpcmdVG5S2xBsTzhEM0ExxCrpkHVUkV1bYrpB0I4VVn +upuOjDKt4H5XrpBSdGIeCrV1TRXEAkWowQ+1oeON+JVfPPnYoxrEhQ6ndVvTNQ1lwLnSRN8MDpUy +48ZwHEKRKTs2aIfSyx17PDq4u5/Bg+3kiDjhKMBhHgadzSdwZ3cM9/YzQ6eAPD74lUZeevJopRkX +4bRJg4ImDVDUo47xsrBYAcY1lSKYMQCpYuGhoofG4v6uqTgwMHH4REPTgHs94Ws3jd8+j00ZUgsM +wmke77FbSvCiT4LcRtBubIC5FHtawqmp9EhF+DR32pZlLbRUHso38frW+OCC8H3BW/jn6/BZ4G3l +HwHzeG42NWGbAZapEt4qrVdEKB26YiRZi2SVKEeyQBcSLzOX8cWXVNIIPdUB5TImt67g498p3LDO +I2lfiu7NVvpx6fsgZt+mMDk7EL2Ze5/IBmEt50iiaR7+87dFdxbL0/ju1dCwqddE7PYajp4+vzEW +bW9Nzv8DDJMh4/7CB42yP4rHvBzQu2FEdgm2Nrc92PM/eJyVewt4HNWV5lddt/RoyZZkyXpZsssy +lrpjuWUbwqNtyTi2cWD8wjYvG091qbtaKtRd1a6qllCw02a/XVg2w2CniQ9MHhMn+YYFQiCfF3oD +wdghyzq7PJyZkA+GCfGQhDyGAJ5vZxMgNnvOvdUvWSY7+j5b3VX3nnvOuefxn3Ov/uGBzt883vXE +Sxtujt2ke/Fxw4lGxwxPG9fd8VA4ptpJ1Rs31IxjpGw9obpxx8x4ajzrOIblpaZVempaY5Ggij+Z +7GhxJCcQVbOXrjr2/IZlDflnvhHMRdWpcd1TTVd1spaFs+ijrnqG66m2g5/GbXuCVrzRpGcDbkTd +hQwZg6puqYbj4BiPCOhqLOPYccN1Y2rKdD3DMvCNPmG4SJAzMjQ0pFq2x1mntQxnwB28CckkVN1x +9GmXVkmYyaRBYqgpwxrzxpEXx1AtYxKpGfuyeqoslOlqPsvaJOdNw2nOdFQdte3UsV9u+1Uwf+6W +utxOw0MRDYs4HM1aXLJYST4uXdK0THfcEKLhYrd7atqMO7anuxNqwtFNS50yvXHkXr1up2pbXATX +0+MTJIjLv/JZtmWU+UNlaxmjyaKt0Dh/qJXMscd3j9cvCcUd3TPCJINpabalOYZrpyaNqLreSKXW +cAnmJP428KmbaN3Y8uUmvsYZsUHVMZbrmUzKNBIlrepJz3CO/TB5SyBXfFSeMpy2E9mU4caiqp5K +oaz4WXXHSa3IrjqWskf1lGqP3mbEvUG+G4YeH1fR3nDn8J89Zamxz2StyBZOZ5OjZ8ZjZSk5JVcT +ZKI1XPmD+dQveq4p2hOtOOCqYzQxol6LJOPIyChqj9ucapI+0ejituWhEsukaaKWT3/UtW2wJOpN +ZGukbzvrjdlF8uqYOYlSEU0UKm5wxh1DT6W5YRue6RiJiLrTMDgh+LYSWLhJ9zTxJo12E9tbXrfq +RVTdlvFM21pzoxFf8xn79jWJaUu9xtqGq4TCIyMjg/D4Ivm331Rum7sIlaRpu3CjryHGyRoNp0Jp +0PKY1JU37TmLXD1pqElL5RO2C6/RyAQMb50zNkkDF+W3TdXNpJgy9EljBkUauKBV8LvBcFAPiR0k +uHvs5amTdl59e94G17MzLvoAKYpUd+MWdcxGddlWlJxi5t6iV3IzyFoJwykqPv+1D9uHuOcS8QFu +FoNEE03Fp0+Wyk2H+xZuC+iG1Nvtav7GahQnND5YM3QnNZ0//vZdATMJ+gtsPrzzbdYzR91pp42Q +Px5WHpO64bwsdcHZY4G2/PQvmmBbg6Qce+jXRwz4+VOyMhf9FvcKDVBL6J4O+34htUPziwEFvvYk +mwPrt+H8b09KjfClnyrzW5JkalXjz/6EtcPwFmkF7NsiXQ8vbJE2QctWaQR2bpVWwT1bpSh0fU9q +gBN3s0X5R081wINPsrmN6rBg00mEVxeu3yY9V9dBpNHZ0d2StpPWUrad0fS4B9puqfcG10glI9Xv +7IwXCkdwiouENFR2aP/4fnWcnuA03MNQOMw1fyDIfyF9iib7skbWSGhTtjMBz+1GWa++Wdqwm9MX +0zSKWK46oq7g04o/+/erRioi4pEfjmhcKDxz1GIcNm0aqYQYAD1BpfPTF852jGRxcjWDZjptJEwM +Oi4cvkVeCAd3SwOMiELvHtyL5j2o0W27pdYS913w05fZQlBvkdou53LMpkauD2KPj5hFER2were0 +Dh7aLQ2NVo0r81PNLo+QuBSmFcvz10nhMjEVF65IE0ULnzCMTClB5k/u6IKWh+W2vlkoaAnDzWA2 +0nhqdKHlC1J3zydJlv/6H9ubZxNqIPf/JcYNVsqcMGaXBv045doYWLMWxsOshfs2kMCNshKUA8jH +PTNtOOjvrklRE/17GoOzhR5tYqrg0fm6nRUBWewycYixKAnNX5AW5JCHLVl0+FEeGxL4G0UUgYZL +5Eb55ykdtUJYgQ/K2K5HMCOOQSmB0cS43cTk41GaFtGE80zhnebyUZGSsS7ZE0+OhbKWeXt4bxDO +75LqKIrc5chLGlALU4SYcCY0L0XDOPeXaGORGlbXNJvddFzEWirmxu5nLCfUpA5X+YtDHKL7EoTA +jYmkdXRsRzNSrhHaxSdsNpJeNJowkno2heLt5yP3qyH+OyKIkiK9MPr76hJx8SKiO2k/x0N7QWpe +TCz6exfyh4zbqYQrdhz3Nn/0j/NzkYphmp1MYtQ1+IgLvZ1jkGg0nslEozzT4NQNBsIvTJY3oYq2 +2t5foOGjLjeSZW1GIuvIrkJcYyLjzwhUQ2QOn/UNjOPCKYSAfBOJBzXp2Gn6ZjocVwhr4FmIFjQc +NNlY0o3wPUSkiwasWnrG9AeKvJm14pSQI5WBpyRwQ4XE3Pnglaekmjncgvi+o9pKYW0xF8Sxba+Y +oyLIlashSh3nUZISFiE8TUDsUBjmPhJohxcapU54/38rnfDeBGvIZ/6tL6+eZ23ET0S3pkP7fWq4 +Anx5jtST+zNUL4xNVjatZexUCsF0pQtjAEG0xDVJMRj91lbd7KjnYCzhSiYEbBZVj5484KF5e70e +Zn5kjK9fBPfkkIQBIqCvlxauqFZkqJ9UM+ibokZ2VjIzAbDzZ99vq0shtqZ0Cv/896w7F6qwYRRi +HYHQjO4g2DNSMVUoH3392u3rEQza2QwujsUKh/bckAWstuMTSNWzOYaL27aDKUf3bKfs/7Qq8Vrx +klzzkkrfRKaq8ys9of0Yfor1oJOgNWliKZfGWdlUqsoHkX8jMhYpFTUR10sg5IwR+tfVjJkxiiWB +UCp5MTE95WCYq2Y1YbrclRE3EBP47vIyo2gvCTJYq8gh55wjX77/EZQTYZiRRO7g/e8EOnOYnDTT +jkZ3otjovUXqGjeRCglo6aRJ2LzI47BqXroqGiUfDM22sWF1WcWIGRqml7TWPFqsvAqZCXzjZqkP +Xr43MCfHUUzJeCNYRGDmHqnm4wJr34YWsNwxMrbjYbKIZSerMrKwYuP2eCqbEJFE8D5ALiBK1JKd +9VcZGt+l2QwJzrwqda6c3eK1TzT5LvjmzdJiLuvymYiNQuo4D78+GDPtEvFw4fI90hWXjRQrGL2i +Rh537CliMF2sYIrldYKKl8pqGT4+IrX3XKTuVfv70bxPPiBdApMvB+ZCc1auh+H7pSH4+mNyHZze +rDDYcrcchM/dL30KtIekOhh6LVAL6l9JNXDgvDwXfh5ldfDc/dIy2H4JY9DcxWrh9/dLA7DgM6ye +EaqEqyXMi0h0Mbz+FakJcpcrddB0lzxAubJJLPTEV5WeQvo+6Zf35JbsSfCKJLTezkwPqutTWHAO +qhtEPsTczetHz8li8ConTPWOkmGs49XG8ngKHVXsOm9OkAUO8lZCCSXEdulj0ahJ25Z1jQmRtXLk +rVjVlws7min2slxRrkOkI4AR1vZ+oi+Xx8VYO4i1A1kgrzgppRFlEWaL7sWNvKL8t+dVJmexbGFz +V+DFYG5HVdfgIm0JXq+qe2I3mo6X1VNbdII16PFVOL7YVqisX9E6LhwQRfzn150h6P1soBMOXhVo +KHRdEtjJ+q9BicQORKP6KPqh5ppjlp7izoBhT+NbAO8MBBblytq86MAoLRJWl4+oFKziPE4ReTdj +xLfge6w2jfIG7KDMLnAeurDAfJTt0YNjnKloFPcothpjDeJcGBoI9HQL2FRep2w+BT0UOHk5/PFY +YM4VvuFwh7PU2DpieCfnN+LzS900EZwte0o0c2wL1j0WWLDm4uL9OdHUO+C7r6Abnv7LwOXdFydz +d6cWKHRqctsimANS3bKL+HUVaqMf9HP465zcCzcdkDvh+wflRpAekRYJDz90QI7Cmf8o9wO64Gjh +rz8vq9oKdCRuWLzbwkNNBhNMgjoviCgQ+HNY5max0uHtIXjsZ3K8iyd3gik0l/epxOBhCN0nXQ6B +B1i4h8PGddt2aRitUxjG1qP41yCxDaY7Afs8LK+Pv6TUwNgu+Ur4cIccatmJ+CTulfNHCJrflLs7 +MHTOslQYwm/Krw3oLu60D1b9Phkl76wTxwfbHROxVmKd6xX+8KZ8WOrZ4Y/Y6Q/IiAEhpDKYv3NB +K3z1Trk7/5UHgwTtlcIPzsiDEqx5Sx75xJlw+G25FWrekhcXvvCWzOYu0TG0lXpDZAvEZXSzTc9H +hHHD1e8G1MLD78vXNbTy5xHbCaWcSIp/CRc++kgu1MOtrjy3AXMdpVssa8KwolfqLrypMK8O3jig +NHSLgkojmFpasH9P9sq9I/DcCml+Vzor4BD5jJbEtEXpSx/TTfjxa0orWKYSLNw8l/1E7q2gVGxi +CDVqnq2B/ayyENaekWthcB5b07F4VpoWnLxXQVD9LUTWmdP4SR3CVHF8Hlt+5E+scSA+rpthpC2A +tdCnRg81i3eAbGHasC8otcKhVwONcFU3WyVWnW5ineLZmc+xxfD+6QCDWwdZD/905HcBRVGJEjFw +GcTms/Xw9Sm5HTa04pA1t2Ai4tmIBrdfhPXD35Z7czyvJEUvjNcnLgdtHpWexSpYFfOKjXYzTdgE +v9NgXr+iF2Fgn0AfooZBsarBnMEXEsmbV7PFVyopnUI0vPoxW7hAd3EuV5TQf8XOwMrXA10s4ukT +R2SsMLga3jjI6mv4nP1wcg7rFJ/DsPJ69LDTS5R2May4efUKf8+3qjWtT1M705nWiBexBCkCHi8o +HbyAgYOt7J0vfsyaRrGOR9dC5WE4S6VgxS1Km9Dqwb2srpBqYzHplhg/ScAxpEOCZ/FxQ4RvgjQU +vnnjUIB5jIpm0uRojOo9N6VTn53XLbSY2IIJYxphmg2HD8vdXJDWGYwQdoaTGXwb6WEhGlIH6iMS +gxMxpRba29lcsHvYJXLCdGDdJcy3rI/fVvxP9gg6+svzWZDBz34g1d5W3l1dFd1x/tlClGnEs54+ +muLtfQvTUpIDzOIEiyDwRHF7xbHJFN930Rrl9u6QN/rmQTItbBZd/jJxOLMZVV8SI9/f05Q//l+W +w46HpPmC4xkOwUXh4w++rijzOTd0akDcoBGlqVyGf/pBoBdWNRTFv+9ypnTzpntYNZPqBTx89z8r +fXxfu/x4IBr0vBr2ScP1/0luI2rNPLlERnXXoCqGTLlcl0Sy1pTDex8hD7FOCgu6lEZbcX0b6xC8 +0Gw0sKDvjkgDtrSwPi7SYATHGnEE5ibvWGhFb6uITYjpBlVaHda9qPQHIxiXbY36STM4hPtWs9o6 +rAbVfoyKZDJd8I1DwqqE7uYiYqRKzOcEjr6iLL0K6y0qEU0s2It7GOHhAzlDrSVxrTGL/JM39UKm +V+zdQubzGAdL6h5KEvWyPkQvCHNblV4iFAWNOBV0KM1CEcWIQaapwyN5qacVnricNcJ7V6L6tj+q +1MPPutjKlcmqXZ9d/1UaK7tCAYPs5wMtyEi1Y8GdWUQQ5fhRjuoYXtcSku8s3NrLnpVzomHKN0a9 +Q9Vd18APB0R06xNopS/mx0lX7aM43RdRM1YmjVHBmqCTJIF1sRwTwwWAp430zzJtOoDCOGEhhND8 +M6tij6dHvXgu8eD0pNQLDwywxqWUFQfLtanQBqo8qvaXX8FLHyiLmukTx3F+RoXYQtbWuGYA/d4z +4yMjCOKuD7Ce4U28zbWeotwgQlUXK5cbLJxwoIxh0LtKgU5dPKyOCvmxHgT9TKC73TF4V0C7jTAd +BhSBcuDoWdz32JdxB6jH2FSKHhXGO6eqnAepmbUHhdCUO2BtExuCZ7cqtXtRxsEqoDjq78pQBitK +fcyI3ObaVl/1mAm0+uonFcKKzgIGisEgPLFJ6YUnzmJIQnab4JkTUrCF0KEPU3FxdTgIR125A/ZG +JQxcjaxpg3gZyejeOHXXXMTaayPUFQuTw2vUPdE8RzcJ8Ws8MVT2j3hI4xL2XVpeZrCo20HB/KwM +h7GChIlm1gVNzawu7EOSEf9sib5VC01ep25F2L9vUO4sdC1mp2pk3IDCmQG2MAiRs3JbK1ZiqWQJ +fHLe4fHVbBnMuYm1wZb17ApYeZb1wktRNg+0IKbUx9ezubVJHf0f9YeFdRfpb1H+aw82wB8ybE7h +a2vZFxm8+13WuN2yMZ+4UwQvCDHg10wqO4bYPJ7SzbRbnUipODR5Mx8lscYwM/pzMROJIJWgswnE +3b9Rapq4ksuny3D9APvDfO4aetrQqO9la2I+aJ8OdMOHHygr4dWnpXlQv4r912ausY2OE+Jxj+IV +RRSMdHXw01Vs6YVUqDYRnyLGvlQI/tTGlsITbwSC8NyHSgO8CFIjjy+EFYFdyvbAuZqaOsVCOmG4 +878j2qC3hfsvZVukWuSboEbh15exj6SL8MKjW8MVTGZNMwaUyRWzT2HLava8zFesFUxWDiIu54hz +Pb8MEC8pCML2gBSE4X7cazSPhsLqDUyX6czhzU3sJAfw9SUAX3j8s+yB9tlRPTTruPUHNfZ/JPin +p6WGerHRLr7O6WxhUWK460NMC4FPY/h/6d7A3MKvdHbPZfnlj9bD0JdY51rT3YIYU5zY9oX3lupx +dC3DsdS+9X2qOI9M4zA/kha7Wwi14OgAKm7zMpRt8OFA/cDMg0iatZ8G0hZqWS95ZSjNcf89KMCK +W2Q2UuxVOKjFDL9OEMPhWEi7HEPxZlTGxtAuDNqkqM5rHl5lg/olNvBZ06Vj7Y00djsN/URBysWw +xunOKk1n8ZStUmwcIXr2cwT+8S/CwBBIXU2Vt2LU4WG48+HAopZQP4lOGZQkD4fD+cWPzueK32i6 +O0R9Lq7CcOY/ke/ZyvnqE8HZRpQWvBoZEwHO3ZYUa158OSp5xJEMB1GizKIDOtj7vtIM2x5kdfP8 +Vfxh1K+EtQ+yzk7+lPec/Qzu81MYPcK8AGj3srrSOf3VJ1jtqso7H36/rvhzsTsNh34UuAQeSUud +hT88wF6ra7iJHz/w41bQXw10RmKEDXC0lzIi6rVJgRgoH8Z1i2698I4ABxI8/K4syG3NhMOxtsk6 +lujFwe9Pyh1NJI1omQp3InzQLwwiqoqWTTKNxTrylaUrHu6aAa1Ysvf+lRyB7b8J7AhSguOHlgnY +Z0ldbfRZ0wl3+FgOgR2cfgrh59ctuf7IbwMt8/lJgm0ZBMX2I6JJm66xP99yrhVO3IfJ8ztflBvg +9/8SaIN932JLMaI8sQvLgCvvkhp30GIUu4pnRPw44epi06N8sBuN7rIzm2l10t9GinTR6FYxibpf +BAt8plt+iwtVJ+38l5+YA0/0Kh3DtB6uZRAUv+AY0Jg04why/FtRCRFp3JDYbszR8HdfYVcFQkGQ +bmIqbP+evGbzHUK9B/wtK04t3kS71aLFouodlfIduINzcKCvyn7Q4Y6e6lyxy28HIjH/ZEClE2Ks +G6m5S1agT+nT5fIa9p3FEsl8Rp4HJ/4xoM7jzSuDICU/eHG9BLz8jNwlrYZn3g6sWFx8VXnk4wd/ +8aJw/ChbK8HqB1k9RI7gJgcewHB887fwvw/+JRCBQ28FOki7QXj6jcC8/FcebE+VaM44J+a+zq2n +iP0qrTNEFwLQrHRnzF0c6rvjAGKbcmuR2+m+LOop5Mc/hFMYlErrNzJaFLZ/M7CgYD3EFs2H958J +sC4Da6WY6GeaVrnTvCcGXzjOFtbH9oYEouFfV4bLzVi72AEp3a+aeY0qisqHpv/BlubG9Ul+NsHr +4YorfhYvp8m9/ZuJnA/eGam6S4Dhl/jUqu5bhQj8qiK++wOi6gX3rgjj9VRA4+o7W4SNt32HLVwa +qXpc3uqqx3DvMdbZFMlkEYH6K4ZXw52y0lo49H0GEuSOs1SuOJXOq+jYkneJKm62ifMar3SNjd9b +xKLWUhP2lCVuFlbdtSOVThgZr/qwsOo6XbGRRqH8thcQMlHwbawcAb89zn7eiQXIYneWmAwnnmPb +4eBjUh286UkNcPBRubGw9ARbJYN2JqBUUeJh6tB7kgK3Ps/64dx7bC4cHFCaIP1OoK7w4POsW+qg +QuciyyyYd+EVNHj3OazxcfnGP3uRTf1RoCufOceOjCEDz/5P1kSi1izlOamo0FKkWi8eXJvA0Ldt +60Y4+2N5EZx6jrXmT011HDnBmoXIx1vkYOHffsjOSaLAmmEipXRWs6XqDXXejMpShHKUbxfkTNWD +S50IhFHJlO55Buy7V2pjNDy/8tmOwr++wJrqmmdqTiSON/6BheFPSake6n/CBuA3++UlBekVtlrJ +zXZ7M46e6PmtNmFySVu02YoX7kRLEy1SH0X3pXyKnlflcvxOog+ONE6kHJTEiljahvrh0eMsCOfz +rHsON0qsianx0w/W66xre3XlS+8i1WaBVYB4XL1/F91A/VSgfU3SdFyPx3zVtfSMO257vqwCrkTU +zbrH4UAqRcHI9fxrRukI1p5PS5fBoSWM5fwXJZAzS34jO/RxlaaNGd4OMeUa/2JJMdGtXV0VxmcQ +jhAf/tBB9bqdN+qpLK7SfMPWDRuvuXbrxg2Dav+eveG1sPhvpNaySc+tVgk8fp/cubpCH6JHq0+F +/sxl0iKT+cMPzodn75HaC6t/wq5jPcXGO2eVbyu/o/Q5DMohOMMwaYy+zl6Lb7KLh81+/4VGqTSq +8jQSN9Gh/EmAK6LGEugEHm/V8BsRhjUZ2bU7xn1CmGDC5uZJp9a2zXH+ep8VEoSOyXbjChfHsLPz +DYsS0vz8CqiHw6+xTaAelmvgsV6le9QPx+tUqh/Va9ff4Gd8d1Dld+L6okOGFx9K2bhVRA0za9rQ +/ZNXd9r1DLrI+rnSpe0Kq17su2nD6+yK/A/Ot4ruorpKYjXlN5fKo3190Hw7gqDTbYEGeOUoqy2s ++0e2Ig3N/1dicOBfA+2g9spKYXKTsvb2jcjrVoP6b+okGQumxwkzo8azKDQmWItqfHJa22cfaykO +8Ogmg2NnDMczDTcCJ38tzT/yqLIdtp9QEEI+pgyVmYPck8qn6AUizifxv6kTygL41ZNKC6iNrJde +fEZ8fe9KrJqKBLqQ3AIYeVSZB9+8V+q4TNwU5qdfBADS1KinZp2PwQU8QEsZNQQ+IHgGQ6fRtv7b +U8qCQH8/vIO/mzTj9jjmN9xNJ21aOhzeL8+H0y8F6uDEf1AW9CRG9tA575RavdzeNc5IX+HwCSV3 +Ze4v+LVLvdj8U9NYQ5KizATXTsy2/CO7WOlKuUCEpjWOeah0fxCDIceRfCyqUwSnoH/1YFuRys44 +annNgD5SzGu/rK3pyU3pF9zRL18gEJvH+8SEzNzyAZ3fSFT3lMEcnX2igFhqHAgGsdJK8bUuurwI +1zKmlvzaJ9vzJ59ugxiTl+ydhaHJdGTmXxJE/N0KoZDGjI7XhVwjAaRKbcez61lH58wBfk4czK87 +2tZBnKsbHLrNh/mnxD7UNtR8esMFbGBFF/IR8IxX4epbRJFqHoZm8lAEQzOfCyoHCnUfKANSLoRL +8BBLMcHNoALo5oamU+GBma/0lAol4cn8xk6Zq2LmpyBwAS1+x2Y2csUiOP+/9gfh+MdKGyz7UFne +F6rggiN3XFUEcXFQjAD87g+Vhd1iSV6UFSf4LWtY9pHSAzXnla5cedBkusw9mddkusg1hpi+SXFf +JMorrT6CmTb/m5oENWj6ik+t8lKlKX3+FVwaN5OKlaucQGrpi5QYosviFcoYnlXlXHmlb2SwRjrj +TVewTn/sQsCFn8R5Bjq6jcUFj5Kj2ZyJQdwS15Yr7jKWHN/fPwz+/MguTg3k5f5fvPCzWzubom5B +POu4dMDrUKU6Q4QZu83lKD7LiYclmyVpSm3ZCmkqB4RCs8lLb6qtgEywJDEdHJWmhfqLa+Sc8IX3 +9UOzeb64dYevqxfhlxSoI0lAzfDKlJ1SB5D6XZVXIK9N+nEWaeQSsYtYjWjWGyXjGpzNBvUUnahN +l09cqc1WpcwKXaUMi98bXEkvfEOHF0fYnNVlntdWOOoM+yNqF+5n/uT+Vu6bwyjZropj/QGXH0Eb +dN7rV8v7soYzzXtN6Av+OB8HFXIfKQ2BWv8hLH6Ddedff7gRcueVervso5pL4RxNqDq+R6McyeG+ +hctj09zmeQN9mE4ijJJkMwQrt9r8rv3Rc5jvf3gjFjKxXwRaGsvhbTAI378RUz4+ruHsbTmvNPEi +tr8o9icdBhXB74ESI6Kr7ze4hA3P5jIzOSwHKixF4DvnlN4SuzXwu9OIUU7dyFpKbFKb8eha1g7P +rmUL8uo5FixbKez7IcbVq38UYLX+cnD27xU+ilFwpff9DeXxQfjeftYT+ffJC3eeU5bUCN7z/3x3 +BxlMU+HUeeWFQOHJQM0jMvyO1bS042Tjduqz6m7cNOlU0gmtCMPZv0P5YvNZQ78vNL/cie6JgM9M +UI+HNxw1H89Nw/XvokjbbmX1wb6SDmHfGaWDnyf39Ol0P5IC3ZQfGumisjo6TR2BszeyzmBplgYt +b7EOmPhqoBma38XiXaupSfbw+8dG3E4YCbFTpCi/PwUna2pCjbiPpRew8kq2HLbsYPXwwVrW2tBf +ehOG2E5pYT7ycPMl0eiGjes2lDR3oGzG5ETD3B/hVE3NMvj+DjkIp19RauCq2preur47DkSpvQV2 +bU23jIEGftwYmJ8rrRGsIIdEKD7MruZytCpxgcEutPgCQWlgAqOOMNdZXiP5nk+iD72Bmo5PUWP2 +37GftaN9RL0PjrYFWm/9pC3sm4HL+Fkprw0qLDNc6YnbJkK8TYm/UT+FQ7U1z7P/B0pZ2kXxlAGW +X/aubi2J34jJSU3wPbVkoL+FE3icbVV5IJT7Gja2qcZS47NvQ5HsgywjzBiRfUr2hBnDjGW+MWYs +SU4l0iXyiZLtlpCT9TsVZYtShqRVCelwE6XsIcul3Hvqnvv7932f533e9/e8v9/pPMRIAaKqkB9P +MOoN1Fjtw5+v4S3dPzLldiHpMw6rq2toYICx5DCIJFcSCwykh1JZ2jSehNXSspcEgsDbTG7Lcnux +ldz5kc/QIL80wB41OZhOyAnh05zpfyj7nGUZUrdjLSAuQePZfsdbzGRKcQntW+56bDzrnLuFzTPI +WGAY2PNRsPHsH1niLlf6sxLoC4Wxao/4YV1BOgKIPrMVX/EPqR0ZxUc6tQ1U2mpFn9CgeKQE3IpU +4Iv3zt8vJWAWkbgNHLIKLNU5fnQ1ne8vwaRQThCdsaa1LHinMDv6wqcFFBG3R3Whf1gxd/6nNBZI +oUZEaFOYTB7DFK0792ecJuZ7v3iuItWeLxmY6v89k8YjP3ad1zFIJMkOct6X+u6ifbx5fbcdxEDt +AkpqtpMbtY6kV0SHK86qlHuc/t1AGxpEyUMPUY2m3iMfxV4Mt2uKkTMOiTw5XDesQiL/Re/CZtEZ +QWvsRTL2A35+hyR4Wu/KnfeumwKx+xPgu0JEBKCZ2hUQ6nBvZW/XbtQxjLzhp37wNiwlco4f6PVS +lZUHrLl+0h3jJTj6ub0ZqUVQA9oU+PDmC35GQoM8+i/96Rhivm2UxhkfSEhMFihIMZSIq1Ufvjb3 +Jq2bHmMrbV/CD5mKSROZkzWLE5p56HnRLIfMvr6ZbpnRlg2Ve1kskOXC9qeEHGT5U6jfZ9bUp9Fr +/Qyko1uakxxx09VTp8FTcLZYKwKINPbWCXDNogvWeSW/eVeZ5FHYawQzxP9EWDYVdikpqB01C+1l +GyaOidsNqTwW3ChhG8YEWWxHKtvfmRxMpbDX5qGPAic+pL3DsAYyWql58o913HhqoOeS6nC9ZAsC +KNuWcZPZR+iiIoMYcw/suPhXL2QgP2mZNcPleo+g246kPLmEOCtU7+ERU1J/0w2al1aAB6WJCByp +jsg5oTQ8DLQxxhxJOlqtzC7hDRF2LpacwMDvRp8Bq1mmxMY7uVoPlpvq3U9jr/R4wj6ysbxA9rCO +1Wyg8dxIDjqAXef4+zecwij0Sd4JsN13zdGo0tsHG4WJ5B1XtWCfsvaBnBRkADfVTKgUNWrlOxJW +N4C96cjJMO+Hjyr48AKHWbdyMguEuitTLzvfPk+SolKf6kPjGGVADI3WzEUtXNUZvZgYqlsxrDz9 +pQ3eroREALu17F3oMd/wXQ9HZ+rPNbmnpXhyIHNleSDMGp1w9o0UXfc2jfeQyJFb6isVj2FQ2Q1J +J0zGYxQze64ssq2G4utUPpra5epudOwIBnBCqTYsfyZtrWmTk3IDokYJWJuVZt54iYYTzi15mF8S +HUD/gLXxrN9/svAdxae3kEv3jb8SnlTVPAggJo9A2uoSADdoWbi63Hy5hYt81C44OS0QqmAGe6gn +IfAHjOYD72VZV7XGeXaSXIMfJUP8uzboncAAKiEihkHZB4Ih66vWPFcRIXEG5Wmp/KY9O/nkSfuO +s06QoiYBSPDbPWc1kZjIG7WqNq1a9Ruaf6gRZmsa8ir/kPgfAo6eV35Q5JX2p08IgS93CvqSX3gu +wAXaAggACJmbSBtUmaiTx0fneibWDRhyW6BaHcN4rJDgVwm1klxrvvRO0cHrmaOufWE/6XNzXKM9 +G9FpkfuwDppBRfffldw6qe/2bP6XHCIYxqSH+rPpIIPoT6H9WBbtxoaKd2Clsc9KyLSKP4n7pXr4 +5t9Qzr/AaDwrm7ZUKj2yjyf0z4mEHd/mPKfeRPsF9KPh7wXEFXQjrg8cYAtnCW4WiDPO6vKdTIEO +6IYDlT2b5C6L2UZZpQxNAZ5xByHD7CIIgRWDxnS9nTfcvk5QsLsec7BfvRiZWRoVzpS/FXk/nPJL +MReQw6JQ/7sfPo42CZHl2IvPA26Sq3cayRv2FLTCetijCIBT3V11bq/AvhjTwvdkd8rDoomYD3CL +nigC4PvnDvEkOdqhzSeOv1Z6Kdxls3VsC4QxFIe0DZAwwqCVH0hV9eIJP7H5ki52k6etVBtfizj3 +PfTKGANwpN8SI5c0LpGvNnvGIooy562Gb8BCJpr8gPQfsTdkhQ+83lHyuuWWnCUzOVv0HuxgdhcB ++G5KnuV1d+dKTl9xGzny9E4b6nIHpGRhD3hwlGlJ9qDSARDUw0/Tk3zTkPnQfgvJtafDcItGPOfw +chOTYyYzlOK1dBdX17segu5ZmACFHz2TaIQq92d/Vl/opEYVjzYYFUDb8LLAVIN+M11jP3d87oYX +rzHqRYyaSyyExwPAKye5zxVbz0w7fmQICb4kbJVGGVVBNLw34BoY2+ezBxgIuTbXFWcj4kCv7RiH +e/BCCCDdhZZiEDeJQi/vuko9bYo2lUgB4a+EKoTJ3uBG7CeoP+adi1q1q+JxSavtsYsbV0Sjru/l +uu0RD+DZCZKGUHo4qRZ3UXEcl7oQCQ8S8XzAK1TrRMRxKdcydmp/t36HJS7OqwwysDGNDyDnLPU3 +0Mbk8+McKvb5YszH0b9t8DL8mXRfajSbymL4h66xE0lKJ6PrV5bzOmtj1er1DBbTHhf/v1TfiB+f +2rqzWExcU1H4RPXzxWOBitI9pNRkptbPGNX/BdF4voxqD0QdCh6UTbhQkX+/5iiPedh7uMImAwE0 +r1bhjJPHcsvdnDpCbIOzZ/0X8NBBWy5Q1ga1JvtVtOelZzzWyElzG4idx8B6dka8LhLdU/rHOpGL +FKtG3G0TDa7iqZxUA921g4kM4/HtMzXrtisnB7wNC6Mwzts3luGrfwSjqGQKyKLyfOv3U124J1Us +5zZ7+HIeIXGotG8XXO/Qifg3CED4i/8CxRPohBlPF0skYlfWP5RhPB7gHbx4nOtsYFzVwLhhL4uC +cmZeck5pSqqCkmdxfk5iSWqKb35KaU6qc2JyRqpehtLmPSy+1gChCREy+A6hygmuWdNz7b1tGnHX +fpQsU3CIwXicbY4xC0FhFIYzKxOjOsVIdiSJwSBlYPW593C/HOfofudj8BdsBpEfoW4mkz/iJ/gN +6E7Ku729T2/P45x5XjLXU67oNPaBQt8JGcWwz4oxGxpI6AmTY+5emExnnkHRKVSrNuWmQGJCB93h +ANYmWJoFOrCsAhpZBwuSmaEKbCMbRCBeyW4+gEaY/swtoTu8So38t/Z4Y2PhFbKO0NAqaZZ32TZ8 +MsZAJW52PNfr/w1bkBpZ4d/BJbfavvgGOSxYM/4CqyH6BQJU8H33cMtTQV56/gBlj2B4nAEuANH/ +j9ADr9ADsMuJk8IOEgdob2xkZXIpk1ELJ5PwFA2z/4k9EQYsIGZhbHOzO5vUTMyXEvD3T6Cg7BiW +MVXGk/tvIhR19NNC0lI5eJydU0tME0EYzu6QFVvBRLCAxDqtUrpYijzEhIaSYCQ+oPLwdStbdtoO +bGdhd7aRmEiIicaLHjZxYrxwMPGqYrJGEzTxwFFjPJqYcPCgFz151H2ACyZFdJLJP/M/vpn/+2Zu +Pq99tlr7+JWwN6PKaESVDQWdVtUZ3XwipLrRVYo0AqMno7CsYhkOGiSbRUTKKWjcIBSX0KhiFDAZ +wbo+jvIa0ovm94NRXkwtfxXuBVuhPXZS8+3FfnOlrWb5+r7l0L8WscX7oOvGpGhNitznj1G7sq+v +5PZxDs0PaWppCCvo4vhwPO9Z0Tor8I+qWionakiRKC4761uRIG9FguBusLVyvjMNTUnAWYkWzcWn +9YFpFRMkj9pbFn7NNbDZJr4q6TthP/wrmvnpVHOjA5iA0ZZoVndM13F7IYpiio3d4erDGqKGrU7E +B05iPWMoSlyEsZj1IwQmOdbZBeqqZjCRrcuNYEDgui0WBmvcboOqbdDxsy9hEHYzzLEP3WzgEBDN +tduwOeq4nPMSAbhpuFAzELypcaEXnL0YuObmTFANkwIkLnsZqYRSgXUxt0Scbr0IzsO4K3XJf3iZ +De7jBUXNScr53DSaou3pnEEujcTFBMzb5aIIvSOZlQadjPSCkDm6VM+WekG1AMuSYiCzIxY6ms0W +EN30qgcNrFBMtkCvI9rdn+DK5tuayJ6N69s6lc2xw1eG/HtvSEdVr6W436yY2kJU3suO+bVs7gwX +YisH+F2sPwmGhYTH/7sHXLP1MAmSwsIOCZyYRVM4j5HmhTs64IUighqaM5BObUslTHSIqb6eD7GM +7E9E5yEqI+Kw7sTymEgKLNq0QBlpqID1tP3bkZz8X2lMbrWRvUyD9op6NFTQgx07wjdtI0Dij763 +VYH9rOZDdT71v6tc/q33PaCn8AuBSrNI9AKSB4NaBcYYVH4j82rd3RimsYY2VXicOx/7LHYDn7K4 +jkJyfl5xiYJTaV5wSVFmXrqWQnZmXspmPuWD3AD/hQ039IoC2nwuXpSSVjQbI4+5fJe1v4wc3YV4 +nI1XfUwb5xnXfYQY0wAuIRAgyQshxAZjB0jSxg4QSqCQEKAYlqql9c53r/HB+e52d4bQpKN066Yp +UdP0pL7b1FRJN62qKkVJU83ttq6JNm3pWillq1Ltu9U+uu2PqY0qrdE+suc9+8CkrTb/AXfvx/P9 ++z3Pvflj35d/7Ttf4fX0ywqOyeqM/bviqpJhTcKjhiZi07SrvM/b4bI1azRxBlsXX/Re8VQHUULT +FGRhIy2rgiVrakyeUgXF9lVVN9G7vVpaB3m9gpjC8bimjt960n/xoQp/Izl7nV2/YFpSJGJahqxO +xWdlPId0AyflI6gTNSRBSCQcDjdEvQh+4TA6LKsd7UjRBAkbSBXS2NQFMBMJBkaqZiFdMCykJZGV +wkiQJE3dbiIqBU2MDYUcIXIS+XXBSoVMC86a8XvmZCvlb5iEX/fk5MRw7+RkQyCAjjqH6c85bOC0 +NovjOdP8dwaiK9u3Wttgn32sauFWNau0gILl+5+hYmeBis+WtdrSAlELhbLaC2R9uskr+w97c3+3 +YsXEzrOoqaaFj+gG+t+ZAkFbsSrJScZ78ewd32LtHWd5+/lI7W25kyFTfgj77V9GGtagFtQWtUPR +juE0Tov6vF9MCYYgQk2ZwbzckCRYgj+w/OpcDuR9oS9xC8mgfNW2fXLPnhf3/maM/GGRC5G255hq ++6PHG8hfBXg4c9JH0Fc43n5kce3FfSdx1N5zo8Iz3jd2CB07hmzmnxVrB4fH3efIwMToSpruyqjx ++P9X24Hoxad/9kigysRWb0pQVawMyRBBFRu9Wka17MX2xtKMrFod7eCA6Cxd7aq++JOPan1PFTH1 +NjOznqSKmNiBzxDQ5Z9StISgBCEhoFeMi4Jp7XUldvktzRJW3wjYp2Y2ke6DXJE9+hcvKeGY0uxu +D/PBNzhRk+yyd+ptxS4mV7/NbKxMCpD36Gq3TXL3WaaFC6Iddv3b1dmDzzKnthSNYV0zrOy7l5m/ +9S0Iuq7IAENNVeYd7JmZBFhPkTg8sr8vPjI6PjgyHENJRZgykQx5S+sKTmPVMpHfxNiFdwLUiZqB +IxEVQh3XdBpWE0rA1NAMxjoyHK1QgI6W1lYKBS2zzWql51vz511ps4KSwVGU0aFmsZAmn/ewO9uQ +oEruAcE0M2mMkhlFAYt1KhrNpbDqWAjEQWMRIl/wso3ZVzxsS932XMDRrCZLyMioMUuStVgqY0na +nOo/jBO9ju0x8gTDVLY0UegAcqwggtygpBREB2K9kciB2OeoYUgUFCUhiDMB71Fy5jpbmZ4Ynoj1 +7Y+P9oz1HPInpUC0AIVgLa0+oDMhCSBxlSIoOdBpgioaUeo+woahURTJqqhkJBqrvuGR8dhI70GU +1Aykyzo2Q177/LYa++hXfZ2z7TtD7W2hHWFFToRVbIWmcwH0Uy8DAHjXP+pAbGBiPH54LODinHx4 +N1PjyfsZss+Gm+13nywhX7ydryVoieF7esx5VezN7fcbQNiRCPU7X8IjiWksQnzcUATRtDmhSoBn +FUsU+kcfJr52poG8dprZQrQ+xrvO9dyJPTn1Ibvxqfe4StJ6gWsi0QDzZFEu1mTpEFczLZiDFBX+ +PGn0xGJ9Y+PgCOrsRG0U6LlHlyCFjKUt2wLM8inG04IrXB5MDmMsYYl88Aa3ldwIsyWkBgwegHxl +ZuNu7Gix5DOH0rJoAELNGUhRAkNGsFPLQCfiTKueEkwM6EhjSRYsyBNZ/DNXQS5wTM1dumZa43DP +fz/NRIGZMcvQ1Km9E+qMCrq6/LPple3AA7fWpX3gzcqOTxTvcqkWyg5NYWuZcYlezdWTS69ypdn3 +GtmOigUN6mwuh3YLQCUYEpKwKRqybkGZWSlDy0ylkDtYQOWaVCMCbdgIocEkAobI6IAyWTGDXgiY +gS1BVh2JkmxAYbTOGbKFKQ5zrmZMLKFEjmGSPge1jsgcvk1yZQ/7HXvinjLi28veWdmfUUUKiGYk +wraFcxVTfooJlhQunIuwm6tcKyORabO3YPPmSaaDfLOJrSlfcS0fjtYoGyKv/Ii5rciEi6iTXG5i +7wgUSM7DHWLYCw7sp82sUO/3o+zW7Et72WZ7oV/JmKmVrFMO1WhbM7Exi5FmwLBDYUxrz2nHGgw0 +WsbSM1YIjWqKIiRgYXQkNnivyxUr1poQ1jQNq6qpCQWmOCoJ6NQhPYcLUI0oqGhexopE9UJwZQMu +0RHLzDYtseav/BM08J1oNh1KYUEHhhiAfzFouP2aMeZSMqCMfO0FDtXmtnsFGM1ka37VEfLEEYDJ +uy9wInnuOFdHas9xG8kzx7ltRD8Hr9PXmLLS1TJJ/dNcY/b+89zXm8iNJa6Ux2nZsm9WbyGXahlP +kTOdIOLbxawvboIxcMqkdNp2jbtn++Hx/khkWJjB0qhl7HVy0XdExE6P6ELYfST3vcVtJr+/xnlJ +doipC1gpGZBJJQVXDuUxQCexlYtCGVNFTrzO3Vm2vJZDDKl/H5w5fYMtzvre4b7XQh6eZJrs/btr +nnqZrdtgyZaCG+K0rU2bMWecAvH20vUt2TdY/t/8vZC/Q4IlphBlZGegmzYjSKDNT4FpV4LScGbz +kDgn0T6lJWihOEXgdC8oHE3JOL1ABXIC4kEJgXayS/9iayvyg308DqaOgvDeOYmOJF5npgeOkY+Q +U5fYXeQ/jXwx2VfE95Dyboan3WxOGgYOhDpIZGQFskPfTGCbADVkNJNQZJEu+UlbE9tGrrawHg42 +SPxVtpKUbGbKeCqBvNfEh8hb23ieRK5x68hLMnv7ggvVLj8cycfabZPgTUaxVuKfzJ9FTU3IfW7t +ks0BoEdXjj+wepfOZ7O4YBdI340DnCLHPLxnc+EonVMKrjroBW4Ggi/iq+zR09W2vugj++r4Ijv8 +dglZ2sYj74rR5ONtfJj84lGu1n5loNleN5YLQU8HU0c++C7nITdfgmb1xC54evZ9tnsTbOboltJD +0E1svi2SC+1MDeMnH15mdtonDnpKwaSQnC8ZqLKlR7lNrpottBaAQDMGdE5IOKC9NTeq58YgcuYq +V03KU8wGe0CsbnTyXOiw0/qck+B0znvC7GSHeLpmzx3atOBsBtH2ycnt8De8veCjwrlsKgKQWGdO +SAg6uOT/tFP0EwZO5U93Igel8OnWD4OqhLph7HDuy2ZfWrfmIVXdaAeKoNkFZ1nB6hR8/ARQK2oL +wLIjJvrJtLnAcnphTiIdSXNrjg1uWyv81Fk1gOVC5A46XhKtgsyOnuB2Zxc9/G/XMUGSKOW3kslS +fj0HnwrZBzfwNyvWyhIMtdAMfM38Vp5OGOSBZn7G1q6sK3W2QqabvYU/sdXkSjM/WE4ZrW8WNvNT +EbkcAlXjLfwiWRtla8jVMLuBSiDPPMZ4yMt/Z0sDrvX5gmntulVGjsEC0eyZIF9XXHxsDPh8BKbz +7A928TNe+/jPS0nRPr6eHO/my8ihYX5tdmYffx+/fvkgiAe2sWA+SdsX/riRlO8COri+n4+uyCKt +ffyDPgelXhp7KOP5viMyudzBV5Pzu/ly8tM+/uMC3a/18//g1jgXsj88wD/OFMgaGuJTBa+LGa4y ++/oQ/6XK/wLwfJ/c8SWX/lpA1vTJ3i5TP+gHTTiuef66KHicjZHNSgMxEMdpLYKrUotW0YNNXVqS +Uhe9iKwoqLSg+AVtFbwtm+w22KZtNvUDFV+hEPDuxaNY9uo71GfwBfTk2eyqoKDQnIbJf2Z+85+X +TvT5NtrpxnXqgMLe+sZOAa7vl5F8jcxMq+CAN5qEi4sjq3ZiVNc0nTBMne5jPJmCokq9+TVab9aM +M+GoyCsJS1AbInB1BWS3NRtBstdC/uAkHrrxwj9QYbTVJrgkOGXulqrNAWbVyb6jJrncqsPt0qZp +Hu5mwWk9D+wG8wQoMLuBVU2N2iQLBDkXSLvUgHoKGqaDhNEUPJh6TF3TpF7Zcl2CK+Xi4tKB4FAp +9FCC/tIsf0mEBImknHc0+QZiBieizRkIcZQRpvnTCtMU/KJIGd5T7FCRSjsBZ75BEMqHlEaNMHCN +VrRrv5p6H5gNaK22aHyuDFZ/by7v5pJyVZ9SpkVGJiTR50Y/XYK5QIf8kq5F5UIzlvq/R4ACfjTB +meRwheIwrYQyPTbu48zuTn/H83uth1jfd077T6f3iQ/FOcg2/gbj5Rc1qGtph+Rwp9e+lfXBpVa7 +nnicW3+e/fF59g2PVHn9XMNcg+I9/Xw8/VwVJsfriE2uV+fYpJbJiCmzuV79AQuqcHO8zvZ4HcYH +UmiqE6+KTN/rw8i1PdadMWgBABSqJGv/AtUuX0U3juqUpZxPicSuW9iT60cxeJybdoxx8THGDTtt +OX0y81Kd83NKcycfsNXk01HILHYsrsxL1tDUtOaa7G8gupnRTlQVALVqD/7wFMuRs1nCjOuifwat +mmuHE0n+MolCeJxbfIhpwxGmDXqm4mlFibmpesn5uQWZOakpbiCehqaOwmY905mRukn5+TkKmcWe +uQX5RSW+qSWJrnllbvlFIanFJcUaXsHOVlZewf5JWanJJVqa1pN9mqQ3P+iLZQwPs1AoSgWJFisk +KgQU5VdUKpTk5+speAUrlOeX5qQo5KWWpRYpFKemAuUTiksSk7MTFMqLMktKUvOAKhVKMlIVklNz +ctSLFfLL8xSKS/KLEtNT9SabTpjomVgMsVAjH0w5FqVr6tqVVBYAXa1ga6sAdhTYSoiyEKCMQk2N +Aqa2ydcnGOqDpHD5D4tNk283aG42mPiZHwDzcHX++sABW3PRX5GGcFJN/nlKa+PJIs6YSKF4nK1W +S2xUVRiOtYV2KJbQllLawpkK40yd3rZhpGQK9jk0rfZhO22xROjpzJnOpXfund57bqfFYGGjC02E +/BZYmMhWwwIdF2ogKXGjIcHoTl1o3BKJLIwbFP9zH9NpaQUSJ/M6//kf3/3fn98uWL5bcH3/1iW2 +wJmukvruejKtaQqRjS5TjTKDt3k8Kk0xI01jjCCNvOnpH+0Oh/tHh6ZPsxhvIDGdUc76UmlN5wOM +04g6f0zThazhn5RnwuFeRZumisMeaPOczVeJHKgyG9pK9pYHiaN6nComIwldS2WjB154Bl7v2FEz +lOg0ZplOjlp0STZGuS6rM/4AaYe7jfvKSJhMRI+Fww4Zhkt98OuVba2Wys6hKH4J+aHEgBY3FUao +OPln8rAFSZrypGMHblXtz37gCxbD2Z5KeO1Q5WGdGZoyz+K2AcSB3giHZ9niUMJ++K7FYRqbpTNs +rVb4TqraGbRQ26L4nyoGeJsq4Fx3EbzVU15EfD7ihZNSXbWpqshiYxzQYrMGPmkkleaL4I0cAHK4 +Fj6a2N6y3vREUhbsOaERU30UROWjIFggAOdD5YijMLsiXSqub2oifSqh+E4yGm/UEo1cTjHCFljM +5HQa/QbnW6om0etUNTJMN4LoSKKzOVPWmeS4CG/jGsOrjMyTJJNkOiM8iQFFkEShi4KkWpS0rs3o +NEUyqGTalBUuwTPt1dB8pAiW9Bb441CpgNabF1gyq2oZ1fW+CFifGsmh8xtcl+KU00Ab8Vqc6L5B +U1EQks8H/b7arRYVH7slUg0rR4v2uNE87SbUfCpoG0HPVEFH6+AW22/W8U5NSAQh+2drwfZ8OqKE +xu4QTIUKYairBJp7KmClpSw7H2ktdPk6goPPChRvSHVAGithWa/a5T4UW0QI1IUAF/vqoCPTCz81 +huFUxh912GbkeaY+eeYJtRvFvM1D8AUneRUoUtnSpinnDwQsTve1mfnHZp8tuQmUake7nCB+24L3 +qEAe8MC5+pfKLVLAwXyWMJSC3w9WP1HJXNRrKqjJtcf5F35sterqlad/sk1cjAnWvD/Uvb6tov5T +p5wqmcDiGFJHnJKJ6LqmixS29TRgTRmmggbgur9yybYZJDFNNbjQ4nIZaRaTEzLTN7gTqIL5hDmT +6YvoyTxU85oct1HJuQb+KKSyDTAN/K+YssX9X5bAg+MjS+sc4di0w5+Ts8XsVLQpVsBxWAk2bGJR +vMW4O64mMhcnimeFckwouxWJ7iGRaFI2rL849Ij6osZJilHVEuBJXcuQlD0wLF0mlzWVMIHRkODi +zn3w8+g/dc7I7LRaIouLGSWyYLXOJM0N9LBizsiqIQkAg+4UFCcMSX7i7nt1jb7NE8fnBmVtXvoo +fqbxY3kK7re1wo3asnLvqtYAzl0L3/fRZZgea8BuWwjvjU3DBexh9yJ7oHi8GQ53lUP3eAPQy82w +PB6y7r4dP2j9PhjvtX7v1ATh78seSKP8vbFa4HQHfFK/Da5NVG6xitYDVy9UwjcTvXBzdC8EjvfA +Nb1OsJTkUgVufVgFHx8f7XDCvFE+PtmTdgTbnrMZJcOMxZhhwO3nW+G3nopSyaFj+AJAJo+MOed5 +sW5IXMeRlmB6VMNx4y4XdgitHmKpzw1/67ShDFyZHHIQuNxQd6Kt2OlgHpibaBvJU7babUk7WSMX +Jik669SBP/8mmA8Ge41YquDTVCh740ThjllM/xE2Ixvcyh2crJR0mwbXUtZaFSSGRqY4Jr11nBJZ +74xirvHFtBjVlJOkpsRzF2mmc2xzKtbGlB0XKYWBmZLgPj0ID88UwV+zn20XDdzrLo6w0rQbGi55 +4equykIrzX5RwjBRGoSv4lWdTJ13O7pdsqvrJF65I+Y/NkvoCFUUU8MWgppEbWnjy2mT9+AWEuN+ +oLt247bjIhd1FhSKsXPNnSmH9xe2wdcLe8E7VZeNpt7xLDlNYwqtSikqixm3fqWpl5o09IYuxU4b +9YEpgv7Eq6dcbnLTVLhqdZ8ZthYa2RgQpttJbrENb7LkiO15ky3HHtiwlGkusi6yX2R+KCiyIg0r +C6nswzM3S9Ycx7Zk335X2vMvLRk8OXy2W05t+gdo9tzvQgsJrekUBOHo8Hic+67ySnnDNubNziwm +fAAnJATO9AKhu63YO9J0E1cgyCMM5YnooW4aYXicm8d1g2tCn2B5ZkmGU05+cnZqSphvSFFiwWRH +Zs3J75m5Ns5oYwEABC4NxvEByJXJJgN0QC5IbN3MkNZHzt1QgoR4nPsd3hWxQVeTJS0xp3izkuZN +JgBCgwa+9ZQBCxyeiPJTtKHW0thG3ZYm5C1vTox4nI1VXWwUVRTOQIpLW2nLbilQaG+p2c7U3W1o +kNrFLtK1BYoCdreFRGJ7d/a2O+zs3GVmtvQHrL9RE170xIxNDE/GxBeD2RDig0ES44OJKQSNBhPU +BxNDgmIMhAcDnvnZrVtLcF52Z8653znnO9859/yFqutfV51rqYFj1b61cZ5m/SqXsyDUbF1zhNHs +3jjcXNtRbKk5HvATfFKcqyRDjSSbNg9NiFaDKPiPBgk3M0yXiMw1wyRzRGdmQddIbszgBV1mkbyp +ixLp6yNBx5GcOkXEkjEcQ7iMa3asEe89GIQTrf71S99df1EqvtZ6c9V8VxcZSsQ7DAyaZkSmcobZ +iRF0JQVNVbQsS7s2PkEocQ8TxXScDMa0CDmUN5WcMot+Q/uTrm+KqVybRBSOZ1yQartujFYmJ0So +lp4nbIqqBWoq2qQT0wtAJ6miOScNdHPLPanTfB4LIAkbdRLfMpiwqrrJelb8T81SLKoRRnVVwc+u +O9agmJh3huaZgz7P0iGiTDgIJjaDKGg1FVV1k6E5FnHAEqZuZ4gHdZY+4oY6wGZ2OcbBgiabCtcG +pplcMGlKZZ2VnqSPaAVVxf65BzCgOJR4jqcLMLtteH45KrrnaJa5MUUn83CMTzFdpTMJO3VRCpGO +aEfIITuS1/mUkmaojXDMpW9k+FlRktxYpXhl3ju9hmCUSZWnqGo19Qr1sHirar8Rjsk8l+PaUMLL +xohMMlNcnqAkkbkyuP3Qgsk7CSvXb116VGgM/ZeXmOjGxnJOakxfMojW5WYhUGuYqAR5TKaG+RR8 +2tL8dGdMXEItlSdK/6pZcpTvDVLnMkIkuHQ1MLy8F0uIuyqqsB+P7Sxj+XglFeJULuRRJ8H4xZaW +ErNtFfglauDLbW/AQHsvzLaPQvROQ/H7dr1+c2Uqu3H2RlH+DNVgCUeFANzqqVtX4ROCKzu31JXb +jyVJJFrctyNbA7/vbPUHg6RtGSbQKX9tifqYOKFBd8+B7goRiRUNfIA64F7PxnpbEJ5lkOtxCofv +BjrK+ik1M0UNhv/ZHtVkuoYtnMIe7YJfpGartVfw2dpiK2nLWEFbZY4re/M/+7J4YwO8sVBX/Gr3 +ntV+XGxjYzhnND82prMcFi9a158Rmp/M4eSpbK8NiVSEvDk4lDrOZDNU6kk0yjS7eFFnJwqKzhAG +tr/eCZ/3+YqvxnvqYLGpDz4bLsB7bzfVeT5xe3+iDuFgok0IQWMyLIaIZ9PtiTxdXe3Bk+VHbu1u +tfqTQidcHd0BHySCNY62nLoluN/dvsbNEswkWYXkxkb6fWxaMezNCQsjXdbRPqEOvhsJrMbRgj9G +XqhylnlxfPT2JnvLJ3Gf4WAgYeaMveV0RtNhrqlIuMGJxnHtcZ0RHHeD4LZlEXIENylJM0PWlRQz +nJ3P1TTuYzLhqQtvCBwzMo59HMd17vikOfqetBGcFUplmRmSwXU7Zo6W7pEyAnd3r6qkdKrPRGC7 +tfndY2vhNK8XEtDwYjPy8ed0I3zDH4G70+vwtx3OLPiKyfwXAvx1YpMvwUzUnBQCfnMT8Mwa6PrY +B+rmYPG4fsMXMTOK4bY1HMuNKcZh1JpmJuxK0zh93lImUdJf0KJRuDe3ocjnerfCb2fXNy7z7iOm +XmDw0fs/tJZvcFuNBs5Fjumu7x4VpQ/v3Glbbd+7dKodXpl9vLU0ZCu7S3DxdMgnq3hT2UPz/Ev+ +4pmF26mqgwOjA8PFN/9e9WAhw4f3GyMPk6+RZ7IygXeg89m6sk3YYi1uFBrOVwu9+wdXgF7S+8Og +s2zG+SBBw7Um6+VBodYaHxCesC4P4oUidrfDJ/EAbLlW65oi+4THYOu366yz+AY//eqHcz/6rJ/x +5cJbQ0K44R/grzvu/AiKb8IBUl0S8vyFey1EBQ6kW3g1S3icWxSwOHBDkHS9AhDo6yv45CempBYp +ZKdWFiskJ+YBcVFRpUJhaSqQLC5NS8usSC22VkhJTc5PSU1RCA3yKVZIzEtRSCwuzkzPA4qkZeak +5iXmpgKFi1IVChJLMor1uEBmJ+Xn58BlPYt981NKc1K9UysVbBVKikpTNwdIX+IBAHjNMUn2Fyro +uwDwAFFLOQocJce0bE4Cr8S5eJw71cb8oY15QwObZGpFSWpRnoKSs5JCUn5+jkJmsVNpXkhqccnm +OjYrwcn54lycIVEuqTmpJakpm6+IOxhN/uDNxgETmSwoJbJ5sxevEobo5JJMH6Cg+eZHuT+F65Fs +KcvPTFEA2hEfH+YbH18EtCm/KBVkYUhmbmpUfl6qBkiFlkJSaV6Yr6Y1F5e+vkICkKNQAlSToJCe +n1qskJSYnK1Qkq9QkpGqUAXUopBZolBcklgEtFuhPLMkw0pBJSRKRyG/SCE0xFkhM00AqDKxBOi3 +PHWgwtQSvcmK4sKcMOdqTF7YLzOZv5KDPzNNQUMRHgKakw+0aU7eO5mfJTWnOHXy/hztyfzLOPG7 +HejQzccanwpM3tsmzI4cSH6T/+gDAAdChzX8Fg18vfWE66XBgnTc1DYpJLeogu5TeJyb3MZ8tZN5 +w6Yy8dz8lNKcVI/8/Oxip9LMnJLMPOfE5IzUyQll2pt3lslxSoHlg1LTUouKUovcivJz3TJzUvMS +c1M1Jl+rN2TXUUhLzClO3czWoMWi4xXsm1igpQCkwLrcixILMqyssFsxWTBOuT4pPz9HIbkoNbEk +VZOrmksBCDLTFDQgIgpqagqKufE4XKgJVg0COJXoFaeWaKTn5Ccl5vgnZaUml+jaleVqaOoolGRk +FusAnTl5dhGPEKaCySuL1NSKUktKi/LwGJ4ONFxzs3bLUiYJXK7YfLAtyAYAUxyDSPYGlxuOB1t6 +cM22g+SwjT83DR05dOZ4nGtKmpC8YT2HtG9igZZCbn5KaU6qR35+drFTaWZOSWaec2JyxuQFUmIi +Sfn5OQrJRamJJakKtgolRaWpmtabF3OUsEt7BQP12inkxmPqnqwpoLRZXOC1AgCTFCT3+f8BKdug +cRLP6c+LB/hNk/bNRK8x+Xt4nKVXXXAT1xWea0uykWPAtiz/yWFt/KMFWVhlCFTGdmUThjhxbJCx +CKE1a+kabbraFbsrNU5iPJ48lWQcyBmytM0QyGSYBDqEdtuqpAUMvKSTyUwe0s6kkMQtTh86bdPO +9KWFdHrvrmwptiRIsi/7c/7P+c65Z68sWD570Xrs3PGeh3526UPLmselCB6UIgkB75Kk7yv6tLUH +TSsqp/JhZiDY7/cPBINSQg7jfsK4gYllWEOcEsuQ3Abz6GAbk4x5mD1YkYQkjpj0NkYx7qz9WTtD +Li6hSsz4pIoVpjtN8pq3sTBR5Z1WZU5UJrA8IoVGdgZVmRcPudmujGxCFlZIkm/eAnKjOKxK8vYE +L6rbxtQeJsKpnEmhT14uHsdixG045fUqcU7c5mazTcZlKclHsEzsGpGG8HhAUXBsXJiEY3+v2UEM ++v0xKYndVB/rMbnM+Idk/hAvug2WvXsecxNXWcJBb6YFGasJWWTgky+88IN4dXGXfUr/je2Iax0l +jkuSQMxjBctJPMyp0R1Y4GO8imVF37q+FTnz0Ha3nO2E5xYccPe7q5hH8STxfAKr4SiJDof5CR7L +A0GmN/1NCzUhpojxa8ecyAOvc37ovFSv9bYiK2w9Vwtde18sJirg87eqXaZAbqNwd+9m+O0rdrj7 +hiFdBQdGhdYCAh5mghMU7GHaIBCqgka/Xf/b6H57WZaPII4NUuPaNR+qc6wIgaQQrh0MOIdz6jeE +2p9S+kgSMSe6CznP6j5uW0nHUEJVSKUZNYoZZVIMR2VJlBJKGvodUYJ9Jk4EPZQD4tGGEqOGmzbB +C9E2/dfRdyu0o+WoyuFnTLQvXhRGcOBXm+ExqQJivSXaH8tRK5zh+uCDZIU1yQkJrA8987uql6+z +jmBYimPmcAInsPHoTsZYeOn6IHwyuw+ePnkQ/vBRE8ztWqUvvCSU2Ew7cORye30uQRNjcPz6LOCT +NdB7I2KUaOBqSMc/2lXs6EuIY2NRTskaA244Ljn1N1/9FG3hJxh3hrKT5s/Q7PfL+CnSVP2SOCHw +YdV9SJDGOWFonH4E75uuIg8D20+yA6qcwCy7lIo01p+d6rIb36h+4oHfzys7SOcMyX1ED+2SpRqH +1Amzl+Ff/nr490+faJgyRc2vzAQvYCJAi8l0Q+Dlqmkz4gKNQ3uB4q5ryYWV1rxkCsqqEuLVqLuZ +2vBv2tQ8prBsVl2zptFSdyvx7ctVpUuwaIuOKl4Z5QQ+4maZtjamyfzycCyuTmrrHkTOQQNhRCsl +UNvBSUXFMRqEO0vZokLKTNjIAGvvbWeZprQ3oqTulBJiBCq2OAJfypKh/st66JU3WbSG8JqvFh7/ +T6nW2ozcZVnq4PKp39d78glPwb75X+qPnFbQcF+CF1ReNNHEjJtvpheZlObCGhNdfM2HspZcIB5P +iKODbCZfMHcmuNQ5W19/v6Qx31BSqFXY/YhDbzynoIZCI/joeZsFdcLs23UbvwaUS6fS4cOnnznh +yDsN37jfLEatZgL1MDuzGga7Szd+vYy6CmVUu2BFHBRfbGzIV3c6lv+ZdGjftqEeXbpYU/4VptRP +rlSQKdUAzwcq4MPzVSDe2EInlj5wda7ovtX83Bh0P3z+Abj1UYNR8Ts31pUUKiUcPd+vh957umC9 +DaYH3vevznPswu6WOhi5edZF3TC6MD2lljBAj7KRJvTEngim205kJ+mk4aV2JFlPC6TJwUW5zKzK +02ltbcbp3Xs/g2uZ7ez5pR13oo1DbIGxs9wzIm3AXpXSO9cy7RQLcaW6M3dEU5klKztHRKO2vRnV +7yPPWYvYBibJy2qCE7Kt50lIL9O2TCPjz9gA78e1+tpbVkttPgzr1fP7UemiPWj67+2lF23eihzw +4zPV4L1Tq5/4s4DgyiulsHfBqYnlyGWhy7F2qhT5Xfk35mRM8zmRo4hlYfcz1bp9wW37CptDySLU +D3/cCxe/sGizCPlOvIYYrXwNcsIHf7HCBV85OC67tMZK5OrLLKimRzSty44SY2XFopKQcVDlBSEg +8Em8C8vEVbqdQNMlFob/sRZsTzbC/pkO/eG/3lxzj/To3jsjiG5v+ht3kyXL6GNv+1Cn9j0Lupyn +mbQ6K+qv9Kwoo3bAit7z5iubhywXOWROO1CN1mNDM9Sd1J9s6EmLdsGBvlVKy0J7A67ddp+4iuz3 +LlmqowylLJVptGcZSpWvRZ4i50oCyTUL5e98R5t3oNWpX1SiqyiX+KsO9D8jXTAz15667UQSgq6b +ZfnSM1eHmjW1Fg0/WGAMk2UJDq6v1xZq0a17KDuctxVSvnpUaa8YCI5SJDBLENI+X4/6pml83kNY +XRwS5J/RiG1DhpH8a3Rn3khrcko6/gwcs7tzIHg/Sxz9aeNFqD24uSX3/p92iyxXI+RY1Lpa0Piq +jPNnW1Ag7wnGTHVp8zXIpdlaUSxL6LlW9FCeHKYutqJ3S7Q1Lah5tZGTMPnpkGlW4Ex7d1M+F7O5 +mrQ5H9qcOt+BUsVaWQdq/Aba1o45tBc8yKOd8qHT/wdubp22+RA0LsMNDsz/l30HI28NMYs2KkYt +iHic+6x1RmeDDyuTocFkX1YbILW5i3UCY70CEPjmp5TmpHqnVuoo6OsrhGSkKiQn5uXnZSYn5ihk +p1Yq5CZWKqRkpqWlFimkFeXnKpQAVRQklmQo5IPEUlMUSvIV8vN88hNT9LgUoCCgKLU4tagsNQCo +ziU1JzM3syS1qFgHLF9rzQWmS1JzN6uyO7AqQoST8vNzFAqw6pucyvOVsKrNUbwprNL4FOwQ2s0E +AEmuWIL2AY03NO5dZ1bVcxVFjZqtVpdyMIwSeJybHtQbtKFViam6dnKP0g4gtdlb+QwrAGsqCP/5 +P2M1u60lgVd6LhznLqLLPMffbI2TeJyVUk1rE1EUpU2LtimCINS2FF9aijMyMzKh3UwkYFMFK+kH +akVRwsvMTfJ0Mm948ya2pKlQ8Re8hW4V3Adm4UJw504FEREU6Q9wo0t3zkeapNWC3t19736cc+75 ++mn40d5w+006eJsO0PQKtWCjeI36zIQ1RhvEAmYYJgPMQRK/duZGFv1KBZinIPFMGU97ceV1TBwu +2src+gOGXResNeoRTqgjy7nRURRGMrdA6y6xcfRTwGYNDOOKBQ4nfAuZUd7Nmoi6UZWnifru1PFu +8np3unTUqKvEsQzjsu+Y0aPSnVAhNji4vk/H6v24jFq+CXG/tYQ5VlCzJX5sTAyillhS1ROOb9su +Zx0Owr01E7xTn6bE9x11/jCAXFwTBakgKaajEe9iCKYBkiwnE+7q0qRWBb7KknaQqjYtY3u1fA9M +Ll7omeIBIXpYzS7IHg9gjDK5txhsD1Czm0YL76jL4svCmAB96lSjrpmhdjFaSVbzIY4b4kN2XDzX +54fiak1HD+X+/jgSLrTsAWtAH+0D2BWUWKEQblDQf5DwHZs490PLMFpluC72siNPcGrgtPim31z2 +eLjJLJnY4xf+Zs1zeam3Nrpn/BrKrea9GmaQVBexG3v3WMe74n12clDOCS1bmo2OlXGT3Zc2wfQ5 +LtsgHxYxeJwdS4UzztQO310rb3GIdJWOFKDvRPv+yHS8Zy12uv+QPWgttF/N8hrxEoHVPPFWKC9Q +h8MmJxUCliSj7W0kTn6cCW7/dM7+Y/H5l0MTA5/XfwN7kmFQ5AKDX3ica77Puvce64blXxkVJzd+ +E9384GuVOoQ5+cFXnu3zZRmfBAIAWMISHPUEFyIC6e0fFZysMOw9IbgwUjkOX+R4nJvu8c1jw3Fe +Tq/gsMSc0lSF4smKiiIqIfmeuQX5RSWOJSVFmUmlJanFGl7B7jn5SYk5/klZqcklWjoKk2t4pRi1 +Nh/hDRYDAIc9GHv7Fkk8Wsxb+zUwNU90EkrHBbu+evWzeJx7+Zqx/ynjhnWWm89YyjJt/mojJT3Z +NiJ/89aIe4wyXsH+SVmpySVaCsn5eSWpFSXWXApAkJmmoKE4eVWUGacOTGKzQvQ6xnpHhbJcPaBI +cUliXkmxnou/X0i8M5BwjQjxdIuEqVUvVshIzEvJSVXILFbILClWyC/PU0jPyU9KzNFRKM5XKCrN +U8jMUyjJSCyBaQHyi0tSE1MU8tMUyosSCwoy89KBWkHKEhXyUssV8vNS9bgm14VLSJYkFqWnljhD +9dnCTbCfvCrcUEhHIS0xpzhVU8FKIa80J6egpGjyghi1yf98Oe1RNdbUKKAI6NpBDcpMy0xNgQSL +hqamQjU4RIBgsky8/uTueEkOWJhMviBjMDkjwWeyRxzf5gsJkqIA5OCCL/gCFg+tRJ7pQIfNOHpW +qmiDzHQ9LTB4nHs/m6lrDtOGBWKSOgrFJYnJ2W5FibmpepnFjsWVeclgzuZ5YoHlAEIXD6P38gME +wfv34xdWvP+8iv3C5KHOgALVAnicrVl7cFTXeZ97z+qBEEKClQQixEcIxC4sK14FsYIVQiDzkhAS +L9uN4e7u2d0Ld+9d3XtXDx4Rbgt1x26De1t/cTxN1E6NnaZtYOjMNmlwcPNwp0lsmDKTSWvXpqnH +aWdw+KPOTGcy037n3LsPPUixG/0h3ce53/mev+/3HX3tYsNLf9tw5SfzBxU7vU/XVJ1Z13/wWrPz +cktNxV7DOGPdYEv+6bTz9nO1zruXq3qGdSVrpQ2bjhnmGWZaNK7oVFNsZtKkkdMTVKHDe3uG9pzc +M3CM2iZjYXqAsSy104xaSobVOHcuLw5kTSNj2EpMY5Tpo9SInWZxmxo6ZaPMnKBZFJg0zEzYuX2p +xYld+i4c/A9pwY3I5V1b4faE5FuzhppsJKeaLEF3UN1aF42bDHUYwA2srBJnfYY55C6Ahpekzc6t +n/ichW82Vxe+cv70zsYbb968/Jhz+53K1Y8oC25tJkvhxBR5DK59UW6A9x7IVc6D79VXiO9hx0vy +khvn3sUXvxYVb7z40ZfWv7popbRpS6iGej/7h3sjkR7TVCZ25ZJJZvZomhFXbNXQ+40Ei0SGcrqt +ZtihMZ0l8ouOS6/WhkP/x0dUKb+Fe98kfrjydWl3vj4hKdKS0t7T1rH8CJO+IX1q6YDSr8LqtPSt +h+/w07T05v58zzel3/8cfOFDqTr/Ny3y72yp7svpcb4Gfn5Kbs4fOiwvXZ7/S13eVtGcMRI5jYmk +3ZVTNVvVe5V4mkFWk3fDV9qlCui05SDcPyLPgwcpuQpsW14PBw15IfzIlqvyH1gy00lgNAOtx8kK +uPBv8hI42Sa1wdpWqUkKws778sr8gZ/KsYG1NZaNisbpsG2qeoomVY0dHTo4jB5QxwNxQ7dsivft +NGdqzvmPWwj+hR8Mk8cmQ/xROGkqqQzT7X0J/KUmVWYeV+30QaYkUNpALhNj5rCa0gPBYFfNhZoZ +m5nMMrRRlugX5h5gE96G7uv24vsQnf7cQu3a1PFgzTnhcTVJA62W0DisWnsyWXsiEKTt7dS5oNEA +PVcKS842aBbhARO5IDucs5OdAdQO6F4SglduEv/htDLKsIYZhwRDV+OKhsvjhomKqHpcy3Hb6Fia +6YgR6BzUJ5vVVKwPgQ2uIsVNuXZw+w3SCFf2kooFdiISian2ybhi2duhez1potEA1ymcUGwF/RQS +GoY1pqfsdABv2+HFfeSzzutjVZMFpbuE9Avid0eHi0uaitCFmq5uWy0kWPQMm0CdNPUMK1QwukVB +ZMsU/N2H6NXnRrwLDdYm6Oru1dRCY2wLbXPXcTmuOYe4LarVE0MtcjbjQBsoqCQcXhTMXx10LSgt +2F5yumsd3PtzebHz3MfzJ1GBSMTLPZ5AXKnhCctmmembhC2RAtwtrp+DXQUnDGClrbZogiWVnGbT +PcP9uJ2iiXAnVV3R1LOiIrE4VcViFm0bF87obhsPHy8ISdt21op0dKRQh1wsHDcyHTrKPW2JPx0x +zYh1jG7cEu4Mb+zQ1FiHqqPTUXaHa7nVwaxMh6dt+LTlTH7cDM/3kJpJLysw/03b4hYGME5B2k1X +dK84adEIXYF/yoyaVSslSJhdJ1iI7mV5RRQf8k3hO1sJPXr8SF8kwhMW35Xeey4sVhIv67RiHc5h +A3PrqPCob1axY74618f8y3fl9EhkrrTi2zgN3/XPK24HG/aQxvzNDeSmtIHv6ZoSMwwNu6wSP2P1 +G/Ez+zJZw7SxTFXLvexFSEVVYEOULIe/ukMWw/gm8uMlXGHc++RJ1K6/BJoB+MZvkxULRb3r2KdQ +ECYx3NlGDu72QMBEE/Bxq8kQ6k1s+ufP08I1oshRHRMJKUTikDmQ07QAD9Wwl3s0Av+wjRw9URSP +GqAo4QPb8Fbx52WeLdt1rtXuG2893H9GWgZTUbm2z8zprllDbk651qUwDRXtkOAaiA+eCnhV3CCE +vsyxEE0qmsWCTsO3NtVwV2FmYm3AyGbSDINflH1NQq1CdbmoyBego1aW+AFSC99kcdVc6hfrs2Qw +/xGLRrHeENpYWXiGRWb32PhxDHFklkFlWxUkwtEpbGSztcFsQ22mF8dDtMHy7kFExz6aoF5tsUQK +ATuNXrMEdqtu2p02YuVIr+qWmihhKJa4FHT+eqB5ZcmkPmbH08NxI4vUxWTcjF5DT2pq3IZv3yVL +WkraYo3zFqBjUhlZG8tnw8QS59r71fDjB9i9/3M7WQbDvaTJWXJ/ARzaTJZtFUVbbJgjOYaomHD7 +s2ufKB2B2aJk0R089vnEZvIh2YdGe1QKuWguhabwVsZUbHDcYIx/2uDMzsqyuKhoGmNIWBnmtc0X +cbRIYO9LOCO9jc61Z30NhXIbdMUFUvCLmxJ16vf54EAnqYUvd5IlUP8d4oN5X8JaxWdhGJwi1W0z +lEc9p5MNzix6pkhzTckWRxlocmUt/BNS5zz9e1X5i51kngR/vIMsls2h/Og2UiNPetE9kmaFvDBp +JoeoklAt5E6pnGqlkZ6jFWgpbwgCExJMUzO8aVo0iYBFUTtTZVYpaVCk6zMvL/jKM94IoJqUjbvS +6QnhIBTN7bFE1+L+1DQOvkVpBc2GPJDxQrqjiDrug3Iwhvcj6MEfbiUdddMXQUUn2QRqD1ngRCcq +4WAXWQjHO5EkYNbkf7eLrPBVeZvBa93ked4tiz4NTcPUEIK7xdz7fiXLkQJSO8nnG6YhA2/CcH8n +6VxpFWI3I5plxKsbQj1keT/2tDnTtcwXiTIeVuKA5ZsWOmL+5R5yQq6f2SDy/9NLVlS1e9W8f3gQ +46habI0XsKFpsuFeCCHkyh5MT+N50lQrtMFoDNrmdhi5igRt8Dapg7eHSEvHTMZZcD+fEtxnazzQ +4WPQMfjK04io794mUaA5yQe3H/P5oPIEaW2f1ZnKoW5dNJbTj/UHgvnPniAnJAgz0pb/6hMkLGUw +98R6ZCvIYhITJZfxssVmRseQRFDO0xITmM5ovlLEU8FrPCw7o+oJNwlFRDVDSQi/iwtzXZT/hZ1f +JS3Qdpc0JzguZW2zNMqco672B3Fdn6akIpE9iOg5BPTQrDe7PU0uhIoO67Em9PghM8FdV3jmHL65 +Ak52++rmF5KM95z1SbKz0r127rzXnHQ1XRfNMpNP0F5oscZ1Tp/2ecSrX42bOH9bZ3DYCdFZTyMR +L7WLsRIja8jbNET/8Pt+WHNOasyvPEBerIb/HsYM+PtxmS6anZdwfQiRPDQDtSwjZ8b5fTCfP0Iu +Sj1ijCwxpGLgSo+6aook7aHcZV6RXEAoRVp6Bz4RnSgqNa0srw2RpV1YlqW3BTY9U3JZKu0QxPpY +fyRiwQtp4u88YrgufWj7RrVQWY6W4RSzi8JLrCb+a2E1vBSPYSZix3WhPVDSOsgpTztsPEweb5xB +bz85BeJSnDfeWfypKFDJGYUvymZ7wRoGiyt+BQ3iXp1fWMeHVeyoq4uaVQpA2AEbfkv+TNPcXMi5 +9Y6/itoTWeTC8IFG2uD1A1jzHVNkkdTlfH2g6ZHJTLOfz4OlOYzLdGkMDD5JDsPWqySyUjzswp5r +IyHhE4S4WhdNctF7TNPAyQGum8Qvt+5wTr7a7jxj+btEMWDLjitmYlp+4PY2G7d/hX+cDc8tht+c +QvLEfQJTW8jy5W6NuLDBJ4lpLYFDXiO8dZdUEz4ZtN4lS6NzYdbsWgmVAz/Pv0J+NzxJOp33n/XB +rX2kyvWFflCaDymTNGBjboA/2k0+484utw8RP9AoqZRysHMdKrIzStpqS3JDFAaHSYvsFe16LNrC +8BEMlh1olPfSMsjZAW+My61R8SbHZ94wh2wmSnHat2X4+3APzfvcrB3Ki3xurP9kflvr3Pq7+c6V +swtdt31tC1nEzzvgaj9ZXumaC5uOkQgcGyb+ZhzFZovHoYy7CiaPofN/FpUWcZ/WwVObSGOHR4ln +849ynxU7oglv7yeNzuCzFHqPE+rjn8K9qLS0JLGak1cOQnCPkXVghOUF8NYJqe7FJ0hf34WawmkC +J6S9a9cWzlHcDahujCF35FQGm/cp3sbDvFxO4ZzBodf7GLJXSdNkgY3HFcEmsfmrFk1jjXIP01Ol +KODXVmHbAmXgTAFXWAhrLs2hAQO3xw4fDNP9nB+j7DEsNqQRZRShLB9q506IhTPcB/QpHFQ+ZRo4 +A9fW8PDDy0OuA/MfP0W+7BNEan3Z4UBaSZR1SRdNZ/fOkWUydd77/ALnC7+syb9wivxCgkt95ICz +/nsV8wX4HClC4H44d4fUhAUoPwr4Bc6qqcfhjbuk0V886cBeVBDqPHPb71z7rwpuQuChQkXwxG1J +3ORc4kIzDC6Ubvk4KBaXT8B4XTYTZjGSzBwV53S7S8OOl7pdRRJSU/w4DLe2Ymv4cCtpqcRb3mhq +O0lXdWEjONJJVi1/qFxeKU7d/WUVYj28ECPNdQL9ixvAgwhpgtZ90mLojpF2uBcjfxacFUXumblo +MiBN7s+/GScTxN0i35ciT9dFyrKE517aNHQj53ZX1Go0Ey576u6DkxDHwy4ESrJ4VckVMz8vA1vo +mUSFf5kjH60MTW/xc7oD3mc4+HJkEEgWGsOx4+YYiVa6xQVT/0oCEB0nlf4SLDEMi3sGB9d/hrU2 +cBZ7xfkxshYy42QYzj4h1cOuSULho3Ec+PKE1MOFZbKf5zusmSA1sHOU/MW6R9EuWDhBdgavbQD6 +iiQ0rIeGs+SpIfc8faYjMY7F3EVa2RPn5wPu+WCgNWUq2TQ/QnOv1kWxjWcNRB7sOfzY7nGL/Mbk +zM6FUIV1EvZm7IwyQTXGT94VnSp8eze/qZLk/5MTR+slnYQuAhZjOBIiZtk5U7fCM+UP5mIaH/75 +2faeoiTFLn4pcFQ3qIUjPA5N3sQq/hdojOku3maZLs6BxDk4nHpM9sOPVvnmr/JGkignGTbmKY6s +7hMxi3jMA/lZI8z7IemAP7gkL4N/1khtfbHI56YOGAl/SyEjPeLER9yche7eUeRL8HNOLK68ukaQ +H7ypghunyYrFWTXL+AlsmRYw8n2C4PTs5tIGzvbnqsVHtUy3cqZ3PAcN55GZvLWZzOfvp3/B23Id +XHtdqnRufeCDa1uJb9v/KyPCzsX35sELyAKdb/97lWwkoPU1yb9IDFA4ZovW0YvEPgrKKwgYG2+R +5t5CQL2+qOgGJoY57TwPe5w3+/Io8q7Es0hEUkTQuXO5ce/0ZBrhcOAeGSE08mxA0TSZ03DW0/jB +jhCBO9KEqmR4ogijMN9gJCw3wj+u8tWtfJR08AJxsaLSLutD9F9ISy0uGFUTTHgTJi/Ja0SuzLNF +L8D5Zo4YTotIVd44S0YqnP03g2K4ztdfJPun8i9RX6YBnqS+7nzlRt+quv8FAXPF4PEbfmPeyNo0 +KrxVGWnr4p2LStoOnGd4nG2QTUsCQQCGqcWiokuXwC4TRKnZB3TKsMhV28QPaPXgQbZxnHRrnNlm +ZwrpD3QKc26dDIJuUcylY5fu/onoX0QiZEFe3xee9+W57Rq9B+P50wgiAn0f5FhNEmwxdpbGAjVs +xDysP4xOwMzYppNMmdn9o5RjFeyiky7lzeJhIR86kRQJl9E8vHDrUDB+gIUFee0ScmwyiiTnmKJW +eEfLqc6iAluTlRz0IqA53PIT0iXCpSZEDRyqMkYA4hgKDOJAcInDADHqC3AFOBaS0592DzSd/xTV +fVxeA7GR3WBhvY7F8JggrZD+ioxtqGM6rZ7IrHorBZYydqF6ipHYjfYx0G9RNKAU3SbmSdf3YF+O +uj8Pq15tQrfLd+OqXeZ6phJcnRtxKF5fUd5NVC9cv2xuJySNxUZ5/mvkN+0roJIQT3D9/pqd/wag +yqRF8QLpss3w/VwpA1NFYn0NNfhlD56+A3icO6b2V22DkfAkYSWh4uCMxKJUp8Tk7My89OCS/KLU +yfrC4gDUxAvs+SuBWXu2EMykX0ogmE3ek8rCPyO+VHicbZHPaxNBFMfprrmEioUUi4j6emvFpicP +NsWYhvgjKAopClYJk9mXZuhkJs7MJqYY46+Sk15y2HtzF8HDggfBW6/+BT0LAW9ectC3iUIP7nH2 ++77v+/28r78yXyaZT2MvU1I2NFhxQsqCFG28jWb4+szFz2Nvcnq+4oK7olZ67gyzw+PzS2/HC4Px +wlw8XvBG2eH39mL04p1/eS4Xvc97T3bW16FgQSgwobpVvAIBsgAUc+QK1jG+B1ZqZ6EZWgdKOzDo +GMk5Sjmdcw2kt2chWocBcC0lcie0yqajycBfjn/kvVEq+j3wL0T5G97ZwWHJiw9L/rlry20tAihX +itXqw3vVKtfNlkSHBSnLd7YfSKZs9OqDvxgd5b2l6GPKn+8XteKhMagcJGoh0UArEQJnVEBTujaT +lIRCMQfMICUGqdUuCcuVNYOMN1hNYjYN9LWba9cbyFrZ/6xeWc2le+l0QgeawoldIhIdvfQ379c1 +2dI6ZruKN4xWOrT/AIA2UEPXQZxxSdwTD+HQsAQKDZ5kRPziq33/2NsqnHTraLNHietCMSn2/w5K +q0EhBkk5MbsYSmQWoRYKGdg498b/6fWpoJkecceKfXyamzZ9tH1zY8MiwcPHaPRW16FdSUSrs/+z +mtjUpgtc6lqNtjPihlOwgbCcmQA6hnrQep3UDxXSa4tOLjVnkkLU62iyUW7kX0pNrQe9Az/uHZz6 +Fv4BgaX8//QiBGL1R7a9QdO2QyV1TNgqIwEiKdJ4nIWQvUoDQRSFUSuDpRgshGu3gbjpNyJIIFiI +iImIVRh3r9khszPr3NnEKBgsLQRhH8BXUNLnEQR7Gwt7H8GZXRZsxIEp5ud855z7+bCyeFx5+Qq8 +C6UEdDSj+IDJSKAeDDidoFAs4nJ4rFWIRF6jnT8F9fl3sNic4TWGY4QRYkrAgPhQMgEmZgY4QYrS +CUFJe2XPJtbIIrBs0EhoCLjdcenVBFIOkZGTgdI1sKvVcl+zBCs2oTQg1QQmKhOzCEZcOEMEiRPg +CRuiDz0LQG3JSkSls1DhyIf9KoELWOFD1xcjSNgUmHDP01LITbOIyosuUhmbJMw08TH6hZjMLAoC +lRqubLLds343CPqFQa8scWhdUe9Vncpju9DyS/C2/x91o/hcmP1m+JikgoW47DXmS6fnzS3bo6s0 +GCRDPhzhGLVNK5ARRn7+erORf9zVd/r22dK9Ru224LqR/ZXay9+f1/O3tdX51X3a+QGOacDV/Av8 +FtktX4cgEbD9SZJpkocRr+lNHHicm7qA8eRCxg3izJzJOYnFxQqhQT6bRZkDmAQUgCA0yNO1qCi/ +SMFWwWRzMiuvoSFXeIiblVVwSVFmXrpCbn5KaU6qd2qlW1F+rltmTipQs0Zyfl5xiQJYGZCrtjnX +7BajUGlmXolFfAlUR0hlQepmR4scRumk/PwchYKi1OLUorLUgMSSDJfUnMzczJLUouLJyy3bGHUm +K1iLCcPtAbojrzQnp6CkaLOu1QtRAME1QJvyAkVNYw6mfoctgA4B5K4IJXiwxFMxeJwBIgDd/5DG +AqvGArCJQpNRPxWT31QFk8cHDZN9KgyTsDwHs6hCaGD+hg3p+ANhtkcPun6VRjiI0FJvhtKLqHib +KHicATgAx//4AvgCkPwUSD8C6ZjsVhvCYjYXuNJVqkAR+H+TEAE1FKao1yYKCV6pWo9hejD0GckY +kup0k1kBH8RXF+7/ASB60Jg/5lEHR1tzvz7z1TDf67SveJwBHwDg/+cD5wOQcBSeVDHI9XVBFtzO +MLWZpuyJkOAvKLGEYwHz3Q849RY/3sgvtpgBWyh1cDnLa49IxfF0Dnic29HJ3dbNveESy+QGFnHF +kCBHZ9f4MCMNTQWNnMSqyvjiwpzMklTj+JKixOTU+DKjzUdY+JhASjlgSjefZJsSV6+vrxAc6OMZ +4hrv7+sZEg+WVMjJTCpKLMpMLVYoLsnMyVEoLi0oyC8qUcgvSsnMSyyqVEhJLElMSixOVcgvSC1K +LMnMzyvW41IAgsw0BQ1FH8eoyHioqR6OwfEIx2mCFYFAUWpJaVGe9eaIVAe+yWIHRbgQiibfSJXb +vKa4Wmryq5neAU6hfvFBroGhnkGu8Z5+Ia5Bfo4+8b7+LqE+rhrpOflJiTk6Cp55JalFeYk5wWBP +6ygo5eWnpFpBgkAJyC0oTcrJLM5ILVKKL55ceF1pukMkI89m9b7D3JuPz1rAN3ntXqHJ75fyTf/g +yMjSfHhl++GVjNsPr2T6KgUAMO197v4QUqWJsBtGuNu+mpQ0seSojeT5Ap14nAEOAfH+rXqterBf +EhSGQEXxIGIggjE8HA8pyxnk7FkfSrNzEi4HFJt89KXEzvqZ8sV+kjHCiT9FNlImk7UZTRTljlPH +Epn3dm/qwWPe6Oat+bzptrMWGhsHFCj0liipMQq9f/Pb7jIt1UUkpPhps0UhQgIUdpoUASHeQdXk +9I3+MSnsY+4eS7aTkSQUs68jWgtEz/4Yelj95efzM8DEWWYQyWNWh+gxMDA2NDQgUGVyZm9ybWFu +Y2UuaAA+iKU0WFAST99S2uEUGx8YY9IzgTEwMDY0NCCTzyMVs2IvSwQURK8iViWRg+qt+8XMXR36 +4HzmCNGzwTOrARTBtA1OOPBuOYNMCwvdqEEEyZkGXrOANa0HhU94l/wBDqSw/uV6bAjTcC+a93i0 +SZ3ghCh4nHv2mWfeF56GFsYtTJcYp6u8YjRoP8XItP0UI7OMBQC65wsV/5wBNZtVEYPFvRJ8kLKq +ogMKzuTh76p4nJVVXWwUVRTOYiuw/FjbAgUKnG0D7LTLFkLUZEtbNNGEn7bWYksiMnN39u7usDNz +xzt3tiCQpj74gJqY3MSaSMQmxkgUhNQYeVIfeDXy4gsh4oPxgQQl0UQxBs+9s9sfQBP3YXfnzr3f +Pec73/nOF7cafnqj8dLFLrl8+8BkEOWB+pEHh1hwkFapO04c8SznjMPJJOCn8yWqntIdo4IFAS10 +GC/r9dpjZvEmUaaAKL4Al7EAnBCoF4gTGQgZ+EyUHb8ENvEhpEK4FJwtAoh/wmOc1nGH4l0HaVFk +kqfl1CM/z8ruI9vkm9eW7Spw4vim59icCRJWQpP5Nk1XvQyUXJYnrsnyx6gtMnAstM2qZwzImZG1 +8rOvG9t45JsB9QuIbAoaCjMUNAjThrxzpVVuHWvu6+npgReoiLgfwkSZYh4crHzkg9ptQZmEQPR/ +QGbKjFVAMEBU8OlxIQdub5GHxpqeiAPSeajPNi8SmKpbzMwtVb0cbBtzuIiIO0hsTJVO39uSWCef +H+pryDPmyssH1sz+MvJ2orFI3JDOTo1+uGQSgztU5iwqlcFSeFYOrKpnwQSL3AKGQAvAfAqKRwhJ +FR85LTmYI1dhski4TpWCKo5NXBdTybMqzc4FNVxJK9Rs1TM5LaaNLKa7kK7JmK9siYq0Yehjp5P6 +R9MWIWcKW1GxmKM8LaqQsMTANKXC8fAbX+/rGdax5Ildyc5B7VeHiV+AMUfj2GUsOIjBMvVgwhFl +CDjznJCGiwTFVQC4L0/FBKX+PNww0s+K4CLJ+oAoEwGWTA61P2Np1kLEAJfwEgZV5MSjgPGCIxQa +XlXCpTA+RTANvG+BJuQ7n2zvLPrwL9Kaq72cGuqUNyabpvcsTzTJt86ueDRWqdw33r2k6smp8Rb5 +x9kWufdwalU/7IJTp2rylUeMdrnz5gp547eVsumDtR1V7/7C1OqC3ZTWapGvTLSsGmUeTSv6QwP6 +ZPsj6x/DEBXxpl5E0fe/3ib/Ptcub99braRl0eMOFtYC3V9hvWpIQ4HanHrYznGBbYZAWewTvFC9 +Rkopajiueb2aEArHdetYDh6db9h5yamPiygpBKccBduH6Jzmch71cjlOA5dgJykS5bUDmxszsNPo +lZc/bZMj37fKo1ebW7W/6DTxoC84sYUhH/94XXecevahZTHqOkcZw+leeXGwe6QPaiH0LgrOKUJK +b/7/ppO6uaFWs2Y5cGXV7FNj356ZVHocVxKuq7ZCaaB+FbE6GaKaNAMWiQQzhWNXLGxq9wQEDFtW +65doklUbKUkqADQr9GsFE1tBiJBZ9Ao03tBV72PGg2hNHlCrc9Am0a/lTr52N2a6uPud0NQebqqw +TB2WWaAILaipfT6U50balK9OL12R2ChvHm5YpxHwuKmiis+kjd7k9N1koqNZv4z8Ba/lV9c7J/Ge +AtqWldEtX8IjIUQBKH7nWMJEXBwFcca2zlG57v5RICWsy4JeV1RV8eJC7BTY2LiJ+ZrfUKAwc8hf +GIVKFKg3m0xqKmPMWLMeqVCw6mGB4BGt86fpU1ybRJg4+kxXDcv/tHq1UsPKgeMFLjznD0bYaLCj +H9Dqu914r37GnopcsSdtZB6cxP1wUh4df1J+eX51VypWma5RLFuU8rxyJ8oOjtWUulbOXGuVr/5w +dcMDeLlcbXjLyxfWy0vvL5e/zjRMn1mWaGmoH5zem0wYGx8cChOMV0xVkOnvliXWoIks7UDI9EOu +WDDH69c03y+/+fkr+z5aOrvyx662/aqWFiliaqYSuxW7u14Aq+4xuFqb1Uo5Nb+ab9HYfOQ3pa3y +xT+vb1LEzCPO1WJY9bEhu+6+RvHOp32gx20aCAc1g6ojLqekgN0Xe4i+aMH9PqbLgRNfNybWeLvA +iUEF7lbOGIeHMotQbEWcP4VsUt4519Kg2JLvXUjJ89ZWOeb8Lm/d3Z3olTPFqvw8t2nH4lDTCyqr +zJJrkaBVxn9mN//1bu4fCVh39/IC9NnBRckXSJVH8iTRhHIWpPurWHZ4nLt5nLnxBPOGtkrh8MTi +XCuF4NScNAVbMKVhvLmwMiMLAPDRDP/wCFXeluteCF/Meq9sI6VSu85sugbFeJxr42jjmOAv4nbH +cVtblWZk5QXTWYWXpa3swtPObkxOYnSK8Nw88aWs9+Xz+6c7nX4+m+HQlV0MhgYGZiYmCn75Kam+ ++SmlOVBSL4Mh8Ez+sgn+zY4FdZEHpaf8nxYyJeXOZHYmT5H3H14VrqiX/B3Gcn9xpEHyk1lMzy9u +TmFaxAgA2VA4lPoTvCl3bfxASt585uAZuSKkKeVgOsZ4nFvfw3K4l2WDduxkg1qWyVp2gpNtY50m +309hS/QKDkvMKU1VSE5MzkhVsFVwKs2zsipKLSzNLEp1Bon5p2mk5+QnJeb4J2WlJpfoQFSUpBaX +uGXmpPrmp5TmpLoXJRZkoCjT1FHIK83JKSgp2rw5Vpxxsr847+QPZ9kmH5BSmXw2n32zRLyoq5ZT +qF98kGtgqGeQa7ynX4hrkJ+jT7yvv0uojyuanZMnLFEM0lFQystPSbXKBdupV5SanllcklrkkZ+f +Xaykw6UABUpFpXlBqcX5OWWpYCmge5Xii3XA4j75iSlIgpMj1ypPlt0uI6qUnloC1ZPiVJqZU5IJ +lN68YUl9IgBGmXDJ8wJNqDKZguBgp6PAQRWJIqWwDtggOnic62lhntzCvGGPKLtGclFiSarm5j2i +F9XZS/Pik/OLUjdPsa1oAQDy/w4E+1RyhX3hjyXMazHCtMdriHJI9oyE6XicXVRNaCRVEObpDhtm +15Al2YRxd0xlg7OTdUhyUJAJiwQRPXjw55Af3Ol+3V0z3aan3+S915kd1hgUFgTRg+/QLh4WvHgQ +1JBDQATdq7KgiCB4lDnvHhcR1uo3mWRiH5ruelVfVX311fvqr8Kf/cJ3c6WXayAkcGhGMYJIIIjU +Vg10yDW9ELw0igMIuYJEaFCISd3a14TcQgkyTRRE5o3ScpF3uNROU4r2wcel7LVipByNNzVcB/Oq +N2ukN89WTKP/NLS59kMYHt8qwsijZYrZ+A1WNj96lyZrp86aPFbHh+cn8kxOXq1jM1fNhd1p0+qP +V20Nji/aHWopcDpStCRvUx15sQNnqFTglvm08YrpNp8r2Czm142L5p5fvuZspxHquFclR0x0DVQH +/agZoaxBJRDaUTFX4QLsrmT7PgPzdzBdqQFPAlCCujqmsml5wpvop5p7MS4WzePgBfP4wVnzEr71 +mVt4sgJz5rfq1LKmYB6LBJ0O12G9TtR4aeKoE3uOaA+r+cvck9NnKnn0N/1SibyPe22LII3ROi0U +zd2HM+b7nXPma3TN3cbz1Ks38f/uDPMmx081VjT7wSXzIpYO7rfulEfHun3790mz/8eUWVo9a375 +9vzBO3cqr486fNL/Qp5ZI+lkj3w2twdcbSnohiiRWDlSDDHkS+QaAyItRB4MmRqcX1UguglIVCLe +wRpFRyQWiR0hdY5FsiSErhRJq7i0tATdSIc2POFtXIS1oW4JYC9HkKB4T4EWZKXA7RSVjkjmUS5o +TwS9q6oOkYaWQBJyQn4cYtEaLAAmgTrJMIxdzBPb5PPwNm+i7tmfVQVN2iT3qHQHzc/+FHOz5U22 +MDakPdvYJNOjTXbZ/Ostj8WooZ1qMJcn5rMPG6y8QbldoMn3hsRFtuE00VFsq+gIqnLAY4ciPe5v +LVoBk7ipmJF9ysEJzvGQ6kLz/vqz2Uchu2h+WL9QIvvCyinPXDNwvWg+cK7NHCtfk+aPlVEzjWD6 +HFTygm18theyZwhubPYkzQhqjmh/dg9hnb1ZYKvZPz6b3aPGhBreLJIn4GEsuoNtaXsYBEhmIXSd +RiEx5jrawZMltIM+UkLMezQzm4MGYEfWFHGQbyrPOaMvcGmV8s13azCosJxTOgJi1ULpIKRQlb3X +YFeyqss+nxncI12SZZS06KaR6Gshe9lPLts/fPcG+/KJw9suu/LUf58L2oT+AfoQw02+rAk8sjv6 +Sye8qnG8219oeJybzjidcUKESOHhB/9ecP3al7TzqE1I4U2GD+oxfhNztAHksw6M9ArszHL5NQYX +MlRhgKTmgeKXG9nC23ice72TfcZu9oYtjCd31ZeWpBmaxZfkx5eXpFlocClAAVjYSkErOT+vuESh +1NBMB1UqPic1z0ohszizKhUhAzIivqCkCKgvt7QEQiTHJ2ckFqGpAWqGquMEqSkFGTM9cD+jxrTj +jCzbL+xilFYCAIxXMxjxAh12ZaiZQaeS/BHn6+LUNLnQI94meJxr5Wvl26DDKhJbxHt7y0e2/3xK +h2tszhz238rD6rrZgfUoIwDXuwzP/wH+YHT52ZJidPkWRhDwg3Bp1G+4mHicAR8A4P+aA5oDkF4U +nqLcp5JiqpPGHuMoXXLmfy4lAOOxcigB5IkN1vkDJSjRcvIIuv6Zn+4NYN/oeeW6LON4nAE5AMb/ +sgSyBLAYARQ++/obO3oAAZD0IQ8tUA/lC8noMpMsATsUawyX6Tr6P/YWI8Dlbrkj64IO4BuTewG3 +cTsXNPwsl+Li2yO94NfZ+Ne/4Lvqnyb9frF4nIVRzWsTQRQnJRRZrD0UjKLgaws1yqaJH4ey1UPY +rqCtoZhqkVK2081Lu3R2ZzIfia1IwP9A5+bBv0HcuyB48aQnbx56UxDE/8DJNi1YrL7Tm+H39d57 +973w+mfhzeOR/vSaQC7Keu7KujO91kIRd7HsU5aiCz7juy4sYJtoqlxYJkLFhAYdF4KOhXO9CZjq +BFaZ2EERdAm9z1oITx2wNRDLiev5s64Vc/POZ0nC0nvN/OWApWiKrvMsWx3B4ulerhWiFQvNq9Gp +/vCDC6SMtEKBHR0LDKWyaTzQMt7DA91BnBPAEdPpieDcKrHBvWOD5MjiAGrGxi9kX0bnTv0Z78eZ +Kf/f8WoHbof1d7C5REoz/wvjeYMNvh3/dNPIsVK2738sG9kovVwsZu/pRMHsNc6bX8kHE81MmM+T +58y3dLHvc70sWHt4kGq1Ck2ScBqnWxCnCoWVtg0kcSSYxIilLQm9WG0zrWCjUom4rnDLrxyCN+aB +DGNdloBPMKqLrS60CaXyyGKTRDugGMR2fLWNIEmC0CO7s0d7t0ZSwUJwp/5waSW821gJHjyqL9nz +3LgOt+FarVabN1fZV7PvXjQv3Ekzy52zTaRtzzvOyW7x58XfTlb1/PwBtcY910hZ7yp4CksH0rYC +tpx707V4nNvFvIt5wzJGkZI5ryV65dqfzuw2/rt7XoFFhNXL5wC4IA3Hfntpg6KXq9yrOgaxeIy3 +TyJbdO5NeJxbf5Hx1yHGDQekN39V2uUKADt4B5OvNXicMzQwMDMxUXBOLErP1yvJz81hkIow6+Wa +1nGhdsac5XwZT7g6X++WNISocnEN9nT308tNYTguGVwaPt3vjuhSkYWyBjX81lktX6CKQgOCQ4Jc +HX3jA/yDQlxdGN6kWB21fNh+IfhE48wHugqKca6WFVClyfkpqempeXpFxQzPzxVan9R8oLb+0W0F +9VRO/43fhf7BVeXkpCaXZObnFYNUXjt8TdouqC376fvNi08UFqRX3V6lDFeZW5CZkxpflFpcmlMC +UnxwfumdtZLn1HR/e5pEpP27H2OVxGpiAAQKKZmJ6Xn5xSWZycUMGXU7XSwWTfe3ONpavUNr8/+d +LSoSEFUZmUUM1sdKuXl+fQiya7A+O3MXl+Syt1XToBZm5hbkF5WAnaU1ec/PBxLHE4+ZZhRY5jpn +ft0lkgMxIzMvLbUoNS85lSEs5snhxPrIG13x7ua1vvPPzYz/zQg1KSczCWTK2RvH911RkWa8fUj2 +T6Th3PNXbKzz4CrywF6axvFS5u3eNXGfP7WFptZW63G2CZpDLMrJL08tysxLZxC5IJ+g0Mg+y/vH +xBpu/h2zGW9NnQw1JT+pOLWoLLUIZNL+WxOlnQ/LOqeeuPHov+f7JWaCcx9CTMovKMnMzaxKBAU6 +w6v6V5vdr91bvVxD2vXqC/9/lh+eX4aZVgCPFu25M5oXyVtUxH+Y8jRjHe8aNqH756CqCjILUoGu +TwUpW/y/6eSbBX2nP7uuv17m+sI88DrLaZiyovz0osRckCqZlrYgjtiNb9/wX+2Tfnh8+6+12sUQ +lxWlJgKTQllqfHFyfkFqMcOzWea3J732qHt31+SgdkyTuNzh+c8gKouLExnedvnmxS1RuiXk78b4 +Rt28Y2q5pDhEtqSyIBURMTt/7ExSLr+9lkdKQmTVlT52lqZV/yDqSksyc4oZtnsdyrSXrtT1cTO4 ++fl2ycoHBi1vIPJliTmZKZBwskgWX8Klezyjo+pwgWvyTJuDCi/iAM4aXWr/Ede4AueF9Bln37oo +YdQlVYqDrFF3eJw79Y592wf2DTN21OvrKySk5RcpaFhbayZYKZRnJJYoZBYr5KSmlSjkpymUZKQq +JJTmpaSmZealpiQA+UD5nPzy1KLMvHSFgtKSYoXMPIWCnMTkVJDyxDwgN7MkMzEnsyq1SE8htKC4 +pCg1MVehKDWttDgVqLhEj0sBCbDmJpYkZ0zevUNuusEHRpbJe7+wT449zcGtYGunkJyfV5KZVzr5 +YaIwXFLWtaKgSCOzRFMhM00BrDe1WBHI1ytLzClNnezeqsCFqpMtHmRU9bR0RpnJe3dybF6w4zbb +ZIELQpPnpHFNtpykOJk3V36y12WhyQeucTcnHdiedIDxhRkAwoZqsvgP3PScskcO8RfbcQNbs4LH +XJm/GI14nFvHeo91QoY1S/nJZt77h3kn5sRmZ+rNOO+R9GmOoYGBmYmJQkpmUXxmXlq+XlExw1Lp +D7UdvybtqVPn8jY8tlZAKnJF9MTFhiKnHH8dDmOLzbh6c88bM4GKhTI8e40mvrAwW8VxYUr0htnv +O5rlkxjqnp21ubjzD9TYnMwkkInHY6z61r7arCvpxfk0/uTZp7+7vnZMDmM00czLT0mNz81PKc1J +jU8tKsovAqmW+FTMd8pNLY8t6GbO2692C5d9Ed8xuZnRVuQ9s7z+iaSN26slvebVLxLSvnXbPmjy +FUZ7kdBXs/m9znWYJuoubeGbUfFV/bVv6GR1pnYAjFJsdPNM0YqIu7Xoxw6tkcNB1pvOO6umdjJ4 +nKVTTWsTQRjGXoSAIkR6UJTXlppdjItYKWVjcqkeGhoLVk+hDJPNu8nQ2ZllZjZtLCUHz4KQX6BH +T0J+Qf+Of8Crs5vsNonsRd/LDjvP87xfz/yIv45/jqrT35v3OgE1OJBqDDIEM2QaPr4/qmkQUkWU +s0/Yh85h5y2g1igC9CpgI056EAqIWITEjGMkucj0S3VncpArXmbgNBKN0EsEGRoTZwzt+x3L/mCP +vp8TGgWeo8kzQhMiaoIhaKOYGFgiE328IDIkwZAqRyMPvaKSOvQmtUbNXcqdxomM0GEuNFvwdJXQ +9TwGVNsKba+n9RXWOykwpaylKDBXxcmztUWE6oAxh7urfUSJAS7PUdlRNqH7ItlvwN6r01VQVuAC +ZcvMCd4ADbECjuflC+AoHNcF5Hakl5XptzvVYuC+f2yGqG6Ur5aSLAQDGY9JqGRENGcBOgtZ929k +RM9w3hLJfgVUo2NxBTBPezddCTN5+dNfm48mKhHGDsyK0T4qYFHMme2/N172WKmx5iwnW5ULz1tw +HBsmxevUQlQb3z/KAK1Sh03KLVYwFq5a2W1hZGfdQTczbtORnYpisUm9kS1urS7fn7S1Wy/hH2hd +TrSXpcS2lqKcmd4W1AfzD0nhqYuXPDur3P/8eH+7G4QDQo1RTsQUqwMb2BefPratgHJu3z81bIRw +cth5A2EignT+esudXu8+nH1/uXPrnxVm17tPNv4n/7PZ7b3tjT8e/oAA8wQ/ykN4mJ4gD2C9KqZj +BvMNDEfN9nice6C6WG3DP36zssSczJTEktT4gsTk7MT01Pjk/Ly0zHQrheLUnDQ9HLI6mz/yv2cC +AKjnG1j3Arv0FvNx8uT7bZYyfbqay8pfPWdoeJw7f5jt6WG2DZNZRHLzUxQycwvyi0ric1NLEuPT +c/KTmieybJ/Iwmg3FwBR3Q/m8QG4oQuBVzg2ops/NV9pos+L/INk+nicuxp3M26DpyRLWGZq+WZP +SR4xAER/BlP1CakDkO6nlmUn+TpCy4XzB30TRVMVeJzr7GH/0MO+4d+fIK/i/DwuBSRQo+CaV1JU +6ZJYkmhl5ZlXlpiTmaIRr4lbjV9pTg6y7GaBv1eYuQtKkzSSixJLUjUVtj5h1GeUAVmEy/DtwkyM +3w4DAHirLqD6deSElG4toGIoLq1iwxGJ58kxQ04CeJydVGtsFFUUzpmZ7S70sdOW3W7ft4WYXajb +Up4ClRoEhRisihJ/yDDdududdHfuMjPLQtwEKhFikOcgJzEmEmIiJkoQTJaoCRQ0xhSl1ZqGQqRR +Y0zUiPhDjIl6Z7eVQowmzo/JPc97znfOd7+7FXh5d/DY6I5VTKMkbrIU0XSrn9gJ1SaGmqIWUUla +jfWrfZRkE3oswU206KMxbjWYTRIsqZE+alsFGzNoMdwV6DYay9hqb5IWvKzoTMK/uEFMarHkVqpM +5m5SWFxJm6zPVFNKnJlKjNejuPUo7l1O00gd+nxiLf75PtTj8GLwOC+OzHFOXGtfoMdJCw9LJ6Ix +lkrrSapNJQpHVkbVZJJlrbvTDVwM4vn1ngYnMP6gJ6XasQQ+K0NzMJ3pTeoxxWTMbiNWmsb0uE5N +rJAhiJdN0YtrZAgFSNf95AmWouE4v01xUYq0zcQRr1Dd/ghj/Zn0smUP65pGDZIjPcX+pvRPGv0G +yxpuhvUcKCRLof70qOw9PFrhvD5W1UoN29yupJlu2MVys8zs140+XrZJYzYztzuXxuaW32HDG38I +AScy4ncRCuDJ41KZ03Wt1nnt2lInOL7/vv/OGf7nvs+Mjd9c6Dwz3oq/9AtBv24pSRq3FZaxLV2j +qD4EtZ0FoKPcZHFAFNXQwrlJ9HNk8hBNUnUrtf6Oa1kCIQx/yH8f+6Gy4s60zgNDoYBtZqgL0R3g +4XsSNPviatJybfi5H57GzX6QcKJN9OB8GVZNipUeyZl4U8KcDOuR9IgeZ/PPVdgREYP5CRmuSi1u +mwozCqtAukhxeaYrcZBBHZIRKMFzAViNR3YLjc5bX4Zw+FOQUfld8DRMekZVS9GoSePhSDRjZHkm +hZn4Y0KIoNwk1CFb5ynDI9fFKiR7JTlPg3ByVrHMn3ZI3nXu7hAWn8YxjpXGecS4yt0uzqYC2aJk +Y4JfUyRWwZBVLTK18G3EdmC0wasaVpaaFg7s5ftKNoEHP9kjeEOca5mkHU2rdoKXmVLTfEb8nMPv +10JzsRrXWWIZQ8MtYaE+EHePUT5NhZPYmHK/4ocmf29raxtx5TbCl0hDdakYwm4ByspTTMskaYQj +ysMR2oVGlA+BLJAuHNkihfFUFczyFJxwMCcQlHWJo7RRqimWsHMteLHxJZgtrrZS2HIY7hFJrgsz +1dCKh4bEGtx5FKo5YYRKlH+VfHj5Ip/s8K3FhcB8eh68UILDA1Aavetp+feXJYyiDCvwORFeOfqU +VJr/oApC4FRdCt7eo8/mcjQv5IRqnHhbasDyXVw0Hbe7aWU04Lt1wDvZBeW4/3mYge90wj7s4I3N +MKlt6lQjXfnuBdAj4MEeocqttKSkaEE1L4SKkefd341OqMTuKPj+VzsjrfyBnNcoyCgPCU0FcpTf +fqdc5gyIsKSY/9QBDvk5EeYUxZ5BYZk7pRVFkc9nA3ZUw8pJaxnvb3c1zMPzb/D+Dm6FTjwdhabb +QD3OIIBD38JMvHc558mpGqEGu7u4jk+oRHIJjY/uk0LY0Q21+MNHULrnzCLIn1kkfP0NBhrFTThc +J+a9MWbYdJuNr87mYM9dLZXnj9eLh7+Yr/ZaSq9qUSVjJvmO2RZ3jOt90en6AiLuclrhyPL84E2x +2YvXVY8Px/mC4abfwNeeZEYftWyl8OpHpicqaIrRSlZPajHV1ML42JgwC5sVqQyvLxEX4sRJwYM9 +J2A+7lwkleQ3iFJpOZ5dI1Xke2XpwgHH/9XZ/JVj0oGrfwHq7JyQ8Bt2qdKIxb2DytHLk1UZvCfI +hOpbUXicbY89TsQwEIX7XIJXJlKUbejQIm2FkOgoKJNJMtgGx7ZsJ7sSWuUoXIFDcDCcCLJaiWb+ +NO+bN5/y+/3r5nbOdjs8UYiwBm70zgaucIDhI0KkyAObCGrtxJDsGZ0kIzggSoYjH6FMzyfY1wXU +1DWHoQGZfqmdt4MKfNC6KXGUqpObvB1Nrxn9zO0oHntICpJD9QtxXk3p9gPHvKqqooEKIHSk9YpO +nbHJFSbSqgeFoIRZjUbygmOV8cnZ5G0ij4324sk59tgjt+1biYGHlmdfInCMnLJYc4H9PfKPDMsc +dZ5ujFxgGQCe4+jNhfmcHF5gibFu/yGLuyQ6lymIFfUPJd8evcKIK/05FT++eZFI/B2yjTtrrqVn +6XBAVRVKmCNQM8PMjnicAdwBI/7ODs4OkKQz8jkR5Fk+0dSubJTzajS8/pghR/E0MDAwMCBiYWtl +ALSqs4LbIapJD6v40roYm7/AzRTOkdfDFGoqnFZk3XwaIwXmJKPiqk9KV1ndk64BoRQ+M8qBkxpG +70EoJdnaHvuqlvVnjZNjAlAU9KOPkVXPYiU7Bi1XSptHJPW6S2STxwLIFGUStXcJ+frsJrS4cGQz +vF7njU/Uk9oDG5O+A4MUWc3R74RkJ54ZAs3oNj+1O0n7FiqTVQQ/FLEpz0TyLBSxa3Vi+PGmviM8 +97NYk6gEQRRJZD6HMBeaeVn2OoPohtASWeN9t5P9BJZWUJYIVcSvj7fe4DiJKpopIBdMhc0xMDA2 +NDQgbm9kZS5ycwA6HOVhm7mKmPIaKtt0m7na8vtXTzQwMDAwIG5vZGUADvCnJfGihjoihAhzTGSP +Fg880VyT6QU7FPpx58I27Y3g/qLRcPsMFh1nNEwfkzgGLVqyLqD5er7qY6H1JZFcUpem/b/cdjQw +MDAwIHRlc3RfcnVubmVyAPgzFNPOn4JbO2ucLxbWHMWvUt6bNDAwMDAgdGltZXIAKYpZeoBgjsXW +lQqCHkVinf5vyMqTvwZZFDG95bO6G/IlFG1pqB3aUFYZBM6jkywHIoyo2Cn8Bq1r5/IGsR1N1ehs +3Y8dNp9LYnDbeJwBbACT/7QStBKQxhTWv6SI8/u0lRpGUg6xUrgkRakQlpHaIhTamhtP4mG1F2bK +OBqDLMPFlbOnY7MQAZwBFL3uQrBslbr78ez/eNEhMscDUti4s8ACjgIUsJXO+6gMx+ctW5WnhdH+ +EX3vwSizYgXSA22RNp3zRLO/qXMd17lKe0JKGQhk99OnnxVmeJx9VEFr1EAYBbHF1oOHFosWy6eH +JQvbFPGiKVF2tdVKa0u3RW/T2WSyGczOpDOTbmuV1bMX63gU/AWCshd/QAVvnj15qf/Aq+BMdrO7 +9WAgCflmvve99+aRNx/H/nwe+zSbdGgELR4S8H3YJJIne2TNfHreJtnNqCD9Gvi34XASRq71p05E +WYgkz0RAUIpVjHiEAt5KaUJCFJmnI1MS0IgSUYHSHk4yUnYz1hY4RVw4eeFMuayPjqb0j+eX9Vyy +2VlYWIAd0Zvtit7wHaAMMKSCNwVuQTECcExwCDwCRVsEMJNtIiS0YyIIqJiApQAJPrAlllcKiDaW +0MhooiqQsZAIg25RM9UxsAxbNNlf4cyCYZX3254QYrMozGh30rKtgtVuKdodZJ8EmcINM5lKoEoC +b7M+N3cyYvB/085a17T/Fs71tYf6+pWp8fVUUc402p/Rx8fzwZ3F/CgSogaKfDCvNHYHUP0FF0sk +SOSU+z1FWXCuEGcoV4RaOIgpI4NdNNITX2/MDo7PVRxlKrrplF2Z0MBs1NWHU8EjY06v4cWQkDXD +h4L+sHOEc9YwIMhSAH8QqkbGkFSYhTgxsCiX43n6w6+ZTq1aX0Ib27XVlbtoo7r1AD1eMY97S8vV +7dUtVN9eXl55ciqcVnXjQBE5OnbEdEOwMOKfo+hxc0YoVmDRLhbCC4vqvEWcWsbqSlDW9LwgZ51L +LY1g6u+HF7svk9qc/vZqunvh9Zfx7vl39zeaNuZGMQhzz89jrnZMSMJezfBWRTHmJnB4mPnivO1m +bHLO+Gjk8qDacMuYpqlxX6+dXNK7t6Z18nNCPzu5tnTKplIJrgYCK2LpU88zZAZZzL/kMJqB+Ss4 +5Ure331/8nv3LzO3eRn5AxjJLd2pB6QheV4XUzVoLihK6fHyeJwBOQDG/9IF0gWwSAEUjgyX+Q+/ +H8hLT+k0r1gwMIV6qaOTXAHxFEn6HFh6i176K3yCL2qX4PxiAVVKk2ECccU4GKv5H+3yBu+LGdrI +PK246K6mOUMkQZXceJx9kMFLG0EUxpm1RUwkGDdRvOgDERMqCXoJjI2XXNpLwEt7XCazT10zmVlm +R0POIr0UpCx0j/FPEFJIKfRUesqxiMfeeojQHgShtw6b6MFDD4/3mPe933vzXX8rjL8Xrr7OFiUz +wSmCCCKDEjWgNLo3+DF7SfIMnjTji7llCuYIIVK8jSZTrVaBMymVAcY5hjY9irfAsDZG9kXjASgJ +QXwz9ymrurZHoYFCJOQ9KQzOM7tko9WDwLerA9Oz8o46ZQKUBoO6E0hbc6EiHPzKvnUWU0AlQlM6 +2qmwyAtNsu0+dwf13G/npUADqQDqwDUzSOnk1IfstZTfo7SZfqzBhGgx3n7tU/pqJ9l/Qdz1CV5j +KBjHElfaIkKjKZUnQnidE1MqxwuNpeRL35mPa/nmanouehOrPD5FllJOeevjmKwkP29Jtlzfm7pW ++f9EJv5w4cZ/8/f5zeiJAfGfxeJZzR3WXEI/J/0DkitMIV0dGPRClH4gDxOmnbXkzp9Zfnc8IjYc +GzPD49Gz9pt/dSO6IeYGgiZ4nHt1VOTZYZENZ420kkrz4pPzi1KtrDJzC3Li8/LjS/My8zJLFDWC +S4pSE3MDijLzizJLKjWtN38yTmFkhypvjjVtjzVlBGImIGbeHmvKYnt5+iJJVqHp/AuZuLcf4GDV +kgIAXFQl8fARjYNH6GLDfCNAcqgwfkuIdwvAGFh4nNsp8l1swx3m+uLUEueMxLy81Jyg1DQrhWqF +xKL0YhCdmpeYlJOaYqWQpJeUn5+jl5OfX5yqUKujUFRaXOKXmJtqpaAE1ByfDNEdX5SapqSjUFCU +WZZYkhpcmZuUnwNRgTBeCaidSwEIkvOBIsklQNM3P2MOZkvgSq0oyC8qAYkXlygA9QSXpGTmO+Xk +J2dn5qUr2ALdkJanUQ3UC3NdGthhiXmVOgpJUGVQAYgdRaklpUV5xVCxyQs41RgVJnZrSoJcXAwy +PB6mTUmHq1bTmgsAovVeC/ACaFS1jkjlpyMW5E8oI+vRdmMgpxh4nPvJ+ZNzgzyLiMKtoJjf4op3 +GffzbyjWsu1687Tq12RjlmMA324OXP4XUgZn30Grt7787MYt4JYGt4xiFnd4nFsivUR6goiIaNpt +p69VOXOdytc8/aLILTxh2vT6jRpKjDYvTh84EeonvF795L+Olzt370tQfhFjYgAECskZqcnZ8cn5 +ubmJeSkMp+rdtkxLLl256O/GMJ+wc6t+vrl4ZHIbo4ddvfROMf/FGa8Pvf219802XUEHjqOMUAPy +cwsyc1LhRjAxK182/SCmWfc5vOmzcN6yLSe+75jMwyQlYrG9nnl7b+Ax3sLlGy9eYvRdUaxqsdmK +aSWzyB4F9uBwjf9rFmmWHTNUtqiW2pT+bfN31uMs9of9ptgJKj6XCj/okae1KyX/eaxTo6GBgZmJ +iUJRaV481O4UvaJihvc7VuT/732+g6dl7qEFsRf2Jlytmzb5L9fSuK6XZbXsm10uBuQvrYg8LnDs +7bG7CyFOL0ktLmEQ61+97e43mfm3vXdUlixz1rm88w0D1AqQPMxfICvyHJeestw2qW19qNmqki8l +J7Qkfk3fxLOEEQAYo6tA97cCzrIiiBhWOrUv9OchNywoe9wE0vZ4nI1YW4wbVxnWeJPtxuk2Cbub +bDeEPXYuHif2JEVpVJzdVRLSJkoJSXNpguLEGdvH68mO57hzjuNduou3L0AfIkhGaBBFonkA0YZA +EkfdABIUEC8I0qZSJR6ooH1AQqKihQf6gAT/f87Ynr2h+MGXc/7r91/Hf/tZz71/9dwyu1ZGCbw8 +s+upWIqcolw87Vy2XOZUqCPUwSGb5U2bp6Iz3keRx5vNrgeRxs6dO8mZMhVl6pKL+ZpDBBBeJMKc +oJzAKTHd8RqKICXmEpNUTVE2yDGHEl4rlDu3FcmAt5ywEjFt24iWHOJSs8hzJs/hTY6Vciie6y22 +jLfqd+sboFbe80zGAuI8Z3ZN0DZRUjqGr+nptkKDC9MVPFe3RFnPx42d8YciW0inF0rjjZhet5wi +q/Mk2baN6MvxZrPx5P+VjQTJZHQmGkVU22iSdLpk2ZSnSy6rkBHb4mLsokGevkzdKWJbToMSiwfQ +pohD4Rx+AYugrkH2E2SQElERcViAMvI4hLouczOdK8YtYTEHwhwOp1tzOEHBU6JsOeMyNGa1Sp0i +BKTBRU4amEMDdVSXIdvO1Z46nwrLg7NKTZDnaWHkAJscwfuxsSR5UcJpU0EKzBEACyejkA0CkgPj +yqcgqs+A9EwGc0Gp6FwUM5mCUS/qyZR0syUOX8cm9JbEJBkda4v3fvHhFv/Y97WxZMkEuUUimEyz ++TDjVzKSH3txZsQd82//Udvgs42RaBdo8fe9q/V3AXD+SxsjW/w3Y9o6/+0xrbsxs7ftS55CulPw +JASAYVNHTyoaLAYIHUTOIVy4gCl4w6u2JfRtLUNTJB/POvGwTygaoweC21zwiaA79FFkIFmRdePJ +vf61H2jbe1CU5dSof3231n8kbEu1xsu6VVquwPBXWDG+ZOlajmB60nvO+cz5c7JsDODltlWgGAMk +OW+A1oIp9GRA3BYyEzg/I99B+SJwyOhoAJ3/4LfaodRyAZHB5piwskAkmXf7rce7ZRJE/dhVrc+7 ++fte781PeryvRdc2v9H9haE9BvK3khqlFFiliqzEElALRZXm2LSCiyJ8KXofb0p4e6aGPRK74sVm +h72vNtZ5x2dje6RZRYtPAIspSN3kTkK0WQ1yCgTla5ZdDLqhzZxx6nr7ybbmzdjpzWvkXRptSVeh +ETT/cvDvj3l/OrHB2zI74MVOP+m9fvLZ3oo5mWZAxqtmgXr3z21t/vvkq9Euh6U9+8IZ+elfOIuf +zd9ceCcStZxqTaTFVJV6b38p3vyWea/rsfmKvAdnwRe6onmUrt44lIIMeKFmuRA+CYFD6+QMcyeo +2yzOfnuX98uf9DTSl2qOJdK8ZoEMMnLy1IkxDOBhVoeacWmVudBpRiURqbuSqEh5wbXyAIDNChNQ ++wkH1NNiguhFWjJrNpTquHUZKKmJlY5UEAXo/XWHZLMjMgtRXzY7titFEiXbFAlSdWnJmsTBglF3 +zAp8lZ0LY6Zk4KF3dU5v/ufW9Yj3wZ0N3vEbK7x7zexhko1XWLEG4c7GM2SC0qpkG5dDjbD8JVpQ +WWAzaAbSLMyrBCcBGzFLLuVl7427W/sLZROCybF3KAE8acjIZu7ei0Q7aet91D/QOIHdpZ2oQfuV +2SPbNE0RBp2gSlVLgCqm3CrK8ck4hbtWSlakdUBikGdk/8AaUFmFKQgteR4VdNEpkKXs+ucbIuId +IZseoWqqex8ODTYOHjsqO1GniDBQrEg7YUphkQEdFHfiEi+ySoIAQ6IM3X8qjT9xwiT2XbZketHO +yqDo9l1adIwm4sS3nL7Af8JgsrjSZctbd0h/JIDUe//OYOOoBF+VWAKVJMASOlmFaCVkuBAcJveP +gA01UIkveAPlHs65Ggcl2bgyNxvH9iv9VvKtCuayCk3QEnZn4yAiE5BTm9M6qIIgJZSMhBIJ1HI8 +ykuJuPeBP2x9XjUD2RQgxjjcUGiZsYlQ5kJ+QOoFtDCyT7XDkcKUx3xUfBiaXDsbYb7YtARmQgpg +k1pvMpGu0Apzp9K2VQGTZKl6L033NaBQofRhq6J2RupUdMpt/A2tT+YLtqoUoca4QZ48dMCA3Q4I +iozK3lZCULjKVpeNu2YFt4h2s4QrjiiYtkEOKsRlhYhyg8rxa0JWulBQ0roUJshCUywsDEpRL3Vk +h3BSkCWd4lE7E5hgTxEJNopw5QbkMhwTILSOktJpAVpgQhJuTq2SERIAezP70y3Per/+eMi/2aut +9t/r0lY3cKpixyzCWC2ISWOZmd2Z2xyzF/c4brAqUnLY38LrQ3zh7GwvS4t3pdSAWowWaPZ+9clg +44DsBMFupzKsszKHlj5MDoyKxNDGkQ65Um8BUzU5B+ewylTwUS0cqMyvs5otRx/GD4YyEqjlkZh1 +lOAwoUA25u0huoQsFQhLLoGd3GdysAlIyhCKoCWm2PznytrgcdiaUeJJqFtdqUZxksuAKnNhleAT +VlV/ImmUYNPWpy0xTWLLrC6WSPqvvqcNyh2v0d4YJFpKuMJr3rqnJrSDGKruC/miumwAB8VsLcEk +BlhYSQGNs0YNPFwsjJ1SUTwVDrz/j29qK+Xm2K10+/vf1frmHcxujGztLJF+dVqLzn19hbbjZX/4 +NHjx1hWtJzVvAi/aCCVu6g5w81/o0zZ9+ggynJRnmQy6mENrdXxL+vf/oJ34bGd0z5/vqrfyzsTG +Pi7nr3//R9oWafsKlBOyfNN1qKWfe/Dt6DUtOiTl5QJ5o2H7/P1UG/BneyLdc3evaKWh3rb9gk4K +f11c6z+3sI0t7a+8klnnmgKeDgq2lZFtOpNRzJgRl1g+k4HGx5V85fnudHpRp2w5bRJufRkLZIJi +/0Pfd+/63J6jB0K+S0uX8H0YpOYC3UrqaNjUvf6fv6MNz+34obZa87/yPe1RGd/jodm4tKMhAnR3 +wZP50sEFF0NsoZDibF9ukj9EeBthqaOL7Qvv9/DA+bwakRxqrTWbZRnmGYMm5ag6PICdx66bU7g1 +QnkH/xsEDEb7kQoPuuDEf3BY64sG1/ikc+sVbaCB0LRYVGHp0+gF9An5MEl5TN+OB/iQFCfT8C7c +GlXfSsBF4dl7Kfhb610AffAfyELYNYX75o6jbczlBoJIBwvDQ8C8oSVkdL4N/vtrI5v81YORYX/f +NW2NPzIYWdMFFP71fdrA3PbXtDktioZbnEG9+tdHtH7/nde17WvVATUseFZDgf6nbmiJRnDa3iha +z93BeQiNL2JjnFbGtOBTRsXls7UEsNP4ArpAriKJOSwXCA4Ie1uUcnvzH2yGxgg92/DX3NF6d6TT +LTNaSGYDlbCHAZyhbb6D6Eolan5Ljczs9Z94TVvvr/2utnJu7Ib215VnITn3h3YiGIL4yNPKw3Eq +MGc5xfnGWfDXVUBjdfYh2BdhDYFGCnnMKtA4DP/qj7Whx9q/yfQoifn/fQWUg95u/7anbZy7eFtb +Zf8PXNStJfcBfFr/Ec0Sp4JxhDceG/vTh8IRVXt4nJt2kmnKSaYNbnMnu89VZinOz03dnD9XnR0A +e9AJk/cLzy6bdw8dY968EFX0Z6kuYFX9FKR4nOs4znb8JNuGKbzuifklurmpuflFlbo5mbmZJQk6 +Col5KQrlGYklCsUlQGaxQmaeQlp+kUJmiR6XAhAoRxcklmQo2Coo+YL1+ad55SdNjuWV5IWYE5+f +Fp+Vn7S5lteRmbUgsaikeDKjoKwKmGUNNgHVlKDU4tSissSSzPw8kMLJ65PZWMG8zasEEh5O9nsl +MDnxi+jmbx8nbQQAx1VBO/UdJjrHaFSww6Dn1TmcaerrUqCtPsZ4nIWQu0vDUBTGsSpq6wPEtyKH +ilofDRSHQt3soILt5guE9DbekkBNSnLTFqUodBREOIKDkwhuglhf+B+4Krg4OXWzYlOTQdFURQQH +z3TO953vB+cUTl3X567jjfx6xOsVEro3oSqxCBB5GWxBpCTxpXAQmZNUppN4iAiiJNNAQJF5mpZY +BFKqxKgGTKRQ3pXiVOOcCT3qEVTC6BDEZNAYURn/7aqaJ7kSgIEVncEPdPfdV1GNXKEbd54vseWg +A8ViF86bgIfFZqwq9eKR2YB3RQ5rjX70GX24YAxi1hjBE3u+N9pw0apHf2kaX/fqcbvktvsevCn5 +UbI6ceDFh5uPdSi+nNrsdvSbPTZ7DLfMJZvXhG9mIzZZ3chZg58cyZqpzDgzudX8bc2sLmskRoGm +GVVlcAfdsOaEX/Xp2kdO6DLPh5VlOhfieY2yME0FFZnZOW2KJOlk0JMkcZ0GIKoo8d39GUcrhgqF +4TLi/yhTdZrzPQmOzr+/HAWBpYfGs1fWxZVVcfbwAbSPw6HjAYIieJw7uY17/mbuhhbGLUz9Ztst +LZgEFgMAUmMHRfsBYZXtIMYv6VIZCUf8DxAMueh1Mf94nPvO+J1xwmMRvobidcVFfy+xPJ0XwJQ+ +xefr1ayNALvZDeD8AduccOGBYFp5858s/PCpw9is5A4HeJy7w3SHaYMHo4jw8Z1VhnJXfU9NPFra +urbh0/lJf3MBtNQOTP8LvI6jno7W8BQWICG73tE7gK14ISx4nOvqYH7bxrxBypdRbbOU72M+7rT8 +IoW0nMR0hcy8yQIxCozFkxnDxTe7xzToSisggZzUEoXM4vycxJLM/DwF28kXug0m53XzSbpl5qR6 +wsStrILLEwvcc/KTEnMmx/SqgVSoo6nwTk2FquBCNr9289HOqYy8ICbcmsk+3R2MipOrF0pNftct +tLmpt8MMAL1NQVn3swF/b4ROyGbGOyzKcFicwNEDWz+OInicrVZdbFRFFM69swHaQlta2kLlZ6pl +2610K0QMbFugBCWCGC0EjaFs796dbi/cvbPMzO0PP2n9eTEahawwkaQICdSARkQN+2DU6pM+gY8a +JUEefDD8mGBCIlHPzG63u22JifE+7O69d8433/nOd87sGzfKL/9RPvqa8Zn587AsfcIIbk75sWab +WYKEMPH8JH7KccnTnLqWcKiHD5ViuLYTktrq0pjlrtL3Owet/P2RUhm1jcWZu8OmvWKdz0mUD3NB +klHbimANHInYrhOJdLGEnySe4JFI0nK8aNFSeeZtc1HmhXfNe2jTIGX7CYumGHGpFedh26UeifYx +mmwODiTDueehdk1FXfAwF0MGLDcqD3xh1owUhdliqGjJJPasILmXUUYO+A4DksJiAnfiApBZlxRh +jTxgpU1971/A9JIHZpekcVIcn39cGDMS/l/S+M/05eiYuSITGzOPf5nu5QH5SQ8K6R+V75mBmrzB +IpEpL8nV943lsuKGidNXB+fNWDhlQrVwvSz/zaxTCzN1e5A05MQ6FJK9nxpzMz9E0TtGfq/K6RDy +wAlUl0la6ELVUpWlk39f7P3MQoFOBapdIjAjKcqEylWwCG6RVx436xsnH07pxW2aIgnfYvFIJE76 +CGuQZ1aa9enTqwMjtuW6hLXSQY/E83iY+sJ1BgjHop9g5nvY8uKYDBA2nAdVV1sbTkEwhBFLYNsl +luensN4Jx0D9wTDeReAG0DFhjDKOLQaAxKYsDvv1OQHGRTh96Zsl8tR2s2SZ73Grj+BDOJj0BW4p +zA8fkR9sN5vl6Dxzvlx5AW2SPc+Yi9KVvwYyF4fQvTkjA8mcDCp0t8OEb7k7LLvf8ZQvB5Lt06l3 +ASmLucPAR/gMcnQ5BUqe5ToHc6n3gfDtmPu2TTjv813seEAnSeIOzI9ivFgb4IBUHFNPY4IanCgU +h+HNvreLcLFKbQUzxvESGt72GYPJgxPaPuEiQFXfSTJRxQN3yq6jZp385XOzumpmSdPXR+u2cDAt +JFsUF04Q0RzCweCUo3BnZ7GnCu2evn69JqCAZMNxVC9vfWguWEOp0BawbAG20LJAKmpcYuUTSIZR +P9EP3w7P1l92BY3araDykxBmUzCZrTZqI0PE9jWHGOmjYAZlwJhl7+fwywPQVqIk1vJwu5/EfbCn +BpPPHTXmN2UZhCDJvFeaW2K+FxWgb5QBUeWCkJw4imrky9+BQ6AVc7yzSoRjJAFjXuUAQVl3yoZS +tFi16qL0xP1KuXGOMaeDeHFVp5Ql7H6c9LkAxhgoJ6gQJE/fETxXPpBXlRdGTTwsu86b9TK1D62X +Ha8aJbLidWDz1T60Jf3mi2XF4s5vybZgE8e7d+RE5VlVQSQt6LadSmBiZUXdAKKqgaElKiyIKlC+ +g6cqQjAZcrhQucDRw+Wlb83aNYAxJTzY3vdsC5YLLKb1q2pj5VYq3zoHEuGTaF564qVA/UCysATZ +ds12oPz9mrlYrvjRmCs3nDXL5M0e6NW1e9Faeedho0re+gv699pHqGIEMusNNsFsF44NAoterA5F +3LsNKhmJQCt5hDWHeov7Nte7zBpsVUOBcNtKEZWB7ifIz4eixCn0rwee7acumBbHKCQzaO/HLoUP +6mnExmmQjlDV1TgupSkIig+HZSVG9Q2zOSwMqgrtouZQuzxWatQW1PXZMVTy2OR7XZhJWCgzkAC3 +dNuTM4JjOKpsEteV6QAmcUZTqckZoTLIHWXZQa4mE4XJkpspynTQ/8RTCLpPTo+hsqpZWuLuXtSU +/p5X6yNI12djFIXrZi0iTNuvz0K9U21mrbz4KCqXJ/82Kk6Mo4U6GopY1pH3msNx0TGSNWKBkR8w +Hh6CmVTQxYXTPiSXjaPl1fjw4RkvjFfQcp3Gledr5ehNcNO5cbRK07p6x2yQmzaZlfLOOFqQ2TWK +go80KhHVKaVLkbd39pCaNIq8fQzVaohwDyo5sQS1ytvjkHRrPdIqLciUnkU/GZffR3PNquLpymGm +SHoeLe0OzThhujVx+P864DDqqT+Zs/SXHiPTe1mZi4dlQyOqlr0HUak8fB7tydAL6G0k/+w2yjP+ +x6jW+AeTw+2r8AvgD/c9a10s5jV8FMGt6bbzr8HXFnicm7ie9dpG1g3ftk/2C2eb/O+Q3OSV53n4 +QhLTrazcgsMTS5IzUosmJ3rJepdkZBYrlCSmKwCpotT0zOKS1KLUFIXyzJIMhUSFjNTEAt3iksSk +nFQFuD6F/DyFzJJihfzyvMy8dAWvYIWSjKLUxJTJgr5izApqWpPtD0tMlhSRY00tstPQnFz4V5hD +Lz8vPi0zJ3XyxI0i7AqJxQqlxkbTHzoyik6+sIdr046J8wF77kHC/wGYSN6M8fiB96jPkIZ0GT+y +JisNUHicW8WyimVCkshhO27uyvV30teWcO44taY2t9rmcM7Gsi2MANEoDen/AbeXnW+Vb3G0ZDlE +au7qF/hS62+LeJwBHwDg/9IE0gSQORTTEIev5zL4CbVlzvaWBv+v+xv84rFNBQL3Jw/e9gJF27/W +JWCwyTKaoBFRQbaXOv+2Hnic61zG2rWMdUK6WHlqUoFCcn5KanKxjkJCUmlefEFeekJjzdYaxt4g +ABwVDrnxmATtKrKPvFfjyk0VebWA1FtndCaraHic7Vl5cBRXeq/up4uRQAIJnRxPAosZGI0kwCBa +SFxmAyyHzLGsg109rZkeqVFP99Ddo8MIC2y8sSu2ge0qf1VeYuwNG3vLa4NLqUziGBa2ktSuN7Vh +k5Rdm9rY2K6tZEnKwX84Xm9543zvdc9oRkg2qf03qkKo3/G97/h913vvfFr5xk+qLjeVuGtLThRt +U3V98tWS82UTO5PJtKP06yqNqwklrTvUMk3HpgnTos6gZtNv7Ommlnosrdo4aqmOohk4oWoWNUcM +ag8qlhrH8YRqqUZMjQQo/qTS/cGYpThqKEtVjilyzDQS2oBEd9ns+I37Uo5mLjM29qcNedBxUpJk +23p2kXSAE+5zrN7eyU2V31+xgRPO/2llG9MjtiSlbZn9bZuxIdVhFBx11JFNRt+wZfdarH5l2lZl +e8x21CRyItHhZMTRbblg1N8Ap4DUw6Xvis0QTYvF8MInwgJ475hYXKxaVjgAN94Wap99kpS7mx4q +maTrvz9/2awiSpKhjgT3moY6eXVHa0PQiViqberDqhUZVnQtjgqSU0psSBlQ/Z20hzpW2j2n1MF/ +RcW5kx8rVzZBKIWn3b4y/w9Q7bZK7ZiiKxZNaKoetylqiWpTNkxbmjFAdVOJ4/+eMXTV4QbULBTW +USzH/fnL1bUpS2Wr5IKZbld4bulEN7Mv1bVhFY3PrGx7SJg6xt9MY2bacO48RTXiKEgB5YitOGlE +BHIlK/F4MG3YSkKlx2nryuEkPRHJYyfAd3HSky+9WClOMNKaneUUKWu0dxp52tqKoxvzOejOAaa9 +nW4zDdS6QxUaTWi6KkXpof27UcQhlSoGjWrJlGk5wVCU2ik1pqFqLQmRGzPjKOuEasVUw2lTUfEp +1c4nq6CgQ6qaooc1I26O2DRuMa0hw45q2TToHdbe3r5Nah+NohA0uk16cDQapobp0Kg3HIrkSDJJ +vWPjCAxnkMtQe8dU2kl0dbs/+dPm7VoiawvZ1jV0P64NWx7RnMFgf4t/fEuIHi9wn/wzaA8ce0xY +2JC2EK9sQE5YZlJmW2UcC7aCYgjNsYJjQqHuGekxxtA++eQjjsmHg1+yJcKJBt3L65YOFpyT23Gi +O5Cv9+0H9lDGILNiLihhiLLGuEkSljKQRJNRLY6/NWeM4vSuA3vMeFpXdyN1dEC37+I9dcx5FN02 +qe+XcYZ8S3VvX1waac6DHKLrK9Tsrvre2sWFOppinqq6rU6Wf69bqOVY5miThzTuJmhCDZ5zySLX +fKmidL93Ipx9R2jFgSqX/vciuHpebJyM/lmlUJ631e2M18LNoFg6ef4lKsHZjzBINK0qP+Q5bHQ4 +iShjykCmUiinrMVZfDBVm2MP9aJaqJNIgVEYd2a/rVrD6IBKbNDf1ROAj38l1Luv/qZ0PmolidqW +nUFLxQjQ2go/HxWXLMw/Jch8OoQ2c+kHi9yfvr+nntFGOe8gDceeJvWr2R4Zee6huaiQH9p100zJ +/pog/wiBUivWwMkPxSK4cYwUw6U/FmsqTcM73V8K9yeFBveNdQsn2z54oOb/9TOrfty2D/a6j3yn +bHLPp29F4Js7xbnzZMz+soH+KdsxMwXn6jAZrlkuNGbebBUSZcVhphR4ZJPQCH0dQmlmb7twu3Si +T7EwOyn0sGkNqdYK1LE6qsa2WAPD0W6WtAyWrAaGaRzxHXP0MWprWDDQKK7YicreuAKdytFivVE6 +Yqb1OCpbGeKZ6NDBr7V1Ya5JaaodCWA0pcvoAdSDM8Y/tqO2aPQwvLdeWA3ruoTlcKRLaIHHuoS2 +zUyxqjGsWabBAoKMDMQkmra1h1UuBAYGdHjNwUDEmGXzwxLtN009HAjRtl73/c+aHvQE2u4L44dS +LB0oL3EkKaZrkoQ70+wItAmaWldimNo1DIHsr0FTx5DjxT/VSCdpH+YnlqePB2DTcbF2406GNiwJ +wjm07VWS6tTXfZrlfZzI5VpMxdTEfz2MxYlCFiXJL0myQTe7wTBZ8jU5lhIY+NQ7phMJTY7FZp5O ++Vz3ZPmXJFbb4KIj/qoUg4Cs+dLgwnHUZuuRdNdD49R24ljhOZYk8fzCc8JwKGIOBUMR9EN0GNUI +jtu4MMLJBL25UOb+DcIyMpFUHDRzzLRQ4Uk1mdNysDWPtXAhZ9PTXsEk7emlx0/MPL8zJ0GvTwL+ +Y7lQEUaFR2KptJyyzES+mIVyB/vHHNV2j2nVz94SimD3u+IC+OLPxXlzp85H68L7y4Xa9QUUDRxG +agfMpBqcBUQe7dCdxCtyxBEsnPbiAtrodVnSnASkqNhYQCIAz+8WAhPoUVm/pexMFg9pyrQ1Vhwj +KCR08X6WOB1zSDVYTcN8FMVOq9RM4GRCVwa8gpGrxeJB1ViBGMKAouen8WC0zaKRdj9tRo7aGJKl +aFsb1sJxfpxNsTwKU0zQ9pCWohqWmArL0EgeyzYfjux4Fl4iMLRRWA+Xu4VF8Ncbhf7KfLRjVQ3r +eoTuynyM+4Mt3ejMbV4f0BZTWqahhqmxoFHI6hG3qyFY3yMsj/zfCLiLvlkPW3qEupVonjZmnpm2 +ZE2Xx2hHdn1bMv5lW+RkPG/XRG5XFqHT987g2VkX6J5WxrA8xVyda2A4hFs4nLAisrQUHq4mtFEs +idCIuUO3+qR67qhD79KfhrmWm6fkYI5yFzIwN/v9+WeHcda3zM773XjucGi6GOiTdyEF+vPvLwQe +lVX/rllkyIsQwxHUvRnML/OnDm6eypnwPxuE2jbWexlxdZR1ZdOTbYFwuDAIF3qEWni9Rzji9u0t +cveNFcP8XqFhM5sP0fHx2ZIqr6tGZVSlbKeYelkOl1ms8ePZ0q2kgaBAsKlXWMOi2D7s+CzsADCd +Y5eTNnJRRdH1MYmHDeykdYwmW/bex6NYkrKCns+wYs1wsIjhgc32ykCmLtxhjkzFFa6u5lyk8RVm +rsqtzAWb3EpvJLsSGW7eLHT+0Wu9Qua1XnE0AKnTYhmc7yN3lGHvzyELoe9xsRqeCJMq+PwtsQpu +rxAr4PJOcQlcWyPWuzf2FGW6d4m2NEMJR73FL2wX52TaHxd/8LK7ubS2Ma44CuvzZJ33RUGvZ1NH +nVDmVhv5XGxgjTJvrdpzbZWdRhlG4cX1ZIOrQQWs6SRHWjh6sY/iFSzvIzHaa0mNdcJeSZV5qpPs +JhPNs63KcwWvmGDNKS91j9oxlvC9uxPvK8mbOXlIHeNdGOpR5lwGveZrCrheW9hDW/nEkRQ8upYs +gAfuJRVF7IRM6l7yGbkL7mH+f4oLYXwD+eG68KxLWVVfWDNxIbwS4unVJAL9ElkG11aT2mY29jVE +dh8uQXwbmsMl4bGEQxwUiSyvCNP+FmYktFEL65DhgETWTHXDJzLfQoq1VYX2VoOZn/WRFuL+9mI5 +GG+SUvj0AEmUsg3owaDtEpvA+BOxFDZdIcUNef6Jhqc9qPQWzMYtAXiRkOpOJoPNazeMR7Z/ScBu +2bDPsb0zPWvYyAQLdfD6VWw/Vm4l81zj8RLYt58sh4+eEErLfaM5Yyk1c/ggebdxyVfovN0kfzeP +sTZlbrhgkMWZT0zSWFw3y27ovCzWQWWazIXPHLK4CHcF4AULnaR9lVAJu9Lkd/WzHQzXmtHLJs6Q +GvhZMykluDdzcJhcEr6K1d+NkCUzsto0Sp4W7xs0zSHZNtMWhi5W+0oc2F49ewi/t7IgluuBpkDE +92FMddIKQvDfhSWZiw+Tb4iLvgywmdvj5PPSnSxW61aEezSGz6ynB0PM0LyeVu3mYHYFgx3W3AiA +sG9+Os7+cOwW99wzdVC1kxStyPog7ceSDcGARaBX6uVuC7EidGxQusQa9xevVMBvB7DtLvqkGr74 +OpkDZpE4H54qEheBuUNsDEY4drI3oBy3MsZs08oxxQNRAG7uEOtLV1qoDmy17/9XjID3PEpq1+Da +YC487PdY26PaNlLzu4w8cHqU4ZQh8GuTkoYwbeVDYa/XYVK38F/uiy9Vw7XtpJKj9x9Ok1r4q+Ok +HC6lhOISz7Hho9Pkb90Hz5dxtSz188jUVWmhOtxUT82EzwWzpy0rMYetmOroc/4cDK5EceThZChS +sMPXvHcvSntpB8uVs6zll1C5hd5F1M48J2+eZR8rsr0208MfAmgGrqFtgKy9ZxCP6NfN/kAeXQxB +iG4vkXAnh+vPofIePkkWryw8aJB1+F6BF1NTToG94cAACS1glpNaPN79Fmz8H0kDDBlCRWW/iYYb +8XpI3Aqdr4o125ll/LMHkTIqF6e8gUhSSQXH9XGqs+tIJaWhDyg2TXeFImljxFJSMmJu9b1rQ93u +xxdrKGM9S8PrO/MCF2vam78l1ge2HbVZf9gZ5t9L61aHC4odmU124KSwTqx2V66pWMtSQRYbzqBl +pge8WsMeM2L4aZhpmwvAfZ7GBjG8RmDzI4jX35iYev7+GJmzJJZKSdJWxLxspY2pC80dTK3BANwI +irXQcVucB+VpUl6NMShPwFamYnfL3mroKxdLipiE0HwEnQkjZWlZVmhvqO00aYZfvi0E4NZGIdCV +16Hzgmh8WtmKSOHjLM6ksRZMaAaWh+hu9HlS696IFZXuG+IPIXDmHWFF4c1UMTxxklTeOw3tCC// +QcBmFxkDCDVFD3unhLg9WUEF594S6+HHu0jFRs9Q3vJp3OHZvPoKevE37MMkzACL20IhV5isgxvb +SBE81SDOETqhsw/JNj1KdkNHI5lbzPfBx0NCE3QsESuapkL8dPWG4Ew1afy2WgZ0MZlX6wel+AF+ +8EEFy/nDig3z52L+5U9Mfa1CmVe60VdK4cZpzD37HiONcPsvhaJl03MGwtH74uU5HwKhHVNtxz8J +5Tt4mcvxxNdQ2zGxYFO9S06GPayRfOwVYs6xFMNOset0FtVH4NS/CLULg/wZDUvvMN8s80gM8gNY +Rv7h2wjJ1AlStjLFrnPiqqPEBmVdS6iOhlqezjW/3YcLPxWXNiFuZ9zCfPjcbiR92RIXwDNUrC7m +VKDqLwgO/lqocztGi6B9F1kLNw2h7NlbCKJHf4FOwb7yHuvOUHEBYdTO3hLqKgpy56VbQiOzcQUs +mSAlBJsmiIawiOBYgFMXUfNnlyOJ6xMYsmqeIdWw+d+EBeUerDhQ2EMi7WRunR8OeqjnhgfxQ5K2 +wXWMDc2rv3zVdg6BulLZu4QCoRNd7marUAHv/VqcN9f3lRCfhQtviQsF89uTHJB0EUt6njdEHGUo +mzD57xBc/yXqpOoLFCMLpTKIJgV+tVPinvxhKVw5QwKZNx4nRwnrkbYwHNCYmUxh9MTWCBOWPkYH +Fe9Shz2xeJcWU+9i3tMVm1UN/oLji0mZM0zv9mYt9dlCgUJkgLTD158kL7iLj7L8PqDhYZYXzEJe +LORhkCo6iwhjFJGKLLa5ilFTx+jPkJ4y7z5J9hTzmAbBq2Qe9L6LEGGmzYTPkBsLls7ovDn5Qpni +7xJ9PrzyrDBXTHfBtQ/JhszFSfLPZVUF9uyhndB8hdS1YBrwcmauQZ62bjVfN3+7nSxcB1UDZDGU +/4CUZy68ScaLjxzM+aFCs+/Dca6FNp4RzGxDy6/Z+tOa7vC3+LxMwq4hfPfnLo+G5EaE60nSAuaH +pGzV/rTttNCEQWX+aJ5zfjlPl37UhVOHsFm5OUha/Aj4ejviFDVSstSLoBKmUC/r5cnMBtmiVfXH +s1WEt5orrYPlz9evkyB0I5rh+WZSXib5PMNZVnufbSTLVzgYKun02m5aGE2GA2704RA89CuywD35 +o4qKqQrAd+5e72vqKS7P4t47oCTtsvOms9WBV/+4x59uEjGrVn2H1EOFiiHhxy+T6sZWPwjjYt8H +vBe/YAgaXiP3QPgqCZRjseppJtSdqf4R+ZsN/wv7zlGx4wOhQXicATMAzP+6yRCiyRCAhAGEArQD +VJuXEOcDHpeCmwNBlxCzAweXzpsDJpctWAMQl+8qAwe3D5wDq4gGshL1+AcOcy3pMolqHYyM5SSH +SkXVDzxQO3icFc2xDcIwFEXRJhUVG/BKG4lEYqHkx36AgTiRvxOJFbJDBqBDYkFMc7uj+7bb8WOq +R9PAjZ5XRpiulEkyfXvXc5QcFtZJOwvxPlGVinwLiv6FkBWX8ORJMwdEGVjvprk37u8tZiWmNLqC +IIpYFu33UK37HyBvKpjyDEKkWQ9wDX/og6E6q3jJM9bxjG9yeJx7LPJYZEMCs9XTCVY5G6eFTryY +x9URfGO97oHrbyIMDQzMTEwU8vJTUuPTivWKihnOlG1Y0P9Afc/+zebnl9fLBzyeKb5r8llm8c0b +ma8ziTyMNH30fKYWP/uJgo729T556z5t2zV5Dtss+1lTN8zOUDe/p3V1Ha92IJv23j7TPciGFxTl +J6cWg21wur/beP6N39VFt+9zaAacCJ4SrZ28uZTdmkmER+jBbP1pUQ3PrhS9una8b+314/w3Jx/h +nA8AmNFY9f0CHORtXeGUY/MAZ5ZpKBu//4MSowh4nLu7Wvr3aumGFsYWphbmLSzdhyevDeTkzCyO +L84vLUpOba8/zALErNvrD7PFCQEAwXYS9ugES3ic+71a+utq6Q32Xkwams3OXu3OXoxAzLTd2Yv5 +JNP0A/2svNulfZm5gcyNjMqTE2axTL+QyszeHubPDMQsQMy6PcyfbWkbALh1GS3yBQQ3meYJGAmA +2HAscWOvtW3hgeTCeJw7onFLY0Me4+Z6xpd8NsVWCl7Fzqk5OVZWeanlGmGpyRCGpqYOlwISyEss +ySxLjS8vyixJjc8vz0stslKYfF5AdvMsgVXMAGuAGv66HHicbVBLTsMwEN3nFKOs2ig4CHZBLOiO +XVUOkPozSQ2ppxqPgarq3XFIi0BCsuzR0/uN/f5ALFCBjmCgZ9pDqVSTjyWHA4bG+ODyezN6oySW +D0WBn98ah71Oo4BRe3JpxMUJOEVZa9m1UFrWgm0bsst8dwcmizGWcF5mk6aqYHuBVBRHSVS308GN +qCLKaiT75sOwMJdhuVWwQUkcItwCMWgIOGjx7wjIHEhB1VyrWQpRINu8iPN09YLH3LUPuafmIbZw +gt61GfL3dzVccybAEI1wroHnvAtn7v0nYUB5slOFDUZKnHd5Dj395BQAMz3/xyqFrlvP+3bd/8Ky +zopfoTocJ8TqgzZ+9HLMPq/xmyU7po9MEk5YF1OzLxkZm0L3VF900tXhgOrRecwq2rhdnY98Dovj +eJyNVE9r1EAUh95sqUKhoFDkCdImNU2rhSIpLay6eyptaQtSPGRnk0kzbHYmzkx23a5l9eQH2KOC +By8elb34GRS/gB9GfJNks1u9OIfh5c37+3u/l28f5t5/nvvyc2W4ubkJzVSKgCrlKh2KTLt+THiY +UFdR/SQRQZvxC6tVCnbThQPWppCwVtZdU9DMur7SkpKOj/b+xK7pgKQ6k1zBFggJBDi9IJp1KVAp +uXDn06xlBUNJNLUh4mCcMT8TVQgrCj1g248cmGg8aAmR2LCxb/QwmAc8HaKDGFoZ91VfeV6WhhjS +54JXcaq3Ruh5kRQdP+ticNuBe6dVX2U0c47almXbsLcPW06lrEtpYeW5egOzF5GMys0bsgvTq/mr +8Y+V9s1hLU0pDxXomEKrrylKIv+IWEKBaESd6Bhh6sUM62caAgTR2PViKqkxxZspwE6oAwSRjpRL +8qgNDHHa50ETQkGVO2+G2CCJoqUvAbWgaQoRYQk+j962l0d76/eHhfeZMP5WXq6pwYP1QHClIXvs +VEo/odyDTLFLWijzHv4xnbXK52IGVEKZYT0V9APMOcQ+jq5280es+LTWqJ+dezkoAUkSKjGzUgap +nkB+IVVUSriaQMSFjnFS0JOshDPMpFFMArhlSRos04JT1IwTg4wrEtHhzIytSjInEJJ6nkpYQEuG +SNLzUyK1KkNNMLGd/3bMszswdRqayy5osjvDXTMOzxM4G6KndV1jbdALrZnUeU1Tvnpe7fi4fvgM +Xhv5+cnR4cF5IT89qdfOJpYvALbEzs5O8f0X4w0tc3Ibwc0x9hHTogvbZcoX7dkSzD74hYNh3njt +wae9BZcoP0QGRpY9/h7/WhrO/l2COGTo4+PNSYfazSnTIRIJ+oGIin3JWBIW3NcgOOpQ7pAAx08L +vtBXNMg0aeEqxehqlgZXKiH9Ym/cssw7ACzKGYEdYl4aaCH7hhGjl4O7t66NcnV19Pty+0ZlNfrY +uD06HtxbvOY6esiXR+zN4vjr4N3SH5tdqYH9DMh/TK8nZasKmveV+Z4tiW/yoolmeJxr38ByegvL +ButgVl1Ds5zUyQ8DVTdbB8/19NbXVwjJSFVIzs/Nzc9TKMpPTLFSSFQoLinKzEvXUUjMS1HIy1dI +y89JSS1SyE8DCiikVqQml5YkJuWkKpTkA1UmFpUopBXl5+pNPr0gUSMTqKYoXS+rOL6ksiBVQ1PB +1lYhqzjZysorOAQoYGUVDDaaa/LEPuHJalu02fPy84DKuCYH9ItNllymP9lnmezkxvVSkxcsEJxc +v0+cSdN+sqCr6OTF64wmB+0X2Xxjjn41AL/XS2zwApRwyxtrJkt9P6vO79bdOJdiL5KFeJy7x36P +fYM7s0hFKZewfop5TpfakUNcBpxhrUZy3yZHMzcDALcZCyfzAQD5hAmA9yoy2rqey01Z86oODMCD +eJxb187TAEQtjFuYMpq3T2tmkmgAAEx8B2XxDAc8MVm1sl2UFv/VryU208DC57sxeJwBwQA+/9UI +1QiQlRSV+tyV/AfP1cWrLen6l1PfSBiT6qGpARS1gwZAQgOq7364wGgIIWuoa5DpzJO9ARkU/Euy +4ptLxCB9SVYLZSsI1hi4Y/CT6gH8PgAr00DtXcKxZNdKLgoYEbloRCywMTAwNjQ0IHNvY2tldF9i +b2R5LnJzADmBUJA3syRpqw6DqbamsmF/nqMGkyQDShStLUyQ1Qgdr3B959+SXxNbUZk29ZOCA78U +B2t2VgCSr3LJ/Ye+rYtflin8tT4VXldo+xK8kkaL7ZLsVebTrCnX0Ls+mMQxxHicW3CIdcdh1g3X +8iWLrRS8ip1Tc3KsrPJSyzXCUpMhDM3JdRVivOVFmSWp8fnlealFVgqTH5bJTb5XsWPzhYIz7KRq +3Hyv4pynOA5Nkz9qS06eYMoxubeCHU3rxiu6m/8e4hIhT+vkv4fubTa74aNLhj9rtjuwMT6IAgBG +4XT89RXTTlAj2dIYDZsxlECMIMCkkPuhbnic+8DWw70hm5lPR6Ekoyi/vNhKoaSoNHWyILMIb3hR +Zkmqc35uQU5qSerk34zWCSgiSjpcCgqJRelALdUKqUVF+UVWCkl6iXmVCrUgGWTjdLhqNa25UisK +8otKFJLz84pLFFIyiwsSS5Iz0C2x1Mcqg2JZcUliSWkxyLZMY6PJCUyiPDA9zjn5xZMvMJlZIAuk +KimArEe1PzUvJaQoMa8YLGQLNCotT6OaS2HyBCZ5R2Q5FIvzy/NSUX2ZnFiQmJSZk1lSaaWglFWs +BPEpAHGfdH334wSKy836RvcfeQjZwIT79uVX/AMktXicvVprbBzXdQYV0SRXEmWJT9GyeLmWxBlq +OSRlR5SGImmZohSplChpKbNqbK+Gu3e5I87OrOYhiZIYgk7qAq5hKz4oEgNukxZFfwRoE2N/tUX6 +AtoCaQvU/dEEKNIHYKBtGsTWnyItiqLnPmZ2ZnelyEYR/tDu3rlz7znnnvOd75yrH/3Gto//e9t3 +Fp7qs0zPpzZ1iWEXSN4pVyzqm45dvfbU97e1OXbutmv6sKdjcI/8TnMF06sYfr4ED9t72GjecrzE +aO8mtQumvSrmezqZo5Z1MvDMu3QmkyL455UCv+DctnM3AxrQgpyx4jiWnCB2Khqm1eyp7xq2V3Fc +P5c3LCtXoBW/FN8lLeflHdund3ydrAR27oaX1/U5MXKuUB3p+P7nslkpBzE9ctswfRSaFB2X+CVK +qL1q2pTIX6vMRma+tvWwR/JmpURdtl7McHBt1zc22eZjY2Mk6+TXqB+pS/KGTTzftCyyQknBNUyb +7SiMEF/OKPp4ItfRjIp6XeO6mF7Odgo05/ElUSU0Rya1kUox3egtavs5y3Equm6WK9XOTr+t7Zbp +oRELsNVzcBOnB+x80VwrRn6NqZGnHtcM5aLuFP8a2GKab7irKLZLyyihR0w7xZRhM7ySgYoQzyGW +eYsSnxpupJhNAya16aNyaERKii6lTD/b2Omz2Z7vuMYqheXeay2r8EFvV7dKRmfIYoXZ7eT57MuG +FdAZ+Fbvu/Dty31wrm/0+OKagpLkPMvxlRseOpRRqVBX1eidCs37Sjpv5EtoukKA1r8TqZdWYavv +l6/ggUi9p6NH2oqJRl21nBXDypDakhlymBkyj3LretZ3UW5dn79waelahoxr4/j4i6+qs6D3P9fK +lwTaP9SB0vEfavXt/n/8XKoSrChewOSrru3/ux0dRZtgeOAhwtsH9sPCc9fha19Ow3HFuJZFC/tL +C1npDGhBcRbosDbqhebAs8BHzJg45gVlfljopTzYMoQduPQS2+DGLVAfbQFrZ0cGDx8muTVKKzmD +HZJWMjwZZzmP7Qstp3uBFNvhvYIGPzm6s/qecqmlOjPSsa1NBsy72gGoZPax8Hcq1IZ3M2cgOPsC +/MXYHpiyOzbNYhhaWuBRdEwuQi6KDUUl97jThn/oPedwvo2hELi3cK5HGF5Y6IRlHJ0iaDoEolLM +eZg5LOc2Kuj5LjXK3MVcOorT26krYgLI6CB8vrgvinTNpfgtj6gRyoSvFjwFxuwe+EFmL6RG/6Om +5PzlT63Iz9hHhbenD8Afj7TCeW0Afm1uD0wrnbtjU3IVI4BRMw2jo52t6Nn4xoQysMc31qKVcIZH +YdwcZHN2uZRbSSkalkerr2l7WzdPu05F+AEigm8W14lhljEIDMQNdAqL7bOOdirgWKRJBjHQl+7m +0lUG+i5CXGHYS8UOqQZjUcDooYNxnPDIjSOOaePp4G4RmsgjQ1lxJxbxIeDBWy8MPeM5ZYqGRK/0 +qFXUEMjCxwr8+wsjX2DyGisWJfOLZ6SEGENl0/eSWt4uob25X0RacdzGVMFe1+DY8anNGuhyl/dI +OfB8AbXktumXnIBZycFVXJFkRnkUjZ45d5FQ13VcjZwKwb7ehU8LlGHLEANl5EmOGVFKbVO6XEC4 +9IVQVCxIfCe0K40MoyXWZkAlzmuaoEuGZorhPWxNdnWnQ1Xn2dy0CIF3pp+FB5Pb90YPz2BS8RAU +0/BOpX+AzWEZrYJOg8llHcGcfJHvVf3q8R9s62ZbR+c4Tco8hf/61QPwpfWOVq4F7Mn2tXKRYHG5 +H9aW+/eK7MyAWeBvJgW55YODYtiLDceVPAxb2W747nJ6YJnNm5MmSUwC/YqaUdTaWH38IeKG0qpk +eobAh1d74a/1A3u4gHHWAOPFfvj65DWYnRqCv5lt38E1LQU2qgmlqe894g17sh3e5291wzdODsFb +hV3TgsZoqJjCX6ok6I3Gw5gcIRPqVELWlaBYpC5DBAudJ/J5Fb0BwZ0FJwN05j4yfrjHMpcyMVwx +xRrkBos1BD50WOKseNTFODTIqlFJ+o9Mnbp+8erCAvzpbHeey9mMJiXeq6nUbGpTxSzOC7zA8uEP +p5VNbtBM5EGvxmb+P4owmhCB76lRzIouLB/p4WQLo4ZJNu+6CgYduoYUsjEPnSLeup0vuY7tBF7N +9cvGegidjJuJfKmRcxjLBYrH6DKWISluPF8HiIXJw2juV+9PXoD35naxfNBZ09QsWAzqB4RzRsn3 +zGfOS3IiWzeWjDDZjyacdXqajDNAHmoQVkyAB3P7erkNJOeP8ds3Lw9Oonv6hh8gtTefP8pJ3Hnv +Cjf4SUWdicmWhJcQWIaShUSm0X4SanqeSc6sx5yhgbrnMfAB++oQwg1Jhw8fDzstCnyc7WP54xeQ +OonTrRHyEOx9dJxgtSQelygqVUF6FRIyBrRGwr8c11w1a8lUSxpGHBo6q+Cj2kqwaedulRVVk49y +TlEEh/wdjwLX8DHifUz9rq6fsixdZ8qbZaQCJj5SkuArd0DCiyqglyvhiknjMzw9GcFJ0XXKijjp +unnJ3ecsTFK6foUaFnyS7YU/f2VvJ5Jf4UA8h6PXjO5/AtfY/cyTOEWy4mx0irrnTZxiIHw4x/n0 +I5zhEYf08zqjvscc0onokK5ePD2P7GX+9Kc8Idj74k+7mrgj4s/8Z8YfEY5iOnzzxW4ojnWCs9BT +7ToF2xj47UDmTNlaOAd+f244zU2HhYaJC7i2YeXCCQXDNxT2D4wp+/fGXmMfrKjaNdcXL1j6Jrq2 +4WjLVBf8cKETfmdO38m0ysWmLMwdRTxsh/95sbOqnD7W8VLzorpOqWbtg2gSOO37qrcu3N8GG4tt +8CeLR9lnKtYO+eriRHvsh9KZZA/wq5f2765rh8C/XiI7ExkEB7qb5Uf2dmiD6keL91v4gSa1yiCY +91bLl3/agkX3m8vPMAYH17MPWmbRE/4+NvZnS2/wsbPwztX3YuODLz+Q4//5MkTjv90yW939i19u +GRAlro60G2l+Fk9T18WQWv3KtZGWukN4DhbNtuof/NL77XU5b3/kcLZl2mvyoBXfDag6BRfyo7Kp +QpDfYl171+BVCkvbRcfCQhGXsixZOztFUSbwNoankdMOYQzKRPvhDPbMdJE0kTy1LK+GyQy+I0Ri +PDkZdbvXH8DY+q4aK2aprLOuJ1ZZf3akEcJerQ8XuQsY+X28TLx3U4Vv5eEgBl68dG8afPC3x3rW +0BAXRV3ms1rJNmTRZmOFXakg+fFI2GSYIvROxTLzWFsHrNUhqqpE60G2cZJEJsRdGFJ6wjID+fAI +fGkiBTfGUhjXO+CvZlOQL3ZVPyr8Vkv2SaRvgI74G1EgyNPHkzfGunCjnfDx0Xb47tl2eLjRf/z+ +/UaWJZlN+KgupCSt+WCsJ7bY008nSNEMGYfvjHQjWzoBPznaAW+PHYJrz++Ad+/2wH/d3dcf2qN+ +beR33fDju7usz1An1JVfEdCcz54JbO7Mup7HXNCQK1gxtT2dxoT3wXJmJ260FLmHuvTs7tO0aCAb +0/UC/wLXb3Zf4dDQwJOjPMJRxWYJzTfza7mJqNDKhJkpI9SvNc3gX8727Hwk1b13cwT+uXgKBuda +25IgXM2uHmkRcVTdKG3tOIxiCSpaMmykrq6n5f07vAQOLCvyGHj4bNcmPiAVLIuQmGNhLZtmvuyk +igr9amXVNQpUgnWmvgK4XTIZhw98izeieBVWNKlViNgd67A0Vuhch+2MCsDggUPneadP15ttOYMi +b0w1TZBhqIUezgPsk41+1qGq/q/3m61PBDFdTSAGtqa6qtX1XAv82909R2K+OF5flDX4rzaQPMWW +e94rFzGDDHvoHlnefhNNFa3gRC1z9Dmvrhvj2HyAORFhTpSRLUrWEWHdTilUCvwj6vYXtKMT8M0j +h4c/f2x0YeLYBG+fctaikiJfPgYaufwdGHqju5U3oeDhVs9ldiL8F/ow/9R8B2NHkcpKR+dJSeRB +5uzouiiH0EXQW/YKf12FU8/1bjLxZTsek0fAmpPEdRxfaIopQ3bLBYSKnisVLR/ZJhMenCT6QgDc +P7A9o0jJPXJ4RIxphper+G7oL9fFO1J4hgbBbU/Xz0luFAouva0gfE8R3W+mn1xUfnDAkT/iIcQ9 +3qoJS24brMmPRB8zaIGsrDeNI8QSPippRWN8yCZ8QksxpuUND98/KRYE+60d8O2NnUCV3qfEBPhw +o4+vJ3++WTzUyn5uVFfvfa0jRA/43sYBVqCdssO6iqV/WjbDBh/qYBaocLMxdCBxq5EPsHrHc2Qe +WLQCrxRPfezkTLsSxPQxixwTmjckXqoroPnMJnkomeP4LL43S2njwxfgj7a6OxOlNYXS/elXeMdQ +x2p6wcFNTw4bM5nUo+prZnMBzOx+444mvjcLAI6XFC69Pj+/hAapuwsS/s0MIZ07ebUjrnUkTgpK +BTNDpE0s6sL1t/bhae5JHBJvaPLm57TsqiaCM5ReRto0UTBtP7qJIHE7axsVr+RENwTrDLPZPQ1r +e0uHEJtuRpeajBCVA6xgeTMWS7QCbXTcMu+MsyoXRRlP4jbLTEIDzEa0XPHXRSs70oqVDNSwE0cO +PzzWrkYrjvIbOte1HV0PbuUw1V46d2m+tg0YU91pJpkaWYv5UJhz+aO0Ogtbk33DIg+hj0/zDy4A +ru7xCyv5ijqLrGmyB8ypnYeVWyy5Z0hOVSW9SAgyf3Hpyrn5LJ/+yeT2Vs1kJ3r5UBf+ap/Qiuyu +7L6SyyC4lal6X+xJb+YML2+aChtkALayjqiuqKrK13l9cuDpSPcRvr+Q559OdMI/nNgPs8fbLmIh +Kprn8lBitzt4agWKCjnr/Epa3irSW9Rdl+6n1Z8Q/HjjCGens1NPtbMeMQozBTcn+jaj4GvezIqM +LJsc0cIbatxXG1mT9NwGH73oRF1CFNp5TTQK2b1dtKdGFqiBAYaoJRBDXvWFAYfGZsoSM5FGIkXq +6dYoCse79tQbYtJlYiTSm+dwoi/JEgHf+PBYN7NSKlKG2wlODPfC7022QXmrC147OTSzwTcW/wp7 +sqvmZIaO+itJHFN4qh5+qa5H+CSY1QhY423UwkR7LwUPJ7tNyakYFpw6M790TSdLtXwtUC1m/Vre +FjxBmpkRFEzs7DI/dt1lsj4vAz4XITwFv3twoA7g2hOFLKLcwMEwUTTl+TxDCLk3hR2bzWX87NFr +1Pre7FZIxNSQWDeOT405KLw15NUzgden9josWJtBABsPe3zRtXqZ0ftC7RbLdtJ1lxtxhI8cLruO +sFvmTscurDbFRlLyJA9nfyzwRXMlee3O5pv5HMcXtfG1Mha3xmrTN5GW2TQX+MXjCqaITYyLISUt +tLjHVttIq3HAalzbW/dYXnycVGK9dJOXNS1Zdm23WM2J4TXInyJWc4vlONWy8XgkXjNGMCjDr//5 +mKFlFBIeA420RHT5MRvBjzbU7ewhLJ4bhI82Dh19HDXBZ00WgszwZcZKdojmKSZrHsfq2KckH9Dy ++jjce+Mv68OFM7dLLhWXWIh1lokxKWNXHFEtHL0wxzNhRN/dZLXIaME1WaM9El17DEbHcJ8to0b2 +bkbOfi6wevRTwaponA++MbG3OZe7sPAInhZ2vgT9bcBF1m+J8T3xf4EKP4vTVa//Sqr9/wBxEuIg ++DVgp8MAiHJIo44dcudiz07bHyZ/PXicdVNNaxRBED0lxMEERPeDiFLMaYVhchAvE4yoG1CJMbAL +HiSHmpnenXY73UN3bUwIYT151EP/Am+eRMz/8OQfyD+x52MHl+z2qbvfq1dVr7qv93+//fVjbeZL +JH7KnhNhkp0wScYPPChXGIY9Y0R9AngGH5p9serQQTalVH2STdwCOtQoTa40DdWE3eCkR9NcsLN3 +mo/5TbDCZB8JV2H7Ml2E7PXavdly7kuhDFsl9F5zWgGWUJ+bHCnJllNK6YbS+p9zPN9fra8/vNPN +0BxWtqlkwuiAG2KSaWO/tnv2uLNptzqjmbezA68lMS1RwIA0w5MXaBg4lx014zmMlAapUhaRMLsw +LiR4Av2yGGZAM0Iu4c2gCq5yhR47KyYBiZKGAMuRV8UMDwbNoODpDOJwJHsXrnLUYxPBBZhSIQJH +rMQCoHlABNXVK5SpYAHkmp1yNTWlby46DmOlRABccuIoinEWlyjPnUjxKuoTXBa+udLt59aG/elv +2G+tx/flvMCjBdm+ksx5tn2rqcj+2Wo/ebS72KSpH+eyNpsu7V7ngRdAgkLEmExs3uoW6dsJ5hhz +wek8Av9j8TEunb41nS+3uTl07teJt7u+/d6+e7XZ/ev9A7WJCLXxig3mDFjUvH5+vHBQ852/1L9C +15/Xo3ic1X0LcFvVmfDcIz/lty3JdvzIlZM4UrDlJLBdKichiROahJCkcWCXoay4lq5tJbIk617l +0dgVgdLOtGUhe6ecGSgl7O7/dx8tJGQ3nvKGKWWHLG3C9EW7u5D+/7Lbf5YS+m9/CGnh/75z7luS +7UC7M+sZsKV77jnf+d6vc/LCgw3f+HbTyaEto0ND4u5cQs7JCXFUzcnS1M6kosppOSdmDsH/lclk +NipKYiKpZFNSHEZtWzu0b+eomDKG5eQpKZlW8HfmoDSWkiPaqi1LlytRcYcyIqdS626W4+t2Z9Vk +Jr1ul6QmD8ojUio1JsUPKNpzI741afZd7FAuqcoxtmZUZO+VfGd7YsNpact7NYUtObaqOinDfwB3 +YqUibs7kkumJ0dGdopzLZXLidF7Oy2ImLSrxTFYW5cNJdUA8NJmMT8oHAfJD0hF83zsEOOAjkoqY +ksfViFdRc/m4Ko6kZCm3Fef6NE4VGstkUuFhrzc51ZVNiVtymaw4Duu4hmmFfStrFTk1HlktHvVS +ySt0NW3duzcWx2ExBpp26m6f9sHe6tO33NjTTZ8+I0S0Nx6opjPvCk3ak8e82oWkjyheuuZVoX2F +nFZzSVmZEfU/Itm8MhkazUzJobiOlXCY3n6KdLWPp0VJVaX4ZEzHaiKfTcmHtXe+1Emf/KkQ9MYz +aVU+rEbFfpib+Oj0GcFHP5wUGql4n1BRfSgnZbNyjn46KIRWp2RVzGUyqiKuF6ckNT4psj3pM/N1 +pgCmGBsUCtNHPiS+JvYhLK7fwN+l4ggJ0MuiZ7lndfg6+vwBwV/JH0z3CktrcY1kOgEgTu9vLyiR +CVkNhSMpOR0CNIv6D5BnUyqViUuqPITvimMyYF0Ws/kx4MJJIDljg82AiL3yeETcyzgxBaSUDsoK +MO9kJiUPiGlGdBg/DltKJgDypIroNNdBrAMMh5LqZGwqr4ZmijCfkxU5d1AOrQnbwGPbAaKoMbaT +0EQqMyalBvi+REkR81evHRB1zEfy2YmclJAj+5WYju3wddZcSe2GSz7tc/HGTxShWYkpshqLwyc5 +EdJfHRCNxTjah7VH4gPXfJRXteN7O3rs9LXJI6cK/fo60qnFLtXXZHPywWQmr2jZ/R3ahbc6AsYX +Ef5SVk4ngCja+SOd9ISHVIZKTAkAcRY2300mQvT4KFlGH73R00w39goV5elx1EQY/hTLhUvPRKNb +mByExvLpWFbNRaM6r0SjaflQyDEZ/ui0GoAHjda3YfihFzcKfu1SobUTRE3flpqT0ko2k1O5aNNH +LwuddOdJ4Q+0E/fV0V1/LKyiz79I/I2bdo1s3bl1C3JE8uq12qlj7dqNl3p9OekQiIuoZOIHZDXC +f9HV+2CO5/yeuk3I2aCa0uJIJp2W4ypoYD4G9TPqP9RZAIY4Ykwh7sPvUCUOZtKpI9r5sG95Zowx +bk6MS+l0BmXuYOaALO4YFTOowQGDck6748F27enB+j8cl1SQnvViPq1I47J4VMwrwNowIi2lYoqS +irEBOjnZnkO4CU2c8TUkx0X+enC9uFp75Gi7Jq6p7nAwALyRzoTYKO3Cmjbtjg9b2VY341YVacrY +r7FPw8DgLodBioEd0DoZO9KhV2AzERocJb7Vdrj5HAxqJZtMpWIJUNpZEAOG9lkHmNqdL7fV7dm+ +Z6tJop9eRU+8R2rpS9WkoasUxRNoheSE9tjbS1bA1u0C5GKLUJivdf6BAFPz9NYDQmMlg0l7PtZB +HwsKldo/76umF/9WqKI3rPLUt0ampGwM3lw9IM7ofCE9AUobkbWu9CqirKgS04rAJ1K6NOcM0Ivf +I2IEWMFAnqFRVQfniAw6HdN0V6unXXvsck1/SbTqMh/iDwCz9N+vFQa1yxl/A59lPWxe7O+nF34k +BOnqS0JVIanE5KmsegQw09/PUWftJplIyaEwk8xZL/tVCv2MoUL9+O6AqPsObn9hQEwAq4HFuzV/ +7W1hcXADkhbt8u5vCjVryqk8Uz+xjzZ1T9/+v0KnD6d0Q6cNJf09bAGH57IFPCe0nhvEo9pPkj30 ++ztIXwEWyunbM37AuBx0fzWeAiWOxtD5dRqUk/s74JVitZdNpkvicLscM1yH2NgRQLaBw2SiGIEf +Y0tl4B8H08i1+RFuW4+g9g8jjyQTH3FfPeX8ErYzbSC+lJ57wObiXOgW+sh1w9qmS71ob1eUMJoT +RUZTOxEf7F/UyDBdc4Z0FrjLVxo0E+foJ0RBqpKflcM20wZuz/VJULnwNWi3qbyiilx1K1mQZpRu +KZcDF/bQZEaRxTi4zDAKPksplOAj4qR0sEEGyQYNoBySs2pEC941qH3zW/U1MzNikGEltmQJTf+x +0EsffZfUrzBct3n9PNr8luCnv00ItW1sGG59UkqDuObAB9SExzpo9BmyZKXbK+ov7RbR4CNCG927 +XOi4DoiYT6eS6QNO53U+1hwQxzmGQPXQh+uIv1r/TB/eLPg378qghUPMiFI8LiuKOJ7LTIFDGM+k +Ulwj5pFYok40CCHGDYxzt1B7LdndWuyC0NufIH5t1/v1zYx7EWe6E6K9M+ivjKAs0OlrSbu2J1Kx +rRS/S0osJ4+Dr5tEZToFeJ5PJDiz09u3eHpxxvpVbASsuiuTpsFvC8yIDkJkk5JNbyglKaprfi7E +0Sh8l77/B6SrzvScMll6vgpMy8m1pIneK5O6CC7osmhFLiFCx5RkUpN+4Ge+XmvxWPrQm6SDFqjQ +Qu8LEH87OOeyQWJDC4WSCSo9BcM21pPGKhZKytqa/YGBcirJEhMMIaQ4PmcxBGx5PJlCXTTDVp/h +dsGOzWHHuzrtAZl8Fos0gLIY+BrpkFPrRaPgu3Oz4JwJooP8rYDq5Dg3bCWmtFPDPStKbSwr5RXZ +DSLHRwL35yvlD1PhatJW4IJlcmKRVxspoaHZ99mMkkTG+HgsesAWxhiAG2yqg3QrA/G2iCodkO0B +Hv5cKfO2N9iYFxTPqYFuH+PFEFtkgK/NPfYO+vBLpHav6wnApSPWFU/8Dtlee3agUdv9duX8hoDB +5cIHaH+WX0CnmL/GGVlknpk0jl4bV5eg+4bFpCpyf26QO3R6XKCoXI/5jGnR/Q1xBAzTls0eXy2w +J0czlc5BqI67WZmTIQSKA0EMiJE3lRAyuI2/w3SaQpjCPGQ0IKbtA8waUuXErGF8MfbXnr67ITqO +IJdcS9f6wOeia9moiGkYreVXvhrksRg4A/Shp4RebwbQxdejLQEiam/cWUdmZuj5R4U+MHtLtOb+ +CnTz0f32aycO17PsA0MqShb9Xk5o1h5bXtkg5YDMsAdOxlU7yYAmqpUFXZ2ELH2i+5wRm+SGwuFw +sRxYOoa/8FFUTK+l7bLZVBK41kjLqAiwNv19XyMXgNiAqObycpjet0/o8ruwB2/BQzQa7YzW2hfv +aqA/b/O00kKd0LLCnGFcSilymCVymDDo0zDi0GCd4BsA2yOjrBQtUO4N+vos6dUOLG+jn7tGqG92 +c4v2xjf91Q4OeXKgtYDJH3ECM43JuJjKHMIUDstTMn6Pg+sxITMhMROSEAUlMcMDcpBm7lIyIYuM +OkMcpIhb0EYyuRy6VCzWzqP4bB+N7dl00+jWLTtEJtJc6g4BpWCQBCTIq5MZeMAFU+Ucw4FJRIrI +H8/D/Gn6zg1kSavb8IW9WpMa2PERmQvQzydXUSmZjIBsXq2ziSmklXTjGeK9uqS8gWGYx82iwf8n +tGM2ZqXbGpQxsfThoODvLiPZjLPAk156I6B+cz6HrMxzzcBKKsTTSIdkziAgmjsgCseukevjdlXk +oFuumk+PZsAeGXCGuCceiKfAS3a7HYq25jP+wh7QG3oAzJSnsQjflbgXY2QIOQEEnIP52NxwgCc5 +xuHn5tAkDTdmSHqHSbLStXYnW5vdX7d4s65b8UjOtNo2w4gbDl+pHY7k0yh1ZQxy/8exyL2lLLK5 +yixteUvwBRK60gP4DARFskk6/SDxe23u/affQzf3WAuo8rp5VSymoMzXNKG/jT7Q4GmgYZ/Q02qs +FTH0a0i7cK5Hu+7OygNXbKGZKTVJ6npmrJNJxxjXhCyQwPBOXyN0Lqz/6FEqNDHz2jdfmgL1cHhY +a9m/uZcNK83pQN7TP9w/7deO39HhtfSz9uW7Outsmlo79XgXfeKMsMZRjzj913fUCPTou2Agnzz2 +jyw5KwS17LFgrako6bE1nq7TX7uzS9CeeLwVp1hmGt9dd4nGyw30nu/AN7841qN5Pj/LZqJ33ysE +veZE4dNHP7+yBbNtBhJjto1jgQmzbZ1Ic3QOEjLmBXPMHCImhrVTr/l7QAG44lgb1rSNgAZ3IrvG +UB3o01XrT+h3lwjBNvsS3O9LYOJy1ZX5iRi4dcIr5ZPlOII5KG+/KzTSgW8L9RDWBeb3Ly+uqWAJ +1M4AfNjzlz1Fc9TwmC7iAy94oQCtjjGbdvsDFV4r94XIEUJ00/8Uun0mJiztOqy982f+3nE7HfRd +W0ZBO5VsR4A60E2sLrh9HT05r2fdkXD93NU96jbU+1ArpxJiWlYjozw7zM0zy44oKiYagYtBl6AH +AJNg/M9ytCIoLJH5J4Mb+CtjUg6UVS5SZE/1Qo2OJ4NcMVawgRdZbt70I+nJGz2NjI2b+X5B4HU+ +pX9yivRpz53xnX7yqzsq9gD4fOPitn379qxlAJmZTHE8lVcmTf2nOJ15HJqQUSMxu6Tngs+tFtYZ +1VOegUEGRcc/Uk5ygFz0vogQpvf3eZrpxYcEke4JC630joRQg57WtrUcEFkxEchqqANg58DpQWxa +ICOIHOU4DkiyUtGpYapxrw2vTkgdWO/vF0NTGxFgWQmG2A6K3KQB0VbZKeKdGHhG2smzvuogc4ll +emKLp4OurhbaaOtTPA2jNR+spDedFZpbbuIluIT5Lk3LpFure6GR3v4FYZd2zwOR0y8+GPQ2OYAE +ZXZfnycAUYWXPhkQGkKYRWOwlsxa214LHhB8GnmhHVTqirl0WJCF03/+jdsK9Fv9Qo3W8EDTinm9 +KmAoUBHgxmw6CoQDStXT2xVh/dzGlcLhG+hTd4PUPpaHJ2peuGquXRHOCr1lsbVtLe72Q1X4nPVi +N9tDGaMx90peuLVZe/q12hEejhgcVkQfl7CasGOmPMTS5dcN0/P9QmbuhS8I112tHXu/kzZcEmqa +XNijLa8IAZra4mnVTv6mhsaeEGrnVjwh3FhBH68AP/Zv/o/QTNf9pyDWMoc3w4pIH/SwqRqdU2HM +0UGf+wzowbfbPJUY3zTQjetI3dyPnhG2ftI1Go1KJWMeOv11oc2nF58cu6K7zwqBgIt9shlWG8Ng +q53XsXjeUq+RYAACQKZ4qwK4ABNpOTEgsjKN7K4Ki1Py1BjgDWt2W1DZcT8EBFuVJsQDspxFweT1 +Pmw8YFG+Mimh2h2DICZzSMynQSR1bRHxag9f7viE2L9KBzISBy8uGl3n3MIGoN5sERdrxw93eWMY +zWEwOcC86Lmu94RVgjbwfg1DeLP7nbmNl4Su3YJCf/MpsrKUpXm+0tNOe2OkZu6ebeSXYGqOVqyw ++iKAudwdF/gtq5uBwaXia0LFXGEvWdK0mCUoLPHFub1j5EeBlRm9xQU7V1CbogoeWmtEkkboqNDj +BfK/6UMrPR39mI1esM4VpZ8LeQJ/yCok8VgecDxs1CPmqz3aX16nv+x6d4F6q32G2+wzzHq9VqHM +Xm+NZxJylI+yFcFMmwe8B/I0uMbG8BCM5XNp7djLvlZbUZQDOUsvLPcsw+ahEa7zMXZjVuGPRjdh +BH7TzWxSZVhkxARMQ3iliKNHANNTWxEidO/iueQU+MVp1erC0E41dAth7fxLvc3bd4f1RfU196zw +hAo4bUQaU8zqIGx52a1AXthxaCSFzvBtXjmdn9LN7T7TYPGt7YtnQ3vl8T1qbt2+kT3ci9gQHuDP +Uor5bOeo9WwWW36yKZyxu8SUZtuNdv62pfVmr4fZZfPOpNBNj82SzsIo+IvRKIJgFEoxW8Lr9qU6 +d8xmEsM5GnBoWX06gHpx06XmmW/Wa/2fpeUwwl2wtmqFNTwtZ7MD9I5ZsmTeHZcs97Cl7BNfwZ6L +J4wvMKNr16a353DOF8ACpiLrMB7Rh9PPzZLueTdeLmJY/E4XnIE+OULqJ3SInO6F/uWMAS8qWG7d +nchYfHWdrv+msGRhDi9Tv9fpw5yEK8aAa7KryszmorOtU+fKodb7OT4GqO4Z2t3w2fpKPgKA+tsf +C0TnHDtKIZHbbYb23AJs4lYLze79MPdpNUbU8/O3M7qk518QOrSTj1S1lXjBDJAxAu5udu/+970i +jPpF1VITWSyu4lhyI6PWRAa9apVH7ORDSxCP9q/yrPhk0WMXWZTJvJoAeBazWJCK9aS2tfRS/ezh +p+YxEUZ+11GymUdLLszL5bLTXD8tnp/nmafdMZGxp1kvPftnZDn97V+T6u3xnKTKYdHmRVj70PEJ +odQqzD9tW3t9TpqS90g5xZxXjwzgOf30CRKoQA+Crv0s+VRaz2Ho1lcv4ClG9jkng0QpqJEx+o7z +tq1kBjE9HhF3sf5VyagGxo+A/EXs67m7G9cx74NsCNPZzxJxFVDMaPRhHmCZjRmMMsrRC/ucXMsw +6x6vP8NiFqwaCpekjjO3w4Ok1AxpvBrfNyIohBk7M1hRzAiJmPCFWcTC0uLhMH3kRs9SOnSTUBlG +U51MF23GiHRdW1lReiuOuHhyLX17K2kvlAK75DvOIWZfLwZpMQkjNAdGLDbzsoqWmfRW0lJWmczo +7ZzJUSC8xJudkfC8zmuUt4wYD8y2go008VSe2e8do7yRD0sQNp41YKWjnyX9jTq8unvLWOMGl29b +jMEr5JnC74FnyszjQj+fsAJnZJFqo5ngt/q/mPJhWa6VisjxYDZLMexDOJhJT8RYgqMEXCx7wqCB +IGORgOt/Wz3m/3TcS1KKFsuODJnF3xk1pcyI8L8ILh07KKXyst4KDzSNcUng+6qzlQMt74Cn7kDn +yYClwUPJNOh/sDjwP1w/l0mJiQxEX9g+xl5l+kXXI1mmuQAjpu2fd++seufa/PoFdm8Kh00XmyVN +vi/69jNCVbWRDDc2NuHmJ2Adh9k1HPTF8lHQld3laQsGQpC+eZSI1mGIdquixLL8BkPRR58SOujS +NlJNvzhL2lqLQaTNs8Tft0htWKRAdCqaQYyRP2MZkP1rPU30S78Wmujt3xG89NkJ4Qq7LujT1cTb +ggWflGrroKS7Z0k7vRQgdd2OWppj56GwFpz20S/PkqYDJQiTSRenm69MSkpPQdf0Cm0fscGE3vsM +qSZpJipdqfJbcxF1PwjUHv2wB1cX8mHQv7qu3br7ej2/eaWCUo4JMA92nZo5IKexCKojQz/eEity +zceluBrq41/vBVHamk7IiT7kj74FmAmkhfX5YetiI1uPJXTxD2yCr2R/cT755ypSg5WlCsz+0WO/ +BvR8HJbbWMRyaFvM6qjuOi4ym1CG7fhUH53nigq1Reabyl8lv6BfLZDX5+4qkD/tG3HTxjz05uiX +NvNFGzbwKfXXMnk1m9feGuko6F8w157tnk2CKHC+UVSNKjvSiAJA2U7nZUWVE/MMjetjFVXKzT9S +H2jk/cuOHJfA93ZMNFf352RXzSorO7mQY0FXz5DALWX9RPaq3T208xbITkjJMxZl+VRZKRIjUAk9 +hS2yUee3Gqxzcg6bgMDTBt8L05Mpw1Tq6WJ1EgZMTIqZXHIimeZ13CEQLUsdlDwHolt0s3Iqzsxs +c4zkOOPDym+mZGSDZXu/qx7Np2PFbnst318SOHpuBwlWxjF9St/dQXpqrSfSE8QfNjfhDvrss2Gt +l9dvLq7zVLSWACabZbU4Vj1YugCC6FeeIN2dzs3bzDaq9ELJLdswaPzMzDjH6XK28MgigXO8MmC+ +E7S/xOTath1+zEUTXuj42JTwbQ9a+CqTrXSThJ2vsd4yMjsMv7c68csn4u8aStlxfMbZd429l4Yp +LQ6A6MlvCL6GUtxYRcXvEl9bMc74kdeCO0MZAUUNf8WY8CupZFzmJUVb1w2bi9HVAF9/aFkbBMHu +X5g7ZBWSKBYa+AY7iqWYg0/P+YmvmXVUsarGet559qd1fQU2x4CoHFGi0X3SRDTKVgAHPgOswxcy +UcST8GbflW0XIcc441wFqwHjguEyz+PqNYcHOExFKEmmbU6EmRviCdAPvks66mxIoxcDxBdcHGGb +XLKkrXuvxyStJzTD2tc6hky+czfkuMWecTzrM/Fjpy498Szxa+v/obEilclktTW/CMyjTxaUWmNg +FAZeufzwnmLj9AVC5rv/VRLwWjPR1c8InRvKnQC0NEEa9xguUkecuVhjiW2B9k6L0WxQ4zd0+jXi +x8OW/LFxipF1+LQX8zmntnQOe371uVdj7zOTORdddOWVk9l5/9DNcpyfkqXTrwo+dFTpG9eSisax +FCbasOMEHV12CIWeOCtUVHKn5sL7y3Ds1bi+ytxaawMcJjeWB8R+vjSD83eCS2wg0PdbQW+vE5bQ +e38sVNLmSlLlWQcYkz7oYhgbKMZYiQqqvhXEQ7dzWtzpIJhF7KJDjBhD2SkndqwrAn5ESMcsnm7H +STq6LByaL6/TiUKFfxd8NHtOqKkBTLCB9NRWgz8A5qVOclndo0YRCo2FdvG39QjcUiAgC3rimZwc +jU7JU9Eoa/40B58TunDqwfIKV6fOrQaokcht5mvz6Ol+tjQbSS9XkWa2Jwws8L+bIc6y2mv1QjJG +DumEOCaDVknwFocx1kvJDzbzBqWccfxZntJbHtBvBIFWlHyOBqtI239n6Qx0G0QHlmB9RnbrTb// +b05QAkzy6GM/EypbilwQevKssLwao51kOm8eFgu6sFEcLpi+GvpyQyXH6uGCqSvYqQNLWX71dqH6 +hut5YxtvL8qoyfEjEOXlFHWYZzV5Q78+IWutltP82g6jAS2ezAK5MVTTjl8OtFqYMN7CiLbj96Mv +UHYC5Wnc6aKxoU/mo3GXSyMh5RpKkLdYdy1A45Cdxu2GhPVbUzvKdS7ty5T70nI8odPZFAGmUniL +pstHsG610Kb7Azhui5HWYOMWldMY1dcdyUxB3AcL9+nCAagNlPZn6AWFtFXrp1bY6FIpDqCPK8XB +DHolTwE50h6I+6X94ZDbnXIHENiAff9LpLPRmbe6EkfqqhLBS7mAxeE/bzfoZUyso76I5cH9D87v +HsG0YX02RzSEP0UipcWy4XrurunS/v4OsuQ687lDXy3Wxwpr75xdqmdrGL/F1JQSQvTxpDgvF+Ch +Avov/QJHQEuR088QOuxI7royU3wFq0tXdq5BpxOoID9fjSdRKzqsyMgUBstRvmFB+pZjn2JtyyKL +TYsIYuJSOi4DnxR59CzEoGuCQlcY65JM4USthiumwlh0wj5wn0577mWfrN9LUhy7OPCGgYzCJjO6 +F5yPk2k1Y98uGxSBNzBVJK7Xjn/P32HA2ucap739Y39h3gjJjgS8sQpPY7EuyGwuk8jHQRFlJXVS +YZ3HzGUYtk5yK/rNP8bBebQ7/LA+62dGfRDxin/A0Tu/gtLjxbQ0JUNErKg5816BwgLq0Hmg19CJ +8NzsMwOKuNdkw+yXC/AquO2AD4cerMD2+UNMDvMAbPhmLC7xNBq31zZaWHpwL+t44OrTHUWXDiit +UBrZTl+n6Hz+tcGSYmA2jBueBD99iFrQONB/IS50MKHH4wkLGp87XmhfUh4f9L6XSEfUPLpTjhAm +eG4K0DWS0Bbdy6r1/PDhwaSSxOsEjDmLzpNJubEkEDZ3BK+p0abjXVcVGVnXIhAPGc16eElCD7tW +QfvyUAvN/pT0NEZwKfNWBbrnOcFXK/bfyvB/Gz0vkHY8tFoVmxGxcv7YXqGTpp4ibUamebFp90Wk +ecraSG7P0EIyRmOj6Ot+UvkZvQ2Ce3+clkYhlrdEyLrjz4va4nYVr/fhzDXET+GhvPMYgF/hoIJz +g3iM0GN9xF9gZ9sMJmWlxnJg2hxK8zBVyYG6u4WjzKC4KAOlj20pPjbyzj/ymMB2Nm3PpS469Cyp +rmCqW3wG3JHm/opeLATnswlJRbsvTSihGfYLZAF/0dvayQo8GovnygMGOaQxKZ0AqwbLKcmEdvz1 +DvrCeZjv6btbCpYRM5DkyvDNR38WoVmMbmtKsR1E5zGhfm4SRmZAiU6wDgZQxCl2jt1MryMvSaoI +ijnjOB+y2Jx5aUNqCB56MrT5alLRNQ/Tave+3tlubxW1FX3MaygqwrYCgmNwEdaYalu+mA0wzVEw +LqjDTnQz9uGGPcX7PuzHf4atOgQWJhDLDJmGxIxhYSIZP3DEWY4sL4r0J37Syo/ePfouaQgumKGj +bzxLegatPem9wcUZHBtvr74zEOBId0siPVlN2j95JZLlkBp6Iij45gsDKvD4u/Z8wkfvo0JNx4Kc +ssII8BhI5fwrbehOf+98yVRQ088ESM/cLX9D/qLax08GWdKCJSu7896un4JjaQt4pvDzYHi6y2II +3ZYwak9krEu6QHNK8JWrQcwusqhdGcqYnA3CY3EE1eYQk0XUnQeMq+Ck+HQ+CdMCx/Fjwig3eJMY +O3oG1spyNnBLTlHgX+nSpdfDXGUPIOTcxVPkl3X0w2cInneqripRC0CrTr/+9+SOubFnyLm6uemz +5H9UaScuVWi1D9RV2YJ0TCrstowH3u9j2YNDeBqNf0YsMcswrLt/OZldhmbrfLECmuOXA2YuxVi0 +WIUbGZFqTCLDxvEMU7NbWGjw10KABckwmp77nlBbpWe2W16BIL7qBtIYtUVKCwZK9tNWyQQ97/P4 +2ekoxMM2xIPxnu0CBNZJxjoIWQANDDLMPvOTkCzmgKhDPz2EsZYdAVV04/eFFu21v2ylJ7d4amn6 +74hvbuurZKwWMdOF4OCZFGC+8eSEQ73hBSJL8NBdFf3Wz8g1GEbPXfgZ+QrBllg8/8iuG0QesU7c +MLZn8CRs4GKr0iHETZwT0ghsGV8ziPNZPCO1GXnVtCyo3dmld3hB4KEkMEE+zU6DsqNWvIjM2yZF +yThCJWvv/JLd5ISGeJAn1c4KFdrgW7VETWkbfnAtZmLwT+nH7fWsM2tGZL/oqVtIO519lZ3SbWU9 +xnNH/4UIFb3OktqkpMT4BnkeBeuWg0zV8G/1gN+8Ak9SDsSAYdOq2X5Mh14hfpr9OdlEZy6UFyHa +/HNSSV/+O9JF171CauZe+zm5LNCZe0ndMsYREo+YjN5T0AlyTgZlxwWctjwAL277V/JD+if/SuqD +wVBcPTxfNo1uugbWxLErgqGgbXCxV8/vD218kxxj13mA/R9TsOTOeQgxhGQDdRXXO9KOpDJSgt+0 +YVJXv4wQwkzGEsBLgE77GVPdUiAkZRgUhDB+DoC+903SjzfzzP39m+R8Jf3bi6RRCyUbm8DxsrYa +8tKlZ4RevaEYwj0zQOCNDqbAv/NL4uN3iDpFWOHOFB8NhkNNSqkY3XRGaB9kgRX2iuzMAJLWrYxt +GPCyNogdyl7WJ8NbJrgbRm84KywRS586tG4Opb/dSJYX+JktcfcBPYLSswfDRuA8uun6rftuifKz +iPazhZOZVMJxRLHM0cRhXb3yA4b6LVMwcZLdyltwdjGrVqsziC64AcCDKKSDXPx0eyalj+jtq6wI +kMnpNMXIw1jcdhnpfIcZ/8g4zThszmCw+3qxfOTCQnLzTJd5rY51yosee4t0NTOLE0YeC7I/6fNn +hG6yfoM29IQ/aPb48M52NgAcpfHYRB58bozBWBvbl94iTW0pJbTouYyxJeZ67S+EJnrvDKkv6Pu1 +xJTTNhQ/rAe+rLxmdD/p+YOFDrozf8zF0uGSrxacMRTPHdjyzixTGLYjW89/8PQFL5HrjxeVErHF +ykjVgjP6HxAd++ZZDB1DRr7EiRo98dw3X4KEX1XNpBgvGdHlGdsQIgXHDoCm5s0vY/nxcS6l+gvY +qMyubYzxR3Y47GHXfN2g/M0Ir68heCM8Q+NkAXejTlHnq+limynxrtbiVAr7PgoKhRd3Zr1eNG/6 +AQnbnaygOl28Ekswt+dUnvjaS2hR3C3delYQP7GQatMvRdZVuXEwmz4yQ3yF360icyizxeiy5GKV +2UdUaJY+o+d3En9hHiVmmL+FpNqVYnNmx+drxIVltDN3N9G/ukhaljrT4Zz+btNJv5MRfPe/TSq7 +udIwewYddo8+eg8J0G0XSTONXuVZid1RdVVcoV2B5aP5d4XWwn+ZoSvNG4X/MkNX2s5dv5ChQ3Nj +brdUUyQrl9Cpd4Ulhdny6rhUzrJYc7jUsOkN6sqytCkxp77GHO9MIJq7M6NvQ4vBkLk7/4NIlbWx +dCY2jqey6P96h1y+imluLIYlZONShvVihjXoKhHng7mf/IrEW/ntAsvK3S4wJ1d6vmDeam81OOmN +LbwDmGcxMJ1Ij9V5VvsdqQ5jKP3gUxBD3FnnGXJ3U9H2es8yek+dZ3lHOUm2hrSXKStRf71nBRvh +L6IchiLW87JZEmuROlsuyXxxxdx/eD2/qawxsEhbniK+eoOmaGPmftrsWdck7QG1I2FCHELxI1im +TSUxKAMvngVTJf5JB8kIC0cRVLy4wdZzb1y3mkJS4k0sR2ksRXbSXC+onZ+kMIMX9LTTH6SIT/DS +lucEsXoNd8Tp00HPJu3MPc20boo0tYbtPiAzzLSnjSxZDQaPfWKt4uwvqxl8ay7HUz7s4VFz2mV0 +/4OwMl5uyNK6rfpFIDo6MAVEn/0HEmQXUTYOVu82zl/Lh+MyY0cRwkbWwyIrVmbDOCo2bLbLiyBS +mKZS7LeDZpNUavG0sQ6tjdd4Ku7/GvFpp19sYTGt9Bppo8vqhAB9Mehpo0O9nib+8fKLpEk7+cUK +HOXB24Sf7xLatHsP9/ThfUUQakE4ygI0do+0HrHijfJ4d9iabn8Br+ZjXxvHFsdBxTlb8GEmSdHV +pRyDmDyfZueRhl0a0Uo/8WuFEnJKOqLAL/6vsQB+ioK9REsRiu9/nKxgDYSw01b6q/8UAtXoOscz +ee2Rl9sYNj58XKgsRZx/+xrBSyf9pZ4FHiLL2bR4xcu1BmYOwcZ0NsVEBlYf2S6GbLm5LP7jBcj7 +E/plzfTcD4XKlUkF/7kZds8gy4lgPtg6+GeofnaDC836Pe1VCRl9SHpHj6dDmxsIYBm8WtvzlYpK +3ltybMDjW+6yfuP5VOqI4XomFQ4ljYqek3OePs8nhS5MThiiz28rse5C2b3M00v39Xk2G5dMmdcC +GUE1v4kQiOi+g5Ce6vNc9dFe65xrXuZ5fNX/B6TvGmblAcxxeJxbvpN/3k7+hhbGFqYtzCvKtm8s +Y/6WCgBmRwly5AIieJybt5P/8jb+DUx+zYL+7YL+jNsF/ZkkTCZ7BnO3FzQzbS9oZtaLBADvogwZ +9jK+2O0qJ4FuUa3y1FCq5Q6EfiEWbXicXVI9aBRBFAZDBGORIIKIVzwtzCyEvTQiXoy/lQiKeEi6 +vcns2+xkZ3eWmdk7Lm683koYsLe3UK4UoomFiI3YWQk2NoKdjY2ze/HOzTSzO+973/e+997Xvbmn +7+dePS8tlyftn9dn7I900b7catnF7YXxh/LXjXnBs0Tb3tuz4xN734+N2m3oxggMleERZ9SgBuMe +ckQFGjMDVLkwzUIeVsEOIGUxVCzAJ1CZobupWYDD4zg3Lq1eCViMLAm41gWGQBnD3OgVl5og3JMh +Lmu42Q3DO1Vc3Y4pz7ry/uY2sgYT0Yq1mRrmRh5eAZNpKjOfMc+fIgUaYBUHrINN9i9fWGuE0sI0 +TDxCdtW+eHd6dM3hSaH5DnY6kZIpqTrhcx1khRDE83zfmxJVx09pTkpeQhTxTkcnQe20T0WBpNZf +Ae4dSTE0wWAQc4GknBZRwnn3nU5+/hNspjIphGsI8WZ2aqLa1EOZIuGeczCz5nODinh+LjU3XGak +vDiTtA/enBsJqk1QueyBCwD2UQ1nBPW4Be8fWQk5yNwMN4fQ01oEuVG9Zd2o1E1Ko9ZOEYhUNTLY +KqgKex5E7qFalEEsBc47LSHss1st+/vTqY2psFuMf4U5R+uwCrtTgV0PHjfUKvf1XqmmeYWp7Fc9 +WbM/968fn0Bs++CJ/fh5yd79sjT+drDT+gtR7wwU+APLiUJsozWnt5+Cj5HePjiFJzsCIXicATgA +x//nC+cLkJMUs3C2hLNM/1TISO1/Of2oOGX+aPeRp5YUanWJZD/RNWhzQ2pM9wEAqgPLeTyzUQGW +BDkYGqr4CH3kwoh9qUErTRm3/yUDQi20soGReJz7cZB5yWHmDXGOTvr6Co4KxSWJOakKaZlAoiQz +N7VIITkxD8gtSlUozwAJAnmleTmZuZklqSkKqXklRZUKmcUKicklmWWpepMbGyX4FcGieiDdxQWp +yZMnLhWb7OgkyaSmNjnB0QLIFJ1c0cM3eYMqy+QDThyT5XO5N+9ztJoPAGuwMeH9EeznY8cfkYbq +EV3le7i7R5WlvSU2eJwdjjFLA0EQhdkmQoQUEiysJp2K3IltsEpnaWtx7u3NJettds6dXc5CFP+B +cMXV4h8QFNLFzsLGf2FjY2vnXqYYmDcf772Ht8HnavBSr+/TNIVz9FJbQOfIgfTe6Tx4TRaahTYI +yhBrOwcJZTyPQFtlQtErZDEyxAiGZDGEOL1fKSNXQI4lOQS8QbWxS2BmelZJY3KpKoZlmLAHSx4c +clgiaM/gkeOOTRZEFSfd00yMd3CubdbHZx6lK6ix7aPbbd8vR+MJoymT+HbBZoaoPpgO24/vw72N +3kjrOWtkhaGG01jNME6751ScdRfH4qT9+druflmMXu/Wt1erv32xdf0PbzZqKqcYeJwzNDAwMzFR +cEksSfVITUxJLQrJzE0t0isqZng/42K2ZKpOlDZLYsDREyVtZ/g+fjSEqHYtS80r8cnPL3BJzUms +9M3PyyzJB+uJWhUjYrqnXuTze3br+uup3CllcxShejxzc1NTMoHW+CdlpSaXgFT7CE3KYUptWB7X +Jh4cIaTekBupJwRVDXJFfmkJQm2Va8bsjZHGd1f1a02cqNPe0njZTBVJbZFeUmZeil5JMYPR+q5j +OSdtX30y/y8/L/TfjQJWwQsoCoGGdUnnm2yM75rRvyyv+IntHDNx4T83oWrCQ9zgynbfkZqjLX7d +rXG+vF+3S/fpk6dM06HKcvNTQCrmzOmaOfVjQmdDztsMoeYQZt734SJQFSUgU+LzwR6Iz8wrSS3K +S8wpBml6Gibs8nPdu11TC36d2bvh4//kGXyeAE2Yl632Ax2h+DmUy17NZs7LLyAlUZ/jzVyXeJzr +5t/NPyGQ3TknPzlbR2FjoAmjgAIQJIP4Vgpg4cn1jOc44YKbnZk8WAHHbRBZ+gI1M2Hdnz5qgkZR +RTG3m5epwB9Dvnicu87fIrAhnpEnsbgyLzk+Iz8/uzh+sh/jFhSBzf8Yb7ICAFlgEMnwAYFZ1pou +b02fHYjwetyrCTA7C7Q7eJy7IPBEYMND1sl+rC6bBdnsmQA7EAWg8x8/QzMpCFnvObaXjrWv1WBN +kBrW1nic+/qL8e8/xg1zFCwUoCAntUQhsbgyLzk+Iz8/uzg+M0XBViExJ0cvL7WiJB5VRkPTmmuS +Xv9kbcWLPMgyk//rSW5mVfrHaEiyqZPnqiVPjldx40NVPdlav2XyWiWhzbqq5WSYunmuGjczhhMn +syqJbj6mmcNMnjM39+k2MqIYuvm/3lorQ5JDcfPKzPdoBvVk+3JOTpPn88xLLccIdAVdO4U0MxOF +ai6Yu0syc1OL4oHmx+eWlmhoYrNlcnWl5Oa7JTM4AFEutSv3AgU+nFgsuHO6E7BNRr6gCFovRbG9 +eJw7nPwmecNbHSkFIMgsjk8pTY0vz0jNi89MyUm1UkhLzCnefE/nKQsARL0QBvwk1AYrvN1KrNys +YUMygGeeKqZrl3t4nJt0nvnjVeYNq4R4Eosr85LjM/Lzs4vjN08UKmWZ7DhBdPIGcRbm5AodODsz +Bc7mR9aBJM6anZmH4E0+K8TBiOC9QeZxJRall+am5pUUw4XYknPyk7MhXH9x1cn2POz6JZm5qUXx ++UlZqckl8Zl5JalFeYk5xVZWqbmZJfHIjoAonHxfTGryb3HFyX/FOEHmYHMnG9iNXJPtxZU3l4jr +2k/+FcY9uT+MlRtJ7ebJYX6sAjmJxSiWbD4bLcs8+bsjn2ReagWq9ZkpGmq5pSUKkzc+Fq9Pzs8r +LlHwdYyID3Z0c4339AtxdXcNslIoNTNRsFXQMFSwsVEwNdZU0FUwtOZSgILi1Jw0PXQbgeYCdWSm +4ZG1xbBIQKEabioIGE2+u1BuckE2qzM2A7QVDOGqawk7Z/K9uHTORw0zSxTKixILJk98LLI5Id6o +AwCgEs09/40BNMLyt0dkc5SQDe7a/XVyNGEDswN4nJ1WTWwbRRRWEse1tyFp4sR22xAmAVW71WIS +3IbWdpO4TWh+TJLGAVRBtaztcbvNetfaXQeiYHxAlSJOJK+qWkRpi8SpgFr2AESqUBAHBBKo4opo +LxxAQuKEhBA/M/5JvFu7QdmD5X0z733v+743Y69eb/pmvelWtHmvqC8pSeGcqi7ogpQKoRNYliO5 +wUNDZrh5vMGRVjUMq07UeHgQTOcMc4QLM4yUycpo7eVOE+1KNTzJIPKkFZSUsagJSVGWE2JygT2g +YznNI0PKYC2EJuMviHIO89Cy4off/D6IeXrhb48XFo+yvrOymhBlvrIpFJp+PhbjePidrAe6HoM3 +tA54bmg3vIfd8NFQh7f2fhDjvoY85F3L3bVIhUIKfpXt58xfXX80P0t71sU0po0fzymCEKUp48UM +AWckY572HZPSOLlEiLFFkvQpYQtq4jxOGjBw8Bm4dtBZ2IIi0vGbm/EiVowQ2qptrTpGl0u7iax5 +hnn8JQ1nNTZ3hDvDYCWXeXgmWi6mkpUCVnPGhCIZ6BjqLxWcyGRwShINXA4PlMKjWDc0dYkEnuYp +YlJVdANF46enTwjjMzNTcWF0LD4/N3N6bLTIhWaiSAQNBonv2VyCTWqkJkdloyoJJaU7SvyLXgsS +AWQZcK/0QjLYuWD3YlOgBUkhr1Pkk2e4MpcdWBEQdSFraCzHM9A27NtjxSPBX4YfhY8v+viHahkK +WQSD21d6wtsk0GBZ9s2W8mU3zZ9aI41HrSKVWkqVDKhzPMqcyFx1FSqa0EfGBrISI8bQCgFrNHAW +GyyZpUqelLanHahtNuolk1MFiBB8OO+Cp9ZbCpVADbiq7QgFdIJtQ3u9NlpVh9s67qCWwz8rCO4M +e6bt7lY3sI1f5dHfyuHC8F1X0Iy2q30t1XXNa0Gukat/h1hXOHP98L/7A3qgrtVFjyvWCsY5SefM +m6fe8R2qn0H2lK8Ya16YgbtTk1BIXDV7zt/ZF9xBBRAveODe1Aj0vLnL7LvwaRjuX3QUshpelNSc +Luxkyuh0agRY1AycerACGcJ65SvT6K09jtDw1SXIetxrV1rhcmQPmsspVMy4QY5pwOI9bUFKwY0P +9ncq+DXDhsPC/e+9vI0EHVdiX9hSJ65mMI3SC6BtWlXw1tEOw0D0OLRv3II/8y1h2xAQmnUVWLYg +SGlYvXwMJt5vK74+4GDVJQq3Z7thQ+2GuQ0/3Jt1wfApp6tSFu7OesH5ZTu8fd0JnVIfnBnx99cy +i/Ksoz+hubYP5AE3jH/mhR8/aTV/3njXTfk9UmyDK/sPf012g+OtvfDFSeSkv/BYg8grfvg8truJ +3L3wdewJuMoHC+S7Tc9iQ//zZNTJtv2vsORU7c8zCH64OWKuf/ui4z9jDQUD9Q5VI94LG+NqVl8e +u0ts9t8owGGAkXicAeUAGv+hD6EPkGUUfkdbgg9iaaX33px9YZ8YvmWVcaixeZQBFP4i1JVGbUHp +MG3NLYRcz128/2l3kyECGDs8GLsGCdK4pQeK0YWXFihxxltFNzEwMDY0NCBGaWxlU2luay5ycwBk +4NZP3XDfw5OCZZgYBJ5zvnXNBZN0AtYUIckw4l0uRzXlp87tYt3EqV9NYF+TXgNmFHJuPUajgADf +qVPHkLTx42thuodrs9gDgAI06VmBklZcviBZ3dcqWPlNiqZG91A0MDAwMCBmZXRjaADSHa/xWlvj +gCv3QmoYsPR458p9YLOMBhUBkXxm8fkM0/+H0prPLqYKTn8pPMcrwxQi5C94nPuyRWjGNqGGLYy2 +FyalsUxe8I7VILGoKLEyPqk0LS21yMrKEcRzAnMcc3LykxNLMvPzfPNTUq2sXCtKUovyEqc7sjCL +Tw8wYRaaLvCZUWLaVEa+6XlLGXmmV05kFJp8YQfH9tkXGDNYocYbEm18UGleSWZuqv/0PBcW6ekK +3xkFEea/Z2Thbfe4xgjETNs9rjHrHAEAxaxMh/UFzTcMA7hDtLxaLEQH6RGjRixygNp4nJt/k2nP +LaYNHxPs9PUV/PJLMjLz0hUyixWKUhNTFDLzSvIVSjJSFZJK09JSixTy0xQSFQpKc3KAgoklCuWJ +xUCcWQLUojf5Q1n8ZMtuvs3/ExZ4AwCUQCG+8HB9sIFaGL2dbk7lvPlJZXZlQuXLJ3ichVRNbBtF +GJVDUgW7IQkNVUgTOiFKuhscJwjaok0TkhaoUEECUiohGq0nu7PxNrszy86sHTctrsSliAthkCy1 +UoFzKxSUQ29QDpXKnwQCIdpKiEO5cACuXBDfzDp2VEXCB9s78+373vfem7nzS8cff3ZsvNc9Uin5 +AUEYeepHlHyOuE9XEIsIJS7yWIywvCD63kDcif1IIChQe3mEqYsS6pI4i+AzOTmJiksJRYJwgSYm +fM4CLEgRpfi+4MhhURUxD3q5JAUDcJ/L77q/rm1BvKgb4BRFUTrALeQEjAMXRh3FkDTWUUxwEKry +mAg/Jm4e6ASEwwAsJDAJXVabXPhBADuV2BeC0IJmqxG5XfFFyVatOmyFufluz6gnx0WuVqGKxE6E +YW6OilHMHOhU4MJliSgCGaXG9mUSx2rZZQX0+v+LpKbS3YAwcKupcRU5vdHUAp6wQCF2lZ4F9BLx +BBJM1TTRPZ/iwD9LgKcvUIUlgYuWyJaCS1WtDbQKAuIIn1HkU90j9F0XGuhhA3xIkFh3TNUaedPx +lo2E+qvmol7waIrYElDrJ0eTGdlVe7C3HJpoBnESeIUz3C6HhvzhnanHfA+VwwLm9nKMo5LtMCrI +qjAav3L+7ID8+96A7Ld3S5rkxtLaxq6tRre5YBG3CY6DavO1nksDPfx+IuuH+uTH/7Q/oSngJRYL +uwQOwUCcCJvRoGpXMGTSFsxeIrYaRvae2ie/Sn6vnQQ5eIWQKJVb99weuxRIxTmEb8+PuZhO860k +aWzHaSICDNaFvhMzgfkKb9kEBrCKLglxtZFRlVBSmEPzQrc79TI0I1ChHvSZhHAEDc+9IOElFUVw +GQcVXFW8OFhNqPzsxwl54Xb7SGpeQjn2SMsykDE9LyGhoN6dvloeOTjhxEKQTPsMdyxrXil2TC2a +aE2jaCSYrlmy1qrJowXQ6DWCOaPnp5vlYPdwiIVTInzYcNLC1kuWdSw1cGEQXo6Ia7RALOs5n0cq +sab87d64/Pxarj4zm8k9VWiCB0SgBTDASKNmNKZcQ2Pj+g47b25LnvymTwN0TSopY+KhFbCXt4RN +KBiQHkLQKImJFjNO5OOPTMnaiY764GBmtwmBjEkADO8T0TjKVi2LkooRsjJB587JL/N79moaMxpf +5TgSsWFOZ+VbR/t71VoRlVjgqlsG+NSvHc6Ycm95WA7dzXW5jJLCMhGGqbBePWnI2Vvd9Y2uTKd8 +/9Nd8tm/svJI1PnBxsOydqNTXj4xKL/32vX/X/0peePnbP3085leeTF6SG+ohcUjGST//alTopu5 +B0xzevNK+eDILu0OklfXD2dfwaJk2CDlrNx/aX9bPis/+XBUfrv+6HG9mJ7lnc781jk0801vWlcG +ZSK9NsxF+cX6WJttysWNATn2dv/myqW5y/07XcUKtf7Rk5mh61cPZqbb5O2Lub6dauTczaEDLwCD +BVDTsnYIt6Es0OGWxVv75OmFYdl1t/P6nmcyx5/+D6oVe/fkBYd8eJx79Y71yDvWDfqirMWZednx +m/VFmRn5C0qK9BKL44GUhqamQu3kBWLimwvEbCQhaibri6pNjhR1nixq0MaNpLR5n8H2fQaMa9wA ++8Edv/QEtHF4am9OOaLMGVIfa7jxStb2G654nAFEALv/kQKRApCmOhV7OgMhFQajDNtHw2+x/+6v +faS/MTAwNjQ0IHByb2Nlc3MucnMAdF0Sc1oLNW1gkxvheCTVsWDw8xSR4DGBSxuY9wfBZu9KO97c +jFHGDeKAvcwycszAwnicO+q8yWXDXM5g5ejktHSN0rzMCs1YroLSJIXS4lSFpNK8+OKCxHIgWVls +ZVWQX5xZARFA4/g4Brm7BofEB7k6Bri6xDt7ePq4WE/eICixeQtnDxNvSGpxSUBiUYlTaWZOymYT +nomiAHPoK1rzHGhs/9nOWC8rK+0txs0+YafrYVXseJxlkM1LAlEUxVGqhUJFGH246BJCWjJa7WYR +Sh+rKLDaROA8Z6758Dmj895kbkqI/gFnYX9GIdauaB0JQYu2rYJW4aaWPSYlqLu5cO4P7jnnvR50 +z4OXm+0DkJNIJGDdFDZFDtQEreKggxqUmcNBI7qgR6gpsIa6jSU0BRpgmawGJC/QBlFAkKJdm+OA +x1QA5VC2uKQU9/4qNFYlQi+goUJaWCWq7y0vuRvtt2b9wjcQ/n9TVROr0WQs7j6dRNxwZLiVuX6c +GO+BSh7lzhLDiC7Gofmw4J9pTXf2A43KYCMz8IfiTu6XKr88T53u2g5CtUAZAjFr0rmNxJC2dSkZ +UCBcyj8ZuKCMgbC8JAqkvaRanjCOWtyLrBPGpFZyeJ+Wr/UiUMFBEF4Er0QlAL0pO7lRyJuynaxn +k5qH0ebHkH/S3focce++grN998wiRnTbNtCWjKruYGWVixisQNJ9vQ2dpbo3qa5vvvMNeCGjLfsB +F+JVqYRUA2hw2lP+kTS93U37ov94nDvEeIhxwjqROa4LGAwEFt/4L+MQp93sbjNRUGkVAJe8Cm2o +BHicMzQwMDMxUXBOLErP1yvJz81hCKmTKlbu9n8vtFzoxzf2Oad2/b4rbQhRlZOZpFdUzNDDa3rW +cJ6IpVn7k2777Gz2jTMeLQAAqdwbp/oNCR1an7lC/6j0cm1sTCwlb1cXqg94nHv7geXLF5YNMYG+ +CkCgr6+vEJKRqlCQmlqkXqyQnJNfnBqfl1+SmVapkJqXkpqiUAKUTcssKi5RyEjMSynOSMxO1eNS +gIIAoDZnkJ6UyQVhYpNr/YU21wWGRE1ekMoyuW61EAdMfvLU1aqCIDviUzKLk/Pz8lKTS1JTNh9c +vVxystwRjskKu00mK/TKTU64JTRZ76zo5IDrPJP5j/sB+byTHxzQRZgj8FB+8oQ7EpMdPrJPzu3T +mPzhidTkA7sMNj872l4EANuIV7j+BWuH/TToAPKzPfr1XjAy4Ga67wCreJwBXgCh//II8ggiMTAw +NjQ0IEFwcC5ycwAjL9Rxo9XXQu+LsoqQW7iEZX7wbZEi7BSRSCkupmhGz2zm4bzsYaERj1nTcrMi +AbYBFNLsmq76/LTUWWVjgRwMTTt0gbO+s+wChgG8JiwF+gpHaZ1qxpqX/WLvDQBSxEYZmVfzdHic +e3mZsfsq44av3PX6+gohGakKztraCsWZKakKmcUKiTnliZXF8Zl5OZl5qToKxfkK5ZklGfmlJQol +GUDp1LLUokqF5MScnNQihfTUkmKFTCDOL89TSM4vqFTITwMqS1UoAqoHkqnpmcUlRYklmfl5elwK +UKAcDTFbIy+VFWiYZuzmN9yvTQSQhCGilxzENQHMKT0x8gGbv6/Pr/9OkVR/kbXYLAs//2GX+nic +m7eAcdsCxg2VnpPXexpvnuLZxQYATzoH5/sUtbdy/LGjGKKtnh6aFmuF7sRYCTF4nAFLAbT+iw7m +DZAsDDAwNjQ0IEFHRU5UU5FdZxSvYW5R623+QxI9XLDkl3LyDt0Kt5HYXTbDGY1hWkQbG3asxVdp +mMd7YhlIBzQwMDAwIGJ1bmRsZXIAEdKzcyxej2INm+TJWUna7Rrb2zCTawExFDDPwtBJUEGdO6ys +uPXsVXIvB3X7k7ABWhTNg0VEqAgI9DtKMUXU7CWHEeWxdJMeArUUj8/V7wHd0t9jddm92V+bolmr +rNOT5wJBFH/hIQnKdDGNM+oJAHkD3YAc1h0UkzwDRBT4VBXTn4TzD35IHE2Em6YURrk4RZOUAzAU +/npXy4+4kHB52fO//MTS+8kmERWT2ANYFMAgPH0JuBcWAUys9ynGvIwIlWq+k0QEshTh+RnoihuV +0LenQCYIUpfRU2TEMpMKBb4UqpnR5rzr+Y9z+kSPO1+K8qoIaw+z3AUvAef8lKL9A5d0CUJTWn86 +YrfGWrX6+BaOjwZbeJwBPQDC/6eABKeABLDZbRQFzIFz8ZUWePGzJU3bKHZNA0jeAbPtbaqEFBmz +5K0Swp8WGp1hWviOdk+dAjT9s6vyfA1uRRzb/wGrI3vgsyOh/aOdT38rD5i/ElY2VHicu816m3WC +rMi0lL6sqYF+k1oYjF84zb1Sb/0ySm2j4SomANKYDT37BXnH3IlDoxd/LasRLV+Unzmdfyy3eJx7 +lLUre8M0QcXMvILSEt2SyoJUJR0FJV1dBN82Nz+lNCd1c4/gUxl1BYVobJLoejZn631nAwArOiGY +/2V1esRzhvgu3EIwRQQlJ2M1Mbn43nicdVTLbtRIFN0g1IMiwax4bLhjaVBZmEoTRRqpox4WURAL +2AAraFDK9u3u0pSrnPJ1OqgVWZpf6G9gj8R3sOArkPgBtlT50bED8ap8H+ec+6j6/95X9glGbwIt +SJ4iZCYtFUJJUkmSWIDQKRidIKysyHO0BVjMhNSQCKVErDCIgIUw/fcGuK9QhpgoPuikMcL6xmY9 +ul816I8a9EdbdJe7rvP8F3hYTkUwgeOtEUBmubEEL+pUFw+JRUH4Ek9KaZ3B4kIWhPaZMf8VERRk +Zf76Q46vEncgfyqgOoe5NRkE2qQ4aVQEBz2SxOiCuuKnoHHVErJAGGp1B+HlFKOQK7NgjZ/LNGox +eLKUKrWouUK9oGoZATklZt75bSN/gKiQXDUO9BRTJ2IuVIG/ilz6Op17UDdb9+KgQ2FFjomcS6xs +5LMJzyhyxZ1RCMME1+Y5bMMtTKfTtlm5oGUQ9nWRLQeyGkIqra6hL1C2nOHNYfz5Zrxzp+oK8gwO +djBW1kydZ0iCl1aFrK+mj1a3g6fYtYNdOaSuhKhm5FUsCtQicyPeFbtxEF6Z+LuVYkEj/lSoEieg +yyz2bYP9vYMg5FInqkx9VOe6BO9GXcEShfUNHfc9uTUJFgX3d44FMc6NxaMzSe6qzEudkDSa0VIW +k26h2oSokXJ5sH6sPhz+chNtQ0OgpTVPVvWaH1lrLAtW1uhFc9EtJuguqx32GVq5D6cN0cHm8c7t +7Qzf+sx3sKXgVqye+3lo92IMyhiA1kXu7/1qezweXzmOWkdUM/3jqVTLc2hKTUOuHsZx1B7PnXHz +ZcQ2P0ZPr8elVMQ2xzt3/+ScJybLpcJDk2Xu2dt8++PB3zA3KvWrHJf6SJ9eIDZ1W6Fd0ZuPOw+r +zoFnbv+Jrd1LlJqSJj6GN+fIOSUd+kWurd2fe7XkQgvVxtZnp5OTOTophepd7g6z9yrBuF6Mym/G +TPvLCfFM14/HTO/vwXimg2gLcCFgfGHs2HWpVL9Ng4LaMtDakGtDTtwLQcmS7b5Hv0K3ZvFu1uac ++zZ9vjP6fu0nFyn09vYSdRzomXDNTy7amnWgn7yQ5IPMJkF4nAEmAdn+jTGNMbBTARQ1pX7bfLZ7 +T1bMqZLO14SsK34UA7NnAZwBFMacpocT3Iw/DXS2M9FGcomsphZcsxcDZQEUQEDkwAmNqiJ7pZx9 +3DWg//nwuDKzkAQ6ARRzLFAnotZSy/cOZ5Y0ZLyW7mCgC7PeBVoCFKdks2p8N2/+akq7eb/gCW4N +3vMHk0wIihTspbtwLRtwSblUbgaGXzO4IM3G+LPqCIkBFEgCwucX6C9FT6JszbBANk6b761pkzEL +E7OaCpYBFEmMuWfhg8Mqns6F+zPYC/M5e7V4s0QMRggU8El8X+xALM8QCV58oE0O01kVG9STnhRE +FEPYv4RDDQYlE4sUTWYqKIPRX2Lbs/YUtwIUaowJgiw1i/5sCyB+QwwhBCGId1KTwRfMfBp/Ev4I +SPoeEUCCX6yhi3mM2M1pNL9jpvt4nEWMMQ7CMAwApY68wmKBqX0KC31AlNjBorUjx9mQ+FIlNp4A +EgMvIhvj6XT3eQ3P97DxfJ8mOF8QDD2wYAJSuwJK7nCoEEPsklgyWjEWr5CYCA3IdAXvspXqhmH9 +R1mXhAJRrbQ67gAcq48UeOmf4x4lauoHbV7a4zZ/Tz8JWzWy8ASoVAWcsKDkiGLsP7buHJMYY5V5 +RHicAUAAv//5FrUXsKgFM2l2YXRlLWRlY29yYXRvci1hc3NpZ24udGVzdC50cwD2HFC8turfV/h6 +/gzKnTsSxhJWIrOfBdoFcnIb1P0PvkIRmkqqaKLMh89TW3+5/lD5vTN4nNvHv49/QxGradqMe6/n +LPv/62Sq+YJldxObWLTdo0wMgEAhLb8oN7GE4dFXBW8RM64rSbOjtCSKGvnc3tkcmryc1dx448J3 +ubfrvyyXrrn44IrHUqfnWz3SIToz8zJLGO4n9akeqT1jE/k43CLGfqkra4TUl8mCbAb1X7iMa6bX +Wfh5G1x54p30Pvt+pZU4RF9OZl4JQ6dcRKP2vrhzQlYBiTVX8xx180UcINJFpXkMG72bE6yW3o+0 +v7FdsUF0SoCc5XEpiGxJanEJw+14gaZP95wmH/TjMbJeePpKsOJhB0MDAzMTE4XSgpTEktT4zMkH +2P4BAAlLZu31AqwqH+Wd0NOzxB849FmK+W/4fGEveJwBJQDa/9BI0EiwSQ0UqmVPqEMRWRpqvtHx +3yxFqcChaKmT7w0js4AN0BZEkRFF+wKOgXIbDh8BwWG0zbf2Y6ELZ/l1W3icASsA1P+q7gP37QOw +ICaTXiZkk44lEwFbk8ImKAZdIDogW12TQR0Tk/wmIbMtJ/3PdeIQjvwIynjki3xrrJlKC8QRlWw+ +4PoG98F4nAGMAHP/jR6NHrAoAhRC7NMWpe39ZdSbBBcz8d4ZewVe07M8AhEBFNWK464ZFtcID1v6 +xrN9uJG3BgRhs2EDPgYU6f35HA8oipGtuTaSA69Zj0Wc7leT7wkWs8kJBgEUsRxW/L3LAx74OalO +JKY/We/iR5Kz4wqFAxRDOfC7IkCC1DwYmSTee37yc86fgZN8DpHTsD5r8G20cLUODPsxyYI4brT1 +I8v7BVlIRXiclVRBjxM3FNYKVkLbVlVAWVqtun2YpdhiMptNhYRmm6LdCsQBFlVI7SGKhHfiZIZO +7HTsNKyiVa4cuPk3cOsBiRMS/wL+R7m3B549M9ls2m3LXDx+7/Pn5/d99vMXK89er7xsHsx6Qsd5 +eigoORxLMEIbEgBl0P4epmuAX6ykNtBPMwFtoJIPRQTa5KkceNBjDwJIhyOVG5h6CjiGfq6G4Dgj +z7lbwvpjGZtUSdiaOqrjhEpWbuS+XJhxLkHCd23Ygdv4E1VIKqEBOwxunAq0WMV8XI5uO0pKzMlZ +bG31p9n+WIap1CMRG1qxtJrshIPtPt5dOrXGY0+B8NARh080iXyYklTexXGPsADPeUZ2nzA4njPa +K61L12kvzasOBjDKlcMvtrSoxf5FNhsInUPcNmPTb9wijIVSoW7hkI8odb8RcHlkpy2Y4VH8+u1t +eCiFWxsLrSEfSw2HyiTFkQLE92CS4rzRSLXKuBEgeJxAKiE1GtREwiBThzwL16qmhg5AO51OtxtA +p0PmK8k8MLrDc55lImvvYLDLKFFFEd4+qg8mETBJFE6wIrj2BPXh+kjG0M/4QFemsys1Uiut6Ov1 +Atlf68y+W71EygzuF4/GDceOszAMPUc3cNCdK5v2GqvbFxc37NubX17w0vrEj4HV699+6rR327nR +/r7+9WcA4qn3heOz0dbGbB6pPHuAWE0feaGcimyuje40u6iKUT8oaXgqF8xRWeujuS4vk+0XZPb9 +3qYszbq2duJ47H7Z/AgWu95XeSHtROW/iLyQXjqEyzhBKpOYhBtcmh1Bghg0wbi8AXbvi7o9V4N/ +1mTm3daMCn8Vu2j0M8fnwBPGIgCtiiIGAt3FPUM4v/XxsBdBZz4FwGfjzlNBWbAQK2VfjBQG+KZw +wN8TLt4Y9sqUrV2vP2pXTV7GV71rt87KNHoi40ft5kL+v732efWSTPLUGCHtn1eJfUM+OV80b72+ +USZCrMqInC77cnbKl77vaLN7/DdxX8iBSWhr2WH/QhgKlPVnvPWUhNgXxs7kKorGNdv+/av2dlfM +PMBXpzIXEp92tP0j+Co+ebOWi3NV6P91Uc5CLtyCVX8LXm0dJOc/AKZQDab5AwWd7Zbh5zxghi1s +BIO6ihm0xJf1eJxbJn1OeoM/5+QrHEISBUX5BalFJZmpxQqJRakKefklCgVFmXklkzjlJlfw8E9O +5RRjSbJSMNo8g5OPBQBdSBL98Ar1kpx+dp04tPIluzgTvAjcqJfOcXicmz2N8e00xg3e/PVcCkAQ +HR2roxCtpKubl69bnliUl5mXXqwEFcrMKygt0S2pLEi1zc1PKc1JxSKRnJ+bm5+XBdQTq5ebWKBR +UJSallmhYGunoFENtkBBIbEovdhKIVpPTw8iqaOQlpOYriOooAQ0D6ymVlMTxNjcyT/JGgAyKTDy ++IsEtWnsSsbnS2zG5SB53GVIDJysnZ54nMVZW2wcVxlW1Ytbp22ujtM0dY6nLjsTr8eOCabdrUPs +yG7aXEzilEZ1XPvs7NndiWdntnNm7FrusiDxgFRUWs5boVL7gsQLobLgCQTtC7zhPgCqoqTlFXgp +L0gICf5zmdv6EjupykqWd2fO+a/f/53/nPPdj+5989373vqkgy7XHdtdePvjgw+EgV0n9INPvYdO +W55rhb5P3ADZ9YbnBxQ1vEbo4IAgjHwSUlxyCLKwVSMoqPleWK0hJYqUUQMHNfbXBw+yqW/vYqe/ +t5f948auVicSH62ObdesX6NaAc2rZwiBQhqgulcOHULRKMJL2A7QN32vblNiYsfRx3wfL5sVeKKv +IIe41aBWQCMnUDOP9Lk8sg00elIZq+fMQSVqMIf6kQ1/uVNcZ84wjGKbUuzYOFGZSBDPB4fkNJjE +Du/RWiuIhvVCZKjpk3JoEV2Hh3lUFybAV1BXNxexE5I8GjLyiOI6KUR6Rkej2TNDs6iZ2DOfF1+a +8re0rYHLZdutgnXjYaVCfMRD4Vn60+gYOj40fCKPtNc0wwy86cCHcbrBjnQfbo2cKCK7v99AK0p0 +xebq5qOY9K3YTe7W/CwInievcY+VQmE1POVDiijzKrGlb+WF6akLJhU67cqyrl4ZzeI8WH8/96KT +/e76sfEER1peWqHcVViZXnYt/Zpnu7pyoGz7EDBNWaoZefb56v5+TcQOfiGbvmS7ZW+Jom8g7Vro +WoHtuRoqIA1maiCcfbbaxx79/e6vS6P90AWDdZGZUuheCt0N1UWQBH0/WPraPQb7+57cQZnq4aHj +I1EKAz8k7L29B+8DsTq7sfcwu7DW22GYlEOGvbPWd37khJHOH3Vxg9a8gMZGQCh8G5BTxw2dB0RA +JsBBEglRVCJa7OHXn3gmI8927cDGDkiLJetqAOSKWIEuUazs62Xv9DzM3vvDA+PSRINDZeLVEDu6 +siM7OSU0Gal0ro52/qjzKzC6TKjl2yWia6CFUwZqOGHVdimkWPq4wu6ZutAyCTiizygIzmiysmCQ +xnUvi3jnUU4+VsDj5Y00c7BMGsQtE9daNmFUDMQyqeDQUYOLudl8LNwnckgivqXkq6kr8eTmZlqy +8l4NbZ8k4iwpTQLTlEJ5VtVAfZ24V4xY4Kyha2UPeM31IDUkALQBizZ8smh7IUWee4lQz1kEanXp +EhS5/hQ1QBmmgAlBbsIEAKEX+hZRIf7N9YGWDDwMXYk5TWtgawFXCZgAhVFAuRUtWG4QraBqSmvm +8vHgGSF4tqAkA28B6hziJyM0bAqmzrVlQBuDeF1JjSttMm4cxqWGiUpr436kSBdy5MtAsA9wVyt5 +7RCoJEJ4JVewQ0kxNXU8dE0ZBlgWXFGlkDyoa8AzBIaSIGzopdB2ykYqSvwjHppx8GE6OB8Qv4AG +X7l61Xzs6tVURuHBNdo3KFYb9vHqfrBOWcQ5oZgRjHiOQ98Ff/hCWIi80qWbZh0QYIKFeYCAZxFK +TexXF2eGZyH+Gg+OES0C0adppH834ed06rekhhjgBVVLzRQ61zE2wFUDdSL/hhLPF7gjK0gtXMK9 +Znq5nGeNDw+xv60e5vy6L9Jr1SCME+4iGuXUORcNz9BvAA4SMEzqT5PxzGZsLMgYyYmz+VgLQxe7 +xzi7aVgTHDXdwEuu3uadcqLAYSo9kdwd+cNeWHvqfvnt3TXj5chazsccQmBymokVVcJybWS983wb +cCfo2Ce4PAnTBY1Hcowie//igQVhbmlb5o5vaC7/hO5W66WoUkPqG7trfeyHPd2wauzpUJ6zn088 +8VjslEn4skD1yHvW++B+dmhy9wkFc4psKJnAtiAwilcE37lkSXU+qEpc4mO+dLMPj3Z9K14t5ejR +u1oUYhJjv75uthJNd86SGh5MVqyIKzOvs5alWLCVpss0W24tsbS5xJ3x6qGIWAEnPHn5L4hhM2G9 +U45tXTU341goeyqWuTZi3TnnKsd1LtGUsCK8ZOB3i5p87DbYdmdkq7h1A3JPZR2E3ou2ybmdGY41 +2T9X9wEFP7SQGJ5h2yQ5d8C4yeQU60piKd0174o81TclMc1gv8gdYT+9uPvZu+EwtnfyQNR9arhE +5e5DKxMLKJSUNd6OYbV3jXa1ZbRkBzVowNBTFNU8bwGFFJgsgCHRRlghyo87M6AKkgZpSPn2CJyB +JLC164dbng+7Iuwv3wX1pGlip6zY2pAWU8JvSzJtrOVBOPzt85H2hTZ6dgXp7SXVC5vpKMPt1LMR +bXkNDmzsZEjr7DrWum1veLvWcEui2sKVGKLGtlvIJCkRj6Xi2UZl68isuWNiyxBYdrIH+yLHq+ps +YM/uu20jZzckNl5wd0BpfNo6MrvIGYa/2RmbyZrP5Or/0lQ+JwjScjDsv8tfeqt3RdFnOSpoGgC3 +wDPHSW9nl2qQexu2ydiySIOTrNrgOgQvKnbl8Ibm1qpht0rKvB1kH13XXdlCBm3UmSKs+rYYa8Oz +xtvSkEyE3HuINGxWe232ZEpipy1VK+XynXVU5rEteyfOOqILEiHnGJYeKg2tzOAt+auNmxKhzfax +zSz7bNVYjdwZAfEGKrcV20RoAG3MvfQk+9fqIyS1rBoJWuY3Oypat3vegG/aoWA0Wc/0Edbzywci +qnumjc12fCb531891r/9hkvQRHJQeW7tyS+NnBKtb/d07ZBdrpx/ZPXjA6XLreSYUW6PBuq4Ac2V +vHioOLiaHDeCiYOD6DzUZRkHuFCALIiVokIwAJXQuRqmNXQKjURHaCBqrrQckDl5j8BfDZudkZOT +E2OXX9x9aWJ67szY9Jm5scvg7Qhbcwz2+SeHD6zbrM73rbCTOH+w2VlR59Go5Hl13SjAlneRFW/k +BtWDIgDKwoFVQzrxfc+XlZdeO+Vz9saNgSvpx9rUWQ73+WInjI+18CirgJQLXAXQqqsOC8EujSs1 +Axp3RrJs2XvHu1nYvedBefaX72S3jj/Ovr+0n/3pllaM5PHj9ePiXH0IFjh1MyHA0MzYIA+OJ33I +JzP/fHR/Hq2ziB27ebInJXcYpF4+c2nqpblzz1+YaBbmATQDN4fYf/yH2NO3jh2IZQswTnArdTa5 +9p0ORTvsk5uPn40tCQgNUqerls9T7fHzBtng1+xAtPbiCKICYKgNyBcU2A9YVsuzVzr62Y8bnR0q +pez9z7rYW4X72anndu0NlqAKA9FGrH87mapRlMvcHwFTxeEvovZXsdQiv1lip/7SvY9XbabqRVAe +jZJYGC7Ej9Ts+FHfE2ado0ofnDo7WBW9wBlYX88JbOvD7Ku3+ueMYhQstTESa1JekAXfDy0Q0qAA +RYev0eVodYc6oQKfNg34FigFN3lEHf1muEPnMWxFZ9TpSwtefeJSj58AnceNZ2OolnjhByejKwwo +4steteqIA6MSNLZInuMCGGiedwsugv0X8B7fp2ErAPYQ+a14PuJeIavluRW7GsoNrCmE8pe6Yjtg +DeRV0Exkdh71Jl+jb7PJkptCt86rjQuAVIt/WWJURbc3DVpJt5WXe9i/Tz+6T91w4obMC98j/qTe +xzrdzlYxo05PxpxEQy5P5zjRezdQKmhtFHHSMzkdj9vVF593g5ET5yZ0QWIpDoun8jZAZsSEf9yl +FmAm0s3fKI1qEHQI0u/eWIR6Q9WbvHggEabSOKaqr25TCryz5NuB6PdsaA8BYuKiOcD1BpQGqrUg +haojhG+hG3ghR58ZbavFaLHMqHuQ40P8E/1vC0pdXEmNJpdq8ozbFM/P0+L61HZtmFvWO/D4fjVJ +RUT8gjXsyVZyO8aDryxopq/S0tHjpQZlCfy0LrK8/mS70kxKVNd8os5hICYYglPF1nLUlQwskK5l +BThxaOF6HFYJkfVni3AdiIU5edmVst+udT2SwSwjLx8FwD7MvM9e7L39/KkBjb1fPwo43sXQrUPs +j5e7V8fsXDgh77koL1WQ4NiWHTjL3NABYGGi7OdcE8ODMzWvccE62Odj2Ju3Qvb6zZ/dqw+5q32f +3rznfyJBV4j5A1tALHF6lP8b74Asp99dj5CWph1veJwBOQDG/5wLnAuQQBQOqGG199pVzW1KQjaP +y/9KxACSfrFUVAEUk+WYOrM0+xpjzeHW8ynFcvWHymCzvAHgAwoZHH/yCRbss8MoGkKgJEyJYG33 +4jrrLxDXeJzbfJ196g32DRdD6vX1Fdzyi7IVchMz8xQSc4rzFUoyivLLixVCgzxdi4ryixTSgLgk +I1UhJ7MktSgxR6EgtSg5Na9EAai+JCOzWCEts6KktChVHcTKSc1LzE3V41IAgpLU4hK9tMTMnMy8 +dA2l4oz80pwUmGbd1Lzk/JRUhdzmdyHb34UwHp0GAMu+N2L5iQUVS/q0FU/vopbBf3rGiccP4k7G +SnicrVprbBzXdcasLYqiREq0SJGiKOlqtKpmJe6QSzEKsyQlUyRlPSiREinZBbXizu7e5Y45nFnP +zJKS6c1WCdA0RVs4uWjGSQDb6gNNncaQaxRFghRx3T9J0AIJ0PZHf7g1+sMx4BZOAdcokKY99955 +7YMU2XT/7M7Mueece57fubMf/KL5g492vfzFnROGiSdWcm9VvtXifHNfpKOy3oLYR1MyWEsi0cKm +qmhIN/S4plg2yqsaFvtcohUjh4EmHlctQ1Ps4IGxpmMTnihx9ku2sWXLthU8zwDfVUaSiXsXlIrs +3bGj4lFZWUWj/AfcdWX+VatiUTEVTcPaBrp5j8cGt6je7pB+5H+e7NyuPr6dkKEjBa0Z5jI2t6XX +i1V6VRraTamyW5V1PT3PDsAnrGsqJolMMRsrZg5kIGyahmklUZQpL/YhaZ3vo48p2kdVqmCzz5fc +x7mjcgyNnXO3zuRjJVuQFkS7YBprwEcsKHpOwzkxhRQLZQ3dskH4CQvlSqaqL6GshhW9VEQmthVV +t1x70V1bBbUIDBTrvp5FRsnOPmGsYAddEmKip3acqQ1EnukRWmBrU077aKTLebotgsi5H+1uUopF +rOecRVM45nz9bKS1ac7ILmOb/PCrvU8jrhVokDXMHBpDK9iylCVM98XXXQSd5kALScSrWLct2b5n +g1CXjjwwO503baFphnsYOBRNIwsPZayvyhduXV+cn5qbX3x25ubVqZuLlyfR+fNePokjvuLcfJLI +9EdFxbIcZWeki6R/uwmeceUk0bIV0+b2QSI67QYVGS93kqvps870Q2EPmS63kG+mowIi/6wcJR+m +28gn6R7Sqpwkg8qhCmxXMywsxUJGCz6eHEZTJyc20mCJZz3FgjAfQzpeQ1PULbUhZoHpVAgiTWzI +JtpIHcQcD35HY2NjyA2qhnQInXefu6qMNKbrQCiJ0jWPyHLuYIUqzsNCaqgg/1iMQjZ0CAY3+Ng3 +jRbPeG7Iu7TMfpJLBLvg6sViNULkBlJyEBGmcV9yl4QXkPR3Dhfc+3JWsSHp6vTIKqWlAnXN8zhr +q+CdrWkSfDw7Of29Qrfz6yORTic1Ejnm3P2S0EK+/+pJ8t3MGfLo1WbyH5kO5/ATQlfLglcfNsnA +bsrSDXaXmsU7Ju/8uDu1acp58e8tYxvaerbFWK6+Ohw5RY68ESP7vrfLmfot4YDKSxzUYhMXDdPG +5tjzJV1lAoN7cQhFGtFj8C3fW9HEVF9QddJyf3SdpUs53Yf4latkOR0Qkv59pypu4fRu+tbnicT3 +C4mUt3z2MngqMMnzhqpLczYtn1JONWOgZchI9BIUHRZjwXKgXZG861twwypqKpj/jh7kIr5XhCiR +XE6wUdgyv6IhxX7IzPrWs6pdqKkQsRj5xm3kzF4R9ju/TArJmJpHErVq1ZKg18ECt/wQ/ZMjldnx +m+PT01PT4cpQq4+e20ybqroIES3bxjWWFP13w4/u5E5H+30hZfe7QrVl3Y6XmcaNO1wwuau4AuCq +LRuN6wIKyitK0Sdc9Ci5V+jzOjtwLmyZtNCHdGUFp1jrpb/YfqdeKCkadF4v7mj0sl2LTvt/Cfsr +nMPCQGphMEXpL2CX6UKC3aq1ilfXafTDHpU1RaWXL5RUE0siJMDg85YYk8GlFubROGsaKyq0lrzV +IGCHqyPWS6IgXMNdHMqemrWTyDZLmPz8SHeFbWSupNrQCVydGNyx6C0r+MkDxeKE5xC/F5WZM6lv +GZ+ajPMMtgn7ypb5u7xqROQVVSuZmMZKsBMmIatY2Asc75pyDp7RpRUT1yZqldZUBVeE61oAp3Ur +GkqG7TSUG5VpZPGEMDp9UIKpz11ZjnJBONhDk6dBl4Z0cR6uCPvJy3f3kFcSe5z8M0JPJcG7ZYNE +D2lXv5lEgwVhmkvKKp7G+hLkWGJjyoWBSkqO+rVhJkP7IgBdulGAyVJJ9zo3UzIGGUQdm+Q+o1AU +TE4bqcXAP2DfTUSlvE3Qn1E3QSuQoevIvl+k8qZc/ODiSLjTCDBBsdyGoEUqaMLQKZiWqoO9jLD2 +JDjZd0uHk3kGfvzo6N78reqdb9c9A49xj1uaeB3arFjyAKrBT7QIiLHHu/nxjCkgOlOFiB7Dm9fC +svPoZ8IB0v6NnolBMeWOLwZks25QXlYJIl9hOQ5KMx+6w43nSn+MoS2RJIZOdnDiuGYoubhH5fzG +kchnSdupKHl0rmVHgJfIlwf2O3/bGtnN+tSSZmQUbb6gWjKlADEz1DWXDGO5FtJvDqUyOA9D/7im +8fC+EwYD/AMzWcnUkS+xt16kXOQ1f6TFSfQKHWQUtzjfa4205zeXreTBRVQ0A3CbbImiet7EALYH +rS0Gy0TQ2PlKW6SziY/v5MFPjpPXf9Bba7333mse/hVmu/3Ot5+K7N5Xq5jT+udCdIij2JUSlHgW +CyXqaikWBuElnYcnhAalBgz60+/uJ9fSQ3xY+/20RP5FOQJj2h7yafoA2ascJ0NKV2KjIa3BgMbd +Rn7wZ10Lde6B6DS0VVw/0fBRKTysBRHZoATFRkg6c8j5qz8CHy996wwA/wT5KNP9a3VsIMJLkACM +jb+aKMc7yRM7DpKPvxOvdc9oa/NE9Rhg+TbcPIi8VSxyyez7HWTvG8MA6neSo2c6Mj6mL5qYajMm +97u/2BHJ/x3tL4hyP4s48sMmiXSOtpOxfYdbaDvgFOT93zt8yishj8fB5IVPDjV7ANj5SUEQOxrZ +kD2pPM5JLQHkqJ8jfqUpgs0Q8/4QUT9BbLkI19Qdkbz46VF5C7U7FPB0iddHAMDgezN5qY5vjHen +acjkeegoUi19VQZtdxNGZqdbiqguQ49f4Fc8v4aFNhGToXqEGneIOkjwGu3q1tQVmnA0bADjC9vH +8VuH8VUg/sErHf9vIL7uvLZqqxvC+cS2JbFT32rjbxl2bwvWbozQY+SlTw9XGjzwYeU2sWyd8Xx0 +ubES52rhrOz2R28jm9clHz7N+vAJKjEGxhaix8VMs5MWBExONVDR0DQLgfII6jUztkVPAYsluwpG +sWNn8t/Dx05A6OXEFBuNs/RuOrqeLccZM2+T6Zjz8w+FHqfydWFfK3viHZI7id3CoQRiduPjNR97 +zqGFUMek9/pC12ny6C/6yNXXdjlv3RXEfbyjMizAmJO//nFXxT8Fhls0TdZMMKkkztyaT0bXKcNy +A8gVXgSO8xZN3by52SJGxVI0Aca4OJkA4soWqAcZ9eDGrCE00sG+UzH/zIr/cIn7+9FVjIsIWhrK +GyWT+fOsRU9PDB0j/72Mez5uGxBq2MxCiUEqtCgO/5C1phQtmbS98Tmvh++gfk6Rfx2Jkr2jXdBm +T1cCifOFEOesAaBI1RXbMOH3SgbCzvLEcfOzgOJGRarO5LqFIVw6WJhBzZDcRRRl6hSj8pUxZ+Wo +0NvZf1c6nwQ/vgRueeni5EJiMBVLOt+PRHoqnINsAWMpdCrTEoQRdAlNsa+FAy0digl6ehjyNr3k +/gxd+g5Lp2KuKNcfzoevCK3kHVkmf9fbRj4/utN5/WcCmpaCV3MoZ7L3LBklu0zzy4KUzrmZxzso +QEMMiO6eewSWhRYAoc0sZqn6MnnY3+nIsUhTV+a+zU40htEplBgYHHK/aKYdjzKO8bCU0GsaqEHA +W3PGc0I3+enpY7fplesoH/ytb5BA90ToSkVQSoquMxXK0L2rIlXMxBmtz3+cbWeL/KeuT/JECPEs +kwcnn3FmLwptB5nmwas2BGiQiyMPf3O/8ycXhW6ndFnY7zybFA44L35N6NgLpUFdwSAhiT4zMDBA +W+HuvGpa9k0YHTWbThLdz42uGmrunIfT6QVTT8b3QCmArAWsS1zv0NIA3tc0eyU3x0N9jLyf7XQ+ +/qXw5Gf84Bb9t06cPAcjRY69t6I4fh5MNcnvgDbkwWqn86f/KJyoVI8iLrPTY95qmX9L2UJJXwZP +0+6PlRXe/asOMDgodhNF1bNaKYctSZQo9o+hcCTEYsFmL4R3GzAr+7/cYdVTrFYvWEM+LvdUGlqv +ZtyvrmpuKciXQLESdDSNJQjjw2o+Kij0taWuWgWcG3EfQuLQeobYaMhSjiWQfQgapVzvKiqAuWqc +47Owlv6EXbVPFhxu4NrgMm8TZeflrwmj3QFfqA2hgHASg0KnM/03QnOzFw/krT/oqSzcvaOnTt3R ++yGga0EJ95TGzkbchs9T/zQaakgKM5s76dBc0j0kPg+RIDVcYCJc1JQsBe80v5kOHrTgLMiNCzdo +Leu9Cm55FkCbsebhhRKFERQWwCiqGyUobQYgnjWoahwBWbB/BbwCjQduoNmZucvPcZDh/NPfC8cM +aJmDVS+nb18LMAwbEhpXy3wOnVB9SAJX/ntw7trNyuMRXh5D50N+aaQJ79wQIn3k6eRT7TSS5qDq +XtZhINAVzSJHxcEuSoPWwMLIHfiRBzs6ycfvNFVonaaTX+1imZHRW1A787nqrKSL3Bp4oZTPQ+pA +bzWyfpUFr9wTq98V1gtgfp2056iceXd3EuVctc5/Ywf7kAbC6VxVcRMtuuH+MUUiD+8cb6f0fuml +aMR5eFE4QtTffaqXvvibnJqbv3lrYn7x9rXFmeuLU89dnge8mxCd1LvC2c0LciWn2Ao1WY5NGAl0 +PpxhKOlfQQ41nKsaLKT1Nxlm49eVSaypGQxRibX7CIDwKp5jdYMpUVSLmFcberhSWir40ZhEusFy +GWI5C6EMAZmF4gohIMXCRWWBp5UjGMKxJq6hM24A/KV5XwHQZNO/8nizIBVaVUKqchMAB7X6WHSd +fk1AKYVAsNQl8Dbc45tjV+zRHR3ucf6ypalZLMWHBj53NlZO++fSV2GG9GKdJ5KfbMAtg/kZUA5y +vgpjukp5zHk1Iq//Q8+Nhk9qZn8WwTWcqlXnC66D2SVH+UgYIsa3294+v/s/P5udgAmFHUaXzCxG +y9ASLOYsw1SXAHJCtwJ+al7F5gifZtgU5PYWipsCP8KqbMk06aFAUSvBaou6rb+fzF7vGIaphtHr +gI8VDhWLUBP70FqBthNxVTXtpF2AbBe9N48qBdhvvzD5fispfunA2ZxqLcezXF11hbrd8vTYRAfy +cOwM+bfZfeTduTfbET0kBwZxTz5pnj/azm8ZunY/CZIzGibD88NtPm22YKiMsCN0jZOuGEr7FNBy +aTRzk3RE++qNA6MLoZupoJVfKOkyfxAMtNVaAZh0XvtDoYc8unyInJtu3xMWTN680kOM6abu8B8D +JsYnLk0tTlyauTwxRX5nuqcl2BORr/aSypVT3f4depZH/wFVhL4BNYn8YvrEFZ5aVAF6jkxngitz +M9dlix2HqPn7EiNmxxPcRiI9u2ZiJxevj1+bmpsdn5iix9hk/Np58pXTxyLRddI+09XEN07Q1AHR +dV4Z5aHpU2hZs23ZdhJfEDpJfGpXhW+2jpbfphate0HCuXuNtU61+jcqnJe7oMaauwJz8qPXlrc/ +P/+cQF660dyHkCxTumB0DJs/Sc/JvUdl570vCwnScvs1Mv3vB7/47u2/fPe28Mcf/C+RAA97+Q/M +cWfNwT5s5R/pIg8WHIxqrtVbC3icHY2/SsNAHMcRHFTs0k2k+gVBreSkFrr4BiKK4ChCLne/ampy +F/L7VczkLjrlBRw6OSmHT+Ls4pN46f7589Ms5p9/m+Glt9gIB1uvq4kl5YiFrBpPRiNV0CMVrCxR +dTxj3OD6/OwKt9jDOJm0v4O38DFIV9p+b+dZO4t0xgaqTKEzXwu0QO4JRe4e4Kdg0bXKYucUdyQX +3s4LutQlcaUNHQ6hmakWjk4UNcolABcJi6xBSk9VVz2KYIqcl12yCbqz3ja1Z46aaUy0cukI5wUN +SfsFFard6Xr7frIWvof7/X+Dw1a49mGZnVHiKQZM9DsrwbBCQxee7RUmsnicZVRBbxtFFJYF6sFU +KBIRFFVUrwa1u8FZu63CwZZrIOQQqY1RE9GDZcXj3bf2lN2Z1cysneJYBiGhXjhUEfK1B34AUg/l +yKkSR34LVw68Ga/rJL14PTPvfe977/tm/vrzyu+vr/zR3pjXavB1LkAhizQcdL7ZO+58e7TfOThs +AhPA0gFHYWDMkhxBCjAjhJHUBiYyTyJIkH0PccKGugxAUJ5UMGFKcDHUwAYyNzYj9YELIwHHqJ6C +zthEYAQGCeajTMkQtQ4o/3z1l/WNf94/+2W68amQu1Lhbhp5TA3HDdBGEXq356//nr24cX1uT5tL +Fg+4yE8g4xlCKJMEQyOVBj4UBASPHuw/3D863u082mu6dlKWZQQDMU8MKtC5GvMxasATDMELKcfb +8X1LMJSCKIcyTZmIoAVcu0p0AjBvw+084Sk3sB1CHW7dgozYmZj+34eabbOmMYlrFjDK0+y4qEeB +rlLlsy8rtx1U4y2kdYDtUKHJlYBupTbgoqZHlSpUtq+H9Cmo2fU2LYMgsFPpvfzvxq/leYIG9FNt +MD2QET5kT6RqgMjTAZE4hVxEGHPSpVku17a2wJ0DCaY5yS5jN6plOtj84ImuAkXUYTJC5wuaLdcg +pMAADq3GNHJDnkEwPMVg8Xxa2rwrVqW/WyJ7/hsOU2qNx+Bd4nj2vP3hteXkbTKN3X72TtDzm+XF +i3Fp8z2337Y+Ds7e+Xx3DjM/0Cay7mtApdJ0U70ESzgZUxr3hfGKLgMjD52jPL8Kd+o+nJ5C3SbP +1kO/hNIsz9y4yrAFX0E/Qh0qPh9ggCwc9cGwQYJ2eP2uYClWnZC52+31ISYWjGx3Qsg0pBEzkObU +5pDstxw35QB1keXGFrASKXdbrf2Wq0KKAI7W8syLTSsHF1YEJxE3mrx+XlU6p5p0h7XD76dcvOms +H0DfzrUjHnMRyYluQMwSjX0bb6+H1Ta3+kIRUF01dK/oaEIPBVrgTCEJGHFji9oKEDIhpIFBzukR +sd5Z/LhTujbPhbWKfszNyIZ5NPfznFZWqdL+FC6wIzmNoidq1rh80m7AQEoiLWBGUdNZtUyec3qs +XhCnCy0+dqtet+e8uPSccpwWP/1W+mBuT1rQ7VYGuaDrRb/Ohr1es7Cud5ET+ecm18XKtxf5bfvD +/daFHv2iIuogy/XI61ZsDlUTEgrb3+z5556BVThZ8edn/qtnfunfq+9aMou/d0qfbLZa66vtEwK9 +Arj44YuSf3V5LQCQVH1FO6/xf0tnCH3/AWOjgxbM7wNGTd1w9Ku1NdbRWpSSeJxrY2ljmWAqkvxm +se+ayOWBF0/IhaROk6kytXr4c6PnXkYA0KkNx68EeJwzNDAwMzFRSCrN0y2pLEgt1itJLS7RKylm +iNxqUuaw1E/tSqRKYzSLurvH3ckSJgZAoJCWWVFSWpTK8Dk8QPmbw3e/xAqd/iufW2vn/GuTAQA8 ++R5m8gOWtH6SSIPzAzHrIY0pMLrdiKRI+nicm3SSpe0Uy4YjNmy5+SmlOamTD1or8kCY8Rn5+dnF +IIHJR2wcJivaym9mtu1/DgAZZhSx8QIG5rbK7XsU4fdjejy5S30RqUvLVHicmykyU2TDCzaRF6YC +HFXpD9dVLmPY6Pfh8RfeqkrZzX/YZJkB9oYOifEdMhCH1Hckc5M1Rh+VcZ1CTpkSGYx4nG2PvQrC +MBDHd53cHY462IIEXP1CUHERl+qiKMT2CgWbhCaoHcRX0Efxadx8FW0LLYl1S+5+/497t17t+2Y/ +pYoeqESgEpbcx+LfgeLlJszrgKuowgiZKsByoO0yFK4QxDwCi6XQYz6+6a4OCeVAJQJ5YPiPbKdf +w4tAT63SrW0E6CIjKld5nEkFTAvpGYfUYQgMz/ns8WnemG7dM0/JUE1KRIyCxmhb7mwxm6yga5k1 +WaVmtd8Pvi4J4h25RNvJdSce+v/wkt66SXTgR+KHUqSynal7Jtj4AmgPqEX6C7SwrwT7jInu3VX4 +0QDPyN0g/k4FeJwBugBF/6QXpBewlgEUl4Dp+lnvr2HL+X1m6YhPk0T6mKizqgENARRKrR2ETkgM +vQFvgkPFY2iuh8aZH5PLAlwUSr/4/ILYX6LMgTyeYVBd5ZlNBaazOwPzAhTYU3hHjTNcbFGul4QA +DMauCkx717NCBrYCFImnG1niYsdqlDYLQjb5dEeMDN9DswwJZAEUmbvFcS4XLnFlU0PRpP+6N+75 +3YeThArtFI2nyuQAHmXsV+mWqj3XLoWaa+fzk4ULH58tVtzyGigSg46Mq5rOpOU+Ac5A9qT0UmoI +eJx1kM1Kw0AUhSFVUDcWpAji4jBQaKEJ6M5IBQtBpNJCbSkipaTJbU0JkzJzUyyl+BDBnQ/g0ofz +AZwY/AFxd8+ZM/fMN8/l18pbZScrlw6f9oA1fDXTLu5H2DR+a2HbbEbi5iSV4v/TIAlpRlI08OPN +dfD3BpPmPDWNYnJy4TywLmKjes1EhVlDyudE2YmMV9DE6QKK5hSwhvQ5WhIShZCmfhoz6JGClKNE +uqjORV7m65UMUCs6samjeYG18bN9q5qdWvYZQHLpmkc5jmOwPLlsoDXojIdeq33dH195Ha932e/2 +bsfdzs2dC3EiCowsto6OAc0hKWX8RbSgz0qYmvM88GINsvfSQeZs77pDmrQjxjePLoACX8qEMUmj +OMxBVCq/sIqP0yILt+ofA2eAvbP8B3ic1Tv9c9s2sr/nr0B5d1NqItFJL5c355za58iK69axPZZ9 +6Z3jYSESlBjzqwRl2fH4f3+7+CABipJlt3NzbybjSMBisdjvBVZxWuRlRe4Juy1YUPVJxXhFHkhU +5ilxpotsFwecdy9iDQhj4+ymL/6/ZX0S809xFuZLjmvTYj8u6+VzWmaMc3N1ME/zcHKXBX3YMeYV +l5+XZVyxD3HC8Gu9PstDthtZ67/kcWbPF7SaA4RBYJzR8m4szkOrOM94vcDzduAfD8q4qPjOdBEn +4Y4EHzAD3qusPUvG8+SGjfIsimdwyruCEevLKS2rmCbW2HmeJ8GcGtR2bR6IJa390jilSZIHG1eG +rOA7GrKFYMmm13H1+HIJ11ocsSqYj5L4FPi6EYUAHARJbCN4QUiQp8WiYvus+JDQGe83Q+3vP9Iy +ZFmczeqJ+coIpxGbVDS4Bnwsg8kgZvaEAt1ILIK0ThrQcpa/x+nD7CYPhOw3nrhccJtbQtL3BHQe +dEdg2rie54syYBLDi2iRBWLHNA+ua21x8xtWlnHI+K5Wq3/Uk9+TIbl/6O0ayoXsLlm1KOVHYGyw +S5ydiF6znSS5SVG9d4KEZjOnL+dvb9cAvHypQOY5r0aAZgHMjuKMhcYwrm6Ni8X/ZCWHwwDq7/7q +vfZeO8bcGZMHBzbZWyfxVG69891f1QJarlKHHwa0VBBJ2AERekkS1gBv3xx1Q719Y8ChNI9gbg3p +OD2542WeVytHxrkfgR3nIN2ErUzzCsbr/XFrMaLpgz0nFoR9UhM2S9cAZakmk9Ewn35ZA6ZmFSx8 +Chfpun3VbKMnUZxUa2DVrIIN+V26qOJkFVjPKECMJyZb4Lua+cLPFlkVp2zNPOPChKxZNaYJDmgw +X5VFkAK4tUyM6EXoAlbX4OiPebqKDQW/KDqnUn4THMXZNStXV60aU0Z5ujLoeV5t/jjy8O7Fg+Eo +kjhb3Mog4xbSN+y2Y4/giDA0VKMMo1HtK4YtV9MDTyLXmW7EinauoEt6FtAfcEqOoEKxD+01mMPg +7ds3zdA0hpFZtqhHBFHn4Cth/IwljHJWz8kYhHjBAyf2EjiH/i52rc2xPQuMUwyRIw/yv/ro+LVn +M5MBo+8wcJxEbhDNNCd6KoBlkAXlS+SZGbkQEvBogNAISA2kDns1sO2fdxGvF0Q6vCmXLAbBqprh +GvvdaNfaylpsQCEaG87CByy8lvskoTGMKr3bGQvFATyW3XijvbODE398PDrZH+/7ZxeT8w9HewcT +jxdJXLnO59vXkdNTDhzzEVrloIEn0y8QFgEBaCLjrltnK0J8Ajuh3IyePU/aAyc//ICRzktp4SoZ +u5cZTSHfvKHJgl31yPB7ggPkJXGGDvwV45KGXmM8UlAoGUguSyEXkNQlzDuDiGPyMCjKvAIC8hI9 +b64CpTPY9z+cnJ0ffviXPzm5OBuNh9+pCbUMAhef68XALT0Lh70BRRzQRZUPbmg5iLO4Gn5lZb4R +YpDS2wGPv7Lhm1d/f6tBs3wQgsFUbJAtkmRQQPZbsXIAji645gYQGntQDdB7REm+XJ2hSUx5XB8u +4hT2xN1oWdK7wTQHV8Tbk4OqpEUXxL5/cHT4fvTLL/7eZDIGLp0cT4av9fLTw7GGe39x7P+4d7Y/ +Ph7v1wDwbe/90djfOzn3T08mh7jcPzzeH5+O4c/xuX/4ce9gLMCv3ikJoqj5ntatMwhrKEfbcoff +A/qWXfekY6210gP1Cl2pZahC8pMHIi0rKGSquet8PPQPxufj43/6e0dHJ5+AcKcn0fzg8SQOWCeI +l7BsVs3Vfsow+g44gJ0d8gnKm4plJF9UhBLO4EwhwWhHwBMVi7LIOfhGKhW6mtOKFOC8K64KIw5T +EG4BuoQCCvIlGFkiVMyJUAUWkjCHwSyvyIzBeEamd4CbERZCgm/y8CSagGT5Xhae0oBpW9Cm6ePf +pV/NZRpgjJcsoz6jM1b6YE1pXHUCwFlmzE8XSfc0xBZW3rDW3IxlDJQU8CYJ2FJrNgXrgI8KNVpI +C6AAovwIzAPQV+Ds29NiXcgk1XzNbELvOmfmecK614gZxZHGujuBBHFCMTcAJRQ/g/Xm5XZQPivy +YL6JOGCdLxzGjYqsDRgP6A0oLCulkSkNwVhg+8hRyRIVDgZQubNkWMRKAIMB2NcQUjRf1mwsVOP/ +bvnVoeVXR9pJKS82rF3nvxdTPXYnmF5bP4aumi5nIEiABZ+S/uBrP0N/V38DelEW9XfOIDOg4EAD +oN5axW5ZICh1kAF4zeHCmfRZgCwyi2/AqITgyIhQsNnRy5dEFjN9NR4gcjFXzZkglICWQQ1fxTN5 +mwCbuiJcYQKwQCdMwriEk6jrEtcR8bDeeSCCM6yCANjkGsBrWGKmgPdEr9glVblgkPWQiUj6XMDf +M9ZGinVt34gQ8t7Dtcvunlfl498WNHGtyGku6CzgBdZNiyPwYK6WKaZYEbmUpXnQJ+rD7a3+aOQ2 +HUO3t1c9lVQpmhBls7sc9ET4Apaha0De2EQJqiy6cB9Bl46fli4LDcLxIg6Mz8wBWiwqwBUDJWpf +F5GKrR4aDsoDock9SnNtlz1TBBIBqtyjCGoD6kBQx8aeQTCGuMl4dHGGcdhc0xGIW1LvCDOYe/dq +I6MyfydLCLcYERujA43GIAZxCwQA9pQ+z3YGeRRtYT+/x162Uf/LKwMncBkwqpRY5Kpc8r/nwX+V +2zaPWg2htrFUto/VTq0Q4lstXVBIU26NTsLua1XSUobAUoJOC9hWG96zC13eurYC5FlyB1Iv2W8L +yP0HabhkQxAZgUQXU51aG4RsvwUPDJ56UdEpxDQiMjVMmyiBUjtjSa1Gp2dw8nP/4/6n8TPVBglp +602TGeIeQzPsySlf7e+L1QZvTO15it/uKZ9gi8uio/eMbfpE8fsj0LlLIprwtVv/nm1/32mk2Oxz +WHR3c6zKz+dlvnQdA3YoQNUAr7khhp1OhQQ1vh5AvRtDupJC2dooJYKh7jFWrigoptoY+42Fz9Q/ +G4OlhkgabPj0DKBLXALXqqwN1ZYgvknQY9ggbtvIRPF3dDL6ebzvQ6l0eHZy/BGqOx1PsCzCGgZZ +F8VlU6VDTQPuStQ8+rIG/CCjwVxFBZLDn5JUy9zb7IkUaY+FJsvvYpxAt6uvTDbYE6IfNxxaY1P9 +VUwdEO1Uph16Oq1oC4GtRyjk1cb3iMye4/etnKfLvFfYuNnEBRlOa9FGW9e3fz0jzZ8tECQcYPHI +sY4GLUNHTqwKoC8SexYLfQsoVNUMcDeZS6OMS/jDyCc2/TmWZbnU5RDvIJ/pDSwS2/5A32C0rlMO +LvCyZd8/3TsY441MS7nVJalQ8C7ncU/Upqe4px6/wls66575slbX9QlTx211S6QrqfcfUxK0igGt +3JJjtUKu44rgQtvSba4oM+9ki2kkdrL3NN7orLBtosYpnhz/66v2omSocZWzamUtL25st1aNulTm +j2Nil8cwrvu3OlQ7O+Bq1VC+ObR9g0w32QCzgoHMN9FBQC7wX+YhTELbDuJSig4YlJfhlbw3Ed79 +bPzhYjKe+ONfoEw4H/snx0f/8ifne2fo5ftmfluyaMHxjktu4+M2MunFG5MnOhaF5ARwTBDFZg34 +/+xd1hT4GhLl8TwvtMrCbf1zV/H5PH9kHbCjquziQweYxQRJI1rMqbLhDcJ+llsz3KW5zQZv1wW9 +VpIbXNUatX+a35IpTxvVUBqQ8Em1R5Jj3X5O5UEb6d1O5/4Q8oXy2tTbWdyTiV/LbPkkDZ66zOMQ +nJx6tab4/9s3z+V8TWjOh4IQEQtgr+EsW+BbTbrgSUf2uVJARjSGegfKSHwbyipwNkyFCwwfmsM6 +diypETwE/yDs5EkIMUa7OH2DTDm20z3rBg3xDWrh9pU7cTK2ZKVHHeDeN/9A9n3/OftpMvJF9umn +tOAHRpj//KqZkyU/8vATHu2w4tjvN6LZe4b1w+dX6u3fEVs/YQuxzgx9lMtSeU2ThHoo1K0HXlHm +N9hx0XIzqxreNxKPjpsTqQ37svIxLpDu0mmeyJeL9cfAyLs1r2T41d4VT9thuTSvA4RRAUO5FU9F +F8cU269+ojd0InrURnnJgOn9mt6H3rabKCNLqtzacKUObOFqE9iChwVSfetbAPE25Ar6ZXOLHeSA +aWkBbMYWUdeQTR+PjG0CnoDQlSxdUjAmaRGgAgGsfL/IPF7QZebqjpcghaNeylZXFzCZzZEgMUHR +QBGNIpQmCp86iYC/goSayZ4Aw2fiK93KAhX8ru6xVUO8CiGVRE2Mi6ZxBkZZWdqjD+psKgWUC/sK +VHTcgpxDhumgPP5pmacxZ/gG4F4iFzy5xqvYbYUH1mOw3h5DXCy8UhvqFhd84S6QVokGuK73FgdH +xWnafl0x1mvowp4N67pAEinlXrseS5v1fo5jbKFDl8S6S15Z7kG6Ss0BhVw7HVNR5ZjcwYz7lpsS +7hjf3W2XvJRXW5DnSxcPSo8lBAF/Qw6r5rVe1fHbm347Dt43x5YUqa/m+eVEw2WTgfVqZcXNqteC +a0bcajXEYBGTsKgSXQ0yXMGJ5mhPWC4VVZzGX4EfEAj3JlSZLxchjWOfg7jle2blA3lzFUcrRY+o +tHQrVv1i4mGrIitFPo5bif+/GQ67m3w2F7tmK9s+xIWZI8sbymm2fT7++GPuplhjJdfbPERJtjx2 +H9hxG7iGOw+NVnj8Oi4OI7f+FUDPw5taF+9PLx0aBKyoOImzBD0kkWKL4VOQF7GIepeO0Png2g/m +1z5mQuhHYSwTLTARDjtX/aZVUnjKy6aU1w0wgDulVSV6nNZijQykcht7l9WN7c0ETmI2fcmtslU0 +9u6ASKiFkH/PygEPji9k38BfjJTNl81uss+c9wl4aS4i3hNMRS1uGwm2UMIqQ6OaOeyY1CEU4eAo +2MtLovgWHDyT4rd+rCG9Ia6TIejXP30jO57nL9CIaDnDbiTnz//rvAOvByAx2BF8hwlHPqfVkpX3 +GOTqHfqITGCTbCXf/oV//px9C8s+HP5yfnE29g8/noJqThy01fhFmGfsxa+1a6x/ZOIKusir/H/+ +9jfjlPWTUngoWUQegJTV3408+myHLDIfjjmsbbFPYvXA2sBfeV846Mw6JuJqycSfJifHnsxxYFWd +jaBOgN/RwqhThlsYNfespaUhkA18F86N/eSSJ3XfuPxat4bLr3X3t1CIh2YnZM5u3RBMlNUBUSyJ +aoIEIPJ1V1z8UFxyCWZRgH2yMuP4rUEK52IM8uCjeCppxLcFuUCtVew2N53GIchCiU8A17Mt2eqJ +B50i1WqyRQbYzv8El6VdeSmrqAfmIy218wcfUuoDpQNgir1aIzBfAWYqukXWJy429c+rWoq+q12B +Shk/gxrpI3Xlh6vZoXU5+J/KDFWwkWAyyXcdaQDgB9zaqzVwuZ1r/Togf75XYA/E1bJV3Oj9KnfB +anwtCuc7BQ3LVN5tP2aqsyvy1GbkB0iAIHVsXw6b/WGQ5sg70rCV/9QXwbov7llJjsLd+O81WYkQ ++L3szg9pucQWyPYVh7oDqX2t1p37Le5G8HnyOdf022c0xhX9mrsgfcWycllvykP8cobLBLz5KU0f +hBMHc3LNGEyenvsQcP2z8dHZSR9zU8zCqbgifaaY1O91OoSELJStZOL3EQ1TjVTAZOJm9glsLcaJ +IFFow1r/a6KnXfu1dum3fjdyb/6EydCo1YuzNcJs/czJJG7DO/n2ZDRcGWehbOqu2SCURz8ITEuK +P004h2JtBArwHlK2w6zKm1sRcWszzZEGzkUOGdBS3tYkHE4TqE8FtpHCR/5bAs4PP0EiehcEhqRr +nZV9ompr2e2dYTYuCiIyxQQTkp6cGFSg6mJSFGNCVdI7LhugVCO5bGJ9pvLSiA00AruWyp7db4pP +ZY/32mmH3fXzTst/fwVurZRlolUebKt7ud1MYf9Q1MVXO1xutuqZP4kweHJlF01tRFG0iumq63FH +U3spuvUeVbt+06lt3Cqt8RpbnM4Kxmbll2frGncmex/G+Cw4+rnVANpebjyQrVaQnUw1sa1/kwLm +rn0FX0tj85S0F4ZgqHyi9i8frbfNCv5xZZW87toI5CUVdhv+dyHY1JrTPjEa7P8Bxesygv8B+8yX +bflMDw+itaX3wOJ9VgR8TEJ4nHvA/YB7gpmIZMUN8Rq/QtZAU83prutePf4a+aV2o9c0VgDMDQ3M +8XylyjwmzDyJ8HLbl++5KXH4s+YNP3icnVTNjtMwEBYHOPQBQByQRhFCiZRNT1yyAlb7I3EAbUUB +IbWV1k2cbXYTO9jOQlVCXgHYJ+FJeAEOPALiCRg7zk+XP4mqUjz2eOabbz7Pj5vf7304nSuaF4ep +gAoSwXNwVkQwKqWzO0rzggsFGxBU8uyCdi6MxzQsiFoNnSKeZTRSU0VUGj0ny4xK/2PyaroZAUwE +RzuXPq7VuqDwhCbquFSHNMqIwAucdUdTXoqIXjHjLc/P3z6N6lFSskjbbWZXcK5CkEqk7NSHJM1o +bykNqDU90KAizqSCuA8c/iYZPDC+sO23gTgxNpUhOIOSHR9WPIupwO1C8EgT2SXfGEzWRDIr30SW +Jml7jBejUiqe71yQrKSXX649qrVftdtBLiybiI3RNx25rte75DRfUqE9ftMWdzYoZuFj4iN2mjJM +rRn04TGXqlkjRMxWN/FNeEFVKRhesRnCdhHkpHDdzZAnqDx48HC44/k9eCyoGo0Ulcp1GJ6ivixj +EBNFtFFQoVIqa52VpAzUiqJQT6lSVABhMchmKdf5kmeaaddk7Lvb4Rwm7llxTQOsvN1GykGOyYI4 +FT44QTDG/4sgcLymV44U0fhMRuNlymJUkhzvl2zSwA6ionCsm63keHmGWawy8MRQSN8WOvXlu+t3 +aoCEC3AbsDNGcpRHU59vi1sAT2Bmos6cokhjrLINP7Emek4GOwvfuqtUGUm2/s9bu71Qt3vmysKz +WrcILXVeoPgBZ7oDR69LkjWktV4BNzVaB6TE3djz9s2YN/LUxLL06J8eH2ENJxZacHejq69Oeo9z +pBhvHqIYJo0W1oP72MEyZxj6jzCgUdW0EUcIsyvE4lOtiZwaIwQlSnyTXpugXZmOVaMKv1argpJ4 +h7NsbeNfVSusCG4y3opT67Rk54y/YUAUzp9liYFwEqVZVkNC0mxLt6VE8IDyw2q4WKNW7YB2t+bC +jrLjpmHbMaZRIFK2t6T4ngeY5sxcAo39pVkdmFi1Md49w+1jrGjOliQ2Tvv4fdGANi5ztkdZPGem +AdVg0PzrgU3NwHW7enACDLDWjTYtSmf4PP4qvn9Jz4irk31giu+0M9BV/Yuw/kNWTseqozXVSyoh +mew11XyHJRbi8v31W5dfb9y+3yJF/sNf1bLVCsdbYBDdg58xsJkb/AkcMaQvpzXaexZzNXeRQBJq +pUirWXicmyx8UXij6n6WmPyC1LzknMRy3eRMvZLU4hK9kmKG0hP3E5UN5QuumG7Z/dHi+Re5jBZr +QwMDMxMTBbjyotSc1MTiVLie1skqs86d1NRr/ifPEbA81f1FgnPT5rss/5lFDm2K04oo12x0yTbh +2LGRLevI/AsrJn/gUBFZmtv//t5e903lmq8arkWf2iDOktY7WYMzGwCfSUJi+ZwB2aS2jmSXao0N +2NZmRly+zjvjOBl4nJ1Vz2sbRxQmpJDG0EPAbgo99DEUtIu1iuUGE5xKh7YJhYbSNKaX1NDp7pM0 +8e7MZmbWcmrEkkPuAf0VhR4CObfXHvs/9C/pm9mVvbIsS65A7O7bed/78b337e+nf7y98e7Nze9s +ap4WPBUDEXMrlHwsUjTtDYCLL35EU6TWvTkma8ItHjx5Nnfi/eubL248ICu8bJpBGFC5jYSEgdIg +yXiMUEjLh0NMINGvQBfSTH+5vVkGIfT6SwMEecrlAddDtCYIw7Ajle1YdTDSahyEDyk1PMkxtsF1 +YNpgdYEERkCbHonVKcFY2JEqpp99uDX969ZHP62LN+CpQYLlw8dKBwMeWxNW+Evhx59ulamQxUl0 +snc/ygqTsjawysJ1NrMdAjcQK2lsCKdU7roFP5c8w8NmDg7OIVkuJGoDI14SKVLNqCNivlcJdl4Y +0DhAjTJG5ls8OW/zpbPjgnzLj/EJyqEdBXtNXiSO4Rle7vg5eRrxGzr/r7D287XCWOmjQarG0Jv+ +udGZvtvqlg3Q2Vvn+HVVUcCqMl5FFGn/Zwn1L0ETa5G7kPssXIVhMnWE270gihpoEEVGFd/oGIGu +7hJFqrBuXSLtV8SEq6Gpp/sw/eeTu2WsskxYmExWOrUkERIdE1sufWC7e53ubqfLWuQ4of+GRWMD +5vZPY660ddS9LIRGQsW4sMRpzo0RcggxN2iAy+Qu5JQ1aiI/wTjlmg6ZI5FPf9jaLCsY6PlJa33p +8E0h6AL+tsd2mT+cY9JjXUaDL9KC4Hpsh/XPj/dbsN2AcLHBDWSPuXTYvf5Fs8MkgLLGpgP3Zifq +2wq3cW/6rYfLB7PSrqCqx6/BI0dpcOobgsk+dNuzSugeJp6L0slVUI3gSZaCGsBzXwdj7cWWnDVi +52Ij5rKsPKtMOnRJeYxB66yfrTbMHn69zRMi1zlMn25+XC4pijKbW2xRMcwrNaiYoj0ivV3Y30o1 +rmzWWYqsnKvDyRNrqlrVGCFpnvMULQL1rtYXAxkBCjJ7offNW1TrK9OAbSgb7NW1rhXtmpGWclL6 +py+IkWYKvrEGEkXaaSHjNh79/4iNXXIxGxNFQct1oi6b2MuWd4dda2bLS0G6qxSgWtoVm7x0Lxp4 +pe/JuaFb78aVThd8qEzUWukr3ZeIVElQrFFSjTpXEvOQh+Hip3m95V2QZ/dFrgPdMW7Iq/SZl/z3 +/37w94P/AOH4T23/TyoJFy4001ejyt48RSFZSv+NUY4FeJyVU01rE0EYprWatvmopYUuVMp0FclK +skEoKsYekpqWVGrRRHsoQSa7k2TqdnbdmY2tVSIeevIgDvTsQcSjkGMviiDeBL3qSTyp/8F3s0k/ +QrV1D7vsO8/zvM/7Mc8vvZx5862nfyFzPT+bKxSbn3se9zYf9n3olbdCv5QEqhJGXCxsly8yax1N +owq2OJGZ/q1j2BbyY/+rk6gL1FwZ4D23d2JJ2ydyIjwH3hYxBEeiRpBDGSMm4rbnGgRh16jROkGU +mcQh8GICWHalBWVY+GeZbF4+HUrJzbA6C8kvI+F6BD1KtL5aehDBY9iMCyCsEvCqlj2WvE/Kd6lI +AiEZ5OK6wK5efaCmB2Vt/HSIrDlgKi7fjp9q5O552IqDNR27glYwmF32xUr75B3XrlMTzE+jQF1v +R3jcqFTb0LZsB6tbtMw1XdhBiuXSQbAG4CgzLA+kDsMCFNwIaBS/Sgz4n3OxU9N0ZgtgZkl8T1e6 +iRVqBQlmQAFTFlcLrdY0UvO4jguGSx0xY7skBV1LUTeVWSwWjBpZxbpJKup/ih6kWfaoJSjjqfaa +ENPPkZ0IwjlWpYxAVRaGMwo911e4zVT5VSmFWrkRklsxffyAoSZa51paKgqSvwe3W2v6IpyQz5QJ ++SkWbvibsLsBu0PtDByGupTLXssX73QuRfcuBCzhrqONthkT9lqQI/Hk+/A5+TNsyoXIRfkkkpbb +kTPyW+S8jETzshBdkq+jkzGEYHNzaySu+eXIL9G6nItpIb8u/5/HqsN7ywiiP2Jn5cDQlNwcU6qd +zNphnqDaTiTdLobABT9iRXJYGWvOD13pK+67j6pFmbeWxKvmhSnfp1oKprK8gXZwCWQJ+y8UOPFp +cmPk5vGET5EnRid64fN9RNsJTE53S3PMOtr/sAMon9i8Mfou9Acmqax//wZZem7WtSqaALIdwKfI +JFXkApyRx3icAW8AkP/QAtACHjQwMDAwIGJ1bgDO2T4yvgDxbomhbcEmPNQ/4NgAyJEeMRTU2/WR +H4JJ7cEAnfgfWVW+ekVJS5FjNBQqccFgZJNRkuGdOEgHfY6yd2pFG5GrbxQjRRzsi2vvG3mNnir2 +ZC8yMejrnJMuASJWnS/i8hwAfG/gwPS25oZRw+YMhfrRo+OQanicAcIBPf7iEuISkL8UMLsoZ0FM +aCdLK0OG56XarOvBHY6R01IULHrXSuxJiED6Ssj9tgleyGpzcxmzOQHWARSp/IBEpY3AFngQSrIW +z1X7EUcru5MjAzgUkXufQ4ZqXaGLq0QwgVnpqqUb4xOTbwMnFOJHRs/ksmPyUxwblF1L+pnEEeYc +k6oDLxQfUKxkTSfaG8V5KC2bOZ0pc4v+fZPtA8IUVIu9zCJpKRrElylEFtpnSrDWDcWTwwQtMrtJ +tVyYPoZglg3FYMWDbsfFNKzwNDAwMDAgbmV0AIJv/yok9YBVFTKyKmAUycS++rcukyIFcRRfdyo5 +qczUM/m2zGk5MZRYDw6c5pOnBS0Ug9XdBO0BqyeqXbIXo2mitdNlskGz6AUPATT2GEZ3Ok/l9am2 +xUqYErMHVCpeMjQwMDAwIHNwYXduAGAPXMi4gow73ie8CMTMe362CPG0kysHmjOx+5Owjp4Vs/Xt +kSA6c04WRWGp5zQwMDAwIHRlc3QA5868exlrz9U+4Nrd3RkiVnbo+R6T+AdVFHJAiC3LM29IDbi6 +tdlf3GGCPG6tk2EIKRR6j4NOLDCyBSu9aUuClnc/r5IIAZOeCMRNScha+wHhLa4aPqlg4n2ZNT9W +PHADVy2OHnicARsA5P++Ab4BkKoUCtczrcdp852BqGxuknSTpZ9oaui08A3o+wNJH4YPKBiOCQic +ItlKhH04HprH83icATsAxP/aOdo5sLQOFDCQykFYjCyQ82eJhikKX9W0x6vNs8gO4gsU0AhJj5FU +7p9n3iv0VDcFbVYafu6zvhocAlHvG236AZdjzh9e0HM0KAw2kLsusU8XW6kIeJw78Jv72G/uDceE +J691k2y+Kdx+U5hx+01hpucvAbf1DROlA3icMzQwMDMxUcjMLcgvKtFNLCkpykwqLUkt1gPiEr2S +YoaG2O7M21eSjtwp8fvr/5650URlBx8ADmYVg/wFQHNTBpVEXuykl4pjz3FrObxVygp4nGuYwbR1 +BtOGBDUuHYXUioLU5JLUlMkJaoosOgrVtZMb1aZAGDWaKmJAhkJ8fGqxb35KaU6qlUJJUWmqAkiN +6GY/9TZGHj09PZgJOpsva+gmAwClEx88/gH6aWwm3tmR1qfKrnJUMjejwmLLGHicAR4A4f+9A70D +kN8UWr8dvPSy8AZd4NlekzkDV7fW9H+R88rsBhB69gGOBunT1twRtxEBCl2MCf8aU/uW/3ica9nJ +0rWTZYNYw+SEo2yT539l3yzbkD4HAHJACg77A47JHvPmNdUVsYOyITdVvwt6iChxeJwBOwDE/58M +nwywGwEU/vZwZ4MX2UZEyvWEpAqj6BQP7H6zLwFeARSYKLKsvwsswrnf4f+RqbSaiHudgbOhAn4D +KS8cLPYDadv9y5hXirsRnS2hO29dNpVz8Ld4nAE2AMn/5gPmA5CRFGyoESEpnOohNL5B/jQdOk3C +dzpTkBSxuRkBFAfFiNaTNc/rNeEBwvYPf58ZhqNQa6IXY/eHArD276Ev9C3TQ1HZ60PAP9esQN63 +eJyNV89vHNUd1+wSp0mIccBeJ0DSl2mUzNSj8ToGgtY1yKRgJUriljgUabWx386+3RmYnVnPe5u1 +45ot4sCpEtUqPKFeqOBUKRIHJA4BiTugRuKCKALEH0BvPfTSft+PmZ21DaoPnjdv3vf39/N5333z +h6Pv/Xn8gwvGpIOibrtOkpXmb19Yvhi3O0FI3njK+Ogpw/A+77cS3PEpoj5OCGI+QZ460YBFg6C4 +iTACoXYcXb6O2nGjGxLTQZaNFp9B24cRYoQyyxSCoD0VpiDU7EYeC+JIqBCflSyKI4+ARzGTK/SL +Zpwggj2fz/29cHrw1tT0VT9mrvcKNStoHfSrv5Aw5OEwpGgRlRey7cwGyFiRjbbVoZmZBSlBu21+ +rVN4lN+7WjxkwxuaWURWhG6iwEZn0YUFlBDWTSJxcAHtpGo5MopTpZg5SltFRytfOF4zZvnidPHQ +oWpNH+CnlorH+X//bRwxnuaPRcUT/P6mcWrw3WsHLiqFKsdup0t9S67tYQgIchZRBq77OYte3I0Y +2oFoLb60ZZyrp0mxbbdBmrgbsrwKkURLRBzJ/MDjN+h8Gf5gOTNj6/SMGBV2lEfSlmXzOAbPP1kp +To/JjzZ/67ZhDb46/DC//bJxjL/2n8IR/uCx4vjvtRoS3aqA28/duLZ2+frFtYR04oQNW2w1aBOI +xJyDdknPdCm5CGXvJgmJ2OVLq/C5bKId/i41pvqUNeIus10WP0esy9dXrrmUJUHUCppb1lKS4C3r +adttBmFoydBsWwc0O4tWRCu1Y+jgnk8i2W6UQF4bKvWojV+FnhTbaceco8gLY9oFkVs4CXA9rMGJ +KEZhHLVIooqCI0ZdaYNsdojHLHCRJInbxszzrdmbKx0WtIPbgBVI8K9mW237WTckUYv5Koo/BMwP +ImvOQfP8X75RvgbHFKwSghvKoVYY13FIHfmiXRH4Ad+HqKEpiFQ4AUNJN6L83T8axwcTrZP9Bumk +kAFPoQzUZbgFvWDCFyFrohm0urS8sO7o4pnSgz04U70ohBbBx41ukBDLdGdT/bkWUidZLE72TfHM +mRnFrezlEdx6IaYUrUJyWtBB4KolsKvBaDK5n1MHQNjZi3kRgQI9P/SlcdbfVpYk+DEVFqsg7Agf +HRGSSAkwD+kpw5btSsM195UYimQLK9oDKT6DTEc4IJXm2AHxjbeNR8aEdejcv9w2TvZlLoEmrKii +uVYShmpfu1oTrtRU9CptUidND+9zQDFGBV2V5V8Wb5dkQ3pk5LQEPndqhYcee2IBBQLr24f3kA4/ +dqBQ4j+iwvgTS8uAuZaIKxBZtbOKqn6QhGDhHg5SH6pBjb9+r1Dq626xhwzkCplMgYpJaShnuwDO +SwqQ4nqok2asr5mIbGoTAK6ApkBDqBErX8Cw9WQ509QHaAOrQJKVIfgs2FycALKbK5fXgBPQ2bPo +9N7bjlqpxjTenTyqf1qgDAISyctJn2BGklUfR1l0ENsqRBJDOAkViAQXMUM9TIeXqCiQ5J0goWyE +S3S+aBh4xJqTdp7f6OLQqkJMDkr/1bQxPtYyxvviQhA8l++zkQK2ccey1hxxwUEHrrfObAc7jkan +etGMoL+kUFOvZ7ZHsytM2Tvr2gWy2ZeeDy1JEIAdCcUnJSdnYagwid5fyIeuFLD4RXILMgdH7L3a +5vbTNQHbI3KDI1OmjTVLOkiTn5Nyl6RRSTaSQnntm8JJQZj85feNo/MjLBX9DEPtwj7/6xvGRFN+ +czLT2qIDF0/YrEDNA5r5s8SuxLhRGboHtxiJcBvKuLaWroGjgiTd1EtNMPMdzHzwTxIVfHKQCVzA +SJ6T87whCILff9AoGc4AHywVbPko2SMUU8UOqsPAMfjUL/G73xpHJjDdijyNSSiDnDwemRa2h5hP +K4n5d/cKJ4w6v/uZcaYPatwg8oBMc20876DzDppLG1hSlTL9KtkSPVc1ZQ5hPjCzwdLUeRRLkUnx +BM1mbUhsKWqByK8TZlVxtQ8KYRirV9XTk09whcLdrOeJ+RHg53wJNK1Kh3RK9hpLT7nCJ60y2yP9 +fJkz6tstqmJ0dRPsUvKTUuktrMuwr1A/lapmYsOuyrZ0T+VLJJTKvqvl0rMD62ywx9kEBVMLbgIF +ajoDKvaADFvAcclDMIxoUu+B3Obgbx/OjME9DhTP1z8tnBjM3hibN+OImAvrUv2wC/d2tpDSjT34 +2n70l8L8vhehPWzSB4Qa/g9ulA7/HAKyR43/6WFjkp+6URgbD6Fmlr7ryrVB+Z9TB2RaBo/fOHHQ +ZL0YnObP/Lr4+IX8yayt9RzkBwlwF1I3Z/7g+V0q53QeRsSbcTeRedgrP1/jG0eNyect29EzrVhJ +e2KhJEeBJy2ITILvw4fYHMQfT83rH2JM3FXMT6Bk6mbVhqGg4kGhcbKLWv444/dfKh6f9ZO4R3cP +m/peX1TTWtBE1gtLl664Udzj379vTJ5O4nY6zMGclUqpdpJC/NjdQumgbgZ+844xfSWfH6ENPmzD +gN4Dbk26wIz7056JRax18Q9IQ14rQv3rpcK5shgGpabc4KOBk9XfDdrCOQk3btwxJl9qCudxSrOq +QL+DvYASF34nAQUxuOit6r4q7LRN0nyAj00Y98lg4+upftpKIxJDqs0quq0Hp4qKTOZNrjMw5dSL +7OwX2/ndZhJ+4I4x8ayMz/u/49ulpsa/rxSdN9/5wvjonS8K0Xv/A4EVIkf6A1PQe5KsOZ3nSjiR +eF/zQFc2FRqteJwBOgDF/4EMgQywnQIU2I4/p2I33idE8EbOAyp1cxsHzvGzsQKPAhQuz0X84BXZ ++xN0VwrPUq7X070HqpNUBa3Z9xog+YsCKfk++yc9J+9viEElI7V62w7Dy414nO1XS2/cVBRWoVRo +VKmLloiqD07c0tjUdcMq0QxD1KapKKraqkGwqKLWsc9kTBxf177OJBqNzJpNJfwH2CCxQvQHAIIf +wBoJNoWfwAKJFec+7LHnoYIE6oZu6tzHOd937nce8+lnR37/9sjXrVtRi2PKTeOD25twI4tDPADv +0AsxBY+FIXoc3B7HBFLuJjyLYdAPQgQXEuRuEKEPLAl2ggh2EeMUAp7CIHHjmG64YbCPhg1uehh5 +YFrQfReGxdOz3xxlkYfFtXMnP8R9jHhqWJ0W6H8ei1IOHiZkqAsXh+9v3r3jpDwJop2gd2jyMF2n +PWs0eYNnSUQXpJfiq9XVXHntZZHHAxbBnruL99wgMRVuC4aVAYAQyWUYEJbNwEcbUkz2MRHfndop +5SilVXIUIzEkQhEOdNjMukXIiX7IBu+5Ye9ujFEbeJKhXT9BEXR9wjscNZcHScDR9PpZtGsDRh7z +ibsNHtnbdr1duiCdm5YTZ2lfHbQ61b5J32TxJYDi86VTFtSIEWyB3lRPMSYpw188PL5werw7vqV2 +Xft0MAAKv0NC2WTeLnJzbMEmUEG6Kf/WVMFxHPmM9qxIwMiaDq3ySSiLRVhojREUXTjz1t8xowAV +x68ax9Rt8Xnn6lXYOMDEC1IsNS0U4WdCVKWuO8D7SAdCRoFMaTUIQ61x2Ga8D6nknDrFTysXcnfg +BhyEjE3lyAYjRS9LcJ1FETkwGrjUcSFRs7FO9oVshzBAd7cttfQRfd3HnjbrPOy7kR+iZes0a0tM +OYFaqz8s3c0Iby0rRtWXEHeVrF2NpUoHEcWp9PMTRhk843SPYkPHi1+XzxU/rrTyJjO4nkXOjqdt +1iAoqyWIa6IukO3FxXLFEfwdHxMiPg/Muno5iWqxXJtzsbKra1NXhme8X0ddPFs+L7i88Rwuxfev +XLg3bJKwp8DZdCBEN60ttWE2T9KuVcTHfii+a7eKM6+eyhumjbbMImPSQbk+5UZtjJZkGPAgpkUT +DwK+zmRF4+Q1sRzOrqO5TGdE4rR6LAFTRxlzqrLs8DrSIql4j0qaTBPWgwfy2W2ZcVuqcsqe8ciF +etcY31FMVDdgg0j0gsinAkH13MfZbtbgHYPIJ2W70ecMkrbho4hIInoNZZwxejTRU0R9enbxzeKT +m6++LL6fXF6g/4wr1HzEn3+e5S+i41CREpXb/M9bjS6M+YtqNdpY8cXSif/bjfFv9QYplCo/pt0K +pI58QCHC8RvmU4+oU6ROv0q7LvDDGCnHy9eHbrcLRilig/Ky2mlXNjsT4pKpIAJEG3m1PpqhaOQ8 +lCX8wdY0JUXHNA5oaKRqxRKlG3lFKVCurjkECGFtTVZ1qxG1oJeDqSnVaC42SFnU6xM2kAm1ISya +hhfEfVIPHvCKJAzcFCImFmIiSBV2hoZEQRftZdy5c63TqnU34YE5twaOrKl3UjJlqQyZlJQyTpKS +y01IMo6e8K09mBPbSmvKYH1nVPtuzCR2LYh29Xqj4pfV19/mYnSS6lNmq3o3u892WsXPK+dzzUnH ++D5jXE4C0tScbt7sy2Kao2ZC01oZcfnT44r8tQEfs23YlnGVLUrIVpx8nGEm2scgpxbjVJaV1zHF +utfJvakhgoDcRpd8CgeVaIJonyZIeUHjKEdOkZSDTsD7LKNZKIuiCXC39vbQD4TTCeb3ErZHs6tT +HDl2MhcKWpwvIbh0SSMv8ybEaIfGV5EBy7OEX+vaboVZNO4KT11kxW8rC/oNFex//oL1AOrppXS7 +x/yMflwmeIXKZnIInIG7zwJfDxQ6YKaeKQSXbKcv+NKliIJOj5HGYnBPQyZG9acrS8WXq5d1jxlO +zHQJpizcR9nFrGrGC4cNddo1nnb5lnKomyZcZUi7+QbSvKb9qOyXW3I2OdF+rTDaC8UfN5+cU2Ed +NhxSVyOYWciLZcPIq8FOrYlxbuNx5obVPFBH3pwDasjryxXgB/MHM2Nj/dqd9Y3bG/kNQ//S2FL3 +y3YoRTnHgFViHtPSY2jtp8fz51Xh7CiNra2/AKZ1SAn8AWdawlom6bKU0XKN+4a/rd97XZeIeJwB +HADj//YD9gOw4gEUStmu6Vf42Nm8hRqzX1aWk0lp1EfdYg8N+vsFnN3xtOO/FmXPI7aV4wnO0AV0 +3ER4nNVaa2wc13XGjGWKXInUgw+JEiVeDilxR9pdPiRb8jIUJVmW6lhv2Wksci0Od2fJkXZn1zOz +ohh6sVaL2rVkJ04n8UUcPyQkatMGbZWordsCRmwDBeo2du0idps4keEfTdMfCfSjRQAXRXvuax67 +S4qQ86cCtNy999xzzz2P75x7Zt762xVv/sPK689JxzR7zkyjbMlMO0bBRPqFop52judK04Z50Ljg +lCz9WMkplpxoxrCSyHYsw5yOcTI9c8rJFEqOGFfRvPt4cZd7bm61+9pUx92wJBbBPVuk9W7+xb/E +A7rU1BJeibV/ljdLZfdQunsTEWTGKpiFkp2bQ7mClkGaWXBmdAs9cMo9MbthZbpg2g4y8sWC5eBf +/lDuPDg0OIjKMRQ9E0OGikb3oEk2i7YhzUbFvnmjjLJWIY8Us5DRk0XNmVFGJtWRCEKM2XktV9Ip +r+5aXnR9wtaLZIW75k82b7d03XQszXTilm4XciWiMyWG5oEfQgqZm0vkz9pKEvXj4lW5vZLRi3Rg +hIuN5tEUEjIlBujxOAFohhAE5EKjSEPb0dRIf4xtILglYa8gtQaUQyMKp/KZJitVhFNAOOwRmroN +luAcJ+GwVEQ7cbZgmFFlwlTU8oRZK5YNTMb75tl3ThwD2tTIJGec1wyTsnV/ORvBrz8iN6G0pWuO +flJ/vGRYOgpZJV/IlHL4/S/IrW7k5e7Ps50sTjkaXhllMibyuqMlSlaOmpL8y+kOYuc5rJvTzgws +HHR7Xt66ttZg+P2fS9vcW3/Yvhz0OTGRyOPENblrZ9VqLkAUrBTQk5rgx85ROrz3OWmTG/m4I+LZ +RnW/9+QGt/jpuq/vkRrx5pNSowosfNfgHMCuSlKBz+C27k+/sX5g4RA8RaOMRKIaQ8qOJHjshOnu +Ta/fk9Fz+jRoKYP8Y8LXLPyaAXtpsMssBBVTZQYBB9iiYM0hw8zoF9w3d7e6ebOr4rGJ03Hfs6d1 +U7fIxICtgybSzMWZa9gJ4awKmVQ8b2VnTgf91U6ABBkgNbW8TmJMaJn8ViOME/FP9+PZ9cRxlvdo +tq2D/wX8hY0MEMxJO8oIvnJZutfdnVHco99uqHhhdjuH0xXhOnfmcEyKBFBpuajnLCcSA3V0xW0e +4xpSwztTPYU9zledCk7c154DfnHPavG8np/SLeLHHe7PlkXc93pQw2Omfl633H0XuttKpkBZVDAP +A5DCju7xQ6hl1jIc/aCR008B1kbdYmbdsC8tNXmCbBmrY1ruOmDdrw9J7Z1MQGJMIq7HBMQFF64s +1YU5U4I0I5Ey/I8YoFEtPRMdVzgYgQ9SOCF/Z41cJq1ZGSWlRpVFXL5CfJ6oDG2xAVYd3bTJZFoz +M0YGhglTlvfsGa1I/XDeywh+bIyK6dFRLgMaYx50hnmQPUDtUtTS57RpXUFJHigVpimPpaNZ0wBP +owRjPfblAarbRN98YBfvhGQnMAVhCTooT/rMiJcAZCwgHRUoGZAoQCQ0Suh6CSFl30v2ZLIoLMtt +8mHAU54PBXj6gNztvvfpch5qdhKCjfNLoqAz8AOepTZk22yrJtmmQM6ljMsq+zseVhI/CnApmJOp +JPr8qWNHE7TcwF2zckslZIEYIoqgW3h7L8RYBCdheudI1rMAlP2/R7K+3Lyv6mkjO0finOQrPz4g +gwUgrvxZQa6FmtLzuN8AunXs7qs+BAtFEPb2GLc1gHE1fHgUAqPPCHjZgoWiTEVgTB0Vsmhc4Uoi +ccOMpqRIPUvJVBqIgJPwK12yLJAy+uCkj4a2ozlGGvXNE3bgLADrpADIgl4g28O3oqWfN1iRnTds +G6TzbTrpnuhsw6mK3NXvgwCn8vOPBwYBOGi6PRyQMWpuAgecaTUNH6ZkAhl8bKgKxX7m/glqSPc/ +vtXSxPZVR/rdnjdb/RIFRGJGFsHD6IDso9nN+NUz0vLdtw1OLgDyC/n8OdAIbn5HSuBffSg1keK1 +EpheetjeaeB6oevAvWnWjkbVuwCI3BP/2bajjtbB/0Aosj1Sjhw78MjhB84cPfbwmYPHHjl6gKAk +nrskj21cxOzuG++uJwGJ8QWp2f39tesbHqN6xIPX5A04dlnujFCVeMXFikBdgPf+i4RwcZ+0DP/x +O9JqMj1YX8jauOTGUvGTvyffh6+skpsqzL1ZXhPRAnmtvz689EOi69dmNUPcHqPhkry/XKNShobk +FgoAJ4CNe1cEnQ0TF85F01ouZ6M9aHAR6wSzhB8Bt7GLe+vI+rvpxvjiXdLmJUMNWcJwhsQPIA1C +AayhDkaKIoo3BfMkqaHOU8TRso5uxal2yE+GsfGCmZsjKDQegqFqIArgUDUA8Rwt4kNcRfrmhSjl +Sfz+30sd+KleqavPd0NOGCcAFgCeEPSIqOPgY8PiNKsuKLxMWXACD3n82QRL6IkBG1RqZI10FewE +gQf289lUVQwV6qV02qsZ7uwG5JcNVTzq3fo5I82OkVJW8IuG/JxyDbF1fzbbhb+ckJu6bwN5uHBQ +7sDXP5RW4tZ3pCj+0kF5BcE4fOGg3BxdKrq545lYJaTfQIAI4KOZ+2FRJbNACWdzlrfrgYPgTQAi +yJk0BFhQjuIvX5JX4pH9stJR369wolfeQKBtxF9vZFFt2he+qpYZ9ASDA3/VkNvwWFS+2/2op72Z +FizxvOak4TaCH31G2ry6unLBFzV5HV77T3Ir/rNeuYGtBVxtfsxz0omJATx0Te7E1wlB4jLQ33xb +brxvCZKJkFaD6o2+sEVu7wthnH7BsB07oGVAD8cq4atb5Tb3zOQG/Iwpr8Cv7JZX4XhUXo3/R5U3 +VpjdGDyCFRaC48Xz2J2jdKUaqOsdIqvlbD3kE7ezac9imgtyqoR3Z0LzZMEuxT7M5HQty6/VvrOG +xArxoj4bC+BiraehsQgaBGUNEVzHg2fljiaP8wvTELSlPmnVvqUmCrFSJAuWLuDzxjPSX0/h65el +rXAnOd0ZDFgePEwz7qpXNvTxkUQwwBntOZoARtF82X0+88NWXt7D7dkW9za3VT+0SsQjH2NFxXff +kVoGQ5t5EFDVKA0U73jsOWlzc1jE7z25yR3TN+aimTmARCP9BPfSjPjC+oPn9SfEX+KlapwI3zdA ++sLAxxadAv8fPdw4mUuQ5nKK4DH5QcZpc7DB8QS4MaYfv2tN4PzH6VHdqzOJe+toRRG4HchBSGje +WxqrVtyN2ZkRuRkhftCHQBB370wXfui35cgLR6H8evs+uaWZz9LzKURhHUl2FCU0kwq6aTkkCNcb +5W+e7XCf/p0W/NI1ualFaDbAez/nHZ66PXMeiME9tvKpBLdTVKky4MLbhikW3b1m2037S6bYkqKM +EmTmam+1Emu37/J2XNpOxMlCGjyRkttWKGQ4cI5uztUfDrO88Udnm+WRGsciBSUom5bvEBhs35D/ +EAoycOM7uVGpEvIZmBGewK+gbH3A7EkP6+MEtMIEAdMF6CxRZkaq9Aw0O9g+cXKB1fOA+5xK6Cgp +LsMBCveT/O5DXE7kATcwTuvGedr4zuiktM7wjKJbiIQpmjWcmULJQY+cPIzsUjZrXNBt0gXHl74i +RZazUgrhprLctYN0y+xCyUrrqDcH2cDScjQdkd4ZHx8LTQAk9zwj91Ug+5PaIg6Zzqtbx8kIYZ9K +oskQjokJ2DeYJom0CzwailanStbySmtFAvVKC8BHRs9qpZxDnsvgZ/NSJ30UQ2u4A03yOld9eSV+ +/lGpsVkoJ062w9K70gZc+FO50b31buvaiQnBkuFgdB63XJa71tq6biaKJXsmKlbj68ugYrj5cVM3 +6ybGaE1qAy5RP2NMMlBf471/DpXS2z+CmutWz5pGMYNPmHKn23xxlbxz2O252KWWy1WpBFQJByeh +SAR9uEDKQzAh7fV01SR2oVIV7rbv/Vpar4YUBrwSM5aeJW2sscdLujXXm7W0aepWpP3jvvHp6i8w +ZSdR+B4oDnyEFXdJRHWR14pRbps9wkiQuflSTxhEW0aH7yauknJPnOtyf+vFf9/eP68wpSV3DseU +qg2U5DgUZHqqPGHC7QLvS0ltrvnNLRXeKgcVjSus7aPQ0k1PxcJjtBLigzxawpT+oCANNJyifklE +mkdQq9DQKh2EGAKzsdYSmMGmF8wttriMoahAnySMql7TPUogLIbEJL74Fak1FHND9WLOWSDkHJu3 +rStaiQm0eNgptcGURGaJPFAhT1F3eU9Hs4ZlO4T97dbsZE9Ud5JFNsCNmVnSqh1klR+WotAizd+V ++Lu7pKa19R393sUcXV3Qp/HnmuC2LEJ+TY2ywmG/nOl5wH210I5/UJaaGmK01nG/erP1Hj/05ymc +silUrlNrCyOD0396c+sAXZnjj1ghOKilPUVT+3oKVBlQtG+sRgH/IXQKH9subbqf95Eg+UF9rFMQ +jnnPLMmoM1ugoyk1UL7xSrZgQuJ08PHXpPYKOYa4QPHgCZxobKF2Yj/ou8okTH0qTPSP9Ad4JBco +XymYP+iB0+IcvQt9v6/w2ub3TuoSMXFCO2Ad/gybmjCcRsjCZtY04JvgV96SYqf5ieFiQkwYQDzY +NU/bDvOoYBlw1dBySUQGqedSVTLJmZPwOe4vdcHw51IEX/ya3L2T7Zj0gAIMMA7oCJGTAj2OD+2K +Qbim/HKKyISHPpTW3TWMyu4nXe0VXyKCdcHCi8lCxQham7hjTZGBFqqFWD2n+l1qEndwjWIDtoMP +paQWgtQ58VDTQ2QPcVNqNIICl044bTEHGZMAbBW+epVKFc7S/Ri00hCVXtpaEVEdF8qLs8XB1j2z +S93WknDL+XJV8cEycNVF3u9XKey2k7j/N8DU/eT1NvzNvBRZAB7d65eWUVAkDTzvKGPC5j7yxapZ +M5AMg4r3jNbUZxHnyg+T/4OnNiTD1J4lAISUMQCdXgpixLBjADa9DMXITyUVBt5WvyKvD71tDWQ4 +6SHvGjz5r9KKFh9zaY3GS63GPi73dk+k8SDGxtFQisPoumoY5c+w8cWX5HXD5Nk/eWVmhL0Rgj6H +dvCv27fXgiaRkNz67wlgLHk2yNZCELCGTfXzjc+CtTHqJXcEuMHjkvs5xbvK0pB2gdqbP3hiKFzP +mTkB8eP6ID0CKE3UWBefuWmYvUP4TJaoFJIr8yhj2I5hkvKKOO0p3YmKhQSZxYH3hKQFWLeNLzF1 +ArYGF/AVMWZGNbCSngkMFXS2+5i3UdqUWpMXGPrvQVVZgCA+vvhF+TD+wbNyg/uLp5pvHH51hbQf +6l9xGiW5I6YQ6XjZG/M+UjHyaNmsHSeFMe5JSMOnYxH+FkngoUTd8pVWR0gD/Bc4gYwMfBoOeSkK +UBiuJGawuOUvSW1FHrQKev/dCKph939/3O7eKjRuWyLOicvZ5iBRAIXYtQ5AqJ08JV9Tsz19nQ1f +eVbqWCt6jvHxoeEUebOtgB//kdzuPtnTfARRUyRR4N4T9YyjeCuHYBF7/SQAayQDBnFNdQemt+Ir +z0mRCgEDi76OEr6OVjGswh7GZ+FFw/UWadMaWCa8Zk3NTvzu1lnxo4MVmCx2SYuX15gMV3yMghSt +Z8LURDd022pigbZJcrcg9KDWmGAM31OJe0L3wWDXkJ2mqFk27Z0LU7NqiwD7EJtL2LpmpWfAUPz3 +jGbPjAQqD7/wqL1R4p/+m7TqVBAjaLh4p2S/AsdYJI2lgqWNuH5uxHJZ3nIqXLykNdMv1zTyOjHd +fhppU/QdLR0dP3bqwS/6TRikIX6RQ1Na+pydgyPi178l7XCv/Hck7g0FyxbNcoyslnYmJqxCwRkQ ++T7hSj9phbhr6hYjingfFQX7YB6duybTin+9Vm5pFAvcj852Di/E3k9o4umb4AjLNq702AMdfj8t +DXd7hpoqmQ9c0KPBR4lxXcGvvih14Cd0GbmbbjaujwtV+Ydm3ZhErxzDz+9n17IDvnRcPtqSUXkF +ziK8zssqQjpIuIC/v1LlbTh5VoaK5GmppbeGXpyZ3ieZW0rTcpuUwp88K/8d3vuQFHGP7G/Fe6bl +5e7xXEODmnAK+3X8XhSKkkf3b5JjkRsN5pP33284pE/qQPzQmvUcf2EH3K5IYZHUsVOapbNGkdeV +o47D25luz/dj+I3vyMvcY/9FX6dd7r5xKxIhqxJGflpRSbzT12zdH39/xRHR8vKgQ0CLvyDhzOhm +IDsScxYgyeUK03xUMMFXkYTcwX/sdo//TWQV4TBhep/u4F8N3/j2X1xCDw4MoJP6NFiPJBT6KAfk +tlGhCCBljiDYjh0eQlGbyrHKvhAHnThaDtx+DvHtEvjqNWnDSj4xSqjwvp9I3b97+oOnT38gvXb6 +A/kXy/8PGLngu/YJCWRsyMT8LPaWwg56TiIdpRV/v0B4nJsm+192QwRLWHpOfpJucmJxarFeSTHD +jlVmDEYm260czjw2rzOy4Vp86DivoYGBmYmJQmZuQX5RiW5uakmiLkiTXklqcQlIT9uyv+HxDMxa +L9f5bil9sb1l4pcDGye7snwSeR27YLO3epWl3FvldYyt257aKiyt3+zNysoukvfuQYY0N6vMjasC +2TuZ7lTMfv3bcHMKjxETAJMrPZ36MvxgO1RoajienI+Std9dDl1mGJVOeJyFUsGK1EAQBfc2IJ48 +eXkEZRMJPeyIHjYqqHgQBGFhT8Ng2kyNyZJ0j+nK7CxDmI/YiwfBX1C/w7PfY3XPREZY8ZTO66rX +79WrH5+Pfn09+jb5uR2Nx3iBfK5Zn+Y4P3uLUjsYi0VVE4xuKIWz0IhUhMqAS0Jj511Nxw5Ma0bl +zDEH3LFuGXYBbSA3ZFxljRoxOVakizKejoBppGG65gO1UYr8+vvtuy9P1OMsTyGfWbqvaMhXQBcF +OecLq2ZphXypucSitQ0iY+d06v+jDJ7mqT8rR0tVk/nIZaAcCA32BF5d8HZAukF3Pf1y705LztYr +mssUkn5H+qRra090cPVHY3DPpWaQmTs/HHXhrBlsPTrJIMPVATzUclNjsXPp+yZDn2D/a+M1D23v +hjbB/nJuJZoWIWCfr6+ndfD9cD/JcOfZxxd6pV3RVktOPed2IslE3v8kZDNLYtGxo9otAS4rCUQw +y17QA+9CuytTIH6fBsUpVrruKMGz59iIpIVtERfWOIbM1ucxzW8UcH/DW4F6ef1fBWQKWYLzszev +rCRpyHDsi5I+nyXhMcgeLqngeAOlVKwvdcX7TYjl9SRBnyi2rz91upaaoFSgTFr7UZ/cyka/ARqN +A5n0zQEtmMjq+QJ2a23F2kPZFn8Tvo3nA3icjVZNbBtFFNYK1B83DUpDfkia9mVbyLp21kkapTSu +06qHip82CEIpUhroxh7H29g7Zmddx7KC1SNSOdCRWCkqtBy4FbWFG5EQcEOICgTtiQO9VBVSCzdO +CN7M/nidWAUfdtfzZt587+d7793+csv1B1tu3lp3+y4qOxuGBcYio8WKQ4CVSdbMm8TGJVpxwGBQ +pNaSeBtQNpwCLFbyeWKrSdDikJmBegwgSy3mQNEsmQ5kwGRnTCtHqwyOwsGJQ1OH4AAchASMwzTK +TppWZQUlk2OHp3BhfGyiMZlGHakUvF4geIVNLAdypk2yDrVrQFZM5rAkMAoOym2CQC8gvCVKGFAL +HApGuUysHBAjW8DtDrGY6QnEAYneMkpED4GGNjJEey7WAAgkNqXSglKZ2o5eIo6hIxLEbpN3KghJ +Uy2aI9PCD2pcZ6QskLdVO7/gifLUBq1I0DvEWkLvZWB/XTpqFUZhfCqN6w0pOBKRJGAy7R9IJOLS +xaEu/y4MgrkCNA/zKoZC1c8z+Sr57yyT75S60DwOEYR6ucIKmjQ30YDjMqS6USzSrOYDHZXO0MN/ +3o3+f1SdRQc4dM6xTWsJMyHhb4in/dtWY8HzXDqGT9PRVJOBhTfmacXKITyD1awsaHz9KrhQUbYP +iliNBqk4GqLFrXV+9c5QYn+9acFqaJXnEUzWLC0R4fv6ajrGh9e6TzeTGR3VPBp1SXC8atTk0YgA +QD1esXQ/4+YQqxZXp4HfeNDr6l3KjhHhoHiy9YSfKMEpcYK/MDM80H6bFA/OPHN0g9hLQHmdxzJ/ +IbSh5drVNN+z1qvPow3JgCALwuRXFs8ji3QklG0Spgkb44Hx/OL9fr6+FpsKkaZbMEDoUaEX46sG +qnPqAmT48JVu/ubD/vG2O1V8El2wLvI3i9QJTu79qIMvvxfj37/Qu9dHuUxqTAs0xfXz1LQ09exZ +y/0zrfTyjhen+exXv7qpPmWH+9sVZdvT08CcHO7XWbkokuuspcb5N5/u5TeObXV/1JRtQ/OhQZsD +Ce7LdWUfv/1o63Pt4waveV+nCGPGEgF+7/e+Pa2xa7elsyV+zVuekutqELYF9+Ix5flJnxRYgEWM +alBGox0sW4YDAvFixSzmUEtO1DrJHCys/NbVA5IuQ610kRpGpYaAMI3HEaaOjM1mEXoSa+QSg1VM +f6NqmNGr6x4uqZRNRyiURJA2rU5D3igyAquR5PG0I9oTtIE8R62RspM3iw6xm3mMuR3JOoFDZxh/ +Db9E2uMLq7Dn3UwmAyOnaK5SJLNCudDtRQsrEKgjogSFahMwooLWH/FqfCTCmcvX+/TQesvXFtQ6 +cVEEsrfKx2/OtiTgSJBn2zs8Hzh2hWC2/nRSmZprU++gWiAWroJXpfI2LfmNS8A3gg6jhw2MATLC +ywUR6DDsSRn2cJuItW+XGnbNFMXWZ2NT4HB/39xm1fOqLjjZUveD7oO1fUWNI1HbQJqXjWbBK6+p +lvKKolTJZAytkR0oFYIJepCoOArw4Zlu/ssHu/jfl7btCDUkgf9zp4e/8XCA/3Wpsz+y7pWRpFc/ ++KuX+vnpu92bykEzGv0hjA305F0/dA9EYG0W97g/n1Qmn0Co7jVH6Xkr5nE5GkRiCseGsRTcjcwq +1QLFRECOkhX0kzcumd4AhYcwlJYcSbwJiuvfHe6RsWx6yoslv3ZnN3/7xpZGHUrLKBQVKwlV23TI +CbMoC5hka+tQkmfqJhZuaIqB8LFDiRrgVxt+7gezCBxpGV7ajSiSxSQ6v7WbpnAuwaevPHKyWkDz +QAsON2p6eLH3Ed/QoJvXJDK+1pacPoUR0EvYSCbGxpIQzjLhseZ4Mx73ZpooHD601tEdRiCEVXMH +LygD88EuHFxnKbAac0gJsngvOMYyutyR0ywqR3I4BUwDrH1yCA1+ZZuKAqRnC6i5qR0h8M7L/e6Z +d5W+rk373IdryiAfWds5sXEETMmHDF7zS9I12vI18bGxG0bc6I9xSXAfrSkDuzdMAmq7EeDZli3/ +t+3Df7R9lWeOnkaO7+Iz397lf3w8iQzvcl+qI9U/f7+bfz25/cNOZc+ToqZ/8cn6Z/f+BRXBKez7 +A6v9O8Exm/oJYG1ogFoqHkqe57nqeJwBOwDE/8keyR6wUwMUJQNOFaGganxkTdIoshr3/emj/uez +ZwNFCRTCeUNt02jOLVDAKyV+danhG7KF1bPADIkCD28bJfsYsoXv+7j2VUNGr1FJ7IXFq2NCGyh4 +nEVQvU7DMBBWhy5F4gVYTp4cqQp7IpaOvAJiSJNLMLiXyD5DoxDgAdg68CAgsTKxsyKeBWEnbZjO +9vdz3+ev7/nnz/zpbfasj1aO4rVTupDRy6ueiUdwxEpDRpDZlnJotKsUgUV2jYzCZI02XgBoZFjX +RZuAZaOognuvLbBUhEXq8bwm6xnBHM7gf1HnMQAkNm1TK2KbwIU4ZWcovraVuFwOeKn8mgQ6mCCR +gBDQj/AYK0iHK0C3nwCUbdBTg0osp9exzaFGt/t4P9n9nh8/hAY+XnaXKQY5jhI5v5IWzS2a2Bkd +RTHjlmWUTnb9wXl/GFL3AwG3DeYsg7HX1SuUor4RAzTaD9+QLgL7D50geT/+BqECtZd1g8Cd5IVI +ptdBCD3F6g4keJwBbgCR/7MqsyqwBAwUDvNMUSRTb07ezzGaHIs8hq4b9CqzGAxvBBTw+fTRpJqZ +pzz5rNeXvtg42UkmxZObEG4U1/gVnV09/WQGm4+9exIHmrq0E+mzHRF4AhTECzZ/IM1S2ELU0x57 +LV0tCPHstLOpE4oB33UydPACG5cUXH72QitHKFwB99vGiy3VCZZ4nAEgAN//ogOiA7AuARSHm7fJ +KtmW3PpKQhWnBM/GZhSx6pNCAWDpJg57+Ba7tc76pJ+KFk85vu2oye4RtIP9JHicm7tA6P0ioYYW +xhamFuYtLDVdXlwKCkrFpQUF+UUlxQoFqUXJqXkluql5yfkpqSkKufkppTmpCnmJuanFCol5KQpF +qVmpyUCFmXlliTmZKQqhIW66FgqpxcmJBamT7a2secD6lXQUqoHmTv/dxWI33bybZR2PkWlKakF+ +cWaJXknxZENp0eksPSzGTEam0817WFpVYKbmJuak5RflpoLsyUksySxLVQgN8oEYP/1iEKP0dLki +FvbJEy6yTf4vyc8OdcR0sV4WdcnQIE/XoqL8Ig0lIAthkpLm5MZ74lMXsHCzFKUm5kzP72ORl8tL +LVfAqV5zsoGN5PQJ3Sws2w/0sAgzQl2pOP1LL8uR6VmszF7T//SxiE9+4PBEQMFUoSCxuDgmT8FA +IS0xM2e6Hjuz3GRtOx4ACMR8RPkGr6CTgxeDWKAvAAYreQ0Zf8pcIQp4nAXBsRGDMAwF0IIuC6T9 +XSqgY5KUNDoix7oYyyfJG2SPrMAd6zBM3vsu13LQsM4znpmR1D4Px0aljB5kgU1L36vjJSmxQSoi +i6M3D2PawWZqo/ZoPeCVmmeN6RbsMSWSIvV98vC7/wHxryb5+zz/ok/pzhsilHMBDb1foFcmU6dj +xnicdVLPaxNBFCYXwVws+CM5eHgsYmcl2SaCaFNaoTVCvSgoeKiRjruvzehmZpmZdFukBPwLlLl7 +9eBF6cVbzv4l3sSLF0FwZmezSSt9h2Xn/X7f9/2Z1n5/r335uzqhEItRlqLGBBKkSco4QiJQARca +3rA0BcphzFM2Yi5Ho9LLCuIhS5OgBVQd8RhICOsb8LYOMFaM70PCJKzb1FH2gEkSVNVtV92e1br8 +BkBQvCMXil6roAe71m/u9xvm64vLH941l6Awu6Kfumam/cbEFXsrnHbc5phHKqM5JzuZFDEqFeEh +xk+oHrYgaKOdGCjU21yjPKApKZc+bkG30+mEwcBvNDOlE8Z7ELB9LqQtPh16KMb63CBK6WJ8iJLp +heBxuFY//WfedxuT6ojIwU2qpJl3zCXukf9qoeCCBHP+9hi3KFc02oPnN97pnCmrSJkUDpCoKeMK +mD6fXW8rK7AlhVKgh7ignlIZlYhy2wRtDlOAXMsjELltTyFlB1heVrQs7qc5ZdpTmCJmxFKygAMe +ZhjrkrEZuQVYvk/GkhZ0wjCymo20eDaUIl8AzMX8Y9eR4QH0E61ezbfta+ZHr3nzjBAHnrg4T3rw +VEura2J1HZrp3Yb52Lx10YYEt8DtmE+PXpmr9y71WyX5od1hE4kfWu4+j2wJ7pAmwW3IqFLBmSwT +Pr9eX3gubVy54E7F5OTnau1GrWt+DUzxXT75/PJx7R8zrycg/gbamWvPW9fsbKkYxRhnqZLicjFh +M3icAW4Akf/fJ98nsEYGFKsXYnnf0vhdqrFYngQ7WIOGDQuZs1oGDAMU+yC+CotUZfyCou4kftwY +Pt8MwhiTegmfFGNSH8MigOewNvIkDVT7Ewe39VMDsy0KjQIUltkVJeIXvlRg7M9/GmeFDpD5Kaqz +zgwRBzqOLrP3DVAgzbh8puG0IhhCIF5c9KPwnRGeeJz79pmx5SvjhNx6fX2FkIzU4lSF0oLikqLU +xFyF4rzEguKM/JJihVKgcGJRemlual6JQkF+cWZJZn5esbVCWn5RtkJuYmaeQmJeikJJRqpCcWVe +skJRaglILDkxJ0e3uCSxqEQhOT+nNDevWI+rJLW4RC8tMTMnMy9dQym1qCi/SC85EWj+xrpuZn6E +jCtIZvJHfZPJ+So8mwNYrrBwwCQnR4nJbXbilOCFi2yOEpuCxHunzBEGAI7GT09+jlAusrqwqhYS +tTJ9cPN2NwekANV4nPv7kPnnQ+YNz2s2v64RKgEARP0IcvQFAPOFlWco3CqCiTF20V8QhG8g+Ht4 +nFun/1l/wgpPfX2FkIxUhbT8omyFotSSxMy8YoXkxJwc3eKSxKISBSCZnK2QnJ9TmguUyMxTKAEq +LijKzCtJLdLjKkktLtFLS8zMycxL37iGSRwARBYfaKcGeJwzMQAChdK8lMzkTIbV1XOP3Pp8QULx +qnbQh6M2Knv5GG6bQBSUpOla6JYl5mSmJJakMtz/+MXBtov7iM36uWuTI4xjVZ+U80IUlhczLKi6 +fk3ava2vQfr2RAfz+bc/Sp+9CABFciq++QFtbzFx6P6MS6sJC/1l0AGaWrgL7XicS0iY4CPSVs/4 +7qznpH8y1xIVvl/51OqpMNcIAJl4DDj8DjWs0YKOvNT+OlyzAFhc7OaLibVfeJxbfpHxy2XGDTza +yonZqQqJCqFBPgr5aQqJefklGalFCpm5BTmpual5JYklmfl5kw1jRScnsHBJZRSlpukoFBTll+Qn +5+co1CrYKuSlloM0T25gkZpsJiFvXq2AoSixGKRCR6FaobA0tajSCshIy8+3UlBKSixSAsrXalpz +TWbkFw5Kyk+p1Msqzs/T0NTUK8n3TSxJzvBPykpNLtGoVigtyrFSSFCpzsgvLgktyqnVT08tsQea +Yws0JUFHIbEovRjT5M0ftLbbAgBL1VAx8wIEyimND5xHBcNG6FcODAot0tpatnice8H5gnOCp0jm +24fPJdtveTKHimxqMsgW8mBxD5sswCixsbSYBQAO4A1A9CzPg1eH2TH5DiCdUzzr2gDcQtAlHnic +mys1V2qCiGlfYtgli6xAHynJOSILX1y6/Z6Z9aiJARAoJBYXpxaVMJzQ0OB/1M5zJKTIxuia/bl7 +pdINlRs9Y5lFri0StuGO+tCovXjjyzmrPkx+9zhYavIu5hqR2jVGjLnCVdekj2TLu/G+59zRJS++ +2YvlHKOIz9/5zz/8WShy2Vnv54UPE9MVrn9ZMVmHLSZCxTnp69vozw4ff3ZZ7khi/felN70Z4oqM +kpICI4Z/+cvFWPn/1D/eHfhm3+bCF1MLrIwg8pl5xQWpySX5RQxivhzuwS9fxns/vFB2/0ZEb6vo +RbPJD9gyRTbrPA/kbg8/urQgQX9Bw8EFa9qXC07eyG6yeSL7OkaRKf/zzdzk/HIbbvqv0WOPDvNV +em48OZjTUcR0Hp9jj96cAydCbmwq+P1+urrufqvJKzgLTX+4XJoU9E5uebvpAecjP4LKbdsfzoA4 +prikKDUxl2GnX/fjVadnFh2Y56Hzb6+ZXu+mXZcn+3H1iSitvcr+l/kDr9c/ZqFXQumRDRNuXJv8 +gSvWaP75a2mKp8RMdN/xeSz9+cw8yoTzP8TIkpxihh+OcsZbvyZaTvCeVXpUZcGHORPYlCfXc1vV +v+AQb6nZU/3k1v8fOU+cOXKKauK4IdpKi3IY/iv+EW9KnP9mnvUDUVezRVUHNix9BJUtycxhOCx+ +Jvij4knma3kPGktTG/5atJbNhEiXWTA8u76vTE2pI7o6/c1fxk38y9StGC4YGhiYmZgolGUWZybl +pOoWZ0y24MmsafqcIrm6Y450oVySxLXd3SEzVrCaQ4wpTyxJzmBY3TlBJH56mPErpSZl1R+9JXXt +jnug8vlF2alF8SUZwEBLKWaQu+p84mDdXxuhHG5frQ0/1tT9vqIFUViVk5nEsGdxyb2/TVPCqmNf +KpT/+jtj/47nJwB/czeS8QKO9zc+jj9X9ZDsUeSW7FwCHib9K3ic28e6j3WDPaPIxQN5dusXRprs +f6fw77OsW2PnQs6+zcGM2YwA/MIOe/gR13l+z7hvV+Jr0REsr6qZN1S4tE14nNu+l/X9AdYNv0z1 +k8tTFJIT8xSSUhUSFUKDfBTy0xQS8/JLMlKLFDJzC3JSc1PzShJLMvPzlHQUNDSnv3dhVM0sKMpP +Ti0u1gVq1i0tygHKVNdqWnMpAEFyfl5xiUK1QkZRapqOAlBhSX5yfo6OQkZ+cUleYm4qUCyxJAPE +UqhVsFVwKs3TAwmE5Ltl5qQC7dcILinKzEvXSMks0tS0nvzPW2ny61ShyTqm8pZg84E2lKdYEWtB +YjHIT5ML5KUnt8WITW6r5p8+zZJRhBvJkskP3ZWbec2285oxrtIAAFPSYQf7A+YseekMASRwAqw8 +Szh518tpHNE4eJwBOwDE//ES8RKw5gMUGi5NYeJzEsZl0qWeX+/HHMYZVDez+gPkAhSBAMAd7zuG +ri1DS5n90ip1KbjAqLPyBn8CM08bif9g2oniVtq5v2zxzexkpJ6FhfBRp9F4nI1U32sUVxRmJ2Np +osZA0hi1ticXhRlZJ4KIsiFKQhNMCEUSf1BiSG9m7mYn2b13vHPXNYRlpQg+Ct2HK33rk/RBKaXQ +B2ubh0IfCmIpfS34B/RB0MfSnjszm50GFR8GZs493znn+8535+V3Q9/8MnT7TuF769+f23/9896E +ZLQWF8GPirBWFatAeQANqvzKTFhloOgGAwpXFuZBlPFMqAqTENaiKqsxrvToH9aIvvSlPdIqC8nC +NX6yLqukCFtAqKduKVLCFwJNd7wPoFznvgoFhywXqzqc1lgJYiVDvubCFmYB+ILHCktUJCsXIZJC +CV9Ui1ARsTL5GKOqYt6gCRMwVede1MLIZWFmNlXXRcidxaSoE4TSLYLJdpMpACRTdcnftQGNDX2D +bOLDbkXMV85UvVxm0sNJfaoc2qCnQwU+aqnYAqMBtkZZnRzPTA7X9ZSYlJJuOq6rv54qDNkEp9Iv +9tmH+ySLRfUmg4nzevT9nsFWHr7agTMe4BdKnGWnpMqx50eLm9x/Xc9iXnDiZ5XGu2wQbXaf4MmJ +5BxXOAN+Iyj9D0tcXKUXC6mchMn0jTqtOktZoyJkY+JL2mUZu7Rv0OH24/uDhVV975V1cM8qyQd9 +ExxpkQ6LHeu9nojjojqw1eyk1/lbAZhmUvtC5ZA42UmcGNyPIBCAbs4MXnqjw2li2AY6g3VNEcYJ +lhrf6p8qtvdhzv0nO2lGQ9Ndj/7Yc1x/6xRO6PVf7SF94CPrQKvjcgSghVMr4l0pI5HS2NjYGdL1 +ZSdMugbFEOmatARnoJlae6dszGJTNwtC5s1rMlTMmLOX1kqpmHr0Uc/wHI7heoI7hEkpJMkJnRqu +gUDFOK5gV8Wu2zv1Wr9bH7TeXC9XIDFsBss5GLHGQCLa7LbboYdCg5NyTFfBE65ujqqSmzp6aO/f +bw6WTNay447ryWf2wf70dhMlxAaESj96aI/oP7+yBvT8M3vfQHqajIxXO2D6xWLhkL76m92vTz21 +Dw3jjMg0wD9KelU8dBhWfvzAPqfn1qwvznbkN2CUP4yvhTwQjRguAJleWFiZ/fTq5PzsJyszs/PT +K2i5lUuTly8S0IW/C4N6e6+1Rw9M2Uf1x3ft3vbeJ/1zu7ZGa3Bsy9RuXue75c+dJDJ2v5eWr/PP +28+PHGuvP+m727tt4dPzQ++2vfHZfykw9mn8BfUs3M2a0nMYSY1gK6IzPMcvTEgEeJwBXACj/54+ +nj6wAxAUq71Suv5ylxhVwLApM14WcE4qXV6TjhAXsy4QDAUU7BnjuYOgJBkDQDx7ldCi9lk0PJqT +zxUYs2YVdgkUCtXZ72O+V7gB7AbWY+SH3e6gXqKT8B4uzJ4oDPlGfJNBWLqWx46YE2K8qw9ZZynj +5SF4nJVTzWsTQRQ/2No2Fw9ii9jqc6Q6W5YkFgTRNLbVglj8AI+hyHb31Y5sZ9KZSWIQDV4EPYjw +7oInjwqePAhCT94E8ar9AxQKelEvzmyiJZJoPezs8Ob9Pt6beRvfdr28N/D868RAoQBz9PDpOG2O +DLbQ1rTEBKwCu4qAdZQWUqWqeViQiZDXs7BGU1XSIAhpLEYJNFQtdSBM0+w8ToXHseliES4vsnwu +QRNrsYycuZ3VqumZom2eZVxRGiE6KZt21Z8JA8ZTuCUxIFUWZSHwAGbKcCsHEDugBW8XZoDToxtH +qDQ3RvNjo7lSxWm4/BBo9thUK4Nc0WpNGCzVlUjKS2VecRQAFeYs5DueeOAEItOUMfBroTeXIXnU +iERbiQcheALoQgVLYS8yiFYsami0tLB43nWJTxeP95HwwEZXnkvbqWy2AvRUNzZq2Zo5qxJ0bTpR +LLKwk97DRWbDIboAO3HS5uzjZypLQq2VDv6m7ja0eWa09U89iQ1Y8HS/XxMmLPjThZNf73GzLtr/ +Uj3gXP/2bvP1rOYXtfv7QrBPIev/U8hSwNmk6Xo0qXAzJ1G3J4Fe3z1MB5+t0Y+PI3RoY5jufDpF +7w7spzcXCvRgPEcXP++l2aE99D3aR6/MUbq0uPuqF+4MhG+7Suvoydpjm1eSszhVBll2O/40CE53 +SsWbVYytQ8Uo6pgEeavm3VgzenJ/krYeD9PW+8Ehl33bfS++TLz98BNHMWtP+ganxzQQSBeHhJVH +OCeRN7jkiyqvTnicAWoAlf/3CfcJkB4UDu/5cFDv5RfatV8vD94FOyadPNOxMgoEFCdfibzmv4sq +ydr56WCHHtdhxgqRk1AEIxT+z+Jjj/1ImJbEQyIxgDB975Yc9pOHBC4UwIlucw0c5nxZtn0ZHDmR +UXhf26CTyQQuZNMw7vcifTR6DmNqSGGEejHUn8tKxJKhGL14nGu4wd55m31Duehkh3be6Qu6GVkn +Czkqb54vuk4eJiK8OcF0Uevk/kowT2izyO5PBnC5yQmmKybvfOswyY97ssMhls0Cb/llkCUVpv+1 +ZxSbPGGjyOQFccbb13MyejCjaJ50Tn36X0lGhckBfhyTDVYITg7YLDz9wQNGiUkX2Sd37FObziPK +qLq9n4/xFwtMH/vkIFP17duFGUtYkY3KmLxLx23ygn2C24HmhUshS0lubzBh3KPMWlycmZ83/SIb +o9z0B+2MopPn9HFO3vBKeHpYBKPJ5NkmnNN7IhjllK25FMCgOBWs3rWoKL9Iryi1OD+nLFUjVS85 +PyV1sqCv2OR8E9bpBRGMbNuPRDB6MyrroGiwQtVeUJSfm1k8nS+KsRXF+9P9ohlf8KFqne7YyCg2 +3SeGcYNQYnliZgmK5PYvMYy+Kmg6tgN1GDNiU53TxKjJiMV8r+33mxnzsWmZDtTiN11qPiP/dPvb +jKzbV7QyRqQBAEIrzVb1E8z4O/7gOskBwEfdxGyV8tv1O7/3eJz7E7Q9ZIOzok5afpGCRnJ+XnGJ +QklRYl5xQX5RiUJ+mkK0UohzgJKOglKIT7BSrKZCNZeCwmRHRRlmBYWEyXGKDjwq1XD1tZPnKsqw +JuiAlOxRlJh8SdFrspSS9+RkJU0tBYXk3BQrhWigHAIklea5VqRqaOogi06ereTqgSKioKenp4Fw +la2tLcQ5CvZA5+nqluQUK8UqAM2ORTEoFuyOx0pFk4OVpYD84pKU1KIiKwWlgsyCVCWEylpNa5DC +duXKyf+UrSabqWhNjlNREAZKQNSApWu5gMomV7OobF6rcp4FADmWUjr0VxVSVyf3EW352AHXuJzo +tu+DjOBYeJxtVM1u20YQRtsEAVTf294mbICShbKSBecHFJw0cYwmiJEGkAMDuSQrcmhus9pVdod2 +XYFQ30GnvkWAoC+QU1+gb9Dc8gA9dpakbMcJBYjLndlvvvnmI//97t33b/67tEvag/SQoSMPNRTO +ziAqpTPofTTuqdncOuIMzwld1Ngc03Zn4MmpjFYfLr1bZpVD2Ia5sxmfFdIdHgllMl3l6OPo+nWu +FCXjXmaNJ+DDR+g43WM41wO4CyXRfCQyh5Jw0mxPmqx4AUKIhmGf84mUOfQpLEAZRUrqA2Vye7yc +qN8xhc3haAt+bG811AkjpxeQG0xmogqI2/JJx0dYE0ee2StrolCrWcH2nfVScPk9m61rhpJxV/Fy +uCdv/7588sXTa4sWl5uKQm0fMYlmFdXpYLA5uiWG/NtMry2CvPXLPnfj8FfM6JmRFZXWMXKeQiG1 +R6hXz6/8ND1Pd8FtDQawXyLMWQ24t/MYCqu1PfZAvNm284OHye7+/qMnP08GB4+ePPjl4MWzpw/u +7e8CN9WkyRn/EesyE4y4+mPj22Xs0Ft9hP2OUBLaz7RCQyLUitE568Jmt7rbJbaPCXfaIcQJX2PG +bb0SdyCeeArC4cwSnsl4Fe5sh6ltrKfHJ+u3f17568ulRnaecp52pNZTmb1i2zTCjHshxJpYk38+ +VshK045G6TA/iwTl9iZQ6MqXyN5X85L54W8EU0lZ2JIEm6Pb8FjdF7A8UFSCZj+zYWU+U0QM9nAE +xw153w94VCoPx04R6zlXml+qKRaWHRDsXs3CjJggzLVUpqkkTQ7M64iLMVRgPmfZPE9X9By+Fg1W +zOLdX1ZFwdbk4zaLT321NRyubZ6Gh+GwD5GMkj4fOX2nwlsVNwNcNE/huqgkuQrHXbRu7ilUJsdC +Gcz7vWS8cr1/lhfNdzrU8won4/ORqx8Ppgt+Mq11/VCb3EmH3nmFPx3k7Em8evn1+6+CQwcb3yzb +jE8ZnXE632Iy/jj4eVrrsMDXldTxegJyqnEPzSGVfbi51ebe6GS64K0zHZuAyEIkbo7UPJXVq42T +/wHOVsNf/gEbe8RavKkGRuT9LCZU3hT29I7qYnicW8K4hHGCkgj/T+eHRjqpl5Yo7+fQn1FvXuqw +3myiWR4AsQULrP8sGj69XOsgsKlL9PETfGfc6v0AlEh4nH1RT2sTQRRnS2lrDiUmq4WK9hHE3aVx +Y62HQtkGjAdLUQ+9KQHHzYsd3Z2Zzkw21VBT9CPMwbs3vSjk4Ek92Yv4YfwGzibZ+A+cy8zj/d7v +z5uvn+dPvsx/2Dtj7jiL5v3akjnZumCardZovbS1UI4TohTsMiUw1lzum2tVdwkGJbAnNS/KDefY +PCxfWWbY/ws19INtC2s0YJ8RoQ64BjwSXGoFcYJEAiOaZggpatIhmmyDPkCgBQfwPlNAIMkxasoQ +WsKYM6UhJkL3JHYgAtInVIPgSvvebSQinKAvcu2NHdgAKHWIhz2S+MWceePWSkURBOZtGYZFGUpU +vUSHheot6+5fppmnDKWinNVh8z8g/UxgHbzZiibWplnyHe+yjQ4e2TizEcY72Mpbd0mKKqTM9u91 +fe/PNa/+HtKfUuVMO5FZc/2FCbvZq6zetF8xm4VsE3IBlXvQhDJ4QDt1UPS5tTkeucqsLIxV69BN +yGPVDl/fP+uAeVmpOTfMu8pl93oboiiCX6oBDIyprjvt0ffqJee8kJhR7Bfp+aMnVtwz31xoFi0h +ubDOqU3YtWK+P4Cx8HEA0c7kmUt4KZFP0a6tGWYk6aH54dbmwnS0fO7TnL1fna58PF1xhos/AR3M +8/KuAnicMzQwMDMxUShILUqLz8jPzy7WK0ktLtErKWbIE64tFUycH6wq/vWeQNIZl9xDBoEAZWcQ +m/dU7VuqkE/Hez2yu12EXfP52P6l7Q54nI1UQWvUQBilpRa7K8XStVq34NdFbQbj1vUkW2NFEGxh +dSuttBTR6WbSBrMzSzLbWkosnj3Z76RXPSmCUG9e1LP4G/wBgvgDBGcy292Ubam5JHnfe2++700m +33/2/Prd83Egj5V8Bb9lhvFNfgJf57N9sQ0xfs4X8F0e2sCuNbYzfkyySFo4aI9ct0iRcboSMIuA +K1jEJySELGISKKz5kRSrIa2DXKNyIgIahIy6m2AULg5NDuOzmX58dXwINzIj+D4YXCxBTKYyAOxp +g9Wk1fZoL0OKUtxilgybLCHKcBO21B1gY80PGKQkNdHkEhzHgStkZyq3zSIRrDNwboBqcN6vM9GU +VmhQG0ok8QOoCR5J2AIjj8HpTGIIR/Xm0SBipIubTXWFj7KjV5OnhBeD53MaBHujdKxdPzLeCW33 +k/P20nQSf0HHDVzovKkLDRZ6IqxTXmNAuQu+jKAW0ChSJC8UdVgNxAoN5pWzyv0x3q303+FU+uuq +7qhhU3obqoe83OYq7X1IhYZPbPwym1uA2AysLlUEy6TIaZ2Bz6G1FEm1saxrD9XiSZuw1dEbqe4I +x4OL+GH6BN4rncT7C6e2ywlcTE+r97dln8btPTdI99vSVw/RV4/Qb5sIul0S+DArE9uB/ej8ut00 +eqDZwF7kGbw8N9ZTxudnz/RpMX6dHR4k+zQawpm57AMuXKa+dp+vdqdX7BTVNkVSY8L7nyHwZm9u +oAxys6EFONl74XSqKtXpCn3PZ24Z8C8ZHbHUD0IdvBKxSJsWE8wunkdy7QX+WMyhs0TcRnqr9Bk3 +5OqRcGtfDqyZkNsl/bkW0tR0QB1UD3iuDAWvyWvSF7xg4PRkJXzp2LvL/p/+f0YTvoX/Az0v1/l2 +JKemtoTB1qnEvAZ7qGuVeJwBPwDA/64YrhiwmgQUCi5S+Em/M3a/DDd9MBvYTyRUrEazrgQeBRTi +Zss7vYsT3HD0EasabMqQmjpi3JNxCiWzBQopAh4+GND9SEUOxv0pBXlY7CdHxpHo9L11ynOIeJx1 +VEFPE0EUDokYLSESiKgYk+emhlldlhZj0GItEjTqAQ8cODQNLN1ZdmC7s8zMSknT4ImzyVz8A3qW +mHjWn+DRmxcvnvwBHnzTXdoStUnT2bfvffO9732v396OvHs/8ub4ogOKtpJVJk6Od2ePNkJPQZO3 +Wl7sz0UspqA4jyT4HLZpwAWF2FPsFcUcnwIPQIWUCQkHgikqMdkEwKeyKViiuHBhg6mQpwqYAi9L +A6l4IsEzgSCNIkhYQt0C4GcJQZRLvWZI6pZUPhZaDpgTFcJqgCfx4lgqm/TSAaxE8CaV0r0l9efC +ZX1pbPQIWt6e4YJEDDJsR7y5x+Idy8mLPHkYN7GRFoXqI+jkUcigoR74DnCsFk/9BlTzvGoVTglB +DeplBxYaUIH6ggPlxlIfwjvw9M8q6NHFKT29OK1/jE+MmviWXr6D7Ark+fBVIaocITicdlHsmNu6 +7mb2ZoA7qBFUppHCGv27cDX+V4YRWdEYU3pyr2OzpNgJ/K4DK2kQUOF6EUpCypulUsl8UeG2Zdtn +sYZrczW6ujw/tRz4lZy4a5TK+Dj9W7tngbacoYeGedAnd2/oexdm9KfSzPluL1nfXH2mv5+bPxqa +AiqdpMrgJ1yo/w4iOzqQWaQ3kuzYC+GroeHQdkKbirxYf7nmJp6QlGTgtu0q/mQ/9eoR6cCgqQqU ++n1VoC8XdO2/MDO2bkTjHRUauBU60DfrcfNB8T5AN9MDQ71f43di4R4w9EGI9o455MN3jNtZDGu4 +afpL7YqbSjQx+EygFvnOklyKOVM/l9XhwnSQof5ae1wTdD9lghIrRpBKIC3bHcwVrasOE4pLfGq/ +DOzUffaWfl0id1bS2DXwJPFU6O5yFpN1JZAKQSo2eseUqLZCB+lk6ba+Vh7XYnVyMlfBSmOfBvhP +4lt6ojw9Zu5yaRtJ+PrDw+sff82y4h+lzGwQrwJ4nDM0MDAzMVHIy09J1S0uzMksSdUrSS0u0Ssp +Zki//FHNaxLz38TTxTvFHHiSly60iwAAh0ER3vEx0MbU8RloUiVW8mqR04PK3jwA4g94nIWSwWsT +QRTG2UISU5Mam5KKh/ZlbWVXlq0WlNLaUhHPlfailFAm2Zd2dDO7zsymbULsQQ+CFME57MG7R7UU +9Kh3PfQiCIJHr/Y/0Mluq9JLF3b3zffme/zmvXn9Nf/tR/5de2DRI5LUiUDwqAgDQXygTFAPgYCI +6qLBaR05+EjaKEBuIDQCxrAhacAgCJGpvTG/qDUhgaOIfClefq/EO9eNrDosnh22YX7hOOGGkdiw +1KcbIwUHvLpLxZIuYKul8Wn1aygX//5ilNWz8wW1O2Sr1sXc5JHPdmVw51FEfGs1Yh42KUPPAckj +rNlzg+pNpqKmxi6rVz/zqkcK6uB9Li49NTIZ4tM2xns1Y+RMEs7CtfjgqlGJp2aM7P7jgdvj+8Pm +hXvx6H2jtHOXB1vbpgNWQsxwExLF6kKTciFnwQwY6rxAfVhPL+VmYELPgW7PrjmDoJ9Vk7bCgEu3 +hZK4yNp/y53QgQhY1nW4d1NITtm6AztpsJCUqtmWWafMSxvOSAs9CAnXf4lcQNAEoptff6DHoHcQ +CT4VUgDVb8j1ULikmCzRb87CpOhzrDlHjgSomwCnY+sDzS/2nQ0Uos83l2T/E2AeTunDXFw1jGm1 ++7wQs7WBrPpczKuPM5VLE4kLbq2kdgcmUmNfSSNTVatltbx9ZQUAt0JNqHvuuq6QRGILmXTXUVop +u2Xb0Pt3HU5hOr4cD1+UyiePo7/q7bnRJ07ng9MxOod/APtmCHj1AqAGlMU+NaObQcVE5DmDo+zR +eAt6eJwBJQDa/9kH2QewRQEUq+PrJ5XTyFVBC3e2OySjwfprxqKTkQEYs3EBaAJMgBDF+oUCduKC +ogMDhM48+eYRTUHhbka3hXB4nK1Xy28bRRhXQgDFoKqoJKVVC8MWiVnV3SbpBcWy06ZUiGdaWkDI +pGK9O3a2Xe+4s+MkVgh7QOLGAQ1Sz3CpKhW1t17K48ix4g/gceBW/gIO8M1j7fHaaQKlUurdne/7 +fc/5zTf3vpy69d3Unerk+YhjJ+WM+G0U0HYnJjyiCeowkhK2TlLE1xjdSNC6H3fhzU9CWIvaEY/W +CUq5H1xFLcI5YYiRgMBHceHWjLhz6u33nW4qJVgUcKdSQvpfQJOUIz8FcI6qoHOtGzGCnYSGZFF/ +Pml03ILSFvqARVzcvLGQ6Q9NP4q7jADMxV67QWPsbIAAyb9bABCU9vVd4ocpKMz1l1YaV0jAvZA0 +o4ScZ7QDHvSwBvQ6jHLKex1SRo7Sd8poq4SmpOL1o09OHPlYYUACsAv+af89iMmPMV+L0nLui1ux +7B8/XkHb5dyB7WKcZJ0kXDpZX62UxMTc7L6EbKjY/UZM8Jb4tX1MPLhXenmAvT2KMqil+O3Nwy9C +dFG6RkKsS12GzKc0Xiduric+/RAf1oseTbATxDQlEC4EVq2hLXHtvdlncyUsTRpN8cL+wxllSmg4 +AYQxyuwM6MC8Tjddw45adRRQ33NjXlURO5tgXUntip0VwRVCARxq245S4vlxjOuD7JSRijRcdT2+ +RhKM6wp7VYedK6OHhpZVdpAzASlxElq5GJEPCemc09gqkDKqmyig9XSu4EEXZbWovwQA9Cq2OryG +5myhkECwBBW72lMa0GQrp2ePMH/jhPHvBL1qbR7Iofhk+ba4UHtO3K8dzIYFP0rAsZSH4OMicmTJ +NiN+Vu5mNKfSL/9KFsnokvqtFiMtv8A1AD1MNHo7Ij8ISJoiysCM+PnygdmtPgC5tEHPScgUbV+/ +MTXxfKYMpM6qDEDvhShJgJ8GNKHedYT5ZgltGpGv9jIzrFG3MGmXK0zdIsAAOrAUZ26/bchmB7hF +MQF0F10mWGn1U6tw7f2QOtYa77IEdRPNTKH+bmhDmmtDRvwWwUVz2d7sGfURg4OW5/QiEHHSsiwU +QQJKWGATrSSEX6afyJCjLA94f0B42yORyHSPhLG3KAaVskIIaBYSy8r2oGqGT8Z0D1ZNUUYDW8YP +paIdeR0g/CQgK018JgdQ2kX5jOk9rwLQ27qugMu6F1dHDHimHiZik75RMRmwkVGPloDKizaYKYt5 +TwFx5NWWHKJrpp7CnEx0dmI/5dY2kK9DLozJmpQxNO0av+AlG03JLhkpK+OrY/higzSQH/odkE37 +VKGYwpBQcSiBsPaTHYaSs//DUCL+PnVQ/LlUEl95L+04iRiPd5hFZOYfYRRRhStMIhEy22n3SaRv +fcdBxE97SYCa3SRQBN32o2SwQcXpz2fEj5P7xNL96WNIgoPLkB7aw2MnEnH7C0f84E5nHngn7RKG +h06wDT/SHEuYJ39wfhSrM9iEIqGxI5dR2oXjgIQkdFxrQnjYAa3MZePs6cP/ofagiloKfoifxL1/ +Z7bfY+KPqaP57DYzPlPfX6tmVkcas1WkJoFdndVSj+hsZuXImO3PYzvXRQ/e/7EwQ3URf608/Zpp +QqUHg81gu9SqaGEvg43U0HNNJMcVsxsLc03+oNvbC3werGFr4pRFoDHRxGXOgYocSuQw4uVzDpRn +vlIckuaHre5hSPpscfLu4uTEN4+d0bx3UlrvtiXphRQlVHcsWo5pQ/HdJbLJXyUyTiAZGG1RC1b8 ++BJsR/H1zAFJdtngk6f0qpaQZwNUoVsg3Whre+QWkTtRpMWilyPXtSYrgVdVfYEQlxsHM0/WUN5h +POkwri93m01oL/XizC84rjXYDk3r9i4y5jyfMb+nEbBCcE13Wguq+/qvcCg3epy8RZIWX3PL40Ab +kJ5htIbKWw3JX49DymBlvOoYVxp9L+QTDKbeYKYaj3IlhbuXwRgroFwoCuR3FzgLu7G8Otb6vRvT +Fn7j4so7MOofkIajZi8Xc13Vs9+Kp34qifbCM68ouY7PUgJXiRBOZ9c6rBfg3IEa5f/Pm3dZMvH7 +zSPi0NKhuw8en7g/+Q8wqTzI9gPAV4G9IxdRUAdfLY5QYnj+RBe7GHicATYAyf/HAscCkDMU1JcS +ZRowlY3tsYJgpJeNtMG+vjyRR30Ueq7rHj/Fd3MfxFfE3c9liksq3ciR2G/BDhtA8QIIs3/Rrof1 +C2IJtK6rm0gH6/CxY3ica+Vr5dtwgkmkzuBlzIROGZE5r6/Mn7mrsuizn6rc5jtMmiwA9MMOa6aw +bXicrJ13IJXv//9JJA2rZCVlJDmZGSVSdiGrklHHcXA4yxlGlDTIKkWaRkoZpYFSZGU1bElIhVT2 +TqF+932fc4y6D33e399fpOvxvO/7uq/r9Xpdr2vcigoKqioq4hQ0mYJAOhJIFDLGBY/EIpB4n004 +NzKLUObeawY+1dejgvobyazDCvfD1PUUZzJYMsIJ7YykYimeSCwVjSCQMC4YQGETAIv8kriSV4n5 +eX/RYiN0I8Jn+2atpLlgkJFCX9Kqv6+pxZ662Oq6kXfGBUGJC7MYEg6BQ1JcERgsFu0C3CkGT6aQ +qCgKhoAH+aJb3axPT8tc3u5xY1CubihvRJclcRZPJqNJ4A8fPAosnzP0Zu+6LNSdO1sdhDmyRDy/ +yu00ginvSMVgKcClEHgCBUFCI50QziQCDuGMwaLJPmQKGgdqHfbYsummUsGl4Ed5NdzFy2V3qCwq +gtFCIbFYCgmJckeToN/JIOtLHvr1czRVbuLjk9sqLKIXayy2w933TNYFTdnJwK8mJ/2y4Cpq+c53 ++8TjJYVCorvNx+fBSWgi8L5BOKhvye9VE0v6C04eVSi/L8/t1WsZPQ/siSZhnH1AmPfswu+b1x9j +667c4Lq/Fm3pjVvKBQe7olHuFKQLiGS5ibT4L8a1vj+tue98q5T28ChqIRyCBX4BGgjt/VJJGDxE +3zmeuh/Fh2lYfWL5XflX3keX8D/tZkaD5V+/Piyv+vuHj7eObDRiUam7jM3ECZjyTmg0EeGFAVoW +mkQikEByNMcOZVP5ddlYMe9+zpeyLEnbnr+FIdFkHALlRkbg0GQy0gU9o24kik6znNcKitnZXvLq +yZOQBRNjxRIwAs5IDBa4PpGERiEZ7ThV8f7ZC9q/F8uLIVSWohrq9h3himGCgsWVeNvVbyQqp13J +exocumffrwd7HVNhimOcp5/u8wPRqxEvo9Ixu81YblI3yXceFWCDQYDax6CAh/TGkClQfe4pDzG6 +zZWYJXRszUSJuCj+MOKxKQxH8SGinZAkEtIHqlq0B5VmFPwfhAkGPj1Xl6gvzbGj+eqCMIEfJ//G +wZI9rQc5uvhKdF9vCWnqjco1EFC4xzu7JNCHEa4EgjuZ9jsJTSZQSSg0AkWgGwXak4buMb59O3Zx +Z6tor3WffHXg/eMId2ZCf6CO3ad0OL81P4l8lajqOrlWNzH/Ti4zFI1HOmLRTtA/gOqi1RYv+Qja +0HabwuUqDLu81tP9q9PN+JgJAO+fSiJjPNFApQPdDEGi4o3wOmABSxSBCJnHHOMyvL/o9Ystuxvq +rm2JIG4JXMDJVI6KB6wj/U9kUAHowlQXV/BlotBERktrC+urWW7W3SHUu3FxtKBz6p18fq7/QZLi +igGqnwR1zURWXPKbidrE5CD5RJke0Y9XxqVPMJOiPSIB6CzOWIIXAg/8P9pp2i57xYVT08TPXjyV +8ToiLTRJzfaMcv4/SlFIPsCDUlCuoI6e4qffX/u/G/QnCl96Yyox9FvV6Mu/6YA0MafUgCcmw2VV +l+zT70jjaxofHfYyoz1xCBfo1hsvtO2LeX2zKcAvhvd71OCwwtWWz8wgLwIJNKfQn5zxCAqahAO8 +JwWNUASVugScbPg5b5huHX07GWNxt9UaeZJpJTBVUgKVFp53qv2aNpJb+lh+TOuq+PpR31L2/1lJ +GVTaXtqwf3OarhumlPxxv8fg1aTi50w7E1MlFVCpeN1iHo7KA1y7+ZIah7tQGgeD3sv9rYQlAH4H +eDUEEmhbHTF4J5BtqCuyuST9w1Lo55tLPZv9Xx6z3HRsPhbo2hS0N61bXkGt51eLGr3NIe7f+elk +vzXP3u2/5uMhDwG1EVAh89PC8KibPULvhoJK+BzWPxCiuofPp4AGboAEORkoPMLnIz/efKaTVWVp +FuzXGn1BHd02rwJgVxBOBDQtEMGikdC9IG9okLZzvsnJ4CDw+b1NGAmxIqvNp+RKoRARwC94yNaG +sZz1aDx/4NGB0k9XjMKvW/JZB2r/kwIOCN4wKCwG0IEqVojtzXF76tMcdZzxr4m00byWyecG/yRE +RJIAwz/1SBvON/mRR6hX3yvsc425JZSfbYxjm08HQyZgpxxoZ5BrKHLVQ0frBVlH1A0fFw/JkXzm +EwDNG5lhaoXb2o3vjipvc5fxDstdefv31iBi83wCZDySSHYlQFWKave9UcGV/+Pb7pRfNeigmkPP +bxf8zXuRkMQ/nc4p9UspXB+EDbnPviSFW6+LthFUgOkYEEnBkskEICKjTHlANHRxcw3ei6Grazdw +N3rFNnS7NO5w1OT4S2LKXzJ61d3E9TITYeJPiieij69reSd1odL21iyKQsBhUEC/RrpDVcStTmT1 +NEkgi8iR2tmHBy6T5a4IzSzvCMTJVDwGRXCCimdMvObQXf62t4zH+PaG0w7OuZJ2s4JUR7QzgYSG +mjjaE2hQUGsHwR08dxc+OnakaK9xKlvII0y9/JG04lkgcP9AdEirRyS9JT7DW6oLWA8+Tw19UXVn +BwlTnVh4ehaEJTgigDoA7BHB0Q0NRphQgILcFdJ+615/agla59tRs6bH48FY7B8cyh0LRENAiEnA +Qw+2wymdYPVSbOhW+Q/TetfJXDOWFatgEbDwjaVJAly3jj/xqC2q684VLh/hvv5+VmESAemEQpIB +B4bE49FYBIoKNC8cONAhAncJ2eALrK8E9onV8lelORgl4Cr3bc9OniVBISDBl+UIRZL9B1r6eHZQ +SSTE6HMOyUMEhaxZPsyR6uwMGmkscJNg+aVnG559LOPnyG2pU+opXE7co3setjwY2tF+B6nsdVk+ +kVIeuI9K/uv66rrGWFZQZeEoMgqDAcvf63ksJZfVbLLoClf/Ofsvirn3Lm2GKe8IWFvwzf5xNa2I +Xo3QHRFrr7S6mlrcWKx8M8AmF5Z2ckV7Qy+V09nmpy8+O+VUObk2uRK9e1K2Fw4AB68UVcg91Zyr +rF+wZHVKjc71y7nCeGGD4W+74RAfChqLxrvQbPqvYs7fGQtD7k7klBzW7As4qf9d+TkMhCLgAHsH +jJadnekdNo5A3mygha62GVK9zrfohKND3NAn5iBIGIsJv351Zf9lZfeOBf6U9NQSG7M1sAQeCIZA +4Il1hXDoaLeQ9/GT+27xaumO1vnKwAPTnUiu0E+hfWm787Put5xjFTYDe8xzxpgxNAM2cyAzPdjA +asSxfWpbHmpv9e7NnZs8n7If5ODn0cEDVgOBIzhRgSE24B0ortANJV3k77J8ViTwmvVLIenzryNV +LdrS/4MQ1PRu+siT6xa1OuwZfLt6h8mx0B/7zOaRIFApZAyg8qfUkXRTuY/XBB+UH/CK+125JrTB +f30DrBQRGg9ecprws161Ui88rn1d26dF6plav21gikNjJUj/0WUl/TEeoXNkZf4s26dnfx+yeNUH +A4CjQDB4BrswbeBF6zCQxh3zmI3fr6eKcWFuLqp89ThvS8tTO1gNd9ozNXr/4rzQkS0ymBD/raHX +/GTAD/slcOUxWMhcxlmVJnCnoX4HWUunZKpKfzgrbi8MV5xEgHIkWcOJNQm3fFVCpIsujn8TC47t ++NgCUxyDR2GpTrQb2oZU//kyQFvUVbf7M7oorilrA+k6LOKE9iY4g4THyO/PjXvX1dmwmtevc1Up +LFt6PQ6WcAWG6kBbR0EdyiBqxGUVIuz028Qa34fNdz9tXsMPZ1Rm2OFl1Q4HLtZ+23/Gl4Ld4GHL +mWJjvxyOIE+ZvSf6YdeVbTp0ua6oaaxz4Oddskb1JyyBxgNek57x+LGSxfr1Frvljoup2gNRMYZR +a3IcYSEqxVkdBMRN0jsSf0lhxf0WPZLI+y51ZsEJeTgAiEaR9JgDO2rAlz9scPD7JhleQ16HLT7d +l6NhEDwaGhdxn715avByRCbp7OfaGxhO7ObNbHDWG08AABfAFABDWqhxTkVn7eHXqHpUex8RDZay +L6cD9EZrxCNhBYhoyLUDRgWBQxJBtMxe0CyHTz9qwUB+fvEiq/LbZXvqYVCCM3j5P7IqVXeoGTdU +B4a1ih5u3P5obV5ZGkoPjgWGgMDlvBHTht3ho++KmtTM0YSHkiEf9h7+crZCCu7FgcYZCFyIJODG +SRSo00uWp7TsHBd7tcTeK0S00eS0OHr9PjiS9qB/3nE+9lP99V8N2Jh9pOP37xrv9nHd5gpHEwhY +INSikJB4MvBvMBEB5Xg+qPT1j5cavfCxt9IX0VP7Fr5JB44mESgE0G7MbNxnhMp5GipXljxpLeAL +OXyiSPYUBQPDgslQaAQhjUQNm+5U7idXxC1dIi46EKjPx6S4E4FKv789JmPPNCTG48JWDwo6NKrU +N+hyFDKBgCE5zY2VLr6AX2BHVK6/0frEoEh6D5fnxTomDIY2uAnaj94oc/Nmh8qHUxcTvS2rKmSf +3WdCUOmIYtvG5x9WNOmYt9dklVL1haOvS16BRciYw4zK5lfiKEUNpwZrNMl47v2mpzjcvgQFw5CR +zmjgVYE/IPsZ6k7hyRofariRuK2e88w9uR8LBeEoIMSnvxyoZYJhB2QdL9odD+D93L3bvciz7XD5 +Q41RwaAKON4VaJlOf4RRFhUl34rLhT/i7zpXmt/pvn5EKx7ONZCxGJqFtCAtyfLV7MzKlwp3NbOw +XY0j/eiCLU/LnuTxGOeZ3f9p8rTyMfXR44jeGt+zlXDFvWgd+3jmHp/lJKV18exdJzA95dXjWWgj +mOIUghuZ1jfe3UxyCJAbr+0Nq1xbY3icz2BPchIsAOYwga4FdA4X6DlYjm19bu9vuv7yDQ1k7E4L +Df73CRvmBadimXSz3UhpwX0aw9IJ2zNTSaaBzxfLzUFDMX9j1QocVfUM+6dkg9OBpc/Gra/5wyBe +gDdCA56YNlDAX05d2iH6hge76pzwuZKgSh309qvMILD8bh+iTeZ5Wxc2lud8P71YeBc67ocLCKHy +M7qgdJkgRSE97UAvZZ3xDe/L2JJnOGbUVB8M9EwSmvDCqb7LxnmgzSNG3vQK3mQG0XtU+xOBB5WD +/mkKrZHYtaS8l8dXWlQxQxi9sO9O0+GMsK2dBOuDdo7bLl5d8nghXFc/jCYRoHgEGJFBXlYI5Vh8 +kGOwIiu7IoTvnse+4LCq1XNyU+NmZdNPjwSfCPkmlSlKSJZ0aB4L+0iei4SmfeKW8u1ZGCD6MuBm +md6PsC8vstYvm8mggGCM1leXKTV4NB9SPy1cEX9km9HJiPTqaK1ZJV0xWCfQGqPQZDIC6eQJhiZO +QN8nYZBYwNBAMTUWSXJBT/dh02M57ezEH9/zl0sRV72Pyd1n1hb9P2uSiVgMBcy/0hwe8GhoLGTV +rRYlEozszqp/shlOPrE6rjDToL/uf1WHIrL4IuOFCMXklHPkjFL1l0vHf6pSmeuAeQMyxQlDAFEx +27p7Raa6dodj439HZe9TD14VW8YcRSHx9G5EIYAaQOQOinDELhoXWHC8oHTj7wHvxU8KRkTX588h +Mjsf471zYW13Vkal+RqTheMWL+K7NjmNzwF7QTX31VNVRMB/vGbs8m2nJVdj8HVHCHM8MX0aFEGA +0vJQY9H4sayz63HK0sqDfL92e6tutwma2DiXAHDHBCjg2OO59b6ig72ndNK7CzsXmXC8T1mHnQuk +IFGuaOien9SrXogdDkMffRUXm6uplOLo8uvDHKQLCYkDug6VPDWTaNrJXyyVk4XkO1HWgdEiqH3Q +KiuZQwBDBmoaT483xkMQVZ3r+BveNruEBcZTrrHk/f4xBwsZMAQRQ0vWHd6JUD9/Z6Ipx/4XW6nJ +kqepN68lMofROHDiFgpyOt5btHHdRiwghRhH1X3sHDjV+GkODu8JxeMBB/tXmh3BRGCXjn40jxRk +D86UmQPyRqNoc+tgAppEwGJpERcOQ8YA/Qyq+FVI6Z6YTnKGckiL1Ovglvh80VaX+RTxPoBTR2Ox +ZIQXMPQheEGNxk4lx0sh7PnF2hviQfE+2TKXNn68PY8Qvb0afcaPmK8J05KUMs3WVml0OkowuToP +OXOMwh6rsNzUc3nFo+DHImUB1JpQdaz9vDhUmyMrnVSF4kYnj901NUqhdu9y0PmJno9kuOJyvaFF +ohvE39/k+JnvaX5E7ryapM48rDto7ymuJHqFjb9w8bfkcbXiEP+Q9/yUz6lwk/6YeRSA8AswvyBc +rWJVY7uUarSg9klm4Tj+wotifaV5YMAkzaq3nj17Ppk0bTHVU7py8fmYcJjsplc980sAVg38AdQD +wglJQSKmI401z8bH2m1Nbv9uW3G0dOS62oYWTMc8ehQMDg0Kor2JGFpqibtuzC4nVkumJ9zfVDvc +JXDvMtmwfxRxpztFI/WKpASJk3e3p3Z8ezXx+VZn+uwR4hwS4MwG7V6ghrlsKbfBj8b8I2M795rn +6fcMTHTL1s6tpI8BLcN0D6P1vp1TvQ9UVS/w6lJWv1a7ouN1aq+++MLoQ3Ztc6uCJmPGu183ft6p +M8wSoadfPRn/2vpQhv6CeSqaYXOKmm6l/9AnsMUcfx/nNKkRtTqyZw6fyiChnP/05VFjr6W7MmpF +fmV2Kmvq8KIO14yMzC3yh8A+lirZR14NFR+KQlo3dxSrya+KWjKXAAb4Ez2P7+9glbtj9NpOyr7d +g/WVcpvzos+PMUedsVSy67Q7970iu/DawyUuAkHBkpc4fTeezj4XPgdMILnTXh+CtjIJclMoBcKD +3NoiiwA3U2m3RqNLctfnaJ40CUZk4goM8qDh1B8ByileNxF7gY+chCuxZ6NzeInG2cpc82nigSiF +iPSC+NMdKk9D2de9jf+V29sk9qaphzP283w8yQUyQZtq19z8VqHYc+CNx+czDyeOEENDkudBUVgC +GXoVeSnPtsmbsp2Rjgu6Uqopcqj6rNumf2GdEIzZBTLaBQo9oAxYV1DRwSq9KA5zy0adFzU7mg45 +Ts6jNjN8CCowJ8uY5IpI7g6OVvIaE05wlp2vDmmujOQCeYKBtuyc/d3OAeXrOBuVgl84BHvxG/8L +DyaHQV5l1fUFJZd3PghaI/ujnXdZTPrhA/7z8HhgWA20BU+aUfi80STXsuMwdWlLln0Rvxo5Mk7G +/V8EoBk4UECmMWq4b697SDD54K6Oasknqx++ezKfAIHmxkE8oCIVOSmu7SkY/Fbq2CLs7rZX+fXz +4CQ01Juzh3fKjnE67zpwNntLV0YLK0Yvu3R+EloacHb957P3yxSXmJHU0Ql+k7x8CEe9eVCoM9Od +DsITCXQl2njNTcPd/N0zufb98SXfHpZxGOohdh2cR2qm35jRxfs46x7IPjFe8io6WvHoMaMD320P +ys2jBE7fgUsWzyOzqKgz5472r9bT2seZrS3kYxM1NwpesDemdiLOQN+75erhSFvr7/eGzcTmiFxB +CloNQT6gK7Rnx9auQnvDh0MWqSo7+azjmWMYcP6f/oQq9kbmFIlIglC38PNMmfqQSgdb0zlIIgpo +at4UoL5oyw8ebukrs+dtWNE9Hhr+pD/VR7np7b45cRB66/nDZlfGkkjRlLIHnPwi0THB66qYQwxX +ziNVcvX6HRmbvL6juaKlrQc7rYXmoMAOMWtMYKEQ+15k66dtdU02HedYS6RY83zmeB9/52yrN9me +lkdRrc7zf0jh4Nuut6xAWYM5/0dgLX7mM6fA+CWnBSrvEAlO554PjWbO4San86AUJI6IhmIqsEm9 +Vih4VBaDt+yavHq82Unxxu7jAhHMVUhocDYZgacCLXoqTZcpce198/tFhYYnrtjrfkF7v99y9C1z +CTIa8C1IZ3C1yJSpd+QL9RW55CmGW0npOpd40DFDfHPnPAooaAK4sfvtOkvtfTXYd7YeVYWV/hYO +g+nzgO7gUhcw9w5duMzxU4a6eN+i8NtDCS3kAc8by27Ow0N1OBWlo0vE329Ir8nyT8JerOSObXR+ +lx05jwBjJkN68ftlOFTksmfex+2+nXHBfGvuz5gLpc+104NhXGWyoo6fPaut59YdIcPmacGL+uZw +CGQgyqLZsWA5vfUvWhOOjIsuuqBB/uQVmKbBPQcHxgBT3rx77/Din4PJns8+CD1aI5VK4e/Tbv4n +FmxouCUv2F2C35tbO7LIB9zR98wW5FrzD7CnApS7MoyOipbIHbE+8+nbIdWmCK9VE1nzwahZQbH4 +z1eL0ylvlrlzsNiNhxwfeEr94TWfwtRb7hE9eyfuYo95zI37GiXfrfQyrwbdnRf2pNd4vlSDY2DA +12MndG2qsdqcVzzPmWjOB0+5zXfI9S6htQqF40fTNRMtJ1eYWu3CzQcz8Ts2yZSqjxmGuHWj+Mon +2A3pgeq/533zYGOfqgUrh00btxgK9tztnCSnFPJfFLDW3D+fAH38jnAEFy0iGMMEE4V9Ow+hqs59 +FcgyyULWrn3rcXqOlAakBIX4jIZoin4oj9cL2o72W7aWiki12KzoveNfePqwvOyTyB6X0mqvjJGd +kyILFy5kNddY9C84Bk+kpdwc0wzcPvmlpG06Xb1pxcO910Ois3f/i8Afb8SrtuTyz/A7BQ2Lc3cN +nw68Z4CyX/0vMtMjHW09WZ0OrPSATmVB1q0vcsd1nCMq/kUBDyZGaTEOo04PFJgcX+PL7XCgM7Dp +6dYVWXWfd83hi6alpppq9TPVg5cr/WIUNdzP9J//aR3j25f3LwL05gpKqA5aHyjT3eR3hcXR5ZeM +J7lNhdD+LxKewHjHacayDOiB4i93j6OS+O52bt4evvXFAtffkmov/0EMRGMLpDqDBYK/IvPeuoV4 +phU0lH5omgMFQkY8Iw6Jsjn05CrpNXuK75aIs/vkLBV+VeXOg0IzqbdjHNX5rxepZx30W2teGHqu +Yd9cfQsKUh0xLvR8MJq2xu1UR1L6Ws6zklJ3dsdGI8sEXQQKj88nQl8oAOJsxouIAqEvqvjOv5mM +4/NzOfj5/O/5cHA6GYskEmkhiZ3hl16efefbYnljPSu2xu0v0f4yMY8CiK0s9OJKiBHWXfzu1ebd +zhPfbnub750TA60bbezNWEYX8V3/eexo7b6m6KHaNV27TXNP2j/7NwmQzrGKezTE2/2T2rvyPfvG +D71xQmZC89L0F/5CIPfCY+38XLfQG/L84+ihlC2hc0xSUDFOCBcMVFmU4ys27O4a2yu7bbeHm/AO +/OSldwLMQXoTR0/Xmu2t/kk+zQJ/h7Njvy5OkA7Y70dimPMMQ+yKoSU6vgh/8BwKjG7l9QjxNhP7 +bBHf8HR2ogGLAVwYEjvtxz5sxu+p9XV+rtL+9LvLniV3LT1Nx/8k6Dl+BBjlop3Q9NUnSsdMBP1f +PzfZEiLluGw716BiIG/8HyS4soCE9qCC/5yR75fXmhjjW5heUF9GKTAqoibyxv+cHWADbxCMJJEo +cNX/1JaRIUufe6kmwmP9plsKbPFdR1T8TuyFxZhO6vx+ueXsxfUv97RhFnS/PLX9ydlC3DCcgiOS +jIGagapuX6ltZ1tHx1GVqGB58R5DxfgVsADwHoDqwXgCrtAFuDJjKLHlOXpngm+S0gXvSZTp6MMr +H74FqcPx4E4lKD0zs5YGl/ZvWYB5UjTcdIalRSr2zpiGKCwLtQhoMRFthgPKQX7PWWUb1L/jxnPO +ENUNe37juKp/zQfjaSmBhucCOJE0zRx/1nae5W+rV7KfOsANixLwKCoJWj0ye15kL/GI5uBPSqnE +HkyK0GCI27lNFvdhBWh5/OK6o2TWXVU9fd6r1troS7Hg3LI14IrTZm+gbQYSLz54ZL5denR92OG8 +Zq8bkmKXuwaZI1DS4LzJPtlAvwkXl+Y8ZQf5kMwbNvvMmSPQ+3SGbm9MODLZIr2VZ6Oax3Mdueqv +S8ouwr4GGogheqoS8FjoBd6S0Y6qy5vAZHjkxv5IjRN0lmqRYE5CQ1AQy+r8fJxQaxSbdCE0kXWj +AflOs9aXeTBGc2s8HKHsd/b71tSPzugl3M6Gcl/bm2HRqfdFX8I8ZXF/HOQ/+eaXu8zYx0d3dPZ5 +6GOID1/OowCiaCcdcOynO/1XEpJmJQKe5evFLOEbv6Z58rTvCvbChqUrz80jiHHCouk7MaDmREDx +8wUVqX/K8+XjtQvy9rxndWgeBcaa/Nabqz6Xb7lk+CD5lcq9x4a4M0FeLPOgjPuuiNV0yzO/zq5X +l3DJJlz0ZU7YUOc8KBVPW7OCoKCg5SGkAtSvMnW7w3b5OS8GXp9b9O2snMK/SlCdIAmLrv0L3Eav +xj1adu7Qq9PhEovZ3pnNIwHtCMQT6BUIxUw3TBde1LxjMHmp08LegbuvCb9vtGJuFZBiTRA4krPp +k3KzfaKV8dHallhLfzQchQbNNG3norzllorrn9OD1RZ8/s3iPCJGWXlbGB5xcgLCVHqDL/z2foW3 +lNGNUgVyzBVJsUs/tW9LwlG0/Ckt2I/I2Psg2rW8v8T8VM+pse5zHxJVfjJl6F7SkO4kHxt7cnwj +coXpijtIKn734hlQ6rwLx9J2edDna581/Aoz4z+Y1XX/IL+q3FnqnVXSSXAQBg/5dMbeShC9KW9x +sum6yrqtXobBu70NZPuVrmXCokQUbZ4PCkCcuCQmfj8q2qtfsX9Jv7//UKzKZTgIGnzMfnFaa+Q5 +dVw0hKnVe7lPRelJT749pcgUxeCdMXgw2sQSCFCT2+ctgiG9bLqvyH+CdVnakxVyq4tL4WhwdwAa +D9UPtBANXFQGBa6M1WV1j/ffoIwSP77dab3i9oF6/Yk3+VXMhcBBC8OM5Z9T+dQSiysTblrKhhxq +fSZvNuYPR86o4/1VSWHBa0e9WHacDtqWI6UqvxqtDYeAyT76nYMr9bEEKO2ymN1iUkysa2v0b/0i +WzGRkb1mRjLz0AxDD0QnWFoztsg915fmKqoTtyAgfpvVh4MpJ7/umkeEhMbS1poyJgQEavLsTrhb +fk1Yr7TAAfGuv7Pn8vjcGiAVl0xNuecRunH1Z4PLVXYtrr7sxn3MqFn+IotqtAz588mthckr7krd +KbBYucBMixlIpg9HSFnh1WP+z8Zk7qVjduCvj8c6b//EnAEnKhBOJAK0ZQhsoPRIjBq/OLnz5xkB +//EfVMTBoWoOwSTY/gvEVDgkyWc6aTMceLzRNFVA+GTslXLE15ObakS+w5p0BsjICXOWHotmi9N+ +ZYUr3m+kEuup/jmPCs/BLfVQCzMdNBmLPp0Zbi8Q72CyLdLj2jM4GpzeJuCQwMBx+u0c2mlpv/X2 +wDIDTdlXE+pDqt+/1R9lwroCISDQi6YyqONnLm6vRz9exNlqZLce272uTuwmrGWcRqE8KNiVEYAV +8oREnovk2uU8SdxkiPFGPRVr9OEVic+dW4SEdgY8EX2iZvvW3EmT+qs8VyVfNelnl8nXBlnBNi4S +iTG1cz7bRbO8RM5EcgHe+IWVqMmDRLdIOALKmzoBpgNMgELzig2eOdv6f6YZurXjYiLk0xYdRx1n +CtJ3kVEYno5mrqenxowub17xvll1YePNVrWcE1k63SmVQfBiUBslAX9DksC5fNoOqayJW1ERpmJO +siHf9rK+X3RONVPI9h9wEnTtuOxRbVsP0cTcvsjRhMCMBerdTjh4mEIlTjVVxqzibn3bx7Lh+eQX +g4VWaQ+7dChJx6/MT6OoOCrNmoAalY4bxGJ2f0wS0rHmevLkKJrF8t6r+TXQOFoUyKljYrt2Mjm8 +J6c3OFLxtY9W9q9789PQzkoizfhzN+RHae4fveORrR5a/DQiy+pGAWxQP0sBGlU+OzF+4Hv21R17 +WpS11NWWynE9CoYFaXESvcVC8fqUjfAZOd3Qsix340t21sPHsrX3Zvr+qPxHDZgxnMPCst7rSZfT +1rzXQIo1fItuOFQBOwakqzFiT8N8P798k5HxckF9U+PBdfKRmuMOcBgVD7fH/Vh1N1LworPp6nip +8AePdj7LO1dyHY6mt/0/1v8VCHSs+1z1szikJ01xW+jlxNKswHVz0EAfpLkf4tI0PwsWUemrT4x2 +JK8N7OCXv39gTm5qsHqu97PwAUF35Be7E23nc5PFPR7ZwI4bGOR0vDpz0xUfQvHWJqdGNZ3coLzA +8+NLja92bfgnFWiCMYz72Vn72H5hI8/FW/habuRd/QLrmOgwlAGBotYfTbXXT1IVN+0MrA5Y4BZX +lcAjmD0XSB8qrWRT3uoexFmZ3BSfejZwm4qrnrDnHBgQiYI5CQaN2zg8omZQv12UOi52TErm48BY +y/s56D89g0HS8oHyNcIFdl8Wj6hFXj/na+H7fA4cDPFATPa1dYHhy5usg9YrlfwHb6x58kgGNr5g +YIz6pSUCqR9c46qKTI893vfOKdT8WtexiN8f5qSd6FstJDXsb4rrPbrVJK/smCEX8XtCKMRmDvCP +hLplGzn2qYAPq03S8mvyeYUcNdl7YN3CDBrEFqXqK5gFcV8eOSLYvqvuIF6SrdRiDgwYMjHejcI5 +Vtuf6/x1ZPNL+85EsQoVZHHADmPopBcSMxXqTL2g4THplXl77Z4NWSMqNrTIxlsefjhrBzCKgMMR +wOksKp4CDE6gTl+b3zhy2WWpeuvNNu/ipxLrr3y6OAbDoL2hTRVeSBKePm34YUhcbTzzwcbRzm/x +cZqTnwmmW8xhQNppD1apbRi757mkS+cWjliurn0x3lFyG6YwDnhGaGUbmJsCufQXxhIRvx/d7d9t +sjhe4vDhzH45gz84IrjiDAUur0EgiZjpfp34XlbEs7b8udtPq4stZU9j9RGXeOZGp5K4R50f/PrE +1iR3dOG9B4UvJE5SrogcnxsF7TZjDKLpdzJ93YJqfPr71pRk2eaEitzTi+emydSp0SzCJGoSH6Mc +7duSdE3ZzcQq7ccx/blhCo7ohIGeuMMzeCvryFrM0oyktIhHUR7Ri9d0Mmeh5eM+eAoS2vqLGlXb +Jaf+aleQwAbvgkdljq2UrRLMWcAIMp5WtUqA+oJ96NOYPMdbH0vjhdlHG/9sBjNBHzwSh0EhMDiG +p2Mlry45LoWqGapWytolEeokfumAPHMeTYYyjdHbvuakJrTz69zgPMIbZiqAGXJPmwMCT+WBdo1h +SGjQXUHeg7uE+4Lum2+JwfXiT+r5w4S+qh1TZK7BeMGMOxD0dHfl6Xxg2fdLYfL0/gWriivWzfGS +ZzaPzIuhtksdP48nm9vnPNUyFnmun3SNOTmjaeTLOu6UwZCazHO7dq+S/cbxccdJb+YglQjm+J2m +JkpdB7kwEa+TXrqTOiLMDiW+lY3EHZtNA4NyFwS4awhBBgRwSJDqvZi1S2c4pab8N+/iZWQ3hdsH +SBv/oMgE4JpIMmg6gbjCCQ0M7WmW2992+UKSp0+vctWO1S8kj+0ekP9EhGdpBzVA00+M3pvrWXZJ +aZR3cU+/2EmTm3GWTSwqOXAw4OFwSIoVBgc9JPbjY2TJ3nhl68dDL6wN0q8pWucGwlEuJAIVSjwM +rDe+WuGsJhFT8szVkB15YpL9/Hs4AAPt9qZl6dicbq3dWiptvvfsd8XM51LYvGspLbAMmUxFI1SU +FTQ2g5iTv/HgB7NopP/9eLEcx8otctsDTOEwLMGFMStHIrgDA3Yw4oGyQdWPo9brbYkcbK/Rmay/ +82iDvgXsuwAFoJQOFOJiGNH59eSXUiS3J4pDz9RGl7G9LG++7oqBw3FoiivBCWpxteqv1xzzlzu1 +UKLoZ+yKsuQvbYfl4BBwdZ4XuHXVC+Z0oFM8P6JOJ+559uxOs91rh6tv9YKeXYEXoZl9YHRlObVQ +m5sgLVk8thM7GFOGuLRos6TK+ywSHExGY53pjRDE9H/kRNYN5hWfvDSuEBDGf8+3VAcBi8G0vLxz +hJEs0/BtndX8RyJVf4cn7l6VAcdSKMD4h4AlkMgIIhiJU0ho2jSIoWJBTZ+nNMdzye5n/FtibPiq +ECvnFgApls1X3rzVj1MrEPfZXBescyXw55FdcBSUanUmEQ6D+SA8WFFkDApSWJ1wK3E8NkUzP6L9 +xTOiSMrrgptVfypMHVlgvmDr3rrm6y8lNytzXLq4wDWtxcZvdmHgFYKHtUDXo++pJJAYlh/q4INP +F3HaWBw9XP1ccGCBtMuWTjWR2QsxiURXNBI6DYh20cfeBodkk2TGFFmffv5wdyDngJHw7BZM8iEC +Y2skmgyd2wIiF8Qi38q0bUzzse3edMUv1tm3v+0mHEJyIeCVEG60wzxUmhz0DxWI3hUetCreeUU3 +6fP63nKmEAisVctTsTf+tjv2lAw71YCE7/38zhcOoC1TAC3d9PF1uV+17oV/XOdgKSnDWeO3Wi3+ +Ny4bjqVSXIHgH4OCrPJ0azF/ItOtmrvmgnVgo61E1asbyu2vLs6HQ1G1qexK8RuWlx0r20t+dEf+ +Pn6vZgMM50gAuxKZDM6+EhGM01W0V8hJDob47T9/+bKgV3j1l9iXbBgYGIUmUTDO0DVBaoVo8YPA +V1RKq19hxmaVG0E8+7echaMwRHAhgCdguBi/gjRezUuf6zl64cobO/QjwxQfbhoyc4CjwRMJaasB +d1x9sVqXL/fZkkW3laVVhU+y1jovhSEYu8KAsbA7mr43jwwM8dCMM4aMf58O4zF9eIY9IOVnTjdq +1DviHPJfdUA+aKHrq2bUh1eHMPp9I5xlthoFqidgeaKCkgK04DWZrCBS/une2ENLE9Pv3eO9d4lv +ZZgS0DkqG8pNjq9JjUpt8fDMSTx5I5ydErseliArT/UNq4abRazGOfEnM8vVllvJlogH9qrAMa5/ +DtW7AimRkid7xMoFzdgu4OIw9SfNS5mAVGCEAVXC+zedkV4d2uaua7M2nDetki5BtcD1XSfXGetm +3locOY48OlEeuYa78DtLapArqaADnnFB48FTFsBcIv08ju+tVVc3nsgR55MISNU58p7yYfwFExT0 +5WBOh0KfeVKrummyXIxn04FLkeVnDKOJe7b7ecKjjLTJB5Gki2olQlFF4iq1vvd60vHiblfhCRzB +iaiE8MSgafuiEs4gbf03lw5P4Eu+30fvsVTtGFOaA4TqXlpe4uDQkpHmS2EiKuxyl/YOVwfCIwQn +cIkpZGPG2ze2S/WI+rVyHLlnVH54dfD25kp4iIh0Ymya4jyTtL772n6NhabfBWSKl66M8bh9Hx6i +ZZEga2TFzmbief+r0P0aiW/sVjvU1VR5mTCAUUdj6aFp3fVzPw/nbn6XOXJF+4FlnI+R53lxWAws +HLKt13bR3uo3K1fLnURmubrVf9mOgisM5bRBwLE1dze3RqHKj7oIVh7Mya4FXrwkGABNW8jLUXac +tDOE/WDiOcsivW/Vv6RVx31gS9P6hSd4DCe9mvMXHrr8ITa/9IbWu6cJfEeSjIJ4WJmhQIMjUh2x +GBTA/rkYW9Fvbdwe4XtrXd8LH4tR3JxaabkI9oadnMhIxs4AqB4xK1UGtG3d2e7i+4u6Si4tTXKc +cIED6Vvj/lqtBmosPy9cGChv1KlrvTXxY+SDJuHrF3/BaDhjiNAlFyYfTJxUexGYM0R8x8Yq5Xpj +ZEIIrjh4kK8jBk/PmG7VdAvoczPO88N3HVp2RMhOzK2ABYZyQeHAzAFQS2C2whXcoEQ/3bZ7GVF3 +d/ERz2gPvbPdH64pfly9UJKJADBWhBFQGug8oPH0eeA11hNb/f2rfc+UNjrCCaApdCeEd4bWOr2x +OZWi6e+ueV7mnqCYY7pugsEnONvnioS2Y4Feemo69s4pAf1kweAfhXGYCynXu9U3Dg4fY4JCGeHC +5bdtTrx563F8aeCZDl8f3ocf98MVd3eCZjAkN60PWvQ24ALp+tLeoJT1dixP/XLhiuOQUEblXub3 +3XmL3Dc90uyLXtLMitjijYdzSmDrpB3cRganLab/CmrYKRo6kSXvI4vSzfwfmkU4uuIOqM+tAQ2+ +Dz8qau3R/T1g18eSnP3y5GWtO6PwFGDV6TET2NCnZUCVzs0/XzUfFRcvj3tMzKovDrvWlVT4DyqQ +WynbV+uwdtcPm/fej5c/uz1CGW2CiwlnoWgsFkMEwieaR0O4ebkD3RgUux9l//pEQvk+rZst/P3t +n/O6cS/gwpL5xEi0W9ONEb74YzR0xcX7lyccZBW8VjjI1v/vaqASWejQ/TduHJnnb/ceGrjdU9bE ++kJzXiU89Fc0bUqB7k4B4wTZBSW2D5/wjyI6BcgfvcxMaqNS/Nsu/CdBaELW73XJUN/IRbGNfWov +mnAnNO/q8c0rxjAEfzzwjIsobVaFugI21776zqd4DePlCbyrreqcDj2O/z+rA8JQqD+UIrKs8ouq +NK5EwnV8n1ePJYXzP2pDcyYnyyeWbB2YHPn8MCSWOLInM0Cndz45PBIHJuXnq4XdvNtXcxcLeLRZ +7DApdLfTLF2wH85//w/SoCo722+Kt79aYswKnT0H3wid8s+u3vFfVKGUwoemijUSh1iE2bcGtV5I +2lL9IXDNfFr0jlK27Iiy0QaJg7sijXR/ccUUvHm12YY56oihzDhlil9CLzixvkX8Q5avtYe++/r7 +9g27mbOgmwfHFLTFlbr3vBT43H71oJYgeErxWB5XjjZl5izkoUGMi3/d5k6Zp5kPRuMsTusdi2k+ +zTlHb0TjiMDYnghclOhKQpKhBMn0IX8+6j9iRR7Z9y548GGdsKcwT8fXORognBS4e4sIGdFXQdr9 +BoaPe0uGK23fSRsFtaYt3MVci7FMiIgkAS8UWhPFCCTojxkR2Po1ceCpCNftNY2B/DUBKMEaOK88 +vx7NtmbczQznTj1QlH1FTGW4RlIQeZcdx1xu2j9ASQdos/2MMwBSy2VkPB6pl8Uv0kIcKjmfJRPT +0/4vYrQV/APPBnMye+QPoF63jdb5fuNjO7ONOYzDAM0FeAoCbXm1mJnC+fNdBqmrb/g1fI3Uei+G +sXjIHAZeENDGyYDDI4Kb5cC6gW7B+hqBq98cZfj1qM5CVlXfDYbia03nUgG3VSDxTkgSUMFQoAma +IWBUS1tCPWIcG4K7ame/ajT8c5RnlT1R9socD8TY7wfZ7nLs7fq2Djvb/Deen0yEUR+X1JmuYo6S +kFAW77OdNk9vQ5u2Bk+zQCP1UvXp+vpbc0DOKHUFRTWEBm3p7Hjfg4zRHRkKrQJsYx0/VnhymrfA +DeT/gJEIJdph2jnRb45WlYvwHCbmmR2s/xKjNKDENQdOq3loJuZj3fJwEUTKoe3rlntvSV9glbCr +kTnI2LJxnUUtdu3AY6/jypcKz+466eC6oi2VKQVNUfJs+HRerAnr4f6is7G3JmRP91ZheIDevB1J +4LJr6GMPIP97Em98+pR92YKOa9y8J4rutmh8ZGIR6Dx0pC6CcYwdlPtzbX9yTpjrYK7SWHrcDscT +mg33574FoJUSwN1hPjhHAu0UzQHLa27chzMlE9baYfw15A2WZ1bywEhgkYd96JcmkHCzFt+xLHWO +LEtbJvQ0TdFNM2n9tuLKfLh+AlwaiXUhAKArbTJHwu2iW3Cf0jajO94iTY9V6s8qSMFgBCSaSDtS +atoTmEdVSOkZWa8PP78q3FHf0GdvReoYHErLBdGCevrplxmqmoo261ES5gLviInD9rtHt7WR50FB +bPRO4N4Xpj5XJoN7ODZNZCd2qyT0wWFEhBP0LY5ZZ0OAAu2h6i973kXf3pPFmdFy9WyBM89HPRgB ++jgezIXSwwEBEw6dLUdWqOks6r3gaqq9csy4HW7gMiMBgD/s/7t3f8MPgdKSwzH9US6bFtfYwhGO +wAgEyk14P9aqL/pYZRMtpUdZIX9XtGHrU0M4wGNWZOiOIkO7UDOuZwbWrObZybu4/9i1E8djVuV+ +6mFCzxyV4LAM7zN4/eLl4pU66kt92HYZHLqoGbjIHs6bwQi40z4tE7B5q/nK96q3sNz11c4S2g9P +XHNyYi4AWfqpi3dY7r4UZrrxYSWGc9vjVqVn6VHtOvOy9Os6cqOfJ1Xvnejehd4auLbGCkN8AZf+ +mMGSsa6MCye1HwsIq1b5oneg83Jy47ozjp2kn0zgGZnnGXdu6eCm/Ob1fXbnW7gTHoKkAYXds49g +ZwiQ6JNkhJ1t8Xl5Gy4V14blG7aLX1b7vDkYvjwU8TuhoT8gXFyVlZRUoD20a0Yy0fVvhvv4NYwI +7xdnS2K6fd/AKZB9UK4Y2m0jKVT68W5f14VK544ppYyM7SxHrdm3Z0POtSg4GPJ5uvSLg9txyAhn +DIlMgXb5QTbP6WOweMnWjAuLtAR2fx4IadSs0YURAm0t7VTdipRTV5azCYTt+5K5etHSZT5eK1dK +MwXAc+toASvaBbhzMj21s8SvPnIlpn3rlgQFxU0TqzJlPnyBG/jQNKhUWgCh0Ocuwcm95sg67pVC +McFnwsc7heDGM9OQpxqIXa6yGNpLEr0gsO/N59rn17w+BpDh0lGgw6M3BTmZwrC1l8h1/HIP1naq +bShRUGlLYEJA5hTn4gw5aN/bA3HudjcGb2lJ8nEqqaDKrQvhPBDdtU5nypHYmXH5RGDmBsUJimqp +aNfggVJxN9NA9AMYFTL0E0rwi7VXnFWJcLkmE1D2KfK17ZmNLivgADQKuIonGloRwnokvQ35NU9U +IT+P7d1aoqNk3U1VeIaEpsxw0kvqDqK19Gs8PO4+UU0sLZd01iVXwHNAQwUPwIFS7Op6w1cMDLO0 +LEpvHjh16hdHLlc9XND5x5TQqn5/m5oDg1Qbg0Vu1GWa2SO6j+Di3ulJoJ7FAvdVk+9JNLCzHH12 +6DK594IunDMiUx0p4AQ/iQAdoIDEQjC7s98prtqvNuHn7SWlv2jKGoZYmjOH//CgP7l/sh56y9oW +8cohxOVB1iNVn6VnYGDaaoJZ8finjqoNKQ4K7Yi6rPt7K0W/VQWv6IQh6eYK7MBU2rlZd4/YmwW+ +2cilZzSUsvZMWV6Kw0QcDOiFdmTMfaHJU1aIgnRBUAjA0+DoK4TkOfiaNhZapqLiO5NrD7mNxCln +R8Cp0ZZNUVwZJ/G+Y1tmN8Hb2pjqu3anmuZviyV3HatgOO/NChpg8eafNtYa+g2XJdkEnipKSh/V +deWfPYvtBZ5YRgA3pmFwgM/3RM/ajtEe4Oj79EObs5cG6VaMeWDFjU/3ypjgRBIaS6Dd4+2TYpdM +lqe2f7muuz+47SRfwpVWGSYUCU2EqmPifhiLmYqdnEaALPL5/Q3Vga2JC+ERsPTLUH3OzXUHXlSL +OyLL39wr2XP/6azJR/Clg+YWOgfJBZqjpzdxsUjegVrRt0cwXbmsBthXlY6bXsxKAjqhHalTwQ8I +LOO57rCpL37fxTvaP/ZKyi3aUfPg2l+AC5r2MQMKY0fUKLZgNTFZsKawNe7iGPdOid4QGUdYCjzi +CHKGeFaZTtmTW/y899Z1JCmfSFgwqAYLMAav0DG54KkS7VRj/YOVB1FHXi3S2sZ6rxktVvwUlgSX +OUyZI8VRb6MRA8PY5vydaqUmDmSpp6TXsBQRPD0VzMY4Ai3QnTblD7iiZe5+VdbfDbdYfPthsmL7 +g0lYFni5aCRgaelH3l65eqa72WOZx+o487hvR95Ikm9VpTHhaAvEZzZEFhGDXsTw4/i4J+JLjyov +Gw5bqDmbxSJ9gLYL7qCln3O32X7PNuk9Nc8O/5Z1yo0wZL3y+N3G2Qi0IpexOB7ch0AguNPW15jp +OcqVnv+12nf4WnpEzGqRU9wOs9YA0fYT0o4uox25BVIo/cxfaVYaAq8RgxKezYauho2n5GEoJycS +vXHJ6lAdRDfdOpvpd7QkZAfWulT4kgcMQEsiY8hEcL0k+M7PXS1T2sci5bZta0SsXYAP0kog9sPf +HLRIm+HzZlyVfxly936+TAuPJP+UrauuVJE58m8yoaHsD/090mZdMKuLgjeF2Ib7JCk4pr4ev8vd +ygR1nrHIPCnZtsq/JGkj+wHXHATXudNR6zfrM8VAoPH7GMeuRj3vMQVMW4XKY+tCBQ5DJgD99UFv +gbFDc2qfBWBdoG5vHC61ymJLTq3mmBV+hWDZt2UPyTf+B73phhH90uN5S5fpV6zM+fs7SMhsYdFf +3vBC0JThp7Wa/jqnX22Q4iq7vlOw9XLaUm6Y0jM/IMPdvGcotHbhwRorHkN3Ve6NRod102AQ8OSh +Ge6wmbNN/WMSpxanv9dYWnUfb2SiHdvfFO2Z6AM8xj3uWohcrqPTfPvlqYO8W46vFRL5wCnBDJ3a +q0P3pWlbHq8+Kvfb+6xe+uqq4zy9ug+Ke5my5KmlUo70r2zl3c+pyQ6sW7+dO+5V/4MngfZvLy5m +hk8vcZZuUc9c+N6YY2J45OFwCuqddHaNKBMKLL7lHMc1BfxPbunljwclPRcRTHQkJuGKz9icPtVu +n/ansfYiykNMIq10z97VMszwb8EzZ2Grl+Ngf9TA2ffKKeoDZ/d6NYwEY4ID5pP4s5rDKqwWeDh1 +LTW5uPvCF8E+B6PnZn0wGvRNArTDoejVzDjTerqpkLauV2/tW21n8E7uZehh5YU8Vr+H/jcxUKW+ +b4350oq1VI1KAZ4U66/DSPRZzn9Vgfa+zNBqmSBj/NYc81DfZH35Totv+IurJOt5tBhWzZVA6zU3 +5d+IftzGhiklFuhcTbHUkH5ZfGkeCVqGGjozH1TwWt+uoDNw8ovm2v3d/nEJjwRFOrn+SWH6OXLa +yzbZBeGzimp8xQcOPrwqihY6/U8SRCTjiMFVKxXcHTco+FqoxmYdw6TWNB8LdZhHYmZtTn2LhtMm +vjJwGD3SU/Xtwdd83LJNelZv/0ln6kgcerUcZUFvty0ObiKJBgxzWJge9RBZLsBUCBozfl01pHtT +bs2JxRPhTkIjGw7Wrl0KA0Bf5mLYWvqGDZrp7/F/kiZyvjLvmEtfU/2CI78IJxY/ZCZgSd/X5kOb +6H7Kpq5Rzs8xvvS5mm7/5+E1cVEu62FQ2he3Zjj7Y3qiFs5S1qOJwjbW9ifQrPUqmn9jsF8+KtZN +XnV/4wmdoVAj4eP2Cj/EOk8E/o3SvCjjC7IzPHGlpFbN171coXF6Wbpx+4xiU1YetYLBvUHzAG59 +nVpSwLAuB7FBb+qiipVx9+MOpsSzBxRntAX9LfAXlpmyPqCCL3HljRPvWXOqSFd/3RKthcFmnM/A +GzTEaVw/Ul3O8d2x/i6nbnzGeYW/CfpWXdrZdoyLJR5LUHc/E6+5eStl/65Dxf6trpoGf6M4NM4R +TSK7YqBX0jWZcu2R0kFz5ZYNVeFH+H/tVNvRA8OQXciYw9CrF8CqWWECvjhLHXq9KO6zsBHO72IG +DAB9zxAIR6Ftnww3VNDbXP0imKV3z/L9uhL5GfIBETst52JpX+sAHtGZHu1vYHkVTD5z/FthdUr4 +Jqvon+nsZTbzCFhZ7YZS8DhUWYSebwebmQXrEq2CQuGA8x1/kwSC4wwzI+YRYLP+6Uv5Bg6FbV6F ++IUVfXJ3/2aAtuo53U65Ow5K47uvVVZGl1tIeui6a4tnm8IxUIp5qRXlgeAzdwGxS8PKnN9RP9fg +nl2FKzxjc/TnSQw6IHx32C523ZJss3enl1990vk3Qjv4kNb8oU4LdQLdTfnN26peu7502JeNGdVr +yhi8JMyEBfd+IEkuVBxjO1r6YvM6nVc1uwbXtbGHFXrt/Hr0+Skm7J8ekW7/pzvjqJRpkVZE/XaK +7CACw7kl+LV7BIzhmcO7/i2ZvEewetc6Lg6seyzbpJQD2hP3GvU/SUJTZsTuh8se86zXkXfdpV5c +xTuQf3nvv4lAHXdMPPwbX/ZNzRXpdSIDQ4aKPO9hYizmDvrvh1L79nG3rmNluzapr4vV5btmOs+G +N/+LIqixuH8NPqT5tZhAlAPCcMUjbXmZ09rzaUx9QBkUEN7td3JivRA1OZbf9fTyOj7WI1SYsIp+ +TibCg4rGolyBiHmqQ/DgZIiFkztcr37OqPm5KOT0gXPBtkz4P2ONvGDeErND+ObxC9cFLO9abea7 +VYtjgv4RY6wKJWXzkd5rFVdiBMl+cZnX1t44NCc5XWHplTaP96MWl71oCNccb+b3bWm7mzgnOh1T +PFpWH7xdr/jjaBOnYaz2y/y6L9Q1zFBG9ex8YLLXNedGMeH5DnlbUfvIKw8CYfwaxEwd4kF2mXLE +h0/p2X1zclJI3jaISEYMCm9g37WECQ4bvmz6Som6L6Oa/DIVZzey8YzjE64Hw3Pyf4Yt4eRb1Sfi +Xh24+PZj6qKs8jVG12MSmAgAbYMKhty0ZXaLHh5/GPf6uHellyw6ySbFZOXRfYLwIAUqH314nbp2 +asNdmbMrl6zAevdJJQjCxK6Awd/B+PAnSA1X+Pe7NbWbpRVOLvBKzcI8dfeJhaXobmKHxfB9VsPb +aZEixsFZqe68KyU4RWDK06IhxoeX6J5xouh88v61djK32dUDvY/9JBS9XH7vb5bqRITWc5f2qjws +4LQt51q7aUvSgEkeSrsUxrkApVUBZ493p38hd4Z1sFvM9do9lpf1Wu+JtnRBCbGLKjiYIRMkANu7 +7ntzSqYHHBC98uSqL+uY4zu5LJFyGB48cQEcJ9EHTiC5/cQWvpigpjcCjWo27vecWxXse9uYkGDx +yKV5i+0Ohlk0Ue8VemickX9QLTHryB4nDNIFD9wUuHCIfpo6dGoC44w2WgQKRTgIw51eE52in31e +pmTdDpA5IuIi6gcvRZ7SouUaKARaripgfMM1eZSfz/ujEZwJaUvszkVUTsyn4Iokg8lxMoqEcaQv +IW9Rk6Zac8ZekQ6ySQpWMh6Oin4ZOq8M8FBKjAPo6CtHHQlO00cU0BsUmXYkPtTRoIttOJWb+eqz +tG66+oEOkUYV6nLNEff/bxcDL/A+PbGPRUTOI3nr0+zVwxZywopZHv/5AngCUIaKp2UweSzfXrOk +pkff+XW3rbRHOPdJjo7cf1YGl9xM3ThkPKvkvmo8rlobyzfaeqKVImGOEcD/X9WnvwHi+S7DKEjs +2eEy58uXjYbYWF+9eaL9X9RpqYYpi//4IWvvPXVK8dD5vMLOmIjI22qjTf9ZFsozjH/jvVA6/LD+ +1bXw2qf2UUmD99//J8HpfmbZlvFADLn1aZ9rW9zu9J4Ayxtbev6L5NRDr/iil5/OXtghjdU2bUGO +SmNalpL+iyB4LBRtnUXZQyeP1uOLtQ97TDYGBvpdX/dlIv6/KEIJcFBQ9Uli0+6CYZtfItSX3Ka1 +b22Cb9z4N0H6Lnv4101srPkhM7xuTKmsbEGfxKnHWUecBP6zLDT2TmlzK2iLyPd8ZCKwIi9Ggzyx +oOQ/CdJeN60CwDlzRg6MvcTo/FmnnXnmvErlV1h1Yh9cjf4/6EMxVebEO66ujuSjn0rqG4mfV5ze +U9n5XySnKrXTzKiVpSxU83ITq8IKFQEJw69ti/+L4HRzclv/egXnXa8KvltbairPZy57vYDr4n9R +nGpOj0hsR7ou3Io36z9lH6dnPLrymWTYfIKM1Vv0fxKpjqDfAdWiLulcPYZN2h8b/cQRsznV1X31 +7/751GbgtyVkM8O+Jur1EVHv8s9h41/uXF03Hw59YHPa7c3YtXW/OFXyWBvlJf61LvnEZe+Clswt +3vOqQevIaAuFoXDuF3fi5ujWnyycOtETPPJrTG6GPp5fA48CDyNk3BOoE5SnKxl3sGh9fhs1/Yuk +kJPs5Ldb8+mAk4fQd+4ZX4ZnDHym2peLFMsXV6XVza2/yrVPvSkUUvs99vs/q5KoeFr8QdsrqKvc +V/PKOGhy524v//ViF6SS0u78V2lQr5ajf0TEb1+w/ejTJiMt1QPJW+NY/lc92urPGUZrYARBGmPR +04y263xXzn7qRUfcEfv/Kjr78S3O3/q12D2t+L3MludRMgOCB77ZztvPmCiDcuLBcje5bcTTZETf +nguJ5GoQNVJ1/l/laCv4GY++GJ2nnXGh30zxcmfrXsPMAn6LZzH/SXH2c2v/cnARz28//NBpuXWB +SvcnI3sB2/8iC2o9DDWQcqfaP1+H9Fi3cu2k2eCSkt75tOhHd/oEXsMd85EOPn5Q6aRmbaG49XnT +9fOhs1ZGQA/j7e7VuGpxrduBMHU3QrRr4gafyNlDB9oecHAqiUomQQuIPlUfkOpFs/P9DhQWHh00 +WXlGfGnRLAQPfXQShQa/IgrYU/LMucCPr0wErTJS8aXPvz7/bNEceOcRu99f8FTfgERmtBFcr5ab +V2AQQvar1pVlZQXrP6LS0uamoUGOrWL7ayH+e3w4x8gl4peWVmTELmNGzThWfuUvYzPtyw53Oqnt +aycz3D888Une/ic29ZVKkhN0wKYnNCDs3NZb9P0rFe3/dv2bH+lqah2ve2XmJaGFn2kPmzfKFgxz +WNxPcAlhQb14n+TTPDcJVLAjErhrkN67bs9Lwx0j412D8q8j3vF/+v2dw/JP2mXW953Mkk8U7hzU +/6zS1WSc4/L2aTYH+7c/CdrLY7wG8tRp3YzkPs0LRBpEC4U+qxz5Lb1vlWpJj/u2Ck9ReCWwdO4I +6sOhIMfCkofrzaKvt5+0Jfeqwpe2BO4Vg0JPXR5KBbBvMzRJunlskdIDq9HSHP4frre75qSh1RDt +4V+za8XWvYyO1Va8uawmRIFX60+IlhihtwUQWoAfNlWOPeVZELqpxqd7j9YZjiGPP6GpioHOnoFu +sOFMxc/kUy87VcZyNxs8sgqzOHHL9k8MsCYErOfsB3sSvXfFnXG2/QnaOeRd/LZFYt/yVzHhwK9d +QqldPHTEE0gPvQ9Q7L/Z+NDuU6DVq3Jv0gbhRl7mNJS+Ncl7oYVIIn1NiprIOMcTLqPMt4IJgSfP +/qxHQW/C+y6nH46TbzW9eLVi1E67Yj4wQckkTwQanO4ioZ2p9GUf8XdGNQlpCjJZW3pGlv+o57IM +b37LHAcJufe+kR+2I1KaK4rdMtRTxgxrvvD8SYCzDLO6Bwga5HB2PDgy/pyY9FNTotR66fJ2PywM +CGVlZiRlpHIrlM4aU7zuP2vaYWb+IZXQKOQOg9FjRi9XNB5Mi5F86LG3MAti+JIz5tkW7lXrBUR6 +NCRd87iY4rS6nd4lcFio2eG+S41i+wGU39UytpsjrqEv/4Ch+H4j9xnD5fGbcshfVURq3VYKJYTN +HjTTjgqlLW+DqqJL+TtXml7p06+XDAbGxX0KeVkoMACaHj/Q56Zo1YhZKEqVeLAjFPvUU9477vyq +rnXad2BYPPA7eEQ145zhbla3RtKp8JdyR5ou5E5MttvbFZJhME/cVJSBAd761PZqobstlT/HfnWs +0DZpfO2yZ+2CwUuL/8CnzjUETD79xOdVsaM1fGn8/oGWDeqLd1VXOAqvY59NQd/KpWDJM2zh69qD +69xGDYa42RZ95PPL3LRP69nsBTdkJLSTeip7S98fuW1EZLxn86pAvquWqLg1SnVNX07NXu1GJWLR +3tNhycvyR4iDjTGfmt9EJ/fvoJ7I0rGeFeaBh2TSpwPhz27cw3Zx0+WTKcsLP/DohFrkhO+8xz9r +QREa7wnuNIcO6aad4Qa1loqP2FPRtXcqhbjDzw9ri3Ssl3hfMwsjkaCg/s8d7ge1H57l4UBplzaG +b9b89vV8wQOFhj84ArTmjYgkoemHAk0t6hOuiR0XCI189GvvdraBd8bW1/dxFsyCyVgMMIJHYomu +SEc0BXMYPWN0Ivg8rfaebI4zRwn33YjtfHfWtN8QmwcGV74DPR+DpG100UZ96n620LWGRdk1fXV8 +i8/RVwWlcAq0D/VgnKE9d1Tw4HBwWRyZ/hXIOMqj/a5Xf7ztbnntPrhPpc887lY7nIonAeM045Np +RAIWS2XUYsn9X6hA6/byguZiTeWaDSE9EjrlMBqMk1EYlmCj3FJE9TpnruMOEd8lN1e7VnK788Bg +TgQUNMGHdpo15w5+nxSqh+ZtRe5HCcsVdu11qw9yNqhofffOY26Z6bewyqY0cJIb05Bbj5fPdWb1 +qMbr98OxVHDCHFyhQF9PCMGqRdtiBES0L1LYijoG3OW7Nm8wwcDAjKdnPPZLFSM/JcFLZidZy3Nx +dZEjyYPkxzDY9FlFU2TJskpOign6zP5OLuN7bBlSiKtb98GQWIIXmoSCNlmCTd6ZQJp9gtbYghi/ +UHdhvM+l1LKEmCwr71hXDhgZcH8TOH9CWxhJRVGojJSj9lU8S1TWZykW609iSt93HAqobifDC1AB +k4lCEqEW54L2JgJvAWp1er6eCRMPKysPnONe0uJzSdvlhg4FVgHcbovCQHEL0O3omX2Ex2SCT2x1 +cCC38Uqx5aEXOrdrasHQQFsBJz7Ac3hIQH06T39I+qz+Clx7ZaWBAGLhshXHLF8b9JXMy884T+y2 +/yRr3dfuiptOrSYnxhSWlV8aWM6cn3EmJJ5AYZwImcSeXpT2rvrJjh3fCnQvnN342XvH/+PsuuOp +fN+/rOhTyahUZlbIJlJ2VkYDUUrWwcl2HDsltJCZjEJGGcmWmchMCiGlyCpkZUf4eZ7nnOM4Q31/ +/3w+r1ev+/32nHtc97Xu6+r8Jw6wkh6kaNBrBZRR+J684cDU4hlhdkRappJ+P3EOSLc1sQHmEo5O +Jds+TJp9t6bYlCJjMRr56SsZxQF5TeIUOBKo0Ow41eCVsHMG4ZOtux8iy28Jk9FvBraHbmrvMK9I +z9sjz2eGa78qiLd9kyJjZScOW5MyNqjyeFgHV3wXt1F8X2l+y+PFxKBwZ9dZzfpeAhyo44qeP/Dh +DQD/GLX951hFUQDFcwfbj5l11Ara5knE4eZA2RukDXTqVcn3SEupst1+T3tGMTdN4p4Ky60N5czB +FkGAaQnWkQOkFLoqECC1wPojWEGThle1/7keH6r/4eDTVyv0R8Cd/bosHhswHmivAcwH0EEIs5Ef +TOUYJozJcJ7j4lJptDLRulRyLQ4XDYxTSX5Ro3InR4cR/paVdOrXtVvp/uobxwGu5rWDCrxuQrW0 +BOwgMIakCI/8NitlmcxRY9Tw8TXZM9XOVXwscLFD/YPMMZoVZM8IsHLe8vN9NbHwXl6R62F977GW +VOJwUNRhCMDCRlB1lwmZzznZnR5qgxKhnAvb/mhOWF8jzgJqGUCzQ5gb9Fax7nhmzfmSKwXBclMr +GmenBR2pZDZBQ9lZ9nZwVJmpG7p/THWfNtm+vyy3YvG4zO+Dx43jf4GDHz0l9LrcoCpHMWvgRA+i +amphQveME3EcYLzamrhtnD2l35PvyjT6eZOtvTn0/6gdj9+jSkGcAq28Yau2+8v9ep/VcQytegtc +2UI11Meg0uFBnAEz8xjDi/aq1Czys/Xe9ktLlbZOUw+DdFvi/44H+muubXyYhQX65bqsopfmIe1E +fc6kW4kdjxUophnlaP+BB4CepMoUr0I0se9fvMoaaCbsPZ5jPEscumEO0UoieAkCPVrB4Or7Bnul +JAG6qYNL9HnRnXbR//ks/3/4IGcxwMguFJ+T67HtqmJcqDWLzMyN0+cY0v5HRjA0zyGhoz7hTks/ +bP8nuN+Do79FN/MfaQB47EO+5vY2Mh2SQdGSJ7ZDq9na1GybwMH7DFQRQLSVPGczj6nJEYPibkOu +x3Q6/UfnFzdB25sDz6EAgwpV937lTVla9/TQrYBDT8RLPJKe7XFJ3kscj64kAdwKLmtbxRyo6gP9 +C6a92kXhAmUxepme4pP/sXbe3GnS+F5IZxNGpC2mc2NALo8S2fHk2WcXUsd1NGxdkRY294kj7VEF +UaPkTBSKv2iy7xS738g+c9fw8Kv7lsRRgFGAauuxOqSrTnvk4hTrro+KQtKVk3Mt6WeIA51gtvYu +MAGgROiG5atl912mqiIr5y14E3koczLxZKCfz19ZNjAMDzw9aWgmq/3pfXGh5heRpReHn7AQZ0Dg +Chy8M3vPYjg6RTOjdWJy//APjUxOlgPpZJvwramrcHR7vPV9NX0qI00lsKriicrrkQp62N5A87Hf +m5AgTcEqJwDyyYTu4KLzluv1lVG3HfN3xX5N8/m4CXK9BEBU26npRb6lHu+B6UzRhZM/pBpTNfGB +zmu7BcqIouO03v3c/6Eyo+Jha7L/7HTTWIRk8cZjbjjAngLcN0gnaNt8qZh5N6jbg7wfXSOoUlCM +eBg7FY6HRoA3I/RACCOegac7C90sgoqPm8nF212mDq4eVVfPIcWfYwQqSRlzNLZPX0ljqrGUKBH+ +7H7jD91re1fxcgKotd+3tsIb9ghF/g9DJ8YlsheUVYqwvTvlpi7uvEEAiX5+om0Qu3WqY/tpnxeR ++QWaXvJjD+zxtzYC596Aiq1i30J7IhuZQg4X0zwrdIreskcipvHAK3cCNPbo6jpwZ0Bhgq5f3oDd +D7rsvl154Eqy7UWNngOZVwy+YEFgTnH7SPezhOEY3biGuHZ+Lu6+6UvqcgSGA3X/4GbADIH/sGGO +JPL7lbhSC2QYB1Vqb28viiDPTrlJgALfgwF5CAAKSsPyuxp9z9LjuFwrpJ5/1l9yYbPCpwD30IZa +tJkDs8zRQ6mewrfPOk/sz5z0Tpb5goeDdi46cR1lKK6ZVjDoSQ3GP0V7ytvfVGlhRnHhCkURsmlI +uJfqKDEyYPoEnF1RDmUxg5LinUi4mIH6p/8G7tyZ8r+m4EYECcYunkX1PRw8QfmDlzJdqy9Oi6E0 +eeOmwkwQlNoP+Yq43nZM/ElPPZPNzib5gJnbMUjg66YgsLbD8/ttZ5Vd6zNHkWN+2qnbY+4XU2yI ++1uYIJyBfuKoQDdWm43ymS3TwhNMuosRPxsfkncwvv9kObMJEiXbjSXfxt66Md/HyxKU/XtektNT +y69lExTUg9XW3gzSWy/d27fEGlZ9gKZG09XMqeJbdqXug7+i0QG05KBn96iGEawVqu5Mw7A9d4qL +PMn/Bgb9ipeMfBvqKD3vU2m39efFtI3TdedvhkP/vfwiN5tvPhPbLkd++1EOsye3exd4axOcLdxu +PSlZ+I5TvWVgLfVvDpmv1fbSLvJ+FEWbYe2hdnIXpqQPHC3u2vbqWcWFS2Z8z6zu12RvAnMwcXIG +rhio1DW6bbz0uT/z+z1PtC8aD/+Q6Ljw5QDT3OnNSGBO8DXtxQwzX/OkMewSpL5sPj/bpqYvXZ7p +LpLbtgneCWbvAL3F/0j5VLKqqTmZw64t+Nzj8h/W7pVJmwKdoaqTYj4NL5+R2FSfs93xbkKzSrX4 +BE3eJjj0+miPTNsPpPMmWnCIJ+8cYircP1NqvgkMnCQwHnHweeb5tPe0RfJnx2ueX+DZorq4ISne +AgZ0IrdFNZLK13e+zKQZMvCITDcvu8v3cKV24Be80eDVVdrlKDzGwXnBQfmeuz/XPlOKC8kbEtGB +kv1ge7s1qQTGjwB6p3BauYOPE3LDI7ZRTWrnWj4mS1zEA2Fa+wL7ZG1jQ6UyTdMmDicmnGeeTr23 +EqCVRGH/4wYdHhTaGuslCfSPt1F3yTZ2ip+geClrs/DY5Inq5KYgUMq8OUtv9N7ml7xpM6M4xWP1 +vYoHrtJvigILPEWMxDY27OradVy0iIIqZNtLzoW9+L8NGwVGVK2lTBcdtbxCDs5JSNUlUwZdZSsW +2hQFluFvqi8Q/NkWJGVIOaRef0IynaGDlQIXhXpHZYJ0tofysoBVO7Bv2Gqeoe5yznbOn/IzvoEH +CiaOEAFikrns9KYnbff92HPxOd0udqc2m6TxuZ1EMOh2husroJKpk0jCmORlLFnbY6igGvYllyl1 +I9gO02gYcBOubRQndwGEFRLT26XvdufK26ffq2RLGkYp9Vhn7M6Gv9vI4AZDJW6Dgd/YM9IlfqE+ +TVSBRXsnsjimqKc3+DctnGAwtH7zU0k46OX5t1ZG6cnCr0x/OuuPVmxoFWmBEFhv0TnwLiSzMi3w +o9m2ye/njGsvPGjQHMMd7AAYBdCaYQRM0fO4g2lsSUoLSwE2DRldsVvn865tgkOf92l+ZX8JZZNF +d32WoQ7vdyO9cLty4jBwU7yVLxD6aXs7/N1t5iPvu4aHkj9m4iIgb+Z6hTu0Lyn24DfFmkMj1tYP +uWKfx44+oI529sfBrqe0alzvbQ1rGLENeUzrhggrtE764HeG4GAwWABuXvSvOqeeQAFPXJywV9Hz +71x5I0tZzfYVB2pmtXbu12wTBCiQdH6FHxhonFjKkYPrDcyevf182r2SEAA0GQ3Ye1TsH1F4DlvP +C5zVG5vQjjTAGwsUDLODWULdI1Et66gFVG+07D5lZsGLHOcQCbY9EDj5nSBwYzBz+9O7qXZpPmm7 +dZHnJNLL335XFKDHha0nWoKbiJY/HBHnpjnqxFtfShKhajSzQDlNCAKM/bxjx3K9aOd8/NmPvu6j +LZ772a6x4Y7F7oagXpbRSYXIbzpQJYaMnhc1JvW4W4833sEdJZghtXHtOgTrBKLcffMsdw+2LHfd +2McsHl1bqcPwju+ILREK0JGvMOGS3Xjt2/2x1WTRjArxwrz2PbjDHVBKPfTfNSTYXHZNewbjR2D9 +ghwPmtsc3SrOahqyx8Z9j3E29pETYwH+OhgYwHTBAUw/4PEBSJVCeTLGMRE+XKcqMqvuy5zt1fGp +iBiVOQzjUoVajEENSdfsYBvAQAR7pwOc28Pyfpq61Og4UvfDxyTZk2JSZzn+hRP7u7y/BARalNZW +u8158VZvM6dc+VijSZxj7R9QYAEHe7gdVPQY4YROAAMIPwcZw80qdB6Gt1jc+sGF7NzBeAz3CK4T +wp1QGRwoHwvYCQsQgQBTyNOWh0KVauK6v8KfhkR45Eg/PHxjMyaw6rYNdJvs+fTOfjvHVNIZt5J3 +SIcPgqLGfcvEsAT+dG2Pctc1kb3Wi61qL4o+XC5CMs80EYODuxYoqA6HJiDiyz65i2djlr5LTnLq +vWAseuN0L+NvWMx3L66Gfk8sDQz7/E6Ma0SnARZpmoQnhTaAkU7QXtBkebzcbh10jVUZrlX7iMF8 +lfVCzibA9T7xFvY25iibP+fnaArDgJR/iFAs66uCvvu/hozwjrXDJsel1Ec5W6LIJ7XrIbuzodOf +EwqHezyJ4eHmULsNG3D7gD14AAq2l+2/uf1dduXY5HxK1m08Mu5aSkaUAv2iC1DGnIACOiAF3csr +9pmtfmrzku/JWgvt627DrO/9jQKdXwU+DANIvPza567T87doczSegNdLj3K35C0RI0GlXwDLgUBN +JwIkeVhFa1j5x/tzjBFz5Bu+il2XpDPliZKg3IwI7BMPshg/oEwVtvfisdt5f2cIf+A+Gr+B55uw +rD8/BMDLBuM+7ffSE78XFz+mILVi3rLgG04MDLSkga5E1Dc4OyEhFubTlFxXPOgcprubSLyc5H++ +/a15lxgLphAPkNa3dgXYOoC1tMyhxsrofb461Rv9p/mo+PKWbWIKffQc+wzPvP8fGEGOe3qTXk9I +tVeKfr26heTTelpTP0NU/CHAJAtASICuhP9VeiKs4Q7Y3QDA1CPoCMDMQTZVtzIOkVCD9vgz8j6e +1NNv2w+LjBNlAx/AgTDtsnNv5SxOPRYk14zYkVGGaOunVSQKQ5qu3y32FmBTJpDEyi/3axM86mrA +2GOB1V8Ugr5ZS21ESVDiG5TlG2Q4JL2La5x+f2xJHf9vhZ7bvktlKrcy7W9UwL5ZX9mb/kkdtF+m +rkuW7WGLNLg6AvvKUPE3hvXvwAiChe80vYv8ghSXymFSr79uva0T3/iTGA3o1sOYZNDmiJ4rWKH+ +tKfvUeZpg9LZPHOeLG9WfDwmjxDrJgDhL3y8lq8jupU9BO1nlj9pwtQNRD9uAt8givUEH/7HIxSj +VLCT5US2Y0DvqtZ7Alc9BostxkC8INvOc1nfyie7RJDlj/UdHvLvMZbZBI/zwwvMpAd/zFBP5zGd +vWkX+EHw69WcuU3QaOEFii0c4cHedCCtVf+JO83nIzmXt3z2XtY9/XQTKrQQXT8nIEvi+0zlswO8 +Za23M++Kvbzh1eP3jYASBWliDg6QkMC7Wkh/nLDRFxx+xdurkMQyo/PA8FhDKDES7PtpfUX/y/0u +6BLwctKZxovTzfMOdS99500iDKAqt37UUPczFhe5VLCIRZFn1w0B40K91B2qUrcHCUhVQlzoytuY +icZipZW/88DdeaFvuf72DsfzXHcmGr4HbMaKpXig2Ne5InsXj2nztWSZSt5Qsc49p9wuW8L7L1zg +/8HO9aA24tF26caz+Ko5bSphqw/NPDmM/MabsaBe9q5/hk+CTRXn8153JmuD0e9mg4ZT/U9GNiVA +CQTAXQwKBcAUBD5rXUlZNKp92lXPnhQenJs3J/KSGqmKILadNlBipBTW570PpjCsUuTzu1L7kzHs +UWO0V7xlyT9wgZIK0/US/Y8gY6rWKzfEy3HrsIiEl8jM440ZBtZ8mzFChSMJrSCZpu7EKFf6Z8R1 +5bJfFD0VR4qSCchRPN1+vQcnQELTdQOxpaVCx+32gXI+9TkPuXaqgX8gwQjzI7u/Dqdnls7qtqmI +1QnvflH5Z4DxH/Drl2zYAViIEJPv8yOfAk+kvvX4fTiucfXvBIAF17NkuJdJi3m3BYKlZKn/mMpM +RN0XokgEFNgDc3PgbmsmOtoXqHOQMVi8a9ecgLU4yS8SHW6azL0EFPl1FiCf0o4YmQa9WdR33YZc +dv5to3LWW3l3/OQjINjR9ghqRYGtDO4VrLUVTMxOn5OOMjHcecDh5xtKVZvRXmKzQsA4cdh5tj+v +3u5VrPQ+2C3VAQrlwD2/iaA33EtBT0MLXrvUZcToOB/6kZsIS1r9gGeFY+HAOQBqgdrYY/wx4J6Q +9suzmI8y7B+yke4renO1RLYhlQgN3A5omrp2FQCZv+jrYZ3J9FHKp56OirCP5DR/0rSkNHwlfZiI +MOFccrqOT0j82XK0tSfd+n54a98JKDPcshkSdcdCk1/aqkQn9ceQnNvrpderOo3VykpDIliimr1k +QIGUuV5ECbVS9+uTUQ3bfM1VBIhx2K8r1ni6PdxW7cNYTY3H3siTMarST2Wsd08TE7Do6UOrC6DD +Z30uP3a+TApelS27Emmm7x+U82glet6HGBPO52DU/Kb4u3n94/GZXyPabzHeZfmkaXJQkAgH6pwQ +1yaxPu3sSpYP2x4j5PYdCRWhJ3p5vHNftxKj3cR4gCYsuVvplDOVlcOnFZH2i3ad3FdSB/+dC6SQ +y7soaHY+f49heD+fiXx6H1Pf1AIRCvR7ESeYDeSVw1wAqBcPkK3ocnBM/nQuM+9Wk8sRhxJO2jjz +ElD9/0K4vieesbxibS6caLv5LbUmQ+WS/r3fNcR+Itp0xrKmse7ej71/CmVzO1ujzrEydOacL2Wf +vrQJD2pF1+wKkHGdR2+gbouG84N6Vk8LHrXeInLxSg1igviftoPBTr7PO3muV3zN7jxSNFqkK2/9 +1PcvfBvtAywuhr1Rv1qvaudJF3Kk7+x4mkz6X4Y6ES6kHRxMesRYGJRSxT7Xaz7TvdFZ/jxFYr54 +g1qfgLdjAxalJUM5JACHWfjz3EqD84YqPpGXFw7J1Am/CJ4hwoF+NLa+5NhCSSbHRe2a4yXOfNct +aVRR6cUz/Nuz/pkIc4CHmrds2bdY0389/lS5v3HLEvlDbzUcFqjqDnCmdDCREK+XWqcpLrS9bdhr +wZq6ONgTWaCMq+dvKA0HOmR5thUjoiZ/Xf/sWbFrKKT6rJSrBq7luv44y/+aHPdeZXVkZxrH5+cs +wqc7k2WMCA6Gbh/wLKzBlIa4383C74kfkmM9adlxI9t2UdENB2aB8bEX32SUSzGN/rq4hdLj5e/v +NWlU39LxBxNysg8FSHMeWqbmQ2wP/jZSkvjrmKmVEkEkMHjX9zTXNzuu1ZCf9Dt4bWTvLZORE3dw +B6+HnZAIGOpdCcZ5zshufUpB97tM1dd2gz7d3TpfLtzB1SIsbKHy6NW8wTt2HgrQa257J6AxnixA +8SuWE3coOn5hYvUqyJAhaFt5T8KXCZ9GKT3+Q7hTbGljb4rKwgB2y/yieYdAhvaP4/sTjJD0uTQ5 +zWYXCSDAsef+03YayBx99LZk6ZDKluNPua5y4+q1YKk5II8bCuVg1zIPaH4SwJEq3xSnx7618uk2 +d8WFQiQO2gazjm1HHUlD1U+Q+SSQCR5TiRD0G5Tywh9MaB07fKYHePNav+uWhiLk1CXijzgK48az +bDDr2JrmeNM/nLGszmQ7TMZda6TeXcQddzDgJAdU0cvGttufkFrczO+66ca/bH5I/DId7lBARwLt +prXxw2TjiYOyfMdzWrXm9msX5T4Pf497DG2BHrjYD9E/ie/Ptg95O2r1OuAzA9vSA8a6QtzPATA6 +QK9nJSzcfblXsCE1nYwBJ2M6ytOHnK3tdWC4OGvA8QXqQejY1dvEwJTV/Kr5kmOUoiOD7+VEWW+b +EkRh2anr8UZZUnlWEmHu/lDq1Jma84FSM1yl/YTRtoBTfA1xLUlVjum679GH5/blnzw+891iz7V3 +hBBgwmd1PCxm/JT2h3JyBQ7nugIfymVcdWFtrPOaIENr6JiwV9bFwoyr2Vd3eMe26h70UfO7L0zz +gDAUTKFpfH/9AtKrxqnTJeNhibfj7o7npwiPPgHWtAbCxzqo07a7bVXh0mM4/VfHpu2dVom1uqX5 +z3CwQCzIDglUi1yvBbieA9X1rta3KeFxmU/wynTRpXOspQokuIYJkBcMVVAGM1kEJPfZk9+vttZs +9aqTEdxGJf0ZVy0A8j9QSjJwb6veUJ1TQ4hfNFX9Nvx1B/N+p10NhAAbNsbT+6GvnqeaPTJqDjnJ +Y0lLM5FGhqsCgiCgTBFaoCkUBBvNP/hIufuugvavfe7JDIYjFAQxa3PgBDdb/0JRyVwX7aPZDTPX ++21TY7pDfhlLVBEAAkMFwpTuG1kI0D0+5j4WlFT46KPtG1yvFjAUtYWMpMM+5wsJlVW/aiar+Z35 +caz+La6KsTYaevqAgNyHCOTaDWcJ5HY4mMChiGibBcdQFdXzXxF0CZbm/Xoci9RBqngsKKXc1haJ +6dO0ujz65dZ7xvw8SqvC0LHG93EhP3Ed9gTeLxeXjvd2P1j2dH1+aTz53dOBH/G0uPHXje5GdBbF +xlB7SKndUa49M40ih8x1yWupTBsvKOC6DQjSrIeqnRnScnLEY780+e9mvno3JCyrC9fxSpAAXfd9 +jULeXHh8JpH8mohrjLOua9HHR2fu6/wLhQMqEV6uRqRknj5gkIQ10DgooElS8O0e3Gg5UTz6OmSr +5n3Ahei4UVj80yZllyttxYxbz79wgHlBUM0GgCbc4iFPvG+9Z1s1f/rivVk9bhHL4X+lAfCKcnvd +KsyC96xyNx/bUdgfr91Z/c94FdSSBnPbeEtcY3YQYBrjZldGUBYrvX3zrxyacDuUqlq+27VPbqut +Z/jk/JUqklRDYa8gXFcQQRYgIRX4ioY71RQ1dSdjzqeM+78zzl/9eeLKP+3P9YQbx2m6wt8fA5cW +ko4qv9XXDzyumx7/TwyoJX0mxDhcKhRn+q39JlXmVRrEkSMvcP2jBPFr6rEd8EgSvFyuBfJwMV86 +q3RdsP3Osy1f9Yz28v8LByZp7ZoMXZuPg6LqPNKlVSWW07no/FPcu504AXpFD++/PjAroP5H2Iu+ +bIxPS++K11D7P5OA+3I1xNGcZEJyqubgtYsjX3XrTuu8vkqMAe8SAzfVmRQat2jTMQO2J0bM7DNC +24QscK06DAGwkSDPKWA8gNkYu/Qf7/kuFPnCN0PjVreK8WfqKlx1EB8NylmoeHZBS5WJFZ3dwVb9 +OesHpfJOC31+HX/DgzlbErelP3BVDZfabv0uKi0qrWzTiWt0YHDAxrVArOfsobUz8zB/9lny6l12 +pmNJWj2nimOiI/OIcbgCvj8BuKUd0F1hQ0AiMe/G6Zwl9oWdai1ftWxvv7uTx132TywYlXrhDJXr +R00Gg8R+g8uXp6/+PH94CffaJMyAbTeevzb6upS8XLZNfYKMNzvvR5xxP8k/kdgCuWlQiHj7mHq5 +11jo8GJfjydprVtkWDfPP1FAT2dBjqsB80cEz2QpMPofL4+epi1VO1oy/xcOrEx6zRafjCwH8095 +17uypPifHaT+hueY3IgGQHDBDzJlLciBlV9+iVOqbk8G+uzFiYJAbxfmoel601BEFLLxsHpNAvMy +e99XQXLjC+2PcCP0G0mgOIm7A8wcU8NV9NP7RQ47fWZKT/FSUprDdT5NSjF/58A6DF7F46NpaVMK +T10R0/+N/4lMXArV/SsBAOTqMcnN92PYPdTwOd5lKjUYobAYTAQIDN86SXtrKNZxKs3gVqQhXUZn +VmieK8HhcAs4qlGMEo15qkvLrOIQ99cek0sHchn+4GpA4H2JWwU4Lun5LvufJfqtM7Z8p8ZaE/6M +Db4lhANnAifzD8C7Nu2UzuFMlKM98Y0q8ZuU2+uVW7g3xToedBkAZVkBtwyAPh+vVvj2z0ryNT0z +k3sPe+5vp+C/tSkatNkuRrZUt17QjRTdvnqQTfp+0f553LQlEGRvYQE8UEK/2VMgX2GgFYm+uzf5 +LCzyyf7lS0NTNgRh+HtvKP7m+OXjzEw974Yudr8ak/gVI4+bAgFC14Q2HEw6wImrnj5F+lpSs2NQ +8sCPvfVHaLVbKnfiOgcg/Mb47IZv+E3iAS9x5Fs6Z3v5riyj9lPxVne5TTmIfUxAldSHKfjM8W1b +ku2pucPM2QcjcJMpQCJUDjiQ+quEqcAZdMpo/Ndqwg+3i7ecm+ut6oYEcGOV2Fgze7s1m9QJ6sqF +KqlVYHnC76ZNHdceZW7FwWLDbdVSJjs2oUDVIsFYMKK0HttYIkinb8O+Uqal1xeXvzqJa55iw7G3 +anfNda9qw5/nRFybK6t+Hy95mfkC1wO4AeoEHhC1jO8LPmH75ymate63aSyFeH2g/m8TlIU5+OQY +QPo4Cky40MvfM4pvyzLil0DSrOZ/3hQJgGZ2SBRb0lE2UGmSfn/CFM6q77lLdDPQusoBrk989WyA +g1NySZcEq9cHykucZ0s3Wx+4ndWamQfqjErKowLzTiN9o70yuVKPOOI4cvfpbYJ0AG8GtMm39OaU +fpDm5M3U3cuD36mzLpwIOIB7p2wA24M74a4B3QLLVGScbHjFsWST3zrbtzonbIICCo5AUuNIfyd1 +05xksaszTH+mpX/aeLi2bhMgaMhjB2HWKDwLWx/YRsloe4hcUJ6+tyh+J9S7kDgFgAjSMGhzPdgY +G0tTZhmyGDJAe2cPbrofiEAXLPeTeMy9f95RlWbPt6QDF8NM2Xf/OkhoPE4XwgPPvFt3iTx0qPR1 +fD6vJpVplu1USwAGDG08MybmF7c97+Wknbrp2ZWYOwfkEwkM1VkPSW0QKNcqM5ZDU7z87vwevmRs +9YZXznr5CTE4MVkibCTpGhTz7FqR+A4BvtmTkqJn7uBaKgAH4GBav3J0X0gcz8nLNUnumHfWd+ku +ntonEkIE5ACHJvO8oIeMLkl8xcqstPmwgUuo4KNDuGnzaMiGmv5ef6jJFhPyy5Wnm5//XLQqukQW +GUYEB1XmAQJuFjaQ32eSf/tj6pdzrjDh315sdE+bdPR8cLUtNBjsPLGeXgD4t7q69hzRJKMiLxF9 +wXdvbtLoZhWuqrEBDDoW3/rrH9rjc3ZvPTKsdnBOSnxM8ygRDNIMAb4y4VYzGL0y9Dlj4eYbGoWO +L7nFI9dws8dREGD0lb4Q5aaPSYFMUeTfDKckf95zbsTNzMY3IOaEJV1zw/3KubouBs1WBbYyOUSn +EAVBHaVPs3VtiXiQMjc3Vrr0W8lQNtjTez9RCPpIXqA03BPQf/hd9I1XJDWxgm98Yx+bEQNBsrLO +wvE+i2y08R9WvT9XTEmj75nGE7pWUS8pUJ4sp+Jdz3+qdWynvS6d5ZZLOz2K7MRNW8WAgO0nYAO8 +UQSQ2mR6p2ek3g42jVxWelqpODmeokb0A9Eb1+0gbOidaoGkUv6vll7j3ZdIrJ9QE8Mg7dBe7D23 +z13r8HjLzOB45fLucNXFS45lJ4minC2kwHdbGKuJsbnTrydZ7ywXH/X7tqIDpEuPinFTFjBoUPoA +jksBG7gJuAxJJUf9Mz6dt5BOkCiXoVM833V/G7H5Af13U9dNO0IsqORMHc9J7NNc1N4/QEVkOJQk +gem4WbJw7XdIGSKSiWSB3FT+c8kLslxcX8kG5MbFMK770rT/zZRWJ/fyVqOFFPZQnpopAmgwJrnx +wYVBm4hwoEvOhxMnYGoy8q5OGkol1gSQLhsU8qY/MsfYfzPejDoqtCyb7aHb2z6Im5KGDUK1BuWb +YSyrauEndVv6EPDeJPd6M+d/5wmi0KqtbrBuY3F/rle7evEyNfcVp8Mna0sJAcBXIHv3PZ0opTmp +xRMaxFnN02VQzIzr2gfGuqPeqq/fZBVMCe4XzDQl55lTpMTdHC6PVUUREE02wHbCdGzBUqO6psoT +665yBPc+WWrtoi2RuEUbhZt3ioHbmaArRv135vvbO4u+jYhesb4LkvEMWbzyuN4cDAp4BY00BfM5 +zJ1Q+OcpcuZCshOn8pC57/enu8qfSn8qRAyPPnxzkuaHE5ktI1ObKV9+kvXL5tbiIXBr2KDPzZVm +56PeeeaGDX5TGQ8qmqr2/qw+jjccSrXZsKGoSbQaTY/ZXMlemddIztxOt0LqihsFcQInno8zregS +Z5AIh2I3B8lv7znp3QyAMJCUkMAaCN636EIIQM0qAEnykVIgYJcre27mSIXtk1m3/uodcLw/Ad4l +gK4DveG2sEdC7489A0pzdNK3RFvJpI/5XcwSzd/PgTcN2GCwyhF0uj9dM5UeZAzpTv+pVRJ5Wa1O +4+M9PDXJFn2Hrc+IA8M7noV+5exxs5zXvwU7FZ0d9+Om5CPWQKgMdhMbqKLXVXYZG/v62F0B3sun +dknyxzNf5cW9/gBHEaoEAvBP4KTySyyQ7bjWE1KeSJeg/17OgqcB160CokzhlnBI8DwPktLvrn/W +7PPoXdZwC0enl2ZKMiEE4IoCtRy1h21/2JYfGpHfJpe/US8aqiKFJCUEAFx39k4mUAqX5Qm51zYR +I6bnGBy+ckjbPySZCMPNvUL7a1loB2D5awLwbcTTxj0z8o+6vlpZEBhqAUqiyx9OsRu+PvlIrERM +W0adjFVQsh33kd269QVVXROAUrswrVch9fE/pwcp8Qc++u/WPORAA6Ozjblciutc25wI42jNdxGt +ajAS0mPTyWao6Di5W1zDIvcfmSyBSogWSBsB6MeNs5CMWRorNtmc9Dp+od6WwSG7G9cfQIzJ3gZ4 +JAy9CS+/MGoVP/3CYOmeweGYpkdvjb6/xw2wb3zcD9V7wqgi4tcqPl1LqP441i16iJ715I+VVnZc +e4aIeRpIIpmrRLd61yVpoVosfDWs0fs2kb+8HpICcP7TJ9/6OGf3u8GHg17LF1plMnHh6hYoHBYo +3eX9mcxk4YVvBt5bHCh1FSJ8+HA1M/RDbridOXC01y1F3hiT26Tvc46fClavsXuScrvGfh733kan +9KDuALSYHM0kYTb6dfbAHqaeQScP/kMDkWO44VBMctHaIb+CcsViEqkAji0TgQFfmObornclGlTa +nWQ1lh3HFbWEOACo1qW8/BM/z19o/GxQ6xTFk6n9/g1u4BgLCrofd4qRjkW/ZeeKiAubnzyUnou0 +wM2uQiOA3AD075w2MNtb5d1tE7Yyr48I3Hlw3lMJ71SiXucBzgU6NrbJz/YMu2admQZ9TpLYMSq+ +whttZwaJPMxV7B6rgRjf+84t46pjSlduY3YdzAxXeGFS4gDTDbHhvW3esixHz1sJ6ulICa3ys2Iz +klSDuJFtdEBlbYfCTFBJ1YDOB8A5tGGD1yXDkzoyhI82GB02LUrajhs+xMAhhds8y3LX8Pj95i/f +Es0be3ZEUy6qDxFDoFWaGt5F+6Pqf/JphqVUbg778j9Vn9xNBAPav0snFD5VSJKl7aM/7Cagta0Q +YXoaZzikJ+NcOSR2MR/F/ZW8y1zzwoMfJL8+JzOIuyvBMoDoGAPkHFy3u8sTaW5aSXKU3BLMeUHh +dfF1nkrMJwJ4qEI4kDKMei+rRyX4PWqa+aLLG/83cyv+omqiWyTxcWtLKOAuqiEGFpuIUxym+cna +Ef2MZ17S0dGNKnohVpkgBBj8/TmyrV/6sqrc2aQ7KchHC+dpWi7gDIa89NCtuN7TWCzcVkCdNWDf +cADTtz1/npjt/iGDG1WFgNDrYvCZFEoaQh7lrBRhby2mlL5m29OiLKyF8MqoAxEECbCVQ2SgDfdL +nqJ4pFaseP5Y3ffsDlHc/Cw0CG0HTBy3ZiAJevjNYPvZs0ujRTzdoUdw/bIQBDIXQRwqUcscZgND +y4WBkt80LZ4RO5f3qH3tJmO6w5jlg3tJEw4RAfpKY2D63LnXhdesghCIhmfdKjd7cdNC8QNDa7hM +/9uZRc389aKLspedZK+lCEQK4zrNCIaD1qCDbV0JfXJzHSLkXA+To8RWizxqcV/JEAgCAY5+5GE2 +S7tt25nIynxfRHfn779lhvsQAif0g04LAnPKsJ4wwKEdpnTV8VvDxLvHPJpLuiZ6dosZhgm4uWWb +EAIMkXQyruNMpp8UvboVpwzNd81oc+GmZxJhwPwqltvN8kN6hp1diw7h1knHYwxFY3BfghKhQIW2 +AP19gPwFm+jPOOvrqpbfFMsWRum0r2zOgUbe3XYl/MuzbZd1Wu8f1gp9dvlBTH0cQeT6nwVqcaFf +4qy/L0Gaop6/AI7uSvF6vXPTmg8/GYkW+DIKWdlpe/8PpHYwV4F1sp7zpw4JMU+GMS125/4nelbW +2jCL8CEhQAbGr4CXBWs8pSeY9h5jOF3ue/Fh145vxv6F2nw0/8gD2gODfsfCbbeuVA+9Tpzfz8xn +KxFV/S9wzO/QPn2XwWs+1fRXKhvMrt38qntWDW4sG48ACjphCnnO3t8p9e7gFiZWiiMFvDae8cUU +07gvunApQDkBtTnIpNniEBK6EPv70pvrUW4WbzpFcW0hXPDaZYN0A/2mNjZg0w6gah7AxWAoxjCl +cZ5JwGKmf68RrbBLZBSulYPLhdWso5Ek6VKu816SqznG8h4mbIz+7W1Bf0FjqRs5WauF59tuqOh1 +UzyuN6vwi4p8I/FXNPD+Eq2zf/Uw752kdN76HwuPftaywleec8y4nlFcAqQDGJxH74U+D03JgbnX +yQoPHujLuO748eXoBK7rEZcBffmCVvPoWwHvi5pG24f4grp2cnyw/cTs8hf4+jUAENzuuvLuyaCm +MlcUt6V6dKvXxIkjuGF9NIHFeo/GQZY3s7l/KqkSenLl9kxZkF3gNMS9ryEUwtke9WgVgB29/GUH +Y8giu3l16qP9ph+2ZXcHZxOHoVHXqG4M3FnIY/UtuSkeakb7vkqBClfDwgTJz0R8O/Vud0hYLNKK +3JfVMrr725lmQmPBI71uzNYWk7XZd4zF87a9uSKiKShX7SeNq6WuwzbMxMkqOEvaR9L9x7MPabJx +9RSY77x7mBgSGN+7LKcpLvbBsC1lK5LhpYv4SYUJXNvM1crE2dUSLWsEzpk30W25uDp5Xifuyime +YN8hI1w7G4r2o/sTo317ci0+CzvMJGC11lzjtWQOgisTto6bAAFIlbF53ePbZRXJlDxk+0Zvi1Wv +zOKda+gdDXxDY0WOL2pU+z0ns1UyeCukfgc6iikv4CZ9YeEw5Xh4G5kZ7vVN1UYM2tgFZnh3OFKM +RBGHod8BoS2L9KcjTYP16nDlC4KxFfAMVy3yN8LE0ejNNLjUL5hhy+BNWUaXc3vHAOeFSgtcex0L +tZ74AArNBB1/8rttwb/td5f02nrcbCZDzOM6kNbBAIDuv7iGCRsmmaO1odRiVjYDH3z6cJOVIQA6 +sxtSqAFov+rpCzfD1clfWIYOj/JGSfgvueHJeAhqj7Ir9M312WThd/bOGwyqwot+e3SZqBP+OgJh +LNnPoQrjpJ8F+A4JmfGM6IbX37En/KFgd/ENidz11KSDCmR/HMKzBhnERg5UW2UmzxKErmnVbhYI +DwDDaS6SaCg1Z6SfnP9J8w7sqBr3D7wbEKvQ1nrlLNS3AxwriOuh5TZW1fNfZedPpBy0MXwag5tA +voED6LhjCcNEWwv5Gts+znF/qReVPqHz42TSwg8x3LDHRjik4KOeM2NPgOfC8U5qayOnUd5Sl6O8 +dw6zbM/GdTdvYML1dojZjIyfPrHI/kTravZEQMGLb4kseFobNh5mYmkChyKH4RcvbPte7Sby4aKu +6X7kzqWXC/a4Dwo3QrGMjMWblc8DXBn/bN+i0YeQ8FTumdyBW9UKBwvusmvba/Xkty5fnX6+vL3W +aSz0NMNPXJfHRhiUAKCkVKq5pf28epiI+4vMMr2+XpuZE5vBsLMAwRjd8v49rqF2Z3dI0NPu23E4 +RTkggU/kHwkAeMwvm5birTRMrxRZFP20PH7OX7TR2hSOFlKBB4zHWoIX7rwJ9NR3/3BO/KdQDmEx +ivFIAai2NK2O75R0Gr3/lSP4uCNMLC98xk0r34DamAlwu7pL5dGlvq9hMZFbFhJcCvLZwvw2QxOK +zfO/vJEqofd4dSfH66WYxkIJnY9Mmx0x0Arnz2tZTJGWO114nvNU1I53u/9L6yMMIRIMN3m6/5VX +57PGqz/LfMI0HFLswxJxCxitEwAAhFTYa6NjzvZK+sYjx/y2BNc1XcR9loHRtTo94oJkpYdDJgqs +C9+ENSb80bmG+x6AYLYZ+U4xqwTRADPPZcoX6TyTl9pyVwleahjP4JoJj/mj80cejC1EOhTQKfkv +6F5VJ6PK/KJNEAw+cHcygfbMJyXjzrDM02T/yReK2yNGUysnqLYSQm2Mjr2ULzrC9vzYBJlHq+Ss +wqDwQmYAwZO1Huga2Bsp6RF/oNtl7hK9AEkTe+9SMq4DEEIAg+W97gT1JTDPWB8RurnkcG78dLK0 +FPZgSzOwVxHMDfWqyXZNRYfKZKr9t+tmwVGjapejj1kvM1DEupz12ZAVB1iwQJhlY2nkjHcnP5H6 +H7rglk6GnD9fJjBYe3ycAAq7uRIAa4m9YHSK6xFVrvrk96GCVeYPxk/uEYCBkgzSPnZGlV23SSlT +MmFJfljQHMsgcCbvHAGEK8x0vUlVXE5gWksT77aFV7l2tfM0Qq4ubHKEMdC2ABcog63f5QVjhlgY +4pdGxdyPObrI7xsSWDFJyyYOqOsCdCcB0GLWRx/UEb6pQ0+V2NUiK+tukvdvMGOtYCZgYRELAVMT +BBxcXPHOrBg3eYQwte0xVlXSx2ERK+wmhCFozQhddb1fx4Xs3tvw0ISfj/PfGllyHH9WuyFBAWyX +LiIoLGANg61p5zYod7ItrYNESh2Py+Xf7ymvXNBxipL7HEsIBvpPYlsP9ZCk1SofPuPEadz0w/nr +Byu8sZAzzRRmAfgJUNeHnuvUuTeCDVXcIT9vPctC7KZvvRhFBAg1XgY9CyoWPUyHXmdTPWotaxgN +FeeP48D/MggEFp8E/9JIqpmiiN6EusgZl7ZzvN2ySmRnpYiANt5w/i+PkIR9fepHzSkzdibJQP4M +13IpYSD0h/oEvZLfitHUV0ycL3e+1CJcVv/uD/54oOkb1KAetwmckVbC/vxEgQhlEQmaYbFft68y +MNfg46E3lfZ2djAzcE5aqevZfL8flR+0zqqIlChp4jUKZMVHWYJuPmg67e2cnextUEWf+RcfzlMJ +DLqyPeTpVz1vSsHz9AclEThGUfEbM9KvWbrZ4fjQ1oaF5jDJU7dLL4lgMD5QdO2nNbgqnWzHa/Pc +E44ZPm8PBzkpSzjnJROBY4pAwFHXt0amezxZOm22oNzRzN5M8fqQi2fTiWAxj2mFlCkmLCZkDW4x +icVqMvZKsFK/ViOGcYLB0MVc1kxrEwFLpIkTuLiHu5t9A3uT5Zg96+oKSexKsl498iJCYgnDZOQ6 +6tyJqQkq1WkwqWJsCnppy8X5g4MIav0MovuCYhlWH0cv/S6yERGLd3yj9eizCkcPS9bbTXggGnOY +DZSovTfh1XbqywfbSrrOTY2TfJdzpLMi/RsavPQUVcR7DrQLybSGcY6q5ySpJ16PIYKzNXGDpg2B +rmMJnYkzXd5C6hymp2mGbt0So33PFKnyOO2vFGBgSlHoZEj+b2uB3YV9vClakaukv5qIA53tnddW +ex3906WQgXp2ycwj1PWMre9RUrNceCQR9JrZBDZCMoM6h7SMTCmm7CL/k7p8q3vqevFK4/KRCGJI +VCo0za3mKHqN02/bJwoyESfzZSit4ohN77q7K4jz6n4LkWDSrcGIFx5uY/vI94jfIQoCTC1zpzVl +H3OOBMDCEID5cvXw0a5DXXTXc3plhjrJ3dVffqMiwoMws4KZI21Qar/40y+ldF3PhlnSou/nC76Y +XyFdlSACRO/HdZtrOLjhhO5Rszjz2w3MKmThlAenjfk3B4MCLjdjuNQbzs6nmJ36Xs7qi/PJNGKn +AWkHt4MDpcXhHmu/GdTi1nV418m9jgjNWwo7GwvH3z/4cOmcdtr8v/AA2K68e8doolSZojpY52+o +yVPszNtDRPgAoyuknF4+l6oyEXo1JCyR12t57xXnGfzRqMZSds7AX4SCYAJiwmAt6VTaHN1xcnq7 +MqGb3KtzHeeV6St2EyFYuxZQ0l1UWFwA1dLO7+stuH/f93vHV/VVLxrnOEqnatXj49esYluwe8Ka +LmCO6plgFP1r/OhX67oL/Wf0an9ueSQq8gdOEImA2awdVwsTWzi0o96bHN5u5DgixD+/i8fCoXA0 +ISDCBA9oCrczX+9OcNpXs6aRNOCZQ8nB3U9vUbmJWyyW4UNsTOysUV8IgODWe2aiDfUjTiwuCMnn +P/PYeeTsRXwQ5MxCmKytIvh1iRLT7tKnylodlN7UHt92Qqr012lGfBTwdhjQeJ0hO0pU/Rx91hP7 +repXRs83Fs6QlLxCHMQDmYGmF7qHxAZdlN6isM8u6VrllUWKVI7SLknfoCdt+Hgr5NrvA9RmO7B4 +r4ANHNWJZ9/i1ybhyccMTiLMvPVs0UENNtUCROBrosjUBgZaYdMRMnEqgd6PqmGqVzsCxxrKZn0Q +hFFrJwS13XwPmQvVSdYkz77VCtaJf5OSTErlQxSDsEVaWqLFQVemcu9LkfgPRwwLnR1lEj6PTW4Z +JIYEd0mStvRKlzN//f17qYUW4uMDHsgB/PGg5obSO7A6Pxx6qKNSSap5NtC9sYMNWRE+K5i8ujkY +Y02QhVFuiZS/OPqspO/C6uM8PwXl5e7NoVgXKzo/BXW4SD0j8ji/c3dzCyZ9+zNZo2Sepkr2z1yQ +gingDFQnwag2DSantrzukvvcoih2Rkncz+aYGNn1/5VxTWS5YVGm0vc/f2NKM1iRe/b1aYfs4Noq +9nObUwJ9ItECTCj+c2RbLOxxb3V8ZDAdPZOuw4D+5mjg+l7bvbD1Ka9PpdG/fepFuvnHZj+5ArlP ++6nUcjbnwPkJpc/kqB63jJMdjzv86GvnK8kgcY6tmxKAyoclY1xae7jcLrMe6lCmnKhH92XINwWB +3qEyjZ3yvgFHHneLV0Tn+wcnvh4R3rYpCuwTcOpF83JJkPW5Lgu9P6Qkv+pmxb9vPktAz1L09OTI +095yuNCoZxDw5s2tW/wn2uaM7ImCsfVwqA45mgaeHJQo+hpeINTh/1TZ4d5dR88g5c1pgNfvOCTv +2IS0hA4dP0jddufqKovugVxxteFNSUCf72t4hsQ9v9OXGVePzWQe1mFP2ZdKDAT1AwT/xdneGpKu +E5zKoxaDbE6e7dse5F5M+2TUPXWUKH7j9zo8SFT1jze6rt1/pRt2bvxQRndg2OZQUBVAt93G/ATN +9JRPyJgC18GcVsFOhgL23rHbt4jxoMGou1IA0wnj/ZTkNhHONy2ZtPJl2c434GYX5Pv/QgKF/BUe +MS/brHbm7wi9G3L1t6pb4EmiOxXb8ZrswNTVnJEj5nArqHBpm4fC8TiLSqI4KNnQxBVTFmP7vaXA +B5YZmhKPWMtGRu7bT+7lx7eFUWiLNSUIYQUJ7qTaG99aF7PdI8w7qDnOsD2yG7arIoYDsnNQ4adj +1PudxpLDfxVeKFiqTmNKPgBjw9e5UDD0zGJeis6mKf0najLFKRn0KVHddkkmLLPN7W9g4GHjOoNO +7vkzCmKkl/I1VGeqWpoZZS/9ZiLGABbfW5tjVNEm7Isn69jUsFSurJn2tSrZUtm0P+P6W74Qp3FY +03mxE1ukhcLTdy4/D7flNL365U6c88SVMQ3iaAQQaYVB/wgkm2GKsgJuYd/OvZPv3Lfbe7Y5kP1i +bsmOE9MjzrQx3lXfslIZHK1iHMp5Oq/E13T8TPzOd8SwWLeLFSrE+eV59/BqMtmzoCuqISGiJ3af +irEjOgVYcKc1LRHoYIzy4kA7CuD7/q2ksvSZ5AjzQIMat0j/9sWdB/EVahQfkHXgjjrCUPADfdsA +TCnwvFKRl2P1vpH1evs/RUeMTI11EGMCS8Ssd7/GSuM82Jv7ZZRG+nyQfKjuF1PGh2RpxobEWID3 +SU5Ajz2Umw8jT+Z6s688/Nwt3d7ZqCz1vE/2Ui490TkG13Z9aav2eKSXLSxzHm8Y8+f/sMiQ/iiY +6F0C5tevmZ7O9kgwDoosOSLDzfDuyY//7Pqkn0lTBM9fIQoF3m+gHFVXzWh/9zwp/uLNPF/o+kJL +Zbj2WzAxHJAhDAVS7h+4t8M5zKRX9dRL7cMJln6piFx8AwELBWCMC/MfSB72vBHl23rmaFhasnFm +O76pi8YA7/GAfpTomTGSGnjIat+9rBbTc5pKfIEygfsx0fVFd60BcK8v5J6fusw/a9LMSzLB2INw +ZjLgIo4DWuViVFxwq220zMA9QuUSCedcION6uZe2jIbsj5Bc9KG/MYItMm3AWL8kJTmPptwCSUbw +rNVjQfjyt3102X+BI+1gbpBXZH2T3as9bXW7lGK5KeptrGK6J33t5VZz4jSOqDvA3B64fqDTYwF3 +Amcox7SHrKNHre+H19OJ82Qqxx7wtUxuwgR5HzFdJtEvbN3i5t54X6clqZIMnuHazc0dQerj+zcW +rIP3ikzNjMb5+fTOhF7zuw+3sj/SqmwhDkdsTI9kvJtts1tfZMGPR7dI+VeAX4qlNb4feR0Maajm +a1YvHJTMQrZBRVkBr/wWKq5zWCsGz8TUlwb9FY7lmfA+0SntS6vEVjarpVfH4ejQlO+L721C4YFX +8GiPCGSvo47hHEmMjOOH8EnqRNW9e0jjB1xhgy7/QAIGNd1+jd0OdeBRnFX/ddJn6w3msB0LRKEO +SCe4PRKB7XrWNyOTeeG/erBg8twQ30qVAqxNcZwYHvPt6H1o8erVXPHeoaM6A0JBS18aTc68buH+ +GxjlgN7QU3KEOmuesV3faPhmoZjMfNt/8NpVfBcpDg9GE3zEv4c8dbbH3ZUlKdEuhfQcrY0Nvh8L +B2xvh+0IVy1evP7fIE+j+oW7R8OiBv+7q65IVLxs9GhtbNpKe3BkPk5lgewNH8L/iNrVCbaSwLx/ +5AHFDWZef43HiRgacRnN0Lvc7I+WVd5TncPwb0QAOtYzJMpawXSu5tv5eO2Xgb803yk1/g0N3awm +ziYAQXpEbus300vvLS3a/8t9QiG6I/Ch7F8IAFiBtmeXpo9QiVdN9INc6+hZinv2RI/SmlRDmJk4 +wNaVk/DcWflfWyt+fpm6r+C9O5z1TUfyNFG0g4392hVhigSFKhPS5PB1N+dGa6kx7nCDMwerG22J +TjuEBB0e2yU/35u1vB7aFvqz/Vg5q+a9IHxHJAoFXQZrNwuQwA/tG9Rcc9FL6tXql0nr7pGdRZQJ +v+bilKrAZwFb1gPD9/D62wxepU7NF9d8mzsweFRx5gmBK37tLwCyBjKB+xhLl98lzYc3bvdeETT7 +/lhMsR3fqYY+VICwR7koyP8YmK2GZDtyfda4uz/R90bIleByYjjQHUxxLK3tzC3T0tGa8enqc03h +4akEbJiNrkpbOMIWnTeX3RZFyhhXnXvw4m/DH3Dn6pHOkhN/wQOwHyLZQxNh6T7lt5y7zv3SD3MS ++o+A2Q3BNEEUGD18YMT38vb+mtRR5Tly5GnPnnaN3moCMCcgw3pDpZNaD1v1qR8Xv5DF7mM6ntQw +a1d/+zE+EFxqpQ0rnd512iO7Mfrre+7Oxre3+veL+1rswgOCiZnrjkqJ1Z8V0xGvRWt359XfzR/T +SdlpiW97mMNMkaBVd3SrwkGyD9k7BjOFyhppD6sY9dHjX4PmMCBqbQ74X8H522pDYapTqOnhU6jc +sY/WR5/iJx/+BkQbrtg25PYd367fHapaSAg+thLL6FghOx2O71pEAx1QrhU2CjUk6cqpbsE4c2at +8udjiu7G+PsXN3IHZRCAmqPWasj3AvKu5KsyWdlf2T6/W/IyJIDHVDwH/mKvEOfSzPzE5buh0k4M +59/8+aGAbzmBmg1wMeJa6FCdQpgz1pqULD/Xc+w/LvJjvqeCklKE8o7HMr6j46+EavaQ5d+X3P+Q +s0gyfbBORXJHsl8yc1xQ7z+zAQRyiEqWM3Tjkde2SajNTor23Q78OEqAAMr3wjs9O2lfip42e0xx +aMmmUynkiJ3fERr8IJk50tbWHXzCarKmRgLNwbHdt8/s/Y1/cFmWe3sPTSq7rHa+fdCMf4fDTJxs +3EFDEIGdKwBW6ARIxuboTTTq2GUTby6yPy1MJPH4KrZ/MxIAY5m1vPr1k5F5doZgk3O3DJni2B87 +fAwQLABzk1B7CYzloD49TsOFTie+jj2QxX97qyfHmd2//X/gM9hb4Fz3RrcNi/c/Sk8+xRt3d2zw +t8H1rVb4/g+MFx/8VrL+/yx7A/QTHxh+e16cMH/4QfUH/MsC0tPBVYLbIdGJjmgDqN1sX/P3kpzD +tPy9FsPWtbSisSfx9VQcClC94UzjCboxMmFwkpfyUNhHxLWQOyXEcNiTo1pdI35r1xzDaXVZueYV +lfC4kOgbBHDOTiYbTOmrQctIEqFL4zciGkjPP/wo5fUtGj9KAjU3xtrF6avXHzCpOowLD+fd+1V1 +1e0DXQW+Fw1CYZRoLLi9zITBseKwHM5ZVWV9GfEpf9/f+HePBWC4Y39qu6pSYWiE9h/5WpoBuWPV +52d/mjjioSwB7QxuJoCVhHOAv4q6wZF9/JScsz3bh5XG8rtI/I0HOLAAS3ltOmHYsZWiHBZv16oY +wXoNPnMFB/MnBWrFS3hg4KehDR0AxN0W8kH/y/IOPam2pyZizxiEtWfwzWwUCD07JsDrcQFTe6Bw +wNohgNs62MDN4Btkh1F5/N2Q8rA60SDvAy2Oe4+yxKvj2x6b0gIsN04eyOpP6TcYyc1xGZViEWeL +Hxb/dxaAoTzy454DHqeSuny1nj5uLGAU2k5hSpgBOsrgI1QUFfglmGS5rZ+bTIU4mwpiTlabkp8P +L5BVqs4lyLRmO5mamGNNMYt9YT+7efTZOvavvW85U30SPyTjO29QSHugpoEbCNOVPscvingvGTz6 +e1p0V/DdMzuTXYnCsGrSHLozOUfhafbwqHwHWZch07dYugxBojhXzJ8ro1aQTIwzipOiH2pqWJ4s +KXE/tUIMhn4fXtmptmN/YMbX2JJCMdN83q916Ud+EsOgHnag+pPeef9AK+Ggqkv/+euiql4fX9Cf +7O3ZBImEmiygXoI1kxZRRUo6biOnhL89vTdJ7+AjrUdEwAigku2awAJakAKONXBPaBbxd3zPs7vt +GeP5wU2HsW8xGT+5yArmtr72SY2j1kdeZS4umwb/zlOZ1nty5L0/PgJuaeW6pmQ52Zo4ga4H6alD +khJNp14rdwiOkyW2Hgi/E7uIjwI8wqgfCndwOQL1A11DL76isNC1lVOwXuU1Tkth5Gn3e4J/f2Kh +IWmFfLb3bOgKYiiyMq4luo2H6ebTvQRBmBoVYOwDJZeP3LL4dmuLxtilCeOkAE566o5+rWg8NBwo +YOAMJg9iYmGnuTvOUE1KJ7uz2YbPbOmkS1Fs9MYHojzYUAseDTt7VzsVOMwGKvl2gvTtmZhAl1Dv +A09YFI47HlHQopXchAHlBF83eAAdBlVM9Qa17H73o5OGTKziJrFVXyMZHmax/Z0Ky5+uqDB676r/ +xHK9+EXa03KUR/npHfBvVDwCLKeRSa/bT9Xnn2vpThfcTNuWUXtKoh8/OQ9DgBblGJ0U61Nep9/8 +42zo2Sv+ylGZ/hJ/k8ECFb4YhdtZ2DvZQq0MsfZCyu8j0WJ7YCfsFEznhZB1DMzd8fjuF2zs2gEB +asKjNoNmR/7zuuN5lzkcok4W9A4e+zWrgJ8PhwkIoGIBDkBaAybl+jRnsfR0S8RL9snr9JP0o9yG +9DJmf6MAcGdNX3NQOfjt+L31t6ndMHfh78vt+PYMdgQB1CDBH30OeTk90PdSzQHkpexRWuuGyzZZ +U0Sh0OE+d2ZY4WbifE3ESui1V6nl54Qs5pyJQpBONuDfSdouWzBnIOXOxWUb1Th7AGl1PtGGGAha +Ewtgr4ORyU+i28cblE5EV5U3yXCTFn8O349vjeJDQSOlesf367QJxwx672VaaziKv7rX/9MID4sV +4EA9K7HDMjIqnGl0m/ZxMAeRlvpISvy6Yl6wdHszCnMnewe0wgD+9CcRDxIqE3ZtrVgdeKPCwsxX +9f4E/nxhEUDlRIEdDr7qqKM2jjyxg5TUfSqMMoNOztmv5LDDZnBbE7cNf14vYKTneQD5wytp37eu +cIxGsF78iK90YuExmhIuUQo/Xemp8Mu3rc1j+K7K7HPzQ7Dh35ObJjCuDCXaWzyRNNmhfky19OQ5 +tyl+OaF/YYByyQGGpydTEuk8/R8tXyQRg9P7OkROIuX/hQEMeKxJP3M42gdAtejHbZiuzlgYdedI +u1rWk1ivfHz3PT4TAI1YyKzuNHa5yb6iu0hHtaf7eiQfflxoYzZ1+dazwi22ORw0+rOlFcL122Nm +v+Jb6OtJm+vJznx8vN3l1q+MOtvpHkw5sl2KT/4ktwkQSF0FYAF2gVb8pfvopGW73Q163Hx2Ik5e +3gSGDoEB0NbLr/c5e7S+D+ozWo1R3M936pI9vrGxDsXS2744b5vRDr4lVa8hzn2tlrSp+fynV3hI +yMuKkplyn+RkBf/jpgndfXMyinbgjvonKXy1HztDGko5W4+gljuV9LZ3fWt47NG628Nv63jjvc5N +8QBosnLIInCu+fXWrECnwC85LBpOr6TxQLYmNoCgh23Q/VmFRiv3nn4p2h6lrypUo7D3y7dr+Lnd +tiZ2oD4O+ENRRwn8s1cmte8+5A7OlTyrulh23MXkSRsbBQGwG1q5QcA9YDj3Q9x8xA9GqbgXUscY +OP603+HTyhLDzwLCoQBwOuUG1b/cC+VPlYYr2Mgqir94boaf4rSOA3rJI1GBUbSSDD9zvzSJKyo6 +45PQnrdHNU6qMggH/p0CQBrCshvvVIxsRc6OlZW0TXAwJfCxE0ZiaaGgU2G0vhqmIU8aWPng2sD2 +27frjJsITxhWyu9olFvkD7LKzIFWkYMjLne5mNXYCPwxmLOVPaRGeYYpRUdJjE8cfqBy+j9Bv72P +KN/V4Y+Hg5c8ZlZhwBunNcVcwAzchLS8o9qf7G7FZLaQ3y9uMLgRLPKq+d85oGDitcqrVQ2OXb87 +T/7p/xShyHRqd89XfA6kjTMcvBiwp4nDp9LJlLNjjpb5XpZcyHERj3vD+I5JEOpgswGIdLdjTY82 +Douojom5zPzidTvlsBIBINjYAxv3Zcun1dhDGg3LTb1XqWHvERePs2zBwwEdUvBcXEkpTFuM6u3V +q64V1Hn2dxg+72bANyTAJt4mQOEpwNsF1pLIY+Ea4PueEUy9hcVmssw+2cFp9TABHCbV3ZMrFlFF +tSM6w+6WimCcT+cRRWP8pNI1YW5pDyzJ+v1UsotfiksxR4i16Tff6Uvqb4QQr3cQx2Gpnartw2oZ +7g4y+/ReGu48PPqxd6sU/vLhAiHbrPA/WEQdbLXfbSVqCyuZ0Wh90Qn8TIx1KJD/DdpZ4KqsT+3R +0m0Rqpa2LVGnRIfr9OJva1tp4V8wGBowacwesroUCl6HmT9lvnva+AW30b3pRH0+cvzUjQ1I9GYC +5YK50u+j25s5Ey+2u+leOPXDd785fq7jBjSmNCtbvlLFVOUs76elqeUiF96g7uPRH4lDoVwTzE8H +CPrrHfZoPDNInBs5+M7jceWfwDda+IohDgGAo3F827SwK6uErs/5/fK83+qgfAvz33DQYnWWmajX +NxedVih+9TN4/gtPuMZh982QTghUFoIAcPhtYGBVUGzPvZM6x/bFrheP7nxfCiw8680tRH7mOXFC +TI8x6DSCjfgA7xbKkLt2QD8w7gtPW7siffX3R5fnVDh0Qv9HsnWr8HKERGRP9u6wQL3ZM3dteS5r +7srCjzwSIwPX9xZt9WKgfpHnc6OeuaNzq2Y851cDiDNgTFQTB2ckWEnmynrARuQtuXdi/z4fcbdW +n4vuo/ufy7njv2HDo0KV4jZBtdRt/qxp9Zo2+Nv3Z5LxImQfQpzNwvF9xXgk0BNV7Bfe0qKHLqev +6rmRfT82GdB+gdY5vUOYOM+akbh2iTujCgP51xSeT7I1jzlQMJ5Jy3vxVyVb175NsZAHRoD7oucT +davf2fyjDi/GKqRbP0p8IA5zArQPJ7X1lVgUGDr/XoP0hn/2662U1R7lj07U4yfsYODAHlhXdoVh +NXK0+/aTLtcEFcmE3NpyIPgVftY7Bos+nipYh8be7xOLo2oIsotf3f9YC9nio5WSoc0ZYOtCwlS/ +yHvkXs7SzuqZ8+NvDz3zWFAtwgOjjGlT0K8J3qf98rqjTxzM6imPP44IJdE3rVwKTiQGQ0kWjFJJ +6YEUPiXzQJ6kerfg0gQfhRNP0UOiWJS+re48FuK8NfBbiJhnehm8+iiVGgN+PiUWxhydQod0sHQy +gRTv5l/y8cz8SpcUo1sSnE1OjF2Z6sF/DLSBwxzpBEpVN5gZErLN64wNkZ8upNzldLMZXE4VQdLp +7rpLjMPGxGPNzLRf++vgMrFz6G0z8RxXF0tnuPzDvJR6xmP7PWJQLB0T7Be2dj7MrMAP+HLXeNqa +JsH+5Dnk7FGaLXwrOU34Hmg0C/imeG3JADUBfdItH6y8HsmKNf1Wy0099RJ+uPsiL1E8WqnBmoDm +Cw8kzx69UCc0NCwSIVJxkJlUYJkIHhjOP8fDItAzel/PjJJFr1syJVp/ET9lxsEECP5g6SMvIsw0 +1cK54/kitjmSakQauvbvsCaCgirsAy0a0T568YpjA26TD30fK8P+NOwzeD0Y+iSOMBgUGNIXnmUg +n2aYHr/yIVhzKfHwG3l8hXZNwFhctrK3h4o5xbzXrTHx7Gz++fGZZTus2PPmh2F8rySYOQhVJ3hR +mcDLeC9J786bq3tHohzNH9Sn4ztrMV4BqHTU2mpBiWjrt6ore+O1kWNIh6ZyjQ8JxSbt/W2Z+Knr +GJo1uwJquHYi+JcZnCJd7uU4w+c/4p/+E/Mkwc+XwsAIKV+a+UNkZC4VOykYaopUS1/45pPz4GdQ +YxjQHg1sXyg69+192cSN3FdM9I4vy9mFm1iXbML+j7Irj4fqX8PaI0IiRWTJGtl3WUrZUkr2ZDAY +2zAziBZZ2pA1a5ZQSkgqhCKSshQtdtJGWbJkSYg758xixjlTv/vP/dzbnecxc5bv9/2+7/M+Lxc0 +lCYzEbOPxIcRWLHIS8jHGHaDBF6GwvGHC9U+FwfHb3BkQbNd+NX9pB9ZQ0fxdfBrGP7uE8YTVUYO +lC0KT51xNw3h1OEIi9rXJwyt4VEzAf+EJfwbSOFsoTCv8pQt7OfQ+0j3pOpvhxqloGESNQUpewek +CQH1JilXC9CV6xx39brSOKsbK2imgvmYFuTyCJpi/TsdaSR73U7DSHqjt9dH9mO6wo8fcE90F4KW +mmlQYZDg0GeEG+FbiYu+bzpmZ7atwjNOzU9o7rB81A5olgueaulKRScMTZ12XWGur3T3nVXkYAer +C2/cfyQh/ST2T9LBmrw1TMjrwgOuv53O3X0WCZU+LaPw9FEAsQXC2QcuqvdYnZosySyVyRK0tgk9 +9Q8s5fEXoMi1c1vt9JtJ+mF8xif14N870sdmoWdRagpC6yv+HxBYfAyHwrqCRKmoDuaGdSPvtUd7 +GXLaaoPUD4+Z/1cioiIToOG0n3h89f58tkpm/EcpN4MSYzo3aOciDRoUYbhWWkdQ3bpz6WX26B/7 +r+ZfZ7UYnIAeE2hQgJUX0PjbEWUPsrmsa6p8p7puo/45fVc+hu7+qc8G/7rGJDYQv2mdufxK95xb +t95/jjx2ShurPPcTWh+lxhP+F1CmAuJaeSkpkMjsfSE6XLXw/ZlprETo8Hn9Y/fQ0H4RaiLigkOR +WQSIOh5fCPtpZ2a3w3aS6+6xmNXtnQPQ7hkqIhAWKn8Hh3gW8O5nbv3IivUdK6w0FGD2MPB34z/N +L/FHhP5G7Z6N745NrJrHtnbXHM+GfBqD8KWM/2vrT1j7i1mql83mi0c98Lft2b0nH4ohSrwJjfZk +IegleqYjJjjDxq6GS6HmhSrrjG1O3oLBAn3UlCsnKSbBfwMU9RoPkHqdeJptwVGy6RBqv06m2Cja +X2MXVEZHJCXlaXAIPyzx38DtSmrbiSsRhu9zXj9wv9cimPk44KAXdIsgSveWvBJCGdIsH8zHszz7 +feGn3tfIXflvW6DVOtJtJktHdVSenWuOijy4nbPhvW55quiRB2s+00aRhuwCSOse40Mta8/nS+NS +Sk+vvN83Wd6oShMJSprITRAUZTnkqIeH/ObVOYpm7NhGKcX7pVZ6cNeLwIKkbAX2vMnt3X67cuWQ +pVMd74eYm2lGnd5/Q4KnV+2uUZOb7vXeDjqWVhIeL1xyF6DJTfIet1THBbDnLIZGm2NdGXoSUzyF +VxmgttKXQEXry5dsQhqQQp52OWB9tE/wx5k23m+o2V/B9eEj0AZFEokLPgoBhXtoDMofUkpE1713 +87ZaafhlR/mKq4c5djyfUoKm38kafMCjDx9G+JHkrKqf6Eo0tQJyfCs5mcZMVDnN0hagsrYl/xC0 +q7cnsS0A7F4mpUcEd7u8tzymcV+1u0pzyFtYXO3K1QSaNMSLQXD1pPwyi6Nt7z3bbwxwiH0Sj6Nf +56nKlw9NsVOzgJdAXua9tf1ppkAO5TuTmxv9RAKEx6FN89RLpCdwU/GxlA9wwCEsl+BStYD1W9fZ +oni0oq2bUWiXw4x95GmYxQdCBWKtbPrLj3GeaH6frBcX2mU88F1hFFo/IS+wZKfnkro/L9KCkeV3 +nxlZxhbhlAfm2Gj/arIGDyblqf/lWuzknaQTO3OdFKWtfQ+YmS0KwxCRrLCoWglELJReLhwMf2ml +3PX+p6te5vFHKYN/wQJvIPgu44Dp6uSmubCh+c1fH0sksfVK9rNuWDiNuMkArc6TNTyAtSxx7SN8 +FyxxMcrp3sktZdn5Y+aWFVfHiBYqdZEN2i1Dpllyibki7R7a+815aLXtzsjr6Kqv0sr0f4ERc5JD +vxfPjHFFx6Y80P4RNZk28mm+B1qcW+oAAZOiJCyn00Xd0uobjwp4knfm+ATElvUwQOvwZCwhpw69 +byp9GnNnG/4Yr0uu1cjk8pE0O0sf9Q8WivdfOYTxI8pseFtoEl2dgvKKOw2No9CsBRmNDzAosPye +Fgofg0zWP9oqeHnt3m3ys0YFULEOGUvZIlXUYBcT9+mGzLmM5/rxvx5v51fxrf8bknKjo77ZVrPI +32NHSn7yBkplrBMZLo7mewQN28hMWPxbv/T9Px7fI/HsQkdTZl8W6mq8upqDSTg0j7CE9XRD4XDE +bOjJbzkGOxWnv003O6i2b+tNvC1qCz25LkFxCJw3lpSoA/Ar2AV0P2Ql9na9lhl0O3rlwt0rj6GH +pWV4e+J8C/2DLzlLd24/1VB57qn4CwUP17kLf3lNwDeOKKTDeWM8gNH2KPDnPzTCxM9/q+wpKEpk +2s8ux1ec+6oIwkNc5EArXMrR4aHj2xtOMarp6tlzdG2QU5D78KzfkBYYkigF/3whB2c2eyoy0kzj +xkkLyRXlF1RToDoxEgM4vwDI9REG4twq/bXHqvWF0ppxqfPrNldv17sGTeWToUsNyeBNr7do45IN +mXDSeyevZP7yoHOiLVQVScaCZmgE2xyHo0xK169stU4sfti1PplzILFsAapuoAKS7BsocpSFbBFf +3C2jymVMduyOsuEzeILy8v87CcrBjTJwBI7LVKXsnM3iW+Quo8aLD1R3MIbWmIw22kHbZqCMvgjU +UmsZwPO8rLd1htfePLW6/vj8R5Yyzs8oaK4YwgMgPcJ9+bs5p15uUGzomH2WPaPsGL+RJpIilYGP +ewmDB8hL8E2pEpaaKI0VMzVvp97GupakxvNCO7IgTFgJktKNnB5R6r4tvbJpUMgrCKuXcHKHquub +N9BEwhIRkPhyoLxN7+RHDfgWnyCM+s4sXt5g/qRAE/OMFt4BSW7fxOGXd6JPWfxr1yN5rnSF3HbN +7XsPzS/O3YiAKi/IDMRQhpTr02Yf2Z36y8hEv7bd6GSTBs+ZI9n7aYMJDxnZZwnyxIdsfHv2RdfJ +P2qGe6WfXsu7WCMXDW3eJrEBkiDKSwtsV27eWGKpRY8p99S23HpelId8v4hxZOaI0QhNKlJ5nSRs +AWueSAfKDQQpirorY9ib9Oisn/7P+PnZt7UVUCcGGnRgHQfj7YmjprwgZdYtsnWqylH5UYuge8bp +fPnnUAEBDUoqMzE9NSxjSU4hIuiq+GBJTsnTuSFFaDWBBhEx8UbcK866OQrNzkvenivAIcPC6+Wv +tiZCmy2ITH/xAhjOahhxL+6Jn0RY3Bx4yel/8so2aLc1kYbKQ2bJ+SGcpVzxgMjFY7PB0lmGrg0/ +mGMUob5CUApKeRXZRczl2tp4xumxP/krGq/ducO50WyPM7QeCOWieMlUbA2sQnXWeppbPTlwQ0Vs +jxfDBWgCioKBqDkjRJypXE8rn77hYKULSm1MSHxrc6+qC3pug4CB464T6FL5UvjV1nwMv1ifQ9DC +9ymrVZFXXkIL70Q84awgib8ABF/Rmds9pd0tW7bmJATyVyc9C+0WPQyNG0jYZfHWwm39K/pnrym7 +X+Pwtni08nQlD/fkf8GCGsHV6wsyCveUPpoqyWjaxLrpcQm76VtaYA/8SgBOh1w6e3L+knzrFe4S +xDzKJnu359mH7m04aG2OCAcO1+6Aroeg8aNU10m2+KIP/1GPa5l1LTins6jAtLMPmlaloAGWEYiC +Oiro2Fq/Tqnw55HOOY+2/rpXwesG9WNaRrJcmAuu9E8V2IQU4q72p35fgcjIvaezjx4qRF3GQ/yf +lLvfHouoZ8wBAkctp08zrMYIaecce8NFi+a/9ezTl23X7/66P/XH48WWX6e2PbLTfA219FvGSNGz +/0f6TqGeMg97fv31CzN2n2IeWtCr04YTTnfLV1pSp4R4bZElusGnsb0Om5zWsNa7fFMHtJT7Dy7K +sPn9VZs64U8/mdCKzQeeR5z0c9xL8ylcTke5apO+XsLHzO1H2w7oq2zwHm7okWFU2PASevD6D3yU +giE+0x8bOzrPln4R31eW1fz04kQbtMGCBiXVLvAYG1Ikx+rAkhHes4o1bK5ocZND/38lot4FpB5d +tHqBmxH/YLeImFqwts2MvQQV/dNgoii95h+qsLZJXtVgEPfux4DXw/bzi3VQHeKyBxw4P3g4INzQ +HoTfdPom+rLBhylWpgzJulvvEOmO3dDEMJECj6S0fLdl3e15QWRPzUYrt0d5YsnjYrFiUGsLIpT4 +5bGUU6OBGs+2sGd8zGVDNWV7V1xyzPmgvWIR2nVFpPD2IAZnpCANPDrJ77ApNOr4oHFxQWUo+KTJ +9ah2mis/TKqiTMSXbZPwHcUz135pF1meN7Pc5wRNFVLBgWwFFcXKGTSCmytiX3+V3+FrinwtZ6o0 +oL3/BArg446rGIZaBmK0inYeUS0dstfKcRmgg/k4UFhDuxLVF/zXqr3yXonsF3lXkVzemSQzIKUE +TYsCGKITDDFzj0EDbsA+Eo5IcMoWOMQZyC3dqG08cWRuaKRHI2hwfEZJdye/DlRI+i86quqC1JRK +j+0fYyW6H+rfBCaLh/NOM8OtT7QYqdO6hBCFUFlifhUfvWXROr4hu17jU5CPyTURaJH1P/Iu/f6U +7Qxx3oV8xxVEx5UNprpN9qcyQPOU/5EV/1bh0MR8X8UHFq2tCTscX/n6yBjabCx/aPICqiH4b7wg +38Zgg8cS+5jUHt9DHNzPMxYiKBXJ/H/yYakIkcVn3oc7T1z5ZvptpjjF/0yAxC1oqpo2IbmdAhhr +D/BlP9D9xqrVmxWeftGn0iw00kkqEtoh8G8+Ug3yXNxqtewx9Vmrsl+6sTIjLEniatCmB9p0VE/k +rLzz4i/WlUqvnhRn2dV+joitdrz5f3CRywrA50DC66miwVzmtdJnoqd7Gpra9vNU7YQ78JOy+0DN +mODuwpt4RdA9ZwsuKi8qOG1u+FZzwEgnLBAIrMHTOKGERT7/dcgHqXDl7B9kcN4yaWHR9EAIcQaa +36f0dVlabPSVeOp2Nb9V/Rl8+OnhLQJWH3yOQ5PZy9xcVhgUl0rmsTNVc86J2rjPx75l3ALVrIEY +wvkWXKF6xs9rBXEHZR/d/tLASX637iupdGjzLdYZ7e3msKzDIE8jc/cuw+1Sf0653NYJ7TzUf/4+ +DJJwnCUpEJdOs4wDIZfdVQZ/Xsg+4oK+vhqLOPEMZkcmosFSA5VbyrGwB+ZBxfk/L593kjnMcnMH +5ycBmDQHIV9HSrh9Fv/AtS/9c+duzewkb7GyMs/KUzAxOyTHZyvwpS6kT//Hx5APJfeLY3+WFeTA +RIAEGAaJwAK24RTyA/Drvl6/GHL9mva9fK+FZN3Ih7yYmnPQ9PLSbC+S5xJBbUXZ0H2x/Dl7sJrw +wbMLVT0qmceRa+gcoY4G5C4WogEJAkOKXsbZ2UtPfNE03MV8NLnCwTZZKKQZGkKSTWEo1PgMlpqX +BHl+Rqz8UMWpzKiqeaOCHdrwRfEsPhvr0377XDG8oWaOteB4NDZwAxfUeAT/HHpgKSeT46+fJ2Ce +4UBp+XrTmeG3uatfz+R+UaP+pzbVUacR0OZcKBWVT0EU4+EhsRbD+0HYx/Uiqyfrdq0Sgr6JJA9e +wmJClslQCDGtveMubLkcufVzwrfxnrXhd27n+UHFDhQupMveGCW68Aa3ypY9/mv6uE55nt98XjsO +6rS/zMS0je7r3voZy2bFjd9d62Uqh2N6ZaC5FWJgKYFw8AGkUoQgz32VapbLcVuTkifT7+4OYcVs +TQ2hSjMyklQCfhsfx79XvXB8UrEntzo7bNq7ayu0pYaEskN5IAhnaTqxuucO+TycgUeRaS/Ki1mx +YrugQnYSbKnZaG5wLHzXsSC5wUshdbeF3KTy+BCC/4CBJ+jzfLdzD8xJl/5ijLCKntDKvCzgDY3+ +SDgMkhR+LjW2fNs06HBKpWMl2u3kjNH8/NYNw/pQ32ESATn/vfQk/Ez33nQ5NeR2fUM1U5N/ptvZ +P58U/oUHT5hgyzoCaCkC3BMIGhqZD1ty/c1uHbFgbzMbY0JoOa22hCbhaZIRllRQd/WxuC4yT6VM +0oOXHYM7kBR8ThD6ktLiARkExpgwHeoRRmXSk7f8ViauyOuv0P5PDISSMvh9gNl0CIKW7LBPrHaU +2ZrIe957VDhdxNWC419C60N/pwN57iQ/zwyXeJGs5t9i4F+iGfJ+JhGax6XmAZV+l9fl2m5pmrtv +db3m/s1VpsFt66A6PWoY+HRtO6ipdJM57MyJ9eirX/McxtePKEPDNyD2IXgwAkV5olc8sUvcgzKz +P2gWO8J5d2qWp4dJIPhqj3jdTjpo1ws1G3jaL5Jmv6BzvSnkUT/mJYueAqLlGTQOWoKR57Y0V0sl +eJ1cfyKxPWNFh5V5wSfEHLRhcQkHxpqSFF93MTC5WzzE74HSESaMyZos1mT6KugxZwkPDASQwHp7 +gsIn8P8jRK+Uww00HGXXWbsMJ0wUHpAse6eapMCPCfkLJcnUa+fX4HD92WkJz8kmmcg3J2QWbW2h +picUMKKrTpfNt8j+oc+2CoEPF6qmOKXFRD2gwfwSDItEYAgmVOssXvi9W7yXS+f/4cub/NUiFSkV +0IEdvk6EdXlX//R04pTSpZ8Y1ltRZ1pUtKc1oO1p5LYZHMabdH4lH8JtUgTonhdeey5nc7F0z3MD +Nw4XMx5YhqVmADCW4I3qY7PqXxl83545+cj56/VVKSpQpRIxjACTfvhVj7gNXhodi/RxTOK56PlU +N8zSyieyag1UJUKAgqVG8G1oNQiyGNvEfgljK9KqdElm9jDCCuayLIFIhV0cRcpyRTLDTYadmgKm +1kKc0j3sUpvORv3tD4On85NvyvkcMTaJP/oXg8u2Z56he6tHA0LRIg8gU7bY7ppp1VlUzju1/k3p +j4fvRh2hFUlgfjrJiYzsItF751TM3Jk1dF+Yhyx2djwzVWwRgI5NAJAE4FIf1/P0qsD11aUT2P49 +7GK3Hol+El2EiLSAzx03WJt7nun8undxdd8jf0ePlZ/ZC+kwlCEOZgD+uzRYbMybaS/dxvDxVbqE +ouz9GcG++EDIJgmAPMFfr4G4cvql6tUCE4akEVvLow7SI9GQnhzg0zisD2G0e+68rNBRqRRzxcuN +nMcv0tt/0oekkWSIhWOwsRWYjoohxsb8P7yUrlis2f2gAZPXf55N6V2YFkQsLkMx7oFqWch9d9zg +lqWSJab0rIJ7UHmX+fQRyBFARgJ47j2BTlpvgumoTOpr203v4o6uc3h2UGi4K5kn/hcjDAq8NaR2 +VOfyvex/1oaVT6RPd5x9+/TBFIYDYlMlQzW+gWIXkfJ1DqhMVi28KeBZ8WrxzPQzUxOIzFwG/4p6 +2CPdJHydUW6kSAWUShDfvBqeqipjvS7Veo1S+YM72CVHG9ogW4oMfCuS8sLwyUPq+htrH2a4yB2O +67r3KdgSBuqGRHgAanVPQgAe/qS13V1WDakaaru6olDm4oTsc4jDhQzZ43ypnIvzxv9XN1Lc7LF6 +E/ctntu8ei+mNlZtD8jDWp+DZDvJLARBJSG3xld1gq69JJtRTmCr9s7SH1+zqxrgLhrJ1ZxcHfOU ++x1a7qyQGu2Ci1cXdWBwX9sP6cYg48A3hPLQfPo0wxmLV3m45KcJ9SyMd3ObsBBRHhnsgiXNw1z6 +62tqeOZYdLFx3m/KLHQN2bjuWptDygdkAnDHUwINBTMvdE3f2tn+c2WyKFvaokHt+vceEFn5Eg6D +QuMfMj9SQw6Fudh91q84dfvnWfFj/ZXXbCKLgtXnIJNqKHiA2X0oRz+ygSP5cG34fjLCMKzSKAPp +NYr4oE3Xa30PEt3S5gELKVoVX68VPXO8eH2TbT9vLQNPPAZSuqZkOOkHHhcJ/w4G2HpVX4UiUpsM +tkrgjpY8UxKxG4ScW2SWXpTl5sAUZ9bzRnHyf84mfZLO7OXIbWluYLV8B0lWQ5hINSLwkoDbpuHk +dqPwcxNDuJy7/fPMdwpyORkhY9WWaLA44tMBvUlPi+KM3wfJZN2cid2XIhGOcBI+BHGlIBNhAbsW +NFEbQSKjHOkKRgKP249IzGkd1kErci5s2vv2qaQARPpFwbj0CAHgzXRxRzLYA5872T/iChX7YFIq +pAPRKlKCDYE13Azl4YD2PUpcHiNUzX4wbnMd3L4yX8497+qvzHJGSMhHSWGEP7scBX+D3j6KK/w1 +wLl28eJkqKlaocD8h99Xn5omQNrYKGkAERYW5gLX8t08UUlnf4oZnfTlTe3Ny4LdqZAxLUs8zt44 +/E/xgOE567LtWNV7Bp3hna4xMgozjYMShRA5+BIPxNmHm/nmIdZnQtdUDM0H9tSdGPaJMYHZ20hw +qrUE5svEGqtGXV3NoGTdvcr73NeBxDXrLx+gyQY1uK1fy/3qRkjxBcvjbz+mlb205ayrgIghl+AE +h1vCLgKgnTJOd2WvClb2TKsP3rb527n3R2MhgxCWocGjBPbV1f6ReLuuMUlbP46U089ejXLQhBGH +eUN+uMfCvLnntxMjWocRTNWNDw76CPps+gfJ8rB1bOzR2CY9h/M3E/k5Cpq626R0dsjCUYCDOsAN +GOAhgp9et9a/krnN7JuYl4SINTaTfdxaDQaMdsdfakpv643N7XR7Tyhttfc/Wbzof4PVOXgjpNZC +xtG68AInR4V7swVT+HpeO0cwehtVbDkGEdSTSZbeJM5uJRP+GxHsKg+DFsR/FXj+OGoDqYYvwZY5 +R4IqKoCFWan/Lu+UNtMpDeVVTPLPz+xwo4foBGixgLf/Q8NmTM4npyNv/OnNjJOLh76/6foXntJE +0vensLmc9eKjrJpFvsUGcTbrF3cgM5PIeKIcnOLB4csXGBDPtrqbqDt5+/XbQ9Z7PL9CpFdkOCEI +WCbwf903eyD/wL7bHZNeGmxyjEYaBZWQsVQ0GCiK0DtE+jG3xrGmmlcrPBhigtTiPi9CeplpsRCP +pH0W6kM8byuCP54SiOIJaH6dxH0UYnhGg4Lclyn2OE39ht74SsV105uOS+/O/ozVhAw7o8WB8gQp +HCqKD4gnKEy9+HViJGPomVGq1HWIGxINCuoW7UrWc2bzBU1+2a2XiytXSLzZarQDkpugQURZe7Bj +6I8SzfIelhY7hdNJ0XVneGgP8SyGpwGrKxLZ26+qlbxtG1MJQ+S63JjteQFJdEDQy9XisYGP6or0 +zh98M7E9RCssqHryQjBERkqTBDR69vTGOlNKUGImrTe8++p5xWBLQ8i3h7zj0c3PSv4rI8Xuw2pS +nDrJrjuYlRTD74Z7GDnEdw/ieUKTBkOsYJ1uKJx8u4n+IOefsutKoZatR+6EQyoetEiWyuWE2gYS +S54+T1J8vA6vsGUMa3eXD8NeStx6MFBJ+uLR/4MeoFj1rGuXxyV6uq6tYkj1qfx9XiMTEBdeWhSU +Phk3JDT5T2ep/nTkN3M0LdIfQU6XZP1nHsBaluKF97WtDD9z912A6PWDO9ZIlA6wjdRAEh60uMgz +iMArR3E/5xNuMWt3mAqp9DMXSW+0OVfTKwHpef4XKRZsuEAQchX3xXmxq1dF8Es+YJGTfjkw5pGu +CcmO/YMQoInT1mhOjTB7toHuBn9d5YhZhX7Uhf9KQ70olAko5nexVOXSbzto0XkKm9RpfDTgPzNR +KeNtHW7GekjyBCa5ruvIakzyvdCbDJkM9ncmku6S6IXhJ0H0w/e9QOdr8/BEFdvEi/QvGzefMTS7 +S3tL+0/MYIZ3sZH1lbT3czah61N5AQbltcXf4MKrf7MCZB8GON7cHTW5bWjQLX54OxK5Q/EbJFlK +i4xycTWcu7uh8/eRbVK7EmLUjsublV7+A/GcocVDTog5PDgbyia57U+h4DexqtdvBXMKdU3+LxJC +RpDUGXS9Afm+soQ5sixS+W768Xjd+wdX/fi/6QCiQLPuih7m3YF7LDt11G8mJJ+xy4J0DtAgAstO +H8xRqmtu2R8VfLhYfvKGSXIj9i8/y5liRjf59ELKOYTwJSr5Bpu3JO7ff6JdxuHdKmnOg7SpqA4Z +JFEeuBVqHj7QLuRhNFGvFBeJaH+DSDeGOy5T0RCf6e+PVp+/gnxikem6idln1uBlPOc1yJzEZVDw +xX+szblxZuCpZscnTOClshm7Sz4QdQMZRozL/2LkTtCW4HmvVdggYt+U6DJmulu90jx6OJk5FDIP +5f/hBb2FAWJNs1F/lqLc2zJxBg+aeodSY6ctIW46/4F4KSnNvysi6fQchjeJ5+ELa25Z3/HjtZBO +PdqEAMObn+6nd5Q/5aoV3ppmb7yKr3rWIu8fDBQpcnIQYrIVO9X1vNbm+S+R24xlDLIiqZEQW3A4 +GipbrxDxsYHcxXsxbxbc6kuUWCOm126ECPKWkSzLmycP6tIlfr8aWqMw5bXZ30JzanOkFhwDIdlE +amYFBs8C1oP2COAh8MZ4SKAdQemrjkvGa5ZW4VWRWWtCkDLTkX9kcyD6Ypp0AEG5tiF2LDP/pMMO +/4yJjeklZkd/QNSfywnAjcgwwXF90JXLm9KrjsWwRLInzqhCep+XcBTtx4FYy+cSyoN0hrw6uU1G +D9JtfklDfIOWgDg3LGksJNEFTuvhCYPjSbyB/Fdeea/S8EZ7i1b8pokHY/pW0ZHtfzb6aD66M2p2 +/5PA7xY/2KCArCfM9KxqU+XK2MyqVho826LT8TGFF9KqJ0MeNkOV3AXgiRYLLE5ex5zWjmBHHSvn +dT4fPwe3UVHBid6/xEQWwCK8Qhdnt2Xd+lNPjOu10aKSmmt94aLKZSxk+JqOutwfD825c/qHazfX +7b2LRb2GOOiT4IQ/Tq37BjiEYpTnf1402iAnex7dsJq74MF6Roh+bYljOfrS5s9daZdEovRNmmRG +HmuvR3SaQryaSGjwTcGfOkBFhfi6lpDkZnVehf6v0fp8i7GH42FSGcvGuIjbfyq5nCz57El/9onJ +P7137StPQQQVMuQtgbAykPdfzdkvMlVhdwo7/NCHfvO3NfF5YyHmETKEHlxCqxpxCNOzGty9c5wz ++Q83yY7bMv3+biwlBCmeyVD34YO1o4ufDD7lG++i6/5ldY7jyWsDs0WYQwchPeOIAQzKSUcCJBp8 +5305ZBzyJs23DMviskvPbDgr5ugGc0jFv+Hg76QIQ/eGF6h+5TrJxcI7g9Suw83mYnogzTUyRFkU +GkO8tEa3uMebGW9Iqe/qODIZyGaOuHMbpqgCDONAOpDbBYgxEtmqdI/+mzi3KAOOh8O8K/VP8dg3 +yk7CVBzwCyUw1AFcsh0o50E84nDexDVGz38HedH52q9fh2vZSiEjiGSWD5IAI3lHFKHvrrNoi03s +t31PJuSDT785szXjQ68bxP4WwgAmxgvmX+7XjipZe/9wpv/mTvXVqHWscECcJwK/6TuQMq4A9K3S +UPgZrvHV/bY6yl6XQ7neqHLCHB6c0AhfBDlModQ0TNXeq0Nmhv0W73zf8LhdYmPmyw3pNPFoTwQe +SHo0DRJV1ynVBb9pqLj6k+G1WOTaHH+Y87ET4J/s6O22tEl6GJ87N33HS3tkXVNhHFvzVaOzIZCh +TTKQ4Rn7dRVq2z8b2O8/Jqtu0Jbwds9QK0xFB/hPrIQjscpOKPNClw3RcsE3TW+1JS92PMnq9crM +MVLdIfMvLnAF2BKUhAo9ZGh44+ps4dzNhxunJyGNETLgZkw120fs8OqdgddXnXrD3far5meA/z7o +/AUZclTjhsCSY1QUuAvWfv12ZS7oh+njFgXt+2zIJrUddBDZHBmPj7ZAAzyKHOSJTa5rGdL1ZBU5 +sImazz8xT1rchZgpkvHLDNST/LxvbI8YVJHTP3lq3f7NOnwDuyBD1eCwWAppWFO9m9T9Kw926Z/k +jHrz/Nl5q744iHwNz+EpQTJqJiXbnqKSL3NEH7398e6ZdIarVpXqDI2Q5kYZosKIKK8gPWO/P3wx +a+085fYdYVb6WH8v683dLhBPJ2ooxQm/KMWxfLW3lYcs88Uilfy0+2o3sBAHB2ow2U6Osi3rcflm +uYbh6NvNVn9+6dfcvbB/9W9IwyIVDZZcZCLa25G6Zx22Cjx1i5bdPPXq0MgpRj+fMHUzSGO4DIXv +9JImoGn+YkGKVlIFm06HYUaYwXGLVAaY0A30nSZ+BUDRRnEtjIdZr9nFPYvosZO8E/DLKmg06g5M +RAvopvHRCX6LxyzVUMCLgK0SOb6yL3tUmLEFGYXhTnWJ64NMRiDgSS8AuB2B2A3pM/PqFS6qeZbh +Jxp01knHMWXBvDigjxX8dTvgZmsW/JJ7RSS2Uva2OKtCZSIHzLmAQLC0pPaN2ViZJ765Jff1iW3y +ykX0ue5siHeGDKVfSayLkFHS+r0/zxbaP1Gna5UUrP51HQaAwtohnRE+oL0rIAsBMvQYtBshMQy+ +baXXWxoCh1veN85FI27Fb2ttd0LDBAm0iMDzMLM/D3Py4umTr9b1oH/+Uru++jdEmErNQHp0TwJw +yae/VL8XFAtt/ZHvZuF8s4SObwGiXwTh9hLeOMLslLdaLrOFL63M6nRDHxjxvWm8eF0eIsgFIcCP +lPDEIr0d0BSL46J+n5a2+munfVG32zZwc7xn3mAFGWsjQ9Nq42RLeHdRI/dajXtXmcbTvr8/aroe +QwNNSr1hEKAM2ksYe7Q75Pb8LsNNHC4h1irc7cUQP2kZSLOoYvJx21W3vIROfxusfBCT++2Lf3YH +DRTpkhqyn9n4YdhLNf1SomJb4YrWFb4YiKCICFlWegTt/IBpSYQxGNENw64Sdd78hnkj3TkROZce +2uXCaCI80BLuS5VpEMj08AyTyKj6I8Ukvjhft91PYz+VQlwjQaAv/uBHSjxRDWalF9XYGXJjtPET +9lDpran4ppkHP2DqT2gPT2K9yJqbbbj2/W3mPUP96lw+2mlD71bCXFxSZZ/S+t3ODY3ftpduMIOQ +Tk1jHd/2Ap7ubBmVl2uyatbAhL+UTMRDBlVol6RaWPKg94faqQ0fvl8s+lAb0NUCmTcoA+1GJcce +zPkv6+2Tm46Mib+yOet19ztv/AJMGvMv3azobZ8ubedvr/TJ/SyXHC3EE/CeByKixxNgUE6EdL/r +G6FUF7NikZhjM8Vn1zjLttd+hqkxU3t38mDOsR64Nc2gMZ/et2bxp1PavnQY7QGAwW8S5EZ5/HKP +dUa4gt8yZcRCSCA016q8S//Nl74ruOaXYjDlek+y0S9Q9MffOE+St6mtQNH0I+TPjRL2b5VtESvd +m7mPwxTHQLy3BxYNDjIDditCcGWpIsR9L7Gwnc84mN3K6/iD2QwkTGEcNB8FDKcdyMWwoWtcpuGc +V174obhitu99tIs+cQPMYZ/06ca9G1TTUFkeNw9Mi5TUNMw8aOGB2O3KAJ4e7ghQwUUOKXqlakQ5 +w1CmXHexZaEl07oN301b4IBETZC9nz0+HgCAp7wFeYKedPY6t9osRPNG+6Q+egmxGKEAko3sZDgO +dHvrBhYoX4qbKh3KY9lVeAL2m+KjcifgpEraBEnrBykJb27N9+Be6eUP2U/XNu7rE3ldHSkCU5yj +cOCjsiiYxQmtuS6WLKT3am8or/Xo5ypJTZgAYJl/362Az13GFnaSBdcNVw3KbXCtVFoB8SOWIXnj +0TTMG3rPdTHKc5HRfH5U/w294dr0sjiY89RSGyClpR/V+oX4sJmR33hfwguB1k96tnmMk3lHYE7D +FP2EhEQ12UNbr/D4vKcsJkMqX1PMe+feugy5BpggBrTtQ2OIzS6FL6292tN2tW2KOGqw54rQHjvH +Nkd4DFlbTO33bT2yMzTdTNx9oPmN3Av+lx47mZJh5J/ggOAlS9xMes8LO6Lrh+U5XtWKZd1xEq9u +hMmYEX4hPtQCFBYyUnJgkb4eabcxyy6VrW7UqrlZ+GeDXBJkrtgypCwBaZa3Pse8L2mLnN0FzPA+ +cXaRp/IwNWQqpBwB2XfCgLmYPzY7JV3a4PW99nGN1ycgIzSWIQlpT/ACI8TLRU+KF1uMBL95cqsd +4SIrCmkhXQYmNmOhwIeir7np+7nqPw3rHzl8EGtv4w55/xXm+AqDB5cgtKMjMWtP17nvuEfHlckK +9auXGPdII367r4M4T8HxEG6ynODPx3Ihyjba74+ptxSHJSeawezNVGBHB8qz3VmzQSOdt7kajT6m +KoJjOezNN2HWiOV4YqgNEPwpf1Mj/Vm4OCIgw0XUpr5g/ttpmAPCcgJSgK3zie88XajOh8yEhTnu +rOca+03rYLSpy9EYhAehQiZafNmF+2jpHwFTv8yjAg1d6uFNMBm1ZXAAeE+azjhM9UWBk4LGtYEQ +DZcjfj0w+VlqIP4/QE0LoeX+1NwX08WYjAljVWt5G89FBRs9iDPsMgJAHgAWG/xZjzD45XGat7TE +5l55uyJ34SBk1OAyKPkH3zyvU+37WN6/6fqTIY5nAr+8b8bBBCJUWDAxTdq8JsYO1LAjGp62mRxI +YbycL+HJFQBTo6LEAyhultcP5dcJCMu/cys76fm7US84ESZtQUIBZuXEDE8c5slin57wTeaPCZO3 +vUYe6F6oG6cNBL8p8SUlq5BBHRbAxZVbKmZTY/1RZFK82yumGze/fgYmPIE3d/vNIuRpoJ6wPTxx +Nevq6wqvs869gkyakwFScVgUDuVDVRWns/VslT2tZzBfbvzpwGRMtMQBVmlYKI4ShalcGzriMtC6 +e+XqqZtn6TsF75yHEQ6AMRT5Kud/Hdz0PFiCMXVm/IRHaVl3wEAmjACFln3bgaBPklpnhJ8+Tnza +eQajVJ7IqQ9z9KOy+6LsYvv6SvD1joSgnWVvBhl3N2doByXsh9kq/+ZjBrCY5hwSvnB/Y4fdE/XP +m8QMVBL0vSGORmSWpUUoLrX71YvqUOuwXa89LgSWeNwbdYJ5vkgRJw6Qei9lh7ahUqSvFl0rKUl3 +La2Ibmo8/Li5jiYYeAeBqwZslwRPXbdohwQhjfaqZ7vNzT548vMlvYPZ7yjRxEMW4dsDxUnwJ1zV +kRk2VjY/zjM/eubnbKAAd1kAxDwJlodUx350dnGW4cFGgY93q4cSP91YcRT1DmJzBUcAVg1L42cd +JBebGzyqWX4cMSga/FIH8WsjYzGO9hLK0tKyFJfw7kiy9M2bknunJZGNOW+a18/d7pj6N36p8h3F +9Y6vQu+S+Jhy1dxr80ZF5h+aMEkDEh7/D0RtKPHFByhajF9s4rU6/d1wqO4CT7qupZ5YC8zBmIJi +6denK772OiBwdEenWteTVq+rbQ9dK2FKWST7E+oYF8AXZPXIJnbdLg/3zNGaPdJXOpAYAKMppcaT +9fUzfS5fPp21me8TvmvhLv+ep8m3EUbpTAbjKMpBqdlo4QiR6pgJQ99V/PpBQ1dkYmFEkUtQGLl2 +ZMO1VKbAe/bSW4tN6aXp21G4VohTOiUFqZ8bmJBF8fI3y+9wKnmysiVo+2PDM1PntzowM8GucQSa +ZTJriptY6Ozl/lV4S+9J1wHRrz5D34o7z8M0LSzngQr0LXdli7lFSHMrKA/zfO0tThqOdIGY/UF5 +MEgHbw8HBOGRZt56rTWUU1HxjKBS4CW5y4ZPmi1hNA0kCoji2yhZw/KB99N6ubSEti2BzBE35L/B +1AWXLHUwOG/wBFun/2QX/48ujm/H70dvO1ApYnf/AaQpnwIHrgAwj6SRyUZpPUfnkT8H1jFMlTyc +LHX+CJPUorblAW+AsY1XaN9WnYSXct/XqPYJyPntxNLEeXu4AnN9qRqxwiNC3WOfFCu9kHqpOWy7 +3nmVyxOY0spSKwMS4eHtCSSaPJwoCz1gqGGGTrd4XIkosd5y1DPtlu9JBJMRbSonewq9Nn73tnfG +303iGh0f++HNaQbOyp9D33/e2jXf1XeRF0Z+T2aC1Iu2GN1T7O57OJYSUbZFfeCu/E31NpgaBAlP +mcn9bcxt8CHe7ovRdI/UL5lQMR2/n5BuYwok8X7iiLo8xO6h8PHP9eNVZ0Yyc2p2dGJxXrm00RS3 +sarzVYOOjUhSPNu9L40fPN6n1blAeq+XgECXNVhyNdBqaajOXvlqbadXrg0iVaM5QBUmJiVnXmBS +KKcv/jkQ2a57TPXudavNehMl1hv5YcLiv8ugSg5fMrE9rPXNbcWrU4XCacxNvFfhFhNwJhk5YbDk +KEW1OxtldwY7SWkyJo6v3pcVfDvmq24ApDH2L1wAhUJ+uKpWulH87kcjO8RsVaUrgjAwDVnEFYD8 +yLSHs9zl7LdTTizUKK3P1LrydW4fZIA8GUVoeiKcDTBAfRgYbA+w3O6t/Ogv2BcdmCgY335UU7Dq +ZiCMopLCm4TyYJWz9sXatrY+t4KJ4qZ3q9icQ5TrYHIGy4xN3jmIHxrjC6jJNx6TSOPnttvw+BhM +owvVrQNgl2963T87zy95/ucp+tcvropzfkyH6RJbll4G80xLJfjIhrIKtYHVjS7f2G4r3DfrCG4b +htHdEjkIuZalJq9lMihvOaexmRAleokJoe/imvNT8gLZMBVHkh8ZgKgMEUkbFe5U6WFcVfVEm+2r +32IApK1YBhTq4J8vCh2M9vPwUCN6748T6bvkElam+q9p/wrT3YZDo4l1NooYX3Ihf8PoqoWx7Xm/ +ZbW5VI54+F23gIeC5TEK5K+zPn5tGrUfz4SsQY2H5juKZayCyQSSkZQrUudxc6SfWLDycJgNX/OI +6pVtYUgY3eQSdCmHzbfPqSgOUxOP1cxDsqEWuGVEdA/BIEnpe1LvNkXTGvjVXyidvcd2DhMQNbDT +nuf7oVZPRTHaLADCXSNh+KHEohu/Mb/f58wF0cYtUTDFUG8POzR+96Z6pQA0rn4Fap/LHO8xLjtr +1xbe0gkJ018waE8HQgJz6UIlFmb5MSoGdp25F/G9u/XKnNeuCZhKFFCEIo6VkiBO5KEoMIEphhoe +f8vggS8DDoyf1SrfJKWryx35Kw/411nqs3mbneIiRLoM0D+Kzodwu/TDPFYgirhzkiNKycNMzIrN +wQhDzEyJsDpiINdXAmLGKIM/KwNxIFm60nxXV4FnUlw22bgroeKzyIaytj6YsyMRRLxalKY+Wrqh +v+9FNjFpbK2SFdtDp3XIvlseBg+1IBi+Nbbx1ucYge1hHkd61zWas1WvWaAFXN7MNWjB6nMDY+z3 +y0Hh9YeLqDu6C5UQ+wISlqjwJz+XkIbdytTvv0W3bim0k9Y7wN4q8cBFPBum4kHZ6790j7dsCGNm +53sQ7fhEjvuewpbhP7vpYBrfYX0CNhz2OiqVUbNz1USn6BbbNA125BWI6yyWkMQgVlmJdtKtyd93 +7S7oWZg4EnNUZoq11v1gJqQZDUsw4yHAJajxsdiG1r6IpByWJpbOzwMV0R0jiZAlkox3IMweR7hR +iljoGEvfNVeHRKKd4nL29PHuelevi6TFANjm4DDe9jjCM4pid70+fXBAqfhUxqbVeUrvfV6fgxh+ +kaFE9R91omDA6YBbmIpCEHOw6rtxIcd7mhcgzhwkAmJAQF6LMEhiH9SDZpkAi8L8HyUOr/NtFesP +9oTMQ6RLJBInJA4o+gCwiPzz4tunur2tkpNsE5KObfr4IQ3S40qCEcIaElLCMN7jrt9mD6mQVWtM +e/IXT2s1jdFGEr4t0gdF/tUfhKM+NmftPo2OEdmLS7bb2z4nDjnxLcejPCgMABJRR2+m97eWX362 +X2y3SONwoW4j3NNGRUC+XM9LSsIiVmK4/RlYvgrUpHXeKuOFpNnJYA8UAHGm/6mYOSdZFTgem72Y +IsWbxqxHG0IYBUZO7bJrpsp2tbtIZOikpj/ewjpcPCQISSqQsGAIS6FIz0vITXy/4+Wjc21/mBAn ++/ScV9yFtBNhl5yqvlR9phv4cEIUfa93V5Ms744tC55wHyfpyNGOhIeSuAx9bL48w8rCY43OvvGF +md0xWPbe6BkYNNm5whHhjnID1xwzuZY7Z2Il5MrQGLE7kbal7rMPIAJ3LJWZBIA6YqysopzXejjA +nv4gbiI53X4jVFKDJUt2gRbOo+BTqAcOnSP0mXBmV/E1mAh0P2cq3dcc1h7/MeAp5GBC5gDkioDL +DR43F31j/FtDqGR8hAbPNJflaWUJf0hekowjGygS/RXJ1/si7tup0uOKu/IfGxfZxhRMa41eh8zv +IrMstcBqY3KZtrk/MWxBPOHS3hSJmMLNQQouFDAPpBMah0IQRwu4o0AOTLRPSdUdPnchAQ6ll7fD +P4aEPYZEmRQcJIvZy6s/a517IHpV18Q3KKB9FrfizG9IjodiZpYoi8HP3+KtnkKXBeJSLr49JfNd +CRJlkSd8kWVnSw8G8pWFtAbLNa/g0WMJ65xR2qErueZp4oFyNg4N/huA3Wr5LuK9vnSg7a82qeLz +XPQsefGQUyN2qbHv+KnfWAfzqNheb7N7OwdQIhZe6RD7MSwgygUPJkg0mDK7P34Sech94NPoRdfp +EuWCpIxRU4iRCBbSTgyuJBLA8RrgaPTe51ty6VmHtrPgem4vNmFVfhSkbIW/JmiEIxYLPnutPQP+ +Wp0pO8+Lq8ZmNw2YJHgLVEIBFNO1wF1Kxu6qqBTngzx0oBVfZOI+iZ5+B4i7Eh7lC/6ujvZA6wdr +ftMluNKLTFiZqwkyDUJ0JkD/B1HJTnSLIscTAIUVX12clFNrnO1I1dqSm6K8trk6kB4aLJUdPzBg +gVK218R/IzNwGw/6cvbnhzIdf951pvrB7MyggQ7pybFDeVAMAzP72rPm4MnXRkhUj+W7OqOt4+bK +kOCRmgBAPdFJnd5cNJJWf+KClFaK6um3MTsg054otTJg7LjsxyuLcsT71evmGVbVGFzs0zi2Wt/D +6W8cwDPsTVgTuvb4hsqJTVy6kTuhUqaasd8vaxCipMKSc312aDToUkPuUJ9dmYF8xMyiPbNHxtoV +e24nt/OfzVC4pyMoiVJjuC2uXvG20lDM6nyf0IGUba98IAkd7LIBhqA1G+VkrzVSI6vkr/B82dco +6+X3/GfELtkRSMfFchIag1LHn364XBbnn6G9+UP8ipdKXT8CZSBGRMupyMIZqi+1czuby2x21evz +J7XrG1ujkzg22sCsz3+fuVq+8crYYLyXSBSzs4rA5ozidrOXkCTgcg7QiN8THFpCevfA+ZfbCstX +3xsIeu8ubuFp+3SjHNtziA4LSkV7fmvG58dbzS/tCTI68fihkXgcwxk/Cchs2n/xkZ2GX1ToSb8y +M7yazPZDaIKz7Y37J0h+kSbXsgmu21eVKv9+lMSi+Uh0n9sxNuF7E6cL/isXkFOg/I1rTXy6P2PP +3R4uX/lIN8Bve06JDqTWSIuL9NssBM69kD+3OfmJiXzG09C0IIuaU5BhUhAO0ijX6rLhGflwy7Qn +u3z93Pf8/KJ6UQFicbUcvHyWa4pedVLtz/itRTIHmLVZr5zkc0yEHPOXc1B5N385wcL3/VGDzpc1 +5dXJeY9N12ulQSStywngZ4yqMXq0jsqyjz7wr5aovPq5naF3M8T0ZzkTwbqKbF9LCFwAMrri2N9Z +uufSfHGV4nGolacStz+EaGL+TgbSYI7F8Rt3rlgn/Jh1tuWSUNvInTWQNP8yGsKrqd64ryNmN2L9 +GFcJt836fbxvz0MmhGOXlizKsZqpL+muVjDt6rYMUjgoHnKWI2PRfZo2dNkkwvM2LAIudYUqZ90z +pLk0Q+NdzjFCqiGA7tDNERhDiARr+K5IP3sgnYH/B7BehEEQ5AuOpz6qm7+er5VB66wrfiGbpbY9 +HqLnImsYIWXq2KIGXHknq8V5idX3L8g4Pj7n3wupWJHRVNO6bi7m/6oLx7hN2gRNrHDaPpVzaxYi +CVuGhBnX9d0Hw4ugd7gleYXj8bnBz8Zfmc5DrESWsZCmYqVUOpXi1qp3IKr4RYJjeTb1mt6ANOYu +Qf82zOpXtN6oZ05uTISUzZ+wCsfOgN0KkFQcmWnZKCJQNaNzVlnbWDiH84nJWvoV+3f33eGC9DyT +8X+btVKb/mGN7wW5dwk7UxKMQ51ibeUMIX6CECIYeaqeqfTqts33a+uVO0J0dee+PI+POEyTZ9ks +DDAVUfZyUDl6Nt6d3nxT2Ltpk1S38lA4PJw/+qdHsohtvIhTnxmbt6zVlTxhTW8Ah0UB2xvw+Xum +YtwdgbhMPtTb0j1D8bqbtCIuwXyeOHxrKV3ykMWk5c56wWDtuZ6NojqfzN4Wb4b4jGPB7BbhtHOL +z1kk1aSc2+LLmlB/XkaTjHFtyOgzqrvaPi7ShTn64PoTJymU62jx9yNKNpB2DyzgH+phTywwVfxQ +eHV6/Va1Skwryy92z3OChd8g1ToslQs18IpLEN5xMJ+ADLhmXyX5sbtiOrIjnq2mR6OMavIGyt4b +sNIHn7nShdtd7S97bTp4xUf6dnd23RzYtfyjnt4efqRKhOj3yGvJdnaW5xPHNim0tX/ujA0QWP55 +QirQF+VA0Gprjvprv1rjclVaogf9JfW1yVB1dd5yCOjuTfobF4/HGbjlBjbtbkgsyT8U4+VF50Kl +pMIH+uAJhmRKC5yAPPDYExS3dU256i7ta8JfdogzG3TjVMsO2NJLwnCgMUvdvkBuHR+I4JwxRO1G +zL7bJ/gKLU2Vt28wGLo2JPRz9UA4PIczAkvxvxzx8Qf4Q0xvrl5fHpGxnTPGVvSebZTaqrgGQ3gC +tCcwXg84mRNfYdmpDfMaR2sWajqi+a1CmVcLtetJ/AUKXgdgxo4T8EZTZIAzimo1a6qunPL78fvC +lhle1/Fh5ChtHrBYKNa9GRc6iZu5kDY9cCxmseuH10p4BBaHxj+H+E2EJHVKe5peeDz24QMRUZtx +lZvbWqSzxDjgob6AHha/+jm6IQiSXPDVKgooZ5BXVb+cXhXa0c9ic+C4av0yOA4w4SR0olqGmUec +2TD6i/Ht3KT02bwpyf58J+pP44AUnxtxswKbRE7iiF2tSA9yMZI7aVHbODWiRXaLz8/Z7rbfZtHC +r2B5HMEHS3v1Zcbe4x97g98/Se+N8vv8ZNCCAfbj7mig0g0uiyiCsanKys/WzdvYFaxc+daN42oq +ZcbehcJCQctl4PBITGVdrLpnfR7TWGklrtA07hVwlC7aowwWiI8P7EkHTyKW/ssES3xQHsLmzL2Z +jJkd77P6+lfAYolLCTjtEYO0RxIt7b/16160ZbY4GLGgst/FWmrS87C84D/xWKL5j1bv+SmGa5zP +mO8rX4xu0/Tbqax1FBZMUWjZi/HzJMirszMQTDouRzaqKJp2q61QDEecRQbRRjshcXv19h0BN+Ie +NdarxZmzWkLG2eUlM7w99uHbaAOdkW6exKzEioHUI9pMmrWKq1bb6t/IGfD9JPSWNhCFxT+RKPyJ +A7/2EO42SNIx8srGoGnztxv7RSXFJDrFDJzseWiTeAAGDW74MztprgFAwXHyXCti0XBROUtjcF/s +pU2HXj7F0KZA2wGpOPBv49ZGGJqdatXqWfuxlZvtsHYPr3k0baAvPnDBH3iRGPzfBm/2xte/TW/o +P9x+h8G3+sZiwe64wrpAWDixGI9eqssj0R7EF1O1wdXzEv2ZzLNb7Pg9DO69GhAcpv+vJJ5EVeiN +OvErj3NEO9uPj/RunwqIS7+Q3Q7L4Yu0wwdyRDdg/DPojSH8krQjEmdOhXo8F1URyUd+KN1f01GU +9jcC/PIATFbAoVGEvIfhDpnuYJM3br2L8anzzLPnOZkFGP+CBzM16x3O61WcbB3yDtu659XVGDl/ +p6ZlEPxvVtLGby+ueng0glh12XnGVcwnKtiyuE2261B5/jbOMIPZ5Tjgc7uurJ3USZk8G8G+MjX3 +G8No1OZRqtfBFeWGfwuRTmCPBn6dQyLtsOBb+OkUHY6r445fuXJbfZ2dfdUNAwUq9QChXg8osB2Q +OAQg0cH/TWckhpCaFYvwHPutLVUnW6I4dKRLRb1+4qPL39FgRjrHhXX35XvaBz5bn/790dhyt+z6 +jfAopB3CAXxu5NnpKkQExx2+1Rz3/8LY+ouhOoSq290dYY/GSiA8PSWwCA8HOzSYM7LNd3rQpRj1 ++PXQDuO9xs0L9R9D86lBOGdAZ+1AyJBWZsmeCHjepTR7FZ20M9GpJaO57A7VxwmNot6gAxTSnbSx +rSncNMC56o36PY2mclb9y0iDlh8/qGFg7G3vjADOlADiUEzMwTuHdS2vHzmfuzaqbMWe3i8uMAiC +2MIO+ILknNmWnyXrG02xrhmydejbvENrdFnuUj0P7ih7DBqHwLpK4ANubyRh28eQlTGoliNHM4/E +aWMCJ9z2PzetQHA/7P0bHB94SqDc3ZEOKGL4aYaNTlJtRHbeOcCR7fRI8FewJGfOPwjA+kdgwyE1 +ybeDgrNPGyYygkJOH95sQA3D77sIT7AAJSUsaZl9cKqvd+4pu1n2mpaJOy2ikM/6OiNwvuByWMzj +bsdQIn/JQS5076Bv+h3GRyxUsb070BwIDp0m1mSBUBjhRhmFC+56QK9o+gkZIiW0Xe5El8rh+4JB +1BTgbm3njXLDETLwSgltPE371ggV0/+xYjlYyxc17tELg7AHHnlwk45WwzTme37w8+ShK6mUaZxA +qB6F+7wzys0BQwi1Pr/TNZqTkPWNduR1EZNfuTbv+CwDHASFsfd2QwBuc56Ad46HvR+lfXLoD2X8 +4TmW/5hqHurBZckxjtvyB/7GgvVzd0N5EOr839vXavZu2KJpbnNE7ekRpz/bT5xOgcMSir3EWIbQ +lQrUvwCK3zXFcsefp9XvOPGua9Eqpnhe9t3IPynAh2Dot+MRZaZorpmgK2UbhhUHXikrwQAJVSrA +JhcLRvkkw9waPT5U/tnAFWPuJzV+NcTdPf6i+xAMHIXVXrqntwItr8xzcyYVMfX2tyCEPNf0Np+G +wQAer8CRGv/H8JEQgugX22hy7dZbvdZsq/PfNV0m1Tkf0Es9+QuYnPeXi7/BcnAsakth0Wo11uPH +ij5teK4JgwMPH6A7EljfdUOjXQniU/O2CPrCrWknvgaKJ9C7yO4SjhyopoUHks7gHrxx8m3LlvCr +qJGJzBqLT1b9ZtFoWhhPYmss+cEgs2yfbniInNwb/5FemD674UblXJQP3OUidGGTvzrBU9VyFaPZ +9zsnThc2PJ61O7PC320YAwNdCp3AGwwgeeTNgz5OtCEVzVRNlLk5CtLvST6DQXoiMARnecItIi5+ +IX/Mx5r5hPXMFBMr2e4bNH9fEdRFGwwIi0ATRyoOpfdDC52cteV5uOr06lda43cP3jCH4wD0tYCn +Bv7348jg5s1xurbMjL7YfXVPIzICVlvZm7DBgIEjJhDlA5D89MozfOUNR0XomTMtozTo48ylF2Ah ++LMSUJlaejJ8CsRVpao/ms9u9YsWSRyQ+3y0QBYOiV/hwTvtjvZwRfoBltOEeSh145dziy/xXelM +dbirI8p6jzVR/iQMHhAjAh9nKNaI6I3D7n0k991+boXLhw8OfelwHyc8RkAnLhIYjrwUGc+tvJ1z +8LjjwInHg+fua/kpPbw/9BSGwAeY60C4nAxhgsK13x/q3na3EjBbKxhhrPbeHwbhi0GAF0QBu+7r +rZhjdrVenztnPrzkfz69E24NBj7uSUgzKfe3yU2OodIv2I3Nd52VtY7BtVItnh74Iw3CnnCoWlbw +77RvjXRrZbMTTbbhYZh8Y+F0Sa0cAqUWQGrtifROkhjgP3v47Z8PHc+/7ZW9+gsCIcwGQbg5ko/k +L2ZEcy58PbBRwc30iGa/kL5zIXY1BLZMyCCBwH9Pd08c5aw4Yt4LrGZuORsf/q3zMqcoc2VPaOBe +vh3PnvzflMR+4CUHv5P8PnHC668zv/r5rr/cTGYxJi5C/Z+s9mh3d4KpNJLiC5rY+W9y/FGwUhKh +h8yzbpdk8adv+icVaUApkA98yFuy6szuLduiXkSM/dk/fu2l28F/4lGePnKOKAwhHfFbf6xjZCiw +arqRf/cw6vzsjQMdbv9iAHDMndUqaI/krMo9PKa+3Pfaa1PC2pbj7AgrD6FxlBgLkrwVyJbwK8ck +knWFpkaEnNC/bacZXlXfuH77/yECOO5sz3xvJ9+yplaXsePkyi554/sWV/4bB+lbxN78Epm34/zp +4dvjygn3m5l/yMRp/EcGcGIUGkuWaKnV9V2+qCxcUcJUJzPXf4jJc7/pJggVeeJc00V2re3MAU4x +iaVGDjUYztZARBHMpx0kcL4owqFvKpEz43tWCJOY/tgXEY0UTIKl4BEIAnCSIGWcoriSD86dWtmc +aaDumnKsLXfO/xgaAqAaNIPZ2cYwwXk94IHk1W92gqHIxbs5UxAEsFBIkLKILai2kFWfWuxeNMms +v2J8W6zgRfQXeASwzoLrpOYs23v2hW2vtMoFdWqiJdmrrnw7BA8hDbMBVcwA1C8nYdhSafzukVVf +Nz6d1lyRiECuWw61R3gQ+8MpAuQXknMnZFMSi8S/CJrezlJP5WBiOgsBArErOclESpyCVAAFf9jt +H2bzjedivZz5Xvjp0ic9GRyCUBAkPNT3rf5s0cp2q5vbx7R0Ix/tF6jYJvF2HwRIUuXAiCZTdqY8 +m9/Fvn2dFr/p85n9TaFjSoo08ct9mx0TmiJkZr6uOuGwle1aysP+vP6dgbTAS/OgcGkjxkmrp9r0 +G8TubrIQkpEWHN77dxQ4NCVWWuvxRXHLzh/7VrC6bRTd5bczJJUWDBDkkjsYlqTtl45xXl7YqSY5 +rDCorIzUWbdw2AKycpMpvLE4tDsxYsAHWx7E3DxJ2wRWEds3yTQIGtWHsszLOe8RwIb3Hdb9TIuQ +4rph/5Re+l0fnMDPtls30i0sZ/xAzWZaMPL5kpJA7Wa4vOu+Ny+3T2zpZi476+man9nybwKCYhhM +3NbMHjL69v7A40n3OK3co9Mmp779poX3QANlV/A5jxsN8Cgrvh0WpyG310XYd0PJYcgasYQiO386 +s3xR/lxco6KpkJPwfFCXa3Oh2nVaMFJFDdzJgY2ctI8Ljef1SdIXPx/cpHZ58lpcqH3q8LZ/kVC0 +jhx9fbm+7k79prQF1t5Pew5VDrb63/8nHJAP4LFsSiy4sv0lxvNjr4Qs4zf5cFiGaf4LS9oBhtZe +eO/uEZX1YrBtjd9jCdxZ7gSaTxwZS0zkFe8e0DmprVv6MiPNLV4ioJlDIG2MFpZgeLVMUnyOq4x7 +6n7FkYKkqEhPm7i7RWOvIAsu1UoEfcMvf7XgTy58EsD56cHbL3m9JuqTra//TkE95IRw/NteXRoY +/Fr69CHT2bOz/jinLZn3aV59Aou3B5BkpSJJEYwdLFiTqBgpYrn1xx/9VoaJLzZ/JQFAvHvOueRc +w22eZp5PLfdgSik+5/diOWjpqAqcarAo4EyG8MAv7lggevUk7Cs97sPdr4010lOCNnxWGnrnZ1B3 +JAZCBFS2KZcNMIP4dWduc8WjpAHWak2DtSpyJjEekA3JgdTrCW6TMqMsQw+PqZmF3Tj3TMokU7Rg +HeTdBADElQnrigL/ztqulljxXevvXd7QapPX/sBHuDaFnzYMQESMKYl9us2x5SKK8+Uv5Koj0xHa +NyAI4pRlUhSu4PkjRVh5R9Ew2iWHP+YPv7WmU9ZyDBJYIVEeRI11WFsUe4RC3aIXinXlftU34uKT +rJ0QhMcyv2YOz6pScb651ZH7GOTQ1uW1h2JwTnAgksMqxRqv01x04Oxb4bV160ctV5/k/F1x4b42 +BAoGW+Q99L5r0HGOqhOvkKPbxs+tPLJvzcXdkBcchSVc5hDmBZ+CZKmno8anK52cTRnvFlwWhfus +D+jGsutAhEvtyZJt13ZxJJU1H55HsSnEwX4aXGi6HrVvOMXxpCqYnrk2c2G3yaEkm9rlnwakQOSZ +yR08tTtngvZPWS9k8SJUbqvo9j92XA4gNGkttZjEPn3PsSmDvd9159SLWpTKwVvcz3IgGEIwTbUa +gBZVOAdCMujQwrPVFU/Xn0i3LKhk9o5wevaH7SgNEoJiZNmUYPyPxu8QOAlHbw/yaqWTktWntE9n +vXyW9sOC9WX9CV0c5/8DJ5jP0ua9vzOqx2rlAaNeNzVNeYmvYnQ0oOTXbF/mE1TQ1+fWOTPSHXdW +xBY9rJNtp4U5ae/mjQXyB4RsOLhCg6uCY29R4g6jU1zev17qRF/sZLqXdT+ABomjAzgNr67MtOju +mLx9/+ltF3yDuyX3GJQy0UAQ2icBgR/w54FbAU68XPdxZaXY3fI3Ut1r9sQ0vNwzwloAiYOIDCQR +HWlHCdE9ucpxf491ulG8fdo1zm7/Iv/9tKD4Z5KUZckSXcHVGCqQ+M6Il0e/zrgh/3EOJMohwIjP +WKTIuXuVP6p/frrpbnP+ZuyuLb3rHSAAcFwmSe5L+oZNtdM8E5btEuIbccdqnNkuZkeG+MEiyfcx +hv6oprHE+a2xse8c1zBjpsQLJEeWI8iFQrI5BbIF1dLyZ9NrtY9bO3PKqm/Y75M0XI4i7cdLK2ay +/z2mAXRZV755T5FZyfbVjsUvTy5HgTsxUWdPoWcHv+oa/hJbHdPh9pWVTxVuJDEZ3LGExNrUBnRr +H0W0fftWmpu3m21P1aFL/gGh099hEFjw4i9bHO4b2yV5cDVjfyZaidasuy5fobbCDoLFfzNPNOHb +qVasczXgMNfh50nCxPtvOIFqmzCFft5zyQ5syZ1goWbnNbkrc0i9lW43O6a4wprf1UnCQgnzq/F/ +kBwgfTnxPuNj/Z7WVfG2U6y9k4+zwli3LoeCM8pJ67uAhtWKvn2WW+OGii5ydR2virDj3AgFuKNx +SMjDhTjBn5Cy+7dJyJWgfc/VzNf75Hpu+DsUQGVwNCS9e5z7+cChfN9Lz4/nuGWVQDZWsA+A9GdU +A6roKs70rKFT8cdim+9+745LZV0OgBUDAieK9T42KV4pOSa3/uxZGB289cnJb9SeBpjqOB4pvaF1 +p5Ty2aJKLalTLk1RycUylTRw4OGI+JqTXXaB4yz4c7+Z1VYfqLHKe657uokx43pt2VkmBE0imIms +haZG1c64Av8Tf+5YYa8fZH8vqg05kFKJCUkBIwIcrEoKayjNOBi17eMERCJDLh7zu5AVci/pSX0L +JJsBR4nytKfS5H23qvPo38G4zvaPnnL3w28T66KvWv2NB8AERf9aLTOcsGc9s4N/YYeOeoFkGORg +TsSAbQ8UKkcAvodl3h4tNcnoMzCRvS1hYWQg5QFkSyfCiXeErCkE63BgnfZb5HXGw+eUdzn2SjSt +qG4fbvsC2WRgOQDwWSmXmdz1u83vdOYNW0WHu7FXqc78HUx6M8NTd1xT15/tZ3EdOfSlrDOobVvk +5N+RJLtAilt3G0ef/uhFEGJQPDjwrdNoZm5SlAQNEqLh8ZJGFLyV7ghXJJbgv4rwQaDcAO0RQDy9 +7mc4y2Cm5NotfZIG9lvSckoUIasbPDGAHky+Ijow/sO64QtDYNHi7O/doj6Q9CARTXGQvTW+2Tv3 +c5tR121+zqa2mcFKw+5BGiiKO3CFL3DL9sB6/Vl5Rdyb+prrBk0cl2igCHsH0Fy+tN5ZPEu7xNFo +/Wq9luXelxiDUhmjsqc04ORTT5pHis4fzUKH0C8/q+yfMS24W9NN08BQHnckiOcdIE3l4G2PJFVK +8d+IECgrc0u+vuWsVSv7P9LOPBCq7/3jtrITSR8ttCBrhJRK1mizL2UpBoNhGI0ZSylkTSRLtpBK +WhSSJcqWULayZI+yloqSrZDf3HtnGO6M+v1+//Stz/e83nOXc895nuec8zwDvPvQk4JXHbv5Yqno +4rCei2YS96fPGz865b3d9nH72DOmAyd62tcVU+Ggc4+LcxqA52M9ttL8LMCM7XWRdr7V6jzTGfh0 +JRw0c83utCjMHJ5fRRfUUyKEFflS2VsGZ8hLdJ3k3/FV5ryVYbX8pvFXRwvvVjclOsAIKKS0fDkj +Pz/zUu+6Tt2Hk3MhnZVh2urZUauooMQN3KBlTdzptbrEaDrJWRetmxDvZhTQWoZIHdpIjSbFdEiF +gCjE0BPvpZub2eTQyJ89z5J+jSXkN0vj1v+jHHHRguwhcb5a67Hp2tcBp/Vq+WmjSdjVYq6wiN8y +8QUfzQoQ2KHs90WUo/qqau8VvWETdYWER5bhKwsQjaetD4S5IsvOv3x8IFqczydCJaH/dgt1kPxo +tiYty+0nHwb7L2+99/aHsbTo+g8pl6mQpO3xpE14nZ5iLU0FW7nKlKvoHpXa/5ZpYb/0F3TBq1wj +2podx3Gr5SiOQVp2C6N12mTsdios4MrCi8M2s1214lAxiDxe5BJlmRSTMDccrbCCAPmwe0dixC56 +ur/+m6Kkv3HGVnG8UinMliNtOiS3w8HvwMZg27geTadJcsSvtOxL330uC8MNAIh1xkiSYnSESyBc +vzXkjylO5LUWvKrJSn68qtKuN1n0nOixZCoSQKjfc1kfEe2w/+haFtVfP37fjJP+xXfG2wYwM3sB +d0Uu7pnML5hEFyhaXg/gu9p04D2PfEV9rduK4MLLoous6Es3PIxj8S/79CqDrti8N8eQCkngyOaE +2Dfx4rw7M0r35yf2vtkcnHaoFBlKBSQt/S2MURmO3UfSLeu+JZStqn6AO5zhxlsDC6YsZQFK6nXO +R9Uyfp32xw/jd4jXVXr63YbZoyQKA9VCWfNJueMO/XHu902SXwxzpTpci2DeOpGAUkssW3o9gNwT +dV5kIChK1v/5SLH9u59/YmBBzCX8gnM2GJYXyn5EoZRO21RBnKYowl87EmbdL561fOOEMIoYxvM3 +/bl5JwzF4mV++uJXWGtoQzIW7Obq3qrVEUP2zauYx9KupKik87tXFCwHcPZYDA4HGQ1zyeKfM+pV +tmcGmB6+weu4KcF6HSxOQJYQbjG3aV7hdESm8FHvg2LVutxlDjrfH/jKLgdJOYfBMJlJYPJM/rpC +h5z9d1AJ+HfMB3MOUWoPe9Q3hOJ3j0f88BkcQ3s8ntT9raD1ChZeIgeBDx+aJJ8XBL4QjPGz/NET +mbIhB9ETc/UFrDMRSfJDVDvF7hjKrNp/N1yT7+XAs2SD/8qrYAYaMcmJlSRZJmz4cBU/mmcph9bZ +8t/dkffNGi9zP8l6w4wDohJpZiClDBFgztJZPyp8sJKji1Vrk8HP6d4/MBOJmPQEjwYW08FesLii +FMV4/MCRlryZ8xWXeKb8cxIjjeRn/87bIz3I4mI7+B45mln4xHWhdOpqG14P0KeG61HWcCWeD3gj +eeJq+y5ciOChOuP4vM3ckR5NcUsJD6A7WTtK2mCQrs7gAVfwp+TLcKwlnHi/n3+mAtOvbKqitR18 +QA10Ih5qP2g0KiM0q/wu7/iZ0azygGjFzM48ysyiW45562ll+ru30uQTl3BYbkvzAd7XoZQZW5QH +0oa0JxFph10sSCbwSZLuMTPjGM5RvbVxgyu3v5QilWtFgZUkoJwqQP4/t4WNPd92e2XLing/krlk +l8xtz6jxR5/jFWUNMHUW8YWEHRw8HMr8WFwAn3Zs1zGuUjubb29XpsBlQrRq0ZUTGn09LwPH2z7O +mu28xyubTxlztwdjewvF0OW7RG01hPfdvr3er1LTqdPD4ZBxJEUSNCouKh16PtXbc6vGJm5NeD8H +g1jQkkw9wKqZjQ3gxxAeJgaNB09IEzo+lHYGnDkYv4fFx+lmWdahWX/pHzuyPfcazTIFYJ6RdHVG +uLjaY8BvLE2egeX4pnthPD8bU9b8DNupxhv9npxZOEy+eIjBPILe8i1n6sXPqDLJmmwBr9WfWpZs +gcMAqRBAP1Nlh95NvYJb3p4KCj03Jp4qoTNG6Ze1tMcAa4mAUwQcgnJDgF+f1PWNmncZ3M+jwrEC +JmGnLqT3sm1ZxpHWvUkZ+cGRp6PEoOenrFgG7eO3akwyoam7SvYuwwjeEBYq/QSOxK7AQYWFzRJg +F68+Z0zDjbNoE2jfos/K8GWvemIOy1IR0B65MVCWxrEz71fD2+/rrIuTZw3wS/KZEMZ7OwzZQUDy +FTCOodxxjl+/Pf+7Om24+ceF57SMwxUrsqTE0gzXVV4/uE/fznTW4ZJb0WN9nx1LiwdDqRbAgCQQ ++BmKliuqfFZimYV3ukxfod4XZcnwG94c/Cvh0YO3pbs5J/9kN037Dmst/IbqYBXL+4fpqCDgsRgS +x5H59UyUUKdiru/x1VeEs48a3q8xW8rh7CWtEASrirj55DEm+ZT1/WM71272jixnd98S/przIwwg +9AtSe/aj/4n4P2JL2O6H96P9zqvzUPa2Iaw94WsitS82tebNqioPf1svZ/vZ9zW6M+u7Aaw9sJkV +/PJsLnB7aJt2p/+RYeT3csvSZezugjUGEiSBnx2ob5vzY0Rvzb46Lpm2hHhsVjgqm4cdhjhgoJG2 +pcEvPoad1YAp9Q+Kpkd5vICDsR/WGAhLoImB07OaftcOhHdflMHXbatLsuLP/HDRCQYshKDBQKTN +79vuzR8qo+ZOBfHjuKWUuE/CXwD09qAipGBX5+Fm2JY9UsW34dap0DpG99WCJzFwCOOK8gAGNWLm +jS7ub06ZdN4l726f2re/6cmfTA6eCSrQwiZJwkAFpUWDSm49qL78381RpPT2W4bSjbZ6+zApnTAF +EgtGZu5P2IqhBcPWfpbMZ1g1Hnkzu+ExBYDwdqD2P7Uf1bLVz9HK0Uvbrv1le5id9ak5rD3hgmRl +yO7r9ehdraLzF/mvjD7EKlUbXHbUy+WAQeTpyaCJHmQn9TDz06Y1qMyyMyd2Xa6SrbgpMr2cBcOO +uadUH4jGb7mIUHvV7rDx6iGOjCXLHkCoHsjSunAOvN3n8wapHfEXRK8jxtsL97yu43wjCQPA2L6k +PeFGMHZYyO4d3KPRys3FHxbJZJfVckWO/dy9kXNUOHCnPsrWE/g8UWA5snJFv8dvtpYVWbVaih1S +HQxks+oR+hu8zEFGZqj+dL0zMOIRn9R7r7kr6mBX3fDfJBZM/NaANVgus4B2KcnTDMr+xWxGcYdD +/gYv3D1kiYHjn1Rl3q3+GJS0aspHFtUOo+H+/XlW/66zIJPtoDxyoAOZljEp89r7VHPl7fnLZn+T +ISurDH00QceVH7lyBmN3xkkruXhfbnzpFvo3jYVAOrhBljj3TjiUMd1c78fVfeXXQ23DsNfR06/Y +/yaERYJ1ghf2haqX1z1+2bLr05GAejaerIl7al4bflLRgE6GQh7MQt2ju292d17Vac/c9u1z14sC +1o+TL/ollvPAGONsjVxYjiW+FgL9IoHJ4tITxfMJHRFsa2qS1mjkl89Qo6HTBmDQvEnhS/Sl8fCk +/FaV4Tor9aise7CXQKLApJxOCCy04EVr3LTe5w0zXZv7rKb+5P3C36eMj1ElkQhXYPkBODsFbbrf +ONthK6DW/P5p07WDN50MAtd5m1b+hQaw6MiTv5w3SmqNMfnUz3lhDPPM9yVRw4CHC2y3hVJ6ZB5R +9wpkGFDq/LE118HXFVtGy0AFxFgRI5R24HP9ExVrvUlSdbOs8MSnwfhYXo129eU/6YQiJsEGlhWA +xXKyg7d68ZLzNnEn9/IYVbpx3dWRRX7p5KCC27qSDntDaInejtH2DSE987MaUkHO6TKyPQeXxCrB +dTrC5InDIqwX3HpSJi6n/V/UG3rdRxAjTW7bO04FmXYKvofDi7Ek90d3A126S91Sn7105ZSykvFi +NGSBtQfrW5Cl+5ovzBY4M5d0TMDf7ICHVuHFPzHZETCIVCTge55DktpJJsSM2qVug1+dbkaWG8Rg +jeH2HQKHkEQ6AQFcm0VPGnpAo02NZ4Y0hp3yArumuiI5b6jWnZqCKS5+pQAydnfC9et0iYRgVJG7 ++fMQLbwM+g8MWYxzBBhzzsblvGc9V5WhGSOg+5GR/t4hWHPQ1wTzDJw2Ux28Gxa850iOe8E5AZZa +0dmqJcWmXAizLwYBbC4luGALpjZhMAPppB246dQngxE38hq4ZqKi7H8c+u8JJRrMg0A80QqkAQJY +e/u1MrFX0jZa1Agf2vq+YL0+8sxFSiw08ACEkXDci9n+xHdrrcN6G+31znYMFS2d/LFA2jrAygAH +vIX8Hyl/diA/ikimSH+q+T7oWfzly9srS41l0l2Rap/I7d4/miWmbplsypAaxh50nenRIBdFgPAY +JMGdF1tzVgcpMT++WN/vxH30iOQjVfdGbooEeJQaIKaUm1rZvDg9cve8f/9SQ9/6an3YOooEaWGK +eAYSYO26zU6zZtGs/7CKQcTJVfn4qXW3/CmxUBwF8ELBSJU76JCCFo5dU9oO7rtPPHG/ihQtDWm1 +d/NOriwAUB+O4dGPPj0/VzV172vMw/ntx5MVGihSkIO4UHLynpyd86riQ5+Z9C/pDW8pZGXCyW1Y +gQOQVc84HFLOq7g1cHvxtpq95Jn/2K9ECbG2BzxG0F4gy7OCPbt2clKJV4QXUep64MJI692C9f1U +aQBQbUxju1J5MMfjncQ+jXzm48+MzxtSBDDOtijwArd8KXeItw6Yu6ssU1p74rdxWDHnTyoEkBwB +B2xJQgDdEoCLNvhfaX2AY97yXGu6s9yThrsjyZ4qDGQeJAwki2+f/td1Xgy22oiz4ux2b9YTmvYm +xmUUaRe8EemJ/DjJbsEsjpV9i8u+wnlIY1a1Ly+WEkN2UCOtvkPs54jQSV56bYnfCnGNz3XnjCki +aChET37GYNFsrY36sKHIt2fnyfLgaxYspR8KRpMlVlDBEwZKW/B+kR4LK3x7bO/uO5R+TqeGZd3o +/O3rjJab9f0oaoABrYWj1gDqQXNDI6ity/FXSOPlNY9Yfk2jvSneN5KY7zJUrAX/JtSqWWgV4+Y1 +u66y+6UijlNrT3bU82OVplLII8X+L3SFH6pkbJ3ZNArQFDFnN2j3MeEGbdEIyCJ0P/v8GnZr2+r4 +tU0ydJw9vvOlv9ypwTZIIGkcGFAyuKnAteO0cJeFp+OJ/pRvCmqJZtSpJQfpTru/SmIoef9IY7UU +x9BQ+EUH9MAYNRRl5wyEYomxEehgHnjHF/boBzj78up4HfITPB7AcoVZV5SahqunkxUGKooaYO65 +iTNL9kpSYu0lxYgLA44aTszUMNxZcNmlxJUl4fdeWUVc7dZZy4+I9zQVjtQIomdJ7IsLK9bBm1Oc +RIWbpH1Nv60vvJGtqVh5+BoVCaB5iFAkY91F7utHCg7bZaS+jZ/z15al2BxPMOuRdtAe8NUBx25P +4P7skxEMuxEUnDht9cy8jSLkAayCg/E64gaXxXjTladCwl4/5aev58btqMJsjTogO/323zRc7TF4 +tA3xDAZYo8IagbezB9eTwH5mi8U4LYaju3nWnzuUxmxRdrZVWUiuxapU9lf6/++HwAUQnNo6JdsN +ttoWl9o1ODIQs9se6v6TKgDv3yvoaiKhNu0W+PDWk51+EXE1zBQHNaQH0prkQ3PW7+61OW3GYo/k +0Q+vujrjHPSkghrjhiSeNYCcMDn/FLnvI2wy3dMhiWIiu/4TtT6/AolxXpg552mzcjmEfIWFVnGr +jiu8/qxzTMB8BZLMVia4ks5EM3m8ycnv+1nRffPj1aZNafN3e5MyKlcQWUzU3LB28mpKQkFAUJt9 +7a6Zvaccgo8KrACCkz4U0hBhufWaZzatmv9t6H9VPjTtqr8pTsFEcGlND08jIYs/DDJP6GenxFq+ ++nEE7uOJWQEmeYpgvibw140EMGfLV0e0v9jeFlzpufb9cH2IAXUBgMhqfr5qXbgVUyIP01gX4/7I +H9nGwZQJFA4q5bH0kvGHu7r2Ombx7L+fFqAzNiV6dcA/b0Ue7MCTJ46b34kZnlSZvaU48zX/caLe +N6oQ8EWRFqpIncN7ywsp1psb6KQnNxK8ud1nvGo1dagKEAuYAJyQxgPLO28uVST01c5XvJrijH6T +TuV7RIEbFvFYV2I8DHs2NX1ou0RfpC3CEqflPDwtHStGjQTa11maHMnU+2SSbGkygQhu/TPjIlZL +uT0pexDOBoUh7Yl2QbiDT3dqZM9LDdG6I/Wr1M04OFI13W8URv6rCugTn+DdNPEwIsFm7Hx9zpXp +wf7u86qUeFskWNMX7ENi4z6X0SYGs7nnWQO2Mk8+PLeWvYUig3IGQqFQTwD86FMy2x5U2zVftJJg +RW1o4LCqq4rjoQQCabtJaSYAji0Ja/LwzJR4qvP+szyvOHXRxic8qXB2WAzeBbxKkZ61WyzUZ6fW +C1Z/O8lq6/GWKeALJcgeC9iCBIvXjpjXZqBe+X502zrD8Vulqzv59iRVnakaog6CTsqo3tGH0teV +B84JFqpbZ5Ztzc2woESgnFFkF6hvcoEZgf/8yWGV1l4DnYCbc9PJNylRYNIaZzyUCzJ41g5n+FqF +ySBMV8Mz7rP2N6P5fVQhF2hCHFAJ37UpTKJWyL+w1vwDdpLv6nGKlhfo4wGTNymnS7GuTbBfvsNH +jvLxMXb75/yrb1nQUwKXrJjZRuwfKZE6p6bUc8AqeF30axapEopDFFAsc6kx9LwjvltoddI3jd7J +6AsfOMVoj7acoUS6EO+r9crPW+8ThlpL26o26gbSXhOnv0xxLFtIQwBAzjmqczH9LVvqw1SST+lc +SujqEUVQgoCyzDZIKzw4SzvEVXRbBvZdVS5Wlk8+laYvbOPrQxFCIoB1Z9In7n+ocUt1cD7NzMm9 +z9s30EokDc+XUsYIzg+4Ug7ZsQv2D/8J89925bq0z08NmNCZTI6umWAv/CcBcDXszIzY84F4vvEw ++aRhG3WuwvCobMqw7eJeFT7bE/Rv+lRy7/6Z7p42VnBnNUM2U4YILj00hGQcpXsQwBHUny6J/x1v +EOXoXcmVQBkBt42CRzah5DMLVZAAmcx3uI4HwgWIi/W313Bailzo2bNnGyUZV/KP/IXjqcIfb0rF +K+mqjioK3lc5NWN9hQoEJb5yQri4kgXYsFxvnjwNHeviOu768BGeuf2WlrURJR6aQdWIbtzyLIg/ +Gaqj6X5uEaEt05o4yhe2JeuZtPY/qMBn58xezwCu7mO7KxHX9Hk73t+OQk45UBRC4YB8MWgwU1Dc +kw4aJffK6OZXATnRbWGoI3VrH1GCABuZaCJzXOG4lPI04ZKjRNHey3NG87897UcpIk5ADiPgDzAG +l3YunOfTtSKLkV3cNZYFfbtYY02oUgBgooP/8uWbeHLTYfn+zzT9A8WNySwUAZKNvGiPOmEIYyW0 +8vBKQUvB6YdDTPivq9k5vieNECyzFP0bvAtpPB5+hh6z3RQ0tVbRqR13HF++9XANRUeFzG0smylx +t8g57eLzzLpOTVUnJHTIlOJQt/CBAfMSvj/O0fd8mdsEY02dsp/7h45P93iXQQSTE0m0L2wWN9AD +gx/Zjwd7tHinp2WtSgmVE9+01rfXJ/p+KiUdoAABKf8WKaLWSZOprT3xaz27eHyr7KfxTBftETVK +LN6ZdBVkgYVHKtaPYxPfr5WYOqY2vPORsYmK1ZqV4YX1ICMs1k558/HNfBwTaLmNdNuUfRGvV0YB +7wcgMUJWbtVN6D7rCNy3nq8Kslk3RRlWJglmOx4pKScrv3s3IKDTWHaX690dZUeRfuxQS3WaAM58 +uZe+TMCVMKE5Q3u9MBjwsUllBX/DTIRp3pNsTHEf69xV2fx5uYdEUQNgv01w8WeUFmbwqItt7Spi +rkAbhl1dmYVCfmRmpvDNxmnzzXQO9WJJ8xoHon7E4PvF/0ECXK7UF2lb86LSUfz0R/qxoaPKO1nL +rFdGgZ5Gfu8BnDLnOOnp0tRdfkgYbxv9eSD/+fJ5E1BwJZMgJfR2INtc7z72DLl//4OeoSdTEojI ++fYca0VKr4FcZqmAG9/2ilrpSkcdn/F3DYd3b+nZW+/xFwEofrFMZ5BdQBh1Q/sjEw/T+Ce6H4NJ +TKlJFHUW97lTuiZAit0BF6C6/lXHjPn52dcJI7wXtp1eusZPlufXGKs+5GpqeFtR+bJ+WyZOJUVx +ZMlpqDN4JNaTmEwA6UpwsEHK4uDtjC6tVcHb9LsEXjTjhst0WZOoUU4Ij2NIT1cwKwFwqJ9YXJNN +uuq2dWqaC87H+BDtIR51Zzw9VQVguRKsH+CKdEEs5FPEMso+7k3Odp69ItAhHL365sMLDWJUJIDm +2doVuagi+veyPtmsdBufxCoE0Z1a1pzwfS4kvQO9PgZ/RdkPyVxmhnW2eX1X6y0fpHktRVDWCwe3 +yBxGYFh1/GAvMB5P58afWp9uQqt8xXDrPVY4i3ZxlrSXBYHPj6pNGjKqL5cyTR3T0mcoYA9zCKQM +EPqBE5jaCcBs2j5+p7H2EUKkdanJ6lrWcg7T+FDEwNZ0nMOK0iGB707Ku/wWu//Jkf7DhyhY68Wz +WgBiqqgdt4vzGKO5lI/lYVW0aOz12EwYsnBWFgqVYZxBDWJ9jU5Euce4w1vEZ/kjB8f1t7IXTm1y +/LsCsOy1bNl9+3A3I+8mCfl8+tqbCaGn02rNopX+XQiUQDWoczQnpb21Gh6KpWsIwbxM5eb6dwmo +XCcoVHrgYfcMfc6jgYtDFk5t/QZHfYtF/i5E/F+XhW7ydSRRyfcb4+BJfGRutSy/fcLWul3/KrOs +x41rhR6WfmTk/ZoxJd55p10Db/Ctz/8oBfLWq5sc3lhwj0yp4ytoT6iImdD+1vo7v1AIBdTwQhVb +oEbiRuh2bIlqwnfUD/kPdf1dwxnpjsM4IqHbCN6h/6h0c/qktpnEJeWqTz/fq13R/rsEEMNb9jxa +aGT7RvsYOGodDYye7Rjm2+R3/tffhaAoL8B7hkU4Do4NnjLgzrHuq0r6nXuuef7vPLFuG+BIEnVq +9VQD5yw+sI252N4pe3EmZs34uZh/0IFKJC52/nWrbA6i7sq+WmOm8VvI2iGOY8xz9l9lQAEux13y +s87ajxqakDmW7BObv2OjaP8mQLwK8m6iV3Mp7/FkJMOfiJrrYaHXTtXeDHz/Vxm8C5B9EMj6sXhD +P05cYhpqeRqQWtNwh9fXRa7sFMe7fxcCJfZ+lhnzne0q9JKc6zR5R7dR4I7WEFwCGP/sgK2c9tCD +kP+Mliozq6Hl45h2zEJKfJuOGoYPmWS1ggh/tcZjsaQiJOgqi4YA6WSTjJ6kwEcI2tuORR8lV8LB +4mfQoHFe6hgj141zxyab4srkZR2kzPCK8M9jceCzAk7wOxPv9XPi/na8Jl2AyI0iDpkWyd36G+Tg +P7vAQhsxkO5I4iiOFRpOfHuFxdVbTOyybodS4sHS1B1/oTFoGxIdedCnxFWD5XmmzREvthrF/w4K +fPClTiOt7TEglhLEmpo4dPbpw3xt4cOy37tD1mbfXwGzARb6CP449Kw2lNzwqfrJxVq87VPRf8wy +eskFpVLUYSjdO1gTa9kwkFc3bNvnnZgbZrnacZL7smN+d40NdR3S1igQjfnk+DUkfij9aZ95ip9n +fsAB/0x36igYCwIyI4NsXc2AfESLx4nKNW/vm4l/p2ub19OnzoIXTtZR6JzGazYVP1BWPGWXndp+ +rJO14EnoCjQYFYBII24pg93HBQruxVbeztvmklEzEnZgBXJxQosbLDGu/xzId6At0CLkkJCIeOC5 +/dRBPM52LzQPrhKYnCw4LXE6GWc7yls0MVjHXkQVA4mHjW1+xtsTtFrn0XosjkduB8dEdcIJYspB +4gBE9mha+MJ0lfedtXyprtlR++6nn5rWN044jkLYOWNcCaMwsCoPZmuWtMK7QsWNeuxZ7mw221Du +cwZ5hVn63JEDyfi4f1Kg9NhcEYwaqZ62pYW1Jx0e6tAk/SpuSfpfiYEqJySKDzLfcDjv9t8j7x1x +2DvqlnRv/0llcVw+YqM9vuetxbTo0die6L2NIwnzSIt/kgCXv0ADQFpXaHC05Ejf7LBBQYoQdvh0 +2dl/UiDOeaCIIpe9N7/L6pfC//VWsuec47o6G2v7byKLM1WSkzZT9ufLwps+2lT8qjGi3xLlCzc5 +KWksWhG3cuoqDjucpIsMdw0/fKRv65pCcQqfLlwChN3tS3d6pnxIeDcac2jPhT1vb+uZ3YDDwEYK +wD1xQWJRGGiM1kjRsUPRvW5lVS3ZZF5K5xW5d3ULDITGOTTGFfTiXKBu5Ctx7OO7deW+huz9NS3W +SjKHZ8UCqJALsxFxAQTAuVmyajOLDCWD4ozP0XFO1MZL8m+hjC+kLlr46RtP79XPzuZ9ta6ku27t +LJXFVJgCtxtBFuls4wIkzl84WIWwxpHqfFV4so9i/vMeNA7f8mnTIylbT3TITcoqKBukkwsGR5pO +Q3MO/67VFYjCtA4bb9Cy3xtmvvsKZXBJNXOyXOaAyu654lPCol1ltTKCDiy8O/qCRncEr6xCuoel +Op3HSw5+y6xK9HojzckU1++8aXv+HFwHjL1KIhFYIBcp4TuGFngCfYQEOUu0jiht/xl75yJeIZIr +lgJKfITwbBqfPdc9vNN7cjzefO6B+LD/1amss3CPYoEHMyuS1x60fJ/3PvJaAdN6Z9zqeBaPJKEG +bbizugQHsa6I2g7afKXr9Gvp0/FFJ38/Fkh/vAJGGkNPTYQOBCNVG4+sy2Qt76hRlztsVEIdW1LP +C+RFvqy+ps/kFJYfl1cxdHSX5LD+02fU+YX+RnYAEVCx/TgmVluU7qXnXvjNxJ3nzl4eEbg7C1Mh +2BjWCBsk8apAywF6gRPX805vYWzHyxt6pQQ9PVH+uHaUuhpQV2xJVbmrDYmpRiqb3o0MhM51u41Z +5h/lEqCOL3gKpFV1QMI7wdDvIiezzUhm+xquvTknk1vdB6hLQKWhAW726K9gE/Nj6yM0Tthj1DI3 +q9Z6wl2VBQ6YvZBQKSbUYuFDk9hp7oww7FCxjsIJiWf368YbHP3hGqAVbo1GkHJKft+ELrIT3Nrr +L1c7pHYzPDjrCdyUhiDS04dCVa4LAS1Q59NXRs79D1ZblvtJFQ1pJRrt7m+Ph+tAW7gW98CBaAc3 +Cqvkw/RqUOE69+BnjeQ5fUEJaigInP1Aw9/nci1uvV+Mh9Rusd477W7HYQBQV4mUfRQIiFiB6If6 +/36K7eXfmqbA+rWiQF/48gND3r+iBOeFWMkYND4CpYPwl+7euHL5pKZhHENi/JH1p1eWAEJeTtCl +Y/+oCe8LbdpG/9PTxTf6wO9Mv+OTK8N4ZxTk/NmfoGnp4L9lXVBWGf00yWP1m7Vwz8Nedpm/Bf3q +Ngclx5iZd61Z9DKhH633fnPyoj1GkSXms7FHuKGIRgndkyOHmLB2chmIxHWF3reevysMqaCILk5q +C7V4AR7DcofVmy5D7GqPf75JvUnkV2nefkr8EmNqmKb+pfircY1+zdHzbdHHPAuGFbZRgoidGWND +7IS/Mgq7At40Cpp4ZykYaSt05u8acKXE2WEQ7ghPMKBJjN19eH+pkc4zpT/9C0au0pw+7gwC7U2d +hJZdVP1v7B75dnpevtCqVvZrRd4TEXi4j4BQLjRrw3nB8CUdc9i+U26ponlM9JaVPIMUaahW8DKX +SM3uIFspJ3/8i4D2/KBHIXlxUrTd1OmFPflQeIbxUbfzmFsO7f66sKzHJ8XPxMfDLVUCCxyFBE6D +QWdsyavSYu7r5j+vadHxLXJr1CgIjjcTNoYPNAQF4rEQANER6NEdCHOyQu5+2zEw/yX/jTd9KSUE +KJsB5f5bsCXnhJNtPhjue2Dq860wjDPe88lcKDzgB6BA4WpgzwDxID1ozvWx+7m11NUbn39XszZX +OSIoem0zVZa8UOhNwZOja3qk1zzAdxh16avdNeO7mksRJB0xBQdxr1u7vrfsO6E1ebVNoF3YquZ7 +Xz0l6IwL8H2C+WBIa3joO3b8EwUCW1F13AWM0QnVsru44LEBAkqq3biQaAqAeddMd3/drCL3Rj/a +NcArVtPNlf8DJXjJL8rvux/wYt/FkAtVL4fmM+ervl4OgweTAAjy30iDP5hTjbwz2Ik4JZi23G/6 +GXz16M2wNRxd8rxwo2dRBzbpmgdsepgqiBz5E23yh0c54X06Qyh8RCbwwLZnMGUX+Y+robPVnryP +f3Na3ettb3f61uSmdl1KMHg2D4sjmD8YO7yrJFlsb0gwL+voYTP+P+I8B1V2XovzXy9GcXxaUIBm +Pyh76+LTVJk6a33zl8+geBTnRZ6zYUo0GpUU+wtJBoS09a6FeQUePWWQLqj0+dYZ8eBvszlwaGH4 +AJIkgkdrQXj/AQexlBDV60G3JtjoPK2PnMI1W60Akz9yPc9LunXvOKLZqrfpj5dKdV7MOQw32JeG +hTeEXG34KcR7YVrdzbY4xIheI6SPAYYslNpaMFSIqbqIsQBiCK2DBSPShrxmcupFuz23b5uiVVbB +P0iRl3jeHCm+aeiMfKy/2ChigxT6jf10V8Y/SIBp2yHjCZSRGNCR0DZCXs/1FEoqW3Pc8UI0pyl1 +GcL7Js2t0FXcH1NlzBhpPfLCSe/pHFuAoq+MvScMX0ySCCAD/cdbdjMrVJlyzmIC7uzsXR+OQFFA +PCXxLkCRNbAuBwjy4BoMgwItRGXum2oxG7I8Yb0aCo+lLYIgs6nL1uv0ql2TBl0CbzWNbjfW6GfC +3RkgXZkLwhM6lAMcGAbIqg1RW5zo625OSc5knedifprfFTpDkYT2V0OdylBLmUdyW/qR0itGRhrJ +l/NmilzgDFTWg9yY23hMPtSyHtGFKUhVeqotLmjAcSodxjkj3clCAwYMv21reyq+pPh6dtslXeKR +eMf9HYYsnlQEmcO7Ja98K3h0VX9DR9OGZ4VVRa2oDXAGPJGEBYLcxDVBaLc7qDC9+oItq6nHUdNR +08jQVVabz2YJZsEUzqAxdtDqYb6tk0GfZXdI08YXLBNtBaxqV5lgrUkOBMLFBY2CdqAt6ecC5onM +wj6hLur9O/ZIKVqhc2oKNlIVgYy3RZMI8vLoI0vWCAXgvTlrq+gyU8+HSgzBvbylCnbA/g5bPBRI ++TOxVyMmhqPg3M9ttN8N51c99M46+RceSI/kSuaUKSoECZ80YxVi12h7HdK7kwU95Aafg5dIQFdu +LYNhKB2UqvY9/qX59H/72IZS4P1ieSgAiyQYoMC2amjBpala5M3RV0PqiCjRy+WlR95fdoPbWMsl +SAUOl7yIJl+xc3ICvJ571tG6OyoPDuX8fpL8NyUQpNe4ohrhUfUiRDP8YKCpgH7C1Be4kUgCYXPj +gEUCC+/crSeloesfTQhj7quPJOKp084o4CTdwuyiq15rca4ul+b7vp5p3wrL6xJcD/KowsBZG2Bf +DRQQIbuBxE1F3md+fogK1FIrowveonNQ9oHd31QAyxEKiBh+9zwklscl9qs01JGt2GgItdbyb/Ay +S/euUkOQXOe8fllb1OdQ2tT5ygN6OKoSK36/EzeOsr/i6ec63Nd4dg2vUWHykZbh/40SkDYbvKmx +A/snDN+duJitOWJ7S1j/Q3M5PNpGVQeUeHnndH+zOM772YW3ermXD75hTft6fQUJwpPB4lBEH6e+ +YcO591j1PQa08xffs/FvqD2FFaLKQjPeEt/K/cjnKw7Y1tqeS06PnDITT+6Zi1D7Gw8eeSauYl1i +Mty9pT962xn1F+seew+yuq2yFl6ZB7E3yA4NG4G3ttqlKc0iV4JtdXdEwA2IRYy4ZmCLtPa0Jtry +qUUiXl1Odd345KHisbuP8+gO16ZRVQBjI2BZGzLnu45dzy9M8K3F7ez5S/gLKYbXir/CI9sEmwd4 +XWRGA3gtiwMT34D0AGtyqQqu52rW7BmzqMgjX7/BVZxRS3d5dGZ3H6fdIM2aUR3qUlIpK6R25znc +BQcpqEYbYRiDPsDth1+pz8a0cFxP7LzXkhG8/ZT6ZBtFELBPoNLJ0N2atiDrhl9bcnBeebFhp8un +9ix5M2NKIDTORwmz1D+e6DJxKxY4F4jAdN08KQNvDFhOaGgTLWmNfd/4bNWpuR6R0Q3YYG6jeCEH +1C0+iiDB6sY4uILjFFhbGqQDWelefGNOmeibTxF1ntb21TpfxE+BBt+AFcoGRUxEAaDdZy5xBIe8 +voHCPLp5H6lrl/+i9MGK6LJFYEHOPefPG61dlYWZie/We7D37urowyvyC4uina8keW0wwhrdJw3W +0QXEe/3RTJNfkQSyFi72H4voRt/dp8SLpE5H7l1lYGj67ukquMdBjkMlgwBUJqmCr8hF7GKat7zY +HVf6Ev1ro/+tiBKzAEBTA474BUvLhM8NMH3lnDwpOYh/++zrqcaXFEaAJSo4K4wN1B0DrLhm5etu +PzO3j+dIujBbI8R3Cb7MQQ67IbDW9nhnRzTReLsXGer1Ta7rWOcDI+GD1+Lp5OpH7FcUAI+mQ1Zw +rMQeqxNfY6Qq+YpOG5afexz4Qhm+VEliCVdMjNEvLrE91fqle/tIrKG4ZYoyty52Os91lIJVBhMA +LgBMtgdo5B+YY8zDqcx9S8wfnxtR24BHqwStqLH485aH2u5JaV17p7ZpNoq3mP3h3KEd1B8egC4L +Z9y/+vPWvo86Nj7b9mnqT5cUKj1LwqzIk3ZhLl5CX335n+ghp1s/2HUnMXdqLnapSN39JwnI74WC +Fc0faXSKH7YLvHiVyRfAqtJzTbruXzRAmIEeO1YeLLPqt8Dz8sfnuyd2ZvjBt4CRw8C2dHC1hiwm +dGp7/hHNhueruF8Lv7NzeDd24F7T8xVFyBfYVz+tbv1qPEq7VT10tZhraajF3L5TK8MLHmPYGye0 +3ZnR76FHuozrJ75ljlg+pWBTLUHBDZCu9oSpCHiR0CMwODWKt5/5z6M8+LTcHK/uCckIuAcMV4H8 +CqWYkXPs2xlF9u7LtXvjkyTxQ/7LyiysA3/f1nPdtLVr00VldH2EyJjR7bOFX6lJgMOWzZIXKCGd +qpPP+qR6do+Ve6D19fL2Z75UByEiTlwxAPEHnAeY9p85zV/zUim3hMcY/X6/SQo1nGSTA4erySed +AeTE5/lz4T8U+H70Hk7077HSjkX/m4YrDuMCeiik56mZ1vYj4ILO9RKv7LvmMxl8xnvE4V7dMilS +3rsFL+vxnAtt2CFH/jIaNokrD1gVirWn4WEoKiIkfwMUKvSx4d4Qt5U7Ii8+0NMiUut0weAUNSHI +0yN5a2QGynxbqK6whvhA1dcJ4Zo8v8H7LJKUpmRiOG4xCyLAjvgc5nxRd6boTOsu+pfou+LrmpSp +jjAwd+W6uHzOhiuaWQ/2/qLdzrJHoeD0pQ6qMFhXHTDVrAAbifT7zFI76BnmuduaVG+qfsTJP9W0 +/gyPE8MlgErtkLX0p8Rvo3DLNMos64AMW05ltA/a+e/8YjUgQINJKIsture1dNtql7v8KiK5H+RP +UzDwYRoYPOkDG7R7F8E6RfvUxffix86NcmdQ2s1P/y7gDGxdhIY6KDL5fV7rRZlYlaK988/dN3z0 +eopM4NueYCpANhccZKfcRI01ZR7T2b7GkS+4+160vU5qIjyyChcAjvgBOKrLZTK/WWHLb30/dqWh +1FmHHib6v+OLH+k5dkYXmwprE+GjOPodn23YwjC/4cvZy3mQLN932MqtNL5QQy9RjG6/nK7zO3kK +nhr5viLSugFky7bToJwiKp78uBfv5WO3b+2zrPVUxzciTlpkO6yX5XCg5w+vc9Su7SGKpr8Fbpn9 +oYaCqaSwCOAUIOhXPfiuJijdVWIlNZ/FYacufnXg+Dg1dOnu6t0yrZwV5WLbMfc+dk0mxfoNFNP1 +UCPJ7/O6/9mEwXma9bql/JG99wUlrF/xUr3PJesUxQ1zqy16Xr9h3VD8PPXlcY9UHh/40j0RxCKt +3QgDHYJg9luTfpgj2/f4ZnZhewfuCqEtt4NaUqN691LnySq9kTZa4H8iWSX2ie2RM2+PdUi/Xvfw +7rqPKwsQz1UvKNSIhozu8+64JCVS4Hrhyfo9H5IwVJ82pOBEGOpAr9CWaExukrkzIjKMu8l+/MS9 +Mef8Oo+yHLqVJYDJA1rzUOkoGTU7990pL+9o8X0EOzu6+ww1lGg8ky/HHlN5eDzP+bZJwxTzwYvP +R7/KWV9vp4oT14KB5WfouuOaLXA4HocT3vV9uibZtlnzoqzw9WcSveB/h9GIVwmGt8fu1TilpXEU +1T/05xBVm418koTi3wjrhY+z6ikDnTB7Zd78/J7tDwPTdjPTHYNHlSkIgTCrePJ7fOfZ4YeHy8// +4PWLvL95/iU1mPBNkrl7R3PK+ZlV9e/xT6Czaf3XpLlp0CJWIil6Ph4GUYHCiPNrtBH7wzxskxuu +rrkGX2UjikDZl10QWDCo5oZCQmHu2SedJ2v9n59703JeV7jilb9XnyF8Ryy5BFaSMERA1j+95m7/ +is0MwdukO3L02iYCZLoS/oKS7y7aGz82FisvL3j7YKfSfR7Mn+LkmK1/wYEF5+UR4fkD/00mnqLf +z5BvFHgwuc6W8doH+KIHUYYspSXIsuxt7mE2cIjujXLorS1O4/b9cBse+gD/BlWPBaGQ8LkWb5d+ +rS71dV/rz/sp3N3CAD9HA/6NWGINgPw75x0lUbcJvyhmFH9jHBMl9AS+6ItDE2wwaDwwZufP4U49 +mB33pUbMPH+kXc1gHdymB9tjiYFt01LGB90z8yN0d0q3H37WP8y5Gx5aBQBHpCcppn+xIevB5dc0 +Pz4dE76dEKJ2jeX8TrhhADDkoePP9NNpx6qbtETUDS/c/ZLsFXhNZTNFCEiBB72i3C8NiLqTKS+m +zx7ryGINx9hqNRlSRNyICTYXH/apS0qfLiWIz53tTdngwVf8RbvtMnxpHlxJAfoWDuVMdOlq/Gjl +/F2Q64peszTs2SCdLjdcDt+DA3FIDxcUlvhB6Z/Lqn5or5m9xz8vfX4yo7FhIxs8lABhi3udLNPZ +RG+Hfjkuqa+dO2nwfV7kVRU8kAdBrkhrLNGceMdRruZ/OajO6c0g85zEs0qxJ+kn4NSysN/yaPJj +7+0FRazZeg+/7GRPxyqouJ0XfA0TIVa1l3RG2mGAwYMEjxmlB5XHKiuE2EZj1vo0JTV27DSnBkPL +lD8u7BfgVeoJLzJW4OLn+Hr7/hlVGEAaJMAEOsQyTACcwmHCMOnScP1k1X1tHeUX3MxT/nAfhwST +b0Uk5hYEHU1ZV7XhoN014XiGMuRG/bWaMyW7qWkA65rgyQzSDhUt3HfRyGSDLOONEYbxAyzotQEd +hdRg2ED/2uY31/OBlhqdeoGngoneI/veucEnVyIMjbTkPmKgqkbBJw6XJPt8Vas3a41TpG3ED8Ho +hRX5JeFt8zl3Z71bq2xPH0i21hrHlbe8On5xBRTI3AwcvyT7hDZ5h35pn3v4HX3tteu7dk9WhZsX +4NYnXIFs8Aq6rmjnuVbs3X6+LNqKdHb6DrHT8PX1v2woMLGJ/6GvykjT9Whkd1wo3ugayyb4tool +uwlGN8gZqTCYFVncsZANrx812f3p/RLXaSGOAiaqgSxuDJa0jxk4LUknJPXHOOC4+G+MIAsmU/n3 +nf+WFkZYquCOtCJ0NejQJc6eVCcT0PnsNMWWXNCAyXT8r9YuHR9SbjiNoKoDAE/VT2i97tP0zqmI +ZTLcq9EufJ5RjSIAlRe1dwepdyVCzzkQZfvDLVpV1bUb3UMT33JQpID7QyNJBZCYUc0JqVfi9Pck +c0i0T7hYr6fNHlyOATlXyWN/hAfluvQLIQh9Glcb3yurcfzPIYHNCJWUvpa2pVmQqAqR5XtnUcr6 +76rjd2mme1O9rYc7rl3meqrzLxpgFsVQIzbG0QzX/l+lKg5HO3RsP3InU2StEVgsCkj1QMwjaoXE +uSOBFwbEZaGMD9+5u02Tzc2+XKR3rusuTxJzVg+nLOUKJnuIeWCA1H+jYjiySbfbYyqJdUdJRAjF +9kDUBZhCwecmiXQjFQK5P9+0A62SyMh6PwC/W0+QdjJ8bTpFAZSzCx63cHwNiFCUFM7NDYSLiEdY +syp3CP9J5AngokISHpYtkKsAOvYMWEBkhW1SSoe8nnbsLhrbax611nIntmC4Efa5LNNxxizuQnJG +uoOJeQlKCpcD/EIvn3mIm3vmqKZp1OfSeGf1X5QWUjZBgx9UJU7xR0wYU1sMFm266dF1O7GfngEP +KcoQHieUWijX30k7N3ynPo/efLAM/lvw9nQeigD4x8LJa5DFR0ywed/0EN2MmTiIOTR1/ghz62WK +LJCtnXQs/aFU//49KbFJebG9YtLuLx9ZxKe+owyRjroD3QUYm/J+4W5o5LF2meDvM5T54h3ZaSbT +ViZxCCuCzerkQspueE3D9ZecMiPDMPeB9ybh5h7/5e+kfLNYJKmI+5y0xcjB4CqGjIcHNl8z2qhT +aaZRQBEBfDsg0Y4T8Uh9t2bDMfruEAY9hRC/K+/fcwv3eFL+sJdfZFvOq1X+pULPrkXdG0t+kKK3 +szwggCK4mNXSGoPGO0EJBFppWHjfB98NSqw/Wrna73tW7xjyCSUaTL8w4R4tui4tvk7sqrPWeHHz +qHD47qVtidl0iN88mCHnxfxE/bYzgfgLPz1EjH6mcMo6py5lSKVYJDFWDmCdd/KURTtvFgaEhJmy +l3pzpkVeN9ceiHPLWIq7oCUJIw3Cc5GTBCq6LdRYuXrWOubL8KjO9kuP7lypmDlgr1CgC1eABjqU +LfijHyeqPbhDmuOkT7tVq0c5+21j4BWGI3gchvw1GF+5W5B+POWBQ1LBZ+Urlc0THK6sFCE0ygp8 +8k3pljcfv62a42UqRPx+t7ZX+VLaExhgjUYisIuHTRYzmgrt/B0/aLSlmSW2g7HWqThz1w5OSQo0 +ijD8EUtsom4xnygSumRozyOZb7v57XjKvocUAOJsyrHl/cyq9bO9roPhWW0dErp2ohdewFtj0MQv +20mjcvRq+PnSjZ3bPAyPhrX6nJEyo9AcfFrgq3Ym5vJ0XbBlAJlbehiOtxxV9umTfe20zicrNpmg +mSjIgOvNQPtY/7MPnZ5ws8yyrLY8uYnTP+reU0V4e6hcPek58HFsOrHvZvhL17YHzC9Pdq/N+M70 +BsZAHwrhgp0Q0PydqxN/R09gx7B6YmKyw7XyMG7hO2/hlKczwgnYvedEqpObota3cSL7LWe2gaTD +4+TnWlL3lThgGOHVEnNThKs8aR5ioL2xZ0tTx73TfKOrGsw2wZs7uUDVZWLbXpesqt/W4yX8df8R +GS26zZFChvDWzjbEVQhSZq4NgfGyXWbRm3wlevakaThOHNzo30gBA0rfgO+2UKt//5ZfQeXN2ISd +6/VbtfHyAvB+CjxdotO/rNwXq4bfXGpJh4b8x7Wa2BOcjo+unfkEwxey8oMPHhz7Fw/2Airaru3P +3ws/H5CuytpUJ6wswrKxowumYo/AOmGcwWeTX67Kdci975rDOkWxDetSaZsfvKaDtwdqK2CBrUc2 +eBdoDwRpqKPvYrqRxqNVa85WK+LTjHnHXtzlS5UHrhgKe5AyE7lsQPA3/gzQ33g1KjHN2F+IRWsC +3jFJOJCdE4AEZF/8njCt/5n4TGNeM4B19Ch3cSoMIm5kWNzdChhGzr38pUmTvxv7c9NzYt6INFtm +T8JANHIhkxPAbMs9m/ss9kLD6R+hObGxe7bzGXCVwBlgg+bCc4EscOJVAxonefp8k25GsETNHD5x +zULQ6OYUj/nfNKiYM3lnFMpGq834t4oPXP/OLr+NY0/uu79IgTnQSox3V26Sjg5+Ucg30fPfKV7+ ++moYRvbjCDeUHbRk4G4PpORH2JBSfcsqMB7pZx++M+OfkXtdvo02oXXU/Z+UAPhc/XSQCf6a+8bX +6WI880N8GmnHPlKHwax6X/NcuNT9EdsL9V2duDI8DrWNx1MmgIIbKPDkEuHVLdlbQJB5/+rOcG1X +dUUYjeYf58MPh5TT1XphMsAjBxLAAvuJCXMtDohpL+Q9JE9Dx1as+KF4IOm2qejlwhbkVTav+Ht6 +K6kBjM+By3o3UFM27aWri+kzdLfUb91aC2fwaDR0YA18XIMSe1Z/EP+UoXvvAGKezVa3/NP+xxQZ +oPF/NNdOfkvNrXx8wTXWitZa0GUmLwXWmKwWMdvwZrP+b+/T/gTdK9GXRb7yaVIvh7UnS4gL2F/g +D/G6CU5oPODh4qsqa/tWLSkS/MmCjxJIqkRP9iEwMd5kYbqX9nFfRnP5y75pBa/uaho4SviTlMMO +40L4Ht2QBIPAHQGNyi+j/Abc953L42znjWCrO5M+MKN2ipIEDgduDbB2JM1rxJ0qBIk+HsvO1wdn +3gUhrz6bKh6VqrbZRk9JAggrk1fbfCMleNxXc63oj8mNmqczf4X6Fn+GW0gkjlTGlDgOQd3Qjpkl +MvxL6g8P7vvf3u3bOGab0gjv/4SbBwImwOEe64Wxj2AFE4ZeskdpqKMQPSq70fv7L/tV1137ZyW3 +xPz5JylwOHiGDh7Y2b6+oPnG5q6p/SKf89emwWCCG4RxI+5MIDC4rnc9JSdPyWEmmjZqpDfiY/7z +MqLAnMGjsKSKlAtFHcc33tuZNBUTYlYYsvNnNluC6I4QdaqsNcLaHqSe/tmH32PiVnrDfG3V1jIj +rateT85TpxatHUaOqh0G3ib29w7OT9ee/aXjpP3xJVWOUq2L3p0Sf4IV18b/orv2UmOHdpDJ4Vcx +FAQAzwR0mkFzyWLC948Hff+XutGXU8eyZGO8R2/CGFcEwamEUqiCtsyCU+N3x6vjjqn7h4K3M8WG +0u0pyqIPsCvQpCpFwH8BbVb65IHHpvuqnue4WhxP241tkrBdtQIO/kGspbClJEPNITGnPv2WnOyV +/J/FVaIlX/+GOkMZtheKcvMY73Lo10xM5GC8G8h7JsNt3dzOtX/TIH0fpLpvueLee2hN475aCORt +zfIXwne95hpfQQP823KNhp0Wks0mSV7C+gdfZl5EYxJfZJVR1wB9QuVNkqoeUfd6TW35XmWzfcSX +CBvDCSQO8HxdoNKmtNO/cJMaVaPqI/nsfeUhaKP8K3ACTBRMmLddgdAhyaJuXSu4i5OVcct0c/yM +zQ3Nz5EqCDUqKNB8glXjvLC1yxHlbwzHMuX8D6+vfjYIb44jTMySLnhX+4WJwKDwxlT5LltBmiQJ +nyOXKypmHNaxwTlPZxzCg2iJgpvYiPN7xD2E1uYvUQdxxgmx1TvC7fyfGGxbmQZHWXBiKNnx9tBz +911othtKtT+3ew+E7siFoeReOVnZVqE7XZjBV5mOo18bHFnZW4+GbD9usDIL/AWPg7Y/QYleVcIq +ViVHyGx2uskb4/ThWq5KxPj9v2iQvETRKV2RoofR7B/jj9nsUEl84dIkBR9Nl6LQrEL6N3gT6+Jl +BcTEJUTy9td/eyZGg2Udepi1sgqwhRC89vdPehjXO35Myq/hF+A6wB1mh7ukvzJK7FzA/wEqHHhI +N7bK6vl+ydeWcd/Yj/BoseQc/psCUGLGhazC66jwDfV81OXKw6onPyqnvXQxOdPH+xcNKEkpAPfE +mxY6aDeNFilVb88RtOv4wJ/a/jfYFWWDRBL6gDVkoBsa75TaLGoYJ2mNDLp5dhdfxXDVXyRA/2fJ +UOq8czrXjj2H9fpYoIVIYVGSKd8luKlL0ADanuGsvpEhyX/ktIJSg9qvXXmfSmbs4W3BxJygaUb4 +mYXgEMDv1zhRH1f688X6U07CpuGbffw47srCeAqZa6HpEYqeLhSb4pe453CDMRGt+2G75waOd6NG +AUyx/yIGDC/kBd/9depR1x6knTTVYRX2HJjV3z0lZPIvOoDpbINAYyDD+7nBr0rO5FS6R+Mh2RG/ +xBsYBq83/YMKgNJKeJt8eXUv1+OiR5L5vrjkV6Fl8J6IdyZ0PWhphbQEucTcqJURjdr58s1Txg+B +30dUbh7lb3CBmwx4V/JSc6vr7uhoYW7VffXYzeG9NSfJ4o3Kl6XIMgPjnFX6CZsQqdcPGi6gK9qK +FHp361pSAqAyLsTwGSnKD/ZXwdHL+I4k7f+UXcO1VbYym3O/16AoAJXsPXNoMLgZf2Ok/fGJw0q0 +cecsGpVyKTUHIxeSpHLPrj9UGn4Nh59wR3R7F/uiR5nDdXsoUs4YwNwmzus7LRmEAtQYPieMHe3t +YYsuK2Fg302RIr058AN0aXkqe9RBzEjOI6lla9HYAXXuD1jKFGHuh4KRbuBOCCxo44LGZcOU8gVF +juILfHqtKndsHV+i722yW1HDdeFWeWceoacynTVfb/3O5mH667KHTGb0X1BXIDEZMIwCRgDB7QOu +ZdFzdkUTB/gNe+Y2Gj5vq2Q/IH3U5m3rlE9Aw35KyiTLCszeDZQ2XqxrdH2gdI3hEGu3ls3m/eav +LlbYVe/LWkkCOEdOrOek2Sv2WUH9QnCFnxnjrh6v5IinohWUUOAIBtC+sr6iRVdZ/FADh+CDGFv0 +E1tj88eU2gNlZxdqlKZX6bk9P0E/+VN6y37LqOL7G/naUyhBYCVp4OgTygOM3Xul/9j3hesoP67I +cG+6wtmI205RFDE8+JEZin7H4K+zsqiUDoh1T3A3OjqZYCg1JwuhnMhcx/SdRW7W/1mMXNaJ8m/n +22y3UEKIhWDJHiDOHhQY/Sz6tpxpXEflq5Rgn7RlR3XyO7WVBAheritES5JXo13bcF7zMl6R9lTE +mODnG5E2jecL7qwgAw5lvsEsu3VjL1ru0t7vo8Yww0l7RoES4urpROhv4PCbeEftU8vx1ALpDGPx +fIn7hwXZUzwpIXhnFClLsPzOysNnr52LEmxtm4jeeiagnP/IsrgUtEOeMN4RO1Qzpj8j/2EZ6vcf +9+0d+lKJm+d6lqTwwuKdnZHEECOSMNwB/wEsYeHqiAILK551vDWcWNSjy4y8cxpzMXswjc20kJIA +GgVmDCQQNE8bjyGeZk533TW1vGSplI5L6zhLiVgomddZov896SSX3k2mPU7pt9QZGM7vMqMAEA0p +iCONQ84KfgqZH8e/2Kvc8wxHNyV2V9ZQujxoCiHaoVZ4YGMJ1OX6aPJXqe281CUyTc9c8b4t3XjL +htm/8ACGCHi9efyAsCt7TIHnqMKxQlq3P2soYMBwA/4bjVmsTMGqxheCU/SoubfBiWZ1Pm9EtOS5 +7ZRZ0DVezOzOGTcV0/6jqkl8qOrm5O1VEfiTkvUUQKDgCfhvMk+X//Sv9b9mHmJLDgWJlJzIlxaZ +Z/WjgDoBSXLAIovgcUOwB63OCF7/mK45z2TSdOhStpgPq+mv239BXQnTJnBCHHxUv2kjt84G/9n6 +fi2doJaIy3+NeRruK/MA9chaTuc8ncw1hSR37zccsi7VVrffU6GIT8d0Y6tSEXO2Vs12iVeNQSj0 +nxpncQoEFNhaVlYoiVZUSH7t2DqDMVOXrgNb0PzV+zdRYLEYDGkTLJhAA4gG2JDqzAM6W4+86Lwl +/+apYX8x0+pqt+6gLzvXU9AhfqRA+YiFMYw0outekVTbun4KhxvMG0gyXz1x5CbjGUoSeCvwn9DV +kJKxjwWnjwgq9t7i4nvrbza2e7vcWflrFGAcAqgK4gEs6TkRLAEEeqGXgbvBJKp8vx08dWz0xzHO +AaGOp6kJwsepiaCc7QkiYCgVZOkCHsXmeXzZdpHvzTdXR/HOxoTAP9TYZZu6tOmOaMbsoFmLNBQr +rczMLsfF02+khAJ/B74r0mx2LrBNL/XtSUHMLllB+wvmCvKX936nyhFsc1IMoPqJ6dkoowebZzaL +ZvbNXq81HUD7UOIwNhhwMAQVIAcqfeDE9lz9s2vEM74FcNxnOYESbKJEehLGDHvkQgf9bId4nGJY +5Dwc2KRZRSeVILC6h44CBsQvgQru4PIVv8gPEfv+ak7aQz07/f3i6IwGl1SjdEXYgjX8SCVeaIts +tme/CjZv6rurxGk3/WF14NElWxuBQBTKmeATkde1hTKxAHhCqanv3uZDfl90RT+znf20RnM97chy +fLGipBWeYFIQl+W6WI5djWUXdeF9dLb99rGgtgS6J0uCQ672CBuCbwSUtHECyp9DGSTAiJR7CT2P +U9DXZ+5mzPe8rqAC7xuUrkCCRk/3UZl74Q9m2Vvc5m9sz5cUjD+bTxVZ/KXnbBIMkzfEP0xd2X3A +pFjqSu9wwDqqGKlK7SL+pTFx09HLPjXG5UHl4pwXK9/u6ApZCXdBANM9GFiG9oQSNAQtv68fiXjy +w0Xx+duf/o/7Lohy0VPTAKeKLcJGe2bM+Sa8fnI+8cHj/7vpsiT9LDF8hHKGEvoTphkMOGlLf4n7 ++vQWsumS4le/kOjZAf4aBfplHLB2QSqbJ5Li/rWsqv30yR8dKmVneXuzt048otCcWHJCklh7h6x6 +3qagI2ewgw43uL9q33ouyLquXzChkroAGLLV2mJ9K7hT1QGhUqL3+3jFMaZt7hQIYPODHRA/BCEJ +rV2iqo7PBNVKcRP+e6NiFDwilsTViYWnyWpJ185XSLMW81XrPh5hNvqtL3DS5fpOCgTpFBdxMAZI +mRKmNZXGkZ7aJ1Ejenk+iFuRVWIUSGjXIzQKE17CooXAsT8+/SEeG2v883mMFnp9b8PHvR5/58EI +l17ThA5SwFV8/oXc3Cqc1GrzzmxqJKmUL2jPgB4yuKN4sbLgvM7r1MC6aw/1eURnyhWeaDvcMmKD +i5E9sdDfnFf8LzwZO2QocP05r6PP5/JzW5YCpLlrYerCY0GD/749A6sOv6Jno+LqAVGTiAuFXJ1L +zo2BZeYkrZ1swDCsDXjGCeBKyuuPKvzZpfbS6GP+AbYLGUU3LZe+ozNo8BnZ2RH6ArBlg7S2DW2V +5h7JPoZBZZ3XkZW3lLIIs/52fZwSjcfZg3VHxcfs/b2aXMaz5varocRoErxNW7dRaA/ESPDQMRGf +1fyDlpuxtENpxhMqw9wzdv0sSRSIxRrCKhuTNv0erveeuvQlt2Lrnpwvc4dVKAGQPUu6G/DpO1rE +andfOqhI35v8TZDJDNmpoxBBAQVLkQPzCwgJZ667694od0ndpDY7zMD/jmfTBkYqkBUCSO0CZH4n +cA/3HbBt0Uiw5zDT6hbcqFqZwXV8MyVuITvvQnJeYDiMRvzc8w57Yf2HaKlZuXxtPWXF8xRgYsJo +wLGmD/tueGgj70atVtonqII3J97d+UQBIPYNYN83EC0F0c5wjcG8elPPhwqD9G0DA5KK2q1ICijB +L0ABNQLBXnUim23PbJO/kyArCmN5QzVOwvUAmiKzENOsv33ce/DdhpSdfKZbMhtFRy/t4N5PiQCO +EQNmE3Qml2znV0r5TKuaZreGGre5+tymG47dj2kG/ioAgA/O7nPNsD3CX083/5R1xD3nbrrzAwog +sAsLDaYMhWofsVmL9O0bm4y/eVRqrK+w0zIy9/osJWxxYfKBUsegG+PMdvqehKuhHn1jXwpe3qZE +APvvEYu9UjfHQ/RhCvf4sWe0vIgtp+NO6p49RwkjdEgbYvCLMNJDvRQ8cgOEtFof+95uPc2ptE+Q +Zcq/cW3YXMwbuAYYFsocOMTdWFjSMrLL8YUUTq/hrYPckpbgSoa1PQoNhvTBJ/gs71Ziq+BrfFhM +/4Y8g6KBtev9C+AMuN0CsB0XS17ulX7IfXRziKP+r53MeMtqWZrDJndWAAHklbTAuImPMlu/bXPO +scz8151fNqbDEcKXApXj8t41l2/ag+A/7csnF6+Xkc5ctRne2gWBBw/nA+fDFrqFUoZcwpPjXe+3 +Gguw20jZbJ6ervixMgpQhyKNmZO3vJFcJ/pKKudxFoMZk+lbChRh8CWmpCAwFkel1rx672Tu2boV +/Z+Llb+Ft0EbFWbxhz7TMMve9votcLrpaVy5Mme8jdtqUThEvCfwKgFqpHSzAsc29Qe3XyHT6a8c +tWhunbGAU67WWJQLjviSMQsBYyPhFoySCCPSPfs0n5FQmJxI7oEXK8PgyMP2tTZLlCemX//iDvxV +kasfJtSYllPEKqZge0WJpyGaGFH9l24Gpj8vnWDUGKZ9DW8PPg2ENSl25Tj5mLGSIzIIp1aTLuhb +x3r86KsaKhDhrwQzAYBe8wS5WL0UGv/EUXxBdBvvbKRDVB4cAlYSFraa5wrZSWZ7mabge7d6KdNx +cWK1VWKXIcBKpzVhoMYABy5Jh/cXvxewiiVx7vVqLmCjCZFSWiuTanPT6h3yqgTCgIIa0BzcpUN2 +IaLrPN+gmpp9inpnL+ShrFIFg+6XUkChmwVMWtLGoBMl87ewmRrvhyMOdSrKPXXTf7X6InVwYWuA +j1LVKvmnw7y3VPpR3xhHvsdm7X1AASNYQKQP1W2T8PSWLq1KPLN0h71LzdNYrITEUgIq7WJjs/Tc +DmBAu6894zYf4y16d+/r3ecOJkgnmoZRQqGolySaYJhYg09FIuj7I87U1JipSxwVX17697ixaKZQ +AvE4DPnDFNugd7X72Yle5In+/4ZUubQ+fy0wpoSBziGY8Z64TQWwWcEBwx6LccbgXdFApg1wVzrG +efHZcbFrPLuxvTZaDy2ycdaYVT4ILUHpqpYfjaB//kL2ldf3PuxI9jvfYDfxHxecOClirkiyzcLQ +NwGckEA6A8ddEVYoNAraYImTVw2R9qhkktq+8Z3sZ3d7XvmlybsWEsbYgUFxyITtSA0svfuEO/jO +s9gtGbU+M83Hqu5Tg/BQED9++ypPmRnal4xCLfz6rxIZX9hFy1BArIGcBZJL67/5qnrtxnvde5o/ +JXfhCO7SBwX+/lWUUIwTeEoLSOpFWuTRGc1imLg5sDm+9dhIUVaYQ1HkIKW7I6Lgp5DXh4zST9f4 +H87OOxDq/3/gJDOjUHZF9spIkeyEkIyiCIfDhTvuzkyRrAYJmUUlq6GkRINEVFZ29k4TLZT1u/f7 +huPep8/398fnE/V+PO997/drPNfr+Qwvc/j1PcjCKDuOuRWSAPoH+TqDj0PN7DddNVyb/VT73Uan +4PZ3Ro9QIVQYX6I3Lf/T66t1r3vbiuaSx+/cKi4IKJMUh2BcwNMVaELeODFOamK9/ZuHqy1859Hv +nahPwtGNM35OkDChQgeQ6IIvRwHQeRcXw9i+lXa+pLPf2K0cu9D80jOTOg0ayZedQ3gY7zXq3I/O +Ceg1/yb8Ve03FAH0xsEClU2BMcLcrDtZFV/UJxOi+4qd2cfh+w0pKMbX2xMeQP5hdhm8Ycx2aSWZ +mR6Lu9wluC78xj6gDhLOHsn6M3AjS8Lq6VktztqzWB3XTVt3nTpEPB41KJa60BTMvenLwX7mD06e +yhr2khuoU6RkhVse2ziPXr0q94HmPHbkS/aVuiNPjKhjpNNShFtVFzIVbmBRi6/8+Ger87u4al+2 +pnX/gQZWDmKA1XJ7Bu8U/2GF8qyFb7sXQ6pq0p4jqIsgkmCPQYw7fkf9EFgjdQx2oAjFHz5Yb7Gn +EyXeyk5VBAD0uUmxnPKrF+xnh4nsyJn74l1Y+5Aq4A3DRzI1BRT29j7eY546oyDEeahqD63svBwE +BCRwo1wJv4GPODTrKr3MzEPt0ZnNrGaH2fjE3OnNqICgHoPv09shmZRqnoaFf86SGsv/woXa7oeB +gnB7GCntlFTVnTSjCYpNWNrPxTFxB4OHFRpi5469Pz88xAS13xC7ieG9ST4/3Btv+l2/kB5zylvF +sD1pZ5KDCxQETkjArgK/7KfPD2mijfQLLDbTlOpztF+o2e+ZSI3CgI4swlAKXei/WDDqbVu4u6fv +QbrozZGTU+oQID5uAXqvvCsvvb5YSKcxwSeVxMWaX5TKBLW6EQcKIRUXCJUA6UooNCGEVfx+Ci1D +Xzm+uCdSwm3N+oHPW2J3ryYGaKmhA4iyIEbDiK7isD4pg5fpl1ozq7Xavc9vL9ngKfB9NUnE5kdE +/liqdLH1zVv82RzN5wyF7cQHxWCfVuHByIJr7Wj6hp+Xs7C+bl+sFXNhzm7boRCcXWcKA3137Ic2 +ZAb5nczvOiOxUzGL87qSU3E5FIFC6wM9rgAnV7347n4T76zuvVMl108fO3TmQVcWBEHuq8dR8PPN +ZcoXA0RrFZJ+uEoECsgUJqdDUZilIZ8dKPlnx6XEd6+Dvd5/ldjk8+38m29QCHgQGY2CuTjDcH+7 +UqtoGnGtvLO30UD3NZeZlHRRIsvnPKhhSyEFqCGBw2/LnlY48PJOiqOd4Lh3vJ6jVM53pn/j+JQR +/IAKyl3vdJvvRJXR1TF5Gi5h48YKt73/lkBcxtfQiW0XF0kL2Xs21aL64rOMabnELmo0aROWcwrE +4qffiP2nS21R89HqJ0L4LweMIjjkXx38N477H/7eH/tnjW91uHv9Z+1mzZjJAdoa9tSJf+NY/NAq +1Ur4IiojG3hWg79mS3noF3MPdqi9eCVMiCFumsvR0b2p68LxbNPxJMOctVfp8jqp0mgUoYM9+MyO +I+N54i2/On+1Ou899WrPoE+7bDA1lPz40oUI1cWCePdkxQKHzv1/Lnh/XWCZosqRNo8zr4+dGGDa +ZJ42qXmb4YzVLr2PI3XUKNCyhxEt7tDQx9n1kW93hsY652aMmXH3as7tXJUkH1ZffMuqwpwY6Jok +jG+WBe3YdvtrJZSetAQTP7Ulu9Ft8/r36+8Hjadde+UuHCkHD10VJO2xYIISea6+2wdMJQq1vfmL +425vOhXXDNUXExupiQJ3BG9CZKKB71REuNfCYIDKDtVu9aj9rz6Mb6MG4otTgceJQDcFc1V/qxzN +T+TT0XOJ48ec9rt6//oHumRobdQczGOH+THPzetL3//YlCV+YzjyHzBo1YDhLp+cS72uEo9tdjjm +56Vs+y4OPzrSvDoMxoFQ+a0pusr6HDb0v2gewrPXse0toEoByXyk4dEtlqUWHrrhAttpKfrLm/0P +1CscyFmVJIJVQR5a8cpsd76KG245fLpNZ/ZIkjl1EONOsWbmSIuOezjtkbDB+nNmaBSHdnTZD/xD +AGG5fI7Y+8lIzHdLu8vk01jpEBZRkRqxVcml4w+TwbXW9q+8F/VUCkbE8xd+chQM8FJDSZojeDoa +p5mTT+PI13XcXFH1XKnenqEtrY5Hzp7/WvpfBYE2Gc0jHfeyqKmDrH2bKx9Fj8wzpfdQ48HCv0uv +7JQgQ7HSRT73gZ9ZPZuZJcW3jm3ZujpKPqUNI5Gwvtvp3Q9VStfpeQujhENFFVenibvETpmF6Yv8 +8tmH8sbk/AWk6c0HhKg+OzxJvOOUu9gFM0E03L1uh4EA4v36OhaDTauSLqDHdSlDOmhxq+206353 +ngM2isjo+PPS8WwW1ATgphPxgQPoe0nvnWNjC3XFHbVCpenzU4E9AVTXaXwVLhQab9DCwC2iiJdD +p/Pi9Qd1N2nOKHnvsV0X1kB1/STnl554E6Prk17Talm0WqjUjsf+H6QNvYL+LYFQlQvHO2VVBNxx +sJHNU65V+LzVNeJq4evN/+ZRvlhvvIc8K3gy5k2b1vbXw9vnAnTnErb0MB/4N49G+SJdsGh8xlS/ +s6GGZ4SKqdXjzF/hokpJjhstc/8tgvj627EvPd+uZ/Hw29hu0/HueqIB6+M4avTyJBa++kFE+6+k +TQI6WcIGJma+tnfZvKmRS1YaYbya9+yz1W8ytBgTf9jnLBatKj/hTXVzJ8FkU3SsZPdLSZ0GXVtz +6V1T0U5rsi4zQJlQpHol7nBPb7xygcEq7VQiJFeAJVOezb+C983CeOM9zsW99Xo13XrVEUKSF16l +ERa3UVSN+C7iPaJzZNo90z7l/neoq5c8Gsvzsl1KHf/IGF22n5AT0qi7wSu+NjsoHApHgtUeCCsT +0Xn68dcnXbmHtKFhIZ84GKSUdktpsQ9CwEBoFkgN93Vzx7vuQCeH8QyWcZfy2Y9jEhkTHl9qxsqj +70OxoJMZjA4TrLC1xyQGIiyxzNOpmbDtyQMl9g3HoMxOPEjmLvSCIX3xxxUJ7vv8o/b0BfkTikXx +vbt+sJTx3ED/kfkvgvCbBHjYk+RfZEp22+SZ+oiVt1tUp+WbEyw3MxhKJ14pC0CvDIzARbX6Dk/E ++sfukGbeG5V0GvIhAihwdh/p670UTNjTVbrPsBVuYsxSHdj7Up5bgX3r23/AAFb/sI2uXVfa+VrZ +l0k3jSC/K9ZMUHsiiLkA5RpQ+IT5ct+9Nv5PJm7offl+cYbnQ09yze3X1DjKAzONu3emvks+5tZx +yXb6VQui18BJzmd12heJz5gAX7xuRYP/gmEASozDoIBFwa/VokuWhSpOPGzW4S83dd3J+LMSOtC3 +4goqLfaiDpSxD0Jgvzr8WPNFEsf42vOnskcVnVMu64ZZ14h7bFmTqiGxmgDQwxAxOVPQGfaqwl0l ++HTOdsm2vO1C1BiKYckkntbYcn9jhY9dG4aneqr41IxkGFWY6FcBfgOX/7OsEsZXM80Pa9ZKYhYG +r4vT6sc/pUYj4XCXvcRhGHJPXyfIYb+4nrGm8O6/pw7eXhtoRQ0kW0xw+yeSVGiD6DD1mf2uIxp+ +bizyL8fusfVihb4RP/dTkwVmpQP+SAQSf4wa64/Aa+SLPs6Xoz8bTWgzw3VOGXB+brqO7aYmBf++ +yF1a2CoVtQSV5i0Zlo1ttE9u8EomtzlTo4mn44hHl/Vwuxk4el4+3oMtzC0yzlIcu5fzZscXjoXy +bCpCIKobARIYbnzzzPOfUco9le8FK+dDV7HFQu1mS/ElkhHH9lwil8f0zWjxqw9ldQUyXSqKHtOr +ke5YrLcSAFbatSc933yI7vRB7lz7hM/CcnqnoUwgErjswLY+6nsTp+7BJAGBGI69w9ZSDmpP/64G +k5//56xZs5juo7d1yAwdelCqcaIuGsqtQULBkltghwoghEPmkjZktw1B2/w47s8pW5arWCVYfgE1 +u5og4tkagD13vepESEthoEicGve7kLn1YQwTL1ZjwTRW/CkSDJZY4OXY98WM/kt0k8KmfPzx5puy +fET6tFcRAiDRFj/2+9Jz/JpM3Wr2MEFFZ1TvziEohHRiG4BaZbe3a/7ejlToj6n19dyc2fXxApQb +ndSgFIckG9bOIDfyNJzXUvf6PFI1jTqYfQoKAfYoUghiUrzW9ty6jXG/1JGfnMQckvY7z/BTg/BP +Afwsh69j+zfY/byXPpF8Q/QyHXPnnBVUEImkFoAxRPxazZg0GCcYPKJHm/gkX/7d9zlrHhSUibmE +urjgy3jhJgBYaR6skIsT5LlTJTnOWfOZcon/uuiT/neuvgiAsjiXBFHWFws9XWR+6bo2b3vRXpGI +97Kx8RaGUD4Ukgiy8FSRwLEofsdpI+WNtgzFWKNTXBsjHVZHCV5t4LAnUKwXjltYXMC7EMhcm1R6 +6astMqXh6DGb7mg6kfGvq4kiPgCJoN7eDyrhpqmXhav6ttax/TTshop2LXEEly0c6YwiBpwvm23S +e3LXxPxhr4CvNDtv2+frXHyryyDNxdmTOUrT961N4KLb9X9HMLxK3M3uuSqKcLGA408M7/t4x0Mq +8t5BH9fcT0o6Dwfa70ZyrY5iiM99w4UzhbNieimjRq213cMBbTaTqqKroWB5NtJvYJcCwjWgUVdi +PDsmhGyx3nbubFn174M52/82/UsabhxbkNmFi/eEbBOVdwwF8u35y5zF/F7ia9GXVUUA2T/4p4if +EMaO5fu4/Vkelr3p39tmxM94MGv9qg+DdNbxIvLbvv0HJNw2TYTv+lnsecNmt7zrqiCoOBF05Yeo +jp+yHp0pTOXiTtxDPEk1W3v3rAoT1aYep0ejrkVX6haHND7ySVjZhWsMVqwGgqoTKe4OSHhSrRty +P3lUc+iUZbNgxyWz7g+zUKGGJQnEWoyEUiBEo87920kEQvtsexzc48BWuXMn+E5pM64mx93fS05h +yf0R6WFhmNCmoLf1xYOSiJ33r8SY74cyM1bgSBT+GxEn4fM/V7nrsMyxr1ikk2dt+D6qaMZD6b3L +pQCgbWFAWHcy9x+x6U3xZ1819bS/TVh15pESmdGESXRVrXDOs9t945XynRz5vUbvDet3eqwuAJ+S +Ci6mgACOOr8CzN9h3k4Bv58pTgc12dhGoFxPJAGAUkg+8rXEuwMFTxR5mFye7Tr/c/8Pu1HlxdX5 +ACzw/Ihn7H1ThyPfeiOZx36MjgTmP5k9UP8cKgdliQfSfYCbAE9sL93HVmYZ604bn00sp19umB9O +bEarHrVZTQ6h9Bu+DRW4s5HGhHr3SIt5sKGe6i/vB7N//SPylNfOrCYKn2AGJPQtaemWIhmVyhl2 +BcZC98/s6hUrDjDkqFlNxtJ94fWF079NNgQMF7k+NRBm9TzAJrQYe3XVTYn0A1iidOk+nLsrGcbU +fhTc26j9tZg/IyNuMsT/v8gBWCR/SJG8QqhXDtOXy4m1mTJ0D65A+euXscDeTPjTFIV3zdqrvfaq +zXbrvsRPZ/xC9tXd1/etrVcXAybEEaqfaq170qx3/waPDqeum+zR43GMH05DxSpW0JaEA1bgHLll +sUmq+Mi9b0YNV4Mf2Eo9tC6sgAoYLu0PcKw+YXfEF+cAfsC7DzH4OIb4ujtz+rMwC4Oyz2kzn2Y/ +ia461MjlEYd9qa3400BrSc0d/JVvlWhFR0d8H676XnC/w7Bwt0CyXL9ik3vtZyPuPLWZjUxmUlM5 +a14mR7uaCCAygFs/nQJR4In9WIf1E+MCQ1vLGwO3raXf6Oj83eDef8DJll+SqPNbYnh5XmTbfQv8 +2XDod8+GH0cWoVwuq4gCVfONf7Ucunm90K/Oz3y+vCf8+Mgehn9LAdeQnehHzBWY8YZR7XDWUkxf +5GfImN9KEnCmXfzzY3bTN0FE6OQ316kj32mnTg5AJX6RUIIhuTTBHnKgjevmzrgzpk1nxp1+47vD +9PqZ1QVg3BGu4CZaV3fGrCLxBPbD9UChH6O8N+5ybmJeDQVtEV8kAijYAKRH41ZAB+I+EPFxd1ax +0DWmhuN3nWK5D3VghWVW04NNQJsO34GccIzRXsHn70/v0Z4J5jvVrYGsKl/D+1sgJbj44u3v1DWZ +qDPr2zY+prs8WPEhRk80mgVKYwX0XKLSSZjTGgFxJ7C/s1/LxFUGBoa8CVG+dwnKrsGgwAPpQDlB +PzihTSADz3qZKp/htHIsYiBipzztmLMwVDgMi9IBfP7Ah+nFCqMPaDuqhIvVJi0eeH9313OrOUjC +GjckYZ64bR1D7KpA6j6OEzMfxN2WZMVTv+0PzU1lxoGAiz2vBKHELDntiaksJIdFuWx9/YhtRu5D +x9tqRv6i8lMRylBhdXK/P1Vz4QYLP2PjwsegV1c0nL8zHtPidY6zXVUWmc4+osO+4yWqqrR009H6 +Uxh5q0ALaygbfol1BQu5EbdHu9eMdON+FYM5c8+KhuwSDnN2tK7+NVyJldswCaLRRhufCO+bM4sd +DVUXZ4lCs61OegIbM1HLUo3mqH0v3p2273nsw+ZHydJz0U6rf2fccAO1rNizPj+23ERLdP98rQtr +8uIc6I6D8hSRhTuWHFiuME8MHGyX6wu+xIBvo0008I08oxluKv3nTpZGWx2D8t2RxS28PRFA6TY3 +d38YsOLB0KDeJcV68nLwy46GhXD22iavt5cf6pUk/Ac5yx1p33dwxjXPwSS6tz+pi6mS935cevAn +lBDg3AGMOCEOdUpnbe6yWuiYcDoYyvVuZ7XoIAwC8kUgsaokyGH+6TOrh0MphSe1AuBY7+TxyzpQ +gSvC8kiyE/bIuzWnxY+/rQ3a1PGHdmPDhZvhUMkchEWR4Ggh6aaHfDsjsFbNaBt+w0Mhb7bdEmkt +gvp6RBpY3OSIJwkLCsPC7qLHVWk+5/cHm9Rc5PEXh/LvkUI1ZM4J2nbVDbZNDAYtG95avS1k6ova +1gcVr19KMgCOMkBb1l1/N9mwx5pdR+fu1xI5MP1UR2X25KqiwOK7S6HKqo6Cjfyqs5xzdz4KHmQI +SnFoMz26Kk99xdgxn/etK7Oi7qbSz8OnM2knXPg1obRakih8rqvLsq+Dcn71IWob57T2mEe8mrmU +6+sr7lATmEwGadFR/HRH29WsX0rzdc3Q41K2z9Z1pzVWQwEL2dlp6bjgd+1OtWdrTM5W5jG3/719 +XXSHcz+UY2slT+77W2Pjod+Ztp1DMu9B3/ktdhtefPaDSoxaJoLoQQd4Gg5bxt+JU58ru6Jp+R7r +VRhbYqF8HeQ80O6AuMF2d5rx5zG7qqQabfvzmTOMS/Y6N1TKJnl+KIwst6LiRLiyiIj8zhTh33oh +R8yPWNp3QiVPr8DJ3kCM+rTsWU4Ue9cj8wrR6W8fI4WK2/4tAKzZBAYwe4VvV9Z4BnzEvghzCxeX ++aaRDGWorUhvXe7lEIEH8XDQROmbCZaejM7SemaWbPDo3zLIH+Kj2I2Hk1TWhSieD/K3lVn796m4 +MlSOMGSSbYpPZ1eetVLuft20DybNCQHJaSI8q7EUtjIznSzjq/hD5lkdpzdd6/vz9IyAju5qAgAz +FR8TJN0/O/q90jOtSeeh319zZzii+48w5BauKoJgL+ytKFS4cS+S07+JbcFi4XbJu995UDFzEkfW +TRsIjRk/ilp/5kb3yYjprNTqV3H7RjdAxfNINBB0wU0efEMJLAIf3EuwzoarFJeV5NDwHvFGsIeM +wfZDZUqThJCnSE9YWfVYTKhIrL11peUzfYH5xe8BAv9i4cvmP7pb4JTWgvfeh3Kv0n2NMTpY2g3y +/0kCSf0S3ZfySsRy+sLwZvbDG79d+j4VI/Ls3xJIN+A3nTwr0HbG9IBdcrHmGzb12bMO5/6N43Ox +CMMQEJPZoOhwXp4/hmUq/0ldW+AdVeEuKOORKMYSGDhyhI4zOLyFtuVQHTdPlD+/WPIZuC9XIXcB +1DmY5ThuEUShPYDMX3BjARw4Pr64q0lxrMe7bDNvPBlQEaZvEaoYPareq/wEyomI/0pkS0rrztKL +4e/Sq20LT1sqGnvfihq/AhWxJXDEUOJzeMX803MbU7Jxu5No8LWFwLtPqL0I+JLyeNjyRMffT6aP +bmtpnjwVNRT89VgelKNpKfntYV9grJ6xfcORYBbT++KMPdHuUhBp+Urg6ZydO4jdU3CbOT7Hiugj +jdT7oP5iekK09mKOAX9Uq6la0TaI1DSlpYSy3+uZRYWykWmHHMudpkxEbx/ZNgHhsVAiZAUhlg7/ +PLrQZha6GMu6Y+6N8q9uWFlyoACEmqpE2JmJPdtAL2DakMBCTUE0X/s+1cm6rientC0VoEjCmrwU +QQfgHLpBq9KzMLPX64JE1/BOvglX2KX8Dxi0F6UQt1p/HElSUzQRu1jDLx5ZpwmJAXFHfNshkj1F +fLT8VyfPKQT8lPPrYdzuWscarpp5C8IAViK0wwFfCm4hxS+IDod5GzDctMWXiqfKXRKaVbDbnthD +sXiFGVwFjzyI3Z8geEB6s+Gkjcu9u8NGtusgYt9K1NITWn6dOU2v9OzP2eRfV/ppnZzqOjUg7N1l +OJgWQ4yfgiqEZsAHM/fGRmtltMpO2JqJnMTlXcFJMgjntCrH4ntfva/Ll4BlzSa13XMIeXoXwrOi +hH82uEkOFI/D7Rle+HRqIG7qi3VVBSQZoNZu1tKO4ng03i6j8dvE4W6zyFWqksAgGaka6Yfsz6cs +Nm3fL1235i/ndH1v1sF7EIkwSuQBEkCNxy82YOk3lCsg58RQpc147+V6xSCX0xovvjE5i09ArKBk +cvCnBpcWjrIiuL8fbBf/rnlMS8F4ffOWMEkITyKZALC8LngzhBGnEyKrzh4/LPn+ulhM/6nvY0fb +iiGy18gk+KNh3uQr3vD6AuYPi5YNPRkG3+Mbrli/OaMBsZGtFEBqoKDxtCv/0b3yc6iQXacKvUKb +TsTYQSQMUODEqSonKz70tmff8+Nb3qbZz13mffn6dOo/cQA8NUtrf9OK67Ga928BS54PT6O0dSAn +K1iImUzhl1MphJXT6u25fLzc+jJf50GHqQWIAKfSkpkKQLnvfuzsiIq1Mt32OiextsLJtPoDxFat +RDQWSa/XRFJjKtRzf6Uz5wDiy26L0hePTSDUKxJH7HxgUeHs/jvr5IbNNp1IXpV3G955RtRCYeT6 +iLBlakVL5nGJ944bj1yVF5N6NOcKcYROGZhSHsSxM3iV/kE4o7fzU93gtq9SfE1hPfUQ+wmBwW+5 +AMYlWds1ycji2HbgOkf8TG47Y8cBiDwNZUIUgeC+xzv1iuPfSDjdf98g9ORQT+eDNzfSUT8gzsYo +r5ZfolkWN1J6yZmBm69E0KUpbZtxlwnEgMdQ+ieSz1leUm/b3qX8qSSSjtE0/bOQ8sqAJBiHJ5yI +JDyjo3vsarYGXN380dYqZeQw5uWPF4Ylq1CuvkFgzZHdMKaPc6kaZ7bcOH1n8eUjrEBi/cooFhkG +6vJnhzgXB9isjew17J6FIVx0mpuEKQn8KgjUuEQTtIh2Pc7fYtq5mjSWWS7bE9gdkuUrVo4xnPXs +i9OR9ID6rXIuKK9lFVn36dedoxE/VflqVsHqV+9P2+Dq5mUV0cEXAJyvJr7DMJRT89YZFb1b6hum +/Z7LPf16C+O1HAD3ptzcE7GCN88bjjNrhtRwqVhK5pstcyMD//MGljE/OT+cguKHgAH6gxfBzbJw +Yyx6EFuidsFXFlnZyjc7gniwrComoewczBsBlGQDPzAnWydJcf3TeyKfu1Fs2m802zVrG6AQQgUk +gZum5xt3usx5BTM3mPkxDyXWV9lCXI73X4AVfl1QuEcPHLHHV/0lrWFnW5UrLt0evMzPsUlasN7M +LUBGhJOqJEKUjpqsZIvfu58zHvKeUJFBnKY3HBRTXN5ic5ksQpkPfFIu2DzGxxeB+5PwDBNhAt7e +SeySmtfUj9s6tFXWvj3wjposI1J3JBi+ZHS5THVJ23VfV9s7H/LNdm6L/GOj9vOfMBgD6AzzuF8j +Jm5Es+tjcrktZ9ab3awQ4DIrunBLQuniAdmwRLry3YYwDQ4xA3F6KGYpXyL3yKaHvPvMb8Ho78sP +zBZ3Fe5l2wtBLDV9wqcUIVwR+E8882uua+PQ+20NcNmSyPZnot5a1mGr8sR2iQTfwS3xS/PRjvxi +rSdof7zjKJSc5wt9/W8enK8nUm4q/rD94C86FurCquFPH6wZuCqJ7wZGKOlNPAhKM9GQXvu6ZXuI +77FR9TcSQa5rTkj+BykYMNQCCPj78a5mQR5tbtFdaaSQZ1vF7xlLzX8LAMnMzluHqmF6kVKH1yrB +ZdncEnn2rUaCjiqJ4di/6VsHRyadrUTZ1pk03+Fgh2KIA3nF29r927hkFMF/yFG+qlUoRAsx/WQ7 +42o46TVFodhGj944Ne1rG5e0N0Hku7zvPXtIkOAXAUYzaD6+2xdocmzcYGFkq1VnEOZOzGRxIQQH +1HXFvRRAHwb16f1bHaPr3XJ+7MmM3V8+FxNn2nENgvKCBQBJX4QeOkvFPusuX1680jDpYC6pc4NN +OXOz3/O/nhA4EoZcwsE8IFAp9wZO8yxl2pk2j7fdGcXyp3DI1VdE7j61+Idp4V/CCPeyLP1OOrjs +wexJ9r3nLBiHcuuk5NXqUqEWYig5AD7zdOooE0rchLWW4Xxu5sJtDrPZMigcKPMFdFWkuBeqX1D2 +J5//2bkSDasbSIMZ/2q+A7HvoFZdqpIBGQe2Ifn/VN8Ytkjq3q/1UiBe6JtDNaQMDMGRvj05pjPq +0u975T3iyKe/cqwyt/txQQIBwM94Y8O1u1Z9SLXn/GNeWie6BIw229AA1OIGaPbAAHYDDjbCPfFB +CqYrW8bPJ77o8JF4ijn7KW2zdmdEHCSLxT8o0pcEGswCAqqzBcWKmKdiuRrdhV+kjprZH8mYhxQA +TpfatUPbeTQ3Hq/aceuE6kXJ0ZpDV59AXA2mWRIeYcnQ7hud+36n5q55wZRfTJ8sXXRjDgIhde2B +kbUVjFQae4O6Fnl3gktc6W5pV8edBadJaBbfWnJZkdnge/HzU7mmyIyzwws/hpMvpN4OZ14FBufE +TMdeA65IBvYB2lCnsd7RhtjqbggEt87h7Hp3wNYkr53f72QuXe9YeD18nzsy7ohs2d94xdPUaYCY +nn+87bvAldvb6hKZOSw7T/CY9gVDEGBCOHEv90cDdbuBFYVQWh4cd5PidHejqxi4d3/qpHPts7k/ +KuckDiUJ6JNKXLApSkQa3a2M+3vikT6DyLsm35cbPmhx7L8MJQRfbJB4Q/jSj7iXjlPk0cR/xO8m +IADGl5p3nui25pHObR5LjB8VSh+m21UPIRnrjsCHeq9JzjJs/VOkcXCHeVpKlvTEPCYb8nJANfIH +OxQ7gWOcVAYQeLh60j+UX79UXVAT2kHPUm1R2xp5H0oI4Wus2FGKOk5HpBXwBemob8vjbX+ndEW5 +/PMqNBZF2lwA2uPM0EDGjuwrdjuPlI+g8g1M0MWGq9BgmgPZ/AZEJE1UZxxMmt9NO+p7Supu/sRe +gR1QewXug73RQEE9Qp1y+HeBS4YK2t8t/ELT7z2FiZl9yYJScqGbL5xvRA97YjhKbUdjiqY+lKy7 +EvL0EiQMR6JRnp6Et0z+xSc/waVQiQ9tL448vXws/NRXmlNJdJASwOEBvj+C/QeqDkJt8+/uSkR+ +nc7xlE4s+dbSii5UpYaDEb4cWA3selSNbvlfl+2KPKbNfx2OUbveZWn7x2ARuLt3RaDx0z6FR473 +2R3tIK2zBk/HKz98Pnvfs5KaFDiYmo+vsEksdZp1/lC5flvq5SvcFzDhgxseRDLscF2dJ1827n3Z +xdC//w3HA4mIlkeNqX5rvm69AkVjgDP0BFeg2Y8D7uePZvFe2HigWG9qW81TTPsYBAN2ESer9QfL +fsAlcNeavaFFf4NKUaxk14RuGyUGXLmhepDho7VjnvmO7xX9MD13sZj3yzdPT4ycgpwLEmcueWKJ +5ZNHa2M1DIO+b1j/MjuleqeFqW5kqfpKCExrXypC3nlHaFOBxne7X/xXjmWa+GZrzP40hkCcwWyI +/KuWv49pjainquycCQto5RWRabtNcTFu9ccuc2I+j+ROf3VH5BzcxkNlmw1rYd0AdzQkBVzs8piJ +Xe2JWKLbBocdkez1YgvvfpZSXuyNJObLELrL48j4/taEiPWHGZnfcp66IbJ28y6jpA8rSdBhTnZE +E3zUa/cVF/zgm/8U6p4hW8xY1cfpi/1MAeJT8Qh1LD/3mhSOsGbMlF9I6911WGVLbYrAvpWEM2At +4yY5eG+qOTf7v+66eD9oGtPqxPFDvE/Bn5USwC1ACKDOCv7I6u+btwqDtmpKvdzocrYyT8bLoSjn +EQUDPGtndxgCNw6WPm3xwZXft4ZqKm6aJtyOe3rm8+X178+uRoLzAQAFk3sidL9sroQxKxQN2xrX +lbmE1EOCgPZE7rNry4xnuDa8Ls1jfl00s98Iasso43tIcKkRMoAdu71Nm2vNN95tny4ocFt6fqnj +kuajwIBq3cS3jXAB+rzh/ZpDW9Tqapx1TrJ91Ir74iNZP1VRc5EC9kSAyrwfHF98TVEePI6U/ixz +8uvdusKWdKXGwffafgwOXyhfBwWqDKAv9KwW9r+5rmFseG74lxs8V8ewZzMkCh7vDAAr0Hoi8FXC +xgVPybDaGt9/3DSv2nJZjWeCUTKHGrv0sWA6kbWvU4B8w/gFpcUta7tqS0bfvk9K/zeqCJpmP4ou +76uSTltz3M/yYUxzZy3DzR3/RsHndCbi8/N1t691oMUPnuhIF3L/O6Dk/28UfE4CdS+n6pX5r12x +kDeW2EVf0V6peRQCBUI0YBoMwBx8c7NIdNdc02dNHabYupffZcz6BFdjwHt8YPkB4elht9jfwPv0 +w64iRp86cRtqEJBpR4xhyWHRvhjCFAAnTc6DQrfgBN219XyOLlk5xxI+H1ugIodYVQ2Dwg9jIaMc +ZuOOD8KMEccupkuqTUo7LtRSQd1w+qK3OxyowOfpAQ/EaYCgEdD0gle3YHr0onWTvCYD66Hsj2GT +ElQk4CvjySmCX3765D6tvT0+t/4q2OpufVGqanxu259VOQBqnLz17GwutqbMebZv9JaZ/8+TTnFU +IZx1hsI9LtBkUQTfbGiVrwaDfYVJS7HA8zYvgfiYSOYN/wkHyw6D0y/EKdJW2Svkl9y1pt7fgXX3 +DiOEqEoAE7Px39bfraVX2u4Nl0A8c8P8wPk83zfNN1flAOjk5iTT2JcVclvZwhmwZxPLht+0qFKB +cEMY4Yrvz+kjkai8Id5COFlDmjNeduPG520XoCFgVYMj3QBPONFHAUO7yRE7u5/erLSOMXqPob+h +d0CensnjrMQHOykFAUULSQ5Gz0+IIzQnCuxHNskaPR8+cTPPS6eMCgIWEVvRrVPR3K4NdS6P52LP +qSinK3uFZ2HHN1HgSNxGA5wXx8KJnpHUu2vGBV3LBg4+CNAVNxZ5bmsLG6HAUEgkMPbwhTkBJQJQ +QvHaMnLgx1P3825D2TrnlVlmrpeMm98QocrjK5vLucK8EJ54K1qJqU5o9/1Tr7aXYLl2zzwx2OZ5 +lRrthlO0kWTV1H/Y/bKRO1KYsMb6B93LGrObM0IHKTcRAuuOAOqnLeWzH3/2PXHNRO0jOulPR4ro +SptuNoZTKDQk1t+LjGyIHFINTb+p1pA1q3BYwtecOWxdADUSiZJzR+Efc3KppVJVsLyCgv+PjHnt +8o1PRHx9qWHEqHf02PkgGfkjVZKOt3efflc3eJXjohY1BgOcd1rWT/VaJw/r1jizDG+pXguLPvmK +7Bt3h6jSJOcjgudK46iRv3mR9oiuR8jaOguXCy1UKbIsCHyzoS2fIkI5JI8bHQyXyy5TTk/a0keh +iRFhogW29GT36El2ml46xeSZWel3t2frpFzU7qSVNOh+AarTYbFAfyTS3EFkOdBuzsX2c7qdSaWj +yUxKdb3qsToLUK+ZbL4XnmL4GFWW4K807ntgMe37fkqKsObjvyx+QUJE8ro3bitOf7uZrc/m0/zO +c0PDFEr6chDcGnfDhgP7nmSdYP7j1gZLzDWsmL5BjQJqOmCwS7O7ybqmXCvs0UmJ3qo9jZNq9EWP +3MMpWHx/vMfRTZZSqqmPrTizn3z01O9QfYn5SnkpWNQdX/oWN6uBY7YYfKewH3xs/IknJFk+99Fy +6jRZ1u2Op1AFCeWEli/zABye87k1e6+gW9i8UN+dDZfe3O4647AShju7uIOfC1o7r6Lf37kw2HE/ +zufugeRKTK3pMYpBCgLkuZG23/l+nb9z98IpQUW19PnP2k+eSd+CgoBrL0RlRrCmx2izD8aKtv9l +LP7yvo6L8lrcmAQbA4O6D9PrONPUxYkBn2vVa4/+GfK5WHCPgsAf0kYiyCccsn52vHb4zY28IZqh +ev71mrDDflkUIBJ8cDgNwBPlBuwkAOi+K4bVi+1viQU2i4brsFBBaP5XCoUfCMY5AYlCAVg0jKC1 +s9sHmN1nfbWJK+D0VrZLrR+EkllSoDgiA6xHzuhAb/yjR0m/PWi/a2BjUPzVr+t3HzeR8q+1WJUG +fSVk5c0uru1rdGO915N+DDtzG27p+kyHKXg1AQAT9OrtnsjRR/lMN+waWBwV1w2UYLEUDL4/Laj4 +Ew3cIydCpG4ymASfLK8oyw2NsvHLVqiiwhEzSdasEWBgrz3zlSZN7XTykN7b0tEJCqUS3ycQ1Mfc +vICINCHHyUHp9GLVjPEW/pcORad+HkpOT7vIRMniI72kEsugyVvFa3z4kYyx5G7JHmajd2aGtEeH +V4KuMMLEJthQo2mCEnVNjXmNtoEXgg//fvL+s0cjBUOWWvpAXd+t+VS1s/OHpsDfi0Hse97a21Nc +j8bpKC6egYSHQuguBE5RA6GbUQ8+fTlVYavvcsTTm/+d2NhKGmhiBJixQFKnK84yxQKtTXzB4idA +ryvCRCld0CuFd3/6qv7Z0lk8LvdEfGS02f8gCbQDy8SM3z4/mqz5XpDukZgMhyHSJ+O/iCCkvwMi +pGalpfJqlfcr3RwuMG26zWz4idbwv4ggbR1d2iXzvwa3HkTlTn//EL7n3O19FRSqNKQAcFiTsm0m +U6+pOR1I+f18ovKE0aFjZe6lJRTaCHUxS0/VoaXL4LktV3OZc8DaE+dyJlmZrjz+z3IAAVumstcH +StnbDXt4MArmV4QhmVr+0wsGG0z6gh1JMFi4F2HCns6uvdnlPzQkdUtI3s5vv7O6Y0rIf5FGEEKs +ZuLqie+SsQa5d66gq5khT88/YTBTBq59/+34fxcHSGBbeM/yR/aLWJtqrPWAxonH7g79B/+LBH8g +KxXMEKP4jpu+bf2U9/r1y+1mEr9EnAPv5LG+oXCbrCKSQt61YLOFhNZ3W2/RrB9vS27e/FZCg8KI +wMkjkyUXoKKgBqDe+7M0kf23u7/M370ZNPZQN5yHxx0KReBsSXzOzeOHR9YpfmzoHvws1LUj+6cX +PYJC5XIDO6FjUc4ocHGT0l9MfXQjztAmpnvzqY4dFTaLR+pWIoAbD+MO8yAzTxJv8HMn2x7j59sT +GpaxVyEmxE7v1yoYuXdbzT7c/VJgT63Vu6rsWvn3W++KPllLgcJxRjpgowPeVlcYwpNQbJHR3+t9 +RrzEM/ZxRc1UQcZb61lk7lOwKCQKjX8mpDoj748fuWXS43Wxu1voh/Jo6cT+nZ35KzkEkuwmza24 +wxIn2u7v7K0slAuu2BJ9zyGBEsCt+Z5wGN7jf82nZ13Hgi1cUEu1zhIh1eufVpdGSRC6orqChXQq +3G0mp6Mx40+sdTcYePcGLcR68EIgKA9iSRoAMpQuMVCRSJBZY6ToPGXiZV/QWENhSyK8yXZMoB6x +E8LFBQ5+MRdHqYPcG46lHCmoUMqXZfrR1ze/biV+HEOmp0qFWSTJ5NeL3kaeiKcVfp2jfTr5JQUA +1EcBrVHiCUbQnHvZcsV975Q7/RMtgbRb2RcsU74MQJJLSPHinuabbj923acrSdp+rdT6mNrtLSsR +3AYt54XAeAEdAgAmMDiYR+jVouzc9Jqb8f6Zc3MPNnVCMKuY5+gFC697f8NEqkalb6mPyhjItfNS +jA6Ckob70Q/vAGEfWpv0xmWPGTJzsiiCUT0C5ulFMUIIaaSE123OIOzP293jkiYwyFgrfGD07mv0 ++ZUE0WFI8KMB2O3ep1/YnwgcvZEsZBjG8ER67G+fDAUGFhPA3SMAnP2TsNm2179Z/VWuD/2T9iSF +D7xh0ADhxiw8/AsNTVra1ub5XWbt3HvQfOe3XkgAXygdA7RoxpBqErld9fA06dFF0b4+vPC8J5mn +NXh5KQ+ARsKxSwYtEH5Bkyp3i+y5PIKVC5H0mcroD4pKsaxhv+UJhRMimh5wuDfuBfoRvUHNs9sY +k0Ytu3avF2sqvyR41oY7Y+K/4AC7v/ZAqMiBT9dcihXE+C/ZNRnPqBRTsCiiyxps+QtOQaO0B/1N +B5oTaR717neqPuBYKxDdCsGhMTDiK+EtuJ3LIFslwo76eOjnJmlBm7TEQQgCZ3X5KYGj6/sTN45J +PxeJGz1uA6eGMKi3+T8vUwHA66tyBhdDtj5dSNn//hf9BGJbz4taimUc5YzxXhbyWpvDwhT3iuGO ++rtdHVsqX7+qvifqRgG5ggFCMMsbeA5A60UwI5KsiOzLEde5AqFHNhIOX/K2HTUN42XIpZg/pHzo +JZdNVBv/6acDsb98ijTq1LovLbyD74mlwAjt/5xQKKBIID4OAMBxLGqTFfW6RlxmVbLnp9d69p8/ +7kgBA8EC4BSAHNaX2BztyUTQ4ano/buKPfr7M8Qn+OrZpHRXckBZSG93NAyfwqaH7hJNf8R8beHa ++x0CXacSr+VwlFMShLKHf2Ji0rF2w9f7F5/Qi16MpmErbNakuBgORKzI9nvyGMpGE8UX11U9pt3M +ZQYw3CZNb3flaP9TAGn6g6ZYw342bVTG9VE9+7J9g0UsRdtbkil8nStFgC7HvewjxhdmnHKfJSXb +t9Fd/5WuTOFYxa0YYMM+FBoRBBr6JI3Acu5FoYdt+29WZbPHdYd9hgU37qMI2XljPPBhO9IRdZJm +sCxWWP8lU11xZqEsUMFjIXOW7rjsd1kK5w8gyxmBdvbFe5PfvNGwVKGFa9x7cJancI/VhbFvFSeh +kKW9BiF2cE6Q7zxi65oKm5puCZFopI/VSgJfc8BFzlJfz0T/sL4JGCQjqVt1N7a6XVvgY7w+XP6O ++bh1R+nzxSBKCeCBJ/Lwr8fTcKXf39aVjTfkWLaG7Wt7/vV7ByWGhSEIDwUsPUMKj8B9bhXlWwub +8R9q1FCU099Owxq+lZIG1FDA20goZ06ac/z+9J0bijMEU5F3X/5hR6IMe4dNKGiglzK5bgtaIkE3 +ee/QZ31JQ+kJFLgZYu+f4DFYCS53O+I7nS/VejNiqbr0YODxoehD3rW+lUE20/0XKSJQBAlkrf8e +ljqfk60LkphSivglH+ZQvkNe7xg0BfQaIXu9AfWZaCvab9cuTZ0R9DOr528U0KJQFYnRY5g3kHi9 +1G4InMnPlbcO0k6yftbYeO4A80OM1tNFNmo8fmcDRvHS54c8tZn0zH8jP3Fb1o7rWsodKe61FIY8 +gQcUXEK3aoK+DHRmJIQWSBPsikJK2uS9IruDkWzttO7bft0QfveGisClEIZehhLXeoWjV87QJPoo +vXflPG2dTOFSIzxtfMl6ABr5+kgpbLYg1MgPnph+mqHJ4JU9xSAhQkTP7VKdZ+ThfZzBoQ/zfE3W +dYykFx38cKhqFyWNJcwjMtv7cXob5+Jg97SPZlzY0cvyM5Jv1E1XAQEk7Hp66SeOlz8elzvyJfUH +WPtp+VD4J8nLgKw02mDeQAsVcI8gTVVAbkfWk77WrX0+8lcWbkonlv0W4Tp26n+SC3ZaXDpNz57F +KDwarKRUIrInRbKsfM6R5wuF8341eaQjflP+wutHD+zcFbgtka+vWpCt7fAuipyD1QSRHraQRVqy ++FFubjfm14poZLd+SUkc7f8kCPRUADssGoEvCdHoHzf67oxDs9Nx28vslpseYbQOUQQLVpPohQgA +2uQSW6duF/kWW6mn86s0O/llvZ9PTIbo1Nz/Ig6nZuJWbjiQkUrmY8qHn+u+v/lKY3d86qY/cb5t +AlHdFNvEf5RKcvZsvvNMkbn5naDMmow4K/uHDgwR9yv+F5k4kSiwzAxO1mdUSps7ki6T7kkKZ72O +KaKyWp/CJFxdFvCvFOMZc/Zto5drmPP6haHIM4l1ArFzOwqgxJJrIvUTk80XpieP87OyMusfvq91 +lFNTA4rBINxgnvizGoPl5xNmsnT763V9xFx67T+WP7mJpECQCLIwT4r1o93z+jSLPZn3LP5wv8X+ +pfOgyAoCCIo8nyT3tWttHykihFiseHyEEnXCGk3lqINEz7GxpuOZ8k0TSccEduT3y/OETw3KU2hX +GDD9hqCeEKfLrZrazCTv/QYYKy6aHwL6ibYO9yj848Qe12B+gTvM0xVoQYck+7IeiZXJBlmC4fQ/ +1sBVMJ90xvNjf1ARAhrToI4uOevM9e166eM7XX2Dx8VbeQIVKQcsgSErwQFqWUTlGfCjEF6qO8pl +78TV7W5ZyY7xjae23GCTPk7hcieIIw4xMid/zPwlkYie0RBp9rJyiaYRITcpc4o0MRJNOrmIEjLW +iXxs1iFbcEErwp3pKObIoS9UKCo7Iek1VJvub71VFqPdyU3jIeh3YA/2ubYzhSgsDI11Bmo2ooBm +JssD3G5RUtHnrEt3/Y2IuOSmEprynlcOWsDSbgpgnddfbH8dzCHGFeFBV/O78gWNrADlYgS6TMBj +k8vzxAxFHn9RsxjeeqO3odGJz29H9ZOj5ithIAkdfO2+xI7q38880hJ9Ucrgd9L5+xj9aF4Z11UK +s4NAkfk0APIQ956erM3+47HFwiLvdzGa+yge/wtNghGuTb8/dsVcbHafDFhfubOFIctiXRHl1fhN +njAL8Yb34r3AOKbFzH2nPv0wULvW1ynGfmd1DqCC8xy4OwqUGwY3jGlqNd9qfyg2KUpBeWLAp4iB +u+FHIPh5rT8LZVLn2zZdq5J9nvughDctRJgiIWIlCXDtV9ryX88InJYbHFm4Ajulv8crjyIFCTxE +CvZvhrKL+jYcPsF1fmOwTgtDhEvSQc79jtvnISUA4SNSzBafkIHyR8q5gTv3szuyyOdDJTDWG9xe +tKLin5KnmA6slAJWc8Q3nEfD4SvS5MzPOLxQjhs9wxZk0fR3V5jTtwtOFNEk/KFdUgQT37GNrIX8 +I6FuqSfnD9Eha+n+OORGbFhjQBl0XimDmIDwI/GHlhDNG+xjhoJjGzSuWTLdFnz2L3bJ8PiqYBtg +T6+ftMtPXcmEyVRVchx95h80qEw2u4+5Tq8d1M4IK7hNF7b4sCSRCgZmwcC9vIgtcgwSNHKwzxLa +EenOr6VnS6OfdglSaJMrCm2ciwljYa7LP8YXt23T9Ldb56/O9FEYZmAuL/5YHz5j7IdZ8Z/4sWNu +L0QUutc10GPzPxguO5eNBepCgaFPUjBSPaI85MfTqH0D67ml0gxc4nedbPSBRMAg6YnQvybrE2m2 +i4U7WR+2LBOee/wL4mJ8T0BCXnI6vdF4SdmkuOSc/nBWEg8m+2+dB3XGG0EMXpA7dXxy6qUu6Tka +5rJ9L9QUrb9ac/AZ7WoywM9dLHp8wTjrj2PlnT1MV22r1ewbuqgz4IlVdxTKAyPnEojbofEa7um9 +ztI+qoL8To7rmRuTTm7+Ipsv8p9k4L8D6M9cm82uufHKfccAgdZxhhgvNosS3f8iAvQrtc6+fnzr +mpVTgKmzc1Iyn9jGDFaqLNDPkLCxcnDDjBKZ7C3+0LBa/2kvUc3s2G1OncNZ2EBdTTDDl6WzUpWm +I7WPI/dTz3rN3QenbQJrqJLAmuSGQgfKERv/adgYb5GO6FXBzurSXR8s1+fL3Z5Gncbt4yh82gTW +LjfENtFT1pSvLwQjLWD/4ESjIVWO8HqICQv4J41ZNlyctXn+HH1nPvnQ/OBLr61KAw8182/8R3kA +Xg6fYZ+wZCm1Fr1meF3mTn3jNaEWqjhuZiDQKCTxDDIXZ/DDxN47efzuj1KY0n4q2m9Jc6XKgj3m +vWFYIFwPwE33ZeWNKpy/J2msLeDS855VyLeqog5jlqpihcewOxyK9ra2TVJMmOHsdoUJj1B/8K4Y +UhHDvJxbG2rgynKjM0UHBzou5FbfSEdR5fCBRsIrxz8tFzKzUoGn5ENPVIeHjZ9twosuvpc37T5+ +pioLMArAGFrOg4vZDzCeL9fNj98vvP1jRsN2lCrkBcfCiFUQd0ciYrecLDb9euy2sOoBV8amZy1n +qIKAzx3mBAxyZ/JtoHnQyk3vjU3DgJFEyO4HR7TPXV6gvqog8cz1fHU+pnXnJic/lQ5ISKuqTjWI +e1JnCGWMLTn5a/rpUTWKF+Gl77uMPnnDT+pRhYin3ognSeZOV3wJHnHdMmTN0rMl309xVv7Xu9Vg +0sm1S8NVc10+a49deJKWXrfmy5GuBU52qiDere6NwgdiLdpy7BxVsoZyrF5fTb/WgvrctiKPiRz1 +Ayur/ESbfOjfWz0VkO1R/lxF5tcvP04l6gi+4vxR2Yl2/XvmBywP2s7OcybYdJYpUkUIuwJxDBDO +RxFMqXLkevpb+he1n4r3/9jbxWVhW5k++18lgfPHeBeiYasgzFbu1q08u5h3/Fyvv0PwuDeC3ziX +Eoff7LobdvGFkijN4K0amR4Vz/ghTnpoErzPEc5Xs/k1cnHzLGc91i8kVq+dn6O8GmcpIJCAJk22 +jXwLzoqLDc4ugfX3f9vWPVSSoeNA8UbAyspAIhUMf5RQ/phuMcOJx4ipd3JqOXSsjPlW4sstYKA8 +De7b+MPQLqRtkzko21ilTlclYN0cAi1xu2CyN957JYTB4nYaYrGLmos2e73oPtG885nxa+fGWtQm +PBuDBojKW0biRiUGuvCjERvSa3pGzzDcemJXsYLAa85EHSV9t7DtlElDluzF7O/tPNrHD2z9u7zs +QhB5jBJpzD14hze0nCWGc8xIEJnEcGDLsjWF8pwbwbVNSNECHUlgYXsUcsXfAOL5tj3+YZp6bH6B +e+R8eFcUE/fcdOf/SzwgjJ71Xbzm5xP98Qyt3Ahvh5rwqVaj5cIIrZ3IpIEjnzCIEUhCrMfg5VbR +Y4e4BmMkv/5NnIvQjhh7sayzii/aEzjOcxDIYsBZoTCsP/6UzOK4t2XupkmDqKd/v0/qJioYmhWs +xFxQXoD7H4ZxRiCAwsvOhLKrGHTiS53ZBafNtk1HG8zfPJQJVdJfyQI7HO5PLIoYYR3QHbzlKSJ7 +MubbJ/ofjedyxFLXZlJAKLQXbMmSRCAJTffuaEi+1unhsqMRGjayRfhLfY86cJIKu/QNyzNjb1Ur +7RuSiESx7JmcYNv2bPo+NARcHa3BwPLyuoVnU5QWSpHDzOD0yyNdK68m3he4ewN/AXy3pbv8dfJn +aMfEz6nsNcLeHb1ys6EOD/ZRiMAQJC2VZGGlT3bo2NLl+PG8nq7jlGSuQP3W6pUYmINCdrczfhu5 +s9ahB1V1Fs9aV2w+qvHIdD00Q/Esm4wbktrDH2UeiGKy4uP/+mZEvvsnNOrjS3AHXnnAHVkhruPu +MSczxKWzLrhuZm0GJYJ1x6IIbx2AaJtDZDBevl92zEna7tnz2m1oQvDrSggN94QRz6pKmH9VNxcL +z3+ZC3/PESCWcafJY4DyeiANBV8UhfAxXZ9Cq94xmsjL/e1lHaAZoNsSynh4JQaOQzIHUp2h6vjX ++xzHYTU2weqHut6wtU/Pr2DIdLOkKsXfJSGI9pag0tJA+9rf77ReLDtNDVQYk8M4oxHe+DJrxr/v +19tu1vCq7dz14uzEhadP7tkLL78e4UkKPRICJEUh5XILXeWS267XCXzLs4YdKpMXoGRQSD8g+I1v +jgsc9gX3JXBWArXBDwte3Hz0U1Z23mit0po+w/HeZ8t7H4FCXOCA8xh/4ptQxoIwq0+5V0TzvHh7 +Qeyns6P2kC03/Ybr16njACGw397PaZde321kau0ORhaDt27h+ygIsNIAPAA4xw+oyrgbJyup4HFc +/yvdg7OHXa7lZb9mO60j+Fezn0ICkFyGe1wYBMH1jRudcHBBxRKLHTfsf6nJfJyJ6+ffyKNvLE4X +frtY/pZCDKG9OfiOeKQKMaZ03QM77uTGzR/uWGPwx2IQAsB4g4c84MBYwBCSaoG9lng0PfXCe7mS +X0VpaI1Lzx/7+dBVlTx9SFWMJ3BUH+2LJH73TSHoJy7O/MgIowbJ4feqLvQOh4qpwst6MYvquP48 +naIg5W/z9fFLOu6r0xlTDVRJnGIYAI4x+v1Wpk7bEGXvXH9f5nFHXvnInt1LlULD3XDvDMB4fRs4 +mmy1OFKxQ3MijRuPwtcfqoXAltYziUFjGbtRZumX5/xfeFt7jJQZPeihBDB74XBvSywa4YzV9/HF +k/ox3PsKslsff9F5V22qXXODQ6j/CAWJX5sIbonQ2xivltObGCQVbrWUtKC+WIq/2EBJ4EYeCu0C +nLPzQiE94IHeQNIW4S2US0pzckqiw9ZOHccoXx4x5uNSfwEhAV8OIFDO2ReDRXnhXwc46bQmj8Wd +OOiYsMGCNxPNy5TjxuQeSJ0HPnGrukb7TMxVHf0Z5+sqsDfscqbPFygIgiboD9ypCwq80xP6HwQ0 +CvdGHn2iou7poQD7M/M1kpLzxD1W4GqVeDNk5m9u0e2XYgUWhIZ2wz8ES1NeDbSk9cMSTk8BpT9x +dhIhqHmDtuas34s7aLSC6QfmoOeD1WUD7RACAoGqE/jDBhr3Bb4K7q7XfiT3GyHjvd2qa7/3PQoC +jMmTFTLT2pFRrc4Isxo0vNCTm6t7P/xARB8lBITj8L1IwHs77loWNatq3NrXghzqrT2sKHWINg4a +Aq72tWCmQ218+2dOfd0l+oQfLA7yP3esvBrU6FNjjtYht7XZu24Mu9nGgnjsE7WsQrivH+CkI/SV +Pc7oa16s4R9nsEPlFsPfKqzCcyk7youR4LEGwWvjnr5X33G/mpSenj/zunWu125ZOM1PFbcIe3qC +a40zMFhABQNc3PG1BXDPGV+U48AvbdptTszIpG74/NEvtpfRN48e/rckX2Lc5cDaCMMfKe66yvK7 +syvtROrUd/BI/hMHQO+8a+91JzICGnavSfiScKk0WvZM7wrQBY4BzyogguBkvoFI8UbufPGuvi2z +NCFtLVHSwT9VpVeAQB62HGB/ygGhCnxfKIeADzRIpp2dqqaWJQzYuMqHd+1DoDDgHS9lY414Mj9O +FqtJTTBb634ubSDscFcQcgWFW8vd4TBvDBL3nztQUI1YHXlhsTPoGm1WcGDx+pA3Dju5Xv3p9V7J +eqKcgHoR4HYAvtf7Z2Nh2Q//MMm+EzsYl3rlAILVbwWz9EyI5RqTzBvT3w7txuRm7LzfLcpzRpUm +QmIlBIR+fHFmEPEuCRZaJebsBiuOCpMoNKtlyNhCl8TAOR9KFD9F7EdeFRTx96+dnppq3ndBxHhG +4mYHxbVgVUEEkBYHByumygHtF3HvEbdNE6OFT5DjCsLvEZYdJ0vltnhL5naIRK5dIYd42hqLz6f/ +al2y/Y7XQf3CN6Wn+4afGu+oMl6mLfp5EXbSJYcHfjGvLox9s8bzXaXYlqObz0btjnhlim1dCXoj +CDYVhrAtk6V8oEZkT130CqpLr7rLMyqq/mZeZt5gJY/FfWcnX7wiAVYIDwRLxQD2Hk6sEwrMRFXU +6Nhs8N6xRRWmeDjOR9/bdPQSaoUgUipE4/yw2JWznrfcnzPZ+sS8P+PdsVVhxbVgRosLqY2HWoFW +/Z13Vplrd6F+H3q48+JPgTmflQRudXTDZ0rHFQVj+QXd7USOXxJSvHtpRDqGPZ7ianymE96HjNdE +ATQqYePwiaKB3GRWbTcOuPpDQS/aHiqoC+5P4i+Ebaogs9iPITAVuy+RxczyJ9PbT1dqnlKhSY8S +t1YBLgXCamPZcoHbLfvGRmPOCLWWxF0b9/XE8UJLAK6+d2zXeS1nmWl9r4tMbWdZ8oKFVWArr0bD +wZqDQKcxXySYBbfEK+4vtbDW69lxze/xNo881kWL0xnl0DzpeREOSYGDR23O7sDX48MHHHPMaFgG +zrY2NhWb/QPHxzlfeAfWemqiMy53lpfRi8inBOwPkVsdBPMFPcEy20A1ckKNvlM3JE4/fxHVqq4o +jrHmfVKx/6hQMaQc/HAijqYnplLpV5wPKV7b9x7++HJe1rC49UcKDIXBkD+q2/19SnnvDfQtXd6c +SdGnnw65tmV6BQN62kjvlbx0LE1C0Ajnt667g2fnIn6MVzVxd9WkrISBUlSE0nCgAFBX3n/t3h8z +ufFzJhH0mz05Pb1US86v4IgFmwD9APd8SGuQH9K+5vz6z4+O2Ruovk+GxzA9trxIDUXDwe7tCCL7 +V6h3+KzogbhbWmxdz290qlyZYhpawRL0e3AQSoyPu2grWQzv6DnyaL5so12H4covR9gFYBjADCM6 +/7WKDNaZSOvRpngwRtln31CXuU+38i0QOKAGB8LNFw3RpWCv5JjB52Gv5IarzX3wQ2Mtr7IQK2fc +khDgXfqC1YsIbeb4x/Z3WwnYHE8dNPzYs6g2UMx15wE0jW9vv+zlrEsznY2uXeOt7i5ovYl2NFAq +1ukvNAzEAlD+4KPts2dJ4rsHl5nkH0gZUHY96fWbdeVrIUDkpVLOPQyKFzy1G02rpC+azYQuLK4o +tYSmgBpYVBo6TLywyxpXW5+iult3J0uZTcddTuFwaCGkMQxH+not1QXmXncPIavRyh9g2XdR4/qz +60xTCs3/EADaOIArjrBiZOxc11cpFFcifF770fzva248/ZZU3jlJBHjkiXjegyXCRC+vKfyx3fOI +fLcRy8VHmYf3Q/NLGkcV45ZN/LR97cLXtoe0nlhUT+G49HwFg1PicVZOoBwm0MsJha/OemTnmoPe ++yY2iZj63lSJ/1h9/i5iwwoKgXSBA4lvyx/zjomYNeuET8vTd6ZKWrCIXmyk9eWkAEGrGu7isBxl +EWKo7WdWP9Fa1LJGzrKChsWq68lKdNmitKYn6IjXQ+du2JR96H3uPQZhaz2sVwCAZxbvSSWZwseN +8s+0mdkHm0qZFbQ89nNkeXDi8ArKCw7DAHm1XnAvIH7lCQsCx+GzbAu2+ecxzBosbjMn3+yNvcAm +Rrc6ic9vJ7vlZ/QvnSctX1333vPN8OqIJIuY8xHmVUUAkPQ1x1tI20/PGE7JJBX1sV2lORzgvhJC +AXULCTkYcKD1FsHhcufV5xls2PljmzexWPaa2fJ5VRSu3KQILEk/QVSHBAtueUUz8Hr6z6XavhMf +XmWxQyMr1JSFqXMXeOM0GAO2d8rvscq2WnfG1xQaJMZREV5g6gkhEgXIcDZS4qxXiTg7knl47+CO +M+sCLovM/RcZAJtPw/XTzWPjxb9MN0eUQl03yZYyrlwnVrDLfCThCcEdMSP3zvotJHx4tj0h0l+D +FwONLymQJs3jvWmnT0g5536f+cX2rWpeP5ViMBEYwkuRw6B8cWsC3qrF/xsgyEniQ4fG3uSW5y6o +1jUpw/LCOh45/xIUiMRZJlh33Pcg/NOyPPC7J7bHb3/2zY3ZP+foRJ3WiW3Dy3uN/xeJoMnS9Oxu +dSh/zBqztp59Uc9EDmrO9/9DDlD2gfQrQbXboe72Yb2yTP8Qc/BwwUdeWLobRwK0GHcYBtRL3dAw +bzAO0OD2Lk5b/gSP1YYvW40cBL9umKv2p4rizF5PuB/cE+YPw8fRXoaWmzT3xkVZG1okqfgdq1hv +UoaEpgmjEQj2AaDZjYh8BiavYnRdqIriBVuNqnDjleolEUTi1hgklliM+NPxgLwpvdZxO4NdfWvY +/obl3l7euX4JBOr7ymFw6y8wi+De+CKixgViu3W9Xkyk+PLknRPQqCxyQVOnAaL0cYmqXY6F8j4j +P62fnS09TwvPrdxVyQj8j4QcWwxJtQQETafK/7z+RTYw7MhuaaUO3WM618ZZ/rMgF4IbqUb96Hx/ +Effav68jpT4IlXBXCuWwQgtBw8lXqlEDNXbWGbO0fW1cWNqtXVvO9a1Zqe2ROJwSjAa7TcI8vUCf +2jrH6RJLoUSYx87R9ph2udain9bZ0DBhjOOXukrp1G+Dsn83WMVeuF4xu3BSzFv2yAoMCfcnGEjk +6/gwLa99SnRWrLJo9olB1MfADL7T96iDwI9k8EMRodOdMbXJlaViY+kOF/zh2H5h6jDgOSanFR5s +HW698RK5YfDSc9cvJo1RSns1V9KolSss+ek5lUeWbVHVI/59sVZTUtUFaNojbOYUAvD9APAVt86h +N547x/EiD8Wqb/Be28ap6ShtywqAmLG7VJsQAIXWzHyJK783qrLIed3vfp1Zp+S2leYcTjEkHv8y +SDjH41Gu7nwG2y9UfUQlMHJicqWVi7uaqBnh/ak4bNKPz8LaErWw1u+vbrRdcQrn34hb1DEyHeeP +XomjkVF9yrBBd6Fxv4u9uTYr3woQ7znGF4zCqZbQVU9dnj7sNatNQTmaVTr88rvjRXPYyXulHMBF +gvYj8yEAINO+ebPA096SPl5Xiuutvj2XFDn6mgIk6IF4DRy9pFISPjzjSOdiO93QFqOXh5Hq10JU +kEhYPTUZlG6LTPj2Y43N6jxjNds/xyZwPla7NQBxBwEEBU3bAUPvX6ZgdJJzjFkgSr0FWfTLD+Lq +QOLBdzm9gwCWsMbX7719KNunpv6942ab3K3vGuquwAi2+Yp5Uj0zO5PwNu0Zh6UrTzPWO4XhooPL +CpAwRyj1nkdOGUYBiz0WJj+U1HI0jr6P3Ou/UjckzS+giizu07GopbPBW8dyDwYW7WESnKV5Yc73 +hdmg+03nShyOXaam40Mm8koJ5U6Jwcoxfvel6NT+VivuHleDBrH4ju7AG8Er7cQQUeQl0b+RTb89 +0nae+b/SzjwQqu/949Eie4UQhVAi+5KIpEKSnVKUwWAwYx1rZcu+byUq+x4S0kIfskabiBSRFmTL +mq185947Y8kd9Pv9k6X7ept77znPec45z/Mc86n4oS1H33if/lsCWutfOGobHzQA9qJvvVQOQpz6 +Q8FaTqVNPnK8ldq3YWngYtNRvkznmM2U6QZlYqdrgyivS9QE/H0x5K6gETb8+P3Tvf9V66h/1fXj +DjYZ96iyb+Wdz/7bpQTWFHHGh3BH45cpDag3W3hLNFjlPPrj7+R24xTpCgKwNvg5Mrh+7KV07dk0 +5kvPRiq5cx2BPr8Tfh+CZwhHuxbcFzU9kxP/dtOUkkqO4aVXquw9f/vWS3r/t9S+Ht1G+x30RxBB +XJ5D0QEvBtVXXI1xQDivLD5TlTCZVxB5seM/llOiz+Np9mqwSbCthto7mOC+AS2piH5vzu1dOz9V +SOdPH6rfolhXP/0XuZCXZm+MsCEcK4GEQsk/yr0ZZn2h2K8w4b5DeqBoNNB1uGB9+KI7d5oEleF8 +u6jJMkSh8OnN2+YmHDV/T9BW10D/f0SATyCRYUiSLxZoQZfFLPbyZSrzNraO8/AwcLU8es+WSB36 ++3bx23tPo5g+5RbL/D0rBPdugEnaX3PRIKqkAieOq4KsiKv6bnPijpzKocuCe4Bd5cXyb9Amjbcr +xp8yvcW5eHf88UbhmFP3HMI9VzBAPDVwlgy47gTtbuPN8YZX+8KzdB0r5z9+zqA8v3e7wraie7A4 +/pSsZbDW3B6UN+1N/3yv/XsFbNgPvWZ9M7Qctoe8nRmXA8cSP+7VSAoYbXA9yhIQJLs8hA3cAwT7 +Bb8lUKkav/1PqDcESFSLiHg/DSpOj+8P/BRp8k31UdDIrnVI4CMAQInuMb4s5+5tdDUUZdz18XO7 +6XZwOK9DYiH1DtCoP1XkTxuewqYfUXHblJf02LxAz7LS2U5IhCW+Vne9g092eipVhHXTnzpyw76a +ybHB9OWXGkFlwfgRQNK/CRL8CffVAZqlLu4wCaNtMG4uSuHMJL6DHFpJQiqiuTbwSksyk8AW5bwX +Ofgs2jcAtSuozjUOZdnwPPIwERL8ApT8MAZPRYKO+8InFHt/Li9L2Rqg2UzfZd9gcUqC+s2ntVTM +wUIo/PZW1tBmjQvvLr2q6v6kIi26LxbVBuXnrlRpraWBcwuBtI4lRvDEl2MyjPXSbxsFUkgPKxse +ctwft3EtFXwQNYDrX0+3No4gz/qd9q1B7/xPzNZwuofwOHCegyPSCMiJQtiZWWNAc9ZdhMxhtxzQ +CZD3usVyLYp7i8IJnTVxY1NoER172XM/t4TRD4FoihjninG17sDsnDVhQj09y9qsnGuoYwlU7j6q +MgJRcszVPTNrwuaWJmBDfLv5CpuzgHv/VGVWhqBTv/AOCf/WtWCAUw/g65GjUSbdOHAlhsK6yOiF +uFL9ahzYePB3W51WMKYRNlxrZq2rbFXkkRlYVvBgLZZws4jkaw1hIT+S1dTLflkOxAXVFbVuWIMF +MJGaLNnZUtULqudnUlTLvpwJwbTJEsFQZkgoS02Z533IS7vKF0zNR5TF7iju5z56uwGeQeJcacAA +Av+irfgtobJYYz7UL39yKwg9cr1NH8KTR7Vj5wZNojy+e0NfEZDJb81oTz+nsvPL3bYjSumUfp4k +oUkD6xMwNseZCYSIEL+NtZWLsKiQOCBnd/QtJs0m6GZuoBe1u2Wc9Pz+r/rrk7OzB9cQXryt0tUg +f+6Alst+MbkpjEJD3HTPugRAP6Ne01ewK9pt5+MNspqvy4/u+/zxHBEYrAC4MNnDNxr6cewco8uT +Wym5tYEF5r/jOakyrqyHR0IZ2wxu83yoFm/G/ovRwpiaVkGU2q/10Li3aQLdPHuzuc1XoZHf3wWu +Gspqu+VslOzZv04FfHtIKSj84yQUrkye8f2pkeWeUSW1b2rrUcA/ff+tc08t2Vo/7igtkxHH+tKi +VKln14EDqFWYRLrAi8JrH/i5Q5pqGEiZW/kPwaNmSAdNnPttjdbFzT7wU9LZ77vYBX5I1fSg95+6 +/CWXh4E0Hx4mREHhDTswJEbpt4o8bhCKqq5/dNaXP4S3decRBDyM66hmuDHBEo0AX5gQYuSWl/VE +AzWVnk5qrcFNMclpcngQf8Y9OCFcyAupVHej2ibucesB7eTxvceVuk9Zs7vA43bg7QJMoUAxdYwU +0xGjsRnxpNZXex1OZREZD8GMVqi8A2CYoPfT70w/nKYba+lRp8SLHjKaLn53ymcduAke3/1bpsMx +PdGK5b/68ogCvrwLGtjitXFz/OO6K3lspjXuYVga474vKeRPtHOU8inXpgkPe4OHojGZ1n22ICWL +6NTOK2aR5ZdI1qYX+0bBHmRuT4TPqEsaveCv2X21nEwzTWvyAMjCJ8cg6P+2JcuuQO5BdOGFLsH5 +EHiQEKR0w/jurG1XrO7r2UZ2N1nJnGPFNb3wBOiUYjEEX/hDz58N5ttd6H0fbnMlaSA/bob5HfcX +uJggo7zpCvv3qKmm3leVhhqDoYJOV2mU/74YcrUJufqEyEFwz+G5Yn9NW7gbXeXU1nMN4xsVaMoE +4OmFg1qBAjHgthEV6ngtt650e/nLHtqgrPkSlsi/bTQexUev4INOYinYleNJN+1qMj9+IFN08JR0 +Me8oLGcPWzHcpClwxFxWzojGsjHeJjctV4eGVYIYboKwAcNBwWiLv3I3HcLMOZFDUTnBqdfObU49 +NCrPxHNwLZ2FLU78gcHQHB2KLzV4dNXB3mRn3+bix7KnprqxzLPXicgBp2njk/Wf11xqUOz4ZEyf +ejSBhYzJbKpVMmoVCp/cC5byNTbHYqAMROXglNdTye7Ox7EKY6VqnB/qU5lL1iOy9B4AHdFNmd/V +hLEGE2Zv9N9jf16S0TiZR0QHiApcVMKfLYBztVGEgkyyczfOhsr/kvv5eaeglp4plaMQayAxLayN +FdIZbFa43xKOoV9Mqli2uaJldj/xDpv8y3vJP+9Q/uB/c68yj5OI7tKityVlj0VuldY5W1iYt1e0 +3jtvLB4aTgQjnFALYKn/nU24tL1Va6aYPEyCw/vlw2eo5U8WzGBY7Fj4kFMg9Anc1QNfj22xfWbn +dYGqH/yGR14k6z3I0+u8uA4RU4QDGDMAfCpCGLKc/34q2XDtk5131ZxHRqrEjMWF16EELOsRjrEF +PhohmtwKYQSVONO9xfh4/jQmGiOn/bX9Ssep4D45yn/UBT8toOXnPEMSOnP4RqngxazY71yKccdT +Cv5RC2d3re2QRpCViZ4TZWocuWhVVcvL/Hrbh/n7kzSf/lVvebUD/cDYQ5Nh0rU1DxGoLESzl7YY +tvsfFZe9lQOxJQNd8oF7haJtDB6GmkZxZMrR/KMe1sFUWILfHouzTWaE+lnJKbtGg6lU0RqeMfNC +pDLV/ReD9FaTBQJHrZBAaCDozQRkXza6rqJN8U6+XuO7rCpJ1LT0dTgcn9NsYoJPiCccAb+kFgiu +k0N5HzdiT7flT/HwXZdpuJDvMt9epvRO4f+kCa1IAJIK1AJfRh01la6L3vPehkI/EY9zOUFcEnp0 +4A/gPHZPkvPRgFhB7WJJ2SJH+yex319pEIehz7JiZcGjYMPxr0bhvOl7pLRuf5XZqS7jv4aGA64h +IfH7Q9amC3cH9tAh+j85fU9F7jSIm0yEBss4epjHwqgRxlLw0GdojARMOr4KCBg154hCOoEfMHNy +vlbr4vV8Or0Rkd5had68zIm5dUmC09fKsb1hoQkM6erUHs4p9mG0lD0h64KNXKyNAAGDp0p0H6sm +T71/8RT5he/V2EXVbYGrCOD/MtAAz/YPGp6UT/k+FMybYi11ccJik9xNGHLhOHb8czBGYIyRVvjB +mpA0oi+SfCFSYdrktn7gT+O4qVSXxLEOGC18/hy4eQRgD8J3zr5FN9Sn3n41NzRIzcjprc9CDIM6 +JbCXiiTkOESoF+iyXHa6Xy1Fv0XUY1Cz0BHtvgYOZuFBBfJjHI42mUxL9fPQeF/nrnvz9cI49sDq +NLQbATaj4c7Mzu0OOy2mPtuT3bVv0LPGiK3OmkOHAJvgHBxcG4J8O6HrVxJ+DGtveKgsEHF0hino +wdnZ76urLHEMczuw8Wrjk7xe5bZHYnjEbKem2WRWh5cUDXo5mHZngCoW+X5T1A47jo6wuEwWOEOx +FF62gFyE/jRygM8zpzXCbM857XldG2p16tV5eyTCzhg6lYJQpA1c+ik96ZQ8lxZluvkZedrzoTGu +l6fXaAHLhKCDOgEhD4H4RJZkneAcIbGElDCGfUxxf6z+QQhnNezw9/ZTI6ZU7FPbhsgrjV7Vbt2Z +ke5G5/5BCcgxwJ8/QkY6fMJ4Sw+1k43wiGqxjUhbCAnnPyiZQfOHViY/K8GQKrLtuWolnCG0R8n2 +x/r9mwq+hsjJy3Edatr8Hoqk/9V8NRkwkLpvYvwPQuYI8PFMRVOX5WeQDHc3XLepNB/fUHqL/NU/ +qBD2tLd6P7H0jDtWRtshaRLflne4DsuV/Q8y+GIymZH397mGVanSUagF2n7O6jO8IPrmX1Twaxpd +96orBndMMrSo80+o+PR4B1C0tv+LDDh9Ak44BceYR+k/PCTDnbULShNS7mIuXWY667rrH9QcF1ZL +hC5xH+jqLDC/lTm6/bPUr97J57SF6xcCFGYGfLsYkweqeDZRCx6866Ux12GktZbCQgDvo6CJ902F +Ube1UwN6r03fYzG6W7BGJydsFOMnktrffCjCyB7dkxlnzE5NVPJ476eJJiKAdwEJ+6JxdrvcO7lq +Nct2CBi++979weHciCERkrBrAhZHJZQyQHw5dtDSTavG6ICDcGqE0U71TRJORHgHazAnG6By3J/f +SMhn3pvu+0HxpMCzYpNeR3EYCm7iCSz+LB9igVUckpTbIRXmPx5X/ugx2xdkIhtQifh3PcKcFqiG +Cqg2fNucE2NxQVQrfq765/MKKbPPBnD2gIgq9DtoSgeo3YpMdQrc8Ft5cr/UVb1C4QbLk7np/6q2 +NKS98Jh+J1Mz7/apYfZxu98NTtjWKjgHi4geQWnxGRqWawVS7Zm99CA/qxmpMuZ7KGPLx9X1lkx8 +AYER88T6a9bnjn5KHsnrQ42wb/VOH19LANek8DvaCTG0Z435xTk6chrlM39fOtFds/Hl6vTSgotz +vysmOd/UhvYknfyVIyA1LOWdErA6veBtEbZf0Ui0Eb4/hmeJmwtpNXPYFZ3lOkZ+Q/FJRW0TnNqy +Z7hYd5Al9vLPKvq8KSuSg4cmmxVLA225lkWCOaEwJtZOhDUdIGOOkM3c/f0sFasn85uuw9wpm97Q +DXoli5XDkYRaf0iEDVgzcXED9xGTyOFksf8SOLO9dKX3bBb00sBkLFOACjGsEU+EZWrCao6evms0 +6tV8DrEL+S1F2Q1OBSjVil88AYp7maKg8a+s1IsROzdmwq9t9T19I8XQnKFWPAy+eAQxPgKGUHeE +N1lnyCs/MHz055Op7fOVH5P9sqRgeGMLQnUUQvhvdPj2P72Msnln7UlIRKvR7+57p2nAgUA9dPDv +gsUpLCBPy+7iAVc6stO8yduMMLf6e7+xG5GtzUIRCUBld0BjtDfX2XqX/5uAgnk6BnL1SxyDfKzE +NLA2hKQwgKRpqlX0cBOiiui99qlumjOU6bTXeTgSqkK1MNMC2QRqjBLX4NXH7RRMI6bdlY5bqXwS +4Vgb7NLsyF8l4Q/6A8ZYQpvfeyqyz9xyCbLwIEJhCWEn6k0WqidjyLmsJ3T2HXZQuWMxjZyGY5Ys +GxN2ncEDJaGygvW62EZ5K8M4Z/nnnu6bkCFHU+htYFRMUPbg4iAwhXKiinjHmvE4vogV4y9Uluyw +9Rs2Cg7BzahxFg6NwgAxwCZYcLF1oSKE06cEJbXWt8LJmlx5W7r3PAn2neBZSwRchL6tfUSasjtc +qpBs39QXlbu/tyrVwXBLSmsR2uP8jm6zPgvWLo3MJslDvO9uu1cww7XHJQduERIEwQ4Bvt1tYSkT +9DJMR/pZRAd6/Lv1XprZHobTsEcv9J9gyZmxEsEQ3wB+sWKafl6NwIlmBBEEjYKKA6Dxh7hS7jjZ +uPVlpu+TqDc06s2MdlzpW4Lg0YVwnp7pMtcfVoF7f4RTtSXPhT++J2wbCYcQ1ipI+i7meu9s8CRr +vHgNEx+T1zdwpRDuemekMcLOzHEh4AOHbqk8YhZSWvjhKxVvvEx6ZFo7o+NpWJRQYQJYWH54xo1V +LMSQb3qfx3Q8lfTVqGPdxBh8JUTCwni3/OUr83aWmP3uWaE7+582jGhGpRNDwWLx8Nb00VTe0I2m +P6nYAVE6csz1LOGuJCwxmaV5vgCbUXIfUz/c+tHFR/hb3V2ZydkDl5/CsKZg6VUHKOAFco5rlFx4 +f+l8fbNblXVfLSPFa9dEfxIYEjfZwEe3RFnQn+5/rMFxrDJP9uiW0OQPhj/gPiY46CyxI7wK6Gcj +vp91o+lCOzvTshVsxYZjiWFL70zr3OjwXNrWP1HXXirtKgjFHpb2PkmUA4L57B3wy8iPhZHZXDmJ +E3fcs0LCguJyG94WZRIhTbBom6WHIFW/VWmfPJdcyRvvc4ZXpJjum4zNRjjUwcFGBNcVcRYWZcy/ +4DIsNQqcCjdmz+xrFz3KJFe4zWz2+WutmJdElfAewjKBHYEulUxoAaHu6p6zNK8ODoYqoxVhBBa2 +Z6EOB23QGl7N7dU3OOm6/0XcDxGJVhZmtu93YFlouXf5ILn1t3NZ+UR1vIGrU5IOG8b+0B89VRgY +GNOgokHgQAec0ocB9zisHcxBA4XA4EdOg/oDWMdHzjJnJuKm3lD3bBi7nWQII4gPXwTCHIATRfBJ +B0t8CEAL882pWXHghrB31t1Bx0YDCrMrhRfW1gK3YrHq2MMiPcNTTcmPRKfcPcIehLCvQi6Yo7Pm +Gmq254U2NG2erjyoyWYild6vtgqHRthZAof44Lo6EFVF8MYF6kTFSRJVKjrmRx5O0XJXPidz711F +Bdzq/+vWUzY6mykL744z88U4YlIu7+kdDUlYSwI6xhhKdgHKq6Mc8Q5xy68j+SOzpiiVXQfMSsY/ +BF0cd2xZlxgAI428zljcaWL+vD97milGuFUyeXjvmvDiajIgofMEMVCoraJUV1d+U9Rz/w/rIdU9 +a0mY2OEHIUw93ZeSbTxWtXz2rY6mRo4tsvxOa8EoDJhAi1z4rZU1VH3iXeSZW9JvfJuVVRTUtjw3 +8ur6IZe8lhjhB3whi4UHc7Vzi06OfxbGVJWPU6X9WI6cmG3OerXAHwjeECHIu2jCzhRJf8UkM2Ve +1tp3akxSigLOeC4XJBwntaIDQVmmA+4k4W+/NTfw8FFfeKZl45MStGEtSajpIJdGGD+ea/qVsUkw +6aiSWu+WG07mUfF5KWvJLLpeC14foXh4Wm2Kis6g3atb70XKtQ7r8G3mjfdbU44gAj5/0AF4P7Cp +4a3606jMMENbdNOM2fFnVqt18uUywFx8oTJ1LgV/YD0bSdVXK6WbZr8N9tKxF25at5I90gocMveq +jnTy+qGUIySHxr4f9r4+87CtZN0i0OYJIGPsE0F6tLAgP/pGo4bWTOmJzA7f++uXWTqodHRGfBmL +syzmpedplzf/wJZc59u4lhIQ07skOrsgW5O/6t2W7cz8wXZBfjWl6bS+c+uSgGpygm3wj80+ttb7 +/ezH6rKkrCXcDoXk/nm2hgbY5vLuS/lScp45VYKme/utpiZTrIV2FWzhEUDdYsEwE35PsM3RearB +l94e8tyaVmF7n2UXh3f+AJynAckCzjCUXLk0pSE1MW+jTLgw63BdIpnJswHroll9uIndCoklvuu3 +i2I+fZsqdTWdcoraxaojXHkOd65HYkkg+k/UBv1j2/Yrzz1Qtrv5+p5ZTlHku9UkQB828tzTJKEW +10P7Zy8zcjr82fv4oC0cs2IufS/9ooCH/p59IsK5g55daQn89vScMCBhIbDKzPqElbyK4tcc4ZET +vtt3DB44VAx3Oe57pAmw8vB34dhsbbUUnrjtfVJhHH77EqcLPhkfpyEuQPC0AXLDE3MRdjF5r7E5 +z+ZH4UwlHmNeAbCkswNQu395j+F28mIMxgTaGEj7z5S//61yNmrrMTgYN51FgPuAfVaxDtcyWlp+ ++LGqYx9+yxTXMtxJBADLiOL+BZIQQD8OsRC94VT+Z+BD/dZuVPDbql+ynjKMo6T1sComyKWnSNj/ +Yjl715Gs7XVujyVpMlswA2U9nNMIFCGAoibgZyQknTpDFUXOdx5+a/XtupfspmobBOcCwrylAVbl ++cYX1gdbGPg5i22tnMmowuAmCcA0GOqkYIDfQqULQKKTTFwI+1NVH/nA+E/sVXmDodlbcA7XggTA +yDaS6bx6xSMr0Xg5hM9gNM7iR54nDAMU2cNN4PBjGmiiK3riE7JDMFfJUfFfa+lGfmY5xjHCkfj7 +BGac4HqMNutJWS7mr6WVsXU/G/38Lf64B6+CgTXqweEYgIVVtbbPMB9Vv1oyY3YzMWkz5bks9Gow +MPGD6uAsmmHJ5lyH2jKflnsMyc3UXSlzPnvcZmE0gM1Oawzh7XA9l5uq64z6+Kcn7mtBsl3L1cgY +uD6LfzQml8pnc0MPZfxOFghNsf9sSrrdNwv2aqjeJVQ4FNeYgbAvE2gS52tzmSFcicbD6PoZ1sRY +8586GFK5tSTAdtx+QeJQhCDnrrvxr7NUh7Ob/lzjgOHsEabIpZVOkgUjC8WVT4tn5WRutK3rEonK +4uSGw/52jKDZOf5/oXEKkHt1bdtkhwxWuID/fr7u1q3qDKn/wS35Af3Ymt/UCmsP1E01tULh7U7a +Tt36PXUeJyq4KVlkclMlDDxfDq+Og+OAgB1bTbT3sEk5D4MfSwZd9Jy3NjEKuN7r2WCutqoLne6c +60yXVrTR5ne1cIupy9K9CHNziYcRkjGdydN2Fdx8Q6yC/iz0ORFrsAB2s3/UIiGDvkHzCG3oEOUu +e9Sv4z0w2KK7B81y7ZD2NtYYE2i+SPgItzxaAhUqxX09PRSot7cz5zDY8MO5E4taaJSxnbUDwt5y +wYO/L85qQHlPg+2Me4CO2tsJ8bRWJNxq9KIENEYA6GEuzeAfrA2Wd54d4Uhq+Zr7C4mAWzdcggL5 +kEsG/ojt567ePXkGffPDFPPDuScO4XsQ5asKAB3SBtdFUMYLbo0yf49PihH7xGCPfA2pit5EIduu +a6tqLCY8AnidzodH2KckaJp8L9kcZ6q371tM4RrMEucb5zFA/cVIgsLq4xzTnbGXR3Q5jdpIuRUZ +4DyfRRSLATLbwUeXO/lk5KTxS3HRMhp+DR96zFTedQo4FjrglOAGaDMiirobSyjvb6Y6/qX+xsan +yfq8cNSyEnhxtiEzb3SKVES7UNk53JqG3R8/wU2eYUpVL4SOO+f6t3WES+s3dR2gUCeRlW/mPH1l +XRIAzOHoFKHHfmHWMkGuXUyK47wu4jzcLAx8OJApIYxu+CVmgv2VRVlL3Dnm0h4l/u5UcbID883A +OllYIXusDdA6gELZjggwARfIbAWWdt7NW/govf10exffjwxE8Het59XCmDUkCEb13udf5Zc76xj8 +h+vaShtGey2aNr9YA3UAKoqCTSWmTYbr0/ORaLmILKzDT9boFsYXp2BgR2srnIONsENZueDXPa2B +M7uA5DYXIM5toYRVAgPfuxo+qixttN0L2+yhbac28s78qx64CA6IRVa907Mq63x2iTH8s4Rlo9T+ +L1dGYcQWHVjCCyJ0wRQKJ49LNConKg64+z+ZpPuVkKk7uLoA7OqUGosoF4KHlobnAllfeIB645Fu +UZglGtBuaGcn8eV9zpNqJDtAhZltiOeag9ldAd+46pdf7ddnVIylmHSE9pSc23FitGaZP+RqhTLi +N8LZRCsUv7CEojwgHx9wnL1vTxlzGfqEuWjM++vSTBnpxBgTFOh6IaBNEMaNaV2Km3Y15niKpvj1 +2/VX86jtJ0YShjxoFdESBUUS5QceNGtsS/VhrO5ksjr8cMefqYPnV1UAoN/2lDMvhQMG5Tbsk3M0 +Vr6lu68qiSgE9DDoe3DRxXL22B3ejG/js4UytEnTAxzVtbmroos59EJPT2i4Uv6yGvhj0dj3WmpY +kDScmxhqiUY4WyExZrixCzd/NEMujIYWerli95IcptgYyu8UpSEPuLAXqhMRAddfhD/KtChXvYsx +2kIhdvk4+bswkq8rLofW7fA1Awh/yLiZ6Sl5NDrDlJyrN5z1k0DuFcaAVUkwNBA0YHRM7edbXtSi +GNG9uV9GPNtf7IshQuJmJLgxGj/HO9F2XXh3Pd2ZyJeu7G0vNsqLcQodXckBK3vA1RfidrjTZJPO +mJNrevTfPK1DQ3NwEu5qRyQGBR7ziE/yAdhpyaTJDN367HNiWfMfJHOswpnCnq9k7YxFwbTM2ZBT +5waMUZtrGM8/vEXGGhx6078S5mqwQKEdAjIR3Qwnv5Jv3kr3yfkXWlNP+6BIq80KxARpaoUvargs +9FXFXt/5zQbr952hHfGMF+NEmMoMBIjCuD+4rCy32H/CmwN3W8rqnDnqFsg5ft8spewjDAwdbUY4 +VMLMaxfHAzeSraoXq8z04r5sHW8JaSMGgfPFCzbsRQO/U409RegeycrdjdAwFl15/UJPB/c8QLOu +EKN0bLzgmJLyHupQxX2h4zNCW1fhAORU4u7zG4dO/6xJ3u3c2FEZdeSAV94KBDqQfNEy5msVksj2 +Cm7yOrzDj0ODxmCvO+OTFRA+bAFYpwU/2zhJim2YkCfPi77SmuOhFXkiveiVDGiDwKVhsBi5kZU1 +5DR0T2BqjSL/y95WIq1v8cHX45Ekw47VaIBBRb19/gcZ/av/vJ1GwQdyzQ73r4+IMEClXvD1yoQa +xn00QjVTPEk+bNZDtiPGoo+TCAOF6oITOXC6b4VEOELOlF99wue+5NNDPq72P2Ub7zBt8RN5AS8C +Lp47Yd+R71JwidtZI2Uk5zAVymZAvvJqwNThGjKwoAn4bib8Zq4o0GHc/QV9d/qSzLsdVfq0Ma7R +SfYC6DJ4HCAgd52QscJvhrAzwk+6FV2ttNUOkgUP3699oJwqu+PocLQDcR2AmJr9bGZyJ6rvgyji +C6vA3lM8mytc4IlFGx35YMpUwTTxgUWHF/nEgz0jWzZPVaxgliQuQGF7BKtNiEEClMwDX3bsTJII +lPzN1VjTPXNBk+P1SaJK4NESSyrc3bX1jvnw+ZoO/105D5rrXrGZYTHSq8MARc985YYviaX/9HHa +LWghub2IbXe8VlBER5bYjcak9P0Sbp/cElOi9bgaIm5016ygcbAa1gH391RACdBf/llob+3PcPNl +Cf/GA+QekrtL9EpWcBhC0Bj4aD7si3s4cVXysF3yxU7zcsYbB138YAgHQoIabg652LfF+1D27pH6 +psciB9DOooMjgb43hVbA0PkWi0MS37fBnADstt5HiWlzQn5nxDv/m7+8AlqMn2Taz9a1Nwt9YHtb +XPZZxyankvmesysvt0OiEeBx4/igZsYTVuFX2ul8+Fm3ifxm/ZnWq3B4wwoKyhWFSkUD5hf8e5IH +bcpvF0f5tYd7uFvay/m5tLZ9X0mCBzHiN4EW7iw/mWzkIIvQZ9+KMiqhEGTqboaZTiIofnqwgIpX +1Wl9+6Hn3ZRfvO3KRmGuK4k911agoP3Avb2FHcqeUf1rjkOqsbSho0wTLjdYzzVw7llB4YYz0BSA +zyW6lIajwfXSE81SVZumvHH1CBMRyZUEMAdbaIsRfHq/b2VxnpEODxuPnmSJCwxKMl6BYDGAwVgo +vL2YeKeRr6GV2qEkQrWRQ287ufzIoTilwhU0ZB4h12VhS60/bFz8sHGzQveR8FuJciKYnAlyxlVJ +/KvnE54XaveJmGA30fN/0zqC8VY6tLLBLOUWrOvZWM+IKZWzRxWiq2h9WO/FGxT7q6wgwbMqwRQi +YDOVUT2Cj8TP0M1Ho8cIG3/atK+LDp6AAvTk8Z5BsnuLvbI2d4X6G2Vf22q+t4eaZRNWcvYOJn+N +wDwd3cH3dEryLOK0uMtpoy5d1bzlC88t3FRZN6mv2wT6ugVH/WseBXoEbZTRaSLIcvOrGCrdu2/T +YCl64kqpa32Zw/xF7ZXD2yIIfAeuLIQ8neVuUJVm2+/ivL329lwj4mw+PEbU+p3LDRt9HvLjbdmt +Gy3v5YaoZHO65OAlbHBegxlugLO3M+YnnAxc8EWAPs+ed8pMsNbc+gUpBWXRlghYGriYWbUtaFou +R4xFVSOUR/L8d2rDgyt8BeA6aX/nNobyG8/cEjTqTrUpu43N+Yn9D0K4s7TwDEKw695UUnqtFXV0 +3AGO+bQ2aXPMeJwBwAA//8MXwxewaQEU1o2XKJdbuDPH0loadxwwbWtP7MWTfQGqFPlGu2o/rnt0 +nmrVV2CWA/qBTAs5k78CF5NSAhMUdnuQlVvomFqqI5x3lNMcS//o53yTvwIXs5ACNgcUJ64djTYb +nmJX8S8MLPvfKq6lc6aT2gkwFGiHtVNpTBPgwQ6sIbmqNnX11DyQkx4KLBRJrPljR7RXjfcNsPx+ +3pVn4DFnsLNeChwBFHHzOXZ6mZWTTHNhOQszhbiUjW2uk44LNSfFVXv+mwFrh5bWR3o7h7dtbQKU +QZbd66EnXHicnVVvbBRFFM/slgpNS2krCGjhcVC4i9eDamLwsKZKj0CFUtsGMKXAdneut7K3s+zM +tlxIuYKJfDKpXsIkxBgFizQmWoTkEjWVDyQmYFT46p/40a8maGJiom/37tq79vyDm1wyM2/m9977 +/d57d/+tprvvNs3+NqmY4kbm3L3v21+i1AENHEszbRh3TUHhlEc9aoCmu4xzECkKg/sH0KY5+TeO +ka0b14fwPqUu7NnXC7rFOOWI4NsdeXuCbFFCUVl3loDsOUp2NuvM5gLBdOoIavThu1zH3LoGm4rY +ANNPUvF8OCI3fqS2SphWm+SnLyrr5A9Z0izFMjUi/zhKTm2Giucxl3JmjdGwH0NkVx34n3y5S10j +v+Vqh/xpmbJcHvBIvfxymDTI2deVVfK7n9UeueKC0iDZObJc9nepq+XUOdIqsx+rtdkgmU7QxjWz +MtKY47K0yWnRCWzfDg/FVwwGcZc4uAfSHpKgszSFJEIuwPm3V/v+4+B4PBW2PcuKALOtjLw3p7Ss +2cahRxvTBnTXdAS4VDO0EYtK1OGidAQJydr3lUY/2xXym/MkIr1JZO6z05g3pEmL/NNGwwdjZJvc +dYIwWX9RXSlvzZKa/K+vkckN8sPDZOUGE9nUMOF2M52mhonLUBQ6hqNBkENydpo8Vle2/3qabKmD +p+b3v+O+ubgfBo1DIDhGcpk82xaHNo5oGs/YOoS5Tm3NNVkU6GmH6uhzt4bFI68fwVDvXib5I8hI +QtNTgLzrFMkcpYKDiT82boOgyOGIZ+DhrsAL1T1hjlFgDnU1YeIJcKFlAJXxeeUa0q2nTMuIyU1P +q/HcTOZROTWjPCLvXyEb10Yh1N5eCgmDLC3zv1whb5P60nYYS0y+eZW0bOVDO4Zjuh9xJCbYXm2M +7qf2qEiFK7LJG1fJLaWt9Lwdq9WzRBl+FByN8zgI17vQO0PyvTPKO5ueQfaSzIVwoV2YJ4JiYUkY +CnFP98lAiBB1Xeb6CwO5cFlGvmeoLVLMKaviJ15lpl0ovxS1jEJjHreZMJOZYqEipGNRn6g4bDlT +9DFxIqcdeiJn7WyUyh2lrXvhEvop3il1WUFbGEdO6V7fSSecKVoAqI0EWBZmtkNO3VbWZE2eov4u +On9FuJrNHeaK3cHUqG5L+DlW2nTLpLbYY9pLIQumKnj6c4GlClox0BFNP1lp8Fny2ythG3LVJwpk +Mfc0syuytNhoHIaGyx6VyFgcU+B5NzNoHPyu/rtMq90oRtjlh7jUPlFSw0xCuFQpnZ2dMF8pkWLA +uevnN8u+G2pNNhaLFZJZcAJl9TDouVgTVVLB0ZsU1O2nFsXijpcR4X+IWvVNeTF0+AZ56hppGVkQ +sKPy9mJ9O6qCFQVbZCwTjRq5S4db5dyTpC47AdTidClFhQ6KlCWCM6cXOYZk0X3QQp6DM2Ueu0AC +8JQnDH8SpbRg0rjY81GcSMJ/Uo4n3J6ixBD4K4x/LkzLKvQljDCRwgMc6GkO46ZIYZB+nqY9Gvi3 +2Dj+/VSK2LhIRPnVtLK2NtG3ry8RkuwaWZ8o1EqocPR/RQy0aih11Lx8j2cfTrTKxqxqLPXmf5M7 +d+1wY6Bt7tKPTfLzm0pTT0XoSzwuHTd4tgi81Ez/0ikjFIcznScw0PAfumSpvcxtSaT+/uMDg/2J +Fw4c707g4uAriW7ULKd2NcvetTW1uR2HauQXN9X6Cw/uKPkHd9RjZ/8CSdMM8/qKAZhXqJSweIHP +39ggRGv/m50rERBCeJyVVc+LHEUUvmZXQwiGVfwBz2YP1djpVaOX2UwkRsFINIsjeAjBqal5vdNs +T1Wnqnomw9AMCB48Sl/9FwQh/gP+GeLdixf/AvFV18x09+wsaLOw0/Xqfe+r9776+o+v/sJfvr+2 +SpQGJpQ0FvIJNwgqgSeBsVzbIg8iCISa5hnaVMngaQjLQ6DHorGxQZ3yjA0t6mkquU3lOXCYK32B +GjRmSGgGnhVY4Bi+fjSA42VdoRxGwM1CCmAhHPfvrTEBPAsPMFCFFgh9GFKw+uHgdvXrwe0VQHvn +EpSkPSXt0visSDWyQKox9nCG0pogPD3cTci5ptCZ0jZaF/qEW74Hwge/tRONfLyBeqnGYjX56rc3 +X2HUF+ARjJpCm1ImHTv2OVIv+veqv28cveWCPMvU/DOeJY9zlD2wusCozq3+ufFG9eetWx+qMfUx +AkE7R1xchI40gbAwzgszYWJSyIvwdBtn9LuMqp+vv0rN4VTRFWbUWOrrKGzzGnWDPNxDGvXM8QWJ +c7CZiWlqAyUu0LJRRERSM6h3rIlDHMdNE+/GArU1UO4BFllKbSdgB0pLEoVlSzA1do9aWD16+fXV +TqpnEyvJAtRaaRJj/d+xXwJNRs39wuluzbra/06kBqYJsOZEsb8Q/X6/cwvCrWD9w+c8tbUUma9M +l8agKDQ+8CcNOuw2Ca7HZ1pNU4NMo1HZaoaOoUH7cDrFccrtOjDDcAfB6a5h1I2N4rlOrROfFwsd +XopLqmpdu+35G0Q3qUWOZAWbXN+FpJCi7gF81ER6W9jTHUSNttCyFks3VHZf/aQPPHEWPK9+PDqq +77qbx5pIi9zbHSrheqKun5+6qbKAemocM5HmE9IkPm93a3caTYS1I6TG1raTExhYlVOp1EAqZ0rw +msoIyT+RYmSXdFlO7ATbTLeDpBZJ0IWMW5iNF8W5MvYLNIaf40Z/q60AO3zvW1KMMLGTEHNHfijt +nffva80X9etgQqjj+v3jIknIOD4Iwwjepb8WThmSn9ARxIRddTNWzdUYbn544dIx2PCSs37jff8/ +Omknda+Lr662cW5IMPZSIb98YqxOu3eu/V1Zm5tny46Xnw8efxm7FHmeJgvWfHxWAsMy6lwSnPGs +7dn+afyi57zaTawHl4D9JAmwNsk9G8gZH1AoLMnOHXr14vrNldWLDgN/kieuk4undJSW9XgaZD1T +r6OuzH1vYuoXfbHr9OhKjk3iO7uZvp4vFW+++8hIYO9VP73GzkpIaCXLuqyvymrpcaO09ZrnUB6+ ++O7a7/AvQVekHOgBhl54nHudujB1g4Xm5ABNHabU4s01mtIsm0/rKrACAHxjCMHwxQQPVygFpPpa +q/xbPpU8InDWAHnNenic5VpbbBzVGdZp7CQ4TpzE3jhOHPt4CWaGrCexoSlyYocQQgMCEoilqLWW +ZHbnrHfweGaZS5yVsx1QH/qEihilI6qqIlR9q9RQIdKHijaqhFRUlfJUVVVpUd8qVQIkGtGL2v/c +5rIXqCr61H3Irufc/tv5/u//J7dv9934Tf+Lt/dtYMeuEtzCNddZw0XbMcg8uUxs33vtL1f7o5d+ +V9Bc4jUc2/CwXvOJixsE/ll67Dz26oFvOOs21m0D+65uwzTXj67/8MDgskVqfgm75krdj6/NIRzj +A2hb/NOjaKqfPYxm/oHjt/cidRPMjE9OoTt3VB3b87Grr5+G7Raik08Mx3+eR9uG2HyNSqkUiW1E ++Fej/c5awyKxNYnGpy87prGoqMcGMLYIrGfCegQv4GKRPqxaJmgTv1ZAe0MxdGgBV+uBvar5znnf +Ne0VRVXVdG56VrGEq+wonxjUDI51mXSZ6LqO2zb1GVL12UyPuJeJy2ee+fSpuU1rpm16dZiqqHhh +EVN7aiCRwgSNJzahieiDM5ujoWBLdPZHA4+KY0DGYI0oHScLZfheGzCIMbWbsLbm14mtiMHo8Hv7 +HhFr113Th8XSpjMsAGZoAMyAfMmGYjYXj52NcYt9t6ITNwtbpbbRV24enOJblXDPXeN3j6HR6JWb +++Nfz6KhMaa5QTzfdZqK2JyFxLfmUOHr5uab5mb0+77Fs4HfCHy8FkAMeb5pWbhC8LMBCYiBPWeN +rNeJS7BpY9AVU73A7SyKq3XdtOOfbEOHDnDD8A+PRovYK37dg2BS4he3oJF49yDaHWprekPxnOoq +xBtVn/1ixtIrFnmMrRGS8o/ugYnAs6tK5iGWu2tUPsWmW9l4ER9RS7lZj54/+4TmsTg1a01lA895 +pgEGNEjDr5fkJnDZSJWYl4kBj5wVsH92l2hXqXDzoUF0vW80VTKnYvzPITQWfpYqXRX5T9ToUEJa +Niuneoc8qXVzbBd6755ox4Nbw4ZLZoLGiqsbBDcscBZeOnWOuxabHvOnrfugOSCTbcABMyxssVOh +cQkjjo0DD8Kg0sQU3mZs0NCHgNJ8Txs4fBhfMG2AMQ9XdTu5mGzbs+chUk7SvSqk5kD4wARzbY0Y +pk5n6KvEgbgvQQBg06fLbcfHDRZjIFjFCWxDd5tafGMCKSHYjltcZReQCsCNeElIL/ebxzo+uEF9 +3MKrhDQ82NzDgc0RAfTgRuBK6nWiG9ip0VC+xC25gb1VszGPG65TJZ6nwXS/5hB3DS8sACium/a9 +c0V89SpWpkzvwcDG09P4iWCtQlxFLgEpPDCbp1F7aV7DMn2lqBXV5SNlFR/Hc/epuMUP072mXcW+ +hJW4PIkWo+c/GY5/MIl2RUdujEU//2QyOvHakEpn+xq76wJqLNPziQ3AUbUcjygSOaLrr+5jyB/v +xpA43jmERscAp04xdISbSN0HhrQBNpWNyP7bZHT2jd2oFD85j/bv6TyFLo2eOzwSpiG/DM/OM8wq +w376ug7eOwfpz/SIpluWsqxXq3C5AJ0b/GmJJUklkQLQS0hQVMvJ9eg4l58hwOv+ZqKhlINlA28e +n6bfy1SW5XJ+Rk03rXhtEh1QYKNFJVnPwJsOpjJqVd2v1pX4j0NoNFwJdBeSKD6+tKiIWzEvVYRn +TECpsauDastiVqlt13KbyI7NhKWAyKQXwmfyCv3Mc820RuDV+bwMhogDeOJrG20di58bQQdGMpZO +7BjrY2jPtBCgTaxldhvgKtIsAoaMv7kF7dG67VLG8xn/swE+pxz/rB8VQgyA8BjR4T5WHL8ukUV4 +Gxum16BmJp6EBNPzAppKKF5kLqaWEw8gTF8DPAWzPRjUahATEGZOVTl6H74Hzx6Zk18lfO+RK0dn +E+UooanC1IpeXaVJ6Ehea3oS3KDYmQTozvAg+uEGERlcnl/iIZd3VnLAoUOpk8yacLAqT+nuMIyJ +5dGE2s8mRd/5cDwECy5RAGS5uEHTksHxlEntBlUfRKC4UXcd2wk8qzkPwIwZ65yxHKeB/cC1GRwb +ri5SNsPijGFFJgLEpRSu6p9+NtAthU4pCLXTBFaCZBR/s4T235XoSh+1XTXThX8XKIi9XER4E8Yn +old+O7qZGzJ6/+UD02omoYHIZB37lqcB8p5naVMRU4Hafrk7JrAzUjKTSMCfO3bKJUWYR08P3fkS +2RxKl0zxmeBOg6oH3A3yAUC5eC7VflikCrXtslGR2b5KkVEfiruGjGSeXyCWi6lglMXBzzL9DW49 +BZYCfgnSWU3mlVWb8n8W9z65wrxdM69ojFhVmpDjgIvpTVxhQQ9HwUE8YYMgCfzHg1vRZJjcFNiA +67WQ46vSBJLmQB6SYa1xMvEp2qYS5nVOdQj5yVnd5Q+KKTkanRFS7TKJHdFj2nodJOymRJhq0c7Q +WK0C1mBHUNcrj+t+XVszbaXNAngmwwKT6Rkmp1IWwiEIX8V2YFlSsH3cuuIsIAp0kMsST42i/WFu +uyTw2FMR0PTQmm4xcp8anLCpHfaW5s7RZJaJWe5SmCnp7qxS0I2QHpvxjjAP0PiApM9aXZgqL/UI +xQcvNZgXVHTX1ZtKarDEKYdEeSgcwg59QOybTlrIzUqiJgcqHoFvI0UVsPKJLsBB9aSwMZgFGIo+ +fWwEsCe+OIW2XGjHE759F0ARA10QpXNKlUToqT0pxIiBTowRA/8TkMHR0x9t271cFenak+yMJfKQ +oVtJiMwyOP9Z4siZkKZsAOUIHYsmuXkRFgcuOSUZnGB3nmAEYpg+F6kvTNlQW9IQygFxy5/AIaBj +Z/G4nM3vLkQmoZlH9CvS50kjYyI/ArFzKksK4u8V0PQQ30VGpRq9+NeR+I0CGt7Mt4nfKaCxfpcA +l6eEcn87X+jVLUgiMlPkF+k2zbZ+Av9kZcvyCXpx4Oi0jbJdyVzlVlyeRnsPEwH7eVtSYdrMzm3G ++j9LbXqIJooQkxmli6C9xBQrom9/OHGuZzAxMUuJQkmNIBZnH2kaL24MiBzGQOLjo2hgZ3viYkPb +M+Rklj0aH8qIWcJzfN6wOIcBI1eQD+ySIcNGqIeiHW9NhYyKl6C0kJ0ZWrnB79bAACtCi4Lj2kx2 +lrobOhTMHuvr8Y6ShykceHjd9OtOwEmpZL2Wsw7ZhCMZXiMwwfDA5LwyVNR4cB6dnJjjHS7ecWAL +FoSrPCgqow9fHR6Qf86Wo1uvDx/l8Ub/TFf2KpjaiqUwLZZ6F0oiJFoZwT6vqqmflU3xrYNoNFr+ ++9hL6t5zHby7d4XUuz5qpW3CaHVoPOxGdHTW6ugEXtpDaOhNy9GNtPtYFO06320KwYDknQRf+5C9 +Ya1wqmLaVSugitIOyJmlpXOH57DnhGwQVL7SVBlbd2keAi7ODwsqllkF/kdjXcaFJg9ZgsAJGg3e +Sb7g6g0MpMCT5VYNQoRld9exeH8abmIdqAvtkfB6oK7boWGJcoDSSoX7kB9EOyLL3BhF3mqEIC6W +JYE/W6F2g7wJ6YiAR0EOv6mwuCyJHUp5GlYzVwKXZr15MFZAWPPjDBtcgfyt5jEQ6pp1nDrlEg94 +YZCDG/yAFl4Hhai3LkU3Ph659l10R8ixi4ktEU3QYuG5tvrxi7NzSeUIhSPJrZEJvANQ5UAxNx1y +XV+PajLXDRaiZEpJHqNAbLpWipCt0+cM+tMmcRZipVRsKD46i0aeynA4bpk8m8WLEkOSgTPmSv2C +DgTpcd1dbbMG5W0s9e3nNlzMm5ilTS/64KPCPppkBaFOau70NUIherO0dTOffm0XGnlGTO1BCCmn +kpsBrRbmS8i+5JOJcYSDQSjAKU5ePWmv+GtjaOKriVWUvP3ERgLmVDXhvPzIbkaXnhFrolsPTAyQ +JGFET/6psPQUqVn8slDIaL8s4o6JrT9jrriG6rH4/WNoD22LDobixtP7KmoHer/KvZqkFNhokxTr +cPGgeIQLxW9X8v6J9ww8uGdiyQksMtwMYAZARhEisigu44WjgswWW+AJcLDbbOuiik2mp7HolrL0 +GT27PHJc8jRYRru2IqPQm6NCcRXYHF6MPHWhrzPm8UORs3NsEzyMZm+MoFLU+JeKLkZvvjt+7RLq +42/IILTGHmFL9CrrYS/Io/Ksij2CwY7zmK/Z0hOacm0cnRH7PoOO70xuBX3yGeL0UZFBmvP8ByyP +f4yRkr7H62M3dtsU0uTLvLtCeQDgFGwfQLq5wvN15sUgsOMAZJctOvaHaNL9N31SRh1Feo6bk2jX +/1XPdDz+xd1oMH57BO5Ue6mXpvf2+99ZJOVc0qNSyngqUy4lxdEXIBrCvehg/MIUOhI9/9Bw1Hhh +R/yHKfSlcXa+ZXEl88WeGk09XIgfoK+JF8fQji0CAqKpj4ajnerW4XalKBzeuB/tiTaGBo93YUL8 +Ouu234UMCQLEy1D6bmzl860cy9k+RUf+Ocjfgy1mKyCKJBXHaCZlYPz9ApqCTDMAV4kNyPSSvd40 +t9BBLZNgiqwkFrgAFK93pqErs0VYh8ysINkExUeEP9i7PdcoZSxhqK32il5+fTo83vYwg5KuSXJd +7Cx8dZaSyZJ8HUl15qCcZ12MVp6+Epoee7VLoVpgN39TdvLcI7jSbFBOwV8ayhQgMgB/ozjP392x +1rXeoBccGwH1FnBSiNmLfEstdy43i6H7Oq3VRf6m/51CBCFzg8zgrJcmAoo243S7qWoXeWYSDIvu +BKFFv6TzjuUOTDo0gk7lR4G9B66dfdbK/KYnh7afvtqXAnZ9N8BWyAqU39pOnbKeEZwvkbDrK4NR ++g97b5DXJLr+8f4wE4Sc2wlJWdj1krJdRj5ZbY8bIZ1soncTrihFk5M6bNyKJ0bRRPip3KvUcQ2z +L9F7YQ0/MmkeCON09p5odzM+NIqGh8QNoQ0DOhjdunrgWKaNkDCgZWER1jtLTJlxJc9Z0a63JrZK ++hc9ensi/sYIKmyniO0SWo2DIeJf3o327Wy1tRL+DRb5fX/2CbMx6SLMo1Z4b8YmlDrxy8M/2jU5 +eJw7HrLLY4L4Ro9Cps3dHO8UzPRyUvPSSzIUFG1tFUwUamoUCoryk1OLi/USi9LLoo1iwRJKurrF +yal5iUWZ+UogNYqTJ2rqu5dkFOWXK+Slliu4FhXlF2kouVYUpCaXpKYoIJQrlGcCDc/PS1XIzssv +z1OAi+cl5qYqaVpz1XJNPqApAQB1TDPf9wj8DrZ9ZiwgAObb4bMqej66rvU4nXicOxFw1mfDdUYh +p9I8vaTSzJyUBIXMYoXyjMSSyfe5xCaLMzlurmbawDL5JbsBm5VCZolC0WRHdme15Py84hKFktKi +PAVbBQ1NBVs7LgWFsvzMFAW4QRrVXJP9OJQnF3PIT57CYcdUq7n5Jkc12+Y0gbWcbMX5ydmpJZsN +pVy5NternGQGAG5lLW24nQR4nMVaSXPcNha++1dAPKTIcotanOTQiqKyZaWSKY+dieyZg0blgkhQ +zYhNdLhI6ij93+ctAAguLcnOYS6JGnjvewveBtB7e+K9TpU4/HYukkLX6nOpmzxbC1WmtWgWSlRK +pvKqUGIhi+xI1A0sLMVKF3myFvquZKq7Km8cVfwiaGuFpHnSBEcvEl3WjchqcQxof7R5pcKgBKnz +rA4iu72SzWJEgIsdSVOMIWCtI3gQb9tVoe7FZkTHeiNpoRqxlHn5k8yLtlJAWbZFYSF028DKrSxa +2PkRlI7RNHW+LpPwYCb+cf7hfYyGldfgpZDoIvFSBP8tOzWy/L5h5DBCkPDhhRA3aj1HOPTnT3nB +iGhf/LvOy/Dz5zSvSrlUMxEY/npPXquyOdgF1nilQPloBkCJqpqvRUJeB7VxCt+qqs51CQo/iGVe +/pt/zkXw8d357UF8GMzAY/fjZbGxCHcyb85uQQYarZZ506hqJhSukAtKdSd+rfQyr1UI+ujiltxr +KGNdJiok6pkI4ziW1XVNfIY2pIUIFJY1WCuytkwa1DhZ5EUaorWRQC+bQKlkgu6/uDyCNTzwRC8h +MBpczGRRK7uu8ARl458VYmT5NbgtnTOxQE8xfTYIGitRWdshI5zl7+kQUtlI9OyG8FFJx1Q21Zqc +3qxXCvxKXODsRNbwk8+wVn/M2aC4UOU1JMlLAYHoy5n74sB7JHFzRJKYc9XWi5DEkSUbT3FYzFU9 +pTrpy/xZXsAxhfe4ch8ToTg+PmYtxDffwKLxACx2AJ2YRLfT/iEhRonxpjG5w9Gl2opCMqa2QKeD +DmKlt1u7VZGL/cuTGI6ig7lSmeYclzNxBWcGJ00YoCItRegX/ME78AMkm50f6G/a6BBL/alU9yuV +NCo9qypd1TYq6SR3+ChqvVQhLQhxb/foh3cEgUL+QPz11/Q2VM3TIoefZ4/TQZrJ9nrRnN0naoUJ +9xjpQpZpodLf1O+KkjOYEaVnob6qVXVLTuN67OL4waaJSbhhwoCvReilGh6K0Jm4CKBRBVTpyrxe +4F/UxoLLyKjJgqDChF6SuPpOaxNJ2wkh4xhTnICeC8mHMzcgJydUCkDlOaoccdp1Us1RACT+fyTT +bWPdgT7FZDH+baGh+Kq6hgpuN81P4aTlmQjRf5EvFxewliza8mYs1uxC6VH3UECIKm70ObU2CDqH +XSnoIKUBdsVjVekEtCBB4yDxjDXH58qmEUD7RgIrFhhIPMIpxIfOCz0MU5z5v321xgH5t/WagPxC +xaDRBVw7zu5zLPbhqC8kC5XcYPLb7hQajeykVOPmjlUeKsuOP9DA7w9XqF9MEQp1hvAizNZqHb7R +ulCy3GpkT7mHrnNuDAdMSOGDSS5UZWb+toT2t1Fv7pwM4eyp6ZOp9JRUnFvFYeLp1DbNB9bQUTu8 +fAE/LyMLAk0vJLdAhlIict+yjbOGYVWFu99/G0HBoZEj/YgbNLGA1H/i8AQTTrg/67faXQE8YDnL +sR6wh6nAR6eYqMfCCN8H2QfdqbsxpVKJrtKP0OXr8KrNMlVFvROHMactGjex8Kyhs6xWuLjPa3cw +6yhoXLz8UnwnfjgWjGb0taCuo0BuA7/H8dIy4PD46ReYCb9/c9ZBvjIWckkh9h+HIkxBsPMP1whU +n6cMpr5gyEuH54xBUF7c+PXF7h8PTAKnGufMnUhkJP1cfS7UtUzWuyuZUzOj0QnGdFk19X/yZgHF +kO4FuzD39vzOfKjVJJQNr0renUGz8ckMoNLZLl559EqVu03VKsdD14bXGUTuWZlOsRLBrkSKXWpi +hhHhPgDcFE9fFFpqVIO/egK7KCpU1jg7ciiqTo4qUm+OdaEo7z5QzcUaY/zjskoWhb772Sg471Td +WHkZxRu3eTul4OzP9zJXNyhjO0kzt4xhCQXxYdMtkV0hNSio3yUMTclVF+h+DmGO8Q2xyzbic1Ho +VbyE5h9wpCzrla6w2AUkiqqeBdv0WDHozM5JnJdJ0aYg4vAAouoRVFnArSvoAdFBcL6MFUyuQu+3 +5wmYcWQRDq1/RDIxbJWMJ/8cwRtXZieEdCOewf4/nD8eC0fzMcdzRJG4zb8KJ0yf3+XCG648EE+J +bMILXDUD1GUPwY8EDjMkjU5i4No94BsHRMVAiLs5tFWNbkKeowHFKClH51ypQq6pTyOMH6zzQZuB +7WgQwE51qhpjBa2KOB1y2eKWAVD9jvFqBDtWkOI+Tiu9Wqn0CUXjur2SVSXXoREdTakuvHMdsO3P +hOMcsm2mjnwCbcz4Ytuvzd/OV0qR6sl87VT8inQdy/DT1T2qfXW9ZwSWMp33gB5/fHd+rpMb1YTc +f0SvCnTyO8fl9Tlh4vzWqm69VglMjqe65EsLgicQlo069zfCB8Q1T19hRE8i9oWrc87ITa4B812U +ZVu32msdUU5er6xRmF6j2xT18GsdRBYBGn4YFLL2+gIy9ocGGOSnkRqYmQM/qkxMydUKJl1pLiZE +BmmbqPxWpTHP9THflx/ciy0Iwocuruxxb7WXgYYAFXerm95YbC4vRDeOBjosXZYw3vMBeQcvaoqP +OQ8rUB3wEvCplG2z0FX+p3uI23KUpi095wCNFXQvJ0f4t69tfuxMj41R5ELnmkGWGPLeahfDLhlf +97ko0bfwPOOsurD248kmrB8rozjrl6e9PfFOyVtFz/ol+OAWvwFQDIkE9LuSyY19/EIYCMsjQVEh +li29YjUiK6BgEQCGID3etHXsCYFR/5flUqU5Xm75CDyj4IbMEe6Xt3ENf/KwUF3vjYNBB23FC2sj +1JM5GeYTT8Zuci/TeiFv4N6J734uLLHCmPqE4R+4wKWuY4gHfZ0eDAdfG+zr5Ij2Yv8yNr3VVIiL +w1ezw4NLlxJYat5SUgw0ozJGwhz6cBPRG7pJ0v0Ii5aFRYI3/F5QQmByWIwQZsJbwbRzDuB+868W +5CYw2qm58/2OaUVwsQn5YdfD4Oc4NnWf3j/cKwXWTJ98chRnRqeFZU7nopM6fM6o1KpYU8qwHzvK +p6yeVMHCgjvYgado0+Ow5qlz5AcXTrpZfMSXXVjt2RIODt36zzxQuwbodnqQv8m7xyH7Bk6DT9I4 +MZh5b1UBNYa+uuy4QQMkubjstOS45Kdw802iC1DOYh+5i9AuvPqd1nvUZsOe20nRTL8kWV2fzY/J +1W+6aAR1O2cDT+tsxWsMH88Od/8fGLBlCh/o+2SBGXBPFRqoMn3QfuD2D74XwpOJ4ay2XsE4eN1Q +fZmOi2d0a/5+s8XPVmCp+avLfOJLTDh4ApT4wbP76hmy0HGl7z2ybusH3SyxqnSjE124Hn+tml/N +Wug88wXzxpdOG8NZDtPe3QsM5smU3SajDcncfuxFGeGFFxzbWWeTVJz0T1Hx3Pg4jbl8jIns3b7/ +CIDOScL9/txophOc5P04YD9Zz7kvzTh/+h9R+O1y84I/WttXZFld314cXkYwrjTJIux9oej/O4XR +N4qJh+iDI/qu/z8jwDWy+q8CVvvU9ZUew0Bz0haWQdU3pWvmmC54nK1YzW/cRBRXKig0oV+ChjSI +amLSyKauk7ZEbbNKljYNalGhKSlwiKrWsWe7Jt7xymMnjaKV75xAc6vEGQmpp3JA4tQDHLgg/gxu +XDjDmy9/pyoSOSS7M/Pe/N7n/F7++Hrs+5/Gvvmxd6+PEaaJuxUGtI99RPtp4ke7BA0iH1P46sYY +JXCIJjF2B+Pz8yiJXUKHUZygLRxGu8glPgooTUER8U0Lub0Ex0KmD1ugYRs/mxn7e/GMFw2GIU6C +iBgW2h9HyIsITVCUJrCD2e8rk1nQQ+bMpkFTz8OUGjYycBxHMf8AcJI42jPuOwHxwhS+mkrSsuC2 +GJAQvIvW+HnTSMk24WYUd+p7DKuTX91zgzAFA5fRehwNAsqmF09latEZiiXseG7i9U0wbHkF7Y9K +0rtukICoOse315VI7HrY3FQbNqppvC90ACo07LtcEBkUJ+nQEKozoTsl+PEQewn2V8NInKFRGnvi +Fu46hLirpPzM8rL2E5qbQ6VF7bPashdil8B9llKFcoQx/iqDW83Ckw9n9+XNI+RxJD5EvReppNAY +S25+aAnrEBrB71HhrMIgoRcMMqVeGwnolrYseznTXmjDgSbwM9hfQrP7QqnjQZajbldCcIg7wKN3 +DrKgj0N2YhFNiC9eGGCSsJnu3FGvtLDK3licZb9eOsZ32C+Xjo+JldfEkSFmv13+IPOilCQUHCCB +Q9GsumFIl9CCLRby+vooILwoW3ZETrSsC3uLdYmppibT6zUlcrGmQYHbcr1tvTjSyVsSWOVuXEYk +DUO9W8VUOpDpEyXdLfJDjGP9OXZ3G2qrKPKTGNKC4uIrTcOkCCHF8Q6buDjJpq6sX7fRwH38BY4p +ZO0SMu7d3ti54Fw00EiaTiNvG1Tk9YYEJFGIfIMrZc57b7PO2SNf1pLbNPhRQ2e2Siet0omIaYha +ghOyrdSqXclb7Lsr6BBkzfMr1z+HxrvqDpNUVZ4LDXLIK0/BLBVl3nVREkU2HECiu+j6oIi3dOiN +2HfYt6+8+SF3Co4lqogQgME7tF1ygJnfpq2XNklJ5pydPFUrPmk4+/ni+zcavpFSBcyqn5J4Tznc +Ff2V/zJZd37lsHQju3t16VXEU4LfmzW0w0aRJPUQwObLeL+qQwuX8EQE+jucstmTqxOHrA570rXY +e6sm++fqCvvTOsqeLp3MdNrIenfK9XXunE6JZhFVG5MuCf7TsFUK50aqrqX+smOd6fOtGHRDqKNg +J68hNr94uh25bBd1GbHqQ9hpFO5g02piVT5VWGsgcy87kl+I6LCn46/zsqrjqLW5Akprr/kPfmzm +izh6+kCY7Pn5ty4dhK7p3nyLezhrtbmakQeprseguvEyYUjiLM/raijq6S0DZnNu4kFlr8rWIKpB +vheSA8VBwr3dMOqB2Glx32SxC3K9lIh+g9jtI7Pz/OH3+sDdNhfui2d+4fGFRQvaOPQ9Iu8COhaG +ZtIPqI3YJ0emM20qNMgbOAx2FPcEECGCno6gpyM3xDGYspUm8Cy4OxgF8AAXPFaCAX4IRJj4AXnk +KJ2NGwU4SBICeQXn4FMm2UwRM0lfFKdRyIE6+NXW2MlPqycLfOGp17DYU3K1oOqIiZc405GA57Qt +DrB8QKlJgTwApuM4bvyIWvXs0wSlSDtlFWw4bjYchnvKO0K8hC1/dok7pP2Ik2WZ3+Y+gtukflt4 +GQYQvEZ8zs0aQCv7ufUyP52MDx24HoQqdEFfCvhN4iHkuy3NoqU4REwUk4fd47VteKpOZ8mtwQD7 +gZvAKyGjZ+lXRJVNH3joTdDEX1TlHR3gMH/OPyvYjCI7Oc2+BwHo5HOAGm3QsiT9ZyXrLyKZzxl6 +IBDsZX1qOqtg1+MLz/fNSn/PR5l6x8lHmjw7K9BbzBuVUWcFbD3zFaihou+mOOWsJqCa4chygdoT +VS4LFH28sSFSZUNSFuUmoDpgWUBgQi005pHp8Hq7E3JNcm6le8SDMZJEKQ33UA8ME1foqoQZlxMq +hN043HPyPBMT7JbiNMvs+ZmpDOhWEX+Z8LqGC2dYhcdUBygKvBpm8GG5N6u78sON+GWVAKrXqC2E +zS1OOzfcXRHbT6Mk6O01AjxCOIS41jNLZaDqSIVNlcxUg1wX3dnirdBxKQ0ekdKkZvDiajRmObQZ +lo32ES9RIOtr67fW14CqW2gJ3jgf9wKgswph1lIT8mbrf0/2kj5uhdDJbs6feFEHkAUgR5N8CkRF +S7DbCsluTQ29Kv7lok4u8YrLVJblYlWaqZebxMlu75F20dRhiA4IbGmanvcWPZHzQw/0lV1HtRyz +TqW6ur3XDgCtbgjxvKwssh8Ov8suW7OzgjcVLhYAx7l3+RWmdDK7NjfF/lqYeDZ5uXPsX9oeHI78 +AeZEwNYQU9X/QdL4M1RklF1i5u9AeJz7wPyBecMdRpGWtS9bGJqeSmxpyWw0b/rKeMJHYhsAxbEN +WPkay7Dprho1OJJbvc97i0huli4Zy5N4nG1PO07DQBAVJRSUgIgihi2IrRiLnygSUSCUgoaG0qzE +2pkQE2fW7CcSiiwqLsDSUHIDJKQchANwBypaTH6kYDTFvJn33sx8fi09fy+9jXi9h5hriKXpQiIz +2ycQWSo0apCEu3FZtVkAQt9T4l6v12rSqgThBKIVmEYtkaQNDOEGzZnIssvUoHZyY/OhFsxJrGMp +MakkSERurELPLxUTZUeJ/q/lot7b96M93gSFJZkgGnPCLCW8sP0YVTBRhZOb/+vx5ioUbOECV3Qr +2/Ptvt+cD3l4K1Py2BUx/6m648Lq+pEeP8oDQBo0ILbUokEA2rSlNQ1geZojG2NUaobdS/XxdDgl +zYZQ+KGRrTsrMm/4ZxAdBIfHZfJy6YIPg8J9bNVd73z5fcS9yg8i7otC9wNeVyp8kx6ZzkvQqdSm +w/F7t/FX33icATcAyP+QBJAEkOYUucMbPaODse9+Gk0thyiI7Bo2qu+R+s4Uq5xEvo8V2AklMmkd +THpsOWUhu9uT3AE0wUMYrvBKuOwroXhAMtpXDsw1mnRQ8wFgTQ14nIVTQWsUMRilh/bQg0X0YCvV +jwE1I+P0IqgtFYtUKIirULyU0mZnvunGziZrJrNtWYbFfyDkXIvgXxAPXvQ/2KOg/6Hg1WSS3U6r +4mEgeXn5vve+vPl2PPn5x+TbX3dZtyekggEkEqnCx4Ir3FcRyJKvcb+DCjIpuhBwkeJiv/vm5OPJ +xFQyjJEmHbIxDbARUHguxf5BEAEJYfkhcNxzCBlUEQyqcDNq8kBkQDmsSinkX+7YVX1GAkXlDqog +bBQxH0BAhyCxL3YxHbWucVdqUK8BEsEL665nGZG/YPwsuzuxBRLaznEkc8lfdEzS2KtSclfHYdU9 +29DbcmOMu6hojLw/tnQON+zNUK8czz1QHSn2CsiEhBtFBLSAl/chFeigxjS3IhDtV5go70vPfL99 +x2xJGIaxEuu2DqkF4X7P4LFj26ejjDO+Q/TP+PoVxvs0Z+mWmWbZRa4CqEIrXV88vKnfHV2AAlSH +KqAS+S1l1tgtMO8bPV6L/vrhUivxgVg+GxfiB+emzXgHJVOFYbVqLbEjkz8yoY/0/PyIXlfISp4o +Jjhk3AxwUOn3+uow4/WZ80fc0y4swFNmnvKZiWRkksOMYgkJzXPwo6U8HeM5Umdlu1A02d2279hD +qQ6gjR3G07iuuZOLNs1bmXf1xGR+jRdsxoS++T/oR8dzL4gjr3eYEQ7qoIcm0adYXPcx7+cnFkb/ +6tAqVcFMB72yNDts/nUm+qZQo4SvMZrX4qjrCHA9HSnj4+OMnx5UNjKrr0ua+zGeFTQce7aWg5Kn +mDGOafBf9TDmnhcZFEqaFAanupqIzY39phUWiuhrh7OfLqcTX6Z+Az5MiTDwcJfsvVFbFNlmgFu1 +SZFX2QJ0FJ+UeJyVVV1r2zAUfS8rjL3sZQNhGMjgqH3sMrqylpZ1D91DBx0LYVHsG9erLbmSnKQL +xT8if2HQ1439wV1ZdtrUbrcFElu69x6d+6GTm8Hvbz9veu83ItChSsZAvV4P5rnU0ItDLyDUJ7tv +yWKDEK6vREgmhQhNIgVRhaCMMa5i3SfaqETEg6G//LX5/Ay0JrtkvxBM53wm6IKEWdQng3EhDudA +/YDUgcOAgJj2iTWIaYAwkSxMn3h5koNXrUGpZr28fLZXIhH7yZUM8RjmIpiBuUHcthHDHzDCPDEQ +ud2h/6Z6KjCFEmSxItLAqySztLVZ/njytLTO1xv4Y0AbFkoRFkqBMNSb7jAN5ijlsT5SMjutyoIl +jJMpaBKH+GokMedAMMry0rjghggZQX+akYxfoB+fGFAzriKNNXBlv20DISXGakNsv3KDhR7Vmbnt +6Q5uKbgsEoXNdMA7HpJH+JYh8+rMm+hzblvnTptmDJt8LE5gduDYUs9c5VDKCaZyP3IME6kAgzEs +VMANNEGL63uuqYzRb4BnUX/YmLpLtzaNNUxJLALLC31OK4yAWFqWVSrHPP10nmgWh8EqgTX2jnxQ +8/WDzjTtYdT3u7mVd8gJ2eZ3n94DMK0Uv/4jRNmJIeT/oXSCaMPDi55OvsPu6+1t0lF8xDzuBrW9 +lSkwPJN+OP14wpwoJJMriluN38g93CAs+asXJY4Cn/HEVIri9ap7X412HYEUIDTUXWafGbmP49vQ +2doiZ/YCneA449VOhNHsblRFJOdKA3V32bcIh5cFT+mgmSavEBFMEgGR16iE1+jc7U6HU3tLFGn6 +WEQb9t3fvYbrlbDKdYD51rXYXu5tvvyMiuxkJcu4iEiKgI+pDt6CRnOMlJ0y81CLGpJr/xOrzXz1 +PmprTbee1HIycoEdXf/Savut1ba0Nq6q9ni5KquVJPv9A1uSISb8BO4WWd8GNX2YsVxcuwUP9BiF +ROzueJwBTACz/8wEzASQFBQeV7MiReSlT8/ua/oCYHKsnU5JWZEoURQ0JP+TtSh6485qRKMnN67b +OWtW5LGNqwEU/h+txLQ45WDMbT3xvXYvUnAA1BYnWyNH/awKF560hiAoAEC9eAhlNzH2q6fLgfV4 +nK08bXAcxZXVG4wtYcs2liVb/qA92GgXjddaSf6SLEDYBgzBBtuEgCSk0e6sNHg1u56Z1QdCGZtc +KC4pcoQJNBxXIVd3qbpUKjmo++EilzvgflyoXD6cqlSKy0ddSO5+pC4Xkrur/Ejlknuvu2emZ3Zl +AxVXWdrtef369evX73v0j//R+tOvr33lHqLdTA2X1gxv5qQxa7o1o2jSslOdpZpdLZmD+CAYIX+S +sdyPf5Vc+iohbw0H3/5u66Vf3E70QwdbKfVM18tq3oxJHdOrO7ZZotWpR82iRy2X4nCxanvmgtft +0ulKdcqonJ2xGHmY3L9pCWbjP7foWDUPht1B9ot7SNc2Ojw8TIvegi4BonkA8OrDZCv7r3NktZ+G +civVWm3xjrpd9KyqzaGpU7dP2EcFAVktW5YPaTZHlyS9QKPlDtHlXDan6Ygvl0Zs2a5VMs/OmBKR +QMt2jpHdD0YwbvQw+phFZCFA0TENL8QwMm1Y9mByLKsuzZ55hGz1FcZQz6mbTfiRGG/GAfV540YS +T93UcPfKlMfzlnNDwVK5f9VA/4GDBXafRbJbmshBuVq3S+wzFtHZ395J1rJ9j5LHr5lyDJu9+ig5 +0oafSkAenTMqdZPRl0gX+3CZDLAPnyMjqyUb2KfPkaeiL50Vso/NjpLW3SWzWDEcA7fsUsMx6Tmz +5tEp05s3TVsKFwrc3exCmaxinxoj646LOWbpI4ZDh2n/EI0kI3wSclGVFHVWDy2w18bIzqMV04se +fBg+D9P9Qyjzbjx8lH8bpgfgQcVwXXosfMC/LbG/HyM960zYvKDnYHeOfW2MbLvemq1VrKLl3ckP +HJ4cYpfKZMeNYlMC+LCWyyfEHOVoqJWtK5EtbHoTWe9Tqo0qpOtN9qirW9CThOvUW6yZ1XKSap1K +enWapFKnEXXj+Uerlr0BL5aUMcqF+7xJNm273cxq/fqAvl8/oIfc1w/qh/TDGrt8P9nsnzMXXb6Z +vFt1vGwul/eqx8/XjUp2VGLT0huJ1tGU/caDkuJ4IEl5PI472Me3IMfGgaP421yogURnQ82lrDLI +zr9AOthN58nGe9XFIwWQpnUQWZFvchQSXhKr4A2HYpxJ+hXQ9amdsZEi6fJVckGq+WUbpP06nXcs +z5iqmPJiU9Ouz5qOOgICXbam63KsbFRcky6vvLWB9C5wuZxY7+DV12P7Pkk6jq2wy5jyQ+8R0yqO +if3kRuDOy3OkjaburNT7KGBnZ5zqfDa4/KGuzTbYw0GqnVm0PWPhuONUHY0us0/OkRsZ+TjpuDYG +vUuCnjbLpmPaRTOEznGxARXZmjCUQn/TGTC8dhXUnmc6RdBZVYerqeuFXACNuA244YUhdnGMdPp2 +1TumDkuyhWQKjeMuzk5VUVGc4R+ymhjQJBBeJzT3hr2YGxWPxgG4T6LwFkZ7x7k+bCbs66fqVsUD +GzLimKfmbSFtPvcaxDW17GKlXoJv2ojjGIuq6APVZmmQjibtsRhXzFm8bbk3nWrxEBoIGBwP0SI/ +3jtqlXsx9sRoegHBoUHK7n+ObGZbzpO204KvbjZGHHoNnHVgvcWk2OSWzIW0H4IeB4CLieJqpnib +MMzxHoWM89uX4EIEwB/pfHbDLpKeACerP7ThQfbRdezFedJ2Pfp+9zlVr4pKHy4yiPx5j2xnrzhg +O6c9soHZNbJ5QwIMNsI+9wTJsonnyGr2mxfIeqORP3i7QOfXwkmNV+P2ug0y5HKhy9GaAxfDpRb8 +jy81jFZrpuNZJnch2c8eI+070ZIsLYcyjrcH7JM1jR4I3BL2/cfIrr0cZsymNHw0SAv6mM1nKfdH +KAX25ilwVG6Zgc1ELoOfdBn6htJKBO+NFpvOpMFQtxZBSI4IuhK6uS9BGsfREiEJCu9s8lGEkLEJ +D3Ip9LWtsoU7HEANlFwmBRCukzoJkKkZy56mRcMGRyqijYJ/ZGB08FjGtNnnfdLOfnmSHImY1MIF +oLfsmOZjZpMromoqFAGuJulwUPjitk1ShZ4Nh1HXohvQYrl3wIKmnWW1h0B/+8fhVF6cI+3ZOTiI +5KEUGhQ5rhKQQ1u52u+/opO3vNLkTaxtgbTtazzuwtAKRgS4XQh2XdMZ/OQPq9nFLOnMZ4sYTFHX +A6Ge1sNTGERFrNNqjfuut/KvEALcwpYN0tWGENHDHPtUjhT63x8eapvzlD2yK7Njh4SM8Um/Bn+N +s8pW0rVXiqrUEKCxshqy2BA7jXg3xZnFzpbIza3cv+NxE5ssk64ugTQUOK5w4OpOmY7O3vgU6dwe +h0YcfSwhIQY2Mka6OrOceA6C/kO2u9AdrrGVfdmAH1t2k3XsW1NkdRuKeHRircGGNdSXonQcpkaG +WFImb9S+fXSEHjt18uzEUfhx/KNnT9zxUMjM0Cy7EJJMVRfCIMargq9h1MC7rQptftKcDzeTw5Ew +2C1tNNGOeDOGF6Jkt5XJUV+wMyWxzdRIX+K6yGNRnUWYG4pZEoizbAWZZJUnyMYPAQR75xxcXPs4 +uZaN3Al27bVpsr4V9uAZ50zQt+zn02R8I6xmhQYL6SywxeNkB5ucIWtaogds6x3khi3ZSOaT1ATv +HNsS7Ni5uguv5ei4Dn5bzXBcENwozuQn2iI9ErjwA7vJwzsjLTRbLdUrQBLKQB3UHLLVYu/8Aagf +exDUzqfrsIXSqszOoHppTfD6f69hjx0j29bTpfheoH39yqrM9uBfT+xkh39H2q7hniAMdbDfrsps +6JOMy4q18naUA5FeEvC8bNQrntwi4Lu0fok8v25N3jSKMxCJsJ6L5ETnqGYkVKuUGnbLRfDblpZz +cM/Gc1kAmsIAFYJwm8M5uKU9KP3ZCZ3OwgFI1vALgI4XSOq9FgqxSx91S9VZ8HhnrOKMVPzCPBrF +oum6CIJRNFjlhUUhgSat1j3TdyB+NSowFQZRc4A0w3bNPKCPbrVjFk1rznTQnctatm2CFRJ70KNn +g7Run7Or83aOCp/QKtNs+JD7PnxiLgyX5f32+QUfaj5DMRLRtJBwR3kq54cpGxGQhpi4/Yqtl4NH +Y0Z8WQWMqdrsay7Ew7c55Nqt85Y3o6DGo55EezrJ3jlJtrG1T5Ctq/hO2F9eIBr7WYVsDD47s5G9 +WYVv6AoeqCmej3Ako1wW5+9g9J3SaRMVBH5nj8ySzj4NBqhGe5qwXOe5qJy8RdwzQ73F7psFw1ea +JRs1zb3aZPadnRA7JzNCKXIGaWT3omEIemt1d0YJ1GFEcjuZNUOwLF9qiC4r8LlsdLKDo7GkoCKX +w26ez9UEUfRKfAjHwHsJV5DR5jKreWTHBgkXHQT72BjpeEBwfyiUj/CrWHCIpvJ/3XUIYgVM91AE +jInA8JsIvio22dHZJPuAG2D0GGm/Jvp0nbK31KMH8ehUi6ckFhLOVw1cVNNNCajIr8qLA7bIkPdc +EexV7Hi9UXxbpLvlGMEzM5uZe4Hs9Wt86jB3DziarGc405j4CeUEhTYcO2cuKgeiiBJeZslpgOHX +WROeiZbDBWvywCeRB7uXAGYZfjmmf4XzXp5UpF/KH4TVFVBE+ZWJGkrKCMh9GpRnDOQMP7UPlVSX +k3qG7yILM3OC5A9IcXMyRlemfFkOgNo/CycuMmmYt/WMSkVIQSTyaAkgIrI87n3oKCWWzW79O9J9 +w0Bff39BKFykNi8RwJFz14q9AYpop9zIKa7l88KgZLlo5BL5w3sonZQIsspW0ZlxTBdsowt4R2VA +uLA4HoMInKXbF894VQdTFodZ7c9J54bkODh2EDZ05bTksKbqwQg7z4EikuuiITl/rRaNaDk28iWy +qV14p5ONyUcf3dOD+mGdu6iH+C8t6UpxoVAuPb/tMRkJ15Vr5dRmGwGUydfFD8fZ/k+Qgz7XANwt +LS4W4VTnq/VKiXsEcNVnLRfdpr3ondBKtXquXsNfNVqGlebwEMEpRZUs/FALozS3PgVniQaQcntn +UM+aNcGs5ltRzeRBLRTrjgOOCChk84DnYbxnNCvWuIrIgeaBNWcREMkMyj/bw974J9LKagOZ9c+t +AVfsvl+tYs/8G7l2neF55mwNVShsPli/vatVXg74yn7dSton0K1R76F8buI498SiyyHuhho+8uVR +8MLpGnhCZqWsDQqRD6V8QEq59EwiJ0VXptEiXKRSeuZdTe+HwLMSommsYzTF5jfF1hR3M+QTE/wM +JiYUvHSuapWomJWPAIAlzbDuiOyoJpWTiolNzF9lw9FsXhsUhSQVg6CCR2saexP9lX9+knQdUty7 +XMrfi9ODnHUQGoAshihZ7Xim/Voxxi60AbpvXCDrQ5UlxhvULmf07eJh4sTFUIORiI+syeLXKQ9i +Cvqb8kgBzTUaA87csgKzAosb6fMgqK1Pw93FfAzwWV5OoDO0Qnw8ChbAVXz9AunamXjYnJ57+cOQ +S2krpN40UPvVeZ5Ki66aYcvYIMGxG8TuEBBGAbvFc5KFEB2njV75COkoe/cF0lFqODw9smQSsZ4Q +uWhYy43LpEQjO+16paLey1++QDq5rN4uiUIARdTnMYSfN0SQJTcnF3JFjdxKcmBjzIFoz1WImjEj +ulblNGdFezNW8Cer5ZNg44X21eqp3ZIU7ubHBgqaZmU5IMxhlOno3Gyeh9u7wMtbHo/1roDkliZ0 +DyZuI1vZ0RGy8XjoSEs83MWTR09vBTx0MHwWy69AyCnknsF4cPmhdt9VuJKgcRQ1vY5WYRzplFcD +dulYpptdovl8Xih7HT+G0ricS3iifDHhwuFOsslrCE5Kn+fyhbC8IS1TVqSZ0EeT8w0vu7eQE4F4 +Nhdc/PbO4GNvr18jvZwcu/wWxH4SdtaoZSPtJ9kkJFJa65yUQ0EJmySZ7PNvklVB7y87WO/XSBub ++Bw5uJGGZnmQHuid6O3tDd55etEXnIm9K7HT2MQpaVI9ehSZseZPE7apEUS1MH7j49hoiBJDaxNj +0HzdSLdegawIRiD3W6+i/lQaVGUkUo4FvRCuIK88/pIj7+VS+1pcLeEiK85DeF54Hry+FVpvXqcO +ZSRfMe1pbyaXL1vgLmt1u2SWLRv1kqKWJDoYR2SuV0K3zK1VLPDFxmwtdx+XLnyOwsU/5MH/djz3 +QXDlstoSxFe30rvPnDqZx4yaySFycBf5b75EWLsTqzDyhcwNweUnVu3jX7FaJujVw03ptHFEA+f0 +14czeTbzNtl4FOsusskCAmh5Fq7Ic2JSC/CC/gUPsUpLplmrLFI8v3lwFU8b9jQ/eDZygLSzyYHM +DQlX0VdQK1YGHO5GD2PKcKMiFnrVK/lDCIep1JwKDLRgyIt6QJ3nqxPLwIeZ5ExxhCCGUaZNnR3G +egLqPlGfWgwNtBZNwfynzAUtJ+vpbPiTpOXOhuVEsPg+lhLNMz/4Nhl4IHZxbBWBJnUTr3QmPUwg +7dS8HeI8ZorQM7FVUfCNH0ULh1hjls0YLmBTl5aXRTyIZuIxhdOkccB8uJwFHEMAxYfYt8+HEKkC +QU8FjQXPFKJucGX2uoLxjnwAN6Z4DuUTFATwE0a5SOl0qu5h1VSI7my9OMOn5aPVRzGmgrCyYs1a +HhqM0UKvTk/AgdmWVwoDXG7CRPK+5s2E5SD8eGRYTKU33URVHRGLeagm5IyentiY8a0Hn6lvYrXb +yBq0wlvuCm0ZJlzEEnsopzHH76Fl180mhpVHi3DO8bLsle2Z7R3xd2ERxWGwi0+TzX46JBNr7sry +mEzkIewimrroTmMwJC46hxlSpsoafHq9oRR2Tif3LKazcD65Jvznm9Yle2+mfb3Bxokutu8l0sK6 +DmVaD6MSx/wGHvu8sUhL1Xl7UNNX5D5XxRiXB5P/c9rnYbc7iwiEzPCFeVBdBnURqboqkFUG9wMs +RJ6OKIwVkuSes2quInnFGRN+ngNdCFauiuF1zUDHyBOSZtpz2MqSzwcvPb1xeNZYuM90zs5ARFA6 +g9MfcI1pE5sJj5lT9Wn6+OPwceTMyElQ/NrAfnAUejVQ+FoffmI/eiHz4875plyg7MKRzC5WfBsi +mNeOZNYPDKqKrDtMfWOTnhLxg9jwQ6B3nzgLHgp79W0yxZ56kuxhz7xGrmE/fgtE8zvvwg99hKzx +xyYTWaF5pwqbHaa9yWRRuKai4/Gf1IlUi7Ox2pDILSIlu1JFAo68p2coDBjg1p1Z1hV87gfEpyAB +ZcN+PUR2KgVKkBXgJohMuAvFX9/Gvv4k2epLYYuSJXoyDoq2v6w6p8mUtLINfpGRbRbnJPw6Qgt4 +2PBR1RfiH9C2l/bEyw2ln9Lh+CF+ZsPDpLM9pyb0OCfGJtnICNn0IRktdFlA7KRSKxYVKa5rPct0 +9tZrdMao1UwQKTSvZWsB8MMi8mKgxgCJRuU7P2PaJs9eg3hyseLCDk4XqFV3Jh88/bQWtAYbMr1a +UPjfP2Of/xFZzdr6M92MfiHTSnq5HMd5MjdOVulUaaoSibMpk/t3uPEmZTleJxPyLbNpYlZ0waNL +nE6WHU50cPGrAltL1f7CQrLlcjMjvPZg3cYd7FeLmXuja3Qt++hthPI4ix2+jWzi4cV+YHxcJU9l +BhTl7tRtHtWJGIbZI+SGNgGtUzn249tIV2e6OVTAjKMlyLKHljIbgne/tYV9c3tm7bVmHpsLWGEY +NMXjRqaF/eT7RGPf+ApQ9syfZs5vCIMS5CAKEXt1gHQOYppaU7d/SoaHhjNdn0WVNFt3sR0X1Q5s +ThIyZk+yC4czffxwt3J/HjxfXg2S+PlH9hdfydwYHfpxfmTCtQUI7u8gl7lPfxJLmo+6Ui+AOS9x +R2XKDCu1lI5qPBsrktxhfZMzi49wAR/VEtEAgvuN8M2S5ivWeFHy1U74hCjuccNaDi7lmBV+cXQV +Nl+KMjzSsmPLFw8rMGQX7Q6i8IKAwd4v3uA370iE0BZ0EDcsk7uXEGY5lFIZp0wma1EydYwVnEle +J9HlveFGG1zlamUOVYGM1HCTCKUFzul2f5p3M2Qn4koyGOKQUvq4bEzje8tGBSTDdueB5BLmFwb6 +KNacJWm5hvQGuHalCjAYLwJ3rkGJCy9bh2c+xDniKoTtqvGz6BGGeVRNhyjoRZkMkceFMvTd5bJw +0+LxJhCtHASL/7ngu6O5dvX0wzpLQF7cfLRkOcAda477qKMa+iWJ0qQ2nlT3yUYd/o8Zm8hmM/wG +ZxvhXKajIUujRu54oG43PGwyxMPdcWkGgi8tbDuJH3Kq1VUqJQN92FfJ2340PT4+GIyj4cSXcXbe +yGz1l9OFUBQ+iIxT8sdbNELRw4IEFzpeZOt24/5AftGVzOhKYhNKxaAfkxqJisgcYGVNmC4+rkiP +FKzm4iNo4qtEjILZZkUkRWPuCWVyR6hNFBiFxYqAKThiWQwB2XefJNt2NoGIQIQ45hLi2FgJjqZx +GfX/CDKabIJNySgSHMlb4osx5Zq27yWFUVctMOoN9O1AQkO1uZJsFlTRTMpjOXqHQLTP5lQfij07 +R7qGkzRzwjxlzbgPLVbQYA84mJbjQn6sQciLWNhFHLM1fEdG9qei4eQl3egL91lERIWtrx2+OKhB +etosVp3SkbAlUDZe3MKj5yKg9LBxB/btzVtF0PtZG4UaOSA6BDGcSib8r9AdEJanAZB1LZN1zXTa +UPDmyRtbwqzwUFxHBvU0mSoac5qyA+izJFszks572PXDoffnRI+GWmcW26Q92O6LxeFtciTXANPT +wwF2rgiAgXzvijCixisa4hDmiBzRw2C34XsDDrl90KbBlxc62aJJrscXGTDFAIqzX3wqFHT5QgOX +xecXyA5fyn+0gkTN28gVCZSSnszc56NZ0YCcnap685MOH8qmNzHFF+l/IR23ApVgm8OGP/DNzoiG +GXQhadWuLMLpVR10DaoruT7dwj+PNXY+8uE8pDZyjFD/zhh75tBrsKu2KeJnjOjCusSukLBccLFH +vOOxNdndE5/u/uD+j2z21RsqnykNB2ntlWzfV3BdpadIFcyhWASHqC+6jMKVG/WWZP1BSdJya9qI +CUajLhYKhnfhys98vfhrT0+Dut4otRdvmh7PAXL26TmyM/iy03brldVYUl7CYd5aKA6D+fOkq4V7 +idgvw94ZJe2FZpYmNr3Smir2N8ffs7kx9kX49iKkqVd1HmrSPN7k1RtYyjNll2TsUbjUNc2VZDQ4 +f3oz+3mF7PnolDlj2aU7OQrgWkLxtaZNdGzvk4kOOmcZAkUU7WNT4O7gLX9dpjAUFHZ3bFccg6Xo +s5QL1AOnIxyRSYxGxhteCVDJzuWaW8Jx5thkv58EVTRJrIeSL0tw7kVNoaPjozxXN67aEoHzLABe +lWfBD9p23YvJoIkrtJzhP6VdazQByPVTvOJ48LrfoUWBhSyegepSiBqkfZzr16c5LcxYawzKVTAw ++ix3QmPG85Waq2DFD06r2VRzkVx7VJMItdQrPPLBbPrJeKx/z64QXwrHtWIa5zCrl9TGeXoCA3pM +wkxhxlL2GQrXKs9GniBdvmBb5GOldgoqCslpIhenAS1c7HSw10RGQnd8uPECLS2zH7aQ60tSLBBx +UhqipYQ8cADVbws9By6APMVs8sq1UDj9anjJLu8k7TR6TyAtw3cJKrk6O7KSOoudZoEgJk/k+zGV +x8gC2TYdH3QCfcjU/ibywvGUrQpqD7GhW1Iby6X61bB+d560n+RQPEfNM/Vgdx065XCRMDBHB16Z +ZWBbgQEMm6ueM8MuctSUhtL+JZq+QCf6HJEtzywuBmQ1+WBqMU4GJN/7wef8tNXojMoagpg9pNaD +4nzXMI1ef+kUzm5DYiZ42dl8OPlWfZOo+0ovIvnNbIn6IlbYN8DftVBjEk1fKUiTVi7c+nJOfcmI +7zg+7tHoPY7RlQKevIyPwo/jV1qZR6ty5eAPx7ew7z1CNviFULMUmr7fLB8iGdFl0q4Wo6VCtHFt +5eB1r8qYpmVHlVvYstnlv5fQLWWgyvzFsbgjTr6YtiQIFBF24/szjYeJeHzTTrkrhfAgG9/DUSSk +ObYGZH0pqQilL9qQz3e0FIq8vKe6/ECXYZccfR4HilhWTklCuFUxIbsiwSmRlgvlOpoTx2oXSEch +WqehRXOFOJI38fvhdw7Z5CQaJY5bWg69givzXreFSNam/cjwle9Yn+HlZ9+5PaOxvX1kdVV092u8 +NUJI96gmo1SdTiaC1knxal0uq+1xhbMuDC0vLcjKrEilYh0FC0vuol3k7wFFOYbAuHiAPfIkuR9L +lKdsUxYpeesvJrUHseIShh9cv1surSBTdVTxmFOwKqDMDfyjHdQoo+tqyPLcdN3EP+JgmyYQNYsd +y1HVhgdt6K1Kb6Fi+Kgngcy8Ei1HQcgwHZtcsYylZkzU6lb83hEw5S442WzazcNUAY+PYIHh3qHE +s2bFMV4JDatjYiKEQSg0wRv+Zp+PqFiaksOzMcDpK1LzfonBSHWbRffQAwPcVvcq9EE4m0U/9T3S +h1J8qnxVfr1/CvtpVqUQWxeUaydcDHnHJPU9Pe+Dr4LuERmp/hEpH0TmrkB5GOIi7Uoj1gcgn0vp +FaiPsGNWq1cXrRDue9jOLen9JHGLLAdur9DbFwlPDMPO785sYb97ObNmHwIqG+YtTQAbU9bTo9IS +GHdvZ799OdPKqp/LrNqdj5swUiWjnNxMTw8b/3zmSPBNv8VXtttDNSVuxwKe3Ds+SKFaic1h66+i +C3TlJuoJqYdvexPCpCdPR0kLYo5lbBLT17ubp/zVN4vo8rP+5oHG3GdkRHW8q4rtj7z94NVPdLHL +75LVvBniGl5ExRq6jy8OiXKejEBdbRliD7HGYPMXb5Jdo2Ib0QssUTz4nmrw/R+kCE9/cFOwNmgL +nnpyfdD2m2vZxJtkPVv+68xfBZefaPNjZ1AIrd5f6Nuv/OhVZKFw+EBKAHiB92oocFqMpDeBIlN1 +nv3CUeN9VliT3Z0GFa/60vhVX9k+GteLgsIDdHvqeNQ/kAYe6WfBIw0ddDyxq7nCzfIDnBVK3UF8 +VzzbJgDjcXcnW/os2ZDFxRuD8gS5XKQuPfcU+X29H/+GBP6tEbQfnlU8JxwS7lGAIrQqGO5V6tOW +3Y15Ma9ey+Yu/cPviUWibs3nHsrcFXT8dP3DWoxriWK/9mKtin+yY5COduf3LeQfdbvHdYkNB5eo +cK+6uQR26wJ/eKNkgW0cbq3GXvl3ckOHCAXwrsJCegjAXv0hab9ESOaxv+F9qXfVbScUkaj1Qvwd +sGnDmTKmUSgqFd4xgH3z+CdqMCMhHBvwYbA3EA85qP5s+wrvMgXd38teH7s4oj2cLrHzPyS7gx/8 +Sys2baT/EocVxRbcSKQBZH8NZbu/R7asLfDuUDGFXdyd6WQ0R1rYi/eR67qSqOSrULxxh735Fulg +W0bI2uDh7+/owOT5R+4VfyRJCC+99Vb6/H+S27DfvIW9dDPpZ5ffIXMrdNXwThelV0JpS4j+mESo +E8uW44L+1IB5Gh4k8L2E7dfzVU0GG2EzxWyt6nj5WdMz8qY9FyFLjPv2nGyeUBp55B998czotUdZ +JuAdN+A8L1RBgJvd+MH4lXqlZSNunwA6KK8XYEMWUnUIuat857WzK24RJ4DAB6+f3LNNrJFNZhUq +FnZDs4lNZAvJPr8709Ei6tbDdPTZFzv8sDdT7UTjACKPhR8b341ZwryoO5joalQQ6FhOuYdDhHZN +DiShwAnpPIFVQE5Q9EoGyhT7v/UQlsm0V5Xnq0QklTdQj6HwQiSBr8aOapw/4t1GZE069BIMiLVd +SDyiVSgVX4EkpIgvudwjMvdoksAHWJTuTvJ44CcHulT/YuZEy/8DXZss5/ACLA6FVf6EYRjqgBxc +G5eL+JUNeTB4nLvFdItpgxijCPP/I3Fe7xrcXt+NnNCT7Sh5f//TH5O1GA0A8aMPIfQZ4ZbC1RNk +SB6kviDsSrz5WFmFHD94nH2QPUsDQRCGEQxqAkI0mEIDkxMhF4+zliSFCEGioChWYrFc9twje7fx +dkOUGNTWTgbUKq2FFoL/QsE2tUW01MpS3EsMdk4zn8+8wzzdxL46sYeV3o5NicNye8bu9oZhQeRA +uEACoRgNwfPrnPo0UER5IjD2zZwhmWjwKjRFWIOmpxgQWJAaJfI4cKDmBVU8qyylGiG31ZEyzEIc +tHGqoIGvlbnTQe65kItmIVsq9VUNE1r9DoAjAqmgBSykrgX1UCjhCG4BE1IFxKe6RhSLImhDCbRS +4ZfUoS78S6b/UCJBCw/YNmZnitgpJyYZ5VwMz27j5UsKu29J/HweT7vS1jt9T1JpN4nSf9OCpnmd +WR9Jj9h4vzaPU+/TeLU1Oxo18DyVwZPlPOYXE3h3EZ8whk/BD6uIt4dJ/C5nsLuZfFztjR38ABez +h132Az+qHkMRxcx+KHA2+E5yJyUM/QcCeJwBNgDJ//EO8Q6wRAQUEsXRoN5dtJnSrCyRq9iS28Ad +KgazWAQFAxRkcaNVLFRcU/lS6FJ+7rEz06TUFLrPGW7zEuBps512tZ4CxpUgkb/SxvZbnTH3eJxr +l1unsGEOZ31OaolCQVF+SX5JZUGqa1lqXolzYk5OsYKtgoE1V3J+XnGJQn5eAIoCoJyGpoKtHTZ9 +2trWXOX5RdmpRXr5eRpK8fFgNfHxSjoYxmhacyUWcxenFpXopRaWJuZoTH7AKFqPpEVTR8FQE25c +am5mCbKBYO1IurE4BkV/UWpuflmqT2ZxSWpeahEup7FBtG+eyZnHCgB+6mgy+xGqgfXWaXf7xUfU +tYKtHhj7YJ+MzXicjY6xSsNQFIap3UrBpe4/gWICh05OFR2dnBSnUuT09sYbSO4pyVlCKQ4iPkAG +Vxdx1M1RCj6GDyB09QF6kydw/fj/j+9tO3z/Hn4saDSxbFw8GwCzKM1yO40IzY6OD+fUsSUrd2z5 +ivvA5kkcqbNot54LC8MeCwvGuMLN1SUkBXsJkxJZscptYb2yZuKDhKvaG8S3hDVcaVPCqhQVIznB +SaWtMDBW16k3Cc7OsQ4dRnylaF76o4v/PAkq11pm/m6KuJO0H2xCQNuYnA4a/ETN48n4+eu3d/RQ +01NNvc+aDiZ/ezp+Xgr9C+r1bGqEaBVz5gR8f0MSa6RfVdAceJwBvQBC//oH+geQYhQZBa8h/4de +Dg7s1LbXYhH++qJ5vpF2PBTcbCcEu6bzJV38q+KsT7w39u04+ZHGkBQtrI8CuugvEHiProuTcKd7 +DrVjRZNqASoULLmdh/A6UG1YSe4eTVRF1YQCyy6TqAHbFBVQGvP/SQZX9FLtM5Nw+4fBfcv8kxwC +GLOvAhUBNirGfL+5FWHkMyDI7JNwKSaty85fNDAwMDAgd29ya2VycwCSRh/1bsyU8VpuLAVWJyfW +FRrS5nDtVun9ByD2/iRcYf4HFGQVx3KA9orlsPaDeJwBfQCC/9Aw0DCwggE8AtMRHrmL9C6lEsYe +k352LnPwkZgxMDA2NDQgYmxvYi50ZXN0LnRzABy5DFbVTWAbYc8bxrd6DwO68LGWs74BhAYUD74a +g6Dq3+cDavewSUvWdLJTAgmzVggqCRRrpZZD6l3PQGMqD+pD+0VixJ9yrrOUEbwGueg1K/UCkm7p +PzktquyMxQvZIrAMyz4AHrN4nAElANr/xhPGE7BCBxQBftvVG7uP8L3e5HygZOWEOX6xMJPPBxiz +bgdYAlQlEUf9A7UAmDFKBtDXH6yQHVzPIMyC7AjieJwBPQDC/7W/A++/A7BYLpO/XgyThXQXkyCc +E5OUJDCTLGoKk5+cK5NJagyTcCcQk/8uEpNCthwCd3OTHGMZsx4vl7ASfBgq/gE7Cp/1KVUAfg00 +RpmECGT+FFneQXicAR4A4f+mAaYBkGQUpckiASbM68a60iKpN6riLBd22VCReC7OYA2+9wUBkICs +jlPClGpzHVtUiiVYpnJYEnicAVcAqP/GmgHGmgGwzwYUArJ7zRIL4Z0D9fBNEZmmekcHa56z4wa1 +BRR4X2HvlQo2CydYWXWY5FFcdzJ0jLOsDIopFBGprGa94dWlxyBpMebjyitpbUDRs0o2/BaSESda +4AKS6E94nAEgAN//rxKvErCkCBQUbGb+aNMtmh/EQgmY2nj89x4kw5O4CHfmGA6z4QKJ6Th4nAEh +AN7/5g3mDbCfAxTMra+Ao3SmEDfPRllVcEQo2ySuqLOzAzMDBx8OjO4BiMcTeJy7wHSBacJ0kces +GQGyWWe2L+JUqVUq4p5T237vysTVSwHD4Q2o4QKH1FZ4nAEhAN7/nRqdGrDMBhQbe8RavKkGRuT9 +LCZU3hT29I7qYrPgBj0G/h8Pg+ACkuoNeJxbL7ReaMMSDpHH8aXNSyq0Yypyglcu+D2DUTQxa+Xk +HRzlAOjKDjfpA4A8eJwBOQDG/+YN5g2QnxR2fb6rFaFEUc9SFCb2PN1+lN78jrGzqAIURfEhioWh +J174W+v9lt5Yxk+tBPizbwN3AzzuHMfjAonoUHicASMA3P+ngASngASwl/IUZNdRptFgOV386nqc +fVgYSJ4QGjGzq/J8DTOREKBsiecVeJy7qLFbY8MX7s1cPO4cACUVBKThAomHInicWyK+RHzDNEaR +g3mTvka8UdTwlXLYr8b12jckeUfQ5lWMvzgB7QUOBeoEiYV2eJxbIfpeZIMOh2h0rI5CtJKubkli +UXpqiW1SaZ5SrM7kFA5VKZB4SWpxiZKOglJaZk6qHoijV1KsFDt5M4cfC1B98WZuzrmMAGhlF3Tq +A4FCeJwBOgDF/68SrxKwXAMUGLe7ygWn6Upqwswjql8glDpa14mzcAMVBRR9zNaB/u6Y45cgJZ8V +ExVfRsI+05OZCJb3xxn6bJLdPnicu/OB6ep7pgkGG7cv3Q4ALv0HGaSmAnicXdd5PFRdGAfwIykk +FRFZkoSEhCxRSW+kJCUVk6Zr5s7MZTb33sGkEG0yllZatMtuQpSKNhWJFookbylECi0iXt4xc0fL +/Pv7fs49d845z3PufAsLG2trPXMKE2LTzWgclAXhoOb5l86CBXxvwT82OzZ3HPG4MNfbbj4B6QiO +0NkcFAa28dmza6Zwlywxrd1QL8tKnV0lSyPUUtflHuu9zFlU4HLNdf9GfvAlYUaF1SN+rqbWh9VL +rC1EPz2IDTH5OELBwJxrQnaDa8uw6dHBFQE6zyzUzg79RxgODtoNerkV/WaFixXN+0j75j1r6Fi1 +k0hRCgMJhsGSELeu0iFNQZt3XnrKj9jTRy89mksIDAcZum5JLxLqTSyLXiZboAuys9dfcBhNyQEY +BQTsaSuuiVlH8tmmT6P3V0RREzdyJcIfYrNhqhnCpjB5VBgDLMM8hc7mjTNuypo4yGdNaVGpKuZL +JQbbWINcg5zy65ePb/t6ftebc6Etm5qalRkE4KAIm45hTDAupyZ+GqNlQ5at8/yA6mi5n7EBeX8Z +MsbHwFHbrcauzl5LuVYuJG7jVLcokx4h4VAOzkSAWdOEKnlE1lhn665rZZTvZXs6fI/9DsSjhPV/ +UNn178253k0M5cSjrk6eGYqmBOIhTBxhkzEOD6WIXu4tqYFxwteNP+Gf/Hdlb9TcjF49ekGspz+P +bQ6HwuYsiI3QYNGfOtj4QOswWVfffM0+e/u6dDNLj47zv1mEwgHx8pVaNho9KvPUsrwUON10OdaB +5N9IAGaOYsC0LsZyzB5WGeJ91jbGwkz99FWPFuns2GSIyeRQwDLfGkPklUeYbO7b77e0Y2xKxsel +/DKUka2Y6xdNuTppxxZ5tV7WDtXGA4OcRX8RMguioBwMONzvWiS427GTMvd0FRpin2x11avml+Tw +cC4PJ+MQHQNrv6q9wTR0TbV4ifSIgBwNrdL6/FFJZcIoCBsn+6P7p0avj8/1VNeCTIf+yTkv/hDi +3XV9NUXL8fFQiKAxOirft0CQunFl66iiIXQwzfpwpYFmZx0tYJawCn02Nq3c2UUCKBAKY+JVXOO3 +WF5rWVwJaLp0MK7IPnO42eAeYZgQF8ideqEcoGHmappTpJDQOLHpQvEE9Fcsffea4L7i5KKxty44 +V/38OqbXCjpQlTrfkmAI8Ow9HlWzFZVJSz2N+Ay3m2xNlbEiBuFQYTrMBrGbHsJLBOmCyB9DjhZl +bXvN597bIRVMJkzBEQ4bA54r5IOfjztfb3Kd1rirJ255TW7ndkKhEMYgMyDJ33duqoCu3D5csDot +MALLmrMKNJ3dSDgMpQHqv/x7zSYPbj9orp3abjstNv2JfJM0xoCz5eVnWirfNFsiMGQ1yy8dvXup +ZTQlU2F0pDCEfNJD/fjQS6tujS3WA1kv6LfUGn6hkcVplSE9SVt1bPOb5MEcmGn7fcza++8kgopg +XAinMEBXW+yy/kTvNU0b3Ztvl34rZAq12gkietmV4cVjZ2R4JeW/OeiEFUxTuF0YSTyCysFhdjBo +vVA7/YPRpG/U/VHqb1+eXHAvL6dHAmAUZXNAc69py+Mh1Qx9+w7ff7W2BQ1OOkhsDzgYZuNkJofD +BVdJgYUmfjqumj0ZrVrbTz1RCro7mUChMJmo2stmfs0IwBfvvDl+4UXFK3s/aiREbB5FFB4O+TNh +4Jfi0J2YtJOyh2Qek9UlzM4huRO1khhl7pnYbNLLCy5JpZsrhdknAoLr3RdIAJ3J8Qckw4pxG6da +kxw6tKd/WrchbNrMvlhJzBCtLdg7uGWLIPg/Nzn6ZW9PQy36m5IiChEjdEYIxAfrNA8cuvLuvVzp +x93G1IpSZwdjp3ypwHAOHYVYYHxAsGLz6yPhguI9E/0S3k3xfKXsRBgc54Lol1OdMt/PFNL2H1FW +1td0zsRjPH/F4nU9brquZVAguJFeIvwRcaXZzt7og81vBOdzRQVPPzZM3Upw02eVggCfu3AFWLTd +hCdBCBsBFtSrai/nN36aoD94Hr5y5cGH8kX7pCmGi0oT+Bbl8bpi+o4eW90vbONXddveJRgd/0OI +p8LMKTosNzsqLbt+Ukz43Vc+odsel/2pJLN5Vz7vy3h9ps660HnLRM1laUpVbSfhOMCO+v1FCmax +vjuyryCtzvFq+DmdXEkYgIFFat6qnvRdBQpBN8ccNdFNoWolWEhDMhdCMdFhm5dU0XxrZvW+5qql +Ic4lTitXXjqY8pcRz/aJSfzBgdaOh9/PyFmzbIr1Fna5jv/lRO0JFw22YZFZZ94Lra3l47R68MOU +Oq5CdKkUUYD/m521Hax/ZIscG8CsvJC1h0w6Z46m0lqkInRMKG0pOWFDAs8/M5bGOAS26BHdgYn4 +U8xoPLaknJgzqRjYN7BdKCfsOFwz66FPwQGlsm1Jg4hkSBGmwjQmhMPiOlkx9nhM5HgKxoveo8ea +YZeYZNlybBTygsWmvUA1yDhrzTP0ogO3N2Shpk6w8dfRR7MDYdSMhsKwP0YVP9qb/3gROBSrMsU+ +1PNWUmGBzrEOzh9arJy075K2ug/4pyYvOdVwO+J28z97LKXPZePA6ehmm3Up3TOjlAseTGeHv6SZ +axB7gIkF8RCKeF6R1uOfrFi1dOnE6X6LTzyRsfaLGnKXINE9Sslj0+yMtodWrUeMqW/7OhU1N1T7 +ECHCEvdJ8Rg7OZ3CU4/uq6S11Ns+4TgEXPi6sljC2KIabkYTSX+IEogB1RLD6vE5KWE62/cv185M +MHFJ0wv4BUU7AmcA0JcUqDP9YS3XsEmDEfljHmWYny0xHC4UxIOB5sFNRSVZJz6VToic7r56fWp0 +vuqQFIgXj9ja3R9pH2Xra1HV+EoZcx3q1lekVwOEEzdc8B+cEJRKsnbtOG3guXn3VpVt7u9JEiDZ +mhhIfn05z1hn4y2zU5O/0B3D9yallrlKxUiVNsJuJuLXq/csMxHMN7XKybCuez3pt1y8t+fE91tu +np/LjsvR/sIzKlTGjnNPjhoGBiacXhQ1ZWhP/8Dkz8PjVsW/m1K0qZrIYVFDCjen0pA5G+3DbYys +5ZQpV+aE1BcQsei+I65MjFxVWLb+uXBJmLn/bf76q9n3FxLHlCvaoiMVFqh19/RUlU6meE/s1P7q +/ZKjOHNoC0HYdFDQFfmZdL7RIL+Xd9nFffbixDIX6R/BoYIza/ZuN6oorZgVmJ7w3qvFtrqQtJtI +cRT8bDU70bhC1Y5PT0jw0cWrczzjiUOCwhAFF12DWFxkpPFa+mTRg22aA1OmmglMVJfMZ3kWNkkh +xmEGw2TiaoiB/wZpjQOVn2fFMbHEPu8bO8pXpOf9QVGgpnJHKXPvsSlPW4UduZptUaGZ+rcIIlpd +EbB3/Ri9wMTTc6lno+vOltg+VmFNKXGCUB4bR1iwueRCCDI8spzcWo8sxhoNWrkePoyn2rqmf0mR +Gkj2WBeq+OzN+X/bhBnHxyXtc35Q8ZdiQYh4wBVKF89ZrW2u6Wh8sT6h4v61gRNrJhJzk0hw5fbl +3RedBKzEZt7r9/39uVZJ3fYSgVmRMdGXjuhCDtqyotu3lu/Ga2v9jvp5dSmuFXjNJhBEg3E+qER6 +UW8NTV1+vtLk8OVvnfmJp4gKjMEsCDi31znUV9salx8JH1OzxVGfdgTcHo1H/sN7GS52H+U/2F1N +DHx/cUV+kWXYz6zfgXj7amTHFLS37aw1iC9s+5KpezjtXb+AQAyIzBAVVpD87QZ9gZ6cYVoVXfcr +7+STJxrXtaQEFnUaohl4hj+N9tX/vGNCs75MTpPdwP6nM44SDGFReThNXEtOx5Xhs5RuGiXlhJ2r +id3g9oAxewKhxF8MLNHFk1Vf92VFNcnUaqObReT9iT/Oz+mm/mXEczdixGxee8bQQLf1jltbz/Nx +L477Sx0XCmGDNRFqjT6J9VadP08eWLJj8qdB1pmJv+Xi+TxmOemXFwfpOFBLru1PNZz1XLFLnzBB +TPDBv3BFALsyV5iXnxUUeUCb4W+cO5qK57BSU/BCvZqmlxh9rTxtQbuj/K0GJULgoispxOSwYbLo +/sFlgCmk7kbqif41l97WrIWEjxuv56q7E1sM47P8OUzMXNR1QPFO63Sfb+diJg9GO3IiLVfpWc5Q +/4vhoTh45OL7XHOhzeBKp+f8dgOvk5YWDerEg0WvlUu75eR0x5fz9jLr/pauXRGHfMPWj6biiVe4 +bk3+FKkelKY69dG1bPjenDdyhRKBQyhArF59XsU0i3g+h95Udf7pp+zSBYFESpE0BZkHr2SLfBec +IndNsE9UY7IW58hoEwIOxclUhEYDE6g/jqZu2Z9+affLa8du9E+uVStRIwxDVD6oI8fgPg1yPute +GJGTeXPYr9wuRUkBJb53cBRiY5LiolcfBRkekp0xNvv2Ov9A5UMpS7ekSBHCAsei7swx+9S4N8dH +Zm1YX1zFnfhN0iOOYxTOyAeR6OBy2CDO26I5WePb0OdMTpLvNERfyclZTzIOD2UCp6UgIW+v+wen +uO9B6SV3h1Tk+xyJNAQD5S6aGcZVywGkTjZI2COfsKSc+yuV7O3Mz+NrFKZ2IJcUDbGnHW5+U8oW +SkQwxAyE+aBjb3d1qEbscdfFvFC/nLW2CpX1GRIQMtJPRj5f5r3c52Lpp3zcZ9LK5w1krvG970RH +CmEgoo70Ma8m/euN9/ptbcWdMnc3/wgdl+5BvGkIwqZyQjAziMs1Q9g0jjlKAasvFnqfG7aKa3/r +ldRuury3cqzbLmI4iRbPuxD91nW4ck58d0G5mvns7waLtSuIb6sQvvgC/r2h9dJ5+pkxJwrzXG4a +1SnsBNJWy4dQFMTalcTLaB/5r557bFgv4v2B/HsBbEm8TXRBAnVaAfPUdSwdKx3ytp1RS1PwuBtx +8VcsnsHnscpjmxDDh5cjeq5qms7OuE2NJj6HtmE4FYzxPHWPlyk0guqFZ74NU+/tsDp39n8sT4bD +4QKMqE94nAEhAN7/zg7ODrCaARR/NPVYLIi2ZZiqW9GWqiGk8CHR5LOuAaAFCJsQJ+ECjJcyeJxb +Ir1EesM+LpFzi6eelq0JEJK+oxP1g9t0r0Sys9HmS1yXmADuRQ2c6gOgDnicAToAxf+vEq8SsFwD +FLOdTbLeyIhJmR3POooEUsNMbkXos3ADFQUUIt2MughgJm4qRRzipSy0dzVPr2yTmQiW0ugYHG2S +/Ap4nLvzgen6O6YJBptNGdW3AwAxzgYd4AKdTXice6LyRGUBr8jkY8s7inateJGXJ3modpKDuXev +9fnNIrwBrAADeQ5e4QKMqj94nAEhAN7/zg7ODrCaARTf/pppf4WEuA0KI4qrflrp6dxm2bOuAaAF +ExIQc+8BgHB4nFsivUR6goiIuOFW7kP6FxgiOJ9cejarNv9yvLHLRo0aXgC/cgyO5gKMlkZ4nAEm +ANn/uPMI/PEIsMdbs/dbogqTx2YskyJnLJNPaAWSaAaDiGe3iGcBMNJ/SRHK6gOiMXicAToAxf+v +Eq8SsFwDFBQcDvESTo0AXnbBqTeWWbgFmwrKs3ADFQUU+PsxN8KElmsWNbiAm7iHj/RQs3OTmQiW +i6EYaG2S/i14nLvzgenbW6YJBpunMR7bBgA1vAc64AKfcHice6LyRGUBr0j6nmXd1voupiI500xX +uW/e/Gvv/mubRXgDWAHodg4g4AKBI3icO8d3jm+DBLtIYxS7f/mxJ5qp3+f2dHtnLRWw3hY6WYdd +CQDW8wy/4QKKp194nAEhAN7/oQ+hD7BgAhSjPfX0jBht9IiRyrUZ9vOvJkzKs7N0Ai0FDQMP6OkF +pB94nAFZAKb/rxKvErBcAxTghOgjR8cseh9VcQsV8+gj2lvRarNwAxUFM4UvRKl8m2uX6cMn3Lin +VDlOdX3JNDAwMDAgdGVzdAANx1eDe5GbLmTX+jPzOGIxC5XhRJO4CHef7CYZbZOAOnicu/OB6c4b +pglGm42YtLYBADH2BiLrA6F9eJwBOwDE/+Qk5CSwUwgUfIwS7g9rMXQkLYcNGmstWY1/YpizZwiZ +BBSN9L78OwuiOS4ZhaN0xhERD/s1frMUDVAFqVAWLeECjvA/eJwBIQDe/6crpyuw1A0UT62BD7ej +fjLqpEdIlpNSa5QrXfGz6A2/B//gD17gBo7ODnice7Fe8s56yYYWxhamFuYWlhbWLWx+ASwKmWkK +03UD2RQ4uBQgYHpVAJs2O5hXzTVdL5tFlTstMyc1viCxJEOTa/rGy0yi01fPZeSa7t/HwjGdO5CN +c7tEINsFNgBQtRuV6wOCQnicATsAxP/ODs4OsJoBFEYGklY31PB0FxMPRyZayycegBBqs64BJwQU +TW+DPlPUsSzZyA/0VR1xzqqzRb6z6QVlAZf+F6PpA4ZueJwBOQDG/6QbpBuQFBQju4JmFQzVTZ74 +1OvtfmjI5llQpLEomQsUSG4lJk4spWIvZNLZ1lnQMwSvQuCz1QvPAedeGh7iAYUaeJz785HjwkeO +DemZzZMzt0/OZMw8DwBjWwmq+wFhle0gxi/pUhkJR/wPEAy56HUx/3ic+874nXHCY5E7/PknmxTE +3Gw2Hp1/pUVYwW3bdyMAsyEMmvwB25xw4YFgWnnznyz88KnD2KzkDgd4nLvDdIdpgwejSHDpRPm+ +7JncZgoOtzSv2G96JJQeBwCaIAr2boyDGnice9vG/KaNeYOU72Zp36AyADFhBebvA4vONHicAT8A +wP/jFOMUsIYDFNXFCHs/XgXhZXzalX/1QJmA5gF0k80DF7OxA7ADFLd2DquP+cWQR8EN0HRBvDpI +2BOKs3UH7gKqrh0rbovJCXicm72CacIKpg1uuZsDc0+pAQAvtgZE6QOrO3icATkAxv/mDeYNkJ8U +gpbuKUlOJHr8Qgz3Ho2+L/OPr6Oxs6gCFEXxIYqFoSde+Fvr/ZbeWMZPrQT4s28DdwMslBxN4wKp +f3icASMA3P+ngASngASw2W0UqyN74LMjof2jnU9/Kw+YvxJWNlSz7W06kilhEGjqA4YIeJwBOgDF +/68SrxKwXAMUwoZrOmIIn/KbrJLxoVZ2NLBL3lizcAMVBRQS7q8vtncmrG2vSShf+aa7AbGmp5OZ +CJb1+xpqbZOHI3icu/OB6etrpgkGm6czHd0KADWkBzfhAoVpeJwBIQDe/+Qk5CSwUwgUYcmqyeia +dWGGMtOhLExT/DSSpWOzZwj9CRYPEA7qA4VPeJwBOgDF/6crpyuwmxMU4yfzZ+EOY07wUAiinrJq +HptkgySzrxO4ARTxEvB8rqwsqrwvbuvAErvSB+O9R5N7FSwZwhtE9gFNqDKZguBgp6PAQRWJIqWw +DtggOnic62lhntzCvGGPKLtGclFiSarm5j2iAWsAYGgIlm6M43B4nLvxlPXkU9YNl2Zsfjjj+00A +Q90JjOoDiDN4nAE6AMX/rxKvErBcAxRbNaYbf13GiLipAst92f1QOhA5eLNwAxUFFKQOoNNmJ8ov +EgfYgabYoTv882tXk5kIlsKkGTNsk4lOeJy784Gp5zXTBINNzDFbASmgBc7kBYgSeJwBVACr/+Qk +5CSwUwgUS6uShN92qAEnBnmosRr2TQMEhcizZwjbAxROOYhP5au2agbrlbLtPOFb/rPeCZNWDKoU +4XjpAWBMGm9yenLxkrF+Q4+T+J2zFA1QBVCfJp/hAoFceJwBIQDe/6crpyuw1A0UMSuQUyuVqWwY +xeFBK+YHlSaOoTGz6A2/B+jcDf7vAogqeJwBLwDQ/9yvGdivGYCEAYQChAOEBIQFtAatRpdAbgQH +lwkVBg6XnEYGF5c//QIMt+lGBvMQnU4QlOACjM8WeJy7x3qPdYMzk4hizanexyoZi5X8OBzqhOa8 +ebyVTXlyOFM7ANVrDNrgA4zGN3icm9Um1tQm1rCFscBp+l9rRvHpE3Yycky/n8LE2r7GiRGImYCY +GYhZtq9xYs1zAADLZhIj4QKIaXicASEA3v/ODs4OsOkEFGDEoTGv6xQflKzGNw+59YXhEO0is/0E +UQIN7Q+z6gOLfXicAToAxf+vEq8SsFwDFGLPG9MxtoEoYRp4WZsr1Asms9FDs3ADFQUU8W7+Inhv +zlNzpVSYB62e20zf2HiTmQiWuz0ZhG2TjRh4nLvzgenXS6YJRpunMJ/YAgA1zAc86gOCTHicAToA +xf/kJOQksEIMFCndU/2Y1uGThMYHKBnUfRe1g08Ok1YMqhQDlKDNfws8yYkexQ14R6qF64xnXbMU +DVAFB0kY++sGjNFaeJwBawCU/94F3gWwIAEUP8pDeJieIA9gvSqmYwbzDQxHzfaTNAFrFLihC4FX +ODaimz81X2miz4v8g2T6k7MBPRRnj57jJ+2pLZMTfzImyzwlfzE1FpMEAj8Ul34OSxmy2qAriDlL +E0QMklVFM4uTVwKHG/wpt/sBqQOQ7qeWZSf5OkLLhfMHfRNFUxV4nOvsYZ/Sw94whfEJd0FpkkZy +UWJJqqbC1ieMqkcBk0IKk+YHjMoBeJwBdgCJ/5qGFt6EFoC0AR1Cl+CvAQuXMEIBQLf9OwEUApe/ +1gEal6ARBSiX8DwBBJeQXgEGh0hFAbdIRQIj5ZcMVQQ6l8kqA7eXXCoEDpfroAMKh60rA7etKwQm +e5ehBQIdl1BGASqXieIEFZfP/wMfl+C0AS+3gKcEmtvfqyuu4QKMf3icASEA3v/ODs4OsOkEFDGh +8Mc6vtP7QP/kLlf/l37P4PILs/0EUQIzihIo4gyL/jV4nNt1UmDyCYGGFsYWpi3MGzum3+9g5p3+ +VIdRcHrCDia+6X0mjNzTK9cBWfntzOzTvTuZ30yP7WLm3d7UxbyecXr/C6BgTA+z4PYZPcybeKf3 +3GXmnx46i9l+uuVyZoHpC2Yxy02+sJVt+oanjOzTF0QyiU7338SsOP1fJJPsdL7ZzAbTi6KYJKYn +nGRmmx4ym1lw8gVzlumps5mTwAyBzUDDz81m1pp8YAPrdL0IZuHpCoJAIf45zJLTs9cxcW3Xm8Pc +0wEAJBhHZOoDkWN4nAE6AMX/rxKvErBcAxSHc1d1MBtf+vYk0Xeg99QT1vvhfbNwAxUFFPIoyQO7 +hV1D9bcED06J3X3WTO6Qk5kIlhMQG5Ntk5J+eJy784FpwQumCUab81jebQYAMfUG4eUFhGZ4nAFV +AKr/5CTkJLDGAxSb1KoBGnoobVcks6DNSMn0YVdpgbPaA3kEFJrAMScfYxsbUWzPDZzzbTwobdkY +s2cIkAgUE42CvRXfSHvQNQ0xEgPqKwdY5KuzCxFZAROGIe37AcYsyU+5CCthid9plWRdqtZ7fBUb +eJxrZGpkmvBW5MjyqOuicVcE52Wy/tnOrF32ZUPHOwCnMA0J/gEgdumUeZWT06RjNCEqexvQ0HDS +Dnicu7Kb6cpupg1Notz5BSWZ+XnF8al5ZZMviktuXiaq1wEA0Z4M4eECiSp4nAEhAN7/pyunK7AY +EBQKdXO86M3Lrt9Ypvzgb3HCTGJ6m7MsEHsFDkwP+u4IjqMLeJwBjgBx/+efAeefAbAcBhSrIfoF +AlTwffdwy1NBXnr+AGWPYLMwBgIFFFnYd5UZjPyGEoEjr18ZtuliJnxbs0YLaA4Uobut2DvSdBNX +IMgjDOWJ6KFuGmGT+Bkes+AZ8RUUjTc07l1nVtVzFUWNmq1Wl3IwjBKT5S82FBJLNVu9kz4Vgvwe +Uk4HJjc2exyUsy8wuB/kQjqd4ASOihp4nGu5LdhyW3CDPNdmR65nfJMfcQrz++WnpAYU5SenFhfr +ZShxTS6QlJu+yoxFqzlfsj1fkhGImYCYeXu+JItoCAD2uhU84QKKqXp4nAEhAN7/8gjyCLAOARSb +v6/Pr/9OkVR/kbXYLAs//2GX+rMiAVADFZUPruoDlmt4nAE6AMX/rxKvErBcAxRbw4+HC9e57/zB +5lns+vUWGpeIlrNwAxUFFFoZab1FXEa0jNfIJhr8qdM6qZuhk5kIlkMKHHRtk5gGeJy784Fpx3Om +CQabr7B0bAYAM5wG9uEChAh4nHui8kRlAw+3yKxX5/44FnhGNX8x7rFY6Xtouxpb1WYFbhd2AAjk +Djr8AbXGPddIWe8qeApLB9K2Arace9O1eJzbxbyLecMyRpHqzOZF01ffWW3FtrGiZ7u/UnTJO18A +tZUM3+ACgEx4nAEgAN//rxKvErCFCBTIHsiP0+MS7o6vGHdY8vNp/CCzrZOZCJYC2RB/4QKAGHic +ASEA3v/kJOQksMQHFBnQBnxZiOPyh2S/MpvzpGq7RZWes9gHjAoXKRCU7wGRxCJ4nJvAMoFlQpyI +kJmC5Z3tZ4pbBMU2BnDLK//5veTPxqJ5jAC3IAzwogR4nDMxAAKFzLyS1KK8xBwGpwnZKhdsrdg2 +GSjwGe3g2bBSq+mmCVhJXn5KKsOTXW7PJzzkCwvUnlq+XKv0+jH9uvkA7jwZFaAKeJwzNDAwMzFR +yCgpKdArKWY4/nz7s9i4dXFZXw993Z8pt/KPv26PiQEQgFUwiFi3F7o6uez5Ivs1+8DVy69uuqgb +GyJMMIwvTi0qSy2KT0vMyUlKTM4GGbkwZiGX5xqLBcGKm5IPsM99VuFzXgaqp6AoMze/KCUzMadY +L6uYoUhgpr7EjOtt3aH7N124URz5eVkCLwCjokIP5AGRvkV4nNv+lXHrV8YNjuKsrkVF+UWbPcTz +kwFgWwhU7wGRvGJ4nDvDdIZpwkeRyyU3v4jNUjaX/7lkE7d6neYmnu8+k1kZ3QHtBw145AKRqSt4 +nOu4INB2QaChhXELk8gGdteiovwiBdvpEw8yKbTbbmDabruB+XQ5AAUlDibgAoQ8eJwBIADf/68S +rxKwhQgUa+ustZTcsWErQF42+krXw/jE50eTmQiWA4AQnuEChAh4nAEhAN7/5CTkJLDEBxTU9frd +3NtVJqXImWFHX008o6zokbPYB4wKP68R+O8BkcgSeJybwDKBZUKcSHunvFz+naiLhwUy1JwezXk7 +N3E228aieYwAyWINXaIEeJwzMQAChcy8ktSivMQcBrGYs3t6BY7e6BLTUYnJ/3e5kz+E3wSsJC8/ +JZXhwaflH9S2qDfvUZzrIpBrUTNdw7gVACqgGTugCnicMzQwMDMxUcgoKSnQKylmeJB5p7V8Q+EO +DoVTP5Q3VFx+uEDlu4kBEIBVMIhYtxe6Orns+SL7NfvA1cuvbrqoGxsiTDCML04tKkstik9LzMlJ +SkzOBhm5MGYhl+caiwXBipuSD7DPfVbhc14GqqegKDM3vyglMzGnWC+rmKFIYKa+xIzrbd2h+zdd +uFEc+XlZAi8AVpFBkuYDgk94nAE2AMn/zALMApBBFDRuiX3V19i/BDwBaKnJILImP2MwkVVEFKts +PUKXo55HvkttxQGbL+SkTWMQka2fdxIXcOkFh3F4nAFZAKb/rxKvErBcAxT8648GeENdkfSfKFVb +EiTj6TZsFrNwAxUFMwAMNBwgdKUjelCIBNMvw3hSn1egNDAwMDAgdGVzdADro5UOKE9RvziTsHKl +zHbEN+IrAJO4CHf9HCLI7gGToRZ4nLvzgWnic6YJBpOvsITzJOalKBRkFqTmZOalbo5j/bcJANAn +DUbhAogieJwBIQDe/+Qk5CSwxAcUU4WD9jW6+Y4WldaNr6clF/gctraz2AeMCiAHEK/vBpHMLHic +AW8AkP+QBJAEkF4UvnAikrMrNgwvfcrKlwAmqZUhDBCRcsszAslJ7fXe7FjCCO9nhWXzpiczGmI0 +MDAwMCBub2RlAD6W2bIzZ1YtI4eTrVVxs27a8jXHk3ABORQhtzk+et1nkQTQbRCtzeFZMRGVnJO9 +AVMVfC8RogR4nDMxAAKFzLyS1KK8xByGgPronPmp1+sXOZlkNVmqWAaExCqYgJXk5aekMqxO+id3 +/8+pE251UX2rjvudit3wMB0AEpwa96AKeJwzNDAwMzFRyCgpKdArKWZ4Wl6aeux90t8DASf7tTau +28ZTGv3UxAAIwCoYRKzbC12dXPZ8kf2afeDq5Vc3XdSNDREmGMYXpxaVpRbFpyXm5CQlJmeDjHxs +eMfU5qKyjDnD3ov5TS8bu1q2nobqKSjKzM0vSslMzCnWyypmKBKYqS8x43pbd+j+TRduFEd+XpbA +CwCezELO/wVpjoA+vQbaRUzThRaVxMVsKpNMqXicAV8AoP/MAswCkMY/qBXCYhmS9yCnYeu5zVwB +gbfyN7MxMDA2NDQgX2h0dHBfc2VydmVyLnRzADO5OfRTyIt5niu1SoTgTp3SttMykwUBMxThGBb/ ++sb2JurzjcbC6rLQfjitBR5ALaTgApGdc3ic6+Pv498QyS6imXsvWbYy/FFDtd87kbkRtXq/bryZ +nMuuCADTUQ3W5QiQ+lZ4nAGFAHr/rhSuFJBBFLmZ0SeWkeU/j+ChDToW6tIauhWSkVVEFPVZunxC +1VN+Gh9jgjxKfkJ9NLFosa2hAhQ0zFS1ZSjCXb2Q/0RuEiO3La7mSLNiAy8CFMW8b1CZcar6YGd7 +n90is/VCVMqfs6UFUwMU3Sz7SxpkZ29TyztfaLb86zrqc4qzDAkiAcOHPD3rAY+yBXicARsA5P/J +AckBkLUUwIYHs6cjRk/oxSS631fWSo+2sMyyjA3v4QKgY3ice8b7jHfDfGaRyjNR55m+3my4oHXl +0+nytiK9Fnf/zZuZjZkBHjQP7O4BiZUueJwBHgDh/9AC0AKQlxRvxP46NCZb3Zf2DvHnBsL+chdE +BJGrpeFzDsjhAs0deJwBIQDe/50anRqwOgoURxGpunX6cuzE6Hc+Jdff3fOGN0+zTgrPAgOTD/P1 +AqAGlMU+NaObQcVE5DmDo+zReAt6eJy7yX6TfYMro4hX9ZMNu/3rVD+0PXdOaLT908JrfHDyREaJ +zYWMGUwAPhUP3OEBh+tHeJxbs5fl6zqWBbzN5iLbzUUYS7kAQtoGEu8DiAN4nAE/AMD/rxKvErCF +CDParKAOHeKxyERFfRTWmF+nUIwWsjQwMDAwIHRlc3QAkFGlrZVXb8SbpnmzBcmE1P577IqTuAh3 +c/QdQ+ECkF94nAEhAN7/5CTkJLDEBxQrvW2Dtpvwkcqw2a+3Pm4l3tdk7rPYB4wKMA8SA+cDhz14 +nAE3AMj/kASQBJBeFLvKvcgspWgIICKN/tPGsP/sIP/3kXLLFOJclWilHP/UbCOH/lFko5NVV/Ua +k1EBvxjSHJyiBHicMzEAAoXMvJLUorzEHIaA+uic+anX6xc5mWQ1WapYBoTEKpiAleTlp6Qy9Dya +tyrVsIyVXT6K5WnJo89H/p2bAQD0rxl47wGFaXicAR8A4P/MAswCkPEUcX7RZ6FaXOe0pqiRBOFQ +9dt2vs6TBQFHA8MQEekEkcN7eJybekHgyXmBhi2MLCnTeVMY1afLFzGqTPcvYpSefjOZUWX79hTG +HG4BhezMvBQFW1tbBaWixHIlrumWBYxp7QsLGIGYafvCAuaS7QCmaBk+4QKFbXic6+Pv49/QyCqS +JXLaMfsc6+Gi7fMqNK5dsWB8kPJw81TWn4wA5+8OxugDkZYjeJwBOADH/8UGxQaQtBQUEbJt5aFJ +MFQ83cvgeupnRPtzg7HIqwEUjiwkzedmdo3z4FHsIhRZgL/txiaThwK+B0ccD2yRj3h4nLvhcc1j +w0yWzbNZ9soDACl/BbpskY0meJxbXLSwaMMa1s3rWEuNASiXBZjhAqcJeJx7xvuMd8N8ZpEvykle +JZEqcduTkxSsvQ8Vm8hFbty8mdmYGQDlvAyx7gGJm1R4nAEeAOH/0ALQApCXFAPtMx2Poznuk2E6 +GL8M/xY9fertkaulx50OEeEC00N4nAEhAN7/nRqdGrA6ChRYUCjtB53CIf9tAumSoRUT2dUAprNO +Cs8C3oANnfUCoAaUxT41o5tBxUTkOYOj7NF4C3p4nLvJfpN9gyujiHPbiTtt3gK90fIXOV/NX8RY +uSbu3uSJjBKbCxkzmAAsow9T7QSH8W14nFuzl+XUOpYNdVymCiX5wSVFmXnpGpoK1QpFqYkpxXoF +pcUZGkrJ+alFyalKmtZA0ZLSojwFpfzSktQiJWuF2s33uJSYms1FtpuLMJZyAQBHfxpV6QWOZXic +AVkApv+vEq8SsFwDFJzNrMgisnYHeh9erSUH/FTRNKcos3ADFQUztmhpr+faFjl2mE3QaR89CsqN +4Ns0MDAwMCB0ZXN0AD5aoUXvK3CTeyiQ1IAF4QzDNBlGk7gId3vvJJVtk7B7eJy784Fp5VOmCUab +n7KWbwIAMyQG5+ECl3V4nHui8kRlwxF2EaXtJ+KE1Ez71ByVHbrc7/nMtD+tuPkGew8XAOeeDUvv +Bo5ReJwBbwCQ/5AEkASQXhQYkLZqcc/JWaW9zOUg5sBQGMX9UZFyyzP2rlK50i/GvADmOfOfoLr4 +WXi3vzQwMDAwIG5vZGUAVrrywTqVl+iTOJ3Tv0E+tIBbjGOTcAEUFBkJY/vVdRJJcASO4Gg2YqAK +h7wLk5gBeCQUNLeiBHicMzEAAoXMvJLUorzEHAb9TXkvlwlEpySts1RVWljE2yArF2UCVpKXn5LK +YLhY8rBO7K4TIp8eLb/i4vvxa7OpEgDyKhkN7gGOUHicW8C4gHFCkoiMm/XbpMffP+dcWCvBW77y +GfNUt+6JZVoAzTcNsO8BjWB4nAEfAOD/zALMApDxFCm3yGe12SLVQgToaL+5FLoI4xn3kwUBR/PE +Dn3pHpHLcnicm3pBYN4JgQmLHFKNLJKSE9NMjAwSTS0MDI1TzBMNLE3MDM2TzVMtks0NjQ0sDFOM +Ei3TUo1TTI2NE1MSzZJMkwwNjC0NDZMtDBI3PgovE/fMS87PzcxL900tLk5MT1Wo5lIAgekfGpmk +mO2tFKZ/ZGYRnvynXHX6fQsmjs3+5e+qpnvYMvJMrv4vPtnuhz2Es+uj+OaJn9aybq7/oZTCpFA9 +3VCFSZHJmmsye5T8dJkURnFG6+n7bjDpAKn1C5nVpn+KYUzdbhDH6MrKkp2ZlzJdsJNZkiNaCcRW +ip3euJA5YnpuESPH9N0dzMrTOY4w80xnFWUR3P4uhdGUux7qxqLU4oL8vOJUHTAPpBXCSs4ozcuG +MFOBnksBeg7Cy0nNSy/JgLCT8lMqfZD4xSVFmcklOigGO+cXZaeCDa21BhLJQLESoOT2fwWMPSum +O4kxiUwTZeLavlaSqUB2eoEFk910HQdmye0HLZhCRcFMtvyCksz8vOmFeUzioODj2h7gx8RlPD25 +iSlr+gdLZpbpH5qYNKfrNDFpT29qZnIEsZTb3zUzbX/XzKy+BADa8Z4i5AWQRXicAVQAq/+OD44P +sHoBFFQz2esT3MNa6AWWZeZQ/SmmGB2Sk44BfRT+vorfxa3phTSzIAdT4++EqkQrBrMfAmIDFCro +lh3bQbhYeTxEOvc3RJM2SRr4s5UF+QFUnSVe5wORqWV4nAE3AMj/1gLWApCnFNNwIQUL/pyjzMEf +kNAIkbzOxt0Mkbs7FGrwkGM7YCtZukn8yeFukAUOtn2DkwoBTOwNGezlApGpMHice/2D7dIPtg0m +3UI6CgWJJSWpRXk6CuWZeSn55cXN8d3b47sZeQwBOfYPKPwBcd9a+AIu7j4RaT+iEDgURtQjlph4 +nDvKdpRtgyGzSGlK0V/j7TPuqR0V+snsGnLw0VfhRgCvCQz18wIrY8psbaFXm/X6ot7eetre85or +O3ic625kmtnItCGGn12hRiGvNCdncwz/I0E4x07RNx4A2gEMEe0Gkmh4nAFtAJL/rhSuFJDxFANT +ceEU2N2qgaKfmnfc8Xhup/SvswUB/QEU5SLx6DXB5vnw4Q5RahCQZ43c04+zFgN7AhSF8hPnT+jP +da6UO5Db/wn+tgBtubOlBSoEFEp157pRujfYosQvBXsTZot0e8Bfk+MJSzOjNw7iAY/3M3icezWH +5c4clg3X/06+9zdss/U/fQEAaP4KeukDj+oqeJwBOQDG/8u+DIK+DLBFDLN/DPxOl6kBAwyzilvt +BJPLXBCTjWD3k2xfEZOMXhCT3Vsdg8hhh8hhAbfIYQKDveX9GejsBY/MPXicaz/E3H2QecMPps0y +zDyXJr+9ysOkYDv5o5qIbV5quU9mcUlqXmqRlUJJRmaxnnJRappHfn62jkJRam5+WSq6dGkeVIFC +7eb7VzW4AZirI93lAY/KAXice7Oa/ekq9glPJz+6LNncyri9lZEx/QoAf4wKjeECtWp4nHvG+4x3 +w3xmkVOxx2OsJsgutGyObPm1Vvxx1uqQzs2bmY2ZAQSbDuruAYmqNXicAR4A4f/QAtACkJcUrNxn +ZbR3nr20hI7l/unsX0+9hzSRq6X+XhE/6gPiJHicAToAxf+dGp0asDoKFKAGlMU+NaObQcVE5DmD +o+zReAt6s04KnAIUI2HUaTyxDFoKWhH3h8jdLUTjX4qT/gwfyWAY0PwBP6oeQxHFzH4ocDb4TnIn +JQz9BwJ4nPvI95FvQyy7SErh4lCdkJjgn0EvgurebTS+vOSKCAC0yw1X6gONF3icAToAxf+vEq8S +sFwDFBCcZlY3/xuPs+oe42svnoiEZTCOs3ADFQUUKDXfM18q9b11/zmfrVSBOQaERGyTmQiWuNEX +/GyMeHicW/mU6ctjpgkGG58e2QgALZkHNeECpWt4nHui8kRlwxF2kYuaTn7lvvtnGXpsTUucEr+9 +tM5j1uYb7D1cAAB3DuPsCpxHeJwBrABT/5AEkASQXhRoKyHPHdCwLa2i+Vpq2Bw7aQPknpFyOBTg +mv3n8Rt4U53Y/bjIIfIoEmxt0ZG+fzO8w63+YUKozae22u7l01lmotJGvjQwMDAwIG5vZGUAJ8xe +uUG2Seg2trCcWp602twtm66TcAEUOdEJQ4Rx84E6fFszFtn7+/zqikRNNDAwMDAgdGhpcmRwYXJ0 +eQDsgoUx6L2t043apGXSJQ13UMvQnpO9AVPhvlUiogR4nDMxAAKFzLyS1KK8xBwG/U15L5cJRKck +rbNUVVpYxNsgKxdlAlaSl5+SyqDBe9JySdHm0E2KU46eUXCa/Pfw92YA5+wZGu8Bm2h4nDvDdIZp +wkcRRkmm+w0f81lr7zmIzC6rTDgS4n5jMiujOwDRjQzC6BONBnicm3dC4N4BgQ0J5pvlLR5oTU6o +YN+sl8y9YXugMGOY73T1REbHyReMuaevmcPEOX1eIuPP6boJjILT1yUxNk3/F8MoMl1AmYllukcy +4/zptlzMHNu/JTOGsfCkpCbnJBalpijYKmhPlnXU2L49gzGdbfr+fEZFFi4FBYXp54oYlRx0FHJS +89JLMnQUkvJTKn2g7OKSoszkEh2FotTigvy84lTn/KJsoEm1OiCNCsmJOTlJicnZIN70z/mMF6dn +eTNJTN/HxCw2/cEVpuLpy+Yw8W8vKWTk5ds+r54xsn37aXYmDbbtv3mZ9rAzam5/LMpkkzM9pJBR +cLt5E9MJ1ekhq5gkGHWmHzRllpZQyCx2zEvOTM0rsQI6KT8nNTFPU6GaS2H6R38mhen5+5jY2i+v +YNp+eQWzdzUA6J5tEuACkc0CeJwBIADf/+wG7AawjgIUlvz4uQ4Q3H13nZGpnI4Y6ceDHW2TogLK +C6wQQecEkchleJxbtJXp0CamDa3sm2dyZDAzFk9W4FESUkgsLcl3zskvTrVSSEvMKU7VmZzAI8+s +UKu5eR5PFEjVb35VIKksACQ3ewuEdwEAbPEXK+sDjRJ4nAE7AMT/jg+OD7ALAhSbGJ6bGbpH6l/r +Sg0FJbCUnMLt07MfAmIDFHHfWvgCLu4+EWk/ohA4FEbUI5aYs5UF+QG/hRfd5wORt154nAE3AMj/ +1gLWApCnFDzO8zVbXihEEjfC3525hMVY0YjYkbs7FMckSwQo3lA1AaqOeDBi4rXO9GrOkwoBTMuM +GYPnAYx5eJy79IOt/wfbhtNdm393qXI0G0/ebjyZUV4TAJhYCtfjBYt2eJwBUwCs/64UrhSwAgMU +pxfSZVQPLK6UBOmtSeBKGX+goCmjFgMBFCwTbtISiwp3sN9m4Yd0sE3IsPxUsyoEpQUUm26njZJA +TYmeaz/mYXPTTp25Y+mT4wlLf9YkOfIJWqxohjMSH4zpKyL5Mwwuvk9X2gJ4nPu7n3nvAeYNymyT +r7TJTuZjZ1dIzs8rLlGoVsgsDg3y0VEoyQ9ILMnwTHPLzEkFCijUTp7IJKpSWpSjpGnNpQAEmWkK +GmC1GmlAJXmJuamamgrVQKnJdmyOk2vZ3DQVFIpSS0qL8tDNQmiAmFS7WYD97Q0ADnkv+OoCj9Yt +eJwBKgDV/+yrB8GpB5Dlk+LTGbPKAeWqs8+s1HaT2z0Mt8IjAe+bk464Irf/vwHtFQ1LF7zuAaB1 +eJw7yXiScUKmSOBik8nHEspvMFzjKspv1zuhctzdeWKtDwDHCAzf5QKP01F4nDtfOqd0g4Qis45C +/mRjxd+To5U1JycofdocrazECOJsXq+iIAYAEJUNauACij94nAEgAN//rxKvErCkCBSzpgr9cwg0 +bClzzczp3RzCK19EqpO4CHfoyw6J6QOMTnicATkAxv/mDeYNkJ8UWL3djtsNS9CCy+b9e43dDNnZ +QHixs6gCFPWQmt+N9I/f2YefGFrQHeG0K3Wrs28DdwOh8R8k4wLDOHicASMA3P+ngASngASwl/IU +fMfP7NVxBdOeIrDiJmmCcb23mTmzq/J8DUyYErPmAYrWS3icu6ixX2PDF+7NXDxRzCw6XAoKm1P4 +37IAAF84B0frA4n2ZHicATsAxP+kF6QXsJYBFMFukvVY7CEoTRpAvyYK601UY7hSs6oBhAQUwk4V +wGcOa+2mE/xRLpbrCmuG2nmzQgZiBeZtGLX/AfvMl235TA8PorWl98DifVYEfExCeJx7wP2Ae4KZ +SHS5Q3+B/6Nfe6KO8/6qv79p0e7S4I1e01gB8V8PnOYFic8deJz7oPZcbYMMo6dCQFF+Uk5qbrGO +QkllQaqCT2paiX9piUtqck5iUWJJZn4eVCI4v7QoORWFk4KkSmFzHiOTEABzFx9T6gOCIHicAToA +xf+vEq8SsFwDFGgQr7xDEcUPyxA2d+A67WdkDECKs3ADFQUUsK8oMI+62ZLljRN5LHL44VEX5VWT +mQiWpXoYgW2bV3icW/mU6e8jpgkGm2MYfTcCADClBkDhArRLeJwBIQDe/+Qk5CSwxAcUMaFccI4U +Ge5oqkhA66A5yK3FcLez2AeMCgY+D87vAY1ieJwBHwDg/5AEkASQqhQo47FXvDTzjARqD8nLAS7Q +VOesprG+UgHanQ5Y4AKR1yB4nHvD9oZtQx+TyIkm11OctpfVxbdPvyEiZp45nSE2fPIiplMA310N +JeYBiRx4nDu0iWnBJqYNPb6TD/k+nrzAV2HzRr+JXgCBzwsG6gOEMXicAToAxf+vEq8SsFwDFFd5 +fthMUCo9QipA/mY322x9OgBJs3ADFQUUM+7Lc3y8kX3y0EpI4SUF5DlKR9STmQiWmukYAW2daHic +W/mU6f5DpgkGm38xrt8AADKrByDhAoEReJx7ovJEZYMui4jvv4JupabgFfu2Ltzd4/vx4tutyZ2b +HVmU+QATGRAM8QJttQ13sT09OqboAZTePi0hH0D4THicu8N3h2+DOZPIvMLgV5cYun4J7q1oKgw9 +r/Q5PUhqszeTICsA+9YNz/ECwbL/9szKL/yuhfXyM/XEH4zdiDR4nHvL95ZvgwibyGTlPexGPPdF +9sZsFF5RXlviLurQuFmDzZURANQRC7DhApLQQ3icm8c3j2/DSWYRvldnjxm2V7xgD7+0/8fSsAhZ +xQb5zXeZHZkB/7UOemySwkN4nPsV+ztqQ4/KZm619xwALOoF6OkFhwh4nAFZAKb/rxKvErBcAxRo +nSD1z/SjPBY10G8/IoWFcuA2RLNwAxUFMy/Y6/wXZIkD7Liw7RaUMC+OqTpNNDAwMDAgdGVzdAC6 +AxXAI7kn4LI2YRfKtnb6b3SMuJO4CHeXNiYdbaBeeJxb+ZRp6wOmCQablzCxbgAALlUF9uEChAd4 +nHui8kRlgy6LCNPcd8yGS2WU4iZmfKuO6rw0QcCoYLMjizIfAODxDJLxAm21DXexPT06pugBlN4+ +LSEfQPhMeJy7w3eHb4M5k0j6PfanVkFR08Jn30lqf2X7WXzp87WbvZkEWQH7Hg628QLBsv/2zMov +/K6F9fIz9cQfjN2INHice8v3lm+DCJuIqfX9HB/NBOnUzY4HM6RNHy/Zmte7WYPNlREA2nYMsOwG +ktM5eJwBbACT/54Ong6wyQMUQ4DnHid7h6U10D5PMdVoXa4tPfWT3QPaFE7HGwWLqkY4VM1xCud2 +d6IqTSwvk8sExRQdgxSDR2WWtZmBj/ZEXgd0DesKWJOkBSgUCXIepmrchMy+iYWIdOd4DrGRoPSz +4AU+AbAILsTuCZLGBnic+xV7IGpDsLRDkl5yTmJxsYZSXn5KqlVufkppTqqSjkI1lwIQZCQWBxTl +l+SXVBakWimkJeYUp+qAJZITc3KswIom35TWmNyhxzuZR4Z/8nI1/snrgGxjGdXJi9Q1+JPz84pL +ikqTS6BqZ8vYTb4uIwtWp6nJPTlCQWxyvwLHZDVZXaB6tc0FsjLsm7nV3nMAAHloM5HgAZKrDXic +W1G2omzDIT3mTGOjzUf1knkAQO0Gw+MBkqFseJz7e4pp4jGmDWc1N/Np9/NuPmG5NRsAYG8JJekD +mSx4nAE5AMb/5g3mDZCfFJd0CUJTWn86YrfGWrX6+BaOjwZbsbOoAhT1kJrfjfSP39mHnxha0B3h +tCt1q7NvA3cDKGQcRuoDhE14nAE6AMX/rxKvErBcAxTR0KgcEEbVbmkl/mz0ct8wmaris7NwAxUF +FOtfSHGf4cZTUJcjQb9JpgoPoT1Mk5kIlgxXGd9tpgx4nFv5lOnFPaYJBpsLmS3WAwAv3QYn4QKJ +NXice6LyRGWDLovIDbOGR/mH989duKVZgEN2Ye4nU7HWzY4synwABg4OCvECbbUNd7E9PTqm6AGU +3j4tIR9A+Ex4nLvDd4dvgzmTiMDFU7tfcyoZbOoweVJgE8Q68fhqpc3eTIKsAO2oDQ7xAsGy//bM +yi/8roX18jP1xB+M3Yg0eJx7y/eWb4MIm0hE336jqtgtSqc+FR+8x7G2Sf/TupjNGmyujAD+zQ6w ++wM7SYZrIvEldyRuRxlD87LJtDWUZXicATsAxP+eDp4OsLcEFJaBYeBQ6YaB+1n4Po9pCNhD+EBB +s8sEAQEUr2dBEmT5ZJXQ5nIaVQ4iZnzwEKqz4AU+ASlkGg/kAZKuf3icW1F2IXnC881SjOm6k99Z +8G/eal7MDABpZwkI4QGCd3icm3iMqfMY04ZliyZPXSQ4ef+iIABOfQjE6QWHeXicAVkApv+vEq8S +sFwDFAQE2F9hKg/HsnSLMjbLIHbqQ1Rgs3ADFQUzznrrvT6IOUV5UX6/3yendtUvf+Q0MDAwMCB0 +ZXN0AIfSy+ez5/ED5RAh4aTNMVp3TH9ik7gId2QwJqdtqVd4nFv5lGnXXaYJBpvlWbrWAQAtZgX4 +6wONAHicATsAxP/kJOQksC0EFLlB6eDbLVIv5cYwLMAOycHm3yiJs0EEEgQUOO07KJMFLGMbwVIV +/FD/7UqZsHCzZwj9CScgGp7xAm21DXexPT06pugBlN4+LSEfQPhMeJy7w3eHb4M5k4hxZ8zuqBRh ++3Apr4WvnK6nf71+c+dmbyZBVgDlIw3v8QLBsv/2zMov/K6F9fIz9cQfjN2INHice8v3lm+DCJvI +JZeErTHOsef3HbVs4dvd0XTodvDbzRpsrowA/vgO4vECO0mGayLxJXckbkcZQ/OyybQ1lGV4nJvH +N49vw3YWkWmNiQ8CXrY1/o78YdefyXHD+YeD4+bTLMFMAAnXD2XrA9IseJwBOwDE/6crpyuwGBAU +CnVzvOjNy67fWKb84G9xwkxiepuzLBDyAhTve9iBNkzZpzk29WltOh/Pqx8vdbMyE3UCYXkbhuEC +jb1EeJxr42jj2HCUUeTC5289v+09z6VUX/1bH+f6pvyJ1sXNNxl1mQAiLxEO6geNvFV4nDvcy3K1 +h2VD8JLk9Jz8pMQc/6Ss1OQSXbvMvJLUorzEHN/8lNKc1KDU9MzikqJKDU1du6LUwtLMolTPFA1k +HToKZbk6Cp5YdVlZuWWm5qRYWU2uXaI4eWOo9uaCpcGJAIxTL8HhAodjeJx7xvuMd0M0s4hP6dtz +E8TOVUdH37uslOTz4o/23sOb85nLmQENAQ/Z6wOKizV4nAE7AMT/pBekF7CWARTBbpL1WOwhKE0a +QL8mCutNVGO4UrOqAYQEFPvMl235TA8PorWl98DifVYEfExCs0IGYgUEvxmk4AKEaHicASAA3/+v +Eq8SsKQIFIqCVe2bA3td5VagZjs44OU3++DNk7gId/KhD9nhAokLeJwBIQDe/+YN5g2wWwMUHsuu +YR2T+G/W+D4ceZq5yKI+qCSzbwN3AwZbDx/gAoAqeJxbIr5EfEMht4hqLVdTwbFrN25J3fvy1eND +xMY3liGTW7nlAfRID4DgAondPnicuyh8UXiDFKfIrEfC1x04muTP97X+ZGXLVe8sdlg+WY9zMQDV +4wzJ4AaJ1RR4nFvivNNhw13GyT85uTf/ZqzmnawuoDi5WVR0cryA72QDMcnJxwVkJh8Vmze5U9B4 +8mFxd67c1OLixPRUTWuuyYJCypPNhAQmewgVTN4lpM4MEnshVDU5RVhpcoew0WZnkUReAKh2INjq +GsFMeJwBqgFV/q8SrxKQWBTy+ub6TX3qWRKAdqL+U89+C8x06LFswAEUrf6L2U7eJ7YLQ1Pq/hZb +eHyLPNOTQAKGFF2mF/NuU+Cdkae7N3b2wtlSd8dbk9oCghQEBNhfYSoPx7J0izI2yyB26kNUYJNw +A2s6au2nXQumHfgDghud7RF1wmv3fV4xMDA2NDQgQ2FyZ28udG9tbACGXtNtYeCMKUWuWSK2SUGE +DkkojZMVBDQUfC73kPH4N+bleoCuJAoqNDZuqoWTXQR9FG5KgZQnzjlfVEC46bt4oTlokiIvk+4E +tRTVl2JOVjdNxQzB6F/zfb8mswOeq5O3BS8UMeXrjrq/IFpTSb10c/m9VvyAlN+z+gUTARSAxyYZ +CihFyNIey/w64YPg8A6QNJMhBzsU64A3qzaANTHKZdOMXdghCoHgoiyTcAc3FOyaF7BrqfzHFENb +6g69s7yshfKdk7sHhxT9nnefJrTk5jBFNAjFeTFjMuz2IJNWCC8zyiCbn9/mq+Gj9+BSdlu+s/qS +qz80MDAwMCB0ZXN0AEfKxXgLphib9JYjANz7xuYnuBpWk7gId/CHxsLsAZPycnicO858nHnDZkYR +9gOzPF9xBjK3/2gJevtA48X/szeKAbPCDkf6A9a9QN9SmRFX22ytmQey0osB/amqeJwBOgDF/+kL +6QuwPwMUjRwASEXU1cFRi4G/vNE4HnEqV9qTUwNoFC+VEh+hewqHMkjQ2GaeqnqrHeFAs88DGgLK +8hg18AIYq5wWOuxO3u64VmNCc7QKOm4PpnicASAA3//IBsgGsHcCFApcXbW/gX7mImf3aZNdlOnO +Z9X8k4sCvfBOEC/xAlkxoaoRqlw3oGXubmo6Z75in68seJwBIQDe/9MR0xGwogUUgKwigKv7yA7m +20I+984h+AVpV/WztgUdAxUnD+X3BPOpTCi0mzO235vg3ueMmFba+kBLeJxbxLqIdcM/RusJkXE8 +l+9uKl2WdkzB9G8oS65k3UsTAyBQSCrN0y0tzk/OTi0pZqhU82GI/5HrY9gg8FOt5vSXNe1OUpMt +mTIBG/UcoPECEHQFCjPuUg43Xrj+YbWq5ZBOEoh4nDvHdY5rAxuzSEVxkFplvpHuR+n7k8/fY9Xi +qNr0ZbMUswkTANgzDLD8Adx3qSX/BAXnqtgkuzk3d/fY0UqOeJz7wPSBaUMMowjP4lflmlzTV6gv +Kp65zmKizqTQg7UAqh8MJf8BBuNrvwdTnvOHWtV4sJxagCb3QL94nAEfAOD/1wPXA5BTFOmNyYKW +r7PyAGgl9jWhbJfmFomZsWdwAfr0D1r/AXkREyLfsc1netZ4QdpFjjPciiHdeJwBHwDg/5QDlAOQ +axToJHBygbz5oaAn3cSU7vXHGE68mbF/FQHycQ+q4AaTyF14nJvbyjXtIecGrv2MjpMXXtBQzixW +KEotyC8qSU1RKMlIVShPrFSIMDWwjC9LLcpMq4xPTi2azHVRTYRLQUsBIqSQnJiTk5SYnK2z2eUi +P2Pz0kvbl15iPL5oe24pkwEvAO57JPn5BRch4eGxADGOAerZej8olArIdctFeJwBWQCm/5cRlxGQ +wDSHQqXnsYrh4y/wn+I13fqnRegnKDQwMDAwIGJ1aWxkAPTKPCx5rPNk1ERlQC4oCRtM+jqssfRY +AxRgx/+d4SNmbOloNHv0VY0b89hFo7NgBDcEg1opxO4Ck7JpeJwBLgDR/+z1AYr1AbCLHJOZHHST +azkZBT09PSAwk0Qd2rMqHts1syNUQRyT0nMjs5hwVArCWBJG8gbkjdpy9YLllX7WWnQqr0MPuyL5 +MHicAWIAnf+6ELoQsIsCPL44M5xRVL7DJXZwn6sAYlRaQyhtMTAwNjQ0IGNvbmZpZ3VyZS50cwAF +E30znel48Xj883pYMEB5CP326ZPHAjsU1AYJMmXaYlmtRr+vlJCFssbptoezFgMkBZqZKXDjB5Or +c3ic+7mA9ek01g2Z6pPzpTk2b9G8zMZtpZCSk1+QmqehqTN5jYGMEJeCgoKWglewc2JOTlJicraG +5uQ3BoaTW/TlJjsYCrCCpScHGDpPfqMvvXmzoZLa5k/h7qWbS89KsG1uvMpuOvlTuMj2jVyMVXbb +Mz0ZBdgBG6koOfAC43Pk7OyYwyMlKpKmRiGxIqE72MN4nDvLfpZ9QzGzyMnXrkWSpjaKPTv2eqnd +UfZYZHrNaHI7sxsA2gYM8/sWuIJDQ7P4T1mjYwNiXDGkaPENBat4nGtbw3p4HeuGNaKTN4ixOCan +peuVpyZlZ5a4p+alFiWW5BcV++flVGoqFKWWlBblKSgllebpQlToJuaX6BbnlxYlpxbrlSQW6aVX +KVk3rxTdvlKU8ayZDi6jFOwVlJC1KilYKUwv82GcKaugpqagiEvbdn5fxvuM0+8EMu6t19dXCAZr +1s0HGZiVn1SskJdallqkkJlXXJCaXKKQl1iSWZaqkJ+UBeQVK+QXKeQmZqcqlGSkKiQWJWeA5BIV +kvPz0jLTS4tSgdoKSkv0uBTAIDNNQQNvOKiBAqJaISczqdhKITpWB6g9Oac0JRXKS8vMSS1WqLXe +/tyP8SvTdCkrRpXte4MYPZkB0fyCaudR2QN4nF2QfzzTeRzHv37E2ORHH7RKhFoY2625tWpkVMwV +i0ldGmP1GDbaJuZ3x2KpqI/SVaKr0SHpwo0iukvKin6u5leKkvXLJXo45nqc6/G4u/e/r+fj9Xi+ +3oOObY4F4YCsnmmvV7Svlp6LYOdZuFQP7u/cfFjsBnqnPFjD2U17dwq3Zajfv8yscOCYHa7HAy/+ +fcpH5w1vLVlNxTY7rBLZdtcLLo1b6oBW+gl3Xf5JD3H6YqxiaGmxnxCegba62ZQOr4S0mj81AcHb +20O6TX8sLFGpmGTil7PjJAjYkXFCLvKAvjlGfJriGYQoVh4hfucUkFLaCtW6HJCDQ7V2+91dnqDI +F0/RYjMdaiUvYKDeCuD7xGLgdRTwdr2SHT+V0eM8/FTyCRbpEUAb/lZAA8olQtbPOxoVVvE4JdVy +IVTrBQG6fCLTa/c3Q1N3j9OtSkbkz2UfCqCX/iqAGefwlkOGXGz6yLvtUkuDbxtTBfP1nYDG+DM/ +RkQj/Swwt9Q45+ZLglQ1UKmvpjJOyTDNFxrdp18FU83DRUtDy4jps4u4SVz2zjghP0KMrMgj10wG +HpnvUTvdQ5/mk3tqBWGwfw4T9K7NwneS1WWSb9/5z/ObMYE9ZTugj4Er6D7tDyauignHisZKhJy6 +0BZvPgtKDRLBCLGL/fqCiYPMk3HgxZsGuePZ62ehmSEeBFWe5N6vfjOyfcPDpR8XFPbF4AjbYaDh +lgz0YprkEe7pKfSp9S5sDJqFCrIKnzWMFiGL2Io7RewD0njqofZrEoLpD7+Mjn0N2fERQhFXiBgN +HI+vw7RpBoNwcQYxKvJGNcrzfww7WhSJZE2ve2IRvfZqSPPtzuDm3I8dykXZZKLXV1DIE4i/tF2c +scaUr+MOccsG+i1vW4WOx2YVfW2LRByfeuXOdSvRURL2MspvjNHPaWID4S6UJ+hTek1SQjqqqg4F +ZxYcvIA+Xr2tCzaiqCDt1liDYJPDvbQsK7RMM6B4iGeOQkMjNrAN8PVDQvq2ZHCUvYyXv8axrlrb +wGQj1rxVmiZaaGbLZAZhy2+FSRtTW0sfwOdGWWDC3NLwTamWO1rEBap9qQFn+KpHUGIMwT2frdYS +SvKEPdZMdkK+xvxDcYUutEPHwgo0g1NCccMd8R+vCbORsvanDxw4WiNOnt0j5IriYvdw2ZwEXqyY +JxAhc0jTxxhbK2eqXrnrOBoqiwXO2Bv/QYWI08q6qsSo5yuX0fG7pAUoUv61NUIYggkDMOb895+R +Z7nafVKbLsRVFjUmIcKbGCrwmSx1OMEc0T+fc6fN7MMd/fXHUlMgMGECZb5Se3DE2G6Zs5G/T6Wo +fKRLK4cSk3ehTtaNuCsWrW97iAacoTSSnofxue5ZDVF8RKIAqd2dFB23ifqTErvZNkYxyng8vrD6 +XzlbJBEheUv6VUm81a/Ukfk8e9kUtmtwNR5em4sHnePebN/5zakcv4H6cqf5Ka9tx/+EM3OtQWo7 +lRLh2zeToe2x+X3eqAU1kvQCOpsmg/uFTouEpJ6cTB/VGlqxnQsPHTwKFaYKEFiSsxhTyWxzq2At +aHpAG+wdutgHs82Y7qta0N17tCgruT0OezM83TUv/co/f0xIFP2tF5MzTR5G/rhMm/y0g0h6trPx +PXLZ2FxfB4Q/UwZilzvErxu79eRhPVIxXKvdBe0t3MDdyrphN3yH942c0JSFhCVS0lqPqb8AdutD +/PECHsHWBrJX6dPoBo3eViGF2qP9nEF4nAEhAN7/3A7cDrA3AhS3hpHkiW6B2qsi/aGcNNYW1e8A +kbNLAhEFE0kPaPECXkXr6IkZqUx497gLbaMh4j3zhh54nHvL95ZvgwibiIRlrHrRoWn+0+Y28C10 +Lax7tnbusc0abK6MAOCJDXbxAuxyr2IOclsudr44Ms87aSvq8/dzeJx7zvucd0MDiwiDpEHuou7f +EaaeChfcLt06pyCf3LF5CkswEwDlDQ1f5wWiRXicu5D8IGHDJVbBtNSS5Ay9gqLU5Py8vNTkEp3J +F1l/Tv7AJssKlpnMzG4EZemzl2w+zp6nOFlWq37yAy2FzWzac5nY8pOygLomx0qbbv6ne4kZAAxG +Iez5A8FnxuHgQtc5awa9YqixEY9GKoxXeJwBOQDG/5AEkASwXAEUa33prPVX2MGx7pJmuGItdMvP +r7STcAEUFDYSQt61bi3XAAcBO9mimQsFcSwWk5gBeP6OGHT7A8O7pxE4KFbUzTRXTXNaASPLPC+s +eJwBOwDE/64UrhSwyQMU8AvPl5U8wSOF1Jaxg5G9T1CttdWz3QO0ARSF8hPnT+jPda6UO5Db/wn+ +tgBtubOlBYkEhzkebuEBti54nDu4kv3JCvaGLYwijNsLGRkDLgMAQmAGnPECsopPm1ZOrb0p1PAQ +QiVcW37iOVp4nFuuvVx7g4SAiF1kxHPW7/OlHhck2jjPtvYKkG5s2awjUM0KANjUDE7zAo6dwKw8 +7R7fw9ngpeSwD1UcsgIIeJwBIwDc//acAfacAbAMShSqxpPDiWCuyZ2Qks8rmo9W3nv4ILMgSlYE +SV8Rh/EF2fcPoJumpBGYBrMAlYJt3+PMGtp4nAFRAK7/zg7ODpCkFAxYVcuMGjv+O9CD/BIGYS5Z +kplGsbgdBRTG79AgRUwtALLoVJrKdnV36NcqnZPpBXwUQ855aqHmB7jKnqTNfHFtQ9EL8KqTeQbV +3WsmufEC4PO9pKSbTS81ouy4+tXS0J8EHOp4nNsitEVogx+ryLXADpmgp9K9yi0vDB9IXd7p9i7l ++OYk1kvMAO/wDuLxAhjJLd2pB6QheV4XUzVoLihK6fHyeJy7xHqJdYMHo0gfz/Sf/PvlT3j7vzRZ +H2Fg0Fq1cvHmGMYyRgDobQ2L8QJCpFkPcA1/6IOhOqt4yTPW8YxvcnicASEA3v/jFOMUsIgGFOFZ +NeLnmSoPB8hwiIevTG6u8ra6s5wGxwMNARAx6AaMvjB4nAFoAJf/1QjVCLDWARREsru6jn9PA8RW +yoG8rfNVG7/gPLPqASYBFKHSgfhNquRc8uU+DpaV6Uy4f0QNkyQDShS+2O0qJ4FuUa3y1FCq5Q6E +fiEWbZOCA78U6qqJjNgXlUBRAhXq6Kd3KpdLNwF21TFZ6QOMukd4nHv/i+nTT6YNvF6TJTN4Njt4 +GTJN3uApLauQnJiTk5SYnK2j4BUclphTmmplFern4urm6efqsvm/T0EBAIRHFUvqFYCqcXicAVoB +pf7mDeYNkJ8U4ke3ZzDybkvoVQaoDLpCmT2AEP2RszkUw+LY8VQ/sc5UtG+UmEu9zbGo4yeSATIU +V/+xazoPod8aV3w9qa/Pyp6j7dOTRgExFLU7fiVMb/DIWlkJ4UVlKUpXDu7Nk4sBWhTMcWfNwT5s +5R/pIg8WHIxqrtVbC5P5AR8UjS18eXoiAVMw1mCuvRSoJzYSA5qTLAKCFNsIDyrtQzBWoyG/ykvg +0vnxWjuhk8ICQRRrusI/j5pY+YN/H0xxI7ojGObekJMXA0QUYW+FJynl8nZ8O1/B6c4YwDAb0LyT +bwMwPN7C2sDVBaQom1FzWx32E2HVS/TyMTAwNjQ0IGxlYWtzYW4uc3VwcAA3Bg0nxWdsJfi/LHQp +4BTtCAZsALPbA0wBFPmU1vyHJAQSVYfAC7xbgwaa/GAekzsFaBQYsYqiJdAMug8UWLxY2v5NpJwQ +17O3BS8BxLyYVf8BY6ODFszvA0ZN3XD0q7U11tFalJJ4nGtjaWOZYCqStEotdLHSI79HT/IcNlTl +zy9bwG+40XMvIwDIoA0krwR4nDM0MDAzMVFIKs3TLaksSC3WK0ktLtErKWYQ73vwgPvtXjnbBau3 +fHooYbsj2uGUiQEQKKRlVpSUFqUy9Olk+ThGBO6VTbZ8UJjxgzu/LtwdAKxIHuXxAhwJ9T7Qrdop +QzrD1DqkSDiJ4w2EeJxrEm4S3rCTTeSFqQBHVfrDdZXLGDb6fXj8hbeqUnbzWbatTADr1w6S/wZZ +y2yHi6aZIQER7mJwu3wJonIbj3icAW8AkP/yFfIVsFUBFMFukvVY7CEoTRpAvyYK601UY7hSs2kB +fQEUU17zfgyD09z7+dSO/kyjCI+PhAGz+gLFBzP1ekS5QBSvmrCf4RAbnxDEbJVmJjQwMDAwIHRy +aW0AkTQozZ1Rni5n3ISo/lMHqAf5dK/wWzHg5wGKsXR4nDtcv7F+Q6L15ixrZyZGzck3bfQ3P7O9 +ywgAfsIKEfoDX/+xSLPy6KgbxmocY0BBvbMKz314nAE6AMX/mROZE7AHBRSFkySazskpLoP+HwhQ +p2VH6GBDgrMbBccDFJriE9dACIIfz46F+QUGbSeJc0Cnk/YIo6QUF9b+A9Wn/Tu9wH+Ob9E7pTUK +LqFliX+XeJy7wHSBSc7EAAgUkkrzGNKnPH597dyOLF/mpbGPDOfNV5VSdZsoVymi0Phe4nH4gYuT +Hmxz2V3aZPEu3G/OxNVLASH0HAzxAgShSfypAc6fQeNylXV4czfp0C6oeJwBIQDe/+IS4hKwDgUU +qOegUxU3Jbe3N7+Twq2vQZxYt0GzIgVABPhsDhPxAjVT85prskB/W2D6/Q7xNRznBfA7eJxr5Gnk +2TCXSeRGn/3yJPN76i4f3M4xa5UWS7Of+7h5I1MAMwDigQ1f9QXPg1eH2TH5DiCdUzzr2gDcQtAl +HnicAVUAqv+dGp0asKgGFKaMYbdyvdj7qY36elY8A70lalg+s7wGXQMUgmYFmfQo5ozZXB/6eUt4 +irSD4TmzLQo+ARRLw8JYdxrxdIXXppj2fecQJ/CRg7N/C54BruAoFvkDFXnJ8FLlSmhuT7FlTAz3 +V/zg6Rp4nAE5AMb/9wn3CbA8BBQnX4m85r+LKsna+elghx7XYcYKkZNQBGUUwIlucw0c5nxZtn0Z +HDmRUXhf26CTyQQuD+oaHq8CeJwzNDAwMzFRyMtPSdUtLszJLEnVK0ktLtErKWaoyrxZ0On96O+D +T5uUZ5jv4HtzuV0PAJ0tFEfiAYjXDnicu3GPc9lNzg1aNc136rbfqWOs+QAAXukJ+e8DgegYeJwB +PwDA/8MXwxewJwIU2Wn99eJbqCeBDJK25krL2xc8CvyTvwIXs1ICuAcU/A62fWYsIADm2+GzKno+ +uq71OJ2zHgqlAbMXHQTgKe8ReJxbL7ReaEKESLgaQ8rGuM6GpD722uP9U587st4UmZhTKZIskXFF +ovM+j6WiZ7Yx9/JEkdaagI0/jRmtHk/+VP/bVMrLru/RpOdL9mfuPD//oaGBgZmJiYJeemZJZnpe +flEqQ1ZVQE/lW4eT105xq7yX72WPmNbsMzmNKUHExPEtg/ihJ2f/KhxT0zBkbMxIvntx8i2mJhGr +r+9SpnAUd946YrX3gFr7JrG6a3WTC5hdE9ZLveM/67/cM7qg4Rob/1rGM4z750ItdE4sSs/Xy8lP +zmbgPFNyqaQmj2H7JBZb13XvOE2CH79DUVWSn5vDoG9pkqGq8kvGPvvz6XWSDYXWhfmZk0VZTCwZ +NcJvF/f+NDm18vAphv4wkalKJ9ig2oNcHV18XfVyUxiOsp+JfZP0JZ0xte5G2N7Mq4eDprFPbmKJ +EMnzapyifs4yPsRhx8vdFQstMyYp6U9+x7JVZO/54jPGn6dcWP/SYudMhos+2otapCdvZ9UXMWQ5 +U182Qeiy1J4A7tePJKs9b6UvmfyL9ZHIj2865idzAg4X39h8rINFbc+JLBfNyR/YZEX8Z28SsTnu +8+zo60LpF9FhB14tvL54siK7tciGy8eabjsXST6xkPyvaXTUIjCV8cTkAnaRSKnahtL1CZO1u9c9 +94nQdn01LW5hp4kBECgUJCZnJ6anFjOsXqqQs3TF1SN3D/t85bFJcv6upqgBU1KSnAFUIf51zo9T +xRenyizLjv181vCVjnbkjcl32VNFnCaELLiQ9q5oRVB3h/r8sOflLgkKk8M49I2z2g3Wqtw//ftb +/tuPD6du1m96IFkGMbMktbiEQeG5lfqdSCG3iWHPfha01j1WVw0PnLyDoxwAzmAdCfQDy4UkTBDq +IWKUvHzKFqFjDJeHbT54nAE0AMv/xwPHA5CUFEbTmpmp5GMsxJZE6yCePOAI8VAwsagLARSnB5Ic +yz8nehPchPte8xH2Nz5HB323FxrxAlxYXxiuVz5Kg5id4cDhF+KLkav2eJw7y3OWZ4M9s0ivDIOH +65WrBwO7G/fvuWghV6gVfmtzMPMvJgDoMw4pbeRveJxb+ZRp/k2mCQabrdjy1wAALG4F2fACYfJV +eiHfYZgsD6kNROKYf20iral4nFvEuoh1gyqTiGaTn1Zhpu4Cv+Osma8bpm3M/CI/bbIlUyYAvakM +gvwB3HepJf8EBeeq2CS7OTd399jRSo54nPvA9IFpQwyjiLnu/tD+hXWb3v69wPXeZolGp/MFbQC7 +jg1g/wETErc6WNbPn6AoXaOK4TtWTYOt/3icAR8A4P/XA9cDkFMU6Y3Jgpavs/IAaCX2NaFsl+YW +iZmxZ3AB+vQPWvEC+fPfy+KfutHLWwpLYkBafGSvWoN4nHsv8F5ggw+LSMLx/3MfKqflvMwwqf4S +2iv9+Ybr4s0JLPwsABS3D3qkkAJ4nF3XezxU6R8H8EfUEpsoxbpWyGKYJLdWkSSVS2lcYo1j5szM +YWbOmHMGo1ZJaV1W+pVCLhWKRCHSRVIUKrsVpXRB5LJWKpSI35g5dJl/P+/Xmec5z/f5Ps9ZQSZb +mJvrmNDYEJdJYqB8DoSDR83v+0tXCSkJ6y3+8OtLds0xolitICATwREmF+XDwDLxnN4jJd7atcZN +ni3SnFy9+9IMQtk7Obpu9zDh0IH5s8m68oq61ftzIGq8slFRZ9zf28zJop8OxIXYQhyhYeA5Yzer +rSfRP+qSqtwC46rP9KdztQmD4WDp5gX33JZb0Mh+J9Dfm8mTzqi/3UxKDcJooN0tev0TvnOrTUU6 +PWFn4u0SbefzEhEIcbkwnYRwaWwBHcYAR79Yrr/DS7tK2nC1bIFSl/L9y8JpicEW5qBIt7Du6sW0 +iA/Z+9pOhXd5v+yYxyIAyke4TAxjA1VhcsPgzSDjs0mGhuEMu6ss0tmeHwwVE2Lg1VhOf/GQwXnv +wQz8RUl5+Bv6iiWE46M4GwGkl/L3ZRFpA82AfVdqaMM1MX07Ur8F4qfsHO1R3veqyojykjUv6aiT +nXv+XGPiLQcKuCZwOGzCgbgIAxa9qvHnd9SPULWWmrj9aW39JI9k5tqX/Y1FaChIlL2rbqH6TtlU +pcBDDh1kzuYcSvmGBGEmfAwYP4k1mxXDqUEoJy1jyaRFWRWuXcTABFwqxGajNKCZuN6jQid66Y2q +OnQOqfNp0qmbmV8NbapAdrlM3m71NGgUdsc0xWzZcUSjV7P9e0LlQDQ+ioHVt9/aJtzqi6IZZd3n +h1mnrKzwePRVogKcJ8CpOMTEwNYPKm2YqpaxuiCJuTuoUFX9ekvJjKSzYT5Qc3Bp9/g06b3a8HXL +mfwN5CCy0b7vhLhmrsUUg1HzC+ZVYQ6UdFriL2k5OskzioEwgUJ2W6X9wCVb2U+tOGJy5HbAul8L +JYAG8WFMvDZ7/SKPTwSC8k+6izJrPSgavFtRQYRhQzzgE9kaeNd+gVpN5b7ZUumH9EpLdOu+xtNz +pw+716euF8pWuJqdSxXkDWcdLjFcYUYwBLiPpO19FMCXOpObhfhM9hoG5EqtJB6C0mEmzAXvj6z7 +eVdfvYZFrq1qfmRGWup5rt60YLNhGo6gXAycqLgt5aYd91rH217/VXbn+4AlKZqE4kMYi8qCJK/P +wTT61q6OrMZ6+X/z8AOjp7yUnpQTDuMzAP2VsLbD8E71nY6mhb2Wi+Pz/pF9OR1jgJVF8nMpmD03 +uvFafPhQzokhZ+MVMymVDvORUBj8NbDkZ/jWvPj8B/uS5/V87v9ivvrUVzS1OEdIyT9V2Cze/kWz +akPK41k+3pxnxC6kIxgPwmks8LY73mE0ieL20mtLR/X1oTL2efVegogmm/nS+6Crp0EZhST1SH6t +SsRDy/cYkaI4zA0FUGRGw6Y3tj02RXE9MRnd9/ifjaQkAObzuShQqFT+uYkEDnnXXaA43FtSunTd +BQGRh8JcnMpGUR4YuReUab5hMEpq8QMLnHHF4sazCTkChcNUopcOO23vfhDZFeL3myz4Q6aqEzea +pyhBBLALalxaFdDPumG1fdDC/rK6fGHyRglgstFAYH/qY8NfQ9faPkbsW95+wXRBA2/8syRmiZYN +HBj3908I/eI8m3mR4q6vzmyrLKcRMcJkhUFC0HjpoIJXf821+5jRzYWJa0xipNJfEQLHeWBrNBxR +Oshfa2STyM3sD3hBG7u49mssXo40421d4wkJ1/Iqz3/cfanDynp5j8U3BBfyRK3V5JyR4ke9zeqy +RSpBZ008RpombegShHARkLV1zqFfIryFwVdcNV9n6XRFBU2+mE4xXNRRwOzesfbFV0Myiv+LLuq7 +XS8VsjnF5zshHsppBegtY0PdNbfWp7Ca/y8eZ/3iHL9XktHsrGZsmMhur0goHL+HyimnFtO7QgmH +ArdHL+q2fJmFaadEllbGaPo8KSURDwnCQEP32NCJdY1kygatL5u24YZtMeit6ZDKg/iYaI8soloK +/bsXFm6dNWfPoIyterTw98M/GPFoezJN34Wdnj838+6O+tMQxVVz3EztqxOdFbjoYSedT4fL71un +kRsbmrpuIIi7wu7J22lEA7GvWvnMD5PyD9/RzBeWFOsFuv16cCadbiHK5387eL2r8riFL2geYNnH +rg7u0pEgNhII8WmsqW2Xhy/Skt7p5uhbf4lTFByR6bJtS8AMosMMNoTD4q5WL5MWu+cnGiaIjtHh +aFslHTPrSp2BglCxiQgeSCy7nkoVSC+xuFH5yLi7/dgb4hhhI9xgmE9i8GE4EKObsOkYoAj/tgWH +45WVrMPdbxwrK9VM7UO/02Jlp3HLN2DLWGBuytrMZ9W7qzvWx5hN/y8XB5veNl3Q3qTwfLbMEi/H +rL0NPfrh/xIxFiJAaOJxnR9+qD62ynhzc8zeE/Hs9E0P/g5/KkGiu4iCq7defnfDyjfJBvT2T/1z +1TwbiRLjIBzxqSZ5xnHPm1FBnvIZn0hV3Au15cnnmEkSxhV1XBJDJAMhWjAGFlTqN/5UmLFTc1ec +o8bZg4YbzugEfYWiQsBZIL/6pN/IwC6DvL2WNhVnyfTA1BAliUF5UIgABo4bVfr/fUtXUe8TVjVP +XvEyOyhPnQbizk1U9H/KVoOKVVZGxhdyaoXeei2FMEQmnPh4BF/ggyG5vuZOfVm67n77A5QjtnT6 +SoCkIjFg0z40mzvwOV1VQ2WiKvX0MJlje3VaTPXU5VhVEn61McbBMGGF8crCfPMnLxS/ycUlHaeS ++4xak3hzvWXvRrf47VpORUXWM4aFAWvztA/4B8tS2z67BPLTSM2eL+UPiRwWHR9POuHGsl4r60eb +w+wz5GhPLbyUrxCx6HYibkiensNpCauGPU+kn3KsePrW8XaQ3lKCiEp0qmmCTXsfe0IGq46+yVwm +xwQfDBq3VhELycP5QHHwiia657wdfQ8d0jVxufJZ92SuJOXDEA0XXTw4PGTqqFtkavn7xmSFGpkT +YUV9H6FWmxeay6YhhrJDYWqgAGHjos4C5LX7PdgXD/Szloag/9L8Gy/v/3DhO8oHuGlJBefJm4XF +47AGWbHwIa90/WqCiFZIBJrMu3YfScjJ+c178pxw2HH+/dqUZmIX8AVcHOHAJpIrGMh3LbBzfpO8 +Bnuu+4bn6sN6oKFl/IMUqcPBeb6fQNufEzH7Nf8BpFj6kJCoCAIBmfWKrNP+h2Jb7o2+80tSOzQB +ZTtIBLaSiomu8aLbKtjCRf5yQv7b77EpVMYgvmCuj+wIseoYxIBxIbiLjPApqmpawhKF+ZGO7euE +SZnE/2AwBwIuzWSVLEvmpdLlsv+UffBlrq25e3kmnnox2JxQ5Jef9tuMpTldqjflUP1l73h/C8R1 +pXoutrS3O6pJN7Gs+/1ZrSNnXo8mEIgFUVmiRgeK/xd/s9SZ8nBWgUUVXaFgz7DViO00gUWdn2jO +O+p2vh44VxDkmfPKY7RECTUNOkYsP4Zw6AKcId7k3bpjlpn33NxXvzBzn9h02qAgD+QTChXwaaKJ +8cDjD8wlJzqTP7V1uOSAxxY++PNrf/9gxGP/dfGV5VeVq/97Tp4T2PWHmfSauTmthONBYVzQ/d45 +fNa7V03bjJWNU3zZ22qc45BvcvF49DzdHFDn9Pf6FwPmlgfcByNO6tGECWEDJU8ztfdZCs9tj3+S +OyAgBWarXd41k4rHUKTk3szoi7reddpc60Wy10UFj7RIQuCimx3ERrkwlcmHeCxQnObfZ8YLfbzK +vz/wttutF9nZUrFEdWFCTiDKxkxExwG4HGWe5zN0Knb+ePRv6B6zzTpm2ot+YHg4Du5t2NGsZmMx +vsmuWdir65FuRn62iPhj0bTcV3c+XUaXrdih4jH2RRC58+MNqt9MKh74bNOTexacWcxSdEu32rh9 +Q12Zw/wBicBpkn4sdadVunzHqkzqW3nrJBU2Z02hlAYh4HCcSkcYDCBP/3g01z8u78L+p1dSr43O +b1KpVCEMS7Tr6VOFrhTJB5HbtmsVZ27xnd9wlJRKbmkjDB/iYpKeoNOyF9I/LK0tc656W2DwvMMZ +9v4ZxKxxjIZOfRqI9h7KBY803ib9qjNUpx+jaKd+8/wy5cKJGsnTBHw22P1Kdv6OGk3LORQ1ZcP/ +mWscdWCtIdIwUSO+Id8aOiG7KHfpcrU7AZGk+MirtTOpeM6fjwYsD5H2vaNhUN94MkQY9jNlDdFv +QiF2MCwEfQcGG8NV49Oc1gjCfy/cail3t4Wo37CpXi2ayVj4S/q5eX1ylRXCZf4Py8xzO98cJQQL +EXV7U1iqOXziPWdHHDg84rNbt/T4jXnETMMQLh0Nw0gQjyf6dmagJnwacDldRjk1ufKv3naPY73G +jiN3ZZyJzypCi8e99kRotpq+f/zSZyu5kYG1i3lyx0cJJRTfV0fttjjNcSn4x6deTnp4cZmXnZIN +cWcWQnw+iLeqTJTSSP7Swkud1NndeaikNogriSNElw/wseZqR5hLim7C84rqvsYeOtl1Y8zXWDyC +AZl5Mi8R/YaLu99VqBnr5VfTo4kPgwgMp4PGgrIeE+O7DrUHvHeqmy7Zb2a3Zvz/crTfsKgeeJwz +NDAwMzFRcHR39QsJ1stNYXjyWVFVeurCY9ypBntbXWaEFLt/e24IURTk6uji6wpStD9ispV0A9fL +7f+fV+ef8zq4yWW+AlRRUmlmTklmXrFeil5JMcNxm9NHD7i9muH3nZ1vVcLhO19PbVtoYgAEcHUM +WcXG/xdXc75b/yB307/Xd2aH1AsKwZTkMUxgX6x9531ehuO3+YFfNqQf2aEvbwWRTS1LzGH492eN +bOrmosppp/svKNf1tS26y3sS6pDMvJLUorzEHN20/CLdktRioGXpICcVyQXeKAp9P8n9T0bZfqHj +yhqGrFoQE2E6GH52x34S2tz8vjD6etOfkNWv0rg2H4YoyctPSWVwX+zTW/eJ9/Xi+rJZhqazA5Rv +LTOGWlpQlFmWWJIK8XyTt57x7+MX9sedMdfKnzVTPH/q6mqIMSUZmUUpBYlFJZUMOroPFioyh7Qz ++UmGOBZaRvRcus4BNaykODk/Ly0zXS+rOD+PQf6dWEDzugXrVJLmtz/VZrr9asPxX1CF5YnFmbpF +pXl5qUVAtQxxNVt6brv36Uj90b5k/nFv5bQpOw0AWwPIFvECGXp8CNAUlwlt3cRXCNFuYHamCR14 +nAEhAN7/rhSuFLCRBRTmJwueY/UchMKi4tDg+tR0x0Nkk7OlBYkEEQoQsP76Atlhx6bY1gyMj5yi +wP+KvKskcwlneJylWF1sFNcV1l2oQwzYUPwLhtx1ib2DzRqSpqI2i00NaXHAxn+gitgwO3PXO3h2 +Zjsza+OAtVHaSm2jPqBbaVI1NTjtQ57aqFuwVFUKrapWapS/PvJQiFQ1qdpEQQp9qFrRc++duzNr +e0l/nryec+65557znXO+e39wt/YfL25+baS+2NOD93r2oKm6LjYs11NN08XjtjZLvE4XHyvkTXIJ +5x3bs72FPMGqh52C5Rk50o3ns4aWxV6WYM2GlU5B82yn060FkxOgO645Rt4TRi2NYL5et4mLLRus +kIxJNC+TrM0ULM0zbAsb7rCtE7F3Yk41C6QXF6xZy563lF7MP4BO4NwJafZyLQZjXsGxpEogsTOB +al/tYulUPW5ryarusOoZc8EeJw3XIxZxXBrft7e6UOua2MMPCIf3VC0rtCZOjk84quXmbcdj6w9X +E7YrfbViuSVlpx0yZ9gF96xjeMQ9ZlsU73u8v7qYhDbcbMHTISDrO9FaVVz6WddQzVZhY1ZI6ZsH +W2rEz9LfDj7XesjI4ER1+4msaukmpF0DiKRVbVZRgriX0s/8OlY8ij2pionj2A4mc8TycE5dAPwQ +jeiQGs/FOsmAmOh4nh0PoJMDiLH8J/E48TyTYJullS3GasYjDj6fVfXjzGIEKy5XPU0s3bBmWKC2 +k4RLzEy32FsBWNAHV7vowC830sNffpTe7W/xsxhtpyjVVidPkOC6dPRIc2nvsLKhpht79iyhJ0cH +gp+lF0e70CHx21I41HiQYKNzs2tDNIXjqZRQxleu4NKtsV3oMbYIY7YkyQ6WaAef27uxq2WJXjAJ +/e2kUid3gDRjvEhrJn5+sBtX3QW0FiORkIZentijVrgKdTg0Pu45RM0JTGPNtF3C6lxUbZZoszgP +wIesilAT1TEN+Ls6N24yODq9Pr2TvjTR/kiwk791OdbcbVuT+RlH1Yk+yHYQvneztmAR7qX0Czyn +t841PBqi9vpYU7HCa/4zyT09njM8D5ACMXUKhMVGADjwi+BUVHsw+NpXaWQwVC5YAD7DIjpTkXGb +zNOlibaB0MNPy3FK5lgpO9KfTNBfTLwrAfSdyWORE741GZdw+mjy9xtYxx0jngpJEC0jx6oko2pQ +GyIJohGIZGHIDpQM04NAsKwV8nnQEcWYLIdEgC71UL95eHExmhaOTW7xK9xgbxgjITPt+aoy4Wcv ++G5CziOfxggULOjq68jGzwYdRualUima97UCuWaVK4ssa/TCZJeM83tfzcYGKgNTNS4y4VyxPxkG +h7491kx/M7aT7ju3jf54upVmnn1eJG8GZoOj8uqDyEAXdAs5yJdqwc/9kE3ID7Q/L+vY832QPFC2 +F3CuwCaICdWoL2A4P8hhmIV55B3ivPgf/BU/QiyLJBXXETsLIrGs3sX5osCCCNrYIkR3OXqGxtne +BMY0uGjMGJZqRvo2c0400KQIejkYonfN0p9MfX4CUEHYXDc8QzWPqZ7ax5VZECtGeLhaUQIXJVzZ +RmraJCeJNeNl4Tz0rtba2xfoMEuVGkp0O1CPOMYUE/Sv2t4zbFlgIQhnEHuonCtXKiSf3r3L6vTW +WLyr0qzMEtMXPwM5O6b/qyxq8u88QJt0SMhRnC5kYOARXQS3AiQCPHlTZewoSwJbDDtfKxBgMioQ +pazsxsmKAObF5MMpf+QGeqxBRk5gRRQtff38nqIMZzV2Up7q0ZXBp2CP7mjsy5OqnFCOuxHLXJDg +3m+4bgHOC1CbL3IKgwuuOKBt6pgNa5ZYccYkHibzGDyCQGi2AygVpUEilRGCIvAounkFSHmgEu3t +AQuA6Ly6iLbUyeWCGtBFtaUuXE6gxfgXXontOfAQAhaESemL7LtIl+/t8H+XRdvo+Ztb6J+f3Us3 +TT1DR6c66dxUZyIoiDB0iiBE7rkDU9HPdOSbg3TPNKYD9xqRQlPTLXRcb6oRZU0P3myk31U3bYXt +cIZVK8T5sn/7YqwNLZZmp3fFLgYeFcQADgh7Gb9QkGqO6KeNvKzK4CShSjXiu0aTQ21zrQQ6fIjf +RA20R+sp7VLvoMb16fOrF9zStKY+9dk1lI34byZRMz30Xp3/fBI97r+9Ge0qXf2+fs6/ORqrp/33 +G/x3XkAb/TujsZrNnukeFznF/ravo7Ye3I+hugFJhgujEbLGxQmdgzQggZE54d9Oog4f9aDmPavd +qFjTRz/+5DAdv99Tuvj392tK7/xr6YB/dzeqod+6/5j/VhI9wW1se/hRmsoNMS65Ju7owCvf7kE/ +3b1jndbj3x1FDStfOIXefzqxeqSzObFev1rZ+T20WLsBtFboEmpHkn0c8Zv9N66hJ4L/V/55DW2P ++bmXUMdZYdi2OEtjbEHBqSPlYuJTsMpmFbSHwHzmJoYn+AL/42uo8URf5NBMWF571NKHbMPiqt3Y +KpgmtBT3+CWN5CPcsFv6pfijB9COz/D/Vtp+hD7ZXuSW464gsQEcI2VPLM1ZyHthm1+LerG2jOWq +mF+rN2ll/DM3UMsG+LBi3UCfe7LI+zq0t3BwsrYuBz1rXqyhBe5mHDvH7qQG3H9Ef1KSeASaHFyG +BEkvQyRNMrYDVx82HFhzl0QQRipYwx6wc8ac9vHtNHbHNcEKvy+FTFDnHYCDEvpf8jJq9bedQk0N +kudE5Ir/+mnU4t/+EG3xr36AztdFZdBmtiyj3f4dqOwGwcTCDAPlCRZf+xPahBZX/vIBemFjfTy6 +eUcH02hcKX6I/vBaMSQn8oqJ0wt51WX3ERYxPnlYUOV86IVzQbNjV0YxGiC9x0eeZkOTvTBI6q1j +3WFcmlESlbVI3g4CliwotJdVvUFMLgHFjqSMDd+LAEu+A1eMXC/XBbA/uxRrK64C639zKZQX5jCa +ImXS6yBAqdryKO9PBhjo6Ag+FtmYXkWzQ2koHF9Ns6WS8DMYF3qkriPUV+om4hV8B+60brqCppbX +Ru4QSrg6XPefLRAi/91LqGGyrBnhJMxSYrWzEZYHPTa+Rhw4q7Bt6NWPdispcZ+MBiQp6WZFPOnI +TOMh+U880rLK32R4xPtExWcf/xC1nqnUhLIhDE0MOlDgIQJCWKZWo6F/bXZ6/aFrsd1FsZRjOFX5 +eFY2x86ME2ssxiP3Y3nJ7sXxCMlhb3hQleQSdEbWiuy0S5w5xlnZfYIXX5EwaqcKBxwCdM5ldtJA +BK3yQ4KoQDPor0lh+ShcSOZ520p0coVOBQPPhf5oF4Ah5oBA8qKFtrk/79gzEDaXDR3XZfkM6u1i +EfaVTJB9qDylUjnW1nsPSEVeBJQqTwZBmYvOt8jJokzWkOMFLzp8UXvYE/grjrxWljMbj+4noFp+ +I/jjYFP9Kv/pg2zLU4KeYjUNSiFnD9Mrdwr6CktFX60/vBT74kZ2Hv8bS7F08UsGtDreTPmrj0lU +q5DHaTCiZTvlFbSbTRjossAxgXmKtEUea/l7heGFYyYkEYY7KEwGfIiHqp+90J3IwRA26lW4vKTB +h4QY/f7t67Ene+RFgmv3htqrlCXV8O9djzUlwyeaEPv8fah6v66r7Nf+y9dibzRykiIWK1KS8AeW +Y/tS/8tjn+zrfX5uOfZc//9lohb7w8uxNkneHnkl1lD3b5pUIqehZ3icfZR5UBNnFMDXY2A4qihQ +BMQJKEqlxKABESpShMolTKMEkLFxSTawyWY3bJbEcDgOVDStpdARaBsOFQRFoEoVhYJBWg8OFQEp +QZyAioOWK0bqQaXdkG3slBn3v533e7/39r1vP08Gw5vJpG0H8USMTmAiBDjxhHW5T0e8KT+bG+9j +mWvR1ddt52mgwnZFRUbAKBSYwudDOB2XAK72Mafp4r2P3Dudk+3j1fnq4QUXmAzyoYEIgnFBAiOh +FdZtqsUeIW/S3ob2PAsLq+Zp0S2UERTDeo0UzbVWKu/d960L+LbWM57FTB27R2nEMHDnK4/h5kJh +s/mSuBsWR1fFvHbXdRiiCaAQApDM9mVO6Cr2w+qVuxqTKj32jW6apsIwyoFQApcDlw9ExaRf+yHE +lnlRrQKzpCh+9ybVQkIKjPD0TYgWRdw4579xyPSwKc3s99Pa9SWlVw0eLgIDW7jsF37ZO8MUCwLB +Z97NH3f0y62pKC4XExhwYIdVxAm7WkVQcNspJ8KV4z7zI5sqwYMlYpDgJumrzBArD0r/oumUWME6 +mwkva/uGz24aPDxUwhFIuIDqg1gNY/DztU1Pv2MI8vP+nm1g8igRhOOYYe4RouJEX9Ulzblf21jR +JtN5eSahBgufDwM5y2eR2xZdq6McHLMVR7Y6BFvKGJQhEUIhHCQgHoccDo9809uWNAbQrLrsBHKO +35jH/g3drRtbLOfxSZiE4ED7xRhOSPRJB5PPKTlLdQPa48OPnGyyGHW6ft28JIFEAqNCPb6TH5il +6RVWxzUML1N5nH85ctzfgcKTZEavvik6Qe7Cz7lwIFzXKHY4wHE8Phne7+K2bT5Natv6i19OVdX6 +7hxT8vwZH7FOLnajlg+LwEQIKDU1X+iSHK6iHzoaZEKzfTw8lNtMiWCR3kI2yUVAiYRDQBLCWF9c +WTTyR+JPNS/W6O5Eet9wXRQpnHhPGtlIjSal5MuSkfPMqRIpzds+VROszvw3Q8w1intbNzyuGRJB +WVYXJieUh2Zl2pq8/2CkqCuDv6EJiS6odnVOdvGVXasDVV+/I+bWYLQdbt/zvCo0ErcPMu0Li7Ut +2DodsP7/LKn8BC+/vhoQsdYPjkr2eChprCDfIgojDxyJYcJ3o69kxp0Jp1V0XMlZdWxCncNVaQcV +82BS+rZzR3iXrLTpIr1+T9Wimvs+45GfUhwCJ+iJmLTlz4gHe2klhbcz+rf3dB450htjJFAIxDl8 +mI/NTRBGE40NuNFf5kze25f+m7lvk/n4ZovS8gz/96SRhapPLZm29baJbd6iuLj7TX1mlV1niOEQ +oPr7I3112lhA926bsBfZ19tdpspSJk4upYQoxoP0hvTsXyxb6pmvB+8s7qGlCxWBnqE2lIEkgIeH +ApsGy9IGLK67nG0gym4Vj3U4G8ISCJdCOND9YcgFH6+ab27lm5x/ng+w19VOIRSQBCEIsOb7Uy43 +vSZRs6jWCKcV/jsWrs1TU3GMK4QIYCTj4KxD7EyZz+OWgfbxIis2vmzEAOi/k4OnoOQvBbg96OWq +X50RhM6M9sl7+NqfLYIEFAWLyHiVaLIl5ouyjODoUq+rXmbO4631lwxxKYgIIfnc/eL8p1PqtpDN +lQ5+QsfaijjBJrOCcmocMiiBi+FzE4l2pK17cplRIbzyaqiuQrPGRxs/ZFBREMC+qnEfbjzWNMl2 +ZamKCqXy1OJNRkIKQzJg2wT9KWdp8snMnMKKtYqe2buvR23+ATAim6LxAp+4VaYvA8LS4Gffw42y +ImkEs+0BeJz7KPBRYIMUq8i7HJc+n5DeYr6YZbyZdn57OjTWTdusx+rMDADjyQyg8QLCnVMWeXzN +oZhZxfvacxKA+Ev/QXicu8R6iXWDB6OIlNaG1j9qVV+fxmdP+S/49l2EkPjTzTGMZYwA+7AO4fEC +uOHGME9FlmbTRkE0NVuUf9ur56p4nFsnvE54gzGbyMNI00fPZ2rxs58o6Ghf75O37tO2XZvd2dKZ +AfQUDrv0CUznzrulGNUshcdG/2Vnq/V5Mb/AeJwBlABr/9UI1QiQlRSV+tyV/AfP1cWrLen6l1Pf +SBiT6qGpARS1gwZAQgOq7364wGgIIWuoa5DpzJO9ARkURLK7uo5/TwPEVsqBvK3zVRu/4DyT6gH8 +PrwgkLDNA+E8soz/oMiXvvs9nawdMTAwNjQ0IHNvY2tldF9ib2R5LnJzAF+l1ZBCogClAQZBUyW4 +9tG0JV+DsyQDMQHfe0Zj5CSM7wN4nNvke8llgtXEok+SuaklGfkpCrYK1QpFqSWlRXnFVgpJeol5 +lZNjmaUmz2eUmpzAzsquo5CcmJyROtmbUVK0vCizJBWkgUtBQU9PD2LA5C+MIZNzmWSlwbJOpWlp +qUWpEGMRah4zmW4+xTybeXILu9rkbezqk1+yb2K3UgBrmTybQ5kNqu4kR8hkQ86MyYVSIpP/8nNM +vsApIA+R0gHaCQLpqSXOmQUZqUVWClA9nFyyMO3RXLLcCFt1JvdzyU6eLcQ1+R+XCkyJLrd8KoaJ +wanFxZn5eTAjkWUyEoG+Cc5MT8xJL8YiH+IT7JaZl1mckZriCzQkMT0V7i4+HmUlbOpDMpOzU0vg +ymJ5xGFuW8kTAmNy8IYCA0Ju8jxeY1ZwpGy+zWvGCGVK889nlIUarZBYBHJYtUJxZlUqNAIVajf/ +EOhkgpm1g09l8nVheVZIaP8UtuBFiarJcSImqCKbT4qwcExml9VACUwrWWNGhc2vZY9zAACKIsIC +6gPXIHicAToAxf/mDeYNsFsDFNHiMkz18Fgj3XngVSkTB/rV2HAPk28DMBSAzjUStQP67ES2HQIu +oxKHkrb71LOzAzMDF+kaQ+0cSXicAc0BMv7mDaENkJWRs38U30BJIQLDX1thgg8knoxb58iXPhmT +RgExNWBVhhHzbXuQbjovuH1LvWFpMmRaNDAwMDAgY29uZmlnAH8vG+nlhMS0ZA/YgxIU2taVrqdl +k6wBORTa4vd1Ak4DEJobU+G7J6T72SjwWpP5AR8Ux18b0Ck723lbgoK4dZTLiYZBsDuTLAKCFLri +d1GojMH2Na7CJnIwEQnWN4RIk8ICQRQAkfgAYANq0ZAuBXdlAjMnI1TNX5MXA0RZuznjqaWFRPGq +ce4wy+F0Bu0Ff7s0MDAwMCBqcwD/2tzA1RFgQhPz2EcJRSIuntCaVjEwMDY0NCBsZWFrc2FuLnN1 +cHAAFAPVfJqfqCQ66OZMiLlAHuiUO82T2wMwFOBOW6YsGEedqKuGQKolwCajmyA3kx8EIhS5lw46 +OgDvaP+lGI1muYejnwSAJ5NVBB8Uw41ZplIh6SKRQ1T4jEty72MnspyTiASfFLdGOZ9+4NbFvkTs +UDqwXzTI0tv3kzsFHRStLSO1nYQjyKO4AbLdnvGsrUVpBpNsBTcUg3uDtKC+jaSqKkndX8Ywuajs +ij6TtwWgFFqmnH0N38qXkqrvrbwbsi8+vshVk2sGe57LzAX7EVnLbIeLppkhARHuYnC7fAmichuP +eJwBGwHk/vIV2gyRvhcU+aa5x4E737rNjiloacFBXVEVQO+TLwFIk+QBIBTzzWyrB5xy8SfxvugZ +CGL4tctwEpMYAiYUkviXq827+S1MDL4p8jIqAvrNIUyTUgJFk7UDO5MmBBsUElu3ny4X7S501fYq +/l1a3SDBlveTigTmkwgGGRTtmXU4Hw/vhjZHmKadGhlSd1+7HJM1BsmTLQdFFFpBkBsYyd4CXnUw +Ylup4yTDLXd3k4YHQJP9B0kUylc1VXOlp64xF6bY53NTAJ5l1pyTWgg5Lm94bGludC1wbHVnaW4t +YnVuLnRlc3QudHMABvr02Dfh2jtMGLQge0rI0saYNumzBwk+AZOACj8UBWEv8h6M+rJfjqwQ4vge +Md6IpROSzHtO8QI16/h1tC8We7hI8ke7SyrEOiXgzHicOy54XHDDbBaR1skqs86d1NRr/ifPEbA8 +1f1FgnPT5vUsEiwA884Nsv4Dy2MdfCTuz5O7tKOLtk7eMFWZ7TN4nLvAdIFJzsQACBSSSvMY9HRc +rp79O4v7mM9+2Q8X245Gqf7ymShXKfLlxAT9jjKzBstczdiD/3sbhfV8nk1cvRQAGk4bdvECz3NU +NrgdbMj1DbW0/+vHYP/YXU94nAEhAN7/uRK5ErDlBBSo56BTFTclt7c3v5PCra9BnFi3QbP5BEAE +CP0PbfsD3jkV1F6Qg9Vg4ImIggAkI79FJPd4nAE7AMT/4hbiFrCABhSmjGG3cr3Y+6mN+npWPAO9 +JWpYPrOUBo0DFEvDwlh3GvF0hdemmPZ95xAn8JGDszUKLQFhtRwG5QqAgld4nAGlAFr/rxKvErAs +AhREi8lVzfPjmHgf4Y/tYIE/2+q7ILNAAhwBFCnEUdNBaOqoQL8kFtsFD+0Bs+YJs3ADNwQUD3iz +47GcypgMUMc+c6i3mOlY0Q6TuweHFFjkFVZwhk5UcejCs1dMU+jMRepNk1YILzPZl66rhAu7jNUt +hr3hgGnzuxsMwjQwMDAwIHRlc3QA5PIQwygdOTvywO9tTBNT4ZwC1xaTuAh3lVNLjvwBAVyfz2p7 +y20RrecN6Vrqxul6dGt4nAEcAOP/xwPHA7CzARRP+GXR/57JkI3NfaNkFmqrn5ma/NAcD1fxAta9 +QN9SmRFX22ytmQey0osB/amqeJx7yf2Se8NuZhH9qULyC6u52o08LtxIm7eqarXsQ4fN55mlmADt +sg3h4gGAtwh4nFv5lGnmTaYJBpvlWaSZNkdz+K0CAEhPBsbwAvOpTCi0mzO235vg3ueMmFba+kBL +eJxbxLqIdcM/RpEJkXE8l+9uKl2WdkzB9G8oS65k3cvJQkwTAOioDd3hAvxceJwBIQDe/5cRlxGw +TAQUu+JRFO7lbfaJTZPymbVkvM/rb3WzYAQ3BBGLEFbrA/ZveJwBOwDE/8YkxiSwxAcUApZHcEaR +Ne7Rq0HuRPs2FrV389uz2AcKBRTZ9w+gm6akEZgGswCVgm3f48wa2rP2DFAFRwEcaPACwWfG4eBC +1zlrBr1iqLERj0YqjFd4nJvAMoFlQwyjSJbbrJjrK+svrGmOf3lghc5bJokMu8kFjAsA4l4OG/EC +w7unETgoVtTNNFdNc1oBI8s8L6x4nAEhAN7/rhSuFLDJAxTwC8+XlTzBI4XUlrGDkb1PUK211bPd +A1EGEYwQXOsD4QZ4nPsk+kl0w34u4we/AgK6ps7M9Xoss/rvwr1yb5pu/zcxAAKFkqLMXIaJJhpn +5wbO00u/07LiXzD7CvafJesBeHAc5fACX/+xSLPy6KgbxmocY0BBvbMKz314nJspPFN4wyMOkVmP +hK87cDTJn+9r/cnKlqveWeywfPI3jsUA36cN5/4B1af9O73Af45v0TulNQouoWWJf5d4nLvAdIFp +wnQRDq5zv2WMpAorZ4o8rfBo32LMu2jbxNVLAbxUDRPxAs+DV4fZMfkOIJ1TPOvaANxC0CUeeJyb +KzVXaoMkl0hTGuvMLxrPem7GyP+q9K7o2tL80HKzLtcHJgDtTw6r7QaGEHicAW0Akv+vEq8SsCwC +FAFcn89qe8ttEa3nDela6sbpenRrs0ACHAEUXOp43aoRyRaakBEdkCDFl1q2a1azcAPSBBQXIeHh +sQAxjgHq2Xo/KJQKyHXLRZNWCE4Uqcl4ScuWjXyy6EaWQKFcGhv4lwqTuAh3OtMwGeYBgLxieJxb ++ZRp6g2mCQaTTSX4N29i6WDcHM3htwoAa6UIr+ECkEt4nHvG+4x3QzSzSL5ubXvajyPuq4OcV3se +7tC9ktk9f3M+czkzAPzdDsTxAlnLbIeLppkhARHuYnC7fAmichuPeJwBIQDe//IV8hWw5gIUU17z +fgyD09z7+dSO/kyjCI+PhAGz+gL4By/AEbfgAoEQeJxbL7ReaMMSDpHWF983C9SIC+dNdDJcE3/q +vrWs5OXJOzjKAeZDDfThApFoeJx7xvuMd0M0s0jk6Zz27mUzFRkF3yUV7K7hXFQk3b85n7mcGQDw +Ng167AiBa3icAYwAc/+vEq8SsFwDFJGJTNFSvjQLcM0hW+oeF+nMnfUts3ADdgIUGKucFjrsTt7u +uFZjQnO0CjpuD6az+gWtARTzqUwotJsztt+b4N7njJhW2vpAS5O7B8oz9faGbkguIUR4yVV6OOY4 +i03mjvY0MDAwMCB0ZXN0AI0gcfFLFREFizKFLmzJlygi/GBDk7gId44NPtDvAoC/bHicW/mUaed1 +pgkGk00l+CdvYglnTsxLmczBasabm1iSnJGZl67gl5+SOnk1a//maA6/VQClExFc4QKHEnicO6Zy +TGVDMIeI8HRlhlh3zdVmN0VkPniEiFWVXfy2OZ3jPicAy/QM2/ECsopPm1ZOrb0p1PAQQiVcW37i +OVp4nFuuvVx7g4SAyAsnxc32lUvdlp6VZQ+QuX30/5vQzM06AtWsAOhdDezzAo6dwKw87R7fw9ng +peSwD1UcsgIIeJwBIwDc//acAfacAbAMShTlLjbc56aIa05IR1qt+HDDienG7LMgSlYEO68RkP8B +IHrQmD/mUQdHW3O/PvPVMN/rtK94nHvO/Jx5QoHIv6TNH3uu1kpUsX2d91FJpFb727KHG1uSGQEB +MQ/b6gOO5QZ4nAE6AMX/hosL7IgLsNIEoxgFArNAB4tes09mOw6T0JQIk9xmDLPGdHsaswqQwwuT +QY/Kg86bh86bAbfOmwK4KdVOGgLjBZYoeJwBUwCs/+YN5g2wAwMUuQxc8MSMYUZ6tjyF27k1Y9FM +dzOTFwNEFFnLbIeLppkhARHuYnC7fAmichuPk28DMBQ56/nhHmhhZY0aPY17acJ/RIWyTLOzAzMD +zmAjA/4B1af9O73Af45v0TulNQouoWWJf5d4nAEeAOH/0ALQApCXFKvZ/25F4pGQdvKVWcPOcPU0 +1B7ukaulAG4RWvECz4NXh9kx+Q4gnVM869oA3ELQJR54nJsrNVdqgySXyKErF8M5ZpT2Ge6fLRXA +m/r0You612Zdrg9MAOfVDaWvAnicMzQwMDMxUcjLT0nVLS7MySxJ1StJLS7RKylm4L0QM+80i7Z2 +bX237ly51UsesSdLAQB2TRDY5gaJvjd4nLtxj/P7Tc4NQip+mXklqUVpicmpCsEliSWpual5JcGV +eckK1VwKQJCck1+cqqFppVCWn5liDRaKDq7MTcrP0UvJLC4ASsYiy9Zu5leRjmi+U7f9Th1jzQcA +eZgks/Nd6vEMZSCUQQJSCuwMsRE0jK1x diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index 624274c3380eb..0c240410ba8fc 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -51,7 +51,7 @@ } }, "candidate": { - "pin": "882b3ce222db5f51adde7dce65bf6262aeb7335f", + "pin": "c6a7bf9d8dc4d44db9f826e47a5ae7645ea6e8c9", "build": { "patch": null, "sha256": null, diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index 43287c7bc98fa..4645b5347940e 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -53,7 +53,7 @@ Source-provenance jobs now check out complete Git history so ancestry validation Qualification requires all 21 artifact builds and the existing native Linux, Linux ARM64 and Windows ARM64 gates. The Linux Bun comparison now builds only the historical `b83b544ef744b6ab0dc1feadb59652261d64291d`/`1600131e46b5af48bbda3559af8d8a3327230b6e` baseline with recorded patches 000/012, and the exact candidate Bun `d9be087429c21e563bb5ac29f8a11805e64b56a3` with measured source overlay `2323913322dfdfed96ecf20163d62f5ff2796ecc` with the measured engine manifest and a measured source compatibility patch for the upstream BuiltinCode and heap-only BigInt APIs. The build receipt binds every original/adapted file digest and the exact compiled-input set, then requires restoration of the frozen checkout before runtime qualification. Baseline and test harness adapters remain excluded from compiled inputs. Existing node:sqlite BigInt read/write, result-metadata and range tests plus the custom-framework Bake production prerender case exercise the changed embedding APIs on the same measured binary. Existing lazy process builtins, even/odd matcher cases and 18 primitive/container serialization cases cover the removed private BigInt32 paths without changing the serialized sign, length or digit encoding. The ordinary embedding retains every feature through the engine removable-feature hooks; an unchanged Collator sensitivity case and a native URL getter smoke must complete without skips. Standalone native probes use the engine-owned untrimmed hook implementation. It preserves the original ordered 44-file/46-result selection and grouped scheduling under the explicit `candidate-pass-baseline-observed-v1` policy, and runs the 85-path historical/current selection union. Every selected candidate file must pass; ordinary baseline failures and unreported file suites remain visible. This measures a Bun-plus-engine upgrade, not an engine-only change. -Qualification requires all 21 artifact builds and the existing native Linux, Linux ARM64 and Windows ARM64 gates. The active Linux consumer now pins Bun `882b3ce222db5f51adde7dce65bf6262aeb7335f`, builds Release with AOT enabled and LTO disabled, and consumes `bun-webkit-linux-amd64-aot` from the same qualification source. Its native build has no source compatibility adapter. The current test-only adapter is measured separately; historical build/test patches and receipts remain unchanged and replay through their frozen qualification revision. Four unchanged `test/aot/every-platform.test.ts` cases must compile and execute images through the same measured binary, without failures, skips or todos. Sync and assembly revalidate the pinned test bytes, binary identity and archived log digest. These gate changes carry no new native qualification result; every engine archive must be rebuilt from the final qualification commit. The Linux Bun comparison now builds only the historical `b83b544ef744b6ab0dc1feadb59652261d64291d`/`1600131e46b5af48bbda3559af8d8a3327230b6e` baseline with recorded patches 000/012, and the exact current candidate with the measured engine manifest. The former `7b573c05d0c52dffc67d4d25daf108bed5930cf2` qualification used a measured source compatibility patch for the upstream BuiltinCode and heap-only BigInt APIs; that historical adapter is retained unchanged. The build receipt binds every original/adapted file digest and the exact compiled-input set, then requires restoration of the frozen checkout before runtime qualification. Baseline and test harness adapters remain excluded from compiled inputs. Existing node:sqlite BigInt read/write, result-metadata and range tests plus the custom-framework Bake production prerender case exercise the changed embedding APIs on the same measured binary. Existing lazy process builtins, even/odd matcher cases and 18 primitive/container serialization cases cover the removed private BigInt32 paths without changing the serialized sign, length or digit encoding. The ordinary embedding retains every feature through the engine removable-feature hooks; an unchanged Collator sensitivity case and a native URL getter smoke must complete without skips. Standalone native probes use the engine-owned untrimmed hook implementation. It preserves the original ordered 44-file/46-result selection and grouped scheduling under the explicit `candidate-pass-baseline-observed-v1` policy, and runs the 85-path historical/current selection union. Every selected candidate file must pass; ordinary baseline failures and unreported file suites remain visible. This measures a Bun-plus-engine upgrade, not an engine-only change. +Qualification requires all 21 artifact builds and the existing native Linux, Linux ARM64 and Windows ARM64 gates. The active Linux consumer now pins Bun `c6a7bf9d8dc4d44db9f826e47a5ae7645ea6e8c9`, builds Release with AOT enabled and LTO disabled, and consumes `bun-webkit-linux-amd64-aot` from the same qualification source. Its native build has no source compatibility adapter. The current test-only adapter is measured separately; historical build/test patches and receipts remain unchanged and replay through their frozen qualification revision. Four unchanged `test/aot/every-platform.test.ts` cases must compile and execute images through the same measured binary, without failures, skips or todos. Sync and assembly revalidate the pinned test bytes, binary identity and archived log digest. These gate changes carry no new native qualification result; every engine archive must be rebuilt from the final qualification commit. The Linux Bun comparison now builds only the historical `b83b544ef744b6ab0dc1feadb59652261d64291d`/`1600131e46b5af48bbda3559af8d8a3327230b6e` baseline with recorded patches 000/012, and the exact current candidate with the measured engine manifest. The former `7b573c05d0c52dffc67d4d25daf108bed5930cf2` qualification used a measured source compatibility patch for the upstream BuiltinCode and heap-only BigInt APIs; that historical adapter is retained unchanged. The build receipt binds every original/adapted file digest and the exact compiled-input set, then requires restoration of the frozen checkout before runtime qualification. Baseline and test harness adapters remain excluded from compiled inputs. Existing node:sqlite BigInt read/write, result-metadata and range tests plus the custom-framework Bake production prerender case exercise the changed embedding APIs on the same measured binary. Existing lazy process builtins, even/odd matcher cases and 18 primitive/container serialization cases cover the removed private BigInt32 paths without changing the serialized sign, length or digit encoding. The ordinary embedding retains every feature through the engine removable-feature hooks; an unchanged Collator sensitivity case and a native URL getter smoke must complete without skips. Standalone native probes use the engine-owned untrimmed hook implementation. It preserves the original ordered 44-file/46-result selection and grouped scheduling under the explicit `candidate-pass-baseline-observed-v1` policy, and runs the 85-path historical/current selection union. Every selected candidate file must pass; ordinary baseline failures and unreported file suites remain visible. This measures a Bun-plus-engine upgrade, not an engine-only change. Compatibility startup and three unchanged memory-release tests, feature regressions, inspector checks and runtime-cache replay at format 45 all reuse the same candidate binary. Eleven current Bun WebKit-upgrade cases must pass without skips. Native ARM64 also runs the parser-arena and both heap-teardown API regressions with three exact completed JUnit identities. Its existing build also links testaot and executes the two compiled namespace cases and eight compiled module-program cases beside the matching jsc. Both selections use the supported single-process native mode under one 600-second supervisor, retain nested image-process supervision, and require every ordered case name and the exact zero-failure summaries. This ARM64 proof covers engine image execution; the separate four-case Linux Bun gate covers its pinned AOT compiler. Neither is ALS/facade integration qualification. Immutable build-tool receipts bind the historical baseline logger adapter and actual build commands to the binaries. The current candidate uses its native build logger without a patch; identical source, compiled-input inventory and executable guards still apply. The consumer identity binds those receipts, source/index, sole tracked manifest overlay, engine archive, binary bytes, measured runtime and separately copied worker fixture. Fixed post-build adapters provide the same reporter, retry accounting, safe logging and process-termination evidence to both frozen Bun pins. The optional crash-remapper install also uses its frozen lockfile on both pins; installation refusal still permits tests to run, without exempting the lockfile from source-restoration guards. Each invocation binds its ordered selection, raw results and terminal observations to that identity; its receipt is finalized only after exact source restoration. Assembly verifies the actual uploaded bytes against that receipt. The historical W113/W150 adapter reconstruction is retired; runtime counterparts are already landed in the candidate. Historical findings above are not fresh qualification results for this source. Consumers must jointly rebuild Bun with the exact engine headers and libraries. @@ -74,3 +74,5 @@ The current 21-lane qualification can assemble the retained build artifacts with The ordinary VM-cache Debug qualification builds its matching non-AOT engine through the frozen Bun local-build owner, with the AOT macro disabled for both engine and consumer. It verifies the real two-case cache-eviction test, Debug/ASAN/assertion compile flags, source receipts and runtime identities rather than substituting an AOT archive. The frozen Bun candidate is admitted from a checksum-bound Git bundle for native qualification before its source branch is published. The snapshot preserves its exact commit, tree, signed history and three public prerequisite boundaries. Linux and Darwin use the same acquisition owner; this does not publish a Bun runtime or promote a consumer pin. Remove the snapshot transport after the qualified commit is available from the Bun fork. + +The Bun qualification snapshot advances through the signed sync repairs to c6a7bf9d. The former882 snapshot had two source-proven native AOT call/signature mismatches; the repaired candidate preserves both mandatory arguments. Qualification still requires fresh native builds and the unchanged runtime gates; source transport or prior candidate receipts do not qualify it. diff --git a/.github/openclaw/variants.json b/.github/openclaw/variants.json index 2a31848cee8b7..9ea98fcfee632 100644 --- a/.github/openclaw/variants.json +++ b/.github/openclaw/variants.json @@ -99,8 +99,8 @@ "manifest_sha256": "df16ba1dcaad70daa014fbc70c7005842fb2bf5099a1df00a83e1075ceef7462" }, "candidate": { - "commit": "882b3ce222db5f51adde7dce65bf6262aeb7335f", - "tree": "20d3242be73f09e989b136c4584191fc7a8a7e82", + "commit": "c6a7bf9d8dc4d44db9f826e47a5ae7645ea6e8c9", + "tree": "ef814c1b5ef7731d6373cfacb8c88b0227a670aa", "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218" } } From 5e7f7f530fa77e832238fb2f93ac4dc6e48d926b Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 19:50:04 +0800 Subject: [PATCH 33/35] fix(ci): qualify the Node hook builtin regression repair --- .github/openclaw/qualification/harness-adapters.json | 2 +- .github/openclaw/variants.json | 4 ++-- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index ee1810e008aef..3e2daaacad25c 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -51,7 +51,7 @@ } }, "candidate": { - "pin": "44624126009dc8303bf382a5a8a273b6abebcba1", + "pin": "28b6101e24b93b4a222b03fc5a6a83cd4d1c2653", "build": { "patch": null, "sha256": null, diff --git a/.github/openclaw/variants.json b/.github/openclaw/variants.json index 6dbe193ad5779..ec1247b5ea1dc 100644 --- a/.github/openclaw/variants.json +++ b/.github/openclaw/variants.json @@ -99,8 +99,8 @@ "manifest_sha256": "df16ba1dcaad70daa014fbc70c7005842fb2bf5099a1df00a83e1075ceef7462" }, "candidate": { - "commit": "44624126009dc8303bf382a5a8a273b6abebcba1", - "tree": "84e156edf55357e5bb7e06e5ac81cdec6925e533", + "commit": "28b6101e24b93b4a222b03fc5a6a83cd4d1c2653", + "tree": "49f313d246312149a63874f5b8a5c5b01b987b2b", "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218" } } From b8010088f8ff5b6f183f807f57e035d0819c5b06 Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 21:51:30 +0800 Subject: [PATCH 34/35] fix(ci): qualify sealed namespaces on Linux and Darwin --- .github/openclaw/qualification/darwin-selected.json | 1 + .github/openclaw/qualification/darwin.py | 2 +- .github/openclaw/qualification/harness-adapters.json | 2 +- .github/openclaw/qualify-darwin.sh | 2 +- .github/openclaw/release-notes.md | 2 +- .github/openclaw/variants.json | 4 ++-- 6 files changed, 7 insertions(+), 6 deletions(-) mode change 100755 => 100644 .github/openclaw/qualify-darwin.sh diff --git a/.github/openclaw/qualification/darwin-selected.json b/.github/openclaw/qualification/darwin-selected.json index b4e12163433d3..b2b112c168ffb 100644 --- a/.github/openclaw/qualification/darwin-selected.json +++ b/.github/openclaw/qualification/darwin-selected.json @@ -12,6 +12,7 @@ "test/js/bun/jsc/webkit-upgrade-df289ce551.test.ts", "test/js/bun/plugin/plugin-resolved-key.test.ts", "test/js/bun/plugin/plugins.test.ts", + "test/js/bun/resolve/esModule.test.ts", "test/js/bun/sqlite/column-types.test.js", "test/js/bun/sqlite/sqlite.test.js", "test/js/node/async_hooks/AsyncLocalStorage.test.ts", diff --git a/.github/openclaw/qualification/darwin.py b/.github/openclaw/qualification/darwin.py index 99d4959ffeb31..f5a26abc021a8 100644 --- a/.github/openclaw/qualification/darwin.py +++ b/.github/openclaw/qualification/darwin.py @@ -17,7 +17,7 @@ def evidence(proof, binaries, source, engine): consumer = json.loads((proof / 'candidate-identity.json').read_text()) identity.validate_evidence(consumer, source, engine, binaries, proof, lane=LANE) selected = compare_fork_ci.selection(compare_fork_ci.read_json(identity.INPUTS / 'darwin-selected.json')) - identity.require(len(selected) == 52, 'Darwin trusted selection drift') + identity.require(len(selected) == 53, 'Darwin trusted selection drift') observed = compare_fork_ci.validate_arm(proof / 'candidate', selected, lane=LANE) identity.require(observed['all_passed'], 'native Darwin selected tests failed') return {'passed': True, 'source': source, 'lane': LANE, diff --git a/.github/openclaw/qualification/harness-adapters.json b/.github/openclaw/qualification/harness-adapters.json index 3e2daaacad25c..9f30290e5ddc1 100644 --- a/.github/openclaw/qualification/harness-adapters.json +++ b/.github/openclaw/qualification/harness-adapters.json @@ -51,7 +51,7 @@ } }, "candidate": { - "pin": "28b6101e24b93b4a222b03fc5a6a83cd4d1c2653", + "pin": "30f563c446f5c0ebb2d71d16ac985c22c037b53b", "build": { "patch": null, "sha256": null, diff --git a/.github/openclaw/qualify-darwin.sh b/.github/openclaw/qualify-darwin.sh old mode 100755 new mode 100644 index a6ca756ff83d7..3fc108d75cbec --- a/.github/openclaw/qualify-darwin.sh +++ b/.github/openclaw/qualify-darwin.sh @@ -46,7 +46,7 @@ mkdir -p "$results/home" "$results/tmp" "$results/bin" "$QUALIFICATION_DIR/sync" chmod 700 "$results/home" "$results/tmp" ln -s "$repo/build/qualify-candidate/bun" "$results/bin/bun" # Recompute with the pinned selection owner; reject drift from the reviewed ordered list. -"$bootstrap" --eval 'import {selectTests} from "./scripts/openclaw-ci/tests.ts";const tracked=Bun.spawnSync(["git","ls-files","-z"]);if(tracked.exitCode!==0)throw new Error("tracked source inventory failed");console.log(JSON.stringify(selectTests(["scripts/build/deps/webkit.ts"],tracked.stdout.toString().split("\0").filter(Boolean),true,"darwin"),null,2));' > build/openclaw-ci/selected.json +"$bootstrap" --eval 'import {selectTests} from "./scripts/openclaw-ci/tests.ts";const tracked=Bun.spawnSync(["git","ls-files","-z"]);if(tracked.exitCode!==0)throw new Error("tracked source inventory failed");console.log(JSON.stringify(selectTests(["scripts/build/deps/webkit.ts", "test/js/bun/resolve/esModule.test.ts"],tracked.stdout.toString().split("\0").filter(Boolean),true,"darwin"),null,2));' > build/openclaw-ci/selected.json cmp "$inputs/darwin-selected.json" build/openclaw-ci/selected.json cp build/openclaw-ci/selected.json "$results/selected.json" python3 "$inputs/harness_adapters.py" test --name candidate --lane "$lane" --root "$QUALIFICATION_DIR" \ diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index 646290f8b62f3..ce8fb4c0876eb 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -2,7 +2,7 @@ Linux qualification binds Node 26.3.0 for the historical baseline and Node 26.12 The current Bun candidate preserves bare-plugin resolution guards, lstat ENOTDIR errors, Darwin hard-link path spelling and Node-compatible trailing-path resolution. Compiled CommonJS forwarding preserves the namespace default, and native-module mocks keep their raw factory exports. Candidate builds use public signed Git history without a source compatibility adapter. Fresh paired native and downstream qualification is required; historical receipts do not qualify this candidate. -Native Darwin ARM64 qualification builds the frozen Bun candidate against the same-run macOS AOT archive, completes the reviewed 52-file selection, and runs all four AOT platform cases before assembly. Linux historical comparison and native Windows ARM64 engine gates remain required. +Native Darwin ARM64 qualification builds the frozen Bun candidate against the same-run macOS AOT archive, completes the reviewed 53-file selection, and runs all four AOT platform cases before assembly. Linux historical comparison and native Windows ARM64 engine gates remain required. The AOT builtin-table collector now recognizes native data properties declared with `CustomValue`. Getter and setter symbols remain available to code generation; Bun's `process.ppid` and `process.title` keep their existing data descriptors. Unknown table attributes still fail validation. diff --git a/.github/openclaw/variants.json b/.github/openclaw/variants.json index ec1247b5ea1dc..0e192341d3d55 100644 --- a/.github/openclaw/variants.json +++ b/.github/openclaw/variants.json @@ -99,8 +99,8 @@ "manifest_sha256": "df16ba1dcaad70daa014fbc70c7005842fb2bf5099a1df00a83e1075ceef7462" }, "candidate": { - "commit": "28b6101e24b93b4a222b03fc5a6a83cd4d1c2653", - "tree": "49f313d246312149a63874f5b8a5c5b01b987b2b", + "commit": "30f563c446f5c0ebb2d71d16ac985c22c037b53b", + "tree": "5148dde801b8774f4b0fe610f310c89d708c75dd", "manifest_blob": "e9544c96d5cd9a5e5f6b0245ed5c8dd78fb1a218" } } From b44e2282734b39f558b04fd8aeb4da358b98668a Mon Sep 17 00:00:00 2001 From: Vincent Koc <25068+vincentkoc@users.noreply.github.com> Date: Mon, 2 Nov 2026 23:13:41 +0800 Subject: [PATCH 35/35] fix(ci): qualify the pinned transpiler cache versions --- .github/openclaw/qualification/stack/check-runtime-cache.py | 6 ++++-- .github/openclaw/qualify-sync.sh | 2 +- .github/openclaw/release-notes.md | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) diff --git a/.github/openclaw/qualification/stack/check-runtime-cache.py b/.github/openclaw/qualification/stack/check-runtime-cache.py index b5ff564dfab73..6eafe24b77b57 100644 --- a/.github/openclaw/qualification/stack/check-runtime-cache.py +++ b/.github/openclaw/qualification/stack/check-runtime-cache.py @@ -13,7 +13,9 @@ p.add_argument('--fixture', required=True, type=Path) p.add_argument('--output', required=True, type=Path) p.add_argument('--expected-version', required=True, type=int) +p.add_argument('--expected-baseline-version', required=True, type=int) a = p.parse_args() +assert a.expected_baseline_version != a.expected_version, 'cache migration requires distinct versions' a.output.mkdir(parents=True, exist_ok=False) source_marker = 'W152_CACHE_SOURCE' replay_marker = 'W152_CACHE_REPLAY' @@ -70,8 +72,8 @@ def mark_cached_output(): assert result.stderr.strip() == expected_marker, ('cache output was not replayed', repeat, result.stderr) rows = json.loads(result.stdout) files = snapshot() - if arm == 'candidate': - assert all(f['version'] == a.expected_version for f in files), files + expected_version = a.expected_baseline_version if arm == 'baseline' else a.expected_version + assert all(f['version'] == expected_version for f in files), files if marked_entry: assert files == before_warm, 'warm run replaced the marked cache instead of loading it' receipt = {'arm': arm, 'repeat': repeat, diff --git a/.github/openclaw/qualify-sync.sh b/.github/openclaw/qualify-sync.sh index ee9f523b2aaf4..666914bb6ff85 100644 --- a/.github/openclaw/qualify-sync.sh +++ b/.github/openclaw/qualify-sync.sh @@ -68,7 +68,7 @@ python3 "$inputs/compile_cache.py" /tmp "$junit_prefix" "$results/module-junit.x "$candidate" test test/aot/every-platform.test.ts > "$results/aot-every-platform.log" 2>&1 "$candidate" test --expose-internals test/js/node/v8/capture-stack-trace.test.js test/js/node/util/util.test.js test/js/bun/sourcemap > "$results/stack-positions.log" 2>&1 "$candidate" test test/bundler/bundler_minify.test.ts > "$results/stack-minifier.log" 2>&1 -python3 "$inputs/stack/check-runtime-cache.py" --baseline "$QUALIFICATION_DIR/bun-baseline/build/qualify-baseline/bun" --candidate "$candidate" --fixture "$inputs/stack/observe-regressions.js" --output "$results/runtime-cache" --expected-version 45 > "$results/stack-cache.json" +python3 "$inputs/stack/check-runtime-cache.py" --baseline "$QUALIFICATION_DIR/bun-baseline/build/qualify-baseline/bun" --candidate "$candidate" --fixture "$inputs/stack/observe-regressions.js" --output "$results/runtime-cache" --expected-baseline-version 36 --expected-version 52 > "$results/stack-cache.json" "$candidate" "$inputs/segmenter.js" > "$results/segmenter.log" 2>&1 "$candidate" test --expose-internals test/js/node/vm/vm.test.ts -t 'a Proxy in the prototype chain' > "$results/proxy.log" 2>&1 "$candidate" test test/js/node/worker_threads/openclaw-resource-limits.test.ts -t resourceLimits > "$results/resource-limits.log" 2>&1 diff --git a/.github/openclaw/release-notes.md b/.github/openclaw/release-notes.md index ce8fb4c0876eb..a0259f45bdec4 100644 --- a/.github/openclaw/release-notes.md +++ b/.github/openclaw/release-notes.md @@ -53,7 +53,7 @@ Source-provenance jobs now check out complete Git history so ancestry validation Qualification requires all 21 artifact builds and the existing native Linux, Linux ARM64 and Windows ARM64 gates. The active Linux consumer now pins Bun `44624126009dc8303bf382a5a8a273b6abebcba1`, builds Release with AOT enabled and LTO disabled, and consumes `bun-webkit-linux-amd64-aot` from the same qualification source. Its native build has no source compatibility adapter. The current test-only adapter is measured separately; historical build/test patches and receipts remain unchanged and replay through their frozen qualification revision. Four unchanged `test/aot/every-platform.test.ts` cases must compile and execute images through the same measured binary, without failures, skips or todos. Sync and assembly revalidate the pinned test bytes, binary identity and archived log digest. These gate changes carry no new native qualification result; every engine archive must be rebuilt from the final qualification commit. The Linux Bun comparison now builds only the historical `b83b544ef744b6ab0dc1feadb59652261d64291d`/`1600131e46b5af48bbda3559af8d8a3327230b6e` baseline with recorded patches 000/012, and the exact current candidate with the measured engine manifest. The former `7b573c05d0c52dffc67d4d25daf108bed5930cf2` qualification used a measured source compatibility patch for the upstream BuiltinCode and heap-only BigInt APIs; that historical adapter is retained unchanged. The build receipt binds every original/adapted file digest and the exact compiled-input set, then requires restoration of the frozen checkout before runtime qualification. Baseline and test harness adapters remain excluded from compiled inputs. Existing node:sqlite BigInt read/write, result-metadata and range tests plus the custom-framework Bake production prerender case exercise the changed embedding APIs on the same measured binary. Existing lazy process builtins, even/odd matcher cases and 18 primitive/container serialization cases cover the removed private BigInt32 paths without changing the serialized sign, length or digit encoding. The ordinary embedding retains every feature through the engine removable-feature hooks; an unchanged Collator sensitivity case and a native URL getter smoke must complete without skips. Standalone native probes use the engine-owned untrimmed hook implementation. It preserves the original ordered 44-file/46-result selection and grouped scheduling under the explicit `candidate-pass-baseline-observed-v1` policy, and runs the 85-path historical/current selection union. Every selected candidate file must pass; ordinary baseline failures and unreported file suites remain visible. This measures a Bun-plus-engine upgrade, not an engine-only change. -Compatibility startup and three unchanged memory-release tests, feature regressions, inspector checks and runtime-cache replay at format 45 all reuse the same candidate binary. Eleven current Bun WebKit-upgrade cases must pass without skips. Native ARM64 also runs the parser-arena and both heap-teardown API regressions with three exact completed JUnit identities. Its existing build also links testaot and executes the two compiled namespace cases and eight compiled module-program cases beside the matching jsc. Both selections use the supported single-process native mode under one 600-second supervisor, retain nested image-process supervision, and require every ordered case name and the exact zero-failure summaries. This ARM64 proof covers engine image execution; the separate four-case Linux Bun gate covers its pinned AOT compiler. Neither is ALS/facade integration qualification. Immutable build-tool receipts bind the historical baseline logger adapter and actual build commands to the binaries. The current candidate uses its native build logger without a patch; identical source, compiled-input inventory and executable guards still apply. The consumer identity binds those receipts, source/index, sole tracked manifest overlay, engine archive, binary bytes, measured runtime and separately copied worker fixture. Fixed post-build adapters provide the same reporter, retry accounting, safe logging and process-termination evidence to both frozen Bun pins. The optional crash-remapper install also uses its frozen lockfile on both pins; installation refusal still permits tests to run, without exempting the lockfile from source-restoration guards. Each invocation binds its ordered selection, raw results and terminal observations to that identity; its receipt is finalized only after exact source restoration. Assembly verifies the actual uploaded bytes against that receipt. The historical W113/W150 adapter reconstruction is retired; runtime counterparts are already landed in the candidate. Historical findings above are not fresh qualification results for this source. Consumers must jointly rebuild Bun with the exact engine headers and libraries. +Compatibility startup and three unchanged memory-release tests, feature regressions, inspector checks and runtime transpiler-cache replacement from baseline format 36 to candidate format 52 and warm replay all reuse the same candidate binary. Eleven current Bun WebKit-upgrade cases must pass without skips. Native ARM64 also runs the parser-arena and both heap-teardown API regressions with three exact completed JUnit identities. Its existing build also links testaot and executes the two compiled namespace cases and eight compiled module-program cases beside the matching jsc. Both selections use the supported single-process native mode under one 600-second supervisor, retain nested image-process supervision, and require every ordered case name and the exact zero-failure summaries. This ARM64 proof covers engine image execution; the separate four-case Linux Bun gate covers its pinned AOT compiler. Neither is ALS/facade integration qualification. Immutable build-tool receipts bind the historical baseline logger adapter and actual build commands to the binaries. The current candidate uses its native build logger without a patch; identical source, compiled-input inventory and executable guards still apply. The consumer identity binds those receipts, source/index, sole tracked manifest overlay, engine archive, binary bytes, measured runtime and separately copied worker fixture. Fixed post-build adapters provide the same reporter, retry accounting, safe logging and process-termination evidence to both frozen Bun pins. The optional crash-remapper install also uses its frozen lockfile on both pins; installation refusal still permits tests to run, without exempting the lockfile from source-restoration guards. Each invocation binds its ordered selection, raw results and terminal observations to that identity; its receipt is finalized only after exact source restoration. Assembly verifies the actual uploaded bytes against that receipt. The historical W113/W150 adapter reconstruction is retired; runtime counterparts are already landed in the candidate. Historical findings above are not fresh qualification results for this source. Consumers must jointly rebuild Bun with the exact engine headers and libraries. The existing x64 Linux consumer uses Release with AOT enabled and LTO disabled. Its 85-file run requires exactly one passing native JUnit result for each of the eight original compile-cache exit modes and deferred idle loading. Assembly revalidates those case identities and the archived XML digest. This is not final ThinLTO shipping qualification. ARM64 JSC proof is separate: the ARM64 Debug/ASAN natural-exit and deferred-idle controls exceeded their existing deadlines and remain unresolved until matched-profile evidence is available.