From f77345491be47377bfe0c48dbcb31dfbf932c8c7 Mon Sep 17 00:00:00 2001 From: Rebecca Sliter <571084+rsliter@users.noreply.github.com> Date: Tue, 29 Sep 2026 19:15:53 -0700 Subject: [PATCH 1/3] fix(deps): remediate Undici advisories Signed-off-by: Rebecca Sliter <571084+rsliter@users.noreply.github.com> --- Dockerfile | 12 +- Dockerfile.base | 2 +- .../package-lock.json | 22 + .../package.json | 2 + .../openclaw-runtime/package-lock.json | 6 +- agents/openclaw/openclaw-runtime/package.json | 3 +- ci/reviewed-npm-audit.json | 2 +- package-lock.json | 8 +- package.json | 2 +- scripts/lib/openclaw-npm-remediation.mts | 327 +++- .../applier/build/messaging-build-applier.mts | 37 +- ...openclaw-2026-9-undici-remediation.test.ts | 189 +++ .../openclaw/openclaw-locked-install.test.ts | 4 +- ...nclaw-2026.9.1-package-lock.json.gz.base64 | 1473 +++++++++-------- .../managed-image-registry-transport.test.ts | 4 +- ...messaging-build-applier-googlechat.test.ts | 1 + .../messaging-build-applier-integrity.test.ts | 1 + .../messaging/messaging-build-applier.test.ts | 16 +- 18 files changed, 1354 insertions(+), 757 deletions(-) create mode 100644 test/agents/openclaw/openclaw-2026-9-undici-remediation.test.ts diff --git a/Dockerfile b/Dockerfile index 6a8de04e243..c5c51f032d6 100644 --- a/Dockerfile +++ b/Dockerfile @@ -65,9 +65,7 @@ COPY tools/mcp-tool-discovery-runtime/reviewed-runtime-bundle/mcp-tool-discovery FROM scratch AS managed-startup-runtime-builder COPY tools/mcp-tool-discovery-runtime/reviewed-runtime-bundle/managed-startup-direct-image-runtime.bundle /out/managed-startup-image-runtime.cjs -# Fetch immutable reviewed archives outside RUN instructions. The protected -# GPU rebuild imports these checksum-addressed source records from the -# amd64 build cache, while every package-materialization RUN remains offline. +# Keep package materialization offline. FROM scratch AS wechat-npm-archives ADD --checksum=sha256:467e8047f7114e45944961fcd3eda9421843c9c65db61ea24176e252ab800ee4 https://registry.npmjs.org/@tencent-weixin/openclaw-weixin/-/openclaw-weixin-2.4.9.tgz /openclaw-weixin-2.4.9.tgz @@ -522,7 +520,9 @@ ADD --chmod=0444 --checksum=sha256:f3fb42099ea7a0efa2753b3e770fa0d505714e1c7d75f FROM scratch AS openclaw-managed-messaging-npm-common-archives-5 ADD --chmod=0444 --checksum=sha256:65834dc9ce7ecceff4334a14796c85960cbf665d09364698bf3196ceed04d677 https://registry.npmjs.org/uint8array-extras/-/uint8array-extras-1.5.0.tgz /uint8array-extras-1.5.0.tgz +ADD --chmod=0444 --checksum=sha256:93b3abe22a9d2858938b5f3829a9fd8952392348ffed9057662ae846e2e46d54 https://registry.npmjs.org/undici/-/undici-7.29.1.tgz /undici-7.29.1.tgz ADD --chmod=0444 --checksum=sha256:9d72c56c17ad2b3d66f006d53945374cc0d2bc68f322439495b972269f4de6bc https://registry.npmjs.org/undici/-/undici-8.10.0.tgz /undici-8.10.0.tgz +ADD --chmod=0444 --checksum=sha256:740638ae32d78d2646a6727950e365fa26b6fa87913fa096e60ed4afeb4634aa https://registry.npmjs.org/undici/-/undici-8.10.2.tgz /undici-8.10.2.tgz ADD --chmod=0444 --checksum=sha256:07a721cb2cd0dd798c24757de34d14e8b640ff8fddef85d662e00b392562a1f2 https://registry.npmjs.org/undici-types/-/undici-types-8.3.0.tgz /undici-types-8.3.0.tgz ADD --chmod=0444 --checksum=sha256:e4bfbbe867144ff24f73198367479378c8b6cffc798a2ec0756a81097606908e https://registry.npmjs.org/unicorn-magic/-/unicorn-magic-0.3.0.tgz /unicorn-magic-0.3.0.tgz ADD --chmod=0444 --checksum=sha256:2dfb5e06d1d4bf1fe9f0fa7f633c4a2fde04d8b41cf0b9bd249a42561d5edfb6 https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz /unpipe-1.0.0.tgz @@ -881,9 +881,7 @@ RUN test -f /usr/local/bin/node \ && test -z "$node_unsafe" \ && json5_unsafe="$(find -L /opt/nemoclaw/node_modules/json5 \( ! -user root -o -perm /022 \) -print -quit)" \ && test -z "$json5_unsafe" -# Reviewed-archive invariants (#5896): the dedicated build stage materializes -# the committed lock, seeds resolver metadata, and re-packs every archive offline -# before this root-owned immutable cache enters the final image. +# Build the immutable archive cache offline (#5896). COPY --from=wechat-npm-cache /out/wechat-npm-cache/ /usr/local/share/nemoclaw/wechat-npm-cache/ COPY --from=openclaw-patch-payload / / @@ -943,7 +941,7 @@ RUN --mount=type=secret,id=nemoclaw-mcporter-audit-receipt,required=false \ OPENCLAW_LOCK_SHA256=none-legacy-fixture; \ OPENCLAW_RECIPE='ignore-scripts+reviewed-lifecycle-v1'; \ if [ "$OPENCLAW_VERSION" = "2026.9.1" ]; then \ - OPENCLAW_LOCK_SHA256=c015570ccccf56986c3d92a85de6f7aa507110f6a11cc2eedd80752672589f9b; \ + OPENCLAW_LOCK_SHA256=71f87f397d8f628c40daefb0cc80d7b35a3be0353884f8275824a46568dc3113; \ ACTUAL_OPENCLAW_LOCK_SHA256="$(sha256sum /usr/local/lib/nemoclaw/openclaw-runtime/package-lock.json | awk '{print $1}')"; \ [ "$ACTUAL_OPENCLAW_LOCK_SHA256" = "$OPENCLAW_LOCK_SHA256" ] \ || { echo "ERROR: OpenClaw lock SHA-256 mismatch (expected $OPENCLAW_LOCK_SHA256, found $ACTUAL_OPENCLAW_LOCK_SHA256)" >&2; exit 1; }; \ diff --git a/Dockerfile.base b/Dockerfile.base index edd2f4aeea4..17c143c6fb1 100644 --- a/Dockerfile.base +++ b/Dockerfile.base @@ -515,7 +515,7 @@ RUN --mount=type=bind,source=nemoclaw-blueprint/blueprint.yaml,target=/tmp/bluep OPENCLAW_LOCK_SHA256=none-legacy-fixture; \ OPENCLAW_RECIPE='ignore-scripts+reviewed-lifecycle-v1'; \ if [ "$OPENCLAW_VERSION" = "2026.9.1" ]; then \ - OPENCLAW_LOCK_SHA256=c015570ccccf56986c3d92a85de6f7aa507110f6a11cc2eedd80752672589f9b; \ + OPENCLAW_LOCK_SHA256=71f87f397d8f628c40daefb0cc80d7b35a3be0353884f8275824a46568dc3113; \ ACTUAL_OPENCLAW_LOCK_SHA256="$(sha256sum /usr/local/lib/nemoclaw/openclaw-runtime/package-lock.json | awk '{print $1}')"; \ [ "$ACTUAL_OPENCLAW_LOCK_SHA256" = "$OPENCLAW_LOCK_SHA256" ] \ || { echo "Error: OpenClaw lock SHA-256 mismatch (expected $OPENCLAW_LOCK_SHA256, found $ACTUAL_OPENCLAW_LOCK_SHA256)"; exit 1; }; \ diff --git a/agents/openclaw/managed-image-messaging-runtime/package-lock.json b/agents/openclaw/managed-image-messaging-runtime/package-lock.json index c5f33757146..d983e27bc60 100644 --- a/agents/openclaw/managed-image-messaging-runtime/package-lock.json +++ b/agents/openclaw/managed-image-messaging-runtime/package-lock.json @@ -24,6 +24,8 @@ "nemoclaw-openclaw-override-ip-address": "npm:ip-address@10.5.0", "nemoclaw-openclaw-override-protobufjs": "npm:protobufjs@8.7.2", "nemoclaw-openclaw-override-qs": "npm:qs@6.15.3", + "nemoclaw-openclaw-override-undici-7": "npm:undici@7.29.1", + "nemoclaw-openclaw-override-undici-8": "npm:undici@8.10.2", "nemoclaw-openclaw-override-uuid": "npm:uuid@14.0.2", "openclaw": "2026.9.1", "undici": "8.10.0" @@ -7435,6 +7437,26 @@ "url": "https://github.com/sponsors/ljharb" } }, + "node_modules/nemoclaw-openclaw-override-undici-7": { + "name": "undici", + "version": "7.29.1", + "resolved": "https://registry.npmjs.org/undici/-/undici-7.29.1.tgz", + "integrity": "sha512-RYONW2MeafgYlkVOKYKkA/Ag7BmXqgIWCa8t1m0JcxrQg9pI9lEqRhAOruOBCbAohOa/gkCF+iPi9hrgvTzu6Q==", + "license": "MIT", + "engines": { + "node": ">=20.18.1" + } + }, + "node_modules/nemoclaw-openclaw-override-undici-8": { + "name": "undici", + "version": "8.10.2", + "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.2.tgz", + "integrity": "sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ==", + "license": "MIT", + "engines": { + "node": ">=22.19.0" + } + }, "node_modules/nemoclaw-openclaw-override-uuid": { "name": "uuid", "version": "14.0.2", diff --git a/agents/openclaw/managed-image-messaging-runtime/package.json b/agents/openclaw/managed-image-messaging-runtime/package.json index d6c60274349..4a0c03e8cc1 100644 --- a/agents/openclaw/managed-image-messaging-runtime/package.json +++ b/agents/openclaw/managed-image-messaging-runtime/package.json @@ -21,6 +21,8 @@ "nemoclaw-openclaw-override-ip-address": "npm:ip-address@10.5.0", "nemoclaw-openclaw-override-protobufjs": "npm:protobufjs@8.7.2", "nemoclaw-openclaw-override-qs": "npm:qs@6.15.3", + "nemoclaw-openclaw-override-undici-7": "npm:undici@7.29.1", + "nemoclaw-openclaw-override-undici-8": "npm:undici@8.10.2", "nemoclaw-openclaw-override-uuid": "npm:uuid@14.0.2", "openclaw": "2026.9.1", "undici": "8.10.0" diff --git a/agents/openclaw/openclaw-runtime/package-lock.json b/agents/openclaw/openclaw-runtime/package-lock.json index 8b12e7cc10c..76b3d67330f 100644 --- a/agents/openclaw/openclaw-runtime/package-lock.json +++ b/agents/openclaw/openclaw-runtime/package-lock.json @@ -4462,9 +4462,9 @@ } }, "node_modules/undici": { - "version": "8.10.0", - "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.0.tgz", - "integrity": "sha512-HvltHd7avK13QIw/oLe4qoOLyoVSoafqJ2jYOrtMRBkbYT31eiBQ8O0ehRKZiEZCMEyLFQNIADpgCWC5fALvYQ==", + "version": "8.10.2", + "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.2.tgz", + "integrity": "sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ==", "license": "MIT", "engines": { "node": ">=22.19.0" diff --git a/agents/openclaw/openclaw-runtime/package.json b/agents/openclaw/openclaw-runtime/package.json index 41d71bbfe20..ab61e7a02a2 100644 --- a/agents/openclaw/openclaw-runtime/package.json +++ b/agents/openclaw/openclaw-runtime/package.json @@ -11,7 +11,8 @@ "overrides": { "hono": "4.12.34", "tar": "7.5.21", - "fast-uri": "3.1.7" + "fast-uri": "3.1.7", + "undici": "8.10.2" }, "engines": { "node": ">=22.22.3 <23 || >=24.15.0 <25 || >=25.9.0" diff --git a/ci/reviewed-npm-audit.json b/ci/reviewed-npm-audit.json index b3cf720e3f5..fe86da71421 100644 --- a/ci/reviewed-npm-audit.json +++ b/ci/reviewed-npm-audit.json @@ -101,7 +101,7 @@ "integrity": "sha512-0Ve0631CdgkJDwd4NNG1BawIdF5yCL2sO+Tts8amStw+H6vKURTj0K4rOa4+hFpJk1Dnw5LyKl5twzwX1VtA2w==", "tarballUrl": "https://registry.npmjs.org/openclaw/-/openclaw-2026.9.1.tgz", "directory": "agents/openclaw/openclaw-runtime", - "lockSha256": "c015570ccccf56986c3d92a85de6f7aa507110f6a11cc2eedd80752672589f9b" + "lockSha256": "71f87f397d8f628c40daefb0cc80d7b35a3be0353884f8275824a46568dc3113" }, { "id": "mcporter-runtime", diff --git a/package-lock.json b/package-lock.json index 3d4c9a1bea2..d88e46d474c 100644 --- a/package-lock.json +++ b/package-lock.json @@ -24,7 +24,7 @@ "qrcode-terminal": "^0.12.0", "smol-toml": "1.8.0", "typebox": "1.1.38", - "undici": "8.10.0", + "undici": "8.10.2", "yaml": "2.8.3" }, "bin": { @@ -8515,9 +8515,9 @@ } }, "node_modules/undici": { - "version": "8.10.0", - "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.0.tgz", - "integrity": "sha512-HvltHd7avK13QIw/oLe4qoOLyoVSoafqJ2jYOrtMRBkbYT31eiBQ8O0ehRKZiEZCMEyLFQNIADpgCWC5fALvYQ==", + "version": "8.10.2", + "resolved": "https://registry.npmjs.org/undici/-/undici-8.10.2.tgz", + "integrity": "sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ==", "license": "MIT", "engines": { "node": ">=22.19.0" diff --git a/package.json b/package.json index a4beb97d85a..99fc3f04759 100644 --- a/package.json +++ b/package.json @@ -119,7 +119,7 @@ "qrcode-terminal": "^0.12.0", "smol-toml": "1.8.0", "typebox": "1.1.38", - "undici": "8.10.0", + "undici": "8.10.2", "yaml": "2.8.3" }, "optionalDependencies": { diff --git a/scripts/lib/openclaw-npm-remediation.mts b/scripts/lib/openclaw-npm-remediation.mts index 39d1411f59e..fa4f5bc0492 100755 --- a/scripts/lib/openclaw-npm-remediation.mts +++ b/scripts/lib/openclaw-npm-remediation.mts @@ -10,11 +10,13 @@ import { cpSync, existsSync, fstatSync, + lstatSync, mkdirSync, mkdtempSync, openSync, readdirSync, readFileSync, + realpathSync, rmSync, writeFileSync, } from "node:fs"; @@ -27,8 +29,16 @@ type JsonObject = Record; type Remediation = Readonly<{ expectedPatchedMetadataIntegrity?: string; expectedPatchedTreeIntegrity?: string; - kind: "axios" | "core" | "current-core" | "jaeger" | "legacy-core" | "undici"; - version: "2026.3.11" | "2026.6.10" | "2026.7.1"; + kind: + | "axios" + | "core" + | "current-bundled-undici" + | "current-core" + | "current-root-undici" + | "jaeger" + | "legacy-core" + | "undici"; + version: "2026.3.11" | "2026.6.10" | "2026.7.1" | "2026.9.1"; }>; type RemediationRequest = Readonly<{ @@ -107,6 +117,14 @@ const CURRENT_UNDICI_VERSION = "8.10.0"; const CURRENT_UNDICI_INTEGRITY = "sha512-HvltHd7avK13QIw/oLe4qoOLyoVSoafqJ2jYOrtMRBkbYT31eiBQ8O0ehRKZiEZCMEyLFQNIADpgCWC5fALvYQ=="; const CURRENT_UNDICI_TARBALL = "https://registry.npmjs.org/undici/-/undici-8.10.0.tgz"; +const PATCHED_UNDICI_8_VERSION = "8.10.2"; +const PATCHED_UNDICI_8_INTEGRITY = + "sha512-/y4/bH9YNU5hi9NIrpOuvGXFcxrj3CMrV+/AYpowAYTpHn8gX/XPFjNy766FPoYY0miQhdW977JFWKGNhBdwyQ=="; +const PATCHED_UNDICI_8_TARBALL = "https://registry.npmjs.org/undici/-/undici-8.10.2.tgz"; +const PATCHED_UNDICI_7_VERSION = "7.29.1"; +const PATCHED_UNDICI_7_INTEGRITY = + "sha512-RYONW2MeafgYlkVOKYKkA/Ag7BmXqgIWCa8t1m0JcxrQg9pI9lEqRhAOruOBCbAohOa/gkCF+iPi9hrgvTzu6Q=="; +const PATCHED_UNDICI_7_TARBALL = "https://registry.npmjs.org/undici/-/undici-7.29.1.tgz"; const CURRENT_IP_ADDRESS_VERSION = "10.3.1"; const CURRENT_IP_ADDRESS_INTEGRITY = "sha512-1e9d3kb97NHJTIJDZW9rKqW2h6+dFa50Dy0fpPSMQp2ADje5gvKsXmdiK6dwY5t76TaTt5+P5N1Y/LoToIxP6g=="; @@ -157,6 +175,12 @@ const REMEDIATIONS: Readonly> = Object.freeze({ kind: "undici", version: "2026.7.1", }, + "@openclaw/discord@2026.9.1": { + expectedPatchedTreeIntegrity: + "sha512-UFBks0k94yKmtnD/D6I908I5vQwlUSohBFdjLdHFhf3cS0SeBpTDMoflBixsj6C3I/QWg6xhBPWJD1o4riDtsQ==", + kind: "current-bundled-undici", + version: "2026.9.1", + }, "@openclaw/msteams@2026.7.1": { expectedPatchedTreeIntegrity: "sha512-qk1PXcRU5r/7zWIJlwHGTBmKIuLoBYHhv6hA1w+mYs0H9JX0nBk6WccahcmiWVzu2SsryCQ4Sck6j4Fbu6kcHg==", @@ -169,6 +193,12 @@ const REMEDIATIONS: Readonly> = Object.freeze({ kind: "axios", version: "2026.7.1", }, + "@openclaw/slack@2026.9.1": { + expectedPatchedTreeIntegrity: + "sha512-iLZXmYOy8g++8oqMEP95lCYLH0OgD5jm0QiqoEQTMYgMiMPrBRjwpX406n5SKIqTYW8bnTGDlTVoTEjMO/dJYQ==", + kind: "current-bundled-undici", + version: "2026.9.1", + }, "openclaw@2026.6.10": { expectedPatchedMetadataIntegrity: "sha512-XMycUUV7gCzUYbjgwrglER0AQEtfuKUz6wyo4ilm/7nSSkLocYUYVkrJuBFYPW3no8Y5FW/1+2hWCssIyjxn3g==", @@ -186,6 +216,12 @@ const REMEDIATIONS: Readonly> = Object.freeze({ kind: "current-core", version: "2026.7.1", }, + "openclaw@2026.9.1": { + expectedPatchedTreeIntegrity: + "sha512-XLwwECWs8nL8/WJ/PplTcL0GyG6VGt0nN8K9idVv3/lKZiMAsJM1aw7SKj68b9Co9UD2iEhWfQKaGC6Pgoeniw==", + kind: "current-root-undici", + version: "2026.9.1", + }, "openclaw@2026.3.11": { kind: "legacy-core", expectedPatchedMetadataIntegrity: @@ -429,6 +465,145 @@ function requireCurrentUndiciReplacement(packageJson: JsonObject, label: string) } } +type BundledUndiciReplacement = Readonly<{ + currentVersion: string; + engine: string; + integrity: string; + tarball: string; + version: string; +}>; + +function bundledUndiciReplacement(packageSpec: string): BundledUndiciReplacement { + if (packageSpec === "@openclaw/discord@2026.9.1") { + return { + currentVersion: "8.10.0", + engine: ">=22.19.0", + integrity: PATCHED_UNDICI_8_INTEGRITY, + tarball: PATCHED_UNDICI_8_TARBALL, + version: PATCHED_UNDICI_8_VERSION, + }; + } + if (packageSpec === "@openclaw/slack@2026.9.1") { + return { + currentVersion: "7.29.0", + engine: ">=20.18.1", + integrity: PATCHED_UNDICI_7_INTEGRITY, + tarball: PATCHED_UNDICI_7_TARBALL, + version: PATCHED_UNDICI_7_VERSION, + }; + } + throw new Error(`No bundled Undici remediation is defined for ${packageSpec}`); +} + +function requireBundledUndiciReplacement( + packageJson: JsonObject, + replacement: BundledUndiciReplacement, + label: string, +): void { + requirePackageIdentity(packageJson, "undici", replacement.version, label); + if ( + (packageJson.dependencies !== undefined && + Object.keys(packageJson.dependencies).length !== 0) || + packageJson.engines?.node !== replacement.engine + ) { + throw new Error( + `undici@${replacement.version} package contract changed; review the remediation before updating it`, + ); + } +} + +export function patchOpenClaw2026_9_1RootUndiciGraph(packageDirectory: string): void { + const packageJsonPath = join(packageDirectory, "package.json"); + const packageJson = readJson(packageJsonPath); + requirePackageIdentity(packageJson, "openclaw", "2026.9.1", "OpenClaw package"); + if (packageJson.dependencies?.undici !== CURRENT_UNDICI_VERSION) { + throw new Error("openclaw@2026.9.1 Undici dependency changed after review"); + } + if (existsSync(join(packageDirectory, "npm-shrinkwrap.json"))) { + throw new Error("openclaw@2026.9.1 unexpectedly includes a nested shrinkwrap"); + } + packageJson.dependencies.undici = PATCHED_UNDICI_8_VERSION; + writeJson(packageJsonPath, packageJson); +} + +function expectedCurrentPluginDependencies( + packageSpec: string, + currentUndiciVersion: string, +): JsonObject { + if (packageSpec === "@openclaw/discord@2026.9.1") { + return { + "@discord/embedded-app-sdk": "2.5.0", + "@discordjs/voice": "0.19.2", + "discord-api-types": "0.38.53", + "libopus-wasm": "0.2.0", + "mdast-util-from-markdown": "2.0.3", + typebox: "1.3.17", + undici: currentUndiciVersion, + ws: "8.21.3", + zod: "4.4.3", + }; + } + if (packageSpec === "@openclaw/slack@2026.9.1") { + return { + "@slack/bolt": "5.0.0", + "@slack/socket-mode": "3.0.0", + "@slack/types": "3.0.0", + "@slack/web-api": "8.0.0", + "get-east-asian-width": "1.6.0", + typebox: "1.3.17", + undici: currentUndiciVersion, + ws: "8.21.3", + zod: "4.4.3", + }; + } + throw new Error(`No bundled Undici remediation is defined for ${packageSpec}`); +} + +export function patchOpenClaw2026_9_1BundledUndiciGraph( + packageDirectory: string, + packageSpec: string, +): BundledUndiciReplacement { + const replacement = bundledUndiciReplacement(packageSpec); + const versionAt = packageSpec.lastIndexOf("@"); + const expectedName = packageSpec.slice(0, versionAt); + const expectedVersion = packageSpec.slice(versionAt + 1); + const packageJsonPath = join(packageDirectory, "package.json"); + const packageJson = readJson(packageJsonPath); + requirePackageIdentity(packageJson, expectedName, expectedVersion, "OpenClaw plugin"); + const expectedDependencies = expectedCurrentPluginDependencies( + packageSpec, + replacement.currentVersion, + ); + requireDependencyShape(packageJson, expectedDependencies, packageSpec); + if ( + !Array.isArray(packageJson.bundledDependencies) || + JSON.stringify(packageJson.bundledDependencies) !== + JSON.stringify(Object.keys(expectedDependencies)) || + existsSync(join(packageDirectory, "npm-shrinkwrap.json")) + ) { + throw new Error(`${packageSpec} bundled dependency layout changed after review`); + } + + const bundledUndici = readJson(join(packageDirectory, "node_modules", "undici", "package.json")); + requirePackageIdentity( + bundledUndici, + "undici", + replacement.currentVersion, + `${packageSpec} bundled Undici package`, + ); + if ( + (bundledUndici.dependencies !== undefined && + Object.keys(bundledUndici.dependencies).length !== 0) || + bundledUndici.engines?.node !== replacement.engine + ) { + throw new Error(`${packageSpec} bundled Undici layout changed after review`); + } + + packageJson.dependencies.undici = replacement.version; + writeJson(packageJsonPath, packageJson); + return replacement; +} + function requireCurrentIpAddressReplacement(packageJson: JsonObject): void { requirePackageIdentity( packageJson, @@ -1169,6 +1344,8 @@ export function buildRemediatedOpenClawPluginArchive( join(sourcePackage, "node_modules", "@openclaw", "fs-safe"), ); patchOpenClawCorePackageGraph(sourcePackage); + } else if (remediation.kind === "current-root-undici") { + patchOpenClaw2026_9_1RootUndiciGraph(sourcePackage); } else if (remediation.kind === "current-core") { const braceExpansionArchive = packReplacement( `brace-expansion@${CURRENT_BRACE_EXPANSION_VERSION}`, @@ -1267,6 +1444,28 @@ export function buildRemediatedOpenClawPluginArchive( requireCurrentIpAddressReplacement(readJson(join(ipAddressPackage, "package.json"))); requireCurrentTarReplacement(readJson(join(tarPackage, "package.json"))); patchCurrentOpenClawCorePackageGraph(sourcePackage); + } else if (remediation.kind === "current-bundled-undici") { + const replacement = bundledUndiciReplacement(request.packageSpec); + const undiciArchive = packReplacement( + `undici@${replacement.version}`, + replacement.integrity, + replacement.tarball, + remediationRoot, + env, + ); + const undiciPackage = extractArchive( + undiciArchive.archivePath, + join(remediationRoot, "undici"), + remediationRoot, + env, + ); + requireBundledUndiciReplacement( + readJson(join(undiciPackage, "package.json")), + replacement, + `${request.packageSpec} Undici remediation package`, + ); + patchOpenClaw2026_9_1BundledUndiciGraph(sourcePackage, request.packageSpec); + copyReplacementPackage(undiciPackage, join(sourcePackage, "node_modules", "undici")); } else if (remediation.kind === "undici") { const undiciArchive = packReplacement( `undici@${CURRENT_UNDICI_VERSION}`, @@ -1607,6 +1806,130 @@ export function buildRemediatedOpenClawArchive( return buildRemediatedOpenClawPluginArchive(request); } +function requireRealDirectory(path: string, label: string): string { + const resolvedPath = resolve(path); + const stats = lstatSync(resolvedPath); + if ( + !stats.isDirectory() || + stats.isSymbolicLink() || + realpathSync(resolvedPath) !== resolvedPath + ) { + throw new Error(`${label} must be a real directory without symbolic links`); + } + return resolvedPath; +} + +function requireRegularFile(path: string, label: string): void { + const stats = lstatSync(path); + if (!stats.isFile() || stats.isSymbolicLink()) { + throw new Error(`${label} must be a regular file`); + } +} + +function requireInstalledBundledUndiciTree( + packageDirectory: string, + packageSpec: string, +): { packageDirectory: string; bundledUndiciDirectory: string } { + const realPackageDirectory = requireRealDirectory( + packageDirectory, + `${packageSpec} installed package`, + ); + requireRegularFile( + join(realPackageDirectory, "package.json"), + `${packageSpec} installed package manifest`, + ); + const bundledUndiciDirectory = requireRealDirectory( + join(realPackageDirectory, "node_modules", "undici"), + `${packageSpec} installed bundled Undici package`, + ); + requireRegularFile( + join(bundledUndiciDirectory, "package.json"), + `${packageSpec} installed bundled Undici manifest`, + ); + return { bundledUndiciDirectory, packageDirectory: realPackageDirectory }; +} + +export function replaceInstalledOpenClaw2026_9_1BundledUndici( + packageDirectory: string, + packageSpec: string, + replacementPackageDirectory: string, +): void { + const target = requireInstalledBundledUndiciTree(packageDirectory, packageSpec); + const replacement = bundledUndiciReplacement(packageSpec); + const replacementDirectory = requireRealDirectory( + replacementPackageDirectory, + `${packageSpec} Undici remediation package`, + ); + requireRegularFile( + join(replacementDirectory, "package.json"), + `${packageSpec} Undici remediation package manifest`, + ); + requireBundledUndiciReplacement( + readJson(join(replacementDirectory, "package.json")), + replacement, + `${packageSpec} Undici remediation package`, + ); + patchOpenClaw2026_9_1BundledUndiciGraph(target.packageDirectory, packageSpec); + copyReplacementPackage(replacementDirectory, target.bundledUndiciDirectory); + const updated = requireInstalledBundledUndiciTree(packageDirectory, packageSpec); + requireBundledUndiciReplacement( + readJson(join(updated.bundledUndiciDirectory, "package.json")), + replacement, + `${packageSpec} installed bundled Undici package`, + ); +} + +export function remediateInstalledOpenClawPluginPackage(request: { + packageDirectory: string; + env?: NodeJS.ProcessEnv; + packageSpec: string; + workingDirectory: string; +}): boolean { + const remediation = REMEDIATIONS[request.packageSpec]; + if (remediation?.kind !== "current-bundled-undici") return false; + const env = { + ...process.env, + ...request.env, + NPM_CONFIG_AUDIT: "false", + NPM_CONFIG_FUND: "false", + NPM_CONFIG_IGNORE_SCRIPTS: "true", + NPM_CONFIG_UPDATE_NOTIFIER: "false", + npm_config_ignore_scripts: "true", + }; + const packageDirectory = requireInstalledBundledUndiciTree( + request.packageDirectory, + request.packageSpec, + ).packageDirectory; + + const workingDirectory = resolve(request.workingDirectory); + mkdirSync(workingDirectory, { recursive: true, mode: 0o700 }); + const remediationRoot = mkdtempSync(join(workingDirectory, "openclaw-installed-remediation-")); + try { + const replacement = bundledUndiciReplacement(request.packageSpec); + const undiciArchive = packReplacement( + `undici@${replacement.version}`, + replacement.integrity, + replacement.tarball, + remediationRoot, + env, + ); + const undiciPackage = extractArchive( + undiciArchive.archivePath, + join(remediationRoot, "undici"), + remediationRoot, + env, + ); + replaceInstalledOpenClaw2026_9_1BundledUndici( + packageDirectory, + request.packageSpec, + undiciPackage, + ); + return true; + } finally { + rmSync(remediationRoot, { recursive: true, force: true }); + } +} + export function remediateReviewedOpenClawPluginArchive( request: RemediationRequest, ): RemediatedArchive { diff --git a/src/lib/messaging/applier/build/messaging-build-applier.mts b/src/lib/messaging/applier/build/messaging-build-applier.mts index 8fa59a4a8b6..53bbb673e70 100755 --- a/src/lib/messaging/applier/build/messaging-build-applier.mts +++ b/src/lib/messaging/applier/build/messaging-build-applier.mts @@ -19,7 +19,10 @@ import { import { homedir } from "node:os"; import { dirname, isAbsolute, join, resolve, sep } from "node:path"; import { pathToFileURL } from "node:url"; -import { remediateReviewedOpenClawPluginArchive } from "../../../../../scripts/lib/openclaw-npm-remediation.mts"; +import { + remediateInstalledOpenClawPluginPackage, + remediateReviewedOpenClawPluginArchive, +} from "../../../../../scripts/lib/openclaw-npm-remediation.mts"; import { packReviewedNpmArchive } from "../../../../../scripts/lib/reviewed-npm-archive.mts"; import { BUILT_IN_CHANNEL_MANIFESTS } from "../../channels/built-ins.ts"; import type { ChannelAgentPackageRuntimeLockSpec, ChannelManifest } from "../../manifest/types.ts"; @@ -152,6 +155,11 @@ export const OPENCLAW_MESSAGING_PLUGIN_ARCHIVE_PROVENANCE_POLICY = Object.freeze registryTarballUrl: "must-match-committed-url", } as const); +const OPENCLAW_INSTALLED_PLUGIN_REMEDIATIONS: Readonly> = Object.freeze({ + "@openclaw/discord@2026.9.1": "discord", + "@openclaw/slack@2026.9.1": "slack", +}); + type HermesUvPackageInstall = { readonly spec: string; }; @@ -821,6 +829,33 @@ function installOpenClawPluginPackages(installs: readonly OpenClawPluginInstall[ ); } verifyTrustedOfficialNpmInstall(install, officialPluginId, inspection); + const packageSpec = install.npmPackageSpec; + const remediatedPluginId = packageSpec + ? OPENCLAW_INSTALLED_PLUGIN_REMEDIATIONS[packageSpec] + : undefined; + if (remediatedPluginId && packageSpec) { + if (remediatedPluginId !== officialPluginId) { + throw new OfficialPluginProvenanceError( + officialPluginId, + "did not retain trusted exact registry provenance", + ); + } + const configuredStateDir = sanitizeOptionalString(env.OPENCLAW_STATE_DIR); + const configuredHome = sanitizeOptionalString(env.HOME); + const stateDir = + configuredStateDir || join(resolve(configuredHome || homedir()), ".openclaw"); + if (!isAbsolute(stateDir)) { + throw new MessagingBuildApplierError( + "OPENCLAW_STATE_DIR must be absolute before installed plugin remediation", + ); + } + remediateInstalledOpenClawPluginPackage({ + env: installEnv as NodeJS.ProcessEnv, + packageDirectory: join(stateDir, "extensions", officialPluginId), + packageSpec, + workingDirectory: packed.rootDir, + }); + } } if (install.runtimeLock) { const openClawVersion = sanitizeOptionalString(env.OPENCLAW_VERSION); diff --git a/test/agents/openclaw/openclaw-2026-9-undici-remediation.test.ts b/test/agents/openclaw/openclaw-2026-9-undici-remediation.test.ts new file mode 100644 index 00000000000..46c641ed0ea --- /dev/null +++ b/test/agents/openclaw/openclaw-2026-9-undici-remediation.test.ts @@ -0,0 +1,189 @@ +// SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved. +// SPDX-License-Identifier: Apache-2.0 + +import fs from "node:fs"; +import os from "node:os"; +import path from "node:path"; +import { afterEach, describe, expect, it } from "vitest"; +import { + patchOpenClaw2026_9_1BundledUndiciGraph, + patchOpenClaw2026_9_1RootUndiciGraph, + remediateInstalledOpenClawPluginPackage, + replaceInstalledOpenClaw2026_9_1BundledUndici, +} from "../../../scripts/lib/openclaw-npm-remediation.mts"; + +const roots: string[] = []; + +const pluginFixtureContracts = { + "@openclaw/discord@2026.9.1": { + dependencies: { + "@discord/embedded-app-sdk": "2.5.0", + "@discordjs/voice": "0.19.2", + "discord-api-types": "0.38.53", + "libopus-wasm": "0.2.0", + "mdast-util-from-markdown": "2.0.3", + typebox: "1.3.17", + undici: "8.10.0", + ws: "8.21.3", + zod: "4.4.3", + }, + engine: ">=22.19.0", + initialUndiciVersion: "8.10.0", + }, + "@openclaw/slack@2026.9.1": { + dependencies: { + "@slack/bolt": "5.0.0", + "@slack/socket-mode": "3.0.0", + "@slack/types": "3.0.0", + "@slack/web-api": "8.0.0", + "get-east-asian-width": "1.6.0", + typebox: "1.3.17", + undici: "7.29.0", + ws: "8.21.3", + zod: "4.4.3", + }, + engine: ">=20.18.1", + initialUndiciVersion: "7.29.0", + }, +} as const; + +type PluginSpec = keyof typeof pluginFixtureContracts; + +function temporaryDirectory(prefix: string): string { + const directory = fs.mkdtempSync(path.join(os.tmpdir(), prefix)); + roots.push(directory); + return directory; +} + +function writeJson(file: string, value: unknown): void { + fs.mkdirSync(path.dirname(file), { recursive: true }); + fs.writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`); +} + +function pluginDependencies(packageSpec: PluginSpec): Record { + const contract = pluginFixtureContracts[packageSpec]; + return { ...contract.dependencies, undici: contract.initialUndiciVersion }; +} + +function writePluginFixture(packageSpec: PluginSpec): string { + const directory = temporaryDirectory("nemoclaw-openclaw-undici-remediation-"); + const versionAt = packageSpec.lastIndexOf("@"); + const name = packageSpec.slice(0, versionAt); + const contract = pluginFixtureContracts[packageSpec]; + const dependencies = pluginDependencies(packageSpec); + writeJson(path.join(directory, "package.json"), { + name, + version: "2026.9.1", + dependencies, + bundledDependencies: Object.keys(dependencies), + }); + writeJson(path.join(directory, "node_modules", "undici", "package.json"), { + name: "undici", + version: contract.initialUndiciVersion, + engines: { node: contract.engine }, + }); + return directory; +} + +afterEach(() => { + for (const root of roots.splice(0)) fs.rmSync(root, { recursive: true, force: true }); +}); + +describe("OpenClaw 2026.9.1 Undici remediation", () => { + it("updates the reviewed root OpenClaw dependency exactly once", () => { + const directory = temporaryDirectory("nemoclaw-openclaw-root-undici-remediation-"); + writeJson(path.join(directory, "package.json"), { + name: "openclaw", + version: "2026.9.1", + dependencies: { chalk: "5.6.2", undici: "8.10.0" }, + }); + + patchOpenClaw2026_9_1RootUndiciGraph(directory); + + expect(() => patchOpenClaw2026_9_1RootUndiciGraph(directory)).toThrow( + "Undici dependency changed after review", + ); + }); + + it("rejects root OpenClaw dependency drift", () => { + const directory = temporaryDirectory("nemoclaw-openclaw-root-undici-remediation-"); + writeJson(path.join(directory, "package.json"), { + name: "openclaw", + version: "2026.9.1", + dependencies: { undici: "8.10.1" }, + }); + + expect(() => patchOpenClaw2026_9_1RootUndiciGraph(directory)).toThrow( + "Undici dependency changed after review", + ); + }); + + it.each([ + ["@openclaw/discord@2026.9.1", "8.10.2"], + ["@openclaw/slack@2026.9.1", "7.29.1"], + ] as const)( + "updates the reviewed bundled Undici declaration for %s", + (packageSpec, patchedVersion) => { + const directory = writePluginFixture(packageSpec); + + const replacement = patchOpenClaw2026_9_1BundledUndiciGraph(directory, packageSpec); + + expect(replacement.version).toBe(patchedVersion); + expect(() => patchOpenClaw2026_9_1BundledUndiciGraph(directory, packageSpec)).toThrow( + "dependency graph changed", + ); + }, + ); + + it.each([ + ["@openclaw/discord@2026.9.1", "8.10.2", ">=22.19.0"], + ["@openclaw/slack@2026.9.1", "7.29.1", ">=20.18.1"], + ] as const)( + "replaces the installed bundled Undici tree for %s", + (packageSpec, patchedVersion, engine) => { + const directory = writePluginFixture(packageSpec); + const replacement = temporaryDirectory("nemoclaw-undici-replacement-"); + writeJson(path.join(replacement, "package.json"), { + name: "undici", + version: patchedVersion, + engines: { node: engine }, + }); + fs.writeFileSync(path.join(replacement, "index.js"), "module.exports = {};\n"); + + expect(() => + replaceInstalledOpenClaw2026_9_1BundledUndici(directory, packageSpec, replacement), + ).not.toThrow(); + expect(() => + replaceInstalledOpenClaw2026_9_1BundledUndici(directory, packageSpec, replacement), + ).toThrow("dependency graph changed"); + }, + ); + + it("rejects a changed bundled dependency graph", () => { + const packageSpec = "@openclaw/discord@2026.9.1"; + const directory = writePluginFixture(packageSpec); + const manifestPath = path.join(directory, "package.json"); + const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8")); + manifest.dependencies.undici = "8.10.1"; + writeJson(manifestPath, manifest); + + expect(() => patchOpenClaw2026_9_1BundledUndiciGraph(directory, packageSpec)).toThrow( + "dependency graph changed", + ); + }); + + it("rejects an installed plugin reached through a symbolic link before fetching replacements", () => { + const root = temporaryDirectory("nemoclaw-openclaw-installed-undici-remediation-"); + const packageDirectory = writePluginFixture("@openclaw/discord@2026.9.1"); + const linkedDirectory = path.join(root, "discord"); + fs.symlinkSync(packageDirectory, linkedDirectory); + + expect(() => + remediateInstalledOpenClawPluginPackage({ + packageDirectory: linkedDirectory, + packageSpec: "@openclaw/discord@2026.9.1", + workingDirectory: root, + }), + ).toThrow("must be a real directory without symbolic links"); + }); +}); diff --git a/test/agents/openclaw/openclaw-locked-install.test.ts b/test/agents/openclaw/openclaw-locked-install.test.ts index d2b424c80da..d3e2146bd35 100644 --- a/test/agents/openclaw/openclaw-locked-install.test.ts +++ b/test/agents/openclaw/openclaw-locked-install.test.ts @@ -19,7 +19,7 @@ const PACKAGE_SPEC = "openclaw@2026.9.1"; const INTEGRITY = "sha512-0Ve0631CdgkJDwd4NNG1BawIdF5yCL2sO+Tts8amStw+H6vKURTj0K4rOa4+hFpJk1Dnw5LyKl5twzwX1VtA2w=="; const TARBALL = "https://registry.npmjs.org/openclaw/-/openclaw-2026.9.1.tgz"; -const LOCK_SHA256 = "c015570ccccf56986c3d92a85de6f7aa507110f6a11cc2eedd80752672589f9b"; +const LOCK_SHA256 = "71f87f397d8f628c40daefb0cc80d7b35a3be0353884f8275824a46568dc3113"; const roots: string[] = []; function sha256(file: string): string { @@ -180,7 +180,7 @@ describe("locked OpenClaw production installation (#5896)", () => { expect(verified).toContain("ip-address@10.7.0"); expect(verified).toContain("tar@7.5.21"); expect(verified).not.toContain("tar@7.5.19"); - expect(verified).toContain("undici@8.10.0"); + expect(verified).toContain("undici@8.10.2"); expect(sha256(LOCKFILE)).toBe(LOCK_SHA256); }); diff --git a/test/fixtures/openclaw-2026.9.1-package-lock.json.gz.base64 b/test/fixtures/openclaw-2026.9.1-package-lock.json.gz.base64 index 8960802d741..f59d734dc10 100644 --- a/test/fixtures/openclaw-2026.9.1-package-lock.json.gz.base64 +++ b/test/fixtures/openclaw-2026.9.1-package-lock.json.gz.base64 @@ -1,731 +1,742 @@ -H4sIAAAAAAAC/9y9aZOjSPMn+H4+RdvzcjQqbgRj+98dLoHQiQRIYm1mjfu+b2ZmP/tKyjsrM0up -zKrufayrUxCAB/jPwyPCw93jf/6nv/76V6LH9r/+6+nXjlMz0ttxmtnJ5aCok8o/Xfwv59sauyj9 -NDnfCf44/XdXGqVm6PiRrT5eRS7lhZ3XfmGXp4KqqO1LWaaboe5eyv7n6fxU8nh09Wtcbn3zVS5X -It+0k/JChzpV59lj+Pllyz7RtE5k/WdvcbnyUNn5SRiE8R/kD+hf95f/9+PzduL6yetHk9S6VPh/ -/gcM/zj9Q/76P2Dkr//1v/46FaA/IOwHeCrA7guwE2HwkfB/ekb+Quf/iVOrjuwS+G8nRiWVGfmn -v1mRVqmZRkBphc859owN0A/0+XeeGJ9GjW2dL3lVlZX/FQAK2/XLquh/JFkclD/Swn23EmB8/ju+ -EP1RucMTYT+pbLfwq/5MufR0DILHgF07tdWO9OkRWswXaSTj/ZTDlWV83EYTZykCLLde7Wb9Fm9n -SBkJ+5lMl9Rqy+cH7khMt0OudK03kTid9zXBFDeq7Ln/8R9Xo5rZdsG+i+yQXtjwP5Af8BmKEwz/ -A70IzTUgJJVXpJlvjnX/A+6DPyAYvIn/r+jfM/6e3q9Zr0VNvJrKgD+b4iILIUVnGMs9SyQNvwW3 -upLh/VJKUnOEUg54DFTVBoyZtYcOO0kq0+5AVS600mVc1UNwMZ9GImohE+kd1i9n8jUtKSjTZFye -QIr1cZWOq/Ke+9CpQf2Xp9vKSk8svbBa2/DSNLy7C3oBzGNlhp+8rOM538Z3uJxvAk6i/PPTXxSP -d+ks7Up/i9ZTwUWvVCch0aN7Pfh46X9fIX2GbtgR8KD93ha9yQ+Y/DH5vOS9oH0Su/uj8R29X0ve -KifWHr/3tZnGq7i3ENKemi8Wpuh7G6Cb2vSSF1Ol6OQDnJUzwmJ8Z1h42mw3NUbqfoe00+WWjRm+ -xbYja93vmHyz8NprJO8XOhi/VsEaaWG3fgVUdleNzdMl893WfVLrN3D4J/onNj+djC9kf81oltW3 -tleWLqSvCgEdwV4SQPSkSRSeCxR8PYv6rRUuLVBXrJnSzA+F6BzKnlio1YHqJ+y2OapRvTeWZVZu -vQGOzD0YX9XEnTqx/MR9yeiqzy53un7l1cbzBl0X0XOW3N3ww0xjoMzSpEyLEqDvWHINOqe+2AwB -8/TABz0e8nlUnuie0Dj/XHo55IpeLiwQZb+qLNHptGrjsrmyjnk4a9ooNhe8Z9sd1vva3GqNQRM7 -Tx0Jy9WWlFZxf8RMvpVXKr4othOxykbzwFOoDZTTX1S1jl5W47bQs7GelP5FjZ2lCnyhZ08ssIvH -62cNi316YPMXfO6SrmtXdxw+DSfirCrfBW9yS3f5gvQJv/uj8YXcryHsJ0DfaLC8oZItOQoSEwTD -qFmtFqHoH6bTQqIAL1owZkeROkyhgzRb+3E/lciD0x7nPs9CjoHxR6Ix5rOZuyYsTDZg6msQvhT0 -V1L9APGJD6eGOG59q/LuOyvwmUr6p0qCrRenr/ajcZsWYQlk/riq/XeVLIHeomXfrOMsGpeD8R3Z -X4uGVcLywvfWyRIrFyKNqNlBxXuw3mK2o9aCgy5Xk57NyqrHPQpmlTXAseoQZACYWiAPi2U0qItl -IBMyMehN1anGKDfcr4mGa1dj+4yrXvp68oQ+9AN/CWysF+EdpyDiJlBPkxboyl7TTVM3soHTvEF/ -D8oTMeKW1v2c9AnBy+/4jtivAax70t2rMqUdagqAq8gCJTECpJXPcwkqrWPngG78ratJsT2VtpKX -BhkL8A4K7TYJLcYBl8gEoo88lLIUSBCO+rFR2RfjEU8vZ8lp1BpFO7Pws+rZzPZrU8+77x7rdeWN -I98o9KK/a6DgqV96AXQ2Luzq/ip6koIXKuAygTNqJ7gbSk9+YD/Q59fbu3LiDp1Piwh43aD4lXY7 -yY0dmWlyHve8msaeNdBpyA3fMtD+iO63Db/dQo/jPiiB85jnvZ4M+3HTxO8l7fPA8Pw7vlD7tbD7 -OSQVOeRv5iFN9JQO5rt6pmyX2pqpc/mIZfsec4WMsRdQKo34jW7xXguYrKxyRKuLbc0MuqkM9SzY -NlDJ7ZpwUk8+6sg+4JKXxrZR+JZrA6avp+92+KcJ4A3q/RX185jt9DO+I/drRhEoANZgmM97NDfn -dTZjdbkywjgcIfmUrZdDJzPgauOokWAq8igQeGszkpi85VoSBXix29oDa9OLttPNKKQ1l7Fs5Ytq -3bKN2r1vwm919pZtZ2M7ry9CezdxfnFTmdaFaY/jU19f1lmWFtV9d39qSy9m2FV50iaXa/AP4i1r -1k/T6gtvDfOiKE7PAkaaBKfaThOWxEmLWE9O9VZ2WZ0GIz9OauaKNuSlSQqci8alXZzk4f0u45l1 -4BPS8ZL6STyenY0vVH8tJNyitr0wwFSGttwT8EM58ptw3vbDoDA7qeZI/Bj7myaBOIZONcYcjOlB -XNgcv5SPQeZtcLe3PDQTljl33KjLo6K6kvsNU1n40/r2zJA70boGHL/UdbMEnHIc+4mf6eV7Su5s -ELkBnp/pnwB6dja+0P01QK0bk5wXwUFm5xtkaIFJnCLhVphm2JJjvZyy2h5yZD4UqDYJ+bVaulkj -eQuCxhIojwwQClQkAYwZqDlahkV7CgrR92wNsx1zTSt+xrFzXwv+QD/dpV4GNlcNusL0NNHxOyBM -HccfW3rR+slYL2IcfQews9LAPw/Y+/WcgPu5cHyp5gotPBX6A89oqwngSw7qTPYYve3LuLIiatrs -OnyaxQe0xts41PwDANukN9ta/MLXjpHA11ZkUhChxAcaMJd+74kTRwyHF92VmdWn+v7vZwbCC3Pu -z//7Lxviq2HCU3n5kuzd1/9M901TySuDyEmhnmZfmd5fbCLzO1bfjH73R7Dvfka+ux73euiAIJ9K -9U7IXRca9K1vybTMOAFxJJfgjpXXhGCnM7IkHdHzRSg2aFKWW3GNmbDnL5N678IxZPTmwBC0PhNw -kwfaD3Hv/k1RdwrbNkrr9zf6FxU9Yv+i9Fr4N0Emq0XJzLGjXPndup2oZWkfD+K6T494COZ0NTIc -UCY9pO1VEO8nSEEtyrSYsiyXHrOFQmvryRbnZssSZzKl4MKVLP0dzf7+8/8REuDrCPwnBOBcz0/4 -nwuvhZ+Tj+2CgEGhmrbHdK0Obt/E03iQhW1KsmLFH+VOx1bGRA90HYsspo7BwIgVEdksOaabyouO -xSR8c9SIg5FBIGTw9s79EP4Lb/6t0e/+TOvv3mj7n1D8dJh34ergUZRMVqkCl1VzmkJB/lzYsN3E -A4kVM2N62giO3CFkKK4gUN+Vw4zDVOQgkp2mwe48iiZqY3ldWgiVoOTa36D4/wnIR35Sd79f7z+r -5hH5Z2XXIm8u0cMmJqPAYApz4x6CYXoM2FXHKk1Tbycyc9S5NIWoedBqMtDEe6+GuxWSpbFjlIKH -62pCgLsphdhJ7UiJzsl7qPhbdP7l4/8ByP9uff9UyyvcP6PrI2inytkaAn1dqogyMtJWzIY56hit -pE1qJyCrmOkpc9bulaynjM2OQGJxaVbKBJ45+IoEXGYHt/U2b5MjDdebxcJb/B26/p+CepSmifsn -Wvx9Ra+wvy+9Fv55JovZcmfMLEadKjDeJxXY9WgHYd6ox6l2I3YBPPLVTvSYQXTQ1C+ZjQkeBVhN -6qpeqHCiDrtiGk/KBbDfrfONGx4+1vcPDPq3lYDCL83mT0jAfUWvJOC+9FoJOFrTVVb2bXLwj+uj -FLGUXjkTWVwkZWbwByt22pnmOQQcGvOdEx2VMkerGb6KU2U9LAkyne1ZPjvmFioMSLeYVGV/KD+W -gAcG/dtKQPcn0O9+Qv4T47xDh8VZQaqmvmQOTmPkM38x288W5Kyu8SlaIP7y4E5Gg8bkR2Wqbaat -6PqsRC86sxIaeH10Zw6V6rqw3IM8A5liKDgG9efHeX8/4mf30z8xu3tezyPuzwuvhR4hVxkqyZ0n -R7KMb7eNPbM3IzkxhqKtWRFUlr3Qcdoo5ashNkg+33sRKUNpb3s83gDrkYnSjqM7PLxqFyGjTSp2 -vm//hh7//uP/Eej/5hb/rJqfsP9Eq0e4PuETpDelba4v9/xpyg5WVlVL1q6i+3zXA5UIavx87w/G -kremFDdBjpm7KHuLoNmmTeb7vlJ5YL1YGVjCCpljkaz751v9PwH51k9Obe63z+6eVfOI/LOya5GH -J1Nrs9lWMtoZa/LEO3it6SS2xI7SxDBFQgqY7RqbKMpyBkNbzglZ2w3yeZunADONarc7RKKDzY4V -Dxc5SnPHWdF07t8xu7t8/D8A+d+t759qeYX7Z3Q9Fqt2tJirbJ2hdtpp64wZmH656VKzKt2RZKMi -ucboDTo3aM7K0zWX6yuOprfuajiYVgG7I5534pmSjlJ1C62ameWLf4eu/6eg3v2J1t791NY/oeOj -zTygdGEA9dTXDjLQsmoujIJ0i/VIxGgBVJJ0iOUdwPLbfAQu58TMINQ09+l1IeLkiseoUtw1CVhJ -rLnLna27iGnpz+v4vwPxqLfsKLrzRMguXH3bIwb+AY4Nu9J/QNjnEX9VyYPnw+lw/ILyFcbagmjp -bjC6aWvt3ZCspVFhDRzYOWm3nqNSzQsYWrbetjWxWbfBBfIIAYbZ68OWb1ZKiR9CGstXamgP9Xy3 -7ZRWsydXecU+gPiB/9irz3y99v0OFz94svvscy/tr59+8NP1vRwRfPrBN+v7vNBe42TwvRL82t3g -zfLPyjYu72hjsMyFv5KFCIrlenCi/FCEsckguLJT+YbbpqzbCCE8qzhWX+pTraZEiMk3cXsMQLb3 -mB2Ey+qOWPNzstOSoJf+AZ4Hn0ey+8M4dm+i2H0ew56V4TTf5MclvTP7OoQUcuti6twsjOWaJVMy -2B+PesxSLIWsdoYy2xXphvGK/LiVJuhxQkvVSkDd/Ej5+7W29bFa0kDpb/ci+ASCv14C+mYIXy4G -vVX8WRDb0FhNJ9aRiiuxGaXwyB8qNVq1iUKjNFgfwNYDFHYUt0sz5mB3tUz2JM94h/XE4TjsIKYh -CzY05lu+kPG2q69GPFC6f/+60KdR7P4sht1bCN7QCEcKgFFqI8j4fkSsmaOZiO4KlFwT7M01Ijss -rutTUZiP9oIfTMiJQ7ilj1kqJHBrMsKPUrxn2JG6wFx9wXodEndCy/ztlr5PoPfrifo34/dyyv5W -8WcxzHoqJKF20ibJvGDRuBAO1eywdeJht1cxgxuarVcXB3PJVIwJyyIKo6avlOHM3S89arPBe2Te -K0nORcFIwcMj4q8rkPr7Z++fRrH7sxh2byF4QxuEHaJquZhVO21iFaZHHYLKbrJ4t/GmaQjqDZUM -hyJFK8yNB7ArN6t5mGpNH7dVPdshXTrZDFKurTcScBxabmlM0tnwt8/JPkAvPjNYj3QfeDx6138c -fxbscjVeb1RwQurxeHwhe4Wj26ZC+V7MS9jjyn1xZERtjjngehvLowW83MUTbKHy7CSkFw6uzcuU -zSILmG5p6VAQHY/7U4ZeT8XpcWj4o6cYI4UJjfYTCRA+CC88GzkrO7Ljc+AQUNqxnlS+efbob04X -Tux7CLxHwZexRi/Dhf7LFQHzL+85x/4/SwXw7JFPBxG9/AY9e4hfJF9W+uo+uzvHRtjF+ASmaY/T -KsrGZ2F4CI6EwQ8fP8vQOdCivI+g+Liyc9aGu3oM/Q6n+0duCW5663uvi2q6iRtfJf2cU1+l9RMf -vy2a64qIsVcBSzcFdr1XzWNKFeSqCK9ubhHr2RDlq8HMzVUd85SOu6PNHg4DFmuKzJyvEyeyKGWz -QYJJlOTLTRvJBykm3OlIaYUJPIBRrm+NoCC9nB9AeyZ/NVT5jWCeczOEyB/kRQ3Al+DTZ+DqQfOg -RCYvs3+crowvIUWP6UHAlzdcWJhU44d8A/fhyi/uKMrH6KaXV4q0LMdlprfJY3jGixvss+67E9q3 -w6mf3TDO9KK8/1bktZ47taqTYNy9BnbqzaE3Lo4LvbJPI+/Yr+6Z8eq+p6CdHxD0MmYzSO+VCf46 -CuxFlpUTj6x72q8+JAtPX2B6ehTZiWvfv+erjyj0dmykVv/2Jz5X9w/K/lpVD90QE/Pp3sF0zqHf -dgG8fgX0dcqZNz/lFgX9TpWfVn4f54tx9Kj8nI57SGIFvD9Qekht9WnF9oz2SZedB0f3pH6tzKgY -mMS+r2mBcWjAZTfE61JnKJo8HqIBaYQIWtU5FEDFeh+MJst2TSAbrEgOVgiBjYkEh04/5HCZRGwE -LHSiCy14Zn9Vmb2R2umnPE7n+14FvL+Obr8EI785Tn01KL1fcL67dA7OfhnZrReVr0eXZnT/Js+y -+tznXTHS7jGWdvI7g/wfsXZOalR37HdzNtyUxeM19bugwPPRGLwukYc/AnW0l446KnuK7um7xTKy -LZ4kqQVCHCwqIXIgy9RlgZJDAVrlej2CXIcQBzxwZ6DrWmaOK+jMc8tVnVBMuevjoKe+I2LzjWj2 -K1Y5XnPkp2WOl5z+6JHu6geeW/PcpL7hqbguo0891t1QVfe5ip5m13HZmG8+FJSDnz3EVr8adlR6 -8dA+n2H5iaZyzcLJN7Wb1ysmbxVf26IgaIDkBtJUHYGWIz1lMJw7AKxCMWqdo7x/3K0zowE0Nm+n -G8bqRytA9eEO8MyWWQSegSvrcrnflstyRi0DidrCuRD/o0I0r2+5N6Dd/Smsu7eQ7q7HebEjSFsZ -dZN5Doa1u95CwqK0VLOWVy1jL5WRIqV7TSn3xt4lD3LVYqm3lpWJkdvtZqXyMQ2alu9tHCst5ibW -au5CVv9BIZm/B+WfVeXvhPpVbc/wfnXlWtAR5dRuq6O4Wy5X6Na3cIKr5Zg5BkLPC34kTeipE4+0 -OR+lYiouuOaQ6pTBUnmpD80+KKS5bTpddBBlhsyNhY5tjyJ34+KLYb680b0U/SmP3t8vHvdd1Z+S -j3N17wjI+dK1ElIcoBh2KgKdrw0cAjhPjEOfAb1cQCXGgsJEmpqsQlQ+hZKl4R9K11s5u8PWgufg -hI+oSZkdqlw6FSFas/RQZyJ6dPs9EnLh6L+DgHR/UHt07+iO7nOaI5ITzAOjUAwWUO+vO28Uukd4 -gYosdUhhZyUcDlrezSlGsjwaGh2npkkce2UjB3PYIPR9VLrZtnVyYCKKkM0KW4M1i5tcff999Ub3 -J7VG957O6D6pMWxgYU4n2MBJg0v2sxkWNJM9rSHtxFrxtJqdhCUyYsjKeuxwGOkZkQVlvmdAE1R4 -0ZoZ7V6aJcM8M1CABuOWY4HUOLbfIRn/Bvrip0nM7xSMl5U9E4yXF64VjKmvrlwzNAW63qYN3mz7 -aht0BGVt6U0XYXiuEWwB6pROdU466r2dyPCb2EsyN1f8gu7CudQXFD0rNsjCmvWlKS7dPfWP8Rz9 -XsCzIu36k2i9b2FBbknu/DP9u2Spd8fjC9VfI7ndhxUab0x6HUw4wq57O++TcDY9NNysU3fVUQCP -AsuAhGPnWD7t6QMfO9aeGS3lpSoeHGEF+1WddouomPVB1ovZfmK332JleWnJutJSfPb5Nf07EsSP -S1p+8lq0frmE+k6KYuTWJvpxhefVpDeKx3c1XqG9d8e9HOMwWMkhinHznW3pyoJYTo8zwttDOOrN -TmO8mdB3NaKmhkIjzpSpsQr0JKPH1+l+uyl5aB7OFR5eYopu+Qtf/UzK/l8tA1yVv+wp4yWgl+dc -wH75frZo6Jbssm/VcLZ+PxyPL3R/ze9g5M65jqsX8bxtBmTtbteHqhDhE/s6gvHgo6Z0uueNSmgK -C9qopUxbWS3CpseHObNRt6EyGml7qbC6UrGlQ2y6aJ2+lzya3rFjZMxEen06v45958XWD5xivsq7 -O/Inxt0dXMs1SgtNisKaZAU06IbN5/1yi0XdxNOqasO6TNQQCAcA0+XK28Ly0lwonrNVaIGJdxGY -+uSwdFk23ypiuOvWSBsT2OiwcL+Pa+c87q6dvOuT8nzV8Ra23dO/JCq/HI0vNH/NuME9TBfDHqEy -BLFxC9xHAbrkZzHO2MSaIBNAzxSdX9FA0I28dlTUey6bcC2vlJ61mKtbptP2EOxkZIGCHBRLhQMg -6Dcy7rK8asd+Vb2bERK6LSPkO5WcWPj89CKAVyxcNXuIj9ultkoWI3e51dMm8sheO0zQ0BzJsoJM -10YY1kW21LcV7Sw2SGQFO3Iu7aNWcwt9y4Ejy7M5LqU6azBFibAP2jfy0bEr0/ttDLxQP48Hz7/X -sozPsmpRlNhEt5a7WvARdRWAMTUlrNZD8MVSP07xQy/i4nIfqaU5qlC4iiFhx7HxukQowmHIvrf9 -0l14paxKabjWwKG9hmXXLPq902NcvBierVZfyf0o1at3uQ9+UWdeqJ+5f/4dX+hdsVmEZYxC9RAd -yoq0Rlty48izzoM4axW66dbGqvUBr0DIgaLjft2IyW7D0hEPo5C0GMx+Y6UruTSihWLVAb/j0O1Q -yBr/jf1Mplfeb+tlzsTP49zTz7U9DC6uTRGTY5Cw1gJlWFuEL5rNqFcUJwx4zN6UwtEcltNFjmjx -MqRYkjBZ15Rhn4IikVyp7dRCKwHwd7vURtHjPowqjvpGfqVp9AG/wK/x60T8zK/Tz4VfV4wbwZBb -6PxuxtLzxnR36BAGA7SxLUuviuBoxsv9OqJqatNStmkqxUawlDwFRHzh97EgcL4oY6tiCilq2x0h -1Bk5PbqX2u/jV105xG+TrzPxE7/OP9fKlwEpUmtyGtozyZJhCZZaQGpkNLTIkcDsgE7lWTaheag7 -Zg5M7hb6sNgVuRIGaDs5Yv3EZNQNzmGVmefmDOzseBMK9Vc7kNI2x6epw+lzdUs3Ivu8vYStx+9O -QdFb+pF3KjnvNPSyZHyp4IoksgiUpyFZwBVBRd0iTFGwh23D3bGendgJo1cL1d4DNV0lwqb3hHXD -g8xEbhzXNtVRKwyzGJsrM8YdYjXb70azJUfZ7m05z0s/anx9nFptfxpbZN5JRJLx/ezlvWn8De7J -71ZzbrVPZ5f5/BVuykYS9Sg9p5E5K0+7QpmZLrMwdFtVd0RUUGHhQxk3lGEWdzW5tBxeknvCIDjX -ZAmkb1lku1mWszo6Ep0oYFSrjyrSoX496fuQkYl15kbh1SUQ24X7IBUfZaIGb+Hke/Wc/b2fn19y -Ul+hCasoP5JdjtVhJysaHafrbBTjkJm3EotlglhNj8gyIRiKyEq8d72FAAgtoWys3EXXi3i6R2bT -yDwk0ipOAcsjhOFwnEnfYBx5y4PumnDnt/Zres62awZHZXVu2JfM8R9PKG9KJ/6a+vP55FV5xCEj -2Uj5rtvVJjLz8aVH92W6Z1yMCMiJrgQ1s9MKfhez3Sqv+mrmgyFRV4qdUK2srVAViw+HI1+qyowc -bDrvRwG93km3qZAqDe3EH07t2k+cSK/s71W/P5E/Mev+6FqFC8dUMyKykMf5meZPoXDlQgEVePBk -xnbcZt5afB0hZeIM1dQunA0/gxYBaw9ahvgTmosOaZzlXLWJ002Hm3DrVvtyTf22vRMuXzx+2Krj -zmP2e/xP/9Z90J6AvBx90MGAX5GSy9F5G5ILFy/kfi0h6yaYjgYMWiBpA657SgGteiiPdbMGoY0w -6dAKZ8Vu5Na658oJLYSeaPGTMpVseTdd7FeI7SRC7xsaqhERzNX7VlwhN25Dcvoys9aB0/9jq/Df -32niHPhxE6te0z9bZR5Pxndkr9g2kYtKt+iblRxN9GJjdZOqaI7egLr20tsMVekT26nNMUf44NW1 -t98Pu81mI8gMatJqaQBuVuT5pjJGQg/PoJDnOd6yvrghyX+rjYux6W4HshP2J3U6ftG27u54aCWP -d9zi6vgTH9/wdYRfbVz2/kPdJx5509/x6ue6Tz71PE7zyRPx6ge7nx+7Rln8irm/tUW89kd858rV -beU0X0Lopu2wg1RZ5Sjp2LV5hJlufurCC7zMgsDK2iNrAAgaVHKF4oFtVRA1QSSO2wBd6JBM2JLa -hNmXOGFUIyPml8dv8En8i1qxfy03i5crGt+fBuAXUv9HsOzeQbL7BI61kC8p47jNFyWxVIR+zRbU -FgwPkyJ22+lsZe54lXcLZVFgHLyObVHo8CkgC1IIQNFCxYOqmB8AQyvzbru2va0YV5vVl/PF/X0o -XutN+F1Q/uxP+P7Fq0FVGH4HLrZJv1u11DHvY2EU7Ly0Z5Uqp0J1wy0NhmWpRY1tUTqvyp539Lab -H6mjSwIV3esowYYOujIDDot4dl7CYU3+SZ/Cr+F/dR6BX/cnfwL87n3ou08CT7bVfMrrrCGFIC0c -kn6/XMznbig33soHpYboEdJPjMMCix1PSpVGUTpISjwW22n+LOZAPuWbRQ7QZpv6QxyskWyxav+Y -S9jfBvsbA4Lfi/zrCl+C//rq1fgPolhPRerImN5pOs5mLtugvWHQOq0q/mbVVAhxsFN53s5CTRNy -hzoelDXo7iW8UuBNJjuaoFGWf+q6gygZdWtwrXBY+3f3ylfnJLhiwPYnYO0+ALX7LKQIzJFTjSkO -c/egko07gtvSEhW9KIsEMQMwoZedeSQGSOqdQ1Af58cDKGIHUYk6Y8UQG3FrHDccnVggOYVyA8S2 -DY62f28HfT2glw04PzDewviNJphHwg/ZP+4o/RqPkJxwq0bbVw2F9/mAAdMdrk+smnXXG85eS2sT -9uc7IDni8QHPRWVeLZL9IO1GhwCvDq3dB7hmytQclmzTrpLGJxNm8UXLy53z1JN95f8lLiaHayYl -Fz48bFz7duOAbmscT5Qv6wqn3/EdrSsSUu3nayaSZd8fTM07JJsj2vqhSrWxdRQyIsfZmBlxojJQ -y7I3jYlAI/DcI7crdAS6XBfEm1jbUVLgKtvDjKfkje1SzY22i+fz73esOy+n5Fdz6JHyw2b3D6Su -SfB9KERX0WBVNTAcKndJeNh45rBKbbpc+bstVdhmqYIiN2HEHCf1YBqayXlsRyk7eJW5QriYscpo -wE9juxHUHhIj7d61VNw3818x6eM1lq8w6Xk7vZ5J+WqZ+fBixqzajj9o/XZKODuW3mWGPfSawZW9 -VRj+ciOu42q9L9Aq1mZcNAnCPS+o/Gm8TDeCM01RW8gwGlXUDQkTzK+Y9Blzy+O3vWFm+cjO85OB -5cOb3zStXP3EU3TnFY90n6yiu76Ct002VzzSvfXAFZrxXXB+k3y/mWLzlWnmWsnneUndLEI1RXmT -yNXFHp3xzY4wgoiwhUNvb1CdnCQVH5eUdWg5zC13MJkSncJNt+vAa4U5OyJLV7WNiNntVR5hMqH8 -8jDw90/n32khvxmx7ie8uk+hBZcmOqnRw/S4Lo14g3H7Ed8RMdDzxTFxpuxUivFROEzcdLeXVy6B -2pw/IMy6JIW5yKr1SsTmXoMd/ExeE8xUt5aLA/PFEd6fxOpak8vXAfvZ2PJW8SegO+4q9eAdBwAL -mmjvABnqeL4qT+A6OVIGX7u+M2VIKV4DIy8pUomlJKwidtTWKE0I49E0Wpp6bM3oEc/JvkJP3Fg/ -/jlDy2+faX/Yp/wJlO/Dqd4s/wTOsyFDk8bpgUXsG8M0bamhClN2HZbMFnYMeIhwx4PSYAsJXOmC -BcUXdVfNCAtxEoKdgRF9aPM4wXdTAABSFo2nK3Ej/akQzD8Oc/eHWnL3VjvuPt2KD1YMQ0bUu5gC -hHu8nKyXjVsUhJnycqhEFYyz6pbsCHc+2/nOiEOOrcWVoTHdmfu8LyvKFxMnaCedwJmEsqxBKRom -0h+ymv0t4P6RFty92X67z7deZyqR9H6HnyYDikDuRJclU86fHw4pUOo9RjZCP6nLqQ1VEwbumrbZ -IKiD7eruEO835JZwhJ4CdQYNZ9pIltte2DXQ/A+FQ/5BeK82gn4d4DfMn2+Wf0ZFs3ixG6BVvClP -oySaXlEtuk5EjA2IzDSqlVhZGxpZdybvuwvaAmywmxi1t5tN0hJfpph/rDiL6RN6KwlTsa0N7LDb -uH/XmPdqC9kH053fC173JnTd54Fr7aYcHUfl0JqMIhMzcWrQKAAlTtdvGwCDIiLlJ1Ne2exZqFts -+lpwRJqHJ8xow9rMZL4dTnyAE1xfpCjLa0YBLI7y3zT8vRY23UiL6hwcWBVpFL3rD4Pc5FD5mvg5 -Ju5V0Ri5zpHSIyKJqHRTOyZbpFlJsusbwahas8IMA0YRiFM1vDELvwH42K5AWw9Qud0LKFSuyTYR -WF8quQAic9AqBmtv2ZRQtfYXPWIusULjSi9cuxqXnh8/S5z4WY8y/Mc1+2/opmlnVflBKNkNIN3R -PGNzd3QJH7sCEsxsXJyp5q3jWrGaH6H9zD/MTUSCjHCb8wt/BO8BXE9H+HHi1sCWabc15fHc4GE0 -Oo/KYVfLC1c71vk0TzFjFgerefJFSGI/tp959/2UpjKx3bTy9SotHrOFfh6rv8Af+FVgpcV7nniv -8iVfj9WJ5AWp0+/4jsgV6Tn4fET2BQTwNbXX1eNM2AZN0+94DEBVZz5rGILbd7tqY5msB8z1k45D -qnaDN6iF0WGhN4ofeTOq5FEpIJAKhBd7ZXOVE7LhJy+Z+MCT85V7Bn2W+2e/1GtWFHT33Dpf5Qd+ -jsHkB3SDu/0T2TMOjyfjC7VfY7FMqNFRJpzWETcu3SExDi5XuR7GCHhYh/0sFaAe92pZahhw02r8 -JPSJlW4uaLPYGKs0JRpO6ydiVoeTUbBcjxglbeTvcAj/66pg6rtUvW9LNHyT9gmaMx+DZnxH4Ncc -lD0j8kfraB2M/OXmOKVV2hGRdcxQib7rVwm6hJqBlHE+1DGxIg0dEGZbDA/SHseqIx52wJSZYuph -RRMQeZwAvFLQ/BeXvRy9rMaWbWdjO68vnfMla+BL1+PLTXXhv53J+EWm3lObO3HWfqajnifiPdXh -F/bYKdL4HI9w53T8r0teZfhP+CXbWWrYhT2ET/a1j0XmWQ7n9wYX0C2S80D3XoLuzy5DimtChXwl -jzCQU7ajWjGtrYQIbK7jnNqniJWaC8LF9iIyXZn7uMbhmRHySm0DGdcv6D2h8vN5bcobN7fDEnVm -CsRSaJ+20tcE6SkVNvj5zBWffPjnjMUvW/dXc6kbeqQnpm2NT6C8G398jqP5vBJ+SfoS4fG84BKd -c4UypheFy5lbuT3AKe7yHb9mVv2y4XcZgh1Tpz4OLelBs6W8jed5VVGapir4xLAMclPAjSJQxChA -fLgSnWCNM/gIjXte/nqCWIg4p52GL5smXJkr5j7CJXg/xwh2QxN7pPoUQxOcs4dgV6Vznmf6MRIS -okJ3qrEWmH5kYKP53G22aFOULNEYTWH4kpiVE2fOymEQskWPBz5YKGLAgOFgrOzNoh26nPD7LEWh -3H6Z4edJsz1NfF4I77ta7jo959jnDPH/eisn95vVZHpV2Cd+f1RP27Y/7u+7VPbZOk4zp7KOqvNn -f1TNHdkLiGWdnfd0+NdPTfe/f94HwfDdpI5Pyv/Hu5JGntNOf17SnhE+C9uz0/GF4q/lbZ6C9QHC -0pmym7QisjUQcFriu1A1FvGGpuZWFE9ycqSHpGHM7KkDLtuaLiUVHyajwwQnAFMoHXe0j/qS3Ytm -XHlBGXx9ZPWfr2m9qdU/bSDw9tTulsidZ3TPTH06G8PXhe7AJh+LdaavXHckKa26oGqTrfd1utRw -7kD6ArstWw2LytWRi9uNvg2T5YZZaAM46eVBzQECydAUaAeD1Qy6kBuel2ft17pIo68eZ3fQy20M -ftoNAn49dvogMuzMx7FdFE/7RbwaofnnFErjyK/s+71hJi9rP43fHD/xS+9+lwX4hUPY6Yb8MeQM -e/nkT1srwK9zuo/9h5eCbpiwfjpc7ZIZ7GyfMSu/sT8YHr688aLRHja7+JTYAy8uvMLx7QZxS16D -54Qvvk5Pp2P4utwGcTBRNgcODPRcX5d1uNK2CudwPkyZiwkDNG3cmoIKrsmJvYY4KOtore6DSCs6 -rLRlfUW7kIKPUgRrMx3BJMc0RxPd/ZMRvX8a5DT6YBJ+m83qgehFq90dXmu1YkNV1yWhj7deduSO -KdlBaTqRJjR4xOeiUgYxYpK23E9Zo0eXwoKWWw3X2D1tR9hQHLsA2peay2DpIvOHEYkso/rw7i4T -sx1zfbo68J10dd8/gXMM7Bpro3HZYekEtZ7cw/UWgmd7J/l5BF/SPgP5smR8oftrPHemhM7qZsZN -IXkZbSZaNWoCEQDIIdoY8I41u323RIyQKPEK53lLnMzXkMWYsm+tN+Lc3uwRcMEBsClPWqbfeCkJ -7LsvWiF/mvn867L3GfxJxf25GUDtnAZ9d/aHs329rPSzZvNj+1vD69+v5gzhuxevjb0ftpnis60F -dCFOsflmSck80ZikuilCM5zI4GQ960A3CWKRSoREVg8riUcap9mval+bhW1Nzou5RUG+OHdKR1Y7 -Dl99MdPO/VedzS3fmjTmGd0n3l2MOlemjeFGB4nZtjtD133Gqxo8xNnWNUdGN6JLvKnnoiBEWJh2 -AK3PDc8/DLm0bueouYbhnov4DF4zcdCqnowIcef2Gz4RndsSFTwMyt4279zEnTPFM1/Ov2PkOo4A -K2ci94Pc4Tuk34prY02pExLDC8Is4NE6ICgGsyqi3W0QWqJS+4ARq1ToGYXYEAMfrg67KpB3Pu4M -a3wKZrRlHg3uOzrnv8AfxBWN2NSjaGz4iTXWsyzqx54dZXZRfmv2sHfqOA+H3r5ybVaxXQbpRiSC -fsOGuyEwddHquDpZYcChCcupCJdLeurkeAcWvSepAGwA83Zqw5C5zGKh2qx3fkDMSRJod07K1fLa -iOvlF+1pJ9F5NqSHXsyi7rpW82zfunz1Y4Y3+JYVIfRqeNM6sT5AFL0R0TPZRxDPJxfcrrCCjfqS -JCcKiWcpOu8Ais5oJvcokqs7UZf2rOROYBITUI/OvAaZaS5opPS8bo9ZhR4PGb7UMCrWpEQBqn4p -R9tM39nBF3vQ9xvCnUH8xQTpvPx6+rDCPw0czGdAfwnFL2fFiQJPL4xrpMLTo/f2l8RvGh5fKJ5l -4fw7xq8bGMP1Sj7Malnuwonpay6lQLRkuonpmTzYHZKixIMhlJyA3JVbnVzCJTZwxF4mcW+Hz2Me -XQ57YVc0AoqwUyhGD9uwmLq/abesT4Jyx5DL3//rHqD/gK6CJm2T7/WJuCN5Aed8cK3/w2jWDUeS -1taSBRzq42YbFw2nBlMgyQMsdGU05PKJmjoFmy6hZZduA24fFgyDcNXCx0hZ1dtOppJRWojtVDKL -nFtBo3dTxEW1vdbD8culp09MQD/gaKS3meV8kKDm82PSe5pnnt4dXTLTXDHaFDTCHRAzJvRikAEV -ZpKlFgnRVjTKQjlKE6geUWjSx3bfrJLjkGnEVmrDAuZmmn9g1sM2HKY9Ua59gT7Q9U5hWfOQ37Yw -/sSXf1mn7zt9iX+2sX5+975rMLg3e5wqytLSr96f20FfsrI8o//M2PKs9Np8kliwZQRSA0bsdjMp -wuZIIPSo52f8gcTXR0uMh8TNkxbe0bsuZ6YbC2zhMEZKzD8xlT8QYZG0Oz6egtM9tvIKUHB0H/k3 -trlcYT+Dbko7/ZH9DLou6XQiB7lj0lPOz+bWgWnQIyvtGSc2F9o8JqDIOo27qTSTm76Y8qphbvEN -oFKUhfGT1Qis5IKQcl8Bq6lusfh0jq4qsV1T3zNEx6/ibRr6H211ecOI/ELyws/zwWULjSvG233o -Y4dkXjsTDIwwsOblKKrwcD5bHNFEguzVTNKr9MDRvYZZezeZ50aSx3JBcxiNriZRsRTnEtxX+6Uv -r+EUbHCuBdo/zclx6buJXtXF+5IK38zTJ+JP3H0sGl8oX2ExnOC1MkHqaHcoWEg5TNE5B8vLTlVb -r0wY16F62SVDYoPPeS2IDvNivbBRS5TmM4TufKwN7FJLpwdxz0WrPR1stKXhfYf2wX/gV3lCXUJ6 -68qP7lYR3lMHyA1MfiL8EDp8f3pRB1f43GoS3fgQa2YiyrO5ngS1qcFCgLTcGss0dkeQ9N4IzaKx -urAU06I9dbKaHh/Ik6IIM1Jv4Sim2YUbrg2OQtn9SiSnx9tsGPc7hb9tpSZOIn0De+7ZcvapPFG4 -Il+oWGk0LVB4E8wofYpzyUzP8Uin6Q2p58ARSWtVDDgnFYwtbQo0JRzNpQe0xIItQnjTzJbLnHDj -NNMxFlWJbWwUHf/FBbfUCE690Fgvzy3nzpj5vONq9OJu4Qq6ZcIFgf/MHvTF3vBvew+Ct4jEE92z -ZDydjS/0rsiSpcLSer+Bk/1Q9rC+zAh96xueT1rRMMUE18N2gk6Ta1/muZ6VfVHsO7DuMUg6WP3e -qChhVevoQRyUuakj62GuWEjzRe+3Syr10O4fF2Vf2FhKzzb0xB2fAIj1xHp7Xbb1/HtD+d2y66cl -6aq5x5nZ9lkgPsD0huHuI9kzpI8nF0SvGNyWSRxw6qEfQYukPVidd2zkZQBZZLX2UKELKegYp3qv -0rbdb2EGQjd1PHHMTpzF6K5sj2Wm9gSO28dVGwl4xyCAKmAfJf+GP7EVwrPVuzdQO39s6112N3jw -Onu+1p7G3gnwu6CC87L3q/X00/VzZ1E+Wx957ql9kinTs83wmbvkp2dD/7gltWcce9uJ9lYBPBO9 -F7/z4Zi4cjVUAOk8R9hVhlXWemvXq56iRtxpVA7zO2y6NLTMlhcbnEEZ1gc9LFmAdKxsGO/QIimQ -G8KC3QvRebfPVS6px4mx3LFW+ynh+/8jhun7afCx2wC8rAFdfscXGlfsbj+vJTMfrSwhjyizVY5g -CggLnDxIhaJL1jKId5VIiNNY0X1f4orIK+Lad0MXYBSUg0Vw1itzpVhSboTgcrPCJ8tcbm8aOVl6 -pZ89m8dVOr5bx/rA2/Pz9p2fyZ949XPhxevzCqsPuCX9cGvgOCHQE4ntZKgJs1qhq9zEkGNPtcuW -t5XpfJsGR2C1nzeWNiKVY7V1+NjLV8Y2lHdqtjTi3jv42XTawKYBfMsMFLrGevPgwvQ2f9EbhvEX -imeWnn/HFxpXbPvHt+0+aaUmVB29masVDE/5RTvqjjtroLZtDBY1znqySiF1rGCeZsKEioRrtKzc -Y9EXcrTI6sadkbzvB1FFBSvDzL84EImfnKSQGyKwbvKZvnevLE/jmygtvtF9+vSZ1rc6zZwJXlDO -rGudZdxJIuAb3OpZPxVTl6L4rOAzplJnsehlmxAoUmawDMSZeTgElECyKZ0tnib9sg0ZagusIwbp -aQaMuF2jpBJHleWsaP/ceqp1jpCwC1+PzunLP1ifvkEpvSB95uuLgsuK9RXKCF1yOkIAkt3RqYG7 -01Vbjzje2jeeCK3n9aq1jkfkiKx6e89KTsLb7FFSWGe2HfY1RmNu2YBImcJKZ8HEkcGHouyQxRcn -fKcvuWwrmVSPjpTIFYO7F9fPW01W/r2jJnFTmN3v7/lP48sTYGnwWlA+tUb0E7e+b63oJek7GXtW -cO3aUR0zkm8hwdxgYzXoiIDX95Na6cMYZTnF7lUY8jbdapnCiUpiGOspstfm/XrGVoVtZxsE8iIC -PUx4TCE1p9w3Mxp5GZD+2z3xn43MfuHA/i2DzA/RfpL791Zsb9Im92TvUL4/uazdXqFF3OPQVMsJ -rFWdtAZlECVCCxf2O8PgmdVaac3EkUDIzGcieoBnx/l0KmhYPG8KiZPN6aErt2tDqyNWn8c9AGwn -8qYq6e+aQ76rTv55CuEsZ8/Y/1k98DCdfW/oC98iFxeid1JxObwMc68wW+czVFxs58luyKd5MfGo -aId1EluXNBPMdxyPVuhooq+KmbQUaLNkYJnnvLqnaNE6hu7ObhfYZLNaHDnfN46wv5l780ynvk8m -XnbMb3cxt3VD/1y5ugD4Oak6vcJJD1z2l/tWR87nhM/S9ez0WmfN+WwFJKxIS1vz0ILLheppHOlL -QszjRE6pM9olmTxWjkEszTzXD0gFW06bIg+VBTY1qr4ftHptrytwsOytjSrHiVmNqN/rOPTCAvUL -7zA3zR6cwuCvuhO9j7BtWqV+XpW6j1/9aLPb0/t/Huk3KjhvdPtz6R3uVwCf6G6EbI+FsWrwUApt -cZZV+ErUeqJqFzQAN9WA9ytSQ5vtXFihgKSJM87IU49a7Nx2biVhWR+REKMsK8MilyjVVDWlT+wL -/j7+pe7YTzaIu2wc17Qz2x47flFW37pN7gPRM7vvD6/dIHe/bGNy4W2VdLRX9O1q1GxrTs55gpy5 -Wuapu1VoTV3bwMsdwKHrgp2tJhVKMJTd7oSDiTNEZDssMZ87BdYcccgopCi9zbpzXkax7Dvl9n2z -0UeqZ+Y8HF87L5XAhBS2PhrjYs3PVMieRnEj0hONU7uaRGbFsveXJX+aeBZLcbkftm6H7/m87h3J -1VQDgRqPdw+JE29Wq0PcJetwSxd/0M/32ezo+8zAD0QvDL07vNYMPLTOINqmBCh2gFd1ucxbKlcA -fL6ADzoNqxosuhgq2rjurWh+JeBciLtIEKyYKejwJLeX5ry2sqxVoGBTSJMSoKQT6u8zA/+iJ35g -z6d64hM3Lds5veO5kzz1KVX/rf3xz+TPOP5UeG3fbCPJ1nEdRUOLFb+AEdhV3AOIS6u+twcQnVvB -tJiOFvI2XR/iYu1O56yL0oxVBnuCS2SctHPryMfbTGz9jXpcFYy+R76phaDXcfuxa36bybcExD5S -vePt3fEYui4YVnMwAZ53FdwFcmOIzQbW9gtuxnQUHow8Kl4Os6jPerQzaRdq5mrSEeS+B3ljNwod -zGwZdTodLGbqwYcdM10pix1ulu0fZenDUn6VxuW3xrK8on3H3ucl18a0CHuTTlf4yo/svNr11hye -5oKxAxYpa8FZXiSSsOjFgQ7QcJ0BYQ8v98sVTqLd2gnnBLBLlHIPs8KEc3o1Oj3OlDGktd8fRPC7 -BoOlqWf22Kvi6Fs9dZ7RvWDzeHatn87K39WZhq7tmm8LnIj4md3HQFjOtKWYWgq/3jEaMN0lcmcW -dmg0eeFaSheJ62XmB/pcUwNKLPYFXwK42BPrZd0H5K3jkUp332UOcYvqPRE8c+X0M75Q+DU79Nlp -CtNNYr1VdQQE9QimE45D/VWTQjknd4tiMwNSEFtMBtxNJw7TQiLOSbExR6exCFO7SeiqU2DOafva -oR2LiZbmxv1zvndvpa57L7jzBoa+pn7m7uuyS4DnFaz2AfhgJLsBqLsto+CjlaWK7nzPyksUnoyW -+dEIpYFFYIitGUlU8nUtzmcUOFvCoz3cVUfBmq9jDbW2uMN1pYXuDovR/jsyZl3N5zKtC/Mjy/Dk -Ng7f0X3g7d3ZxSY8uWLXxK0M7eW+llJ2MoH4PYYfOG0qAVq6c/a+BenRnGePyzis4D4ilEOhbtGs -zPL9ijPzeaPOBhffUFG1Dzpzt9sURkqhPvUN+RTvP+MxG8atvh/Qy0WHqyD6OAfHbetEP5N/Bdh9 -Ro4r14u4+eo0tqCWpkYso+My01d1t8K3ZK+Hg4DXeiCYgirne3FoaizbtyTbe8YGwQSBWKq0NLK0 -gHLYLhxRxMrfkvO9fvD779lQ/Fp+d7apv6e/wdv0zZnkma3n3/EdkSuM5jZJ5EG4naMzelItJmIN -4HkcYwshFSCbW1bYdKUVA+KgyuzoTWEict0DDA7IVD9ApWvik7hccAm4AunSXJcw6ddt/8Whxsdb -3d+5Sb2MYPTduni2lzX4OjDu7unLdfK1/curYz25c4iOnlbqXiY9KcdZpPvJeTB3/wavKjnd8awO -9DWBE0rjok7GZyfBt5cKs8KuThOb+y8kX1vh7l5vbHd+9fYLnFPgZefUK6e7EruNTlL6Nq8uToYv -/BDB17T61KzSy0r+kysB/JUonJvDCJ/LwUWuPzdZvfd0fa9Xh29qZReal3Z2ORpf6FyRu3e2Q31r -v9d9nFzZw8zanuZQUzV19CkajPDZap2JkbpesGtiOPCZonLqMDuGEKwoPiwOATfsF8hsTXWmXBvu -QG5SsD98saE9ZdJ9w6/xZT6m8w3wS6F+O4LqjVyNP2Ukehl3c7njPp7kLqMQ9PO1FxESd8Zo6P2c -Rq/SHWXvONw+N+q9dfnFPOTutV9kS7ofhJ+vEC9f59IQny/KwK8bmXMSHu/tet9KwvTihjuVaJ3e -79Toq/dv+0Ue4F/makoT84Hdr3h6kYsHxp0ng8hLZZZ2/Vi3rOLxxSZv54B6RbbQE/fFsOcnnIu0 -rp4J5EsdaD+LX391pWjOfYhe3cdG//zs6Vpd2u9kvXqZferVxSff/9vC5v+h8XMP+q3Qq/NmD7H/ -vr/u5BYr1E/kn+nUp8LxhfoV6nXdqpP9ujs4wTajlhC7E/cae+gQ3suiliVmTlu3TeqyhA9JSeim -ZQsIKFaiWjKlFIGlvE0QHUlvQTeiN4/5ZX+E8S/G73+QZ+3UV5+bx13vdJIc8LbFNQj/vlD9N/D+ -ZOrVp/72/G7oeZnuGjGr7HdTQSA3+QvckbyI0/ngMhu8wurmBHnNYKTJTph+j9fF6jAHp3TthJqZ -+jxPgK1cb+rggJGgSWNyFSUwyMEKje6APbVVc+/gOFoEL1bubuRK1mY2O8353ZusOz+nUn5vLvZ5 -K9gr2ic2vSq5zMKu2ccFySUylXoygCmPtgGBVBkSahfxnGYYBXDZdTJfUUce88p2PaEX8wAkBRMT -jquBNPnZaNRFGcvMXFb3K7UEEUreEqh0O79OrwVj+Leayp/RfeDT3dm15vIEgrb8BoiKPTedAcbe -6t1F581GmWqnkHacqW3TbML9RB8ioFj3oykiHLcaPMcGmyPjOPSkLOsbspSmHSguSUU3kuzdrPNK -8nDyK05d8mWPq9OUxDy1dmvc+lblfdAGb5Syt+t55OSbVy+t9QrpA4MgmHELfAQGuotE8GG/94c1 -jgK6plaZz3NIBWpu3jUgu6k7fxk0NLKEUYfpPU1Zo/M0FqVNgCzknZKwG4TPrJYBv9Ba77/mV5yE -v8TJt/j3xLUrdJx7IBZFteJmmJcTrKo4W2lpFFiU6Ts0Wc726mhy4IxDCBtE6Eszf3CTqIBgGrUo -ROM6BAGJwQbXqARtR6ZQlUTYK6L7DXnj3xXJh1ygv+5JnqWWf09bTm7j/onoA9PPwRYXSr/mtbVu -NHUILM0aJplnkQ0eMEbbFfQeceZ4QmxNkKmseIkadTwsk65v6aNXZx4uEhC53bZAWI+KhWFHrbOs -k7CqB1UV/qzH6emLfae/PjHzuyPTq8amP1f3Kx/XKxLXXVBrC/004EpK//0t529tmY+kHyTksWAM -XhdaP5nC02gkB9udnSzySEGUYCeAfp+nWZ5qs3pia2rG+cUGdiG+2uswD9gmF9OWOyDQaNkVI25h -Rq6Ll2mY7aYzyddAWPq+NnlDS7TP+eeNKDXebYu3bGL+RPbM68eT8YXaFXzuKSljYWUpDgsfYvNm -kk+PycbQN91Ec6ZzfOPPOgndOCG/6Vd9BCtuN9KBOlbSJJ7ngbdE2cQxlo11wNPqkBNImUrSn2yP -gR/HfasXl8znn8jI3menMeRHld3d8iO236viV9nSrxCpux1509juzkand41FrW08GHvHWRr1jh9F -j8L32YCm/wGdWuB9AtG/oNOM5Jq9pp+syW+7tt+SDeie5llu747G+HVZf6xRhORdsLNLGVUnDex4 -IymJp4myb8holwV64e28lezSa4cCq8oODEmhImHhV0YQplufraM9uN6k0uY4470ZQ6Tel/PS+eW4 -Tvyz6Wx8H/hlPzew/bbE3Fe0kOcW46ugjuwPE2zDtw3ZHshe8L4/Ht8Ru2JkKxByySg8vehGKqZb -AsIdMdiTKbNfzA0VYlE3x8zZWsTZRKIEWyU1WPBqE2NS+oAe44aG08VIPGGNDmC+noglk66+uiRT -paGdXIK8/MSJ9Mf0768shidGnO5EHowayEsz74XIM4sk/jp3fX3iB6EXhd6PT3P3Qn9wNsFucWj/ -5vWHRyA/tQbxyhD8XhZ36AYZeyJ8EbOn00sW9yuWJHbEPNXcrbYa6VixanO5izTN3gQygJpJDG7X -6gRc2NZW0MCMqElnO2NBT1Q0KQvni6FIiYUTM0TZwYhxxCt11TVEJlHfaTP7Vmv9L83dHxu137AQ -32DqfVtD/gPMvWcH+Es4+bNO993o9Rs6wNfkzzL7uuwueP2KXtGo7VYYls1xAZOBZUuyOlvY5k7X -5kkFbMV9kGrMFFvvcVDDJwAf7xZ0uJ4uJ7kHbWbIMF1VoqFrC8yWaqhZOPqwbgP0q9PY54Peh305 -Pt0Xwnc7yF2F12mYZtnWB1Oam2C6o3oHz93xZSJzFSpbHnQyutoKO5lZUzsb91gYIyquNqbpdmGg -2orCV91SFVYt7K7NVkjJtteNaFgOawobyI4iF9B8FYTAqsKXMqkf0z+Yi+1hSe77/PsvFM+sPP9e -69e/7YB9b2o4KKz1fDGnfNwUtvP5bDJ0e0NEoKWXVHHVLlNdtqeTw1QgPY/OiGYm60vfcqJgK+H2 -cc/Mw/+PuzfrUlVb1kX/ymz75Z5z3U7qqrX9sEBBEVEBQfRh3UZdSF0I+LB++7XIzJFmNUjTOddZ -p7U5h4BkIBG9iN4j4vuMtTDo9tpsuoLpvy+v/y2e9OMSbG8kn9X6+rxvci2hTxftlMh1qp1gMd+0 -e7+O12kLiLy8sJbeuGg3pVjBGV3AyGaa4WIhRwuCYxQuG2XFINWWIEegaKB6MgknM9GdwEov9f7l -IMqe0QZp+Smu0z2wsleRJ11fD4ZEP1DZPYMUx5lG2FRYz3c+CWC4tNZHjeS2nW8vRbvb7qGpLQlc -xZHr2Xq83kmzKmg3fKPbLDULAwqKRyg0VhdZGDkpOkcd+jHFUS8Bpw9Yhi6KGD6Fr8+0ppfbiHfp -POelz2W8fxKD3DPU9+lLnpUNY6cyztPk5yy6d3Sl14LP1n11OiT7daSjBmBTYe2OHGGTtBNwHBcN -Bvnshpu4Fge3gZ5bNDKYUeBmXK9A5ZAGyhJbygeLKQM3bgEu5UNPWiDpYjkxJGzlz7m99xAbv3SE -q/HeFDSm3smTj1LPO+9u/ULfercVcWEjNYPTbdUPiJL72dmphs55z80oAyP5MooAXQAvv23vDx5w -tvsHl4eXJ/SoP5PNw5g3W3y7j1QHl1tn7USOKIPdAbG2U3xVrnZTK9ESoj0QxyXETBdkAersuiYT -fOsg0sDwK8UoLGTjVYtN7Pg849J/JyDx4zcU3qLwPy4UeSP5yXIv533DkZSrhIpxGs9PazmNzwat -MotYPHIbn1WI+aISjBHDG/G0DAs4MSAmoJnZKgXjZRgeyclsrMpGEY9Wk9wINA+L3dCkyJH0N7Ic -fFh/9v2i5vdVQNfsHagPL8ab3NLnqvQPfsWb2unXE41RDssuNtOo/Dhj6XRD2iSvKI1f53WdoSZf -bP9awH8I2cNrtT2uePBF6lPv+FYZf7lWXCZM9ZMjTc0OvMA7bt4QKjwaOWZpEeg+2OJGE0xST6hS -ZWJ64ZYFJsAgokoOETfcamFRvJUuR+hy7ApTt+XiDPxp/tAt7MHHzfyDdgz+daVZN8nUHzOf3mu6 -q9gn211PhlQ/4+21UbvikIMkAguQgVZxmmtq7k1XA9bRwninSMkASkfyqrXhFQytYA6iIt4zZWTK -pKV5+gvVX9KpVc0Sl03gibmAnR390yR2xxoaSXV63ZNXZUbO6wTxd/umH+WP/wftoz/5VEZ9Gpii -wCyuGZGfFDdQ9zSQ9w84t5T3V4fXB/SoqII6u5sWucW3+n7jAzUTa/vj6MDXOdYFAkyvE5t3ML0V -/DQqJoC43q5OK8bt3kBLyS9MnvYm4Rxm8MWSJQrOCDjE/TQf+3ve62se648mrw+xMp5Gh9v557Ub -DP15g1j9ZmXxZhnxhZ8M3WSdnd3k5nVZxl/jHn/8Wz7bWUDubV83D/jVwG4uX/YZeiQoOXQ834fj -kOZGmu4RNFQn7bScuxQOxXgHERKX6zmtT0LA0/YCV7D8yFUq2W3UaLJwnREbLmQDgWfsZqmuo62+ -6jrhU5DqjxrY7xTfa7xPM/sLSoI73Nj0gr94/rhQD/QpOVcF2ceBvcqldLCmq1NH3M0Qv6GaRdsO -GJ5ZBmESTahVUszKkaWEJdR03Rg/zDJjW3nJcVwIW1nJXWS5xGXXoJC2lB9exf83ek+FEcef4y6g -dy0PLzLPhrkcDK9ienANklIzCIKyUO2luB9kcByy07QWY4BhbIZdQOOpD+FNsM5kdbdvxxNk1Tqt -HY4O8qA5CMh8s7IL9pBIpl00mUphaLnyf+g2/eP6DmEJvEQasbdLe8NMi+rMzlkV54DJZ+Bbnydw -v9kCgi858PckJ/z5lJ5wyU7ohdLzZKubazc/5+P963uS9H+JPTWNXydDuF9SvoVysqvGgG1amx2h -DqBNDtLNqOPmAySpYJNtQKxxW+U4GG+yTRlUXqx427iDbcnedMIIwimUna9ysQS2R1VZpMd5Rf7Q -LzsDgzenofwpzIfdMWmhf7ZXm32CtPabLPlzGPM6QDzX3t2BuPtKyqOwdm/XpI9jwnol99SKXp31 -Zb6CrPHCbmbwzEj92ERKD13GgiEyTT1CyXKbBNhUbeDxoRyR83CynguUP3BMSMflrl5OHdRfg+p8 -tMHJII39UE0FNY9W0n/uBPCyN/BZoAq9x0bphY3jenAJVfVgzVzDqumaDMshcBM4mc6XYrTeUAN7 -vB3hjegDFXDY0mhVL0Uh3xyBBDkU0IJTWinoVoPjHo71MhVpIACIXMPnQl1BFfTDDv4305n6gedH -p/+rP8NPu83pB9zjK70WfTbNq9Phk8weFQimu8k6WbTEYiXG42bGDGxfB5zAWAmVBcvMAJR25T6f -IZtQpgFurIAO5e+KlmRHQGSyB9LTO4rkrLG5MAC7zGhjJnp9yKS/EfPuF/L20yT9NCvhJAW5o92f -RJ5Ve/oYPsn4vUonuT7Lt0A728/iOkrXRaJBO1afIG5eOQMt3Kt5Ki92ulWogR2oyxXqigo/nW7R -qsx3jDAY7LVuE1cATbuKWncYATjKQza+8T/7AfheQG+uCTPFQ8s+Xgs+6/XVad/CDrkWXXdEUsxy -I6VbcCNMMt5PME9HAh5Dl3gi02A3gmB0sdWqYxhzG4YPOJsUwXaws3VwRcloRI89KPZW5IhYtZPl -pr6vrOj886/FqPDn2xl3TYm/BD9p6elseBX4ey1p691epCYbma7Y7OD4hKhwuBKGRbbQFgtt5nJ1 -RrTrLaJmXBXjhJt21HSs6YkzrzitQjPxiO13lbewDqMkWHAm5Efsb5OZPwWTe/UKr9Lj/vvfjYN9 -P9Y7/HbX5Q3ILvY2u+yGyAe5qSd4iwRP9ITjfN1Kvo/oD9+Ltv4lon/PHJaG39NFF+QVkGgYKwm5 -lKWIsk6VpUbNwHFizvJGIDYHYF1YFHzk6e0O5SKxHsxW3AYauxOuIqHdejTxxqxhuq7uzLuf1hnd -aeXP7Yh+XLT7bVrmB+Dv92wqwHcAONG7aHw+AuBE+5H5aKAfTlF7svIpOsUyUEzlLc5oedWMQv+I -H3hsvibpGYZNB6hHAejBnLbQaU5wFVCvrWjuj6d0sZJGgRiO29CYk+6q9R/Kw3Tqt/C/EX3zKyv/ -nn4Bvivu/Dv6Bbhf5Hk5Z9dMiDfgsjQ8prH1ZGUvQCsRXY5KswVOWemA2BWmu5oUdrbSFowagnCZ -BTgDLYhm5M+lYJWgI2UKHGcHvcFwL542/wn0C/eZ8+uUcewu5+wzfgWsn2NmeU10AKCAkwIuUSlc -1z156ZPt2nGqMpkF43JtEevtaM7Z1ADYLPZ8vlq3gQiQmWKTGl/4+mTtQosOyiE/r7V8PGOw5q/j -V4Dvw6hEH9PB7yRQ+KpNfBX2QO6qYPyIWQHpV7WI73dCpxphNK7zaCpoOtQQXldGISWueP3Ic8ER -KCY1gtUjqBGDwV70pWbiR2hUUXUyojST4hfJltohwI5GBpxPK3Oj+euYFeAezAr9nL5HNY/v8yB8 -2jh+M5MT9wHKfTCTE/0C8utN4c2XnCqtpxSFbtUugro1WnfGYYslCwaLa9cdyNXGyBfaiBZQkDSx -XZKYC1plN/P1KKtjqsGNYk2AAaTbEqo6yxX9f9VM/hri6TP3HbpjYfki97KwfDm7OO59qLg4U7Zp -fWAqdpyitMrVCrhZBKsjufC4alCQa99bbOKoCKWwgiRiJ1OD4zqyHJjEqBYVFL1o+NJw1vk4FaS4 -WpHZPJZ+WhN0TaP617s+HCT+qZdfEcz+dbvzeUF9qi65M+f+nbqXe6CvcJ/+9S7TqkoD+2xfN7iO -AP+C7qv7eZ04/39S0c9H+c6P43l+J/2pSd5c68v5fBCoFQYEqmtHFEbzg5nWqTVvaZWNpu6hKpYF -Ml1UIty1I8pMRJO1M6QFoaUvLZLQJPnZNkBILVqzSMzojeUeuqZWfoqfd3mBF2pg4m0KxUv8EL2j -VKzX5vMb7MrPeBTuGEheSz7b7fX5hVGhD/6+MDJws0lm/qENIXS/22OL0crCpybO2KVKjXfWMokl -QUmWkCYUrgYeR4eqqlY7tWQOYbwYJ2SRWTM3a5RtMmVCi8JE6YEpEOSf54q8HooOrDQ5DKOgcj4t -tyLu8Mh/iT2p+NfJ8CLt9/rlBT078Mfw5E7pa1o1NcYS3YkCsiuD16sNfhgci4EsZwM/V+dsloJp -szNavOnkZrWcmRvzGG7LTGrqcl26WgEGro/WPxysz9wzxSvymVNTvuCH/vE/f9xHeHapCPw/s2Yy -cByHwNAvEmS+3/GeZJ7bw/XokibTo7PZVpf744MOjVA80neWlo8yYcBVoixpNi8ucGDsYmEJH9Na -LfMJweMl1wYVPxoQwlaAKcHWl/OpXVPHOVpySapJSX5LdfaXr7CdIv2l9z7AFlXhnHT91XOapvnz -6b6ry/bNZ5z6ZFlHFzSMrx5zFXsx4BMkwmNRbE7jblo4D52dryLP7exy0HceZmgPl/YsuRmsa2le -FA2oegUxdTzdruW6DkmgCuC9srQG4RGy45YENgsrLHB9kuTYNhtvWq5pDOOQj8FByKtLwYnWjyEA -6TNhBnHs2IFRfQVEf4cqn6Wetfl8fIl39VCori+5qsvH4WJMS63mbtuaIzyKjwDe3MRxJHmwuBWW -U5Jt+TWUe3hrocdOQaYGy9Jrr4TMyj22OYRZgRpsCS9UdHlyX7zrlTv9uNSCZ6Fn3Twd9k0v2AOH -iaGjwDYykM2xE0eHtbTUtw4/PeRLoUpyxq6P62l2zKTdkS73gujvYGHAJkygiNRxoqQ854iZLrQG -am+dHS/lTvOZanhl9JVqXgN2fhIJvCfD6pfcs35eToZXcT2644Qru5mNxZmeIYWAh7xNj+cLL5up -AhQm4fGw5chIGGjd2DCpGR3nC3C7FMb2CiKmkSeY8MDxV97YItkqkefmZESL/t/H4x5k5xf+InXi -rmzxF6kXnT4dD6F+ieGgwAM4SLRpq6zTKTEJFxDnKuY8VcGBWa0DKywlZSNFPuDvuv2CFLJYdIl6 -26w2iDww9jtcBhqI3EW6MmW2erBVV8tHkUZBvXzVW7T6T9Il7mmrrwSfNfvqdIj2C1sPVl4wOIi1 -utjPOrYNRKbC+IhLxU5ICuzoz1C1zI4YuVn6DIdJKb/bc91iypsMXU2bo0Z7e0yuEltblGN5gUNA -HI/zRyj3AbtB9xZPBJf1cByUzheQG/dZ6yr2yVbXkwvGRh9A5UOW8vj+9BIzMXFCmMRsxcOTGho4 -eN2WxHGCMFs6xszT1FV6s8WmaY8ifsSDXUB7koyuZwg4i5n1ssl3aoNsom6K0HdOS+XXNUfoXSvc -F6lX9TxVHKH9Vrbj5EjBCz4Z51trP2HV2QEnKdmUg7XCTkcS0Sw1h56b++WRoqhtlq9RvBNlflIp -iwgORnOoMeid0qLgwMeohQawp7YN/IfXvn4CC/YZ5NFdLfrdA67Ge3f5AoHUo5XHLAhOkqOBsSyD -jEtw6opdFO2OJlPE86WOHNxNGlI0tWKTtVsYlQQwljFb1qKf7P1QP5ymT26/RbR6mlf0JFuvYi/i -pP90O14QuL6ozbzHdBeZF2td8b2gfsOQNvd8frMQcXYuHVPi2MSWBy7itdZthG144B2RRLowAxt5 -vI7VpBBxgnQl0xKYFE/g0YzlwPKYTgCgq7zBWogMkqLn9w5DTus8NNnmIvGik9Nnb3iYaSvOMypK -hOlkKiceJXG+PBLNLW1pWYJTZaxMrBxxEbwNPU3brP0QzfO5uZ5HOaGUIckMXF6C2HrETng4EspO -cvjmLqc4TD+ds/DzpsX3B+WzxJNCzh/Dq4jfK4TGFquE8EiWPk5UhD/K5WAb5KSAJUiXbRUCE7GB -IATa1Fad1s02ArRfoTsxJ6RkPRmnYoivZ5BdWews3OBgtxvrCtqvBuXeDpkZycHo0RNvASge1xtf -yT0r+9dZ316pBKsDQGrZrt6Yh7kiVuuxSvqsW+w2HhBPgUQDTDQFR1tTaWtI5aXV3G6E5Yjv5pI+ -0PjVEjsUcx0JyLzKuc63V4qq/HDj8fQGSR2bztNq4sr0BPbVcmn5TmwMq3RYlQ+lPnsn/Vnjr6/1 -JT4bjDceGY5mE3jNJllH7JcxQAB0a2xTQzZDjUHn3G7eKbtok5BOOykRGl3OZzKF45Z2UGF8QejU -etNGg1nZEPaRzoX1T1ku/mEaphMBRZ1UQfwSCCFvsyNPr2hEnmMWxk+AQvHvWrMwzvZzHt953jzg -rU2fLvftTguRBFZUguih7vO7BIrm/p4z6NF6qcqSHm58DWVoQE6WB7I9eKcuk9E6xS/RWJZapYXk -KEWr/OjkJlguo6I2lh1i1/dh2d+8Rpd96sGRdwGjvpP+VnHna5foUh++DslPdds6WIgGky0xIhix -RFfYYL+IPFWVHTiM1TW0BoCUkcVxkXeQtHKiWRA3u0lKTD1KW2kIK2kYk+Sob3IdfHCqXkkGX6nv -GGSfjx/gXQPISeRFT6fP4VXI75XT6uODY3XrbDIvcq447AtVSdvWnfEYPSVU8ti2lWZFWalW4ihH -ZxJMgfMtSW8wi5h4SQFsgVQYmJJo5gKcx9UeyRafIiT+r1Ob+mMp/zFZzc+7nsO0GJ4hYov/3Wf8 -iK7EX/9C3ibfZMY+fQm638RVP4BU+Nc5dwd/E/1/vdv7zDrWYwRpjIfmZJzknc3XGH1zMHyZA1E3 -n/ErkjbNfY4thMkCZMwCmbWRNMj9Xe3qWgGOD3UodBSyG5n6TpyO5yi7rFJbMUebdpnLpKhAlU5j -fpOP9PEPR/lrQO+JIOYcFKmMM6Pb84j/HpnkY5CC9xgF53jhq3DhP7GeyfFX1IHHbQec5F2sVPbd -AmAFHhCBLl8l1kRVfRRtj+CqVQJb5wpgUIAZTYADj9/64WHgVETXioMSprYDbTLepwc5dSUnBt2S -UA8uOtjGtN3Jdv3D2rdr0/2Ao+xeLe9T1/2KUOP7sZKLxJOmL58Xv6dHjCRKcNDyWRNJiXENGV3Y -RDjDBYsF1OyEAWKtRbjZTILpnD2OtgBnr/kFxMqYthk305yYASFaKUlSTI0pRjMKxC7xAW7c9Ajf -KPlzo44i5UKq91Q/+5AlQBScvFIjM7rLKkBIzxtx7Xvv57l09/PS4X/sr3/7pDzbKJogGRpFjKPv -DfLp/W2/u93CcczS7i/++Q8CA4G/c3/P3xMFSd32/zXX2/v+luvdUZom3nfEF0FpHb7zBz3f9ZyV -8B1VPt/fU/ypFSBwf1Veb+/7W6533/ySHuNMVzpR9zmUMfUKSL73SHOReR5qLgfDq5jfDzZpagwc -xWQWq3WKiJ21YusNFtpFK9lSY1cMMh8hPopwgS6ZfNFhlQyOsGg8IRzHiASQRceEHhbJcoWNedUD -5l0oi9tH7AnCfQtlry7Vx2P2PTUgJ3knNZ7+HSL9qj1UIxBnR2cjR2wdHum6webpfgvNMcdaSNud -4MbdjpoTzXhqAhnmVILR6n7qM1bRgOzW7AYTYEFj8EFWFugCoex2SvPND/cHbpzBfyE9ncFTt907 -dhp/2jTPOWTIHRq9ir2o9Xo4fJLVw/NQgJTK00rMjtkCFqflgM+BmaWly5DkDKwJpG2xtrnsQCeN -Pgc9HNenU9WiNqq4xxM6YqpJyUkwmjgDZZscEkOCOeWrHcA+KI5lOTz1MseqPkZdPX2fPmOfYW/p -bm+KkZ+ZXt7c8asO98Is8QYusfa7zHeSpwfAP9tc6AnkYZ138Z7ZLuF7QDxeJDwKwiNKb1yR25Ih -5I4F+1nguY2ePoYXCT1CKgva20GTuFv4Y4Ku82Q9QQBNgvGUwMHBbsushHB1qL0lOUjm5tbV8bWW -zValwxzSzLS3gzzbAZGgJjFrQXNnt1UQie6Be/W5VmKj2H+6kXGhZPj+5HKVeVLN9WB4FdNj5xSf -WAd6PvVwAU39qkZZogUNiM59OsxwSyMFf650CyrXjCw5zvZ1qTHtTrZ4laKdbWk6+AryhXFdKia7 -PE66rrYcvFf6lBkkt63vRS3nr57e47x3+u1UZbjPnPQetPRxCDNvZF+scnOlL9IMwOuV2bB7bLpe -dWzTCTruT/ZbvRWpxAxxlBkEkTZLRoCMM2A2xSaohphgpplzYsycFhl7n6GzzJTUyMU5XI+o+bSG -Hg419oWSzzPcZRet+ELB318cv5J7Vu6vs4tieyyWuyPSysYEBi0cYJbHwzYdG5NqFU9KqyS2wYGv -diybO/jEbBbutG5raruIDwm7F49CZNOTLQqQYCZbkrxT2MTP6z2l19KjOQ3+T8ot/ojj/XGRx3fS -L2Z9c61vRFJJ9giEapjRcXM/Q9y9KrO1iW+qkHFX9mh1cvwSEiDjOqnndbD1S5rxGG1Tpkd6MhA3 -oqmxB8u2MjOgZKJpYDiipIdkTP0bg+hxEJ90aX7aCzH0HqtdhZ5tdT0aXgX93kSGirGzml/Am7ET -jyw6gw8c42ZAjLK0v5kl6kJRGjBoSwLY66aNr07LYDZuZvuFzfkMaWwqqJzCo7VezNsUCOiJhqSP -gtDC+6rzGc7vcdy6v8Q+6/Ry0pdNd256R3sP+mhYpxLljgR9g5odqM7ycJAslwVPiTOoVEI04UmD -h50UyuODxAYOqo0hLyoVGAMTCJuXm3JbjWovUCoF++EW4K+GdyFOQ/9KQr6/eUQMkuA0r38KcQid -bYbf0QaexF6awNPx8CqsR1laNpfYcqDNRwWUqCCjKyARG9uUa6IxPQW9xJPquqpavqmrMceK0xw2 -I31AHjKvHdsCMoNWTTiaBU5GEMugWu/QefQpAhoT1c7S2A/fBC6/2LUvDMsZnlR85qN9Ytw8b/2S -32wTEHkGPHxm0oQfmCsZlIZh9bV+ZpSflzjfA/v7LPTJ9OfDIdEP3rdimWk+TvhUBKBCF1no6O0N -ysMlOLLS0b6dzmuLWI5nGNOaK8xGLXiHWROv0ul9jVEwCI5awg7q6Xq5dRVmTCZ4HJPfNPxvl7Rn -e0HoE7oo0VPLxygwv9jyB+/S8lnok5bPh5eN/x7zlrBrtynEqPvNGF5r3LwARSkVyYOqBt5mjMyj -MYkYAIEx+WiA5iw4NSEtxQ4Q51musdAPrn4sBhjrS/ipcQIjgwnCddT8dIR9aYnPNZ93EAH2MUb5 -RfrkHY390szLS2pkjwaOc9GxNtfz3QSZwQZwLtSPHNYPjzmWtt60M0Yq1W31gzUvD6lmTGc5UGKt -zuOArq/w6kjIVEsvq2miLIFKrzhkI68j+q6khMTx0iowTj7pQ5eNv8Se0W1fTvouFhfiipHFmRdI -09C0ycyfIJpj2i2630FTCIYKM8L4vZg7y9Lws4qhGCEFbCKdIce1nq89w0tgcxMtFH3vg5I6ERFI -3v4wTHtGND7XJL+CtID+7/EAXhns5vqbt35cxvFrwac28vq0d4ZxSKgrnQVDIzeWZb1f7GSVddkA -pq05MQIOTdxYUw1cUoSzhFgoa5ld3YXRrmix0lkbC8aDVHyQIliTGQgmuZY1IIy/dXH0N9v4A5rw -xyVvvZP+jGv9+lrftC0gFHapmDUgR07kJkIBZy4vVzRiuZZezelsBUrHeayugWm9Gu02HUPwW2pX -iI7QwEsg4fh8JTHIShMpYxuDHALBtD6+WVSdOnrhWMYTv7ZaOn90aV38kUVGdU6r+H/KPxLjrOM/ -xkuRff75fwRJWTmG/X86L32Phz2Ol/53nQG84Zj+TfP8CmgduWuf/TOgdaTfnrstMwRZFgsgwr18 -U0eGTylF62yT1rFtfoKAg8kyFwBqGc21bu4h01VS4Eq+3Kw3S12QmxHsTLaj/Q6jFota8Q5KkXnL -nzI5n6kE6yI4Z7i+yjxB30aGPuDNvUFx+YiY+Iki5yeI+/98Atx/Qt/H/2Zi5lftqEejy+JhUSfD -zPiUFRC/bzh8Jfjc8F6dDvF+gyCVJx2xo8alpJLLGqFYuVyp6HInRcp6hRKKLx1rYYevZD3bziue -8yJgzDJbVheig8UaA6qaapZAjjgS2sIaAefGzt/8sOldfv/e6T5ucJdioSIZxoZ34eg7RwyRv9JJ -evzu4o3dbr559eqPKyV8FnpqIs+HvcsIDZntspxo9yLBFq7HdzR4HDAhSk+ESFTsSGLh8DBLcb/e -jCHW3gtbbTAB1miSg1uWgw/eek3uc5ETUqieJhQGFqgi/WcXfCYnFVq+Y+2/2Mv8fozmReq5Iz8f -X3Yye8RnJjrolbY50UZeInumMzFq0w0zRu+28ma5HGnO1gdJU5EO413eHrHE1ktouXbpCvARfAK1 -B55Ct3yZlTxYalxOa9RAlh6E5memafQCsnRf6cBp1Ieobw/w7zyU32HBvej9W2BwzxR+5Rle6YuK -7e+3iRvJp3Zxc36p2e7RNoqZt5aSvZpMoZJryG6Na4qKHMdIuYlrvNz5fOlsSU0fTOQaWeEcwdWD -2WKc6u4+YiNzPlMSC+FUaao5qKVifjhgLPURK5g3yEC/VfDJL86uCSqf7CEgd8Bb3Mr+peOnC8Or -2N9reYMTwTxCZzCrs5O16TrTkesW4dgNqsOcXnigGulIw6mqsm4pWNBlzvHEqap5Ss4OmoNPmwG6 -ycOJR1nHrlxrMJuZTvOfS3JyWoa5QRKU/hdFxOg9XeKX3LOxfp0NL/J6pAdq0XHvIeyC9kd7+Ggf -CH7W2ICkjtEjLLdyk+2tyZbMypFmjba7RY4220Tb0POpODCLqp6FzmoTbDlgFMX1uCBHPjbY/3Db -xzn5kkFRVr8i/D+CKPzKKtbn1VT3hDTPAi92sM7VUr1imdHCmHn8AJYwVZaYvWWxwnQtLVeGbqtt -stuxkbTebUGRU+naYHMHYgeL7uDZR8Dgu0WA7yjxuMTsAzQlE4wEJuw8QwY/TH9rCiPLLj+y14B/ -EmMEn0Yy7oFdv4o8a/JyMCT6Qa7vzDFzJDmFIcUD6XJbXj0c15xoa9ghohAgtaoMEu1KgCN362RK -5h4Ap4md2suEI2A1k4pT2sG2VkV00WQ7eIVh22D1QJJCGL6HYusfRlMOS3sPWIVzwe80ojP8xSE4 -0+n+Eo78SREn+X/8z8168x9lfBq3ujMTkv/qZvS8Rvjjf7CPbr3AIlZ14QwP6PVu7NyU//ifmzzp -J5rMJ8zBV18cU/uZNQK7LE3R+zjB+rx2v0zD36jjbiFvFPVtOU15z19d9fuoHMvLYj4yms9mJRDG -7wItepb71IfPh8NnYT1QizQHxBFoZHv72bix0cViAjFGw9sc1o3mcLkcrKuSNGKlagZT/CCo8joE -BbRYGujA57LZHhonDTbvhAirmmOjQ1pFw80jKmS+qBy+4KdaUXD69wLUa6URcGq/72eTy80n57pI -s8Aansa5p7vOKM5vVvf/OCnutAayrnB5FznIB9+f0XCy6onQlngjwjGK008OomGTFvvTmjoYVnVw -fR6J3pYi/uNKEQt4TyP6OdDwpnv/4qM8LdmT6zYY/DbF+RVpZWEk5XnT69Rpz29cVdFz7Rx8W9T1 -Dz+NHbMIbM8BrMBIrzchZ2Tr13dFne1E0XXHKbs2mgsM8tA8jSB/QrcjWnxulkZ0UvHL0fX34re7 -cv84dQcnugRE2g+Mh7y1Spwegygyntiwg+ip9Z4R8m5vfOkGTw9+251u7nFP453hOs8ArJ9IuqAN -R6dp5nof8idxO4gH0SEwhqnddE4BZP7pXZKXgf98++2Ln3qtVRvA6f+hXQSHq23AP+E3wNLGeY/p -iVj5TYOwfCPav9+0u3yT7gPbKD7kLD2/S2a7z7/qRiUnHzs2zmzxF/W//9MifWp45xXT7Z/ages+ -M7e/Ab+vnORw+SPiT/RzHhzy7R86rWMZHz/sOQ50eb83zdkNIuclcAm/w+J+ob19y3F7HptuSfje -Me6db0nLMy7QaU1yWpq56Qt51y0N+2uY3zeYvuevn1E430BunisvT+p4z7N6/qJME+z6DfyGN/up -VvxtYfjpq+eyy/fFVi+FUm+roi4j8EutyrvClKe8hef8qbfJUuevy/epBc9Et85piBlWz8MlfN55 -f3XLizv7xnc9Oy0nZZ6m/ut3b9psNoyN7ENlZuc4z8l5Oevu6WVu+2wWGV1TnA0+/DXQ42/a06ml -VVU3vL4X9ba6PC+s5+Sm04++6eJ5HVj7sBw2RvlkhDdvVRintlTET7EI8Cbic6k8j5+GBeJP8tZE -lVE86wm+RZovTmu4MjjXSZ8Bxf0nC2O3r1SVUeo9bQe9qYA5dxwzbV/mAOLtl+XzrH0ZdpDbHXE7 -sIKnwepNZ24cc5jV1x+EnEZr4u2Xr37504/G3zS85mmYgN80rc6Io2uboz50iK+ky+8c4XeFDK88 -spfjP+M7KhlOg87pP+SP/4GRp0y3k56xsyN/dcxPF7A/P9xG/H3tbplfkL0PjvXcoqn/6u9s3m7y -f+BRfJYa/v00obfCT/7o9eCSDt4jcSix9vG6hOzVxtWkyhEoq83bIzsAY0iTD1E93zCk6nHHMvRw -uEHyyl/NKnC9rWYMa0+IpWMfXClHDwlHdyweGOJeRuEfRoS+4Pv+dtjnK9bungvUX3PZP6G+tN+/ -awqf+Y2Pgyb/zbNODeXD630BzEfZhgE5pJjZaiCUOUHCuORLZWvuArTJ3SNkWYI+cIsBvRwNUlIg -dgdl0OQ6WNZKDUmjslNzWBxni0Dwuzm8W85UBf1hrp95eYXkGqu5L/jwz4c3mJ6b3h+3l48d8Y9r -W/E7NqI+esB5CPl1NrwI/n17COsJpm18NKeDw3FNO+LxsKXakppusYK2CphFeaIKFGWU7mUuIHR+ -N6JrCt7tlXXJh9ByZTmjwJ0jVuZWzgrJxmsKkB7JHoH+yBLnlOzhSYFO+wXJ2/c76S+xJ63/OrmQ -vPXohHk9k/RoraiTOTyfUoqqp6TWlFu0TI3E91J8vlBiEmWhOWOxZIkswdOaJJCPnUwdgd1uJkbi -5oAQ+XJpUpk9i0SVFR4CiEn+TNFl1UVfMF3eUxX/Su6zqq9nQ7RflfzRZKhiNKPXUGGGgTY2YT8X -uOliO2+9ak8uVLndIfyuGSMcvqhaU99JoyRRAmi+bwf8OPXtVcRlMAw3Gj3nfWc3kxT2xwmkUVqc -J8qTeqpXWDLfnSXJB/CinlbJr9X6vZjqx02hTKDPwcaxuwJKTzLPTeB6NMT6BZIGPACg1nZlWRo5 -t2NmHujkaHtwKSVDDlJZ5DUsLXTZKsxgc7BaQLUjLsjV2ezYylLrlbv44Ot+glqK4ChxyoWaXWc/ -9JPM5Bk9Ef2Ka+s9wNB1cRmdlHPeoCvL59YDvRXzlh/mTYbydy36/IM/JYX/fkT3IvJkzsvnlRW+ -R/w2CWXIHATtBK7dw5zaJdRskjibgYlNNDzMs223WmUeKmkVASMmtp+tJqp13Kvdhp1STMPSBKoa -+9kORXiUG88ZjrAC8D4Mv0809dqV+SRF+h6YlV9yzzp7ORlexfVA+J0Gi5HJQ5FgRyhaTQp/4apI -VGfgOgR2jDhjMADemaeeMFrV8mhJODYce5aAFhDRDQQGZt16W8uGFjULk3aMzUTJzOaBirOM2Iks -41MYSexmY6N3avmz1HNe+fPxBWOhx9Axh0llzUAEmDQbBUfUsIrYJYvYkS2dHJmZvtsveagWOffo -IoVcrxxvakydsnOcwbaVBhtcOchjScPVwl7aciBDGNLMHpGSgd/dkV9tfX7mDN2Rv/8k9Kzjp8OL -I9Rjcl5LYmwhzQCj2zCbkwEfNI7JEYgtjznUZfjAofNJQsmT0cZgtUbCORO2Jg4CbZMSlGX+GASY -l86gLdGaYpNC61bMflp5dHai7aDIXur4wHvAGr6TCfUuH7uOzttexTXl6foXwP02j4I6eCht3UXi -2drnz740dYziLJKuLglshALAQqI8qYIAq1zrXQqQijkw3Dm9P9JZxdVimdrUlEv3k0Vt77IASCWN -QPxEEwalPMBWmizag3FBbKWfJRSUZ+gKb9gE9iXl95ls/r9v78iGZ//o8j3+dkY+pyT8+pq4c6/j -ftu+cSQfh6d5I/lSlfPqvC/Gpiyzo1UZEkENtCaWClur5KZKlnGLpAwBDF5qa1kw0eMKSxO90Tjk -qMXxOl1YS3cyGozkceYKgIqRqCt6CLmbjgw2EqRH+N6JccXU/Bd0yYT/rsmIHy1Kb37CZ5V26J0m -O4t9sdf55FJp18O3spfdAKHrDWLApzl+N+VrcZetLS+c1HMVqJk5UJvWjqOWujlOSddFl2SnZRjj -go6rkDWbblMsR7mWsLfU0pMmukeXEv1IF+FV+O1Drd05fT2LvWjt6XgI9ZzBjjhRozv/OJoD686u -oWhGyxW7227MjbEg0u18apb1MbUKvEMX+GZHG94EkSWU2+CQBgFnerY4C2EK0d3C2iY2lLfVynsM -jh0E/6SRPkczP0EBuGtQucg86/lyMLyK+b2Sg3ZR0bPEzn2IQDQJFVJbsWcsjyd1kDIbHtQgfr0Q -/N2uXIIZK6bj9ogh1Brl1mtT2QEtv1TqcXJs55qcM5pyWC1Y2LuLdTGtTgu0nuVUvtMaXppk2UPL -tT5K+Hx60l9Rs0X+oA3ZzsXpDo7OF1vk3++xv8SemtKvk8sWeJ8uCyuDDaWfHApaVffBYDGgdgYc -MVGdkNQx8JbdpCiNdiCoEt4IG3SXbjJ2y+wnvhQ2dBiOR/tN629BTWD9PdkctwSHWfTfmmr9sbav -OQYf6Zm6a2Q8Czxr+PQxpPoNh+WhsuxMIUferMvpkJV43TaRZehzmrYNjxN6tSQ3k1Esm0Uc4aiy -aoBwNkYnKUuRhkwUMEaDuuUVAsKBcNdQMnDwpeaLEgfk+5z0P4kE2UG4P2fsfMGld0848JfYi76f -Ty41sj2CgXmgRDGTUwNmZI9oYI7idkOqHYXEUdqWK8VskhjrCiGBD+Iq6Eiho8v9msOPtQaEGCOW -8XKyG69KQgjVQRyaOAHu3UdO3S9ZLh+q7DbxpbfOLjLP+rocDK9ieuwh8aiKrNOqEmiLHlPzeW2j -I5MwYelYSaLKulPz4K+nIGXm+rpNlMAhN0m4oucasBFHxWyHqxqQT2f4HESW+RKZW/Z213yrCucv -qpq6KqI9Tw13N3AnTsOvIybkXWPJK7knk706u6wfe4wsohJuj9ZmsaRBp6Gn2REU22zLHRoP78IO -WkyQtnLS/IijqDZKAXnlJQUETCbVILCQYLY+SiRbI2tbhFDFaBJNjScs/sg2fgZXjQz7c1Dge6a6 -Z6FnnT0dDpF+09xGDeE8ag2pWqIevsoxC6Yma2szGXc2GVRz8riOgsxjR0dk5pR0ECyFtLLJmYqn -FYOs6JE3wdv9TO0030xFZWCGDhDS/9btKzdI7GGdPZRv80nmScFPR31ZNlfZsqFtCdhGugQfQtJA -fJIPsnG9lQOksRxNkibbTbvgF5aVoyCdNAQTlaw+Es0K2lWD5ZzGuZwqaz7jN2NwWSa88tO9qyg9 -4xg8lzA/b1/995uiXac9KeF1AOL+uNN3Leg51fDUjM8JC+dMxC+2LL6/R/5G9smib65cti16bJaP -O26FMCKAbM8lLyN1DjTgcjeVwSgTnEnRppU13Vj5grWTqMq5Rtdcn2UkCnX4FEFpV8pSsJjsA9Tq -+MCttiDuw5zXZ6vqS73jf/6/5/QG8vpxxjcC//x/77bE+1TNTxZ695REvhF+MsWbK8Or4B62cJaJ -sqIPy8TeCm4DEphXkd3uKBEK7C+OVYOgR2bt+vxx7sfMumx4xsOAbpDlNaCNMWu7iTEvpbl1XY5j -lY2FHbhif7htGBX1qVlZ/lPmCXQH+s8/r1lw8KUS5TkB7pr8hv9ob+lslP/PsR674HoWerbj02Hf -xdas4EhFmWuxdbCwhV1brdctC0F3ELbspqLHcJ5i8OokpgvBGRRNAdaZL+9l/dAEaYzwAzfj3ZSv -Ds60cGt7TgJFWz+Ew/X+aSgoh24dRZdt4+GFEjVLP2cPRO4lFv7oGVcm1o++uRSh91n9dnGMDepB -OSqVTTem8oXhhBoy5g7+SLAiwQ6OW2Om1lOaROR5aBKJUk8S2x5NJwfQ3w+ELcGIdFRuHAFVHQ9n -NVyXvH9r7slTWvjHM8k9fPFngWeeotPHEO5HEU+PAGKWurPDblIUibNZGGwyc5ZztR3MoklFVAsD -bHaBvFqj4hZqYlcIK3iAL+EMro/woNxHEbnc7eKZuMidvUPsBXPhSXdBjj9nyZ/BAC+vYEXBTabu -t/X7lF3/sYLhO9a7F4lPtHTY8CLj9yrW4+XGIZxuup1CqDW3tVXaeYPJcooUW30wELJj0UWzRtlQ -ZIUs9gOV1JcRyW2EpddUR9skI33i4sdtM1aPzlTcuK1Rdt59Kn6uNzjr+KzeO/Kg7x9/br28xwVy -X8m90BG8nPUN51aE31AZP9gc6mYx05s9dtSmWefz+dGD83W0j2ZLF4y1dqKYDsJlsBY4O8uuF9vQ -mI/TDs+oepJJ7GQzIYlNJgrRIid/mGuVDa8v8uTuQn+ru/vaU/hwOj6XRXzfvXoRezbT8/HwKqxH -VG4VxA1AGKJ9gNNcLlqhOex0a+U2TJEAsx3cbq0tNa1LAJ8bCqItaUHbCBtvMR9xSrCMIVbRgyQs -x1Fgayoxi5LRAn4kqOoHELjfVfzHmVKfbdhBd+IZ38h/QTa+uXp58R5GUauZRY/RjjUmVbhyjpt6 -STUjNGnURJsCJMDHSMdOpRVq4oSlR2NAKijf5tcjFWrHpsLqHqwLC2NFhqXsaMRBskHwU677rwmn -v9BoUFZfOJbkfWo8XXzW3enw4liSv1cY3HW0TObMfoFsa9+ZGYmabUaYipgmlpbjrlkwpHwca9H4 -TICUWvTs4OR5CNXkQNHGRLjfrNHuUE5H2SbPNzndmuBxRP+VhNT9UTk+NMClRsyw7TQZGtnnCR3U -vYCNL6KfwfFeLgwvUn9vEme/Ex3D4I+KtFaygtBhHQlmIhGtj17SkoZPT6hs5q4BYgChccSK5G4r -UZY3Gh8URTZlhxPAdBoFyKbY2aNALj16Tf08rfmfV2Dtfz4PK3/A0M+M8KpQ79O6jzuN8Cz62QbP -59fyjh42MDU4QHUVQ8coNlAVcBdDU2sm7wO3ZpANipD2pqtn7HQu2UKb1HnEQ/sghsXlQcYlRFel -3cHlqFU67mRIrgjD0f2V/cOUi8tLDy8FwsNLNfpLsgz0MXTDmyrCzii863cQcfLG4R7Vau8KKk93 -/PkDF/giz+uyoVkHkf3pBiR5R9rGrehnw79cGF6k9shWpNFd2ESJakZTzcvBlOGQWQTgPrA4lJh7 -ZOaNzXJoUrcJZ5euEdoOenKBq1mBjIxgOuBwp7F4BsjRUELV46oL7MHovgXIO2U9a/+/P7tn+Aoq -4qXM7+u/qJwrEs+vs5/Y91cJ7ceLnHtKF55knvH8rkdDuF/JAgCQZMxtlFlLRu3o2Ng0zaxnc1js -NgwEDxx+S4jjOazk85jeO4JK5a182NRKtw5jhFPjjGHFmnOtPc3nrKFN1HFr4s1P3ejTy/0AGw7/ -twEBfmrw52XB42IJz0KvJr+un3pGE2SC2u0AsKFbYVIj6VaMjmTYAXvTLxeFQijCjli17JTxZtiA -g+OK28CuAFvLivEha7rdS6V55DSCH7CpLDj4tgJTgaB/vHR6riv/J3wX3x/5A/tc29tnew73GOd0 -frHM6fOy59DHLGiyorU1rYIMNUYwYLJH6pkLEPrWlKwu9RXBPtAtLysLz+ci1CEgX0snCbOQjpS1 -MfR2CfMQKKxHAyQ8rbcOqdDgtvRvDaLdhoAejF96lfsMYXo964tiauwpqcMkItya8KaxnA7jsoMH -CyltATvenyvzpcLEctx5q3LS7DWtAt2dAeZFJR4HMV7N1vTU3Ukkl8QMKk7Q+aYjgObfujOZJd4X -hVB3afks8azf82fffRkUlDbY1oiYhSulWCdv46Ahtkd8LQhagfg4RYAMvGUHiCtl5cYqzBBaHWde -68wgaixLoS+awoqvxS1ZcIZukXGaRtojNHuOAiE/iHa84Et8wv91hzt2FXnS8PVgeJHyexVDlkFA -Oy+o8aUcTnOOGWeJIq5lWHbWqY5GEF1DGjfvNIdZc8bhKCUHbNaKXIHU+6kmZEqh0LA42oPRYqZ0 -+1B1j8Tuh1tfN8lK1yqxW+yOp9b5QZz4lcuN/flhKfU7r+8X1seZ6fLp7Nu58A9pEP0LIO5D9L4t -gOiJ4V3hjelV6Ug/0MeyIiRPb2fbfFWBdcm6pifZbsWuzPkcsA4HfLpiMc075KOa5scyuPBUDLZL -vOCavPCM/WJeTNlwZBb/jgII8PMCCPxP+MHGey3/YwPe4wu8SD0Z8eV4iPfzCQo8WlnMpN3pEW91 -MVsTfNKORd/egMK4zeZeys0trzbKdmTMAGXJ7xp+YVQCJWyByh3siqhrloIKquMQode6yrjtTP8p -9MZN+fUHhaUfWBrqYem/z+H7yPgdRCZf+CjfjzudBZ5Mfv64eCU9ok4zwc/Xy0Yp8gUNLbZYpByr -GTQpmEBN7bkY87t6HowNUZ4NgoqzBzSjsaTOhMsDv5kPCiVfjEcEOh8pXByZgIqqO9SfSQ/cmP1Q -cU/D9ydlEvdUYF9EnnV3/hxCPcuvDWdltuPY2m4Gg5WRM+VsMN2qXDOyD+hcO9iJz3QEyWLEik8L -ElhqB18s6DHHsWOfHE/HnHwAllSARCu/ZBfhkpB0cPDDvvI8H3wwmt0krJ9nzDej4a8EtA860Pvc -pg9KuAsnr4PCGdqnf6wqfVlTQx/fFhtBcpH2XLD0T/hdzz491jwtNvfXtfRHd/x2lG/8wPKH19bz -sYynrvjByHJtEFfm+Kft1rvo2h48dNz+qk9Iye9heHst+aU/XE+HV5E94K0xMARnJ8+wA1ABX+4s -Q4o3eNTp+mm0IaxSZnVr3OzhNOZWM7ZRF0utmgmHeFxQLA+59GyndjtL5oh9O2E2sazXdjH6oS/w -ugL7A4/ww67x98W8X1XlPm4x9Sz0CTrnfNh3SUXVgC5B2aGQqm0nZjuHGOvCAc6w0eLQac1RZfDa -n9OJ1ExFxRNERsbhyCLoaRQaTuU4Uz2BIH1NG/O5qu222q6rZeYhXL/3sTCcBrbgENi1EX3BxPDg -yuSPxsLPaOWgO4z7RvrFym+uXQjmesxj7qRleWLQlBOqLQ52WBZRPIfhpbheB1O5ocUiDVhH9HLS -O6bzEbCSCkIu5bGynqseYO7oXcUN1hq/n1o4gMq8UNTBQPr31wx9Ns88jgT9wye8MsXN9b5k6Ath -ge3FcRcJdWS327miuoWZYuv66KO+PYBZcrFa6SAc76oE0mqZldbp1gF2djTrBjOkHmWuEUw4EHMI -htyAgW5K09h7oFP2ZlJ+nDpfCz5p8fVpX+UJgcAoJJ1sJmw3P6Yu58YHocns1TEPOgifHyRXQLoD -4GpTggkhBGgiZKbI0GxQuJ7MUjnRqjMBzQ+eQhaGsnTmquM3j1TeaxTHj0HTzsCO31bdi9iz4l5O -hhdpPQJshD7byDyzOMjUEhscfIiTBvxk7wPIGKaP2r7cYJ5d7WEyJshpR5Z7bgxmuewIU2ibgQCj -CvLEcl1POHRLgF0usJn+FZLQH0v5jytg2n+9Q8B8Cwv+HWTMoW0UzanPGUWMo++1+eG97e/vjIKk -bvsJvd7aQ+bp0XbalLe33jvUfa6Bv6KJ3Tzjtr29/qZv4wuVcpexKLx0mf1kDvBVN1trI7WJ8BQX -DETFCgsNByoz5qXjCKojRRFE1pfmlV8uEw4QbdqFxJreb/29LcSxFRr87jZr18rqm+rn/7pq5zd1 -xN9qpOXtA656eHnCz+3Z/uXWbD+xZdvfksI40rpcWhNZsvRVqIsZyisJWzSVVIuFaVCtB3sIaPeh -UVg6aTL5qt0Uk0gA5MEI28SbvXvYNF2Oca7uBsx2xJT46pbx+Z0l2/8UO96OIX+JIV894taSr77o -a0qs0bUZZVF7GR1NY6DRct08mUlXp2s726HJxlxNI2XgWVQucdq0pGAhRs1VMhJ0tKislXg8LIJy -oPBHcSZDyohtslpt/r2d8qKGx9my/ast2X5sx290yAapRlOyFWA3SDakK82AmKxzIbV1dUcJdE0b -Bazy/hFlpvzczVhwIwLiejKSXYOQw61ZbIMYm9d7xKsP4nLCE2tiJv1bO+TDbHg7//4lVnz1iFs7 -vvqiryU7xGP5rgMgwsxhiVtJy82cxcn1dmPJuz0jaTSsz4v1arpYLzMMa2cBwDBMvIxRsNLEsRhW -qwEbZXtcZVTdNvIBipug9O+05EkJCHy/JW/3/T7eRr+nfOO14LPVXp0O0X7FHI3QSbKUhTOw5DMc -ZgtlZ0/KUJxtSiPDUnkR+FO/xifETFsCVMgzuNo5h/mg0utlXiQeGQJWK6w33UZtDsq6CILdEfgp -wdtN7fs5E/EtOuenhV/POOe/gw77+zZFbx7/WegTusv0L6GzXyeXIGiPfZQtQmorZWrle64YZVwi -UYda0eO8rg9Yqi+FbOKscWNSFEiKTCyKjjQDnzGuqixHidlOJjtuAIBpyhNCsapV5Viptoo9Inb2 -y+rY32yoD0gpPh5p4XtKRd5Kv+DH314aXkX/3niEL3ZVveXFk6VyGO3kOvL4tvJZaht73o5fTkfd -ar2uZ1aNsyqGVtvxAJ0glKWaMLlvR3gougBtrtzNZC5V3mpt+0j7F9NfvcuaP3frNxwm7/NV/3lO -uoW/ix//hqTjnxe93kUydyvp0aRqb9rfa9qSzwaK788Rv8Sem9zLyWWg6DE/dPD6ULfKbjXuJGO/ -5+TVbipw8UAQtJwPStujgNGuiSm3Ogj6fEUu5E2IkMByHC7MAkWUMtXzRU0HJetCE3vU5hvLZppv -4NK/y2+pSus5ueV8eEMYUzrFExnN9eun829nv6BnSpl7DfmKRObjOuTXvDK9MyWehJ4TJZ4OhxdJ -vzfhMgt41SGtehIWIRKLDLfZDhxUFPn9BlG09YA4sHx4GFN7J5yoXXYgJ6uxS6Ize7Up9wJ5FGV+ -hrfbycnqbUFu96uOBj8d61fzW/t9Md6/4JOfB/s3tQav6uf/61349/NChls2quaTJIxXNVTXCBrW -I6/qNTdQWVj3lpv+8YOC9zfh4cehjL4WfG5hr077YowGjL3DCHl8SJYyRU8YX5zDB27nEj55iJnQ -T41dvhzPTo1vqlXCfhwL9dQIEKvFVp4mFjq2HS8ymKBTd2vSjVUpyuDgPzI/43cZTMRdcYCPM5iI -fhGArTbhQ3hvxHNl3Tb4otyFKdO6SlMmYGfZThlbaDaQYMjCjqt6B2XRYOG2mt2uKnt6iBfaUsJ1 -ZTtBabXqKoALiDGES/93ZDBB4INIFV6s8gBKhS8Soc7uKvmjRKiLhB7kp5nLHU9e8ngzm854Ol7P -5RU8bqahzWElEaZUVR8rW2ppn1+M7IMyQJIJv8hXNgjSmZ/PZACc+/RCVXBgQCgjkyK3S5f+MSrO -jcW+rdcrOdrHA9o9lZRngZekkDgawv2qJmH64C90JDbJo43vOoJfrCsliyAOwqYbfJPkIVgWm2gv -zK1sGwGeyIuzoKsnOSw4PLzlWnUV2hEzQOYWBJaOOK/mqNVLr++mmmeuuHO5VnzXHIP++cBCH8c5 -J5z8wLhfJMERN7STdybBXYT83sKTXRW2MTAD0LXS1nOEW2zDUTzfV8w64Rug0GJB4TvB2dK7LJ4x -cOBRmlGPRlhbGiQ8WQiaMKbzbJkggnZcVOAxLlTQe1QSHPmOPvQXkN15W+NNZtpnWW7YHVluHyam -IR+mnWFvH/Eu7QyGLuL/RvT1HjlmTz/qkTlmV5E98s21rJxtiLEdOhYdcJnJM5CD5C0vlSy+SFcW -BjhruzBNfoT64FwrN36SGog3iOGpFTF8HU6PZbtDtZlGDyZqbcHAnGkeMV730fgzb+lnHhN+R/3X -SeKl/uv0efGU8N8rkUdXRYMHh72NZ+Qq2MpQpdPKkl4yR37W1OCaIdzc0EELIC1Eoh1/sY11jGCD -sJtMJkyFWADDp82k0UBE1phKP0xZ7RFoSRD5byuozIaF83lx3mkGuAPM9UnmxTyXo+FFzu8NhEAw -byMUzpoz+yAvF1HiqS246Gy34CUsKrc1eEwETT1qB7o4snwFkhqU+1XHKuZEsyFuohOqUJ36B1Y3 -ws4WyYavf+jK/uOy3QE8a+lCoP6G2/b5q3+CnzAVPmC7MTP26VegJ9AdJX779FLbt0+vuCY9hiHU -nzPkqkOPO8vBSrSzKf2YZnmjHYBusvA1iInIxToe5RCBI1NHgAdso60Pg8iZOHMIGSc+3Lhmnjba -Sh/xS/CIVsb2s2Hof53jLfRi/McuCsz//V9f6eY0ll5Zix9ZAXkVelHR9bBv7eNad4suKMw4R9CO -lJjGy0faPBiQKY2kmxZ26ERJcJhfd6zPbo2NHGk7eHwQRcrZmWIJyG67qoGVABjMvJuEKF/k4rT5 -Dx9nzjq8iv24DSN3eHDPQp9tdDocXiT1oE4NOmfZcmtgtusWWAweqZWrN6gyYma40nlHaJxFYJOH -kT9mT2P/CpokpaqxczDDET+dQK4VIu60S/SAWmyXaLJZzgf5Q1J+zyvAXvp8Tfj9WTiXuEenL4Kv -en05vYRue+wVLsIDgFH+1Ej3JuDLamg5yNQ+QHBj46BYidQOW0ZxMkgc3wGlMV3KlWzOVocZuKOg -dV1yoFLvZP6QiAMFjXCWX5GRcx+686Vyee90n26j3uPQPQt9row+HQ6Rfn5cGsbOAsztQQeG5ZGt -0i1KFuDKyTG7Edk9H42WNS5hLgpF7r5s9FqotoXvpetsnnS8NY1hVPXzdoCt8xjmE6WZ+yz+d5GF -Xl62Sq/htexT0KJ78N9vRT8r9uXCkOwHB5/LVs3bK5xarGI0N+mRMDDGqcdjI2YsBlAoOGDRYYUi -zY7kTJuXIyLUSD0LZuFEns/TCFkMZCzwJ1urWM3XSYpntM3cjyP1wjNyXnGcWbStKjg4X+Tk3954 -GXBPb3/SYa8hdm85w/N2VXSytfNQitxb0Wfz3FzoS5XbSKAJbFCuAKG8yqZRruRldhpIWZ85BHFp -+6AQTf0pOZV3iViyBugYsLtW50t9qVCWJRX/f3tX9twot9zf81fcyiulKxCrHpKKEGLRwiKEWKqS -FDuIVaxCldy/PUiyPbLH9jCy8937pfIwYw5Cjehuzunu0/1rOEsAxma2EeICYVkY6p74lkkXwq4N -p4cwOTa7tgj94NIbvfi4Wh17pF34G+IXPr8+M7oRHsBpUZfbBbnUpwxbmJysHbtjdQJTE1znAqwt -NPzAU0FaWe4Jr86KjEfr1CiFmC5qekkibDguAmpz0Jgj67aUgRGpbuy/tOP2M+P++cHNj8kgOfVW -edV9bBROH0MBeqZ6Ec3z8Wg6DAnIP+xlNBBEYAO3mwRNE16obas37mrnXE77JRO31C0rqWs9irVj -pq2KvaerE3UK+LHHlMdK9PPwjKptt1iQQFRq3An2v+jd3JnOj+LH/z2NyiKz+7lxlLqnKrSj0Scx -wse2tN67wVX0P58eusUFZ7Ui5FJQ+YUlmBC+xIH6JOxybqerJiPi41mQbWFgBowhd1pGxdmNmXDs -aOeF3jXWqbYWNKamky4v7d0qXC1pOoXMx7re9o9RZVbtfYhqgvduO/YI057I3lj1NBhdqQ1oXadT -qnOQY3TLW7jsiydGsrcKwFSNiJcTL48KHSwQeCLaAmca4Lgg7dPCSCUew8NlQNdSuG9xFFlSmVjU -4px3mNI6+A8mprzfleiTaMHdw5tlP0jC8rnGErqzi95capmleyuL+Py6S5qa76bvx2nvL3Qbt2dt -8iN9BXobrr2/2nMrOxhwWZyZP3pUf/gjXxpWfPooeZbFL1eBH11VVx7xwQ+7xWXu5iH4FTz4tYHG -UxH1JTFg8kAweSB4/1MOgeMUn0w++CPv0RPZ23v0NLhONAO8sDiWys1aVihF3CHIwSmUsQDjxzgN -vbCiRMBoiyQx7ExedetVUxmnvNuD6WRsUWMeqcjZzBj7y4VjKPhqU5jZCgI0ffbFjQovK1qzcG6P -Dr7NyAjzy/M9ZXNckoR/P5T2l0sJ5QCRHcsP86N6W/D3DYPjZa47lqPb138tnADzgn762hYcNZlb -C33iHUsArwBFMzJgs56lCupvuSOB1nTlhIo4d8pZvumNYy3zV/sNwm4m1N7iDgy/2+nsRLATEWpm -v9Va7ZPU2XLkuF7P5kt2TO4Wt1/+M+RQGTpXJyBN3fjuJf1dmYHfuc04GJf3WPcrd78qteaHyRzw -X9FHVOGO8EUp7oajK8UBmJHIelViE/d4PEpdAdb7hS83JCy5QszlG1C1EU30s0TwantfF5RaluzE -5T1KBnWEP0gZd84o4rAX8KPabFGniPx0u3/MRijMi3/3OfTCQ6b0PeFLBfHd8BrDG/ISudEkoaVc -rDlkAZHkqpCrDCAV2IVPyKnuaVlhW8BA7OF5PwPWDb3ZgxqtSjMRPindUZsh20Jbc5kpK4wlVyCK -GZv2e2J42G+W7P8xIYLCLHuD4FL1/2HMEH4gevOD7FWSz4PRldqv5SgViASIq3LWzcQUKdlWB4Ll -RMSLBlCXCGsQGrA6tPskASshjyyIK6q5hZdW75gS4XKt+KFuekHCIHu2zXDx4B7A/KuO0b+VYdyE -5ihz2q5X0DzoTZJ09Cziy4P9fqPpQRD4hdmOrMzpPmlA84iAbkSv4rkdXlvMDBDOCj1LByqOT2rk -4QZ6Wjp7cEyC6o4/nrDmxODgeblAeDAiS2SdNclCV5dniTnNp5Y83c5WNWz5GwSMCwc9Z+slNNlI -KPnFJH+rq26JZX+D35qYFyaM3KLo14LrBT9h9oSXtuejS2XS9XPwrdFYp3mYP7cTf8QfHmqCXEBK -TCt2R72sXDP5BK2YeAgL5Y72EyTK3ZkrevGAPDEiB2dKhGgC5XNuK4dgTCzyQwks9qkarnA+o7gF -o4BssMABo9MJCuI2Ot4/IRpvC1pjfBxaQ+iKIaRCTOoEQbe7yvkq5NMlEFZXYTwKyzs53cs4Ddz+ -QX5oAPy68McsCrN7/6sfhBRuZF4nKJqeO+q9FO/mYf0NfT8h5j8d9+K1FS8N6l9dc32M/lEL97mt -yd+gVyUrg/XnTcHQqx/3fiAYemAiuaN7KRn6MRpd6Q1In3ImikEuqUiLdZyxlievXBDjtFlFykKB -GJiwoTLkMUnEzKm4m24SliSYNC9tOdks5Ywm1kI//RO1M27FKjt0JcJgwIOmzVNek9d76aObsD7x -3yYPg6Xc0b+DSrk7e/XoBvBO88BUdbFt6Z5DelMDs3xqhaFiJXl8xOTpOAfwFtc1cbwk2aBQKEoJ -WhNoZnxXW/XRM9Rd4yrjMaXvmZJi8O1qPW4W7R+JW/NZrslT8sTvc7l6QgO6JJrciAxgpURKMEeo -0Nx3QdkNAMw/HEB4bSVbWq2z8uyvplk2z1udK4IgEwgw946IrUQKSkVR2nqCR1futo0NFBN1gdE7 -WnW+IxXoL8gQNmZ19XGW2kMgmjeSFz5eD4ZCaqfrXaGskonShWu8iAMzr8dGjKB0y/uRwZjz3LA4 -1jxQut/Gy7lwXssRYHPiLC0Xx/0URZkDt16mK8uR5lC6F8+AP9O/aLo5rlX7TwFt5C3uWe68D4kX -XktBXqJ1yM+9Vl/yFy5+Lvx6SflpZ/S53vT3k26HbMQOmd0f2X/6bHYftO1U5LCcgfjKdpJkZTGN -b/InSV4WuMXs5X2EytPFEaKBPLe2GQ4CumtSp6hFKYfgRR5gKMw6pHoy2ddiPdeSvNabZK69Uocf -TtSPyupXJXXPDtUtOHAnpGHxg/5hsx+u1J3kPrhNL/nC7Xn+2X3atv3r03U3rLXfvEdvsZZ1XF0e -+7Pb3MjeBFnneVZU//xTQeG///4yeVGD4nNtmzxsSxSv1e15eEVyG7Ai6kYGr4iJTOHbsAvBBbSQ -xOywPuNR7uapLHFTrhMtlvUhTdPcxkKdJYdXecdPZtSJsSWLZfDG7rZsBNpWe7SlIlSqx6yJ0k2a -DxmE97Y2+gA82IXkFRjscjC6UhnAFHy8okqLWB+yzMhb88h0dSxglBRHpT9PbTtgmQgoDU5HZLJR -MntDLmgWVQrI4xBnDyybGGwx+9DUtsmFCJjX2zB7rAbhhSnXUsrb6JEt30EOVdmvB591cXqA/6lz -5X7q3Fo2DUCO91PDwynazjjbPOwOu/bQ1tThXJ8RUbT1iVytxLhkZhIE6OwE5Lb7gjQ1WU2cQ9bu -llhNbG0QErPepGA1T4QS3Tb4b10PX61bl1CS87Ks/bQoXooHcncUVEn8EgF+/f3K9J8+IV47Nl7P -4+B9qm9c9J9hdZMwcUfX7Z0XMIZXPn5SvlQgvPo12QV7MA3LwH1e5JE3QLyvg5m3ss03PptZ1aX7 -44dNvrSE/yPF/q5lzKPLA4b2J6bjI6/JD8LX1+XH8GpGDnhtTluNTMFcPEq7vRTOibaTilU52Qix -NkHOEigKjHkAo34RbDJhXlaktEG7Rghme1lphc1BqnZNKaoZP2c9kWlNU1oGuy82Sfrqu/G5xfg0 -WT2KvfuPq2RVmCSuE37cjQl6tW/9G1CZL4RvUJkvw2v2+oB1cTPbLR0jJ8r1kYrHGLH2pMQSifNK -XEv8HiM5I+P8orRpSgK2ZbMakyeXkgS/O61WWQB2YyKAyeOeTudHaew7QOGGnDZ70FiorpvcF+Fk -3re2d39N+saquxNDW70v0DWl4WqRE+gqjFErMBoEOxAHwbWy1RFdbhJ9A/t7xmFY4kTnoqopm5Iv -YoGaF1F22ixcPhxrBtfW20ZHNL7VN8v8MVzRfj63+ol71GtiYn64xD+IwPqa9oVdr88MxWGN2FMx -ORu5XjlJwUNH6lAU2tiAii0UMQR1AvwoX0EM4mpJo5VtYi+gYKeSqq6c48LUW2jcGTmm15SO43rV -WDzoJNQXA6XPj/IDDgf+X+sD8fZeH+1dPC6iK+U7AV3H112MAeLBAcChg8o+wTAK16R5JChqi/D1 -iXQr8jzHDUkIkp3EpezCwSy50Jxw0Z3nDQPiBoIourOWA1XptArdjLvgTLiRbUGzPyjv+s0++/tz -xSOJ7PeEL5y9G44GFiZiJ8xZYeelk+/ONFJKLq+f2qohzx628BGm6n+/PEVYodnVjuJ2q4mqzUzO -Syi/7MpYL7akS3NxGaLITC9pRqmDpCm+aPC65b15Cb1FBcmsQ7+2jcK0zPu/z4kL8F17qTe5DaP4 -B8zHJykQT0WOv7qqdc3o/srJIztMyN8hY+I9lnxfE+6fqL9VyPjWT3pQkmVySMegFY4zRdkebFSL -cc5Uw7GwXC7rpM6WtLT0KKoTEAwISLX0zP0GQ3cke5y4mUEG53i6sIOTEB7yyNrOCXlPSgrY/p20 -8s+oHh/X+36DdtxKf9+eGqob+/lhznv+prQ6uNo5GThJrUO1GbttYWIHkU3yXeCm0U4PiJyZ1rYx -hkRCzpAaoRnSjcbkIRf2JTXfZOvZOKzJFUdr269uaZpxPLKy+sUneOPx/kJ3LmX8/aMWvfJcfbtn -PKIB6gX/KdXrxxz6kYpNvqZiTzd4q2ZPp6+qNiA8qYrymG1YaaenbFius+nGPpKssIwmdMQK4yrO -m9jpitRNENOVciQwQ9jvqqBsfSwHoUzOdjFKFHYe0rMDPbGKySya/IlVbdjC+adRSD8140tb1Opb -+w7f0b2q38toaPdh69wZkEsQ7VSAQn5prVIhbvRdoYpUjGACZDEgBWtc2gDTKhKLU8ETB0XZhXRM -RVGyUv0U2mBzj5tBsFwzR8GcrrLiW7AivlFMYWma9qCIRHhJR/sEsuvBeMQL2auQngdDYxHWmmHi -LSSdSLtL04mD6gmlIRvmEBtNN9lsSWrLs+slseewGAOmtBJ2O5pfglzjCrIIWrbm7ylxa3vMcQbm -B/Oo5N6DGZ5lVhe2+8mKfcHWeGDFfiF7YdDLYHSl9msGKQffzOtEja1NEJH+eYfrkY3qmrJDMBoM -VzUhM9qxZ0Qros55HIBifMDcdHk8nCHDOk5iVDWPelrsrVYV1E1HwzSC+7+VIP1dSQ93D/+8L/cR -o9G/Tr7C6Wf6rzn+dHJ0I/9r1tckq8Br2D6XXKdrK40gPKdgsubkyPNsx1BbA5N1rZK3p7WhnFkf -FccYxlZYnSkxW08XRuYAYaoFqww+Sn7bi2zcQV80np+2BS9JMy8rxetsrHstviBxYMNkU5mpYxZO -61pBlkXl97rXb4hfQZZfnxrqZltzS5sai46OVLHcnnEyhvlaUpZZkLSM7DbjLijwJjAZMbaRmccV -Zc5tTcwWd2TNQVyVFDtqiThjeRLMS89FgEZi0i+nyFaX/LM4tF7XL72RjGf2flv/GBMUuzMpBonm -eSvm+3KynoneRHE9HJp9RTWLDkX3MEXidZRuMwAJBWaHeiJUxluilbJg70Rp6BviJt/0xFdLSQ3a -UCdn8+UCVuJJvktnuzAISD3dBobEMmS4bf84xIif0hG/U9HvSb+AyD+fGKrk6VgO0oYKMZq1rL3X -hEUGqNkhpM8NUBIbccOS9nnvip6SU8t1m613YFBBMaK35NwKiXw5a9zFwkkjthO7nThOzluv/WLF -0ntZnuBvc/v/kzN/2yq5wn964cX4Td027l+Ab4X3eYf+Cwb+q7NDQX/MOqaXNoXpK2IPMXi4JdEq -9GcisitZ0jAKYU/khz0AnB2lTdw9UZ8tHe9SLJhuypbHJqYjV7xB13Pu1PuBZLqtN5T5Jwf96dlZ -ZRH80VxzqaJAH5HchehNWpej0Y3QgD2aEOnnXS9ACw2UqPU6EuYHIADmez46Jvl4vvGIhoiMPOL3 -K+zASFm26arjeW3oyl7nDJs2sK6f/cGFRxGiYNNaSKPZ7KvwYlnkpuG5f2WvR0/WC/y/WYj/YYrc -EBUgs8Jtw2qA9Cvz43SohwzdnuAFft68ZEINM2U1J6jmTbzp2vaUz1VCXxzhWNDIZa6Iu+1EYFm7 -XYsCzLbl8iiw5kSIxtkSL2rmnAPLYpVtxf38vGxnzuJwXKvjht+K7IdllnHtCmY0em0BfSb7mxM7 -9srRBUw8N8sP0JLtIGvT4v3OJK++ib8th7l8eu4ttBf4zzfdnuOXrQ30q+APnyhCFvbPX4Ve+Ind -8UhU+J7wRTPuhkOjwRlayuJqEfljipP4hEXgPTiu3WJd5L2p4URKQFQM35iulnt53R5WbhrL2Wk8 -EcbkLjaUauECSwYvUT1YnDGQEOMZu519S049Noi1/Zzxkiv1QUHzA6bEHd0rY19GI2yYKeFsNTvo -gDnI+StCFefYqZmz9JZTdcU6Hp0FtxLNVTae2TuFP7fr3Qqbsfj24KzVcmHYM368I53KU1pY1Be+ -WKB7scDaLzqR/2bd5q5x5Z6qa8sf+7m1x1tsgQ8n5fuUcdd1cRS5SyR7pEUE9g82aRcI9mF44qHW -IT3Ba58aBBuBw9qF8LC6KevjHsPiHQzOC423FocTwizaOGvhBisKJJnbDZYXqdcGMggVkd/RzkHk -Sd2ZWgW+zrU9BCySAIQ8Nj1OGMcv2ofM0KocmbHvWoX5rWknP8heWPMyGJpsQouzgBfpTRG1ZxwT -cds5OEkoB+2mSw2dx2RfqA8UVBc6kvEJAQr1NNs4ibVF0HVW2StByzq8lRM22tILbHOyisD1HmXQ -bXV5nzfEI5P6heKVLf3f0ZXGgGl8SddThJUsYLV3almR1njbkzymXrIuhdk4nQWYhS1YsJ0vshU4 -TkRXUzAbblfUnoA3kVCz4patZG21UqZTjjTP8njyEUdAUqY+Z0nmf7wlAD2kLz3JG08yf3QjMgBw -inRBereKtrnQwJSbMmF+kFTJBXH4wDuQLawPcKp7+w045sXJtJTOM+6ERV7n7XalJITqZg6QQCUX -E2Ia81pV4+w8+R64tS+7JJfWbWVl2tGtz9ONM7/VnOEyod4qSD8qaQAf6pPU03xqktQfXQsZBojK -M3W2Bc2UtOxxpNLwmd4t0pNMCzNG0aYMbQlkFTSUsy65eJGpAi1UMnj256Gkt1wZrachoxlrOJpp -FCFkBsIkm9nuy3W2/Q9Nq9HzyvNzDuw1AfP6efE+lM87mdz/d3Jdn4X96uQbpn2fat0T7vXrfjhU -yZIDrojaAjyYR1Mo64g3tsrCW4STmb3G5+OmTVqb3YPCFHcFaAHlJ9Kou0NsFCe0dHcmT/qQggEZ -jLa5CaOSZ9sAbv6h+Od/vICt7PQJ7AmEPzRF9ESfpoj+aHQjNKC3CCiWsmnsoZzHc87bjPWFwhr8 -riG0CQRAYSxmY5YHMKairWBuSsG64LLVPJpFNtlyjdnP9Rwwy8DNaQOF1AFlYVkIHlv166DLA/dj -4OFHEpefaPaMeToagcNSlY9nOJvOWS1ZLkWGdI5n08KPM71WiUhiVvyizlhaL8h2jwUqt7HzWXKi -1lp2sFmPLqaKDIkudlbKdsEtOWvNYRDo1cfZQ6nKdf/7iCu6wKh3MQrz4/2kR5CFfqJ+4dXbcyNo -GMZQ0axkMpyj5+N8HlLGNJoJ5dmwqcaZsW3LrZYMDOvRAYGFla2WaWKT2zU41XcKkgouaxD6xMRj -aOPvHJCQSXc6I6QDNvtzxysvd7HDD4GNoUdM/RvNi6SuB6MbmV/Lh23iinVws1lBsMS142ztIsdM -WHfZXs5M77icHHShqDZbMrL0HQy5ISkRAugG25URLoz5ZtGtaYnnZlTuz9U56s3Wjf4dxtukX22m -g/ZAnp74s+gE8RB21D3hH5y9xSeIYdhRBxhHZXuPgU6WAHok0py3W9tCKJ4ifmzV7BllMuuwDsIT -Xc94ky/h+TTuzapCPboHX1OXOGktbVrPdwslkiHGJazckB6bTNPQzop0lJj+h5VZ4IN8uqN8ZdTd -+IrONIBTgESSGjlvQs9GMa+06pMhYXLY+07How2rqnk8lSjhN8vCFmqegFlmN2/7KVlG8+CsTNdV -sOUX032xnNPzteKzrkun3p9+ongCCfoolvmIrC4kr0K6HNyiyL+WTn7oJpYeyGXttWq8akUbiGGb -x4G2XsYrrD6DurNcCLFEWTF2yMZ6LIZIYhGmr0T7OUHS+J7g67PbifxxG5UzODhXqz+wj8FPADjf -l9D5mvSFs69ODE3iXIgUeoRqraNPy3xerNO5DaVseoR9wcQog8zsGRdyk50pz2f4fr6ElCW1Mf35 -mYs0vlR0j4IcczUer3cLiTiFnFWwlf2Y2dWYH6KnQA+FeS8Ee8Zc/lw36Qewg+QZS117DugqomkF -kabsE/BA1HWzXXS7AM2arTl2uqwdk8eZZSy7OYB6CsCdJeGczFZn/ahvZ5ycbQNHKmCXM8aidvT/ -OIW7dGC9ISaVozyLO+9jMDz4oaYk793gqeHu29MjeFizEmeyVNfzsEkMfSdzme9ON6VPz42iQnGI -DCNbZXpTbQ5FQRxbO5eKmaMxoYiGIhbjeGkSKqNaFi7GCTHWlvoe55asYXxL6slQjr/fA/uN04D9 -FXqM3XfUnzh93xb9ifKv2YxaioE3lgRFvXftuNUUa8/iFEeApTc3KFfCrV1u2tw8maRpw+Ymagsg -2W3LbGPPAkUEcARu8shCEpCk473c2xXudP9YgWj/DKETjy5YdTcWlZ/U1EGPMO0N+Rvf3py8VtcN -iL5OlrMUPhOzLVYcVoScEFmxnYPB2LLjMXVc49VWdBgD4aD5waGBhblZJ/qJZDutXq0JZOrWtkgH -DZmdNqUXe4JFRCfTlT5J1pw8J2t+wsHArFp/9HHLIfSxVr0vZK8tjp8H1w4YA5br0lygeFrnpwhr -YFaHUeBwJlvdBIuV3IHalljKJ0Ns/XWBdyXIkeeAacIZNN4pzHKdyPtjSeTWdJY23Fxb1AK7zgv9 -q4XuT1s+FyzENyXs72rh2zDeZyII7eBb0/euFF96Sw9M3CPXHLyLoZ0Ki02MgzHcHWEdQ0LAbPNW -O5YMqatRdNxUqaX5xYYCugNeBCoY1QvqdF6ausYcFiqa+Wa+4jeL/t8htAbhoXzM87B0T/dB1V93 -Dr9wdvTM0Sucyt2Z3w6pEkPF94uqa/ChWOYryi/ifK64BodFMzWjy2h0jAZGpYUV154LBeFXK0Ct -LGtqktO5e1YW7UQC21hfEbyiS6c5VGw1n69dfV2Rs2WrcRYwruh9hDjZ2Q755WaQX/JzV/c3nHq4 -s8nk6x7NnSPzmq+/tTly6Xedd99qjt9IPnU4z7uh5neMyPmY2pZuVkzbNbZo9hNgV0spBjubSDwY -vQ831SI/2C2s/XQVizJ0UkoDrvExJwlIe6psmkQsP5fErb2FpXnjnkX7sZbw7cdRjAn0iKV4XXUv -IYvL14cEgKGdMY5E9ZSJxVhYqYdjbWwhWV1pdnNyWMCFTsWJmFqwbiXn9ab3t73UZCCW5nz1vBQW -qoFvmnwFAJlj1J6vb1HwWzKQrxGtdyax3HUL6hc5/Ren7CXr6Q02qjciRo0Zh84TNuq//gv6fsH0 -2xtt3Mr85GavUNayvOrFaMZPXUDeQ2X7+acMo/Dr9+xHBtb3mShPNK+thq9HQ40T3W+UndceOxtX -tP2mIAGZS8q9Lic7mdDGlVxUDm9suGQDpDgg7Ypwq3VamIAJWew03j2e9zS4UhmfFd2w24c0XfBU -+3vZct+Rb9ZldpXZWXwrYvw+jMw7uhfm/hgNRcs86UfHoJXVeK+bZz4eZ3NK5wFYjTNVajeecSKz -kK+wI99FwMkTnBCdEkmtLpBJwRt0DkW8EB7VKYwd0W2gOGl+XMTyn7wB8TlzPsyVQB6YVHt6vXD6 -/0fX7/9aKF214OkDt6TjidLqfuy4k4MdqBO2TRBmSa+pUNZUZ1csJZLjp7Td5XiKUMFpuQhVfrbc -7KExeVQ9dRxFPg4plM0uu530cM/AARzulS5MA9OOBvL3gkx67d9Z2oGbmB96khP0gWX9Z/pP7H99 -cnQj/2txCGPR99J8B51Wcu9z6/Lc23Io08GB6E2hZLWnan2tsMZyE1J0XjUiAm3kVM28hHDSeQJO -UMzgPYPb4JR8ruXNjE4P7CBr/fPV6qanF+fn8hzEX/7rv/7yH2+xev/p8u+//+l/ANRLpvX4jgIA +H4sIAAAAAAAAA9y9aXPjytIe+N2/4sT9aJqNhQAIOOadMTYCBHcSAJeJ8QT2fd9he377kJTUIiVR +AqnuPsc37rktrFlEPllZWVmZWf/jP/31179CJTD+9V+Pf40g0nyl6kexEZ4P0iLMnePN/3J6rDTS +zInC05Pgj+P/nq76keaZjm/IP+8OztdTIymc1MiOF/K0MM7XYkXzFOt87X8cz49Xfh51/hnnRz/8 +Kec7vqMZYXamQx6bs40+fHlbN4409SNZ5+JXnO+8NHZ6EwZh7AfxA/rX8+3/9fN9I7Sc8O2rYaSf +G/w//wOGfxz/G/z1f8CDv/7n//zreAH5AaE/wOMF9PkCeiQM/iT8ny7In+n8v0GkF76RAf/tyKgw +13zn+G+cRnmkRT6Q6d4lxy7YAP1ALr/zyPjILw39dMvO8zj7rwCQGpaT5WnzI4wDN/sRpdbNRoD+ +6d/+meiP3GpfCTthblipkzcnypmtoBDcB4zCLPSqp4z20HQyjXwRa0YsJs2C/dofmjMBYNjFfDNu +1lg1HmQ+vx2LVEbO11yyY/f4aN0mUl3ZwxWrcM6B14SlLNrWf/xHZ1Rjw0iZm8i20ZkN/33wAz5B +cYThvyNnoekCQpjbaRQ7Wl9xPuE++AOCwYf4/4b+M+Of6X3N+oNfBvORCDjjESYw0CCtVXW2ZfCw +5NbgWpFirJmtwkjrIaQJ7l1ZNgB1rG+h3Wa1yqJ6R+YWNFdETFY8cDoZ+QKiD4arG6yfjcUuPcnN +orCfHUEKlH4e9fPsmfvQsUP9l9fHslwJdSXVK0O1o8h7egq6AuZnY6oTXrdxybf+Ey6nh4CjKL9/ ++5vicZPOzMiVj2i9XjjrlfwoJIr/rAd/3vpfHaRPVVTDB16038eiN/wBEz+G90veFe2j2D0f9Z/o +fS158wRf2NzWOYwPnIzZUz5qyMl0qgmOvQTqkUHNOCGS0lrcwXE2xnXaMdupfRhvRmpP3m4G1Wi2 +ZgKaq9B1T180GzpZTu2qi+R9oYOxrgpWjVKjcnIgN+q8rx1vaTd791GtP8Dhd/SPbH496Z/Jfs1o +hlHWhp1lFqTMUx7pwXboQtSwDCWOdSVsMfabte7NdFCR9LFUTnapYO6yBp/K+Y5shsy63Mt+sVVn +WZyt7Rb2tS0YdOriZhHqTmhdMzpv4vOTlpPbhXrZoYvUv2TJ0wM/tCgAsjgKsyjNAOqJJV3QOY7F +mgdoxxc+GfEG96PySveIxunPeZQbdBjlvHQgbee5Lpj1IV9aTCItAg6Oy8oPtClnG0aNNs5holdq +exBqW+7xs/maWM2DZo9qXCXOZWyarodCHvcmri2RSyihvqlqTSXL+1WqxH0lzJyzGjtJFXilZ48s +MNKf908aFr3bsPkLPg1J3frVE4eP5kQQ59lN8IaPDJdXpI/4PR/1z+S+hrAZAk15gMUlGa6Jnhtq +IOj55Xw+9QRnNxqlKxKw/Smt1SShwCTSrsYLJ2hGK2JnVvuJwzGQqaLcHi/VyXhsLXAdFVWY/B6E +14L+RqpfID7y4dgR+5Wj5/bzYAVeqKR/qiQYSnr8asfvV1HqZUDs9PPCualkceQRLfthGyfROB/0 +n8h+LRp6BotTx16EMzSbCtRAjncy1oDFGjVMueBNZDYfNkyc5Q1mkzAjLQCWkVs3BsBIBzlYyPxW +ns5cERfxVinzWlZ7iXrLhu0oGpaR940TrkrmKOEr+tAP7BrYQEm9J05B+EOgHictUMdR04oiyzeA +47xBuQXlkRj+SO++JH1E8Py3/0TsawCLhrC2skgedgUJwLmvgyvBB1Zzh2NDZLUIzB2ydNbWYRUY +o9V6ZUduzACciUCbZUgJgcuGIj5QejZC6hLE83tlX8rMlT1iK9k4PFqtvr/RUifOL2a2bwG+b+r5 +9N19pcjtvu+oqZI2Tx0UPI5LV0DH/dTIn+8iRym4UgHnCZxamO6TKT38gf5ALu9XT9fxJ3TuFhGw +m1H8Rrsd5cbwtSg82T1vprEnDXQ0ueFHDO3P6P4y89tKlSBo3Aw42Ty3RjL0x0MTv2vaJ8Pw9Ld/ +pva1sDsJtEoTyFlOPApvSAVMNsVYWs8OC7pIxD0abxvU4mPamELRqsctFZ2zK0BjRJnFK0WoCrpV +NKktxu66hDJ2U3rDYvjZQPYJl+woMNTU0S0D0BwlujngHyeAD6j3N9RPNtvxT/+J3NeMwhEALEAv +mTRIok2KeMwoYq56gdcbJCOmmLW1SIPzpSn7vCaJPZfn9GVvRScVWxEIwAn12mgZg5pWtaL5HnWw +aN2QvqnWdUMtrOcu/NFgrxtG3DeS4iy0TxPnq4eyqEg1ox8cx/qsiOMozZ+H+2Nfupph59lRm5zv +wT/wj7xZ76bVZ96q2llRHN8F1Ch0j60dJyyhGaWBEh7bzY0sPxojP45qpkMfsqMwAk6X+pmRHuXh +9pBx4R24QzquqR/F4+Ksf6b6tZCw08KwPReVaUq3jsC3Wc8pvUnVtK1Eb1YFS2D7wFmWIcTSVHSg +tVYd7YSpwXIzce/G9hKzGt1GYn6WsPulPNtLsrXqJCRf6tx79e2JIU+i1QUcJ1MULQPMrB84oRMr +2S0ld3KIPADPe/pHgC7O+me6XwNUWQHB2j7sxkayHLQVMAyigbfmRzE6Yxk7IfWqgUyR83iyCj1u +IWdWXK7sKU6hIZT4Kgi58iAE1DF4MA8x6m9JyENu+RrGG7pLL77g2GmsBX8gdw+pZ8Omk9HlRceJ +jlMDXmSaTl9X0soJ+0oaYMgNwE5KA7sfsNvtHIF7f7F/bqaDFh7xzY6jD/Mh4KxMxBxuUWrdZEGu +++So3NTYKA52SIFVgXdwdgBsEPZ4rXNT57D3ea7QfY2EcCnYUYA2cxpbGJqC114NV1pcHNv7v1+5 +/MSc5/P/58uO+MZMeL2eXZN9+vr3dD90lbxxiBwV6nH2FSvN2ScyeWL1w+jXfwT7+j3ydXfci7YG +3GS0KjZ8YllQq6wdXaRE2nTxPTEDN4y4wHkjGhMZYQq2I0CBShGiWAkLVINtZxYWWwsOILXRWhqn +lDGPaRxQfYp7/W+Kupkahprpv7/TXzX0E/urq13hX7qxKKcZPUH3Yu7Ui2ooZ5mx3wmLJtpjHphQ +eU81QZGwB1Ujg1gzHKTkNIvSEcOw0T6eStRhMVxj7HiWYXQspaw3F1d/R7d//vx/hAQ4ygD+EwJw +aucd/qeLXeFnxX01xWGQz0fVPlrIrdWUwShoRX4dEYyQc3uxVtC5OlRcRUF9nS4C0FUDSRgsZyxd +j8RpzaArbLk/4Ds1hkBI5YyN9Sn8Z978W6P/m9X+RTPvsL9D8VNeUnvznU2SIpFHEpzl5XEKBTkT +fsnUQxvE5/SYbijV3bM7jybZFEccS/RiFpUHO4GoDwfYmvj+UC51u45SPuel5PA3KP5/AvK+Exb1 +79f7F838RP7iWlfktRmyWwaE76p0qi2tnduO9i4zrxmpLIv1UKT3ChtFEDlxq4MIlMHWLuB6Poij +wFQz3sYUOcTBzYgcGGFhrkKFFbdQ+rfo/PPH/wOQ/936/rWVN7jfo+t9aCOL8QICHWWV45mvRpUQ +txPEVKvVYViYLpEHdENq42orxQ2pLjf4IBBmWi4N4bGJzQnAojdwVayTKtxTcLGcTu3p36Hr/ymo ++1EUWn+ixz839Ab756td4Z/EohDPNupYp+WRBGNNmIN1g9QQavcajKyWQu3CPUeuBZtuBROJnIxe +auCeh+WwyIupDIdyu0lHwTCbAtvNIlla3u5zff/CoH9bCUidTCv/hAQ8N/RGAp6vdpWAvT6ax1lT +hTtnv9ivfIZUcnMoCtMwi1VupwdmNT7YJg576mRj+nspS5B8jM2DSFq0M5yIxluGi/eJjvDtoJ4O +86zZZZ9LwAuD/m0l4Dfbej8beYP8HXberkaDOCVkTZnRO7NUk7EzHW/HU2JcFNgISQfObGcNe+2B +TvbS6LAcVYLlMCtqWms5X8KLvTU2yUhR+NkW5GhIEzzeVD937PwWO+/vR/wUfvonZneX7fzE/fJi +V+gHxDxGVmJti74oYut1aYyNZU8M1TatCkYApVnD1+yhF3F5G6gEl2xtnxChqDFsDiuBRU9DKNNU +TA6eV1OPPgxzZrL9vMP/nhH/+eP/Eej/5h5/0cw77O/o9QO2Cblw0GirdaLMttxxyg7mel6s9E1O +NcmmAXIBPHCTrdOqM04fkexwsI+tadboOMWUVTjZNrnMAYvpXEVDho9NnWA+N/Z+S6//JyBfOeGx +z/322d1FMz+Rv7jWFXl4ONKXy3UuIrW6II68gxcHhUBn6H41VDUBX7n0eoEOJWk2hqE1a3qMYbnJ +pEoigB75hVXvfMFEx/ucg9MEodj9OC3rz5H/TbO788f/A5D/3fr+tZU3uN+j69FANvzpRGaKGDGi ++rCI6ZZuZss60vLM6q0MRCAWKLVEJirF6km0YBNlzlLU2pq3O01PYavHcWYwlqJeJK+heTnWHeHv +0PX/FNR/s57/2cgbzO/Q8f5y4pIK34JK5Bx2IlAxcsL33GiNNgOfPrhQRlAemtQAw62THjib4GMV +l6PEoRapgBFzDiUzYVOGYL5itE1irq1pQH3ux/ktOv7vQNxvdMP3nyIR4jNXP46IgX+AfdXIlR8Q +ej/ibxp5iXw4HvavKHdw1qZ4RdWtWo8qfWt5RLHqpXrLgrUZ1YsJsio4HkWyyl5XGjqulxhP7CFA +1RqlXXPlXMqwnUehyVz2jLaYbNa1VB2MT4OJ3oH4SfzYm898u/Z9g4ufvFnf+961//XuF+9u79oi +uPvFD9u7X2i7BBn8Wgl+G27w4fV7ZRsTN5Ta6trUmYu8DwVi0Zp+sku9QKMHmLSRuZJdR4xV8h48 +zllGmSmjQ0EKEJ0sg2rvgkxj0xsIE+UNvuAmRH0I3eZvcUe/WYO+H8nbY87vwbH+EMX6fgwbRoSj +ZJnsZ9RGawoPkoi1hcoTLVVnC4aICHe73ysBQzLkYL5RpfEmjZa0nSb79WqI7IfUKp/ziJXsSWe7 +OKwdtFgdwL9hKHocwa+XgH4xhNeLQR9dvhfEylPno6G+J4NcKHsR3HPaXPbnVShRCAUWO7CyAYnp +BdVMC1jYms/CLcHR9m4xNFkW3QmRx4AlhTq6w8ecYSnzHgdkf8vM4dpXdDeKf6wbXrr33l+8F7+e +BKCkXPIitu3hC3qvhYI1B1eWBjbaYiCaDKYoI4Gf9La84w6JoYlbmYPqMsSzC8LH9qtgSzM9eYpa +ypSx60FQ8xX9t3v67kDv64n6L8bvesr+0eV7MYwb0iOgaliF4SRlkCDld/l4tzaDdrOVUZVty7Vd +pDttRue0BosCAiOaI2Xe2NrObHK5xJrBpJHChPXdnoR5+4GzyMG/JQzv2qq/G8U/1gcvJ2LvL96L +H2ziecUGjFwfhnqq2eTOzY0yDjZLexR5oFKSYbtLIyRHraAF62w5n3jRoWyCKi/Gm0EdDZftKjks +litg31bsTB1G4/Zvn5N9gl5wYrDiKw7w8+gGbvBxTovcj9cHDRyR+nncP5PtEOi2zBGuEZIMttls +m+5p4TBBTXCxDsTeFJ5tgiE6lTlm6FFTEztMsoiJfR0YranVLsVrDnNGNLUYCaN9W3J7W1J7Eu2p +t+KT78st+m8nJ2du+EZwShwCMiNQwtzRThH95fHGkX0vifcIeJ1rdJ0udHHjZsL89TOn3P+LUgAX +r9ydRHT9DUr8kr9IXDf65jmjPuVGGGn/CKZm9KPcj/snYTi/DP6AYfDT108ydEq0eGID/EVjp6oN +T+2oyhNOz698+a0fJDd99L3dspoe4sZ3SV9y6ru03vHxl2VzdcgYe5Ow9FBi161mfpZUGXTK8Kon +Or4Yt34yb7VEmxcBRyqY1VtuYc9l0DKNtckiNH2dlJbLgTv0w2S2rHxxtwpwa9STKn4It6CfKGvV +TQk74VrQGIvfTVX+IJnn1A0h4gdxVgPwOfn0AlzFLV+UyPC6+sfxTv+cUvSzPAh4/cCZhWHef6k3 +8JyufPVE+tI38Td30ijL+lmsVGcoz+kZVw8YJ933JLQ/W4dvPNCPlTR7/tbBWz137FVHwXj6Gehx +NIc+uNlPldw4Wt6Bkz8z481zr0k7PyDoOmfTjZ6VCfY2C+yqysqRR/oz7TcfEnvHL9BsxfeN0DKe +f+ebj0iVqq9GevPxJ16q+xdl31XV319BCcLvHh0085T6baTA25+AvC058+GnPKKgbzR5t/L7vF6M +qfjZfTrupYgVcNtQeiltdbdiu6B91GUn4+iZ1NfKjAyAYeA4h4Or7kpwVrfBIlNokiL2O78dlLwP +zYsEcqF0sXV7w1m1wAdLNA13ugeBpTZwd7WyS+As9BkfmCp47enw2PiuMvugtNO7Ok6n594kvL/N +bj898rGd+sYo/etpwfnp1ik5+zqzW0lzR/HP3ej5l1xU9fnrqe6KGtXPQ9NRn/7OJP+fWJtHNaqY +t0qwgI9V8XhL/Skp8HTUB7sV8nB6oII0q72CiLak2MpmOvMNnSMIcjrAdzoZ4gkQx/IsRYg2BfVs +sehBlokLLeZaY9CydC3BJGRsW9m8CEk62zSB23QSqC95/B6WDqscbznybpnjmtOfvVJ3fuHSm2eF +xQNvBUXm3/Va/UBT9X0Nvc6ug6zUPnzJzVonfh4IoDdmR66kL/3zAss7ukqXhZNf1G/erph8dLlr +j4KgFhJL6CArA2jWUyIaxdgdwEgkLRcJwjn7zSJWS+DAJNVoSetNbw7IDlwDtlbRU9dWMWmRzbbr +bJaNyZm7Itdwwgf/qBTN7j33AbRve5R+Mdb1R0jX3XGebnDCkHr1cJKAXmEt1hA/zXRZK8R5RRsz +qSetou1Byrbq1iJ2Yl6hkb0QpaGaGNVyLnMBBWq6Yy9NPUonGlodrKko/4NSMn8Pyu9V5e+E+k1r +F3i/udMV9IF07Lf5XtjMZnNk7egYzhZiQO9dvuF4x18NqZEZ9A4Tzo+ESJiy5S5SSJUhk0xpy62b +riaGZtb+ThBpIlGnCrreC+yDiy+qdv2gdb70y+XjRkTv7xeP56HqT8nHqbkbAnK61VVC0h0UwGaO +I5OFikEAawuB59CgnfDIitYhL1yNNEbCc4dEiEx1dpllz83Nbq3DE3DI+eQwi3d5sjpeGhzKmY2Y +Q8GmPlcLnSXkzNF/BwGp/6D2qG/ojvo+zeGLIWqDvie4U6hxFrXd86w9PEUEhtxFsDnnd7tDUk9I +eqXbFNTbjzQN3zfSUnQnsIorWz+z4nVlJsBQECCD4dcqo6UPhfr+++qN+k9qjfqWzqjv1BgGMNVG +Q7RlV61FNOMx6pbDLXUYVEN9zlFyfBQWXw0gPW7Q3a6nxHjsZsmWBjVQ4gR9rFbb1ThsJ7GKABQY +VCwDROr+IUPi31BfvJvE/E7BuG7sQjCub3QVjJEjzy3N03iqWEclVq6bfO3WOKmvqWXto1hywJkU +VEiFrM2o19gbgeaWgR3GViI5KVV7k1WTktQ4XQ6m+rjJNGFmbf+GSIEbkaO/FvA4jermKFq3PSyD +R4o7v6f/VCz16bh/pvo1kuutlyPBUqMW7pDFjaIxkib0xqNdyY5reZPveXDPMzSIm0aCJqOG2nGB +qW/p3kycycLO5OewkxdRPfXTcePGjRBvh8avKPH81pPV0VN8ivnVnCcS+I9zWX6iK1pfLqF+vIaE +DB7top83eFpN+uBy/6nFDtp7s9+KAQaDueghKDvZGLoiTfHZaD/G7S2EIfb4aOON+aYuBnKkStTA +HNEFmoP2Sm2wRbRdLzMOmngTiYNnqKToztSR7ynZ/9UyQKf6Za8VLwElO9UCdrJbHelUCO6B8oMf +tXDyfr8c9890v+a327MmbM0W02BSle1gYa0XuzwV4CP7apy24f1BqhXb7mXQCOYPvYrUDGk+9coG +ayf0Ul57Uq932K5Svc4kY7ULNAspolvFo6kN0x/0aV8pjufd2HdabP0kKOa7vHsif2Tc00FXrpEH +TyNJtAznQIksmWTSzNaoXw/tQ54vGYv2S3zAAsBoNrfXsDjTppJtriWKp4OND0YO0c4shknWkuBt +6sWgCnC0t5vektIHuHaq424Z4Q22Xa+GPsK2Z/rnQuXno/6Z5teMa63daNpuB2Q8GBiYDm59F5lx +4wCjDXyBEyGgxJLCzSnArXt21UuLLRsP2YqTMlufTuQ1XR+2EGzGRIqALBSsUhMYIL+QceflVSNw +8vxmRUjosYqQNxo5svDy9CyAHRauyi3EBdXsMA+nPWu2VqLSt4nmsBsintYTRWkwWqieV6TxTFnn +lDldDnzd3RCT1davDlaqrFmwp9sGy0ZkrbeasMKN3eEX8tE0cs3+bQw8Uz/Zg6e/XVnGxXE+TTN0 +qOizTcE7A3nuggE5wvXKHmDTmbIfYbtGwITZ1pczrZcjcB5A/IZlgkU2IHGTJprGcDJrameivIq8 +xQFsbxkNVyzrsuh3Y8Q4RzFcrFZ35L4fKflN7oPf1Jln6ifun/72z/Q6bBahqz1P3vm7LCf03ppY +muK4tiFWn3tWtDbQfLHDchAyIX+/XZRCuFkylM/BCLSatlqz1KO5mKn+VNILl9uwyLpNxQP3C8eZ +WMk/k9fvcexE/GTnHv90HWEwYaEJqBiAuL7gSVVfD7i0XPYaSTI9l0ONZcbvtXY2miaDQzDzSIbA +NcbSRNghIV8g5nI10pGcB5zNJjIQZL/1/Jy9tZD4CL+i6JZf4PSFD9iWb4if+HX8c+ZXB7sR9Nip +wm3GDDUpNWuDtJ7bQktD15U8dfdaMNsufLIglxVpaJqULnldSiJAwKZOE/A86wgiOk9HkCRX9R5C +zJ7ZINtVp97djV9FbuK/Tb5OxI/8Ov3pKl8qJK0qjT0gDR3OaAZnyCkk+2pJCSwBjHfISBzHQ4qD +6n1swsRmqrTTTZpInotUwz3aDDVaXmIsmmtJoo3B2giWHl98dwDJDK1/nDocP1fRFdU3TttLGEpw +cwqKPDKO3GjktNPQ9ZX+uYEORWQHUBJ5RArnOOnXUy9CwAY2VGvD2EZohLSST2VjCxRUHvLLxuYX +JQfSQ7E0LUOTexXfjgN0Io1pqw3keLvpjWcsaXxWpfkzDjp+6Sj9SK+ao20R20cRCfvPs5db0/gH +wpNvNnPqta9n5/l8hzBlNfQbhJpQgwkjjupUGmsWPVUVQ5Y3uJ+SXupAMdtmXhzUBTHTTW4lNriK +s5bG4IOmYgbr5SwbF/4erwUeJSullxPmLWV3Men7lJGhfuJGahcZEBip9SIVn1WifkDr3W7nFO99 +eX6uSd1BE+Z+sifqBC28WpQOVBAt4l6AQVpSrRg05oV8tB/MQpwm8TjDGsue8gBf4dJSTyxkMQ1G +28F45Gu7cDUPIkC3cb7d7cedtgN6IIKuS7rzR/s1XbKti3GU5aeOfa4c//mE8qFy4m+pX84nO9UR +h9RwuUo29abQBmMHm9lUk0Vb2kJxlxgqklvQm0PKbQKmnid5k48d0MOLXDJCshIPc0RGg91uz2Wy +NCZag0qankstNp9h9gmr8sgzQqc99msnNH0lv606HlK/78gfmfV81FXhwgFZ9vDY4zBufHBGkDe3 +IJd0bXg4Zmp2Oal0rvAHWWi2+chIzSU3hqYuY7SHeOAMKdbfRUGcsPkyiJY1psGVlW+zxTej9j7Z +O+H8xf2XrTqeImZ/Tfzp37oP2iuQ56NPBpgH1OIb4qdtSM5cPJP7WkIWpTvqtSg0HUQluGhICdSL +NtsX5QKElvywRnKMEeqeVSi2JYYU79mCzg2zaGWIm9F0Ox8YZsg3jnpADrgPs8W2EuaDB7chOX6Z +VijA8f99PXVu7zRxSvx4iFVv6Z+8Mj9P+k9kO2ybyPqZlTblXPSHSrrU62Gelnu7RSxjZi/bPHPw +9chg6T28s4vC3m7bzXK55EUa0Sg5UwErTpNkmas9voHHkMdxLKfr39yQ5L8V6tnZ9LQD2RH7ozrt +X/WtpydeesnPJ971lA6hju/4+EGs4xVCn75U3/HKh/GOnd+r73zrMk/zNRKx84v1+9e6KIuvmPtb +e8TbeMQbdzr3leN8aUCVVY3uVrme9cKaWWh7mK4nxyE8xbLYdfW42jMqMEDcXMwRzDX0HCKHgxXL +LoHaMwnaq4jDkN5mGK7mPTXgZvtfEJP4Fzln/potp9crGr++DMAXUv9HsKxvIFnfgWPBJzNS3a+T +aYbPJL5ZMCm5Br3dMA2sajSeaxtO5qxUmqYoCy8CQ+BrbASI/MoDIH8qY26eTnaAesiSer0w7LUQ +5Mv5t+vF/X0odo0m/FVQvo8nvH2zM6gSzW3A6TpsNvOK3CdNwPfcjR01jJQnpCcv2ZlKMww5LdA1 +QiV51nCmUtWTPbm3CCCnGgXBGc9E5prLoj7HTDLYK4g/GVP4Pfw71xH4ejz5E+DXt6Gv7wSeqPLJ +iFMYdeWBFL8Lm+1sOplYnljacwdclXgzIJxQ3U3RwLRXkVRKUg2tQptBNwdnHLAgF3HlNAEorYqc +NnAXg3g6/yWBP/9s2D8wCH4v8m8bvAb/7d3O+LeCUIwEck9r9nE6zsQWUyKNqlIKJUvOcl7mA3xn +ROKkGnuHA5+Y5H4nLUBru8JyCV7GonngD6TuHIdu1w979QJcSCz6YKjorwO2c02CDgbbn4C1/gTU ++l5IBzBLjA50uptYO5korR5cZbogKWmWhgPNBUNqVmt7vIVWjblzi/1kvwMFdCdIfq3OaXwprNX9 +kqVCHSRGUKKC6LrEkG8nBfwpQM8bcH7ivIWxB10wPwm/VP94ovQ1Hh4xZOflYZuXJNYkLQqMNpgy +1AvGWixZY7FaaLAz2QDhHgt2WCJIk3wabtvVprdzsXxXGY2LHTSRnMArQzPysHSIkJ5+0/PyFDz1 +6l/5//Czy6HLpOTMh5eNaz/uHNBjneOV8nld4fi3/0SrQ0Gq7WRB+6LoOK12sHfhco9UjieTVaDv ++RhPMCage6wgteQsazR1yFMDeGIT6znSAy22doNlcNiQK9eS1rsxR4pLwyLLB30Xl/PvG96d6yl5 +Zw79pPyy2f0LqS4FvnepYEkHWJZVFIOyTejtlrbWziODyubOZk2mhpbJoMAOaSHBCMUdeVp4su1I +aQPPY4v3pmNG6rXY0bbrQdUuVKP6pqfiuZt/xaTP11i+w6TLftqdScl8FjvwdEzPq5rbHZr1CDc3 +DLWJVaNtDiqbNXqqOrOlsAjyxTZF8uAwZv2h6205XuaO9jJV8uYoQgw+RilEkpcEjNNfMeked8vP +b/vAzfKZn+edg+XThz90rXR+4zW7s8Mr9Z1N1N0b+Nhl0+GV+qMXOmjGm+D8Jvn+sMTmG9dMV8nn +uJW8nHpyhHAansjTLTLmyg2uuj5u8LvGWCIKMQxzLshIfVexqJVtYCLCa4kdrReuXfETpkdklmyo +Pr3ZytyAjvkvNvzoYAb+/un8jR7ymxGr3+FV34UWnGnIsEB2o/0iU4Mlym57XI0HQMOl+9AcMaNV +gPW8dmhFm604t3DEYJ12QC8ygp8IjFzMBXRil+jOicUFTo8UfTbd0d+08P4kVl1dLt8H7L2z5aPL +d0C33+Tyzt63AOqW/tYEYsS0HVkcwkW4J1WusBxzRBOrYAH07DCNVgy5QnN8Q67VTINQDon8maYE ++pjqcazoSNTQCpT9n3O0/PaZ9qdjyp9A+Tmd6sPrd+A8bmMkLM0GmAaO2o6iimxzL2IWXkavYVOF +Wx8zbShy1xDPZhaYklxa1PkY1wdmiDNj0Kd2VRKE2GYEAEDEIMFoLiwfLFV8f0rVH4f5K//Zr8K4 +/qgf13f34p0ewJDqNxYqAd4Wy4aLWWmlKa5FnOhJfg5jjLwmatyajDeO2WMH+0pnM08dbbRt0mQ5 +6Qih6VbDmmc1XJoV4Mpvhw/VbvzfoQ9/mRL5K9F933/r+3uvOVoR1HaDHScDEk9sBIshItaZ7HYR +kCkNSpR8MyyykQHlQxquy6pcDhAT3RT1LtguiTVu8g0JKjTijQ89UawaflNCkz+UDvkH4e3sBP0+ +wB+4Pz+8fo+KZrB000LzYJkdrSSKmpMVsggFlHHxWFPzuZDrS2qwqDXOsaaUDhhgPVQLezMeRhk2 +i1Bnn7M63YTUesWPhKpQ0d1m+e0i1r/dQ/bJdOf3gld/CF19P3CVUWa9fS9rK42WRHwsjFQKAaDQ +rJt1CaCQj0fccMRJyy0D1dNlU/CmQHHwkO4tGYMeTtbtkQ9wiCnTCGG4g5oC0734N5m/XWFT1CjN +T8mBeRr5/s14mMFDAZVviZ9y4t5c6g+6BVLauL/Cc0U77MP1oJyvRMtR3V6+YPgxCvR8ECMLeKml +TglwgZGDhuIiYrXlEShbEFXIM84qY12ISEA9bfWtbpB8Xn0a19vB2XnOFernSmoZeT+znVNs9Evh +xJd5/U8yX0SUYT+67L+haJoR57eiXuHHQHqiecLm6eicPtYBElQrLYzOJ5Vp6YGc7KHt2NlNtMEK +Ur11wk2dHrwFMCXqYfuhVQBruloXpM2xrY1SyMTP2k0hTq3DvkhGSYSq48CdT8JvQhI4gXER3feu +TGVoWFHuKHn0UpX0Eaz+An9gncCK0luReG/qJXfH6kjyjNTxb/+JSIfyHFzSI5oUAriC3Cryfsyv +3bJsNhwKILI5GZc0zm7rTb7UNcYGJspRxw3yaomViI5SXqqUkuPbYzLjkJWLD3IQnm6lZacgZNUJ +r5n4wpPTnWcG3cv9U1xqlxUFxTr1zjf1gS8xGP6AHgi3fyV7wuHnSf9M7WssZiHZ24u4WZnC0qLq +QYCBs3mieMEA3C28ZhzxUIPZhbgqaXBZHbih5+BzRZtSWrpU51GEl+yhGQpx4Q177mzRo6WoFH9F +QPhfnZKpn0r1fizR8EPaxy1PfHTL/hOBrzko2qrv9Bb+wu05s+V+RMmUKQwWAU2GyqaZh8gMKltC +xDhPQYWcUBWAH69RzI0aDM33mFcDI3qEyrs5hUPEfghwUkpx31z2MpUs7+uGEfeNpDgPzueqgdeh +x+eHitT5qZmuSgpeVeo99rkjZ40LHXXxZHpsw0mNvplGwSkf4Sno+F/nusofFJb89XHJRhypRmq0 +3qt/7XORuajhfMu4uH/l9ILuswQ9n51Nii6pQo6U+CjISuteIWn6ejXgmUTBWLmJBnqkTXEL3QqD +0VzbBgUGj1WPkwoDiNlmSm1xmZtMCk1cWonhZYg5liCGRJqo6tQVbwvSaynsDwemzytX3Pny+4rF +1737fOkbtdRVxVdCzdD7R1Bu5h+f8mjuV8LXpM8ZHpcXztk5HZQxNU0tVluL1Q6OMIuruQU9b2Yl +t4kH6D4yi31bETY0nonrYJLkOXk4yBI2VHWVWKZwKfEk3nMHDpwLprvAaKyHBA3XrXz6p8oYwk9l +p+Hzpgkda8U8Z7i4t2uMoA90sZ9UX3No3FP1ELRTOedJrOx9PsRzZCOrC55ueiram0ysco2Uacbg +pVqmqrMS4mxoThjRcz0mbTDXAVNJcGnQa9W5sZxWbZ3gThNHCJQY1xV+XjXb68TnSnhvarlues40 +ThXi//Uq8//l82ZiJU+NI78/a6eqqh/Pz50bu7eN48wpK/z89NmfNfNE9gxiVsSnPR3+9a7r3iyC +9ImYOVZYBEfl/+OmpBGnstP3S9oF4ZOwXZz2zxS/lrdJBBY7CI3G0mZYCYO1OgBHGbbxZHUaLCly +ovvBMCF6ikeo6tgYmeCsKqhsJWPtsLcbYjig8Zlp9bZ+kzFbQQty283c71tW/7lL74305nUDgY+n +do9k7lzQPTH19awPd0vdgTUuEIpYmVtWbyVV8pQsNKbYFtHsgLE7wuGZdVYdUD+b79mgWiprL5wt +6emhBYeN2MoJgA9iJAKqVmUOKpWKJceJ4061nW4PkWqT/5zdQdfbGLzbDQJ+azt9khl24mPfSNPX +/SLeWGjOqYRS33fyJ9qnQmdXrR/tN9MJncx+3mUBvgoIOz6Q/Ew5Q6/ffLe1wtXd09f0nZcfBT0w +Yb07Xe1cGezkn9FypzQ+MQ+vHzxrtJfNLu4Se+DqxhscP+4Qj9Q1uCR8jnV6Pe3D3WobBO5QWu5Y +0FUSZZEV3vywlliTdWBSmw5poKyCSuNlcEEMjQXEQnFNHYrG9Q9pjWaGqMwpC5KwXjRAq1gZoCtT +03pDpZPX439XkCP/k0n4Yz6rF6JnrfZ02NVrxXiyoqz4Jljb8Z7dR0QNRdFwNaTAPTYRpMwNBhph +iM2IURtkxk8psTpgB2ZLGT7apvvahbbZwaLRaBo7bY8YzPxid3OXifGG7ozfcfb7cbm6Xz+BM1W0 +i7dRPe+wdIRaCZ/h+gjBk7+TuB/Ba9onIK+v9M90v8Zzo62QcVGO2REkzvzl8JD3SlcAAKL1lyq8 +YbR6W88GqodnWI5xnC4MJwtIpzXR0RdLYWIstwNwygKwJg4rulnaEQFsbwcgdhyi3s58/nXe++yD +yfmnMnHfDKAwj0bfk//h5F/PcuWk2Zzgdq27R2bdt5s5QXjzZtfc+3YdSw5T6UDtYSSTLGekyOGl +RsjL1NO8oQgOF+MatEI3EMiQD0V5N19xg9Ist/PCOYy9qiAm6UQnIUeYmJkpyjWLzb9Zaef5q07u +lpusfKRozAXdV96dnTody8awvd2KXlcbVVEc2s5LzMOYytJ6at2jMqwsJgLP+6gX1QClTFTb2bXJ +alFNEG0Bww3rczG8oAO3km1xwAe11Sy5UDAfK1TwYpR97N55iDsniie+nP72B904AszNodi0Yo1t +Bs1aWKgLUh4SKJbiWgr3Fi5O0qie49VmOaBWZGTsUHwe8Q0t4Uu85bz5bpO74sbBzHaBjcCY0rW9 +yv6Kwfkv8AfeoRNriu/3VSfU+0oc+03fNvzYSG9P6h+pHnajjZM59PGdrlXFNjGkqL4AOiXjbVpX +UwS9ZotwjgK70stGApzNqJGZYDWYNvZKBmAVmFQjA4a0WRzw+XKxcVx8QhBAtTEjthAXalDMvulP +O4rOhUkPXc2inoZW7eTfOn/18yPQ3Xr6DG8X7/kTg6Mi1D9B9H5v2CvZnyCeTs64dfCC9ZqMIIYS +gcURMqkBkoopOrFJgi1qQVltmZU1hAmUR2wqtsvB+GCBakRNimof58h+F2OzA0oGh1UoAXkzE/11 +rGwM95sj6O2O8OQQv5ognZZfjx+WOkfDQbsA+lsofm5+dTCyfNdWUrWLVNiKf2t/Sewh8/hM8SQL +p799rJthDBdzcTcuRLH2hppzsEgJolaaFWq2xoH1LkwzzG29lekSm2ytEDM4Q1sW34oEZm+wScAh +s3bLb9KSRwbMCAqQ3dpLR79Cd360W9adoDwx5Pzv//UM0H90qeOo2VEV/tqYiCeSZ3BOB13jH3rj +ut0T1GGx0oFdsV+ug7RkZXcEhImLepaIeGwylCMzZaIZNKujtctuvZSmB2w+dVBClJWqFsmwF6VC +NVppacLOod7NEnF+YSwUr3+99HTHBPQTjvpKFevmDZaCDzkPn2meePp0dK5M08Ha5A+41Q60AFfS +VgRkmA5nB5/314KapdJ+NYSKHomETWA05Tzct/EBX68qL4XZ8cHZ0Yt27bWjBs8WDk/tqGIjMYy2 +Sx5bGH/ly7/04/cdv8Q5+VjvVWGdpgovbo9jQ3GUOfntud1j1SM/oH/hbLm42rWeJOquaZ44AD1m +vRymXrnHB1Sv4cbcjsAWe10I2tBKwgreUJs6oUdLHaxgLxhkqHNkKrfDvTSsNlwwAkdbdG6nIG8q +zuDf2OfSwX92vU/ur/CfQd2KToeim5gaNWKdeKLv6BLZM6stbQba9DAJcMjXj3Y3GcVi2aQjTla1 +NbYEZJLUUW4474G5mOKrxJHAfKToDDaaIPNcqLrVC/s1UT1aFHnOZ1tdPmCRn0me+Xk6OG+h0cHe +bjwH3YWTwhyioI+CBSf6fo55k/F0j4QryJiPV0oe7ViqOaD61goniRomgZhSLEoh86GfzoTJCm7y +7cwRF3AElhhbAb9i44W7ONnPHCtU8uJmWutp4vcoT1+Jv3L356X+mXIHj+EQK6ThoPA3u5SBpN0I +mbCwOKtlubKzkLZMshEtwsOX2IQ7uP5uki6mBqILq8l4QNUOWrlGdohGO2HL+vMt5S4PM9X+FdoH ++4F1ioQ6p/QWueM/rSLcUgf3h+JeEn5JHX4+PauDDjG3hxVVOhCjxQLCMYkSuoV2gHl3ULELND4w +G5ygtqqnpaVee5kQpdVxkD0owY44KgovJpQK9gOKmVreQmVJhNnOBWK0f8yH8bxT+Mdeavwo0g+w +55ktp5jKI4UO9UKF/EBRPImV7phURhgbjpUE8xWKWhJKAuwHUSELLmtGvLqmNJ4i+b02s4EKnzKp +By/L8WyW4FYQxQrKIDK+DtS05r654Bap7nEU6ivZqec8OTMvB65SSZ8Wru4vo3hUFNC9Du8/NIJe +7Q3/cfQg+IhIvNI9ScbrWf9Mr0OVLBleLbZLONy2WQMrsxhX1o5qO4TutyOUt2x0wysUsXBEjm0Y +0RGEpgaLBoVWO73ZqjnJzwsF2QmtNNGUwaKdSPrg04IEHQTkXErdM16WL6FrH0tmG6oSWv0jAIES +viyNvlmXrWzn2VH+tOx6tyR1mnucmG2cBOITTB8wd3+SPUH68+SMaAfjNgsDl5V3TQ+ahtVOr+19 +Kc5cSCfyhY3wtUdC+yBSGpkyjGYN0xCyLIKhqdXCOEA2WbXPYrnBMczYzyufx2p6AMg8+lnxb/iO +rRAuVu8+QO30sZV93t3gJerscq09Cuwj4E9JBadl7zfr6cf7p8HiyamDvHXqhEeZ0mxD8/71X3+G +S949G/rHLaldcOzjINpHBfBE9Fn8Tod9vONqKA9SSTJg5jGa64u1UcwbkuyxR6sc5jboaKYeYkOc +LjEaoRkHtNFwClKBtKTtXTWIgETlp8yW90+7fc6TlbwfqrMNo39Wqf+98P3viOHNlaDTFOghAM9r +QOe//TONDrvbT4qVlvTmOp/4pFZJezAC+ClG7FappKz0mRtscgEXRoGkOM6KTX07DQrH8iyAlhAW +FsBxI02kdEZa/gATyzk2nCXiZ6bCbY7oSq6cIpv7edR/Wse6wR7koTXH9+SPvHp/8Rz12cHrA64J +x1urGIbz1HDF1CJUenEhUXmioYN9Q1azijOk0WQduXtgvp2U+qFHSPt8bXKBnczVtSdu5HimBo29 +c+LRqIQ1FfglM1Coi/fmJYTpY/4iD5jxZ4onlp7+9s80Omz7x1XVNqxWpSebSjmRcxgecdOqV+83 +ekuuqwBMC4yxRZkcFIGE2gcNxuWBt0Cy3NqnTSr607gorTHBOY7r56Q7V7Xkm4ZI8Bok9UHZ4S9n +Uw/FTD+HV2ZH+8aP0qt7f30rfPr4mbeWiR4LmjkRPKMc612DZaxhyGNLTG8YJxIiiyS5OOViOpfH +gWDHSw9II7rV1YE5tjEIyIBwmZlrLAqbWeXR5BpY+PSgoWjQZzelFK1YMsvG6S9yMXSx+PRThoSR +Oop/Kl9+g5uDh7bAuiZ94uvVhfOKdQdlhMxYZYADK6OmIhWzRvOq6LGcvi1tAVpMinml7/eD/WDe +GFtmZYacwexXEmOO1+22QCnUykpwkEWwVOswvqexNs3qwfSbE77jl5y3lQzzn4GU7xLpPjDuru6f +tprMnedAzRsJCX/7yH+0L4+ARe5bQblrjegdt37dWtE16ScZu7jQde2oCOiVow/cicoEslvjLqds +h4XUeAHCsJLRyDBkL+v5LIJDmUBRxpZEu0qaxZjJU8OIlwPI9nFkN+RQiTiY2bYcU4PrhPTfHol/ +YZl9EcD+S4zMT9F+lftbK7YPaZNnsk8oP5+c1247aBFr35b5bAgf8nq1AEUQwT0d47cbVeXo+UKq +tNBcgZCWjAVkB4/3k9GIP6DBpExXrKiNdnW2XqiHwmeUSdAAwHooLvOM+lVzyJvq5J+nEE5ydsH+ +e/XAy3T2lul7vxv7heiTVJwPz2ZuB7d1MkaE6XoSbtpklKRDm/Q3aL1iioyi3cmG5ZAc6Q2VeTpe +zXhKy2hY5Fi7aEhK0PeetTGqKTpczqd71nHUPewsJ/YkVj4LpbtTJq4H5o+HmMeGoX+uXJ0BvE+q +jj/hqAfO+8vdkKzHAjkvCZ+k6+K0a7DmZDwHQkagVmttV4GzqWwfWMJZ8QGH4QkpjymLoJNA2rvB +amxbjktI6GxUpoknTdGRmjdNeygWxiIHW91YG4i0H2p575tTgK8Ch648UF9Eh1lR/BIUBn83nOg2 +woamZ8ppVeo5f/WzzW6Pv/9+pD9o4LTR7furT7h3AD5ULH+w3qfqvMS8lWcI4zjH5sKhwfNqSgFw +mbdYMycOSLme8HMEWB2EMasmkU1ON1Y10UMvK/YDDyV1PUZ9C8/kSNZuLdp8tC/4bfwzxTRefRBP +1Ti69DPD6JtOmt3eqPWROcIL0RO7nw+7bpC7nVUBMbXXUtTbSsp63ivXBSsmHE6MrUNsy5u5p48s +Q8WyDcAii5QZz4c5gtOkUW34nYbRuG+YDD6ZmCla7jFITVd+9Jh357SMohtPyu3XzUZ/Uj0x5+W4 +67x0BYYEv3aQABMKbixDxsgPSoEaHli5LojBOJ01zizjjhPPdCbMtu3aqrEtlxSNubIOsjqASpuz +dqEZLOfzXVCHC29NpX8wzvdidvTr3MAvRM8MfTrs6gZuK7MVDG0FSIaL5UU2SyoykQBsMoV3CgXL +B1iwUEQwMMWeU9ycx1gPswauO6dHoMkR7HY14Q5zXZ+7EjqCDqsQyKjwPlvhl47RX4zEL+y5ayQ+ +clM3zONvPA2SxzElv1Wn/LHx+D35E47vLnYdm41BuDYtUzog6ZybwgPYkqwdiK3mTWO0IDLR3VE6 +6k3FdbTYBenCGk0YC6FoPXO3OBuKGGEk+p4L1rFQOUt5P09pZftLQqa6jooXQ/PHTH4kIfYn1Sfe +Ph33oW7JsAcT5eFJncO1K5aqUC7hw3bKjumaxNyeTQazduw3cYPUGmVB5UQOa5zYNiCnbnqeiWoV +LY9GrU6PbHi3oUdzabrBtOwXOcM6svRlKT+Pbm6d+lguyxvaT+y9vNI1p4XfalQ0x+aObyT5ptEn +8Cjh1Q0wjRgdjpM0XPHTRmgpF/EWMeA18Gw7m2MEUi9Mb4IDm1DKtjDDD1mzkf3j63QWQIdv+sM+ +MhN/lzGYaUps9O08uL2h9yOROhd0z9j8POsapzN3NkV8QBZGwVUphvvc2GgCwMvGh5kQ6RK32NAH +YLQJxVpLDU8tk9TSpdoXFrPYcZXJQXZJId2mXAZgQoMvZkXjEo/aI7lya/0D+oE/onqPBE9cOf7p +nyl8zQ5lfJzC1MNAqWRlAIKKD1MhyyLOvIyghBXrabocAxGIToctZkVDk64gAWNXgTpBRoEAk5uh +Z8kjYMIetoVJmTrtz7TlL1KvXWLvPipddyu58wGGvqV+4u7ba+cEzw6sdgB4p4abFijqNS1hvbku +C9Zky4gzBB72Zsle9VYtM4AhpqBXgpQsCmEyJsHxDO5t4Trf8/pkERwQfY2ZbJ3pyGY37W1/RcWs +znzOoiLVPvMMDx/j8BPdF94+nZ19wsMOuyauRWgrNsUqYoZDiNui2I49jFbAIdqYW0eHFH/CMftZ +4OVw4+PSLpXXSJzFyXbOasmklMethS1JP9+6tbbZLFM1IhHnm3P3y8/4WQ3j0dgP6HrRoRNEn9fg +eGyd6D35N4A9V+TouF7ETuZH24KcaQd85u9nsTIv6jm2JhrFa3msUFxe42Ux2QptWaDxtiKYxlaX +A5Tn8ZlMrXr6wSVNpvZ6JD531sRkq+yc5tdsKN6V37WhKbf0N/iYvjmRPLH19Lf/RKSD09wg8MT1 +1hNkTA3z6VAoACwJAnTKRzxksLMcHc0PaTswEWm8t0cw7lvWDgbbwUjZQZmlYcMgm7IhOAepTFtk +MOEUVfNNU+Pzre6fwqSuMxgdq0gv9rK+dmCdVO357fN94q3/yy4CJXwKiPZfV+qui55k/dhXnPBk +zD3/gjeNHJ+4aAN5S+CIUj8twv4pSPDCR3vxRJwa+XFi8/yFxFsv3NPP6xu1k3/8A04l8OJT6ZXj +U6FR+Ucp/ZhX5yDDqzhE8C2tJtLy6LyS/xpKcH866C/IWLuSg7Nc3zdZfY50vTWqww/1sjPNcz87 +H/XPdDrU7h1vEEffbhUHI+ZGO9bXxznUSI5MZYS4PWw8X8SCLy+mzAJvd1wsyazcjvceBEuSAwut +y7bb6WC8IGtNLFSrJZYR2Oy+2dFeK+l+ENd4XY/p9AB8LdQfZ1B9UKvxXUWi67yb8xPP+SRPFYWg +9/euMiSenNHXcZRXNY3elDuKbwTcXjr1Prp9NQ95+tlX1ZKejfDTHfz655w74uWiDPy2k5lH4bE/ +bvejIkxXDzypRP34+46dPr/92Bd1gL+s1RSF2gu73/D0LBcvjDtNBgfXyiyqm76i6+nPHza8vP9a +A+oN2VQJrSuz5x3OaVTkFwJ5rQONi/z1N3fS8jSGKPlzbvT7d4/3isy4UfXquvrUm5uvsf+Ppc3/ +Q/PnXvRbquSnzR4C53a87vARL9Q78hc69fVi/0y9g3pdVPJwu6h3pruOyRnEbITtgdnVA86O/YrB +x2ZVVGVkMbgDrULPirIK4BE0Qw7hiJR4hrSXrr8n7ClVCvYk4GbNHsa+mb//SZ2141h96h5Po9NR +csDHFtcg7Ptj7M+Ctu/xfkf789Krr+Pt6bchp2W6LmKWGzdLQVyXgesuWieSZ3E6HZxngx28bqab +FDRKaMyQbrZYkc53E3BEFaZ30CKH43CwEotl4e5QAtQoVMz9EAZZWKKQDbAl13Ji70zz4MPTubXp +WSt9OR4f5/yfidBtprwvpXxrLna/F+wN7SOb3lw5z8K67OMySFZEtGoIFyZtygB4QqYJqJoGE4qm +JcBiFuFkTu451M6qxZCaTlyQ4DWU389bQuPGvV7txww9thjFyeUMHJDiGkcey1o7f8HxZ8EodtMp +9oir/ILuC5+ezrq6y0MIWnNLwE+37GgMqFu9saa1Pe7FshFBh/1Yrspy6W2HSusD6aLpjQb8fn2A +J2hrsEQQePYqjpuSyFajGhRmhKSoYXyz6rwUvpx8xalzvex+fpySaMfervcrR89vFScePORr/aSd +n5z88O65t3aQPtB13TE7xXqgq1gDH95tt067wBBAOch57HDsIAcPVlKXILMsamfmltRgBiMm3dgH +aYFMokBYLd3BVNxIIbMccLFe0eA3euvz13zFyfu12Tvqb/j3yrUOOs7a4dM0n7Nj1E5wRpbM9Wqm +pqgfKxsknI23cm+4Y9WdB6u456zGTmuFfgrBFKKTgwNbDwYg3hrgAllB657G5xnuNZLwzWHyc5F8 +qQX69UhyUVr+lra838f4QvSF6adkizOlr3mtL8qD3Lr6QW+Hsa0TJebSalWn1HZgTrAQX2sgnevB +DFGLoJ2FdVNRe7uIbUzAIWK9rgCv6KVT1fArc1aEXl60ssz/2YjT4xc7ZtO9MPNNy7STbfq+ueej +mzGuHQrXnVGrUuVocIXZLdkAH0qvvyb9IiE/L/TBbqn1wxE88nuiu94Y4TTxpYHkbnjQaZIoTqLD +uBgaBzlmnXQJWxCXbxWYAwyNDSjdagdQb1anPXaq+ZaFZZEXb0bjlXMA4W+WDPtIpd3RE41T/XnV +j9SbffGRTcxfyZ54/fOkf6bWgc8NuYoZWJoJ7dSBmKQcJqN9uFSVZT08mKMJtnTG9QpZmh63bOaN +D0tW3VOAIpCiMJgkrj1DmNBUZ6W+w6J8l+CDLFqt/mR/dJ0gaColPVc+79wpY6WJjzbkZ409PfIj +MG418VlH7ChS523JTuGs9cnpdNNZVBnqi7O3H0d+Yzq+/1P47k1o+u/QsQc+FxD9CzrOSLrsNf3q +Tf44tP2RakDPNE9y+3TUx7pV/dF7/iCp3Y2RiYg8LGHT7q3CYBRK25LwN7GrpPbGnosWtTBJMM8N +V11JpM9PnVx1vWjtMIW/BRfLaLXcjzl7TOOR/e26dE7WL0Ln5DrrPyd+GZcOtntnsZ39Hx16yKXH +uBPUvvFpgW34MZPthewZ7+fj/hOxDpYtj4sZLXHUtO7JqKLzA3aPwrZIas10osoQg1gJqo0XAsaE +K5I3ZOIA83ahoXRE7ZB9UFJwNO0JR6yRFkwWQyGjo/l3l2TyyDPCc5KXE5q+8rP8+xuP4ZERxycH +L06NwbWb90zkwiOJva1dXxz5gStpqjT949w9VV6CTdBHAtp/8frDTyDvWoN44wj+OHT0kSXVS8Jn +MXs9PVdx77AkscEn0cFaH+Y9BU3nVSLW/uFgLF0RQLQwANcLeQhODX3NH8AYLwhzPWZAW5AOq9ib +TNs0wqdmQONZDQ/UPZbL87rE49U3l78/8eN/11v/pbv7c6f2Bx7ie0XyL+hGEuA/wN17CoA/p5Nf +DLo3s9cfGADfkj/J7NtrT8nrHUZFtTAqvp2V+ylMuLqxEuXx1NA2ymES5sBa2LrRgR6hiy0GHrAh +wAWbKeUtRrNhYkPL8aAdzXNBVQ5T1FgVUDk1lXZRuch3p7GXRu/Lvhx3j4Xw0w5ynfA6mmm6cct1 +Cj5mYr9QfYLn6fg8kemEypoDzZjK1/xGpBfkxsBsBkbxnC3UUbSeqshhTmLzeibz8wq2FlrFR0TV +KKrfztoFibZETRJTaDJ3PWCeYzORUPafhsd17nfd4sFeluR+XXz/meKJlae/XeP61zWwbbQDBvIL +JZlOSAfT+PVkMh629VYVBtDMDvMgr2aRIhqj4W7EE7ZNxXg5FpWZo5u+u15hxn5L///UfVmTqtqy +7l9ZcV5uw3EhPUSchw0KiogNCKIP6watgPSNgA/7t1/RqppapTUpq9be50SsNQWkEskcI0eObL4U +9vpKAJq9Ohkv4B8CB+yS1/8eT/rnEmxvKLdsvT7vmlxLaONZPSZSjapHWMhX9d4tw1VcgyIvzcz5 +bpjV61ws4ITOYGQ9TnAxk4IZwTEylwySDIjVeZ8jUNRTdhIJRxPRGcFyJ/b+7SDKO7324kcbF+Ip +WNkLyROvLwc9ohuo7J5BsuNEJSzKL6dblwQxfLnSBtXSqRvXmotWs9lDY2spcAVHriar4Wq7nBRe +veYrzWKpie9RUDhAoaEyS/zAjtEpatM/Uxz1FnC602XozIjeS/i6bWt6vo34kM7Tbn3O+v6FDPKM +qu8yl3Zm0gvtQm+XyQdyJZ+aSteEW+lenfbIbhPpqILYWFg5A1tYR/WoPwyzCoNcds2NHJODa09L +TRoBJlR/PSwXffkQe/Icm0sHk8k9J6xBLub93XKGxLP5SF9iC3fK7R8twl+T8dtEuAjvXUFjvDtZ +8kG827XerV/oWx9cEedupIZ3uq24uuHvkbNd9OzW56bnnh59GkWAzoCXX5b3nQe0cr9zuXd+Qof6 +M8k4DHmjxjf7QLFxqbZXdmCLUr85IOZmjC/yxXZsRmpE1AfiOIeY8YzM+hq7KskI39jIEtDdQtYz +E1nvitk6tF2ecX5info3OhTeo/D/XCjyhvKL5N7Ou4YjKUf2Zf2kz097OZVPgFqeBCweOJXLysR0 +Vgj6gOH1cJz7GRzpEOPRzGQR98O57x/J0WSoSHoWDhajVPfUHRY6vkGRg2+6mr/U5eBu/dnXi5o/ +VgFdsnduc7ge9MW41iUnIbxWpd/5Fe9qp68XGj3v5U1oxMGvh7+/Ia6it73mzVPDFmryTfbXBL68 +If33NHu4ZtvPFQ++UX2ZHV8q489XssP4sXYypKnJgRd420krQoEHA9vITQLdextcr7xRvBOKWB4Z +O3/DgiMQCKicQ8Q1t5iZFG/G8wE6HzrC2Km5MPk0nNzFF3ILe3B/mN8Zx8+sUh1Ls26Sqe+Jjnpa +dBeyL7K7nPSobsLbq4N6wSGHpQjO+gy0CONUVdLdeAGwtuqHW3kZAVA8kBa1BS9gaAFzEBXwO0NC +xkycG6e/UNw5HZvFJHLYCB4ZM9jeftOR9Y/cNnt6VJxe92RVGYF9nSD+wW96L3/8G4bGv3zZu9hU +enlSTIFnZJeMyAfFDdQzA+TjA9qR8vFq7/KADhVVUGM14yw1+Vrbr12wZEJ1fxwc+DLFGk+A6VVk +8Tam1YIbB9kIFFebxWnHuNnraL50M4OndyN/CjP4bM4SGad7HOI8zMf+mvV63cf63uJ1FyvjRTvc +rj/XZjD05w1i9budxbttxCd2MnSTddaaydV1WcbfYx7f/y2PPAtfT1e694BfA+zm8tnP0CFByabD +6d4f+jQ3ULUdQUNlVI/zqUPhUIg3ELHkUi2ltZEP7tS9wGUsP3DkQnIqJRjNHHvA+jNJR+AJu54r +q2CjLZpGeAhSfW+A/Y7xnfR9/BB/EXrKwdgSPDM2sc6tB7qUnCuC5OLgXuFi2lvRxWkibieIW1HV +rK4Bhmfmnh8FI2oRZZN8YMp+DlVNM8QPk0TfFLvoOMyEjSSnDjKf45KjU0idSz9exf8vtJ4yPQwf +4y6gT20PzzRbwZwPehcyHXoNkssK8Lw8U6y5uAcSOPTZcVyKIcgwFsPOoOHYhfDKWyWSst3XwxGy +qO3a8gcHCagOAjJdL6yMPURLw8qqRKEwNF90awvxycp7eQc/B98ijdj7rb1uxFnRducssjZg8gh8 +63EC9zsXEHzOgf+a7vvrxdl/SU84Zyd0Qul5kdXNtZufc99//UyS/i+yp6Hx66QHd0vKN1FOcpQQ +tAxzvSUUAFqnfboaNNwUQKICNtiqj1VOLR+B4TpZ516xC+XdJmxga2mtG2EA4RTKThepmIOboyLP +4uO0IL9pl7XA4NVJlb+E+bAnFi30z/oiswdIa7/Jkm/DmBcF8Vp791sKHxF3r6jcJP18A2v3dk/6 +aG39+iC6onsaRVdnXTtfQeZwZlUTeKLHbmgg+Q6dh4IuMlU5QMl8E3nYWKng4SEfkFN/tJoKlAvY +BqThUlPOxzbqrvrKdLDGSS8OXV+JBSUNHiZR/w9YAN58A48CVV/vnnkheRHP6eAcqurQNXMFK4Zj +MCyHwJVnJxqfi8FqTQHWcDPAK9EFC/CwodGinItCuj6CEXLIoBkn10uvWQDHPRxqeSzSoAcSqYpP +hbKACuibE/xf3M7U9XZucPq/+NN/OG1OP+AZW+madCuaq9PeC80OFQiGs04aSTTFbCGGw2rCAJar +gbanL4TChCUG6C+3+T6dIGtfokFuKPdtyt1mNckOwMBgD+ROayiSM4fGTAetPKH1ifgZKiryVVQr +6DZt7BNWx9EjjxHacgN5YtyfSLasPX30Xmj8nqWjVJukG7Ce7CdhGcSrLFKhLauNECctbED190oa +S7OtZmaKZ3nKfIE6osyPxxu0yNMtIwDAXm3WYQHStCMrZYMRoN0tgvg7TuJ/dgPwPYPeXBJmPmvs ++fV91DXhlq9Xp10LO6RSdJwBSTHz9TLe9NfCKOHdCNtpiMdj6ByPJLrfDCAYnW3U4uiH3JrhPc4i +xX4NbC2tv6AkNKCHOyjcLcgBsahH83X5XFlR+/MvxajwY3fGU0viL8IvXHo5610I/p5L6mq7F6nR +WqILNjnYLiHKHC77fpbM1NlMnThcmRD1aoMoCVeEOOHEDTUeqlpkTwtOLdBEPGL7bbGbmYdB5M04 +A3ID9rfJzA/B5K5e4So97pe9/KNVCd1xsJ/Heoffe13egexi77PLbhr5IDf1BH+8Q4InOsJxXo+S +ryP6P9kf4TeI/h1zWCp+T2eNlxZgpGLsUkiXSYzIq1ieq9SkP4yMSVoJxPoArjKTgo88vdmiXCCW +wGTBraGhM+IKEtquBqPdkNUNx9HsafPdOqMnpfxYjuj9ot0vt2X+Afz9jkPl9rvfAHCiT7XxuQfA +iXZr5qP2XX+MWqOFS9ExlvTFWNrgjJoW1cB3j/iBx6Yrkp5g2BhAdxSIHoxxDZ3WBEfua6UZTN3h +mM4Wy4En+sPa16eks6jdH+3DdJq3388qfh598zMp/779AvxU3Pl37RfgbpHn+ZRdMT5e9ee5vmMq +S4sW1qxvRqLDUXEywykzBohtZjiLUWYlC3XGKH4fzhMPZ6AZUQ3c6dJbROhAHoPHyUGrMHwXjqt/ +aTHck+0XnhPn5ynj2FPG2aP+Clg3w8zcVcEBhDxu6XGRQuGatpPmLlmvbLvIo4k3zFcmsdoMppxF +AeB6tufTxar2RJBMZItU+czVRisHmjVQCrlpqabDCYN9bXo+ody/vO37/o7+Ow0UPhsTn4U9kKcq +GO91VkC6VS3i+63QKLofDMs0GAuqBlXErskDnxIXvHbkOe8IZqMSwcoBVIkesBfdZTVyAzQoqDIa +UKpB8bNoQ20RcEsjAOfS8lT/wdHwvrPCh3qBp42+nxoeX++D8HBw/GYlJ54Kyt9byYluAfnVOttN +55yyXI0pCt0oTQA1K7Rs9MMGi2YMFpaOA0jFWk9n6oAW0D5pYNsoMma0wq6nq0FShlSF69mK6HuQ +Zi1RxZ4vfhRK+9++kl9DPD0y378usyu6543l29nZcO/SioszJIvWAEO2whilFa6U++uZtziSsx1X +ABm5cnezdRhk/tIvoCWxlSjguApMGyYxqkYFWcsqPtftVTqMhWVYLMhkGn4zQ+wVwOufH+awF7mn +WX5BMPvnrefzjxb1qTjnzrTzO3bO93xIxLqu6vnnh0yrIvasVr6Od9EA/4Seq/u5Tpz/fLD9a4t+ +7uU7P1IgX+/z/IH6y5C8uda15/NBoBYY6CmOFVAYzQMTtVFK3lQLC42dQ5HNM2Q8K0S4qQeUEYkG +ayVI3Yfm7nIW+QbJTzYeQqrBikVCRqtM59BUpfxd/LzzC7y1Bibep1C8xQ/v2BS/LRXr5Hx+h115 +Pz/8KUVyTbmV2/X5uaNCF/x9YaDjRhVN3EPtQ+h+u8dmg4WJjw2csXKFGm7NeRQuBTmaQ6qQOWr/ +ODgURbHYKjlz8MPZMCKzxJw4SSVvojHjmxQmfqUK4PdwrW1FXgdGe2YcHXqBVzzaXLWwhV+3yH+R +PbH410nvTO33/OUFLTnwR/9kTmkrWjFUxhSdkdxnFzqvFWv8ABwzQJISwE2VKZvE/bja6jVeNVK1 +mE+MtXH0N3myrMp8lTtq1vccF/3UVdphTrS9Z7Kr5jOnoXzGD/3jv/54ruHZuSLwv2fNpGfbNoGh +j3zDTwGMvtBsx8Pl6Jwm02GyWWaTusODBg1QPNC2ppoOEgHgClFaqhYvznBw6GB+Dh/jUsnTEcHj +OVd7BT8ACGEjwJRgafPp2Cqp4xTNuShWl1F62+rsb99h21n8i+9dgC2KzD7x+rPnVFX158t9F5Pt +i884zcm8DM5oGJ895kL2LMAXSISfRbE56d04e6R7nludLyTbcXY+6LoOM/QOX+5Zcg2syuU0y6q+ +ssuIsb3TrFIqS58ECw/ey3MT8I+QFdYkuJ6ZfoZroyjFNslwXXNVpeuHdNgHfF6ZC3aw+pkGIF0W +TC8MbcvTH6px5DlWvlJtufl6fI53dWCops25okmH/mxIL2vV2dQlR+woPgB5Yx2GwXIHixthPibZ +ml9B6Q6vTfTYyMhYZ1l6tcsho3COdQphpqd4G2Lny5o0ei7edWVO/1xqwSvRljcvh13TC/bgYaRr +KLgJdGR9bMTBYbWcaxubHx/SuVBEKWOVx9U4OSbL7ZHO94LobmEBYCPGk0XqOJJjnrPFRBNqHbU2 +9pZfpnb1iDW8PPiMNdeAnQ8igc9kWP2i2/Ln7aR3IddhOo64vJlYWJhoCZIJuM9b9HA62yUTRYD8 +yD8eNhwZCIDaDHWDmtBhOutv5sLQWkDEONgJBgzY7mI3NEm2iKSpMRrQovuv6+PuJe0Lf5I68VS2 ++BvVM09fjntQt8TwvsCDeJ+o41pexWNi5M8gzpGNaaz0AaNYeaafL+X1MnBBd9vsZ6SQhKJDlJtq +sUYkQN9vcQmsIHIbaPKY2WjeRlnMf6ppFNTJVr1Fq3+QLvHMWL0i3HL26rSHdgtbA4udBxzEUpnt +Jw1beyJTYHzAxWIjRBl2dCeokidHjFzPXYbDljG/3XPNbMwbDF2Mq6NK7/aYVESWOsuH0gyHwDAc +pj/B3B/wBj1bPOGd98Ohlz9alNCnIrm/yL7I6nJyxtjoAqh8SGIe359eYiJGtg+TmCXv8KiEABsv +65w4jhBmQ4eYcVq68t1ktq7qo4gfcW/r0bulhK4mSH8SMqt5lW6VClkHzRh5WMH9m2Up/7zmCH1q +h/tG9cKel4ojtNvOdhgdKXjGR8N0Y+5HrDI54CQlGZK3ktnxYElUc9Wmp8Z+fqQoapOkKxRvRIkf +FfIsgL3BFKp0eivXaB9wMWqmguxpbIP/w2tfH8CCPYI8empEf3jARXgfLp8hkDqM8pDt90fRUcdY +lkGGeX/siE0QbI8Gk4XTuYYcnHXsUzS1YKOVk+nFEmRMfTIvRTfau752OC2f3H6DqOU4LehRslqE +u4D7mU4y/0Y5nhG4Hq7IzymjM82ztC74XlA3NaROdy6/nok4O10eY+JYheauPwtXarMWNv6Bt0US +afykX0nDVahEmYgTpLM0TIGJ8QgeTFiunx/jEQg2xQ5YCYFOUvT0WTVk149j689x5UTxzJPTZ2d4 +mHEtThMqiITxaCxFO2rJudJANDa0qSYRTuWhPDJTxEHw2t+p6nrl+miaTo3VNEgJOfdJBnD4JcSW +A3bEw4GQN0ubf7QB+9wo9uOHaxbeOi2+rpRbiieGtB+9C4nfM4TGZouI2JEsfRwpCH+UcmDjpaSA +RUiTbGQCEzFAEDx1bCl27SRrAdov0K2YEstoNRrGoo+vJpBVmOzEX+P9ZjvUZLRbDcqzEzLRo4Pe +YSbeAlD83Gy8otsy+9dZ11kpe4sDSKrJtlwbh6ksFquhQrqsk23XOzAcg5EKGmjcH2wMuS4hhV8u +plYlzAd8M11qgMov5tghm2qIR6ZFyjWutZAV+ZuOx9MbRGVo2C+7iUunpy728vn9c9O1Q71XxL2H +29/nWp99oP7K8etrXRufAcP1jvQHkxG8YqOkIfbzECRAutY3sS4ZvsqgU247beRtsI5Iux7lCI3O +pxOJwnFTPSgwPiM0arWuA2CSV4R1pFNh9d0uF/8wdMMOwKyMCi98C4SQt9mRp1fUg51tZOda02eB +QruAeN3wNtNb+T3SUd+YPO8e8F6mL5e7TqeZSIILKkI0X3P5bQQFU3fP6fRgNVekpeavXRVlaFCK +5geyPuxOUyahNYqfo6G0rOUakoIYLdKjnRr9fB5kpT5vEKt8Dsv+5jWa5KEFRz4FjPqB+nvGtdfO +0aUu/TqWbqxZ5sFEVJisiQHBiDm6wID9LNgpimTDfqisoBUIxowkDrO0gZYLO5h4YbUdxcR4R6kL +FWGXKsZEKeoaXAMf7KJTksFn7Dt6yWP98cw+5UzyzKfTZ+9C5PfMqbXhwTabVTKaZimXHfaZIsd1 +7Ux4jB4TCnms60I1gyRXCnGQopMlTPWnG5JeYyYx2kUZuAFjATCWopEKcBoWeySZPURI/N+nMfXH +XPpjtJi2Xs9enPVaiNjs/3TRH8Gl8dc/kffJN4m+P8Ne/PMDCswdSIV/trk7+PVNuV1ce3tfu451 +0CDVI6it53IyTvRa8VV61xwMV+L6qJNO+AVJG8Y+xWbCaNZnjAyZ1MESSN1t6Whq1h8eSl9oKGQ7 +MLStOB5OUXZexJZsDNb1PJVIUYYKjcbcKh1ow29q+UtA76VBTBsUKfS2o9urxv+ITHIfpOAjRkEb +L7wKF/6FdUyOv6AO/Jw74ETvLKW8qwuAFXhQBJt0EZkjRXFRtD72F7XsWRqXgUDWT2iiD+z4jesf +ALsgmloEcpjaAOpouI8PUuws7bDv5IRycFBgE9JWI1nlN2vfLkP3To+yZ7m8jx3ns4YaX4+VnCme +OH3+PNs9HWIkQYT3TZc1kJgYlpDe+FWAM5w3m0HVVgAQcyXC1XrkjafscbABOWvFzyBWwtT1sBqn +xAT00UKOomysjzGakSF2jgO4fjMjXD3n20EdBPK5qd5/XOpnf2QLEHgnq1RP9Oa8CxDi1hFXf7R+ +Xkt3H5cO/2N/+dsX5ll6VnlRT89CHP0okIf3193udjLbNnKrO/nXP/B0BP7K/R1/T+BFZd3911xu +7/pbLncHcRztvkI+83Lz8JU/6PiubVbCV1j5en9H8qdRgMDdWXm5vetvudx980s66Jkmt4NHLqfT +6k9dAcl31jRnmq2qOR/0LmR+r2ziWAds2WBmi1WMiI25YMs15ltZvbSWlVUwyHSAuCjCedrS4LMG +K6T+AAuGI8K29UDos+iQ0Pwsmi+wIa/swGnjS+LmJ3yCcNdC2YtJdV9nP1MDcqJ3YuPp3x7SrdpD +0T1xcrTXUsCW/pEuK2wa7zfQFLPN2XKzFZyw2VJTohqODTDB7ELQa82NXcbMqj67MRpgBM5oDD5I +8gydIZRVj2n+YeC2a9eKa2Pwn0hHY/A0bfe2FT8KPfTbnS709cSvV7Jntl4Oey+0OlgeMhhTaVyI +yTGZweI4B/gUnJhqPPdJTscqb7nJVhaXHOio0qb9HY5r47FiUmtF3OMRHTDFKOeWMBrZgLyJDpG+ +hLmHqZCtB7ADd808751mmW3+gsy97QGc5/Er9hl2+9W7YuTXTi/v7vhVh3vuLPEOLrF0m8S1o5cH +PNNL814rzc+BPMzWi/fa7fJO+PD3IB5vFH4KwiOIb0yR25Ih5IkNe0uwHaOnj96ZQoeQyozebaFR +2MzcIUGXabQaIaC6hPGYwPvAdsMsBH9xKHdzEoimxsbR8JWaTBa5zRzixLA2QJpswUBQopA1oam9 +3cjIku6Ae/WYK6Ge7R86Ms4tGb6+uFxonlhzOehdyHTwnOIj80BPxztcQGO3KFGWqPs6RKcu7Se4 +qZKCO5WbGZWqehIdJ/syV5l6K5m8QtH2JjdsfAG5wrDMZYOdH0dNU5o23il9yvCi29H3xpb2q5f3 +aH2nX505f8Bd1qSPoKU/hzDzjvZZKjdXuiLNgLxWGBW7x8arRcNWjaDh7mi/0WqRigwfRxnAC9RJ +NAAlnOknY2yEqojRT1RjSgyZ0yZj7zJ0khhLJXBwDtcCajouoR+HGvuEye0Kd/aiPaochJ5yYl/R +bZn76+zM2A6b5eaI1JI+gvsmDjLz42ETD/VRsQhHuZkTG+/AF1uWTW18ZFQzZ1zWJbWZhYeI3YtH +IbDo0QYFyX4imUtpK7ORm5Z7SuuWqfw/tTTjXo/3n4s8fqB+Fuu7a10jknK0RyBUxfSGm7oJ4uwV +iS0NfF34jLOwBouT4ReRIBmWUTktvY2b08yOUdd5fKRHgLgWDZU9mJaZGB4lEVUFwwG1/JGMqX9j +ED30whMvH/U/hP7E0GekdiHayupy1LsQ+r2IdAVjJyU/g9dDOxyYdAIfOMZJwBBlaXc9iZSZLFd9 +r84JcK8ZFr44bYPZsJrsZxbnMqS+LqB8DA9WWjatY9CjRyoS/xSEVpf94fl9X+H8HiXuft28+UX2 +lafnk67ddKfG7mjt+y7ql/GScgaCtkaNpq9MUh+I5vOMp8QJlMs+GvGkzsN2DKXhYcl6NqoOoV2Q +yzDWjyBsmq/zTTEod55cyNg3XYC/Bt65cRr6dzbk+xdrRC/yTuv6Q4hDqJXZ1x2Sb2TPQ+DluHch +1qEsLZku2RxQp4MMipQ+o8l9ItQ3MVcFQ3rc30W7ZVkWRc1XZTHkWHGcwkagAeQh2dVDS0Am0KLy +BxPPTghi7hWrLToNHiKgMUFpz/V9713g8hOvfaabdu/E4rYf7UvHzdb1e0fAn44JiGwBD187af5E +Z71Xterlum52lX6iP0y/Jp6C/X0l+iL69rBHdIP3LVhmnA4jPhZBKNNEFjru9jq1w5dwYMaDfT2e +liYxH04wpjYWmIWa8BYzR7tCo/clRsH9/qAmLK8cr+YbR2aGZISH4UNsyweC/+2WtpUXhL6gixId +uXwMvMd9e58yz1+IvnC5PTw7/jusW8K23sQQo+zXQ3ilctOsLy5jkTwoirdbD5FpMCQRHSQwJh0A +aMr2xwakxtgB4namo8+0g6MdMwBj3SV+GpzgQGc8fxV8s+rzaiS+1nx+ecvUCfU6fGzzPTXYz8M8 +P6dGdhjgOBccS2M13Y6QCayDbaF+YLOuf0yxuN6NG32gUM1GO5jT/BCr+niSgjlWazwOatoCL46E +RNX0vBhH8hwstIJD1tIq+Gxxe8yIyN7FhaefbNIf3Tb+Itui276ddN0szsQFI4mTnbcc+4ZFJu4I +UW3DqtH9FhpDMJQZAcbvxdSe57qbFAzFCDFoEfEEOa60dLXTdxFsrIOZrO3d/lIZiQgkbb4Zpm0R +jdua5CtIi2f6gvw3tQCuBHZz/d1b/1zG8TXh0xi5Pu2cYewTykJj+76e6vO83M+2ksI6rAfT5pQY +gIcqrMyx2p9ThD2HWCipmW3Z+ME2q7HcXukzZgcpOBAjWJXoCLZ0TBMg9H/p5uhfLOP4Y5vwn0ve ++kD9Fdf6+lrXtC3QF7axmFR9jhxJVYCC9lSaL2jEdEytmNLJor88TkNlBY7LxWC7bhiC31DbTLSF +Cp6DEceniyWDLFSR0jdhn0MgmNaGN5uq00TPbFN/6a+t5PYfTVxmfySBXrRpFf8r/yPSWx7/MZyL +7OvP/8OL8sLWrXtB6r+ncPe5vvQdHvZzfel/Nxn6Nz2mfzM8PwNaR57ysz8CWke6+dwtiSHIPJuB +Ab5L12Wgu5Sc1fYmqm3L4kdIHxjNUwGk5sFUbaY7ZLyIMlxO5+vVeq4JUjWA7dFmsN9i1GxWyruD +nCW7+Xc7ObetBMvMazNcrzJP0PeRoTt9c29QXO41Jn5pkfMdxP2/XgD3X9D3H0C5/20K8WocdRh0 +SdjLyqiX6A+7AuLPqcMrwu3Auzrt4d2UIJVGDbGlhvlSIeclQrFSvlDQ+XYZyKsFSsju8lgKW3wh +aclmWvDcLgCHLLNhNSE4mKwOUMVYNQVywJHQBlYJONW37vqbQ+/8+/d2c3/AnYuFsqgX6rtzj742 +YvgMUty/0bt4I7ebb65e/edKCV+JnobI62HnMkJdYpskJeq9SLCZs+Mbun8EGB+lR0IgylawZGH/ +MIlxt1wPIdbaCxsVGIErNEr7G5aDD7vVitynIifEUDmOKKyfod0qBf77FnxGJxaarm3uP/Flfj1G +80a1ncivx2dPZof4zEjr73LLGKmDXSTtDHukl4bjJ4zWbKT1fD5Q7Y3bJw15eRhu0/qIRZaWQ/OV +Qxegi+AjqD7wFLrh8yTn+7nKpbRKAdIjMX0Vzc+I4+ANZOm50oGT1oeoLyv4DxbK77Dg3vj+JTC4 +1xZ+eQuv9HDiPhO3u6F8Ghc35+ea7Q5jI5vsVstor0RjKOcqslnhqqwgxyGSr8MSz7cun9sbUtWA +kVQiC5wjuBKYzIax5uwDNjCmEzkyEU5ZjlUbNRXM9QHGVH5iB/MOGei3DD7ZxcklQeWBDwF5At7i +lvYvHr9c6F3I/p7La5zwpgE6gVmNHa0Mxx4PHCfzh45XHKb0bNdXAg2pOEWRVzUFC5rE2TtxrKg7 +OWWB6uDShoeuU3+0o8xjk69UmE0M+0dwVf49TU5O2zDHi7zc/aSIGH1mSvyi2wrr11nvTK9DeqAa +HPc7hJ3R7mAPH60DwU8qC1wqQ/QIS7VUJXtztCGTfKCag812lqLVJlLX9HQsAkZWlBPfXqy9DQcO +grAcZuTAxYCHba87Gjz2yZb0srx49YV9E6LwM6mYj6upnglptgTPcjDbaqlOscxgpk92PAAvMUVa +MnvTZIXxajlf6Jql1NF2ywbL1XbTFzmFLnU2tSEWmDWHnXUEdb6ZefiWEo9zzDpAYzLCSHDEThME ++Gb6W5XpSXL+kZ0U/omM/iitnngKdv1CsuXk+aBHdINc3xpD5khyMkOKB9LhNrxyOK440VKxQ0Ah +YGwWCSRahQAHzsZO5MQ5gHYV2uUuEY6gWY0KTq6BTamI6KxKtvACwzbeQ6DWJxD64AfL/eeZef/Q +q7yXW3vQzOwzfqcetPAXB69tp/uLOPInRZzo//FfN/vNf+ThSW81bSck9+pmtN0j/PFf2L1bz7CI +RZnZvQN6uRtrh/If/3WTJ/3SJvMFc/Dqi2NsvWx9Yey8Nb0btP19OmGX1+6WafgbdjxN5B2jvkyn +yp/5qwt/fyrH8ryZD/Tq0arUh/GnQIte6b7M4faw90qsA2qRavdxBBpYu/1kWFnobDaCGL3iLQ5r +BlM4nwOrIif1UC4qYIwfBEVa+X0BzeY6CrhcMtlDw6jCpo0QYEV1rDRILWi4+okKmU8qh8/4qWbg +nf49A/WacQCexu/H1eR888m4zuLEM3snPfdyV4vi/G53/48T4057IPMCl3emg9z5vkXDSYqXhrbE +OxK2np1+shf0qjjbn/bUXq8ovcvzSPS2FPEflxax4O5Fo7eBhnfT+1c/ytOWPbq4weD3Kc5XTSsz +Pcpbp9dp0rZvXBTBa+0cfFvU9Q83Dm0j86ydDZqeHl9uQlpk6+u7gsayg+DicUoug+YMg9wzThrk +T+hWo4XtsNSDE4vfji6/F7/1yv3jNB3s4BwQqe8ID3kvlTA+ekGgv3TD9oKX0dsi5N3e+DYNXh78 +fjrd3OOc9J3u2BdK76X4dtcZbTg4LTOX+5A/iVsl7gUHT+/FVtXYGZi4p3eJ3hR/e/vti59mrVnq +4On/npV5h4ts+n/C74Cl9dbH1H71Ud+brh7sPzrtzt/Ee8/SzyQ/9Cxt3yWxnNdfdcOSk40d6m23 ++DP7P/5pFr8MvHbHdPunluecaVIfAfILOzqc/4j4E33cB4d8/4d2bZv6/Ye9xoHO7/duODteYL8F +LuEPWNxvbW/f97htddNtE74PHffaW+K8xQU67UlOWzMnfvl50Ls27Ncwv+8wfduvX1E430Funr7y +T+y4TJR3w7Atb8cu38Dv+ma/1Iq/Lww/ffVadvmx2OqtUOp9VdRZA7/VqnwoTPnjkrfwmj/1Plmq +/Tp/UV93Gt3aJxXTK17VJdx63q9ueTNn39murdFyYuZp6b98927MJr1QT+4yM2njPCfjpeXdy8vc +ztkk0JsqawXe+6Xo8Xfj6TTSiqLpXd6Lel9dnmbma3LT6UffTPG09My9n/cqPX8Rwru3yvTTWMrC +l1hE/ybi80dbeR6+qAXiT/JWRIWevfIJvkWaz057uNxr66RbQHH3RcLY7SsVeRDvXtxB7ypg2olj +xPXbGkC8/zJ/XbXPaudGxu1e3vRelNW7yVzZRi8pLz8IOWlr4v2XV7/85Ufj7wZe9aIm4HdDq9HD +4DLmqLsG8aXp8gdD+EMhw5VF9nb8Z/hEJcNJ6Zz+Q/74Lxh5yXQ78RlrDfmLYX66gP151434+9rd +PD0jex9s83VEUx13iuc17ObqHYviUWr419OE3hM/2aOXg3M6eIfEocjch6scshZrR10WtkCZdVof +WaAfQqp0CMrpmiGVHXfM/R0OV0hauItJ0V9tignDWiNiblsHZ5mih4ijGxb3dHEvofA3I0Kf9Pv+ +6iD5tGt3xw3qr7XsL6hr2+/fDYVHduN9X80z0OS/edZpoNy93hXAfJCsmT6HZBNL8YQ8JUgYX7rL +vDa2HlqlzhEyTUEDnAyg5wMgJgVie5CBKtX6eSmX0HKQN0oKi8Nk5gluM4W384kio9/M9TPOrxBd +YjXPBR8+b/P+zIDp6PS+P17uG+L3a1vxJxxR9x7QqpBfZ70z4d+PB78cYeraRVPaOxxXtC0eDxuq +zqnxBstoM4NZlCcKT5YH8V7iPELjtwO6pODtXl7lvA/NF6Y98JwpYiZOYS+QZLiiwOVPdo9AvyWJ +NiW7d2KgXT/gP/ZUGPAX2RPXf52cm7x1mIRpOVlqwUpWRlN4OqZkRYtJtco3aB7rkbuL8elMDkmU +haaMyZI5Mu+f9iSedGwk6ghutxMxENcHhEjnc4NKrEkgKqzwI4CYnbzTjxmdF03wSafLZ6rir+i+ +svpy1kO7VckfDYbKBhN6BWWG76lDA3ZTgRvPNtN6V+zJmSLVW4TfVkOEw2dFbWjb5SCKZA+a7muA +H8autQi4BIbhSqWnvGtvJ0uZ/XYCaRBn7UJ5Yk/xpvO+Hk/4fm7EeZd8zdavxVTvD4U8gh6DjWNP +BZReaLZD4HLUw7oFkgAeBFFzszBNlZxaITP1NHKwOTiUnCCHZZ6lJbycaZKZGd76YNagYgWclyqT +ybGWlvUu34YHV3Mj1JQFWw5jzletMvmmnWREr+iJH9JmrnttfQQYumwugxNzWgddnr+OHug9mff9 +Yd5lKH9Voq8/+EHMHH4ionsmeRLn+fPSFb5D/DbyJcgAvHoEl85hSm0jajKK7DVgYCMV99Nk0ywW +yQ5dqgUBIwa2nyxGinncK82aHVNMxdIEquj7yRZFeJQbThmOML3+cxh+Dzh1bco8SJF+BmblF92W +Z28nvQu5Dgi/Y282MHgoEKwARYtR5s4cBQnKpL/ywS0jThgMhLfGaSYMFqU0mBO2BYc7U0AziGgA +gYFZp9yUkq4G1cygbX09khPjM7Pvq4wz9dAOTP0hjCR249jonFr+SrXNK389PmMsdFAdU5iUVwxE +9KNqLeOI4hcBO2cRK7CWJ0Nmom33cx4qRc45OkgmlQt7N9bHdt7YNrCpl8Aalw/ScKniSmbNLcmT +IAypurXX/o3a71LL+YDLv1yfj4yhJ/L3X4i2PH45PBtCHRbn1VIMTaQCMLr2kynp8V5lGxyBWNKQ +Qx2G92w6HUWUNBqsdVatljhnwObIRqBNlPcliT96HraLJ9CGqA2xiqFVLSbfrTxqjWjLy85Os7+w +p3avf3wtE+pDPnYZtG6v7JLydPkL8HmZB175KAz+XNu6M8VW2u1n1zZ1jGzPoqbMCWyAguBsSe2W +BQSa+UprYpCUDUB3pvT+SCcFV4p5bFFjLt6PZqW1TTwwXqoE4kaqAOQSgC1USbSAYUY8BHzqmFCQ +t9AVu17lWeeU39dm8/95e0fSa+2j8/f4+xW5TUn49TXxpK/jedm+MyR/Dk/zhvK5KufqvCvGpiSx +g0XuE14J1gYWCxsz58ZyknCzKPdBDJ6rK0kw0OMCiyOtUjnkqIbhKp6Zc2c0AAbSMHEEUMFI1BF3 +CLkdD3Q2EL6JUHV5kUi/YGr+Ezpnwn9VZMS3NqU3P+FRpd3XTapfZN/k1Z6cK+062FbWvAEQulwj +Onxa47djvhS3ycrc+aNyqoAlMwVLw9xy1FwzhjHpOOicbNQEY5y+7chkycabGEtRriasDTXfLUfa +js6Xz5UiPmLbr/DbXa49uXy9kj1z7eW4B3VcwY44UaJb9ziYgqvGKqFgQksFu92sjbU+I+LNdGzk +5TE2M7xBZ/h6S+u7ESItUW6NQyoEtu3ZwsSHKURzMnMTWVBaF4ufMBJg+BKde3qQvkYzH6AAPKVU +zjRbPp8Pehcyv2eyV88KehJZqQsRiLpEhdiSrQnL41Hpxcya76sQv5oJ7nabz/sJK8bD+ogh1Arl +VitD3oI1P5fLYXSsp6qUMqp8WMxY+IbJnYu34uK0QbtaAe4t36/lVK5d67s4SpIfLde6l/D58qS/ +o2arW+vW+2PIss9Gt3d8rOjgJ2bsL7KnofTr5OwC7zJlYRlYU9rJoKAVZe8BM4Da6nDABGVEUkdv +N29GWa7XgKAs8UpYo9t4nbAbZj9yl35F+/5wsF/X7qavCqy7J6vjhuAw8yfaCnVPtb7P7UuOwT0+ +U09pxpZgy+HTR4/qpg7zQ2FaiUwOdpMmpX12yWuWgcx9l1PVjX8c0Ys5uR4NQsnIwgBH5UUF+pMh +OopZitQlIoMxuq+Zu0xAuD7cVJQEHtzlI4P+pq1ndyZ/JxJkef6+zdj5pJfeM+HAX2TP/H49OdfI +dggGpp4chExKAczAGtDgFMWtilQaCgmDuM4XslFFIdZkQgQfxIXXkEJD5/sVhx9LFfQxRszD+Wg7 +XOSE4CtA6Bs40d87P7l0v2W53GXZbeJLZ56dabb8Oh/0LmQ6+JB4VEFWcVEItEkPqem0tNCBQRjw +8lgsRYV1xsbBXY37lJFqqzqSPZtcR/6CnqrgWhxkky2uqGA6nuDTPjJP58jUtDbbz4boxyqcv6lq +6sKIul0anh7gdhj7n0dMyKd0yRXdk8iuzs77xw6aRZT9zdFcz+Z0367ocXLsi3Wy4Q7VDm/8BpqN +kLqw4/SIo6g6iEFpsYsyCByNCsAzEW+yOi5JtkRWlgihsl5FqhKOWPwnx3gLrhro1qOlDnlqqXsl +2vLs5bCHdFvm1ooPp0GtL4s5usMXKWbC1GhlrkfDxiK9YkoeV4GX7NjBEZnYOe15cyEuLHKi4HHB +IAt6sBvh9X6iNKprxKIMGL4N+j+xzD3vvnK8yOqVj1p/PNdv84XmicEvR127bC6SeUVbS3ATaEv4 +4JM64pK8lwzLjeQhlWmry+Vos65n/Mw0U7RPRxXBBDmrDUSjgLYFMJ/SOJdSeckn/HrYn+cRL3/X +dxXELY7Bawnzq/vqyl9xriy16xMTrgMQX93+Ph8m3NlF7zSM24SFNhPxE5fF133k72ifJPruytlt +0cFZPmy4BcKIILJpS14GyhSs+vPtWOoHiWCPsjouzPHaTGesFQVFylWa6rgss6RQm48RlHaWSdzP +RnsPNRvec4pNH3dh7tGe7sZV9Snf8T//b5veQF4+Wnyj/p//92lJfEzVfLDRe6Yk8h3xkyjeXeld +CHeQhT2P5AV9mEfWRnCqPoHtCrLZHpeEDLuzY1Eh6JFZOS5/nLohs8orntlhYAMkaQmqQ8zcrENs +F9PcqsyHocKGwra/YL/pNgyy8jSsTPcl8wR6Av3nr0sWHHyuRHlNgLskv+Hf8i21Qvl/9if1Y8+s +Qq9EWzm+HHbdbE0yjpTlqRqaBxObWaVZ75p5Jmg2wubNWNwx3E7WeWUU0plgA1mV9cvElfaSdqi8 +OER4wEl4J+aLgz3OnNKakmBWd2vg8hN9zu7z2Mt7ThkEZ7dx79wSNYkfdw9EnuxaefcZl06s9745 +F6F32f02YYgBJZAPcnndDKl0ptu+igy5gzsQzECwvONGnyjlmCYRaeobRCSXo8iyBuPRoe/uAWFD +MCId5GtbQBV7h7Mqri1/wmH1/KLykhZ+fyV5pl98S7DtU3T66MHdWsTTA5CYxM7ksB1lWWSvZzob +Tez5VKmBSTAqiGKm96utJy1WqLiBqtAR/AIG8DmcwOURBvJ9EJDz7TaciLPU3tvEXjBmu06u7g+Z +uq9Z8i0Y4PkVzMC7ydT9Mn9fsuvvMxh+Yr97pvjSlg7rnWn8nsVaOF/bhN2MN2MINaeWuoibHTCa +j5FsowGAkByzJphU8poiC2S2BxRSmwcktxbmu6o4WgYZaCMHP26qoXK0x+LaqfW86TRyP7L4td6g +5XHL3ifyoJ/XP7dW3s8Fcq/ontsRvJ11DecWhFtRCQ+sD2U1m2jVHjuq46Rx+fS4g9NVsA8mc6cf +qvVINmyES2DVs7emVc42vj4dxg2eUOUoWbKj9Ygk1okoBLOU/GauVdK7vMiLufsMUN/zmunaUri7 +HLdlEV83r97ItmJ6Pe5diHWIyi28sAIJXbQOcJxKWS1Uh61mLpyKySJwsoXrjbmhxmUO4lNdRtQ5 +LahrYb2bTQec7M1DiJU1L/LzYeBZqkJMgmgwe5g6/gyo6h0I3K8y/n6m1COH3RNY/R/pvyEb31w9 +v3gHoSjFxKSHaMPqo8Jf2Md1OaeqARpVSqSOQRLkQ6Rhx8sFauCEqQVDcJlRrsWvBgpUDw2Z1Xaw +Jsz0Bennkq0Sh6XV7z/sdf95w+lPOOrlj9kI/0k+x8bTxVfenQ7PhiX5e4bBTUNLZMrsZ8imdO2J +HinJeoApiGFgcT5sqhlDSsehGgzbBkixSU8Odpr6UEkCsjok/P16hTaHfDxI1mm6Tuna6B8HnQzL +vx+V464AzjViumXFUU9PHid0UE8o/lvSr+B4bxd6Z6q/F4m934q2rvNHebmSk4zQYA3xJiIRrI67 +qCZ1lx5RycRZgQQAoWHAiuR2s6TM3WB4kGXJkGxO6MfjwEPW2dYaeFK+o1fU99Oa/7oAa//1qlb+ +gJ/3/78v1HtY9/GkEF5Jv8rg9fxS3tFBBoYKe6imYOgQxQBF7m9DaGxOpL3nlAyyRhHSWjflhB1P +l5ZQR2Ua8NDeC2FxfpDwJaIpy+3B4ahFPGwkSCoI3dbchfXNlIvzS/fOBcK9czX6f7wmy9zm0rxB +N7yrImz0bHf5DiJO1vgd7/gHA+1DQeXpjj+/YQKf6e2apGeUXvAIKwc96a2vp23ckn4V/NuF3plq +h2xFGt36VRApRjBWd2k/ZjhkEoC4C84OOeYcmWllsRwalXXEWbmj+5aNnkzgYpIhA90bAxxuVybP +gCnqL1HluGg8Cxg8twH5wKxX7v/no3t6V1ARb2V+n/9FYV+QeH6dfUe+v0po729ynildeKHZ4vld +jnpwt5IFECTJkFvLk5oM6sGxsmiaWU2msNisGQgGbH5DiMMpLKfTkN7bgkKltXRYl3Kz8kOEU8KE +YcWSc8w9zaesro6UYW10a1/1mRl9ermL5+opl/Gdxm//IiDAhwJ/3Rb8XCzhlehF5Jf9U8dogkRQ +2y3Yr+haGJVIvBGDI+k34N5w81kmE7KwJRY1O2Z2Ewzg4LDg1rAjwOa8YFzIHG/2y9w4cirBA2ws +CTa+KfqxQHwX4fNXXflf8FP9/p7fOb2Ot0c+h2eEczo/S+b0efY5dBELGi1odUUrfYYaIhg42iPl +xAEJbWMszSZ2ZcE60DUvybOdywWoTUCuGo8iZrY8UuZa1+o5zEN9YTUAEP+03zrEQoV3W07/Nu/B +bQjoh/FLL3RfIUwvZ11RTPU9tWywJeFvDHhdmXaDcclhBwsxbYJb3p3K07nMhFLY7Bb5qNqratF3 +tno/zQrxCIR4MVnRY2e7JLkoZFBxhE7XDQH+BDjfN0ZxtPukEOopLrcUW/62n139Mmh/ucY2esDM +nGWMNdIm9Cpic8RXgqBmiItTRJ+BNyyAOMskX5uZ4UOL42RX2xOIGkpL3xUNYcGX4obMOF0zyTCO +A/UnONtGgZBvRDve8CXu2+HYE+bYheSJw5eD3pnK71kMmToBbXdeic8lf5xyzDCJZHElwZK9ijU0 +gOgSUrlpo9rMitMPx2V0wCa1yGVIuR+rQiJnMg2Lg30/mE3kZu8rzpHYftP1dZOsdKkSu8XueBmd +d+LEVyY39ufdUuoPVt8vrI+20+XL2VcXjJ8ZEN0LIJ5D9L4tgOiI4V3glbEr4oF2oI95QSx3Wj3Z +pIuiX+asY+yWllOwC2M6Bc3DAR8vWEzdHdJBSfNDqT/bKRhs5XjGVWm20/ezaTZm/YGR/TsKIG6R +S24KIPA/v5NyfE941/TvC/AZW+CN6kmIb8c9vJtNkOHBwmRG9VYLeLMJ2ZLgo3oouta6LwzrZLqL +uam5K/W8HugTUJ7z24qf6YVACRuwcIBtFjTVXFD6ytBH6JWmME490b4LvXFTfn2nsPSOpKEOkv7X +GXz3hN9A5GOo5mfyLFuCJ5G3H2erpEPUaSK46WpeyVk6o6HZBgvkYzGBRhnjKbE1FUN+W069oS5K +E8ArOAugGZUlNcafH/j1FMjkdDYcEOh0IHNhYIAKqmxRd/LZtP0Rxr2o7wdlEs9UYJ9JtrxrP3tQ +x/Jr3V4Y9TA0N2sAWOgpk0+A8UbhqoF1QKfqwYpcpiFIFiMWfJyR4Fw9uGJGDzmOHbrkcDzkpAM4 +pzwkWLg5O/PnxFLrA9+cK6/rwR1tdpOw3q6Y77ThrwS0OxPoY27TnRLuzE5LL7N71ukfs4jf9tTQ +/dtC3YvO1F4Llv6CP8zs02ON02Zzf9lL37vjt1q+cj3T7V1Gz30aL1Pxjma5DIhL5/gXd+tT7dp+ +WHXc/qq7E4F8qsPbNeW3+XA57V1IdoC3xvp+f3KyDBsQFfD51tSX4RoPGk07aRvCzCVWM4fVHo5D +bjFhK2U2V4uJcAiHGcXykENPtkqzNSWO2NcjZh1KWmllD511HW2B6wrsOxbh3anxvBfoqzK+qsr9 +uc3UK9EX6Jz2sOuWiipBbQklh2xZbBox2drEUBMOcIINZodGrY4Kg5fulI6W1ViUd4LISDgcmAQ9 +DnzdLmx7rEUQpK1ofTpV1O1G3TalxPxIr9/nujCcFJt38KxSD66F/vdWJt/ThQ8wE55YsD5QP0v5 +3bVzg7kO65gzqlmeAKp8RNXZwfLzLAinMDwXVytvLFW0mMUea4u7lNwd4+kAXCwzQsqlobyaKjvQ +2NLbggNWKr8fmziISryQlR7wE+L+Zs3Qo3XmUVbuM3PszhOuRHFzvWsz9Jkww/bisAmEMrDqzVRW +nMyIsVV5dFHXAmCWnC0WWh8Ot0UEqaXELlfxxga3VjBpgAlSDhJH90ZcH7MJhlz3Pc1YjsPPMnS/ +ytd3i/LPsfOa8ImL16ddmSd4AiOTdLQesc30GDucEx6EKrEWx9RrIHx6WDoC0hxARx0TjA8hYBUg +E1mCJkDm7CSWSolamQhoetjJZKbLc3uq2O5n0P5fZt41iuN90LQW2PHLrHsj2zLu7aR3ptYhwEZo +k7XEM7ODRM0x4OBC3BLgR3sXRIYwfVT3+RrbWcUeJkOCHDdkvueG/SSVbGEMbZI+yCiCNDIdZycc +mjnIzmfYRPsMSeiPufTHBTDt1x3vENU/XO+CjNmz9Kw6zTk9C3H0Izfv3lv//s7Ai8q6G9HLrR1o +nh5txVV+e+uzqu4xB/6OIXbzjNvxdv1N18Hny/k2YVF47jD70RTki2ayUgdKFeAxLuiIgmUm6gMK +M+SXxwFUBrIsiKy7nBZuPo84ULRoBxJLer9x95YQhqav89vbrF0zKf/juvr5Py7ceTl/VEf8pUGa +3z7gwoe3J3xfnvXfLs36gSzr7pIUhoHapMsVkURzV4GakKF2OWGJhhyroTD2ihWwh8B67+uZqZEG +ky7qdTYKBFACBtg6XO+dw7pqUoxzNMdjNgMmxxe3HZ8/SLL+nyLHWx3ytwjy6hG3krz6oqsosUpT +J5RJ7SV0MA7BSk014yQmTRmvrGSLRmtjMQ5kYGdS6ZJTxzkFCyFqLKKBoKFZYS7E42Hm5YDMH8WJ +BMkDtkpKpfr3TsozG35Oln/jlHx7wD05fmFCVkgxGJO1ADtetCad5QQMyTIVYktTtpRAl7SewQrv +HlFmzE+dhO2vRVBcjQaSoxOSvzGyjRdi03KP7MqDOB/xxIqYLP+tE/LHZHi7/v4tUrx6xK0cr77o +KskG2bF804AQYaTwklss5+spi5OrzdqUtntmqdKwNs1Wi/FsNU8wrJ54IMMw4TxE+4UqDkW/WABs +kOxxhVE0S08BFDf6y3+nJE9MQODnJXnr97vvRn+mfOOacCu1q9Me2q2YoxKapbRM/Ek/5xMcZjN5 +a41yX5yscz3BYmnmuWO3xEfERJ2DlM8zuNLYhylQaOU8zaId6YNmLazWzVqpDvIq87ztEfxug7eb +2vc2E/E9OufDwq9XnPPP4ynfQXh9Rvi/iZw9k/j+i+yL4N9iZ53S3DcIqS7ksZnuuWyQcNGSOpSy +FqZlecBibS4kI3uF66MsQ2JkZFJ0oOr4hHEUeT6IjHo02nIA2I9jnhCyRanIx0KxFOwnYme/pI79 +iwV1pynFfU0LP1Mq8p76GT/+9lLvQvr3wiNcsSnKDS+eJJXCaCOVwY6vC5elNuFut+Xn40GzWK3K +iVnirIKhxWYIoCOEMhUDJvf1APdFB6SNhbMeTZfFbrGyXKT+m9tffciab6f1ux4mH/NV/2qTbu+E +MD7Hj3/XpOOvM1+fajJ3S+kGKeoHmqq9G3/XbUseKYqvrxG/yLZD7u3krCg6rA8NvDqUtbxdDJul +vt9z0mI7FrgQEAQ15b3c2lHgYFuFlFMcBG26IGfS2kdIcD70Z0aGInIea+mspL2cdaCRNajTtWkx +j5xU93DpP+S3FPm5qUib3NIe/uf1N7mdvTSjuXz9cv5VJdL2LSCeViRXTWTu1yFf95XpnCnxQrRN +lHg57J0p/V6E88TjFZs0y5Gf+UgoMtx6A9ioKPL7NSKrK4A4sLx/GFJ72x8pTXIgR4uhQ6ITa7HO +9wJ5FCV+gteb0UnqdUZu9ouG7j/U9Yvprfw+0fdv+OStsn9Xa3BVP/8fH8K/jwsZbrtRVQ+SMK5q +qC4RNKxDXtV1b6A8M58tN/3jGwXv78LDP4cyek24HWFXp10xRj3G2mKENDxEc4miR4wrTuEDt3UI +lzyEjO/G+jadDyenwTdWC2E/DIVyrHuIWWOLnSpmGrYZzhKYoGNnY9CVWcgycHB/Mj/jdxlMxFNx +gPsZTES3CMBGHfE+vNfDqbyqK3yWb/2YqR25yqN+Y1p2HppoAixhyMSOi3ILJQEwc2rVqheFNT6E +M3W+xDV5M0JppWgKkPOIIYR/s0jov0sGE/QkavOHpgpvUvmBlgqfJEK15urXCy+vE6HOFDo0P00c +7niykofryXjC0+FqKi3gYTX2LQ7LCT+mivJYWMuadvnZwDrIABKN+Fm6sPp9OnHTiQT2py49U2Qc +BAh5YFDkZv4QZK47Ks6NxL7M10tztPsK7ZlKypbgOSkkDHpwt6pJmD64Mw0JDfJo4duG4GerQk4C +iIOw8RpfR6nfz7N1sBemZrIJwJ3IixOvKUcpLNg8vOFqZeFbAQMgUxPq57Y4LaboQzjKG75+WGpe +e8W15VrPtHb742TA/GChj223CSffEO4nSXDETdvJJ5PgzkR+L+HRtvDrEJyA6EquyynCzTb+IJzu +C2YV8RWYqaEg841gb+htEk4Y2NtRql4OBlid6yQ8mgmqMKTTZB4hgnqcFf1jmCmfdq3ooG5/JcHd +YsC3Qv4FZNe6Nd5lpj3KcrvpwNgxy+1uYtpt98LXtDPs/SM+pJ3B0Jn8l/X98yADHXLMXn7UU+Ps +QY7ZhWSHfHM1ySdrYmj5tkl7XGLwDGQjac0vcxafxQsTA+2VlRkGP0Dd/lTN124U68gOCOGxGTB8 +6Y+Peb1F1YlKAyOlNGFw+nAH9SV93YXjr31LH1lM+Jd5eqZ4rv86fZ4tJfz3TOTRRVbh3mFv4Qm5 +8DYSVGi0PKfnzJGfVGV/xRBOqmt9EyRNZEnb7mwTahjBen4zGo2YAjFBho+rUaX2EUllCu0wZtWf +QEuCvt/76dmCyqSX2Y+L804rwBNgri80z+I5H/XOdH4vIASCeQuhcNaYWAdpPguinVL3Z43lZPwS +C/JN2T9Ggqoc1QOdHVm+6JMqlLpFw8rGSLUgbqQRilCc5gdWVsLWEsmKL79pyv7j7O4AX7l0bqD+ +rrft61d/9R90KvwBd2Oi7x/C+rU6/+tqqaV4ru3bxxdckw5qCHWnDLlo0OPWtLEcbSxKO8ZJWqkH +sBnNXBViAnK2CgcpRODI2BZggK3U1QEI7JE9hZBh5MKVY6RxpS60AT/vH9FC3zxSQ/+7jbfQs+Ef +28Az/s8nW7WzLr10Lf7JCsgL0TOLLoddax9XmpM1XmaEKYI25JKpdulAnXoAGdNIvK5hm47kCIf5 +VcO67EZfS4G6hYcHUaTsrSHmoOTUixJcCKDOTJuRj/JZKo5/pELv36hnWh5eyN4fw8gTFtwr0VcZ +nQ57Z0odWqd6jT2vuRU42TYzLOwfqYWjVag8YCa43OyO0DAJ+lXqB+6QPen+BTSKckVlp/0ER9x4 +BDmmjzjjJtI8araZo9F6PgXSH0n5bXeAnfh53fD7UTj36z7Ca8IXvr6dnkO3HXyFM/8AYpQ71uO9 +AbqS4ps2MrYOEFxZeF8sRGqLzYMwAiLbtfvLIZ1LhWRMFodJf0tBqzLn+nK5lfhDJAIyGuAsvyAD ++zl053Pl8t5+tL4hTxl0r0RfK6NPhz2kmx0X+6E966cW0PT9/MgW8QYls/7CTjGrEtk9HwzmJb7E +HBQKnH1eaaVQbDJ3F6+SadTw5jiEUcVNawBbpSHMR3I1ddluzpofWYNOL1vEl/DaI3uOfAr//Zb0 +K2PfLvTIbnDwqWSWvLXAqdkiRFODHgiAPox3PDZghqIH+YLdzxosk5eTIzlRp/mA8FVSS7yJP5Km +0zhAZoCEee5oY2aL6SqK8YS2mOdxpN76jLQ7jraLtll4B/vadninaG9vPCvc09ufeNhJxe5Nu9e6 +q4KTrB+5dp9rkXtLuhXPzYWurXKrZd8A1yiX9aG0SMZBKqd5clKkrMscvDC33L4QjN0xOZa2kZiz +et/WYWelTOfa/P+392VdqmrLmu/3V+xRrww3IAj4cGtcEWlsaESkeagatNKDtOK49/z2Qs3MZWYu +c7Ncec6tXaMe1komYiARwZwRMSO+kKe2LRVIlgCMzWwj1AWCsjDUPfEtky6MXRtOD2FybHZtERz8 +S2/04nG1OvZMu/APxC98fn9mdCM8gNOiLrcLcqlPGbYwOVk7dsfqBKUmtM4FRFtoeMhTflpZ7gmv +zoqMR+vUKIWYLmp6SaJsABY+tQk15si6LWVgRKobD0ECBu24fWbc/3hy82M8SE69VV51j43C6XMo +QK9UL6J5PR5NhyEBHcK9PPEFEdgg7SaZpAkv1LbVG3e1cy6n/ZKJW+qWldS1HsXaMdNWxd7T1bE6 +BQ6xx5THSjzkwXmitt1iQQJRqXEnZBiq7BeoMD9M52fx4/87jcois/u5cZS6pyqwo9EXMcLntrR+ +doOr6D+fHrrFhWS1IuSSXx0KSzBhfIkD9UnY5dxOV01GxMGZn20RYAaAsDsto+LsxkwAOtp5oXeN +daqtBY2p6bjLS3u3ClZLmk5h87mut/1jVJlVew9RTfDebX8iNvNG9saql8HoSm1A6zqdUp1Qjidb +3sLlg3hiJHurAEzViHg59vKo0KECRcaiLXCmAYEFaZ8WRirxGB4sfbqWgn2LT9AllYlFLc55hymt +8PBkYsrPuxJ9ES24e3iz7AdJUL7WWMJ3dtGHSy2zdG9lEV9fd0lTO7jpz+O09xe6jduzNvmRvgJ/ +DNfeX+25le0PuCzOzB89qh/+yLeGFV8+Sp5l8dtV0KOr6sojHvywW1zmbh5C3sGDX+SYvRRRXxID +fr2GGX4Pjvble3TJIXCch4HjntATntgb2dt79DK4TjQDvLA4lsrNWlYoRdyhaOgUCigg+DFOAy+o +KBEw2iJJDDuTV9161VTGKe/2UDoGLQrk0YqczQzwsFw4hoKvNoWZrWBA02e/uVHhZUVrFs7t0aGP +GRlBfnm+l2yOS5Lwr4fS/riUUA4Q2fHRlIf92duCv24YHC9z3bEc3b7+18LxMc/vp69twVHjubXQ +x96xBPAKUDQjAzbrWapMDlvuSExqunICRZw75Szf9Maxlh1W+w3KbsbU3uJCht/tdHYs2IkINw9h +m39xEnPLkeN6PZsv2TG5W9x++WfIoTJwrk5Amrrx3Uv6qzKDvnObcTAu77HuV+5+VWrNh8kcyJ+T +Z1ThjvBFKe6GoyvFAZiR6HpVYmP3eDxKXQHV+8VBbkhEcoWYyzeQaqOaeMgSwavtfV1QalmyY5f3 +KBnSUT6UMu6cUUS4F/Cj2mwnThEd0u2XGxWP2VSYF//ua+iFp0zpe8KXCuK74TWGN+QlcqNxQku5 +WHPoAibJVSFXGUAqiIuc0FPd07KCtkCA2MPzfgasG3qzhzRalWYiclK6ozZDt4W25jJTVhhLrqAJ +Zmy+I876x3CV/teGCAqz7A2CS9X/w5gh8kT05gfZqyRfB6Mrtb+Wo1SgEiCuylk3E1O0ZFsd8Jdj +ES8aQF2irEFowCps90kCVUIeWTBXVHMLL63eMSWC5Vo5BLrp+QmD7tk2w8XQDaH8dx2j/yiDuAnM +Uea0Xa+gud+bJOnoVcSXB/v1RtODIPALsx1ZmfM4Ygk9JaAb0at4bofXFjMDhLOanKWQiuOTGnm4 +MTktnT0EkpC6448nrDkxOHReLlAeisgSXWdNstDV5VliTvOpJU+3s1WNWIcNCsWFMzln6yU83kiT +YSG1x8KxuuqWWPYP5KOJeWHCyC2Kfi24XvAJsye4tD0fXSqTrp9DH43GOs2D2yv5D/gpf3ioCXIB +KTGt2B31snLN5KHpiDyREfaB9gskyt2ZK3rxgDwxIodmSoRqAnXg3FYOoJhY5GEJLPapGqxwPqO4 +BaNArL/AAaPTCQrmNjreP+Ek3ha0xhxweA1PVgwhFWJSJ+hku6uc34V8ugTC6iqIR0F5J6d7Gae+ +2z/IDw14l4YSlGZRmN3Pv/ogpHAj8z5B0fTcUe+leDcP6x+TnyfE/G/HvXhtxcvtPlxzfYz+UQv3 +ta3JP+B3JSuD9edDwdC7H/fzQDD8xERyR/dSMvRjNLrSG5A+5YwVg1xSkRbrOGMtT165IMC0WUXK +QoEZhLDhMuAxScTMqbibbhKWJJg0L2052SzljCbWQj/9E7UDtmKVhV2JMhjwpGnzktfk9V766Cas +L/y3Jybdz/TvoFLuzl49ugG80zwoVV1sW7rngN7UwCyfWkGgWEkeHzF5CuYA3uK6JoJLkvULhaIU +vzWBZsZ3tVUfPUPdNa4CgpS+Z0qKwberNdgsvsPeGYxb81WuyUvyxK9zuXpBA7okmtyIDGClREoI +R6jw/OBCsusD2CEMIWRtJVtarbPyfFhNs2yetzpX+H4mEFDuHVFbiZQJFUVp6wkeXbnbNjYmmKgL +jN7RqvMdqUB/oEPYmNXV4yy1p0A0byQvfLweDIXUTte7QlklY6UL1ngR+2Zeg0aMTuiWP0QGY85z +w+JYM6T0Qxsv58J5LUeAzYmztFwc99PJhAm59TJdWY40h9O9eAYOM/03TTfHterDS0Ab/Yh7ljtv +wbOP1aD30bpPCet3+QsXPxd5v6R82hl9rTf9ZeMBHrIRO2R2f2b/6avZfdC2U5EjcgbhK9tJkpXF +NAeTP0nyssAtZi/vo4k8XRxhGshza5vhEKC7JnWK2gnlELzIAwyFWWGqJ+N9LdZzLclrvUnm2jt1 ++OFE/aisfldS9+pQ3YIDd0IaFj/oHzb74UrdSe7BbXrJF27P86/u07btny/X3bDWfvEevcVa1nF1 +eeyvbnMjexNknedZUd3d4uXoUV37F8vkRQ2Kr7Vt/LQtUbxXt9fhFcltwIqoGxmyIsYyhW+DLoAW +8EISs3B9xqPczVNZ4qZcJ1ose4A1TXMba+IsObzKO348o06MLVksgzd2t2UjyLbaoy0VgVI9Z02U +btI8ZBDe29q/3gP5RvIKDHY5GF2pDGAKDq6o0iLWYZYZeWsema6OBYyS4qg8zFPb9lkmAkqD01GZ +bJTM3pALmp0oBexxqLMHlk0MtZgdNrVtcgEK5fU2yJ6rQXhjyrWU8jZ6Zst3kENV9uvBwxDVU9Nh +T/DK/dS5tWwagBx/SA0Pp2g742wz3IW7NmxrKjzXZ1QUbX0sVysxLpmZBAM6O4a47b4gTU1WEyfM +2t0Sq4mtDcFi1psUrOaJcKLbBv+t6+G7desSSnLelrVPi+KleCB3R36VvK57H1wptzIPL58Q7x0b +r+ex/3OqH1z0z7C6SZC4o+v2zvVz5ONmU/L6Pfj9r8ku2INpUPru6yKPvif8IZh5K9v84LOZVV26 +P37Yr28b/TF4Q/xfG/u7ljGPLg8YPILiGz/5mvwgfH1dfgyvZuSA1+a01cgUysWjtNtLwZxoO6lY +leONEGtj9CxBosCYIRT1i2CTCfOyIqXNpGsEf7aXlVbYhFK1a0pRzfg564lMa5rS0t/9ZpOk3303 +vrYYXyarZ7F3/+9VsipIEtcJHndjgt/tW/8CVOYb4RtU5tvwmr0+YF3czHZLx8iJcn2kYhAj1p6U +WCJxXolrid9jJGdk3KEobZqSgG3ZrEDy5FKScOhOq1XmQx1I+Ah53NPp/CiBBwco3ID7Eur/SzZd +N7kvwsm8LxatpzBF70jfWHV3Ymir98VkTWm4WuTEZBXEE8s3GhQLiVBwrWx1nCw3ib5BDnvGYVji +ROeiqimbki9igZoXUXbaLFw+ADWDa+tto6Ma3+qbZf4crmg/n1v9xD3qNTExHy7xTyKwvqd9Ydf7 +M0NxWCP2VIzPRq5XTlLw8JEKi0IDDbjYwhFDUCfgEOUrmEFdLWm0sk3sBezvVFLVlXNcmHoLg52R +Y3pN6TiuV43FQ05C/Wag9PVRfsDhIP+0PhAf7/Vo7+J5EV0p3wnoOr7uYgwQDw4ADu1X9glBJkhN +mkeCorYoX59ItyLPc9yQBD/ZSVzKLhzMkgvNCRbded4wEG6gqKI7a9lXlU6rJhuw88+EG9kWPEg8 +38Hb9/vsP58rnklkvyd84ezdcDSwMBE7Yc4KOy+dfHem0VJyef3UVg159rDFAWWq/vfLU5QVml3t +KG63GqvazOS8hDqUXRnrxZZ0aS4ugwk600uaUWo/aR42whm6cpf35iX8ERUks8J+bRsFaZn3f1+u +gZG79lJ/vM9tGMU/YD6+SIF4KXL8q6ta14zur3zCwoR+tvn4T8+Y+BlLHtaj/ZYuXql/VMj41k96 +UJJlEqYgZAVgpijb0J5oMc6ZagAKy+WyTupsSUtLj6I6AcUAn1RLz9xvsMmOZI9jNzNI/xxPF7Z/ +EoIwj6ztnJD3pKRAv2tPPquVf0f1eFzv+w3acSv9/XhqqG7s5+Gc9w6b0uqQaudk0Di1wmoDum1h +YqHIJvnOd9Nop/tEzkxr2wBhkZAztEZphnQjkAxzYV9S8022noFBTa44Wtv+7pamGccjK6vffIIP +Hu9f6M6ljL9/1KJXnqtv94pHNEC9kL+lev2YQx+p2BPhyJ/c4KOavZy+qtqA8KQqyiDbsNJOT9mg +XGfTjX0kWWEZjemIFcAqzpvY6YrUTVDTlXLUNwPk0FV+2R6wHIIzOdvFE6Kw84CehfTYKsazaPw3 +VrVhC+ffRiEPqRlf2qI+Wgif6zt8R/eqfm+jod2HrXNnwC5BtFMBDviltUqFuNF3hSpSMYoJsMVA +FKJxaQNMq0gsTgVPhIqyC+iYiqJkpR5SeIPNPW4GI3LNHAVzusqKb8GK+EYxBaVp2oMiEsElHe0L +yK4n4xFvZK9Ceh0MjUVYa4aJt7B0Iu0uTcfORE8oDd0wYWw03XizJaktz66XxJ7DYgyY0krQ7Wh+ +CXGNK8giZNnaYU+JW9tjjjMoD82jkntPZniWWV3Y7hcr9gVb44kV+43shUFvg9GV2l8zSAkPZl4n +amxt/Ig8nHe4HtkTXVN2KEZDwaomZEY79oxoxYlzBn1IjEPMTZfH8Awb1nEcT1TzqKfF3mpVQd10 +NEKj+CMG/TxB+ruSHu4e/nVf7hGjJ3+Of4fTr/Tfc/zl5OhG/q9ZX5OsgqwR+1xyna6tNILwnILJ +mpMjz7MdQ20NTNa1St6e1oZyZg8TEcQwtsLqTInZerowMgcIUs1fZchROrS9yMAO/k3j+WVb8JI0 +87ZSvM/GutfiCxIHNkw2lZk6ZuG0ruVnWfQQYeo59/oD8SvI8vtTQ91sa25pU2PR0ZEqltszTsYI +X0vKMvOTlpHdBuz8Am98kxFjG515XFHm3NbEbHFH1hzMVUmxo5aoA8pjf156Lgo0EpP+dopsdck/ +iwPrff3SB8l4Zu+39Y8xnmB3JsUg0bxuxXxfTtYr0ZsorodDs6+oZtFNJnuEIvE6SrcZgAYCs5t4 +IlzGW6KVMn/vRGlwMMRNvumJr5aS6reBTs7mywWixON8l852ge+Terr1DYllyGD7Tdnmg6JIH9MR +v1PR70m/gci/nhiq5Cko+2lDBRjNWtbea4IiA9QsDOhzA5TERtywpH3eu6Kn5NRy3WbrHeRXcIzq +LTm3AiJfzhp3sXDSiO3EbieCyXnrtb9ZsfSzLM9h2vuOJf8/OfOnAviaf/llO7c3flO3jfsX4KGV +/VRU+TP9Nwz8d2eHgv6YdUwvbQrTV8QeZvBgS06q4DAT0V3JkoZRCHsiD/cAcHaUNnH3RH22dLxL +MX+6KVseG5uOXPEGXc+5U+8Hkum23lDm3xz0p2dnlUXIo7nmUkXxhOV9I3qT1uVodCM0YI8mQPt5 +1/MnhQZJ1HodCfMQ8IH5no+OSQ7ONx7REJGRR/x+hYWMlGWbrjqe14au7HXOsGkD6/rZH1p4FCEK +Nq0F9ORhYsxgeLEsctPg3L+y16MX6wV5Ypvml7eEP6XIDVEBMivcNqgGSL8yH6dDPWXo9gQv8PPm +JRNqmCmrOX41b+JN17anfK4S+uKIxIJGLnNF3G3HAsva7VoUELYtl0eBNcdCBGZLvKiZcw4si1W2 +Fffz87KdOYvwuFbBht+K7MMyy7h2BTMavbeAvpL9zYkFvXJ0ARPPzfIBWrLtZ216y1j51Jnk3Tfx +j+Uwl0/PvYX28t0PldadGb9tbUx+F/zhC0XIgv75q8ALvrA7nokK3xO+aMbdcGg0OJuUsrhaRAeQ +4iQ+YVFkD4G1W6yLvDc1nEjxiYrhG9PVci+v23DlprGcncCxAJK72FCqhQssGbyc6P7ijEGEGM/Y +YdHgX6iK/Yq1/Zzxliv1oKD5CVPiju6VsW+jETbMlHC2mu13wBziDitCFefYqZmz9JZTdcU6Hp0F +txLNVQbO7J3Cn9v1boXNWHwbOmu1XBj2jAd3pFN5SouI+uIgFpO9WGDtbzqR/2Hd5i6wck/VteWP +/TLdjj9iCzyclO+uClzXxSevXs/4Gbha9E/4VwtF/9mTdoFiD8MTT7UO6Qle+9Sg2Aga1i6ER9RN +WR/3GBbvEGheaLy1CE8os2jjrEUarCjQZG43WF6kXuvLEFxEh452QpEndWdqFfg61/YwsEh8CPbY +9DhmnMPDAObXZmhVjsz44FqF+YApz6Wd/CB7Yc3bYGiyCS3OfF6kN0XUnnFMxG0ndJJA9ttNlxo6 +j8kHoQ4puC50NOMTAhLqabZxEmuLTtZZZa8ELevwVk7YaEsvsM3JKnzXe5ZBt9Xl57whnpnULxSv +bOn/jq40BkzjS7qeoqxkAau9U8uKtMbbnuQx9ZJ1KczAdOZjFrZgoXa+yFYQmIiupmA20q6oPYFs +IqFmxS1bydpqpUynHGmeZXD8iCMQKVNfsyR7VEmGXmBWn9GXnuSNJ9lhdCMyAHCKdCF6t4q2udAg +lJsyQR5KquRCOBLyDmwL6xBJdW+/gUBeHE9L6TzjTljkdd5uV0pCoG7mAAlUcjEmpjGvVTXOzpPv +gVv7bZfk0rqtrEw7uvV5unHml5ozXCbUWwXpo5KGJ+R0o/nSJKk/uhYyDBCVZ+psC5kpadlgpNLI +md4t0pNMCzNG0aYMbQlk5TeUsy65eJGpAi1UMnQ+zANJb7kyWk8DRjPWSDTTKELIDJRJNrPdb9fZ +9j80rUavK8/nHNhrAub18x8gQx+M00+Z3P/v5Lq+CvvdyQ9M+z7Vuifc69f9cKiSJSGuiNoCCs2j +KZR1xBtbZeEtgvHMXuNzsGmT1mb3kDDFXQFewPmJNOoujI3iNCndncmTB1jBgAyZtLmJTCTPtgH8 +S+ixf5rn+q8TsJU9yma8xLHhX0d1eiH6MkX0R6MboQG9RSCxlE1jD+c8nnPeBtQXCmvwu4bQxjAA +B7GYgSwPYExFW/7clPx1wWWreTSLbLLlGrOf6zlglkGb0wYOqHDCIrLgP7fq136X++5j4OFnEpdf +aPaMeTkaQcNSlY9nJJvOWS1ZLkWGdI5n08KPM71WiUhiVvyizlhaL8h2j/kqt7HzWXKi1loW2qxH +F1NFhkUXOytlu+CWnLXmMBjy6uNX9U5f8KX/fcQVXWDUuxiF+Xg/6RlkoU/UL7z6eG4ED8MYKpqV +TAbzyfk4nweUMY1mQnk2bKpxZmzbcqslgyB6FKKIsLLVMk1scruGpvpOQVPBZQ1CH5t4DG8OOwci +ZNKdzggpxL7D8f1vjFde7mI/yhMgLvu9v+5J32heJHU9GN3IDMCA6lDQYqc6r0z8YMpzRS7UDaPR +9qkIkfmm2APgTM+zdqbvcjYlDhqoiXTIdziG0WKm61ASSL6jTnF8SasrhvdJp+2+w3gb96vNdNAe +yMsTfxWdIJ7Cjron/IOzt/gEMQw7KkTwiWzvMcjJEkCPRJrzdmtbCMRTxINWzZ4nTGaFaz840fWM +N/kSmU/j3qwq1KMbHjR1iZPW0qb1fLdQIhlmXMLKja/Y+xWbAjsr0lFiHh5WZkFP8umO8pVRd+Mr +OtMATgESSWrkvAk8e4J5pVWfDAmTg953Oh5tRFXN46mcEIdmWdhCzRMIy+zmbT8ly5PcPyvTdeVv ++cV0Xyzn9HytHFjXpdOHrcL+NhPFC0jQo1jmM7K6kLwK6XJwiyL/tXTysBtbui+Xtdeq8aoVbSBG +bB4H2noZr7D6DOnOciHEEmXFWJiBeiwGaGIR5kGJ9nOCpPE9wddntxP54zYqZ4h/rlb/wj4GnwBw +vi+h8z3pC2ffnRiaxLkQqckRrrWOPi3zebFO5zacsukROQgmRhlkZs+4gBvvTHk+w/fzJawsqY15 +mJ+5SONLRfco2DFXILjeLSTiFHBWwVb2c2ZXYz5ET4GfCvNeCPaMufy5btIPYAfJM5a69hzIVUTT +8iNN2SdQSNR1s110O3+SNVsTdLqsBcnjzDKW3RyYeArAnSXhnMxWZ/2ob2ecnG19RyoQlzNAUTt+ +C3LKMIW7dGC9ISaVozyLO+8xGB7yVFOSn93gpeHux9MjZFizEme8VNfzoEkMfSdz2cGdbsoDPTeK +aoLDZBDZKtObanM48uPY2rlUzByNMUU0FLEA46VJqIxqWbgYJwSoLfU9zi1Zw/iW1JOhHP95D+wP +TgP2J/wcu++ov3D6vi36C+W/ZvPEUgy8sSQ46r1rx62mWHsWpzgKLL25QbkSbu1y0+bmyThNGzY3 +J7YAkd22zDb2zFdEAEeRJo8sNIFIOt7LvV3hTvfPFYj2zxA48eiCVXdj0SMDCnmuVe8n8je+fTh5 +ra4bEH0dL2cpciZmW6wIV4ScEFmxnUM+aNkxSB3XeLUVHcZAOXgeOjSwMDfrRD+RbKfVqzWBTt3a +Fmm/IbPTpvRiT7CI6GS6jxahS7Lm+DVZ8wsO+mbVHkaPWw5NnmvV+0b22uL4dXDtgDFguS7NxQRP +6/wUYQ3C6sgECM9kq5tQsZI7SNsSS/lkiO1hXeBdCXHk2WeaYAaDO4VZrhN5fyyJ3JrO0oaba4ta +YNd5of9uofvLls8FC/FDCftPtfBjGO8rEQT2owbmz6XvXSm+9ZYemLhHrjlkF8M7FRGbGIdipDsi +OoYGgNnmrXYsGVJXo+i4qVJLOxQbCuhCvPBVKKoX1Om8NHWNCRfqJDuY+YrfLPp/YWANwkN5zPOg +dE/3QdVPhuwnKJULZ0evHL3Cqdyd+fT1b5m3r0z+uuoaeiqW+Y7ymzhfK66hYdFMzegyegJOfKPS +goprz4WC8qsVoFaWNTXJ6dw9K4t2LEFtrK8IXtGl0xwuttqBr119XZGzZatxFgBW9D5CnexsB/xy +M8gv+dzV/QOnnu5s8pNa0F/1aO4cmfd8/aXNkUu/6/yxrfnUu3sl+dLhPO+Gmt8xKucgtS3drJi2 +a2zR7MfArpZSDHE2kRgavQ831aKDv1tY++kqFmX4pJQGUuMgJwloe6psmkStQy6JW3uLSPPGPYv2 +cy3h28dRjDH8jKV4XXUvIYvL14cEgOGdAUaiesrEAhRWanisjS0sqyvNbk4OC7jwqTgRUwvRreS8 +3vT+tpeaDMzS3EE9L4WFauCbJl8BQOYYtXfQtxPoWzKQL4UQP5vEctctqL/I6b84ZdeJEP1YNV1X +3ogYNWYcOC/YqP/z3yc/L5j+eKONW5lf3OwdylqWV70Yzcv5SxeQt4/+66ufMozCX79nPzKwvs9E +eaF5bTV8PRpqnOiHRtl57bGzcUXbbwoSkLmk3OtyspMJDazkonJ4Y8MlGyDFAWlXBFut04IESshi +p/Hu8bynoZXKHFjRDbp9QNMFTz3SrwfZct+Rb9ZldpXZWXwrYvw+jMw7uhfm/hgNRcs86UfHoJUV +uNfNMx+D2ZzSeQBR40yV2o1nnMgs4CvsyHcRcPIEJ5hMiaRWF+i44A06hyNeCI7qFMGOk62vOGl+ +XMTy37wB8Tl7ZFu8RysbKqSeXi+c/v/R9ft/LZSuWvB0yC3peKy0+iF23HFo++qYbROUWdJrKpA1 +1dkVS4nk+CltdzmeopR/Wi4ClZ8tN3sYJI+qp4JRdMBhhbLZZbcbFEF7lsO90gWpb9rRQP5ekEmv +/TtL23eTR5lMyJ/jyRPL+mf6L+x/f3J0I//X4hBA8eCl+Q4+reTe59blubflJkyH+KI3hZPVnqr1 +tcIay01A0XnViCi8kVM18xLCSecJNJ5gBu8Z3Aan5HMtb2Z0Gj5M2X1nrX+9Wt309OL8XJ6D+OM/ +//OP//URq/ffLv/+69/+D8+CRm/4jgIA diff --git a/test/package-contract/managed-image-registry-transport.test.ts b/test/package-contract/managed-image-registry-transport.test.ts index 340f2f127a1..7e2669fc477 100644 --- a/test/package-contract/managed-image-registry-transport.test.ts +++ b/test/package-contract/managed-image-registry-transport.test.ts @@ -35,7 +35,7 @@ describe("managed image registry transport package contract", () => { const productionDependencies = JSON.parse(productionTree.stdout) as { dependencies?: { undici?: { version?: string } }; }; - expect(productionDependencies.dependencies?.undici?.version).toBe("8.10.0"); + expect(productionDependencies.dependencies?.undici?.version).toBe("8.10.2"); const fixtureRoot = createPackageFixture({ prefix: "nemoclaw-managed-registry-pack-", @@ -101,7 +101,7 @@ describe("managed image registry transport package contract", () => { const installedProductionDependencies = JSON.parse(installedProductionTree.stdout) as { dependencies?: { undici?: { version?: string } }; }; - expect(installedProductionDependencies.dependencies?.undici?.version).toBe("8.10.0"); + expect(installedProductionDependencies.dependencies?.undici?.version).toBe("8.10.2"); const probe = spawnSync( process.execPath, diff --git a/test/runtime/messaging/messaging-build-applier-googlechat.test.ts b/test/runtime/messaging/messaging-build-applier-googlechat.test.ts index 164c10701e2..bc0de179aab 100644 --- a/test/runtime/messaging/messaging-build-applier-googlechat.test.ts +++ b/test/runtime/messaging/messaging-build-applier-googlechat.test.ts @@ -9,6 +9,7 @@ import path from "node:path"; import { expect, it, vi } from "vitest"; vi.mock("../../../scripts/lib/openclaw-npm-remediation.mts", () => ({ + remediateInstalledOpenClawPluginPackage: vi.fn(() => false), remediateReviewedOpenClawPluginArchive: vi.fn(() => { throw new Error("Official npm installs must not remediate a discarded archive."); }), diff --git a/test/runtime/messaging/messaging-build-applier-integrity.test.ts b/test/runtime/messaging/messaging-build-applier-integrity.test.ts index 638b24ccca1..5a1727a0e5e 100644 --- a/test/runtime/messaging/messaging-build-applier-integrity.test.ts +++ b/test/runtime/messaging/messaging-build-applier-integrity.test.ts @@ -23,6 +23,7 @@ vi.mock("../../../scripts/lib/openclaw-npm-remediation.mts", async (importOrigin await importOriginal(); return { ...original, + remediateInstalledOpenClawPluginPackage: vi.fn(() => true), remediateReviewedOpenClawPluginArchive: ({ archivePath }: { archivePath: string }) => ({ archivePath, integrity: "sha512-messaging-integrity-test-remediation", diff --git a/test/runtime/messaging/messaging-build-applier.test.ts b/test/runtime/messaging/messaging-build-applier.test.ts index 7eb022b4c53..6eb84437795 100644 --- a/test/runtime/messaging/messaging-build-applier.test.ts +++ b/test/runtime/messaging/messaging-build-applier.test.ts @@ -22,7 +22,8 @@ import { officialPluginInspections, } from "./official-plugin-inspection-fixture"; -const { remediateReviewedArchive } = vi.hoisted(() => ({ +const { remediateInstalledPackage, remediateReviewedArchive } = vi.hoisted(() => ({ + remediateInstalledPackage: vi.fn(() => true), remediateReviewedArchive: vi.fn(({ archivePath }: { archivePath: string }) => ({ archivePath, integrity: "sha512-messaging-test-remediation", @@ -35,6 +36,7 @@ vi.mock("../../../scripts/lib/openclaw-npm-remediation.mts", async (importOrigin await importOriginal(); return { ...original, + remediateInstalledOpenClawPluginPackage: remediateInstalledPackage, remediateReviewedOpenClawPluginArchive: remediateReviewedArchive, }; }); @@ -687,6 +689,12 @@ describe("messaging-build-applier.mts: agent-install", () => { expect(trace).toContain("npm|pack|@openclaw/discord@2026.9.1|--pack-destination"); expect(trace).toContain("plugins|install|--force|--accept-capabilities|npm:@openclaw/"); expect(trace).toContain("discord@2026.9.1|ignore-scripts=true/true"); + expect(remediateInstalledPackage).toHaveBeenCalledWith( + expect.objectContaining({ + packageSpec: "@openclaw/discord@2026.9.1", + packageDirectory: expect.stringMatching(/\/extensions\/discord$/), + }), + ); } finally { fs.rmSync(tmp, { recursive: true, force: true }); } @@ -1048,6 +1056,12 @@ describe("messaging-build-applier.mts: agent-install", () => { ); expect(trace).toContain("slack@2026.9.1"); expect(remediateReviewedArchive).not.toHaveBeenCalled(); + expect(remediateInstalledPackage).toHaveBeenCalledWith( + expect.objectContaining({ + packageSpec: "@openclaw/slack@2026.9.1", + packageDirectory: expect.stringMatching(/\/extensions\/slack$/), + }), + ); } finally { fs.rmSync(tmp, { recursive: true, force: true }); } From 8d78201936b31c5b1b7b902bebcc16bdd26a2183 Mon Sep 17 00:00:00 2001 From: Rebecca Sliter <571084+rsliter@users.noreply.github.com> Date: Wed, 30 Sep 2026 07:17:45 -0700 Subject: [PATCH 2/3] fix(deps): record qualification and harden diagnostics Signed-off-by: Rebecca Sliter <571084+rsliter@users.noreply.github.com> --- Dockerfile | 2 +- ci/pi-agent-qualification-v1-linux-amd64.json | 8 ++++---- ci/pi-agent-qualification-v1-linux-arm64.json | 8 ++++---- src/lib/agent/candidate-authority.ts | 4 ++-- .../applier/build/messaging-build-applier.mts | 17 ++--------------- .../messaging-build-applier-googlechat.test.ts | 9 ++------- 6 files changed, 15 insertions(+), 33 deletions(-) diff --git a/Dockerfile b/Dockerfile index c5c51f032d6..7a3a2971b95 100644 --- a/Dockerfile +++ b/Dockerfile @@ -881,7 +881,7 @@ RUN test -f /usr/local/bin/node \ && test -z "$node_unsafe" \ && json5_unsafe="$(find -L /opt/nemoclaw/node_modules/json5 \( ! -user root -o -perm /022 \) -print -quit)" \ && test -z "$json5_unsafe" -# Build the immutable archive cache offline (#5896). +# Reviewed-archive invariants (#5896): immutable offline cache. COPY --from=wechat-npm-cache /out/wechat-npm-cache/ /usr/local/share/nemoclaw/wechat-npm-cache/ COPY --from=openclaw-patch-payload / / diff --git a/ci/pi-agent-qualification-v1-linux-amd64.json b/ci/pi-agent-qualification-v1-linux-amd64.json index 8641a360d9f..34bbb6e772e 100644 --- a/ci/pi-agent-qualification-v1-linux-amd64.json +++ b/ci/pi-agent-qualification-v1-linux-amd64.json @@ -3,13 +3,13 @@ "agent": "pi", "platform": "linux/amd64", "image": "ghcr.io/nvidia/nemoclaw/pi-sandbox", - "digest": "sha256:2585d6f48d1a6d6c059b59e8c273fb08274b4e8af8ba9d0db59f0df45fc4f479", - "reference": "ghcr.io/nvidia/nemoclaw/pi-sandbox@sha256:2585d6f48d1a6d6c059b59e8c273fb08274b4e8af8ba9d0db59f0df45fc4f479", + "digest": "sha256:ec5befc280f4869782952a4fb147e7f8321780db1887a3248accfe38e7e8b980", + "reference": "ghcr.io/nvidia/nemoclaw/pi-sandbox@sha256:ec5befc280f4869782952a4fb147e7f8321780db1887a3248accfe38e7e8b980", "source": { "repository": "NVIDIA/NemoClaw", - "revision": "d60ee0bb36e582f83846f41a1b7e94719fcd89f6", + "revision": "b0e98ce714029f43ec8573c735cfbeed453ff219", "release": "v0.1.0", - "cohort": "ghrun-36504446248-1" + "cohort": "ghrun-36661723135-1" }, "startupProfileContractVersion": 1, "capabilityContractVersion": 1 diff --git a/ci/pi-agent-qualification-v1-linux-arm64.json b/ci/pi-agent-qualification-v1-linux-arm64.json index 596cda3930c..c1cc39b7b5a 100644 --- a/ci/pi-agent-qualification-v1-linux-arm64.json +++ b/ci/pi-agent-qualification-v1-linux-arm64.json @@ -3,13 +3,13 @@ "agent": "pi", "platform": "linux/arm64", "image": "ghcr.io/nvidia/nemoclaw/pi-sandbox", - "digest": "sha256:de600347e74f8bd4be17b572b079159f98037200477505c718b5b0f3f47b66fb", - "reference": "ghcr.io/nvidia/nemoclaw/pi-sandbox@sha256:de600347e74f8bd4be17b572b079159f98037200477505c718b5b0f3f47b66fb", + "digest": "sha256:455a795a5c78abbc4ed3087f075ea545b394d58b7dbcd1768ac7c2713aa9d158", + "reference": "ghcr.io/nvidia/nemoclaw/pi-sandbox@sha256:455a795a5c78abbc4ed3087f075ea545b394d58b7dbcd1768ac7c2713aa9d158", "source": { "repository": "NVIDIA/NemoClaw", - "revision": "d60ee0bb36e582f83846f41a1b7e94719fcd89f6", + "revision": "b0e98ce714029f43ec8573c735cfbeed453ff219", "release": "v0.1.0", - "cohort": "ghrun-36504446248-1" + "cohort": "ghrun-36661723135-1" }, "startupProfileContractVersion": 1, "capabilityContractVersion": 1 diff --git a/src/lib/agent/candidate-authority.ts b/src/lib/agent/candidate-authority.ts index ab1d87be2c0..2c60267ca61 100644 --- a/src/lib/agent/candidate-authority.ts +++ b/src/lib/agent/candidate-authority.ts @@ -13,8 +13,8 @@ export const CANDIDATE_QUALIFICATION_RECEIPT_DIGESTS: Readonly< Record > = Object.freeze({ pi: Object.freeze([ - "d15d60a0dc53885c825acde83ad426b87b61dc942036446438846f471d90fb57", - "20d963079d246a59f5015d1c9324b5531301336f2d366a7f7b3da54f1fa12075", + "e4d558c94b576a014f04979b50baf1f72cb2ef8f99097f15e994fb7148ff03d7", + "99caba01565ccdb579c1b76413dab922142b05e6cdafbe13ad0db6447f64f669", ]), }); diff --git a/src/lib/messaging/applier/build/messaging-build-applier.mts b/src/lib/messaging/applier/build/messaging-build-applier.mts index 53bbb673e70..61b66c05c40 100755 --- a/src/lib/messaging/applier/build/messaging-build-applier.mts +++ b/src/lib/messaging/applier/build/messaging-build-applier.mts @@ -2211,24 +2211,11 @@ function isMainModule(): boolean { return process.argv[1] ? import.meta.url === pathToFileURL(resolve(process.argv[1])).href : false; } -function fatalMessagingBuildDiagnostic(error: unknown): string { - if (error instanceof OfficialPluginProvenanceError) { - return `Official OpenClaw plugin '${error.pluginId}' ${error.condition}. NemoClaw manages the package pins and build cache. Report this failure, the plugin name and your NemoClaw version to a maintainer.`; - } - if (error instanceof MessagingBuildCommandError) { - return "Messaging build applier command failed."; - } - if (error instanceof MessagingBuildApplierError) { - return "Messaging build applier rejected invalid or unsafe input."; - } - return "Messaging build applier failed."; -} - if (isMainModule()) { try { main(); - } catch (error) { - console.error(fatalMessagingBuildDiagnostic(error)); + } catch { + console.error("Messaging build applier failed."); process.exit(2); } } diff --git a/test/runtime/messaging/messaging-build-applier-googlechat.test.ts b/test/runtime/messaging/messaging-build-applier-googlechat.test.ts index bc0de179aab..2031fb180cf 100644 --- a/test/runtime/messaging/messaging-build-applier-googlechat.test.ts +++ b/test/runtime/messaging/messaging-build-applier-googlechat.test.ts @@ -159,12 +159,7 @@ it.each(["slack", "discord", "teams", "whatsapp", "googlechat"])( env: { ...env, OPENCLAW_TRUSTED: "false", OPENCLAW_INSPECTION_CANARY: canary }, }); expect(failedInspection.status).toBe(2); - expect(failedInspection.stderr).toContain( - `Official OpenClaw plugin '${pluginId}' did not retain trusted exact registry provenance`, - ); - expect(failedInspection.stderr).toContain( - "Report this failure, the plugin name and your NemoClaw version", - ); + expect(failedInspection.stderr).toContain("Messaging build applier failed."); expect(failedInspection.stdout + failedInspection.stderr).not.toContain(canary); expect(() => applyMessagingBuildPhase(serializedPlan, "agent-install", { @@ -190,7 +185,7 @@ it("bounds a hung official-plugin inspection and removes its packed archive", () env: { ...env, OPENCLAW_INSPECTION_HANG: "1" }, }); expect(timedOut.status).toBe(2); - expect(timedOut.stderr).toContain("Official OpenClaw plugin 'slack' inspection timed out"); + expect(timedOut.stderr).toContain("Messaging build applier failed."); expect(remainingPackedDirectories(packedDirectories)).toEqual([]); } finally { fs.rmSync(tmp, { recursive: true, force: true }); From 1dc162e5a84d8e6e18af3bad7eaa0837bbfb2a38 Mon Sep 17 00:00:00 2001 From: Rebecca Sliter <571084+rsliter@users.noreply.github.com> Date: Wed, 30 Sep 2026 09:07:50 -0700 Subject: [PATCH 3/3] test(security): align redacted messaging diagnostics Signed-off-by: Rebecca Sliter <571084+rsliter@users.noreply.github.com> --- test/security/fatal-process-diagnostics.test.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/test/security/fatal-process-diagnostics.test.ts b/test/security/fatal-process-diagnostics.test.ts index 407c9c93dca..e89bebb95e4 100644 --- a/test/security/fatal-process-diagnostics.test.ts +++ b/test/security/fatal-process-diagnostics.test.ts @@ -61,7 +61,7 @@ describe("fatal process diagnostics", () => { expect(result.status).toBe(2); expect(result.stdout).toBe(""); - expect(result.stderr).toContain("Messaging build applier rejected invalid or unsafe input."); + expect(result.stderr).toContain("Messaging build applier failed."); expect(result.stderr).not.toContain(CREDENTIAL_CANARY); }); @@ -99,7 +99,7 @@ describe("fatal process diagnostics", () => { expect(result.status).toBe(2); expect(result.stdout).toContain("+ openclaw doctor --fix --non-interactive"); expect(result.stdout).not.toContain(CREDENTIAL_CANARY); - expect(result.stderr).toContain("Messaging build applier command failed."); + expect(result.stderr).toContain("Messaging build applier failed."); expect(result.stderr).not.toContain(CREDENTIAL_CANARY); } finally { fs.rmSync(root, { force: true, recursive: true });