diff --git a/.pnp.cjs b/.pnp.cjs index 00eda0facd72..cc4759668ecc 100755 --- a/.pnp.cjs +++ b/.pnp.cjs @@ -46258,10 +46258,10 @@ const Filename = { pnpCjs: `.pnp.cjs`, rc: `.yarnrc.yml` }; -const npath = Object.create((external_path_default())); +const path_npath = Object.create((external_path_default())); const ppath = Object.create((external_path_default()).posix); -npath.cwd = () => process.cwd(); +path_npath.cwd = () => process.cwd(); ppath.cwd = () => toPortablePath(process.cwd()); @@ -46286,10 +46286,10 @@ const contains = function (pathUtils, from, to) { } }; -npath.fromPortablePath = fromPortablePath; -npath.toPortablePath = toPortablePath; +path_npath.fromPortablePath = fromPortablePath; +path_npath.toPortablePath = toPortablePath; -npath.contains = (from, to) => contains(npath, from, to); +path_npath.contains = (from, to) => contains(path_npath, from, to); ppath.contains = (from, to) => contains(ppath, from, to); @@ -46316,10 +46316,10 @@ function toPortablePath(p) { } function convertPath(targetPathUtils, sourcePath) { - return targetPathUtils === npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath); + return targetPathUtils === path_npath ? fromPortablePath(sourcePath) : toPortablePath(sourcePath); } function toFilename(filename) { - if (npath.parse(filename).dir !== `` || ppath.parse(filename).dir !== ``) throw new Error(`Invalid filename: "${filename}"`); + if (path_npath.parse(filename).dir !== `` || ppath.parse(filename).dir !== ``) throw new Error(`Invalid filename: "${filename}"`); return filename; } ;// CONCATENATED MODULE: ../yarnpkg-fslib/sources/algorithms/copyPromise.ts @@ -47098,20 +47098,20 @@ class NodeFS extends BasePortableFakeFS { async openPromise(p, flags, mode) { return await new Promise((resolve, reject) => { - this.realFs.open(npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve, reject)); + this.realFs.open(path_npath.fromPortablePath(p), flags, mode, this.makeCallback(resolve, reject)); }); } openSync(p, flags, mode) { - return this.realFs.openSync(npath.fromPortablePath(p), flags, mode); + return this.realFs.openSync(path_npath.fromPortablePath(p), flags, mode); } async opendirPromise(p, opts) { return await new Promise((resolve, reject) => { if (typeof opts !== `undefined`) { - this.realFs.opendir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); + this.realFs.opendir(path_npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); } else { - this.realFs.opendir(npath.fromPortablePath(p), this.makeCallback(resolve, reject)); + this.realFs.opendir(path_npath.fromPortablePath(p), this.makeCallback(resolve, reject)); } }).then(dir => { return Object.defineProperty(dir, `path`, { @@ -47123,7 +47123,7 @@ class NodeFS extends BasePortableFakeFS { } opendirSync(p, opts) { - const dir = typeof opts !== `undefined` ? this.realFs.opendirSync(npath.fromPortablePath(p), opts) : this.realFs.opendirSync(npath.fromPortablePath(p)); + const dir = typeof opts !== `undefined` ? this.realFs.opendirSync(path_npath.fromPortablePath(p), opts) : this.realFs.opendirSync(path_npath.fromPortablePath(p)); return Object.defineProperty(dir, `path`, { value: p, configurable: true, @@ -47176,62 +47176,62 @@ class NodeFS extends BasePortableFakeFS { } createReadStream(p, opts) { - const realPath = p !== null ? npath.fromPortablePath(p) : p; + const realPath = p !== null ? path_npath.fromPortablePath(p) : p; return this.realFs.createReadStream(realPath, opts); } createWriteStream(p, opts) { - const realPath = p !== null ? npath.fromPortablePath(p) : p; + const realPath = p !== null ? path_npath.fromPortablePath(p) : p; return this.realFs.createWriteStream(realPath, opts); } async realpathPromise(p) { return await new Promise((resolve, reject) => { - this.realFs.realpath(npath.fromPortablePath(p), {}, this.makeCallback(resolve, reject)); + this.realFs.realpath(path_npath.fromPortablePath(p), {}, this.makeCallback(resolve, reject)); }).then(path => { - return npath.toPortablePath(path); + return path_npath.toPortablePath(path); }); } realpathSync(p) { - return npath.toPortablePath(this.realFs.realpathSync(npath.fromPortablePath(p), {})); + return path_npath.toPortablePath(this.realFs.realpathSync(path_npath.fromPortablePath(p), {})); } async existsPromise(p) { return await new Promise(resolve => { - this.realFs.exists(npath.fromPortablePath(p), resolve); + this.realFs.exists(path_npath.fromPortablePath(p), resolve); }); } accessSync(p, mode) { - return this.realFs.accessSync(npath.fromPortablePath(p), mode); + return this.realFs.accessSync(path_npath.fromPortablePath(p), mode); } async accessPromise(p, mode) { return await new Promise((resolve, reject) => { - this.realFs.access(npath.fromPortablePath(p), mode, this.makeCallback(resolve, reject)); + this.realFs.access(path_npath.fromPortablePath(p), mode, this.makeCallback(resolve, reject)); }); } existsSync(p) { - return this.realFs.existsSync(npath.fromPortablePath(p)); + return this.realFs.existsSync(path_npath.fromPortablePath(p)); } async statPromise(p, opts) { return await new Promise((resolve, reject) => { if (opts) { - this.realFs.stat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); + this.realFs.stat(path_npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); } else { - this.realFs.stat(npath.fromPortablePath(p), this.makeCallback(resolve, reject)); + this.realFs.stat(path_npath.fromPortablePath(p), this.makeCallback(resolve, reject)); } }); } statSync(p, opts) { if (opts) { - return this.realFs.statSync(npath.fromPortablePath(p), opts); + return this.realFs.statSync(path_npath.fromPortablePath(p), opts); } else { - return this.realFs.statSync(npath.fromPortablePath(p)); + return this.realFs.statSync(path_npath.fromPortablePath(p)); } } @@ -47259,9 +47259,9 @@ class NodeFS extends BasePortableFakeFS { return await new Promise((resolve, reject) => { if (opts) { // @ts-expect-error - TS does not know this takes options - this.realFs.lstat(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); + this.realFs.lstat(path_npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); } else { - this.realFs.lstat(npath.fromPortablePath(p), this.makeCallback(resolve, reject)); + this.realFs.lstat(path_npath.fromPortablePath(p), this.makeCallback(resolve, reject)); } }); } @@ -47269,55 +47269,55 @@ class NodeFS extends BasePortableFakeFS { lstatSync(p, opts) { if (opts) { // @ts-expect-error - TS does not know this takes options - return this.realFs.lstatSync(npath.fromPortablePath(p), opts); + return this.realFs.lstatSync(path_npath.fromPortablePath(p), opts); } else { - return this.realFs.lstatSync(npath.fromPortablePath(p)); + return this.realFs.lstatSync(path_npath.fromPortablePath(p)); } } async chmodPromise(p, mask) { return await new Promise((resolve, reject) => { - this.realFs.chmod(npath.fromPortablePath(p), mask, this.makeCallback(resolve, reject)); + this.realFs.chmod(path_npath.fromPortablePath(p), mask, this.makeCallback(resolve, reject)); }); } chmodSync(p, mask) { - return this.realFs.chmodSync(npath.fromPortablePath(p), mask); + return this.realFs.chmodSync(path_npath.fromPortablePath(p), mask); } async chownPromise(p, uid, gid) { return await new Promise((resolve, reject) => { - this.realFs.chown(npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve, reject)); + this.realFs.chown(path_npath.fromPortablePath(p), uid, gid, this.makeCallback(resolve, reject)); }); } chownSync(p, uid, gid) { - return this.realFs.chownSync(npath.fromPortablePath(p), uid, gid); + return this.realFs.chownSync(path_npath.fromPortablePath(p), uid, gid); } async renamePromise(oldP, newP) { return await new Promise((resolve, reject) => { - this.realFs.rename(npath.fromPortablePath(oldP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject)); + this.realFs.rename(path_npath.fromPortablePath(oldP), path_npath.fromPortablePath(newP), this.makeCallback(resolve, reject)); }); } renameSync(oldP, newP) { - return this.realFs.renameSync(npath.fromPortablePath(oldP), npath.fromPortablePath(newP)); + return this.realFs.renameSync(path_npath.fromPortablePath(oldP), path_npath.fromPortablePath(newP)); } async copyFilePromise(sourceP, destP, flags = 0) { return await new Promise((resolve, reject) => { - this.realFs.copyFile(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags, this.makeCallback(resolve, reject)); + this.realFs.copyFile(path_npath.fromPortablePath(sourceP), path_npath.fromPortablePath(destP), flags, this.makeCallback(resolve, reject)); }); } copyFileSync(sourceP, destP, flags = 0) { - return this.realFs.copyFileSync(npath.fromPortablePath(sourceP), npath.fromPortablePath(destP), flags); + return this.realFs.copyFileSync(path_npath.fromPortablePath(sourceP), path_npath.fromPortablePath(destP), flags); } async appendFilePromise(p, content, opts) { return await new Promise((resolve, reject) => { - const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p; + const fsNativePath = typeof p === `string` ? path_npath.fromPortablePath(p) : p; if (opts) { this.realFs.appendFile(fsNativePath, content, opts, this.makeCallback(resolve, reject)); @@ -47328,7 +47328,7 @@ class NodeFS extends BasePortableFakeFS { } appendFileSync(p, content, opts) { - const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p; + const fsNativePath = typeof p === `string` ? path_npath.fromPortablePath(p) : p; if (opts) { this.realFs.appendFileSync(fsNativePath, content, opts); @@ -47339,7 +47339,7 @@ class NodeFS extends BasePortableFakeFS { async writeFilePromise(p, content, opts) { return await new Promise((resolve, reject) => { - const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p; + const fsNativePath = typeof p === `string` ? path_npath.fromPortablePath(p) : p; if (opts) { this.realFs.writeFile(fsNativePath, content, opts, this.makeCallback(resolve, reject)); @@ -47350,7 +47350,7 @@ class NodeFS extends BasePortableFakeFS { } writeFileSync(p, content, opts) { - const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p; + const fsNativePath = typeof p === `string` ? path_npath.fromPortablePath(p) : p; if (opts) { this.realFs.writeFileSync(fsNativePath, content, opts); @@ -47361,22 +47361,22 @@ class NodeFS extends BasePortableFakeFS { async unlinkPromise(p) { return await new Promise((resolve, reject) => { - this.realFs.unlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject)); + this.realFs.unlink(path_npath.fromPortablePath(p), this.makeCallback(resolve, reject)); }); } unlinkSync(p) { - return this.realFs.unlinkSync(npath.fromPortablePath(p)); + return this.realFs.unlinkSync(path_npath.fromPortablePath(p)); } async utimesPromise(p, atime, mtime) { return await new Promise((resolve, reject) => { - this.realFs.utimes(npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject)); + this.realFs.utimes(path_npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject)); }); } utimesSync(p, atime, mtime) { - this.realFs.utimesSync(npath.fromPortablePath(p), atime, mtime); + this.realFs.utimesSync(path_npath.fromPortablePath(p), atime, mtime); } async lutimesPromiseImpl(p, atime, mtime) { @@ -47384,7 +47384,7 @@ class NodeFS extends BasePortableFakeFS { const lutimes = this.realFs.lutimes; if (typeof lutimes === `undefined`) throw ENOSYS(`unavailable Node binding`, `lutimes '${p}'`); return await new Promise((resolve, reject) => { - lutimes.call(this.realFs, npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject)); + lutimes.call(this.realFs, path_npath.fromPortablePath(p), atime, mtime, this.makeCallback(resolve, reject)); }); } @@ -47392,122 +47392,122 @@ class NodeFS extends BasePortableFakeFS { // @ts-expect-error: Not yet in DefinitelyTyped const lutimesSync = this.realFs.lutimesSync; if (typeof lutimesSync === `undefined`) throw ENOSYS(`unavailable Node binding`, `lutimes '${p}'`); - lutimesSync.call(this.realFs, npath.fromPortablePath(p), atime, mtime); + lutimesSync.call(this.realFs, path_npath.fromPortablePath(p), atime, mtime); } async mkdirPromise(p, opts) { return await new Promise((resolve, reject) => { - this.realFs.mkdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); + this.realFs.mkdir(path_npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); }); } mkdirSync(p, opts) { - return this.realFs.mkdirSync(npath.fromPortablePath(p), opts); + return this.realFs.mkdirSync(path_npath.fromPortablePath(p), opts); } async rmdirPromise(p, opts) { return await new Promise((resolve, reject) => { // TODO: always pass opts when min node version is 12.10+ if (opts) { - this.realFs.rmdir(npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); + this.realFs.rmdir(path_npath.fromPortablePath(p), opts, this.makeCallback(resolve, reject)); } else { - this.realFs.rmdir(npath.fromPortablePath(p), this.makeCallback(resolve, reject)); + this.realFs.rmdir(path_npath.fromPortablePath(p), this.makeCallback(resolve, reject)); } }); } rmdirSync(p, opts) { - return this.realFs.rmdirSync(npath.fromPortablePath(p), opts); + return this.realFs.rmdirSync(path_npath.fromPortablePath(p), opts); } async linkPromise(existingP, newP) { return await new Promise((resolve, reject) => { - this.realFs.link(npath.fromPortablePath(existingP), npath.fromPortablePath(newP), this.makeCallback(resolve, reject)); + this.realFs.link(path_npath.fromPortablePath(existingP), path_npath.fromPortablePath(newP), this.makeCallback(resolve, reject)); }); } linkSync(existingP, newP) { - return this.realFs.linkSync(npath.fromPortablePath(existingP), npath.fromPortablePath(newP)); + return this.realFs.linkSync(path_npath.fromPortablePath(existingP), path_npath.fromPortablePath(newP)); } async symlinkPromise(target, p, type) { return await new Promise((resolve, reject) => { - this.realFs.symlink(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type, this.makeCallback(resolve, reject)); + this.realFs.symlink(path_npath.fromPortablePath(target.replace(/\/+$/, ``)), path_npath.fromPortablePath(p), type, this.makeCallback(resolve, reject)); }); } symlinkSync(target, p, type) { - return this.realFs.symlinkSync(npath.fromPortablePath(target.replace(/\/+$/, ``)), npath.fromPortablePath(p), type); + return this.realFs.symlinkSync(path_npath.fromPortablePath(target.replace(/\/+$/, ``)), path_npath.fromPortablePath(p), type); } async readFilePromise(p, encoding) { return await new Promise((resolve, reject) => { - const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p; + const fsNativePath = typeof p === `string` ? path_npath.fromPortablePath(p) : p; this.realFs.readFile(fsNativePath, encoding, this.makeCallback(resolve, reject)); }); } readFileSync(p, encoding) { - const fsNativePath = typeof p === `string` ? npath.fromPortablePath(p) : p; + const fsNativePath = typeof p === `string` ? path_npath.fromPortablePath(p) : p; return this.realFs.readFileSync(fsNativePath, encoding); } async readdirPromise(p, opts) { return await new Promise((resolve, reject) => { if (opts === null || opts === void 0 ? void 0 : opts.withFileTypes) { - this.realFs.readdir(npath.fromPortablePath(p), { + this.realFs.readdir(path_npath.fromPortablePath(p), { withFileTypes: true }, this.makeCallback(resolve, reject)); } else { - this.realFs.readdir(npath.fromPortablePath(p), this.makeCallback(value => resolve(value), reject)); + this.realFs.readdir(path_npath.fromPortablePath(p), this.makeCallback(value => resolve(value), reject)); } }); } readdirSync(p, opts) { if (opts === null || opts === void 0 ? void 0 : opts.withFileTypes) { - return this.realFs.readdirSync(npath.fromPortablePath(p), { + return this.realFs.readdirSync(path_npath.fromPortablePath(p), { withFileTypes: true }); } else { - return this.realFs.readdirSync(npath.fromPortablePath(p)); + return this.realFs.readdirSync(path_npath.fromPortablePath(p)); } } async readlinkPromise(p) { return await new Promise((resolve, reject) => { - this.realFs.readlink(npath.fromPortablePath(p), this.makeCallback(resolve, reject)); + this.realFs.readlink(path_npath.fromPortablePath(p), this.makeCallback(resolve, reject)); }).then(path => { - return npath.toPortablePath(path); + return path_npath.toPortablePath(path); }); } readlinkSync(p) { - return npath.toPortablePath(this.realFs.readlinkSync(npath.fromPortablePath(p))); + return path_npath.toPortablePath(this.realFs.readlinkSync(path_npath.fromPortablePath(p))); } async truncatePromise(p, len) { return await new Promise((resolve, reject) => { - this.realFs.truncate(npath.fromPortablePath(p), len, this.makeCallback(resolve, reject)); + this.realFs.truncate(path_npath.fromPortablePath(p), len, this.makeCallback(resolve, reject)); }); } truncateSync(p, len) { - return this.realFs.truncateSync(npath.fromPortablePath(p), len); + return this.realFs.truncateSync(path_npath.fromPortablePath(p), len); } watch(p, a, b) { - return this.realFs.watch(npath.fromPortablePath(p), // @ts-expect-error + return this.realFs.watch(path_npath.fromPortablePath(p), // @ts-expect-error a, b); } watchFile(p, a, b) { - return this.realFs.watchFile(npath.fromPortablePath(p), // @ts-expect-error + return this.realFs.watchFile(path_npath.fromPortablePath(p), // @ts-expect-error a, b); } unwatchFile(p, cb) { - return this.realFs.unwatchFile(npath.fromPortablePath(p), cb); + return this.realFs.unwatchFile(path_npath.fromPortablePath(p), cb); } makeCallback(resolve, reject) { @@ -48524,7 +48524,7 @@ class ZipFS extends BasePortableFakeFS { } if (typeof source === `string`) { - this.zip = this.libzip.open(npath.fromPortablePath(source), flags, errPtr); + this.zip = this.libzip.open(path_npath.fromPortablePath(source), flags, errPtr); } else { const lzSource = this.allocateUnattachedSource(source); @@ -50907,7 +50907,7 @@ const external_url_namespaceObject = require("url");; class URLFS extends ProxiedFS { constructor(baseFs) { - super(npath); + super(path_npath); this.baseFs = baseFs; } @@ -51092,16 +51092,16 @@ function extendFs(realFs, fakeFs) { class PosixFS extends ProxiedFS { constructor(baseFs) { - super(npath); + super(path_npath); this.baseFs = baseFs; } mapFromBase(path) { - return npath.fromPortablePath(path); + return path_npath.fromPortablePath(path); } mapToBase(path) { - return npath.toPortablePath(path); + return path_npath.toPortablePath(path); } } @@ -51160,7 +51160,7 @@ function getIssuerModule(parent) { return issuer || null; } function getPathForDisplay(p) { - return npath.normalize(npath.fromPortablePath(p)); + return path_npath.normalize(path_npath.fromPortablePath(p)); } ;// CONCATENATED MODULE: ./sources/loader/nodeUtils.ts @@ -51168,32 +51168,7 @@ function getPathForDisplay(p) { // @ts-expect-error const builtinModules = new Set(external_module_.Module.builtinModules || Object.keys(process.binding(`natives`))); -const isBuiltinModule = request => request.startsWith(`node:`) || builtinModules.has(request); // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/run_main.js#L11-L24 - -function resolveMainPath(main) { - let mainPath = external_module_.Module._findPath(npath.resolve(main), null, true); - - if (!mainPath) return false; // const preserveSymlinksMain = getOptionValue(`--preserve-symlinks-main`); - // if (!preserveSymlinksMain) - - mainPath = external_fs_default().realpathSync(mainPath); - return mainPath; -} // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/run_main.js#L26-L41 - -function shouldUseESMLoader(mainPath) { - // const userLoader = getOptionValue(`--experimental-loader`); - // if (userLoader) - // return true; - // const esModuleSpecifierResolution = - // getOptionValue(`--experimental-specifier-resolution`); - // if (esModuleSpecifierResolution === `node`) - // return true; - // Determine the module format of the main - if (mainPath && mainPath.endsWith(`.mjs`)) return true; - if (!mainPath || mainPath.endsWith(`.cjs`)) return false; - const pkg = readPackageScope(mainPath); - return pkg && pkg.data.type === `module`; -} // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/cjs/loader.js#L315-L330 +const isBuiltinModule = request => request.startsWith(`node:`) || builtinModules.has(request); // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/cjs/loader.js#L315-L330 function readPackageScope(checkPath) { const rootSeparatorIndex = checkPath.indexOf(npath.sep); @@ -51218,8 +51193,8 @@ function readPackageScope(checkPath) { function readPackage(requestPath) { const jsonPath = npath.resolve(requestPath, `package.json`); - if (!external_fs_default().existsSync(jsonPath)) return null; - return JSON.parse(external_fs_default().readFileSync(jsonPath, `utf8`)); + if (!fs.existsSync(jsonPath)) return null; + return JSON.parse(fs.readFileSync(jsonPath, `utf8`)); } ;// CONCATENATED MODULE: ./sources/loader/applyPatch.ts @@ -51297,7 +51272,7 @@ function applyPatch(pnpapi, opts) { const isOwnedByRuntime = parentApi !== null ? parentApi.findPackageLocator(modulePath) !== null : false; - const moduleApiPath = isOwnedByRuntime ? parentApiPath : opts.manager.findApiPathFor(npath.dirname(modulePath)); + const moduleApiPath = isOwnedByRuntime ? parentApiPath : opts.manager.findApiPathFor(path_npath.dirname(modulePath)); const entry = moduleApiPath !== null ? opts.manager.getApiEntry(moduleApiPath) : { instance: null, cache: defaultCache @@ -51306,8 +51281,8 @@ function applyPatch(pnpapi, opts) { const cacheEntry = entry.cache[modulePath]; if (cacheEntry) { - // When a dynamic import is used in CJS files Node adds the module - // to the cache but doesn't load it so we do it here. + // When the Node ESM loader encounters CJS modules it adds them + // to the cache but doesn't load them so we do that here. // // Keep track of and check if the module is already loading to // handle circular requires. @@ -51316,7 +51291,13 @@ function applyPatch(pnpapi, opts) { // create modules without the `loaded` and `load` properties if (cacheEntry.loaded === false && cacheEntry.isLoading !== true) { try { - cacheEntry.isLoading = true; + cacheEntry.isLoading = true; // The main module is exposed as a global variable + + if (isMain) { + process.mainModule = cacheEntry; + cacheEntry.id = `.`; + } + cacheEntry.load(modulePath); } finally { cacheEntry.isLoading = false; @@ -51329,7 +51310,7 @@ function applyPatch(pnpapi, opts) { const module = new external_module_.Module(modulePath, parent !== null && parent !== void 0 ? parent : undefined); module.pnpApiPath = moduleApiPath; - entry.cache[modulePath] = module; // The main module is exposed as global variable + entry.cache[modulePath] = module; // The main module is exposed as a global variable if (isMain) { process.mainModule = module; @@ -51376,7 +51357,7 @@ function applyPatch(pnpapi, opts) { const issuer = getIssuerModule(module); if (issuer !== null) { - const path = npath.dirname(issuer.filename); + const path = path_npath.dirname(issuer.filename); const apiPath = opts.manager.getApiPathFromParent(issuer); return [{ apiPath, @@ -51385,7 +51366,7 @@ function applyPatch(pnpapi, opts) { }]; } else { const path = process.cwd(); - const apiPath = (_a = opts.manager.findApiPathFor(npath.join(path, `[file]`))) !== null && _a !== void 0 ? _a : opts.manager.getApiPathFromParent(null); + const apiPath = (_a = opts.manager.findApiPathFor(path_npath.join(path, `[file]`))) !== null && _a !== void 0 ? _a : opts.manager.getApiPathFromParent(null); return [{ apiPath, path, @@ -51396,7 +51377,7 @@ function applyPatch(pnpapi, opts) { function makeFakeParent(path) { const fakeParent = new external_module_.Module(``); - const fakeFilePath = npath.join(path, `[file]`); + const fakeFilePath = path_npath.join(path, `[file]`); fakeParent.paths = external_module_.Module._nodeModulePaths(fakeFilePath); return fakeParent; } // Splits a require request into its components, or return null if the request is a file path @@ -51441,11 +51422,11 @@ function applyPatch(pnpapi, opts) { const issuerSpecs = options && options.paths ? getIssuerSpecsFromPaths(options.paths) : getIssuerSpecsFromModule(parent); if (request.match(pathRegExp) === null) { - const parentDirectory = (parent === null || parent === void 0 ? void 0 : parent.filename) != null ? npath.dirname(parent.filename) : null; - const absoluteRequest = npath.isAbsolute(request) ? request : parentDirectory !== null ? npath.resolve(parentDirectory, request) : null; + const parentDirectory = (parent === null || parent === void 0 ? void 0 : parent.filename) != null ? path_npath.dirname(parent.filename) : null; + const absoluteRequest = path_npath.isAbsolute(request) ? request : parentDirectory !== null ? path_npath.resolve(parentDirectory, request) : null; if (absoluteRequest !== null) { - const apiPath = parentDirectory === npath.dirname(absoluteRequest) && (parent === null || parent === void 0 ? void 0 : parent.pnpApiPath) ? parent.pnpApiPath : opts.manager.findApiPathFor(absoluteRequest); + const apiPath = parentDirectory === path_npath.dirname(absoluteRequest) && (parent === null || parent === void 0 ? void 0 : parent.pnpApiPath) ? parent.pnpApiPath : opts.manager.findApiPathFor(absoluteRequest); if (apiPath !== null) { issuerSpecs.unshift({ @@ -51502,7 +51483,7 @@ function applyPatch(pnpapi, opts) { if (request === `pnpapi`) return false; if (!enableNativeHooks) return originalFindPath.call(external_module_.Module, request, paths, isMain); // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/cjs/loader.js#L490-L494 - const isAbsolute = npath.isAbsolute(request); + const isAbsolute = path_npath.isAbsolute(request); if (isAbsolute) paths = [``];else if (!paths || paths.length === 0) return false; for (const path of paths) { @@ -51527,23 +51508,6 @@ function applyPatch(pnpapi, opts) { } return false; - }; // Specifying the `--experimental-loader` flag makes Node enter ESM mode so we change it to not do that - // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/run_main.js#L72-L81 - // Tested by https://github.com/yarnpkg/berry/blob/d80ee2dc5298d31eb864288d77671a2264713371/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts#L226-L244 - // Upstream issue https://github.com/nodejs/node/issues/33226 - - - const originalRunMain = moduleExports.runMain; - - moduleExports.runMain = function (main = process.argv[1]) { - const resolvedMain = resolveMainPath(main); - const useESMLoader = resolvedMain ? shouldUseESMLoader(resolvedMain) : false; - - if (useESMLoader) { - originalRunMain(main); - } else { - external_module_.Module._load(main, null, true); - } }; patchFs((external_fs_default()), new PosixFS(opts.fakeFs)); @@ -51553,7 +51517,7 @@ function applyPatch(pnpapi, opts) { function hydrateRuntimeState(data, { basePath }) { - const portablePath = npath.toPortablePath(basePath); + const portablePath = path_npath.toPortablePath(basePath); const absolutePortablePath = ppath.resolve(portablePath); const ignorePattern = data.ignorePatternData !== null ? new RegExp(data.ignorePatternData) : null; const packageLocatorsByLocations = new Map(); @@ -52086,7 +52050,7 @@ function makeApi(runtimeState, opts) { // the {paths} option at all, since it internally makes _resolveFilename create another // fake module anyway. - return external_module_.Module._resolveFilename(npath.fromPortablePath(request), makeFakeModule(npath.fromPortablePath(issuer)), false, { + return external_module_.Module._resolveFilename(path_npath.fromPortablePath(request), makeFakeModule(path_npath.fromPortablePath(issuer)), false, { plugnplay: false }); } @@ -52259,7 +52223,7 @@ function makeApi(runtimeState, opts) { considerBuiltins = true } = {}) { // 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); // Bailout if the request is a native module + if (request === `pnpapi`) return path_npath.toPortablePath(opts.pnpapiResolution); // Bailout if the request is a native module if (considerBuiltins && isBuiltinModule(request)) return null; const requestForDisplay = getPathForDisplay(request); @@ -52285,7 +52249,7 @@ function makeApi(runtimeState, opts) { }); } - return npath.toPortablePath(result); + return path_npath.toPortablePath(result); } } @@ -52339,7 +52303,7 @@ function makeApi(runtimeState, opts) { }); } - return npath.toPortablePath(result); + return path_npath.toPortablePath(result); } const issuerInformation = getPackageInformationSafe(issuerLocator); // We obtain the dependency reference in regard to the package that request it @@ -52619,35 +52583,35 @@ function makeApi(runtimeState, opts) { getPackageInformation: locator => { const info = getPackageInformation(locator); if (info === null) return null; - const packageLocation = npath.fromPortablePath(info.packageLocation); + const packageLocation = path_npath.fromPortablePath(info.packageLocation); const nativeInfo = { ...info, packageLocation }; return nativeInfo; }, findPackageLocator: path => { - return findPackageLocator(npath.toPortablePath(path)); + return findPackageLocator(path_npath.toPortablePath(path)); }, resolveToUnqualified: maybeLog(`resolveToUnqualified`, (request, issuer, opts) => { - const portableIssuer = issuer !== null ? npath.toPortablePath(issuer) : null; - const resolution = resolveToUnqualified(npath.toPortablePath(request), portableIssuer, opts); + const portableIssuer = issuer !== null ? path_npath.toPortablePath(issuer) : null; + const resolution = resolveToUnqualified(path_npath.toPortablePath(request), portableIssuer, opts); if (resolution === null) return null; - return npath.fromPortablePath(resolution); + return path_npath.fromPortablePath(resolution); }), resolveUnqualified: maybeLog(`resolveUnqualified`, (unqualifiedPath, opts) => { - return npath.fromPortablePath(resolveUnqualified(npath.toPortablePath(unqualifiedPath), opts)); + return path_npath.fromPortablePath(resolveUnqualified(path_npath.toPortablePath(unqualifiedPath), opts)); }), resolveRequest: maybeLog(`resolveRequest`, (request, issuer, opts) => { - const portableIssuer = issuer !== null ? npath.toPortablePath(issuer) : null; - const resolution = resolveRequest(npath.toPortablePath(request), portableIssuer, opts); + const portableIssuer = issuer !== null ? path_npath.toPortablePath(issuer) : null; + const resolution = resolveRequest(path_npath.toPortablePath(request), portableIssuer, opts); if (resolution === null) return null; - return npath.fromPortablePath(resolution); + return path_npath.fromPortablePath(resolution); }), resolveVirtual: maybeLog(`resolveVirtual`, path => { - const result = resolveVirtual(npath.toPortablePath(path)); + const result = resolveVirtual(path_npath.toPortablePath(path)); if (result !== null) { - return npath.fromPortablePath(result); + return path_npath.fromPortablePath(result); } else { return null; } @@ -52658,8 +52622,8 @@ function makeApi(runtimeState, opts) { function makeManager(pnpapi, opts) { - const initialApiPath = npath.toPortablePath(pnpapi.resolveToUnqualified(`pnpapi`, null)); - const initialApiStats = opts.fakeFs.statSync(npath.toPortablePath(initialApiPath)); + const initialApiPath = path_npath.toPortablePath(pnpapi.resolveToUnqualified(`pnpapi`, null)); + const initialApiStats = opts.fakeFs.statSync(path_npath.toPortablePath(initialApiPath)); const apiMetadata = new Map([[initialApiPath, { cache: external_module_.Module._cache, instance: pnpapi, @@ -52668,7 +52632,7 @@ function makeManager(pnpapi, opts) { }]]); function loadApiInstance(pnpApiPath) { - const nativePath = npath.fromPortablePath(pnpApiPath); // @ts-expect-error + const nativePath = path_npath.fromPortablePath(pnpApiPath); // @ts-expect-error const module = new external_module_.Module(nativePath, null); // @ts-expect-error @@ -52683,7 +52647,7 @@ function makeManager(pnpapi, opts) { const stats = opts.fakeFs.statSync(pnpApiPath); if (stats.mtime > apiEntry.stats.mtime) { - process.emitWarning(`[Warning] The runtime detected new informations in a PnP file; reloading the API instance (${npath.fromPortablePath(pnpApiPath)})`); + process.emitWarning(`[Warning] The runtime detected new informations in a PnP file; reloading the API instance (${path_npath.fromPortablePath(pnpApiPath)})`); apiEntry.stats = stats; apiEntry.instance = loadApiInstance(pnpApiPath); } @@ -52751,11 +52715,11 @@ function makeManager(pnpapi, opts) { if (bestCandidate) { if (bestCandidate.apiPaths.length === 1) return bestCandidate.apiPaths[0]; - const controlSegment = bestCandidate.apiPaths.map(apiPath => ` ${npath.fromPortablePath(apiPath)}`).join(`\n`); + const controlSegment = bestCandidate.apiPaths.map(apiPath => ` ${path_npath.fromPortablePath(apiPath)}`).join(`\n`); throw new Error(`Unable to locate pnpapi, the module '${modulePath}' is controlled by multiple pnpapi instances.\nThis is usually caused by using the global cache (enableGlobalCache: true)\n\nControlled by:\n${controlSegment}\n`); } - const start = ppath.resolve(npath.toPortablePath(modulePath)); + const start = ppath.resolve(path_npath.toPortablePath(modulePath)); let curr; let next = start; diff --git a/.yarn/versions/4da93d59.yml b/.yarn/versions/4da93d59.yml new file mode 100644 index 000000000000..1ef7ecb1c936 --- /dev/null +++ b/.yarn/versions/4da93d59.yml @@ -0,0 +1,28 @@ +releases: + "@yarnpkg/cli": patch + "@yarnpkg/plugin-pnp": patch + "@yarnpkg/pnp": patch + +declined: + - "@yarnpkg/esbuild-plugin-pnp" + - "@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 eea091cdcd40..bd04e7ec2c92 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,7 @@ Yarn now accepts sponsorships! Please give a look at our [OpenCollective](https: ### Bugfixes - `@yarnpkg/pnpify` now escapes paths correctly +- The ESM loader is now enabled regardless of the entrypoint module type, this fixes support for dynamic imports in commonjs modules when the entrypoint is also commonjs ### Bugfixes diff --git a/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-bins-esm-1.0.0/index.mjs b/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-bins-esm-1.0.0/index.mjs index 753a47d529e1..2dea2a5bb739 100644 --- a/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-bins-esm-1.0.0/index.mjs +++ b/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-bins-esm-1.0.0/index.mjs @@ -1 +1,2 @@ +import 'fs'; console.log(42); diff --git a/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-exports-1.0.0/index.js b/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-exports-1.0.0/index.js deleted file mode 100644 index f4991fa4fc62..000000000000 --- a/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-exports-1.0.0/index.js +++ /dev/null @@ -1 +0,0 @@ -module.exports.foo = 42; diff --git a/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-exports-1.0.0/package.json b/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-exports-1.0.0/package.json deleted file mode 100644 index 19ff10472bc8..000000000000 --- a/packages/acceptance-tests/pkg-tests-fixtures/packages/no-deps-exports-1.0.0/package.json +++ /dev/null @@ -1,4 +0,0 @@ -{ - "name": "no-deps-exports", - "version": "1.0.0" -} 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 3fffd7f139fe..fd1a2893cb0e 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,4 +1,4 @@ -import {Filename, PortablePath, ppath, xfs} from '@yarnpkg/fslib'; +import {Filename, ppath, xfs} from '@yarnpkg/fslib'; describe(`Plug'n'Play - ESM`, () => { test( @@ -141,57 +141,6 @@ describe(`Plug'n'Play - ESM`, () => { ), ); - test( - `it should support named exports in commonjs files`, - makeTemporaryEnv( - { - dependencies: { - 'no-deps-exports': `1.0.0`, - }, - type: `module`, - }, - 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 'no-deps-exports';\nconsole.log(foo)`, - ); - - await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ - code: 0, - stdout: `42\n`, - }); - }, - ), - ); - - test( - `it should always set default as module.exports when importing a commonjs file`, - makeTemporaryEnv( - { - type: `module`, - }, - 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.cjs';\nconsole.log(foo)`, - ); - await xfs.writeFilePromise( - ppath.join(path, `foo.cjs` as Filename), - `module.exports.default = 42`, - ); - - await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ - code: 0, - stdout: `{ default: 42 }\n`, - }); - }, - ), - ); - test( `it should respect exports`, makeTemporaryEnv( @@ -228,21 +177,17 @@ describe(`Plug'n'Play - ESM`, () => { { type: `module`, dependencies: { - foo: `portal:./pkg`, + 'no-deps': `1.0.0`, }, }, async ({path, run, source}) => { - await xfs.mkdirPromise(ppath.join(path, `pkg` as Filename)); - await xfs.writeJsonPromise(ppath.join(path, `pkg/package.json` as Filename), {}); - await xfs.writeFilePromise(ppath.join(path, `pkg/index.js` as Filename), `module.exports = 42`); - - await xfs.writeFilePromise(ppath.join(path, `index.js` as Filename), `import foo from 'foo';\nconsole.log(foo)`); + await xfs.writeFilePromise(ppath.join(path, `index.js` as Filename), `import pkg from 'no-deps';\nconsole.log(pkg)`); await expect(run(`install`)).resolves.toMatchObject({code: 0}); await expect(run(`node`, `./index.js`)).resolves.toMatchObject({ code: 0, - stdout: `42\n`, + stdout: `{ name: 'no-deps', version: '1.0.0' }\n`, }); }, ), @@ -255,21 +200,21 @@ describe(`Plug'n'Play - ESM`, () => { type: `module`, }, async ({path, run, source}) => { - await xfs.writeFilePromise(ppath.join(path, `index` as Filename), `console.log('foo')`); + await xfs.writeFilePromise(ppath.join(path, `index.ts` as Filename), ``); await expect(run(`install`)).resolves.toMatchObject({code: 0}); - await expect(run(`node`, `./index`)).rejects.toMatchObject({ + await expect(run(`node`, `./index.ts`)).rejects.toMatchObject({ code: 1, - stderr: expect.stringContaining(`Unknown file extension ""`), + stderr: expect.stringContaining(`Unknown file extension ".ts"`), }); }, ), ); - // Tests the workaround for https://github.com/nodejs/node/issues/33226 + // Tests https://github.com/nodejs/node/issues/33226 test( - `it should not enter ESM mode just because the loader is present`, + `it should not load extensionless commonjs files as ESM`, makeTemporaryEnv( { }, { @@ -289,37 +234,19 @@ describe(`Plug'n'Play - ESM`, () => { ); test( - `it should enter ESM mode when entrypoint is ESM`, + `it should support ESM binaries`, makeTemporaryEnv( { - workspaces: [`workspace`], dependencies: { - pkg: `workspace:*`, + 'no-deps-bins-esm': `1.0.0`, }, }, async ({path, run, source}) => { - await xfs.mkdirPromise(ppath.join(path, `workspace` as PortablePath)); - await xfs.writeJsonPromise(ppath.join(path, `workspace/package.json` as PortablePath), { - name: `pkg`, - type: `module`, - bin: `index.mjs`, - peerDependencies: { - 'no-deps': `*`, - }, - }); - await xfs.writeFilePromise(ppath.join(path, `workspace/index.mjs` as Filename), `import 'fs'; console.log('foo')`); - await expect(run(`install`)).resolves.toMatchObject({code: 0}); - // Ensure path is virtual (ie node can't find it by default) - await expect(run(`bin`, `pkg`)).resolves.toMatchObject({ + await expect(run(`no-deps-bins-esm`)).resolves.toMatchObject({ code: 0, - stdout: expect.stringContaining(`__virtual__`), - }); - - await expect(run(`pkg`)).resolves.toMatchObject({ - code: 0, - stdout: `foo\n`, + stdout: `42\n`, }); }, ), @@ -340,7 +267,7 @@ describe(`Plug'n'Play - ESM`, () => { ); test( - `it should work with dynamic imports in esm mode`, + `it should support dynamic imports in ESM mode`, makeTemporaryEnv( { type: `module`, @@ -360,21 +287,20 @@ describe(`Plug'n'Play - ESM`, () => { ), ); - // Requires the ESM loader to be loaded but currently that enters ESM - // mode and would test the incorrect code path - test.skip( - `it should work with dynamic imports in commonjs mode`, + test( + `it should support dynamic imports in commonjs mode`, makeTemporaryEnv( { dependencies: { "no-deps": `1.0.0`, + "is-number": `1.0.0`, }, }, { pnpEnableEsmLoader: true, }, async ({path, run, source}) => { - await xfs.writeFilePromise(ppath.join(path, `index.js` as Filename), `import('no-deps').then(() => console.log(42))`); + await xfs.writeFilePromise(ppath.join(path, `index.js` as Filename), `require('no-deps');\nimport('is-number').then(() => console.log(42))`); await expect(run(`install`)).resolves.toMatchObject({code: 0}); @@ -385,4 +311,33 @@ describe(`Plug'n'Play - ESM`, () => { }, ), ); + + test( + `it should set the main module`, + makeTemporaryEnv( + {}, + { + pnpEnableEsmLoader: true, + }, + async ({path, run, source}) => { + await expect(run(`install`)).resolves.toMatchObject({code: 0}); + + await xfs.writeFilePromise( + ppath.join(path, `index.js` as Filename), + ` + console.log({ + require: typeof require, + main: require.main === module, + mainModule: process.mainModule === module, + }); + `, + ); + + await expect(run(`node`, `index.js`)).resolves.toMatchObject({ + code: 0, + stdout: `{ require: 'function', main: true, mainModule: true }\n`, + }); + }, + ), + ); }); diff --git a/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js b/packages/yarnpkg-pnp/sources/esm-loader/built-loader.js index a76ee77a4882..24cc134d6bc0 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/loaderUtils.ts b/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts index 751812cb241e..f409bd939aee 100644 --- a/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts +++ b/packages/yarnpkg-pnp/sources/esm-loader/loaderUtils.ts @@ -48,6 +48,9 @@ export function getFileFormat(filepath: string): string | null { `Unknown file extension ".json" for ${filepath}`, ); } + // Matching files without extensions deviates from Node's default + // behaviour but is a fix for https://github.com/nodejs/node/issues/33226 + case ``: case `.js`: { const pkg = nodeUtils.readPackageScope(filepath); if (pkg) { diff --git a/packages/yarnpkg-pnp/sources/hook.js b/packages/yarnpkg-pnp/sources/hook.js index 82a20fd2a66c..6964687d04a7 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('W3SrWMM8i+9A7YQkEtPf3qbcGtkUC87nPo6NECmpmvUNBQ9XSLhD7SLHwWXzfdt0FFRVc5PKkJkAplAANqd6rzpCIssF7rVZHx5oBhlPQfBSS/Ft5+uYh2gYCznGaXfd6L5HeHCPERe+CWPStMfRop9Hkr84o6uElxlJeJjF6j+5vSn7B+aOvlHvl/f9cSWxVZKi65b8FElo00giKXaQEivJCwsLpvf5w8L6msKFVugzHHYW8sy5QWfJllnoeA2IMG79IcIQUTEdTnGJrOqtfZYt9luf+PV7nVZPU411IozD/E2JCyFUyIfAMmzEfmA2iSu65qDnd/L/Qvdmo7wgs2gwyg7+n99fn+oa+WeHBDU/+Iwuvrff29TO8eVkzTY5Spk/KuBCsv22p9YxuMgNXgLbMPZfm5+/WkMmjIXlqamIY6fUwjX1ah4YgYlT/P5it/jw9appj6b6ohLmuIJTmLc8VW4aHiQ4V6ocEmn/W87uvZyYnkLd2QRa4sOnYvvSFRH4f0v1XW0JpQrib1mVVphdv+Jcic/i8BhT4NCALczU+uvzqmgPoWMQ9HEtOZdsWTOOL62onIyWhImWhBFNcAnICTMj/7OpndeXkyEFkSoJ7GQ0YZTS2FLxNjnhyZ0U9CkptUEUuMAObDdHQ5iAH2DrU/Xt1VRn53sGodnZeIRDSJX1oQASdM6rqp53yM5TFGAqy3YmaX0eHULCZNeVX/3U7//989Wbxe4Ipxvll27Kctrkp7KABhZr5tAVCHKVX6pV1d/09yl0CJDNGIEW0KZGfpRt8cfDX0BlZpjjq+rqJSuVJkK8AUoToyLCGBBCVLVxZdLXA8XEeDsF+rqmPQgzpVM0PFFj++OhQ1ZadHyzu8CqqINh0S2x1iKjn/3GIgJ1uo6Z7yWlgDavBUBfSpz/v1y89/53IW25yyONxpbjMcjJhJhdam5lYyC0DrjUj29s/8tFC29mfVueGQYYBGpAKtoZ5tXoh4qvK/lRMq0/HnZ3TezsDDm+V10SLSThaqwk+EbId7XCn8ggkhbZN3H9/3L5DPBn2EqykrhNCorrWzo7bs9HVpw2MOW91LVep33ZOtwPlKKAExey7J1Os8uDswWOyOFae7+OV9QwtR7pJBrZkTegAvGWzy5E24QaP1F5+Ew1j9eUenz4As1Pm7bh0m678gbQesSkcwIOOWA9xS2IIuz/t2lfE76qkm3Z/iD5D7iHdhhzt5cwBAxytO67r1673nuldVXJbleV5B1Jdu+X1P77BfZZtdy/JA3IGnL3Uveiewi9gGHL9oemTx70AsDJgTPkjCDcJNsgDTfNAJNww/X/v/dTq2oPkmCijDPD9k4JUixjzGDYY/5j7ha/i1JEfEQnIgLoJAFyFckkK0WZMkqts8+578f/PwJURABUAgFmNklJ3SqWY6qt0VK2cTNnpj2ZWT+cgVQNlNXtZz3rcft905Tq1q0gpzCq3dVPFwSXGY17gWmF+ZneyOuritMLK53QBFBwL8hPfvxl6pt983evN4M/c6XZ0RHepVWDgLSCwZhHPRym/H1van3be997+RIgKYpUy5VvY8w2M8GqolT6xvnYT+vdc+4J5bv3vmggzRSRmYhPJoAIESCjRYCMKVGqe18myPuSUFUCoqoTIKsboFS/QXVXBKTq/qGqHi/3XWmsWRq7mth/41dj7G5mtdN4df/xbrHZzGKxH/4JDkvde3Ntvl0Fg5ROizErHWNULWIximCoipM06YEji/DW01tlfr2C+n7ggt+E4ZKWB60sBiznuqsmg3tv975SB0TgKKUlpyqrulafgtDKBl0artHv7TeWUluOei31aADN2NqAM9pXB3Bbz3+UuEe+MDbYWAEDRm1ItYdEKaiEKCkbkf7oBTHA3P47e47/Muvf3SsFlelAUFlOcDAcq9wDRMV63RyaA2yzHvNeZH5sk1IJA8QAUQRjA3FOG7AIc/uI0CX8fixE/9E3LggzvGCKM1f1v8m0+0kYYYQI/aCRFvM0fCLkUEoOfXDb7msd3en/8/p8LsmW6RIOwaSGavCgwVANIhVUFFFEUcGDoB48eDjD7f+zbv89fHtm9idfsp9JFoGoQCAQFQjEEWyCQCAqKiqa3YqKCsT1c5P/5z/dR5iXXFGBQIxATF4QCAR5QSAQiIrmpz9BVCBGjBixBKLbVkFNz+zn72lB1bWIQCAQCEQEIgIRgUAgEAgEAhGRukL0/5/n/6t4ROITsGBqpO2FRpM3/BvF+gPo5v//ixXoEYH3/m/PERTIGoyEsEKYw8pyAFGGrAzYjmrv3Yw7BthmHfaBjI8FYBEimIEssefKrV2ljbow7lrB6QBu6/9zT+S+Xry8BwLCNmIbSJRUSyhCj41YEGMgYSBhXDzvFi4Ov/YHaR2SLXTD60dclgIToL2b8hzUpwdw1hmjMj/vDQcfsgjqmAk1lKG7DlwNyEYdX0AwqI9wpuL0iDTHxXRERrAz3j4ASRMDgdqlK+6eMa3Av4kcU9/dlyy6t7unTnYsu4xTIRQWvzF3lRyZP1K92bcei4WuR2WMMIEKxAKIMQGPX3jvxA+zgrJg4DqWoTNghMp4szZfZE9TM1ELfEuC6Utgs3k0uyRDTJ/PuhaoSABPV2A7yC/wBALC1FWKAhIUfGYiGsLQZS6bizEf1AGZaTj+v5zIs8ILE2TmFYt19MzIeegMZiTPSzNW1RUC/gRRWAVPvbPDT3iJTuVopPgxHSfwZ2gHGb0jP7fckHP++85Klre7QlC0fWUkJLGWo+pIpCUH2VTKechrbjH+bt1VQGvvAvm45e3kJtYYgPJuPIlErTtPmbMLu7qLdlOf7M2Fvvdnx7hWYSCoKHMp8EIFxTAyFJxDZxQsLg5WdW4VYJZQbbDUWMwZY8YD2SY84UU/odR5YTMLl64vNA6aBsiRVJGh4onJAnBh8FrFb5t/EiUMU1oIpUoLxdMEIs/UA/rlMGItUuazF5a7iMekPJU0cXg5KUzH3mevtuhxWlikZrLAMxDC7Zd7U/nuCdGFcjVFddT76vLxbAkP4RIEjRIiAMGSJ4ClXghZ895qxhZh7A957s2KNQW8qnrlfUK4nOqqiUR8d11UKwIf80B+1+NjAXu58gU5aV2/Dntt4VADKjJplcHft4q1KnzZGNSjiKLYkvxLMemfsYqkqZGmHIGUNRXhRw8Mjx5Sl3psCBG41OJ+lAMjJSGFTlv8/FANEJgziXUrzU5eiuWc5Zd/ksxsCgBF2BTRthuSroWp1f6IF8ftn1HQ9ZX2j5PFPXiFd2GrHZ4LbrTD5B8tkNi4TEurpyDTMo/dVdwT116xpUHwXV7RatEx9droQraQioAFpPKTYIqZUVyJaFa+UnySbQRRyz6JN0uEN7y1wg1gHvsocxpRyWmT2f6t6Ml2DVbHDEyeKw/W87QG7CvDiosN9r8wu4t49+jYNjt/1soxaZl83tx+2ABTGz8DBZ5CptX6oBEWcSgQagIvBtlLVUhcCt6EWeE5WJZAtNJTFkRcn3c0O6Nf9maia82I0A6+8fG6nDFvNTg7Y6PR8/lJ6TQIahjaFGJ8jIvP4fJKFZiHb11IK9Cgt7+jcL5unTz/j3NgvQA6AIDVHoHEgC6e5V7TJfLl0N7Y3Zgc1JWVkZsdK0KYeuWe0oZNcURn5hxotqcyr/qK48dVJfmXR1KkvRtqHfQC5x/xDXv22OOwrdfDZsE5TznepEVSe2KjiO0DVyI4kbJZy6a2/cSOPWm9RWO+kUl2LPp1ZI/HJga/bIXIZI1El0lb5gnL0Zap3+82JcY2hA9U2z9O7SgLvFKFJhZ5/YoPADQvoH4yRiQYrZWsZBsysyQC/cnrr9250B9liCWC4iPmuHGBUiGUdU6qPKrfiXx2qv/qD59Cupm9yxhBA6XUImXnCelCg5EsrXSlwL1UYCbHDB/nwnEdmpE/k75kq5zrua5/mJhtdJbulxDF7/K8QuOb/U0+UUmOJg/VmaacTZT7AqNqRFJaui6aO9qB5GnG2OH4yTtDkba8/3w560oDfIZAUd/6g+6brrZj+C5XiaI3pUI8PmXB9ZXqoVZunJJ8mUCmDS/1ZkmmXRORD7+aXDlC4sejgDC192L8AvXuAjEXf0ocYHJqvBYEUnxLisncp8lV1PYtAUJam4S0I5jOFZhwpf2hU4KYGtMHlfSRC9imdzwAS15b5UKR5puZra/Wn+nat6oNwFhpWckiJoLZoqkNJvEX+pLFOzr0rO8rpo7/ux0dI0PP/xT4d+Vx00UVcI4NHp06y6L+o/2+/PlShsymtEk4ozjQS2zEC6DQ5KzQOCysQQxWi6gpi/WPs0f7/wyjOs1HR0ZRS4jhxyau7dsA1UJpS7LEf0LL31JSIfBiMbUX3gVs8WuGBWdWIACjf1w/jQIuu6GBBUJqnWlWo9+kcCZz5sSMvZoUiXYXYEUaxQjKyy0VPVCSZ2wux3peRwYrYDSxnacWlJeJmndffv26cpyxR6LX0WQxoYMVPWra6ox+ZuJV+BQTGRxKTw3RVZTLiO5vXrsQKfL3qqdpvtoD24KVj5EqoqmFueXvgL+zQdp6UvsDZ60DL9hxTkOTuVexZL+qPjM6w6mQMLMnln4mhKVwQ4vXClSAOvrpVlRag4co9zokTBugq9Lvb16gEyL+GCz0YbbnYVNmya4rjQKw6AF5domnXSZZWx2f0p6qnHlwkkNzKtF3zACru2iQnkwNQmBKFvtwHuua+K3tkQwye8LbZAgnY5rjN+IxQSlBqy+0+vPrAgYjxBD5VnqJTMLr5Eh7TOQHwMmYAYnlFmQtg3Dh5DigbSbQc0xZ3xPF2x2fTKxTiuMeOemrSY/WGzgNYE3VX7fuGmnaTjFnW7xegHipgnm5F3vJO0fEwS2WV4xW9MCHEl6AhbHcAahZPC9tPLdIeKT8ublgr2yFWgCyS/PdYOSKtBy+/LI3gW8yKVaBBNTZgNcabaaY3qMa/Pa7LgQ3mxWvDPR10nBvwqye1Dp2NUgyCyMqrgAGBUcBTFXjs6qbCC24/6lmvkBOGKGAz+b0e+cLF7H+NW5VoKSoKrfvaqn03yvVVLYcc4xWwvU01seJFqDtJsXeM4G5rqHbHCjt59VIHIJp92/Ol6CgdbGMk2BFW2D0SYTYAF3MEc7DBWaT+vxSAlOppTRJlr/H0KF+HAsFuCBQH0/izmdEVGbB8tZAW4sLIrrcKNVReKbsr2B4JmoXtD2a9EIx8Z3YV7l+6vRvqcJcyxK09QT+obPWKQ+E0aV+XIr1YeR7UwHqvRFjYYa32B8prEKWJR8q6QJlUUmKV818bXisCrvG/TmpWDdNgNsP4MdaR9ngBtaCxnzfpbjSWFzo3OyxqBUYC8J4aufnA2E16GqZsUbWqxiz3rwBiHRMl8pZvh5lHJeFLIP3mhs7PCjDiP3aexF/x52Node78Xe4jGR3PFei8TdvAbuucHOD2+z3B8sPio4bwSyWHt8uLZqEacAVdbpj4wuzcTCHjclVbvtjmF+o7MG8N9wbF9vAJVreUa40qld8+Wxu/nFACVJqY1xBuxbAe5QI/rgfNF8Afg2VP279NYCW9Xp9zqrHgcgATmcr6H6QGZDf1Q5c6V/FA6t08Mf9No8j4FcM88bjfyOD6f7zG0STZwJrawr/MBKZSYmlDT0Cx65/s5+4XTM4lm3bCqAJ7RxOnKdS/Cl9yxJGOLBoheeJoZyvzYUv+gydVlQMFvYNweM3TTJmut2+/p+r3TyRsJpirPexY4rc5gpxp39DwuYJM1+Or79XsQ2je6haj30lpz2y6IwXwmZdI3u5PbmLqBSqrwd5XzusG22/nZJNh1P47Xf0rWHqJ53UgoCzubIbT3Z7tY91yABHZUN1Rz06Yj+IFP0gkgEEXA0CvRs0gJMvX5poAQyywuwWZ4hqf196pC3wBSGpTVCBJPqJoISgA3bL3P023Z9YDuJ9HZWtbWGUYSf9w7MWrAvQhrPaUDmY9ugQCZBWYexL761dpHGOiOPUc5nLVidP83/RwelUAd1WcsM8VZDJQcCmmmGxrmQOgcPz+3+D6NlHnm5et1iuybEhYSz84FbhnWo1EUwgeuUmncbWjSdbE/BWNprqxM5GvyJ6CtCGl5RLNWpu83C1nw1i1r0Wc2w9rO47DI3ClyTFobToBK87jJEDkMMaIa9O2ZUyk3OX4qUCdF9RhdqPFzJbmy/ERugrpLswCJfkDrevmyN28P+dqm/D7Q1JY3US0xjt8Iy9/GBq8VFGtCuYKTWoj8jzvMIdct5qlmnj2WZfJlQYlJ+bmxxpP40qsEcOvOPUJveBJzZ5OW5m7zjWGQ3OfmtZ8qs9Ziag5oJ7hTieqWF+Cez9Ow4hufxvqwIg74SPFvk569vEw+35y2Mngs9/tMO9XGXycnn8xbRszps+qU9hwJkNlMTfnvUttFFZz6ET0CfqbAbP5IPump+dh+wBpovjdjNpTOLy0dlk0uFf5NluT8y0DGeGUf0WBqdk2qZncuqdNfSjxjyIftCM7OPzL7azvnE2C8fXE9Nr7uN06uSuJnG024uP3XOt0mq+B/FIXnXIm16RXm/Jux7IQUd9aGTQUZ999W8f+ho6km8d8l9vyI8elAk56YH86pA/PZDR//EVn1IOUsdICjQ4EpWgS7HI7K0QGwGjXQ6rQOeM8EyqGIsgBYillqSJkjBgECkiBScJQrIHNHj2FWONDRpdJCtIVYcmBwWxhgp44hoJuoDf0DgXS/S4gVaIVh7DCrhoLdBAYaNtPo5EYO6sMh4Dhp9SiZCeoMGJVoJVEOs8UmRem8ZZCmzh3WkPYAYRUQpJjRUNXlLrpI5rSUpoAOJUEgRj0LByioj0U9YegHdpIGhUAFIwWC/QAdIx0AfS3GiyF9FO0OJShJPU094sjWZeSEf/ncKch8ZBfklEeOgYLNAz5oTmE6pMeBj4URFVP0dzRzUImopfFanxEc1zqk7QtPQpUG2uIeWBOHY0Pb81yDr5Hs3nLIPQGAvNFywRmjFnSaA787/QXFlFYRM4M4Ga5PdofsdiLGyUKw2yUd+h+T3LSth03Fuge/wTmj+y6AWbgXuCPJhfo6GnHgSH/EBmgsP0QNUKh8WBqhEO9YFKhcPmgAnu8RBwbYEfLwOFTY+t+iU6/WxVphw+D6gq4fB9QBWFw+kAl9z2XhhpcNuD4JrgtpeBEcF1hTAhuO5eeE2Bu4PgDHHdZeDWAu8K4TYF3t0LEwu8OwgmKfDuMjDR4J4LoWA6aZUNH58HKFPVgGqYl0ejgXzBkLk38jlfLb1qHhk6PqTcMigny5khcKI4Zz+Wc60yNl8XvChlVo68ZHKTygsv5s+zASCfHhO3YIPQ7t7BKjpH7RJ8yxEjKOQK7o4KKn1kRRrQosIIK2hSpAH1RzgU1cUwwgoqrY/M4XdnINWuNFBQHBkcLHoa0SuIKBknFEaKi9M+4BSlwQxFEupsCkUkXFdxZOKo8Cso1KuvqD1NzZk5FDtzVMBxGCoIwbr7N0QvkEGFQbZbc20VFGlAfcRAs3IePRGuEy2akZt22Cioo7oYVqp8gn2Mt0jl4p+iC0rajfDjk17BMWCdHQaWPg4KcUwHZqzCE/wK2qu1bIygSANaRtKgwggrqKpHxb7liEEKvYJ7BxtFGcGq6hQ1LihMUEDRkpRDYC5glWBEYKEI0qCAw0qnsANJ8imUVlCoWwUGWUWnKOqIXoRVgqFRPBKhZWBxDsMOlkGRPKqLZ2WzzNln3OMwhLAXSC/GEIVcwaEQR/u4f0Mql5GOootwULHKPHuLdQjV/nYZu1TKLXx2RJSlj8dY8YycJkQtCIP74eitTgzM1S7e/Ggp4scoBSRr+vdpktANHKqwgnWyRQRaH0GRHSnedH7HxAgKIhz1Cm4JhLAJoPURQpgdFc06rDBBqJJaoIZJXjeQwNlWFuN+OxIi14wMSHM46dqcqd0eZAMDp1Arkh7LQt2PNrQtPYoNXkqVakmq4rQBN63iQH/wASmOOAgT1DtMFcxqoGiHaC/KjvXpiEGpmqEp0qcj2PubJGxHZbPS2Wfe4nCs3QEKpZV8Lya1ZCv6Z3uKvS2cfrvMvnloo4Df7IxeHEtp4jIakFSuPAnURmZl68ZYr9l8VChoq2PiPz5sCS6z9duL7340Nk2O8him2ueTJyjnKFp4ibCiLhxRNSPI3u5z92PcMHRfTxFwBUevIJoFsSKBg1FNwQ1DBdQz2zYatEkc73bgvTZBuKird4ntMLCSJ8AWqjwpKeC4H5gZjAI0rCuOCrDzUDrETWvVMsPw5vGEEQquZrPzzPvhUUSctlq8VBvdPF++U6p34lQmtEWD2vV+oxO5TApDHsQIcbx+l4uvKLo7eERwN8LDP/NIEtoKoIgUvx4fzeLr6aynYxRiApxIOXBR2mo3PJs9RRE21MBM+uVCvTV4B95KqLohiYlUJSWjYkFASCUft1nyu5wIIg+KmnB8P0eoKXWHj+8irJAzigwpoZBJ2AuJIQqdX0nzsG/tHhFsFrto6mSQWXU9hnZW0QnV1Z0m4mYnS1jEaWaTooHz0e7IVOdAHVcxYsgQ4hNOwYAsRHT4rW7dfEPVfk/hfhzhOFPwo08RONwEFs/USFKOI9GgkKABqoVEAs2Lhh1iQ2sA3lom1DS2sV4hHHgyw1fSAI2FSApigYAGmGL5oFBoj7TqoTAXxtHxq2Z2vciVRlGTlEMDvMcm6QAIyhkifKlA9l7DgO0sbqI6TUarUGFpNo1pi9mlcVMM0dPa3EevCNcaR/7b4x8x36EI9SlqT7i2A6kankp1ks/lRNkTUFhAMZWjHriMKtt4o7R3p5eOX0AqJhMRDALMK3ozEuxBiHSuKgObrLIP1p4nBOtkqLtdx95PURFDDTN1XKyHBQo6n0ZQUbvTPsAMjvaymMbnqFCwpO1ZpdsH3o6KZi9zs/0SFYpLVESgpmVa5fImkNu1KqcmjSQ6JRHdeHwnHGWig93FP1PgNGwlwD6DFnpJsNMAgrG5FAqB6UdEb8bxFEYdnIC2ZzYj0Pepu30RPUUBhXkRkkS0kUREKZBiDGRu+GSExHzduQhjK0ZPFcBLUbogeedYBK9rZyukiC56dU2KP0uSE1gOPic3n7HYolgpTOcwQsYsmafqUi4MmCHmMVMIKFpXIvvxsmp9IDDKzUGl/X4EmF0fraKr2Bl6s/b5BOalXsumjrcWv6/ZUdh7tDIz3aEWNNHnSlzcmFGBahoMNRTq5F8jzmIMXkGzOm1k0igACUbM/LUOdx7JUDQV3LTomBK22sqjxA2Ry7Q2Jy8/ezYTs1ZmlImDRu3hJHqDanAQDxfevlrXg7HE8TWK2aJ5/KCOSoYehZE3GKEnDioCC2JqphGSGAAFeEJnBqEPwOHG/V2Dguj36VMbmaGsiMQ33C9R9o7z/r+KtHXQ01BvPPf1U+XOrQXX5lD2+hlh5OSjWkZzDxo6RvURegf659nD5qCyPWvQXkntQTv4qfEIPSjCnUZ1eFS+2xrl1CkCTccRwX+/2nAHy2Hz/Eo4xpM114vcYhN+SFcrBxCBGhLsQrBAMXp46DB8sOgnkMkjhBDVuObkcOveM41mnrfoA9YKfBoBa+AJAtZYLzd0cgVJHscCmp4vcdhGgPM6ZxBoVNxkV12Bw+wgyID/bKw4uOj8lyNwOogua5ng3OITVh30TrwmemgcNwLuIuAJ0JmjpJ0UI7FQ18K9tRWUTOpJCL5pjIQSUs08ifcmK9SxA9STXZrocVOqIO7yLH2CoXPaAikL4uTpIqLlFOeCD4kFcmWXK42Ug1lyAHwY4OGA8yZHr0ZnMDTKVEtapog9WWphRtTAdmvjU8bjFaw/HzD/ICdJJgGveSYhCvEt5iz/OxCQvExLhooYWoBJizx1OFay2xSzNgTNU1YXroGZcsauxULRhkhjbUfF+6NlzfcNlBoBPndjuh0PrlSIY9BCTfOloE49wWZ4g8YfhMPAYj5F1mxmj7yDH0eHiB3o2ETd/TzCuz8np2zKAL9leCRQVCF2v1SDSNq0ajwNXXu6fTlxnQoSx2buGq6HPDaL++gFjXp1ivqZwKDNiF23H7ahN3bkvFlY1DcxZ3muNtq1gjahqGjLKCjur+zCqmW3cT9dfwBElEpLNjFGnNVBtUUxA9pUIYimS2vRhdxLlAwOC7vrXBTLd0l2CglhJMVZlVa1R6yWDsN0nA6qBUW8Ur4jlTqSJ1P/8bakvyJPaAZbbWKxb6y/Qv1mvHxBF1rqgTcJ+qFG4VY9dQzs8si6NiDbMyPc5zQySYzFGVFuBrpuH6Lt/p6Cy3VYVU1JMioMd4+1H4tRwPkyT7vVQcGk2noPOJSREf3fzIm2qkpE3Oy/M9x2oBODGlQYUKwWjLixt8fNJHEQSRxGgRESIjmF4nBWH44TcqMAZWI1ESwHZK2VgKFVAwBFC+EDItPGdvsXEv+JBVU6yUn9zfkFZ+dWtsbEkfESLSYQbqLBWaY5Wux4UQMyIYFVnnlyrIiGSTqJmFWubJGTanxVwLPKXWlC4fN2xPU7iTgsMvDJW8+ZzWYVEPIST0SK47+GQOvqkhDSk9EkqPlcLbFGucR+T3GzWku5uz9F71TPmMbqU7b1DkmQQZEzshJC7INDiAd1KXW4G+MQuCzxn7ea0hHMYBPR6kP29JlBm6RVNzAUkTg5ku70R1R+dSA5lrijRp5SazHZdMmzbfepSXkVeWJqATkEEc3qJ5PndM5D4WNvSFqsFgKJfDdEVPbmnfc30l1FYFRm+4vpdqlvEU6hMW/tp7kuXIrVCJxG9pyi2H+li0X/CE9024zUjWlhJDqEKJNpLC1JfSnG3tTHJ9sZob/MZPQnndwSno7h1w4KRtCGJ0BjSGb7JakjOxGHB8kWHNZ8CMMcdshQNPhWsYAm5xMIqtpC1Y7bU0Tehx1DN4rRiU8t1SyiPtMWYv8rVjScmnZdulyiDiqMehPaboaSIjunBzGp7P+iytcDQyp5KRVdNWuj9uCH2QO3FZCS8sxl+VyrLJdjSBk+5Dr1JO3X+FzJyLFBEqTECxly7voAaGxVqyvSYXLUJGxcDqTcUZfkEBOXSh8EXAVgPlGudcItyj4tOKFXNL86xFpIaYjCk62Ygmu+qxD9XBpjMP2qedQ4tyKodcGqS9DQ7FJdMjspgtcGnhA6c0jhbPD7GG4pcJNp4OlgUGQx/VKqvFe1Tw9WEcUMxbgChySZT7BEBZiW5/0Ro9NiouEohZz3ATj2os5tgi7p7Y0ZyM6v67yfKiNY8RiykkObZH1hZUV90mgDSmqLdpqMWSxYJUlnOiC8UwMBhup8BdiP2EM3vQx3Ajv9GXV8kIq13kyAPG0mAO/ARYQEAhnskgBa4rccIrQhioJk+aJwLk56QUxH/UcFwn6LPRzqQCkB1qpUYYSUFB1+HziqZA1iGjJK0R7Re9xFX9EHm0tq6DaSGB05r8XgphtxOJpig3nsAijiBJjCzyaOx3fmkS9VY8+ewf3UB2sp8hqhszK9e8dUKhYfr7GDJvCWfTOOFP23y6/Jg6Uxg/uDb7KxH6z1Hs4Oip7c3f9Pxps+9qX4AOA32U2SwVV9IvpbWmC6rBEHi+TB8+KUmXYfRsdonzpMRcgGB3g/j+JnxsrEyGQBVJIKq1inNJP9Ey6uSggXDxBIsWBP1zPqbTBgQipXyIOAB1qa21RWttg8SKiqucnu+vhcavGpSNxtARdWgHKYhA4qKiihlu6lOk00QrCkpsZFtFYEVvWO5Pwzvy//TIebWqEL8tFHd0SV3WSpZ3n8PhZU2bN92OUjUaoFhriwd8TBnWyYHcGAkzqONAOXoAO/m+TMqDTJpg+XZjgyeoWHZH1MWpgyRoFRxTT8KVf330ClwbsEzdUOFSl6iBneB4JmqD6t8IfAMMLSzlBOIzi6JO7ZlNtHyM7JCl9vGAGrxMDVcWRgY4ifazcJi0USeFBw0O3CO6eyirB6Yh/qJXzdgUQkr7cHlNJ/ZBQd0zHMFZVgMEuRa0FC7AaGHidn8ndFwj1Jwx7jq8MIWcQjlVsRJMGAmOsYalYalPWZI8tC++G0NmbOIO/F8KXchq/lMu5jmQ+2m7sQFO95l4lrp6UoaPRYShml1XIMwlRE6qae3V2qK7mCTrUN9YiAeTnyUJZKeyCCIwr9dNiMe1p1IyRujNK+HOMAQFHishmwNFKEm4uGp0hxjKRsRzk4QVzqoyaMR2lKwjhcKnEa+RhNNSottDnMEqo7d/XFUQ1FaslJj7PRmmhcCpInJ2vFmvdrUbGpYiUzzj7pt0NxKBWIrMTfiSAKvZ/ATEPDuAo1a0DBAaj2Ssg/K/c7QgAvOoGVM6Umj/HZoi0KNRkn3znR6VmpWBtEvSi3fxmS1du1ctCKAmPoF81iBQsxCVZl/wtJY3RAGEjAGE+JougpgTOOqxyI77XI8vWr5WkfxDrAzhz0rSgRp9CmDqvUYMcjZPiEVkhatpDGWzzFA5dYprIdH4338ZH7OJ0yjk/wOS48L694jztf45VXcTk1+fEn5zfsZSWSJePe4+saOkedawtKQOTiTQ8rx3MA5bgKuK/oslQHxrqCZFbhhXPO4Y2p6vzCUsER8H/ABSDfAPm03MBPDmrxvzf+xArK9/EEYtkCgsEZMBbSTUCxOlF01fBVWMoOhffDGrLnuMwGEGT3cZzcNY9FXuSLhkGtDgtPKGYJMKgD5YTmaYAdzoTd+4IakswmW3ASqBOtRiSTCiK0ZelaFrF89EJVOaEYlPbfTwgMioRjwsDwZCbtnsK0A2+mOpcpXbaUyzvn0YXPlKLZERup/ZIFbmd79Z4qdT+cG/D3XP/Zfs1uYN5qa/HrkNvrsuKmPxHuUSSLY4KcEGjxhFp3BoTZs5pskuJa4w1RMuQgWFblQPVjc+q/db89Yz3NtufNBA+xe/b0vLsARcJKr6tv5x2XZRJI7DPbPw4Ns3n+nKj+5yPgJna0DHpP6L9NIpIbhfu8ltGVEOoMnuKqCk4YrEK86sMjKyqmRrVtWkN2cPpewue7qvLv9MdHX5eIklHbFgp66ibCpZ/+VysIHmIxwaG9DFFovj16JZLEs9YE8vIWY1bC/jTQjAKPnRjUNAryj7GudGC+0kY3uCp176zmP9PtDUv8vzevpvvVMdo4cF+/rY9jCPlrUKBv0c0on8lEPj0hQzWFBtZ48iMbJfmzjjVEM0Qpw9V1BTC4WxGtWf4i3Lh855+RbNXyUqIYpaSPOTxW/3P9NHqpUYkyNnZ0LTRzpK1VuhAVrp3DU08qNfv5esUxHOwuHEYEWIJIbDqs6rd1NQqiU/5S/fyfweP+dCvix92B40TmzSb97zurvlx7xxP9DXt+GCuNWqHAdjydcp3mNOBMX2AfxVwvV8oMUsMapZ3krJwkUO/UYC89ZfhHhuY/KOF1/QMsthkRM2Dv38R8SlmU3OKosmcFXc8qyGF24kD22EZ/WtkyAVD29SJU+qitPVZWQ5m3mQ4cCFmWsmuR9rKXAutsbjgHRCtovSV8sLExssVFsBaFaLmx1uJWNjVSJjR062U9YWzz1bp9QEBa2q9MIrytjyDAma0lRAg4EVpWBrrPNiKk2N4K2VNsdFrVhsNM6+0XQhRmjWk3ENoCHIV+KyBJuMmfwv1+hWCKYZQSqZZpOwTKsClYXvjXVSEWAjlxG3GmqJ3MQghixW0xcGjGjOWK7eNCpKQF9QU3R6GpqAADMA/i5FQDef4RkNSWSmPA5gIn45XRVWmejW+i6KGKOFd1BcuB4Rds4DkIRx5xcGc1i7LQQlaNdcLM3BIJYaTxoc+6sxcALp7GLquP9fEEtmgV8gFZGCBWNQA+3iFnsenqoTEZOn3yN9yQEafUxLPZcEKu8WfnxmK96AA5I1Ohs1ZYcAN4PwX1QarrF2PtbB/YrKyZolXOv/jVkTLbm6XRTZweTdhH9UILx0f3aLBSuyg3EJIqZ7incjHo8JXlMkJgFCABADOdrqCoGvNl+zjZGV58WrXdOLQx1aFxDKLedboRCnPkTvoBaR8QyiXOg7YOyO8cCBhDkMsYhwZMXS7kxZqnQt0MFYyriWa0u1XNm6ZfBz7OaSqZdpOlmugD1gReKxQNuByvfCJO0UeEmsupqGwmEDhL/MjhkuyrStfWcjwYxvdhYL911r5hspgmT8GxyWou4afOWy1a86pKrl3Na/8BUoVD47WtuRKErOh49+cU8mXvFhswI2ITHkK1CpWwD67Wk9st1kQeT1h3ElFItEM4Xj4wBJfW3GyV2UyDiGSL0AXG0lnPoshr2txhcFWk8ytAbpMo6g8VMGBQoqiamWkurJaibyg50opAaEWzsq3/UsC49WoaY2lXxgF2xOpP+PT2trF6hsG2tkdZ56/gfSoUXLuoCD/PAKn0lMebnVrn0TqKuj3qq4c/wl2ys1g1Z7Zu0ZnOIk1Fcb7gl08H2vqkaEOHbcpCH6JgnRV63w+RgXQuL29Y5cO0csfKXkEALaK0C7uA4OXoOni0ZN0yr50r1GB/eJd/de3gRLqUGy6/Wjw256hDkaOuI99BNtSPUYcrJIoYw7RS/ziPlBpn8YHgulZKrqgRlkw9bFQcyCOYNmC/BkGp6vUJO35N1NRnZ1sCL1MDfCSYynoXC0fcUUdDp6UnO3CKGkBx5Qbarza1wd6Wj5jYK3lAkj6HI6mWjz+xqz3fYBonkUkgXLkDAaj+UCZa68byWq9IR1SFzSctYpgkiEe3Gc6p/QxLt1+1A3nnKr4h2BFcXWticceDna65/7mLLm3VeZxMrsTEfiUlYqv1YkF05k/H6j9Jn1iMirQiMUWpYC94pzS2JsSvkvAloZVotjCzH3TtA/Jx29vGPG8YGo/dkk3xmSzQGLlrMt/QnG5i27lyakeFuiI/4ekPGzCNph0EV/OY5WJFwzOYl/wHt60rtAn1HBgX/DdOvgVeAjOxQjIodEyKz4SUwOwq0EV7N5pDCuG9ckqgw4/2j6RaHhFAeCBWHzBoOSX6BvwDBlbPXPjOp5N2Ywuqz7CNrTaVf3hCUIXVZAGd79rkj/c0RFjqqm1XHeQXdnfAv2JhL9Vpgqz/9i/S9LygfIqUoXqf7IXidKUXPShqvhdQeI/+B3ZlWKONRf7blDn3DdEGAVr34yOTrM2PwlaL22ETOTzVytGa+JQkuyeZMhfbPzAZnqzBh0BMwM62st3sqhNTLDBE/hPf5fbk8WJayoQuDb3hZQ+KFTF1IWCMuY/FpgIENk948AGAKa1VObVzr5A6S57gQF3njofKOuQNK4UmQRZ7Gjo7M5HYjWWzm2t1tKDTSP5XNbC9Ul62AdJ30yyXQrM+lquaUM/aGsLv4sOMK0V5s2+5W51+zPyXp5UTS/4DB2hp4epPHWld5+nJD9+wGE4ZYtNQBHiF03YPHLWcS7SWuhowzN0KmK067WUOd+wHgLVhemYyyxb7gpH5MseD4Tt++I3Ah7bYLuumUIK88CvTsFHFJPM+ICtCeHnvQ3QB3PNWTTua3SUqB9n5+F+QIEm938meIg8u7cFg/1z3r+K4sQMzODQoQ/foKU1iNk3S1yYM+4VpQhb8603i+iwKBwI3RDe4yEBp6CV1eDXt8IQJs1ZgT7D245NDD7F5vtvMqzVketfvL0ISAcEayttmSnm59Gk7b+2xSri0aQlJg5rQ58jyq/m+CchBdqIouq0TQWFTsasiFYQ9lW6jMbZFvd649KQlQ2ZHFvO8USk/BU59llUrEmbN/OQeFTdsqega1tTrPiVM1tpaSsLL7Hy446FTiSSkMZSNo9YNR/WNsgoUU3SoWJQ8P6LChD+GE0flDSOG0qRq/UcVDSciYkU8GREiYmATR2XGUWPhEMDCUMsIpa+KWCySm7/RIggYfBSpjuxOhWrRVZK7iZTxWl6EZagxYUVwFin2s7inTWCtCRpJLzJLqDdG2Vspeh5HdmfE20ABgssuOGVHRUJm99fLB7Is6m8Ca4KIbfbpgncB5QARlEPSIneisziqFq4UDE2jU90JAaHHZd8RM2ASXffmpeyMGX8IxX4Jz18+5vZjkOvl67klqfUYoqwvyiWnwLkcLa7IGqVE+ZzZijGEfjXy6kKqZZXPLy/YYVNfZwfl5kHiPbcknRNG11clKtdXGnG5F0ONySGAZUYM1mBqWrpUnzhdvOGVxln0HCebziQAVovAMNmlEZDpB8sG9/XapkuLzNCDiDRj0mkB+3O2f7CDI07DgkMXYLydVbmawsz0EdHX3rG9BBtXEvEpXy01t5Dczj2k0NTRPsnQeKILwjlR6HxVO94miJl2piQg4WvlQ9GP0G8iuQqiTSrnsVf0mCnzBb0A/iEddVYKqA6BSAFdMBMCrDmLFhBgFc+0FiR0gTn/O3k84c/Z3HA34YEYK03B+QFyP8fSwKjw/oLvnEWcovzWthxB7fLA2xoDp2ta4rQ6scqgaeCTQz6ksaoIuDwI+R5G66skI1yIFpL04yiOTNHWuHwNCsFMihRD969Sw8d7X826D97ahPfI19PQwg+5/LuycWRoFO1ksB7LjnZ8BtNOQxkh8wenqIuhPLPlfwzvorPcK1qXCwgSyefQOAc6d/ClcLKRsgsSFjpyBC1b3BoEB5Ncov6T1/4pw78oTPiX74bWEqtUMWrDSJ5hv2v6PwWNVHqTr0JmHWUSJPMMUDUY7l8HUTuUfoa2WAIKXtiPCq/xWaG1pOJcI9/7JY+Ch4onU70hvQiwlEiPn0JQBDVMLAvD1ASrnTJ0W4XVyzJ22IqdsdgyBivT8RK4dRp4xdjvwz80jGVil9VzcDFIp3KKkCWqf1Tmt/Jwzay07jghfcAu8C809Tv8rJ/w6a7dkdVShuw8KBoytrgHQU2Vn6dBCieo4a1ValT1u93ygAI1V4R2fdluLxnlv29Q3RIdxqiRxOpCWrH1GuwHdnXR1gZ46/oCsELbuXUu6HEMU3U6T+qaYLEiJbF2kvKZcDHtJ5WWAExzStJpqZjK35T57wDvfbLIHlEGsCh+0g1JUf6tbSS7iL+AvwZEaVeq//CAjLiISe8ZAosRxslYE04sxxh+/1xZnYewyeMvL/tr/lmgb8QOtNmTlT4si98WP4DdxfrsdgLgoaqfwq9qYeVUGmc3I15i8IffsHqlndBfTw4nDbREclHqKnuWbKYj8lNILJKLcR2NOz9rTV2YMLGd/D2wCMyTMCLXfWmGNLCWg39MSQHPSpumyQxM7KWiGRbqKR8FGomv6A2MxRnMpK37kcIYELU+inpV6/Fe84UJc63NIC4Kz1UTZLZtDFcYLU/wGX2jWTTx4RtETaeoXUISoxLfTXISDNt/WnW6C/cbmThPQSoilX+Zm7lnOKEbsMTs4WR0rapxvWZEW/6HplMnsAcxmpGkitBaoF6SXCfprEoqq9S0rJWrNfu7Tf9cQyrVL8XvYUs+/j+Tuplxw3dEAnOcy9dT1ImIUsPl4lx2gZPpWkm7ZgVidL/o5/55Se0DZDPpYSwOTyycuZ7KeYK38MK0TqsO+QW8fpySCpf6nQCA7jtuM4C5MwHLuERUCyQ4pW5Zpj1PO+JjVa+OzquswNtK5VGiE6wRIGfJOGpeR798BcxQ2xcXoUYqutkWk3c/amgTu+JhhDC7NE5/kTemTrITc2rPy6cRxXw/GEkueRgYli15LY2T46OpYOn/Nj6hyEhVuUERQW0qGMbMpkfA08Z8dFVeI6n+Pn7j0vxvfznDPaSWERlDSJGzBCNJqy+xQs1GHIFjFLqTRIpvPn+NtdoFNs8lO02djVc8r9evoBDqHG5uo1OaBgSrGqvqzSV73im5stRSKuYyGFkK84PB6tbluqm44h5lp3M1Y7fT+sP10J2YtEgJGTI9uePaTmkUTyseFNzODRlHrm0LNrx++qt5vV99TvG8RMHym8XTyMsKL+wF7j710W9A+vnOpY+MGbQNB4s+Wo7GgAWsKlw7pk8Aa9FKphg8K4GM8ZNZV8EApPyN/elcNH0u0S7mXNSNWcG6c6tbixhrBX9ulkVuWCDaih2+SXC7P651NHRagH/jg3LStGLpBGd9nr1UoGxCAfDYv/OPGCdOAo0cglfBaIH5fF+ZB+V9WKUi81Q9RQLEE7JPVSBvlAyfACKPJtvvA5JLUdOXBwqHoC57MnkYOLj0RF15Mh4RRxxQ9CkLxKvtgG2RlVbzTYRPsKx8+SiegpvKPf9Lg0kNtaIdRTid0fVQHm1ZdWaxFEGb2l1CWyG0FGyXsBGQEeA70wEnPK6JVaflhylxhdkjgNIiiVvYIMySL6kKgoKeR9YCS6nwLJjY4C4kwnzq91IzK9PI2gYEGZahVEu7MLcz+++LCMlde2uiNVHKrIo+IX7RQe6nY4LzBaITicGWcJumU7jlD2ZOX3Pi9c3qmfYoOLwiPTiyfEfDd+y1aVxpt6rt22rz1SNgVp5sfV2iNqcoq0S2S2FxXI+7QJJKq59H7AUPgHYV3hj3/nDjRa0ts7/AXfl1SSbhXBCSHPHZlbvuKEFOUjQJzq7IxSHI8qzU5HS7D6oknb5lRKRENqG5QaGF0hq2ASxV9kkz9U7wXTDkPBXPt5cgeZq7ZBcr40iPZVe23xxCqKPFJIm0MAkfVQOCFeY8oy1YAsKWKorbiYx9OlnG1tVnthbvlNbAcyyIBCdrCIeW/eUzul9V4D96hHsDInu60IjJLWqZ1nJhQA5Rr1daDgkQsexHWbxcetnI1j69lBdSN5K9M6KCjsY3qXkx7daSByOil/6Z9xf13abf8VU+zs6Uz3IcNXwP2xONL1LyUckiEVsCsTQa2uKMHO2HuaZt3woZFrARYfHRdUJRBaFMzy6ACWlfO/iu6voQTP3oqt52mwkuZ/OjBCA6f/POIlcYqciXLpy/rcPm1bIFLpN7paomEd2yYTzEQtjkhMh8BC3u+6YS0eDitPR7DsVwI2nt1jKX/UiifG6re3MuJdS+cYXPsE2lZMdka9iWrJJGuTTqE82LaGY323gT0skEO4B0QiNLoK7WIT+ruTFw2+R142PXb1pXw6X0iIER2OMmoOLm9PgAbHBreqEG3oJuXhCxFxZhcm6czlWKsKjJahkrLZiEfu02ph1mSrr88ivWvhOOgYTT9PAJFGDGHYAV0HE1cAtccAxsD3FTDTRVw0WZRLp5ZfWqopjuQt5m+GXoAr63HvSA2G53D2bxbxFpDljCCtJEbKhl4MXEViR50fT7GrZ1MPVHntI1Xe9qafSGD/A3hppyQ7N59vu5x7SV6H9aB8PDpJ0Tey7X6hBWFc4zTwqqJ6gWpdPCUPf0cWczOAMP+Dg5Ni7SihYEcuOAnnXAhPuRXANjOkpOb1nRFQwxQ3XFd+CSvIFGpW+AE0T7FinwlYhwr+jkj6QN+IORWZgfFKu3eXdNk3cuZyljOvENHRBKcSMNFFl5VosMOejo6CB6+3AAHQ9JC4uhgwJl3LJyRBaJBWdA8s1+MO/MAjjwWEZ/L+PQ+UFXlGcjVs0H26VkZDN0iJVmq2HbTVjaVJTwIb3wPlvYR4KTUCyRxH3rJyH9dD0w69ZLiObf/7XL7lmm+g2Ag+IXPp5qJV43RIFCTYMn73+ixo3PfG9BBLO0n8b/H0ecbj/qC/hqRTf1pKxIexgskFzA/xV5rzFht8TGJb0eFx1CY/7QVPRzZjBoJP5En2DcqEccfMedm2HPsAMAHkUQYQCkJuldMP15UnqmlRDP4dIasOQi0p1R3Z3TBgAPVUc+9dRPwB/iuM2BDLpACP4JrPu1UtjCC9r4mFP1FIJZ6aZiUCwVUBCmKrqfw8dzBMt6wxnEJxYVlRLNBj1covaSn/dOUtp8ZvoiFZwBFjrF86lFiX5NexqnDWZoLX2Sh75FffU1EyRaQJAsoZ5iZU6QDDRxcqoJYKCTfLPjJamRszPCVKukaVS3ABg4mYWcmcwsdWQii9YpRYZQOv89my3p6AZ0iUzwKQyBXZmg1pWJzSEuOoF5Rovr7gwxPk7PrKjvW5zilOCRhUAQfrRccgoGSh4n1ealCLIT5ir+Ns3WFh/cZIHFolW0jJz2ziqhV1/c5ZTF7FzqnimSlAsP4MlcaYNjTxXUXNfijnVmmxlxdfceMoo6PWfht612ZGZKzKIDELr7pHPrQBPvIdW3FlaLCVOUM6bK7frP09ABx0m1wf9wbP24WAfqfkzADmSm6BD28iUcYyXh43zCptILpIy0eCr9vNLzXTVGTTKlW3Hx/7ugrQeecRpATu7q3fasXTd0ITuokttm+OcUKUiBfJAngCm9wgjI4TsypkZZpmwL95eLXcF9P3i06BAe9q7OCmQA6Hdga2BmnB0i9TArtDxdwjJDxuZG5w/umCLm3TOibd6cejZPclbt+cLtaHiHf5giXnxiu8gwD4pAzbUcijcTMhzBIhNLnZWnya8SwS4P+3EZI3pX/ZvCPiSY+2/vjkMzsRqO5D2OkVBvkcW+QcuIrP2jdNfZtVX60mZwDjUwn3uMk1N29WCTt8h7Y0XxcPb/4Qs3uB5+o2lcsIuuLJ0oZ9WzgihKf0mxoiyS2LV6wzXCw2SaWcGPZOf7OYY3hYvBq9vB1bGc7Ax9bvM0OCDqfdK6+22Jw6rHRKN4Jo7i/GgIr6SZevCCUD8O8S7oYKHpWUCfFLGtqowy4gcW4p5Kw/mlufqKtjYnh4QiUERaXvhns/hZZPKH4ekZBu4wwVq84QfB0xFUNIR61WewdyKwsBlG4uKyBG+YjktN03AYCzIgNmXXoOJwQlFHAtmKhy4d6UdeqANm94GszPfS/MuL/N2oFEgA1mECt4QLjHeEyHhj07qh0zzBrSjGU61oBZSPReHAqfbIEoY6ZVFOourQvLBy1lZkioE3E6oYmL5eYHxJpkW5aUUviYyE0cRD7MHNEGsIt4NL43TY9k0khz1h9Uf+qRXq9ii7s9JrI8Y+6YNYuCeIhAR/2x8VNgMPB8UK4PpIogudm/3Dq4mT4ZonoJAfpc1iImEGDPNXvuy5RnXu8CkN4Vp/QDqfK1sMbpp/O8yTK/4kB0Cocervb6h0Ku1gt6RAMgU57XhxiDTeWoLMRGgA2AEbM0SQfaqTjfRXJCMoarAU1bxlgTbSIHn10SnzIjsp1LVspRz6TmbEEIFwzIhFpcFy7GSdZmBZyXQBNQ7i1vGAgBoOZJawR/GBTWq4RGtKBwWd6UYE3KnLh5+xmuBhQc8My9M+iVi5YmFScgTkWonVD1gXAI5y8RRdk6qA9q1QVVCQ7P1mtPkxGmQPNaqK93dFaObom9o05J0OgEgTmw2uIC5yi5uNNY3TV0BSugfPZonpas2qbaTZ5/l9XNkmMOG64TDxCCYbAjhHSRcUp6XyPBq5/MhZqy7LiGlZObEUxd0IrKnHYYnvzxVZ+VUtGeKn8t/4yldL1jkUrkJGAmHA6qUbIbEKycHUVikUaKbIUabHHKwMPoC5YE8hwAvyFKfHJNryVmUMMREV8ps7miPDxLxiAxuZE0z+xFYyT0GZh6bKSq8WgSQhMyUKkp1K8zIA6xH+kk32HIhAw1Ys6XaKpk205EV7KzoBapPSI5FJItsisKqmOhUtJqFptEME477orpTFjnBJlUipqZZ2CSKM1wzQ1UI7xSez9BSuyab1klYom0Pbc/oz7H4gjcLI6h/0igKUYgJHfQqQb5VE6qoC3Y0lNAnxUW03VBtht+4DV6cirtlIrLmVnkrTAw2dazwEFklCUZoEnzC74RwSVdR7IPN/BFAVyUQAy8KpVYr70RQSnyVeRTqj+VRw+MPIlkPKd1DLfh4YQDjWJj/fTE+O9vLvcvgD88m7tk+rboW7kgE+UkBxRdrRciLwPeIThWOOHjEHBYNXPReeRT+Tnx9fwvv+8qUXqvKsaMPwiErH2+lZ92yFyx3SO5QBB37UPYF5xuJ2QJSLer+AG1316fv8CtD5syQM+3gzOl/1T5SpKf/ZEL71ftvBMtBRlh7HJbMskeI772jIKHIn9faL8vvStkU2iYlP2LAA4MCzVM/rfRsZTBJya6TS77CxYVW099T1qM5/k7pVI5oPtd3XhNgaqvHhcj1VYezRdFwGUxuK/Ge3Z0hENmdpw/wPKIFX3YFLbR3X0uPpQC1gnpLbnFMMuzQolb4JCVXINZQvsuknr1v4VehbbBVPw8sJfFfV2vqtwhxViKT/gX8yeD6iI38/DIfwj1o87d4JG9kCPm8PlHhPHOUbtB/Gf9iONOTxtViHbRXSREkXhJ6oEWKn1L0cyUUVazMxlbpfOXnLkshwSkUu67xZHqpobcGVv/0Ty6K0PfBsqMq9LrFDsXxtEeFBDctqdUAEVwztLqBw0TMT3eQZVlpwZ1ZIq/lyXoJiXnlDJWulEU2pOLODUX3DTvfdiroyjWWNFV7JnfIiajHdMkUOlNb92eLFp05hOF4qajH4Bt0+5PztVfuLqQjX48MN2xov8uoTGjKM2fibOSTZ0SbocZWzkXA5fdlGZFlgc0+y2poGeOCEhti0CSW3RbjvGDSa0aLnBr6L+uZMLd8A5K+SaukzI0hjHv3R2mFkdB3eq0MpUa5w7mwQmD00VcXMSHNp41tBi70tdWfkRrPFtx8ULcWvR6ErvqyIX2ymbX+j6btNRkzXZhJGfP4s/qYsryPa54Lq969Kw4ZJgKAY+iUk/OzqAxbvL2lskwlFOyynMeFozb6VE06YUCsrdMbsa3nsgQtgvw11oJP1h7aqFa1vSgXWmPw0y8J5yugxxyn4xjfXeqoiggSfHK+UrmPOrS/+XOmFi3NxScYFs5IpV8WsRf0h/pG5NZ11ZdjYVlqW5mkiz+sgtFyk5dw4DhTCJq8xK5A0FJbSN7OC8TAP4FMtwdWfHIZ33jUtzXR92flEqBMjfrY+u+YPgHiUaeDbxvEsrrHxcAmu9SWbwRQ1+70wOKu7sgL5ZtIJ/jUPJGywet23X6A/DwdIswG4v5ytnWHbNVixt6Up/x80qyV7RF3o1xpOrQUZ52LaJTuI1gOwcWXFKne0pwztFfFCnb1XY0tm+8TZ2Z2wJdIQ3bUDvpnbzfJGY5knKG3BTS3JV/2BBEu7nq7FxXfq8bGUmj/pI5aGhQAHk44q+46UcyzFeRlyCnrfzmlp40LB5MtLM0FtiKglsBE8a7aqEezwprQYFwwdnlRPZDjQbpJw34u3TpnPfVyAHLzSEYeA93xuJzgXSOP5DNmzRfgIZIbb2dRRtc5j5BgYcuGDhkiwsRrbzR3mgp6FyrqbXMBhioKSSq+4d9g4Kyi9EY1NgPngA/2B7+iGDz+teoxjNfo6JLmaISqd6OgxBNJTmCRGp/s1mqAfV6uGI/0pSybRSPY9B+wXo2e2DZP0MJp0mHAlyzATKUsL3D4OObHlCSG/6pkIDjWtlEIzDuVFivgAbikU6yI8FAEvEgON1yXaBbZt69tcZ2pA59kb5L1TLrd5gZWMYM/xIZa+F9F+1KGiLQ3uHhoIP2sCXaMCca+FxbA81QslkekYOQ7GLCVw9qSJ3IGQ4lnjwYKYAI7MZiscGm0ZZ4QwoGe9E+4Hc4w/9GpUOdYizZmL6sFpK4JSEpFdvmkKt46vGOlK/DWTQFolGIBgn5BNM2YluUwEOfz9wRKOpKYXe0kq3ODCSVEGG1ok2/bvRJVcVjWk0+Mu/w0xh8dKa0F9kGJQN4MZ+Tvq5hleZY2Vh7fuh8gJfgKnNBsTkUmTM6sxi/OGWH/NMIm7O2ArtejJbCd2ttkr7AwHJuuR0J56ndsbWH4uY2US8ILUCUkTm+FsvluOkzwEUuV52NGkNr7zYgJg2DtX+6jz0I9CDV/GuXg8YVIEw1VLGMPn5b//5zSZejKpeCvPU/5qGK9F9gJehU4r/IN68IO89m/cMMAu+j9mTe5r7/D/rc3ite+KjyBieBZLEytJVHGKBPszLrsUwvNoauuPIWf99/FlOU03mroybPEVq/8qKUJV+anlittYD3QkrAFtQ4AJLya5ItK1AEGTeY56ywRZsdbdSA5v+Fu+vT4usR4fiznKnjojsbaZSqQKQWrcvsq8HJLQrlpX+NM8LsaN3Ju154ljyIZJzCEGEW2LOzisowEuAeiy2/JrGmLrexGu0Dfe3ZP/FNVVVk5pEwVQkMBAZ47JAVRE3fXbIRDm0g8/dzrZpCTd9pLlm+QsI3Rfh0pQ81BrsNIKjApS9mpqvCYtvsNfM2MJaPBKq1Kg/BdgvppzoCZPnTwm+37GvEVtalK7LbyCCBpGAI1LrMfH4h/tKdksfZIlxRlIFWnwvDAdZ1Sjllw744MkuqHTpTAqU16mV5cNHSVyuzBj2hJbjldCnSz9NnWQ5VWodqS6W3yVpZ41AEpAP6xuFmnH04fNfj7RB0xvaXZ+EaZHsW+0wrA8KKOCSbF3uVTy54jp9wCrYhB7lMBAIQ9ry4G8ZUbUPVlKHh7+BlpiMnVYjiqQ2i5ZIqcWE1lBgU8NuyMLEoGpSSRTpMyjIqOKmoyosnhpKKgnLbE+JRdBtAl34CGVcZ34+ZQoYXBaDDIYPYAnDcVF+Cp2JlCZcnIR/HYJh3xrxOjT9dVfgxAiSzWl3403/4jey/hftbrfLL6e9O2h+UrqUCFV70u3jAxko+ybxfNcB/Ia/zku1tEyY2nbKH37dxQsDqf05PgMsPyzhSLKJacI/IiKv54NM215GBCdMytU6R3PjyXT39RaDIvlVWQP+ajkgYGoIFHM9rqnS9IeeI6I5vzv2FgA4vmh4C09UGDNCgU8bkWBOTg39g4OxdYIAke6QdNMBceIqPOIMnkFa6jprJAhwKHZmSmR70lflSYMHkdCbEvwcNILSUcyGU5YVblQrg/NiERraQ8pZa8II6n/j9653PAhluX5bdI12Z4DbtIJU96nqidxGKrQQYG9Cjb08xeATFvO3wVPBKyLv4gdNA72Zee5nVrv0RnlEpA+CTNT4qel2CdokVCLhw3LtTuOn3R0l3r8i3EKFni9lAlebpeotISXkAJkWtUgbVKWssxs+jrgYR4moIM6/CbnXflDycqx1rmyG7VzdpcHQygcHVNYJkhzxMaZuLYnjtXJw03riG5xkdAs+6sE2AHaSeQ9XZ6Xz1hdQGzcKxX8NxO1suw3LSWuX9WtT3YITd7wgjcPNPACZYKuvAzm932CeqY1KOOUd+qnV57CbM/TqqBmw0GCR+uxcPsV8lLGI2opTuQYYoLG8siL0fDmnqZU3xItiumbkT5av1zP20zBZy5y9wnOiOca99bjmb92kbsU5Y0XtZclXGEeMwFHN9mEUPqUpzpefJ5st5vquhxPokDdXadqVUbMaHDO2GkiAXBP8yt5dXrSyggpqfU8ma6msRElrCyqjDyRWHROKc9awdCgdRqNllFB9BvIksOkYRe9eGI7bXuodpc29euwIhGkLj890d6bjNJlFXTDOnEaky0MMHHFT+ubWZruYTTgo6Gi7ihT2fDkrGJBveIoLfklUjLmOTdn7Sv4PHa9kQqPX6xD+HwQDB0JN7UKzHhQrbtKxst7o7p2Wz3ubdC8Vsy4TuEGzy2OaW5Hxc97d21CoF5T0KB1UaMXFeUKldjwOEKXKu6Xlwbv5yQ3ReWmfCS1yRyOhxHeFVSdvEysRntP0MJMHjeMG8wwI+8PNs9m0OzxOO/7sYs77J77/z4uZ9lNx+kgLNo32P9z/XGa7FT5qeW0BYvIWRJjr1s3i4l2TyztXdB1No0XfMmODq/yDnL74JkWlQjpbcL7D4E/LjzFkUy2fRHuopIpsb8kPAtwLwgLsKayqurpoyxryqi61kf31CjBrD0xg/1Os4nxmFn+lR4Jv9VrdqfGtXzneEJv9KTbR4GkckMGUUfeYa/4LTifXjxOim+HCiUobcF0/HamiohEORLpN5OlF4Z465+xJQSn1Nn3AyZXH2KRuBFJ0nJ+pkw0S/iODlUt6IMkPYjFBmNDi5i+uIr54/+GdIRLisFRxQMtJN2oy2IdSl+1iinr46cv02pUVGemnkyd0Yg8jEqTD7c56Fdk8JEsab4j+FOzSgHnaxZrZjhx6ZTw9Hizg2QPcaw4jJid7iMS4xzHY4wi+fX3iW5itjC6YJwz8Czlhp9u/TZbDZuC+fyQWTxWHHskO1pyeU5M59HxvAbRxq7OVebyxT+iRlgqBx9w4YOF4iWsArViUjarDCxsIhTvbbIOsRS7alvHjfNLkJ8s5QvQ6eIAtei01Mhk9fooo5tt7LUQpS9CxkzqWoPoZnRWwik1mw1RtXDBIx+Mtn5JHwLzaMd+SmWgo4IsBpmIDL64eiXhLpyp+50c4d314Cq8h+eEo6Lz6ooqSqXw8fxSYeYuE+9uzKdRXnrpFc2hvzLR10PytGPi9bbiz/thpkXamfl9TPixCpUMJmjmqEpqhA++FhB2z/54U1lW+hA0QsZzoQVbi1HVV0aFVl5nngyQDyyt+JTKUI5j5tGhszpVlYYVgZwI3Sz0tEx+vT0gFPXIKCnfwNdTCPXBdqRETQlH8WrdWgmFv5d0+1AHAXA5V6BgslOpa8m8nRdtCxhvoymfCyMT2JqkjnIEQD0/Q6GGs0hqVylZRqAs9VqppprFQtNIdYLq9fNMC/IjGsPfnTJJEoV5aCJUIZvpcD+Y+Qukzg3mOY4+5wf1junoWjd8vclCyN8VFeN7pdycdaljY7fvHMEquBCuIkpRk1YHqAz92Ajo/Z9hpz2gLSPqN1SphQpdm06eDAlovjTophFkAChoI3B3vdb4tTQxVoVAs0pc53hKP1yoQQxSUuSpTmbOoiwhLp+KpDzZH6QTbUWdtqVgHqySXDZgi+GpPNYRPTAQzES6fs0E4RUJlMkPmfe3i3D3gHEpMwdBLlPjzJZPJfII37FrK1yYwjlqZL2g+E8GMvwFGh0s/1pcOMihdEpdOr8iDG3N2ZojPa2t/3D3ofXvhehaMNIhKxpMcJwtP6QPz0XErC2c/feBrKMAkXWBiNSj3MCxX8CMR1hIKCyKe9msgI9fIhdbUqHbUxwgmXV+Gk6Cx8U2Fp9xa6CWKeWDbk2F6e3soSJMeOE+NqyRI6UL30JFIcQYToTR7hrGAZT9zrS6XS8rjfH3QsSqVpun4g66v7y5iirpCyGerwxoklRE+kjGppwmRXYOV89Ke22EbYZWqNjLkCdvN9QIO3GCUBqzKRmW9wQ1XM1eH5rLwnR6fuLfnzwNG3IufDzKv6kU5VOLbNXk+yU7Vnbp0fDb3tnI0Nz14Fm8vJlHJFvrJGxx2RcIigzJWGvmeEd5oN517GE/0Ib+iE4w0w24feUJtYvZFaNt7aSs0wcWMuzyRPaxMkz0eXzB+aM2WapEc7v9k0xyZ8MVYBc/EGK7Ui+tKicAPWLdHvaGbbjavEsaLbaztdEvYmuFf3uEIKsbZeMNrl+v4n/KE740Vqs8un5USiSEsd3Htuu5HKoP3+I1SzWDZU4Ibl0KDAeNDrnWxrUvO72OBBGCPM2uXvHug9btSnSWwcYuiLEvoJl0ur2QVZ/tGSdNPPU5kQhoIP5B0gTd1ii0slnaz9kQkmBxIEHFQOBHoZCVGoz/268aFhorkvFhDHO+wi30Vajy4Dtqws7T5wErhq/9RM1Ji1pAjWTQsYfKxmFcxP8JZyyyshN5DLGmrq3BgymJ8FAExmUcU+llf7K3uvfnEHcnxeq/DbRQnRlsdA2Fdjp0BnynFE5hXEWogjq0fx3jML82/0mqR/DBzepOZv9gmJyOlT43mz/ZK2eJG0w/Vni7J3t45NV5By3ZQctvYevqWvDjYxwfHbFZGTbYWI23cnrwAEXAYxOiFDVIbe6i4sbSyTVL9jW/9uDR8Qkp8MH21wZj13LCPUDcBu1i4vGT8QJbAANhjcfNBDkpokIVBVC0o6ilzGi1CBfJHlIR8xwnHhoUvLQqFdLcIyar0AcHtt/J4wl/nawOFrzKTp99SyOfqvX0s40DiCNgEvOB5BE1rknacT+hQfV4eYIp19a8ioZkoM1B9XQzH3mNealSznz2taGMx1Er2p/8x4GspQuoYQvN86ItHUKCAWHJR8J/WPj54WylPIxFxNaOBoVjQ/b0iCRFZiKkbm1av5Q4W9NFWq4AsoViY/9mvIzabJjN0lnDnHKiT0Pv4H8iGYjAgCBPEGDVpXZTBEofvTbHAv5CAAcClmN+gHNDrOjFSAFofZtCWvEo3P1HoabPJX7XUGAZeo5VPxQEiPjX9yUTnmhjb6UDZ2TSfGV7W2bAYqeeKkK6q/VJGKlpr167RUSn9pjX8F/omUOawON4aaWQhufiTlFkjF5eemeltpVbm5EQaDiFsyhg+vlljMzFIrOysfLNHBG8OV6I3WGdlyXQYFe9CGRWSfHeiaKH4ePIqu1ZCAYdrdDJk4LAHxFOO0XzqiGeqO8gvuXpOPhNJQ/GqG8axI5LIwrjGsbTl8/foh6CIQglTFo8YEhD+hgSuzMVsC1weQiJVuG9gm3ATVOw2lt52MiL18JeDLAMKbTinafcYFvAKSBupevU3BOVpQj2twxMArERGtDKjIrjfZLt5XGJYn0UWU1X28s/as3QI7o8oTnpafQ/zg6Z1U6OfqYyA4WNDBdxWUwDI8/8aJtJI7eEqtJQ+cBQ6qC6p/HWe5pDeQDMiCASZ1UkARHCKYp25avA1o6pQ+mBSGwzQ6MRhVCJz/eUigFWEvdzSF8iyrDZmc48nDkA1W3UoHrZJMnlRdnDL41xysr5DNlr62pbby9xLABk4xWJ5EcxWQQ+UShgu/l8lFd8uZ6MSkKurJjL3XVnjjoZVkMN3OOrv2St1OSSS1GRWSvZd7gBMElKQJHEYLZs1Net4UlZVnmgrBnuLF3T2sgYlBvI6pc0ih6Az3Dr/RFzcYZ3kPYgcgHoGHqCmngYdE7himX2dBuSqWDu33twjJjyDRiZawX1H+V8ppQZEKlILuR+3eMTmBvY6iqNrPCIAZBlPQ59M5NRI8isPAVYHnfgh4b8iBUfKCPNOPrfnZ3a6IAiKsVxZBlhJ4QCTgb5uExZmJbR0DZN605oCLvJxLsxjmzt3RThvGGn1AUVsu4fC744FBHyKHAoMV7N5LKJdL8I6F1Q89JHHQD1ZaGZv/ZSZuL8sF6GOnNWnQ5238OOhTJvF4AN0+NJ4i9xvH8QkqPosCM+Rt9aPCOiVIsJfrIg8islPrQ+0l/AiMS3xfUHUFN23kLKgeVaEd3JdsBN0m3pIyzAtYWQhwk7U6BjR+pGJ68439VVXDTDqEmgNji2APanaDkJ6JLNkl6mVzAflrG1t8dtZDGBsd0M3SpGpg4YxhJe4kAH+gOedNsx+Dsh3tOhpW/SODYnmkUKeJTzZ/Y2q8eaBD1avNatNT0+G8P7QkuGccdwkFlpK5BT2wD3F/LXgRES1krSFjuETXS3qkeviY7UzHA1kpYmAKVLh0GB00uUDNub7ZRKloj4epWFeJkwUWrFh4SvPqCtCpSDfRYFcBxPZhiZ+ny/1yKyHFtdRCpCeWGdFzQ+yinT/Yda6wMLKXqvRX99qz/552MkedDTMpyuvG+MYZoSUhyciT97DanJPxnZiFbiH2WAx0gHESEhri1eBF6Picigvb5SaCLkrl1LJmqFZOsnyMtBoZRvQxFFYxdRByopTwi2LjyjTnNnjuedTOfMQUHtwk9oDjeImp/k3p3i+SXidX2XyErj8d3LFb3d6VmjJuuLaZkkE1BJf1T3nIPOoS8sY4z/YeCr+LqO/Med+CHxAvjgvWEjrlHcbmLcRaRgdA7ptGOf9+3DA4sjVWtIX7KFxBOalZXQrqIjtCN8L40uHrmqwYhXklsGCN5JDEMb83miorXIxqmlmENocJaKz4Vx1AGuZk1pK1lmdOSUl29i8ReAJF4yReTGuack8PxiimeyLN+i9I4aDUPedg55R5XCG3AD7b1wxj4oa86SXQ/G4w+B3JDeVnrXDS3GUp1aBRRf7zsFKFUc3R72gZHN74N25gPWjsIbY7T4REuAZIhdv/Q7HZEvUR6JqfQRUrUMIv7FMenXZrgrAqp/Qu8XllRDozHejN11HN8DRKkUD8RpHEemLhGmeLxGvUYHr61rGrPo0M0KB+fdh5MKI5qHVt6NZ6YLKkKjxmO0fqghlUhKM3h3PDc85z2hfJOEWYO9kxKsYql4Qvs6cae10QseYC9hRg8mBTtF1MEMY4vdrevYzy4ROXMrvI5SEpfWOec6tnEcRsm2vg+QH1G/E4xatiODqzJMezAmkwbFJrMHEZVhdoxotGhv5IwNilXYKc573iO8wYulcHt9zG41Y5nbFKKF8OK6B7Kxi3mrqc3vyibY/pUoc8ZZLn+vjMlS0zDoH04Y7ORqMlXsWG+DwXnDRhHP+3EFxUhKhiqMWiHO+ylISw8LcmOI9Cc3PdnY4GFnR8x5pMs/w6L0hWR2iWprCBNNo0M9jAM/GRRxdbOEpwthYvhxJHQrdei319nV2gioCssObFUNB1sZCbTqrkCRf8PBpWejQH+MHKXrUZxib1JzB1ybLdCue7XOQ1/aCLrC1siIs+SFJqpEefR3V7UZ8VUxu0Tc7mgcJzdEZmwV7jJMt1FVhdFVEe4Uy9AC2Botv7sUD+QjyLDgHIGoYCTFV4LwEgHOG16FtYImUQyDfQEF9D0C4foo23TFSUgArWvxkoaoZzumJmF3UB97uxO0006Zx4z4pdVTHUJF5p16fHtX4ky8Y6w7I7vSWCY4YmUW55Kpms7akhkasU9LHMeiZY0ituEjLs9XGkwoTwHloFxpPAzzgiKnRAWa0xME7tQodkngztVTQUXtqFvcuJ7uuDUFtRoSA2rAztCHjNlG3YHTAqEI64Ilxjt+NRGewOxccFxyR1Zdjtbwoj0+6GMo0i1EZLqYECy00XQEGWn7SAqXcfyFRd7vjwdYofxL5tDs8XRvgHB++m3xxR+7pMf7taS54v+cAnL5vl5y6K6GhUTgqfvxviIxLBjKMY5xLsWkymWvYIYcCEGWnI1MxMlB8livi0yW9OgCYu3Dt47/YXLM3O4axH4JTALfWonfxDH+EMRTGa5vplsZC34bWoBPYS+oQIjEQhICB2ikUkT05NIIqaRxxHJK0odE06VEnMqBpJZmeyRKaefS7oO2MuJeEdmKkWu/gZcdYezQgvTTjIVQYgnzB1InDAN3kiRPUzMH9dEICFv17uGth8eVHTtLc56U1zajKkolKLjCo8SmjTBHgY3m2H/+Q2aEJwZFPcsluyISfHM4TlneRt4bGJk1WELdwzoj1VnZhuo45gTTxtZ/w83JdtbqkFXNaWz1a+CJ2PitlV7FnDvpS19dXt5G9cd7nL/me+YIWnEo+2r2/wwu+rjefZNbJCF/ZSvgfnVuNSSfQvs6DJbB70ZzS7GsHpG+3N/LvlzijRH1k+YcdSxPv5l5sLB+XTBGucaQ5a7WYV+/tJpOEfqBL6CSZZp2lfb3D/VwFpM6jBjvV1xy7kSBTPpaRdjr1PO42cNcOST0Z5K9ktYF6heqMrNCfWdOYGBR1xSOx+YXCAVWa77jUtDcmZZT0V+wP4Mag+5jsTQbV/L8AuCBQPxeAFNmUQnrCszIzHqd6rPDQk5SUYuYsdRgRjqM/wENGyAMHBilmXxD7J1IG9UG87nC4C3uyyCPDnsCeMOt4yOcCC2hr36HqBwXr1VY1EOUp10k7zrBFQyYwP6eopIP81j6kCoekLWcOHauw6o7v+/MC/3EWjoArAXCl6JV+LJe9AWjYTL7anTQVDlWYnhjjz3u2doJAtokQG/4PNSnxClRjh2QMcp+vAcjWGsdWsTGesmhe6Jc3qUiwjl3wvTTcNAcXGgtbvBWiyMxtWy84R3wZTqR+zQOeqEnj8TRPpyhBP5u842xVthPFJ1e8aVlJHhBmWRv8yNiDd3/R1a0lHHDBRXw9SQQW3XCqppUJJFjdBJ6Si4Yh+6RXM1t+WZEGBD5pw/IQgBhwPyX0RKa+VbHbKP0L42jlmusuUusjQI8s+6U1v0E60+2wmxCZwv+WWAqfIMyBTiZvSJROgNOHD0YmunXdFcTspcJ+TFwiufNzzyYuRcMXmaSqDEdQF+iiReei7wk+15Si5OOLt1p11A/bwsYZ9pESUC6vJ5RB3sG703Qe00WUEB8bK5fHHcTB+ttFRdgoJE7p/2oEtqM2EiuJMhKGLnym5rhGqDZhO6DGdSSf9ZIR9IDhYWYXPCWbp0d5GPTgnWlCFcugG+I3saJ4YkT+wI+s/nKi28aZpQu3290jhcz0w/v+7QNsBLqaejScLM73NIGLAB9l62wwD83Xv2E9qZz0GkLQesVmr0KwCPDwavJrpGWV2OzshNUrsrEsZ3jZSJIH7U2UCec+gCfOr1kHyDl9cQ/+mUBRx0G63vDnYGbivKYs58S/RMsjQMnBIBNfG4xoyIu2WmwlCScUJHG6qHJkimtrbrR6dh5cl4WDcZ+5e4AvU+ufHXjLVhpsq3eriCkOWhVX3LiW4lXOjT3ot1yW/VQXpvdAYQdm7o4bG6PEQDHT3OyHbievJG03RDq7pTR02WQ6gxr2eObcy/GHzBXB7AvPb8HOyn3ZwmkWGDnsUT0iPZSn5oUNN0cKmxK4QHcL38BSOoj1IAbzgyMq8fh1GX8ke2bqL72dfgN08aBgOiG1yCeSzvlk7PZylb2xouiLZ4QLioUwIx2Zv+u34ewxK9Qp9b2bG71BWFdib3SPgS0339oRgtkR0LByBGDGiLyn23KHt16tx9paDluqCyH1gBbaQh6LE1OdWNZU/XhHdcK4dJn0NIM6C8OBSqCXmQKm7ELPPWsthtfWssSUhwOzT08MBnk5x7kp3tvnEN6iI7kBWpzHhFcTzecfUsA0W6Z9w1cTpwk1NLBuJ1PtOoPPF76x1/J1t+1MXE97RZDMp3ujMm1oLvOCyG1fx59pyf+988b9UjtnLqNnIyMrNLQ+UTjXbPwge+nnyyRCdeklMSnZW4jSQ7tEn1bydnnRy8C2vqdprLf2bPUkIH3P2cvHJg8hc/mZD9pz6U7Nibn8/9OeiIpEpJFvg3qfNuk6l08h+SiVO0qlCcf7XFd6NO5l72RJaFHCpTljJWvCnkK/qV3xAp36qr3yV5lZRd2KDqLXGYBijgnQ1en7KIMPWD5bYZGSsmGT2abFq1Uk9w2kR22pWumM8mUh5k2bQnvcEVk7HoN4OOrrOoJbRAjJs+aWUQGnYcufSBjcGhQkU9dg6iY1qrmpJvMCSfT5fmaC5YfZwu/TZMZxjDxJHmJrgPzPHpozuzruTE7kU0TI/tS6KVVPIdQ8oqa98Z7oqiVSKPNB3dPy6qHYN9o+4X9nltLfZ5t7dFE+eazZo9K9an/CtNMScwH2n4lKDAwyVlXWF8oTw2DWJKKGHrbnZd6n9Y73634tGrQgC5emrzMvkXUtr7dSMSPnHd1SqZRbpUhlZn+6hlk/twqbUa0oWdyBclFZy5WPMS/RGuf8DrN9vVSDX2Uz2YaiypudqfwzH85tOAXp6Al0iwNs+6ECbNd14lPNwBpSMel6LSpqqMW+GUzoaOHV+LFuhnbOcYh7cJCNeKCy2yz7W8PlZzrt1dCtSC3UbUGnA45lvDOH1/glIzPNIPDvJ/TQZZn8kdrfBIZvUzfLnl/fy+aTwTmplCiGQIAaz8EZBYXLWi8bmUKOqsj1p101IujaKi7JcOKNaLhzfqWJ3QGIDZ3xT4HABugL7z2jBET/2vwVd/7tPllBayhU/Q+L6LnhSs8mfb0ZrtkLvYXAyWyIlTWmfGsQ/DhUlhAmg3jIzNYkBmkSnSIYEAka147cj7W+Rv7WEoOI4zg2653tsVwNpEwFai81TcY3dVvmnbtUwbhWVov8Y9q5ndASWEw8mZJ84LVyvoXyOaJQw0YG0Gu4EGxW0IIKyilMSvK6OUAKOgtlEMmY9zVlgXjXK3n1f9TiGxRyad0DBBw0uYaQ+HsMFjIksv2IZ//gKpz30A+Ygi9PfLt5iNlxMbYfVoui8ERLi6kuowscBcn6Pi5jVAwvmcYja03oekzJ9KxKyiqpIKPhoc7148xGQPYoQLlm6ljJQYtGiET4uPgrmr8J8jcoN40VDrzyW9LYBAvrM6OmRjPkZeZtB+1mxwFPRe4n6XsntnQ7ZN27FnfE+zGxC30OsKcSeK8ahckOxhnHfvmXes+rTigstVaR4hdbsxxeKJXK2dsNgR8LjtTQhihm3bfybjjI38fMOBA2m3GO6q4iFJE6bGEGeffYEj4SMQpOJkXhSB8UqYfwjyGA9vHfFwz/hYKjrpiWyROHela04uuRRntfgppSkscMU20fAVNkw9akjveTHoAuVdDQ3dqFEBYxaItRIT5QbXD1evQBkq3xv1Uzw2O2LsQx5uZOp4a/sOKEkU0ykCIrhX18jy9iMHA+1tFk8YNkAHlTzPu0/NEloyHSIb7bl17vf9KhR/JhwsTDTZTrd5SKHLSU6geCyyKhRRFVQaDI3xpiZcfzVnlPPaoSGkmMriYEAROzYLBwgu6K68q+y7q2+N06S0dUujIQcHFdHXv7G90irAS86DRSnZJRjiW4w2MpCJK+g40ZYQ5cPZreUnRRjxo1nrrN6zj8zFockNlm8Kg9Hp6PPi6EQ5E83eiw+kXhQtWCHxYFxKwPgQTVd7syycPhz46cNx0TLycx/sXHtb4aDNPgBh9yBGTjHGtbBgfvsbqHwv+wBGrV9FjH4qfumPpooRKjnxOXaLYa9wi8+mgRauUWlH8rT5YR+8kyUgYcnXKJUWNwp8tp9IikubzYMlpSPoaJUn4OqaPghI1oOgBBBRGH4+GBJVdPT9oq+C5dqWQ1LCijXDYH9oK349dwrUaUT4/6H/4R79jr+tE3BT5cw7Um2neig+I0/VlF4Da5OEuaCFaCT2JHBAxe0fCngY3lEPqb59LAKT5M4mwm4MPS7hyE/8xognILdc0zPKFWr7D3AVwBiwvACjDYw4mI6n17YixCJFiDR1Ah98sDy9fj5F12KxdymZ/KrdAF9XssoIx3UNv1el3HQnHl9NyGG8pm/JlIC/5rb1d9SP5eVqonRdHIMEN7peX+khLCMrXnXs5WV3NyKIwpRZmuXnP8C7GzdvK+fmIyEb0/HwOIx5D/lPiL4cRF+jgCaLdd1YR+AdPiahJWCF8V40PterYcYz+8Kx+jtQ8g42H78LHzdu5biLlM9jVoD0bXkMV8TNsWOof2/cEvxciTHJjJF4DfAHwIsB01oM9YGkQoFZry0qIQ5G09BdX4CZ08EyQM4IsGCG/iFnNY6n0KC7S4+V/oqMADTKOK+AJCjH2FjLw8FAyZS5xSKCUKY8X9/qMQY9LhYlpud64E2Izf6HlSa/99yvm2dZhY5zCECTYZoR3cBz5h3AFb4mWJKG/rSCKvPiZK3WiQK8eQO+F+FNj8AvFUqlEZEjvSpgrQlb7eCN9KIIflN8vG/ftoId5OkpCIlfMDTiWzPGOkGMkoqdZN7SgHwUgon2S0zDNX2FuggahZYJv8196szw5tPju7ARO9VsE7ozL1U7mJR06f9Hykuz5zry1b+rvPSd8MfCh0Y2CdXXl6CSQB2eKm980uPDU3Dd9jOFIazaxDfkQTzmBOEawDfeswVcZwxHeOzpbnY5bIPANBHmIN4Lc7fMMZlJksblHkEJJJzDDTn1Y0GC7r87IRomaCRzZeU/D4igC+yoWRwStp9OvfQAaf1RigPWFTNw7TSzOSWSo0D551JzOaj5CrDVrIJOZfHG0GFKGoJljfNgzz99hZHWgyZ7M0/HVrM6bmuzSXrkF9hUUyPk1z+wtoEDBpjZbB5H7hlOMM2XJAw6pQ7xi7qLc+5ujJiZfVboeaQ+/ZRYtpuKVSqdIRaJlKuXjKtpGIGS1eoR7W3IzfAr2YZCHNTpAHuEXVm1ksjE4Rb/spjdifpbiPg/owLH+YMhK1LICMUDTUsFTq7jf6hR7ZuVHzUTHxBW0/BdS+RXQht5N1BjyIs3MZ0huShBJV1inmcPt/HOx2KNk7YPl0QGL57BN7XGEp4EIWyrhkbrEngIdTjg6xrA5+MrnihzI9wLWdbjzcKHWDE/FTaCBhcqSkHujMQ/yq8kaaReQZYz9zDMnuqF2xcBkx7PxY227z4DMGC4uOMmDW0LVCh8WNvcmbCVAENA8TXpbdPEbctxEFeOaIAy5Ky0KgfZItDJ2n8QozKL5Xv+QM4oXRkRU5CPazNPIN2pjbCH2ZOEi8B8TFC2Cxn4LfwbTKWEb+tbBI25XAeV7AKiiSXHNHCoGqunJ1a+E9M+6vqhvrJXP+drK6TgIiORtQbGzILGN9HcIRIBcE2zT28ldIH8OTE1oSaoKOAGclVjFw/NunT1XMZmKdb3KjAiEE97cO1uZr6L9nWchZU+3mYRgJX1G3Ynw7RXpASQlgblA4zxMc6rzcESySPWTlHA6O/7wyhahjIEwIpl7nyGqOaPDGaeXAhbjXBFfyOXtitpv/A0YPlb6gQT6G/ZK2k1dht1U5lfMgg7/RiRZoZX7vgE30f2BfJ9bxxtPQHO3MygurSauleHOjYhR6zW/gZvl/tCNH+pCzscmezB0HY/n8bomqcy17cVxoJOeOV7RsvRm+ZmJclaMYgpmOZYK0hW/lQbfMYIgqLO5a3adPuAqAO0GMGRGubNyHtzE1csAJL6k7hGJSQ8GVF2bOoFwr8+C2KuQdpEYr1lFjZPbjAhzPYKny8+2NS9oa6DoqGtqWqa4zD7xGjsxDAPI85CuX/dGYzAQiURaWgFkBIRPjmeK7rljFJa59Q2vY4/MCIBQfiwUA7L8DSuaZfEXHy+/Q9PwF/DgcaPek8pqk7kRYsesSlworIlTSRzLZSHkqrRi+k1uHUs5Z9J+Qj8yYwWo0hszKINRBMBvl1a4z39gF1naeu93Ia5paKmW4V0ro2RNjplGw9N9ngwJ1ak9ALYeeMzykDSJT+xPg/tVQokbUvSVeqzHtsZoTe2M0vktPGVPac/bGt0pjdxXp8ewlz809HyZ4nJqB75UX1dHgK+8ydQV7KDzRTSyxAzv+ucTsgX6khH1TxbN/8aecejmVxgFbstjW4sXJbec1FGIGncKnvFzJgK+nULHcOugMbq4CU47ay3yu9ptvjxLrZXDq6Rh3hJao8Fze9pM94dOH1/k57h7kT+pZYdlbZUHOH7ykEasQEPG949s1UimRGe2qFE0nP9ht9PPwfsdk1LAAN2IiTUS3h8PX1i+AV8KKJ/msmcUKKHHFK/0XagRaAJA+bhIYX+w5WF25KYcXJzNkiI9PW32R9wF9PC6FjWL4WpmYX2TLk3U/zjow0TYZ7By8/wby3goos6NS1lIQW5CYHi39Mhma7Adh/oCJKcdPx08wAJ4YRQGO+4dwQCdJHHtJeXNGFYIo6T6T6hkES3TeTPYi88ba9ZvP4hZcbcTC7tNZKhSCVGJtuTDIAsFXd5zi0/0IeAvjYF7FqI2ZHZlSiF4hFBbYjA4ezY3UD3xENZg3uoFG41KDmDCS7vK++2Vhoo3y1Oft0X42iFuDioMtGeFZyymM7GXJm68ltZsHXipRzkw58jST6Jj/LmJRpyNSr7tR8LsIh6TZjFKP/wAGj+QMCPKlT+3WyiewYpcnb86s2fQoEp/4kgWE8JezkI0pXPyPb0Ie4ECl08lJg9E/Pl1/ou9T2o2y5DxRE6tsL1f2jKu4pePZ0aYyRQI5UnDjy9zAVxqSpd+uFRcvKFJPqxjqAPV3UmSy1clLDN+8+LrTBypQ37pjcfCXIAwpBkQvofVHz9xW8vnDHnfxmcDZnpZ8X6p1LdCB7PjDjv6+jiJGeBdvKA1E9U/FJHCheA2qLMke1QFdTjHTtXHuq359mel9Q0V03oMS3mpiIvu4+r5gOEJdp/MRUpgeO+9mGKN0y2TrR+X6gLBqn40A5I5+/VP+AOt57+XB6YyqxiqBrsXlCAE4zMwjTNNd04RillHLm8XSOX3G1u9+ISsG4F6K2Qcr/KonYbj34UjFG+b/Y9V6Ei0iU337WCKhI19ZQuO2+SZgRAZdB+drs+y7JSJeZytL/NdfNS6SE9U1nUSaAMDm9zAKcMnnKsGhKY1bDskFe1yAoBVNT2l1xT+irv/egcX1lfnPjXAB/Xh5GPmx5TumSFK44iILFyNF/7EsAAxLUU0rqui2CFRd4y0/bn87pkRiOBLhAdM5hBamUnt9joHeYRMsc1gOqJxzEFISUOaUbmxHQOH03FHDTN+4jybUKuAyIqA5lA14mLcBOypAXt0LaG3Ous3zEddI1eWvbh+E7W0Y1iyPuNPeWESU1ssvxo3Zl5vvjLGDd87QTUt6fyKs3VYT6WCyppvFzxQ8oY/tgTMrQQ0Ql3XwwU886aeQIBurTXPZWR4GcSph2K8h8GhNrNfOobEnhmH3WQP3hnPBsIz5B4EUgCsPVIqiS8mgtCC2r+W1+Zq17BQjdKgCy6K4iwQp+1zJdgeQoFgknWQ50nxF7jBfgZVo6A3p2aERF4YgSADx5nKoeYFP6IrIta90Z0wd5X7cH6qQV3QOMpm5gPm4zfplCu2MZRZxHUMBLRgr8hvbHlZ7tho6jcHxUMUxIF4WHCKcDOOmjbuCStCAa9Rv+M2LA4KgbHhdBD6Ev2xUW4nhI+QcDJ4fRpFYihRgQBSI+hD4uOfyhhR53cqbQlt7MmZgJzgBGKYm3ARXAwJkdJgrDK56m7vO5SanOmFA4yedSqTHtQucHqyF+2kYBf0MEAc106X4me78TWn8PFS3tFW85iFgEpaBdhrtIIw/XQobiI0JRRUvjmXxn6HKiKUGJwwbO6mk4XiVAxXy9nHtL3ocZ/bDxxqtWgX5kMLXWEjYg8fxXFTfU2R0kbFsTgJE/QOp4v1pRFM5OZEsUetLDVahN/2I2wG0rOtm+qc9fC3NpJzT1K7v8QOfIdSbx58A6l0FSRGB9GN1Nq5EbmuKVTxOTD6Nz6QIsJoicvkb3Mfh1XU3+5h+MT6+pVwJyXsE2Ad5SZ+8Z8jtFpzon1MdM1emN07Ex1Jbqxn+mjjsmUXxtHKE6/tV/EnFKRFM0huBeJsGs4NkqUbtYKp4B9guU+kpNAtkeQC0Fm1b13EVR86gT4tM2w5+wQYb4PrVBSFKzUcjftE6mfYS9yQREMGnmXV1ykAl9owWLtFzz9EXJ7dzYZpDN6udpvhyfUL63hbKr/LYhoPu/82shSxjq3l8+y+G7ivfEIHnyBpIKl8Z55AbZm6SI5AIUwdbhbO36Snit/iC3dhFrxKj0o/8FAEKTCTglFikomdOz5fqtlLGhlylr/6gMiSxlvJbB0IRaysqqlN61iaWyw+4Qh+JXEo2dCWj5ozXTggyDKH7q7l0sHRM/JSr49q3wKCHwBgtiPlAC7bBHfW4WPjvmFRksQvvs1OwnFMckFaZbHQDlnr3ifvrlggI8tQeHDZU7yJX5pNEiRbVjtGG2fnOzsqnoVM8Fmq2id8winCBuXsi0zaWvZbi4i1g9Q08VW1AqJDuQCop7Km1z88NepN7g8+THA5X8jWmKu/wz48EFFA/a7ChYG55JuGZ9R6UqEPLFT2ynh1fsIXUL3LSrP9ayu2qNXhKu0VDw2fun5qyPSNHsinCT6gw6+wUIjEk/x3CmVPA3XgkfIc4LIyvSVGd7PDLpnqWTNnnndb6CUGzPizZ/Sq+6uEw33sURw1Lda6EfcRrdRaRW6dSPIo4wYC61PNFakPunHIq+fTjG0T4zi57eIJX2ZYANveOwmghrJwGEUkB5XeIEDMoKoqgdAFsZSrdRFLWOp0icnpUqYZ6v9mLesPeLVqUVj/ojSEDzs0f9/v2gTylfJSNep0WyAwXNrBETsqra0TwucG9tCta1dPhTHsYrndKdmFkzHc59D9yU5FD1jB3YCyTAE0rrn4LM5RtJvvQXQeCdUhMYqpzwpZnW1SvkO2fbGh1jDPFJ7/+lAKx9FQcLQgPKmJHPWaw3ZL3OrWL9TkPt8M3yDLLqwaNU123oKF5zMOUHakBJnWpCT65XouPxE+JoERe5SDWoIZ7IqQhVul9anroms2f0ple6xunL9FmjYiBYeI5gOKtz0RgWN1XxJjVCHZ6b/teQvAtrL6/+VATszTEe0c0l/UDI2z68VYMB+lhS6vWOr0VLbwxhrPB/4G8UPiXD4QUaY0nfNfnR/2E31zZSqHwAYWzecd8rowqZlniqqzHHwvI/Om6R7v0q72GPEYqQk7emDqEe711VgCPYsja3dl4LWYL89WFO+58UgBlQjp6ObtnhZv628k1J7AKrL5kiBsyMZMdA0g8SJhL34uuWepq1D2c/AO5t2I0fCqQAeXdYBtKADUDkubAUCT7kAToA4xlVDH9kYTAgDPOVc+SBTQSsmT+uXJxMLmazsi9eGx0ssfYhKAhBV7J3Vtr392BwdIZd/v55LGr+U0XpULcDsS6lPdwx3DtRFcz7Ai6kKJGswMPGeIGwewp7qKwS7+45JLr8nStzCgEeXXITpE55XHJncSavOBYJ23aZgI/573YNZweBK1wb9wZQXQwvaHRsb8PYYshvY4qkUoNw5tvbOoJEdpNOAZz+l1wA2vQ6EmnJTetafhx8RyfVQKqaMdsZ/HEZBwvXzANT7fNU39Ha2uggzzLih+tL/YswNY6L2WJKptN4h6FNX6GObhcjgPd3gC8jQdvceJNzy7//GuO+df0AcFJ7g95gLk/OD03HL92b+gO3It7VmDUTxYHSelEd5+S/3Py+KtkhaT6HT9RZai7z6j5EExeW59x4KdRmMxsu4BL8peISoOIKZoQQvTXjpqHCFCKPK0hCyWI26QTKmmPq9zEpymX9pTaOI+6w48PfDAujYLLG4rvqyseZq6K4tb4eL9HbqxKU+YlwJK3JFTYEhdDsA1m0djFHwUINYKX+YlEn4Nel8tQv3RecdyirxoHNPbD04pPLCSE8NvbfiJpGhDas1dX46kIURr8tPqCX/gkaTWt76NH0t+SyRyb95A2q0FLrenS7+tbl7HrI8pRutCQJFbSbVvIy/z/azzejDXI41fhwodVVvc+SdLFxvy8Xe8VIIqvwI3jaJyQF20RfyQQMISIWvKiYHlxjPGrmceYPjM0xvQhtU/XwFSoKep5fDrtksBaIpuBENrPDhoMr1+2djRASALwlaBlunraMl1D5nVYQ2VVdSkRbpndH2Of4omqyg1p3QcJU/l/vwH0rfbaaS9rFOnTBixsBZNqOrfn4n7Bms3tCkxm8qmL+0qLto0FPAsmjYTozs6o2q1b4ZkZ6O5zjwL0TYqJqcdD8X5ya2pQ2L10nHzzCs+bbBpkPAMUtdpe6+K7Yt5k2Jii6z15wPksjR5K11tNBsakLNZEZ+VuzXhiGzc58wYrfCMMzY+lT3JZTY2CAgQ6vlyDxRj6i0GUM2zA+1U8UpIb82p/JKWHRr5Y5yMKbb/w8W3VVBn1YYMOov7RRPxQj4j555UbGtru0j0MgNtmMX8c6lqIeTzgbu7mO5NnwWRG2HXDUQ43ZpWHqsDtWEwTrhrg4YST5hs2AIimztZXRG7x47OU5RgR5QiXe57GOsOfmyf9CTXaK4kSXHqcbzDlzZPvYvi/QXhfpjNCQ0xUqJVQJ6JFi3+VU1ICtCuNdzG8WQgNEtUR8oSN2EPM5czRfAnGREgSiRMN7Hz2r+SBbkIqb9OcneyGNHwrdl8cQh1r0k4vLWhH959cVfJtz8ihXfXB84HDXZQIYoE1AWWiiSk9JYuNZcQI5tGuL7EwzQsmkM6ltckoImYBtrXqfwU/PFRs36oo9p4Rts+ToyABUFs1IyQWbpsohQAnhnFmSd8ySB9LkbCPGuK6ghHuhESKpdqQ7Vtx+PZELDcyFeDEIwU29KIXXhEc1OFc5yQGs0Xm+NFtDTWukpJSMMlkV/AJR7CkkNfsU2ScwEOdD1l7ugFb2CvGaLVp8/ouKxliMw0QK5gP1JuVGv7ZlwJftcWtfpS8cLXiD1RSyMrknolaKkyo7qP8k207V+HsXMz6rdjtgYAT8EmQhxoSJ1pLNRRo6rhIKWw1ZS8L8AvsYrWw9Csx9W/pAUqnC1pLzdHhf9o+BZuvizRS70IjYHFgNvwq8dtP87KJlZxt7TNdnb6jdXHPCgJb7NV4c9lAOV7WUM5zVNdBwuQT212IynhkfBvuQZ+VVuGR1zgrAha23zIgcmpmbnM1pDIwpeBo/n6+oKNRPp78Wp++kE+Jb1XKovP+aPX1lT+RnmsGNRwHVnlhU5HkbGQRJYc5IXrE5RZeWxeJ/tsY6bt7soPlcxR5NGzMmexmrdhRXpEeJTBK7UtAclZeKncCAcjXSYkKzKp3j3oWJI8/vxStGqFmdUnb87UxBwJnhS9beXrT4P6Pde0wTjB8h1XBCNxas47nvkRXLJ/wsoQt8mLQz+/QGYbpW0237qshgkEr/XbIz9d0x/oaPHzDHi/AoP5NPXbIecBT8Ct6g9AKTpFZ8/eXPwz6BkI6iOkNsypDfRCno2xtukNQb1s+o/p+4YNicT/x73zAxojIbhhWOeLxJ+kkUP345xXbTIeYrtx+c86jJaJJL1wJ6Lm/j2XnRYxNPBYS6C0gbZE6zBY98rVWKkMJPOh2juLbzddjnbd+hMOnrwDc2htvK/w67qZZsioYPJr25LgcslAnRKEfSHtEpzM4uVDzZrsBMNfB/5KRRDCjfvyO0OVEn7noZ6hB5mUP2pgDkC2SpUpqohB6E/wy7J33wj5EV2RnQJ77yqlocNnhEirq/RLYhWzPen2Wg3bRej2zophn+gAqfbgodwoQscEWoIZjFgNN5DuBbXssO+Gs6b8eZuCbRYnviGSRzNFVazGXYPwC7I4Sg1egcd6G08FsnfftjLHmMUFTrYCphKh1KPB5fq0jBtezaIL2yfncz20aniJQ8A9vdA1HIurxH1VfeHvZklcHHcNxvnztK605inzawuwugU24A7PCm1z027srNq88CaWkMzrWvWCocLktBPwtDMoeurlxkZWNBsCFGWOpSiSwc7ZCpnGERNxIVbV5vq7XBbrmPw0z2bgqnVVQsba/3fKT92BArvwvlBG2spsEzXF5+Nh7uikR6MV+Sg3ek4mYtLp6vEHgInVEQa0a6YQpnHVMUJb6nlAeHS0QxaWcUK8cgHAyP9kkoT5cI3CE15cm69D7iFLLXYPbFMvfKyhjGCPoqhWeLDSi0QethbUGZ0S1HpZvrGVYf4rFFtCvWLEXj/Hhnij61VAdtKNlPz7ePs6qtyQOXtc+oQa7RfYmrYrpa4N/pt1dShYjk1OTO39LHIpXAYt+WzlyG+GvIHjXce3hAWFLSXtvqvAMYLVSf4LPSv2IPanGm2xnUHlUq0uPcZ9A1wBpCNicu2tMKwDWIJCk55jxDrt6WyHcw+mlyKSwolgjSv/lwwR+wO95X89AvpvIu/CCwXgyjxShn9rqDf94xYQxmqW/CmSDRttEQ94bTeJm9/03n4ZujBD0xGpTPR48PcML7AP9BeodDzXwvPLCESy8Sh8DHvM+ZlHMQOH28Or2d8vR+9GXCzG9TMngV6iNu9LG0qDvt4VpCDBf8zRvnoHkR18OT37d3SMfERUzhUGWmrDBgNE9ETHl1eH1ypsHTJ+4fNjr8D05DP+f6//XooYWvezNQGZA06j70A3ayJh8fUsNintf5MlXbw+zpT4abf17TxUfhWukGSs6ZV+8iwUU6hpsB8VzBOfBmaaCAt5acHuWUnpL7ilMfkOobreqiOapqI0WkjYwB3l9myweC4S1hfnS9FaBiVWKouTtVZ+x6tS6DdV2dx2IecbMyJpZAqeJkiz9HuqvvOZIEcSYZDCJdLwTSEPYDE+loaMdQHHkbInnpMNf1FGom39OYqeiqLVfCS6HQiPBEIb2+KGuyZ1LNnBA3IC9ulbtuQnCz9EAooOXYPQ3SP36IydFIrDXaZhFedcMXdxbrQjkG8tDnJAXS5UqjDUpcn+B+K82Y3A+8ZAyh2O6ESUZt52Qa2nQCjHNXU/+JlMMw7W56jE+y0mYEnUguqLoga4rC5yQYeFn6lLI8uOuObBB+RkhgihizCiwYn1DYM3miSyaDHGGpYyB4IZRnjLuGD8s+qcrFjKrDbwR2TlKW8D+SAIqEoVxDS8n0KIO66lNiojCu888MB82B8FcaZVGgiH31EQZ1+EjxnjMTKH1QyA7YOXPj9GXE0hX7CghhnKSUWPaFuf8YTtOYzJRTSkhUDAqp4gdH5CeB5vpPiqBYIlDsPRJD8a5bsKOiJ+YT6JVo9lWLitdTC8EQIwApcVWxGeI9XHYxToMH9QGFyr+YB5xlMJZWK+TEb4cUPLAPRjMcqh+wzG+oSHo8IBH2Ubcc0YyHFYaKehx8kzRoLqfDccM0jNQ0w6hj3uZZwJm22LsqDg4lGl7BKlzUVY/3n3rdwEe0hIpTag82gq1S5REMYx6DlX8wOGj6gkTP24SGm9k4jfB0Dg9eFGPyndJLgUCcgxTIxq1lwY16x1cOUeJWaed0EdEZOahStDODlgzrdXOWInV4UPoYJZFeFXIlSnGqMhWKtSNVXXGULcRVCB+wlgCHz7pgXCNdEZGemVcd8Ogj7809j+x6IMZWg7vFtuFxSjHEcQvjtD5FlKAvF6kNjzPDTa8xSyhmGAMk6FObnLBYO0COFgul0EXAImlRWp4VZzpZF64K8ywKc0VioBIHpsZfNbgCSTbctnUlbD2zJf9t9pB96rr/3KwD3z3X/wumljO8XPuUSv8c3pZnd2RLHS7O5YTpjH0a9QVHHA5ZbudoGCVl408H6LqZzNC8Txc/Z0ZgWSfsFVyNK88x+NPUtRzgzmuClATFZ2tw1LzDlaafKE1pUD1aC07aWK+uA18Pdeo9hMbcR4Sm9uK1GF/e0r8hsuqla/+3T9BDxp9zh2Fz5jIlizJrFPAHgvJsocUYIo3jGSHz60I4ORXAx1tzpNW2h60b+iKCJZ6nFAN33DAX2I0oz/IxarpeDK8vM8IjnaozyVWH8TSDVgATNdtdmjk0tAZQ7KL2Fz6/R5ELfnSav7ZBzPjnmofptReidv31gjIkJSIAzr6z4Lows38dpiRiPKTgmlXLAyCyanyJhZSucclaWHRCEWMVuvMJgjEjShm6++G0sXrdyuZjh2fG4RbMkGF6bjwG+hm6uTCsBk2aFzKs/IaTOokQv8ML6zfI3PCzHA6VpQSKG9A10rn1w88B0EMr2YqAjNHsDkXXi0komp9DndTw72xKp1EDD2wclyQiPhSMoXN7wcl01RZJkvtZViH4+QQRS6kJmXz0QkC+P5yiHPXv7s5Mked06Ki2lb4OcmrdD05t3nhEmXmJmkDRoSDKqsBo6qJ/aCkabCSKVaHLFrIqsaMu8ishX/z1x9HDc48RPKvZm1HLZkdEWOpyBQ+Ux2N1Q0x0UctDIXXKf89MxiB1R0Ch13U7OlbuWXlwEPGq7FwZ1nFV1DsxD35RQdfkQHaQga1kgisNaWSrvLDZDSGfd20tGeSIREQPTPgiRC9P6+0sOWIHQDyUmaW07agCEQyBPaDHYxP9Mmu7lQGECekg32o2VTDmxnv5cfZCAATMicFTsXxMwMs0JQ2s/j5HQm6WaLSDzkDtAU+4DggB8ARrQaHxILjPHovSEhG5i3TGm2/SjJ4RIUHtSxHMjWNPUf4EzHcStAoIh9UgQ+Ayruv2hrhmI/sYypy1KIAmBvNpeQQmTBPm3qvVxDAyBUc0DRFNX5xlFw1nO6sQaLIqTlLQl5boDTMLaUu66dJrmrwgHe6uBVQ9J5U8pnSWiovmnFI55A85DMKbYi9faI/l83Jmjx66UdhgufndF1BlCuPmMNIJv/dWInARRnS3dufA2y8lN5b7FBAKnRyVHuZ2uJA4fjeI7OVlbd6crdlfgPcXHWXaIsy+kGYSnlk65/b4TdsdLCzcxmxWBu6Ruoq3sgmqXu20fAfDrWiEIK05zFDMbXVG831VXcjF4M6e37wn510k8TqIW3+9psVJt5zdVO0f1N+AOVjOh2/Mp4+KZOEkAe+e638A100S7i1lFFnj8w4GutcgTwUclmkZcTGhEHJc4qizF3Pqk24k0xgAIvwjUz6J8OEhOoyTk5ylHqEKlhFfHFVagB4Nskv6OHMRjzCvpY9V57qVuyt0NQ70vIBSnpq7TEV8RyikBti99ZYyuwyVagR60M9h3sXevsItNSfEgYLERcE2Z+ZbaOD9LZIisWftr7V822+7V5eaaOv9muc2OjuVdOOH/KqD+43ffE0eaX88mX0hGWv9AfwjpISTDhvORiLN0OPs7oDWLRdqBAzzF4Lkck4uySfQBsD5J5UhtvzcD/l+8Ft9gpFvOhI/HXyHzrATIaW2TdzLGvC/lGBkFUt0Iy9a0OlXXjyjLHi5jaU0pDYmr2iK6B9icupfsgn/rmjZxC/t+K12f7E7X0y9SIPCe/gPzU492deG89rrWFB2++tKFkiC50MmsiIyMYVVY416q4Pgk3JP+idcoXiceqGmgWTtJtKqtaPE05SV28bUqZM+19RfNcAbb+WDa3WTFmLEIjFT5KJXVD4Wcce2COIG5+anEyh0oaV7SYzw2ahMA8ymOBAKfNToBVPw/CBBZvAPqBUytmnaD2yEFb48u0CqpCgvRpvhBJtJybSnIUPlZHWMhXB/SWahLek/1qAsXlwtCDhr+KRXfOlhCXl6tgLC2miFEnQp/T8vDXrYQbML1bOIVWFPrK3RsRw8r+P2BXEovq1dGlGSag45Eo6iqupAkUiykhfSMlA7i5WikLvk8NIlyqUiTDeE8YV3FgeEkrSaYF1pAQ9ZoLA5vbEKZsB/+sqqIsGPvR6zTC0qlJCQYBOnipDmnCoEqDLA5sLRJYaSPoWxjwZDSNfgbuQRetezqNgiuVAe2X+2j2bIHFWmYxHQyU4qv8YlqIm9T/nfMaS4PkfYoupNfRyka7uSjKObTWhotDaf2mjZ0AoWi6tG71/ztxvXiELtTU4KwzTu9gJxqZWRzeOVK6nkdLk0XIJYdXJU01DPJcdANbKRobkm1kkB0S1E84nDRZkIPQjto2Y1m0YTqURAFujEsg501p+q8+Ni3qS+/l552URH8IS7cHLlos75jE1DS7Ed6zcz5G0J6dAtKzAtdakbDZn1KaF1GYR4uYKeHynAgvt8uy5c/N/ql7AMBRjgHpf5v9I08LkukOEuRXGA7tH5ROOp4JzTb05rxwIgIm+ZUy5CKiuG4OZBKF2xxo3FLJ85zBevq5ONluyVfAoS2UILesKvlftNiLxPnoy6n5qqIKByDv2yLLvBIWRxhLEnPajfLBlzEBoIsWRpkSR9RxPbTU+HJtLCs/O4TeX/M4s4XnYj0e07rd5BuTvyUmZrnhR3G8qQpjRXKorU4q+tdvQ9sK1/UnlU1wNWgTXSSZEwbjNKelMMVGMv5rhxp1zjMQUW/fkNx0gjrbce0q2SylcrGyde3rZZwOdprxYiTBkrpg2/EpEfwx17Gt9ojd0mBNRheqxjtGoTA78njtnppvVFmDPRIMwVYCqhvEIFyNc8q0XLrb+qKVspuxBaGMtVAFltfv02UPN+8tdVdaysFy1xpveC5ZoS6lF7mCUjz+rvyLH9Msyw6qDS7Q7FNjRkSGYMtIj9OIXDy6TNxUHP/ARhpc5rFszUStwo00Aa0xMXnFD40i5hR6S4t4CICX/oJeHPUyAiJVdh5cN/ElVtvGbBg4ckCkvQg0hJwRsnshywBCDw6fG2sRAUpoS41+9kItRvejoNJH7spekL5jGWS3u+F17TIpcfuukwwNS9cUgXMiQ3y3XmGs4cC3xhJaylsdMXyXQgY7hKgC2G0pfLIe1OlgC2uItSs0CpEifYjAnze8D6iJrlT9vg83XIji9FBun1XqEPuKPKPOTnopvDIjEWA5f5pnLw06+Lcx/7MCXmlWMfDEVawBJbbm/Gf/vaI1BDSMm534a0+DA/PCwEOvfBcj7QYWWR66NEqSP6neJAvQxL4ZfDPGY0vsZhJ/xC+tZlAs8N6Wea/8DdErPK/41rXBia+XzGyOBWAexZSfbAehoOTo1VhIOxPckvDefj8ML9BfZ/d4duFUA4+iQikBAWaNnhtv5zehjJbNuTBxv7+ITK0c9UYxx8Zcta5n6Q4dUIBBjUCW4lRoNX5aFZaRCXRSUHVzDE9jAVkdBEfxy9R2j4LoQIeDi6jowMNYgDHDu1MSItMfE1ajLWOW+Dlkhk0ZFiVSBEuGP4ybczgJ4MFqzQZZ+hBwDJusE/qre6smCBuAPYllA5Nf1EcVb2hOQfordPDJt3dvKKo6IwuC28/lbMUXmre1QeSB32zo4PAoCzynsaqbpCU3BV7IDnU0Ml91cLp0zKk7FPqi/8y57IE0MOU/ZtOHSoCPSrDeMIvYMwYnG+rziVobiShXGFGTZc/uwA2WZN9sx/o/cS4KIcFAJc9mXqRIfnmXn9R1BVQU5D3WSXdV22YaKQ+JuswwXLNFP6PEbkKRVWQlnn/gZ0DxnWZWngk1E7xS9ax1T3KJzMCPOHZJGt5wkSx59mx4Ax8t8fCBOya74A3cWVT4jB7ZJylx94H3R85/3Fklx7gicdIc1oiPlLh84AayicVto87H7WoaHy5x/sAVY0AXu9KinRRjimdmNQmVTdFxr/Kuq1fYl2ZTqExEotvHyG2jZYFur0Rkdi51LoWwe0h3oar2WmgH22VbXstTvHjZbJGcLNLnYkNdmqawk8ipkzkie42jHe6tdHY9QxWbHkHTK+zBBKu+osVjidZbRaPc6S6T5+OCxqdC6G7LFZjuEniR9VdjGNij2Ji0R4YeC0K24Lnxro9dQEvq6WNG2zwpVmq8gooqQKIRoqBdq1BgMLWQiNZMkXRdKP7f88vH0/bIffW8MvcXSdwX5yqORPcgvg776RcG/JOEyA6xzh434WDyyhbpcuQuSIeP3bkircrlWMWxV8dSKOmJzyV6r6KasJGt3MQ1n31XpteXMvGNn5kiLxiU0S+b5KETeAbz1JdngqLeCJTAEi9OH+xrFSj9WmsvzJUqk4XFnkZdTLyLuVhQVW3Uu7IWsdxVXCVeMIWjxJagUmBZUlxF8sJeZjXuaOl9DQxMagHrwnYU7S52KCrX21OWnyfyllFJyotvyYdJ/OfDWuLhA3dUlh+s2OYzWH/hyghM0wEn+93Cgy79zeY1p1puHif8zlVX9eiJH6bXXL+OEoyuB+PD7CTvTk95ddd8lsMO9KgvNqj6DrRsKr6NxYrzT77sTF9sUFeU7Hn/lPQvDph46yDxz5WtonOzlBsbrnpssmyfUSIs9JXkv1Wk2p5r4GX6xI7eeW2U4bNWValMOI/Rzsypt4kVPlLi8oEbwPYKLFlzFtFqJVrSRx+KzNE+OIEDWvA4ge9enWg1iW9BufMuNjQqdvbiP44BXAGmBaXOtfReEsE1T87uZyIlx3eaUI9PilDuD5A8GxRBtCWODxwAoiAPmutW+vPx1z+48kYrae2zCB+gZEyndfGyQY2qg4OSH0P0VcG+xObQbJavDMoIDRmRSTNGYGaMJt7iQ3lOJxMptU692G8uMUQQikfYgBPFfmT5lN3Lpvtrmuo3fw/l5SpfHTw5rzwTx1zX4Jzr+gTBQrFB5lejtPosTV27QtZ2uB0RBPoSftew2EUtrGcGHbuAFu19IfIjj+CwwYna6RGkEpivLxymIKC7+C/9N2TrX6r3v952ZSBMpX1r3bL1/NZfpRojToluHVvvF4UfuUXI1QmztRn3Ng+mBoAA6VLNyHRyDk9eFkBPLHk40lzdSF7p2ndmRrxFdqASzpW7IdBhNQKeWtoMWoEsWfk4R+i1L346jViW7CXkRgOCfJ0g1NO8gJcn4ziFoERQkUeIGOndzwYEOaMcutGFYB1z+Xa6e8i/T3wrDji2sjCGVEHjJYvBRlKXlhqqHUnwKoKkEu+XvQp7fVNuOgumXVt0JBJqlJ6FUdAzauIZ1sIu8d4viKT4E9lDBPmi4eMKWY/3k+iDpwwwHlrkDmLVPiTH8AL9XyGZ9PSsjPBSncbgZBPOjVMODwuQwzM5wpesIewvJz3VmqaCKpzmEAhILitegkUv2Tlr9jf5scN9JzCqOMUp2elzYw4Zf4MfoMDojM2HE9CCFaLgoRK+BEdUqkPFUZE8wTyOYgoODfz5BkRL5X+cvQxGo1Bgyz4zM5CaY9nyNBkCOyykmLOUkHIMpRRcPmtKrYF87whE6eibhMK7K+EQAxiHrsLU++v1yJNgxdH+ldVbISoGCzEGckczYryV3UdXC314SsChQjm1mJ3uLtjRho18U5caOjFLzdNjeAPgB6rlGjj0ok6V9777ghYrEJGPfMeupecHGhn/Q7Lq/hIh/SK+k8cfAtHu9Vv4tCATv2Ye9P9NXzLwEm1yTy8xogCXoL/i+HBT6stvNcwhpl9FPyBPpvFLHx83i/IFvveAubQkXJH/rRgdzgLs6ER0WqUH3m/1ai3MFqx5UpEjpQRQa8lSsy0oFrZ27KMof4c0KdeKsOfjeDaq1e3i0ehTHXu1B30zxh9x+Q3NECE3trq4cHVXI1p1z3yxKzjX6x0RPJzAK5WcFs/FCq2q1vtnNIS7696aUnGQvbBgrxAcvaCbr9x6AFCk+kD5g2hM1MwCovk/hwyurlo298rdvDkU5hLQBWaTpKqwxmGblMErQ7vNQ2kZ9utrp3JDQWNJE+j7WhBLmca5TQF7gJvzrdccOPougwhHIlSIm1Hk7rgRDIFId/obu8WZh/kl89vmSv5ADKuPVetUKHMgYylzXSVlUOgK4yIUo07uaDMbOHiQN324514Wr+S3dzPaML0xLZmLxO1Z37phcuiLv+HvllIRRYv9t3F5bDwkhX36H3Q8ojxxr7MVPf+8GHZHJKQ/N0FjCZtfGubRsznmdVl+WmX2hG/p7/CJpeteyiwbfF18Q4qQvbLgnt/nfYOJC1p9WVEOvWM5oqxejiOJtPJPm0WzehZvyt2cqCTLu1U1XDf3lZyYm3opIZV/nIaDGAbH3xqhPw2+odSJqQnCSqTSxtvVKgys32sjFCb09XMV2RDGy1y96fP6nKq0tNAjanLY38zWi9SPyexBwZT4ntu1iu79uMJTHhXuZMtPUJ+kkS4zTlwzd/OkzIKNcASPdqz0g6hNEwtbZ0vcqFnyXqVnG2a0jT204c97troluAmB1XgwNEd9d50Iaqmc734iLlGC+1sunnRb6Npja3EjOQe88lCIdJXPl4SilIrbjJPWz/Gb2rC85jfkykTKV7yYZwxR5IZtvDxovAd5jYm0o5Xw4pJpn8b7zqYtT+jVacOBxvcPhNDXtA5sLaTm5keZemUy5DCu6BlE8N5w/3Bx/fq0lESF/a77AcTSEtVJ4DSV7b6sEdtPnoeqh/P1zfXjXwMzIqFRYe+kQ0MNp9dkAPoMfq/6yOR2jQ5XFXocrCyWZMDCEALqBlOkOYBjRxv3muBEcYGzdGMsB2Yx9vanUXANywcE0JzNNqM1FGobutI2XrJNhFQkF5OlNUqbuimhD3L7TIzplsmik2MswY5dYhar5W8fIe4/pG7mqbvF9mBO4S5bIFVHBhEYLTFhgSZFHNESUKEcNLMjjfF8B0jB/cYCVY6SpCJskMYipkfPWd+lO/JXN5Mqn6E1xwHdgaTPxH1xyD/OQUaIhbCPczcAkX0exb+cYhm2/alWN4g6IRTMqHDfjahFiaSmUIVueYCtUgY+khdcF0WqL+ldEbemBwhgxZ+eSF7emb5FshalGWqascAldRroALe3z5vweTmjLeAbFPBoJvTPCW+reYUClZnlEUSaavIntIBd+IE5Qylffg4pEsCjHXJMW1yGAxhaA96jiUjiyPtggKx7hyjp4RSQig5e+eox6/fSap7c2K7YS3o6ekPuSzrANMRb1wo/rYpv9XQi7/E3zIp6NbiM8DSTyoQplfYGImYf7nBi+DNR3fVGuWwotuoXgHDt7yh65TKrcwxCuDOalXigyYrCR3e+CjwUgSwBrLnltvtiV92Xbhpl8CPprO+gX/R82UtQGm9X/gZpPkDK4alUF1pPyrDPHbi+mvYMImRJUrU5icu/ocCywQU95/HUpEvtxQb4jt18gVpl+5JszVPXPGDonpr7G9IdbjhFw34x1icbs2T/htw/0boZJJA//a1YIUBP8GHDflr/cw7nFQ+PKcUhz51h3a5ar8mQT8N9APiesbJnGBF7TbOYftYIB3tNIay7VyTGEm6rwIoDBSROo9NOK9rgd6p8i9o94GtGQGuZ54cDgHnOqW9Pvek8IEuKCB40jKBdgbdszQkSdmUKDGQKgjVuwQeLu0IrmSKA9bvpz8u90aKxMR12MmGx37cICk3jx2QgmP361/Bz2GIFvlJ6L74DqKZI8qx3f98ImRJbP2nPS1Hwv8WxgOUH9cBXHWTrblKSskOoSz1snzAtWYgdZ6Xq8aFBmF1/giuijP1mJEhCmm5SYk58uOdaJdJkM52N3KADSadu5d+eG859WR+eYaBqLNQ9iorNosO/ZexTmsTq6j8MqsfdjRGOBWtjuRfouzjsB7mGzYZKWzt+dAqlNfAsUG5O0QqhKi84tkxVHEtIl/kEfoiQ20DlMmGrSK9xXYqxywtReXyuoVY1JWOxZXVm6HEKJFMQd7Er/snwyDmwH3OlEZpRAvvkfBNpLAz2BsEG446oTjELSGI14LgKPpacMponrkipmEUkhH8lUjaP5gWL/Ob3ihEVjX1OAAyI1TEvAb36A3+wcN3qqfcrX+1fVY6P5Pj+IKqnEpA8iWZ86gjHhQNppV6x6vSsAMfHXSsOBYHOe/B5CJ4nS7jhItc14R8hgRTbS4Tbi/XZ7Yl31UScYv6JrF1ZwZIK4vxkBPdSSMq+G75eAX6769FhslJeImw54CJCReOwkFWhrWeMYLVhG8ZWvRaokL5wKYsP5M5Vl53RESSDOHS65GoZD3BrIKmsycorBJzjDuE5w0WzV/uCBOQVwCRmukIsjWMqIB1YZNLHLUfQr3OskQ2UZ8l8JqHVLLM0ia5pFNRl8DYJv5tQg4YhJ9xnw7alwrG1M1pTnxgtvUrMCwm2nzQT8ewnIYeb1KOavp3yANdG2Y4J3EqhGgfF/UmweFJ1vmz5CotvarEoVXGwN362gRGO5deXwve2+Fh2Do2edZnZHynG+baWnNsidt/gS7YQi1EXeFYCkwejC4JzefsX6dhxDreRQnWXgNQdeC6ytBMU33kwAFWIcNpxrlXvm+PHyxWguH3fsGutq+wKbg4E6+5NOJZuOeZw22XhAeuzOMp+B+IOLlKf9AQyGKcgeSgcrEUyM2oPN6AVmmf8nguQbgyiq2EtD4HRiAn9BJmjZWayRngxynKsUo/Cdbkgp4jym81CnQiHwHQ57XUsUa71qdEOObyV2cpLOpbbM8QFTwe1b1n2shdvmESO5O3liS+I6L2f7dD0rn63o518PZt8qIaUtwwvGivVzGhFQMcMMT5k0hTEMUwQSUqp5Qz3je0QICW05E9apSarLr+bGvNULDJXLflXIukGu+LRXh5JCRVIdLAc6wtf2ubdyUDZABn26zwbfh/azd7G/l0382AZYZQ+Qcs0TlwUOGUmctguM+2pLdymgCJwW3V7dwVRDu3DjJA5tt1Sb+Nsipvb6mGbi3i4GWZ9vo3Ph1xgdzkWAt4ndUt2ZZ6B8bA0UooGumpoPrmwt7YPNr6hwkM+nlwFYZbutXmIzROs+drITE5D4HT01hoPewPh94xFOJRbXGcfB4lyd5qzXMjEy4QLFA0uQ+1X39Ese1rGLRcWo/Jnn4gnHSxhNMxlpTaDxGK+47DDJ4xZU4GU6GQASXbN7qnzKHJw/6SzgDh8y6TQUmjC8meEMHxhRbS5AQ0HZxMJDNcoOdfT3HofV+aiROTLPm0B1WsTiM5E6mK+WFy+EjBDYGnS/NPBXRP/y/oG2wk4ooCknYTD3g5E6RrvGMhryR9I6x9nXFhVK4BUW1zLgWU3F4h6nmv+tRFEgrWM/9dMpe6pxBlkX84Kk9rTHQoz3AYNleLLEGCy/Zxa8CK5hSkOXFuTYAdH7hAh+os6ynDUuNImV5DUtCJNDQeOis3upRU7l0YzuCDGkpG1g0pCJhCZkFIhzoTH2erv6bPKmaLArbm9LB3usbeiiqnJBzUsSXBbnhuCuvhG3BIF7cp1to089Op2YAtfQdXZFc+yjiNy4jzadHIT8qLyeBkV8R2uAF2haC/cbURK9A+pIQ8FGTgYdEXvXRELhgRFpH7LOQhX1e4ozJwPAYJIqrV0uDZyCrQQzGx6ZoBxidMc6KcPgvl2Cyx/xs976rayfNjbduQt6MqrXiRbgyfsF01aE6Tzz245evjcRy4dLgzf78fTHa0g4qXFoZyC6j1wtycyPWzt0TnVgyMaGO5ZR7FbZ0DIS5rXJUaDys3RTZd2bozBfpLNwl/ychDtt10cY8BBg6fHc4txD14ET2BVVlHArMjE+iGYFxNxmgHCIMCdBTIfFtvehKQ59zORUNcCqYgFAMaz6HW2m3AxdOhXMTfox0WaOP4dhG8RO3uElMSgV5jApQ0CUiR1xtnHIUGvlQq8C3uZdps4yEwS1pB666NW75RgMnKD+PiLiXLRco0jEW0UYNVcBTr4eoR/lM8q3pbmpFXOB21Rg3RcoQiS94IV4XPyFjKyKIU7unqpQtMaG1TlxfWqqArdZRAyLHZCq9fNlgotD8MY5gygM/zyIvS5yaGuLzcm/sNVOIai1LoE5lXrpoMePG1W3Nq4krFMzKj4OZiBoIZQ31C/KWQPE0ZgRbpVmx4cm1qpOyShperuOW4q/AXkhEO2zKCLBX8W4XCZHHkAduOxUmf7gAduVGfLvqD3JwOwWcj4a+lcsCm0I7NOqbLhc65aEpV+kF5SWXtJoegGCZsMV6TpFkceuVtA3EYP8WrYYn1BQIeckQdzGIZMyElQDUr89v94m3D9NjKLzPDCKm5LXpX1nYaKOn1Gi6APglAZvGUxcKBav8TavFA2k/y8YDUerZVtAClSbaf+rGjFQb3qdDCnVqhsB2gDLi437d82tCAd1wJtVOIBwBHSO2l4CiZh8wjVX0ffOhEIb+9EDiYjKQQsgXkMeorO8Wdh3jTvI2dH9Sb3JOHIHIjUsz3k5wTofIczDqSaw4UUABaIPiV95Alzg6fzYD2pAuFTudGylkdeJyGxKqZzpBg02XbhHars9g7p0M4j+7TW6souCzfdbKaYtarj7qMwFiK6AXazqGR0k/LeeCXwUhVEIwFFSrfJAnWCu2uCeLs8KGH+wo0E4+d6xcOL+D3jow05IKgjaKhPCIde+ow8buHgYGjq0Cg4hJwfaek5oPBXkNwDSww5XrJ8LKD+stsvE8MlGts0jXhJZK3+RV995XgPDeehGxkswXKdn/+HPyhk4rbHl4Vw3rXT5EDRnHw4dPqkfPV5AURNnXudyPsktrlofEC/Ek7M7aliYEzuYzTQb2WMHuFnAl2CKsHrvvgVAobIxEqJoFwcYZuDTJjJWaJ/asMmsnx6RiTF/HcIwKsppdQIOMgnmOXYlNSi2oQ55hwfiIQ9DwRzKDUnqGVkwxx7QK11eQoTaSxO67kVvvyYzcCl61A2MLh+S1dnhsJIm1SSkOfAtWOJcNS9fBb3szy0XJsd6j488JDykUF0G6YM40D9Gdyr52FiNyD6MxNJMpB0BR57DKMR6urLub/R6Rn7yJ39Krz2+YfYrHl0EFJVO41UIKGYBBw/068PRBd/l6Ysg6WQQMbNEoCppBIH/byk37GZbL6jnAkgS+ow3RzbnfEes8yQRhy4SHDsWD7AqUucLi76QGg0xVTzit5khDlJ6QwD/AHdikqLt4gy1qhdAJ0xgu1BNxo7cMus6IomEc/LbMNTaVnRKeiTmRSHux97qB/sIPrrWXWHnEhCiXNhRcXneBYb0bdNBDJvoRLjQIfWwGb9szTbE8T/iPdlN3wuNzNyIHUy9ORIZywFRA3VGVbYovFdBppG6rw5hzZqcH8NQcRNUgPKYj3RUzlYjdUBLlBHkB6rvovbHaQmV1mxsBHgA81AJbU/guTKmSJ61sgNV1GEN4EbLNIUOh3iKcq7cYKsNxZMCIfx6WhCdbxMUabR5LzoRVCwXEHaWmRDlS30yAZtvNKGLqxqToT072htAtHYEj5V225NGgm5P4D7aynFG2Hjfphcw2XTZmOY3JumVuszKcGpDiYxVw5HTAf0c8U4xuDZ0hpdFLDNqSaeN+994buSsCtEpwQlxPDTbdbDO4P1H04Ngyn5VfzdFf26rG1u+PqWvI3832EW/Z2CNBq+aUi7V9L5w1Gv2oRubS8+nRsUqXAXTxwqpVPby3rYOR2mbmnJm19cSuG8skJfqOp/SRx4OdNwKHHBFdbXhhVDDoas1UHdt8IYUFxQDXRzQHE6chCq3irZqZIoRymo/weZfibCBChwAWWEo8jPexVo+KCySTPsXnAbB+/5pGHsZboBU4nNxaAUU/uuA3CiF8lBFbr2lr0idx/WwmUO5HNLNhNv75TGgy1S4oOrseGXiY1sDCOdD9JEmGVHbru0U5yKpN7MhWwzVugLEkimnLlrsdcEvdcsWIMMpTIH3krhYKjxhWE7NJmKwBT52Dta/0AqbVOXJdPsk0QUi6/UzayKf+gf1QpyYZgqURhFpLIOZukfS4/BdPwJor93KI31CIRc4DErmu3+xuDX/jK2LXbVOg87F00wLoZLi1zoSTEUXEsYCmtK8G85ED8lqMcScXy1eahUre0pxD6j5GOWjzIecNiC1A+fyr0P4slJVi+U/VQrkt/ylRQx2j6hdrXpkc1afB2UxlVIhRKqivPKTmNvVsT64855Vs7e1c86fwmBr+4FhCL66QkbkOKxLUGzyeWBHv2jpRNccwTejWgVYn2Xkth6h9AB6PS2MztwWP3uPiaOyU6aHnZsnSmPV9bN17zeOn5R5XYTvxdohgSiiLrgnj8wCgC1uefbFisGAKL+BP9yXR9cJhsdmOvyXFaYtN2BeMKsE+gq1pGp2xRm/uG+0sJJ0YZNCE5qMP4c/wOAsm+z6SHr6H5auDp3Ea1l7jK9728G3FTKXFaw/sEg2/izOD+nJTA0zi+NUwcRTYRBwRdGOTSTIsqlmPh/arL8Pas80RyaZOmARYN+YcgglRgE51R7TVWAbmWRdyv3y2aCPahMpfFo/zjKTlyCrWzY2eYGMZ1BCLCdgWph1ATdUg4HnRT+9mUoB+7UClHUf0iOGunJMUWoKUkrStIXTslN0BYtyrZFf/iaInA3XcMk9XN+7fxFUODb9U+Kjj+A+Ia/buGY+mfdVdtHSN4pgnxOI4ahkwhttjYmvOjyX3aWnkVKP62hOBkM3Xp/finJAXEzTncqHVlOVsH4sN167hnzeV4wEn3PRlLdRyFwHC/TSkU5WY9bwdNpvPVwe3IakI0OgW8d/Zo2iKF7nYDIIVz8zeTTp3Xa1GH38U7I+9XiNoJAVeJRV6B7GfbW104SUuNCbh7ULqjCfVvy8I3zQwpdWxKt1TuF7cjOExSYoU7hnIVNBjtEPrwftdGCcLAOtnan0E6DE9V5nbVB3vKcsiIf/6aezymjQjbyXQX48Im5olxoPdKOYHq4kS4/F33ZIch+UtAorOHvUHocegRUc+YdN7LChB9CuoGmkDQoEtgGd4CqVXt8WyMlMHIrac0hymVRqhG7KZy3pzojOUYahJrOSEegNfNI6KVS7PoHtEFRU0lHRiEzREMIJwnMO4aLwxO+sik7bFB62FlxWOGqPZnFdY68j5TBJprWYPkXUon1iIKjXKGTzns0lFWAIw/IfdCwBnCayMsiCENv51+K6tSCsRT7eDY4fMNR6vz1z3xl4YMDwG+sfuemn02DARdMAAtu9ygcX3CzBbXb2Dq3yMdcPl54og2v7KhC9HOWALg1RuoqCZx7U3huhNsQcUFK1kpe08qyQl3xckrPdOXWZRF2AgeTHRARHfbDKXDkFDBCC0yQgstQ3PRfqHav+5dkly8omDf23esFnBPsHeE5AGpzjeuPBbcv34cTmoYEjjAvFwJiI84DHR3kbuj6Tn+N8Lqm/j1HUBJ2ZLwEuDChIuGBSUVLnniisbcHyZJbwKGUf6ggc/jjtL92+l9j9QO2e4aQjlaw4xOPlR1VZpr4BdL/rjtD6B0uPI+gYg7eoYV+2lFmDlnV/vnVj6N1BhD5zuwtO8hfV1Y/WpTlvqqLkrv9HuWiuPwtQBhAntUzIy4VOKLRYlOwIfyy/wNLAlT4Wyyc5YaICPd9IDicHcW/7n1Hs3R+gYTRAG7yD4GIa52T47lXn/4TfMsG56QTXvonn7OpqZ3biL8HNam+JuXfsxZ017etZP7CxB6W1S/ZM7NgPT6GX7j3F2Q6dlzAp1AStiqjCd07AYvGKAhBS+3WblDKhap2wxt0yJMzFwP+8KqdKBXUWLkb/l2iyEd7Vkz7C66o7iUsoqgLIiEd9DVTzdDmqwS/IzAgunX6X7kgE4Zipclwtbd0RnFD2e/RL5SRvUsZMyQP6ua1/+CRNxC8HVbwZ24FNK4k16yBA4HubfXceJtm2BqwmXNQsLlndlBIPmsi8ErX3sfWmM30yK/LKcrmE7Hsk7pikHPq0PP41fsGJ1I0+5sS4ghYJyZ3Qq70MNmCX9lv/bhhqIMLnRe9+kEjv7Iw4T3MFiRkmaPa7vuvXFlvkZoSWJ6ln0642Ilckvwe5I8i6Z3hfV0ULFQeY8V18Rb+/UGN+6h1BBEvcVaYNrT/pLbEgs+sTuU8lAbF+82DNHgpO5ATd2OSeow2uvlyR3cio03uTsZRAli9IUuvyxWNjDxqIInZ8PpQTQjzxlaD5LodWLHUf2BOdwAm5nUqLlVyyC0d3/AObtGuF0M4BFGNccFaSOhbYy03tsE8/W7Pzo4a7wRkoYf/FaEos7MRB6ulDuikss1rtwQBj8HuM5u8VEffH3GSrE4gfh+8tyIJaxzYXwUoxBJTpYfB4Jzqjd2FsEoveiQ5U/WLHo0LPDlX4KMMpH+NK3eddKzYE7DX7AmXKdbGDQH37CXQjEuG1vy+lgGCEmnRcjKaLrzBE3dxPXXD8b9gOtUdM50FLaxcwGRgeDM77gLSCfuCHyt+e1/aWhkkpNEnmURLDGFIZWTMT+/FS/vaNGx+UrsWKab4+1tg50IYF85GLIDurt0GPcysPjF40fIdSdEBkvDOzwvbSx+7PsuGwt3awWNdeJj8p9inVwTZxLuofeJIKPTtE49ic3Q//Ylp4jeUe034OC46Q9Rd56sQ75EPbHEFzDDy1NmFw4Bm9R8C2Kr9JerZ+KBob/taRID7hS4D/MUC1inMY4YayG6EHt7yNtFMGjXv3MyH7P+pqaRWbvTn6mx6viIw5pATb/ZpDVqbaPc4neXyiGjdab/1aRa4a+p+wzoYIbLm3NADATwVJETRVJEH4K9G4n49P9yMTyIrF7YfY0FVCD3Fg4YfFdRaqYMCvtnVMJrhbY6/VCvi/5erir1vByJuFpjo7I0r1DdNW6vhpYo56VieDZOayRkmuAe8PlX8B5E2Q6hQLViOiPkrbR0fTZv+UzKU0Hl1lSzaWipVu7syL5H3HARWRGggx+OYT/iNLeQcXONsJoewSfzEW6W0PL3KYJpf25QKfusWhbqOBwLuG6ADNT21qw9pd3RNqlmV3ciegBrWS7kylkGbalIkiU3gq0S2cLL47taUJhlAfbc3zBTH3Qa9BoQnyApsbL6+QxSQUsibY+jHJEH4vA10/cAIyl6bjuxzl1UT/NKFOwjVxi7dKrueVOEE7zvCj6cY9oyWxssehtGxx7EtsvzAuf7nWw6qpfxBMHLNZshr0gIw8y6HoahmILgsc7wPcdWZ7Z7FQHwRl3upz7PRfyWW+/eoweaF/EkMLGb/kVjPxmHdM0kHmg9hK5aEvYeZ5QM2UDgzFch830WQpKqgBZO37lJRq5nVuHMvOZr0dwy4UuJtUYCHnYVvxzTRK9a2aoFAJ5Lkj2+HtSTEKBldf4xZ+bPrCLPyatt87APEOivjenFsG1SFonPN7uGqMPTWM+mgwvcO50KXg6lwi4elFUiV58Ql2Hk80QJ32DpGLRb486kMCC5UlBOejocms3otp6twY3RlC15zEGI8Lzf7DdiBqR9LB/OOUzkD+ExLD8ifJgIp3SiTIFTAYYEnhBy1L0GtPduM66v9hbR7iWo7zTzHEugJRQ+NXR37XoOSweigrZrQsD+6Kzj5P6eS3yTK8XXpF/JeB3zhI40KQJYgZVgiKr8tKeRjFaiECKYZo2qOCt1bKYZjdw+5cNyCJvSbFZZz6qVKvakZtmiL6PTfHXylgKXTQf75klAoCc+SO3y881Tk7eTH3Tec69fj6euxgbsOu+V5f8aOTjyiB909/4Et28vDJR4+xOPjpU/4PEfcSWA75HDnIygeCPdDyCnv+xkRp6fa4eYD3jDgg5W+2Li0S+L/YJT03+v0+urpbNufjvbIEpX8n7uo6HpuYzB0rUK5MJRe8yvjYGve23cK9cHMK0YfaUYqHfcDzUJ6BKepshzVD8OWy2o/K2J/33YsXnftp2qjFTLsD3RW0bZ0S7FvFic7tJ1O5uPVLslSfAOS8AxogMbsWHmtDSCn67E9BeNTtid8+IxAZ2/dK1NWHUkPxPY76urfGUbUSIC5P9v6MS1d72wn0dJr+npuw34PB9IlEsjHNvaDAm/uIFIz+SWYRlP0/Be104aJlCcKhYz3oInrZkXO7CFu8m0pHt+JCMUYSGaq0S67FIziVKS3PeQqzCXartpp+6VZDmywXXPMm0LiTbDrQT4s1pWLo4IUYTeTAAZPatg+CxmFz6hsT8WKQuGr91MKvucj9Ttzq0xO96Q6S9Gnl+RgxGrFyeqK51fYCjp6OWprUUXgFGHpOzmhAWlZnuu4xZcc+On2BTqCCmuYC/3Rtpy5vHAcN/WF1g6hxjUDVlGrX7wzfhmLpH1TXP1IxOC4QFalUBjGcDB+uKjwZTpo05wCFG46ooBXrQ5gs/08PshHitnsBYYus9I2VZcMk3iNNSed+MwHaSu/QVAXUuIMpk7JNXpAKjX9A7ek1kWDA6VOam3SXH1NBc5Dqnhdsx2qGBBtCR5PGYHaFxkbIduzcqhSCHePjRhHR35KnUwi6uzLlDEwQ5M59pLRAZVPBM2CpW1Aq9UvPOVP5+Z0j7gjhpN7wjDrPCMV+ok7HktlVi5LAID66yhMzdBwVhOqstwnH1H8T2toFMmq2MoFfA41miCGMR4P8z6XqPWyGs1pPWB7M0TF4IwgxfLH6qu7Ix7g0LVUh3lNhvPVJkr3+CaHsQ2ubGh5z3ITSWUTZBLvKblyFUVJLso9YB74/iAtqw5k4Y2eqgGnuIXL7EQ3y2Muo/ZNDpTcJUrvhmYtctXzBixw/REG992muElNqJulCd3O/VSfVw/nqCqI0UOjyrKoTSFa7Bgh1bZtnPkEW2tF77Fho38qL+VVlm/9cuRq5/p17MLJe/pC84rty2gv5T1VH0v1XjhnQnUzYRWIy2y32Jyo7xIZMu8aEHqaAUGKTsaCRHMuq5GG2Y+z0WL6BjUlUboJjAfz5S0TcNG9mo/7ACc9SLjquhsGEGBsgBBoITPlvo9hyqjN9DbNc7JV0NuQOTv200GS25nD5OqwwyAgzDMzTh5Zs02CnbvPn8x655vmp5tY5CXIo7cIoM25RBtGu5vMiojxUZNUbxwsyR4H7bmuG7tqhoV8IIzo2XrMbQbFnheGiUa0Quxv5cVHxNV/yQD9/9aTeplvtsf6rBfh+MudQmgVlsBIaGKhupXHWhrdrGJU3LjkXqyl7KKbz0+j6hUXLimqzhFbeWX4MnOLOMaW2xwISj335YnRFrMhRL7Xstq/hRF7hNABmhTexIETxyz8xSUOU97fQ34aayx8WyeMY19eMNQbhcVdtISoF7oFwSVad1tQK0lLyRYGm7knZpbyXLFNUajZ3ulBHJY+3W8kre9UZkY660zl8udB3+4RFOAdtBhEmK6KgCJZV/Igt9/pxpvcIlZ+hfIAqkoBrCE5r5pWt4nEqhoCA+qLHgp2GrfdWaTWqZQlEUq2IbBABld7IBg/VbZcqbleYg5nFWHzRrZ3eQYxMtWn6PHLwUQE3XzW5pvGrKdV2rl8tRF68q68UKNuBEn6R2JSL3SFQn8QbWrCOP22VOAHnK5E3WFlpkrmw9fTwNY9TcXKzRQ7/bVSfqB1BDRPiFil79WeDv4Mn8pts1eHN42rcJ8xbLidNMtnBL9WeGbuBtt1XmBFL27On7UDKtN85XxnyYiZlY74fZPzVNkKq3UajFsFdcxidGDqNCVFR4cMhs/IVVqlmctp3iYGi0JAdZYSFPWehyiEV6eynJNBfXUjTN9rJBhlMj+XGXVlk21PVp0jGdkUxcedXXX4XHBjZsQA+47vHFEmU0TF4HyfR7lhwVIZNQTrK3jbDwuJeevjxGPOiY+KApOah29Ok0yaOzXcILWH8lgh6AbvTskoHLZ947va0XO//ImwiICiQObaQOwxtSKuSphF7pyplvhPGKzur2eU4VZBSr8yxIPf3iqtUivwkWrxj9cIr6T9rRnREUpBrJCnRy8nsJXhJ++uVpPHLxgSjPWRvUB8Cs4y4jqeomOAWst97Z/txHlPGOkJR0pku/MAJyBuGFkjV9MLCiD2zHGKr6cQNrCIFUTTSEFDtbyQUV9/rqkILID3Wyg6zXrcVfRWXUiw7QnBihlccU/kxC4FvjHHiRITvNSDdjdLxkmkAyrMepQAG0CYJhVxyKpWakE+EcGNbRppSgQd75mp4JGHQggZmAub7SvK0FB+BussPTQNEIzctE5S0vmi0vyoVzMECQNHCPn8yilvvK8qeP5+sEtea/dqU7nQTxfZ4QXPMsk0/gmp57rAv+rmQX3OcJudls1vnYyXj2OGgV7co+ecV435dC5v+BWUKjhw4OjW2TYXaeIY2AiGf7DKTeEBo3rj6sHgwsmaMn+LqhtyaapL7qx4PW2+ykD085E7GODaiebvc6vdJEbXLvB6CKfsvE+tTj/moEE5Z5plXUwHka2m6k/38HD9FNFJfK1dnycR1e2CyV/NEHkc8fZ1j1lE5L9Q5evl9+htOAdIsaRtQQxrV+AymhYdcsFoSvGgqcN9O7Azdbpz4vmz7Guze1GI7VpzPTvj+21vyYO1O+fuUnmxZ9iKCIut/DwgWhJtV+f+85yBgwjypzk7P89KHPwK5pGdzn0JH67Ye3oHwa00AOJhTzbx0O+fDtQOEqXCDAWX9Fj4FbWiANwo/7ZoDZ2uh27PaXzZCJSNT6vp5H8GdO8UNQWA4/Dvc1TZ8wZS7BI1bRQu9MCUDW/wx0WlpBugAMBeWwZlbW9+uo1ZgnlkapD5CBxYsjYh+lQFX6JuhWDhq2TH4pk6ujCCdnx5Qq7SObcaC7BpcS8ZLt4UF2YUZvJvY+F+wXmP0Kvb1Y93ot6zPzAuD3TiqFIzjiG2HSZ4GzKCRT0wtJVbLE9RUS+D6R37J30e1Gzf5cedfJT5f1jRn9MuyJ8H0PVq9jc5YtTPqu4c0Otb/LsPvf18+kpChJ3sbHMYtSs8/gzBv6s8o//n2VpYZw3MZNRSX4VlH0Ea+7Bgm9Oo6AhHmUqes1bEqpYjhwZKe0y11z7tXeVjcFn/P6XC12HU1Xt2ZK8ui+7dh++VtPrTCvsYIltLr91vN76WD/w3B8ctN1va/Y34A0ubeBaRslXlsc+gCilKdjKZ2hcMOdA0mOijCmaXmeiMls20vDoIdTqTVpR9HwarwZqYEy3s3B0GiUujWg1oGdKZ8l02igdKX8cxD3wjLr4qDdEQBQGTc5YeliQYUJmiPsWG4pf7LerHzLGHYpD9HUruNrX3CoCHn4zJnEpehVP0rBp/pFkzVm430295/sa6p942aiTZVKU9Llj+jHhvualXDJk9ryo78KjQl6BMiCloKW2Xs7exPLtO8CThg8VWMTbG4CF3uW4V2vl+17euv4VD6671tQ/jOaO3IbffPpWQJNzy+5+rf7WKwijF2ZzXCtGua+3cuNuPacI6784sCRn6qPyMvHAJSph1owxnFXD6NBOLEYp5uGEF82CMqiwoGexk4a4mg/7ZNN187KVStFKGsuq13RfnlVT/g/t9pSXMvokcLcHb25aUcWjtCbuQYK3nwwd6n0d75O6Ow1abWffpaIYRFUGtC9qkep51tZXaLFN3TUrxNcI/c5QigkRopz9QukpZwdGChHJjqx0PSAyV2AOSSgW1xcT38AIas2Dx4hMsEQ+oE/eB7d8TlJofUU8eWjWgg2kVj1fT7Dbii1ZkuFjnEbVEj40NvuVHDeNWMT7nzb5n8p6w50Fmx8YY0T2AHAg9jnviwz+tKRKDth8iIQIaIKoVUAyRfKs+jgPJPu8wHtiaUdp9OY9UtIqvDlZMv6+nJP2jw3cJH6Gj2fct6kK8WpJW1mNTHkY2tjXeBL0ZaTl/ZxI6R7klH4rHDNWIZPY9H0cczLZbP/qfSkwiqnNTthKLsRVgbohB/Kh0SuJ4/DhOjPBRn8dpqqT4QkqGyDe01f5WGSMBAADYhMfb1Bv/P1HGaLbndoMIFDpQPI9+q92EXvFPm0z6MeN/rROKKuDmKY7eYeJr353HyOBaV4DIJY0rKJ2OOg6OP0OFjB4iOsU/16h9hYNEnF4yqDUHReGo6HsQGENjszw/oX0u8aLNMSRArB370LoihFHBXOwVRYDniRB8Yna/UPn6xQuF3Pujed8vMmi9DryC5i1tXY2ZaSac47PkatQ8Khsv6QNxMDcbKrov9EcxPU6HvdyJx5M4nN1d3ElxObyn0tPVBzp7u2x3+xCSCe0mytbeHrkbuZMGF6sOxqlM07iCvXWZqYFi7eHI7O3EI/PACc3yDyTfxDWMMaZi8vwoNDLIBpJBPGDrMRFXBlq5LWPEU4U0ctr4b8UoE8E76KpbuvT4bq/8fikd2k96MlolU/SofHleBuWXF79TnB0V3SZorUuPMPQMRBb7NBNvvZnmaluesFX8czelVDs90FJdDdqHZN0BnU+TmANG5aI6DKqEqvI95u+GicfJ8bS7RIRVrOUmKa3RAQWcg+JmxLZL7CuhHnKNbCCcJR35R5HZcyXpxaIAXW5HI2TusPFu0hM3wbh5eifDeRHCQVxz8zMZO0UX0V0a/uF1PRAspRkJXvEsVHskv+lI/KvchXG7tB5EoigKuJiGwahEDJcwuyyVqxJW6Y1JyEot3umVimgAzKQ1W2bS42qHqIMqkncgIsAI0mYXWLaQ+EsIt3tzYKdQa72m3GICbHuIZmI6ERSXZ2PiMijWKOgB1Pia2FhFp/0YVcSMF/q4xBu5xtbsO7ZX2F28du0gFvRTjUzXPT4fxBbplr5sFalEuxUXtbca1zNyg+iwev4WpYlF24z0JI1mOWnEwD5r5UpRf41zl3WnOCrSnrY7VYpxQ+INPt58Eb2b49+GB0KHqQeH2rt/+ngjZPVwnXtw+LaHJZeKMujZZvSawb8p6WmJasuRWshGvHTNG/er6XIUv7ZgbK3KFrnIy67wKsKUXs5KBdqTHpOErQF6J5tuQsv8FtY5dSUX7Lm/nK9zFlx/5S2xm3uIJEV7jvqagbengrFOPZSOv/VJ+KDjEB4ykTwrIMctELd/Uig3iqc8/ThWBQk+nbzCVHTzchAoHogRl/cPwg/sdonntBzQT9iYPV6itLlSRniNOfT8NC/djwxv6YGi+UQNng+qKjb8BUtQYGyhfM/owi1R277NlycFQwmPCMJUWk5xLywyLw9byN4EystfVWhcdzaJPXWsvafbHAklT+R5FaDDRGQ8f5EtKwQHygVGAUqyL0l8C6HoEF1mxWayEdwk8ZIyiaS7AH5ts3vy2g4e3IV4mXCRhP4LIvy5kAia0Dc/kvTjt1VsMhHImQ1CWmGzG3muq2iUUADWPb5fTQntnQMjCKsfmK9PUWIF/t0ibRlY2EVRz1n+8K/3c0uetGiW5HCAbe9vkLGGVM1r0T4BCnuLq5Ncfe+8t1ZPfnvfwuOorNkz5LbU2rZ20CNn3MnDDD5XTtVU6WWoIedyJxNIbW4cbArQ8KySCHW++M1JV2CwXamvlb72JesUTklPP5txQyvB13cF1FHQ0ouuP3+jiLdwaz6ItQjL2tCg5IYsQANtu0ZAAEMF4w6x/75MsPhpBBREwehszbFx87m9x4z87Mo468cSRp7COP1WeL7vFIYw8pJHvOt+gdsA0xT4+/UKvg0BCO+ErItkffO2TP7cWnwhuB+a+3UWRAvAMW0DRjCuOyu8GFF50nj7JnLP9hcKCfAxgNDHDjyDGhAAlYxOO/wg9Ezk470e/lfu8iHPtoCzse3fzcYdqCngwwebIc6EVM+44pvToDDouzKKun+AOgmxdqBrmazoO023gvmLJ3CK7PkapS7ZZoUVH8X5TrecjEGuHIWNkyDrzayybke/3yownexDOM3ncescKunkbNVRtHzKxddpBQVF9QZ46WM/h+lf8+f51LSBkPK/oEywpZsl5pZnzglaZfKE7Ir3BR8qsUjfBg6ljI27yyvWpeEJn340igU52QUd6ZFQkgy94GBMQEdDsOOpfU47GEvhww2y76h8zN1IgbKKl7AdgujEf3wKr+OT5a2dCeEeOquuHpBwHy0P9Kb2dpBmxNHusEKYf+IELnul63TilHVWfd2OOB6ryD6teCD6QErDqsKsP8i0OzmCUulhBrbRCikzEbxQPaMKfuH9BB47nQNFWkz9aObeW+5rJSXVKf4KifcBvooqspV9M9l7CL5eTayQVNhGd7A9W95RRxA3TKwtI2i38he2HSVLFWOf4IE5FI/BACtZwYaacV7k3IQqKCeop1GzsV8WsoJye17TASNj7lRx6WJGsfPVBj64W5D7T2BCKf7mlP9gZauLJMiLOJhG0RSAuFh19EOAn6F6h+T0f7bRXgGmgaz9vw8rQ0R4YkuaBZUiI7EEg8zF2K4iq8mHADBwoB0bZ5lZ8SEBN61sls/mIO7hUTdQpUhrCUuMDTUGntcKrNLQsSkupqYOz6ARacKW6VorjSuau40iADmGiUpdye3jB6BIk1xJ+x4EKS9qrb5qtedfOGxukmyEuoooZoJW3C1aLhpS3i0m4QwK7JAwrQghcigtGyf7AnjNKMguE2wYz9IgV+cjZ+82QlG9egcrCFbk8UHRYNobpcH/ZPLiXi9H0YoqEKw1wFkhKlht9HcdwkSM4lgpdL8Y8wFJv3FYwVBWDrOEL6ySwd11q+6JTUGqlZT5PdYELUSbVUa3QAG/C2mF1D+Txf3FjhNAeFft5uUFlwL6dxCOoVQqdttKErU0HFj4XnBSeXrdMnWgyl1QcOh1HNIIcXK5996gsj1fGB24gJTPQqnu1gcpGbN9Aw3h1upSiMcmRHEPJDexaet7SprUFmmzsDx+fWBvqHok4AeWAOuE6Euw+v1CTevevf76kPkpgEl6sPDAYZ/lqiSzqnsKbFGjqTDB/Qvt7tKf013TitpYT3CKDvjefr8BkWXu0sbQan155Aru0HoUL2ydTUbwDY5Yt9NsKkdNnFkBwh3Of2MfiDVRKYSWCZIfDzDifKC20yBqb+8WScIVAmhM5ZIjOIk8Ar5ocSEGu3ZmrbnfRSa1YNfp3UgtGJxMyrnO9rHbGMOhBnjCCjJdAfihZMyhYnLYSaLX+0LEgSwBba+dTViYouLAnxGMaBWcDa7s61/iZoKd6tvhgIqXQQO395aso+H5n2G9+Fv4DlvsFIHxYo/Y7eKXiSLh1F8/X6gIiKH4ebKtEX909hZKLXfaILKV/nMao9p9F/99FFXkaGYTOxGCSrUomYweMKsIniC9aH1T+hqI8lPOrilLNdF9x7BqPtb+gNHflU3fKN7N/qRIoY1qbHLObm16c5WQk4NW4QBu4sBG2qGXC6gKggaRs/ac+wEQ9EtEux9gXRRWMByuUd/+4587mpOuTpg/dhMtj6MVHXG2LAJezM1zcGabtXvYtJQWbygJO+VDaKtc2/mi7Pa3a8tffqyIG8HxJMn59pidC5wSfWzE0vLRsMtZwir6T+mzDWMjkjXz1l8lHWIff17B4MEdextjOXnRlhIZHKx8Q3nUboHyQk4NeywDh0QLn1ASwisd0BDmjxKyoGyD2aPpWzJQJuikqxfo9qwUNbOnUgb2Tyh/dN+fnzIT/aQbb+ItnMFCVJ0Gb5l8Wx7z09nwd8YnxRUi2YLbknGsHmNTCX4BqzU0V1lduPyo1wsMF8xgz7gqRyfXRVDL9uoMbin5kmUGWIjwF8yxncIhz+Crax2qIt9khNRCXhYFfOJFSOUU0Elrltea0uxG/eMCvr2iGoJYEXm8r2mwikOXcQEfaFGNQCqQy/veifCffChUH17PT0xfPH1ycj3BNawah0YCoU46txwkbexxOC5cbbQ/+ZrjMqYFZFKq65za3o1SIPWQRD5KsLARGXTxEJtlQWBVUl/2LBMkgmc9v83iX/l2mgH4h+vpcrGG2KwmpCm2uIjlpslvF0HgorxlRbWxJbZTFvLV1vRiLNczUgokozeMeY9IAD+V1f7RLWXJnxM3vfxcKVMjEmfaZxEsZGESIiEFe/+r+CG3GN47SwS7CTpc3zvJ7qfXimjEI5A+v9DC5uaNnWcDcokmpXG3KGbi0d1AGWepRd9GDC2sEixLOqjJ9Y9b44gNU5liGoN78g0QayA8SmuIB5SIoSCt+LZLJ9IQTId6RjkhO0dRndxIM4L9unrraLpmR5CCvf0V6YbDlr7KPs35sdHQwohNkFgo4g8m7sSj3kZzzYicmRgtxWH8uety104aGsprH2DkXfeRD/L+GDWAr9qWyhhCue0Xddju9GNgIdDZGMYtLHkWZkVcM2UzDYWEZ4W9Q6p84iJ6N5hchLekqgSMLHF1Q9cmaLjraI5N0c/emjA8kyfRnrCpgMN7kU1HxZQY5bmgVmCqMYzc+wmAVu3rSeqf94wdsKTro7Ez2FPOMEawkGncl01aaEMK5LchiXibDPTRVkur457IlAh2DRLw0aTa6RPrci0LyuhKQR65HmGF4FGMqQnkxclWoR7gs+pM8sVrMDTJ+mXQ5dF1OQVDWMz0a6b7oKAHm8Z9Ed70+q8pL3stDp9dsgUFdN25woja1oHpur4F2R5Wa+8jUKHPXG2TyFDeXRB7H862u+zA65o/R8U1wGqhTUttQB6LWhkgg/erBD/dh+ZMbOIJ7aAmEWpRNct7ltm/aC9xdPkZ0AjhgUUS4AUcmqkUkdRWtjFsnRcjYfaWyX5F+tPGcvaYE7WENmd4pegQJvVe9p5lxPeVb/xExTEXp7OgTpMu3icgEkyQcCOZOY3mz+q7BQ6c4MGIO8HJpqf6B1rj/vJVTfTXhDaZiM6ui4/8FJ0zpPoQXteNtSzpIUnUmJw6mWt7yEFvicLa8UJSCPvRhfacQCfz1IBQoj7K8mPqzXKkuZxd6pIEflwM8U7I/s6jDH+fWKtq469RFicx1ucjcVds9SNXesYTIvokCLFsm/5eEt4+XvzCvx6D/1+39a1G+LghBkLe5HygToUpbAhh30y4+2VrbxWWUI5abyXFJxVFVS0UKei0nMWq/R7vTaXC0qKP+gc57GM43QN2HKAoCOtEVGu7PWUFGtWGdlCc/9CIE0HGKNivnWIRAy4cTWniODPlpVszyf14oXswZzttJUqX6onLmCxRwSg5qIcPgQXXrjg27IGYVFc0Ma1/kjWnIT089x1ePxE8mz+x7xQB083TELaNWSqm3PxwWnQb0Gf2/I1EZiOTmoZ78s4uvQg4VoUxGJF29at0Xoui7xHOipRY5rrzWbKjc1Kz2ImEYyxdw8pmN8Fp731H9zyrvLdkbcqkMu0Jjw8sKa+UG/ZqxY+1mSgiXjzm6ahqBnJK2Wu4oawGgFHluxYvsPVqTUmud1imBOmqk++YWaw0BAjpCdh/sPCBUQAH7KwL7rlX3b3gXPMcPfQUGGVsjTzUCqOIxs7M2tAoRmQKylyiEmaDBZCCsq16XFJo+imwhkYhKuSJHE34h8kFcJPxiHJUzLRF24nKKUhu68CK7jS/iz/QLwQyO7gDoPPHKKjlusXOtXBDt9mvgjZ3ToWVfrjsAeQctTUFW287Yd4MyMSy1TxX5DOdy+faFp5rWFVe2yhXsH+CiR0XHExZn1dIcjuJeuaGpmEsqdeyyKUz2yU5XL9OLkQHDzbRhUZBgk9CyJfHet96ZrrjIrmisEWaKN99Hj5uFAMVPLn7zCpZsTcOUkTv1Niz6ePP9BOWJ1WsgB1JH3FAbeGtxkzFvjRjNdUHyo0sSZ3+FhIIFJ/h2u9xLNUPU2np50pCT3erAOWeJRrxQiTI7nIheR344YXMqdMDEq5Zz5DNsmTPbyZ68WhwZGq2k4V6imT2YPRZeZwoH/zFqgMNXktop4eeKkPHrPo+iYhCnPwggONLyO2PnRx8c/jNz4HbMNVw6CkTuWD3zV3eJpX1A/ABwWQxnX4pHdObtKyL1O8UoqibGeL6pTt9frnr8tHZ5U/RAC1pnScUhAdxhpFJkS/0uUf7kUdxUkfmYmH2kpYVqlja1CW1oiClkQ3ry0xb7i+ln2qNF2lE8LTHrDhUKg455E5+qkT1c12FeUOigk7VPD35zdLWOjyY1ldGO8NHo8fC3AnsIUDhntGpTE2uaaj6vd5tLNVs/6vh9L1q+/ia4/t6N7C8/m8Hi8MTavbuiON3uGYK/X6apN+OLnPznSK+RWZpwkXc5+W1cr+rN6NV0hEmZd/50TbcVLKKSXFI4ajVUektAYwsHbldQv46bVbjma3ivLjqAk7X7TKCiTEg6hY+otmVVqoBcTsg9vFw055dUZt14T8NG1mSphGCcpF9L1JSyWYbwCUW3vJF+ZmBl+NPXpBDJZQOwOTOb+3DeW/Rv7rBsJflYtx1o8h/VtqUMW85lN74tUmn+5ia+/jqr24/nzbN4k1uMC+pmlshheeZVl3GbRTaV1tWP1xRko1qCQIrVgqvu2RNd6spDWpRtGQvUyyMB8+kq5U0cFIDw1tttBXjtXJj7zevtQ95qTqnEZNaXbo4OTqDpXilZaRDNqABQO0eccUJFnU9aruO1AZGYF6ZReYJyXs+vrbWHDZgkZnHVgb3uMiS/TmClOKBC4PEN4Hqcmr3q0Qf/3mnv5tQAfDFzHcvGyNWW6mq2SZWphLSueuGfQ0EeIxlTUE1qrl3QqMuEzd7CvbcQnM3qHN9L+SSk2ptdcw87gtW5G4dpQvJinLCVtPryCRhf6LtRgm8kVplhSjUfMa0Y2OJAUyVjxdZ+n1YeJtPGGVpMmIJiv+lPgdGQt6b+JAvJJMXo5PmnLwmMTPI0FM72oedFBj8Y/ASu9wwSWjbaUoEhgUpr8Gd5YaHkhsy+KqYEGE47LFwv/hjwtcOzg0RaK16DGMTGLXsNCA2SYfu5ffHvlDWh4yy9AxTtUy5t7wXhpKR9EoZWcBbU0Q0XXj1N9/rowtbEa7A5vOCNAGCy3dHcITzYVK1D8AmzWlFupneZuKs5WtKg8TqnvJuyET8t7pafA5ZMBP7mjmEuUnA0Q9PdmC7HDgi7sVsLSRriMIUByZvcsBTL+WgsyJa7oUu/udRzZ6bxZIb0Y8BDsX2wyHD/sWxJA6rNoTzL/qU/NsLEFSkaEGLpxjiny4VQVGrw3vMClNf/4padiGBHM7xmrj3k8IqCmLfPG+hRg8JBl1pna+jYoDbyzJlNwKZg556Pyo5sNexM66PZAlX/PG2yBV/Ep8KIggiB9CBFKGg8MElqzZYIxnYG9YqGHGRnp4Y67gVkXSrJMRGByYC5fm/wTRtk/LtQCO5Tfa/TQZl9bK0CKCbXlHN/lxSxNFAzt0oOkFunrFacozGl86jM2o1NSrdxE59ZSRDlm39+tzZNIOJZBgOxjUEzeAhkuJCH13AIC/BeytUffvB7Iu9BkkeIGS5OqXfzB0iZsNWwRYcCceEXLaVtYNgvQzNkuyCkjs3nNFZ7OO1UGbliNXnZ6weXaO2CuBobbVKjXkbnl5AjYiT2fW/Ay2Q2i/MojgS9/TJZv4TkAcuqyHvzePn5kKTimzhi97LqJdExse/5eq/EN3wmEtD8x9F2rXvD9xcvKaE7YtFid14kTEzzmdJK2gQO2vKiEih6iQOy0ySwDiuVjF2Xk7kTnVVnYrgST1t7RNm4jbvxbsqFzMsKm9uFJ6HZanRf+PmSfEMW69oqlcrU4YVlsbsyO+PWgaAW9E8YhDESbzOrPqaLJ2L8GP4jOn6zomo6cv48sbsPYkqI4nuUAIwkv1V97XDXyZsH91V5zJU+tsRqGH4GuEXQcOYSjbl+8zXo+CrYebHrb0It5XyGpLNsbSwFN2YdsE6zyxUzmelDOtW9qy4h9XHm06d3wrBtPdkEc3easbozY7MPQlnW8vqkpC7WL+eZ47Q6IWamTV1azvsOk0Q3zH3Ns5TYDVfw2w5kOURkXHndvkej+cITX85b86p8V6OPyQ/TKVVvTdpMM0A4fwaN2XbDpQQFwzoDlVe76lYar48UFZ+tY8ne6aKwwBAalKX6TBYVmCAT0VhtALNVegndelhlOf156o/5jNZ2XxWC4Hq+ie1WLu/Caz77C49bFlTZfJI07+n00ci8lR/V5G3zD7l4U4icUscRWjn5FG3elzI9Zk9ggILqspUW8LE5rS5updb9Y177zpn+r7S/LWoHiVOqAVSYuzHtQtlnrd1UPc2H5Lu71H9YGzr6E5HmJeX2RlOUXBqbdlHgrHeWRtNaIXfm0dr/nbMREbUvGYlsV1Fz84tKbAlVzEdp36USZ+PenI5RyZm1nKQ7u7kRl/yhRFro2oHEdzd33QPWkDlrXJ+2CMOJ+26cZOHWvfXfCjnUKgkx+fy9cV7YEbJ77FduLyMh1tSyE5+W4Y0d+nF26XJo+bYbhXkoEOgyRdzSL6r26KlJXWuygjIMWrMQ3AMBAAIIINRtOjUUIftI+oRgh4R0bW6A5/2gZiRSF9yyP4OWXhD1Pfo8CEAOBnAir0LiBMpSV7VAjyW6jlQBFhoybOIpt81Mz5ATXpYwgmpkUzUo3ihKQ8hP9ht4mTpwPFwB8LVO7O8N+sPAdBJcf6IqMkWbDczBDHjtnYoX+V7r0m/pPCHShxHvYH7OcVrU7gFe4tKqB5mMJ38faO1mR8S7oHPYa4Fk4SLQtbR79c98dvNbauTSlIWQ19Gfg7Lw2ZKyTz7a94N/b24wVL4sJP/p62vyB5QjtZqFJZx18JIKMsO5RBu9pQ9DDKfp7cuTYeY3VQ+LJB6cP7r8vkRyVbt9qwgu7CWP4/iwCnWg4lwrO4UaRq8wK2y+3GOr4M9G2f0fGsoT+WePQ9Z1hYic5Vje3qujildPerPtdoVsFa5rtQ81wfuVgUMW0bUC7yoAt5EpI3OmA76ehsN+Ljxa+ITKK/Mg+cGmC2A5fW6C5O9bEZeKBPFdhZ0WaaVRPR6yVobxk1ce2VzMiom7dhmnzYIL+slmeQt6y5m5oaZMq946WYy2Dw74I+8KpSA6cmrwG+qrlyrVlMzTp9sum6YjkcymLZ3z9MxM3hznZI0G2W0DzubPjYkQVIjQOEmiG29jASArORa55d1ZRh/qMaAipO6CXAg8pxPKt7x8pYhhLLuNzwXB+7yu7ebTCM36a5f6wAaaUtnhHPHk+Rak0N826+TVcMRbxoKlaNu5vEaE7OGYInH7QL8ZNDIg6xYbnHXvege0/ndrxdGs7ayH2/Ul2ImZMLN9YfX+OSvJgLRyfhTE/3sZYGUWXdjsY0DA9HXSP7jCpMqZugbLX5dB4nimoRAkCAMF/cpMIHfBQG+6yxs2ZXNEjofK5JwHqHFdUTttYUGe+9cQzsZq0kMU23YB6nXu9pDehbXUm1bCE6Vjb/dGl9YX28qqMhBCL2IWMjroyEyBU2m4SchWJm1Jg+tmobwrdFfXEhrBXbuAUzv3nfMy4gpi1IKB+Z4ydMgaihc6Q2oN6VTNAlGBv9h0VXg/9H33Z4QwUxVsTrCx3dkxj3ESjQxICWNNI/XKgLWtfNMyaV3EagaKOtnNcmtYVwu/Sl4kQjrS0AUOJ32/x91H34rb685Wdc13gzkYQ7U3khWXu8AGKuAaGtlPAO//91D4fq6h6y10kN//UzMaj9pu/z1cksWP3F5gYooAl/wYl4ahzwpH91q3eyoxVYtNRlqHsIjDrWUSI4rnXXNXeniUpnGLN+Pb5YzlSn8RsaZLMzMJIEE++oDpSR4suYIUREA/Qm0P/b7QNZs7vy2RdH+TaKXR2VAlJlJzFyYUXwXlVkhGHGLqjXuNu4FZYfmK/OxXOKhncqcUeQ3Omeqh7CxZjiRKZipsHG6Y4fL2keEsKxpywvpdbKjQG4PlOV67O89sOsatX+5IRfhS/lq3dr9uZowGSNVBB8doR8ZJEkt4CO00fkYgZcq5xaDrziKawC32HxrrqnAc93s03hCTHUdvviThNK3EsLw7quI/9ts7tNwODYRN6rv2QO7Ht46htBSMqFDIUJx3/eBcfB77gLs4Z0yOXpO9xY7H7b/pL6gFXCzrGu0PW3dowb+RbH7zFg+Ar+bhq9EzoR7gvLHbgq7tlKnLl8fF1DK3/YWni99akM7AQJuREUWYrJHO6UngSFE58Ue375W4gwsMM59vrgDDFYdEt1yr3pUAkJIRx8X5LAqovad8CgWtTT1/YrL9d6NPm5XckAKj5VFWFYamXPrXfIKFS81xWAN7TSjlUbb+UQIDMftxy4s5SnE/NaJLLOm1ct2Bt1lmJskxAkDKRQJes+2HyLF2JC6NhcjrtBp6qeQ1GNbYT48UpqSq4v7S3ZhGovvGV3UVOo+UXCiMmH1H4nK/xPi98gHPJBqLhrXuG0i6tQaAYabFaiWJl7KvSqXySW15wAOVoiiOw0LKBDlTqe4WJo6wl/L9S7Hz+1lZLE9spNoVxOF2pLMueFT6nMjoCuX9tQPKz7T7wA6c5vFJDCIZsXuzQKrkLKwAabxZOzOE394a7Pjoe5gVLHiqDTe0Swnge6fUpFvKny1b35LPnpSVh244k0jZjRM1VCp/boRIFYct2xkGQoU2rGqF2molXNzn12bTC2Segww2t2dzVuvp9UCkOU8hdNCLcBZf1DUyoVxJAiGSoMpm45AyBtKXua2KuMl4uTXvq+Fg2YNHsy3mggYkhzr4BHXezxyFsYjOkCSzWnBSfwKdgCZZwzCS5og62+rSQLNHnnsnkn6+lof9ZdVS5J1KhrPWMlkJfzrz57wH/7tpxb78fIN0Zke7JTWU65nB9iKfUteOtinoqccb2ndw5BgROrKi/7/cH3I/zbT9LFcFny4+Ws+2/h8FMZkVg+2ZFZG/iqkDtagYMhcc4TNeSMuX+tZQlkOGVNZj02uVQPXSMKWly0OApeR/EJWfH6GMt8/g+wFI+sCOwzHL/Oy+jGlRLZjFw7+xLIQ6vG7CK0lxgOzZ9gCgHz+++WF/YVshvLCqvyo3YIsjY70GCs7plytVC7nIuSs20S2SD8kkBBYWIR7T4K1bLP2Ge65OF/CeI+YDOAmzQU77nffbMZ9FYRnnOPLs/xaMvnZba4ngs/LD/MKq7WPqp0EufE2H3rEBbvZFkSqvYV9QluL4yKgJqd2RidmM1+thSFgHF1mwFKyjc34V8xvwSO56Alhx0psaaG14DrSMTStuiSzKBWVXtZYKRu/jOyXvuN7NWU1z9eto8365RX4PmUvOk5GUjVuGtDRb1H5yoBLxFgZvC2L84C6tHeHAy4DiiqabRQ7ozLIUVzLAr9JxTuOKvcz82aN7b4a+cPNLLfvcl6UxnJZHMG2aRzHv3dQv2jfSinEXbT3VoPuUFgHsFexOn/2sqMDOVJ67ZhjnfbIPmwIt7fp7g1BPMnB27RXThZSNjE+x7uspC1YkpQcqH9fVtiWLDIIvjyBNtDAjI/wUARo2QVkgGVBcdxXEjWslXvCujgihXtr6XW4whDtj3ZCgnEwX3ut0HouEEwBeEqqcUggZBeJm7kbRu3c7NOnSNzMZPJ/qJf9ZADx6heL938wQNT8T6SKnDb2I3AFQpLyCKOczpvFV5Fo0vpSd+HWhoLQtxvFSJl+b5shmDx6tuR+FVGZlDgSkstVHvA1xOLAD+jdiBGeojcHFP5VDSX26PMIJjYUp5+7dokAOh6dM/dHnlDzwKOzoHfQFxFU2kIEr1GQPB9iywJyBMBdMUre0sGNJXf3rgOjhsRcAovlw2SI/JZBaZTtfK5Akd8dUDLaBMk2HcODMlNCQnlWvr5wvI+VK9Mlou4lyZG9peofpcBQAvBNMOR93QWHZzZmfxW4AohunsZoAHyZwYWFtfRrTsUHi7gFq1WZXBfkrJM/+nYjdE7RuqSTprjUi77Bkcr3lZkoclOkFU7p8kdZ8xZx46KkIZ2kXCy9Dxg3hUp6xkcbcgUC3y1nIvs392bf2+Ugoqmx3GbxsaH8yLIHsMOUzcebM8vHSZndITtPJ1kmkyDG4U+GAhhs9inx2j9taAXZ/E65kqZ+MRWBWVy0DIWqfG/Uoouuh2UW+XU5HFX3qARauwW8mFISRNQEwMj1x9bvSym32kRIuMn+LeNM9HZulks9UlvNdamUn8mfGtbUXPlvpglx3RbbU4iw6zJGGMZwuL7By/MsD5nSRauLLgdGHDBUPKtK8cztT7nlo7RuaaRFe0GmuRgq7ln6/331e/1O+OfHw/Xn7YmLUYBMOYqcqFxGBlV5u02UXj7MUaSMg1DzNe7Bm+nKVaDesHHWpJQL0Sk4vgTiO3RDUSO1Qrrbrv1C5HS7E2lknqYwgr2z4aP1yDfXmVqvB3+a1TUKuzos8gscwfm8hKCGCc2i/dTHIVbGMIb3VSmTvLP4we7hAkODAPLRtNLddVh4I7px+vxLq091r51BBPTbS4PgtV3zxCzg4193/LI9oenflClHzvy+SV+S4SQqFaNeadyTDI5W0v8Hnm2tMQArNWT5pcynBiaszRf7n8un/RKt3251a5Lrfb1Up3g4a5+/9v2dMzuy5t/crlxGZjxeS6rFU8EjfgcSpFGlqZq2LI2jZdjAD3OqtE4FNXWcyNqj4A04gxhJ/tWbnLEDo4u13KT11M1ZXCfKVEmDfB0NSiWnu06N4IT7t8COCyWjl19n66Jf7NC667nzBvF6BzQUJVem3cv3a3H6vHowA2u3NPMLvfABnnv6czneTB3JCjNPcC3P2FOhJT7ixf3wRZX0cWyOSHwXhShSl6M0plZQeW4qYZtvJgJ73BbH67DLUVWw2vfPTjgApIJMHfCJEMvJ1vshwT8r0qzf+izPBV0eeua+pUY6WXNsAhrHLBRpdEz9JK21kQQDcD4m90C0b2v25UGMNYK9lYKDmh304CQ0GIMlTTvE9Os9z9UKmUi+NCYLDGX1GPQOLFRmzbrakZQojT0XgpFoaJF74Nbs5SQ36iYqzJbwDE/R1mhKj3j7pvATuvfkbbgy2qFfgtM45lthzpeE6jNl0kV2A7Xc0YauPKDSvR4O8IzEXFfn51UeaDfrcjcs6EI18TCUXFUnHvtYkXbTiwIHXvN03+Tpjp4ZzbhMZqjkav7VGFRWrRR6ocusm1ngShcQ54J8DlnERtZACfTWLSyeyR6DIhrhmvOxKwpHzkJGOf2pHGugzAFvakL7XncEkZB+duNuLBTE9p1r2DlpxjPgUzBOZ2xV7JsYeaaho8oNvoHitUvjzaBNaMhSpd17QilT29A2gBE8JA5j2OhSW1lBF5luP1kLNM7Y2eAQjUP5W4F3XDiNEn8EVe7Wh0X/WkSpeDDM7iFaZpWb0K8OU3bLg4uWkZEyJ80Asqq3zVNBp4L6Ire0QCWQ5cIfyd09NX6NGdDRHRXuXfUCROYv5IOCnfEmfEziLKZRZvswYxY7ZpFjSbDmHOawBCei0mFB06Js7KIzK5/DLFfWkNqThy9ulfkzYcjhRQL9iHRaAfmaWmDfkrPcjNW6U7rWsbagjpWUsShBZdsmCj3dLiCMXCKmfvwADX74EqrfPeJG0nxBa+K9iBK1COsSmufIohKu8Mg5+jrbpHOPH1APgVxMRodBODEvm77kQVKsOJUH1zNVpjeSpNfW4Zhq6PIwbdmMMqkRUjSTZWkUYjuRCbm7jmXVA/afbl7NrU0ksW6xZ6foMHC14q0mL/EJLcnHTJoDuyMkXaygbgT9uCDcGnLHpOhn72QcAOLFMnM/GgvIutqrOLNiCCyOZ27DM9rhE7Cl8q2efLNzPhDg4x3h4wY6QfmjrJsV2IWECtoKws/T3Sv59cXzkb3aJSwfGNDa8Bpi4ckRMLFIZgE5eJJ80kAZk3vol8Wm5U92SJHFbLshgBFkUo0e/xuYvglaSultiWL2sYwWqAtH4fgxfqPalElyhRcyJWgA4OpKlzgHPTndg2mYKQIdTlPRAQcdzGq4kNnICUcw/e6wYURFj+lmdrlQQhnqpn1Ne6b4+xUFwI9rqWWoSUwrrbYVhp08SG5a0yp0JitbbQ6tBleoVTaNZCEBzJhc+jLBYa8bydHv2puTd0x8G0Ds6rpIBEtCVSpb0bcCl3NZEl+qIaWzGx+PmcCVaRa9eLDiAQIqwcDbQJwm1nwwqIVr1JB4r5DRE1NTdhL4lvIWuwlNKeMtpGCC2VhrU9lm4gqqqRHX0CqbQatKVV1B77oIHy+4B6ehNzT8P1f+GBvEA4ctYWHneplNy1JeGhZFyAFpGlKDAlvaXDl95sm1mvtVV0ciDmTK2V0daCXfVCyVVoNZxJxZk8kzXiwwlKiSTxJChErBeBU5lzZzuRiqiXNFz/Q02TOrYmanxL8aAgZ3eP5xBvgdP2+oCq5/bQHrgAEvJDPvPN5d2n01LVrkENwe88g9louzlyPkgewV/6FWafV3euk48ljw0Y0qjctBjT1UUTsueHWC9ZeiuyKwWYbD2vkGzHg1/0TqzP37O5gRNmvQNRx5ExEVxMZCbAgp0HqzPbeIFBAMK3rhjX+UDbtY0DnwGel++dMv18eahboQ/n8yufH7Zbjr9GuujbYTXBv/iGV3+fyI38ZLpLO627g4OUlVOpXkP6orT7IBd1T0jCrvrosAR8gHebYgInXux9GukjeWeluezmAsG+B7Y3855OnDD/kJ8MkfRP/FfhN/PuR+OUjkP6/iFWzAZgBIH7186BRKbk0dLEw8t4aSteEmvlJTc70lf9pQ+KeNAdEqbo6Z7/IJGOmwBjX9+AvNWJ/FlaI8ilGrU+vTZNBuSl5rTEyCPTF1nDSxbroWx47tIgfhWJqAp3+VbVLqPbJtFdvXbpIFwVDUFZZyE6grSxqE3rfH8qewiDRG55qiAT+deg2P50MF5pkvN202hb0rEsTRp1jIXKGQRVKmlIhqaqFNaIISqBdSpl06HxcXO4ANglhGMhJUIjXTA81MFTiCGrAY0KRDRQLMlVnekhetyorhni0sxceeqBorA8kvtoJHlk9uuIJJg1SaPE7r2OJQRiwh0q9YWUjzUcznWIOn4CLFA8Q3WDPZ+xPHuzP2s66m7Z92CpZmm20/5RT68Y/LAh+/0E168/F33NkzfYxFySaPOGheZyPmlOWYAN1Gjc4dCKTy/jSEnlXekCBiF5Sn/Dp4h1uWP2dqlomonHdotbj2rtoG7Wqx9uf57fWYLyeA0Lmkf/bvgz+7kaKFwfiE+1m/rwOTVK7Apt8yt4HPkFtI2W6L8CWr6a/rnr/DfwrQjv9WBwBod4o79WLQmvRhufEqfXYq2Z7uJ6JR4SaXf+pN2JujEAdC3kYBnitpBJsorjGqtAE8kVZTC7KuT/TB1A4aEdsELyQJwa9uMZSngMGU8B9FqNwrmwd3+7DaYfPXmhlltl59L7zhTm3vnnnOJfcsyoU8GXATOcwG1gTfbKkWR8H+S/vDtuv4Rx9EN8SmmBDYJZ5t14istqIctpplKVyn3XS3AyhEouYLq7EItApEgt8+OLwHOJsu3eMspJFI5BN5cUPoL5sraE0Slfhkg4XV3GhUWuIoISvtB6rZbX9/MAK/8LIJQClpOCH1xxde0jd3MopqN9jaSlRoJtqcuHP7rJ2JIo2st/QSTOIUvSoSuiCLxifIdlJOhqkpDNlf+rS9/CKpoTIGk3Y/tgt61nEibRT2WgR/YBBK1bPdwFcvYMcUXKiClUYoiX5LhhbNTGxlYoMtdsXMMSd4GmfwzRNx8Dg27BOQ4ijnScLhr6rPbZAZJOxuzspPGWJtedf4WcdgoIAuC0UZy7DHGVInNb6v6jU+fafAObydrL0yaSPU5tvn96/MgE7kxqnkV7WOL4HSzOcxCJgGtdaNc8i2Am2oyiBC4G7hjj1TaZtA38F3JL/HYCMM3U/4CMpHvSsPKIiOyr6Z2xK1Am7bpGLlAUeUT/g3E/cjnEbuN85xpFbJaDVlm93U48TwwRcUve32goGDMhLk2xh7lLYAsDxJISKpChO8SqAynlQUjUKw8OqXRdzXkgJHeP3QSmWWTnIjH7T5edxatwdDjipyeLNtwlWRbkoT2w5KKPWn6Slo7GSLq9lxetBhP6AdKRC4lf3gJPXiSOwBfucj4NTT2aAgIhWv8o7MJBK2MVy8U7UNHVePd8/IzcwvNMG80A6CZmv3MeNyZHZPyfDct0th/nQ6fgqJ1S4N6fxHou8RZFHuLjWGWFX01foUaaZOljqK1mdoxqG8jf/iPuiS6hRHYcq6I6PzMkhYfsoSS9yVJZDQ2KagOCWSDkva3/RfW7qQcmAQCktOTm3qrgzrifrZc8/n6p/CRq6KYKnbt+Ao5ZJyaKzcTJUnXDI/umDQ52esMHSbDce5yYqTG41QXceSTwe1nXF5TXaMqzPtWBPvpOzWFEwDRCx0+mygLEsHopC5cXcXzfRKYHITKfz84HL+7eudeOv5nQY76FGAhwrnastoP7JqTg8vwTpHbGhhyZHQSje89pivHT3BDp4wmAWKSFEhzer592/2haJdKtiSV7J+WyIfQYR8RgyzEu4ZcsmPvFnjpyvaFg7JpO4j6/twlrLnnN4/ZlBOiIs/+uQYWR/iwC21N0e1Z6Z4xioBmyUKD8UyokZGSPsRLkLkzXhmqVkGIYA09/TBu/EOsGb+FAhlq1++2R6yAbI04gU8QzztPeZtzaBy7tlUsCQ2YFWuPYh7dBehJp/94m3Dzo8MhmYUr/dLtTcYQn1NzNWYMx5mBDKc9livmd/z12Uh4T0lkuJKS8LB1zKDqKF0mHilvsIjCi0TLTCcQK4uSb7wWOlYGipCdGobGvYYSkJ3v94s/6tga2/PPreHw5QZiDy0TSZF1313KiMMCBKn1J1WjqInIqcupwlGOuS4GRhzZ8XWrtj0tLnkDVzLi3NFDdd/9/JanOD6u4bD014e/AkOLgv73oNXKz9RW/QOpyYuJgW8D6xnc8TvY/Rk3E5dtiEJEwyduRynwYoxinRknLWWe/r0BENHY3+feoHmKAz9xRQL8saR9Yzk86OZdljJnit6pH0m/KUPTNbDFg7D9TcmL05BzzrIDd9cNksc5k7yYB5s7qXrett/YTLizm0gN07MepNSuwFsR68RSvas0+xd1PN0sDzmC7n96VNBUXlaid4LyhVfGEp2W9GFmHUfj7AbpzcY6WS4/jXxyfNbO7o3zfu9sSW7vsOAIWze6U3tc3NC8+lXywuiw95zA6in2aI/1LRmPXWTOA3n0Ir2TlqBMGMXLd+IBdNJE4yb8xu0Q7rHcVLdmPU72HBqpWgfLc+IrJya/kUF7zvdEKKLWBVkuB6nvqV7UwbCwd2HYnacbmGviwF4M7ZeuMp+4OeKdBS894BT3EqkrSbCdYqHk39KkW8wgvjcp8Yo1ERdZN3FkQKtXPQ0Q0k+Us2JD3t/Hdjbv6ntO/PQi1Ve7Y7H+3Hpa1uviV7SixgEakvz6k4yInFnumkYtczpeztPl/4iQms7NEPwOEaZ9v9a5Nkmcb8fbId6KIjPz66146hhv7QT9Wb1p1JRBfK3a+XQmQp0EvXkNTdbOYjB06AcG8d22hDwEiXknWrv1eKdAB4nuDiBiS5E7vV0+EGRQnIaeBjNw6KsZ++qeG9ZPfx3irqLHoYoa3IWNpiot6A3VNk012mQdorZbKe153fWPdoVMd+cjYFoq+c7q48qiBi6QQUdQaHzeo5As8Ghk7g4a+CoCA5W7jiJtXgxaLmFyd4CAgEP18xqq0fj/iz3rs30K66ZE8u7yLhobemY6y4vItJHWPS0RjD483DxrLLoov/NMLsP5dYqkLhKJ++iZOxzPMJMlE5Rf5XTm7HunYiFChus2Lt3qWcLnPrc932mF0yuuMKCJjDeM1fmLNBK6uA1uIJEbOkkvuYeLJyREc+0HiGm86vA+XtlOdKKKQodvVdIhUXfMuQGBFQCR+rvjGtNfCYLQ0AWGmQzpu8rzd6DVxQJl7z3HjZiG7Dnn7cO5iAMpVN+uTr/grvGSPYYpnj8PpLzPBHJUPPr1WReTObcsq9+2BnfGleCkmx97vy/l/rMfiflRihj/P/SI17FAA9bMleJl+3z/LEtD5yc8Fj/LmLSra3dYZK5aMtj/duHomsLBcBjb7juS+Lo8KE3yJwQvXT4qhNrM6H8OFxzxM1HwIf8wN5xmU047OUG/9sNhy5SRAzPSbnqC8qfdGiqmLqS0jqYLHHZFRxeHX7dE7fZjMNcEj4xsYYZOu2izfm71kCFAjRQta1NxXqF5fRzYuH/Q6zqRZz0KJqIL0KNbKADkBUZTInqkmCR++py6ZC+EiT3oLsVfDQmwNSPkVcZS5/zm4eh8lARZdx05uyN32mczUTXugiwH4LhuFDeODsIelFSHfdkQ/tetV05OSHUpZ9J1z2gEeyepQ+9WOw3cJbkrM1s0jlU99iB1a+myWrHjBAg0SMliEHz4A7zTmd+HHtZMOZkwT84ER8Wszgvpzww/yvDjKuDSWBC0wVzW0xsegDnavc5Z65e9MkA+XdgyJ8Yc1igUGzzZV5EPupuxPMgXkIwJu42ohx/bNpCOgDTutMqlPeH6xReB2WvOYLNe8NpTKewIfAhzi+p1qAfSUnlH+X6UptsL9w+PnSme+Y45Yuws5wz+dNAa7MJZnx3SfQWLgCfTTbiOlAbtIcRmq6yaAMBDmP3W6OObZfwl0Ty0QrqPnxyanmkqsDGkj3RorhniNrm7J8YUiT6DdtRFxKy00uujpA/taM0Yy3wYCwhOTsG1oQK14bdy0l1+kyhL1omw3AibfzXpmWkwR8AcNseA2oFeUCUDEctgPJctMuuJa3BeJzYESpAmU/SZu5n17g64J/mvSt1UnVCetsgs3Gygj/KjvHH0KNtx0jxJUQVTuhsg8CpL+NwJCEpzK+qebiEpCXmH6PCUobPgNv+DYmjI5F85bAqa+8curfAVBHbuZk2DgLp/VnceXXm+s4oioWRefbf+GJge8JPp/aW/CjD1XaXtFaKXp6zihGhsuFxiN23/DmMPL7lDrJE00pwFGXhKgpyqTHvDaMdKSbXgefzIO8tTydntsLKN8mx01iGiI5+SDk2soDk7Dyz03mV7R2AF7ND2JhV5+L8wl6mCFhf9YyTJGE5JIGKdGQdEr8sdB7Vq+0uhc8hfOtRJ21TUUVCURnfWl6yewB6f/Z55rLzZWtIz3bTw8KbE0uwgsyTCF+HJT1vFmDlvYjf0yj1utl+78an+9dAEzWal7oEa4jyxsO7z0VebsIpHTWxYQRY5C5qzEUfq5qd3CFku1msIBg/vWxDeqTP53DIGVlFJM+l6jFRk33MmrmVzubnjrayzVTYf2IRWDizqOKHDyM2wwaOrktclnZppEha7IXw6mVBq2LeZzyeAFjUnFwjzx1ApyU5lx5QdfejUXs19FL/bgY04TFddd6WJHuXUIVKVppxSvtkDQh+/SGl46MzrgzOU2RnGd4Bpg1miCj+yBNVlqItFunxZRk0j2s9u8FbkTClRI2KE+/4Qbl65YnmPa5lp3Sh4h4hUaKjEP9YdIMGBEFtRVRdNA7+pCoTNQAb7P/dOaI9+64ZqvUHRNafnCOaJ0cMTx7/3hijowem9NDr8zodZKslhcNJSFuO3HlrfQVwpNf2zc9LNCVGC3ozHcQwDMM4vpBLidqZvc4HH7SzRnikQgyVKCKt8Bq9eMr6T6chRatelO52V38Dx53SlmH4ZHT4MXGdCXY2OGnLaicHrs55LdMjoe0XtosNg3wnYRzvHRbge4DCZJTIaiY0T5hO7MVJ2sBM9E3oOZd9f7bGIYzi7XvkNljbkBzMDZ79mTK0atyLKWAoQvatiIhuOTFhVf/iNP8TnMejhzkeR5xtG17G1VW7g7P80nlnNfyUG74b/nxH3dLozCBzCITJrP6bQ14fTVm+sxgUFvSk0Q3RoLFdZM4ZmQoP7qeaGiMP9kXNb0X0iWNVJbGqfn8f/Q9WtfnfQ79kM5S/gUBpJ56wAY1Tggsk1yTrAci97Rsgj6SJqctcD2E2QNOvh55aOmW+GYP5tkcqCTCPzW6NC+RzDm/EQvPCUKQn93p9o92WsFte5BLmGtfDPWB2amGNq+hMZl0J2Wy8tE5g1ed/4A7HZtkVLTpV0V2docvMmGtHYePxbZIqb2AjM4Op6skqPzJnIDzi4z7VXKB+cDlYJmstBOEylVZ3bdP+WvEnNkJpG9iqGnpBPADpieHNyPdxSbarQq8SbehD3CjV97mUSNzR8wDqZKmofApJz1Ca3uKxtkYF0PX3QesVJj5WvnzXEw9QQD7flE6D8+dCZkAvxm0AfaY15CEP6YqF+vdaUTRvwpU0/6FtadN99QZzSa/vLWvHFV3z0w+5BwQiEWLwhwo5r5pRj9I71c4W0s82gogiQh2bayHhHWK9ecCsiSdI5JN1g/hG5Jllar+UkJ0i0ZvJA3WKIQ2YzVfo7jGj7sPYrcJM+ugbidUMknZ1tOifqRK9tV+GoH+/qjc/FxiO54wQ+SPvW2fKermjvVRoF7W1FYxn1HZ4Mu/n71kCHLa5l9yaJz4tTC3WiBkQotOltWnitfUxm89t7jkPifOoG1dreXe9lY/PNElbx//D800TBkBlxMSA4fZNPqbOpApaircfnFPothCyf/C53VIVaPGypN8WQg9D0umaiylVc/XFkWnB4K7zQN5Cxwf/9mS2Zt14rRbtz9H3ea4UGld2gUS2QloqjyHnfJO9PBUaSWDxXctNAj0zxBjUB09UYcR+iGrIVIA1IQkpeFeuD/GjahJu7cGEVpgZAUhNkdrBdOtXBRb7gKiGM0kEanDC6B3IxtsJ2GbqoUaOvecS+lFD5tSw1//XI3E+Uyjnq6jkHNAEaLyYrUJsTqEqyBqoTLOnPuXi8jSPW6jcCj1JuDSo36bdFUd9oNb2Jb8nJ0k/nH3j50Rj+ROAJjfzPsB3XQocqwBenu8UdhN+yEC6V8pVc01HZLin5Q9FMymaz+iTc4J5dvXuzYRRKuUtvm3Y2PqBnuczDMMwfLk9jXjBisNHOS4x57dwTr0/xyEd82eyShD5T4QFrmH1/+3ydCaOD9qScGCk9pBxoeUjTKPpKabZQVlwKNer7St/lVPKc9XJ31AmLHFwH5VPiHxKh15vbw+f0ZB+tgILN5DQrzWpu+AOwfsLrJvZbNAbNhZUC4GJAzpUbd24A4TB32dbCeF9/oUDzEHYFi7YzyW0Pe5ZB0OlIcPZYRPHfXrX6YOah52ZjrRKvCfccPEedBQa1rpDv14yrvAPVrirWmVvXgwYFTV/4XGqw2smnUmqBNMp6zwpbPyrnLCccrPJNEFoUNqA3PhyPbbQ7PvqhYkc35d9dnDtmYLqFGdOM4/icPvu41AV+PCjslKoqYlqEO2Ws/6KqCtOdAhX5qfWA4B4KBVxDEwrkW7Xmgs18uTLg4p9GyNUN6q98/Xo+3u0kAvkJUlYErgO9nrlSgZn8H2UyMIFvbiYfv9nTgvuiAKKEdyn27EnocwSER/ARDpiJDyk+sIrU2ZmFTsrxh17bNWKwWjJsKlXceR699ujA6hz7msNe5n5WlxOApJMhyvtICO5YGo5Qsyqiiq4vG46sZnwELPhw8jJyac7MLtQoTszvRna+wuHzxydcGY8dutfxEIElxLUIh/WO+4S/NxFJ+0r4iWRUZoeSTVEvOcSMMQD31hEQ3jHE3TvIcBIf9yeqIxiFmkflZ6usd3HukHh052CV/GlZD+yDkzgfKupF2Urln+FK9GRkgwlFjpgHbhAWH8SyYJswEXH0rxReuODRe1B9Vflag1sThqC3+NI95JXZ086h1cBcXTFdqsQDv/XmM1RXUK3NuOGUP6OgqDSmrF/YEyMCYr+NW3TE1tW5hib5J7wy0wh/dzb50XRsVx1OPCjtNLSJTp6f10gzLvDAD1tZYYgFhg0uXLCjjckJ/P/G+9mMz9BMJSppuKAIymquFe8MrYhR6o6bC//Yho/90GNhdU1p82OVeM+Wnf7xVW/Cai9861+tuBy1AixkG84CCL97u4/BnVejm45anYPcU3lKXM53eVJXr8O+AOsa7aHkhdT19KNRcRgqo+95Ff/BAzMa+Jb6tdW9VaqEgBPrCGW+Khdv5TXpfxPPQN3CSTH0GXEl2D206T/GHjMCachYMl1mKqyygQrVKZ0kpc1JGVFij4dLMFA5V40oW8MmNuvoyRabRO3D/zBSdZAlraO5NJsBiak247nm7fXcr/vw+FpGeXtEnCqRXbubMdSWXETvzWVYwivggCeRCxodddQkEEs2U7XmlWOJNFBsi2cVZGyuwesEId0BcKdz5//uUIeDvAnDa0eYTh2JLsoZ0XGUBNeTY4EZPPOqoSfyl7dit3IOprF4waSvpfcDcMwDDum5Id1VKNuF3GfrhqPiGYbN1+Z9FtnX4RbZlWSXwe9yWpzMjxgOnwzScHCZAfCw14i0v4ZaF1jYuIkcFeH7+gAPTcSrFcL9voC2st9BkuiBDK/SMlzsgqrE2j9MQvuaRBKrHACZDXYOOlISjETBpU5C/0v29O8O6+66KLYG/Ut4q30bQen/6FBDCcf04AFHGXEwBdjN5u2SRXjPuq2WDqeFkOg4Wr3FAVqvIm2LT8Ql4lGomIiFsxkOu0CmoxpIC/MeKloPdNFAx3Pl47k0AgOTw+/KDI7ZpA89nv6J1eb3oUqGCpKalYvMrWp7yiD+UopgsANCwgJdr14WkNHrJdHPLAoZObIvuzThKRmB42IDLB829+yKAC0Es+zp/osIoGK7z9FebfS/F+LwSfilO5iCgtkDnZ/6Ll7cs0vDWV+VLkcsbG+j9v6GochdZTkkOeAtE3VIzuR7YEiY2qq5GBpAiOeR34fmtd3zFNIO583MRin/+RWprLTLH0Nj42q/TkN6sZ3PHUPFZwM3xgkggcZTo3xJrD4LkH8oDSRJuCBy4TpQzqL+BkwMzOT+qlQslzp0K8aCo8jcDy7kVUsPL0DRcVDb7mYh/jx2Ip/f1niGu5g4cuAsGupab/Qs6V0BBaRfxEBAsexKjTb+zPIwNA6cRtOGRhjyq0d4vNbZJqSIeniYfTUIyvD7nyAyNNaiKK6S53hwPB9imb1Mx/MF7Qc9egOIh3hikIYYUM0z2SvQHoZL6U8SWLmWUKcmd86Osq29yPq36iK0GrRGfiXnfKNrVR1cwdoeFMiadF41AxVHHF5Bs8wNeqtUcpm7VuNd4lb3mqPeFbHtf4qQCBK0WkmMhnTCekmV72fJ14HC6Y+fb2e8Z66DbvcnERB1vKiWGeHk/Ek9RwpjVdl60avOyQjhsDef3qdGuxzThNOA/7JNbX+W+C284WWlizzFJoKqrbc27O5rZBanImsCQunR54IjEgkNnH9qJZ/sa0ptzSEUBVJFrBaGUr/Iua6Tn75cdp3tWz1XiqgVssCkutWHoibLOE75faqowXC674TRY4f2Ne6ztnxN5OyyGgsOe5O/5+bXSWY6eSNIw/oHZFeoTOBJrnMrfrGyYuKlwD9HYZs2al2rSjiPcUrisRfaOZiluHT45uD4bx6aQOEtdCyi3q4kgDA2m51VG5vfglYggjCIzQ9CPF3cUrBF6m9EhjJ4aAdmdziLBZQmIhvwh1nxeEfDY5u8Nc++4C/M8Y2NrHOVpSKnqObG4Pko1D0WxGlS84V5QLoJn7rwoRDuP80jqOOVYYd8anymVHpu5B7POk5H5zm983T572uqzgHLrAexkv8zQuNkoSntyCxJcYwDMOUT/GMF2Yl3pdyoUSwCCpIMbvRCrgmRADPkxcuD5l3vIqjejdgZrzKa+0hSaOew7PXu0jdVYXpTuXcL+LKeeGk0vYotv5fsai0Os6i7Z7BMnyilb/TpgcHie23ReHnahul0rU8NtwB8aalxXyIjFj4iCHl5kzwP9z3TmPS/nkpRmtkLlvBEcvimjoXsUIxgO96jx+4tGK2NTJye7ibebQAg/ZN0p9f1Bzt+o87vJ7klimi8AujZmL+xO3a4TAhPncEJcZYRx8HCQdCkhApuQ+dYfa/nG1fa5ReOjLyX8NdKl6zSaO8zZ8eu6ATnnPn6CdHUmsIhdjK2YWkHUSX58sOjJwXTpZAHUeRdOBos/S2ySCde1DPJDisVYfBvImx1NTxD4+baqJuCtnya5PUyGJeT3vaHuKm0hfjk1kw0bkHtVPkkti1UfAgttoxAn6wa3xKjzRWmKLQhgzzlBunOZ++rYYSIaffe7+B+qTUkl7KJRUiHaz2pklR4B34Umgek5hYe+j+m0Uxsh9cP995JzA6PpqMZTVAhXtCdA4BkLkS0QLl50ztUaW459pcJiuwHPwbj1Hi2aL5Iljy8a8GTPjaXME52QZwL+N8ztO0Y7mcXtDkWPRfUR5wBd7iKl2h92Bp5axOOu9MnC7DRAdFuUGLHwHxiYTe4UM++nrsFYI1H5fdpIUwZN7xsvdC677BQYHPpYruj5+rbfijbMZjiKELqztYmGPm0QJU05ptlmP9z+VzNVByDXepKCTPu/zwuCm0T9dDLcZSU7uyhw7QiBrHCTum1JHmfPrm0yHhIBlIaKZC390I5kpEU116x49fJX33O3kDboXeg9kcChnCZ9YTmuwOKIYhhi74NPgFp0SmoDTdYjnbZCChQfeZw53w3p3tz5L7fMJ7d8qy8tqgCH8/RDujcPDmC3m70wRUxdke2Eeli5GpEegtorpgfW7wchVezykzn8KJ+xiyXnK/+ULeu0ZzX7Of4ubFurmxhh6DRAVDBvXq5lR18F3tLZKnhvaQkv2pc7gt+MPlqaHNzCBt1WGZPf2xSCWyDhsLeAR6i95d8hJUpLDvzYdIf+dBC5HjZQTw8V+QZKEjNNW2p+3Bthxgg7qguY3J9MbniwSIB4pcXprnJItiboe6aKVw4j6BD70VUiJZ1OIyzln0SFSBYNvt09hmIOiL02+7GaNhcx/zpX75jceH/MAflDanX9pCEhPR0Li6EATkc53vp7h55xxF58ugzzmZdENS2kTto11dOCm6pG7XPweDwETftVJ8+851o/UPPzOcmjVdJ4OwBRqzqxmgY7Eq9DjfpDlVHSkkwYbFUZMz3XpruAdxJIY+z2ct4SKi73EyF2AyDMMw7JAbgfCZk8ZpH+w/iHu8jkuXoCuG4za3A82OR60gyaJAhUZ69X4Tyt7T5qzvemjzenTVA1I1H2K1eFP80M4Jo+gjnuFUtvtAiHw7qXLtZxmaZDyJ7JecZSE2mBc17ZVE6cFsbvfo9Z5vfq5PV4rGIQrm0lPAggCiFJzxKxG2nNf1KhViRPW5HQdscdlSVd+uV/9DVs2jizEgR/SlIVzu2yq4K7jnyG1ocvqA0YAb0XUp3JqRzyFz3uPJfHuiUIJQVFqypH4WovvS0jka+rFRYNUZhYZ07ueWKSMvvBPP5E/yi2deXbSi80AdF4UVoImDyL54Os6+7klHJrbZNov7T7wmMy48A3W29BnIRhaIycL2DkE6WtITigVa5sxZGi/ynkTSwqONW2ULGBL9428wzCjCv6jk99p1aN0G1EZcMBwsBHuISWfadOaODRGjZ5UERm1srnxg9e7R9a4PqNrB8LtXVVI6ogej42i3KhXxrZrwb9BLnoMV5kIrkJSnNbyv6D9FVxp/zzD6J4OljOTum5F0K9gZRG0o3kaBEXeqlnSfPOiQK+U1HyJxuXp8QTNsNOuL1U7WQ7JiU4hmHAVWdYKoQofKzpCXjONpfagH5P8FQ2ce6DiiM9vUF/XiQP6DN0k/OxhCqkj9xtXYiaWZ95YNTkUe+RtUWjen/kA2eKsra7dyzQQDx+Dsx6XEAF36UA7lDH4iPmiWhmL1tpkJg705nsE90fs8ZYs6CRebZyn3HTqxW8CcRURJmCcUgaRJU5td8MmXQJdE058ibnD6L2aYM16r73HOPMbIJoJPDOMtivEG2HUlK+edoe2itS+Kh3/TYn0/WxXQ5xTBGSbf1oTKCrLMvFxlWLCR365l6HxCKKvsdltKCNi63XKlJ4ZgMSiyBBsQotv7tTkqjfZRQJBvhTYYiuem31QvXD68GYGBJVEDZf7//G4TNkw22rjf6vRFN/LNzwBsmIPV31OoOgOzb/zK3SoZTfGWqKkUlgQF0e3Q8So1f9rHuYp+4B77p97iDYj/emxgZiX0GRAJw4b0nqHPGft8ikc6ycArMCxJfXuwvxDalLPwDSGmEJA4Mx5sjhlW9c74kq43iYC9LpAooFsdDzHP2RKO5z+GDJODAvVGZ9kl62xVoZ14lWiLME/UY0rCHxImx1PAHGJ2rQGN++nJ5L0MTtYgJVvVt324SMzt0asMEQ4HBHNbrYIQnKGyxKCoorsJPj1qeDZXlWffQjeuqpCnO6JpXf195N8QNGcuBU+jk57iF9WL+t/eDjJD9jN1iwHauPTVM++o+rh+b4w5VypZ8E2X6F6k0QW/MZ7RFu5zfo16fItczHQdmeDNIKfZ1PMPn08XDcMwDMM+04IymB/kjSrd4yBzWV+wx80Rj2fWuiL6bybyreleDOhaGGWOWBzxYnxjzpABkaMgqulzK3ZyzVm4P1Som/nIla+6L9CVL1YlLLRKH6Xv7H4m6ZFsNMhJ0QTTrgJTR+PTeA8KuTCtLfv7qhDa4hKINvYob4b18xJXl2taAixh/GTrZkF+qWZZzY1dPi2Q/QO0i6PbBkMEPcQFUoDEbZmY+Evnf5w9fwJJ2sAaYQW2PBfCufFByL0Zr8CinrvjKTNuCTCrAPWCXXJG1NAnA2woGzNXHz9NntKqthFqcwdp3EWgLbWCEitpPKYVHvzKtnMcaM7rd6xMHYUuG/xMC8oUYT/TqFFFGf6hvJWWuDHKcur63wmJoPiVZZS7MaGicgt6ZGrXDqSI828nnYg3sjdUglIN6CIsxkq+x07n+nMdEgy4Snlb9l7l9+YQ0QW307uVwJtnvOgx0/xbfNjtKKUkCBTaiLBvSNoQheimWR7DkjvclTkpjUWkALv2QR9/H6uKmRB7sFH7w+aW8Wijk0357aN+0JuduGpOJjK6h5dNQiFRGi06Aom4ijI8gWwag8vwcPs7wzxpg6X3LBxQUeuEvsGlcAnfPB6ddKIGYM/0okJs++nUrN8FOQ7A4d5ZVZsrol1HUX62Yze0pFgSuADF3EwyMH674VrvHn1ifpA3Fo8Wed0dBXhhqDUiVUId8D+D57jjeTsbl0vwTnyrw4KRl9PwwNfNY34mttsSHNjh1nx2pr1vf6YR01jcNeRfNk9BpS6Da3nMNx2y20xILXMAdEtI4FS9go7FGg5TD796ts41KPi0PDRRQRoLtaM6qQ9/39XTGBICd2qDFJpWItwg+oKG9E51Dpnbl4GjswzfJvDP2F3SnuyhfKnjZbnzZh9tUX7DFpicZ3Aei+wkmyNAGW8ZtD0V0u6p7Fq+IQkIhleMXC0h3Qq8b8t4hRqHx8+P/k8+pcUtB+MSaqz7GbB8CyjOVK9WVK5yr/z+giOXBiLlgW0/ppH9jYbrqXSPA+fk9YsO3cnpq71q7BStPVGMiBtseNARtxZgCi/O5C8DKg7sBVBYrBXN9YovaQfnn5eWT+BPv0R66/5DMWJ2fvD0wlmzGGZiIWH/2Ll2C1eSysnR9KWywsR1RtKfiZWlSsdFDAE2LPHgi1wgpyQM1Bu0oTQlWBFL/CbBsWJule4sWtNca7WljW9thHsBGblX8ndrrqrvEXAI23e+XTRTiZCsvb3rhAuHcTaeP80udrO+mkA4oNXXNrItOxHPeSwUNAex7TyfAzffe8X9yfT95WEcD/BapKjyiPZ0SBhedNFl+hJ6IoAFYCJdqVQY+V91u0fLFsff8FohO5GYFsQwDMNc+jun2aJ+yuGdGXj1iBaHf11RvDJmMFjMZYFdRQRpFk1zAqDlJNqkZsG2j6jBO4BR056gFV+Xv5kkLxsF7BjPQDca9k4IKhU4248VJU0+Rju/RHWWsaI4FGrlXxbuMf3orpCIPjCc4CVLJldJB7iohPr3kPa8HXdw8ip/GfPtP5b0R5tz/TmfuSYzJnMHfLuOwFvzSphSlkLjaSWnSSZDJURgum/3EJ2Vv7HYwD4ISupFct07FprwdeveSP9oYNd6alW/4tIZ3N7NY2nX0HjTRw1zqh06Wknn9c9IfFRDAmEqZLHPeJK8XrHVBEeAQZEyg9DULA/1uLZ4Vo9Or5vYnrXYcPPKKYd0mYxCr4v8yHZ8W2PfMyVjTs4nilstMu/h7ROfoLde4miIJUVBhT630Qg0Fkt+H2U9aKlk1GHyhPofUS8nji9r5YQtwivkeA+Dpg0OFj4FMh4hfZHz+zD7eSI6XDccFijJzKcsmJwf7IKndAlqtIoNqXnJoEOqd8E3+Oakq3DbWLMOcH+egtuEzI+xv1D5WV+vt2xfN+GhwCvpe6eG6hGnwDMXjPpSQkd+wXOj5403PNu7VRlmP9DMpsW/4MyaUxNXyWIXl1ua1FlgIXf5ow86dr5MXHR1WPuLfX2Ljcc5dkfZXVUq1VCr6hhWgqRjZnUb8Pd8F5ye/RnipVi5MAscNnhIZdhZn3ggSylxRfMRVfn0C8FpFlLBKusCucThYlpbY/NaW2VziVEbCDnxSc5yekCsE0I7ljSw9Sc9bqlqHnDTAa4ZnYpQ2FYJaZZoJI4pap3KcQ99wc14GnZBN8Q+0sqmW4yOI1b434JXIVKPaz0qoPz50ZGydRzXEz8np2TFNIEQlKL2o0qc1YBmDCshJUcp+aegv7wZkhn1nx4BkZRlKyawJDLdOcU+ZXeeEoaITqMGL/z56zb+3Qye6CUJDihjsecJ5mxq2wdsfJMKQcascdIjRjqVEUswLvv9BAl8s61OcDVQnn5LaiqDGYRvQeDGx4v4FSb9t6Qm9CuoCzwAgrwAHo0HgeTLveuru5wR+B7dpI2/16C7mWRINWMlm2hkTkFNsAS0XIEgeOZNfnDpN+6oo4dPKbmg92fEseCZlhCVxIDoB+Z2w7QzPzi5+cU3Ht9jqohE8I8I0LxGNfqGPpHkiiIppQMkgS91FLHVfbX+dAo6fns9X1rWcqYelK+RZ5rKZXpjmfRytxHIl6tv8sQK1LnCxInyu4Y/m1gwMSlZ6beCCzOI6TyaG4NwGFYEESGlbTbb5/o+3Xuj3RdA5KhyjsdSuoTha9TzwUhKpHDJg+3ZQ0/m43AS5Y08sDgPWW4c2lCXzG9VU4YnqV+xTv4yDEOo/TGlXjqpkzElXNIpZjN+X5yqgTI5XLqp0zHZXEaohTOOnkApesKsD3eoWdMOnuQrqdIOnFArq9MeXUSpXhYCUXmFK6bwDrdMjSPckye+YKNQ/sMZFZwwkcqY4hsWiQd8olau8UcWcIsfszIBIaBJDEGpVQpCR0SmhIFoUhJG3CVZkEOjsiav2CAb8paNSUfes0qyxRprlWdsRovscZHWZMA1PCb5wCU2Sv9wR7bQN27M1mjEB7pEP3hlp3RJ2fECTSgHXozmlCNeEjhmHRPMJ3Vkgk/UDRPzJ+ojv/E/1GNu8IGq4VfNgbLlFn/JKnJm/C9WGRfJ78gjg/EbeZeG5A/UIzLzv1kFRur+UQx8GzReG9/KGbPAP+M/TEO7cZuk5rLA5qh9YwoMr6C5KfEnass1SeujvjeKYXVsSFN9Uzg2jNffpK/wf6M/aX/UoTFXlKOW3HxT3MKnMRJR6ZZrl3Z9qLkZU5t2HYdQau89r8K0tfeBV0y3wVyZW5LhB1sYbhpO1Ad+JX/SesRp/HpK9R2/fd/F2QnXvD5yTPEWXm9NQvwCxXp2hQyv+xvfyHkfQDIsBvi3bQX4TjugHKbAPYrCvTVgPuQABKi1gSrLQa6diox2PfimVTR6QXPRtpDUerHOMykyKTJpytoffvPDjNNvvmA7/vYwWPXbY2F09P+u8dKn7f9dK2/Z9vcT0FDHdThVbS7a5HWzyetfHaA8cOrW4lXIl19D3T/+9hie3OHXx/W4pT9te/fI/7qa0W4r6P9+VwnnrB1BRZWVdzEIemjX4c5iXIe93HeqlpTLEcrnCOXMFZnVFZINCuXOl3c/hn9FTEsg+AYIAjyj4A0wZQROFwoAyBhgBee8fbnEBrun448eItFgpPqV/APhckdby+h8yMdbmCeZyRJzbjWp4tVRMZ6YJmtTPvdrZxUz/YZhvNws+ec3yT1ZWcS1f8rxaGObFK5c7uDJMu69ycerzJNLf5dxbmmpiv++FON50+TZA587s7cK2aQbwnjBLNmbkVyttYiTs3L8kbXpTbup3mcb1XvsXfUPRW2eTPznSCPyGtV471M1D4U1TTbu+NyFZ6tYeN0wGq8wS779IbmdtUXc+laO/3sxMqQSp+4OegaTjLzCqdyhPVPdIv6U5rk/O+V48+UYc/3GYzIXVePlXO7LSZF8+W0ZW840t7WSj3fPx41/5smNF6vxaOlypcOGLildVfEhM8t9eFKM94vEgzfT5MGjxXgVn7tyUSZX/lrFitmY5VaWG7Lxfrj48WWW/NhajudJ7sWHPHnxYBHnFua5c3vl+JPJo2/UX8rqHsLrkqKFavlkxBtSHG1I0qmVIZp1mgysPKaej1Q18KtWVXl7cRQF/+C5b06ih+aBhGr4xLgNKQZPJGktlRHU6zTp5fIY2S2WVOaK6Dz8Bt36E/he/M7xRZRxF2k8u6ieXvLmpa+aGMNL5q+e/NfF+9O59xl/c+xFK1M8fdt941nrTXPJYP4tZ9d42P5xhO78GRzfbD4v3+b/fx0SQax3nJpCMG80LtEMbe++wfdntC99hDetJbPxXxtf92vpehKz/Fq4IZ+VN8CgOvjvSxFuEsVzisxoMV4ZxePYyySuu/srrt0PUq3Hv/PXcEWKeH7GzzuHW714wUEjjjd1WI97T57l66NcZHsYAYSpPLmtvU+noAdhNKtLgx4UZEIWrf7TsGu94d93N5WCCa8UY48PSuIQ3zgYPaViMs5JJnfeqRU3u1SmileTf/ZWfrdauVnRA0CjoB4TjTs9kHsS9U6q5M6Ir3ejkCeoHvYGPKifPQ0J056+XVjX4+Tir45BDZrKnr1qV4XXUGixsIemteKoK3eUgtoZKcqUgC2JPd2OWZFn0f6I8v80kJLYwRulZydxRo7sGBfE2FXeaTQ0SlA76MTYxyuR2OJvghUrByXwA41b6oVlNxxavU3yA4YiK49RVtTeXSOPEB5sKMwuIQrQE5YBAjiBbBDPqI4F8hlCEpxVqcrljigT9DGWEXdyChgD8hJiC3pEniBCh82EWSByhd4oTf6wM8rvEWOEvIbokta6BfINwimcB2SBiA1GwHJNE0sYHXKGeExseb9D/gbhDbZWiXNuiMKgH7H8h2CHU4V8gHhJmqNHPnaERJO+vklVxh1RRvRfLCfciR0xXpHZEU+K7pA9ESGx9cIshsgH6E9Y3vFYRiuMa+RNR+xU7d2I/JQIN8B5hIyEiL/DmGG5pYk1GPfIKYmAunf/yPdE+Ba2SgmzN0TRQj9g+YLgFU4F8i4hnk1znCJfEkLGOHeiZWuIcox+huWKezkdMf4jrxJia+hL5NdEhB+wZS6YQeQBvVaa7GaQU4ZxQq6K6KLqOEO+KsIFnF+RGiJWDMEy7nRiLcYj8kIRj1Hduw3yixK+h22thDk0RNFD/8RyTAQfcJoi7xXxElXHgHxShDSq7txV5cwQZYN+geU36cVGGO/IRRFPA3qOHEqER2z/hNlB5CP0HZZDMpWLFcYt8lYRu0Hr3Yr8rIQb4XyNPCgifoOxwHLmOrEK4w5Zd2ZXVdS9u0cejfAVbIUSZmeIooL+huUzEaxw8shmiOdWdSyRz4aQI5zvFS3VEOUR+g2Wi84gpwrjC3lpiG2LPkeejAh/w3apMIsi8g76gyrxIH8VxhXy2hDdWG3dCvlmCNfB+T+yGCIeYZRYbjqdWI/xgpwN8Tg28f6G/M0In2F7ljgXhigy9B8sP4ngF5xWyAdDvIy9cgT5iBBMjD+Jc2mIEnTDYqqJDRgJmYingA6yQwTY9sIsCZEn6C2WXj3I3xFjjLxB7ILauhr5CcIlOJ+QARE7jIglazQxxWiQE57ccqXu3TvyHcIrbFMlzF4RhULvsfxTggangLyDeO41x4h8gRCD86OiZbMjSoOeYbls3MupwzgiryC2PXqF/AoRdtgmCjM7Io/oa6XJ380ovxXGL3JNiK5RWzdHviaEizi/I3VETAyHZdJoYh3GE/IiIR4bE+8e+SURfoBto8Q57IhigP4Py7cS/A6nGfI+IV4a1TFHPiWEtDQ6SlVWhihb6JdY/tSdWIZxQC4J8TRCL5AjEeEVtm9hdorIx+jPWD7UY7lcYZwhbxNiN1J7d478nAg3xvkWeUiI+APGEsu5MckPGDWyNp5c/Djwk1BhvNCeqQmdiurnTt/k9j6pqin1MX+aZ/OReuiCzpFq+qIey29vR+dIjWZr1DfzTQs6R/tb/b15VX9nvdl1eWadD8e2Z93Yp2OOXTF/N7+9h1/GdLPS9cEcK9lkTDYvss5v74fJWjG/UP5/m84FVJKjPIgGCdY0yDFHTS3aUGgjIk2uyk40J9B4JOXQ2Mg6UNJIlJg75Uk0xDzdE4EcUNFIbvdEXeWFshUNbdCmRPoc2m7kPlBqI62QC7Siwec0J8hy3LEWHVGkhry0uSkhCkGZIaEOCkAOAOAUgDkAAFBDNgt1qLHBg4DT4xwwlXQEOEL7AKAOdUDbIqDHPY8XwvS422sz4q7v58b8LkJxs0fmqKHd84ObNga9ykJ/1KlUhPKiT8Y3tUWu6/W6GFqSZZzlkeJnr/Gase3/iWczXs9qSJUetHUzYR8jofwdavX7CGAdGv4EUQrF2z5ZkePE0xmPcaLew9wAjyh3+5R8Prj3+8d7BlYt49/CNJeLv/RLm6mvw6YgFKO9+ZE+ufvv7Zz9/VeVPrmAfj+4ehqWFidz6ZrFXWXucHRN/20ru536YfzAiN3K9V/V4XY2r02Caz6jpsrW7ev8wGyVjtOq3vfP/vFyPgrTl7+hCaPqV4+HvLdWpq/pw8ThueqsdP3rUibrDaHgVWVeoLy6V36v1xTjavSOU6sbp6BXEz1L/MNUnp7F4EQnAjmX06NRbpr5tt8ZzCYxfISEH+1zSwXEHnvXLow+vDl3iXracw8jWZ2UqFZQcpeg2Tx8YfkUVRG9E83HKUpgDlNhtbO1N9pNxIdWawGBiiVT7CNnLdfooRpNyEOyOjYQb9lFE5l3wiuqFGABvMQsZ3EwD/ZPZtsg8U9VID5PB8rOpdjkq9YK9hEYv9WXqaBM5aP0tP+a1XOZA3WpkBvoxKynkF8ZpHMdSqTnBkRZ/xQXPYvdrJ6ZXHBC+UGegRhHOj2Gz13zxBCtizi1I23Z8GzSiYE7vEQFe6uCwBCncmQlgUZl0cGimbQfcLov6KTSJJY3BecUfRUugLBFsp8brwJF996lc3NDDt4gfgAkq/L0bh6CZuqJz8mJzz1KF7V0JvQGk3WRsxe5YdKoHlIKf28DE0W6aJh8N0sEPXsPQblhVZW+k6FX8CKSuOtiruO4EkjKWY8Lx6AkEcl10BzViF5qP+Y6CdTPQ4vzR0flUU1r/YwRqovvsKuc/VfrDteqTbx5QvSFYWJ7ziegIiESQ3rZ3Fnv2iSdm6EYo5Sp6zONhPTCtsb1LCLqUlAr0NHZ066TGPrH5+kF5oDBtSWp6SqytWKKgB4gPzu7JE3QoBY9LR3AJe5R32CFCmKLCoTLopYZx/t9lXQa+MLOnq4jHa9GOskajJQPMeNDieVvSGjui386Sja3Gxij0KOO9OPkiL/RhdGMCCTCg1LzrEdOfvqQzk1SQ3NnWrAm+fTLhUxlK0eJiwUs9/ItbMWcStS7d+mS7OxLUyskBGtLWciEtNGmcp38QCV0gyiRv6QOTROs2MU8mxyCQW22JEkd3jLB1YxDK3qzjFPAIq3wMnwm54mrxvhOJ4tJU7aq9rl6YsE5mgrDP881SeorqrJumTTTtkpFW7IaURtZWd5hW6zhSS1sRLWkC0aXAeCen5cTNCLVar3SS83AedeBCukmgiburJBz5aF5ob5Te3uh0ZpZbfSukL2ZVooEarkX8Q9rLnwxTjeEbzcgrwMDr6tgIBazbU4sbBumttGuhKlVA8zCyqmuHCmdyO+mQMjSt6a2vRCHalrv/nmvbd1Kg5hov86djW59hFe7ga8HEi7EQkfQ5opK7er3M6iHQGyR3mJe2E8JTRaeubf7ZFxMRPpaJCgemkF+hlUUqfjLs1bsFSWhXt9ADF8U/G1eJu0AW7w9ti9GoxWLxOe0+Kp7W8BoLBnzaleXZVzNYSirWxDTkklzoOEiPqbK10kvZTMnx7N23yjK2+Jbv3jGa+8hWIis3su0rn7W2QjW1fI8M1QmKr6XcLsb15RsFnGpZKM+SBwQYoD/y8hxfpfyVnoGA8vODDM0GBVMiAkoSfQBoAlzBKLmKU1E/SK8ejHVJv/1pH7H5SuyYTHCaKDfeikzFnrqyb7R84IvrVZGI63v4Qzm9Zz/7gIyD0+Kf4rxP3rnrs4A398BMKHJtBcemxQ/tXbdyACMo2Aleo91zRf493HzgueguIaaSgb06WxTLWQXT5n2FU743AbQP2lAWK4gjYj6wpYIXOspJ7FpJALbbl5uPfYi9qVMLsT4snsfGuJGXSvvEJKWbfbrRWwHBtrll3/9faNriXHCozJPTcl2XvNAB+TXQBHw8E09E/wmpIYgLxCjkD0K87eonFD65mgVpuy+Ee6YiWqOKGTkwNIc3x9KT7/cZOl8Y3o8nV3JpMRdpuToBV3mMlDp3FOlLroviTfLE8x92637gTYAtywEXBENUAII6JjG/Suk3d5U6OzVxmJNUrSUDug8OgSl05n30tfY4UFXbuVJVeyOOjHO/yJ1L1WKNlWVut/JK73eQJc5gLgQhEPbyRcjXIfOBECmLz0hPlXe6Xh9t1hox/mjSqQc1jn5z/u2cJYwNTcJMMuJmF033j3lGmxy4nc0Qeg4SCr6FzW0O6sQmbN680SbNsKpjGffKU4XLrwc666WzRnJiJsWuGcaKXRbhPxoPLebvJ3Vl4EbKc5ifxz57dSsmtJRQGrn8rWyE5oYGLCnpjsbDtxWGGBvOO0LGud/Zxm4gBpEr4GPfuc0tHEFmrLKtyBHXU/1Epydd+iP6Jv993c+mvTcwRQXB/iOh1fUBSEyL85MHD0Dp7zjMVL6pLr8UtgjIkpSAwH9e+RNIQKHWVN1xDMGcKljuP/mX5HMtvZb20xyhiT0H/OH7EV08u2Vw9Huu4f5iupghl4w1jV3kE5rNPpe5ps6nBMmu4VuPMsVrEJgB3PHXki4I+lI/eRIZd1nr5/YsWn1ogYYnCUYbYJCv8LPtR/KBlb2MoNPvKI7LZHNG5O71WhOAUeb4mGwKSN/F6UnfxTGqxtTTVH1fbbGFXHtrDUz4CQ5Ifk0grnC3G7KMwG1PLtIvJR4UZs/4D0hhTQFHdKgmN2IyZmXbprv8k5qFndzbjv3zoklVjON1fWts7/Xb2EWrPnsmxe/2Y0j4ge5wGDn41yRqAdDx8LPMxFlP2gzwH5IDNS9+7ggI9jIWwuxGUMZq7/TMFwrsBWJ4KYHsX3p+iNIgsRHGnIv51e78DGnymJj0a/PQYOlcmMi5r1xBvA/Ux+e483A9Z9fc6tfvy1vc9j9QJNnpBn+lEbezspCBy1TTO3jGzgH+6k3V1WL/nGSfZBSH76/cv8/L5D2lGW/rMR1Gw6X+9+Cp04VTuWO3N3BrBa14+apQ4lZ7rj51QsEhGU5+t7GI5oaHz4ARyexeE+wz3ysPZ41rkag4GhL6qO/TNmX7sR9POALwQjbXdD/k/RqldZCQBQqFBV97U9co7GftpyAb10x+hJfiHoYKRqIIzjIe2rx+TeRTd9mst2kUr+0s5I466svQ77TRZLVVTg6kVILm9OB03Of/8z8CLz8+B0T6CxtTr/FV8IuMNKk0Advm8k32e6sjXIzaz4W3+Xru2SIZwNXM+z+mo6HZ1yZPjmJF9PT/7fsUnbmc35GmXnMCh07wKwS1vrHeXwBUjGjniBN2cJVPIxrUQ2M/EyOImm/FwhoUrrE6XbRGZcbhPPovTLeJh2wM8CY1FKUWs/ZRZMaDUZv+cwiywN5sswCJwQTOwoo4gTeK3O3whuUGXZsyUcuCjAhp2JLyFoKdreDk+MvUSuCPyl6lt2nlo2Kmnxu2jVJ7eW+ASGhliz3hk5g+kUrc4LP+KZJr7ExBK0tcs031IHucm/IQyj5Ttl0/QKLdbZq2+iHo0vlprjczj6eirSYyAjZUOltth8yHScadtQypZNCHJEjAbGyN5OzdW3MVciVXoVUZjy7vCzUTeTVVPzLc4yobx8RvXa79MlCs8PVkQmtykbg1lkVtT02JsoE5YwoUEW7OS2pfZ+wg/TGxUhXMzTKdUdvgO2iqam/oHQaawOJBb0eFdJHJ2X1wAh+5PvWJ3Z4+j2SKlrUkYU9lpqoD+FIsPcjkuL9bUa2h/Q9c8ga8jnCgPpToGGZMDVxd4/QyWb9C4Yap4wG+4BEowZo1AQrpyXz8dsq5lAlcFr3hJtrtIrKIIgWqTeJqdxN6XjE8X1hC4Oc811AdNN3AyhEWc8rfsitqzCrx9nD3aj7dNme7gBhHZ3x5CqBINEwxzdW8SMqi+qj3Ve8Wvo2uL7ixJY+hMdXOns35NzYxld2Fik7Ah6BamqH8IKGx3U0WJGEGXFsyjNrwk+6hyRVJ9/XnldgaeplwDW/j/aYnJrYHkZZf3os2V08qMKH7z+9BNt7aNzDKnopkM8O3e2uuHaNR5nmxXuBP3GglOsQit472bQ9w8DlFzyb7NvCBsmwFOLePU1rMErS1EbmAJ1JU/Fiw+OzkW+IrjXjRrc/20yIcjwYP5hMsoc1S5HsT9zgcZl21MN3/y1oiNdoHOgAnpnIQ3YIiP28QylTqFU1D/HaYBnkN1Ld4gTDm1T9BiqDth+8BkF42OYCuo/GJqN56E81sPBDv179OV55cmxrrc2jjQvb+F6Qar/WEL78LY1hg6ElWI1mtNJgirpbQPfchhzcC5bQCemluJfETh87VlNTNEnb0u8qDU5S9GkJMMkVp8sevab4zUSbg01OHX6UTiSRiIEOKP0NI469j8TOT9C1Mo21XSzjBu5ouJbYbLU047HMtPtgLObxgZS22c5MTy2tjkUi9syYdpz1aN5DQ85rxpHY3c3RT1Zney3pM/R3EBO4olVxfm/Vk9fHmmlKmSkaD1Hs5rG2rzX8Sc1SRLAVD0ll86AuDW10z6NlqMCpOysB109eEfJj6OW2wxRyHAqbf+YMKu2i5N41srDWaU5ge5g2kOZI0Q7f2e1C9sbQep/4mrK/RwPrS5rOEs/7ZefA5BaKjbToqHi99EhWqT/ANTQpxe1zuThehqFwRmvGI/e/rotPvm3rt04i5s8WZPMlzo36xnHhFZNZUJklkTywF66AafBcI7UxWhCzGcgF4LGdl8IzRqSjT70ISuSjabdxC+Exjl9RD6LepQCmDjWBktdfnNCje1sQlFfdrnJxoE9ViFeXtb8FqXUSV/lH4VpfaOcf5hJ0TTupw9qEsajpI6ji4EqWJv8T4Tx/tRdr9OA2+JUD8JJf0kMhYBSrybKmIN4DNzGkuvgGe+Se8hT1Wb4BGlTkMzLEePVpIaWEt6I6VPFN4KB3GjL66F8SWEaSLX8rxHX64CRlBw3tMbKo7cXNc4Jy3YRDKhYNXjA/7M+cv6KNScDmCuvo3sDF9VH9+OvtvqMXLq1Pe74OjTvqcbKJuGP0deLhOW5bi/vov8y4SW1FABaz7ypa69eFNjRjc2Nmp8l+ohaqtqGpZ4WMUss74L6YnH3vO0tFeifpQDyuIS3JGIm2gG/6PVGrDGdhrs8EtX3ORPCGCSTQ79WDtTpbI6mf8t1xJaCrwoyL50T3C1VtxkJd0pgltvIUZeMJjBchQ1M+MwpK2NcMIQ3ysolOMNdvnpTnS0/F4LkYjbYeaePPtRGtOqe9gQjD+mtijgwqDMzqc+H6XESctTFVZ4GGx4zmY2dgwOpk52R5LTmprrBMVQnFKndBasN6OPDBAw4llA4E3Y7wUNy0F3ky6ahMncf+gZnmUHgvhyisPNnHXIIO1oH/7bXgFFegVYwCE+azdlvRgSpSr4xJmFuQ5xjdlcgywKn3rfUiKMLjgbq6pv9jTGMX/FbUiSOBe/sWP0MrwMzmGPH0sUqerH8vZtwo+ACLMVbZEsDQJBm6BDI2exLOQSnv43arepDW1YaYCxxJHrni9t2nZkfBR6im4EL0rQeA4j5CAFv8Xx+zlvETiwrXFDshqAfM2elHzZ9xXz+RsM33G86ti7Q0gdkzKSGxYkXk+FTzTqQb5Hm/nc7lqmTVTNE3n8so9MJefPF6U1J5EUnoiVmOIY1PVkOM4rTirShvvEAlpiuuL4PQetpat724ZoQxd0gc07O3O4edzWF5LQQ8UHpcQpPnlPS77WrdhsYCRx1WFe7W9DuVoHjq7iHyMfqEFFuxUCGBaAbrosPi4Vqir3UQRAg+hPwu7QGNtCSRljxTWMlw5iQe/ynr1230u50EDC1J+sntLZwnVKQEd+YWMTO/oSVgeLlY/aqxNSDL5CHZ2EIqEuNql1smdayMf3ffX1hyHwDoFZoxPNvyfDfcrdaTRs+wFDJY3CuZoDigfIiUYFjBiPigQhbiT5IiQriY4uagYjEIz6YqcUNlAqpCK3xBy3BlL0MFKlYE6nq0hvOhAYqKrxuvww4E61JuZ4u58SNERkcdls+VotoKk0C29iDFkM6Wu5e+bmKDAy9MQoURAD1CEAxKcy6g3eWpYFb0tbPUKEQPCcdhGn4WoNspd46DIXCsG5mWDooGWhIICiUo5wdaF7p9iFAXCNONHPp9fx/YSnNfEgAKAErmJtcNbumQK+vyIBABBHnuNT+h0bpshzxbPKQwzmVe+m7gECkoqyznwjXJ6VlLFTUgSijb0bZf2Pr6RvaMlOQ04FpX8nES2gy3ygVlAjiXvRtomtmBJ9aOpJF6Lh1sJHlFoe2ZnZaP/Q3hkJV2HOi2c4HPNkU3Co9YraJxU6ybeDhO3FfgiiCCsqxLuXqZsJbZ3kqU/2LwkuVZqOM5IrFhOLHfk/yzhh/JYtV0V7OxhpG9I8642pTHn6Rk5Z/VIK2AWdC7k/GzNGXngI7y+gyuh1liU8yUcQ33RRfNNZ+vAsNjlMJOifwhr5l2u6SfsuuprQVLAxoiT1jsebweImdb2WyvZvIaEg/KgaQOi7PZ2qmZ+/V5Pu4eLoHh4TbzhD9mgiLU4o8DhC5JwB7A086rZ0tE2UJQ88ZpsknfksFkQn2iQheCl4IT7+gTYL5bJY9Sxz2o6Y3t4NbFVH5KwDkyI07zwAdkGV6nU6M5Ib7XOzM0MJ7qOi3MYxUagQEDJ9DzJzP3psNYahg+qskpZlID8Y4BxnBAeOV6OaHeQ2SLE5HAxrqb0g6hpIfdQDW3NPxnbL74vG5FD9R9V20HJDi/0KGU68fUMqdHxWQT7vG+HUwCbjKnBkVNzvhyfuO7PCM5+J7SBi8GpMHDnYRQmRUE05eJ9+Vyje6CAMF67hFGltpKlc41LR7Qq+dNQ6/73NkqDczDLGXOq9fI1keIM9/kHNClA98q7l5ygrHtEkqWdxQgQTcn9KURQxOolgWRwFSo8VcLlDPU5dCQrIo0+gDTNew9Bge4K8E3ZJX5R3vvXZnB5+2ZdQe/0v48YKWg37HJkg9ZoGaao0wTWws4TwMThmOTCCeW4lMeOvPXw71wZFQhd2QF7G8xqMBUcMyzfjGBCRgUuyNosKU8cnJPK5WrHpkaLk/fbhIB5kb7+zB+TsZlneIFUkpuEkPWKPDbv/A+nI8F+88pdrmDmW8mZ9O8FZVSz+Kjp4IQyMhb1f2OJ20ozRYO3lkz6FOlICdrEzstdsPYJoqeyYdinqaj0ow2rzJwnoIQcznsGe4Bc6KqROTdodqN8Sjc7MYWNxF0nDS4P51goPCNoIyPkZKGhXyyk5Gh940wTqgp7UFx24rA0xUlel2TLgnmpodYBS4MnbjkqVCkwB9fVZtnlZduOeh3rFJKFkWox4UNnQcYEdiOBmHZHJ0LGsr9dRTC09TIsVeYfVZWi22Z0WEif50cnE/BfmwRlodSEdCOoww48jAjG7NOTxJ02rHJimHPnFWqE7OKqcfOGQNzwWtULzfUngksjWu4nhkWTa7D2DACKX2rWUMYXBj3NPpwXEQZb88Bdjpd7C2Fttyl1ELUaYM5RuOlsQTmFzMgLxXLJpeBm2dWFpT80QmhBpbv6Amo1kmQJdJgpVDLJsRmQ0bsFXBehVB9WO3MQRecHjy2oRo2xVvGk1FNGgG9mT4WkV2orIaSSCAl+7GSWVEcSgcGvXlIRNhZC9zy/m4shzzkaKQhCVro7YVgA9vfxlgsnSoJeF3Nq8ap6KNQWHzOC+Rnfr3sMmWr8Vi+jAQyp22noYaJpYsfd8ze5rL8bSNwKIo9L2rz+4HTkd6OSipkG1lzjyMuGjQUowWwkcZmODyBqni9bn1rrbWK4yZ/SUtPX3U3IYescYJo32jRPyYxDQfr7hQXdUb9G9lBISFiDbrQH11Y4JKxu40geTVe2JRdIDq8pULw/beYaxykyJeLw/S8PYMXwkqX+hr/g58mT6s1SrKaFGtrrxHgVLKkobMWfzbVBo9mO0Y2ljlaXr7P92Qnm5X8bYZwEjjtXFm4ALIJUojfUj645nyBz/kFwG5xPvaQ895C2D7oHfvcjzDf6MRuiM1vTI7xX2g6n+MNc7byx80+KwNPHE+ZFKu4jjnrbAzHnsB4YPL7q3LYQnvxyUiGTzagLgq4GU9Rqgn6PhsOEAMRAfqGjio3dbwQKN3FwQNl4U8ichqMd5gt12RgsppeGUHQX/m6Sv15fkom1TEDCeJ7Jp0OvTpvSjZBEtJF4kr6bAUX76CDUTdbF+VXhsjhTyvVuXoNxsjXsxpz42miV1qGDC7mxKwhN+eUyWhgMrynFyPNIyp2GYapZFw+Tj5wXCofYAci4/iIjzyM4QhVf4ZWK8mwQ0Lst9bvH+bLUBjy/I+3tbBVXh//NGOljJwx8suglCcrAi58TPErSQ9pswZQIAaSnCnxpOJlh+JYnNTWq3oYVnr2pRo0JemDOVNpS+ncMJ7TEpmPqdjiGC607oZtKpSfFQGzTHmCgqARQclg1E58Cphid40LrIYvOa+DNT98ZaxCvJk21q00yj7QHVOxHYrB4Tg1jz7GVaYEfnjdfNIV5NZLS06foxFl8iInxlshbQwmk6VaJjf04RD9trST7Qk8DybxkjRAjB8eyQZ0g2Ii0YZlYsBzmNghpKWVJPOVNvMX8JjthtVuEwwud3VZU6qEwktrcM7nD/lcc2Zh1PLs5i+CVYBTQ4Rls+CsIlN2nLZurHHjJiDT44J269XKjIScqfzYHk9TOD5poECq81xF/ggvGPLC3qeuAMekXUUhtlJbcLzHQvMoJqpFrtVkQatSFlCc3oJWc5wR4qtk0lg6PfOTJgKnyhRqXuydOpUKGFEFGgykotht4mQx7QTLC2JUjTxS3iWIiisqRBmkQWCbSyLpFMF+5gV3EP3PysdqidWbIxlOfduoAowfc4Wm0TTAXsE9i2xIfiXHdbMNuLcVwDTyWaDa1CDKDwuwO0ueZA3iRj1KNPnG2g9/iRLKyLkGwZC12niPw155rw60tJnmTA0Oh7pJNSkyJkNl50S9O4b7Dnf/z3xtb7pk7NYBxDOU3+edvfwMYOTSn3SchkNH2MY+8+nIZ+d1f4frHyGaa6cgnE7RHfzWhQG7vsp5cM8+6w/RROfePL5/DqLTjVIUnvc1Ivmkfv9NdBHg3AeJ1z68EclMcretN8zJRh8Hi20K+FswGCoAeinq28ZPVN9HpccO5lj1Qu4F8MmD3PRoLjwCkS5TROHh7hgBznAhdF7FAnoF1XtE7pFvfIOLkw36ZH9YrG6d4ExeRcz2efgRThMuzDSsPjXs20rlwAqmwxtLGRGc+AlHl+paf7UNhI87H5V2mEG5RK6BNIoc7+FxZNjwPSveZGqwwT8/tz8gKj15bf3Ie87ni08bWbbUgrug62w6zCYIA4tHmFUMtTAs36va6WSusy4cIAAP9rKUzDGAW9ulOq87DwbUTmhjeviXIkkncL2q9ZrsKjZSZKZI1ZRnA4LNfQVxeurBcVXGXbNx7CxNz6qtw5CsKetqtvu3v8ac5axNPHSxyA4WBKPRNvG8Ij6AVYTNXq38yBlsFgsr+75Pldcqtw5Hyhgur5R7g4okwXlFKW1Dq07k7x/y4jg+fbgMnYt2IxFuPWj4BGLDnFuo/tNOp6cYKc4F7VwrjPd+xozgKy9orCBcX2xaXhwN+5VcDIxeqHFpDcczO8NWSZHWvcQkusi3VRtYvvQjP3gIMkoCgsiRKzmNDu5cjtKtEg+KQ3GbQhuuZZfqAQoPDJfttT98ZGGEezSQ6nFhGh56Wbl6XP+G5+CegXkELoOu2zS3dZm9Prr0LNcYeKR1aVZDhrK/yKiMvC2J9jMauBEA0HuLg3ItgOY1ZGC2R/AwduwfeSF6pfpO1xXH4HoJSgkdlGsBVI9PBzUu5j+iXiV/bHaV2cXpkF2NkEnHI3a58f2sPtY5M39D2RtonEfndfrjP7+saGWPS3SQU8r9E+HBYf6Qfo+csoX8X++IK7BTk0+z+eS81yhyencrO5iN1xAomci26qG8oypVJvS69zx+VraE1oaCVk2LDLiDZKhjNsiODzpr3GPB4EtMeQ/Zytsq7jgPWfrCfDNWP6yS+nYRlpSa59tYYE3uN0lJOt0K0v/4aa+QrK8fd0E+eAzsTwKHHwPYsnLyrKaEHmIYmZ1tpuCS+wEFibRRH1KGfqFcbWSW2z3aEH7AJViLxtxxZ9UKjIfCwfb3y6yN8BYJpedhuyN5h+EylYjHWuMYhu0XQd5b+KcfX/osr1OEchrQfO0QMO6pXN9UlIQCAS1xhFye9QniXx4PbRwdLLY+4pkbGB4IkxPZK2i/TsH2SqPukbK8inCMKqun8U5nC/pjFyPZxuh6aEKMFMhATA9b3k/JH3I7kncwyqKyyPih5SwXK7zdIJzqLQD2MZtqYwznjvTdo3/gDc/c0lrG1QKFY4OO25/aoMBFhblRIhbQyOWiL/XABxiv2J7RxQa8ELn5WqmjOOs5z6sX2snQYsAAljjotLjGemibHJAvZva7cVtLqTv3gV3gkZwE/EaUiAiRuPNk9/q8UNlOopJ3Ddg5/UUj1iqq1sA2OqRLq7a+e4qVmepgZWriRr5PRU+/3r281T70RT/DPEPAx0/0Oa+eFx9QpkRER3ZX0TzXKMI4vqKR3MRr7OdC62V1AZcvd7BZBSTAvtDGBptfjtp9L7YYD0aEr0aEEU8gFka4OW/1ICtTMIzwDUnmyEPfzqt2dcPBV1xSCp9mMVbDSNyxdQW2vQkiDp+8xAhAlZlte3vHdNKZMxWlEkRmKQUlti6ZN49aw+ghccxLbtnJRWBc4HQVPg1hXpRHBHNE5HS5nG+UkmEo4oDCpwFYHzkgmINYZKTJhGJMFn1YFKfecAZQPpsFz2kN9sW2gAA76oDIaUuqgjmEvbfDTU2PjACiVM/rElyW3wLQgjyCQ0b80WUanhi9ddfOg9V06IaKOpDBvmrJfFjSTEcxb2S1sfQ0uuil7wKV+02/PE396jzJv9yeYt7ig6Lh2P7lCzSgD6vEeYU4l40yGwnJRf8D7D6UQd+FGocMhnz9wN9feg4rI8ZDICZduDfkuGuZgu2TKaiDDiSgP9RoTRYRbxDxyDIF5aqxcQKKSDQ+R2W/5Mt6KCrIScPTgZiUFB19gSQgHA2aYIPJUADl7ookaYWog+n4jJ2HsqFkyJIMTrYxm6b0MWNMhNYeqpvKRh0Ig8yWq9OAcCBgwys2sZZQyRzhYEVpaY/JzlUcfQ2z4FUzgYQutP7az0qjxbwviHYoo8aaFf1yN9aiyS1weesbmwxipsgsbifMindAISPbYN3WPZAAwkg5N9gzHg7adBePyUfM9ObiWfmJ5nmYp9w/EcePyxIMC5jV7Ch5AvtuDLCIsWnEdf9LKuVlGRZNoXQq7NgbLKgt9JGBIpvFOxDz9cl0H19DN6xHb5Rd7OPtBezvIQ8KEHyLd+1ZO+wxJXTAAXu7NgEp+HSPDtEUApjfr0fTV6EuErIc19Gdiq69K+44P3AFh6gKjX5Djp/WDSsDWOrM09sevgnc363EVwZc/Bp7sX5DP/dCvOkJ4uIvv72Qwu2XsuX7rdq1OPJ9Jo7camfy4G301LcWTUb5URb3CYX6VQ9+dYC0PVMDvwLJvIOmhWRGNvzLPA6/ktGuTafLUcWa+J0do/Qlc5jwWOmRboeUnwomMSieXeB37TaFg5pVqLSzdZeU3Ujfw76kaDqbbO2bXSAYkyLFnd1zV93TAd/OnqaMLN++D4iTznUh2S8Iiq5ZrhHCkbp7taAAYawrMkWr2kAF+JMseWXKI39iCu5gj2+PXhhsPZTkvBx0WmQUKSqdRqRPWOtkVr9TM8tDMByXZoLEBDRIaXYo12EUoFuvNPJ1vrGle7O1M/SVgkBsi9lvBFghQt+uXo8sz7Ud3xE202wGj935cYsqCT7wpNHzZ36RbCLBigHHIgIUaqql1jIxlu5gURRtOg1K+AkYfSdIr6TlOTMS3Ct4nysccceFg8FIJxFqfuCmJTgS3+VdkpAchY3IlaJA04huGZ0FQAZtw4dUUIwfeHCiG1xTaJByGD6QfKwGrzjuJmtB+Np+aeGAlXGKnhfFiQqudj6Wk6sYslSwnhzjxLStnFMspLqiMETwwUDTHG+QGH64/2ko/k2vYHH+BAksgl85Bc1gLp8N5CYMC/wY+SkUHocu/LMU+Ppr2eZRafXrfrDsoORQ38iXpZpVFPV9w7Wj9Q+fXs66vnMJNJVY+FplwNKm9LgqIHcHEp0burjeeSS8rQYFoojunTFPxy6FjaMsiBufaNnlRPEoW1wJ9/Ftbc6QIVLjG6xWTVfePKGYYrt2gB6p7ybeZYR4HWnnN452MfRXldY1U1CMUSaxFWAh7DzC5irgSqLLChkOdhQB9MwCRdVd5KHCvtNqBjf+vHCr/T0yh44J5XAD62juPBtgPLEyCkTEyU2KskmMOv0U1H47Z3axoEfCJqh8J01QpUmM59LcAD4BJJ7WC1XqagclLafNstf5r97ZIr88ZZ4dBWMnIuT9qHwsP/etpveb9KZHAQA/FAWegNIqvxoZk+BFC4kDhNRUrLByzV1crbkHhDYbKGJ6ir16+UzKCGJ2lBIs3HakP6iTUKsZJIXFmoZLddr24bA0ozDLdb0zlUHrb/Ordfu6mGdYzBDq8mMYrX8HyKi27L/MDXHaC17AL/OMtItgfPf6/o2g9nRIkIk/s2RGwqU7eXGpJvnOXs+NyKVCH6fAm49UFtcWBu8yY+oKkRFTLKxyKcdJuYO4lLFugoxf90PaT6F9H0omHaswlToWIrPnPr+gv8XimG1twLXZUdF29n+8G9/9+uX2YdhXn+9Eho2lgYiGGNDk+LZlYirINXBYpNiGx41+hbL5z+b/5F1IfZ13QKNYo2H93e6w8YkGSzty5JjXzhoVtfMpv/02h8VTfr/HRO96uhu9VKent1eG1gKyZBHYbYm4qjbggbt77LK60IXuB7yByK8Jt2uuKCGcmiyYx9x/0AbQ4BGknATHJ4K9jyHTOxtIl37JDst7BdEYjoYB0zOcFiY9id1ntrm1axzc0pL3uDtbFZ55S4sTx9bTv3+5Mr6duWrNo/p1GIdpe0vbvKjU9F7TMqCfdIquW45iCRH+SecypIitP82Q0WDckhxkWTL6zBXj8TBdZCCWVcjAWLqPnnLAZ8pYL8B2e0gFBYBCXx6vKsEzDg0jKOSz56/FBpfY3itQHg0aBwJkM3J4gtWsMB1o5I32Rnrzdgp4MY9v6A67AH7wbEckZG8dp7uEeJy+nJfI5D49zs8GNUen4uevskv9PVmPKzqdbJINsyVrGiXUZG8VwJaOxZXMpTg+OxqmQF/0lF2VIHfpDQHN0my03i9uef5+18rzHxOm6tUXA+Va7wHNWPn4CfYEjHZJftxRum/3pJnesGzKJ8LWcpltDzX1HHiniIReEhaPkPPj5T/lY2kZ8ScLDpJFiEP1b+95EjK0Zn1yWdon8L7zwMAqSyBc5PUcOXOjgDGXD76zSYKYBFioHfOLeW56d4Tz8zryeRmCTVjEHQ42X/YSXxvfXRDKXT+NUnpcpNQAAu+8ZxgzS9eQvc3bpExU+wHxS1icN7Ar6vwEU/Z/I905iTdLVRkqLpWB+EKV/we4DeCQZHfKXXORdlytfn8F+1CN1ch8KX3pyD6wJVxC1XORQoSxUInsSDUGg/0o2IKA73ZdSoIHUPR2AvUwl3hvgWEAHUh53ozIFTwZHVC1PEUCcB8MAPzmPfK9JbPSx/1D2DFIBbKOzUbmlrR/jlxWlA3UNfaaf23lWkhuoK3AAWrV1rlBmaGX3dY9ANENuJ9xSYWcgLsdGLtJRkkODBFNUnFB7LwMRZsMAFZZyODzvuq+lQe/QbJjDeNFh4p5tJDwHxSV+DQqGlmEJzlVcw/msCNkEdFm4nX5VGkRoSCyWfBIa4y/gQb2apNqTe1qLB4TbPdlhGD3jOS5YOvqihTKUYJBJTRaOtwXgeZTW4DKyp35mwHAlzWsU2biiwud/l98i4Qslvym5oDT0V2/oMKnuEQvygCM0Kexyi8uTkWj2LhbBX8+oLMw96TcKciQbCeT9l3BaFNx9qShU1JcbtJl9IxT8gHie82VB3ZmRdkC8PrU/9HOe+kCPbCqehJo2/GpMY0UPHUP0AdKN8rJPqZm4sg7YOM9DeUKjdWYfD1Bg0euh9OujiF9CMP1nl7FUjWj1aJkiVMrYrE5yR5nEpwMU+BaMxX4p3PBEZcpqjUhsQChXiFi0TlToge/iRCR+qogqz34Agoa6OCIeHjBO3CwY01VrwbX+cZPkcTSvDQvFvnvyEUZ4sMZEmJ7RNtU1+LPgsVjSQNKNGap3Wgr8nVk40HtYzLJajMEHoVBarStTjyPGBuHLQqxB7pBV1OoJGJxFBBUDBixroapDQXzGa0dzG37MvwdENvwNRSj74U/mI+74O8Oy7xDNVdC8A007dJmFIPWKkMT5NCc4dOrnIw2jzo2iMxjj+gqeW2+XTvzq4ZB+Ul9LeLm207+m7k/S8svVNz/jE59Zt5RTSQozkmUJpamx1JNLkLSl8h7d/Xkbrb+Beq+iWmxE+4ujCfZb+lULbCTbER01QG24vgzv7E1okECDgfAqvQjjehv7EXMYLV0FBO5GNlequVtLgozE/0W7xvqgcm6cZazTKHttCq+4qv4QSNWOgk1NyJ+Ox9kzllzmHrXKYv5KLMrysehGvd8CEfWn54v2IJrs7QLvBUe1Qy3TwWob3TZPCs2Cx9igWy5ppTGVIHyngnr1mRgRsxNK6H8wL3N6aRV9z20dP9JzoYoWqdi+U+sfpZOpPgqpbVFEk8DpaohfpSfPDmP2MXYOw/OhxDVZ4aARZ+RmhDgB1Ioo/2lIeI7RdnjH4Gt21okYd9DCVs/+JG4Gi3r0qyFHlEGBX1OR1899haOASE4lX25w0lQkyAd9uSUR4DJrVZv02rI8RnA0P7dK06pVw+rN74jgUPa4Fy4PGveQJACSLAsHzaf0bzexxV/GtyQCpOFVBN6Jro7wXO1hU5mLAw+SwefaoHMIHhVDOg4uUvmY2xZM3AykJA0xVwNP1PgYQa5CjIQQ/3lyBVVhHewKPQxp1WAtczlUia552obesd7iFpYmNOBc5NoR5n1C4E4N/WdgRDlWM8FGkXgTcyHgYg8TndP3JHnNWnGmdwEjrlLGX/IDX2LWD8wsoI+Opw5kIVm5WXYaBQfJaChvsSTK6O7g+HDEgnr6VP0YwkcKPQsvdS4wk8SvnJA7jDFfvH1oiXjCHSKMbIfUWKRTB88jkx89pVttO/rqmYCuJlLbckcKiR3Othhz0Hyh7KM8U+Sg51rJ2uhbnenS/7oL8kqzPqHmZyTtgE6bwc+5EcH4vbhylO4RVx5BJemSk2ExF3TKUKeiK6YsT5bKy3z6ggxTbssy8vl0BbxGVqJiuQLhjGMJTPYgGmi/skisw35E60lzpEjMxgNihcfKSojSfM6hb3PqzklGZ8ncBbJmHUeb0hjSrN5HtsPC1TEvM2RfTaQuW7HtSA1yxZ6+IvhHgUPUNQhpaqNaZHVPQafA+Fr7zW6ejqk0A2spMbyH6j8I32WdC1T5G4Jd5JxkE6Qf1Q7KBrWZINcMtbC0wGc839GxEtHddqdDjvWulioFkYmmV4VlaOV5R7ALAsTdXVmH9X85M6RpWx7JyDkFnzFRtenanLneZ3SUm09Kbb7WoO6aX9sabt7mXBaDa+ay3UWum5marWlJvkJlWIjbKZcCzVsi2RL9/9Ltx1Lq2ABDYiaFbME/81d8+mBE3EDeljwML/IIeLWAoqo5mvLifINq2fPpj0ddo1wxpfmxfG+yAoxVGJcdfN0gov1Pr50d3jKF1DZu/qz2hkyv8Y3VZ87fwHTVU1WVZ17pomzeV5iaYqs3Nvt20lRlf3DZd/wGbsqBkpZHH/Kieh59drj4+sQV9LjXFX9FNsxxHai/0i5Zef5x5hgWE97Am557l6QNm02zR2tmGdjT13weDAbkLtNJkz4ctUYEJwjS1zcpjtUHZJwkx/5ZHoTBzcrwJlvBBUkuzKPOvioMhiik/FgzlU8Fdg0agvbzlcy4pM1XhoIZxHH2LQ4fANNdk0IYl72ipY1T9meOuKeQmTqWcyBx7FAxpZ3r8Ob8gHISNkla+3tEvvJBm4FM13/bhW3UGRGMAwrr9RNTZJ8okVxP9nVlbBBn+TJiBAMrnt7O/laEeCdHB7BHAn9UWbtoHu6kpWvPxWxdh4Yu/+id/9eTg+OUmDIenVXdY8OkOSi0bwddu9mEdpr1243575dLjGrnH9CX8B/UPu+i3iO8/cCVqqouxlQ6wCO4nEv939jeYReDInQgZDrdJl3Nmxq2vuiLbFoxsEjDrnKXrNCKHyLf+94IWgIBZawG7THYf/AmCLVU6573FObMhs5mgz3lc9d4zN15pilMtuGO8HI4eohP7qlqq92+HC8MRiUIQ3qgIGH16TV+gtXuznjqecBiz+oYBM50OkwAhKBIIvJi6Z38H1trBNA7jr9haWc9Ta5gHCTjqF6c2ZLyeOUEQrz2Tf+Mf5Hrsc/in4bPTfm6uVLwTlKi4vrpiFRSe4bBLxLJYjF7W5STrfHDY4PaE4VOLxjJp9N6l+Nzx1BoHaJu8IuFJL0LXGG8bD8EBem/ym+fxQvgMPyGd9DKMCbe4vBQbKw72JjQTg37E4vUH8F8W96Mo1noluu4HAju1lQZp+lv9KloPIDmiJcn6KwqrsUkyrjTOGmmn62Z6im3TDe5CtaIrCn/SPI4pllJiDiRLhTzTDLH2iVP7vqVDJJAlzUJEzgzd/Prt7iOtrRIVUiAd9gp5Ja6ad7QG1B3JEEn00vmcZhbwrekkhb16vPpDKmsx6TgUZSVzBel1+yQjNXTfLMkoyNoSOzBPJtAD2XzkiitDqWNDMdr8LTaXSjgTmRVlsPkWhGTrNlvD41rttMcQ4xbgYSni2yMUosiGKi0LElnW+gH8BOKOJoiHzr7es0+FUb8QKY54w1/AhtpeapXc9QG+AucFP6nPvY2GEIzb12OQ+JBM29Al/nhuOLJ7dX7BHwqBbP90pjGPzvK3miRrUfYXVHb/hNJ8w78MKwkRkaNIGr/LmWfOwM/NS44sMxuvUcCgo21HdP3Bl8BenFu1S8u5UFU2h4qoJAqrBLqCz1KzsdxfVoxK9TtZD+vVnKdWaVDfOXlcLmZpV0OmSp5FUzQgYlLX+NfwSnOvlsVn4NBB4+9nQ65+Ia/lFEEAX5fXq3z2pfR8Bmga3IzTM8+tb0LrKCUuHmSm6HfVq+xQZsKEgwoqf8gx5HefL5bjgR3UYEcKlBaVCaz+/9e2W/wSeAUDTB0GN4+PZZllhArOKoMbpRlz9WitolQlj+IOfwiTcUInbVP+r5N1lipBu88a41/gUTxJfj6WG2tjTG9iavUrzJLdkM9JWck9j2+YcPLoturN4rUtygaD8ZP815rN+XVOBsl9XPFJiwPfDlHbG9ZpgYoUf7cZS1aegYgmCW7fJI5zgW3QuHQazEt71XKuinmF/yl1jBs/eBHILoqcP0yFZSO9Ltnknpg91wZLsS6Cc+z4uNh4sPjkY4lm0MzAXiICB8I48RD0JzB72NM96fWFyXlyEg8gQJtt8GU8vJV3LiEdq9SNy/3qI6rgCocQzmsLXX++JL+m7aM4pZBQpW541+s0xB5ftKVKUPplskel9/1BQHOWjHNfbNGrjHxjuFOnTOH8Py9L9hvRAcpjXGUkqxmgi6gHHHzF/vtpj8R0mVdvw9PTSbsJl77T2ZSAVJrzMm/Su4t6QC4A1BDgjvXYK6fUEIAKuAEEi9LxocLJu3/p5lwo836OWdCoenh+iHfWI2RLciMb/nBaiyGhfQQtMRSVNzM1TNWpL4A3eD2xxSr+O3BOXyKTVM/c7fBqydQcLCKJdm2TqyOa68vqUsjq0Q4rtUQ8Fq9OaQYOwqnBZ8ZgFRtJGk3X5uQa30ZENWPcnHVjEoXRBTSZPvwcaFQyTZcAVyFrztVzu+GIChbXdwzAwF40HqqJE7Svbq/d/bhN53m7/U9HtV9NIeIPGt5OQjSNyAl8ow9meI5LOGCk2qawX38k8hMjONnSwOwxCd3NZ5u6ibFnQGbLyQRJuQ17O/TDtT95sv7eEmmQt84o1fN9C1HidGcdKGgB6vflxSpfrZ/gDuavzHQKtGOoPXDR+GCPvkm455Jc5/pl87k0sz8wmHEeQfY6032Jy/76YxGlwrboMizJsdwNVUoo92DfhCxA0U8Cxn8bHaQAHPlfOnsnYWG//GXkF9XZnBbCa7waiK+5o1mAaNBpV+mihdE1EGsDY8qE8tM4J9m4L7LprQRdKrfx7NNPjGrpnVSozeG52ps+frhDq78/VCuCmZdwsN/FF3A6bRgxcOPaetLuWgv69tkUQhgBgbnZ61sPORmG+VAbPhc72I1y8Cv6/9LAv3y5BR+5SH9uU3nPzY/KIXFX9Joez6yc47+QXUFgEU5XD5zrZgdaRoGXRhoHjpKwyrEOLygGMP3Rr10oCqHg/jsna0CPNk3EstVqZjVrRIYTT5QVgCYMxml78ubL4JEaDG5gLD6hNyVKn07ag26EC9HqRCjabgdScSYIj0fMEG/A3a7uPbAUFBUajj1x+1OyZODKwgBGGiFlz0J+ZQCSzRYI2/4tBGKsjZK4/wq2pRGwv7JKFBYaYM3HkdVAPiVQb2kGzwclzYhZlP0Y3d6AVboWsEePGnlQG9PrTDysawEzNvhs9HiABfFMuQ3Zl5p/paphAL3X+RWACkBMPIS62jO1zUnXXidZ4I1qg8mgQl9YY36aSCjKeuKyjl0g81GFqAn3b1vn255o0Nb+RBYxpfwR7QcjFccerouQWO4SU0cjq6pbORe9pqVnohsCEhWIcOlsHxM0i7MMCVjGkVzbvZdGs4RVh8gJFtkR7YJAHaifTUPx91AeE52QKb1uqw7YENfFijSqxAVw4pmn8ZdgTUkGEyjOJCrE7uRmUd0TvK3luUOkH6Mjy/0XxU5PaFGkX0WcdcmV4Viq5eip6Q7k+A/TZAsKBlQ3kzCsCRPH5wiiMbaYIHXiC0i89cmNtSAqjSKvGL1eqs5ZbOeckH4Gv2ERiMZkgaN0v3kICudX7wOqr4Pg9YFVFJ2D692KD8wD0dgKpOlVdBVa3iqrzKqrhqsAoqrqpv4Rwb23jEQnwhdJsrhnHGi8Nn0Z/M73jtrBjs91tkeFTmvnfFn+k+dn9V/vkMWe4eqLCMUmKs3f/LTImGVZ6f+71iTbyoG1HJIhGLZW9CMt8E6mF9+/PpvudHeVHkmb1kXYPPlWFtTN8Hq52IeIoKMaFFEPF7f8yEq8EqkVRlKr0CD4PL0zfm39X7O5O6WaZn5ugSkckp1M26cHQFiOD41DZVFRx45qwdf36YhTJvpyPGT1IsfJcZXq9e3/BpML6ra02j9QIlLROMLGjlsSM/eISBXYBMAGwp7ZuEc9NOce81otIIc546PIOjQO0u8L/NVutqD9BoDIhdvLi1ozFJRSod8nsy/fq87LCdYRY+klgS3yv8CV3tgH2eK3SZJSwpkRsfwILjbH48kgIFEH2JOM1A6ipZfFUPmCCXmwDt6mWvYZ24BP/qY0+Aw9aPtdgsQz71trj9xcAqiJ2mlYrmd3dgxaUqtbrJO8y9TCQkpB1GTd5ZHA5dAGaGU6Z8eNR6v/VqI9wG0fyw+L1UmLLojrRfYPzNn0iCRQvTFgUZ4XY1zISlPCLAmAG7tDd7RSfBF60R6JVyaIGZEILM2EjZg60muEy8kuEumpHuekrGoW+EhITeorUBAoIlVMfSWhK6zJoAIxOHS6A0yWJn5yHSjDZBPI3Mnx2K6GSAYpBtWdbmQpxuC26aThHfDoDFxt8RJ5GIs3vOUHzOCViPWN3aFiL9T6rN2H5/tGItPNck2p0ZQIzs8O760Yocqa1Y/zQiQOIfa0QgBgKHzN9v/PmtYdhyFN77kW1oQCg7fqPxJ4g/L5UaZ2MRQQSrxJrJNLZsN9zTDH9/ghi+i0X385jfHPhRiYLEAaRdiOxwSc7U33VxTkApzjJqwI/iTn83iHc/a5SvHTg8fqcqkUZmhRyeDXbVwhECFV5GLjBzW1uY09gs9FbXrf0cBNOZHDZziSykYdm+RUxk8azEar8I38YFrBWmNwyJq5ddoIbtf4mEISn3ljD/LS8oeA7x/ao7pPiG3ee+z7qxRk4rysNldvgoqR4tFXwOTO5fbUe9qnPGZsKlq3cJFcBaFhk5uPc9hw851lTRsVoQA7bJZ/e+D0cTPFWbSZhKnt5zoUSJAB7P9hqmmb4QOSUS3iUYoNYO9wRPHMXNkGGtrKPvjTI7qZMJXObFvHlO/iTLaQxN1k/EsuB4kDBE9yO0V38YVmf4jmWd/+awDIBeW1GC5NIGnobyeVfwXfKZjvyIhx1iU1xq3ONeJRlAfD3dPgrqL9sqCC8bHPCItXpv41V2O64Rqro6tJHtuZmdWyQmLdHeHvNwbeXmium/OAq7AoJcQ+G8rmrwW8Q3X1VoZIq18DdLC3utQrbTwGnCKPIi3GCHeXb708J8CtNAqQebHHz9ziRS5jKrxscPcxbLV/NKmcnw3WrzerhkCkCM2L4zGi+FUxDQMA2cBAqhxyX9uscpJzgOO8PmOYIo8xHiHjhzyNxJuOCOVkfrjdWeKbVOCVip5WoSKY7ddxUZjv35VuvkzwO3S0FyiuW9Hw1xMyChAaVzRfoVNLk3teAHrWu9uv1rWtsIfPCJzjiUjY6O50KIfrWyjiTVCyQYoITSlOjXSiPZOSuXYoSmp89G/nOsYrTobjnSkmr3drfJE4zM2mVmjGr2eE7aHi2bFuPpAQLDIRdP2bVus168cGkuYYFe2cA4RF0wCnq5ijFz4NaQsnh50160GbCuaQ9NZknTMC+bQj2XbKnRgByt4wOuzmaXvm9oxj4vLYuveDq0IbnkcuTQ9oebWJ6+kd8ZxN49FtGw6x2SKdsNz1r9pmevprETttOVWvE2zes5CNe5tpmwV+p27+BQWKBIbg0is58IihC9WjgQtkWsO1Lp3zebKVOKrjwKe7dMbS/+hBoLIIqzrlN1XxWEE5JtVgIX+lJL0jdwmv9BFtMj9WpuBhEfzFgh2mwUVeLET/PFMlBbmTxvhEN6e8j01WUskGcU2ERluZ90Dy0tS3xw0YeYNrtnQiXLT/a7qvP9pDaaMtJt4U8gAGw4Xs2pEi50u71eQzahaTM73/yKDGw4ZuHB3oEsxnlCWBA3QMOhdKznLAq/RNWiLrEh4sCP8lhIhYuHJ2wo4tqKFsaqjkJIrioAX/fuydMo66B40ZEYTkKKil4G7ua//qv+7IfxX9hq/bpJ2br4Cpknn39o7t5qu3IDDBewuIF+ZZn72z/+fnxwubX+x16u6uzjs2cFFVjInXb+Tyl98wBFyMOIm0lpJZaIS+j90v7QldcaiPIHZLd0TBumHePo7hDVvteY3TxoC/xMLLrmZZrfAsbt6sauATfuGre5ejmaPeBWjoRsGoFgZX7cvbsTtmHWzj2tRr0CbNZkO9rdl687YeAPdBq26DnEa+7FReT/myiwk3WnmcE1c7GPzF2tsEBG08echPPcBc15+MblwTNAPukKssjPeYGVuvXoZzAvh1BvhuPsGpfacF2eAARcMMiZMEOiKHEbsHsEOFd8pfiPOgbUuuDOJQlDpt042WTBW1J4HlHlgR0wFLm8RGMQ5X911gmZKkLlEz19Ghn2EVVPS8uo8LtQLli2qAXREBYw3Jy7R3ajz3MqcJz4tGNGPoUiPRb57Pjxqys8wHSttjC8suuwhN/B2ztI6GM0xtOIMveaKmdYl9bAE63afLTXeJRyVMvTrq7EVMKCBRgfnV2a679Vz1qdwIcjLQNzjjRbE2GYOYBLk8yH6kVWfcuYKf4qe1u9mnM7wPXIYLqWwYN1Tpt/FIfqGL73mq6Bvb/SRliZWxAzbArT6PtUa+BSRHE2rjWJwSDcUv5IPQZ+TSsD/KNWBi7n999uSZg42weDLqIdMc93Px9LxuCrzrcjQcHyp1+JSduWEx65HfiE4zkvfMGfuyuTv/v2DSo/QUwns9IlCVmfsTRDzr5LB853UA00kr79eecA+8IHtjjLqhgI18OoGJmk2grEYWOogBrgoE822Tfai0bu3m3kCxoOGsqrbpiD/2XT9qIJyrgeTdiOuSDncgpZuWFQ2m267u+KsQoVD/S9a/MNWTB1TbIxdAiknH5LX0VmgPHjEEOLXhVVN8VjFMulmP4CQG1HF2UAPt/KRay0dS2FGDMF7yrksay9kmJlrpU53jpIrNS1hrxaaC5fan5Vgof3jpVXs6dzTT12ksKg8y0Vs+kOYErHVQ8KjF5p8//GXtms6O3DpEEukbdMFs/v71fpIT8o4ybhilXzSNB3zQZGt/Tz/1UjYPAiin+NYxyHjUiO6HHTZqdTP15b8ii27WtOnf5PtoWFbPm7FKbKAHAmnO0iX1sHpe+gzd6rfC+LmTEC+AO4xxsO/xR2SdThHlEBi1LOEX6SJ62ytjYbY/SWXgMu7fTkK9dgP/X/kthPCuiB2GgWPoP546lfZcJnbn6rSSQZpCHdakB9y6t+5tKnldbDN1+U82Uc69dyNp1sQX3Rzpj001pO+SNJa50D70uzV4yOUf5qh8TglAxc0QdIrxG1/XMhGz7zJUp08meaLz8KeMTqftyhxww5G9yvnBWypvnghcWBB9UxW93Eheau8Syja0cQYfGL1MbFN11rVkjXxl338celQkBI0+XFkvWniwvrn0dY7SvHXIyOh1Kb/nmT3/YgN2ITHJCzinFYZjWpatBpem/uVpwbDEn8ztpOeD6rhbledDQf9wpZFrYvLzE0sRNKvBSGNs7xXSMjRUwTbdTZ5YuUXm3MN8k2z7/JP38FVj48nm32yIbvXRbbCbjGHJmzuYhjzm/sstOucxp+XAux30bG3RnE964wsHvLribRNiLHEW1JXkXzt/O6ywzJvJou+IgDpfW6gBhc4eot+igeIBSZ0A+fKVnlP8hhF7UqpdDjXj843Y/9+OeHVU34HRC79K/GwXGhPUe2GkUUMn5K0Y83I+W1D1MjPueIE63Q+owr0kFH3hKwAh64karRimutTHvQG1f0OzItKzCIBeiD3D80zDSXDm/fejBf3zQ9app+Bqu9vlbr2idDq5+kDnp4mTSroHHe8sZ+Dnrk0A8onKG0n6VsyhnOb12g5lJT7uREXH1YWj5+xemXb+5yMQpDm4fqaUfhsNPnJvtHuWOS1tHO1WMUwzM82h3W9+x2X8zvgnfPGCU6BJq7TVGEQliOttDzM520B8a5D6h/gLbV36vTPekVKKLVgrTLmhnpuRoOKt01WhuC88wj4lvPI9l+nucE5rdCQd71QazrgZzf36y/fpPL3IT63J6dpclNPMKa1XksnsM09qC4iEVAk0VAxCgUVC8qsimfnn9yHOJm09qGtPeVwNDXuFU5hrT5orIBASM0Ek18qbmQbiKPxFQwbA/gtSclKIGrN5yWt+12GhZh+qrn7Cw2++ZdoScTvY6Y8MeklNVuunNazVeWjvMQJk0y7WmIziSMhuvH8aaI44xhuHsnRuNzTqMKVNdVSL11EwapExOgMZFNT6pBoFuhg+pHuDIdpA8/rwbtaPw+mkQPewDSmtpnYjYfJK5w9WcJ08amfRLt/40qySHPq0T+0pk4wiRAph7V6p14XKFn/3c2khRsuFBwBLm6XJW/asTV89ZcsrL/eY4rZFqnaxV41HY4vKQcZM83LsHTCWvJi1SSrrLVOvvtMgnbDdfpyDOvfI3T6HabDbxZCbvVeutZDJf/Eay7r3Ss24ZvKu3uyGxJJbsml1m6k4aLvHYguIXEcSYatcbj+Le8hCzcgGIzmbF+V2TmWNQhYxnV+u0Cw/xVjOJaMHJYuTb1jBg1O6bCAQYe5Obo8VUr4NtVHtbCDsof41yeL+LsnpINOkBVBDWI7SANs259FrWD/7qL7FS1fXGOVpS2IN2XSjqMgGBvmESSH9vpCgw4/fMOJCJXm6N1O8Wz906LVifsmSP8l3eVWy4vB4U6IAWOOHPfAlJI4clbPenZcCRbzo21ruQh00c322+0z7ldXIgYCAZbROcs1CoA3srFdofAYBB8399cYufKP0PzHy4E8ocRsbTSsNp36AwXkOG0dC+3TYkGzFt198ln/HtYbr6jzDjFVs42hLv0H2Zk/b24qbErXP/D5mg0Cc+yHaM0X6/xoFUoB14LvmRvc14GIvQtLi8SOMVsJR3yF39FCxGNhwUWsZXHBDvPs12azAaGjfyg8YSI7nyodqaMmCArRhzEAQNTQHLUPPiSitaI769lqnBWY/t+SDOrSg6vb1/Sk0LHmNN2gkdXz4Z58RDvvyuGyN6SkavTydG1LAekKxarzOnQXEnWXKvkjDqKPcbqvI+ewDBxhrgpvSGZ1k+II30oZ6eO6G/DytcySecicU6rbwrajx5a/rzqemfP6V4qVqZ70nTfOCTRwq6NL3jEDJYjrGaKy21zFb1fAIOXikTZWeSo7pNoV9gTKthoF+X3BOf5xKeAMZDSpPEPuKXhvnnhjuCBzCUB8X03ekmTvGj9PfNSFMPWpFx3iKoWsTKkbRQjfuvaOwpRebg6wN+bpIdUzfKOdB1ARF7PRc7Y/W6WeD5asgp7XfuhyGTtrfdHvyYKZsSwBqUUKCk+SfdKvAqOyrkesTrrcWkeNBTsW9daJ8dr4kq4+MEZ73z07Ad+bQC651vJF/0MiK/gecYWkTqWdwV8hzNsgbrDm9AzJchIzHZJHYi/p2tPL1cCyGDoXbvbOqzeundgo5uEZUBhd/tl5zRjlPZ+jJyzLkkpMbzb/Z7aXjSsQV+Q0q1ezzHtJ+2XYQMZBn0lah6CJFUIBy5ZIMdf1OeVmj1NU5Hvlvt2w4nYf1zfSqX/BU3CzEG0Oy0fh+8zn/gCicRxTs0/35BjZeLw2C1qUsjZGhqZOgPkIKuR7MpkTPzCdet2rz0AF2RK5HCFg9TnqLNeRj2jZ/rA3/XY6KRkOycdpjMMnAcx1WGHugc5AYSWLYPDIctzrfvbF7Gt9Z6jwK8FhnZDnhxS7er8xOze/GNT727R9xh/+jx5Kn9KZ3KYsuIG3JoeEI64/U3NDp3+o3LX6JHE2UZ+NLV9m7VNZo7m4RvVrNfWYLfj8KcLleH1AIqxg0x7f2aQ210AJ6tLwfUsVvmFpUvv/XYyGQc1gomwWg7IeAr0rV5n5ZhC51tgKX+H9GWU2uvkwSp8j9IAtQRmGpuEsmvIOXsAGELdh5+bu7WqdQ44hxAOnp1n1Nla+3AbB28xZGltI/cMjAWnYyrWJqDCOh80To4XsrFs9xgqaHD3qDRAW2tgMtW073cswYCGHNhWWIDxGIfLaN6HtUGkIfAoh+RrN9QEZi7WnL374JftY/i1KqYhDYi20GUAf4ZU2Nwed6jq5Z+/ihYv0HTa6NOZNS/D5KAtLoH4U1Qm0sCCj9zevdDeYRm6lQ3ZeEBaTmdZ03otFScffE1cAhTOfi7VG1u1IR3CF/t8KMaElnMBZRBiJ5Q1egZ93+rjIBEJalO5QFC6a1Z1+q6eQSLvOgygDlQPoG0fTEz7CWhlTv0P9Fgviok6IIedFL7WzM3NRZ8Nt4LFNuH927OHwXGx0BTi94prV5xblXNKgcMd/U2J7/lbFRQno+s2EcK5gPUxH3azHTCfuMnGlXgp/v3aBLbiqyF35TbLB3AFSu90/PZ2W4xmA4W+UdY6YMBn52ux/69S/MWWZEXVdMO0bMf1/CCM4iTN8qKs6qbt+mGc5mXd9uO87uf9fghGUAwnSIoGQM26dEpJ8i0r7ucDluqlO5r+ahz3OQFPtKhAZhwbJ31OEfrxPBYFLMZ/RnYi38suazE/7ZeH/qOigUn7o3pn8nGUxLbOppSSTAO9Hlw2n0S28MY7ql3pBSUTQB+jT5CnF2l/qQHmTRJ1jjOvt6ePi4JtY0RzTMZFOCrOxzjMiVX2n1ROFiJxrjihLQvBLcJHu3G8FECKQn22tdFGiWqxyNMlW1MuDZyt/OV6+nROtiTcF0dMB7JddPQyG+PQtnVGarnDzrONw6nZq8pXE6nrKE2VFVT22WYxRhG2dBsHb/ZKM/JLqjY+PkDC5QJEaGvOKnXvdtuO+ha5P0vGwTK4iz0aZCPWGu+sSGxQwyXS1kMGboGh2W4qFBwJOSYOwrqvDSCrJSiZZfa9VUcqDOWc0sRU4dPFdBp2eDK3LNag97QJRW4l6hMXXFZU3++V9pWxHnfMBXBSEOPnkGX0BSr/EJglo2CjN374A6+a/5Qg7ZfPsvb+3w9CRs5nD+/vIRGUJwvshhDoiQ5u0QY8sYeDsEQfP8LGTyJXmvDrZ95yEH55zFtZJOR2pQ6/juZ78e87uQj85VDZdwh4qcR6u8Q/1vKatMBdrtpvTnm6u95+48rTHMBvS/lssprHFpTH0vZr57q2fX8uyGa0Wktngb8CiWJJucWu5T9eUSnWRdWceuDbDCmQ5XtoEOL+VxExmgePId8QhoqUCGao4eJpfTtpFlzJgk/ru/+URzVNYAe6T6/XbrsEGSeAT++HyEflZ+wQeXpjvZkqP+NE8OldPVCVKlShh+hTXtsDnYoLYIaLpzc5cRaMdX+yG3Bc6GeB6yYNPMlgtxA+4VRUPzBSK0Hgkf/j+N1eFJ/9YSQj6Dv/YXqFqQIpiHDDLQ37zbIyCLQIXu3d+4YWmksArEDnqne/K6u0AojAVe5Nen+0hfXiW/imKlOiNR4J7yoPd19beYHI0Q2PtOQ+2EEQ6CXZY5+K+VDfOoD9DFxldoJVI9i0Ch7z3yIVEgUsgSeZi6K9mDhXitc2ZyT/1XWgn3pvOMj0qbJn0n98/mksao0K9Dy66T1ZGWgwMSAFGk/1oe5ZGDPQu9pHGR0wKSAFGps/tYG6WwRsIPVUn+/rqfit0IJgiR3oXuWLpGv7YZmpDDPGrlLUvE8CV/mnBmSyMy3eqqEVOcYJpM/qIiiyYQoS326eOfUSj9TSpud0jAl36yzIE3Jg9cQV0Wkxsit8FR4BT8PU2obhA5dPzaXahC+NHr+iKLJeMQXMGHka6y+3dS0B+ELkqTdlQ2Rf8D0NW7Vg9gXfU/+pU4AKgD8AT7ntUn3AqaET1JS/XHCsyQIzELzKSz02yKYExzUUOjrOevS9wVGTO4T95ipmxTcuVeizIkmIrbTU8x39RDiHDxS/0//DGj6RI6xA6GodbElyCIgBupqH90oOwB+AKwFvtEumA7hA4cqO3h2XWQxYMXa1V/21pnAUSCF65Zv/MuP5wlDixcd8L9RLolEu9w1ZX22XCuiVANteVZoaa5ctS/O2+hOad6S9ORgxd/P80nGd/LSKuRoQHBO2zNAL2K6MkIauW1MjjWwUmJj2CaP9/VQcXp09VtSinXGq5fnzIojQx6Wioo0ZC0rq8UfMAIE90PIULi10AC4a6MwCPZDMBD1LuscA27Bf7DAXfY/CVdkA0w0zeNSju54NB94+G27QVUYX1T8BvPEjLmoRJGo4B4D3WRrHVqd/MzMeQqYBKN41kplMyjXOugcyrhNDIlIh1e9MUykBU2tKA64BZNdQMjA0iKKlNTbPneBJT45NWoreeFPcuTCWFJ2iTRKKPvfs+vL21SoM02JyJf8xR34JHU79H4Ty5b4nm9yv3x27l1Ul9dtVFg205+rXb5/SpzHRmlyvf94H5aP/0yosenWAskUIr+uUoENE6ujkFmpxW/QeCtCFNe5aZIXxuhmpu1+YxZMPfbICDrFGJabpATc4OsDOZ3hCFAY0ZzE72uepeWb5maXllk0DYzFBN0HPonMUHOJszUY9Z3WZCbWMuAfXBc+qXjgkwK5atTHz8Js0uvYsiQfUMYsSjLfyjvHtjE4zNvFfac5criPVs4FokSidH4nPfVSsY8zGyNbMjfg3feV27ufbpJ2U2dnb4ReAsllE5lv74a4AZ/mjGIcXY/Lsbtz9Rk8PfwyWlNHauBTutnVgamK0NPEPwTOdyCc3ckgPbBZJybcnEInSVQ8lsqEKjolUJQwxp8iiNhZfYXDy2tfpfvs2X1qKXDd4pvGek1ncBH7xJzpaCgXJMaPD+bvubedN5b8TLKcUOTKnAw5+sjQpPKgqqgEha2lOk5iqZt2d+4B1Qu588Fdsf4AeVobJHndIYEF4m1aBedFBD1sHiPxLcthjBelTqwWBscRr3HPXZkGh6hMrRVG2RV3v0UgIz6a8TDssO8S6LAZn2SzAaRigxI7bRxwFkgPiVgk5+1VuNIymZtgOgUsbm8ja4oLRKbIukjhBv5aJBDbKY49iOpcUN/yhoaChZYqJ5Uu2zjNZb1qTmLL+j8VggIDHH5SUkrUEuWAUxOQstJkfMDQro4nVfgZknSCXOVT2to7M8/4l7zAjx1nEYxEe+0IOyl2jvE33FhVFup1wAHbx8c8HAo9VCrRKJzzn/xNb1QKJKEHdbGin7r9zgO3xkzz/PjASGCOHXnsb1fPksgoo/1n9ErvCylhY6VH72Eq5ngy6HWcvtl+1Vlcc66iYu+NM2WfTv/yW4EHatNt1tKq1LeNGtj2LDzX2UHl1Aoz8CxVZrlVkGeA/HicOxy9m9j1tFL+GR3Zg5Jzo08RBGAeyJyhJ4nrAXOAiQ5RxjysJsPoveKjFocHPG3J0HIH5h5/3RZbjdOqi1VYFZeuILuE5uSBsi8SOF+F5e+NLiPhjh3jIFsL2y4+Kjun64sykb3uUvKqQ1K2tMezQIKwX9PIu2c99kAOKtWtfASkT317+jLC4euRPAMYmVvgjzxSWa5d2rZ9c43ydWpC2mU/LZUc1xskeswu6YBqNuxOJ1ZQSnRiBrmy/XZhfdkoBrjedorSoJTKr02QA8sliXIIN5aPBDmbdloCwdXNj6q8yQCKj/NnuniA1247CF5GPxTWMdOHwMzvDlE9IB/BjDaOppfkMNzWnviE5dJuVYpr35ek6YOWT/N6LYgOT2uxBjyqHv7WDubj3nCXldiv7K7FcaOyOoi4s93/eXXWQqUxs7TljPJCxuq+Aflnk3YY8v/fJophHpEn5Ocw32neWjivtzAB/JAI4bO276vzPW2+tuqulNOxd3ylmlWLbzXpxxAd2ldrn2rvjKRqgLXzjrO54FjVfFKFE5BmctU/9eH4wageZYGsBPJZoV+sE5ur/mZYHuS5QQNEmRhcsCyWXGsvYo8QzrgaEF0/2MbkRCz+4CkjSlz37/KHHzSZvFNEvelG3bMygj3y1ltsiD9YUTZrj0vPssUD3Q713G720SB78WziC6fitDjGqsnsJwOy1NC8b0Z1Mi8ylEqfwjFxM31I1jHi2DOhfMwvJUc7xDYMfplW9Bo+3FLNpEC08HR4F2IO6DgSw6WmMROQUIllWkRqZpWbPc5QJAGyIgQMOhTRqNsCJQArBhFg9FNfVCDHCzrMu+1JoigvPy/5NjH0DY5c/PlvuLt62nyvm5r+i919d4HjOHP4Rk6EYw8dE104wg+LXSWFrL5a2F3tUXeuH4vCvsfUB23giMO7I6FQXApKZeg98VdeltetjXvAq41ntrSgHTllr+Mg+cQADnv58LG0xHg19nfZr9MbrmTwynBL0nDw9+GJ98fYctpsnvE8S41n5tWbHjFUvMJH3vEM1A2upJzcvCdI/Ei8Z+veBCxpgrfy78QKnHoUdmEwRXExqjIhxjvZoYe1/T9AEMcaSAvafuRfkug/nEbNwj/4tdl1HPdphYvtOdUaI5cuHxqKo+/73XLmwPk7kGz4CQQ3oQo1UWzywT8ACFQIKQSBk2Al1mOi2bdQ2ia9AMFPfdnisKpCg7ogCT5gJ5DE4/HAiVW8S93VllrdZCRa7PdpsyZCMPUHbHqkigRPBdRX4DCzOpHDSyodVF361WU+CG2jmbQPlO7Dr5RmCsJn7HsyxYohm/rUVX/ub73iYSvZpIIgrllwlgKiGlfrtQnrRUy2qeR85XmzZtPg33hDqTds51VS9giPjojUBMJxULQjUaEog27nfveCJaccv7mxOzch4YcJ/hc0wa29b5YBgJRgSAFQSlJfNwpHRF1YXgh72ndMq3W3RUYzZLVoBhDENJadTPEH1IIA1x6qSVoS5G5n4LOs1B3vVWA04ojyYC/OzWMzzzk09FAsKCN5eC3p187ayBGMgY+N+bK0vYgk0mxNTWj77XIWddOfusR02bA+BPA0XGQqmpU34Nm/x9NAZ35km7Sy88XiU3ehgl/u+AW8A9Hgab7wTaGyjjappLAg3s/c0knSNZk5zxLy3X0LDm4RxZZiLCIVjmBzM1Kj++m1qaxE2VmVMWJXuOy9ICmXM5niRBiKkIGr7jNp8kIRzLZw1IzsDfCpQGVjzqjQAB+e/rpJEoGj1PaSLjHsHkv5mVUdFo+HpA76s/9wiyMsPCksR2zTrfGdeV4lIO/5spDc9imHS1ISzTmRIHx7xlB6d6MUhp+sDnCbCW38VZRfw3FSdnVMm54dvN1/g+E8D0dyGhzjKYE0DqQrl6GxEePoQFd9u7HGpFCWW4kVF/GjTmkTG3rbV43Ypbp1mHTo/Ugwes3MvFaWzsNYTK6Gp7PeTAJC3Wbff1oOGTgC8DOkM0zLL+4m8ILiVOWytTdqeQl5r5sbGAs7ys/UMtVhdEzqVF0MS2WTpVd4YzLg3Ujp65b+4Cq8yQWkpODviu4iK/u8iyV7BxXC5vgiHSyk5rGVDkvPAfogFvfTLgduQPK/yH59mutZz+AJ8gEs5gdkEblWZ6l4k6/q9ifzYwasnMOV5+yNZ4t1Ag14Cq2UgBpfkb8fT7ABFc19BzYc4/zCqq/DAkvV1oyfj38h2hU0Pydjl2Tri4FaLCMaQMjYYh0aVZosMqcNNWbDG0PujMJOCAVhjGhQ3zHvdynr4od7aQxnxQQRL7E5TAkwfp2GLztVOtc/aKax2b7u/f2y2/NlRcgjXaXWyQ5kOX34lJUFsT0Cmg//Hst/tSzQ4lcrtKlWR3UY5336ylZ0eaTWjq2qs7EVwkBl1x1CCK/CYKWCwRAhvVDTmQEjfH7C/T95jsl7adwOqK44kegu35igyfET6YVvcm0UjU1U+I+fvz6S5Jy43LQKgQ3lS5R9qsCV+3gBflrqUXzDjJ6q+UuweJJXGmM9s77hMiuerg7nqPCf860inN93US4HMLN2BfwqZscKSxDfGTWwklJLVUYPWtV6dBhZ+kw3oj2nsrtufCoPx9xf1H80+qldY04500MTLIBZ5+V8j5X3rxxOSXTa8SJAOdqd+x0GhgfcohEaHQNwdCCdaxFPCFgKhB0MFUXJntJCGBaE/NJ+BL/o1W69InJHaL9FD8dBySC7BCVVL649SqRsmscQuNEHTs9Y+8KRB5tFlZVOPw16HgNZPJxf6tvWDV8OpStWBhc89AtH0pFVJ1OEFK98XbixKvQgOVOLxyItAdxHr6PnaMPZUkj+kDRBcc/ZWzioyf9SWh5HBJXnDlOt/dRX7HV8fvDMvKLn5lftbBU2tnjW9zyDxG35xDgwpwHYik5YT4iVn6Pei8INHNEGJPXq9/OHwrIolGYlQWWoveGOC2CvQ+06EE544qo7iqHv7EFq+1YjaA6umdVXUu7A3Ez3k7qnc1+HHETJQ3CnYrPCy/FvDnzG1O3473QrWv2eDzYZ6Oy4jKbTwor+xeIPHSJoM17TGxzfmtbEoes4jzaVyOmE56FBlbU0IQswe5NIPNoG09Q+7bmHlBOilRS9TIDqYByDDe69j235DZ6FjHs0bpuJ1sjruqMHJrzEJC67jUxMMgT2EYmk38W4295s4KyXZzeGcfhhWA21W0aeuM3/pq3MY7ric0/3X/xN1NJiv0Ul8klg/oUiDNdG0Ld4Jin69ttU8N98398LSodlfQ0D99hGGCEBa/t5yBgCbHPDsSPVC6Hpf8wc+rEhTHoUpkrpqC90AVh1NhMTpgPoPavao5a3lgMyEEJ1eS8uKvtXWYZPeP5DG+6e/4u8m6dkS7Pvk+Pvg3ThmZpeZYL3DENdzbGDObM76Sj6bXqHoEwx9MyTthxhbxUvpQKQhpBS5SeOvmtTeuAuXa/xtHoYU9doyZIFbOwhaCR/yq2q2UVXGURs4vA9RyRjr+fnO0wHtJfCy+sQBas8DTY1IYiyM2roWd2UqS85AYuphuD5yzVUWw+mFu3Wui8DapcRzxDkgLv2XghWOqmwCUkEJgKFqm9RPHrjzQ+iBdJJPSR6OnRSti8Q3KISMfVjQkX/NwF0z5/HGcb1DonJa2N8AtQovDmv8ZA9ih2svpc/NId4T4+5dlpV3kcByVrtif8phx/DWSckk31MBoiNJGflOSZ3GHHWywkUqFZC2Bc1r5FK1mgFTKVBpqcxEC1C7fM4c5TjUlvQxwe/uRGhAj4j23oyQVVLotEd0EeJvnikHBf5Anq08nsgbdTHOY6pEvD/DYA5RFDA+ss0xUcJ7yzdTOAfkRyQhIhYKqeHmbiaPPuYhZ2RJ5rKWy1zrLSzcdZZjoiEGP6jqm3Fchk6DDHCdnOkpGy46epALlDxuhHLSE88w9XZOXxIr6LyYkYt77uabypT609Fxsbe2QnzUQIbiIkloNgMW35amEVzrM7SUxynGcS1MEvh5A8//GWUH+SgBsulkbYbIIecLpATn9fuh97ONsmH3sIEXAdfEgM7qth2pRvNrvuNmplilh9apOOBIb72Zg6K4XAUHDK7AbhIKYic2JpxFw3MRlh1+r4dLSc5H3+PWWyc7Q4m/BHg91qkhNYtQM4mrqCPtn9HP8Jae1oW7dfZcPESnoU/yHwN+Ht8f6Rt2e1uL90yeT+9PDVv3vGWo6WP8xytqyVrdmZ7yyDTI7Q495wf2KtX5bsScRMNr6ZFctQDFzKntm5mwXyjdZowBpTnuwss3dwMg6/w9Bp3Xnu6nCiswV1fp49L3+O2o3oX3a304zWvOwPruBsJFjNV2th3/6ZuVkI0WjYvo3ixw/AC/dkpC4k7eyoHpnUxOITo5BMPI1JGJQ6hGiH9wsPcfPe2WY0th//cPLL+vj7BG9C/mPd+LnlXz67S48OYpGGe3Pgf4bw/443wozdXv0JzQrpIgPCyCfViQGmhp/0WwSsY8c5oAgmVmgA2bKSWTZwBWOIWGLYz7vBwwJsYT/qejOkr71VGes/cCk8h56BEw6Yza3E7pTzX3V6VMNem1yeqHg05wRjdR95dWhTOPqO23q3W3WI/NINYSCn2PnfuxmVvphRJo3JcMcwBfredVHc4Qt8RcSAvEEo6g4ws1WRM30PacgfbTE6nFkK1J+QFor9vft2pwIqqeNmEiPcEH3rvtmHUCquhO9bNwXvId0opwaCfXbUOctm+H5c8zixRlH8VLnWnlbzvrDyYPvHpeB4Cw43/i9ur6oN1sFCLS+3MwYRz2TRSQ0mM6rxu+ceojP0w4OvooQfldu8WEGLTlfk3gcK9nArB7MQHTeAi5DYXWsB/YWFPmFzDE4c3x1JCterx5UTp2i20cW6HSziWuFs+aOlP9fYHnNnhZlvqF76pDiwGm7gv/7p7n0wbB3s9jFAbMGD0tnCyfYsaGYosSx/qBIMO9a8uKlUtZ6XEbG5xvQjvb2nLLQQz1tva8Gz9rCYvh7TSbkfD1Ej3AnamPQb/nv+AB4BIatwJL/DN+04mgoJaLbeABv7CWjq4EZ8J4SOE+FCRMfYulY459FhOB1nHI6Xb1AAVvVw/34BkScnWPJeQYSW+YuP0tXdN1ixmKUhf3wtHp71cJd/+XuiU2NmO1W+YMSxHSABMUpcMHvPWFYeh7667Sx8rX8sZpcPyw9Px5YlcC/33WpbkShsR5IoNl0C0KH0UxSg/pdvl47LP74xuss0V9U/HDvsSx6GMkDvjpUbz/x28Baap8q25SwQbD/IwZEj4xv0LC8HrsXfHZ4jUKOvChiGaTJbVD0qDsbDCvq1woj2wneTSG2Syur9mmFybJSlq7UZWF4pk2RIpvudU1dfakUzS5g8IAmS/WJM44OYbjQxA/9zZa7rteS1L1aKFgv9nb03LfUEng0d9GTvM6c4BROKXL7PIMg7j/W1rDsTcHfgUvmUdZ9iOXg0OZJabmOsF+xSW9FJLSR6J9blo0vg5vgOiMEBaRbFQfJzGkeKl3sc73fzmZAmIWOPD0pPFHEcnhXnjTqhalvq50fcR4DQGn8ZM1tsK1ovWot8FEirZZvBaCbcP8nyP7fmr+q2CBAmNqra+qcsskCzWdbFP6aopesK2fg3NwB0RAW7INurvV5/8aDRxhY9IHapWW1AoCZgduG3BsVsGEGXgrLLjc7z2eqgN3rV9B1JYuU97HfARjoa87btUMf5R8W6wO+hT0yH2YSbF8uL/O7Pgtk4m3wdGsE7iJnfe+duHuFL2kEefE7p5Zwj9B/+UbmKemGQYZT0DvUggcS4gCezyf037ytXmxHoMUkCjpWkruHvb7dfUmCYc2f1Zd6hXggLYd+dvlWkaSv0pgb5s2hbd2WsBFSrAjrhaErvhGbqwRZwb1J6GcB5v/UhrVL6aaBL3GC6PD0tM9/mIVxsCNA2i3Pvp9asX3A6mfgD2XExl/Dhq2e2ARPCGI6myOHbHwuK09mvFDa5sbbj4M7tLnzyCzUQK1Q+0xjq3kNO92C0Myop/9gVdDNoqzUEjtomyWR/MKuP79wcPInN0PVv6R9u7AccDMCeDNzcTT3vrssjdmNwRUGwIuSh3SjCOXwT06RewM1CGQmRNou+FXl7u1kg+nAXQy9DfbNwRySwb9wB3E6C1+II2ZE9D/OLsxhssMt9t2aIcAZk4ADSz/ncpGKVcPbB/ab4habYhRHJhEVUMJHYTQ6RBOMx/iGGyJg1AeerK70R1QeO0Pg9QwK1Cyc4Hj8Clb2SL5dtj8x1oQBZ9m4KUGE42nvq9sTXyBsjdtJ+sgyH6v5B8x93vm/IZnUf6w4kJky7YwA/FoKIXTtJTyaNhUU6KW0RTEDMdKebk35yhi5O1LzkNuPDp+tAw6uwSuK8ofuVtfqF3Ezlg9j4smrid3A5J9o03TL+5varRXRUyjmXZlZb4ICWW2ovJXFu0w8GNpTcZsOElaGjwfsAHHKPdqAW/Kev2J/BEIQs1LOJ3P3yNTZqa+b3U9hAEGkvGZGc/bN+tptYfqEDeQvLOMtGqYCvVQfjw6UH04h4qQ9D53q6G6mYxpACUJG2uvnOJtJeHgMbEH7zkl7CZLIyAMoJNy0fQ6kjvhVRy04bqDDwgxYbfSFrV0+INYjepLCQkDcWvItmNl7AMmoT4E1vKRt2QJM3tQHCk7FfaDXejVkN3hN8jKn0ktw+qyhcGAwKl0pRv46Jj5kQKE5n2huZoRSUV9zgqWeGgcR7me67keereBz9TiOsvUuANYax75w3r7of6BbG6nSJCHM7dlVtp8Zt7hPNAg3pK2+kqSWOKt1ZF0A6VxHBRIvOeUtKeiKeE4pO65qZXPg5wijVTUcr0vzXomhaQu74wzc03KGEed587wlNKrER0YIfI8jenDJNi6rgKw3B28vtC9RSHEy5KIRQvbgsoH3vQNyCPYcDmgSIeHlgHo3BJ41tJwLk8PmsFRYin/V4SCPoj9PgMLPqHFJbfLnLlFRpARNyJ32YsWoxI2S46huMLZ8/voZR95UMZp+JmRjlDUnfrCBy7Y+0lxpK5LAS3u2uPk+1ofMuhcT0M+LvDD5wqS+Igsi1nOcxV9XB028XK+QMLZVNUiwRc0ld0QCbtphCEhkuGVyyXc4prmh4+B6vKt2WH26k3eXJiHN1KkCkE4wkMO4GLnrB13IYpAfrzXoVoBM0YI2tjza1CULccwwjVz02K9BwW0f9cP/R/2d93lD3mQdxfBLfURyRIpDDcHpQ4UU+NUPOMCY2nLhzcOKxCpnDvl23R2feLRTUzomkf6P1XxcUH6SxQzpksbdWc2XTlbubhcrpi+3ZaowyASS67/H0S2/Z+OLXgm+AsA9DAMuMPSBacp2rz8X7baFEayVqPFHOsYowBoKOBax6cAYEc5B+dpGl3u2Z4b/a0CytdJvgjGiLFTcG2PWO+UFXB19RQGcSc9WTmvot0XTT4I6Wata/03ljV6nMT3lYaQSWmKWjqt+0fd+JCALzTdELPvKoCsd5kbUGZHxgr3YK4KIjQ+PNbVccMbdev1u7ENWsn6iBE3ISsPHlkwAU9WZf/jiRcagU3CBQ2sufjO9FwPKvkXVi6oQXxK6sx6cRBluHHyM+Cf8gzodsYZyCw8A+zhZ+iAP1VtqKCKno/P1QRLroEKjkYBnuQx2wLYej4J3ihgmajgGtqRUG8RCmF/BJWuT5KWLpSJyHXhX5D4iuOPHQzcU2nlB3LsF3vLHEuV4H2Bzjl+O23Yt0aMr6wSoNdUrJZH75S0aELS2nstMPcOP2v4fF2X7DChiEV2lbV3/uFKYnHIdFP6E1D6fgWrzL9gmsvPDLoi3/e74F+mW1sdy7uOrbaGiAsE+gkMuIPQlUoX+D21S5W59cgGJ5fmZvC3x/2tWebxSA/yx8d4VUG6G6t+T5xyFjxX1ulumL1BLo+/EngfuRzkbwrNptiw/IMHP1c9RbQIATImrKlA6SHuVUs+YFS6wOW8N1mEHC4oj9JYNJ2E/UI0ZFEmjGIOT0806CO1rFRVyC4IETPQW5wLnqcAZTqPuYFFuopi5RZ3RHWPt01gtQTwSIEfml6mhDVTeZALg6Ep4lUaoNN1um1Y7Ti+uICMVtyMtktGpnmllbFiWZdQHzZZqUBLQCUqcVJfuIHKsabeKrTRURmQC86a5XiCn5hmCggubqAkGyRx/VFd19eSsUAn4X3G6r3gCpu2sGWT0lkAAFoccAtsbOg1fL23QpyE9wuxINBJKEjHFR0A4haPNtjP0Aec/egEaKQ+UxuMdOIsiIU/rXMFMVn8PRZmaYDTYjrujjCcegzgS+Lk8BhfPJgt5t6afCOfPnezKkwHSlqZxzJ+pNiCwU2qq7qD/eFZ7WZb828C4BL/KXPS5ekjWASqO9qnMHdMujeRbUvXqHUg8rMfWWBZkCxXPbJAKXDfY6nLVR6fRVLTs8pgMGBcVxw9gh3c+wlYARBzVa8n3mNc0lbLiAVLKBI0yKvx+iejPXLylDkMAVGF2RbitV0iDKNjUdT3EAFFUwP1TypwVmYoscW6Quj5ngvz99aAG8oAgJ0W4Nhdu/EuFgBVAXCKCAzTq8HJKPQGd2zPCU4HEBQY849F8MKMRHwXpk/NWfQ0Qr7gNJDCOPNPHxhU1i4x0lbyWeQBukf1SAAOAAwo6onAMeqXtCXfsd+ew34wFycd37NE4DBuzkujc2LcOZO+ziO2V/PG94FsPr+oOy/TnT3q8lKx/ASOuVsUXl5ylWNiXyolVi1BA4NZAHOwVKnFyNxVLU1qiVoYLmFtdelZ6xgGS3qCAgB5c71kJyfNRWiYAA5Gou3YWCt1CeYsMNZcL2VpTQRct/7BTX0QTQs/3YYwzwQg5c1FLfR4kbaEBwA39MyAGn7GJbs4ZthNlX7kLAfgnABlUleWoEVCLA5SKhk1ljDzXnXbEYsajvM5eT8bAeCcA+PbdVgAjvNueSO5DDMBKlsrWLzBGAGwyXwJ8WAQE4Ax0jy+5QAG1vxZaZln9sSOe+yOywdlSBdC9yV5zqPLEgOkg6BIyT3epwvh61enhHQ6YWBshGZMBsdQOyj9EQbxNni4bRBUz8GljmeEjiz3DI2EZ6SlxLYGOhi66Jrhc9xc09ZkUTD6t4M7NceQwXqnKemzv2gt0nLQ2j3nFx734qbvVENi0dj7Lgj5gvr+7LDxCHBsDCwb8fqHHJjYdmuNGyRiZrWd9Xnj5pw2FSdLmAsaWw85l5G2brnQhARcPtxcj2NgBx1OwrDSiDgfYsJ53mSlMKqaUwEzDajT0QAgcWB8ywdDzANBLAIy2Tohjo25Z2CrBKABwKDXt0awuAFw/PWtEAAAoCa/9YGNwv59JUjvyYdlRpKcM81ph6VFry7qVKA72cGPQzVVOX5rjWrBHWjI+KG/zpoEB8tbxw3twleqCgBkm6lbXYuOaFitTdlhqjZTI9kNFzJQZC87sUAl+0HTSzSMNHbM3nIdfvpiF0/0yXqJ+WzAh2fyrDYade/fWl8L/izGUmVTVzvjY2aXK49Jtkm/Ep4x6HROxo8wCtoW60ELu4Wj18soysELsnXIAH8BoJVGPhRvNiL6YempT98zTjhCZD0dAN+PwyTQ3Pi/Y6uWMEahSUgI3FbYSZJOtwis4cMaIal9k6OJlOkutaotjgYAp8KFw/eSEbHofkaK/IwqV/Ajowm0t/n8ZqHz5nHyAD1Y9BCc+kwCBs96N0/QMLtTkvDb8cEy98dwVrnPI+BUvOQHtIivwbdXuO826ATexoOGywLFK9J+5opJA1GLXxIRDK5ryrEAXDE9esNvnzcwYRT6XQtiFvYbqMMemnbLF3arywmV0lC6Xx9YFPVR9Cz+Qh4YTI5mts4toRb4XhbZmOROpsvM8LaIZcRfK1PEwimb+mkr8zBAmqoehpt8R5OnKPbgsVSEimhg04sbXJMFnEng6kmKK41x3sLJLelkQptG5ZCT9I0Sgdk9iAN9dz2PVlqa6UxvVYW5DFMsQG0Zy4QPaIJlKzY6aMK1yzbfbc4abM9NcGiMTx3XZFuQY97PBA1OVCxf8YEFYrILu7skVn7v+cUe4FPiRpeTHCEYsrk0uCAkaAxojMwloVuGklx9B7q8hFusQxu/718Z7ngthUPMIohHyAXJtXWUpEHE/7zcC2H7iSAy3wgSkp0w6nmWbK0xnn1JIlNz0ZhMiUCSa6N5d67xq5ObjIs2UevFG96a4BgULklq+93/9IwTpnOcfSUc93Jp44ZDEmtX29WlEFxHVdKYwGmU4pPzr5ClOvtzsBBb4XlYKKiPmmy8n7p3G/UNKHouYEac/9yPqy3bdRSQL032oa7UOH5mD5yE9yNZyW9k3qE1tM+2o63kLpOYXKRtvcafwBwmoSoFIPrhzbfAWkByGgAb7cSVsscXl9iD0qgwamV6cdu8pANKHiKUZssd59O+1LVTu3n2b0sS/f1/irfOqt3psk4sjpKmeUsnCP4sqy1CdDyUjJfu/peJ6gDTxLICJmpVLKRjhfRtiElowHCxCKUtHeQlcybQUb8YgbQekzNng6LOxskzQjChbW/1U7fbfJ5gAmOgTc+bhejgk3TLCw+ka3CStkpmQUvCAWNIw90m0S4UHqZIdjSu7HddSgt5i2XCHuJSU6rY1ERElHmB2gqOlqMWsfWLcHFeZNGMtYqlUZ3a+BwHM+1U9NWUwFU+KzRdp7hO05ebbToMGBxm168mLzqsQgOa/fa113cXQDLQ/pg/YFLPgfAsk9h3MlamGlZNx/27XabdQ7oZSievteTzTNkptl7aQGyFAbFTMVuZ5mOdRe1qUwM26KxdupcnYdExD8R3PjGrRbpyr++5IXQ8SDLJlJlYCpvFDZmYr9ueCbGsVT2f1ggOcciGpB0b9Xj0lM9uXeZoI2ZdiI0gxJsVThHt9a5DcKoPA1hevXDGZMf8HINeF4QjAMb5/GzfNu2hiZ8cEs5xDisy61Zr/HDluv2tt6S515cKvOz0Mqu+00NRq+TXfHQX7wTj1l/OCgyE7Xwo9kjdB3VwVhANbKxbWfc+9iQthAke/No//qoQCcmkHBBCY602cY2nozzBFZLEE+Ev3In2Vrurc/HxURE4IniK1iriJzcinnIL4isHXv708lY2HocZefm/vvxfX5Gv3M72pyWESqQpxCrEEUaTwhzPdXB0RFx6SqUDaQ6Q7Iq0Rxn0Y6LoYN1Lic6d6+rpsinTbea6ehKRUhGzxXU8nbPNr87SLKOCSsKoREh5PoOkm4xXnNuOAWCXFSgVri9Qa/JF9um5Hdlm21iR/JDZkhPq4pAdYxLMgHXXQwuLFRyMLTsVL+QKDBNTisbIjpqM+ZLgcLFXV4bPSM1wYKZviRaps7hFMIbL1++0GKMMzurb7/XAfdr+6LKZvBpyfEAF9J9GYSDCAOjRNsoduK3fReW4/Jb4t00ADEMFUIpVUdvf9Ke7gtW+6iwNdjd9+5M7OO2HqdR83KCINl30zO4CTmTh18XLyLGLHX90jNj6rYOo/1g23z86PJS2rel1FHWYwatcqJyiD4doHb1XAMBUChjBouJVbu3Sl608r9/ZnxjoquMTrI87PXX1cVdcYSus1jARq+A8TVj7pHyR7la0kNQy7fXhOyLJgb/5aOEGypphHq4CAWD0EUHh29S+sMe8F8MM9Pld4HrF2ckrriTPaWZlQZe5n94GC9AF/PQOToAuICsyGoEUq4tYVYgEQWAOIspFS1CDiU5Cll8EDV/cbf1nRWQDOgEUAQEDpRfmPCEIEV4fNSsqGgVZ1GeN+evpJ9vKMNiWdMHpaVIhLKra2rUl2LAwCKt9kHTyF/R1AHapsQsjovNfxSSRlsW51MW65fsk31tOCU6SmggFwdmHSqNrdK2PA0o5UaF5enhQWzaaPjoXWAnx/pUqhJOk3k6KoymqYe/mvtLXsAY4TRdLVlLVrax1oht3C6RhTkZTTmC42lviZG6wZiUkkJkwyJZY05+iQQxAb60ydtjmM+xK+sedaipDzIJAvghQqogoDB/VRmtj3QkynIarxgQ5IS28ilEzhQI5BzG58XVb8qn7a8kcx3G27ZbYWyp5yuMaZ3sOOekwUVE1uaniT3FSmI8SKba3My3YCy29O7UymBu3fSYR6sfxchMtO66ArrEWey98LoE6V+2VoNI5rCvpgsu+uaP0njVcZSfR6s0oK37DM0YZdbKz4VmYZeV0EytrAJk3i4CrEBofCJz5RvJQlC4Hve7MyWJxjv6zLk+7/c+jnD4AP/gKH+lk2T6iA380+afCXu2BA1/pM8/bGLG2u1qdV6aDgkqzwKv8GGbx4xT0bMNMM18I/qXb5YK+Ik9/EFZIySl6WNkrVOLA6Xe9efgf7sHEGiqfpFiYHD8l7ySga+kfNAsJx3zInNQs8ZeZAbB+bJt8CuPV7dh28NPf9rTvslC7sd7dgrVO5FTNUF9gTuWNnx7AtaKx+X7+I94XV22oKVmQEV2q59bwu8AFx27VyXr6bcd856aQSNI/5u+T+wxR7HnLToSTw1+3yTP3OAVLEco9+1iC2y5AGPEhSY+5sOCaUpikF2BBpX0T/Cgf1gYZLlcX15LMq7G+T2UnCI2084p7HrtGMnXmR2rP1B6nZn6M3epaowC07zmYFlEtrM9LSr5MSwpj2dUxCWw7y8k6kt+TmNqM81G1j4ajamAkfNTZhRbP6QeAzB5BvTHdo0fwtrhdHcd4ULXo/l9Gh4OI7gs0tCc8ik2nY50RLhjHHYrvX29Kmc/nUw8nEM3kw477ZQf8ZdwTW0A/9hyceMgMfd6GjpuIGds1BAOJ4nBWyAsjYLCkEleS0U3uK3VBSM7AJxgpdeD1dE6q6ERsg4TKSnbXOTOBE013+tWLGrNot+Bp3OJ8Ng+4FcPVreJ3E+U/xisSxnbYsYwMIoyGJ5NikWfZJKgxZJGbrl8XkeYCKlU2nBs3CzaOmC2g5YRU9NJlnQCdOSgiV+HmmwN0BmRrbrKEO/fH5lzt9bcSYSBvu0yNAy11VKh58bFt0VoJ0NLWYtlxyNCcdXPdtu8ClgH85aQGRruwAE7gdReMY/3bXbxY+BHwiqF0ia1ndqpq1sBQZPOYol5FHiW+mhz/tL+O44lt2nDnK1qbU70k1cIH4LQP0OfWqwki7LE+dUEZqIMp/b9KhMHA95kejYYEkyBOr3EO/dU+mHO+WCOcAib/6KHHaW+a/brMvkdaDCuNBX6OiMxzzfO4vEbzzYtLMCzm+2ZUVD9TLDCTrkc0pTLv6AF5IaLXDz6wC4+znpc1pZdDbcDFlQmnYzny+Iz8pzPCbL4SAbg7ECY0dTU/Fy3pE2hp6lqDv/LrmryCawpUl1GbnPLK+fYx2LNQpAxPUZdWNgYgcFF8hz4h9Uljz/INBYgOSX6NAYokZ2SCkc0ThXDx3ZR72hB1Z2M9UoNHUjRQIgThwQE97LQkxtLg/eH0DlQ2a0tuLZxXAXhqfI6Ua28glIWl6xiT/bDOhQuVjfA0VeXX18ex/mNmug9VEPPtanscmRAVxY9aPOHi5Rdyh18KGVIA/yttHx2PRr8JDvjWfYDDzeRsmc4WV5pfcCwMY7g5YpUAJdMgXVuNevmurC910L7z2KqXQWisd6o+eLoF64zXdGYQANq+y1KJ1sm2mqDdAzgYAyjDSROAH5Jrn3pKnc3jxG7GQTjVGH77gk931/2h+jxzDRig5RmC7M6mczWaOmpVuyTft5XYwOvp8wcb/tcZpnb+saev/rhDfyLE1KMOyNfFrfZeI+bSNCIrZhtaNrvvx8fMWVFf7ofkSVdDu3XdyK2juCuqnQM6tG/a/mW1YHvm1QE8MuJ51JspCNiNjV61O6rus+Qziifbuhk4pP2XLBz5K/L+x2qPre/NBuI0gjsBwNLl2bs1ySp6FG2ctnnX204oJdJlNoO3yjKNWrXZI27+vdkOKaDtb0zVU3DaFwLGTyOnZrOQDatycsIiWTPcFlg04yzYoMeL3DgvvjkOsW6j5WjD1flIBPARfN/1fBGUXMm15pHOgUWy2z7OVJH6sSNjSYWrqv3leRRmE33bJYIlXFHQsiTWcfNxhbUeEN1QHNV8MKyBV36vyC+8sgt4FXNVZ9IjXzhGDW04JTCxouBiva1JWoy5M/WJLcrhPNWPfmIo5zteQrSPm9geUmLk1t9pin9fdGyMF9onnjVa85H8kR5RCHUR889Py1xTJGnpnBiXJ7aAbykgUdKttZ1hwPhBFkxdk1TBP5HHuQnryrYJR7uQXR4SRZGwBnpBWk8caSOhi+kq+4V5eLRkcswd78ibwmbgHqb4MPslPJsvGQnxYqM7tcrGRNlcy+IzXSXgtkb5siZ7XY0pu9XJ9nAgmBj/hAVLWSJ5IwCPodY5qrroXBvS3ZnwGwcRVAYlL//YtXeuAOFU3n0aBY1eXv6XDlJ0LuDVw8eedqMosP5iic/z5zF/iV9qI3TRX3XzsEUT1vuVmNi0/S2EeL52AV+m1kQveQjzHUs0OSw5IygpZ0Tzg92aE3vZ4E3TtO8l8YRcX0IiT2dDch/YHyQmhw+bq5bpQ2/pIQ7zwevNSsscrsV72DwAHTgKvpgy6//ykzme8gJeTEYZxC/Xc1CVqWnmBMFM/afkYPGBrPaKdhbEuMjQHadKJy/3NIWPJCWL2ZIqO2I3bB/+HQKPhD5scFEV69t5hWRlR6aX5YjuBuoYiWbP5xTe3MhDrepF/tBTD/8cU4z6vE2OWph4veGraYIAAyYNqIIWLRgPpcHx4D342WzhYGYyxE9AWJeNPFlRcszyg8ToYGi/TdRIot6Wy9qHbtLyhzLoTb4Zy5YaSQo0xLwoKKOkHa1uYRdo/u5/ZKKr+sle1Etn7VdEEw1PCWCrgmY355V7uwel8lo0eLwKVvuB/WoDRmHNKRaLB71zpQLswBqe0bhlWVCCGJ1jKzm1bwbuvelH9atZpX6XuMjQRb0fOThWfASjRkGpwrVKLXnmqodOnh4HMKLY3eRwmj7RQelDTtRaptniqXpLIY7SvhMeUWQixMpMyOSOOKX0gQ3vF4arNL74vnxYUwZ3/i56YSyTTEC2FJGNRq3vPqu+o1cbgiHnvwtzvWtbz0dXi3jl+v8WZOx5w3e4Nn3AmpiRvnjX4YqIfNKSnBW/wL5HlfPWRvCRMz17/DayALHYM5zMlB5jIUhDzP6JSc56vxGyvTHJP2xhZBqJAeXOE8whLCksAcJEjkSuG/6v08180xs/J2Ivl6JiRdhJdcTxG0o4T0vrcdhizjPeGAsz/vg6neJXXudsaYG5QXKnrm02InBSXMsUBsO7tBsgcBhJMcfP7hvN0n537SfaclBhl+XNgOVGV9V6hlzE9nFb/f89aPIHU6KPd0FvauRCty4K2GCksVGsK6/FwXGje/JRG17Xt7frLTIXFepcHzpuYrEvMDhaeC9r41jMEUm8NH2wwMVdHXiFKWgeawMGbMjnj5xm5i1AbSwca4aLFQmD8nd+V9mv3zxkNxgHUIlDIfBmcF50T4YFadiq8RkP2TFvb+Ndr/wFdZJYFmUMFlK9Iy/XVPVrzvwQBX3r8Q3BJ0dY3/zWcdsvpsAZXqIl7zo49r0a/3ClkvvrJr6INDo6jXG+9AnQ/YbsgQTcKTrn4OC+knVUOZPkgnfW/NtuoynAs5+mCNrHtZcWbG9rIz9ZJCPsFueWPsK6gqzGP++fGB2P9dQDl/LyGbEpFjMgbWr6tGBFUo7Mw6qcQGHrqEO1d+kVniC9A3qO2b52LmotwfUbtHaiOIUEKqzFe7+RfoqLFyoR2HdfOqxBLMHc4dhw84cTHwaQn7mHk3xs6/YMOxjcFT7Xuoja3QBxbieP3sj1PLzkUY9UX2uAXKwQb6URcrHEW8Q5W13aokWwX1nLsOQy2q+h3LkwazrrjAQUoM4KGn5ruljSgCGCLaNnqlIbqwRnV6wTUdoiiHpuGIa8RVf7ImdxbxZCTBTfFz95QJABpZRp7UbpY7909Jg9AaNsGO7q8xT/LMuy78J3C1UQEL/hI+YDky3OJJDNLmfA/LGHL8ZuvQtEib1x6gKEJvu31ub3KFBoJ72U8gFCJqbQsk/XIoasEkGWk/Fs6ICyH5xii2HJwh1Sg3o/rNZV/c8OxCLIt4pkvYAxmn/LgsP0QPhyLjzIL9K7jOixZbNCfaIP+5/1QfGdeC2SW+JSYAk8eFxXOaS6wF6Sm5K+ljw4iLI/0h3yAUIJMesH8Ij20Fp+n9rsBID87Bq5ntWMHZfNugzUO6+uznf27hpGmI7PBYn7GOc539Z2riBDPq6wKrlaZJYNUpYzXytjl3lRYslod3nv/oef2NhYcGKFj2uuzuNXtiUQX2aN1qvpJ+orLCcjCvoM9JC0Z7wlBvSuG6AnTXDZlOV0SkvMSykmKcP7eCzFOVziEhz9eT0EnFxvJT6IIHUirrDb21TKblXhw2C88UGQKTwvo+iAfs4ia3uKgsf5wfJosKlf+JQzQ6uuXd2F2c8tUceHAGawKhviwOWQsTa+znYNce2BeIcI1AFy/xhS9+N6l5+g4TN0ZmtW7zRTRu6nZiMMP+WFIL0jLoZ6b5Zo+kE0DglrI3I3YXuu1psu8Dl9mydBYhNicxtd1LEG+kamu/vlyl78jyMUJwhBCe7x8pFYhTziKpAMDYBtSOJw6hWt7v0nvb+Jjxaw+GyTGzEyfjYOJ13vA0OhHChxhU3IpbPeVAK9rUiqBQ3NS33RX1/TiHOaSleoksspY8ImNivLK1htiwkD7lJf687nWvfKuAYEOS70yJ0MlkjBQXmKVKRN5PUJfoBTHBZ4qwcKJw/icuhBnnmqMiCd2UDR2joopYFwt+lXqRSkgY2U1p5FIB61u5dMpY1IEB8cj4TEzlX7y20pVVSzZqRPFh7zFU9nRBjDAL+CFNjEwPX5ft7jYDKPhRENTsJoGz/AkHHWl1SYgL5CjiOxjec6djq4g/okH6HAKTgBoWaHuCh3vLE+OX7s6KrjU9/6lpkXmcGXoSN6PBBvgZD2Z6riDRC8hmnHFVN7MEU+jIJ1mMBBolPR8oWG+I9P3VsxohF7PsLzIrm9Fa3xbJGRvCYJb8hm6gxu32OpRP7gulSnJ3ZfWUXNEIbDSjpAJB9LIX2b/hoJ658oYfITKYy2IUrBcpVsw/b3LqYFRFwEE11w9e0ZmIHzSiXVwcMyoe/Gabacvzcyg6iD2w9mKO57cV67NRyT0n9RFDoa2ZHpz5VmDk8OIxmVxZ9It/L2z6e2+zLH3ZvuIb2gyczVSJOFv0nisf5U5ZZjP66O2oup9bnJDvradVoAZUxehuuPovcKltY2rHbIrHWFTrCwNsnfztAhHNZnFz17ws9InqjUB/1vOPG9B8jjfJzkX8LFs/vyG5gUuPdJ0q6ovydJaUsYPwLPf1jz2FQLUgyBP/p04bLh/whO//EwM1vp0+4kg0x1WC8E+fpHucKsDIHX2sgnx054j0AAXXgKUU8tmjawn5V3ATB5D8cnaCQiDphXLMuknLFETuFatWvHeQnXZnqm5BnlN2joEo6gD5yzHUPMhoO0l8zIq8Qqm4LVOgGlnC1wtQ0he0595Oy+yWW+DuqG1E+htTIbagPQOyy/CZaX/MWjvHvmvaKojlWwEbEFNMLKUzu5FuRu0gxvmJQWdNemuHCfV9tjajAO1a/hF8ellFR0x9/SsfMoRHI49BYNmACopSbo1DyXPDsNcG/MoOEVBExwcL7ckUWQ6WuGjN2nwsvY59eiIIAISlSW0B+HZtCaNRL/l3fv5moxAbD+YdOkNZ9WG1ogYSM1nzBAou3D+WcQZlPNFkmS7uBMg14QkOn9eH2BYvec32qo7eUZO6JDYCBhCMb2TBKInMZNdQmD4jVSulcGE42SdtfYknfLHgc7FW/c9WN3VNH3ouGsxCibtDV7yMuPM6kbqMIn8G6pE9Ca3pnhKKMZ+HkXUebURXQBp0dGCxIb4r+88PjDdjxF52x5gE15g9sioN85EhW4XEzJx//U+brDssAqfBQQSrXcIf1T89iQ0fW+mfRJgwuRNG/3ySZcsx5y6BqnZyFvdQzmw131Pl03/qIPV2BPSlBJUBt/5YPAmOAdOvAJHMeZBWML8oh48U7ZvHveHS65S8GC9WCgVR+lRZe4z2SlAllTlWh/KYpkSH8sLHYJZt9MQmJb2Suw1ill9GQwV9Frs7TImOb3UZ/WfngamZDyhNKxJ9G6V6zgCv8ES43xvppoeGHtctD9EZVHt4nlAws2fqxq0YCC40MdxDPqM/7jOO2fqIXNF4F2om5+YgtD9ekzQ93pLm8NjOlAEhT7m5MN0nymcXMpCv7i6Twfw5GyvGwstXiKkKACrPZOwkBjmy9vR06eIgk7esY7UaczKjDHm72u2HrvaEdwwW97rBP8d0jMg5XBH2G1UY0/J4ve0LYn1op5m9ARTZfLgx3B8v16JWdGTstjehrviEc6oaHO/T9d6HyTpZCy2y2cw9jk6praSzut9wrDWA0D7gcV8VWLiKaX9i03J65i7uon5OF0ltCtwF2Bvzch+jQvC0HSmOTCC6lU4l8pkEe1oRinVw5ZYDJ9WuqhZ5yQfLBI1ltRLbvQWBysOLGm/GAjwZy4hbiHpK9ydoi7tPBFv7N3S88ohCTdqvH1kQOcHDTHbJT3TJOPb8B/Q3raje32Dh/MxPYm4kOaWBYS0bWV52iuq+HJdCcy2W4zhVP/c17wUrXQC8bNL7xALVxDo/5rP+8ls5sXmhb4L1k/17Y//phMZlG3vIYjzVNQZkxxWf6d8hG+t5cDoGQi0iBAnmWeRKCsr/Y2kYgEWe/6eLn4WCdWlIYMwiNP4TSKsif8R2HJ0gDdzX05Myk+nX/irYNaGXVF4Z5oqEc6PO2qW/ov3gqtge17mdhBtChjyQgaNTeRpS0gRrVpBX0ESN/RAr6RktTxoR1vZgtDc1+ztRm79F3in56aD37SYP4XXTQPBTZvPRZRpUfWRdPe/ApcRf5sRu+dzB5t0Q/OlkodvBzGJUejFd9lWJl+mCBd/rg/Nl4Db6JKd17R7vTj5mUydXMtuHNqcufpHK/8Nq+Nk5Kc1p4YG60Pqfvh+DcTR2f1dOgnSEiKUEJr7dBFmd86AI1g2iv0vUVhB5uOjhou67b9kTEj6IDXqi1gjfokHwbZJbBAhJiPUwd8l/hbJrh2YEBkfQOWfN7agvaBVTPo2buf2Hx6t+NwHpvYCGLsUbP42t/JXWuyCLLVRgR9Yr06TDP94UsJpXvXCgOwQlv8LZZ7cyLOKTZe1RAzYTlcqIsdlrtbZLyAX9ZWIegTpwx0EKbceZjDGrYsOoRp6guWEio4Z2G6/qHxvi9ZFLDDagkB31aqT07OdXMTBgHIE8NpmfUNP3OTk7Gyyxf2/WCXxv/SoNbsxzrzGwkUW9px/U7A4tk/IfPCjWXnF+52o0T2FK48xZbYB65FUAVXtQPcHq7FPbpbPQ8QMoTf1nyrTAuGQb/HLG1UhdkyQTvKFOTIcx9JHbQGoCfLp46T6LqqjBq3dyglSvqjrGRjkprxCAkyGDcVClSUDv6gxjy+aVrMkEPMyo/9IpvSXmkScdd+u/plj30YFNsOJOjv5AymrDygmHxyPNw1Wq8uPolpvwyF+h0678D+6ArgkdnCM4OVv1NThc+p7AFqC36i0kFoHc8MdLN+kXzGBhe2MBmKiBc3IfOa6lLhK+TXWbmqMQ3Vkuw3QhhIbnC5Z+xzWwNfs128de09LFQjeQxhEb3z6J9eBL+JlrD8+IiJE73bBpFoA4hmdO08tWhSFhLoCm6djVs729wxn7YAls1o5GTw/C/MfC5iS7zIhz1BMN4EcJWmMFn5kOE/QjPVT86AYDXdFQDoA9PaJXCYeWyMn+tGPpAFYgkAcBYw3tGBGhRyejaxeXadOepus+kuzbUOD0LG+hq9yrgtH7NS/YdoYfoz/+ym06o8lbEU3cPRq21XjszTmenbITJ4A3344Y/PLby7Fpz7bsf4paGQRZ7wOaCYD4lNb88dN21cIZfJiG8HI18nOBDEFgpeT/BHns5f2JCPXh3v+HMgooVJVR9rTn0YpzgbTfIlyPEzb+nOeCQRmACS4SIfYK+lzTlBMpuoGIko44L9tbV5/j7+fVbg1AUFmUQAEdsrA9OWlFVAQ/iM9bANCrcEd/hJpA/BoR2zs63GV/jcqu8cnfF4b2UwQa8KluMQocVG4cJzQovFGTSjnE/YgP5PxLdvbTv0blE7/tb60dW82De7/m7f5s3lSEDDfnT/w+PL8hES1yflJc4XRgfRgXa2WR6OaH840ssfIREtq1vYZtVvDlBahmdwC6G5S87yi9ihvsnnQpOZKc2Q1E/BNZ2cwSVjs6wQ+NIfQCkimXyR53vjWHF2bqwRqKNiXWlHF0WaBogcpI+zuJXJkH6ZTTqYtNyXxSOUzAHnFhvGtm8fjE0OErY7301LjfEKFSB3mkio+pKk2QW/e9AcKL2z93yln0uvTyidneq5baZsSGvkWD3joyir0bkK735f5iyu5p1FPqY7QWGN5/j6y/nHmLKtKWXnHZdZ+uBAwsMyLfxR0B8pmuOjtx11b7+4QmJvgbvOzn8j+Jd6JaUfFW99z4mVnOB/Mkbov+k9lSE5rYfH51Lw0+1pHoDIs1togiO4UJ8R1a+P0AUbcHHRs5r/4c96pDRg3iYAdIwHgLd0ec8n67PC10vMtrW2QDJnXMV4OkztfnkThDWTNVrFw+BPTZmfRRJPYLifuH8Bw80HzPKSaEzJZ8OmHwe+8KQyikO0cjII4pFxb3HHlgylDApYbjLi9J9yiDwDTRXEd7Yt90CQ84Gp8m5AZBZjfrZUaHNaVNqZvzHJkjG8I/fYVtxg4bG8DYvP3RgKErHRCQFGLh2xKWwWCll41sUi5GKBNpmfxNu14er4sryIhm/9oogSb9wAW2g94JyDt7BsgJ6U8e1Y9TfE35kskPudDTg+nEIVtyBxMa6StRX4Y0my4J17JOPFeR9mCWyhNUFKJkgg/WCkvc/AG6Ir02B64NW43IR4FC+xyLK68YagBy4yOm526WX1DOELNx2MT0rkHCNbJ5cmWcfMBfro9vg4HTz46xL/Cy+HxJUTmfl/7yzYr8llKo5JOdqB7toxMbhV7SVz10oaRV99x94hiT6B569Ozo6Au2SfDP3A/3bn/AtH86od0Jc1DHpHIypziLlgvJYvgGx1oBOCeWj2XzmjwOBtzuFKKLYmUPRiu60Fk0N8bqoLd9I4LtEkw6DDA21F5zPF1acgSfXyW/YaxCMMK9ZZeDs0yzBuWtbcPw7r3WkrgdYWLCaNkucMB8jFHigiAnHu0ZPjU2vSbRZZrVFtwiBeRNu5Brff10MtDBj0HcLp4dZ3jRDeME+qibA3id+i0UNK+1Lr1zQtUrwtuHZSz63cPhnb5pt5bu48RxCblqaZmQW91RKfUC6XzWzaVtOxJNqNreYx4YXA6ylWFn+yJ9rDDBP5dGU2b0TjzVHn9W8+GLesAuIWqFhhZV9Cq7dejY3/pJr0IFGa7GOjFzv7EiB+E2/t94hf3Nbs6QQeux4NteBYnwzI5id+QBlCmTKzdR6St6/gOZZbnxXfdC9ajlSIas8cF9MIkRXjnnNR1EIM7JtoNYsM9PtorxKLxAbbR4Swb6LVXDD4gnR+dpUiBnedbc1h079RCdEAUUubd4ZtpeLNbhMQ+yyws0EpilFsk5oH7jGi1hoRJ/prUR6vr6qELlHGuYTzEbJMs1rNjm7FPMDNPCo0UCzD0MavCgwL4/AzSL/WCY34FT+cLhShQNWhXsZLVoExLWYWWlB85PkEqD9iS79aFvUiw6hGUDYHtpMEmedJo6ib7fdumadqUyzotQia5DE+TGhAclMyhJL3YB+NvLBwzeHspjmskZjxtnNL+48yoJkRUIj3YNL1HparGHrB67BeSerfWloUvP1St5lxYJU65vzxOUMJwVzPkm4E4Qwf8ipyzCoqnHitmEAkCE5YLGqA1GVDbS4r3LiLm1sNhXpxYUSqRKU7NwQqeVGr3ga6dd9MyNI8bNjsLCu0wGvQkaHWa6oAlJoiyzr53ZWW04vS8GndJwjqFPuoDgK+FQ1bznklbTD3u4OVy8ThFq2sA/f9cdsqV7/1DtYwncEWnyYVjc7oCHPR1kZ0DA5fBNvgtY2II57/vD5clm18hDUkDTslAoLUSSMhwo1iHi58cZj1K0kxPg/3QE9baBgNuQwByJBSl3vDZTBGtGMZXvAC2cw+BqLT+Jph2SoiplcHg2vmwr/EYN5Gl7w5ofryNzXzCjjfzIwq1gHhdEagm84Ic9wYV4Jj0h+rBHfmWlXv2XRXpdgDtZcOjcHcC2jm7ynBGgtVkYyAjalKRhxmuWDpAWSP6Zdix0rM6+zcCQQ6m30P0XHyqvhTVMjMmduwwejZbf4rjkkODkSkXR+OYp7epaIDoYGLmJmrmzJ7cuShnqaJDITsWWJbA+vjiEFRWpgY8MRNSRVQJg1Ijn+e0DQYAYBobvsO60OW4CkMYIsj7MW4HCmTBjJDP8u5JZYqGjWzc9VGA0292aDg5rzKKcOrWRz0tNdcnYSSmktLvTiOadFS7EuAOr+5rEYXIGHkmqdsT4pwqaPuvKLu8pnuckXd+UUdnxBi0gCm2OcBgNIAFm90Iov6E4KlFACGmAvzExdMGsghCmYKaKAFQHBnJl2oD3COqTjQgSXu2vx4EPmABwJiySNqVlMgHnFCHhAABoJD8r/gBh1v3vwZBem7hOV+9PNy692m7DZgf6iSYvygX2RegXZi9uIFAuH6+CfdQfLN5sl5DXe33yeYDzz4yAwvfLQG1IgIC3snVwF99Tipe7khP6IUz4iOe4rEi9/fCNygY3tWrTMj0ig4ZBZualY4QHKdc3istAi3PzHWxMQ857Y67l3Aop2Nb8gOh5vHb7oPJpnEh5i8pIDOm8MBzAbQYdsAqR9nJR5a7FQnX7En761kQoia0MSp+7HywJv5CUHuyqIn/tEIav3nvTzK8/pXD4VuTnTQw6cPdIqGGJ80r0x5ZDRPtR54hVUs8iXl0MyxRP/SpJBttx7KDRiUAE+NxBfMa+EJvSYg2++5PhqZrniCXcMtoGawMZ9EhEpAL/fkpUw4bUhqbggGbRqjWIEjVQp9ObOr2ZxshtuUNDBxZOS/8nkeFiO3e7Hs6mQg5YT/Q4uGx2fiBUIgABEL52I1o7LZ7Ouinm/5Wmoiu9rJpySXgjd3tdlmT3Bl2mwzP+Mz+aoVsOaNyXhtUsja7KY6nxmTxVT7XE1BMn8uMlfhIXCtiNTlG/lR6Ka+N5NkZJLaX45f4UXIGDM9XH2NcIZg8X16SyzjE/zRii0MN6Bl8jNgH30GUJOeAeeEZ8CXP4uPzzOpcHioJxEFEMpJV4mjWQCgqAUAPg3ER6KZNEDjdEwTusBsgQDx9CRD9SEfxFcsCMCV93p82pZJIwPFPosQAGW+M0Z3OhdgsFQDFkMe+Eez5AAG9imBN5LmhjgZYLHUA28MzfmROMruDsdDOsrEJEEeJKoIS9awNH/LjoeBELFSMQCqqLurN8i0PpEnmJgnMnDcAOpWz3R84o8SKxQITogD4zfhdFxYsFv8pYORbq3ZDInqeRYm3fCvzUAfFufUghCgwzCntThMHUx1ImHEFZxHRX6TUrOJ5EIiLvE1HEtGkvGQIRyFqYdFmYsMNgnZmjIhiE9qAs76PoHsKBdTAYZIPQAC0wGT1+TAOKMJ2LImuXIeE3DUmwCfm/JD8k/qrwHi0wQscHqARR0f5L4+hBmRUr+2BDKetP3I17sQGGLjdgnhOleDqF49BHt8c9nq2QEsQ2gkAO9PXagGlOhJvctcLCn64RwmQKHpC0svuIE/l3Mq/6vsCXdRgVO8A7JqqrT15Lk6nBI42oeJ0O+zKR+fItV6WAcGPbVyCtx9AMyXEIGMJ3Vy+30UwW7m4WtZhHqWCzu0w+2GjUt5dJEbX0J43tBQ13oLHothEsgGzgKkJdLmrRCiJFyPeFB+eP3x6IOv9jsKMmVtaUZADQuh5s1smlYMj43xivyPtnln59GxX3fMyngnIkW+wUwDNd19xTcz6aJ1fbCFFwnQJwRl0GFkaSF4/hwN71Gv6lc70LEGkvOAqQqOE8xdDzCy752Uf327woxP375rQNPyDWIVrgfh9QgXxGjikiEzeGZfJMRFSK+hL4fLaLbPSKA5oMKQ9DJZFSDY08VaJYCr6MuFwHU8o97+uRGd4M1TqACdv0s2gI+0/AYFm5P7FdzVCx0a/FeDEDpwDUz0919SCbpWsRA6eYeiMjirQUw6Y+VclGXPe0vGBXhR3Go21/125/1PJen2MdN7q8J4H34kJL8wdsDumhxiH0Z7llpbWPBIBgU7MKMV5jTaiPJjhWhi1jOcOPSN2/OCxHbBvnNDyps26G8cWcdaIzP1Ig4l2XJZgq6rRZM/kfp3TNBJ9yPVt/savJ+qiZUHUklBJJ4OCLPPsHYzQgC39f05n7yzune4vtbzZFDdY2KEubzD/bigRxinOgIIPFShYV2Nvn9TTYZP2tHtMPs09TdF8IxVvJzTWkfU/UAmZcw5lQG5w7dfhVnYc13AnOksY/fozK8Tz6eYcJv2rQMYm+P4ZOoOQNR/TRwMGqRlenTzMiYkuGaW53T6pZhWCAK0g6csOiAAeC6tgm9OP3NzLlRNxFr97S5+BVo+d2ch6qvwwf6lBwzzA6P2ivIKW4b0V4Z1I89C2Et943BCL/t/rACAcFkc6TbU8NmqpwG2XSUCMZ6iX+DfnEI+S8njfMA4TRdAyu5LrSb1oy+wQ4vV18BpujyMWbFOLG1VXl7dDJ4jKhZHSjU4P7F7Iet/jGe/L1kvfdbtjs3cjmfqO2uyhq9lDM9HusFPdKtCg+UAUCjg6njJlvJdzs2TLLtEYuzHtPzdn6kKVz0JoYpB/xJvawoeUzB2zlPVf2AlkayOiW+WvNPrhf78uh5TJFwnLiPF/bBltPXQUB/SNLZOXvr1eeC/xSgW1kP/LXtmgsTVmzIsMXovNV4ffZRe8tpbWkKEUZrY8C9okoVXo6l8YB/VT9P+4JrkO4k1clpe29GeaUjy2qesk4fMhAG2ZJb/d+Y32P3UTvWrLwlEEyczAf0eih2QJJ0rQri91Cbxsw/TuSuEqb45614+A68o8DpBqYO2gk8asPq53gHSPelQ9RqlWuQGXAng9fpzJ1B3OYHWaxxdNRTMzVeKcHup6cPVldKVAbxOKjYjdDE+sOTDqJ2k9GcoYcYnBXi9xvtqzK+XyZjdQXag0lRIPMDrAyGLN4XOFQNqDXOr9w267IzZDV3zUfEXo4fklGF3x9Wud4PzFbB6Ab2e0cggScFUf3IaOUYHwgRTvUCbaLiI/goJt5/cLXRL3RUBaq/RZgqFf94VAugFbLr0MiUtEhZh9kbRA4YRzT+JBuwhgEsXwqhdcaD2x5nM2gZmD59cDsbthnRKOkAEwWcZdn8KwMFxuWBymFG/Q2cGgu9gqhd4lqequ6LA6yMTq9ltg9VPCV6W2oK1bZSSNcAWpX0hgdP6BZAn9813Pxfucyu/g3Tv1RE8kr8e1mo6OsheVsGrp20y+tifytlzAOz795GV0Yprm9/6iKj1l3lpe5cWp00+LBxh89hs0j0WlnFxAleMSIKNdEJw0qkAASy37LuBFumWC6CBKPRad6binXNBLQwVWw7Mb/Nax9YIiP/9QC2CGY1A0xW8EjsF8vz/YP4OeGUYcoB+GoH0x7sPGuhg+wvxUFPT6Ew5s/FrJ27g97uqIDvLZD+3O8j93TBN+APws5HAzROeJr33ngrBUPU05eHEO3rwQSgQWnU393tgL+/qabab7sn9Tl48FT1shyTq+52JeB38Ps3OJ5IEnPk0F69xrE2HYoGR988OCc3gJ4A5Pak6Bt4qA/xOwRmHtnodMEFvq8MBF0z2Ivz2/xXI/NFozkvH/lAkRvihKEfsQwkzCud3BMGwjV2VhWsdLASjWXN+jmmimMNYnKOikkK10RdQorscWYk5Qt+GxheIJaeni9O2Gy4TOrxQHIZYFAGkNJ/b1VApeZDSo/EUVtxN+X7pfFJLNZQohEHNEnaJdjNGiN6zjZJXENrZcLES0nDtYkNQhbiWMpF9B5S6YKbJSkkRNTZTIWNS0ND8AO4Qer5JyM53bolsVQeRU5XLR0dN+YWThw+4A2MhsPrwhQvB7qiDVjKfTWyZO+tKiyEidL+EuUWPiEkFbO9V0/hx4mRYNCuAxvNacIUHu/xqf39o9kXUHj48X4bzNPfm+XnnXWr/RSuUGOdo78VChQtgt201CXOc90uXGi7WP7vdhXdtJ4cQjmgPW6FGy0ySq8CmbVAYyAf+jJPe8aCEpEKCLNSCWcu461sWt4DSSBnCwg5xmOTKTOztBQrAtJU/jAve818qUk+4YwTzkKP5DKDrT1uzbPh+tIPYO9q5lqYKAiabZEBTJ9aVJpOhJFM5jQ7786iq4RMwG8zvaHCsmyrBqcmYGTAud8YcWSstRNOn9DrYkk3BfDmUl/IQILbpJ+ZYHlDcKnTOkGlPl2lt/poj4SI2CKN4GYbihUxA2szWjLrBObDnZEniHUwzsPVaScPXXywmYSto3A4AOY7fq1I59R6loppfe2CkoCV1lkwbSZxG8i8ZkuhfPSF/oS8zjT6K2E616tXR6Y1ZOgXjfqlUshCd5YoaOq9O5VRKdt8lHZAln5REUe/FvdFpIDTWDSibJIjQ8J3Y6MUH+Yf2sRYPFrQQ/NpliXo4DGIUZu4XUbQpekPRCdpJuxY/0Vm7lrCVei6Bhvo077pzoLbiPUk1p1ZNp1AgZddR9OZ7E9bAyF+y6P4DNiNTst7fc5ScfUo2BUPDZFqdwTItPzjr1+QN/laB//oH2WoVLJLyMH6z1K5eryKfGShzr7yOnRSP+dnqHOusspceTIxPpbbR8n+nWl9OdbuWWK320XPGbcQnxzUTtWFsMnlTQSN7qR7x8vCupbZASCqkc+dl+1FzpwXXb/hCcApJEtffvmQakFzdQjNR4051Y/f2xeFkU2J+hFYLxjUqA0wcH1G1nyyquE1n5WfitwFjEPoqVcBnz+BBhZqe0f0RDSN9DDRgPO3YITxLyeb/LDc1eGq3t1qC2Mm2JpZIrtqg71ShIs8G252gXC0FfQIjrhRzSUX246YCcSkoFdbxZFUAEt0AVzMl8ojvSjcAV786cqYHdrxUUUEOAzW2ebDB9ysEis7fWg7LkTfjNl94jpggjoYYx1JHHAACAAgQR7DYI53weSmEALAjUBuSgWQG8RyR7FnKlDgG0Vlj/4AvADkSAfYfkgcAIKAJJEJpoIAPiEyJyH25bcp2080PRxv5CK7eIEbY9AdF7fFeUBHk7zw1nIj/7zDXJidItsxOV9c0T9PUaWVyVsos7UmVZf0jZqyFiE2OPVJDzrgYwMTDVKmEbjBbaUd3/9V9J9MNgGFAbtEwX0vbSvglp7btGm/6cXgSxhkSmiapRB9/hr8BocfmNioJsots09eabLOv4sNUcEGVrfwtUNsq7h3k0h2DU3yCFHEyNZOd/LVUJl96Eu5o0CqYpO6a7N9Pg86lc+fce/wSv02RB3ullLB2n86XK3Ttu1Dw5iBjiRppic1x/s+iwo6oolbWtGjQZAYTQ9n6wc4KL2O37mEgai9lJBNDFzfjOuPv4jHd/n5mDCshsIXTHN8LNXwZfm0dta+sH0eF/5fB7ymMG23v5Ud7HMT1aOVNjxG0zUYfYvtIYasR5liyPQOEZJWF/pQ6fLMrpyIpO3f+v/8RHz6vroyPVJLO84qfFe1i/nNacX1MPx8/FMVzA+z8fHw52eI6ynhV1V39x33f/cAbirn1BFn9pJ4IXlB55syjFfEta9Ivgjc92SXaCmNyub0XJoLR/9BoKGm9zQ54+OQSot/1Tgebjm9SqcquzzuBfZBavXIijXR97USs88Ag9Ac52RM2DybmHXrVBatVTRWdnLnJnXPCxlHYDLMyWpWjyh8WsDWvXl+qz+tvEBbS47wgQbrViqctZjNzTO+3vI2vbfku8QgkUEQJSRGR5PZDRHlNNIVFVAVBph58J8HkWlqFe1SQZLlhWqM7IkcoLPj1DBIFpOoENa82Ob4Kj9fsrhU1m0xAVQb+iBZSU4mmxY1JONS0STy6cYsjj2yws/eYEt0fthKFgcqRyt0OJaKd0X15OQh3re3B+AkKex5v+ADL8m3H6dx7jJ+xMMoZeVGyxTpldHASQmvfUh1Tqm9gnXKoxlJ+A6axvRZJuBkAAlLD6wSr8B6xYSIAfgpVfo+7zPUcIp8mbOsSvpnOIlNX4RtlhyD1pWJzbO5Zp497cNwKm9cP10NiWdpFwHc4JksG66D+wESxbJiPs2yujNZdUUcpYxtZauy93dtF0sPWU+LV5hcpOSGhRMQNgnuM2IH+MTgQvLqbBBKE152sJ6T6Q9rvdhCY2Hk8KZK9IOXCOC8f8dhAINqhpoYowTEtFNP4E5gQb22zBJtAGt7Y8ggUS6yGJxDlK9zzkBcYozebQ/DiY2MrYGHDtd/YS4Sa1vwI3nJTNKRvgJdex7OpMsIb2z4r5HYfaXAPC88GF0U73FfZhUwB59qax1lqcCrduc2hxXd8Yirxupqtgy22PzNmvhiXk8tJnnRzfjn27XJvuH4U1I2rE9lPTse4nA3/kuj5yPUCbL/cLIwLvi2e9aSs4Nv56XBn5ovYH5/M5djrIyjrobp4YE8DMJU2sohDFpxzTEZf5it+SdrAhZI3m/cWuYAO33swWXLlJWylH++bI3F375hgC5P054GX3dcol8xjO8RmNcXgPZrN7QiotK/tGA3juG/fKB0jB/oXIX2TT7ec2VkHreF8mE/6dXQ1nwG9JwOHv32socfrEGCmVJWxJqiC4EZ/+pnfP08jgYBnEBa/4cYnjin7EyNC5yKwwbZ02hKxIzagzFb2jCRiuqeAPUZsgI2UgU8Oez6xWX4emwdseNlfZaqL1LN8Lge1Cr2m+bwuUEXuMKNhaFN7sbTUD/P1nliYqhetfRL5bCbv1LgFPUxceZwMUOwiPZg3BAsdEXH54mdYKiTuotnbpEwTAiETwFcQf7OYskZ0lQVo4x3+7sCumIlfXek+H1t67jjWmiUU2nVQZuPWcFIcZs6dYULJJ5jgsTvIk95KyXBMrimwwT+llUECQTbr2Nw76mWYTQ5wy0z+ps0EBuwJrocgBKEo9vaG4tNYAMxSAl4cUb6fxiet19tDuwny3nzMjrti+z9UE03mHLJO6+YUZaV4I8kytIPoLUtb/XpxG1OUslkS64lIvfGhk37fDE2wdTtjCtPzMxYoPEk/Vcc9Ter3ugsdm+ABrIQmRYTsqnOID+PJuR4I/Iqor6+8ZN3k3HX5AXrVEvVQOvPqQEJmlhEN/mFqtRTymdTe4ZOfPjfAJo4gaOtbvIZ4v4Os7y/xe2jZW6yPSljba5LvHXpgn74Au9x0lPDeAacVCf/eN+qo5LLTRLjf22Xf90y/u/zGYoVqUa3ogigq1YDa4WtZtKj9eL+2kXGxvRziL8P8i53VlvqXmacNbbQf7HcV3ADhMUCo2amG6+olSz+coqO3c7sZLef+uPFu9wdXW9qmgBaeYzvrl/lfX8/qaKO9axHyK5ay5mf6TZWVDTkBCQUaXMZecuST7zbf6jlt5XAteoDtiiZ6G6OWiPsiGmZDY/ju+urMOnGOblCcxJeEvE3xHw4/k9z0U1zO4nS6rczZ+fThSZ0rfrYdhYtRhXtmwzlgofINLO46ihd12L74QCGHUJog++rz3JeExqRYDLw8G/FGa1dov3xbBYwNTxxuhxH2yxJ0/RYleNocSVqOLuFjID5GebsQR1xrt+e1ewJZ89FvYDYzu1h67ThipQclhLwyL8ExuY28W74e6aSWaPBEEMUg+f+2NCP3R8v4FWLxjeMb3xu/uYzCFQ3esDhGgD+3sVmoQ5lG8OdptMbyXKA2JbRc4oVg3Pr0lIh/2dlfUfl/PQexIU6ae3Av6lTsvl57LQWV+Djp1u2Qv+OU4djoBd8GbLcn6KaRVLwtiW3v+Lzc3Pmv5Gi6KkhKUVK6sqg6bftwvq2rsu3Ko17Hg/GSV8Xq6L/y34lq3Ay6fGYKz/7I2Cbha9Wd2Ff474zE6b5IoS08qHfHhNoNP/xC75lFq3anjWGERVTDfaus2Tq6uJaJ6EZpL+foXW0HfuLztT0rWAIJemF2ZsINwHebnAT2tGe2tu8VTWWygF7kLjXrA6sHIMn94EaJpC8l6otRZDOH0m92B6DqftNt0yYL2eN0BJrzyJMfSr78KbLs10C0ZdnpnISU8wGlf2x7kxy8TlskCuoch476NseKW/oXbxu/Jo5HgDGM95i/zHyalgfQscEczSMIwRfQZRvpphb7TCy067C3ZkBnpwY46XhozEqw23tZNeRqeJicGBy+2mYyZb21BXHWqT1eqXs/7wHctFHK3F8zRrrr/gUD/c5DrHbsZ+ETvYGGqAB1ZTRRGysCY0/o1uSanbCwNFOAUAWnH6e0EnGkA5+R32y9ZUp13d7K4eS9U72lFR1F43DMs41g/C/K1kIpHnsczfPPm6cHfm3mHExbSXz0w++8AMcosPmJ2vx7fWvHYgfMq90xJC2zGfrfa2Z2adcQfEmZuXyAGD+QoZzCIvWQxLpVhNinKyrq25H17aIV4am4UQel7Lb5Oj9jqa36SiF5zITjNuKtyLxK3wfD65lR2LoYmyqYAXZzFcTqG1+vtU/DgMRHd0FTQOX72xk2PLR+/UEp72662u7kIp2OZky6Z1mXjnoX02FX2FG2UlQHZooZM7COEjMz2OWVgpTjnNOx9JaZGOre4GOQ+WdOOK88NPE+yklxT7EOBuuQDMPJZJel2n4OyEsOnM1GFkj2WIt9WrC0e9/bnqUof/ntJiyN40nOwexmIbKVN5x+S3iflO/7CNTRVkrpitbbxaWx98Lq53yWNmgGZrNMpj5YaVlrSMgZJUpAxvb76FvPLX0oK8iIfh/CzZ2gE46IfwxuULipkTR1VNbGt4bLB+uBUVoNClVcombVHrjdRr9X0EsKnQMLSy3ZMSJisM+hiZWD9Vx7V/u2YyA7K907scK5JqZ+C9wjqDzT35J7kabFriV1hkmeqmN9UbjWDj/3IPcSOG4phpdQWMm3z5hxJGZ8nNe+8QKOoFAozPZuoHSia4gr5B4s2vz5UfJw9x18+3LNzopCOzNfz5ei2cW/lGqpVfQz/JLoOQQ76D3i9a33nQSL/nyDbPee1hDyB90Kmd1ReK4tYlvySPhFPXhnT21yh7wdOzYOdlAl6nNKzKwi4iSrYPfDtM+cxgJsp+8rcOu742ATxo74IAv551ZQdzwbgjA7AghCGQPYA7R3xTmxWDO00Dk9LADNfhmtxps80Tc2CMxRbYtGLfy9zQLSw9z7fzlc3ziyHWpjHR4PBr9RnF5DtW7J6kb0fbZgts4JeG59r6RnJJ+zWSzMuqc5YChP7RYMUv6uc79dzdWAIN70p1c+UCnJhEU7kmeaDnka5V7ivffgvx32dGfG7/tA05Q1fLii1bq3pDlpaw8Skj/mGjTKc/9Iq2Ce3cy8vFhO0fTX2Z68cXC1z7FpraY1Gmhl0cq8ZwBoHFPsrpstiKCCG7B1KycvCqVrZZfPEFf1C32a6aWJKyZxk1CpbxNZplmTt4lfX22P2UY4LcxCgBaDRhr7W9Y1ItxSIZ2WWGjCj3FodnuB2nzreakQIqvLPR7BOp+xadKnd3kjb4pZ3D/jGvbvfk8umVoG+k5i4z0TCFMPXdMLL9opUy6Ufg7uKw3Enr/cymlhnozB+CqD1SV5H1cH4BZrMPzk9zxEvSzkLapDy0/6irbROPCNJbppzFjTGJWuiqT7C6rnpUqOcZ0kP6jE1EGRQVtOvYSFxqvzadUNoFrG2ObjrLF9W5s+jbGpohAeOSf7LyP+YWf3ATFLpJfV29HHNaHqG0uWuYZWrUFS7asZuk8irY4nwxGc/doo9AwMN9HYBjCHSczx7yhDV3oQfd3EP7VlM3AIMIga2ch/2gxS+gBxl2yAzFrPygvzlpb7fva4EmDLwJQBfhvruMNa7xlXfva3ULYgCI6alWj/v/ndpniYTPAM5wsDJHjEMGkrDYO9S2ELdYKX+AwVvf0HiNx3Bt1qQmzg8xzPHZaqQyxO7gupMJD9Ivxwr6nQHWMmgFNYs2uvzkJF7sV1TrzePG9VlQMa0qUuZ+rz5Ae+8VueuqJSYTcjKP/gwXK8RqU/XeX9D636r0vHoxfcAIOy9qPO4a1YaQB39nyTu9njeUCzfqUS5dm+w71Vx8yTW1glFSgrCYDN7Yq9uwPHnX7993Ick8zxHSnKdQaZehy4UsztpprtMDAY4OSJQ0e3tVOrRcjzLR1I8k9pm4nsroot6SrRAZus22kTt+p2GYyJU1uNN3dZbQ8sYcHA/CQ9zp9tZIqvcjNYO2ZoqDsJuEfqQx4d90ft5pTlFhCIGVt6UD4kfbRuCwxl5e2Aul2O5/pEU83/d5fAwoZHs0QOJqckbqIxqMTUXwP5Gx5UbPPKE88dyInhDbt/xmmNdMtdAgT60IgdQhWafmkLR7N7X7anR9uQ7HuvQ4P5Zg5/1GDE84n/Pz6z3UE/dLP57T06mxz/9gmmV8fJ1nj4tlmoy+g2XFySLuvaFdV2gzUPrsDTliuMBD2srMyd2pW8aWn5X+0SR1BNBmtQAuknSGT2L4SXiPiapq31vqDduZrg0IwwKjh7L7a2cHyNxCirKDhAtwIpyqHt7X+PfP9l5KfOHHJ1ZQPe6i9G+JeESt/6/yRtj3V8XMi6soe/SfL3mEfNY8IuscVZarsuU05I5op7FOWej6xH5/Y88gpRqtbBLn+jdaiHV2KbjmApPXZTfEUHLoW16KuzztNDUZH9tOcLlOfLUHPgmPu576FKJg+6aci0kx58VMLui74MveBMAQSGyJsgfj55eQpC/oZyLELojOP+FlwpdrU1JtxpCF9c78Avl1wedOLQjXcelvfCE/Zh9w8f9McO8U+/5M8Es29ZngcwZXPE1NXgK5x/tQ9Z3OEXs5OZXDnrenuEKhCj9jyvPvWHMRaynbC0FvWd9eJfh3A3pVpWtP7VRAsFv/CajGZFxFyjV8gTjO0n8z1sIO9N5RJyI8vQuMe0bSysRmVyCRZJphGpBdAjf5sdZUXiuqBYuPCmzC2nxuhCXo/CF2IFgbgPKRta5ZkjBsfgJvjaFdYI+vhOdID6KlfKJZnUVyCrrhVrChV5lAQLDrvqxyYo6DFkV7KdpVQz5AFcY20efTViqbCfdj2sCevNspXDJ7fNVkWGCk8DDB0fI+ynAGQ35K0iVIRLrHAd2p9wuH9kUetnhxI0K+G3h9/xnParew9CDH/QG4vVLP/X1jv6fIIplehXXv5wY6krBjEIiUHyNPB3bKOj3qkBUHwU7F56NYrL0FZmUjUGSRfBienZsWsigq0ekAAe2yiir7dNragVWUcVMtXsWE0mJN8vTUA82fAjC9O4wDat8h8qWfMMyx6op/sjUT5uHIsxIIO870028yRT6//5zdWEr10UXbFb8q3EDSehxi4r0f09Mg2YjgEKbpi2+rrNyv0I02Jwa6z54NKu02C/YTG1tuSPPBOwfnc8cDiuWfQKuZPu4kpwqaB8mtlRhyW+wM79Xd+gvWa4XLFePS2VF2uTYIC60q3+uxMViw9PG9FqWW4Ms5+BAmaUhQkuRvUS7QFokVb2ZRJ3YtM76TBkLlumbbUZR+On7RVPWlq6stSsYrkZROa/Wmuy9enAvSrs6Z6ik7IvC2kna8Sl/wnb/fuXkVxx0ywbdNNmnD3zB1Xjn9uA3jvxHZJdrKfN2EqA3eBidAVwv9UhWt9z5l3s9cm5OuOo84ns5WUYq84XGSkPJwxLUU257tK8OZbsAKqXwRZ8TKqA/oP2runx1LGrtzZie1FqHeWE8tDPKJRmiHsDWYnaBD7LwQ1yQ9X0983iEyUDV+9w3tGzK8Eynqg6Syrqj5x5iBPH6nJ5C5vLehjWNxxs+tW93rhaeHXrROW6Ae5Y09GKtKwQQQgSXjIAUSV1GFiqSAj68RQVCne2Y/qtkdRFR8cBez2PG10Ku2tYIFe0vE4DfosknMhFeTqi0147DlQafLmwZi8/8BPaz4R7ZW+YdwlfTXWiARKnyK7gSVc+42SYxZAc39rfivt+a4dZ2XMTS6UTcVAr5ziB0Izr+mBPbl9001/tP8f9dDO3uW6XABG2ek2OQHayfNTW0gUzKo0ikv9dd/y76Dh/o10fx3rAUNKrMAxvm3YYGf/jsKfmcl1pU0Q4cNmmTr6RmYiT3xRauioVkQC2Fn3RedzD0sLpG6LeTlwvG93AnZVUfNkraYnWtw4n2JzrMajODXFJx4Plx2QJve2c/jeJ91vZx//h5LXb35zcx92+9o80uQof8Y1CBE6Ec0I9PIn6hhXt0vpCvk0Ho8dBAcR0ZmxjqFlU7Og19JmxhDXwqUHelJhF1US5t28YHBeJOzBkqgDWpVL8UK4snZRLrsGdi+FwG+ae1IvHxKvgmLgeT1IHCUqRSBS+Rpsncy1JdEpPqyCcS2HE7bVrBX3yt+cfmgHRpoUqYe5eVqA0DQBRnJ8r0t5Q7jY1ScVrFfEIwo0LBN7xDUEPzGR/C9obrUIyxwUAmBs73W8USIwwv1KtsMGrJRayVrnnHL244YKhChAKDcXTCOANSGJCOCDaipy2NnQ2rPT8QRCdSGj2w+P2FJOsXx79B3k/fGvdgJqak0hMfkzC0qAhsGXfyRjbWOXns1H/6wroSmuoSy2vOWeZ93gzpEMky66XYkLsSP8wnKRsuv0v38xVvatvfc/7sJA7qDX1fkTYvWM7RnRjQL0Wl//0+AXKUBtARIzy5xb42gW9+xxZdSKgeN3o/hUiPQTMpoY1UB2q5TN1hEaOdAR0blVthYx96jDLfqvPC47gHqaCi5B23JnFQT3lAuV8DKJTNxrHIp/E2HzTwwAPPL1/x1Fz/xIdzTLj0JP02I9008szVvhDc7nznNOpo3qq5/fEJiz8Msh/IoHR8MG9O5r+Y9y42KOdTryVTf2nGszrv+y0/CqpHRy8e0cvG3pSa5hWUzbqyrWwOA0AT0Y6Nuab/eMgFkCuwrT5Tc7/AanN7aLvrS52p7O/4nSTT1L+NVoPf+bL69bhGrzWTFUtDg60G+rvzi1gN5ln/GxpRVSxOUKfjEfPTTACe+CzI+NEX6EyI6c0uOEcXXCIwSY308W5RibzSHPfyT6/KAXs9lmVVBot/6HHNiyLKflHkKYtUlEAjAzvzT1GJIjYZwCpxAXKNvwaOl616qIYK8aNglZ1ivRK4WYn0TB6vLIJX93bzz6IGRL7qfZGLPaTtbYZamybEDZ3+MztIJlABFwgCObiXcdv6bVjPzP+itcMdBp3bkhcbduTjNNHdS4PIVjImaHysqFAYquaUt8J+qJsF/owKAcZ4FgSfjX4X4x10JfkNzGIKQgEsSPUSYOSKyGyCXjOGUqHmBj5dImSGb3vFL+Zo5RGzoygmULKfV/hhmOXQHOGaHN+OqVA9nR+cYwQNgiJlwd43YAnb0RtxeK2lr30c6BiLLDpz6TrNAFb/MO59sTwR+8Z9RyXJniu2+09k2IBj1koRqh3+5/NRfuvacCwzJFlKGspqOkQ/3TZ2yIwGjgWWP+3GjM4TofcocKfAsRakTqYNrXcTKv4JJ2I+iL2DadQraXzp3qZCx1SHI6V7T9zQI01/sWrv0ARBMcTjqC4F4jMv1CZXFTlg6EsibNeiKSW3iQ5hvm/axU9IxhlClnTvE0AGH1B43qbfJ0eueM33d1OrVnEhn0BditKq0Xh+C9IouvT6zGUIbaLkmlZX1pM0RBdw1CAUb2uZeaLU41uNMaKQAKC6g6vIsZqZBzRdBNzLHPFQZG2+73Hgw3EecRNVSsiQPz1rA/INZ0nm3YWeQr/0xwHRkQ3N7f7mUhfemsF8Z/m/M/kBhOUp77Tt0R9koQih1GcBbspEVuaqUt0MpePAJnLn0zwNpagAVC9Tsh5HBQIO/zrHZhZLSeLMfjv+O+Mpr6A2EMqy7IG+6W2t4MqO7jF/+YTpsLtUGIw4nKgIsrNND+C+fYT1D4dFe5/mF8kwY06jJYXE4emPU7sOKySF+I3D3GmHlhY4cjy4BZubcv5+qkoNvuhHurZWaY2zXXJL5O7qafsw36jTwj48mcvRtd6mK9qhIKRohQ2MNBsup9YfpzFKDNydqN19vMFU+iwWRB0pVNKiejs027wrhUBG7YzGEKjrJ5MqXqPW80GiZOlyaYe4fCbbv818swAU4L4t+k8ZeXsCmFZrULSMCvYXQXlKFd5elE3CBUPxtRGLZOhWvaeULLHQ+XF+C6fjle1/ppCMKL6BI77JgYd4+0wlBpQxjyRorKG/XLXltg7AauoimIP+udknPHSh4wSKZDo/9xLbVRlvYxK/2znPieK+rNbf/cTsZcLXTlMQ8l4bqEpPTpEU+oiWsU/i60VQmHK1u+/qm0urEus/afI/2OiV6n3LuKXacjK20Oc3ePCDvvgtoeqofxvQ7LELds1idMfZ44Zhfsmoe+f5WU4Cpe/1p/Z0Nlc8+0Lt3ymfs6etQbD9E/lN01FciMJ+QI3nTG1bx+XKmzF0e2I4Qn8wUB04pmvZKNWq/LZB0JdlX0GPolQgSvovbe3m/8tRePLyC1r1xqUBzLYPKjWdKRs6fqtD/OEt7m/jDU1Du/x1tyfhoPw9lGX1C/Y1AAsmEejogQFZAMp3jxRXuaJ/vEp0sY8K3PSbP8SsivhsWpwryGZysHXXIb3CPUV2dgwe+irT52PFLCfhH3HxXzRwwN52mD4QJgA8Lcvf03TeyEq3OfPpEvbEDoJLtffaApGXgFFrmZUGM3RehCLWoe2+2YP3PfaeYuRmDrLoFSy48LtbQVpbNi0+4kNaRu4N27JjoeywxcH2zf93Rnm6jD8ivd/1pncP/cCCsHMaE/En8X9afUG3J+V93jHmiRhFml1cbuSqVHcngsv+TcEx5Jt6wR1Pzwkb0Cbi/ZY7ZoSiTisWUZ6ptxYXcfz8oHhd+jNDiaW2KDCIWHb3375+d0+U4g7IC78WWwB3V3XaGVZRnSo4o/B530tWxdViBrQlBWbSe3887J9EBRE2CAyinVZFbu2Vm8u1/+GAMK4xJKQsAxId3ofcmAIAKT9ZPC74fgP51vDe5CA4p/vrHzABD0JC+vwFHlTUANLdC+ZZ/c+XMuYh1pKbST1/J2XWK8zQ6JM0ZTIhF4G/eX5fwcpk/QAMbWSwwgemaCGE0+sJnMliwMtilq9LsJwC1FeRfe/NNqh0X1oQ4+O7gYdBK9BzTzyLgugRNfUxH4dUejP7L8J5wAv7Gh9PCbWdv7fRkVph4wWqdkm72G9/5kW39UvmTFeWsEs+IFyS0KDnsrPKRIzDPKxYInMQnF40xd9Z4Py+/47uj22eMw9tlyvlm/Qfjb+VXFpQY//l34UO36QWLulHJRhddWYJa8XcIb1c7XFpQUh+Y/sBledLf7YnqHa6t9jM2paRyQLMP0RZMuXffn08PpfTev2Kh7g35eAzDOAV4JeHrzSpv4fVt9U/y8rxm9jVxa5L4H/q6FnudMzdcWn5eauo0PcMRyvNM9/RSdf7ONur1aWeVLfyT0weE9XM0hHFqMqqAx0NdTtqEE+BXAphJdB3aG30OX8wz+84H/5vIeGPZAx/5ndf52q1TXOi4dOjwnO/zLw8v7o3aXO7Jr9OHUURyYbcDbf9e3b6ZkMIwR7ZYpaAYUn6NV2AtxnRfXH7JmamjT1bWNKbfHPEn2W3NE6v3f1K+pMQXCi5cmWfP5URkOvkuqDoRcmM+rd0IBlCGOFS70Eqi8AdXrXH12LLzS7L8nggIQTXyPiKrNdP7mgjbPPn227f1BrWlXgTogkAEBo33pflGuiFmpLEq63o9KHQ+eLgV6PaEmMoC2buTcg03FL1vS9YC709oCr45FWA1/mvRnqXBX0RxKK+LOfFtiMjKtB6yrqJISAldN+fGKwGy3LSZZ+ngjMIBesHWuZjyysjCUUnJMCI4aGyqVGAheqQl4lWtVcrk5EodJgc2mKAGvc45sg8J0jM+X5eICkvJ2XiG5Pf6PsEVNVmGH3AIBOwcbIe8ybo2bskhgUNCmQDSti7Xy7g6bKNy3WbSBq6p43O1QSVvH+08YWcuT7B/YIMJofALMC9uTCuTo9HfRIGaFG3PrebKB3P+RC7xA8o8A72UeeyBDX1f708RzrAeFitgk+WOEP4H2JyjMKBO48NEySg6mJ4RRtvmItTtnxhEahNKBSoShpZwUC13QlFCgvbVWvYxUP1uAdeyD5K3Ad/ZO4VNqIPejhaxyshCACEQ9k4n+7NNHwDgi14LUArNGH7iWlWXziS5Ptdsl4D8Z9RXXp7KlFc5GsEiwhYHlfpyCYn5W6MHSG9FhzpwmF30Nxh3JZbD81crYuB01SnoDtXTGvBQ5rZTbozo3VCEQb4zFvuCROkfSb9lbBja/xoqngS+8BLyLGUcVpch7dAF8E0k+dGi/tsDLb7u4nr7a16Z1YKZXCR/ir4r6lp25M2yEltMYdzezMUtx61C8N26C2WOf6vBsDmA00CHQTHA9dSXhwoTCtHnUmjjs1fTfgUByChozAuDP0MRt7BkwxwiOdT/ZobHGGmadSwIK+Ry7LzEW0d1HCIYN3qaEFHpM2rNhNe+BR1Efn+h4ItP/yrvux7G+WNITeirOFx10g0UCNMG9z7BMYSMoFUfBDOKNmeJI3V92CcnE85Evi0CX0q4ihvpuFzuxtD63dx06SoWEIuywg6CmSt2XjBCglmZA7YLUglf6oxtDap3SThC4xs2pl5yZxX4BJPsTthHYx6ZA33b0fg1Cj0EICTP2q/QD2ZCJAerVwEU157yZSXAEu4gsI9TWLrStDfFBpJqFgoIF5HhoUb6/NyTKfqeijkWzpv/CDb1Dfx16GHSM91vBnSOa3rm73wU25oOW9xfHJRl9scFF/5faNOuAbF7aoDpiegof9jk9LTL17cwnlBSZL4GtPdSQxK5AN702hSZ046uIG/sVE9YlOoZR9eXP0GSR5ozm/F9Gi8HVgZD7nD49FTHnUFE3tX5s8YZehR1tUyIqNspPAcCKDPSfbxQwe+sN8hUgd7s+HqH8aimfDyfv0K6BghoMQByhOBceOa8GlThE/RPQSNLQZiMwHyR7ZeFKb+J41QWurJK6f/ylyebid/wDyHIPc496FN0XwxFp6XCSMDDmjKljnwDIAVW0QazjhmXt7oliOFDanC83LigpAkAvBCFAu9Hr41PNmfpVMl5ggHb331ApEecsrUwOkTUk3TQKaerQRmYHNyyRSnE14cdVhd7hnL18xQDE8ailvn+J8+4TWLnq6+A9UAxW10wKKNRJn3347E6M83EZ0sGgaxaUUCWopld2sVVTFMZLTdS/9H4h0eDGzUsqKtZ2xm8myUSd22aULCYHhsyObB8U4eOrNus/C1Nb5nBS2IJkMfZ3im2mxpOGg6GeUl5W/YfBvEJ5YJfCTT9E3QjvHXiLpxVEjarJdnWe5gNbDbx1PIfHCgLCYd2D6hFoCM+zaDdVNW6n+uKJo7ZYmWZljJorV0GcIpWu70AVKeQBEZOPxKIdZ/ZLJW+eTNIzA05DpIqBQNiInRqPb83zNc1Mhhu1PBuKr3Fhb9o3uV8hAwXDJ8Iq40s5UZPdJ0HXx1bd/TCpNWjtK9duL4IiQjmFEUc5Xnu8FiIDFEcu2Pg/S2JgTicKM0MFxbtJmKf4tD4+y8z0RdSvLL7skfBowgBTo5J98tscLn4I8cIyiTVwgMhpLqbE4W9tJdc2swuZrKq5aChnvLtYCgN26ISJTn24PADOtYCByS4HpdT7HQfa7HWXDYpJXj+VsUTIxSF4BjLJS3oyUdfkI1/62bsqXZDISKcD1GNxhSauBcEi0vXfaQf0aLSxth3/maZF01CmkwAurmSda4SSh20S+tUVT6pZAGAbQq1XXTGmKRhQzW8Qmqc9p3prd6D10i8ch7SAohPtJmZWMtT4nc3fK1LlQQ+HSBYWZ/64WclzsJBaIPMWHSugJh5MnsXuCMqVF2oz8k7hPaje4VZOyIxTvEUgzn7mgEmHCIbGxPIRsNznY2mM+ujiZIPiUahHwRxLvsD21+JuwtHXjLdpGtWGHo2BEMDPfkxSb2EAPvlCAttaFDT9qFLrgCqM5z/9s0uq4Cf1McNF5d1tYLwIlHHrkQQF4RStQT7GNzwWIjhmVd5/ZfatAFEpCXPhOgLmtDktjaHe9IxAcdOR5Y7TBYqK7O1LzY8N77GzrSM2ONbC8vLi/vrNHX4UBZzIAieTdMusQhT7ie4FiTX4FwpBDaFB8wIEj6OTrUMEY59d5WAr42O3UgzmDaYK4gwbCULO6yw468p0K4z/itsaCncj2tPaLgriLteXdWzQjsJJ2jxMTlOwzU5yZMe5uE3sSnB2aMj9K9UWtlfNLFry/22qA5OM+m4atr3IwHSmDyHtucE0oTdqjMFRkfNVE/Gp4+umUQVbBCrigyIyoLeYHBWOTCKRCoKR3lEVWwFaawds0N2GzTKeaazjXM/aLFFYohiDkNifu8hC0JNduVCMGIwABWMZpiT7xSziZ+nxUiOTX+DVOSURnGfGIDTVt2cH9rtWHPxsO+DQ2sdnlf219jltMEOEQ5loUmqPfncsnJt+ToOw+TBg4OzGnheiKNh6mCw4S3HmGl+pxrHk2L6xztBtVcLOVi4kRFyqwgQUZEj3Z765I0DMaLACfP4DpTPtvVLBpx1VCW6faGbw1xiJ4YYlgQvOKynTK0LubraFHWkNWAmbya+psIZBktWXwSjayt9fCNXNIep/MDoQqS04BOPHQrLkQ+uasx6VmXN1WAjAKoWwytKhfCNDSvFG952Y31K2ysLXRB408GLLost/MBUrEqt5BZatvddWqW0sNirItfI6IcYqPvEaqEAW3KYoA62SbCudVu5AcZ23HN0NOizSmo1JKxlqdb3dSd3W8V3LVQNQjc7wZWmnETln/3SbmWgeYbrdXNPnQMeNP9PbMadg1pV01DjA7FtdT/R2PO+n/ej4JjkbUkKq71/0wLC2jKw2pDmePOkaAu5elkiVNjWghdODyFwnBei8TzxN5AYISxOqs0/eROcb5fFJNHMuIUxZaQFHD+QSEfhHFIKnwYVqipgmcv6Smtg34fKdupGjbSvqmB/UlV6knYGvEp0wY34HWJI2O4/xGQ59S5/U9QtMREoRQPYWmM5eKZ6LO1eGOArcikj+E8pxOl6EENYhFXrQW8XfO4IjCdUq776FG1O5bLBJlBo13ksALB8Y8VcNW0fuzte7Fz4aC41NgGSpPOz0N2AzXbF19cqtTpGT81u4E7JMFNeFhZZaCWr12OXhDqxzD/U4Wka5DG0w2RB6jjASsFurUZgY5Ly/jJfcJUxPNnuHwr9OBqafADTbSTrHxtRLgN1O086qVEU9KtGL/+jmNwGcMQ1sdq2nXMsdDyCpcyEdrda/G0oE+e5AfGK/oD4cCrAPUjb83Z5L+LcEoOUWt5Q8x2Iw3a932CGAyerPXgsFHG85F1d5qT7UXUA/Jg9LqkJwrIX8sXQCb3qev8ANpy8pl2aSzCUxKo+PGgHN2HRw8fz4gmI6fPHFhGo+psfJg2EFWCtMGP502yfARY2qG8lbPa1rRmtSm23FJD3WDU73weqo2YBcskzqSpA3dg4zWlW2uIUzI7C7AJM0AlgCZl/ERJptWgTS1jfsHq/R2znmwqyjP21qsNquOdmzD87xaIeIWt5q2JiluvOiawFSOXFhDaVQTmr7gAxy4L7hFvT1Lu/4bXLoJWh49sSMtSSMm7kIXGY85KhA32NM8d7vVFfN1Jg2i1wO0+t3w0CPAO1G06704vY3g9pyza+7OE1TASDbqqpZ8tYdKz5K9iHFCZNjKkFQcUo4QZjwtF7AI4oIYhqFilQNwHACE98VW100viBi17h7V8a1uACDdxYyD9a3ytXeJ3L7EbRh5xu7CVNMWQ4tbsVB5EIiVkOYvPOkj8PLMD6JCuRj+CJRwyhw9Ts5xivPdyzi8lTm9Om76FYPwDm+3PJwrRG8X73SAUrxTiIcQe0G8XEUsOoQXAgWbEP4V62gCv2GvZ2opnBqsvFIfj35NDW0TjVjnddA3o5X4+SadmgHQGjy6C7PzhG+xnzQaRFkz3jSFk50CmS4BEczI3ye0CwzyuQkz+kZ5xBfdWQpNeboaFDIlZgLBYnqBQWa+53RcE2AvWlGqcfNHN85tBqc10VKr2jYqd9fQrNzzrAKV1ND3hT/eIco9+JxAH0DqYROAnMe25ccmcP/pUafM50QCHWem4KUEIh8Ff39q4dxJ250OIUJG3/twBNSjI92Pw5NkQbKduXOSZDz0ztKZ8CNCZeP12KDCeXvfOpl1VR6cIyMsCojDFSk9f8AWBuKtqyOXb2KyTksZDCcged/MZ5HrWmA9/aO/Aso0qFMlRF8ZYaHjYpqxLHYAj2g+cegGz7IbiF02sULKJkMFJOIUnZUPy2nFgmQyL1Q6LrtcHX8Q4T96D4cfDj+sWUv2Js5NMoHHrb946JIk/i+HAz7xfXdBO4WI6B2I5r9QBhHyqmAFCMEPU5FCTuK+eWun92Niv4zlwVv7vxDa6vzMDkP4znGpVKW32PouBz54x47xLX2xr/IbmkwQJ2KzKFik8cCprBUGLcp9y/KpCpNLqXfjAIyrdBNlN6JDQ5QLsTsxnlVVWgkTmf2ad9ipcRaA/MCjJCGipQAAHnU0yMo8aIuUgibBGfYeDk11lO4vwGoRqNFxw328Uk9EtQ5AA3qRSyKdFqxxn26TDZwM7b6NgqBLDB7HGafAEE92bAjSReUkrYqtc0JxcG1FW1fU28jzxJKuXcTOxlAeh6OJ4SiNbKbtagaLrC/1dj8M3G7R6V07arsRFY7l7fxATEBJZR0YcH1c5cWYnkDdgcipZFqFUhMJRtx2kFAkYNVIUAGv/oxf77RgkgaaQm1NqzgHIUtxrqlqSoUKHBNHlN6xCwt8GkabGsW1TlsWfbfVN1F2wsX4FZjK7JPxVjV90IF7AXDaM28HBWpUWLhBrh45SGNc4ROIddyx5sX3xm8d5r0APPPPjcMJRsRAxnE9ddZ8nhlJgYB7CV32F2cDSAvi+LF2U3Y/x/kYoJaShKYm7+YtDYnCKNg4wnw0SV8XSceSUCw/vaR7fTylojDIKKoF1Do0Dd3TxuTdy6E+m3hef6ICxlyl/dK4pP+ckSV5GLEObyJ5pThhgsqd4BMDX0vSzMX7GWCWmSJKIpYaJcxIGpXVpPKoET4/EaE3iBOg346KlUFg4wtTqDCgH9pFelhG0SMvyeVkBRp2fSDRlVMeOp3tCSTjicgjUqjITeK1xucc+KDyng8wTdC3S06H7dLP+Qe4KChU6GKGpqFO1XmIisjj81ir6dcQNR5d5hDcXFpTIRhp9TErhFlJy3CLFqF/XAyB2GsURekZbSD4D1mROteW2G55900JbZxmY9942x7AP0yvljk0FulbYlYTsR7g8w/FQiCHhnUK4I+EovkYZf1fhAe/7rlaP478ZMWmP2HJowREiQqeOvdfAZSebbvrjRXz/x+BdwNCNzvexltVSMwnDyaWkeJ9dWpe/yt03EySQ4espFmblibgWqCmQlBkEPgIdcVHiZGNq5sRI4IuSbFkxQbCy+bkVV1JIxPA1dE8VZ257K2mlKFtQrCTw9a72P2F4q99/tPzNIrInh8I5+3WnP25DXADcVmg3/j8YV5BZyRQ+m7hNUUkGmMCgqhudsQ8kne9gKtkNzJdRaXpPkssJCBO+VQTiMqqF1aWZYK3QqvjiJ3Iqzahq6h75dtB46VVuwqft+24D2PghL/KZRK1OnUrsknHmpVp2ehAzT9ctII2d5d/Fl/7wD59LjCZOSHa7OQM45goCMZT3r8BTf8X9yf/TWD3B/UlhItJXIdCd0X9WrCKHOx5+ayL4TXty09gDPNsaTI0lLqsjHEb+JXifj93vFK3YmJkFJgX1oAkKXCdkDWgKVsj2Th52mLlp2pvuDCoQvnCbafAfmbBJqJWLxANC8/LvT1ZsRWaVCFV1xtPNSf/j7tKlnoYqcSWFjwJouJLc5kUpzNg8vD0FMogeHGGntpLdRpzaYqY3XHqnlgd5gTKLESmpZhRTx4malxq92S4WDZlmNqIdEoey26LVs/D5zRenJGKKhzW3uyU7e1vTtn9QOhWYWL6q/mbLSsCscyIpzhp+gUJTeO/wI1H/KqYi7uYJIk8q8wT+hrKR2X2s3wsvVpH6i51tlP4z5LIzzb/y2RKTVxy+uA2mRGPBARd1whkGyL1pgkmg4/kBwSYhMGZct3SOlo1PhBJcRmawAzUFwa7E6wWeYfHQI623raRYuXRYzm7OXCGlMh5+ZjN/RjvaANcOBUwOHPi914jCrC91E7yNskZ9GqAqbSbZyN7HvAgj2iYCndnjJGhgdnoHRuGDfi1GxeBbi4scdUS+08RAvCmY09twYp6pzda+2mPu9R+PAmw1FncU45gDA/qYVEbheN+38yBlKT5+q17QnXDLjtOe5fqTaTqtN3b8Z7sBU4qhJQZ5ok9DAlbPPG+R9rleLL910OHIZlVoBj6yWJhIIYgeisP6MJKh6l3MU38ioPYPpKVAUC6V8NypsbFQ43PYvjRUvRnRT7oCsANDnKZ9l62lDNLDuiiWsVFgMxt8TzdqTHUc305C8mPCiJv/LsenUUUgxS5obDQkIFW0hwnyXnozq2Hq6MMRFyLsn9t9GjrXbtmjktGEwpTUIq8hAukZiKAn4FvnZEIafGtrYacyKyLT5jQO6qDvdh5sYcwNWyoMcN7vTnKOXXahwMsLtWnvEbNkrLDAMQn6fDPSu7KKtxguldNe9X1C+LMxhl+S3aAT4qkyq728LWYZjwvUaSmDiYKL3WArshU0Bz7Em5PcfqHz6tNq6AoBIwfiu7OTQ4d5f4Qslwl4xWgIiAlUSGG5FE2D7JVLWAaD5wwSRSGTY7126vOu/7jYpUuwu4DmaGoZEnACswkUJFE2h1akrKZwqgB4ox9th/vm76RUFv7EXypRCMHX52bWXtH0LwpwwjB4fLPB+ZpPJj0iqf9HqOT7P/PmDDccEooS6G2sS6LNO3foRjak2PJrzWWR/MjVyAvUvdo1i/9xpBoJrpE3yOD0UsPyJZMcgCyz/ElbaGY730Q4TpRbTOiJvXBJeOwu9l2oGrvXVqBaR0SZtYZVikz73iUWb51p/mB1EX0/DKhe0ZBTOZjcqsA3TFfXG82Mfq7w1ChoGlKpo+hoqFUtQfRfgRdx0aiLLPkyH4R9ZXm+UTK1/UYPOpLAVgTn6qcdL39e0Jw2nyziblZec597aAs7JyMVyHlwDEtyqwyq5cCzKWoy7X6yb4kLoF0Ojvq4cQ+o+gNxO7Oy51866UCUI5w172Ny4IhHftAwKIDNIUgucazXNpUOIAD/XJz2cYUHHTKUf3nwyS3PNiD1jZjNhdTRyOt1dA/OSlcMgmV9amCNaGWPh9+eqDpA03rG6MZblU06t/dJ6uJp0wkB41oG77qoSoa8ZiqYDbwKdGjzhRxolol1ek+spcGAlO22C2aoMCjzVPvkibfdMM+Re38zASTFFAAauI69WXrPNFckbsd5fpGnXYgTOHW9KizpJKTjlj72zEchxqQN7wwZO/PPfmAiM0PU/SB46VmZ/VIsDCAwgUvUVUw3ENi12SW5RGdC5tdk7F1rmolGbf/WKi/sJQUuxpHRLBoxg4rqGZUF/4adRQACh+NCX9XvrA2AekQwwm7HO+0szOIDZuLbgTazsG65AMO+TDPf7FsOHwwpt/ZUnNnJC/PCCWB/Gyg8iMm6ADVjz5/g8JE7uJQOQJOJnImERngAUnFnfc7DKzfhq5XX7NR5WaY6z1Yglwe51Yunv3+KrxCZX6Tf83NnDk1Jm1dBzgHdnye9LTrJx+5TOWpWW3jGtVjzdYIJJYkY/7jktgvds3aNeP5U8YAwGUEZrs0ZEY054Rulskdb6XlNUvtZmq/kcnC3E3Htpk3U/ZtcvCT1TsXxcUHb4/FfjA6Tko7K45jN4/2ZdcEqZ741nLnGRTgcJ/tM4VvdAdQIOucPw4fTBenrDn0nllliSvpFqHK715fi75N9ZYCtlF5mO2Vc6b236t5Dhh4CLDeoM3nKBmjs22nsRVtfjyp2boDz2mB7B/3LclmZwHp80M9OY5w9HM8GI3i6u0ztfk5lpu31zroy41KDAtuJMvOpu18rlw1DDwxYkBXibWHdfMWgDaBds8Z80INKc6QowSGdKRxQKmXCaBpdlgoQxgemLtXP44tfclqgBiTK6RsuOdQnIJ1u3o7HfFbf0iGHkMTPK6QqRe2mE0qInIB7/O+RIKeJZ2vEJsFOg5ewIzPFV+zXrADGCnwm4qYfftRbxUFJhRImzieV8RQwCkaOaN61Zl8y2jkttXzLLrS9TxvJjGTOdXanJe+YzXUjudNMV9GN6GIa+vZH8kRhaGXrC2IjSfmgtWwUGs6gKJkHoNyz3X+WwbmN8nw8gNkd7DZ2Einv7If/kQiZzpEEIZKG3h3SoL0i8R/lMeL9gg79uSSCP4YFb69A6bVdl3KpXs9eNpwrrgxARTx510j2913qL0L45F5tc/sDzZnIeJEL5fy5RSb82lYp3NGesknDCYq57QH6q8exej2EoBmGh0dr9Xxf2a582WgBW6Dui2G0wjF0qWPXsEK/6KsVkwnMsEwJpldh2s2t0iiTKHTF4xVtBm51rk9GnhPgI/dSJIDbYS9N+rmUOb2PRpf20ZD77inxKCrpzESjVs0T7ss/Lw3CoOonwIy564fst/bpv7fkORGtz3g/ga8K18Am6Xl+yQYRXsJBzW7sElQaEfstS8sMUkaq9lFtdG5g22nczUwYq1LWJT0PiIZIK2h912ANPFymySIfjrf81UEuN6cgGWsBizFUdq788Etwew0fTAxBnspfACsd3B4MkGbzepCFGvDsmcu6ewImpMOdHLxYPHDn2ufCYRBGyd1Z8F1tqTUzyJHUjZtEOPHhuh9Yg44bJvuWbUIonkOExD7UABv1rUH3Pm7A5gzzBug8yjPRQH0qIpr+VJvIv82HLl2DZ7n73rnOEr5YTtKuRLNanvy66Fqpj8nxaVROvei3pqy0qgsr5oC7yxDq63Xl/UViADtPnipIqO3/rH0HPuQ2NTUxOvaJdfyxWcQiTZqkyUYPn0RPO7+aT2ckEjWiA5MEO94BMN+ax71HvdC29doDBldWzAvQiN6PfhtdNC6J/GYT2Xa0QsZdEkmt+jhcFapv6W15Qtj1fvQOJF3QtG7fmF4hZYCNaGTZ6UljBtxWpucehZEEZ/kofPhNShziHPS4VBoUROvEFjWYszUBILsZbXwiRTaphmWis7GuYXulriDswDsuUf0NHPnxo/D362OaxLdGd0Lb9hYYxYArxIDGeW7s3FEjetCYIoUUm8NbXvGBlIFfBP3VDb7TA9DAXoUmzAyDGKiRskpG7vhTMWkx6I99LxOSzMUeuMGyg7huYnP97HI2sDxd6aVy0/3aFzma9OtL7Ek3YMxVwmFh5JVuWZprfE7WwGp4tGkfQWJXdyXNJ/IjhyOy//bHvGz+YoOXyaKZWwayMxVevcGIhK9JW5tQ7i+24VlsKKU3Rx+doFwJgkjPsfehGimcZBbxUCrtrfMflMCi7h/igV2oiQsvnugYvbimZTz0lj4jIJ7i9aMikjM4ka9Gw48elsbLE0c1QaZe09UsFIhiiY4sTOE+Gobxe3aZtPMiPAsHkzD5pQIAQNxAa55eiV4+8WVXyfR5q53A+SF4p4AuenGTPL4jv+iRSZLSL1wAYvmu/RpYEq7FYA9lFBxNl+wmz/LUAMxlr/D3LxqO0ORPEnzPI2Bw4j1BDaTUUq9bP3c4KZquS/dCtoo16KWQ7dPezBVWmrQuaNNG9oAwxj8nIF+p5W7kSr/jWo2m1ZZCCUqcG/JuYFv0aLeRd3pOMTS1KXg5hxs5oT15kLU+9FXFOlULanWoJjQ2DyaPSw9Ulvaq8hJ7Mxmzm0oh8NdjOBdWFoSvj3l2iZ8iU5Dgm9KuEkEOyra5qjFQDI9iRTHqgdT11O0ML+hqbs7z1mgeZWcuTNBEz37pyX8fUgrfdiwBD+NWs6Es2289FX5a4HlUTIWFu8HgFEuSPpiHb5n3oDnS2u1mIFovwa5mdGnhmUmwfxJHiq9Or8XFnpOiNBhtM1YNV+ga+R5XnAZa6q3TGDdeeDuj5oRku8mtSkD/0+aPkgbLB3DAfP4fTRuhkp5L/84/p2xwoWIClaikskBt5efbwZRKBDURsBmjHfjwfRK4k26bhKy6CfbjboOcdsm7pxYAChmUqs+2gGRsAJMAExpM027C6tutUbMEJKpkPp+PS82BT/mEKrA/V9mBj6HJcOwq+HV5ebhP88FXRcnY9ZA4LJcJJXN1QiwA4UGnjPPfGgRIMNYzow8Ymm9kCwGPmx/reCc2YkT9ZnJdOBL9UGH3nOmmBeh6CzPDAPZZLBvWE5TK5p8DK6Yvl+WtQ/wId4+mmL4m5ZZHTHDby4KlfphKpz1KV6ImccfOZD9TNZu8eez6xcBfM+cr/sJj4nZnpMc/MKefP5L6OPm/0uztU3HU88uRZIX6ORPiHNWlgdIKkpq92fLvFuugZLT0ep4DPm0eRcNrIN7OV+KNE9Lu+5SGsVnk18qm4RW4ijwNxxd976NwYYNmKWoNI9QjcfQU2ySr0OlA8SyQqDhYMCmkMj01wwbR5igP91fyoB8qlHfJ2N2Z1FxLMyDatQu0nywWqFkZMRZ81eQrHwFt2ZyXlbSdwJsuyw=', 'base64')).toString(); + hook = require('zlib').brotliDecompressSync(Buffer.from('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', 'base64')).toString(); return hook; }; diff --git a/packages/yarnpkg-pnp/sources/loader/applyPatch.ts b/packages/yarnpkg-pnp/sources/loader/applyPatch.ts index a48cb1f4defd..c9db34fe8ce3 100644 --- a/packages/yarnpkg-pnp/sources/loader/applyPatch.ts +++ b/packages/yarnpkg-pnp/sources/loader/applyPatch.ts @@ -126,10 +126,10 @@ export function applyPatch(pnpapi: PnpApi, opts: ApplyPatchOptions) { // Check if the module has already been created for the given file - const cacheEntry = entry.cache[modulePath] as PatchedModule; + const cacheEntry = entry.cache[modulePath] as PatchedModule | undefined; if (cacheEntry) { - // When a dynamic import is used in CJS files Node adds the module - // to the cache but doesn't load it so we do it here. + // When the Node ESM loader encounters CJS modules it adds them + // to the cache but doesn't load them so we do that here. // // Keep track of and check if the module is already loading to // handle circular requires. @@ -139,6 +139,13 @@ export function applyPatch(pnpapi: PnpApi, opts: ApplyPatchOptions) { if (cacheEntry.loaded === false && cacheEntry.isLoading !== true) { try { cacheEntry.isLoading = true; + + // The main module is exposed as a global variable + if (isMain) { + process.mainModule = cacheEntry; + cacheEntry.id = `.`; + } + cacheEntry.load(modulePath); } finally { cacheEntry.isLoading = false; @@ -155,8 +162,7 @@ export function applyPatch(pnpapi: PnpApi, opts: ApplyPatchOptions) { entry.cache[modulePath] = module; - // The main module is exposed as global variable - + // The main module is exposed as a global variable if (isMain) { process.mainModule = module; module.id = `.`; @@ -390,21 +396,5 @@ export function applyPatch(pnpapi: PnpApi, opts: ApplyPatchOptions) { return false; }; - // Specifying the `--experimental-loader` flag makes Node enter ESM mode so we change it to not do that - // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/run_main.js#L72-L81 - // Tested by https://github.com/yarnpkg/berry/blob/d80ee2dc5298d31eb864288d77671a2264713371/packages/acceptance-tests/pkg-tests-specs/sources/pnp-esm.test.ts#L226-L244 - // Upstream issue https://github.com/nodejs/node/issues/33226 - const originalRunMain = moduleExports.runMain; - moduleExports.runMain = function (main = process.argv[1]) { - const resolvedMain = nodeUtils.resolveMainPath(main); - - const useESMLoader = resolvedMain ? nodeUtils.shouldUseESMLoader(resolvedMain) : false; - if (useESMLoader) { - originalRunMain(main); - } else { - Module._load(main, null, true); - } - }; - patchFs(fs, new PosixFS(opts.fakeFs)); } diff --git a/packages/yarnpkg-pnp/sources/loader/nodeUtils.ts b/packages/yarnpkg-pnp/sources/loader/nodeUtils.ts index 3dfb39d5e097..63c2c3e1506d 100644 --- a/packages/yarnpkg-pnp/sources/loader/nodeUtils.ts +++ b/packages/yarnpkg-pnp/sources/loader/nodeUtils.ts @@ -7,37 +7,6 @@ const builtinModules = new Set(Module.builtinModules || Object.keys(process.bind export const isBuiltinModule = (request: string) => request.startsWith(`node:`) || builtinModules.has(request); -// https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/run_main.js#L11-L24 -export function resolveMainPath(main: NativePath) { - let mainPath = Module._findPath(npath.resolve(main), null, true); - if (!mainPath) - return false; - - // const preserveSymlinksMain = getOptionValue(`--preserve-symlinks-main`); - // if (!preserveSymlinksMain) - mainPath = fs.realpathSync(mainPath); - - return mainPath; -} - -// https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/run_main.js#L26-L41 -export function shouldUseESMLoader(mainPath: NativePath) { - // const userLoader = getOptionValue(`--experimental-loader`); - // if (userLoader) - // return true; - // const esModuleSpecifierResolution = - // getOptionValue(`--experimental-specifier-resolution`); - // if (esModuleSpecifierResolution === `node`) - // return true; - // Determine the module format of the main - if (mainPath && mainPath.endsWith(`.mjs`)) - return true; - if (!mainPath || mainPath.endsWith(`.cjs`)) - return false; - const pkg = readPackageScope(mainPath); - return pkg && pkg.data.type === `module`; -} - // https://github.com/nodejs/node/blob/e817ba70f56c4bfd5d4a68dce8b165142312e7b6/lib/internal/modules/cjs/loader.js#L315-L330 export function readPackageScope(checkPath: NativePath) { const rootSeparatorIndex = checkPath.indexOf(npath.sep);