@oxy-hq/cli 0.4.0 → 0.5.0

package/dist/main.mjs

@@ -8,6 +8,7 @@ import { spawn, spawnSync } from "node:child_process";
 import pc from "picocolors";
 import { createServer } from "node:http";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline/promises";
 import { once } from "node:events";
 import { gunzipSync, gzipSync } from "node:zlib";
 import { Ajv } from "ajv";
@@ -47,7 +48,9 @@ const ExitCode = {
 	/** The server answered 5xx, or the network failed. Retryable. */
 	UNAVAILABLE: 7,
 	/** A refusal: the operation would have destroyed or overwritten something. */
-	REFUSED: 8
+	REFUSED: 8,
+	/** `oxyc checks run`: a check ran and failed or timed out. */
+	CHECK_FAILED: 9
 };
 /**
 * An error that already knows how it should end the process.
@@ -974,7 +977,7 @@ function warn(message) {
 	write(`${err.yellow("warning:")} ${message}`);
 }
 /** A failure, on its way to a non-zero exit. */
-function error(message) {
+function error$1(message) {
 	write(`${err.red("error:")} ${message}`);
 }
 /**
@@ -1977,7 +1980,7 @@ function formatBody(body, opts) {
 * shaped to avoid.
 */
 const MAX_PAGES = 100;
-function isObject$1(value) {
+function isObject$4(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 /**
@@ -1993,13 +1996,13 @@ function readPage(payload, page, explicitKey) {
 		rows: payload,
 		hasMore: false
 	};
-	if (!isObject$1(payload)) return {
+	if (!isObject$4(payload)) return {
 		rows: [],
 		hasMore: false
 	};
 	const rowsKey = explicitKey ?? Object.keys(payload).find((k) => Array.isArray(payload[k]));
 	const rows = rowsKey && Array.isArray(payload[rowsKey]) ? payload[rowsKey] : [];
-	const pagination = isObject$1(payload.pagination) ? payload.pagination : void 0;
+	const pagination = isObject$4(payload.pagination) ? payload.pagination : void 0;
 	let hasMore = false;
 	let signal;
 	if (pagination && typeof pagination.has_next === "boolean") {
@@ -2101,7 +2104,7 @@ async function paginate(opts) {
 		hint("if the endpoint takes page/page_size or limit/offset, walk it yourself: `oxyc api '<path>?page=1'`");
 	}
 	if (opts.slurp) return JSON.stringify(pages, null, 2);
-	if (rowsKey && isObject$1(lastPayload)) return JSON.stringify({
+	if (rowsKey && isObject$4(lastPayload)) return JSON.stringify({
 		...lastPayload,
 		[rowsKey]: merged
 	}, null, 2);
@@ -2431,12 +2434,12 @@ function invalidManifest(path, detail) {
 		remedy: "fix the file and re-run"
 	});
 }
-const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isObject$3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 /** Checks only the fields this CLI reads, as the types it reads them as. `null` is absent. */
 function shapeProblem(manifest) {
-	if (!isObject(manifest)) return "the top level must be an object";
+	if (!isObject$3(manifest)) return "the top level must be an object";
 	const notString = (obj, key) => obj[key] != null && typeof obj[key] !== "string";
-	const notObject = (obj, key) => obj[key] != null && !isObject(obj[key]);
+	const notObject = (obj, key) => obj[key] != null && !isObject$3(obj[key]);
 	for (const key of [
 		"slug",
 		"orgSlug",
@@ -2456,7 +2459,7 @@ function shapeProblem(manifest) {
 	for (const [section, field] of [["environments", "target"], ["functions", "entry"]]) {
 		const entries = manifest[section] ?? {};
 		for (const [name, entry] of Object.entries(entries)) {
-			if (!isObject(entry)) return `\`${section}.${name}\` must be an object`;
+			if (!isObject$3(entry)) return `\`${section}.${name}\` must be an object`;
 			if (notString(entry, field)) return `\`${section}.${name}.${field}\` must be a string`;
 		}
 	}
@@ -3189,6 +3192,380 @@ function runToken(ctx) {
 	process.stdout.write(`${token}\n`);
 }
 
+//#endregion
+//#region src/publish/server.ts
+/**
+* The three HTTP calls a publish makes, plus the trusted-publishing exchange.
+*
+* Direct `fetch` rather than `api/request.ts`: the upload is multipart and the
+* two lookups are public, and neither fits a JSON-string request with a
+* credential chosen by path. What they share with it is the exit-code mapping.
+*/
+const LOOKUP_TIMEOUT_MS$1 = 3e4;
+/** The bundle upload, which can be tens of megabytes. */
+const UPLOAD_TIMEOUT_MS = 12e4;
+async function send(url, init, timeoutMs) {
+	try {
+		return await fetch(url, {
+			...init,
+			signal: AbortSignal.timeout(timeoutMs)
+		});
+	} catch (cause) {
+		throw new CliError(`${init.method ?? "GET"} ${url} failed: ${cause.message}`, { code: ExitCode.UNAVAILABLE });
+	}
+}
+async function json$1(response, what) {
+	const text = await response.text();
+	try {
+		return JSON.parse(text);
+	} catch {
+		throw new CliError(`could not parse the ${what} response`, {
+			code: ExitCode.UNAVAILABLE,
+			detail: text.slice(0, 2e3)
+		});
+	}
+}
+function base(target) {
+	return target.replace(/\/+$/, "");
+}
+/** The project an app publishes into, from its `(org, app)` on the target. Public. */
+async function fetchProject(target, org, app) {
+	const url = `${base(target)}/api/apps/${encodeURIComponent(org)}/${encodeURIComponent(app)}/build-config`;
+	const response = await send(url, {}, LOOKUP_TIMEOUT_MS$1);
+	if (response.status === 404) throw new CliError(`app ${org}/${app} is not registered on ${target}`, {
+		code: ExitCode.NOT_FOUND,
+		hint: "register it in the oxy admin UI, or pass --project <uuid> for its first publish"
+	});
+	if (!response.ok) throw new CliError(`build-config lookup failed (${response.status}) at ${url}`, { code: exitCodeForStatus(response.status) });
+	return (await json$1(response, "build-config")).project_id;
+}
+/** The org a pinned workspace belongs to — a workspace has exactly one. Public. */
+async function fetchOrgForProject(target, projectId) {
+	const url = `${base(target)}/api/org-for-project/${encodeURIComponent(projectId)}`;
+	const response = await send(url, {}, LOOKUP_TIMEOUT_MS$1);
+	if (response.status === 404) throw new CliError(`workspace ${projectId} not found on ${target}`, {
+		code: ExitCode.NOT_FOUND,
+		hint: "check --project / OXY_PROJECT"
+	});
+	if (!response.ok) throw new CliError(`org-for-project lookup failed (${response.status}) at ${url}`, { code: exitCodeForStatus(response.status) });
+	return (await json$1(response, "org-for-project")).org_slug;
+}
+/**
+* POST the bundle. Resolves the parsed result, or throws with the status
+* mapped onto the exit-code contract and the server's body as detail.
+*/
+async function uploadBundle(req) {
+	const form = new FormData();
+	for (const [name, value] of req.fields) if (value !== void 0) form.append(name, value);
+	const bytes = new Uint8Array(req.tarball);
+	form.append("bundle", new Blob([bytes], { type: "application/gzip" }), "bundle.tar.gz");
+	const response = await send(`${base(req.target)}/api/customer-apps/publish`, {
+		method: "POST",
+		headers: { authorization: `Bearer ${req.token}` },
+		body: form
+	}, UPLOAD_TIMEOUT_MS);
+	if (!response.ok) {
+		const body = await response.text();
+		throw new CliError(`publish failed (${response.status})`, {
+			code: exitCodeForStatus(response.status),
+			detail: body.slice(0, 4e3)
+		});
+	}
+	return json$1(response, "publish");
+}
+/** The two variables GitHub sets in a job granted `id-token: write`. */
+function githubOidcAvailable(env = process.env) {
+	return Boolean(env.ACTIONS_ID_TOKEN_REQUEST_URL && env.ACTIONS_ID_TOKEN_REQUEST_TOKEN);
+}
+/** The audience the server pins. A token minted for any other is refused. */
+const OIDC_AUDIENCE = "oxy-publish";
+async function exchangeGithubOidc(target, orgSlug, app, env = process.env) {
+	const requestUrl = new URL(env.ACTIONS_ID_TOKEN_REQUEST_URL ?? "");
+	requestUrl.searchParams.set("audience", OIDC_AUDIENCE);
+	const minted = await send(requestUrl.toString(), { headers: { authorization: `bearer ${env.ACTIONS_ID_TOKEN_REQUEST_TOKEN}` } }, LOOKUP_TIMEOUT_MS$1);
+	if (!minted.ok) throw new CliError(`GitHub refused to mint an OIDC token (${minted.status})`, {
+		code: ExitCode.AUTH,
+		hint: "the publishing job needs `permissions: id-token: write`"
+	});
+	const oidc = (await json$1(minted, "GitHub OIDC")).value;
+	if (!oidc) throw new CliError("GitHub returned no OIDC token", { code: ExitCode.AUTH });
+	const exchanged = await send(`${base(target)}/api/customer-apps/publish/oidc-exchange`, {
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${oidc}`,
+			"content-type": "application/json"
+		},
+		body: JSON.stringify({ app: `${orgSlug}/${app}` })
+	}, LOOKUP_TIMEOUT_MS$1);
+	if (!exchanged.ok) {
+		const body = await exchanged.text();
+		throw new CliError(`trusted-publishing exchange failed (${exchanged.status})`, {
+			code: exitCodeForStatus(exchanged.status),
+			detail: body.slice(0, 2e3),
+			hint: `is this workflow registered as a publisher for ${orgSlug}/${app}, with the same repository, workflow file and environment?`
+		});
+	}
+	const body = await json$1(exchanged, "exchange");
+	if (!body.token) throw new CliError("the exchange returned no token", { code: ExitCode.AUTH });
+	return {
+		token: body.token,
+		appId: body.app_id
+	};
+}
+
+//#endregion
+//#region src/commands/checks.ts
+/**
+* `oxyc checks run <app>` — run every function an app marked `"check": true`
+* and wait for a verdict.
+*
+* This is what a release workflow calls once an environment serves a build: it
+* POSTs one run per check, polls each to a terminal status, and exits
+* `CHECK_FAILED` (9) the moment any of them did not pass — so a release gate
+* can branch on the exit code alone, the same contract every other `oxyc`
+* command keeps.
+*
+* Talks only to four routes (`GET /api/admin/apps`, `GET .../functions`,
+* `POST .../functions/{name}/runs`, `GET .../function-runs/{run_id}`); nothing
+* here decides whether a function IS a check — that is `FunctionSummary.check`,
+* which the server projects from the manifest flag.
+*
+* Two surfaces, same handlers. A human runs this with their own credential and
+* hits `/api/admin/apps/…`. CI has no credential to store: in a job with
+* `id-token: write` it exchanges a GitHub OIDC token for the same short-lived,
+* app-scoped publish token `oxyc publish` uses, and then hits
+* `/api/customer-apps/…` — the same three handlers, mounted where a publish
+* token may reach them. The app-listing route is NOT one of them (a publish
+* token may not enumerate apps), which is why the exchange returns the app id
+* rather than leaving the CLI to look one up.
+*/
+const TERMINAL = /* @__PURE__ */ new Set([
+	"done",
+	"failed",
+	"cancelled",
+	"timed_out"
+]);
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** Hard stop on the admin-apps walk, mirroring `api/paginate.ts`'s `MAX_PAGES`. */
+const MAX_APP_PAGES = 100;
+async function runChecks(ctx, app, opts) {
+	if (!Number.isFinite(opts.timeoutSeconds) || opts.timeoutSeconds <= 0) throw usageError("--timeout must be a positive number of seconds", "e.g. --timeout 60 (the default is 300)");
+	const target = ctx.target();
+	const machine = await resolveCredentials(ctx, target, app);
+	const creds = {
+		target,
+		bearer: machine.bearer,
+		headers: machine.apiKey ? { "X-API-Key": machine.apiKey } : void 0,
+		surface: machine.surface
+	};
+	if (!machine.appId && creds.surface === MACHINE_SURFACE && !UUID_RE.test(app)) throw usageError("a publish token cannot resolve <org>/<app> — pass the app UUID", "resolving a slug means listing every app, which a publish token may not do; the id is on the app's admin page, and `oxyc publish --json` reports it");
+	const { appId, label } = machine.appId ? {
+		appId: machine.appId,
+		label: app
+	} : await resolveApp$1(creds, app);
+	const checks = await listChecks(creds, appId);
+	if (checks.length === 0) throw new CliError(`${label} declares no checks (no function has "check": true)`, {
+		code: ExitCode.FAILURE,
+		hint: `mark a function "check": true in oxy-app.json to give it one`
+	});
+	const results = [];
+	for (const fn of checks) {
+		const result = await runOneCheck(creds, appId, fn.name, opts);
+		results.push(result);
+		if (!opts.json) printResultLine(result);
+	}
+	if (opts.json) {
+		const report = {
+			app: label,
+			appId,
+			checks: results
+		};
+		process.stdout.write(`${JSON.stringify(report)}\n`);
+	}
+	const failed = results.filter((r) => !r.passed);
+	if (failed.length > 0) throw new CliError(`${failed.length} of ${results.length} check(s) failed: ${failed.map((r) => r.name).join(", ")}`, { code: ExitCode.CHECK_FAILED });
+}
+/** The prefix `oxyc publish` mints and the exchange returns. */
+const PUBLISH_TOKEN_PREFIX = "oxypublish_";
+/** Where the three function routes live for each kind of credential. */
+const ADMIN_SURFACE = "/api/admin/apps";
+const MACHINE_SURFACE = "/api/customer-apps";
+/**
+* A stored credential if there is one, a minted one if there is not.
+*
+* Bearer wins when one resolves; otherwise the API key. Neither resolving is
+* not yet an error in CI: a job holding `id-token: write` can mint, so the
+* exchange is tried before giving up. Only when that is unavailable too does
+* this throw the SAME `authError` every other command throws — reusing
+* `ctx.bearer()` for that throw keeps the message and the `oxyc login …` hint
+* defined in exactly one place (`context/resolve.ts`) rather than duplicated
+* here.
+*
+* A publish token — minted here or handed in through `OXY_TOKEN` — reads the
+* machine surface, because the admin one refuses it.
+*/
+async function resolveCredentials(ctx, target, app) {
+	const bearer = ctx.maybeBearer();
+	if (bearer) return {
+		bearer,
+		surface: bearer.startsWith(PUBLISH_TOKEN_PREFIX) ? MACHINE_SURFACE : ADMIN_SURFACE
+	};
+	const apiKey = ctx.apiKey();
+	if (apiKey) return {
+		apiKey,
+		surface: ADMIN_SURFACE
+	};
+	if (githubOidcAvailable()) {
+		const [orgSlug, ...rest] = app.split("/");
+		const appSlug = rest.join("/");
+		if (!orgSlug || !appSlug) throw usageError("trusted publishing needs <app> as \"<org-slug>/<app-slug>\"", "the exchange is keyed by slug; a UUID names an app it cannot verify a publisher for");
+		const minted = await exchangeGithubOidc(target, orgSlug, appSlug);
+		if (!minted.appId) throw new CliError("the OIDC exchange returned no app_id", {
+			code: ExitCode.UNAVAILABLE,
+			hint: "this deployment predates trusted checks — upgrade it, or set OXY_TOKEN and pass the app UUID"
+		});
+		return {
+			bearer: minted.token,
+			surface: MACHINE_SURFACE,
+			appId: minted.appId
+		};
+	}
+	ctx.bearer();
+	return { surface: ADMIN_SURFACE };
+}
+function ensureOk(response) {
+	if (response.status < 200 || response.status >= 300) throw errorForResponse(response);
+}
+/**
+* Resolve `<org-slug>/<app-slug>` to an app id by paging
+* `GET /api/admin/apps` — skipped entirely when `app` is already a UUID.
+*/
+async function resolveApp$1(creds, app) {
+	if (UUID_RE.test(app)) return {
+		appId: app,
+		label: app
+	};
+	const [orgSlug, ...rest] = app.split("/");
+	const appSlug = rest.join("/");
+	let offset = 0;
+	for (let page = 0; page < MAX_APP_PAGES; page++) {
+		const response = await request({
+			target: creds.target,
+			path: `/api/admin/apps?limit=100&offset=${offset}`,
+			method: "GET",
+			bearer: creds.bearer,
+			headers: creds.headers
+		});
+		ensureOk(response);
+		const payload = parseJson(response.body);
+		const match = (payload?.items ?? []).find((item) => item.org_slug === orgSlug && item.slug === appSlug);
+		if (match) return {
+			appId: match.id,
+			label: `${orgSlug}/${appSlug}`
+		};
+		if (payload?.next_offset == null) break;
+		offset = payload.next_offset;
+	}
+	throw new CliError(`no app "${app}"`, {
+		code: ExitCode.NOT_FOUND,
+		hint: "<app> is \"<org-slug>/<app-slug>\" or an app UUID"
+	});
+}
+/** `GET .../functions`, filtered to `check: true` and sorted by name. */
+async function listChecks(creds, appId) {
+	const response = await request({
+		target: creds.target,
+		path: `${creds.surface}/${appId}/functions`,
+		method: "GET",
+		bearer: creds.bearer,
+		headers: creds.headers
+	});
+	ensureOk(response);
+	return (parseJson(response.body) ?? []).filter((fn) => fn.check === true).sort((a, b) => a.name.localeCompare(b.name));
+}
+/** POST the run, poll it to a terminal status or `timeoutSeconds`, and score it. */
+async function runOneCheck(creds, appId, name, opts) {
+	const start = Date.now();
+	const runId = await startRun(creds, appId, name);
+	const detail = await pollUntilTerminal(creds, appId, runId, opts);
+	const durationMs = Date.now() - start;
+	const answerFailed = parsesToOkFalse(detail.answer);
+	const passed = detail.status === "done" && !answerFailed;
+	const error = passed ? void 0 : failureMessage(detail, answerFailed, opts.timeoutSeconds);
+	return {
+		name,
+		runId,
+		status: detail.status,
+		passed,
+		error,
+		durationMs
+	};
+}
+async function startRun(creds, appId, name) {
+	const response = await request({
+		target: creds.target,
+		path: `${creds.surface}/${appId}/functions/${encodeURIComponent(name)}/runs`,
+		method: "POST",
+		body: "{}",
+		bearer: creds.bearer,
+		headers: creds.headers
+	});
+	ensureOk(response);
+	const payload = parseJson(response.body);
+	if (!payload?.run_id) throw new CliError(`POST .../functions/${name}/runs did not return a run_id`, { code: ExitCode.UNAVAILABLE });
+	return payload.run_id;
+}
+async function getRunDetail(creds, appId, runId) {
+	const response = await request({
+		target: creds.target,
+		path: `${creds.surface}/${appId}/function-runs/${runId}`,
+		method: "GET",
+		bearer: creds.bearer,
+		headers: creds.headers
+	});
+	ensureOk(response);
+	return parseJson(response.body);
+}
+/** Poll every `pollMs` (default 2000) until a terminal status, or the client-side timeout. */
+async function pollUntilTerminal(creds, appId, runId, opts) {
+	const deadline = Date.now() + opts.timeoutSeconds * 1e3;
+	for (;;) {
+		const detail = await getRunDetail(creds, appId, runId);
+		if (TERMINAL.has(detail.status)) return detail;
+		if (Date.now() >= deadline) return {
+			...detail,
+			status: "timed_out"
+		};
+		await sleep(opts.pollMs ?? 2e3);
+	}
+}
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/** A check fails when its answer parses to an object whose `ok` is `false`. */
+function parsesToOkFalse(answer) {
+	if (!answer) return false;
+	const parsed = parseJson(answer);
+	return typeof parsed === "object" && parsed !== null && !Array.isArray(parsed) && parsed.ok === false;
+}
+function failureMessage(detail, answerFailed, timeoutSeconds) {
+	if (detail.error) return detail.error;
+	if (detail.status === "timed_out") return `timed out after ${timeoutSeconds}s`;
+	if (answerFailed) return `answer reported "ok": false`;
+	if (detail.status === "cancelled") return "run cancelled";
+	return `status ${detail.status}`;
+}
+function printResultLine(result) {
+	if (process.env.OXYC_QUIET) return;
+	const seconds = `${(result.durationMs / 1e3).toFixed(1)}s`;
+	if (result.passed) {
+		process.stderr.write(`${err.green("✓")} ${result.name} ${seconds}\n`);
+		return;
+	}
+	const reason = (result.error ?? result.status).slice(0, 200);
+	process.stderr.write(`${err.red("✗")} ${result.name} failed: ${reason}\n`);
+}
+
 //#endregion
 //#region src/commands/customers.ts
 /**
@@ -3650,7 +4027,7 @@ tokens than the same rows as JSON, which repeats every field name per row.
 
     0 ok · 1 it ran and found problems · 2 you called it wrong, stop
     4 log in (\`oxyc login --env <env>\`) · 5 not found · 6 malformed request
-    7 retryable (5xx/timeout) · 8 refused
+    7 retryable (5xx/timeout) · 8 refused · 9 a check failed (\`oxyc checks run\`)
 
 ### Beyond the API
 
@@ -3689,7 +4066,7 @@ function runGuide() {
 
 //#endregion
 //#region src/generated/version.ts
-const VERSION = "0.4.0";
+const VERSION = "0.5.0";
 
 //#endregion
 //#region src/publish/manifest.ts
@@ -3702,6 +4079,31 @@ const VERSION = "0.4.0";
 * SDK field added tomorrow cannot break a publish today.
 */
 /**
+* Longest writer name: Postgres caps identifiers at 63 bytes, and the longest
+* derived form is `app_<name>_rw` — `crates/oltp/src/schema.rs` `MAX_NAME_LEN`.
+*/
+const WRITER_NAME_MAX = 56;
+/** `validate_name`, as a sentence to put in an error. */
+const WRITER_NAME_SHAPE = `1-${56} characters: a lowercase letter, then lowercase letters, digits or underscores`;
+/** `app_writer_name`: how a slug becomes a writer, as a sentence. */
+const WRITER_NAME_RULE = `\`-\` becomes \`_\`, and the result must be ${WRITER_NAME_SHAPE}`;
+/** `crates/oltp/src/schema.rs` `validate_name`. */
+function isValidWriterName(name) {
+	return new RegExp(`^[a-z][a-z0-9_]{0,55}$`).test(name);
+}
+/**
+* The writer an app owns, DERIVED from its slug — `app_writer_name` in
+* `crates/oltp/src/schema.rs`. `undefined` when the slug cannot back a schema.
+*
+* A slug that already contains `_` is refused rather than normalised: `my_app`
+* would alias the hyphenated sibling `my-app` onto one schema and role.
+*/
+function appWriterName(slug) {
+	if (slug.includes("_")) return void 0;
+	const name = slug.replaceAll("-", "_");
+	return isValidWriterName(name) ? name : void 0;
+}
+/**
 * `<dir>/oxy-app.json`, or `undefined` when there is none. A broken one throws:
 * publishing past it used to ship a bundle with no functions and an identity
 * taken from flags or the directory.
@@ -3847,6 +4249,16 @@ function workflowYaml(o) {
 	const bundlePath = o.appDir === "." ? o.outDir : `${o.appDir}/${o.outDir}`;
 	const pnpm = o.pnpmFromPackageJson ? "" : "\n        with:\n          version: 10";
 	const node = o.nodeVersionFile ? "node-version-file: .nvmrc" : "node-version: 20";
+	const promote = o.promote ? " --promote" : "";
+	const checksStep = o.hasChecks && o.promote ? `      # Runs every function the manifest marks \`"check": true\` against the
+      # build the step above just promoted, and fails the job if any of them does
+      # not pass. It mints its own short-lived credential from the same OIDC
+      # token — nothing stored, and nothing carried over from the step above.
+      - name: Run the app's checks
+        env:
+          npm_config_ignore_scripts: "true"
+        run: npx --yes ${cli} checks run ${o.org}/${o.app} --env ${o.env}
+` : "";
 	return `# Generated by \`oxyc init-ci\`. Trusted publishing — no stored secret.
 #
 # \`id-token: write\` is job-level and visible to every step, so the publish job
@@ -3911,8 +4323,8 @@ jobs:
         env:
           # The CLI's own dependencies run no install scripts in this job.
           npm_config_ignore_scripts: "true"
-        run: npx --yes ${cli} publish --prebuilt --dir ${o.outDir} --env ${o.env} --org ${o.org} --app ${o.app}${workdir}
-`;
+        run: npx --yes ${cli} publish --prebuilt${promote} --dir ${o.outDir} --env ${o.env} --org ${o.org} --app ${o.app}${workdir}
+${checksStep}`;
 }
 /** `gh api users/<owner> --jq .id`, when gh is here and answers. */
 function ownerId(owner) {
@@ -3935,6 +4347,8 @@ function runInitCi(ctx, flags) {
 	const path = join(root, WORKFLOW_PATH);
 	if (existsSync(path) && !flags.force) throw refusal(`${WORKFLOW_PATH} already exists`, { hint: "pass --force to overwrite it" });
 	const appDir = relative(root, ctx.cwd).split(sep).join("/") || ".";
+	const manifest = loadPublishManifest(ctx.cwd);
+	const hasChecks = Object.values(manifest?.functions ?? {}).some((fn) => fn?.check === true);
 	mkdirSync(dirname(path), { recursive: true });
 	writeFileSync(path, workflowYaml({
 		org,
@@ -3942,7 +4356,9 @@ function runInitCi(ctx, flags) {
 		environment,
 		env: ctx.flags.env ?? "production",
 		appDir,
-		outDir: buildSteps(loadPublishManifest(ctx.cwd)).outDir,
+		outDir: buildSteps(manifest).outDir,
+		hasChecks,
+		promote: flags.promote === true,
 		pnpmFromPackageJson: packageJsonPinsPnpm(root),
 		nodeVersionFile: existsSync(join(root, ".nvmrc")),
 		cliVersion: VERSION
@@ -3959,6 +4375,7 @@ function runInitCi(ctx, flags) {
 	const [owner = "<owner>", repo = "<repo>"] = slug?.split("/") ?? [];
 	const id = slug ? ownerId(owner) : void 0;
 	process.stdout.write(`${out.green("wrote")} ${path}\n\n`);
+	if (hasChecks && !flags.promote) info("the manifest declares a check, but this workflow publishes a draft — a check runs the LIVE build, so it would verify the previously promoted one. Re-run with --promote to publish live and verify what this workflow ships.");
 	info("next: register this workflow as a publisher for the app, then gate the environment");
 	process.stdout.write(`  oxyc api /api/customer-apps/<app-id>/publishers --env ${ctx.flags.env ?? "production"} -X POST \\\n    -f repo_owner=${owner} -F repo_owner_id=${id ?? `<numeric id: gh api users/${owner} --jq .id>`} \\\n    -f repo_name=${repo} -f workflow_ref=${WORKFLOW_PATH} -f environment=${environment}\n\n  <app-id> is ${org}/${app}'s id on its admin page. Then add required reviewers to the\n  '${environment}' environment in Settings → Environments.\n`);
 }
@@ -4190,7 +4607,7 @@ function runLaunch(ctx, name, flags) {
 	});
 	child.on("error", (cause) => {
 		const missing = cause.code === "ENOENT";
-		error(missing ? "`claude` is not on PATH" : `could not start claude: ${cause.message}`);
+		error$1(missing ? "`claude` is not on PATH" : `could not start claude: ${cause.message}`);
 		hint(missing ? "install Claude Code, or use `--dry-run` to print the command instead" : "use `--dry-run` to print the command and run it yourself");
 		process.exit(missing ? ExitCode.UNAVAILABLE : ExitCode.FAILURE);
 	});
@@ -4257,6 +4674,265 @@ function shellQuote(value) {
 	return `'${value.replaceAll("'", `'\\''`)}'`;
 }
 
+//#endregion
+//#region src/commands/oltp.ts
+/**
+* `oxyc oltp status | provision` — an org's OLTP database, from a laptop.
+*
+* A thin client over the admin console's routes, so staff can see and request
+* provisioning without a shell on the server. The Rust `oxy oltp` reads
+* `OXY_DATABASE_URL` and has no `--env`: it only reaches the control plane of
+* the machine it runs on.
+*
+*   GET  /api/admin/oltp                          every org, with a database or without
+*   GET  /api/admin/orgs/{org_id}/oltp            one org's store and writers
+*   POST /api/admin/orgs/{org_id}/oltp/provision  {"writers": ["app:<writer>", …]}
+*
+* All three sit behind the `PlatformOltp` capability and the admin scope fence,
+* so an org outside a bounded staff grant answers 404 rather than 403. None of
+* them returns a credential.
+*/
+/**
+* Provisioning creates a project at the provider and its roles, which is slower
+* than a read. The default two-minute client timeout would abandon a call the
+* server is still completing; retrying is safe, but the timeout reads as failure.
+*/
+const PROVISION_TIMEOUT_MS = 3e5;
+/**
+* `--writer app:<slug>` / `pipeline:<source>` → what the server accepts.
+*
+* The server takes a WRITER NAME, and a slug's hyphens are illegal in one, so
+* `app:store-ops` is derived to `app:store_ops` exactly as the platform derives
+* `ctx.oltp`'s schema. A name already carrying `_` is what the server's own
+* messages print, and is validated as the writer it already is.
+*/
+function parseWriter(typed) {
+	const colon = typed.indexOf(":");
+	const kind = colon < 0 ? "" : typed.slice(0, colon);
+	const name = colon < 0 ? "" : typed.slice(colon + 1).trim();
+	if (kind === "app") {
+		const writer = name.includes("_") ? isValidWriterName(name) ? name : void 0 : appWriterName(name);
+		if (writer === void 0) throw usageError(`invalid app writer in --writer ${typed}`, `from a slug, ${WRITER_NAME_RULE}`);
+		return {
+			spec: `app:${writer}`,
+			typed,
+			schema: `app_${writer}`
+		};
+	}
+	if (kind === "pipeline") {
+		if (!isValidWriterName(name)) throw usageError(`invalid pipeline source in --writer ${typed}`, `it must be ${WRITER_NAME_SHAPE}`);
+		return {
+			spec: `pipeline:${name}`,
+			typed,
+			schema: `raw_${name}`
+		};
+	}
+	throw usageError(`--writer ${typed} must look like app:<slug> or pipeline:<source>`);
+}
+/** Why the server refused, in the terms an operator acts on. */
+function refusalReason(status) {
+	switch (status) {
+		case 400: return "the server rejected the request as malformed";
+		case 401: return "not authenticated for this target";
+		case 403: return "the OLTP console needs platform staff standing that may operate it — and an active `oxyc assume` session closes /admin";
+		case 404: return "no such org here — or one outside your staff grant's scope, which answers 404 on purpose";
+		case 409: return "the provisioner refused a state an operator has to resolve";
+		case 503: return "this deployment has no OLTP provider configured — not an Oxy fault";
+		default: return;
+	}
+}
+function oltpError(method, path, response) {
+	const body = response.body.trim();
+	const detail = [refusalReason(response.status), body && body !== "{}" ? `server: ${body}` : ""].filter((line) => Boolean(line)).join("\n");
+	return new CliError(`${method} ${path} failed (${response.status})`, {
+		code: exitCodeForStatus(response.status),
+		detail: detail || void 0,
+		remedy: response.status === 401 ? "oxyc login --env <env>" : void 0
+	});
+}
+/** A 2xx JSON body, or the error its status deserves. */
+async function call(ctx, method, path, opts = {}) {
+	const response = await request({
+		target: ctx.target(),
+		path,
+		method,
+		bearer: ctx.bearer(),
+		body: opts.body === void 0 ? void 0 : JSON.stringify(opts.body),
+		timeoutMs: opts.timeoutMs
+	});
+	if (response.status < 200 || response.status >= 300) throw oltpError(method, path, response);
+	const parsed = parseJson(response.body);
+	if (parsed === void 0 || parsed === null) throw new CliError(`${method} ${path} did not return JSON`, {
+		code: ExitCode.FAILURE,
+		detail: response.body.trim().slice(0, 500) || void 0,
+		hint: "the deployment may predate this route — `oxyc routes oltp` lists what it mounts"
+	});
+	return parsed;
+}
+const orgPath = (orgId) => `/api/admin/orgs/${encodeURIComponent(orgId)}/oltp`;
+async function runOltpStatus(ctx, org, json) {
+	const named = orgOrHint(ctx, org);
+	if (!named) return listTenants(ctx, json);
+	const orgId = await resolveOrgId(ctx, org);
+	const info = await call(ctx, "GET", orgPath(orgId));
+	if (json) {
+		process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
+		return;
+	}
+	printStore(named, info);
+}
+async function listTenants(ctx, json) {
+	const rows = await call(ctx, "GET", "/api/admin/oltp");
+	if (!Array.isArray(rows)) throw new CliError("GET /api/admin/oltp did not return a list", { code: ExitCode.FAILURE });
+	if (json) {
+		process.stdout.write(`${JSON.stringify(rows, null, 2)}\n`);
+		return;
+	}
+	if (rows.length === 0) {
+		info(`no organizations are visible to you on ${ctx.target()}`);
+		return;
+	}
+	process.stdout.write(`${table(rows, [
+		{
+			header: "ORG",
+			value: (r) => r.org_name
+		},
+		{
+			header: "ORG ID",
+			value: (r) => r.org_id
+		},
+		{
+			header: "STATUS",
+			value: (r) => r.status
+		},
+		{
+			header: "DATABASE",
+			value: (r) => r.database
+		},
+		{
+			header: "PROVIDER",
+			value: (r) => [r.provider, r.region].filter(Boolean).join(" / ")
+		},
+		{
+			header: "SCHEMAS",
+			value: (r) => r.schemas.map((s) => s.analytics_visible ? `${s.schema} (analytics)` : s.schema).join(", ")
+		},
+		{
+			header: "NOTES",
+			value: (r) => tenantNotes(r)
+		}
+	])}\n`);
+	const provisioned = rows.filter((r) => r.status !== "none").length;
+	info(`${provisioned} of ${rows.length} org(s) have an OLTP database`);
+}
+function tenantNotes(row) {
+	if (row.status === "none") return "";
+	const notes = [];
+	if (!row.analyst_ready) notes.push("analyst not minted");
+	if (row.platform_drift) notes.push("platform objects behind");
+	return notes.join(", ");
+}
+function printStore(org, info) {
+	if (!info.is_provisioned) {
+		process.stdout.write(`no OLTP database for org ${org}\n`);
+		hint(`oxyc oltp provision --org ${org} --writer app:<slug>`);
+		return;
+	}
+	const fields = [
+		["database", info.database],
+		["host", info.host],
+		["provider", [info.provider, info.region].filter(Boolean).join(" / ")],
+		["project", [info.project_name, info.console_url].filter(Boolean).join("  ")],
+		["status", info.status],
+		["platform", `v${info.platform_schema_version}/${info.expected_platform_schema_version}`],
+		["analyst", info.analyst_ready ? `${info.analyst_role} (ready)` : `${info.analyst_role} — NOT MINTED, postgres_managed cannot resolve`]
+	];
+	process.stdout.write(`${fields.map(([k, v]) => `${k.padEnd(9)} ${v}`).join("\n")}\n`);
+	if (info.schemas.length === 0) {
+		process.stdout.write("\nno writers yet\n");
+		return;
+	}
+	process.stdout.write(`\n${table(info.schemas, [
+		{
+			header: "SCHEMA",
+			value: (s) => s.schema
+		},
+		{
+			header: "KIND",
+			value: (s) => s.kind
+		},
+		{
+			header: "WRITER",
+			value: (s) => s.writer_name
+		},
+		{
+			header: "ROLE",
+			value: (s) => s.role
+		},
+		{
+			header: "ANALYTICS",
+			value: (s) => s.analytics_visible ? "visible" : "hidden"
+		}
+	])}\n`);
+}
+async function runOltpProvision(ctx, org, typedWriters, flags) {
+	if (typedWriters.length === 0) throw usageError("name at least one --writer", "app:<slug> for a custom app's ctx.oltp store, pipeline:<source> for an Airway pipeline");
+	const writers = /* @__PURE__ */ new Map();
+	for (const plan of typedWriters.map(parseWriter)) if (!writers.has(plan.spec)) writers.set(plan.spec, plan);
+	const orgId = await resolveOrgId(ctx, org);
+	const current = await call(ctx, "GET", orgPath(orgId));
+	printPlan(ctx.target(), orgOrHint(ctx, org), orgId, current, [...writers.values()]);
+	if (!flags.yes) await confirm();
+	const info = await call(ctx, "POST", `${orgPath(orgId)}/provision`, {
+		body: { writers: [...writers.keys()] },
+		timeoutMs: PROVISION_TIMEOUT_MS
+	});
+	if (flags.json) {
+		process.stdout.write(`${JSON.stringify(info, null, 2)}\n`);
+		return;
+	}
+	process.stdout.write(`${out.green(`provisioned ${info.database} on ${info.host}`)}\n`);
+	printStore(orgOrHint(ctx, org), info);
+}
+/**
+* What is about to happen, on stderr — stdout is the result — and not through
+* `log.info`, which `--quiet` silences: this is what the prompt asks about.
+*/
+function printPlan(target, org, orgId, current, writers) {
+	const existing = new Set(current.schemas.map((s) => s.schema));
+	const lines = [`On ${target}, for org ${org === orgId ? orgId : `${org} (${orgId})`}:`];
+	lines.push(current.is_provisioned ? `  database  ${current.database} on ${current.host} — exists, reconciled` : "  database  a NEW database at the deployment's OLTP provider — a billable resource");
+	for (const w of writers) {
+		const from = w.typed === w.spec ? "" : ` (from ${w.typed})`;
+		const state = existing.has(w.schema) ? "exists, reconciled" : "new schema and read-write role";
+		lines.push(`  writer    ${w.spec} → ${w.schema}${from} — ${state}`);
+	}
+	process.stderr.write(`${lines.join("\n")}\n`);
+}
+/**
+* Never assumes yes. With no terminal to ask, an unconfirmed provision refuses
+* rather than proceeding or hanging on a prompt nobody can answer.
+*/
+async function confirm() {
+	if (!process.stdin.isTTY) throw new CliError("provisioning needs --yes when stdin is not a terminal", {
+		code: ExitCode.REFUSED,
+		detail: "it creates a billable database at the deployment's OLTP provider",
+		remedy: "re-run with --yes once the plan above is what you want"
+	});
+	const prompt = createInterface({
+		input: process.stdin,
+		output: process.stderr
+	});
+	let answer;
+	try {
+		answer = (await prompt.question("Provision? [y/N] ")).trim().toLowerCase();
+	} finally {
+		prompt.close();
+	}
+	if (answer === "y" || answer === "yes") return;
+	throw new CliError("not provisioned — the confirmation was declined", { code: ExitCode.REFUSED });
+}
+
 //#endregion
 //#region src/commands/proxy.ts
 /**
@@ -4450,7 +5126,7 @@ function readBody(req) {
 		req.on("error", reject);
 	});
 }
-function json$1(res, status, body) {
+function json(res, status, body) {
 	const payload = JSON.stringify(body);
 	res.writeHead(status, {
 		"content-type": "application/json",
@@ -4509,7 +5185,7 @@ async function runProxy(ctx, flags) {
 		}
 		if (!flags.allowWrites && isWritePath(method, path)) {
 			warn(`held  ${method} ${path}  (side-effecting; --allow-writes to forward)`);
-			json$1(res, 409, {
+			json(res, 409, {
 				error: "held_by_oxyc_proxy",
 				message: `oxyc proxy holds side-effecting calls by default. Re-run with --allow-writes to forward ${method} ${path}.`
 			});
@@ -4519,7 +5195,7 @@ async function runProxy(ctx, flags) {
 		try {
 			body = await readBody(req);
 		} catch (cause) {
-			json$1(res, 413, {
+			json(res, 413, {
 				error: "request_too_large",
 				message: cause.message
 			});
@@ -4562,12 +5238,12 @@ async function runProxy(ctx, flags) {
 				info(`${out.dim("closed")}  ${method} ${path}  (the browser went away)`);
 				return;
 			}
-			error(`${method} ${path} failed: ${cause.message}`);
+			error$1(`${method} ${path} failed: ${cause.message}`);
 			if (res.headersSent) {
 				res.destroy();
 				return;
 			}
-			json$1(res, 502, {
+			json(res, 502, {
 				error: "upstream_unreachable",
 				message: cause.message
 			});
@@ -4634,25 +5310,1043 @@ function parseValue(value) {
 			return quote === "\"" ? inner.replace(/\\n/g, "\n") : inner;
 		}
 	}
-	const hash = value.search(/\s#/);
-	return (hash >= 0 ? value.slice(0, hash) : value).trim();
+	const hash = value.search(/\s#/);
+	return (hash >= 0 ? value.slice(0, hash) : value).trim();
+}
+/** Load both files for `cwd`. Returns the paths that were read. */
+function loadDotenv(cwd, env = process.env) {
+	const read = [];
+	for (const name of [".env.local", ".env"]) {
+		const path = findUp(cwd, name);
+		if (!path) continue;
+		let text;
+		try {
+			text = readFileSync(path, "utf8");
+		} catch {
+			continue;
+		}
+		read.push(path);
+		for (const [key, value] of parseDotenv(text)) if (env[key] === void 0) env[key] = value;
+	}
+	return read;
+}
+
+//#endregion
+//#region src/publish/capabilities.ts
+/**
+* Which manifest capability each `ctx.<area>.<op>` needs — the CLI's copy of
+* the fail-closed gates in
+* `crates/app/src/server/api/custom_apps_functions/host.rs`.
+*
+* ONE SOURCE OF TRUTH, AND IT IS NOT THIS FILE. `FunctionCapabilities` in
+* `host.rs` is the struct every gate reads: each `ctx.*` op refuses with
+* `<Area>CapabilityMissing` when its field is false, `check_storage_capability`
+* is the op-by-op split for `ctx.storage`, and `check_write_destination` plus
+* `host/destinations.rs` decide a `ctx.warehouse` / `ctx.tx` write. This file
+* names those fields so `oxyc validate` and `oxyc publish` can answer, before
+* the upload, what the host would answer at the first call.
+*
+* HELD TO THE STRUCT BY A RUST TEST. `cli_capabilities_drift.rs`, beside
+* `host.rs`, `include_str!`s this file and fails when the `hostField` values
+* below stop naming exactly the gate fields `FunctionCapabilities` carries, or
+* when the `storage.*` ops here stop matching `check_storage_capability`'s
+* arms. A gate added to the host without an entry here fails that test; an
+* entry here for a gate the host no longer has fails it too.
+*
+* THE RUST TEST READS TEXT, NOT TYPESCRIPT: after stripping comments it takes
+* every line starting `hostField:` and the `ops: […]` array after it (wrapped
+* across lines or not). Keep those two keys spelled as they are, and keep a
+* `hostField` out of any comment that is not a full-line one.
+*/
+const isObject$2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+/** `spec.<a>.<b> === true`. */
+function flag(spec, a, b) {
+	const block = spec[a];
+	return isObject$2(block) && block[b] === true;
+}
+/**
+* Every gate in `FunctionCapabilities`, in the struct's order.
+*
+* `storage_retention` and `fetch_max_bytes` are also fields of that struct and
+* are deliberately absent here: a retention policy and a byte ceiling shape a
+* call that is allowed, they never refuse one. The Rust test carries the same
+* two names as its exclusion list, so a third non-gate field has to be added
+* in both places on purpose.
+*/
+const GATED_CAPABILITIES = [
+	{
+		hostField: "secrets_write",
+		manifest: "secrets.write",
+		declare: "\"secrets\": { \"write\": true }",
+		ops: ["secrets.set"],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "secrets", "write")
+	},
+	{
+		hostField: "email_send",
+		manifest: "email.send",
+		declare: "\"email\": { \"send\": true }",
+		ops: ["email.send"],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "email", "send")
+	},
+	{
+		hostField: "org_read",
+		manifest: "org.read",
+		declare: "\"org\": { \"read\": true }",
+		ops: [
+			"org.people",
+			"org.places",
+			"org.assignments"
+		],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "org", "read")
+	},
+	{
+		hostField: "storage_read",
+		manifest: "storage.read",
+		declare: "\"storage\": { \"read\": true }",
+		ops: [
+			"storage.getDownloadUrl",
+			"storage.get",
+			"storage.head",
+			"storage.list",
+			"storage.copy"
+		],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "storage", "read")
+	},
+	{
+		hostField: "storage_write",
+		manifest: "storage.write",
+		declare: "\"storage\": { \"write\": true }",
+		ops: [
+			"storage.getUploadUrl",
+			"storage.put",
+			"storage.delete",
+			"storage.copy"
+		],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "storage", "write")
+	},
+	{
+		hostField: "oltp",
+		manifest: "oltp.enabled",
+		declare: "\"oltp\": { \"enabled\": true }",
+		ops: ["oltp.*"],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "oltp", "enabled")
+	},
+	{
+		hostField: "airhouse",
+		manifest: "airhouse.enabled",
+		declare: "\"airhouse\": { \"enabled\": true }",
+		ops: ["airhouse.*"],
+		gate: "manifest",
+		declares: (spec) => flag(spec, "airhouse", "enabled")
+	},
+	{
+		hostField: "customer_warehouse_writes",
+		manifest: "customerWarehouseWrites",
+		declare: "\"customerWarehouseWrites\": { \"<database>\": \"<why this write stays there>\" }",
+		ops: [
+			"warehouse.insert",
+			"warehouse.exec",
+			"warehouse.upsert",
+			"tx"
+		],
+		gate: "destination",
+		declares: (spec, database) => {
+			const writes = spec.customerWarehouseWrites;
+			if (database === void 0 || !isObject$2(writes)) return false;
+			const reason = writes[database];
+			return typeof reason === "string" && reason.trim() !== "";
+		}
+	}
+];
+/**
+* The `ctx.warehouse` / `ctx.tx` writes, which also need the database in the
+* function's `destinations` — `write_destinations` on the host, checked by
+* `check_write_destination` before any capability: "an empty allowlist denies
+* every database". Not a `FunctionCapabilities` field, so not in the map above.
+*/
+const WRITE_OPS = GATED_CAPABILITIES.filter((c) => c.gate === "destination").flatMap((c) => c.ops);
+/** The gates a `ctx` member path needs — usually one; `storage.copy` needs two. */
+function capabilitiesFor(member) {
+	const area = member.split(".")[0] ?? member;
+	return GATED_CAPABILITIES.filter((c) => c.ops.includes(member) || c.ops.includes(`${area}.*`));
+}
+
+//#endregion
+//#region src/publish/placement-scan.ts
+/** Every character but a newline as a space, so offsets and line numbers survive. */
+function blank(text) {
+	return text.replace(/[^\n]/g, " ");
+}
+/** 1-based line of `offset` in `text`; shared with `function-lint.ts`. */
+function lineAt(text, offset) {
+	let line = 1;
+	for (let i = 0; i < offset; i++) if (text.charCodeAt(i) === 10) line++;
+	return line;
+}
+function stickyAt(re, text, at) {
+	re.lastIndex = at;
+	return re.exec(text);
+}
+/** Just past a block comment opened at `open`; SQL nests them, JavaScript does not. */
+function closeBlockComment(text, open, nested) {
+	let depth = 1;
+	let i = open + 2;
+	while (i < text.length) if (nested && text.startsWith("/*", i)) {
+		depth++;
+		i += 2;
+	} else if (text.startsWith("*/", i)) {
+		depth--;
+		i += 2;
+		if (depth === 0) return i;
+	} else i++;
+	return text.length;
+}
+/** Just past the quote closing the one at `open`; a doubled quote is an escape. */
+function closeDoubled(text, open, quote) {
+	for (let i = open + 1; i < text.length; i++) {
+		if (text[i] !== quote) continue;
+		if (text[i + 1] === quote) {
+			i++;
+			continue;
+		}
+		return i + 1;
+	}
+	return text.length;
+}
+function dollarTagAt(text, at) {
+	return stickyAt(/\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/y, text, at)?.[0];
+}
+/** One masked token: where it ends, and what replaces it in each view. */
+function sqlToken(sql, i) {
+	const two = sql.slice(i, i + 2);
+	let end;
+	if (two === "--") {
+		const newline = sql.indexOf("\n", i);
+		end = newline < 0 ? sql.length : newline;
+	} else if (two === "/*") end = closeBlockComment(sql, i, true);
+	else if (sql[i] === "'") end = closeDoubled(sql, i, "'");
+	else if (sql[i] === "$" && dollarTagAt(sql, i)) {
+		const tag = dollarTagAt(sql, i);
+		const close = sql.indexOf(tag, i + tag.length);
+		end = close < 0 ? sql.length : close + tag.length;
+	} else if (sql[i] === "\"") {
+		const close = closeDoubled(sql, i, "\"");
+		const inner = sql.slice(i + 1, Math.max(i + 1, close - 1));
+		const tail = sql.slice(i + 1 + inner.length, close);
+		return {
+			end: close,
+			code: sql.slice(i, close),
+			bare: `"${blank(inner)}${tail}`
+		};
+	}
+	if (end === void 0) return void 0;
+	const masked = blank(sql.slice(i, end));
+	return {
+		end,
+		code: masked,
+		bare: masked
+	};
+}
+function maskSql(sql) {
+	const code = [];
+	const bare = [];
+	let plain = 0;
+	let i = 0;
+	while (i < sql.length) {
+		const token = sqlToken(sql, i);
+		if (!token) {
+			i++;
+			continue;
+		}
+		code.push(sql.slice(plain, i), token.code);
+		bare.push(sql.slice(plain, i), token.bare);
+		i = token.end;
+		plain = token.end;
+	}
+	code.push(sql.slice(plain));
+	bare.push(sql.slice(plain));
+	return {
+		code: code.join(""),
+		bare: bare.join("")
+	};
+}
+const DUCKLAKE = "DuckLake has no primary keys, unique constraints, indexes or foreign keys, and a table carrying one fails and leaves the app's Airhouse writer inert";
+/** Leftmost-first, so `CREATE UNIQUE INDEX` is one hit rather than that and `UNIQUE`. */
+const UNSUPPORTED = /\bCREATE\s+(?:UNIQUE\s+)?INDEX\b|\bPRIMARY\s+KEY\b|\bUNIQUE\b|\bFOREIGN\s+KEY\b|\bREFERENCES\b/gi;
+function unsupportedConstraints(sql, bare) {
+	const hits = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const m of bare.matchAll(UNSUPPORTED)) {
+		const written = m[0].replace(/\s+/g, " ").toUpperCase();
+		const line = lineAt(sql, m.index ?? 0);
+		const key = `${line}:${written === "REFERENCES" ? "FOREIGN KEY" : written}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		hits.push({
+			line,
+			level: "error",
+			message: `\`${written}\` is not supported on Airhouse: ${DUCKLAKE}`
+		});
+	}
+	return hits;
+}
+const TARGETED = [
+	{
+		label: "CREATE TABLE",
+		re: /\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:TEMP|TEMPORARY)\s+)?TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?/gi
+	},
+	{
+		label: "CREATE VIEW",
+		re: /\bCREATE\s+(?:OR\s+REPLACE\s+)?(?:(?:TEMP|TEMPORARY)\s+)?VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?/gi
+	},
+	{
+		label: "ALTER TABLE",
+		re: /\bALTER\s+TABLE\s+(?:IF\s+EXISTS\s+)?/gi
+	},
+	{
+		label: "DROP TABLE",
+		re: /\bDROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?/gi,
+		list: true
+	},
+	{
+		label: "DROP VIEW",
+		re: /\bDROP\s+VIEW\s+(?:IF\s+EXISTS\s+)?/gi,
+		list: true
+	},
+	{
+		label: "INSERT INTO",
+		re: /\bINSERT\s+(?:OR\s+(?:REPLACE|IGNORE)\s+)?INTO\s+/gi
+	},
+	{
+		label: "UPDATE",
+		re: /(?<!\b(?:DO|ON)\s+)\bUPDATE\s+/gi
+	},
+	{
+		label: "DELETE FROM",
+		re: /\bDELETE\s+FROM\s+/gi
+	},
+	{
+		label: "COMMENT ON",
+		re: /\bCOMMENT\s+ON\s+(?:TABLE|VIEW|COLUMN)\s+/gi
+	}
+];
+const PART = /"(?:[^"]|"")*"|[A-Za-z_][A-Za-z0-9_$]*/y;
+const DOT = /\s*\.\s*/y;
+const COMMA = /\s*,\s*/y;
+function readName(code, at) {
+	const raw = [];
+	const parts = [];
+	let i = at;
+	for (;;) {
+		const part = stickyAt(PART, code, i);
+		if (!part) return void 0;
+		const token = part[0];
+		raw.push(token);
+		parts.push((token.startsWith("\"") ? token.slice(1, -1).replaceAll("\"\"", "\"") : token).toLowerCase());
+		i = PART.lastIndex;
+		if (!stickyAt(DOT, code, i)) break;
+		i = DOT.lastIndex;
+	}
+	return {
+		raw,
+		parts,
+		end: i
+	};
+}
+function misplaced(label, name, schema, column) {
+	const want = column ? 3 : 2;
+	if (name.parts.length === want && name.parts[0] === schema) return void 0;
+	const written = `${label} ${name.raw.join(".")}`;
+	const suggestion = `${schema}.${name.raw.slice(-(want - 1)).join(".")}`;
+	return `\`${written}\` ${name.parts.length < want ? "is unqualified" : "is outside the app's schema"} — write \`${suggestion}\`: the server refuses an Airhouse migration target that is not qualified with \`${schema}\``;
+}
+function misplacedTargets(sql, masked, schema) {
+	const hits = [];
+	for (const target of TARGETED) for (const m of masked.bare.matchAll(target.re)) {
+		const column = /\bCOLUMN\s+$/i.test(m[0]);
+		let at = (m.index ?? 0) + m[0].length;
+		for (;;) {
+			const name = readName(masked.code, at);
+			if (!name) break;
+			const problem = misplaced(target.label, name, schema, column);
+			if (problem) hits.push({
+				line: lineAt(sql, at),
+				level: "error",
+				message: problem
+			});
+			if (!target.list || !stickyAt(COMMA, masked.code, name.end)) break;
+			at = COMMA.lastIndex;
+		}
+	}
+	return hits;
+}
+/**
+* Every placement problem in one Airhouse migration.
+*
+* `schema` is `app_<writer>`, or `undefined` when the slug could not derive one
+* — the target check then has nothing to compare against and is skipped; the
+* caller reports why.
+*/
+function scanAirhouseMigration(sql, schema) {
+	const masked = maskSql(sql);
+	const hits = unsupportedConstraints(sql, masked.bare);
+	for (const m of masked.bare.matchAll(/\bCREATE\s+SCHEMA\b/gi)) hits.push({
+		line: lineAt(sql, m.index ?? 0),
+		level: "warning",
+		message: `\`CREATE SCHEMA\` is unnecessary — the platform creates ${schema ? `\`${schema}\`` : "the app's schema"} before it applies migrations`
+	});
+	if (schema !== void 0) hits.push(...misplacedTargets(sql, masked, schema));
+	return hits.sort((a, b) => a.line - b.line);
+}
+/** Just past a quote closing the one at `open`; a backslash escapes. */
+function closeEscaped(text, open, quote) {
+	for (let i = open + 1; i < text.length; i++) {
+		if (text[i] === "\\") {
+			i++;
+			continue;
+		}
+		if (text[i] === quote) return i + 1;
+		if (quote !== "`" && text[i] === "\n") return i;
+	}
+	return text.length;
+}
+/** A `/` starts a regex literal only where a value may begin, not after one. */
+function regexCanStart(text, at) {
+	let j = at - 1;
+	while (j >= 0 && /\s/.test(text[j])) j--;
+	return j < 0 || "(,=:[!&|?{};".includes(text[j]);
+}
+function closeRegex(text, open) {
+	let inClass = false;
+	for (let i = open + 1; i < text.length; i++) {
+		const c = text[i];
+		if (c === "\\") i++;
+		else if (c === "\n") return open + 1;
+		else if (inClass) {
+			if (c === "]") inClass = false;
+		} else if (c === "[") inClass = true;
+		else if (c === "/") return i + 1;
+	}
+	return open + 1;
+}
+/**
+* Comments, strings, template literals and regex literals blanked.
+*
+* APPROXIMATE: a template literal is masked whole, `${…}` included, so a call
+* written inside one is not seen. That errs toward silence, which is the side
+* a warning should err on.
+*/
+function maskJs(source) {
+	const out = [];
+	let plain = 0;
+	let i = 0;
+	while (i < source.length) {
+		const c = source[i];
+		const two = source.slice(i, i + 2);
+		let end;
+		if (two === "//") {
+			const newline = source.indexOf("\n", i);
+			end = newline < 0 ? source.length : newline;
+		} else if (two === "/*") end = closeBlockComment(source, i, false);
+		else if (c === "'" || c === "\"" || c === "`") end = closeEscaped(source, i, c);
+		else if (c === "/" && regexCanStart(source, i)) end = closeRegex(source, i);
+		if (end === void 0) {
+			i++;
+			continue;
+		}
+		out.push(source.slice(plain, i), blank(source.slice(i, end)));
+		i = end;
+		plain = end;
+	}
+	out.push(source.slice(plain));
+	return out.join("");
+}
+/** Top-level argument ranges of a call whose `(` ends just before `from`. */
+function splitArgs(code, from) {
+	const args = [];
+	let depth = 0;
+	let start = from;
+	for (let i = from; i < code.length; i++) {
+		const c = code[i];
+		if (c === "(" || c === "[" || c === "{") depth++;
+		else if (c === ")" || c === "]" || c === "}") {
+			if (depth === 0) {
+				args.push({
+					start,
+					end: i
+				});
+				return args;
+			}
+			depth--;
+		} else if (c === "," && depth === 0) {
+			args.push({
+				start,
+				end: i
+			});
+			start = i + 1;
+		}
+	}
+}
+/** The value of a plain string literal, or `undefined` for anything computed. */
+function literalString(text) {
+	const quoted = /^(['"])((?:\\.|(?!\1)[^\\])*)\1$/s.exec(text);
+	if (quoted) return quoted[2];
+	if (/^`[^`]*`$/.test(text) && !text.includes("${")) return text.slice(1, -1);
+}
+const SECRETS_SET = /\bctx\s*\??\.\s*secrets\s*\??\.\s*set\s*\(/g;
+/** A rotated token written back is what `secrets.write` is for. */
+const CREDENTIAL_KEY = /(token|secret|key|password)/i;
+const STATE_WORD = /^(state|cursor|checkpoint|progress|last|count|counter|cache|offset|watermark)$/i;
+/**
+* Whether a key names state, by whole words — `SYNC_CURSOR`, `row-count`,
+* `lastSyncAt` — so `QB_ACCOUNT_ID` is not read as a `count`.
+*/
+function namesState(key) {
+	return key.replace(/([a-z0-9])([A-Z])/g, "$1_$2").split(/[^A-Za-z0-9]+/).some((word) => STATE_WORD.test(word));
+}
+const STRINGIFY = /\bJSON\s*\??\.\s*stringify\b/;
+/**
+* `ctx.secrets.set` calls that look like state rather than a credential.
+*
+* ONE FILE — the function's entry. A helper module it imports is not followed,
+* so a call made there is not seen.
+*/
+function secretsUsedAsState(source) {
+	const code = maskJs(source);
+	const hits = [];
+	for (const m of code.matchAll(SECRETS_SET)) {
+		const args = splitArgs(code, (m.index ?? 0) + m[0].length);
+		const keyRange = args?.[0];
+		if (!keyRange) continue;
+		const keyText = source.slice(keyRange.start, keyRange.end).trim();
+		const key = literalString(keyText);
+		if (key !== void 0 && CREDENTIAL_KEY.test(key)) continue;
+		const valueRange = args?.[1];
+		const value = valueRange ? code.slice(valueRange.start, valueRange.end) : "";
+		const why = STRINGIFY.test(value) ? "a `JSON.stringify(…)` value" : key !== void 0 && namesState(key) ? `a key that names state (\`${key}\`)` : void 0;
+		if (why === void 0) continue;
+		hits.push({
+			line: lineAt(source, m.index ?? 0),
+			call: `ctx.secrets.set(${keyText}, …)`,
+			why
+		});
+	}
+	return hits;
+}
+
+//#endregion
+//#region src/publish/function-lint.ts
+/**
+* The Oxy Functions lint `oxyc validate` and `oxyc publish` run over an app's
+* function sources: the "works locally, fails closed in prod" mistakes that a
+* bundle carries silently and the host refuses on the first call.
+*
+* THREE RULES, each mirroring a refusal the platform already makes:
+*
+* - `capability` — a `ctx.<area>.<op>` call whose manifest capability the
+*   function does not declare. `capabilities.ts` is the map; `host.rs`'s
+*   `FunctionCapabilities` is the truth it is held to.
+* - `isolate-global` — a Node or Web global the isolate does not provide.
+*   `internal-docs/customer-apps-functions.md`, "Limits & safety": the isolate
+*   is bare `deno_core`, so `TextEncoder`/`TextDecoder`, `Blob`, `File`,
+*   `FormData`, `crypto.subtle` and `Buffer` are `ReferenceError`s that no
+*   `tsc` catches — and `process`, a Node global the same passage rules out
+*   ("only `oxy_functions_ext` ops plus what `BOOTSTRAP_JS` defines"), which
+*   `runtime.rs`'s bootstrap does not define.
+* - `destinations` / `engine` / `customer-warehouse` — a `ctx.warehouse` /
+*   `ctx.tx` write to a database the function may not write, or an op the
+*   engine refuses by name. The allowlist half is answered here; the half that
+*   needs the database's engine is `function-engines.ts`, at publish.
+*
+* LEXICAL, NOT A PARSER, AND NOT THE AUTHORITY — the same footing as
+* `placement-scan.ts`, whose `maskJs` this reuses: comments, strings, template
+* literals and regex literals are blanked before anything is matched, a call
+* is only seen when written on the context by name (`ctx.storage.put(`, or
+* `run.ctx.storage.put(` — a `ctx` handed around in a struct is still the
+* context), and a source that cannot be read is reported as not linted rather
+* than guessed at. Where this and the host disagree, the host is right; a
+* false positive is what `oxyc publish --allow-function-lint` is for.
+*
+* FOLLOWS RELATIVE IMPORTS. The entry alone is often a thin router — the
+* platform canary's `canary.ts` imports every `ctx` call from `steps.ts` — so
+* `./x`, `./x.js` (the TS spelling of `./x.ts`) and `./dir` (its `index.*`) are
+* read too, inside the app directory only, each file once. A package import
+* is not followed: what `@oxy-hq/sdk` does is its own test suite's problem.
+*/
+/** `internal-docs/customer-apps-functions.md` § "Limits & safety", plus `process`. */
+const ABSENT_GLOBALS = [
+	{
+		name: "Buffer",
+		instead: "for base64 use `btoa`/`atob` (strings) or `bytesToBase64`/`base64ToBytes` from `@oxy-hq/sdk` (bytes); pass binary to `ctx.storage.put` / `ctx.email.send` as `{ encoding: \"base64\" }`"
+	},
+	{
+		name: "TextEncoder",
+		instead: "pass strings as-is — `ctx.fetch`, `ctx.storage` and `ctx.email.send` take UTF-8 text"
+	},
+	{
+		name: "TextDecoder",
+		instead: "`ctx.fetch` decodes as UTF-8 by default; ask for `{ encoding: \"base64\" }` for bytes"
+	},
+	{
+		name: "Blob",
+		instead: "send a string or a base64 body: `ctx.fetch(url, { body, encoding })`"
+	},
+	{
+		name: "File",
+		instead: "send a string or a base64 body: `ctx.fetch(url, { body, encoding })`"
+	},
+	{
+		name: "FormData",
+		instead: "encode the form body yourself (`URLSearchParams`, or a multipart string)"
+	},
+	{
+		name: "crypto",
+		member: "subtle",
+		instead: "use `ctx.crypto` — HMAC sign / verify and a constant-time compare"
+	},
+	{
+		name: "process",
+		member: "",
+		instead: "read configuration from `ctx.env`"
+	}
+];
+const MANIFEST$1 = "oxy-app.json";
+const isObject$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const EXTENSIONS = [
+	".ts",
+	".tsx",
+	".mts",
+	".js",
+	".mjs",
+	".jsx"
+];
+/** A bound on the walk, so a pathological tree cannot make `validate` hang. */
+const MAX_FILES = 200;
+/** The file `spec` names from `from`, inside `appDir`, or `undefined`. */
+function resolveRelative(appDir, from, spec) {
+	if (!spec.startsWith("./") && !spec.startsWith("../")) return void 0;
+	const base = resolve(dirname(from), spec);
+	if (base !== appDir && !base.startsWith(appDir + sep)) return void 0;
+	const candidates = [base];
+	if (/\.[mc]?jsx?$/.test(base)) candidates.push(base.replace(/\.([mc]?)js$/, ".$1ts"), base.replace(/\.jsx?$/, ".tsx"));
+	for (const ext of EXTENSIONS) candidates.push(base + ext);
+	for (const ext of EXTENSIONS) candidates.push(join(base, `index${ext}`));
+	for (const candidate of candidates) {
+		if (candidate.endsWith(".d.ts")) continue;
+		try {
+			if (statSync(candidate).isFile()) return candidate;
+		} catch {}
+	}
+}
+/**
+* A quoted specifier at `lastIndex` in the ORIGINAL source, after real
+* whitespace only. Sticky, and applied to the original rather than the masked
+* text on purpose: masking blanks the quotes too, so a `\s*` matched on the
+* masked code would swallow the whole specifier and land past it.
+*/
+const SPECIFIER_AT = /\s*(['"])((?:\\.|(?!\1)[^\\\n])*)\1/y;
+/**
+* The keyword an import specifier follows, found on the MASKED code so a
+* commented-out import is not followed, and read from the original at the
+* same offset, which masking preserves. A keyword not followed by a quote —
+* `Array.from(xs)`, `import.meta`, `import { x }` before its `from` — reads
+* nothing and is skipped.
+*/
+const SPECIFIER_STARTS = [
+	/\b(?:import|export)\b[^;]*?\bfrom\b/g,
+	/\bimport\s*\(/g,
+	/\bimport\b/g
+];
+function importSpecifiers(source, masked) {
+	const found = [];
+	for (const re of SPECIFIER_STARTS) for (const m of masked.matchAll(re)) {
+		SPECIFIER_AT.lastIndex = (m.index ?? 0) + m[0].length;
+		const spec = SPECIFIER_AT.exec(source);
+		if (spec?.[2] !== void 0) found.push(spec[2]);
+	}
+	return found;
+}
+/**
+* The entry and every source it reaches through relative imports.
+*
+* A file that cannot be read lands in `unreadable` with its code, and only the
+* ENTRY's absence is worth a line to the author — a helper that vanished mid
+* edit is the bundler's report to make.
+*/
+function loadSources(appDir, entry, cache) {
+	const files = [];
+	const unreadable = [];
+	const seen = /* @__PURE__ */ new Set();
+	const queue = [resolve(appDir, entry)];
+	while (queue.length > 0 && files.length < MAX_FILES) {
+		const path = queue.shift();
+		if (seen.has(path)) continue;
+		seen.add(path);
+		const rel = relative(appDir, path).split(sep).join("/");
+		let file = cache.loaded.get(path);
+		if (file === void 0) {
+			const known = cache.unreadable.get(path);
+			if (known !== void 0) {
+				unreadable.push({
+					rel,
+					code: known
+				});
+				continue;
+			}
+			try {
+				file = {
+					rel,
+					source: readFileSync(path, "utf8")
+				};
+				cache.loaded.set(path, file);
+			} catch (cause) {
+				const code = cause.code ?? "EUNKNOWN";
+				cache.unreadable.set(path, code);
+				unreadable.push({
+					rel,
+					code
+				});
+				continue;
+			}
+		}
+		files.push(file);
+		for (const spec of importSpecifiers(file.source, maskJs(file.source))) {
+			const next = resolveRelative(appDir, path, spec);
+			if (next !== void 0 && !seen.has(next)) queue.push(next);
+		}
+	}
+	return {
+		files,
+		unreadable
+	};
+}
+/**
+* `ctx.<area>(` or `ctx.<area>.<op>(`, optional-chained or not. `ctx` may be a
+* member of something (`run.ctx.`) but not the tail of a longer name
+* (`myctx.`), and the last segment must be CALLED — `ctx.airhouse.schema` is a
+* property read, which the host never sees.
+*/
+const CTX_CALL = /(?<![\w$])ctx\s*\??\.\s*([A-Za-z_$][\w$]*)(?:\s*\??\.\s*([A-Za-z_$][\w$]*))?\s*\(/g;
+function ctxCalls(fn, file, masked) {
+	const calls = [];
+	for (const m of masked.matchAll(CTX_CALL)) {
+		const member = m[2] === void 0 ? m[1] : `${m[1]}.${m[2]}`;
+		const at = m.index ?? 0;
+		const call = {
+			fn,
+			file: file.rel,
+			line: lineAt(file.source, at),
+			member,
+			call: `ctx.${member}(`
+		};
+		if (WRITE_OPS.includes(member)) {
+			const first = splitArgs(masked, at + m[0].length)?.[0];
+			if (first) {
+				const database = literalString(file.source.slice(first.start, first.end).trim());
+				if (database !== void 0) call.database = database;
+			}
+		}
+		calls.push(call);
+	}
+	return calls;
+}
+const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+/**
+* Does this file declare `name` itself — a `const`, a `function`, an `import`,
+* a parameter? Then a use of it is the author's own value, not the missing
+* global, and reporting it would be a false refusal at exit 1: the one thing
+* this lint must never do. So the check errs WIDE — a shadow anywhere in the
+* file silences the name for the whole file, block scope be damned — and what
+* a miss here costs is a hit, never a refusal.
+*
+* Type-only imports do not count: `import type { Blob }` gives a name to
+* annotate with, not one to call, so `new Blob(` still throws.
+*/
+function isShadowed(masked, name) {
+	const n = escapeRe(name);
+	return new RegExp(`\\b(?:const|let|var)\\s+(?:${n}\\b|\\{[^}]*\\b${n}\\b[^}]*\\}|\\[[^\\]]*\\b${n}\\b[^\\]]*\\])|\\b(?:function|class)\\s+${n}\\b|\\bimport\\s+(?!type\\b)[^;]*?\\b${n}\\b[^;]*?\\bfrom\\b|\\bimport\\s+(?!type\\b)(?:\\*\\s+as\\s+)?${n}\\b|(?<![\\w$.])${n}\\s*=>`).test(masked) || parameterLists(masked).some((list) => bindsName(list, n));
+}
+/**
+* Every parenthesised parameter list: after `function`, before `=>`, and a
+* method's `name(…) {`. Lexical, so `if (x) {` reads as a method too — which
+* only ever widens the shadow, never a refusal.
+*/
+function parameterLists(masked) {
+	const lists = [];
+	for (const re of [
+		/\bfunction\b[^(]*\(([^()]*)\)/g,
+		/\(([^()]*)\)\s*(?::[^=]*?)?=>/g,
+		/\b[\w$]+\s*\(([^()]*)\)\s*(?::[^{]*?)?\{/g
+	]) for (const m of masked.matchAll(re)) lists.push(m[1] ?? "");
+	return lists;
+}
+/**
+* Does `list` BIND `name` — as a parameter, not as a type (`x: Buffer`,
+* `Array<Buffer>`, `Blob | File`) or a default-value use (`w = Buffer.from(…)`)?
+*/
+function bindsName(list, n) {
+	return new RegExp(`(?<![:<|&\\w$.]\\s*)\\b${n}\\b(?!\\s*[.(])`).test(list);
+}
+/**
+* The shape that throws. A VALUE use — called, constructed, or a member read —
+* never a type annotation (`body: Blob`), a `typeof` guard, or a property of
+* something else (`node.Buffer`). For a `member` global only `<name>.<member>`
+* counts, and `process.` matches any member.
+*/
+function absentGlobalShape(global) {
+	const n = escapeRe(global.name);
+	if (global.member === void 0) return new RegExp(`(?<![\\w$.])(?:new\\s+)?${n}\\s*[.(]`, "g");
+	const member = global.member === "" ? "[A-Za-z_$][\\w$]*" : `${escapeRe(global.member)}\\b`;
+	return new RegExp(`(?<![\\w$.])${n}\\s*\\.\\s*${member}`, "g");
+}
+function absentGlobals(fn, file, masked) {
+	const issues = [];
+	for (const global of ABSENT_GLOBALS) {
+		if (isShadowed(masked, global.name)) continue;
+		for (const m of masked.matchAll(absentGlobalShape(global))) {
+			const written = m[0].replace(/\s+/g, "").replace(/^new/, "new ");
+			const what = global.member ? `${global.name}.${global.member}` : global.name;
+			issues.push({
+				rule: "isolate-global",
+				fn,
+				level: "error",
+				file: file.rel,
+				path: `line ${lineAt(file.source, m.index ?? 0)}`,
+				message: `\`${written}\` — the Oxy Functions isolate has no \`${what}\` (it is bare deno_core, not Node or a browser), so this throws ReferenceError at runtime; ${global.instead}`
+			});
+		}
+	}
+	return issues;
+}
+function capabilityIssues(spec, call) {
+	const issues = [];
+	for (const cap of capabilitiesFor(call.member)) {
+		if (cap.gate !== "manifest" || cap.declares(spec)) continue;
+		issues.push({
+			rule: "capability",
+			fn: call.fn,
+			level: "error",
+			file: call.file,
+			path: `line ${call.line}`,
+			message: `\`${call.call}\` needs the \`${cap.manifest}\` capability, which function \`${call.fn}\` does not declare — the host refuses the call (fail-closed); add ${cap.declare} to functions.${call.fn} in ${MANIFEST$1}`
+		});
+	}
+	return issues;
+}
+/**
+* The allowlist half of `check_write_destination`: a write needs the database
+* in `destinations`, and an empty allowlist denies every database. The kind of
+* store, and the engine, wait for the server.
+*/
+function destinationIssue(spec, call) {
+	if (!WRITE_OPS.includes(call.member)) return void 0;
+	const destinations = Array.isArray(spec.destinations) ? spec.destinations.filter((d) => typeof d === "string") : [];
+	const written = call.database === void 0 ? call.call : `${call.call}"${call.database}", …)`;
+	const at = `functions.${call.fn}.destinations`;
+	if (destinations.length === 0) return {
+		rule: "destinations",
+		fn: call.fn,
+		level: "error",
+		file: call.file,
+		path: `line ${call.line}`,
+		message: `\`${written}\` is a write, and function \`${call.fn}\` declares no \`destinations\` — an empty allowlist refuses every database; add "destinations": ["<database>"] to functions.${call.fn} in ${MANIFEST$1}`
+	};
+	if (call.database !== void 0 && !destinations.includes(call.database)) return {
+		rule: "destinations",
+		fn: call.fn,
+		level: "error",
+		file: call.file,
+		path: `line ${call.line}`,
+		message: `\`${written}\` writes \`${call.database}\`, which is not in \`${at}\` (${JSON.stringify(destinations)}) — the host refuses a write outside the allowlist; add it there in ${MANIFEST$1}`
+	};
+}
+/**
+* Every lint issue in one app's functions, plus what the server must finish.
+*
+* `skipped` is worded for the author: which function was not read, and that
+* the engine check waits for `oxyc publish`. Nothing here needs a credential.
+*/
+function lintAppFunctions(appDir, manifest) {
+	const result = {
+		issues: [],
+		writes: [],
+		skipped: [],
+		files: []
+	};
+	const cache = {
+		loaded: /* @__PURE__ */ new Map(),
+		unreadable: /* @__PURE__ */ new Map()
+	};
+	const globalsScanned = /* @__PURE__ */ new Set();
+	const functions = isObject$1(manifest.functions) ? manifest.functions : {};
+	for (const [fn, spec] of Object.entries(functions)) {
+		if (!isObject$1(spec) || spec.entry != null && typeof spec.entry !== "string") continue;
+		const entry = functionEntry(manifest, fn);
+		const { files, unreadable } = loadSources(appDir, entry, cache);
+		const missingEntry = unreadable.find((u) => u.rel === entry.replace(/^\.\//, ""));
+		if (missingEntry) {
+			result.skipped.push(`function \`${fn}\` was not linted: ${entry} could not be read (${missingEntry.code})`);
+			continue;
+		}
+		for (const file of files) {
+			const masked = maskJs(file.source);
+			if (!globalsScanned.has(file.rel)) {
+				globalsScanned.add(file.rel);
+				result.files.push(file.rel);
+				result.issues.push(...absentGlobals(fn, file, masked));
+			}
+			for (const call of ctxCalls(fn, file, masked)) {
+				result.issues.push(...capabilityIssues(spec, call));
+				const destination = destinationIssue(spec, call);
+				if (destination) result.issues.push(destination);
+				else if (WRITE_OPS.includes(call.member)) result.writes.push(call);
+			}
+		}
+	}
+	result.issues.sort((a, b) => a.file.localeCompare(b.file) || lineOf(a) - lineOf(b));
+	return result;
+}
+const lineOf = (issue) => Number(issue.path.replace(/^line /, "")) || 0;
+/** `[function-lint/<rule>] file (line N): message` — the shape a warning prints. */
+function describeLintIssue(issue, prefix = "") {
+	return `[function-lint/${issue.rule}] ${prefix}${issue.file} (${issue.path}): ${issue.message}`;
+}
+
+//#endregion
+//#region src/publish/function-engines.ts
+/**
+* The half of the Oxy Functions lint that needs the server: what KIND of
+* store each `ctx.warehouse` / `ctx.tx` write lands on, and which engine.
+*
+* The manifest's `destinations` name workspace databases, not their engines,
+* so `oxyc publish` asks the target — `GET /api/{project}/databases`, the
+* `list_databases` route `oxyc routes databases` lists, which answers `name`,
+* `dialect` (the query engine: `postgres`, `duckdb`, `clickhouse`, …) and
+* `db_type` (the `config.yml` kind: `airhouse_managed`, `postgres_managed`,
+* `snowflake`, …). Three refusals the host makes are then answerable before
+* the upload:
+*
+* - `customer-warehouse` — `host/destinations.rs` `destination_write_policy`:
+*   Airhouse (`airhouse` / `airhouse_managed`) takes the write; the org's OLTP
+*   (`postgres_managed`) is refused with a pointer at `ctx.oltp`; anything else
+*   is a customer warehouse, read-only unless the function names it in
+*   `customerWarehouseWrites` with a reason.
+* - `engine` for `ctx.warehouse.upsert` — `upsert_support.rs`: it compiles to
+*   `INSERT … ON CONFLICT`, which only the `postgres` and `duckdb` dialects
+*   parse, so every other dialect is refused by name.
+* - `engine` for `ctx.tx` — Postgres only; another backend rejects the
+*   transaction rather than faking it statement by statement.
+*
+* SKIPPED, NEVER GUESSED, when the list cannot be fetched: an unreachable or
+* unauthorised target prints one warning and the publish goes on, because the
+* host still makes every one of these refusals at the first call.
+*/
+const LOOKUP_TIMEOUT_MS = 3e4;
+/** Dialects whose `INSERT … ON CONFLICT` the host lets through (`parses_on_conflict`). */
+const UPSERT_DIALECTS = ["postgres", "duckdb"];
+/** The one dialect `ctx.tx` opens a transaction on. */
+const TX_DIALECTS = ["postgres"];
+/** `destination_kind`: these take a write with no exception. */
+const AIRHOUSE_TYPES = ["airhouse", "airhouse_managed"];
+const MANAGED_OLTP_TYPE = "postgres_managed";
+/**
+* The project's databases, or `undefined` with the reason when the target did
+* not answer — a network failure, a 401/403, a body that is not the list. The
+* caller prints the reason once and continues: this check is advisory, and a
+* publish must not fail on a lookup the upload itself does not need.
+*/
+async function fetchDatabaseEngines(target, project, token) {
+	const url = `${target.replace(/\/+$/, "")}/api/${encodeURIComponent(project)}/databases`;
+	let response;
+	try {
+		response = await fetch(url, {
+			headers: { authorization: `Bearer ${token}` },
+			signal: AbortSignal.timeout(LOOKUP_TIMEOUT_MS)
+		});
+	} catch (cause) {
+		return { skipped: `GET ${url} failed: ${cause.message}` };
+	}
+	if (!response.ok) return { skipped: `GET ${url} answered ${response.status}` };
+	let parsed;
+	try {
+		parsed = JSON.parse(await response.text());
+	} catch {
+		return { skipped: `GET ${url} did not answer JSON` };
+	}
+	if (!Array.isArray(parsed)) return { skipped: `GET ${url} did not answer a list` };
+	const databases = parsed.filter((d) => typeof d === "object" && d !== null && typeof d.name === "string" && typeof d.dialect === "string" && typeof d.db_type === "string");
+	if (databases.length !== parsed.length) return { skipped: `GET ${url} answered ${parsed.length - databases.length} row(s) without a string name, dialect and db_type` };
+	return { databases };
 }
-/** Load both files for `cwd`. Returns the paths that were read. */
-function loadDotenv(cwd, env = process.env) {
-	const read = [];
-	for (const name of [".env.local", ".env"]) {
-		const path = findUp(cwd, name);
-		if (!path) continue;
-		let text;
-		try {
-			text = readFileSync(path, "utf8");
-		} catch {
+/** The gates a write's database decides — one today, and never silently a second. */
+const DESTINATION_GATES = GATED_CAPABILITIES.filter((c) => c.gate === "destination");
+const DESTINATION_DECLARE = DESTINATION_GATES.map((c) => c.declare).join(" and ");
+function issue(call, rule, message) {
+	return {
+		rule,
+		fn: call.fn,
+		level: "error",
+		file: call.file,
+		path: `line ${call.line}`,
+		message
+	};
+}
+/** `ctx.warehouse.upsert("db", …)` — the call with the database it named. */
+const written = (call) => `${call.call}"${call.database}", …)`;
+/**
+* Every refusal the engine list settles for the writes `lintAppFunctions`
+* collected. A write whose database is not a literal has nothing to look up
+* and is the host's to judge.
+*/
+function checkEngines(writes, manifest, databases) {
+	const issues = [];
+	const functions = typeof manifest.functions === "object" && manifest.functions !== null ? manifest.functions : {};
+	for (const call of writes) {
+		if (call.database === void 0) continue;
+		const spec = functions[call.fn];
+		if (typeof spec !== "object" || spec === null) continue;
+		const db = databases.find((d) => d.name === call.database);
+		if (!db) {
+			issues.push(issue(call, "destinations", `\`${written(call)}\` writes \`${call.database}\`, which is not a database of this project — the host refuses a write to a database that is not configured; check the name against the workspace's config.yml`));
 			continue;
 		}
-		read.push(path);
-		for (const [key, value] of parseDotenv(text)) if (env[key] === void 0) env[key] = value;
+		const kind = kindIssue(call, spec, db);
+		if (kind) issues.push(kind);
+		const engine = engineIssue(call, db);
+		if (engine) issues.push(engine);
 	}
-	return read;
+	return issues;
+}
+function kindIssue(call, spec, db) {
+	if (AIRHOUSE_TYPES.includes(db.db_type)) return void 0;
+	if (db.db_type === MANAGED_OLTP_TYPE) return issue(call, "customer-warehouse", `\`${written(call)}\` writes \`${db.name}\`, the org's OLTP store, which \`ctx.warehouse\` and \`ctx.tx\` reach as the read-only analyst — write this app's own records with \`ctx.oltp\` instead (its \`app_<writer>\` schema needs no destination)`);
+	if (DESTINATION_GATES.some((gate) => gate.declares(spec, db.name))) return void 0;
+	const tx = call.member === "tx" ? " (a `ctx.tx` transaction counts as a write even when it only reads — read with `ctx.warehouse.query` instead)" : "";
+	return issue(call, "customer-warehouse", `\`${written(call)}\` writes \`${db.name}\` (${db.db_type}), a customer warehouse, and customer warehouses are read-only to apps — facts belong in \`ctx.airhouse\`, records in \`ctx.oltp\`; if this write has to stay, say why: add ${DESTINATION_DECLARE} to functions.${call.fn} in oxy-app.json${tx}`);
+}
+function engineIssue(call, db) {
+	if (call.member === "warehouse.upsert" && !UPSERT_DIALECTS.includes(db.dialect)) return issue(call, "engine", `\`${written(call)}\` — \`${db.name}\` is ${db.dialect}, and \`upsert\` compiles to \`INSERT … ON CONFLICT … DO UPDATE\`, which only Postgres and DuckDB parse; the host refuses it by name — use \`ctx.warehouse.insert\`, or \`ctx.warehouse.exec\` with this warehouse's own upsert statement`);
+	if (call.member === "tx" && !TX_DIALECTS.includes(db.dialect)) return issue(call, "engine", `\`${written(call)}\` — \`${db.name}\` is ${db.dialect}, and \`ctx.tx\` is Postgres-only; the host refuses to open the transaction rather than run the statements one by one — use \`ctx.warehouse.exec\` per statement, or \`ctx.oltp.tx\` for the app's own store`);
+}
+/**
+* The lint's verdict as an error, for a publish that does not carry
+* `--allow-function-lint`. FAILURE (1), the code `oxyc validate` gives a
+* finding: the command ran and the answer is bad. Not REFUSED (8) — nothing
+* would have been destroyed — and not USAGE (2): the invocation was fine.
+*/
+function functionLintFailure(issues, prefix = "") {
+	return new CliError(`${issues.length} Oxy Function lint problem(s) — the host would refuse these at the first call`, {
+		code: ExitCode.FAILURE,
+		detail: issues.map((issue) => describeLintIssue(issue, prefix)).join("\n"),
+		hint: "each line above names the file, the line, the call and the fix",
+		remedy: "fix the manifest or the call, then publish again. A false positive? `oxyc publish --allow-function-lint` publishes with these as warnings — and please open an issue naming the rule, so the rule gets fixed"
+	});
 }
 
 //#endregion
@@ -4912,134 +6606,6 @@ function resolveBuildId(flag, env = process.env) {
 	return flag?.trim() || ciBuildId(env) || randomUUID().replaceAll("-", "");
 }
 
-//#endregion
-//#region src/publish/server.ts
-/**
-* The three HTTP calls a publish makes, plus the trusted-publishing exchange.
-*
-* Direct `fetch` rather than `api/request.ts`: the upload is multipart and the
-* two lookups are public, and neither fits a JSON-string request with a
-* credential chosen by path. What they share with it is the exit-code mapping.
-*/
-const LOOKUP_TIMEOUT_MS = 3e4;
-/** The bundle upload, which can be tens of megabytes. */
-const UPLOAD_TIMEOUT_MS = 12e4;
-async function send(url, init, timeoutMs) {
-	try {
-		return await fetch(url, {
-			...init,
-			signal: AbortSignal.timeout(timeoutMs)
-		});
-	} catch (cause) {
-		throw new CliError(`${init.method ?? "GET"} ${url} failed: ${cause.message}`, { code: ExitCode.UNAVAILABLE });
-	}
-}
-async function json(response, what) {
-	const text = await response.text();
-	try {
-		return JSON.parse(text);
-	} catch {
-		throw new CliError(`could not parse the ${what} response`, {
-			code: ExitCode.UNAVAILABLE,
-			detail: text.slice(0, 2e3)
-		});
-	}
-}
-function base(target) {
-	return target.replace(/\/+$/, "");
-}
-/** The project an app publishes into, from its `(org, app)` on the target. Public. */
-async function fetchProject(target, org, app) {
-	const url = `${base(target)}/api/apps/${encodeURIComponent(org)}/${encodeURIComponent(app)}/build-config`;
-	const response = await send(url, {}, LOOKUP_TIMEOUT_MS);
-	if (response.status === 404) throw new CliError(`app ${org}/${app} is not registered on ${target}`, {
-		code: ExitCode.NOT_FOUND,
-		hint: "register it in the oxy admin UI, or pass --project <uuid> for its first publish"
-	});
-	if (!response.ok) throw new CliError(`build-config lookup failed (${response.status}) at ${url}`, { code: exitCodeForStatus(response.status) });
-	return (await json(response, "build-config")).project_id;
-}
-/** The org a pinned workspace belongs to — a workspace has exactly one. Public. */
-async function fetchOrgForProject(target, projectId) {
-	const url = `${base(target)}/api/org-for-project/${encodeURIComponent(projectId)}`;
-	const response = await send(url, {}, LOOKUP_TIMEOUT_MS);
-	if (response.status === 404) throw new CliError(`workspace ${projectId} not found on ${target}`, {
-		code: ExitCode.NOT_FOUND,
-		hint: "check --project / OXY_PROJECT"
-	});
-	if (!response.ok) throw new CliError(`org-for-project lookup failed (${response.status}) at ${url}`, { code: exitCodeForStatus(response.status) });
-	return (await json(response, "org-for-project")).org_slug;
-}
-/**
-* POST the bundle. Resolves the parsed result, or throws with the status
-* mapped onto the exit-code contract and the server's body as detail.
-*/
-async function uploadBundle(req) {
-	const form = new FormData();
-	for (const [name, value] of req.fields) if (value !== void 0) form.append(name, value);
-	const bytes = new Uint8Array(req.tarball);
-	form.append("bundle", new Blob([bytes], { type: "application/gzip" }), "bundle.tar.gz");
-	const response = await send(`${base(req.target)}/api/customer-apps/publish`, {
-		method: "POST",
-		headers: { authorization: `Bearer ${req.token}` },
-		body: form
-	}, UPLOAD_TIMEOUT_MS);
-	if (!response.ok) {
-		const body = await response.text();
-		throw new CliError(`publish failed (${response.status})`, {
-			code: exitCodeForStatus(response.status),
-			detail: body.slice(0, 4e3)
-		});
-	}
-	return json(response, "publish");
-}
-/** The two variables GitHub sets in a job granted `id-token: write`. */
-function githubOidcAvailable(env = process.env) {
-	return Boolean(env.ACTIONS_ID_TOKEN_REQUEST_URL && env.ACTIONS_ID_TOKEN_REQUEST_TOKEN);
-}
-/** The audience the server pins. A token minted for any other is refused. */
-const OIDC_AUDIENCE = "oxy-publish";
-/**
-* Trusted publishing: a GitHub OIDC token, exchanged for a publish credential
-* scoped to exactly `org/app` and valid for fifteen minutes.
-*
-* Called immediately before the upload, not at startup: the OIDC token is
-* single-use and the credential short-lived, and a build can take longer than
-* either should be held. The server matches the token's claims against a
-* publisher registered for the app — repository owner id, repo, workflow path,
-* environment — so a 403 here almost always means a registration mismatch.
-*/
-async function exchangeGithubOidc(target, orgSlug, app, env = process.env) {
-	const requestUrl = new URL(env.ACTIONS_ID_TOKEN_REQUEST_URL ?? "");
-	requestUrl.searchParams.set("audience", OIDC_AUDIENCE);
-	const minted = await send(requestUrl.toString(), { headers: { authorization: `bearer ${env.ACTIONS_ID_TOKEN_REQUEST_TOKEN}` } }, LOOKUP_TIMEOUT_MS);
-	if (!minted.ok) throw new CliError(`GitHub refused to mint an OIDC token (${minted.status})`, {
-		code: ExitCode.AUTH,
-		hint: "the publishing job needs `permissions: id-token: write`"
-	});
-	const oidc = (await json(minted, "GitHub OIDC")).value;
-	if (!oidc) throw new CliError("GitHub returned no OIDC token", { code: ExitCode.AUTH });
-	const exchanged = await send(`${base(target)}/api/customer-apps/publish/oidc-exchange`, {
-		method: "POST",
-		headers: {
-			authorization: `Bearer ${oidc}`,
-			"content-type": "application/json"
-		},
-		body: JSON.stringify({ app: `${orgSlug}/${app}` })
-	}, LOOKUP_TIMEOUT_MS);
-	if (!exchanged.ok) {
-		const body = await exchanged.text();
-		throw new CliError(`trusted-publishing exchange failed (${exchanged.status})`, {
-			code: exitCodeForStatus(exchanged.status),
-			detail: body.slice(0, 2e3),
-			hint: `is this workflow registered as a publisher for ${orgSlug}/${app}, with the same repository, workflow file and environment?`
-		});
-	}
-	const token = (await json(exchanged, "exchange")).token;
-	if (!token) throw new CliError("the exchange returned no token", { code: ExitCode.AUTH });
-	return token;
-}
-
 //#endregion
 //#region src/publish/tarball.ts
 /**
@@ -5255,6 +6821,38 @@ function prepareBundle(ctx, flags, manifest, identity) {
 	}
 	return bundleDir;
 }
+/**
+* The lint's findings: fail closed, or — with `--allow-function-lint` — a
+* warning each, naming the rule so a false positive can be reported by name.
+*
+* `skipped` lines are warnings either way: a function that was not read was
+* not linted, and saying so is what keeps a clean run honest.
+*/
+function reportFunctionLint(issues, skipped, allow) {
+	for (const line of skipped) warn(`function lint: ${line}`);
+	if (issues.length === 0) return;
+	if (allow) {
+		for (const issue of issues) warn(describeLintIssue(issue));
+		return;
+	}
+	throw functionLintFailure(issues);
+}
+/**
+* The engine half of the lint, once the project and a credential are known.
+*
+* ADVISORY: a lookup that fails prints one warning and the publish goes on —
+* the host refuses every one of these at the first call anyway, and a publish
+* must not fail on a request the upload itself does not make.
+*/
+async function lintEngines(lint, manifest, target, project, token, allow) {
+	if (lint.writes.length === 0) return;
+	const engines = await fetchDatabaseEngines(target, project, token);
+	if ("skipped" in engines) {
+		warn(`function lint: the engine check (\`upsert\` and \`ctx.tx\` dialects, customer-warehouse writes) was skipped — could not list the project's databases: ${engines.skipped}`);
+		return;
+	}
+	reportFunctionLint(checkEngines(lint.writes, manifest, engines.databases), [], allow);
+}
 /** Flags win, then the checkout, then the CI variables; every gap is a warning. */
 function resolveProvenance(cwd, flags) {
 	const git = captureGitSource(cwd);
@@ -5273,7 +6871,7 @@ async function uploadToken(ctx, credential, identity) {
 	if (credential.kind === "token") return credential.token;
 	if (!identity.org || UUID.test(identity.org)) throw usageError("trusted publishing needs the org SLUG", "set oxy-app.json `orgSlug` or pass --org <slug> — the exchange is registered by slug");
 	info("exchanging the GitHub OIDC token for a publish credential");
-	return exchangeGithubOidc(ctx.target(), identity.org, identity.app);
+	return (await exchangeGithubOidc(ctx.target(), identity.org, identity.app)).token;
 }
 function printResult(target, identity, result, asJson) {
 	for (const warning of result.warnings ?? []) warn(warning);
@@ -5294,8 +6892,11 @@ async function runPublish(ctx, flags) {
 	const projectPin = ctx.flags.project ?? envValue("OXY_PROJECT");
 	const credential = flags.buildOnly ? void 0 : resolveCredential(ctx);
 	if (!identity.org && projectPin) identity.org = await fetchOrgForProject(ctx.target(), projectPin);
+	const lint = manifest ? lintAppFunctions(ctx.cwd, manifest) : void 0;
+	if (lint) reportFunctionLint(lint.issues, lint.skipped, flags.allowFunctionLint);
 	const bundleDir = prepareBundle(ctx, flags, manifest, identity);
 	if (flags.buildOnly || !credential) {
+		if (lint && lint.writes.length > 0) info("function lint: the engine check (`upsert` and `ctx.tx` dialects, customer-warehouse writes) needs the server — the publishing job runs it before the upload");
 		if (flags.json) process.stdout.write(`${JSON.stringify({ bundle_dir: bundleDir }, null, 2)}\n`);
 		else process.stdout.write(`${out.green("built")} ${bundleDir}\n`);
 		return;
@@ -5313,6 +6914,7 @@ async function runPublish(ctx, flags) {
 	const who = identity.org ? `${identity.org}/${identity.app}` : `${identity.app} → workspace ${project}`;
 	info(`publishing ${who} (${tarball.length} bytes) → ${target} [${channel}]`);
 	const token = await uploadToken(ctx, credential, identity);
+	if (lint && manifest) await lintEngines(lint, manifest, target, project, token, flags.allowFunctionLint);
 	let result;
 	try {
 		result = await uploadBundle({
@@ -5913,7 +7515,7 @@ function refuseOnCollision(plan, repoLabel) {
 //#endregion
 //#region src/generated/embedded-assets.ts
 /** sha256 of the compressed payload, truncated — the extraction cache key. */
-const ASSETS_DIGEST = "100ac2fc00976a2e";
+const ASSETS_DIGEST = "cd3188a91f93402a";
 /** The directories this payload reconstructs, relative to a package root. */
 const ASSET_DIRS = [
 	"json-schemas",
@@ -5921,7 +7523,7 @@ const ASSET_DIRS = [
 	"template"
 ];
 /** gzip(JSON({ "<path>": { d: base64, x?: 1 } })), base64'd. */
-const ASSETS_GZIP_BASE64 = "H4sIAAAAAAACA+y9WXeqWrc1/F/27fcWinE9i9PauRAjCFGzxUh1J5CAEdS9LPG0979/rY85QVRQU65i52K3tZMoxZxjjrKPPv7nr+fFbPq/F174GI8W/3cUPE6X/3v5uFj+H/z+r//6n7/8v/7rr8fNLFCb6sQTejPHrIbq8yxQ47DitxvfOon4jyeIq47Vex4pxtIe1Nde7K2dthY60/6ye+uts+8l6qI5bgTqVJ/7yjai60R65NV0ZWRuo74grpw4mqrjzZ3abIz9drRxBuo3tamt7Xge2bX+uNPAs2iJY8nVkaVFTlP9psoLfB6/f7atXuQl6p3alHz+2Y0XixvH0ioj09jhnux9GoEa90JPOPrd4X1Db6qFjwP+3Owec18xll6iflPb6X3Z97S2FjljfE997gh65MTRamTpc1eo7zpVes9bPJ8apPeSRHZdSWTPimeqh645HN+Ppf/k7ll5tCRaL3P/nPj9zm9rczf2xtn32e9Xvrld5O7jn9xn2ov8tj53Y//k/R3FiG3LWPjN03e0BXFl14zEi42VXZuM78eN6tG9E9+s0zW7yebgu6OpMXEE48k1xYljbvCO9JzZe7Yr+XUOXWX7N62nnH+G/Lpcve4PjqVXRmZ9ymSjcbT+jUCVK3dHzzD2FTlxBKNSKh/y4dp4NT3BPbj8Zr93p8bCbe7va/XZtZ7wb3q/WJ44SlQZmeLKNrf9Y5l1YnnhCUP+2cN3PHi+KCdn5XJ9dJ7488fG1jejxDH72Bv3YJ1j48ZTjGdfMSbH7+e1tbVrSZW8vB1ct62tPcVIfCWKis6NY4Ubx+xV+H1P9jf33Jm85z/zNDha71he0ucP7wOZmjimE/rmlvaU7cvm+DMlZ+3sHqdnt+oqm/Hh86dnr/hZs7U73Ct+RvW6p0AX5O4b5D5zcF7o86FT6xau4cGZlpf+4Zk9vJdtaYltTcYnn4mjimNWd4XPesU+HZy3grXwFXHtNkv2zeo9e3G08ZVo7dJZ1/722iT/oXs7C2yrt8N5Udv6zLb6ga+Ecy+RKq4gLtS2H3qJNHenznokGBO1GU4cS4+8uDp342jnK9GzqsBG9X7cDW4CoyW2HnazYGRWN65iLB2zjuuuXWGz9HGu2k7kxVE8Mnshex5p7o6lykgZBo7lhG5T2owsKXKVaOUMbsbla310xs7q9GJdcqC7jtf4SJ86CuxutHZjeTE8PpOKE7rtXnRiJ6IT/Xm4Pzm5cQXtH5zjg7MxlRK3JkXeVJ87VoFsxr21G/eq3lSL3LhXL5Qt0ndy1W33C+zN4TOMzHrFMf3IG6uLkzMQi4lrynTW1Kkxd6f9AhknmVj6ZgXX23SeGwdre2Tr/vFNfeoY4tIV9KhEdj9Xn0yNVYGOPdF9R7b54DnVOFr5ijF1LLVgfZy1F1dD0iNNrYr1Pn12bTky63PXMpZ0r+bN5uCZ+7Oi9Rzbpj7hNi105RO5iW1zu3MObefdU/+///uv//e/CvzYsfd5TuxEnkJJHDuwjmLs7Jo2Z4rqhgTUUMRNx9xGfmwsVIV9T1VwCJy5UzMSmxbgZnWFE3zOsV27Uz16bB8b1EJF2nYVcay2pdBvQynWd6rirL2x9OwK9YpjhRVVceauYuzUZhh0ps7csbzVo1ld2M1NYDfrFbcmze2kXnfNbdBpSkFn2tu6SmOhKo2Va+oBlKoqa5EniAs/NiZqW4tcRa6MLCeCYoXSdgbSBA69XdPX3nQSwNH0FRmHceUkTLmaQ7n30JRiBAudgwN+KNxm9UDx5QRbTrxYrh8IbKlRy31v2qt49Bx7xZsK8f4AahPb0kM7lneniq5w3VvZ5wfSyjarkZdIsReLy0weaE03ga98D8jwKPKO/a3O16m7spS6506M0BaCIFMmSrTjaxqQM/QwD1RFjFWlFTiKXLFNLfSEYQDZw1qPzBsYzEhtS4krkIxNvUSiPYA8d6bR0lUaK7UpDbEPA1kfDpvSwraiyBtLiWP11i6MIu2TkX+fiptIC9rnw+cO7trO3B5Irt2CEtlO+rTfxo2vSP7dQNq5dC25kvsezkXgKEbFNqOFl0ihFw/xczwy65HTlGBIsEYrp4lnMnaO2Q9ss5e4td4uPWtechOoLXnhNqVJbv1pr71E2vmWtHFrWoW+O50ED7WwrjbDlm/2fugtdaHK0tqr6VMvNnadptQcmb7um0byONgEQ6G+9gVnYZvLqNOUbl0leh5VwjX2rtO8HQd39lxVeqE7lsbOAOtCTm8wUozEGdQ9N9qubEUKHk15efB8Vveb2qwEriI+2+Ym6AykEEb80dLndq335ChqgO8dynXeaEqulTcU55298cjSI7fIWJ91SIuC2WiFz/lmjwKbE8MU65En9JKRJdHfmS71F66gwYmauzh3UwQd0dqddoORWf+HBwr4f8gW9GjyOJC6D61KYAvY1wOH69DxVcigLj40sI63C/c4+BjriWPatG5qguDXgV7jayJ2XaV66wr1eGT6jm1Ws+vndMsOtsed6nO7KkZu7M/deHiNjtk7yU1JcMz6xK2pgScYS9usV0ZmFzpgivNTZINIt0T+zDFvAtvEM9QrnSbTxVyXJ2pbW/twphMpelR6C9/qzWHbHgdSZYS/mf6M66I5bJIX07Ps3yeRuPMEme4HD61tj2yREsLezB3FWMFBt1M9qIgT25pAP40dMwz9OFr7ljo/sgehO43eIXnQi1xTpvvrfJ0yG38mEDsXyJ068OeTEF5ND33FKErSnPgWQ8VIOlavYlt6pCqi4FhaMjKxN4dn4lIi4IIjdriG52X7wVfkijNM7dlZ+1kZKdFqJJCdfYmeyH1PTBxT3rlCHWc3s1+qIm88ZTuH3oAM2TjDbWnuKcaCZL/N1sxLmA7uC/JKVbT8Gk5wBrz8+jL7RWfBTr+/mwdqu5faKnZ+Yimw21HI7Hg4d+Mlnu2bqsgTG+8D27iXlWe13ZvB/ozIjjWe1fu7RtSU1t74dhxo/aNrGDGCGv92FrimMRnB4T5wxLuwGTW1vdn/vb0JRko0HTWl72o7nI3ofOLv8o2qSIEtb/HcwWMijSm4sfQnXxF/OGZ9dz+W7tV2NSD/QkFCCmvZe3YsCTp5oSpa1Sc7vK2rrd7CtoyJM2hUOs92YJv1iaoYoRdv546lBr4i/4BO8JvsvXrNm9pdIiWOCXnUd2kgT0HbYMO/L0UOApCpHuR8nKmH5BnsNXwIJFRIJmBTb4Ihzjf0VP67bWMFf9ZLpLpbGwZubMB/CFUlDL0Y1zHmFLwnEoJ72Ou1q+jwdbiuujk6L/X6g2CfBPQneuD8WRlmclzh56VKcnMm2XU2WXZkq0ivnCYh8+fPrEaPsbg6SZ4Vnr9Iepi0Al+Jlo41X7vxMLhThisnuQnslrx0LG1uC631gyLurIq8cgRj4Vi94G4gVT0kYcjvT2OCIfM/ZX3tKHK9Y0K+oPeGkNWVz22DFxsL2Caf/D654liQ7whyFDyaxs7Hnity3abzIgWuIu/8plRzTOOH3bwJ9NQXaHdJDxiGfqu2mX1D0tqx+qszPhStZ6EefWsieL8Hgm1u53i3dJ0v6XwjlhcjU08TUYlvbl9iy0NX2QQ2kiHt/hJxgDfFPnXx70pt+3NfCWhvRpYa7H0paWNbWuiaRsWxtF1nLBmIJ3jSbedwf4/2WNHnniCPXfgMNSmyBSTOutl94I/4bWPlDA6vqbZ7VcQ0ttVlsqGIVV9hugMxQO4eM/jiI0VcOLfzYx/6YD3v+fp4u1nqv0zux42lqlDR5dv+HtrTwT0UY2Wb2sIx+9/UNvxZelfEPTNX2E6sWm/uCNXwftzYdZ4bgWtGK6umrf1a95t6a1/yzU/k6p30iZl/90/yW+72vrB29Dx5naLJj209crEOsj4bmfUfOC/pM5q0d9foIMSLxspRSJ9k11GV6tqBvJF+MSql52GS95F4Ancv43m/dE1yure9e98i1R8UPxs7yKcNubEc5rfJGxQ4KvC9mf+RXsP3VG5PVMVJXKHCdaChHfmyufyFOB7FxrPfPPh7eR6IJ+POJCeLYoYef29Nb0pr+PheHE2cgRRjDYrfxQuoqFeU7D4v65+SED+K4cr9zPI12dvmhPJi8cj0ArfmRN5Um0PW4Keoyll5XBUkSkvilJLzSP+pEy82YpKHcXfN8x9zHiOvjb18FcaU5etS6E9coQeOk7qHtu3Y7yjw+0/j35cWLi8UGG1LmlvCMnocXL3f0rA1CUaCUe+MG4Eeywu33Q3sWH4esZxW0B/WhwNZ+3vYim6titwfGGJHN6JAbYaSO4VNEjcjsztXFciF9PewZdz3h9FT35A0q7KUTbMR3LXEjWPWpdGgsVbT/0esZEmh35wgNhdGlrZ242rkTvuBH8vJyIQtNXadogLH2VzHWZ8lBQWkec5FwTk89SdP9/nwezHyjMaTb2mLssLOqU5nuUnD0Lr5GLYTIS65WaotxONhQjln2PG2tn5sT9jnUdjjeeD7sRSM2nrFa3eR3w89ZbKinAfJSvTcQY58IArdgbh0rN7ORtFIaMyRZ3uoSZE7kef3Y2ngWL0NcgHwVbB3qsKe707J9No3VZFmflvfeLvZuiPImxHqB+QzTFa2IC47NXvbqWmRV5PW7rR3cp++IC49RcYzL1yhx/IjlibAlnixuPabm8AZ1Ked9J1ucZ/tGvmukSLu/NvZtvvQ3/WaotA1G7+DDo729l98jT72ymy/1VS5LZI28AsdC/uDeF5eID5wY153IJ1sLNTmotCu+5aW+tQh4nk/lllO2OqTb0xxz0ASRmYrs9vwdx3BXxTkcheuUvmWf877cRqP9r9RjJ6zHVbt4HPMft/OAqcmVToPw1Uvn/PYzQLHdGLkDO7jauQoUdUdSIGtFMmBvHocinFxMbJE95/3Ma/x405txWBzpa3L+z5FxdBD23KF3C1tK8zyGdfrpGr4qFBROHBrRsVrGwQIGAkotkob8vlY7jlQW+lZoxzGWr3tb+4f7CLb/2Ywyplid7m+Pll7DbKztC0qro99M1r5t93kxUXdYxDOHuRVBEY5iWMf2OeDwbCPOtPfmd+ZxX/8HMjI8TnBPndgTFL/2aZcT+ND1vrdC/Xch7tO/hCf4j25zuI5LcesP8Mvp5ohy4UhFqAaiVbrBvZBHXEbMBtat0YKYvteBLvC4hYHZ3jtjTfB3ldKc245G44aIs/L8f3Naoi2pbH4h3Rkdx9HwW+i68irx4G0xv28MWq4xsJpd9Pa42HeIGf36b3Mykku1VW2S8TzjmkjbofvFI4GlYqbVElOaS33tQWqR2Zykq9rNov0a24/koMYiGJE9u7bJ9pDRVy57clpjP+Lyl3O1l19NvV9THxFrp2wA5RX8pRo45hb1KqCtI7BZXCIGil0pxcbz44JG9Lj+XaVy6S+9prVhWM52L+DvLfd5PLTpPxs0Df9yJ3qaQyRyjn2pE7xhLJduA+z8vw78t7NU3+6LA/D7E6B/3wZjPo72Mi0Tni1fPQRFwkG6u7pd6HDW6nscxyAa7e2C9fguuZ59q2f88dtuRL4Qhi5Y2nlmBHl78lfgi6Jo8hV+oFLMbbE9X+v6rWlBeU8FOSsmc/1kMXkRlof2Nc9Y2PnClsBOsqZamv4STjDdlOqkU5UtDXynUyXQT/ymosQzpGLxLP4Qhj6TWnhWPoOeIpjHbvX0ez5HjOdIa8QYzhNieJKq+aEXtxALfbZi5GjItwC0781I3GVBt0XeVNm/zhWCPKlAKTbq6Q5K+Z70BqHyLc6MQCKBvLmtRG9C2p4+toWxMV9ydnAOtyPpXWvmdOfh3pw7sYhgI+47w/Hip4Qj7J6lxb5zcYP1NlGhlj14k3gx/BlxQTXRCxkCfLcEtLYFtcDHsIZ+wTWlBejpLG2aW3FZ1cg4CX3MTfY94raFJN8LAZ9y21CWuOGTxBy+0L1M4Z34boLcYIiIddgMnnQgIlZqW2p6k2ltScMv3F5yev70I5FAXUqL+F1LcW4obxirTe3Y+Taoxg5PmA8vLFU82KxgnqEfSDbmzGrmelzr0ag++rI6s0op5zab+QJuZyn+Xmrqa5U2Z8B75SeBV+QmdzFcoL7PCjbpcHX2m6inibt8Hl3qkP2MvtD9bl2L8VawW6ihp6dDdvc1mwLNTWf1bziDESb6trJyKQzSDbASdiZgX5GrSU9R7D9yLkW5SfeXZ9Wcvpk/HN1aA50e1LDz+/RNTUdhoFI36uxhg9mC8uIamCoo5m9CnRsiU+U7mnqFz3ZZvRk8xwDP8t/u8o2dM3WQm07wM4sVNxT7lV8U5+7ySZ4gD6qQGcsFqhBz3NxKP/urvOsBoRPYmf+m6pkeEqWx1DCtVfrf8MNurv+2n9u5c8t/Ff4tU9Uj7+tBFZT27mx/MMxRGrksZo4o8CMRAI789n7BGrze/7n7P3gG+T8YcFGHZIwlnQv1KoIw+ZQbQS5gx58lAUDNzdmdupLmsAvSjyPk79+6usyXeHGsDNS5NakBemLml7F+zzSGZOfR02WN7+ZNYdcx9cc+r6fB6pPXKELH2rpmqS3Qwd4uilqZ3jGVAf0Ii+GT6xFVAfguQ/HrLDr43znbZgiP9uCsWG6T6aa/cgkPNlRnVNcOUV5gStzpbl8Z/BgGjtPkKdZviyXk2M4UIPp75Z8b7TCwUNV0vpVURq2oqdBxXDs5jnA/Dl/WIvcKYtNi/zovD5+SQ7zuviM5W4Hg4J8ITCzBfk/5JUNalaTgoeqJD9MZC2fR+Y+7L1b0zPdP0pj4ebsn2Fs7DxFXKGB7W48o3t1mtLKrfWDPvNRbg/t6B4/4sV9yHLitydpDlLrmNw2KxHVah0B9XU/fGT3DDNchxItPWUbcTkNOkIPcrxm52MbsTpED3nwrm3Wp7oiPo8Swpcg/pONgbhzzG3cMaEbdPhDiFlv4MfdDaTaiHRBf9NrSjOck7S2bAp5261+u58c5csVyeexRwU50fONF6+XI2Ch3EgMR4MX5DuvbWhRjFV/OFmmumbE/INbwsG26D3hd7Kmr5bcHwwaM7tJOexnfKYjHH7Gbk5WqtyrjghHCl+F1udlup/prN3IrM5dhfl7rmIvKe9MekXkfro26VhS6E31uqr4iPXIn7gk50wvOWj2G9tm74faDPGMGzT0qIoUekr0BH/Zbmb48MXjYFKU4ynCa5/WSMx61S2rf8QF9jK4rq5VgOUYAGugs/zIVVhNxMl5TLY9SPEc27lX66dY7xu/rYWqrP/9MNysOSYe/vgOmLVHU6Q4gnDfZiPDTbkx1Y0mdpPhphELuGlDHzA2wMW18Td56QmNwI+jUFUaz2aN2Zw7xQH2puKYN3PLJCy4bJu9mdrWqq4yhC+JuijqBFXCeI8lvCNsd+gqEdP5uetz/O4c+SG35gPHUfeYPWaY3yZwQuRnuja3e5Yw37nCzbf7GHmcKuKPhW8agcVjPzWR5EdFJj2kypH0MNwE+xz8T8B5XGyO0iLPMuYecpinGGSWs3ptU6VZpzPvNC83A2HPnMG5hiBt7QrbyDZvXtt4ebaX4pL/PARWyOhFfivDkV7GhkSQS+QG/MStGZsUz3+ck3KEo7r8WxvaptQLwfTttfnd7Fn3OFXbdCpZLgz2nuHk/rkbSzsfuYDLWAvXOrunBb0w5xvcr6kHHei8lzR/Zrn8d1wz3Qoju2ZUnMHsH8L4mn50sW7+Qc2x5/OC9C6yO9WTx2O/on02V7dDU/bIdOZlzdOFOHGOvbPR66JEhH11pjrPmwyDu/H8gV+3Dt+y8Jxc7Lu6hkzhQr/JFXgXepehAdxv/dhWP12PQXnI+hEqxsqB3Rm+QNdMTvBlHA+EHBTVdVF3Xuxj+oP+h7Sf4ySe3/dp9J7SPo3D+L5XtWHLT2JwaXc//r62a8bYGdSj1CYyzAPzqVgN9OYb8k5ae3lrDDWZ+2XDh8pSfphWPZVhLlIM+t/DMYtlHxQRtc+E/76oN+Vb9q6oe6Sfz9WS7sd5zES1bgvfV+nn+HM+Qzbdqf40gj1mz9l9qMBv1J76la2mD+tDqxK1ngzk13rIBa98GfFFL6G6f9l3qj25X9Vko10FBu+4Vv5GooRcvewI/5vmRF9r01lumNWdr68dIk5AI/wycseNWZ9kYgL/7SHtdYNvbjXVyWPFuDci0ewbmshyL9QInHiKuDjqS/2la1y58/AuhBK2APtSr1hCdL19moiSb+mzTC4JT9mYpWfn7vfASmZnMKtTvP7903MZ3LW2a8ijN578FvLkF+dur8Jg81pDZ4Q4LLjeHh31Tb0z6cKFvswzub48iQT0w+F1UCOi/h34FHGKmaa+WrzPgOWQfg/sYjV8BNbEgiwZr8IKMUKTahX5Ky8Wq26sU4wO3wB1H/QxQ04/ZD3OkTiU64JrSDN23YLnRSw8Mqsst3LbWHUbZ9eW1UivX1P2+VbUOsCGZPk+1K1YD14JxgUymGJB8P+sB4nJb2SjriXYvM6a9RVSPaXDnxX9Q8YRVobhQY+xMil2NYfpP7rmPa/7pvhC5GNGZh35TsRek/u01shqDMscHh/PnjiWtLDNXuQ0T3CG7JyhX1xB/502d6YRxzuw97gHr4MiVx1luBwp8nxUGy57zUqV14XAfxF6+94HhvmPqY8K5wtxAO+dYdhDjgPi90O/X3XttY1d56G/7I3TnkZp7QtG4kzBecH3ku3dw3C4CRxgB/Z4yxLs4p/WR3AWP3Mo0+N/LzblXF6otNfhmr65C5hf6mdvE7fFjvEN3HD+Ed4jzPtewUNx2LMrpXIW3CmSB2K3FGcEnxr8KFZTm4ysHsvPyZsx8aig/p/ieJ+3DPd0W/fUuMF7CFqooWzSnrwMI6Oc9umm/Y/p9Wz+zAbHsZBOR/y/1y2hLfQiD5hVwinU16hBAjfimAxLYiP+b4mrw75ej+u9LfL9Cd7NZiR/lTROoVwvMAGxkXE3IA9HepFqGAxrYKe9zEpjX+fi2DqnBvIq6GvitUlcYcN6b8Z5PBryzVJldLsIEH/3mjcCr11EtqXBBy19Pl8Qk1EtxSlmfcVcB/shMDwu8IlWH2s2sy0NzxKNKI/orVQ5w14K1Es2hq6UV56wZT1ghBPSqo7iR74sslgMNbIMO8T6jPfYIYaxRN7DZ7UT4DqQW5jx/BZ6kjP/IcN0WHLVsXqsrxP4DUFO3IwjRotsQa7m+jRZnYv2O5fnbwPbLk8dwZjcGVXI684GLsuUE/qOGTGZb80fHio3wTDlRVKoFv63E2M9o8oI6071AeCcohD9K15sMEw+4ZaZHIyAo0pz/m0jsSnvEYYe8lBKK/CUbUh9qRm3DelH1y7Dm9/Ovg2FEH3eM+wncGUp/lRV0v45ZtdMQSrruf52P0FOwwhd1BWb3y98NpVdcNdgTdCHjF7CiPQOfCPGLwDsE2o6deq1VhUNNj55NEl+M6wC+dGon5hkw1OdtMb+wO9A3z3hnOA3oIc2/h6gnou9tc3qeGQCX6TXO2PpwRWqEfwm3eouVCWEHQbGErko1GUmjCuC8QfZCsMB2E1pDPklzBt6/UBmF+sppohkyzXlOtYUeCB2jRb6kxbACGV7xXWV1dRAvkf3A47NNuF3Zf1MK7/ZSLDGuZ936OMg+YWfUetyfIM+c2vE8QP/+dmt9ZaoddpJhleKGFcV5fbnwKBC91MvurmdPwKrofTWIJtjdcTD/Xgth0hhjjUngyTf3F+CnrdNPcRn/diAfgfOxFPjtE/amHA7QTrcampZn8jfCuMN+zuCzWAyDD9AVVI+MfBqibUif+FlOY8rccFWuCGOI+hFrlfRd3WiY3ez4CFucD10nhfCFeqLx8FN0IfuhI9/21/1kgV0xxI632ly3wh6IK78h+u+AwwK8mg+9Q6gtxz7iHvqqR4lnKS7778JXMUQHMbPQWfKQ48Qx5/a5g3+XvGVPQ8Zy/8ZO7/ZqHRvG2mNvGZb2gr8UqecE31gltduhk3gdrfdPV/HLuz3vSIHya5z4hdc0QtyoZeY+57H+1tWKzqUO+L/cZAHLsrLXB9rXkHUWNyT+vRWnE+kRTa4zhgnXba3+X1Wle3ar22XjqnPfbP6nbhW2tsb/i/6j1Jsz9/uGBxhFIulNhn/ZT1GhJdl2OIc74m8cIX61BMYPtVRZMQXAutNSH2hxrKT4o7pPBVypKwZf1O+T1mHDzgjXCw7d9zny/BNdE1fETdqW6+B2438VPR4CNvQtRqMX0cJ544QBhf0UFFu/Yq6eFrfZr7te8l0dr3iv19Rw75K5s7hRYr5Gl7OAZLvo4m5fgwRY/tNyekPq9293/kyXqhL9QnO6XGZgLhdmL8DCfQcGGinrA6b1YmJT6Skxp3V4LPrHNehC/oiF27rXfsiqQ4+FIxKIe9GQT38JAfdP8OrF/Ec1ATx61UcnyluLkB8glod1tnj9Tx7ivw2sCKFdcmA+yvRnm+S1YVYTTPj79zzIihyHbaXYV7rEdMzwIbl82zSac3VbARe2xjDp2CxYal8FuVyyrBdY1YHPdJFcVqDKCVmLyGXnc8/k1h24+1BL+nfy5L/ZU7BGIEIAqlc8R3s9rtRrUtOID9EZw64RmSwXiwuriNxZALCiVCifeC+BanfhBSyItbcaXeRNU1TgMJInwDSRZHMSyZogllT0MrAXjvu/OcLDXAsIIShJyyCAZJaMZqyDRS9eQAOkKH0n0cGUuPvcfOdkaPeBE9WNfh4QtnzQIZ+aphbV5HlnR7yi3sibvaFm6O/5wyF126cIcFqjMvAUseEoPlnHQEUrcj1a4zZXlalMQhPkZiBU+FREY45LPw5y5TD+03tqKBhB0S3OTBTQSKSK63dSDkBMBUbbNboxhitB43Z3jhOFrn3Y4mwNpxOkvPQYw1eCYBOPOiYpeSEvKGNOX2KEbNGID1Co1BnLFEx1q1pO05AC9Z7NI1Rg0OnKaGpLEscEfmXElUOihhIIgxuAj3ezj0WRCFpwwiclWo4ErJGtY3XlISRxRuk6O84/72qa+JMnyNoZSz0Jfs6Bpu/Y8qrAhmr2Fbvx1W6aQo9sWTN+ZTgZQUY9uzQPy0G3vlMOauS7jorY74SVbjTc8nYqz4M67gae2goi3XWhGjpAJODKK3GJxZMbDShxSKRHkJ+KcitdanpLEeKtyCZUbZwAGgSiduUGFib9rYVjNoEVEKCZcID85yhJ/JwArN2TN7MQ41kAIuWGPhfcbIKbLFMskMEWdeecwJbDySST5ZsNW4cs1dlzTt8na0et2M9IpNC0gHgvDSBRkQPlsaJSIb7IA4JBCUDSgWHzTZZwwdvfK8TcReahzqWVgWhMiMu6ekPB+B6ko2U8DowKvLDw4CSFynZcmZDMTUDTR7Ow4IlIQUjyUiBzfqkg+K51Qhyfgmel5PbaAEHkHFCYf7d/fqkiXi+dgTQxvfq+UIAmkbd2I/UZpibCpWCD8jHSRtYtoyoWyLyGU5EnCfZTskkH9xYrDnxlnQartOPo+nQMiJvOpmXkrMVAhDKmklSYM1x8KulxD/jc6TAFFRwmX7fKT9RfAJay/mJpyCBi+Rzc2f8OkD4cbG1UL9/Dqh5SPL3enDpbXpeyoL6t+0Zmxh2vF60Jq9tHjgbrBcPM8j8ZRQW2gYao1dZkyJvMEl9czsl+2dJUb7W8Eu3a9vsXwcKOwsw2YZ2XA4w+cWABKzR4z0mQMXcx592rweDEzEHJiBRkxHZbbcmcdlvzLhtqnFAzdq3tGfeEE/Nhmj2/iAwYxlg/CXkRrlzTw09Z8H0LgDcwvDqtTOgGxNOLtP2eXHKmXvTHiMdbRtLdwyQrVR1OWGxQ2dPX/vCTW6dpckjNUOD6B7Nw78HkWaqd18Iisz0ocH03tWAjyxGlrP3/M872GI0pBYkorWKK/hT+NxHv2dF03NDICb7uPHoGVmR/Iqi4nslyrmuXRUUkQrsxBsLQ/t7XVMQKpkSV6DXLsnb9Q2g6TTDFSscFZ2TFNAoJyOBzum46DNW/2JCV3wlcfvbCiMgKRic2eui4ts0KNQJj4PLANELvkSquxBXlzT4lMXpByRn5KdT42ZbwpABPigJeT5GLo7BIwBdpT/zZsTFJULbQrtaSpCLAoSRnDkDl8DpV4CVz+jjgkLBufPCYv4rzqJc+PdLNuMMoL78jBStafYcL9AZxc9ztnk/9Q3nbmw8IW70pv03Pffjx+i5G0uQb0ZW78lV5HEJieIV9v6KZogzvtSp/S8Hf6onDe7vc9YeDRFg+p0lnPHnf60zV7eE3ITEEtkoJP3hviAAcCkQgoNOQk50NskV2+odEzKCnAVkZLvj+WCaeOor0SaNwwBIMWh4nPTsWxrp00ezwRsUq/BHKjblVKoAN1RpsNlYMkBUAnAUkb3TQAYt9BP4ndUxG/pQZlvPkcyeAwu/JB8fKSlpafFeFsrTxXufHZ5ypshfelbeAkC51OTDp20XT0I/tb2FPn+pjTznK/D4/r2AF8xfedFZQR0N5DCMNJLl7DNi3pTkE3lDRqCSEkmkP7N4rQSE9Aa9XR7HvwRAUqhf9zXhX93n+Ewf3VOiyCIColMg0MvsF5fpD9k7du1Psgs7gCeI+MzcVp3BfjI1NaO19bnX/LIHX/ag2B7w9y30SYttwQnJRwF5xoVm1Nzw3DPnryjnnG9OYYNtQd5p6RuQivJ6eAhcCKtDGzveLMHJsIry5u9x3on0KLoKFPuz467CmvKvGF8U5fteSux2BQEYB07blvYrx4f1j7FT0VMegP2Cc5gfMsuHCegVBig+HLzJiL0nAEGjfrCwTY2Bh6kurYNkqoJ6cYr1Ssn/bKVXRdOGG/fqaeODC6IzSw9BluaaRujVjISILWU0dRlElIymFWAWvFiuURO1qRGIsUw2zjZVngODXoHv0lNc0zDzA4rlr3DPL937ikbLwhzlb57L/KQY5A1nNT0PuzecKQwYASnkwjerK4avqYY+/o7mw9YyeiQypz0pbWoD999h5LeEg8RnrAnhSxxTTlCbPcBZELk1ar+NWTp0yK2FdeTDfVlEM0nFNrdPvmBEI2Fbt2rABhm79FzmSYs8hplIcRgLRmTbm6nKfE2DH+Io8hMQh4PAajtJ8S62LD4ReWWL19Cm3cAVqnO/zYglcgS/S9tqnGKS2N/2NWM6+8jbdnM+tJGU+qxX2L1yH+wqu1fmK5/FKpX6qufrba0Uf6mn+r3omdqVr1j0DbEorzv8VrUimwYMQHZuzsUD71QD6oHEGjZy9UJdeDtSIkZAn+KIFQ0E4z+IDIPFo5HD8a4dU6t3LIaj4ySqU5D5EyYtubns75diiK4hq3slpvhsLFnsW6a6/VycUZhPmBpLm3B2YqwqwBXJi47lzx1q/Mr07X9U5WiQFdOpPN5XCSeSk59Sn+oKIpurde75gVeX9UbJ3hcMwArK5OTsEKxfJi8Wi7Wr4633bpKctEDYsPatBpeRDKsacJ+YYV1jRsI6SofnKtm5YFjklHAnN/wAw2e9WH5mA7zDCLEBP48poTAfiLK/JyfsDOzYwD4Tib4b67xW/D1Iyd285Dxh+NtyLrwnZFwe275THuU8zrFEJwzK8cUv3bNfQL9mvUacFMZ7k5793Np0rk/qJ55fqpcI2yiPs37p2e3HxrNtGbt0aJq+7+th69BmgyAsLhsgfLBpyIHOBuXguUA6H4MQgg+qyz0PNTozQqwDoh6bXTPDqFs1IhYH0Sfw9RXHlCdk+zC0B3sH8lDqY5AFFwSP6P9oG0RsQORLJgi+WHMjfufzIfNZn9LDLECzNd6ByLUybDwnG4esCtSYe/RM+BvI9ImQhOVCbmfBMDamvCcrxXKiiVWC3VRbdSKV6DSlB9S7RnLlA3VWJotPZ/LC5bW099Vrx2tXrh9ejT08E/McYi9LMUzH+MwrfQO29+frQu/mQ31KvpZj0j8CE7LHzH7OepUSfl+Thx9ctHHUQ3elnJzDJ1+PEf4Xx+h78ourn/ksGfu5Hp2CfO8VPbrh2qcez32+iuXCGdFTLnc14URYWUzMSUUMRmwJ+8Hr4op8AzvbSfbYII8TJoEoDQRPI8uZO20DucYUI/HsCtuqa9aRg+dkmiyv3mlmJDjUj4tYkPJv8LUxCJINe6TBHvtzSHEj6mLPR/nL4K6NftaUyGweebG444RJG2//nhl5DAYC+m1/jfjUFqKlTdgn+kzsKmLot7vHPVpXY65LBhNndYasB531rUUd5F+VxqS7a2w7t916L9nU7h/UVe/WCVjtwtipsvGgN6VxfhjftQRNpz0A52Rc29fz3384Ud9B34dZpyEKe2wZ6zFM88RdvPvAwLtr7pRwunOSNfQwmxgMBEI36DBOMjdozLr3d43JrrXpovc5Ix5kpGcftE6b9F3efRBYBD8uWmW1pjEGcOozRlxm7FDnokHH1HMsV6gf+1CWtp1bdddrbqq9Zz/4oPdPczjjKwlICvobjBtPERO/VaLbLtVjy55v2tu6x30KcW/nH69DTIOATnve2ic9HBNX6N2c79XgRCARiOF0hQ27vEZXI04SE38/jJiRqQykriuIP6AXs/oHJ0R8JLxOb577Dh9MTdjNtAf3lGj/bYOE+L1yfdKDl5CF67jucyHPREFvnhrLOzt5KwFdIx2G+joC/3PkOdjvmmQSPurkfa8n/Xsrod4LB6Oc+Innz6eYwDYbRbmL157Non2lc9E926s8xAAJIdr5sr4eFg8RKO5LTL8He5DWBylnDSJPNjzEqpHcR15ND1JCUi8bjDhM/RHGDwPb09bWnAA0HUbACI2iowGLqBUQEVd92hmyQQYdiw/eaGPYYJAOC9Z9M3oeVTAgi3FK4DMdxNU4k0Jw8Dx4d59IAsnHi/yEDc7FZ0YpMSwIIdM6aRu21k9GRLCJPOgih6NIBy+Dy4MI5Xdp/tONqbc28RlxKoby7Q4JyRkvjt9McYKNmWtGiReLSTpUum9GiS/IdbUVrfy2QYOFefxR3gNfSFh4NtcwZjitY7li8eMre85ZffhqcnkuN4pIPib3NdN6x8a2NMorHcqVOAHpe+r3YLgn2+8wJVsM3k7CeXagWqGP5sUisw172eC9qXgfY0McC829T+IwLgTiaSKMDos1rh2ueP0Atz0mQBlhGLWlvofefRu2hNuX4hxDo7geytbnvXJacaGvcbHnGOc3xeYO144SLUHuSfLM8pjAXKXDA2K+3gH5FK1qFT3eIF52KHZn8nE/bnwnLEZVpJ//Ht98Z+ujP3GOrPfHScbi5rPifsdqvQ0nyff9Rf2LER9AzXDYiIlpsL3NhtreEscL44ZJdcFiHzdsoGPWrmKE7nhDHCQs13J5H96Yz2G14fLc4J6D6b3yh78EJpr7F+MSOf2MPphyf/eSjC0xSMKHXAn6HIOZPVZvIKJj9Ag88hqME0cLn4YGiKvOWOr5FngKgPV3kMNkPbMPs+DvtjN3LD89+6u/uf9lCWSX/78P6J1Ze83PqrHVI2/wppwlP9Ov0NspN0rKica4x4BzAyfb2CG8enpON0F6HjtNKTt3nBic5XbfgF+7rg7A8gTlue/9YNj3wqn/ErjTL9/g3+Mb1PpfvsGXb/DlG3z5BoEa+xXnyzf48g2+fIMv3wD72f7yDb58gy/f4Ms3IN6oL9/gyzf4IN/A2H3pg99NH0Sr9+CceWmvRp/3sxC/fio7pBecudum+uUYA/R0U34eZfVd6fnT/Ya0z+NF/a9ls1NepKOu48+4ym+5UledxcIWy0RhL/4FvOkF3N57DQ5M44uy81Vu26zuV4zzu8U4sVixhC9d9qXL/nW6jOGEXhS76esvP+19eFFKMVrl+KYHX5GBX1o7nNMOvC0YfE4zaGhoMLCBGg2jzuKUZqgNK9/TzyIGShwT+DcamroYmctIbfoVV9DDx4G3UJteDZySxKli+mstmeR0S2Pmw6ZYvYptVjeFcw9+97zKT7ZHI7P+RHtliHxf39Zf5L7QJuk0kDqbh8e4/jFEOvbL8m/BXSt6eEj4ZxXMDsMgbpnPPtzOMUdIq+lrR5HrWrIJtJ0HeawDB+oI36d3g33MrjZDGkYO3KZrNeZfsfrnx+qFmNTz/i/k7J14UnhO8WW6cUi435QHbSBOIEOYJ4YeL+I5sKSN257sZ7Ix/2rtjm+CB4uwwOhRiklXpL3Lt1thZBq11A50nrfMnsqpL/z+/Pp87V90ZoeEcc4Pl+VzRGN55QhlebLGbGD0/k4/S9xVsYFB8cSBwGaBNaa+Ik5sazLtNBvTHp1xzHCTp27izTvNPR/KXZts8c5X5KUH7qpLNvOt3I9kj8ptx94H/tD+zc/Eba19WZy7kUh61qoxnfxGXsn1C8+ZzPomv+TsA+Xs1T23pzhzbVjQX1xm96vugOaBgkuChmTDtjtKFPM5JJWc3iSfx0tyWHozSii/AB3f1ubMb8jy9uCgOOR/icWVU8SLfB3W/8EW5IVtqeBqWXqKnIysHmKALKdxpxhbyI1jtRaq4qNvd+orQ8xYw/8vfGU4P4vzf1vcdT5P9G6cYl8Y8q9a8Adw4EQ9zGELvXG23nPMcd+f/8aMnStgiTeBU+vTGXPgx7f7dMacweQDuVk+p7aMmtUncS6vvs7X1/n6Ol8fdr6mfvMLu/An5kMK42EBnMzgdk7XOwJfwj4f3AzpXLkx+YhT8Ks5NT0iv7CJM6ZHd4Oz/atvyr18Ek7yCzf8db6+ztcfcb62Hz3fqTSnmvJvMa5YFmuX1ZpyeZqFqmRyvKCaAOOh+9fla17BNfWV2/h0nLsefZ2vf835khjfUHVsWz2ap7E/VxF8gZVb059G5s3PO0PvhyP7woN+Yaj+rRiqr7P/2bXJ8TvEgOe47wv5q/i5IsxKqkMol5ntrT3FLCUjtIUgs7f259vXlOfuJbM5Ls0zuE73XBWbXmXfr8yvNi7NYfOvnUnw3rGrfoCZOzz/loAatfHE69mMj7Wg5v6RsetPxt6AI++FNYRehfEsf2HGPjKHU9ZT9Un58y/cyb8cd/IKX6uV1wP52tYpxhW5QtaHcaSDP9IP+7n49y+c3xfO7wvn96Vv34bz033TSB6HjO/6GOd3wSc9ryMPec+P+Ik5RjvHK39w3fO+5thRcM9e5kOe46coxE8fn9FzmPHL17o7jj/2Z0gb0kzgF66rK9SjojnaH8fDIU+BzwQfuFMon2STll67/wlzTg+e5SNmSmMW1m5kgbO5/vxoiNm7vSxv0Kt6NX3tstlm++sNpIjlCGT22baUAKPj8/kGvkKz23eeYjyPTGduJ3xudEsUHEtLMIMVMYpv6WuXX6NjbiM/NhZsfltv7tV0muVu1bJrz53x/po4j7/43KLjPQDX+pVzmRrbyzMSo5WvGNPyGKtgZmmzrP6DGXrRktWAGpvOc+PKni8+4+OM3bfNer3onF83s17FLGDCP6vj7prPF5zzmXdrAzPDK9kzFNu2dkne+Ox98+t8NkcjviU2ha5wLanywhrelf6MFvltrX7Wp8nN5OgOLvZvZvOVSmPkdHY4Pa8xd6f933pGLuYY4R3eiDlNRibmfp+bz35NbaQ0jnvLXOPQUXR2nmJ5MTyxXXrim8OfwatVwvVfcs3rY95rc4z7WUOyiPxn9KKa1FW1hzSXJi8swZm75+ZVvkAXFPrN5bWjgvmTF32R8tzttb4Yjzk8c/vE5x+9aDbiVT5WwT1+wvpe9hcv52AQ44Z2LO9K5quy536vnIsiY75f6AkfM5vTaWt1q6ZV3UhcYHavf03O4FzO9bxNuoRjL7ENuZllTa2KueG953e3ZZj1tfam53xyefVY1P91URdeMQO7qoeesJTTZyjzb8ryAefum9MV5WtfWMt6Ub7m/Izf983tR4+YwUy5Jpo/97YarqXNaYbmhTruu81p/Sm+w+Va7Hk9+8vyxbyzvt3zT70U1/NAc9SJ6yTXy1/n2J5oZQvbqqPkZrC35apjafXOWFJ4bFjUv5+/1vX8VSl2Z3xxnnGpL3RVvqOkBl5oa6xw49a0c/HVWT/zjD90zRxxyovp6TOU6cDB5uX3zfvQ5zBExX7KtXqK1/21q+KW99j/8/aqF7mmvPKV6FlPMfRFa9q+lq9mO3fNqPK2mOxSDuZ1s78L4mih9+65m5QD72xcWlT36I6IIwpzFnPXeJvOyfiqXsAnVTYT8xW4wHN+7EtkSoydaS/6F/u0aw955Gn3Kr/MZrjU8etxXefzg6U1oLfs8ZRqbk/vZLcJk6MqOY62aTedBTxFLdFHD2wcVR4HbB57MZ+ZuCLeHquHWaBzXwmCw+dj9yJ9RjVDVnuka1n080pN5zTfFnG95Z4vup7X56P318A7DvP8durr8x7AiNWkuX1+L/msevUbxzp+MIbqjZxsnxsj7RyzGoITxa6KWzpvg8+Jk07xdg7OTGjH2xTnCr6WtdsGbi5aYfZp6kuoShVytVAV48Zra5FXYz50ZywZmOP6WFvmn2OVy+ey82FVRbXdq7tTPXxsSnN3LO3XIZGOfMK3YOP/Vfnfq+cqeIX5fW5Da1pYWJs/PO8fn1P7ikPeGIcYC6f9Usx7Kh90/neOuUXOGnaOzwknPzNwOa+dc8hrF2Q+eHtJvurToP6fA05nq7JSW3XwRU8d1PEFXgsnHLy8ehxIa/i/3ljaPZr1im0Fq9/Tp2UxjhfL5ViUN3NZX4zFiuKQnm2FzEfNepLIz0ncms/ikTZqoEbijt+id3/jGG/aW9Nc95etq8LPG/VbegJq68T7yHjMlDzmqTGzrR7F6p7QfROmvNwWvCXmkSeOwvSgbW77V+jqa/Tp3xTjROyd3pKf8hVxMzK7H1JnyXTKp+AxxaUbR+dreZ/Qt0J4EOJnqscj069mOktxwF2R5vCpt8IeSF1XEH8AR8mfm8Vd8A8VxFRy1VfEpU35p5vVB2KsUQdauDUtKsZZv9nPWbqCHrnNT/JzFDF5FUcJ/G9lu/aAg4V95fomyyOlfvr784xfUYcr8i/ETeo3s2cnPVkmezweojik6rb1Xdl7fOGlzuTzmf/1RntmLGBnkI9kvP9shoeq8Nke8fBgtgftH+XNpP/QjI9aZfUo5LnvDbHzKbmQN9XNzuX3n3BukcPlOZQX5rLE9Qi5yn0vOc4T5HyXk3/icHMV44bwnbGeyuTHY9bf2D+W8vW8NMeX1SgO3zewrW7AecVTPYf4JLNF+3kM+XzETeCamEsTrZzam9bsAnbndb6sbeoTXqcJXfl67NN71/uQ03ZMP+E2+4X6nMeDaT9Ha7t2hSXk+cjG0n5VgY95/5k+//I4CPe4tSvX+riuCd988xo+TzpvD8NNwK/Bz+L7c9VT/PTG3AXlbTCTpW3s6N572UxzC9/Upk95ik7a56HIOzvxKM+v1ZDP91ap3iF9lXjv0af/nrnIN9cDUls0xJq3jvtvXlXr+cz8+YLZAO1T46j36sn34VvWuud6Zz6DzwP+97NvaQnrU7mylnPbunjuuW0p738rqK+WyYJrRquRWWXycNtYdRvX5gvYGv8KtVUWa7+t3vaZWH5XEdeeLO5QV3CoJiwvPpqL6SyepbJduzXJLJb/Xwfr5pjw21Fz/qqT/OJ1kvxefURP4aee19QvLMV5/arz3qe95Kum+MuflZ0X/wF596m/9uJl7Cpi7a22bI+XeBN27WfkFyre1Ih+UfsJfzR99l0JX0pBHelN/u/+fr8CbreSy3+9DZ8Vue1edG0/K9Mdf1Z8+7v53LYgrvb115/HxW7TbK3hN1UJK35bemLnFrwpjeBm1hyqSjUElxo42NyaUbFjsQqs5UDWh8OmRDbfIcwzcb+hdlhza9oPJ96u/aTuudF2xXj2tci3eqRHwYlA/W1shuzYMcM5rkm5RVmujszej34srke1bjCYDJeeIu585HePeBHUZhhm32v3Km6tsXQEecPz6n8/tieBPjVWdo2dNy2RArum33RiJ/KV3swGL4yMMyyBZ4bzebJ6iBcbK8LDKvLUNqMV6h/sPnh2MemAu8Bq5D4HbgY9emz3/6Mq0n8eCVfTSxxL33UmdelhOAyerGqAdfAEceEDF67okS0Aw2pMVGX/ebsJvlmf6gSqAn4b4n2oeLE8d/HZJmoSkYBn7ggUK41ts/ejI2znbrxYuor4bJubYIR1ayOvDp5KeeELxH83ccw6OCLwnKGrbNd+VZy5tV7FExoLte3PHPMGtSBwgYOrAlw9B1g4XAt21SWs7uQj67/sOoW2wUhOdMzrOUfofSwhXHu1F9fQJFpDwZiobT30Yj/ymxKtJ8NCdYkbUlX2eAuWd6Zca+i2fcxKXqKOgbl3fowYpaoNm7RP9TviHq5u/PaE5pOiTmKR/zoJvLYxdgmnSc/tqc8L2jdViSqs52C7toUFziTjGKH79jaO2Zs7cfSstuT+wCqvmRzkgeSl/zv2OdmxOHl8KU9aLNfonCLXSHVPXKMxG8B2x60l2SoFM7CNCfbnwTIqvikvgDN3rPDZRS4aPJQcb26zOmlQWgt9z37Gz+FvQR0zsmt65MjQzXLFfznv7rMtGBusodoKh4bcAI9u6LcN0nfYl85YksEB8ji4HYdzNUD9X73Vbh65XrKFXuS19ci5XdDfwK1DMyfN7Q6YRduMFqgTEE8++QelNZ4D/8isVj63Zn1V/eg0h9p9sM98/jIu7iX1cPQnvRRbQN9RsnrNziGs+Hb+SPZO3sH+eG3MkO/x+qF407H8mp9U6X4dy0hcxVjZAmJsPVCbYZoTD47O4FX7+ka/98+uDytG6Lyilj9M/cWmNHNMeYKeyPtEyvaJfI/WfO7G87BjHfha5Lu5plyHruUzYp+dgRQ81siOPXuxUfGSuq22q6LdvG6PH2uXz+4FPOUvsyeuaVRGivjSWeaqIet99B/6Srh2mo2ZXjGGnar097DaXw9l+n/JaPXUTkWXH1rGUB+A3zy1QTqri8v0+et8g6bWf6j2hh+AP0Ouj3jCrJq+tmq9yK5pZ3sIC3E4NSnFuS6A1UXPGHFPKmk9OOOevhtWxHuy/TUJPnekKloIHwr61k3AVwnONdIDmYy+g13/yHxkP11DQxEfWIzxO3Ja8L1/KV4gOt0v1sdgZPgPFo8N0z0mf8FuL/+DXih+z9XDRO7pA0l8Mhs52zMMPKG39pThH+1D+9QvKVZ91AjN3kvjo0GWI2CcrGvf6lMPNPYDOTkvacy6j3eNya6VdJsFuui2u7nujDV23eaHcLV9QP/Bp+InZn5b34BTk8c0b+Nts7TFq2VANgYPzdJY6m24sXefs6tVkfvAfyNLq2FOkD7cDtW2NPcUYzEy6xHzY08w8YhlIq/J819mfTEylxG3MWnvk9apfOdxCes/ZrFKxHI+zdk/4DS/G88QU0Z2zag4Zh+zSAK7jdyT9JT+3q1pgXp/14ia0txnsdEEPV3ou6LvwA8bSAHlSKuI/7vf7ify3Jv64aOJnA/l5ih28jneHPaCZE7hnxtI4OgMPMxYaDZmmS5N9Sd774XakudeHK6p31rpJY6pR9TvCRwZeDYVNkfTjuXnEXG7bdBbsHIUscZnqOA+S6ZXkVPBfAjMe7wJhoIRqYr04CvGZoDv3M6+9c0oQV7L5mvdx4wIxdjw2ZILxyI+1bUbbzHjZWULwzSPl+2hVusGjlmfdEwx7pjbtW320eMG/POM1k4Ql8AeQkY7TWlHfoDirFneh/KS+z0yRPCqBWo7yw+GyCfaA45zp/5YikfpX8LCI3/Y1mc052IgzWxzG3dMXJ/85LUbDz8yx7YZWVLkYl8+AcfgKdHGMZGnfOmscarn7TxFfnYG1cQxoTMof7yx0Xu1z6kFnTiV2Xrdpb3InVfKf3VXH+CrUh+1b2nPL59BRP0dc1tA3q5XtYkng3MgQEZqUmQnwKvSWat6cS+CzWQyZOzuGE4a52altsTlyNLp3BOPAc8delNjleVChHBNsrffi+v8lzf29Z/Pmbwufv4p/tCn9o+lsvwpczh+SR6wT13vyFiNhPraF27epybXL+G4P8udT3j7cY7DP7cHl9ZMe7bN3qx4vV7DHXtN31QvtIUwug4HctnfLctPH59Pq3+O0x89cYU2prgnhdtv1pdD34WejNwx98lQ20EeALlHNvtvDh44fM5mM6tCVZE3Hmp3qc7kfVW20luMTGPlK40iO36Qv1Jj/tmCc4f8RWn/26twlvLGk4nrsoc+yKL9O8ZelNebG2PeJ/Dtyvk+hhtHW8zS470+KT9+lK511nPK7HqurnwT6DxGu4d/3obPhP4OIxmZXdQCJmqb1WXJj6RaK/EALZg/qTHfNq3PDMhPxBy3835WYeyRW6P26ayNg/PxnvM1plLoK8FrdUTkxuQ7FOcWD/NWsU31lHP+535e2Tn5YLFDoXy8wxqX8O1fyvuexe/v5wQc6jGN+ZyvnV+Syy+crP35XB7npNVTvriftN4n3FKH9yjuLSJurTz3FsdpMGwu5hQ1WYxEMptydeH3U8wB0ubwY+lsH84TOjgzb51ZU8SXdeC3XMKaxWfW5cyssz2v6E2qD8GXFL+Zi/TFs3D8hHQpzY3X62X6oXR/j/YLsq4qfuLWjA3duxnWHVNOOk1p6Qr1yqi5obmMnaYU+Up3VTQb82zf92vsXpX2qH3IIXddH+JlzGBJDHPKd/7C83Z2X0q4AyLI0TFX3pp9pr5Lz98Jz944dw4PdOWFnGQZ7m0aRfZJbVvb+qacEIZ9fORHmOIKtu3o8zXHNH4cfxayc/y7kSJWT3qRkKedGqe9GqgrAIuX8zdTv5L8zXbl7qn/3//91//7X389L2bT/73wwsd4tPi/3mz6NA7+D37313/9z1/+X//1F9sPdeIJvRl4zpg8AFfX+NZJxH88QVx1rN7zSDGW9qC+9mJv7bS10Jn2l91bb519L8VuTIG52kZ83tDaRf/i/m9ldq1Mx+X46/P7yjkw2qzPhuu6MzZMo9nXlqBBHp9P7EthfiP9LHxpGfWXyE+YP+fjnFLft5iMEonNVMwwaLLAcpCwFS3go9Y+eErgtyjpNU/9bZbD7FW9KeI9HTU/rPnzSDCQ46uCswdnAvOc79rGLsXu8Fl1qe8T2FPMzuvN7sC3oRgrmufbBI6hv1KbjAOPz3Nif2+JN48DwjkI9E40o1EKVXmD8wn+jzrOmC9vxvvnl8aoh7ixUVPbyHGh9h2ufapLOvRzeh13LHnHnFNWU82eU22GUSf2iMPPm4LPj2MyFT0Cfwjlevk18/fj10ctfu7GjXkn2q4spS4/YnYe5E9JZQ/5tM031EQ9wXhK73s/lpbASBbrimNdUIJPOtabBXPrbNRi8C6RGDoCxUhHslcyE+DERpyPafvpfSZsFlkf+iGOztrNsz0zJ/Hs+fl8B+e0PGYowGGX4o4uxIHwp2Q61zmflj9jLoaPc3W5o+cqs9Ev9G9baSzsHfmj1+etTu1vPgdz+k5hZJvbykgWmY5IrvFlpcgbV0l/eTXg0IYB8DNuGxxg0OG9Hx5qHOSrhmsfHLNTnecSDOBdqu74JtAJ70l16Cy+5debeomUXdMSDOBpUFPAM058zNyBLuT46rvx3HBZzhhc0YzTNrb/uRvfjgOtX/BsUkhcQjWp0jGjVWcsWR7tAWJiehb0hD6PEqolUc44/SxqXU6T18gFecIxO5P9viEX3djCr/ME5D6O1ncHjE41YLhmY+XWjCnsAuruvqWxWN+sBK5wA3xyFqdmcajZQJ1+hzl5sAl2zDCuxOEAfmAljNwBw0MD1+GMs7oR8EkLXwmfEIvbwuLb/TTDYj85Zp2w6c5xjuaddMqA70Gf7r28ZVxI3viV/einOIucf2mdzqE85Ok44aA+h3+8gE0o5V28sB5HfCTn/F/X7G2u8Xf3OJ9N8DDs9TO7VTPS+/B4hHIFjC/ioKYihSS/ggjcqOaMpZUL3AjqL0KE3gDU/0LULNn8M33Hz8NBX0J6vlgfIuUKwRG4X+MPkK8Hs7f5bDvF+EG2n2SjOMfZOfs0lRLHgG/gJ47pl8v6afzd9+Lh0jb9qRcb01RWbL6evpXy26DuzXz0TlPKzZ5K69kU50IeWK7SUo94H8vy76dn/Xz8KiWOKU+dShYTfI6tpNyHnuK+uQ8dnua4zsUACrN3ttVn2NB27pq3s5zP3yK+J+K6U+hfxKWohWc8RPC/Ux+UMMFCBG4yOosd4NxMmeP8KN6I8bNPvTCZ740cfgW4VYYB9JMR50BMZwy77SJs5DI7y1kcJFcOYgmrqZFPbDXVeRrPAM8B39znWAXdCkPCKAxSbjxv9WhWF/djCfnbCu7vmPpT7h2/qc0K89PHjSViFcyFdWuN4hzYYY2npP56bEsOc5ml9dWzeaWis6lFpHMtfe3F0ZUyY9wgP0A9R+3j7zdmjqKhRynlK1qwvGArSPXSPqfEuIJ8S4tts8d5zsnP0fTWELGO506MG5s4AobZue9Mo6ULmYwN6PG5r4iUE7mntac83DdV0cd+s5rG0AwfczsLOuObtWtNlvSM1h6D2Bkw7rz7sUScNq65CRwhqlg1I8G9Rm294rW7yBdMwfHomyrw78uOID+75nDtEo9PddGxsB7fg+tisMK9L9/b8z76wLGktSdEwB3Vz+855ZS+YZ71NfZ7MJTv+wOWj3qMxZUzaMycQX3aGUtB36xGXhw92wOx69Z6T33MeDC3kSc05jyPlfLY0/nNz45nsxy6wZ28GT9Sb6ORIG9kNdUFYnNXkYFfp/wSnVfWrzVlXChdjp24CQxWD6wyX3uTXRf1JVfYCjxnaxit7kpttQLkTzomu46qNFbcZ5jbCcelKLl3fZgHqnIwA5pjwXiOjvIm7FpHNqWkJ6isFn563tN9w7/cZ7yEgc/XhMZHvkhensZ9S9qAO9+OjaFtaVPH6l9jj/92U65Twq9JG47VrbpjHlex8wu9WfFicaG2U86ZDAsTjKw+nxdy8441AtR4X1sboO9eWxOwcvHgMi/PKQbPRr253V17gkzzF7BOpLMUnAn4uRrzQ5kdZZydzTAo+nwBvvYibua43nRxnm/xHHX0zSausAnY3HQjJ/OQf6zZBr50aNcolwcffY5cH/xdH3OikfcTxCr427yasfGUbZ3HkSu1JY89yhWxHjKW48M1fdSEa+44H7sCixjOkRekOr8QgtuUxbpsrfncBwOxOPTFBrxzWEuyIVEmgz/Y3/AMUaLKkQQ+Pbae2DfGZXg/blTtJvCK1Jcb7jkKJwtV0SJbkKs8xxhyXGeN64HV0TvcpufAS6gWPkEPqMdnyxfO1rhy1vDLZmAc1DEO/N6z11Gwbr3oxH5MsOY9cJOPnWHm617hN1DOhe0b6Q7YX/I157aw3O3XBvpIR5/hA+OzlcaI/dT2JjBrvJe33fOxRyNF3jhM9lxb3s9I4bqNx/M+9EE6oyjInwe7KW3AYcqeB/EEYYCh15GvndnEmyOFdk1bezVgGDBvgfelmBXWi9/Wa8Ceem0JWED0jVM/C+Y4cX24Y+9xeqZ4TjewFalum9WFeiDPw2IsFNejjuUwDnCGVQYuEX5n8jho7HVIkz3XfSkPMv5jtjSbyZT68Ja08RL4VPLGu53xn8WdDfue1EOv3SC/GDo+42LZkV82xZ7fj6Wql9C8tQr8Y3wfuBA8T0eIVj7qUoqYPA5y11KkwG6+LjYr5FE41A/fnVheeIKR4rIP1pHWrClBx63gG13QvSSTyOu9KK4vOhdxukeSq7YXfJ1ux8GdDV0OGYtVuXrwzK5Qh4yxHGDOHl/SKaVYz/NzOq7AK7GzbChy4qDXPTiL+T+XE2v6ZrQARqjP/LIsJ3eFf3JbwmXOdA7qB+3+Ej0uWc0CPM81ae4q4t6PO6qz3I+l4KTGcTsLHhOJxRe3M8SVz64iY47gEvVEF/1nD/1lL9qM1XY1eF1uqfAdaX38ZhU+be7Z9zk1whgz+eDzL1pHnLGvtjtXzDg6zge9DWN6kS/3St6ra7Ggp7YuV4N5IU4MOuSq2su78bi9Ky8T5dGIt+It80Y/h/cge1bv2ll47aV4uefvwvyy185quZqv4Mr5SS/A0pfNM7h6PnFbq1s1repG4oK4gv69c0N/OFb0VI7l+03nL8bL6NEQCUdp1ZzQG3/Nlnxlb+d4ZPovnSn54T0ir8HsXcW3fa2NOrYtLznX0+s5HwirYZ2da/yy2XNlffJX8rJfxidesDWX+cyL8edX9GpdxcWVx1f/EraoZO8v4Fh8s/fjQZF/5PIWl/tZBj/dF9t1q+gf1BK3pr6wh5H6becuct5U79CrtkBcdTTfZoR+5GwGlMfjBvDvHfDNcVwJxTXPiNlR97FNPcPIIE9C+E6B5fXtAccMyl3kdVbou7YpLuGzSogDDfUjklf0f6R9osRbRTUE9P8C+4GapCDn8HMt5BWTUa23obpR2wevW6S28G7LVn+c9v1sGY7nqFeF42kSh2ZIZ/x7wQPy/YRjuUFvUA5bt01j751jDgNTkEiOdEV76Faqc2+KGeKSX86FUBLvXcnjcQEjRu9sR93dgxklHnAUvyEP+KfydLeBOdXHvxBH9yv6/z7Gdni1Hs7I5KPssqfIO68GfGv/3OdeMDusVPau41D7PJ9nY1u9HfSWI4sCcPcfZ6MP7/NvW+eUg9US9rHMh8lzyg1qiNfEg7+Zz3n9OthTbe3XesiPUu0cnMSMF6x7Sf4OMI7dB3VTmgt5GV/QK3IB1866uWBP015vQ5yMXnD+zHIf4LrZgZfi5DKb/EJf/LJPe3n2km32noHJK5Y9LYfhO8N9Usw/jD4PVlMv/LuP+tzMrRm49nvxFD/bqHOfm8f6hvkM+76D4cddH7HyBQ63XO/xf0pk/yX6/EIN+xp+1rOcbFfyvX6ePsZcZJo3Ov0d1vk8rnnI8bYPqU/7ppl1GnhvrpDtn50/THsE35Tz/pQZsJ8706W3cmt+7CKvMnhTHafqCYQrXX7QPKh8nuJja4qfNcOQXeed7FhprfOjuJs/Zx7yvm/vCdifP+ndaJbEH1V/opkJf9w+7fMef+K7FfC7/NZ1QuJy+eP26XN9AgnneEocT2/aC8Rz6rX+8u8wo4N8nN+6tv7efL6TPTft/VjqY0aPA07kpFpDvo/qVjV9bRMGOB+/8/4L4g6Vf6Q90Try+xW9qco9/aEpTTA3FzEKx/UBI7jCz2zmD+HE01lV6B0KPMWn+6JGZJv1HdNvhDEOhjTzimZABR3OEUHczdT7xPpL/Ro4dqivHBg9VitqqYFXA0eEfJPWktxECvR9bP/tPgYf7xa+4OzOJI5a6r3Gfa2mNsF1HEXz1LjB+mUPOH3z/d+5Op2yDR9NzMEKQy/Wn4FX9DIu9f0ZvR9/XwNPjb5B4gvC9Q/e/wMxgx+AW+O5oz/IL9r75n8cLod8vv6fpONpztifh5/a1wf/wHdbe9M/SgZpzvEXhu9NGD7MFyiuFbzC5/ujYgmLan3n68u/9pl5C9aycN7kXlbSvov8nIXtDjNb3Rg9JmxehFsL652xNCz12Q5mkpKNBF4Kego99ZzXd0O8x17Wf5vDcHCeMc67hpmikTf2ab5b9qyGSLLpCfA3xZraXAS2IiZOVczNPZXwDgnm/YG3yFPEjW+y2SCqotU5tgp9dEv2LMSTIIws4sBkvA3ED9yYDQWjQrMmat3gZjYa5H1YmtkYf0dfbOQq4HCpR1g/mrWQ8T2zXjN3ijmpBvqys/mC6A1NOWMwM5bwZwq43/DOe//pQl/Xr5OP/Vm6zhCXtllHn9Pkp8WEjMsLXIzBQ2WLmca5uPCN5+ujzlU7PwuD9TW7NW2q3t8pk7EUuMK24sngD6mH4Ciym4hnPM5zkeEQU76ELE67G8/BmQKOROrPxN64bcz4nf0DvjFXGdJ8YGBe0P+Z9uCjV9WxVOIsc0wnppjXciKrhu9kPZBVN97OaZa0sj+LlpCupY44F1wv4GXBPoUu41fAjGbii8nVpzHbeMHnqjz7Vq/iClWuc7bUI29PDfA7EbbTi41nrKe3W7CYWWEzRhF/8v41zjspVe14O/eEkGNV9YhmTFMvaSNwslnSNzRbA/Na0vkz+RkjdwP0v0FnqDkOSMoRQF8tvXZ/pbbq62w25m7Ge0MZ37nDeNd2LnircDa4HEDOaFbNfh0+fvby7zjDIZcT3MtX/1NmrH/V277qbV/1tq9621e97ave9mfW27TIafdmI9OpfNXbvuptXzWarxrNV43mq0bzVaP5qtH84TWa5aPV276Hj/BVn/lj6jO/ZK7tqj6e30+H7X0547eWt6J3i0fmtuJY2u5a3fBYqywuzlEt9cPT3rizHL+lPZjnuel578owOw+v7+XlvtMfl9eT/zj5vb4X/Pd7twSzTf+ovB7vqfvisPtYDjsvwyD0njzozDi6+co7vjLvSHOxez/Snro3+6x/VBxEvei/dV77V6i5Zv3psjh3SvgCUKd3FdJdT74i/nDMOlv3ov2NiY8K8zlKOAI+hkfVEqLJCzmOrs078nkzEvFvuMIyci/Ffm/gC8CcN1/BjKGP4SP4XP2F+WDffy8MwiX5/srVX9/Lb31xXnwo58VUX48EY3Upx/mGnv5P5Y5zTRGzQhPikEveJ5eVm+WXn3twribHMYqvnXdDM7KK5P7ybJn+mblSk/I5tBdn+5w/C5dyZ+d9o7P7XqxLrJJ5BU+n8wpOuSDH18xCKeHlJL7M9Do00yNUm7N/MPfVNjdLNjNo9k+O6/KAe/NOwdw1YDQbQQf9hfi82WD8/1Z33hlLfeDvaPYVrstwlnN3nPUOLj3M9QOGls9buxvPFjSrD9hSmsF1OBfPvp1hJk90co1BNm8x8C3MVZMnNE/nACdLs3JWHVOfe8Ji37vJZ8Zhbvhw111gNgxxjiKX0e7mOUT5nIcwQu8lzbY94hBFbp/mM2FenIJZZQzHns0UUmRgzdf8uQhLbgviJsW7M+5RjfhL+SxyNs+u5gDrzmbDKQ7wvEdzCwmHG9rTXuRO+wHfQz4n6iYYWMC4V9lzEybZgE8VuKYRYmau1dT4rCX818q4UL3YCB15M75PsKa90G021moraukDmj+JNQa3a3SIU3Yga7tHC89X4TOQ0z3tYR5oHWuc9sjC/2Bz1uRF1tdKPbLS2qH5RjkfmmGQgzuSXek5/11L6M0w/85uThjHK2a1c7w+3hfz6oBJpnds9zC7DhjfmYO+35J5asU5jfP60p7SnPlK2TzFS/rHtvQKON2IU3Bw9ayww/P3MON7kXLGAkPcWKV8pHZTSnVjMBKMOjDOflsPbYZ7zmPAz88F+xgdeDQXXoP+KeHXLptb0vsB+c2fIV+Qd4frgR7p79Bjf5ty9NSviL1hK+rqhth8aIlNq9rdWRXN6FeWsvFO89Ecsz7xFBF8gk++pS1eMCOt6tV04MgjN9Y3LmYaNRuzBzNaDYbfoX+ZLpZ7kJ0fdw+LVE/uHKufch8vvZpep/mWpg7OrZ0nZFhz1CUnP32vgS0T+D5e2QtlVLvZHKj8DJ7hjvQxdETl57+XzmZWJdef5wfS4ZgRiTk3mDOKeZgS5+Ym3cW5p6FvhzRrUm2z+6jNED7MfubfbSXwhG3V4TOss+/U9MhFr4IpV2yB6crMdmBNLawDs3t3g58x72nPOW0omKN2EmuKL/AZT651NOfpTXofPAZYx6N4aUz69eh3/vG7HPrjF2q8WuzWtKVtFeJTimeToadoKlcdSw8w285Wejs/bpzvHSnMDR3nUeBzTV7n3w+K1+QDYgXse9c2l1E2H/1Xn6/EZqOU5SDB0Z/2TD69b5+IsXLa0hrctTSPuPnr8w/ifH1YvvOsPSrIRwHfw+cQdh5a44s1sxc/T3fHuI415Kg/NR+RxmhvzIWxZz/fU3CivwzGmcO/K0Hn0DxwJ8YMuvpz2odpD+hvubmbfGYhxWkizavDzIUh9wseTJlmMnvjm2Bg3gTmUO49NDeBV5MiW4jidO5h6keoCnzybH539vv7sSQZ1d7TcNd7GlaM2+HEGNqlddB8rq8x1mXjdlDZSoOKcfD9cszGdlE6V+fcvJIruFbT9XDkbJ8+YgZD1Yu3T9wXvTInSn024DtfvHsNgDDUvZ17dZ8Lm1V7uR6urYEbsM2b8S+KOftAO8Ji8Wtrkeq0t3N3yzTXM/7V8SCO6XPddJ3s+lZ36ZiYMV/Zlp3rN+Sli/bxs2ry+b74J1sIw1GRvL+mxtUvyZ+cnc1OfRFPhboircMYIouJXpufEZAf3q6dqlg+o6qQZ4D3ylt66CridD+P6H3t2JGtFGxzW8X3kLfFfHQbvfEDaZPjOHg+5KlLz5BkDCebwFWiH8gnHXO4EYbieU64rz6fsUTYtttZtXfbTTpCD3uxcAX/yVG0oMAPPtQBEx25lm5/uJStSk8yWnL3oeI/DVvycFA4X+6MHSyR/fOxZsZD8MDOUv+y3pYr52Ijis+tGpuT9h4xUorbsoSPqquEmLUVeXyO/XGcVOSbDRQjdCj3wL/TZlwNlMtWtEhVjDmfdR6qio5687OPmffs2TIeBcesCyNLW7txlXLYedmHz4I8LXLAnbFkeALL37HciLHIzyS2+X6qbX3N+Bp7cwdnqmbg7CzVVjg05EYw4s99NMe6dG7hdXm67P1myKFSPYLmrw/P5k4KfZZX8Vvy/Rtn555z0xgrP44SV6gvqR6Tm6P+gfwRkTt1GHbgvXDtZl24ooflREb1M7LF9Sp0YMWmeSw0sw26+vIeviSe6796TrnqmPLCV8LbkYKaVTZP8HANLuUeLtZqjRXlDM3r80oGyzHH4MQhHhuyPcc1N8jktjLinJ9O20BeEnw0xKPkKNGO3zetFa3Bt4QcJP3drGO2adUxwZmSq/vS+dYT3xwGd1N/TrWeMdX8kpGlVzBT0I5hlxb/cP6ZmW05jCNKoFxqxeW8N35bW/ssX4o6aM2jOY71qaqQDGDt4dtEtrD4Zjc3waMpVlFPs+ks0XNUvfgmGFmYO3jDeHYifcbeL40dpJ1tRbt8Xco2tTV4XW1ev/RqUoi6nI9aVbPxz11cX9+NZ4GdrqEsPpMM7OaBqmioyf24H3NuWpYfRi5/7cQ25g3uRonk2nsOoifwAeHMO4rkq20t5HoZ3+d1R/R1470pjx74Zr3mxfLGEsTkrnmzAlcsuG+gr+2WyPLVz9ti+dzVA5WeqwVbsHCb0m5k6YWcWIdYY9rTc7WWsSuIC8eUV+f0JbB3Pvy4WH5BncUgvclsyA2ee0J+2YA4eUNVCauuKa98JYLOmPgW1hD5ocbMGdSnnTH4c9VdV6mCO3ehKpKnPmszq6kF4BzrmxqrhxNPU2OL2uxDzah0TDHuWFroxn6kEm+UsfIUOfEEg+loblvJV1PkpdcUceYWqqKFtrCg2nXKK+zEw7zMwR7OSIcpxGMUsfoXdBSvOQ+kpW1uKafMavHZO4NjrZLVbtt+5Ch+lM7OzM6ypZ7NIxfhys7irgpzgoex2alfVAX25wm8Ti+oE0rgckK9HnW5jqWvO6YBbmPYojG4mrMZoqc4ghpxQkGXxvKz3+7Cj6+645Q/zpgDU+ELmGu6XfsCq307Cqu7A9c4MvV0LSOSUeL96qYcXcCOr/wm4/YyBenBNcUfjqFHXu3/Z+/buhTFtqz/S71+fREMs9IzRj8IIYihZqohtzeBSDAEtcor9uj//o259gbRwLthZp30ocepjlQE9t7rOtecnWeeJ4PHObGHvpn0fGutGXCZGvR/im30eCaOuvTdkT534yV4schWgN+LfX4SutHXGfFtDaQMfxlqQi1fqwEzUg8bjEd6QfYfHHhGCfaT20ffZ/ZxtmZnns77wCN7Z0P/1Ec+guf31DBwZCF8A1/WaIi9WkhyD3CowSaDi5pwGGo5sgfECYi4avoGH0P8XeCUZs9pFuk5seZ+at+ex74dKVPgVH4YuX2OC3Qwj+kU0R7s2War0N5bKz1DX/gEPdQP+sH7sETZ83JkDoO/t5cdmzroplhcvZdTdz5Qt0Xe2JowO4ZnAvcaMCupTYPffukVyt80JdE9koaO2BIcQ597NX4mwlZodyWnG7a+vw6kV8YfXvVb8lPceK/OtWoGJ1JlPf9XYCGMlfeiBgWvJrG8VS0vnFpz3jf0gj0ogfdv0a91Zo5cHrqREnmyMEYc4kZ60Y2Fv1yxPG+YyX0Vls1Ba53u19f2vDl4Wu30Ro/VWPbNGifrvIt/SOuIO/nlHgxoHRib4G1Xzw521ahj7mG3LpJfM2P+c2Rn9UOTfHd7XxRsw+N519O5PdWFE+k55/DzMM2WKU24Xifh1vNqwnzGVHCjZe6/e2p52Tda6ztgogNXDX9Qj+vzcK3YLwtPKBf6FCsGC0ft/ABH65H5sA/nvQdeV7W18FhcPEatiHgaZSlCnu8WEafzGBNxcxUYY3wn0c6sjBnuUGK1NdxPUYIfCl+6Ut0eSMgF4rcucVeivurbZvBuG/qQcViG6+3fXabaBhyXxmuDu/i5+sID9gznxmz6nSR+eoZOaGXZJP5Mb72XOyAbvz5Xl83nytE+RZ+dm4/n8YCe6L7fP64jmt/7yO7zT5mvSM7JKT3Kw3jzAXIH55q55EJ55kRhzylKEyu+aib5vjhwUZj3uz+Na7rpiGXC1fa37XyK2d3kQPDRqzlmDbwoBAZ4O5YkLFqH8mo3ZvbA6krZ6yezPsDgzi3glRgX6ve2qePMvu9iRZ0owfitJoh1Ea/bZrB0UCMnrZWv7P8vfi4X8zF/YYmrCe4bOAVux/P21bujhoh1fyR95QOfRfw8dah+f0C39kZ1t5PsRG4+zbh6db3ezGLzXtUyYuV4C9srB2EjcucNWRp7tc7SXY8XjWK48Ext7vDPN6LWwnkdr769DkvfusPb4ytoxlSf0/zfCXPsOfWD/XVW1KhHnQA5A/In2rfV1QI5jDuQ+Nq3/W6v/ZnPtekTHpsV/WgLFGdkT9yoPKe4HL0lsz7hOMO8+ml6tpP9v+lL3b6Pnzn3Z67ZcduRwbejvpZns46v2af7N76XhvqTq64WbpQ/I/3jl5ztTs7BT/NzPUdEf15qvwpN3xN18HQs+shNof1e3PZxLK/1QisKFo44JX5x2wiJ75t6X4r0vSe0/YaoLPvdctE26mPsGTfGzCx+pwy+WOgz/zf6zZQXweY8F+aNQcmn3FgN0T9k+THsnkG+cGmZYTLfwrjpeT2O9yy3emW2LA3eutLmeYTt82/JlXG3KkjtWHjtVqtx69VKZk0GjtgpQaOBap0mcOXC8hgG+Ba8j7l7cc/938q/IV/wVEVwIwU2cuQZ4fD83CdzDVmq6b2wuslJsvVDqtEHntkZO8X65A1xBfUQMHOks3okZsxHmNmBz3zyO4aw9GpD9OLXnlwpayp04PUltOJQ23tRO6E3IBss2kZpwuq3w/kJWJP8WsE5fBqnznfWfklON34er8IDpec7g828bewgf/XBrdMvtpaW0criOxiWJS+2UDoL4FC37JQYjhyG7UjsxfxKPNJn2WEJc8tvZmdiFZt+W5fqbF5HHyXzCLynl9GtQN+pNXHUkNtqaFa0Fp5Zf7e7zG53cH6QWxTbiS6Dr6vlwC126lt2Pqr4L+l7m61fWG0d5/Ydcw5kS7j2RV5OYovQrfCCBD+aXbuGkfRDK3+9hDRnOLfEcNo3+JzFYIyeKPbAels38mvSR+PvCH0IZf1mlN61KvA/q5Knhu9uLLVsE+eitdaqSruLvlNXYhoYYum9b6zCxiicYW6T9zR9C3uixn4DPUzSNGF9cbFvVH1r591/w+xAdRbamCslPZw2sLBLi3LBnu+oekCaJ+wdpefjwxrKwUb/heo2ZcEW/UzPZTVsGBzjUVWWbq3p673hBP0xTy0LbF7tH6MXSbW8LU6F8+JvM9Mjnm0wyYQFYnooLF8OgOFCnm7FUnqeetWhb0U6NE0xJ0Sz8g2ZzX1B0wX9cpaTlCWPad6wnEGWlpYRxmw2tLTw5GQm1xOw9xsD7RfnE+b6EPvm7U6wRXh3mTPNdDQUvfsqb/q+NJtba35pxKibCoGrDrFHYVsKlqHNMatssd7isCF/+PwaPQcrKj81DMSMJeaXMM81KGHG1ifN2KgzcIo+ZqulZNb3afzWJUyyuvStSHnvxxtcg1UtW4Ze7r0WlFddKcttvaWYgt59VSuEtyIfM2C4jWSmGvGoLUsj0viBro2aYlmP+4qfPAuSU2c5b84ga6fNXR9LdfGP/vXjeZnY8pPfI40jOlsT6o+q+Tm4xWvjyb03jF2tKUXwVP9PTc30hEsa9enQY8W8J8WPqvTBvljyk/+ipLkE1e2Ydtls4tYk6pMCR2qhR2202exw4rMY5gkxpwj/00/sw3Ysu8k7ih3knFNuI9K9ZIn62o3Rw7XmL91f3VbcpE5yqp2md8Tij7b/WqB1zqmVEM43JC4EXh/sG8neefrVsfJ3rZVze/uD65YVKAb6aVrj5aVtlEwbcZ2qx6+GsqRYnONxiGekm19f6KnlInHB8vjJKdantizMoEfmyIin2DU12C5+zt6YXttQU1uCO0LNpT3zRD3BeIFXgHTVNvPjT34P/A7QUFOVZV9HTStMbRLTQ8s76531p9bST+jP3nZWZfvZP2eO8K45LZ55nq59JATuz9MqlVE70hleLnLEcqFhQuvdjvpGc7enxHEeEuGlEk1C5E6O2p6RbzKW0ItfeLKAufTIjsJ3rkcfW0YncAeZ/V2DbiAwjZ114hvTPjp07Vn+t4W7TGz1Dib8xrO9O/vt3wNDcN9ZVNTaYPuM3l349HJjRaM06URD5OQz26wHu7kt57dpO0UPdd78nBaanoYeYx7HjaAfWxkn1+2JYcHuSi2eH8eIw70ofOfcSl3Ov+Nv28u6n/Yq8upFwCmmHCibGGTjJ8pHzmgp4eMhjiL0TIgjKM0764EX07O822ZrTXMHmEU4ghG9cs5gd39/fj90x0f947kpR/q8b9iTG8VKe7jiDvn++lUzeZyj7svBWdk9fBbputU+YtuSPnUn6Qt2T+Rb25pFeoLPioGD3/S90x7dAYzCdXwk3F/uYgOves8f7eBptvK1KHG86dLf+Xf2bjgOOsE0/Gw8efLuTp6D2fTyW6+ylMTp+2rzqCOf9KwncrCw3zlvDnXz+zwvpZkTzNSxteDPcAHn1cH5wo8zlnvxorvPnj2XRmt5KZfLsT3O8cGn723qydHcEDQ8QprrBfY+4jOIdNbLaz5D0moLFZ//ht8r6kvS2Kw1fVtcLawB4R6hAzJ3Y2naN2ahpiwHmO1FP7ARj+fsv9vEh2jKmt8xg8AxpaltNr9ocgFcfogXEP8u3KIybeDzEdmihTsosX+TSyXHWLnaoDJOuC7g6xn2cug3upKr0TqVCm789a8G/2/qGyjLAWlio97I74vNYvLZR7UcvyXXGFH+GDkqapxf/3oZ0LUEzGEmMX/yHC9sZgB90YXDeyGkUW4gn21NPML/J9dthXwO55166sD0FZuLl0GJ/XeceT5RR4+hgOdL8Igv3coM7xXvx43LhCmFv8f7xd/ofpheN62pG+fxWm1x9jo5scQJ2I8jHLonxA8/TucPbfEzfYIPWzVfUxuQrfcryYy44JKOPauHOsC+quHSobqhPrfVcryNSzsd5513xtrmRICvfC1KoTNU6oiF4T/fDDbP+RGL+Hn1iSNxJntnCmb0rdzaBY9V8r6L3v3QKWq37Tcd63tkZ/CjzZwEYtxGRDWsoN9FD6Kw8N6rv3q9MXgb6bGtl9mzR3rsHuFvugY3z39raINztkg920/k3uez3aPmCfnGITzxQU2oY3X022q7DDp0TnDGtRgxF+ZzQ277yxqbv64bbJb9Ksz259b3IpbPm0WOz7v9Xtsf411dm7RRM1ucWxe6HOuX2JR/lD7f4Xrd9vrvX7/Bwfd/o3r259YlWG60+pHMQt7+LO3lNrm+psJjk3vVKW2xvLChHfZP0t9O69PD/FkG1L4YN+Q/Iv4h/tVP2af0nj5tdupxzs6ZkVpNLUMI/lnn7HCPc2v9B/vX7+D7v2W9+wgf7A4P6maGhzDwpcAZEb5v2TeahIVqFK3Vr44n2nBEXcWDe0Sr58i9du+o3VrY4f+6Bsf9iEN+GftI9S+KHcP3n4eHUeZalWJ/qdsVgGlcEkaVZuO8wFP1omUSJ0kAriRX1YN+sQls9zPxG1VJx2Zq870KnPSLWlmAc9KTy3Q9R9VZ7ihWJh/5jaiu3bXN1hLfB6aNcOVy4DeKmzlzfJf3bqvgv+8bJfC5MTyMMuOcEssv34b8WQzJS/hUCCPHtV48MYxt1tctOGJr4XBMHK+ZApu77JtS6KB32pUKllkfAVuzwbWHsS3jHdULb12GK+/ovRlxLKrgv0veWbjW5KBpGaVRRy2/9+Ol71H9bum/Vgt+r9jBHO2igb4EtJRrrdBRrc11wO9SDGA3Jpoazlx1FfL5vtz3njwrYY1q6CnrsTOoFJrPbcYNJWN+LnnHLZ+/y65tMhy7IUrfgU9p90JWj6zyfpkITirotoD3JZwD39Qn3Ropg0taMs2aTO+azQYQLzN+d+HU7JCwI8Tp5SXzURmc+UH8IuO7xPsGBr7IsFqIIcGNlJzbxkByrCrL+b69T7476ipwDMU38T08Q60TuJGHfrvfpv0pPW/tzxjcOMS1FLtRSDNe+CzFqmo453uCzXcRH9r2O4D2UJ9zLDpRuaCp8IUJl1PynCl+8BOxLL9VDEO4KssY/mPiF4vq5voP9ux2iD7KQd7iK3xa8lu2Cu2rcslJ5qjlT6mHcW7G+kncEgdqUYc1q4/UpG+rvXiYXyrhWdU5F+U1s72fjAXbqgF8Suy3F+9x9b2nNYh7YjUtI/zBtOyUws0xOB/7gN8dozTRqRfavKkGTmLv+0b7priT7HVvwaP8WXihHnFoeqN92IR87Eh52TBWpKusqYgX9R+4BvSXEszdt6iScJmyeY2E75j1uf0zcUPH9IWO6PDm4nyrm+9s+MQx1wKe8JT/qVYPG4YyshH/GOHUBkZ3l9NV1QOKn6Mw9OKUa9Hn2txsntOo/HzOyUiPiGdKKSfak7l7cx+f9MU85UI9tEfE02Wy360nfJCn2bjjNnNP/+8DhtY7hav8dFySh9nEsVPU1wm/KPj9oGOX6FbyvcO0zcAvZAK/hHkpaHDm8AODf3Wo1HvDlWT09C54WH+CFtxNeRh76b6jPCZ0h3v4oM/BJrIciWbJ7CLyphLlhXZXCGzRg94Fx1UAj2MjzxrzPAqaA/u4Dy/T3004PE/ncX1lWo9ffYtrs1gyzUAO+2aL8+fmPV9y/1l+0adjOJ+CO9LD/flUbu9ww1d8I9uDuqQ76gyw70/nNg7AcbewR5101pMw4iJx+wZ9EfPa+pKdG5xdzBWC92MF/NjajdNZV1d7by5dYTloyPhvfWbK2uRX0I50Ir0IHRJPDWiPOuJqeOb7mToi+K+Jsxqcn1Tj4PaW9ZKIk5C4lYHjBF/0BDwrtmFT/cCNejPbpPopzszc3npv1bhZa7naYHh//5XBZW7rHRysIzNu948xZNc2pQU0dZ1ivXRKnNOGxoMZELaR60sC8zxheMHK2FbrhYbMuJVee8tpqn3MYr91Q5ZCT23OX7rARZb+pnoMzrwBDu2gxHiKyd7MtWqqOcE0kNUK05lQvYmnoGdHupoC5i4t0nLe1Qi9Mg6+SjO9HltG6b1/ht4tOGcoZiKOCMbp4BT1QjLXj/leXjPjehDSqG8yDVrMCKd8l5wDolvVpc7BulG+ntSBmkZ+Hn1YP4Xukd6lyeZY9mKrcs+zN/GqgWANGA47mfHSdb3eSXkPYOs8zHgHxFMNv5Zw0qmrxOcVwE0FnQMWw+rrPpvJLWzxJsAugIeddIZXEyeaIe4l/gzGq5Dej+TWfn78aovhAY3H3H3WtQ1hAX4PfJfxH5CffXdIe4DmSZcO0xNmf0vOqFyKM/YC+37xRho2erkh/vx3cSAfzM11+qhvq+BG4Nh5luMEycwi55hFLhf1Td+3qtKfbB8XFqTdzv1vt9dRbqErzfWuvpzO6Qktd45tLoITR59l9agcXA9a6UzbYsz7GKxODA128OWRbk997YgrwVN7P9WffZgzCBO+7lNi4qq/wym+/SyRMn/rlaMPz3GixgD0LPqmPYHPs6LyAtw4H/nOs7xyKQc6dEkEpulO+szoE5AWw5vZYRzKwOHXPOIsdlVl7VIMt8X3MGnIUhG9FOjPZbUbHOL1SePlGc2HEzf7Rp8EmHxwgICv1TLCaRrvqCdqQqfPq107Ryxp1cnrawF2l+eVauKX82J2ZepUc9bsEN/+YSwq3xvK9ySnOVcb7BCHevJMr0kv5pR4qvuBMz/Jt7b377W6QIPO5IxcrEc9TrkzsdUK9bOQY9gy5zUAj4Uy27nvylPjXQOPPtOuU5aDuhoOMYPRTb6vFMYZvpwC8ik3Lk1ssxM1onJsx+WxpwrThkhzq4WGEYArJ7ZNb90wJmtHfJol9YjGayXWiKeN3uXsG+kH/AL5S7r/zpg5UyvUM7BIEzdEHWrI+62v0NwwCjtn5tnHey4wvYRUq6xrG3boQv+J7AfjqzF5P8KU65+on5Dez89//9v1mPr+uZwD+17NuYZ48jkoNd6b82b3KaZcMe9+hOXA7AYZfuQOtCHWDdRKVWvuFOujhhgUHGO5sGv1wB61Z8A+2OjTF5uz/qi1cAZCYv9nzWftHZwH7DkK6e/n2vV9fvBqm1r9peqWZ+KqDpxNaX8f8Nw9MXha5+yJrZrh557T4bwZw042c8/p7Wvcafx2ElbruLbAnl76eXqeyAm/5893HLQJFIucbqOHpClDNppmP6Fzarta+Ik+sMs0dJrd8+tS4MO09mDF9+T8H/bPYe7rY7pL/L35p+PVsrbsjJlpn+1z2ye8kYn6cfugNlH6XgdPNJdLmlPhZ9twbb8NP1y/OcAFvMefds+cZ73IHxziagHnX3nuFtvn2mb0KNfeyTGqZGTzHu3ZwjvmNhnz/a3Cbe2vsJVn7Z7XFtmH5uSw/mHKO7A+e5+L5bmnKhPSfzt9r6+x11sy7fVUD+BOMUvhd45ZtvUzz/FNG/3AU9cZ+KO+0Ul0L8newE+l96Dcdr29rd/LiUvQSzl4DjqhS9zq1CM+105gthccBMDaDk/24Tucm99SW5G9l85tfbq59Zt552RypNZ4oq7qR7txjm3ZftelK/Ydi488NSw4qu5qA4aRNnf3e3jn/dgd/vzaPukxn2sL9Kkr6mfGNhryArzzEHXET89BBr99DpLOV5915oBDNK6KdXhNArMmwj3tlsji5+FPjmVJk/rgurxBl1ldhefXjPQnaKs4sIuX+xeBr096rXvGo/j9o72AfXliRmOE+h0H8zb9CbpwrhiKdk8I3tRwxmefzvHp4ZvamnomcQq1LDOYOKY+u/Tdt5hNYjGQGbw76A+bdvhqKE+kyajf0/9YVCu6IPfDuR7Y++Y4TszjgSVzOCZJizoLj7TBtCPnZrMWxJFmXmDftt4718K8xt4NMudps9+QB8zub/+0eeuCmAJ+woLWwxkxxcezuaVBOnSK+sDZ4aX9EHtk9sBZa8i/d/E5jEnnxEBv2xrpU8usl7jm4Cs+z2fugJUtEL+6kvQ56pFTrKP/ec91LV5wRm+Nr5mcX8sMz61jxkmc3jfuUcPU9sXfn6D3nl93vLPG+65m9369rgNnj9Vfz6/1NLsU+0/u2Jta3avOg3zMUfXvbmiHllCGjfjxa665ELxVL1t3x1Ceumeu/U4eLjbe28k+mFlm8Cl9ymMxT0vesy8O21OmvSDe1EeSTndznRNHRUn8gHi1smy8Vw7ZZrzLpm2URp7qnxvfZr4bXLGuzey6Jte7c+zTvKieclhb/eT8j8cFbXq3nhHOvedmzl6pz7Jxa1N+Wh7mFlaejs+EHvLBQvC21Ze+5uz2smv8if3ko/0M4SIMSMQ492+at4z0iTNqr5s59+IkuQXu57kyb1aO2OXL8tPZbXJSVpd3fl4eGv+D8lCc4QsxP8LEGTL/e8V6FTbrFc65T76zrW2zXsq/la0N56+qPreLnfH5sdHmu1es6zq7rsn17mxb1xfhG39t2zpxwquwWdhHW/7uijUWsmu85dvvHQdfhvv4pePgS2uCzm3qgAVWB/yJtT/5n1P72/DA6xfg5ATgECbooZyDsfoY02ppTAte8z64q3rl6M42N74snkWfrn5TX2pDJzna4aD9YE+h2XnuemFO5BwcK60LP0+lxa1xIntwcL81LsgRSyHviZ/jG5lWQ3T22nKMS3l++/OWiwVYHcW05PMb79HiOMc2Hqi3XYorqB2s1ae6MOf6QcwGeqoeO9EVfjDmaztKtW3uXweKfz6uJn2X18We6VpeORMQ76zJT5gH0CYXa8GerxnxKefq6O8eOlvXrd+Kr1+2lvfZPbL1gR7ZSVoJ5/MOfwJ+f/POSq80V33+GUzW/a1Hc+jrs/qatPd7lPOle6AWfiOegXv0wQZ78Da/SVxDmqNV4qE9d90xBz18FUvTt4vzwmGCcd9cS18OuA4xNM/AWxsmf78n9vRYrqhFdfx+aBlPgyPvN6uHct77TXhRrpitaCWxZEaP6/79iKN46X0YwyPzTCdwkn88WwPPKE1cUw+7m2sTF9WhdQTviHNuHg6OAKN0Pg6YzThBl35+Hxyw9jvjgAt9szM9G+NdwzzqKrwCZ8pjFnYdzOgTDzib/8ji+u882/ALzI9vaqzn2EvaF1fUntM5UXrWe/f4CI/D5i4+xkntJMatYz4OnFZ2VyKeUI1zp39inFS4LxYsnEPn6bVYN2yj9QM9D7PAeaSiVqizffgr2Q/BiULonl7W86zp876pCHbvFn1Php3e9m8/ofd5QX0hw29zIxuSiR3Ptu2Z7z5i22t5DzOx1RavVKo7jNqNFekp9+4Oj3beOmlO0eVccZvrMN7COnSjJ5Y4g5ZyATxiiR7It4G09kQ9dOVt7qeGLAHbjDx2AL0KcM6Bz9ARLZ+4xoh7jekd8zPpW6pUsgxhmv395Fk/2JyEa6orcU1lpr3hFnXompBOc8OkeyZ+Z8YrSPc+sMxWqNXsiW26fkZ/+Us+B3rlPdEUIc5GsZfeN/Ss2X83v4CfzzPCginWgcef22ZrralCaJkt6A6svw1yrzvrJ9ywpl5wYgHX/Vsjvrqlb5nNZD2KtqEvNbWzAK9woytF7kiHJsfcU8vgQAU/uwCt4ey/WaY9MotS3Dda4fa9lmOmGyXhndP5Q52CapG1DunwuIwnj2nCgLPRlMBXSdz5/LzRv6GGz3jYwC0OfkLCtIOXMGB/W4JzMLaNYAEeum+cW84teqFtVkbExcd0X94t0rLmuiLyhK/vOLlvfJa4v7WavXBq+gzvCHo20HW2uoxH0ZalKXRxNDVcE09qFEK3u+QU6TkWrtgD/+aTq64mFngCVWkG7jHPrFONDHyiDrRvUt7EZP8T7yz9rjNq+m9GWdDU2Rxnhniea60ZuDAa4M8btQqwT5pajsDBaJkdepaU5zez/xzos9dI2zx2izyXiaTArUnwWwXLmIUpb58IHkCJ8bTJ0ldNmaXn0DQqvisGgav2/Kex3MMZQj5kVZWlW2u16Rz2Nlo2O3yie2KO02JFK+e8/ki5254Hfr2drLdvm9D5GCZrOsVe1Gp1wRlIc+jZkO24wRzwSXXSCPo6fPZiPfaNWPoz2f/fBs8D/8VCDIT3GWmK4HPto8SmLZxoVeJrmuy9ROv9iC+4UG/9SC0sfRaB7VldVWIbPKD+xVoM+695AgfcK2wDcVAyLlPS9yJbwa7VkFlsnmhSwTcwTaWN3cx+nrSXGP/XmRxyh3TT69x/XMqHm7nXk7lfbcFRV6WGqQgU30Qh9g7XFCil9siSic88w32Gd6EItlkvNQaS4phS4a37PAgmWuIniO9zy5dwTkXuowXiYJSDqG/W1568sX3wOTn2KdEakxx1Setjpf7W214n1YM21hy+7GUwWThR76+XgYQYHj4afO6kVQX9NAf+AbzGpk62wDaU9/7zmDSj+uDN70prNt/Q2/IdWo1xozdMcFZWfHCHeNCdkaWFPZC+JfsJ17FN8PK3Joxzkp4rc9+TBey7XYQGq89qBLBXA2EB3SvUzD01ib+X6f5EHb1hJM/M75/pY83Jrg2kolPUp7bMuQJriP3hL+GLlALmo6wR09ja6Kj1oNsV22oIrjvGBczt/cZGbvytHSkT0t+KM2tXa42dosf40dUwWcfQHdXhiwvgtf6JtcKDdSJ+9s7KJTLxAI8lK3hHa03thJa4Cuic4z2weM9vjJjtaYzCmaMe5vM9QVdly28e1FLiPjAnTp84kQfcT6xH+rsp2gs3LG/qEHperWYvfys+m+5RaK5pKu0J7E3klV8Qa1s754rWtbskntwNLor/3WyyOGSIvdRakE0hzh39yathP1Z9S+HPwPhfS8lvJnEAYqG3LmkcbGsU0nft0EKslfD4MO5v5k9V5OyFCzluj2hUkb0AF7neo/X2L9PVPWVW/Oz+8LF6TO0cvtaceo9wHucwsw3g5g3f+7L0Dh57zkUf9w1l2jcnCad0oNX4XuhKFL/w3G+Db+N/d2OW63eNJ98VyzOuxUP2yY2X2J9+cu+M83eY/CbP0VrguCtpamfiohcSIc63Y0cs0HdxlixZSrmdKJ9JtC9pv29rgeyrxX9Yuwt6kNu1s4OaUBfa3pv0rQ/Gfo5R/tvuKSPMI7N6wkk2qbfREW37blQWnKg9g+9zk9j5dbyxV/xzLAdu/Z2JCaFLCf72wIWulNm+ZcwHDUro/+XowBPmYubWMhzKW7jxo/pUW9c+ud4OrZMi0xFomFmOc+I9p/dDMZ7K1kNLNbaWPtfvSLRb1w1RAWal5FEeX2L3c6X/y9VLOzneXQUW6YdRbQDaseskpq8Xm5n458lvG/U1Pd+3F3XIawUWf2azWA/tqML7fd7CHXXG8Dke3mPkohaBGj7L9c2kjiKx55elNcVokTJlMTSr3bnrMY+d8W+diVVsU02ir+rv/ViCdsqE6iRsn375rrJn+R5VpqQHy2Lu2c49UgxpUf7iLTxjhVoAeo+xJ4bQjxpQPAr9F1UhDd1Ut3Y05OtceW/iOkU9sqPwifWumX6srZTZM9UwW6csodFHWmU/G38G7n1TOpdbATnCOtWyYOd9rlWV+VtXmqMebpv1mPH5l5DHxDgTbrEVujGrLWzVabg2EIuhlUKiD7DRMl5yvQtoEKMvMEzi69deb+njvdpmPdHWCJD3kA4R6ovQsq11xpbZTs7iHHUNd8A1JYqoS7cKF2km3Fb/htluvRO6xc45NWCT+3tmp9P647YmMV27i7yC9BYEZ5TmKGPUwxzRLtjGEzung/FfrF/AeBudiOdVxN2Y0UNTy/OXwXgr1/HEYEG1Pa4taGd0YNCfgfYa1sgatciH8LrXAjGml7GnyZo5RQkce8gbsc986FQ5tc7YFNmegY4hahsU09A+UpZMv63DNLGhkcD1a0iXDJosRs9/yWgSkJZBV4o98FomtdCol+iGD/tGZ14vtr8keTl/l7FnPFHuazMeQMpt+wartWqqLpImETQU0AdS6LuLVD8ccWVXCkgfuigVGkZI30m0X5DDWoiNTNKugx0qaajj4HxBY4jqu5Wtdw8ME3AOLHcF/l5aWCN7Av27JObCtfumtsuZt/5GNYOnvziP6Tzpk6C+SmukSq+d3kppC22/Ca1EBbXf0lqrTUI3+upbo7Bgm81pRm97nbxr0vDuSoM3sxO6sTDoG6sp9RKydQI5kPuG1+G1B/RxhlTHitpTraoQBsRC77XaCrxID7znMV23J5YWnmhPUXOl35UnsLkC8HcvVM9uCW5RCh1orslSEXXfvloWXLE3RZ23T/Xv+sRRV1R7br1XZujjOSLqC+lcEWwbt0sVsS9LiCcDxMrJPqV9EJUF1BNwLw1TX7I92Qneuk/+C3SjNjFxUpekfZbpgSS1lyWru1DOPMe713uF8Zsc+ppaFvFviO09o0R+iNsa6plYpKfS4Rp1qOV3klpKsa+Wpyx+XwmO8fQn5XXVVf21F/YsyhdKtLdcMYCP+ZvtY2Vkwz9ij3dRr8C6P2EdFi59FvH9huMfNXZ3UPmLtDW7ksh+q/dXQ2b7lv17UteB/YWfX/J6DvZuNdlLM+oDkF7alo7jhOukDd66UmSZvI6mCnQ/thksbZxDFodx/0J6j3NNHiMuQW09ef9pP4rHHhGdQeL5qcwtU1ry+IvelVvUEUOuoQ1IdbVs7iyzNebxXHL9tJ/yWl21dmphU60mTT3Ya8TN9Lua3xOUJl+vJAYa2kZrYqtJLRF199vqI/I46eS4t03viu8N1odLcwKrK0V9M8BezMYIlB9YZmttU9wE+8D98Ah6rcrApWfN1kXT+jH23N99U1oyPU7sO6bF2Rd16N7j+sk6Zm1zgjFDnis4qhJraj2wxOks1UWutZa2sZqynJPsfjYv5nnPlHRCbfSCVL4mteYXrHc7KkOTKZvzFpJcyBClPH/+5Rvp/pWnHvCHInt/rih53CfzZ9fn1KO+DxZtBi2yNtu3rOf0i3Hk83d+3v5EjhHpMfn/JMdiNY5sX+5wnhE/+R3UuWXS88T+mvDaSeiqCurjmV4js3+sF0L6wrAjw77RKnzb9L3J3ltiec108cp/2xRzlOep3amx9cg55/epaZ2yHw7Xh6kPeno+QX3EU+3wth4vr9UmthZ2xq1VeD3Vpp4FegM8doTvLe34EvK3qAmkeAZTWlJ+yXWy3BHZmOT+cP0/me2T/kS9Glx+ttpDD3beGJQ8rSb4mlqfOiL2IDvTDoulWV6M68fkw3jfgHT/gKPx2/g33rNL9L4tpZCXI27ij42ub46tgM7DDW1FIacvHV/LNYXrlDhO+gxe+WgrHsUZJ156b+PTM5rjpI/H9L6NeoD+0rdoZy/J479ozbvjv7J9HoaVyOapyC/0uVPUR31W66I8wDNKgUu4lWv1fk/UOANvb6QMKD46XQ+btCWT/YIcIXk2lz8HxWEs/hj2DSF0Ri3C1dF8RK3pd3n+db2u8cnPSVwC7sgOztCVfOVxwDt6eajPs15T1e/XkhhcCDW1I7gRx6nJQdiI3Dnpe7/bY9L1liVoVq1saKYAK7YTp7QiH/HIFPy4qS6lMl011cJUe/aGplH5E74cvsIVdRaTwy5RrkGxSKZGmL67uVYlPneB4ZaoR5zxCeSDRvA9NsOtTGyq3UILF+8Is4At+Drkw4GNvElEPq5PU6yYKmEfTz01+MFy45nP+sB67JEPbE0cU4LNQr8S9g+8pdw/UR3H1QY/nWsSnEY/PI5tOANv2rZNbcZqfb1ZH70L5D5mhfLJvlouairwE6jpJdemcx6+qXpsUS1wt+ZZiVu/EEfGtRw3GXzdyTHXK8OUpbqU+3JaSy7x3K9UcowVzlhIvQP1KzjFyfag/2CT9vAOrlFlGO+Mhmg2n/9gz7md++vlneEUEhvGzgDwHFv3meTFtA8SzBP8f0OWgC/j9pb6nvDfgS2SnkkBdsWhvdI7npNzjBvuxSGsSEtwR3QutushVJNYJtiyLcxTGpsQPktab2LHBK/DYlHq/2VwJbBR6fO+Tqn/9han+Kc9MUzqHzh2yuP1jjbr45vAWnPcmrIPy+r55nF/weqi3RxsfaKRdTNsfVqHuTaWeck9Q0fmkPm+fNlcQyrLo8L//PF///HH+3Q8+s+pG7xF/el//wjHy/+cvU1n/4U///Gv//3D++Nff7BH1oYJFJ2FQxiNqgDWvjPqxEajErh089ldpN9LxlT46A2HOU2dotdDCpSEoNyc5B77jXQq0ufK3I5WCy8uUZmZQvZEEpiX/XmZYGbX6qDnBuwhBgyGlbt0pEVJqRTl2Dn+jpKOQ62DBG7ghU6EsL3pW6P6wsO/kaQ24Pxkqil0Q8nlWywBbkSlOJRak2ewUrhJKfBqLE10UEot6gGOcSYMar5WC9umoybRZ15U5R0QL1cMUdKceIAbU1l3yGXkM22F/a3P3dFIR4taFKJqIQ+V98PZ8mWmM24nO5KUjg+EH+EH3hkQwR7MR0RtBaRSAWAkHIaMUkdoy5WxRa3gpY9yeENm5W6UIhtU8qwvLEqNCXIOVztpDKSqI1LZFvASFpKhPD9q8/SJ7R9bLRN0i5fAAyfywhQqJpanfYIHAypcXich2aZ1tKdspkyzbbXU9W5BCkmmopCsD0zgoEFUdZ2QvjOC26I9Qn93xNLAgTlX03eP5xygDIo1yGndr22zA9jN6EMos20mt93xiFJMrMtqNzwC7NthYcG7oypIU2cua+cUGq/tWWu3vBRNBFv1QlPkbpbsSmtqmfrQ7mKcMvzb6xYKjdferPleiVuv1WXzubrbii+4tDdYOdIZCCTzTJC3wa7MmgIb9cNKWg0bWYyPtJdKmZ9jULk1lzu/ObDIvZWG7N75OVPL75aRCaF2YGAbtzL785jL6MCuCUnb2ltrA6m8Zw0FV953HnNLNttSW8osG+JtwUn2tPx3XE9eK5/DeVV78lbrEAwSJVC4atg0hDg4w2iPAYLIRgJgg3pfUL5GWdMs0tn+YUfhFO1YWywXnPV4wWXiP9gTS1TWH6G3R+DU2bJVfKwUQX7qmWCvg41cO/6Xv4/T2rDd1Ldl13vLxn5Y+x0beW35nZWY6O9beyVLg7lb8ml2l7u0d6scSsP0HON95rWzG7v7b7+t+JAm9Ef60Bb1H44BeNXy0B79cP+n2JWccdiYWsPHngfSRNyuExQB8NsaQnxuh5m8PbPTlNZqsPU7dray+90cmcg8+zXdV+L48A5YuSk/rYUfdWs55z5Lobm7drCLH2gvqx/vO1Le0TqxlTIbDcorH2WeYT/kZCMdZcSULqBEM2V7qCzYct07HPJvbHTe5/LKV6xdW356A+Sd23yWFvaStI7KHFkoeWNQGfHfGWnPBd/lcMWGmYVIVMZOMUD5vUDQHrkw49/xG12UwVCCkuI+pWYYaxyvm8+V5cvr1K+LralT1If1uFLWOOVgA3Y7UtBa2Ip3NDlYvNWGPmCjLo1+7VxbLswsNnI4pXJPVKLYNhkZSlqDntkZN4zOxBV5CZCXbxwq30gLXPvbexPnCLGV6qjlIsrOznaLa+KM7AWkA1m8JQhooVqGh7b97qjOLVKd6ZZNLZCPOeAj8iiD6hs6EJmfcRYDT8kOUIywte+O2t9MDL1n33+EwFuGtz52bk5qz+yxY3l0HbtxwsESTsZ+XAtjPTE2KthmZXCkNRS+1STyj5fe14FY6dIYQknuaS9c+xbjAyyvfsX+PDd+yFAubkOe47zcUXn35Lr3ARqf99mRF/TNDkHNtbCQhbN558EHWoUrfEheifabZVJpftowVsjxBNQNYJtts5LUB/bm5V4UBpu6Qv2HK5YCl8Zt2hxm0ho7YhnxaQIdBBRl4EblIqDymqpwuFvzsGxp9v3d+vnZaGLRMjA+h3FgAXtOBAwb17INNvprii3AN6e2SXn23DY7oEz42xTDoaP22Fg2jUWV42/vq7VtLP/fEYnnAC0Bs9h6R7x8o9gggv9heTJyZ9ju47EBqyXl2oCPLX+KxdDWby1cFVAfb91HTcNojzR1FVK7vYZxNzqH6wS2takH9bbH8URl7oiliSVSOwT7zn9Re3M7fmKjNGJ5+dYV0Goh6B8gIk4N8WwyMtMKnKg8p/EHWeDw9M66EQnDly5gwdR+zvpilIIXgDM7aEPJHr2zelwZb2zeEBQMsOv8XtEmKvMaA+AqocggCaw8ziBpeIfld+RJjSI/P5/u11F/Ib+9Nw/Ohf9zmteckaGPowFxncGJR+2BuRtD53/+L8/ojOwu2cYLx0aVNezDHlrj3LznlL3bUXVQd1KLBiMyVsyh0iP6zBdN9mjcRlN82LZ1n6Qn3Cn2uG2s0DoHrMXW1IBGezy0YYy64Kk933gXzHq89OtEpbEEhA01y9BWEa8epmxj+V3vmK/e39bbU4vg9dbZVr1VXAV9o0BjBX3DntD422jIYHMqq0sBbkby7wx2GNuGPnfFYOHJlb+1auf7azcdm7y5H6e6QntSlv3/+Vim98Ox0w//c/oW9UezgTu9X7U+Qx7ixudXmpNTa6vhjECTLIt92UQABwZnYKloBT5UTM6r9Gx5l5MbN9UMOCFb4dtqqvBnOGml+Wd3BsWyJ71+ybAnDVahGo0uAQ1H4+SYTQKQotkOkCR1Iqo7xEZqZ2EV9RkBBOOD5K+FhKB+MyzZ8zsMgNuiKrDyeQSwLTmPmP6YNcxEB9uDWKxDsVsp3keKtI9UNp+sYZ+Iwb4oJluBOzh0lwwTnjT8u7POtyT1aHclvGsRw56ampIX+TsEixwYy4YZEtJFiyrvEGsXAg9AJ0QP1AQPMfw1t+PK2DJWRcukQTA+zCNtkV6+MHKXkAYRUgKUZD/ziisbPi7gd1knhxGIaHKQVObYwDyinC0Cp1sQkZ78HndJrZLMLJ/87eYNavbOXhP7fS65bSaTyxlkZ8/US8/OScPFuySdiW/Ze+7zqzdHBjG1Yf9sgtgKBnROJxeVEyEz2v+uNuhMAPDSqsn3O59INOpfKmJ2Y/DUZv+dQ05O1ZTTRRyemNgMETZWUbGzim2/F+mRjWHZqLUhjlKWrFITfirRdXo/v4BQ8lZM0t0/NH6I6DPnGhcI7jKS3bxr3YE4vrpPIO43EVc+U7DgwNnc3+08d09oIKP/sCc+U4RsDyH9+ncmpM+A98+yCRSLnC+0w0iYI2XqVO8ltFP9XYR2NrbsLDEsts/PEpGg98qEA9mgmP3ZNjw+YMMPE93u646dIQR5B7KVj8Mqo1bhbNsslkEUdIUAXTWxyRhMXt9a6OwEUu71y2Gx25TA53yxW7zTDg3vnCmYsgLJMu31hJRqdJ+YZQ9x8G8SsxxAIx72TSn65QqxACZQld5D586iACQQcegcDG2TOjkY6B6eaydsoBeI9KFzhdjJMLEVW/dyT7GTb909sdv5w18f7cZZtmX7XT9EKj5BpCLSp654tkhFyIiGz4pt4oTY30YdUb+D2OdvnoOkSMqzzhyQ8sJ1sQ6rSVCP4M4iTYifJz85lj0qwmSbQcBQH2fXjMI3VZlBEPl0ccEcQQcmhry5lnBn4YajYoOnkHXTpMFhtJramnpmC5NKLcsMLhINt83g3anpREjzaihPNxAQ56K4+hPIB1wxFO2eELypP0dM/BKRk58lJr69FhmU9Hn2LfveExH3q8TFN+dps9+Sgd37i4z3/kEi45k9cNYa8u9dHGO7c62KtQRCvE7kQiCjAuHhBqPQ9NuMgBkocDPpcwAtiP7nXdf1FxA67htn1zInZ9cxEwHcKIzuIxhY/Z0FAycXCX2pZwp8pbUeJkrXv2dv6meKvf2aa47ppMsE3lQheKveQtyN7QPHUJ5+mrBb93x7mp3mu5WP9Ixw7j0342sJP/AuX0FIXOyMz41vs9+9Yl3X2XVNrnfn2Gd9WU8qM5F3Rf6XxAUMM6dj8n3dzLmX7em+yrxZORQfYXL6qKD6IR+M877Vl75ijYXsGn9mP/lYP6PVvQgD8mmEPc11zt7Znu5dNt4rx+zyRfmpc5uclNflf2IeOvjn5KE4wxdifmDXmf8VrxBDl9P1mjhD5pPvbGsL+8S2/8G2duIMV6ETeWBEODc22nz3CpH7ZpxdV369e/eK44vwjb+0be0bpauwWdhHW/7umrPbzaxxuIXzurPN7V1kc3/tOPjSmuCN6oBMKHn282p/7X9Q7Y8xLaD/cAFObiN0dQ7G6mNMG6cxbSrIpn+/NY75qM0dXBTPok83uKkvjToLj6YTDwsROcWzsSOYEzkHxxoznA6dJ3z3Lji43xsXtJnePcs3EruBffbacozLwoluf95ysQBHMS25Z2wfk8U5tvEqgeF8XME2DuADewiET8Emcy7epkbTx6Ebla7wg81kbZeW2cFk9Pz+daDmz8fVjNJ3eVXsma5leOVMwGB7TX7CPEB8DFOWyypwyrT3vc7V0d89eLauWz/WY96av/v0Hlm8v0d2hPXmsvmYz8Hvp+/srUdMiuefwWTdayExu5ye/1WSvS8w/GG6B0qvRL58jz6Ytg9v83vENSNirv1OzMPnrjvYiaoQiQwv9YelBOOeuZarcUElU64XXcyz9Pjf74o9bR871wP8PgQEDrMobTO1nPl+OZ/FNbMVvSTe2DDLKXfvRxzHS18o9nNMxDL3bI30ed9UBLu3uTaxVR48Jx2Ii5yb1zFhv7NxwGzGiYQSw7vggOPfGQfsqWHBUXvnr63ZIbH5i+cYWMzCrqMvB1zs0t21CXeebfgV5sfTGus59pL2xTV9vs0cRMlV9TvXmwmPw+cu/gkcOJ+GBWOMcb1yrEf6uynaCzcsf+Am+qXsB5jNTD28sOcpOFEIEZlb9D0ZdnrHv92/93lBfSHDb3MjG5KJHYfnrkk27nzEtleyKWZjqyyvVCr6U8hwrQ3uytezy7acx5y8GwcGbuSBcXNjg7b6Bg8OoAcH0IMD6MEB9OAAenAAPTiAHhxADw6gBwfQgwPowQH04AB6cAA9OIAeHEAPDqAHB9CDA+jBAfTgAHpwAD04gB4cQA8OoAcH0IMD6MEB9OAA+hU5gJwIej9hwRXKTPnwoGLkXfpqD16iBy/Rg5fowUv04CV68BI9eIkevEQPXqIHL9GDl+jBS/TgJXrwEj14iR68RA9eogcvUS4vEWbzD9evMjXRg3ugtDi/Hl1anF6LTjGbBWZzS4tb48H2cOAUfudeOOMqOvtMM46i8/G4vMfHeJXug8dt/i543JTH5mI+neiqeJjPIaYcP3eOkZoX9Wxv3Q/K5yY6O/fM5yQ6n2Ml3lmT9v25crR/G66c/jU8OZet32qHI2dyL36c5lEsSt5sZdIn3Dezc0dM+wdeofPP4C5H0pl9NGAO2CzwLlfSfeaMhN85rtnMX589Bx7bhjJ8FUvTtyt4Pnh+ublWlutj5MXorSZ/vyvGTD52rjcz+UfeL+cpap//fpP5a/Wq2gyPNzZcS3fO4YWjseV+rswjMz6Z9djgml+OnK08ToqjmEtPVWJb1At7esxnYg/zcNlH8syjdvzBwfTgYHpwMD04mB4cTA8OpgcH04OD6cHBdC0HE2Iw9E7c0A4toYx+0I+NfdN7OT4gd83aXYn5i5o37hutsaa2AmcgDeyutLbN+gT79Q0cqKqy1tSq73LspUa41MJUU8uxpm56SxrHq/JYre4MpLUjCqHGZqnDt1pn3ZClQFOl5Bl8DVjHLv/NhFtKVKZObejbarj21HAOfh57VF84XfoucJ++tpnPhv8EZ//0rStRLLvDJ7UHg/pxXx+0r4UQs/IB+IF0tt77z9BnxOGH48Mjdn6HAzyN1xP7nLn/MNePpPHntj3I7R1JWo3uwffEYGKJvm+JylxT66FWawGXjTP2xTbavmU2fasrrdle6PmUU3WXPuYVNj1C/nezyWzIMJxrtdbCMXo+m6/Xn7xac4r9aSn83o0KsFql5DcdQ5l7avgO7pK3rjTsm8inS++eLDF8OH3XDi2x4qcz+5SzoU+yKvH9vp1374vxP6zdBbWxHZ98qPd3KQfvLeqsGS61l82/S2V5VPifP/7vP/54n45H/zl1g7eoP/3v5fjv4Y9wvPwv/PWPf/3vH94f//qD3Zk2TCwwOyHwuBVY8x0Pyjxukq01n91F+r1kaphPQjPGOUXw1PKMW3P+hg5UQHdYn9NVBXucOFvTCiVd3dHeqiixPrgiLJc+t4rhD1QPHVMqnGKRO+JqYUXKlFm31sQtdsBIVtJUHdGDkHTT02tiYgieUV36luGFzqjte6qy7hebft948j01mLixFHhmZ4HOM0UeA6nXV8N1xtovvEiP3Sgc2qo+12pS6A6EgmW2/tZq9sTqSpIt6nNPwXuYzvc+X/Z07Mt69k1573ZqNjsq+VzO+9qxRJzFgZ20PYyCu9WYzPXdSMe/hajA5axVZMEioYOu0r3e3sMI9YVndsJe5j4wqWVH4ehS6/Ax+ss9tek74Htn990e9l57Lc1hy6fjtzJVsR8fIx3RoiiknjNRfJQl8hx1jdOsYS/9nY/3jP9N3mO0/f2t9zJUli6doxlln6fYBF3ENFMPnpKdSTq7+pNttARi86h5qLD5ntkKbVkC28zEBnrDePItU1pqNW/iqb5PaDKzHiDj8CLuPXF2a825pkrvjhqGzqjja3KQnqWX7vPAr8OmILq3Y7Dp2Mi0a/WwYdYFZ9Rk/6a0Oq8yPCvYFDsUiTkDqeoZrb87Vc3XC8rra1daOAMphK1560rEzONGZdg6ZE0j+3XqO9FX3xX1GJ/RavWFZ5SGDbMT981Khlm/jftFhCraZt3Xvr1UQhkVw97mu5v3s9ZqVOXg7648hy21zXqJR5CxIy59S0RW4IWaHGTYRdnkZGJPPTUIPFlCxon7RzSLjmzgyBIyhsCKlLVtNn1HDf+2u9KrE5WLdrQK+mKPIpp2FI56ph66o+Gkcdw+Zf+dGAc+VhPrfM12O691/m60g/aUbAvPPnb34ZHu7m73YNvGR2G0E92mduUy9tX6ZA9L2ZEq+8fqGPbAp1XKD0foPdp/hyvnh2yh8laTFu6oo27Qf3vs4Xl7aO0ay9398+4Wrd2/USz2YV1rwa6yERCJ728ZG2l+fJYP2coJWQUh0ly1vHbFEFMDrGqJ8yZaPnylh72jhnOtutMdUDsLq6jPbKNUcOODXftfsFp48bqyCt3O2mTYjXaV8vLRAPlnYd80yD40ThbJfGhfNB2x/Ldt1l+dYr3QicLQUdsnZpythTtq+zb7jg+kJbK6V7W86AMpX1MEsvncF9pmsHTU8L1vbr7DmKNZlclWYdt41/WG7NT8ty61g4l/zYl/c+JUdC/F5kG2q9OQo/bENlbDC1Goh2wa1nupJ2d3xwftq5Bfi4S9NpvOUZ05tKe/u+i8hLl27tKznbOu7FxsnjuvsoN8lXLKniPA7tTDD4jg3C5R8r02YtCob+hTW5YWNvLOgeSTPVTKtO9tswUWPWZXa/XQLUrIY0NNrQeWOKUY1ImlQINynEhxBWK2d+RevGrIc9Mwidtip0iV4bkdC9/bpl7oy0LBEWehMyCU3RhdcviGnqlPLHEmw4a4scQ/I8S2Yce22Rpv3Q+6vDU9RvxqdaW5bbq+hRwANQAx+OGp5b9to+Q3ZKnYh52QpaLd5dXtrjSwDOTGnQW/RyA0Ytts+26xs0Cs7opfecxcCt9qbd8dIa9uFSyzXnBjXnVi352CVQ/vlvmwnv+iChN3VF+4SWxdVSbuyEOVtO6MOgJsliuWBTdqhTsdxyvjNsT3hUEuAj2zr7audySvYlXbk1HnfN9IC5araMl+YbG9qsSuqA939tXCrg2nmtqb2/GTb8nldL3NYge2f27JTzewgUCQnd7pRr7JfMNmb3D/gucRXFRCUasRw0Kf5y62GRTcSHlnOZ0dODU9PNJtyFXPylR3yx9twIEaw7k5wLG1Z6xGQ/v09W+iMqup5YjZB2Hp1dK8i7EQGZ0Q56ZvNn3EmZ4hUM2rEcNO6DiblLNt1XI+xvFbtSJDKPwsBNARFhP+vKd284crstGIh5OanEtnRykgLgY7FOoCvCY4dMSWAAUPT64sKNc2OyGvJ8Y2cm4DNcdlji/cYlp1ciaUfgbq6FCccV73Yid/uLSbtK/j5kah2DdQ4007t7vKKLxbynxL0iW1iBmOdcw8tTVG7mObduiOwkKf/GNlbBmromXCd0qBWyQli62u80t3ia5MiM6qm9jVNE+SIgsMlqx7UsDvujGpnI/p/ctB4NS84A2/GykTB2dzq3N7C2Tiye9xt6uf2Kh8Fhqwz38CA/Jrou57LhLicAdut954T3WdhxLOQwnnoYTzUMJ5KOE8lHAeSjgPJZyHEs5DCeehhPNQwnko4TyUcB5KOA8lnIcSzkMJ56GE81DCeSjhPJRwHko4DyWchxLOQwnnoYTzUMJ5KOH8gko4D9WZh+rMQ3XmoTrzUJ15qM48VGceqjMP1ZmH6sxDdeahOvNQnXmozjxUZx6qMw/VmYfqTJ7qjFM8GzuCOZFzcKwxw+nQecJ374KD+71xQUy15WzfSAoz9tlryzEuTGkmvIsS0PqCM7Zvvu8c23gNL8geXMEOY98+lZJz8Ta1VEnkCj/YTNY2VTm5fx2o+fNxNXtUWS5W7wmvnAkYbK/JT5gHiI9hypKZtDwbfAZf1+edq6O/e/BsXbd+rMe8vL/CT/XfRuEnUXq5WOUnUXg5X+lH2FH64ao191H7aXV/47hmVA8to/OdmFrPXfcNw/SDrfrA+83yop75fjnfyDWzFb0k3thwKyl370ccx0tfyMR7jM8j92ztMNXv4SV6KLE8lFgeSiwPJZaHEstDieWhxPJQYnnEtjdWYkkVSwr2xEEtaLced7JKxGnKrAf5+3ifhvEz5ta4Fm7+30lbwO4e7yW4p9RlDvGFHqmhOIYeuEU9trvlYZ+43VrUx/HUr8RlDlUYzkXO3zc4xZ/8V1Nfe7I0AMab7KFKfH1ftOeV2Df0oinS////Gu8r9n6UMvEafs/tiZ3GP5af81YGTrGyZ959z3Xz+unZ2S4l1wfQ/Iubgz3dtfV7fctm3b/s8zN77QvnJyQOTMyHm1LgRr25Vk01JQLwXbJ669JPcDwNWUrPZUOWwDVH/qtxdB3y9voJOPjjfbRTbPcBjENOfSLf/5bP4Tw7qfa2T68kh2943z7N+zvnIT2O5Ridogyd2qPz95gqhJbZEtyot7DVEPzda4oTaM8pS1ddlTiHatQ3VsQX6ohPc60qCMRVOxr6Nvlcic76t0Hlq4ecU0jO/tNX9n46P4ib83Xf2p/A5bgH861F5eUBO3iE/3drhnfOsDD7z4ET6auPNmo3xjhwryN+pi+w2wl3LdlpsTwDV6vdffLbifIT1MP4OW3IUnIesxyIXE2Mzth8n008GH8dz+NOwEMc4Uk/Fs/tt7+n17MfscEjNrg+Nhh58iM2eMQGj9jgERtUBnaxEz5ig0ds8IgNHrGBJtenj9jgERs8YoNHbEDrWXvEBo/Y4JNiA7P5sAf/MHvQ39HnOOSr9vuBvfjPvborDIdPumLJ3iG7YEfhFPhoTa2XGgNJsQxoeXGbo94/bkhwXrnvqJtvfw7zIJ9qoyrH1/fUuOU0W+Xvxxfs2xM5NisHz3mIw/mgnvV+/Pgh3cXt/GKw53wN9vs2N37kOP+wHAczZT8etuxhy34/W5an43gkd1O/PuK0m8Rp7N3vPRu52E+mC8p0D+n5gHuCRilp0jcG0jM04qyoB63SJE/xX6rh62vMP4scqFYPHWDaTDvU1NUEuvP1Ymdhq0qpHi/9+tr18d9uLAW2+HUELbiUX0UOCvApbrETOGZl8u9YV/nJ/mjihGVaK7PI1vW6nLuzONMnKcDskVY6nTVg/Hq+GylzW9xXf6uMu3rre/JZrqsJvdqJF/V8Rw3/truVkafiuYajhlwZtWg/Qr9XGTmxO8nk7P4LzruhA/s7c3PnsB+5+ifn6kx3+Kz4t7M4Yf55ecrcn52r534SLn5mG8raM+thQ6Q9NHdF7GvS0g3cmjR963IN3TS+gm671PJIT7Ze0lQbtoJp8L6O/e81e2KbXuIH5t9V5k+TWPjo3tw7q7O3Zs7e/Xln9tVTldhjWtvs+VQFGrexZZRG++pkmhzUe4WvyWeZnquxAqZXhN5035iFmuwVHLETvHXdqSa7RZxx6Hpahreox9BTTs5PZezBF0PX2xCWuXMVxzllTo33DvN9sd/Z4HoP+pc9cd6p9vWuuK1ywRTDuSnCzuo/uE2+Lm9Rv553zob63H7ss8/dZ+3T9IvNU3DmYRqHHdMzVvCspJmO/xP1uUdawdKwb9hM53PU3tjNGs0NrbWaN/FUn2KFvqlRfQE23o1CigXSuj3sodnc0gVnfCEf52lOm4NqvVvGKnAH0jv0vy2zPsHsxqamURnbZhX7JnS7S98utqea6hVsxLI1/PeqYHeHl3IQnJB3Ha4T3cpXPjDkj17wtb3gvPfeE1sBuPA37zvE3M3m/MsBnStgiRuyNPJknLFO2JClKf4bZ/CleyFXxAl95zv1ltGz+nLCbN2RPIPp3xz0RVHpcb4e5+txvj7tfHmFB3bh37IekpsPW6IytRCP8vfdN8ENsakHv6h0ruYsRvQKdMbUHsWFdMbU3uSwLtVVtZc74SQfuOHH+Xqcr3+H8wWN3uv7071Laqr8nVENNcm19/WaMnWapb/Zx0vqCbA9+9vVa6aP2sYvX9uAPXqcr9/lfA2ZpmjDqAeuqA+z56pPsUBp4SnliTP4eWfodjiyBx70gaH6TTFUj7N/997kLXLAvc+zp5bWZueKYVYSG0K1zBTfOnjrPvkdQ3nvy6m/fb+7f020rPPf0Z53f5AT9FTbc1puepJ/P7G+ejBHzd8TH+usn5K7VrOYue3zX/pBPWq9zPvZqL/m9tw/M3f9udibUX3hnNlD6BU7gTt6YMY+uYYz/bn18wfu5DfHnVwQa23ZgWxv6wPGFWeZzWHs2uDPjMN+Lv79gfN74PweOL+Hvb0K5ycogm3WS69F2AttF+d3JCY9aCMHtoo4lWkb7DxzitFOr7WVvxyLNetD/CbnUc7lKz6Gn97lpT6AGT9+rfS9J/lH5gyFp3F0n4CvlBhmsud7YjCxRN+3kjNUa4XASzpq+MU22r6F89CV1jhTjtrzqQbU5Tloqk3I/242GU/zMJxrtdbCMXroyUFb98mrNac4n5bCn8GoQCO6lPymYyjAeKLXAFz8sG9irUvvniwx30TftUNLrPBrKtA3ACZ0QRoqKnLTwvbeOJnH+LB+zIb7Xe/RHvYvm527VGvjIG97IZzT/FPUCnW2tw7mqJkz8rJz/4OeGM5tcRW+FuuGbbR+QIPR3Ggb7XBE59npKsPWdqViXw1R30jrGq6ox31DmfbNSWjLUoB5Lq3G90JXIi06XtvcaGjyv7sx42PvGk++K5ZnqJc4Yqlgm0HBjZfYn35y75YMbflh8pszyygV+gbwTdgjnYmLcx5hvoLiLfouzpIls2tapNVaGmEWA7PJbL9v2fu93Psf1u4CTY4zuHL2aQAeqdNeppV0hj/oWWbr7529fAwLdjr++mbxtjKyjVLBLNLZystn4Tdmbi2fT8jLO2sX10a37uWsHPrE3Bx7ew2bahul9ze9nD7beXFYS3Chg8PO3+Z6XSlktU6uiQBNOVFYwnbDT3hqMHFjae2q+nvfsCdWLBVoj1TLom3W477RCWEPPLOzcPg1GsYq9CJ9SpjEUQvnNnSiVsksptee2IPNNVHD+uSY7Nr6yO4axF6+rlH6/u1IERxao8rq6MzvYQ37fG1reV9ecEjH/FBeoj+5ajn2DtSBDuqWHNI3OsF26aqy7hfSe8iPi2t7atsHfzf7nvdjdXNrxmfkRbAVjikVzsztTuxn1EOvVi8dzPENO4DvJU3z7tFZwokz6oS2uDdP2dZwHukTZ7T3jB7UUz9wpvbrFX1CLmwZHuaOru0rIw4aOOrB3vIJ/Zu9df2TbNaedTiiZ9qJPaP3M7glLtCEPKkHcioGPfETK0cpA1cYntU3O6kGl8wcKFNTtCd7dNHOtgX7etl7+luXaDntx/afGovxXodrrH5Az8kdnYdLOCnGyvmNn/B+j8eLx3tyqFUHVqSs7Xz978KHHPWaHhy0zgif0DsP/3Yit5Jdq5fMYl1wwvK0bwgT75Qe0iG+isM+6VhdbI9vsBduJAR0b3Jd6BulQuv95r4sfKtJC3d0KCY/pAt5yBaeov/WCVxxpiT3sC++2deHPPS7x3Xf8v3ImdwiObWvz5s/fVP1d496Rq2Vcy0vsVmfWEZ9etA3bOUDHP9V+SfFDnvf5Yl29uZ4jFthJG5sbzccUudij17VcM37cRmuvRLHH4VzS1wJNmq1xhPDRtRYvb4xkFSeG+bx62WvdToHVYIvGtwAS3io3pFrN/b4GjNYOsX6ofzqYJx5IB46pd5HdbFOcg/7bGB3ef7vnqBNfiBOOdVO8Xma+kl5yy3W/4headoz6CS9fP9EHGdu7WI1cYywcF1OdqwGc2TWt3tyHi22bl67SXjszsY8N/vEV1SONlx4+rU2J+VOOoPbaF89/ALs4qE49pw9VY7sUSv8jWPahYs68qh5Uly2tz/G3wPrBR2KJY71NtJ+UMcz9PitV47ta+3GiLB+P27kt4nPEH2qlC9s1PQ9MSz0ZWkE7IWHWawoLLx1mZ5tPhaC9a48sxUmnDjb98d+i+wZYRUZ5pGuZdL/P9eqfH885/GOZe4vPJ1397PXV8cz9rJca9rldQ+5XnCK0sQ6vJaRhR44zhCb1/1krokrcUP3zZHWG1xIeUXnrXufPOnjbJuNMxNY0Qp9Jsy2xTZmhGvgHCWsQhpLaKqAfTXVVP2JuKeKLIZuDCTdFXv+W3GWvY95pp7LzocplLVaq+SMOsGbLE2cgbR5D7G0ExNeg9//req/J3MLu7n1fe5Di3WuEa4dOu+fX1N75CFX5iH61K6daQOGyf6g87+2jRVq1vBzjJOa8csD00S88/Y277yfxuC1GcWqP7qlP7d4mc3CXKuWwPk8stHHF3kvnLgclDlmAhH/ugNp/WaUCpbpz/+ZMS3LcdxISd/tzXuVx3OxvDykZZkBi1FT3CbFObFT9Fg+UkMPVI+dwTV29x+c441aC3fUOTe/U/l5ozlWV0RvnXQZin2zMyZMFfwQfb4ytswW5equ2LyKj3u/L7gm51GGtsrsoGWs2ifY6lPs6XfKcTi35TX1KU8tL/tG81P6LKlNuct8TnnmROHhXt4deM0ID0I8BqWob3hCarNUGzjDpIZPvPRWV2o6YvlvzG/x+2Z5F+JDFTmVInhqeWZR/elp/okzd+gDTZ1iPdyjk3BtnDNzxE7oyHeKc9RyfBEPIOJvdbVwMX8H/8rtTVpHSuL023Nen9CHy4svysskbmb3TnZy397j+RDlIYJT66z3PccDL3Wgns/iryv9mT6Fn0E9knHQMx0OTeX6HFFvS5+D1o/qZtKfpNNRLMzfxCwPu15u3KUWclXf7FB9/wfOLWq4vIZyZi2rvOijVrmZd8d5wj5fZ/Y/ccs4qv5E+M6ok+zJz5+VvVJ7I5kbPLfGl/Yotp+X5iv4vEhi55CfpL5owxuSrUc8YXZi6YITu3jVOzuC3bkslrWMzpD3aQJHOR37dOt+H2ratuHF3Gefac95PpjMkVdXC0ecYT/v+FhaLwH4mNvr8vzmeRB+49kqnKzTZiA2X17Ce0Xn7bW39Pk1+Fm8vZYc5U9X1i6obgN9kJpOc1mZvZnUFr5oskd1ikaiuaUqayt2qc5fL6Ke784Tu0P2KnavsSOH6xSX1SKv7gckvqiHd57Uea7r9dyzfj5lPqB+1zzqVpzNHmLLYvPQ7Mw99HcRf797Zj1mcyon9nKeq0fPPfct+3k3cvqr+/aCQzNnAtsPz5V5s3JqvYC941+ht8py7ev6bffE8jtqeeEq5TX6Cjb1hJXpZ/NFHZ7jXC2comTk7/9fB+tmG4jb0XN+9El+8T5Jdq0+Y6bwruc1iQv34ryUX1TzdNSKHz3FX/6srN3o36DuPvIWbjSLHLVcvNaXbfASV2HXfkZ9oeCO9PAX9Z+IR5N7X+/hz8vpI10V/25+71fA7RYy9a/r8FmhU2uFp86zMtvx75Xf/tNibvC2bPqvP0/vyGLcN180NSh4NekHO7fga6z4T2O5p6lCAB1qcJc4Rb1gRWUBWMuu0un1ZIl8vm1ucYgUnWL9bztaLTzOVcK0rOqhZ7bIjoITgebbGP/UwDaCCa5JtUVFEfpG6+92VF70i02/O+zNXLW85pqHW7wImhwE6fdqrYJTrMxsUVnyuvr3t9rQ74z0OeMzKq3rseRbxc5TI7JDT22NLfBRKjjDEvgtwcWS4GnAeTknPKyqjMCDgv4H+x3cezlugLvArGQ+B26GTvhWa/+pqdKfb4SracW22Vk3hiXptdfzf5iCTzqOYnnqAReudkJLBIYVfMebz1syOHE96hNoKng1ifeh4Ebg+dGHmoyeRCjinhsi5UoDy2j93RBXEyeazhy1/G4ZS7+P91ZDXR18YMrUE0k7fGgbJXBE4D7BBbPwhPLYKbYKrliZajVvbBO3jA49EHBVgCN0CwuHa8GvOoTVHX5m/5ddJ9c36PEHG3M55wg9jykGC7d4dg9NoncIzupaJ3AjL/Rkid4nw0I1/RfWN0/xFqzuTLXWwKl54FmboY/h1uoTL0KOItR7Mq1T6YX4kYWlVxv6jqEH6JOYFL8OfbemDxzCadJ9u9r7lNYN/E9s5mC1sMQpziTjGKHfbS1tozWxo/Bdqyrtrrm/Z7JVB1Jm3j9xzsmKysO3c3lzI6VI5xS1Rup74hqVcRe+O6rOyFep4M/Th1ifV1MveIYyBc7cNoN3B7Vo007x5hbrk/p7e6G3nGe8D38L+pjgiQttBbZZKXjn4pCHyrsl6ku8Q60a9HSlAr7CwKvpZO+wLtAGAAfIW/d5EEw0H/1/7bn+9MbtkiW2QrfWCe3nKf0buHWAX7GN1RqYRcsIp+gTkBYVxQd7ezxb8ZEhFO7bsz6pf/Sxhtp8tQ58/jgu7px+OOaTzsUW0HfUtF+ztgkrvpq8kb9T1vA/0H4HJxn7XvmpYXpFLxbo9xqmHjuqPrdE5NgdX5ODjI7E1hk8aV2vjHv/vfvDqh7YF/Tye0m8KEtj21CGmIn8Fm/0Pij2qE4mTjQJGuZWrEWxG/EeIkeKdOpL2F3JfyuSH3t3I73gxiVLqwllSz5tjd+Kx8/uETzlL7MmjqEX+mp5eOa503Sl08b8oacGC1uujDsFvdcQpO89ob3oKfTfkl5taY1CR3mt6r1OdzjXqokP6rC+uEKfPy02kOvtV6HV+wT8GWp9xBNmFjsLs9gKrWL94AxhLg6nKCU4V/BpFjEzRpz3atIPLkc8HnvpFcrfyPcXJcTcoabWA8RQsLcO8TSCc43sQLpHb+DXP7Me2U7eoa6WX1mO8U/ktOBrfy5eIPy4XmyOQU/xHywf6yVrTPGCVZv9iVko/pvz16HS6nSl8g+jkvE94NVsLVy1928dQxPfs1EWPPQIjda5+VE3rREwLYiFZ7ZpBhrrgZqcG1fGzbeXynBdjZtyji16bi5PO2OVdVP+FK62T5g/uCt+YuzVOktwavKc5jreNrM+vXgPKHr3Vd6bS12HG7u53mNdQO0D/9c360Vw6XZ6q55Wkyauqk/7RilkcewHTDxymdCVef3LKDGOdeZjktmneqPwleclbP6Y5Sohq/nI47/AN/8yGCOnDK2iXiAO6tHQt2qoPUk/kr87xbqvfXuphLI08VhuNMRMF+auMrzVPtVIBeT/zS/fhsrEHXnBm4GaD9XmKHfyON6cc06PNJV/riuBo9N3VaXQlyvj1JYm9pM991SrKhM3ChY0b622YtvohDTvCRwZeDZVpudmRcp7n7jdlpgtmNtquch1gPE7M2ZXUVNpFRAvIs/uidCHk149VV928Z3n8Ze2Ecaoa1n8XbehGaXqS67fPrVN4lPlvNjluSX2kjpeuob1YtO3jdKwYZSjhrFaWEYbM27AP4/p3YnlGbCH2KMNWVpTHKDaC1b3obrkZo30MnjVfK2W1gcD1BOtLse503ws5aP0v4SFR/2w1hkTP3RXGlvGKmoYuD7FyQsn6n1mjW3ZN6XQwbrcAcfgquHSNlCnPFeTk/p5a1dV3u2ukNUvWFqYvdrU1PxGlOzZUsmhtcicV6p/NeefEKvSHLVn1t/Pnske0nzHxBJRt2sJFvFkbDQe3KIUWjHwqnTWBDdqhfCZbA/p6xeGk8a5mWvV8qxvdujcE48Brx26I32e1kLEYEF7b7MWp8UvV871H66ZXJY//5R46K7zY8levoum+C/JA3bX9x3q875YWnji0216chsNi2zsf/gdRoS3v1TD4x16qvnv6xLu2FPmploB+PtPw4Ecj3f31ad3z6d5IL7TIszE5fqY/JkU7r/ZXA59F3YydAY8JkNvB3UA1B7NFvzyBDxw+JzVlYiHVFOVpYveXWIz+VyVpbamfUOfe2olz49v1a+0iH8259yhfrF3/u0inKWydBXiumxhDjJv/XaxF4e0XvicwJcT9R51JwpXnpHONCb8+GHyrtOZU+bXM33lJ7/Dc7RviM9riJkw3wFdDWgWlYZajfVlKY6kXivxAE1ZPFlnsW3Sn+lSnFiwTe1wnJWbe2TeUe2jjsjW+ThTB+KgjRhJgaf6l9qI0IkodsivLW7XrSKL+imH4s+N7uih/cFyh9z9cYN3vIdv/1jd9yB+f6MTsG3H6izm9PfY9sM95636wpk6KZyTtpPwxf2k9/2BW+q4Hk7IuLWy3Fscp8GwudAblFmORHs24erC30fQH61PEMfS2d7WMd06M1edqSifL2srbjmGNYsOvJcD2rcbXtGnxB6CLym6mov0GF7zg9/0YrKlqhL3zU5pn33Yu74764W9rqle7BT1JdeiK9mGAh33GTSG+vISXGulhiyFntqcv3Tz/N6Bue9L/J5Aa1Tb5pA7bQ7xOGZwTw7zke/8zPN2cF32cAeE2Ee7XHkL9pnSOjl/H3j2BplzuGUrj9Qk9+HeRmFofeht11eeocSEYd/RsHMMaJr5u58v2ob+9we9O/VDrXzQV8vCh1kk1GlH+sdZDfQVgMXLxJupjhP+t1Z4+dH+n//54//+44/pcBCG0/8er+L/7A/+Xvbj/5wMJm/hYPQ2/e/ui9Zo/Ffk/fGv//3D++NffzS6hZnM4vgvmlp+eusKSQ1xtsm79bW8c5a+cW41HntSryqpi9kmcQ9yPXScq05ojfSRzWpQqFMS5i2piWlVvanLUqa+Uxlbcim5j/mbIUwtechwfrW0djFN6ih9qstVNtrtVTyHFFjFjpD00oD3J90x8DypiHHDwIG+HdUq0GtRoFcJXFsMHIdfZ3UJ/nyobaEuuLYifWyZduiuqeY+d4v6kvw5qwGye+tKf/dh/wekc5Z5LsTo4KOSAnfU4nVUHf4l6Bsr1GdRpxQcvtcbsoTa5TCZdWKfVwqaCsxUaeHJG068hiwFmjzJ/NaYaimaugqA3SW+lEyt0VbKxM1hinrsRuXYFSv+C+rD8mQLu/gyYPVUzmfJ759qnYIbUw3Xd4pBqWFk68qltSUPSTvQTbTJUDc027gO8TI4wCuJQaLdi/M99MwEYwGfWS668dNmj6gB9OfmTiwtPaM+7Zu4LuZgy+/ueprqVfXZ9SdJDQk5oW0ijmyFDX88a3QLL/Kg6b8WgxLVgFnNePPezOaLPBj/ldbCVR16V6jJsvon21trz6iv30gXqjDNXIfqsE70NcG8rfvYF2pnYRV1xBMFXnf/62XA91j09cVKa9elmV0LfNIyjvPqg1v4gyW0bfhneT840f1DDfrr9jupTN4t0u3S1wkG1BmhvwWdRD3gWq1LR0xq3xL4MgK693i50Zw0Vqgrzyxjhv2LOj7e84sdKbjO2pOF2Cl2eN4C7hfU5lluhJyU8JoDqYd6s8f6AExXUBUCV8YMd7nAz3WBdMbMzsIdDeeyP37XYsmgHjHFZNB2DBYuzhjlUR7trz5pwbZSnJtlEjYB12F12Pb4pYPzO2I5mx0D14tcTSpi7agOjlr2oBI3nzWx8Vp5arxWi4119SmDsf0i+5OvWm3p/6hMvsKG/pALs4a5fPkhJ+eBsFIxcKiWzHJCtwgsWM/3IuR75L++on/SlJ+Exns1bg3Gf2lyAD7Y2Ba/znGenOex0Hyv+y9d6as8WvrpXjEq6AWMWG+nE7oq5ZFzqzj0f8jSqI+zpiojfv1V4725RI/mZQvLC7yn9GyZ9ZETlwqOCDu75L2VTS/pe1f6U1O9iSdXyujfTAZLdu3nAmxypNUEX1OpPsux2JUvrddKyZIlrtU7xHtdOyJiQ9oXjM9gIPktsblqrZtFy7BK9iv+T4q+GcqwpfaK1qsmWq9uqfUehi21vWquK6XWa/PJMir+C9sjsW1avoN1BX51MKH+CZ4TfVur2gLOddGIgC+d4Vz5hjBbAoOMs2PqBR7DVsqoOfHnHVgyO5vW87jYXCs+7hf++1ssba+NWvGdCPZB8xMMbd9sT7Qa7YOujflUFfxtEmzlV02RFsCod+H3xd7IjSurb12+X4qb2r8bf/3r49lfkl1qj9CHJF8zIZuGPVMtz7Vnbdl8t2bNZ3/WfB1+eHa8b8vorDd9sspfL++VebP7tG4Oxn/Jg8Bvveph890ttZ7bpaaqDyzRjuyoE7Xew+Dbq1VqilWx+dwu2IYdNtfVtf3sLptRZQL8I/b0m5mc93pI80w1D2c7Bt4Kvk1Ofo9jqjxRmXuEYe/NUHewxBnzU4YXkF1itoWtb1fyk56CKdrw7WQX3FHLbwyk79h7sBfw2X1VWcsj9n5wL8CJW2I5Zpx3fN/XpKlltEJNDjiOoh6iv2uRJmnFt0Z6BFuLnhvh1JO+Ia/XyFFHYL0QxuUMno6XJG6IyoXU1xPGGe+h8tdLBJ89/ktTWwGvzYGTj/0+1vV57NO5FRXklbEjUl8z+94Kjvh1rlVJMztAbwRnuW8UfPgm5GIus9tT4mJntpX8GHFLo8YXUR1w1jdbtC68d7r+/6S9WXfiSBYt/INq3XVBmKzkEWTmwQkYCekNSU7ASKAsJsOv/9be50RI2JnV3d996NVZmTaDFIo4Z5898HN207u7R20BHj7q5rDycmvhTHlf3Ww+7Db0Q3p8BdnHBrPS0Jy13fQ8Wh+GxZmdyszZPfxC7mu4HEBDUtq3RN9g5sUh50qzTXg7/BqZGmHecjDzhLdaCG+uWqvOGXIzRy2Hefx95EgW58ofXwI7Z+W1kHkqz+yEvbpgCK1NrPqQ1XJ67ncmF9QqYde74r00H3Ob+FXMZzfROn9fddnDF+dgF2t1to5vsrePdE2vuO5nh5B5tlIrjlzjuwivUdbY5HbEqLvpN1Y94b4Hy+kQ9epo25qH86q57nbPwTpcYW1mXkavOXj7FvNv+JUexdd/k8bZAmfmr2E6q0W3FvPPYn7vxdczcf609iyG7EnmrtPZx5lnueGP9ZWcEayr/advw+1h6G4r2H//9Z6MatDVNtRfLeazi71a6nru59dgObgT3+wkh5U/OfS7pxT57uFyk8e1KXsiew/A2ewVuBivM+tTvpbFq/V7n/+Hz3iPat4tcLyfYdZ5T7qN29u8jhrZ1m1yRiKbGPjm5DDatpZ8PtALdqX+D9yCX8p6E2tp+9CXINPzGLpP62F7Amx4b+om1DLyOb/O3pUDMeyjfnr+vl5IzZJTQ9OejKee156hluw24UV1i2vT83B6GA63eT+qKXfCHfy2lu7D5ws53XOph8CFCYqfAS596ffSSzKXnGhc9wh14PPh11DmwEPdr3eRM7njnAJ3JliqTuv5gxyf+H64jGrgUNcvb710H/pPp1WvDQ71aeSgXh5fYodeuZvYrT9F/vUv5Y4UdexzuzJZ595i93Efuc1fw32extl3fI6T3NfG+ZEborViVz7byAE//WM3cvActJGXkMWoY3uDKu5RnC0uzJiuoV4cD5Pu5haW/aW64SWB96STnlbELT7qI5+cvV0f9ZjDfmI9JNcEe2blyM+SfWzefA/YUmu1HByimncP5zucARX2dc1c+TWNM59N0Y2Z3G29rq2N7kcX9OGeNxj3exNodID9FTyC7XX4QzRz95ft90tSS2qjrPH0hlzMbfUQz+vvkVO5sI+6NfaJn+7CeUPXZWMTOh7O6EtpBv+X0Vvh/SJ/cUqcxi1s5oq/t65RbWI0c/ismHeYnoLnxHCby+tCE4S6BD2s7MvdRaXya7jVPoC4AOZU37UvmKRRhj2yXkf2tOyzg1TxoZbBC7RXaEVZBzVt3V3nto9cFJjGK3KIA7d5YF8Mz6Ubn/Fczq3mu1+bpPCJRc0c7dOfiV//J8oatShtGP1dviQvCedH5+wCD8jAFUzOKznfqfWL0ENC5+Z4eia2cQ0OwXKwM1hAvyt9+HB7OGpvL1nrwCrY41UvmNl53c0maea2vw33g5znI3LPu51j+H40s6lbsGzdbS3W7dzCue2J74n7NEQ/Mcdn6l3XiwJvRv/QtrO+3nX9inpmOf7c65xG86r8dzP/3u+K12LgSk/z5nt37O0/tZb+KXthzrwKnzXSeeR7p7g3q2u9bOu7f3mN9RtrxOm3fsfMA65r4mJZun/ZNr+H+0EazkWX8WNfXZvXBu6INaj4BP4e96AeLsfYL77r3oLv8XcpP/EoGH7nHi7VM3x+tZgGeN5xtwOvukv83mjgc0uP9oiV8fvg7O9d9ay7ruVzosfdoMZa/8hwrosOLnYmG+CnslaUo9abVN6QYWquFfopOaPu5dcPOqckQJ8G7SP+/nc8Hb3OqG0Df+Zw/ibrtcwNWut9ffRj8pu4Dzg7eI+C585a7tHD/UXfA80M9ROJ21q/LjrBsjL58bqbeIt00HndTUL0j+PX0N4jnIlRLfmJ+xnU8Dx456SDzO3643fswrdH14ndF6tZ1E33K+haexNcW+EBFvkxxbNgrmENM6wO9v39w+szM8HjGgmhucS5Ch6geLmZev24ullOFzBvcL5wjSp4Fs21Q90YZd5x6Uw24IQBE394r+f+erj97TXGOZQGfpU9kczItJ5FLygeeO9RbXBNluM9arMImAcxGKn3gCWgNgqc0xa+ZHEV+1Z9E2UT6Jvun3vMl1trMBNN8Q4YCutyv75zs8kl4gwHPGc+d1f2oPLMmD0FtSzfl+uKXESeHfgze+RAnqVtsJykL1nzARNwszIH8ysW2u+FObihqNOImzveT+R/oI9nnbOErqeaxtT98rXuI7d1jVSnp58/DZv5w7ODzzG6Pa4F/B14kqIBGtyHr4ehm7XWQS/dRP51KDOsw79eW3evz9HrAXUa68EXzivS95WDOfTpjlrW7l066wqcD+znlaWT7rCfRd0UfdMmen56nNPcbH+kemy77j9jxoJvXT+9vtGodBpOsATPpuMuK5PxfOG9eJ3G62wxmc+8qc54Bin2q9jZ/Ey6jX9Cv/4TGSov29Zsmjbms0U4n3mT/rI6+zGveC8yt2Dff4y8Rh4+H9b9948jOHC4Pz+2/eHjfvz0Db9T2ne/9XvASjypjTDf+LwP/6frjzWbTarxnthv/WXb/OA9bLIOboHPC5ykvG5j8QTF+ck96/Nn7PdOpRzfq3ze5QTXkGcfNBdlvNmVmo/1jFnrptc1GJupg0bLomYLXOtzjroGn0UweM7Jntaf6hXBZK+50Zkqz7s1iDLWOX9zPuIW5yQ+56fvdux3B9VEe4iolpwF95XeFOuFvUv34669yTDg2TWpjPwwf+uxVsZzhNqvMlo+cK3XsbPZxF2DDdYvgkVd6ZMbznHNPeIPJT9nehkT557mm6A2uMS1sVyz53b9ZdsSvM1vXgIzc8Gfce7CQ0F9uwMX+NpVr1exFvD3E/c353Tz8DEGnmxwdA9ec+gdO8Jdf24fdU706fxtXkoeBeW9vMKc5P1k3Xe/kw/P9eYTYxpi35EZSD2NOsCYgA+nFez/w+3hWu6No9rE9hvik9DIzHkeAEvHHKlHro3p+3E+pG+9mZ3XExv/MlczPZHgP9Ti+9MTXlPqK8wqWvZ5Eb58iprljBrc3Xv3UHj7W/lcTX1d7Vtk5oRs9JN4csw24tPfOcLnE7hj0Y8TG6HPNJ5H7cVrgf8BX+VzvB9/G7/GV8wCQ+fjEuyBzen+2AVvHv3577DT2cUFH8KZVYG/B23w+b0R9+T3XPuGdGpnQL7xFGmvg14Zl21kwN/k+7EHMnvwNs6wLz4NS33S0V5TN8+jfZjHTqqc+u88H+NuejTzoEeMSHoB8UYg53oDPBtYlfY2C+FHS71usCjs/4lbwifYAzTNfvZO7wytXyK/IfiqX025Xnaca+mclL0Hzvn3xJVZV7iclvpe7W2Jqdl68Yz1Kr2qdzXnaUmX8Y7nKJzmt9BPcupO9qg1GtXQ2RwFj55yzZv6lPzGnofMLniA/AmTAW6o+P/hY0J8VXWSfgX7FJ9HaECgpYyzyrnfSVvwDV4R98T1tniN8G6lrlkv9HNMdd8cZXqdtYcz9yUwvYjTHJoZtXnNl23rvmJGSIi6T/Gt8Rq8q5B4NNYt9xSt7Wb0NQnhoUJPlOl6uC/qIJwlJk/BzYxGp9lA/8BaVXWgwRKadqsX3a2WE9SqwG+hZa4EzgbfAzyKXTjN/4its5brCk6yrOm99rjHncFRi2qDnyu/fg6Xg7VZwzhnUbMnyxa95bBGi3vK/g174QHZXeE+XRM7494B/BeamPTsZgabm/w02NzLe/51DbwevgXQvnVnP4vvgP2+nvJ7KF6HOVXQxYybeNROvJgn9cgfXKC1J74gM6xvFn/jNSSn9hDOm7+iLjD1w5rYQ8H3JD4mfeH3dcjZ4q70feGnQh+BLXAkN6N24gBsXeanT2uvl1yAJf5u7sg+Du+nazKBNzj2+x7OlPX7+H13n9wM36x1hi9P4gM3aw6H7vj28jqGN0vurnPuGePXqd03WBeAAyHr7wBscIUe5rGmNz0Ga+I4m+RyXnubwFnLHLR4fr73O3K2l7kj1vOa9xe9V4EfSL8snk6sB9j7NKt9d/Mecg2N16/tRnvmjdfDW2sfLPM0gZcGcLeeh94st/1cuR507OvcgdkFmXfE9zM1SCJ6JfZVnNNubc+GHriydDrXlXyWO/qowCHX4750Ou/0HwLe4Xj3ZQ21QuMS9SacL7753jHuNDJitE69NLcFX3ryj/Yu7C3HW2JP5b/Hs7Qn5up++Z2fkZ/yXMD5p591i58V3Ss/64e5FoJZtjZxbSLvBU5Nt3GPvMYm8ZMSF6H8GRvEApDhy3v53F4Pu60LZnvwng+9BrxJ38PlpPid3uwS8PPan+f1C5YeemJcR+jZ66hxia0ZPAb3ejmp4xyIfF5P6NF+Fj2Ax+spnlr0mPoZOLN3XpdekqLv1j0HM9hKXPPwXPO/H54RfHdzJsq6B76W4jvhbA2Xg3fFPgRLZG+NLLgUfAY+J8nS9OIVwWhLmkf7LHH+JntA4tc3CfbvrtHQNXbBcvcN37E4C67DQHvpUL7/Hntn4st3WvW8LbT9SVeuTYD+xEE/AdyDNeqRc2yukzyPs45ei4bWvnj9PI3I25LZd+g0LqHzkS6dzk7X8D5yGnvkYAbonXopcRJ5zeQSOckROsFV10sTXd/Yd0Of/etPzJP5PjzjZ/RMk9+tXqIsuYRd/S5OJ1s5Hf0zMHHsIU2z75wwyxptm7+GKWfUOgOWPZ/z11pytv20nXHxd3m2Rz1P55jtUi0kOjydhYkeQjOI4JUE71Xye+F/1K2iHoF/3FDnXIKfFLkxlzDjDIA1zpSzasVZux85NPlBt7oRrzbUGNU7z9baLA38qdTj2eO+UnyeJI0y0QOAbxuAn4l6jTOlw69+pwUN7r+ez7Zfu+a2XxvpHp7Q940+cIWfVneTRr0W66/h45rEfc+T7qYaZLLuoFOK+Vw9b9fDIFcceRN1r0Oeuz3UhaiB4EUxa8Xd9FXP6HW5DlQ96gk1qM7BttKfSM6MzJ/wLE0qwtsZr4OpYDVJp7GJu+m6b/re+5H102gZYn2jR74nfrJBzodoinGvOC+uAk+KiKXLuYQeOAYXi33U5B9yzKamrlgYnhvwTXj5yHzfL9UC7An4XX8Gy1Ye2LyouMDtu8gBmLBncdd5O5QZ7abIj0GtU4c/JfzYbqi1V/Cj0DP+E1b9pd7lniPnMdbCkRwCYDSvh2HQraaR37i9CUeGvmBhlj5x/56Dk0dej+Aq/Bnti+g9+PQ3ffXUhy9i/yw4TlmbGl/zI+qNYTFPY9+PDM3YaWqPMl4HPfFIDOiRONG62VyjOp+tyG2dtC5FbT50d6YPLWarVk/uPwGzT4Pl4Cg5XMAdnsrz8M+1rtZmwm/5/TM0/jZ+79eFr9g5CFfF1s2lWrlj6sP1+H3sjMiDEB6H7fPwO9Nc6gpb/9XTUPe0uPuBbJeSfn3DvUjzS6Ve7u2+mfdeZF6G9b/qzICFnRdOeub8n5hsq0W8pzZZIEckSi0Osk564DLNWLf86TtP3juCSTwfPsbP4Rr3UuabnR3PM/Q1y/EwePC51PcSzs0icb7js//eU647qca12SWkH2Bjx/WacSZBXw3tJTeJ4g9uprPwTuMBIw0w180MP3ZyBA4SssdLMz6L2pthD3/renft+76568MJ5/Qia0idgzOlhucKHnmHX+ZZ+z0eOlj33SOf89/hnsHz4Ys2H/hlbO4XPkfJj3Pu1yuoybFOmF22Vf5Tjf5r2l+gdse6II5g5w2r3uCS+MlBfwZ19D8j+90w96+qZ4C93pajEHTpXXePq42KrBH9btpToDeNnGrad3PtIw+KSzTOgvk1atF+DPwanE71PjN8S34e4TcI7+gmevcOZpo4swrP1R7wHXpJgBN11plUZbWcVaUXo98BuR2xk9L7IJg3nbFbBR5fTaSG4nUBxygSXzbD84Cv303nWxvgV7zXJd8GnPWKa5xW/vQEXjR4SsNtvlyRFyX4iPJt0jf4hRZ9UQ0/A36O8bJHfRDg/Mg8zKF3htvKmvaVPIhBtJ9VyeXKGnnYI3cAmN2RMzY/xJlHLwA81+JlampS2Uvimic4DGpV8pgWyr0gn0ey2Jy6zmQGF3gbco6yl2siuXfUYlTIv/dnPJNQl4jWM0UO+nHlz36KFmZmvDnSgLwb+++b8uw+qqHu7u/jG9fYMGGPTp77IUFm+pbrABzyQwSdB3vFAfnbUYbsZu8p0DNe+mjig5co45z7BL4pe+ht6xA5H7uH75bZNU5PWN3/Hp9NweXYy775jSr4Q/C3+MTD/7QH4Qz8SLGngb9S7N1mbgT8gp604CtfkiW4cckheT6Y+csFz3Pp+b9BBxLViGXjbPrHrhFe6+k+vualZ4pzwhzZXu467yu/W+b7GXkUcgZ/8hx+6LFZlxmO4efe9vBLv9uaswvUVf/DXFDOtuI+vBjuQQb9SusaLvunEkdSe7vxcNht/Qycj0uSpdJTdBope8WsU9f/PoJHHtUmtdBPLvp394C96eASOx30meSsxaW9buS2Ml4j1Iz7wSWa5uZ52zNvC3vdtoXaUPjsD2e10STMqtSVCp+/m/h1zUNuXRJojuz3bZxH29YzeIdcg9sBv/tCrp/L63crr62+8bEpZXmIZjjQPV72WPL1TqHfObPfWA5QA5BfIs+x4b99Okctr5TPDfx1OfvVGaByR7FfE2++cK9Uzir2PNRl00cNjOHX5pHlBxj/seomAg637Jd6Zot7hdNFdWxwJZzD6DX0Ggo/qNv8tawhlwCeqeDTpk/iaSYcTOtbxjP+lOJcBu9Tn/9Nvyf5PC/X33P2Slj7Ja4N3keO9xT6E+hQbiOnegnduupaCp3M0tG17RUcP+vh6DRzN4PnyMycyVzbMj9rrYfqwzcC12E5+Ak+z5A+a+zzz6w52uGR2KHWJegvhlu5RuxZfME/oYMwfMwQOpGsAf8unfegVxEMP5LPQD1M+drEmOdyLW+Uy499aqFcTPIHrC4Kfx7as1/4lHqecX4Obrr8TgmX09dIuo1NXJuthXehmn/xV0P9rXvuw7/loamhetC7kVPzqaZrCa+km+L8stdf18qRGJyekfBTxBlp1tGw1zoCE/xjbSNnWBnzO5a8zHfEWdHLc61+1Ilj6Xct40jCA2ndVssQ64732nyGn+B49n6P6QU9Ym7gBO++/Pwn3CpAbytec/p6nevKQ35cas6y7y54Ae0HXIN8XGiMtCc9W7y6wCBKWh/MN/Q59qef9W+cL5BzzPcZXKQnlefTzF1Fi2V8ik3Px3Nmr3wXzOsxP37gL5jvT3yAGsVyPzgu1e6ss+RMsV5h/XXU9TbiP8+aqMzZ55z64Qy7Sf/YdxWzwL7m1I+GX58QY09NTZsrHpEnwlN4l5q9NeM6rcg6XYDb5VfvgcUPhXe8Wo6Fews+YjdYB+4kih3vFnYXB1zbNw9zztMZuMzSMb7CaRJYjrjOnVAHO2uTJXvud7xz1E3/0bMf7/HAHwz+yEOcaH/aAWZwicA99weXhDWj1B1Sa5l+Q7zzOUNSDkrEWVTjZjzdFNshd2E1r6M2euQhvErtAw6lWX/gP8Xwl+9OoD84syekt0DrEq3Ji8YcdBN1092f1sLLtmWvnfE9xSx54RTeG3/syzg/aW3IEee+VezDpmf6hN0Ai8Q+vFv5ofA29sBTbH/IOlYwPs4xNEPBYj5n4dJjz0J9OzsqVoF7x/NN+YFpv3wG1YrPsHSgm9yUz6Cjek4/7mvuZgs9erjs59DU8r5hL/fsv6/l9U4psB/jkzyqoQcb0J9/wXnOVWomcKnKM43bJ17As5wjQRczjc4pIq8dn3X9Tfk91JLD1yTupro/ynvpv9t97GXbep4t6q+eN/k59VqDZeXU8VW7zOvjV77xXCLPRzg6Jk/enOePeRRFXfF0WM15f7qYN5R6U8GK7F6gfBuzTv4Jlzvh5TjftTcrzwyx13G2WTfZHUGhadEefmf2l3vo2x7e3uPQtb1xlRi8cuPNzFi4pKZP/9O5yrr1Qg/Y35yXeC7m9B0npxrX8h7XgHvr7wtPWDgKwBT8yXu4bBHPtPnVDnVyPMdEl+ZNA/ApltRmENNEvYEcB+398D55/H54vKbNXLzX2SvoM+4aPR73Du7D/qIzeXXBq0vTePsELe57v8P59h2cWvL/amOjJ5mKBw44fcSAqrHtdahVyWPW60/Wk1/0cG3RPuu+FHUbm1D12fB+KHN3uMZ5nvH16WNIrILcBA+zzx3PFuq3bAZ6JfRnP4kVdxrAmi+qZbEYsNS/5jNDe9IENyJXzbTV2BdaqEG66naclc+eivr4lV9HrcCzTuaWacXuRUUdfuX8HfdUXwvvBVw/zh5rZPQPo/3g/vIeV8a368f43nZGz/36y6vMdqSGRn0MzQdyWrSGvh/u49fxcXxf3AQn5XfMuaer59FqOVCMTTQrBQ8CuqrOfdUdXMh35xnTOWLOaO+PPEeCA+N8cgesNeB9wue+y/xlOXPl2r6jNoiI+2NNT+4WEzN68241L+V985prNowTzm0fWdJ6EMPkfMfyv+aNNMksj43zFr22PC9k9gtti/K7pLb8afwOyVNCflBRi2RYd/2uaH3C5RgzwQUx6oXwBAL6AkPz1TgmfvU89WfMFMD98bLObeV3zkkbe4x3inbU8FU0cwAae/he6Jn3kcNLGvVeIN6i8AdA//kLzyey4qI9+J1Y08ClwQH8SINlWMKniVcRSwh84GqLnJ9DcMs2cHbVelyinX4n3+JI5+jG/Ch+D/I74TdETjj7yYv1IzHXQ3Fn0WEutgazEN9g6I3q3MvizDP8wArWV0Qvau2bWc9YX4F7xOe2XfaQBMZYUUyL9YLVWtr7bvuse0iP001KXIQciYR9MN4H/RPrS/COb616VOPewhoJXC30YqO5zDXpMVG8fqHfQP4idGPLqZ3/yT7CmtjOrSLfI5d8tZycXqSWEj7VEtq1RHjTt4bZV6Qfrsn74pkP3NYOXltxodU012PPmVl5RrXVuYnUuTz/wq5nPGpFZ9a1fXSBfXiSsRKSB8t+9W748lHmPZn6EXpfaK2g5ef+wFpuzdodOuDIbxMnxOzf+gL7TzbLC/le9AjpTm6ythsFj9YBl6Rpvj+wOv67qW24T7PO0Ovb8QbkvvZm4N4c2KNtq5vYvIZTwid7JZ1gVa6t2W+me6+SdBvn0X52f+s2c+mnyEe9JT6wbsxEkKnUqsb7FjRbRo/Yoha+N6iLn79HHbnWaBviP/vJJX4/smcPu43UnOm4juTAuK0DZuKoV2RmbHRRck4mznc+58lygBz6u9Gqcp/YKzdH5ibEj3QmAZ+kM18La7ikKRv5yTFy4INFrt2Z+D/xCHOupT9L2ORPns3oqTGPkj/j76AhlvsxF21U4RtdvJf4SHnrl20LdQ24vTepE9Mz9jbRlmE+CZ6t6FkCwU9zzJZwfmNdk5OF+jpjP3ILl9Dcyc/w/O8YHxjD9xI+nswkOiabDfUBPRGAoScOPLxKHC79DDFmDyUdZ0xNObQ7A/hMEJ+Gd7LMGZOD1r3/zh9Wr2vF3YEfpYW2S/2RCnxetGBb5eC6h18yL0edhVlo03DY7g/3bO+dl473BC4xscP9+Mz5u19NlzXxt6ZeDhi3b3qa2e0NfMAafSNxPlSlB6SPIdbdltzODLzEE3gVR3I8oZXDHB/3RPnwhqcx3Ou+5afn0VJ6fuHQL04hs8dKmnP0hXL9oBP6ucL583nehLmhU5f6RDFY1ofuZhFhvT9To7HWeg41fDWi/7X3s5gjffw0/t/I4zMz7lnP4/7NHg/3tzaW2emcHHHypVRfJHvq9DAMegm01+nS4YybOlf1VLqF8n2haVpbzFV/3u7djncjltUTzg1n5YZLavzVmzn1V1Gm2QSYlaqngcWLgD8vB3vWQ1ud3dEvnGeszGOJD3eE6w9Ppz3mYhPy0XFOQHfAGZfW96+3DbD7fQgfjG5rMvMGvdm8NXhNZz8C4x/Ubvx4tfwXam955uNsHsoM/Q81xscGmN7Lez5/vE6ftQr0NfkTXzgXrpHoGNQ/nRozzNZWwJfIg4OPdHrWeZHtX0L2Co3M+gIRw+EcKktwTqPXsJx6mQHjWbBzOWeTktPsT0taJvB0Ou/J0gNPJouzBvoo1fBMwJF4XSyurE1nfipa8IJDI8+96mHxneDrGPmi2Qzm4JWFuFc3wULNXCElDvRm50zgG9NDwvjhSHZZ1qhy5pUh46pztc/WOtdnC7xWr1LMgyfVBDw5qRetFiFYqr68NFMznimyDgZV4rLb1vqHrusfaeMWLJO19VZQf5+kNsCM90GL72b29402OQ+of4nXw72pu1BXNb8b/aa8fny275c1xQtCfEtwfck1Wfl4ZsApoo5iqHPDwg/h2XDB4PUySJVLw88qvOJ22fOHvhKojValOV/kp/tYdSvQKoScu5Jnq/5TRb4BPW/oJ0BPLNP/HXkmOh/VkLUtMj7a5/G9iWfh8tbbncitnFc3cTY5YD+Rvsdbu9kEXKS8uBfQoersy3CBrd+I1fUV83HxHjG6SN1jJqwTDVcduDV9U/atXLX1rC3kfBR9EO+tI+dAWNpXY3m2U81u/eZm5B6rv5kHDrPhbaHvS5FtOcJnX8ocRZ5xfSbdwy/BgkOd8ySirelNztBLr7oN4IF2vdv3wrPBfFnrTQOe1yY2OQ3GH8z4lAn2aPMY+r00Ra0BfmgAjqbbcoyXFd4P3AU3K/og1M/YW+J9CH7hryG5wqWzeds4rfzkFtjedPxt8jy+MSu2XcWctaqeGPgsw1UvvUptQE6b4ZpdgTHqHnR88BB6XnzrP48rqDs4Z7mJx43urRWem53GNaqNz6ix8F0wBxq/Nituxp9BvZbGKWr4j9Rk2+JnwOGiX9D8k+cb1vgWmDI0s3LGg2MUdBqbpNo4Rk5nh7lC0Bv/Gq4Ph+ChxydOURnfvfVwrjp5V16rVNPtVn5nH2XM6X3X/sTwPuBv9ctwyYhZ+cQLzuE1r0vf3qhFW4v9fhMNiHxmcK7C7uyodR84Gvy82McV81FPh0EVmnXxM0jB2bobrJl7nB8MbZ3vPO0Tt3jtUDhauc571QN8dgntPlNohd4ERypdXw8YieKqSVWwGHtd2ANAowXcIHQ2FcECJumfanrgLzG1b4phcp5ITRH2/WFgeh7R8HKGGbibkg8auO7TB16hesbm4kHWER7U3vBE6OWQB9d8PV/UX2feYCFeZK0fr9vW82ul3n1tp8+e22q/3lreoj1ree2F+JN1kv7MG3Tk+qTCJV9O1z/4bMQHzHBj8cvTekQ0yu6+hDkrvsv505f6snM1XlByTyb0ZR92H/R3l6/XbyH8Q795dLPmN2jhsXanc+gfG4Jr+dyLj/1uFVypp8JTK5dcU5ccWtzjHPXfi2KHmqNxgofDCp6P01x8xpaTNN6HaeA29L/Jk05j0WPrnmv3dlPz7E3+jMxlcL2r0+lispgvGi/LStLy2p5kRtdmdzfDNWjbvme01Pp1y9loNTJ+vKY/Qi8oXgHk/AiXu5SB86lGFH8Eb+dS3zDV2of+XXngUINQxiTohRXOuT/UNEtbOVT1OzlqOIfJ32owX3kkfO1/6cfG3/rWIwBnWd2sjz28YumlmAUlHl5Jr3s/VCbdpuEToX6mtm5V4KCKSZWzmxo13Q/BS9Y+vm98D28r5TdyJvzJx0y5CcfCD03uzeefK+Nj+Cz0ZPNnJ/JIuwVnS/efbeLH534ba4T4GvTc4OeoPz2518R6jD9enHlyH8g9wGvK/jLcHpTv2nRG/kb0re2PztSbdJbV2eJVtOivyuvCGXkLwJ2jzu0EPue15BUG/vgx8NMT9ONYy9bzR+8PeHbQNYrvDHmKFldMug3OY1lPqp5B5u0b4Yt1vc1KZ+PYdyO/k1usDPwZeqeVNd0D4Z/73pr84z88/5O74O8v7+3rpNvMDYdBcxzLmUCVxJ/803cH22Q5qfe3hWZUM4WHeO51reSFX2xCb01dLxvhDPJ6wBujSr2WuT/zq61ZYyd9MvckcTo5PWNEV6w/2+L1x2wkyrzacFvUTbHgqxmeZ/T5QeaprgNzKKyrifp4ylk0Emzf3Ish9iL0R6anVp7eJhIfw7r62qah6IzpgRRlHtbdPFzS78RiiUYzG2eda3wl71M4S+5Mf6azhiYi8GeC+QL7zYgpfdWydVkrq48P9R1mr2S9W+qj8via3zFTivZT6d2EL2d9WKCnHn7ixoAvEGXwNgU/Y/Jv/Lnhf8mfg8f/uZQhAe+IeuBXjyMf1zCp0kdWzwXM9QYGp36trgvvD8z3wVFSLjU8AHAO3upGtwTc50YeGD2LxFdKvFA3H6LtboDXcx85vNb3kVNFrXJZ7SfAH8y9uJe9MEdZfodGzd1u9N/R62KmwrMP+XF5kHnEgbE/lbzk8Pv/lO6T3QdW4vN6jZBVRU7/cR2opkd1t/SYwnMVbSu38TM9Lp+RJxj602/oISbPTei/bG+16rX5XQPX+sjSE4IeUNYjWa8D8PpMefx743s3O/Sfp9eJzqrRAyXdxuXFPMPcr78Dq19/uV4O5v0NYjUvhZcF68nhNj9H1/whQ4u/nzVLfgx2LiH8ii8eAZYTXfCFiDNLRon2Zbr/do7u/iF3EM8GZyN2nulKbx12U/J8kGcaFr2MedYLPyGtb1eayZc4nRt46eS4LKcP/ya4ywefJdxb+K2Kp2bjtqqNmdnJ+e3ceovSY23YKWceNj8mc+FQvc1buH7qi4wegDwbeiCiZpwvZh0z7zafH+sLvT3qixU9ooFJdd7jrHE3GB79SHva3/uFhkXXg67dQSq1kOjI1MPvh/SUkudX9koKatBIVVN4EfW7zY/A+Cm7gyq9QKgLnm7tjKDkkSjPiegLw2Zu6iKdvfMentE/Gq/JiF4OE5kHGT3E88Jwf809vESqe7A+q8o5cbOWZH0SW0Ud1arCX2RY+DZh1nmULBxgVh+q74F3h/UhT9VDmhja+Ixs1qn4oxbrfaif5VdC3SC+Y5ImlhMC3mnh5UCPd+UMJaxjpIYz2BM4Z+GSmqu71oo8T9infuEDWs1iFjmNSlhDTX41/f/D2TDstoGXPnMWWBHPr4J/FosGMvuMc3Z2uL7FOS96+5dt82nyPMXMr+QpwZ4RuMu3APkiDubr4lWF9wKORN/H/Sx9602H5IXMW4vXDnjmjVsivdYx9EO8733ky74addMt/DeSrnd8m/fN/nuJyMdhXaT6lEEaOJ2qxUt6Sf6WsVZO+R2u+Rbry/BTk25jH5Ir2S/1IpzZkDNLP1a3yj1E+SxYd2fZkzibKH3fxx7JzUR3qhoxephHdi6KbJ6rzBz/oL/+yo+XHnzYbT6NX/t39FbQOmENDOdPw2G3nwNXDJxTajw3gJkabyacp5wZYD1j7pYl8KUqca7b60W1M0am6MybLeaLem/h0MuJnPaXdf6wbsCbe+s+cJKu7HWwZqlLFJ68+Rx9c75I5i65ycmyeey7ufH6/aU+hawx5f4J16vfHYCbbj0QS5j5elHxFl47fZlVx+tVb1aJyW+q75Y1m6/coC+D1vbqX0TPOPg8rvzkLL6/8gyW9I7q80pulGgdiNNtsI6zUm5DJfHt3Ocus7JqTr4OuUeHX9NSfoT1Ul5avgZ6bWikd+TkWb7NU+HTTH3i5B/B8w02aD11zqMl9K+LYdkPLSz7WXaDU7JkLpt4ef9Wbz8+27nzPqXvOH2OutCzgvvAmebGzYoaNlimJR7HA7dNMwrod6E1tOrR+LOfcGbRJm7LPKOk+x2+KuoR2ir8XKTvkOv5fFAPAsGYtacxHtKbxLX4dGmufS3hMLbuHApfVny8DQ4teT1tcnKjbkm3a84ozrzCY+DH6vFsOfUb5RAVuLbkYwxZV6g/tM49NFMvAS6RlnMcXrbEb/OQulSLCf9Rp13Sq+G6DkWbxPk8Zk/0qR2tD1/yW86nQ7Y6bQ/7/y66pRzdEV/zxwin98Pao5Wk0n85YpOyKexi3JfsNcLlIvI9G+PCtk0sjB/jo4eAEtz6w/uaJTq64bhINogkCNy6QFq+QP9aVpai8swop3Nf1QA/fVyiWuuuUotc6ShHLVV3CUvcnRm1vuNox4gg3j5ELUj8jH5ftp5LDz+nkHHzF9pl2AWvlpNt6G9IN3+RKG2zZVkZI0e4y8k/RZQJS0qxhxc7Z6HKqHUPPxvaN7aIbWN3Zmzh79belRZAQhsE9PNwLeVefPl7hVUpw5aS7N+piSJhooWBsS6mJRdGcPq4wCrqqJGGJ4kna+2jGih5HUsZMeMZ3SpAXb4g+gfrIcke41YMVfFL7Er3MSqmZFd2o3Q/E0qrRFiWrDe4paJlrFcwVsVWVJbLCGz1aJUdQkZZ47FFacz/ixXyw7N1x7HegiQjfROLjmPkNK5qq8F1MlqCjudJ666UO0BKHEELFF+OrPnSysqWWIoNEHh1I3JYWkLbuJc5JUf2KBDJAyGhBJb+ArM+3JvS2AAQdffKkcHo4Sgwthje3VIGnMI2zMjJvD+vJ2tTGvh1WDy/0/YPUQA2Wk/lBr/fQ34NeUxX/rR/WBrdcJubvQbyW7beo21roDHzGPfgGpdKDB3FzR/2C9BAsgRWDBzxo3WBfLR1VzsR3QtV/iKQm2lHRW76eMzhvdO3bkeoGTJuzxPKgSZXjVw/f40FeYyL4fH3zPiZh+fG3CtjOSVjEmt9ZmQq5ruvR7TAm4B+cAu1dCVttts8cy9zQsilStdW1p5IqhOV5KGMb+yjLL3bstvEXdnWmHLTlq4JOZqbQhXmmEhjA7n22QKxpCto6g979NNwpBEpBaV3cXr4mQd6lESMh7RhR3vv7QN/UpfPAnq4XROGNqESIYz5is+o98ZI8EzkK0qHa7IcgJKSGgk59j8j3zftb6BWi79Z0wIFmhIQlIGesQMtj3cNDaQ9jDIPIznQLCTKTq9rabReipwXqEUsRrydGQ0YWMxEJNmYinlxRvO+THNGsqKkKaJS+HNGoiol6Vyp+20j5yximGykiUO5Kuw4NrAGISxgY8QWEt11PQz7u4eaYlsaS9qxi8hGtezTqKfEWKzfWJ7yDGYZPm9NS3uFtI9N28rYErDf4XXL2MYr1XixZ7lLWnJp37iD8heUfn6otsGL3uASON4OUMEwa5r3WvP8fD2si+cqAcRB6eJn69dlrXjdgmZnxwpsd4fbvCYWeWxdAbvfANsSnt3Dfhpr38qWNMaD5aVQRbVsLu3PEvPSm+WQaMEqJ6bMylPIqVSbAV60loMy2hTYjrXXNVimOuouj6IBQz2tS2Uuzsd/FD4yrZuJ4NqFS45uuObwXC1QfpP+ApoG6UgF3Y+ysw/CTsHnc/n2/RspgISzJhvYzJNC9XwcBm6j+E618eUlS3c8m91G6WzR85r7WbNEra6WfpflvNogpRyDF2dh5766VZXWnlwox1xaOcvvakrsRX2vM5subsbKg/d4y7gXyC9JeaSMPKXFTk1sqMSy37trfDf2elg8bCKxlTmKXYq3G/nVNOl2NPobdJnWBTWUlXJametiPfeaGldrZTaoyYTS2YM80bvHpX2S9fqNUZ0qSdExA84BrGfEU9RgE8ax9v9aP4s8oduohnKdqnHNE6tXgfFLlkv1NOE+eMT1uqDOiuZPSr8HdAFb8WsxnlmqDRPPytRQO4S+PhfLW62xDb1JrFJ6kwrrgUIuhHULqotIiQQ2+reYxd9JhMy49Nxvy/Nl4oNj7PuI/+mVIFWlJRcji8btUTKTEBrgiKM2EPiVLTRiozyRTd/M/o1IwcbNnBvSEwqd0F3nz0X0k2frahNxrvTjc2gor1/ObokQjLpXwHK2b8PYRtZiFVAH22k3S2kTaWP7/FL0Y3kE6m6+xCIOX4/Yh+RZ0PeN9pOajqHlHBVaaSExuxkJ2qd1JXSOvdrfEGKYkTbXasW9JkbeDzWYPiOoD4bR0jsm3d2JUAj6tmxyoLw0Mz0bY3NqtGSRCLwqo0VZVxXXR3pWWozsxUIM9ryw525i7Guigx5Hw9sCwu5nBjbkd3k4Wx/qe9gvaJ2YIELERrV4u0cZgbE9o7zoW78UQajPvxlRCQX/0WplY+yEQ40AcrPONnZo91Lcm/ljz2TibWREZaQw8hpin/GRyvlAmjnWq6VSPkhbrrBAnJ4iJzgJNVdG0krT0+itGSBkS0dUGuKGdjQSc1mGijYxoUmx6RwtKTU9BX6CuKy9QM+PGEnsdDLKpX9z/QzlxMiGi58x0ldIJRghKX1o11hnDHAuVmNbJ4i8V+TkjZvGzpVshR5leO4+uSQ+roPQFhMnJbQeOgngPJ4FrIMBCZOeL9bzOMNklCmRSQHsMwnBT9Q2lJIQSOxlv2rmGG0y+u2BUlSDvXgHa02lj6mM0N2n4ScILE63/w309R51d8NP6dLf+h1ODGpM2ZXH7xwynUkYRYJ+o9XrnNUJBqXIMaqlMmGRcoop02/GtUQdWSJf0gHR/oW+Qd7x6E4wlZV0o65NeirS9nqzg7YXF2FpNcDUh/v5LawJux6Isvwsy+nNo5tNs/LW29wLmM44m3/9fHTiN+nEZB7iFmPKQ1cuceHn9obtlsmuX68VS0Uo8mPrgAAUX9kAd9N6GaiNMEEGlzVRDpLJx8mM2dIGfGwlWZssUGkXxJ3tJO5SekRsr+v+PjHs8dSyKNud6bxwANyOJFkcrCTDUAIzB2XdLlGmJNLVk23/CGcmbc9L15R/b5igBj7hPRuB8bXFPWryfTjlv/HnMfmn6r7PNrVyItOknegUJ9ZrW7hNEf6yJRKgp8ka6VR8Taep6bVPmtAn7QG2lJDureu1uBZU76tu58otQ902Rlu0PIB3+sIkqwmTHpNhQLFGPfwbRqO6JZHlwnJTjoaBskDLqSxXbb/UdW2JkmOSFmoyOLsRShJ0W9fC79YKymU4C8CNatXENWNJ9JBGB4VVtG+dHpjT3fr1zW01CzYFJnTNNdgYcNqZFao5PkN4vl/W+TlyZmn/+QPPyuXHtnEPu8cLrt2ICpypMrnqp9V+vP4hkwd8p79MYkgBcwGWto76AtMIo+hFFaN7lCFy5Ekag7riMzlOpkAddd0uUpGFQd2HmzYcF8A+PbiEJsUhXxR5k4+onADz5/+995/bZ3v9mZw4K0O4Jnl5F0EBb97HJnWfyizdxqiG923os/r5ffoGHthGzqwupSZYtt47FNvyrMAhYrd+q5VgimXlgmPNuFP0O1A9N0/htrnH3/9YYjLmvSdu82Nww9+3iuSV18p3SYB5Wo/m1VPIzzJej2+A2+kwCfXTOugSfrzAYTexJaeoWcQp8M/7+Mgtw/SqcAfDRpk6Lw/rN0eC4TtYwCuwrbLk3ncrp8if/jf3qpzoc4k5CZ7Ze8K9pXfCazZGD9dvXPru/7IOHqEhOhH+2z0puW/zO6z27fXgVo+W8zoh1cHNvPa45BrDkpv/Hl8frsXf0uJNkLic/pw37rF/vZiSYuQH6wHW1nMNzsL7vlvNyuzrH29gHDRPI7+6M8+h7JmlZ+L5A2ynSrjs/xW4JQcBslzR9m4uhHqZnnVF+3Ojg/XcqprL9QKn2EhV4HfoGfWwOf8J7X/+t03YRULXb/+taDckpeco9+N4puPFOsczWGJohHnU4/RWkyBkbCUQCmAIMCg9Tr/F1ZFr/a/Je3y1qj+TzAjIBOt8DUfoOlPmDESxIOvXI9M6LNQHSPFk+7DqSWkuEM/sjj3pjbVJVRzuH9aM+TvUIGSkN2TccSpGckjh09ScN0dSkgCTRgJTneCmgvPIzYRFptNf+2wq860MJaFNP2spnOPswmc1rjajeRXPizgyuJVTeQ0iqcfNmqfR0n7e9ejPz/LfUW2w/zlvlPfDz8/2O+9bNv08Sliv/Om/PmsKLd3N2p4CYvPrZQcZgVp9OtJhXeg4b2xGEJuocJ7JIiSyF9BKFSpOvc5UKM+ltRlaRra0YAXzRVSlNwMV2GQd10AF4qRpp/PCFFrHTpVu4DKm0T3j/kFn7x9bqDMb5oy4h8sB3vvE1BGoTlDHzKkI2kS9BOmldOUpHJ1ZhxI6lPFCmzAXFaYPzJYnKHFPsWmPumEVEIip4TCKBLMFsJcy//lMlKFmtIJkH1IBL+r8gPd6VrD8paW+xRmcgNA3NLarjGedeW3AGps4O+2olDAKXXnG6BobZl4N11+dq+7iVrXZFO6LhDhVbdW599v562vlqVBu8nlAusHYjn6sm4+MVgrHQBnvnEb+hOyY/rN3CtyHGp/wsqQxfVJVz0v1saQCXtVt5Pg2l7HMaF7FqICJW3B9wPMq0KFRx0obr9eG/QBg/0SYHed+27h9t+FYVY2z9C59U8PURrjfrUV7B+e/DVKHyixLGV965xWh/Ur+cmvloY6p4pp3TFxZOxw1KbOLLkl0K+A+YF4zHflgAja/67X8K3ALiOzNb9jWFQ5Wrqb16fNdMFXnfzqLxxau+83Ihk6ahWsKU1xMqjj+W2r0x/dEb/P0Nse99c7JFn1r8OU9BVoFm611BVsv2Zb6P4WHtReWpD89X8OalwOG/PfaQpnUgMuoTPvOa5t0F6VnodgnOBqbFmd44S7srR9dF0p1smV6mjQH9kS30P/g8xdmwmiWdSQ1fwy3UOP6JiM3qH7Pj9Ckjj8xFrVJQ+MiEc2to98zo1Cy0fB3HNm4dVHDK82lxP7RZ0fqaAMb6UjJqAZlNAS1keOdhTm5sM+Bm04Wi9R79jrefLq46njSqIiIT5RSVjX571a4joEdXq7hXjLjbtU6Rt0K3BwyM95w91TzP1I6RLlYjOww5tulmSgV+1SVCRRE578N+sXXxWTK5BFZl6eg1mISGdUEj/sJn+NyDSZsPaiCZ5fI+aBjPV5naZxbHFtX/TTXVdxGG09vXnmMYv8OdTpGklA+cJ2zhzfOt/sBXI4PpTMJzPaKKvYMNK/9v/eUNA9Iq/kuqTVN0FjW9v+ZwNO8iptpSOWU/t1NkmlNSrqMJckYFOW69uNh/ubaUamu92uJHWhcYSQxZ9LV5F2Myb/gA8/bTd5fm2cr6jb2gORHc+yzwfoHfva9vlbMSL+fOKobd/TQpBc/ixspemqTuF7GRTSJVuvWTzWvA4g8JdRHWgeUPj7HKRYvwF7P1y4cDAh/RzWMzOB2X98Fy0G9pOpStRDwMDioPJnr7Mh1Nqw64zZPheQJDitwpLM0Id0fis+s9BkkJ8nr1STFyHt6Q6Jjz7JUMeq1e7JcEzjiyP0xCRPmPr3IfbJjsxfrzNJKi1GAgV9BOVtI4kdvcHnzjUudHY1+f1Av3cRxc+WHGGFo7aZ42FTdpjIkiLXWJcWP9uaoV1pn0FvoEAt1nk8XNeKLbxgn0FVkIpQp56lIYncHOIfgtnbQegX41takKIyQajNviAJIcYVPqsENalCDefEesZ7CtZhU4AwQb7UuIXQ9SdV9CufB38U9AxMTI2x8BqZ/lfctJCzfACHLdfh6nyWJeGDV4MQE6CpbT816k5oq1evPtbswdAWtWwy1BvQEpUnQgadE9ZG9pVw/Sf+CNBDBtiS1blq6P6FNqwPbe+SW+seruOeG8lyUKFpUulTjYjxozwJRnnPsuo3gHHaziji570j/2TMdSL8X9pEDUxhkhA/KluB1yng1e7w4cC3H6x+Ccf1lU3CWg5N1NrO4nyonJE1uI+7XG4zgcQ2Vyc3rBfeDXcQx42RjXKoF9zX3tPmAGxVrjft2kQiDte0MfmEsIekDszTMOtWoJ2qLuVB8MLI4091xP+D7RU5gHYRBnRtR3WpZ1XBQQR1zi2vTQt3bOUX9LN31t9et1N+DZNQ5bsfz/rGfdXbBfJAsfbhwCJYRcG+os/c2tb8dB2u/gET40bz6K54396P0+PGSVuAgBKqgdXCzDq/b1g+hDbTEuag3+wmcFpQISZUeIHUSGEalLypv+70xfgwy9MFWxWhTKNWZMVXFI91BJBm9LmdOt1k4mLG/Ik6t7myyvxiWuqrl4G5glTQBHG7UiTGQc0npMnBJx1gvXYv6raEJ0Oz9Dys6IoozQNj1smDJOr9YV4782xesyK3gTEAyraEF5EWKl3dOshQugKqs+axs4T5gz1OlLHwPu57zswe3TPRAyXdQD8KeYmJZEzX1ofQZH+YRcD0DbmFq5mDe8ha76zdZJ6zpqZCK74fLqEaK4EmdOs54DlE/EgOnQrNJt2hxXppZumbYhaK/UedYF+4WSG2iwhVYvOIbvr2Pr0m3g1RhuMNUTKIaKGkysoaaJiS2oUpbnh1U9PuLU5wRH72Hquw1TqyT56bst8sBnUlLI2yTfoCzBWx5oRCDnuBI0oxRIkOVNfKrF7oQijvK0brnmr7K0AzNWUE3XO+keFElWU4koVQVCEoRuPNsczhCZ00jM0HSMnDGnX+HyQfLCV3RcHZRAQmcoDbY958/7lHP2//sedWVP/sOxeiPbfMUb5vbxNnU+1vpyybv6JXTszlzQHkOlwmf/d+/x6wa3/4HLNm1I2zggUc4cYzclqbpeFTfh/sSPiX3UNyt/hfM2uDWxGk7x8jiZx8X9NW8LlKL4rlypAf9wP2g1OCPvSV+/6aKeqiiMnV3lj0JqeAG3z+U15y4cAM3YTq2uLawDp2IQ50rCROi9uecEBjXieknqjJS55QtXe8dTxzRkUi7VzoE1G1Wacozfs0Zgz3j7YyBijbTexjKp6REYC7BM8vO6LgPyVxz+6ZnodZXQs0RmvieKR+CwT3M5kxvgb2f9CC3QfeRGHNyFwl6uwvG96VnoKL0hrXvVtGbneaOh734JikFfYNLbajewyxZ6LhtgxWLA1ObKWAmZSs2tDQ4BbrVoN9p/VhUp5dFu7OYVtaXWdsbz7xZB+64Re9Mh8lyEh0cfhQ7lN5TnEfSMyitKjewqh44iAITeMFado6f8cOaUHQ/ffZi3zWJMerg0C7jD8aB41ZIOMp1LN0INKGgwK9ZQ2kPFjhIFyjXsJJoUVZV41yMHcy+jXoJr8s9kjN4TQr+Qo04H0+H7P+s8vy/UgcpJF85AQ76T+ogDVXGLT1SgLz39gz9vpFZ5qx8r1ZSC91X3dSYPmDJ0ITGjPRHfucak8GC8m4hqiGyg6uGVTxHCEPiNvyVMGjw8wIXqykotioahfqlwM+S+QlH6+0QomRlguqI58Ew0juVbxPMX0fbViciq9UrQcF1sLbexbD2Q4RpgMNpEg0VElo5CQcVNYWYWMTCXHwwzxGz+Kp8l7ktoe2om2VdN71CrAb2vbutnEZTbBkwHDCqJhrS4jh3IBiNuyKMc3clqsfDNbbszU2cwUB8QAPUecqRItvIz9cW8LoRZbPkuIOZH/w1cj69R298+dFt3ML70+VHb3JM/PivEdt+wlM6fhJ6TYjwzGWyeXs9DHW8cNfjLNdjJxUjuUTN7iZoZ3IaLi5nB9PqoKx6kyAJjuIQbGLCugK2MB/KUmtcA8AAcwr4HBuiJTQMjFPOpmyAWY4E8pTWGsxnisCIYuwv3w0MwPXcoZidQubVcspgbYi/dQyCbeV9hZAiaXlOoGLYEY0VgaugtSgNtZX3Tl/D8pJchZUbmBwyZKJ0RGAUre1uQYuoTXYrp/lgkGgpT91OHd9z2KVR66w02sR/v9qWs2paLDEkx1h8KiOreeITSlr/wHVZgOEMuHz3N9v2uTwz/ee+OSKtQUaJ4iN70J3Gq2Ae3vmZb1Vh42dok55+871CsFPB/qsStgfbTCHD6bKF5Oa1GtQ52EdYGovxEsOd9Djdlll9KLPCJYzQxaQW91UgLjDZyiNJPOtpRuiXoegtaYlUeQm42BhrKPxNetkIECYDuTa5QhoCl/jCqsczbQ0u/TpbVvvZwOTNZpfkVv+5rDQC32u0Fp3WzyUMmyB85diLpurcA1f8Hgzgw1GmtDCzrzXfxxTtGvixc6fhsZqOSJDGAFDIPw/MY7d5iPfeMZw37xCzu+nkPfBDZVEiJG1tVB3rqVyLQzxvvDOAG4ow3jsYAjXZ7rA1cxpXpdOVjFG+7DMwenwKGKLm0TQGSoCRTyOZtQ3r635sEpo6iHB75aSVUcnkjwEeeE+zTxSwGMIdbgoRlO67jnFvCDoYVJNmzudstCTjUoy2FD5BSWLNs+dsEVKMlPD6Q6oaghP3LkBgTirqHTX9o7E8FEQoT0vX7XHPbxHCjxF4k6VPaugqZjGl4CcxsylKW6o1UP53rfnWNaKJoSqDaM4p5+YKrPOOjnKcE9t1MmUxXnQ+LkFmTDgg8C+b3q6NIZCwqK/5B9jbgCZDNSvR/ZPUJ64hKCHe2wIN/+a5kTBiwhFo8S6JMTDp6nnpjy8oG8VgRUrfpGeCWLRkdFuvCnN9kzFdC+3br9hpMISg3zsOtc3YmpGCZ81Z+9/6z/2jBNg01/09z7ftC9q35eA4Wsp/j5oHbVUGoBq8ouXrvx/W/T1LVWkFt1f7PgIL9b/13YEYGnc7dVFOLbbymSr8WdAQ9DPPAWcTln8uBVJ4xoS2DjP1kxiagKHd1GCOFttPmHRD+TLyvVPcmyH8h6+/qM0YdABIluEmYiSyo6kRDTvlu/D3uzSoKD/TsqcuW8eEcAfrEShHUvkOfAbkTHflWVAKXFkVoEoPofMZs8qg1zrH3YqpOdd9E0qtAS1qXq3PrxqAkZY6u4GOp/utNfRZiQH5LbyV6TWEVJxg2Rdzfrf1Q2g/9U2Eayx0ClzXnblHDLi2a3I2gEnEkC1slQrYPmDw/ZRqXlzfKc1sUecslDF91doqPRuawJ+U01wzrqhX+LPKji9fW1KNFIZMsnQDlRaUl6gbl9XGD7+TImBpuqw21oUSbMGgihWU1TUaf/C9FjAKdpqy7jTEO84aPH/mVFBJ/Rj2ECQJ82xAb3Wa42p4ignJSKNMjIMEZnpicFSpxUXoF2HzoAgbV1W0GkPuJ2Y0JTSe13w98iVEHRC2Grzxs4bdxnlQM7RG3eve+2WTP3yPrSiXeN9MKPRZn60uzYRKJscvW0LL37nnPD9d7Jnl1rlvBAIb3Ffcg0Q9J+vyt3WGhia0Hp+XrVDANUS2UD4sB4B7jQpT7oeu9cLY55TGPR0hEjpGCFqrCoPr4NbAOOUSbZOK1l86ppMaaUCYvSnBr6Br8HmgWYdjqRROSgNcqG3d9z735ylV0FrHi2KOdJqo5u1Xbut11j5CRcrwNqkdWCNTyfaoMrMjFH6O0vhXaNp72cf5HHJ0MiFM+6LP1E+31Sf9B3Sucjh177qelUYMP93WUmgtV/09jmlP+Dn8v/6v/Pfm9VnbLoSWeHgDJbFXyTWkcvpanSz6Cp/YZ7Mn6sHSGOJ7vwMzPBq1H/vP7evqJs9p4MA0/dN7ORhH0dxd6u/55m8YKa78MY2Z8/1/+/6F1GC0fPgsKUy4TZAwatWgNkZtteH1Rx2x3xm60HfZY/A8evdwIXSIBZwxeiehPLTT3c95Kj8jcI4Z+dk9Q5SXU0trG93zHK4JsYS4/9PvTF5nc3w2KKI8EwL7zvXtfl8v5mHry3UqqWv185SVmoPwv75PJeX70vydBmu8DFeHl7+e3qEi5jjwun7FGrtVrTEL6kMoOT9/vtne02CQp4Ncy8/X6L/pncPz6P5B+uwP1EBYQ5UF3mMQ7UM6AwRfqHPNX8Pd5+Bi9kLl4NO8/HlLvdpa79EgfK5saZC8/f6XjNJhwgd1I3vBFu89qKoZX6MNZfiIgQbyOt5iJ+GmvAfN78BgpoDzAJv2jufRto5r2Bjd67wuhLklQJ01uYS0XaWHcXm2KSzftz+LP/9sHmx9lPQmT7L3picx62r93S++2xEqwtBTWnmvorTQ5rZUx4D+v3258nPTpI+voUajP+fNRvk1hrZebIG+jBrudbb46EyrdMM49tvh/LVSWSduazlve/PZvPXUf66s32pHDTes3kf7Na7fPfY/PhIEM8xbjZ9zrTN7lWO/V/zsyxafZf1NaQCvokhtNfq9Si6fuXkZ3Zrn0VZquj/d1wCQdg/BIpN7f9u8/LC1cFPO5w7Pin/tv8TwaHyJndk/I1/wKdIhS4Ez4Z4BRGXnlqPen1IYQYv43HTZymfLwS2qIRzYGopp/TFIoSgrnQ/vwTJEeNnd1FcYUX2ikBpKRnenmGPxTNIhw0D9oJaQUglFpYS8Ffc4cJuZfOYQ2BIDBQTatu4HGr44/Vu/e82EuqPvs6OCHoJRvGPYpXH7LpL7dXiQiNkwl+t6tvhY9LsnjCFPkRNm+Du6oywHZ0D6oBqSJtNl+JgJ+T4FGdRz6lhBimOSB7cdMYEYSkn38MsDzcxTfNctj9ZtiGlm9449+irgHWJka/YdwROatr///Z63wx7pAEIfihnc/x1i3N2epTBUi9VQmnX+157vTz0aeq9PPc8T+rDbiH3bRzW8sZ866euVe7Ly99ryeXIHO6ij3+bVW+R8HJNl0/y9jqv7aui9gKzLGuMtHPRI9V2M93oeX7Gf/Jy3Glr7iTTI7ktSZ41u3/FMFGvQmWGUWFf8oBq79SLESUzaL4qX7xkU4DSOGiak5tFa9yIojmpuS2UAdlWPsvF6CLorepXa7Gk4bzZ+bFt/mx4WeCbq5DcT4NCrrH8AX6Whc+s96a3PKsk49NNJ57XtPXsYhQ2D9Swd/Hid889bqKxl7xHajAQzkR5QeTPXnpQ17xZtacKs1GypoYfY4yRIujF8lT31p/5/qe/ld4DaNc7SXSjY1eV3dJ2XrfzsaG+fYZhclr5P+irOUdW1rA3z86Wayf4uw7wrb269BnzEjNnfnPTMfs79SN+63vuo5135371Pr1ko0m8GG5W/D1MJ5G4eFtXJfLatiqm8Y+gS7Nn5mTEeFay1aT6L0qnsZ8NzDtzrdzOEEu7/+FwPt+xJivG420pjZ1BdgX5WUI7v4RKzAp4124CGhnWRfpLegD9719G2taQLhi9mjHQ5mDf/kedBe9ptNZNgplg+N0abQnn99p+x4GbxusvxZQWKV/e7YIhOebbToGwDki+MNF+rm3BZ6UwXnYYrxvGtltfewAy3yoAAv1Mxxu4GkzChQ4qny5jcr+O7yZ4nfZacFe3icyccJVavwElWfn39GExcjAGHxKEbN+y1w1fdJ9oFhjvddV5nXmM69WZ9jAJBK5E+qsBhiAdIn/6n/ZO/I9e/eQksxQ6uId426qb3FcMGvJJJLHEQ4tP/5WxH7ksh/TTGjyXnFZ5Rj9S03iNWb3pOGzLUm2zs3ibSnc9YhSrZW1fKQIG7qOtO3K1fI/M5ujhrqnlMfGly0FpAcCjZlyrj59ld/95Q4XagcwRZA2p+YxDfJV2g18qTbsgz19VQ2WmlMV/cSvIbYqiFW4WO3k+eNxj3u+r0IRJkYElwkrurq4i4DFVmI+nLFSfrePNXt1XG83Zvgvd7i91HQ+cFhp4s673qzV+77Otv4VyD/oQGurZ03C1qD5Fsl9zhnl+rg1dreL8f518DzpsXSA9Htxz7Td/QgYRW8P277a/a6e7H9jvq/LWaiZaDiUm7Wfk0xT9GDGw4lnEaS+vF6xo6W3wzch8x7w7m5vOWwpTNfXEal5WTKp62VupBKv3tAz3i4w4M18yOw/lgXTLBBpax1wDL8kys9NykdA4TSglcqDzuJyGlCKS4Hktm1KSdyNzX0q059xFqu6HX4prZeWctkrCfrbiJwHx9AFzWftfPOKR1/yrNpWQG2tkhMIBhoIbS6tfxmu+hym5UkkzcFmuR/Y7SLUlNZc0gwaV6r4xUHxQ1dUEhfvmtLMeR5xqv1dfrab6f0NNpNL2VPwODXDrVNPIHaTkUocA/SeO5qTvpO/D+UJzzRFqwrTKEUpzm7D5ujMEPK/axbYbLRKQVf8Y3QT9P1AaBczOtL/h9q0L90Z/pdo5i2bATZzj3yTg6Pas70YkS80LGYkIQ1e1NMMugLD/oarBPL8TaEpej56PBN2WOJzIX8zydV/517XneYOa21uPn5lX/dxptn0AnUUehoj601/LxdS3dS8+jV6/dWcy8RnvuDVSKwx6FdLRCNoq+jLRSunOKgwecx9IjJPBTBiZwlv7pHlhrjRJWwediZ86DgLMzmnHrOsAcXHspt/VP6HtXwUonIqVr5ugNNjFdy4ilnjErWnVpKC4OgEvMOkJKH4dt1BodPQ9phWEo2uUANGCqcM46rWBY3C3qjdF2R7PoubocfeaaGJmEUMx0HdMgf3oClTjujTW8sSOukOUaf2scKiHp+YC7l8pzWqQkI5QBrmQrtyRBwLPnaqiW1IZGoszzUepcUOw9XEOePYFaKBhj/b4L/g/pa9gTfiEEEGeeBNuIJK7P2Sp6mR0pogvtiUErlbkRqbJ0gjHhTJTgF4F8dMiLeP4R311byqNDmhjqcNDC18Ey2ayWMw1YX4B6j2ftHjkfzmdnWOFzALNHvwrpBXobzCkewqsfwhFK4aiW4iy0YgauHI27EKmtCLqgSb9875mEhG4KCQnCIL4b1ym1MOk87hMMuD3gZ8ohdxe1Y0jLvCGVQGoAducImWhc87ZGKq+hGKm43z6tg472ad3CTYxuTg5liuhpYY6PsOOrSEDpiIjzNh3xLG7K/HSJwAuu2fasfQUn5Hmx8xic5rU77mt7sZ4vgvXrrrHot71g7k0WC6cJmeVWgp5gzk9ZMD479ldnteTZJnNyJ8wMtV8pd1gTItF8CO9TOYpQ/Cr8zO32ug8HLb9z7VOeMrshvOax52tonwW6qdinvB5flhazqU3KwRsvvG9Z4906qIqDZxv7kOC8VeKSRf/+ZNdzuUYF7jnEmdNFPWN6Eg2fwfPDMyMhdRWuv5HL2fQJ0qjHZ0efOeM0h9kMznruHaTTl8PH3t/mxHj/Gv/FoIscNXZA+ZSGuG2r1wiYpATYroOpkY14Vt4CqvPI71RGfvskM0rlCKFv34v9zOtt8zKkzcDHceRPOIezGHix9jM4niZOB3s4n5O5Hxhqqn4v4JKoZxFexyCyQmbe06AGy2EQWws733oINtmRMxhnDUMzJd3dWNcEc0jC8zzq7U4IBVfLHHXGQm0mfYvUSJTd5eIUKzKuyC+4YgwjhQxKPrNQ9bcHofLP6/uRuLWB7n8M51WhllJOj7U6q0YM+xykEmpPHtclceqPdjvvx4Im27NhA5wPyqzezLKMhBC1oQbfzAs3sqQwvr/Yvdc1Tq1Xca/dtjJ5tjx9rnR9klNi6liZ44uzKGXMh8DS5iEn9IDF3IaYB5Pv0fyl0vNffbp/VcrBS9gH4IaGZ86bS1j73YYyIRSyG6ahPyPO8MJ7AEusRiXpfiAQzlgQ2c837D19jGroU4hPZlGP5+FF9lArH4LTm+zXrE2mEqjRsY6q+tkLyaWdJXarG/LpGFjpnSO/URU5FCjzwFsFPxh2WycJOvdUxhPkJgAmVufYspXCI/4MqyLutZR7iTzik+zE/V7ILfBn6d1gkQE+VcXdqy2O7JlYwzsGKhnZXqkuBu+pXMPwfKgNaKX0dZ7UIgajs22p+5q58uMoNd3ZQOrljLwIYyNR3hcL6rdK2uS8LcnjWfcx4IL4HmxYjNTuqu+nlla0UcsKKYuxpwpKtbU4xw9SwdVLvdxXjBL2B5RzfMX+y6FyM8wIr+IMWC+5D5fCuJu55aAaN16xFqi+Bz4cH8n7vCNUqeB5Sv2voTXEoIVO7hlcClKN7dtScAule69f/c5tdc3FhswXp8MytgzskO/5egC+i+fnFW6kct2q61IvjnlzHuJzPR8ZCibcDWD+ag3RbQ9lLVRTBGnzPXiG03UTfW3ZrXuHWSCcymX/GyMg7aGmCGrpKFyma8zCSjWs5y3Strtn8GLL68w6r15r0Xc37wywIeeucCzEHichjC2u68Q3kr5T+vZ6sC6Wsu7FFZnSetTZzfyfcElMvRyAQ8f+MKOMIBWn0fpOw0Ot5NCrpIt5u+F5bhHOYTi8RQ+jlmTTXAJMs8U38IlXfgN7A957XQ5ZChAM7p+4Zt7Qd6A2EUyKyQ2wAuF56G6QBJAm3UWu/86fBacRqQduNqkHjrUUMfsN5xR96V8wO2EofQhpgqkrCkzm+CkUSDA7Or+qlFLkvWeV1+h32eSh/7GL1caj9KwbLssNwWM6ky3VvNAWHNdBbXCJa+MT3SD9KmZSO87x6cxNh/kydlS6zghWZFCO1ABmb11OaFER6l6vlncMoDO1xchtpaMsPnNtd8EHhRvyRxp2EyvntHY26IX2/LwSAGPrPwSVDoT7uj388hyeBScNcFLJcgMaitMKNQgC57saGm5mmb7Mv4xuYvh6kHqQGBZev8+asgjvrOo5TAwRspMzeXO+uMdPaREosx9zNonOAc+NYN543iRYVp2JUWNmqMuT9Qi8Tl8tCrOPTXhrHtRx+ILzHLYMIomSvgt131A+Czhn8m/dj7oNmOt2ssS4A/O81/mStR7ks3yDi7pwiBBoRu5TbUXbTFyDwi4CmKYNOyU/ZMQZlOHuGuw+gRSLMqFZHjuoL+kezusq4WmwXvjI34Q/r5J31nqs4bh+/DCTPaVzEKsgyORVuyCY7bzggXS+9L+4tr/bN7UWezhHIuEBS1D9p9BA2+spt3i1VEtFPI831nTE67BvR0Yq/+k1jO1TnHncJ0dbcN1w/qVZEfSNvt7LQuEY5hJCVs9D50nvVc71s3Lql4Syc9ag0MPsRLrOsHvONTSNwHIBImIY6FOUu7/r7BDQJjXfQ78nQZNz9LsNWlma51h56Aj3hbXbkVJFp/P+ZiyRzDwQrt2d2dxbLGglg9ltIV1vGwxzY/FOCQTbmDN+VPPOKwk5JOZi3h+/E9Oq8pQqR10cmnEusS74qEb+E98raHfaMxdh2B/e6+JJwsbbs85s1/FeO1OxktxzflYBt6d8HkD7ATslK5fX95c5Czn8Ig+T/YjfnbzVts5RipoLzylqLOheNDUC60ak+3KPYAngnaJtqYdpzy5BpV5V/BVpJNlquc6F5028g+/J9V2boT62fHnyh50JgmWttcqrn55X0I5IDwHL2Zu7zjsB9mnacnDu9q00zzl+svK80V5qXuWsDfXoVPAnnDFmzg8JNs+PSPZHciyhFfE0EcdoE7CmwOEVC1CxeHOzqvI6vw+f8nn8lM+b+F//81xt+0mSinPYLfBjui9TMl+yLfXHF/c8XOxfhos1/ge+TyZ/t97yNcr/RjdxcplK/54W/37CWT/az+5vzX+26eC+TfvP27TfLPRFOlf/9J5f+ahX/P6r/f0EVitiRSTfda1S2qxlr7sJ3X0R6bO8z/7/ByeDdrnKNZZ/o3USbX1Fm0hu/etyt4Z+p79tNazVY29yC26N4jp0m9/4bz1ckzxHnRnvyWv48dZLW3GPGJezEquGhpnD9nfF7BY8pv77cbjC+gGXose6hHjBgnqD0u+xXkPdNbtE84bh/2xfrg/vTU3YT/Pcuf3zqIL11f/bXeeqgfHm0H0NS+FxIwSQtiFlp+2G+7ZId0NwUZxGpb/dbYbzulpE9Gm3IhyvzjXuCM6JvffH+wffe3R/+j6q/Obf14f85WrvLdcirvF/uJbF/Gv+79cQ2hyt9cq1Gj4TaoW/JaHgkXsyIldJbLBRm0kQY6uBHuGBgyu8qTWsPrA+FhVvPFtMFv3n9nrqIb2GvADh/BheHM44d2Nff1jYQ69/9Jp/UdOCvfSvYTN/v17i5yd+Rkhvhzqz/fQ72PfqUXfRAJcPXL+oxjV8k5SFauPH/qTfoX6CBB38u5+vxWsbq43+88c1zhZ/vVVo5cfZGj7jyg/rQ+EdYi+BZeGx/9zP+Rq9Qfrj/Tj8ObX38Hdcc3sf3czyIS/yPDR/x338xEnv/136vZtocM1aHjTJdfBzBHLrz1f1Zx5+72+ZOaXncGE+W/k5Ig8AfMvh7zhMOAdRo0xVdyl8y5bhV4APGTHcszY9DFVPoVq/ZNTMySUS/pCEuhd8A1gBzI6q0asm7Vkeb5sNaHaS5XRLXk2ZE294HFpLlXCNYYmTcBQLg6rVi1p9FzBR8o/T9aNFz581Gm5GSz7of0+w8GYA7/YLv2FtbEXMrMzoqMtpSgyURk3XzB81ON3BRvQw6dnO8iw3hBzC4UJ4g58svURfEDubtbW8QhpYezJQW8LX8a11f/Pr7/rfcu7imqCXB16IgPQ218FQdS+YD+5Qy2o4JjC1f+ME/QsfqFmaOQv+jeBq/szzkXUg+ifiq2VOCRMzBrTikvlqYW8DTXCA2rYK7kuC+3gM/Y5T6v9p0cwAVOmBZT4FHTUwKnNdNSEPvB8+n9QXro3dBvma0dbavDzYwljrRthcINlkj/0Bc/OWaGPdlsWZCusCqzX7r6xBbOqP6HlK6S6o9RNJNgKHptc8qYXb8DPnDNYetPToPdg2fH0vtbliXY90ya3hAshZALwjzjpZQps5BIt7x+E0/7QG19Z658FiZ2usfKsXYOF94G3DEPZNm5WfHFRXTczZ1BXSl5SwTNgS2VSugksBS/CgJ+sAPKzyuui7mzKGyedGuDHirSBcRNzfxi1E2qPyforZh+ERWj0Yngv2xRZHt8kr9Yv0mB5snCSZQ7Q21IeKDYjYQUryjOm9wjxmzENxDRFBEGhSHT4nvrudd7qVU8G9aH4v2yaPlrCzmf4VaNA7v6vc15PRy1srMtfMK8pWZO2yrk14rWbfojWpSe9TPbOmBVpb4zK+UEqis2vR2l/TMreadL+fys9msZcTqzkbjCDQNRyUrJNeJIRZk7SaZt3y2Rcdr7dVzwD1qpA93PoHPB+q49f4HpB7tmGYvdE3QusdiO31Dc/2yuoFgbs1JZLAJ7fGWGbT5lWwZuFk4ffJK5c1gJpr/fI+vsLyj3pF4cldgsKWaj1yHveYQOwiyUnC9X+7VaFVhr5Vfyc+/pzX8QzukW6z6rXPmJeIJp82WLsVLVm8ymdbMmtrp5xRoyUOOBfyeKYlj2eAcAvIE8CeDetFcKV5Pr+vbvhv71zaW8upQRLBIXsUv8vInyHtLFfsBWsglfrQWhLb54E2ZEumJKYhefqbi/JWBJMQvobyHa8aKr6DJVRXUkJZY9xHtB5KYPmUGpu8/6SpUGve0ydPD+or7DkNLoEm5Ak3CRbQH+RWBtkCzx5rXXedh+Sl6ZyhZM/12doH+yE5L6W5mbz2H62HvJu1xFdbp8DOXsWnw8xGBD8W+3DRKNCerltgEl/O/99GXny2LzU2xmXLKcz+Xm6/OwuFFwPbuITRHa39yq1CF3bSer6YMbmbsnWu2qJ2YGFd4Z6v30ExLnD/jqIlLriTL+sHy3jhjZmz0XC8/jdLLbG5hEZq3hr8eIxUKOvtPvEwbUSHqStkD2OsBrVLjUGtFKtx5bW5BTgLYEFl6j+1WzL2sIaLQ3tnZ3JbLVuajCaeQKhx5Pebp7nb3E45L2zcVst8Y3yFpuY6utOD1hF6rz5/1t1Wo0BwHfB6e5wvwlGRVMUX1iWl2cK2QXxicGvFRvOg9nwHzE1e3hcfk/tY+KxFTMF9dP8o8QGnf9koEre667vJ3/09Yk/63/r74pr195X95ygKRnQ8f7CHAMancUcPXPM4845G5130CbtL8HxcwyIrcNWST2d1sIGKnOlwqDrCxGKX1Ndw3wqd1An9p5wW1n64HjnN0ywTzupDJIu7UTvLGNyw4aLSeNGUtd1wfh3Sst+vX5PlbG1nruRadGo4K6FhD9wqzp08ylD/MNqiPD8ibg4rvZG1SAwfefGavhfQzg4JamKXFhj/lE989eHvz99/P29lf8a8fFjyC7JeKyWNcum8hL211al/ju759jXSg/bwR9QiuNeR2nep1Z618yJ/77P97Lz5nfynZ/B+k7wUwfS76BycMS2mVSNdcTlWWzrpweg75UovEvke9GA30X7ZBNhMcH+zb3km4ZL4G9LfCvv5wmbRzuiKPkzOYGd2iWp9o2tfl/ed4DFNOdV7/Vn7XszYi3WxK88OWAdyzqxzwH/pm3HfPlmhJavT6v+s/ok329NbfDr/8/bfGKIJScDv3EAOSHjhvVs4/XdjNCUja/S3eKczs+shAlAWOMQRIGiAAMEIVY0Hx9C8GCi1KC7CAltCfI6GH7GAGFJIU5TLUFBJPn5IwhHfsxQlaCIJlcjIHLnIaVjfbI0LdB5yaW68mekSgDL83tUQQXzXJc8tVC9Abggqko2WQvKQQTIEbnV6kNOPk4PEIvPjDcPebuNkyJAl4YX1vi1iB1lAVIzXsXhwL46SR8L4RpMHcItqHGRpUQdf8FYdA09GvGIwweLZ24RObN4HMfTiKb73AFBIDOdzu4rhVLQXT2Pm3mQNLNoKjL2SLE0FoMOhV7/03QEEn+e3bLEd3QYgRWAjwp/3NEXaclD6kAUAcKcUiSmmOViLvUIUFWjc6WhZxHrGTvNvFHto2OIaiHedJ1tgLktCNvVGxb2WIt1k0UmmoWRffVrnjKeW9VsQVsRf8vO6xWYEkeJruzPF+hJvxWTDTDf38OvLOjf5G70iore4xzYatiDP+tVU/WKH5ZhK62PLPADG7ooXpJ8eI0Mkz4w3c6K5T4/ZI7pubDwqho4AUty9XWMYKFbxbJmcPJNJYp7DIlcHxa0hqFBEhyHrqzGfYdNs41BLJjZ7+MqSpERCS3wD2WwsxQCufw2DPo+RocH9oBspyEsA8FITrXqUAxkHFYbb9QrF/j4BTVMkIPvshEG7CBWu+logqz7Gp4cibvknXLaYDeXJM4JDAaLU1moJEcrO7iujgmyi5hVjYyZnDA/pLx72xKP3IW8Dn93k1yDnYs9cS5NXJSAd83KQe4mcrE8meEL8sIQQxubCNMcRwmk0L+89uH9FFDkzDw1Zkj/7ZAjdp9CfoNmBOQaA3SpixQMO/m3+TmHkWMTKghBJw7CAQ/nCzEqv2an4WcSJH3693FokfhhTyrIRh41U/ePzzN9nPK67n9Sj/WzzZv2uLen0XjbVeohEpxGgZtnIAX5HQSBE+sZ7KRewzoa2G/C6Gp9uyaKYYRh2IKF2epBhaze8saBjXiKj2kX4iJhzrE0RsZ/wHvGtcQp9RNB/ACT8Ehsrhn8AXtJz6XpiYFGAEPY1P9YArgyxZLjNr2pmQ/KomKE1D5ETVmhkSn/oExpieU4MwXiaPwDRFLP7JmelWuzRXQJ4bLBByJBiSUgxstasUA3iqNIaJKlU9pxsMfz8OcSwgZlw6itc5DHFReMv4rPCszcnYAsCgWY/WZJcN8SQZKjmHwJuqOgvdFv6Hp/NJcWkRwHsc8m0CQaHdUR0x/qcqYj/m9kfXRikdtGEAESHMKFewbDWkETibHG00c1fnq1Z6dnymKkV1rw0vj2Q1SAw2wsRSchXczZJxg+b14LZGSs/OUsDIOQangt4XXfQDv2JCENg2AdgBGTWLc0UKtanvDO5mLwpY4IX1wAci7evGERNqjHI4vupIV+DHMTiN1h6+xUE+XrtsbeHNJCF6cnihPNCjfEKz+Nmbp9DWTMTnM27Fz1LhtvcEF1hJpaKCegVxKSr5plZz35+VzTkTnoXMQLNHADk01gmbOYbQ06msFt+D0TDHM1DoGRINBeJC5C3U0X+62jbcsux00V2lBBsEgprRHQjAhjuu0N5RjQXmPmtsm6j2uCuIr2znp87rYNJbqRYO/v++bVtjLzJQuFZCyGHj3OtgxpCDQMWXCevEO/YfEA7IGPmXLDE2Y5he/1bSCO69KhkbdZvakRW3q+sYJLgHQgAn8w1WRs8fh4R47k5CD93m6NCcMzk9ok3tZCcmCF47reTG8Q0v9mD5Owu1Z6sR92i/tR7KgJV1LYdGk+wiQL5XIxOx+IPnn0IgJVpndWtpmG3w3M3Ys6WJWJegj0JtpsgS/E81GGaDNPVIItPiPBe3ar6mbw1TCLQR8TIY3ZwxvaHAgTzu3It8++73nm0nJxhNrTqyvki975z4pnYbb1zQLccqxkbCZp51F1c/j/e3qw5lWzJEv4v/ZpdVQxCefjM+gEQQzDpACKAeGOQIESAyGQS/PrP1nLfQwAnM+/ta/1Qdit1JIaIHXu7L1/DPN/8bOfsfx/n285z562U6WxKu8rGRMXrmY/8wq2SL3MERaXnw/O85j7HOmLq1XxqFpyZArRlTUrgciukdN7rFr8ja1vct75Pmt17JiqJZB5X5fmNmSuCQVmWpihcC4mucw5oWYd9VFJrjzVlJOZMNp4exBQrPpe9lhlGqPs/KplDe8y8qi8MwmbbLsHOlhjVYO2g/wEB8EKzqpdvkwvz2xgEvcvTDxXr/EZRaYPCCvc3dhjM7PG9mD0shISZL5/m2IMJiJOw7jKE3HVgzlQr3pm1i32UBlKmX/oZ+5/hrEMyBT7qybNkQIQrJ/JRor3JQ6wnICJfpzrMp/Fzg8SRCw3P5P35vOPZhkFWNF4lE5jBhMip/V56PbMVFLbqpT/GaugC8TKAtUm+u2xRjOiE7wJ0GeDHZkNZgTMGHSLK0O9W+fojYk1KgVce+zG+63yzPzgx2FkIlqjFx8xu2+O5BZiGAQSy3iejnjE53s0kG29pMriF2Arib0/yNjfmLCLJ9ZTuWY2QCTVFmJ3ReF3F9AC0a93+m+aFCfkdhLTyj6Ba2803anT0kkEm5+c0871CfYT7IP/drwSVFcgDPZtLA7AdxOoRch9USCfXhIYMth+2JhbfapiM3PrkogJeriMhgsjvCBG6mHfPtjHc9rJF6rU8ReTufkM0stbB+EVNLtmjTOrhUzTqIkPjA+SkSWmHvu3MYbGXXUzTXs08h3HT7CJnixnoLiDmHdEIAEZOEFRUQXZ+A3hshA0Q0W2KRxWdACOiyHYeSy+hIBmxA68nO8xGxbX0HoulGP12eO0nA/0M2oNW4hUJq+Ns8WOeq+2jcfcjAtbUSD6QPzbfJJ80zcYwAr1rXfbOea6YhdknvuNU+xcMVCa5g4iNR+w3ltpPms/Knk/zMyiEE9N01FoQHWcTnA2mpifmchFR/UyGh8a4SXCvVJZjWYeK6R6wsqEZwh4iDSMoo+mgDJJPKvw3JB0vX3yHgendd2V2mw6h5TOYfBYCninjIK1TXqyASAUJr3HZ7Hm8J15vbdbH0fT9FDet3Z5njRYwRKvTOIr5LrPNQohJja4xSuL6lTpcRJdyZnxTSPQ+sJ/BZmFNbc1W1T0mYI0b5ZBNacyNOIzPLOS9jxFzwXrLQdL9+WayM2DqhvOsUkR/RxJxNPqW+7Sp7Stbg3+g7iqAmPQxydWkLtG9W0zFSl8Tf78fB9gz1+1t8/r6GVzF7Lh7isZNEY2KwZCcvSA0btT4td7fLyrZ66KB3A7J8gBJzxKitx1dc+WPyXjxMcXwtVJejnO1/FhEEumf5fX71Yq7qF7aVzbydzSO1Z+Z1+JwAD9rrJY0qRfzhP10vEvmcTF1XeR7VbMdSxbhOSWY1XnnmTOVYuKwIgziQCyqBEr84HAX9XlCMqfk2DAPSwaqJqNYhSyy7j/wemIgFW04OJVhqmamZDNTYKujxde8gVwkK3RZGRFU+mznWdL0hiEtFbcK4V/N78a5dK3wGqdribZ8F2f8YD+Pmp9Xf3yp8GWHZwbfHyYe6FPnGBxtRICu2YAycEIejWKsQV2u3fxSuMyvX9+dtwWGCuZZgJhGMe2yiBWkL7gyA7FOgX/LYEqSbVdEv4TvCQFc5t3Ho0ygyqCspvk0sjHDHxU1YH9YL2FQKvWMkkQG55Yx8CFJSQZNBz/AAP2lmBU2E+CaMFaKiCGk96tHf0usXGYeEGofgCPNxVQrjXdgr1Rih+mXDN4zFZOTVuWTf9fB4M70hMis9Ix27Bqb1dX4Y8xaZPnT1EpvBa7H9ue31FxvhRTWM88l8UxIi78FlZ2pW/8QfITPjP9avvD47PB34Hpmfw8z45wYf+v9FVzRz5dffv2G9TJDLnitCDHeEr0rxD4wgyKG2+ifJuNuZow1nS1iqH6c5Zscik68dYdrNMHesykI7hQXMWvCLGhljRhdPWN6m7PuC2/cI2FWATLnuE9jfckqCiWjW/P25ua9Xux11OdcCLSoV8RswfVZah4KQ2mDY0qvle8isOAzCosb5nnCWIj7VS/fHZVaPzHcQz62BpjI/lXzs9VBfj5MgD1li3rPah+Ct+mwXs62vRArvhP2TzEDWz4ZdtLjPThMRwtiFeOcioJCXOvF0mAm/rUwAuVJTrAMMbBD7p+EHThs04oZ8F1gSrNZuEGqmpIlW5fdijOtr7MqnTXU7Rl5QQ63mL6vgAFAVA1MDETYE83/5LPivYwBf8bv3Wcw1fZwC5PrZXoj/V0Ky8TMyhKvpD9jjZnd0WSK+XWoIxYnPLu6ty972WatF/ZrQbU4CGrN2rD6Xe5ljOlHqCEq7HuzmN3p/WEvl8Ymh62emVuNaADmjBfGhmjqQpr8Genc5rsxnOQPyYj+kv57TAKzzSvF81/Z+M9gxz5fj/ox7IUqbAeRZTXP9z/QD7Y3IlyTnGIQebIi9jJ7Rm9nh/iLenE9Ga/t0Pu+P8T+sX+ufH57OY2L/OJyT5xr54T0pbnqJ91LTzczktMCs6+LEF3m1zRmH4lY7VPwMhrHrGhSMPBDfrLJJAdSWnKdWVOaLOqsq81r92dNZ2L5O8VSdYa1OpEkZY2c+5h5fjH7tA5TgqH8r4gwIdTbqtmRmX9d31kb+oEPwV6xGTPzERFxjtgHTX2soVlD95s3OVN6FC2HZxXp7iNZO2LiUy/yb5VsY/tE7G/oeduj4qY9kp5X+muZu8k+kWQWMifGvr/Ce+F3cIbKNX4wl5c6yxj5r8yc2pzZ+r8P8vM4VznwM9TDNd6LRiw4WzRDeUJxJIJuusDcHc5FQUVReqEK65VL96WTBQlpmPvh5v5SE9o+SZ/1s4oK0G8d9POn5kNpsYIv7MT+jR7p3LqtJaZ1ijbxfS5GXPc+qh1mpR3nVGrmeRCsE3wL3gMhdjVAPsLPdM/sqdjHzdee0z0/RP2oj0LOPMe5GmZABayt+aVgzqrj+yhLUWZbMe9Xdy1u3jfdwwtpzO//vtC7/2kMm/Xf8cx/qEj32RirM/TjL/fS4eP9J1sUQ+KQmX8XmnRXa282eMYYPKEuh6ESzFTwNyJqv7keCdfwYpT5mm1Qz9TEpKSypliKP8uDTKVhKnh9Y1r+6LNdyo3huhgOK+XKaFD6bldKF0N6CxsLmZOMClsx0Cn/OSO+UouZm2rMOrDOXr6MSZ70Z29fS1MHKWkIuJYVxTE0yODssrcetK+D6HHrhbrtSRYXw8a7Z1SMCW09buatR91j7WcAvvS+CS8ITtKs9yuMKJh1D85DXFp2PkuXbpw5v1Yy36+DNbLtjckicQWtjWHeBOKsfO9a0Xym01xIYn+aM1pE78FyMCj+lO94uIqhHQVs+trIHpYzMrKmfuUhnqthvpxMrl/PPXsd0SfLrFh740znc8VeZpg+pznrlWuWrh9sKNVADUgbWI+LLXtBxyk6wTDQfH7poWx9h+x41LNimEMS+SExJPveAAZECTkBugfzv23/gt5F9kBvH/JNmiiGBpHemYNoAAvqShimS1gje88a/l3E4nMV0DeN6brMg50BqQhQGqi/OYNZTUfnPbNOczUaAhqxg35uj9cBwUlogmVSAURKZPw0OJvlkngCDn0+lq24yfxzvocRe+fDHY2jLqUtTTka/WQWz42Yb6vm1nzt5iX4Qwzz/kEdnwPRHIIf6Xm7n12uk57ticODzDvLHVyXHg2SYEQSrilmgHEJwhwHds7qBah1TwsRE3kGwDRtMWciCJSodxOpLWkyIde10aUJX2QMqZ34QwwVG8Zwl2eRwYZj7z5SZMG5f76Z0VxzFWYGDAikaQKw2DTO0lyY95K/N7noS4QUeIRSxTnlXvn1VDQoD8Ih6pbwQtPE0dkacxkeWqDmYR724PWiONd72ud18q918L3kO4kQtSB8uHqJ/97dmLAm/PfyqTMqiRFBjXvJT3ONXz93dXnmGOSU+Wd9njGR4/q4dt5qso8ofsrnjTjD4qQmR2ufH4P9c05hupy/VhCizxINUzDPb/Secf+Ul5Wfi1Av8Z5bGiODI/FmzBwHq2vL20dMZntUyZ6iOCvPcT06idCssjE8RTGfw3VUHNTVmEboIu+luMRkC4yL+Dy5hDDSncr6dZw++3wbnGHvMBiGksnnEK6RfT5/cc+DQmckmB/2THN+zsCNQX0PU+2YODIMfa++weRk1M9NEPAzEuyX7xM305hQo5m0R+ET5oCCh9o5pb8PCi7V6OaBt9l9GddXzg9zfWIJ2Fv5tZqHy1av3Wtz2TLYF018yOXyPkNvb7KUh2pQYzmSjkiMe8IzBbNLkua1B1bzFjHkkHP3znhTsBusTZ8banopO+OxfMA595UFRDTlufBzsJcTJ5N9mz17ircabWo02FPeLzkh7H1yac7BA65ci2Jm7u8GEy1forCY5kciEC0uv+K81aDjlewFqBGKm+jz65d/F8h8YDXfdlpY7+BTCAerfMZnNfW+cgw8LnBWegzc8xyD1hJzjWz9FLN/S6ba34hYUecOvZ0R5hnuhZ6XeM1vw3cw/V8K21jUi6eZ9/NhttZRnJQYhqu7qjDbW0+5HoWLMxuFFI5Ox90Dzd0s/4o48IlBLJzl1TIpTqdwVSBA+sE5+O1sr+J6qY/KP+JM387gD+1BljNSg3fifnwIPynVg/H9IazbkuvLXgaYPLCx6UXnrFzfHfn77VqukdRNf8wQVHE5L3vZfg3/u8A6BBZcTwVi/yBXl3xQvs8fLayj+iKZKQdorMEQrpYWMcuEM6PClriA/O3RzMb4u5XlbqLrKhplZea4+bEcrIvNt1jOPhM8PMG+kuM+aPjZshd+TnII98Q1VN635Wnzs7P+MM+DNcZU4zIGZq3EeBT7FgykEDDUU3NN3ZPqC/RM5OiAy6J9iPBstuWTGBj1xKxqxLPKhvnSwDAsZrCvTi7L7XtuUWxeWI9sWiPs8Zh9f6/eRwzXWcNkmSZMuewpkr4deOlO8YblOzigFGrWgOVgv8fc8YDw8SnEno1FEo0OOotM8L9f5ItVisAjjwsa3xSt+Zu5/jPHfYJJL/b0o/IPYOaF3hFBZmY+lFqHwE3c/J/XFOtOzPtqxT9h6NeusNdZPcR+iBfBm6F7wlrrvA0P5rMCMwf/0Qhk1AiPuISdUwrv3gtCcM9rW4S5A3kmy28QykxKu8/JuKlmjLjmWZ4ZECZJcEo2mYy7CIvTwEn2eR8RjG9HhauIYc8P1oXD1CTAiPNRM2PAejgK97Xqme/JcxHUYLjttAdecMZxwvAr9iU0I1zQrBWiY8HDZO59boFjAfwKxnAwzZqi92l0z9HI9GvYv6qOR/zIgNoIoMcd85lWHscBZ09LZq6JWS/JrNFNfK7pjOYE5HmawMaDmCoTTzZz7orhFc3rRQjzCh7f4lMMoZ8kANgTG0mosYYUGk5xo7kTrB7PYvLpAuU9I1PwWCpff6R6v3otxlmxUL6ROwPwObrkL6gwtBXVxVTonmOOc/ObHM0FzTIxr/0uvAony3I1P2BOAr5Dfo3/n1zcX+37rXgnRl40R+xqLWtnC0Pi2ZXzcjgOwZ+oIPgC+/dsVMQ5Wh5W0WOflz6P61czWxqwvNHcU2sP2Z+DRrdAw/GBO19hKjHb7hLlPhXMrA/rBz3KXHrus9RvypW4mf+9XpTXq7V1KuSs3j3NVaiIPgGc64kYXtOgkns8zqKN8Ja8GpV9rZ35NWhmJMHT7C/PxIwRSIsanuZnY56JWvdCtCi/a/vvytcfMtO1s1XHg+M6EcNENfQwHGbhpNlzRnRDrKsbDLwrkP8wbmJGACxsMxfu4u8mlFh7FP3cPrZBA3hyzkXISU3HD2NgswCPdcSaTdapw1ny9+FL/lrv0wBSQrNohh/PGmsjYgTP4jA2GECu1OI82eILZk/v7+Zi0mB5fylsATOacXM1vxRpKCXmBdgbioaHYmaWPMv17FxVtpjtkx+nhq5i5Eiub01meHamGptz7IfgA6WvL4S5yMwIHFtw3mrXdp4GYehhNeTAzBar+hki24uAu24Ni3NF6U2V1+DxW1YwzwHPGDMXw7XUfvFrMi6neknzDOE7EQ+Qs+IYVLGvFS9qhI15sfRb0tNr2C0MuYMWzUVHBezHf8xywgmaIEijwTBZ3S/OGpQpvCkxMQfeGiV27mlmNSKotNfIrp3e7jRvCN8C/ZMJW7n5O92PTK9EjY4zRRdtnp41PE+u4CIx2KsKLvShg54Jgv5hrdl8G9YGo0G53Q9ZMyzDYaE5DMMaz1sJnLZhA4NhodoPVzZ0mjNsNbFEINdfrUFvXn6yvST70Yj4hdE12fpVw22wHhdOT9GaKJdyIgaGWyPihonC2zAc9DP8nMO3XMnyOoj5AneCKR+1Ompqq5w7wQ1lDc42P1qTavE1qHZ/vq2jzmDYHaohA0yGxJjE6XpWPHu34dEaOHoamzkNFoU7g/n8fGvNCFez5Y4mx++VJ6ctGpk1nnU4xBi9YjE/23acCS64Q+OQ4RTUEFRWfniFBvgJZ7WytSb4m1ldamXVRe1F5BtmyAevW5w8aY9888rwYJ8ZmXFKDST3i0ZjWGeVDWsNrLHqm9QkNLb4C76u1o80diqIYYMYcc6ByZGTHe7k7BcuVE/MLfH3K/KHWbPZ10Oo8zONgqQ+BY4rPT/DklY8F21IB2oTmNhA0wAMv7RzMxzq7VCjALdnGMVukgvJMRPtooZvghuaLX7wPknPYMLWafjygItmtYvkPaK2yoXHiHizh4UY/q/jKxjunO6Z1Qy5dTQBrZrva/r+A0N6iHtj/17tZsud8mWI5enadSanPOdUB60G7OCuX2b57lU+i4a70pQM16x4JZ4laznN6+TedXbrSfUjnnakpYbVF9kjixurH60XPz1N5yrC3L8CbLNWUMPT7ALmhHny8Dcavit6a8wzL1Ij4X6bGXFlk2RegY+gn9b3UixtP8svxFxZwl6uqCHFlEl0M36QkvbFf7RiDQW1ARTsZz6EXx0uGYBe7+9mocwBNfCSv2P2RO0BgZ9p6EnW1q3TEXW9Z6kvb/S6Mkc/BlW5N+2xzuBp/p2YfT8PvRzuM+bosxwD7Gi24mrq/imq1xA8xj4Ba0BN7/nvNOaR7zbqDb/DfthdOk3s0/ItJ2b9MMyBVtz1cwzF4Ox+DgOa3FDCbhtlwxXKPKqdXsVczZ53op2yc+291qAZ4kY9DSwT3YZoLyQM7WwNjZNuwqBm5bOIxsUYEnV3NJJhnwrc0fD/qSdaBdQOeByVRhf1DuZcGYS2mCA8hpZyDlO72tBE8IewR47Xy0nuB3vqCCbw7nobDWdiehrUXRH4moKLpL4XelmaJec5y2MfagyZJUCgp+dkeLCc0BHPkzutGfdFG0bXP00uxoCse4rqyUZNlC0u/aBnW6rJL/lS2lvZ50G521nhpDRPC+3HJSCtdjVhQ3pucI3ABDAyHH95ll2Pu4lO6Iu4X20T7elhBJJshMcKDg74+aE1uzc6YznbXG2INRrB4JhG8dSsXeY5g+n5ZuW4LotrZVPMA2vjM2j6YOFUIzRX+btRYjRLk0H5E2cZZjomdHqeL68mjmM+AgdK+mLsJ6vTfPnV6lmtaenSeQly7bfSU/utWkjp7FgX4JkMLwzAAl5Tecq2P6uXbvwFTqWZD4GDeW5/Vo+dawDj+q/JyzAbvQX517e+mI55+J78bufYlUD6ZTc3fHp96Sfd68LNBhiuZblx8l2r0EIsTghzmuQOy/ZyF862xKx27zzDxMQWeNukIjxg9FXKCZCgaWI6EiokmoXwyX4/20PItafZlK+xgxmP/Z3/gZHgUoxgVmb/E6NKp21GrX/CPY5o5kp9Cj+HBHussMbQV20RpA3zf8M1YmAhtAzsubMnMQYiD8vD0zhjhbHm7fta/pLiCOjVhbdw3jmNpuG9gq/z6PpqOI3Vo1J3lhVDtuX/+T83Biv79810e4jn/7X5Wrwn8Xb5TwxWHg8Xzn9tsCKArohdTWKCOgYzNTAaNbNRbqHFhKbxNZx4PlBChCFW3YDqKsSHq1EhM8uXd5NLoTATQt9pTlLR2RfowxgAoOFRRcR7Juiy+A6vN06vIPOsIBbR9CcU2RCbSoKWEWbxMHDOcOpeat14fNK4FBdIt4W4hElbzw+BPyQBbJhueHVuiV2IqT/NMIbfFUYHleYBG+eCw1EWWhtJjAv2sgEWzxhYmYG4NCCFkzV/ydOA4zqXYZcdPvAA8QZiZiAvf181TQuciwCaiPvTQNJPZnWksJePi1E2hjAlqDpXVm1OLjC+8QfOAIzmxkHTBxMH5fUs171KmgW+350hij/M8dalJDmpq74MmJgwhYIhPKNpjEa1g36GdEFjHkQmSNCw4wZcXGQjTbuFw+T/DWn0Xux1RmNPsoYxjvi5/Poy6TjGmZXADwwDKEzr/R7U9Vmg2U+ZxQFFHPLffwemtybmeZHf94eHRgRLV28cMkivUeAJBVzGI+juFhU6Kg6VXCOmLfnF0YkUkoQNlhBzWQgRWFSh/r2jr5h/IOVolieQp4S5fgIjFptWJiL283TE9CxTrKH5L2gC1EZFjyCSgaiA9b6f5Qq3jqSSOiPmLAcm0VyeWqEILkxDcPWAvE91vPXIMkhHKV9vzUtME9u27symkQufJkxBGLY4pBtZx+oe3R2rAsRyoMOEiNL1dZA2Iel8dvRZ79omLBTh3Wq2qaHoKGAobgyISJgXY5qv93FXhKAW0CvvFxYsiwDSxIuRNNP+nqBCNFwPM2gHcNPyDqEdASi6mier2ejcolAApMyUSHHdUqK4IQsjLRJAxZ8KBsVGbAYHeRoc1WsA79Aw4/vt30GAzneOv/637scYggWksj4ibJrkBBqWuDOBoumNkpLruxMOXwxx5vWlaWzXKLKNoMATyGAospuNakxyNQ7FxjCAa3eAAoGEXpeYvCnmX4VMdYlGyRap8Pq3OxHZWNGlJB8Jqe6k+5OsiesehAIBFF52y8pWnhcYFUEIT8OWhqYw8j50MBAtqOjoGOVVCDNIk1PpsOfdS+9zPd+Qdd11Hq/ThF06VYOorz/X9C9vPRTGuUPiiMQ1ii5f4/RnuSUH3/4bEiXVYRJp2QlMRfTnAG2e06YCEAb21Hn+C2J4DketuQOHX27IaIutgU2QEfEl3YFTr3u9qVeMaQfXQmWT/twTQ2g31yS9llWQ6M7Myd136C+RBOw12n+IuQsJOJfXGGZTcPnzmzHv+bfJMmrGwrOqdBRDFeP0R3Oc5VQcaNMFKpwCR2FeBdR+nfU8qQjR1wO/botbBcixt1pBpyPQucTg7fy8856J7tKcM8Ygx5KeKEIpQ8zLukfTHVP3UgyV9BmXPZ7g0JwiaAwG1nsxY/LPS5CMxcABg3caSih5JAIJEw0RyPMkHdFV/zTbJgcawHmv4wTNtT8pSlE3yrkBpesmVRvCs6flQJOtjfPtNBfCuKLl9pZD8q6gSuRS5UDGO+r5iJSHrAxkkAbaRP3GRDjvPGADAkIxjWR4Dvda/jUjaez2eR0xSRgNjojENYXeNsyOGG4+x1UcQAWUet2UUoYwMAKa5JG27RLp5XkrKEE4ZS60AkB6YwQQR6Mz01JSe/6otJWkTa9nic9LNPsT7uGZ5wqEHFURIkGASUOuugF7OinhkzaFqedYn1EfKBayfyxkXJJScjz7V7PS12+WsF6X97SDIJN2ffdaa3P25sUAJzmifiZ4BHExauHRGfujManYYUD1M1YSX50JUM7pU40ofFGO/M6TAWEtkJQS+bjEhq8ZASwxoGrH5THuDUUErIE80xUAMgApVYQk55kKGrYCgP28BCkCsBHcSOoL6jv3HeXcqikYzPQs03fIfrbh0FkSw+W+iMM/0i+EiMfeUwbUi4vUgwmfFyH4Fk6TTRFCexKUYDyD9YwUYIJ7o8wxqIkQmgCfuiorSYv9XGXbxfXWlDfPpVsIDd41188ngkuaLk2QtlRnbyrps7JHGXdrIdog4Ysus+75wX61qFex7wrhpy7JaBMCBvtWZS3mi9jHTbLppC6EIhWoeMYlhw8k5ixGWSXYpH7PCQZqGOhKGjp7ivTvud4wLNqB7YPX+0R64AQOxla0WbOmC85QggaRcMHdT0ZzGLKtBIhE+jHIJd2rZ6Kg+4Pew3EII4LNuyZjzLbdvAokRBBeYT0mDsLsi2Ww9EbyWem7w6FrqgYnceldhl5G+LKSIcR8OduKq68vokWfvXj5ssZ8KvgDoaKlpnYYfNHsDekX7XG0mjVCpi3TMG0zNKCi9isqHDGE0FFfzbjYxziyCMBECBLzvZZehwzXJk0wSNJUoYOAkO8DY/oRmb1uZdPDPWFX2w5FlKjTAHGv+LmQVKwkEkHHq0ktTw1Z6GgsZ9eEbv21C/saC+i6oYCQXyHY0u/JfmZxhenge517O00SZGiHVI61fU5SJFj0n5UysJfMZFTySamO/MvEROMy3rsxMvNAXyvmdfdG6gIOfvcgAlnB8lrINCq41DR2SdVBgsNNX3SUtS6YliPS3BAafHMZmjUYcxkD3hvytFlDuD8QX0sywiRNCj0gsXYm6das2fC+rXp5FmxRu4PwHWWlV68VSFSvcmC1m+Sqp7d68TrO1I5RLkRfsQuS7LI10BqEQG64nVbKNKCUwU3fpgxwUF6vXdpICRMMZBdtE+zPMYehGKhIXxLruZERI710mnE0jnba75gExf2swufWT2EUQm7e7psv7ONLUiPCoHeWKxRmHKwbosTQq5uyMGaBeeuWSbzj5obpKjQZw0CyHIPwjbNiNmKP9wcMAJUUshZjmORYWYNAaxJdSLCRIQX7ZE0qqydrRxzIYoCL4QFFq+rybYyNjRCe5iTmPJmoIE/TGQqTe3FlZoZ0zVrxGI37aiDU0b4NybRF9C9M7wo2BRFzo6a6BMAfjyT+b0hGykYD/uwiIp0wYTrgVmuoJJMWkuq5P86Xk3lS5H5LEQ/T4sz17zwHtX2MZ1lxN9QQrJ2i3JCphDSbxPMphgpb/Qy9YbUaj3teX4/341nb1QF9eFyMMgemzqT7FexVwJ/2N+eHDiZrewxgJak0NKZQMOtFyimAfTUvLsXDaq3ZrzSXnrGJGHCOCjlJ2sB9LcXzem0XVZoQCjSYsKpC+mgLgtoXkwBs3ynu+8CLjOHNLFgXe/3hE6+HvCevwctbtfjWH/bi8Yi4Hu8fSe54D0luTBZjEGjO/FtjtLbYDPE3ajhgB5cwhkFPlcITH5yzpsczieJLTYxf0SydtUnyqWadX1OaJDazPGvH3es4nyClmUSjyRaGoKhduh8wpkCazu3PcY7NOfgRrHMyTj5muehjkQuTaY7GPjvUM9Eo/JNEXBlOpr+DOY+QRMu64mwSY9APwZxgpy73JO0oTr3yUmTvhNUe7uwMbJgeNjTXw+/Vn//i+fSFw98wjGYiq+AZ2tuX4kW92Df/1mr0T32+xwoEl2s0pMnFEO/XA65QhcEEEv9WmVnW7KOrO4Fya7DetQaBj414PakRmbrazBdweDhJDpiuh43hO4gBJa4HrjXwTqSvp83LlmlBOvaGzNJgiIt6ESZzH/eiaPcZX5dfJonl4Hpvb+9Rw4n2BqnTInykcSKFSybFxabc8D5BuGqeoYqXLiszhcKWaRM8m4pSQ5jX8fqRSQ5ztdUuyi1T73M7SwvW7GVBBL0IcbEptVN9IcQb258yhQI1W97MYyBCnSBFmiSp7xPIgWL21TO4H8jkRxU1r6fjrog0IbLJfe+xbtqOjJuRWUxoTO+IjdvB+Ib9QdKOzVrZvdLUX3ESY8yW+n4bFSZdv5TUKYahpqZZjFnPiElUhSaHf+D7vot5UsGQISfbaAfSKAnPMiCW/a2yevidWsSEOj4p0ZDW8tGo9qfD40NnntrbgVR2Bi6u5CwQvL4XI6QjNpGWhnNsn8b7DNmpdiF2bgi58t2xV7GHnG0WEIlgn3JzCumhFAeqLif175XMYpogNx1napbsMJKCikNR64BY/eORichO7n+UzJc7SaUf9ex7iBkMzlkrttIz0AVHKBEa5rxioE+CC9Y1iUfmjL6KSU61ZZPshWQmZtmDR5/dmiki7YSi6ahCEhF6rieu+ZdOIdB6n/hSb7c0rz/PpbFRM2cSnKR5FezB37vvDdo1zcsI4RJT8+ls0vbXOntV7KKWFdOnohhfj2quV2ffEV5l7iLzNdNjSIpk+MG6DXM0kBMvlviktRxJXgUzd1jUf9x+R8ELHc6A+npPMkxjsTL9FPqIexK0wWyUDG1E+/UzZ0mKpZg581KEADSBbU3q1mTr7j7iZ/L5u3JOw4QjLLKHlF7fpMX2Pzy8M12bOt6BmFicdzTiHOf5bPk/13mHMSgxP9dzQkyFPtSs/apnqoRMJCAnfuueXjD/lsLxzOtAOIs6bZwrntV4omXNR2tFW/PJWZMxaw/pwqg7cjPMRke92JzX87cvu+dr2v0zBJIQ7BhzjjcaJ7rrb4Ji5N65NQeSVTQqshYEudH0/8BZuN+OohXCQMa5aDeDMTNFpUqm5b72Fc9yzdwUArIc8M4F8a1ZvLBGAJgBYk+iOfmGSWmxkLhCqf1IyiXOYIMw5hvgvcThTFCDMUDibJS1hGCLS0f6Dj9aSN1q0BBXBd/VtGGX8A5oXubzNd6VNCQ9eXZHw4Bth2Z2FCNVZZ5oMHQmSPkGt/XsLuK5L8LYuQh/DRlaSLQUwVUtgSy1H6lBemXbz4Pwy575JbiYf29L/5mBmBP45ZTnkJJE+eyXQAjPzreyzzIMSD/b+LJbun3Pii1aPTFqDUQwoQYLWP+4RhVrtO5CCequxmmrmcq8XitIr5/ds2djDYKayApdjemjNRWebYDvd8Fj4L4y34QPCOdn4lPyDAbS81DEms3ChEH7CNTLBRUSAXf/NqZukV4rCVeJEk8Qs1bx4C2ub9On1WTFnf0UpYBkW7ZcGaZIVtJr77b29Gf3MOwDiUs+u8zZuWYqnJVIPZxOm0Yfz+c82tQOMkswBml2XisY1sALz5FAJElArhjcnRjJFqnMarYisw+P+8O95Zb/Y9eKFZH6mBrM831jzfzMBZvkZb2IyGaeD89K5mZaMlP5SAJf+gIZJFVnZ0IQXXm1tiVOS09clefbmM9Z/g9+9tTqxCSmDvVnJ+6Lo2QvolBbl5CnJAYNEOAvjZmNOR95nUjiNdi/crCAy/FaNfqX90HKZOZ+HxL+BMSfm+mYIn+KoVvxzs6U8Zzfzvat8Ymd9/YpQJG6EVhX2QmdwuLNDPicfvZzcqbd/xyYY/dP4Ow8RyhcwEyGyYPEc/F784tiZfXyg/fxX9u83tNyAKHAtuNEp2LaiO+jogEl34JjJEET/N40FMz9kPROcvFgICRCAX0GdoIFOBw2oog28MKadhDwmedmN2soFwHmepcs77sJcGEwgjNHtIIWm4Bn04yJa2dF0FU4GfMZ5cbpek6erEgIab6YrYrBnXkmZR7GM1wNdxtKaPUMKCA2VeLwPs0nxCwn1HkjTG4K15u9gMZnxjRL16jsrXI/1dDVPqMG26R4LKh/JxODGwHDEOGK8E8gUlVOy7tip1KrpNe8qZf8vlHThaV3Mf1xTsS1EyVHmzX4aN1C2PIuMwD3Wg37M6kRU3twuDdhLjQW1vfETBxntuxzZb928z/vB+tdGBWOtR4VA+bd3OOB+JxPxXaBCUMIap/1SL8T1rOInUuXoA4zxf5Va2Wa2si9hfkze0zuO8LFZBjEhRy3KhJ0ayoiTBCYpKJq9JkUVphnmGf2Ta1ycOeHcLcW+K71HgXZxAYG8txNRxMKDmW+ooapoz5xYr1u58mYc3xwTcC/Xf7VtfPWjDv7xVwGZ//eErP9s0POVfSWUoOM+6f2CP2LzFlbm5qKWb5Se8ItdiaGS8p1VV7qa2x5ezRalmfE7fFtBnWgn69pQMLt3uDPCZ6Wb5sfONs+aX6V+94bcbs7r0zvz+9k+381E1226gx4ebZnkKkLzXNr+UNiBDfJfasYCNiBvfech8l34f2FgVBP1uHScHQMZ4rmKt5sTtLfH9aK82Pls3PEPtC3Iitv9gQyPPqBjXCX+kz31nsvAlflceCMZbAa5hzxZNQlhqomo7quUrVzZsLnt+MHOFF8LJinx9GQcIO9mCDg+qyOUxijDmTeOtyEmAUSo0BtR/4Ja8HuiubIm7nhhVxnI+DkPM9xjarELskT6CbEQUPi+xWcgf1RhL0g0yrt/hb7NKEpE2L6Ca9nF7x1iwen5gZcA5MbbHFiDIhLO5+XhBl4Qmx5RENUBlwAq2HADYKmIOYjVyR5chyRtKGdzFnDy6whtZyZ00tggohIA4ZZ4OwTgZKaK/P3lJeHNUi+OoIZldfgGWx5c97KnSEqhIPG8AvPznm+KYEj9CL9iBEMsUehgALcjqBexP50sDwPCRS9qrnbVwAjaeW/KNekZQUhdVfHz687J36445w9maAn9/O4bPDA3fxSyrXjtXI++5cpDTS6xlTRcQ9h1Cb9k89jclic8DISO/dtLE4Lihm/T7Pcns/X20ZFqstdej01DL/mRltREYMnx83wP5+cHZjxqrE9Q2Xmy68f00Y/g2T69qWYX+RhXL4qYCbDBPtN9zQbFMmnb+ck4b6tJkFiGPe9NlhY24jbLlkYMyQ/pVdp+bxSs/aCl3+f/45Z+6zeM9z338AdkmCxc8vgl/7ncEGgyXFKPksNpko09XE6D2IcmK8e1PwWPOyEphqOa2F5eJW4aeu0KQSQBlO8BH7QZeamHxzoOXOc2T31AabocfaZJL31g8LQ20kKN9LAKT4idtT39A46sza4jlwn2VtF6CpG7cJtHGHPbo9rWYhBIwkLXL7n98uPcXaZ0lWkucToVQ+zXLRx2KUJacpw/fas0Le2n5W+fO6LclEPJtz26OlZih8jCTubDW72Ue/8gxBxJn0i6q+rPKfpPTNVf4q58tLvMRnAeDvT8bD418/q5RUzUHM/lZ8IjBW95yQ3bOl+tzJBYmLwV/qS73b72n0YfO9TNeqlXPwYlE5BtRC+Vb+b/Xj1+/t5l8YpBgUza9+yDjKcdP7tedmpJNaocWL2ykYzQcgvzpdOXP4SY0/BsjvgbSCM5rw7RqNEaqh6ITuDhoI4FuaC9l7Gbdfvmr7DrQ+3H9laR89X9gzt0i4726bWlj+/1LAX1mB4xvF3dp8WTrDBILE3677WOPw+HXc/IJ4Htw+fox2X6zTUUPwIgQrUuvDczBo+krwWuJtqGmbnqxsJx50Jf+KcEq0q94s6EWCWvR0+45EakXy5oLUI92RjMgEe40zCztIBhCPOcq3A7vC+2SXTw/v//PcyPkwPhz/j2fHwvjeSuuBSbkSAp4RSCwrAOhovn10GMcY02AoBcwFa83X/Q1NOSRC9oxMcK5tsMhsVL++DYrc/zP4cJuvjjPpwvk4RLankpqkfbb538P0Efo77l8Vo2Lr7Cqvj7H/28z/j3WH/P/P4v3bHWRLvV/+9X7lvVEXReWnnmrtZXExm2wkB/2kJ4izZLFUJiUQYJAplJxshu8giVuGcbA52Ufcya3WWlNeYDMpfCxyQMd3/douXH63gTAFYvS9uNxboTjfdZtjQ+yuyKoi2VyQjoCBBEyTNphCtot4XRYgg1fA7qOhsWk/OqbTjX3wXATboAi13nQCNuw69zNp3U20FKuiR66PueiMOec6LUXMvZBU3yJoyQbsmoMzYFt1UBE8ocIK4UgjllbgjTpEQBIrz6XUKl1px8CVxTt0lr2hwAoLRzcQM54LqYreorrKTuFw2gxM4GfQy61hT15I5AEL8fa62MQ753uclETHicJUDZUnGGUVMpp1sQoK99wT+NYCVPQWYogCPZ7l+gd9HHB2oeMe1dN/LiE5vk76aKKQElKpTfLc2okaKXy7ZPQotCppyh0QfeHynlBOFJNrONfnRObXRJU2GJTsZOtuBOYlY7eXXJz43xCJyj0lixRApUece/7urKv7Jfa8KNtzJUZ4hEZBOMIz53C0doVCBUjyHdN6zbphrdX7W+8oCVtxXNwVupgTwRoWCcZad1cPNwksg5HM0KlindnEf7yf4TgsSms7W9XtOcYeAbfNGeJ1KQZ5KqJjnAVJ3DZE/TzIzrm2jd5BGKLxq6p06mYAI2PHIj5IMaD7vwjgE1QUkgRNY+vM+yd5R6wf9QfktzCTDXma5HISdZT9c9d6qycsg7O2Dau21Xyk3w0q5ObyUX9+yvWVYXdWCWv/nIBO+YiAwzSXnuefK7u6RkL1l0I57gGenOBmFxeFb5lB7i60jjnHtpWOUAXYoDh6UY7o9ymDNNF+6N/TSv8s9CqmrcCvjwWzTKQ0J1n22Aoes8kxL6j1AMA4NXr7M9Vul9mrj/BV3KBY2wOpCHESS2TbaAZhR0qi6/H2fFiAXQBgjQBIGyg4ge5QKPw530Zh74HUx6n7ieYez94zpTHwvdeeQAZE8nyAYytBSn7O7fRL7kzR1pXieQ3p584TUr4D7RnOrzsGnqGFS6RfX9P0K/GJZEkHrxVgc03Qweet6j8If16mig6CLpmM3QHgrp1Nm0yCWuHeg0eB+RLLacZbjZ5ZEoTyFswDdPidjKWSZhl2hA6dcP4o6On4Dc/XIOLhHuuckV7Mn9QblUS9sNnvDZqf/KPmEzUwzgdBGnTDzdPQX5w6bnqyOEBgWZEQAbkjhTGnE53OFlDr/TNQ1zZ67A5MKsztNjDM09qktyT90gDT32SacwE3ZOEZaJ2M8G9KkicBJPyPcGhoUZmAoZgdkSGgV4aqf+qbkiU0xNg6DaVF54cSzyFyfRuc4cQPYZyPm0D3YAP8xiP5oKpqGtF4vkpwMUZ8kf4mYhAYHxuGb36eL1CpxfoeDhKTKskjmnvnwWQ/pVDShQxAA6KpxalG3UU2yM+Ai3sfe75QAzzipHm2akREHbeAYVlSXQyE4R+OAZ5Tb500CKfeEi3wf3mOTECGko0rzFG0mSz37LhxADvBciBOwJijE9/tRIGcygcsmByMRk+aGe54bIzRXYUbSGYx7rQh+xBEfqbWSVBSNupdISTOzjXMZk9oTA29xAn3FHl8pLZsvVUf2U+HiBIC9kDz2rh7t61n1Y9mUfeZlEBZ74bDZGYTdQPcS49xq13l7K8Lb4OJIh0ocxLO8d0Ohco7kvfX9awMUG9ZrV3GKIoi0gxuXPh8Y9MfqFPjofSgUgyCe/9boZiKCEPy3pQwNULeXT9EmAjDnNdIA3Iu37rTsfF6N4xOFF9FeXXXPaHpJRL//HNcFRFhj6+i80jWEZIqzDmbw/Jl0stvzGXvNEetBXyuZb4OlDmESCrI3EyV/l55fUUvBNfft69m6+vtkRQA/9clBzgOTXCfp5XTwevD5Rbi3YoIc1jzMOYJqt+nOXa2/ck/mcwIIygQv8hrcfymG4tpK7+nYZ3PFLUh/JkkVg8K5kLMlJX2kiXPoIFOvX334+lNxXjODW/xNS8RmfjpzuFHS5o4iy9H3bqJu5Oiz3rKraJzpNsfZcthbfzeHmWWR93hUcumUdZMOQmEK3sM61BuHSytyknNGhVp2mGeGRGLOwsGtOz9N3QQh32tsTD5qV9Y2AoAp4TU8zy4keCZCIEBaYvl6c39+9z6r1Kg0DLG/k2jy9NEKCbnfiQiyLemqhtTxqzPRO8N1ACkuiP4ZwKQbQ8RgPQE3R1MX0kU9PMLlmGmJFLrV9kg0AXAIcUFQySaL0Q9Ng2B6Tquyba4W10zcbOy/X+PM+j1zv5+8xtnixyBosX6gE3aWCRSa7HFRwQ9IlEt/eEGcoFK6tj/NmX9fp6Cvfct21B3OJhDi37SekppiXv8B4dd1MaIjqgzX67YmIykNDrTNxiE3GQf7diNzrGxFDPVzEKxbHLAVMlFc2jbHnW1QCdZ0H6ZrcP8SVBaz1y1IMOHlNcls+d8bIVTjv0GQr2y6JPYHMZI8viGEwVmDwe5nULXPnu17XHr5r/EKrsdYBdHjFQd06n6LfQ0gtax5Dig7Impjj+cbskg9aVN8tl0KiKZI/SNwRrf1zWT0fWWC5ygEWZjPDwSKE15PCgI3HPZdSjFdbeuF0yzOakJuWb+zpgHGrpdxJB+Sk0XoZffhdCqPptYd7feBMZFLvoIoc2WNkOxrgjzWv6ad4Xjdt838t3yv8fdxlv/GmfSjUzGGFO6e4zqP609bJWhiSH9c1CfL5vXrmeSpURcpPC+Dwa9qTvPs2vV4U3eL6NdiVLyn/N2sSzzXZ39cPtNRbNP3UjfdfhIRoJfkBAyK05/HOtwvSaSIs9do3MxBLKGkNNbx8wYTqpj2hARYO8iBa3qjc8KQDylMwUawIkmcflq2B8QesHZzAV3uu4kjJIdH1GxEJ73eMf03pS+sRfOzdM9FknIKI9TPjOtuB/vY+6N6T81JxAWZ36EWlYfrpNxbf9d08L4OHtVWvpOfEUQ2iIDKPlTrJgvWZwsVP4QwwDB1vd6PCEImm36uzsIWE7N/J/d9NKE7p6SoghTu94pRjg66Ioh0+NpdT21xxlRfWpgjTexnPFExUOl3Ehv5fcIf76Pw+lEvHj9eqru7tZ0rHt2a17+rfO0ePQNK0np+fVBPyvpmwmtmdinFzXEn9lMHKDiwgwmaRyB1A7VfQWoTGKqUvls4o2FGlos2QWUlzy3JAiC9S1/XqYgxmbl35h7gmWOa0Ki3k8FclFVDM9RWUh+gh9qE0i8PjDhTxQp2GKZ9+MuX2bfQe7MPSePYOuBlTVC6wRyNuZM1Dsho4vjK9EjmddWJN6+kfYdbGMO4TZE4p1cv1B0pxIh5iZMnarpmBIqX6YiiZ97joOYSLoMYBOx5HLw8bToqjgLhZVEpfbu1sEvmudonBxv/+399/6//L/tXs4FFvJ9/nd7//K/pbrf/p+OBmtkeb2HzB2MDlj29vfNH4GxRoVXDvZGgWBNswOAoMyaodXF0ZtQYGMfIbUt102Y+Lfu5JDNohHFQrX3asEm/RPUgVZaO4CswHPcfQKii22e7SW6BeDL8ElrF9gx+GiHWv4dWLaxjvAYQSGPall6m9qolNo4ewsA+rDiVkpvbvwfFKOTVLCw8LwrwPOFN5HteOB1lxrQIL9az5eXrrm0Urppcl7k5girnZfD5jWPqgGPq5+f3sDcMfvvJv8mup+Pgt0D4w3spg8TM2XgHyggi3XLBOHhBXVTxwqDguFzT0sX35TDrTSC3i6zJtrb3+picA95Lzu2V2woobJfMEYCA8ZHAB+q7wdbhcwLOkZbF2lpoWQp492zHM6k2UcYyOP68EB0EhAksrD4ubOeMB95Ctf86D1UonKOqFef/JfkuXisqZqOEXWpqCK7hBPBHJGddtzlXisnfQDt/2zoq1GbaR/2uUqpVV+XhxTznElxqwzhca04+wyt9NbMoRTeAHO6uja7nRY68TXmNeu1CU18TAFNxW7HzrzLhgX3DXzYhdndrxvPF5FgFeiVw0+T3+o1B2A/CYfPjLRsOh7VwGNTF9w4BjeQYvWR+zD4LS+uFKvcjZ8sBKZcRnLdPwZXp+yNBIWg34HnS6P45pdlsEYF+RhOjJRiPYtFXVha8xvP8gjoDamMkLIzHxv31vIHjBdo1JTZHr9Nxd0WfK/DztjjyS4doHJ6UH8Y2trLcXWa5YgZt1fu1+tweFIrB8qvFILFaUblXy13Q2MPvYhfBU6CSPaLles8smmF1FfaS4s8w7PfCsPfcHmfioJb5XYM970p34a72is1xl6VQEPe+g7j028+4FDerd68XSwDsuvXRw15UlqAdhIGDK719EKpIXU//CthFoSFbfmN9AtK8g9l9Xq8XVkd/phHHOWYcfpnlELYRXqUlqGVM+/tu9bgYfawND8N83r3j9i32s1zwLKNdjg8VzpRSvhUXHU+rzrW2bI/CZdBIGNLqPKA0pLJC/p98f+81LORCSIGQambKUPhw/z6wbaDoA2z56/t7GPiUoyXwSTMYzUi7I3vFFK0sR5aWr4+24RzZES2NuCWUehseRcu68top59UiY9lmwpDgDcPhj2Lk3rfwwSKHsBuFc2FqP16tI5xjlRJ9mYQDZkpFhMEVsyjD5/XCeTbIpgy8qU8XL0hojBNqErFP6DX8if99eTppgMd5Xin8QajcewZbgGoa/a/gJdjpvirnz/Ubo+bf2leeib+1c/Rjxv9/nLKdx9+7z97qcbzJsx/XiTwn0TOsbuAg65cDuHIKiN8L9RSzfASawKs3OSqkwDEgAr8Wm+QEjpCtuUBjaNCnQmFo8O3Bp0m1rzhb8dyz9JUxNJ8J1GXw/7y2lzuM5XeRjH6LQRzAE0m+y6jH/wbXfXQpHTDSayLcI987ydkbLMdve2nJUN56Z8gcUFZl9en9TRxUJhtyibC2+fclQLdPWHdoEzuX8lxbonmrUjoox+mIumyMMMAGfW6W7dGPZXtE3SqvQ1DJnrCvSd3UB+km9Tvmmo1Lzh/A//f2ZoFa4zC7mPcsHQGVTjY/luPKetkeE+ZKXGnP96PnZVCfeJ/ldr1lpbWrlH8E1e+XcabWeXvJvuD8mW97uwDXrBEe56QEhGvCY/XuWiAx1FDBshlPZB/S9Xn37LjP9B/4PLvNVPbqoY60swzycOEBS6XOGD6uCSWFnvYU1LrNt2r4GlbsWJAt3o1/HX3fOB6q1/aR+LEK/EXKSPnsxlZGww/CFd9nH40AKUDX0U84RsH9GgkfeZ4XjQvWBDUXpAMI5INzR8LMmicNv/DGx9QAbhBOYkOt8+HnJBcmCA7F2P/Bs+WgIR3phrkawgjMWDN5r6Of+S54Y1CGCZqQLtXRUbPi7QlL9STDGWSeQ9wT44txEm2C1ps4L6vJ6zCTVPt+EJlcMx8a2C1kdOKus2jncI1k78shDHsVzxBIVyli5HO3h6o2jvtshFa53jxNxs11O1cABxe+MesFOZYaBKDe7XOlNJhnEX3SdBQh2HipARpY0wm41bNNt9DMG6qX21PaXnA6A1JGiyN0RlHF1fQI01NI1Rsv27Y/dt5SxZ3y+jm6ikgVMx6F9JzekoZG0l+yCWr7ZRswXdzPIlxhQS74zf7HuuQ7CapJfXjNKPxQOkiwGM5VagMQdHfSfc7WY+h3o3pCLUQQlxdB4/uH6Hz7O3g76e9jL3dw0SW8EnKoBGu3fvpXQumil1m2x7WnPuoz0pT6O9GFBOkaryI1Lsa0ICdKPxQZeOoq1JtwTf7tJ0YUB//7JHdn5DZj9Pcm8KkYxP3f4TvOZ69WRF+ZtC+7YmA8Yy7lVwYDCllTtQfWZxKv/Uydl5yngHiM37iMjSr6XRhC5I8YTK3a98+5GOGQqK/nuD/jVZ17rmoQ7s/8f+l6peA8bz0SK/g5CK+vn18cVU3Ui53XROD/1DNu9rYgDnFPOc7A9VBq2dUFOaFWKmedJ6vpyZ4QFq7nImkhxAs0XJIh6VJDm983gWt2dCzUNeiF62cJerTwW7huJ9/Hpj2z8X+36xhnP3oo+Cb0oR28yM8O6TUVdz5bcbGIXqL5GaBXWbN/ejn/6A+L9Yr/zJV2tbfMpIW+wj6X46/7+5vqY7x7kreQ97OO9tKY2A08r/uX60OE6iA6jtufOzhdoEAD+9XDw3Tc/9D+adkp8WdPwIA6JTlzUWMFkulAmmRQyeaC+u47eHnCvppr5wpZ8Qt52nRSe45b66+fu4ReDJ9fz9Nt1fjTZaSW1/u+DY8I0lEfNQak4Cxob3akPj4YDR8dVD6Pm5cAdWx2sg2Pi8bw4PxskwM0NI5yxZCvlRnXT0m3AQXP0B/Rv6xF38F1ZO+9wTf0Hmu45SfrycMUgazjEmoV4FznoLK4zAalQ8Q9zgRhBtugGk4GYQ9/v4peMufKRnQDP99Krcr2l/u0W0MvDOBraV/Atcs+O+fOo+ageHP9pP+Wfbq04v2rZJOgspDa7CVTxNhmsmHfFDcvrp5ueuccnoN2rp8s4uKRHsIvwW/Nz+ov+3J73+O7PcZqpSeDcmuYKb6CSjdlUOmToS17ULj2kLpWBIPxRpqC86jHL7WqGp7lcCHqxKFbyhPjfASJu2tcCe7+241XoH/sFTvqTZ/eb8tSp2LcWy/fjMFWS4c/WXyNY7g5/H2F4oexGO7r0o6PZNRTHtZKe1MDLow2/OKti4odQckI8UX6xAn9IxYH8T6CHhZ76q96SnrtZ6YVE7Lav+r74HN9RaPv88TQVjxM2PXefr3aTSQ03vb86lf0vYouMuZRTfxxsZRRL0YWJkw91Yua2hefrV660SyxjgVOBXrsn3NDCVAvA9vrCn2Y/v+83tIH/jEf4PkqbdtbYLnzZfvyYxngObW9zg+vhunFGPN7mNUzf4/3L1iOB+UfH6yd3M9+gp5G/8abmqxi8aZNUJk/vwJnIF4awcOh2Bx3nl9jhtAqDg3aKl/z3seJ69/ugf5zYDXbggeDYp9xNEKP1m+0ixFHbjIyE9rb/4NnpdZlX6heE1nVEMNDUPx37FopXkDnNyIY9VYBvWXH/dVRE1cLSz1tXl/tNcDaJs1hr5pBpZdizMowVku9nzF3AXMdWf+CC/z4Aarwz/jHD/z3T+BqBhOCZ4YNzYv27KtucB/kH0zGycl4BpgxPXx85HuU5PU3WKPhVsa+1k/Du8Yepl2HBGHxNmuECKtF8GzO6RuLF/Ee5EwJ0oXTrBHJuNQbPz+QgwiVuKHaOGjHQTm+OEq57NVlhKmerDyC30FrkJH6HDKgry9e16yFKZkoBnHvC7VAexwsm5eC/Q5B5ccpqAR/cQatWcOb+4NzE/MLeIOxzhuXz1K7WerN0uGgP/5oUS/Per7YGejIG/5l9ADhc/27V7vhs6JmW340zsCa4ibX4P1z/TEobZqxPPvmswUxsPHqslMpL16V+v0Xo3U5194ywA2fmww9rAnNq9J018dQmyvGU0BDguNf7OkX9U6UtX1HzcC9nY4KG/FnwhyOdPljUK2tgZFhPQ51L7PzNb/3fVBr+/vlo//279G/ca4KblIpgOZZnYpHrKXVuFqYNFDPP97KaezvPjqj9XnHtaTfELx44acqmQNCG8HMUzAtc8Z4lLbb55Sz5LLiC33VbVflu1jvaqHETFxe2s7px7OraU72b86MK4W770/cfFs1PjpmRs46T7+PqcNEIx6Xl4buN3EYBHCJi/U3zmHePjTB1Sf+H+ZHo9pewm4p6cJZpfcl7W2czopLIHlash98SZ+76C9a9juRagcvgt1tTWpqgNbd9w/kzCamEuyCergnBU/+G75M67/bSwyO/M5aXf7OP8uJ5cYlfB6pe+O75xl7elHf01uvN5hIo5fMs+wp4ib2JMEbYu89ZGbl+oWWeI5wjrhuVVY6Oyv9GbxUd63e7rYf9XvNFn+23GmtEqwnmxr3JNzH2z3J0j820Y4el7Um6UgR7ycp4b+akTPjgBpfpRWz70jTf9Q3hq8jshTQufA+dmZG6d3nNBephxWxAGAoxLrgWzPblg+BJ41oD7KYMTxH9EUyfwtNuMoYnN8ocEp8NvNs7DzKrZ6l9C2+znP0cjcYnXl977Ohdr+VLcF/KcxYbkbD78n7J61pKad8+O/2HlWXbfTbcZ/z03a+fJzXM/LdLirjuFl7j2rI18+dT0OUc4TnhY8plL7mlzX2pYzMxu/fCx78MucS6t2EkozMAZS89w38JBg8KlyT2JvjQ0Lheb1ijb7GSifc8n0c/bgSeLwZrUdMGKqsNW/uLpip+onf1KXAeIhjxB6+IVhGT7CM9PyZ2KN4Wy53n6jXgrgfL0YRzsL4H9KeVA/9X+/b079MeqKG+JbjJ4QmDxS5Oaz/Rwk1P52mgoMKanwnarj4r2hK1fwpZ3XPl8KVDy2HlzRRxI1DiIyEJVzcjZ6IYUMyyYfGRLhgGglZWNVbYMfXWXGoKHqcArWNNjTEf02I7AflLAFnZ3p7Ua0BzaEXIHGZJtSRnvh9rJi/J5sNdd91ghhIEscwSIhhEqR2FS6imvlXUgFJqpMyWk8G0nxZAJ+vn/rshvzUZIFG3So3TDeAkaEnF79qG9b6MxtI85Z5Wg5r4WAIE/+BMbORQZo+/ELo8RoKDY0ZhpnkpS9anjuym2dE+Eu+7k95n98mplHQxgL37CE5Do3nJsEg7WBMc1BIMLAsF34igHZur517Pxj7TaVp/VStjmzKdhBkyC0spqBvXM7GLLBMyIBPTFmGMI1sSAq0hsFZXcVoWOu+uaJHjUVJEqBmclonOexiiIbp30NQZJRRXYNHwoO50DAdajPKiDl2PVzDnCN62avJV8dpwRwgxPvOsDk256InUVOSvTO9/Jd0Z/QTiEQrc18ge+SlfhjV3pL+x9u61sUa+4U27JGGSRtoNRIe/KU2zAQf5qbj5mkGx4ptzxiGuAITz9fbF02iFxtJtJ8YkkxeDf3uyHilO9IZCCxRbqGH9M1hyMO+ZnTbABj+Qv8Erbwh+7C43GOw2ct8h/1q8tq/qLmZkF/cNTfDVxNmvEWTefYGzs574hbwnHj3S0FBnBNLuW80dfQ4819/tEvUaZ5ccJHo56yRzSjJuPBdAnCOEOgFV3O4WRcu+s25hGJOtUQwtDooqZWhAfQ4QBiKN6DB83aWYWo3C4PCGz3jLrUPpjXJLC6beSGODgby2pNNSPPGGxBYw3yEzKmmNp72uwBtHQdNxqfjbv1p4TarF7ORZ7bvrR+rG1NNqQQYNXpCQIAmTk1KlZR8q5km4IT1owWi0UNlZuZsGRWxl61psDduklDjGQnmZ5e/JNvZNecId/3f+5lkOKiFlXEmHPWHheE4Uyi/DYfP7XGWwwAZ+qMxwp622KLoQXGtDWMZxkrzDQYnKFKzaD6PQbXP0O6299mp6fADz9++lhp2hHAIa9BnDP/ojSEmi9oEk1z6RUKjR5jWkKdPkF5nuaxobvWsb/VuAdQFAp8wUJVi8GX/u36PN/ytkB7xOsU1AxJkr3L+JQg9BpkYa5P7Hge8Gz0D1JDK+jTEi3E/AzBZgVjTAHsaH6d5DLDGXRjDapFuiKwWHbXMRLSCrEsWaoDalgG+BdYJnOTLJB0+uA6pv73Xdsy393+TahxAeLbrydz7udxvAgHv2GPTz9Bz4EiWtXAdvoa14mtvmK0pEfIwb/RN8KIQqjeLrNlXGFIC/cvoKT2cfKhJ+Af6lK0dJIN0bPeCSLSZaECy89zSekG4/XJBE1mAxBP+O88T0zBa/SD26uCmzuE1EvIOwWoZjD8te6O+qeegizmSMNkI43ZeCbqNzumRp4vzC0pidWiiqMDTrsiQR0IHjoYArwRRd/+c/gRhXDCPT3yNiTcg9s7Xp4d+EUYH5j5vYLTAVttqxQ6qi6aJa3qtPBomuM9rB+0lr3mTtfB63beicXc1OX/9VWN2/vpz/ZF8nW1r9t+X6Sbx7LcqijSJEMcxzj9kgww/xkyVvJ2+K/J3j5QfbUMWSyqreai9RWgXjzRYzsiBxYB3YOsNvNlACqf2qHhmoWcc8OSgg9P9WiapyvhSMT0YmyykY6AtcNpMlDXOtD+TaOYOyuruZw9MjjMLCfN7ZtKyW1Q884mBdPL4rP1ss9Yf2o2QjvCaRnIwh/WEvwuxNQ0qlOU8TBtEOYUCU22UXcvOXxqW76VjD7vkajdBsYVHIXITi8+pOGfyvXQDy842C2Wq/AuIkkVjI0lFyBlXVGFma0OK95FmtGJd/X2jK4MGU8zIQofo2pMm2MpG8TcKDDGhGtWEDV3tNo04eLb5cYBCQ66LFkvScGLzJrNFX7P5lnSHveF3hw1gY5GQReM1d744Vw5uOrKbwtWySXTtWyHgYFhoBNVo8Jah4Q4Nld6y5WF7mLy2K+Xy27q3fMtE9aCavKn5UrU/jMrh8HtoEoOtUkNS6E5Mib+kFBMPTARWSyPavzWToUswjFTIFjeT7Z5DoFTQSRYgU6kTsnnZWG6JkB2j+nfC1PJRuNY1imZ2Lel9tb1B8oh0m70FruH63nBJ18PdsA35mvbwB7NKDhBlhUo6pTVFM47eHotFDFxoF2ia+aMzfdL7RxM+fbYvjjHXrtBVksZJxqFZNnCw4Vkwe6kQvzC2oIpolTaZi0uHNg72uPQDG//PjWMt3O2dlbvf3aUUEGqM8ch4jc98vrn1TdfUIOAZyhtXNPJgvoId+pZf+exNZ+ZHVoTu92LMgGnh/u8M+9Q0Bo0V0rvgGg1XS/9McUZVTBTERA73mW7w9wZ52qDOcyvda5qJmoDtp0iRN6Yj6f3izqBpvoVzrS9C5XvtwW5uj77VsTptHuSQdtOUp0WnAiBa0zQyP0wSCs8BZ5p2Z7Yn08Um9zoVc2tydfHPaPTkpVkZ5YsxOEKSdrJFUsK9CVXKjAjibJ5ZUtBAaWXsNP/GdM0ZD/lMXM+w5mzv8+1ELkgXmr7J30PzMQU615JMjdRY1A+aSqxGRp4xGcGHKFfM3BRnW+7nND1LGWVZA6ZZbqKKIzba5nt5xmMl77w8q+FanwWmAh5MCqT6R85WXQts/JnIFsqeYZ5NuxYAVmICOh13r6a4nObCo9cc7Wf5cO2re7gXq4Ei0tbnFzG9ezBB4vk63xTP0biZeTfJ9rkQQAPVjjjHxcxCkphkXz4k0bhkjKqMUZmYrhk1MZp7ZdRQ3eQLy03jImw1YwilhlpQWT0u7Ce59cEz4fJrxapf3wG0elsXhya9e1YXMJAAUS6UhJhBFo0X7j3Wymq2wX3sJu0xz8nLoiKsYCYOyr5c5dQE09G3p2V/2B0ElcxvQRUpksWXfuVBGpwCaAKqCwsZ+zbNSXVQML04kwuCJvnmtv03oM5sVPvTuixLMyimOXWXtj2rh9vJqFtgIgEdsGksZ43bLFNOz1N8nrdN+LQA+9+YpSpbwgcQIjAW0maoHshmwNRaFu9pUgQwnURywcTfN4SRQwDbKJ8dAF5s9qsdAEY4Q+4aLIKVVXH2NsnmxmXZnGM4l6LxSpOJOw6EugfzuoNwVRvKBPAQvPTOHVXgvmWSas8oXpBOStVdlf1IeywAtceSvmDtRLkESj+T2tB7y3aHztxK94gzz8QszHEFnFdTPGE6ZCeshwuizpC6RXoO0wPluqtoE52YVmJSNVjPqmHDwJ4r47dLufWWab610yaKqtx3rEOo7jEFfKeJA2opJNx4aez5fmEmSfcnGLe0bxQ3qhyUelFrsfllLrVBo3ziOjMTT3n+DUPBJB2aBJjVfNPcMR1S6lRcs0tUyRL8fB+oet+5DtypxrzaDcMpU196Z0jqrD6KyaDHKrWGUOWfo1ryEVaL7f6QKYxrfJ9ZvbgCk0uTZRwTxSlPnTGFKipn7AOhajzQad+o+126KAdRq4VTwaO2/QlwqL+FqlCAtdfYZ744QxtJA5T65KEhMWtDwyTDvpQ49WmaUZuVwdODvx9jrxdzU6YTuTPRKNddauBWkzzuFNBkhYvCf9zVNaCJfTZd9caI0Sh+NJnD2xd0LdCgzAyu7GBKB7Ni9qXMeOu64Jnz2iTdBlmTsubAwjUDh9riZwC12zoZvGUKXYC/Q4M51LXm3ojqbG4GPdVwMqx+N3uZZPhW0/1e+x93TT3j3rMY2nIgSgcEplIZk7bnh+xnZ3x49T8H9ulWvEsBl634K62Gr4er+QYpQcFSkrW4X+F5ytwxj2+MEyeSRCv4C9gLo0LOM+bUGspT0HHgiOQkDLUIFgqeIKA298vpaPGl6YqyhzjzcJzRe0moSYOE7RhDewzLNJVJXDagjDOgOjAKT7mxkFqcA5mzDtQBeP5IKRbv3seYCkGdkcczLvhHBNNMY1QLRRnOcpgn5bs7MdBR9YF1VeCwA6ZIpnZiGpEP5k82YUZSyDvOzOxlb2spPbOwn+1m2+hk0sLMsBruHZLAJamAzhCN7hnEUnzWvDxXP8xwcK+DvCOSxEVhK8C4MgBTa2ryeLjjMWnZK+JZpymwsoN+OcyRhKdiNtL1oczIkyjWa0cAmpJIbc3CMbj2TBM9MoYwc6neVLWwOOAw/RDp1p3nIH0GekNBpi6KWbmeab3Md5Pm1RwM8vcb03E/WIyCx0P6NK4jJre6t05H94BwpAx8rBM8Tzqso4r8tm7SBFH0aCb5Mo2d+GnGMKOtJ0eToulUP8A9a8QssAaM00l6EJo6M4W16D9vwl5cR3ru/LqveloOPBcc7978fFt3a+0KCRWizq5DfVS0NUHbqbi4z7S3HOb+2tSxrjhKeuD/Oxmdm2IsiRn390uMi9V0Umu9ya+HTHsx8oUZb1fUi3A0YQCCMZDi9ZLeuGLcDpjmikHNhQP9s7AC0S/O5axMJLmaeC/dRVSBsjJYxjATDkMZkt8+R1fgM55hu2LP3j5eT+Bik3BQBFzHM2WTXiZ9XaDa/wlmq78mNiX2P0PHJNR7KsMQxWsyMghfZbGXSE+Hvt0oZvQsqH9zyOJjo7KfFE7G0Yl9/Nb24G5Aqnv8XFNRZbDqOX9YpfZKz5TEumDJe7jUIWUUcsCO9BgMXIMkbRhrziPFsnSw21kO12G5X83W2pssTT85qHn78vHC1iz39CzMwvA6fdGU6noTiaHEpV/j8oxnYZLRIU5H8ACbRITPbpJZ7Dxi0B/Wqm9DJqH6yudf1dnm79D32fdhqrTD13wTxOXjQR7rY+PkZJjwNjXG1XAyY9FB46fpQ1kjGfxYBrSKCTjslfuUdXOxyczGBcqo4lBXajo43+MQVJrC2L98/RGkf865hLAr9+oqEtiBWXtgWJmP3Eduf6/2OSWjVZ0WUu8TeLiFe+7ml+ItWSx27P7MMogLW+yfi1FwcubkRedUo5gr9r5fv99fDkD/yft9TgdZ73Pqe/1iUP7q1NxDJWncmRMLDvND91uwwgs0kZbflzNBayIqzybbaMfznX1ucx3UD8dZLrBr1eKG7sw2psTKRFZSJhMAHxjocxaBmVnv2axLuz4rpWVngAHzk/2cRrEzeRCE4/+MOOwNCYbrnIbRCVJVC/770BBbyG4Ws1OiDhRaR/SHv+jrl/16aINWaB7t8F97nYypuBtaS4rt/HKrbrbGuMfUdYgNKdL1FN6s8i/rHiURKnEwZbCv68W4sN0O/JVQZsl71niZe77UT0haboIMt3wb1f4UAplJeCvu5YyrHW+vtbmfJu2LATw26MKkL4eObCJ4smI4gTV55fmSh/ID2K0a997fU2HbGwP1m78RDK+vWDrORmKvK7h4iFIjXPtKMux7DBQo3V4/OtXt5rm91C5GOaOYsAmJSN3Xi3MznOWbB3/Wo0Qshl+Is2Bxb4mlSHzNfaM2etYe4DDLM/l90B82w8Hwuzo833y+u74fZ3P2tFCMXJ5lzhyWLsm1mEV9YgNJrBp9oeTrUhyOu8nddfcwPblXgbi/wMwepKJqVZ6vTW9vHWdMr2fNanUOaNLkb9er7Q0due9Bn+gSq+mIuDQYEc7neDFmKIi83tntn2lsqpqqb7xzkeTW9pgOk2YmiT3ePud0QWTYgguystfKIxXDLPdVa0p9vT+Rlmrr2zx6ueQI7EWSQ3s2JAjPIFMW08rrk32fOp6faGm+pzx7fe+cxj2fPLvziNeg9k51WNfjRbi6GP1BNOquQMJ2z1BvOYQCaVTMSKgPnPzKq0m+n6XyofflkWpNOrrsa55KlLWtvAaC0LJKfsQazZq6yTk1eBgz+kHiC+f0+wRbs86HcbpnyiYTmj+rk4fjs4AUt0WohyHHubWAs441ctxept/nrR6udCZpjPU3Wt+TXOylpSaqZmRo0QTzfzUqn29Cpv5RFDAow5x9syil3wdmx8AjOB/VWRfXtPaAdIQ18xUhNbIXEpJ1E4SrxH3OEDMMXP+WR3r+TO8NZpZp+5jkXc7ydeoacJbpHFJf41Lc0zkOeAuT0VyIzkb5UusGPVFhx4/5SoH3mVB71rJwaGF4U6OZjXrp99Zz81m/s/1bu57evvzXw5ki9RmewU+/v/Cwjup3M1wTYwc5PQEmPFyHlXCYdPq1jnVijcR5KhcNLG+HtZc/LzV7tJwxMruT81KxsTj1fam+fI3L8SxXhPLs6D+fDodiujgI2wwmeEuTk+9xw8biMtWgkNnFC4DId3fiWiX9wp0LjZu1EGPGXEJ5KpZgL5g8eFKoCYgFJ3YPoRDkJtG52q/117XwraY4mreGLUdH5s5U9c6VZEtVZ4P9ocE/SUhEX/tuzNIvhntUQ+Ivv7M8DwbzRB1fTu7FFyTOyjzXPq9FzvoXqBsHnJ0r9mmdAr16qO+7Nq7sPGCwIK736+AjzJvtmXmY4XMi7MLs8ehx65IgT2xQAkH+mOXoIoh6RefRxSNFTRWpGYgZXNXkuwR1WCH3qk4UUk+WS+Iytvpu57r76QjujIJrTyrr1Pt4HLK95/zJ0Ku5DXZKjjo7VOJzhBRSOhJpn8X5LrlN2ag2TLrNt0xh+WqCr2QOanGd4Za1q8w17f1xr2ln5nwvj6CNOpek+kjCq7Y9JsrPRMm/8t0UJPQJ9XjXODQfpc5Oz2YUx5K+p5I5sJfA3KdB5zuzFmWvdJgm8GOpg9ThU8VXbh6DM+yldOxWns7cT4EtDrsf4TocDDPJzzfsTZ/y7yC1Y53pPZZ90+IXFDI9W2eqm/AtJRQzNKTN/fneSaii+7lxuJT3sTVB1XNqtY6aXliNzx84qcqRrkvs8xrKM8LZ9fZ1i8f67wPckOtkOpo8T9ycFOvC/JtyPvE+/Z0VZxnXFKhZPRdg64bq3sMK/CgOHMFteui4oMIHc3uuqihf49IaKcKYdYHj5AkLj/aaXQomeb344c4owyli7TL1hCDgmeJZAr6P/lzWVO/XwinWnn0fC/e/l1erkPNjRH52HkgVtqyNNyGwI1Aki9+5xS8v0SBrsGGZGbj3WVm8zOD5DcuPZX28IBbNsAKZoeRC69zjPR/uGje6X5O3L4TX/E5R1Rj4SjNZxAUNu+oTb5kMbq8rsHr7uR+E8JKTqP1Lt+nmuyZxHnMTnjEMZZiIcxtcWnLEUt13Dvphs/ZgfmqDkSbg1Gw7x0fcTS91+uYeLa7ubAcWnmxeOfcR7ARCQBM4h70cz5fhOOo99tzFIXjo+SITf8borpnjQRqR5+p93LkNeBDX7tH3pj3uJvNt5HNtsY4Tv6/xAwxT32f0nRc3Jc5afk9xODfh5yy3OE5FzHmdkxskgXUQBwWb4jGIU7i7qO91z/HfRzEB/rud5d+r2Fl7zSmENWnehvvF3sCmErjatpzC4W73gEku+fA4UP5aZR0UNLJF/3OGGgT0UGTxUBS90nrNrNe/FA26e+yFUdp9pLqqDdfoA+xalEBWmaf43IzU/Crd71Uf7tW3gplJRVzmXDDS0JvjaH0yXmUc9ywlQPTfwwYgST3WxdlZ8EPbvP1FaqIbl3HuS/UwcxeQV/KfCXkWUxjbuLldKF/U48I++q7W3VTnncZd3P8et/srn20EXon4ymABEkwreJ0VhZ9MKDFnCxJoZtanw4jxuT9v91C7jj44r9uoY2Wjc1RhavGjp+e8/k0Kw28wePWZIi85Z0/geU9yB6z10uKz5/ctnDu+pnpjwRNUPKr1l8y9JzIDOZoQUtlHMC/B5+su1YU1eW9Yhw7BAyBy3BQvKczC1YB32HjKCcp+dg2paRgRT/aMAOEJ+jnee4tLAh9ppUXB9j6lsB7vTI8fuYNo8Dcw9Qv6bnAUpDaVoNH09xFcJqj0f3+/mGvSORJXSO0pZv0K3sjzPd2zpB2znJDN8IXRK6oTdxHP5WY6WmhNG15SfbbcSzO30plwqjZbRjkKpuiYNTP1jTfLhdsaaiEG9Fle5u40uV8z+tynA2Uxh2gzHLVf+Kc8Nmt2ULp7D00cYY+OZ5h7oAlKT/fGt3oI5ZKwP+Ps8tnjZt6tF53J4HP+qWfoSucIwMtW0bZvHQQnOXCT79YD+rwrcIP2yOdjfWNeKUFSvS9vNiZ12SuConS+b+Y6DwSOqXrU41D6WKLih71n72zinuL/O9N+4vKPm89uEhmywFan43JCQfH9/ahPx03fhOLmuthnNxUEOduubX8VjQqf6lhu10WqjtP7wfOTAX+mR9eAOnED9gSibt7pCep3mjSj2C8x+ew8/+B9MM9uiNMQ+URpHhXvBWdho+99ihPK57l2pibE8Bo4I6KL/6/2IwmLHXdSYnKKyBsQvHdFREn396fb17h7zR4xhcUx8sXpdt6nLqijnnL5ytn5FkF1w6PMJIzr77JowiZb9e4hqqzjyf19N3i3+TvbX4pAVjjLCyaQiAkA149ycc0+ZN2r0/WueY/rYtQE/pJZKPfGhDfSXTm/gCszwi7XN0kzmYgYq/yuhEkOeWb0h9leWFvfXbfHBhB6xmn9F2F+su3SVRo8UeUK2KBWOHHNLrcmBcHde6Euaeu56/V2Wzq6ebycm1Dg/WNjlNXS6Ifuz9YUlyjNY6OrvawVFT1/TsbNC3lvyvG8ufbb+fnB/UndYwi2RSDracuwFiTN6+a8EJ4HndfiCXqrysOZerpWimEEtI5v91kXHkhMxUvd6Uuv+zfJO95rJeBng+9wL0hm6PK2KbjNHceRAYK6B6Hn+IXZwU5cj/9qz//X+uO7vb7e3Y3zD3CaCtbmzdyIfcfduTnqhc1mb9js9AfnlPkLZhNhddUcau2QSqd74z5Mx9x5rnS37tPB9M4l8oHuy/6e1gFai7kweYPRkQ93u69ibpwPRU/lOS36eO+jmsdwi9Pnkt/r2+cqXcPYZCs8D3R3vli9rGACHmegK3u6GJoYvq/lMt7XiK4fUn51Ftg4nvlgUzhpD6/cOMO5x5nVTNRxl4kAHo9+9eD73HPqYzHNganHbNtBOOZQsXambjANoGHTEI0J10q4qZg5QQdzvl8DltsEDWlzF0HPGHs4gufCzX27wX/XmQYw9ieTUkhcTjjM9/t5b9S88pn0nTapwxoSp7A8cplXpM1U6uoSm5ceQXidyTWoFuv92zO4+ih4WvAGPgeXAvUPvUzyMayFlbdq8jZI44yiF/j8Wn7cnLG/Cr/+98/8Xxuu6driuakJNvdnpBgrSPqM56j+/pKhTgXuuZNcdt0awP0T+raye3/LP1AzI/JQ+ln4DsxzP+7PyHSvshLMH+Gpgr/7c5x5PozxPC4aoeGRW60qQpnxjM7yi8SG3t/XYTuLT9sAVTODqh2Datgd1vqRS637B+fn39cyion/7flpZ9MaYC/PgibFeC7H6d7F2+um9eKeTuPg/6X2hbO3XnxDqcSbHYFLcrPm5d5JQHm9uaI52yPeca67a4+dLn+eW+6CmxrAM4kRB044DRs3Un2ff+PsfhyIXekbl0/j3u3O1uU/6sMezgKmNmmsf9NHlneRBPb+J/utMvhKrt9Q/MBy4e1sQI0Cz3faZ9X+POx5bc2SxaxfE06ES+rSHrPkVZ5doh79IwTz5ZzAm9WVHmEExIuPHq7xNqhW72bKQUJTGS9lUmueuCzO3ZLskmnfv4fpybBvrKnNlb2HvK2FuHoiEe+0gLbxRgNu8CTDedP98L6+hnbgjn+2+OL9k7RN4WbZ2rHM72n5GM78Rnhq5KOED+oN4dR532M1k7mr4CYNy2vYRbkVcddI3JLJo0vfUzUeu6/lD+DPoK4YVMNy/0XnfTY1J1n7cwATPi/8FPIUzJ4rmtIH5weTQTcJ8RjMzRZ59FvzWx3Hab7tWo+Wxaa2pdanXt5OBf/LCZbUTYCN94b95cOaCbw8wWrBZ1Kn4FrmVwkYk1zxQlzR4lvyvXE94BEz31jOnI/f6bPmcbaF/2ew4Fi0lgVgy6YPu8WIrtN6lc7zUU4MPxcxdZpY+wH46ZLu4O+/7uyd51YrJJiYZCv897+xX/r+HpqQaL5bSV7z8f7o5stxWnOmHH/Wav4+e9+rOO+g/+AeqTomM1OyHBqdb9PxnJq1B9eIvhqcoXm9B5On7t8H9xZGmqIL0p7E4/nuVe//pZx9JF0a/Vdi9Cnp9NvbZ/9fSr81GiGZ6au2jho54p6Wz/Oo3rpL/f5VqrjUCqq3kmTDVUoL6nyk7usSZzS5mosm5WGq4MT5L3wuGiZ9S7T/+Jy3WAKNjCuPPQ8emwmXjsELE+oG4bDw2g/Bhwq7w0pRdQL96yK+ee7q3RUdmmvN8G1dqA2T4hB4UjvHtX5cNLo5/znBbJ9eTtVmrb8uDvq8J/3svJKl3vo1Tv+36Kq6NNx7jeVvJ9wfQvoBKVZ0Ss1qxSFbvHo2Q5NG4/GQ1HVckt7E5dpqdjzusvEdSs2pSgfLUal6HCjoPFJcvmTzqp5e80vB01x4s1VNlAoq1WJQmZ+b/vlj5lXy+U4TYzI4hrYqPPcak4z/XJDz8fJ131ve6krq0X6WK0IHpp5atUzw8lTsvJUeps0AA52Mun8imettVDvif+ebexwj2iQJfQOMH8SAnFnBJ4UTuor8MwH8RnqYLKiXMtoNfA5zLx6dLXNq0ZJPsxaCl7Wdf5F3m4POVWbvBo/W+f6Da/Mrbc7Z4pvzXLI3Z7Pzx+jf1yN14eP2hEtV9ZIod9EYM8AmPdKwx8ITxcx4iBHkOzZRk/rM22tr9exF+NBcsF/O8uRdqjO7r40FXoRUS/x75/ZczXH2IrzW707p4fnVtBhOFYmcw3Tt/vn1D3lDpdXPQWnbqaRqf/SqmPOsjO9AOy/ruT1i+uc/nMOWjrNtdJhv/L2zC70h5h9XzCXBM+I+2mjSM6T1EpxbA6tTAA8TvSZ6IvigUL/4oP7zzhFT99PbizyTzufE84QoXToyI81PnXEpsIS97uNiuAgeXp6aywfrMTlq75/iG6iB7j2vacxeUHSELpHEPEs3+zTv5cFp8rM8/15jey3v9nV/z71ZR59MnBhkU4mrqEEX9eXzo4SCyt/snz6+CLwgXRNNni0PYONqI58DYDh6wVtm2byWtjc6gOU/TUeY0EdPdcjyN5/TUenZ1CtaR9xfk0vZ30ce76UOUzTXhnuyZ4icWo/W5DfdJ14lXUuepaAu59ck53w3DI53b3Iusx/Whw/nD51l3z7Tog+RZGam+hVMb+1M1b1UCeWCG4+fea62i3RePbt5D5OQQ45/PiTGimQX6s4ETwPWeXxQ+/5DH0jwyJ0u0Whne5ocbP0CmWavc9P/5Nnt1SBIzXI+Lnd1K/cIJIikPG+0RjdBDL426GY9JFE9UaN4u7Y0cdbj01nfsHJmMW5arYnVkqmmth0/XNdvg0zSG4rmzGLiyjGlB6j7fhbzd3M8qbV2tz3t7bMDXy9TA8t7eP5Epp8WD5SLmINT/w7NscxYeV/Ig5V053yzcHutDOdGOVB8JqHNUU5PysPR6EQkpAGefLW1BEX8Yk1WshfTHz/e6+x8XmfoSAJcAD9HuEh9MSoYXtJ/8LzFHOsXXDl3//6CIyefWdaXeEy4FMPF7T3UObepVcqaKDNBLbeOwuIBc1dwuKEBbw+MDiorOibsx/XkMjFp0c7zCc9s6xb7YS8kvPrLhN6EsjeJ75rzNUJSpqvtOQsSjyDq/3Fu9SxPvH2PhX/6fXLqda/frJd+xtjDS+ZZUp1bKD4YmohoZ2j27598DZ2HNdk0MuBwe/DAPQ+v4+ySPc1VJ+KS7nV2Vw8/Yd6v3gPHyASQPOKmW56geg26aydaKtSYmyRnkrQXddYi8PBRHr5yWnLw2XlK6ZsQQBM0zrfY+GND/HRNcZM2ZHyhot37w/6SPlIx1g38dCdjhHf0sK5wnTYLJu8107qQYWkNTnMvWxz1w+bbYFh8vcXeqdFA4ujj9zvdreVLIZ6Onk7iWRc8mglk59fM+ea7SkjDoNzsJx3iXB7mP19U5rsgVg4F9xWbQMa19QpN1m2t6ifBe6l9mo5Gnup0VMjezWAs3hU8v24W8ME5v37uHgXN3DyvfZtqfHsNg0oJmPv69rM0YyZmyWv7HjCVzEGf84PwI8Fdxd+4lLeWfA8zG7Lpg4+/B3zizHf5usX3TBLbv4hzyAwqiPvmM8QP93noxphibXQryZ4aXdWvpOaNaS7Lf7LP+r94DnFmiL9kCuuuFsOwVg7DCs6L4nWes5wYnic+D0F6IvIYbj307t/LeJMRTxRM2ehpH/gcJe2R3atsOqv6qzlNJq7x8hd8z3RADGtO48fQYtCX+HNKDXVeCv4MrX2UzDY16Fd2HgZ6jxkySCVaTfL0ihY9AhK/60abTt73Lkp7oRu+Pj1LbnE8vA7roYf7kvXqu13nhymfu9JhXtG54Qjex/Pb3/uc/x1+F6f+/qR4YWaen/jPgP2si0Z4lbRXf+2lEtPBb3L8pOz3/8/emzUprjXZgv+lXr/uugxBnuSa9QMQiCEIIpkkpDckRQKBBORhCmjr/9623H0PGiLP+Qa7tx/6oayqTkYESNra2335GirD+26r+DRUM+t9g57zH+Cm5tbOmtJfPcIrzV60bceD/ud34Vwfw72bdIr704fi7jIX86S8r6R3vimMPqMHoRlex65LpkabYusJzJrbRil5J6s6RgfQTHZub14dOso/yq5N8h5fmfl0q+RaOLyDelbc/whBY+LLprA7m/85rMkcx+Yc0jo9H5W3+fuk5HM6sa51h/e/rvFlf6hGdQp/k0CMp8J9klTPzaBTzZ0Z3yVtU56pTvudHHAPR4tu5tmP7lOsFSR/FxK8c3v5B3Tqg49Coq/12U1wWgkbH6VH8EG+vdnrjHwlPjecRt2sxl161/Z8XkXsAWidAUGHQ/SyvrfMlyeumcZpLSyvE8vvRpavZyYfYu3vd+thXfeaezvN0XBLDZ5p8DL3wV58XOuPMgm/rS/e6ZI1/vvaQqUB59+L9bA/vvv37xdf6ddqzZvyiZ5Umm8ufDEdw5PVSc3mXh988hGcXAlz6ezKPufkc+7GJu7kOT5IWSe+GXtNFTRWNEs+kU8F1ePuzfI9sdZS9U9aD53qjWaNaq++fy+u48JapL33vNhmUmavvIa+X/L7bsnP/Mu1TdmZj7XKGkDgIiqZVZ/xJ5lrie+Ek3L4nvJcY60G94aco7LqObuSOTTplwiHED0LaSbhidBRnE4d1kj4hXjr68Ramgnth+JXLj134XMU3u4QzzCQM4X8m9PkKX/GSoCR4tdUo/sggyHhHSHdosxhojt5ylx9b3I2Z35BR/Tv1nGl+LfCs7i3wf2u5vTRhgOMta21firgE33vsrX+uaxctadyEftuy72tWNqCU+Bhf0nOyoeL078d8CGB3VVoH1VeyU5AHHPmmpdwOHotcIUrwaxp9b6MifodnYCd66llv7ByedQzgQdFWG+XfM5GcSoJqwQ389323tq2J1leVLeY+2HPgeB/UMrhcc/WuQcfqR37Emb8uDb6HaJ1HiNI9cZehl1a13F9LCFq9j4D75PPKjD8VS/ZoR4YeZxyDN+BaF8yJ++SVvQe95IU98iuPeU5neCJwZ5RKvxrCm+cD/B2KFW9o/N4rgpfK+PisL9oFT4kicJ+8nppVWsJd0jpwMk3R+sSUgc62sNfz/zdG/lld9qMUZtgR9IcDbqc/2Pwi8L9TDFzUvdw5AXAc3dvW0lgL/YPr8rD1woFhLbceHebvn4HP+ugFqvZDPVZykdp1JHw0uIaSkLtU0vrxMLSGN80WNZnEoAr0E/4MxBGCA1Fvh5P3Qpje83LyKN+5NvgufsivpHcfxa8F3Ie3fI9mStdJZ+Z2AMeOK2O6Bw1PmLSS33L7cuot8HR2LPfheXfttxpHXTOz+IzJo8gwkQtX+Phg/xieE5gB4Zqn7pCroutl3/+bnjQPcoqeox2Rb6yz1xBy/umjMMhnNJcTRabzA3DCcvWgpx3pEKBM7pRy3u9ZukW75pHL5iC+j7kL2bCkz3mMpTkn51E54W9D1h+ElGPy7228dMcJ8RJo3ussmtuRmcmfrEWfsx1hdJZzto7y18DfIAq+82pXvdJ37uplwgHM97Qd3LGo5nbyvYQPXhauMqPZS2+XeKbrWdF7I9E9bHV+8ssVvzb8T3Rx2/CLwJuFVeJvB+0T5jmOBpPR4cw4Qr1dc+V5qATX8NtXJzv9PhMhx/DsEZ+R6eVN0yIf+R9Nkbb9jDYai4zeTVw+Kh+FsQ9X6mMK8IE8Y5SHXy3c48kF4TnoZLvwfthJg8O+Q7HKK1y7WvWFvv2ieeI7lErnz8WFbdr9AJ4HtQP255QwMPuSvucw4szfGNzXdNrTkO4tvn2eP8D0m7g7DT6eO1xYOchbNtv5EdlB9MaD7w95/KxJy9lt/Sn19iD/4Hqs4h3j/vxAIcFHBXG63X4ufKAI88ZyzOIfeE1h4vOxoK/ZFRHvYS1zPNR1hxUj+TbkEZnyVaSe85+pyqnIVDZDS2zB2S84U2twdxfex/pj3F9mJFhlnAMSAOb0VApbIO9dFRAt3l3DvQuIGyXeGY2b4p9XFQekPHk878pj62R+NFlZ/R2zk6rye8GOJp++vvfy832Mx6xi3VQA58vs85zvuV8NvrLId458kH0lYcS5wacih707WtoPgde0JtwTziGxfO27rczho4Ntf5d7cU0YyXckn3fRS9dyLcxvpM680DW3E3vC5w/2Pig9WFlddh8zLwnu6VnL56NoonOeLoXvGYn8LvcxPVXyVUbJ8CiaP4q3qXK00RnXFj6EapL9twj4L7ooNxt2+EZaN6rVWm1jBdXzqNeaeM3xhdSv0vCd8AeNd7EnPtQ8G5jLmW+lhzz/r/MeCgYf2D41qQUFF7w2NThwPTdF+r7ic7AeJUP6+J5VvuEtrioPxD/VPQnwzrqp+6LpRG0dIhVhUmI/9j0x6zivoG3AhyNv4viYtx+44vNdTf6NHMv8z4u5nnHPQcB4pPFzn2eLqYO/PUHvSZjjlmdpORukV+BzBOxzhpXax9L3nu8x0nNAr+9RO2ZqBUkaD53jaU6YOIIlDybmcmd43kl9QjZsHSF61qe7ZJH1h3DB30xdXlv1+dTLzhG+3HFnGWoqVqHQWLyZ/ysPkO8iXAuQDvX+PgicFdrM/TZmrlfyYN4FcRnhDaUOMxl1ySZCYp/pu4Bagaq77dyniu/5b11XvIMv9f8iO67k40Zo76Kezq/4R5zH629hFXmFmY3ixoFgqfYu1Y9y6O6P/7wvSCFNwX1QsU8PviKiD8AeFNZzaGt46N3hT0WOB/T7NWYff1h+Vko/Ig8OlmvRN4g1SjrB82h85wPC/3cB/z+o1pQDW1vmpZdW2Z9UaBzRtg8svEGfenHtu12ILi+yW6cGI/U5fBRmoFiPgdrfh4sp8TzkewEJ/PM+69GJ9RhbE33RsLp92ftQ+zBi5ZropHxgTZ7tu13zN7/pDtFlirXmJzTRt4nXeDY+TNj+lA4xsIZDt2ds5jOMhqHDz7nrUw2Z5r4XoX6C/juvrGXxHnVZ+0T3ju3B2+Bp5cyf2+FbUnfeZE5i42v5bTy/0t8grguIZ3NxJpLGo6X9sez5p+++MzKe8o5fPCx78XwWLyUfI7tX/eBPYX93NvbYDmto28SbYR4X6Ke5izS2OR55jSB3eJMU2FhGg9kvzQ+a7S2TmEf4KEcQ0/23FThwqy7RS0a1dzT+6QMP1uwHmrvPlizmumZj+TFKhwuzpcYiu9SXos5TALlH/WbupI0PGUeRI5Vu6maJJNNKpoSyTGkueVyrHTzkus3TOyZnl+8XvZ4rSXEVcvr/TF/zHoZRf+uj06Re12Dj3mDuG0jz+CEf0tbYGNFPDM/f4Ulk/7iWfl5KU1Mg/K2cf+tGXYpb3NBsx/TU8m7o3lbmawtS//5H9ROTQj7lMwdxtrhveBA35/J0VR5S8W5X1Ip+nrzLKyYd4kayuSK43zL5tqyL2XE2OqR+xjNf0e9X/SzKHAbsEegL1xwbc8ayjzeeKK9h/VZNcIe2KcCmP9H4b3rZL2bI8NrUD6fu1CdS6LVNnXy+Br1dwUdYNxz9tiXoKteJO7bfOfOltWpM3dbZnZR4F39b+QaFOaDSYrfHcxa56DzV/O8f3punZlJy/ybz00veUQ1S7uYXZPgCByDlJ6heCgrTSv7reK+c5627dFPWXQnaEuET4qz54FzirP5sjkCVj2BWeY/hh+Dsvkxex88F2fLQVqc6YbemXhwo2WrdPZfvP/j26BTnf3VbHZ0f9qWcQ9G+bXVm9Ic8kfnb3FiSrUOc3AIJyVaL6vmIB3TsnUmvuGiXRvbexLX5d/y/ElwrUaEXZEn6Jk5DYf1KG3UwuXw46++l/BOjtifsQcQT687fp1luPHkzVh4713LO095K/yWx9JpHVj7WcVM9Ma4GPfnLzOjEyvOtMavs5n2zdhldVbiOUo6qDJ/8i88l/bt87ImvUa1eQxqjWuUuj/17z0O8FBEvuL2P3imDMM946AR9YbJE9dnlg95DiMYeZHtzbcOcMZzn1zKRVPzXpp51z6vfgosjHUwEfcVt7DnNLIZvpynZXkJqTr28v9Fvm7gjQ/hvfXP8nW3g+enf+B9Nz4A7bbbXX/B6UQPnaSKnyLn9fO8u/sPci4ZV7b8x6H7vUYfh3VW8/LJmQS65mD8l7Mf2Xshx3Esevl57gbz+kXXWcyIT+4Sppabv/H7L3hH/p2hnpp9yvjnOhVLW1bwIjsGW/CTBzvuxQeE5Q62U/gAPRsP/aftwKn8IXOI4nkgz/rt48gz2o/DN34WLfm7tK4pH3viTgfqXmb3teKa+pL7JJzfPNe4cC6pcznlmdtQ6rMXfOa2+HnwLiitcw2mJRqRMm1S+f67yO6l7NlQczEv3Mi+jGyFK3nkexM1T+U5ZB2a/ImNIbCP4a3Up+ShsyV6Th3eyBmfkHxGt/bx19pzqRWmkpc03ITFvjaPcZfmHcRe4xIsB6ei93KC6xvM3NdMPmpJD2bxI5V2Cbyy32dUW1oVXbMrX9pi3W34FJSReDfzW1tPYvgdNN8saD1xrXrGOynzKVH8GZyNqpbDjNB9CCZyZD/phfJc4LVi5VQQzrEkjy3ycChey+fm3YOPH9XtmWwnNccS316Vo5vHJq9q3qnPja98alL3vvKChsJoBj1ni5my5UcsnrxNeF6lAWet7TQ2gVzG4rqaWRmxrF/ZjxVP05knwXCxa77NF+6bK3kA+DnOxCEOJWHmyruc88MLOvD8HEneZWABvBexjiMu+DUMiu9bfrZp4cO05m3slLwyffI144ykTE5Nr7mN0+Qal/hPkNbY9Gwq+9CqCVSmGelAtS6O/Mi8ICG/6Ro0nZWLna1W5r0ZeGOqAXl+WPQY/bHN4SLPWFPDPdZ3JJnUql5Zqezf/PWQdw3N/yhDReH6eL/ofPo4lOLvCsMedGmvns0WU2dR6g0IDkTzsULmVV5nq3LguXY42Tg0e+iOq+AhBMsxzblG2/Y8/PIzvuvZjV9z7tFeuD6UC/K5y30PlbdTyHUmzWSZh1J3+MPtrkswXH6HGH/Emjd5RiUzO85sxT0wvoJFD4M6ZmgWx0L+JvB25qHReuZ3xeoZUAPBHwEZYwHto5jjbRLf+6ys+kWPQ+Xv5C9d0rbBK0Jp5IWzsjHnV+Pqp80deYDLuRkLvp2/V8V7Z+pw4b0Q/soedcLfej4YnDuzBsDboGwf0WISN7tYp6nnqWdq5IEH/jL19DL7FW8i2//P8vs1/ksfyAYqOdNphrtS+GHNOYGXEguHl3OaFtb84MZz6PlhPe26r1N36lDN+Rf45sj7BFaLOTt5P3LOVmNteMTOLrBy2grew7VGojN6sz6TvM5NXoCaWV7s2WG51zxnCvI5Wcyg/2L2butSqb4AfxS+h7J+ivh5WT2hshn4ffhD9o5joNYsPF81lwA5Plj77u6L879krqm5OuLJJ/UDsq1y54724HSazjzRXv0094nuDcGM7EyQbHZ66b3tNjmTLnVO9n49p1p/OJx23bmdUZHvdeHtuPIaOo/2pfy60YNpj+2Y/cq+DTpDK/dRvMlTB72yu9jd/uC5NXwpwUWU77AdHGUvRv9e4tFk+AHTRcObucMf813VmSfEWb2vPGcbEhfgSdcHo3sh49zi2zqPsllLbpYOrOlb0cNfcwBqvvdZ1fwfaNs56yzJzQdLdGpZ7RznuNAejBllwr0lavmm8duUPkG4CvaMW81lSnxEv7NvDvTIXoOwEZOXAJylKtqgsTo/gAng+69zWaCEhSPLpOz5SA+S1db32jkND/ab/L0x3jwjzk8SDcrnsMyLR2YPZ8qQ197h2jsT9RnVjfl3TPai9mIXO66ehVg5S+rf8j64/0TuiI8zADPPWus/kTNy4PpJc4vUtQo3KbcXO+3ZvFL94XYXxawPk6dadm12Tb59nxX3V1OP6DkF54DVmtX4+URzENuLFHVJyfzjorn83P/wM6ttGmWem1wzJgXcY1HZtP/GzBn+hdBX/Ov4ULF36eG/D3pj4O+Ez6qzqITHWuJfS1jQhTUBzPUvzj11ztdP7HFm3sQZsyWc4nWQEsaw9Tkj+mrjl3rNFHo8Xq+ZvXFrcgVCmp2Lh02vuZc8Q1VnPXwPPEtTf+VyJ77KlHhgJoT7g6zRsDfcQItg9HAxMlNoDhLcSzNHN8w52VCOdFgfFL1PKavKzuYlj0DRVSRpCQd8zx6QWP/Kp1nlNDiPsp5AZdFh7RKvh3rUjK8aMsHIo4VwpaW+/jymsIHes8zvVvpFOz/8muHiwGOLfNjo/l/Ksb7qN+B979XsmnrbVpuYm72xXqZET1cy4yJPd/JJKXCdfM461nWa8p9T+WOGH8nc2mxW/XgTEH/xu80nq4T3splY/Bh04r+TQbNXzzAQXTmdl4+T9jgiTgeeJZ6PeZZn4BuB1J0y7z5iPrfI5tkZ3a3wRc17GrDOnOfSmLdmatp/Bef87bOtZOrv88/f6m4z/gz3KG3e3z6O0A9Y/cCT4igmQaaGNevbZGzrOTNxLmKsbeL7jsnPnnu9p/U8dY+G67lYD+9TrfFYVtw3dxuV5JxoD8McR0PxU8GhUTq03+AI/elmRT4JWdxDvGE3eRxB/95XWIJkIK5Yv8VeL3zO19nHRXyGyXPM2UY14sas5x644cx1VnU7PNQoe7HrTGaz9p/Q4ZAnl6kDN0GPa3bMZrBvLCxvxdH8aT3N4wadyj8Gnfz9LeGrdTIc0bd5dUJ7eK725RqXc4zKe8l8xnFf5TvyfSjiGlYejvBETB6f1OXSm797zep/8H252O/LxB32p+7k22hZ+bvzjrq/HFL/9vZxlPfFmU0r7kK0R4nWAxHeVNLffBxyvmcmc748p5HnFlZdeg+8eBMRT2f8MGu0tR/m6oZhoR8VHUNH5jN0No6v0X6YgB+n9sXV3+yvyt7hfP/oF95d6539cj2pnN32FX5OyD4Plr7oCrK5QWX906jgGRMcC/4Y5E092KGO/GqWmcsv1b5Sf2Pv+nu5PVJPa15iZ4p6dVtSc1p9tNJXOFXf+zyyVsbU63TWbkkzTHiS/tt9yrrFc8d7XpZLc4yWdM+xJ9r5pNtFujjzPJ88TpnDuL39znef+qOSeZL2MDTZC3TGqOwCrSvAjIPwKHre1StnZH1yjrFVI5TO2xmbU3+TfB10H+Px+l551bPyeZHPZC9N8XJYeZOyrFtL/zNUnPtf8LmT/LYkXkpPkGpvvoHrTCeD58ntbfZk+d0P3XnSHE7xLhaxwGqYJp/QWkV0D4jLQ9hN7vfbrgMOVntB8y3KTYirag7GWhHhAu1LPH8y+j6jpxJvuSfL01WtHcmFb+x5hkW85od9RhY/Azoy5qCSf+Ke89PR10M3R/5mS+6LqWepuafg4wSuouJNATs6B55D+UAlawq1ANYsMCiViWmwEl4LNF/iLDRwOzB//TwGGR2k2iu41lzWkh32h/c6PBEq52H/3J+504G7GP4E/21ZSbo/Z0+794ruWeHz8HPiTon34PYrhfdY/FW2w/55stg1x/Pq1HnbVpkjijPouaL5LX/zPEINffRri29vJpeVerF5N/GmxLVv7fF5mf1qX9F7z7B/hpdxc9Sx5qq9YSNzJil/iG7Dce+qb7opDJ14D8C+Q9mT4TVI9dhyI2syIv1SsMe7yP2Xb2uo8/kltQ1pc+R3qAagdytNEuTpjehdbXwQJi/5X8J3y2kufJ2TAU/fMCXc9srznr9xRnzloYQ5v5nV2d7AGc0tMiRi0iLRXBAa9X3Ya259vA+Pg8yrVG7PrWx+Rn252pOkH7wwz8QFJiRz3HyPbHvUsy89acOz/unCKeY+f7YI5pSZY+U3LPuTPTx82AO5dRbtrvjuMOYTFHD2Ftb4Ocx6qWA9r3/2b+JTkVxib/FS9Lh5XU+Y45/YWYMZDKo/vYb3m60DQt9+sLLu4TVNeQMT9CalPk0OejrhW4MzPpR5XoPqz5X05wYfZe48+Z3AH2d+sPwjFmV+Nx8+z8Ep76zUU6jEZzarWVU9V+tQMt8WLBy1dIavfmSvwyFpzgQfZr8Wk9m0sXxEbD8tcHTKruURL4e11VL32hZnFTpucJaq2ONvo2KvKXV3dz3yJqU8UbUusGbesWY6mxNq5cmszItncPwtZlHGTRKvkR8z67NrOQ72x+Gb9VlZD8+6W5mSr1BEPNQh9r+lraNvk5dHnLqWz7SdY29jF8R3S1/LOMXGo/Kz7Lrs96aMn1u2PnyjY9W5dWG9zXM1aBsYi2H90ZL8Ti+ib4f37JXraf3zl7LPIHyGuKDGx0VyNUljW5i79FUuUXKJ0+aHpZHdxKXv6mci5znNkILUz/kN6FneNkybyvuAOJXsBzSu4lkOBNdcLUvXeIY/pHsKy++ZckzZp6rQU83sWUo3GC6S8aL0eVj571Y+A2MLSrtCnAjje+yTl0VjJ7o7zQX1y3zhmL96CTw1q/VRo+/gT7/yGhvRDMo7n/cU53NCsLASPNC5B/XX5ovCujqDXW5euVV8LPwb+8UV+VrKX3TF+wHvgU7zGHQGx6/WMPFIOM9h/VZ2Jqj9zGSmKz/q1PJztr2By9aA9tVR/CyqUXFP98QLJw6G8N+U59xOzuMdrkdyS9izd3Yr+4w89nv72u8oZl5eL6iGqfgqPU9u4z6vT9Rl8H8q8/Er8JdE0w7+zuhe4Tncne7rdQUuR4e5B3lfDI1dPR++0soX+Uv9rDc1srkID1xijdn7YkEHI+d98ij727af+KCzydRZksWj82J8q4aItS5U73Wl53VYq97Iw2O20zVlbuaJGpd6vcx19KebKI2TuBOXfm+13iVfjHyLAsE1xDNDnj1jqsoDFdkGlAlkvDlK11MGW8EcM024p9XaXfgqfap6CjgB1RNfn9X/GkY2oDUUP14elcNoVlXzYcUtNjjZdve39CWDe7urzhOrx+wudk4P3rfwCwhT92TxEI+R0vzxz9qchLK/r8+rjK+KXUebHGDKuYjSZCce/yd/OWWvlt4wAed55TWrBa+wr97FHu+LjGu46xzmt5h1k7nF161EqcPZefRMP5G5fuEZl+Eylb6PZt67MX+PewPf+yRfa2s2ndE0WNlo3FfXnCJPUuUMSr8VM19EeS1/tc9SX1aYbfWUnw77NiB/dNVLbpHusRxw8pUX3YZwYtWLlnuxqnxlmVOifoRmij5DcViNx35nqHrYZIC9aB+QV56aL9HsYl1+5ioupuV7slt5QS5PuqsyBdeGn0/vJHhjzMkt+/tWDVLgXf0HMYXc+6vvxcvf9BK16u59lDar0bPSBNj+4r/1Kuesb+Tl4pzt2bPUMfk1hym9i6fAc/7Mak0byTt5504T5clTulYL/C/2do/ueX7K0ymz/0tdo/hTfs25xfAIKnBe2euIsiDhO0BzYeJu2D6nqEHI44B1ebS+d6slMHiaP5XU2eu1X5vkNI+tdLhtF/zhB9vpH9h7o+q5tcTz7+yov/qdd6zdM4XpVD+/Ai5OtU7rO9V+X2pA/39/03/W3/S//p//47/O7+kxWZ3f/8d/r7fnzSX8H7fDn7ufyeF2+h/XVbKNV+f3/76v0uS//uf//V/xf/3P/xrc2x7h/5wZ/HNZabTnC/fn8h7THApeN+AvDnpV5HmdiHej7mG/XRUfGvb2g374dvgQnhbNDCJ4CHgtCwOJMc/lc6fPGaeR8nKfZTOXvIUznndUriPt5/UI/qJam8FcATnblS/GBHpWym6HHzb2AK+bmbVyrc8+ArSf9jb3sB5vyOejh/x0Z2vx17jW475ROJT8bENPYyz6bBEMfBPVd8KVSx7kM4tcoDqfhz7XBg/gOZwlpzMEXvK5UzxnmJh7uXxV81vS/PCcVdUY4iPj8fzVZ44FzxgogwH5Ts7Jb+EZDa9hfYJMuB8uz33OKy++cx/d0D6h7LVoe6ZzlkDoJXuq75dUUyei09pw5r17DGpP51XNbeAZQacAnRL1Hp2jzuWxdAq23h35NMy/d5L2fHH7NVofPvB3pirPnvleyseNOSM8V9oj3zeqy0wQXmFO+xrVsRe5j8Fztyba7g0+g/EJ/i6Kx0HfF/62ffKXZX2pxc3S+C9jFTp/T7z/GmGddDebMI0Twuzou97k+yWV3JqSbO0JrYvJrgn93slfQtdBs3TMSLDvC98w/rHYneeLrvM89Vq2v+Gf8k5ozynpJ+mZ4ZqotxHeeFgf3rn/EMx4/1qYtwJTVvfdFR8axhLp/c3ggKQr4Z/JemwiFxxcvs5wSWuH1pLKexjQNS92bnvarTqjtIpe4kVp5+ARuPLwLi5eOmmTvVJov/n8qfcb9rCALy7lIEuGN3EprTxqU59rb5WMtxzWCc5qiyc4TMAJpf7Gw++MFVcdXpHkoeTnvws8YLxPntfxcxCvQsVDGBJHCz0y9kzjj5jF20X/8kG8hSX1B0kmH5b9QR9KM05rrAbeU0DzK+tMEvy2XQ332HumqAuIj0T1AvUT0BETBobs5s2KPdZQV1BOdkZHjPdm2WYthvj+Qr9jsMphInq2+8qL9wGfj5I7YPN7GOdSWRo059zzuYL9buHA14Zw9XuwdKor/juVsPZdcki60LveA9EbqedtcQU/xHeZvXf69rXj70zhTcraDjwrr4EatYL3gXEf1KvgqQkPTu7TtIBpSJbqcnqIHkea+4R99BRPat8lLIAzCHV9KD4K5C3Hz6E+hmYxYR8qlWXWpTlQrN5H4MTk/+DuZA6AeXBdag7K1yKuQy/ZKRzU8rcu5rTxGfOQ/eFini3txbyPO0Pkjo+nM+6RkUMnHsOWv7C8T+xZHYaecwyTygvtGfY7wL1Nzv+EZ+XqHgkue1Qa+q/OZNGyKG9LO89L8yqyvCOu/3NZhIyP2Noh1c+iP9225zHral/Iqy3nOZjR4XWnznTnuHPH0tv2LH2V6L7ACQRuZvg9+L43oxW6M38Z9da74rOwfo/WzqjO15mtv4BdtZPR+oj+V2bqzUv0wPPhHAesAdQfdNa2Di/AXNl36nW9UGcZ+c4mW+6h3dP7DGsYWFQDddwlJg4nNOLIOkX/KBy/nTtbVJIf82wetq71ZK3pM1Lh1HivhYuePcOl17HPcX7nh9WQfHMnih+3CfZT6aNxdjGvJEzNHDWq0b6MPUXNTbGuH7zHYS/PXcPHYT34aF3Gs6fP1w/l+fG6diuUt7d2uxuH9Emz9nJeHY4W1XZ7UlmsZ+4r9XhU3yivO4trCN84nX0pe8kAudzcA5v1em8PF3fLZ0X2BakXVH3Mf7OntPyNJK617P1f3m+8m9iDMA+yvkt3/GOeTNuzRWNu86c0N2PZ5rpLry/xhuYZJT2jlVe9hfUhvxtKR3dvz2NvCK/SingDET85EJ4h48tK19b+malj3OZPaLP0XFrxr+DNxNnKDXk3X3L5fT+X1fGru4h/LqUGWVabb5NF1VlWv8t8SPW17o36G6/Fa4XyxGgdH2PrjDNc1O/yWeMb/M0w4/JrpDfahPtEzYY4t29mekDcv0DnkrDmmr2wn+x7NYwt3zM/dSVHp1BfWbn00GkDd6puyMsEXI17dt5GHhM8Q/6wfp61v+g/imeSyVDh9Se5pezRLP+tvuo18d2yPYmqUbjPu1rnG+VPKn+zd68KXNXe4zVXW3t+szc1casmlZ3iP0jdKt4BkvEb4W/DO5D7eeF+Yr8wPsbW2gWPQ+marLPO1MWkAbip+oT37GJGvFwr+yss5pXm62zR6EPf6LMHTfbcuZu8YXvmL57oMufWeWga/5VrBSfzSD2DzIHZ79XdZuYW8CXzMvUj95IzfkfDWmMb1px70NM4qOHL6+v9vnYXOzqXeD5FmgBg+nvmqfO5GaSfG+qFFPdK7wmkA1PaWJqNwP+N/Cik5lMZEHbWhg+OqHfSnLKgllDtKTNFw2ugz3Hg4cXZCuw1AO7LNUyHV385JAydnhHrRu19GZrBwj4zWB9e0Pub85HXpfJhtHNYrHpXvCWJ+3ZGbtSgD2y6UYlnVarPo/pE8CnutZEPwJ+h/PKajxi+98vXb9kcbLzPC+Rr6x717aNbs3/GnNeWZqnbnLvdeDZ1xz8XXWe+oOucfBv0xpnZZ4T71n/Ne8edB8+Lyutj8G08nzwyHIKeaDz3yJR4Oud/b+SJTrtT/Qgxd92398ta8lDzspG7sK91+5vfp5yEaA/v/lY1z1sczaoH9O5xb32ms4P2st//HHnVpsAhWp+vrcNLmbcK9dCVadvtOp2JO3aWVXc2R49qPZ/RvXnT+NHj+LFagN8z3oS9zTWqT/ieba2fMd/pQ9bh3O3CZ7jZnbkDyWGDdoD4sOxtrHFC9x4wBygZ9JT/yXAtGIVg0fm5DOa2tN8J55T9WUm3bDTZSbj3v8F3nHPJM/0u6lnyK+CaTGlN3KcIe0XrYOfAXLXvB+sV8a7SjII9X6AHtDLulJcXY5KJZOZugFMKV4ayNoOZrbUyeT/oP+KOxXni/e8PnaknNfogPVbJ0zd1LoOt7oM4Y1zWs2Q0ffuLzCejO+z+HU+2nJeo8qGZtU1mDO25xtsJz1wy+S6MHWxUzuWRclO0F+2kzC9gQ3ODXtfi64r+Hc+908CM4GpmwgpHxNmms7txPkF7vRM+QlELnV07+V5COEOkO/4mvdzanpOHKbgKzXok+RzwxMC5UOLPUwlrZ+BqH/LMduHjJNxNyi/RPE/WZ7MO0Jrb4nltiMsM3kPPJ25KqU+PyhA1XBnby/0D729GO2b5p38xv8xlumr/ffLeL+T09Gg294g71Ux2Ae4n9Irw8SrzjJpp/7Uc3sj123/Yo4ywX9LSrzqt7y+YEaa39Wj7dHnxwLHijB6dJYJ1Xhs/yN9wfqB+jTy1gR+Z+h/4Q3GN4d5TvYvPyuQ7MV5p1zQ942Orajs9M+PfL+PtfbCOZ/oYPLc0ViRYsfZslzNxPUht/7XBmmfv7Kdg+bKZerXIF+9aOVGkWWOOxMJ4jsM3ve7ew47yN2ydgy1nR8WEmRnOO86FYf01r738iJfD06BTfSxqweugt6nE/fbjbfv9GtTcygj+ZDP0+JiJVq9l8zT6OY9+7rHqDMr8NrSPGXi7jDNb/m3Qf/A8MJ8/CF7GmXQy+/EBtVWBg8v5uKzLEj8MVctTRkzPTaEds7SnxLtfcW4XY8nqHve/8uPCeeTQ7IhrR33PXv1O64A6d+T5R+VH807zvNaNa0/UyJ9JVLzvhm+6pGsfzCtVZ3RvcC3QaeqM8H9a+7ov3gea5eHceG5xzqjKAku/498Sv+5WfG+Ivghn6W7WbY6ns++4L/AVuYIHzufrV7zQLzxZS7jqyuvc6oPuKodP6Z3BASS+lPe0/rnNfg85g8CruIbbKveU5Ida3DsZ64RvJGWRHALW5Xzwe+Q+LE7OxvhQ8bti4eqELVLm37KMl8me8+KNmMPy6F0n32CcI6te81b2rmtPyu7mx3yxuI5SnqONasNjCE3hB/kIG10HfVa5J6CrfdCM3hj913/Qh/SNsABkjXnVa7jfXSSrzdbLczYR+QpTDohgD5J/SfkopC0o3MtBp/U5ynu+KW0RaiF1hiw+1wOHNC0/XBff29fZr/Ai1hmDwGQLuiXtSX7VWIk1+1UeTJiNj59blUF3s5gvbsDF98KLYG5niuwcmlPDA7V4/mlO9OYc1ibrl/p6z5iQzmKrcD6HPlf+KPsbr9ssx4n8CHi/ulvZgtKvfN58lemhdKc6u2hc9VPy3y/1PVB7UzbHjjM27FxH9Nz62jvDR+yNP3huPVjLPed8nUKGm+Vx3QEG5NRJy8FY4tnyIl6/fjylr7Pd9p/a+7YxrffRrKox4eHdZCkqH8nM/uhZ12J4dNQr8Z745Z5nPMLv7mPZQy7VYIdr+sq7WjgVOd58CU+J/UCbyK2WzL900ImSqPp5GRKHariJ74P1T9JFT8hnfFh/vS5TzVU13K2Pw3rZ2YSvnUpj6Z5uo/nuspwdo5fZ069R9fY5qrf2gz5x7Ek7g3v+Ow2/8mP9J3X7HzZ/hXU6WI/meWsfyE7ZM7TzDi2fZtSHqbMlLSBrmNb+rFV5fZ7Iu/q/49k1T5Sr9ZzzkefPMc8wVxtRdjM/9y2eR1QDJtU6g7c/8k6fo2fnMuhU/3zd3u6o81aP19Nr7Qlr4EB6wU7lEz6xpV7y2ylrD+uT7aDTbeJaC3XYv+CjO+hMOX+H3hu6bjufquCha33e5d+/z5aH7kz5+bYOEfWt09z8aPeFx3r1GNSH7P/AHOkD+kx/SVgqZp0b8gH7Kz/dIi6jPI2U5yz623MEr6YZ58QTzy3TK0uvxX2Y4sok5f7S40RnOGbxWeIA5fBFxdX+z/V1ef4V7d3296geoRfTfj6SvyIcyGPYabvuIulqnzfy+RpWrMxH67O6nH205H1C6W81v4r38zNjOoQhZ+Zb8LYi/hLhz5zVVdJrjW1uks4f61AuIK0P0mfTfTf4geURQ7wMzL2m7nCR4QkVMQqzrmY2pwvvJ+pg0snb+lDgAsrvb0McgLQhHE3xJ0ibV/LZ+CIrRPtcQFtBtfTnetBjjIueS394DGrQdjLfk/5ep1pZkd6H1xr3u2PgyI9B/+k+XpbotKlXmioeEM3xdHav8v2EX0GNZ+M0n6H3HXNp+PKW1wnsDYD+qnWOt+1bVHdOg+cn8AVro1qDOIJUL/xzZxL/HYs7H2qNqsqcecrUgoUMY/AJPKoJmQOO2u75JP6bn+nIA6bLnBnZBzgrlj7vycZiDN5bd04jb3xakWaLc3TZb4NxQb3GND9neoWGJNpydorsO1gzF/ZxTZAfd7Ew6As4fz+XlXXUH3/Ch9+dWZ9//ze9zfvtR+TdtJ5i2nUWk8Wwvai4P113+AqtVbxt/5gnTfg6/lgk2Debkx9z9MLQX76ul0We/FZfdzd5c7vfs+/4vXUgHwTeH48DJ2jPHddZ3FuH4aN1e33m/xnN6X+f6f/vVOz/Zv6nE50GnfhjNavWDG81Og66zTeab++C19livBh0Nsegs1tPu98pJ3bWTd6mj9MX54zZiwt79v/Ks+Vf9pIr7O/ESxp0q+6iOmG/V28IT60qcW+tbEZ4btAcW2W5M6fwr/1y1Rleac5m1fFkskB+pM7uPi927uvEnQ7d3cLkzYgWGdxLxsxaVl6DNaubfOEh3iPd3PNk0fgx3yXPkwU8atxuMacZ3mbwjXKRnZog+9rvjXd+p/UneS3WJuuR214X90fyc9hE/bH2fWBe3CdjU53v8P+WMwHnHvbh7GxczTyZwz2sr5bjEsyKtajKsweaMDwv21dVZTbPuu5sSp7Xzln7xc8yPP+ThWOUYB8+Y6/C7aK6QD6v1D8BfNdt+wfOy2CJ+hiZiZjNkub+HrHOD9yHIp6juRDm75bUQDL3R51gzeINL/dR5tMY11+bg+2g9Pzhf5scRNugcRh7bY7uJet127r/2DbhCXQN9/A9JC2ErI/WcfDxT3uf2c+Feu1l5+9/H9z3wnfsj5knKV71gjPQfcaZN6f6IXN/aa4UpS5m09B4mdpOeZBj3cKz9P60z3IJ+N+Rs1B8buxbHXvDzDUSrqX9ypLcc8Tz/RcwyXLPI/s9wx5bj+6t9Utx9t8cFv/bsYBPG538Lfd5f1U787vTGeziOuffwHcx6lQz/Hn8d9GjRoWz+vmpJN9Gn0F4l5Xu+f5jW6KR0d8N9Qnm6IMt5ZaZa9r9uOX7sTHNYf/qc4HVqN6vuG9hhq98d+0M9rbR2XSP83nliTBXdR1vW5ObPFoSXkuz6+KZMnwWTob4u1s8uB58dJ7AzaT7z/83ZgjJRTxfEpMhy9yVqJfcSnsW+Dmyjs/mPQv39Pip+USd9XYG3wPUGZ32BXPEKAXv7hN4/d33btuRXseT46jUbwuZajmtr/ifKu+PqOde1HkzS8Y/5tv21U+P4qWGZww85qlQG6DeDret/aja+GN0v+2iTlQ2p9E8l9FeXTdqyN+vBV67g5ev5yKvv/8s1r/9a7iF1RsLvsazuHv7ZVFpvllZgxo7NB65GS4z+HqCcbYOqBV9D/Ms4n3fKf+xRz50J/aMB+/I1ua8irYGM42SHrqz+/dxEpqT6Yzy9SiltVclvQp5ADgNpfsMe+5+hf2Fs6LB4ajCp4b7N6xbM/8s9YdWmZXM0yM9X9wfVpU+i3AIzKGMRmXt074C3ae7VjNyVeMQf561qCWeYNDzjHM5l6zTiOox5qvg/W54fnNbr/ZdM5co9JnHz0GnCu+Ui5ldjMPlrP3dPoNl/tpcdtYX5sjvvr0l5+il0/gTM8UXt7LGv4Ueahr0hbvt8P733oMvvs9W78WYhyttpHs74F1jXd6Ocz0/qvgeNOtGNh34Y0v4PntPR7Nm3R39bkrzr58+7vN++tPo6CZH2ZuS4Lnk79Xk3zp//7qKnIDgFNZwL3lum6lJPedO/hc0r2ufsC+/bdsFPGs0q9pn9ZmfRctkYJv9kXgpUY4zWsx/Iq9rwTgMNxmz9ahGWlh6vvyexKewNtwGJbUwuJGDj0+aSf7Yfv/1sv3+a7QPjsFSPner+fjCbdwkWX9hrpV+MKf7H/R5ncGloEG+Ky9Z5d9p3kvthy0zGOUriN4efzuo0bstfAWt6eD9r4gfUea46ARyPFfoU4hLrLxyHoQ3dBTH3DmtasCDxxu8h6KHfsRfeiG60ENVVt4rc3SNDzV5fhD2By30veSc8p6oPsc7jnzW4b30PdiX6oFNrfMrqjUvg2IWneTq5es4cLWY5821YsZnzvC+OlnNNPIz/yb/uZgJMmtqvj1zqRWmVuBEs7aS19HZrtVVPy57bMlzID/YC/mOkd+bPG+lrdm7lZXkB0RL9xgsp6yXoPVl/KZpDos1cNd8sU1cXF82X9v2x6jYeejC7/0wc2Tlxct4rnCkt8BqV2WzRsri9VFP1MHJy+wFv+VX8F71YzY5vMj/Peic1q+z3bHk3C1kjYCLrd4Ht7L5Me/mtBf96Z2ztwh//BUvkS1mNNHR/fs3ue913/v8s4zjQDmdmIt3Dr9G98OFvAfvjUZIGK/t/5KbE9SaFbNOaI9Sut+S/MfmDtmhI9J2Ek8POrar5kyp7Mm8hhdZTKQpc/LX9Rfrz0HfJvubsyc9V190kXIvdDZDzanbfDprxit+VWOcdZe4JDeO1yx7UNH5wz6QD+GqU7bFaNue4V4pzfOwD66V1lMr306t8SznEIkXPj2Xm8bCVsjwNVltuMZN2CMst868gGkS1caJzEjIjyG6l++fGa2feS4ZvIR5lsiwexVPxyrmXAfKBus0aK8f7ZNzKJr4Er9X0g3DJ5rOnc6GZrhhOr2yx1RwfO9Pq1G6OLF3GrxawdlfHNV3KLvO4v1S3BvCERU2t4mNJvHse+fEeJvLnmbX3H34LSX7VUnmuGgjgJ8m7BVL/IHcd9OZwax/7H0eo/rkD/k9xuuyOFl5LoJ1rfLdZWaqni2dvR+iicZe6s53U2exrfK7pn26u+o6v8qroLUBHSt7AqncIKVd6dKMP+xPD0rnVdJPUr00EG/NLH81z28zuI6la1KajaImNFO7i+6EzkDcZ2hmqzRDE+zaaHHLexK1ZxLPU/wTKyX1ywNnEO7HaNs6zJV/X0dzQ0UrKvv8vNukWnqb8XSRs0bOWrkfJdd0xTOFljHW/iuCZ7KumnA2ixOTP0MuzIUJjvhdPqsG6CfWI4/mCOtRGqPnO4fwLWVcjDK8l7UqvAupZhp53/XPx9A5QxvglHi8KY2D9fMB8aAyf188dO3/1rqgHl/WhYP/N//2aG/v/9m/R755XrxnjmmVMkoGnQbVROSRuiydCek5i/23fGiZlqRjSnJ/b7NaDuF9kERJkz20Z+3oZdaCv1wVa++rz6DrWE4bEWqSbTt66ejP279s7X0zylzzEOcxcf5eqdYY3vF5JXid+Z+N+b7Rr9GeOBuXl220hg8X3klwQ+IanvMN3I8KcIOg09oPOtGx4IPD+0Vz2Fkf1B75cm9fXma7r3gij8BzgTmc0fcPtlM51/9pvk8O42w//GW0HnKtLhq8zeNlxh6lpD8nT5PJeqjqLNboA9+Eh96fnC2mam1bV6r3V8vbsHBuFnSvo237mWp0VZ8ij9r+9yXnmnPGgJ5tnYzeDX4TBRx4/dKJdgUvDcwP2TfsUTJfAS/0JPOTbB3/7+dJMHYIbpNgB4P14f/K+vjsr+mfkbLref1o5Wx+Dp/36P9MV/vV+j22TH2WKxKdxwAWJUSNyekrK0wBIhHfC1IUGBS2o4OfiZiuDSi0EYRqjmEIOjmoUNM9GSTVvq/VZkCHvJjXg2wFAYyfkkiCDEVU8FS8JLJFMnj+/EBxTSDuR4OMBbCJR0xoZAKoPAD9c1slhpbgJxzQDAZTg0OfY19DrWUtjoU6zMW8wzY0rZLgEaYoYtRpES7J2E8OTiYpo9DCZxFxAObiMI+hISstpBOJwi3zNRUSIy8QE+4sATeFfM3aMKEAuMJGQyJyCXHPe2MyCsZ9HmsA4LYeY6Babx/9OsJXuwR+BwSkq2KPjK5k+EagyRkEYSxwMmHuvxqBDMhIMN3VhtPcfPsdbUj3sJqXrPhzRoHVubBi6/opGNTd4Z4FPVdMaRsfK7x8toCJvu/TejJrP969xoc2wiCzzvhuBymzuYOEiHV0eCQ3MHdV0Lk0EJbwCYhJj9qwypgPbsL9uK5Nu40REAkRBl0yAzgpozhDmrIJ60Q6AnCggiF3RrxAIOsTmk5zv5RhDxUw2AylgWrThssAUVKRwDIiQfN14BlvCMye7NzevDp0JGSCGxomEeuwMBFoE7nZmM+ISIpCimB+ysWDf69a30+e/fNBXwOZ1tbHCA3Rxsu0EUvgOAVwpS6MhviZ3BWRDOYBEJaRmAHXClHzle8TB3WQ2VI6VuZetxAGaNT46Wu5hDWYQbOZJAL0fBKrBdoYNvQQvjVsqP0G5haj+rgRpq8XiFnMYJqGUTDNt8A6mPImuyAbSkUmi2isaR3kTBkQNEf3xTJWjnsOBahn9lTZg/mzYEJZpSY2IEGdFgNZhkX4PgAB0SDwPhf3vl86W7yfrfNoViGgH8U3DsjR7D//P/JZ68HzpzoUAVT9Y/D8SSEEP+RAo4aVRa5k4CWAUSVYqgN7DEE3kSYDGJAxceUy2j59UWyZ8Ecj/vrchOmJ93ky2CYR1R4BXwT40rtM95C+GwPC6h4DkI1pMC3hWVRA/OWgnAyTVNA0i1T4DBtvopq7FpBm/YLQ2zr2D4A9zbUOP01J9Fn1t00TclN/veLn/RoFO6k9fxcs2/icbeA1Ehoyy9nC66X1i//WOQmWbRIJE4ncmOfhff0IvI0KMuG9iI3YjxSYCFMxZeoljSHdQ2e6nBMRv4rBGZm5Bdu2/byNgHhJxsaPuEbCoGOQBjArAJBmztI9hLeybnrYh5w9EeHJkM9Jg7SJpuU66FWP7xg4ZQDj+BCS2W5DC47eIbK/8ZrhoDMy8biF99ZVm+BkhnPZYAoyKaAwh2zIRrAkkeyWDDjx97sIq1vjPDyvyOSJ9mTz3uv9QoGoJhwTYoWwHp+IwKqAOxn0yh5AZzmBx3c2ho1qyZZJZ9+zZhEqvKiPpuY71TaBl/C/dTZkEhTU3B0Zp5jrv4c1uX6vdeTGnszKiZxrmTlTmBo38Nb+ImJvn8lHdP1kPmmCYm3DDussQBPxicb6QkFifWqKRDjrwuTkSgQ43t9/4j6ScKCX3EbpcIN7WwiLVsA1n2V6f1fm5vL8jIkvgaeZMAU6V4Ja4xjVTN2J/UwB5SteD7R3axKs1BMAMck4RYdeNMms5W/tmRM5czzn4nsxhvRr2zyEQKu9MsMcNnCPKGirT+eTEFBpX2DBU3bNAuC7M2Hh9qKFUkrIJECUZfa9BiFaRODKxHyD9w4Nx6qmSQgb9fkE2LHR+kkHoOc+B0A0QjUnqg7YJ0zYoGFwjLpaTOGSx6ALw4Xuet5tzhd3qbesvmPQaS9NTcMmcDADUj1CmLp1X9aeMVZpViVUchPUnGO4VQGfps7EM8gJP+o8vLT7HDLxpDOG3wWcL9Pi81DCYU3+S3i4I3uSdWbtojSB0ezuTQKn/OVOBk+6N5CaLreu+3h/G3sGRqmGZJF68TNIMMsAcZfWWQyjS5C/+zsB2K1Arn4MQNEiQrT3gdeo4owmYQ4GN8thBYT44j2DsVWTAiItITyJGPLvLPWVeq+frnXt5SVPWEdMlqW958SmFZmzYzJxh4sFnzvcN9J6t+r/XpUI8WL+p4PXC9+ZntXnho2/aB/FEB2iBhL+U6CUMbVCKM0eIaMhC0Ir6nO49hySSaauV8wzwLC0lns3NyET3niNZ39+oYUE2uQcNb8SywaKfKyA4oUifpq6VP8uE60AipFhbG4PyPXWPpsbf7OGmgy29JrXsGOdxziHucfYo2eFyT/AVDJagBCseE0E/tD6rjUSc+bJmS7XxMaFtO7EAEz3MhhaJSR8pjDvdjXaI4RgUb6v4bkCkEl1mJsC7HEOoA7Ae78Na1N1bn2IKOUycMQAbKaM/UmsWvgcFeRKew393wbcNyIHNnll0n+cBN4Z+92ZhoPcf37GXpIAVC5bm34dAS2md1WhZBIEfdF1U8kz9b3pNeqjV6gmwXKaNZXfwjjFGi5JjSYmZ8ZIfj8lg78JCFn3vAm8NndTa0UF+Rx8JWji52pCDdU+T4QDu89ng46y84OM/giIt4gSNEDc0LBLjBgqElpwMWEgppZUJAQySYdRVMnzVKHBrnzvaD+uKMIR30uFG2RCCzcxmwL9iVoapjFsoNDeU7BV/tkoo5X+Kwte9uODOa++FzAUE2C9WPudIcjHWx8Dj/30/m4Z9ubWTVXXDMbYhc2+5ExU6yrQxK32JepV8B4guCkj8CQg9V58/hRAZBmgqVoprDXVXkp176pHf4tF4EQu/9RmwZnv7RDxZIfwJ22eTnukiJd6FP5F55mfNhEiUXlftpWZ9C1eDm8UXiOEP8sIblM8q7L7jrWXtifJmIJns6JuHRB8jT0ObOIeVpPXC/dn4QydBYIPEeKNs68bDOddTRC4cZBnk8lg1vpRIUls2DM9komf4HIlZ4se0ot47RR4QcVeo2I0nMEBbENjCr7PkPulbsrhWW9b6R2XWaLV1ziAjVlMVF377LrjBQwyFtt4nqmdLHPCKHVVPcsYlPVvMJYPljy0HhXuh6pr5fzncKTHSoYM2ZpwTbWVfFdz5sJAqev2Jq776qrASTYD1EZHNtHNCixVpuRn1GKDXnKmOrDnXFiEzrgP12tcq2TPU8YRYPIoBGX6O3iGFokqh59m9txvTP6IH3Rf+tNrRAO6m4XvumyOQ6GKLR38NIJobd8W0/fT5d1zziGuXbAx9H1+nWpdR/ADhTXj3qG2O3PN4V4UGS7otDseTIgqjbnrDN1JdQqxcAZXV7WQWgOZkDW6D/FlteQwE8KAiUREJCX79+XMUs9bjO1nBbz24XsBG42lEg7Hpo8qPIZJ3fKzq55zw/uRC8+6E8mEzJ3d3RsHuUttxcEQFCyQLtZudTikoFzLON4OWePebZjoWp/eNVVD4OfjxBimfV9LP/AyMOGKF0XOkTXARAoyMkou/r29C7EfLMfWLIX3Pb/cVFTX0yCX4IwQc9FHUKgt42u0hyiIBsf4jt80nsxENZwpG792hmkhE0jTFg/HOGhqPUinSbwdrq0zKnOuaZOQ0jPzyXpnQWISwwcEddZuZ8INtNA1Uw+rz7iFNTKQYzOm3O+pcMyRMd/fZOsVmCC7FV178J69jdLmn8aYio1fiEiwbbNpO59NwDrFuJSeZ2G2ATO+YDk+Btz/Me4mZEQz08LshAPPdB1H9ZVVn7DR/obx5s+jrlX3YhCtydZKsKwNYICpYa51krOF5g68X+Pfq3XU8lEdM6tJyfwE63fMptm98SGsJWzgvJzWaSjd+7xKnc/vMQgqewlBy/9b7t6U4DMPCo6k698cYZqWmT3OjADKdeIfTNRzH0qU4uuZCg2a7zBu/8HnpMZnJvqc1AKrq8II1O9zcAuZzhSCsuj3Zsrwjo3S+DOBeTidedVd0J4tMzU2eJHzIItt5M4Mqam5R1Jnwcbul0loCHy65jTeTHCImDwnc0VKtEirQgLWwS2EffseDLcXYlKJs+0ThjGWMTDw74E6T9vhtj2cu+0fi2TqTE3QwC2UkBw5by+8njKmk7n5oJqdfnKdDPyUQ3ZJOBDQvzVTtRYiCG5gOi89qDI8FDIc/Q07SMJ+7vI3fnjObp0T291gRrjqNTGnPDOJnbD1B9eWVriSESFdjOnxTYvy/FkpgV3EDdMz950SkNkfHzV2x2bWFewvwLyiGrAomW1pQYuETYFIaZl5q3BJg60u9kSkr7ePgapd7ftgkTCF6MdzQXmP+Fln+rH7amnMPRkv49mm9BJCPlK1uH5nT9L7oVa6xSzG3+UIrnovNHO4WyZ0BCYwvjf+ExiqCdOiniZLBNknm1AFeGfra4t7IJ+D+r37fb3YNX+46hnIs+LQxCZII0/5ICJVqylDSnXvldFf3I+vMs+n92bRbUzmE16rJWbumxz2lXtPs9gd99fKRHT6GNVw9jQeZMivn3PGtFBxNYT4B05Ba4tzdpC29L4sgTAqCFDOVVPHUV2aTiwzf3omezkbVOAYEfSGhA/GF1qvVDsxpg3jB5hgBTxjPgHfHJj9UkjyeKcIF5RrEfNy4iNYPc+yiAFkTOJ5b87V/lMxFJXg095mwz2w3FcVbmm9hwGRSplgWJgbew1gKJg1stGcwrT4embzyqej5n4Wp0OtMcFCp3jv6dmQcLTflmCSOBEcZxPdW1t1z+31M4Tg1BJnKcOlIIXZW0MbgKuAQBZZi5kozzsk6N0yqO+BS+EidBsBcCCEI8zsAaNtkMR0qEXHCLVBeht0ua/PiO/E7GW1RK9A/IMzyFmEr5ua+uRzEPHJqrN0fRbdSZB9iWqbtRYC3Qt7wR8aV2BxIXqLlMJkGOdlbN6Y1JLpQkgG/epc0pjghzIay2M1LJKw939rfi91FnM6qB7APJONb6lGIIIm1zs152btGSfG9g0e4y+Hd+YJDRsyC2ZDANkLFxJgUsZJkXAqM6Ps6Z7wmPnv/QC16xb7cbTfmfmsnh9ybWJC+gxvS63vqdv+MXCGP+ZVev4nhLMAXwQJG4H21J9l/mZ2JlvyN8vO5R8UjF7z1aw3x1mTMIj7lyTN9armwvxZhGpZcbwx2lM9Y/P+Pgd/bIo+4kj1fX96LeBLWVFT5p6VfD8S0Rc/X/rXbne9qLjoo7uDruNTiIgWvYlgo+7emZ/QpLkf14AI4UvSFfUrOlBF3m0VKjCthzRjc6oc2A2jaz7fViQgaROpHaIKMfHO9nTcP5u9quu8qVpvtOTrDujszNc8wFnsWra1niwa3ez1V3mdaLM/NoS0Qx+I18BiUQ4nw76kBCs1CYajd75izDZYpMXzPA5PZFEdAiippx2qwCX6eeLm5Gq2YV04b9l9Gz1R7kxWhr0IFGFxSn6GmpsZ0jsYwMRpz7WV8MBqjBdmcTHul4bV95lN7ifuD10TxD4rD5jQYP1i3++uXUe46xeanXM9qwRjFKzHHB07VJGFWcSzkoA9CubDGtPGIgYL6PGcgQ35sDY5yM3MuxMKeQ+Xr4qTaZ+hJ+xP/hZG6c1b3GmwGTR6APxcbXol0i3qG+4FKmG9pcSYStTBIdsUpKEMxTWWcVHnwrKOc0b17eA43M6WIeeRzwcOSVp5DRJBK1GDrEcxTCVsig377XCQrCAORimYNyUyQ0hE2AGxjeBpeD+cJ5qvZ4RMFAiiuEuD6azdnS6Ctrv4XFAv11N7a5XeQb+T5aplg5sEA1Hzkm6T5ogDJ257EsDDvFgL06PgOuoDaX2p2kH2HWWU3p240/ag+/ljUX01sx/VQyN4LnVIjK7qSsYnVH3vVFeeqzBtbQAD8UOsAyD5HbUxMDGntbBE1GQwHH9aL/hsoH3I9xq8b4Kn0WEDNzGQVv1znfd3Xcvoz4NRe+gllhFadg9T76uFs5lewaob6QzwGg0TvvOkghPl+aFWdnaBBGTNd83horIwnLQW4ZrDedd9A1Hdqsd5HaoAaOntCXdjriCMIi6DruCL1F/oNZPZE4SP9KIMlTROkhH8KHGbEiiR6eVa/7vMB0nwq/YLmoW6EI+c7DmsDtMUnvRo2+4hBC1gjk2Wy1VrKf624vXIft6WMLdFgYtkzSNlHTyZeZiuqfJicufyvlT1P2M/Ue274mtXw73Vk2ueG2PVLKbK1Lqv86rbHdhzf+I/TR+juuGeL2vNekiGr5tj1GlsfQm/Ac+JjR6Yk2XNbClcSt1fcz7yXmLNCsTYTguisN522cB794L9HKGkHBiS4W1D1H0MEKIrvb/0NXvCFFM28QnZNMr6WQvP4H1OxOxTJcoD7xMmTno+pc8H4RELPrtX/LlML/cvcFk7qBO646HGRahHDcDJe9h9rQoFx3d4l9pfendtaEu8J+Z8Gq4E7VNU98BU5iJhkftAZgkv8gw1VlBz7lEu1Cxnsqq5BWJWmIQpY6x8NiWVl9nta06XDh3GnGZIXMVQ+vUVCQxJkJgEqpZWXGo2XKhG6BuotkJY76aSwySeZ7y3HMM0kRpS4fMLI2o2AbQV5k3SOnU8zEjoGhvzgjkb+J18Zuj6mzBgg8tnTDfN+ba4ZHCQ+3GtsW4lIiYOj7OFOa+/lX1Q/Xyl8cPtuvPRfvoU91r4HHvuvAlIe8G8/nfP3YAzy4ZAtO43zLcUfExjvY2r/P5HSAYLVJvvpPdS7yudR5jDRcRL4SAvCQ1+80ncGnMwK7+/BkfGdS3bONftuWu2HtXYiRY8p7aOwYhTHWWKw/VTz0U4JMIP1PpTPClt1mRx4S+d1OAuCDAM8H703e2obgJsozsMNQiPe8nwHxmXO8Te4Gq/lxDEo/b++m+bOdEL14S4zlcOYWgTTjBwCkEv336Dl1l7D+1ZrDGSewVMfbCn4LgNvxukmZEAqM/GYJubmfWqiU/YBtZJcuYAy4XgLoy1c8/C83wfIaqZa7XX8wH1sQpPBc6V4DwX3IT/Jp85e3puKQd9m3luAgHekwSkMs9TgphCMittb/yUDC8OYT2imSPCEYHdMW4QJzijhEMia3CYkHHzUmo+NbdgXRnpZ0qeM/RTwJyrWFe0LztKCE6cvvzv0PcYefq+0D2Y09y3a+PberasQpS5RsqGYdr1xkBCX3Q94VUTa59Zs9alXY16LGoekTl7+/SugiJh0rKfWn+L53XQJaxEd0RzWTJRoHP1Muh+HsVUlmoM0rGYs5nfUZrlIihryHsvca8z/FBVb5GGhvBGL6vZEY4jsCYKqS3hcezZCDDL0/RTV/VRjwgcOeaOko7I3yOcwpU+anwNeovCe/+VPojP36kz7yadqTtsu1331Ztp7s03oy1SWrKbrbXQdQALzF3h5DpbMsLTOHjCfNgSjB7364UNCU4rtc/oGcH48DJ7Ws/Bx9q7J+HVWFoq4mEeWeuhA3nPgefIOoc2gnhHFOQQew0xtDZnQl7nNiQdXpZjlMNumZ9EZ73BuaM02a/6NFM44rqYh8ih2Xy2o5ap6u9uTEK4R1J4guHQGZySeds0f8C+LgFwpl4Hth70Fn9YQVnG7MXGaIA/smaAsBDW58WCy2mehR0uelQ1qv87PV/GLIzr85jnDNcg9RVnnkOnW1wj0R7HNc0VPPA5cFdPm38LV3Z8zRhcUI3Ac1TGh9kcyqeaZ3xkw1Pdkx/43LD2IZvTQjU9cSwwrzhSrfNxoOss4wJJaHlm7cp9O7IWgjVHAZ3PMreAEXB/apsuVcPUwZx0p3gC9D3I0D9aUx9E93XIMzaFk6GfJj6HBAH2xknUZ/0emcHc8e6cVW+Dec7ZruENNjb5Vs5dsE0Oq1c5d7COTvyMWn+jhpdeiHkPCAciTD/0qknQSxTOwddMvbtzkXDRb3kjF9IGaK0FsFOXuIOy/xuj9+Wr4RVgP8wZn2Zny9yv83qfqvdbZtzO2TK+v1J/SZiZ2sd4LVm1/KWzz2ghMphk7t9m04XTnS8Wl9CckTu7bxHuneKsKR2e1SvbfBcylzkhcBYhm1QnEObSrDEWqWbBVPdzaInoLzlMhkKeEuqPidcDE5CFrrFWqD1h7tHJGG8RlxR7E8LOqOe2+MPcY4OXXiWuSsAGnVW/TqY1hL9pcxuqubhGUho8a74mewjqsydbF0Sf90Z7ruZUSb+h+S1Yr1ufQsusvYh6F+qlRedGwen4nnvCdSRo3tZAaNxAMDUyZdq2ZxTuvlfPBLVSUJE99yTYyCFGPbTl/YjO4cxaaF3CfXCO0ldaBwuqBVziTpOeUOm4RDcrWnfcI5rfUm9KYamZIL6cEZpoceSdoOsg8yqaRVAAleA18m6bmb7oAZjjbPWt8XJcxTlKWkfm/nNtZRtO0v7EZ5nRLgv/j+euGQNK4CcxzWTHlZw+zO7vKAwr5iBF0rlEffce0dzgae2amRppj0c6WFphYJgjvApW95R/FpYus/WieUyCF4KfA28EpXsbdWx9S+tf1+ZODrofl3DyzNxe8FvNCUT/8HYHR0Np8hscyKNNn6bXiOp5S6+Tnw2trc/McC3ctZr7qz3OPi/5bFJ63VzImPB4g/7wKucX1+bY29zmOaxNmU8AfBBG9WRg21yLxp0DMbQRjjIM0rOx3PlE/T3z89jIbAfznInXsjg7Rr9ord2zwYAI/3mYM5Q47KLn4dmrrOcHz+GmB+Kwq3+zeCK818XMlTD6rMJ743tTfr88Mk21uLmYgyV3mXVTzQY98Hu/jfeYje9n1GMSdmBjLu+ELT2t/WX7Nlpy0H1A5sbOPe4lKerR0bbdYQ2Q7l95HxAuHp1lGhdXvOruerV3d0FN1fBj6tXgMRCTeZMy1o+vo/VRuAJi5EPvkei5eX3PxSTu4C/bubOMZ/ERz6AfpG+EiV3PV7UJ73uLYXXlfVamJXxMCke+ZT01TNAQ1hHxUK3/Pj6slu0bm821b5jThSnXZWSea2nFwy3rFaK98JLXzN8edJ3utGNC6kIOtytykpdssCq4Ob9z+n10H2/g8igcTnFJubZjXPVxysyRbc6l5uOqWoX5e1pfYfF3EUyR4QBZ63IPTDC3X3zFzzL7oszO37Z6fibvrNJeF7TZ639yXyTOxBSBY8T3aG/fLTws3w9bfIo8J43nUTwbOxV6CDVn7zlPxovADqWcMA+E8J/xNey7Z5wvCICluQT9fdfm3+tZTIYvyech1h1zg2HEtFeaA9l/CPfk9zNrrsjYkbkevf/AxwDczOtI9vRZd4E6dzK/g8fUXCj+lvKe+Zp3xbqqty1hxjDfy/YBtpcC92yK77UOe04DdTHN3iyM0OICrRUPTvm8UE1pvGoETwG3p6X5pqKxt+cVZj1l+1LBjgyXqbA+iuaceE8Uj5tqgTL+zJe+D9tGw5fa/p/9PbxHOf8D9Xu/wUyPmfmxzWH5Wz9Xhul9+d0JHzxrfO/rv8mY39LyZ2Jel8E/nfbbolvJ8a8snUmNsYIoPTNHlTgwxsCZ90TWLTDvFee/Ze5LZ3PMZ/MXeBLxcdWskDE1zCBIV0MagJQxZZp/frXmn09ZLyXS4jq3qM8eIMQTW5q5QFjn88bsM3kvEuvs9T4fbFLs3pmbUb4OYBzIXiODM86t6M54uDo/GK/WZ9kf+u8Ip9PvmHmgnP+oy/M1FL2HAflkOR9R2nzoEJ3ahmfttGZva7/XQC/+E1wW1E38ngtHsu5WRrUWe2Sk41Psof9/wv5widPq3a9ZOD79nYUJ09wyLix7Fr4j14X9V2We++X7muf+ff1zjVuYNThnbdXv3x/FSf7y/bX7ORd8YjFYX0lwY2TMqE2fJj0c65A+ta5UGXeOlN6zsIfFpLnAbEs8wK6+zAxkRkB/Z1J1Ef41nroDpZ3kert0bdLMizXjUq+JESBxPsswWWv+jvpQentosZr3d7e5Wy0HpzIsks9Uu5blfZzrE9bBCi9xY3C3jEeY5UMD3wJ+H+UeKA+vW+wN4edyUBxzwsiYJ0bzeaW1w/lle0rI2aJMnLO6Qn53WJuX4UfyucDY7OcmIr+8L9aUukez7/yegu/41fqTa8v3qG5345BB4qxtGyRe8hhaeRiQ5gpY76LmYdick5+4jrD2WSPD8lrzT+E2qOdKhrZGc8U8NfAeQgl/t89/wi+x7xnvwdJQIoU5q15D8fTVzMTi1tiYmrqWDdUpufdFeA3koxaSKbjWVmiNhOH+6F4NMzIK+CjR1h9kdiM+C5qrzIFemLvOeEZleRdaGLH+7tZcE2uOgmOoNld7TeYMLcEYy7i6NuapZnhB3mOK6lBtjklBNiXaIz3byZ1xgv/BiDyp8fk1TOS689xSPrcNN5NCG9n/UfRVUpNpI37mAl6MZpexH8wfv7gvBtNaZt+XL34+U5/9jZ9/BMD0wDGmes5+d3Omn9Nu6/m1+9+p7ej5c1lptOcL9+fydnjhCXGZUgUW+Idfy2rzbbKoOssqYi4EYSE2kUYZ6sY+mHczYQTZDpvHcH1k22es2MdBI7t2HATbz99OElFIqDNV9EsXf2cjjmAnjT7PgCa3H3Y336HOAmiB2tkUQuJuQlbuUjRmZ32cwzZZ2LYJ3IcoaoruOKnnriUoO3flzwexX5Wq32n+XFQ+3Wm1+ZNW+L396i+Ta7ycvHT2t/WCYkva3wcO7z5BjaY+why7vfzs8FRE/+/W8XvuRP0+6Oav65bpON9n7eew51Sxcic1QvN38ZJ3FFYJjtfmOhvoFtfzhTueV4cB3kw+sVq/XlJ7en/4lZ3E4P9uVMDSiYnVq5V1qURTiRpPv30a/SfGJaE6mMRIB8bqoUvwfMK6MGwEtgOmNzfsJR/Y+eSeZFY+ocj1V74/cLWzIljUNNVyE6xQzPv8oFypjsRG6GHa4F6o6qO1VU385ZhikzRaonZouOp55F4q7lcUUcexXBJbIFPBvbgNKhb+yfeGSfjVdZB19JiQyZ+d9vpl22AHVhXvwCig7TCLU30DNSsQS2JRS7RD1Pus6mqZ7w/da1aUIzLziZwfB12Jwk2ZuTroc5TaaNv+jjXrZ95BxJGgsz5cfC+5Q61BismeMJ27cE2hKG1n7kyyjgLb9jPU8HTPPQdTM3Gy1ZGVD0Ll+TtStwe3HMW+1GwFJ2nPF7cLvy/tDCvPum+beImplMOsKPs79pwq3mEVq4f1P0rt//Yk68ZUh2AQh7UGKzl67hOm5LROPk7oIm5R2vwIPJoo2b+LSdjGr+9yLiHOh19zbzFPWlFh70I1+a1PN5jiQMWr3yFZT+TwJdfMHRc/i4nsScIs2tJEHr/X2czgmhwjotQJjhLbo9FGQRUVY0VXpj4iyNTn2KrYHt3bpX02SNWgTla5v2oqiomzikcjNp5mkYJtzev/K9YXX5uKYh50nQ/Z89eTyk4zlwzD+InZPRmkSrNzoSLJnKw+M5dqdnevXAdYtZtdI/LeaZRZW5WDtd1zzR7I+wAx/vxlm54ls7tgdb5j1wfc071LU6LiPTAdNu1lDruD2hWQXINMQp/WM6wlOBQLK9N6R2zXBjAXKRJYo9T3TASFTKXYGSDwxlXtooUqae9ecBaMjCvBxkJ0P5gFJA5WGUaKTDXVf9sndeVsovY/w6qj9TWHE1DYaf162SfXeHb4RYjj9on23gLrLuuekHNtkMiimpsMOsMudQC0vzJju8jEkwobKHfW6QjvMhhu7KzVSy4xHBxmXImrZygsJovZyed81tnbckgtTq+1YyT/Dq0xoJl3zXQpOrHRvQeDHOeUckind5vjKMnRlVlgZhJkFE1lLnAqmkwmvsToou63rmOKecpNToRGbYSuZLrjCA9xTafqHc8RbNiMOuBaVPEr951mRUWN8P0GGmQii6hLVlMmdUYVJoc3pZRQao09uZvpCZ+KcC6iRiOjQocz5g3v1UuP3i9WypACWP3fNAnajWqt44iceZtP726TlVwz+lvrEdjP2+Na1RASH1SMvF3y3sbRFO5D3QOeTjunVV1PkqB+pj26k8h+p5EHHUtfnMAzspNxweLvRMiEKFC+k3sOEFSwQCQK7hqtj3Yno/ax2/ucp4FQMMnkgJxb9fTLY1VOXHPugfUe+UZtYvcaLxkmOTtUJBQVUuNJvUxyknfUunt24pM6e6kjn2WCC+VA4H2mVtLAxrjuNzA5eIG7UiBuTcxs5W46czbWWtma1KjGVV9xBBv0vZOJFBdGJ7vvB63jLV6yI9jL9mjcxGst2X8Pv/A9FUoW0Jlh3CoC4yglLsENZncyewJ7LNTWL9NsP5aEfXIKoz3HjsnSNSfco2rTBIyavPuTXT9x74Wag99RvJedVO51R/aomnsKtsQyO63I+QjP7LOBvxXsp5KuwHU5unSK8hJnGGLy2r+HdTU5ZiftVpyYqjFQzyjVs7znJ6Paw7QmuZBLjjfesGsaOn4VP96WKKYn9R7dopTqjA9y86s1L1GNmDkXiofugR3ErmwUYWK5NIlTqawHjuwjdAkTXEJXXHqXOukwIZVarhdlp5lE1C2vau/C9ItjBeuvL52ddlqpApHWrKGOmpB9WUtx3DAzawkR9HmKP4ESD5Fo0b31OV4fH8FyWFvRVERHblMNLms6F8sJ9VdTnNI2gnLSO03TV2GNK2bXJbwd6zj3xB2FUNWAFBbJBu7PXDtmonaFcd4mppa3cMbzTrUS3qt3UuBQDHLjQW71M3XWf5fen2IqZdLzajmf4Pknl4DVIpu453DPxBGD1zBtMMsBa2JH0eOskFi+fuusD2fgIPw91LTbdu9BvTdOXraHU0YRZvobvi8ldfXKa3yEffRGE4okdI3ak9YXx50yEwPKQq7NHHahUzVyT0XWOhd8H+llbGUlRRvHxCCHMo5dMHVyA6l1/MK0UupDjXyGveZenu0mTPH+DR/mPEfdBtZP+xogNshyMeL7Qu+PYSrUgjTQaC0pCb+JG042Ll1FhCsFNDN02NGA3GKg0E8ugYnBO2PPRA+p1Mnq2keWk6bUKWCffSDuJ6SoIq2KMPX2XaLGKEGD7tmls61gL1+AiaUUWqi/eZJwJhct1E5hz7mrekr3Jr02RT69pS2NpVFfIc58Wr1XY2Uwrs/vNe80tQFyS05R2cmdVqGyazMicoVRKO6VhimHfnUXe+MEiC6vc17HL9sj+tBfL+T8Ov1YaWUwMylUf0Hvr3o+2LslajbuNeHeq9+VidQQeiraY4ZsVGtWwYx8s6aVYEpr9uzMVmw11CQo/95cXraIvtY1zFGiUe9QsJLqDHtLR/ZQjqTVceKDPrFL/1Dv5js7T1WjNMCU4cHqDDgeDBu4/2C0yqQerNzdqHiN1KdjXfkU/bRArwX1FjkaicIE31k5i6t9lJziIiToaHaHwdrw2VL30HovqN/MPmG/6/ydTFyqcbbn74Y9Sxj6Y3o2+nqsc42YKkt2/jGfuVD4rChKSF2g1zG9e4j9Zccxg4WJG/nAGU/ncHugtco4lEmPkZ/pnRNikxnWzi2XqHSMasaJyuA0zVPsVUkFZ8f2hZ6LiMgLuXJ39JmKz4Q7NGHArGKI7+w8pyIASY31GHSGkmDFe3yUdSI7yjlGLhpqeorIyGjpJgNRWhDD/0bvF77PJiy5lzo+sJNXhXH0IbmM7MfALKuxVnCRataaGNE+jmsSzBI9Y2s9qXwOEd0Zcd3M6pbtUSlP8c4f9f3tm/ohy5A7Xn3ZSzENFeefl4zDbw9Ys0N1MfUblBzytJ6AMQ3ncO+T17lgx+I2Zzsh3DPnKq1vThjyJ0fNTAdOGdxLzmFZ89b3xvd4nnd3thpaHFtMqtFKPSPG4l5IpTYrpnIAn4iQtrTcVOyITERxGwcSYXb3EuAmwPmqYRpX/aUor1IkyYyxBvbh7Uhxt+FWYyu7kBUqJ0m/oHOYXb1pTf+p6sQpFIFQgYrjgXJsBb5De/3k8DKRXllqYp6TCOPBn7XzGKFxe922Z7HXuPDZTFNUvH9U64O5xe4ZC17L+9cXxoi0kzqnKMAdu3P4pVUQPF/StYRf+7zGntk7CtGidB0455y7ds5uHbHHp6vlpkJ7DNVx3ZPl7HQSNSfXq5h17ANgJag7lKPnBtjN9IsJ+9v68OL32mucRavWURhdn9egllygJA+8Ro0xJxOTS24KXGsk4d7/Y9CDK02DajR/P7zG9TG7v9fAdHMfrEQkJ9AXZoCQ+hSKQfw+YU+ZmGTChtFPch8gezR9z876uDZ/I1j/3hXV7F0cp8zzjBInCMVw/CapLuhzH509p5phHana1uCwN+t7cg0DBatPPRf1lTcwtNkFkdVqwsKQNc/frbPHRLet/4atipcEPXbMJwf/1/UErqSd6jPeC/TXfA8DYfppV4TdKK+U48QAuEfRnGu0PfziZDTt4MkOobSO1HW3XpTCixkacu4xe+sETDPuOXu8N5ymgzU1heIEWDIwIaQzUA/nusPXznajn/mqP61E/ddvo3tz49eqCbPf4iTcVg/RrIHaZQ0FP2NgcAZRsa80ayKXV2EV8JTfw38TdWTrCOXHCT2YVQ8Aa6itllCT4DtMH75yt5f4zbCfWLPDV3qe7/1kbRxapuLOcviFfwv6yjUZM8MktV0ihVnN6QL7+BiZRI1NngUnz0gnH6j3OLodNzlVJE/7pX60zktSa6jPVkkj7KgVH3H/A8y/eugvgNHpuphne60jFPxHupYUDNGd7uf9TuX8Toxvqp9T20Vz0NtI6mKVHCOFfc2OycAsO1z7G8x1IXt7vNEOWuS+QGdOJm4az321p56fXdhQO88PL520DSxyA7X3l3sJVL5gB3uovzfbEHtq67j2e8Te+VAqDO5DsGZpRgznCMyCJjTjovMIc2xyodJzbIXhEBZOThvtwv8mnDazhnb6+/1A/YSUTswWn19vr89tnm2lYNCRmyAcjdZTcS/xO81N1MMaZCWAWf/sbo3EEcL5iHXfrAY030GPABwdagB3l61Np3ApvBjlN+/1jK+LQwKvU66HdbrW+BTW3Z30w3jvqadeqT6SsHA+w5hF0iaMJYA6pJiow+eQOHwpNajqeeLlkN1WrFmUyy5ft7Dv7tkt6JPYRNLjPXECZuvqL9tHOf/Wr4/W7bXXuqhksjn2tm5QNY6WfE+j/lCU6t21//bSO91b31Wk7A84VW9b33n9Pa1lj4VLzc+VN2k+HTrpgFj4zkfgNo/Bc327fgmUW5CNRR45ieO7UosC++W5gThKc62p50VZpqx246JnjzlM9XUePZgnAfWdu8fzD9PJxcxAZZ7a4wSlsNfcYG2hl2dHLX0OuovdTWYQOMuffr18HNY/eptK3G9hj5bZ0Qbuld/G82799fHEuPwOKSO384Sw2SbweGJk2cw93/us+0s+n+K+e0fCHeFT8m6oM0pmGuo73eAyAYd3XseOuOTFxzglxjA5ryonTlGmKvzuz5W4UhJDnvu2k52s6su+oWqCzl6xmc318J6aUM9OnI36q+APzbuks+r9Tq4ByUZ/4hnOPFbEQgEieC0/39uR6+zOkROSaA9oKUayWtMVvNsh4UjmPglLklSH/nJ4IidDi8eDa6Xzgdh4VL8kUVo90r2z3iVENUfE1uX9WfWUun7B7MJKkpEaXKdDxp5zD/pD9OKah0SuOeKIG4g6M5wI1wp7LOGpdn/HmCZSLdnhdFoFJok5LzF4CVeaKifrOxSD4EuxUgQuRFAwOsA6HuHtqFJvMetEgtg9TJtXUYyoGvkDvBpx3rVcz+D8E+tEoYLSF64IFia6II5PNYHbD9U5qBdYVcHfrbtx5l1T5+f3nOjeOvidZhqmNEfD/PSicO0RItoz8/gnmjNjPbnsuGT4EynvafbezEoznpW7XANoXofBgqt4h19UQig+Y5BWG1Sn6X0xeYTbmF1n04bgI41dMbFIcFi5VuBwEbBD9EGdyplTHaOzchXxwa2iNRJcwZ2J1Ps6Yw4drinsPL2MgK0mxDH6Uxw5auS8LHjD1Bn+WDhtZ9qhWdLD6oPsZ5yZk0R3y1WoU0gNuPjeZyOmdBCk0zgP5oWhXkKf3qyPPPkONeCYdL4AZwfOvxNHzUuxN+FYe2tP1Km3sfdE+5HMSI5ypjLea3Apmfm90n7CigrF9aCzlDAkvTbVnKTPyZLgKJIS+3lyewW/wNoDpDfbmXrATo+mGpHSO4Ll5oa6jFwWDYfmFNbiY7hV9WTrO2rrH0hlVSpfxox5fXZidssRbGKl8Ysmz8yXg/Wi6yxmPYMRa4yE+yZJJQc2TPfXqO061f2gSzj6edXvXv3a59Hn5GtKsUU9Yv6WUlm2L1F/s4bqKu4PT6MF9ZzXSCdztvSeS87yvUT3U5xuSUqyu6kduQ6yVJp/Bp57s949Ob8Y6xRHOVbrdtgJiNZ8qtLjhXVPcw8rGUz1on30CS2Lm7qBAlU7C/rkVkkcCXaezbLo8Zm899HZBAetgXLws2YJ3BeafZ24CZKcRM+2DezQ9xp7SaM2XK1s0gPNweOl+b5Sy3F9qGfMqGtuwGQUt4l6HHrmtO5fMyoBwVPWliupPsPe+7s/mLsBV/fF+iUVN9ztQWFB1ly4ynNh2nuBMWJfUi7eNv/QKHQJX1hKj7aVe8Kz+YnilvE7mn1unfXh10vSriJ5JBJHVlZKYZ5c5fsh6Z/qmTFPwt1C6cpYiukxY6+hcTONS9yOwIqU8w6cWLBf5RMULZfDnAvq/KB7HHr2rO5SXAvtiN1Jy/nIzLsknCzbh7Kb4iPwgmrInAdJM3EaBvs1TgWa19NCD4zEruisapvMPJWTmZVjz6WkXtHX+qaxFLmfHa08yWN9L52dzQHO4A0ZPosoo4wK5jnbo5bvl1x7aszr38TU8rzGL3A7cExQRwEv1nNJ6pdxL9MEZwmpzun7tw4vvvwd3+rRoPQkzID21Se8b0iggtuS2kNoj9duo33m4qLvAQZv4w40J+2Pr52UlAbgmn2ouseqp609Ijj5XkSz1Nw8Wt6p9XqQNq46vYHwRlLkf5Bz+3ZgEpD072xIBRYXHTf2hrebvT/kPEizTaxbxig77OCi7sEuSp00pvkLZtTuqezde7u3gQvgnpzh4OR3zDOka2Osx57DvdC+C54A1X7smLLygCcI51bhoV+5Btb1vWLlXa+VVYndjtjvcO5iJsxzjGVAtQjmeTPi+QhvDPN8wvd1gsajRMGiXbnBH9OJ65Oj8HcXxXdIuYIpTFKwKJo3Zt59w4VgFwv5eyqdFv0oZspphmuhZjpXM5eSVNzCvDG5KP4/9yHM7wu34HZhv6B0lrvw114Y2xpT+hqnBoArYNYm8Zp5fVh7ur6HD5XG8LI9Pla1hL47vyMq9ZZmWVgDMkdhLpWZWX1eqbeBe6/HewS594DngvPcYweO7Bll5hCZc2hyFO4A0sz1TJ/cWHSaK9Wq7H6t6lQX/T3PRsDpyX0WnO6OP7QmhpyJwSMClyKAownhPi/bA/qtfwycsSS+xeAl93bb9px581PlSlvzl8MjaRyW4NWsZjZ/mv7/zuGXm4KX4GyBCWIN4793Pp7WPhR8bvN55jYn7mL4OnPHA7/Tag56bThPJD7z5sxnFNPvSEdDyXA4S5hPUee5vPMQzr1ylKTe3uLIoNY5wim/k2LWaDvhsWswrQs1u6A+UPFMizUE9kTjZvY983esZM4Xcgjn9C071VopV4/ZFCNJwaT1qZOdOQmXHLXBzVPXr+f+J3C/FM6yYielxK+7hk/Yb18pWUbV8OKkL1xUzZNmnrlwwTBb7RFOf4HOAO9atD5KPcw8MfQd8n6pVF95DjwDhoKReF7iMIcag3roGs3GtdLaeh+v7NZ3exmkzZTSAO1kVcwgWU/FSTadIRIxRSMQQ0+zG2yzKYhhD/gl1hKfnwvl4i6c6E6aaB46v8+cjKn0IpJIyk552yfUGrxWaf6SJMSZ6bUpXZD33danL46fMotnLQdc/fHsOqwo5//dTAOa67RuvnaUOtrrP89VeZDjliQ7accwrMVt69fLDtywbDoqOekqh33iux9+4ZolKYGd5MRlk2ZPcIy/63RNxgvAmSx5d38soUsBVy9Gescj0C4iQarnbLl3R/ivl7DGyWEx5oGak5D/O0/ZWlx4y4pf0sEMtaa1Lkcb2w7qLs0YmG/H7lEmGQguHMBqyWUoz0/aQfMxK/DTXc1ds9XWwlsgPOntdrRd/B9hLagE2n2P0gZwxlwiVX/qRCG479N9Kd3Dea5XPRLuiLksP4vFvHJ25qmat6Of3RDGw88cMwnMybKpVFl8ON4I1rWxFeuk+yJXARt/6lr3TOFehf1ZuHfgejahEXusSM06Jr1AsG3LOcuaTuytdK/WNHeXdIy26qeq0fMhk2Jl96NSi58Mf4Z7+Izbpe47JE1iNx4OJDF9sLedRCmNgPi3dr08JB4Pfc7WdsISnv3V31NPyprRrdnHZY6tUyH5PFCuOLqfPKmkiZBU1IQH4d1TyWMPy7Fb1OhPmqurelK5JyYh7P9t7suWE9e2Lf/lvu6qcwAb76Qi7gPINKKzASNALxVGOEFGgDLpDBH17xVjNmstCTL3PrfuiaiHjMy0Qe1qZjMadRndGM4O3uvVqHM2M9gmozggMRyxvFVdhupKGmeoeyCpddLvD1hP8/kyanK/UoWx70Owwo7ihboHKEZEe8QurkS4bvQcvU1i+JC292diPOafSGwuNRrCyXNtxeC3VSHWuGrbmPgseF/wgA7sPurVTopTszF+dMMHEOWfo7jrFoU7uxNnXZvn2tipA7yw5BtTxRwucvmJYNlpTRKlqB2fn3gchFt+nyy2IdUP8zgvccA6p9fZBMoSFH9QHfsFe8Iy/eY39Ps++FJQejpSL1Z7l05sbXAQ6KVSTR+9BPRthTvAWCjqzbKS1l/+jV7wvXdEvbkF8Qfp31LrPUOFb4Xex3faT8rCc67VBA9xJb5pXN114nSEWN55Zz868XqZ43h+h/IM8NAzuLm1bvEVzjn3VLsSN0Le01BDx+eL2Guwj3zLqK42cxgAqhU2iu+MmfimmLpOnMpzx9ptlLictbnx4NcX6aKO+UW5Hd4R9ZXy6h0yjrJr9DIllX5Wzs7GjZb7Boyk5moNXa9zKtSNLd4PYlTtufL3EfePJba6zz+06wD16NU9D9fK+ElSKLfHB44M/DOOwcBPgGME+Art0+Jy7qBmPHN6SN2pKuYvlkYxvtUvQp0Xc0z2O1IXUnz4gtQOEQv+/Wt2atTU8wzZfYX39DPtacobpH5LJ041F+Z3uQ0ox8/j4iPbU6Fap8TYmdga4xZOCu8l1F8E32Q5mVTDF5Voqam0i6HpySRXF4f5Et/j6jqc2rODe8Lc9G7xOKrszUqC5N4natDCV2kGq4XtNW/mzQZiG8T4Dm8qdWpqbet8STkc8LHgsgf72dRXZ8mbNfJeT9HgeAYp7iGNNpUjqz1b3IcTK8g5gX8KVG0w9z1Srdy/T5BPMw9JawJQTVKM4Yw1EgRbzc+B94VQVCapn1pQlXNxpRJ8rcGdZ3BkiOMoVr29JvD7f4ZTH2uPU2tpHBekEs1cV1Z3KYNn1DFK26QGmbmGey5ymrvGIdc1jErti4MFMIr/qqQzGXTEXRL5D+Wv82bwaV2/7FqWux9VkBInmuHrqBC8zCR+51zdqSlKn1/7k6hjWlX5oTj3gc9jcPPqDEzK+arA6uoIOApunZD4xslR66WzyYKcYoXDwqqNManK4D2duM/ZR/8U8zdTl1IshO5fRqPCO3fIyWFrlGlo3+tO3X1dMA5OLDyYGOfEwmziG2c4cyx11iPVzfRE+IxJGbV82T+YA8wOEcNUOGD8/jSXZlwMxqbUV4iPg9rLj3mpfVVuklU5tPw7GReoScCtqkzYy0l5PSPOWb4GWO8smsn6XdxeSJ05trUbiz9lHrXFdmv+LTger3jRGmi+vsnX9K0DzKDUlJWXbrEwD6TQrD1RXufpGgaO+yvlNNpjtm6Vm35Z+qwd7tFhjfpiZSCHw250AeD0YNef/Bg0GIMR55DHUOcO31/BQy2pVSsK/ylT65w5Cv7CN6J1NAQfEWpidg4tLb4QTqfJ96Be6Q7HZd3nOlITyzjcGq4+cZ5zcTi0ZiZQPquCV76flxpr4d1dwlGRYn/Ubl0c4mzaO1DsQs+e6hF4xlL/Fiy6qaM9ktusuiwix3tnV93suzDqStxX8rZDnrvqarmVnJwV2AgXQy58vAa7+aZxQ5RY/ZW5xOElpLjVVW/TPNRoRch7zGKkbcyVHBdcb1ujngeOAOXQpp84dh0NjEo17TM8xgz3TObGgbUYNNe6wcF3HKX5gmA6flKv28tyHlU1FT2PcFpVZTnBIUp+dtn96JbQu4QrTZUVuDfVvbcJBVdUZteJVv/nu65FLq7AWTtknuU/q9jxXO3l7ObcvDaS9hHpDBHnphPvNIZyzkeOVT+NQvLk6+TUp6S3LeOY8M2ZPfjJ4gW1F4M8pog6w1M4eeRnXwqFy0o8KtFbWRHOczbi5838K7mHTd26GvLeh3qQ1LKNAj9qyVrrwlrBjvVaozHfp7Fr6myKKx8U1ljDvXASnngcSEzi7k8WD7PP8/O43o5a4y/27VZPcQcd2TPMupzNf1STgXtN1o2PcBmZ9Qcxciffm1imjdx5pf+Qj/F20qfI9hRNHb3VI1yYc/8Ho89VbwxGo9rPcLqGcvRRnvNRuCaWh6JKy65iJM3ZDOYzu64bvvzXRrEN3ka451KTtFobuVwesTucgpsHxMhSV81wHmJ9v4wxlT4/Y8KfaJwR35P7yoOg1pacD4p3p2gzNPtgtKn8CEl3i+otqE+hP8VO6uoG6uBIqHfSap/ewTWrploLvVAOR/srYt9krXGUxirIDzjvO7DTofbU1KUd56QeMeKO4Ap12Dnh1M4/Ost0NWNckPCAyZGeON5Rq7plx1u9D+rRxKa3a+uqyo+UuWrWE7gAnxYTOOv+9dqtLmRm7Tbxksa/hMe+U+fN1VhvnAipXqnrdTrfkGMOuZ9RbXOrmi+ooYLDjvpCn/pGpF4uOUjo9GGIw009JcWkCSeR15G11K5QWzAcQG+Tm0d2XFCNUnU58Ey6thZu+Y98TKm72fjddT3Vd0MxF7gozM0G7gQxgr73Zb4OPp8SfwGq2fXh+KsR1IO66qPNm8FGuL6sCjmid9N6nw79xYSwBxj3pCN4m+89x6vUz/VQ+WdwiIVydyT5bvfWMesH64zQ3CeHHuUSzkpfRdaL2D1xfPKLNUq0dqINuRsa9/aolBTYTa9yRFwvnEmtT2tNKM1ok6BPPyUH6Gukip/GDV51xEhjpWz1jCr7sJpmztmFIwpwFjp2BKsq+EqDNevEKWExsYbn+UBaC30XHnDE8ViH51R+nKFPInU+jqFdbKeJSd6he9Ea7ojDzloqOr8PGsPBSXpW2nc0/oPiKuv0UQyS2adM3V7r0TknJa438HG5Bquu84iptPdktTxQL+caQF9cLsgxQcdhpn+xIL0q5jLPrAOBKs7aXng1/WR8DD1Pl6st+AF2jWIsdyJ7EOF3uY9qFVxNXcp1ZvQ24EsUyZHQum0yj/lGMZhzPXV1cuNLclI2jnHMtTvMH0J1AetIbK29SFK8Z1fT7FiIrlnMFzg44CVEG7h2f5GLUFeVhZ+/yJ0p+nw8vXJ8/oflPpo/n7k1ZilrTO7Y6E0H2Eed+OTxr871yVw14pykjHEi7KjyK19sjsA9W8MFs/wcPJMnjcUQ75OmV/Mm3nbdkhzsYO0KHo/pMUPvoQi18sUyg2exirzq6Kg1nFzvrUFu6H5mDV92WMdAuBiIwzPzfUBrLDC+Bo9snBIFp4c8UWpSjhJzyvWJADg5ee6N0bAQjGfcq15xzJgdI1hvFgaHMl46GLebtV3iUHHihmJzeru+Mr/rOJNaeQcafxSjoD+8WzrYPa0J/2K9BA4gSLxt7eRi1W/GuIOR037jR2tt9ATAH7S8fMnPmKtEvYIF524aLzMOXVwH3iezHGcxg83jNaHeb4Or3Bs9mloDKe6zo6nknN++4e/XuLL0vRV6Y+bn2BdfY/v7zshxm4F+i3eHR+px3Ce4qWVU+iqGJZM/oEf7RuP4ed/pxY+a9x/YAX3w27yX62D5nO1rKU4kcg6jOyW8Bea7cx7H7125Fd249qqadqGby73tfucYoHsWx6XE3bjVhON1uk97Pt0X8RKzOnTqIpd3NQDelF2YHm1trErnIe6wxXYyB470Sur9tnXXEa47xcJGJ+zEblBJRg/h5by7Eu5kw7gn1Tajem2h354Wa8Fg/dUeF1akC0w9La1/xTd13ZR4VlRzzuE/l7vO2yS5Ki7F0cdw61raW6GeJuEd6J3aOv6LwUCrwwTqj1TT6Fj3XOOc6ziyMC86F0+4Y4P7gZqrkKYaMHwav1HtruPu7YxP6Tl5naszsVrNm7ODraM9LjsN0TuathHj8r4uLj4h94OpluttuSee7csbV9KnPBZOYgtTF9E6kvz+alxCY/ST1sfOgDB60qfNrBsG49yJU8HjUg8Tfe9jOHHcebzdD+Cgb2NC5SgzbtrbmNwZGGdHmV2wzo6LV9SE1mW/bPqQbn9+UiYuUTgZ/Cl6ntJPTa7eVh19H5fDUkXeq+CAc7xtk6OVgvOMXd73Odf3JTmR5fgf0qtb2l6d44Tk8uAYy8jYHMLiDU/WbaBxIT628Hy6JSj7J8duCXiFPtVIkHfPJxXC/XU4H9S1hXD46mg3L7ELzWw6+IE4LxScPumSDHZLo/9H+Xjd9ilYQ5S45LqXiqOcwQLzszvr/pJ1wWA878OM5zRxqIIsDoL6x4zBtVw41YBz5rpop9TxLEbhZIYaKT3zTpwOFN8tGk4F6ouBZ42+5SawLivGsXEm95Ydz4KFujJvg3r9Pzqu5o7ouficMxzYFZjyONKJ4XfHY1nWvXt9VuVGunG7e6/6e5wneZ8afdWNg5EgzCO5ocKxQeIUdeyk8/OzF51EuJmf+dlwHXTn1FmP+H1kdCZxXYrFqYt+NPdVkEs4/XTW6WN+MbmthLHUPWKnX+qpvmByYYwR9SJve+Au9477VozHZjzY9QWunqphqpz5Rt8fjIRzIrqIXKcy+wWtm+Bts5tnYyt6gj3tFxKuiDGXBe69cg8c2nrzSSOdE14T8zNM7V6UGTf0Tig+h3Yl4zMK79Oqy03HvXSyPTbR7eL4g3Ru4CQrumoOLoJwO4w7Njz6pCDxAOvoOlrcXOfn2FZqIIW51o82pD959OtGf5Ix0znneOJ/2Ove0tyYUiyoeKjObNsmzT4ZZ/vZFMdeqUMtxZQvsWqvggsG7inn7qKVBVes1ay0N7qDeIZ+ElzDQZrZ5yk+jcH5qJxDqhnnnKao/gDuKtU8gQ8uwGE0g71q8Picb6lvxhwww2OqFbnWHLnuttgPcO6jYBndmrHR+byHC3Uw6CbPtz3b+7mL5tOZPfycFuaXjCYM67Xc6sC4eQNciQW3Lpxh1q84OXkXOejSWo/9EFofnH8XpA/BGr7NBnSsbYyYzVufnF6+9iW0lmgw7GE1X5//rc6Wo0lbI9d1vkfiae/JlcVb3fQBiBs6APcpKaFWo305wTmYdxCwRirG8CDafPvTOHFSXrICjvsUGbz/o3z+MfWWaUPWYcLcEK+ZNd5EG5RqG6RnwPse9kzqbxxVi9rFod/rT0APd5X6nRsMGvEygDWz2kPOfn2JLk6MLf1ANxYKJ0ODk4Z+KveVvpFrK9Y+uKgaTVujLarYJuP642KjVVfYjeP22WuqnebgaruYIeCWCftNuhxOPGRi7yJ6E9KblXthrbAwdrl0vL9xnYodtn19ZiXK0wYL5Ssyb5zxoEbnw/SZFQ9CWgx+KzhbLoRx7uYaXDXlfY25/aZ2oDqZ821ycvTLFDPBNVhv9wNjnOI1xnkk1E/2SCcykdqk4AtFK1CxQ6q3Jm5PErvJ+ivYBHnGNJegxdEKCl3bVxVsLe/3nMMaR2aNsZDD/ZxvKg9S/yU3+DzHhPlLyZ5rs4JJFoww1gjKg+31qkanwQ2wg2J5aeq659TBeBj9f8IuKzeLMX+M++jEjPchp3qrU/mjE59t39rBuCHOJ28EwbM4eAvXVdzk4I770y1GpRWcSduF8yqzDnrbfpH7UP3NgvZt9o6Q/It1T2VNtO9C3q3Jt4wz8pVcuBBPsSO7cp7HGc66jR2yeDfSFXNcsow2yB2ta+ppyrvL4xZaxP3bG1wMtJ4ZR2X0TrmPYJ47OI0OB7mdhKUEc+yivA7H78nUBDPuU7R+Mb4IXDrGFkmdhjHQJdE+Fx5F4+pn1snHo18XfTeJKbLcaMUaUOxLeDXldSIGGG+CLWmbbgTDiDHaQt2wd8N/78Qp7RHzUpl1r/hdByPiXvA+KTrVK2d/rEHrzWKX9DyhwZejfuZo6Kv+LGtNKh9QvLAwHyVv1jhuO5d+HM/hEDr7giWV90FjmnRPqR+EeR+phqHgbIwu6CbrxJ2bX+o0S/qGpPG0TK+0RkzK4pKI/i7VjC9m3E5mrlaeYKS1lgHddBl3puedGUc6HkVjvmZ5KoaXKz3y1gKYM0dTJft7b+v0ozfRn3y+lLh3tk7NWr3CyYq598+xBp7/YNr/Sbx90tOrlUM47Rp+JjTPnOdEfSbax+Jo0zgiZnUc/h7eaW2yeTztKVWeu65+pcFWSNx9R39Q98grnFFvcXbU15NaVQX9npq3vbs2GA2hiHM4HTefePYvFM9n9QJC/D1ti5dYG7pD6FsRzlL3afa/Ghs8leAqjsRdycaHuvdrXc7gwJ287voxKZ7Zq4hqNB3SDNsarSvOHybwFwh4DEEHwfJvEKMS74jni+nZUVwsHPJ0vkm0x4s8UmuG5CwoWnW61zMf++L4A2DfJ96z6YdpPpl53w4mC8/Y9HCYRyv54yD91TrMrrKZfJvySIqZO/ys2sM6xQKFhXDLwmYxJcyAxzwJo789ACcu+qHxA3R+OyN9H5JTOtyablx70xrg4nbcY1xsQprnwrelnukqwXphY2XTF5FasKnH6nx5Yq4K183gG4U5Q7UP4bfd0woEDyXjZ6V4Ia4HfkMNvMs6GVqjP9AYHmXfVUfizc7vjpndi3CNz6PRWZ9VJrb9BR+I6mDCZ3m79dRg7AFrL56dHFX0O8m3ZZWErYA02azePekqU2wq/PMCxbnsD/ijk9yZ/8wDz+tILOnzm/ryvQVvReBIhF+E/IP8Y5QLY72BspyBe14h6nmXqanuTc+Za/VPopnHeJRt9llnHbiTo7MuS82EeuriNwDPlb71dmGtPmBzXLzEek68Tsv9d3G7OW2UgnrFLFAfc/Wf8pxN6o8SryW73nFuYd18pwZPwHX5EnswWI33Mb1zs4aQf1ZmXzb68H6jTzh40V/oZPQsmmXZg0VjyHH/zdbARdtnSy7VBehnU61uousknE253+Jt1UPlkXVA6+yALTUzxPGEjwgpjtpdeugXeKtld1Muzaftz5kHXmSRcBKOJgKtrZKbkC7nnHtiUq/A+q/1SXUHJp2NdThtg+ejHLyj3wBXBnEmXQvlDmZdoz4hejrJKto82rU3o8fm5DMT8AT32ofvqPeRwwsBZpfHBY+rWPB42DO0L4m6IuI2iZVRz9798TqqfvV4/Ele2fjBOr2kBaF7nPMcwD2o4ntlV5M5HKTr90no6AngfJm59qT51QvzjdYSd15DyaGlL014V8IEDNJfu4w3q1zTJt0xc9yCaMcf563EIwx43dEaKBGnfjkj3uU+g1fWfJP3jnJiPfAstttv1pKopLj/Kt4R+bFGTbihV4jDoXhdqhUyvzMJnVqTtxmmM3KTx5jvHf06uCNfJ+kB0v1jzxSvEEc3fqE83J3jCnwHC46+E+JPrrEQpxb+WHyOo7f8z6zD7v9exod4ud39/HAsdsWWqmzs9eYIn0QazU13YJ4OE+03bi2S1DkZ+dLSLPAHkiotxuGELUW4NNA+QW5PWpkE/e6NtKRZ2zKVfLj2vWJNhxnOI+XVxmA87A/Jho3ailSWp9T7l614CoFN2dna8DH9lpYUHF9a8C8GOsFtaioxwGoLtISslLmVc2WLM32N2/epG+YPCVoPaoh/UXlUpEwWti3PVa3m3JasUy4nKVLXmjgrz6MQnTNMpPNQgW9qiyKlJx3WuqQp1eOx4+P7kuai3evKDrmlOrZ9Gxt7ld/ZxEnpEq2YMpUtm3s8CwnpAB+p7hx6t2OxOEwBm8ZYJEhHq3eMSsssrN+GISjJkDWO2Kekc6RLFhqciIl9Km0NWdYZ2qXLGb9vGo+JscbIWN1UFHZ1wbN9oXNgCe+TlYWmtCzdQ/RTa8VmZZmdaSvLuEDpRUoT5asr5IlmJZHlyS9noKlsKEy0cI479CWBWNG80O2EllHPtjdGAZmwu7CXo7e5GUPYbpcDKQmaMiDRPIOCWjTkW5EoG9nWOpXC6u9T/09Qrqkcb6E40lauLHEetpzkcHw2qk1As6Wts15Wu9KzpOGJkdQR2wvISJJ0OZUDH804ZPiJkSk5EsXJ+9YBdAN/S7nz5Ji9UxkJKQrTPVkam2SlGfJhynnd5Y4sNacPsOUbJt0z2j61nkiaXlXy6I6tMMumOnZ2KjHPlgWyBlvpU5LAWZC8RGFL891CetXO8+LApFOhEzHcKLeOO9AZhQGtfa/M8v4yd0E/9S9o/VXOc6awFLTsTbQO2CrznCI5c7YlYlmH2aRPJX209/HcPqbmOR69mM7zw1vujsNG//uYbB/Hncw29Z6m+3/+Yxkf1h8fqe5UmU9Eu+33ePmPyyZxNjLCaXUnXyvyMUEspVqPn7tlu9XHInGYvRV3i9bwHF13p+5De7W4qN5auxiVMPkqhMFfePAyKJy0h8OcJEy88NpFbX2CxQox7+OJYrW4SLnSfNK4dksaLzIezYtpsk2zizdjMqVWZ33uL7ogAyufHEiXnRYqXtQkBipGW2ACx0/G993xupqVvkTP51F0Ghl3eM9jjjZC8mgE1gLes72Mpz33D7Laxoa7hoWAvIG+ri9Z3Dzhwk1Nf/KI+5cJGxyi1rDs4hiyfn0uxwm6gBYnFW4S1o9W/+ZSNXa5UKwB21u+l4Iyrs31dqbrI19x3H/FYP3YX73NfGjbr+Y6SIx6UBmb2PV9miaKQaAa/wCbLm0kqcXpQI8WHqRfierwS/wuvrWCyzCxP9XO4sUGHE/WuWK8BffR+L3peAgmw6AdBvVV+20dLQeFSv9tHLyAm+DXK0Hg1bzh+Os1uNTa40utRhiGoNboerWXt+IA2PzpW7HdHY3LLb8+bAzXjeCtMTj69cbxA1ppk69iiHviBbZA+PZpb8n4Y7quw3wyPnTjx+NrbHwP98iPKY8lXIfUHgn7T7kJBSxcVzfH1fngasJdGC9Ci5ejDWG9W5jfRhyDZSepQNsKYyUNOQ8SbF4DngEvwToZvRXK/eG4PMZ4CNaN0Wjc8N7qpBWYRPDgsvnbvRq00e2KeIFaqpYbY5OzWF8ddxbfnRRYkw86XzJWr7vlpFjAfXONotV7wnd8r3qA59V8MzyRvhnGW6sNv6RP+f1SPFSe/OcvLOD0zLvgZEz42N0J/T6HRzcawBbHpvUMBGAb6qcShmNR3X3yd+TaGljnZk/QJ59NA+imo8d2DKeDQ98rlG4x7+znBp/E+YNv8HXGN2wy6PgX/jzm5vQhXOFeB+PyeARN8HryPC00BqOg0h0Ga/NZeEJMH4LLHPpNju9M1Fwf3efUhU7kqFLqDXadzJyPa/MpzVPrownMPx+/oN4kN2PcHmN8EP8Ic02LVnKmniT0qksH1hsemOeHYLJg7q/w1R4UDv5bMXgbBhX/rdgfm3cKTd1p+zuw5dCzfqsnz6PC6jUI+o0pfb5NvS37efg69jGf1r84/mAQ9N+CQmU0tO/T+hUGmDP+k1/v90bjfndUrwTjQvB9WG+MB+N2bVwY8zrDmrM1wtZsGluskYNJclFPVNfnCro471Lf8r2U7kXnpJvfq3ZrZI//mQuIKOiGXu57KTA1CzvfHv973pm5DwS50I5fJGGVgjarUaLjwxkzL3H1G9VDaG0oHsJR0fGBLBI/6tXq9R4WVAtk3yPhLxRIk4rrLH9yX2Bsru+/9Mf4yuW8SCdVrRNg3f9/PYcmVkYbLSQsOfPPRL+VfCnNOP0v/TEaQ/Bk3MzI97Mm3kpUQyfOECdFVC/bwatt0Vx9F5wDfCxjxuvf8XeOazUExNBZQ1CqNaGc3nXG59u/CLaF96RksWnsF6JxjcQrcNfTOuLBr8K7l/M7pcLDijDv4hNQENwJ6m84h+FVk2Y8eWkYrx63dszaIl5b77vsG524R9RPM9eXq11fKbmatCUey+hjE/YXCSlfP3Q/7uqlQn8PGtqiXwv9lyFhek19jfovlJgAO8D1xYfFUfuH6HdD2wCYmOi6x7jZLsjPhLnQ6KXhHsQr8qrewewtUSP/QOqZEbau9oJeCvOHFxeOS8sU44WThPCf3Zh0xzB2VDspVdw/YrRZKSFfEmDdw2blwjjLjN/znp8bFwlu9lDFm1zMvoeeIPDI2Zrb5mOz+3n5fTqTvkfr9+XHPz73u61+4INIHW024vrcLf2k8n1c+AqGxcp3PwbothoDuLkgcKKPROCymIz3EN73cVMI8Ke9+CWu/enx4hTPNxAS8p98z//j9c0/y3FwHq6i4Tyfj5XeWzXGd76P5DxGqATn2et3ID4Tv8TVuJut4CSLuHx99/y9nleybPosF3mrh0jFOJzPQeh54eH62o74ylc63w5iMlnBebfDcoRFiRam3Gdbmd8BmFzh7+Faw7oj5pHmnw1tEmrkytfw0R89lrufPX4Wg7RyU1BN4/Qjibcff5Guptt08z/Pu5/rffoeffzj8p7JW5+5wFcQD0zhR1kdceODpz4NwNZxwXKxh2aOap4J132d9ebtudroB9H4yNb4OfYV/r87xpWTwjq/wi+jPgaO/Q7NE96Dnzimx77Juocd3Q+5cEaenxH7pjoYEKOnoxgR4XsW3aKncMsIc5U7x7cffA7Koy7hpXgMp+Kn0WyUCdPFeebPEP6RLe5bGcwUeR4NTa6mvJL7exnX/+nYk8oReXTU/La33EPu20YlxX3zNb7iuq6Pp1f8//kRnh68z2gslPsj+yA8fbh/htj5bIpT5Pc1s36pV/UcFP9mxZAqH9d4wuY5cn4LvM1I8zTm/seqnxGKJy7p39C+hr1e11bop0MPQvAhyB1T9OaQO72XiBv2hCnTHVVj4fH98ImrV1j6G+fd8VrO0/e5fs56AxC/f5XTj96SH5BwjLoPOT1qi/crzjdfxIsyuZlem2CgsKyGitdmfBR7elNxWorArs4v70M0jnX8KPYVx+/AJ0kKpbxnBMdo2ztYbD744QHpJcyy+LcYGlrRdo3r382m7bOjuY/9iovXVPS7aSBIzCMYnU1yocI2jY3GmnUkBI9n9Ju/qS4Ocv916HrdoyiK3OEGp6ixtnrnPrpjErom3AP7fS9u79fLr4EW8ZvszzQQvOLM9ryt/iI3AKhQrToe3bg2Qf8VtaDQ9fCVQnjvrXp88R7PhCcSn6XulLaFNetrf5XpnK1hbjvocxH6ATkE8S9w3JT6zKp7Ms5cc3MxKSsGec+4cuagi5eU9j0J04i4kPQspcaSuy40rk6Lgrz3UtUW9Ftaz4M+nPp10fGNTxZr+irPF8+QtE9W9C5FK8roZRMvjPFJ3dhtLhWp+Ny2Y0qwX4j3ReOHe6XwOCmib68NL20MytYOnaztHPoN016m0YUYK3Lw6tnam+j9wcuO9J20z/v4hW2Ymi7sqXSZTfs75gE7sXYJOFXE7odVWBpz/zyWBtFWrw3PqPrH61v9fDPGnx8rL6PHDunwjVkPbdgM4OVCehsYey+yhoXTPocuVf5/VFqtom21w7Wcm3mfLW7vo59xetj/c/Fx+sd+ZcOAOlLqS7fUTudxhWrxbO2MaUZLoSulbmr5Qg/KQIdQoiWZ/Ri1eYI8JF13qmALFBsmbAvtB5piYn9NVtVaolPpBqY7ZW2SFb6ltE58TkJ6psq7VH/qHZE0xI2EHpeGme5le6JC3XDKCIDiOrZrDHsSy4pbW/GRS0tYoVdr+l2urRzT24ML0qCZpaQQbB1W8WHJ9HhJBpV6xrAWiMUqpGlsa5wQ6HcWso9c2srYxp556VVJ97j6RBaokBXdVC5Ucmn1MpZGfz/dpnKZsTq8sYVFWDNZHI11k5eRqfvb5QOV7Js3K2TzemOb2+yvmMYlx5TpLRbiu6xN6pqOSe96Yp+R2I/R8yEr04tdAuhZN9EjZStZtnv+m8/oeXftPVfPXbXbag1XoGm48Necje02Q+mr3g/l7oWQ80vG7owkpchO1MJjaR6KlfN2DosmSslZCu3vvo932nbHBAeBVRGfg22YOMTULRy9y7bKtOtYVwkjgR1VLma8t4YnSHZIij127oWlokvJfk5bWgWl+NkoGFAaPRqXFZo8HgbtftdzIK2OVapQC62NqbwbtQfFZ9VKHSXKd7FQphJsvdyYNFSiAW0kKxVB1iVbtSr+SmcPBuKsVqquxOLxg2FokKZN5iglgX7Da2JAFqxvu+U9G2ud4xPQqRuF5eRya6c5HdXm3VGRt/xLkaVTW/2F39gfutMkiYqFDiDUC696CKfBSdpxJEvgLVOCx7+O/HWn2V/7Hv5GSsXlRj8e/jlYN95GjcrbWzEYDQrBvNcoVvx4ferGj7HvzTZ+q/YQeutYMAYGbyElEmoXRbDymEL+liSWbKgsW71rU2WrA5U12ag8hCac6G6Jmmxo8gLb3zoSDNcFwfkhB91WaSK23Yt7WspMdUwYeHopQzMRiK9iW9ACHsTGVidnF8D20V923EjowS2mjDUVWw3TeBILeFfekOSXFDeF58g0YKU6GSwDpGi2Qy7DkV0wp2/ABWBs8JirGzlYoeaewtiREDcpXV2t0jXV0TDzFDZJWg5j1JHiGaYh1sW46NI40g+vuiOoM0tAIgWwFZzLmWWTQOHwbmwKUrb1HTLuSGW5S8P1nKXANgIdztLsmf4p5yD6KOalSMFXFKaeSWOiFqwwqXU8Zuq/OQdJVkKiK+J1CHEKyZObkHXkrC+uzJ6MmxtaV2xo/CKvxxQvwmFlZEphU5jWR0H/+a0YNsafhbgNyOzD4PQv4Jl47lk7BLJZnjlWhQ5dXMc7rq1q4AgPZBV+iJqQtiFZcxwDVS1IOpzfRywbNm60SepoXK+MgucCraXUEqX9bHF15cL9BtveMmbJ4AFJYpkpc2JXKeMUz2EYhHpssjWn+2KovKHAwZbh3/CHsEkqu04WcSNDxdK5Qa1kogyQlCul96fFZLGTspRQQJH6m3YGzSei5JYaRy4Bq80NWUot2ULOhXb2r9lWMslvfL43STIDsOdPsiOa9rbyfvXZHL0tLL2Wqd/aKw1/43tREhW/ju1LNW7Xq/HLpVYBlDTkz4lMBErms2Ub1VbAW6b9aB5HSz8efPlx9Y/2J1U/QffeLMgiNdn4jT1+/+nH1UP4MFj2vNrihefLUS2Pw7i6tccaVuVYf2LNQEkH0I+FV/3yttijArKc7XjrJVWrIUXnVb+91oPX4ZIpIK78j7E6JVhxzhqX8JkU9+xdywaSZmpWiijRSbyUzVOQkmViSbHQfP7CfvyH3zjg+Ly3qiX0VDBkxez+THJ426Huz+Vw2l94nPJlj8mx3GgYNIJR0G4MYdutlodElxyejHV6a3jK0e9uZPjnm2+dX8VxBkf3vFtOc+vFtFm9I2VD58hA7Y29xGD3q7g0mjnPcNqsGitG5GLzLfYVs8/ckbJhOUiUEQQn+8v7ycqFLUgiPmx+U3rUKfzcdX4TP7P9KmNzqdSSo8j88ruwVibp9EYwevOqO43XXFjBrFRMuhuleRR30YggYKnY9azmim/99XPk0pbI6nF+mJPWo7UdsAqya5HSfjW+kbSMybZ7jmNNR9nz6FhjPCTGGuoDZwdz61pRC8VkUhEJ8obQ4x7JEtSLf/GsM2X66k5aD/yMqPRdgeV5yvAwpTmSPDfFUp2W/UxX5lA+Dva9WtNasVOp7RCCVjBRyRuJ05pZmzmGGykdKDjkj6/zOHv8u7b0xqJVZJIu8wexclFreCpjYy3I5ZJ1hvhFm4LMFWMRfDs/qKVJNQmRVSFpE2rpUinVqx5QYu+Oirtw8nU275nnSiGcrki6bKhxEWQ1vRvr4Sffk/UB9oOICXLrlremdbni7NHIc4sqd/Fv2aOR2yQVhkiM/NhD+b9RWUWbqOLHfoff2eK7jonXt6r5mb5H+hnDJS/zoIJ3UelVdx0tqU6wT3q9GJbyC6969hsFyHOd2IIcEI1q3H6uk92tjHd5V2uzXoBG7Bxnv/CqF79RWH5vnfHzw0eMY/gxHZvtXjvuuvROuZfaN6sEXn3Jbfnx0Y+r8Rh5hLcQvgJZPB+6k1Uyb1W3LmV7Vlqd3gkC8Rib+Sn7L/8780zXvdg31wI5f0hs9ZZmjfrz5cz/ljWv0nHuG9c7LdGcrSB37I16/Gw+ixXfHIPofnPfK6JzvHa+8//H84AMBWTe9P/P+z/te87t+Zf18nbM1f/UY9z97kTXC/tdOzZ/8V3k8Q/nw8dovbwZu297855ertpNL+6+e4XDO6CC3nq5mPZRxv6T66CI1dz3WEjvnTPzXptJ4ntoJZO0O9b8M7UqECtiLnhtis/aD9nYic8fMb+mFCSOrBxBPkmWAnmNM+bsPeycMcrxZnfyiDgSMdj32bS99WMbc7p7j1zvgeDJSmWi2JGoedyue94t2xd7rLbkue3L4Kt9eYz9xvl2/08k7lRrjs1Y22MFtmIneNkv5pm7Vg2+nPlg42p3jqEFOOlBnvEImQz/UsUaiPryKtoMKU77d+RCUpeqRRtqaXrDcfg6Xo9d+wWBJg9h2UKWfgrdCifFc3avz8Ce9iHGGEnRJ8eQ2knEJToyDOCrrOPTgd1ILS/5HoGDw7CnMkmhszQKaiEpU1xNTOzGjsqb+gkYsYlduQVWFFlaUEMPUbNSIEiTQ4/N1xlJApPgFIBJ0LVaSyq2ADK8pGGwagce2yvOm0wvR3wVeSZPRKzRWTSLZ/BAuAZX/LnAtaBWh5raVmLzh1oaPhdiaXH7M9sK07xw805y76skfP5Gdlp4FwvwrIRrovA05ZaFJZZapTqQtVWg3JLrF9R3Ac/mfWZlElKWV0wKRsKOrR9WKmch9teS268ox6X5D/tWj6XdZ80Dxerdtxq3ScnqQ/Jh2wMyNSqBrpjrc2zWrotJ/1OkTMQqJz3NJ+30Tm+I2npSm2EbhtLB2IgJVM3EcN1las43LZHMAqxE1zY/5RyT8ofpMME8l2eN+b1D76w7+WZ/5hXP2O96I3/Z+3wE1LrULZXJshpxwaLVLoajdZw9zvBP+fepe6mevo8oD/+ckXSDv5bfubFI7G+/3mEjqdIR/rOuqaCgNj7p+OZ39c73wa5j54OpCegefaTzOHPwzpqrrXs8r0eZ81LnYyttte410LdWe8XyWpB86cEGpzFeF/ay9ztjhdaWjsI6Xz57596zWAtP+oWF9DaiDSQFGmzRrLSU3BjUe3YlYYmeTrWnncDJk/3cq8btljPvvN+8r8HOXNtgU6H8K/QyEiAx95scq0yS5xgQfXe2IagVYNDpomngOinnclwrY1mZ/sk8a6e/obIqwru6+o1+e1ikZ2lyNakhJdEGFKAGW/oK1YDp446lXmPxOk76DXMu3TvJBsVYP6pc7xnroFo/oseJubCANJhKC06SC2KLkOA02Ra5vR/ImAV7tkwoH039mvi3Y9snvgj/E3lczOu5Tzw22idqUWkva89jMbqwzcJc99gL9o0K9ukr34fEl2YODwG/p9yAY0A8k6+Ea1xDkmqNLv6yC8nV5zFygmU7ni19Z01y14ibOfO5R13Ciau/EuIte49fNu6UaxgNdh35t+/tl73RWmIIQHjLifw7DePqiusVJO31PdwkR7KbnAxwzTwXA1CwBvFNjOTU5zCuVYJax1WnhXFfpfj2neqSZOnyNhovZB9EPF0tAnoblQDLobGB33dH469eN0G9sRZl6gG5a/KfHzc2r5D36RXKt+tN9fIaV1CrOc23JJPx7bvHdvfyLDbvOg9pHxrcOZf/ByNJK0eq27S+vgnCtaPPI7fPmtgNOXl32t7gunSv9jXv5XWvMaknYxsb+HnqVsxc1DwMqlGEdGRo+rgskYq5IjB0UzOm2LnZ31OOP62qDQJ64KvZ5ivxvdXb4Opfe5/rJfqO4bT98D7ti8Qk1U3YUotlylbMZx8mjjxTKjxQsqNlPnqjwLSs7DVhnKnlHcuiEMUOfM3U9HBLgOxgrXHjpSLqOohfKH4QGhetzTOHZrggKZV6VvqonrxkYqnWQiQrUGOpqr0HrzNNklZTiuDFsZ3dKw3Q2EoQXTAjH7kKDRyNcxW1+VV5R8F/ZPaf2TYoY81BjBU9MOUkLx08m/avC4IJCtQeeByveu1++nt+x/rMSPqiJLaaD+/MTc/3Iq5cHzMSrtSvkn6WrC+1pXB/H16kz+p7MlY9Q+uw/bhLRmZI7WEJAtz1au23db8XjIdEF8RzIotzoqEQZQCydCSHmMdJjAtJK6gHozdQZuiejfxswdAXoXFwESvJrBWAQNCKK+BkpG+O+2i/JYOlWCFkNSJcaS4n7zcxCI09khsH/K8mkrjIKy7GSk17uZkaJsbVYRvRPk8ycjuSbmn16B4pVyA7AYov2sNCGXkTS400Fu2gDjqWyX2FDlvPYTBoDaV7m02Sg1KX5Dum38m2gGOxXodtACT+goy0j+n/tvpMgW1Wjvl3o9JzwGw40mwlhQGbZye2bFqbhXSvSrQSpZH6v2bsP+XPI32ec5chg4ivLyyRvIZkuGptWOsQ1Fen1eVi8njQ/cfETzJPukt+PzS2RlRjBp0IlkEltS40dJkm02Vf7PiGjOga0rN6L7PJF/UkPkam5pqEXvWr/9zLvyO1UvlEXIQaub0fpyfIeBXcn+BxDgm9u6wdNvHd5d7y5yGKD6i84XR1ngPLIPKFjgUp7QkcM+H9kPVQHsuW35/y59Ee+wY0tLlguGaTc9ZuWeT2GPsy5H2nuSjCcoAwHZJvqeWe0pLzY4Gkf5tEYVKZyL1r+S5yup8ie0s4le4ypfXF3QMpv67Kz70Fv4ttcH7R/eW5fu15EeXwsFbFeGqXzPdtLextAJgqxTVOLTuDHTHWhxm5TuQ2g3/y5/8rtWzpoY6qhxD14PqwPS70X4N1MMrnWFLPyvViGkKVHFr8QJyrWyVifWiwIJSrM44Ekn4qN0o1Dtdi3mIZokvFyn6x/slScBAnP3ZjvDZqEGvBjZKkp9Kdqabj4DddCsmiWTnNpf+CmgVB2VFD24SQtLYYoKSi86HSq6agUu4Qkw3rydugUJkMAz+m2HFTOS08f/ka23iN7Sh6FAcinp9PoR3in6zlin+EbZIfU2x595zt52/2ncXDe59Brf8YjqRnYOrYyNcpJv3NeU2PnWvdm74rySW0d8LxZMdlpg/OmKboopgjxQ6FCeqr4WbdYQyUObfQd8Cuql0j5HgPPSNz78j+sQw7xxlP4bR9YuqHxAi0j3M+wTSUthkvLzGt958uJcn2KdWit3oElqxr783WD1himOIT5LKMmcGeWXPwcuHS7nvZGIktSyxtRWuCs02A3h4whRk9JpKI5nX5vJgyxopk3R+Ga3pP1s4W6+T6fdIANP1K0oTeyuCGMzLNLCewVr0aQ02APSXH3Gr3i1hhRTV+3rtWUqsAjbWE+K67TIEJO4tGTDG6Fs4e7ISn1WV3Olu2i2Xn2Ve3bs6SwQ6Brh9jjswulAvBBnNa+071pFaAHPSfNFaw70q9L7pUv4ieJPYWJEkwIUz1y5vEM9HlHmW1QvLDM9aNYpm+mPF/RvtIJS0oBhhbaQ3zu/Hyfct7BqD0EhuDumItjmi/KcKGeDebhrAGS0KWMOtw/o/40V+yZPnXHpROV959xvIMdP9ij3tCroHaXgg7Sqf+rRJ3ppaK50T1bJVq4H3LjUejhwVjNEvaa6YxIPN8xdSQkcGjuFJvjsQqzmHyLZZEgLQi9n30IkxeGywzcvPLVOp5/pqutZFZs9Dn/MqtWffWIdeGw65/W+RNyYpqUMAXP4C+xGOS4j6qhwyz4/ayPvrLlPJ2wiRgbG57lY63Nn3Y0Th8ex0NttPWYMs978GyC9oT8u/GN9OTRT91jv0TfYfYX05HtIaTvcb7pFwkfAX3XqAtdu1cCztev/24M0ippuI/nzPrM69TPq2Xk01wmV80DsD8Z/l7xIzDdTIaF0mTa2f6/tonF4znu43VNPYszEuw/eDjgFpEc40sLlaogyGe34QbkkFZ5/d7sSs3tOgF1SxZpt/q16mNAM9Vle7h9axs8n5/Y+WbRd7jxLZthgMR65onmA/IHWwWLCOkWFvOb0c1Wg8W03YiFHG1FN/Mmw3GQEzXbOc0cqXch4yP5HX3BDr4UPIFWdfXs+latbeuatnrjumPS5/6eBgbUfFQnU4LGNdJdLsXX3EsH+PE9ttiWwO7E1/lsWVkRW/lxq38dca2HhYyx2x85Gdjs7XKQ4r8TQNjvF9AzU/4Aca+it/j0OA5XY08qhGTRSRRI59+e864+gsrxG82VxsRlYv35lLjcz4Zn6JSAxRiyGJc35usv9i9ZJ+h0HNz+KQsLszfkr1n5AsXYOq1jX3i1PNdKyK1yE6FQl/4GN053w1FK3M+Y8c1ZcY2zmty6E6DMK9p7nlxffah/dn9o1NNc+MkF+++mXnKEqhZKx8ZRxSPPu9y7yF/L2be7j9cXG5JLdKLRpPuF1Tgm/cs8ZGls+YkMgxu6o49pcw7ox35Ph386vgZvgLVDnLjz8F5njmmv8mx8Oz+q3nUX+RYkNQafucxb3pbe9HUW9O1UUzJfBX02+x+1J8PwHVwa/dO3dxHfVxxtc0B3ydbXle8ZWrWI8Yp/U38wqU2nk18kV/5SkSSGraqV2t700glX7rOMR9tv6kcObLWpvdmsfFqH/rpyoQ5fXLc559Ma6f4R4/3gyRoxIaN7LsJJ0uWexX7zBqX8DLWHuVBbUVeR8v0X37OBl88JFs+P65WKHbxzP5O6/6iBMybv3wFJqt1WPuc5+Eafv+5S+9H96FwF280nzQKM6Ls7isdPmfq9BlQZ2K5FdMjpf3H3O+kUFvg/N1J8IXe6/Rtn+lFSS5/5Jiiylw6ipGitX2O0a1eLvMSRPJkFzNXxx3f3DtGnvfX17ZAfeTm2ixmnNQ4ngg7fomcZ1L7BaZGJczYEphwMdu17FkOHuQtjeaxn5sDmvv+Zn61Djf3gNxF3ovWezr2HWm859P4NNdf3J8RG3gbSPoIRq+1/7wZi8C0T+vQFc7MT/M54mkcnJjDHjcqyRxrsLUPxzj53k8N/b0bq+SX2M3vq8S79ZvEHVQbKMbXq4wB7SGSo8LO03DtMj1oy4khuRrC7VxJHoP21q+yxKpK/d6/kwYnW+u9Txa7hTkPrBDUeodwp0fiFFpbR+H7umNpwWPpbq2iyhq5iKt4z2GFGifvU23ml0THwt33pfUTsjGf8jpgxohzLdH8d3uXF1ynzUfKmz9KNmeYXGsLs2Zo31LrhwPOY2Q8rXyvuLF1qG9rc61xJWcz9RjfzblkblCewzUAxOI3mrRUZ2ULulwMdC82/XZT16e6Anoentbabvflj9b637Qvy3443eF+YTXwndcOP7smNcFTqcYGX8/jR206j38V6/76PTv7T9z77MSVyu9j9YT6KB+MIWK8vMN5d/BTjw63Qe0lcf69wzPY53gG+1xciZ4q4UyCoN3zvaViwa3ULMflpBcMyx+KFUm2cC0WbXVdi10OQfaeNn+HS1CL/JwNZFQ8x93fx8V5eyjDP8vJzQKvm+GgtF3pPM6jBuN1pR6M++PRuPIieWvuPuoZ3Gnb9tLt+qbj/oZvQuuV1VonDOfKsffN3qesXSJJirzVWPWYeobZVxxcNccv7ey549qC+LMc57As/7R9mD6Ad449GnWJ/B7dM9x4wUiQLbJayM1Gufuz3HNrS+cVDh8kb1o5OrXRo1/vG0sLiUXThbGwMv1Xt3+VwYwIJtZoTA/WjedRYTF6KwYvQ0huIhaQa4UMcadZuZjztHoGi9UZmb0OudqJsFvNxpVleGhMkpY3aVVsYDtCWtWWo8o5tR6DYlc5D9XkjIZ9i6wqE+pnqpyJ4WyTpNEny9OxbRE4ZLyXL3YfI3e9lnpPzl5HMRpzL6O5T1KPv58//n0OWu74yiNx4xAb1/461ySpPTMGko3LZyX7sElyhMyh9okoBuFY/+jXqZ/OdazJELVW7k1Q/SZ7nsx6izXJ3IdZB82cUWxzhDofcKnNRG1o/3uxzVQzqq7EWofGDOrmrDlfzWKEnv0/2p/12/2ZLMyrW/5ORLKpTn8U62iZOJ2NWi2oZ70GXG0D/v7jX9UFsnr8wAVfMvWB/fvot2txTWTdMA6t1BWN9QHsZB7z2K+s7gJZW6Yh39fzotXed8e9veGvZ8/1IBiQi8Wlie0tsDwlmks6L3+GE1g8sU2a9Ju1R3ghzE3TyENpL/DuuxOZoL/37mLmh7RFjpOegdW3GQyCoW/ltw3Hm+zYCbOSrU0xn78EqUlgELPvIcj0ihNbZylZ6aVf2Pr8ZVwzQz9sWiMLyXBS5l48H9/Gco3Fbn45ExcJ2H2p+7JFLMtilllyHJJVxtpNtS3QG2Npden5CGaKdC9orYB1KesDiBT715X4dGYvNbgOwsSSTQ1zCvdRCfy4/mq+oTlDXiyZHp7UnDN9hYvVIqCaNsvDK7cg1v3I2b9XLJNaOTOODbxGyMpVLotGhfKPkPJDv0P4r0aFdE2mVDfBPnNTL0I9G59fRg8DcMaWN+tIqw+dhXtjkTDDDiYbx5XjDXbyvcM8qS67k2Q8KFafhHt9iIrD5/Fz2hsF/fFw/JjHIqfSs74ungvr17PkaXQ8p2/HeM3YqVFrPg08d+1tPTB6BIYDPG1f5g/tq7u3OvkE57itxeqDrej4HaqnA2zOtwOxWWIvGHrGyGsvmeugWjnmSARVzqXLLR9eUbPhOKjq1HOYN0axzA0WHccaFiEpye9HMJw37xz4/Dv8eOqx+8vvMo9n08VP31u8jOPqH4jFPi7Clfeq694I6/MK+FLMyXUvrsadkb/8PopgrdcbFCu1t/q5MiAflnbB94pFn3Dj/rLN59v6XpQyljSlnGH6QNia70YC3/PXGc0Fz9f4knterdzn7+NGWK/HGyKWht3b4K3YHotlgME+LpqNnyTTv10/+d4wNxd+G69s1bOF859I5YdPZn2JlZ8jnAxHe0qsDiFfTmvhPe2l3D4jmMDgkfolsiZx74AtEdjCQi3pGLMm+iQZaU4ev4/LYNovCqdWbMiz9zuzuZ1wUgxnKaVrZsts1i55CApqOcoxr8XeK/fb4M7vPEfNVdrw5yFsHV0Tz8EW9dBJz+Dlr2JIWY+7k/LA94ppUO8PXuLcGPCKV/r5+qs9Lg4bbw5OBPGS31yc/g35v/0z2HUU641aYHQt7PI6Z7n6QOpgcLifXqyoLof2/Nxe9jJzfKrp3nLHO297qpva3I25mtOScjW1nuvkY3FNMebIsaivfKvD1EtfoEE3sL3KHH/zb18z4nW9Ttb5yLxzxIpUM+T379SQsp/hZ8qfydZddCxxvYzegeGAe8M/M9dU3P+YTgvEE4VUPekePKMuweMa+jyL511+7cqcQ7Talk7vC+tAOo+rTs2MZPr/gBUCah8v8beTaPKRNcJLPLSaMZnjc+9+XGpw7LrpI/YB3w/z97jQngnH7MdwsoAlKMVRUJWeT9fLcAuJWM3l+se2cOU5VvJtzkgYnjCNSgnpFFo7etZmIouAmPr/xk6WPa0a5RvNM4ezg2OQrt+F+AErkkMX3bL5poJYjfCfEpt8Ej60JJbukzLFtuAHzDcLo8+nXDW3d57nL/+q9h2VGmXuj9aXzjjXuff0W80Fb3kKN3gWDZa63VIOwVbMzJvc3+vDzqYB8ma1dqYYvCNyujNoim2i5XBdGQWFxmgI6xrS/XLHtXhjUR7+6NTnFQdQXY5JR7KYhJswofcNfI/oG9Ke4lU289hyD4BxQg2X/Kio5nG+e53qixVtxjfx+6ge9IaIiUmamGwE2M7RGXOiA7HN2zRK7lKMHgI8W9VR2ht87s0+0C6G2EuajSvl0zccdorBNo62BWlVcG5+O06MHsa/Nk50PXz6hXbGv/BO77/HoEX4fMbx6TWylHl9vK4MxvWgLh5j9+aM5hFkTUDP1zO1rNv8y+JXyXoUe/vHlLBP0L1aIe+9c+/cY1UNTk84wLLnynOL6dnV+4Vocz4MLiZ/Ibl09ABDkjCH9Tth70iiWzgvy/5z9atLuerjk/8LDc1cXZI4xVL/QE8rs6dpr63NXFjlU1XaXp29/GxcJDHZMGWfvMdMX4v85bDvKfdlVIsJz8XXtFdOo2PDTOs7cXWxzlJcLjoIF+X1VorzJvGJ2Hp9u0gJPw5uysZobOI9UuwUirYX9w8YS+hg9BgrIj0vcEm5p9a/zEtfe5JNhybeRuNGxGWPyzfqh+m90bxM5ptKMSwtWRq71CCJbn4WyQE40HfCc2hulrVPJh6QPAfG9YXQj0OsjLr8gWWoVQsKayzxKovzTVlwiWGB+WdiH1ZKgCNAnp+EW8MbgU7Ynuovz3WKeQzHslixPPJbHqxbT8mMBz/23RpLpqZv6n6ZORxZbKD7XFB35HXzCo6VYJ7EW7S2mm0Qw/++ZvY2qVxJ73CLvMPo6KyRp4kUvFh2iTUa9Ydq+/lDQv0NidFTR8szX+fK9RBWJ+QXHWMbwLL6isu606PR2IN1TCS2y9ePRpMZ4+bBgRSODtZy8O8FR2jWAa2XyPz/hH4lW24PYYF0FB5U+jdwSPc1f7KxoskRAu75uvnb3uGkEQ87fGAec6ZGX/+qjYuCt20GB7aSubFnE6s6cIGD2PC4pbfp4LyplhhJH4H1SfoPofBLlP+MvQ2/MxoQzeAxnPSXzK1WrHI2Fx0FRscxrz1AcvCIU2m+3a9xXhcl3mvledCcpzlucMaO/mwGr8t8vWHOekjtFbAmzR8WxC39GNUUXxW3W4qvbcPWI5B+SRJt24yRkOfL+oas+5zBPGfqAe4zXqAO5OpaMO/GXYO2PcMn4/4YNB5cXVReD7qWP+VimWQ9oNrmlfpBsG+fKkYU9crzU56LCv50byR7JOuHIrawuArmYKnewHlGc0XsK+laLT92ZrhF4E02qC6BPWpWAsa6uhsXepfe1S93jHayeKJuhk6/0OqoRw/QsWB/4tnUWhCxdQJrJne82ievs6z52ba4FdbWpTHay/SxO4Pdf/7H//iPr//4X8WMEPzH5n17iKP9Pw+7FH/91kLGfvoUf5z/4sOwmvme7O5+7P/8XxOqxl0ltwgA";
+const ASSETS_GZIP_BASE64 = "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";
 
 //#endregion
 //#region src/template/embedded.ts
@@ -6465,6 +8067,218 @@ function runSkillsList() {
 	}])}\n`);
 }
 
+//#endregion
+//#region src/publish/placement.ts
+/**
+* The data-placement checks `oxyc validate` runs over an `oxy-app.json`.
+*
+* THE SHAPE OF THE DATA PICKS THE STORE. Append-only facts and history go to
+* the workspace's Airhouse through `ctx.airhouse`, in the app's own
+* `app_<writer>` schema; records the app edits go to org OLTP (`ctx.oltp`);
+* files go to `ctx.storage`; a customer warehouse is read-only, written only
+* under a declared, reasoned exception.
+*
+* ADVISORY. Each rule mirrors a refusal the platform makes at publish or
+* promote, and answers before a bundle is built. The server is the authority:
+* where the two disagree, it is right.
+*/
+const MANIFEST = "oxy-app.json";
+const isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const error = (file, path, message) => ({
+	level: "error",
+	file,
+	path,
+	message
+});
+const warning = (file, path, message) => ({
+	level: "warning",
+	file,
+	path,
+	message
+});
+function writerFor(slug) {
+	if (slug === void 0) return { kind: "unknown" };
+	const name = appWriterName(slug);
+	if (name !== void 0) return {
+		kind: "derived",
+		schema: `app_${name}`
+	};
+	return {
+		kind: "underivable",
+		why: slug.includes("_") ? `the slug \`${slug}\` contains \`_\`, and a slug containing \`_\` cannot back a schema — it would share one with its hyphenated twin` : `the slug \`${slug}\` cannot derive a writer: ${WRITER_NAME_RULE}`
+	};
+}
+/**
+* Every placement issue in one app.
+*
+* `slug` is passed rather than read, because a manifest without one still
+* publishes — under `--app`, or from an `apps/<org>/<app>/` directory — and the
+* caller is what knows which applies.
+*/
+function checkAppPlacement(appDir, manifest, slug) {
+	const issues = [];
+	const writer = writerFor(slug);
+	let usesSchema = false;
+	const functions = isObject(manifest.functions) ? manifest.functions : {};
+	for (const [name, spec] of Object.entries(functions)) {
+		if (!isObject(spec)) {
+			issues.push(error(MANIFEST, `functions.${name}`, "must be an object"));
+			continue;
+		}
+		checkWarehouseWrites(name, spec, issues);
+		usesSchema = checkAirhouseGate(name, spec, writer, issues) || usesSchema;
+		checkSecretsAsState(appDir, manifest, name, spec, issues);
+	}
+	usesSchema = checkAirhouseMigrations(appDir, manifest, writer, issues) || usesSchema;
+	if (usesSchema && writer.kind === "unknown") issues.push(warning(MANIFEST, "slug", "`ctx.airhouse` and Airhouse migrations use the schema `app_<writer>`, derived from the app slug, and no slug is known here — set `slug` in oxy-app.json so it can be checked"));
+	return issues;
+}
+function checkWarehouseWrites(fn, spec, issues) {
+	const writes = spec.customerWarehouseWrites;
+	if (writes == null) return;
+	const path = `functions.${fn}.customerWarehouseWrites`;
+	if (!isObject(writes)) {
+		issues.push(error(MANIFEST, path, "must be an object mapping a database to the reason this function may write to it"));
+		return;
+	}
+	const destinations = Array.isArray(spec.destinations) ? spec.destinations : [];
+	for (const [database, reason] of Object.entries(writes)) {
+		const at = `${path}.${database}`;
+		if (typeof reason !== "string" || !reason.trim()) issues.push(error(MANIFEST, at, "the reason must be a non-empty string — an exception to read-only customer warehouses has to say why it exists"));
+		else if (!destinations.includes(database)) issues.push(error(MANIFEST, at, `\`${database}\` is not in this function's \`destinations\`, so the function cannot write to it — an exception for a database the function cannot write is dead config`));
+		else issues.push(warning(MANIFEST, at, `function \`${fn}\` writes to customer warehouse \`${database}\` (reason: ${reason.trim()}) — customer warehouses are read-only by default; facts and history belong in \`ctx.airhouse\`, records in \`ctx.oltp\``));
+	}
+}
+/** True when this function turns `ctx.airhouse` on. */
+function checkAirhouseGate(fn, spec, writer, issues) {
+	const gate = spec.airhouse;
+	if (gate == null) return false;
+	const path = `functions.${fn}.airhouse`;
+	if (!isObject(gate)) {
+		issues.push(error(MANIFEST, path, "must be an object: `{ \"enabled\": true }`"));
+		return false;
+	}
+	if (gate.enabled != null && typeof gate.enabled !== "boolean") {
+		issues.push(error(MANIFEST, `${path}.enabled`, "must be true or false"));
+		return false;
+	}
+	if (gate.enabled !== true) return false;
+	if (writer.kind === "underivable") issues.push(error(MANIFEST, `${path}.enabled`, `\`ctx.airhouse\` writes the app's own schema \`app_<writer>\`, whose writer is derived from the app slug — and ${writer.why}`));
+	return true;
+}
+function checkSecretsAsState(appDir, manifest, fn, spec, issues) {
+	if (spec.entry != null && typeof spec.entry !== "string") {
+		issues.push(error(MANIFEST, `functions.${fn}.entry`, "must be a string"));
+		return;
+	}
+	const entry = functionEntry(manifest, fn);
+	let source;
+	try {
+		source = readFileSync(join(appDir, entry), "utf8");
+	} catch (cause) {
+		const code = cause.code ?? "EUNKNOWN";
+		issues.push(warning(MANIFEST, `functions.${fn}`, `not scanned for \`ctx.secrets.set\`: ${entry} could not be read (${code})`));
+		return;
+	}
+	for (const hit of secretsUsedAsState(source)) issues.push(warning(entry, `line ${hit.line}`, `function \`${fn}\` stores ${hit.why} with \`${hit.call}\` — secrets hold credentials; state that changes belongs in \`ctx.oltp\` (records) or \`ctx.airhouse\` (facts)`));
+}
+/**
+* `migrations.dir`'s rule on the server (`normalize_dir`): a plain relative
+* directory, since it is matched as a prefix inside the bundle.
+*/
+function normalizeDir(dir) {
+	const trimmed = dir.trim().replace(/^\/+|\/+$/g, "");
+	if (trimmed === "" || dir.startsWith("/") || dir.includes("\\") || trimmed.split("/").some((c) => c === ".." || c === "." || c === "")) return;
+	return trimmed;
+}
+/** The declared directory, normalised, or `undefined` after reporting why not. */
+function declaredDir(manifest, issues) {
+	const block = manifest.airhouseMigrations;
+	if (!isObject(block)) {
+		issues.push(error(MANIFEST, "airhouseMigrations", "must be an object: `{ \"dir\": \"airhouse-migrations\" }`"));
+		return;
+	}
+	if (typeof block.dir !== "string" || !block.dir.trim()) {
+		issues.push(error(MANIFEST, "airhouseMigrations.dir", "is required — the directory of `.sql` files applied, once each and in filename order, to the app's Airhouse schema at promote"));
+		return;
+	}
+	const dir = normalizeDir(block.dir);
+	if (dir === void 0) {
+		issues.push(error(MANIFEST, "airhouseMigrations.dir", `\`${block.dir}\` is not a safe path inside the bundle — use a plain relative directory such as "airhouse-migrations"`));
+		return;
+	}
+	const oltp = manifest.migrations;
+	if (isObject(oltp) && typeof oltp.dir === "string" && normalizeDir(oltp.dir) === dir) {
+		issues.push(error(MANIFEST, "airhouseMigrations.dir", `\`${dir}\` is also \`migrations.dir\` — OLTP migrations run on Postgres and Airhouse migrations on DuckLake, so each needs its own directory`));
+		return;
+	}
+	return dir;
+}
+/**
+* Where the directory is in the SOURCE tree.
+*
+* The server reads it from the built bundle, so it may live at the app root,
+* under `public/` (which Vite copies to the bundle root), or already in the
+* build output.
+*/
+function locateDir(appDir, dir, outDir) {
+	const candidates = /* @__PURE__ */ new Set([
+		dir,
+		`public/${dir}`,
+		`${outDir.replace(/\/+$/, "")}/${dir}`
+	]);
+	for (const candidate of candidates) try {
+		if (statSync(join(appDir, candidate)).isDirectory()) return candidate;
+	} catch {}
+}
+/** `*.sql` under `root`, as paths relative to it — the server's `collect`, which recurses. */
+function sqlFiles(root, prefix = "") {
+	const found = [];
+	for (const entry of readdirSync(join(root, prefix), { withFileTypes: true })) {
+		const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.isDirectory()) found.push(...sqlFiles(root, rel));
+		else if (entry.name.endsWith(".sql")) found.push(rel);
+	}
+	return found;
+}
+/** True when the app declares Airhouse migrations. */
+function checkAirhouseMigrations(appDir, manifest, writer, issues) {
+	if (manifest.airhouseMigrations == null) return false;
+	const dir = declaredDir(manifest, issues);
+	if (dir === void 0) return true;
+	if (writer.kind === "underivable") issues.push(error(MANIFEST, "airhouseMigrations", `Airhouse migrations run in the app's own schema \`app_<writer>\`, whose writer is derived from the app slug — and ${writer.why}`));
+	const build = isObject(manifest.build) ? manifest.build : {};
+	const outDir = typeof build.outDir === "string" && build.outDir.trim() ? build.outDir : "out";
+	const found = locateDir(appDir, dir, outDir);
+	if (found === void 0) {
+		issues.push(error(MANIFEST, "airhouseMigrations.dir", `\`${dir}\` does not exist — looked for ${dir}/, public/${dir}/ and ${outDir}/${dir}/ in the app directory`));
+		return true;
+	}
+	let files;
+	try {
+		files = sqlFiles(join(appDir, found)).sort();
+	} catch (cause) {
+		issues.push(error(MANIFEST, "airhouseMigrations.dir", `\`${found}\` could not be read: ${cause.message}`));
+		return true;
+	}
+	if (files.length === 0) {
+		issues.push(error(MANIFEST, "airhouseMigrations.dir", `\`${found}\` holds no \`.sql\` files — the platform refuses a declared migrations directory with nothing in it`));
+		return true;
+	}
+	const schema = writer.kind === "derived" ? writer.schema : void 0;
+	for (const rel of files) {
+		const file = `${found}/${rel}`;
+		const sql = readFileSync(join(appDir, file), "utf8");
+		for (const hit of scanAirhouseMigration(sql, schema)) issues.push({
+			level: hit.level,
+			file,
+			path: `line ${hit.line}`,
+			message: hit.message
+		});
+	}
+	return true;
+}
+
 //#endregion
 //#region src/commands/validate.ts
 /**
@@ -6523,6 +8337,16 @@ const SKIP = /* @__PURE__ */ new Set([
 	".venv",
 	"__pycache__"
 ]);
+/**
+* The custom-app manifest, checked for DATA PLACEMENT rather than against a
+* schema: none is generated for it — the SDK's type is its only definition —
+* so `publish/placement.ts` checks where the app's data goes instead.
+*/
+const APP_MANIFEST = "oxy-app.json";
+/** Matched on the basename, for the reason `schemaFor` gives. */
+function isAppManifest(path) {
+	return (path.split("\\").join("/").split("/").pop() ?? path) === APP_MANIFEST;
+}
 /** The schema a path is governed by, or `undefined` for a file we do not check. */
 function schemaFor(path) {
 	const normalised = path.split("\\").join("/");
@@ -6638,8 +8462,10 @@ function walk(root, prefix = "") {
 			out.broken.push(...nested.broken);
 			continue;
 		}
-		if (extname(entry.name) !== ".yml" && extname(entry.name) !== ".yaml") continue;
-		if (!schemaFor(rel)) continue;
+		if (entry.name !== APP_MANIFEST) {
+			if (extname(entry.name) !== ".yml" && extname(entry.name) !== ".yaml") continue;
+			if (!schemaFor(rel)) continue;
+		}
 		if (entry.isSymbolicLink()) {
 			let target;
 			try {
@@ -6847,11 +8673,12 @@ function describe(file, errors) {
 * missing from the installation: `compileAll` skips a schema that is not on
 * disk, this returned no findings, and the caller counted the file anyway.
 */
-function validateFile(root, rel, compiled) {
+function validateFile(root, rel, compiled, warnings, notes) {
 	const schema = schemaFor(rel);
-	if (!schema) return KIND_UNKNOWN;
-	const validate = compiled.get(schema);
-	if (!validate) return SCHEMA_MISSING;
+	const manifest = isAppManifest(rel);
+	if (!schema && !manifest) return KIND_UNKNOWN;
+	const validate = schema ? compiled.get(schema) : void 0;
+	if (schema && !validate) return SCHEMA_MISSING;
 	const full = join(root, rel);
 	let stats;
 	try {
@@ -6874,6 +8701,7 @@ function validateFile(root, rel, compiled) {
 		hint: WHOLE_WORKSPACE_HINT,
 		remedy: whyUnreadable(ENOTFILE).remedy
 	});
+	if (!validate) return validateAppManifest(root, rel, warnings, notes);
 	let parsed;
 	try {
 		parsed = parse$1(readFileSync(full, "utf8"));
@@ -6900,9 +8728,9 @@ function runValidate(flags, cwd = process.cwd()) {
 		files: [relative(root, resolve(base, single))],
 		broken: []
 	} : walk(root);
-	if (single && !schemaFor(files[0] ?? "")) throw new CliError(`oxyc validate does not know how to check ${single}`, {
+	if (single && !schemaFor(files[0] ?? "") && !isAppManifest(files[0] ?? "")) throw new CliError(`oxyc validate does not know how to check ${single}`, {
 		code: ExitCode.USAGE,
-		hint: `it checks ${SCHEMA_FOR.map(([s]) => s).join(", ")}`
+		hint: `it checks ${[...SCHEMA_FOR.map(([s]) => s), APP_MANIFEST].join(", ")}`
 	});
 	if (files.length === 0 && broken.length === 0) {
 		if (flags.json) {
@@ -6919,10 +8747,12 @@ function runValidate(flags, cwd = process.cwd()) {
 		return;
 	}
 	const findings = [];
+	const warnings = [];
+	const notes = /* @__PURE__ */ new Set();
 	const checked = [];
 	const unchecked = [];
 	for (const rel of files) {
-		const result = validateFile(root, rel, compiled);
+		const result = validateFile(root, rel, compiled, warnings, notes);
 		if (typeof result === "string") {
 			unchecked.push({
 				path: rel,
@@ -6935,6 +8765,8 @@ function runValidate(flags, cwd = process.cwd()) {
 	}
 	const nothingRead = checked.length === 0 && unchecked.length + broken.length > 0;
 	if (flags.json) {
+		reportWarnings(warnings);
+		reportNotes(notes);
 		const report = {
 			checked: checked.length,
 			unchecked,
@@ -6948,6 +8780,8 @@ function runValidate(flags, cwd = process.cwd()) {
 	}
 	listSkipped("no schema was applied", unchecked, whyUnchecked);
 	listSkipped("could not read them", broken, whyUnreadable);
+	reportWarnings(warnings);
+	reportNotes(notes);
 	if (findings.length === 0) {
 		if (nothingRead) throw nothingReadFailure(unchecked.length + broken.length);
 		process.stdout.write(`${out.green(`${checked.length} file(s) valid`)}\n`);
@@ -6972,6 +8806,79 @@ function runValidate(flags, cwd = process.cwd()) {
 	throw silentFailure(findings.length, checked.length);
 }
 /**
+* An `oxy-app.json`: where its data goes, and what its functions call — not
+* its schema.
+*
+* Errors come back as findings and fail the run like a schema violation;
+* warnings are collected for `reportWarnings` and do not. Unparsable JSON is a
+* `(parse)` finding, the YAML arm's rule — not the throw `readAppManifest`
+* makes, which would end the walk at the first broken manifest.
+*
+* The function lint runs beside the placement check on the same manifest. Its
+* offline half — capabilities, isolate globals, the `destinations` allowlist —
+* is answered here; the half that needs the database's engine is `publish`'s,
+* and `notes` says so once, rather than reporting a clean run as complete.
+*/
+function validateAppManifest(root, rel, warnings, notes) {
+	const full = join(root, rel);
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(full, "utf8"));
+	} catch (cause) {
+		return [{
+			file: rel,
+			path: "(parse)",
+			message: cause.message.split("\n")[0] ?? ""
+		}];
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) return [{
+		file: rel,
+		path: "(root)",
+		message: "the top level must be an object"
+	}];
+	const manifest = parsed;
+	const appDir = dirname(full);
+	const slug = typeof manifest.slug === "string" && manifest.slug.trim() ? manifest.slug : inferOrgApp(appDir).app;
+	const prefix = dirname(rel) === "." ? "" : `${dirname(rel)}/`;
+	const findings = [];
+	for (const issue of checkAppPlacement(appDir, manifest, slug)) {
+		const finding = {
+			file: `${prefix}${issue.file}`,
+			path: issue.path,
+			message: issue.message
+		};
+		(issue.level === "error" ? findings : warnings).push(finding);
+	}
+	const lint = lintAppFunctions(appDir, manifest);
+	for (const issue of lint.issues) findings.push({
+		file: `${prefix}${issue.file}`,
+		path: issue.path,
+		message: `[function-lint/${issue.rule}] ${issue.message}`
+	});
+	for (const line of lint.skipped) notes.add(`${prefix}${APP_MANIFEST}: ${line}`);
+	if (lint.writes.length > 0) notes.add(`${prefix}${APP_MANIFEST}: the engine half of the function lint (\`upsert\` and \`ctx.tx\` dialects, customer-warehouse writes) needs the server and is skipped offline — \`oxyc publish\` runs it before the upload`);
+	return findings;
+}
+/**
+* Warnings from the manifest checks: printed, never counted as problems.
+*
+* On stderr in both modes, the channel every other warning here takes, so
+* `--json` keeps one document on stdout and its shape does not move.
+*/
+function reportWarnings(warnings) {
+	for (const w of warnings) warn(`${w.file} (${w.path}): ${w.message}`);
+}
+/**
+* What the function lint did NOT do, once each.
+*
+* `info`, not `warn`: a skipped engine check is the ordinary offline case, not
+* a degraded run — but it is said, because a clean `validate` on a function
+* that upserts into ClickHouse is not a clean publish.
+*/
+function reportNotes(notes) {
+	for (const note of notes) info(note);
+}
+/**
 * Name each skipped file with its reason, capped, and say when the cap bit.
 *
 * ONE SHARED REASON IS PRINTED ONCE. Moving the reason per file fixed a message
@@ -7719,6 +9626,16 @@ function buildProgram() {
 		if (opts.all && opts.org) throw usageError("--all and --org name different sets", "drop one — ending every session and ending one are different acts");
 		await runAssumeEnd(createContext(globals(opts)), opts.org, Boolean(opts.all));
 	});
+	const oltp = program.command("oltp").description("an org's OLTP database (ctx.oltp) — status, and provisioning, for staff");
+	withGlobals(oltp.command("status").description("every org's OLTP state — or, with --org, one org's store and writers").option("--json", "emit the server's response")).action(async (opts) => {
+		await runOltpStatus(createContext(globals(opts)), opts.org, Boolean(opts.json));
+	});
+	withGlobals(oltp.command("provision").description("create or reconcile an org's OLTP database and writers — a billable resource").option("--writer <app:slug|pipeline:source>", "a writer to ensure (repeatable)", collect, []).option("--yes", "provision without asking").option("--json", "emit the server's response")).action(async (opts) => {
+		await runOltpProvision(createContext(globals(opts)), opts.org, opts.writer, {
+			yes: opts.yes,
+			json: opts.json
+		});
+	});
 	withGlobals(program.command("logout").description("drop the cached token for a deployment")).action((opts) => {
 		runLogout(createContext(globals(opts)));
 	});
@@ -7728,6 +9645,12 @@ function buildProgram() {
 	withGlobals(program.command("token").description("print the bearer token, for a raw curl")).action((opts) => {
 		runToken(createContext(globals(opts)));
 	});
+	withGlobals(program.command("checks").description("run an app's checks (functions marked \"check\": true)").command("run <app>").description("run every check of <org>/<app> (or an app id) and wait for results").option("--json", "emit results as JSON").option("--timeout <seconds>", "per-check timeout", "300")).action(async (app, opts) => {
+		await runChecks(createContext(globals(opts)), app, {
+			json: Boolean(opts.json),
+			timeoutSeconds: Number(opts.timeout)
+		});
+	});
 	withGlobals(program.command("list").description("the customers, from the GitHub topic that registers them").option("--refresh", "ask GitHub again rather than serving the hour-long cache").option("--json", "emit the customers as a JSON array")).action((opts) => {
 		runList(createContext(globals(opts)), {
 			refresh: opts.refresh,
@@ -7799,7 +9722,7 @@ function buildProgram() {
 			yes: opts.yes
 		});
 	});
-	withGlobals(program.command("publish").description("build a custom app and publish its bundle (a draft, unless --promote)").option("--app <slug>", "app slug (default: OXY_APP, then oxy-app.json slug, then apps/<org>/<app>/)").option("--build-id <id>", "unique per publish (default: the CI run, else random)").option("--dir <path>", "publish this pre-built directory instead of running the build").option("--promote", "publish straight to the live channel").option("--name <name>", "display name override for the app").option("--repo <url>", "git remote to record (default: the checkout's origin)").option("--commit <sha>", "commit to record (default: HEAD, or GITHUB_SHA)").option("--branch <name>", "branch to record (default: the checkout's, or GITHUB_REF_NAME)").option("--build-only", "build and bundle functions, then stop — no credential needed").option("--prebuilt", "with --dir: its functions are already bundled; check them, don't rebuild").option("--json", "print the server's result as JSON").addHelpText("after", "\n--org takes a slug or a UUID (default: OXY_ORG, then oxy-app.json orgSlug, then\nthe apps/<org>/<app>/ directory). --project pins the workspace; otherwise it is\nresolved from the target. .env.local and .env are loaded without overriding.\n\nAuth: the --token-env variable, then `oxyc login`'s cache — or, in a GitHub\nActions job with `id-token: write` and neither, trusted publishing via OIDC.\n")).action(async (opts) => {
+	withGlobals(program.command("publish").description("build a custom app and publish its bundle (a draft, unless --promote)").option("--app <slug>", "app slug (default: OXY_APP, then oxy-app.json slug, then apps/<org>/<app>/)").option("--build-id <id>", "unique per publish (default: the CI run, else random)").option("--dir <path>", "publish this pre-built directory instead of running the build").option("--promote", "publish straight to the live channel").option("--name <name>", "display name override for the app").option("--repo <url>", "git remote to record (default: the checkout's origin)").option("--commit <sha>", "commit to record (default: HEAD, or GITHUB_SHA)").option("--branch <name>", "branch to record (default: the checkout's, or GITHUB_REF_NAME)").option("--build-only", "build and bundle functions, then stop — no credential needed").option("--prebuilt", "with --dir: its functions are already bundled; check them, don't rebuild").option("--json", "print the server's result as JSON").option("--allow-function-lint", "publish past an Oxy Function lint finding; each prints as a warning naming its rule").addHelpText("after", "\n--org takes a slug or a UUID (default: OXY_ORG, then oxy-app.json orgSlug, then\nthe apps/<org>/<app>/ directory). --project pins the workspace; otherwise it is\nresolved from the target. .env.local and .env are loaded without overriding.\n\nAuth: the --token-env variable, then `oxyc login`'s cache — or, in a GitHub\nActions job with `id-token: write` and neither, trusted publishing via OIDC.\n\nBefore the build, each Oxy Function's source is linted for what the host refuses\nat the first call: a `ctx.*` call whose capability the manifest lacks, a global\nthe isolate does not have (Buffer, TextEncoder, process, …), a write outside\n`destinations`; before the upload, with the target's database list, an `upsert`\nor `ctx.tx` on an engine that refuses it and a customer-warehouse write with no\n`customerWarehouseWrites` reason. `--allow-function-lint` is the way past a\nfalse positive — please open an issue naming the rule.\n")).action(async (opts) => {
 		await runPublish(createContext(globals(opts)), {
 			app: opts.app,
 			buildId: opts.buildId,
@@ -7811,17 +9734,19 @@ function buildProgram() {
 			branch: opts.branch,
 			buildOnly: opts.buildOnly,
 			prebuilt: opts.prebuilt,
-			json: opts.json
+			json: opts.json,
+			allowFunctionLint: opts.allowFunctionLint
 		});
 	});
-	withGlobals(program.command("init-ci").description("write a GitHub Actions workflow that publishes this app with trusted publishing").option("--app <org/app>", "the app to publish (default: this directory's oxy-app.json)").option("--environment <name>", "GitHub environment the publish job runs in", "oxy-publish").option("--force", "overwrite an existing workflow")).action((opts) => {
+	withGlobals(program.command("init-ci").description("write a GitHub Actions workflow that publishes this app with trusted publishing").option("--app <org/app>", "the app to publish (default: this directory's oxy-app.json)").option("--environment <name>", "GitHub environment the publish job runs in", "oxy-publish").option("--force", "overwrite an existing workflow").option("--promote", "publish straight to the live channel, and verify it with the app's checks")).action((opts) => {
 		runInitCi(createContext(globals(opts)), {
 			app: opts.app,
 			environment: opts.environment,
-			force: opts.force
+			force: opts.force,
+			promote: opts.promote
 		});
 	});
-	program.command("validate").description("check a workspace's YAML against the schemas, without a Rust binary").option("-f, --file <path>", "validate one file instead of the whole workspace").option("--json", "emit findings as JSON").addHelpText("after", "\nStructural checks only. `oxy validate` additionally resolves `databases:` and\n`llm.ref` against config.yml, which needs the workspace loaded — where the two\ndisagree, that one is right. The schemas here are generated from the same Rust\ntypes, so they cannot drift from it.\n").action((opts) => {
+	program.command("validate").description("check a workspace's YAML against the schemas, and oxy-app.json's data placement").option("-f, --file <path>", "validate one file instead of the whole workspace").option("--json", "emit findings as JSON").addHelpText("after", "\nStructural checks only. `oxy validate` additionally resolves `databases:` and\n`llm.ref` against config.yml, which needs the workspace loaded — where the two\ndisagree, that one is right. The schemas here are generated from the same Rust\ntypes, so they cannot drift from it.\n\nEach oxy-app.json is checked for where its data goes: customerWarehouseWrites,\nairhouse, airhouseMigrations (DuckLake-safe, schema-qualified SQL) and secrets\nused as state. Its functions' sources are linted for a `ctx.*` call whose\ncapability the manifest lacks, a global the isolate does not have (Buffer,\nTextEncoder, process, …) and a write outside `destinations`; the engine half\n(upsert / ctx.tx dialect, customer-warehouse writes) needs the server and runs\nin `oxyc publish`. Warnings go to stderr; the server is the authority.\n").action((opts) => {
 		runValidate({
 			file: opts.file,
 			json: opts.json
@@ -7871,6 +9796,7 @@ const EXIT_CODE_HELP = `0  success
 6  the request was malformed (4xx other than 401/403/404)
 7  unavailable — 5xx, a timeout, or the network failed. Retryable.
 8  refused — the operation would have destroyed or overwritten something
+9  a check ran and failed or timed out (\`oxyc checks run\`)
 `;
 /**
 * Render a failure and pick the exit code.
@@ -7881,13 +9807,13 @@ const EXIT_CODE_HELP = `0  success
 */
 function reportAndExit(cause) {
 	if (cause instanceof CliError) {
-		error(cause.message);
+		error$1(cause.message);
 		if (cause.detail) for (const line of cause.detail.split("\n")) process.stderr.write(`  ${err.dim(line)}\n`);
 		if (cause.hint) for (const line of cause.hint.split("\n")) hint(line);
 		if (cause.remedy) remedy(cause.remedy);
 		process.exit(cause.code);
 	}
-	error(cause?.message ?? String(cause));
+	error$1(cause?.message ?? String(cause));
 	if (process.env.OXYC_DEBUG && cause instanceof Error && cause.stack) process.stderr.write(`${err.dim(cause.stack)}\n`);
 	process.exit(ExitCode.FAILURE);
 }