diff --git a/.eslintignore b/.eslintignore index 5b2c3874d788..cd1f22758713 100644 --- a/.eslintignore +++ b/.eslintignore @@ -21,3 +21,6 @@ /packages/gatsby/public/** # Files generated by TypeDoc /packages/gatsby/static/api/** + +# Minimize the diff with upstream +packages/yarnpkg-pnp/sources/node/** diff --git a/.pnp.cjs b/.pnp.cjs index ece53b0d5725..70f89cb519ca 100755 --- a/.pnp.cjs +++ b/.pnp.cjs @@ -45813,6 +45813,7 @@ const zlib = require('zlib'); const require$$0 = require('module'); const StringDecoder = require('string_decoder'); const url = require('url'); +const assert = require('assert'); const _interopDefaultLegacy = e => e && typeof e === 'object' && 'default' in e ? e : { default: e }; @@ -45840,6 +45841,7 @@ const nodeUtils__namespace = /*#__PURE__*/_interopNamespace(nodeUtils); const zlib__default = /*#__PURE__*/_interopDefaultLegacy(zlib); const require$$0__default = /*#__PURE__*/_interopDefaultLegacy(require$$0); const StringDecoder__default = /*#__PURE__*/_interopDefaultLegacy(StringDecoder); +const assert__default = /*#__PURE__*/_interopDefaultLegacy(assert); const S_IFMT = 61440; const S_IFDIR = 16384; @@ -54925,6 +54927,459 @@ function resolve(pkg, entry='.', options={}) { } } +const ArrayIsArray = Array.isArray; +const JSONStringify = JSON.stringify; +const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames; +const ObjectPrototypeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop); +const RegExpPrototypeExec = (obj, string) => RegExp.prototype.exec.call(obj, string); +const RegExpPrototypeSymbolReplace = (obj, ...rest) => RegExp.prototype[Symbol.replace].apply(obj, rest); +const StringPrototypeEndsWith = (str, ...rest) => String.prototype.endsWith.apply(str, rest); +const StringPrototypeIncludes = (str, ...rest) => String.prototype.includes.apply(str, rest); +const StringPrototypeLastIndexOf = (str, ...rest) => String.prototype.lastIndexOf.apply(str, rest); +const StringPrototypeIndexOf = (str, ...rest) => String.prototype.indexOf.apply(str, rest); +const StringPrototypeReplace = (str, ...rest) => String.prototype.replace.apply(str, rest); +const StringPrototypeSlice = (str, ...rest) => String.prototype.slice.apply(str, rest); +const StringPrototypeStartsWith = (str, ...rest) => String.prototype.startsWith.apply(str, rest); +const SafeMap = Map; +const JSONParse = JSON.parse; + +function createErrorType(code, messageCreator, errorType) { + return class extends errorType { + constructor(...args) { + super(messageCreator(...args)); + this.code = code; + this.name = `${errorType.name} [${code}]`; + } + }; +} +const ERR_PACKAGE_IMPORT_NOT_DEFINED = createErrorType( + `ERR_PACKAGE_IMPORT_NOT_DEFINED`, + (specifier, packagePath, base) => { + return `Package import specifier "${specifier}" is not defined${packagePath ? ` in package ${packagePath}package.json` : ``} imported from ${base}`; + }, + TypeError +); +const ERR_INVALID_MODULE_SPECIFIER = createErrorType( + `ERR_INVALID_MODULE_SPECIFIER`, + (request, reason, base = void 0) => { + return `Invalid module "${request}" ${reason}${base ? ` imported from ${base}` : ``}`; + }, + TypeError +); +const ERR_INVALID_PACKAGE_TARGET = createErrorType( + `ERR_INVALID_PACKAGE_TARGET`, + (pkgPath, key, target, isImport = false, base = void 0) => { + const relError = typeof target === `string` && !isImport && target.length && !StringPrototypeStartsWith(target, `./`); + if (key === `.`) { + assert__default.default(isImport === false); + return `Invalid "exports" main target ${JSONStringify(target)} defined in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`; + } + return `Invalid "${isImport ? `imports` : `exports`}" target ${JSONStringify( + target + )} defined for '${key}' in the package config ${pkgPath}package.json${base ? ` imported from ${base}` : ``}${relError ? `; targets must start with "./"` : ``}`; + }, + Error +); +const ERR_INVALID_PACKAGE_CONFIG = createErrorType( + `ERR_INVALID_PACKAGE_CONFIG`, + (path, base, message) => { + return `Invalid package config ${path}${base ? ` while importing ${base}` : ``}${message ? `. ${message}` : ``}`; + }, + Error +); + +function filterOwnProperties(source, keys) { + const filtered = /* @__PURE__ */ Object.create(null); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (ObjectPrototypeHasOwnProperty(source, key)) { + filtered[key] = source[key]; + } + } + return filtered; +} + +const packageJSONCache = new SafeMap(); +function getPackageConfig(path, specifier, base, readFileSyncFn) { + const existing = packageJSONCache.get(path); + if (existing !== void 0) { + return existing; + } + const source = readFileSyncFn(path); + if (source === void 0) { + const packageConfig2 = { + pjsonPath: path, + exists: false, + main: void 0, + name: void 0, + type: "none", + exports: void 0, + imports: void 0 + }; + packageJSONCache.set(path, packageConfig2); + return packageConfig2; + } + let packageJSON; + try { + packageJSON = JSONParse(source); + } catch (error) { + throw new ERR_INVALID_PACKAGE_CONFIG( + path, + (base ? `"${specifier}" from ` : "") + url.fileURLToPath(base || specifier), + error.message + ); + } + let { imports, main, name, type } = filterOwnProperties(packageJSON, [ + "imports", + "main", + "name", + "type" + ]); + const exports = ObjectPrototypeHasOwnProperty(packageJSON, "exports") ? packageJSON.exports : void 0; + if (typeof imports !== "object" || imports === null) { + imports = void 0; + } + if (typeof main !== "string") { + main = void 0; + } + if (typeof name !== "string") { + name = void 0; + } + if (type !== "module" && type !== "commonjs") { + type = "none"; + } + const packageConfig = { + pjsonPath: path, + exists: true, + main, + name, + type, + exports, + imports + }; + packageJSONCache.set(path, packageConfig); + return packageConfig; +} +function getPackageScopeConfig(resolved, readFileSyncFn) { + let packageJSONUrl = new URL("./package.json", resolved); + while (true) { + const packageJSONPath2 = packageJSONUrl.pathname; + if (StringPrototypeEndsWith(packageJSONPath2, "node_modules/package.json")) { + break; + } + const packageConfig2 = getPackageConfig( + url.fileURLToPath(packageJSONUrl), + resolved, + void 0, + readFileSyncFn + ); + if (packageConfig2.exists) { + return packageConfig2; + } + const lastPackageJSONUrl = packageJSONUrl; + packageJSONUrl = new URL("../package.json", packageJSONUrl); + if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) { + break; + } + } + const packageJSONPath = url.fileURLToPath(packageJSONUrl); + const packageConfig = { + pjsonPath: packageJSONPath, + exists: false, + main: void 0, + name: void 0, + type: "none", + exports: void 0, + imports: void 0 + }; + packageJSONCache.set(packageJSONPath, packageConfig); + return packageConfig; +} + +/** + @license + Copyright Node.js contributors. All rights reserved. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal in the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + IN THE SOFTWARE. +*/ +function throwImportNotDefined(specifier, packageJSONUrl, base) { + throw new ERR_PACKAGE_IMPORT_NOT_DEFINED( + specifier, + packageJSONUrl && url.fileURLToPath(new URL(".", packageJSONUrl)), + url.fileURLToPath(base) + ); +} +function throwInvalidSubpath(subpath, packageJSONUrl, internal, base) { + const reason = `request is not a valid subpath for the "${internal ? "imports" : "exports"}" resolution of ${url.fileURLToPath(packageJSONUrl)}`; + throw new ERR_INVALID_MODULE_SPECIFIER( + subpath, + reason, + base && url.fileURLToPath(base) + ); +} +function throwInvalidPackageTarget(subpath, target, packageJSONUrl, internal, base) { + if (typeof target === "object" && target !== null) { + target = JSONStringify(target, null, ""); + } else { + target = `${target}`; + } + throw new ERR_INVALID_PACKAGE_TARGET( + url.fileURLToPath(new URL(".", packageJSONUrl)), + subpath, + target, + internal, + base && url.fileURLToPath(base) + ); +} +const invalidSegmentRegEx = /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i; +const patternRegEx = /\*/g; +function resolvePackageTargetString(target, subpath, match, packageJSONUrl, base, pattern, internal, conditions) { + if (subpath !== "" && !pattern && target[target.length - 1] !== "/") + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + if (!StringPrototypeStartsWith(target, "./")) { + if (internal && !StringPrototypeStartsWith(target, "../") && !StringPrototypeStartsWith(target, "/")) { + let isURL = false; + try { + new URL(target); + isURL = true; + } catch { + } + if (!isURL) { + const exportTarget = pattern ? RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) : target + subpath; + return exportTarget; + } + } + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + } + if (RegExpPrototypeExec( + invalidSegmentRegEx, + StringPrototypeSlice(target, 2) + ) !== null) + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + const resolved = new URL(target, packageJSONUrl); + const resolvedPath = resolved.pathname; + const packagePath = new URL(".", packageJSONUrl).pathname; + if (!StringPrototypeStartsWith(resolvedPath, packagePath)) + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + if (subpath === "") + return resolved; + if (RegExpPrototypeExec(invalidSegmentRegEx, subpath) !== null) { + const request = pattern ? StringPrototypeReplace(match, "*", () => subpath) : match + subpath; + throwInvalidSubpath(request, packageJSONUrl, internal, base); + } + if (pattern) { + return new URL( + RegExpPrototypeSymbolReplace(patternRegEx, resolved.href, () => subpath) + ); + } + return new URL(subpath, resolved); +} +function isArrayIndex(key) { + const keyNum = +key; + if (`${keyNum}` !== key) + return false; + return keyNum >= 0 && keyNum < 4294967295; +} +function resolvePackageTarget(packageJSONUrl, target, subpath, packageSubpath, base, pattern, internal, conditions) { + if (typeof target === "string") { + return resolvePackageTargetString( + target, + subpath, + packageSubpath, + packageJSONUrl, + base, + pattern, + internal); + } else if (ArrayIsArray(target)) { + if (target.length === 0) { + return null; + } + let lastException; + for (let i = 0; i < target.length; i++) { + const targetItem = target[i]; + let resolveResult; + try { + resolveResult = resolvePackageTarget( + packageJSONUrl, + targetItem, + subpath, + packageSubpath, + base, + pattern, + internal, + conditions + ); + } catch (e) { + lastException = e; + if (e.code === "ERR_INVALID_PACKAGE_TARGET") { + continue; + } + throw e; + } + if (resolveResult === void 0) { + continue; + } + if (resolveResult === null) { + lastException = null; + continue; + } + return resolveResult; + } + if (lastException === void 0 || lastException === null) + return lastException; + throw lastException; + } else if (typeof target === "object" && target !== null) { + const keys = ObjectGetOwnPropertyNames(target); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (isArrayIndex(key)) { + throw new ERR_INVALID_PACKAGE_CONFIG( + url.fileURLToPath(packageJSONUrl), + base, + '"exports" cannot contain numeric property keys.' + ); + } + } + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (key === "default" || conditions.has(key)) { + const conditionalTarget = target[key]; + const resolveResult = resolvePackageTarget( + packageJSONUrl, + conditionalTarget, + subpath, + packageSubpath, + base, + pattern, + internal, + conditions + ); + if (resolveResult === void 0) + continue; + return resolveResult; + } + } + return void 0; + } else if (target === null) { + return null; + } + throwInvalidPackageTarget( + packageSubpath, + target, + packageJSONUrl, + internal, + base + ); +} +function patternKeyCompare(a, b) { + const aPatternIndex = StringPrototypeIndexOf(a, "*"); + const bPatternIndex = StringPrototypeIndexOf(b, "*"); + const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; + const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; + if (baseLenA > baseLenB) + return -1; + if (baseLenB > baseLenA) + return 1; + if (aPatternIndex === -1) + return 1; + if (bPatternIndex === -1) + return -1; + if (a.length > b.length) + return -1; + if (b.length > a.length) + return 1; + return 0; +} +function packageImportsResolve({ + name, + base, + conditions, + readFileSyncFn +}) { + if (name === "#" || StringPrototypeStartsWith(name, "#/") || StringPrototypeEndsWith(name, "/")) { + const reason = "is not a valid internal imports specifier name"; + throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, url.fileURLToPath(base)); + } + let packageJSONUrl; + const packageConfig = getPackageScopeConfig(base, readFileSyncFn); + if (packageConfig.exists) { + packageJSONUrl = url.pathToFileURL(packageConfig.pjsonPath); + const imports = packageConfig.imports; + if (imports) { + if (ObjectPrototypeHasOwnProperty(imports, name) && !StringPrototypeIncludes(name, "*")) { + const resolveResult = resolvePackageTarget( + packageJSONUrl, + imports[name], + "", + name, + base, + false, + true, + conditions + ); + if (resolveResult != null) { + return resolveResult; + } + } else { + let bestMatch = ""; + let bestMatchSubpath; + const keys = ObjectGetOwnPropertyNames(imports); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const patternIndex = StringPrototypeIndexOf(key, "*"); + if (patternIndex !== -1 && StringPrototypeStartsWith( + name, + StringPrototypeSlice(key, 0, patternIndex) + )) { + const patternTrailer = StringPrototypeSlice(key, patternIndex + 1); + if (name.length >= key.length && StringPrototypeEndsWith(name, patternTrailer) && patternKeyCompare(bestMatch, key) === 1 && StringPrototypeLastIndexOf(key, "*") === patternIndex) { + bestMatch = key; + bestMatchSubpath = StringPrototypeSlice( + name, + patternIndex, + name.length - patternTrailer.length + ); + } + } + } + if (bestMatch) { + const target = imports[bestMatch]; + const resolveResult = resolvePackageTarget( + packageJSONUrl, + target, + bestMatchSubpath, + bestMatch, + base, + true, + true, + conditions + ); + if (resolveResult != null) { + return resolveResult; + } + } + } + } + } + throwImportNotDefined(name, packageJSONUrl, base); +} + function makeApi(runtimeState, opts) { const alwaysWarnOnFallback = Number(process.env.PNP_ALWAYS_WARN_ON_FALLBACK) > 0; const debugLevel = Number(process.env.PNP_DEBUG_LEVEL); @@ -55226,7 +55681,18 @@ function makeApi(runtimeState, opts) { } while (relativeLocation !== ``); return null; } + function tryReadFile(filePath) { + try { + return opts.fakeFs.readFileSync(npath.toPortablePath(filePath), `utf8`); + } catch (err) { + if (err.code === `ENOENT`) + return void 0; + throw err; + } + } function resolveToUnqualified(request, issuer, { considerBuiltins = true } = {}) { + if (request.startsWith(`#`)) + throw new Error(`resolveToUnqualified can not handle private import mappings`); if (request === `pnpapi`) return npath.toPortablePath(opts.pnpapiResolution); if (considerBuiltins && isBuiltinModule(request)) @@ -55505,8 +55971,28 @@ ${candidates.map((candidate) => `Not found: ${getPathForDisplay(candidate)} ); } } - function resolveRequest(request, issuer, { considerBuiltins, extensions, conditions } = {}) { + function resolvePrivateRequest(request, issuer, opts2) { + if (!issuer) + throw new Error(`Assertion failed: An issuer is required to resolve private import mappings`); + const resolved = packageImportsResolve({ + name: request, + base: url.pathToFileURL(npath.fromPortablePath(issuer)), + conditions: opts2.conditions ?? defaultExportsConditions, + readFileSyncFn: tryReadFile + }); + if (resolved instanceof URL) { + return resolveUnqualified(npath.toPortablePath(url.fileURLToPath(resolved)), { extensions: opts2.extensions }); + } else { + if (resolved.startsWith(`#`)) + throw new Error(`Mapping from one private import to another isn't allowed`); + return resolveRequest(resolved, issuer, opts2); + } + } + function resolveRequest(request, issuer, opts2 = {}) { try { + if (request.startsWith(`#`)) + return resolvePrivateRequest(request, issuer, opts2); + const { considerBuiltins, extensions, conditions } = opts2; const unqualifiedPath = resolveToUnqualified(request, issuer, { considerBuiltins }); if (request === `pnpapi`) return unqualifiedPath; diff --git a/.yarn/versions/db135733.yml b/.yarn/versions/db135733.yml new file mode 100644 index 000000000000..22e76f05f959 --- /dev/null +++ b/.yarn/versions/db135733.yml @@ -0,0 +1,27 @@ +releases: + "@yarnpkg/cli": patch + "@yarnpkg/plugin-pnp": patch + "@yarnpkg/pnp": patch + +declined: + - "@yarnpkg/plugin-compat" + - "@yarnpkg/plugin-constraints" + - "@yarnpkg/plugin-dlx" + - "@yarnpkg/plugin-essentials" + - "@yarnpkg/plugin-init" + - "@yarnpkg/plugin-interactive-tools" + - "@yarnpkg/plugin-nm" + - "@yarnpkg/plugin-npm-cli" + - "@yarnpkg/plugin-pack" + - "@yarnpkg/plugin-patch" + - "@yarnpkg/plugin-pnpm" + - "@yarnpkg/plugin-stage" + - "@yarnpkg/plugin-typescript" + - "@yarnpkg/plugin-version" + - "@yarnpkg/plugin-workspace-tools" + - "@yarnpkg/builder" + - "@yarnpkg/core" + - "@yarnpkg/doctor" + - "@yarnpkg/nm" + - "@yarnpkg/pnpify" + - "@yarnpkg/sdks" diff --git a/CHANGELOG.md b/CHANGELOG.md index ec171d1932fa..bf2cc0c6f6e6 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -74,6 +74,7 @@ The following changes only affect people writing Yarn plugins: ### Compatibility - The patched filesystem now supports `fchown`. +- PnP now handles private import mappings. - Updates the PnP compatibility layer for TypeScript v4.8.4 and v4.9.1-beta. ### Shell diff --git a/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts b/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts index ef1f16e8b739..887f7c27e12c 100644 --- a/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts +++ b/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts @@ -1,5 +1,5 @@ -import {Filename, ppath, xfs} from '@yarnpkg/fslib'; -import * as loaderFlags from '@yarnpkg/pnp/sources/esm-loader/loaderFlags'; +import {Filename, PortablePath, ppath, xfs} from '@yarnpkg/fslib'; +import * as loaderFlags from '@yarnpkg/pnp/sources/esm-loader/loaderFlags'; describe(`Plug'n'Play - ESM`, () => { test( @@ -657,4 +657,221 @@ describe(`Plug'n'Play - ESM`, () => { }, ), ); + + describe(`private import mappings`, () => { + test( + `it should support private import mappings`, + makeTemporaryEnv( + { + type: `module`, + imports: { + "#foo": `./foo.js`, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import {foo} from '#foo';\nconsole.log(foo)`, + ); + await xfs.writeFilePromise( + ppath.join(path, `foo.js` as Filename), + `export const foo = 42;`, + ); + + await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `42\n`, + }); + }, + ), + ); + + test( + `it should support conditions`, + makeTemporaryEnv( + { + type: `module`, + imports: { + "#foo": { + node: `./foo.js`, + default: `./404.js`, + }, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import {foo} from '#foo';\nconsole.log(foo)`, + ); + await xfs.writeFilePromise( + ppath.join(path, `foo.js` as Filename), + `export const foo = 42;`, + ); + + await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `42\n`, + }); + }, + ), + ); + + test( + `it should use the closest manifest`, + makeTemporaryEnv( + { + type: `module`, + imports: { + "#foo": `./foo/index.js`, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.mkdirPromise(ppath.join(path, `foo` as Filename)); + await xfs.writeJsonPromise(ppath.join(path, `foo/package.json` as PortablePath), { + type: `module`, + imports: { + "#bar": `./bar.js`, + }, + }); + await xfs.writeFilePromise( + ppath.join(path, `foo/bar.js` as Filename), + `export const bar = 42;`, + ); + await xfs.writeFilePromise(ppath.join(path, `foo/index.js` as PortablePath), `export * from '#bar';`); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import {bar} from '#foo';\nconsole.log(bar)`, + ); + + await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `42\n`, + }); + }, + ), + ); + + test( + `it should support mapping to a dependency`, + makeTemporaryEnv( + { + type: `module`, + dependencies: { + "no-deps": `1.0.0`, + }, + imports: { + "#foo/*": `no-deps/*`, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import noDeps from '#foo/index.js';\nconsole.log(noDeps)`, + ); + + await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `{ name: 'no-deps', version: '1.0.0' }\n`, + }); + }, + ), + ); + + test( + `it should use legacy resolve when mapping to a dependency without an exports field`, + makeTemporaryEnv( + { + type: `module`, + dependencies: { + "no-deps": `1.0.0`, + }, + imports: { + "#foo": `no-deps`, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import noDeps from '#foo';\nconsole.log(noDeps)`, + ); + + await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `{ name: 'no-deps', version: '1.0.0' }\n`, + }); + }, + ), + ); + + test( + `it should support wildcards`, + makeTemporaryEnv( + { + type: `module`, + imports: { + "#foo/*": `./*.js`, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import {foo} from '#foo/foo';\nconsole.log(foo)`, + ); + await xfs.writeFilePromise( + ppath.join(path, `foo.js` as Filename), + `export const foo = 42;`, + ); + + await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `42\n`, + }); + }, + ), + ); + + test( + `it should not allow mapping to another private mapping`, + makeTemporaryEnv( + { + type: `module`, + imports: { + "#foo": `#bar`, + "#bar": `./bar.js`, + }, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + `import {foo} from '#foo';\nconsole.log(foo)`, + ); + await xfs.writeFilePromise( + ppath.join(path, `bar.js` as Filename), + `export const foo = 42;`, + ); + + await expect(run(`node`, `./index.js`)).rejects.toMatchObject({ + code: 1, + stdout: ``, + stderr: expect.stringContaining(`Mapping from one private import to another isn't allowed`), + }); + }, + ), + ); + }); }); diff --git a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js index 601975803165..ce5e120bbc2e 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js +++ b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js @@ -2,7 +2,7 @@ let hook; module.exports = () => { if (typeof hook === `undefined`) - hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); + hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); return hook; }; diff --git a/packages/yarnpkg-pnp/sources/esm-loader/hooks/resolve.ts b/packages/yarnpkg-pnp/sources/esm-loader/hooks/resolve.ts index 99dd10a5a549..8a9646f9ed97 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/hooks/resolve.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/hooks/resolve.ts @@ -1,17 +1,55 @@ import {NativePath, PortablePath} from '@yarnpkg/fslib'; +import fs from 'fs'; import moduleExports from 'module'; import {fileURLToPath, pathToFileURL} from 'url'; import * as nodeUtils from '../../loader/nodeUtils'; +import {packageImportsResolve} from '../../node/resolve'; import {PnpApi} from '../../types'; import * as loaderUtils from '../loaderUtils'; const pathRegExp = /^(?![a-zA-Z]:[\\/]|\\\\|\.{0,2}(?:\/|$))((?:node:)?(?:@[^/]+\/)?[^/]+)\/*(.*|)$/; const isRelativeRegexp = /^\.{0,2}\//; +type ResolveContext = { + conditions: Array; + parentURL: string | undefined; +}; + +function tryReadFile(filePath: string) { + try { + return fs.readFileSync(filePath, `utf8`); + } catch (err) { + if (err.code === `ENOENT`) + return undefined; + + throw err; + } +} + +async function resolvePrivateRequest(specifier: string, issuer: string, context: ResolveContext, nextResolve: typeof resolve): Promise<{ url: string, shortCircuit: boolean }> { + const resolved = packageImportsResolve({ + name: specifier, + base: pathToFileURL(issuer), + conditions: new Set(context.conditions), + readFileSyncFn: tryReadFile, + }); + + if (resolved instanceof URL) { + return {url: resolved.href, shortCircuit: true}; + } else { + if (resolved.startsWith(`#`)) + // Node behaves interestingly by default so just block the request for now. + // https://github.com/nodejs/node/issues/40579 + throw new Error(`Mapping from one private import to another isn't allowed`); + + return resolve(resolved, context, nextResolve); + } +} + export async function resolve( originalSpecifier: string, - context: { conditions: Array, parentURL: string | undefined }, + context: ResolveContext, nextResolve: typeof resolve, ): Promise<{ url: string, shortCircuit: boolean }> { const {findPnpApi} = (moduleExports as unknown) as { findPnpApi?: (path: NativePath) => null | PnpApi }; @@ -38,6 +76,9 @@ export async function resolve( if (!pnpapi) return nextResolve(originalSpecifier, context, nextResolve); + if (specifier.startsWith(`#`)) + return resolvePrivateRequest(specifier, issuer, context, nextResolve); + const dependencyNameMatch = specifier.match(pathRegExp); let allowLegacyResolve = false; diff --git a/packages/yarnpkg-pnp/sources/hook.js b/packages/yarnpkg-pnp/sources/hook.js index ed8fdb4df771..06423d8c8cbc 100644 --- a/packages/yarnpkg-pnp/sources/hook.js +++ b/packages/yarnpkg-pnp/sources/hook.js @@ -2,7 +2,7 @@ let hook; module.exports = () => { if (typeof hook === `undefined`) - hook = require('zlib').brotliDecompressSync(Buffer.from('W8CXWKPorXgAtRNSSBv9PduIA8qQYcpw138M8UGlRC5TcIS5qa0CoF9vVsXzxt3NDxRUVROX2pCVlJ1poTA2caq+b4jlwTVctgKVm0JQojva4LEr5wyPkFxFjQ46+bAayzqNu5HceAkPTGtZBy/nVr3OYQQSwVMPR81e0a3reeXLcQWGHCp/r02uIvkHu+94uhGkKP202PxL+V3I7BhJ0cv/tv8ZjcTuON1Lxw3Y6+Y/kf7pHiSR/Dkgwrj1AwlDRFqb2I/TJW4xRZ7qqr6dn/jF8s831f7z8/XqHgbqZzhWZj0ZshclWY2yOriS3IvLJSkCohGBIIsHHXQXUNVMsZagtv+J1yeu8R8CFVVt+Fs8d+9Ps6/fMCnIYcuMkDDRFlLrlUbKiJbIdZ4N12Tv/zbT7r6cPizLCBTQkHTCRymlgw0ChrHWtNcW2xLxv9myapmrIKYkjm5YgR0+nNiLlx4g/tL87Lepdq5zzPXZXQ76aOFkA2J40k8N0iPj07RVFaKpQW0pd2SHw98W2x/tz1op1X3wdADdwHZzNIQJ+AG2nO9b1aKr0rtY/s4htam6OO/vnFgbGGsBWViyH//D+fT5sbtbqmlrP8/MnQtzA+gQiZK/lLwOiEpaomjfu5JP+S/kvVvHAJnymkAKZC4Dz/+Xqi63KW178QwKf9QMlbazKXuGziGSjgiCx6xcf7w2ybBcn9QKmF3JrP/GKgsHKH4ojLOYP/v/5eK+j4d2Pm8pyYrjkEAV46HMrsM7lYWhtEPPpK7f29z/clVnfmOZRLiDdnySkB1FfRydvFL5FjZcz4ePotfz6nN2s4QUkC5pRPzVatOIWKt6iPA8JV7Hg4OwXds9vj8zk0zatH4J0hvBlKgg+MWXb0yPhx2krd30+PIJEBRsQLrijeIMlK2o2H2pRYnT5yMPBNDWec7sreSVJcHKmMT8jFP2VNoILCdnqpHOKlvgcsPje0A7o26lcXCdA4f/1t48XkFDZz1CEt3QSgtGUG+/DkSfibN+kSjdyEr0bHIUWygECyQI5Mv3/9+3tFfyQJMcfBnjQ0Va+Xcw8i5UrJV3HXM3UVWvatCW090EJAIkx3E4xn1/zL1lXlVjuhsgP9Dk1yLB720m5zNFyhLrwwzENzaSIgVpKv//fd8s05qS8TYJm2aMM0nYOPfst9XAx8cqP8Mip8d4amRcpln3nH3PfcD/AEhWkW2KHCN2y7vY+DhSGgEomWoZF0n/f29p2fa9/3/8iEyAIMAGSdCUcd1SqVvGrSMToC2WvN2NcavGe/e+K8Z77//DiB8RqgyTzYzIyNNIgxHSzZAJ8P8fmawfAbCUCYKayCSrlUBX6YBdLQ1JOVaNLwLgqGjqDI2cbTPOr1lydozxK21nZ1zN+KXxu8XsZrGaxW41s9NuO/5/Uz/pSKPRbK9o02AAfJKl+/+2QUn3CeEu2sk5trfVPt9+3j5praP9MGELaGgIC4ChwUGwsQ389+0txQ4YRDwM+/zf/Z+UkUNCRmSqq6qvVkeedYoE8epdgZGNXEhA8b9L5+dnh6u6apTpjyKulSjHZbx0zJR5ZW+5E1SCuqJqEa4S4bAW+Kc6UM28pf1ABeJcqLErZKbAWEMtPV8H02sf3MyJBRjYnyjBhMuDADOXHjPNgkrwWhFrNNsv68/DNv//sBl7IvpimzYlEmKBOgUzFs4Z1Ti98d7/84+b1fsdArdAwmpbKhATQsSxgBeChkoEDZXRNbu7iXeT+qMF0iWlXamAR/AgCcFDEStaJEgSPECAIBV27hstT4b/tn2/o4J3CXlhQE8wjTBUCa1iIYgSBnENRL0Kgrt/xAljIp1V624D3sZu74XugayAUMQIRBShySZEEaJBIkQHwJ1s190LCZBAW5N8hRlMnIioqNnf8++//YAPLgQCgQM700AgsBAIHCgWOr7Q8f90Uf/XPSFPjKgYgahAVJAXBAKB4CcIBPlBIPam/T+/t3t53U89xRZTBJwiyCBBpggyYJBRAk4RJGDAKVIMGOEU7/fbtr6H2p6xu/d7VTcCgUAgEIgIRPaKukIgEAgEIiIiIiIiou3d4p+vz33CbDIz09kgWiAQCAQCgUCQDQLRAtEC0QKBONmUKHHWLQhqZ1fIu7sRIyY5BAKBIHkEAoFAIBDkMwJB8s2noqL59JOKWmlbNo9U7o/64Z7pUa1h/n9b/cHclXGjRgmlJBSlDMAEoyaMSd185/99fN1LqlNGKX8F6g74w0Y+SA8UfcQgOcApSddA30UZQ+87pRgw0HJP6It2woxTyr25p2D59pehjbmyglejEI90D2LAQG+7Lnp/R7pQF2MPffPNHkY80Cgldm1NycFlZzvr3Smk3CB4eEnjhpGTKTDJJnTf7fo4RDqPfCnUr3j6cKY59SBwJ4RUskS0+iY9waEODk/wFVcO/RpGMHQ9wmc3bQS8EKbIxYfE/LieE99Rk/ZzP6m//Sc70JBRHf84u3F4UdEA2UnYE0V+ZxqUWOxy41TsfHzRgmF04dCiV+AOjmA4rTjH6C9kv0j1aaL8+mCbuNkx8j++c6xHlrTon9S6RMlfcINtcgcbHdoXgEPHLaC4CaAWF6AIo6m3NTmQtyMU95VbP5a5wWlwwE6Iv4qisz+ntTF6oXqnaijWXXzjod9LtDtRFEieO3f/edISsN8ZcFkweZgNFDYjzERnGET4+uiy7YRDY43iQzQxds10lGFQEXAm2g7RQCydiT3iCouF1z/ar3+DOBSGZNNIvQx9isTNz2fpzSPO+8/nqOwjXT/7qJNIZxrXEqwF9GKR1ZPN+OdB5BXJu2zCOfXN46O79rwGmmhL9AmErUz5ic30Mo4XGFtK/lyYuKj240I5SfzoG21iCdLfo+e60oKT83SN2Nr0WRvh/LyYJiQfY/e4SuQCP/ALTPN7k5fgOSvU3fdRiFPVc1vEGgHb0hbmSxZaa9fXTSvrZWyJVAdFJd/0p1XKVKv9tsXkYpGLNQK3uq6MgAnu99k0ol75dSs2ZLnCCfg19yBIvfZAsl2FZFrRgxXHz8BuXvv450+sEcAc068qUuSqVX7dcvIEsCVSky3D+7ckIir5pQY/4dWitylhkSCceiUXN2tJ3kij+zpSHUcZrNIdJD+JUms15z4pw84z/k9L1v7hzRJpFNelUe5oBfWNXSoNNRDqL556COnZTLEt/esaDP6XPEfWz4/Bj8vIMZj+7HaOwxGEN21NnX8Y9KDI5YWKyRH0RjtzLDYseeI/3LJf2a5MPMlH0ZARkS8/+fApFIb1xa+OIED9LedVdebuvGa7IvQlYxlNZYsP/YOG0kB7zYqkw3OQMZUTL+lAY3wvp5vClH66gluxPaH9dthfWG6BSNfZA/pIeNI6ihucX5fZjU9UqVfH7Ej+Sdk13ydb0VH5jCSJ3dL1h9zsaP/aPnZdd6GPe+Iydx+R7gpBSiCoP+tIUbQs5PIWhkLa0nJw9Xa15FtgtSBXv7r61bWt8lve/d1AzCW6g7goah5yrnPoFxBKLdG16yUf6C48kXd/t6EsapMTSK/RTuTuCmguLGin8hNQQPW8aCczEZCfncgMSrobP0ng2ojRe5lNLjgiVQjwOqXk3IrBFgclLi+wznXwZosHryryDdBqmITGEHFOOCHtADVOZoy0rmeNSb6QN0vsWmCljHl9bLFcobDoZOSTYnjLXh3Rv4qFbrT1aCwZ8XSuPhLPENlu1OiV9nqcXtw9+NULWFHQeOOpr3lnJ47Dd6pqrq5crtRtadjFE9PoEDG2mGKap+HqacN6gFMjOkxuhIuLXVhO3Q53+5/HGXfTasN1zXZlumbyQ2dSNMcJx0X5sP4eilSX8c/78y0eaXyck0o97H+cNCA8XcFTVCAAY0ACA/WIkB+Se31ai0CzRlHp42rVMlF5PKKQSgJinp5Um/21oiUB1cCvbbYjoBqIcnZFEhmqRphl+UAKg82IfWEAGGGiAZnm+ooHz6sxaClAAdxXA0jvAUFPA+SzfyDzxuoxSuFAsNCzeqs+NF6bSWlRINGphhZSdI+Tchvjmh6mU8yvPJG+fSfidUJed6OYNognq6RX0ON5agcwXMau1S5D10hIqYAFRioxuTpHlNGUJV6N0sY+TlBpr6QvwCyvJRlJnff6ecczppBO6aBa/k2vatVTfymXlGql65SgpztFK2fjcT/lAWr9LC1v7+dSkkEVcAP1wavKWaHLGm2iMIDdLNPZRDb4wb71nzu9A3VT/CMT+5PHxpMtkIwmPSgy6gAVu6jqo2e0gmeKHlmIfmfottxRJWH5nbpanFrjPV3XUhq0lvlWm9JkZDp0ZoRiIjZqcf3axdYeCLpU16W1Slt1SQvlw/r/dJwa5d/LzDhkypRAUHaFv7s+I0JXcteiqnADbLJD7EAUdHuNeF/AGHFSRB8ltR4tdnJ3ciulr9miZSzF1WcnpsAvy4BC3x+O5JzXG+JKGndGuYyeD7LQLt/V5wX9ppiErbofLz17Y9dyyrq5ZLo8Zq0U48r98CsjtNA/+tmvxoTnofp0XuDK309T0FNutn0n/p9ISW8YRKTnyOjaSRrUdT5B7b8gp1AmIYlSk1BDMXjW6OReBe6tH01UYHDYLCpHzJgJKoTrRliXFQ0X+i8qGGKdRWP86w2oKfGfe0YScf+W3FrmU3OdLTP8tfoeDRD8a6csZST1U+bcCVC20ZTd1VpaC+dwsbXFD1Wd/wP5ZQQL0gLcIKywWyjBIdynfNe8avsBdw3lmvWNDT0MmPkXW/HIyeu0WHHEuDRFEg2JSiXUOj7srYW4aIH2BaZiEKKCHtRYSfMGp5szLIUa5N9Llbngf+/k4DjfSr2kTy8uQxnigonz+WDK2BEdET1++WqfZTIR09F/Kh0ymVhTY7CClMaMxSncnGThBhWyfpZhQQfVvYegU3BSlW2hSjFh9HAGokGWwkn3AKflkIVc03URNpFETy2kI4REU5EevyoWlePeXryEFbxlOoKds4v0cnvXpqNe384HbAILPuIC/fOgi0NpXSl3Fw+FqO9SHoIDY60sdvvhv++lDR27PrP2fNEIGZP3l3XGNpaN0BeekFNULJSlslL0nfYWduaQuAT0T5GtHKtcblEeDaGC44fYARTXUfO5HDpQ4EfIF7/99c3RgtAjGI6tMuE3TSNtKwZ/jeA7cL7dMaox1C9YRflOWogiKAIVfpodpXY9nir1DhpUWnfXczzIaPpy0KeoJX0g50if68Src+sNU+AY5aYXgnqS6947TCjq4K+ogEaLaxx1Ll+OyInPJDBLuHP+RBclDz6ljZBK4JZFJprKbSjKFY1InyGs6plCgXEvmnZEeDuoVSZNp15pc2lO1P70uUzg6WIxLZ3ToaQKsGKfgTZ3gSuCw5WHC7O1rZqSIp3gKVnhT5lVOi+a2+PaeKxgZUjTSFt6LvtahkR4yhiXOsBaLIHv56lpEZZmFbtUXFvBaBbhG222iVNzKYv3vML6id/3CE4C2RtLxrWlCdVqZW+afPRXTancwQ9WoXTdpYPDimrgx7SMuP0C0Xj173PoDcR2icElI+QbRV+uwu0OKtiGfI+RTDQp4RnqREpReyd66JV4j7hl+xV+Ew8hDL9jFONNCgxiHEh5WOS3lXDQ0UGzuuWeyqguyOqBYlmH6UiTGSthCVn3quB5ofBARGguay5TVp7fPVBmLKlliucSj2qsncnGAPGnBKPtWIfTrD9ext6QMpDIwXUNrhhe0rHkCrF6osvL09wjayaatsvRtbMU8Qa9DuX5nFpTRf3TRi2R9KduuKJeDBRGdSZUoliAVtoGuS0YkUYimO5IRTR6vHwR8/Mu6/qF19QBnjHoy9piAuIBzbdeIkGbOebtKOadiIesqCGrBbopMIOg88QtoWC/XBSvOnvHuGCM4+CGeldQ8WrT+k7tRy/U3j1nKSqR0v79w1qPkH/naHvOZUQnfMWeoAcqJUxVb/L9xCCrxFVJ+C4oJ01rGiZZupk8Hp9Rm1VUNfPOaDAQjWCTe42p890vcC+dTSleGpkuFrUTPhpTOtsQwglPVTRaeTbsWzOzX4RUzYSov5Q3vQi0grttgkeuAwYoFcKn1vMWDldSvVlHL5jk6NVVOG3RcoxoAxDeXDN4wilPewTpWcTkmULoLAy31fR9FlnzkP/8+h2MjQ9/83Jn9C7o+QdsMIaDj0RvpWGTYvfmHX8HdGpZQCPH/Bm/kIRPhqfX6vFuT5QJ7wnUNfZ6qztWpwLLIgK9P/Ah3KBlr4a5chhq0LC+SJtC3tN18nEydAZj6cWRE0dFe58Xh3A0gxxzRX+W83chxjXaPJhk+CnSS2QhH7HJY63oCn5r1lQV/eKCbLmzmAupI3BZKdWD9pVNC3Cofh3eH4rTwLonML26ePf7Smb2Abnhjj1KSSBo100okt34pzTbCViOOWMW6l2SzVtVC8vKyTcvZ9hA6zPj2mTXQ5SkTvqNTDBzX6zf1g/XPy5FaL9z495GEzbkQZLvvJKik8djunkSaK/timXGM3lGZyh6HI9YN3f0MmcSB8yVHDi0ZlOGKj5RbnCSvvUa38ec3H9+4/tgMJwsTMrPopJTY6jkr3Lo7HID72/Ry4dFDs2SHLfXSwSPs+JN0rqsZqJLUeFoSxdwJqEtjmHJ9r2u9GjZ+JYEG9rz4yiR5IbZanWQRCJnC2MSzLa6Uis13VvoWPRCJa1dxXoarMgsFwrDGYvJKeG08x5eGOSZV4f7oObSwxln+6nTZiiobvB6McIMM7rDU0NVWaGxtsVHOiTpNY4TsSkNdYwfrs/oAoeg+P1ugkrVtulRZiwq4fImm0ii22436q22Bf/dsDJx9647xNt/tHfK90znV9uCrRu9C4hlF7ELPXi6vdgH/RGurG9u1ZnZWLxIpNOSjTO2XqnHIK8zugm3pU/GjGGIknexITWz7ZXYvShBB5blNJWdhe7vlCRO5089N3YSLbL+QuLb2dolU1u355PgNDrR7eYDkZOAaO0tC30l0b6TJIdLuBNNvY7DOU8uX2KDiUUDRErH284DM4rVdtzkHyiYwdZ8VNMfdS6n6cd8sjBYrMQaw/+RiRErhgFAKkaBVZ4OYQjUr706uDKSsPeY9Phl7ylYTYVSMdMz2v1sHyyCtzvbZWtcfhPTTrmvNuNIKo0CQ+aw3NkxXEpDMerlWhMRIIsyyiuEcPUnsKwnEdakKcMtqkC1rXbmWdH6CkbCWMlcTMVxYknlyacMhWgKt3nrbamaJ5uyTe2NvgnuKurS0X5KGnbrE6V2bKiOfYS4s66RJrFUrsFm45ppHYxfcPLnnklUb0vW6wBjsPygGakGL/2PvNb1YrTaKJVUDrj9U7fh36IMitr7IaeDt5WiA6zq8CQ+DmrW900s/8i8+jHoy4lumPiWK9kJXSF/kt+9TiRD9vAbFo+Ug9+XMtC9BDtLXfj4cEC+yxtRpps0KQd637E7Cnpcs/wUtsPLv383n017rzr/0Im6uD1uoPQ+jR8F+FdP5jfxl6cPI3ifaryYpycDsqXkeDh5D16HytFBSnvwEBo0WW7nvkeQ23U+MSkm8ijOohBm+d6x4oEKosqZLXpLK9qCCjHRI8gB+rqpwsnQNbeSWZh0o5GVsc5SgsKfRSfKCHpNdz24lVIqkHdia7CVmKrQrSbyk4xcAJyaySYCdN1Lg0UxN7emld9sKHcKQHAPB+CTtlZ7Bg7GbI+enBtQ3w3zhhfDvbAPJrneX2PXKzVXVp1i9QuxXoTxzxcEqDximWV3Ee6EzASFClGteUjvlElq8KnSoO6nd0W+7w67cL4saFOWIhfUNjpY+Zp0Gd+Uygs4lhHlOnxr+Nm4AwOc8CEMeoFnxQkJyl8LI2nhnbxS7B83+pzC2mmnnYsvVw7vBORt1zWZYFeyY9aDWDWm3chDz5IeD1nQbm1p1ZyocnWBXNTnuzK50pyuvMDVPA3PfYaY1qlDV1xeNLY8GU122ep7rjfWKt0sUpaqEq1gW4/3WTToacFTlRKJ3YBvckY97HjWdaxZFmLHzKvxRSW+gwO2qjGz/9Il5fZqtcmptfgqk9EjEjUTNKtYaEdBSdqUNB3zMUYGTbeZIWr1b/wKEgx2mwoiBxVRH0Vjp6sOEkHZVUD+m73BbdEIkPZCOc0+TiwojQoY20Tc+OMFGq9ZJrDO3USO5kfXyRzG1MMVE69EBt5PSawgM20dn+kPS5uBIqiE5lFzXOi21vdlEb49yVnrL4Nso3Ev7mtYfsJHKq4lvmxV61KwOJB33Qf8duxcxurTmGdweQabezNE5eprgl9Ng1g7XxsGX6TOwW2QGJvzJh1hS9ugnMQlLOANLXMIhiIRohSzTsJYm49TqjdfIhnf63brmpkVPCHP3TPwEru7MpBrGxAX4k8sCNsQPrJ5hPMl3NfiLtu1abQNj69jwHsB8/lbNWcYrR611dRjiJENuzYr8QT/ofItbMx2KNLBKquRdGbUiZ2hf4ayVgXTHyRq/ugIetfpHSMajoF3+OL+v8ZuITFWuIXnGMHSkvfIUMxtsO+JfcYfd1R2F9VcAjbsYUv7KIgo1aqVE6h4qz72BCQ8vB0Qa8l8pT39IJoe8c5UKeP8cT4IdGlYis7j2V3A5BpDCHgcVxqQQWSwh5ExWnHEk6DddUeQnEnl5dEKcxIuCXaIGfd70Z/lcQu5P27pQ9JabJcB3jCNFfxVQ2AT6k0abkns+Pw2IPTO/zLcjnNGbVagct4A/R6PFcA8Hdi29WWeXtfYgeZLN7n4sQjP5Cw1yqcTFk9NPijXOnimq198/goJTDdcY/BFTjc+jy6VVy/oqEe3cgMpFYVO7D59eUUblkNz/ZMTXJ4USsWPBom8vxXBXUl9uDLFKS+zKj9vYkdqkLOq6bgWxuF3TTQqMPRx/4Ew+XtV3SjyjM/V1QStj2uMRPnTpyB2YSiiUj7f0U19Vt5d+Tll7G3YKHtsvYG3E9cJLlbdNdQvxyDoaLHL6DHiDqA7TxsOXI+JVsU7rkW7UDQDGc23p2oJh8/i4MMFobde2EbpQyMUlnnkm4fQPnKAIbvJ4Hgy+tHyg8CJT3cqyMPNANZp037uUWv81AEuGnogP7VfiovioHFgrasD8YGWJyESHcRcRbm3LlXslKrZUnapWT/b2HAcmeD+VPsFmCKzW2gVQVc+hxYsjVceAubILJuqdVFh8IRFkM624/i8VhgosAYGFc+mcdkmADUmojvrolTSG7uDDhTwdsUODzGITDzpjQhu7eraqDcRnyUnJKgmYC190uuW9fhZTlQK1Ze8RZh3oMiLrelLlWAxKYou5uJyQV+chAneALbp+5cl9525D8HWkugjN0nuunLOgvs3/qGNkrgLvDPzG+hAaOZdWH1sbHmW1oyCWo/TZfrBKN88cA7qsgkqPBo3s+Pph51bg2uKy0RgjHU2wi42jFyV/KVUTIGvoiHVcG6fDslcdrBjfRgQ9Mtu7FHRQmB4QO2cFw6wJ9sX2TAnRdjloUFmTUpukC6CxPpHThDTMQDHD+cQ2yaoiuaAuOYVoJ5/O4DWz4zakFohH/8WD0+g6hQqE0nbxYQAUumBRpg65mrxEhCuoSIrgN9Gpo/kMdFIEhF4XoUXx7Ly6VhHwfHoeIt4mmzLzEybjTEHlVStdxF/BJcZ89qQd5SUTkPpuR7EB7E2T1QFIzrzFCA6siD6odghOCavMZxPeGPUcZAKlM0/bN4RrazV74KGlZyO/PaqaPG1gk5kQfstFqABq+EmDJSRVOXdfKz5fIOWlzsxFudACzsfUEiR+sr7U4DeZXKQZ6D7FBYmKdCYcL3FIUFN6pBWHOedz3hneHKQJEUuG7J3QyavuIH/RUrebJ5cLFPPFFOtlFmX12e+9OyTvEjajXih4fnE8KAHl0fb3scKB0kC1BnR5c6dRt+bsPq0WjFNhqSUrqLrp6EtmGkDbE1pL3YrW3qySOyDQORR5Oe9B8NVY5SM/WmQedu6YW/Qur5eGZGycF/Z4BrMit3ep6AXqFZBXkcg+xwVXgJ9uOLh4wu3qfP15VyB4OX7kBd/+HgrMj54cjppP+MqnABe7voiIF/UYBUpfuLOoS8tN7FeYuoz1lNEMDeX6gqd+uPcdMFwbgjQ1iIpK49rS0WNg2wf6yaaj8j1DTOXa707YqI8P7fM1fXkb425QRyulnbSPbbgo4GH2wjAaUivb9vo9S3BM/Ol6pdi66apkKmf7+x06WHpSjURMK7aXf+w3C3fgSdXryGnHNw+bySfK4QKyT3POcoCTuJOjCifvEC+Ks//91M7Li++Yhpro2CQwqh+dkZFWCqNEv32xaBY70ZU+gDp2vDe6t2F+bh3a5spewZHSPSBS7yxUnNHg8uzcI3pesauyAfu3/65d7ZIq9mKjGustiInORVxGHW2A9qUP7xEg6S2/BmiJYJ8+O2ZbYJVn6zig0vIi/1WgpjLuoADKEuCDr6m67XUWLtfDgsy4UJ17mZsqdAtj+68bqv9f2mVFkYQNBteQDXqbGK30OPR5/xwExHXjUdwxHM9/likL9pbD7++ZNqCxIL4oDWcQLkjv2DAzbkoE/O5GYXVsEzrl+fisaWL8qBtV8n7WviIPgysbjQUlVdpkuRXzcrPLLoqPAO4WmM1mmtce8+Rt8VoizDNqj8xonGekWtJ1Mu/ZGul0TJ6SfPV92dznToafetTwFJDUE8fGx6SQkwdp8ZI45jt3S8ajMa11eeGuGq9cM22fq5EGWdUywknf3L592rRZedmBwdQaYrkE8NZUYW47k+IwP5hW4j2jjdHEeFm+XjfyNyr3PcHa5lss4k+Ytdb4kUojt5Bfrp/RKAXNqxSaigvQfKQjFzSeYvppRPaLQjetn0TUM/ukNBW7OqtCXQNNumuIVHA/6Aj/bPLNS/cG5zL64edmqBb61tTvsp5Ov783+6hifrFWJgshQ4/0uuDEJdWb7es3uSGOViFIX8N0UPVmbRxZ1NyEM+l4zss/RcAy6lV9zZ4CEwHd7FxGDsccbg8O8vm3nd2z4t1ZUUupZxFBex04k6w0RrCIjjFjZaRziECWdxBPJn2DN75qpX0W6KqT1z1MZ/cPfuxXUlxhFY1p5YRRtBrhSJFDJO7wVGbOjSuh86WAqeY2t5JLQNxBZngToMe5mrr/Ez7FOFk4Tl2eD3Efk2i7m6UGmgkoEmrcJajJXXDgIY5gywxlJEoXYjV407FwaMQ2CGSF6IdqTLIWPmAndns25GvgA6VL/KTsEJC0xAqIw3rPWpWqDb4+2TxHxt/+VA4GatCMVNJ5CeRTOcrslQnSkRMNuaqJw5DwOFtp08EONcaVWOFk7hquip2rZV499UA5XoVkVgBslDRxApoSyqgTWSzkNFal94qTqEhvowIryeCqAhr6u4/9hm7hVFhchxvA+OUmrRrsApQMMjYaB9cexZEAqvk2AsdmhSK3XBluFIIcQ7lOJCRune50wbGgGmMIsX0B9SjeTKJt4ocz/r4i3H8LDWK+AeO+nnbWv/KmxWsR1VHwWydJMvPKIR5T9F+ebtkljkpZxwT6AxoSTv+cc0Xe+YKPV2eDLYHbuq485uJXKJR7aUpdFkGulSFGH275L6ta9BxBAVzDHUoo1e3Z8LG1MUkxZTWckaR7EwhxXfDCMFX6y72cCoTf9fffUQcRENqXoIKrJPRGDLhY+rikmJKa15RJmvTSA5YYEyq5B7fD26NTGe6503PiCPPAePBmhVrFMhJ9xhtBgssPxeJkZ0ise4mjZg6Thdr1utqVCgSVKogDVVoNJcFYYyypP/uihH8CSWGSGPmZ3sfjqSKcueg24v/gWlZKy1+CSNOWuUmI8KUR8YzMEIFjRCQFZiaFQJkR/vZoqR1a2bM2PI5oGwMSODhMq99rl2YpiUyLoyIShr5YKfRFposYp+2I5W9BYUub6DLK6Tdc5O8PJVOA+0FmUJq1tmvN1YpTpXtiVw9YbbGZY9P1JgcYINNXWhzo6xa9yQ+hINAOIMGssTY/oskuSdb0HLyWOewTTMeyLRAUnGfZhqJz08RsTDiVk0lIdnTymVoNoQCz7udWjg42qVy/vV2gbGNpQwJV6QTkuneguWvD6avJkNUjxVNqgM+isoLPGYaYx0IQfDX2vTk7DkXoeqKCBu6iG9YPvJ/YQm+5oWSKM9C9MEk0sRRRqKUE4cboqjDyM+AmZ0DLztV1lo+Jc4qQMnJgJjKwFrWbe3PHZRwW7MflSVRDEnkKEGVzFyqMsLbxxH6UCgcCyWyYzjoPwl8VUno8kRaiS6D41iGchxE63CIiwUvoHdbPTrayxKiFkurhAm7DvF3nlx57hYI97nNhotEYtyiGrf2D8vGIhUXGuqsIi0wn7R0VLRP+aDKSZKymWiuEmurcL7qu/sqaAYngSccfwKcZF0c9DLTikwGUYQg+6laOddDcoeF41D9GpwHoyydD5AvVkIm5Qw39q+PG1jGTMpI0PMXXjZilKdUdBd9z41qIIcEI1yuEN2wkvZiw2jo8wgr3pioGryNFhr+SWpmi1uFhYm0YViT8Fd7hUyUE1SrP3GsmX8NYaYOy9YY7XTf9mg0/oJ9wnuObWtTvMhtw8WAkbh72gqegyZ7KlSyqzgdSF+ywwWRrqTKZoa12FfdJR7ALywxAQfz/yanQc9iTNVjEY4xWDYccUcybIEiqQZY8sL4qRDsgElSHdBAxxMfH5QjxSwG+PYuHsbiS91hD2F6uDzpuHLm93hvjAOBJCUGhLYswNqHncKemzyO8MOKRI4AfeTYUPYtZDaWJ9C+95geU7CsjQU46GWDj+qza9lQbnqMEmYfB63w4PtrxVBzNEnZ8Ls598N2tZsPlPlgKR/vUFRhi4ubDZ7Kyz8m90YinO8YrUryoVKiKxCVHgiZYutco5cScNpZOixtrJOMopIhXvDwbrAOlbZRsMgMxSI8Eg9hc2XiG07oMoqxQzJI4sAdDpYrbxM7D2LMm94ywfRso/1mwxafr9M8Lt90b1bTct8gha5Vodsz0HUpdHmF4tGY/IjWmInU5P4rH+EpDkDAK6ClYkaBtJKPHrVcResHEUXKK6wxtOSIepKPTBUnPOAV0lIxQ4Fayke9jrmL1h0s+hWGG8UQrz2ANVJ852y6RvMRtgIWAJzTEbe4/DsPMbjzFCzY6NhphoCjeiWRAYRUZJQvqKPjs0S0n+FIX03RU0yzMpddWsnfqZ2JeIPxITGZsRrBnMrlY6GLKX2c9tNi03/nTQAZwq/GD9+4N9RjVbB4VvQrZsVo+ayVns8Kdz6biLbnB75Gip8tXiZE8ltBoqMVENFPK6nRjQIrBKCxRDy9z2JUdfR+AV6R167QBQ10eYXymxF4Fe5wFf/Q5cJGB8tVVGP5DQ/1/Wk7B0sAIfVAfkuHhEroDNnawdfpaL8iNupNWfPbR2xBABIe2U7Cq74zjRS6EOajGX9BLWY+tl71lG9szzVIfl+FXzBYConGbAhY3/Mfhx85XreqMt188f0KpUSMBlX5HjGw8YEcdtwPQbOZ2o4edmN6/2nmQ/1T5zQeMnATMB+Rf/yAJYHmwo9VoOKuoM5FLxIexOK7RDA5+04jqrOVbedmLN0D+9hOK87SOq0ovGKETRcSAcIWAsDuGk7zBwiCnYV5Opi3c2fMWVRbwA4eWmmi2GkB2knvChKMAmG1IKRlfneQOBCIc8HvEhKwIMaC3S0UN+YY8aQ5jLvDo2bDURWfGjAO767r09APaV2LQJTzRJsA4W9CchtDQjtN+0qotlHt/VSxtGhn2O3IzDfHsUN6Le3w2ZlBSnY2wgOe3x4vryjhGdJJogjEc4L2Xn1dbwQdbOtwgto2sV1IfSuR54f2nwcjtjLdfCmRemhHjZbQJaFfhplq7KYiwZhMR4/nvAJmGKalogxpFm3ooZl5v1WEEi3QdfTtVVnmVvy6ZWO9dL9DgdhhKhcWdD/Ii8ENE5E9ZU/oZYxt31dLerdelI0rbsIavLZmts84q2+7ES9rMP5pvnK8bp23XtrS3g2imXfGCJGoWx4UhE0e2Tve32TZBBBZgCCtySk6E2djIFADFejxFhHcVKNPrQbRQB5Zgy4kk7u9roWTELWEYvjWH0DTAiKIPPIGfSRzz0vSNf/hitvHE85HD4aMtjt5mLhcQVm0JjNhMdzkBhHwQwfEAlHQ+pkfu2QFD7zn+g/POmzLXOcxNr2CZz+1ha76TJF1whm1mz57WigCZaFChKOlfuTTERxIpz1iPmG9Dqy8W7QYNFobPAFj8+c0eH3bmP00ReeZg3VDkGESOHW1ie1b7+7gEIPDhJs3BmNwPYjUBJfzPnEWnF+PV1+0BB6/ptTG4YJrHaClUtgAFqdxTvpVm61iX8h3ZUSfeyYUuaeGHqwvrXjUrVvOxCcOD3kJyouuFdkEB6ABvXwICZBHQocnBs5qAkZ2CmPf0+WDbemtvq84O90/lheRMZnZ4tHhDHrGE/Dx25VrbNNPvWi/M7Ti8llq9xYvNdb7eBM0JjV9S358kFN5HFYdlQrp/bCW+x4db5b2KkVukx1s8401/M2cG2KtOxsaehx7PnCSY96v7y+duel+082dubCZX6QbcT5ggO7D2Mj/VllRqeJW6SCzUzxPk+e7H7vFnzhoK8FZ9PjiCvUFFVuMwSoB5dpBU/RWDZ4KSrI9LZIAUrS/O19MGJEqnvvsFHSNIdRfKaWFCghyocDQlB987i476nNTxAtx1HqmEeD8ZAVas41dtGzOQigqaLOvBWNS8TeDI4Ftdnt+f+A9IduVNpDlZPUHwzHgwVJJR+pL9DCWktZ0FVUgBqfKiRtW9jmiXh8ct23V1zhNQr/LzR9KYv1399xu/dZeD61crNlIHCdWXeySKoCWAvW4wUBMjnKcg2OG5VaLOqq25mYn8P0yOIuUxSojlS5bU4YLD3XVaa55Ary4DqaqRtcsHsyxssskNFh3blynGZPy5rQX1pIoUo7oxCkMVO9uhqR5n6Clomz80BG+MRgSyAhh8Q6rwpz2wlvOp88bUIwGQBRTh+nwxnToMBa16P3KEcfU8Fb1yPN5Synj1WwWa62viwyMCLePzHgBGz538xkVX8DtfGDrrVaKhiL7ojlehSK1FIKuUQutcu4uknV6jitV6EIKXZ+BrkWh76ZQ/pgbPueTK55rQkA5iWJz+dcp8jlRWkuDaC8irMpxSYZ44FLngaUlIJKZBEX82ZgKBUQ4LFo+GRLfLIIkizeOJsioYfyjN92n9xIjUVr5eW8L5dUpakshYgXUpmlX+NOo+PYlxAHexgzpCYhs/jQrvq3xKVHtjYgHxWROz/ItLQL5wpjQRtgHYXuJVUFLbi4NNakgmKdZ8fj5uo0eXx/91JP745HZflVROnqSsxOu+CQCx43nldiFgu2La/mz6NGztQ/zPKzP8pjVD129f9VTPXFmT3APbF30FnHTuJY8mHK8bC18RyA+v+ludx4EaDw3JSmy6ml9aCMwBFKzL/vhaelolAtDAH/WiTD3kZgyjCTKeiZpwAkG1U9+hHTgnFkmVrgPop30B87dWcfd/6P73JjZ9pINQ78ol//lJERj827SuZpgN+Vq5sibjm4PmFT2zUBfWTqrgBF6yMUDbe2kOGXT/zU4jXmTO0jtfdDJ4LIG2edxoJ5pyGTiGhSl5PUShZ1fGaik0vGodeMaqVyxO3DfcElJ+Ua/2rdZ5dmtXsVTuyfo0Y+ceU0xay9Q3D4RifcCls5JLsjjYcvuhgtvSu0ctErPbMH2cF9Z2rji9MK0lhnEGW4+yX2kBISAvbE0d8XthS3PNTkqN4ki0XFj43fnK+mhNl163/bd6VQHu94+OU/28m1oEjkRUYhysiFwfNdx5nP/zXWGS3u9y7ObcVojN96VBkDs6KJKpRHbrhlV5GcqoprPJRurafeA0QIfKHIjBC0rajio2xfUGwIO3NYhiI6fPyyb92smBcGXOH3SHd2YPnBSNbfsmWHI+D/HlPIasPu7Fqwl4qVsVkwnZ0WkaHZMk8+K1PRsPtEzXx9GpHHji0oqJrLdVgWIBAiEdwzYg6h5Cyb44A0qhha4lPPHWfPGDtLDLC8y+UorMGrFmnD1Cl1coWs20PUpdBGFkMPAeSdwqeOWF618YNxeshYQFRqIcB78b8ZqUVEvBk6TdS9ZC4gKDU6QNX+qOfZQO27cqBC4noMUO0YuAfr4UWXW5CFmkOFFI1pd+Hh13pUTQuA2ECIrABy5Trl4lBlSB3wqY8Ac286bPkyfR8YUO64B0/xx7bzVQ+QgxNJIVddafZ3R2WdexeKFkoJ1CrWAx4R0hHpnK6yODGnzsJgk4V6uDCwaICzUPgwd186bMcAct+SYnIBopk56543qMYFMa7HHpMsfLc8HsofoFc+JE2xLzLg6DX6DJL/xJZ6fltRqGrZPkRBLGx7mnw9jjcDZ6uifb8/eUz3dy5ioNybboTzx4LQDvJeIyGRv8UkJf98zTne4nJefzoABvLoxkRb6AQ8IaLI4MUuzdIzoMf46k/piESfYoU6+7qolY6S1NEdSW3Xs+Xi/EKvTw4DBrI5BvXfo1CQNQf4d7VmcNkmYGiha6AMQcIA63wBjJ0RfUpbjM5a9ST/0fPELY5+b7CTK8DkICFLxLxONjZMR4E70HnO/fiK84MfIf/OXGvgpc7tC432yOQDhCcFmxuw0BnLCBUZXJLp4f/JhF+AXDLf4KoeNWMz3suCPXQZ3xDOSSjQdNdI4cR7vn82cnGLB744ZyQcsplTIZllYxchNkeFgB2wGs7o3VS4CkI/8U4wvIqMBWTcVB+0MFBh6+SEcMA1HZhWK9HAMviUcHJH3pAeB7GBJogno+pOKlMf0vrzig3/BtpzbHoPzOlBSOxaTJWUjijRD9AUItKlKAzSbkKk+iE7ksGBczWB2kztsjasmPKud+nkaasbQCxLB1ZfteMh+4PXSP4bJH2RxiU4hAlDGrBxOGJFpQ6DZBr5IQ8KoHpx46FkmqH4qiZvYO4oKt+MD4RnNLqEeVlBJG1uR/Iybc4KiTPEDudGR49OsE7DXher85M7ecoH46rZg4Yu7V8wS8ge0WAJf7DzJ6bW5yL1o8lCL80K0iE6MhQlcgM3YmiRipnjN77/ysuWsFLnCb6GneqYhI0EZeBT01EWAcRwSCR57OieQktOhr8HL89EKWkZb407b2xdKqraqJyKAtqVRIA+9RKLju4bOhwYO85MTKeEFyVvrbDOIf2iOJimKYFdqAQI9CHCQi3os8SFCdULSvVnHiUFF2QJPQdthQ/Zug0PrlTkJn92WsNMfsfQwm+UdYuPDERosCSypXFacdbBtjWl4SINXssDUm/WAorDuh7ln4wkQeENTwbLP3bIsLEaFtGJKEwSfL0JaGrziBEh9nBTvRaWeiYte7e7NkH+FQNwdJaidImk7i2pjvYskA1WLM5rPKrbLJx3uY+XJkmDUR0go4hneIr9B5EwVuQKKH0ZERohic7TKY4VYIaDlBVRHBTDTHIvnv4CbDwd2JyB0hGhQY2cg2VyZoghW3tlt8jeV8x0K6FbUmuwFpGrSb7UNGE/vpGifuziaQVR+/LPuTMm+k2T/5v9zkj6Z/vxunZXPJikjPJzPWGvz9j7njV/f+2Ht9EzeFv9/PG8Hjo76N+tF/omec0/EPZMcO0b54YKz6QT2hu++FkXRq+iDxU+yQOQOOVgQPx3/oKYGap/vND9Nh+PKi8YpNEiZqTLG/kHmpnirtCdHld0IMbJDNjNEgDR+eEnH1S1UOnp8FAq0xkn5Gb0XrmxDfcZJer0cfBa1iyaRU2ZZXhZRBhY6vuWYKHDutmAQJIyWv5H3pwoL57xWUr7lQz4rs+EhDoVyTLwszx+o7vjJPHe4ivTfBrNg1a3dljMyEyWfZq7ujBoKMXQ6gjOQkwrCYmSU3YKcqPd9Xy6YpHAD6iSVm25pBFrd7S0jcc6h0/u2IaxwRCo9YmGTAyEKVjn9OE+Br6QM7YoEW7/CqjY8VFJfe3JnQRziBE0s0ry8DBxk+fFO0TnLnq+Saw7BAP4umC6Qs1Xtsto+Ayr2YFdj77On1vrUUT6ZKk5vK1uvZQEiJedC63EChnrt0cn0cujZYfmvPCsLCZPpszs8j5yrR0UHihAX9h74IISmtDiDQyZI6v8kXDPK+vHx5ymCd4uPmA9UzWJa0A3mWe0ipMYfowwEoX0vEfFpUtA6I8X8udc+K8Xc+NhI7HH2UGdTvNjJmZw7q3Vt42hgaY2oPtqr/qE8ke41EU26+K2v9H7nKs8J3cX0Ifb8MB12TlhAonySXyGNeUkYD+C2L5z/P/197hUkqyqBQ3hYtxxD/FZ3OO/dR4hPVS8WbIiqIAbsyfJdQg/Jw1uC6obBaVIVkvcuTp0n/1HQHRvYL69ZOXVpxk9emtHFsxmvnDlnKrQ+3gR2AOA+A2iEhUAFY1b10C3ZVawbGI9k9v7hB+vuRA9BIk6mISEUIG4mBCFCsHkx+ybys0uFgYuFvl06Y1dRXrlS31rKQyNMji5xnBwsEx3cwzQUsFU96vWwaSrl4apdNA4zjo7z8G9wBVWz5aSvp1ijr/ZEa12BsWn4JH4jh9EF0W57UmnXunIecLBqrxvko+IFxR46vi485nPqEpJVu9ETsiJCa+Rfz2Utfhi1s5XHjOK43JUYMde7EOC82JANJmJmjhYW2HI7wBZjgMnOnPp4TjQXksFYRFWMhERPjxNP8PFi7KVMcG1b5KydAodmliAL64QkUpO/Nsv32+LRgezNsU3/YpwbNt95fMymkjxau7UbKmeUbA5GRMCP3iPEfJlutHvYkCLfaBuZpNQihJcKmj5rzwTENRa6hNFv65WlNGzwKTcyQPRSkWaKltXTMkD0EvGnG1ouxmhxD3TgdAYVowSl0rpqc7+v3IQ72UvhYk0S4S42rM8AyEuEscVqlPNWGguwmu1JFKyKFo7Py9KR8fizaEjjIQ56sbp9QdTcDVCAdiigmEcijFUpzSpNFhxPLjUcHKuBfT485DIn4l/7A5lvz7XIbKxiorMF4i4dFF2aqS/w7SwUTcwG2T5zla42zvXjn1uOghF65lDsBKZ3tSr3D9CbFzbnL/RkJ59q598g4Rov9Ik0f4MSZLD0y5Mi5O6IPW33g6Y4kz4+CFsh6BNnvUiONZF7LQm08YnCiDPgMkDk2cNMxzNWyCFdCTNLeIQEYCFofPPx8oAqm2fislGE0rI4x+DWnQtPd5GKdYLLQaEXrcB5PUGwcmsIvjOhvkjMp64RwvuMOKtns31Rw7A6d4IiFYuWb87qXXSKIqklYdLhUMTN8PE5hDzWXJgnu8cK7W2LIEGPwzuvvBIXkbKQOqesSZZZ78ri7CeVUbs7YEW1tKA8Kl8GFlZgZxYEG6LV2yg/ewRgzBWno+Mj8V91gnIhYgmGEmqATJOqeC7+rvlW0goxR+5zymRjaNWY2pfLFSDEp0MGFMfq2BpjFRU9Ac1zZDknCXOVjq/m3bFCeARmnLVhYVGhz7uk48wOEk+XoIOApyswP0KUu3z5BrVru1gRCuLWwb1L2pjHI9lCKtcKayTY1jntbmfwAIsoGaziGLpl9nAnv1BEYWf/RD0HiYc6+LGPXvVhSVcCl4WEVSlCgHzLmm/max8NbtFzXVpr1fUaFsp5arfLm7r49GlMhGVggPxnKgUxn5k876vlmJIIxv0de5O5w/CvgLT7u6q0HwrQB8/LpGKAZGwq3MtKeZzKG8dAe28AzAFoQ4KaWQAUiq1quWIM2CrDtQAob26WC4kRjJ4IDXpaKhhxio3jmbPoh9CEEbV9f8lrRj5Hj4VRo0WodcY0aHkjkQzC5e+SOxcRvdBBH7TQg9Dmwcs1EEBA0JZ7aGOVMwdBi034RuoglLai80NguOAJI9B6VeRuhFIHQBt4YmIIwuo1mUeG78l5cMQBjkeDEG939s+R6jbkjq5HdCRNkmpedzo9ItAskf7h7AMErVboItOspPLjUxCjbR2jddcwg5dcwRkg0OKMB/uPCZiUMZCpaXbEz9siPOZ5fRh+VEPr6ZXIka9FSbQ22WrTH3omNirvHPfHPBn/QXmTDsP48qD882eFszCZQkE5whUL9GezlecxpcPmeJaik8oBTk9gmwO0E9qYmyu2KUtu5/XUm4V+B7gBnIpPsj4BXbKjGIswTIHBYlqIow98nXWedMep5D4cxTwPBInlpI4e8HF9/GQbL6DPl12o2FqfokFez+Swc7GvMskDZQIVZZmHOA121iDjMhKl5VHcL9H6BJ3YuCFrbT4vc+VpNMTGGVELA0sRilJ2Amv6rAthOwdtCqqyqpWNNjJam1KOApGnqHLcohBJQeVbiGRr8QYBxa0QTYuc8zeDhejLBpiSF9Cs9IrlAEVjSN144GMxiscynLt1u2EkXbiC/8asqCE4RlTdmmzhbViXrfqkxjhlm6HdnQ85o7uEkpnmS3b2m5Sq2iajS518N2FnksTtpJwDk7v1s5j1lFFZj3TkTfv9ReKomhrBJQir1VxqVdig5bDQamWCZUDrMpkLMTRu0dfiJwqaZfNK/9/9vg9N4lW9VNLwVxgrbZDdsd49MU1nR9sVzlGhnCGD0RUz5Wk5MYMxIWaEfoVxfSYYcrThjIy0XadcK/MRt7hC5hKCxBprVxtPqufLbtoEeTwFIHb78WDi3aqSIFigMFEYMR0TBriaamRyZwndcei7/pkrLN44L5jIHL/jsE8R0wQCQBAMb4tsP+G5ND4kFYQJbZa7jrJ6UakFQ8dbZKCLXofqi0lReC1LZBYcWUlxi7L3cQ8CbzkOluRMfoRXTlmEEjCeSyD554VhR8YkjBFJRMYLyE8CcEFMMAddczTGxkoBfcRZp1UTLueIYU+r2/F3usjrJq8iCGJTQdZWFrSi0DJ70y29DKwexSbMZXzo7dC6ozZs7uL4Vd+f1sb3b7qPZe6nQqHf9Fy/P9GtFbTfPb0OBfNFjUK7OqpjCCSspkyrmb74DBkw+oSgMvFXxI88CYthEloW2XGlhRzWwQvqRbqq2i7+m6ccxO0iOoJv2Se/QQC1cIEzto+ro3tTtvwwWqCRDkuW7n1yZCxSRTJakvCXWIJTzpSrmnhw6lm/53m2n2UnpXjRuARP3XiU9jGV/gwm62GgylELyXZ4fWct1EWJUtgBq8q4Nx9qz1qV6eUQNyUi3SBHw2OgD7WwSkmXHUthWBcMJ9csk3kl2B7XBmfUWLUojGtEjOji2g6dlgmLY/fUBU9eSk6cX9lSUJViIjprfkLgOldFtuO49gUZP40+WkAZhAXHjbQDJiyihF7gOuUybnCRKotPGHP3ujkfTimkR1EW0VQz7lp4r6eIri/BB6NxITTfydi9ckMAjLpe9IHuJMUIJ8ApmVftfst6+H63gAIwk3JxiA3nWzB9V5ZR0cq9RMNDbJgExzCWzpB9uBsNv23dV01oilG9bAKcSBDQoJ7mjtS2beDwh+F/m333ifMx6BIvLuWE/YmefYaJXsSLqDAyhKEDwPNtbwdEu9WTALKXAV9MiiihK4BixVR+9KX90QKYootIs8lBCKMF0v9Sd2GDjPNCo2860uY+J55vyeBJJyNXo9CQ1D/2vNLmdNvcf+xDyT4cexleHeMCgx3Tif43cq7flfMfJIPKNeebsztwS0ReZO68OTh7c05x30XSFIwKB8DUxogBTmr7juNtYpL+eSfdMZPnGgEniqefeOhvn8uEvTDyy/hkxW6+YmT+yqE/2ZwjVfMhqnpMaq0tTzyuc56d+0N/JFGJ3MfjYVIcJJaR/qZk/amlJuYhoaq7EA5DtoVJNq5VGS3KEnPUqUSvD6ca4lun9KbVm/9OX7fKdIBlaOKNowRZC1/Dmdw+8cts729rJ49OWUn1gU+iewrQvqj0zSstv03Uhsw+MHl3/0koSndWUBv1E+cak3CzhYcQBWaDvMmXtnq+ar+ZXoctoYySjLiW9+bP591t+klpScLBwo0XbVV76dYdgdXVZxEVeglW76vo61QSdCy7/Df/lAFvynC7xNja6GIBYSMb0iIcMX0T5McICIhOO+jIJV7HlJ0v25UI3LxoAnkP5AegTZyrITFBwBcw5ePLlLF9lVeiRvmU4SC+gbGAkNzrH5/2MeVT7wSIroeelIU85EOhLFFooiQOsYJLtwbczHD0ccyP9SfC9fRvTXkPG1zEzhblN1/Qyf1ScOGxJHphLovU049VoITU3xMBZDUFQSRuYWSWVMWkRK8+xpSLBBa9pmSquF5WulCeSA3Dasq5J3zLZlcIUgA1YfLG5PJ6iwUpERRlgc3Z+GVYEGBrCMnqCnmq9kwR+KSbpy9uu8YpvSUv0AL0VHilb25KF4fEx6cjH7cUlwTTBvi3xDyJGZb2i+s6NH+0W/1XN3qktVbat8l7wMOzJkPjSU8ae8FBgwBQuDzYwqjuAC+PzPsz6VZdfY120DLaospR05WA0KIqZRjFlIVsnEV40GR0eoKjpDWAGfwUOO3jdvq089KOEaJxPaWcyISFuaVRlbIJiVRKtJ71R+Odp5asKYueFi7TGiZ27OwUkUgtjobZSibD0mZ4/vijDRrJediOqKLXBB3JQcQDNS3xlBBHJ79fY0BvJeqDQp0UhFNw/MQo0KZOhiKKpmFEXrTslfLENXQC9zCE0znsxaq6uAsKWTbX+mSr88bxd0iN/F09nRu8Xxo1+Rn1bmYhZwg0AFaxev3iYNSvuT+pUfnn3ha9EnDP3kA0DFaQ3GHeRNORA3l0iqP5zPUQ7PV9Qsv7par7ZHuiUXMVwqmA48llDNanF7gtFgSHF56K1JFquhsAnzDC1MCXZ1QKC4IX3/ZQp4Me4PgXGVscEhaw0OYf4UV+Nj2unUlMcrTxSBvNFo0w6+4MPMW3lmZewAFse4fl0SrO8WvfFdvTILzrrMU/HDmZ0UsT0tdxOnMqNbDEKg1AHePQJFRTpy/7g1WPQV53iDEcV/jv7NSMyKV9X+pg5VxeAS2eBVTeEyt+bTpccMKJbPc4Mz3KPbwj5nfjKzk7RcPOHdUfiLDzhG1R/2lKFkSOZhzgbOcM4Loj5mIhQc1bovILhpUKAKuB4/IPEx/Xy8dJylEUzgaFsAWAfqlUzyRsAgyqubcjDlbOy/045iw9CEoeW50KvFtV+sB5ufHoxgdBB26yawlYzTmD4gOCnJQgRPOI7cnP77hLRcStPmKcj32yqs0E0qwd58VUSEYh0xlV/jobJ15eKc/UyI32uACfkSA3WrKakXuzpG+4+cjEsyCJOgqgD9rApIIlEPhWW87mLUC+4lFODnBZzOQkuch/zKKgyAI2kMKl0PdBUuGAVExUlZVOloOXxIucKM8QMSGLZyxA1BtnOLbubmSIrdg91U+T/AfTSrmVVFei4jUaeIO9yl2gMPtL0OaF76pwyp3X5w3wC0n/Rg2+J4KcbqTjV2B1jLUvrPxXUb8g+kATvMJ8YNacYzFFOgwH+HPiJSu1hM7juQN9mP5TJ28kN5RCIpUexKrp8lSpwS2UgXx8HfxcxNRtVqIlEz0mYzr+gsLTs9NNj2sZ9/SKjem63cU+GfsVgpfJhZnzmBIgHbozlBt7reGAX/rFDWk/57t8fI+49621oX0lpo8t1WpUjIbGI1kIPUJaZrwm6LdvPuhpaQ1iPpbFTl0KtLcAm+JP6h956dm/281NBnmFm5fpX4NSQrBiPLwGDvSf8gC2xtf6LkvVQi+8SqOrKZfjssMfmlRROIKbgUX69XIhZaMx3sPEyttipd74oN1PKBVWMQU2ciNTYMRcOMawsotlKdKpxNVJDJPXpd06cPs45Wp+894A/iGn+GP4gF9SpWhcY2ELFnEgrDeB4yoHfBO46IGv44vXrpL/YS74hzwRoQtI9L+HYoz/lxTScPIcZW06NCbhEzBfA6yR/Stl2ePHMbtcI+rzDIwSmVxN18kWIjF9Bl8KtZkfpWFVkehHi4ew7WVobcirtRLyZVaxRaItNCG0unfE0ILmVpHEJj8k5dqmdwkCPf7VinNQRH8ArccqPR1OEfP6ilRqX9rar4iXC0Yd2dbs7gfxK++3By/oAIn5zdwsSFD1o0Kqhkn4e67m8xCv9F0xXA8Crh2EFiD01YOwUg8K4DHM9wUjYuSgF6z9dod8WDz0F0sRmalESmLg1QjIdjW4EWrhpFyLvMEL007Zn/pI2frcTxcwgVisDB7Npl4lHarVQ9oWN5jpswnoC22VoSVCEdSLo+vZwAYC2QT0HQnXV0np8ZPOxhUy0sW7CgAFsd8NTBhdcx+Mvxi4Xls5CvcGVS8Sabe+eilS+uReru5OfvFU3WkXmMPwLfy+h7y/aq0kXZhdRcp20NnEQgDE+gVh+BJI3w7QpoAYVcVbRV1radMALAPQKtMdyAxsg9GK0y4Ivrx6p4HlU3qcyOXBFc96Z+s7oWIsizI+vSwW10yiE6mYNHcGlRXtM89jPZ/0JUwYxlUnO/ntFJBzSM9SdLt4n9Jrr/z9HiRoWOxzn7hbSPbLznrx223R6240x1OzJm+iQk3dZrMAUMd+j2Au4u+dBgB5wb12rI4feSWPp5BHy4876uPPN4/HAP/4Z31E+J+l+u897NBE5MOv7DpQwmbBPL/B5Ef6yA/TqXvknMub42eJ8DfjoiER/JXO9OZFSBHQb54IsXmG0Hrv8GMR5CsCJrFhsuSRCD7CGy3gooy/3dOzq/ZvHvnu0UpIlpu/Rwnsr3cDWH4wh4OvEGbuYaPSadyB5pM9OYE9O4kNTsteHOzetq+WHd/2zWfvTrIfD5sc7KfHvpzMvh1yljvkfuyvxYr/51Hw+1x25N5gWLQRnzvvrauwxlfSeM9MIrN7tBevha9ywVjjyI1HRxEbD7l2XjSI13FBbglrEA2P0QC5I1hXSu5NEiKWW3LmEhYYhPYJkqXcJU6bsCA3JS4F0QAkx0WTSmMQo46KQ7OTHJry0DegE485cpGjSeSnZRhvDfCOJNDsg9rCZTNivcF6JqccWiCVaOOcDQYNggZxmsWRE2idaBudpCgKIUPYkKOcoxAIyG5YOx0EDTV5qgAvBEEbnHXJ22AhOVQjEGEAlkhsIHJipyGIRmM7/SPthQ6XE5zkgR4tl2FxLuSp+M5uxU3rIJ6SEG56zuboAfOBxr+k5LgZudIgqr5Do2PVC23DSQ60wbdojKwaoe0oNMjG3DsxJhadox04maOL7DpyXHIehNa4zoEu1b+hcY03uTSn5KgkHFeBY8upzX6GxktScFwpZwS5Uq646ig13lA3jqvMpQa5Vv+KxluaTria81eD1PgJrXed+gGtnzr1z2j93Kl/QuuhU79D65dOfUbrfaf+Ea1fO/U/aD126u7R+q1T/4DW7536X/yD92z6+wPGeNJBo7vbC4oc+O6UuaC2TgO8xh12cP1ecGqB+1NmTnD3ZeA0B76/Dhx/8j1XfsooPJRj/4xf88z3H9RQP8D0/8Ys15/Qiy5apol+zb5xzvxmlaNv5DcXC25b/tEq0ff0OK8laxXpVd4onzjDe13seO/5JZePvM/cqy563ife5/KCce4GXawZC/dMuWQc3ZMuEmPPu1xGRnXZ1t2RyRmPA/236pTHlv5T/aLvt2kaewaIm/kzPg8RAIs1w7wAV/ASaMDcLCoqw2nP5BA20IoYjhZinoe1cDBj4P+KQiisHWHpfrGQnlaiDmg0gILIxdNEA5gW1w0U6jX9OZORMFZqCkUkPHINBqnm91EDCipDCwELNcO8vk9PJBPINGAHKOLFBA7XrH6GXlEWxHDkYoFfmRqa6btXZAnHqbBpHvhRntmfG9tDOb91E7lj43x8i5ou7ZIbKOxtGSyOl2wWvqe2AnXsahc6kECv4NHDl0ALsY5zTFC0cj3xuqi3kp2wQErfksCdACn9lU7bYxYq9P92/RaMoAVdTO2KwgQZTDFAPNkPUOjAGaxeUxSPiYWARYLCkcWaNBLITIEJMvCMXhVXcIyCQxQqszoEQTVSykRVOmpfj3QXUz+htMRwMig3A4XUaPPpZ9R0rfQAvDz2QCzSKjrEWoXbvx8y9noxClVKgThf9hw34lZlqyoD4EcHV5O1pRau6gW5xaMxVhbeySJ/Z+G6JmTHAZL7n6EKXzswoiDS6aeu4B7RAKbRPERjBRyr2XvvuOkElTHcDOCD0mNCA6w0eVoo0NqTr/GOGxthrTyTEHIzsPftMzkPSE5B0QlQLHyYCI+SZLsh1JymdslW06T/rzIeclv6/klfMtWrVPYJ2a2aJlhZQUdGtvIt53P8IKCz8NFt+8CTFXXf5b4XkXDUXj+jPo/HOWB0xJnVNEtNmzEfE38IzdPx8fsLr8Iz6L+WoJ0pkRlbKFoAM/NU+BFm6JEaE7VZ1npz67hnoBkz/I3jVwgRe7wVkK4zZEhwnki6UrjKhYq0GmEEeqU+g/msMjqjdeT4o/dQ4v3bQAhNArUZ8Ayw04p7LaAgVofI0kZm7QKfvLEEoo9DQQzMa91ArhUgQZo/38uoYFOATBhLhgGK6hEeAcPnZpOgMvjahQ7Bzv9weeBAf5uIwxlqbyIgWixAkIUqNQeYdjfmqsg5vnysP7ylR9fuYlpn5qaoDTbc8YK3xzxSDjl4+g7GzHV9YxDHiymL9GoSSen1SYvXy483xfb7mpJ4rN6QnNjxXSfC60iPG1CThphAigRruJxiEdOTx3uSP3VETFKtFJjxj6mPJtqlqCz5PQemRHEJVo0eDwOkxbqJn7yDgRso1DioA0lsRkOc4i7H+Prb+3Bjxo6qeBRhgRmySP/tlJKpNRpx6pSC3k6aWTB7ZAhxKx4iO8nUYdMJPp0S5Css3lETAgIxRByY4WAtOvnz95dGV1PS6ROQf+8ZWDo1xdNnDyvoaqoVBAoaYZsGGmje1XJGbIyJCbOdtYGKUFXuZz3XyQzv0MHLnmH5QkhkmF+I4Ucr1Nx9Dk0Yll/miqXFo/OYE9hFYOls7pEOBigrRlEk4DKz2WArbfXmjhQAYQQYpBpduAjrxeKI6Sr3NgBLSLxyvTpunVgL2GkAfUNKxDFLV/oKyOASCMJ4itHWdGASJhSDN175ExefC8UPDc47/8ALPykYh0b45Fde5je8+52v/sJv/bxwikNPwW/Yj7cXSeMpI4G1oqupKUNGCYicvhlg+X0OoOwXDs8ImlRsYHP9mognFQeoiYnKCPH6+ZmOFUfA/xEuAPkOyBO2Ct456I3/O/8nlpPf4WYQS6cRFM4hvcWJ4fdcIjyMieELX4H9EoBLgkUL6STOpwlzKNSUAEXmQpFMemsROOrZxHHdC008XoqYoapx+Ke9hXdAb2aFvTb19xwF0RoxDwfw9jt/ImbA9Pbh993FgMgFby+m2R3mxR+d1luE3L+ybgfCIzsuc+I0HMWRHqcn9uM7ChMRPaYBJig5ZqaCdqnQNBbmGB1d7N+dV6L+dOdgdlrV3JtT4owHnUQMxKcvFJB1giHI/gHu74NRdkgBTCSM0FEcTOEIt08DcbyMP6YkMHBc1oSHaYIA0/uNF3Q3ba/Ma6K3A7mERwjcTqCAdgW8OvQGvTgScJoKqkZuMjzUPVFNHmpvHWAzhyw+gwSOfqQFzoFUYqqcXVfG3rUFezpN+OOtjhJ6nAw93EKg5TyDTbss20eGkrzFTKoGSkU1CbtOqU3MBRI0F0fMQCVKcL5zROhjKIPLptSd1ntRdjxqz2MU4XfFee/KCif0qX4D3LKiuwo0zHFSTuIFm7SJ0XC4nIIcmqwRdd0U6o0f7Mef898ZDgqKw/W4Y2qGgYIoTA7EBYt9Kh7fNHLZpUi8OPtMvNnjJ8RrcXSDw8U1Dfw4hRbS7r+9HJfHLfQ41AtkgA7ABIWFCAu8dB2dKZ7gto6sOKRgpKs1X5bCMVQGh3gE6DRpHvF+OMvQjXmoto2sC1eDwPfEk4mcBR4Ga//aOUQ64XNx0SEHiv2mSOm4jvUCI8SzwIGVt6aTSUC4RCfG7btZOw7qhbgFOF+cgmWAoaZMGUZLg0g+BetX09DWEIFiOJlkxqucqs3vDCOGNFQcvV2FSLFYgFRV+gp5H50MkzJvGSZlU+/S10S6cMlkMuy7dP4UmkCXM+QRB3Hle8ngIgIrhmAQOv63BIP8Ho/nyoyDIkGhsQgar5QZfu+rtDrMKExPqmQSWasCICDLdRGLywzU4uGuQHNEd56dLeJZC5BWr6MPGUTNjH/yCeUljzPoepwYFLqj0SD9h9Cq8QyUAkrRNKXbnsigGMNOnYqdzgeB/iLXJMiDKQj7OKJkFZDquSLHMgGe71LaOtc8WcbQ47SS/rBiKOj+H0nJBuwgW2gnVjkZUqMoxOMlbf+hAHzo4Lvo2ZbQq8YcxkRwYNpsiNMGYuVVrA2QkBZFinOaivgGAadN1ZVYgpnCycMmn+o2HPz/DcvcWQVDYi2x3KjVHr5TdUQ3M2HoMoTZNYx57co2NE+JGJD5azKaJI0PacTdVT0wUM549DAy5nTeIGC5lf8af17zW0PQaQT4hQLTNfm3EVMpRgxFccCcOpZIaFzcld5tvByvX2kbBxcItn/Iu4frebojLfLncF3219hiLgQ3kA1z7yihUr1/+D3d/Wn6uD68r/a1aayaywi/7y+G2adyqKgiDXVQef5q+uNy7TqSDW5Yx9mlxrCmcJwgba8dBOliqgpXDUHxO9lsQ506/bM5IgWAiPSe1ZhAygVsfAbLCPsDNZw2rQYoyZBoOj3LcvRY11fJ7a3K9/Y6VdhLKaRv6ybU2mDW0UFMSMwqNBM1X3ybAMf+TDBCs6wvJlUpaC+vpZ5OT39Zv9foH11nCTHR44Z539FHdn8XE8Jeg7UATlkG8kuwxU9zKHI/wLzRjE5wuBqcLqZPtPi/OAafY2e0emW6SCbg65W292NTDEn4OhwXRVNBMbCOxyzqSS4z0cclJMH+eogXFgUduoS5ClhnIYcHnqpjcSrtSfy2OIgphHeqcHaTb4rxinQKEGW+XsgIC2RdoRn5MwGCYinCNw7wM/9umPiPmwi1HDTr+qLWvMYyYAfmEGRkwd8qgWXAtw21lwZEIX+onYrIfNcasBuTmIg1RFt8q/ifs9hp8cSStadvIeKk4ifT22HKCbPZiVHAUn89/P6tknSfyeNgZ7T8UoNaA/YHi0c8r4Ae37ydnshxwT+rORjLWG2vN1yPF7w6ILjtEPsRvnlMjQn1Ej+dz1w0YBr/Z5FIPwAXg92yp82Uq5ekF1yPFy+m19Rj074dPyfCdADkZBYkjZyvDh1xb1Mj3QvyNxxcH4ZyfApKRRVJy5PC0RBTMuybWTWQLKlaEsj994DgxGdF0UxatDuG4kSOz6Qn/WXKs2nM85us9DEpTqOAruV8gv3A4rx6Zyn+oxfmtoNdVUKST6cYpBE8q6ASivocS+nn5uJimYx5n0GzQk+/g6BcwZfOARfABzkpwQkRD3E2rQV9E1eEOaJse3SDyIAV5DE6n8Fga53q5+QRmbeI4n1vIeLEt6RvFricSU81gcGq3QfkH/Hmak7xUMXzh+nzh4k4PYpWcvw8fynOyzVMaUMvwSx1/4ddnsWjKMMCsi7PDB86XAxgcKC9urLOdVyjmKYMtkgKmzZi22EURS85DYTP3moEqiu3jDb8CvV+9IiD6SmuhA4SAe0lZsgiMJ4RJNEQw2AWwiWGhNPIhcSdGrL7dGIUIqRSzAgxJLQUtNOkdVbRVyGrOMyIvT1jahYqXz12dFpRZXmYOevRnITrsTpdbYTXr8WrUlNizItDv7O/O1YIRxxYo/RcoLT9iyaUcY32w8JCLpDMfnrFaqvFKoPAeooFPXD4cNV4mq5DZA/Lq+aiUiBa4Si7W+/hN+c83Wpwx+nvJJyU744TKKhnA5oPw8A0CgzqYNk3b8+Ex2j29v5hglLQGSrwe83VcIcBCpZlv6jTtH5hnJKA+k9u5GptNFwwM4M+EWq2HgQfAkOqdMFMvh6TYKQ0dlIcqtbsJDEgO4UaDBVKOh5o4ElD0Yn2Pia8Dhvg4gWm0jEziFqmSmlwUxFNiP4H9xCZiQQoSh+fEJqm14q19syo+6UP1rOVbdBa+aNi5fHUfWf1mMTCjUw2tHY20mI62lDX0+xyBjPxzJ9We+Zqw5QdEl3/+uj24f4cKvEhGLUOTUZSk6VQylC6NBNQuxm6CbKjzcicGO0ySEWsBlf1zTD2M1OglpHG6DUTeBJxMqcJZMhFT3P2zQgs6KkOsh60DIpUXka4sJjD44sJQivCkM9Do9xHPFk6EfP7LErh7oqlL7rM+gfw+D5xvOhGw4Xwc+U4hzz8BAghb5wfIAe4zJDX07QQaYtHKyMrcqr7jRuafrH1EJrb3Y2G4B9YHlY2xWKdGyBlAgN6/VGj90+s8JT6JAXN2QZB7zWAGW6BIlT1p7UVDiOCYdb4cQg0qNGlcF8J65kXKUTdA74azAjQGIjaeuQ4n00JHCWwGGOjEtKSgOYN0pDQNH2LJe7LgpgWGiIvJAxpunNFMbkcY66YAwYDdFYpoeVjYJix4kz+LnLZTps1hW2+K4qqisSofCdQNAUGxSwr2hEYtMAUIztfGcdZ4n1gBIN8PdY/fuflfufnh2AD9YzwdR8qcQEtfTG4mwkwB6ulGoSpkO6SJLg791ysRXqC7gDM0Z9GWIjXvhQTo1xy7YCimE4Q61I2CeKm5QZ3t6gCgciU+Z7DEq1RRXhNMg1PTA4hu3YzcZ58BMpd3MWDx7nmLjP59chBVoI4JxPwfuQDNEYkrK6HgmaCoQKqRUkP2RiOiQYmSNTJ7VP0PBZO4HkCFxdMKAp3Q7mK4CLHDO4yw4nB1bthMNMJftJJVinrlIiSdO5XUaD8BSW8zrDTmCIpuhMm9C00Gw4krZWys45e4cTCw1R7wlhyUgYAyHuZRTyrb/u8pvHTtDUJBZA5znWLtN+ZVFgzW8XcCWtJ99uYGz9hmIVWCJJHTNFyo2WxqQBKs47rrINju90LU9QPWSKv0sZGAIJi7Mv52JxAgLMmsWl0BUIEw1bZnreFZn+6QOtAiKJLtV/U0vmF1qtfCFGYVpbcZ0JzQAOaKxQS27JdIOzd3BB/DbVAWWMa4iHpnVIzk6klIO2bOuZj8SrB7apbu8jfWXIBqL+GlApS7arDy0KDs7Ri2FsTEcdL4B8DzRqTiZfccY0PfFxLwkxFwntzSNx2m6QyAb1T3VYBMWC67uKMD9Jl68DXA7aa6anuc7yfvFqYRiVexVuzuB8MJHbVzLnFwJi6WIFgPw5UmvJ28KCSRLzDbGFoEuIhjeTMdKFRVlFKngQmsinJq0uOYnI5od+eu+MHrN4BMXXB1aOuVTUzpbhAW3VC+pghfk0o9B1yIJfUM0+56m9zcvOdXtxDchV6b+J6dXmNE2Ju+bRMfKRqsYR5y75MmqgMyFdQlCKxlSJtpIuzbkGyEpP2Xbl4SYO4AgA3fvXFkeYw2ICRQGztw0uPf+0dXZ6NC7vGUi5y5HocGZz7vt+yzyAK0NXm7/jI0h/Pav/ud3NA8/mKawrjMwsWCKlRelS9P5Wsa7DJ2plAWq8BvHNCY7vaMWSrWXCG/n4uEd8htImDkCCxA8MNdMoNcAHu5K8NnTZQEZuw8b3j+XBBzLid9uDWStMiDhWQF2K5bazChetAzDKJ8HvB7j2xVE3TbAqL/PWhyfX+QbhdIrRWExcfPyQO21RieZjyf60RZdY4xm652oL84G9a95b/9CEUvn9GR7nHbUmCEya2OGiGpTvqwz7BK0FRuHsokMy3HJbvYMBQYyVhNnytBkiRNTqd/a6TXGmHqM2O5Y8sf/cKHsaZngbOkRI0NEprSfcj2vm/HIOhckQnRcAjeBllqg4++cvXclb5sCO1hoStEHHXw7AbUt8RFHLGIm+uRXCovDEIYKMondI+ARNOf+xfuIW7T/9X2ZAJ0a4Ks7oh6yH9ONqAK0UZvwbon40oS99ztQFGSGtwWQrFd/w1iBExgjpAsSdDNNm9zDTDKMFsOSfCQUdNrPD/zgIvcwO8Xa29+VOcr2hQkMmrXNbERWlmEzu9nvDd2WnpGu2I0UTHZNtZXNPvFNdaLP3i82mVBXXGMGm1u9yRbvRMvI7nbmocpp6uWU9xzDRIHVp2GbS4bvxv/sLB2GpVXyZYlebXzqOZvYkWv09LSiZSlq71e0xlTiGq7dX5Fa9grIXSNxNOf7ve8bvQKJEwJ2RwEJJqGpj/wDbWO7cxQ5Mt9A0IhWr3ecgT9vDP6RNNkkIkvoQXikvpXwkI+e8qVR4ES0gi1mY3mQEKog8+XLRfBgiwg33bVV4IeMdhFGe2Y4CpSNdh9wptvVg82T90S4TfRs7YqNKOmIiCZoMdNJ91a1oQPh8Lk76tci9+K+OsDqo2BAhbGUggqYegVBg4lOrTtjxn5xvyHyuqaXjAlCT4/DPdD2DcibU9bBJ1qPR0dcws1TUvKlIs8wPyMSelf0H9DYGnq/kYhgo2hWgBxRSSHQESXaxmKWDenHi3af7CTzF+qBMXC8q3O6gRsMLbm+e4y39F8UTrWCuHT5ihHpd1SfINbOA6FlR1OSMVfRkJv6YeiGaMsV9ySgxiwsUslPspeoZo0cmyTYHtZH6+Yb56v/B/oN2qwDd8x/lPCBj/WRwOzod6nP0wAQrMvJYzXr6SR8CaH09NnhDIkA86C4jWeTx3k0JQHL2Fg/NL3Y1fENSgM80MsNP8C+Jsf5xzfhrT4KctfkRSyZ1PKM44aKs0rgl/xrjcUdfLiRP/Oe2EzRj1Ew9ON/HD0QllhKww2RWVqdwvsjb8e/PFpdQE99SnZAZu/Dq0Dqx7yivf8O56/miAj30LzhjKYrIq2uqVE1E8hsgygOEQNdAuCCr9PSQ/Hra623QlywG7RSZzz9qDsjSBWq32MtbLVS8fZ5PqK6KY0ZqZm5J47SjIb3mCB5FoldlIHk2WcmSqJnT/wWGWegLfAVBgQMTsbooAT1x7IkV1nCdAgkAtFcTatIUZVIt+j2eDxrH6CsB4O6ybCgrEIRsjHyI3e0SCWNm0R6SNzWFzWUeacA7VNTO3R7KLjwJxyMbIh6jNb066fziZWDAUAIOaoxtTq0oBnNs2fWsWIGhtHcoSsPe0B+f+D4f9L1qcXyXHj+oL+eFXc6rIF/+Ktp+nRSPYsVr1Xj22jaRjyTyYYEZs8mJyQ2JM72VGgWSDPqZapBRp3rlYLpunwV0wIzZ5MbkhMab3MqMgsoJ07XOdl99TFkbU9nn49bSPmZpYC3PvlgHAYL85DIgGPozpp/ivnZ+gk3vWEn3uFpsMaXteV3KKv0d+Itr+PHxh/nn9u++NvXZkqOnrxTWQIX8HCZA9poMEyB7TqfBHwuCrSFTbFQ66DqElyGH1MvSyvQNxmM5LRxIiRvr0sqKo3SKKayLtV01Efhz6kjnzOERwYjONxzuL61by5w3Q7/HS2RD0yLsJHvCd7KvUFtDYiN0N8yJcd1hBBNJgGCK6uQE5Xwuuq0zRKHYgp0NwJzA88srNvP6Pv86Wwj989XzvnE6SqZi8PiPp/tYZZZfdlJlK0nVk1qgw48kRoMa9MvzHYGv9dU1EjjVAnPBfqdPPvAS5OUj9Bg15gEv39TmpSHHDov0G/UQucON06RQonY+ZazvuIcgNtugN3HCK+yNMSZWr+fMJRG6WrJkZC/1j1jmTImvfHsMuPoqRXiEzILPrNEU7UCSowsFa5aErcN3Agzg/HRlI50e4QBKyWnmILaWH8Oc8iZCIdnPCttgHnD88tsFpBvtuWG3c2Oxe/H8oMPJUtqKPteKib5RqTzXv4lhGPP4sgUu3aBm8XuDvUtQBeF0FyGSSbBrxPzXO+B5nU9PQPUBqDwGqiZdkChAyggpJhFaRQ61LLxl4eKta0m70FdPm0yFcCBIR7I6/63G+6n6PB3DcycBIFSBS85KywxVSwUL632fZXKWBryiVTjYZ/0XAsQ/Ypeb5DqflFa7dSX6zLnNrJddjnOZWbMPD3DU+EaSCcOHDoSsCbFkowsLq+f/3vMUqC6HHNRYzRlhxvh81IPQjlwvRdjl2G1zTOFQuEbq6IQdlqsD5Cd7tvVSG9pZcaBNHCSVvoKsgbM7Ef8EIu08TSMwEb4lt3FAdOySdotuC7gvvO/TBnNIxl/nArJn7fvJhttFy+x24EXUjbBfSAFdr5bZ1Wwr8LOVejCmwo9aYT1sLS+Tjkk0IAfN5nSkRnyIUeRtzmbh3Nqwm0QEBR+isjWaa+96lZbMzcq29AH4Sj0EigEQmek2N3qRAoE7kU//jyp2Y/yzXZhOkr/IvgMJTmepa2OWkuLh0vT2HcB7Srue0PCbJeaocpoNo6ppkzdytx1TGEi0TF1wQLtKI/r/6nWUPdaFC3LaNIH3GhZ9sTf4Twkv+Bf8aIFse9HN1i8+lISP8kQp8EgvX08kimUrchGBm4qepAMk9VvcDXkvNqKDytqZ3yHFSMxFCua5sjx8JE893WzwQDX6b2h3WCFSDdh1RWgoabcqsnRX4lpQG0AZlK+uSUedIIedOrvwdQSMVWKYWvgsTLqQJK77UIbSiesejxms9okZjAEf6N5wdndvbiKZ5oa1vK38IWraKhXaOlAkk3mnu03T3rxA5ztLTDgPiaGaHgSavy8KE3i92rSZGVDRY0/S1+n9F+78owVTu5BuQnQyy8LF5AegTUNQfo6j1Ni7wL1sBihb9SfjaKZ9E0oTMKe3wD5kB9mTnhWFFJZHralB0uqBRQS1+WrmUFSZGhgNg4E5NBUA7zWimEHvVuoQDXBcOqVkLOnxPvK3/N6jJ9iVzfLt478jm9fK4yzWwBNx6sYGC2prHvkKvtwnYcYirrUrMgmp1Z/KYMHUrKCNmvxAtFE4nbpEhJCHDbxJAmSqJYn2yo4amMENWt66WUL7BxfTjq/alBnhQip3KGSiCc+akod06oVIu18t6H7sOZQnDviIJmqvf3y+mLVuZBV72Iqv+bTf4IYSfXV8iy6gaYLtZqiYhyx6MK+pTAIOMY2wCyilF1o4U0YjMiUVR/87U4VT6HXftVLAZRloS+eusH8T2DCf9EK92lEHuQSNEh7UpzkYyMq3eAJRERjaLhs1gvqUkWAT4nPjnnly/0PXgmpgxyT1Cw06om3Y7kGZ4UpuBnNkRAz2kvMBXV1NyEGGm1SG3roBP5mUhgQjiiPX3D28Lgm/6uUZC6NUd33uVenikyAF7yEHMkRTaBlCqWzosjzew/zUgcu7Ql93d5EDBqEIXWPIwQ2qoCS4wjhJoMn8f64vrLm7y9OR5Z80/ywfHBmoOZCOHVfar4h2wu3lSexIEDxO6Av5MZJYX4iSc9LE1PihnLPExA7U4rL+PW46OkqOZ8D3NbKoxn7VSsitqYhrrgNvWwPPe0djVAttMSj1q8nsMskTUk++fmvRLnzwH9ZLUXVn/5Ahtz1gyOxNtnvb97qFVdQoAQAHVLWucRPG497EQ4whjn1dl0Dr2U2R6dzePTWcWnPKaFVxiaui79/EZ3e4MBezSLM/Ng854r8cCM1JY4Ldn7uC0mgRl1ym0PPveiLvr3RYcYhEsYgEsDKLysHGHkSQXWhuyFNaFXQTafc0yAxf6SiXgEjujEj7SjDfT70DSOLjs9QyMwnyH8DicsWTynQfvObj1URZfWRlOxwR3qucQMztkXdR9lDWx4xlxCHYEJmjBodv6iKTJW3s2xAemd8zU9sGbVOHtNYmj/XdfKDk15tlZbjZFD2nrw9KaPFcvdPgJt+PbiZIW6UU1trguxRnUDYl0e7VklLFecNOGIo15HuL4a4oERMj7Ka5OAHol4ZsrScuw46YT6qE62b5ADV4aqtfRkXcigWldd5I8fVODQ9SX3U/FzTo50Ntm2aB9e3/lKrRPkpmUFLVA6dhTtAUZATIA6eGIbIiO7/W/IcVLqJBbRZpXg3ax7thZg3nsMSdAcsCUns4msCJ1sIus+09kCMfjJ4DIDftb5B7Rv43iyv2zCiaKmcLw6AV6XbsqBow2k3Z80fKekLMsWjmeXHhgrdVIiGd8vliC4thiKiLywcAcqZuMjMCj/bjXghshm3J85Vf2MF8LfRPNUkMleONiED0SudMgL04A3hgIwHQuSztRsrtdUMbmx0JyNHIzdJgLDwnDMwpZlgvc3Mrcqm9TwKguUv8KU43isCED3aREJHYYoawM7sLnKRsUsCvanHJ4UV9Gu5UUzmZ4yYYH16uAMGDxRZ/7blddNPeHmYm1/bom5WBID1B8YUjAccd5uTMp9i4cwsxNSllqMGxgq4rdK80qiX2rFrKIyOx57YBgiwg45hq7dd4ECPokGlIZ3cpenMN+K/jcN/nK2NODJbjJ4kalF/WCzZAyyZVIExYugTaYFUPqrxwQN60sdKy7BdQ2GDPN0TrSqj6zaZ9klAINX05SnGIivGDdfj2heZqC/9YQbzSdYstyoFzOUdl1xBxNUcYsIYWsVytz50dgpN0cYO5tBTSMDBU+RcajL4CMiXba85LPU6hIB4pEAypN1kANsazamEF7RC39wt2HerOQV6lc6VStqxePO5bgidPIx96KVA0x2heB41V3nsRFxH4Doio0oMPSIB8Whkde5FR+ncCnc8d9OUQ21jwJssrxERPeeqK9SYFhDwr7ZCub5Jb/Fnekdc0GWqfM44iQOtIa1kIUCMss9/HXZoYQMroZrkNwGTUn2xhktIqyudVjJj9jeyQlRTdnqr21NslOc8I18Mc5/iTN4JNQ4SMCA2ORtG+gmZ4rlVNzeke9D7jJheM2sbLwZpud8VfmogbhMA1ZP+XixXQkaIcmDqUDI89TmVfAVplmjVki0jGqYnEAwYwadiNp03PE2ONqy8MIOxVmbLdbVuRL0c8Xd6pDyBbrlZNAmlfQvbwtEh7jfi3KDdOlHIbCr3p4S0R+ii6DeKchm1JGZlK+B9VnEhfkki+JtvRU8sP0w6UnQnVTkhJZGkCHyEXNjp8IECRXFD/KD3c5RRXK6lOqBt8+4UjXDPeD9IjswQA4wZB1UVXXTsryUZxLAY1BGDFhPFU7Zya4COSsL4VlX/fBIdhgo8INrHOmMTCEiKFwlt6hgpwbMQm6Pf28+elbmu8VkqP4FD7na5871w6gMPlid/402sAaCgfDwvaeVM+/ig7k/l1O6IVErlrii4smTmxj95DpauNdByImfIdDIHVgoDbSzDh2uHf4GDv0J65ZOwla164ZGgIlpfLZrBfj8AdPWpPsYUaOrwtsMHpYa/IeW+mdkECOouY/8BibFBLkO9o4TiWEiIdpxNZgAvWrmA3YQymM7l5u7QCwO4kIXlfv7luct3jJRV/W8ndCNLUDSyjEMijUEXBUsQUGuS6aFEqXgLmJFr9zsMAMBu+KaULHhYCZGoS/EfEY7MZKDxKY4bKoUuSbPgpg0sFj0p7ZvG26bDcfblAUPIrpAQ6EAw5T4ZUOda2L6USXQrJ6s8RiKYaKOpUUViMQNtZ4qnZoS4DZw6uLHM7YjpdeCFrnmqehcndIFkBhZ3y3eSBbDmIGjak1G8fsZuwjYK6Om2G8YftFsvi6VICBypYZNNchXsheywjsdb7eUomXeD1s1WxYavfdbZ1wNU0YkV9yf8zmwwxu0bZ6K2YEClhX1Fv9Sq5xGPFaC9fd+sBfcXH3U8ldaFanAHdIEbqrdyLszq7GRB4YoY5Or9uZ6I8Jivoiv3tWLF0WMeU5fIjsWyD9VSCrWWKMHOuE6ZY4NKGO065ma3791LsclZFHQIFMoq25RnHbkzDe7eUxq2taYwNPtlRVHZlkGobHK/UQJApFso3L7KILTZKBjXvWAQrONtxszjiOKz0nbHawiTYVRgdOR9TgpLpJAXMpOle13EwcArgnHKGHaXHI2a1+aNJxmU/YR4B2trRUyMt2AwGnloUo8HdsS5Nrz6rMiC51HXwi8BBpcu4ZyM64YpNcB1V1TYbWEbE1B8iDvYw9t5BrJY1OFGcORswR9oaRzonhoXvgTCwhzYcN8YlBigBdjTPWAh01+H0tOSIDPKcbnsHSjPJzjj8BpoAKadkqHB5Xri++B7aBnqSdTm2e6ppE72rk7T8h7rusHYiJdD7neTicvKWBO/Alr5AfN/xvWwXgUfyZBOHifn3xno6NbdWsrpRUo0gfo9r2kDxtRRTLjF+vUgfFuq2v0rH+/q/1IkLN4j32RKEyRsZdJesUVJYSB10rD0cToNShUTnGQuLWeiXbulmHMWVZy6TRhCEpGUYHIHSdxrWEesiYtjZtxE/3/baAXn0hmE8CXcr8XttCXeX+5FvySJWAA6XW//+GDjBlFYGG2kAbDxIXJtYZliVXXRqUNs75ybEGikw5cZuEdIk0vbQJFFZYsiZ9YCnWJJq7WOI8ByJZB/JpIvqZV8lFO4NlYFN5V2Nt4oIs1jl8R2jK1bh1fGFABfvOMTRSQ5pEA86xCjEn3UsuMc8nkAjZ7aTFU79eEpPOmRs5I4UQ+TvYR10ZPwm6N/95kByOHxOm4t3f1qb60NjPuRZoaAb4igN1uEo+9ady3mnWq7Vdhr7UXMzFndg/SDG51QwY/Xi1ox1r4Af0mrCpfWISua7fQQNTc1tyzk0eQ9iStlWay9B5cLMXnigGBlQZFMXcFa6wLz9/Vsrqliy3fgfg2uozxZkfG05gwxk8vFYEi0bIph9r86pPII9OAeEkJFfOmC2azaRw3mm+8mfFYFs2V+fTFZwJ5iQJmQbI1RQXf7IQwo/ASuHOEMwDBc4EelPFZdnmklezA04fOC/3BEtk9NTq1QKt6gRWWRBJaMPC4lmAFhB3hKUaogacoOlDTllQNvOvY/RaJuBsN/1yVONpx/PdxJKM6Xnxrdf4uM1sChwrr2RkSvrmIxq+6dPb6Q9ViF5aq+tMqqajSLrAPDUlZXaCzAvGtPjBO4WUCtcVi/U8XOsJ1w9XLH96Tll4ShD8EnRlthDJPb6fCU9lKUMphid47KR3g72i4XTDka4ECQcJ8kQRj/TKcnzAtgV2V3Dk10PeTIdGoq/PKvJQpVQNWMtzFzjzEMnO3o+oU49nk+/OSg0oaF2CULtF3r4pBWxZZAetzpkNACsG+gjuhgjDcxyq2JWtcVAS3k7YefOOPXKoBox0gmfikZ1vLeEV26VH7uwBKR1OaA6LD+qpTvh5uDmsP4IP/JHKGO3qhlBqIG8P0MGXmyro5erQI51HroLD7JoGfL/G1jnOKQyOZ8sgu5Q2gCmwSnz6DVRU8H64uwMNHaNQGcrXJzCzKgZGeYvNUeArcuUR12PSe1J2OGFKcBvZunxIgbKkkkYX/tCdcZii2/G0da+p0FkLY68/ETfhJWvH1UWm58stj87ovezOQ/hY7y51MUxdxTCZKU7yPHfUOZk8sVgtHCoRdqHQJSs5CHTUUz6PV9gGDB3hR9RECyqEB8MQD1brnpoVmRD6xqNNLR+MXfclyKcdAQ9gKRZ/ULIDMnuF6wdF7hZG6fWOMucnyMfL693K1NNvMGJzxhStTog98cylgKWc8zLZfPuP9TEJAWM4W3NrEnHrxurdYY+cz5bIzUanK51jrDpVtkqJ55rmrjE3JjpptzQQUTwd3b+Cb8fPQK2XxyoMM+s/mdTlRbE9FIBFJaJbltQv7/+BpvbljhAJV/qP+TDAtkl5QAXX2SI5qoRHFvGWkc7VNuRQ6XK4OY2Y4pSpLcJBZtEvnFyCHktf1BDcywrdwmB3kWGl9tzUilFIZbbil1yMBS4P5Fml3GpoYM8CWnfrD4HITF9GRoi8s6X0ut+tymskuluAwZEASeBsJEXj1OrzR9bdpF1hI55juOPVFva9TvucyDH3okyf+8vpXNVZoPpT2a1IYZD6Rdqv8/Eal6CKo/U/N4twewRhgdfUhCfX7SVlWJCpKm4TY848VS7XUOXbLc7xvguPVIYXf32ulq5tpukXuyO8Ga2S5AdIUbY/uwNbeL9s0tMBseJezY/j4OkRzFnk70D3sT5fUL+QkSJAOTC6Of4kxv0AZ988OOg55vpMdAORGlwqSuAf8BSZH/dtE/VrqR2u7OvdYK3k+/4FFT+wR5kdtb+WXvG+lQbs8Q5cimc3J9Jy2f7j9D6V0vhRdgp7Ol6NaMuP2K6wv7gol7cDiWnm9I8scA5msAv74V/REaa92DWxrdEKFVbR4Uz1BC9V3Gr7CB+O80Si3dEcBWat+w4eo7DX0UlrWPvPwikTSYW2GF5d7lz8oHz7+EnjKDx+kZrWf4Ol4VEJuiTNeEM2EsO03Yo5to0/hbNN07dAMLxIDW49K8cSaV69h0toCTnsxMOczxRW+kvRFSag4jkT8tsNxmV++go+7bEehlNCrO3xNW5wBjrfYmTSXbGa8OmMnP+bZLgMj/IDtvSrEvKVnV7NDoFS+3iihBj/ijfkHPxZk+F1Tckq0CoMoZ0ql6rR/V6lwA4Br1+JHWhLjTAQmEyBPA5Gmr/8O36mZCWBu5jL3Hqp94GwcJ9xloJw7gfc2ILuqYLmmWY+kteLDGCTseaalkLz06xhuEfOqTi6K0g/PyQn5X+A7+bhPZQvWVj3qhNwi3DxKVTp02c0SMA5SYXnnpTC1X2PZ/0NOoGcd+irYwuamo0+e0Sd+0SpdDzOO1Fc+SCCgtxtk/kZeibhvH+Okfw1yEU46Jzfc05SOGiPOsl9eiSLhuMx5zkp1hWD5Q/a/MuD07fwerfwtANgiqRJ+DqYYDcB3t6iyLaU7pqMOGj1tOcPcIEG4aFo89qphe3AYShS0NpzZ/itught9qtXBqf7plnPPOy49xRpy/vb/srwXMsOygaPR4uMp3tQkNSF2PV9V2x/i4ICA5HovRWDqu5luUe22l6MVFsuZzSgjv4CObuQqHeT+nKeMmGdY0qu/1R0rcjPUnV4NcUKUwl84tl72HLxrNP6glMFXwNe9berqjogrJVT2bqqc/HSQr2gln/d1mvkgDM0MqpFa15c/bvSC9XYdHaOYbdHnNKkyHnxXmgnLd0QW7I2LPKEDyBOCZJLH/XCjKz0u+BT1cPx8cqD565Ko+lSquGR/1CUDEqv9M0eM05LOgmOV0KLs9o+WFf+mqgXguCUrXAXBk72rGB+KdNRwT9xZ2NOtT4vLljxwHlhc3hkQMps2fulABYqHC5kA2lavekVE2p1eqNIUO1Vujn7RaCr8jcB4iYRei83h1InyFZEg7qyRSubWGiaPZwNpacFrYjJvts+Kj1lXyF8O6SzW104m/7gS15RCSf886qrgN9Dz+VE3FCv9PGUjQqwRNrIYSa7o50n5qJeNqmC1hmsliuMeph06Gz3QPpBUOIrwPrJwo2lGkZ3x2oJRJTqjFWvQGbZYK3ZfEI8xUB1Yi0ZqCyT6qjUpJzvBnZogIexjApOQ5I8nyl/jZiMNNtuwTsucpC1uMdJiEM6Pl1EwmU25jbIYkpdXlzcyAEvVeQm+rFWtJ1qoXNys622x14jdQnQs+j9E23vm581W3HQ7Tf5VDRkzZ2nTpCMXHqmOlTEIDUWhzOFH8z6cOqtGINg6voRKbwZfjE4cBs8gmKkthppG/0MJsLhfa7xftYhJqAM13L8EEP0E3SLbU84WFJIEHhg5FNAp5RnJkwTDN3qAC12Lxt7NkEp4K3Elb1GYHLassmmC/IAVbKVFyaTWydkvlDaLL6RzD/M8NxlYp6Yh5HVRoy1jpwkOSxRXI/uHxITlArxiS9LdS8wEWpHFs2PFehVi/pvCrUvw88vzbJQnLFvxNSVetQHFcqnV1kZ9C8+KPgvEQ00rNkxvSOB4xNeYnfcpPU/ZT5l7Pe9Fv/sHNAgBxZxPAuUKBRt3+GLGGd2M/Un3mr9CU2Oc4bWx3keErtfrVnVJZRmK6ZkN9FHRZmGfGVmlzACrYIL3kaGJKgy5W5tR0vqs2659Eo8IXQ+bE+mHxz9NjP1EyDqisQ2ohZCNeOEIbEXSV0XBFddGD/5cy53P3wrKIvBIY6l2YC3tw+LEvHrO3G3YwEYmDlLtD1WDxSgRAq+LaRFcMGY8SamW4WgLDAuOXYsIIbta8QiBdqpaL2+Rkqa504HtCC/oWRewQgHcpFQqhLf7zSjUP58IVtGwxnizMrQnW0AV7e5eyuMOVKNPBSuzjY/cUZBKm3laToOSb3I9Lg4YHCFwWMG95PBa6tIpGXekQNPIjIBEJdMwC2IgolN5EjCJshCoAt0Me4HFeHE1t1ciJRinXXYgyAnxhScJqqJU3llO3LIxHTJ5CQWzaLY59dtAgWgWqXb7jjazF3y6boeBkhk1CKdFJSDaC0H5N7Z6NTeetiMCcVbcf7dyt3aQy4jH7uOzG9A3LxaG7Ucx+Q2tauB10sjvS9B3UE5aIRAr5Wi0mbTRgX6bgcnIy8OCuLG38csTJFU3ZTkEvAPHSaLelkbLR8LdiHRbkoZAbwOH66VAiSNUl9BpBTDJEgw8kUOE/IQEwswZkWoigu0AcrRYyBIQMBlcagyHX1/Y1SWYzLt/ry95r/ffTHqkFcK7JUg1n5MioNsEh5XcFeI3g6G7QUamjPySx3sfUmp5fF/ilY9AYQayUseh0hcgCaviqjdrWCeT5oyfpPAitymztn7Nmxlr/yrn9qxWRKGZcLyQTveK/NX4ifpr45I4QmUXAIptMzE5QMzEqOCfFY9UkOxEnaTjmJAwmCg08q2I9QsUl0MY4VRrAuEatnW4idZMVPk+JXqZxxvOWAx5olySmbeSCxhEeR1vQHxLM1JhWimPPSs1CcRHANgIm+oTnUDCf3SpIaVy3AQ/t2PXAAYoC0UuAAw4nY1GCyok1AR1IG2ChITBwXATkKhAQWR8GBs4EbSKixnN26gpv+6NJD89GnbmKnmJFInWuSAdxLh+mZTqj7DccZjDqAnVypo5PfJQPAAiImbHkiVYWZYELuF86UfP7GExP+o1W7kqxN6N6BIwtbSZY9dMRrlsVPoCNzzkDGgw2QfqCyYRjKYFRHjhOCKX3t+oi/xjFCQPVCa9eFo86QKwCUUqu5+PtSIrnCKh99w3Ri0IIoc8kk+TXH8OKd1Cw0SyqVOYNKfTBNjllS+jXfTTO6EyRW8qcjhAR0I3brEYyGljUggR5aUHmwAkWZuZGPEPKyooJqvDMsUghZFS2zw/qitEFNIVHEvSatsTW3xeD61MUiguqNKVkgJW6QLC5YqxwUnDxkmZB6ptiEVPvXHssEAmTGGYh9S1K5p+10BM2m0wXhN+DzF4wTaRsb+JprRGV1/WJzQ3ovR3R8QdvgAg8eTmiOHYK7fDz1EPq5lYNLy6X+OI5PuJ/CToL+Z/ni40A6VaQWjl9oppI8yyXLzxycQ3zu7gcWINENYkcXKJOgMnCfyrYb3KCdMjiaArPM45HMXCKy9EQOjgOwTBslmxc2MJk1cGE+abAilPjlmnjdO8ojJpJULg3saYCOGcU5Z2r8FI6hccKejDaysQQIYhQQHVV8XIgfrk/Lh+rohCfbvP0SYWnwvKFgGKKpeLMLmqbBKoive6g4NlYCQNcGqrFx6N5CMcGpYjDWyYoBQD5xZFkRR4abj1ouJFPSMjrnDEQglxdk9YenUqz8VIWY1qPK5qe4CzyoLFdVvbei63zNkPfRaZuymjGUJLL+vRCzI2g44gtuLSS2+ruverEJxkQ7aNy2iC78FD1FdymlHQlpLBt1KdSSQKg6sEs39wy5ipFfIjMicJ43DRWJxm7msg9bjrJOJZLX2hezDL2KkV8gMyOyzSlFr3wSjPKplJLmyjwTz4CZfGu0cobpB0FP9Z35+2kSn277ncwbSqrXyAtYYog42kNcggc/4TcLgxE1YugNNx1LrPVX5rtV7P1TtboAQJjomi7FKrIwUl6wO7JHhvEhOucekl9NWRCGwRLJzq3pi2RKNa9wqCTxScnsjcJAa4o3AQWqInw4utygOfO5gBA5SQ7wROEgN8TOEE5KQSLWRfLB+vatK6Pg7aZ4G+IwexbE7ifphKaIbSKtzJDRZSPc8QENUP3tOfqTS5lZJxqjylPkC8B44ONcKH2aJ1vBwi0DESJ+QJd6tbkpP5xPiNHP5BFq7HIEMWVv7QvbhF4GIkT4hi31W1xqWyY29kmwwrUrAxHWVabUxY6e9zUxSBeZ/GdCvj9o9kqn+l+MvwDiavyY8qVPfqY780892Ilc99bb8ZhRH4aTqViMuJf/Gxh9g/xzAEtl6LAEWKL9R57Qo01KhAomXrJOLyC3U0zT3r7IaiOPtmtevp5/F9UJjDxI3JiTOE4+jWOSD0iSSofdOKI3BKRHYq8vjj+KJ2lTe4ghNTR3ISzGacM1ooONHsl4ufevKs8cUinyalEu7zkqtbDLLuADXr/1hOdeZnwgZ+KGYm93kpandU+p9IeIlCsLGi5426lZzKPw9Z8OQmuL+zWikUyFjsNmoVzP3/AXYqqitn+9qYASrlSA1U7BjrrqTDBpbSBIJkKejlNZQM1u+cvpa76NSGdiMpfwopeLfvTJChdmwdhyHKpLvj8vuuC9l/gUJKKipQUgoJng2EoBc06Udr7RYBrJPRcFA9mlXnbXaobHbNzewAi6EzJCzGtc6Tbkfpkpo/fM6ex0BrR2ifEcRmr5FU6dZxmMAqvd6jS39BomScnIHu2fXrFQJrAglScmbCHyz6CYtSMr7m6HQ8wWn+ibBXH0y+YOXbVJeUGd+iWeY2G6rQa1EuiOzuZdTpApdHpJHBCOevtiSCcJMPtr8IeHJXs6gd+qdUFw7vVZN71YXjhL4XCJD/IFdfay5Ok8rpgON/RtLkP5P0BRg+c/9MkAB8oC6UQK4f8R19vbMwgGl4pdrdG+uL0RTg5F1UVlhgJVpTTjkFkyydebG750BUfhvTmsSkbVeMwJMjgbBaMYe4hDfkZFBtsI4m6Vv/7Jd21IhIhxmZrQ/vAjAgnKSZF1qPBXeYmOyq8BpWAyLK6UgDDh7CGGdFG0ROlY55oBoDMlXK5EIQUxpOjirGK5Im4eVEiyO48+CWFE3NZMLeY/t16vOqpgY8erTKpjrL4rItIQTPaZjxZhulj+91FdlRvdCgq1WwnLLTFxcHRWviTKbgut2NElAnmQob70inH1pR+DGlWMEPcggXLdLWUvww9VP0IqLPRAzPB72pGvoAxTBTZ3dC9Lw6spapPvt5BZ6EAlU+amXTDMUGFSv4HoqmMgY/GCR5mnEvS/TkBplPrCThpmjQlVGVG3jaGCHyWIuI2t+Y8FcHp229x1JYvvnaBWYKkIEi1Fi5dAIDaoU5gZGTpsWtW+ZwNAQsFfRC10YASwmm7j65MzXnQ+VWkK8HfWC4G1B1rYP7cVkq3/1Ujkd+Hi5MKRs+e+2R7E32vH9I0WcGMZbzDjgBDPz4eVsIlzSlSS69cIWbh1khGQRy+KabdVa4BNy22oII+WRwW8+R/DTUW13xIyxj1wHgp1zD8x2sGND6vO1zVNUg6PWu98hyjMEmRZDnF6StsPe3tQzW8WdTBeThfjG8X7Lo7lCegV4t2rqYWOiBOHSP0gPD0iGq8g6A3oF+LmWW9E5xK3XtKZZO15Cfssm8fH5LwhCqLUidwMCODWuA94Bup7x3Bf4WAgsv9oi+CDFDUTFbKcNwk5WxSMcNpbic/aYJfU/Jp4OWvFOcdz5ivF1rB8K2HZCNpamekmK1jxTOLQl/zsapIwBrEi/47J1+R4EwU7+928ztiLTJDC0a4lUPaKseztrMXLNUIXpwda31Bd2Q3t2otFaBl6Ewg9vV1rRgc9yBanGaAvaIrbweE/xBhR/VmkutR9mvlU7xFBWTAGzx1JOdm0veeLA0lXKF49Rzb1Mq/MKFylmF6VCtDQvfidrtLnjlhDPvtXFeiGtvMjXD2o2w8RUb7lYIyRONtaLS+d/Jbaa2eszd+UEluoap+8/UnyWW3ytbLq4sbE1VUAwxnr3bt8OORbffI2XzcUUtmH+Z8dLSatJLChvboJ9zVbhVSSIUErXXzwnUFc5BJYbdeuy+wjzidnafKMXZ9KOsB13MHqhb2eOEisGz9zZ0uv6JIEuzhUojgPJDFr0GpevnJd2EWry3Sa1k+xdM/bc2oMkjdyGKV5kp7vCF7ntHU1Ul5HnVs1G0TmlMS9um6dFYhBp91DhINK4yP8/bws1r1tGqLdEUviYgSHxcHsCtsuEU+718kr3c+sXHjUHm5eHXxuZpprEsJMDdelPHoHZtCafqJkrCEWQ9mfXpB4SboMAzSr56t3ZpSz+S8AMTlNzi5XzV32l7JAII67Qu/kED+RfGYBA/xW5fYDpFZ5riKC90o4BpgFvbJq4qwfVXDRdMTJsT+C+XJalYxrOyzsICQmVZnir0XygIiTuggvJF2M6CmeAX9SNecjEzXRJC5JexeBqqDMcRIEJxKGkllRTRaR4t7/sBdLiD0COVRiI3Al5IIk9YPQivXVkDTJOlc70x/P9NEHvP8WOVj4T9mPPvh0A7AFjn5+lMjCGxSHhCzRp5+QQbLZWsEcQz8hZMP5qaaFcDmP0L9jo//4qWO+kjW0kbI5JxfWSJ+mZEf7M/b5+G5xHxGQwvg+yojeM5GAh2FMxlqgriVVzwvjhYK+wW5EA2TJ9F/+tumAaUWClSdIIn7R8koNt6gCwqVb47QjaEQKsuDV2NqBkrQc6KLgRsCdgOegfDE/e5IyGUWAPVtkrc7iJa/9KAb2NPVhGVQt1U4QRFUyQ5rt3VMr8z1wd2eM0wk7TI7JAQdchGtjbKgOWgNMJzmde8VTqLBjNhvpbWbeAaMSoi5exb/Ti/LhI9+Or1gIp3eMb8bpiUpE3sgMFXoXNXG9NDL3CVI4MZx86E8hYXMVOuFRmlLmZ7+zurGvMABhsCglJluASkR1dj/cDi4a9QEcJ03O9/APODXu8dSOL2XAqlXoA0TaAfJgrbViR5KtARwNNzXwbcOv/pVkdgt5Ln8ikm2t99JMKcr/oWEEZ7ChrYjTe1ZE26oYlK80rRuJTt0LvOlgKVKSqbZiqzwKOmbK2cnYlWRMLWxbc+z6o8/UsKEEbVeLyPg6sr+sL8pQr7iYmh2bsGpEnXGNGRyo1AtDfh8fb0l5OznKh7FgWIALHToKn41XoJ6MKOltg8HuCh5HFF1tubmt9P0GFekHUiPi4lgoCwkLoQOY3mgWcO8CuTuMZO2OKEoWQWiqFOWuYac+tcuToJqTMO9WRGB2uUjxx6waMPGHIgWaxbOFfBdi7CsUBwHZ8f6bujx82Zwi2iUzMw8HE8BVSEOyQwU7j+cFK8PW0GIWYlGNe0P7UjcRuMXVjTdv918zWSSHGfilRyzTqDfszAKPEEciC5mCyWNXnpRFxnvfqB0qrfsAOJFYzMg0tX8VdET3V1TANCYume01kgbd5Ex1SIqqxp0HPvIymtfSiogAX7PX7wIxBZmCoQS0Bv612ppYFECmLb+RhNeCzDGNeiF599x7QynoY+qDKgyaQan5JMAcjQVcucXmBgkdl4L8yKmABzdiITQHITCmKQk0JOyZkcDJIVxgJZlcAPH8soFC7eJ62JcF7Ksmy1ffjQsyXHChlnRS2H2oZskBKygLYF3PtMKsqjVgmjMDCUUsbKwCoXyb6bQ76vJ0qmLLzzZMMzTrwYncgLxrETK3LRab59DGy+GMBj/cjlxUZgcHD62GDZyTkYnq6F04if8Y4ojZE2msw4t21wfUdkCjdb03aAspXMzQX3wObSbe5WVoD166gaUZsvMfKdubOGzLIeXOVwEwxaBaojYElAO1Zmk4GjrSKxM5kGfLvnMNW39abUCMCY9sMXQsGxh7oJ9Ogd7Wnb+BF10bn74T4QH3NhnFpdagVBLvMEm2HylzXlOeGGC2WeLpf63p+MIr+ipQJeHt43UnpKJBjWwMPNzItD2kNzQM/gOv1CM0IAXPCnouDktt9FeKaZgAlK40rmAyE4/KGlQK2S9C9hQvxMkPCGwBRgq7/UKHIkI9+lgkE4wdSDIzDTNdpFdlMtd6bFIT8xqZdBpqxLJr/IQW12hIzCTrTqt9emnculkpNTgBLrhpdXbvWKErBgTjb5xgJhQaN4CchGzUHUfzkDoOOm9IhwK6BMY8GDISG78JyMJch2qYrGg9Uj3g7DFCUE99iHlDRWeUGEnw+ZnhG1HWnYh3HTuHzj9D4mTkoqN34Ds1phoiZ/wocDmSVlj7YUw5Veej7fE1vT7rXfljV9cU1j+MZIfkFXvcRdE3JWAZLf15xK75qQru7F98HHoXv/PutG9g1sTvYt1BE8k7XFI/37Ms2jdzL4/eQLnfqx/vhmppDm4LO0J7gnY+8hSJVudgb3DJA8F6i34Xo3O2oQ82CNaneQm5CEzvEn0x3Pb/81TJMPQJpZGxi0eOXmP0JoGLPKWKzkwV8jzKWkCCqeCbz8mIyBAeN/WRBT4FoXAph4AxcQG+8DPohqZO2lVYMtUGndHf5ns7nSu/aXdDe80ungOLb570ClAoXPuy7xGjNtk4btYS5k+mrI9T4RDiA0J7+yx7ojPJhsiZGGVmlCTOA3xtGLYwuwI9nHoXKT01OfUslOI1zdu8PclqNxIXg4MJwHXHxMMHpRC1tDCSkkqZsD0YFmny65tfeUA1aF8G0Mm1SFsIattH6oYEULCHu4rUcOREFnV/AwPKNZmQlmM7auxmhOwVnaWhXJZ6d76gFdYJZsUeVNSrWurWsEI+25VqgOjslLsFrbvesePwdJqR/SAL5ZfqDYCTeejpX5YyhSTCeNSo2mQkUnE4GU2AGwy0Ybr+zFKtwoNjv13SDM8HImSsu8GgQmLZOJ1yKm1yz17bqaanZ4bd36azrkqRtYJSDHz55Olp5vA3o/VzUJFPsnNwGRY2uIF69LkqDxheqMJJzxYo5ycsgWiqd89m4uBlIpwp3zYFUc6gDWsbVCFrtkCk3Jl8rsDU8bFcOPGEWoyJubFop3HE7VD/HxAesGswmy1xT6xAoMk1LbGXLZWxlZFA059v6CweXxCDoDFn+6TwUD+gqfbzmuAOuXSfomvdibaRkIYTOsORMiaKpl2GhzhLCdvzfG1vFFOJxu6Npmu2YytgKPGSY701VhcH93Ue4EyzudoDt4UhQxYHMQPoLzgZEmUMl+EYQng3gnLEVRgeSCYJRp4yFAZHgdWhJUX5tEzQLwSJVDAKX9eqwCTtDknPr+V5ZCtQDoae9t5Yf2hm6lsSFTl5ygow0xwvWYYvluWH4oDnttUVVlKENSluw+Ac1YjOdyQFvcdxfoK848xO0BW0bjZvBikHIgqgPuZaiA4cbMssqNDSiwoyi1lR3L7PGCDjjMIFSEUdFobdoYX50hA9q2oDU8HLdjA1+XRaewRyE4FEG5BROvzVHRzjbnKCApECirjqQ8Wy/nLjcUpLEcz4xum57WmKF0qqPOtgfWmeAmwX91vim1+7J4/Pqdl6w/48JsXSdOSnGt4WlPvhXCd7OSCmRo8dkJVB8srIfl2as1svVrGlGFi8hq20oeDtNYhokIbNwWkWmwafFORwJ54zjUSdEKUhmQJJ2eU4m5K4hUX1qHgSFmR/WPkBzjnnkQjc6bH6gMuhTNw+WQWXjgGpllOjw6AsBqarLcmpaX+r7RWR7dYtgRbMn4A41SMpiWJABAeXQmBEtNZ7HADGmcOL7NSOjL5KEn/YVvPbmYYWHxkyJo8QGkoDcpBzUzsEDkhbr0qoTxhyoJQodCVRxErJvhiJv+mYCAADCeHvdDpQCYqPpKK6vj9spLOuA2wM0MwJ5peAIdBvrAnSuNe2oHk5ofZJ10ITX0rjFB4oOIRHkvKdSOOseYsXoUyMW9lqvIFN/BSdxPAQv9hmnTKBeJN27ycD69iYNe2qgupZ91TzRcYBa64sTzgOTgvZlYLYrrjhFNgXwV80H8dpGf0xRspWcYyIiBYvsIOYKPIC0rNxE8s83EI8FC5N2HunndR6pPugv8puipqssM/qt1/9I1Q1c3LYBatapLm2L36Rh57ziCzKYBglv+1tSotBxKeh/Y2cDREqxKTqemz867pArHfF1PIPfOv/eRP148n4c35ivzvUQPp3a50IKCG1PIzFVBrYvDOu5AJ72JKGaURiVKF+ht9uCclMw5SGpTzwjmlKySdhOQCi2+EduFHgIoyzvS06ZktgzsWNtEbBEk2BoVBpcV1FOfncUs5Wmfd0jVsrKaRnQilRbpr0Zkqpfz6wK7JLZIXpUCCv7smuGhXNb89aoHCWdXTvjhynNd2rADjkWcup8E2Ouum85WycP4t8MP8rZYTwtJ+vLk3BZznel7udydixdOd/MLw/iJx0vq5n9MdCUuO3zMqzbw3520kR0Iv16JyJMxEgvhB8wNc4QofRiuv8Hq40zglD+q0wValSvyquDWkbHoQ3UXyXqrFTdonoovs4pE3WqGYIP1Uiy6+H8cb/oP1SoMqnFql6xq2t90ZaSr9gw4T3PsiUuO2Q9dA2MygMeXggW7zwTj3Yy2jaiT/rlNJUpObcufyZe5iqtiwiU3VtVhYmbSVYgUQrrhUDgDfhB2nqFTDvm3zp4/P3KsFsVeEZU3ITOU05BWm2IwPwgaEdNdlDFoHpQrUYwI2A4fhs8atW/ndGczN2gXOgqUBrJ/4qyNWmuoo3CRW97VcRyhRd55yykCTF26r9f7DgJvtJVywA/EzvUR3H3qtHV5jHQQsDcmmKoPWqxA4H5ThVDGuqFuE/KQoJDYA2zoobCI10tuZ7ahTpweuxBStFGBclFb3UBdeVpO8+mtITh+MoECdF1jl2CHKyCbu+A2wi7nfl5Y80w/+3E41EkF+JBNIeSGhNDk2UQun1cAd8z5ZdAf8DEG4/HnQOFhoAfAUYKFaUqz2Ft6Uer7rXS8mr54vD0phtgGWnUy+GkNqcJ7DSAvh34djGgiyscOOWU+Aljdq4cFBssz6aHHK5SBchqIRlkwHzLqZWgGyEbQLwynS+m0CRdDjQpcXtM8riLZ3tQXfcowlmSkH71UvDzZOJDmJPnFa6fjBTQV6x1O4QuV00uJ17MT+8qcPtcHYk5dwESNRN8f4mdQF3zj5i5dUXD+ZI0szqx0yN496T1zDZNsYBLKb1sieEgX0S1kebwY1cMbiblI3M21tS00fKcZq33raYcXAYL7Z+ATDjS4FSkQnk8pncOMo+ZLzG5GYML7qhnOcaxB9wcRBvDwtxNGSwRfaoMcjJnEimT7Le07cmfJGD1u3c9uucUaHN4xDAB8ggo+TvOWKI5JEtwqX0nAw3eHE/W2VtHv7VwL8rHLnYJZialTUsvm5F4foxq9P2irJUwETmdC6CPwEldjr5vXP3BvAm8siPnm5lvqNB3MwU5qAK6smNrCtEBxo5axxjOjjVZSZthfTAjwCX40exAaXg8yGxWqQxjEHSnnMTy+iqH1uT9RQXkot3Et2FaSDlme7yukq9lknNctLOCbRRW1Ape5mcpokObT8YrCzMBZa0AxQzaMm0TqJI1TGTT5nmyeJv3X2ONe4PvOmOJCfTQx+mzOZe+4NE2SZorrbEHlb0kNm4R/sf4LW55MtBYkfRXz16JS89dniSWnlWRbFf627Uw3kIYgtMqgUoneE3X9QlAFUiqjgmiAkq0OBrMrWgrgkQ4Lwetnk+p64dEWlMzsy9LPH9eTCRMrH+kv/gpP3Avq1jcFfFOABrYt/fCP4jz6XGfgNJo6DigmQEpBklHLo16xkNHyKUqeumbe26KYhE0wa1y6rdjHQSeDr5I3L+YmoJA7VsDx+ymye5fH4bXXt35snTOTWKPSgerKZ7OABJ5MvypxAKF2tYvAVhuWOqdnDtUFF2PuuYWO8vPDMSvq+gcmNXNR9tvEHmCGmejk1f3ei+4w+InV7gJyauhYiMNFiTvhxaD10nJ93yMRzyj5C0LQYu5dbIlfaTbweEn7JX+lmHd5Z2/clRFtmA2M7y+YyIc5puRPQnH3xXRqJcfJqsA523XjVVTCZBKRZtQSiNgxypp9jBg58jmSlKIKDusfP2W7hIDFc9qa43+zZFqTanicRaXTvJ4tjrM5fXO3RdU3K1aEQHdsW27YPfW+w0tsHjkSu1AFDb9JYJx5ldOgu7dRKdwgx+Jk4hwiesuQkW9PtzE1ouvBacDQphZiLOh4ZCvorMftaeBd+bxAMtELus3Vjx/+L7Md2kbQdeRLhJpEDgElU9xJyooD3TOcstkmXrR5Q8s5u6twnsRCxeb4QOro56GSxFkQtxBXiihvoJpH+Vq/gSUM3IT2IX+ZNycsd4wTY8iwCX0sEBxuKUsda4doAZCkYlJVrfeKhr1VuIJlxrGx2YM7NH2fFsHLs7t3jeYWR0S4k2BLxG0B7BLBwNvZyasLZ+69GuCk+AODZcJ9E1G5qvY2/ozSghIg1Pr9ba1e+CBsGP2X98jlMDigcmfGlVlyJ0Vq4I0fJ9RNq0x6woDUCqFOnz6UUbJ5OUSYVjmFuTDqDrCxdairq6k3rc1sSSH64qqgwElpZgYr/VmZWpzZrZHeqHPnSWSb33PQtBvKHA/HNpr2IjhoqiDjM4Kl7kChgwB4TcWh4uT8khcOstilc915IJMseCn1xzrUFG6QFksM3BCO2Ue1TrDSB4jkxmogmXb2s0SA51L1t35UsWeXuEzjbArR4Z1zCVirjKx+YCHmzETEVkJsAA15/hK9f8Qugyc6qV+U5rDNWeeG9FODdgtffPqW4G6DMuLa3ThXmHzTLFi4rHi73VuF+KgKPaKaProtZGhWXergRnCgZILlsWgH6RimlQeGmdvx6pGIpHT8vrsmkk3QPcXX2lG5cWliw/O8cUdvi7Lf8CgsFGmTUhuICxPDYR2RqRi5BF1PPCpMmnk3Ts6jjma9KAnmFCZpt+qjWZxVbY7OiopOgO1tgVMVr0LQsvDedW+aQY1ep0vebjcIGcaHJz7xkTk8JQpmPQKQfWhSwp6KVW9hBef11Kbf+T51PtSLyYS1KEYaJLOdl89Gfas7y6/IUBEX6PQqhJE5oxDGs+2zZdD2RtWWZvX4aOx69ljzR/hZqvLQu51E1CRI6vtpz6eK76pWrYVYtdkAkY5e6vRsD2+XmhF/XVRdtKMhwQhNvMSzYWXOWhjYtTKY7Yu1cKa1fdKj/heV2iwKBzkn1Mmys7mABmqOk4RHISmtRXNc29RVcQeSmeVtf+CzRNF6XBsmaZjo01nZYCk8YHH7QnTXGFjq68V6lqJqEUJLGiDcrM6ymWErZ/32tlZwfOGlsn6JdshwWGCuprQAJ3qDAVL+VTc8St40EibBk/r5XJibWDwgPaRY4wmU5JGVO7S+0HIoQhsc8BCfADmZEoseR91dTXMdUThYCtBzswl9KOrFtYeNDtHz3rvLnmuwTMppqqFtQfNztGzL1COF2w7R4P4iKm/UkD/FejpW2WYRc4LY0HiWniSMuDoYYTPeHiXAp7KJpCqP/CNyFZqU3r6X9DZgdPg5S/WFsNnoSTfKoBPXgSVR6n+jm55PjYxWjsPZplzDSJK6g6EwoldOcmYrgqlpSQcwCPiqPcPnB6Kw59FVcy9AzsrDYSX+19dVCJL3gEOYXTQCvJu6fcaJLxNOOJwfoT3b0YBdSNNy4ZOKr9FU16v3xlWI0AZrqTsqAIs8Ts7AzCqqE8X+0yGnj8Vg7VIrwSoKHCyV2NyZH90TbzBLprvA+G289CKtex0O1fpEzm+gchwVnsDhBZgPg0LTTnoMWj0W3Q7W0RVlMDDqVksFFencuTjFd1WTHHnSE3fyZ6b3JSRM2NN9w3mtqmwBB7wkWTeYWlj1TWwHG9Ol9fOt/XvJIGPoL7x1k4zuNCdTEcs9YMr57aR8VwdNgrU3qaMxU8DA0RmZ+pWf4kim60GiQSaEyONlk8jrkEx3vkHHv1YIDvExld/4dvStrqjFV3nI45DK8xoPKasRBU2q3IjyQY9ZuI47JuOPwJRRNQiZ/X4fDNePoqFr1Q91Ik0SCRlL6GjKxJgEghC/rmdBsm8LNv0ASCsLjHiWU0VZ8ZBVNjXMRfHDNpwEKYaovVj6JqIbXDIg5svPIShNQ4ffPavfAqmWMFbIZh2zTHPqT5lREE1gZICafO5kWx29wu3idADCCCvBX0Heb29ztMULB9E9GjRzBZjahjfgnUqvFDAOd2Tgvm81h73aVQTkYWgr344RPAjB8BYCUrBJATXDTazFoGpDaI2DTcdZvx+egc2ZRNKyUaYPzmjn08M/J/z6RcTpEDhODr/dWLke6f0DxNz/iGn4J0dP2TqAfv6R1A6Rb0Q6O4AFv2IhgpWMop76UBBF4c+uu42g28862VjzdPPHp/DVt8sDarKnFaJO9k0jPB0h3RSgB7B7F7jUGm/H5Fdmvi6sFeCyCWH7x7CMMPc3djotHWhQgZFc9RC8j0fi8OJ+Xv0KdMYLwgL4lhZsVvcbiwPJgCS6G1RNKJvBGSnz3pMt85ar/hU0yS5CF7qNyrvcIQ/WbkV3bp5qSc/tzg8+qms97uWAtbnorHIVBJMDMwrvSW7CyCunxy6XClZBnSnrdg62ICyOngMuvHvVsOqp9j21lFqJvjaw/ruL3xJRHD0oR9/mWeCWitclxFlPAHl3vZnKCW8SWPF28xynvOlxVpdQc8eotZAm1RhHhS3tQYgcaGA2WjMsgQlYAN8ixSJ6RIs3R6DpY7zdAnm+Mlsbx7hPyYc/GaZ9Yt9sMrc7KXyDN4/jCkrshFV+P5eJ01piWeHR2yCFqU//ndw/sbu65lrR0VsJaGYiAk0AR6RXdchoS2bW7Z+ge6oJ9XeMmPoFZfiOqmlZDcDLpDgrYlPOGLzQbQQy++E6O6ozcNDcQXJscf6OD5+VRx+vARPvBiDC4lLsYgJzaueu1sVK0TB6AN+k/HoQyLhMTFOyBUaHviJE2Aw7Rsy5lyYfHif2Pd5UCjjoqYeq6XX5X7RhTP29T3DRtAqQ+uj+AOkSKuzj4W1Lb9/rQwJsgXmUoWT3/Tkc2WCMlHtOSVS/638FaUo34RqIZkkM0z0gipKmTF6jluRNoHnfgK+FaetOzvGRX4kZTNyHVj9QCDTmO1ZAm65pJhZkARMCHiGq/wtZjosjek+V/097IRt373LGZJfvjhoCaPfGp+s2kh+XVhxmll/4fCK0R3DK1G3ZtkKjM+k3H5eCeBRjUfx4NE21Xdd4zOICfE/PWtquqDjT2eRqMJMpc+dNoUksL6GCWaCXZDiMt38myACPslenMvYJDgQ0stpzTxHUVnIEMTEgSNDKrkLA3oFmIdYAlmxy8x6zmbxOgqw9L8glAZBHn+QWYYD0fhH7pisnqiG+Wg9xkI8os+QFN5a0TUfw0qS6tAQbgaCCQWtPmcmWaK4ZbTzjlmoJSOWTibSBLqa4GK3nUHlj6lKDimEc9gkygfZaac9L6FuXr64tZpt3ysh5oW3P8IH+dEa3SyVM2FvO+k81atscLQGUVuEEV9y1N0i8Ym+NbnkwLVYN8mQHRjj/btVL1xIvfs7dfIIp//dJX7r9eI9clVYM/eOxYyzhXl4QK9PBu1KDaxfrNioXFZYBV1wRTi99c//o+HIwcFjS6DTSrLrCzJHXDdvgllwjc7QztxordcF/glb/sI5Pv/zrOjLXiscGogIRLIxY40z1J9GZBmwmB4Zi9WprlJxQfQSBIHt/eBGHvNxletaiuN0x+iBWptJU4JW3lN+KeCHw875UaBxD4V2thch+N1BMBTo/aMZORyI2jJsC2lSz1Rge/OwQ+jyB5b7AeHXAyuvZdJgTVl+ytrM4jFFSsA1Ssu2EmktX7rPH5MQoTch+lGotOjkH9HMfdwDSF84M4ggl9oL8IGVkwXWPRIPbs6lEXyhJ5JiQta2XQbQxSnjMQFJGk8BO6bnFHmOBmOJ7i8TJIwL7AS66tZ4JRFGwTMlnezD/v3lt8470pKJL20vsJ+YsEKKxoCGlfSJ9Bb2KoQ6JO6RIZTpbd6EVI3jIyVkd1z/3giVQDMKl8F8upPe7DfBPSE7xHUrTwomKf23bwcdj1Peuc/6RSMbeIr+15o02GssujD+NKfIZ0mAQQbcKXuDn+BFwIZtVeiifMQEk1N6+Iiv8C9ITdpu/qnlK/yFnfxWmuVMzm2VrvJrsOQyWgTNEBGPMdeoxQfFeBgDeykccMKk973Q1SDBfUrNC3pBNmzxz/4BRgX61x/NonOTthCTuz5p/zO6y+UQ+O3cVnHS0mOmzm9CsXncMSzF5otPsmIoGcZ60qypMQGhAjD0Pj29lwreP0bl2qNjwNsTQxi1LYk2inKQjkF/jPZJCwHdTf69f9hJorSdV/Fapl4S+6fTk47O4OvyCZ+pUtXQsHoMf+U3X64YQixKgwT1NIp3ZVIsebVrH4qBKIsg5XkypDX4xBrxR7Kju7jt2nX3VSxQUodxe72tb6V6EJhmxdsFT+3mgG8nazJv6/igvQq0FRdm1x8F8NI75mfWbGmoFhZR1VvNDPRNPJD7skMDTA2o57ap3PN9cWlh91/PZ4bZp76fH88pPhZu0yyG7I/E3wHbuplSEwDul+iicR7EzH0bJpf69LZ632fs+L6HOwiyVyKXYeC87JsHfvpusXvpG+hGda0uNxPGE4ZB7cqCjISRVX0M0xLmVdbYc8rWmWL8C/97J1o8ED9mB7zciwYSYG9k9qvVBY0N8epbx2wzULxibYFkvQXodb7YmlBNzCJh72TixMbY77jbN1ex4Sd+3UBZQOErv6KB5/eDv61k6twSXpnSoMeNx4RUUkFAYoErGQeZ8zrGzgFISrvHvpAFdUJf5rheGNz0xdF7wdIFSS+TNh0YFvfW0aH4gBmAIRKbeqjAZ6pYxZscf+rVxVyWSmfqbKY7o24aGavtIql5RIptzdCHPEJYLBbSsrwuA6zfB541Q8aKt8swx6bRx3Nvm4NCT8nyuanEC5Rx1O+NpDlk2oYGyGpEycsh4UX/VL4pxTZ4J0gN9SPAFN9BKyxt+yMHk4XxSxqkJ3CU0V1vW8cx1OXY3ztfynodJu7M+2w84r+6MpP/DSDy+5O0fpQa21hLImMjhIfa6WcTRqquplaOJUD0yhSsIjwtJOOJDVYL71ZlVDcSWbHvMC0HkPwO3AN0XZWaBCKqSmRJAbXv2auxSiqnmL1XBGSqAQPFWhjzaTVbisghG8LlLNmMFAFjn8NoSJXEOzPPxZ6adJqGOVXPzHT4qJoG5xe7G2Nq1qDMwc7PJO3u8CffHXCXdsXrD58/MGPnuZNv8I6KhZJ/wEKG92oISjGjqGwLoCFTUtpdERahj4SXSGi6N42D1fPheGxeaNmtpFnM+bGk02p6q9KYauK31e8qEh5fL4x14BmeZ7fSC+Z/5rerPtExo2sx8V+nE5BAFN9B0jtV0pQgcUo1nUnGMwo3is1AcDD2iDUm7m0/OfkGYiFOLT8A9aycnKCBB5K3x94isIo7cdqpZvA1pp5aSp5kA0+bD6PKy2hy8KgqcDGyP32zL90/ywop6xxYyg1AQfz0u8foYLxHE+x4eIJEw/ecGtUgplQWAtWfsVMcE8yiHVlwcTQJK23RQR6y3n6cDHjckY5N0ji4/J2o7h0uxYUcO5exbB8rG1uaA7cEtWYQM+vROaNWOsXKTZlW/D81AQGUCs1pCDGEQQh24kAxMCbXBBJNb4rf/fUSvuEjJnLjby5qsO5twDi5kWXlNxODO5B6lyEbUuWGE2gOucflGGRByViulxl28wD4Qe8zB5+54gN2HYT3JEwFmcRvf09vT+CPyf9v8GElvrnhNrNs2cSRhx4FcdRzHF/Lylgn02ojabAfZ+0ugD41AQFdJlsah/lLbEuvUSgI8HV6py+UB4d42uToOEHlawR7IpyuheiaDxqBTcdtrsXCi55qZ035i1xHUziXycfC1uZClAQTB7w2xbfkbfR0j6FI84uJqFxhIplrixpAxHHh4j3yTQ3fkikLLAALM8Xl8IKEWxiT6G6N3Bx77m4BrTBysIosUdI2ulFHMMFSteE17mvSKVJg0gjLOu2pamTubyQPYUOE3G/QZUE++AaPftoSMnId5vb0MoKZkAdi4UR1659UgHQXJ3QshXJKWIu7ne95+4NMvO3pCk9wfXC7T/yNOZ1FNl8CSZNxFK2lyuXYg0M40ulyvPIBGbbd8dbiQELJ/N5DVqk82BMB5xEG5Wl8sbz/zTtZoxBtTKIe5jG0Ddq1ylwlCKWahIfPbLgbBXFuUCequx+cVZL7V+3Ezomy6NnKo27xoNurxv2Ko0s6AUWZATnMK6UUyMi9mu1kgPsn5dMGxsA6z/+DKL8ytaqfrid0gQmxGelFZxnVAC5lntbhHp5u1nqFD86bf8wcKraZRdLo/C+VrWENwV+8yulEMYJX80W2l/vfoi93RxzHZ/OrmCsgbm54yG0MKaiBI+0RWnehAfWDy/IvyTWnkcFZCdNokGNOg4FnZzsjM59HMGE4mVNTRt5LTS2/2R2YD2AMIU30RY34udXECDCe1PTOVJQJyjBDUS0jDkbe5AsVB0QjGIbeZ+RYQXXqhNdHjaj4ysGARDhOD1FWRuaLoG3ao/IZvHkiCSQxga4lQ8hTAwz9FY8F6F/rF0D/J4CXVDz1V4/LE1HQf6Y/C2HEe6L5omEmdgqlOX9q/+fF/jUtvieWeMcndyKOVKH68/VzYqxYF7E85eSAdpetBKym9wbzt6tmtiqrTaomo3+2DTjHnt7od8Mhl0yoycETq27Z2zbSXTi8T3IvPcpCcNJ6js+3+m+RWYY9AZJK74OYgkIpyIySY8q6z0IaDSOzGt57b2jLMOXImRoclQypIyJaenF0P5sVlKnRovIZU5ATtSrPAf1qyo8l14ko2vV1HZA5G7kGKBDG5M4usW1OSSlI2Vip6vpLOPCehetc8JG7ocVGAKMzAptIzlydxlSOpXCB6oSdUGiElUJgGkmJ3ecT/Y77ghfctflcJLQN2ncamTIBcth8rlgMSUvsgQWftgenfM0lMclPkeo2h8Mn10ukJX257edOhmUa4XBD9vnwjh+YCXPAC08eeddpJIhAwjM5Rn0hUTPo4mClEVI3tX9ze1oyBP1+9EiAKLEWtwwumikTdOACi57ilQsz7nsGP4LXVSTEXQGn27uvXsNujObrj++xuzVjUx5AAjCDN8AsB3suYVu18UJBlZBNMtifQygolY2NQDK/Jy+z/qb5M4Tt6OQMQYX7kzIwDWlU3fEOUPzUjZwUcbNsjJBaPFuUVFPfgYjJ36EJCicgB6T8W6Ok91udTIrSdMYKVDVPJoN1ZpQeT4LN1Vmx3S44Vja76mjaTREiCluTV2KxC4bKfOTJV1TY7ooufEb4ZPiYqjV//xVGvONuk9v5Y/bA04jJZvlYS2gOqdbIabk0jrx9HVU0dGaXzR7IwRRSoUMYR5peJIKpGK0ykbnJSzLIL5bmyd91lFhuBSud6jglFBbLpRtA61+ssbOAV2WbHLs86jm6UnUk7i1YNmAlvZeckN028XlyHPXG/DBxifJML4NA0EGFQbYstiBvcSowBaqTXcS0yqrqrK955E02X/6zonCZQBi+QjYsguVFzRRZ5fqKT7gqmb1itvoPLyCo9ifANBW5cpWOAQWBUkihl5/Zhjnyj/wtEC/SGoPiO2hKh8lSHu0pyY3salvnoeKxAXZGi0xTzQlTX3T07jFtLXj8mwINwYZJ4yUXjF+zGfNc6pL7AmG0Q6TD3DTter9wZgeeJHcMFfuuB5NY9XhZDwZND7UIb4IHtTSo3IxyNpVkMkDLwH1RmWsqY6J7rnYzZs6+gOQ4xAW2s5pqRzAbi8MEzsZqlBfASEwqMUslCmD6k212k/CEDYz+IK/LA/Zjs4vstjoS7d595EDCRbVGa8TzpVNDyOmI9PTx35OYtWIP6YoJB923HPYZZuMCtGDM1mn7JChsQ1cRvojzL3AfiZt4sOk5VSMgeAagi5QyiFCrMHA9Ot2gDYdLKzHI3dHb/mCnEtQE4VFE8ghI/IpMNWNbAykKJ9BhhK2q7Ys/qC4lKKW6yjmKV0BfOIMVliyEtMTCBex2ELqhe7O6TcIIZ4vW1PQNlSrstZsr9W9kuwsg2jIqma9D8hOghCCdoD17e7icA4n4LkibQwt735oFwCmdkjhM7T8gUUKghAzl0awnW98lssasHKuWfh2JwpAlfEraPeyJ/M6mE8BvoP8Vzp31muKMn3Pyy8uNTT9s4xC1cGAZaLiRDM8gM9bUprg01BxRjGajXxjb3UxWmCAZXWBWiLiuTYVxKDZZKrGOaXnRk3yeQbUtVY0/zOFooouZtoY9uqClpAxZx8xCtuJ2XHs/PeQD1K+PYfsTyhnxqqXNFqaTzJTox4TL7XKptUq6CN1UEaz3I5tSUpyHXfZG9LK15icOyeqAbL2teRaaWfTxqbNI0BfJvi9un+6H+gOdH12gzy8t6pWtpCU4aP8532YrB45Vdyy4t9br59B1s6BqoQI9IfytpEq9GqN3uXh1aNe8tsq5bm4/XYGElgko1pVOizwsiqChd0bdKaa1ADk7XMC9Riq892qtBH3CCqOQkksUwm+dpbFgfOy8cq4F96HTIB82Cl3ajKomIj63wg2+BwelAdlYjWkxFazLSAn7OLrtKm3yEcn4eFpz/EZajw7AWsy0oNkOCL/d7uIty4MNnMBhhUnnmAoZGAXscQSQaoda1y0c4E2pJlSAmiZ6aON/RgZGeIEhT52u9w/CrR0Knf0FqeoHxOJ2UFUrzXfJcImr3P8QbxPxPA7sHdbsNO5uhfrtdGzHnS9wfdM3Ypd10QAmdim9N6wCHk8qavVBXSUw1r6QgPAb0uyTfcLkUoMntkVfLIpib3YzGU6qm2wLOrjNliratWqxlFRU+ClJbR1qT/7Bvljxtiu+X/x2R7rExdQsmEQB9S7hlh7yX8QEelrFrxH9y+ZaUB8qEVIfZklCmCofEsyQp0H9CEZEpmgHzP8E33g5qZC2S/hkqS9Tt59LgVUh947h8/6lZPEZ7A9wP7ntR2XbprDijC90kQcJY5vIgsGcCsm9NfB6d3ivCLK9BIhJ+SupJAFEsjVQYLrhHDNKxil/ln/dMTN34OO0A7Ogu3NGHfj9jHAFbvZNjdRVzexEnKbiOhg+krPE8uDyQbUxtuCtA+NNFiyxkmcQpeJvXVwN2c1QV+6AeOyi6ODFoAC0XTVLUtXVoIGQcCveGjotssAVjaaSCE14jSRPV7bC/qDzJRRrMtCwxuW0bfJ3DraqH9WIf9BVHCLHrzc/TSoi2NLyumsn95PGiIdxalWRpuHeu3VfGWCWA0liGN/9pN71Y5D0ETWNLr2Cd0QxaI80LuKy/nSo8om0wWjTg3KLHOYyFxc6Pd2OqlCWfWwysGTw4DZ24F2ri72f4m58nhbVSapzvGqOileETZ1Jdq59T2aWZsPJPvfJ08Rr7rzCi38k5X7op6pKh0326jw0HNDZockLYzIpLdav5rM3qI8GgSOskMI9qN/xhuhX9eiaOANIoX/fdwvpzM43cTbIw0ZHgfCs60F7y5Dh4MVzCaPv7v3mnXk8zQBR0Db/NdIPKI9btMtREoBmVN2pTB4yQGK9TvNabAiz3C3YuS7sGePirQmRUa7TMpxTI/jmhRfAXUWhAP42te3w5jlRyeQ8Tlv5CAiH39EtEvomETbTb04ENVDT/UMTXDmIsgR7Tudf2muxNDOgIzXK1ngmjwNMWfmRVwY5Fz08pLG5ejKkBAOiK1ALOn0Fn2syJf8pqpc/843o5rXkr5FdB0t/QAyirXnETzZxAMpwokqzjwjAdZ17lE4HUCZudEYANP9lZ9HzDpHHBwVv6dyuXdG1esTy8kpBZHicpCXp6CS8u/NLq+95A8CO0v17pKQFInyWkALEs4Navli9BVwLwJqa8dmzyjfPvL4uLohg2xqBuVeNFXS9C0T16VIV97Si5cU4OY91yiOfFESwzKtkFSF/KCBRu7FfoTqGX8oX9zBJUGi8yolR2pvt095StYm6oUmMYLNyUWse9+mnAbai8jLm5qezHxKhf5NGi3IBHokvamjXg5vxYBKHVcq2Xal9NZ/teWXVdvU+7dmT1js2eGlY0AVR0JHunUGlfswVxeZixo+DuNOGyeufP6QI/nt5ndz3bRDPlGwxLcH48YFfaSLYt4NJzKu+rc8cTCGoOAyK4SCGXwfm81rtLHgSTf/Kek9HGFEbvQ3G2BtxYhLfrTB3OuwpnfSORhkoNH1LqV576RATk3kBjRhiCrlm5IRVfsYFknk+vu3DPAvjpKk9vvfzMc4/gSOg1rp5raqb3OpTmdma3Q/BOZ7w4cfn0Oi2RgYsboGYgrmpy19OTRJ1IgGSfiNipoKUMM+wmArawiMJu3/jGrVH+91iPski6qfH3qeHrHuMOQ5ltxWPd98OpFK1y/mFCQio9AfvidG5dqEt/pTzMxMr6mBIMvVcKP/vTJ76HafcHTJ0VC0FGwevZCFcDgccfg1zch+Ntkj4u7ZwCh98chu5g09bKny4VpEdYMne1hK8INF4XRPgYwAPFlcYfVL7xlYXhw13AO156gEtWLvqAoSk9COqG/RD2FTxULJqYmS7pNHXul/Y7iumbJe0AE7TR1H6umGILsFr4RsYIdD0iJv9Wz6ciKVJMxfXTD6ifoC17O0v14e7xNmpRo/sAGYr8Y78/bw73LdYOvIlJ7DC1nNblSd11PXUuyPKLzovTLjOBcK0N+B+BvQQbOR4cDK/s9ODO08jkFgrDUJ/efnDVqs6K+xBarr2EdzphBu7c2/hGVHmDZR6pZltRCq/YwiFXKyUEY89q5ABGxWeI9tkgrM9SuUTyYkui0ETroASzsxlCHrHz2U3ysPq34GMS2lzxPkLulUsL4hjrGn5L7z9RsYyq8hmIDOR4HyoLt7uI573pesEhvdiv4VsRTstOSBXcEiYzKRj6zYPdgJJx9P70bfouXgLV/RsVi+cugGFlKFLdjwpAEoYh8WaouseG+qIZjyUDnxg34MGvLqBi0/fyZOc10PkvvDV9sbhDretA8pSdpJAsyqoiKrEljo0buPtbkEglyMqQDUt/US3W4HIxbgso2iJC3kYuZQhArNdSMjgaVZETDGRyCFS1oAozb348TQZMUM/NpojkLib/WFkUDFjfZ/Nq9096WzpNSd9x4OQ7ZeJJAE1gbkCxP4uTCbsh48dbzomfFJwmLnbGT2jFeYtnYkQRnFjU8MoVKDDMgJfIEcSsd4JJWxKhhPSlAA566yKsQTR+ZAK1BBwHRC8TFi3dLX2E11NKIhT9ZS4NFolwqsr2jIthye93eAoddw+uff4RRLzsVyHlHP3XFxOJ2JpIqmPfD0BHcwObgUr00Kh8zVRm2+jN6Tbe6J1/xJ0uRsGep7U9Ce/acmg0CrgrUBPypv4nBEO/Bck3Bjq0w3S4exHvsNOUci2NaFlpoguwahzi4g1KWkFC2+c7Qj7BLhTMCrJgUiGTBDSh0T3O8kXRs6E/s8HbVockkScJQFTPXQu43qFFKSWdnw1c4bZ/hkrUfRH53vXANg8LBYgQMsBhBWjDKmdF5gSO9n6/BwmqmO/XQAHEri5vZR3x2pOJNJmo1jt4IbL95cqW4ehUYhixYU5ZMImFso8uhsABUuv8ANPUkpsKdChSzjMySfUTWpi5k5+FYWNpq2xty+0I2AqeVHJ2sJggh0cKCYSDlE0zLIGB8WAIvY247x3C2hZwQw9uRBnMrstUuxIWwRXmRThJvz+U9y5ikc7AcqtqiM7fHPRsVWVsSEHbrMWyRVPo5mqrCG4KWrnpv+ZBxfJ/8CNweeo5BdunHpuyxuOWWAI58fzDDlHRPL+6BxkVJrH4VnXJhEQY7pBlXEuTRcG8fGJ3eVDG2OreNw+N2DI8SxMjfjOuLVNLsA29n0HSok3KH9QfexTLwyAjgLqwkGcDpf+vCM+SekiLm7Q8mOJt3ACq1Nx07FrT9KKIycxH2/3flr4Y9BMiMIKseT7js0EFpIaAE3FeZOKk34qV6AgaODdTgH2IEHi83JLiIVx1cJLkUprQJ/hVHva7r5kf/zo1k9HDESbmKCXWEvx1+51KwOZIEmVgtPuL84GwrZB8AkEjx/tFEBf4SdNdxTQYpa2N5krGevx32tAvH4NQb1wACssTZhEp76qve+9QBYAbOx1LrQ2VniQQNg4orothUOprBhd6JsdQMyrQJa/us7o66/nWES6a3YVtKTRViTV1sL+GDS+3D0UyIpEPn1NUUc2grutoI+BoOitQEp6TjQOHoSQ1mUEgrAqJN2QZpDW0FaFersvnUT/0LbNG+pREOsVADHsRD0qhx3UrcXYHD51xyOI/EOUf2xBLNN9e4NxiLH7silY2N2/eMj5NIfSBeKaaIT0xAXb3Unh75AfE1dBjRwX8BhxnV5Ul33/UwXC/E5AiCSlr9ojC1M2nPQQpIdX9qlYZapj5Aa2D0yZcNQT5yiQSIamoZ4Hie9I8Cqz4Lo1gNK6UyE40QVQSfPTiK3mOKnqWWX2+RFGKUp+lQGnO4+7APPf+8SW3KvRyBnqbCDG0aLsW0wBdgQEa2ipHwG27YFjzALPtiAWyAroc2bt7vAuPwGoWnSowOUd2Vb0TN0I3V/ILaD1BenAG5SOWZUHNICZe1NygBGlNbEkWNFvf5Zat/GXNQyMPM47ix8NsRB/7QxcPH4NOR5dvr4iO2Tqdt+4FgvqhFDjGliLH92/NvW0Ldg0GlwQxXYRFxSuisz5IjSGt5PPCwmonQwxbgH4cCqlpPC6IIaOcE413+jvClK9Agwc9xJMr0YewP78CMtZBDtgjy1hPcnXMSjbKuEtAEZihQBgoOXQ1dYk1nNbgGTd4LBoafsuQsdyPcjX8dzxa1SLYhsq5/S/ADiQ6t9TijNgEghtTj5atkXOLazekxbO09FNmM+G79O1dvJUvavJ2NWnYp77S8xMb/J6D8InCXi69SjM33RrsjnP0YIMo3v6NHsLwPvWBf3YunO1XoSojio/HUJHfRYbXScONvwPnVfvalAJPE4rwzFB3u6WcshtjiiWYDBAJMlvlRBLxklwrm+XXFiwEd98k5v0g7/KTgFLNxawcZkIq4Qqm5SsmuiVLBtgKey4fQwRW+R3SGsiEFh4L4MNkUDSIQxPF4dFQoEOHPlcCtkEHkMEL0ozeqXzcF8JHwe/uis2SRzsTI545UWFRNp5eOQXWGglhJDYPmUGclx/9A+VgPvErfn0/Si/PtPKg3TuAfSe9O6Ide1RjffNMRcIuZ1ELSkIFfKlbOL1VaGZ1e8fxiUPRM9Rw6P8Fra+FXAOHNGhY6ID8ZWgTuOYj8+aAXQsUaZI8td0lqBpycIOXYb623Ts0U9ICfnYUlAeoNj6g8XUaC6dTkCpOIxnuXMzQAcP0P/qBC8Gh3hPF7MgMPQCuS9SG24a3TiIFS3uFrQTfgtwMpz3yMaxGZISFhtEsWyVYztZpWeJyvC/m7G4DZ2WC/H1LScTeYIdV39G30HA3zhvZI2xu8dMlAAEQAKgoeMLPGSFgKIpbGorbxNZWiYzbyfNfVIJ8sjfwG35bYxe+6U7GwUVKXb33iE8yqBwT7Rd+UqwHny/QwEufWdFLlvtP04aF3uWMZsvGiEIJl6CLMlBokF35j/RwmJ1Oyx0yoFDmLUj34LHCx4BkNueqUVsuDXWTAgsdHZgHcDHC5K19FzEBPZ/AIuKXW+i0zbwVPkP92T6J8yZ0kb86KJx/U4HaWkBQUpSoxXQ/HBkszS6rsWTL0k2Qmbe038L6XSg1wJtpjmguz4wN+VvAMbZRHPj1ODwE8iHItMy3Rn2SJZp4aqYXuMlUzFmdvlLT2ZklhdU3twAcZHFmjCLWfmnKTT+/PqrkgBxQPPeLtRJOusdjx0hvevyNorwgKIckGGwt30ifYAmqBdtnukCCUn//mtn22TzG37rVji3bbKLNtnUpE8kaGppPrZOgOX/8Vcr7M9LLwD/3gV8utfiRW0W5I1mTFR7qJ4ADFAvhfqI4L6A3cvQZ/VWYIkW65Sn7RGcGDkrUjdVLxP9bmhgAVGvh6vW+3crm6DtrviPuUsavJSSTTKQZeOqPc3Ai+AAfamXDoRrjdMgxTBujN7P2Uc3DjaldgmFF2sSPIDqXCIHUV6mUorhiRZTHk5Hhr3zUCXT82HQyKnprSPWvpEVX8wTD89m8r9XItHrUjPJ4eL0q+s+FBOHNpuTFiUcMvocKMGNLXMglAHfc1nxIwtUrS7+iBSXsc4sAGDPRa0Yqmh/Ye4Bmgy0Tx5ubwAS7J1bE8Q7YrSzh8V9c9AHekMXDgI7N4mWiHGk9/S4h3jXVb4aIhoEQK+F2dm+Q2g+KDQmnOc4k6REE2nEEDrtMGs3VWJK2He30xEMWYvxJnvDjicThHy/KEYg8PcxglaItyvCUALtBsfigFB8pkPvd4kpTT87OKbE9AgCJ4I0NVY7omgJjDjjzrEGpG+NecyeVcw4Dudo8DbcAlRdcVq/hDO9BrYpppdM1Uw0Bez4kCMbwdpPJ3SFBSAAs2n/j0lPWyD7+R32w9hqPCA5K56i1GdfBtyCnK5pZyPoFxKrJiTD/dS48vMr0LCoijWhO8XohOZU8M4xfID9VjGmcb7M2vpV24dbRB9Mi+NTXTC1nmSfFqNIkgq0bAofyXzxGWvfq5r9+GFn6URbxRp4dsLmDf+fzbNHIqn3X2F0X/M9TDzc12QCmSaJctOteWPMjfwNjivxleM5UepjFxIZZ4OsxBbSKgMlcjLMzAWJ7mOtQr+D2ln0BFCct/cEoB3q+0H6+BOnsEOMn1Rz9UBFGRNipeQ3kaNx9elO354bWZX1C/5HDBTN94zvQ30P7q4/GZeQtluOIoowpx3JGaRjFmLpH2LEl0CEmxhhdhoFkh6rL2g5LoqnhnTzH7mRJRVB5zkOEYv0NSA2gGx0ub75hA6V6t54r5y/YuAukF2TyaHiYsiIPlR9toF1Vd7dJhpaz5hOkJeYk7sj4SkzL9jkVs/2DX7JFAkt+SPaMoeKBXzkY9Z3WMYkixEWYw+4iBcFE3x80fTQ371RItTAL9b7YmyWL2cBM7RGOOzDSZZluMV776hLrTfzdeN2rDvlqdQNoeWRnya3e1ZcDtakeJTTBXy5Ke3eXNKRXKO/IB9IoxbjMamO/warbYJefPbuL6YRSc30B2zEae4S+gVwiN2O1hh+k9b2kxh63lz+eAKnzfgIYQC5TgAik8GLI7OX+LPKDsLVTOW01H8CybWAxonttqryfkbLNFEjTNXc/Hg/BkJRr1tBQ2/4xSOEn53sQHM3WS87FZ49stKJgAlZ6AsVD4KuWzmtYYrD3RdwsyAKOdldRDaqADgGROzCA4wObYUCjZ9lS+whvJI+PlBODIwIHm5a7RmwjIhsshHLHLc98Pa2Q+K4JyQk4FWZKphDg7fnC6VFqcc7JUoKAXBPexe4b4LtN4lsQUeiHfGazOzVCf8qPYw2rSiqOmXnL89F8ox+llF6tE2C1SN6O6Qx3s5whjHhOWtPIzaobe35wrrC2RiodNLQH3pMR7bGDdEc49rja8LjXbA5vCmv0/YNViwV6pt/tmUEgoPyxlUfxds8PrjwHVvA3RxtkxPNViZ72L5YmGeFQzUccMl0w21CM8CFMO7W9rP9bvf9gKMSQHzTzOeJk2L0pixg6o+xq7AxB5P/ZSrUNoSUk2cLMsSw7fiOL42Y3Vy8Pyo7+WyUooR9ckFM9+WOsRsBGHCViRD+3e6lURkDfhdsVShc/NOQJwQyZaoEA6GXR+r+Dh+54zPqEPO4Mpej4H2SO0kBXjZaBtTFo7ptOvKFFYchXrnN94qdZftaJLoT14BDl16aeJekRiM82EQqSknw2XvB221pNp7KcAEoDJZMjghERa7dfwexBIG8Q2TU45Il00LrURzme5NXOn1qQAaXZINAPLHUqtHF9CIZtdNGft8bCSPurYJiksjKCrfvtCjwVzZJLS10erIs0r9yTysWFztR+R0pM6+gDfj0CS/o/kMwytWcElCnNxH49+oy0Ie+p5VMAiSaDzoQ3M/BZoXF7XYOIDk/In/K9khEjbJJt1sGpPOfkDylzhZzVwc/1Mf2TWLxYDg11ycwU/cNy0VORUja6iwYxI0iuP3qKoPtJbdhKYeriEIOKY4WRCf3ITYSZsB6jmLqVjCg4K7mPkTtkIzCK71glqcT5VgkMCzZ4zhxFstmbiaGGlU2uRhTVnk59awGIh7VlsKzd0KBwobLd7X6eDZ9gowm8o7ETK50zS+ar5fCAw3IHg/1wylw428JNvRjsjDOwoWqfn7zZORVJTxcBiElD1RIfj8zjuyAruEHAwruauxDrFnEAL2c3AnRYKxCO6PyzVR7vgNLH4rSN3PtoaMxT0ozugEaB6cp7toHSwSxf1KIhJJRdGUqqyaegjhWtOOHupg6kP+Hc3N94jJrRLCHqn1WOZmL8fwsr7JvusRzvpAYEgd2QNfwg5nrFbjBLdasbkgh4M07ILHcD0jTKl5fCGMnpATPfSDYLwS5Nm6CpVGG/1M8GxYG3a50epiIBr6qh8INx00IgqZM+CmOBFEJOzVlZvxQTlOygwEFNxv7EMscOwGjeaHcHnWzfMoD+tQ2XLeMNfyAruEHw7m5PnGZNTvF9s+na1EaRqWSgrhoiablfP//8NvvxFaiDoGs++z9nfjT2XQchPQu5Y5dRGvYJbSGb6zhh3INP5i5XoEb3GKNaBPIUEmf7aG0zxIzxLSWHdA1/D+g4K7mPsQaKfdjxc/g7g79VSOftt4qGk7cXWKaX+rZTLDi70xL71Isglzml87bTQfgFNh5jPsI5+b69JYFcxHZIhPObVsny6ettw4AGo679+TixBySOWUijQbHPgUNW9lsSbHwwYqXg9GC67QY+uHp5NHXDLTBDcAt8BtuAG6B3+YNJo7cBneytD9+k5uzySP3Cu4A7D1ugmGWzv9orf/91+I+/e74xX+NY/+M0/xf98g/x/0LQrVSvkSfvyNX9KGFIUMkfn/cIDg3zv1N94bIVBT2LrOOgikf02/bFJz6QcByH1VsbrAsIzxf8XZHBFipylUZkbMXVYGKDLxyEh8JV3MVD7GzV9Gj1VLFoZFfAZ4LQYDgpWO8AoLi85SkZQF3z6pqZwKzKb18CyMfk+URrBIADJjFnGTAEXcxJxlwxF1mJNkBX9l3heKHLJ/Z6+9PR7vdaaPN7b022gBkZw0/mLlegSVsbWeiKjos2eIV8A/N93RGGD8BGFWEj+KCIF5MR+pQPvpJQc0HJY9dPH5BMJChpt3J2zwnhtMj6Hv6RBjfUX6cto+LWBxWMoKe0rd1CkoyYIzJMiDs3feqxxuvwU3Saw0uixs/7w8Q7jZRXcBM/jAl0ulzW5YXPSS95SpghnhSDwAEqt9g4Oe9wzFDkH99ThRsKksFHl3d33wxRmhimaSjn7hzDZ75W8LSP30c5l7QiLsABTjiLkABjupSla4uC8+um5vl0+ZL7XDqsWsAoPXobYRLXH3+MBlR0UWolCivn6RflIgWpKwukYbAFv/a6uA4epeRQbMw+l7k3Dk5+poE+Zw6iiUsg89o8iJU19e8MgR4mYiujSSBfEAmI0kgH2R6izpAiO3dbJ6yFwOZMAnyAZkwCfJBp1oXT0FCKZtidF9U/qQ8V24Wom5LfHGz3P8l0+YHgShkY+RDwnvL0f3/pfj7z03CVf8MRAvid6re4RtY8E4Jfp11Kxjr8xDOBQ+jHrV6HrNKjt/iXV797x3Z0WSE6W1Nn9EaYW2sdkv+dLuuVzoC9h5Prr8Q3Xh3ccUPWf9W5/Ed1vRbyoUyYCifuGYPShlwxtZG6TBKTmVX/IPcZUVQxwx2Jb+YF4+2Yv84ZYlb9hiUB6xsWygzhTHwfzZfsu9OmfDENkE5Y2MPnvKPUmFQPrCwtWLbQ+ReTEE7IQZvfYwQMCYV8O+sUOrXBYw/LKMkzx8oObPNnhGMMY1N5yqVQOgYYKAcivBh+n0Asff17+1r/fdF+e74tr5YPMfLIQuXXkF9H2m96EuyXgsvlT1aEV3lhLi8PclRQ63Nik5aPxwQoWOU1MOEojRR6Wu/Pjytvv9dXNc3fvrritCoCO/gR+niZvxUfYxwWY4qidVXBp5BbrmLaPLFbfcFBqZAP16rl6IZqVa9IyU2RHRpPGtvr3qCmZuVS1V81Ygq/hScX+UjK6qJM6l4cAO21EMVl9DWyt07QIYkFHEu1JYhQVgxU0EsTGmHt4xgd95dTXPkoDlEj7iJdFYmVZ51gc00EyggsK7OQ0VgmAhmW1dHGXEYJq3zFb6ilez/3MByMdStQTI6ASA/h2SUVZjOgEhZhzPAV812NUYmITgTcwuaijDyFuORoq4JNNj0/yLtTgyupcX/JjKIcjMqWXaQ7FSyFjYp5b2rWIwlVk1n5AhKiy9xqQiERC1cG1ZDenniN5Ow2x6iauLrAer9/IH06RX+ye8Vihm5tFHn3fr1Eu2Ua51DbyBeIwMHDTAaEZxhkmsKllpA+xNrGAEtcpSmXT6jKBW5uxkIIKOjw9m+NyXMS/ukX9eCQKsA5luFDHh/Dt/lfMIs5a2i7V8lOqi4TSPbA0iKvs4gX1f2h4qjxLhGt0eCYqS5RXKd2v8kZgVJUhaMIItIzAqSpCwYQRaRcQoSoNELrTcWPGlbmV5k+j1JDxj/ebmIL+/LHCPF+lEnID/yIGwYwmMABlsDbrAwIJjPqFZ6xVuWOBfcRWwWYlNOW9GVB8WDOJhUnXLSntUQXpZM70XhhBpbP0h7g+MMUR3HUHUoeZUnD6tYZkpxniI0HUv+zvMatjov+S/PIex0UfIxzzHs5QxX49vImTxAtdyGd9U+z/8V4yLzfK3leHa86ng6uSi9S7kIyKF440xGUAT5vg5DK3DpXk20xLgDKZ+KwLpY0ZybiEgYZo6UGpdA6sI5pDv+z//k5huPXkegADS8Z32bRUMecDHjwe4LB7r2xqanTwWeAfxY8KzEbNSiYDn1ZtpSbqotWoMbnTUI2oF2vMnNPqFPrGy5AvIHLFNw8nPIHIGsKBRFk58F3mPsJYJbOI3pJ+mW/HI88rCYvfr4y0SakCbIRJqQJshEyieP7iU+XnLzieHxkpsnx2+wcTFJgn3oR37/DGOMWwAMAhcjlAFZBiudl5TjLAnqcQJMmlg16LDprQsab8gLm4SNPt1G4Cfj92BlrfdsjTpSblz9yNlnjnni7itfB+u7gsehAL7J3itfdIDtF8ad17EZBR+xgoESmizcmIiLuqMIiSELBq8SQvzGcXG/svzDAA4u/JXlVTwTf/5G1cSF9tQGnn4+DNSRb+YBfaw2vwSFqMTh0La017A2J6dthd5hbabN1ZJRm0uWHAUyAOpgHuF7xvjxAuOP7Pol/ygwTq4KTRZ/O7F5IP2eJPdOVVEMGIE93PhRqSrYitXrKrVyLoAXFhYjTfJVuKnm/0ZxBju9OH6CVokfjrcmjpkuVUDQ8qDJ7vBJGHDhdcjbB1I8SZzkwB8HVyOdSgMtWUWJiBGv8RHVye+mQ4nT9qCwEUzUgYxEvVUqyX7wniCviwmBOcVSqItPIBPiz/aRCQq8ZM8fh9dIfuEwVXLxtF5gOQXgxaBttf1/vD4hngg2PTDbE1VehxQQLUSFxGRCFIaT6V/FpIsuo7+q7vr5lgOBIVExzI6T6SLzZPZ2fvV6DUHQOghyfH3/WFIjOMOmBr5abQOUEqJC/FOLJdAeLN1oWl6O8fuLd3jLAKC2jJkZjNzDdbFtfXjn6aHlWTPQbxUJFmpCLW2my+h6B/Zqs9Ciwsh7NLje2oczOfFVQ0LfwyetUFMk+FfxnSs24iK+gqezfOlHmPKkcx1KBKfPUQPRZirfir3CV6J2MwIDpL4UhsPddPbuZfQT8M1epvqMoeJTune8CMPuNRvdFsn5jZsJoZJSHHC/EF4VNQaRfg52r0oXVtlOwkABM0xkLiDmfhu3+WLgDEAmk1TflGJPGGRTEgTb+zxW0JomXk3tULGZofjB2AJenSTlGmdl5ndQ7EZlhO+A1icsHIa8swQupngl1T0Fti0SsMw5nkKCg3idaqABsM/N8LzdVRhOgYmt8ApZCWV3e0Klriztg6dTNx822G8Zu3oT20mNqW/H3TNyFLPxkdOhMQ44CPWItF+YmToxDMByHQzuqzEw1ucWnlXFcPhmUxX5Bx2Q7ntwHASYRJkxCUEOmlnMbTN04ijq18RqYZAOeqmtAkxSReNCb0c7eASttMIqbT8M9jzORM8crI5rA5/bwjgHil95CxpZPwiI848MSUfFNWGWZ3ESIn/6FC7sChpcioja+4JRIZWK7FMZRVkyNTG04SbT7ZK4Ud6XQop8mAtsxR8K7Wf0tAlspamSq7MO2k4WNZPlCh2LVN9us0bZ8g/oW2hROCVAiRZhTYEWlCxm4piD+7b6Lttp2QGyI3qT4nboIezU4MBFfRdrn5JMN/IvmJraFIZVh4AC6RfRZzWRXCYPxZ8dhUkKVYkTD+skSXUOUWYNFUM1fsNG5peXVEHk/5T2NnEUlg0AvmhbNNPwmbJHBFMwUuxquLS1SfCnBd2paiUOfvEhx75zL7IG9YOrxZ0KssokO53wTI4xlKERmJ9UznPY+TGxusI2V6k/d2lQF/1iWnpYPz2k0Kl+gwF6+zQO4LNWeh16tdSa6dwOVJwriZeSAzpUFU671ODaHRNTVssebuzfeCVnUSRY7gsQHHV84Kutk6nBvT32AZK+XaWS+ra3pw0cHBUjHh5cYN8w4RqWJkp0Sl867Kd1mLGCcOHyUD1EsuO7IAMG5jEOF2JScJOPmEigPFs1+ExafKItIwUBtCE/Rn+o/4hEyZoIsAs53YzLMRIbN+YUE49gKKHv4juPf9RuOtDuYbrfGjPc/kVeHexnLhwNst0u/IsnGz7anT/jVMl6g5odGYRJaOKIsmrTxHkMJc6w7gxDlzuV5nnXtz+mark3AiUhg3TYl6n3aLsc135OOXcHd+Xa/asYWzi+uFoD+ZW42iIix5GSwGDfSlbI8siWYwfelCsigUE4voppM7EkTfN74TwlZ5oFkhMe7my/wghlMQHmyPO4tVyyLpiBNMck9GAaTkOl7oaHy6ulmoe6RMkjfCWucc1fiJW9XlwQ1200y/Uxbu/yieqtF+ilkGr6eg4J84/AqUOzYE+9Rp4MHljPySmymLz0fvo7ILq2ex+F3ROZ2OkiFmspNWKHRUuRiLvXTyEOmVdHvBnF65i9EV0+Di422NDy05L0Q90ac8O3gaJfnNIR6FGr3WBP4lvXIRQcgwDLdhx1oBw9WkktIEoUz0f/zWcQHcGLsdwc0taUiYo6ccTFZxrxXYT/BkJLkEWVPtUklOjrETL53hAAh652/LfrC/k33zIE1TKgbYUKGb6zMlGbHNMygEGhEgE304dyl3QDRieHJ/zwyQAunB2UgrxtbnB58us2ZZCkJSc2SubvpAwCb9dfza8F+ywHow74w5K6aD9OT0GNukpMbS+a125NBv5twnH4xFTFqwqPDC5r9Jmuf78v0b2wfKTbveC4QIdv6+7tlwNCGTFLiTdvlPfEh3PV/Do63S9LdGfLtuDWnobBCMGz9BUjh12Udu/V/crQtfzxoicL//Lz16+AonUbGgZ9T6/Y35p2vO3f0SdONaki4QEB4G3wkJD7v5x+btfxqNrOk9YDNwGM5btmY06xO1OiK6T+ElLcHHp62FKZMa8HMtMCyiRMUMdqhilQ0cNEGF5v+KEu/mr4wXBurk9cZo2QUNjLfifLl6eftwv/eZs/vvH4dUsDF4Ab4FdcIJtG+t0fxlbEV4FwuwyWOifQxo1DPjDFS6PKNfKWb81aG9S/eBqssKrY2puXFqx7ucaETU85bX3v9oDB1t9Uxfq+tal9eNUndR6/4F0rN9B5tD/cBBTcbO5D7PfLGGZmbpK5WT49Xm2TPX0pbLbhNibgqw2Gc3N94jJrmvz9IkQOUYiW+kWxBJOVyxhevOrTWySYJye0AzGjfI2MTm8v7PXhMjeM2gicP8NnjseqHGnMG6oZt1OLmIbLCiIQ/Xmm+g605LBEmNNCtlXlxVJihnVHxcQyR+7X7rjlCssegCu1u2DHFO0LAaGqfKv9oyH3D2BW/3s5ZvpUprhPNasgLrcz5i34Tj0BOUyi0/GC7WVNbMjPlweLV10pKneotGLpXAzAKmG4s4Y0KZh+3KrzPWOc0nK7f+XPDA/vQuicwQgxPGTR8AJU4wnvN/O+Lz739wd1CBUAEun+CINPXBaGNCpK9kAQ4WJzZH/inDBsfmpFhxPKi0gVJQG8miN0BKX0fUg8AUWoCmSrMF4vwH8m9YDpsO8RZJ7sHI9QZUiJkkHvf0RnLx7EemBv44UuM4DWRTmvx7V8H9PJEUolzoLgBO+XJISnicI/LTihkknZdNlN6FJ3/MMD06gUAR6xqreyRsl7vpNR6qtH0j4JdfIRSyweH0SC4iVy+t4ZPxhaZhC/dOz1qU96c/by415YcsVCUdnr5E37gl7xB6VJQfc5EUj09akHu9xpccEyTo5h31Nv3i4ItelsqLTHmSfvc5+OY599crsMzmilY3nLmQLeRXliGKfbjM+l8CaTCL/L6WRX2ugL0lQnEwjJx2QgGGSWN7hJFAhTgCPYFQ+9Yq1zgPRjQLXQE9i9icc04vxqgI0h10QxByyJxQXBTXdOiplq7m2TyM7MEjKPUW+CUTaT3LHIgkh+F/RCYUWK5U+WZTEQIVXvB9ymzfv+sh5NmY6/Resdebnu54Rl74hiiHTLbLAeIeR8HY2uVaJlG+jHGCU9XkJpQGfq6VfadJi7OxTY06F4+4uhMhL9kntPeFwGkFLxmkXHNwU4nh66XOEg0HULvu6i59kjGljKyWNFArsK1esj/JSflZJ7NfL5YrUn1d3SjtrLR2ycjQgqhwLuWEk86HGVdwPdIVo/vFzYiRaj2xBrhkVBdt6xaiifVfu0hPsRfI2Maq5xORMesgyOOUvHjFQpIQrzIYWmScmtZdpDwKyIbidxeaTcojjyRYI0pANKVrdEBiB47SiLoDYKttVofzDtYahLUCfAIyviuQwHSJfdfoB6Tmx1CE8OifukBPgnUD9+YUe/GiJUIvGYEPoL6+1aa9zvAI1mtN6a5Tss+lELubbTDl5ccCyEc1le7em1WdDNbEwbcAOAYvcp13f81o0rXlKaKzyGZR6dRqJwZcbKrlujFqEVyUkcDwIX2Bva51SgZg2rbYROBy4sOMXL7o6c/Jw8V2JMYdBDSb3pzqX2EQnprmXYt08k68YPWcG+Cji72GaUNfjZZb3d4MBWQYxLxggb4upnwBbjL49rwIADps1SrGXolDPpoV7eV+UugIxXKyz6uvYaFUUgvKcDHmscC0IOVPszuCdcEx4dRfkZFtcY/ANgUkFfze2VU+8bXkvp2MMlZSvGBX5MdgYp43A+6ZyoecZHCsoiXq6o64BkDA98dLfz/flab7+Fp63uAboAEGV/gfr8cfLid5vrCXj0UtgXsAVJe8hEb9S0iu8Yl5PtNGlQ1pLifgib8sIBFmvuFpqFd7LN2zn3zN8kCC3gQbQ3VgJcSCoZrlmgcpL9OOm2R1g6D2Jsg4bCxk1KInue0vIUKk2S3n0ja0JumsecgB3NKPslXRiEIG5TtL+E+3H8/AFkRE6j8N3sv+7oBm+3sDZKp45I6KwgauWY0pMh7WAZaJp8gA+yUln9W2PRduWGIs3YSdsYmrbAXfPoQbzjl0G0qqluNzsmJe5Z5dum1FDJMoETGC8lNVElZH6k6TjCWyOQyikUbN2wmHcAou0xZ4wkd+5ldntgmx5g8m3WObPbWiblVb8fTfnrmt+T6npSDKgg0QFr8Li+dpcdgBXz1gVq6kEJyRJTMC2FnyRBmukZKHmDqkd3FRpE8SiUL2eU4IhrIEkcYM7nD/er6AnmMFFe8eqJtCoEyQvAIZ0X0Wk3Ya8li1xazqcAdBtDU1n/V6PhbCl8zAMKqgTfY+ifujXH3mRQdcR1g9YOX+REJY0PKhYGzwpfhNNA25vNqboqFhhs5bLYHZfnj2DgmXnp5ANs+m6TZf4jhBlbt4XdrhDCQzoNLKcpMPdjSTyVTB6FJ8+2q5qlHaMg/jVakLthJ71UuOPfFl6hCDfu1zJCCgVKMihIwd6hK0bDPCcUmWJUvnMwEA8z0zXDJFmeXTBzwb/4OlqBtiLexa2jOcL1VDvVhbp3EotWkWFxZTugDn72yPh3gQW4LRJC+OD55QzqJAJNESnAonmksUqsemzwLPGNOEAX0JyDMzU5q4k1Js0xHQP8bHIcMglz1DwLSxiDIQwxuTDa6dlLjdH/ntTTwB9Y1Vkrw9Dg6iG2CUXHjOnh6OXAoMbFnID7yUgHhCJ7V3VJBkgnBI8+ZL5ZXTtBTJrzC6xZQmHn5G4ozYBq55hjwtpCSS46ui2aIhpspBuj+C4L9UhwDyLmmRqov3xKiWleAvsRmGBIHCQsnSbIwsyESj7Dzy8OsfMSY5SgKLlFfT2jI21FZ3X3UYmOSfUahXbPzPo7KZY2EIWkA+TAxpyv9o0DyZ9BETCslHcL4u1gljYhfzqxBmnGNq59aOSvyVsTxfKV7qtqFlpUDw06EMIwbMOUgQy6l+YqmU/NQ6qCBr48I5ms1LZ6plXrkpMaPl4o262HEmWZmEnGdzMBiLJPFEVhYsiivx+R/tkOhrGZ2CTuYsVNi73t2FT48ygJ+2wd68xYhOe+gGvwVSqRwAuapjw4OrAjeR7/2rSpCwKuGVVJtG82rAq9u2lW5OU+k/B3v+okuTTPiQbq1yjVuhKIBIRtlYC9pWefbpT2Ij94X/xus8X6vIAGOWMYzGFzzsRAWGs4UZh9Np9w6aNkaIEbYhJozjouspbrslQObl9LxdSBhhbiYK0PicV8KZdRfieh6OStnOCxjAEVuPbRyRF6ryY6mFPLFfdeIowJl4vZ64S0/QEoSBIBHiDFbRkgCkR3+TZFb8DMDlF8A94l32rgGb8xguoMMHQpuobtr4nrJjBpfaTuHiV0gR1RMtDh58pOBSqrdPhEdi/EsTdN9Ck6QDdurvJ87St6PUA0mcloYRdGjXaXWOFThwS98PouXqLK6b2DctclsBnB66orW8zcdNXMLk0W85DHMIwFh4gXsA+AyZmUHRPaDyuYprGIaCQYrsMeLGDsK5bnJ4J4u9wmfvn8nRjj59MVDx/FrxuLtskBQR1BQ31E2PfSZ+ROpVRCNsyGRsEhlGn+V1KEnJT4fBHiB2B53+DqhcYCSskm+mVkvEZjB1UjLvNOiq/sqy8db1niPHQQ6iB20PnpD3ygkKLbTi7Tcd63U9g/GiCkuag7y2ycg3hmKWwQ3CYiXy5Rt2zw6f1KfGvPTQUDA14VpBY6wOiR90ygS1D6O/wG7Tai0ZkcvikG0FghfBjTNQHs2BXbchcsHHHoSADyRldKqBKw/JEYLDGHmLY2bWWbDauM63aBsBDmmCK3waJ7b1IZybUkslPLqIYpfEH/viPzSyXCui5NgOBCglN6OkMURlHgxMWpspALwBLhqPuCWeznRbqRkFvUfWTAKCqsfu7pMsG6rD84kNlM7BmISvZIHI9OtvKfPoTBsUMBXD1MrthHo0TJ0woSAtk+NmsfHISupoa+JjBekcLyhf5cE038ZlOWwryYiY8j20wTQMg2kwGYwuswGF/SlCDTBEAWqL9KMNziuC8CKNOjKk1KKJJEIWwYQV9tJUJPhSMo0stp8dfQArMylTQC6JHtWSKptDhF5HFa/QsgQUU38YIpcgEsOumcspxoivadItMARQaLZGoMVZZNPVQJ1cicqx2K+W0kCyXOhRWTMFOhb0TrPgx1jxbKMQ50bA1o1kXVjpBwo9k16W9aFQPg1MzQS1x9lZxS4u0K7A9xWZs9RrpGap+DQ7v1F7y1/i02Ckshp+WFXT568/5CG0hhqZtYfec2ewiAanHpEwCgoaSMF2QC8ZMDe7nbd+CWzGuzip/IvyqoHuJZCtCA0HXYfEM2topz6nX16TqaAA7ICp9LKkiXpNYPJwxbtSkYtPFCCG3qak4O+ma0Vn/4sYXS0C+7BbpciZ17I9gJSq9Q/MDDiNuFx6bOGmB0a6paVdcswDk2ukQbs4kJptMU4PGqfoZ3OddECxXBKqqJp61Yn+GpJJwulUMJItrg8b4c4L3B+i+cZgxQlTzT/e2rYVWGq4Gw7HV5G9pfaRH+xyRNogDRSgqWuBhx1JuQ0LPrq6VznioVHvCSUaVM1FYKVtEwTZaWbtOLSykovqm5O2+uFHaQK/yrhxXmWu2EyhaGbKyDWufCGFBcYDxJyQFeXhiCyH0X6QJVJ8pRSf6IdwnxuFqBCyjVPQRVoOGDwjPVuAPRR3u7+ZRi8DwNZddEsIKAkJiSLFaD74jxLAVQOvf9+aAYugurYQt6586K1Ri2fR4nw5aawun/nsaoWCU2tAUYGtxhmqClQ+Ml7qJ3rzgWybwqJEjAS6Evql62V2TmCaldwDvlKwq3KIVNTKUXKbRcSVTznSfXmIrAFMOxEbFkkErd1Sb6DHu1wwouFl+om9mtf7Sfkl4xWw0OemK5jJTX/kG6JxsxmA49Qfb3LqWxHo6QrUbAW1m3YHMcAsvcWQ33y11h16IJ+tnm0iIb3mgMhTieqy7mV+Vwv+PICrWZYxlf6tbXKlZryePemUKyRjitAHnor2guMC2LTXJzkBibxC9vRRU3f8dlXLK/YHaNt0ft7MiuRJF2q7hGtP1aYjRAdWxPiqW+z12aV1LA8dP+owK8sQkIX82Pt9iABKd3CdqD9nmg22znmUiuOqDckdmEWNpPSWy9gu+B4siVveGPET4yXfo9prOu8HZtA9fKpG2NTKia7V9KErv77wW8WzEhI4WaQQfEeB5rG6zCC+O96eMrmCiEFA4ILuwQw5uAd5pWkqjE2EUsQ5WwUn7d5Ff5/QA+bERnaUN95XEH479qObisouf5m0FnOnqr3v04nfmTAZfBUbdf1c1JgryzpQrKxNDaWLmrHWQ0kg6iTMxys4OUiuw5Gv+Fk6fDRp3qclHUrBnENDIyKpg7MDgJL3O0jgmSSvQctOp6IcnMVFl3DHcqAumVAET2sBpOyCuVg8ftnaiEsRLJapI3lwFIT+oq6cG2GTv9gUsUJwXFyStBvEI7NHu2E+0P3/uYeFq9+lf1l/11jC9yhdPHFYrGtcj6yfrhuF795fCqGzKk6JRB+kijAUN6x+PDumxWzncL9A1DMDQyQj1Wx6OjGS//kk9JihP3INqdno6wbFY58B+7NOCMe9DmIeOs1L4zIRfPVggjjucSMRlO3tstG9MSqLd3JteBtNOP3jpUCQI8PEZX9kIXbr4XMjzWVlJiQVNyZq56u1l0rVzQTGM0CbSegx2C2Um5+Je0MLdp400ZfTva/ue3twt0ZU20U+9phnA4j1BghzmFM4vV6PrlPPAe/UAeTgt7b2dbdzNUNl6HRFZdnbQbQHxLXZFe/qrOyAJ6yIaMYqFbqcy6fKnJ04/c7HghTtxk8emwg2qgy3YZEJymrAho5sRpgaTQuoSjNl1fm0uC8MrSOk9Q1NjscY7hHBjYRqKZQz6XgzKNxF+FDe/7juQY6i706vQ0g7dZcsqN3+2QeP7JrAuRaTHRCWjdYPBGF44QmPca76f6N77Krj0o/by3DJjgteFaptGco67Q1df7TcmzWA9QaVuB5QtRch1XwHcDvCmi67YYRifAoWPh7nasCYLCJ6MBSPli/vCoFi7YVkUxzgWHrzhMgni9mdeMVRj5iyVuZd68GgKMghFgKdtNCocuuNSC2W3buryRD7p8KAvRGl7Hs3LRLR0Hh+eIgXg8XM/AmAstyyOUoZeXUgA+h5GHOLcV7ZXtyq3lWIYTBBhtgQXh4XCGHYzIAtDDx4MdBCQ7VCiG5kWodvFX8ZdcBlR/hMGXwcnXPsHYjeBxYmlZ1BBKN178jK4iRiDsy2mP9BLngVQZJjXoR3/8HIcACzFt/vickHUZcGHERMIDE69ORnIqpc0DpuA6tTGtXYghSfKmkkwZH/f74/f/4yzd9tzfTyvwgjcnWVl2MKlt+htIxw4DWNzYzxzEQHKgH53lG3rlWZYB2cTnt2yUbeJTKT1YQgYQxtf64r9WZbku6qIUXH7mclH8mUAY0DyLMzMuEzgWo8a2CSDjsq/gSQ5FfoNvXueWiAjX/SC4O5TRELYqHnyJmFE6XOINHbGsJTc5dn7beJF8re+CbyvPym5SYpZzCZV2ShUoNNMzoornYpbEjqv2MQsuW7AJz5e52O1D+Iabv0HVY9cXWG0mldas24SuZzksNzg7pWBldqtXeMq7Tlt/RDunijISCt27DIFxUd8PwkS1oJdVEqmSbBSqOZEh4C2KdarqZxcFMzAyw8pMWp14YMQrhYq1388F2TCVWJ0CnvZ6M4rL5e+Qst8oJq4uVc5QPZibm98wzRuJmkJHDKCNB+rbkaln1ECXtkZvxN5Nnt5O4MlZUCdXZrbi9YiPlWcvsDVKQZSWpcRpOJz0rRaDVh7cPUjpH1JRDYS+vFCVrSa8LubLIiQ/kA1gj33XrfcYCnlFcL3iRC/5zDIIL+XsSQ4rK5AXDP7hh8HbEp497rmThkU4jpLDHHwrC7ARPt4f+Yy13cJ/vHHgSVEXEhPs+4sYanLxiIQHl8SQAj9ihiSsGM54kDOZ2PhkF6LakjgH8TCS30MDDgcdL3ygSPqEtGpllKEXJA02NO9LhNAw1kzMK3ZgwTL/oT04fcIGr6h6rc2h6LhbI3gyY4k+rcCJZowXsJYiOrWjFYNn1Xl0zCXcB/iLGUv0r+hqV6u/LQRYrI1DI2jov6IDmdTQRI9iDrE/ECRujaBOGKP6vuDLewOgEIs8JS0mY4OvjP4hpJd+ESzkTNMvRgyCxOWHKNyqRLrXuIrQImNBd8A9QzaYdlEJYzxG+yBOcH8uGuBtHoTDlG/R4hZZFDKrDbjj1m8A+ooGgMcQABXMJUIA7Yf7o4z1BhlPG1CVKrqIUKDooYpJNngTyzQUqSezsa1ko1wv+nyH9jVqTPl3N8AuhLROz05DAMM9eWzz2FldcmCO+TclhT3EoXAvS+8k5W5n6Dxc6fsiY0ZOiz9QPPp7qc1G6rZnE+LsQ0V4OX/HKnurwfX+d9TjeBMjDJWyJEK0e1OFPC0f0A9sMwSsZ9P7Aa/VDlgLUrmznfuC+tY1oErutn/UdCG5uAjTpKBTbiUongPgDnNmQQFMJbyajl4oJkZIiYpK2jR6wqdX2+bQS2QVnteshe881nX6AUjgTBAThTPwWhggORSR3LBScylEF1PBF5zJyj4O6R8DTja1WWu6lx2onJys9ujwDGRwJjyq1nvnunNiFhlzk2Okaz7eYqoWLPFcg8OCkHFARaFZMB+x5C92DDw17dZPOL6IV+VKrLXW0tQIt7RK3nQUEFud9z40fGJq2J2n8t2yDCQbP3A+o0PaVX7ktda2fECRgt5mrKkcb62qMNfxRI6X7aBBa2bUrzROu8ObpppVGRJ+jLx7uTbaQRfU1YgaWzkbgb0Yjt1KtKsyOHXDj5A2t+2WxlajOoQ76Ap82Xy4RWIQufJzYuADj1AvCZIq1qyjQpvVYcnhU/NG6NYfEzplcLi0qjytpAaO7l1LON75sGf0rHn7lHRuCX/8Qt2sbun226YgjN7jD/AVnm+9SnYamForX4vmjjBbi9FnBDMtdZ6cfwVk7Fvh0PWWvE2Edhuaeld8p23XVyYNQ/yaAJ1gg0udkYqCqVP6nLL0g06MqNmv0ctldUjuYegOkrXX2MbxZadjfk4TzlPb24wTYZDGBo7ogZP+Q/4SlSDYvbrKG/IuLlO4YHG/bz+HthMkAqFSt430VU0x093LOon7h9Jk0j6YrO6V/Q6mYqITK30jvLLSwQ/bcTQdPcJ5RWlWJe4R5Xl97hEUb3Fg5pOmxqQeSaewyRtuwlSXVk+fk2xiy1rquwLCwXzA3kuckej4bzn2tauaUZl1C249akbFPfc+lQ4kQV84oLXlnmSia5XS53lmq9uK1NvgT6CnUMTQFvyGRTPRbYUROL+iIojvO1YAKE9XptiaNQAnQBk/fF/AW3xnQZ+AB4/nNZ/CZyHvW/khReiA6BZJMZJ5DaD2QT39YEFBvXikK3Zd0PDcdWURnf0GIJBY7ZTz7BN8LWC/idU7xAK3x1av6AiZBgZnwmlRdMsr/y0H2bRtakt6WkM7yfwrVQlk1PsBjp8mKUWcgw+VaMLfdUgvt18eHn6G4fVmXoB+aFOvzFsW9S8EhHyiOp0YUC9QM0nmMLogBljVcWs9Hweirp53ASluP9vxHuM7v5+AY5OsPYrqqPev5/VQumFoYaL4mVlwDeaeYEy/kESzJZJBwbCsCKEa0r2PDpHTzgI8OODlzIE1CJDx/BHNzYE14QBnFvyTwRWWOiX1D2Dls2V9mSlN/9YOVdiABXAhDyvITAmUXQG9Ao/zl4VnwdgoD9Kb7mRSToIjfo91vNRZuc2CWuyUrelUtSVqHldRJfcKGu2VtN2QMCD5MhPRq0huDa9IC44+8LCMcCc+iANHIeIygwircj4MTmNZDhoIO7ni51c4BkujJEjUe3/5CsBKQKND/KarqGXlCs/G1ebdyhTFQ6X7qhr/LO+PlngrUouGRd+E95ANIfXr7Uk3D/tu1MXlT8S+k8zsJt8ql5hb2FHwbpLEe1x5citvdVcOPCyIgqfOLUY1tLNl4braZc2jolmPd/XNuBFEFY4fE3KjKYjXdhqoty26G+YjFwxQ2+ImO/uZwbl9SMA5+uaRMhYOGV8yXqLCeGhOs3HYT/N7w+5xnuoVmouIOvuK0oooFUadqsewCCn7tufhY05Qhmmawb0YSYfpyJiPDDGrPxLfM/n/UIJ44IgSPtkMdW6FhsWtwHBc+apTG8/K+WNL0b/laNUNdhKySKVXXxsxStaC/dqcbEniza9aMOXu5P5OF6YsyJiPhH8A/TsV4KG4oKZT+mLci3/ik2WPPZrI4+SXdjwIOGJdbeAiQRWyy+IgdgZd63f0jD1YZN0Y0jPvIRBV27pgCGqrGs/JozUWMNpYLrkp8N8dcLCNwCO74sZnBlOG3ZjW87JNmxF/TPuoHLpSymH20ItJackdic141rJfFnMBaHc1XhId0VuAb7OVwzSosczFnLTVC6DaF7mAOPZiYbyuaD9WnPjDciEfQgMysWNQy1q3Ac2tuAgl6rMlhSj0TYB94EtUqt/NhQMTJG8zv06QXz+Uf//wr4m2iF4g0KcWAzD0hmuELkMhhqwno1Xke5by+HqAZQKJR42edqktGk7AeV5/W587MzhlCdXpKAcxXvyHQlUegW1u5L1iQ39E71khF7R50XylEv7YqicS7WDrhInTNDGiTh3B+ktp/UFrZNF5T0pDOyZYytqgpAgMjsfCkYLArG7V0hAu2U7BFzkD9CU5aeOKX18+7mEFwTJoD4Kq98KaGmBAU8gUOoW7MJWnaaIJNMwEknSymMs8uQFJfUNxxHQGiuHQz7E1JPeqVpvh7ttBz9bHVnLUKlEkLycazI2MBS2HU5b4TUkWhA5QgfE/1nP400KdGjryT+AgigFusfYMd0zClHtaGtYf0QtLL9SXkhF5Zpf9EKy6ORj7LRFRdgmV8V5fe9FkrbPG8eMwgk7x1/HNlmigD+k0EhCyx0fevQ104roo+BUeQRdOcoPfocz7jkXcdQywdsiWeur+7WrhO3IKuaat4lkFgqD3gWd/GmCigDHCBB0IqPo88bkUKQ7swmBddPMxwByKlwQSpPpTo1XPgJTnmZK9kKQxs5B3AT6D2pqxb0G4ORAsQOJLq+QwkM4IguCLKTe9MSyhrqTrQM8Dp8l5+oO/kKBrEQIX2Va8toQgVSkl3EGpEbH8Xf99EjGvYkA/xT7sixhVXwWcQKWhtU7kEGrKTdoEiTnWd9lDUCT7MgZr/wEUq1adon/+ABCi+6EsrOAvZDuXQ8XSin2ZaeqJGJGgUllVOiIYJaPGOnF1CpQbSO03DWH2MmE8OvWlk/HvtuOnkrkABcE/3IwFVHr6sranu7f0DRi1PH4uSzJU0jNKE52mu2mpqPUCpw3xZAsB7p6GFwqwBGG9Sia+UWwqfYe+ZNuuoURPPAU4FDM7wfmIs0Z4QxgmiIwgjmAVjECDuGZRVQYKazLG+ecAvmDwZFxG5LGqqdjmvqQVmyAQph62yQKOuNRI2RrwqYkYtGZ9SHezBTHdlAbohxYRKLr3QycqpsVGaY6fCVkEhFczydoftxPgidtDuxLg0aCEaZR+XgpzpSrFT4NP44mm1iuxV00UYqRywoaDTP9QWTlMIYtL08LUmATUyti1ExU3Isp2Tzl2Av6bL1usDEXuPj0E4KtRQLo7fiBOYyOOvCbAzoIL2FJD4pBpkDvl9Hj8ktWeYa/+Q6c1vvonGMl54B4C76nsHvYs42JqoL5aB/qKP+ICflYWP7Tm2dTA17RfQSS7kyW19NML/FFllfQT63tj4C1ISiCQGKJPUPGdYvyGhqxFBpYjyANuxnJuY+aqQyKfpGU6jyOa7Cq7vMRkPvoGZnwTz7r0ZD9gBM4KosFuxNSZ2y2heqpmFdxV0/cKvm5QiDitCY4M0Qeo6hJPbDuyxI7kaBJObzxxSojFbZ7c6aSIkpOa9cS+Huckx4e1QOalnFjmE0zwy/iZeJljTgEXnV3pojgIE+pEmrmYJ5jXAWQv+gud4xz10v3LxdxXYjk9X9qHejS/NvIYhRj+Y7bXqO/M0f8xY1IYICFxx/TR9eTFPoANdPc7UIMCNC1rMz0TZ1SAUJdlzaZJjU2Ml4nMMzmnhj9f4O8qRAemazuEJBGH4hdsQVopBK8X6MkN6tbnUVQ4JN8JnXZGfNTmcI3V4OZ1C7HxvsF7s/CeN6P3mgdH0hmc3UxFf3zC+Ufjsb7HbajrKIdhGn843QO/hdqIQhxzQ8jOjf81QIf/s4FRRfTokpLdFkzYHr7i0GwxEDzK60Pk5Yr8a9Qo22aXRn3nHQ+bX1Wd1C4WqvnwcgXWirm8xr045plY5xCFWtDrrtPFfoLzYl2o718g8ocRGxt+zwKx+q5Qa1rHXo9YXaZbgBwn8ZZ5cUg6Z0cB6g5pdN7LDLxunQwTZCOGTfrGmvCASw0id5QVAF0ZU3YU0M6QpVQ6DWEy4nBxDs5g6AbKWQdPTrofDjN/t46F0FiG7NYUjqYHdqmBSm0xMp4FNchiPOUDv8il5bEi/PQydacR7Z+KcRFhFee04oKOp0ixxdG4f6vXK2xnnINxzmEr5R0bq6F9gk6SDPXjlBEEIIfvz/VF2HarbmcZ+Gf1HR/tAm93PEkNewcfhw0p4BIE/KVn/a6mU0mLV2KMH0pr863M92flTdHmxpqhmxXB+cealKZG1uXTtiIQzv8Lbc/r3K3Yb5sz07orddNmu5Ly5RBzr1KLa5H/Q8auVvXydsUpf5f+dxxF0jP10vdkMUi2ZhnptKS7af/oD8tB29g6VO8G4tjLL9dMpcn1MOqqM4StoiTuRnn/YJYsuD7vCSNzTsoFFEZWZJ2sF86vguAxs5WRlk52hEYBvYL4cSrZ/hiMPXBZzJJpzrXaxI5WUfHd6z6ixYNZ0H4U4ouy910pyA7HOmejZCmaYdCjrRYYV5Dks20tkwAB0jFXFvboMounD1Vp4WnXV3r5WqF0V2Xjw0L4usj5/Yu95d+70Bet9RlW+9kGI7Gsj5eQNM2611RAOhBWbbIwSjbHmaBFUIyfqjkxgCBS3UQs8/fz59nmvwLmDhmciZCrQOlf46hb2RDRyBbP93+PuMd4m7374+uDpGRGiVgH3o9aJxXEIk91jsYnoNQrIq9BtHYmQtYwYFVSAOewByprn6FJp4TSh5HIHBtMNqZbkHmgbDzT/j6TfwdTAhfRCrPN2RtvhAp6DlppqqAs6fN3KuDqJ1bjddzYmciiwnnkV27YHyd70LdV1G9sk6hz4YzMhLkoIrJR9dmnbOaO6rcfTYzmLdy9i4QM2HjLjADt2hpIyoYWQVMWBW2CCIvi5UEtwljrHT7K5rfk7uYUIjSq/dDk8aa0SVb28dwIvmpHEDXrfpwt26Iuu2XHgEougtJKFNjSlYehtk5KxPdTO07vwt545CmRbaGu/XEUTgjtRSsaptJXW6b6vyIfFzUFBEUmbyN+XKKW4hPcmQwKzdPQFMThNsCicmomvZKPqUNBPqZBZqtz79/lhmfW8ZmUiEsoKrzMIZliR7cP7+GHoRvVsWJpocSeRNJ78znNIkVpcdxqpV7I3OV7qUfOiwJqU+AqyJL4CpbQCOqvoiWwEnPZV2KHOicxa7/AsH8cNYAmTt/iy23CXcWuirdHtn9/0Df7h9/l41TGoltCZjyU9yU3gxMAAAQLHH96jvK692ZWxAStpwpKmeYHt5o/vk721C1yAt0gC024a4aNxFGrmzMUe8a7SxHO2FSihtWu+v61pC3pkE49Bg1wIAWzOVHooWEyqr7bbBKEaULuR05fLon5c1OFe+iancCov1YuSe3SlHrbcOUySm6d/u5IsvaixoHenG3tzwOfsRSorwjDS/0JhVBCUwblrvlt1X1kNgez+tf2U42PJTjOVYZ6ofEy7qzTpOPi3arVAIlPkmHbVaiBYkI1W6aoaPVclAGbKg2nPkl08GNUf6AsdGqLm85LqYOEriqMJcpuU5afrMW3p5ruavOOgfkOCGdmmqbDlNNURQd2umWi4brnjZ3P5YK0k2asUz51NQdH7ZanKY2NDGR+J4tQTUmIuomHljvVmcW/wCDU43ScpYghMpRKPYVHXVPMCaBZrK+pl964/j5tYSxVL+OZaNd1p3kgiISfX+4V4CLgbVPQC/2iF+5YeUR8X3ZjVcnf1aMt/uJSrrv70Tn08mvuzx/NcMUqSCNIC0dzKVXcqR1IoUFcjUSl3cOBhaa4MK4OGEJd17+fahAqxCpNDcuLwWuJVvHrBWnkh0bVHqooNslNHPtVke2a2MC9Mj1ntlvmMMiF1iEp4Y2Scja581ocF3e7bikpmamkqEsp7EgndCYXf6wqcpgXRrmvnzlTZQ6zCGXfZ38O1rQlqxDPcEGMmbXq0K7GUFI4thXvrjb1WHBy4fJgNHuRtOI36DpJ+FBRKpE1IpKewS4uDuJtiGGXC3vLC+viXc5E98NnLRbX2UKeZ9bhSHCoRylCBhADRWPVU7Po4gOlHJe4sMkbbeZA4PJfjDLBzUtSpK/SEkJLqg0uX05wtnBHMZjrFFxMf5mj1WR2p4kDcTwV2ycVpBPc66YloFS5EvbNN8qE1nNJoOQLB3K/z2JhIq4gc49QLr0xtI3+xeXFZLTMJ7p1cvrLCHImO/DVmKDNOKvD8YGFuTntKT0QrWzWai/1wz7qqzQJ/Dfx9H6nuyIyLV79+K44vm+E3AyZB81EaAz+XHQApjiT6lK6qWbjXZMW3IxEHGiX46nGRWMUZhaTyGZbg/oh4LQpi5XtqPpumcr8mwLcBFGFLgKpYH6W/0OYhKYL7/LSIM6Pv2tqwBuLakiw1KXTxlGhEhLA4rnOKoziBqPoN5mhXiKQGDk/S+TZRRaHlbMwtmzHspt+uxUe0t0oL0vA3Q1gBCG6GHycXNNLWQyK/2gyNU3qpNjpQ5P+rEliWy3RnMKIIWVxihd7P1wZS0Ygcsxhq4sulTUOdrE4cr5+nPVAf1l65ifmya43Qf51MMz3Mu1hzSYhUwPJbQ4dyUj/No7cPcx5UAxXn4UcA2vL+Rnu3B6FTG7JACAMSdIIcfuTtLf4HRnrXDG02yf2uf6yVY/5gLwc7YhW8vONLNqFAFlBZsk74kZ7OmARiv1BdUoHoC0+Nx1VmUjJmlYVhK1cDHFx6aTuY5m359YGLrgwI3sDobg+iAtAssZyrNREWsdxrtmDQREhcdrvijpJCnEQYK3CcdLjpr2dZFHj8IdODMA3/3F/vNU2+2NP+AaUEWc+noO48H6WPYzCX3PtNLZi6T5WOEwlfWF1MHOHgjQFhQ1vncHo+SQbbK0FI265wUDC82dQ7znQWaxL6BLMmHXysIJLnwP2cECZIXTb5SK7g2Qn5PlU/4jSh4L+HpflhRJVRgsBhAzf8LKtqJOH7UngA7+GA/PvepfFaa2yKClow6QuIV5orVQSY374ezDMeH+NF7kDDqOaW5zL68qCkEmhnJggCyV+F4JS9EAunY6ZiVuUvz1uJumoCARcQDiI37sHvbLvovASzmlNHvQItyh5vtVWtQMkB1j+/Q3SIuyB1TYOqdm2GVmiVF+LQ1k+V52YrFmmkz3VZ40PUgnoQkIBCQIWt1kdTE3rjzGlgApU2EmlZzuKIp0cZmMKmOcO76pxM3ndSuiidOPo5drJwyqpuuKZfG3XYS14biArhSACR8AzezUII63ei2soYioe/YWcBwt8O0YIu8skQI28Zd54gVumH/GYYvBdFpWOzOKyQBPCZHBTA1H5p5CMNiNbq1pJyUFdaZAhV4UqqsSI0obq6uvJ+HCtzsRD17Fx3J0nBwQkdrKrT3c7x30fh1WKL/mw7gy3TPGwfWXczr6BSxFopEA5FgU3cRgTXmyhUgCIuWFAvrOjBm3MlDam+aQfMA9DaGu/daxZyb/AESNQZiW9Ek2AT45Q7FTM/tEz+Oi3IIlY+W4F91x67tV86uMdFQ7eNxvlUV1oPMnJGF+TwWYEhLHuwn+z6DFMpNWS2vYBz2Q6oS2O+FZPi2q9kMbM2wW3SsZAGTEGOiDY4zB5G3Qom4iRyezaMbkpjlbWa83pQkQ6mJsjuHeEIBecSBO2JxFsNiHfo4LlSpOvyxGYQBShW9Zl641SD8zwrrYVgRN+ORr8IACEOO1jCKU9GsMhrj0kR3/BHhksgkPCBAYCDQUEhlVMrLOljGAbRMZfzb/olQMiimKFiZ3nzr2m2AOunoYN8AN+ll3xarYMqvaZlFgCA1HGPReoNr733gHfGK4xTiyF1t6qN3CyPlTMG8oK+xf0DzzgFKSdJT7fQS3BBLaCCNTS0xiFZ4V75C2Ff5/wDONvoywzgJZ7poN1CknIKvlSqa6gFZqonrtqg+3kNzMeQFoc8IB8jc4WgsGIpLGSzCU/QGWRJEdgMBQew1OCUKqCaWrJDntL9ugfnz/gQhOITHyg2ArcmNkmHSznLlLDmhYeg9SFMGPDk/S1jKDhykQt22rdL/JyEqVWFHAC1D+D2sMyyzCnz4WC7UbaTxTumffBHhGWbUQZkmxiNATAM/QRIjoVYcljT04APOc4y4OojAsxBRR0WA7GpyauFYdlmdLkibgn1sQ4HytnefjPtArJSug9pUGUuaEeMvDGMdXHOYdEIhNqS084ztw+VJCBBUyEvJOP2/7/Vs6yA0smuRpVtWR/tjH4Qw3whhVkfBUBbztW1oFW4LDpMfgdiH54sgRu+6VkCuIIAJ1As9JGQWs565fuOaALtSb1o1nGHq71JGrv6b+LsNCfye2q22A8tgQqf/OiN2d6/iJvklxYXvHEzsq/O5Rm/4bd2Rtx00dLJH5nLBs6EQUXt21UPi/w953Iu6lcjR8l8KG3VUhJdNKfIWPhI3249HoDN1rrC2VMEAxUvZpxudILeh2E+pMGGFNuUmOqbwUQJ8Hzwtfj+JNvbqJI3R7Bq5QHiHGzXkQLI+JbCFqGRt6I3iaBsgXR95oLVw8MLS4NfVtu0QXGEbvDgQMpcLiWKClgkDeC1ILuEtewKq4jvLu77JVe5SIbvSUXCF1u6IJg4vKADuISFkz2kATVQ4LSE9zxEjLIlooJPl4sxCrwXQ1JbhgUj9o9+a3CO3X1kjS9Qsdv1ZFIVDm0tRRTle2Xtuo0G9rQaZ8SO4yrCkUJwMfqrDtKKKnkcZqT+G1USCBn5g3DpCB7ADVDMYOlgzLvVWOXX2Lquov2yKaoWtGw3UK4TUXru8bns4f9o0GcTVDmcW4/2cQVpOhiHoMSXJ2GZjZFnqxyWxEY8k3/ll3RfdPn4zlbOuJxTcjQXHXSryLPTuaJ/A+FUHZLpqXfCLJ1XvGUgaen01CyelOKF7cQsnFmEYwKs9MAR5iKgPW59hMjk/MYh0eRwAvpDHtG9ubZUnzn3ctinqVk3cZocStcEoGh0rSyRguq4Ld5H1IderTBFxGz7h2begpwu5KbuU9+8I+wZ7liIbq0xsqUX2CSHjXzx/SMaNbqF1IqfclwCElALdFvJkD5RKdPmfn6JBC/aXC4OdfuUKAkkY0p5Jh9vbUJkt/nZxxT2c2uVATUmi7gTe0zMM7jmSZlI6JJ8pWH8rvmkErCtNk4riu4GoYOYAfgWsfIQbpMbSdruHVUQeK7ZuG5HDH/+MCFP07XlK5AMIYpE/7hYvD79OpVTZD2Nn5CCTgfAPlHmu/nxiRXyyTju8F42Ew8atsLVGBA6GA69qI76vuhTMl2rIagIeYG0MTLLDMnFFTDLGDfHrRHhSlQABf5+tQcouzMIuIDiXIP42EwaD14NwnM8BMh0D3Qn1IGQdHAgVsarSdT34KlYd2+UMLMf9JJDidQUmXSrg9NJIza6hvcJ58Kj5Gog5sc516OtWRMnOBLSpB7XxV5V0rIHXCm+hijQZANcZraEaDGpfJK2JSZW00VELE9qpKglQf3okHQHbSJ8jzkQ/6gHH+WxDmapQ6mkAsfkJmRq/GjuoHLXQ7AHGARxJUDY1cPIohOhcsjdHBEXHjRQHK9i9sMgu2eifYb1A2SrotSKxV/JqoFtZh7AM4EsuQMW5DO9yfxIIOsUK9Xv2xoSOIBTWxGZcxs3XryL8zmc/G7ZYTmqP0A+inLVD4uD1F9vLjeWmVXsxozjKzpz94PKPrPMvK9TnpgdCKH/0htGdCkpXZnSNWpceKn1LI+GPIBJ1mTtgzIbkHdGGtspYimDeKsFLCR2qy0EFDPnNfyOZHIkRPl78zrn4fiUOOEVYhmFtbfmBy0WuYHEygzVmpoHuA8PkUdc6MJjXLYRiKlb/9BLSfgKr9mX5qihaJFv3IqU4aszKmazE3N9ePoPasDtOp5ckwVLLui4VVLr6LxQIJNWLdtZYOcIi2aWN/86phQUvU/kTDGx1j7VbLiiAcm0tjqloUlPuynX/0rOfHAUdUc5HJ4U8K9bVWWLSYemOjuV7yPNORVQwOvjMtubmFi6NkbaF3wI7h9oJcBkmQICP9YjnP/qLfOnRP6PtWSVRJdauKJl0Q8VkwK4dqXyACdypqWN8vGeHnC1DUGhrG8uPTosQtGT3LE1LUcmHjmBXTghhdcjqRcjPMaE1BssA0kIcPydMnO9kzzirl2z56QL6gXd117TyIo5e/YxYf4GTeiwUsO9FtAAMjKsnfwHxP5SkblGy5NB5c6zPx6S1AVMccTAvZqcenMaaZJ/TSAfrTpQcGo9vk5TRMQBOTsDPjVBdtN+HGWqWbF/2SlFjp2s+qZLNqqjRxw6nLYbQCA8hFSRKsaMOV2UtEJxo0abEGPWaYzK1ADNdVDeaasP5tqFOjc1+mjB9DAV/AkucPLXHnsPy/bXsfIfvC4MAMZQiyJZ3WfaC4zzB9SqZI3swIFLqmjuC6qpjBgsH4b4yoo3fnZrcFkwIePwul3sA3k4gmtZxigxg6tGKLveAadjeQ+oYGqRkXA+j2ViIo2p5Le3OMBuDe44jhUYydtw1nohZtstXEOlZqyTWTwH/Gd4URIZKuRvs7uf8TbdhOLRPNdLj2cP5lIzovrypqmNbX7HV2rDxAn65pgN25A0t4rfXkjX7MBfIvXMDQYKrprH7AkI//2jXK5XnErqUqhKxv9fZejFo7/JTz0ddMZ9j5IQg9U9Snj+h7Z8YTxiRu2XuJicm9bZukHDdRfBmpxgCa+IgNZaGJgTIY8hITi+T8LJqWRIaUmZca+COKPNlYG+uxJSuo/ngwwI0USAX7VPkboFM5Z/PGfF4SRpvmFRnHS6afJDGK5kBOoMkOKJ1lg2EwoOzoUAWf0DWshQaFK4R7LhEs2OZAqs1bsmEUNaGmSPAibQJ18mBwcZG3dfdmXxVl0XypVNzOqef5lLrFL23CxQjRfL24QezEvyIzI7LXJrLS6KFrGejatJvzbV085Wct5ZalbmTWAf//3HTOw1305GG3s3K7aYU3sm6T5V8cVK7SHbWCI83NMC9JBJEz8IJBV7n6BHJifDQ60e5i6lUlZYM90ziy4gO+1mqdIPFiOU9eWvN7gT0CdHA41kbRmoD0SY6dL1J+JD912kHmJceQ0MgRoFDRbgvMUeySCHNozbrB+hcaPIltaGo7Gosc7vsFl5EUnwlBiLX4jcXzUvFp1kdQejcxYXK9WDlBRK/M5EQDhL60JWMQwxzcSNdvst97LyivsbZmb2Cq8Cb0JSaYmyeKBydg9SLBPSdPOGvdBN8z1/fECpzcWweI0V8lQe4RYokzGYwBK/mqLBUHnilDgi8HuwbfwsIRavRXs6Ql0sZTBbzPg77GuGVFPjmPas8GeHn8cHPEI3B959zL4rYmvAgvXEB2hMkGE1wbJzjdr32medTmuTYkj7Wn/o/YfBWuefZ9/pONqTRYt978u7Rx15YKz/LwdBKvUHz3liuuky7Rrh9bboi6SbWXppVZzlvd/OpgZe5zNQ7fcZy2WzHhB/c0/P4TlYC9jTUserqBmfSJGqEBOQdNIAdD3MVVDqUEvV4ugrFHiaFjOzzNEboa0vAsP4OSMyBMV1IKb2nwUYO6XTxTzNJgSJAY0Y7fi7Ea14IrziTEAmkGH00Mj15h++aDVK5l3oiBQL03PVNVTraIEzzFOUqHB2veAjF8XX36MTPMf4Xk7VU8h6TlhsAy5lScdFCnCwFbqwFi+MyBEoPgD2/NW5tDp2+99AFTdIivOjChx7/7pFJPXtRBFMg5lcb0LTMPNIGuZREN1Pgz5JWgRUVPtP19GFHLvOVejBzIzF5F7tfyRgqlUYN5JBOYTRDtAs3/74MInOOTYmRwdI09tNuX1RtUKWqYtTEMUSwyf6tVOTFrFhiL7Lzz1xtt3UMgY3e+ES2KT1q9AbV3w/MiV67XUxDML1gzxdxJDtNCxfOBXbmI84RlsYITL2Y4Jj6ED4emCx22mkPojm2FoNSVGLlZEotGKPomhCjaaQ2OUm5m8W05GJB80h3JOt4uT2OMqVXL4Ts0h392c23GiP5xY7njfJx/yXHRznNr3RUOoGTjpENOkz0X5CdcnErCVRaBnk4Udy1V8qBjs5QCTQ/HyFD/wfFcWI/ULPRSIVaIW/4rnXv3jjcQ8YZMfIDNxEsNCNuRH/HDQOcWBRGNBE0olmv1L9AwyX7KbMx9Scj4PHPw95qozoksR/4KxJWlW/TzjGMmSAXkGplKibjHRLwHOViikXd1sDxK4qhE8n5SfsW7PhPQhjVHAlkoAhqWdGJhhWlgmFEKzFmz9sONEhCi4K/SEkBimAj1K6bf2pAH+MK33WxRadNVxolftbrwOf2CpiYXu+LOdf7v+OEZly63g9Y60dfErZyxAWAiNbW8uewfnyFkpdAxe2riw1YBid0qafVa9aAO145smytpx3SsLtTa23kGQn/nNyGC7Fzxh6WljY4r9qfTPhRB0tnri05qifEjrdkVMlAUZyklflcb+piZ2Kl6VWHG4mvMhoTFa544+dN4dIOTKbBQ1aJmYOnoh5BAMx7mwM+OHDjVFUTrJbhwvgBeAQtqTnptqtx7qQeG3kEJ+SdB7ClTeeP7HGqzo9/4TNNniyYuMhsCiIJ0trIHf7MSI+X66vQA+BIGeVXsUuxVTJbAGTqr3tFZ0Md07K298xobS3dPtd/FgU15QkNDzK0dhaYP1EzNd7LBvwgOwexbH3ZTWSX59XKWrDsm6Jnz17yV7Ekenhg4PXvhp1aX4FnrsiMG6EazstPNId5Bfeg8dh/rkD+Q1KPCqgK9Fr5kgHnPDXtDfAKvWFWguyO7ksC6MxyRvuq6MauN2qJKgLs5T0k4VtCrzPOmoPX54du0e0jpxdd7Tqng87l8PMpUQAAgozBQSe1+shE08R2B1Xo4q5+8C74R0myKBh33IVrrlXJpkQjROq9P34S0LljmkmDYxSFzUfvOEzM0WYxk0TMfQxHr0IOdCalg7Pz5AvH/wouOTJUbu883C5Jc6Io8DUSbeH0v7K0yej8NIPmRyD0XC4tp+WUHyOF5+QgF8ddtYB7+eY9POzYBTwC4p+/4hvrKd6qScChgHh4OZljcIb+guu0VPLFpNQjLioaSAggvpj00BcHBBEOr/7zQHJfVNJuAQbS6d9PR/zs2MA4i1pW04SCFBrYwqQQa5dbqc13p7P5VgscG2WVou4Y+/ritfJahpw51jT2KLAhuNkU1cSBgM4e5Nk82DgQAY7GxxRfKiwM8IOxMhBZvlfUEXQ1HY/vxpryUbjudB7NqePb/uqmqgJhoFgKLr8/Y/yz0L/lBNbMQL/pXgZPzJYz2B6b8k688JuJfmVjiaBQvRBLRWApcXg6XkXnyljkm/ngFsfvwYFKfcE6mC2pDzHkf4gR8+PiyRsw3asE/7s3uQEbvwTH47kCOacXBFCHPiqCr6DteIln5NrPfBM8/jYF3WnP6NdnkOSyllbBWN4RKjjp+KOqQ/ZN+BVY1DOH72aV+BgcLIcVj8mrHx+mCJAkQjWIIj0YXo8Gw1d1bq6b93Fk/UsKmJP9i/kGaN6JO2l6d1PFse7P2W/ZDAN/b4cL0UdJT9yIa1Aym4JuS5a4UqVgKBjUoTx3KIcO1w8yIl0RDHZ1qAg2WjJfFkOgAHssfkMI/DHglTXhxZyxL4zNbzRP+vZkMfddOqgZYtYsoxIhLnclKQmV9xPkZrl/KZbw2+WP5zr7HJYT5O2As3K2fOZor/co9KPDt+JZQhH91aiA+tqHpHPjJPyo1rE6bSxh+uMjSx/E2673AUKZnSUvnB/1ewc8ODNqknMvma2NQik9P/CxaP5lP9OH6kLTdZToi9yMYJn+fJ5JxgaEV1r5pj4MxK+W5o97T46JrfoQ+Moh4hvXUDa7rfcgiDUsX5y4+vUPOK0ErnwGOOce+81tpXF4wbPN4dJot24LQ6aQZXIJn17nCciuE/TxVP6gcKe55d4MVj6ldbhIiNvPoST+zMVO7cPk7fbvACs+Uc7ZxoPgepCH7bwXrOL/Dfpr3VU/ZBi/VYrKOhiOZFkLeeeR/AXUQGPlSmcl6yAnvhOEyTgvKMaesFfCB7D+J5tTNYJqYoLRzHgmGpeHcfezoPp3p6CqZiY+EMB02EDStkVWgkkcXh5BLX1GVa/W7rNGjnud5QYN2u15niuaFJ69fiB5GtHBt7WnNkmuL8RHGkBxfhQcMksXJ/KjH0RDcnWh63EQSatymZAu28QovsES8dVaBv9vtYFJr0c9XZr0I7Gejv/ccBrcmf+H8j+Jroyby080+oblvzvQLei3UNWXm5QHtRW0hzsKI9p7QLVwuD115poXyodglMHF5nVZrBKgs+ykEBmobLNPT5wq7duhYjLUbmCrlVpHy+wMEiQrbUif9nJTQHOwO3dkC9gd84vS3katUiCfTTW4PbllF+tzICw4Ga3f6hMjiYvnRyIrQaj2BSBEWW7L3hOehVZi94l4huKNeieBoXpXz6WxvOCnMumy6mHBgko9JRoSJAu4CONARRC4utxfNH0Nc8xQjfLcXvKOpbmfuEMjzxU0sw3q76d6RQADTO0Ugw2LZijrFWjTIis0obTau3j9JKXgDlQnscZ8w/EiARd8JXoSCl1PO1b6dWEJWykyCCntHZTs6F0ERhkOMd78thsmPueFaxwFlE7lEpbxNLnp1s2IC0DYvMJITGkgq7AZxrokDD1o3kxkis4PVhwYC7DmB78r3yWOQvfurvYNVmeT4uWUHyYEt4ZM8KsE9YAtUotwq6XmfKJVps3/HsoMyUwfcTWvsEG4dLcvs2+gHY1zP2f0CCMEKvfTvN8PmJ/ywhusN9My2JxOLzSBjvlcuYCGwpZNvo0fcE20/8y4dt96vRXEnoR0+gGXoUUYvNKhZlEabFgyNGwXasLhlCgBzEoAQZzvU3eBKn1XxMsSthxhTfEw1jgOGEpi9LKu5OND2XtNJScY7EN1+2t2JXzpfKLAVYet1UH0WgJDOnyKJ6JStqGLXovzWtJYP5PiRMi0aF2fb/NUM8/rtrVSfNEI3kc6xjCfkos7M8k6mhdmG7a5C+WZlrv86d4ybE/Bml5mByxd2gpx29OH4OyFw+lnVV+IFGzLr1unK78/p9kcO45Sy3fXpHQjKWN6gZ/xUvHam1u4eo3+pWh2NCU0a+ZOc+G/BtUnkmICUr0mjDY/q7GPII3QfgX4uIhdCCQKyG8KkxhKEFe5ODmARAfImDQmiTdhogC6PQ9rrl7Tt8uMhjUKiNdvdY2xPCUbtF+6QsmjoM7x6BLArNB9quz2s2TGpMJYDEbsYbSGa/YSyhCc/vn9i1hwDoVmhDzeYKantXOp+7Bd2T9r+lXFsAw0hDiYW1oc7EtDhpOfh7N0fObxEMN0J9B1JYd2r9qtjqC0N6ideAC6Aw1ug0WoWqInzU6PfnqwQGRnW40yYY6nTNvpxpPXDIVG2VHsyyhMU6pbNG1C6eybWghh+wAUiAjXIFXD/oQ7t1uUlUgBZFMJ4q6HCUt0LJRvR08BjjIN/QgCmyrFPldIBnOWuqQlQ5tfpGVwPnpBlje39xmrr5n4anRrvlyT3ZAAnlP3OKdYKaDgwi3YkeIh4TD+2m6yEHC76iobDwRIIERLkqKtbTwyUoH+caKXiRgDXDPmLx8ZNDIlAKfi/aASy4ZEFoqQOnD9pyGZZithw4FTySSmVnPls8SYjMmh6956jjz0tUQbl1PE3QnKo5yWPvuNsKLqwv9eUEXUqYJtb0zFRiIa4+nfxJLgJIb9Gr7dZIqwpAyGQmozV9x0QWdVChmBYv4hmTXrGaS6cQjtikAUMS9PMfvn2162cbWAWghyitnnmn2qmF5ZwX0SMMtarGtI6idk+pcXY1vdH6sdHPL7H5/05eHB5hW6j4Ged94VSgo2ZFTTvsAKNbUPDYraThHi7xfAaHLoC3jnauHqEmUvdn8CSGg2NO7kAQHDvDbFg/O1b0qze1ub1kSy2qB+83Y0yQ2Ef85BCDlTa5q/Ukkuze4LlCNHDV62HWSOx6VHd4o6v37dbdzpYgcam3tOGpUqBPTjfqlOUDiL9nVpmegO1UD0U4SKPruJQCGyUooBQEsoHnByG6tPDjZ9u3W6TjZG/kgEwnc6QHEvRkI8j+RoOHuV4/plXXhzJx1mZtRSExHiR24a9cv6nKfW21bzNOuTqPdjjWsDSkaLtAhZKGaK3TyHYNMiHK1Jz2RRduj2kM4AfUw6zg+UYltBmGKrOpJW4xtracBlZ4PTsUI9BFtdberjXctYilHCKLLRXQ+hdCCJ5/3xFGxmEulbB+GAdSwTciOkhtEXBYJz+sWGgZvyGDXE11yY/RBGSHdcxL+WFcAis1G8r6vKg4t7QnkGDt/FEz3HbIDYkYz5IvRezcQAi7wKm5w9aR9QtAiDoVa+ubW8qtVDPpme5pSmhizLqVg/Klx+xb5Y5aHE8PpBWAjULQbZlVouzGAWdPE8ZaKEu0O4eGVB9n5fnH4Hyj33d74cLwcfnjcRoRphYyTXSXODN1KSkNQNeLbTPy59unw7YJpIwzVJhoQMW9xIE0d0IB8RDcG5SQDO52ZGEW100WLo/ZlmPigMb7Yj0fno6qozfIEXceXhqOHvSF9iXxKeZKbhatryiPr4e3DKtbwLjupf3mp6VuX4f2M2mUFoCYpeSacgf6ENzZ5jJbsdbiBmgpifp+UweLEJ8AMmVC99Z4+0Wa+klPqNS19ydwTKbAHujHcerkqWW1UkHzbpSqqjS0Wk5/HALmaTZbrvL5gxBig5t82jm8bcNgwFwsugwqTjY7HbRlmkPKwNq/ZE0NZsb9HitiW7KGBFIi/4HWS/5gJxW+wl3h95QKEOZp7CUB+yGpJ4ULyzcBflebMPDocvvBJtyz3QFCAr6Mz1Gkcu4nuJ7QTdg+NFKmm1rwKAmutK+KPzUTB5uqm5Haif3BQgl0SKiaSz7garmw7kLFV53W/j4bs09OfCbtsbmc4PM2dBsxkjER8B7GX6dswIrXeq48faMnHfKTR/xwnrjn9cfjD7Rnd/z4zLPbhOUmvEiyVTRiQ7Kl/Zw8h/6CgmtnqcdvthwyzgNqOGkkKOSArSlt8cD8jli9+Obol0r5VUxR1G07KOT0pTHKwOVXtGO6gC0DdsDn0JomYrm3kfQTZpPkyBqJbb8zu/L9DctEewjVBqXmj+88zUeu7E53r/AUwag0U8NleZZar/xyCysMkBSVWZB6oPKzopQFW7lKYsmyTqI7OOabq4EdqUnuIoZ/uMJkDWgm/SHoUs7HmabAjfhLgWnfIgBl7jFwP1eANISqBYLDwHOwGhCgq6tl/UbphqBCh5ZHQiDwZWGi7h8Du9qtnQBGZdb2EW/ZlpksYjLIeONh1qHlagJ0y7FCtzh5fXBcQ8WAAWdvRd1UPYVq7+2kMBn3wscJTHah1eYb19SXjKoZmHbfvncgyggpCdoN8M/2ITjsJPCz/1vXDNofm3dGRAcXbmFkVbvKQHSHm935A8XA5HCOv95AfhmYpUJ+2Txebav98tv1zedGwlp0afcmmhewAk+hgMgR+twIK0brDF0RTOzmh9ZM+j3eoAcKe4k1CB+IVdjaS5kSdxo4BIWHToB+EBji/aloEEQzuLvykwQTEBb5oIp+XsrsCDFAdSHii4wf/HXE4+0vTGNTwpxCE6B5UioVMydJgdck4AIg0nS/HCI7HVJF5NAxzeRuMCuzQlgzIA7QVJo8JhRS8cunxHp6Uk3qypORB8FyqaZb3JODifg3y5TexlpBQDjUbUKs52zyRgRBxMQSzEHB6oKGyZmV8/6Nec9CPlCxmLPJqAfsTPDFVbQcJqEZgQx0hdjEmUP8HSNhCUqrpJafTKQzy6c0MwoLq8E9TMZUFldJ7CgWipREMnYDQoXpjXjXUrOyFa8Y5pGRwq1gx6RvFsm+S6tXw1YB20dJqESnyUiQHZFbMhw2LE7sVB1DzkDFlPzDAmpMLzwTX6n3gdrG3tZV6/DVElk0U1oFvYRg0jgV0UqCyurA/i9G+xS3ELBbq66UmJoORM5yS4j8jnHbvuMGSlwlMjoixW8lMDyI3SuFLAIwUlbk8TdlAORHkYgRy8l0ZgAh9N4lwPMCHYn3FzDNLOmBvGwVM5Rdod7KwFBAAdRbDSeP8S86EDlgIJDaJ4EDlm2gviIGp1AsCKnXC7OKCRVscqgFbv6LXalGuFge1q8VAQxzNGceNkMQdvy18EjsRt3SgTpfxJI44MwQvavohvl/ksmpFRzJgPU+dn3m1sz3X49PP/n9TQzhzKeuKhFEzX8sH0pmO2BnoDFZSm50MxIsb+VkMqFk9y/Lnqe9Fn8fyYIEhRFo+MNRhPzrenGK3pY8FUE2cuQQSGSfc+XDxZ/St8BIAVRWFD7wRkOdQG3YN61Z/RWVEripU9na05v9Y2/IeRX/vfN8f69NUwBadlw3mPs3BzHv+W7PkO4szDKunrNwTChb4ZSqEv3RLeFVqmNtINASJu38kP+FlgTXuFIrKP5U4MOey9W7s/Sh98dHBKRKk8/iqytnpd5N1KEyi950XmCNWnSUh+Jbu8XNRCH8WqS2Z4llHvKzLSs4osKFFeoGIo5/rnjkqSg7yKc8jb150f4NQnr0P4amMeKJNazZcdMW7izMkatwUVDLVyOz5GimLrgLSYwD3FiEQeri46UTyXFVKdMNCzk7K+1dlSxtgRM6LIlrq8sEywhwk93VHZdDMbcF10c8uMe5ybKB2bfBLqwo6ySgERMgC3Lyw1Qm7yAnpa2NPWig+/LA8Q4Fg/R4hKqbhD3BWk6RXh1K1irn/BOrpST1EWfkg6lkGg/33RFJsrEM/TB18hlagUQ3vOrjZa9gyu14Gzh5NQ0GgBlVG0GpYPhgM7HShKU76qXbGhTIQOZISAt1PY7GHIrBL5728lu0KslSTaiLIr6ZC4kk8Bsf1tUsapEVbaM4ViTtAW3Z44a2pUhY5VW/Idt/zKOKStJe/fQvkG/7M/kBW+5mISq2JrmHhSZTD7726q5O7GIBFFYenPw2a+G9vP8J/+DfSvr+201AREiFFqFrV2mdkD/+Q90LnXh+PajzRQtT2uH+Zuo+34EtkiYxxQ2PBaNGuvriJMzw/hGTjhAjSiaGruxWzYDfxBnT4FHigFnY/EfT6Pq3/dkEyzKqFruEvGHhLRCZ+Ti+WKWBya+udJnnmg1Ld3xDGy/SXgB7bOcOcaiBj/8rZCpmDxjnWZLrJ/TXMe8YclPF8ajVxJ9miY+q1oQJznymnBBIq9uLPNhaOhZBW5kkdg7SA/SsbSG4AdOdcXJpTOsgFwVYLRII1eIiZ7hQpKguRac49est1ekx4c8MuFQRX+pXvhzCP198cqE1Vog0H0TniJw3U0hxv3+FBrLyFLdoiQUBAm51PJe41QWfd3DLECjfR4D/k0hHTPDChAqvjBErjz4xKsi4Wq/Yb0Kc/HfYj6WzP6Qfk2wSQRoHB9h29ZIq+ipo+QcTbK35dEChnhHXmOSIPWT5oMCV88XWCfSRPnzcPVkj8GQJH+bxZcVO0656ZvUaLzdS//DlagrjKj6Lc139+G+i1DjFE7i5c1T459mV6xjM28xuzjL5kADeCcAo/zhx4Mgdc73vh/+P0Xndq/Cg4uYHmX3wYoVuftCvj9bArZ8GgJV0+746exPRJfCiqOMtUKVskxuLLRqp2c+EKHScLwWijdyINzZLLMMfHU4zZYUz5srIEEVbTiokNKtIH1QUCxrYdJvm9YUHzU2+OqGGqlTpCMSQXVKRzZfd93as5xAfKrmtMx3pPtXChftEOo3Ckp8r802n3l/ZEni2dGwFWGNQ+OObjCjjYnkp3+XHAmQjsDYSvKCUXNE3MbciuAXZ27fpF2QLFNofFKVNyUSO2yd9KGT1zqf5RXnOsZcUZJyiJgmdhHqR2dk+BiU9U1nHcEBC+ENmZ2RwP+ERUycTO2JK/0obfIp3TEVVqWGeCImyeaXhj/iHTmIIgTc+iYGDRcJfyMK6FoslNeAzLFXCoH/mRpAPcxJYO5aUBNkSuSC7aokv9UA254rmKqtiVcr4M4aTbgcN3KiCE9CWbA5CzkKj4E5LJlS7suOrbfgVXmwfTpKU8isVnATZkg95jzBV4e6PbCgbZHKrYqXJ66fmEV1SOYbZzunRg4zwYH0YyPRILZcDBkdU2xxZDMQRqdJAExKzXiZrF+42E3bVcGYMJmVbsff1y1f/vMUnFx1K+MY0Yq11/pFHMamoK4RfRcMy99PFJYZZKlNFhTdYZQyw26HmkDAleXYiOrD3B1tVW3lNa5slPT0px8R6mJvgqFTL0RRb5cAZKAsCRjxjm13SIQPcGoLW+WZGddtWDA2G21pwR/AZWT/KH3GjI6aAlUdafYVVxh0LvCidKaIqfITYUE+VNqpmcvEBGNBkcOH5MrTpY9wiaVuGqYfpfTMVP1zLTaJObO5XUToY05szxaoNf9bqgwHn3RLH3gLjjFj3w2ABKkXWwV+3NH60CltDiyDlZB9VTNiEdfIXN+MiNsObGFaiUXNzZn2bYF+Y3gWfCccMjjCnDB5BH6Rp740sf2ghZZrehnXJNiS9QtS+LkVxsRjc1RD/K4ttlvjTtEitm8kP/TF/l9vbgkzgFhFFzU2HOB4fnEdHAgp3CZopcJKP8n+JZLKIWSuIkHTTTfvTP/OlcDTFTcffONZYT52v4VgnHU5HB/0/VXCnSnGDIuWlT1NurlSD6NQqU1n3LmgD1IkXW4LQN3juhkOtBl7pSzDx01VzWVhIAUjDJ3dC9riuFMYDqboyYrpDJxpCxXfEKQCNQs+2CWF/tzeFyS3YZrGQzfz1lVNkfuWdOKYVeMnX5iNZJQCHVPtDYyt+Vfmwh/ODIjQMha9zjK5uT/STb1aSuVzKgVyLF6kjmwpSfKIvRSVv+Wl7AdG4ZEqzGEndJDWF72beJGOVlP8AScBGMG6/QHyki38AoCfgFUc+BrbT0Ic8AKt+iRojBybQIRa75LojmUt2WRiYGPGyCMvnJVIy2NTJ7tK41u0C0o87JNpqiiCRPUygmYxSr5TJkKZywZiBAmMKyCOYPj30OHqka39PGgasNB9R4e41MlUkTMBwWwvujOoZuZ1L042OmELJM0ty2IoEFgAupf5HDlR4hNjwi0WiP2I8xtLTM1Agq4CSTFVkYwslVsmuKLS9cpZKU5q7yq2KThGZMomm83vuihfSr2cs2i3lDhhV0gQYe9z6pqNkzWwPBYoI4hag2JVFAYjpzi/26QWT5R81W4K3wGRQAnnV92swcow8UgqiQZM0RIxDvs1/eKC7U0nzxFiSwWevrmsJPPPpajps0/cz08BypZEqbQONCAghMtM4ZSjpV6dvPBr9PWg26nG2BZ11QMqGO2XHosmBEvuVT+0PPhDlozlVqL1bwZ5bfSS9FOQitpLp4Xg0JJ9Q8CaD7hjxmvUTG2OnhdO4DjLncGEb+h8YFlAlq0xLRmKbNbYL/moY+2ULyZf/eU7RnhR7md3BJZsdzoZ6oToVZrmqSBDED/iOHcoN+BrMxRFCOVuJgZrhoJlybuZ/r+woQrDpG6TQx9wTZvmaXNXk7j2s/XxGK00WJDJh+aqLQDQHzEP8tfjF96LKzLnfrCvI68skB5t2IAUInJDCjaU1y5V89cf3Z0kR/HS5QLmCKAvftnmUqpaAvvhyv9k0wtmTl/zN8Z+E+14hgH1HHs75/jr62dEZ0+PLZ2QIxplpXdSV6bIPXJWeWNSJ7prIX0MWX2OBjPMQN5NRy2XudgaoPKGerRA7JEhplPNBSk1mlJZ6bhpvlnrvKrZt3fArXjzi2/VX83/F1xwvGWjj5QCcdQT3dFpR09d5Edj4p6haCAOmyq0cdI+E1juic1UHs0xBBg+xeQI2rIgxFdBzbwBJFowSk3g+846f982tvXD8J1yLYxBlcSbxpfId8Gf3k1Cn9wYJbAmi+9abf/nwYTZos5RdeX0ivHpEOPMF53bZvqLqeiUpi09Zkm8zOVkxDpkR0CukuEJm8GEJH81P10+oN4i9FGeTNmo1i/RjuXWvqadpGICtxKtFcC+gove4dKxUmx5RvyxxgGVqfTaIsjX77331xQnTEEEb2iBjSaEkPfirnhlWGEmGPDmQWNmQ8GSh8GU5FwgKHjqT/iKpVWNOSahoef6mUBAqIbtYPwEFOgqL6HxxWVaTf0318+qDEU23pXHYhaz/46J6i1rkpVYkwEvOmoEl3vuSyFJ8t11M4EVAdwXTEr/bWz1tbXS1nGi8nBJCQ+bQCzfLaHSgVayKBeVSGRM25c9AKpD01GPe1TSWa4WiXShCErk7GbnNof7yXeyAaM2T6AQIurcWqNlk2d+z6p7vEdl8sipzAFur/c6ml/Ml3li897EqBWUVtXh0wNM0UiR7KOecXS7qeqY/EC6XWTeCZx5ZhEvYhNiwa6LDWiiZoPsKHgLL/jEz/U3QwR/l69Y1avU2VHZNIgWnjq6fALmfarZCDbmzWcodCpohA5WafmvKJlma+qmlTvmE1W1r88q06TZ+yxjepLHLpknCJPskuxxDyJCRgNGyPVQRhDSniBfKGagNM57MIJYUANsEnTw2EhDY/jCBxO5lsnEnGhyc7ybSRsK5B0ayFCqHhPZivzd95qnvd7SQxbX8SVlOgiNu3BRXlmrRNTbK3Q4vd3M5cMUCgnoz6hvNzDz1SGK2QCCZDEJG1peZekvkrDNoG/Kghea013jjiXd+nHqMSLLD53CJUSOakn0fNkKyiiiFKuNMpa6vqmdrN5Yl6kq7JjlsJzoPMKIQ1ykhmjA288mJJxtUkRCmjLZ6YXH5dM+ODg/vgCGHQRbZwDKrlQxTpc5YsAqe70EBddwuXHIRFSsPMzCzFVzEMV2hWh4i5+8J26mSuCfKUFpibJuJQ8ReKACtAnirlLghiABelkzvziAlaGR5GNfkU1KahOTEogAOYlfaniULvljoacWQejiSy4N5o+rgrheTGpZKDSSmcEBZdATkOsooWAuPbM2/NaZpBuhUcPdc1VXELGzN4AFbkzZP20NVu/0P/ALtCkrLX8VFAOjYINU6Q0kHzcNRLgyADg0LEEMyEw1u2RTYRBLA40rRAQVAkaidrXbUj2WmgFK7aP0LanyuB35kwY9blcbjtk1itUxjwYYQoA6WKeEKL4drqgFgtRmHLr9Qg39DyXyYEY4GSUNpK/sNIg1HQxoWaqjg+TB1hhQXF1yMmmLJU8Sm8SKLHGZ+MKG/bD9YQnVub1iwxsQSleW8UhOhMo7Fd+tIryMDtS2JzMJz6xaHLjW6RR+KjM+IT7KvF/65F9lrftwGf6KeXPtdAEliTxhJ/mN3lMtmCJC0tCJuNlF4GBgqQ24yKea9QgOy4McQbxO98Xc1pA+qvs9Ii1HIrxLWumJz6WFtQG0pIcGAN7U+QLzZWtNhfHn5zxDO5EHzX9qqQONia8M+oVGrtHMUPyOfU40s/9riVBxJCFn+M4SDJk0+mEwiMSGBgqhCT/ZAynC/3w1DGgeN/yN4RpofbfBpTQBnmiHdEpDPcJgsBob0YiuHZmj9sJ0gNf90njSMqj3msl2AyoJi/B+UuUYNu7WpeGtCZOBEhXrOEROKUCjZN9Jv+mKZIfhFD27+besHsZA0fyVzgHcgNS8pa0kiZZzLIw185B+a9/Jk4gs2SSB48C3KWSL77sFJZCGGrlUWE/GEF5+kvvb4xBhx6EVQW3WZ4wj5DIXZeq8bDxu9uwfkTz4Saa4ysJM8HS3g6aXK1ylMxPbb5OYRDIHBhyoiaLt618hh7GhcqH8GSEA5zd6p5kebmMGdFTctOEDJutCezyamzAgxyAL+lplXJGonor6afzJTg47kf66g2rrFzzV2LaSG8tJKRK0bcoavxuzFBEPQI8FAH/l2x1YYPRjU5KGaSMQpXcwym5elo3tzYxd6RXtznU/+SvfmivbWzaejo3trbJ0DtV7wPgPuqoxN1PXGtJ7ECph2NDMkKM3xEa/MSYeHptFrGDsxRUfAtsTxMUB7N/uxg14Rqo8me6KQtN5NoX9v6EkKDEfpdLivZ6kVaUS/9ZqJbEEXm6EdEu0N1eymu5Yi4LSkgF/IUddwtvTKQVrM30ITDoJ2YWxSN0cpEc9SzvgelrFw0R/gTKI2nl7cEIL8d+qQbRrtkINApSE9Mna2Hr9Ix9UADoMWc/bSitUmrQcDn0niJ/N3lfIiBU31mcBxNQI0WlCabzrbv83l9Zt6hnBwgywK7skPqhM909kvz5tdBdLfzvhNe1ZG/xi0l2Y+Fd2lDQre61BNRB4v5fmx56qagLX7TcoF7vsk5jfzX3/g0ATRIsSobviMjAVVwc/sozWBOJ7NFxId/Am1d0MGEur+G3RoMeBJLCZqf45txTcTjd9MPTx8y15a9+HYByYeUDysB640wRx/+Z7MPYxArVb2GbrP32S/itIcPJQWSYzKzOzPx1j78uiH5XHixQCNkPfwt0LYBcQnze7r99fD8T0jvwrOLA1547dHe/SVpfvotNpismcOUzFF299luZDI3O6Zk64/OVSQcrKFY85k+uidJf15UYRb6PeLQHVz9CXgUIo+IZkozdF3lFqMk4miPSQkRvAcUaSd5lQ5Z2YMNRfbs3/9QG4DehEi7wUnDypfmcogXqtQWjIDjnYcRYB/W0wELgO7jGN5j5LJtqsXLxRuu0PLgiE1KJxZcgVWgkRpZrpKWszfgpbIJDHU7yskcB0Qrx7k1oNogGS46T4+O+4OJcTGwDwKwfAHNGAIuJBOJJHbUu7VYWhQub8Jk2PczNT0zfD2aF4e9fpdIvYeuI9B69PQ6yueEdhO5qgykj5DlmIQoo/9W6UM6ZWu3wPg2I12QaE+JGmpGar6T3LtjG1KFYCyW3OHd2l9ityvGDe7yrd79vEitT7WvcYGNAfo7GWpctmTuVKyrn04B8WnQcxkgfjUNDrrsDdD0a7kCLyVSFlWGeLo4RD9AFUG54obARKrMza6gT6/hKxyi8NTHGAu086sOh2i4twMcH/zuxfiDIo8rmyXZkEc9XDxEtFtynWo6eNA9FbM6SEJfyV5/Lgd+KD74HpqbWLnJn9/oXfCnnbAn4NTmef0T8g8Kd1EesbrdcSo381ZZk53b3fTHQ80T6ANUykmemFdSZSlaOfiFi/8Oc7AhFKDfVmuUgQ/ioEvi8CCBM6JwhsBUhHBR1F4zBEITQX+TYDGekBSBe5bFOZ0sBoTkNIBLT2IYwA+SQa9BRBCANmLga1lwHUJ3KlkMNcM6Gpg7YDT3EGZI3gVAwmRd9Fl0AAgAChAABBC1USmmnHHZ0z+f5aqyF7aJRrQu3Tnjv/S+qn7V+/bcfu0fa73jCn5ru6n16vyytUD4+0YP+pnG7/HEOptuzt37pRFz4e7HtND2A2zvUhbdtXPok136fWb2wwHUuYFVmplD/eU8AaPlMYnXLDM/MdAo/xgGlZwgu9YGUv8QJP5hzc2yhGzOYoIIaEmgdCyyVIRMl5lQZjYIivCjEsTJQbaLJdE5UrlmtjTIVviSGfSkxfcZHnEQqfyhG3YIi/Yjq3JiB3YZfrAGo8qX9g5PXSgSPRGBVXLfaY/VJlnlTOqiQP0n2oGT+cV58a1+icaZYZ/oem5zv6DJvPP/BeN8YOJNAN/sy85V/5n/8Nm4kLnY9Ydf3BPlA1v6l7TOslM/SebhqM8O3AbeM98xnJOcOuJquAb3lFOfFt3OsWrB2yng+OZBM/0q9Il1JnuK32H2tddpffi/f8dVxJ+XPO5UnsxLv/i+gJzX9eVlpD3eqwMhf9Oz5VpS+v0UJkcmkyXXD/g/1T/VOZTcM1TXtry5EzKKwpLZ46UfdHhtKX0V3rbT5sHmsrbtNw09NcwWtLqv737bfmdTqbjsd8xMP39Mpc6u9P++ntPdlh/fJvW0ovtz85WdTKUUkp5uQ/Ctm+kh5rI6xoFdXJnIXcqm5bWx8zCnsisMFWxrzMPa9X7onLJFa44BSm1WIM+hMth6ogxWc/7eXARcJAc53zRT9HZzZMlnKJx9l5cGjaXjAD8Mg8lGLZ9uS0tPlzbQ6C4JUNcAoh0mjTGsRvognH9NGfSPvkhG7gDk1NQRZEwMm7Z1bdcNjHDr4iqDqoc3hbqgBVuunVQLyMDba235fTDY9JVDj4mEoF4/Nb+Pjebrwz/2i0oEz7f1C6lfef5VO0XBh0lJihrRZxk5yZj6OSE/tXNaEoj4n+A8c676mKUhVMaMSb1lDeSgXCut0XfW39FIxO7XY5k1vbg6VxZFpUTqSgP9uZ4b+IWB64Atc3FVyYjhN3i4capH9b7ZTkGueJ9nGEAa2OmSFIbC8sPM5up044gZUTeYXDEIgFyKIjOPZnEQzabJ01Ci5H0j0wDKZevkXFvlmY6LqQcmy7y9JBCh8gLj9g7oEM/5ar/Wi7hzvPQTKxNCsLe0Td9MpKkzy9w9/RXiNG/Hus5EhakEYX2eCwbOi98d7VvCD7NjYhGHjTHyxQyJSVQ55L4rPggwbWCkvnN2me27YsfE/Xflw25zXGUWWAZ/V6ShjeG8Yza+MDCW2HmIN2nGpdki7/nKl57FfGGbjK559T6+H0L+oAnls+dy4I/+iTg4zqYpiH789wtcGr+7mysDNpFyArqkNhoFFqhUD0PoXnzongVPQEswUK8wJ7Wk8/aLJsX/X/IYa4pdfiqi2G2d25K2lUNmzK1nlPKhWqECjwUKQvhOLlrPUUipvDTQ6oKKUNwRKJ9AONuvwtXAml5wzvhOacBHKjn+15w/t6LGE6IJ7G6Hj5TYKCl9jX0xBL1D4XANyVvN4Uraj0h6fRp3dxVBekOExGenNtAxGsMJJEXwSnsOzHpEEWqhcTwy4gnIAsy40BkXVrM6dZ4L/8CBJtab4wL42dMmSMvXGyUTv8SMcwx8jqChSORbxg3SHvc7YC/GaRrzihA50yuCvGecj/x/DDUYfryLwG+YkFWmFvNk9kGiUsf0GzIvY0KuWjNmGEiztuBUJQ3DNuw/YgPTCITY8JIb2gQAK4ilKRfSinBnKN9D8JSDjv9F9DtMpMIHmlBU9wJNvoynL5E9JBo1CWLBB8XpZPZjQdBzXrSKWYOVqiBKk3odZ90DALpPQliO2dTDGu2hjwVE4Y9nhVI7ngMPPHSeQWLKDFZ00VGFUHLyx7WDcrIIjrzNG3u2rEZEuFLf9+/9U0JEp1B+xjqFSSDR7Y1+k527jqWZyBNf90sSGUCBNI3nz1rUwvrKtTpGfGMq5qy/xLW9mWUPBORQEOozSQx/dQkizeMHH3CrK8oTncYhmFY1nCPtJkUxDhMX/cO4Y3ewa1dtE6yORpzeRxEm1P29BMm8jkljbBA4qNnCHte+8xes94IuO8Qfj6oYlJKVzhUTeDsNKDNh5Y7z6noNiyrS2/96fTr+EybYlw8ng2nRMKUZHO4HAGX81B33dzGMo7rSZbeA6Qp0Cm9ih93c+k8YayMcMaext21OYmr9d7ylrDlGbLtRVXs6kGi7y23bR/hksBpyeV6I0PoFYxZZJ+O16roTOuYg3MKPfebQrgNxD2Bj4VRqQjdh/TZMQN9lPo28jyUd5kjV1YGaGEqByC/WiQ3s2VwHN2G0bKAz7ZpnEItwLParXZv0fGfDR0b0Ufnx5XxjkiK06d0SRb9nEmWcBQ4kl8QnuCs6TkH7H5QceFbg9aPtieqiDuIqHcNlTHewuPl2E3ODphILQBENBQR8mrDY9HsyMYQZXyIaAi5BKYxdyt+Gbr3llRtHbjDAkbUT65SPKMJOBS4uhXoNGIVS2yHXnTArOCbYYKE3s7KHYziKbpSSnVmPUQcDBKIfl8FFlsBTeJkY/3NBsyfbQeEYa9Ixyads3m1OtcVtd2OwTPmTQxtRwtSAEBaNK10pPKp+4SawZydnHMhWGsVgdpf3yMt0xPVB51C3KhoILHJH78q8LlRoFZlB/aR5qN+wlw2/noqd5rb4NYFPM2qxcM73nq2deJ0FdgDtTOuSxDokoQpK7dd6ffBNE8e65ldXhj3n+lMljjEJzckxonrxKULZHzySU9I8XS4sVWc/GY3zYnF/ILXZbJa1KHnNBeXyv+gMEYxhFefU/rqUmYYQGi45AqNtyE4J9kIHQoteGhzkTbhmLZAYdRqjqSjCKnz9Waqa1Og4kTuykifjfw2kYzH/dtepTDNW4JRTO9WCasEBJ2yhqVCMIH9JeTUkYLQkSIVbjW0VUIqt+WZaVGp9dJIEbenGr0h4rftqALR5SfffUt4Otq11G6m+pgprNWuR2Wfg3ID2fRVSWvxv/wF+bTEx7NjJ4MFpIFSoiTVMoHIGDgOG79k79djA0gQAQZYTVizm/ss8zzaZ1ER1ckvwR2hnnnKw2J3wX6Dt3UwSxO0xEcKfgtd4LFXPExkPRme+vU7Nr6dflKRmd/tYmyjTXrYAA+X1we/NJn0GBFN/G9LGwvGqL5XZ/TQuKKd4pcUv1ugM9ivyFTl5XpBB8kYibRNIN5QLg3KawjaQydYv6waROi3lX2GPhudgePO0X7locqqaA06qkeSfMicWVs2GtN/ndokE7LODr1RRgHACcnR9mZ9CtIK08YsTZ2Jb/ABXDXZB2BjPfNPCR9UogTh/IzOEbXdrD4ClAvtq+xbhSali8v7Z3611qAesJt1WlUNhmEYxkR2jonIoGXM9B4SDtUalQVu7nuyr1YgoXVTm81bV3gI26IFG16imK/kO3TeAXAXNcDthGOWc24W2oUfvdCMSRZqFWehqiSUWnPhRt4eXX+vPKmg7DmBXbIjOHNnheoDD8R7VCCS6XAl15cNRxQXSvSMB2xdot+byK9cQgRYyff7WFcovF911SJnjPsXihwckMM8yR4V4uHfMWAUOmLLypxoeuYL5KEXmMmGxFQ8MPylH06Dh5hu3zghVvAtB4+OYcWAVa2xl/xqNfqgyRfgTkGPeeGUbqqSRqyNQfE6qOKWGt2X3Z14SosFze56SJaF80GzX1d3hfaIc+mL+1GQrLDrOZKlK3Lxf/LtomifcUCL3YdFpLiFuBSiHI5DDFVGwCdTvX4ThY+hNjloapU9pkqNypl7bWFcAix2qSKZ65Y+2ZXxE70XLAcmB5jwo93DPQJeNGtUz4ga2LLNlZOBO+mpMI/MafvONijkNTH9eJ3i/o7c4WqMLl3gFZOK5qNLRSSE0AuwOoBOvExFDZTsyqcOVRYI74RXYy2RxE+77BWym2JSmR5wxi2EoRlcwThgtoAb2+H2yQuUsldOPpD6N5QKzoAD4JbDmCszNFx+BhAtcutXD2tdKjBD4B7lxarUDIWNJsLyMx2ntyXcxFTlPXZsUgvfzI3oKveAM8aY3KwktKjrhjyAFzunsQDM4vj/KaNnAP/V+bICkY/3wRKWiXyoBrfwaN70I6ndhqz8Tgd6v7PQteuznSDhIqv252Jt+qV1F1TxYwSJlR1jUGeZDGhPArFP7lVJvMzwAhD6lbFNsKH0T+0RgWLF2L2lwHFmaPluna63sK9rE4RAJBFhDAkL9Dobq6v/zKoMACF/uCgJfSbtGupkGK1C3aT/hJfumESyFd7zhKQ99ujQkNXcDuJtazHFrbByP3aXAWp5ID6CeVR/oe727B1GRjJqIxxrDvi/8CE0DqKkkGBlZtNo88NBsad2qaJmhXIF/Ysd2TVePk9yUzpt5v8QnDlwZtwAtwTfc+BwTsOVVLMmf+aJadzOIFXrj+i08E34ZrR7+VZBe4+JamwNbNZEHFihISejRHhCdAo20khPGqqtzOAjtXfK2sPeCnMQK0tuuwe+slH2nIY0vRkGocuD/l06JVU3/n7wpLmyR154Fzk/NjQ+v5WsKUgCQmIrmY/1sN14B9um+Oq45W/cabvHa9VOqrKuy3uVdX+1Iyeg8d2QQ1Lkd/3A3SBSJIyjwfEBdC2cFdD43/m3drthasGR+N50p6A8GH8H6dSJ2dEz9U80lDdv8+ivlyfNjoemN4wi/ZCaDibP2mMjgr1T/+KlYsgnqDsJqgGY4i7XKtrB01Q7gGEYhpHC+dY7/WOmjdwAWBirOFmojzIxFBXpXc0HDMbRW9N9sRsopY785o4otn3k+NLByDvRJLuVv6TBJmzZPlLpWAp5wtDiRVQpB5hlbBd05ZHves9qOYUMpZiDKadIs5CBc3SDRPBQ8iQccD6ZpP3q5X9Xrketbud46TBGuWoaYP+1JqI6S9LD2Xp2h1GqL/NbR3/emlTrjhInscXr0S4luZ0iCOP3MhoA+/+pxUArSbD8DUPLJGjQhAzY5YZlbKmbnTK8eoSazeDUzIerCrvT24sBn7Njuc5KBnZ7BpRgC1IpWCOLvi+CZFyBpv6WWQpq+pqfxnE0rwcdhwZaZePhRFTPxCaa/lyZ0ihtdEnG7UeTgCd6bbcEuSYJITEMCZq5Jt6LWLbS9NJmyDap0Ffi+TnlppHxle9AvUJOpaSsjn9Q/UW6t/hmmZVEY9H7lE7b21V5EAJfIJDyS/rrLByg+XKwxWEi5L2AZ9UshWef7DAvtqbL2UpFDOpuSEYInwGLyUIyZ1osxf4Alww7XwvdxtWdlwUbAyVaU953m8ryA8V1oMuby52KeIIdruDq44L6pyix2zeGp7HnPKxKMcG/xkZu/MVsX0Qa5IkVu5tn3YTRYR/5NhZ4MBSwcbJ6pMA6fW/z23xzzFEUYfYK4OacmvBEthKjdKfrpqO2J+YN8hznMz7lMcxZIBDqUKp+MOcEMmlGqaX3mfB1pVkIqzC9ivS6FwglJ4bzoemXN+I3nkuAGZ+wX356tm3gc+03eLVE5i4kCWSCWwuG2BtIeAdNROm1SEgJrdKxfWLRdPxY/atdTN9w5TEYFiy1MR3ETRaJiEYHXBuAeFzpkrqFHneCNIPgpj5ruD/FDgcuBB1pr29mzgQmuDpHiZE6Ssl/h+jlulPoKPnZFiiTjlXxbdqR6Xbq5HEk0JwIaA8NlWOjzJ+VEvxma3UlqSJLCCsK+y8HZ9g6YOdWSXAHTEGzsZHD6T0bh4nXBtxIu1hvtaCWjsrc2MWThCQGfK9RI25Fkb1ws5wslSoIUx38ghBkLBVFXAcHSF5NFtmFKSDBaLru9b2nv9dEkUMUi2IHOQu+9h6l3DYPRMUceEq1KLCxS18nPORyCr26SpjFspeLCPN9S++zdYMmTQjiyX6MpkksslzlBnttJBZvOqpGdeLxkPIEqZleIfHJYDsI/T2A1UQxzInBKPZyPt8ttZz/iDx2IaeTMnK2d6nkQW79v4mnxaPL9Xutj5+rPdZk7vJnqW4kBtymAk+HUGUOZOHTK3A/a33TqT3UF+mxA52ow8tnf7Q5lmWmEN+7t4IGc3mx63BPxT5VXg/HC6BsBAGmaYhKVyam55d3i5e9IMnHiXISEW0YhmFYlP25iGzwVlcHNcgXOS+ctJB2qAfGfvWjKlWjnj8vxZjn4tL8Bq6GaqT1tGMmxOdO4Ig/Giebk8U5UE6F8nzZIduZhrotvAg64R7kSjr3oI7QErduCNZDt6Et8X3NYxLTISN6Box0vFrW8auegAlfO3nSA6kX244sk2NQ2EKw5hPeVRDJMBHkYZnKt+gfHjdFnTVdGWoQEcwC7YwO+Mx6wtm1JDcv8iuz47ZHxjjbA4PiOpbjAm5Qe6MFOvLy1NBeF20Y4jNLt9FBJ3GT9rQ9ONxtQaEAYkwn7M4CW2M0bB4psWN6iTen73DuVeXou1bKJBMe94mEciPTSfdhBBUkhynPl117T9H/G3aZrcglsXMy5HSB+ga8kdD7wEAb+csUm7EHaGympb8Ea2JbMGsQkpMgWk/FIVfrKYEfNkNOl2bfI4k0MfX5hJoUxp8eaaygnMlCsml66KkD+xXL8TBnSdjrNVAu4LJ26kpaKjmhEn3jTA8mA0L/H6BdIw2QLwkb4gxlayEfpjQ90rBUDSVC1i67ECZ895VQH7590kHmNevdC6m/M8VaCZk4DBIcQY+Nn3nRcWtWI6YhszZGh40FSn1UdtsxXWB5lec4KUQ6WPXYu80tPD0d9Z/kYYbJCnCwFSmm5DC5RDnqeNPd9PihWN8ds8krOuZv5pq+k8w7XlE38CAT/rwUo9Rlb7r20P2nEpqrmzWPSYztQlzsPnkOb5QcsmXgM+txIhu3BWdIm8MNFcQhjdGwuXaq6qgZe4A8mdNsT27kL5MG6blJNBnLspHC+XvHw5zFK3vyGTydvFxmXwMYB5nXLKVh7bcnHEUA675AXCQrwEG4pz/jCN7sZSklv+775DlcGwVVD8rPmcoyKkQK8HTy0tMVxKMbU6O3m2tPw2xMjR4EoZr4OrFAfpPqOvTFq79oKctx/EOkv9ffqXmXMae1Jpj6zjweo8QjkoMKXmmU6AoDUe1A8eov4NghXeMuKFrV4kAW4TlrcCVj5/+FA0kJPaKJS07P4dn5IwGVqYy2fmbUc3i2gnOylXgwxEYVOcUCkRELf8xprbk0rGpd8vCui9eT3FJ1r1/vEc4xszb/+3zuHP0kCaL1gCr9zpn68gCbGlnMq8mx6K8zXB3P+5DrVtJLucQaJbpykEfWJ20S8msFloM/O01JEJC0K4vEHaSNKDdocWH2rjILE7pwi1XMwHKs/9nKWZ1kJ2Fz1ItG2ffxq6SvC4pWDSnTDBX4mkMSFOHvZ8u/K6AJcj5C+Tho0NBjkMgRmmp/7To0LSAt3+A8aCEyAuIT8S8LaYD9KvyGHokq8EBSQj/c1tvbMmMPTpuofdQd/e5rnleINmriWvogjsQghmEYRnKP1/EVJFmUXQ9tPpV+kZVhlBbCKNoqyYek6KX6tGt699lPFbjApbtsCCmu4wwo48xwwE8JXk8IeWJ/2zsULwjtVHlZjJZ5P6loduiIC4YD9KySQFY7GH4ivlUzTsLbdHq4VdKZEziv1TyuDJ/LMq7pI2f/wPHB+g8Xa14jQdU0Y37jfiVVSdGJtUTkl7CkibBtB6fsqvn87M3VMQ6RaxtcaQbOO6OepZx5OvOHNyOwRhv3m3sKVWeVwpLQ2u3z/x0h+bjgJ5RlKEOC5/r2nyaU99kzVVZFeGCqxmSr+rYPq1UQQs3mqvK/j/zbn0JnMLta5R5kUULhBO0WipJHm63Grh58zv8QGYGd4l2dsGskk99PZu3spSEpDCkUbDECU8lvyGe2aMUov09zKzYehgvi2AjaC5g0vQRE/9s3Mg69fpGesFMgEF6liF/rCsZb56W+Vaj+Fjh1GDguv5j0OJZOHG9hJtTjKgoAYX4TSxgbW/SMVOXbB+mh3knPEYyuubbSDB9rnfNCC+LbgUmla3k7bQaUf6WeVtt/OtGgAcsAyKb5a341Xk8S9Zh+1eO8HRKNkLhPwO3mLo3LRf9pnO6TwdOLknNPiGWVzQxO/7ZVz1OQv4riqpBYgPzlGb9tALxR7qZjZ4h/4yMYusEWBFg3lyWv9xZdbNPK0fIvfhKObtIGjctj4nO568PamoRh273dg5/Q1KZg6GkIg4IXzwFWVnl0Npd5FpFLtlELBIYqS68SaXU4+M2fvFXc10mWLBM3MoJMlFDbLDfnVPRgW24epB6pWfqQwm6YAs2nhGG1pvlFvyPwblA1OKDlkjaC6LVAKARAbsV9BEnzcG8qisiLos+6wijxvfX2WzvWvapQvxC6AxChPAdESevwCe3ztqYCeRH9JZRMk0KCjtn1H3ev9dmcp1XFWUuBRr18cd97Gl1BHL5twzrABYwvZosuasrVDMy1mvOJveVbUGef4eADWayFShuSj/1FtIDaB8tdN6N5uBoy3pzM8phrHThLC7rkiQdn4yz+BsY8c8cTz9szU3mucpF5pdVPtnOMPg6SzJIe2XAD8OUai1/C2cdbrh69lYFDHDhYIzkutvF7UcabnhaJn9+qcmujCLXCgGFvyv/FDEbUbipwPKBbFQuoOLBXIJzvWE/D7mf/QE8QTfi96IKV+gI6l934FBJxgAJeOS20Mxc6N59Df+EoQujzRXkGeXOaIZQW10aCfdxKHFcAytOiYXDP6U6WTQV1/bb4HVKQ9rHRKjnnifyM4LYkms9qB+QyrfkpcMhVoDCZ4YpmXaxbDh8SMgJhtDrfMSNjsR53iBwN1QRLxZIzjMuId3G1mlIW8OctX7Xhj2EYhmFkLusLvjXdixkyIHIKdTMf6aP0nVVg6mhCW1wCS4AljKcFsn+QuC0TI6zAlnN3PGX6ZIANbe4gjYNf2XafaUGZEjdGWSZUVG7xRvaGXH+uQ7rgdnq7HaWUNMtjWOjj72NtdLIp9/CySZBNY3ADKmqdAOyZXtw7q2pLAhcgzA/yxkqoA/5vdVgwggM73Ib8y+YJqWUO6uFXz3ZUJ/XTSoQbdJbh2yx33uydZHOENyQBwVDj8Ph1PwOWX3DkUpXuceCitSeKmfxlQO3g/PPMzg+ebuFKUrGyVOmEgXqDrdKdRSP3Sv5mKhGSxW7WV4+Fgua+vzyMiy66TP+rbo+5rC/YN7JqtHjxdJ/1wsBHdPiCohxFW0OdmIpVGE5PsV7mopJp/RxomneaqDboToknptRczGkJv2q85ptv6bvh4+aIJ49xoUUoDDjxC1j5NSMjKZdWlBTPxQgVLqsNzIy0u37aPncDMPGuPZ349QnFcT3rIJU8GkOSjiHXGZMm0zNrXRGGcHFLPXhpy1tFuArAKgFfS2Zm3Rc3dBiQBM1C6VW3xH3yZ4dCxr9Toel81imgzxUYO5JNzquSzcEuQw79NxPZ0HjUOUQjyh4zFG5GHzA4I+i37YJZSrRU957JMLoUnBCPJqDpNL0QKdI8+QjRffDdQqsPPp5oMRqBU0fQ1nQvBrPL9wS09wfIviDiFO+/P7ZqAInu8ZKKD5cXk62oyev7C+cYm9S0KrzghpbkRQf0gagQBQKu3Vz2LQs/GnQtjLJ/FzpqYES+CoQDaauXTOB+EpGXHEhJwbnbYp/jn7FGhTo0vgY5wfby1x0Ll2ZGdrRjXSNstE9jgh5A8C9HLI745OrLGLk/lT8PAPvnqqgjCiWtuqNRWCn1woTuEUYOAzGzNb3AgKQ7BPaQrynZbmV8dzGwHwLSJzuVQRpRMb4x51W/QKXyTJtJWRJY9RnL6Des0LZvFsK07mHlZSxOcyd6raei+jNG8j0GXahlw2VK6E/S06FABnp3i9mHc8iAyFHZE5QrT4OUawCGRUqzyV6/OBW9ffT0jVr9pjGi+jZqbJ6J88cfTMCzEpindtLDW1VHlHWt3MhPbbptt04Q1fQ5w4MpuW/QNl5Au0MmrVHRo4N0FMEGwUs05e0suMHXoVPUhN8BRt75qSn/DEo8/xc9McjSvn2LxFrysGiQFTu5ZuM4YiTWiTWIfZVIfL9OrNaoVRiuMyceb9dQSc3qt3G7yQCOe5XDsNwi1IakBuBmYfFXniJMCsy27l6r8izcH9IdSaoqxNEq4MR0s8t1E3m+nycF8ggGO9k5PQ0jEv7U5WpDJSZbn24yfEif9zYJ7dShAlMsMBrJ7F4biHQYhmE47JbKcWtmpXs1eAcIO1nL2KTJx+jCPaa/Ev47/M2dhUQhxcfW+67YAX4kmQn26Cb7Lzv7EjNp1IDbXhBTRwqrmtCCB7gXZ35dbrfbF0Vv5pNqeSVguGha/i/wW12js0aZU3Cb0CY8FMCKBFKx7AeaeZkt29l5SdEepRpqdeG122476xMPzUIq+FgKBuJox5KmmBQpow3nB+vRccTKsV1qF/X35jQA24dX1PgakLgcpx3VpARMhiwbExAlMLOZHdBEZcRBIeqUR7u0KoRo0ItA5AUDZaBDZkXhEzSYxExBx1+g/vyuemx7Uf1WcNF32n0HzvFYSrA9e9hahbCrXBQbWiEaMOKFctAzdalrX5RzO9t+bWMAoH7qlj3MphWJpjD1SWYrlNYmLAqeEP1/97kqMYsJBpNvXX9IvoTa/Xsge5mtNzPKljWKFcm7xhfce7JjCgIBh5xSpx7zzHwP6/JK82xCRtO8h6SSgle6vimvR+rHGUapHZo7d0CwmuaPiX4sflrZafAosOMmP7IQyJXYgLcb2XBxczOBiSoAAlz1mhSS61LGYHrLmeTKh5nlx9Nv1efACgEnxpBMEYfD3Sa4AsJsGSgEJGNLvGvoDxch9IP/NtBwK7Rphr66RM0IvZONyASoiFVUBtAfQMWhlnCpYQpDzEnuBiaoP9Z5jQwnxILjEQpxOZCJBwSeFI4UUon+rIUS9eP1FUc5q1+UhUzJYBBl/Ej0IRwpIuIFYsUotXmpP78Ssz0E5fS3Kc9hBsscEVRyVoSGVSdA2B+WT5nzv1sxd1yb/Z6bZqSHsrJ91aNYZe9ID3RkJhvEaa2rKG5fW+tHPE6BaASCnqpVM3sHkS5LILHKDkrwGt3z/WkmK5g3mPDLhRHyFNKf9lb62qiWJ4EzWzlzPEnXbW4c+c4y+n5kFtEQKO+TkGNGX45Va9piS6sBtMISl6fqtlQVBymgbdeJxWIH1124sezs5J1SOJEXVpB1e79JraCmPCT8V7moZBxqeven1XXF6pdTk2xyi0rGHhWcqY98zKl6XEdH10mNyhSN6Sj3fToz8ABniXBOcUmelGLwbgnelf2/PMgJQf3zfFy11PSwCxyZKdSndL76ClTesnAVCHNTdPOT628lzcsO3gZS8cIsVrHsZojTPLYT36vGFKzF0F7bo2mSFubx1jUy/d9WwCRmG55p1pJIXh1hqlym/zX2Cx6HEp7AdskFjXqdCheupUoE/0PmeEML69hnbgkftj4SfNZmoOGccKoCZOETvW9fN1/SSdwKAJllTpfASld9/woGlVXk58j7acwM04uP/PCwyqEVwLPPK/LQFQFzPogqdz2+Z3NpiDdwIt3HdjSxQVKU7wC991v4XG3Spk3bTtLONp9d71i+IX+S/jqtjtzTY9r72/rni1eKrr/8NHmlDm7p2LA+1s7g1OMuO6OzvJizVEheKfjocxufn9Fr4UaRsM1luJgtBtDH5M1mBNck/TQOkuNmQVwqWF5yKAG3kAPTNxaZVgYf93MPiWQ/pDqV+cUXA5ebPFpH700cb2OZzC0uSR63mmuSpz3lyvREiDq5kPG5H3vnsZA2jOOVFsm7a5K71VnFmW/VeHRTB6WfXGfvoXXn2muxO3BrmZy6ucxgbVsz8+WjcnagUCcP/vC5IwfnIRt1QxjPWSQ7S5LbCFZx8Kkaj28aoDbnBm92rQdbY3E40Fgmf11cWojamtaL98rWi7y6deVyvBNPc27lpVBYqVoUPv1LCvfuWxX++z/Vwd/FWCONOHWXMDCYrIkNTuUSHchcW8Wv2jL3a68ab7VMsZQ2TcmS14xXcrkPZ2Xy4do67lh17k4njnfFxz/flsk/z87Ho6XPVY4b+qTyo4lXa4vcqwfleH9J3HhVJzfurMa75XN/fKmSP26cxzmzaZ47t90wH++Xi28fFsm3R+vxCpJ79CYmj/5YxbGNZe7YQTXe4kwoIw/3W1HyUIFPDG/IcbIjSadRhWjXaTLIxcg8/dDc73oGY6aZZ/bk/GtCJK9O/F3yUC2fGLchx+iWJJ21KoLNOk0GUYzC/WJJY6mM3g3uO9a7ag++J8qBMQ2ibSm5Kx+4i1/h2tKhNvmZLFwefyI2VT8nrPb8lNBi9X+wtc8z9j8wm7+wtwaChIuway6jaBulvYqbdt8h4u7+Ph6gFFLxMx625ebnxC1248+B6dEe6GrD/+Dg/1jFfbVhiT/3Na5xVqaqQbnE6GYP3zcKNgaCjk2au5rLcDgwaEWAXgBpCoBqAqCMvRvy16MxJLrXHljgD7MF/bC8gA+zO2c9LEz9M1XAmXEqP5BXG8nVgZOdhetfdYbI5zrDnRUibpJi4zPf2aNs75UQIWMCnjzpsC3zLb3vuXzqASVuU0t+LEorteTOzDl36FXMiB+Ko//z6NZ/i7v/Cem8MbGA3j49J8epHH7bhE3IOLHButxWgnmvaY3O0Qc5v6P7HIWmrcA5p7DXFuIUwZ2JZmkstOP+fCrngQD7Wf71IlODZJd1f3YwHAxwpoICb7RIQzQeoTnJ+MA0rE08saEz+cU1jGY86wZyACxThwbTj1M2SGAXLDmZNUeMLQztrrArMcELvgou1S/CYU4lXy4MSyv5rPz3zh0moCo7XMAUoQuCJsGCoJ04QsMGKb/zZe4MJuWQQXIxmZQ8TBZ7LnXFws7fwUzDG9NAy1xkohkPMRbl3X+TG8pfzxm65tvHVA1z799TR35t14nFZeW354ZkhNOpdT38ZsfS1vO7Xf6tPuvUVOsdqTL0Ga3gTg4BY6QuIXegJ9QJEjpsJiwCiQq9NbX1086QnwmjoG4gfVZrv6LeIE7hPFITJK0wAtoZq1jG6FELZJuZeb+kvkK8wdZNaYmGlAZ9QvuCsMOpoR4gj1k5euqxI5Ic9OlZmirtSJXQf9AOuBObMJ6o6sit0h3VMwmFbRAWMSSO0G9pL3icimsYZ9RtR+517v2gPmXiRjgXVDKS/oCxoP1nFWsxrqlDlsC893/Ueya+g62ZwuINKTvoe7QPCK9wKqm7jDyYcqypl4zIDOdetOoMqWboR9of7uUwYXxRVxm5M/Q16lsm4Sds8wsWkBjQN1Nb3WxymDMOqGtF+mR2XFCviriA8xNlRdKMIbRZp4t1jC11ocg2mfd+or6o+AG2iyksYUXKAfob2pQJv8Oppu4VeUxmx4B6UkRas+7ummphSNWin9B+slWsYLygmiK3Iz1SQyU8YnsXFgeJBfo92j7bp5NrGP+pj4rcj9X7k/qs4gqcz6gPiqTvMFa0I+1iDeOSmncO1zTMe/+hjkZ8A1s5hcUZUjbQn9HeMuEaTp5aDXnoZseKejZEJjhfT1qpIdUE/R/tpLPJoWF8oC4NuevoS+pkJPwD2+nEIorEHvrNrPAgvw3jD3VjSD+b1/6cejPE9XD+oiZD0hFGRfvX6WIDxiNqMWQ7c+D9GfXViJ9je0haSkPKOfo32ncm/IbTOfVgyOPslSOoR0RwYPxKWipDKtANzXQVGxkZVchtQAfVIQG2nbBIRmKG3tEGfZDfCWNG3SL3wbz2G+oTxGU4H1CBpA4joc1XVjFltKgDntz6mnnvf6h3iFfY6iksXpFSoQ9o7yqscAqoO8jDoBwT6gUiBuftpFW7I5VBn9NOV+7l0GNMqCvI3YDeUN8gYYft78TCjsSEfjG19YcZ8tMwflDXGelb89ovqdeMuITzC0pHUmE42t+VVazHuKUuMrJtHXj31JdM/Ajb1ZSWsCPlCP0d7VOFP+C0oO4z8tiaHSP1lBHpWOmYmqoxpOqgn9J+9U5sztijWkZuC3pJjUzCK2yfwuIUiTP0B9qrPk6n1zCO1MeM3Bdz72/U50zcDOf/1IeMpJ8w1mjJ9VgXA22elSuXqDC80I4JCR0NNYxLQ3+39UY11dQwfrXr6kX3E9AJHRPV9kG1xW3d0zFRxbhT9MkUreiY2KV5ePaafrf1zPR5phmvpu629Y+Nnpn6w0wtt3Vzz5h+nOt7ZfoqNubMfDyad7ytb2beOTPn7s/BHIMlotyIBgnWtsgU2bARbSm1FZE2qnIvGgm0HskRTa1cBCpaSZKiU25FQ4r5WghEQEUT0a6FTRNL5U40dEHbChki2l3JdaDSVjohCnSiwUfaA2SRSy5EC8rckpcumgqiEGCDJIAEPayUMELKEhQPHgrINBDwJmIpiCvCBkZkEzYIRBJth2Ei8SXk/DtgrMImeJd7QKmdTQBD6Qw4wwYFJGyCigxdJ+4nVH6WiNpb8PFjCaeTO/0GtP8COolH5GRGRw9t7dhVODVslxnaXVfk4bN8y9D1zu2tQpGb8RmbHbg7KgTGf2bjs5ejMA826fCBhcVfRb8x0G6R0GktGSDpIuTfecaA3q3dScHZke+ZHWxLZ1TZeW57OJXDR1089J/+twqeQ/PcFKvL7s/av4gOq7BpO7S/qKOFlR4+mw1Vu/lvTfixJf9fyZ302zDoP57n0+ag/5tfytK25UXR/vHFsH7Z7Y1KMb+9mE6TYvwsCLm+GHaMXcWn9B1MPsK9HspyU9zfdN+qL8dWhWf9rd1T974U1f3C9avFbvbwzP52XzeXL3WLbt0S/Vr44WKhvHfQbzf7snmX+ypjJ4oYV4b0kOze3GGX/UWTXDzDHzciXuSh7pVApRv18Swd/hIK/f/N5FJfst73AymgXq/lf60UWiqUUntR8IS2t/gwhShN7iSzXnxMs1xOflgkIEFe1txzohXeoBe+eaBPfSufZX2RO0/egin1rYj4Q999WSL2CBYxvnqTL1eEwCnK80eFuK8rZ5gKPRI8C1Gl/K9TRZdTaen1gknIjV8OHLf3Q9obgqrNR2Co0kGFbPh4vRiEI/aSJWqZg4HK+I/KRBmWgycutJiI+EXk2mrp1D6vkXLhyeL8ZoACfaXsyY84qccaDRFEbf32HbvXcxdKaZQu1QWiIYpIgmX9bcomQif8dhTSensJPTTo3GwmAPvE74ysUagxRhAHf2sfzb1AjwSuJdQWdKFZEp3h2KTJ4mYHf2XxccNnSMaqRImNcfHy1LXtsh9ZsCJ0muN/0BfFd/AcX6xY99mxAUU1ecBkmRs1SDl827WZRp6fBHTqCM/ovDJWoc9Cw+7URE6asSZW0IpUER99RRBtXl8qk/Kao4+RnJrJdcvlXvB3eCzoZuRrxhJQCZmuilbsg6cw2/xofOvHGo5jx5QqgFQaBaNKtFkd7U39ej52TBfJ89F+shOPOdsgUGVQBcwQz4zopWrl8yOvyRLsyXEyzHcjJPr0kE8SJdYKGdj2cmOp7/hoyrm7gesapTyEYKEE776aQtdlH/Mf/01Okq7bBMu1RByUBnoij8+qQmwReA9vmXjoOxM29xpycniswO3SPrtpvK5opUDq9JE0ayr/5sOc+hpCalXJSixWkr6hsgfqqNG6Zetdr7xxGgYNHEU5bkIPCWdgEAu3FLEGUUzM9mVxZej/nEHKYSsyz9RNNQFQRhWI8M4X+R0Rq0q8nOCaKl6onLhVmp6hCMOE50S4G7INL/10Hz5NttTVt00ZvYJb9ZN9wehVTy5rPYOodM4WiHrSPhgSoMyno4qNnFWjvT473CLZ3xnP2CnQ3hCFpCrRZwAOpWnQqcn6e5HVpigTbNpuOom3NM8C0uw1MtTciY2OhVooFF5jqDaNpzPVJ2lZx8lFlcoB63273HSrEAR3y9AvV18TkdUd3B7d4H33d57b27ASVWnPMehjDZw8vln+dmrzIJpTHg9oek9O836ov1Whwuae/yz2hedYI0V1RX4+eGvuyLowul+hsq0R4F8kIRDSHXt9N7sgWql1L9e+6nx89eShVeMe/TI+lAdRnw8Ih1ugGt2zmWZ5886tNKTMIel1IaRaozNZR+62y/XyrhO76U8JXf82wnqRtw2HyjvUremFQqDyGnVvn5gRr0gOcfmAPlqJvxpoNy/0JmGX3UZRV/fxMM9MDnph+WXDkyEV3aUj8h5oBRK4bf7SgpJwBwIGFwFQ8RMeCl09+iq7LB1AtH+rPp7tlvkj0yOpD2g+lT6L8vhOiODpa4hRdV4tcsP7/TpjPltmvbGFGn20REG4/4yrXQN+donIST2Js1pbFXmuTZwNBwDqMAMa9PaiR78a3lgPhYKwt3tdZtw7g79veBmqECKUeU4RpRW5BTt8TyJvdDKhUzeijBjkB08KUWzaRU/uGheUf6/LW0BB4sFyvLFkJfQPhsamqHlnrBg0OQq7ZFbvm3O4ZDdthVCCTVLG1F7KoQKCuOO3EcRc7nOvk7bnG27IfoiQY62wiIK+Bj8Zb0tHzabveMPH9QJg6hnAeiaQ1bNQIQ1w68DJKSXYi/by0LKl0o1qYb1JcNK2i6SAGA1BVGjIMwD3qX8bMnYdGEeFDURds6iKYEZ8QclATTSnZrAhRVMI1RqbkO//VPr6VdsmOtuSBuCxmhpYQdXj/D4NpIdZXuK3kKpr5/ZEodp/jBlw6+DQ1rWIFc1BDypBjHgmDhQWPks4/adY8dmRoBT61jderOXJfGu2fwS3TSlWDWtADTS2E+17/KS2EULKT+grAsCrKnULzdPFEQY6LuuOMBG136yNlEMGXj/RdbEa0EA1MxS+saqVaD37rUl9B4VGkydM9vaALwWg/6YQiUDt24RDzYWFihd2EsvI5AdMudBHxnBOyckbw5Qh1B2UkHAiKqQLN84DtZIfNTu+oSywXjwtbUTzlFBfaoI4swaT5xL7RAOvQfwwEx5GTwEksiDi1m6rO0cMDn+9qfMTSVmMccK5bs8KqqK7wkqmcnUkPEafpA4+nWTmxPH1oJfIxXJRE6flqWxpFqLwIG+mnpKxCr2+yksXJ0kk2dVutPq4YAVk8aOAlvUcgab+ByL4iNfo8vkGiWs8flMDzy0sN65JaKvqO603Pyw881oUxzQcXkq6Ra0PDIIKSCzoPweLL715fPZkQVjtZ4yGZeJNp/AwxYTfqR5p49GGUalnz2DY555X6N2cso5IUgAW2vFv9LvgNAKiZW1wcVTHcng0g15s3wwMnqAPzHxcguMRCfpEykCyUC5MFj7bC9gZ+arkMMvNvYMTAXYrnCaiRUngWGOrFrp7GbYoJPIdHsJ2kALon0Qs4uUY523zJ14DMfPHUQKIrEQ/4hA+hBGkHQl45up5jZZK86PPqZ47CP6KviAT85BvQHnI5kWP86++QhmTjdlCWn4mpwcxa0iQIj+PJINZia9YRkDKiAYF47b9buFOT2VkURFU5KTHJbI044uc8rBGkmXQatTACcbYSMrCE3HF4t549OIdiutSNBD2kPlkjUhKqo+La1CAwppX2aTSwEJvQk5zdXBBX6QTRZgUTcEMHap55xWvQlDM6DW4gYPsWM3n+SLfx3qdM2sKzkqahV2Af0zAjMqrJYMi8D8Ky6RfjFSlhsZoX5HWnn/ZmbN6+5gzim+GgqGqF8/25/9qSj7Nftoz90NIkwZnkbia5Ev4pz3xR6OVom0tXa4/FJjEvu40qvTXo5x34ZT64vnxkcGVAV/3BKzsF/3OPz0aXmfphcWaPsd3SaqPXlk1ALKieM9oTis7xTkHFaDIuKs+/bWtKRwAdVjckjdXAbDwMfjufHk1lDu8Kc9khc8AhE7mdViOP+kpzjLSisIFElNaHbuMhSz73fbvN/84UccE0RKL3gxLE2TCMS5WI2qA8q3zzFmU3dsQAvZ/E66dY5JOvz5sQGBe/9G+Cvb+/3fXU0PYm8zm61nfbGZ+lXY0nK8Y2PXB0tRWRrczJ1RdLfWEUVXMwTgVsKbtS8Ccyudrj9yHbiX7u4Zz1b1yp5YepJxRlmg62Bpfv7hhXPol4f4WbWQpDMcqHQ++U7U/wpYJsc+fCzuoeBvPcr9TQJrfQqqzSuMm7n7ubgh5nZee+h96f6tmVy7tDK/9Dz1k6mPmeZUAO0rWQL0EMC2hVWk73mrO9K9mYiD8rlC7LeCM3UHpiENmYqyf/QraNttS0Ws5jSYDt9hpgEIGjY6mdDIzBmasGzggUzDaD/omPPSGmdrjXaCBhw1jMJSHTvPCV3UEogFDjrhGoLrVAFfg6KgYvm7Urav2YpVhoLYsv0hzedMuko4Z8rIEOFy5uCiYXdziCh/d+ivc3mrHYBSSshT2g/fR7esw+ZgCZ9ExHpVnZFBLd56rVRcyEN70eelaI6yO8wjaSv1JQ4aUQqwrBXJ+hiYtqV25nzes1cKlkpiI8i4y9VBqEWwRDtUNL3tpwCSWi9KRx3cnIIpPCqm+Lct7UZhu3rS6ejVCQG5b58+3zgfqhfZDaKvdEFhveJwwgc9TZkOBTTHe1ECZv4ynzbNAfR9pX7vFUfpotVloPZ/DVaK98/wMdqEoJ34kJdGuOYrHoMeA7TYNWXgaGTZtgEQdQ0HYRoOHs/o8BOj208jV8nC8vO9kjoLYKNzW6FILO3Phzq4iFR/DoAr+9o7tNCkXbB9Ho/cMeTajlkSfq8do/chEjG56496fXP3A1MQKyIZaG/FSDgMLI7gAp2W3yODUlkk/iXvu49EmmYSNA6cXAPKKhAqkaG98m3uvxXwIiUB7VBCCCRWh5Y9QkS9XWpwHKVjColW44Z3QDsaSQyXg7otZ1JYd0vGTS311QfKrt8pYKqsvNjjDk46e6GMD7GEYptPoxJbLOKJ7H2LxpucZAzcxuBYLaSW3fEII8+vTvMifOipDUexk+JLQseUt85PxWgMD920R+JItcAhO2jBUTNhRFpu3Pce5WkBlVZktwfkK/uzvopZWygZx+w69XdXsIDz1iuwoE10MY45g5R+9qVt2hUgWmRSF2RBTZdcAM3m6YUnNP07j9Z20HRWwAyNakZyeRXyfozJqVA16ri+bWyZYDU7d012PkrcntCo7WdBWy6j3ZdvUi21haEi0nYXOopz+GLVtJs04iNLatF7nEtyKNavtmSgTiiD18zrMlXT8JLz06a1hkvGieTafSrJ15Zl21LIiEfv52OUYwsFlCyA1yoPftosZ/MCPIZRmTk7HMDqbKNL5HE7uBconf8lOVJPBF5ctctDx7AG3NjUE8YYHVbqehYd5NTnE57KEoqRcIzZu7UOOUCvUFRxVRszl7HEZFpxjB21wFyOxHup6VT8hikdO0t1gQh2kFMWVdw76oPHOynVD1S0TqE4D2rHdUuFNGZfRSYWyNFSj/hiXYt+7Pr8On5r2ZMhOSBudC/540XsSXEzbFMrKfs6pkV05xF6GynP0i1YNzGoVFdy6Sj2IYCaS/YDQF0ucKU33qwpV85mITH7Tx8y4IXCxOIi5ceNgpKHa6PoWoqySX6ZHZdkGi4jRB3+T6Ol3SSjCZRUpRpaFvEq19cApkDjZj9yCCW6eqT8OFEK+8TK8oiCHVP7elfBUWwqR70DwiXl+VMMIHv57pdGv9JjRzCf3H2a1uHEg7MV2FbZWGir1jLYOV+ZqfdgpVxxE6IXFH1qMMcyBy2jR2w1mLzGptbAbj5XQoONSfpK6hY+x9BtPgo8hgQ91ZAKBtVwGtPFdAI9+MIRH8gKXxSig4KgLbvYMMADgnDuAcAfiDM7fP4EhtYVdvShjdZVYe99nUD+JaUbPsaiHmk2ztcNro/1Rzr+P542fSLUYVKv2+1p9gFGYt3ah4ZCJnPxMszLUBlLG5sm/J/fpdHNF8dJWTTqVOWljpNmAQpSBECw56NphtiO/Y2JxfgDyeWU41FNxEGTMAzhy0jhIqxGhHR8STuEgFGfb5fpp6jDe7Oxh3hJsVfTlve0OZ23UFeZ9muo4IeLWAO6wZu03ZVa/yKG8oNUjIyuyxypBKA9FXWnD1Mf97WP6anY6j3s+7yE0zBVG9DMMw6+2teoTSOv641gCD91DJbc+spvALVqgxrskiT95GM6yK2QIKIYkYCMCCWQwfve8RaHcve5uAMiXeIdPFh5+L0PmTtdTEUK72Da1TSVwONgrvp48FxLmGgkH6OSXYqr8iFzi3ewHlwZrx3+SHQNDJ3htY09ZiL9rYMo6t+P5KeX2C4oRqtePUYlnBDSkuNCd2Y1PmdKZLArL53O6l157famzhENWGAaOj3LpLKLHXifFuGj8nsp78EqslLmbY4EnlirnIQqvCn/PRt3x1KccS+TutE+VPNeK5TlEyZY86Vg5imA2kiOeTBEE4o8814rFHLc2ZB54SrVPX610SBChOcu7Iwultn98VUgptp5oeS/IrqYp24tO19R65sidciqpYaCzktLMJe94t63IG55A8XKe/AhM9dFGe0XBsBSx/QJQooaXIIXOdxu8lshAO4lBgfw8dFwPd+u8n3vDmf7BkFf9VNHsg/sZQ0+eNh1g+uOEOTbh7XHKQttk271Qs5vhsbFPBJyeLBQ2NOydMQvKOJIHQZrHhZ9DrwpP1pdUwH4HtA5qTrGIaiZD6A9OUvKAB1dLUs5wZ6rz3zkL96MNpyKimQREi3o0sdtV8rD6cl5TEnl+V953s0ahhySNcBy2F+Gaz1rHcoFvVovBo3JgzZGBI5BZtP0Z/W5Ch0t2ykPFxiRdnp41zOti/Gfyu1AnkRk92lmy1YS2T5OYP4UNSZTIkOrFowG1vUf0Ac9Ucojsl5DjnB9h+95QZ9ylidjzdvDry+Uw8gTUUaT6jvgqXBgpPlVfTkKzfxsoVd2H2GCoOcMIIXzkfkkKQQgf5d/DdRNSkITZI4q8y5XhPJFY/xYOeoX0+ogQrj2mm5lzcmPwPr0iR5DcNoCzwwY/0hs5aZeXQX4UbjLpRiGZyJA531vxqxGPVxSUrmDa8lbSg4Z1xV7Pbu/dtdgPMULVxSIllCI8givzSn1aipszU5uunuU2Q0j0lcW66VbL1ktDzchXYCBG2q7ZjrfeUNLqA3v9KKZjwK25ZBUpnXhUvRFl65sjKIRwaDsw5S5j2t0mh3bKCNHSFiR5cYTUQdLPCRg8cdOiDF+56dWrEWsEeLdrRIprzsjWhh4CEm9gqJeCdcZZu5NLYR1WR0ydmGMEn1Fq+9BCSSTi8m2y6NjDW30qhS9Qep9dOXYSsRk8b3uYlneNP8sYylepDdXPNvZTXztCCmLLl32ghwm4HoPQT1g+to7kQk1VKoorxYTWsEAabpAflsj5zAQVkWZt85xbdXpPVG5qPnjhT/6glvlrU2Z4Wo+belM2WytbvWPUlCTcIiRq09BJMVMbrNv9GzZYOyrQUc6ALt2oGkntZR6S+jjvzdBkFSLWj/Loh5ULV6LyxYtH0orH6ZeJ6mGIX2qj/hA1XvMYpEwtp3ddLGha+cg8ZVB9oSKyfgSo7pBCS3Qigcju/UhRUQjVGazqqDIPARkLa+aGdbWPUsepZnOV1o1IsbgLXspxWEhLjwzIVZinMM3JZvmCBwNxu7+20OvDS+SbtSlM/LXs/lwln/0Fh9F7fc8v/cp9M0qXY5hg+B41x8FmY1t6DQEUhMr4eEPb8j1eHLkNDP7SRdqUnggizTet2dLrEP6ZP87BWNKCM7HFTozubCojUbZOYblYOUx2odY5G9Xny688z3+19lCTivbpb/WQVLeGKhwDnI7Lx3sypgRcwXOwZ/MGTzN+BJ4SS93yu06E0Y/D8lm/2OnKWg76anegOTEb2mkPj8G33LjqD13VY4/G0K+QKRxK5chGqaxgwbJc4OoHSWNEMPgMdn2xvWTRaheMmPzYAApkzQCm4dV2ZtP+5zUqWhTdSuySJCntEuvGsVuYZWVu2V4DGNlMlWO6UqXeWkkl2bKOoYmoXqD3M7o7U6FLVZjmrDevNh33pj0yV68fjvRdvw99H2LEHMgqFErVtqcuCZpOPDpcqpgVvDQusxxAvFXknnqCUBTdFvrpAAdDrnx9Q299FeqMcsPrHTZnnbTjfSpXI3WxjbR1cxM9KVpoL2kdHOfjKxIKhebbv/nuqdew/SBHydROnJK/Npil+nrQES8YosNS+i+nsz0+5MW6a7w6iZHrrZa4jv83IsAFHkWWbchjJKN5vqJfG/TReAW3qzUnHksNk8dBm3LvM+LuikdhhBpwCeirlYj9IwWCOY5Yj4CN7aGt3ZFc+Ne75fzfAPIFzWxNQwv5JMp4kX5ihN6dd2hZGIcVm16sdRLJjxt4qbRnzv9KWXPQccghzJWo2boTpAYCKY8u9Pk+GLCMiKGjPugKK3+dQiYiK1YLXVbhiprnZcpbdrr533eMU6p/KVlriwB+J1rrJz+vdTaC5JxqM8lKI++hIjqNddy9OSK+WDftdsj0sZ25oWvhMsgT0qBv6/+UMfZEaeQwoxzt9+JNMgupPzNBX3JaiDjuUsT8oGRiRv/G/b3YP/b+xF2t0IhfKn/9cbKPV3pSRbLkFYaQ++H4BlIWi6YvQVXMwhi9EJIa/3wne2ACty5GAxFvQK3ViHi7liQ/tJB4BzuIvjIrLiYTcf6VqGJK0NbgAV5TihE5AJMNKhlwRIxz65+saTpdcRfRSRUifVpIqEjwk61gKxJ99IoWSNwL43YlEoGjWwd0Df2DNun8Ypn6SIbOq5O3hjnMKzc5SLHW2iILpLdiYg/YRUyZDKCxW4tMjjj5LvoByhxJbpININaHDrqT2ArmbcQOY4TMMQtaQeS6e9q5D/vPr3Erhgrj8NeXnuX8upr5GQXdUPowh0shrXvQTGuZYkjSNzGkMNsej4iBbMaxvajjJ0irrjKTwIuMOLB6vaFNeNqxoxTURA/JxnwRx2Vdi2rS9AvD7NHWTMs5Fp9GesoxwiFBQhqylzJkCoqSQJxO7Sqry59END+7PVTkmf/HcRyxZLcirBToKAPohQ9FCPwQbQzUtsbULV0OhDgXUIa/bb48u2gvyai7I4+wS0eey1wq36zbsrU2HgVVxxy+d9vmLmUDRBw00QbEuOYCFVluwIUgXWVoPT+KO3QpHQU6k1BBpDD4jYdStV7ge1+pmZ4AOnAsc77QJ7OpnRCAvKA/nXGl6hxm4Jix2ZbbIEQAND+J1uvmPYJA8RoJUw4CR5Q1NtlZ2nwc75VkZ7afWk31Fh7kBW0be0QuusJ5usSLsJmnbejHnEudYZRQghSWFEEaSw+VLbK1eMVu721R1RDFNB/bstdF39QoSQxSXRKBg68a5iZSNuNsqhaeGfE/E/CGfmRsuyW8rIhrPMx2Dsto/1FLOED6i4ZQrW93CSORTSKBNqlE58N5d3wyQG/nFhoC4ydXCsdw+mv3u1KaK9dBtU9NAGm6KqVx5HkWyDla+VR66M7u+/qEz8qkdYsrUOT+zl0NqHOZ0MAmkj31JPqQnXh4ZxOiV31CnJWU6I2FF60J/E/3dsU0XdCePpSUaiQuWWv+90Id0J4esNsC/Fe3KFoAlyDReP1s7Xk4Riq3/yTZ22HoUQQZUhmCKDN0XgYHP1WfAkNLkCw+UXUmO5gpH0dK6AtzrOmizymZf42qVjAnK/1Y1r9LSfBN0RkyRWOxTTyCL+yJPxmR3w01zLyzi9qcSvJXcjLtXxynT5dzW6p9pIJKIDkVBvHc9CVZNPnO6dgYHAcMtPiwoH7vNtRMeSV/cHCkY36Kyu0MKnYnbg6fCBqzy6PyY0V4tTFWelIEkE8vT4aBJtNtXS9XBulJyN3uqiXDlQ430uoM+7QqBeagqub9JoYeGCXv+628Z8D8xOKDXCcGK5Te06ib1Xqs7AYtbA1npbde97Zm3yWgUz1NQDiqSXSyPByU1EJlYaAGfKUysbOljvKAjInHN+jZQb4PbTJpIgpLI2SwMfavPq5Byazu4GPjbOR/XVegu5kxZHg8uM3FeB/FoIdnsvj3gVnPx4+mR1IFj9881U0j1q0qHoDo3R6YsYxeLLg8TvoR/lx3zsSEUNvDFh4TD2kc3mG9OCvER3gp27h/4QgccDgiGeA7LFHmdeegD/+T0M1NnbKglKjxqew7HBXTAvzjd0C0jKyS3oClpzjwk5Z6IAMWkRNmPxGW8YKmvhuN0B9my9ARXXHrbHxiSUaNlKAMLmKih1fUE8f1exno8Y9JnOVNct10gEy+IlAHCkmLBjSwKkCgkqy2d5m5i13RlesFp/tk69AdXirIKY+0u1l8ltrF99qEs+daKHBmtCE8Wm3Dnh2mTZ4ZNf4GbbuDW5Tg2OZkwpyodjZVB9XECW+ctLw9uCX3v6h5WTnlbL47ZUYIgPYiAVs/CYDtVea2XvMr2EfWr0AIBCjxPFG6z0LhT4OPrTmcoR6zdSyu94cgcOZwskwdyR0h0dRy74kIzAf0DGMZstyBJ4e9gYhOagj9r4NtTvW+FzQ17MU7VBKVUFz7lHLtviA6crKU8qTRI6wC3RGXiewHISkr5zB7UWWlWhlh/UEotPFLuvpQlPWjcL2HHBU8OYco6QxLhjgBMx53R4T7CMxjJriP9/913ChdV+jqPYW2K+nxVLpZScUg2f1pcAMlH0OR+GJpHHIstlxWCjlnDwdxFDD0xxuvmOZex346IMFa/WLWT660tzs2N10BWPfluaZkbI65IRX13j7rJ/qcoYf8wW5KotX7/PzC1S9Kp6aPQD5NAgfesKAeinRVqRGwIBlM7s6AlZv2VGPuTtaXhFzBCOes0XVhtzOzUnB3awFqN5mvrjgdRT2wyWmm/H1VdurFwP3/MrSYzbu8oqKz0RyvLbsxi4z1eTPW8G52lnQ41qX5hkWTdDpvWpKuP/ywsPdz6O6C9cy23Y1RfZoyASddu2U2tI1pmejyKNkj6wNZqn6+vh+u3xOQYN1HmoXPgeBz34AdTT10Zd/m8ItYJpTaZaQVVwUkrO/PtO4m6GP0nNrTptyTAcGfjQ0MOy5H3oJBlvsCSLE/Ag6zu+e7IQkk+80PmvN+NKuZv2fDuhXcFcOICDek424jGqxuJL/HEQvJ8LOcgPe4FBhGmPEYBLYnu2SMbc84WETYnVYNKT/VZO62GuSU447GOBeC2K/IF4F26FbY3YwIbdxQP97TeQ9e5dpfFCJwO2TA7VACNEDAuH8pUx4vAgR0mfId9Us+W0SobC+9zpFtMl1LKgnLjIDVxNvB9L46cTt1B0tLolhjoVo14n7rq5sziHCMo6LeeZEcUiTCJQI/EruyQjSIaSugY5oytlRohWufqTh/JcVXaNZYa6ol0DFNEhv+tcS1T7a7NEd/PE62zPKiNYtM10RLLm5kl6yy1uw/SPCmeaLiIgcLLpdlODHDBm+a5pn2rtxcNsuWrgGDykXPTMyFSfH0WYr1J6xeTGc+IzFWsLmxYIgbwaBRv5f1pUjzwz43iV+xwLuZnR/eDmD6H5u5H9p/0G855ZWPt3uARMvngnVyiGF5Fq0UsJnVhYcmpadwPM2f5lradBB/ruXVHyT7GCZEFJnzvF12N+MuL87JYpsrg0IVxu4OJvPnebdWamIIqNfHxrlK+4pE0FNuXD0dnACjzdCipJSYTq2zoe3HpSSPUaObOGJJdE6FHlSV1+V1eYQ9WIcT6DPaGtIVivK+58XmoM9xJFaJ7rK+aSQg/UPgU9TTUL4y3Xx+hDM7TLJ2iAJxThfwgB8hjHR/H8mWpQI09pjNZb6XRy5NpXqOV1HnL2jN0+nMuhbhgubgZjkHx8Ue7tAQl9Q8z3oGaMopvz6hqjlgPTAqlm79dzPzzKxIHCFSyTu4i//XG71QKvcmG3683uzUSmeKR6Gaj3J8qxDs9bSZQ71DTr12Q/dKUcMcMdN0EYlF4/qKBfp6vbfBnlvLXZdTvr58vj8ZBrPM1njVtd1SLuSDSeYW7SN4xtIM4aVPmDa8w24FOH+7dFd78/Y5T5ZBsTIi3fuW2+cFt8alZuDM6X1SZJGJ+qzKs5k3iJ+Qlg9Fq3azw/LElt2kNbQnTNbvJRZZP3WcEyLdOTNwlmi1y/HT/+aUqpq0iw6n1oNEK6e2SGJPbbwDw7xdoZt/xTW9Nl/pSJ24JU6dECztTmr2HQTDIvjD2d3FRMCPuNE2h3jcfLCyp0SJWZa+86SEA6w/QJuzfcKlF01Htn+RZo7mDXMab0FNmMPaB/T7yR5/VIQiBBEOQ9/XVUGqtghRjpxO+KJDzFxzmBk671m8X7gnaldRHhzo7G0Be5twekKa/mXIwZ6s12lxXrqVLKM/4E30odqWFmjN22JJXrfZKC/WC8hSW5r+Da0wzZDsawVsWShww1awawEVp/eri4RDN6fTGUAb+uBmB14ICSHYqYNaDY3tJjhxoD7Wj/xCv593+XJXW0zNPB9iF2Ept+IZfiV1DNgqS0PEJthDCkfxGMI+wLFXdhCwBOzUIxFjXH8UZux59GriWPiRTgvtNU/nowj5KC3WokV45EBEYWqcBLhgN0kTOJGIpF1LeCv80h2RTmrOgGrI/453N+Aak/aVE6epLC58pnOE4EXIHOgsPoaJFcqD+8kKLI53Kfl22QLvHLKMqL+g7bsqn1hspKXyHSiPHTIiUGo3mXldIgZRlX6ImVDpoYhWLfRuQ1Wi67NY9hxOaHHyLEgRU+UsXgb0LR6FxDtWbZOO4p1aDimh3CDENEC/CwzWoAIoD9U/7Sj0+CErnKraUFjx0PUI/aNVKCX294CidMGXrwl3o8VS4qTtJDnuJXLQUiHEwhlmykLCMOnEkSCf4i1BLYdFidgh0p6HGeKuZKK0wme1J/xy1Lh6f/BNkXaUY2zo2wwfmhFAFDgqeGNywWxVSaGxw0S6AhJhVDtFFzkioABh2ox+Bl1JpTbUi3veyslkpJ0fbDEsIEKR+TKM1gu2C/hkRHyhEOpIbXCDSEOQeMngbxr9r7kPDfTvNQyCQS34gBi2MMLnlu8iSlMbSK6Hn9azUBYtYlCuNanTrp2sJykC8u6MkA5Ci8lPnxp6UlLnl4SrR2IwJaJ1TLXEI+F75i4gS4chXtNnFXSWuoctYPnJlEvBOYfubJc90lexbtrugb0f22NJdeSnk5nwMz71lPqCN3KJF7ingy5gS0ggkHa+8jOVNpB+o4zL8a+tGZUSX4jHOkQQUhxs7ZMkv8+MBfyF5tlknJ6tdumP7PAWfj+Mny7g8fYPi+FB4NZqL271kecL/LFJ3BY/h3QUdd6dQRypKoqnosVG2svEHGOOqhkrYpvKUFaB1Q/iklawRq7WiGYOFitOVwmkW66J9ym0U4Oeuz+b6Cr/gDiouxC+2+5w/fNPjC83Z9b9YWBDTgBoeoK1WmCgNfFAX+3qhtQqT8/Ihsh09BeHo7go81rMes00YTZL+pUe3XfvRu9r9ggTxGlLdt4smumHV7x8oxHzFa/vce7Sag078kHh8YN37vJOmX/6aUBqth7IQ4l7qE0M2+JM02Ww7OXurTvzaFJSSCShRMgBOPV5OwmPD9GBl6EL0SSCQaIerTLhOaPLD0g+AwbyQxZJtNOLztaeU357V2z54N741Eh0vlVG67VSR/mMMIxotUlkaOJT7zDfqmtVKOIOaDfQYtkE2hWGTP3igZYO3ZNJrvnit2xmwnB2zXDYzIdEi1ehfeyptxlU9dnj6SyRSNaJAl0juSSYEJ3udGu8f9Bu5btuNfKqyA7vrNlQvP3/7CXmsK2LaJauS2KLWmeCjJywx8ViKw9uB2tw16L1IeCLbG9cAooD6U8QvoNjVFX07bWZcBi/3EYQTfHUuxuxMXaLHCH9l6m2Wt3tLVf0VGdqjMRT+dUE05EqJxCLtvxRH6FX3J8RsuShVymPARp2LdUwKEwpX+QSzkPn/I9305CJXp/EzchOKiuziRZwUV1RSeRm94MKb8sr8jnSbF9reeyIyJZ475O7biJNuEyyWztYU64g+AWJR8lBP7QWGG64/JLogNmi9TziJXyzlgXdiiVNazOcHvciqhDy/Uw4qPFK2oTM34Si2MvJPi5Sz04/OZ/bzRXi6B5LmLSFzgIvbrj8oZVGUsExNneM+RgsHzRdzKeaETHyCwdSIRnjVvJeAmkI1fronMkTBkyoq333cx0Y9yx86VZtqt4hB5yNI367TJB9Bbi1FOEpEeCzcFT1QH894NqBuy2ahb6nXDqeo01Wh6pXoRqp0f24X4pqH+nM8ECTpTRP2D1Vaj7yYJnScwPEzso4njlU+nEwbYqmR/A6b/dKaCIsuZ8Qph9TQX1IdDtg4vIYQQHBVKJHT7vSP+6vv6AYbtxxPQQDl9OZA154cXTEA4RYNk4tOv2x8gkRjwCNh0dokatoDWEn6YqF5YISu1wH91ac0e3P4DdL4HVjAubHaAryTzkQ/PZI/PdKb98eYflVfNhvkKBdPhHtnEawX6PKiPBVHeoMA4bVY9bVx307YQnieZIQcnYG6g9DpUlA6A9d4QUU2z6Kxp2hDE6SGDzVKvN1hTvmYQ1Wu1iK9qmJmoJ6JRiT2Gsi6ObACGe4Kv42SnH/ML7GVD0XarCNZa61RekD+mssd7WGylQp4s25GextBJXqKg4CRdtpuclhOwaPMDEwqNH/L6aZVQz5sk90kqUjTV2xjPpeBxe1HQ39KUNXJ9nNUdQ9Jnp2d7S9ZcH1iEUTsupbJGoCovj27jA+lpiSOux3YjdLT/MyLiMa7xVp9xPzuOiCNMjFJrhvyiQhUKnZmmbRl8FSpodZJbNRV/faw5rGJdVFLmg5VJJWbzaRssWIpsIVve1pqGknBWfgsaBu6hcRNE2HNQK97IMEVmgPpf1kJ7pmQ4zcVixtkAh1+hNdoEYOSJMHnSSsH48ilcZowPiy9lxIMg7qCBxbqauZfFOXnzsHfhRmh64Wu3lG0ZiyXjjOmcPK9UWujDHxeMHrm49it1YGRXwLesYEYjSBUWe0aw5gqtjCj1u69v2kvHIdnqKz7if1KaX3EZ732hqxLoQ6H/8Yu1xz2hoV4UwaAYaj6dejH1hm4aC4v3MSFVQPxwlz8MJ2vawlolmVvrlN532tIWC9I9nrj5p1Y3BsCmL7XMTx2txWg6sETX24Bd1a4ocy7GiTCrMhiMbl2rhBmBciE1Ryf3E1NhU1aBHUfWSzbewKdVvNYaOq6HAJsaHgPMEraFXHf83WzFQ1UVR3wgPk4llN8sF3obydYfegaRlF1pMkG65jfTkqUkOrT0aa2OTdej7U9mu0H5aJYhdmoBgf6dUJdVC8z7qHWTy+0aRrI2+8V608c88f+Eq9W3VOHzUtw9SOM9a4jhZsvBSKNTBpGLuCbTHWqpAly9WkVv4Bivww9dt9+vQn3WQBFDPuir6YYXk4gVDrFWIPuirrZl72T+CchXrfAfTXqAAnuGIwaY19BChRI/XHNiNoP0g7OLPgu3qoF5wnOp7RhBIDCgQZQ2H0Ql6UH8zjffAuku3G9wc25B6GoJYDlRFktOUVaUHo8YYHftoHi0f5y+IuSNRIYZZsabFjR5EZT0deNqLedeDQYiTWisSY/PwfYdMZrqDOaGLl7svN/U9bcjtZ8U51mE/q2yW8gmdfoo3oLjKEa5X3S1cPT6NTgRRsaijWZ0iS+5IawMAnxBvu/RnnJhwM+SvZF5CvTstnOIciS/AO3NAlbrzCMGSXfqTn1c70KqaRZcwbNeY+3ngjHWj6sm/kCbJtLoZqRwaF8EI61ENYC4VM3Sj6Tli5bJRtKimeSOFuButGvb/UMejGmfgJVBHIYkBpDutSJ5x0RMiElN2WdlUShYlom2vsEC1gL5SUOGGZqgt7eXngdibVofF81yfa4txBMAqTwTQyEj180RbziaVfCfL3sjTbM8h3/PyQ8/3OyhNyGc7c85FEJpe/T03Yu1l4t9S35Vd8mM8eLQxtX3KVMtFO/lpZzMxMA019m9dOVFooV3xMdGWxlGVSVz+AnbDptxH4iXA+LTPemVeGyM8nYWUJbsexBJMrtbk5klxrmLrmj8Wqn1FBeWXWZ/gmKbK4k5XfzxLt1km6Dtj84DUi2IL4tQTIJFlusrJBj6fSmw6udl1wnZX/U41iSu6HLRdnJpghbjs2xxS05wYCWO6GzwoCuTki+uIEvpX1sxyReI++kMAEclMu2AR3vBkCvE3hXFqaNJQp7zPePcCgbTqbZn5syOkxdPPecPDRu/WWAV8Nrh/05wY5+1oKw2bdDH/+woY2w4cO0hKKnYGO89bSfyBDf/DDGy0hivJCEOwXcDrMRHoeE+BicpKms9c8REE7D7JHg6HXczYg4UG/IQodyGY6mEB+nfbRNaHXCzCszbRyVo75yf9YEQsGKFlTcCHIMio23amBQUqmWZTw/npSM10VJcSyNA8PvexKTZlzrTIBC8IbM/kv9eevW/El5Kant1TK9Zn49OB2NresWe6dnGL4qmdwKL8Wko/69FHX7w0n0p9PRP/g21erBavpWogQ0hBX1Gat2i1HRuJVrtuanGFQFNfE3pd8nD+r2J+/S9DeMrPCwNGmxoRyoTl6RADXfRyChHGS6PE83UuurKtcG0k1Ta6XcPiwoDOjKbEESm7SmNRKJG8R5hY83aUKSbjGpv6Jw7FRe345hHj8c8hNC9RXyp00bbvYKwdcw1xqbD04xdAVheJnitDbXXyVSr9RRCmx7gbOaPYrrBBp/Q/32jpt1Cq+3pUBMnT5msK4CLj5Of+X0RJkC5BV7g1+PmEUn6vOFkGLBG8d8X4CpqqjL/rBLbJpRvGHS8e+8znzdmLhsXtUVKoEGeejOdGImAFQAnWhyXHxG+ni6xKdP3CyTTeDUJgWpD+Av9WMyUEfs7dOC95zooauPmlDXR7k8gjMetBsjiWsDZ1wSH3Keg7hHbR1EPI2RarlFlEiquUon4sGaapEe5jB4KExl3Q4ynbGI7hy+wwhPhFsaWm8ItxDDzt7sOzxPiYFC6iWE8ci58AoOCozAGouGq63Ywv4pvKvLd47ZTOHOgZfONhmlRkGa/hEhhStv4Jt/J098uZnpM5rdkCvLzyUuaEZ3Eo9q37cQPqhQi8325RpjP0DdQzRyVRzaRqpRgzpyWTW7gJWny81glQ/xONnCRYZhIICCH0TsIqA1qseQnYZcwj2n9AqNiS3Fh+fsyBAFYvx716+DL1FuqytBZ5qJ9bnsAWsJffnGDcyDNhfe/5UrS7cLDwcqyucH9H4hpRbJfOUp9dNkQY8J/JsfkqRnJ/xMzKXcW5aZD/eIzHbn9Y2QD69m73lcUh+z5nBVuvOuLfE7n9R/M8esCzehzmpZuS1Izhm5wn+T6RTEDvXcCSQ6qYi51p6NK0iaDhfcu7f8yFURtoQf6N2KmMaeR6GzK3DsGsVByizacbd/AzNkz83onQK2WxwJOhan8lsRf3EN7/gHtWXYsnzyYz3AJ7x+DPIZUFrIiGmsnDuR0TrFpCd1rLh2mxo4tmVqkjQNyRTKkZ1C+UX0/674RULNypn+WYlsovud5PfDZtyvKQMSa+Tzxcugkaq4bu16ZlUrNYI2nJZrZzqE88XDC5w+hThIvxXbZUimQhqMIzu9xPAE9lRV9MigWHuqqVRuzD9tZ7OOmpErD6NT83QLpT2Jz5efG1GN/Bzj7ICZDRkSRGOHjJLsIRWoKzMq7RNr3MEomp88T/M3EFmxXdTSLmhUqT5x1grk9GkSVqSiIjDIs0ic+3Az2dQIplxq+9inZClxQoYnDid/rtG8YVfhPK0JRMbt3bzxMic0iwGoFQa1sMip8BzhYObLFaadcTngaa3chSw+cZmRhB/5fka3eXBHKs44srhIh7lWIa2gfmSWnH+ib2xmvapOurQxjJopCL7p/jaEWLhBjSemMjTG88J4R8/KvLoU0/P3cUHjQX8eINPwhHbVrdLaU42nsz2zbImee83QrVTl6RlMHsxDcT9i5eHETJM9pwp7EBYl5mC+XpatjLrQ50bEZaDLfGFvPxP5otiUmAxvh/O0hQeimgfRCuiEvJtexMe5tq7Sai16xxrUPYTDwfui8sh6/ziOIzWX3XYAVGivy+FGfV5Cv44oy2/Bhp0u0RVDDo6Yf0vtiA/AUs2BeZefF+d8XH4EFWeebNxNyDgW10QT8F7btlb2DRnPxuhCu2Vi5NHmcb8oABFcNC48R2Psp9fxDfRv3rKthAWIn4IS7TOI51rdEttTklHeXCL0MuwzrvIZPj97gfk/Lh6xjYZX3Ch08yLvSYiXDpKpGk5LH7tNjvR4OHDYzAutT/jge0PjIc9xtTUFBrz2toRKPlrItS2EfyHc5cNbVI6mD15qdz5DD07s6mnJ3FmA5BM2r18Il0rPzzKNA44fJfLPaEm4Wub+ARTLP99QI2juplSS4u2HyXlhbtRosua+Zj2grumrI4F6sxkbt+TpXhtO62eJmtTtXBtCSt689l/nmexj/JL5yIkaoa39sUjyLZVSfmg/0kbeLJQG+FjEsmYKfgrhxmkQ47+melOXgbDy4E3n8BdD3s8lMFvEOUcDOcSaJotOXmUAaWUsJoYgoYf00oPyXweAmm55nPu5zBOl6yNUmtM/oY/pTrqDKc+W8hD24sTXBqCnu4vRltqfQx6tL1JDj82SPPheDPqBmLBbswiR7+ba0d7kfFyfvyC2Hnp1YMjBIkzLXYVyYvNDPP6zmveGvV10GxtwGJ2gZ0trvM1BfuWWuDAaJVDu5il23aSnT2ASL2TyAL5CLQ+/af1tDPVbe0QixBiFRkpIGEHXFhUNuOpzBu1TZr5/tpNHt2LnqGKWGYDVUHSBmI+UcPuFyfUpkyDbbEuoCgsTe4kTDuvq5YdkciPTzux93uFnhJlcqfvmIO12cJqujKNCgUSeuzIDOFE1Rr8tco5dyFuo9boGZ3tKnE93/n3JGaJcBw0Ewue7YdXhJNkzdXAgUw6XV2fYgJW+CR8PQY853FUq/fReVxC4BjveqBh/SS/LDauXjBs1+b1FvbEzju4cA8iU5+nkG0EH0jghXEE9iN9mpY9Ye4QaJkATVB+3iCsNjzjx2Smz9iiRxTBASX3kwvAL8ZMEYX8g2m5bNOO3viEDcITx6saTkM83Ypmmn1Amy521PdZTLq7x3YiSIaR+T3elEXZ4/6ePlafdFhXsyjShrh2H5z0UqUXgs6gFstkWEGL9hfq3N+Ufv4aRegIodkDaADR6bVJssTBgFp7fDRWw+gG5BzKgKZrKmN0kx7SSL1lnmsvClAgo+KYm2vOvZTuzqjHNOSGnHo7ZfgWV4W4QY8h3y3FKFDVZ11lNdKqRhgn9ngS7wbJBcjXSc9kqIu95fxejNG3zwtSEZ9vxCmwDIYW4Ej03NGxVDArJ8Q7rxemogRzxYVokXSGdIaAFSjrEvprwD8gDgY99cjgZzuoXu1MdyUEakoofNZEh/06FJKmzIHmoooW/WqeBfZKcAuvURiCY50gHxijIh2aGnN7kLFaE6+h+j8DOB4f4NCsQUxNF9YE5VsWjkX+eU3aBH6DcK5rghYdzqJUfbxPnLTeONck7NMqRWiHYLKtahow1DGThhu4w4zLvHQcK8rbGL14atIIW7IFOAxjH6DBatM2uTdIfRd3sV7b/VL5d7QI9WhjUSaWW2+yxORBYtj/oxcoxQyVAQ/t2g8M1CV1WKR+Z0FMMB9V36KmId27u0EHLH2lJ5K4Oo1//Ts3EagDgWDdl57xZxCvM1cxtN1c6OPo3QVa/eo72qS/Z9Aa65vWO82kAQ2085e+9tOBpu8qE4H1gToQgJWBCFSBOqABDawBECgDBNYH5lMyw6x+SxV5r37o1T7m7rqKD+eTDCB6KsCvn1TndvVCPXkhbttnbfdfml5Mw+uiUZpvccVf+2XEskisrQmvhnekhGXe+I1EL1JsMiOao7+hkSNtdv+w6QzniUioYcPbwRQ2dl69bwRV78aHfb3OvtjocllH+bkP8gy27gIwzdruZN7os1/gPFQdftqTM2UsVsY2sVoJeOfBEmG8vsnNnLRLMYb5vIpgEqk6owziwg8TURA0x2dnzMLa7J8w4ldpUYI04klfB0U0rEbSZagmd0V9uSxRLt6E6iog9ahFCzdN7/cQ3dQ0hSnIs5GCevimOe9A9F1pyMPhYf1xlSBWKzlNtYZ2YKaES5zZx0bUieklR6dWK/yJG3UUi11no6nCa9YTPGDcabxdzJwIoe609b/7QhapVtjthQxq9VsvEIF/avnl8S+v8MkiAiX+cVfWbu27YQb7vRpe/ykMw9slLX4mqabjLifa2uyMaIO/zGZc2kreMbSdZBas1bL3xEZdCW6BnLjUM3l6uMXd4bxrDCakfamFopIGEJn+ZO0V3MnPsbB6upZn352sR75Pg5oTOkP602o6p2aRhCr3sg24J2TTqyNI6IliU/LAQ65tYCeVOlcJrfBp8UCfT0EEc/ZQW8ehR56UcK6OD8UftKo3EYPzkyylTag9nA3/f6CiusAciUbp87BsYKmpuZ8D8p+SQQ37CZb1YAeF6y9jAMPb1zsG3wnGjA1eqs+y9BDtg/gpmVGhkaStBUBtBbT0ifDhIFM70ZIi8ZzHQ93IKL/Oq6o5toKduo/pkV/8Jpb7xmhnqGJUYCDopAQ3OsEhpkyRlR/1d5pRUFtopd3RakYTZeKzV3J6OkQIl/cY9VslEVo+k+ltrunv98D9Ufs5hJMuzXOge1O6bEkLtvvTzOcrNDpi+bLrwsoqzPZmSJNw/fBjw/RQ51/VE7Y4gn2r184h/UXPY8I5Qf502olkZvJuyu1620PjA8AnhpPgTJmDA66hwLMCyKSOweTlMb4McUC27VvDLj5GD7p419oPjH6MwLFVZvtzkHTOwvuYuOi2gIDNm6LbU3/uNfkV1xdK0cHQyxUgUvh5Y1u4pqCeXe03xeS/sNoBsRC0uwdyz2m92tN+hV8gThd+gud4k4G40JqG3EYddFbZ0dFQOK/L7gI6pVfxRFZ74Hjzay9pjYDCqzY1z9JgynsW3UsYuTbH1jLbIVx/1q4FJ3S8i0qqKFrJ96zDPzDVYgK/aFshi5NLMo5VVz3QkcqPD9O/RU5E+351WZ5MMnEdc/KyUjZzI329XXRkg3atiDjacazbZiHhjSNQ/9wkRxCIzDjNwsawZiKn76Fe3Zujru5tLHzEaJCny9W4r2FEUV8wka/RO//jSs4CVNcv4WZWvHpKblek3YxVkwQcVlaw9VyeNXzJR8ZLZyQ26o5TH7VrRfQWmdHobr98L3G+TrkTGpNrGsLSO9wUQQ8QXS+FLuKBsUgYsArkNHWyDuL65IRf5oZU/xwj0duPePy1p2tym9zVOIPYwuc08Opnst8G688dFHU/buHNU1vRcZU+i5rud7j2hMQvOvb+QXY1xS7dtt9mmZw3xzbThq6xY/tS41D7FxZ6QhMcC+wY61NUd9+VS24drs7TKt3H2K0UNSc0TmV5WHHElAhTtvkcj0jP+RWzMsyUH1R5eRTo3iS9ZibrGn5dXNuBRco8Q2o79ag9cd2tWabQS4G8lAzOhFng47k2haVpyBmAnN9dprLnQnNo5+Li1O71loOrR4ynav1TgY0do99NYK47HZ4ehZL9oOML48NHllzHehnSkwkyMhuWwJfPllOWwS9Z609/ail/eX5ByMv3ZaQPvascMuxwtfFz78MOR//yFfaH7PYU+1bWYZywx5i1/n1q2ZOeQ96i+HNpcYByFC+z6kR1FJ7O9s/y3tAZdgHfnMqnR7FNgI3Y9O+wwpu/9HtkAWsBfJ8HGSlSBTz5TpGlPTxaF0qb7zbPGBBDCIhsXyF7GMUr8haVY1wMHRyMWoHzRS3CFufHoYXwALQfmSkVJZfZj3n5a/TPA1/kQ9nhX6zQy0Qbf1kLfuXb+ELrL+scX/j0iZtnIsBUuKKgsec6xRd0+erK4gigz5JajrZq47weY9t+Y6zAGLxgJsm7w4MZgYfRn3e1AFL7q397mt529c0Yce425YL6StzqwhCZb7c/h214sAg/sK2O/gcXZ7DUaEdq9r+iP5VX1BcPzMUorj6188RW9Cks8UB1bWFoqcJXzZ/e2vshv/XV6/NWszxzr1fUBc1ferMzeUE0tRo+92z4BLFI3v68j764HDT5GOOQC5urntTHzvyRsU8DBxOs3I0HkuCBTyci+/GDlZO84ttIfd7T36xflJPH5YIycXHGJzNF+pArK1M8m1IpjxIaUn6712/tcyuE82/vqS1HAgpJXX30x9lLXqBjv+htim0DQAw+iYOnG/k0gPOMhl+FfjXrq6CXu3S1Pg+Cnr/aUZ2HB1WUFmPfB5jOEC4s1uJIb4XKlBbRGU+cCMU+3leMWtNwzUFq0Y6n8Y+A7QdptSUt+87DGR6H7vznD1Jb/540W9U2OgOE5PKT6xIWP8n84JvvBwph6QuPvA0p0SC8jZJ9jH6lUbL3sDmosi00+WO7+BktbcodnRVsAilVWdg2GCNwrUQx/N6p9x3fyL3A8PkugNlL87qA9UCjzX+kcg3td6zQNMi6zrrg4wNYPEoMo29qfOaIPt0D81jF3hO0kCg+fbjQlJ9qirOss2Czjt4vOjt/S4cVOUyR12fe/K4N/RN/YKULXs1qiunqIKlr9sNuoX/otKhYdIf+r2BgYZ1hA6RokJISem6CfJC1sIrZ74kv/HzzfiS7x0MpM+FBRxl31lrZaeuNjDG84/I+8tutVfwG+Lo8/zjLMvTb4iyN7tMM7AY+7eVyV+XS/cGv/gV8tN488THY9Ax4o2g3EUu3aCT571TQ1Exo2dsQKZuVofcrqywHPX3/tp/+rsYyyTBt+jhdXKki0+FNi4IfdVJTGEiPThIPp3jKAgxmvVC2ImIUZwRmwM2eoNxHNTom0Ngr3ooOzhFc/m1/oBWYDtlgaDxcYO/yS4V9qE8cNZ24ET/8v0WWLYXA01+Ss83N9MBuD6xPREDZU4Is55c+vKk4+0AvkxhOnyUyfFXWJ/mlUvYRu/GSWyZ6VlcJCVv01k7KaDvq9ubEYzaPCpOF7ua/miajz93jh1TrNc4qntb30h+9aaHRIao7FZFb73oyCCfaTC9vEgLa4H1N36p7ZXtFfOmar1yfU+3et35umKyfv5fp/JDBEa0Yk932lQ6NCWbJAb/Ubba3sEEkTqPl0dOQXYw7/wvL5xP7xacNdOM0v3P7D+4hAYdb2BtUm4iP9L4bNTsT9LD1k+alX0yp+hVHLVqs28VDsjWXlYRNwXr1J75TW7weGMDNWXByoJ5qMMM6SBabIjhUv4NBXduG2exkeUy+G/nQmYrf1rNz61YpkPbNriSUdrnfuY5P1Q9wb+K9WzZ3XjsmkfGNrT05LL6c/6zC2Nb9UOy8mV2w/8m4jxo3s6c11BWwWXHV0b2xt2n/eQ+oY1311LO+l7zn8KZoPsA33ByCR4wHigHqO0bKKJ+fSu8DnasiW7ONn1VKmSQUPtnWULjWfdjf1CggxPhBz+AsDW/VGUt8LGkzxoYY2WUQpARrYSvqsmRTZOUPf2Lprf952lhsz7f7hLiY0QwMygueaTyH8meW0091sMP2gPV2Nv6U0d5y88li+Sf3Z+V+je5ihYdibGRrf2qwKODraDGyXVhpWjxXT1tqFZXdypv/KRRINdMbAYk+f4/yppdGtpy5I/mQV1GKPSjxlo/e9IhUPRi6nReTWRyJWap7aiR0h116cgli/NCJ4XtrK8AFYv1TLro90Rsn+62s0LvusuWph8UedLsUYf2KqUjDXB5HCx5DwJvdrp6vlnabW7TuylPt5813mqYox9IY/BAJ435Thw9xcSKeRz4rxeD6ofTObjpGEwVZi11ozmmShnIRE/2mDo/fBqqjn5L/0UJ12WJnIJeHjWlHM0drS1cpoP7oK9c84YvU5zQ2BqWtWMMQZH0HuOSsJr9zle+mE87+lQv2E+hhCKp/zwPVshkEizpPdiAem+HT0CkTCy2YvRWHlYF6QU+9a6rSaCRUWwfHh7woNhOO9p/TGgszWte0msx7otBiWPdhyZqUcV5WjY8V5FuLfVy6qbMcby1z3XJ81Ft6ntP+iyb6Ha3fcLx/oT5tz65yYPObRM3uc8PVD+H4JtDRCjYbQWPNdsN2iGY8SuCHr4RpZxTEjTmswg8hpVG0xq6u8lt73PuT9YYlsvl14xgTKDjAgkbrPUOf7Jjo+Ns6zba9XQh+x+s0BJuXa1AMAeLc7B7mLMlgc414wpDmw0h0BqnOIj8y1E1mbPj7jweb2FpGcbcxnRmlzhAGl8cVwzOaRYLWMKMSB0/YIK2iHiuUgREO0Ch3+JcrntyhZ15OlcNm8TUx5Knl7e4TX1n+wxOSPL55Xm6d0+nJ+XC2LAWD7kMOU9DwY9x7pOHOkccLPFFzkNeNitggHfoSiJTPM9PhJrSmM675aQbdUpxcmxhDz0axHN5diVQf9mqrVh09QvZVstmuPLpQgKzAXGHJY1WC262IsYz8GU3LxgqIuWcIU7MZJmuH8orGnXIMe0xs+1A9F91MvihlncQXJC6zXPkCM9rhrvc5iR45NfPz9d/nz80/yT7MBjMpWKpIX1e+/2nuA1//893jT5vjJjAP5Oq5eZk2fJ1YXJdp1jcLK/wzWnH5uD0nJkfb4Z13Nyz3neNGS90Dk0Yi3jf/7KZX7YKnwMrWjQJ2tsivbpbseYtNGm978NDydppDbaZ7AHZ3LQ4LVjZftLTSCF3jDhtkxjPwcmMc1aHqk6O6KwlBLMttQqmQ06El6y+m4qsfHmWtbaXCoeXm9bVgrrUwOa5d7jUx08DKToow2rkpb18w11k+aqk2aLzkMirMZnwdLfEe1Cw440JxerbPxqs0Gl7BV2nmXTW72undgftPZGtUvbS8c3roDkWdKaLlKaNExemctHmn7j3/6r/9rDCSj05/Ry6SerWRITze/0dOC8DrE557yO9p3owFY5VDiBSmPM7DlWmrVE/CYsusw4o+xyp/G8UvLd0Mnak/TqQEOcD0bjW8IQkmcdoN63eHV7mCTb7Qfr62fPxDnninPFwzHqpITo/7KqYHc0MFLe6hEbDsiN3vLaL2FCvxZKBXynk4nQPKRM72JGC/FiB/2BhQT6S3i+vtB7vc5QfR4NuuNFSAOio4sF2/oL6dZczCkFiOaCpDNJ+weJzBnjyGATMa5eu/lcZZS9+/IszCCcXgAuia7XftkVZELqVP9cjgI1n0fBAXak3OutVpiTGOnVp4j1GNDxwmRkr50s7+cEmUMueoxNU4Ss+OyQbsRLgdNdFWOudvajGoNHmdMiYKodMn32dCWGtSZMi/poyVwqWYQ1MSZcVp+9eNUFp2oNpjZcH5krhgqox6TWLCDow1k5jwAyOJ5EQd7KyiU5LKHN8n3gCi9Vu3Ne2+KwX/GDwNOKFuwUzO+U8usmwFtQXBmIJG5/4mOjxWbJH1T772vtiufkgwuuIhLSyFK18o1vLxe4E+vYUCFULB6IpX6cMDh7KxeS3DwlZ1LW/8B4SM/WtKuCtxo72mMcUjs3xNE0qMdvmapg9Q1OqrfZbHrcDaNc2sjx7rV+2w2CMhY4bB8T655Dy1vbKOP18SDD7G6hU/y05qrF353wIoyFBdxeIbuyuKFOHKS12QtI3+iitVIN315UPFwf2rTxoGV16fLQzP9dJUl9pe9z+S0RFxsHTlTR/78Jpbkbz3XX73YB2K6cUXpF86wRt2gBBqwjj+Yr/F15c6SqFFw3D17x6RqZA99Mu1/3BImbnRrPmnDx0L6eHafzGKc4k1CttUoBprV/lNmK3dR1U5pDzM2NrYp7E1zFTXra0+P9sCoJVB3LeE0gOhrqxYIAl6K9dVHAJfW7OxNixKtiqVIXHlVwo1CT+LlaRYXV+7WfdcoT/uF9vjYhdvyFz9MdqZ1zbWox12/VbzF/2n6q/aRkGxbkfkO8H6f5MgSCzF0pVdtGexmqzlBf8pj7TI1Ua4HAjmnDtWnGjhzFyoh1Gjv8IZ5wtDAsuG+GIXTJWtjhIsGDKXvWKRafUGmLOGKwx9STqvxryh/y1keIFqZSu8ITBeZmJYNpT1Rgo5e320mW6m9XquFI0LKO1r005o7HSLQClJ85DcHPI8kbY2LAKdDhXMUa44+7rqKWbUKj9qR5FcEEzfQpOOf2DbnEhbbAhlqI74aS22JggBTBumVbfebSMIPMwxTuelXJPT5G14T3tyVhoF1VPzB5pJHtK1YDMIw4W8tPNjIcADIqxiJQ/XpMx/dMY3pFecvCeN44GkXbIxLkB2R4b0PbYhhlBLG+LssLCvZx/SYxcljnYpWcxlp+b31Eo1bY1plYHLNIZlpaYVNe4ymp0PnEP7AtMXRvBkfskFZm8dBgeHrRl+kMZsVsu15W520D3hiPqXTt+53fJCmjZZlvcKWBpOApJZFm9u2VnyGUGXyn1z9KnaUcSsmQvodevk+f//CtD5j8xiL/vAj5m1sK5p8FAzH5EEpQ1LzFaTHPlQLfPaJcBS7ZrgppdoNtyZa9AcBbP8G3SmWiTfBlJvhFuq11Ef7YXYSGeuxbPbjuqNcsaqdYMjK0RE3+jEbDVJHvFsJrcx3lw9KfnGz5B4oTHKGa1nRCMpIboNc+bqdQ/kmH9vIDLZ4HdHXbalDXfmqtf0o12K/hJhtF6vnzgaotqIyGSDds/GiFYJxY3MTDcE3Y61XxvlTFWv8ZsNE+1Ge0stMWz3EfmhxXI9UbCkm1cvwZltYXYHTUN9yWC0XiffhBrC6BKwVE/IT7HGmFQbHplsCK+HFD3YfwWoplsJfaXLQvJSwGhLEL4yIeJ00UZGZhu0jEHejuZGZaZbMgnvLRudWGyID0creGVjvKWGjGaHezS85DDXkmT1E4xD7u3JNC9ZZsPOoL1KXuF9XrZI31yx6CUD27fGNVgRfsKD9icjr+8eWA0kl1iFs2k1Oxr5ZvlgZjGtr7tUC0slP7spKjSZoAJ0VK/HeqqbfyUuv2S/kpU2QN7BGO5NCXEzcYmvOEMyA/axBy7shAwbNNt4pjVCDwYmqTpovd5YtQ6pFbVlvdNjJuMBEJfibJtxR5GFa2IWFmHIDvKRXhZNjxyjPAm+balcMInPHKNwJY39SkhwqRgN7qRzn4r6KVPW/ooDUDQt3uwkFT31o7pBPqQ0j+BMTByCkbqK5jBkD1NnS4c+zePlI8Inbe1vAtBcyyUwmer5TzVILk1D0P6NbCeJqY1taZKcSVDa1otb+dinfqumJu+HL+1PD0fRa0131uZOkYAmfxT4ymqmj2pnnZr17/vXdXJQE5tUIzH+4I+Z1w/+AXnz4E90y1P7+/pMY7/s9B91tt50qGKhUWxtBqvUWyz5TGK75QrUt5V4KPGQep6RprF+w8NctFtrkFallzkjq2UTJyMXTVg1qORjliR5ksIZHqWHyU35cIuRFLyyZWOKEi/UBEEUM6vLLJZ46t2o0au1nwgWr097roTXfGJZvRBWOuO1aYq6Gy2T9bt0KJ2Z07roFaPO+P25JStW9I7ws4VReDkyHuR4nsMO0SyVtkWTpwski7lacrLKMMnGLE3asXIuQ8nsogcVG0o+paqS8uJrSakPcx042FmYcQ6spVwphoVkrrlVd3TSxUXBk2RlkIeuRZwelbUHL42Ee8Hpr2cvh84FxXnR+SJEvj2ceQr2+szeOjJwD/fk2F1pa0lzvF0R8qjWNkMxLO4/OzevFrfObt5vouq3uk6CKNiUL6LVwBgHWAmpSwtvedqi8TO4gkM4v1tMxIJnKzlQb/sTT3pxVCf1BodCBlnbulbcoygT+A85Xc/0Q4lOcjTTeZiTkZ3RHSTM9CChi8V4/reQPXK3oknW9trwBFiDS2ZaaKoKtrPLg4SZLkjJ3bAmyoWxWGNq1NpiYRRzXE22pNeJz5tsgRjZx3MH6iDPRXU659+qzrdVhdKzNgzvR4Op2ItUWl2S1Frrykgvx7qCRY0VXEXGppnlhM8F1lKvW97V9DqOqbqOZWnfS9RyvntXU2Wi0TqpiaQusFWdd6uy3e+BEgbddHK4iDdw7I0LDzIhMWKbTwlLZIYkaJDhNW6YeY7aBm0RsZZMw1uNZX0g5ULIbvfm4lzQa0ZRI2rkbsdI+bnDtwEVlJ3Cxfvd9TT8XneHYq7B6pZABzJSMU68PV6koLbr/OA1Z3A7lrlFmax5jjfYss5HhGteIYmCxd/a5njgJeIQ6pge//F4WTFOyeEOKCHQ+eVQCtc6njpYUFo5via/jHETnTviDivA8vTxujGSYwba4ByBrtCYLS4I4QH0qDJkXds+hxWfASExlc1u44cSPUeRREghsxT1KXqAoPlAKkmO6jkdXJHoHfIu+6nauhGmVYkNH4yKO0EGhqJA3aZKOpA1ZXEq+gpAN9u31qjNV8PBKxPUBgnIoUePcw1R76+c3XFB0cBg2coA3RmFbO+gAWr+brAuYstdc07JzqlXHDuPdkVMOsc+Kq7vgQifeslKdmker3SNcmrf7eXOx7w0QJ4IyBJU8rC5D1aaicqDIUk4YfplFkji2AMC+xFwbd3mNezf3eqrkgFsAw20TfkjhMEnGA3NeMxYnJa6LffFzYGbjIKZtg0x220WzxEzZn5rhOMFORcd96ZzqbBqVMI9d8Axb8tnHNJNIB6zwwSzEgNQJUKiuH3xNsnkPoqWbabNsE3QavBa/wQQWyNsLMbr9bxrtM3Hm4v4LjXwvz//6XPx/V8HcDovKo/eNWBqymB+aRsFarcRCyP5+N5MKh2CRqbtCmyYn3M4XVrGeBos6jNh1z0R6EkC5gBWkMPtsb5trQswHwFmVU5BCBJU7Ndt++7XBZlD4RMqCU1JPhJbI00OVouWWKwHQ5gB55EpCqSMa9hayV19cAizArZ7hINzhtmdc/agbTN8ODbtw0Qo5rl7WFfYxsHtHZ0v14PozmkY4Eki3rtBFJ2L0R4jn+AkALMtwBBfBlcwbsHIdFaEKJO8Ku63KrYaECvcidWQ86s1RrO8JEYZrx4kPSWfAu3G1XH2S1OrixJbnjLhePa3A+e05z7VmXjeZVXveCvOO6ujiVumQ4+EC18hPqRsqnkntiBRV6fjo2y6woYcQZ54qICgHOXG+h9gKHIogT999cgdqXtgBEGGUTII0Zv3H/Gwugifq8FZqMBp9jzGcnG3LBIPw7nihliLv2X8h6RWxR3X6gk3CuOuaAhvSVHIuQ7OVgxFbK/oqyuTxs5uxQv5jagcCkk+WPMcJtTMuCvPoi0ucsvue4bmlIY0hwsPbhsXqPy+ZASlFee4cHJ3Bcag2h1KG+05DtSiXj+IYihi5tfH7FgfZYkNEhgO7HFLosFZT94ePXnnnIc+a8TFWdSl6Lkdj38zCuTwqfgXtasufOqituQQ4XRIKsxIhwKV/Q12DIYz4cIvE4Rwo9imSXd4VpDE10raOSWdx5lDGRR/4Xb1ogaSvhVKLYIsJwO5Ei+zAKEx5whVOACMoAuoo3lyyojlrWMJk1WxTCQRHD6QrFWCXYwrJqcaIbGPFqReSO1BZx5RJmKY19xpzLxaUdkh6mpPmvnfO1DQdRY/DwzJwHpXnRKwhBmvPuntVKcp9zgNWb/hRq2GYxCBSnCsFBNTQT4+DHMzpJ1huiALpm93p9Ha4o5/0KU6UpEAETgMtkXEfZSE8K6B/MhZuHUQA6x4iSDdPRauflh5txJYab12jjNiAhsNAyxV/1rCOBa/IZOFJdn2uqOx1RTzUlwPlOhkxS2lj7vqghuAeaVegqPAv+hJLFXooty+ziKiEDEi9BRwHw3mLiGXWnmVIgiZfT8tEmsIQxae9URtTSy7mJ0QS2eVwfrSGPqKisydGg/DqsjZBfLRQHZSN5JCUd/8ihNI2pl+aLYv3nxlG9IVII8LB/yOgLb49wBAAs1WWaLafwzZVnAnRDd3XAeZsWp06YtXapUPvAbO6JMsCamkDk5PW8OLEcqfz9imKGnSDH4J/878M51RlaFEKPMJQFX6VK3zGVqg6/VePrjWDg9UODC7jcm4cAImbetKvlg+HvKjLP8kpagFTHIeM7iOOsZfE6FKBvGbReNki95dt/sK9NVKhfyQ4ELaMJsW78d6aT3+7pXcnRcL51gFkVW35YjWklxYyuGnzLZpszTQ1UOYgmc+w3KmpWfdHUGUZpjBwzOHdFGyD8Vi4DLQbSVIkPKaUVEOy7HAgB9oAJ7RWaHe84jHbi9cXQphJRJdUMD+JI0/VVQQGKpjRr2jDiKkSyHCBteCXPDDAvs6VC3pacV/LZzcCqPfPR8Ot3D0kwOYS3J2xDGa7lBGywzWftscmk4NR1RxEUPMwP0MDr7VUTjnyWo2jrU0Zhp5WcBYWFQtNhCOAiwCFkyifMCYqYGzxI8M4VAGITNfphF+OEcn/E/IhjKp1EqSRntVfc4fv8bwLS1x8quI8kHulFIiC8aUalwbxtHvmcL3nXh67ijGCEkxCW1ytA2A7DsYEHiyF0EORUPZBNyATox7rpDfYjFYXiUU48pA12991OKqz/ffGoeWND4VvHAEly3+8XfE8HujYAkvgt0jCICLsBEZyiMI7QSnvGSmkSXMqSElwqp9O1VkYRDF5UbxIcnkXALP+93EccyE8xyMVuIkWPReXvYfeH1Uknipb/FUCNcLd7oY7zVCr5BVPDipMbv6UMhy9XcQjcFq/TTEzpVJUNGlQVopGLs+7iUXvxayBBxLcSqlZ/GrwT+lrMxKPrNb8hfcKe7J3zz2CI9l4+0O7oi3LH5MjbrS6Q8q077wSIfdwYADDRi+nJrdSnM4N8ZXaBh3b0TcPX6zhmzDBugLeaFcDMj19AcOUUM5CQ+IyZQ+t7ySo5FxdmR6FP8IFaABrDfigHIaRw0CEsYAow8AXvuWzRVQbiRJvmwNpz33KtI0RPfThcnz4CibP7BZyWxUFiByrVx9VjPuQ5OBnmnq60ksHmJHg79zM9/HC7/W3TGJL3d8PZKlJPvirH/phKkT8/wlPcEgIvwLKXOskcwgBKih2gxj0e4K38fjtV5QzOuTFbLTeSaqqdbVbfW06kUPGRPvDLGqgRL8QLeMU/zrJRIKjCJZ/PcgS+4N4RTAoV/NZlv4QDLLfBqBt3LY2wKHQhoyCRTBxJTFX5ot+esnym0EgK6HLrJPFEVac4EVzO1k3hSMrVW92zOlOwp1FVi1qILloj+abnCNrh4Mlc2PStJBIpnxpN9uKJs4N1qMPNkKX7CZwxml89zBxx2gYilJeEogzaTuT6WVFQAsTELTCikLs08AhGOOv6Qvi6QlV2dzHbQp96FaAHOuufhl7J//RZZotFMXCtC78ggQk/34JiFzNFp0y2Lxlo8wtEKmYTCMY/YHwHFFC7hFvEO8t1LDKvILAb9aUmseTngynMqpCMauRCyK9aaVrCaXexU0YlVGRFFM9OnF+/SZzCTr743lwusyU8FbxYoGpJJZGJHPalgvNg7NYsLs7EqD9eFy5VCdKyBKPcyO2Fc/9xIhe50j0KXVqhesSQMvU1X7VPU5YlQ7GxW4PQ8tfc40S5fTqC6hUZGE4xy6OGMncjEGiudk55KVlzEk7BwONL81k2gGP3p2ne1rdC2zXRDUx2pOXuUL7hTX3wNy33zhIJDYeNnjzxPdDE4ryPr4a+vwYBUJI76fM46sJc2qD07c7G4ZmcxtHW6n7lWSoWuOqMW/L0fC9BcJsEjME9ZGB+1coFzKJ/8YIuzjTqd2YUzZ31ku7W/tvWz7yms8eIxI+YfSl5i4Jw5MSkUjmBRf71pU1wx+dR87Ye4Z2TWS4R64aLrDmfBbymSjiPRLxp9loL7QUzvRCP9gl2QbHxf7DHLeciy6i37+LqOO+K9Pol45n0EqMT+FmWFRou1Gu5G/8n4JLx8qDamDr7yJUePTkRaylRC9aMPXb9t1P3+N25+bG1lYc7Uv+M3vvcA9HwdkVHrWen8IW9NiRsYuZrdXK4OanvPsx5wh4V7IJuq2L6e0+YrtTZzNcKfUKfm2lqnvvzkxgemLLw1Aaq2Mr6tFDple6/0nEiw56ZKLj4W67qSzP5ABG1GXHL06C2OPP+CXvGJ/Z3U158f4uzSo9WWGWuofYfnx3muhuE7XSohBn3RDnpwMBP8OJd+SaPSr5cZHDH5sCVpxDVxy0Ls5Whpt6BVLwJnjzEOZ6V7ReIiFjGsubMTLBIZUZGRgLJHizwJtsskuDFW4KIruv43TSDIeh/SWUt/2jGSJ5/Dz6+MT8cjlNiBcgMtFFTmEt0RAcNDbpeNNeU1PXfjRCoWR7qa7YiBEnXA1l+uHetEohZtWfcXYozsHIY9GMvAZKxXDs/JKVQyjMiupnZeInMq3YI06nbU78zQbl9ky2K6sp8eyqphwGH9q90zVxDpg312mZT8wt9b5tYgys+ICVf18ma4Y0lBsoWFJLPb01k4LqCitG+RKr7PqGZLWY96nLxp2b+NFxlw6wdgr8JCBR1Qns52jZyL/hW1ivjgWQWJoxEyp96MO6Px0vKnhBhApq5sD9KRExFzUYk3FVdodBfHDh8uXFY1chZ1YQvYPDqCP32E/K5X/YCVFT2OeREZBgwnPWVplIBml974sVVLqVbEKf+2CNZcKTqSVjhmp0VSObUbIoaiK2kQZckfkBV91Rl5CW0VER88spzZh/HnmQppN8fjPqZK24QDGnokLIYZ3T5cdEvw5Q2LXfl9P1CL5Kk9xhx1uwsGrPhOQ8Iu7jzEg8YMaW7MWOzAFffHaVTjum+CDVryOdS01xbKHcBCjsaKuwuTll9CMSWwswiT9JqXoE0WyI7UvIv922AJJd7cTQmtqOzO0H6WjJAuzkfihbh7Ql/7KjvL3MP54VCJ3Sx/u4OQZxHAPNKRT7+FGpAp3Ol0T3n5dfBG0upxtaKnuf/r63lVLrEWvPUvp4fsLomeuMJTVPKLKZF4xLIKMRGHfdKiTKx0rRDMsnnRj71RUB9mxK4MWIp+gAMnpnvSOcLH4orNXtNcK9m7INlhFkedtuTsBEniQvp3cY7x72VNYaJZ3MYNQlUq15E4rnRczLCyJQNjTuEIP6+O2tX1UdwqmT36tmOjEj0mTKWqxXGicV+vCrIbLe/LgBivj9SV1M79Qrv7/nXd0WhSCPCcYtHfTKynf7MrR0Ft0xyJtHRgAKldeiFyyfXXA27Us8MYzD6e8/VFsJUNPYkbC7+hie2NiuiXOTpySSukVAGkzt+/M59RXKKtVRCdxRSvy63UMeBcQnn2lur9Hld/Vo0DWHQh9uVMaXaha6Gd0eDc77cPRbv67qbGwc17M0lb0/kpbODtHruKMd590fYOT02h4i0Yq5rpNaxtHur15QUaqz/GRKl6lpru/iT4uIn0sQY8W5YiF5rR8NxhmafBNKmVpo7y/wjRwRjBdxGvgrfh/Inj862qDV3DUIZbaGDwCaEMNu9T0aYiyl1K0oJegOVV69nxa5kYpZIwzDI/XlZzGn5JSW/1KxoDq9mbO6riTO+g9MqWnJr+uy2SqLunDwpWggqxpJaxIAB4pjA6BDGgF6MajrUFO3hB6PTTHI9PFGglhct5VoI1epjWqbejOP2HjjbRBXjS9nVC7R27zavLqnYW+/ktWDB1jmzvY8O5noH4DSlfK9KQ3dUTyhsplqUM3MNPN3exRFdNab6fq9O0ZrXy00S0IXFs40tTHKrq+6eje/NJrUpup3F/8rCmcDwJ6wbpKbMQPoBVhQY82BzkiNa+LFHqR/aUJIOhVr8NeC/fzNCT0kLk2vYKQdSDQySo0fa8aVVK+3q7x7s6jHE4Z8TQn2/AC5wGestyTbQfoMySUSJ448lqIwbK3pNyRHnEZ2SF9OKXGc7/0AxpUT9sZB8rDVDkN/XKuZ4hUAuPG83KpDG2YuNtWWJBz5k2NwnxNxNGhGsBa/DZehqYLuKLjEx2B20NLMQEqOiRkicIDbWzPQvNJVojYOIFfiLjDJQ63IfY8ArNC6QPIYDyokHOmKkaqMV3ZnxHBonOM11IZURQZd86rYF3n4jpqQdXhR3Iv4nkN38X4xs8hxPtTjlkWzEQFLHoK6Il4KljkrN3FSkS6uaFox2pKC6w3I1iUsrOKQ1BlO12Da127IZvI9AgHvkm0OeL6b0uTh2zjK3rzbJzo41Vgz/EhQn/Wa3F/GM1uBCyP9HcmA4qZiquHh4BSZGeECegWryqGdALLOKbjeg4PdBg+aOaPKlymJ6KUs/2dZWhbNNTdyeYy/jzS+It2txsuGepxfTdpDh+IRdmEhR0CXaAuxQ7vwe7Pi9bxFh4cCjuErhAPG9h8iAxm77+dpIE3vnZBvtcW99hI20I8IilpAW4vST4BoQ2JkzrPO/FuKMo9F8aq7NRdJToNBXsJHPIiwCjGCgyjyA4aVykw53aAPPBr1o3k9wKt9IxDPW5GJVe7z2K9Lt4H2iwlU/6OZnYhZCQ59RRDR5CJkCSCsKwsdwEUKFJeTDYS1yVfihM+KFV6AJwc/Lokc4Ei0O1kHTkEYxNLZk5pfsyjYX39sGT1YNLHkfVDSC2K8w6XhpDAbmNNAA2MY+09FyUDJwa7M12FILlIBFehcwhQvhIgHHhR9bIXwqhemEbFWpepPicdKPcVezApd4fiGsr72tUgUSiTCH2QJ7a3JNQgwXq8yaJ4WW35Qgw6mVDnX/JbvrtSD6JX+WzLfGgWbI70byNEk5ig11YreHoD3aeGtVENCp9RDI2pnCfRJMDOSk6N8nwdGcl8Za1u/2TVlpK7nhjqB5Xiipv5WDfYHOmoAZMgitGhHpBf0thqeA/V2Ed5AbnnTz0ufAlje23unzGojJQeYeMlY0q4f6b+OpVkhCBSI65pHoz+CP3Rm6eeUbVrpF5tPt9xS0+er1KTRn2DOMWR1gYP9BjR3cxaCFA4iBo9ddzqoaIC9kNvuQRLEiynNybQVEGjR0qvQY+Ha9r0xGwINE3vGrhmdp5SIL/qcUqJXT3/0vnTPKVcXFa3ONVZ0X7V5i5gWib2qmbhPqyI55V6MFdAHaN5QBmYaRDbE3Nsmk3KKkRZB3UnfNOJsHASlhzKv5mAG50uIs0fmLKDLMZGVerdw5mUENtzmSv7h+8VsHst/ey1B/SpQKxMr/79y2p3q2rZYumz/HetQ1NFQqcMvrFpcYvBIMNu0z8U8CzO7XH6/1JXd8UT//UICTOfkPPTkLqN2exwG87GeBQhDdUCKWo04k/KzlqPy9I3UVY1AiwtV7PHE6ojyY9OYawJO97QyNLlgIIzcicZ3nWFzg0k9PusJeWYfFIGQXtmcltcIaoDr26yoxw3WprOk1fhhmuYszN8dMdR09wSU/uFB/T/QbPDlUsIV7/MIUoyvcHujJa6VN5OiQ0d7cX79+GtJEkBFieggCapaKwCeh4Js7HguhohUm3sROtrIWoidYNXJJC+GeajbGJwNM4SNySUEPpHYqXsGBzK6lWa41n1RMcIQ8MGqBeBUnZn6AJIvxA06aMWXhgIXrKjTkVw+e0oZvtT9hvAOYiA4Hb7uaWllV0d+WtB+W2aT8cV/4XytEBaXUJgWso6CF1AdMfsdvFG0QaIjOF0YWl9icBJ681pPrhZh3UYDCHI448qmPUlPuIORhwAtP8C4olzEPDo14oy0HQ0wMyf9gRlmFLfREeHyyC8uNnWotX2qcXxTxAtNeL6iuLY1GcrklMrOMg54OcXaYg6zddI49MY6Z9XxJOVWPGmKCyN0frwyezMlHFN9qd+F3RpwgTVztpzJVs5lzgQ8u29Mbf3YOkXYdJucpE2q0jyy/0IdGgkwMMzGXCw2r45Mfi3teabpZb1jc7hEawEziSlCGfkChoDo1sjLaJBIyfMkYQOdVKhRUFLRAXpjoKGehGwNGQaGohJJAlcfk803yTPw8T2E5Vcjs8XTN2DudEGgYZVyUxqgpKPdpQDdTPVy44I1DrVskOaZ/2n8qG3Roq+/WVgp8iWqATlLXhkCtcqygAreSuHOw6HROobqDIQVJqyffRzMmuTNYVmRXYo+ZsYVRfPgp7a9wYKk5ksk0MHpMIh7m18GHRSbteh3UzaAWiycf9MeNrZqJikI2PdVN5X6xYnX0gKDJPMkcnfKxpVb37qEpV5aSpWg7+ahxRYZoIoUhlT6DEqbJ+fKSGbXCskAmDPwZCtVCOxHQZHyJgAv62tb1EZGNIeA5jh41fjPcIuSeyGm06HNky/jvE6hrfzrZLzLz2iLo01Ayh/zpnzYN3i4LtgxJPaO6pWHV4e1So1k9Tl8Q8EJawZg+3lIwqaf44GEY32WW5vGRVEAJdmyrCJfnhON4PlBBzdejJkak+qf3wVzPFPjJfzWABboOAH3wk2YcNmOLSPZbVvKXbLAUetj8W7gRoOAIG+hL5pWN4CCnysSMwgvJsnNmuiFlbhXX2hzRA1qCTJyH9XxYGYwiZxHjNK1AnXSFYNi8XNwa133Ie4c22g3jZDnA5379ni3Cre39IUK0Uz+rjQ5fWAYNEEisH1k2LprXDeAJQa/tWNkkDOT0pPuwNpHWmf5xIRi31wk968WqwbVlRMFlqvB4TOuvzzoO3NvpimWfTGBl9heE4sh9mzFI1nw8OIQbtmebgZZ6oLkD8dYF34rljACt0g3bpyJ/WepaR9RCC4E4L2dYqZ5vJzWTqagbW6+zEcOBJqPqNenv98x3ZcAe6cCmBeOVxT4y8OiVeiSOD2Si8cIvQDphcBHKcVEd+C7ateQ0mwBojisJ2+YKQ07qftEKDZe9sn9eMrNC27gvKZfrAV9qhNT6kL54n4gsd6AF4Gr/rC9PkpUcxuKH3BQm9f0LzoK6WtT0IDvqJqKcuK4SBFjOsO4WxmyHxzD8bR+CZit+wY+jb1dkOzJb/Wn+sZlnyAWqAvMOlsGgtaORYQsZmItfbqHWhfFOUTs8rBj8uN0ge9iVAIy6xpaPlZWYDcmooTGsBUO83Sw+G0Gmmg8z1dH/fEkC9bKzroAD+wOu1DB/bW1Mg0NqqE7lep93kueg92sadpBR+WqZmeVkXpGXlgdS4wTy/TBBKd8WIH4ZJs040/DUuUcq3fdcJyzymJNX0MsLcv0axw7O6TR8MkhCgi/c3XyW/fDWJ/HxqzwhqvRp7bWScRzGlcQaK1EKvR2Cpe5FOuIIzKMIWoa/vTzSL3rFUCNX2wIRxPjmNRFSBimFVhDX7VowaqWtC4IAsCMOPlGY+507EtiYmDCfE4GKlYP2sHqeC2lBaa2OR/MF5PqRToHGhMXTL5ckz9gjBQQRYUMTQIbIgWFs4fJu5nNmPqB6x0U6YbnxZyIggrjE5iJuYBB5I/6GyUokcuuJtACoINyjQDpzLi+64OnXnGB5kxV4YfOauEHUD2hu82ipQYSursPrpSUg0oRmoS1CWaYv/+zDe7ymaPBEAVcsuheVz6CKGAGQ2CZ4tf96LqRNCvtMblAIxPvkRLMVijwJhHy57wJSzmxyqNW7A9OAS2lF3d0gj70LSbE56lfSkCIUn0mHSJCvfOsVmQ05cX8WJoigB1KKLhIe+M6OBTyoe1vbTOkErg4da73ctkM3fh0ek1kpepYh5M1H1ZldmG0rLXxyvtiKASXT3odsSNYG+VCgXIQhwYt47N1uPSiUY8hV5GUI2THlm4zxNBj+U0Xag5bdS+Kb2LWG0/ftg1Ru/gAlMIG50eFhJ70M4s9bJcfEMF8c8p7hfQ2J/OT6tIMuO8hM4lmOxZkgRyGMngxG27qAqz4mH4yCckydhSrma2uOmkwhRA46Jn6gIU25wBGuDOOfBbEh7fyYc6rjoTD4cR8l1OvsMebpVlnEUqzV8nX8fIgeYJG4gzbDEy2WrOqHss6af0SyEI7+NCT9aUA0hvo7PkQC6vO6jBPa4JtsZKVQ+f1/TIQFBKFODDoaxzQ5R5/03NacpO/9M0TfXK91LiE0XaOiiKgseRUqTv/+sXOWbRJb6rPyBKwcgK245NgbSedTXGRXPVYl04BHOKla0kQMHQJcelQk2LeslL30mHE/RgQhKv8/kBc2rseYkuSyg2CE1TbcwjAzz4IL1YkiiMAwj+kZLLpo4NDkbunbw9QrGZiQ8LrF9mXZ+hueNWr8ymvpMy3w19+grWtNPTlYCIHyF0C2cecZxw/tIC/RmWSCYt8uFI8WEEdI2x1Nk3u58W6tN7Jg5L6MtfAqafdzW6emELknfc+uOt/k/91NJ0Rd9hcLdM1kA2PlJG6yLRINBWPUKxSoOZk2HIDlEFCer5eA4tWrOjO6GN7ZeiCI8dCOgS1xPOJdBzJEaJegIkg7PFdpl/97E8ZIWE1CTrLwIhizST73ZicOdmM8NsD9xWl8SLdxBKzEmzTWaS0TMSB5fMrkW+SBQkcsxuY2BKisRabBeZ3Ze/TBFBV7X6IScBjk6qlbVzz0BI5nuVSeMhfyt/3aDU/fFFVwI0H30RxSBKou47GqKXSwqXsYLVp7Fl6qJUWepE138MoADgVXiX5bkxF/TVdvqdeu3Qa+/pyX4bILYLu8O/+zxHIN9FZrWZeSOMOW6DUxaQqyjbG+YIZ1/EHf/rc1b4PZh1zA0yZRCUrpfWIghYOb4uNOf1xf6psLSzLgC+HfB/G89mdVTEPvVxTEe19G3m7mhOpTG6aWSoMcXhDUhMTlJlj+UdoG/KDj6jHYy0RmuyjjjBXr/DJOXiRShaQ03yE6kfe3zCBH8J18dRnBeH7kAj9f5oyrQ7q3t8QIJORprfp5vBcVvf0PyVu6hqRdewCcAssdoTKh+f5cxd1o0f1/qNyahWFzNajkE0FJWr8t0HJxcr6LhKRCW+um6faf5wNqDDttMNLB2V1RLeL3NN9p5etg5JgWtTmE5OHlDHDq2SlujFmPqM+1Vj78yY5ZG7aUc7VOwSCyqjrb8AK+9dY/H1RXwKZC2xwFSV2mgUs1nLfzqnabH7zAR7XlwtgpROBrjB74ef78Trv04QOtGD/2bG/n8UxOvWQixxvGYgC+Dy8JIGExYrfV8xY56v7ORXD0+N6ENHO0OW2hza/m4TImyUmkhMr0r7aqdEzPuJ/i5jvZggaadiPe7QETsVHVCI97k0vmQ2SxUihj1+FAiLy8CG2KtqQs/2tIzIMlWZo6qDtIHWsYGXDEI4zIJCAlDfgoOqxgVqj5HeiZ28KeDkl29r+pPWHRFK+cHyZPrDggOumPO3VS731mfTXn19e+o1tO7avY5zxzwNyuZAm9bfhnqxFML7l63gKxEcYaC4k3LB4u8QR8qaZmnsBL0Pet4BxPj+WFiXbq01n0Tk+n/oOQ3snfkRdR875QBY5X4EamHbshE677L6ChjUNd0tfEMP6Z20TyKPOVQOPyiZeQ5ipcb3NtPJo7RJnU8NS+JH8rggevxr2e5nPcPxnp4HqQKKZI/qGZy1ZJZ76Paw5BffV7mqQJeL6XVdn6IrdZF3iCKdWWE6kYrly0MnhZs0XtJfv+0xVDw8PVVAUBWOmFKcIsOkl7a9LtE7Wv049H/zzqCSgzTtyUWXeQRAWwMgYRulFz8R9iJsP6JlRtJfszjqEmk8RUHDDPJz5g2zb9mDkxE4JRg/+kw82KaioQCDKMXyEzYIbafktovdExygerewaDVIodCkQ4a1sMQz5QWfoBNgLLrR/k1KMI8GOux1qr4LGFqsJqtqaHaF+/Yoyi8YWG6wWYHcFSHYh15wnm3zCeyVoFgMtCGTlm7nxrJXepdbhkKiDPBMHgqDzTriIEYSBcV2sZkyRWoTAROeh/x0lHp1qCgGzJfJ4odTbo72+b8GMa2TofdOZ5+qMUOJZrFCGiJ4OrPvbJh8xoaFY8yXDSeyxkIgdJAi8xRmbqUkpA5XWNN7T4IYfYMeEMkR9PYTz8fanPYqrVuZNIHXpkZvGGguTFr6dAQ1SvpnStUNwTTaQ+CTw//gsAv1hr9uKZNVBgnHxwxtA3thp1jcUb+b2VYgVegngxt2gnzGQDqfJYsppvK1ApV8zv0FX8AM0eNzBqKtjEFh3GXkFB6crXpudF39K7+Hhx92VQsqbzoJH4SvM3hnq8YP9Vsf91NnyUE/Zdky+tzHUigjNE471OJQbaa6RTr4C+jRrZVucGv9St8jFgJK9Yg5fXG7DyBj7Se+kra27Ub/E5ZFNRpqYgbz7R/xgpe5U4SlJof17d7dmRfCadjWvdPoD9V1OYU4avwVpxtD32rq4XHYB+k4h4zI0s1kZKdgDdeowoKcFpXYT96VeKQwdxQyfM6l6C3ryExq+k5aXWqE8kja6uUjADsQMrbcrUCtnF8c8uvXKaEGunp+Dh0vFtCmsqSIYJZdIsxubTLTwcTg9aE78IdOFhEwCj/GoWkp0rfD2gm87SKDBPEekDLhU8t3wzCxMibhYIibV2lfk0zv3z/ze2apCRw/PKQTuNvWrPTT3bBraQiBUCEh5IMcUn/nUtGpO1VLxsqayI1uvPGwtlzxfPq/3QdWMTj+vmnKdjxJ/dqEgTk3blQaXlN4SotRrepyShjxYZ/wWeiSIuxquQ/G6VZR/2K0eiIEajGnZ1uYBN+T2RctQlgTHqMp2aB7cm9ExW/32Fy8/GMqdh1axj9Oes1xmOTCpxgfjrc6rbXiOK9TJ19nVdCFhCQboR5BP9anHVwUHJYNkoWykoSKFYpMTydTDoWDxy5k/2QkzTE6VAoXgRQQlsLkQcwxeV2nRF7JrutOMq2VLgCqaHH+x4DEjZ4HrbXMB1poyD8a/e7Dt+BSdlzzFo56ARH6HV9QMzTSCcGUOfO9iMqP5WQ10f1YDusiLfgzHNVQTG8BUrS+wDG9CKPhL0r/Yr3apTmD6Lnfg5VCrv6J6U+Da2EgtR7j0sRyXxIzyzlpTAQ5aiMAiGrdS9CTVw1Ojk8cMSo4ChNeYTu4ZyOzg7eJj6avuMxSduI3ze+AvIcZymZLBLCH8JfBr1hdb3IyqULsr9LFoGvqUhgOeXBkoFADqZxc8KmSoRO4ye/Hfw+jQHoWiixG4gjPUNeLrdg7MxdT1UDiLGLydfl+hxABSLUu6HM4yBOmgVULP74T6zdOQrMd9y8eXSqykQNVoZ5Ye4G/7NwS6nc/2Z7F29WIs5TWs9ge5ogJQLb6/ifDZSgU6Uogh/tTU5CvBM2yrYs8C91Xt3BvVJ6U4PXQvWPqKQnFTMeh3myRUxuBqL31B6aeV5s2AF5kzYWBe0YpyZtoTXZzCSfmPGltWKlzUh33gK0SWCoxkWiLHx+OIjvlhK9Lk9VgsLxjk7VExa+MEmJ1SJKM5IyoBDqKeP40LoEXEkHf1KAVWPNFfw+GpBxVVft7mWrg31iJ8LHytB/KvL3Mc1QfBkRlVLbjari4Ec0BrDkCm3DmV3DWwyeTgi0AEXcCnB0H9WxNnNOb9tb/+xjl0+BVemHJeRlUd2ET7dK+6/gxVIkbvtBUDqelyCt74774RwtJa7pQgtakhM/FQ4cW7dI8W0TvmfhdVNFVabiRMbF6PLdRuqrYTLRb+RW1jE2YXVJHUXhJDuVXkqlppGVphM3QWg6qcBkOYVH80N3Ji0a7+wVuJM6/lEX2w3GuDqeXj+9Wd1QXvr/5Z/Iu/PNB/LcEIq6GKlx0v3JLBlG1Sn8dsfK/nbWMb9kV3HtwuozKclmKZCXoGiZMyvY3+/b5/id04jqbEM6dXo46nNSRcskfUH8vG4cAHITPcmukywHkKJKDbGgwQmsGZgWgDzLc+kaJ+HS97/UMnx/MRm/RuaMe4VPFAM+nMu8aJIaiDmV+CIy3enYvitzLuaYOaSfz6OM1VFcDb3s7zr1BCmNLpOipflmfcfukr2jrvwnCIzyDzPn04jo7tpxlJtVRyiMRYVoPjM0Odex6d/I+rOdwBIYJQJWfvmxfd66b5L2nBS1cgpmSITqjwxJ+V5K4nT20FUNzXpPP/wgYzBE2MS80NwkfSdVkyYJF5azOMyB+BX3FnorD4giaromb7wswpm7/2K8ULoLbK4CGRghApr2M8kwVwEtSxv+z9cUKNLYv8KrSxaD1K6PttVEzg2bvIrP3pTXBDdvp1f6omdV9uFa2Aaj9aWsP/dhNBXmJaHmhMYT7AIQcQrX9MJPrYms6QCZWF/6W5is2o6dKvQQnfFTZinrZB+es2kNuwGwol4K87KL9+4Vnu1UKEEIZkGFs/AQDZdINusUUx75Bhzxx80ziFWBgoBcdc9JxMDBsCslw3kZ1DvScm08snCIet8WGDV4pvm9k2wABeeIUDnQXMiIn5p0SQ95NKhjJyOMO1ROJdjkQUegHHpCq7Ds+LhcAD8aOoqd6VRtNFuh5Ntnzs8dUSx9mh00VmUFYM63r2YQeaLjNUGOkN/du7M1nVdCzKUbQr127XfVOm6LFXNyVvZCKADjPyEsXegqK/3Jzrjz0B0swZwWmpSjmNpFX/CuUKJk5BRfmHUlLFcnnFJ4xZDNqOKe1yvhTKXOdv3FA+yeiJyzuGIKHQAoMF3PanmZuXD1nX6VIWkP/1vFn3oZ2kj2Hxk2uh5twgj3pzeGOVrDguOhPnBn5qr0GzMcheEWIVbZcUPk6IiJ2DiEGvhTWR4nkC1NnwoMM415hn1nq+3uEWtarJBSxUI/I+D5gc4968jmICDwFSa7jjImdQEdtx0H0h6YuN9TuWXV8uIFJcKwtG0O9/4SeVRG/15DFJhmr7CE0Kp6QQgOjrAvtw6YRXoIq334J/2XqsZidSD1b58EDLVKx39Ud4G318YMHW77G4tg+TafQQbv2xpwcUhbi6T+hVcxvA5ZWc1WE+VsAJFn1EwlqHsNoP/ijGQHearhE/gyAxmOBF37JMYltSy79sJgS5PKvM4x1a9P3NHNwiXKzqG422wDQ82Kbq5ZVCkgR+h2PT4RCWAgv718cU+MhO/uzW5IkM8Tc68imeNiEH2pTHyUcLs3RAo5oHt2Ya+o4u563Y598/jWQVLhm+c9T49wETtK/wfoKzkmd2Cp7jrKQp0Vp1PawvUdWZEkiAFnF3JvIKqntUXH+LlinAXtL/m6Hxa3tCAO5th91vG8Msg8Ynsk+GLXfzl5Tr8lZME1NcqE7MvgqvYDu9AJAlnDodfnixpUS/sih8Znx2oklv5iFGzuTqvDlIU+NG9wDpfqQuStui57ocY5FreZ9tl5vorKYx7dZIGTFw0WF7DN4+laddb27iZ4NxE04Y+ZnzeojiJqWFmMRPeabnXzVQ1Yh96LXOy8t+HqH0mX1AgYZM6DV258TjBz5qvSdut7hvG9DXMMwOxEpX6guQpz1bxzy3ZAR+YaBYC9G0H484dIeN4jcY20N1WcCtlkfL66zy1sXW7Sl9ba+yRa1dTm4tNLZVFVYA5mJgGMaSEk/zZDz5qpYSh3ca/TkqtPKajg2sxifJir0S0+pf2TOlv0haDPwcIPIkA/vzUmqH5GEi4zccIXcMYKYwFyTdIa38LLP6ciMiD3xKUPBhTP4ZB2mtQxHtWXm/BmhArjS8h//bmZBsDGGXWeUhKRqeUkB4cHik4cDUbo66JoV5+rWfSf49ippdIlWjSzQxGDbqL2iURF3qEpTR1NHGcSQIoHOh5W2vBpMxSV7UrX43DbBl8GxMR0B6xf9UQJytRN8gV4nXtojMH9KkbJos5gkj41CB2cRHfIBhUFQvCxDbsNbfRUmACSRLgbshz0x40xgivKq8NLMxrz7zJ4hy30zWw5A9pOkAaADX404MQBaebRInQsA6C6PJQRdycaeKIBgFjHww/Qu/5DLAneMomavL8tDU8iYsn5d5wjfv2vtQjVZpBH6utH5KgeIJDq+XQQiG/o9IfkCgH5/kc+8gIcno+YNSFvtuqaN2uWe+JwwbJWFpYOb+sPermziIx5dV3RW5YILDq4QFALXvhtBN0p4RWi+cJxDY/cbys68/JPblam7UYW5n2Y5NNfZAMY0L530TcNBP+i6VhI6SoCocXJ4ZbsUn41bv5vNirwzMYM+yCrJk44lk2kh0PnBtmIFi0GFSGWi5+PmXGMN5Sd3qhsLS8hEFOW1QYW0rkOSKq99/KWcn4FUg4h1FNdd1AhxomBuFBqbl1HUkmkRuAdgKwGAO1BCI/8Fs+FlEMWopcqY9rFPMRlu3WaVcCiK/FkyCcO+SS3fhZJ2zkj+KkrCCW0beZh6TcPsm8gXo324LGx3A7o+V99rjpb1/RUyPoWe+jCwp8VFUN4nEO2h8g4iJ4863UDcHFoPackpLBTiNmyrkR1SXlRmgJOdliCmi3+7PIS0gZBhVJMdh77NWawJQBrNgTCgnROiGLPwD4L4qvjfiii0rrn9RsNtUdQtBTmdmLJ3aVVIi390uFPOIQVVAlpdCpiBCiJJ3aVjz4jQMwEbSAEm56kA/IS5sw/4mAY5CeF5PIwkGs+dLjIw1UicmSn0Wl5CHYImR7KVe1FEnanjBfPYs1Us1FYE9sbtRGk8o7o0hNiHPZz/Nmtcc1pAlpn4Nq+EzN7O4MkwIgz6uKr+cFbPg1+rOlc/AdRzVUMNtarPSjCu4Xb+sthKlpCkE9yuu+hgBZYNfQlQfqQggy39c1SBmzhV8Kxd8cpvpL1XnCLCvl17vKW9wqo/nPgah+CZcHQ86/oDCS3nxgJZ45cgvDm7MNLJXYdjjOfE4DZLIVwP0vpxPyeH8UhKL2xf2s75ljCFib2g0jcU33yBeiiP3w7PCP2ZWhuQmkSPLK4GAvWRjY5i3+z99Hz+LwmHlkF7cez7ZUs9vBaQZsJeod3fcjbmMiI42GI8HzarHNIXNz/kZWkPLR1mG9/mIRqYhPbkH5d3GuRzmO3vZNVsHhR1Pt8e/ehwNHN8HuFyL8+04P/T6sexps/AZfb+BDed+VvDFXebwlC89kStRpV27I9ibM8AYNFW1qhZT0JU9OCTd4c9fU6wMi+iT5S7CYHX/eABVcFA5UL2Nvc4qJoX1LOJm5VDJvhY1eM+3LuC80mHlSFifrBf/xWIteLZlcjX5Pyfs7Ck3XqSwEvI9TrKfSKp3jniwCI/vKKA0PGZrd8NBYUwD+uDZX0Rxdf5dwnDv6YE2KKH/HKeRQDLBnYV6R01Uf7LDW45W8MMWLpeM/vP0BSfcvfuz0EI3lCqMUhl5dOJvqvIIz8CvqslCtxcevr/K0DYXjen7kQgXMLi1J1soPYu1/vQh+R0HBBmUeGRiq0KLLes6tX6WQc3FyvlzIzBZw0ektHDwA2MZTd7UQsPDSyi5Xw13l36o23SDSNPUvyMbhC1nSbSPPnDy0fkIBCu8MO6rz/MV9XsgVB1jqvMzRtW2c6smQjAZpxnm32UDjfbgut55tuKfAmi0ZKdbE5+FsHpTuTWB9VWlTGmfODSdPKsIiJKFNM308ner5pf9AwEwicpDTlJSSiCjxCIVK0jesKtip2gsQxkrYpYnt3YkU6g21fRn7IxwYlzlI+zJk+JHutgnF//cIuVc6b83+mBgvf805/21AZh48l/D+jJ7Fp9fPozkvG/KgMF59jbv/ww6PZJmnChUDyHJpRK7i7mbcx67ntBMmR1Botb7ggHQQSeOCic5zKnphfZ8YgB/GnUYmcNf7KLR2e7t7oHCDZayCLi1cjNNmqWmny6sTOzd2ciBPcbipTG5mAeJr2p3KqONWK0hGmwDiaOz+h8i1MJsswM0+MSgHteY+G7QYcjDizYuQncm4HNVM2yEzrcIWqLz22IF52YaReKZBVnvifF4mNn8Xm9Q7tJnChm2/ctepCPYeh7E0POqq2s2GJMi3OASicUapICzMgpGP8eVjzD/x2G6BLmIKoO0xeNO82cyBOvI5///KkWJDWxMSTFEyjO3m63StxtcGwNYZO1n4QLBMJEAW31FBK8lTuK4lio7OiEPLIY6XJ4hQkznVNypCJLFwdfkq1UBAFXhyv2LjwrzYlZcxDsZLszpjZB2+jSHkw6IrXeqccMHhTfFYQeZKtKqJ+G0x3uhtmo+mR7TKKQ+XhMVmK9A+pmb4jM166oI8KuoRt5Hm0A25yqPjRzzLul5UCLo+NrOHw+gqtiO4CBNo+HvwN1Pp6i47vidnsjIm02Z78EUmUCSbHGr/W4ZPi/BQBOiBbnzTV+Dwqp3kVZ/LyeJGQntyq+lf53xGdZDbwvD5I7ecCWPEe7dZb0qP4J4w3UN/sWg9N39ifJDNeFNC3cmGxN05IQz90DzlaoK3Ghxp2CNsT39HnhHF2GoeGdzlHj8iYxC+Ei1msvJlGqKJAxAop4xOErZCVuAMnGiKqMsj2YdLS/6STJr5DoeTRPl5WOCF87Z+l/Kltsb05No+RD6VB5DHTCRVT5IqOfzbKjFsOp00S65cp6V8mmPQHF4PfYLVxRzWOeT0DsxRGRyHIdB046MfoHnm/3jomeY09e5S0H54R63P9urz7hSie4oOrrpWC/cmiVg8t70zPuphyivKooaR9UKGhRCv93tYh8JwTZbEsV3Rly/U0QfslKVdjr+Pdhh/32H1PfSQ24Y4efQkIk8aTPK8JYdV6EbaD57Om9V37GVDqda02+q4s4+odwHmoKTukgDEPPsBsvdrIqkbMJ3JFYYiVybJG8uI4xL4fYqpyHNvPin9K+e/ShG7wnc5+y5oOGW1zO27PW5vk/zFTfPKjP2edyuK6glz8ralzWmNOoQsTS9YMJG3PDcZY8FSATDxH0Ha9lMAceLNa16opT3KzH+VA+v5Ky+FAcVm3Sfs39iau0MhQ5wnSAn8Oq4kWyZwyFa+UlCTgs/lrPM3Jmp1ELgfM8wkuUMIOR+6A0LzWAZQptcAwqR3Si7qB5+CYo9DWm1ZEQPH+Awb2Jh7Bl5cC0fIP71cdMorGl4lXgSBA2uEy5XrcywWjWUPA1kuSrjEmELa5F7UqPGuB/hqZt0kymvnRmk0niCjfS2eCrMyODZ9KZGL7KjiqIsZB0ODlpLbw3RUc9JvNJaBKcfUZu+9xEUL1sIr++ZoGhWMiPnS4vH0+oaRodgVRmz4nUfugFJRnXZ1tVXn1MM72NpyEAeAblldRpxG86FfoyaNUJm1+14ioLgNncG8Kcft2R4cs2xbXTAWxZ7quIVkyRdodEZgWW2QPGWTjuJqs9iLcpFDBTTkPlkQa5JLR5Cr8QLZ6xko2fXyIFAK4lWB5h65c4gJGjWcqbk477b+aPfjzQFOfcPUy64bEENZ61nJ3NAaz+KIq04It3LEvVoI7UYR7AX7TjF9uTMy+0ecJVqZOQRY2dA71PGjYCqU/QAITcQkx/6CXCJR7pRBEBiLYExI8XkY/cq3eiAoobNqrp1gVGYJpwP5apntVgqlbyWiY6M5uUSR2s4FaLRKVUVJTnKatCVEXeTMh5YOc4BGQ6JP+uitBLjkpWvhp/bVRf9mRQIQC+rIOyaqOFpcxqVk+pzFyKfVANKS76Dwyo3brbTtGrLPARvwtF31xYAphLg/r/8WISeo6D3aBNlKV20kG6Ilg5WHfJm4AEIjdxrd8UIyzgIl92YtI6JvTJN5/TeV2Bo/l0gRGLLs0S3Yr+qQeuV/iBSOf+bPs3aiFMkAg/eWstK3vaA1+7sysnILbfGipOr+gzscvJN6N8ynfNZUN6xLF32pPUyz9DrJ9ammo3KmZHRS3l1uMxBGs6xd0YhJxI6A+oKfKPRqwfNq6NbF1TiqxZmlAJRH0gcOeU4Zp2XfxAmhC9558FKPlr4SmmlQyXhLeH5uoD/tITfREpyDMBJdIlfkfZIHaqpnu4V7N5KM4B1CditWKqEM4JZh6ya1wq60SuHivTi+6x7Z0g3E5cbuy0/++elJmGXdO46AmLamqyuh5BIS/7DBKAb8vb78bYhGO7scXgXXSL3YC9nhyFe2RREHleKmy2MNt9mG9M6Rm913UogjjhzZeUSRr3Y3q5IHkFkURcMRnLd6kKsKXc7YJ2TRn+NQMuG9mT6vs9KdSGQ2/PEmV2X7CfcpfqpHJbNS5zfgeNFezWMZrbp9ktM7W5jY0sgqKc88DOUi54TjiU//Y+DGxir49bx9MNmcQrcynuym9R3SmOmDSCY6/yZNX2YYtMKhlay6LfRrnlWRCFhTlT0mJLIPDxY6h+B7dN5oHwJAT3qwoXU2fURIsEhq4gNemhsec6kW55H4BwtHlIv5Xr+4NbeY2Jv0KjUHcSktPwgjOqiu6adsmKizI5F0aMR0MAyOQmOCjVFBjS0kMSS/uyHXaD3omQUVBEUW2RDPkQiMJRfps0TuS7aDbyU/GOxSOi2Cpm3k+IGWnPdH58sLxC5GLM+d+zwn1uuAdgBva0BMmdWl7T2M6U2lRcUkSBGPYI2n+k4BZ0+xMgmPpHztoazbOwODu4DSkvDHlzEG2hM3akh+udKmcyl7s1cfDxP18CTetdw+r8qU/Az6twEz8JCq6asUORNa1Y5Gvy9llI+bIa5tSIakjCYkW2Dsu1sXQRrYCzlkOUIorydyH4vN6o3ml56hNj4vLW9Tg7P6xrWMu9Sa6DuxUjtnIIDpcpbN40s96WkC1D7CRssodIvM/ACi9UXDPcSsQ+BOiOpbg+jSC/UGarFQs/96W8e08DHt593ur2rCtiLEomiio3eTx5Hc9L0XZWq15o9C6Fdk7Ud06iXU6OX90zFjN8OSi6FLNU+aymXRJezuTQ4gzuuFIcYiJ4zez4vizuqs7wF6COjixf/KKHDQ9GfjGgeJeZyvo0MtZYxGMmsS/ChHw+nKx5rSh0HL3rgq22n4zwZP3Ru1/eVAi4F6Aq0dwXoEqsYx11XoKiomY1+iFokgdM4/1EbowsUwT3hhwX5XwSUvzDEQa/MPTBCrJTJ3sNreLPNeBT6BUXHw093MstDPBB0DrAhJjAQd5TJhDkLAZ94HsrxVYn5+IGENshrracBqzJd9hWBlEGSOl7vHltr4MefvvKKD9CYzuf4M+YWIvGrSsxX7Z4TDHWLx4A7HImMBXp+s8naVzrhZxOSdBHeUX9QjbG46OVSegv8JqcogXeqFYAdwe2bMdCLlcL9JkoPdOyLGFT16zJ0U2XAGJKQAHu44Kw5RCk+I5rAf4IXfmSLj34hr5Nzm+0W5LcBvPZLtBhqcDPKVWsaM35at4Hry/BvSefZtSiXgFMDK9m5egjfm0eVp/k/N16drgL8QTDfqieMKtfyC1ogjwxNz6E/Xrl3O73oxuuA/nIDE83cJG6S5oc/cSl6ryfotyPSyCdfwaqexR8QCSntUf8dn0SHafy40qA7cX9pT0UUktG7qQAXqJ4kfiYxxuWuMzT8DVou8eHeK0jHZJRmB3s7SGK3PELuSlAPBoOaj4atnoo1JwA2BQGbME6hNzzljpHRCb5KphnI4p6I7Z6DFz5LVPq9WsRD5r8kAuRJ34A', 'base64')).toString(); + hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); return hook; }; diff --git a/packages/yarnpkg-pnp/sources/loader/makeApi.ts b/packages/yarnpkg-pnp/sources/loader/makeApi.ts index 943c1d0e6655..e76ce22b5545 100644 --- a/packages/yarnpkg-pnp/sources/loader/makeApi.ts +++ b/packages/yarnpkg-pnp/sources/loader/makeApi.ts @@ -2,8 +2,10 @@ import {ppath, Filename} import {FakeFS, NativePath, PortablePath, VirtualFS, npath} from '@yarnpkg/fslib'; import {Module} from 'module'; import {resolve as resolveExport} from 'resolve.exports'; +import {fileURLToPath, pathToFileURL} from 'url'; import {inspect} from 'util'; +import {packageImportsResolve} from '../node/resolve.js'; import {PackageInformation, PackageLocator, PnpApi, RuntimeState, PhysicalPackageLocator, DependencyTarget, ResolveToUnqualifiedOptions, ResolveUnqualifiedOptions, ResolveRequestOptions} from '../types'; import {ErrorCode, makeError, getPathForDisplay} from './internalTools'; @@ -522,6 +524,17 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp return null; } + function tryReadFile(filePath: NativePath) { + try { + return opts.fakeFs.readFileSync(npath.toPortablePath(filePath), `utf8`); + } catch (err) { + if (err.code === `ENOENT`) + return undefined; + + throw err; + } + } + /** * Transforms a request (what's typically passed as argument to the require function) into an unqualified path. * This path is called "unqualified" because it only changes the package name to the package location on the disk, @@ -535,6 +548,9 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp */ function resolveToUnqualified(request: PortablePath, issuer: PortablePath | null, {considerBuiltins = true}: ResolveToUnqualifiedOptions = {}): PortablePath | null { + if (request.startsWith(`#`)) + throw new Error(`resolveToUnqualified can not handle private import mappings`); + // The 'pnpapi' request is reserved and will always return the path to the PnP file, from everywhere if (request === `pnpapi`) return npath.toPortablePath(opts.pnpapiResolution); @@ -853,6 +869,29 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp } } + function resolvePrivateRequest(request: PortablePath, issuer: PortablePath | null, opts: ResolveRequestOptions) { + if (!issuer) + throw new Error(`Assertion failed: An issuer is required to resolve private import mappings`); + + const resolved = packageImportsResolve({ + name: request, + base: pathToFileURL(npath.fromPortablePath(issuer)), + conditions: opts.conditions ?? defaultExportsConditions, + readFileSyncFn: tryReadFile, + }); + + if (resolved instanceof URL) { + return resolveUnqualified(npath.toPortablePath(fileURLToPath(resolved)), {extensions: opts.extensions}); + } else { + if (resolved.startsWith(`#`)) + // Node behaves interestingly by default so just block the request for now. + // https://github.com/nodejs/node/issues/40579 + throw new Error(`Mapping from one private import to another isn't allowed`); + + return resolveRequest(resolved as PortablePath, issuer, opts); + } + } + /** * Transforms a request into a fully qualified path. * @@ -861,8 +900,13 @@ export function makeApi(runtimeState: RuntimeState, opts: MakeApiOptions): PnpAp * imports won't be computed correctly (they'll get resolved relative to "/tmp/" instead of "/tmp/foo/"). */ - function resolveRequest(request: PortablePath, issuer: PortablePath | null, {considerBuiltins, extensions, conditions}: ResolveRequestOptions = {}): PortablePath | null { + function resolveRequest(request: PortablePath, issuer: PortablePath | null, opts: ResolveRequestOptions = {}): PortablePath | null { try { + if (request.startsWith(`#`)) + return resolvePrivateRequest(request, issuer, opts); + + const {considerBuiltins, extensions, conditions} = opts; + const unqualifiedPath = resolveToUnqualified(request, issuer, {considerBuiltins}); // If the request is the pnpapi, we can just return the unqualifiedPath diff --git a/packages/yarnpkg-pnp/sources/node/README.md b/packages/yarnpkg-pnp/sources/node/README.md new file mode 100644 index 000000000000..c6f2b60f173f --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/README.md @@ -0,0 +1,3 @@ +- The contents of this folder is copied from various parts of Node.js v18.9.0, run through Prettier, and slightly modified to fit our needs. +- Linting has been disabled to minimize the diff with upstream +- The license is embedded in `./resolve` diff --git a/packages/yarnpkg-pnp/sources/node/errors.js b/packages/yarnpkg-pnp/sources/node/errors.js new file mode 100644 index 000000000000..8236693d93bf --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/errors.js @@ -0,0 +1,71 @@ +import assert from 'assert'; + +import { StringPrototypeStartsWith, JSONStringify } from './primordials.js'; + +function createErrorType(code, messageCreator, errorType) { + return class extends errorType { + constructor(...args) { + super(messageCreator(...args)); + this.code = code; + this.name = `${errorType.name} [${code}]`; + } + }; +} + +export const ERR_PACKAGE_IMPORT_NOT_DEFINED = createErrorType( + `ERR_PACKAGE_IMPORT_NOT_DEFINED`, + (specifier, packagePath, base) => { + return `Package import specifier "${specifier}" is not defined${ + packagePath ? ` in package ${packagePath}package.json` : `` + } imported from ${base}`; + }, + TypeError +); + +export const ERR_INVALID_MODULE_SPECIFIER = createErrorType( + `ERR_INVALID_MODULE_SPECIFIER`, + (request, reason, base = undefined) => { + return `Invalid module "${request}" ${reason}${ + base ? ` imported from ${base}` : `` + }`; + }, + TypeError +); + +export const ERR_INVALID_PACKAGE_TARGET = createErrorType( + `ERR_INVALID_PACKAGE_TARGET`, + (pkgPath, key, target, isImport = false, base = undefined) => { + const relError = + typeof target === `string` && + !isImport && + target.length && + !StringPrototypeStartsWith(target, `./`); + if (key === `.`) { + assert(isImport === false); + return ( + `Invalid "exports" main target ${JSONStringify(target)} defined ` + + `in the package config ${pkgPath}package.json${ + base ? ` imported from ${base}` : `` + }${relError ? `; targets must start with "./"` : ``}` + ); + } + return `Invalid "${ + isImport ? `imports` : `exports` + }" target ${JSONStringify( + target + )} defined for '${key}' in the package config ${pkgPath}package.json${ + base ? ` imported from ${base}` : `` + }${relError ? `; targets must start with "./"` : ``}`; + }, + Error +); + +export const ERR_INVALID_PACKAGE_CONFIG = createErrorType( + `ERR_INVALID_PACKAGE_CONFIG`, + (path, base, message) => { + return `Invalid package config ${path}${ + base ? ` while importing ${base}` : `` + }${message ? `. ${message}` : ``}`; + }, + Error +); diff --git a/packages/yarnpkg-pnp/sources/node/package_config.js b/packages/yarnpkg-pnp/sources/node/package_config.js new file mode 100644 index 000000000000..e03d1bf92871 --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/package_config.js @@ -0,0 +1,120 @@ +import { fileURLToPath } from 'url'; + +import { ERR_INVALID_PACKAGE_CONFIG } from './errors.js'; +import { filterOwnProperties } from './util.js'; + +import { + SafeMap, + JSONParse, + ObjectPrototypeHasOwnProperty, + StringPrototypeEndsWith, +} from './primordials.js'; + +const packageJSONCache = new SafeMap(); + +function getPackageConfig(path, specifier, base, readFileSyncFn) { + const existing = packageJSONCache.get(path); + if (existing !== undefined) { + return existing; + } + const source = readFileSyncFn(path); + if (source === undefined) { + const packageConfig = { + pjsonPath: path, + exists: false, + main: undefined, + name: undefined, + type: 'none', + exports: undefined, + imports: undefined, + }; + packageJSONCache.set(path, packageConfig); + return packageConfig; + } + + let packageJSON; + try { + packageJSON = JSONParse(source); + } catch (error) { + throw new ERR_INVALID_PACKAGE_CONFIG( + path, + (base ? `"${specifier}" from ` : '') + fileURLToPath(base || specifier), + error.message + ); + } + + let { imports, main, name, type } = filterOwnProperties(packageJSON, [ + 'imports', + 'main', + 'name', + 'type', + ]); + const exports = ObjectPrototypeHasOwnProperty(packageJSON, 'exports') + ? packageJSON.exports + : undefined; + if (typeof imports !== 'object' || imports === null) { + imports = undefined; + } + if (typeof main !== 'string') { + main = undefined; + } + if (typeof name !== 'string') { + name = undefined; + } + // Ignore unknown types for forwards compatibility + if (type !== 'module' && type !== 'commonjs') { + type = 'none'; + } + + const packageConfig = { + pjsonPath: path, + exists: true, + main, + name, + type, + exports, + imports, + }; + packageJSONCache.set(path, packageConfig); + return packageConfig; +} + +export function getPackageScopeConfig(resolved, readFileSyncFn) { + let packageJSONUrl = new URL('./package.json', resolved); + while (true) { + const packageJSONPath = packageJSONUrl.pathname; + if (StringPrototypeEndsWith(packageJSONPath, 'node_modules/package.json')) { + break; + } + const packageConfig = getPackageConfig( + fileURLToPath(packageJSONUrl), + resolved, + undefined, + readFileSyncFn + ); + if (packageConfig.exists) { + return packageConfig; + } + + const lastPackageJSONUrl = packageJSONUrl; + packageJSONUrl = new URL('../package.json', packageJSONUrl); + + // Terminates at root where ../package.json equals ../../package.json + // (can't just check "/package.json" for Windows support). + if (packageJSONUrl.pathname === lastPackageJSONUrl.pathname) { + break; + } + } + const packageJSONPath = fileURLToPath(packageJSONUrl); + const packageConfig = { + pjsonPath: packageJSONPath, + exists: false, + main: undefined, + name: undefined, + type: 'none', + exports: undefined, + imports: undefined, + }; + packageJSONCache.set(packageJSONPath, packageConfig); + return packageConfig; +} diff --git a/packages/yarnpkg-pnp/sources/node/primordials.js b/packages/yarnpkg-pnp/sources/node/primordials.js new file mode 100644 index 000000000000..3d5e8bf4e43d --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/primordials.js @@ -0,0 +1,15 @@ +export const ArrayIsArray = Array.isArray; +export const JSONStringify = JSON.stringify; +export const ObjectGetOwnPropertyNames = Object.getOwnPropertyNames; +export const ObjectPrototypeHasOwnProperty = (obj, prop) => Object.prototype.hasOwnProperty.call(obj, prop); +export const RegExpPrototypeExec = (obj, string) => RegExp.prototype.exec.call(obj, string); +export const RegExpPrototypeSymbolReplace = (obj, ...rest) => RegExp.prototype[Symbol.replace].apply(obj, rest); +export const StringPrototypeEndsWith = (str, ...rest) => String.prototype.endsWith.apply(str, rest); +export const StringPrototypeIncludes = (str, ...rest) => String.prototype.includes.apply(str, rest); +export const StringPrototypeLastIndexOf = (str, ...rest) => String.prototype.lastIndexOf.apply(str, rest); +export const StringPrototypeIndexOf = (str, ...rest) => String.prototype.indexOf.apply(str, rest); +export const StringPrototypeReplace = (str, ...rest) => String.prototype.replace.apply(str, rest); +export const StringPrototypeSlice = (str, ...rest) => String.prototype.slice.apply(str, rest); +export const StringPrototypeStartsWith = (str, ...rest) => String.prototype.startsWith.apply(str, rest); +export const SafeMap = Map; +export const JSONParse = JSON.parse; diff --git a/packages/yarnpkg-pnp/sources/node/resolve.d.ts b/packages/yarnpkg-pnp/sources/node/resolve.d.ts new file mode 100644 index 000000000000..508573a26817 --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/resolve.d.ts @@ -0,0 +1,10 @@ +export type PackageImportsResolveOptions = { + name: string; + base: URL | string; + conditions: Set; + readFileSyncFn: (path: string) => string | undefined; +}; + +export function packageImportsResolve( + opts: PackageImportsResolveOptions +): URL | string; diff --git a/packages/yarnpkg-pnp/sources/node/resolve.js b/packages/yarnpkg-pnp/sources/node/resolve.js new file mode 100644 index 000000000000..f462f394b7b9 --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/resolve.js @@ -0,0 +1,374 @@ +/** + @license + Copyright Node.js contributors. All rights reserved. + + Permission is hereby granted, free of charge, to any person obtaining a copy + of this software and associated documentation files (the "Software"), to + deal in the Software without restriction, including without limitation the + rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + sell copies of the Software, and to permit persons to whom the Software is + furnished to do so, subject to the following conditions: + + The above copyright notice and this permission notice shall be included in + all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS + IN THE SOFTWARE. +*/ + +import { fileURLToPath, pathToFileURL } from 'url'; +import { + ERR_INVALID_MODULE_SPECIFIER, + ERR_INVALID_PACKAGE_CONFIG, + ERR_INVALID_PACKAGE_TARGET, + ERR_PACKAGE_IMPORT_NOT_DEFINED, +} from './errors.js'; +import { getPackageScopeConfig } from './package_config.js'; +import { + JSONStringify, + StringPrototypeStartsWith, + RegExpPrototypeSymbolReplace, + RegExpPrototypeExec, + StringPrototypeSlice, + StringPrototypeReplace, + ArrayIsArray, + ObjectGetOwnPropertyNames, + StringPrototypeIndexOf, + StringPrototypeEndsWith, + ObjectPrototypeHasOwnProperty, + StringPrototypeIncludes, + StringPrototypeLastIndexOf, +} from './primordials.js'; + +function throwImportNotDefined(specifier, packageJSONUrl, base) { + throw new ERR_PACKAGE_IMPORT_NOT_DEFINED( + specifier, + packageJSONUrl && fileURLToPath(new URL('.', packageJSONUrl)), + fileURLToPath(base) + ); +} + +function throwInvalidSubpath(subpath, packageJSONUrl, internal, base) { + const reason = `request is not a valid subpath for the "${ + internal ? 'imports' : 'exports' + }" resolution of ${fileURLToPath(packageJSONUrl)}`; + throw new ERR_INVALID_MODULE_SPECIFIER( + subpath, + reason, + base && fileURLToPath(base) + ); +} + +function throwInvalidPackageTarget( + subpath, + target, + packageJSONUrl, + internal, + base +) { + if (typeof target === 'object' && target !== null) { + target = JSONStringify(target, null, ''); + } else { + target = `${target}`; + } + throw new ERR_INVALID_PACKAGE_TARGET( + fileURLToPath(new URL('.', packageJSONUrl)), + subpath, + target, + internal, + base && fileURLToPath(base) + ); +} + +const invalidSegmentRegEx = + /(^|\\|\/)((\.|%2e)(\.|%2e)?|(n|%6e|%4e)(o|%6f|%4f)(d|%64|%44)(e|%65|%45)(_|%5f)(m|%6d|%4d)(o|%6f|%4f)(d|%64|%44)(u|%75|%55)(l|%6c|%4c)(e|%65|%45)(s|%73|%53))(\\|\/|$)/i; +const patternRegEx = /\*/g; + +function resolvePackageTargetString( + target, + subpath, + match, + packageJSONUrl, + base, + pattern, + internal, + conditions +) { + if (subpath !== '' && !pattern && target[target.length - 1] !== '/') + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + + if (!StringPrototypeStartsWith(target, './')) { + if ( + internal && + !StringPrototypeStartsWith(target, '../') && + !StringPrototypeStartsWith(target, '/') + ) { + let isURL = false; + try { + new URL(target); + isURL = true; + } catch { + // Continue regardless of error. + } + if (!isURL) { + const exportTarget = pattern + ? RegExpPrototypeSymbolReplace(patternRegEx, target, () => subpath) + : target + subpath; + return exportTarget; + } + } + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + } + + if ( + RegExpPrototypeExec( + invalidSegmentRegEx, + StringPrototypeSlice(target, 2) + ) !== null + ) + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + + const resolved = new URL(target, packageJSONUrl); + const resolvedPath = resolved.pathname; + const packagePath = new URL('.', packageJSONUrl).pathname; + + if (!StringPrototypeStartsWith(resolvedPath, packagePath)) + throwInvalidPackageTarget(match, target, packageJSONUrl, internal, base); + + if (subpath === '') return resolved; + + if (RegExpPrototypeExec(invalidSegmentRegEx, subpath) !== null) { + const request = pattern + ? StringPrototypeReplace(match, '*', () => subpath) + : match + subpath; + throwInvalidSubpath(request, packageJSONUrl, internal, base); + } + + if (pattern) { + return new URL( + RegExpPrototypeSymbolReplace(patternRegEx, resolved.href, () => subpath) + ); + } + + return new URL(subpath, resolved); +} + +function isArrayIndex(key) { + const keyNum = +key; + if (`${keyNum}` !== key) return false; + return keyNum >= 0 && keyNum < 0xFFFF_FFFF; +} + +function resolvePackageTarget( + packageJSONUrl, + target, + subpath, + packageSubpath, + base, + pattern, + internal, + conditions +) { + if (typeof target === 'string') { + return resolvePackageTargetString( + target, + subpath, + packageSubpath, + packageJSONUrl, + base, + pattern, + internal, + conditions + ); + } else if (ArrayIsArray(target)) { + if (target.length === 0) { + return null; + } + + let lastException; + for (let i = 0; i < target.length; i++) { + const targetItem = target[i]; + let resolveResult; + try { + resolveResult = resolvePackageTarget( + packageJSONUrl, + targetItem, + subpath, + packageSubpath, + base, + pattern, + internal, + conditions + ); + } catch (e) { + lastException = e; + if (e.code === 'ERR_INVALID_PACKAGE_TARGET') { + continue; + } + throw e; + } + if (resolveResult === undefined) { + continue; + } + if (resolveResult === null) { + lastException = null; + continue; + } + return resolveResult; + } + if (lastException === undefined || lastException === null) + return lastException; + throw lastException; + } else if (typeof target === 'object' && target !== null) { + const keys = ObjectGetOwnPropertyNames(target); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (isArrayIndex(key)) { + throw new ERR_INVALID_PACKAGE_CONFIG( + fileURLToPath(packageJSONUrl), + base, + '"exports" cannot contain numeric property keys.' + ); + } + } + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (key === 'default' || conditions.has(key)) { + const conditionalTarget = target[key]; + const resolveResult = resolvePackageTarget( + packageJSONUrl, + conditionalTarget, + subpath, + packageSubpath, + base, + pattern, + internal, + conditions + ); + if (resolveResult === undefined) continue; + return resolveResult; + } + } + return undefined; + } else if (target === null) { + return null; + } + throwInvalidPackageTarget( + packageSubpath, + target, + packageJSONUrl, + internal, + base + ); +} + +function patternKeyCompare(a, b) { + const aPatternIndex = StringPrototypeIndexOf(a, '*'); + const bPatternIndex = StringPrototypeIndexOf(b, '*'); + const baseLenA = aPatternIndex === -1 ? a.length : aPatternIndex + 1; + const baseLenB = bPatternIndex === -1 ? b.length : bPatternIndex + 1; + if (baseLenA > baseLenB) return -1; + if (baseLenB > baseLenA) return 1; + if (aPatternIndex === -1) return 1; + if (bPatternIndex === -1) return -1; + if (a.length > b.length) return -1; + if (b.length > a.length) return 1; + return 0; +} + +function packageImportsResolve({ + name, + base, + conditions, + readFileSyncFn, +}) { + if ( + name === '#' || + StringPrototypeStartsWith(name, '#/') || + StringPrototypeEndsWith(name, '/') + ) { + const reason = 'is not a valid internal imports specifier name'; + throw new ERR_INVALID_MODULE_SPECIFIER(name, reason, fileURLToPath(base)); + } + let packageJSONUrl; + const packageConfig = getPackageScopeConfig(base, readFileSyncFn); + if (packageConfig.exists) { + packageJSONUrl = pathToFileURL(packageConfig.pjsonPath); + const imports = packageConfig.imports; + if (imports) { + if ( + ObjectPrototypeHasOwnProperty(imports, name) && + !StringPrototypeIncludes(name, '*') + ) { + const resolveResult = resolvePackageTarget( + packageJSONUrl, + imports[name], + '', + name, + base, + false, + true, + conditions + ); + if (resolveResult != null) { + return resolveResult; + } + } else { + let bestMatch = ''; + let bestMatchSubpath; + const keys = ObjectGetOwnPropertyNames(imports); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + const patternIndex = StringPrototypeIndexOf(key, '*'); + if ( + patternIndex !== -1 && + StringPrototypeStartsWith( + name, + StringPrototypeSlice(key, 0, patternIndex) + ) + ) { + const patternTrailer = StringPrototypeSlice(key, patternIndex + 1); + if ( + name.length >= key.length && + StringPrototypeEndsWith(name, patternTrailer) && + patternKeyCompare(bestMatch, key) === 1 && + StringPrototypeLastIndexOf(key, '*') === patternIndex + ) { + bestMatch = key; + bestMatchSubpath = StringPrototypeSlice( + name, + patternIndex, + name.length - patternTrailer.length + ); + } + } + } + + if (bestMatch) { + const target = imports[bestMatch]; + const resolveResult = resolvePackageTarget( + packageJSONUrl, + target, + bestMatchSubpath, + bestMatch, + base, + true, + true, + conditions + ); + if (resolveResult != null) { + return resolveResult; + } + } + } + } + } + throwImportNotDefined(name, packageJSONUrl, base); +} + +export { packageImportsResolve }; diff --git a/packages/yarnpkg-pnp/sources/node/util.js b/packages/yarnpkg-pnp/sources/node/util.js new file mode 100644 index 000000000000..4a935db794f3 --- /dev/null +++ b/packages/yarnpkg-pnp/sources/node/util.js @@ -0,0 +1,13 @@ +import { ObjectPrototypeHasOwnProperty } from './primordials.js'; + +export function filterOwnProperties(source, keys) { + const filtered = Object.create(null); + for (let i = 0; i < keys.length; i++) { + const key = keys[i]; + if (ObjectPrototypeHasOwnProperty(source, key)) { + filtered[key] = source[key]; + } + } + + return filtered; +} diff --git a/scripts/setup-ts-execution.js b/scripts/setup-ts-execution.js index 8a8e4c0ac4a2..a2bce3cd3548 100644 --- a/scripts/setup-ts-execution.js +++ b/scripts/setup-ts-execution.js @@ -13,8 +13,13 @@ if (!process.env.BABEL_CACHE_PATH) require(`@babel/register`)({ root, - extensions: [`.tsx`, `.ts`], + extensions: [`.tsx`, `.ts`, `.js`], only: [ - p => `/`, + p => { + if (p?.endsWith(`.js`)) + return /packages(\\|\/)yarnpkg-pnp(\\|\/)sources(\\|\/)node/.test(p); + + return true; + }, ], });