From 61a8ee1eb47cc0fcb6fac9b23d78c81119503a6a Mon Sep 17 00:00:00 2001 From: Taras Mankovski Date: Sun, 18 Oct 2026 05:42:49 -0400 Subject: [PATCH 1/4] =?UTF-8?q?=E2=9C=A8=20Select=20a=20component's=20resu?= =?UTF-8?q?lt=20with=20yq,=20and=20render=20a=20value=20as=20YAML=20(#934)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A shared `yq` attribute selects one JSON value out of what a component returned, and `` renders a value as a YAML document. Both are one WebAssembly engine, built once per execution and only when something asks it a question: a document that writes neither decodes and compiles nothing. The engine's bytes are committed source. `scripts/generate-yq-wasm.ts` writes `packages/core/src/yq-wasm.ts` from the pinned `yq.rs@0.1.0` package, verifying its name, version, length and digest, and emits the provenance and the vendor notices beside it. A compiled binary and an installed npm package therefore carry the engine in their own static import graph rather than reaching for a path, a fetch or a host filesystem. Selection sits in one fixed place in an invocation's life: the producer's own contract accepts what it produced, its invocation joins, and only then is the expression asked. An expression repairs no return its schema rejected, and an answer that is not one JSON value refuses with the way to ask for several. A host that evaluates generated source on somebody's behalf can own where one occurrence's selected result goes. That destination is stated once, as a value canonical execution copies before any document code runs, and is authenticated against the exact definition this execution's capture published. It is reachable through no context, no name and no metadata, and a receiver belongs to one occurrence and is revoked when that invocation settles. The REPL Sidekick uses it. A reply may write `yq` on any control it is admitted to; the intent is marked before the work, the original outcome is recorded as it always was, and a separate acknowledged `control-presentation` record carries the selected value. What a next turn is sent is that record — so an acknowledgement that never landed sends nothing rather than a raw fallback. Static document validation now takes its engine-owned props from `ENGINE_OWNED_PROPS` rather than keeping its own list, which is what lets an entry a run executes also pass the REPL's preflight. --- architecture.md | 136 ++- deno.json | 4 +- deno.lock | 10 +- packages/cli/src/repl/program.ts | 3 +- packages/cli/src/repl/sidekick/admission.ts | 34 +- packages/cli/src/repl/sidekick/controls.ts | 259 ++++- packages/cli/src/repl/sidekick/feedback.ts | 148 ++- packages/cli/src/repl/sidekick/history.ts | 114 ++- packages/cli/src/repl/sidekick/model.ts | 108 ++ packages/cli/src/repl/sidekick/owner.ts | 32 +- packages/cli/src/repl/sidekick/profile.ts | 92 +- packages/cli/src/repl/sidekick/requests.ts | 15 +- .../repl/issue-883/mounted-program.ts | 17 +- .../fixtures/repl/issue-883/recovery-phase.ts | 2 + .../repl/issue-883/sidekick-harness.ts | 3 +- packages/cli/tests/repl-entries.test.ts | 121 +++ .../cli/tests/repl-sidekick-controls.test.ts | 425 +++++++- .../cli/tests/repl-sidekick-journey.test.ts | 313 +++++- .../cli/tests/repl-sidekick-lifecycle.test.ts | 4 + .../cli/tests/repl-sidekick-recovery.test.ts | 326 ++++++ packages/core/deno.json | 3 +- packages/core/host.ts | 31 + packages/core/package.json | 3 +- .../core/src/component-result-destinations.ts | 295 ++++++ packages/core/src/component-result.ts | 91 ++ packages/core/src/components/Json.ts | 29 +- packages/core/src/components/Yaml.ts | 90 ++ .../src/components/component-resolution.ts | 21 + packages/core/src/components/components.md | 17 + .../core/src/components/json-serialization.ts | 40 + packages/core/src/components/registry.ts | 14 + packages/core/src/document-validation.ts | 17 +- packages/core/src/execute.ts | 113 +++ packages/core/src/expand.ts | 209 +++- packages/core/src/generated-xmd.ts | 216 +++- packages/core/src/invocation-rules.ts | 45 + packages/core/src/structural-rules.ts | 3 +- packages/core/src/value-query.ts | 259 +++++ packages/core/src/yq-vendor-notices/LICENSE | 21 + .../yq-vendor-notices/THIRD_PARTY_NOTICES.md | 878 ++++++++++++++++ packages/core/src/yq-wasm.provenance.json | 23 + packages/core/src/yq-wasm.ts | 640 ++++++++++++ .../core/tests/document-validation.test.ts | 28 + .../core/tests/generated-composition.test.ts | 226 ++++- .../core/tests/generated-xmd-root.test.ts | 26 + .../core/tests/host-generated-root.test.ts | 4 +- packages/core/tests/syntax-catalog.test.ts | 43 + packages/core/tests/yaml-component.test.ts | 324 ++++++ packages/core/tests/yq-component.test.ts | 939 ++++++++++++++++++ pnpm-lock.yaml | 10 + scripts/build-npm.ts | 32 +- scripts/generate-yq-wasm.ts | 271 +++++ scripts/lib/compile.ts | 16 + scripts/tests/yq-distribution.test.ts | 464 +++++++++ specs/executable-mdx-spec.md | 108 +- specs/release-process-spec.md | 63 ++ specs/repl-spec.md | 41 + 57 files changed, 7642 insertions(+), 177 deletions(-) create mode 100644 packages/core/src/component-result-destinations.ts create mode 100644 packages/core/src/component-result.ts create mode 100644 packages/core/src/components/Yaml.ts create mode 100644 packages/core/src/components/json-serialization.ts create mode 100644 packages/core/src/value-query.ts create mode 100644 packages/core/src/yq-vendor-notices/LICENSE create mode 100644 packages/core/src/yq-vendor-notices/THIRD_PARTY_NOTICES.md create mode 100644 packages/core/src/yq-wasm.provenance.json create mode 100644 packages/core/src/yq-wasm.ts create mode 100644 packages/core/tests/yaml-component.test.ts create mode 100644 packages/core/tests/yq-component.test.ts create mode 100644 scripts/generate-yq-wasm.ts create mode 100644 scripts/tests/yq-distribution.test.ts diff --git a/architecture.md b/architecture.md index 73e652edb..19a2598a1 100644 --- a/architecture.md +++ b/architecture.md @@ -374,6 +374,90 @@ therefore agree on the ID of every element they both retain, and may share IDs without sharing effects — run identity and workflow-definition identity are what tell those runs apart. +### What an accepted result becomes + +An invocation's result travels a fixed route, and the order is the whole of the +contract: + +```text +form, authored props and genuine destination checks + -> the producer runs once, keeping its own effects and outcomes + -> its own return validation and complete joined teardown + -> returned-value middleware, including `yq` selection + -> selected JSON acceptance + -> the selected capture, and any acknowledged root publication + -> the acknowledged selected presentation for that exact occurrence +``` + +`Component.result` is the one seam between acceptance and binding, published +under the stable name `executablemd.core.component-result`. A handler receives +the accepted result and the query the invocation wrote, and answers with the +value to bind — which is all it can do. By the time it is asked, acceptance has +happened and publication has not, so nothing it returns repairs a return the +producer's own schema rejected, a printed error, a refused producer or a failed +cleanup. Permission, durable identity, which occurrence a result belongs to and +whether an append was acknowledged are each settled by the execution that owns +them; a middleware answer is data. + +The terminal is the engine's own. With no query it answers with the same +reference it was given, so an ordinary invocation binds exactly what it always +did. With one it asks the execution's `yq` engine, which validates the result as +JSON, evaluates the expression and validates the one answer as JSON. Both +canonical paths — a Markdown body and a function component, with or without +`returns` — cross it, because a consumer composing around results composes +around all of them rather than only the queried ones. + +**The engine belongs to the execution and starts when it is wanted.** One lazy +owner per document execution, selected before expansion under the stable name +`executablemd.core.value-query`, shared by that execution's generated roots and +distinct from a concurrent execution's. A document that writes neither `yq` nor +`` decodes and compiles nothing. `until()` does not cancel the vendor's +compilation, so what halting stops is the continuation: a halted first consumer +binds nothing, publishes nothing and appends nothing, and the owner is revoked +with its execution. Every evaluation supplies an empty environment, an empty +file map and a fixed instant, so no expression reads this host's environment, +filesystem or clock. + +### Where an owned result may go + +A host that evaluates generated source on somebody's behalf has a use for a +result a document does not: the Sidekick's reply asked the root to do something, +and the answer has to come back to it. That is a **destination**, and it is not +public result middleware's to answer. + +The host states its destinations on the `ExecutionInstallation` it already hands +over, and canonical execution copies them before any installation, middleware or +document code runs — the terms admissions and declared components already +travel on. Nothing afterwards adds, replaces or reads the collection: it is +reachable through no context, no contextual Api, no stable name and no +definition metadata. + +What an entry names is authenticated rather than spelled. For a component the +host published, the entry carries the exact object it published through its own +`componentAnswers` request, compared by identity against core's own record of +that publication; the row it then routes to is the sealed implementation +canonical capture produced. A look-alike, a copy taken afterwards, a same-named +registration and a definition another execution built are each absent from the +route. For a **selected** protected name — canonical ``, which the host +selects and core's own tier answers — there is no published object to hand over, +so the entry names the selection and core resolves the implementation from its +own capture, refusing a name some provider published. + +A receiver belongs to one occurrence. Canonical invocation opens one before +required-as is decided, binds it to the exact `ComponentInvocation` the engine +minted, and revokes it when that invocation settles. Two same-named controls in +one response are two invocations and therefore two receivers; a receiver kept +from a finished occurrence answers for nothing. Nothing correlates by component +name, by completion order or by whichever occurrence came last. A genuine +execution-owned destination is also the one thing that can satisfy an +already-authorized uncaptured return — a tag name, a returns schema, a `yq` +expression, a public option and a Context value each supply none. + +A generated import is answered with a fresh wrapper per import, because the +admitted form is decided per invocation, so the expansion site cannot see the +implementation underneath it. Canonical resolution says which one it is, at the +moment it produces the answer, by exact object on both sides. + ### Definition-owned return state A value body — a value root, or a Markdown component that declares `returns` — @@ -4066,6 +4150,21 @@ is the binding contract the children actually run under. ``, exact spelling in the retained source, never join the retained named-component list, and change no record version. +Core's always-on composition table holds its own pure components: `` +and ``, each under its own `https://executable.md/components/` identity +and its self-closing spelling alone. `allow` does not select between them — +rendering a value a fragment already holds performs nothing — so a host can +neither remove one by omitting it nor give one an effect by naming it. + +That table is a fact about the build rather than about the policy a host +stated, which is what decides how a retained admission reads. A record written +before a pure component existed holds no row for it, and that record is what its +own continuation is held to: the comparison is against the historical rows, and +so is the table that continuation may *name*. So an older admission is neither +refused for a row its fragment never named nor quietly widened to include one, +while new source is admitted under the current table. A retained composition row +this build no longer supplies is stale and refuses. + A trusted host may add another pure component only by placing its exact definition and stable identity in the composition table captured before execution. It is not inferred to be pure from its name, documentation or @@ -7728,6 +7827,38 @@ question the question an authored document asks, and what keeps a repository, registered or middleware component of the same name from receiving a reply's permission. Its form and its class are its declaration's: paired, and a write. +**A reply may select out of what a control returned, and what comes back is +that selection.** `yq` on a control is the engine's ordinary attribute, so the +route is the ordinary one: the control performs its own work once, records its +own outcome, and the selection happens after that outcome and before the +capture. + +What the *history* gains is a mark and a record. A queried occurrence's intent +carries `presentation: "selected-v1"`, written before the original work by the +occurrence's own receiver — never inferred afterwards from a record and never +supplied in an argument a reply wrote. The selected value is then a separate +closed `control-presentation` record, through the same serialized writer, naming +that exact conversation, response and control order, and appended only after the +original outcome succeeded, the selection was accepted as JSON, and whatever +capture or publication the occurrence owed has happened. Its acknowledged append +is the sole acceptance of a selected presentation. + +So the two states a reader has to tell apart are told apart by the records +themselves. A marked intent with an acknowledged presentation is a selection; +a marked intent with none is an **interrupted** selection, reported as that and +never answered with the observation the producer retained — which is the one +substitution this pair exists to prevent. A refused control keeps refused +feedback whatever a constant expression would have produced, cancellation writes +no successful presentation, and an unmarked record keeps exactly the historical +meaning it had. History refuses an orphan, a duplicate, a wrong occurrence, a +presentation for an operation that did not succeed, and a malformed selected +value. + +A read's own identity, range and continuation stay beside the selected value +rather than inside it: selecting a field out of a window neither reads another +page nor changes the extent the producer observed, and a reply has to be able to +tell those apart. + **What the reply asked for comes back to it, and that is what the next turn is for.** After the response finishes and its scope joins, the designated results go to the same conversation as one turn, in admission order read back out of the @@ -8433,7 +8564,10 @@ Status is measured against main. | `` | Binds rendered content or an exact by-reference value in the existing environment; source choice precedes execution. [Binding](specs/executable-mdx-spec.md#65-prop-validation). | built on the #527 stack | | `` | Renders a supplied string inside a safe fence, preserving its exact value through return and capture. [Forms and validation](specs/executable-mdx-spec.md#619-showing-text-as-a-code-block-codeblock). | built on the #658 stack | | `…` | Renders content only under a true lexical verbosity value; CLI diagnostics remain host presentation. [Verbosity](specs/executable-mdx-spec.md#620-verbose-only-content-verbose). | built on this stack | -| `` | Renders a captured value through native two-space JSON serialization without changing its operand. [Validation, failures and exact capture](specs/executable-mdx-spec.md#612-json-in-both-directions-json-parse-and-safeparse). | built on the #452 stack, with ordinary text capture enabled by #666 | +| `` | Renders a captured value through native two-space JSON serialization without changing its operand. [Validation, failures and exact capture](specs/executable-mdx-spec.md#612-json-in-both-directions-json-yaml-parse-and-safeparse). | built on the #452 stack, with ordinary text capture enabled by #666 | +| `` | Renders a captured value as one complete YAML document — two-space indentation, no separators, one terminating newline — through the same single native JSON serialization `` describes the operand with, then the execution's own engine under the identity expression. Nothing else turns a value into YAML, and scalars stay quoted where their type depends on it so the text parses back to the value that went in. [Forms, failures and exact capture](specs/executable-mdx-spec.md#612-json-in-both-directions-json-yaml-parse-and-safeparse). | built on this stack | +| `yq` | Selects one JSON value out of what an ordinary component returned, before that result becomes a capture. One shared engine-owned invocation attribute, separate from `as` and consumed before the producer's own props are validated; it runs after the producer's own return validation and joined teardown, so no expression repairs a rejected return, a refused producer or a failed cleanup. One value or a refusal — `null`, `false`, `[]` and a multiline string are values, while no match and several matches both refuse with the array guidance. [Authored contract](specs/executable-mdx-spec.md#621-selecting-out-of-a-result-yq) and [the seam](#what-an-accepted-result-becomes). | built on this stack | +| owned result destinations | Where a trusted host's own component results go, for the components it published or the protected name it selected. Stated on the `ExecutionInstallation`, copied before any installation runs, authenticated by exact object against this execution's own publication record, and opened per canonical occurrence. [Invariant](#where-an-owned-result-may-go). | built on this stack | | root failure settlement | a text root installs the fail-capable `output` mode for its whole body, so an uncaught, undecided failure is the document execution's own outcome, whether or not the root declares `` [Invariant](#3-error-mode-is-lexical). | built on the #453 stack | | `` region `output` mode | an undecided error fails the document execution [Invariant](#3-error-mode-is-lexical). | built on main | | `` rendering selection | chooses which regions of a body render, and buffers a root that declares one; it decides nothing about failure [Interface and evidence](specs/executable-mdx-spec.md#69-component-declared-output-output). | built on main | diff --git a/deno.json b/deno.json index 292fd4016..ac3481836 100644 --- a/deno.json +++ b/deno.json @@ -49,7 +49,9 @@ "typescript": "npm:typescript@^5.0.0", "unist-util-select": "npm:unist-util-select@^5", "zod": "npm:zod@^4.3.6", - "mdast-util-to-string": "npm:mdast-util-to-string@^4" + "mdast-util-to-string": "npm:mdast-util-to-string@^4", + "yq.rs/loader": "npm:yq.rs@0.1.0/loader", + "yq.rs/yq.wasm": "npm:yq.rs@0.1.0/yq.wasm" }, "tasks": { "xmd": "deno run --allow-all packages/cli/src/deno.ts", diff --git a/deno.lock b/deno.lock index 011bf7f1a..5c0aefe10 100644 --- a/deno.lock +++ b/deno.lock @@ -115,6 +115,7 @@ "npm:unist-util-select@5": "5.1.0", "npm:vite@^7.1.3": "7.3.6_@types+node@24.13.3_tsx@4.23.1", "npm:vite@^7.1.4": "7.3.6_@types+node@24.13.3_tsx@4.23.1", + "npm:yq.rs@0.1.0": "0.1.0", "npm:zod@4": "4.6.6", "npm:zod@^4.3.6": "4.6.6" }, @@ -4301,6 +4302,10 @@ "yargs-parser" ] }, + "yq.rs@0.1.0": { + "integrity": "sha512-on2F3W24SipMbxPDgbEZnpxC2bll6Zssc8b3hFupcuF/AcGtLZZm+qPfekhTZIBbWmZjL/XL/uq5oIioZBODww==", + "bin": true + }, "zod@4.6.6": { "integrity": "sha512-4UmzQUF5fxvfcYHlbjBmejU+w+hbDnWFx4aS8kBx7nPBHcO2SqPbpAG8snbdg+Xse4pRefR98hgjFgIMCI/UhA==" }, @@ -4339,6 +4344,7 @@ "npm:semver@^7.8.5", "npm:typescript@5", "npm:unist-util-select@5", + "npm:yq.rs@0.1.0", "npm:zod@^4.3.6" ], "packageJson": { @@ -4438,6 +4444,7 @@ "npm:remark@15", "npm:remend@^1.2.2", "npm:unist-util-select@5", + "npm:yq.rs@0.1.0", "npm:zod@^4.3.6" ], "packageJson": { @@ -4465,7 +4472,8 @@ "npm:mdast-util-to-string@4", "npm:remark@15", "npm:remend@^1.2.2", - "npm:unist-util-select@5" + "npm:unist-util-select@5", + "npm:yq.rs@0.1.0" ] } }, diff --git a/packages/cli/src/repl/program.ts b/packages/cli/src/repl/program.ts index f9fc27037..3d3b7fa69 100644 --- a/packages/cli/src/repl/program.ts +++ b/packages/cli/src/repl/program.ts @@ -1048,8 +1048,9 @@ function* drive( return Ok(established); }, root: sidekickRoot, - submit(at, journal): Operation> { + submit(at, journal, presenting): Operation> { return submitForSidekick(at, { + presenting, session: { // The whole acknowledged history, read at the moment the // reservation asks for it. `current.model` is the projection of diff --git a/packages/cli/src/repl/sidekick/admission.ts b/packages/cli/src/repl/sidekick/admission.ts index a2f07319f..b3fec4f25 100644 --- a/packages/cli/src/repl/sidekick/admission.ts +++ b/packages/cli/src/repl/sidekick/admission.ts @@ -58,7 +58,7 @@ import { bindRetainedPrefix, failedOutcome, measureRetainedPrefix } from "./hist import type { SidekickRecord, SidekickWriter } from "./history.ts"; import { projectSidekick } from "./model.ts"; import type { SidekickSubmitIntent } from "./model.ts"; -import type { ControlJournal, SubmitReceipt } from "./controls.ts"; +import type { ControlJournal, SidekickOccurrence, SubmitReceipt } from "./controls.ts"; import type { ReplSubmission, StartingCheck } from "../session.ts"; /** @@ -216,9 +216,18 @@ export function* submitForSidekick( readonly writer: EntryJournal; /** Tell the loop something happened, so it applies the report. */ readonly woke: () => void; + /** + * This occurrence's own receiver, when the reply queried the receipt. + * + * Submit's intent binds the reservation this takes, so this is the one + * place that can mark it — and it marks exactly one intent. The position it + * took is filed with the receiver only after the entry reached its own + * outcome, which is what the destination then presents against. + */ + readonly presenting: SidekickOccurrence | undefined; }, ): Operation> { - const { session, facts, held, journal, writer, woke } = options; + const { session, facts, held, journal, writer, woke, presenting } = options; // The session's own terms first, before anything is written and before // anything is waited for. A session that is ending, is running an entry, or // follows an entry that never settled refuses — and it has to refuse *here*, @@ -297,6 +306,7 @@ export function* submitForSidekick( revision: reservation.revision, retained, }, + presenting?.query === undefined ? undefined : "selected-v1", ); const submitted = yield* session.submit(reservation.source, () => @@ -338,6 +348,11 @@ export function* submitForSidekick( read: { entry: submission.entry }, }; yield* journal.settled(order, outcome.ok ? Ok(undefined) : Err(outcome.error), receipt.status); + // Filed after the entry's own outcome, against the one intent this + // submission wrote. A submission whose entry ran and failed still produced + // that entry's receipt, so its selection is of an answer rather than of a + // refusal. + presenting?.file(order); return Ok(receipt); } @@ -367,7 +382,7 @@ export function controlJournal( ): ControlJournal { let next = from; return { - *began(occurrence, reserved): Operation { + *began(occurrence, reserved, presentation): Operation { const order = next; next += 1; yield* writer.append({ @@ -378,6 +393,7 @@ export function controlJournal( component: occurrence.component, arguments: occurrence.arguments, ...(reserved === undefined ? {} : { submit: reserved }), + ...(presentation === undefined ? {} : { presentation }), }); return order; }, @@ -391,6 +407,18 @@ export function controlJournal( ...(observed === undefined ? {} : { observed }), }); }, + *presented(order, selected, read): Operation { + yield* writer.append({ + kind: "control-presentation", + conversation: at.conversation, + response: at.response, + order, + version: 1, + outcome: selected.ok ? { status: "ok" } : failedOutcome(selected.error), + ...(selected.ok ? { selected: selected.value } : {}), + ...(selected.ok && read !== undefined ? { read } : {}), + }); + }, }; } diff --git a/packages/cli/src/repl/sidekick/controls.ts b/packages/cli/src/repl/sidekick/controls.ts index 329d25531..e46f0a099 100644 --- a/packages/cli/src/repl/sidekick/controls.ts +++ b/packages/cli/src/repl/sidekick/controls.ts @@ -47,10 +47,16 @@ * installs is where its pair is written. See `questions.ts`. */ -import { Ok } from "effection"; +import { Err, Ok } from "effection"; import type { Operation, Result } from "effection"; import { content } from "@executablemd/core"; -import type { InvocationForm } from "@executablemd/core"; +import type { ComponentInvocation, InvocationForm } from "@executablemd/core"; +import type { + ResultDestination, + ResultDestinationEntry, + ResultOccurrence, + ResultOccurrenceLookup, +} from "@executablemd/core/host"; import type { FunctionComponentDefinition, GeneratedEffect, @@ -125,8 +131,16 @@ export interface SidekickRequests { environment(): Operation>; /** Fill the shared draft with exactly this source. Moves no focus. */ fillDraft(source: string): Operation>; - /** Admit the draft and wait for the exact admitted entry to finish. */ - submit(): Operation>; + /** + * Admit the draft and wait for the exact admitted entry to finish. + * + * `presenting` is this occurrence's own receiver, when it queried. Submit's + * intent binds the reservation the root took, so the root writes that pair — + * which is why the mode arrives here rather than being written by the wrapper + * out in this module. The root marks that one intent and files the position + * it took; nothing adds a second intent or a second reservation. + */ + submit(presenting: SidekickOccurrence | undefined): Operation>; /** Read one window of one entry's observed output. */ entryOutput(request: OutputReadRequest): Operation>; } @@ -173,9 +187,31 @@ export interface ControlJournal { * from — has to be on disk before the slot is acted on. Every other control * answers a question about state that is already there, so there is nothing * for it to bind. + * + * `presentation` is the mode this occurrence's result will be presented in, + * and it is written here — before the original work — because the whole point + * of marking is that a reader of an interrupted conversation can tell a + * selection that never completed from an ordinary outcome. It comes from the + * occurrence's own receiver rather than from an argument a reply wrote, and + * an occurrence that queried nothing is unmarked exactly as it always was. */ - began(occurrence: ControlOccurrence, reserved?: ReservedSlot): Operation; + began( + occurrence: ControlOccurrence, + reserved?: ReservedSlot, + presentation?: "selected-v1", + ): Operation; settled(order: number, outcome: Result, observed?: Json): Operation; + /** + * Record what this occurrence's result was selected down to. + * + * A record of its own, appended after the original outcome and after whatever + * capture or publication the occurrence owed — so its presence is proof the + * whole route completed and its absence beside a marked intent is proof the + * route was interrupted. `read` is the original observation's own identity, + * range and continuation, kept beside the selected value rather than inside + * it. + */ + presented(order: number, selected: Result, read?: Json): Operation; } /** The entry slot a Submit intent binds, so a dead process can be reconciled. */ @@ -278,6 +314,14 @@ export interface SidekickControl { * row rather than quietly leaving a reply under-told. */ readonly props?: readonly string[]; + /** + * Whether this conversation selects the name rather than answering for it. + * + * True for a protected component: canonical resolution answers it from core's + * own tier, so there is no definition here to publish and its destination is + * named by the selection instead. + */ + readonly selected?: boolean; } /** @@ -331,27 +375,151 @@ function offering(key: string, form: InvocationForm, effect: GeneratedEffect): G return offered; } +/** + * What one queried occurrence of an owned control shares with its destination. + * + * Two halves of one piece of bookkeeping that meet at different moments. The + * control's own body knows which journal position it took and what read context + * its observation carried, while it is running; the destination is what is left + * to receive the selected value afterwards. Neither knows the other's half, so + * they share this — filed by the body, read by the destination, and reached by + * the exact occurrence object the engine minted rather than by a name, a count + * or whichever occurrence came last. + */ +interface Filed { + order: number | undefined; + read: Json | undefined; +} + +/** The occurrence one control body is in, as that body sees it. */ +export interface SidekickOccurrence { + /** The expression this occurrence selects with, when it selects. */ + readonly query: string | undefined; + /** Record the journal position this occurrence took, and its read context. */ + file(order: number, read?: Json): void; +} + +/** + * This conversation's own destinations, and the occurrences behind them. + * + * One of these per conversation, beside the controls it owns. What it holds is + * per-occurrence and weak: a receiver's lifetime is its occurrence's, and + * nothing here keeps one alive or reachable after the invocation that opened it + * has settled. + */ +export interface SidekickDestinations { + /** The entry one owned definition is routed through. */ + entry(definition: FunctionComponentDefinition): ResultDestinationEntry; + /** The entry one selected protected name is routed through. */ + selected(name: string): ResultDestinationEntry; + /** Take the lookup canonical execution hands this host at installation. */ + installed(lookup: ResultOccurrenceLookup): void; + /** The occurrence this invocation is in, when it is an owned queried one. */ + of(invocation: ComponentInvocation): SidekickOccurrence | undefined; +} + +/** + * Build this conversation's destinations over its own control journal. + * + * The journal is the response-routing one the ceiling already writes through, + * so a selected presentation is filed by the same serialized writer, under the + * same response, as the intent and the outcome it belongs to. + */ +export function sidekickDestinations(journal: ControlJournal): SidekickDestinations { + const filed = new WeakMap(); + let lookup: ResultOccurrenceLookup | undefined; + return { + entry(definition: FunctionComponentDefinition): ResultDestinationEntry { + return { definition, open: (query) => opened(query) }; + }, + selected(name: string): ResultDestinationEntry { + return { selected: name, open: (query) => opened(query) }; + }, + installed(taken: ResultOccurrenceLookup): void { + lookup = taken; + }, + of(invocation: ComponentInvocation): SidekickOccurrence | undefined { + const occurrence = lookup?.(invocation); + if (occurrence === undefined) { + return undefined; + } + const held = filed.get(occurrence); + if (held === undefined) { + return undefined; + } + return { + query: occurrence.query, + file(order: number, read?: Json): void { + held.order = order; + held.read = read; + }, + }; + }, + }; + + /** One occurrence's destination, which is the same for every control. */ + function opened(query: string | undefined): ResultDestination { + const held: Filed = { order: undefined, read: undefined }; + return { + *accept(selected: unknown): Operation { + const order = held.order; + if (order === undefined || query === undefined) { + // An occurrence whose body filed nothing recorded no intent to + // present, so there is nothing for a presentation to belong to — a + // refused original outcome and an unqueried occurrence both land + // here, and both keep the feedback they already had. + return; + } + yield* journal.presented(order, Ok(parseSelected(selected)), held.read); + }, + serves(occurrence: ResultOccurrence): void { + filed.set(occurrence, held); + }, + }; + } +} + +/** + * The selected value, as the record retains it. + * + * Parsed rather than asserted: what reaches a destination is whatever the + * engine's own JSON acceptance produced, and the record is JSON, so a value + * outside that domain is a failure of this presentation rather than something + * written down as if it were data. + */ +function parseSelected(selected: unknown): Json { + return JSON.parse(JSON.stringify(selected ?? null)); +} + /** * Run one control's work, recording the intent before and the outcome after. * * The outcome crosses as a `Result` and the *rendered* value is what the * element becomes. A refusal renders its reason, so a reply reads why its * operation did not happen in the place it asked for it. + * + * A queried occurrence is marked here, before the work, from its own receiver — + * and the position it took is filed where its destination will find it. An + * occurrence that queried nothing is unmarked and files nothing, so its + * feedback stays exactly the ordinary observation it always was. */ function* performed( journal: ControlJournal, + mine: SidekickOccurrence | undefined, occurrence: ControlOccurrence, work: () => Operation>, render: (value: T) => string, observed?: (value: T) => Json, + context?: (value: T) => Json | undefined, ): Operation { - const order = yield* journal.began(occurrence); + const selecting = mine?.query !== undefined; + const order = yield* journal.began(occurrence, undefined, selecting ? "selected-v1" : undefined); let answer: Result; try { answer = yield* work(); } catch (error) { const failure = error instanceof Error ? error : new Error(String(error)); - yield* journal.settled(order, { ok: false, error: failure } as Result); + yield* journal.settled(order, Err(failure)); throw failure; } yield* journal.settled( @@ -359,6 +527,12 @@ function* performed( answer, answer.ok && observed !== undefined ? observed(answer.value) : undefined, ); + if (selecting && answer.ok) { + // Filed only for a successful original outcome: a refused control keeps + // refused feedback, and a presentation for it would promote a refusal into + // an answer. + mine?.file(order, context === undefined ? undefined : context(answer.value)); + } return answer.ok ? render(answer.value) : answer.error.message; } @@ -399,15 +573,17 @@ function* delegated( export function sidekickObservations( requests: SidekickRequests, journal: ControlJournal, + destinations: SidekickDestinations, ): SidekickControl[] { const observations: SidekickControl[] = [ reading("REPL.Bindings", "Bindings", { kind: "function", name: "REPL.Bindings", props: NO_PROPS, - *fn(): Operation { + *fn(_props: Json, invocation: ComponentInvocation): Operation { return yield* performed( journal, + destinations.of(invocation), { component: "REPL.Bindings", arguments: {} }, () => requests.bindings(), // The detached map, as JSON a reply reads rather than as prose about @@ -426,10 +602,14 @@ export function sidekickObservations( // comma-separated string would have been a third spelling nothing else // in the language uses. props: SYNTAX_NAMES_PROPS, - *fn(props: { names?: readonly string[] }): Operation { + *fn( + props: { names?: readonly string[] }, + invocation: ComponentInvocation, + ): Operation { const names = props.names; return yield* performed( journal, + destinations.of(invocation), { component: "REPL.Syntax", arguments: names === undefined ? {} : { names: [...names] }, @@ -444,9 +624,10 @@ export function sidekickObservations( kind: "function", name: "REPL.Environment", props: NO_PROPS, - *fn(): Operation { + *fn(_props: Json, invocation: ComponentInvocation): Operation { return yield* performed( journal, + destinations.of(invocation), { component: "REPL.Environment", arguments: {} }, () => requests.environment(), (value) => value, @@ -470,13 +651,19 @@ export function sidekickObservations( }, additionalProperties: false, }, - *fn(props: OutputReadRequest): Operation { + *fn(props: OutputReadRequest, invocation: ComponentInvocation): Operation { return yield* performed( journal, - { component: "REPL.EntryOutput", arguments: { ...props } as Json }, + destinations.of(invocation), + { component: "REPL.EntryOutput", arguments: { ...props } }, () => requests.entryOutput(props), renderRead, - (value) => ({ ...value }) as unknown as Json, + (value) => readObservation(value), + // The read's own identity, range and continuation, kept beside a + // selected value rather than inside it: selecting a field out of a + // window neither reads another page nor changes the extent the + // producer actually observed. + (value) => readContext(value), ); }, }), @@ -488,9 +675,10 @@ export function sidekickObservations( kind: "function", name, props: NO_PROPS, - *fn(): Operation { + *fn(_props: Json, invocation: ComponentInvocation): Operation { return yield* performed( journal, + destinations.of(invocation), { component: name, arguments: {} }, () => requests.guide(chapter), // Literal Markdown, returned as it is written. Nothing in a guide @@ -524,19 +712,21 @@ export function sidekickObservations( export function sidekickMutations( requests: SidekickRequests, journal: ControlJournal, + destinations: SidekickDestinations, ): SidekickControl[] { return [ writing("REPL.EntryInput", "EntryInput", "paired", { kind: "function", name: "REPL.EntryInput", props: NO_PROPS, - *fn(): Operation { + *fn(_props: Json, invocation: ComponentInvocation): Operation { // The rendered content, once. It is entry source — not response // syntax — so it is handed over as the literal string it is and // never re-expanded. const source = String(yield* content()); return yield* performed( journal, + destinations.of(invocation), { component: "REPL.EntryInput", arguments: { source } }, () => requests.fillDraft(source), // The acknowledgement, not the program. A reply that was handed its @@ -549,11 +739,12 @@ export function sidekickMutations( kind: "function", name: "REPL.Submit", props: NO_PROPS, - *fn(): Operation { + *fn(_props: Json, invocation: ComponentInvocation): Operation { // Unjournaled here on purpose; see {@link delegated}. The root writes // this control's pair, because the intent binds the slot the root - // took and nothing out here knows what that is yet. - return yield* delegated(() => requests.submit(), renderReceipt); + // took and nothing out here knows what that is yet — and for the same + // reason the root is what marks it, from the receiver handed over here. + return yield* delegated(() => requests.submit(destinations.of(invocation)), renderReceipt); }, }), // Core's own ``, admitted paired — and with **no definition of its @@ -572,7 +763,7 @@ export function sidekickMutations( // // Its answer still becomes feedback. The pair is written by the provider // the owner installs rather than by `performed()` here; see `questions.ts`. - { name: ELICIT_CONTROL, form: "paired", effect: "write", props: ["schema"] }, + { name: ELICIT_CONTROL, form: "paired", effect: "write", props: ["schema"], selected: true }, ]; } @@ -628,6 +819,36 @@ export function renderRead(held: OutputRead): string { return lines.join("\n"); } +/** One read's complete observation, as the outcome retains it. */ +function readObservation(held: OutputRead): Json { + return { + entry: held.entry, + status: held.status, + offset: held.offset, + length: held.length, + text: held.text, + ...(held.next === undefined ? {} : { next: { ...held.next } }), + }; +} + +/** + * One read's identity, range and continuation, without its text. + * + * What a reply needs beside a selected value: which entry it read, how much of + * it the producer actually observed, and whether there is more. The text is + * deliberately absent — a selection replaced it, and carrying both would make + * the window and the selection two accounts of one read. + */ +function readContext(held: OutputRead): Json { + return { + entry: held.entry, + status: held.status, + offset: held.offset, + length: held.length, + ...(held.next === undefined ? {} : { next: { ...held.next } }), + }; +} + /** The longest run of one character, so a fence can be longer than it. */ function longestRun(text: string, character: string): number { let longest = 0; diff --git a/packages/cli/src/repl/sidekick/feedback.ts b/packages/cli/src/repl/sidekick/feedback.ts index 8a1d66f46..761580556 100644 --- a/packages/cli/src/repl/sidekick/feedback.ts +++ b/packages/cli/src/repl/sidekick/feedback.ts @@ -37,7 +37,7 @@ import { Err, Ok } from "effection"; import type { Operation, Result } from "effection"; import { DESIGNATED, DRAFT_FILLED, renderRead, renderReceipt } from "./controls.ts"; -import type { ControlOutcomeRecord, ControlRecord } from "./history.ts"; +import type { ControlOutcomeRecord, ControlPresentationRecord, ControlRecord } from "./history.ts"; import type { OutputRead } from "./output.ts"; import { describeGuideIndex, readSidekickBootstrap, sidekickGuideIndex } from "./guide.ts"; import { fingerprint } from "./history.ts"; @@ -206,7 +206,7 @@ export interface DesignatedResult { * Decided from the retained facts rather than from the text, because the text * is what this decision chooses the wording of. */ - readonly kind: "answered" | "refused"; + readonly kind: "answered" | "refused" | "incomplete"; /** The answer itself, or the reason — the text, with nothing wrapped round it. */ readonly text: string; /** @@ -218,6 +218,15 @@ export interface DesignatedResult { * fence whatever happened to look like JSON. */ readonly json: boolean; + /** + * The read context a selected presentation kept beside its value. + * + * Present only for a queried read whose original observation carried one. + * Stated beside the selected payload rather than merged into it: selecting a + * field out of a window neither reads another page nor changes the extent the + * producer observed. + */ + readonly read?: string; } /** @@ -246,6 +255,17 @@ export function designatedResults( }[] = [], ): readonly DesignatedResult[] { const intents = new Map(); + /** The acknowledged selected presentation each occurrence has, if any. */ + const presentations = new Map(); + for (const record of records) { + if ( + record.kind === "control-presentation" && + record.conversation === at.conversation && + record.response === at.response + ) { + presentations.set(record.order, record); + } + } const results: DesignatedResult[] = refused // Through the same set, so a control that is not designated does not get // its refusals delivered either. One set decides what comes back. @@ -274,7 +294,12 @@ export function designatedResults( if (intent === undefined || !DESIGNATED.has(intent.component)) { continue; } - results.push({ order: record.order, ...answered(intent, record) }); + results.push({ + order: record.order, + ...(intent.presentation === "selected-v1" + ? presented(intent, record, presentations.get(record.order)) + : answered(intent, record)), + }); } // Stable, so a refusal and the pair that followed it keep the order they // happened in: the refusal was pushed first and holds the order that pair @@ -311,12 +336,7 @@ export function recoveredWork( items.push({ order: result.order, component: result.component, - body: - result.kind === "answered" - ? result.json - ? fenced(result.text) - : result.text - : `${refusal(result.component)}: ${result.text}`, + body: labelled(result), }); } for (const waiting of unanswered(records, at)) { @@ -390,6 +410,64 @@ function asking(intent: ControlRecord): string { ); } +/** + * What one *queried* operation answered, which is only ever its acknowledged + * selected presentation. + * + * A marked occurrence has one source of feedback and no fallback. An + * acknowledged presentation is the selected value, as the JSON it is, with the + * read context the original observation carried stated beside it rather than + * inside it. A recorded selection failure is a failure of the selection and + * says so. And a marked intent with no presentation at all is an **interrupted + * selection**: the original work may well have happened, and what must not + * happen is answering with the observation the producer retained — the reply + * asked for a selection, and sending it the whole thing instead is the one + * substitution this protocol exists to prevent. + */ +function presented( + intent: ControlRecord, + record: ControlOutcomeRecord, + presentation: ControlPresentationRecord | undefined, +): Omit { + const component = intent.component; + if (record.outcome.status !== "ok") { + // The original outcome stands. A refused control keeps refused feedback, + // whatever a selection would have produced from a constant. + return { component, kind: "refused", text: record.outcome.error.message, json: false }; + } + if (presentation === undefined) { + return { + component, + kind: "incomplete", + text: + "This operation completed and its selected result was never recorded, so what it " + + "selected is not known. Nothing of it will be repeated.", + json: false, + }; + } + if (presentation.outcome.status !== "ok") { + return { + component, + kind: "refused", + text: `its yq expression did not select one value: ${presentation.outcome.error.message}`, + json: false, + }; + } + const selected = JSON.stringify(presentation.selected ?? null, null, 2); + if (presentation.read === undefined) { + return { component, kind: "answered", text: selected, json: true }; + } + return { + component, + kind: "answered", + // The range outside the payload, so a reply can tell what it selected from + // how much the producer actually observed. + text: selected, + json: true, + read: JSON.stringify(presentation.read, null, 2), + }; +} + /** * What one retained operation answered, in the words the reply is told it in. * @@ -524,20 +602,11 @@ export function sealedFeedback( // One answer to one question, with nothing round it — not even a fence // around a JSON value, because the whole message is that value and a // reply can parse it as it stands. - parts.push(only.kind === "answered" ? only.text : `${refusal(only.component)}: ${only.text}`); + parts.push(sole(only)); } } else { for (const result of results) { - const body = - result.kind === "answered" - ? result.json - ? // Fenced, because this one is sitting among other things now and a - // reply has to know where the value ends. Longer than any run inside - // it, since a published string may hold a fence of its own. - fenced(result.text) - : result.text - : `${refusal(result.component)}: ${result.text}`; - parts.push(`## ${result.component}\n\n${body}`); + parts.push(`## ${result.component}\n\n${labelled(result)}`); } } if (failure !== undefined) { @@ -549,6 +618,45 @@ export function sealedFeedback( return parts.join("\n\n"); } +/** + * One result alone, with nothing round it. + * + * The reply asked one question and this is the answer, so a JSON value is not + * even fenced: the whole message is that value and a reply can parse it as it + * stands. A read context is the one thing that still needs saying, because it + * is a second fact about the same read. + */ +function sole(result: DesignatedResult): string { + if (result.kind === "refused") { + return `${refusal(result.component)}: ${result.text}`; + } + if (result.kind === "incomplete") { + return result.text; + } + return result.read === undefined + ? result.text + : [result.text, `What that was selected from:`, fenced(result.read)].join("\n\n"); +} + +/** One result among others, under its own heading. */ +function labelled(result: DesignatedResult): string { + if (result.kind === "refused") { + return `${refusal(result.component)}: ${result.text}`; + } + if (result.kind === "incomplete") { + return result.text; + } + const body = result.json + ? // Fenced, because this one is sitting among other things now and a reply + // has to know where the value ends. Longer than any run inside it, since + // a published string may hold a fence of its own. + fenced(result.text) + : result.text; + return result.read === undefined + ? body + : [body, "What that was selected from:", fenced(result.read)].join("\n\n"); +} + /** * How one control's failure is introduced. * diff --git a/packages/cli/src/repl/sidekick/history.ts b/packages/cli/src/repl/sidekick/history.ts index 2d58404e7..44a48f3cd 100644 --- a/packages/cli/src/repl/sidekick/history.ts +++ b/packages/cli/src/repl/sidekick/history.ts @@ -148,6 +148,7 @@ export type SidekickRecord = | ResponseRecord | ControlRecord | ControlOutcomeRecord + | ControlPresentationRecord | FeedbackRecord; /** Ownership: which execution this history belongs to, and what it came from. */ @@ -280,6 +281,18 @@ export interface ControlRecord { readonly order: number; readonly component: string; readonly arguments: unknown; + /** + * How this occurrence's result will be presented, when the reply queried it. + * + * Written here, before the original work, by the receiver the response owns — + * never inferred afterwards from a record, and never supplied in an argument + * a reply wrote. An occurrence marked this way is one whose feedback comes + * from an acknowledged `control-presentation` and from nowhere else, so an + * interrupted selection reads as incomplete rather than falling back to the + * observation the producer happened to retain. An unmarked record keeps the + * historical meaning it already had. + */ + readonly presentation?: "selected-v1"; /** Submit alone binds the slot it reserved, so a crash can be reconciled. */ readonly submit?: { /** @@ -311,6 +324,45 @@ export interface ControlOutcomeRecord { readonly observed?: unknown; } +/** + * What one queried occurrence's result was selected down to. + * + * A record of its own rather than a member of the outcome, because the two say + * different things and are acknowledged at different moments. The outcome is + * the producer's own: what the control did, exactly as it always was. This is + * what the reply is told, and it exists only once the original work succeeded, + * the selection was accepted as JSON and whatever capture or publication the + * occurrence owed has happened — so a presentation in the file is proof the + * whole route completed, and its absence beside a marked intent is proof the + * route was interrupted. + * + * It names the exact occurrence — this conversation, this response, this + * control order — because a selected value belongs to one invocation. Two + * same-named controls in one response select different things, and a record + * correlated by component name or by completion order would hand one of them + * the other's answer. + * + * `read` is the original observation's own identity, range and continuation, + * kept beside the selected value rather than inside it: selecting a field out + * of a window neither reads another page nor changes the extent the producer + * actually observed, and a reply has to be able to tell those apart. + */ +export interface ControlPresentationRecord { + readonly kind: "control-presentation"; + readonly conversation: string; + readonly response: string; + /** The intent this presents, by the order that intent was written under. */ + readonly order: number; + /** The one shape this record has; any other value is a shape this build lacks. */ + readonly version: 1; + /** Whether the selection was accepted, in the repository's own encoding. */ + readonly outcome: RetainedOutcome; + /** The selected JSON value, present exactly when the outcome succeeded. */ + readonly selected?: unknown; + /** The read context the original observation carried, when it carried one. */ + readonly read?: unknown; +} + /** * The ordered operation facts one next turn was given, and that turn's identity. * @@ -399,6 +451,8 @@ export function parseSidekickRecord(line: string): SidekickRecord | undefined { return control(value); case "control-outcome": return controlOutcome(value); + case "control-presentation": + return controlPresentation(value); case "feedback": return feedback(value); default: @@ -668,11 +722,16 @@ function control(value: Record): ControlRecord | undefined { !exactly( value, ["kind", "conversation", "response", "order", "component", "arguments"], - ["submit"], + ["submit", "presentation"], ) ) { return undefined; } + // One spelling, or none. A marker this build does not have is a record this + // grammar does not have, rather than an occurrence read as unqueried. + if (Object.hasOwn(value, "presentation") && value.presentation !== "selected-v1") { + return undefined; + } const held = str(value.conversation); const named = str(value.response); const order = whole(value.order); @@ -716,6 +775,59 @@ function control(value: Record): ControlRecord | undefined { component, arguments: value.arguments, ...(submit === undefined ? {} : { submit }), + ...(Object.hasOwn(value, "presentation") ? { presentation: "selected-v1" as const } : {}), + }; +} + +/** + * One selected presentation, read as the closed shape it is. + * + * A successful one carries its value and no reason; a failed one carries its + * reason and no value. Both arms together, or either member on the wrong arm, + * is a record this grammar does not have — so a history cannot hold a + * presentation that both answered and did not. + */ +function controlPresentation( + value: Record, +): ControlPresentationRecord | undefined { + if ( + !exactly( + value, + ["kind", "conversation", "response", "order", "version", "outcome"], + ["selected", "read"], + ) + ) { + return undefined; + } + const held = str(value.conversation); + const named = str(value.response); + const order = whole(value.order); + const outcome = outcomeOf(value.outcome); + if ( + held === undefined || + named === undefined || + order === undefined || + outcome === undefined || + value.version !== 1 + ) { + return undefined; + } + const succeeded = outcome.status === "ok"; + if (succeeded !== Object.hasOwn(value, "selected")) { + return undefined; + } + if (!succeeded && Object.hasOwn(value, "read")) { + return undefined; + } + return { + kind: "control-presentation", + conversation: held, + response: named, + order, + version: 1, + outcome, + ...(Object.hasOwn(value, "selected") ? { selected: value.selected } : {}), + ...(Object.hasOwn(value, "read") ? { read: value.read } : {}), }; } diff --git a/packages/cli/src/repl/sidekick/model.ts b/packages/cli/src/repl/sidekick/model.ts index 3fa2b234c..216ba6b0f 100644 --- a/packages/cli/src/repl/sidekick/model.ts +++ b/packages/cli/src/repl/sidekick/model.ts @@ -40,6 +40,7 @@ import { parseDurableEvent } from "@executablemd/durable-streams"; import type { ConversationRecord, + ControlPresentationRecord, ControlRecord, ResponseRecord, RetainedPrefix, @@ -316,6 +317,21 @@ export interface SidekickOperation { */ readonly status: "ok" | "failed" | "unfinished"; readonly failure: string | undefined; + /** + * How this occurrence's result is presented, when its own intent marked one. + * + * Absent for every occurrence that was never queried, which is what keeps an + * unmarked history reading exactly as it did. `selected` means an + * acknowledged presentation holds the value; `refused` means the selection + * was recorded as having failed; `incomplete` means the intent was marked and + * no presentation was ever acknowledged — an interrupted selection, which is + * reported as itself and never substituted with the producer's observation. + */ + readonly presentation?: "selected" | "refused" | "incomplete"; + /** The selected JSON value an acknowledged presentation holds. */ + readonly selected?: unknown; + /** The read context that presentation kept beside the selected value. */ + readonly read?: unknown; } /** A Submit whose reservation the entry journal still has to be asked about. */ @@ -929,6 +945,8 @@ export function projectSidekick(records: readonly SidekickRecord[]): Result(); const operations: SidekickOperation[] = []; const settled = new Set(); + /** Each acknowledged selected presentation, by the occurrence it names. */ + const presented = new Map(); let preferences: SidekickPreferences | undefined; const delivered = new Map(); const unestablished: { conversation: string; turn: number | null }[] = []; @@ -1178,6 +1196,62 @@ export function projectSidekick(records: readonly SidekickRecord[]): Result + held.conversation === record.conversation && + held.response === record.response && + held.order === record.order, + ); + if (owning?.status !== "ok") { + return Err( + new SidekickProjectionError( + `this chat history records a selected result for an operation that did not ` + + `succeed (record ${position}).`, + ), + ); + } + presented.set(key, record); + break; + } case "feedback": if (record.turn === null) { // Feedback text retained before its turn: composed for that response @@ -1243,6 +1317,37 @@ export function projectSidekick(records: readonly SidekickRecord[]): Result { + const intent = intents.get(slot(held.conversation, held.response, held.order)); + if (intent?.record.presentation !== "selected-v1") { + return held; + } + const presentation = presented.get(slot(held.conversation, held.response, held.order)); + if (presentation === undefined) { + return { ...held, presentation: "incomplete" as const }; + } + if (presentation.outcome.status !== "ok") { + return { + ...held, + presentation: "refused" as const, + failure: presentation.outcome.error.message, + }; + } + return { + ...held, + presentation: "selected" as const, + selected: presentation.selected, + ...(Object.hasOwn(presentation, "read") ? { read: presentation.read } : {}), + }; + }); + operations.length = 0; + operations.push(...settledOperations); + // Intents with no outcome, in the order they were written. These are the // operations an explicit continuation has to account for, and the reason the // family is two records. @@ -1258,6 +1363,9 @@ export function projectSidekick(records: readonly SidekickRecord[]): Result left.order - right.order); diff --git a/packages/cli/src/repl/sidekick/owner.ts b/packages/cli/src/repl/sidekick/owner.ts index 86e1a4ae2..69954dbb5 100644 --- a/packages/cli/src/repl/sidekick/owner.ts +++ b/packages/cli/src/repl/sidekick/owner.ts @@ -104,7 +104,7 @@ import { } from "./profile.ts"; import { sidekickRequests } from "./requests.ts"; import type { RootReading } from "./requests.ts"; -import type { ControlJournal, SubmitReceipt } from "./controls.ts"; +import type { ControlJournal, SidekickOccurrence, SubmitReceipt } from "./controls.ts"; import { useSidekickQuestions } from "./questions.ts"; import type { ReplElicitations } from "../elicitation.ts"; import { @@ -360,7 +360,11 @@ export interface SidekickOwnerInput { * Handed in rather than performed here: a submission binds a reservation the * root owns the slot for, and this owner owns a conversation. */ - submit(at: ResponseAt, journal: ControlJournal): Operation>; + submit( + at: ResponseAt, + journal: ControlJournal, + presenting: SidekickOccurrence | undefined, + ): Operation>; /** The chat revision this message clears, read when the message is sent. */ revision(): number; /** @@ -534,7 +538,7 @@ export interface SidekickOwner { interface ServingResponse { readonly journal: ControlJournal; /** Admit the draft for this response, recording a refusal that wrote nothing. */ - submit(): Operation>; + submit(presenting: SidekickOccurrence | undefined): Operation>; } /** What a captured control refuses with when no response is running. */ @@ -590,16 +594,19 @@ export function useSidekickOwner(input: SidekickOwnerInput): Operation> { - return yield* servingNow().submit(); + sidekickRequests(root, function* (presenting): Operation> { + return yield* servingNow().submit(presenting); }), { - *began(occurrence, reserved): Operation { - return yield* servingNow().journal.began(occurrence, reserved); + *began(occurrence, reserved, presentation): Operation { + return yield* servingNow().journal.began(occurrence, reserved, presentation); }, *settled(order, outcome, observed): Operation { yield* servingNow().journal.settled(order, outcome, observed); }, + *presented(order, selected, read): Operation { + yield* servingNow().journal.presented(order, selected, read); + }, }, ); /** How this conversation's execution captures those controls, once. */ @@ -1488,13 +1495,16 @@ export function useSidekickOwner(input: SidekickOwnerInput): Operation { + *began(occurrence, reserved, presentation): Operation { pairs += 1; - return yield* written.began(occurrence, reserved); + return yield* written.began(occurrence, reserved, presentation); }, *settled(order, outcome, observed): Operation { yield* written.settled(order, outcome, observed); }, + *presented(order, selected, read): Operation { + yield* written.presented(order, selected, read); + }, }; /** * What this turn's controls file under, and the slot its Submit binds. @@ -1505,9 +1515,9 @@ export function useSidekickOwner(input: SidekickOwnerInput): Operation> { + *submit(presenting): Operation> { const taken = pairs; - const answer = yield* input.submit(at, journal); + const answer = yield* input.submit(at, journal, presenting); if (!answer.ok && pairs === taken) { refused.push({ order: taken, diff --git a/packages/cli/src/repl/sidekick/profile.ts b/packages/cli/src/repl/sidekick/profile.ts index 1ebd71a9d..50b766cab 100644 --- a/packages/cli/src/repl/sidekick/profile.ts +++ b/packages/cli/src/repl/sidekick/profile.ts @@ -63,6 +63,7 @@ import { Component, SYNTAX_COMPONENT } from "@executablemd/core"; import type { GeneratedSelection, InvocationForm } from "@executablemd/core"; +import { coreCompositionVocabulary } from "@executablemd/core/host"; import type { ComponentAnswerInstallation, ComponentAnswerRegistrar, @@ -71,8 +72,18 @@ import type { import type { FunctionComponentDefinition } from "@executablemd/core"; import type { Operation } from "effection"; -import { DESIGNATED, sidekickMutations, sidekickObservations } from "./controls.ts"; -import type { ControlJournal, SidekickControl, SidekickRequests } from "./controls.ts"; +import { + DESIGNATED, + sidekickDestinations, + sidekickMutations, + sidekickObservations, +} from "./controls.ts"; +import type { + ControlJournal, + SidekickControl, + SidekickDestinations, + SidekickRequests, +} from "./controls.ts"; /** * The ceiling one response is admitted under, as its execution captures it. @@ -88,6 +99,15 @@ export interface ResponseCeiling { readonly controls: readonly SidekickControl[]; /** Both classes, always: a reply may read and may write the draft. */ readonly allow: readonly ["read", "write"]; + /** + * Where a selected result of one of those controls goes. + * + * Beside the controls rather than behind them, because the two are one + * capture: an entry names the exact definition this conversation published, + * and the occurrence a control body is in is the occurrence its destination + * receives. + */ + readonly destinations: SidekickDestinations; } /** @@ -102,12 +122,14 @@ export function sidekickResponseCeiling( requests: SidekickRequests, journal: ControlJournal, ): ResponseCeiling { + const destinations = sidekickDestinations(journal); return { controls: Object.freeze([ - ...sidekickObservations(requests, journal), - ...sidekickMutations(requests, journal), + ...sidekickObservations(requests, journal, destinations), + ...sidekickMutations(requests, journal, destinations), ]), allow: ["read", "write"] as const, + destinations, }; } @@ -190,6 +212,26 @@ export function sidekickCeilingInstallation(ceiling: ResponseCeiling): Execution }; return { componentAnswers: [answers], + // The destinations this conversation owns, one per control it publishes. + // Stated on the same installation the answers are, so what canonical + // execution copies before any document code runs is the whole of it: the + // definition each entry names is the exact object the request above + // published, and an entry naming anything else routes nothing. + resultDestinations: { + destinations: Object.freeze([ + ...[...owned.values()].map((definition) => ceiling.destinations.entry(definition)), + // A control this conversation selects rather than answers for — + // canonical ``. There is no definition here to hand over, so + // the entry names the selection and core resolves which implementation + // its own tier answered with. + ...ceiling.controls + .filter((control) => control.selected === true) + .map((control) => ceiling.destinations.selected(control.name)), + ]), + installed: (lookup) => { + ceiling.destinations.installed(lookup); + }, + }, *install(): Operation { yield* Component.around({ generated: () => selection }); }, @@ -202,8 +244,15 @@ const CONTROL_ORIGIN = "@executablemd/cli:repl/sidekick"; /** One admitted control, as the compact surface describes it. */ export interface SurfaceEntry { readonly name: string; - /** `read` observes and returns; `write` changes something a person sees. */ - readonly effect: "read" | "write"; + /** + * What writing this does. + * + * `read` observes and returns; `write` changes something a person sees; + * `render` turns a value the reply already holds into text and reaches + * nothing — core's always-on composition table, which `allow` does not select + * between and which therefore grants no permission at all. + */ + readonly effect: "read" | "write" | "render"; /** * Which spelling is admitted. * @@ -240,6 +289,21 @@ export function responseSurface(ceiling: ResponseCeiling): readonly SurfaceEntry designated: false, }, ]; + // Core's always-on composition table, derived from core rather than listed + // here. A reply may write these whatever `allow` selected, so a surface that + // omitted one would describe a vocabulary narrower than the one the response + // is admitted under — and a hand-kept copy would stop being true the next + // time core admits a pure component. Their returns are the reply's own to + // render: nothing is performed, so there is nothing to answer back. + for (const pure of coreCompositionVocabulary()) { + entries.push({ + name: pure.name, + effect: "render", + form: pure.form, + props: ["value"], + designated: false, + }); + } for (const control of ceiling.controls) { entries.push({ name: control.name, @@ -306,5 +370,21 @@ export function describeSurface(entries: readonly SurfaceEntry[]): string { const ordinary = entry.designated ? "" : " (its return is yours to render, not feedback)"; lines.push(`- ${spelling} — ${entry.effect}.${props}${ordinary}`); } + // Stated once, after the list, because it is one rule about every control + // rather than a prop any of them declares: `yq` and `as` are the engine's, + // they are consumed before a control's own props are checked, and a control's + // schema therefore never mentions either. Describing them per line would read + // as six separate contracts for one rule. + lines.push( + "", + "Two props are the engine's own and may be written on any control above, " + + "beside that control's own props:", + '- yq="" — select one JSON value out of what the control returned, ' + + "with yq. The selected value is what is captured and what comes back as feedback. " + + "A control that returns text is queried as a JSON string, so decode it explicitly " + + "with from_json or from_yaml. An expression that matches nothing, or matches more " + + "than once, refuses — collect matches into an array with [ ... ].", + '- as="" — bind the result instead of rendering it.', + ); return lines.join("\n"); } diff --git a/packages/cli/src/repl/sidekick/requests.ts b/packages/cli/src/repl/sidekick/requests.ts index 472816b71..1eedeb246 100644 --- a/packages/cli/src/repl/sidekick/requests.ts +++ b/packages/cli/src/repl/sidekick/requests.ts @@ -38,7 +38,12 @@ import { entryInitialBindings } from "../model.ts"; import type { ReplModel } from "../model.ts"; import type { ReplHostFact } from "../host.ts"; import type { ReplPrinting, ReplSession } from "../session.ts"; -import type { GuideChapter, SidekickRequests, SubmitReceipt } from "./controls.ts"; +import type { + GuideChapter, + SidekickOccurrence, + SidekickRequests, + SubmitReceipt, +} from "./controls.ts"; import { replEnvironment } from "./environment.ts"; import { readGuideChapter } from "./guide.ts"; import { readEntryOutput } from "./output.ts"; @@ -160,7 +165,9 @@ export function rootReads( * submission binds a reservation into the chat history that asked for it, so it * needs the response that asked — and a response is the owner's, not the loop's. */ -export type SubmitForReply = () => Operation>; +export type SubmitForReply = ( + presenting: SidekickOccurrence | undefined, +) => Operation>; /** * Build the requests one response is answered by. @@ -208,8 +215,8 @@ export function sidekickRequests(root: RootReading, submit: SubmitForReply): Sid fillDraft(source: string): Operation> { return root.fill(source); }, - submit(): Operation> { - return submit(); + submit(presenting): Operation> { + return submit(presenting); }, // deno-lint-ignore require-yield *entryOutput(request: OutputReadRequest): Operation> { diff --git a/packages/cli/tests/fixtures/repl/issue-883/mounted-program.ts b/packages/cli/tests/fixtures/repl/issue-883/mounted-program.ts index 7690f3648..a582fd006 100644 --- a/packages/cli/tests/fixtures/repl/issue-883/mounted-program.ts +++ b/packages/cli/tests/fixtures/repl/issue-883/mounted-program.ts @@ -795,6 +795,15 @@ export interface HeldAppend { readonly released: boolean; /** Let it finish. */ release(): void; + /** + * Refuse it instead, as the storage underneath would refuse a write. + * + * The hold is the Promise the host's own append is defined in, so rejecting + * it is a refusal of the write itself: nothing is appended and the task that + * asked for it fails where it asked. A product flag would be the wrong seam + * for this — there is none, and there should not be one. + */ + refuse(reason: string): void; } /** @@ -842,11 +851,13 @@ export function appendGate(): AppendGate { }, holdNext(accepts: (path: string, record: string) => boolean): HeldAppend { let letGo = (): void => {}; + let refused: (error: Error) => void = () => {}; let announce = (): void => {}; let inFlight = false; let released = false; - const waiting = new Promise((resolve) => { + const waiting = new Promise((resolve, reject) => { letGo = resolve; + refused = reject; }); const arrival = new Promise((resolve) => { announce = resolve; @@ -873,6 +884,10 @@ export function appendGate(): AppendGate { released = true; letGo(); }, + refuse(reason: string): void { + released = true; + refused(new Error(reason)); + }, }; }, around(path: string, record: string): Promise | undefined { diff --git a/packages/cli/tests/fixtures/repl/issue-883/recovery-phase.ts b/packages/cli/tests/fixtures/repl/issue-883/recovery-phase.ts index 1a82d5231..359ec01cf 100644 --- a/packages/cli/tests/fixtures/repl/issue-883/recovery-phase.ts +++ b/packages/cli/tests/fixtures/repl/issue-883/recovery-phase.ts @@ -705,6 +705,8 @@ function* phases(): Operation { yield* submitForSidekick( { conversation: CHAT, response: RESPONSE }, { + // No receiver: this case is about the reservation, not a selection. + presenting: undefined, session: { // The acknowledged history, read the way the root reads it. entries: () => { diff --git a/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts b/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts index acf28e775..c60d2e786 100644 --- a/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts +++ b/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts @@ -238,8 +238,9 @@ export function* useHarness( return Ok(execution.chat as PairedChatStorage); }, root, - submit(at, journal: ControlJournal): Operation> { + submit(at, journal: ControlJournal, presenting): Operation> { return submitForSidekick(at, { + presenting, session: { // The acknowledged history, read the way the root reads it. entries: () => { diff --git a/packages/cli/tests/repl-entries.test.ts b/packages/cli/tests/repl-entries.test.ts index 9f7cca677..f70b99f4a 100644 --- a/packages/cli/tests/repl-entries.test.ts +++ b/packages/cli/tests/repl-entries.test.ts @@ -4902,3 +4902,124 @@ describe("REPL entries: what the Bindings reading shows at each position (#939)" expect(yield* bindingsAt(terminal, "entry-1")).toEqual(['token = "alpha"']); }); }); + +/** + * Tier EP6 — a selected capture crosses to the next entry. + * + * `yq` selects before a capture is published, so what the next entry inherits + * is the selected value and not the result it was selected out of. Driven + * through two real entries over one physical journal, each with its own segment + * view, and the second is handed exactly the record the public projection + * derives from the first — the same record a cold command derives from the same + * bytes. + */ +describe("REPL entries: a selected capture is what the next entry inherits", () => { + beforeAll(() => useTempFileCompiler()); + + /** A producer whose return is text holding more than the entry wants. */ + const RECORDS: ExecutionInstallation = { + components: [ + { + name: "Records", + origin: "repl-entries-test", + props: { type: "object", properties: {}, additionalProperties: false }, + description: "Return the text one entry selects out of.", + factory: () => + // deno-lint-ignore require-yield + function* (): Operation { + return JSON.stringify({ + records: [ + { name: "a", status: "ok" }, + { name: "b", status: "failed" }, + ], + }); + }, + }, + ], + }; + + /** One entry at the end of `physical`, retaining its root captures. */ + function* selecting( + physical: DurableStream, + source: string, + initialBindings: Readonly> = {}, + ): Operation> { + const view = new EntrySegmentStream(physical); + try { + return yield* yield* executeInstalled({ ...inlineSource(source), stream: view }, [RECORDS], { + initialBindings, + rootBindingPublications: "json-v1", + }); + } catch (error) { + return { ok: false, error: error instanceof Error ? error : new Error(String(error)) }; + } + } + + const SELECTS = [ + ``, + "", + "One: {failed.length}", + "", + ].join("\n"); + + // Read through a block rather than an interpolation: text interpolation + // resolves a binding name and not an expression over it. + const READS = [ + "```js eval", + "const picked = failed[0].name;", + "```", + "", + "Two: {picked}", + "", + ].join("\n"); + + it("EP6: the next entry starts from the selected value, not the producer's text", function* () { + const physical = new InMemoryStream(); + const first = yield* selecting(physical, SELECTS); + expect(first.ok).toBe(true); + expect(String(first.ok && first.value)).toContain("One: 1"); + + // Exactly what the projection says the next entry starts with. + const carried = inherited(yield* physical.readAll()); + expect(carried).toEqual({ failed: [{ name: "b" }] }); + // The text the producer returned did not cross, so the next entry cannot + // read a field the selection removed. + expect(JSON.stringify(carried)).not.toContain("status"); + + const second = yield* selecting(physical, READS, carried); + expect(second.ok).toBe(true); + expect(String(second.ok && second.value)).toContain("Two: b"); + }); + + it("EP6: the first entry's own binding is unchanged by the second entry's edit", function* () { + const physical = new InMemoryStream(); + yield* selecting(physical, SELECTS); + const carried = inherited(yield* physical.readAll()); + + const second = yield* selecting( + physical, + [ + "```js eval", + 'failed.push({ name: "later" });', + "const seen = failed.length;", + "```", + "", + "Two: {seen}", + "", + ].join("\n"), + carried, + ); + expect(second.ok).toBe(true); + expect(String(second.ok && second.value)).toContain("Two: 2"); + + const model = projected(yield* physical.readAll()); + const [one, two] = model.entries; + // The edit happened — the second entry read two — and it published nothing: + // a mutation is not a publication, so the retained value stays the one + // value the first entry selected, in both entries' readings and in what a + // third entry would start from. + expect(value(one.bindings, "failed")).toEqual([{ name: "b" }]); + expect(value(two.bindings, "failed")).toEqual([{ name: "b" }]); + expect(inherited(yield* physical.readAll()).failed).toEqual([{ name: "b" }]); + }); +}); diff --git a/packages/cli/tests/repl-sidekick-controls.test.ts b/packages/cli/tests/repl-sidekick-controls.test.ts index 96d114471..e62a977dd 100644 --- a/packages/cli/tests/repl-sidekick-controls.test.ts +++ b/packages/cli/tests/repl-sidekick-controls.test.ts @@ -41,7 +41,7 @@ import { InMemoryStream } from "@executablemd/durable-streams"; import type { Json } from "@executablemd/durable-streams"; import { Component, Execution, retainedSource, useTempFileCompiler } from "@executablemd/core"; import type { FunctionComponentDefinition } from "@executablemd/core"; -import { executeInstalled } from "@executablemd/core/host"; +import { coreCompositionVocabulary, executeInstalled } from "@executablemd/core/host"; import type { ExecutionInstallation, GeneratedXmdRootResult } from "@executablemd/core/host"; import { cwd, platform } from "@executablemd/runtime"; @@ -131,6 +131,15 @@ interface Asked { readonly began: ControlOccurrence[]; /** Every outcome recorded, by the order it settled. */ readonly settled: { order: number; ok: boolean; observed?: Json }[]; + /** Every intent marked as presenting a selected result, by its order. */ + readonly marked: { order: number; presentation: string }[]; + /** Every selected presentation recorded, by the order it belongs to. */ + readonly presented: { + order: number; + selected: Json | undefined; + failure: string | undefined; + read?: Json; + }[]; /** Whatever the draft now holds. */ draft: string | undefined; } @@ -143,7 +152,7 @@ interface StubOptions { } function fresh(): Asked { - return { requests: [], began: [], settled: [], draft: undefined }; + return { requests: [], began: [], settled: [], marked: [], presented: [], draft: undefined }; } /** @@ -190,9 +199,16 @@ function requests( asked.draft = source; return Ok(undefined); }, - *submit(): Operation> { + *submit(presenting): Operation> { asked.requests.push("submit"); - const order = yield* journal.began({ component: "REPL.Submit", arguments: {} }); + // Marked here for the reason the root marks it: Submit's intent binds the + // reservation the root took, so the root is what writes that pair — and + // what marks it, from the receiver handed over with the request. + const order = yield* journal.began( + { component: "REPL.Submit", arguments: {} }, + undefined, + presenting?.query === undefined ? undefined : "selected-v1", + ); if (options.refuse === "submit") { const refusal = new Error("the REPL cannot submit right now"); yield* journal.settled(order, Err(refusal)); @@ -205,6 +221,7 @@ function requests( read: { entry: "entry-1", limit: 4096 }, }; yield* journal.settled(order, Ok(undefined), receipt.status); + presenting?.file(order); return Ok(receipt); }, entryOutput: (request: OutputReadRequest) => @@ -240,11 +257,23 @@ function ceilingFor(asked: Asked, options: StubOptions = {}): ResponseCeiling { function journalOf(asked: Asked): ControlJournal { return { // deno-lint-ignore require-yield - *began(occurrence): Operation { + *began(occurrence, _reserved, presentation): Operation { asked.began.push(occurrence); + if (presentation !== undefined) { + asked.marked.push({ order: asked.began.length - 1, presentation }); + } return asked.began.length - 1; }, // deno-lint-ignore require-yield + *presented(order, selected, read): Operation { + asked.presented.push({ + order, + selected: selected.ok ? selected.value : undefined, + failure: selected.ok ? undefined : selected.error.message, + ...(read === undefined ? {} : { read }), + }); + }, + // deno-lint-ignore require-yield *settled(order, outcome, observed): Operation { asked.settled.push({ order, @@ -268,9 +297,24 @@ function reply( source: string, asked: Asked, options: StubOptions = {}, +): Operation> { + const ceiling = ceilingFor(asked, options); + return replyThrough(sidekickCeilingInstallation(ceiling), ceiling, source); +} + +/** + * Evaluate one reply through an installation a case assembled itself. + * + * The same held host execution as {@link reply}, with the ceiling installation + * supplied rather than derived — which is what lets a case state destinations + * that name something other than what this conversation published. + */ +function replyThrough( + installation: ExecutionInstallation, + ceiling: ResponseCeiling, + source: string, ): Operation> { return scoped(function* () { - const ceiling = ceilingFor(asked, options); const gate = withResolvers(); const entered = withResolvers(); const execution = yield* executeInstalled( @@ -279,7 +323,7 @@ function reply( stream: new InMemoryStream(), }, [ - sidekickCeilingInstallation(ceiling), + installation, { components: [ { @@ -492,6 +536,12 @@ describe("Tier R3 — what the ceiling admits, and what it does not", () => { // Core's own too, admitted by this ceiling rather than installed // beside it: the canonical question, under its own name. "Elicit", + // Core's always-on composition table, which `allow` does not select + // between: a reply may render a value it already holds whatever it was + // admitted for. Taken from core rather than listed, because a copy here + // would be a second statement of what is admitted — which is the one + // thing this case exists to rule out. + ...coreCompositionVocabulary().map((pure) => pure.name), ...GUIDE_CHAPTERS.map((chapter) => `Guide.${chapter}`), "REPL.Bindings", "REPL.EntryInput", @@ -502,6 +552,20 @@ describe("Tier R3 — what the ceiling admits, and what it does not", () => { ].sort(), ); + // Rendering is its own class, so a reader of the surface can tell a control + // that reaches something from one that turns a value into text: `allow` + // selects between read and write and never between these. + expect( + surface + .filter((entry) => entry.effect === "render") + .map((entry) => entry.name) + .sort(), + ).toEqual( + coreCompositionVocabulary() + .map((pure) => pure.name) + .toSorted(), + ); + // The two classes, and the forms each name is admitted for. The question is // a write because asking is not reading: a reply admitted to read alone // promises nobody will be interrupted. @@ -1038,7 +1102,7 @@ describe("Tier R3 — a reservation is found by all three of its facts", () => { describe("Tier R3 — the guide index describes what is admitted", () => { /** The names this ceiling registers, which is what may be advertised. */ function admittedNames(): ReadonlySet { - const asked: Asked = { requests: [], began: [], settled: [], draft: undefined }; + const asked: Asked = fresh(); const ceiling = ceilingFor(asked); return new Set(ceiling.controls.filter((one) => one.effect === "read").map((one) => one.name)); } @@ -1186,7 +1250,7 @@ describe("Tier R3 — a shipped example prepares a draft and runs", () => { * point of the row. */ function* prepared(chapter: GuideChapter): Operation<{ draft: string; fills: number }> { - const asked: Asked = { requests: [], began: [], settled: [], draft: undefined }; + const asked: Asked = fresh(); const answer = yield* reply(yield* displayed(chapter), asked); if (!answer.ok) { throw new Error(`Guide.${chapter}'s example was refused: ${answer.error.message}`); @@ -1961,3 +2025,346 @@ describe("Tier R3 — what a capture seals, and what cannot reach across it", () expect(asked.requests).toEqual(["bindings"]); }); }); + +/** + * Tier R6 — selecting out of what a control returned. + * + * A reply may write `yq` on any control it is admitted to, and what comes back + * is the selected value rather than the whole observation. What these cases + * discriminate is the *route*: the intent is marked before the original work, + * the selected value is a separate acknowledged record for that exact + * occurrence, and nothing about either is read from a component name, a + * completion order or the observation the producer happened to retain. + * + * Driven through the real `evaluateGeneratedXmdRoot` and the real ceiling + * installation, because the receiver only exists where canonical invocation + * opens one: a direct call to a control would prove nothing about which + * occurrence a value belongs to. + */ +describe("Tier R6 — a reply selects out of a control's own result", () => { + beforeAll(() => useTempFileCompiler()); + + it("R6a: a queried capture marks its intent and presents the selected value", function* () { + const asked = fresh(); + const answer = yield* reply( + `\n{names}\n\n`, + asked, + ); + + expect(answer.ok).toBe(true); + // Marked before the work, from the occurrence's own receiver — not from the + // record that came afterwards and not from an argument the reply wrote. + expect(asked.marked).toEqual([{ order: 0, presentation: "selected-v1" }]); + // One presentation, holding the selected data rather than the binding map. + expect(asked.presented).toEqual([{ order: 0, selected: ["Ada", "Grace"], failure: undefined }]); + // The original observation stands beside it, unchanged: the outcome is + // still what the control actually did. + expect(asked.settled[0]?.observed).toEqual({ names: ["Ada", "Grace"] }); + // And the capture is the selected value, which is what the reply rendered. + expect(answer.ok && answer.value.output).toContain("Ada"); + }); + + it("R6b: a queried occurrence without `as` presents the same selected value", function* () { + const asked = fresh(); + const answer = yield* reply( + `\n\n\n`, + asked, + ); + + expect(answer.ok).toBe(true); + expect(asked.marked).toEqual([{ order: 0, presentation: "selected-v1" }]); + expect(asked.presented).toEqual([{ order: 0, selected: ["Ada", "Grace"], failure: undefined }]); + }); + + it("R6c: an unqueried occurrence is unmarked and presents nothing", function* () { + const asked = fresh(); + const answer = yield* reply(`\n\n\n`, asked); + + expect(answer.ok).toBe(true); + // Exactly as it was before any of this existed, which is what keeps an + // older history and an unqueried reply reading the same. + expect(asked.marked).toEqual([]); + expect(asked.presented).toEqual([]); + }); + + it("R6d: two same-named occurrences select different values in admission order", function* () { + const asked = fresh(); + const answer = yield* reply( + [ + "", + ``, + ``, + "{first}/{second}", + "", + "", + ].join("\n"), + asked, + ); + + expect(answer.ok).toBe(true); + // Two occurrences, two receivers, two presentations — in admission order, + // and each holding its own value. One receiver reused, or a correlation by + // component name, would have given both the same answer. + expect(asked.marked).toEqual([ + { order: 0, presentation: "selected-v1" }, + { order: 1, presentation: "selected-v1" }, + ]); + expect(asked.presented).toEqual([ + { order: 0, selected: "Ada", failure: undefined }, + { order: 1, selected: "Grace", failure: undefined }, + ]); + expect(answer.ok && answer.value.output).toContain("Ada/Grace"); + }); + + it("R6e: a refused control with a query that would succeed stays refused", function* () { + const asked = fresh(); + // The expression is a constant, so a route that queried anything at all + // would produce a value — and must not, because the control refused. + const answer = yield* reply( + `\n\n\n`, + asked, + { refuse: "bindings" }, + ); + + expect(answer.ok).toBe(true); + expect(asked.marked).toEqual([{ order: 0, presentation: "selected-v1" }]); + // Marked and never presented: the original outcome is the refusal, and a + // presentation here would promote it into an answer. + expect(asked.presented).toEqual([]); + expect(asked.settled[0]?.ok).toBe(false); + }); + + it("R6f: a query that selects nothing refuses and presents nothing", function* () { + const asked = fresh(); + const answer = yield* reply( + `\n\n\n`, + asked, + ); + + // The original control succeeded; the selection did not produce one value, + // so the invocation refuses and nothing is captured or presented. + expect(asked.settled[0]?.ok).toBe(true); + expect(asked.presented).toEqual([]); + expect(answer.ok === false || answer.value.output.includes("one JSON value")).toBe(true); + }); + + it("R6g: a queried read keeps its range beside the selected value", function* () { + const asked = fresh(); + // The expression maps the window this read returned to the empty + // selection, which is the case that matters: an empty selected payload + // still has to carry the extent the producer actually observed. + const answer = yield* reply( + `\n\n\n`, + asked, + ); + + expect(answer.ok).toBe(true); + const held = asked.presented[0]; + expect(held?.selected).toEqual([]); + // The read's own identity and extent, outside the payload: selecting a + // field neither read another page nor changed what the producer observed. + expect(held?.read).toEqual({ + entry: "entry-1", + status: "completed", + offset: 0, + length: 12, + }); + }); + + it("R6g: one bounded window of a longer entry keeps its continuation", function* () { + // A nonzero bounded window of an entry longer than it, so there genuinely + // is a next page to ask for — which is the only arrangement in which "no + // later page was requested" says anything. + const asked = fresh(); + const answer = yield* reply( + `\n` + + `\n` + + `\n`, + asked, + { + read: { + entry: "entry-1", + status: "completed", + length: 400, + offset: 40, + limit: 12, + text: "a window of ", + previous: undefined, + next: { entry: "entry-1", offset: 52, limit: 12 }, + }, + }, + ); + + expect(answer.ok).toBe(true); + const held = asked.presented[0]; + // The empty selected payload, and beside it the window's own identity, + // range and continuation — the text deliberately absent, because the + // selection replaced it. + expect(held?.selected).toEqual([]); + expect(held?.read).toEqual({ + entry: "entry-1", + status: "completed", + offset: 40, + length: 400, + next: { entry: "entry-1", offset: 52, limit: 12 }, + }); + expect(JSON.stringify(held?.read)).not.toContain("a window of"); + // Exactly one read, and no second one: selecting out of a window is not a + // reason to go and fetch the page the continuation names. + expect(asked.requests).toEqual(["entryOutput"]); + }); + + it("R6h: a second response's receiver is its own", function* () { + const first = fresh(); + const second = fresh(); + yield* reply(`\n\n\n`, first); + yield* reply(`\n\n\n`, second); + + // Each response filed its own occurrence. Nothing crossed: the receiver is + // opened per invocation and closed when that invocation settles, so a + // second response cannot reach the first one's. + expect(first.presented).toEqual([{ order: 0, selected: "Ada", failure: undefined }]); + expect(second.presented).toEqual([{ order: 0, selected: "Grace", failure: undefined }]); + }); + + it("R6j: a copied definition is routed nowhere", function* () { + const asked = fresh(); + const ceiling = ceilingFor(asked); + const installation = sidekickCeilingInstallation(ceiling); + // Every member the published definitions have, in objects nothing + // published. A route that compared shape, or matched the name these copies + // carry, would hand a reply the destination belonging to the real ones. + const copied: ExecutionInstallation = { + ...installation, + resultDestinations: { + destinations: (installation.resultDestinations?.destinations ?? []).map((entry) => + "definition" in entry ? { ...entry, definition: { ...entry.definition } } : entry, + ), + ...(installation.resultDestinations?.installed === undefined + ? {} + : { installed: installation.resultDestinations.installed }), + }, + }; + const answer = yield* replyThrough( + copied, + ceiling, + `\n{n}\n\n`, + ); + + // The control still ran and still selected — `yq` is the engine's and owes + // nothing to a destination — and nothing was marked or presented, because + // no destination was authenticated for it. + expect(answer.ok).toBe(true); + expect(answer.ok && answer.value.output).toContain("Ada"); + expect(asked.marked).toEqual([]); + expect(asked.presented).toEqual([]); + }); + + it("R6i: a queried Submit marks the one intent its root wrote", function* () { + const asked = fresh(); + // The identity expression, because what this row is about is the *one* + // intent and the *one* presentation rather than the shape of the receipt: a + // Submit's intent binds the reservation its root took, so a route that + // wrote its own would leave two attempts in the history. + const answer = yield* reply(`\n\n\n`, asked); + + expect(answer.ok).toBe(true); + expect(asked.began.filter((held) => held.component === "REPL.Submit").length).toBe(1); + expect(asked.marked).toEqual([{ order: 0, presentation: "selected-v1" }]); + expect(asked.presented.length).toBe(1); + expect(asked.presented[0]?.order).toBe(0); + expect(String(asked.presented[0]?.selected)).toContain("entry-1"); + }); +}); + +/** + * Tier R8 — rendering a selected value in a real reply, and saying so once. + * + * `` is composition: it reaches nothing, answers nobody back, and is + * available to a reply whatever `allow` selected. These cases drive it through + * the same real root evaluation the rows above use, so what is checked is the + * vocabulary this conversation actually admits rather than a list kept beside + * it — and the compact surface a first turn reads is checked against that same + * vocabulary for the same reason. + */ +describe("Tier R8 — a reply renders what it selected", () => { + beforeAll(() => useTempFileCompiler()); + + it("R8a: a reply selects with yq and renders the result as YAML", function* () { + const asked = fresh(); + const answer = yield* reply( + [ + "", + ``, + "", + "", + "", + ].join("\n"), + asked, + ); + + expect(answer.ok).toBe(true); + const output = String(answer.ok && answer.value.output); + // The selected value, rendered as a YAML sequence by the same engine that + // selected it. A reply that had been handed the whole binding map would + // have rendered a mapping with a `names` key instead. + expect(output).toContain("- Ada"); + expect(output).toContain("- Grace"); + expect(output).not.toContain("names:"); + // And the selection is still one acknowledged presentation for that one + // occurrence: rendering it changed nothing about what came back. + expect(asked.marked).toEqual([{ order: 0, presentation: "selected-v1" }]); + expect(asked.presented).toEqual([{ order: 0, selected: ["Ada", "Grace"], failure: undefined }]); + }); + + it("R8a: rendering reaches nothing and answers nobody back", function* () { + const asked = fresh(); + const answer = yield* reply( + `\n\n\n`, + asked, + ); + + expect(answer.ok).toBe(true); + expect(String(answer.ok && answer.value.output)).toContain("- two"); + // No control ran, so nothing was requested, marked or presented: writing + // `` is not asking the root for anything. + expect(asked.requests).toEqual([]); + expect(asked.marked).toEqual([]); + expect(asked.presented).toEqual([]); + }); + + it("R8b: the compact surface advertises Yaml as rendering, with Json", function* () { + const asked = fresh(); + const surface = responseSurface(ceilingFor(asked)); + const rendering = surface.filter((entry) => entry.effect === "render"); + + // Derived from core's own composition table, which is why both appear and + // why neither is designated — their returns are the reply's to render. + expect(rendering.map((entry) => entry.name)).toEqual(["Json", "Yaml"]); + expect(rendering.every((entry) => entry.designated)).toBe(false); + expect(rendering.every((entry) => entry.form === "self-closing")).toBe(true); + + const described = describeSurface(surface); + expect(described).toContain(""); + expect(described).toContain(""); + }); + + it("R8b: the shared yq and as are stated once, for every control", function* () { + const asked = fresh(); + const described = describeSurface(responseSurface(ceilingFor(asked))); + + // One rule about every control rather than a prop any of them declares, so + // it is said after the list and said once. A description that repeated it + // per line would read as one contract per control. + expect(described.match(/yq=""/g)?.length).toBe(1); + expect(described.match(/as=""/g)?.length).toBe(1); + expect(described).toContain("from_json"); + expect(described).toContain("[ ... ]"); + // And no control's own prop list claims either of them: the engine consumes + // both before a control's schema is checked. + for (const entry of responseSurface(ceilingFor(asked))) { + expect(entry.props).not.toContain("yq"); + expect(entry.props).not.toContain("as"); + } + }); +}); diff --git a/packages/cli/tests/repl-sidekick-journey.test.ts b/packages/cli/tests/repl-sidekick-journey.test.ts index 432d08ae7..d24cdda7b 100644 --- a/packages/cli/tests/repl-sidekick-journey.test.ts +++ b/packages/cli/tests/repl-sidekick-journey.test.ts @@ -18,7 +18,7 @@ import { describe, it } from "@executablemd/test-support/bdd"; import { expect } from "@executablemd/test-support/expect"; -import { Ok, spawn, suspend, useScope, withResolvers } from "effection"; +import { Ok, scoped, spawn, suspend, useScope, withResolvers } from "effection"; import type { Operation, Result } from "effection"; import { previewGeneratedXmdRoot } from "@executablemd/core/host"; @@ -32,12 +32,18 @@ import type { SidekickOwner, SidekickTurn } from "../src/repl/sidekick/owner.ts" import type { PairedChatStorage } from "../src/repl/sidekick/repository.ts"; import type { SidekickRecord } from "../src/repl/sidekick/history.ts"; import type { SubmitReceipt } from "../src/repl/sidekick/controls.ts"; -import { AGENT, records, useHarness } from "./fixtures/repl/issue-883/sidekick-harness.ts"; +import { + AGENT, + records, + useHarness, + useTemporary, +} from "./fixtures/repl/issue-883/sidekick-harness.ts"; import type { Harness } from "./fixtures/repl/issue-883/sidekick-harness.ts"; import { appendGate, awaiting, awaited, + click, draftText, focusDraft, focusMessage, @@ -45,11 +51,13 @@ import { messageText, MOUNTED_AGENT, mountedReading, + operationGate, screenOf, sendMessage, settled, shows, typing, + useMountedHost, useMountedRepl, } from "./fixtures/repl/issue-883/mounted-program.ts"; import type { MountedRepl } from "./fixtures/repl/issue-883/mounted-program.ts"; @@ -1653,6 +1661,307 @@ describe("Tier R5 — a mounted message prepares and submits a real entry", () = }); }); +/** + * Tier R9 — the moment a selected result becomes feedback (E7). + * + * A queried control does three things in order: it records the intent, it does + * its own work, and *then* a separate record acknowledges what was selected out + * of the result. The third one is a real append through the host boundary, and + * everything these rows are about happens in the interval it occupies. + * + * So the interval is held open — at the host's own append, inside the operation + * that performs it — and what is asserted is what a next turn is sent while the + * acknowledgement is still in flight, and what is sent once it lands. Both + * gates are the test's own: nothing in the product has a flag for this, and a + * gate on the caller rather than on the append would be a gate on the test. + */ +describe("Tier R9 — a selected result is feedback only once it is acknowledged", () => { + /** The record a presentation is, as it reaches the file. */ + const PRESENTATION = '"kind":"control-presentation"'; + + /** One entry, so there is a published fact for a reply to select out of. */ + function* publishing(repl: MountedRepl): Operation { + repl.fake.script({ reply: entrySource("greeting", "Hello from the reply.", "{greeting}") }); + repl.fake.script({ reply: "Thanks for the receipt.\n" }); + yield* sendMessage(repl, "greet"); + yield* awaiting(repl.terminal, "the reply answering about its own entry", (one) => + shows(one, "Thanks for the receipt."), + ); + } + + it("R9a: nothing is sent while the acknowledgement is in flight, and one lands", function* () { + const gate = appendGate(); + const repl = yield* useMountedRepl({ gate }); + yield* publishing(repl); + const before = repl.fake.prompts.length; + + // A reply that selects one published name out of what the read returned. + repl.fake.script({ + reply: `\n\n\n`, + }); + repl.fake.script({ reply: "Got the one value.\n" }); + + const acknowledging = gate.holdNext((_path, record) => record.includes(PRESENTATION)); + yield* sendMessage(repl, "what did it publish?"); + yield* acknowledging.started(); + expect(acknowledging.inFlight).toBe(true); + + // The original outcome is already written and the selection has already + // happened — this append is the acknowledgement of it. What has gone out is + // the person's own message and nothing after it: a build that had sent the + // whole observation as a raw fallback, or sent the selected value without + // writing it down, would already be a turn ahead here. + yield* settled(20); + expect(repl.fake.prompts.length).toBe(before + 1); + + acknowledging.release(); + yield* awaiting(repl.terminal, "the reply answering about the selected value", (one) => + shows(one, "Got the one value."), + ); + + // Exactly one presentation, for exactly that occurrence — released once, + // not once per wait — and the turn it enabled carries the selected value + // alone rather than the binding map the control actually returned. + const read = yield* mountedReading(repl); + const presentations = read.chat.filter((record) => record.kind === "control-presentation"); + expect(presentations.length).toBe(1); + const only = presentations[0]; + expect(only?.kind === "control-presentation" && only.outcome.status).toBe("ok"); + expect(only?.kind === "control-presentation" && only.selected).toBe("Hello from the reply."); + expect(JSON.parse(repl.fake.prompts.at(-1) ?? "")).toBe("Hello from the reply."); + // The observation stands beside it, unchanged: the outcome is still what + // the control did, and the selection is a separate record about it. + const outcomes = read.chat.filter( + (record) => record.kind === "control-outcome" && record.observed !== undefined, + ); + expect( + outcomes.some( + (record) => + record.kind === "control-outcome" && + JSON.stringify(record.observed) === JSON.stringify({ greeting: "Hello from the reply." }), + ), + ).toBe(true); + }); + + it("R9b: Stop before the acknowledgement sends nothing, and writes nothing", function* () { + const dataRoot = yield* useTemporary("xmd-repl-r9b-"); + const operations = operationGate(); + const host = yield* useMountedHost({ dataRoot, operations }); + const repl = yield* useMountedRepl({ host }); + yield* publishing(repl); + const before = repl.fake.prompts.length; + + repl.fake.script({ + reply: `\n\n\n`, + }); + // Scripted but never reached: a follow-up turn appearing here is the + // failure this row is named for. + repl.fake.script({ reply: "Should never be asked.\n" }); + + // Held at the operation the append *is*, rather than at a promise the host + // was already handed: a native append cannot be taken back, so only this + // boundary can say whether Stop took the record back or merely stopped + // waiting for it. + const acknowledging = operations.holdNext((_path, record) => record.includes(PRESENTATION)); + yield* sendMessage(repl, "what did it publish?"); + yield* acknowledging.started(); + expect(acknowledging.holding).toBe(true); + + yield* click(repl.terminal, "[stop]"); + yield* awaiting(repl.terminal, "the Sidekick going idle", (one) => shows(one, "[send]")); + // Teardown joined the held operation rather than leaving a write scheduled + // behind it, and the operation came down without appending. + yield* awaited("the acknowledgement coming down", () => acknowledging.abandoned); + expect(acknowledging.holding).toBe(false); + + // Nothing physical: the presentation was never written, which is the fact a + // promise gate could not establish. + expect(operations.appended.some((one) => one.record.includes(PRESENTATION))).toBe(false); + const read = yield* mountedReading(repl); + expect(read.chat.filter((record) => record.kind === "control-presentation")).toEqual([]); + // And no follow-up turn after the message's own: not the selected value, + // and not the whole observation as a raw fallback. + expect(repl.fake.prompts.length).toBe(before + 1); + expect( + repl.fake.prompts.slice(before).some((one) => one.includes("Hello from the reply.")), + ).toBe(false); + }); + + it("R9c: a refused acknowledgement is nobody's successful feedback", function* () { + const gate = appendGate(); + const repl = yield* useMountedRepl({ gate }); + yield* publishing(repl); + const before = repl.fake.prompts.length; + + repl.fake.script({ + reply: `\n\n\n`, + }); + // Scripted for whatever this conversation does next, so the row reads what + // actually happened rather than stalling on an unscripted turn. + repl.fake.script({ reply: "Carrying on.\n" }); + + // The storage refuses this one write. Nothing in the product has a flag for + // that: the refusal is the gate's, at the boundary the host's own append is + // defined in. + const acknowledging = gate.holdNext((_path, record) => record.includes(PRESENTATION)); + yield* sendMessage(repl, "what did it publish?"); + yield* acknowledging.started(); + acknowledging.refuse("the storage refused this record"); + + yield* awaiting(repl.terminal, "the Sidekick going idle again", (one) => shows(one, "[send]")); + yield* settled(40); + + // No presentation was retained, and so no successful selected feedback + // exists for anybody to be sent: the record is what makes a selection + // feedback, and this one was refused. + const read = yield* mountedReading(repl); + expect(read.chat.filter((record) => record.kind === "control-presentation")).toEqual([]); + expect( + repl.fake.prompts.slice(before + 1).some((one) => one.includes("Hello from the reply.")), + ).toBe(false); + // The original outcome stands, because it happened: the refusal is of the + // acknowledgement and not a retraction of the work. + expect( + read.chat.some( + (record) => + record.kind === "control-outcome" && + JSON.stringify(record.observed) === JSON.stringify({ greeting: "Hello from the reply." }), + ), + ).toBe(true); + // And the intent is still marked, which is what makes this history an + // incomplete selection rather than an unqueried control: whoever reads it + // next can tell that a selection was owed and never acknowledged. + expect( + read.chat.filter( + (record) => record.kind === "control" && record.presentation === "selected-v1", + ).length, + ).toBe(1); + }); + + it("R9d: two occurrences of one control select different data, and settle once each", function* () { + const gate = appendGate(); + const repl = yield* useMountedRepl({ gate }); + yield* publishing(repl); + const before = repl.fake.prompts.length; + + // One response, two occurrences of the same control, two expressions. The + // failure this discriminates is a receiver correlated by component name or + // by completion order: either would hand both occurrences one answer. + repl.fake.script({ + reply: [ + "", + ``, + ``, + "{whole}/{size}", + "", + "", + ].join("\n"), + }); + repl.fake.script({ reply: "Both came back.\n" }); + + // The second occurrence's acknowledgement is held, so the two are observed + // at different moments rather than as a finished pair. + const second = gate.holdNext( + (_path, record) => record.includes(PRESENTATION) && record.includes('"order":1'), + ); + yield* sendMessage(repl, "two readings"); + yield* second.started(); + + // The first one is already acknowledged while the second is still in + // flight, and no turn has gone out for either. + yield* settled(20); + expect(repl.fake.prompts.length).toBe(before + 1); + + second.release(); + yield* awaiting(repl.terminal, "the reply answering about both", (one) => + shows(one, "Both came back."), + ); + + // Two presentations, in admission order, each holding its own value and + // each written once. + const read = yield* mountedReading(repl); + const presentations = read.chat.flatMap((record) => + record.kind === "control-presentation" + ? [{ order: record.order, selected: record.selected }] + : [], + ); + expect(presentations).toEqual([ + { order: 0, selected: "Hello from the reply." }, + { order: 1, selected: "Hello from the reply.".length }, + ]); + // And the turn they enabled carries both — two sections, in the order the + // response admitted them, each holding its own selected value and neither + // holding the binding map the control actually returned. + const feedback = repl.fake.prompts.at(-1) ?? ""; + expect(feedback.match(/## REPL\.Bindings/g)?.length).toBe(2); + expect(feedback.indexOf('"Hello from the reply."')).toBeLessThan(feedback.indexOf("21")); + expect(feedback).not.toContain('"greeting"'); + }); + + it("R9e: a cold reopen reads the saved selection, and reruns nothing", function* () { + const dataRoot = yield* useTemporary("xmd-repl-r9e-"); + let execution = ""; + let entries = 0; + let saved: readonly SidekickRecord[] = []; + + yield* scoped(function* (): Operation { + const host = yield* useMountedHost({ dataRoot }); + const repl = yield* useMountedRepl({ host }); + yield* publishing(repl); + repl.fake.script({ + reply: `\n\n\n`, + }); + repl.fake.script({ reply: "Got the one value.\n" }); + yield* sendMessage(repl, "what did it publish?"); + yield* awaiting(repl.terminal, "the selected value coming back", (one) => + shows(one, "Got the one value."), + ); + + const read = yield* mountedReading(repl); + execution = read.execution; + entries = read.model.entries.length; + saved = read.chat; + // This process really did acknowledge one selection, which is what the + // cold half is then held to. + expect(saved.filter((record) => record.kind === "control-presentation").length).toBe(1); + }); + + // Cold, over those files, with its own provider: nothing of the process + // above is still alive. + const cold = yield* useMountedHost({ dataRoot }); + const reopened = yield* useMountedRepl({ + host: cold, + location: `xmd://repl/${execution}/entries`, + }); + + // Inspected before anything is said to it. The history is exactly what was + // saved, the entry that ran is not run again, and this process has asked + // the provider nothing: reopening is a read. + const inspected = yield* mountedReading(reopened); + expect(inspected.chat).toEqual(saved); + expect(inspected.model.entries.length).toBe(entries); + expect(reopened.fake.prompts).toEqual([]); + + // An explicit continuation, and it is the only thing that asks the + // provider anything. Its first turn carries the saved conversation. + reopened.fake.script({ reply: "Carried it over.\n" }); + yield* sendMessage(reopened, "and now?"); + yield* awaiting(reopened.terminal, "the continuation answering", (one) => + shows(one, "Carried it over."), + ); + + const after = yield* mountedReading(reopened); + // One turn, no control: the continuation repeated no completed control and + // ran no entry, and the one acknowledged selection is still the one that + // was saved — unchanged, and not written a second time. + expect(reopened.fake.prompts.length).toBe(1); + expect(after.model.entries.length).toBe(entries); + const presentations = after.chat.filter((record) => record.kind === "control-presentation"); + expect(presentations.length).toBe(1); + expect(presentations).toEqual(saved.filter((record) => record.kind === "control-presentation")); + }); +}); + /** * Tier TE — the names a person published, and what a reply really does with them. * diff --git a/packages/cli/tests/repl-sidekick-lifecycle.test.ts b/packages/cli/tests/repl-sidekick-lifecycle.test.ts index 6df945bb2..815bbe13b 100644 --- a/packages/cli/tests/repl-sidekick-lifecycle.test.ts +++ b/packages/cli/tests/repl-sidekick-lifecycle.test.ts @@ -169,6 +169,8 @@ describe("Tier R6 — Stop ends the asking and nothing else", () => { }, // deno-lint-ignore require-yield *settled(): Operation {}, + // deno-lint-ignore require-yield + *presented(): Operation {}, }; const session: AdmittingSession = { entries: () => Ok([]), @@ -183,6 +185,8 @@ describe("Tier R6 — Stop ends the asking and nothing else", () => { submitForSidekick( { conversation: "c", response: "response:1" }, { + // No receiver: this case is about the reservation, not a selection. + presenting: undefined, session, facts: () => ({ live: true, diff --git a/packages/cli/tests/repl-sidekick-recovery.test.ts b/packages/cli/tests/repl-sidekick-recovery.test.ts index ea6743cc4..62683c176 100644 --- a/packages/cli/tests/repl-sidekick-recovery.test.ts +++ b/packages/cli/tests/repl-sidekick-recovery.test.ts @@ -42,12 +42,14 @@ import { ENTRIES_FILE, PAIRED_DIRECTORY, parseEntryRecords, + parseSidekickRecord, readSidekickRecords, SIDEKICK_FILE, serializeSidekickRecord, } from "../src/repl/sidekick/history.ts"; import type { ControlRecord, SidekickRecord } from "../src/repl/sidekick/history.ts"; import { projectSidekick } from "../src/repl/sidekick/model.ts"; +import { designatedResults, recoveredWork, sealedFeedback } from "../src/repl/sidekick/feedback.ts"; import { sidekickChatRows } from "../src/repl/program.ts"; import type { ReplSidekickChatRow } from "../src/repl/application.ts"; import type { SidekickReading } from "../src/repl/sidekick/model.ts"; @@ -1418,6 +1420,8 @@ describe("Tier R2 — a reservation binds what the writer has acknowledged", () const asked = yield* submitForSidekick( { conversation: CHAT, response: RESPONSE }, { + // No receiver: this case is about the reservation, not a selection. + presenting: undefined, session: { // The acknowledged history, read the way the root reads it. entries: () => { @@ -1472,6 +1476,8 @@ describe("Tier R2 — a reservation binds what the writer has acknowledged", () const accepted = yield* submitForSidekick( { conversation: CHAT, response: RESPONSE }, { + // No receiver: this case is about the reservation, not a selection. + presenting: undefined, session: { // The acknowledged history, read the way the root reads it. entries: () => { @@ -2332,3 +2338,323 @@ describe("Tier IN5 — a chat saved by the build before this one", () => { expect(fills).toHaveLength(1); }); }); + +/** + * Tier R7 — what a cold reopening says about a selected result. + * + * Three shapes of history, and they must read as three different things. One + * holds an acknowledged selection; one holds a marked intent whose selection + * was never acknowledged; one predates selection entirely. A reading that + * rounded any of them to the nearest other would either lose a historical + * answer or hand a reply the observation it deliberately did not ask for. + * + * Projected from records alone, through `projectSidekick`, which is what a cold + * open actually does: no conversation is opened, no provider is contacted and + * no control is run. + */ +describe("Tier R7 — a cold reopening reads a selected result from its records", () => { + const RESPONSE = "r1"; + + /** One control's intent, marked or not. */ + function intent(order: number, component: string, marked: boolean): SidekickRecord { + return { + kind: "control", + conversation: CHAT, + response: RESPONSE, + order, + component, + arguments: {}, + ...(marked ? { presentation: "selected-v1" as const } : {}), + }; + } + + function outcome(order: number, observed?: unknown, failure?: string): SidekickRecord { + return { + kind: "control-outcome", + conversation: CHAT, + response: RESPONSE, + order, + outcome: + failure === undefined + ? { status: "ok" } + : { status: "err", error: { name: "Error", message: failure } }, + ...(observed === undefined ? {} : { observed }), + }; + } + + function presentation( + order: number, + selected: unknown, + options: { read?: unknown; failure?: string; conversation?: string; response?: string } = {}, + ): SidekickRecord { + return { + kind: "control-presentation", + conversation: options.conversation ?? CHAT, + response: options.response ?? RESPONSE, + order, + version: 1, + outcome: + options.failure === undefined + ? { status: "ok" } + : { status: "err", error: { name: "Error", message: options.failure } }, + ...(options.failure === undefined ? { selected } : {}), + ...(options.read === undefined || options.failure !== undefined + ? {} + : { read: options.read }), + }; + } + + /** A history with one turn, one reply and whatever control records follow. */ + function history(...controls: SidekickRecord[]): SidekickRecord[] { + return [...opened(), turn(1, "said"), reply(1, "answered"), ...controls]; + } + + it("R7a: an acknowledged selection is reconstructed exactly", function* () { + const reading = project( + history( + intent(0, "REPL.Bindings", true), + outcome(0, { names: ["Ada", "Grace"] }), + presentation(0, ["Ada", "Grace"]), + ), + ); + + const held = reading.operations.find((operation) => operation.order === 0); + expect(held?.status).toBe("ok"); + expect(held?.presentation).toBe("selected"); + // The selected value, out of the record, unchanged. + expect(held?.selected).toEqual(["Ada", "Grace"]); + }); + + it("R7a: a queried read keeps its range beside the value", function* () { + const reading = project( + history( + intent(0, "REPL.EntryOutput", true), + outcome(0, { entry: "entry-1", status: "completed", offset: 0, length: 12, text: "x" }), + presentation(0, [], { + read: { entry: "entry-1", status: "completed", offset: 0, length: 12 }, + }), + ), + ); + + const held = reading.operations.find((operation) => operation.order === 0); + expect(held?.selected).toEqual([]); + // Outside the payload: an empty selection still says how much the producer + // observed, which is what a reply needs to decide whether to read on. + expect(held?.read).toEqual({ + entry: "entry-1", + status: "completed", + offset: 0, + length: 12, + }); + }); + + it("R7b: a marked intent with no presentation is incomplete, and exposes nothing", function* () { + const reading = project( + history(intent(0, "REPL.Bindings", true), outcome(0, { names: ["Ada", "Grace"] })), + ); + + const held = reading.operations.find((operation) => operation.order === 0); + // The original outcome stands as evidence, and the selection is reported as + // the interrupted thing it is. What must not appear is the observation: a + // reply that asked for a field is never handed the whole map instead. + expect(held?.status).toBe("ok"); + expect(held?.presentation).toBe("incomplete"); + expect(held?.selected).toBeUndefined(); + }); + + it("R7b: an unfinished marked intent is incomplete too", function* () { + const reading = project(history(intent(0, "REPL.Bindings", true))); + + const waiting = reading.unfinished.find((operation) => operation.order === 0); + expect(waiting?.status).toBe("unfinished"); + expect(waiting?.presentation).toBe("incomplete"); + }); + + it("R7b: a recorded selection failure reads as refused, not as a value", function* () { + const reading = project( + history( + intent(0, "REPL.Bindings", true), + outcome(0, { names: [] }), + presentation(0, undefined, { failure: "this yq expression must return one JSON value." }), + ), + ); + + const held = reading.operations.find((operation) => operation.order === 0); + expect(held?.presentation).toBe("refused"); + expect(held?.selected).toBeUndefined(); + expect(held?.failure).toContain("one JSON value"); + }); + + it("R7c: a history written before selection keeps its own meaning", function* () { + const reading = project( + history(intent(0, "REPL.Bindings", false), outcome(0, { names: ["Ada"] })), + ); + + const held = reading.operations.find((operation) => operation.order === 0); + // No member at all, which is what keeps an older file projecting exactly as + // it did: the observation is still the answer for an unqueried control. + expect(held?.status).toBe("ok"); + expect(held?.presentation).toBeUndefined(); + expect(held?.selected).toBeUndefined(); + }); + + it("R7d: a presentation for an operation this history does not record refuses", function* () { + expect(refusalOf(history(presentation(0, ["Ada"])))).toContain("does not record"); + }); + + it("R7d: a presentation for an unmarked operation refuses", function* () { + expect( + refusalOf( + history(intent(0, "REPL.Bindings", false), outcome(0, {}), presentation(0, ["Ada"])), + ), + ).toContain("did not ask for one"); + }); + + it("R7d: a presentation before its own outcome refuses", function* () { + expect( + refusalOf(history(intent(0, "REPL.Bindings", true), presentation(0, ["Ada"]))), + ).toContain("before the operation's own outcome"); + }); + + it("R7d: two presentations for one operation refuse", function* () { + expect( + refusalOf( + history( + intent(0, "REPL.Bindings", true), + outcome(0, {}), + presentation(0, ["Ada"]), + presentation(0, ["Grace"]), + ), + ), + ).toContain("two selected results"); + }); + + it("R7d: a presentation for an operation that failed refuses", function* () { + expect( + refusalOf( + history( + intent(0, "REPL.Bindings", true), + outcome(0, undefined, "the REPL cannot do that"), + presentation(0, ["Ada"]), + ), + ), + ).toContain("did not succeed"); + }); + + it("R7d: a presentation naming another occurrence refuses", function* () { + // The right order, in a response this history never recorded: an + // association by order alone would have accepted it. + expect( + refusalOf( + history( + intent(0, "REPL.Bindings", true), + outcome(0, {}), + presentation(0, ["Ada"], { response: "r2" }), + ), + ), + ).toContain("does not record"); + }); + + it("R7e: what a cold continuation is sent for each of the three shapes", function* () { + const at = { conversation: CHAT, response: RESPONSE }; + const acknowledged = history( + intent(0, "REPL.Bindings", true), + outcome(0, { names: ["Ada", "Grace"] }), + presentation(0, ["Ada", "Grace"]), + ); + const interrupted = history( + intent(0, "REPL.Bindings", true), + outcome(0, { names: ["Ada", "Grace"] }), + ); + const historical = history( + intent(0, "REPL.Bindings", false), + outcome(0, { names: ["Ada", "Grace"] }), + ); + + // (a) The selected value, as the JSON it is, and nothing of the map. + const selected = sealedFeedback(designatedResults(acknowledged, at)); + expect(JSON.parse(String(selected))).toEqual(["Ada", "Grace"]); + + // (b) Told truthfully, and the observation is not in it. This is the + // substitution the pair exists to prevent: the names are in the retained + // outcome and must not reach the reply that asked for a selection. + const incomplete = String(sealedFeedback(designatedResults(interrupted, at))); + expect(incomplete).toContain("never recorded"); + expect(incomplete).not.toContain("Ada"); + + // (c) An unmarked occurrence keeps the feedback it always had: its own + // observation, serialized as the value it is. + const unmarked = sealedFeedback(designatedResults(historical, at)); + expect(JSON.parse(String(unmarked))).toEqual({ names: ["Ada", "Grace"] }); + }); + + it("R7e: an interrupted response's account carries the same three readings", function* () { + const at = { conversation: CHAT, response: RESPONSE }; + const account = String( + recoveredWork( + history( + intent(0, "REPL.Bindings", true), + outcome(0, { names: ["Ada"] }), + presentation(0, ["Ada"]), + intent(1, "REPL.Environment", true), + outcome(1, "cwd: /work"), + ), + at, + ), + ); + + // The acknowledged one is its selected value; the marked one with no + // presentation says so. Both under their own headings, in order. + expect(account).toContain("## REPL.Bindings"); + expect(account).toContain('"Ada"'); + expect(account).toContain("## REPL.Environment"); + expect(account).toContain("never recorded"); + // And the second one's own observation is not substituted for its missing + // selection. + expect(account).not.toContain("cwd: /work"); + }); + + it("R7d: a malformed selected value is unreadable history", function* () { + // Both arms at once — a presentation that answered and did not. Read + // through the repository's own parser rather than the typed builder above, + // because that is where a record arrives from. + const malformed = parseSidekickRecord( + JSON.stringify({ + kind: "control-presentation", + conversation: CHAT, + response: RESPONSE, + order: 0, + version: 1, + outcome: { status: "ok" }, + }), + ); + expect(malformed).toBeUndefined(); + + const wrongVersion = parseSidekickRecord( + JSON.stringify({ + kind: "control-presentation", + conversation: CHAT, + response: RESPONSE, + order: 0, + version: 2, + outcome: { status: "ok" }, + selected: null, + }), + ); + expect(wrongVersion).toBeUndefined(); + + // And the one this build does have reads back as itself. + const readable = parseSidekickRecord( + JSON.stringify({ + kind: "control-presentation", + conversation: CHAT, + response: RESPONSE, + order: 0, + version: 1, + outcome: { status: "ok" }, + selected: ["Ada"], + }), + ); + expect(readable?.kind).toBe("control-presentation"); + }); +}); diff --git a/packages/core/deno.json b/packages/core/deno.json index abdb91ecd..17681b00c 100644 --- a/packages/core/deno.json +++ b/packages/core/deno.json @@ -22,6 +22,7 @@ "zod": "npm:zod@^4.3.6", "unist-util-select": "npm:unist-util-select@^5", "mdast-util-to-string": "npm:mdast-util-to-string@^4", - "@secretlint/profiler": "npm:@secretlint/profiler@13.0.4" + "@secretlint/profiler": "npm:@secretlint/profiler@13.0.4", + "yq.rs/loader": "npm:yq.rs@0.1.0/loader" } } diff --git a/packages/core/host.ts b/packages/core/host.ts index b250f4224..5d10dd994 100644 --- a/packages/core/host.ts +++ b/packages/core/host.ts @@ -278,6 +278,37 @@ export type { */ export { installInvocationAgentProvider } from "./src/agent/launch-install.ts"; export { GeneratedXmdError } from "./src/generated-xmd.ts"; +/** + * Where this host's own results may go, for the components it published. + * + * Here rather than on `./api` because it is an internal host installation + * contract: a host states its destinations on the `ExecutionInstallation` it + * already hands over, canonical execution copies them before any installation + * runs, and the lookup a host's own component body reaches its occurrence + * through arrives as the argument of one call. None of it is component props, + * definition metadata, a Context slot or a contextual Api, so nothing a + * document, a component or a middleware package can name acquires one. + */ +export { ResultDestinationError } from "./src/component-result-destinations.ts"; +export type { + ResultDestination, + ResultDestinationEntry, + ResultDestinationInstallation, + ResultOccurrence, + ResultOccurrenceLookup, +} from "./src/component-result-destinations.ts"; +/** + * The pure components every generated evaluation may write, for a host that + * describes the vocabulary a response is admitted under. + * + * Core's own always-on table, which `allow` does not select between: a host + * cannot remove a pure component from a fragment's vocabulary by omitting it + * and cannot add an effect to the table by naming one. This is the describing + * half of that fact, so a host telling an agent what it may write derives the + * list rather than keeping a copy of it. + */ +export { coreCompositionVocabulary } from "./src/generated-xmd.ts"; +export type { CompositionVocabulary } from "./src/generated-xmd.ts"; /** * Evaluating generated source as a **root** rather than as a fragment — see diff --git a/packages/core/package.json b/packages/core/package.json index 087e5b35f..e37167fe9 100644 --- a/packages/core/package.json +++ b/packages/core/package.json @@ -34,6 +34,7 @@ "mdast-util-to-string": "^4", "remark": "15", "remend": "^1.2.2", - "unist-util-select": "^5" + "unist-util-select": "^5", + "yq.rs": "0.1.0" } } diff --git a/packages/core/src/component-result-destinations.ts b/packages/core/src/component-result-destinations.ts new file mode 100644 index 000000000..8381b6d9f --- /dev/null +++ b/packages/core/src/component-result-destinations.ts @@ -0,0 +1,295 @@ +/** + * Where one occurrence's selected result is allowed to go, and who may say so. + * + * A host that evaluates generated source on somebody's behalf has a use for an + * invocation's result that a document does not: the Sidekick's reply asked the + * root to do something, and what it asked for has to come back to it. That is a + * **destination** — not a binding the source wrote, and not something public + * result middleware may answer. + * + * ## The installation is trusted; the association is not negotiable + * + * The host states its destinations once, as a value canonical execution copies + * before any installation, middleware or document code runs — the same terms + * admissions and declared components travel on. Nothing afterwards can add one, + * replace one or read the collection: it is reachable through no context, no + * contextual Api, no stable name and no definition metadata, which is why an + * entry here cannot be acquired by spelling something. + * + * What an entry names is the **exact definition** this execution's capture + * authenticated. The host supplies the object it published through its own + * `componentAnswers` request, and the route keeps core's own retained copy of + * that publication. A look-alike carrying the same members, a copy taken + * afterwards, a same-named registration and a definition another execution + * built are each absent from the route, so an occurrence of one is an ordinary + * invocation with nowhere to send anything. + * + * ## A receiver belongs to one occurrence + * + * Canonical invocation opens a receiver for the exact occurrence it is about to + * run, keyed by the `ComponentInvocation` the engine minted for it, and revokes + * it when that invocation settles. Two same-named controls in one response are + * two invocations and therefore two receivers; a receiver kept from a finished + * occurrence answers for nothing. Nothing correlates by component name, by + * completion order or by "the last one", because those are the readings that + * hand one occurrence another's answer. + * + * The host reaches its own receiver through the lookup core hands it at + * installation — delivered as the argument of one call, published nowhere. A + * control body already holds the invocation the engine gave it, so asking for + * *its own* occurrence is the only thing it can do with that lookup. + */ + +import type { Operation } from "effection"; + +import type { ComponentInvocation } from "./invocation-identity.ts"; +import type { FunctionComponentDefinition } from "./types.ts"; + +/** What one occurrence of an owned definition may do with its own result. */ +export interface ResultOccurrence { + /** + * The `yq` expression this occurrence was written with, when it wrote one. + * + * The engine's own reading of the authored invocation, so a host deciding + * how to record the occurrence is reading what will actually happen rather + * than an argument the source supplied. + */ + readonly query: string | undefined; + /** + * Hand this occurrence's accepted, selected result to its destination. + * + * Called by canonical expansion after the producer's own contract accepted + * what it produced, its invocation joined, and the selection and any capture + * or publication the occurrence owed have happened. Once per occurrence: a + * second call answers nothing, because one invocation produces one result. + */ + deliver(selected: unknown): Operation; +} + +/** What a host's destination does with one occurrence's selected result. */ +export interface ResultDestination { + /** + * Accept one occurrence's selected result. + * + * The host's own work — writing it down, sending it on — and its outcome is + * the host's too. A failure here is an ordinary failure of the invocation + * that produced the result, in the region that invocation was written in. + */ + accept(selected: unknown): Operation; + /** + * Which occurrence this destination is serving. + * + * Told once, immediately after the destination is opened and before the + * invocation runs. It exists because the two halves of a host's own + * bookkeeping meet at different moments: its component body knows what the + * occurrence is doing while it runs, and this destination is what is left to + * receive the result afterwards. Pairing them by the exact occurrence object + * is what keeps a host from correlating by component name, by completion + * order or by whichever occurrence came last. + */ + serves?(occurrence: ResultOccurrence): void; +} + +/** + * One component this host owns a destination for, named one of two ways. + * + * A host publishes most of what a generated source may write, and for those it + * hands over the **exact definition** it published: the route compares that + * object against core's own record of the publication, so a look-alike, a copy + * taken afterwards and a definition another execution built are each absent. + * + * A **selected** name is the other case, and it exists because some of what a + * host offers is not the host's to publish. Canonical `` is protected, + * so the host selects the name and core's own tier answers it — there is no + * published object for the host to hand over. Naming it here states nothing + * about the implementation: core resolves it from its own capture, and refuses + * a name some provider published, because a name a provider answered for is one + * whose destination belongs to whoever published it. + */ +export type ResultDestinationEntry = + | { + readonly definition: FunctionComponentDefinition; + /** Open a destination for one occurrence of it. */ + open(query: string | undefined): ResultDestination; + } + | { + readonly selected: string; + open(query: string | undefined): ResultDestination; + }; + +/** + * What a trusted host states about its destinations, and what it is handed back. + * + * `destinations` is read once and copied; `installed` is called with the lookup + * a control body uses to reach its own occurrence. The call is where the + * capability is delivered, which is why there is no reader for one. + */ +export interface ResultDestinationInstallation { + readonly destinations: readonly ResultDestinationEntry[]; + installed?(lookup: ResultOccurrenceLookup): void; +} + +/** How a host asks for the occurrence one invocation of its own is in. */ +export type ResultOccurrenceLookup = ( + invocation: ComponentInvocation, +) => ResultOccurrence | undefined; + +/** This execution's own destinations, as canonical expansion consults them. */ +export interface ResultDestinationRoute { + /** Whether this execution owns a destination for this exact implementation. */ + owns(fn: unknown): boolean; + /** + * Record that `wrapper` is canonical resolution's own answer for `implementation`. + * + * A generated import is answered with a fresh wrapper per import — canonical + * resolution builds it so the admitted form can be decided per invocation — + * and that wrapper is what the expansion site is holding. So the site cannot + * recognize the implementation underneath it, and resolution is the only + * thing that can say which one it is. + * + * Exact objects on both sides, stated by canonical resolution at the moment + * it produces the answer. Nothing a host, a document or a middleware package + * holds reaches this, and an alias for an implementation this route does not + * own records nothing. + */ + alias(wrapper: unknown, implementation: unknown): void; + /** + * Open the receiver for one occurrence, or none. + * + * `undefined` when nothing owns this implementation, which is every ordinary + * invocation. Opened before the invocation runs, so the destination exists + * while required-as is being decided and while the producer's own body is + * recording what it is about to do; `bind` then ties it to the exact + * invocation object the engine mints, which is what a host's own body + * presents when it asks for its occurrence. The closer runs when the + * invocation settles, however it settles. + */ + open( + fn: unknown, + request: { readonly component: string; readonly query: string | undefined }, + ): OpenedDestination | undefined; + /** End the route with its execution. */ + revoke(): void; +} + +/** + * Build this execution's route from what the host stated. + * + * `authenticated` is asked about each entry and answers with the implementation + * this execution's capture holds for it, or nothing. An entry nothing + * authenticated is left out — not refused, because a host may legitimately + * state a destination for a name a particular execution never resolved, and an + * execution that resolved it is the only one that can route it. + */ +export function createResultDestinationRoute( + installation: ResultDestinationInstallation | undefined, + authenticated: (entry: ResultDestinationEntry) => unknown, +): ResultDestinationRoute { + const owned = new Map(); + for (const entry of installation?.destinations ?? []) { + const implementation = authenticated(entry); + if (typeof implementation === "function") { + owned.set(implementation, entry); + } + } + // Keyed by the exact invocation object the engine minted, held weakly: a + // receiver's lifetime is its occurrence's, and nothing here keeps one alive. + const open = new WeakMap(); + let live = true; + + // Canonical resolution's own answers, each standing for the implementation it + // wraps. Weak, because a wrapper belongs to one import. + const aliases = new WeakMap(); + const held = (fn: unknown): ResultDestinationEntry | undefined => { + if (!live) { + return undefined; + } + const direct = owned.get(fn); + if (direct !== undefined) { + return direct; + } + const behind = typeof fn === "function" ? aliases.get(fn) : undefined; + return behind === undefined ? undefined : owned.get(behind); + }; + + const route: ResultDestinationRoute = { + owns(fn: unknown): boolean { + return held(fn) !== undefined; + }, + alias(wrapper: unknown, implementation: unknown): void { + if (live && typeof wrapper === "function" && owned.has(implementation)) { + aliases.set(wrapper, implementation); + } + }, + open(fn, request) { + const entry = held(fn); + if (entry === undefined) { + return undefined; + } + const destination = entry.open(request.query); + let usable = true; + let delivered = false; + let bound: ComponentInvocation | undefined; + const occurrence: ResultOccurrence = { + query: request.query, + *deliver(selected: unknown): Operation { + if (!usable || !live) { + throw new ResultDestinationError( + `<${request.component} /> has finished, so its result has nowhere to go.`, + ); + } + if (delivered) { + throw new ResultDestinationError( + `<${request.component} /> delivered its result more than once.`, + ); + } + delivered = true; + yield* destination.accept(selected); + }, + }; + destination.serves?.(occurrence); + return { + occurrence, + bind(invocation: ComponentInvocation): void { + if (!usable) { + return; + } + bound = invocation; + open.set(invocation, occurrence); + }, + close(): void { + usable = false; + if (bound !== undefined) { + open.delete(bound); + } + }, + }; + }, + revoke(): void { + live = false; + owned.clear(); + }, + }; + + installation?.installed?.((invocation: ComponentInvocation) => + live ? open.get(invocation) : undefined, + ); + return route; +} + +/** One occurrence's open destination, as canonical expansion holds it. */ +export interface OpenedDestination { + readonly occurrence: ResultOccurrence; + /** Tie this destination to the exact invocation the engine minted. */ + bind(invocation: ComponentInvocation): void; + /** End it, however the invocation settled. */ + close(): void; +} + +/** A result offered to a destination that is no longer there to take it. */ +export class ResultDestinationError extends Error { + constructor(message: string) { + super(message); + this.name = "ResultDestinationError"; + } +} diff --git a/packages/core/src/component-result.ts b/packages/core/src/component-result.ts new file mode 100644 index 000000000..626ac212e --- /dev/null +++ b/packages/core/src/component-result.ts @@ -0,0 +1,91 @@ +/** + * The one seam between what a component produced and what the document binds. + * + * An invocation's result travels a fixed route: the producer runs once, its own + * `returns` schema accepts what it produced, its invocation tears down and + * joins — and only then is there a value for anything to transform. This Api is + * where that transformation happens, and `yq` is the one the engine installs on + * it. + * + * Both canonical paths call it: a Markdown component that declares `returns`, a + * function component with or without one, and a Markdown body whose rendering + * is its result. One seam rather than two is what keeps "select before you + * bind" a property of the engine instead of a property of whichever producer + * somebody wrote. + * + * ## It transforms a value and decides nothing + * + * A handler receives the accepted result and the query the invocation asked + * for, and answers with the value to bind. That is all it can do. It cannot + * make a refused producer succeed, rescue a return the schema rejected, repair + * a cleanup that failed, reach the journal, or bind anything itself — by the + * time it is asked, acceptance has already happened and publication has not. + * + * Nothing durable is decided here either. Permission, durable identity, which + * occurrence a selected result belongs to and whether an append was + * acknowledged are each settled by the execution that owns them, from state no + * handler holds. A middleware answer is data. + * + * ## The terminal is the engine's own + * + * With no query the terminal answers with the same reference it was given, so + * an ordinary invocation binds exactly what it always did — by reference, + * including values JSON has no shape for. With a query it asks this execution's + * engine, which validates the result as JSON, evaluates the expression and + * validates the one answer as JSON. + */ + +import { type Api, createApi } from "@effectionx/context-api"; +import type { Operation } from "effection"; + +import { useValueQuery } from "./value-query.ts"; + +/** The key canonical core publishes the result seam under. */ +const COMPONENT_RESULT_KEY = "executablemd.core.component-result"; + +/** What an invocation produced, and what it asked to be done with it. */ +export interface ComponentResultRequest { + /** The authored tag name, for a diagnostic that has to say where. */ + readonly component: string; + /** The result the producer's own contract already accepted. */ + readonly value: unknown; + /** The `yq` expression the invocation wrote, when it wrote one. */ + readonly query?: string; +} + +/** + * The value an invocation's accepted result becomes. + * + * Composable like every other contextual Api: a handler may read the request, + * transform what the terminal answers, refuse by throwing, and delegate with + * `yield* next(request)`. What it returns is the value — which is why it is + * data and not authority. + */ +export interface ComponentResultApi { + result(request: ComponentResultRequest): Operation; +} + +export const ComponentResult: Api = createApi( + COMPONENT_RESULT_KEY, + { + *result(request: ComponentResultRequest): Operation { + if (request.query === undefined) { + return request.value; + } + const queries = yield* useValueQuery(); + return yield* queries.select(request.query, request.value); + }, + }, +); + +/** + * The value to bind for one accepted result. + * + * Called by canonical expansion after acceptance and teardown and before + * binding, publication or presentation. An invocation that wrote no `yq` still + * crosses it, because a consumer composing around results composes around all + * of them rather than only the queried ones. + */ +export function componentResult(request: ComponentResultRequest): Operation { + return ComponentResult.operations.result(request); +} diff --git a/packages/core/src/components/Json.ts b/packages/core/src/components/Json.ts index 402e31063..ad36cb8e1 100644 --- a/packages/core/src/components/Json.ts +++ b/packages/core/src/components/Json.ts @@ -31,26 +31,23 @@ * * ## One call, and two ways it can fail * - * `JSON.stringify` runs once. It is never called again to describe a failure, - * because the value can carry a getter or a `toJSON` hook the document does not - * own, and asking twice would run somebody else's code twice. + * The serialization is `json-serialization.ts`'s, which `` describes the + * same value through: one call, never repeated to explain a failure, because + * the value can carry a getter or a `toJSON` hook the document does not own. * - * Its two failures are different facts and stay separate. Returning something - * that is not a string means the value has no JSON text at all — root - * `undefined`, a function, a symbol — while a thrown exception means + * Its two failures are different facts and stay separate here. Returning + * something that is not a string means the value has no JSON text at all — + * root `undefined`, a function, a symbol — while a thrown exception means * serialization started and could not finish: a `bigint`, a cycle, or a hook * that threw. The thrown value is preserved as `cause` exactly as it arrived, * and neither the error nor the rejected value is interpolated into the * message. - * - * Native `JSON.stringify` decides everything else — property enumeration, - * nested `undefined`/function/symbol omission, non-finite numbers, `toJSON`, - * supported built-ins. This restates none of it and normalizes none of it. */ import type { Operation } from "effection"; import { capture, hasCapture, hasContent } from "../component-api.ts"; import { printErrors } from "../component-failures.ts"; +import { serializeJson } from "./json-serialization.ts"; export const props = { type: "object", @@ -81,14 +78,12 @@ export default printErrors(function* Json(): Operation { const value = yield* capture("value"); - let text: unknown; - try { - text = JSON.stringify(value, null, 2); - } catch (error) { - throw new JsonRenderError(THREW, { cause: error }); + const serialized = serializeJson(value); + if (serialized.kind === "threw") { + throw new JsonRenderError(THREW, { cause: serialized.cause }); } - if (typeof text !== "string") { + if (serialized.kind === "no-text") { throw new JsonRenderError(NO_TEXT); } - return text; + return serialized.text; }); diff --git a/packages/core/src/components/Yaml.ts b/packages/core/src/components/Yaml.ts new file mode 100644 index 000000000..ec567819b --- /dev/null +++ b/packages/core/src/components/Yaml.ts @@ -0,0 +1,90 @@ +/** + * `` — render a structured value as YAML text. + * + * ``'s sibling, and deliberately its exact shape: one supplied value to + * one piece of text, written where the element is or captured by `as`, with no + * option to choose. Rendering YAML is something a document asks for explicitly: + * nothing turns a value into YAML because it was captured, selected or + * displayed somewhere, and a selected binding stays data whatever renders it. + * + * ```md + * + * + * ``` + * + * The operand is a **capture**, so the exact evaluation result arrives by + * reference (§6.5), for the reason ``'s does: an ordinary prop would + * cross the component JSON boundary first and rewrite the value before this + * ever saw it. + * + * ## Shape is decided before the operand runs + * + * Content, then the syntactic presence of `value`, and only then the captured + * operand. An operand expression can call a getter or a function the author + * wrote, so a malformed invocation costs nothing — and a failure is atomic: + * nothing is captured, nothing is rendered, and the diagnostic names `` + * at the position it was written. + * + * ## One serialization, then one evaluation + * + * The value is serialized once, through the same call `` describes it + * with (`json-serialization.ts`), and that text is handed to this execution's + * own engine under the identity expression. So the two components cannot + * disagree about what the value is, and `JSON.parse` of the one and a YAML + * parse of the other produce the same value. + * + * What comes back is the vendor's complete YAML document: two-space + * indentation, no document separators, scalars left quoted where their type + * depends on it, and one terminating newline. It is returned exactly as the + * engine produced it — appending a separator or a second newline would make the + * text this renders something the vendor never wrote, and quoting is what keeps + * the string `"false"` a string and a multiline string a block scalar that + * parses back whole. + */ + +import type { Operation } from "effection"; +import { capture, hasCapture, hasContent } from "../component-api.ts"; +import { printErrors } from "../component-failures.ts"; +import { useValueQuery } from "../value-query.ts"; +import { serializeJson } from "./json-serialization.ts"; + +export const props = { + type: "object", + properties: {}, + additionalProperties: false, +}; + +/** An invocation `` cannot render, or a value it cannot turn into text. */ +export class YamlRenderError extends Error { + constructor(message: string, options?: ErrorOptions) { + super(message, options); + this.name = "YamlRenderError"; + } +} + +const CONTENT = " renders the value it is given, not content: write ."; +const MISSING = " requires a `value` prop: write ."; +const NO_TEXT = " serialization produced no JSON text for this value."; +const THREW = " serialization of this value failed."; + +export default printErrors(function* Yaml(): Operation { + if (yield* hasContent()) { + throw new YamlRenderError(CONTENT); + } + if (!(yield* hasCapture("value"))) { + throw new YamlRenderError(MISSING); + } + + const value = yield* capture("value"); + + const serialized = serializeJson(value); + if (serialized.kind === "threw") { + throw new YamlRenderError(THREW, { cause: serialized.cause }); + } + if (serialized.kind === "no-text") { + throw new YamlRenderError(NO_TEXT); + } + + const queries = yield* useValueQuery(); + return yield* queries.yaml(serialized.text); +}); diff --git a/packages/core/src/components/component-resolution.ts b/packages/core/src/components/component-resolution.ts index b067d6377..10926cd1f 100644 --- a/packages/core/src/components/component-resolution.ts +++ b/packages/core/src/components/component-resolution.ts @@ -660,6 +660,27 @@ export class CanonicalImports { * its forms is offered under is on the copy, because it is the definition's * own. */ + /** + * The name a provider published this exact object for, if it published it. + * + * Exact-object authentication and nothing else: an object this owner never + * recorded answers `undefined`, however many members it shares with one that + * was published. The name it comes back with is what *this* owner recorded at + * publication, so a caller holding a published definition can find the row + * canonical execution produced for it rather than matching a spelling. + * + * It grants nothing. Knowing which name an object was published for is not + * permission to invoke it, to publish another, or to reach the copy behind + * it — that copy stays with `identify`, which requires the resolution window + * the publication happened in. + */ + publishedName(answer: unknown): string | undefined { + if (!this.#active || typeof answer !== "object" || answer === null) { + return undefined; + } + return this.#answers.get(answer)?.name; + } + identify(resolution: ResolutionWindow, answer: unknown): IdentifiedAnswer | undefined { if (!this.#active || typeof answer !== "object" || answer === null) { return undefined; diff --git a/packages/core/src/components/components.md b/packages/core/src/components/components.md index a63a87642..c2039ac5c 100644 --- a/packages/core/src/components/components.md +++ b/packages/core/src/components/components.md @@ -317,6 +317,23 @@ Writes the JSON where the element is written, or binds it with `as`. The counterpart of ``: this turns a value into text, that turns text into a value. +## Yaml + +Renders a value as YAML text. + +```mdx + +``` + +Writes the YAML where the element is written, or binds it with `as`. Json's +sibling: the same value, the same place, a different text. Nothing else turns a +value into YAML — a binding a `yq` expression selected stays data until this +element renders it. + +Scalars are quoted where their type depends on it, so the YAML parses back to +the value that went in: the string `"false"` stays a string and a multiline +string stays whole. + ## Parse Parses JSON text against a schema, and errors on invalid content. diff --git a/packages/core/src/components/json-serialization.ts b/packages/core/src/components/json-serialization.ts new file mode 100644 index 000000000..94a4d2d52 --- /dev/null +++ b/packages/core/src/components/json-serialization.ts @@ -0,0 +1,40 @@ +/** + * The one native serialization `` and `` both describe a value + * through. + * + * Both components answer the same question about the operand they were handed — + * what is this value's JSON text — and they must answer it the same way, from + * one call. The operand can carry a getter, a `toJSON` hook or a `Proxy` the + * document does not own, so serializing twice would run somebody else's code + * twice and could produce two different readings of one value. + * + * So the call happens here, once, and what comes back is the outcome rather + * than the text: the two ways it can fail are different facts about the value + * and each caller says so in its own words. Returning something that is not a + * string means the value has no JSON text at all — root `undefined`, a + * function, a symbol — while a thrown exception means serialization started and + * could not finish: a `bigint`, a cycle, or a hook that threw. The thrown value + * travels exactly as it arrived so a caller can keep it as `cause`. + * + * Native `JSON.stringify` decides everything else — property enumeration, + * nested `undefined`/function/symbol omission, non-finite numbers, `toJSON`, + * supported built-ins. This normalizes none of it, and adds no trailing + * newline. + */ + +/** What the one serialization call produced. */ +export type JsonSerialization = + | { readonly kind: "text"; readonly text: string } + | { readonly kind: "no-text" } + | { readonly kind: "threw"; readonly cause: unknown }; + +/** Serialize one operand, exactly once, with two-space indentation. */ +export function serializeJson(value: unknown): JsonSerialization { + let text: unknown; + try { + text = JSON.stringify(value, null, 2); + } catch (cause) { + return { kind: "threw", cause }; + } + return typeof text === "string" ? { kind: "text", text } : { kind: "no-text" }; +} diff --git a/packages/core/src/components/registry.ts b/packages/core/src/components/registry.ts index dce48adfc..dcf8486bf 100644 --- a/packages/core/src/components/registry.ts +++ b/packages/core/src/components/registry.ts @@ -37,6 +37,7 @@ import Glob, { returns as globReturns, } from "./Glob.ts"; import Json, { props as jsonProps } from "./Json.ts"; +import Yaml, { props as yamlProps } from "./Yaml.ts"; import Parse, { props as parseProps, returns as parseReturns } from "./Parse.ts"; import SafeParse, { props as safeParseProps, returns as safeParseReturns } from "./SafeParse.ts"; import Test, { props as testProps } from "./Test.ts"; @@ -254,6 +255,19 @@ export const CORE_REGISTRY: ComponentRegistry = new Map([ }, { captures: ["value"], forms: ["self-closing"] }, ), + core( + "Yaml", + Yaml, + parseJsonObject(yamlProps), + { + description: + "Render a value as YAML text. `` writes the YAML where you " + + "put it. Nothing else turns a value into YAML.", + as: "Optional. Captures the YAML text instead of emitting it.", + context: null, + }, + { captures: ["value"], forms: ["self-closing"] }, + ), core( "Parse", Parse, diff --git a/packages/core/src/document-validation.ts b/packages/core/src/document-validation.ts index 27c1318d7..2040e4297 100644 --- a/packages/core/src/document-validation.ts +++ b/packages/core/src/document-validation.ts @@ -54,6 +54,7 @@ import { asBindingViolation, asExpressionViolation, capturedBinding, + ENGINE_OWNED_PROPS, returnCaptureViolation, } from "./invocation-rules.ts"; import type { IdentityComponent } from "./invocation-identity.ts"; @@ -1084,8 +1085,8 @@ class ValidationState { ); } - // `slot` and `as` are the engine's, and a declared capture is handed over - // unresolved — none of the three meets the schema, during execution or here. + // `slot`, `as` and `yq` are the engine's, and a declared capture is handed + // over unresolved — none of them meets the schema, during execution or here. const statics = schemaVisible(segment.props, contract.captures); const dynamics = schemaVisible(segment.expressions, contract.captures); @@ -1398,17 +1399,23 @@ function positionOf(segment: ComponentElement): { position?: Readonly( written: Record, captures: readonly string[], ): Record { const captured = new Set(captures); + const owned = new Set(ENGINE_OWNED_PROPS); const visible: Record = {}; for (const [key, value] of Object.entries(written)) { - if (key === "slot" || key === "as" || captured.has(key)) { + if (owned.has(key) || captured.has(key)) { continue; } visible[key] = value; diff --git a/packages/core/src/execute.ts b/packages/core/src/execute.ts index f826a0d41..3de013125 100644 --- a/packages/core/src/execute.ts +++ b/packages/core/src/execute.ts @@ -33,6 +33,13 @@ import { createReplayStream } from "./replay-stream.ts"; import { ExecutionProtocolError, issueExecution } from "./execution-request.ts"; import { DocumentProtocolError, issueDocument } from "./document-request.ts"; import { claimBoundExec } from "./bound-exec.ts"; +import { createValueQuery, ValueQueryContext } from "./value-query.ts"; +import { createResultDestinationRoute } from "./component-result-destinations.ts"; +import type { + ResultDestinationInstallation, + ResultDestinationRoute, +} from "./component-result-destinations.ts"; +import type { ValueQueryOwner } from "./value-query.ts"; import type { DocumentSettlement, IssuedDocument } from "./document-request.ts"; import type { DocumentRequest, DurablePreparation } from "./document-request.ts"; import { @@ -2151,6 +2158,8 @@ function* runValueRoot( importTerminal: ComponentImportTerminal, /** This execution's own root publisher, for the captures the body may bind. */ publications: RootBindingPublications | undefined, + /** This execution's own destinations, for the results they may receive. */ + destinations: ResultDestinationRoute | undefined, ): Operation { // Created outside the scope the body runs in, so the value it selected is // still readable after that scope — and its teardown — has finished. @@ -2182,6 +2191,7 @@ function* runValueRoot( environment, importTerminal, publications, + destinations, ownBody, ); const exactRecord = environment.sourceSegments; @@ -2239,6 +2249,14 @@ function* documentWorkflow( * be handing in an environment this root had not created yet. */ publicationMode: RootBindingPublicationMode | undefined, + /** + * Where a result this host owns a destination for may go. + * + * The execution's own route, handed over beside the root owner and for the + * same reason: it is not something the environment describes, and nothing a + * document, a component or middleware can name reaches it. + */ + destinations: ResultDestinationRoute, ): Workflow { // This run's memory of a checked command failure it never authorized. Passed // by value into core's own expansion and reachable from nowhere else, so no @@ -2338,6 +2356,19 @@ function* documentWorkflow( const rootPath = ""; const scopedExpansion: Operation = scoped(function* () { + // This execution's own `yq` engine, selected before anything can ask for + // one. Lazy, so a document that writes neither `yq` nor `` decodes + // and compiles nothing; installed above `roots.activate()` so the generated + // roots this execution evaluates reach the same owner its own elements do, + // while a concurrent execution reaches a different one. The release is + // registered before the owner exists, so an engine that arrives after this + // scope ended answers nobody. + let queries: ValueQueryOwner | undefined; + yield* ensure(() => { + queries?.close(); + }); + queries = createValueQuery(); + yield* ValueQueryContext.set(queries); // Before any authored work, and in this scope rather than outside // `durableRun`: this is the scope `Execution.document` has already // installed the document's runtime services in — its Agent provider, its @@ -2389,6 +2420,7 @@ function* documentWorkflow( environment, importTerminal, publications, + destinations, ); } @@ -2414,6 +2446,7 @@ function* documentWorkflow( environment, importTerminal, publications, + destinations, undefined, ); // An empty buffered root emits no output event. @@ -2444,6 +2477,7 @@ function* documentWorkflow( environment, importTerminal, publications, + destinations, undefined, ); @@ -2610,6 +2644,15 @@ export interface HostExecution extends DocumentExecution { */ interface ComponentAssembly { readonly startingRegistry: ComponentRegistry; + /** + * Where a result this host owns a destination for may go. + * + * Part of the assembly because it is the same capture: an entry names the + * exact definition this execution's `componentAnswers` path published, so the + * route and the implementations a generated root may invoke are settled + * together rather than reconciled afterwards. + */ + readonly destinations: ResultDestinationRoute; readonly bundle: WorkflowComponentCatalog | undefined; readonly catalog: ExecutionDeclarationCatalog; readonly installedComponents: InstalledComponents | undefined; @@ -2666,6 +2709,8 @@ function* assembleComponents( documentation: readonly DocumentationContribution[], canonicalImports: CanonicalImports, lifetime: EvaluationLifetime, + /** The destinations this host stated, copied before any installation ran. */ + resultDestinations: ResultDestinationInstallation | undefined, ): Operation { // The paths *this capture* resolves against, copied: the selection below is // resolved against the environment the host assembled, and a later edit to @@ -2803,6 +2848,40 @@ function* assembleComponents( identity.componentRouting.project, ); + // Built here, from the two things that settle it: the host's own entries, and + // what this execution's capture actually published. An entry is authenticated + // by the exact object the provider published — never by the name it was + // published under — and the row it then routes to is the sealed + // implementation canonical capture produced, so a definition the capture + // never saw reaches no destination. + const captured = [ + ...(evaluationProfile?.composition ?? []), + ...(evaluationProfile?.read ?? []), + ...(evaluationProfile?.write ?? []), + ]; + const destinations = createResultDestinationRoute(resultDestinations, (entry) => { + if ("definition" in entry) { + // Authenticated by the exact object the provider published — never by the + // name it was published under. The row it then routes to is the sealed + // implementation canonical capture produced, so a definition the capture + // never saw reaches no destination. + const name = canonicalImports.publishedName(entry.definition); + return name === undefined + ? undefined + : captured.find((held) => held.name === name)?.definition.fn; + } + // A name this host selected and did not publish: core's own tier answered + // it, so core is what resolves which implementation that is. The origin on + // the captured row is where that answer came from, and only core's own + // qualifies — a name a provider published has a destination belonging to + // whoever published it rather than to whoever selected it. + const held = captured.find((row) => row.name === entry.selected); + return held?.origin === CORE_ORIGIN ? held.definition.fn : undefined; + }); + yield* ensure(() => { + destinations.revoke(); + }); + return { startingRegistry, bundle, @@ -2813,6 +2892,7 @@ function* assembleComponents( imports, describe, evaluationProfile, + destinations, }; } @@ -3206,6 +3286,7 @@ function* executeDocument( componentRouting: identity.componentRouting, reference: derivedSyntax, live: profile.live, + destinations: assembly.destinations, }); roots.supply({ journal, evaluator: bound }); @@ -3227,6 +3308,7 @@ function* executeDocument( initialBindings, roots, publicationMode, + assembly.destinations, ), ); try { @@ -3475,6 +3557,16 @@ export interface ExecutionInstallation { * installation's origin. */ readonly componentAnswers?: readonly ComponentAnswerInstallation[]; + /** + * Where this host's own results may go, for the components it published. + * + * Read once and copied before any installation runs, like the admissions + * beside it, so what may receive a result is fixed before installed code, + * middleware or document code exists. Each entry names the exact definition + * this host published through its own `componentAnswers` request; an entry + * naming anything else routes nothing. + */ + readonly resultDestinations?: ResultDestinationInstallation; install?(): Operation; } @@ -4084,6 +4176,26 @@ function* invoke( ), ); + // Read once, here, with the admissions and the declarations: a destination a + // host added from inside its own `install()` would be one nothing captured, + // and a member that answered differently on a second reading would let a host + // be tested for one destination and install another. One installation states + // them; two stating destinations is a composition nothing here resolves, so + // the first is the one that is read. + const statedDestinations = installations.flatMap((installation) => + installation.resultDestinations === undefined ? [] : [installation.resultDestinations], + ); + const resultDestinations = Object.freeze( + statedDestinations.length === 0 + ? undefined + : { + destinations: Object.freeze([...(statedDestinations[0]?.destinations ?? [])]), + ...(statedDestinations[0]?.installed === undefined + ? {} + : { installed: statedDestinations[0].installed.bind(statedDestinations[0]) }), + }, + ); + // The lifetime every captured generated implementation is held to, opened // and armed before a single `install()` runs — so what a capture retains is // revoked however the execution ends, including when it is halted partway @@ -4172,6 +4284,7 @@ function* invoke( documentation, canonicalImports, lifetime, + resultDestinations, ); // Whatever a handler returns is not an execution, so it is not read. diff --git a/packages/core/src/expand.ts b/packages/core/src/expand.ts index e03385bd8..3c391feb5 100644 --- a/packages/core/src/expand.ts +++ b/packages/core/src/expand.ts @@ -65,6 +65,9 @@ import { asBindingViolation, asExpressionViolation, capturedBinding, + ENGINE_OWNED_PROPS, + queriedExpression, + queryExpressionViolation, returnCaptureViolation, } from "./invocation-rules.ts"; import { interpolate } from "./interpolate.ts"; @@ -145,7 +148,9 @@ import type { Workflow } from "@executablemd/durable-streams"; import { SchemaValidationError, validateProps, validateReturnValue } from "./validate.ts"; import { isJsonObject, parseJson } from "./json.ts"; import { bindRootCapture } from "./root-binding-publications.ts"; +import { componentResult } from "./component-result.ts"; import type { RootBindingPublications } from "./root-binding-publications.ts"; +import type { ResultDestinationRoute } from "./component-result-destinations.ts"; import { healSegment } from "./heal.ts"; import { scanSegments } from "./scanner.ts"; import { declareChildAnswers, expandAnswers, strayAnswerError } from "./answers.ts"; @@ -292,6 +297,7 @@ function expandChildrenScoped( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { return scoped(function* () { @@ -317,6 +323,7 @@ function expandChildrenScoped( environment, imports, publications, + destinations, returnBody, ); }); @@ -387,6 +394,7 @@ interface ProjectionState { narrowedSyntax: SyntaxReference | undefined; imports: ComponentImportTerminal | undefined; publications: RootBindingPublications | undefined; + destinations: ResultDestinationRoute | undefined; } interface ProjectionFrame { @@ -536,6 +544,7 @@ function createProjectionHandle(state: ProjectionState): ProjectionHandle { state.environment, state.imports, state.publications, + state.destinations, options.returnFrame, ); outcome.resolve({ segments: rendered }); @@ -650,6 +659,7 @@ function createProjectionHandle(state: ProjectionState): ProjectionHandle { state.environment, state.imports, state.publications, + state.destinations, request.kind === "markdown" ? undefined : state.callerReturn, ); outcome.resolve({ segments: [...errors, ...rendered] }); @@ -856,9 +866,11 @@ export function expandSegments( checkedFailures, environment, // No execution terminal: an expansion driven directly resolves its imports - // through the ordinary public Component Api, exactly as it always has. And - // no root publisher: an expansion with no execution has no root environment - // of an execution's to publish for. + // through the ordinary public Component Api, exactly as it always has. No + // root publisher: an expansion with no execution has no root environment of + // an execution's to publish for. And no destinations: a result has nowhere + // to go that an execution did not state. + undefined, undefined, undefined, undefined, @@ -942,6 +954,7 @@ function* expandListSegments( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { // An execution opens the table its printed errors record their causes in. @@ -967,6 +980,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); }); @@ -1090,6 +1104,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, )), ); @@ -1112,6 +1127,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, )), ); @@ -1135,6 +1151,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); break; @@ -1170,6 +1187,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); break; @@ -1190,6 +1208,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); break; @@ -1213,6 +1232,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); // Which state this is, answered by identity rather than by name: @@ -1261,6 +1281,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); break; @@ -1300,6 +1321,7 @@ function* expandListSegments( environment, imports, publications, + destinations, ); break; } @@ -1354,6 +1376,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); break; @@ -1378,6 +1401,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ); // A printed error the callee produced is data, and stays data here: it @@ -1524,6 +1548,7 @@ function* expandListSegments( environment, imports, publications, + destinations, returnBody, ), ); @@ -1588,6 +1613,7 @@ function* checkedCommandFailure( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { // Written down before it is raised or projected, and before the error mode is @@ -1695,6 +1721,7 @@ function* expandLet( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { // Every one of these is decided from what the author wrote, so the whole @@ -1729,6 +1756,7 @@ function* expandLet( environment, imports, publications, + destinations, returnBody, ), ); @@ -1843,6 +1871,7 @@ function* expandEach( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { return yield* structural(segment, path, () => work()); @@ -1907,6 +1936,7 @@ function* expandEach( environment, imports, publications, + destinations, returnBody, ); // A `` in the body exits the enclosing ``, so the remaining @@ -2036,6 +2066,7 @@ function* expandIf( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { return yield* structural(segment, path, () => work()); @@ -2113,6 +2144,7 @@ function* expandIf( environment, imports, publications, + destinations, returnBody, ); }; @@ -2194,6 +2226,7 @@ function* expandSwitch( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { return yield* structural(segment, path, () => work()); @@ -2269,6 +2302,7 @@ function* expandSwitch( environment, imports, publications, + destinations, returnBody, ), ); @@ -2348,6 +2382,7 @@ function* expandLoop( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { return yield* structural(segment, path, () => work()); @@ -2410,6 +2445,7 @@ function* expandLoop( environment, imports, publications, + destinations, returnBody, ); if (frame.broken) { @@ -2535,6 +2571,7 @@ function spawnChild( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, ): Operation { return scoped(function* () { yield* provideEnv(spawnEnvironment(incoming)); @@ -2568,6 +2605,7 @@ function spawnChild( environment, imports, publications, + destinations, undefined, ), ); @@ -2615,6 +2653,7 @@ function* expandAll( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, ): Operation { return yield* structural(segment, path, () => work()); @@ -2646,6 +2685,7 @@ function* expandAll( environment, imports, publications, + destinations, ), ); @@ -2750,6 +2790,7 @@ function* expandPrintErrors( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { const refusal = printErrorsViolations(segment)[0]; @@ -2778,6 +2819,7 @@ function* expandPrintErrors( environment, imports, publications, + destinations, returnBody, ); }); @@ -2818,6 +2860,7 @@ function* expandComponent( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { // Surrounded before resolution, props validation or any body: what an @@ -2996,6 +3039,7 @@ function* expandComponent( environment, imports, publications, + destinations, returnBody, selected, dispatcher, @@ -3042,6 +3086,7 @@ function* expandComponent( // expansion engine for slot assignment, not forwarded to the child. let validatedProps: Record; let asBinding: string | undefined; + let query: string | undefined; try { const refused = asBindingViolation(name, resolvedProps.as); if (refused !== undefined) { @@ -3049,7 +3094,17 @@ function* expandComponent( } asBinding = capturedBinding(resolvedProps.as); - const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps; + // Consumed before the producer's own closed schema is checked, and before + // its body runs: a component with `additionalProperties: false` accepts an + // invocation that selected out of its result without ever seeing that it + // did, and a `yq` that is not a string refuses with no effect performed. + const unusable = queryExpressionViolation(name, resolvedProps.yq); + if (unusable !== undefined) { + throw new Error(unusable.message); + } + query = queriedExpression(resolvedProps.yq); + + const { slot: _slot, as: _as, yq: _yq, ...propsForValidation } = resolvedProps; validatedProps = yield* validateProps(name, propsForValidation, definition.props); } catch (error) { return [yield* raise(schemaValidationErrorSegment(error, name))]; @@ -3157,6 +3212,7 @@ function* expandComponent( environment, imports, publications, + destinations, }); // Published on the eval scope, which every task the invocation owns // descends from — including its persist-eval blocks and its content. @@ -3233,6 +3289,7 @@ function* expandComponent( bodyEnvironment, imports, publications, + destinations, returnBody, ); }, observed.settled); @@ -3258,11 +3315,27 @@ function* expandComponent( }), ]; } - yield* bindRootCapture(publications, parentEnv, asBinding, value, position); + // The returned value is accepted and the invocation has joined, so this is + // where a query may transform it. No expression repairs the schema above + // or the cleanup that just finished, and a refusal here binds nothing. + let selected: unknown; + try { + selected = yield* componentResult({ component: name, value, query }); + } catch (error) { + const fatal = fatalCause(error); + if (fatal !== undefined) { + throw fatal; + } + return [yield* raise(schemaValidationErrorSegment(error, name))]; + } + yield* bindRootCapture(publications, parentEnv, asBinding, selected, position); return []; } - const bodyOwner = asBinding === undefined ? owner : undefined; + // A queried rendering is buffered like a captured one. Emitting the raw text + // into the caller's region and then querying a copy would show the reader + // the text the selection was meant to replace. + const bodyOwner = asBinding === undefined && query === undefined ? owner : undefined; // Where this body's own segments start, so what it renders can be told apart // from what the caller had already produced into the same array. const renderedFrom = bodyOwner?.length ?? 0; @@ -3283,6 +3356,7 @@ function* expandComponent( bodyEnvironment, imports, publications, + destinations, returnBody, ); }, observed.settled); @@ -3298,14 +3372,21 @@ function* expandComponent( // binds instead. Recording it here — against the segments this body produced, // after it produced them — is what carries the fact to the emission loop, // which is outside every scope the invocation owned. - if (authorizedCanonically && environment?.installedComponents?.declaresExact(name) === true) { + // + // A selection replaces the rendering with a value of its own, so a queried + // invocation contributes no source segments to mark. + if ( + query === undefined && + authorizedCanonically && + environment?.installedComponents?.declaresExact(name) === true + ) { markExactSource( environment?.sourceSegments, bodyOwner === undefined ? expanded : bodyOwner.slice(renderedFrom), ); } - if (asBinding) { + if (asBinding !== undefined || query !== undefined) { // A capture never swallows an error. The body reported these where they // were created (§6.9) — including the ones a string projection rendered // away — so they are handed back as they are and the binding stays unset. @@ -3319,6 +3400,27 @@ function* expandComponent( return errors; } + let selected: unknown; + try { + selected = yield* componentResult({ + component: name, + value: renderSegments(expanded), + query, + }); + } catch (error) { + const fatal = fatalCause(error); + if (fatal !== undefined) { + throw fatal; + } + return [yield* raise(schemaValidationErrorSegment(error, name))]; + } + if (asBinding === undefined) { + // Queried and uncaptured: the selected value is what this element + // renders. A string renders as itself and anything else renders + // nothing, which is the rule an uncaptured result already follows. + return typeof selected === "string" ? [{ type: "text", content: selected }] : []; + } + const parentEnv = yield* env; if (!parentEnv) { return [ @@ -3329,13 +3431,7 @@ function* expandComponent( }), ]; } - yield* bindRootCapture( - publications, - parentEnv, - asBinding, - renderSegments(expanded), - position, - ); + yield* bindRootCapture(publications, parentEnv, asBinding, selected, position); return []; } @@ -3466,6 +3562,7 @@ function* expandFunctionComponent( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, /** * The identity domain canonical resolution selected for this invocation. @@ -3503,7 +3600,14 @@ function* expandFunctionComponent( // Captures are the engine's to hand over unresolved, like `slot` and `as` are // the engine's to consume: they never meet the JSON gate below, and never // appear in `validatedProps`. - const captured = new Set(definition.captures ?? []); + // The engine's own props never become a component's captures. `as`, `slot` + // and `yq` are consumed here, so a declaration naming one of them would + // otherwise intercept the prop the engine is about to act on. + const captured = new Set( + (definition.captures ?? []).filter( + (declared) => !(ENGINE_OWNED_PROPS as readonly string[]).includes(declared), + ), + ); const literalCaptures: Record = {}; const expressionCaptures: Record = {}; const openProps: Record = {}; @@ -3553,8 +3657,16 @@ function* expandFunctionComponent( return [yield* raise({ type: "error", message: asRefused.message, source: name })]; } const asBinding = capturedBinding(resolvedProps.as); + // Consumed before the producer's own closed schema is checked and before its + // body runs, so a `yq` that is not a string refuses with no effect performed + // and a closed props schema never sees the prop at all. + const unusableQuery = queryExpressionViolation(name, resolvedProps.yq); + if (unusableQuery !== undefined) { + return [yield* raise({ type: "error", message: unusableQuery.message, source: name })]; + } + const query = queriedExpression(resolvedProps.yq); const owner = asBinding === undefined ? callerOwner : undefined; - const { slot: _slot, as: _as, ...propsForValidation } = resolvedProps; + const { slot: _slot, as: _as, yq: _yq, ...propsForValidation } = resolvedProps; let validatedProps: Record; try { @@ -3564,8 +3676,20 @@ function* expandFunctionComponent( } const returns = definition.returns; - const missingCapture = returnCaptureViolation(name, returns !== undefined, asBinding); + // Opened before required-as is decided, because a genuine execution-owned + // destination is the one thing that can satisfy an already-authorized + // uncaptured return: the host that published this exact definition said where + // its result goes, so the result is not being discarded. A tag name, a + // returns schema, a `yq` expression, a public option and a Context value each + // say nothing here — only the route this execution built from what the host + // stated before any document code ran. + const designated = destinations?.open(definition.fn, { component: name, query }); + const missingCapture = + designated === undefined + ? returnCaptureViolation(name, returns !== undefined, asBinding) + : undefined; if (missingCapture !== undefined) { + designated?.close(); return [yield* raise({ type: "error", message: missingCapture.message, source: name })]; } @@ -3650,6 +3774,11 @@ function* expandFunctionComponent( ) : undefined) ?? issueInvocation(expansion.id, name, selected, frame, !selfClosing, dispatcher); + // Tied to the exact object the engine minted for this occurrence, which + // is what the host's own body presents when it asks which occurrence it + // is in. Two same-named controls in one response are two invocations + // and therefore two receivers. + designated?.bind(issued.invocation); const dispatchBody = (body: Operation) => environment?.invokeGeneratedComponent === undefined ? body @@ -3680,6 +3809,7 @@ function* expandFunctionComponent( environment, imports, publications, + destinations, }; // Only the ordinary handle is published. The richer projection a // protected body may reach stays a closure at the dispatch below, so @@ -3886,13 +4016,28 @@ function* expandFunctionComponent( returns === undefined ? output : yield* validateReturnValue(name, parseJson(output), returns); - yield* bindRootCapture(publications, parentEnv, asBinding, captured, position); + // The invocation has joined and its own contract has accepted what it + // produced, so this is where a query may transform it. + const selected = yield* componentResult({ component: name, value: captured, query }); + yield* bindRootCapture(publications, parentEnv, asBinding, selected, position); + // After the capture and whatever publication it owed, which is the + // order a reader of the history depends on: a destination holding a + // value the capture never retained would describe work this run did not + // finish. Capturing a designated result does not switch its destination + // off — a reply may both use the value where it asked and be told it. + if (designated !== undefined) { + yield* designated.occurrence.deliver(selected); + } return []; } // Without `as` there is nowhere to bind, so only text can be observed: // a string renders, and anything else renders nothing rather than being // stringified into the document. - return typeof output === "string" ? [{ type: "text", content: output }] : []; + const rendered = yield* componentResult({ component: name, value: output, query }); + if (designated !== undefined) { + yield* designated.occurrence.deliver(rendered); + } + return typeof rendered === "string" ? [{ type: "text", content: rendered }] : []; } catch (error) { // Everything below runs after `withInvocation()` has dismantled the // invocation, so what is handled here accounts for the body and its @@ -4039,7 +4184,16 @@ function* expandFunctionComponent( } return produced; } - return yield* accepted(); + try { + return yield* accepted(); + } finally { + // Revoked however the occurrence settled — completed, failed or cancelled. + // A receiver kept from a finished invocation answers for nothing, which is + // what keeps a late or retained reference from filing under an occurrence + // that is over. Synchronous, so it is in place before anything else can be + // asked about this invocation. + designated?.close(); + } } /** @@ -4539,6 +4693,7 @@ export function* expandBody( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { if (!bodyHasOutput(bodySegments)) { @@ -4556,6 +4711,7 @@ export function* expandBody( environment, imports, publications, + destinations, returnBody, ); } @@ -4580,6 +4736,7 @@ export function* expandBody( environment, imports, publications, + destinations, returnBody, ); } else if (chunk.output) { @@ -4598,6 +4755,7 @@ export function* expandBody( environment, imports, publications, + destinations, returnBody, ); }); @@ -4618,6 +4776,7 @@ export function* expandBody( environment, imports, publications, + destinations, returnBody, ); }); @@ -4648,6 +4807,7 @@ function runDocumentation( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { return scoped(function* () { @@ -4665,6 +4825,7 @@ function runDocumentation( environment, imports, publications, + destinations, returnBody, ); }); @@ -4719,6 +4880,7 @@ function* expandValueBody( environment: ExecutionEnvironment | undefined, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { const slots = partitionBySlot(children); @@ -4747,6 +4909,7 @@ function* expandValueBody( environment, imports, publications, + destinations, ownBody, ); } @@ -4790,6 +4953,7 @@ function* expandInstalledStructural( environment: ExecutionEnvironment, imports: ComponentImportTerminal | undefined, publications: RootBindingPublications | undefined, + destinations: ResultDestinationRoute | undefined, returnBody: ReturnBody | undefined, ): Operation { const name = segment.name; @@ -4893,6 +5057,7 @@ function* expandInstalledStructural( environment, imports, publications, + destinations, returnBody, children: segment.children, }); @@ -4947,6 +5112,7 @@ interface RegionContext { readonly environment: ExecutionEnvironment; readonly imports: ComponentImportTerminal | undefined; readonly publications: RootBindingPublications | undefined; + readonly destinations: ResultDestinationRoute | undefined; readonly returnBody: ReturnBody | undefined; readonly children: Segment[]; } @@ -5113,6 +5279,7 @@ function* produceRegion( context.environment, context.imports, context.publications, + context.destinations, context.returnBody, ); } catch (error) { diff --git a/packages/core/src/generated-xmd.ts b/packages/core/src/generated-xmd.ts index 67e296693..90a3bfcb3 100644 --- a/packages/core/src/generated-xmd.ts +++ b/packages/core/src/generated-xmd.ts @@ -168,7 +168,8 @@ import { } from "./structural-rules.ts"; import type { StructuralViolation } from "./structural-rules.ts"; import { installFormSyntax, invocationForm } from "./invocation-identity.ts"; -import type { FormSyntax, ComponentRouting } from "./invocation-identity.ts"; +import type { FormSyntax, ComponentRouting, InvocationForm } from "./invocation-identity.ts"; +import type { ResultDestinationRoute } from "./component-result-destinations.ts"; import type { ComponentInvocation } from "./invocation-identity.ts"; import type { SyntaxReference } from "./syntax-reference.ts"; import { useNarrowedSyntax } from "./syntax-api.ts"; @@ -418,6 +419,16 @@ export interface GeneratedObservation { */ export const JSON_COMPOSITION_IDENTITY = "https://executable.md/components/json"; +/** + * Core's ``, on the same terms. + * + * Rendering a value the fragment already holds performs nothing, so Yaml is + * trusted composition rather than an effect and carries no read or write form + * for an owner to offer. Its own identity, because an admission that reused + * Json's would say a fragment had been granted the other component. + */ +export const YAML_COMPOSITION_IDENTITY = "https://executable.md/components/yaml"; + /** * Core's own ``, as the evaluator admits it. * @@ -494,6 +505,21 @@ export function pinnedJson(): CompositionEntry { return { name: "Json", identity: JSON_COMPOSITION_IDENTITY, definition }; } +/** + * Core's ``, admitted as trusted composition beside ``. + * + * The exact core definition, so a same-name replacement anywhere reaches + * nothing here, and self-closing alone, because `` refuses content of its + * own and the refusal belongs in preflight rather than inside the component. + */ +export function pinnedYaml(): CompositionEntry { + const definition = CORE_REGISTRY.get("Yaml")?.default?.definition; + if (definition === undefined || definition.kind !== "function") { + throw new GeneratedXmdError("core supplies no Yaml component to admit."); + } + return { name: "Yaml", identity: YAML_COMPOSITION_IDENTITY, definition }; +} + /** * The always-on trusted composition table. * @@ -501,9 +527,39 @@ export function pinnedJson(): CompositionEntry { * fragment's vocabulary by omitting it, and cannot add an effect to the table * by naming one. A trusted host that wants another pure component states its * exact definition, which is a different act from this one. + * + * Adding Yaml here widens what new source may write and widens no retained + * grant: a continuation is compared against the composition set its own + * admission recorded, so a history admitted when Json was the whole table + * reopens under that table and gains nothing. */ export function coreComposition(): readonly CompositionEntry[] { - return [pinnedJson()]; + return [pinnedJson(), pinnedYaml()]; +} + +/** + * One pure component every generated evaluation may write, as a describer reads it. + * + * Name and spelling only. A host describing the vocabulary a response may write + * needs to say that the always-on table exists and what is in it, and it must + * not have to restate the list — a hand-kept copy is a description that starts + * out true and drifts. Nothing callable and no identity crosses: this is what + * is admitted, not permission to invoke it. + */ +export interface CompositionVocabulary { + readonly name: string; + /** The one spelling the composition table admits, which is self-closing. */ + readonly form: InvocationForm; +} + +/** The always-on composition table, as a describer reads it. */ +export function coreCompositionVocabulary(): readonly CompositionVocabulary[] { + return Object.freeze( + coreComposition().map((entry): CompositionVocabulary => { + const described: CompositionVocabulary = { name: entry.name, form: "self-closing" }; + return Object.freeze(described); + }), + ); } /** @@ -725,6 +781,14 @@ export interface GeneratedRootBinding { readonly reference: SyntaxReference | undefined; /** Whether the captured implementations still belong to a live execution. */ readonly live: () => boolean; + /** + * Where a result this execution's host owns a destination for may go. + * + * The execution's own route, which is why it arrives here rather than on the + * request: a root is evaluated by the execution that captured the selection + * it runs under, and a destination belongs to the same capture. + */ + readonly destinations: ResultDestinationRoute | undefined; } /** @@ -740,6 +804,7 @@ interface ResolvedRoot { readonly componentRouting: ComponentRouting; readonly reference: SyntaxReference | undefined; readonly live: () => boolean; + readonly destinations: ResultDestinationRoute | undefined; } /** @@ -945,7 +1010,13 @@ class GeneratedComponentResolution implements ComponentResolution { return true; } - constructor(named: readonly Planned[], componentRouting?: ComponentRouting) { + readonly #destinations: ResultDestinationRoute | undefined; + + constructor( + named: readonly Planned[], + componentRouting?: ComponentRouting, + destinations?: ResultDestinationRoute, + ) { const planned = new Map>(); for (const invocation of named) { const byForm = planned.get(invocation.name) ?? new Map(); @@ -954,6 +1025,7 @@ class GeneratedComponentResolution implements ComponentResolution { } this.#planned = planned; this.#componentRouting = componentRouting; + this.#destinations = destinations; } /** The answer canonical execution produces for this name. */ @@ -993,6 +1065,10 @@ class GeneratedComponentResolution implements ComponentResolution { return yield* implementation(props, invocation); }, }; + // Said where the answer is produced: the expansion site holds this wrapper + // and cannot see the implementation underneath it, so this is the only + // place that can tell a destination route the two are one component. + this.#destinations?.alias(admitted.fn, implementation); this.#invocations.set(admitted.fn, byForm); // The wrapper above is the answer to the import; the dispatcher underneath // it is the form dispatcher. Remembered by name so `verify` can record it @@ -1085,6 +1161,8 @@ function selection(allow: readonly GeneratedEffectClass[] | undefined): Generate function selectedEntries( request: GeneratedFragmentRequest, allow: readonly GeneratedEffectClass[], + /** The composition table to admit, which a continuation reads off its own record. */ + composition: readonly CompositionEntry[] = coreComposition(), ): Entry[] { const entries: Entry[] = []; // One kept reading per definition object, so a name admitted for two @@ -1093,13 +1171,13 @@ function selectedEntries( // Before either effect table and under every selection: composition is not a // class `allow` chooses between, so its entries are in the policy the same // way whatever the caller asked for, and in one canonical position. - for (const composition of coreComposition()) { + for (const pure of composition) { entries.push({ - name: composition.name, + name: pure.name, // Core's own, and the one admitted identity not read off an owner's // generated metadata: a pure component offers no effect to declare. - identities: new Map([["self-closing", composition.identity]]), - definition: composition.definition, + identities: new Map([["self-closing", pure.identity]]), + definition: pure.definition, forms: ["self-closing"], kind: "capability", effect: "composition", @@ -1568,6 +1646,33 @@ function readNamed(value: Json): RetainedInvocation[] | undefined { return named; } +/** + * The composition table a retained admission was made under, or `undefined` + * when it is the one this build already offers. + * + * Core's always-on table is a fact about the build rather than about the grant + * a host stated, so a record written before a pure component existed holds no + * row for it. Holding such a record to today's table would refuse a + * continuation for a row its own fragment never named, and adding the row to it + * would widen a grant nobody reviewed. So a continuation reopens under exactly + * the composition rows its own admission retained — read through the same + * reader every other term is read with — while new source is admitted under the + * current table. + * + * A retained row this build no longer supplies is left out, which makes the + * comparison below fail: a grant naming a component that is gone is stale + * rather than reconstructible. + */ + +function retainedComposition(retained: Policy): readonly CompositionEntry[] | undefined { + const identities = new Set( + retained.allowed.filter((row) => row.effect === "composition").map((row) => row.identity), + ); + const current = coreComposition(); + const historical = current.filter((entry) => identities.has(entry.identity)); + return historical.length === current.length ? undefined : historical; +} + /** * Whether a resumed run still holds the grant the retained admission was made * under. @@ -2323,6 +2428,14 @@ function expand( * its own owner outside the expansion. */ owner: Segment[] | undefined, + /** + * Where a result this execution's host owns a destination for may go. + * + * A root's is its execution's own route, narrowed to nothing a fragment + * receives: `` in a document asked for a rendering, not for + * somebody's operation to be answered. + */ + destinations: ResultDestinationRoute | undefined, ): Operation { return scoped(function* () { // A root selects what it renders, so a failure inside it renders as the @@ -2358,7 +2471,7 @@ function expand( // trusted-document evaluator. Set on this scope, so it ends with the // fragment and reaches nothing the document expands afterwards. yield* GeneratedDataExpressions.set(true); - const resolution = new GeneratedComponentResolution(named, componentRouting); + const resolution = new GeneratedComponentResolution(named, componentRouting, destinations); yield* Component.around( { // deno-lint-ignore require-yield @@ -2415,6 +2528,10 @@ function expand( // A fragment writes an environment of its own, so it has no root // capture to publish and no root publisher to be given one. undefined, + // Where a result the host owns a destination for goes. A root's is its + // execution's own; a fragment is given none, because `` in a + // document asked for a rendering rather than for somebody's operation. + destinations, undefined, ); return renderSegments(owner ?? []); @@ -2437,6 +2554,7 @@ function expand( // And no root publisher: a fragment's locals are its own, and a name it // binds is not something a later entry inherits. undefined, + destinations, // A generated fragment is the engine's own text, so it owns no value body // and a written into it satisfies no declaration. undefined, @@ -2498,37 +2616,13 @@ function* evaluateGenerated( resolved?: ResolvedRoot, ): Operation { const allow = selection(request.allow); - const entries = selectedEntries(request, allow); - const table = admitted(entries); - const policy = currentPolicy(allow, entries); - // A fragment's pair arrives already narrowed, from the protected site - // canonical `` holds. A root's is derived here. - let narrowed = componentRouting; - let reference = syntax; - if (resolved !== undefined) { - if (!resolved.live()) { - throw new GeneratedXmdError(REVOKED_IMPLEMENTATIONS); - } - // Seeded with the exact implementations this root admitted. Closed rather - // than revoked, and registered before anything expands: cleanups - // registered later unwind first, so the route outlives every body inside - // it and a wrapper kept past this root answers for nothing while the - // execution stays open for the next one. - const route = resolved.componentRouting.narrow(entries.map((entry) => entry.definition.fn)); - yield* ensure(() => { - route.close(); - }); - narrowed = route; - // Narrowing is the reference's own operation, exactly as a fragment's is, - // and for the same reason: what this source may *write* is its admitted - // table, while what it may *read about* is the vocabulary its execution - // captured — every bootstrapped package's chapter included, each entry - // reported with its availability here. - // The captured entries this root was selected from, which is the shape - // `admittedSymbols` already describes an evaluation's vocabulary with — the - // same call the authored site makes, so one description mechanism answers - // for both kinds. - reference = resolved.reference?.available(admittedSymbols(resolved.describing)); + let entries = selectedEntries(request, allow); + let table = admitted(entries); + let policy = currentPolicy(allow, entries); + // Asked before anything is recorded: an execution whose implementations are + // gone admits nothing rather than appending an admission it cannot perform. + if (resolved !== undefined && !resolved.live()) { + throw new GeneratedXmdError(REVOKED_IMPLEMENTATIONS); } const stored = yield* persistAdmission( @@ -2555,6 +2649,19 @@ function* evaluateGenerated( CONSTRUCT[decided.construct], ); } + // Core's always-on composition table is a build fact rather than a grant a + // host stated, so a retained admission reopens under the rows it recorded + // rather than under today's. What that changes is both halves at once: the + // comparison below is against the historical set, and the table this + // continuation may *name* is that set too — so a record written before a pure + // component existed is neither refused for a row it never named nor quietly + // widened to include one. + const historical = retainedComposition(decided.policy); + if (historical !== undefined) { + entries = selectedEntries(request, allow, historical); + table = admitted(entries); + policy = currentPolicy(allow, entries); + } // Before a single component is invoked or a single effect is performed: a // retained admission is a grant whose selected spellings, identities, // effects and classes must be stated exactly again. A run that moved any of @@ -2570,6 +2677,35 @@ function* evaluateGenerated( throw new GeneratedXmdError(STALE_TEXT); } + // A fragment's pair arrives already narrowed, from the protected site + // canonical `` holds. A root's is derived here, from the entries + // reconciliation settled — so what this source may invoke is exactly what it + // may name rather than whatever today's table happens to hold. + let narrowed = componentRouting; + let reference = syntax; + if (resolved !== undefined) { + // Seeded with the exact implementations this root admitted. Closed rather + // than revoked, and registered before anything expands: cleanups + // registered later unwind first, so the route outlives every body inside + // it and a wrapper kept past this root answers for nothing while the + // execution stays open for the next one. + const route = resolved.componentRouting.narrow(entries.map((entry) => entry.definition.fn)); + yield* ensure(() => { + route.close(); + }); + narrowed = route; + // Narrowing is the reference's own operation, exactly as a fragment's is, + // and for the same reason: what this source may *write* is its admitted + // table, while what it may *read about* is the vocabulary its execution + // captured — every bootstrapped package's chapter included, each entry + // reported with its availability here. + // The captured entries this root was selected from, which is the shape + // `admittedSymbols` already describes an evaluation's vocabulary with — the + // same call the authored site makes, so one description mechanism answers + // for both kinds. + reference = resolved.reference?.available(admittedSymbols(resolved.describing)); + } + // The retained source is what expands, so a continuation runs exactly the // bytes this run admitted rather than a caller's copy of them. const restored = yield* preflight(request.id, decided.source, table, language); @@ -2588,6 +2724,7 @@ function* evaluateGenerated( narrowed, reference, rendering?.owner, + resolved?.destinations, ); } @@ -2710,6 +2847,7 @@ function* evaluateRoot( componentRouting: binding.componentRouting, reference: binding.reference, live: binding.live, + destinations: binding.destinations, }, ); }); diff --git a/packages/core/src/invocation-rules.ts b/packages/core/src/invocation-rules.ts index 3564627ef..96161eff9 100644 --- a/packages/core/src/invocation-rules.ts +++ b/packages/core/src/invocation-rules.ts @@ -65,6 +65,51 @@ export function capturedBinding(value: Json | undefined): string | undefined { return binding.ok ? binding.value : undefined; } +/** + * The props the engine consumes rather than hands to a component. + * + * `slot` places projected content, `as` names a binding, and `yq` selects out + * of what the invocation produced. None of them is a component's to declare or + * to receive: each is stripped before the component's own closed props schema + * is checked, so a producer with `additionalProperties: false` accepts an + * invocation that wrote one without ever seeing it. + */ +export const ENGINE_OWNED_PROPS = ["slot", "as", "yq"] as const; + +/** + * What a `yq` that is not an expression says. + * + * Unlike `as`, which names a binding and is therefore held to a string literal, + * `yq` is a value the document may compute: an expression that produces the + * expression. So the rule is about the value rather than about the syntax, and + * it is asked of whatever value its caller has — expansion asks it of the + * resolved prop and validation asks it of the literal the author wrote, which + * is why a dynamic one is not statically checkable rather than invalid. + * + * The empty string is a string. What an empty expression means belongs to the + * engine's own dialect, and inventing a second answer here would be a second + * grammar. + */ +export function queryExpressionViolation( + name: string, + value: Json | undefined, +): StructuralViolation | undefined { + return value === undefined || typeof value === "string" + ? undefined + : { + code: "props-invalid", + source: name, + message: + `Prop "yq" on <${name} /> must be a string holding a yq expression, got ` + + `${value === null ? "null" : Array.isArray(value) ? "array" : typeof value}.`, + }; +} + +/** The expression a well-formed `yq` names, or `undefined` when it names none. */ +export function queriedExpression(value: Json | undefined): string | undefined { + return typeof value === "string" ? value : undefined; +} + /** * A component that declares `returns` renders nothing, so an invocation that * captures nothing would discard the only thing it produces. diff --git a/packages/core/src/structural-rules.ts b/packages/core/src/structural-rules.ts index 98113d461..6adc4f72b 100644 --- a/packages/core/src/structural-rules.ts +++ b/packages/core/src/structural-rules.ts @@ -36,7 +36,8 @@ export type StructuralViolationCode = | "structural-usage-invalid" | "binding-invalid" | "capture-invalid" - | "return-usage-invalid"; + | "return-usage-invalid" + | "props-invalid"; /** One thing a construct's source got wrong. */ export interface StructuralViolation { diff --git a/packages/core/src/value-query.ts b/packages/core/src/value-query.ts new file mode 100644 index 000000000..33cd0e99e --- /dev/null +++ b/packages/core/src/value-query.ts @@ -0,0 +1,259 @@ +/** + * One execution's own `yq` engine, and the two questions it answers. + * + * A shared `yq` attribute selects data out of what a component returned, and + * `` renders a value as a YAML document. Both are the same engine asking + * the same vendor the same way, so both live here rather than in the two places + * that call them. + * + * ## The engine belongs to the execution, and starts when it is wanted + * + * `yq.rs` publishes a root entry that compiles embedded WebAssembly and + * instantiates a singleton while that module is evaluated. Importing it would + * start a compilation in every process that loads core, for every document, + * including the ones that query nothing. So core imports `yq.rs/loader`, which + * instantiates nothing by itself, and supplies the bytes from its own generated + * module (`yq-wasm.ts`). + * + * The owner below is built once per document execution and compiles on the + * first question asked of it. A document that writes neither `yq` nor `` + * decodes nothing and compiles nothing; one that writes three of them compiles + * once; and a second execution gets a second owner, because an engine shared + * across executions would outlive the one that paid for it. Nothing here is + * module-global: no engine, no pending initialization, no registry and no + * result cache. + * + * ## A halted first consumer does not publish + * + * `until()` adapts a promise and does not cancel it, so halting the coroutine + * that started the initialization leaves the vendor's own compilation running to + * completion. What halting does stop is the continuation: the suspended consumer + * never resumes, so it binds nothing, publishes nothing and appends nothing. The + * resolved engine stays on the owner for whoever asks next, and the owner is + * revoked with its execution — an owner kept past teardown refuses rather than + * answering from a finished run. + * + * ## The vendor is asked with no ambient inputs + * + * Every evaluation supplies an empty environment, an empty file map and a fixed + * instant. `env(NAME)` therefore reports that the variable was not provided, + * `load(path)` that the file was not provided, and `now` answers + * `1970-01-01T00:00:00Z` — so an expression a document or an agent wrote cannot + * read this host's environment, its filesystem or its clock through the engine. + * + * ## One answer, read whole + * + * `evaluateWithStatus` is what selection uses, because `evaluate` throws for the + * vendor status that `null` and `false` produce — and those are values a + * document may legitimately select. `matched` takes no part in acceptance for + * the same reason. + * + * The answer is parsed whole. A `yq` expression may produce no results or + * several, and the vendor prints several as several JSON documents in one + * answer: reading the first, or splitting the text into lines, would turn + * "these two things matched" into "this one thing matched" and would cut a + * multiline string in half. So the whole answer is one JSON value or the + * invocation refuses, and the refusal names the way to ask for several. + */ + +import { createContext, until } from "effection"; +import type { Operation } from "effection"; +import { createYq } from "yq.rs/loader"; +import type { EvalOptions, Yq } from "yq.rs/loader"; + +import { parseJson } from "./json.ts"; +import type { Json } from "./types.ts"; +import { YQ_WASM_BASE64 } from "./yq-wasm.ts"; + +/** The instant the engine reports for `now`, in place of this host's clock. */ +const FIXED_NOW = "1970-01-01T00:00:00Z"; + +/** What every evaluation supplies, whatever it is being asked. */ +const SHARED: EvalOptions = { + unwrapScalar: false, + printDocSeparators: false, + indent: 2, + env: {}, + files: {}, + now: FIXED_NOW, +}; + +/** Selection reads JSON and answers in JSON. */ +const SELECT: EvalOptions = { ...SHARED, inputFormat: "json", outputFormat: "json" }; + +/** Rendering reads JSON and answers in YAML. */ +const RENDER: EvalOptions = { ...SHARED, inputFormat: "json", outputFormat: "yaml" }; + +/** The identity expression, which is what rendering asks for. */ +const IDENTITY = "."; + +/** What an invocation is told when its expression did not produce one value. */ +export const ONE_VALUE = + "This yq expression must return one JSON value. Collect matches into an array with [ ... ]."; + +/** A `yq` expression that could not be evaluated, or an answer with no one value. */ +export class ValueQueryError extends Error { + constructor(message: string, options?: ErrorOptions) { + super(message, options); + this.name = "ValueQueryError"; + } +} + +/** The questions one execution's engine answers. */ +export interface ValueQuery { + /** + * The one JSON value `expression` selects out of `value`. + * + * `value` is the result a component actually returned, validated as JSON and + * serialized for the engine — so a component that returned text is queried as + * a JSON string, and an expression that wants the data inside it decodes it + * explicitly with `from_json` or `from_yaml`. + */ + select(expression: string, value: unknown): Operation; + /** + * The complete YAML document for one piece of JSON text. + * + * The text is the operand's own single serialization, so `` and + * `` describe the same value through the same one call into it. + */ + yaml(json: string): Operation; +} + +/** How an owner reaches a vendor engine for the bytes it was given. */ +export type EngineFactory = (bytes: Uint8Array) => Promise; + +/** + * The generated bytes, decoded. + * + * Decoded inside initialization rather than at module evaluation: the encoded + * string is source data, and a document that asks nothing of the engine pays + * for neither the decode nor the compile. + * + * Decoding is in bounded slices because `String.fromCharCode(...bytes)` over + * four hundred thousand arguments overflows the call stack on every runtime + * this ships to. + */ +function decode(): Uint8Array { + const binary = atob(YQ_WASM_BASE64); + const bytes = new Uint8Array(binary.length); + for (let at = 0; at < binary.length; at++) { + bytes[at] = binary.charCodeAt(at); + } + return bytes; +} + +/** One execution's owner, revoked with the execution that built it. */ +export interface ValueQueryOwner extends ValueQuery { + /** Make this owner unusable, and release what it was holding. */ + close(): void; +} + +/** + * Build the owner for one document execution. + * + * The factory is an argument so a test can hold an initialization open and + * observe what a halted consumer does with it. Production passes none and gets + * the pinned loader. + */ +export function createValueQuery(factory: EngineFactory = createYq): ValueQueryOwner { + // The one pending initialization this owner will ever start. Stored before + // the first consumer suspends, so a second consumer arriving while the first + // is waiting shares it instead of starting a second compilation. + let pending: Promise | undefined; + let live = true; + + function* engine(): Operation { + if (!live) { + throw new ValueQueryError( + "This execution has ended, so its yq engine is no longer available.", + ); + } + pending ??= factory(decode()); + const ready = yield* until(pending); + // Read again after the suspension: an owner revoked while the vendor was + // compiling must not answer from the engine that arrived afterwards. + if (!live) { + throw new ValueQueryError( + "This execution has ended, so its yq engine is no longer available.", + ); + } + return ready; + } + + return { + *select(expression: string, value: unknown): Operation { + const input = JSON.stringify(parseJson(value)); + const yq = yield* engine(); + + let answer: string; + try { + answer = yq.evaluateWithStatus(expression, input, SELECT).output; + } catch (error) { + throw new ValueQueryError( + `This yq expression could not be evaluated: ${ + error instanceof Error ? error.message : String(error) + }`, + { cause: error }, + ); + } + + // The whole answer, or nothing. An empty answer is no results, and an + // answer that is not one JSON value is the vendor printing several — both + // are the same thing to an invocation that binds one value, and neither + // contributes a partial reading of what did match. + if (answer.trim() === "") { + throw new ValueQueryError(ONE_VALUE); + } + let parsed: unknown; + try { + parsed = JSON.parse(answer); + } catch (error) { + throw new ValueQueryError(ONE_VALUE, { cause: error }); + } + return parseJson(parsed); + }, + + *yaml(json: string): Operation { + const yq = yield* engine(); + try { + return yq.evaluateWithStatus(IDENTITY, json, RENDER).output; + } catch (error) { + throw new ValueQueryError( + `This value could not be rendered as YAML: ${ + error instanceof Error ? error.message : String(error) + }`, + { cause: error }, + ); + } + }, + + close(): void { + live = false; + pending = undefined; + }, + }; +} + +/** + * Which engine answers here. + * + * A stable namespaced name, so a separately loaded copy of core reaches the + * engine the execution installed rather than starting one of its own. It routes + * and permits nothing: what an expression may read is decided by the empty + * environment and file map every evaluation supplies, not by who answered. + * + * There is no default. An expansion driven with no execution behind it has no + * engine, and `yq` and `` say so rather than reaching for host state. + */ +export const ValueQueryContext = createContext("executablemd.core.value-query"); + +/** The engine in scope, or the refusal for an execution that installed none. */ +export function* useValueQuery(): Operation { + const selected = yield* ValueQueryContext.get(); + if (selected === undefined) { + throw new ValueQueryError( + "This execution has no yq engine, so `yq` and are unavailable here.", + ); + } + return selected; +} diff --git a/packages/core/src/yq-vendor-notices/LICENSE b/packages/core/src/yq-vendor-notices/LICENSE new file mode 100644 index 000000000..fbd037447 --- /dev/null +++ b/packages/core/src/yq-vendor-notices/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2026 Taras Mankovski + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/packages/core/src/yq-vendor-notices/THIRD_PARTY_NOTICES.md b/packages/core/src/yq-vendor-notices/THIRD_PARTY_NOTICES.md new file mode 100644 index 000000000..2e165f824 --- /dev/null +++ b/packages/core/src/yq-vendor-notices/THIRD_PARTY_NOTICES.md @@ -0,0 +1,878 @@ +# Third-party notices + +yq.rs includes or derives from the projects below. The project-level MIT +license in `LICENSE` covers original yq.rs contributions; upstream licenses +and notices remain applicable to their respective portions. These notices +apply to the Rust source and to distributed native and WebAssembly binaries, +including the npm package. + +The complete upstream license texts are reproduced below so this notice is +self-contained in published packages. Separate copies are retained under +`licenses/` in the Rust crate (`crates/yq-core/licenses/` in the repository). Development-only Cargo dependencies retain their own licenses and +attribution in their published source packages. + +## saphyr-parser 0.2.2 + +Source: https://github.com/saphyr-rs/saphyr at commit +`b8205d5f60ea44f757f7d075fe4f3704bbe5dccc` (`parser/`). + +Scope: `crates/yq-core/src/yaml/saphyr/` contains a vendored and modified copy +of saphyr-parser. yq.rs modifications integrate the parser with the local +module layout and add go-yaml-compatible comment handling and parsing +behavior. The go-yaml-derived portions also carry the notices in the next +section. + +License: MIT OR Apache-2.0 for both Chen Yuheng's original work and +Ethiraric's later modifications. All four upstream license files are +retained, together with the upstream license-selection notice. The files +referenced by the vendored `LICENSE` are also retained in its `.licenses/` +directory; the vendored notice corrects two upstream relative-link typos. + +### saphyr-parser upstream LICENSE + +```text +Code up to and including commit `da52a68615f2ecdd6b7e4567019f280c433c1521` is licensed by Chen Yuheng under either of: + - [Apache License, Version 2.0](.licenses/ChenYuheng-Apache) (http://www.apache.org/licenses/LICENSE-2.0) + - [MIT License](./licenses/ChenYuheng-MIT) (http://opensource.org/licenses/MIT) + +Code modifications starting with commit `1d71a23b151dcc12b289d0f06d8207dd9c764216` (included) are licenced by Ethiraric under either of: + - [Apache License, Version 2.0](.licenses/Ethiraric-Apache) (http://www.apache.org/licenses/LICENSE-2.0) + - [MIT License](./licenses/Ethiraric-MIT) (http://opensource.org/licenses/MIT) + +Redistributions of this Work must include licenses of both Chen Yuheng and Ethiraric. +``` + +### ChenYuheng-MIT + +```text +The MIT License (MIT) + +Copyright (c) 2015 Chen Yuheng + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +``` + +### ChenYuheng-Apache + +```text +Copyright (c) 2015 Chen Yuheng + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS +``` + +### Ethiraric-MIT + +```text +The MIT License (MIT) + +Copyright (c) 2023 Ethiraric + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +``` + +### Ethiraric-Apache + +```text +Copyright (c) 2023 Ethiraric + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS +``` + +## go-yaml v4 and libyaml + +Source: https://github.com/yaml/go-yaml at commit +`1c17b9cee72bf81ae73a8be50fbd7dd3a9985125` (`go.yaml.in/yaml/v4`). + +Scope: Rust ports and adaptations of the upstream YAML emitter, scalar +resolver, node composition, and comment scanner/parser behavior in +`crates/yq-core/src/yaml/emitter.rs`, `resolve.rs`, `decode.rs`, `encode.rs`, +and the modified `saphyr/scanner.rs`, `saphyr/parser.rs`, +`saphyr/char_traits.rs`, and `saphyr/input/`. These files were translated +from Go to Rust and adapted to yq.rs's arena, parser events and host-free +engine; they are not unchanged upstream files. + +License: Apache-2.0 for go-yaml contributions, together with MIT for portions +ported from libyaml. The upstream ported files carry +`SPDX-License-Identifier: Apache-2.0 AND MIT`. The complete go-yaml LICENSE +and NOTICE follow, including the copyright holders for both layers. + +The historical go-yaml v3.0.1 LICENSE is also reproduced verbatim to retain +the full MIT permission text for the libyaml-derived portions. Its source is +https://github.com/go-yaml/yaml/blob/v3.0.1/LICENSE. Its historical Go +filenames correspond to `internal/libyaml/` in the v4 source. + +### go-yaml LICENSE + +```text + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 2025 - The go-yaml Project Contributors + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. +``` + +### go-yaml NOTICE + +```text +The following files were ported to Go from C files of libyaml, and thus are +still covered by their original MIT license, with the additional copyright +starting in 2011 when the project was ported over: + +- internal/libyaml/api.go +- internal/libyaml/emitter.go +- internal/libyaml/parser.go +- internal/libyaml/reader.go +- internal/libyaml/scanner.go +- internal/libyaml/writer.go +- internal/libyaml/yaml.go +- internal/libyaml/yamlprivate.go + +Copyright 2006-2010 Kirill Simonov +https://opensource.org/license/mit + +All the remaining project files are covered by the Apache license: + +Copyright 2011-2019 Canonical Ltd +Copyright 2025 The go-yaml Project Contributors +http://www.apache.org/licenses/LICENSE-2.0 +``` + +### Historical go-yaml/libyaml LICENSE + +```text + +This project is covered by two different licenses: MIT and Apache. + +#### MIT License #### + +The following files were ported to Go from C files of libyaml, and thus +are still covered by their original MIT license, with the additional +copyright staring in 2011 when the project was ported over: + + apic.go emitterc.go parserc.go readerc.go scannerc.go + writerc.go yamlh.go yamlprivateh.go + +Copyright (c) 2006-2010 Kirill Simonov +Copyright (c) 2006-2011 Kirill Simonov + +Permission is hereby granted, free of charge, to any person obtaining a copy of +this software and associated documentation files (the "Software"), to deal in +the Software without restriction, including without limitation the rights to +use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies +of the Software, and to permit persons to whom the Software is furnished to do +so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + +### Apache License ### + +All the remaining project files are covered by the Apache license: + +Copyright (c) 2011-2019 Canonical Ltd + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. +``` + +## mikefarah/yq + +Source: https://github.com/mikefarah/yq at commit +`a814ff5166040ec745a96bddd79ee31c3a548e83`. + +Scope: the lexer rules, parser/operator model, expression evaluation and +operator logic in `crates/yq-core/src/`, including YAML node and encoding +behavior derived from `pkg/yqlib`; the conformance scenario fixture +`crates/yq-core/tests/fixtures/scenarios.json` (`tests/fixtures/scenarios.json` +in the original checkout) and associated fixture documentation. +These are Rust ports/adaptations and exported test data from yq, with local +changes to support the arena-based evaluator and host-supplied options. + +License: MIT, Copyright (c) 2017 Mike Farah. + +### mikefarah/yq LICENSE + +```text +The MIT License (MIT) + +Copyright (c) 2017 Mike Farah + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. +``` + +## regex-lite 0.1.9 + +Source: https://github.com/rust-lang/regex at commit +`0c07fae444adf0802d84455e689f1143d2dd7790` (`regex-lite/`). + +Scope: Cargo dependency linked into yq-core and the distributed WebAssembly +module for regular-expression evaluation. This distribution uses its MIT +license option (upstream offers MIT OR Apache-2.0). + +### regex-lite LICENSE-MIT + +```text +Copyright (c) 2014 The Rust Project Developers + +Permission is hereby granted, free of charge, to any +person obtaining a copy of this software and associated +documentation files (the "Software"), to deal in the +Software without restriction, including without +limitation the rights to use, copy, modify, merge, +publish, distribute, sublicense, and/or sell copies of +the Software, and to permit persons to whom the Software +is furnished to do so, subject to the following +conditions: + +The above copyright notice and this permission notice +shall be included in all copies or substantial portions +of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF +ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED +TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A +PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT +SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION +OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR +IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER +DEALINGS IN THE SOFTWARE. +``` diff --git a/packages/core/src/yq-wasm.provenance.json b/packages/core/src/yq-wasm.provenance.json new file mode 100644 index 000000000..59cc84109 --- /dev/null +++ b/packages/core/src/yq-wasm.provenance.json @@ -0,0 +1,23 @@ +{ + "format": 1, + "package": "yq.rs", + "version": "0.1.0", + "asset": "dist/yq.wasm", + "bytes": 468387, + "sha256": "97252eddd0dd7c2d80c25f8b73aec0874af954ca77ea33d8eb892c0a845eac46", + "license": "MIT AND Apache-2.0", + "homepage": "https://github.com/taras/yq.rs#readme", + "runtimeExport": "yq.rs/loader", + "generator": "scripts/generate-yq-wasm.ts", + "encoded": "packages/core/src/yq-wasm.ts", + "notices": [ + { + "path": "yq-vendor-notices/LICENSE", + "sha256": "647c2da0124ded4c754c2dd65d5928d26b961f3f2fc96a953801e01ad4c88404" + }, + { + "path": "yq-vendor-notices/THIRD_PARTY_NOTICES.md", + "sha256": "1f2ef73819837f4a7553557f625ab4895c435038a95d404efb47b5fc7cfc4401" + } + ] +} diff --git a/packages/core/src/yq-wasm.ts b/packages/core/src/yq-wasm.ts new file mode 100644 index 000000000..3fb284ad6 --- /dev/null +++ b/packages/core/src/yq-wasm.ts @@ -0,0 +1,640 @@ +/** + * The pinned `yq.rs` WebAssembly module, base64-encoded as immutable source. + * + * Generated by `scripts/generate-yq-wasm.ts` from yq.rs@0.1.0's published + * `dist/yq.wasm` — 468387 bytes, SHA-256 + * `97252eddd0dd7c2d80c25f8b73aec0874af954ca77ea33d8eb892c0a845eac46`. + * `yq-wasm.provenance.json` records that attribution and + * `yq-vendor-notices/` carries the vendor's own license and notices. + * + * Do not edit. Regenerate with: + * + * ``` + * deno run --allow-all scripts/generate-yq-wasm.ts + * ``` + * + * This is source data and not a ready engine: nothing here decodes, compiles or + * instantiates anything. One execution's own lazy initialization decodes this + * string and hands the bytes to the loader (`value-query.ts`), so a document + * that queries nothing compiles nothing. + * + * The encoding is an array of lines joined back together because one literal of + * this length is a line nothing reads well. The decoded bytes are the same + * either way. + */ + +const LINES: readonly string[] = [ + "AGFzbQEAAAAB3AIrYAR/f39/AGACf38AYAN/f38AYAF/AGADf39/AX9gAn9/AX9gBX9/f39/AGABfwF/YAZ/f39/f38AYAh/f39/f39/fwBgBH9/f38Bf2AHf39/f39/fwBgBX9/f39/AX9gA39/fwF+YAZ/f39/f38Bf2AAAGAAAX9gBH5+f38BfmAEf39/fgBgAn9+AGAHf39/f39/fwF/YAp/f39/f39/f39/AGAEf35+fwBgBn9+f39/fwBgCX9/f39/f35+fgBgA39+fgBgA39/fgF/YAF/AX5gCX9/f39/f39/fwF/YAN+fn4BfmAGf39/fn9/AGADfn5/AX5gAn98AGANf39/f39/f39/f39/fwBgAn5+AX5gB39/f39+f38AYAN/f34AYAR/f35+AGAJf39/f39/f39/AGAOf39/f39/f39/f39/f38AYAR/fn5+AGAFf35+fn8AYAV/fn5+fgADkwiRCAMBAQMDAQIAAgECBQIUAggFAgoFAgICBQUBBAcDDwAAAgoHAAgCAQMBAAIEBw4OBgAOAQMPAgIABQoGBQMDAgQFBAIFAQELBQUFDA4MBAUEBQICAgUBAQwFBgYFBQMDBQMFAgUDCAcCBwcPBxcYBgECAgIKBQUFBQQFAhkFBQUFBQ8DAg0aAgABAhECGwMCDQUCAgEBAwEIAQMFBQMBAwEDAQMBBgAFAQEGEQUGBggAAQoCAQIcFQYCBgQCAQMCAQMDBwEBAwcHAgEBAQMCBwQCAQcBAQIIAgIDBwoCAQcBCgIEAQIIAgICBAcDAwMDAQIBAgEAAQEBAQUHAAMKBwUFBQUHAgEBBQMFAQEBBAUBAQEBBQEBBAQCAQYGCgQBAQEAABICAAQGAgAADgQCBQYDCgIDBQIDBQcKAAYCBAgGAAECAwMBAAoEAAELAgYGCAQICB0TCgUBAQAAAgABBgUBBAMABgUDAQUDAwkDAwMCAwMDAwIBAQMCAAMDAgIBAgICAgMFBQUFBQECAgECEQICCAAB", + "BR4KAgEDAAUDAQEFCwMBAgcBAQECAgUHAgMBAwUHAAcHAgcFAgEDBQQCAgIDBgIBCAEHAgEFAwIFAwMCAwECCgQFBwEBAQMDAwMBAwMHBwcBBwICBgIFEAAAABACBgoAAAEQABACBgcCDQ0NHw0HAwEFBAUEAQEBAQEAAAMBAQMDBwMBAQcBAgEIAwYLBgIMAAwBAgAGAQYIAAEBCgoEAAYCAgEBAAADAwMDAwYJAwEDAQUBAAEBAQMBAQEDAwMDAQcDAwMDAwcDAAQEAAALAAMDAQEABgsLBQACBRMgAgICCAMBAQoGAAMHBAQEBgEDCwMDAwgGBgAAAAALAiEFAwIFAwcDBwcBAQAAAgEDAgEHBwIBAQIEAgEAAAYAAgIKAgACAAgAAAEAAQELAgAAAAYAAAACBgAICAAACAAHAAgACAAAAAAAAAAABgAAAAAAAAAIBAAAAgAUAAAAAAAAAAAAAAAAAAACBQIAAAQAAwAHAAEIAAAAAAEiAAAABgAEAgAAAgAGAAAACAoAAAQEAAgAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIBAAgGAwEBAAAAAAAAAQABAAMAAAIDAAECBwMBAwAGAAMBIwAAAQAIAAAAAgAGAAYGAAAABwEAAwAAAAQICwEABggAAAEAAAYAAAAABxUABgAAAAMFAAMDCgEAJAABCgIACgIABgkJCgQGBgEJAAEGAgEIBAUFCQIJCgYFCCUSBgISAQAJCQAAAwYJCSYJCQkJCQkGBgkLAQkJCAkJCQkJAQEABgABAwMJAgQCAQUBJwACAgICAgABAAEEKBYpKhYTCAAADAICAAIABwwAAgYGCAQHAXABgQKBAgUDAQARBgkBfwFBgIDAAAsHYwcGbWVtb3J5AgAIeXFfYWxsb2MALAd5cV9ldmFsAC0QeXFfZXZhbF9zZXF1ZW5jZQAuE3lxX2V2YWxfd2l0aF9zdGF0dXMAMQd5cV9mcmVlADIOeXFfcmVzdWx0X2ZyZWUAMwnlAwEA", + "QQELgAILExg4RxNIWFtcX2GTApABqwGAAYAC6AL7A4QDhQOGA5QD/QP+A/8DgQSFBLUHmwPtB3x5fXR1lQXDBcYFywXPBdMF1QXYBe4F8QW7B3aUA6oGrAauBrUGtwa5BrsGvQaCArQHlAd+fn9/PD9AQTtQTU5PpgGBAv8B7QHvAfEB+QGHAj9AjQKOAo8CkAKRAogCiQKKAosChQKGAowCnAPKB8sHxAfFB9gH2AfYB94H3wfbB9sH2wfZB9kH2QfPB9AHzQfOB6kHqgemB6YHpgfTB9QH0QfSB9wH3QfVB9UH1QfxB/IH9Qf1B/MH9AecA4YEhwSIBDujB64FsAW3BbkFige6BegFvAXCBcUFxwXKBc0FzgXQBdIF1AXWBdcF2QXaBdsF3AXdBd8F4AXhBeIF5AXlBesF7QXwBfIF8wX1BfcF+QX6Bf8FgQaDBoUGiQaKBosGjgaPBpAGlQacBp8GmwagBqMGpQamBqcGqAapBqsGrQavBrAGsQayBrMGtAa2BrgGuga8Br4GwQbIBskGygbLBswGzgatBdAG0gbTBt0G4wbkBuYG6AbpBuoG7AbuBvEG8gbzBvYG+Qb/BoIHgweFB4YHiAeJB4sHjgf4BZAHkQeSB5UHmgecB6AHDAFSCsPYGJEIWwECfyAAKAIMIAAoAgQiAWtBGG4hAgNAIAIEQCABKAIAIAFBBGooAgAQASABQQxqKAIAIAFBEGooAgAQASACQQFrIQIgAUEYaiEBDAELCyAAKAIIIAAoAgAQAgsMACAAIAFBAUEBEDALDAAgACABQQRBGBAwCxkAIAAQBCAAKAIYIAAoAhwQBSAAQQxqEAQLVgEDfyAAKAIEIgMhASAAKAIIIQIDQCACBEAgASgCACABQQRqKAIAEAEgAUEMaigCACABQRBqKAIAEAEgAkEBayECIAFBGGohAQwBCwsgACgCACADEAILEAAgAEF/RwRAIAAgARABCwtfAQN/IwBBEGsiAyQAIANBCGogAkEBQQEQByAD", + "KAIIIQUgAygCDCEEIABBADYCCCAAIAQ2AgQgACAFNgIAIAIEQCACBEAgBCABIAL8CgAACyAAIAI2AggLIANBEGokAAvhAQIEfwF+IwBBEGsiBSQAIwBBEGsiBiQAIAVBBGoiBAJ/AkACQAJAIAOtIAGtfiIIQiCIpw0AIAinIgNBgICAgHggAmtLDQAgAw0BIAQgAjYCCCAEQQA2AgRBAAwDCyAEQQA2AgQMAQsgBkEIaiACIAMQiQEgBigCCCIHBEAgBCAHNgIIIAQgATYCBEEADAILIAQgAzYCCCAEIAI2AgQLQQELNgIAIAZBEGokACAFKAIIIQEgBSgCBEEBRgRAIAUoAgwaIAEQHAALIAAgBSgCDDYCBCAAIAE2AgAgBUEQaiQAC8MDAQR/IwBBMGsiAyQAIANBDGpB5JfDAEEBEAYgASACaiEGA0AgASAGRwRAAn8gASwAACICQQBOBEAgAkH/AXEhAiABQQFqDAELIAEtAAFBP3EhBCACQR9xIQUgAkFfTQRAIAVBBnQgBHIhAiABQQJqDAELIAEtAAJBP3EgBEEGdHIhBCACQXBJBEAgBCAFQQx0ciECIAFBA2oMAQsgBUESdEGAgPAAcSABLQADQT9xIARBBnRyciECIAFBBGoLIQECQAJAAkACQAJAAkACQAJAIAJBCWsOBQYEAQEFAAsgAkEiRg0BIAJB3ABGDQILIAJBIEkNBSADQQxqIAIQCQwHCyADQQxqQeDRwwBBAhAKDAYLIANBDGpBnL7DAEECEAoMBQsgA0EMakGevsMAQQIQCgwECyADQQxqQaC+wwBBAhAKDAMLIANBDGpBor7DAEECEAoMAgsgAyACNgIkIANBATYCLCADIANBJGo2AiggA0EYakHw0cMAIANBKGoQDCADKAIYIANBDGogAygCHCIFIAMoAiAQCiAFEAEMAQsLIANBDGpBIhAJIAAgAygCFDYCCCAAIAMpAgw3AgAgA0EwaiQAC+0BAQZ/IAAoAgghBSAAAn9BASAB", + "QYABSSIDDQAaQQIgAUGAEEkNABpBA0EEIAFBgIAESRsLIgcQKCAAKAIEIAVqIQICQCADRQRAIAFBP3FBgH9yIQMgAUEGdiEEIAFBgBBJBEAgAiADOgABIAIgBEHAAXI6AAAMAgsgAUEMdiEGIARBP3FBgH9yIQQgAUH//wNNBEAgAiADOgACIAIgBDoAASACIAZB4AFyOgAADAILIAIgAzoAAyACIAQ6AAIgAiAGQT9xQYB/cjoAASACIAFBEnZBcHI6AAAMAQsgAiABOgAACyAAIAUgB2o2AggLMAEBfyAAIAIQKCAAKAIIIQMgAgRAIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIC2EBAn8jAEEQayICJAAgACgCACEDQQkhAANAIAAgAmpBBmogA0EPcS0AiIRBOgAAIABBAWshACADQQR2IgMNAAsgAUEBQcSbwwBBAiAAIAJqQQdqQQkgAGsQSyACQRBqJAAL/gIBBn8gAkEBcQRAIAAgASACQQF2EAYPCyMAQRBrIgUkAAJAAkACQAJAAkACQAJAIAJBAXEEQCACQQF2IQMMAQsgAS0AACIDRQ0BIAEhBANAIARBAWohBwJAIAPAQQBIBEAgA0H/AXFBgAFGBEAgBiAHLwAAIgRqIQYgBCAHakECaiEEDAILIAcgA0EDcUEIeCIEQQV0QYCAgIAEcSAEQQd0ckEddmogA0EBdkECcWogA0ECdkECcWohBCAGRSAIciEIDAELIAcgA0H/AXEiA2ohBCADIAZqIQYLIAQtAAAiAw0AC0EAIQMgCCAGQRBJcQ0AIAZBAXQiA0EASA0ECyADDQELQQEhBEEAIQMMAQsgAxAbIgRFDQILIAVBADYCCCAFIAQ2AgQgBSADNgIAIAVBwNjAACABIAIQOUUNAkHo2MAAQdYAIAVBD2pB2NjAAEHA2cAAEDoACxA0AAtBARAcAAsgACAFKAIINgIIIAAgBSkCADcCACAFQRBqJAAL7wICAX8BfiMAQfAAayIHJAAg", + "B0EMaiAEQQEgBRtBASAEGyAFQQAgBBsQDgJ/AkACQCAHKAIMQX9GBEAgByAHLwAZOwE8IAcgBy0AGzoAPiAHLQAYIQQgBykCECEIDAELIAcgA0EAIAIbNgJsIAcgAkEBIAMbQQEgAhs2AmggB0HQAGogAEEBIAEbQQEgABsgAUEAIAAbIAdB6ABqQQEgB0EMahAPAn8gBygCUCIAQX9HBEAgByAHLwBlOwE8IAcgBy0AZzoAPiAHLQBkIQQgBykCXCEIIAAgBygCVBABQX8MAQsgByAHLwBhOwE8IAcgBy0AYzoAPiAHLQBgIQQgBykCWCEIIAcoAlQLIQUgB0EMahADIAVBf0cNAQsgByAEOgBIIAcgCDcDQCAHIAcvATw7AEkgByAHLQA+OgBLQQEMAQsgByAINwJEIAcgBTYCQEEAQQIgBEEBcRtBACAGGwsgB0FAaxAQIAdB8ABqJAALuQwCCn8BfiMAQaABayIDJAAgA0EAOgBCIANBAjYCPCADQQA7AUAgA0EANgIgIANCgICAgMAANwIYIANCgICAgHA3AiwgA0KAgICAwAA3AiQgA0GBBDsAQyADQRBqIAEgAhAUAkACQCADKAIUIgEEQCADKAIQIgIgAUHnssMAQQIQEkUNAQsgACADQRhqQTD8CgAADAELIANBJGohCCADQfgAaiACIAEQFSADKAKEASEBIAMoAoABIQIgAygCfCEHAn8gAygCeEEBRgRAIAAgATYCDCAAIAI2AgggACAHNgIEIABBfzYCAEF/DAELIANBMGohCiADIAc2AlAgAyACNgJIIAMgAiABQRhsaiIHNgJUIANB/ABqIQYDQAJAIAMgAiAHRwR/IAJBGGohASACKAIAIgtBf0cNASABBSAHCzYCTCADQcgAahAAIAAgA0EYakEw/AoAAAwDCyACKAIEIQwgAikCBCENIAMgAkEMaiIFKAIINgJgIAMgBSkCADcDWAJAAkACQAJAAkACQAJAIA2nIgIgDUIgiKciBEGG1cAA", + "QQsQEkUEQCACIARBkdXAAEEMEBJFBEACQAJAAkACQAJAAkAgAiAEQZ3VwABBBhASRQRAIAIgBEGj1cAAQQkQEg0BIAIgBEGs1cAAQQwQEg0CIAIgBEG41cAAQRIQEg0DIAIgBEHon8MAQQMQEg0GIAIgBEHK1cAAQQMQEg0FIAIgBEHN1cAAQQUQEg0EIAMgATYCTCADIAQ2ApwBIAMgAjYCmAEgA0ECNgJ8IAMgA0GYAWo2AnggAEEEakHck8AAIANB+ABqEAwMDwsgAygCXCECAkACQAJAIAMoAmAiBQ4CDQABCyACLQAAIgRBK2sOAwwBDAELIAItAAAhBAsgAiAEQf8BcUErRiIJaiEEIAUgCWsiAkEJTwRAQQAhBQNAIAJFDQ0gBa1CCn4iDUIgiKcNDCADQQhqIAQtAABBChAWIAMoAghBAUcNDCAEQQFqIQQgAkEBayECIA2nIgkgAygCDGoiBSAJTw0ACwwLC0EAIQUDQCACRQ0MIAMgBC0AAEEKEBYgAygCAEEBRw0LIARBAWohBCACQQFrIQIgAygCBCAFQQpsaiEFDAALAAsgAyADKAJcIAMoAmAQFzoAQgwLCyADIAMoAlwgAygCYBAXOgBEDAoLIAMgAygCXCADKAJgEBc6AEMMCQsgA0H4AGogAygCXCADKAJgEBUgAygCeA0FIAMgBigCCDYCkAEgAyAGKQIANwOIASAIEAQgCCADKAKQATYCCCAIIAMpA4gBNwIADAgLIANB+ABqIAMoAlwgAygCYBAVIAMoAngNAyADIAYoAgg2AnAgAyAGKQIANwNoIANBGGoQBCADIAMoAnA2AiAgAyADKQNoNwMYDAcLIAMgBSgCCDYCgAEgAyAFKQIANwN4IAMoAjAgAygCNBAFIAogAygCgAE2AgggCiADKQN4NwIADAcLIANB+ABqIAMoAlwgAygCYBARIAMoAngiAkF/RwRAIAAgAygAfTYACSAAIAMoAIABNgAMIAMgATYCTCAAIAMtAHw6AAgg", + "ACACNgIEDAgLIAMgAy0AfDoAQQwFCyADQfgAaiADKAJcIAMoAmAQESADKAJ4IgJBf0cEQCAAIAMoAH02AAkgACADKACAATYADCADIAE2AkwgACADLQB8OgAIIAAgAjYCBAwHCyADIAMtAHw6AEAMBAsgAyABNgJMIAMgBikCACINNwNoIAMgBigCCCIBNgJwIAAgATYCDCAAIA03AgQMBQsgAyABNgJMIAMgBikCACINNwOIASADIAYoAggiATYCkAEgACABNgIMIAAgDTcCBAwECyADQQM2ApwBIAMgA0HYAGo2ApgBIANB+ABqQYySwAAgA0GYAWoQDCADKAJ8IQUgAygCeCICQX9GDQAgAyABNgJMIAAgAygCgAE2AgwgACAFNgIIIAAgAjYCBAwDCyADIAU2AjwLIAMoAlggAygCXBABCyALIAwQASABIQIMAQsLIABBfzYCACADKAJYIAMoAlwQASALIAwQASADQcgAahAAIAMoAjQhASADKAIwCyADQRhqEAQgARAFIAgQBAsgA0GgAWokAAvFCgITfwF+IwBB0ARrIgYkACAGQQA2AhAgBkKAgICAEDcCCCAFLQAsIQcgBTEAKSEZIAZBATsBJCAGQgA3AhwgBiAFNQIkIAUxACtCMIZCgICAgIAgQgAgGVAgByAHQQJGG0EBcRuEIBlCIIaEhDcCFCAGQgE3AiggBkEoaiADIAUtACoiDBsiCUEBIAQgDBtBA3RqIREgBUEYaiESIAZBwAJqIQogBkHYAmohDSAGQcwCaiEOIAZBtAJqIQsgBkHYAGohEyAGQbgCaiEUIAUoAhQhFSAFKAIQIRYgBSgCCCEXIAUoAgQhGCAFLQAoIQ9BACEHAkADQAJAAkACQAJAAkAgCSARRwRAIAkoAgQhAyAJKAIAIQQgBkEANgI4IAZCgICAgMAANwIwIAdBAWohECAJQQhqIQkCQCAMRQRAAkACQCAPQQFxBEAgBkGoAmogBkEwaiAEIAMQswQgBikCsAIhGSAG", + "KAKsAiEIIAYoAqgCDQEgBiAINgI8IAYgGTcCQCAZQiCIpyEFIBmnIQQMBAsgBkGoAmogBkEwaiAEIAMgBxC0BCAGKQKwAiEZIAYoAqwCIQggBigCqAJFDQELIAghAwwHCyAGIAg2AjwgBiAZNwJAIBmnIQQMAwtBBEEEEOUCIQRBASEIIAZBqAJqIgNBpeDCAEEGQQFBABDeAiAEIAZBMGogAxDfAjYCACAGQQE2AkQgBiAENgJAIAZBATYCPEEBIQUgD0UNAgsgBUECdCEDQQAhBQNAIAMgBUZFBEAgBigCNCAGKAI4IAQgBWooAgAQ4QIgBzYCjAEgBUEEaiEFDAELCyAGQagCaiABIAIQtQQgBikDsAIhGSAGKAKsAiEDIAYoAqgCIgVBf0YNAgwDCyAAIAYpAgg3AgQgACAGKAIQNgIMIAAgBi0AJToAECAAQX82AgAMBgsgBkGoAmogASACELUEIAYpA7ACIRkgBigCrAIhAyAGKAKoAiIFQX9HDQELIAggBBAmDAELIBMgFEHQAfwKAAAgBiAZNwNQIAYgAzYCTCAGIAU2AkggDUEANgIAIA1BADYAAyAGIAYoAjg2ArACIAYgBikCMDcDqAIgBkF/NgLMAiAGQoCAgIDAADcCtAIgBkIANwK8AiAGQgQ3AsQCIAZBuARqIgMgGCAXELYEIAsQBCALIAYoAsAENgIIIAsgBikCuAQ3AgAgAyASELcEIAYoAswCIAYoAtACEAUgDiAGKALABDYCCCAOIAYpArgENwIAIAMgFiAVELYEIAoQBCAKIAYoAsAENgIIIAogBikCuAQ3AgAgAyAGQTxqELgEIAZBoARqIgcgBkGoAmogAyAGQcgAakEAIAVBAkcbELkEIAYpAqgEIRkgBigCpAQhAyAGKAKgBCIEQX5HBEAgBiADNgKMBCAGIAYpArAENwKYBCAGIAQ2AogEIAYgGTcCkAQgByAZQiCIpyIDKAIMIAMoAhAQiwMgBigCqARBAnQhB0EAIQUgBigC", + "pAQhBAJAA0AgBSAHRwRAIAZBuARqIAZBCGogBkGoAmogBCAFaigCABC6BCAGKAK4BCIDQX9HDQIgBUEEaiEFDAELCyAGKAKgBCAEECYgBkGIBGoQuwQgBkGoAmoQvAQgBkHIAGoQvQQgECEHDAQLIAYpArwEIRkgBigCoAQgBBAmIAZBiARqELsECyAGQagCahC8BCAGQcgAahC9BAwBCyAGQTBqEL4ECyAQIQcgA0F/Rg0ACyAAIAYoAhA2AgggACAGKQIINwIAIAAgGTcCECAAIAM2AgwLIAZB0ARqJAALdwEDfwJAAkACQCABKAIAIgQgASgCCCICTQRAIAEoAgQhAwwBCyABKAIEIQEgAkUEQEEBIQMgASAEEBkMAQsgASAEIAIQGiIDRQ0BC0EMEBsiAUUNASABIAI2AgggASADNgIEIAEgADYCACABDwtBARAcAAsQHQALqQEBAX8jAEEQayIDJAACQAJAIAEgAkH91MAAQQQQEkUEQCABIAJB45vDAEEBEBJFDQELIABBfzYCACAAQQA6AAQMAQsCQCABIAJBgdXAAEEEEBJFBEAgASACQYXVwABBARASRQ0BCyAAQX82AgAgAEEBOgAEDAELIAMgAjYCBCADIAE2AgAgA0ECNgIMIAMgAzYCCCAAQY2TwAAgA0EIahAMCyADQRBqJAALGQEBfyABIANGBH8gACACIAEQ+gcFQQELRQsQACABIAAoAgAgACgCBBArC84BAQh/IwBBMGsiAyQAIAMgATYCGCADIAE2AhAgAyACNgIUIAMgASACajYCHCADQQA2AiAgA0EkaiADQRBqEKACIAMoAixBACADKAIkIgQbIQIgAygCKCEFIANBGGohBgJAA0AgAygCGCEHIAMoAhwhCCADQQhqIAYQngIgAygCDCIJQX9GDQEgAygCCCEKIAkQIg0ACyADKAIYIAggB2sgCmpqIAMoAhxrIQILIAAgAiAFQQAgBBsiAms2AgQgACABIAJqNgIAIANBMGokAAvn", + "CwIJfwF+IwBBoAFrIgMkACADIAI2AjggAyABNgI0IANBKGogASACEBQgA0EgaiADKAIoIAMoAixB+wAQHgJAAkACQCADKAIgIgFFDQAgA0EYaiABIAMoAiRB/QAQHyADKAIYIgJFDQAgAygCHCEGDAELIANBAjYCbCADIANBNGo2AmggA0GIAWpBlZHAACADQegAahAMIAMoApABIQYgAygCjAEhAiADKAKIASIBQX9GDQAgACAGNgIMIAAgAjYCCCAAIAE2AgQgAEEBNgIADAELQQAhASADQQA2AkQgA0KAgICAwAA3AjwgA0HIAGogAiACIAZqECAgA0GUAWohCUEEIQogA0GMAWohByADKAJMIQUgAygCUCEEA0ACQCABIARPDQADQAJAIAEgBEYEQCAEIQYMAQsCQCAFIAQgAUHU1cAAECEoAgAQIg0AIAUgBCABQeTVwAAQISgCAEEsRg0AIAEhBgwBCyABQQFqIQEMAQsLIAMgBjYCVCABIARPDQAgA0GIAWogBSAEIANB1ABqECMgAyAHKQIANwNoIAMgBygCCDYCcAJAAkAgAygCiAFBAUYEQCAAIAMoAnA2AgwgACADKQNoNwIEIABBATYCAAwBCyADIAMoAnA2AmAgAyADKQNoNwNYIAMoAlQiASAEIAEgBEsbIQIgAUEBaiEGAkACQAJAA0ACQAJAIAEgAkcEQCAFIAQgAUH01cAAECEoAgAQIg0BCyABIARPDQEgBSAEIAFBhNbAABAhKAIAQTpHDQEDQCAEIAYiAksEQCACQQFqIQYgBSAEIAJBlNbAABAhKAIAECINAQsLIAMgAjYCVCACIARGDQQCQAJAIAUgBCACQaTWwAAQISgCAEEiRgRAIANBiAFqIAUgBCADQdQAahAjIAMoAogBRQ0BIAMgBygCCCIBNgJwIAMgBykCACIMNwNoIAAgATYCDCAAIAw3AgQMCAsgBSAEIAJBtNbAABAhKAIAQfsARw0FQQAhBiACIQEMAQsgAyAHKQIA", + "NwN4IAMgBygCCDYCgAEgAygCVCEBDAgLA0ACQAJAIAEgBEkEQCAFIAQgAUHE1sAAECEoAgBBIkYEQCADQYgBaiAFIAQgA0HUAGoQIyADKAKQASEBIAMoAowBIQsgAygCiAFFBEAgCyABEAEgAygCVCEBDAULIAAgAygClAE2AgwgACABNgIIIAAgCzYCBAwKCyAFIAQgAUHU1sAAECEoAgBB+wBGDQEgBSAEIAFB5NbAABAhKAIAQf0ARw0CIAZBAWsiBg0CIAMgAUEBaiIBNgJUIANBCGogBSAEIAIgAUH01sAAECQgA0H4AGogAygCCCICIAIgAygCDEECdGoQJQwLCyAAQQRqQYTXwABBHhAGDAgLIAZBAWohBgsgAyABQQFqIgE2AlQMAAsACyAGQQFqIQYgAUEBaiEBDAELCyADQQM2AowBIAMgA0HYAGo2AogBIABBBGpBqIHAACADQYgBahAMDAILIAIgBCACIARLGyEGIAIhAQNAAkAgASAGRg0AIAUgBCABQaTXwAAQISgCAEEsRg0AIAUgBCABQbTXwAAQISgCABAiDQAgAUEBaiEBDAELCyADIAE2AlQgA0EQaiAFIAQgAiABQcTXwAAQJCADQfgAaiADKAIQIgIgAiADKAIUQQJ0ahAlDAMLIANBAzYCjAEgAyADQdgAajYCiAEgAEEEakGPgcAAIANBiAFqEAwLIABBATYCACADKAJYIAMoAlwQAQsgAygCSCAFECYgA0E8ahAEDAMLIAkgAykDeDcCACAJIAMoAoABNgIIIAMgAygCYDYCkAEgAyADKQNYNwOIASADKAI8IAhGBEAgA0E8ahAnIAMoAkAhCgsgCiAIQRhsaiICIAMpA4gBNwIAIAIgAykDmAE3AhAgAiADKQOQATcCCCADIAhBAWoiCDYCRAwBCwsgACADKAJENgIMIAAgAykCPDcCBCAAQQA2AgAgAygCSCAFECYLIANBoAFqJAALNgEBfyAAIAFBwQBrQV9xQQpqIAFBMGsi", + "AyACQQpLGyADIAFBOUsbIgE2AgQgACABIAJJNgIACxsBAX8gAUEERgR/IAAoAABB9OTVqwZGBUEACwsQACABIAAoAgQgACgCCBArC1sBAn8CQCAAQQRrKAIAIgJBeHEiA0EEQQggAkEDcSICGyABak8EQCACQQAgAyABQSdqSxsNASAAED0PC0G42MIAQS5B6NjCABA+AAtB+NjCAEEuQajZwgAQPgAL+QUBB38CQAJAAkACQAJAAkAgAEEEayIHKAIAIghBeHEiBEEEQQggCEEDcSIFGyABak8EQCAFQQAgBCABQSdqSxsNAUEAIQFBUEHI7cMAKAIAIglrQXdxQQNrIAJNDQZBECACQQtqQXhxIAJBC0kbIQMgAEEIayEGAkACQAJAAkAgBQRAIAQgBmohBSADIARNDQMgBUGw7cMAKAIARg0EIAVBrO3DACgCAEYNAiAFKAIEIghBAnENCiAIQXhxIgggBGoiBCADSQ0KIAUgCBBFIAQgA2siBUEQSQ0BIAcgAyAHKAIAQQFxckECcjYCACADIAZqIgMgBUEDcjYCBCAEIAZqIgQgBCgCBEEBcjYCBCADIAUQRAwICyAGRSADQYACSSADIARPcnINCSAEIANrIAlBAXRNDQgMCQsgByAEIAcoAgBBAXFyQQJyNgIAIAQgBmoiAyADKAIEQQFyNgIEDAYLQaTtwwAoAgAgBGoiBCADSQ0HAkAgBCADayIFQQ9NBEAgByAIQQFxIARyQQJyNgIAIAQgBmoiAyADKAIEQQFyNgIEQQAhBUEAIQMMAQsgByADIAhBAXFyQQJyNgIAIAMgBmoiAyAFQQFyNgIEIAQgBmoiBCAFNgIAIAQgBCgCBEF+cTYCBAtBrO3DACADNgIAQaTtwwAgBTYCAAwFCyAEIANrIgRBD00NBCAHIAMgCEEBcXJBAnI2AgAgAyAGaiIDIARBA3I2AgQgBSAFKAIEQQFyNgIEIAMgBBBEDAQLQajtwwAoAgAgBGoiBCADSw0CDAULQbjY", + "wgBBLkHo2MIAED4AC0H42MIAQS5BqNnCABA+AAsgByADIAhBAXFyQQJyNgIAIAMgBmoiBSAEIANrIgNBAXI2AgRBqO3DACADNgIAQbDtwwAgBTYCAAsgBkUNAQsgAA8LIAIQGyIDRQ0AIAJBfEF4IAcoAgAiAUEDcRsgAUF4cWoiASABIAJLGyIBBEAgAyAAIAH8CgAACyAAED0gAyEBCyABC80lAgh/AX4CQAJAAkACQCAAQfUBTwRAIABBQEFQQcjtwwAoAgBrQXdxQQNrIgEgAUFATxtPDQMgAEELaiIBQXhxIQVBoO3DACgCACIIRQ0CQR8hByAAQfX//wdPDQEgBUEmIAFBCHZnIgBrdkEBcSAAQQF0ckE+cyEHDAELAkACQAJAAkACQEGc7cMAKAIAIgJBECAAQQtqQfgDcSAAQQtJGyIFQQN2IgB2IgFBA3EEQCABQX9zQQFxIABqIgZBA3QiAEGU68MAaiIEIABBnOvDAGooAgAiASgCCCIDRg0BIAMgBDYCDCAEIAM2AggMAgsgBUGk7cMAKAIATQ0GIAFFBEBBoO3DACgCACIARQ0HIABoQQJ0QYTqwwBqKAIAIgEoAgRBeHEgBWshAyABIQIDQAJAIAEoAhAiAEUEQCABKAIUIgBFDQELIAAoAgRBeHEgBWsiASADIAEgA0kiARshAyAAIAIgARshAiAAIQEMAQsLIAIoAhghBwJAAkAgAiACKAIMIgBGBEAgAkEUQRAgAigCFCIAG2ooAgAiAQ0BQQAhAAwCCyACKAIIIgEgADYCDCAAIAE2AggMAQsgAkEUaiACQRBqIAAbIQQDQCAEIQYgASIAQRRqIABBEGogACgCFCIBGyEEIABBFEEQIAEbaigCACIBDQALIAZBADYCAAsgB0UNBQJAIAIoAhxBAnRBhOrDAGoiASgCACACRwRAIAIgBygCEEcEQCAHIAA2AhQgAA0CDAgLIAcgADYCECAADQEMBwsgASAANgIAIABFDQULIAAgBzYCGCAC", + "KAIQIgEEQCAAIAE2AhAgASAANgIYCyACKAIUIgFFDQUgACABNgIUIAEgADYCGAwFCwJAQQIgAHQiBEEAIARrciABIAB0cWgiBkEDdCIBQZTrwwBqIgQgAUGc68MAaigCACIAKAIIIgNHBEAgAyAENgIMIAQgAzYCCAwBC0Gc7cMAIAJBfiAGd3E2AgALIAAgBUEDcjYCBCAAIAFqIAEgBWsiAzYCACAAIAVqIgYgA0EBcjYCBEGk7cMAKAIAIgJFDQJBrO3DACgCACEBAkBBnO3DACgCACIEQQEgAkEDdnQiBXFFBEBBnO3DACAEIAVyNgIAIAJBeHFBlOvDAGoiBSEEDAELIAJBeHEiAkGU68MAaiEEIAJBnOvDAGooAgAhBQsgBCABNgIIIAUgATYCDCABIAQ2AgwgASAFNgIIDAILQZztwwAgAkF+IAZ3cTYCAAsgASAAQQNyNgIEIAAgAWoiACAAKAIEQQFyNgIEIAFBCGoPC0Gs7cMAIAY2AgBBpO3DACADNgIADAULQaDtwwBBoO3DACgCAEF+IAIoAhx3cTYCAAsCQAJAIANBEE8EQCACIAVBA3I2AgQgAiAFaiIGIANBAXI2AgQgAyAGaiADNgIAQaTtwwAoAgAiAUUNAUGs7cMAKAIAIQACQEGc7cMAKAIAIgRBASABQQN2dCIHcUUEQEGc7cMAIAQgB3I2AgAgAUF4cUGU68MAaiIEIQEMAQsgAUF4cSIEQZTrwwBqIQEgBEGc68MAaigCACEECyABIAA2AgggBCAANgIMIAAgATYCDCAAIAQ2AggMAQsgAiADIAVqIgBBA3I2AgQgACACaiIAIAAoAgRBAXI2AgQMAQtBrO3DACAGNgIAQaTtwwAgAzYCAAsgAkEIaiIDRQ0BDAILQQAgBWshAwJAAkACQCAHQQJ0QYTqwwBqKAIAIgJFBEBBACEBQQAhAAwBC0EAIQEgBUEZIAdBAXZrQQAgB0EfRxt0IQRBACEAA0ACQCACKAIEQXhxIgYgBUkN", + "ACAGIAVrIgYgA08NACACIQEgBiIDDQBBACEDIAEhAAwDCyACKAIUIgYgACAGIAIgBEEddkEEcWooAhAiAkcbIAAgBhshACAEQQF0IQQgAg0ACwsgACABckUEQEEAIQFBAiAHdCIAQQAgAGtyIAhxIgBFDQMgAGhBAnRBhOrDAGooAgAhAAsgAEUNAQsDQCAAKAIEQXhxIgYgBWsiBCADIAMgBEsbIQcgACgCECICRQRAIAAoAhQhAgsgASAAIAMgBE0bIQAgAyAHIAUgBksiBBshAyABIAAgBBshASACIgANAAsLIAFFDQAgBUGk7cMAKAIAIgBNIAMgACAFa09xDQAgASgCGCEHAkACQCABIAEoAgwiAEYEQCABQRRBECABKAIUIgAbaigCACICDQFBACEADAILIAEoAggiAiAANgIMIAAgAjYCCAwBCyABQRRqIAFBEGogABshBANAIAQhBiACIgBBFGogAEEQaiAAKAIUIgIbIQQgAEEUQRAgAhtqKAIAIgINAAsgBkEANgIACwJAIAdFDQACQAJAIAEoAhxBAnRBhOrDAGoiAigCACABRwRAIAEgBygCEEcEQCAHIAA2AhQgAA0CDAQLIAcgADYCECAADQEMAwsgAiAANgIAIABFDQELIAAgBzYCGCABKAIQIgIEQCAAIAI2AhAgAiAANgIYCyABKAIUIgJFDQEgACACNgIUIAIgADYCGAwBC0Gg7cMAQaDtwwAoAgBBfiABKAIcd3E2AgALAkAgA0EQTwRAIAEgBUEDcjYCBCABIAVqIgAgA0EBcjYCBCAAIANqIAM2AgAgA0GAAk8EQCAAIAMQkgIMAgsCQEGc7cMAKAIAIgJBASADQQN2dCIEcUUEQEGc7cMAIAIgBHI2AgAgA0H4AXFBlOvDAGoiAyECDAELIANB+AFxIgRBlOvDAGohAiAEQZzrwwBqKAIAIQMLIAIgADYCCCADIAA2AgwgACACNgIMIAAgAzYCCAwBCyABIAMgBWoiAEEDcjYCBCAA", + "IAFqIgAgACgCBEEBcjYCBAsgAUEIaiIDDQELQbTtwwACfwJAIAVBpO3DACgCACIBSwRAIAVBqO3DACgCACIATwRAQQAhAyAFQcjtwwAoAgAiAGpBL2pBACAAa3EiAEUNAkHQ7cMALQAAQdDtwwBBAToAAEGA7sMAIQIgAEGAEktyDQJBgBIMAwtBqO3DACAAIAVrIgE2AgBBsO3DAEGw7cMAKAIAIgAgBWoiAjYCACACIAFBAXI2AgQgACAFQQNyNgIEIABBCGohAwwDC0Gs7cMAKAIAIQACQCABIAVrIgJBD00EQEGs7cMAQQA2AgBBpO3DAEEANgIAIAAgAUEDcjYCBCAAIAFqIgEgASgCBEEBcjYCBAwBC0Gk7cMAIAI2AgBBrO3DACAAIAVqIgQ2AgAgBCACQQFyNgIEIAAgAWogAjYCACAAIAVBA3I2AgQLDAMLIABBEHYgAEH//wNxQQBHaiIAQAAiAUF/Rg0BIAFBEHQiAkUNASAAQRB0IgBBEGsgACACQQAgAGtGGwsiAUG07cMAKAIAaiIANgIAQbjtwwAgAEG47cMAKAIAIgQgACAESxs2AgACQAJAAkACQAJAAkACQAJAAkBBsO3DACgCACIEBEBBhOvDACEAA0AgAiAAKAIAIgMgACgCBCIGakYNAiAAKAIIIgANAAsMAgtBwO3DACgCACIARSAAIAJLcg0FDAcLIAIgBE0gAyAES3INACAAKAIMRQ0BC0HA7cMAQcDtwwAoAgAiACACIAAgAkkbNgIAIAEgAmohA0GE68MAIQACQAJAAkADQCADIAAoAgAiBkcEQCAAKAIIIgANAQwCCwsgACgCDEUNAQtBhOvDACEAA0AgBCAAKAIAIgNPBEAgBCADIAAoAgRqIgZJDQMLIAAoAgghAAwACwALIAAgAjYCACAAIAAoAgQgAWo2AgQgAkEPakF4cUEIayICIAVBA3I2AgQgBkEPakF4cUEIayIBIAIgBWoiAGshAyABQbDtwwAoAgBGDQIgAUGs", + "7cMAKAIARg0DIAEoAgQiBUEDcUEBRgRAIAEgBUF4cSIEEEUgASAEaiIBKAIEIQUgAyAEaiEDCyABIAVBfnE2AgQgACADQQFyNgIEIAAgA2ogAzYCACADQYACTwRAIAAgAxCSAgwGCwJAQZztwwAoAgAiAUEBIANBA3Z0IgRxRQRAQZztwwAgASAEcjYCACADQfgBcUGU68MAaiIDIQUMAQsgA0H4AXEiAUGU68MAaiEFIAFBnOvDAGooAgAhAwsgBSAANgIIIAMgADYCDCAAIAU2AgwgACADNgIIDAULQbDtwwAgAkEPakF4cSIAQQhrIgM2AgBBqO3DACABQShrIgcgAiAAa2pBCGoiADYCACADIABBAXI2AgQgAiAHakEoNgIEQbztwwBBgICAATYCACAEIAZBIGtBeHFBCGsiACAAIARBEGpJGyIDQRs2AgRBhOvDACkCACEJIANBEGpBjOvDACkCADcCACADQQhqIgAgCTcCAEGI68MAIAE2AgBBhOvDACACNgIAQYzrwwAgADYCAEGQ68MAQQA2AgAgA0EcaiEAA0AgAEEHNgIAIABBBGoiACAGSQ0ACyADIARGDQYgAyADKAIEQX5xNgIEIAQgAyAEayIAQQFyNgIEIAMgADYCACAAQYACTwRAIAQgABCSAgwHCwJAQZztwwAoAgAiAUEBIABBA3Z0IgJxRQRAQZztwwAgASACcjYCACAAQfgBcUGU68MAaiIAIQEMAQsgAEH4AXEiAEGU68MAaiEBIABBnOvDAGooAgAhAAsgASAENgIIIAAgBDYCDCAEIAE2AgwgBCAANgIIDAYLIAAgASAGajYCBEGw7cMAQbDtwwAoAgAiAEEPakF4cSICQQhrIgQ2AgBBqO3DAEGo7cMAKAIAIAFqIgEgACACa2pBCGoiAjYCACAEIAJBAXI2AgQgACABakEoNgIEQbztwwBBgICAATYCAAwFC0Gw7cMAIAA2AgBBqO3DAEGo7cMAKAIAIANqIgE2AgAgACABQQFy", + "NgIEDAILQaztwwAgADYCAEGk7cMAQaTtwwAoAgAgA2oiATYCACAAIAFBAXI2AgQgACABaiABNgIADAELQcDtwwAgAjYCAAwBCyACQQhqDwtBiOvDACABNgIAQYTrwwAgAjYCAEGg68MAQZTrwwA2AgBBqOvDAEGc68MANgIAQZzrwwBBlOvDADYCAEGw68MAQaTrwwA2AgBBpOvDAEGc68MANgIAQbjrwwBBrOvDADYCAEGs68MAQaTrwwA2AgBBwOvDAEG068MANgIAQbTrwwBBrOvDADYCAEHI68MAQbzrwwA2AgBBvOvDAEG068MANgIAQdDrwwBBxOvDADYCAEHE68MAQbzrwwA2AgBB2OvDAEHM68MANgIAQczrwwBBxOvDADYCAEHE7cMAQcztwwAoAgAiAEF/IAAbNgIAQZDrwwBBADYCAEHg68MAQdTrwwA2AgBB1OvDAEHM68MANgIAQdzrwwBB1OvDADYCAEHo68MAQdzrwwA2AgBB5OvDAEHc68MANgIAQfDrwwBB5OvDADYCAEHs68MAQeTrwwA2AgBB+OvDAEHs68MANgIAQfTrwwBB7OvDADYCAEGA7MMAQfTrwwA2AgBB/OvDAEH068MANgIAQYjswwBB/OvDADYCAEGE7MMAQfzrwwA2AgBBkOzDAEGE7MMANgIAQZjswwBBjOzDADYCAEGM7MMAQYTswwA2AgBBlOzDAEGM7MMANgIAQaDswwBBlOzDADYCAEGo7MMAQZzswwA2AgBBnOzDAEGU7MMANgIAQaTswwBBnOzDADYCAEGw7MMAQaTswwA2AgBBrOzDAEGk7MMANgIAQbjswwBBrOzDADYCAEG07MMAQazswwA2AgBBwOzDAEG07MMANgIAQbzswwBBtOzDADYCAEHI7MMAQbzswwA2AgBBxOzDAEG87MMANgIAQdDswwBBxOzDADYCAEHM7MMAQcTswwA2AgBB2OzDAEHM7MMANgIAQdTswwBBzOzDADYCAEHg7MMAQdTswwA2", + "AgBB3OzDAEHU7MMANgIAQejswwBB3OzDADYCAEHw7MMAQeTswwA2AgBB5OzDAEHc7MMANgIAQfjswwBB7OzDADYCAEHs7MMAQeTswwA2AgBBgO3DAEH07MMANgIAQfTswwBB7OzDADYCAEGI7cMAQfzswwA2AgBB/OzDAEH07MMANgIAQZDtwwBBhO3DADYCAEGE7cMAQfzswwA2AgBBmO3DAEGM7cMANgIAQYztwwBBhO3DADYCAEGw7cMAIAJBD2pBeHEiAEEIayIENgIAQZTtwwBBjO3DADYCAEGo7cMAIAFBKGsiASACIABrakEIaiIANgIAIAQgAEEBcjYCBCABIAJqQSg2AgRBvO3DAEGAgIABNgIAC0EAIQNBqO3DACgCACIAIAVNDQBBqO3DACAAIAVrIgE2AgBBsO3DAEGw7cMAKAIAIgAgBWoiAjYCACACIAFBAXI2AgQgACAFQQNyNgIEDAELIAMPCyAAQQhqCw0AIAAEQBAdAAsQNAALDQBB5O3DAEEBOgAAAAtKAQF/IwBBIGsiBCQAIARBADYCHCAEQRBqIAMgBEEcahCYAiAEQQhqIAQoAhAgBCgCFCABIAIQmgIgACAEKQMINwMAIARBIGokAAtKAQF/IwBBIGsiBCQAIARBADYCHCAEQRBqIAMgBEEcahCYAiAEQQhqIAQoAhAgBCgCFCABIAIQmwIgACAEKQMINwMAIARBIGokAAu/AgEEfyMAQTBrIgMkACADIAI2AhggAyABNgIUAkAgA0EUahDCASIBQX9HBEAgA0EIakEDIAMoAhgiAiADKAIUIgVrIgRBAnYgBEEDcUEAR2oiBCAEQQNNG0EBakEEQQQQByADKAIIIQYgAygCDCIEIAE2AgAgA0EBNgIkIAMgBDYCICADIAY2AhwgAyACNgIsIAMgBTYCKEEEIQFBASECA0AgA0EoahDCASIFQX9GRQRAIAMoAhwgAkYEQCADQRxqIAIgAygCLCADKAIoayIEQQJ2IARBA3FBAEdq", + "QQFqQQRBBBAvIAMoAiAhBAsgASAEaiAFNgIAIAMgAkEBaiICNgIkIAFBBGohAQwBCwsgACADKAIkNgIIIAAgAykCHDcCAAwBCyAAQQA2AgggAEKAgICAwAA3AgALIANBMGokAAsbACABIAJNBEAgAiABIAMQKgALIAAgAkECdGoLkAEBAn8CQCAAQQlrIgJBF00EQEEBIQFBn4CABCACdkEBcQ0BC0EAIQEgAEGFAUkNAAJAIABBCHYiAgRAIAJBMEcEQCACQSBGDQIgAkEWRw0DIABBgC1GIQEMAwsgAEGA4ABGIQEMAgsgAEH/AXEtAMjVQyEBDAELIABB/wFxLQDI1UNBAnFBAXYhAQsgAUEBcQu2BgEHfyMAQTBrIgQkAAJAAkAgAygCACIFIAJPDQAgASAFQQJ0aigCAEEiRw0AIAMgBUEBaiIINgIAIARBADYCICAEQoCAgIAQNwIYA0AgAiAITQRAIABBBGpB1NfAAEETEAYgAEEBNgIAIAQoAhggBCgCHBABDAMLAkAgASAIQQJ0aiIHKAIAIgVB3ABHBEAgBUEiRwRAIARBGGogBRAJIAghBQwCCyAAIAQpAhg3AgQgACAEKAIgNgIMIABBADYCACADIAhBAWo2AgAMBAsgAyAIQQFqIgU2AgACQCACIAVNBEAgAEEEakHn18AAQQoQBiAAQQE2AgAMAQsCQAJAAkACQAJAAkACQAJAIAEgBUECdGooAgAiBkHuAGsOCAEGBgYDBgIHAAsgBkHiAGsOBQMFBQUEBQsgBEEYakEKEAkMBwsgBEEYakEJEAkMBgsgBEEYakENEAkMBQsgBEEYakEIEAkMBAsgBEEYakEMEAkMAwsgBEEYaiAGEAkMAgsCQCACIAhBBmpPBEAgBEEkaiAHQQhqIAdBGGoQJSAEKAIoIQkCQAJAAkAgBCgCLCIFDgIEAAELIAktAAAiB0Eraw4DAwEDAQsgCS0AACEHCyAJIAdB/wFxQStGIgZqIQcCQCAFIAZrIgVBCU8E", + "QEEAIQYDQCAFRQ0CIAZB/////wBLDQQgBEEQaiAHLQAAQRAQFiAEKAIQQQFHDQQgB0EBaiEHIAVBAWshBSAGQQR0IgogBCgCFGoiBiAKTw0ACwwDC0EAIQYDQCAFRQ0BIARBCGogBy0AAEEQEBYgBCgCCEEBRw0DIAdBAWohByAFQQFrIQUgBCgCDCAGQQR0aiEGDAALAAsgBEEYakH9/wNBfyAGIAZBgLADc0GAgMQAa0GAkLx/SRsiBSAFQX9GGxAJIAQoAiQgCRABIAhBBWohBQwDCyAAQQRqQfDUwABBDRAGIABBATYCAAwBCyAAQQRqQfDUwABBDRAGIABBATYCACAEKAIkIAkQAQsgBCgCGCAEKAIcEAEMAwsgAyAFQQFqIgg2AgAMAAsACyAAQQRqQfHXwABBDxAGIABBATYCAAsgBEEwaiQACzMAIAMgBE0gAiAET3FFBEAgAyAEIAIgBRApAAsgACAEIANrNgIEIAAgASADQQJ0ajYCAAtzAQJ/IwBBEGsiAyQAIANBADYCDCADQoCAgIAQNwIEIANBBGogAiABa0ECdiIEECggASACRwRAA0AgA0EEaiABKAIAENcCIAFBBGohASAEQQFrIgQNAAsLIAAgAygCDDYCCCAAIAMpAgQ3AgAgA0EQaiQACwwAIAAgAUEEQQQQMAsLACAAQRhBBBCGCAsNACAAIAFBAUEBEIcIC5gCAQF/IwBBIGsiBCQAAkACQAJAIAAgAk0EQCABIAJLDQEgACABTQ0CIAQgADYCCCAEIAE2AgwgBCAEQQxqrUKAgICAwACENwMYIAQgBEEIaq1CgICAgMAAhDcDEEHag8AAIARBEGogAxA1AAsgBCAANgIIIAQgAjYCDCAEIARBDGqtQoCAgIDAAIQ3AxggBCAEQQhqrUKAgICAwACENwMQQdaKwAAgBEEQaiADEDUACyAEIAE2AgggBCACNgIMIAQgBEEMaq1CgICAgMAAhDcDGAwBCyAEIAE2AgggBCACNgIMIAQg", + "BEEMaq1CgICAgMAAhDcDGAsgBCAEQQhqrUKAgICAwACENwMQQY+LwAAgBEEQaiADEDUAC1ABAX8jAEEgayIDJAAgAyABNgIMIAMgADYCCCADIANBCGqtQoCAgIDAAIQ3AxggAyADQQxqrUKAgICAwACENwMQQamEwAAgA0EQaiACEDUAC+YDAQZ/AkACQCAAKAIIIgZBgICAwAFxRQ0AAkACQAJAAkAgBkGAgICAAXEEQCAALwEOIgcNAUEAIQIMAgsgAkEQTwRAIAEgAhBJIQMMBAsgAkUNAyABIQQgAiEFA0AgAyAELAAAQb9/SmohAyAEQQFqIQQgBUEBayIFDQALDAMLIAEgAmohCEEAIQIgASEDIAchBQNAIAMiBCAIRg0CAn8gBEEBaiAELAAAIgNBAE4NABogBEECaiADQWBJDQAaIARBBEEDIANBb0sbagsiAyAEayACaiECIAVBAWsiBQ0ACwtBACEFCyAHIAVrIQMLIAMgAC8BDCIFTw0AIAUgA2shB0EAIQRBACEFAkACQAJAIAZBHXZBA3FBAWsOAgABAgsgByEFDAELIAdB/v8DcUEBdiEFCyAGQf///wBxIQggACgCBCEGIAAoAgAhAANAIARB//8DcSAFQf//A3FJBEBBASEDIARBAWohBCAAIAggBigCEBEFAEUNAQwDCwtBASEDIAAgASACIAYoAgwRBAANASAHIAVrQf//A3EhAUEAIQQDQCABIARB//8DcU0EQEEADwsgBEEBaiEEIAAgCCAGKAIQEQUARQ0ACwwBCyAAKAIAIAEgAiAAKAIEKAIMEQQAIQMLIAMLJgEBfyMAQRBrIgEkACABQQhqIABBAUEBEAcgASgCDCABQRBqJAALEgAgACABIAIgAyAEIAVBABANC+oFAQR/IwBB0AFrIgYkACAGQaABaiAEQQEgBRtBASAEGyAFQQAgBBsQDgJAAkACQCAGKAKgASIEQX9GBEAgBiAGKAKsATYCcCAGIAYpAqQBNwNoDAELIAZB", + "kAFqIAJBASADG0EBIAIbIANBACACGxAVIAZBlAFqIQIgBigCkAFBAUcNASAGIAIoAgg2AnAgBiACKQIANwNoIAZBoAFqEAMLQQEgBkHoAGoQECEEDAELIAFBACAAGyEHIABBASABG0EBIAAbIQggBiAGKQKkATcDaCAGIAYoAqwBNgJwIAYgAigCCDYCQCAGIAIpAgA3AzggBiAGKQLIATcCMCAGIAYpAsABNwIoIAYgBikCuAE3AiAgBiAGKQKwATcCGCAGIAQ2AgggBiAGKQKkATcCDCAGIAYoAqwBNgIUIAYoAjwhBCAGIAYoAkAiAkEEQQgQB0EAIQUgBkEANgKYASAGIAYoAgQiAzYClAEgBiAGKAIAIgA2ApABAkACQCAAIAJJBEAgBkGQAWpBACACQQRBCBAvIAYoApQBIQMgBigCmAEhBQwBCyACRQ0BCyACIAVqIARBFGohBCADIAVBA3RqIQUDQCAFIARBBGspAgA3AgAgBEEYaiEEIAVBCGohBSACQQFrIgINAAsgBigCkAEhACEFCyAGQfgAaiAIIAcgAyAFIAZBCGoQDwJAIAYoAngiAkF/RwRAIAYoAoQBIAYoAowBIQQgBigCiAEhASAGQdAAaiIIIAYoAnwiByAGKAKAARAIIAZB3ABqIgkgASAEEAggBkEDNgKcASAGQQM2ApQBIAYgCTYCmAEgBiAINgKQASAGQcQAaiIEQY6WwAAgBkGQAWoQDCAGKAJcIAYoAmAQASAGKAJQIAYoAlQQAUEDIAQQECEEIAIgBxABIAEQAQwBC0EAQQIgBi0AiAEbIAZB/ABqEBAhBAsgACADQQRBCBAwIAZBOGoQBCAGQQhqEAMLIAZB0AFqJAAgBAs/AQJ/IwBBEGsiBSQAIAVBCGogACABIAIgAyAEEJcBIAUoAggiAEF/RwRAIAUoAgwhBiAAEBwACyAFQRBqJAALWAECfyMAQRBrIgQkAAJ/IABFBEBBACEAIARBDGoMAQsgBCACNgIMIAAgA2wh", + "ACAEQQhqCyAANgIAIAQoAgwiAARAIAQoAgghBSABIAUQiAELIARBEGokAAsSACAAIAEgAiADIAQgBUEBEA0LCAAgASAAEAELFAAgACgCCCAAKAIEEAEgAEEMEBkLEQBB0NvCAEEjQbDYwAAQNQAL3AECAX8BfiMAQSBrIgMkACADIAE2AhAgAyAANgIMIANBATsBHCADIAI2AhggAyADQQxqNgIUIwBBEGsiASQAIANBFGoiACkCACEEIAEgADYCDCABIAQ3AgQjAEEQayIAJAAgAUEEaiIBKAIAIgIoAgQiA0EBcQRAIAIoAgAhAiAAIANBAXY2AgQgACACNgIAIAEoAggiAS0ACCECIAEtAAkaIABB4NfCACACEIQCAAsgAEF/NgIAIAAgATYCDCABKAIIIgEtAAghAiABLQAJGiAAQfzXwgAgAhCEAgALgwEBA38jAEEQayIDJAAgAiABIAJqIgFLBEBBABAcAAsgA0EEaiAAKAIAIgIgACgCBEEIIAEgAkEBdCICIAEgAksbIgEgAUEITRsiARA3IAMoAgRBAUYEQCADKAIIIAMoAgwhBRAcAAsgAygCCCECIAAgATYCACAAIAI2AgQgA0EQaiQAC2EBAX8CfyADQQBIBEBBASEBQQQMAQsCfwJ/IAEEQCACIAEgAxAaDAELIAMQGwsiBEUEQCAAQQE2AgRBAQwBCyAAIAQ2AgRBAAshASADIQRBCAsgAGogBDYCACAAIAE2AgALiQIBB38jAEEQayIDJABBCiECIAAoAgAiBCEAIARB6AdPBEADQCADQQZqIAJqIgVBBGsgACIGIABBkM4AbiIAQZDOAGxrIgdB//8DcUHkAG4iCEEBdC8A8YhBOwAAIAVBAmsgByAIQeQAbGtB//8DcUEBdC8A8YhBOwAAIAJBBGshAiAGQf+s4gRLDQALCyAAQQlLBEAgAkECayICIANBBmpqIAAgAEH//wNxQeQAbiIAQeQAbGtB//8DcUEBdC8A8YhBOwAAC0EAIAQg", + "ABtFBEAgAkEBayICIANBBmpqIABBAXQtAPKIQToAAAsgAUEBQQFBACADQQZqIAJqQQogAmsQSyADQRBqJAAL+wMBCH8jAEEQayIGJAACfwJAIANBAXFFBEAgAi0AACIFDQFBAAwCCyAAIAIgA0EBdiABKAIMEQQADAELIAEoAgwhCgNAIAJBAWohBAJAAkACQAJAIAXAQQBIBEAgBUH/AXEiCEGAAUYNASAIQcABRw0DIAYgATYCBCAGIAA2AgAgBkKggICABjcCCCADIAdBA3RqIgIoAgAgBiACKAIEEQUARQ0CQQEMBgsgACAEIAVB/wFxIgIgChEEAEUEQCACIARqIQIMBAtBAQwFCyAAIAJBA2oiBCACLwABIgIgChEEAEUEQCACIARqIQIMAwtBAQwECyAHQQFqIQcgBCECDAELQaCAgIAGIQsgBUEBcQRAIAIoAAEhCyACQQVqIQQLQQAhCAJ/IAVBAnFFBEBBACEJIAQMAQsgBC8AACEJIARBAmoLIQIgBUEEcQR/IAIvAAAhCCACQQJqBSACCyEEIAVBCHEEfyAELwAAIQcgBEECagUgBAshAiAFQRBxBEAgAyAJQQN0ai8BBCEJCyAGIAVBIHEEfyADIAhBA3RqLwEEBSAICzsBDiAGIAk7AQwgBiALNgIIIAYgATYCBCAGIAA2AgBBASADIAdBA3RqIgQoAgAgBiAEKAIEEQUADQIaIAdBAWohBwsgAi0AACIFDQALQQALIAZBEGokAAtbAQF/IwBBIGsiBSQAIAUgATYCBCAFIAA2AgAgBSADNgIMIAUgAjYCCCAFIAVBCGqtQoCAgIDQAIQ3AxggBSAFrUKAgICA4ACENwMQQfuVwAAgBUEQaiAEEDUACxkAIAEoAgBBoNvDAEEFIAEoAgQoAgwRBAALbAEDfwJAAkAgACgCACICBEAgACgCBCIAQQRrKAIAIgFBeHEiA0EEQQggAUEDcSIBGyACakkNASABQQAgAyACQSdqSxsNAiAAED0LDwtB", + "uNjCAEEuQejYwgAQPgALQfjYwgBBLkGo2cIAED4AC9YGAQR/IABBCGsiASAAQQRrKAIAIgNBeHEiAGohAgJAAkAgA0EBcQ0AIANBAnFFDQEgASgCACIDIABqIQAgASADayIBQaztwwAoAgBGBEAgAigCBEEDcUEDRw0BQaTtwwAgADYCACACIAIoAgRBfnE2AgQgASAAQQFyNgIEIAIgADYCAA8LIAEgAxBFCwJAAkACQAJAAkACQAJAIAIoAgQiA0ECcUUEQCACQbDtwwAoAgBGDQIgAkGs7cMAKAIARg0FIAIgA0F4cSICEEUgASAAIAJqIgBBAXI2AgQgACABaiAANgIAIAFBrO3DACgCAEcNAUGk7cMAIAA2AgAPCyACIANBfnE2AgQgASAAQQFyNgIEIAAgAWogADYCAAsgAEGAAkkNASABIAAQkgJBACEBQcTtwwBBxO3DACgCAEEBayIANgIAIABFDQIMBgtBsO3DACABNgIAQajtwwBBqO3DACgCACAAaiIANgIAIAEgAEEBcjYCBEGs7cMAKAIAIAFGBEBBpO3DAEEANgIAQaztwwBBADYCAAsgAEG87cMAKAIAIgJNDQVBUEHI7cMAKAIAIgFrQXdxQQNGDQVBsO3DACgCACIARQ0FQajtwwAoAgAiA0EpSQ0EIAFFDQNBhOvDACEBA0AgACABKAIAIgRPBEAgACAEIAEoAgRqSQ0GCyABKAIIIQEMAAsACwJAQZztwwAoAgAiAkEBIABBA3Z0IgNxRQRAQZztwwAgAiADcjYCACAAQfgBcUGU68MAaiIAIQIMAQsgAEH4AXEiAEGU68MAaiECIABBnOvDAGooAgAhAAsgAiABNgIIIAAgATYCDCABIAI2AgwgASAANgIIDwtBjOvDACgCACIABEADQCABQQFqIQEgACgCCCIADQALC0HE7cMAQcztwwAoAgAiACABIAAgAUsbQX8gABs2AgAPC0Gs7cMAIAE2AgBBpO3DAEGk7cMAKAIAIABqIgA2", + "AgAgASAAQQFyNgIEIAAgAWogADYCAA8LQbjZwgAQZAALQQAhAUGM68MAKAIAIgAEQANAIAFBAWohASAAKAIIIgANAAsLQcTtwwBBzO3DACgCACIAIAEgACABSxtBfyAAGzYCACACIANPDQBBvO3DAEF/NgIACwsRACAAIAFBAXRBAXIgAhA1AAtUAQF/AkACQCAAKAIAIAAoAggiA2sgAkkEQCAAIAMgAhA2IAAoAgghAwwBCyACRQ0BCyACRQ0AIAAoAgQgA2ogASAC/AoAAAsgACACIANqNgIIQQALgAIBBn8gACgCCCEEAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCyIGIAAoAgAgBGtLBEAgACAEIAYQNgsgACgCBCAEaiECAkAgAUGAAU8EQCABQT9xQYB/ciEFIAFBBnYhAyABQYAQSQRAIAIgBToAASACIANBwAFyOgAADAILIAFBDHYhByADQT9xQYB/ciEDIAFB//8DTQRAIAIgBToAAiACIAM6AAEgAiAHQeABcjoAAAwCCyACIAU6AAMgAiADOgACIAIgB0E/cUGAf3I6AAEgAiABQRJ2QXByOgAADAELIAIgAToAAAsgACAEIAZqNgIIQQALDwAgAEHA2MAAIAEgAhA5C0QBAX8CQAJAIAJFBEBBASEDDAELIAIQGyIDRQ0BIAMgASAC/AoAAAsgACACNgIIIAAgAzYCBCAAIAI2AgAPC0EBEBwAC40DAQV/AkACQCABQQlPBEAgAEFAQVBByO3DACgCAGtBd3FBA2siBCAEQUBPG0EQIAEgAUEQTRsiAWtPDQEgAUEQIABBC2pBeHEgAEELSRsiBGpBDGoQGyICRQ0BIAJBCGshACABQQFrIgMgAnFFBEAgACEBDAMLIAJBBGsiBSgCACIGQXhxIAIgA2pBACABa3FBCGsiAiABQQAgAiAAa0EQTRtqIgEgAGsiAmshAyAGQQNxBEAgASADIAEoAgRBAXFyQQJyNgIEIAEg", + "A2oiAyADKAIEQQFyNgIEIAUgAiAFKAIAQQFxckECcjYCACAAIAJqIgMgAygCBEEBcjYCBCAAIAIQRAwDCyAAKAIAIQAgASADNgIEIAEgACACajYCAAwCCyAAEBshAwsgAw8LAkAgASgCBCIAQQNxRQ0AIABBeHEiAiAEQRBqTQ0AIAEgBCAAQQFxckECcjYCBCABIARqIgAgAiAEayIEQQNyNgIEIAEgAmoiAiACKAIEQQFyNgIEIAAgBBBECyABQQhqC48EAQJ/IAAgAWohAgJAAkACQCAAKAIEIgNBAXENACADQQJxRQ0BIAAoAgAiAyABaiEBIAAgA2siAEGs7cMAKAIARgRAIAIoAgRBA3FBA0cNAUGk7cMAIAE2AgAgAiACKAIEQX5xNgIEIAAgAUEBcjYCBCACIAE2AgAPCyAAIAMQRQsCQAJAIAIoAgQiA0ECcUUEQCACQbDtwwAoAgBGDQIgAkGs7cMAKAIARg0EIAIgA0F4cSICEEUgACABIAJqIgFBAXI2AgQgACABaiABNgIAIABBrO3DACgCAEcNAUGk7cMAIAE2AgAPCyACIANBfnE2AgQgACABQQFyNgIEIAAgAWogATYCAAsgAUGAAk8EQCAAIAEQkgIPCwJAQZztwwAoAgAiAkEBIAFBA3Z0IgNxRQRAQZztwwAgAiADcjYCACABQfgBcUGU68MAaiIBIQIMAQsgAUH4AXEiAUGU68MAaiECIAFBnOvDAGooAgAhAQsgAiAANgIIIAEgADYCDCAAIAI2AgwgACABNgIIDwtBsO3DACAANgIAQajtwwBBqO3DACgCACABaiIBNgIAIAAgAUEBcjYCBCAAQaztwwAoAgBHDQBBpO3DAEEANgIAQaztwwBBADYCAAsPC0Gs7cMAIAA2AgBBpO3DAEGk7cMAKAIAIAFqIgE2AgAgACABQQFyNgIEIAAgAWogATYCAAuCAwEEfyAAKAIMIQICQAJAAkAgAUGAAk8EQCAAKAIYIQMCQAJAIAAgAkYE", + "QCAAQRRBECAAKAIUIgIbaigCACIBDQFBACECDAILIAAoAggiASACNgIMIAIgATYCCAwBCyAAQRRqIABBEGogAhshBANAIAQhBSABIgJBFGogAkEQaiACKAIUIgEbIQQgAkEUQRAgARtqKAIAIgENAAsgBUEANgIACyADRQ0CAkAgACgCHEECdEGE6sMAaiIBKAIAIABHBEAgAygCECAARg0BIAMgAjYCFCACDQMMBAsgASACNgIAIAJFDQQMAgsgAyACNgIQIAINAQwCCyAAKAIIIgAgAkcEQCAAIAI2AgwgAiAANgIIDwtBnO3DAEGc7cMAKAIAQX4gAUEDdndxNgIADwsgAiADNgIYIAAoAhAiAQRAIAIgATYCECABIAI2AhgLIAAoAhQiAEUNACACIAA2AhQgACACNgIYDwsPC0Gg7cMAQaDtwwAoAgBBfiAAKAIcd3E2AgAL6gEBAX8jAEFAaiIHJAAgByABNgIEIAcgADYCACAHIAM2AgwgByACNgIIIAdBAjYCFCAHQe+IwQA2AhAgBARAIAcgBTYCHCAHIAQ2AhggByAHQQhqrUKAgICA0ACENwM4IAcgB61CgICAgNAAhDcDMCAHIAdBGGqtQoCAgIDwAIQ3AyggByAHQRBqrUKAgICA4ACENwMgQdKSwAAgB0EgaiAGEDUACyAHIAdBCGqtQoCAgIDQAIQ3AzAgByAHrUKAgICA0ACENwMoIAcgB0EQaq1CgICAgOAAhDcDIEGbksAAIAdBIGogBhA1AAsUACAAKAIAIAEgACgCBCgCDBEFAAsYACABKAIAIAEoAgQgACgCACAAKAIEEDkL/AMBB38gASAAIABBA2pBfHEiBmsiBGoiBUEDcSECQQAhASAAIAZHBEADQCADIAAsAABBv39KaiEDIABBAWohACAEQQFqIgQNAAsLIAIEQCAGIAVB/P///wdxaiEAA0AgASAALAAAQb9/SmohASAAQQFqIQAgAkEBayICDQALCyAFQQJ2IQQgASADaiEF", + "AkADQCAGIQMgBEUNAUHAASAEIARBwAFPGyIHQQNxIQICQCAHQQJ0IgZB8AdxIgBFBEBBACEBDAELIAAgA2ohCEEAIQEgAyEAA0AgASAAKAIAIgFBf3NBB3YgAUEGdnJBgYKECHFqIABBBGooAgAiAUF/c0EHdiABQQZ2ckGBgoQIcWogAEEIaigCACIBQX9zQQd2IAFBBnZyQYGChAhxaiAAQQxqKAIAIgFBf3NBB3YgAUEGdnJBgYKECHFqIQEgAEEQaiIAIAhHDQALCyAEIAdrIQQgAyAGaiEGIAFBCHZB/4H8B3EgAUH/gfwHcWpBgYAEbEEQdiAFaiEFIAJFDQALIAJBAnQhAiADIAdB/AFxQQJ0aiEAQQAhAQNAIAEgACgCACIBQX9zQQd2IAFBBnZyQYGChAhxaiEBIABBBGohACACQQRrIgINAAsgAUEIdkH/gfwHcSABQf+B/AdxakGBgARsQRB2IAVqIQULIAUL+AEBA38jAEEgayIFJABBASEHAkAgACgCACIGIAEgAiAAKAIEIgIoAgwiAREEAA0AAkAgAC0ACkGAAXFFBEAgBkGD4sIAQQEgAREEAA0CIAMgACAEEQUADQIgACgCACEGIAAoAgQoAgwhAQwBCyAGQc+FwQBBAiABEQQADQEgBUEBOgAPIAUgAjYCBCAFIAY2AgAgBUHMhsEANgIUIAUgACkCCDcCGCAFIAVBD2o2AgggBSAFNgIQIAMgBUEQaiAEEQUADQEgBSgCEEHNhcEAQQIgBSgCFCgCDBEEAA0BCyAGQYTiwgBBASABEQQAIQcLIAVBIGokACAHC8MEAgZ/AX4CfyABRQRAIAAoAgghBkEtIQsgBUEBagwBC0ErQX8gACgCCCIGQYCAgAFxIgEbIQsgAUEVdiAFagshCQJAIAZBgICABHFFBEBBACECDAELIAMEQCACIQEgAyEIA0AgByABLAAAQb9/SmohByABQQFqIQEgCEEBayIIDQALCyAHIAlqIQkLAkAgAC8BDCII", + "IAlLBEACQAJAIAZBgICACHFFBEAgCCAJayEJQQAhAUEAIQgCQAJAAkAgBkEddkEDcUEBaw4DAAEAAgsgCSEIDAELIAlB/v8DcUEBdiEICyAGQf///wBxIQogACgCBCEGIAAoAgAhAANAIAFB//8DcSAIQf//A3FPDQJBASEHIAFBAWohASAAIAogBigCEBEFAEUNAAsMBAsgACAAKQIIIgynQYCAgP95cUGwgICAAnI2AghBASEHIAAoAgAiBiAAKAIEIgogCyACIAMQTA0DQQAhASAIIAlrQf//A3EhAgNAIAFB//8DcSACTw0CIAFBAWohASAGQTAgCigCEBEFAEUNAAsMAwtBASEHIAAgBiALIAIgAxBMDQIgACAEIAUgBigCDBEEAA0CIAkgCGtB//8DcSECQQAhAQNAIAIgAUH//wNxTQRAQQAPCyABQQFqIQEgACAKIAYoAhARBQBFDQALDAILIAYgBCAFIAooAgwRBAANASAAIAw3AghBAA8LQQEhByAAKAIAIgEgACgCBCIAIAsgAiADEEwNACABIAQgBSAAKAIMEQQAIQcLIAcLNQACQCACQX9GDQAgACACIAEoAhARBQBFDQBBAQ8LIANFBEBBAA8LIAAgAyAEIAEoAgwRBAALrgQBC38gACgCBCEJIAAoAgAhCiAAKAIIIQsCQANAIAYNAQJ/AkAgAiAESQ0AA0AgASAEaiEFAkACQAJAAkACQCACIARrIgZBB00EQCACIARHDQEgAiEEDAcLIAVBA2pBfHEiACAFRg0BIAAgBWshA0EAIQADQCAAIAVqLQAAQQpGDQUgAyAAQQFqIgBHDQALIAMgBkEIayIASw0DDAILQQAhAANAIAAgBWotAABBCkYNBCAGIABBAWoiAEcNAAsgAiEEDAULIAZBCGshAEEAIQMLA0BBgIKECCADIAVqIgcoAgAiDUGKlKjQAHNrIA1yQYCChAggB0EEaigCACIHQYqUqNAAc2sgB3JxQYCBgoR4cUGAgYKEeEcN", + "ASADQQhqIgMgAE0NAAsLIAMgBkYEQCACIQQMAwsgAyAFaiEGIAIgA2sgBGshB0EAIQACQANAIAAgBmotAABBCkYNASAHIABBAWoiAEcNAAsgAiEEDAMLIAAgA2ohAAsgACAEaiIDQQFqIQQCQCACIANNDQAgACAFai0AAEEKRw0AQQAhBiAEIgUMAwsgAiAETw0ACwsgAiAIRg0CQQEhBiAIIQUgAgshAAJAIAstAAAEQCAKQY6owgBBBCAJKAIMEQQADQELQQAhAyAAIAhHBEAgACABakEBay0AAEEKRiEDCyAAIAhrIQAgASAIaiEHIAsgAzoAACAFIQggCiAHIAAgCSgCDBEEAEUNAQsLQQEhDAsgDAtPAQJ/IAAoAgQhAiAAKAIAIQMCQCAAKAIIIgAtAABFDQAgA0GOqMIAQQQgAigCDBEEAEUNAEEBDwsgACABQQpGOgAAIAMgASACKAIQEQUACw8AIABBzIbBACABIAIQOQvkAwIDfgR/IwBBIGsiBSQAIAAoAgAhBgJ/AkAgASgCCCIAQYCAgBBxRQRAIABBgICAIHENAUEUIQAgBikDACIDIQIgA0LoB1oEQANAIAVBDGogAGoiBkEEayACIgQgAkKQzgCAIgJCkM4Afn2nIgdB//8DcUHkAG4iCEEBdC8A8YhBOwAAIAZBAmsgByAIQeQAbGtB//8DcUEBdC8A8YhBOwAAIABBBGshACAEQv+s4gRWDQALCyACQglWBEAgAEECayIAIAVBDGpqIAKnIgYgBkH//wNxQeQAbiIGQeQAbGtB//8DcUEBdC8A8YhBOwAAIAatIQILIANQRSACUHFFBEAgAEEBayIAIAVBDGpqIAKnQQF0LQDyiEE6AAALIAFBAUEBQQAgBUEMaiAAakEUIABrEEsMAgsgBikDACECQREhAANAIAAgBWpBCmogAqdBD3EtAIiEQToAACAAQQFrIQAgAkIEiCICQgBSDQALIAFBAUHEm8MAQQIgACAFakELakERIABrEEsM", + "AQsgBikDACECQREhAANAIAAgBWpBCmogAqdBD3EtAKCqQjoAACAAQQFrIQAgAkIEiCICQgBSDQALIAFBAUHEm8MAQQIgACAFakELakERIABrEEsLIAVBIGokAAuzEAEFfyMAQRBrIgYkACAAAn8CQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABDigGAQEBAQEBAQEEAwEBBQEBAQEBAQEBAQEBAQEBAQEBAQEBCAEBAQEHAAsgAUHcAEYNAQsgAUH+//8AcUGe/wNGIAFBIGtB3wBJcg0MIAFBIEkgAUH/AGtBIUlyIAFBgMADa0GAMkkgAUGAgDxrQf7/A0lyciABQSBGIAFBgIBAakH+/wNJcnINDSABQYUBSQ0LAkACQAJAAkACQCABQQh2IgVBFmsOGwAEBAQEBAQEBAQDBAQEBAQEBAQEBAQEBAQEAQILIAFBgC1GIQMMAwsgAUGA4ABGIQMMAgsgBQ0BIAFB/wFxLQDI1UMhAwwBCyABQf8BcS0AyNVDQQJxQQF2IQMLIANBAXENDSACQQFxIAFBgAZPcQ0HIAFBrAFLDQgMCwsgAEIANwECIABB3LgBOwEADAkLIABCADcBAiAAQdzcATsBAAwICyAAQgA3AQIgAEHc6AE7AQAMBwsgAEIANwECIABB3OQBOwEADAYLIABCADcBAiAAQdzgADsBAAwFCyACQYACcUUNBiAAQgA3AQIgAEHczgA7AQAMBAsgAkH///8HcUGAgARPDQIMBQtBACEFQRBBACABQaudBE8bIgIgAkEIciICIAEgAkECdCgCuKlBQf///wBxSRsiAiACQQRyIgIgASACQQJ0KAK4qUFB////AHFJGyICIAJBAnIiAiABIAJBAnQoAripQUH///8AcUkbIgIgAkEBaiICIAEgAkECdCgCuKlBQf///wBxSRsiAiACQQFqIgIgASACQQJ0KAK4qUFB////AHFJGyICQQJ0KAK4qUFBC3QiAyABQQt0IgRGIAMgBElq", + "IAJqIgRBAnQiAkG4qcEAaiEHIAIoAripQUEVdiECQf8FIQMCQCAEQR9NBEAgBygCBEEVdiEDIARFDQELIAdBBGsoAgBB////AHEhBQsCQCADIAJBf3NqRQ0AIAEgBWshBSADQQFrIQRBACEDA0AgAyACQYv4wABqLQAAaiIDIAVLDQEgBCACQQFqIgJHDQALCyACQQFxDQULQQAhBUEGQQAgAUGA/ANPGyICIAJBA2oiAiABIAJBAnQoAuirQUH///8AcUkbIgIgAkEBaiICIAEgAkECdCgC6KtBQf///wBxSRsiAiACQQFqIgIgASACQQJ0KALoq0FB////AHFJGyICQQJ0KALoq0FBC3QiAyABQQt0IgRGIAMgBElqIAJqIgRBAnQiAkHoq8EAaiEHIAIoAuirQUEVdiECQSMhAwJAIARBCk0EQCAHKAIEQRV2IQMgBEUNAQsgB0EEaygCAEH///8AcSEFCwJAIAMgAkF/c2pFDQAgASAFayEFIANBAWshBEEAIQMDQCADIAJBrYDBAGotAABqIgMgBUsNASAEIAJBAWoiAkcNAAsLIAJBAXENBEEAIQVBBUEAIAFBvaEETxsiAiACQQNqIgIgASACQQJ0KAKYrEFB////AHFJGyICIAJBAWoiAiABIAJBAnQoApisQUH///8AcUkbIgIgAkEBaiICIAEgAkECdCgCmKxBQf///wBxSRsiAkECdCgCmKxBQQt0IgMgAUELdCIERiADIARJaiACaiIEQQJ0IgJBmKzBAGohByACKAKYrEFBFXYhAkErIQMCQCAEQQlNBEAgBygCBEEVdiEDIARFDQELIAdBBGsoAgBB////AHEhBQsCQCADIAJBf3NqRQ0AIAEgBWshBSADQQFrIQRBACEDA0AgAyACQdCAwQBqLQAAaiIDIAVLDQEgBCACQQFqIgJHDQALCyACQQFxRQ0CDAQLIABCADcBAiAAQdzEADsBAAtBACECQQIMAwsCf0EBIQICQAJAIAFB+AZJDQAg", + "AUH+/w9JDQEgAUGBgDhGIAFBoIA4a0HgAElyIAFBgII4a0HwAUkgAUGAgDxrQf7/A0lycg0AIAFBgIBAakH+/wNJIQILIAIMAQtBACEFQRtBACABQfzlBk8bIgIgAkENaiICIAEgAkECdCgC0KZBQf///wBxSRsiAiACQQdqIgIgASACQQJ0KALQpkFB////AHFJGyICIAJBA2oiAiABIAJBAnQoAtCmQUH///8AcUkbIgIgAkECaiICIAEgAkECdCgC0KZBQf///wBxSRsiAiACQQFqIgIgASACQQJ0KALQpkFB////AHFJGyICQQJ0KALQpkFBC3QiAyABQQt0IgRGIAMgBElqIAJqIgRBAnQiAkHQpsEAaiEHIAIoAtCmQUEVdiECQbULIQMCQCAEQTRNBEAgBygCBEEVdiEDIARFDQELIAdBBGsoAgBB////AHEhBQsCQCADIAJBf3NqRQ0AIAEgBWshBSADQQFrIQRBACEDA0AgAyACQb/lwABqLQAAaiIDIAVLDQEgBCACQQFqIgJHDQALCyACQQFxRQtFDQELIAAgATYCAEGAASECQYEBDAELIAZBADoACCAGQQA7AQYgBiABQRR2LQCIhEE6AAkgBiABQQR2QQ9xLQCIhEE6AA0gBiABQQh2QQ9xLQCIhEE6AAwgBiABQQx2QQ9xLQCIhEE6AAsgBiABQRB2QQ9xLQCIhEE6AAogAUEBcmdBAnYiAiAGQQZqIgNqIgVB+wA6AAAgBUEBa0H1ADoAACADIAJBAmsiAmpB3AA6AAAgACAGKQEGNwIAIAZB/QA6AA8gBiABQQ9xLQCIhEE6AA4gACAGLwEOOwEIQQoLOgANIAAgAjoADCAGQRBqJAALqwUCBn8BfgJAIAJFDQAgAkEHayIDQQAgAiADTxshByABQQNqQXxxIAFrIQhBACEDA0ACQAJAAkAgASADai0AACIFwCIGQQBOBEAgCCADa0EDcQ0BIAMgB08NAgNAIAEgA2oiBEEEaigCACAEKAIA", + "ckGAgYKEeHENAyADQQhqIgMgB0kNAAsMAgtCgICAgJAgIQkCQAJAAkACQAJAAkACQAJAAkAgBS0AyNdDQQJrDgMAAQIHCyADQQFqIgQgAkkNAkIAIQkMBgsgA0EBaiIEIAJJDQJCACEJDAULIANBAWoiBCACSQ0CQgAhCQwECyABIARqLAAAQb9/Sg0DDAQLIAEgBGosAAAhBAJAAkAgBUHgAWsiBQRAIAVBDUYEQAwCBQwDCwALIARBYHFBoH9GDQMMBAsgBEGff0oNAwwCCyAGQR9qQf8BcUEMTwRAIAZBfnFBbkcNAyAEQUBIDQIMAwsgBEFASA0BDAILIAEgBGosAAAhBAJAAkACQAJAIAVB8AFrDgUBAAAAAgALIAZBD2pB/wFxQQJLDQQgBEFASA0CDAQLIARB8ABqQf8BcUEwSQ0BDAMLIARBj39KDQILIAIgA0ECaiIETQRAQgAhCQwCCyABIARqLAAAQb9/SgRAQoCAgICQwAAhCQwCC0IAIQkgA0EDaiIEIAJPDQEgASAEaiwAAEFASA0CQoCAgICQ4AAhCQwBC0IAIQkgA0ECaiIEIAJPDQAgASAEaiwAAEG/f0wNAUKAgICAkMAAIQkLIAAgCSADrYQ3AgQgAEEBNgIADwsgBEEBaiEDDAILIANBAWohAwwBCyACIANNDQADQCABIANqLAAAQQBIDQEgAiADQQFqIgNHDQALDAILIAIgA0sNAAsLIAAgAjYCCCAAIAE2AgQgAEEANgIAC/0EAgx/An4jAEGgAWsiCCQAIAhBAEGgAfwLAAJAAkAgAiAAKAKgASIFTQRAIAVBKU8NAiAFQQFqIQwgBUECdCEJIAEgAkECdGohDQJAA0AgCCAGQQJ0aiEDA0AgBiECIAMhBCABIA1GDQQgA0EEaiEDIAJBAWohBiABKAIAIQcgAUEEaiILIQEgB0UNAAsgB60hEEIAIQ8gCSEHIAIhASAAIQMDQCABQShPDQIgBCAPIAQ1AgB8IAM1AgAgEH58Ig8+", + "AgAgD0IgiCEPIARBBGohBCABQQFqIQEgA0EEaiEDIAdBBGsiBw0ACwJAIAogD1AEfyAFBSACIAVqIgFBKE8NASAIIAFBAnRqIA8+AgAgDAsgAmoiASABIApJGyEKIAshAQwBCwsgAUEoQZyGwQAQKgALIAFBKEGchsEAECoACyACQQFqIQ0gAkECdCEMIAAgBUECdGohDiAAIQMCQANAIAggB0ECdGohBgNAIAchCyAGIQQgAyAORg0DIARBBGohBiAHQQFqIQcgAygCACEJIANBBGoiBSEDIAlFDQALIAmtIRBCACEPIAwhCSALIQMgASEGA0AgA0EoTw0CIAQgDyAENQIAfCAGNQIAIBB+fCIPPgIAIA9CIIghDyAEQQRqIQQgA0EBaiEDIAZBBGohBiAJQQRrIgkNAAsCQCAKIA9QBH8gAgUgAiALaiIDQShPDQEgCCADQQJ0aiAPPgIAIA0LIAtqIgMgAyAKSRshCiAFIQMMAQsLIANBKEGchsEAECoACyADQShBnIbBABAqAAsgACAIQaAB/AoAACAAIAo2AqABIAhBoAFqJAAPC0EAIAVBKEGchsEAECkAC7sDAQd/AkACQCABQYAKSQRAIAFBBXYhBQJAAkAgACgCoAEiBARAIARBAWshAyAEQQJ0IABqQQRrIQIgBCAFakECdCAAakEEayEGIARBKUkhBANAIARFDQIgAyAFaiIHQShPDQMgBiACKAIANgIAIAZBBGshBiACQQRrIQIgA0EBayIDQX9HDQALCyABQR9xIQQCQCAFRQ0AIAVBAnQiAUUNACAAQQAgAfwLAAsgACgCoAEgBWohAiAERQRAIAAgAjYCoAEgAA8LIAJBAWsiA0EnSw0DIAIhASAAIANBAnRqKAIAQSAgBGsiBnYiA0UNBCACQSdNBEAgACACQQJ0aiADNgIAIAJBAWohAQwFCyACQShBnIbBABAqAAsgA0EoQZyGwQAQKgALIAdBKEGchsEAECoAC0GshsEAQR1BnIbBABA+", + "AAsgA0EoQZyGwQAQKgALIAIgBUEBaiIHSwRAIAJBAnQgAGpBCGshAwNAIANBBGoiCCAIKAIAIAR0IAMoAgAgBnZyNgIAIANBBGshAyAHIAJBAWsiAkkNAAsLIAAgBUECdGoiAiACKAIAIAR0NgIAIAAgATYCoAEgAAuUBAIJfwR+AkAgACgCACICRQ0AIAFBP3EiCEEBdCIBLwHQuEEiA0H/D3EiBCABLwHSuEFB/w9xayEFQQAgAmshCSAAQQhqIQogA0ELdiEDQeR1IQECQAJAAkADQCABIAVqQeR1Rg0DIAEgBGoiBkUNAyABIAlqQeR1Rg0BIAFB5HtGDQIgASAKaiABQQFqIQFBnApqLQAAIgcgBkHuw8EAai0AACIGRg0ACyADIAYgB0trIQMMAgsgA0EBayEDDAELQYAGQYAGQfDDwQAQKgALIABBB2oiBCADaiEFIAitIQ4DQCACIgFBAWshAgJAAkAgAUGBBkkEQCABIARqMQAAIA6GIA18IgsgC0IKgCINQnZ+fCEMIAIgA2pBgAZJDQEgDFANAiAAQQE6AIgGDAILIAJBgAZB9IbBABAqAAsgASAFaiAMPAAACyACDQALIAtCCloEQCADQQdqIQIDQCANIgsgC0IKgCINQnZ+fCEMAkAgAkEIa0GABk8EQCAMUA0BIABBAToAiAYMAQsgACACaiAMPAAACyACQQFrIQIgC0IKWg0ACwsgACAAKAIEIANqNgIEIABBgAYgACgCACADaiIBIAFBgAZPGyICNgIAIAFFDQADQCACQQFrIQECQCACQYAGTQRAIAAgAmpBB2otAABFDQEMAwsgAUGABkHkhsEAECoACyAAIAE2AgAgASICDQALCwvkAwIHfwR+IABBCGohBSABQT9xrSEKIAAoAgAhA0EAIQECQAJAA0AgASADRgRAIAlQDQMgCSAKiFBFBEAgAyEBDAMLIAMhAQNAIAFBAWohASAJQgp+IgkgCohQDQALDAILIAFBgAZHBEAgACABaiAB", + "QQFqIQFBCGoxAAAgCUIKfnwiCSAKiFANAQwCCwtBgAZBgAZBhIfBABAqAAsgACAAKAIEIAFrQQFqIgI2AgQgAkGBcE4EQEJ/IAqGQn+FIQxBACECIAEgA0kEQEGABiABayICQQAgAkGABk0bIQYgASADayEHIAEgBWohCCADIAFrIQIDQCAEIAZGBEAgASAEakGABkGUh8EAECoACyAEIAhqMQAAIAQgBWogCSAKiDwAACAJIAyDQgp+fCEJIAcgBEEBaiIEag0ACwsgCVBFBEADQCAJIgsgDINCCn4hCSALIAqIpyEBAkAgAkGABk8EQCABQf8BcUUNASAAQQE6AIgGDAELIAIgBWogAToAACACQQFqIQILIAlQRQ0ACwsgAkGABkshAwNAIAAgAjYCACACRQ0CIAJBAWshASADRQRAIAAgAmogASECQQdqLQAARQ0BDAMLCyABQYAGQeSGwQAQKgALIABBADoAiAYgAEIANwIACwvxBwIDfwF+IwBBMGsiBSQAAkAgACgCACIGIAEgAiAAKAIEIgEoAgwiAhEEAARAQQEhAQwBCwJAAkACQAJAIAAoAggiB0GAgIAEcUUEQEEBIQEgBkGD4sIAQQEgAhEEAA0FIAdBgICAEHENASAHQYCAgCBxDQIgAyAAEDhFDQQMBQsgBkHPhcEAQQIgAhEEAARAQQEhAQwFCyAFQQE6ABcgBSABNgIMIAUgBjYCCCAFQcyGwQA2AhwgBSAAKQIIIgg3AiAgBSAFQRdqNgIQIAUgBUEIajYCGAJAAkAgCKciAUGAgIAQcUUEQCABQYCAgCBxDQEgAyAFQRhqEDhFDQUMAgsgAygCACEBQQkhAgNAIAIgBWpBJmogAUEPcS0AiIRBOgAAIAJBAWshAiABQQR2IgENAAsgBUEYakEBQcSbwwBBAiACIAVqQSdqQQkgAmsQSw0BDAQLIAMoAgAhAUEJIQIDQCACIAVqQSZqIAFBD3EtAKCqQjoAACACQQFrIQIgAUEEdiIBDQAL", + "IAVBGGpBAUHEm8MAQQIgAiAFakEnakEJIAJrEEtFDQMLQQEhAQwECyADKAIAIQFBCSECA0AgAiAFakEWaiABQQ9xLQCIhEE6AAAgAkEBayECIAFBBHYiAQ0AC0EBIQEgAEEBQcSbwwBBAiACIAVqQRdqQQkgAmsQS0UNAgwDCyADKAIAIQFBCSECA0AgAiAFakEWaiABQQ9xLQCgqkI6AAAgAkEBayECIAFBBHYiAQ0AC0EBIQEgAEEBQcSbwwBBAiACIAVqQRdqQQkgAmsQSw0CDAELIAUoAhhBzYXBAEECIAUoAhwoAgwRBABFDQBBASEBDAELAkACQAJAIAAtAApBgAFxRQRAIAAoAgAiAkHGhcEAQQIgACgCBCIDKAIMIgYRBABFDQFBASEBDAQLIAVBAToAF0HMhsEAIQEgBUHMhsEANgIcIAUgACkCCDcCICAFIAAoAgQiAzYCDCAFIAAoAgAiAjYCCCAFIAVBF2o2AhAgBSAFQQhqNgIYAkAgBCgCACIAKAIAQX5HBEAgBSAANgIoIAVBGGpBqdvDAEEEIAVBKGpBCBBKDQEgBSgCHCEBIAUoAhghAAwDCyAFQQhqIQAgAEGl28MAQQQQTUUNAgtBASEBDAMLIAQoAgAiASgCAEF+RwRAIAUgATYCGEEBIQEgAEGp28MAQQQgBUEYakEIEEoNAyAAKAIEIQMgACgCACECDAILQQEhASACQaXbwwBBBCAGEQQADQIMAQsgAEHNhcEAQQIgASgCDBEEAEUNAEEBIQEMAQsgAkGE4sIAQQEgAygCDBEEACEBCyAFQTBqJAAgAQvYAwEHfyMAQRBrIgIkACAAKAIAIgMoAgAhByADKAIEIQhBASEFAkAgASgCACIAQZHdwwBBAyABKAIEIgYoAgwiBBEEAA0AIAggAyAHQX9GGyEDIAEtAApBgAFxRQRAIABBw4XBAEEDIAQRBAANASAAQZTdwwBBBiAEEQQADQEgAEHIhcEAQQIgBBEEAA0BIAMoAgQgAygC", + "CCAAIAYQcw0BIABBxoXBAEECIAQRBAANASAAQZrdwwBBBiAEEQQADQEgAEHIhcEAQQIgBBEEAA0BIAMoAhAgAygCFCAAIAYQcw0BIABBmYbBAEECIAQRBAAhBQwBCyAAQcqFwQBBAyAEEQQADQAgAiAGNgIEIAIgADYCACACQQE6AA8gAiACQQ9qIgE2AgggAkGU3cMAQQYQTQ0AIAJByIXBAEECEE0NACADKAIEIAMoAgggAkHMhsEAEHMNAAJAIAJBzYXBAEECEE0NACACIAY2AgQgAiAANgIAIAJBAToADyACIAE2AgggAkGa3cMAQQYQTQ0BIAJByIXBAEECEE0NASADKAIQIAMoAhQgAkHMhsEAEHMNASACQc2FwQBBAhBNDQAgAEGI4sIAQQEgBBEEACEFDAELCyACQRBqJAAgBQvSCAILfwF+QQEhCUEBIQwgBEEBRwRAQQEhCEEBIQcDQAJAIAQgBiAKaiIFSwRAIAMgCGotAAAiCCADIAVqLQAAIgVPBEAgBSAIRwRAQQEhCUEAIQYgByIKQQFqIQcMAwtBACAGQQFqIgUgBSAJRiIIGyEGIAVBACAIGyAHaiEHDAILIAYgB2pBAWoiByAKayEJQQAhBgwBCyAFIARB5IfBABAqAAsgBiAHaiIIIARJDQALQQEhCEEBIQdBACEGQQAhBQNAAkACQCAEIAUgBmoiC0sEQCADIAhqLQAAIgggAyALai0AACILSw0BIAggC0cEQEEBIQxBACEGIAciBUEBaiEHDAMLQQAgBkEBaiIIIAggDEYiCxshBiAIQQAgCxsgB2ohBwwCCyALIARB5IfBABAqAAsgBiAHakEBaiIHIAVrIQxBACEGCyAGIAdqIgggBEkNAAsLAkACQAJAAkACQCAKIAUgBSAKSSIHGyILIARNBEAgCSAMIAcbIgcgC2oiBSAHSSAEIAVJcg0BAn8gAyADIAdqIAsQ+gcEQCADIQYgBCEHA0BCASAGMQAAhiAQhCEQIAZBAWohBiAH", + "QQFrIgcNAAsgBCALayIHIAsgByALSxtBAWohB0F/IQggCyEFQX8MAQsgBEEBayEOQQEhCkEAIQZBASEFQQAhDANAIAQgBSIIIAZqIg1LBEAgBCAGayAFQX9zaiIFIARPDQggDiAGIAxqayIJIARPDQcCQAJAIAMgBWotAAAiBSADIAlqLQAAIglPBEAgBSAJRg0BIAhBAWohBUEAIQZBASEKIAghDAwCCyANQQFqIgUgDGshCkEAIQYMAQtBACAGQQFqIgUgBSAKRiIJGyEGIAVBACAJGyAIaiEFCyAHIApHDQELC0EBIQpBACEGQQEhBUEAIQkDQCAEIAUiCCAGaiIPSwRAIAQgBmsgBUF/c2oiBSAETw0FIA4gBiAJamsiDSAETw0GAkACQCADIAVqLQAAIgUgAyANai0AACINTQRAIAUgDUYNASAIQQFqIQVBACEGQQEhCiAIIQkMAgsgD0EBaiIFIAlrIQpBACEGDAELQQAgBkEBaiIFIAUgCkYiDRshBiAFQQAgDRsgCGohBQsgByAKRw0BCwsgBCAJIAwgCSAMSxtrIQUCQCAHRQRAQQAhB0EAIQgMAQtBACEIQQAhBgNAQgEgAyAGajEAAIYgEIQhECAHIAZBAWoiBkcNAAsLIAQLIQYgACAENgI8IAAgAzYCOCAAIAI2AjQgACABNgIwIAAgBjYCKCAAIAg2AiQgACACNgIgIABBADYCHCAAIAc2AhggACAFNgIUIAAgCzYCECAAIBA3AwggAEEBNgIADwtBACALIARBpIjBABApAAsgByAFIARBlIjBABApAAsgBSAEQfSHwQAQKgALIA0gBEGEiMEAECoACyAJIARBhIjBABAqAAsgBSAEQfSHwQAQKgALpQgBAX8jAEEwayIFJAAgBSADNgIEIAUgAjYCACAFIAE2AggCQAJAAkACQAJAAkAgASACTwRAIAEgA0kNBiACIANLDQEgAkUgASACTXINAyAAIAJqLAAAQb9/Sg0DIAAgAkEBayIDaiwA", + "AEG/f0wEQCACQQJrIgMgAkEDayAAIANqLAAAQb9/ShshAwsDQAJAIAEgAkcEQCAAIAJqLAAAQb9/TA0BDAULIAEgAUG0iMEAECoACyACQQFqIgIgAUkNAAsgASECDAILIAUgBUEIaq1CgICAgMAAhDcDICAFIAWtQoCAgIDAAIQ3AxhB3onAACAFQRhqIAQQNQALIAUgBUEEaq1CgICAgMAAhDcDICAFIAWtQoCAgIDAAIQ3AxhBgoTAACAFQRhqIAQQNQALIAUgAzYCDCAFIAI2AhACQCACIANJDQACQCABIANGDQAgAwRAIAAgA2osAABBv39MDQILIAEgAkYNACAAIAJqLAAAQb9/TA0BCyACIANGDQIgBQJ/IAAgA2oiASwAACIAQQBOBEAgAEH/AXEMAQsgAS0AAUE/cSIDIABBH3EiAkEGdHIgAEFfTQ0AGiABLQACQT9xIANBBnRyIgMgAkEMdHIgAEFwSQ0AGiACQRJ0QYCA8ABxIAEtAANBP3EgA0EGdHJyCzYCFCAFIAVBDGqtQoCAgICQAYQ3AyggBSAFQRRqrUKAgICAoAGENwMgIAUgBa1CgICAgMAAhDcDGEH9y8AAIAVBGGogBBA1AAsgACABIAMgAiAEEFoACyADRSABIANNcg0CIAAgA2osAABBv39KDQIgACADQQFrIgJqLAAAQb9/TARAIANBAmsiAiADQQNrIAAgAmosAABBv39KGyECCwJAA0ACQCABIANHBEAgACADaiwAAEG/f0wNAQwDCyABIAFBtIjBABAqAAsgA0EBaiIDIAFJDQALIAEhAwsgBSACNgIMIAUgAzYCECACIANLDQECQCABIAJGDQAgAgRAIAAgAmosAABBv39MDQMLIAEgA0YNACAAIANqLAAAQb9/TA0CCyACIANGDQAgBQJ/IAAgAmoiASwAACIAQQBOBEAgAEH/AXEMAQsgAS0AAUE/cSIDIABBH3EiAkEGdHIgAEFfTQ0AGiABLQACQT9xIANBBnRyIgMg", + "AkEMdHIgAEFwSQ0AGiACQRJ0QYCA8ABxIAEtAANBP3EgA0EGdHJyCzYCFCAFIAVBDGqtQoCAgICQAYQ3AyggBSAFQRRqrUKAgICAoAGENwMgIAUgBUEEaq1CgICAgMAAhDcDGEHPzMAAIAVBGGogBBA1AAsgBBBdAAsgACABIAIgAyAEEFoACyAFIAVBCGqtQoCAgIDAAIQ3AyAgBSAFQQRqrUKAgICAwACENwMYQZuKwAAgBUEYaiAEEDUAC+EDAQN/IwBBEGsiBCQAAkACQAJAIAEoAggiAkGAgIAQcUUEQCACQYCAgCBxDQEgACABEDhFDQJBASECDAMLIAAoAgAhAkEJIQMDQCADIARqQQZqIAJBD3EtAIiEQToAACADQQFrIQMgAkEEdiICDQALQQEhAiABQQFBxJvDAEECIAMgBGpBB2pBCSADaxBLRQ0BDAILIAAoAgAhAkEJIQMDQCADIARqQQZqIAJBD3EtAKCqQjoAACADQQFrIQMgAkEEdiICDQALQQEhAiABQQFBxJvDAEECIAMgBGpBB2pBCSADaxBLDQELIAEoAgBBjKjCAEECIAEoAgQoAgwRBAAEQEEBIQIMAQsgAEEEaiEAAkAgASgCCCICQYCAgBBxRQRAIAJBgICAIHENASAAIAEQOCECDAILIAAoAgAhAkEJIQMDQCADIARqQQZqIAJBD3EtAIiEQToAACADQQFrIQMgAkEEdiICDQALIAFBAUHEm8MAQQIgAyAEakEHakEJIANrEEshAgwBCyAAKAIAIQJBCSEDA0AgAyAEakEGaiACQQ9xLQCgqkI6AAAgA0EBayEDIAJBBHYiAg0ACyABQQFBxJvDAEECIAMgBGpBB2pBCSADaxBLIQILIARBEGokACACC40BAQR/IwBBEGsiAiQAAn9BASABKAIAIgNBJyABKAIEIgUoAhAiAREFAA0AGiACIAAoAgBBgQIQUQJAIAItAA0iAEGBAU8EQCADIAIoAgAgAREFAEUNAUEBDAILIAMg", + "AiACLQAMIgRqIAAgBGsgBSgCDBEEAEUNAEEBDAELIANBJyABEQUACyACQRBqJAALDgBBxIjBAEErIAAQPgALDgAgAEKAgICAsAEQgAgLDQAgAUHwqsIAQRgQKwsOACAAQoCAgIDAARCACAsNACABQdCqwgBBIBArCzoBAX8jAEEQayIDJAAgAyABNgIEIAMgADYCACADIAOtQoCAgIDgAIQ3AwhBjJbAACADQQhqIAIQNQALLAEBfyABBEADQCACIAAsAABBv39KaiECIABBAWohACABQQFrIgENAAsLIAILDgBB3IrBAEEzIAAQNQAL7gIBAX8CQCACBEAgAS0AAEEwTQ0BIAVBAjsBAAJAAkACQAJAIAPBIgZBAEoEQCAFIAE2AgQgAiADQf//A3EiA0sNAiAFQQA7AQwgBSACNgIIIAUgAyACazYCECAEDQFBAiEBDAQLIAUgAjYCICAFIAE2AhwgBUECOwEYIAVBADsBDCAFQQI2AgggBUG4hMEANgIEIAVBACAGayIDNgIQQQMhASACIARPDQMgBCACayICIANNDQMgAiAGaiEEDAILIAVBATYCICAFQeSdwwA2AhwgBUECOwEYDAELIAVBAjsBGCAFQQE2AhQgBUHkncMANgIQIAVBAjsBDCAFIAM2AgggBSACIANrIgI2AiAgBSABIANqNgIcIAIgBE8EQEEDIQEMAgsgBCACayEECyAFIAQ2AiggBUEAOwEkQQQhAQsgACABNgIEIAAgBTYCAA8LQZSLwQBBIUG4i8EAED4AC0HIi8EAQR9B6IvBABA+AAvUAgEFf0EZQQAgAEG51AVPGyIBIAFBDWoiASAAIAFBAnQoApyMQUH///8AcUkbIgEgAUEGaiIBIAAgAUECdCgCnIxBQf///wBxSRsiASABQQNqIgEgACABQQJ0KAKcjEFB////AHFJGyIBIAFBAmoiASAAIAFBAnQoApyMQUH///8AcUkbIgEgAUEBaiIBIAAgAUECdCgCnIxBQf///wBx", + "SRsiAUECdCgCnIxBQQt0IgIgAEELdCIERiACIARJaiABaiIEQQJ0IgFBnIzBAGohBSABKAKcjEFBFXYhAUHvCyECAkAgBEExTQRAIAUoAgRBFXYhAiAERQ0BCyAFQQRrKAIAQf///wBxIQMLAkAgAiABQX9zakUNACAAIANrIQMgAkEBayECQQAhAANAIAAgAUHQ2cAAai0AAGoiACADSw0BIAIgAUEBaiIBRw0ACwsgAUEBcQuDAwEFfyABQYCACE8EQCAAQX82AgAPCyACIAFBDHZB8P8/cWoiBSgCACEEQQAhAgJAAkACQCAFKAIEIgMOAgIBAAsgAUH//wNxIQYDQCACIANBAXYiByACaiICIAQgAkEGbGovAQAgBksbIQIgAyAHayIDQQFLDQALCyAEIAJBBmxqIgIvAQAiAyABQf//A3EiBEsNACADIAJBAmotAABqQf//A3EgBEkNACACLQADIAEgA3NxQQFxDQAgAEIANwIEIAAgAUGAgARxIAIvAQQgAWpB//8DcXI2AgAPCyAFKAIIIQRBACECAkACQAJAAkAgBSgCDCIDDgICAQALIAFB//8DcSEFA0AgAiADQQF2IgYgAmoiAiAEIAJBA3RqLwEAIAVLGyECIAMgBmsiA0EBSw0ACwsgBCACQQN0aiICLwEAIAFB//8DcUYNAQsgAEF/NgIADwsgACABQYCABHEiASACLwEGcjYCCCAAIAEgAi8BBHI2AgQgACABIAIvAQJyNgIAC9QCAQV/QRJBACAAQfO9BE8bIgEgAUEJciIBIAAgAUECdCgCqKhBQf///wBxSRsiASABQQRyIgEgACABQQJ0KAKoqEFB////AHFJGyIBIAFBAmoiASAAIAFBAnQoAqioQUH///8AcUkbIgEgAUEBaiIBIAAgAUECdCgCqKhBQf///wBxSRsiASABQQFqIgEgACABQQJ0KAKoqEFB////AHFJGyIBQQJ0KAKoqEFBC3QiAiAAQQt0IgRGIAIgBElqIAFqIgRB", + "AnQiAUGoqMEAaiEFIAEoAqioQUEVdiEBQZcHIQICQCAEQSJNBEAgBSgCBEEVdiECIARFDQELIAVBBGsoAgBB////AHEhAwsCQCACIAFBf3NqRQ0AIAAgA2shAyACQQFrIQJBACEAA0AgACABQfTwwABqLQAAaiIAIANLDQEgAiABQQFqIgFHDQALCyABQQFxC+ABAQR/IABBhz9LIgFBAkEBIAEbIgEgACABQQJ0KALErEFB////AHFJGyIBIAFBAnQoAsSsQUELdCIBIABBC3QiAklqIAEgAkZqIgNBAnQiAUHErMEAaiEEQRUhAiABKALErEFBFXYhAQJ/AkAgA0EBSw0AIAQoAgRBFXYhAiADDQBBAAwBCyAEQQRrKAIAQf///wBxCyEDAkAgAiABQX9zakUNACAAIANrIQMgAkEBayECQQAhAANAIAAgAUH7gMEAai0AAGoiACADSw0BIAIgAUEBaiIBRw0ACwsgAUEBcQsSAEHAlcIAQZkBQYyWwgAQNQALIwEBf0EBIABBAXJnQR9zIgEgAUEBdmsiAXQgACABdmpBAXYLjQYCCX8FfiMAQRBrIgskAAJAAkACfwJAAkAgAVBFBEBBoH8gAiABeSIPp2siBmvBQdAAbEGwpwVqQc4QbSICQdAASw0BIAsgAkEEdCICKQOglkJCACABIA+GQgAQ/gcgCykDCCALKQMAQj+IfCIBQUAgBiACLwGolkJqayIJrSIPiKchBiACLwGqlkIhAkIBIA+GIhFCAX0iEiABgyIPUARAIARBCksNBSAEQQJ0QZSmwgBqKAIAIAZLDQULIAlBP3EhCCAGQZDOAE8EQCAGQcCEPUkNAyAGQYDC1y9PBEBBCEEJIAZBgJTr3ANJIgcbIQpBgMLXL0GAlOvcAyAHGwwFC0EGQQcgBkGAreIESSIHGyEKQcCEPUGAreIEIAcbDAQLIAZB5ABPBEBBAkEDIAZB6AdJIgcbIQpB5ABB6AcgBxsMBAtBCkEBIAZBCUsiChsMAwtB", + "sKDCAEEcQcygwgAQPgALIAJB0QBB3KDCABAqAAtBBEEFIAZBoI0GSSIHGyEKQZDOAEGgjQYgBxsLIQcgCK0hEAJAAkACQAJAIAogAmtBAWrBIgggBcEiAkoEQCAJQf//A3EhDSAIIAVrwSAEIAggAmsgBEkbIglBAWshDkEAIQIDQCAGIAduIQwgAiAERg0DIAYgByAMbGshBiACIANqIAxBMGo6AAAgAiAORg0EIAIgCkYNAiACQQFqIQIgB0EKSSAHQQpuIQdFDQALQeygwgAQZAALIAAgAyAEQQAgCCAFIAFCCoAgB60gEIYgERBtDAULIAJBAWohAiANQQFrQT9xrSETQgEhAQNAIAEgE4hQRQRAIABBADYCAAwGCyACIARPDQMgAiADaiAPQgp+Ig8gEIinQTBqOgAAIAFCCn4hASAPIBKDIQ8gCSACQQFqIgJHDQALIAAgAyAEIAkgCCAFIA8gESABEG0MBAsgBCAEQfygwgAQKgALIAAgAyAEIAkgCCAFIAatIBCGIA98IAetIBCGIBEQbQwCCyACIARBjKHCABAqAAsgAEEANgIACyALQRBqJAAL5gIBBH8CQAJAAkACQAJAAkACQCAHIAhWBEAgByAIfSAIWA0EIAYgByAGfVQgByAGQgGGfSAIQgGGWnENAyAGIAhYDQcgByAGIAh9IgZ9IAZWDQcgAiADSQ0FIAEgA2ohDCADIQkDQCAJIgpFDQIgCkEBayIJIAFqIgstAABBOUYNAAsgCyALLQAAQQFqOgAAIAMgCmsiBUUNAiABIApqQTAgBfwLAAwCCyAAQQA2AgAPCwJAIANFBEBBMSEJDAELIAFBMToAAEEwIQkgA0EBayIKRQ0AIAFBAWpBMCAK/AsACyAEQQFqwSIEIAXBTCACIANNcg0AIAwgCToAACADQQFqIQMLIAIgA08NA0EAIAMgAkHcp8IAECkACyACIANPDQJBACADIAJB/KfCABApAAsgAEEANgIADwtBACADIAJB7KfCABAp", + "AAsgACAEOwEIIAAgAzYCBCAAIAE2AgAPCyAAQQA2AgAL/hYCFn8DfiMAQcAGayIFJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEpAwAiG1BFBEAgASkDCCIcUA0BIAEpAxAiHVANAiAdIBtCf4VWDQMgGyAcVA0EIAEuARghASAFIBs3AwggBUEBQQIgG0KAgICAEFQbNgKoASAFQRBqQQBBmAH8CwAgBUG0AWpBAEGcAfwLACAFQQE2ArABIAVBATYC0AIgAawgG0IBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyIHwSEMAkAgAUEATgRAIAVBCGogARBUGgwBCyAFQbABakEAIAFrwRBUGgsCQCAMQQBIBEAgBUEIakEAIAxrQf//A3EQbwwBCyAFQbABaiAHQf//AXEQbwsgBUGcBWogBUGwAWpBpAH8CgAAIAMiCUEKTwRAIAVBmAVqIQcDQCAFKAK8BiIBQShLDQsgAQRAIAFBAnQhAUIAIRsDQCABIAdqIgYgBjUCACAbQiCGhCIbQoCU69wDgCIcPgIAIBsgHEKAlOvcA359IRsgAUEEayIBDQALCyAJQQlrIglBCUsNAAsLIAlBAnQoApimQkEBdCIHRQ0FAn8CQCAFKAK8BiIBQShNBEAgAQ0BQQAMAgsMCwsgAUECdCEBIAVBmAVqIQYgB60hG0IAIRwDQCABIAZqIgcgBzUCACAcQiCGhCIcIBuAIh0+AgAgHCAbIB1+fSEcIAFBBGsiAQ0ACyAFKAK8BgshAQJAAkAgBSgCqAEiBiABIAEgBkkbIghBKE0EQCAIDQFBACEIDAILDAwLQQAhCSAFQQhqIQogBUGcBWohASAIIQcDQCABIAooAgAiDSABKAIAaiILIAlBAXFqIgk2AgAgCyANSSAJIAtJciEJIAFBBGohASAKQQRqIQogB0EBayIHDQALIAlFDQAgCEEoRg0MIAVBnAVqIAhBAnRqQQE2AgAgCEEBaiEICyAFIAg2ArwGIAUo", + "AtACIg0gCCAIIA1JGyIBQSlPDQkgAUECdCEBIAVBmAVqIQcCQAJAA0AgAUUNASABIAdqKAIAIgggAUEEayIBIAVBsAFqaigCACIJRg0ACyAIIAlPDQAgBkUEQEEAIQYgBUEANgKoAQwCCyAGQQJ0IgogBUEIaiIBaiEHQgAhGwNAIAEgATUCAEIKfiAbfCIbPgIAIAFBBGohASAbQiCIIRsgCkEEayIKDQALIBtQRQRAIAZBKEYNDiAHIBs+AgAgBkEBaiEGCyAFIAY2AqgBDAELIAxBAWohDAtBASEHAkAgDMEiASAEwSIISCIVRQRAIAwgBGvBIAMgASAIayADSRsiCw0BC0EAIQsMCAsgBUHUAmoiASAFQbABaiIHQaQB/AoAACABQQEQVCAFQfgDaiIEIAdBpAH8CgAAIARBAhBUIQQgBUGcBWoiCCAHQaQB/AoAACAFQQRqIRYgBUGsAWohFyAFQdACaiEYIAVB9ANqIRkgBUGYBWohGiAIQQMQVCEHKAKgASESIAQoAqABIRMgBygCoAEhFAJAAkADQCARIQ4gBkEpTw0PIA5BAWohESAGQQJ0IQRBACEBA0AgASAERg0DIAVBCGogAWogAUEEaiEBKAIARQ0ACyAUIAYgBiAUSRsiBEEpTw0QIARBAnQhAQJ/AkADQCABRQ0BIAEgGmohByABQQRrIgEgBUEIamooAgAiCCAHKAIAIgdGDQALQQAgByAISw0BGgtBASEJIAVBnAVqIQogBUEIaiEBIAQhBwNAIAEgASgCACIIIAooAgBBf3NqIgYgCUEBcWoiCTYCACAGIAhJIAYgCUtyIQkgAUEEaiEBIApBBGohCiAHQQFrIgcNAAsgCUUNEiAFIAQ2AqgBIAQhBkEICyEPIBMgBiAGIBNJGyIEQSlPDRAgBEECdCEBAkACQANAIAFFDQEgASAZaiEHIAFBBGsiASAFQQhqaigCACIIIAcoAgAiB0YNAAsgByAITQ0AIAYhBAwBCyAEBEBBASEJIAVB", + "+ANqIQogBUEIaiEBIAQhBwNAIAEgASgCACIIIAooAgBBf3NqIgYgCUEBcWoiCTYCACAGIAhJIAYgCUtyIQkgAUEEaiEBIApBBGohCiAHQQFrIgcNAAsgCUUNEwsgBSAENgKoASAPQQRyIQ8LIBIgBCAEIBJJGyIIQSlPDQ0gCEECdCEBAkACQANAIAFFDQEgASAYaiEHIAFBBGsiASAFQQhqaigCACIGIAcoAgAiB0YNAAsgBiAHTw0AIAQhCAwBCyAIBEBBASEJIAVB1AJqIQogBUEIaiEBIAghBwNAIAEgASgCACIGIAooAgBBf3NqIgQgCUEBcWoiCTYCACAEIAZJIAQgCUtyIQkgAUEEaiEBIApBBGohCiAHQQFrIgcNAAsgCUUNEwsgBSAINgKoASAPQQJqIQ8LIA0gCCAIIA1JGyIGQSlPDQ8gBkECdCEBAkACQANAIAFFDQEgASAXaiEEIAEgFmogAUEEayEBKAIAIgcgBCgCACIERg0ACyAEIAdNDQAgCCEGDAELIAYEQEEBIQkgBUGwAWohCiAFQQhqIQEgBiEHA0AgASABKAIAIgggCigCAEF/c2oiBCAJQQFxaiIJNgIAIAQgCEkgBCAJS3IhCSABQQRqIQEgCkEEaiEKIAdBAWsiBw0ACyAJRQ0TCyAFIAY2AqgBIA9BAWohDwsgAyAORg0BIAIgDmogD0EwajoAAAJAIAZFBEBBACEGDAELIAZBAnQiCiAFQQhqIgFqQgAhGwNAIAEgATUCAEIKfiAbfCIbPgIAIAFBBGohASAbQiCIIRsgCkEEayIKDQALIBtQDQAgBkEoRg0PIBs+AgAgBkEBaiEGCyAFIAY2AqgBIAsgEUcNAAtBACEHDAkLIAMgA0HYpMIAECoACyADIAtJDQYCQCALIA5GDQAgCyAOayIBRQ0AIAIgDmpBMCAB/AsACyAAIAw7AQggACALNgIEDAgLQbCgwgBBHEH4o8IAED4AC0GsocIAQR1BiKTCABA+AAtB3KHCAEEc", + "QZikwgAQPgALQbCjwgBBNkGIpcIAED4AC0HoosIAQTdB+KTCABA+AAtB5IXBAEEbQZyGwQAQPgALIA4gCyADQeikwgAQKQALAkACfwJAAkACQAJAIA1FDQAgDUECdCIKIAVBsAFqIgFqQgAhGwNAIAEgATUCAEIFfiAbfCIbPgIAIAFBBGohASAbQiCIIRsgCkEEayIKDQALIBtQBEAgDSEQDAELIA1BKEYNCSAbPgIAIA1BAWohEAsgBSAQNgLQAiAQIAYgBiAQSRsiAUEpTw0GIAFBAnQhASAFQQRqIQggBUGsAWohCQJAAkADQCABRQ0BIAEgCWohBiABIAhqIAFBBGshASgCACIEIAYoAgAiBkYNAAsgBCAGSyAEIAZJa0H/AXEOAgABBAtBACAHDQQaIAtBAWsiASADTw0BIAEgAmotAABBAXFFDQMLIAMgC0kNASACIAtqIAshAQJAA0AgASIERQ0BIAFBAWsiASACaiIGLQAAQTlGDQALIAYgBi0AAEEBajoAACALIARrIgFFDQMgAiAEakEwIAH8CwAMAwtBMSEBAkAgBw0AIAJBMToAAEEwIQEgC0EBayIERQ0AIAJBAWpBMCAE/AsACyAMQQFqIQwgFSADIAtNcg0CIAE6AAAgC0EBaiELDAILIAEgA0GopMIAECoAC0EAIAsgA0G4pMIAECkACyADIAtJDQEgCwshASAAIAw7AQggACABNgIEDAELQQAgCyADQcikwgAQKQALIAAgAjYCACAFQcAGaiQADwtBACABQShBnIbBABApAAtBACAIQShBnIbBABApAAtBKEEoQZyGwQAQKgALQQAgBkEoQZyGwQAQKQALQQAgBEEoQZyGwQAQKQALQf+FwQBBGkGchsEAED4AC84EAgR/An4CQAJAAkAgAUEITwRAIAFBB3EiA0UNAQJAIAAoAqABIgJBKE0EQCACDQEgAEEANgKgAQwDCwwDCyAAIAJBAnQiBGohBSADQQJ0KAKYpkIgA3atIQcgACED", + "A0AgAyADNQIAIAd+IAZ8IgY+AgAgA0EEaiEDIAZCIIghBiAEQQRrIgQNAAsgACAGUAR/IAIFIAJBKEYNBCAFIAY+AgAgAkEBags2AqABDAELAkAgACgCoAEiAkEoTQRAIAINASAAQQA2AqABDwsMAgsgAUECdDUCmKZCIQcgACACQQJ0IgRqIQEgACEDA0AgAyADNQIAIAd+IAZ8IgY+AgAgA0EEaiEDIAZCIIghBiAEQQRrIgQNAAsgACAGUAR/IAIFIAJBKEYNAyABIAY+AgAgAkEBags2AqABDwsCQCABQQhxBEACQAJAIAAoAqABIgJBKE0EQCACDQFBACECDAILDAQLIAAgAkECdCIEakIAIQYgACEDA0AgAyADNQIAQuHrF34gBnwiBj4CACADQQRqIQMgBkIgiCEGIARBBGsiBA0ACyAGUA0AIAJBKEYNAiAGPgIAIAJBAWohAgsgACACNgKgAQsgAUEQcQRAIABBwKbCAEECEFMLIAFBIHEEQCAAQcimwgBBAxBTCyABQcAAcQRAIABB1KbCAEEFEFMLIAFBgAFxBEAgAEHopsIAQQoQUwsgAUGAAnEEQCAAQZCnwgBBExBTCyAAIAEQVBoPCwwBC0EAIAJBKEGchsEAECkAC0EoQShBnIbBABAqAAumDAISfgl/IwBB0ABrIhYkAAJAAkACQAJAAkACQAJAAkACQCABKQMAIgNQRQRAIAEpAwgiBFANASABKQMQIgZQDQIgBiADIAZ8IgVWDQMgAyAEVA0EIAVCgICAgICAgIAgWg0FIBYgAS8BGCIBOwFAIBYgAyAEfSIGNwM4IBYgBiAFeSIEhiIIIASIIgc3A0ggBiAHUg0JIBYgATsBQCAWIAM3AzggFiADIASGIgYgBIgiBzcDSCADIAdSDQlBoH8gASAEp2siGGvBQdAAbEGwpwVqQc4QbSIBQdAASw0HIBZBIGogAUEEdCIBKQOglkIiA0IAIAUgBIZCABD+ByAWQRBqIANCACAIQgAQ/gcg", + "FiADQgAgBkIAEP4HQgFBACAYIAEvAaiWQmprIhitIgOGIghCAX0hCSAWKQMQQj+HIQwgFikDAEI/iCEOIBYpAwghDyABLwGqlkIhASAYQT9xIRggFikDGCEQIBYpAygiEyAWKQMgQj+IIhR8IhFCAXwiByADiKciF0GQzgBPBEAgF0HAhD1JDQcgF0GAwtcvTwRAQQhBCSAXQYCU69wDSSIVGyEZQYDC1y9BgJTr3AMgFRshFQwKC0EGQQcgF0GAreIESSIVGyEZQcCEPUGAreIEIBUbIRUMCQsgF0HkAE8EQEECQQMgF0HoB0kiFRshGUHkAEHoByAVGyEVDAkLQQpBASAXQQlLIhkbIRUMCAtBsKDCAEEcQZyhwgAQPgALQayhwgBBHUHMocIAED4AC0HcocIAQRxB+KHCABA+AAtBsKPCAEE2QeijwgAQPgALQeiiwgBBN0Ggo8IAED4AC0GIosIAQS1BuKLCABA+AAtBBEEFIBdBoI0GSSIVGyEZQZDOAEGgjQYgFRshFQwBCyABQdEAQdygwgAQKgALIAcgCYMhBCAOIA98IQogGK0hCyAZIAFrQQFqIRsgDCAQfSAHfEIBfCINIAmDIQVBACEBAkACQAJAAkACQAJAAkACQAJAA0AgASACaiIcIBcgFW4iHUEwaiIaOgAAIAFBAWohGCANIBcgFSAdbGsiF60gC4YiEiAEfCIDVg0CIAEgGUYEQEIBIQMDQCADIQYgASIYQRBGDQUgASACakEBaiAEQgp+IgQgC4inQTBqIhc6AAAgA0IKfiEDIAFBAWohASAFQgp+IgUgBCAJgyIEWA0ACyAFIAR9IgsgCFQhFSADIAcgCn1+IgkgA3whByAEIAkgA30iCVoNByAIIAtYDQIMBwsgFUEKSSAVQQpuIRUgGCEBRQ0AC0HIosIAEGQACyABIAJqIQEgBSAIfSELIAggCX0hDUIAIAR9IQoDQCAEIAh8IgMgCVQgCSAKfCAEIA18WnJFBEBBACEVDAYLIAEg", + "F0EBayIXOgAAIAogC3wiDCAIVCEVIAMgCVoNBiAKIAh9IQogAyEEIAggDFgNAAsMBQsgDSADfSIFIBWtIAuGIgZUIQEgByAKfSIHQgF8IQggBSAGVCADIAdCAX0iCVpyDQEgDCARfCAQfSAEIAZ8IgQgEnx9QgJ8IQsgESAKfSADfSEKIAQgDnwgD3wgFH0gE30gEnwhB0IAIQQDQCADIAZ8IgUgCVQgBCAKfCAHWnJFBEBBACEBDAMLIBwgGkEBayIaOgAAIAQgC3wiDCAGVCEBIAUgCVoNAyAGIAd8IQcgBCAGfSEEIAUhAyAGIAxYDQALDAILQRFBEUHYosIAECoACyADIQULAkAgBSAIWiABcg0AIAggBSAGfCIDWCAIIAV9IAMgCH1UcQ0AIABBADYCAAwECyAFIA1CBH1YIAVCAlpxRQRAIABBADYCAAwECyAAIBs7AQggACAYNgIEDAILIAQhAwsCQCADIAdaIBVyDQAgByADIAh8IgRYIAcgA30gBCAHfVRxDQAgAEEANgIADAILIAMgBSAGQlh+fFggAyAGQhR+WnFFBEAgAEEANgIADAILIAAgGzsBCCAAIBhBAmo2AgQLIAAgAjYCAAsgFkHQAGokAA8LIwBBEGsiACQAIAAgFkE4ajYCDCAAIBZByABqNgIIIABBCGpBmITBACAAQQxqQZiEwQBBACAAQdSFwQAQRgALqxoCGX8EfiMAQbAKayIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAEpAwAiHVBFBEAgASkDCCIfUA0BIAEpAxAiHlANAiAdIB58IhwgHlQNAyAdIB9UDQQgASwAGiEQIAEuARghBiADIB03AwggA0EBQQIgHUKAgICAEFQbNgKoASADQRBqQQBBmAH8CwAgAyAfNwOwASADQQFBAiAfQoCAgIAQVBs2AtACIANBuAFqQQBBmAH8CwAgAyAeNwPYAiADQQFBAiAeQoCAgIAQVBs2AvgDIANB4AJqQQBBmAH8", + "CwAgA0GABGpBAEGcAfwLACADQQE2AvwDIANBATYCnAUgBqwgHEIBfXl9QsKawegEfkKAoc2gtAJ8QiCIpyIBwSEOAkAgBkEATgRAIANBCGogBhBUGiADQbABaiAGEFQaIANB2AJqIAYQVBoMAQsgA0H8A2pBACAGa8EQVBoLAkAgDkEASARAIANBCGpBACAOa0H//wNxIgEQbyADQbABaiABEG8gA0HYAmogARBvDAELIANB/ANqIAFB//8BcRBvCyADQYwJaiADQQhqQaQB/AoAAAJAAkAgAygC+AMiBiADKAKsCiIBIAEgBkkbIgdBKE0EQCAHDQFBACEHDAILDAwLIANB2AJqIQggA0GMCWohASAHIQQDQCABIAgoAgAiCyABKAIAaiIKIAVBAXFqIgU2AgAgCiALSSAFIApJciEFIAFBBGohASAIQQRqIQggBEEBayIEDQALIAVFDQAgB0EoRg0NIANBjAlqIAdBAnRqQQE2AgAgB0EBaiEHCyADIAc2AqwKIAcgAygCnAUiDyAHIA9LGyIBQSlPDQ0gAUECdCEBIANBiAlqIQcCQAJ/A0BBACABRQ0BGiABIAdqIQQgAUEEayIBIANB/ANqaigCACIFIAQoAgAiBEYNAAsgBCAFSSAEIAVLawsgEE4EQAJAAkAgAygCqAEiBUEoTQRAIAUNAUEAIQUMAgtBACAFQShBnIbBABApAAsgBUECdCIIIANBCGoiAWpCACEcA0AgASABNQIAQgp+IBx8Ihw+AgAgAUEEaiEBIBxCIIghHCAIQQRrIggNAAsgHFANACAFQShGDQ8gHD4CACAFQQFqIQULIAMgBTYCqAEgAygC0AIiBEEoSw0HQQAhCyADAn9BACAERQ0AGiAEQQJ0IgggA0GwAWoiAWpCACEcA0AgASABNQIAQgp+IBx8Ihw+AgAgAUEEaiEBIBxCIIghHCAIQQRrIggNAAsgBCAcUA0AGiAEQShGDQ8gHD4CACAEQQFqCzYC0AIgBgRAIAZBAnQi", + "CCADQdgCaiIBakIAIRwDQCABIAE1AgBCCn4gHHwiHD4CACABQQRqIQEgHEIgiCEcIAhBBGsiCA0ACyAcUARAIAMgBiILNgL4AwwDCyAGQShGDQ8gHD4CACAGQQFqIQsLIAMgCzYC+AMMAQsgDkEBaiEOIAMoAqgBIQUgBiELCyADQaAFaiIBIANB/ANqIgZBpAH8CgAAIAFBARBUIQQgA0HEBmoiASAGQaQB/AoAACABQQIQVCEBIANB6AdqIgcgBkGkAfwKAAACQAJAIAdBAxBUKAKgASIRIAUgBSARSRsiBkEoTQRAIANB+ANqIRUgA0GICWohFiADQawBaiEXIANBnAVqIRggA0HABmohGSADQeQHaiEaIAQoAqABIRIgASgCoAEhE0EAIQcDQCAHIQ0gBkECdCEBAn8CQANAIAFFDQEgASAaaiEEIAFBBGsiASADQQhqaigCACIHIAQoAgAiBEYNAAtBACAEIAdLDQEaCyAGBEBBASEFIANB6AdqIQggA0EIaiEBIAYhBANAIAEgASgCACIKIAgoAgBBf3NqIgkgBUEBcWoiBzYCACAJIApJIAcgCUlyIQUgAUEEaiEBIAhBBGohCCAEQQFrIgQNAAsgBUUNFAsgAyAGNgKoASAGIQVBCAshCSATIAUgBSATSRsiBkEpTw0PIAZBAnQhAQJAAkADQCABRQ0BIAEgGWohBCABQQRrIgEgA0EIamooAgAiByAEKAIAIgRGDQALIAQgB00NACAFIQYMAQsgBgRAQQEhBSADQcQGaiEIIANBCGohASAGIQQDQCABIAEoAgAiCiAIKAIAQX9zaiIMIAVBAXFqIgc2AgAgByAMSSAKIAxLciEFIAFBBGohASAIQQRqIQggBEEBayIEDQALIAVFDRQLIAMgBjYCqAEgCUEEciEJCyASIAYgBiASSRsiB0EpTw0OIAdBAnQhAQJAAkADQCABRQ0BIAEgGGohBCABQQRrIgEgA0EIamooAgAiBSAEKAIAIgRGDQALIAQg", + "BU0NACAGIQcMAQsgBwRAQQEhBSADQaAFaiEIIANBCGohASAHIQQDQCABIAEoAgAiCiAIKAIAQX9zaiIMIAVBAXFqIgY2AgAgBiAMSSAKIAxLciEFIAFBBGohASAIQQRqIQggBEEBayIEDQALIAVFDRQLIAMgBzYCqAEgCUECaiEJCyAPIAcgByAPSRsiBkEpTw0PIAZBAnQhAQJAAkADQCABRQ0BIAFBBGsiASADQQhqaigCACIFIAEgA0H8A2pqKAIAIgRGDQALIAQgBU0NACAHIQYMAQsgBgRAQQEhBSADQfwDaiEIIANBCGohASAGIQQDQCABIAEoAgAiCiAIKAIAQX9zaiIMIAVBAXFqIgc2AgAgByAMSSAKIAxLciEFIAFBBGohASAIQQRqIQggBEEBayIEDQALIAVFDRQLIAMgBjYCqAEgCUEBaiEJCyANQRFGDQogAiANaiAJQTBqOgAAIAMoAtACIgogBiAGIApJGyIBQSlPDREgDUEBaiEHIAFBAnQhAQJ/A0BBACABRQ0BGiABIBdqIQQgAUEEayIBIANBCGpqKAIAIgUgBCgCACIERg0ACyAEIAVJIAQgBUtrCyEbIANBjAlqIANBCGpBpAH8CgAAAkACQCALIAMoAqwKIgEgASALSRsiCUEoTQRAIAkNAUEAIQkMAgtBACAJQShBnIbBABApAAtBACEFIANB2AJqIQggA0GMCWohASAJIQQDQCABIAgoAgAiDCABKAIAaiIUIAVBAXFqIgU2AgAgBSAUSSAMIBRLciEFIAFBBGohASAIQQRqIQggBEEBayIEDQALIAVFDQAgCUEoRg0RIANBjAlqIAlBAnRqQQE2AgAgCUEBaiEJCyADIAk2AqwKIAkgDyAJIA9LGyIBQSlPDREgAUECdCEBAn8DQEEAIAFFDQEaIAEgFmohBSABIBVqIAFBBGshASgCACIJIAUoAgAiBEYNAAsgBCAJSSAEIAlLawshASAQIBtKDQIgASAQSA0DQQAhBCADAn9B", + "ACAGRQ0AGiAGQQJ0IgggA0EIaiIBakIAIRwDQCABIAE1AgBCCn4gHHwiHD4CACABQQRqIQEgHEIgiCEcIAhBBGsiCA0ACyAGIBxQDQAaIAZBKEYNESAcPgIAIAZBAWoLIgU2AqgBAkAgCkUNACAKQQJ0IgggA0GwAWoiAWpCACEcA0AgASABNQIAQgp+IBx8Ihw+AgAgAUEEaiEBIBxCIIghHCAIQQRrIggNAAsgHFAEQCAKIQQMAQsgCkEoRg0RIBw+AgAgCkEBaiEECyADIAQ2AtACAkAgC0UEQEEAIQsMAQsgC0ECdCIIIANB2AJqIgFqQgAhHANAIAEgATUCAEIKfiAcfCIcPgIAIAFBBGohASAcQiCIIRwgCEEEayIIDQALIBxQDQAgC0EoRg0RIBw+AgAgC0EBaiELCyADIAs2AvgDIBEgBSAFIBFJGyIGQSlJDQALCwwNCyABIBBODQkgA0EIakEBEFQaIA8gAygCqAEiASABIA9JGyIBQSlPDQ4gAUECdCEBIANBBGohCiADQfgDaiELA0AgAUUNASABIAtqIQUgASAKaiABQQRrIQEoAgAiBCAFKAIAIgZGDQALIAQgBkkNCQsgAiAHaiAHIQECQANAIAEiBkUNASABQQFrIgEgAmoiBS0AAEE5Rg0ACyAFIAUtAABBAWo6AAAgByAGayIBRQ0JIAIgBmpBMCAB/AsADAkLIAJBMToAACANBEAgAkEBakEwIA38CwALIA1BD0sNB0EwOgAAIA5BAWohDiANQQJqIQcMCQtBsKDCAEEcQZilwgAQPgALQayhwgBBHUGopcIAED4AC0HcocIAQRxBuKXCABA+AAtBsKPCAEE2QYimwgAQPgALQeiiwgBBN0H4pcIAED4AC0EAIARBKEGchsEAECkAC0ERQRFByKXCABAqAAsgB0ERQdilwgAQKgALIA1BEE0NAEEAIAdBEUHopcIAECkACyAAIA47AQggACAHNgIEIAAgAjYCACADQbAKaiQADwtBACAH", + "QShBnIbBABApAAtBACAGQShBnIbBABApAAtBKEEoQZyGwQAQKgALQQAgAUEoQZyGwQAQKQALQf+FwQBBGkGchsEAED4AC1ABAX8jAEEgayIDJAAgAyABNgIIIAMgADYCDCADIANBDGqtQoCAgIDAAIQ3AxggAyADQQhqrUKAgICAwACENwMQQYLOwAAgA0EQaiACEDUAC9wFAQt/IwBBEGsiCiQAQQEhDAJAIAJBIiADKAIQIg0RBQANAAJAAkACQCABRQRADAELIAEhBiAAIQkDQCAGIAlqIQ5BACELAkACQANAIAkgC2oiBy0AACIIQf8Aa0H/AXFBoQFJIAhBIkZyIAhB3ABGcg0BIAYgC0EBaiILRw0ACyAEIAZqIQQMAQsCfyAHLAAAIgZBAE4EQCAGQf8BcSEGIAdBAWoMAQsgBy0AAUE/cSEIIAZBH3EhCSAGQV9NBEAgCUEGdCAIciEGIAdBAmoMAQsgBy0AAkE/cSAIQQZ0ciEIIAZBcEkEQCAIIAlBDHRyIQYgB0EDagwBCyAJQRJ0QYCA8ABxIActAANBP3EgCEEGdHJyIQYgB0EEagshCSAEIAtqIQQgCiAGQYGABBBRAkAgCi0ADSIHIAotAAwiC2siCEH/AXFBAUYNAAJAAkAgASAESSAEIAVJcg0AAkAgASAFRg0AIAUEQCAAIAVqLAAAQb9/TA0CCyABIARGDQAgACAEaiwAAEG/f0wNAQsgAiAAIAVqIAQgBWsgAygCDCIFEQQARQ0BDAcLIAAgASAFIARBsKrCABBaAAsCQCAHQYEBTwRAIAIgCigCACANEQUADQcMAQsgAiAKIAtqIAggBREEAA0GCyAGQYABSQRAIARBAWohBQwBCyAGQYAQSQRAIARBAmohBQwBC0EDQQQgBkGAgARJGyAEaiEFCwJ/QQEgBkGAAUkNABpBAiAGQYAQSQ0AGkEDQQQgBkGAgARJGwsgBGohBCAOIAlrIgYNAQsLIAEgBEkgBCAFSXINASABIAVGBEAg", + "ASEFDAELIAUEQCAAIAVqLAAAQb9/TA0CCyABIARGBEAgASEEDAELIAAgBGosAABBQEgNAQsgAiAAIAVqIAQgBWsgAygCDBEEAA0CIAJBIiANEQUAIQwMAgsgACABIAUgBEHAqsIAEFoACwsgCkEQaiQAIAwLmAIBB38jAEEQayIDJABBCiECIAAoAgAiBCAEQR91IgBzIABrIgBB6AdPBEADQCADQQZqIAJqIgVBBGsgACIGIABBkM4AbiIAQZDOAGxrIgdB//8DcUHkAG4iCEEBdC8A8YhBOwAAIAVBAmsgByAIQeQAbGtB//8DcUEBdC8A8YhBOwAAIAJBBGshAiAGQf+s4gRLDQALCyAAQQlLBEAgAkECayICIANBBmpqIAAgAEH//wNxQeQAbiIAQeQAbGtB//8DcUEBdC8A8YhBOwAAC0EAIAQgABtFBEAgAkEBayICIANBBmpqIABBAXQtAPKIQToAAAsgASAEQX9zQR92QQFBACADQQZqIAJqQQogAmsQSyADQRBqJAALiQEBA38jAEEQayIDJABBAyECIAAtAAAiACEEIABBCk8EQCADIAAgAEHkAG4iBEHkAGxrQf8BcUEBdC8A8YhBOwAOQQEhAgtBACAAIAQbRQRAIAJBAWsiAiADQQ1qaiAEQQF0LQDyiEE6AAALIAFBAUEBQQAgA0ENaiACaiACQQNzEEsgA0EQaiQAC2UBAn8jAEEQayICJAAgAC0AACEDQQMhAANAIAAgAmpBDGogA0EPcUGgqsIAai0AADoAACAAQQFrIQAgA0EEdiIDDQALIAFBAUHEm8MAQQIgACACakENakEDIABrEEsgAkEQaiQAC9UEAgZ/AX4jAEEQayIFJAACQCAALwEMIgNFBEAgACgCACAAKAIEIAEQeCECDAELIAUgASgCDCIHNgIMIAUgASgCCCICNgIIIAUgASgCBCIENgIEIAUgASgCACIBNgIAAkAgACkCCCIIpyIGQYCAgAhxBEAgACgCACABIAQgACgC", + "BCgCDBEEAA0BIAAgBkGAgID/eXFBsICAgAJyIgY2AgggBUIBNwIAIARB//8DcSEBQQAhBCADIAFrIgFBACABIANNGyEDCyAHBEADQEF/An8CQAJAAkACQCACLwEAQQFrDgIBAgALIAJBBGooAgAMAwsgAkECai8BACIBDQFBAQwCCyACQQhqKAIADAELIAFB9v8XaiABQZz/H2pxIAFBmPg3aiABQfCxH2pxc0ERdkEBagsgBGoiASABIARJGyEEIAJBDGohAiAHQQFrIgcNAAsLAkAgA0H//wNxIARNBEAgACgCACAAKAIEIAUQeCECDAELIAMgBGshAUEAIQJBACEDAkACQAJAIAZBHXZBA3FBAWsOAwABAAILIAEhAwwBCyABQf7/A3FBAXYhAwsgBkH///8AcSEHIAAoAgQhBCAAKAIAIQYDQCACQf//A3EgA0H//wNxSQRAIAJBAWohAiAGIAcgBCgCEBEFAEUNAQwDCwsgBiAEIAUQeA0BIAEgA2tB//8DcSEBQQAhAwNAIAEgA0H//wNxTQRAQQAhAgwCC0EBIQIgA0EBaiEDIAYgByAEKAIQEQUARQ0ACwsgACAINwIIDAELQQEhAgsgBUEQaiQAIAILjgMBBn8jAEEQayIFJAACfwJAIAIoAgQiA0UNACAAIAIoAgAgAyABKAIMEQQARQ0AQQEMAQsgAigCDCIDBEAgAigCCCIEIANBDGxqIQYDQAJAAkACQAJAIAQvAQBBAWsOAgIBAAsCQCAEKAIEIgJBwQBPBEAgAUEMaigCACEDA0BBASAAQaSHwQBBwAAgAxEEAA0IGiACQUBqIgJBwABLDQALDAELIAJFDQMgAUEMaigCACEDCyAAQaSHwQAgAiADEQQARQ0CQQEMBQsgACAEKAIEIAQoAgggAUEMaigCABEEAEUNAUEBDAQLIAQvAQIhAiAFQQA6AAwgBUEANgIIIAIEfyACQfb/F2ogAkGc/x9qcSACQZj4N2ogAkHwsR9qcXNBEXZBAWoF", + "QQELIgchAwNAIANBAWsiAyAFQQhqIghqIAIgAkH//wNxQQpuIgJBCmxrQTByOgAAIAMNAAsgACAIIAcgAUEMaigCABEEAEUNAEEBDAMLIARBDGoiBCAGRw0ACwtBAAsgBUEQaiQAC6ICAgR/A34jAEEgayIDJABBFCECIAApAwAiByAHQj+HIgaFIAZ9IgZC6AdaBEADQCADQQxqIAJqIgBBBGsgBiIIIAZCkM4AgCIGQpDOAH59pyIEQf//A3FB5ABuIgVBAXQvAPGIQTsAACAAQQJrIAQgBUHkAGxrQf//A3FBAXQvAPGIQTsAACACQQRrIQIgCEL/rOIEVg0ACwsgBkIJVgRAIAJBAmsiAiADQQxqaiAGpyIAIABB//8DcUHkAG4iAEHkAGxrQf//A3FBAXQvAPGIQTsAACAArSEGCyAHUEUgBlBxRQRAIAJBAWsiAiADQQxqaiAGp0EBdC0A8ohBOgAACyABIAdCAFlBAUEAIANBDGogAmpBFCACaxBLIANBIGokAAucHQMNfwV+AXwjAEHADGsiByQAAkAgAkUEQCAAQQA6AAFBASEDDAELAkACQAJAAkACQAJAAkACQAJAIAcCfwJAAn8CQAJAIAEtAAAiDUEraw4DAAEAAQtBASACQQFrIgJFDQEaIAFBAWohAQsgASEDAkACQCAAAnwCQAJAAkACQAJ+AkAgAiIFQQhJDQADQCADKQAAIhBCxoyZsuTIkaPGAHwgEEKw4MCBg4aMmDB9IhCEQoCBgoSIkKDAgH+DUEUNASARQoDC1y9+IBBCCn4gEEIIiHwiEEIQiEL/gYCA8B+DQoGAgICA4gl+IBBC/4GAgPAfg0LkgICAgMjQB358QiCIfCERIANBCGohAyAFQQhrIgVBB0sNAAsgBQ0AQQEhCkIADAELA0AgAy0AACIGQTBrIgRB/wFxQQlLDQIgEUIKfiAErUL/AYN8IRFBASEKIANBAWohAyAFQQFrIgUNAAtCAAshE0EAIQUgAiEGDAELIAIg", + "BWshDAJ+IAZBLkcEQEEAIQYgBSEEQgAMAQsgA0EBaiEDIAVBAWshCAJAAkACQAJAIAVBCUgEQCAIIQQMAQsgCCEEA0AgAykAACIQQsaMmbLkyJGjxgB8IBBCsODAgYOGjJgwfSIQhEKAgYKEiJCgwIB/g1BFDQIgEUKAwtcvfiAQQgp+IBBCCIh8IhBCEIhC/4GAgPAfg0KBgICAgOIJfiAQQv+BgIDwH4NC5ICAgIDI0Ad+fEIgiHwhESADQQhqIQMgBEEIayIEQQdLDQALCyAERQ0BCyADIgYgBGohAwNAIAYtAABBMGsiCUH/AXFBCUsEQCAGIQMMAwsgEUIKfiAJrUL/AYN8IREgBkEBaiEGIARBAWsiBA0ACwtBACEEC0EAIAggBGsiBmusCyESIAYgDGoiBkUNASAERQRAQQEhCgwBCyADLQAAQSByQeUARwRAQQAhCgwBCyAEQQFrIglFDQEgA0EBaiEIIAMtAAEiDCEKAkACQCAMQStrDgMAAQABCyAEQQJrIglFDQIgA0ECaiEIIAMtAAIhCgsgCkEwa0H/AXFBCUsNAQJAA0AgCC0AAEEwayIEQf8BcUEJSw0BIBNCCn4gBK1C/wGDfCIQIBMgE0KAgARTIgQbIRMgECAUIAQbIRQgCEEBaiEIIAlBAWsiCQ0AC0EAIQkLQgAgFH0gFCAMQS1GGyITIBJ8IRIgCUUhCgsCf0EAIAZBFEgNABogBkETayEGIAIhCCABIQMDQAJAAkAgAy0AACIJQS5rDgMAAQABCyAGIAlBL2siBEEAIAQgCU0bayEGIANBAWohAyAIQQFrIggNAQsLQQAgBkEATA0AGkEAIAJrIQRCACERIAEhAyATAn8CQAJAAn8CQANAIAQhBiADLQAAQTBrIgRB/wFxQQlLDQEgA0EBaiEDIBFCCn4gBK1C/wGDfCIRQv//j7u61q3wDVhBACAGQQFqIgQbDQALIBFC//+Pu7rWrfANVg0DIAZBf0YNAkEAIARrDAELQQAgBmsL", + "QQFrIgZFBEBBACAGawwDCyADQQFqIQMgBiEFA0AgBSAGayADLQAAQTBrIghB/wFxQQlLDQMaIAVBAWshBCARQgp+IAitQv8Bg3wiEUL//4+7utat8A1YBEAgA0EBaiEDIAVBAUcgBCEFDQELCyAEIAZrDAILQQFBAEEAQYDEwQAQKQALQQAgBCAFamsLrHwhEkEBCyEFIApFDQAgEkImfUJEVCARQoCAgICAgIAQVnIgBXINAyASQhZXBEAgEqchASARuiEVIBJCAFMNAiABQQN0KwOYqEIgFaIMAwsgByARQgAgEqdBA3RB2IHBAGopAwBCABD+ByAHKQMIQgBSDQMgBykDACIQQoCAgICAgIAQVg0DIBC6RJLVTQbP8IBEogwCCyAAAnwCQAJAIAJBA2sOBgEGBgYGAAYLIAEpAABC37///v379+9fg0LJnJnK5KmSqtkAUg0FRAAAAAAAAPB/DAELRAAAAAAAAPB/IAEzAAAgATEAAkIQhoRC37//BoMiEELJnJkCUQ0AGiAQQs6CuQJSDQREAAAAAAAA+H8LIhWaIBUgDUEtRhs5AwhBACEDDBALIBVBmKjCACABQQN0aysDAKMLIhWaIBUgDUEtRhs5AwhBACEDDA4LIAdBEGogEiAREHsCQCAFIAcoAhgiBkEATnFFBEAgBkEASA0BIAcpAxAhEQwOCyAHQbAGaiASIBFCAXwQeyAHKQOwBiIRIAcpAxBSDQAgBiAHKAK4BkYNDQsgB0GwBmoiBCELQQAhBSAEQQBBiQb8CwAgB0G4BmohD0EAIQMCfwJAAkACQAJAA0AgASADaiIOIgQtAAAiBkEwRwRAIAIgBWohCCAGQTBrIgVB/wFxQQlLDQMgA0F/cyACaiEEQQAhAwNAIAghCSADQf8FTQRAIAMgD2ogBToAAAsgAyAOakEBaiEFIANBAWohBiADIARHBEAgCUEBayEIIAYhAyAFLQAAIgxBMGsiBUH/AXFBCUsNBAwBCwsgCyAGNgIAQQAhC0EA", + "IQkMDwsgBUEBayEFIAIgA0EBaiIDRw0AC0EAIQoMDwsgBiAOaiEEIAcgBjYCsAZBACELIAxBLkYNASAIIQkgBCEFDAwLIAZBLkcEQEEAIQpBACELDA0LIARBAWohBSAIQQFrIQoMAQsgCUECayIKIQkgBiAOakEBaiIFIAYNARoLIApFBEBBACEKQQAhBkEAIQkMCQsgBCAIaiEEQQAhAwJAA0AgAyAFaiIILQAAQTBHDQEgCiADQQFqIgNHDQALQQAhBkEAIQkgBCEFDAkLIAogA2shCUEAIQYgCAshBSAJQQhJDQUgBkEIaiEDA0AgA0EIayADIgZBgAZPDQQaIAUpAAAiEELGjJmy5MiRo8YAfCAQQrDgwIGDhoyYMH0iEIRCgIGChIiQoMCAf4NCAFINAyADQQhrIgRBgAZNBEAgB0GwBmogA2ogEDcAACADQQhqIQMgBUEIaiEFIAlBCGsiCUEHTQ0GDAELCyAEQYAGQYAGQbC4wQAQKQALQQELIQMgAEEBOgABDAsLIAZBCGsLIgY2ArAGDAILIAcgBjYCsAYLIAkNAEEAIQkMAQsgBS0AAEEwayIIQf8BcUEJTQRAIAVBAWohBAJ/A0AgBCEFIAYiA0H/BU0EQCADIA9qIAg6AAALIAlBAUcEQCADQQFqIQYgBUEBaiEEIAlBAWsiCSAFLQAAQTBrIghB/wFxQQlLDQIaDAELC0EACyEJIANBAWohBgsgByAGNgKwBgsgByAJIAprIgs2ArQGCwJAIAZFBEBBACEKDAELIAIgCWshAyACIAlPBEBBACEEAkAgAiAJRg0AIAFBAWshAQNAAkACQCABIANqLQAAQS5rDgMBAwADCyAEQQFqIQQLIANBAWsiAw0ACwsgByAGIAtqIgs2ArQGIAcgBiAEayIKNgKwBiAKQYEGSQ0BQYAGIQogB0GABjYCsAYgB0EBOgC4DAwBC0EAIAMgAkHAuMEAECkACyAFIQQgCSEICwJAIAhFDQAgBC0AAEEgckHlAEcN", + "ACAHIAhBAWsiBgR/AkACQAJAAkAgBEEBaiIFLQAAIglBK2sOAwABAAELIAhBAmsiBkUNASAEQQJqIQULQQAhBEEAIQMDQCAFLQAAQTBrQf8BcSIBQQlLDQIgA0EKbCABaiICIAMgA0GAgARIIgEbIQMgAiAEIAEbIQQgBUEBaiEFIAZBAWsiBg0ACwwBC0EAIQQLQQAgBGsgBCAJQS1GGwVBAAsgC2o2ArQGCyAKQRJLDQELQRMgCmsiAUUNACAHIApqQbgGakEAIAH8CwALIAdBJGogB0GwBmpBjAb8CgAAQgAhEUEAIQYgBygCJEUNACAHKAIoIgNBvH1IDQBB/w8hBiADQbUCSg0AAkAgA0EATARAQQAhBQwBC0EAIQUDQEE8IQQgA0ETSQRAIAMtALCFQSEECyAHQSRqIAQQViAHKAIoIgNBgHBKBEAgBCAFaiEFIANBAEwNAgwBCwtBACEGDAELIAdBLGohAgNAAkAgB0EkagJ/IANFBEAgAi0AACIBQQRLDQJBAkEBIAFBAkkbDAELQTxBACADayIBQRNPDQAaIAEtALCFQQsiARBVIAcoAigiA0H/D0oNAiAFIAFrIQUgA0EATA0BCwsgBUEBayIDQYF4TARAA0AgB0EkakE8QYJ4IANrIgEgAUE8TxsiARBWIAEgA2oiA0GCeEkNAAsLIANB/wdqQf4PSg0AIAdBJGpBNRBVAkACQAJAAkAgBygCJCIBRQ0AIAcoAigiBEEASA0AIARBEksNAiAERQRAQgAhEgwCC0EAIQVCACESA0AgEkIKfiESIAEgBUsEQCASIAIgBWoxAAB8IRILIAVBAWoiBSAERw0ACwwBCyADQf4HaiEGDAMLAkAgASAETQ0AAkAgASAEQQFqRiACIARqIgItAAAiAUEFRnFFBEAgAUEESw0BDAILIActAKwGDQAgBEUNASACQQFrLQAAQQFxRQ0BCyASQgF8IRILIBJCgICAgICAgBBUDQELIAdBJGoiAUEBEFZCACEQQQAh", + "BAJAIAEoAgAiBUUNACABKAIEIghBAEgNAEJ/IRAgCEESSw0AAkAgCEUEQEIAIRAMAQsgAUEIaiECQgAhEANAIBBCCn4hECAEIAVJBEAgECACIARqMQAAfCEQCyAIIARBAWoiBEcNAAsLIAUgCE0NAAJAIAUgCEEBakYgASAIaiIFLQAIIgJBBUZxRQRAIAJBBEsNAQwCCyABLQCIBg0AIAhFDQEgBUEHai0AAEEBcUUNAQsgEEIBfCEQCyAQIRIgA0GACGpB/g9KDQEgA0EBaiEDCyASQv////////8HgyERQf4HQf8HIBJCgICAgICAgAhUGyADaiEGCyAAIAatQjSGIBGEvyIVmiAVIA1BLUYbOQMIQQAhAwsgACADOgAAIAdBwAxqJAALqQMCBn4EfyMAQSBrIgokACAAQv8PNwMIIABCADcDAAJAAkAgAlAgAUKqfVNyDQAgAUK0AlUNASAKQRBqIAGnIglBBHQiDEHw7sEAaikDAEIAIAIgAnkiBoYiA0IAEP4HIAopAxAhBSAKKQMYIgJC/wODQv8DUQRAIAogDEH47sEAaikDAEIAIANCABD+ByACIAopAwgiAiAFfCIFIAJUrXwhAgsgBUJ/UiABQht8QtMAVHJFBEBBfyELDAELIAIgAkI/iCIHQgl8IgiIIQMgB6cgCUHqpA1sQRB1IAana2pBP2oiCUGCeE4EQCAJQYAIQf8HIANC/P////////8AgyADIAMgCIYgAlEbIAMgA0IDg0IBURsgAyAFQgJUGyADIAFCBHxCHFQbIgFCAYMgAXwiAUL/////////H1YiCRtqIgtB/g9LDQJCACABQgGIQv/////////3/wCDIAkbIQQMAQsgCUHDd0kNACADQYJ4IAlrrYgiAUIBgyABfCIBQv////////8PViELIAFCAYghBAsgACALNgIIIAAgBDcDAAsgCkEgaiQAC54NAwd/BX4BfCABKAIIIgNBgICAAXEhAiAAKwMAIQ4gA0GAgICAAXFFBEAg", + "AkEARyEEQQAhAyMAQYABayIAJAAgDr0iCUL/////////B4MiDEKAgICAgICACIQgCUIBhkL+////////D4MgCUI0iKdB/w9xIgUbIgpCAYMhDUECIQICQAJAAkACQAJAIAxQIgZBAkEDIAYbQQQgCUKAgICAgICA+P8AgyIMUBsgDEKAgICAgICA+P8AURtBAWsOBAABAgMEC0EDIQIMAwtBBCECDAILIAVBswhrIQMgDVAhAkIBIQsMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIDGyEKQgJCASADGyELIA1QIQJBy3dBzHcgAxsgBWohAwsgACADOwF4IAAgCzcDcCAAQgE3A2ggACAKNwNgIAAgAjoAegJ/AkACQAJAAkAgAkH/AXFBAU0EQEHAl8MAQQEgCUIAUyICGyEDQcCXwwBBsJvDACACGyECIAlCP4inIQUgAEEgaiAAQeAAaiAAQQ9qEHAgACgCIEUNASAAIAAoAig2AlggACAAKQIgNwNQDAILIAJBAmsiBUH/AXFFDQJBASECQcCXwwBBsJvDACAJQgBTIgMbQcCXwwBBASADGyAEGyEDIAlCP4inIARyIQQgAEECOwEgIAVB/wFxQQJGDQMgAEEDNgIoIABB+JrDADYCJCAAQSBqDAQLIABB0ABqIABB4ABqIABBD2oQcQsgAiADIAQbIQMgBCAFciEEIAAgACgCUCAAKAJUIAAvAVhBACAAQSBqEGUgACgCBCECIAAoAgAMAgsgAEEDNgIoIABB4JvDADYCJCAAQQI7ASBBASEDQQAhBEEBIQIgAEEgagwBCyAAQQE2AiggAEHW4cIANgIkIABBIGoLIQUgACACNgJcIAAgBTYCWCAAIAQ2AlQgACADNgJQIAEgAEHQAGoQdyAAQYABaiQADwsgAkEARyEFIAEvAQ4hACMAQfAIayICJAAgDr0iCUL/////////B4MiDEKAgICAgICACIQgCUIBhkL+////////D4MgCUI0iKdB/w9x", + "IgYbIgpCAYMhDUECIQMCQAJAAkACQAJAIAxQIgdBAkEDIAcbQQQgCUKAgICAgICA+P8AgyIMUBsgDEKAgICAgICA+P8AURtBAWsOBAABAgMEC0EDIQMMAwtBBCEDDAILIAZBswhrIQQgDVAhA0IBIQsMAQtCgICAgICAgCAgCkIBhiAKQoCAgICAgIAIUSIEGyEKQgJCASAEGyELIA1QIQNBy3dBzHcgBBsgBmohBAsgAiAEOwHoCCACIAs3A+AIIAJCATcD2AggAiAKNwPQCCACIAM6AOoIAn8CQCADQf8BcUEBTQRAQXRBBSAEwSIDQQBIGyADbCIDQcD9AEkNAUH4hMEAQSVBoIXBABA+AAsCQAJAIANBAmsiBkH/AXEEQEEBIQNBwJfDAEGwm8MAIAlCAFMiBBtBwJfDAEEBIAQbIAUbIQQgCUI/iKcgBXIhBSAGQf8BcUECRw0BIAJBAjsBkAggAA0CIAJBATYCmAggAkHW4cIANgKUCCACQZAIagwECyACQQM2ApgIIAJB4JvDADYClAggAkECOwGQCEEBIQRBACEFQQEhAyACQZAIagwDCyACQQM2ApgIIAJB+JrDADYClAggAkECOwGQCCACQZAIagwCCyACIAA2AqAIIAJBADsBnAhBAiEDIAJBAjYCmAggAkG4hMEANgKUCCACQZAIagwBC0HAl8MAQQEgCUIAUyIGGyEHQcCXwwBBsJvDACAGGyAJQj+IpyEIIAJBkAhqIAogBCACQRBqIANBBHZBFWoiBEGAgH5BACAAayAAwUEASBsiAxBsIAPBIQMCQCACKAKQCARAIAIgAigCmAg2AsgIIAIgAikCkAg3A8AIDAELIAJBwAhqIAJB0AhqIAJBEGogBCADEG4LIAcgBRshBCAFIAhyIQUgAyACLgHICCIGSARAIAJBCGogAigCwAggAigCxAggBiAAIAJBkAhqEGUgAigCDCEDIAIoAggMAQtBAiEDIAJBAjsBkAggAEUEQEEBIQMgAkEBNgKY", + "CCACQdbhwgA2ApQIIAJBkAhqDAELIAIgADYCoAggAkEAOwGcCCACQQI2ApgIIAJBuITBADYClAggAkGQCGoLIQAgAiADNgLMCCACIAA2AsgIIAIgBTYCxAggAiAENgLACCABIAJBwAhqEHcgAkHwCGokAAv1EAMMfwV+AXwgASgCCCIEQYCAgAFxIQMgACsDACETIARBgICAgAFxRQRAIANBAEchBUEAIQQjAEGgAWsiACQAIBO9Ig5C/////////weDIhFCgICAgICAgAiEIA5CAYZC/v///////w+DIA5CNIinQf8PcSIGGyIPQgGDIRJBAiEDAkACQAJAAkACQCARUCIHQQJBAyAHG0EEIA5CgICAgICAgPj/AIMiEVAbIBFCgICAgICAgPj/AFEbQQFrDgQAAQIDBAtBAyEDDAMLQQQhAwwCCyAGQbMIayEEIBJQIQNCASEQDAELQoCAgICAgIAgIA9CAYYgD0KAgICAgICACFEiBBshD0ICQgEgBBshECASUCEDQct3Qcx3IAQbIAZqIQQLIAAgBDsBiAEgACAQNwOAASAAQgE3A3ggACAPNwNwIAAgAzoAigECQAJAAkACQAJAAkACQAJAIANB/wFxQQFNBEAgAEHgAGogAEHwAGogAEEHahBwIAAoAmBFDQEgACAAKAJoNgKYASAAIAApAmA3A5ABDAILIANBAmsiA0H/AXFFDQJBASEEQcCXwwBBsJvDACAOQgBTIgYbQcCXwwBBASAGGyAFGyEGIA5CP4inIAVyIQUgAEECOwEYIANB/wFxQQJGDQMgAEEDNgIgIABB+JrDADYCHAwHCyAAQZABaiAAQfAAaiAAQQdqEHELIAAoApQBIgNFDQIgACgCkAEiBC0AAEEwTQ0DQcCXwwBBASAOQgBTIgYbIQJBwJfDAEGwm8MAIAYbIQYgDkI/iKchCCAALgGYASEHIABBATYCICAAIAQ2AhwgAEECOwEYIANBAWsiCUUEQCAAQSRqIQNBAyEEDAULIABB", + "PGohAyAAIAk2AjggAEECOwEwIABB5J3DADYCKCAAQQI7ASQgAEEBNgIsIAAgBEEBajYCNEEFIQQMBAsgAEEDNgIgIABB4JvDADYCHCAAQQI7ARhBASEGQQAhBUEBIQQMBAsgAEEDNgIgIABBuoTBADYCHAwDC0GUi8EAQSFB+IvBABA+AAtByIvBAEEfQYiMwQAQPgALIAYgAiAFGyEGIAUgCHIhBSADQQE7AQwgA0ECOwEAIANBAkEBIAdBAEwiAhs2AgggA0GZjMEAQZiMwQAgAhs2AgQgAyAHQQFrIgMgA0EfdSIDcyADazsBDgsgACAENgJsIAAgBTYCZCAAIAY2AmAgACAAQRhqNgJoIAEgAEHgAGoQdyAAQaABaiQADwsgA0EARyEIIAEiBy8BDiEDQQAhASMAQZAJayICJAAgE70iDkL/////////B4MiEUKAgICAgICACIQgDkIBhkL+////////D4MgDkI0iKdB/w9xIgQbIg9CAYMhEkECIQACQAJAAkACQAJAIBFQIgVBAkEDIAUbQQQgDkKAgICAgICA+P8AgyIRUBsgEUKAgICAgICA+P8AURtBAWsOBAABAgMEC0EDIQAMAwtBBCEADAILIARBswhrIQEgElAhAEIBIRAMAQtCgICAgICAgCAgD0IBhiAPQoCAgICAgIAIUSIBGyEPQgJCASABGyEQIBJQIQBBy3dBzHcgARsgBGohAQsgAiABOwH4CCACIBA3A/AIIAJCATcD6AggAiAPNwPgCCACIAA6APoIAkACQCAAQf8BcUEBTQRAIANBAWpBdEEFIAHBIgBBAEgbIABsQQR2QRVqIgAgACADSxsiAEGBCEkNAUG/hMEAQSlB6ITBABA+AAsCQAJAIABBAmsiBUH/AXEEQEEBIQBBwJfDAEGwm8MAIA5CAFMiARtBwJfDAEEBIAEbIAgbIQEgDkI/iKcgCHIhBCAFQf8BcUECRw0BIAJBAjsBiAggAw0CIAJBAzYCkAggAkG6hMEANgKM", + "CAwECyACQQM2ApAIIAJB4JvDADYCjAggAkECOwGICEEBIQFBACEEQQEhAAwDCyACQQM2ApAIIAJB+JrDADYCjAggAkECOwGICAwCCyACQQI2AqgIIAJBvYTBADYCpAggAkECOwGgCCACIAM2ApgIIAJBADsBlAggAkECNgKQCCACQbiEwQA2AowIQQMhAAwBCyACQdAIaiAPIAEgAkEIaiAAQYCAAhBsAkAgAigC0AgEQCACIAIoAtgINgKICSACIAIpAtAINwOACQwBCyACQYAJaiACQeAIaiACQQhqIABBgIACEG4LAkACQAJAIAIoAoQJIgUEQCACKAKACSIGLQAAQTBNDQEgDkIAUyEKIA5CP4ghDiACQaAIaiEBIAIuAYgJIQlBASEAIAJBATYCkAggAiAGNgKMCEECIQQgAkECOwGICCAFQQFrIgVFBEAgA0UNBCACQZwIaiELIAJBmAhqIQwgAkGUCGohBkHkncMAIQ0MAwsgAkGoCGohCyACQaQIaiEMIAJB5J3DADYCmAggAkECOwGUCCACQQE2ApwIIAZBAWohDUEDIQQgASEGIAUhACACQawIaiEBDAILQZSLwQBBIUH4i8EAED4AC0HIi8EAQR9BiIzBABA+AAsgDCANNgIAIAZBAjsBACALIAA2AgAgAyAFTQRAIAQhAAwBCyABQQA7AQAgASADIAVrNgIEIARBAWohAAtBwJfDAEGwm8MAIAobQcCXwwBBASAKGyAIGyEBIA6nIAhyIQQgAkGICGogAEEMbGoiAyIFAn8gCUEASgRAIANBATYCCCADQZiMwQA2AgQgA0ECOwEAIAlBAWsMAQsgAkGICGogAEEMbGoiA0ECNgIIIANBmYzBADYCBCADQQI7AQBBASAJaws7AQ4gBUEBOwEMIABBAmohAAsgAiAANgLcCCACIAQ2AtQIIAIgATYC0AggAiACQYgIajYC2AggByACQdAIahB3IAJBkAlqJAALZwIBfwF+IwBBIGsiAiQAIAApAwAh", + "A0EXIQADQCAAIAJqQQhqIAOnQQdxLQCYqkI6AAAgAEEBayEAIANCA4giA0IAUg0ACyABQQFBxpvDAEECIAAgAmpBCWpBFyAAaxBLIAJBIGokAAtnAgF/AX4jAEEQayICJAAgACkDACEDQREhAANAIAAgAmpBAmsgA6dBD3EtAKCqQjoAACAAQQFrIQAgA0IEiCIDQgBSDQALIAFBAUHEm8MAQQIgACACakEBa0ERIABrEEsgAkEQaiQAC/oBAQN/IwBBEGsiAiQAIAAoAgAhAAJ/IAEtAAtBGHFFBEAgASgCACAAIAEoAgQoAhARBQAMAQsgAkEANgIMIAEgAkEMagJ/IABBgAFPBEAgAEE/cUGAf3IhAyAAQQZ2IQEgAEGAEEkEQCACIAM6AA0gAiABQcABcjoADEECDAILIABBDHYhBCABQT9xQYB/ciEBIABB//8DTQRAIAIgAzoADiACIAE6AA0gAiAEQeABcjoADEEDDAILIAIgAzoADyACIAE6AA4gAiAEQT9xQYB/cjoADSACIABBEnZBcHI6AAxBBAwBCyACIAA6AAxBAQsQKwsgAkEQaiQACxEAQYirwgBBOUGkq8IAEDUAC1wCAX8BfkEAEPsDIgFFBEAjAEEQayIAJAAgACAAQQ9qrUKAgICA0AGENwMAQe+TwAAgAEG0q8IAEDUACyAAIAEpAwg3AwggACABKQMAIgI3AwAgASACQgF8NwMAC78BAQZ/IwBBIGsiAyQAIANBFGoiByABQQggAhCHAQJAIAMoAhQiBARAIAMoAhwhBSADQQhqIAQgAygCGCIGEIkBIAMoAggiCEUNASAGIAMoAgwiBEcEQCAHIAFBCEGAgICAeCAEQQhrIAFBAWpuZ3YiAhCHASADKAIcIQULIABBADYCDCAAIAJBAWsiATYCBCAAIAUgCGo2AgAgACABIAJBA3ZBB2wgAUEISRs2AgggA0EgaiQADwsQgQEACxAdAAsqACAAKQMAIABBCGopAwAgASACQXRsaiIA", + "QQxrKAIAIABBCGsoAgAQigELdQECfyABIAKncSEDQQghBAN/IAAgA2opAABCgIGChIiQoMCAf4MiAlAEfyADIARqIAFxIQMgBEEIaiEEDAEFIAAgAyACeqdBA3ZqIAFxIgNqLAAAQQBOBH8gACkDAEKAgYKEiJCgwIB/g3qnQQN2BSADCwsLCzsBAX8DQCACBEAgACgAACEDIAAgASgAADYAACABIAM2AAAgAkEBayECIAFBBGohASAAQQRqIQAMAQsLC4IBAgF/AX4CQAJAIAGtIAOtfiIFQiCIpw0AIAIgBaciAWpBAWsiBCABSQ0AIANBCGoiAyAEQQAgAmtxIgRqIgEgA0kNAUGAgICAeCACayABTwRAIAAgBDYCCCAAIAE2AgQgACACNgIADwsgAEEANgIADwsgAEEANgIADwsgAEEANgIACw0AIAEEQCAAIAEQGQsLHQAgAgRAIAIgARBDIQELIAAgAjYCBCAAIAE2AgALjQEBAX8jAEFAaiIEJAAgBEIANwMwIARCADcDOCAEIAE3AyggBCABQvPK0cunjNmy9ACFNwMYIAQgAULt3pHzlszct+QAhTcDECAEIAA3AyAgBCAAQuHklfPW7Nm87ACFNwMIIAQgAEL1ys2D16zbt/MAhTcDACACQQhqIAMgBBCLASAEEIwBIARBQGskAAsxAQF/IwBBEGsiAyQAIAIgACABEI4BIANB/wE6AA8gAiADQQ9qQQEQjgEgA0EQaiQAC5oCAgV+AX8jAEEgayIGJAAgBiAAKQMQNwMQIAYgACkDCDcDCCAGIAApAwA3AwAgBiAAKQMwIAA1AjhCOIaEIgMgACkDGIU3AxggBhCNASAGKQMQIQEgBikDACEFIAYpAwghBCAGKQMYIQIgBkEgaiQAIAIgBEL/AYV8IgQgASADIAWFfCIDIAFCDYmFIgF8IgUgAUIRiYUiAUINiSABIAJCEIkgBIUiASADQiCJfCICfCIDhSIEQhGJIAFCFYkgAoUiASAFQiCJfCIC", + "IAR8IgWFIgRCDYkgAUIQiSAChSIBIANCIIl8IgIgBHyFIgNCEYkgAUIViSAChSIBIAVCIIl8IgIgA3wiA0IgiYUgAUIQiSAChUIViYUgA4ULZgEFfiAAIAApAxgiAUIQiSABIAApAwh8IgGFIgIgACkDECIDIAApAwB8IgRCIIl8IgU3AwAgACACQhWJIAWFNwMYIAAgASADQg2JIASFIgJ8IgEgAkIRiYU3AxAgACABQiCJNwMIC/IBAgN/AX4gACAAKAI4IAJqNgI4AkACQCAAKAI8IgRFBEAMAQsgAUEAQQggBGsiAyACIAIgA0sbEI8BIQYgACAAKQMwIAYgBEEDdK2GhCIGNwMwIAIgA08EQCAAIAApAxggBoU3AxggABCNASAAQQA2AjwgACAAKQMAIAApAzCFNwMADAELIAIgBGohAQwBCyACIANrIgRBeHEhBQNAIAMgBU9FBEAgACABIANqKQAAIgYgACkDGIU3AxggABCNASAAIAYgACkDAIU3AwAgA0EIaiEDDAELCyAAIAEgAyAEQQdxIgEQjwE3AzALIAAgATYCPAtwAgF/AX5BBCEDAn4gAkEESQRAQQAhA0IADAELIAAgAWo1AAALIQQgAiADQQFySwRAIAAgAWogA2ozAAAgA0EDdK2GIASEIQQgA0ECciEDCyACIANLBH4gACABIANqajEAACADQQN0rYYgBIQFIAQLC5EBAQJ/IwBBEGsiAyQAAn8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACABEDgMAgsgACgCACECQQkhAANAIAAgA2pBBmogAkEPcS0AoKpCOgAAIABBAWshACACQQR2IgINAAsgAUEBQcSbwwBBAiAAIANqQQdqQQkgAGsQSwwBCyAAIAEQCwsgA0EQaiQAC4kBAQN/IwBBIGsiAyQAIAEoAgghBCADIAI2AhwgA0EBNgIYIANBAjYCECADQQhqIAQgA0EQahCSASADKAIMIQIgASADKAIIIgU2AgggACAE", + "IAJrNgIQIAAgAjYCDCAAIAE2AgggACABKAIEIgEgAkEDdGo2AgQgACABIAVBA3RqNgIAIANBIGokAAvSAQEEfyACKAIMIQQgAigCBCEFIAIoAgAhBiABIQMCQAJAAkACQAJAAkACQAJAAkACQCACKAIIQQFrDgIAAgELIAEgBEkNAiAEIQMMAQsgASAETQ0EIARBAWohAwtBACECIAZBAWsOAgIGAQtBACAEIAFBkNTCABApAAsgAyAFSQ0CIAUhAgwECyADIAVLDQIgBSADIAFBsNTCABApAAtBACAEIAFBgNTCABApAAsgBSADIAFBoNTCABApAAsgBUEBaiECCyAAIAM2AgQgACACNgIAC20BBH8jAEEQayICJAAgAkEIaiABKAIIIgQQlAEgAigCDCEDIAEgAigCCCIFNgIIIAAgAzYCDCAAIAE2AgggACAEIANrNgIQIAAgASgCBCIBIANBBXRqNgIEIAAgASAFQQV0ajYCACACQRBqJAALOwEBfyMAQSBrIgIkACACQQI2AhggAkECNgIQIAJBCGogASACQRBqEJIBIAAgAikDCDcDACACQSBqJAALWQECfyAAKAIAIgEgASgCACIBQQFrNgIAIAFBAUYEQAJAIAAoAgAiAUF/Rg0AIAAoAgQhACABIAEoAgQiAkEBazYCBCACQQFHDQAgASAAQQtqQXxxEIgBCwsLDQAgACABQQhBBBCHCAvAAgIEfwF+IwBBIGsiBiQAAn9BACADIAIgA2oiB0sNABpBACECIAZBFGohCAJAAkAgBa0gByABKAIAIglBAXQiAyADIAdJGyIDQQhBBCAFQQFGGyIHIAMgB0sbIgetfiIKQiCIpw0AIAqnIgNBgICAgHggBGtLDQACfyAJRQRAQQAhBSAGQRxqDAELIAEoAgQhCCAGIAQ2AhwgBSAJbCEFIAZBGGoLIAU2AgACfyAGKAIcBEAgBigCGCICRQRAIAZBCGogBCADEIkBIAYoAggMAgsgCCACIAMQGgwBCyAG", + "IAQgAxCJASAGKAIACyIFDQEgBiAENgIUIAZBEGohCCADIQILIAggAjYCACAGKAIQIQUgBigCFAwBCyABIAc2AgAgASAFNgIEQX8LIQMgACAFNgIEIAAgAzYCACAGQSBqJAALkgMCC38DfiMAQSBrIgokACABKAIEIgYgASgCACICa0EFdiIDIAAoAgAgACgCCCIEa0sEQCAAIAQgA0EEQSAQLyAAKAIIIQQLIAJBIGohBSAAKAIEIARBBXRqIQMgASgCECEHIAEoAgwhCSABKAIIIQgCQANAAkACQAJAIAIgBkcEQCACQSBqIQEgAigCACILQQJHDQIgACAENgIIIAEgBkYNASAGIAVrQQV2IQIDQCACRQ0CIAJBAWshAiAFEJkBIAVBIGohBQwACwALIAAgBDYCCAsgB0UNAyAJIAgoAggiAEYNASAHQQV0IgFFDQEgCCgCBCICIABBBXRqIAIgCUEFdGogAfwKAAAMAQsgAkEcaigCACEMIAJBFGopAgAhDSACQQxqKQIAIQ4gAkEEaikCACEPIAMgCzYCACADQQRqIA83AgAgA0EMaiAONwIAIANBFGogDTcCACADQRxqIAw2AgAgA0EgaiEDIAVBIGohBSAEQQFqIQQgASECDAELCyAIIAAgB2o2AggLIApBIGokAAvNBQIEfwN+IwBBkAFrIgEkACAAQQhqAkACQAJAAkACQAJAQQQgACgCCCICQQJrIAJBAU0bQQRrDgQDAAECBQsgACgCDCICKAIIIAJBFGooAgAQmgENAwwECyAAKAIUDQIMAwsgACgCFEUNAgwBCyAAKAIQIgIoAgggAkEUaigCABCaAUUNAQtBBEEgEJsBIQIgACkCGCEFIABBgAI7ARwgACkCCCEGIABBAjYCCCAAKQIAIQcgAEIBNwIAIAIgBzcCACACIAY3AgggAiAAKQIQNwIQIAIgBTcCGCABQQE2AgwgASACNgIIIAFBATYCBCABQdwAaiEDIAFB1ABqIQJBASEAA0ACQAJA", + "AkACQAJAAkAgAEUNACABIABBAWsiADYCDCABIAEoAgggAEEFdGoiACkCBDcDMCABIAApAgw3AzggASAAKQIUNwNAIAEgACgCHDYCSCAAKAIAIgBBAkYNACACIAEoAkg2AhggAiABKQNANwIQIAIgASkDODcCCCACIAEpAzA3AgAgASAANgJQQQQgASgCWCIAQQJrIABBAU0bQQRrDgQBAgMEBQsgAUEEahCcAQwGCyABKAJgIgApAgAhBSAAQgE3AgAgACkCGCEGIABBgAI7ARwgACkCCCEHIABBAjYCCCABIAU3A3AgASAHNwN4IAEgACkCEDcDgAEgASAGNwOIASABQQRqIAFB8ABqEJ0BDAMLIAEoAlwiACkCACEFIABCATcCACAAKQIYIQYgAEGAAjsBHCAAKQIIIQcgAEECNgIIIAEgBTcDcCABIAc3A3ggASAAKQIQNwOAASABIAY3A4gBIAFBBGogAUHwAGoQnQEMAgsgAUHwAGoiACADEJMBIAFBBGogABCYAQwBCyABQfAAaiIAIAMQkwEgAUEEaiAAEJgBCyABQdAAahCZASABKAIMIQAMAAsACxCeASABQZABaiQACy4AAn9BAEEBQQQgAEECayAAQQFNGyIAdEEPcQ0AGkEBQQEgAHRBMHENABogAQsLMAECfyMAQRBrIgIkACACQQhqIAAgARCJASACKAIIIgNFBEAQHQALIAJBEGokACADCz4BA38gACgCCCEBIAAoAgQiAyECA0AgAQRAIAFBAWshASACEJkBIAJBIGohAgwBCwsgACgCACADQQRBIBAwC44BAQN/IAAoAggiAyAAKAIARgRAIwBBEGsiAiQAIAJBCGogACAAKAIAQQFBBEEgEJcBIAIoAggiBEF/RwRAIAIoAgwaIAQQHAALIAJBEGokAAsgACADQQFqNgIIIAAoAgQgA0EFdGoiACABKQIANwIAIAAgASkCCDcCCCAAIAEpAhA3AhAgACABKQIYNwIYC3ABAX8CQAJAAkAC", + "QAJAAkBBBCAAKAIAIgFBAmsgAUEBTRsOBwEBAgEDBAUACyAAQQRqEJwBCw8LIAAoAgQgACgCCBCfAQ8LIABBCGoQoAEPCyAAKAIMIAAoAhAQoQEgAEEEahCgAQ8LIABBBGoQnAELDAAgACABQQRBCBAwCxEAIAAoAgAiABCZASAAEKIBCxQAIABFIAFFckUEQCAAIAEQiAELCwgAIABBIBAZCw0AIAAgAUEMQQQQhwgLKAAgASADRgRAIAFBAnQiAQRAIAAgAiAB/AoAAAsPCyABIAMgBBByAAs4AQF/IwBBEGsiBCQAIAQgATYCDCAEIAA2AgggBEEIakHEq8IAIARBDGpBxKvCACACQS0gAxBGAAsLACAAKAIAIAEQXAtQAQF/IwBBIGsiAiQAIAJBCGogAUEEQQQQByACQQA2AhwgAiACKQMINwIUIAJBFGogARCoASAAIAIoAhw2AgggACACKQIUNwIAIAJBIGokAAuQAQEEfyAAKAIAIAAoAggiA2sgAUkEQCAAIAMgAUEEQQQQLyAAKAIIIQMLIAAoAgQgA0ECdGohBEEBIAEgAUEBTRsiBUEBayECAkADQCACBEAgBEEANgIAIAJBAWshAiAEQQRqIQQMAQUCQCADIAVqIQIgAQ0AIAJBAWshAgwDCwsLIARBADYCAAsgACACNgIIC00AAkAgA0UNAAJAIAIgA00EQCACIANHDQEMAgsgASADaiwAAEG/f0oNAQsgASACIAMgAiAEEFoACyAAIAIgA2s2AgQgACABIANqNgIAC4oBAQF/IwBBQGoiBCQAIARCADcDMCAEQgA3AzggBCABNwMoIAQgAULzytHLp4zZsvQAhTcDGCAEIAFC7d6R85bM3LfkAIU3AxAgBCAANwMgIAQgAELh5JXz1uzZvOwAhTcDCCAEIABC9crNg9es27fzAIU3AwAgAiADIAQQiwEgBBCMASAEQUBrJAAL4wEBAn8gASgCCCICQYCAgBBxRQRAIAJBgICAIHFFBEAgACAB", + "EDgPCyAAKAIAIQIjAEEQayIDJABBCSEAA0AgACADakEGaiACQQ9xLQCgqkI6AAAgAEEBayEAIAJBBHYiAg0ACyABQQFBxJvDAEECIAAgA2pBB2pBCSAAaxBLIANBEGokAA8LIAAoAgAhAiMAQRBrIgMkAEEJIQADQCAAIANqQQZqIAJBD3EtAIiEQToAACAAQQFrIQAgAkEEdiICDQALIAFBAUHEm8MAQQIgACADakEHakEJIABrEEsgA0EQaiQAC+EKAhR/An4jAEHgAmsiDiQAQoCAgICAgICAwAAgAa0iGYAiGiAZfkKAgICAgICAgMAAUq0CfyABQYEgTwRAIAEQawwBC0HAACABIAFBAXZrIgYgBkHAAE8bCyESIBp8IRkgAEEIayEVIABBDGohFEEBIQhBACEGA0BBACENQQEhCiABIA9LIhYEQCAAIA9BA3QiB2ohDCAZIA9BAXQCfwJAIAEgD2siCiASSQ0AQQAhCwJAAkAgCkECSQ0AAkACQCAMKAIIIgUgDCgCACIJRgRAIAwoAgwgDCgCBE8NAQwCCyAFIAlJDQELIAcgFGohBUECIQcDQCAHIApGDQICQCAFQQRqKAIAIgkgBUEEaygCACINRgRAIAVBCGooAgAgBSgCAEkNBQwBCyAJIA1JDQQLIAVBCGohBSAHQQFqIQcMAAsACyAHIBRqIQVBAiEHA0BBASELIAcgCkYNAQJAIAVBBGooAgAiCSAFQQRrKAIAIg1GBEAgBUEIaigCACAFKAIATw0EDAELIAkgDU8NAwsgBUEIaiEFIAdBAWohBwwACwALIAohBwsgByASSQ0AAkAgC0UNACAOQdACaiIFIAwgB0EBdiIKIApBxN3CABCtASAOKALQAiELIA4oAtQCIQ0gBSAMIAdBA3RqIApBA3QiDGsgCiAKQdTdwgAQrQFBACEFQQAgDWshESAOKALQAiAMakEIayEJIA4oAtQCIgwgCkEBa0shEAJAA0AgBSAKaiITRQ0CIAUgEUYNASAQ", + "BEAgCykCACEaIAsgCSkCADcCACAJIBo3AgAgC0EIaiELIAlBCGshCSAFQQFrIQUMAQsLIBNBAWsgDEH03cIAECoACyANIA1B5N3CABAqAAsgB0EBdEEBcgwBCyAKIBIgCiASSRtBAXQgBEUNABogDEEgIAogCkEgTxsiByACIANBAEEAEK4BIAdBAXRBAXILIgpBAXZqrX4gDyAIQQF2a60gD618IBl+hXmnIQ0LIBUgD0EDdCIHaiEMIAAgB2ohEwNAAkACQAJAAkACQCAGQQJPBEAgBkEBayIHIA5BjgJqai0AACANTw0BCyAOQY4CaiAGaiANOgAAIA5BBGogBkECdGogCDYCACAWRQ0BIAZBAWohBiAKQQF2IA9qIQ8gCiEIDAYLIAMgDkEEaiAHQQJ0aigCACILQQF2IgYgCEEBdiIFaiIRTyAIIAtyQQFxRXENASAAIA8gEWtBA3RqIQkgC0EBcUUNAgwDCyAIQQFxRQRAIAAgASACIAMQrwELIA5B4AJqJAAPCyARQQF0IQggByEGDAILIAkgBiACIAMQrwELIAhBAXFFBEAgCSAGQQN0aiAFIAIgAxCvAQsCQCAGRSAFRXINACADIAUgBiAFIAZJIhAbIgtJDQAgCSAGQQN0aiIFIAkgEBshCCALQQN0IgYEQCACIAggBvwKAAALIAIgBmohCwJAIBBFBEAgAiEGA0AgBiALRiAFIBNGcg0CIAggBSAGAn8gBSgCACIJIAYoAgAiEEcEQCAJIBBJDAELIAUoAgQgBigCBEkLIgkbKQIANwIAIAhBCGohCCAFIAlBA3RqIQUgBiAJQQFzQQN0aiEGDAALAAsgDCEGA0ACfyALQQhrIgUoAgAiFyAIQQhrIhAoAgAiGEcEQCAXIBhJDAELIAtBBGsoAgAgCEEEaygCAEkLIQggBiAQIAUgCBspAgA3AgAgBSAIQQN0aiELIAkgECAIQQFzQQN0aiIIRwRAIAZBCGshBiACIAtHDQELCyACIQYLIAsgBmsi", + "BUUNACAIIAYgBfwKAAALIBFBAXRBAXIhCCAHIQYMAAsACwALEQAgACABIAIgAyAEQQMQgQgL0w8BDX8jAEEgayIOJAAgAkEIayEQAkACQAJAA0ACQAJAAkAgAUEhTwRAIAQNASAAIAEgAiADQQEQrAEMBwsgAUECSQ0GIAMgAUEQakkNBCABQQF2IQMgAUEPSw0BIAFBB0sEQCAAIAIQsAEgACADQQN0IgRqIAIgBGoQsAFBBCEHDAYLIAIgACkCADcCACACIANBA3QiBGogACAEaikCADcCAEEBIQcMBQsgACABQQN2IgpBOGxqIQYgACAKQQV0aiENIAFBwABPBEAgACANIAYgChCxASELDAILAn8gACgCACIKIA0oAgAiCUcEQCAJIApLDAELIAAoAgQgDSgCBEkLIQcgACELAn8gBigCACIMIApHBEAgCiAMSQwBCyAAKAIEIAYoAgRJCyAHRw0BIAYgDSAJIAxHBH8gCSAMSQUgDSgCBCAGKAIESQsgB3MbIQsMAQsgACACIAIgAUEDdGoiBBCyASAAIANBA3QiBWogAiAFaiAEQUBrELIBQQghBwwDCyAEQQFrIQQgCygCACEGIA4gCygCBCIKNgIMIA4gBjYCCCALIABrQQN2IQ0CQAJAIAVFDQAgBiAFKAIAIghGBEAgBSgCBCAKSQ0BDAILIAYgCE0NAQsgASADSw0CIAIgAUEDdCIRaiEJQQAhCCAAIQYgDSEKA0AgACAKQQNrIgdBACAHIApNG0EDdGohEgNAIAYgEk9FBEAgCEEDdCACIAlBCGsCfyAGKAIAIgcgCygCACIMRwRAIAcgDEkMAQsgBkEEaigCACALKAIESQsiBxtqIAYpAgA3AgAgByAIaiIIQQN0IAIgCUEQawJ/IAwgBkEIaiIPKAIAIgdHBEAgByAMSQwBCyAGQQxqKAIAIAsoAgRJCyIHG2ogDykCADcCACAHIAhqIghBA3QgAiAJQRhrAn8gDCAGQRBqIg8oAgAiB0cEQCAH", + "IAxJDAELIAZBFGooAgAgCygCBEkLIgcbaiAPKQIANwIAIAcgCGoiCEEDdCACIAlBIGsiCQJ/IAwgBkEYaiIPKAIAIgdHBEAgByAMSQwBCyAGQRxqKAIAIAsoAgRJCyIHG2ogDykCADcCACAGQSBqIQYgByAIaiEIDAELCyAAIApBA3RqIQwDQCAGIAxPBEACQCABIApGDQAgCUEIayIJIAhBA3RqIAYpAgA3AgAgBkEIaiEGIAEhCgwDCwUgCEEDdCACIAlBCGsiCQJ/IAYoAgAiByALKAIAIhJHBEAgByASSQwBCyAGQQRqKAIAIAsoAgRJCyIHG2ogBikCADcCACAGQQhqIQYgByAIaiEIDAELCwsgCEEDdCIGBEAgACACIAb8CgAACyAQIBFqIQkgACAGaiEHIAghBgNAIAEgBkZFBEAgByAJKQIANwIAIAZBAWohBiAHQQhqIQcgCUEIayEJDAELCyAIRQ0AIA5BEGogACABIAhBpN3CABCtASAOKAIUIQEgDigCECEAIA4oAhggDigCHCACIAMgBCAOQQhqEK4BDAELIAEgA0sNASACIAFBA3QiDGohCUEAIQggACEGA0AgACANQQNrIgVBACAFIA1NG0EDdGohEQNAIAYgEU9FBEAgCEEDdCAJQQhrIAICfyALKAIAIgUgBigCACIKRwRAIAUgCkkMAQsgCygCBCAGQQRqKAIASQsiBxtqIAYpAgA3AgAgCCAHQQFzaiIKQQN0IAlBEGsgAgJ/IAZBCGoiCCgCACIHIAVHBEAgBSAHSQwBCyALKAIEIAZBDGooAgBJCyIHG2ogCCkCADcCACAKIAdBAXNqIgpBA3QgCUEYayACAn8gBkEQaiIIKAIAIgcgBUcEQCAFIAdJDAELIAsoAgQgBkEUaigCAEkLIgcbaiAIKQIANwIAIAogB0EBc2oiCkEDdCAJQSBrIgkgAgJ/IAZBGGoiCCgCACIHIAVHBEAgBSAHSQwBCyALKAIEIAZBHGooAgBJCyIHG2og", + "CCkCADcCACAGQSBqIQYgCiAHQQFzaiEIDAELCyAAIA1BA3RqIQUDQCAFIAZNBEACQCABIA1GDQAgAiAIQQN0aiAGKQIANwIAIAZBCGohBiAIQQFqIQggCUEIayEJIAEhDQwDCwUgCEEDdCAJQQhrIgkgAgJ/IAsoAgAiCiAGKAIAIgdHBEAgByAKSwwBCyALKAIEIAZBBGooAgBJCyIHG2ogBikCADcCACAGQQhqIQYgCCAHQQFzaiEIDAELCwsgCEEDdCIFBEAgACACIAX8CgAACyAMIBBqIQkgASAIayINIQYgACAFaiIAIQcDQCAGBEAgByAJKQIANwIAIAZBAWshBiAHQQhqIQcgCUEIayEJDAELCyABIAhPBEBBACEFIA0hAQwBCwsgCCABIAFBtN3CABApAAsAC0EAIQsgDkEANgIYQQAgB2shBSACIAdBA3QiBGohDSAAIARqIQogDiADNgIcIAEgA2shDCAOQRhqIRADQAJAIAtBAkcEQCAFIAwgAyAQIAtBAnRqKAIAIgQbIgYgByAGIAdLG2ohCSANIARBA3QiBGohBiAEIApqIQggAiAEaiEEA0AgCUUNAiAGIAgpAgA3AgAgBCAGELMBIAlBAWshCSAGQQhqIQYgCEEIaiEIDAALAAsgAiABIAAQtAEMAgsgC0EBaiELDAALAAsgDkEgaiQACxsAIAAgASACIAMgAUEBcmdBAXRBPnNBABCuAQvKAgEJfwJ/IAAoAggiAiAAKAIAIgNHBEAgAiADSQwBCyAAKAIMIAAoAgRJCyECIABBEEEYAn8gACgCGCIDIAAoAhAiBUcEQCADIAVJDAELIAAoAhwgACgCFEkLIgYbaiEFIAAgAkVBA3RqIQMCfyAAQRhBECAGG2oiBigCACIEIAAgAkEDdGoiCCgCACIARwRAIAAgBEsMAQsgBigCBCAIKAIESQshAAJ/IAUgAyAGIAAbAn8gBSgCACICIAMoAgAiBEcEQCACIARJDAELIAUoAgQgAygCBEkL", + "IgIbIgQoAgAiByAIIAYgAyACGyAAGyIJKAIAIgpHBEAgByAKSQwBCyAEKAIEIAkoAgRJCyEHIAEgBiAIIAAbKQIANwIAIAEgBCAJIAcbKQIANwIIIAEgCSAEIAcbKQIANwIQIAEgAyAFIAIbKQIANwIYC8kBAQN/IANBCE8EQCAAIAAgA0EDdiIDQQV0IgRqIAAgA0E4bCIFaiADELEBIQAgASABIARqIAEgBWogAxCxASEBIAIgAiAEaiACIAVqIAMQsQEhAgsCfyAAKAIAIgMgASgCACIERwRAIAMgBEkMAQsgACgCBCABKAIESQshBQJ/IAIoAgAiBiADRwRAIAMgBkkMAQsgACgCBCACKAIESQsgBUYEfyACIAEgBCAGRwR/IAQgBkkFIAEoAgQgAigCBEkLIAVzGwUgAAsLHwAgACACELABIABBIGogAkEgahCwASACQQggARC0AQuoAQEDfwJAAkAgASgCACIDIAFBCGsoAgAiAkYEQCABKAIEIgIgAUEEaygCAEkNAQwCCyACIANNDQEgASgCBCECCyABQRBrIQEDQAJAIAFBEGogAUEIaiIEKQIANwIAIAAgBEYNAAJAIAEoAgAiBCADRgRAIAIgAUEEaigCAEkNAQwCCyADIARPDQELIAFBCGshAQwBCwsgAUEIaiADrSACrUIghoQ3AgALC7UCAQd/IAIgAUEDdEEIayIEaiEHIAAgBGohBSAAIAFBAXYiCEEDdGoiBEEIayEGA0AgCARAIAIgBCAAAn8gBCgCACIDIAAoAgAiCUcEQCADIAlJDAELIAQoAgQgACgCBEkLIgMbKQIANwIAIAJBCGohAiADQQN0IARqIQQgA0VBA3QgAGohACAHIAYgBQJ/IAUoAgAiAyAGKAIAIglHBEAgAyAJSQwBCyAFKAIEIAYoAgRJCyIDGykCADcCACAIQQFrIQggB0EIayEHIAYgA0EDdCIDayEGIAMgBWpBCGshBQwBBQJAIAZBCGohAyABQQFxBH8gAiAA", + "IAQgACADSSIBGykCADcCACAEIAAgA09BA3RqIQQgACABQQN0agUgAAsgA0cgBCAFQQhqR3INAA8LCwsQagAL8wUBEX8jAEFAaiIJJAAgASAINgJoIAFBADYCVCABIAg2AjggAUEANgIkIAFBADYCCAJAIAQgBUsNACABQShqIRMgAUE8aiEUIAFBDGohFiAAKAI8IQ8gACgCOCEQIAAoAkwhFyAALQBUQQFxIRggBCELA0AgBSALSQRAIA0hCgwCCwJAAkAgASgCJCIKRQRAQQEhCiANQQFxDQQgGEUgBCALT3INAUEAIQoMBAsgDUEBcQ0BCyAJQThqIAEoAlwgASgCYCIAIAAgASgCZGsiACAAIAEoAmhqQai2wgAQJCAQIA8gASAJKAI4IAkoAjwgFiACIAMgCyAXELYBIAEoAiQhCgsgCUEwaiALIAIgA0GYrcIAELcBIAlBKGogCSgCMCAJKAI0ELgBIAkoAiwhDiAJKAIoIQAgCUEgaiABKAIQIAEoAhQgCkH8tsIAELkBQf3/AyAAIABBf0YbIRUgCyAOaiELIAkoAiAiESAJKAIkQQJ0aiEZAkACQAJAA0AgESAZRg0BIBEoAgAhEiARQQRqIRECQAJAAkAgECAPIBIQugEiDC0AAEEBaw4GAQMDAwMCAAsgDkUNAiAVIAwoAghHDQIgDCgCBCEAIAlBCGogEyASELsBIBAgDyABIAkoAgggCSgCDCAUIAIgAyALIAAQtgEMAgsgDCgCEEEDdCEKIAwoAgwhACAMKAIEIQwDQCAKRQ0CIAAoAgAgFUsNAiAAKAIEIBVPBEAgDkUNAyAJQRBqIBMgEhC7ASAQIA8gASAJKAIQIAkoAhQgFCACIAMgCyAMELYBCyAKQQhrIQogAEEIaiEADAALAAsLIAlBGGogEyASELsBIAcgCCAJKAIYIAkoAhxBiK3CABCkAUEBIQAgBkUNAUEBIQoMBAsgBkUEQCANIgAhCiAODQIMBAtBACEAIA0iCiAORXJBAXEN", + "AwwBC0EBIQogDkUNAgsgFiAUQQwQhgEgAUEANgJUIAAhDQwACwALIAlBQGskACAKQQFxC+cMAQ5/IwBBQGoiCyQAIAtBADYCKCALIAk2AiwgAiALQShqELwBIAVBHGohFSAIQQFqIRQgBiAIaiIQQQFrIRYgBiAIQQFrIg5qIREgBSgCGCEMIAUoAgghEwNAIAIoAgQgAigCCCIKQQxsakEMayEJA0ACQAJAAkAgCkUNACACIApBAWsiCjYCCCAJQQRqKAIAIQ8gCSgCAA4DAQIAAgsgC0FAayQADwsgDCATIAwgE0sbIRcDQCAMIQkDQCALIA82AhwCQAJAIAkgBSgCECAFKAIUIA9BvLfCABAhKAIAIgxLBEAgBSgCBCAFKAIIIAxBzLfCABAhKAIAIA9GDQELIAsgCTYCICAJIBdHDQEgCyATNgIkIAtBDjYCPCALQQ82AjQgC0EPNgIsIAsgC0EcajYCOCALIAtBJGo2AjAgCyALQSBqNgIoQcaLwAAgC0EoakGMt8IAEDUACyAJIQwMBQsgBSgCBCAFKAIIIAlBnLfCABAhIA82AgAgBSgCECAFKAIUIA9BrLfCABAhIAUgCUEBaiIMNgIYIAk2AgACQAJAAkACQAJAAkACQAJAAkAgACABIA8QugEiDS0AAEECaw4DAQIDAAsgC0EIaiAVIA8QuwEgCygCCCALKAIMIAMgBEH4rMIAEKQBDAwLAkAgDS0AAUUEQCANKAIMIglFDQ0gDSgCCCINKAIAIQ8gAiAJQQJ0QQRrIglBAnYiChCjASAKIAIoAggiCmohEiACKAIEIApBDGxqIQoDQCAJRQ0CIApBADYCACAKQQRqIAkgDWooAgA2AgAgCUEEayEJIApBDGohCgwACwALIA1BCGooAgAiCiANQQxqKAIAIglBAnRqQQRrIQ0gCUUgDUVyDQwgDSgCACEPIAtBEGogCiAJIAlBAWtB2KzCABC5ASALKAIQIQogAiALKAIUIhIQowEgAigCCCEJIAIg", + "EgR/IAkgEmogAigCBCAJQQxsaiEJA0AgCUEANgIAIAlBBGogCigCADYCACAKQQRqIQogCUEMaiEJIBJBAWsiEg0ACwUgCQs2AggMCQsgAiASNgIIDAgLIA0oAgQhDyAMIQkgDS8BAiINRQ0GAkACQAJAAkACQAJAAkACQAJAAkACQAJAIA1oQQFrDgsBAgMEBQYHCAkKCwALIAgNFQwRCyAHIAhHDRQMEAsgCEUNDyAHIA5LBEAgES0AAEEKRw0UDBALIA4gB0HEssIAECoACyAHIAhGDQ4gByAISwRAIBAtAABBCkcNEwwPCyAIIAdB1LLCABAqAAsgCEUNDQJAIAcgDksEQCARLQAAQQprDgQPExMBEwsgDiAHQeSywgAQKgALIAcgCE0NDSAQLQAAQQpGDREMDQsgByAIRg0MAkAgByAISwRAIBAtAABBCmsOBAESEg4SCyAIIAdB9LLCABAqAAsgCEUNDCAWLQAAQQ1GDRAMDAsCQCAIBEAgByAOTQ0IIBEtAAAtAIDSQiEKIAcgCEsNASAKQQFxRQ0RDA0LQQAhCiAHIAhNDRALIBAtAAAtAIDSQiAKQQFxRg0PDAsLAkAgCARAIAcgDksEQCARLQAALQCA0kIhCiAHIAhLDQIgCkEBcQ0RDA0LIA4gB0GUs8IAECoAC0EAIQogByAITQ0LCyAQLQAALQCA0kIgCkEBcUcNDgwKCyAIRQ0IIAcgDk0NBSAHIAhNDQ0gEC0AAC0AgNJCIBEtAAAtAIDSQg0NQQFxRQ0NDAkLIAhFDQwgByAOTQ0FIBEtAAAtAIDSQkEBIQogByAISwRAIBAtAAAtAIDSQkEBcyEKC0EBcUUNDCAMIQkgCkEBcUUNDAwICyAIRQ0HIAcgDksEQCARLQAALQCA0kINDAwICyAOIAdBxLPCABAqAAsgByAITQ0GIBAtAAAtAIDSQg0KDAYLIA0oAgQhDyAMIQkgDSgCCCINIARPDQUgC0EBNgIoIAsgDTYCLCALIAMgDUECdGoi", + "CSgCADYCMCACIAtBKGoQvAEgFEUNAyAJIBQ2AgAMBgsgDiAHQYSzwgAQKgALIA4gB0Gks8IAECoACyAOIAdBtLPCABAqAAtB6KzCABBdAAsgB0UNBCAGLQAALQCA0kINAAsLDAILIAQgD00EQCAPIARByKzCABAqAAUgAyAPQQJ0aiAJQQhqKAIANgIAIAlBDGshCQwBCwALAAsACyoAIAEgA00EQCAAIAMgAWs2AgQgACABIAJqNgIADwsgASADIAMgBBApAAvvAQEFfwJAIAJFBEBBfyEEDAELAkACQCABLAAAIgRBAEgEQEEAIQRBDCEFAkADQCACIANGBEAgAiEDDAULIAEgA2otAAAiBi0AhM9CIQcgBUEMRgR/Qf8BIAd2IAZxBSAGQT9xIARBBnRyCyEEIAUgB2oiBUHsAE8NAyAFLQCE0UIiBUUNASADQQFqIQMgBUEMRw0ACyAEQX9HIARBgLADc0GAgMQAa0GAkLx/T3ENBEHUq8IAEF0AC0EBIAMgA0EBTRshAwwCC0EBIQMMAgsgBUHsAEHw0cIAECoAC0F/IQQLIAAgAzYCBCAAIAQ2AgALIwAgAiADSQRAQQAgAyACIAQQKQALIAAgAzYCBCAAIAE2AgALHgAgASACTQRAIAIgAUGUuMIAECoACyAAIAJBFGxqC1QBAX8jAEEQayIDJAAgA0EIaiABKAIEIAEoAgggASgCDCACbCICIAIgASgCEGpB7LbCABAkIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAtCAQF/IAAoAggiAiAAKAIARgRAIAAQvQELIAAgAkEBajYCCCAAKAIEIAJBDGxqIgAgASkCADcCACAAIAEoAgg2AggLCwAgAEEMQQQQhggLQQECfyAAIAIQlgEgACgCCCEDAkAgAkUNACACQQN0IgRFDQAgACgCBCADQQN0aiABIAT8CgAACyAAIAIgA2o2AggLfgEDfyAAIAAoAggiAiABSQR/IAIhAyABIAJrIgQg", + "ACgCACACa0sEQCAAIAIgBEEEQQQQLyAAKAIIIQMLIAJBf3MgAWohASAAKAIEIANBAnRqIQIDQCACQQA2AgAgAQRAIAFBAWshASACQQRqIQIMAQsLIAMgBGoFIAELNgIICwsAIABBCEEEEIYICwsAIABBFEEEEIYICzIBAn8jAEEQayIBJAAgAUEIaiAAEMMBIAEoAgghACABKAIMIAFBEGokAEF/IABBAXEbC8cBAQV/AkAgASgCACICIAEoAgRGBEAMAQtBASEGIAEgAkEBajYCACACLQAAIgPAQQBODQAgASACQQJqNgIAIAItAAFBP3EhBCADQR9xIQUgA0HfAU0EQCAFQQZ0IARyIQMMAQsgASACQQNqNgIAIAItAAJBP3EgBEEGdHIhBCADQfABSQRAIAQgBUEMdHIhAwwBCyABIAJBBGo2AgAgBUESdEGAgPAAcSACLQADQT9xIARBBnRyciEDCyAAIAM2AgQgACAGNgIAC+w9Ahp/AX4jAEGQA2siAiQAAkACQAJAAkACQCABKAIUIhIgASgCAE0EQCASQX9HBEAgASASQQFqNgIUIAJBADYCYCACQoCAgIDAADcCWCACQQA2AmwgAkKAgICAwAA3AmQgAUE0aiEUIAFBJGohECACQZwBaiETIAJB7AFqIQ0gAkHMAWohDCACQYwCaiELIAJB/ABqIRUgAkHIAWohFyABQRxqIQcDQCABEMUBAkACQAJAAkACfwJAAkACQAJAAkACQAJAAkAgASgCGCABKAIQRwRAAkACQAJAAkAgBygCABDGASIEQShrDgQBAwkJAAsCQCAEQfsAaw4CCAsACyAEQT9GDQggBEHbAEYNCSAHKAIAEMYBIQMgARDHARoCQAJAAkACQAJAAkACQCADQdwAaw4DAgEEAAsgA0EkRg0EIANBLkYNAgsgAkHAAWogASADEMgBDAQLIAJBwAFqIAEQyQEMAwsgAkGAAmoiAyABEMoBAkACQCACLQCCAkUEQCADIAEQygEgAi0A", + "hAINASACQouAgIDw/78INwKIAiACQoCAgICQATcCgAIgDSADEMsBDAILIAJBCGpBAUEEQQgQB0EAIQMgAkEANgKIAiACIAIpAwg3AoACIAJBgAJqQQEQlgEgAigCiAIiBUEBaiEGIAIoAoQCIAVBA3RqIQQDQCADQQFxRQRAIARCgICAgPD/vwg3AgAgBEEIaiEEQQEhAwwBCwsgAiACKQKAAjcDgAMgAiAGNgKIAyACQYADahDMASANIAIoAogDNgIIIA0gAikDgAM3AgAMAQsgAkKOgICA8P+/CDcCmAIgAkKLgICAwAE3ApACIAJCgICAgJABNwKIAiACQoCAgIAwNwKAAiACQRBqQQNBBEEIEAdBACEEIAJBADYCiAMgAiACKQMQNwKAAyACQYADakEDEJYBIAIoAogDIgNBA2ohBSACKAKEAyADQQN0aiEDA0AgBEEYRwRAIAMgBGogAiAEakGIAmopAgA3AgAgBEEIaiEEDAELCyACIAIpAoADNwOwASACIAU2ArgBIAJBsAFqEMwBIA0gAigCuAE2AgggDSACKQOwATcCAAsgAkEENgLoASACQQA7AfwBIAJCATcDwAEgAiACKQLwATcD0AEgAiACKQLoATcDyAEgAiACKQL4ATcD2AEMAgsgAkGAAmoiAyABEMoBQQEhBCACLQCBAkEBRgRAIAMgARDKAUEQQQQgAi0AhAIbIQQLIAJBBTYCyAEgAkIBNwLAASACIAQ7AcwBIAJBAToA3QEgAiAEQQFGOgDcAQwBCyACQYACaiIDIAEQygFBAiEEIAItAIECQQFGBEAgAyABEMoBQSBBCCACLQCEAhshBAsgAkGAAjsB3AEgAiAEOwHMASACQQU2AsgBIAJCATcCwAELIAIoAsgBIQQgAigCxAEhAyACKALAASIGQQJHDQEgACAENgIIIAAgAzYCBAwWCyACQUBrIBBB7L7CABDNASACKAJAIgMvAAQhBSADKAAAIQMgAigCRCIEIAQoAgBBAWs2AgAg", + "AiADNgKAAyACIAU7AYQDIAIgBygCABDGASIDNgKAAiADQShGBEAgARDOARpBHCEFQcC+wgAhBiABQcCuwgBBAhDPAQ0VIAFBwq7CAEECEM8BDRUgAUHErsIAQQMQzwENFSABQceuwgBBAxDPAQ0VAkAgAUHAvcIAQQMQzwFFBEAgAUHDvcIAQQIQzwFFDQELIAEoAiAiA0F/Rw0MDBULIAFBrpfDAEEBEM8BRQRAIAEoAiAiA0F/Rg0VIAEgA0EBaiIPNgIgIAJBgAJqIAEQxAEgAigCiAIhBSACKAKEAiEGIAIoAoACIgNBAkYNFiACIAsoAhA2AvABIAIgCykCCDcD6AEgAiALKQIANwPgAUEEQSAQmwEiBCACKALwASIJNgIcIAQgBTYCCCAEIAY2AgQgBCADNgIAIAQgAikD4AE3AgwgBCACKQPoATcCFCAGQQFqIgVBfyAFGyEGQQchBUEAIQogBC0AHQwNCyABKAIYIhggASgCEEYEQEEsIQVBlL7CACEGDBYLIAJBOGogEEHQu8IAEM0BIAIoAjgiAy0AACEKIAMtAAEhDiADLQACIREgAy0AAyEPIAMtAAQhFiADLQAFIQkgAigCPCIDIAMoAgBBAWs2AgBBACEEIAJBgAJqQQBBgAH8CwBBACEDA0ACQAJAAkACQAJAIAcoAgAQxgFBOkcEQCAHKAIAEMYBQSlHDQELIARBAXFFDQFBLyEFQeC7wgAhBgwbCyAHKAIAEMYBIhlBLUYEQCADQQFxQQEhA0UNBEEnIQVBj7zCACEGDBsLIANBAXMhBEEYIQVBpLjCACEGAkACQAJAAkACQAJAAkAgBygCABDGASIIQfMAaw4GASEGISEEAAsCQCAIQdIAaw4EAyEhAgALAkAgCEHpAGsOBQUhISEAIQsgBEEBcSEODAULIARBAXEhEQwECyAEQQFxIQ8MAwsgBEEBcSEWDAILIARBAXEhCQwBCyAEQQFxIQoLIAcoAgAQxgEiBUGAAk8NASAFQf8ATQRA", + "IAJBgAJqIAVqIgUtAABFDQNBJCEFQZe9wgAhBgwbCyAFQYABQci8wgAQKgALIAJBMGogEEHIvcIAENABIAIoAjQhBSACKAIwIgMgEToAAiADIA46AAEgAyAKOgAAIANBBWogCToAACADIBpBgICAeHEgD0H/AXFyIBZBCHRyIgY7AAMgBSAFKAIAQQFqNgIAIAYgCUH/AXFBEHRyIRogASgCGCEEIAcoAgAQxgFBKUYEQCAEIBhHDRJBKSEFQdi9wgAhBgwaCyACIAcoAgAQxgEiAzYCgAIgA0E6RgRAIAEQxwEaIAJBgAJqIAEQxAEgAigCiAIhBSACKAKEAiEGIAIoAoACIgNBAkYNGiACLwGeAiEbIAItAJwCIQkgAigCmAIhCCACKAKUAiEKIAIoApACIQ8gAigCjAIhBCACLQCdAgwRC0GswsMAIAJBgAJqQQBBhL7CABClAQALQYyswgBBKyACQY8DakG4rMIAQbi8wgAQOgALIAVBAToAAAsgGUEtRiEEIAEQxwENAAtBPyEFQdi8wgAhBgwVCyACQYACakG8vcIAQQBB3L7CABClAQALIBMgDCgCEDYCECATIAwpAgg3AgggEyAMKQIANwIAIAIgBDYCmAEgAiADNgKUASACIAY2ApABIAJB5ABqIAJBkAFqEJ0BDA8LIBJFDQELIAEoAhQiA0UNASABIANBAWs2AhQgAiACKAJsNgLoASACIAIpAmQ3A+ABIAJBgAJqIgEgAkHgAWoQ0QEgAkHYAGogARCdASACIAIoAmAiCDYC6AEgAiACKQJYNwPgAUEBIQtBBCEMQQAhA0EAIQlBBCEHIAgiBSEKAkACQAJAAkAgBQ4CAQACCyACQQA2AugBIAIoAuQBIgEoAgAiC0ECRg0FIAEvAR4hBCABLQAdIQMgAS0AHCEJIAEoAhghBiABKAIUIQggASgCECEMIAEoAgwhBSABKAIIIQcgASgCBCEKCyACQeABahCcAQwBCyACIAIoAuQBIgw2AogCQQAh", + "ASACQQA2AoACIAIgDCAIQQV0ajYCjAIgAkGAAmoQ0gEiAwRAIAMoAgAtABwhCQsgAkGAAmoQ0gEiAwRAIAMoAgAtAB0hAQsgAkGAAmoQ0gEiAwR/IAMoAgAiAygCBCEKIAMoAgAFQQALIQcgCUEBcSEJIAFBAXEhBCACKAKAAiEGIAIoAowCIQ8gAigCiAIhBSACKAKEAiENA0AgByELIAQhAwNAAkACQCAGQQFxRQRAIAUgD0YNAiAFIgFBIGohBQwBCyANIgFFDQELIAlBAXFBACEJBEAgAS0AHCEJC0EBIQQgA0EBcUUEQCABLQAdIQQLIAEoAgAiECALcQRAQQAhBkEAIQcgBCEDIAogASgCBEcNAwwCC0EAIQZBACEHIAQhAyALIBByRQ0BDAILCwsgAigC4AEhBUEJIQcLIAAgBDsBHiAAIAM6AB0gACAJOgAcIAAgBjYCGCAAIAg2AhQgACAMNgIQIAAgBTYCDCAAIAc2AgggACAKNgIEIAAgCzYCAAwUCyAAQSY2AgggAEGwv8IANgIEDBELQcitwgAQXQALQfS3wgAQXQALIAIgAigCbDYCyAEgAiACKQJkNwPAASACIAcoAgAQxgEiAzYCgAICQAJAAkACQCADQfsARgRAQZTIwgAhBkE/IQMgAigCyAEiBUUNAyACIAVBAWsiBTYCyAEgAigCxAEgBUEFdGoiBSgCACIIQQJGDQMgAiAFKAIcNgKYAiACIAUpAhQ3A5ACIAIgBSkCDDcDiAIgAiAFKQIENwOAAkEEQSAQmwEiBCAINgIAIAQgAikDgAI3AgQgBCACKQOIAjcCDCAEIAIpA5ACNwIUIAQgAigCmAI2AhwgAiAENgKAAyABEM4BRQRAQSohA0HTyMIAIQYMAwsgAkGAAmogARDTASACKAKEAiEDIAIoAoACIgYNAiABKAIYIAEoAhBGBEBBOSEDQfLKwgAhBgwDC0EBIQYgAyEFAkAgBygCABDGAUEsRw0AIAEQzgFFBEBBPyEDQf3I", + "wgAhBgwECyAHKAIAEMYBQf0ARgR/QQAFIAJBgAJqIAEQ0wEgAigChAIhBSACKAKAAiIGBEAgBSEDDAULQQELIQYgASgCGCABKAIQRw0AQTohA0G8ycIAIQYMAwsgBygCABDGAUH9AEcEQEHFACEDQa3KwgAhBgwDC0EBIQogARDOAUUNASAHKAIAEMYBQT9HDQEgARDHARpBACEKDAELIAJBgAJqQZDIwgBBq8vCAEHEy8IAEKUBAAsgAkGAAmogARDKASACLQCDAiEIIAZFIAMgBU1yRQRAQTchA0H2ycIAIQYMAQsgAiAIIApzOgDwASACIAU2AuQBIAIgBjYC4AEgAiADNgLsASACIAQ2AugBIAJBgAJqIgMgAkHgAWoQ1AEgAkHAAWogAxCdASACKALEASEGIAIoAsgBIQMgAigCwAEiBEF/Rg0CIAIgAzYCbCACIAY2AmggAiAENgJkDAwLIAJBgANqEKABCyACQcABahCcAQsgACADNgIIIAAgBjYCBCAAQQI2AgAMDwsgAiACKAJsIgM2AsgBIAIgAikCZDcDwAEgAAJ/AkAgA0UNACACIANBAWsiAzYCyAEgAigCxAEgA0EFdGoiAygCACIEQQJGDQAgAiADKAIcNgKYAiACIAMpAhQ3A5ACIAIgAykCDDcDiAIgAiADKQIENwOAAkEEQSAQmwEiBSAENgIAIAUgAikDgAI3AgQgBSACKQOIAjcCDCAFIAIpA5ACNwIUIAUgAigCmAI2AhwCfwJAAkACQCAHKAIAEMYBIgNBKmsOAgECAAsgA0E/RgRAQQEhBkEADAMLIAIgAzYC4AEgAkEQNgKEAiACIAJB4AFqNgKAAkGW0cAAIAJBgAJqQZjMwgAQNQALQQAhBkEADAELQQAhBkEBCyEJQQEhAwJAIAEQxwFFDQAgBygCABDGAUE/Rw0AIAEQxwEaQQAhAwsgAkGAAmoiBCABEMoBIAIgAi0AgwIgA3M6APABIAJBATYC5AEgAiAGNgLgASACIAk2", + "AuwBIAIgBTYC6AEgBCACQeABahDUASACQcABaiAEEJ0BIAIoAsQBIQQgAigCyAEiAyACKALAASIGQX9GDQEaIAIgAzYCbCACIAQ2AmggAiAGNgJkDAoLIAJBwAFqEJwBQdTLwgAhBEHBAAs2AgggACAENgIEIABBAjYCAAwOCyACIAcoAgAQxgEiAzYCgAICQAJAAkAgA0HbAEYEQCACQQA2AogDIAJCgICAgMAANwKAAyABEM4BDQEMAgsgAkGAAmpBvLjCAEEAQcC7wgAQpQEACwJAIAcoAgAQxgFB3gBHIgkNACABEM4BDQBBLiEDQd64wgAhBAwCCwJAA0AgBygCABDGAUEtRw0BIAJBgANqQS1BLRDVASABEM4BDQALQTshA0GMucIAIQQMAgsCQCACKAKIAw0AIAcoAgAQxgFB3QBHDQAgAkGAA2pB3QBB3QAQ1QEgARDOAQ0AQcIAIQNBx7nCACEEDAILA0AgARDFASABKAIYIAEoAhBGDQECQAJAAkACQAJAAkACQAJAAkACQAJAIAcoAgAQxgEiBEHbAGsOAwEKBwALIARBJkYNASAEQS1GDQIgBEH+AEYNAwwJCyACIAcoAgAQxgEiAzYCgAIgA0HbAEcNBiAHKAIAIQMgASgCGCEIIAEQxwFFDQQgBygCABDGAUE6Rw0EIAEQxwFFDQQgBygCABDGAUHeAEciBUUEQCABEMcBRQ0FCyABKAIYIQQDQCAHKAIAEMYBQTpHBEAgARDHAQ0BCwsgASgCGCIKIAEoAhAiBkYNBCACQcgAaiABKAIMIAYgBCAKQezHwgAQ1gEgAigCTCEEIAIoAkghCiABQfzHwgBBAhDPAUUNBCACQeABaiAKIAQQ1wEgAigC4AFBAUYNBCACQYACaiIDIAIoAuQBIAIoAugBENgBIAVFBEAgAxDZAQsgAigCgAIiA0F/Rw0DDAcLIAEQ2gFBJkcNB0EtIQNBs7rCACEEDAoLIAEQ2gFBLUcNBkErIQNB4LrCACEEDAkL", + "IAEQ2gFB/gBHDQVBNSEDQYu7wgAhBAwICyACKAKEAiEFIAJBgANqIAIpAoQCIhynIBxCIIinEL4BIAMgBRCfAQwFCyABIAg2AhggAUEcaiADNgIADAILIAEQxwEaIAIpAoADIRwgAiACKAKIAzYCiAIgAiAcNwKAAiACQYACaiIDEMwBIAIgAigCiAI2AugBIAIgAikCgAI3A+ABIAMgARDKASACLQCAAgRAQQAhBCACKALoASEGA0AgBCAGRwRAIAJB0ABqIAIoAuQBIAIoAugBIARBlLHCABDbASIDKAIAIANBBGooAgAQ3AEgAigCUCIDQX9HBEAgAkHgAWogAyACKAJUENUBCyAEQQFqIQQMAQsLIAJB4AFqEMwBCyAJRQRAIAJB4AFqENkBCyAVIAIoAugBNgIIIBUgAikD4AE3AgAgAkEAOwGMASACQQQ2AnggAkIBNwJwIAJB5ABqIAJB8ABqEJ0BDA0LIAJBgAJqQby4wgBBAEGAyMIAEKUBAAtBKiEDQYm6wgAhBAwDCyACQYACaiABEN0BIAIoAogCIQMgAigChAIhBAJAIAIoAoACIgZBAkYNACAMIAsoAhA2AhAgDCALKQIINwIIIAwgCykCADcCACACIAM2AsgBIAIgBDYCxAEgAiAGNgLAASABEMUBAkAgASgCGCABKAIQRgRAQTAhA0HoxcIAIQQMAQsCQCAHKAIAEMYBQS1HDQAgARDeAUHdAEYNACABEN4BQS1GDQAgARDOAUUEQEE7IQNBjLnCACEEDAILIAJBgAJqIgUgARDdASACKAKIAiEDIAIoAoQCIQQgAigCgAIiBkECRg0BIA0gCygCEDYCECANIAspAgg3AgggDSALKQIANwIAIAIgAzYC6AEgAiAENgLkASACIAY2AuABIAIgAikC2AE3A5gCIAIgAikC0AE3A5ACIAIgAikCyAE3A4gCIAIgAikCwAE3A4ACIAJBsAFqIAUQ3wEgAigCtAEhAyACKAKwASIEBEAgAkHgAWoQ", + "mQEMAwsgAiACKQL4ATcDmAIgAiACKQLwATcDkAIgAiACKQLoATcDiAIgAiACKQLgATcDgAIgAkGwAWogAkGAAmoQ3wEgAigCtAEhBiACKAKwASIEBEAgBiEDDAMLIAMgBk0EQCACQYADaiADIAYQ1QEMBAtBICEDQcjFwgAhBAwCCyACIAIpAsgBNwOIAiACIAIpAtgBNwOYAiACIAIpAtABNwOQAiACIAIpAsABNwOAAiACQQI2AogCQX8hBkEqIQVBm9bCACEEAkACQAJAQQQgA0ECayADQQFNG0EBaw4CAAECCyACKALMASEFQQRBCBCbASIEIAU2AgQgBCAFNgIAQQEhBkEBIQUMAQsgAigClAIhBSACKAKQAiEEIAIoAowCIQYLIANBBEcEQCAXEJ4BCyACQYACahCZASAGQX9GBEAgBSEDDAILIAJBgANqIAQgBRC+ASAGIAQQnwEMAgsgAkHAAWoQmQELIARFDQALDAELQcC4wgAhBEEeIQMLIAIoAoADIAIoAoQDEJ8BIAAgAzYCCCAAIAQ2AgQMDAsgAikCZCEcIAJCgICAgMAANwJkIAIoAmwhBCACQQA2AmwgAiAENgLoASACIBw3A+ABIAJBgAJqIgMgAkHgAWoQ0QEgAkHYAGogAxCdASABEMcBGgwGCyABIANBAWoiDzYCICABKAIYIgkgASgCEEYEQEEzIQVBtsfCACEGDAoLA0AgBygCABDGAUE+RwRAIAcoAgAQxgEhAwJAAkACQCAJIAEoAhhHBEAgA0HbAGsiBUEETQ0BDAILIANB3wBGIANB3///AHFBwQBrQRpJcg0CQRIhBUGYxsIAIQYgA0GqAUkNDiADEGYNAgwOC0EBIAV0QRVxDQELIANBLkYgA0Hf//8AcUHBAGtBGklyIANBMGtBCklyDQBBEiEFQZjGwgAhBiADQaoBSQ0MIAMQZg0AIANBsgFJDQxBACEKQRVBACADQdCoBE8bIgQgBEELaiIEIAMgBEECdCgCvKpBQf//", + "/wBxSRsiBCAEQQVqIgQgAyAEQQJ0KAK8qkFB////AHFJGyIEIARBA2oiBCADIARBAnQoAryqQUH///8AcUkbIgQgBEEBaiIEIAMgBEECdCgCvKpBQf///wBxSRsiBCAEQQFqIgQgAyAEQQJ0KAK8qkFB////AHFJGyIEQQJ0KAK8qkFBC3QiCCADQQt0Ig5GIAggDklqIARqIg5BAnQiBEG8qsEAaiERIAQoAryqQUEVdiEEQaMCIQgCQCAOQSlNBEAgESgCBEEVdiEIIA5FDQELIBFBBGsoAgBB////AHEhCgsCQCAIIARBf3NqRQ0AIAMgCmshCiAIQQFrIQhBACEDA0AgAyAEQYr+wABqLQAAaiIDIApLDQEgCCAEQQFqIgRHDQALCyAEQQFxRQ0MCyABEMcBDQELCyABKAIYIgMgASgCEEYEQEE6IQVB/MbCACEGDAoLIAIgBygCABDGASIFNgKAAgJAIAVBPkYEQCABEMcBGiACQShqIAEoAgwgASgCECAJIANBsMbCABDWASACKAIsIggNAUEpIQVBwMbCACEGDAsLIAJBgAJqQazGwgBBAEHsxsIAEKUBAAsCQCABKAIwRQRAIAIoAighBSABQX82AjAgASgCPCIERQRAQQAhBAwCCyABKAI4IQZBACEDA0AgBEEBTQRAIAUgCCAGIANBDGxqIgRBBGooAgAgBEEIaigCABDgAUH/AXEiBARAIAMgBEH/AUZqIQQMBAsgAUEANgIwQZSuwgAhBkEcIQUMDQUgAyAEQQF2IgkgA2oiAyAFIAggBiADQQxsaiIDQQRqKAIAIANBCGooAgAQ4AFB/wFxQQFGGyEDIAQgCWshBAwBCwALAAtBhK7CABBeAAsgAkGAAmogBSAIEOEBIAEoAjwiAyAESQ0CIBQoAgAgA0YEQCAUEL0BCyABKAI4IARBDGxqIQYCQCADIARNDQAgAyAEa0EMbCIERQ0AIAZBDGogBiAE/AoAAAsgBiACKAKIAjYCCCAGIAIpAoAC", + "NwIAIAEgA0EBajYCPCABIAEoAjBBAWo2AjAgAkEgakEBIAgQiQEgAigCICIKRQ0DIAgEQCAKIAUgCPwKAAALIAJBgAJqIAEQxAEgAigCiAIhBSACKAKEAiEGIAIoAoACIgNBAkYEQCAKIAgQoQEMCgsgAiALKAIQNgLQASACIAspAgg3A8gBIAIgCykCADcDwAFBBEEgEJsBIgQgAigC0AEiCTYCHCAEIAU2AgggBCAGNgIEIAQgAzYCACAEIAIpA8ABNwIMIAQgAikDyAE3AhQgBkEBaiIFQX8gBRshBkEHIQUgBC0AHQshDiACIBs7AZ4CIAIgDjoAnQIgAiAJOgCcAiACIAg2ApgCIAIgCjYClAIgAiAPNgKQAiACIAQ2AowCIAIgBTYCiAIgAiAGNgKEAiACIAM2AoACIAJB5ABqIAJBgAJqEJ0BIAJBGGogEEH8vsIAENABIAIoAhwhBCACKAIYIgMgAi8BhAM7AAQgAyACKAKAAzYAACAEIAQoAgBBAWo2AgALIAcoAgBBKUYNAkEkIQVBjL/CACEGDAcLIwBBIGsiACQAIAAgAzYCDCAAIAQ2AgggACAAQQxqrUKAgICAwACENwMYIAAgAEEIaq1CgICAgMAAhDcDEEHjz8AAIABBEGpBsK7CABA1AAsQHQALIAEQxwEaDAALAAtB2K3CABBdAAsgAEEcNgIIIABB6K3CADYCBCAAQQI2AgAMBAtBFyEFQeSrwgAhBgsgACAFNgIIIAAgBjYCBAsgAEECNgIAIAJB5ABqEJwBCyACQdgAahCcAQsgAkGQA2okAAuWAQEDfyMAQRBrIgEkACABQQpqIAAQygECQCABLQAPQQFHDQAgAEEcaiECA0AgACgCGCAAKAIQRg0BAkAgAigCABDGARAiRQRAIAIoAgAQxgFBI0YNAQwDCyAAEMcBGgwBCyAAEMcBGgNAIAAoAhggACgCEEYNASACKAIAEMYBIAAQxwEaQQpHDQALDAALAAsgAUEQaiQACxsAIABB", + "f0YEQEHcrsIAQR1B/K7CABBiAAsgAAunAQEEfyMAQRBrIgIkACAAKAIYIgMgACgCEEcEQCAAAn9BASAAQRxqIgQoAgAQxgEiAUGAAUkNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsgA2oiATYCGCACIAAoAgwgACgCECABQcyuwgAQqQEgAiACKAIAIgA2AgggAiAAIAIoAgRqNgIMIAQgAkEIahDCASIANgIAIABBf0chAQsgAkEQaiQAIAELogEBAn8jAEEgayIDJAAgA0EQaiABEMoBAn8CQCADLQAQQQFGBEAgA0EIaiACIAIQ3AEgAygCCCIBQX9HDQELIABBAzYCCEEMDAELIAMoAgwhBCADIAE2AhggAyACNgIUIAMgAjYCECADIAQ2AhwgAEEMaiADQRBqEMsBQQQhAkEICyEBIABBADsBHCAAQgE3AgAgACABaiACNgIAIANBIGokAAuEEwEFfyMAQTBrIgIkAAJAAkACQAJAAkACQAJAAkACQCABKAIYIAEoAhBHBEAgAUEcaigCABDGASIDQTBrQQpPBEACQAJAAkACQAJAIANB8ABrDgkCAQEHAQMBBwMACwJAIANB0ABrDggCAQEHAQMBBwALIANBxABGIANB5ABGcg0GCyABEMcBGiADQSNrIgRBHE0NAgwJCyAAQSs2AgggAEHWv8IANgIEIABBAjYCAAwMC0ECIQMCQAJAAkACQAJAIAFBHGooAgAQxgEiBEH1AGsOBAIBAQQACyAEQdUARg0CCyACIAQ2AiQgAkEQNgIIIAIgAkEkajYCBEHwhcAAIAJBBGpBxM7CABA1AAtBBCEDDAELQQghAwsgARDOAUUEQCAAQTk2AgggAEGIzsIANgIEIABBAjYCAAwMCyABQRxqIgQoAgAQxgFB+wBGBEAgAkEANgIMIAJCgICAgBA3AgQDQCABEM4BRQ0GIAQoAgAQxgFB/QBGDQYgBCgCABDGARD6AQRAIAJBBGogBCgCABDGARAJDAEFQTwh", + "AUGIw8IAIQMMCAsACwALIAJBADYCDCACQoCAgIAQNwIEA0ACQAJAIAACfwJAAkACQCADIAVHBEAgBQ0BDAMLIAEQzgEaIAJBJGogAigCCCIDIAIoAgxBEBD7ASACLQAkDQEgAigCKCIEQYCwA3NBgIDEAGtBgJC8f0kgBEF/RnINASAAIAEgBBDIAQwFCyABEM4BDQFB78PCACEDQcYADAILIABBKzYCCCAAQcTDwgA2AgQgAEECNgIADAMLIAQoAgAQxgEQ+gENAUG1xMIAIQNBPws2AgggACADNgIEIABBAjYCACACKAIIIQMMAQsgAkEEaiAEKAIAEMYBEAkgBUEBaiEFDAELCyACKAIEIAMQAQwLC0EBIAR0QeubgIABcUUNBgwHCyAAQSA2AgggAEGdwMIANgIEIABBAjYCAAwJCyAAQccANgIIIABBvcDCADYCBCAAQQI2AgAMCAsgAUEcaigCABDGASEDIAEQxwEaAkACQAJAAkACQAJAIANB0wBrDgUBBAQEAgALAkAgA0HzAGsOBQEEBAQCAAsgA0HEAEcgA0HkAEdxDQMgAkEEakH0xMIAQQUQ1wEgAigCBEEBRw0CIAIgAikCCDcCJEGMrMIAQSsgAkEkakH8q8IAQfzEwgAQOgALIAJBBGpBjMXCAEEFENcBIAIoAgRBAUcNASACIAIpAgg3AiRBjKzCAEErIAJBJGpB/KvCAEGUxcIAEDoACyACQQRqQaTFwgBBBBDXASACKAIEQQFGDQILIAJBBGoiASACKAIIIAIoAgwQ2AEgA0HaAE0EQCABENkBCyAAIAIoAgw2AhQgACACKQIENwIMIABBADsBHCAAQQQ2AgggAEIBNwIADAkLIAIgAzYCJCACQRA2AgggAiACQSRqNgIEQZmAwAAgAkEEakG4xcIAEDUACyACIAIpAgg3AiRBjKzCAEErIAJBJGpB/KvCAEGoxcIAEDoACyABKAIYIAEoAhBGBEBByAAhAUHAwsIAIQMMAQsgAiABQRxq", + "KAIAEMYBIgM2AiQCQCADQf0ARgRAIAEQzgEaIAIoAgwiBA0BQTghAUH4wcIAIQMMAgsgAkEkakHMwcIAQQBBsMLCABClAQALIAJBJGogAigCCCIDIARBEBD7AQJAIAItACQNACACKAIoIgRBgLADc0GAgMQAa0GAkLx/SSAEQX9Gcg0AIAAgASAEEMgBDAILIABBKDYCCCAAQdDBwgA2AgQgAEECNgIADAELIAAgATYCCCAAIAM2AgQgAEECNgIAIAIoAgghAwsgAigCBCADEAEMBAsgA0H9AHFBPEYgA0H/AEtyRSADQd8AcUHbAGtBZU1xIANB2wBrQQRJIANB+wBrQQRJcnINAAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgA0E8aw4HCwEMAQEICgALAkAgA0HyAGsOCQYBBAEHAQEBCQALAkAgA0HhAGsOBgINAQEBAwALIANB7gBGDQQLIABBHDYCCCAAQYHAwgA2AgQgAEECNgIADA8LIAAgAUEHEMgBDA4LIAAgAUEMEMgBDA0LIAAgAUEJEMgBDAwLIAAgAUEKEMgBDAsLIAAgAUENEMgBDAoLIAAgAUELEMgBDAkLIABBgQI7ARwgAEEBOwEMIABBBTYCCCAAQgE3AgAMCAsgAEGAAjsBHCAAQQI7AQwgAEEFNgIIIABCATcCAAwHCyAAQYACOwEcIABBgAE7AQwgAEEFNgIIIABCATcCAAwGCyAAQYACOwEcIABBgAI7AQwgAEEFNgIIIABCATcCAAwFCyAAQYACOwEcIABBgAQ7AQwgAEEFNgIIIABCATcCAAwECyACQYACOwEgIAJBwAA7ARAgAkEFNgIMIAJCATcCBCABKAIYIAEoAhBGDQIgAUEcaiIDKAIAEMYBQfsARw0CIAIgAygCABDGASIDNgIkAkAgA0H7AEYEQCABKAIYIQMgARDOAQ0BQcEAIQNBqMzCACEEDAMLIAJBJGpBkMjCAEEAQfjNwgAQpQEACyABQRxqIgUoAgAQ", + "xgEiBEEtRiAEQd///wBxQdsAa0FlS3JFBEAgASADNgIYIAVB+wA2AgAMAwsgAkEANgIsIAJCgICAgBA3AiQDQEHHACEDQa/NwgAhBAJAAn8CQAJAIAEoAhggASgCEEYNACAFKAIAEMYBIgZBLUYgBkHf//8AcUHBAGtBGklyDQMgASgCGCABKAIQRg0AIAFBHGooAgAQxgFB/QBHDQAgARDHARpBgAIgAigCKCIBIAIoAiwiBEHpzMIAQQUQEg0CGkGABCABIARBk+PCAEEDEBINAhpBgAggASAEQe7MwgBBChASDQIaIAEgBEH4zMIAQQgQEg0BQS8hA0GAzcIAIQQLIAIoAiQgAigCKBABDAULQYAQCyEDIAIoAiQgARABIAJBBGoQmQEgAkGAAjsBICACIAM7ARAgAkEFNgIMIAJCATcCBAwECyACQSRqIAUoAgAQxgEQCSABEM4BGgwACwALIAJBBGogASADEMgBIAAgAikCHDcCGCAAIAIpAhQ3AhAgACACKQIMNwIIIAAgAikCBDcCAAwCCyAAIAM2AgggACAENgIEIABBAjYCACACQQRqEJkBDAELIAAgAikCHDcCGCAAIAIpAhQ3AhAgACACKQIMNwIIIAAgAikCBDcCAAsgAkEwaiQAC1MBAn8jAEEQayICJAAgAkEIaiABQSRqQZyvwgAQzQEgAigCDCEBIAAgAigCCCIDLwAEOwAEIAAgAygAADYAACABIAEoAgBBAWs2AgAgAkEQaiQAC8IBAQN/IwBBQGoiAiQAIAIgASkCCDcCLCACIAEpAgA3AiQgAkEIakECQQRBCBAHQQAhASACQQA2AjwgAiACKQMINwI0IAJBNGpBAhCWASACKAI8IgNBAmohBCACKAI4IANBA3RqIQMDQCABQRBGRQRAIAEgA2ogASACakEkaikCADcCACABQQhqIQEMAQsLIAIgAikCNDcDECACIAQ2AhggAkEQahDMASAAIAIoAhg2AgggACACKQMQNwIAIAJBQGsk", + "AAvXBAEMfyMAQSBrIgokACAAKAIIIgJBAWohCSAAKAIEIgQhAQJAA0AgCUEBayIJQQJJDQECQAJAIAEoAgAiBSABQQhqIgMoAgAiCEYEQCABQQRqKAIAIgYgAUEMaigCACIHSQ0BDAILIAUgCE8NASABQQxqKAIAIQcgAUEEaigCACEGCyADIQEgByAGIAYgB0sbQQFqIAggBSAFIAhJG0kNAQsLAkAgAkECTwRAIAJBFU8EQCMAQZAgayIBJAACQEHAhD0gAiACQcCEPU8bIgMgAiACQQF2ayIFIAMgBUsbIgNBgQRPBEAgAUEIaiADQQRBCBAHIAQgAiABKAIMIgQgASgCCCIDIAJBwQBJEKwBIAMgBBCfAQwBCyAEIAIgAUEQakGABCACQcEASRCsAQsgAUGQIGokAAwCCyACQQN0IQNBCCEBA0AgASADRg0CIAQgASAEahCzASABQQhqIQEMAAsACyACDQBB2LDCAEEpQYSxwgAQPgALQQAhAUEEIQQDQAJAAkAgASACRwRAIAAoAgQhAyACIAAoAggiCUkEQCADIARqIgZBBGsoAgAiBSADIAlBA3RqIgdBCGsiCygCACIIIAUgCEsbIAYoAgAiBiAHQQRrIgwoAgAiByAGIAdJG0EBak0NAgsgACADIAkgAUHIsMIAENsBIgMoAgAgAygCBBDVAQwCCyAKQQxqIgEgACACEJEBIAEQ/AEMAwsgDCAGIAcgBiAHSxs2AgAgCyAFIAggBSAISRs2AgALIAFBAWohASAEQQhqIQQMAAsACyAKQSBqJAALDQAgACABIAJBBBCCCAsfAQF/IAAQxwEEfyAAEMUBIAAoAhggACgCEEcFQQALC2sBAn8jAEEQayIDJAAgA0EIaiAAKAIMIAAoAhAgACgCGEGsr8IAEKkBAkAgAygCCCADKAIMIAEgAhD9ASIERQ0AIAEgAhBjIQIDQCACRQ0BIAAQxwEaIAJBAWshAgwACwALIANBEGokACAECw0AIAAgASACQQQQ", + "gwgLxAIBB38CQAJAAkACQAJAIAEoAggiAg4CAQADCyABQQA2AgggASgCBCICKAIAIgNBAkYNAyAAIAM2AgAgACACKQIENwIEIAAgAikCDDcCDCAAIAIpAhQ3AhQgACACKAIcNgIcDAELIABBgAI7ARwgAEECNgIIIABCATcCAAsgARCcAQ8LIAJBBXQhBiABKAIEIgItABwhB0EBIQNBASEEA0ACfwJAIAYEQCAEQQFxQQAhBARAIAJBHWotAAAhBAsgAw0BQQAMAgsgACAEOgAdIAAgBzoAHCAAQQg2AgggACAFNgIEIAAgAzYCACAAIAEoAgg2AhQgACABKQIANwIMDwtBACACKAIAQQFHDQAaQX8gBSACQQRqKAIAaiIDIAMgBUkbIQVBAQshAyACQSBqIQIgBkEgayEGDAALAAtBhLjCABBdAAtaAQJ/IABBBGohAgJAIAAoAgBBAUYEQCACKAIAIQEMAQsCQCAAKAIIIgEgACgCDEYEQEEAIQEMAQsgACABQSBqNgIICyAAIAE2AgQgAEEBNgIACyACQQAgARsLqwIBA38jAEEgayICJAAgAkEANgIUIAJCgICAgBA3AgwgAUEcaiEDA0ACQCABKAIYIAEoAhBGDQAgAygCABDGARAiRQ0AIAEQxwEaDAELCwNAAkAgASgCGCABKAIQRg0AIAFBHGoiAygCABDGAUEwSQ0AIAMoAgAQxgFBOUsNACACQQxqIAMoAgAQxgEQCSABEM4BGgwBCwsDQAJAIAEoAhggASgCEEYNACABQRxqKAIAEMYBECJFDQAgARDOARoMAQsLIAIoAhAhAQJ/IAIoAhQiA0UEQEEsIQNBnsHCAAwBCyACQRhqIAEgA0EKEPsBQRogAigCHCACLQAYIgQbIQNBhMHCAEEAIAQbCyEEIAAgAzYCBCAAIAQ2AgAgAigCDCABEAEgAkEgaiQAC6ECAQV/AkACfwJAAkACQAJAIAEoAgwOAgABAgtBASEEIAEoAgBBAUcNAiABKAIE", + "DQIgAEGAAjsBHCAAQQI2AgggAEIBNwIAIAEoAggiARCZAQwECyABKAIAQQFHDQAgASgCBEEBRw0AIAAgASgCCCIBKQIANwIAIAAgASkCCDcCCCAAIAEpAhA3AhAgACABKQIYNwIYDAMLIAEoAggiAigCBCEFIAItAB0hBCACLQAcIQYgAigCAAwBC0EAIAEoAggiAigCBCIDIAIoAgAiAhshBUEAIAIgAxsgAiACGwshAyAAIAQ6AB0gACAGOgAcIAAgBTYCBCAAIAM2AgAgACABKAIQNgIYIAAgASkCCDcCECAAIAEpAgA3AggPCyABEKIBCzwBAX8gACgCCCIDIAAoAgBGBEAgABDAAQsgACADQQFqNgIIIAAoAgQgA0EDdGoiACACNgIEIAAgATYCAAtmAAJAIAIgBEkgAyAES3INAAJAIAIgA0YNACADBEAgASADaiwAAEG/f0wNAgsgAiAERg0AIAEgBGosAABBv39MDQELIAAgBCADazYCBCAAIAEgA2o2AgAPCyABIAIgAyAEIAUQWgALxwMBAX9BAyEDIAACfwJAIAEgAkHA1MIAQQUQEgRAQdTVwgAhAgwBCwJAIAEgAkHF1MIAQQUQEgRAQdDVwgAhAgwBCyABIAJBytTCAEEFEBIEQEHO1cIAIQJBASEDDAILIAEgAkHP1MIAQQUQEgRAQcrVwgAhAgwBCyABIAJB1NTCAEEFEBIEQEHG1cIAIQIMAQsgASACQfTEwgBBBRASBEBBxNXCACECQQEhAwwCCyABIAJB2dTCAEEFEBIEQEHC1cIAIQJBASEDDAILIAEgAkHe1MIAQQUQEgRAQcDVwgAhAkEBIQMMAgsgASACQePUwgBBBRASBEBBvtXCACECQQEhAwwCCyABIAJB6NTCAEEFEBIEQEG21cIAIQJBBCEDDAILIAEgAkGMxcIAQQUQEgRAQarVwgAhAkEGIQMMAgsgASACQe3UwgBBBRASBEBBqNXCACECQQEhAwwCCyABIAJBpMXCAEEE", + "EBIEQEGg1cIAIQJBBCEDDAILIAEgAkHy1MIAQQYQEgRAQZrVwgAhAgwCCyAAQSI2AgggAEH41MIANgIEQQEMAgtBAiEDCyAAIAI2AgQgACACIANBAXRqNgIIQQALNgIAC8UBAQN/IwBBIGsiAyQAIAMgAiABa0EBdiIFQQRBCBAHIANBADYCHCADIAMpAwA3AhQgA0EUaiAFEJYBIAMoAhwhBCABIAJHBEAgBCAFaiADKAIYIARBA3RqIQQDQCAEIAEtAAA2AgAgBEEEaiABQQFqLQAANgIAIAFBAmohASAEQQhqIQQgBUEBayIFDQALIQQLIAMgAykCFDcDCCADIAQ2AhAgA0EIahDMASAAIAMoAhA2AgggACADKQMINwIAIANBIGokAAuhAwEHfyMAQSBrIgYkAAJAAkACQAJAAkAgACgCCCIDBEAgACgCBCIBIANBAEGkscIAENsBKAIABEAgASADQQBBtLHCABDbASgCABD+ASIBQX9GDQIgAEEAIAEQ1QELQQEhAQNAIAEgA0cEQEGAwAMhAiAAKAIEIgQgACgCCCIFIAFBAWtBhLLCABDbASgCBCIHQf+vA0cEQCAHQQFqIgJBgLADc0GAgMQAa0H/j7x/TQ0FCyAEIAUgAUGkssIAENsBKAIAEP4BIgRBf0YNBSAAIAIgBBDVASABQQFqIQEMAQsLIAAoAgQiAiAAKAIIIgQgA0EBayIFQdSxwgAQ2wEoAgRB/v/DAE0EQEGAwAMhASACIAQgBUHkscIAENsBKAIEIgJB/68DRwRAIAJBAWoiAUGAsANzQYCAxABrQf+PvH9NDQYLIAAgAUH//8MAENUBCyAGQQxqIgEgACADEJEBIAEQ/AEMBQsgAEEAQf//wwAQ1QEMBAtBxLHCABBdAAtBlLLCABBdAAtBtLLCABBdAAtB9LHCABBdAAsgBkEgaiQAC5MBAQR/IwBBEGsiASQAQX8hAiAAKAIYIgMgACgCECIERwRAIAEgACgCDCAEAn9BASAAQRxq", + "KAIAEMYBIgBBgAFJDQAaQQIgAEGAEEkNABpBA0EEIABBgIAESRsLIANqQYyvwgAQqQEgASABKAIAIgA2AgggASAAIAEoAgRqNgIMIAFBCGoQwgEhAgsgAUEQaiQAIAILGwAgASACTQRAIAIgASADECoACyAAIAJBA3RqC3MBAn8Cf0HhACABIAFB4QBNGyIDQfoAIAIgAkH6AE8bIgRNBEAgBEEgayECIANBIGsMAQtBf0HBACABIAFBwQBNGyIBQdoAIAIgAkHaAE8bIgJLDQAaIAJBIGohAiABQSBqCyEBIAAgAjYCBCAAIAE2AgALRAEBfyABQRxqKAIAEMYBIQIgARDHARogAkHcAEYEQCAAIAEQyQEPCyAAQQA7ARwgACACNgIMIABBAzYCCCAAQgE3AgAL5QIBCH8jAEEwayIBJAAgAUEkaiAAEMoBAn8gAS0AKUUEQCAAENoBDAELQX8gACgCGCIEIAAoAhBGDQAaAn9BASAAQRxqKAIAEMYBIgNBgAFJDQAaQQIgA0GAEEkNABpBA0EEIANBgIAESRsLIQIgAUEYaiAAKAIMIAAoAhAgAiAEaiIFQaitwgAQqQEgASgCHCEDIAEoAhghAkEAIQQgAUEANgIsIAEgAiADaiIDNgIoIAEgAjYCJAJAA0AgAUEQaiABQSRqEMMBIAEoAhBBAUcNASABKAIUIQYgASABKAIsIgcgA2ogAiABKAIoIgNqayABKAIkIgJqNgIsIAYQIg0AIAQiCEUgBkEjRnEhBCAGQQpBIyAIG0YNAAsgBSAHaiEFCyABQQhqIAAoAgwgACgCECAFQbitwgAQqQEgASABKAIIIgA2AiQgASAAIAEoAgxqNgIoIAFBJGoQwgELIAFBMGokAAswAQF/IAAgASgCDEHBACABKAIIQQNGIgIbNgIEIABBAEHa1cIAIAIbNgIAIAEQmQELKAAgACACIAEgAyABIANJGxD6ByIAIAEgA2sgABsiAEEASiAAQQBIawtTAQN/IwBBEGsi", + "AyQAIANBCGogAkEBQQEQByADKAIMIQQgAygCCCEFIAIEQCAEIAEgAvwKAAALIAAgAjYCCCAAIAQ2AgQgACAFNgIAIANBEGokAAupAQEDfyACQQFqIQIDQEHorcIAIQQCQAJAAkAgAkUgAkEBayABS3INAEEQIQNBACEEAkBBBCAAKAIIIgVBAmsgBUEBTRtBBGsOBAMCAAABCyAAKAIUQQV0IQMgACgCECEAA0AgA0UEQEEADwsgA0EgayEDIAAgASACEOIBIQQgAEEgaiEAIARFDQALCyAEDwtBDCEDCyACQQFqIQIgACADaigCACEADAALAAspAANAIAEEQCAAKAIAIABBBGooAgAQASABQQFrIQEgAEEMaiEADAELCwsNACAAIAEgAkEIEIMIC/YRAhd/BH4jAEHQAGsiBiQAIAZBKGogAUEIaiIIQci1wgAQ5gEgBigCKCgCSCEKIAYoAiwiByAHKAIAQQFrNgIAIAogAiACIApLGyEHA0AgAiAHRwRAIAZBIGogCEGYtsIAEOQBIAYoAiQhCSAGKAIgQUBrQQAgBhDVASAJIAkoAgBBAWo2AgAgB0EBaiEHDAELCwJAAkACQCACIApPBEACQCADBEACQAJAAkAgBEEATgRAIARB9f///wdPDQEgBkEYakEEIARBC2pB/P///wdxEIkBIAYoAhgiDUUNAiANQoGAgIAQNwIAIA1BCGohFyAEBEAgFyADIAT8CgAACyAGIAQ2AjQgBiANNgIwIAZBEGogCEHYtcIAEOQBIAYoAhQhGCAGKAIQIQogDSANKAIAIgNBAWo2AgAgA0EASA0DIAYgBDYCPCAGIA02AjggCikDGCAKKQMgIA0gBBCKASEeIAooAhBFBEAgCkEYaiEZIwBBMGsiCCQAAn8CQAJAIApBCGoiDigCDCIUQQFqIgNFDQAgDigCBCIMIAxBAWoiD0EDdiIHQQdsIAxBCEkbIhFBAXYgA0kEQCAIQSBqQQwCfyARQQFqIgcgAyADIAdJGyID", + "QQ9PBEAgA0H/////AUsNA0F/IANBA3RBB25BAWtndkEBagwBC0EEIANBCHFBCGogA0EESRsLEIMBIAgoAiQiDCAIKAIgIglFDQMaIAgoAighDyAIKAIsIQMgDEEJaiIHBEAgCUH/ASAH/AsACyAIIAM2AhwgCCAPNgIYIAggDDYCFCAIIAk2AhAgCEKMgICAgAE3AgggCCAOQRBqNgIEIA4oAgAiAykDAEJ/hUKAgYKEiJCgwIB/gyEdIAhBEGohECADIQcDQCAUBEADQCAdUARAIAtBCGohCyAHQQhqIgcpAwBCf4VCgIGChIiQoMCAf4MhHQwBCwsgCSAJIAwgGSADIB16p0EDdiALaiIREIQBIh8QhQEiA2ogH6dBGXYiEjoAACAJIANBCGsgDHFqQQhqIBI6AAAgCSADQXRsakEMayISIA4oAgAiAyARQXRsakEMayIRKAAINgAIIBIgESkAADcAACAUQQFrIRQgHUIBfSAdgyEdDAELCyAIIA4oAgwiAzYCHCAIIA8gA2s2AhggDiAQQQQQhgEgCCgCFCIDRQ0CIAhBIGogCCgCCCAIKAIMIANBAWoQhwEgCCgCIBogCCgCECAIKAIoayAIKAIkEIgBDAILIAcgD0EHcUEAR2ohAyAOKAIAIgkhCwNAIAMEQCALIAspAwAiHUJ/hUIHiEKBgoSIkKDAgAGDIB1C//79+/fv37//AIR8NwMAIAtBCGohCyADQQFrIQMMAQUCQCAPQQhPBEAgCSAPaiAJKQAANwAADAELIA9FDQAgCUEIaiAJIA/8CgAAC0EAIQMDQAJAIA8gAyIHRwRAIANBAWohAyAHIAlqIhItAABBgAFHDQIgCSADQXRsaiELA0AgByAMIBkgCSAHEIQBIh2nIhVxIhZrIAkgDCAdEIUBIhAgFmtzIAxxQQhJDQIgCSAQaiIWLQAAIBYgFUEZdiIVOgAAIAkgEEEIayAMcWpBCGogFToAACAJIBBBdGxqQQxrIRBB/wFGBEAgEkH/AToA", + "ACAJIAdBCGsgDHFqQQhqQf8BOgAAIBAgCygACDYACCAQIAspAAA3AAAMBAUgCyAQQQMQhgEMAQsACwALIA4gESAUazYCCAwFCyASIBVBGXYiCzoAACAJIAdBCGsgDHFqQQhqIAs6AAAMAAsACwALAAsQgQEAC0EACxogCEEwaiQACyAKKAIMIgggHqdxIQMgHkIZiCIfQv8Ag0KBgoSIkKDAgAF+ISAgCigCCCEHAkACQANAIAMgB2opAAAiHiAghSIdQn+FIB1CgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhHQNAIB1QRQRAIAcgHXqnQQN2IANqIAhxQXRsaiIJQQhrKAIAIQsgCUEMaygCACIOIA1GIAQgC0ZxDQMgFyAEIA5BCGogCxASDQMgHUIBfSAdgyEdDAELCyAeQoCBgoSIkKDAgH+DIR0CQAJ/IBtFBEBBACAdUA0BGiADIB16p0EDdmogCHEhEwsgHSAeQgGGg0IAUg0BQQELIRsgAyAcQQhqIhxqIAhxIQMMAQsLIAcgE2osAAAiA0EATgRAIAcgBykDAEKAgYKEiJCgwIB/g3qnQQN2IhNqLQAAIQMLIAcgE2ogH6dB/wBxIgk6AAAgByATQQhrIAhxakEIaiAJOgAAIAogCigCECADQQFxazYCECAKIAooAhRBAWo2AhQgByATQXRsaiIDQQxrIA02AgAgA0EIayAENgIAIANBBGsgAjYCAAwBCyAJQQRrIAI2AgAgBkE4ahCVAQsgDSANKAIAIgNBAWo2AgAgA0EASA0DIApBQGsgDSAEENUBIAogBCAKKAJQakEEajYCUCAYIBgoAgBBAWo2AgAgBkEwahCVAQwFC0GMrMIAQSsgBkHPAGpB1M7CAEHkzsIAEDoAC0HQ28IAQSNBoNjAABA1AAsQHQsACyAGQQhqIAhB6LXCABDkASAGKAIMIQMgBigCCEFAa0EAIAYQ1QEgAyADKAIAQQFqNgIACyACQQBIDQELQQEhByAGIAJBAXQiBDYC", + "QCAGQQA2AjwgBkEEOgA4IAZBMGogASAGQThqEOcBIAYoAjQhAiAGKAIwIgMEQCAAIAM2AgQMAwsgBkE4aiABIAUQ6AEgBigCQCEDIAYoAjwhBSAGKAI4QQFGBEAgACAFNgIEIAMhAgwDCyAGIARBAXI2AkAgBkEANgI8IAZBBDoAOCAGQTBqIAEgBkE4ahDnASAGKAI0IQQCfyAGKAIwIgcEQCAAIAc2AgRBAQwBCyABIAIgBRDpASIFBEAgACAFNgIEDAMLIAEgAyAEEOkBIgEEQCAAIAE2AgQMAwsgACACNgIEQQALIQcgBCECDAILIABB+LXCADYCBEEBIQdBHSECDAELQQEhB0EiIQILIAAgBzYCACAAIAI2AgggBkHQAGokAAsNACAAIAEgAkEIEIIIC7UCAQZ/IwBBIGsiBCQAIARBGGogAUEIaiIFQYi0wgAQ5gEgBCgCGCgCPCEIIAQoAhwiAyADKAIAQQFrNgIAQQMhA0EQIQYCQAJAAkAgAi0AAEEBaw4CAQACC0ECIQNBDCEGCyACIAZqKAIAIAN0IQcLIARBEGogBUGYtMIAEOQBIAQoAhAiAyADKAJQIAdqNgJQIAQoAhQiAyADKAIAQQFqNgIAIARBCGogBUGotMIAEOQBIAQoAgwhAyAEKAIIIgUoAjwiBiAFKAI0RgRAIAVBNGoQwQELIAUgBkEBajYCPCAFKAI4IAZBFGxqIgUgAikCADcCACAFIAIpAgg3AgggBSACKAIQNgIQIAMgAygCAEEBajYCACAAIAEQ6gEiATYCACAAQSIgCCABGzYCBCAEQSBqJAALhR0BCX8jAEFAaiIDJAACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEEIAIoAggiBkECayAGQQFNG0EBaw4HAAECAwQFCAYLIAMgAigCDDYCJCADQQA2AiAgA0EAOgAcIANBMGogASADQRxqEOcBIAMoAjAhASAAIAMoAjQiAjYCCCAAIAEgAiABGzYCBCAAIAFBAEc2", + "AgAMCwsCQCACKAIUIgYEQCACKAIQIQIgAyAGQQRBCBAHIANBADYCOCADIAMpAwA3AjAgA0EwaiAGEJYBIAYgAygCOCIEaiEFIAMoAjQgBEEDdGohBANAIAQgAikCADcCACACQQhqIQIgBEEIaiEEIAZBAWsiBg0ACyADIAMpAjA3AiQgAyAFNgIsIANBADYCICADQQE6ABwMAQsgA0EFOgAcCyADQTBqIAEgA0EcahDnASADKAIwIQEgACADKAI0IgI2AgggACABIAIgARs2AgQgACABQQBHNgIADAoLIANBAzoAHCADIAIvAQw7AR4gA0EANgIgIANBMGogASADQRxqEOcBIAMoAjAhASAAIAMoAjQiAjYCCCAAIAEgAiABGzYCBCAAIAFBAEc2AgAMCQsCQAJAIAIoAhQiBCAGQQFxRSIGckUgAigCDCIFQQFGcUUEQCAGDQEgAigCECEIIAQgBUcNAiAAIAEgCCAEEPQBDAsLIAIoAhAhBCACLQAYIQIgA0EANgIoIANCgICAgMAANwIgIAMgAkEBczoAHSADQQI6ABwgA0EwaiABIANBHGoQ5wEgAygCNCECIAMoAjAiBQRAIAAgAjYCCCAAIAU2AgQgAEEBNgIADAsLIANBHGogASAEEOgBIAMoAiQhBSADKAIgIQYgAygCHEEBRgRAIAAgBTYCCCAAIAY2AgQgAEEBNgIADAsLIANBHGogARD1ASADKAIgIQQgAygCHCIHBEAgACAENgIIIAAgBzYCBCAAQQE2AgAMCwsgASACIAYQ6QEiBgRAIABBIjYCCCAAIAY2AgQgAEEBNgIADAsLIAEgAiAEEOkBIgYEQCAAQSI2AgggACAGNgIEIABBATYCAAwLCyABIAUgBBDpASIBBEAgAEEiNgIIIAAgATYCBCAAQQE2AgAMCwsgACAENgIIIAAgAjYCBCAAQQA2AgAMCgsgAi0AGCEFIAIoAhAhAgJAAkACQCAEDgIAAQILIAItAB1FBEAgA0EANgIoIANC", + "gICAgMAANwIgIAMgBUEBczoAHSADQQI6ABwgA0EwaiABIANBHGoQ5wEgAygCNCEEIAMoAjAiBQRAIAAgBDYCCCAAIAU2AgQgAEEBNgIADA0LIANBHGogASACEOgBIAMoAiQhAiADKAIgIQUgAygCHEEBRgRAIAAgAjYCCCAAIAU2AgQgAEEBNgIADA0LIAEgBCAFEOkBIgUEQCAAQSI2AgggACAFNgIEIABBATYCAAwNCyABIAIgBBDpASIBBEAgAEEiNgIIIAAgATYCBCAAQQE2AgAMDQsgACAENgIIIAAgBDYCBCAAQQA2AgAMDAsgA0EcaiIHIAEgAhDoASADKAIkIQQgAygCICEGIAMoAhwNCiADQQA2AiggA0KAgICAwAA3AiAgAyAFQQFzIgU6AB0gA0ECOgAcIANBMGogASAHEOcBIAMoAjQhAiADKAIwIgcEQCAAIAI2AgggACAHNgIEIABBATYCAAwMCyABIAQgAhDpASIEBEAgAEEiNgIIIAAgBDYCBCAAQQE2AgAMDAsgASACIAYQ6QEiBARAIABBIjYCCCAAIAQ2AgQgAEEBNgIADAwLIANBADYCKCADQoCAgIDAADcCICADIAU6AB0gA0ECOgAcIANBMGogASADQRxqEOcBIAMoAjQhBCADKAIwIgUEQCAAIAQ2AgggACAFNgIEIABBATYCAAwMCyADQRxqIAEQ9QEgAygCICEFIAMoAhwiBwRAIAAgBTYCCCAAIAc2AgQgAEEBNgIADAwLIAEgBCAGEOkBIgYEQCAAQSI2AgggACAGNgIEIABBATYCAAwMCyABIAQgBRDpASIGBEAgAEEiNgIIIAAgBjYCBCAAQQE2AgAMDAsgASACIAUQ6QEiAQRAIABBIjYCCCAAIAE2AgQgAEEBNgIADAwLIAAgBTYCCCAAIAQ2AgQgAEEANgIADAsLIANBHGoiByABIAIQ6AEgAygCJCEGIAMoAiAhBCADKAIcDQggA0EANgIoIANCgICAgMAANwIgIAMg", + "BUEBczoAHSADQQI6ABwgA0EwaiABIAcQ5wEgAygCNCECIAMoAjAiBQRAIAAgAjYCCCAAIAU2AgQgAEEBNgIADAsLIAEgBiACEOkBIgUEQCAAQSI2AgggACAFNgIEIABBATYCAAwLCyABIAIgBBDpASIBBEAgAEEiNgIIIAAgATYCBCAAQQE2AgAMCwsgACACNgIIIAAgBDYCBCAAQQA2AgAMCgsgA0EcaiIIIAEgAiAEQQFrEPQBIAMoAiQhBiADKAIgIQcgAygCHA0GIAggASACEOgBIAMoAiQhCCADKAIgIQQgAygCHEEBRgRAIAAgCDYCCCAAIAQ2AgQgAEEBNgIADAoLIANBADYCKCADQoCAgIDAADcCICADIAVBAXM6AB0gA0ECOgAcIANBMGogASADQRxqEOcBIAMoAjQhAiADKAIwIgUEQCAAIAI2AgggACAFNgIEIABBATYCAAwKCyABIAYgBBDpASIFBEAgAEEiNgIIIAAgBTYCBCAAQQE2AgAMCgsgASAIIAIQ6QEiBQRAIABBIjYCCCAAIAU2AgQgAEEBNgIADAoLIAEgAiAEEOkBIgEEQCAAQSI2AgggACABNgIEIABBATYCAAwKCyAAIAI2AgggACAHNgIEIABBADYCAAwJCyACLQAYIANBHGogASAIIAQQ9AEgAygCJCECIAMoAiAhCiADKAIcQQFGBEAgACACNgIIIAAgCjYCBCAAQQE2AgAMCQsgA0EcaiABEPUBIAMoAiAhByADKAIcIgYNAyAFIARrIgRBACAEIAVNG0EBaiEGQQFzIQsDQAJAIAZBAWsiBgRAIANBADYCKCADQoCAgIDAADcCICADIAs6AB0gA0ECOgAcIANBMGogASADQRxqEOcBIAMoAjQhBSADKAIwIgRFDQEgACAFNgIIIAAgBDYCBCAAQQE2AgAMCwsgASACIAcQ6QEiAQRAIABBIjYCCCAAIAE2AgQgAEEBNgIADAsLIAAgBzYCCCAAIAo2AgQgAEEANgIADAoL", + "IANBHGogASAIEOgBIAMoAiQhBCADKAIgIQkgAygCHEEBRgRAIAAgBDYCCCAAIAk2AgQgAEEBNgIADAoLIAEgAiAFEOkBIgIEQCAAQSI2AgggACACNgIEIABBATYCAAwKCyABIAUgCRDpASICBEAgAEEiNgIIIAAgAjYCBCAAQQE2AgAMCgsgBCECIAEgBSAHEOkBIgRFDQALIABBIjYCCCAAIAQ2AgQgAEEBNgIADAgLIAAgASACKAIQIAIoAhQgAigCGCACKAIMEOUBDAcLIAMgATYCECADIAIoAhAiBDYCCCADIAQgAigCFEEFdGo2AgwgA0EcaiADQQhqEPYBIAMoAhwiAkECRg0AIAMoAiQhBCADKAIgIQYgAkEBcQRAIAAgBDYCCCAAIAY2AgQgAEEBNgIADAcLIAMgAygCEDYCOCADIAMpAgg3AzADQCADQRxqIANBMGoQ9gECQCADKAIcIgdBAkcEQCADKAIkIQUgAygCICECIAAgB0EBcQR/IAUFIAEgBCACEOkBIgJFDQJBIgs2AgggACACNgIEIABBATYCAAwJCyAAIAQ2AgggACAGNgIEIABBADYCAAwICyAFIQQMAAsACyAAIAEQ9wEMBQsgACAHNgIIIAAgBjYCBCAAQQE2AgAMBAsgAyABNgIQIAMgAigCECIENgIIIAMgBCACKAIUQQV0ajYCDCADQTBqIANBCGoiBxD2AQJAAkACQAJ/IAMoAjAiBUECRwRAQQEhBiADKAI4IQIgAygCNCIEIAVBAXENARogA0EcaiAHEPYBIAMoAhwiB0ECRg0CIAMoAiQhBSADKAIgIQggB0EBcUUNBCAAIAg2AgQgBSECDAMLIANBBToAHCADQRRqIAEgA0EcahDnASADKAIUIgFBAEchBiABIAMoAhgiAiABGwshBCAAIAI2AgggACAENgIEIAAgBjYCAAwGCyAAIAQ2AgRBACEGCyAAIAY2AgAgACACNgIIDAQLIANBADYCKCADQoCAgIDAADcCICAD", + "QQI7ARwgA0EwaiABIANBHGoQ5wEgAygCNCEGIAMoAjAiBwRAIAAgBjYCCCAAIAc2AgQgAEEBNgIADAQLIANBHGogARD1ASADKAIgIQcgAygCHCIKBEAgACAHNgIIIAAgCjYCBCAAQQE2AgAMBAsgASAGIAQQ6QEiBARAIABBIjYCCCAAIAQ2AgQgAEEBNgIADAQLIAEgAiAHEOkBIgIEQCAAQSI2AgggACACNgIEIABBATYCAAwECyABIAYgCBDpASICBEAgAEEiNgIIIAAgAjYCBCAAQQE2AgAMBAsgASAFIAcQ6QEiAgRAIABBIjYCCCAAIAI2AgQgAEEBNgIADAQLIAMgAygCEDYCOCADIAMpAgg3AzADQAJAIANBHGogA0EwahD2AQJAIAMoAhwiBEECRwRAIAMoAiQhBSADKAIgIQIgBEEBcUUNASAFIQQMAgsgACAHNgIIIAAgBjYCBCAAQQA2AgAMBgtBIiEEIAEgBiACEOkBIgINACABIAUgBxDpASICRQ0BCwsgACAENgIIIAAgAjYCBCAAQQE2AgAMAwsgACAGNgIIIAAgBzYCBCAAQQE2AgAMAgsgACAGNgIIIAAgBDYCBCAAQQE2AgAMAQsgACAENgIIIAAgBjYCBCAAQQE2AgALIANBQGskAAvQAgEFfyMAQSBrIgMkACADQRhqIABBCGoiB0G4tMIAEOYBIAMoAhgoAlAhBSADKAIcIgQgBCgCAEEBazYCACADQRBqIAdByLTCABDkASADKAIQIgYoAjwiBCABSwRAIAMoAhQhBAJAAkACQCAGKAI4IAFBFGxqIgEtAABBAmsOBQABAQICAQsgASgCDCIGIAEoAgRGBEAgAUEEahDrAQsgASAGQQFqNgIMIAEoAgggBkECdGogAjYCACAFQQRqIQUMAQsgASACNgIECyAEIAQoAgBBAWo2AgAgA0EIaiAHQei0wgAQ5gEgAygCCCgCUCADKAIMIgEgASgCAEEBazYCAEEAIQEgBUcEQCADIAdB", + "+LTCABDkASADKAIAIAU2AlAgAygCBCIBIAEoAgBBAWo2AgAgABDqASEBCyADQSBqJAAgAQ8LIAEgBEHYtMIAECoAC4EBAQV/IwBBEGsiAiQAIAAoAgBBAUYEQCAAKAIEIQEgAkEIaiAAQQhqQdSzwgAQ5gEgAigCCCIAKAJQIQMgACgCSCEEIAAoAjwhACACKAIMIgUgBSgCAEEBazYCAEHks8IAQQAgAyAAQRRsIARBA3RqaiABSxshAQsgAkEQaiQAIAELCwAgAEEEQQQQhggLnwMCCX8BfiMAQRBrIgQkACAAKAIoIAAoAiwQASAAKAI8IQIgACgCOCIDIQEDQCACBEACQAJAAkAgAS0AAEEBaw4CAAECCyABQQhqKAIAIAFBDGooAgAQnwEMAQsgAUEEaigCACABQQhqKAIAECYLIAJBAWshAiABQRRqIQEMAQsLIAAoAjQgA0EEQRQQMCAAKAIMIgYEQCAAKAIIIQMCQCAAKAIUIgVFDQAgA0EIaiEBIAMpAwBCf4VCgIGChIiQoMCAf4MhCiADIQIDQCAFRQ0BA0AgCkIAUkUEQCACQeAAayECIAEpAwBCf4VCgIGChIiQoMCAf4MhCiABQQhqIQEMAQsLIAIgCnqnQQN2QXRsakEMaxCVASAFQQFrIQUgCkIBfSAKgyEKDAALAAsgBEEEakEMQQggBkEBahCHASADIAQoAgxrIAQoAgQhCCAEKAIIEIgBCyAAKAJIIQIgACgCRCIDIQEDQCACBEAgASgCAARAIAEQlQELIAJBAWshAiABQQhqIQEMAQsLIAAoAkAgA0EEQQgQMCAEQRBqJAALCgAgACgCABDuAQtKAQF/IAAgACgCACIBQQFrNgIAIAFBAUYEQCAAQQhqEOwBAkAgAEF/Rg0AIAAgACgCBCIBQQFrNgIEIAFBAUcNACAAQeAAEBkLCwsjACAAIAEoAgAiAEHEAGooAgAgAEHQAGooAgAQ8AEgABDuAQstACAAQQxqIAEgAhDyASAAQTxq", + "IAEgAhDyASAAQQA2AgggAEKAgICAwAA3AgALHgAgACABKAIAIgBBxABqKAIAIABB0ABqKAIAEPABC/UBAgF/AX4jAEHQAGsiAyQAIANBADYCTCADQgQ3AkQgA0IANwI8IANCgICAgMAANwI0IANBNGpBABDzASADQQA2AiwgA0IANwIkIANCgICAgMAANwIcIAMgAygCTDYCGCADIAMpAkQ3AxAgAyADKQI8NwMIIAMgAykCNDcDACADIAEQ8wEgAyACQQF0IgI2AiwgAyACNgIoIAFBAWqtIAKtfiIEQiCIUARAAkAgBKciASADKAIkIgJNBEAgAyABNgIkDAELIANBHGogASACaxCoAQsgACADQTD8CgAAIANB0ABqJAAPC0G4tsIAQSJB3LbCABBiAAsaACAAQQA2AhggACABEL8BIABBDGogARC/AQuOAgEEfyMAQTBrIgQkACAEIAM2AgwgBEEANgIIIAQgAjYCBCAEIAE2AgAgBEEQaiAEEPgBAkAgBCgCECIDQQJHBEAgBCgCGCECIAQoAhQhBSADQQFxBEAgACACNgIIIAAgBTYCBCAAQQE2AgAMAgsgBCAEKQIINwMYIAQgBCkCADcDEANAIARBJGogBEEQahD4AQJAIAQoAiQiB0ECRwRAIAQoAiwhBiAEKAIoIQMgACAHQQFxBH8gBgUgASACIAMQ6QEiA0UNAkEiCzYCCCAAIAM2AgQgAEEBNgIADAQLIAAgAjYCCCAAIAU2AgQgAEEANgIADAMLIAYhAgwACwALIAAgARD3AQsgBEEwaiQACzUBAX8jAEEgayICJAAgAkEAOwEOIAJBADYCECACQQM6AAwgACABIAJBDGoQ5wEgAkEgaiQACzIBAX8gASgCACICIAEoAgRHBEAgASACQSBqNgIAIAAgASgCCCACEOgBDwsgAEECNgIAC0cBAn8jAEEQayICJAAgAkEIaiABEPUBIAIoAgghASAAIAIoAgwiAzYCCCAAIAEgAyABGzYCBCAAIAFB", + "AEc2AgAgAkEQaiQACzUBAX8gASgCCCICIAEoAgxJBEAgASACQQFqNgIIIAAgASgCACABKAIEEOgBDwsgAEECNgIACxkAIAEoAgBBqNfCAEELIAEoAgQoAgwRBAALHgAgAEEwa0EKSSAAQeEAa0EGSXIgAEHBAGtBBklyC9ICAgN/An4jAEEQayIFJAACQAJAAkACQAJAAkACQCACDgIAAQILIABBADoAAUEBIQIMBQsgAS0AACIEQStrDgMCAQIBCyABLQAAIQQLIAEgBEH/AXFBK0YiBGohASACIARrIgJBCU8EQEEAIQQgA60hBwJAA0AgAkUNBCAFQQhqIAEtAAAgAxAWIAUoAgghBiAErSAHfiIIQiCIpw0BIAZBAXFFDQMgAUEBaiEBIAJBAWshAiAFKAIMIgYgCKdqIgQgBk8NAAsgAEECOgABQQEhAgwEC0EBIQIgBkEBcUUNASAAQQI6AAEMAwtBACEEA0AgAkUNAiAFIAEtAAAgAxAWIAUoAgBBAUcNASABQQFqIQEgAkEBayECIAUoAgQgAyAEbGohBAwACwALQQEhAiAAQQE6AAEMAQsgACAENgIEQQAhAgsgACACOgAAIAVBEGokAAtiAQV/IABChICAgMAANwIAIAAoAhAiAQRAAkAgACgCDCIDIAAoAggiACgCCCICRg0AIAFBA3QiBEUNACAAKAIEIgUgAkEDdGogBSADQQN0aiAE/AoAAAsgACABIAJqNgIICwsZAQF/IAEgA08EfyACIAAgAxD6BwVBAQtFC0QAIABBgMADRgRAQf+vAw8LAkAgAEUEQEF/IQAMAQsgAEEBayIAQYCwA3NBgIDEAGtB/4+8f0sNAEH0zsIAEF0ACyAACy0BAX8jAEEQayICJAAgAiAANgIMIAFBxdbCAEEQIAJBDGpBERBKIAJBEGokAAsNACABQbPXwgBBAhArC5gCAQV/IwBBEGsiAiQAQQEhBQJAIAEoAgAiA0Gg28MAQQUgASgCBCIGKAIMIgQRBAAN", + "ACABLQAKQYABcUUEQCADQcOFwQBBAyAEEQQADQEgA0HV1sIAQQMgBBEEAA0BIANByIXBAEECIAQRBAANASAAKAIAIAAoAgQgAyAGEHMNASADQZmGwQBBAiAEEQQAIQUMAQsgA0HKhcEAQQMgBBEEAA0AIAIgBjYCBCACIAM2AgAgAkEBOgAPIAIgAkEPajYCCCACQdXWwgBBAxBNDQAgAkHIhcEAQQIQTQ0AIAAoAgAgACgCBCACQcyGwQAQcw0AIAJBzYXBAEECEE0NACADQYjiwgBBASAEEQQAIQULIAJBEGokACAFCzgBAX8jAEEQayICJAAgAkECNgIMIAIgADYCCCABKAIAIAEoAgRBjJbAACACQQhqEDkgAkEQaiQACxIAIABFBEBB2NbCABBdAAsgAAuxAQECfyMAQRBrIgMkAEHg7cMAQeDtwwAoAgAiBEEBajYCAAJAIARBAEgNAAJAQdjtwwAtAABFBEBB2O3DAEEBOgAAQdTtwwBB1O3DACgCAEEBajYCAEHc7cMAKAIAIgBBAEgNAiAAIABBAWoiAUwNAUHI2cIAQRxB5NnCABBiAAsgA0EIaiAAIAEoAhgRAQAMAQtB3O3DACABQQFrNgIAQdjtwwBBADoAACACRQ0AAAsACwkAIABBADYCAAscACAAQaDYwgApAgA3AgggAEGY2MIAKQIANwIACyUAIAAoAgAtAABFBEAgAUGM5MIAQQUQKw8LIAFB7ezCAEEEECsLbwEDfwJAAkAgACgCACICQQBKBEAgACgCBCIAQQRrKAIAIgFBeHEiA0EEQQggAUEDcSIBGyACakkNASABQQAgAyACQSdqSxsNAiAAED0LDwtBuNjCAEEuQejYwgAQPgALQfjYwgBBLkGo2cIAED4AC0YAIAAoAgBBf0cEQCABKAIAIAAoAgQgACgCCCABKAIEKAIMEQQADwsgASgCACABKAIEIAAoAgwoAgAiACgCACAAKAIEEDkL3AECAn8BfiMAQSBrIgIkACABKAIA", + "QX9GBEAgASgCDCEDIAJBADYCGCACQoCAgIAQNwIQIAJBEGpByNfCACADKAIAIgMoAgAgAygCBBA5GiACIAIoAhgiAzYCCCACIAIpAhAiBDcDACABIAM2AgggASAENwIACyABKAIIIQMgAUEANgIIIAEpAgAhBCABQoCAgIAQNwIAIAIgAzYCGCACIAQ3AxBBDBAbIgFFBEAQHQALIAEgAigCGDYCCCABIAIpAxA3AgAgAEGQ2sIANgIEIAAgATYCACACQSBqJAALjQECAn8BfiMAQSBrIgIkACABKAIAQX9GBEAgASgCDCEDIAJBADYCHCACQoCAgIAQNwIUIAJBFGpByNfCACADKAIAIgMoAgAgAygCBBA5GiACIAIoAhwiAzYCECACIAIpAhQiBDcDCCABIAM2AgggASAENwIACyAAQZDawgA2AgQgACABNgIAIAJBIGokAAscACAAQbDYwgApAgA3AgggAEGo2MIAKQIANwIACw8AIABByNfCACABIAIQOQscACABKAIAIAAoAgAgACgCBCABKAIEKAIMEQQACz4BAn8gASgCBCECIAEoAgAhA0EIEBsiAUUEQBAdAAsgASACNgIEIAEgAzYCACAAQfTZwgA2AgQgACABNgIACxMAIABB9NnCADYCBCAAIAE2AgALDAAgACABKQIANwMAC7oCAQR/QR8hAiAAQgA3AhAgAUGAgIAISQRAIAFBJiABQQh2ZyIDa3ZBAXEgA0EBdHJBPnMhAgsgACACNgIcIAJBAnRBhOrDAGohBEEBIAJ0IgNBoO3DACgCAHFFBEAgBCAANgIAIAAgBDYCGCAAIAA2AgwgACAANgIIQaDtwwBBoO3DACgCACADcjYCAA8LAkACQCABIAQoAgAiAygCBEF4cUYEQCADIQIMAQsgAUEZIAJBAXZrQQAgAkEfRxt0IQUDQCADIAVBHXZBBHFqIgQoAhAiAkUNAiAFQQF0IQUgAiEDIAIoAgRBeHEgAUcNAAsLIAIoAggiASAANgIM", + "IAIgADYCCCAAQQA2AhggACACNgIMIAAgATYCCA8LIARBEGogADYCACAAIAM2AhggACAANgIMIAAgADYCCAsZACABKAIAQYTawgBBCyABKAIEKAIMEQQAC30BBn8jAEEQayICJAAgASgCECEEIAEoAhQhBSACQQhqIAFBEGoQlQIgACACKAIMIgNBf0YEf0ECBSABKAIQIQYgASgCFCEHIAMgAUECEJYCIAAgAigCCCIDNgIEIAAgAyAGIAdrIAUgBGtqajYCCEEBcws2AgAgAkEQaiQAC3MBBX8jAEEQayICJAAgASgCACEEIAEoAgQhBSACQQhqIAEQwwECQCACKAIIQQFHBEBBfyEDDAELIAIoAgwhAyABIAEoAgAgASgCCCIGIAVqIAQgASgCBGprajYCCAsgACADNgIEIAAgBjYCACACQRBqJAALNgECfyACQQJ0IQIDQCACIgMEQCACQQRrIQIgASgCACEEIAFBBGohASAAIARHDQELCyADQQBHCzgBAX8jAEEQayIDJAAgA0EANgIMIAMgAiADQQxqEJgCIAAgASADKAIAIAMoAgQQ/QEgA0EQaiQACzoAIAEgAhCZAiAAAn9BASABQYABSQ0AGkECIAFBgBBJDQAaQQNBBCABQYCABEkbCzYCBCAAIAI2AgALogEBA38gAEGAAU8EQCAAQT9xQYB/ciEDIABBBnYhAiAAQYAQSQRAIAEgAzoAASABIAJBwAFyOgAADwsgAEEMdiEEIAJBP3FBgH9yIQIgAEH//wNNBEAgASADOgACIAEgAjoAASABIARB4AFyOgAADwsgASADOgADIAEgAjoAAiABIARBP3FBgH9yOgABIAEgAEESdkFwcjoAAA8LIAEgADoAAAsoACADIAQgASACEP0BIQEgACAEIAJrNgIEIAAgAiADakEAIAEbNgIACyUAIAMgBCABIAIQnAIhASAAIAQgAms2AgQgACADQQAgARs2AgALHgEBfyABIANPBH8gAiAAIAEgA2tqIAMQ", + "nQIFQQALCwwAIAAgASACEPoHRQtQAQF/IwBBEGsiAiQAIAJBCGogARCfAiAAIAIoAghBAUcEf0F/BSABKAIIIAEoAgRqIAEoAgBrIQEgAigCDAs2AgQgACABNgIAIAJBEGokAAu/AQEDfyABKAIEIgQgASgCAEYEf0EABSABIARBAWsiAjYCBCACLAAAIgJBAEgEQCABIARBAmsiAzYCBCACQT9xAn8gAy0AACIDwCICQUBOBEAgA0EfcQwBCyABIARBA2siAzYCBCACQT9xAn8gAy0AACIDwCICQUBOBEAgA0EPcQwBCyABIARBBGsiATYCBCACQT9xIAEtAABBB3FBBnRyC0EGdHILQQZ0ciECC0EBCyEBIAAgAjYCBCAAIAE2AgALfAEGfyMAQRBrIgIkACABQQhqIQQgAAJ/A0AgASgCCCEFIAEoAgwhBiACQQhqIAQQlQJBACACKAIMIgdBf0YNARogAigCCCEDIAcQIg0ACyAAIAM2AgQgACABKAIIIAYgBWsgA2pqIAEoAgxrNgIIQQELNgIAIAJBEGokAAufAQEFfyMAQTBrIgQkACAEQQxqIAMgASACEKICIAQoAhAiBSAEKAIYIgZqIQcgBCgCDCEIIAQoAhwhAgJAA0ACQCAEIAc2AiggBCAFIAIiA2o2AiwgBCAEQShqEJ8CIAQoAgBBAUcNACAEKAIsIAQoAihrIAZqIQIgBCgCBCAIRg0BDAILC0EAIQMLIAAgAzYCBCAAIAE2AgAgBEEwaiQAC2IBAn8jAEEQayIEJAAgBEEANgIMIAQgASAEQQxqEJgCIAQoAgQhBSAAIAM2AhAgAEEANgIMIAAgAzYCCCAAIAI2AgQgACAFOgAYIAAgATYCACAAIAQoAgw2AhQgBEEQaiQAC4QBAQF/IwBBMGsiBCQAIARBADYCICAEIAEgAmo2AhwgBCABNgIYIAQgAjYCFCAEIAE2AhAgBCADNwMIIAAgAgJ/AkADQAJAIARBJGogBEEIahCUAiAEKAIk", + "QQFrDgIAAgELCyAEKAIoDAELIAILIgJrNgIEIAAgASACajYCACAEQTBqJAALZQEBfyMAQSBrIgMkACADQQA2AhAgAyABNgIIIAMgATYCACADIAI2AgQgAyABIAJqNgIMIANBFGogAxCgAiAAIAIgAygCGCACIAMoAhQbIgJrNgIEIAAgASACajYCACADQSBqJAALpQEBBn8jAEEwayIEJAAgBEEMaiADIAEgAhCiAiAEKAIQIgYgBCgCHCIHaiEIIAQoAgwhCSAEKAIYIQMCQANAAkAgBCAINgIsIAQgBiADIgVqNgIoIAQgBEEoahDDASAEKAIAQQFHDQAgBCgCKCAEKAIsayAHaiEDIAQoAgQgCUYNAQwCCwsgAiEFCyAAIAIgBWs2AgQgACABIAVqNgIAIARBMGokAAs4AQF/IwBBEGsiAyQAIANBADYCDCADIAIgA0EMahCYAiAAIAEgAygCACADKAIEEJwCIANBEGokAAv4BwIHfwF+IwBBMGsiBSQAAkACQCACBEACQAJAIAStIAJBDGxBDGsiAkEMbq1+IgxCIIinDQAgASgCCCIIIAynaiIKIAhJDQAgASgCBCEJIAIhByABQQxqIgEhBgNAIAdFDQIgB0EMayEHIAYoAgghCyAGQQxqIQYgCiALaiIKIAtPDQALC0Gk3MIAQTVB3NzCABBiAAsgBUEIaiAKQQFBARAHIAVBADYCHCAFIAUpAwg3AhQgBUEUaiAJIAggCWoQqAIgCiAFKAIcIgZrIQcgBSgCGCAGaiEGAkACQAJAAkACQAJAIAQOBQABAgMEBQsDQCACRQ0HIAEoAgQhAyAFQSBqIAYgByABKAIIIgQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgAyAEEKoCIAJBDGshAiABQQxqIQEMAAsACwNAIAJFDQYgASgCBCEIIAEoAgghBCAFQSBqIgkgBiAHQQEQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgA0EBEKoCIAkgBiAH", + "IAQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgCCAEEKoCIAJBDGshAiABQQxqIQEMAAsACwNAIAJFDQUgASgCBCEIIAEoAgghBCAFQSBqIgkgBiAHQQIQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgA0ECEKoCIAkgBiAHIAQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgCCAEEKoCIAJBDGshAiABQQxqIQEMAAsACwNAIAJFDQQgASgCBCEIIAEoAgghBCAFQSBqIgkgBiAHQQMQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgA0EDEKoCIAkgBiAHIAQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgCCAEEKoCIAJBDGshAiABQQxqIQEMAAsACwNAIAJFDQMgASgCBCEIIAEoAgghBCAFQSBqIgkgBiAHQQQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgA0EEEKoCIAkgBiAHIAQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgCCAEEKoCIAJBDGshAiABQQxqIQEMAAsACwNAIAJFDQIgASgCBCEJIAEoAgghCCAFQSBqIgsgBiAHIAQQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgAyAEEKoCIAsgBiAHIAgQqQIgBSgCLCEHIAUoAighBiAFKAIgIAUoAiQgCSAIEKoCIAJBDGshAiABQQxqIQEMAAsACyAAQQA2AgggAEKAgICAEDcCAAwBCyAAIAUpAhQ3AgAgACAKIAdrNgIICyAFQTBqJAALDQAgACABIAIgAWsQCgs7ACACIANJBEBBwevCAEETQZTcwgAQNQALIAAgAzYCBCAAIAE2AgAgACACIANrNgIMIAAgASADajYCCAsmACABIANGBEAgAQRAIAAgAiAB/AoAAAsPCyABIANBlNzCABByAAvXCgMNfwJ8An4jAEGAAWsiBiQAIAZB4ABqIREgBkHQAGoh", + "EiABKAIIIQ4gASgCBCEPIABBCGohCyAAQQRqIQxBACEBAn8DQCADIAVJIAEgA0cgASAFR3FFDQEaIAIgAyABQYSvwwAQISgCACEJIAQgBSABQZSvwwAQISgCACENIAZBCGogDCgCACALKAIAIAkQrAIiB0EcaigCACAHQSBqKAIAEEIgBkEYaiAMKAIAIAsoAgAgDRCsAiIHQRxqKAIAIAdBIGooAgAQQiAGKAIMIgcgBigCEEHE8sIAQQIQ/QFFBEAgBkFAayAAIAkQrQIgBigCCCAHEAEgBiAGKAJINgIQIAYgBikCQDcDCAsgBigCHCIHIAYoAiBBxPLCAEECEP0BRQRAIAZBQGsgACANEK0CIAYoAhggBxABIAYgBigCSDYCICAGIAYpAkA3AxgLIAZBKGogDCgCACALKAIAIAkQrAIiB0EoaigCACAHQSxqKAIAEEIgBkE0aiAMKAIAIAsoAgAgDRCsAiIHQShqKAIAIAdBLGooAgAQQkEAIQggBigCDCIKIAYoAhAiB0H4rsMAQQsQEgRAIAYoAhwgBigCIEH4rsMAQQsQEiEICwJAIAogB0Hj38IAQQUQEkUNACAPIA4QrgJFDQAgBkFAayIQIA8gDiAGKAIsIAYoAjAQrwIgBigCQCAQELACQX9GBEBBACEIDAELIAZBQGsiECAPIA4gBigCOCAGKAI8EK8CIAYoAkBBf0chCCAQELACCwJAAkAgCiAHQaXgwgBBBhASBEAgBigCHCAGKAIgQaXgwgBBBhCxAg0BCwJAIAogB0Gl4MIAQQYQsQIEQCAGKAIcIAYoAiBBpeDCAEEGEBINAQsgCiAHQYbkwgBBBhASIhAEQCAGKAIcIAYoAiBBhuTCAEEGELECDQILIAogB0GG5MIAQQYQsQIEQCAGKAIcIAYoAiBBhuTCAEEGEBINAQsCQAJAIBAEQCAGKAIcIAYoAiBBhuTCAEEGEBINAQsCQAJ/AkACQAJAIAhFBEACQCAKIAdBnN/CAEEFEBJFDQAg", + "BigCHCAGKAIgQZzfwgBBBRASRQ0AIAZBQGsgBigCLCAGKAIwELICIBIgBigCOCAGKAI8ELICIAYoAkAEQCAGKAJQDQMLIAZBQGsQswILIAogBxC0Ag0CIAYoAjAhByAGKAIsIQkMBwsgBkFAayAPIA4gBigCLCIHIAYoAjAiCRCvAiARIA8gDiAGKAI4Ig0gBigCPCIIEK8CIAYoAkBBf0cEQCAGKAJgQX9HDQMLIAcgCSANIAgQ4AEMAwsgBikDSCIVIAYpA1giFlUgFSAWU2shByAGQUBrELMCDAgLIAYoAjAhByAGKAIsIQkgBigCHCAGKAIgELQCRQ0EIAZBQGsgCSAHELUCIBIgBigCOCAGKAI8ELUCAkAgBigCQEUEQCAGKAJQRQ0BCyAGQUBrELYCDAULIAYrA1ghEyAGKwNIIRQgBkFAaxC2AiAUIBRiIBMgE2JyDQJBAEF/IBMgFGUiBxtBAUF+IAcbIBMgFGYbIQcMBwsgBkFAayARELcCCyEHIAZBQGsQsAIgERCwAgwFC0EAIQcMBAsgDCgCACALKAIAIAkQrAIQuAIgDCgCACALKAIAIA0QrAIQuAJrIQcMAwsgCSAHIAYoAjggBigCPBDgASEHDAILQQEhBwwBC0H/ASEHCyAGKAI0IAYoAjgQASAGKAIoIAYoAiwQASAGKAIYIAYoAhwQASAGKAIIIAoQASABQQFqIQEgB0H/AXEiCEUNAAsgCEH/AUYLIAZBgAFqJAALEAAgACABIAJBiPPCABC5Agv5AQEFfyMAQSBrIgMkAAJAAkAgASgCBCABKAIIIAJByPLCABC5AiIEQRxqKAIAIgUgBEEgaigCACIGQcTywgBBAhD9AQ0AIARBLGooAgAiB0UNACADQQhqIARBKGooAgAgBxBCIANBFGogASADKAIMIgQgAygCEBC6AgJAIAMoAhQiBUF/RwRAIAEoAgQgASgCCCACQejywgAQuQIhASADKAIYIQIMAQsgASgCBCABKAIIIAMoAhgi", + "AkHY8sIAELkCIQELIAAgAUEcaigCACABQSBqKAIAEEIgAygCCCAEEAEgBSACEAUMAQsgACAFIAYQQgsgA0EgaiQACxIAIAAgAUGs4sIAQRkQEkEBcwtIACAAIAEgAiADIAQQuwICQCAAKAIAQX9HDQAgASACQaziwgBBGRASRQ0AIAAoAgQgACgCCCAAQfzCwwBBCiADIAQQuwIQAQsLGQAgACgCAEF/RgRAIAAoAgQgACgCCBABCwsfAQF/QQEhBCABIANGBH8gACACIAEQ+gdBAEcFQQELC/sHAgd/AX4jAEGgAWsiAyQAIAMgAjYCQCADIAE2AjwCQCABIAJB3wAQvQJFBEAgA0HEAGogASACEAYMAQsgA0HEAGogASACQd8AQQFBABC+AgsgAygCSCEFQQEhBwJAIAMoAkwiBEUEQCAFIQEgBCECDAELQbCbwwAhCEGgm8MAIQkgBCECAkACQCAFIgEtAABBK2sOAwECAAILQcCXwwAhCEG0m8MAIQkLQQEhBiADQTBqQQEgBSAEIAkQvwIgAygCNCECIAMoAjAhASAIIQcLIAMgBjYCVCADIAc2AlAgA0EoakHEm8MAQQIgASACEJoCAn8gAygCKCIGBEAgAygCLAwBCyADQSBqQYjfwgBBAiABIAIQmgIgAygCICEGIAMoAiQLIQcCQCAGBEAgAyAGNgJYIAMgBzYCXCADQQI2ApwBIANBAjYClAEgAyADQdgAajYCmAEgAyADQdAAajYCkAEgA0H0AGpBgIDAACADQZABahAMIANBgAFqIAMoAngiASADKAJ8QRAQwAIgAAJ/IAMtAIABBEAgA0HgAGpBBHIgA0E8ahDBAiADKAJkIQIgACADKQNoNwMIIAMoAnQgARABQQAMAQsgAykDiAEhCiADKAJ0IAEQASAAIAo3AwhBBCECQfCawwALNgIAIAAgAjYCBAwBCyADQRhqQcabwwBBAiABIAIQmgIgAygCGCIBBEAgAygCHCECIAMgATYCWCADIAI2", + "AlwgA0ECNgKcASADQQI2ApQBIAMgA0HYAGo2ApgBIAMgA0HQAGo2ApABIANB9ABqQYCAwAAgA0GQAWoQDCADQYABaiADKAJ4IgEgAygCfEEIEMACIAACfyADLQCAAQRAIANB4ABqQQRyIANBPGoQwQIgAygCZCECIAAgAykDaDcDCCADKAJ0IAEQAUEADAELIAMpA4gBIQogAygCdCABEAEgACAKNwMIQQQhAkH0msMACzYCACAAIAI2AgQMAQsgA0EQaiAFIARBKxAeAkAgAygCFCAEIAMoAhAiARsiBARAIANBCGogASAFIAEbIgcgBEEtEKUCIAMoAgwhASADKAIIIQIDQCABRQ0CIAFBAWshASACLQAAIAJBAWohAkE6a0H/AXFB9QFLDQALCyAAQQRqIANBPGoQwQIgAEEANgIADAELIANBkAFqIAcgBBDCAiADLQCQAUEBRgRAIANBAjYCZCADIANBPGo2AmAgA0GAAWpBBHJB+MPAACADQeAAahAMIAMoAoQBIQEgACADKQOIATcDCCAAIAE2AgQgAEEANgIADAELIAAgAykDmAE3AwggAEECNgIEIABByJvDADYCAAsgAygCRCAFEAEgA0GgAWokAAsPACAAEMMCIABBEGoQwwILKAEBf0EBIQIgACABQZzfwgBBBRASBH9BAQUgACABQaHfwgBBBxASCwuIBAIGfwF8IwBBQGoiAyQAIAMgAjYCDCADIAE2AgggA0EQaiABIAJB3wBBAUEAEL4CIANBHGogAygCFCIGIAMoAhgiBxC8AiADIAMoAiAiAiADKAIkIgVBKxClAkQAAAAAAADwfyEJAkACQAJAIAMoAgAiASADKAIEIgRB+JrDAEEDEBINACABIARB+5rDAEEIEBINACABIARBg5vDAEEEEBINAEQAAAAAAADw/yEJIAEgBEGHm8MAQQQQEg0AIAEgBEGLm8MAQQkQEg0AIAEgBEGUm8MAQQUQEg0ARAAAAAAAAPh/IQkgASAEQZmbwwBB", + "AxASDQAgASAEQZybwwBBBBASDQAgBUUNASACIQEDQAJAAkAgBQRAIAEtAAAiBEEwa0H/AXFBCkkNAiAEQStrIghBA0sgCEEBRnINAQwCCyADQShqIAYgBxB6QQEhAQJAIAMtAChBAUYEQCADQQI2AjwgAyADQQhqNgI4IABBBGpB9pbAACADQThqEAwMAQsgACADKwMwOQMIQQAhAQsgACABNgIADAULIARB5QBHDQMLIAFBAWohASAFQQFrIQUMAAsACyAAQQA2AgAgACAJOQMIDAELIANBAjYCLCADIANBCGo2AiggAEEEakH2lsAAIANBKGoQDCAAQQE2AgALIAMoAhwgAhABIAMoAhAgBhABIANBQGskAAsPACAAEMQCIABBEGoQxAILswECAn8CfiAAKQMQIgQgASkDECIFUgRAIAQgBVUgBCAFU2sPCyAAKAIYIgMgASgCGCICRwRAIAIgA0kgAiADS2sPCwJAIAAoAhwiAyABKAIcIgJHDQAgACgCACIDIAEoAgAiAkcNAEEAIQICQCADQQJHDQAgAEEIakEIIAFBCGpBCBDgASICQf8BcQ0AIAAoAgQiACABKAIEIgFLIAAgAUlrIQILIAIPCyACIANIIAIgA0prC7UBAQR/IwBBEGsiASQAAkAgACgCHCICIAAoAiAiBEGl4MIAQQYQEg0AQQEhAyAALQCaAUECRw0AIAIgBEGG5MIAQQYQEkUNACABQQRqIAAoAiggACgCLBC8AgJAIAEoAggiACABKAIMIgJB45vDAEEBEBINACAAIAJB5JvDAEEDEBINACAAIAJB55vDAEECEBINACAAIAJB7ezCAEEEEBIhAwsgASgCBCAAEAELIAFBEGokACADCxAAIAAgASACIANBnAEQhAgLswUBC38jAEGwBmsiBCQAAkAgAwRAIARB/ARqIQUgBEEIaiIGIAIgAxDbAiAEKAIUIQkgBCgCECEHIAQoAgwhCiAEKAIIIQsgBiABIAQoAhgiDCAEKAIcENwC", + "IARB+ARqIAYQ3QICQAJAAkAgBCgC+AQEQCAAIAUoAgg2AgggACAFKQIANwIADAELIAQgBSgCCCIGNgLwBCAEIAUpAgA3A+gEAkAgBkUEQCAHRQ0BIARBlAVqIgVBpeDCAEEGQQFBABDeAiAEQegEaiABIAUQ3wIQ4AIgBCgC8ARFDQELIAEoAgQgASgCCCAEKALsBCgCACIFEKwCLQCaASEIIAEoAgQgASgCCCAFEOECIgZB1ABByAAgCEECRiIIG2oiDSgCACAGQdgAQcwAIAgbaiIOKAIAEAEgDSALNgIAIA4gCjYCACAGQdwAQdAAIAgbaiAHNgIAIAEoAgQgASgCCCAFEKwCIgdBHGooAgAgB0EgaigCAEHj38IAQQUQEg0CIAEoAgQgASgCCCAFEOECQgA3ApABIABBfzYCACAAIAU2AgQMAwsgAEHNs8MAQQMQBiAEKALoBCAEKALsBBAmCyAEQQhqEOICIAkgDBABIAsgChABDAMLIARBiAVqIAEoAgQgASgCCCAFEKwCIgVB2ABqKAIAIAVB3ABqKAIAEEIgBEGUBWoiBUHj38IAQQUgAiADEN4CIAEgBRDfAiECIAEoAgQgASgCCCACEOECIgEoAlQgAUHYAGooAgAQASABIAQoApAFNgJcIAEgBCkCiAU3AlQgACACNgIEIABBfzYCAAsgBCgC6AQgBCgC7AQQJiAEQQhqEOICIAkgDBABDAELIARBCGoiAkGl4MIAQQZBAUEAEN4CIAEgAhDfAiEBIABBfzYCACAAIAE2AgQLIARBsAZqJAALmCQCCn8IfiMAQdABayIFJAAgBSACNgJQIAUgATYCTCAFIAQ2AlggBSADNgJUIAVB3ABqIAEgAhDMAiAFQegAaiIJIAMgAyAEahAgIAVBADYCdCAFIAI2AogBIAUgATYChAEgBSAENgKAASAFIAM2AnwgBSAFQc8BajYCjAEgBSAJNgJ4QQIhCUIBIREgBSgCZCEMQQAhBEIBIQ9CASESAkADQAJA", + "AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkAgBiAMTwRAIAUoAnQiASAFKAJwIgJHDQEgCUECRg0mAkAgEEIMVwRAIAlBAXENASAQQgAgEEIMUhshEAwoCyAFQQI2ApQBIAUgBUHUAGo2ApABIAVBsAFqQavDwAAgBUGQAWoQDCAAIAUoArgBNgIMIAAgBSkCsAE3AgQgAEF/NgIADCkLQgwgEEIMfCAQQgxRGyEQDCYLIAZBAWohASAFKAJgIgggBkEDdGoiAygCBCECIAMoAgAiA0EBaw4eFRQRECIhDw4fDR4dCgkIBQQDAhwcARkZGRgYGBcWIwsgBUFAayAFKAJsIAIgAUGox8MAEM0CIAVBpAFqIgEgBSgCQCICIAIgBSgCREECdGoQJSAFQQM2AsQBIAVBAjYCvAEgBUECNgK0ASAFIAE2AsABIAUgBUHMAGo2ArgBIAUgBUHUAGo2ArABIAVBkAFqQcTTwAAgBUGwAWoQDCAAIAUoApgBNgIMIAAgBSkCkAE3AgQgAEF/NgIAIAUoAqQBIAUoAqgBEAEMJgsgBSgCdCIDIQYDQAJAAkAgBSgCcCIEIAZLBEAgBSgCbCAEIAZBoMvDABAhKAIAQcEAa0EaSQ0BCyAFIAY2AnQgBiADa0EDSQ0BIAVBKGogBSgCbCAFKAJwIAMgBkGwy8MAECQgBUGwAWogBSgCKCICIAIgBSgCLEECdGoQJUEAIQdBACEEIAUoArQBIgMgBSgCuAEiAkHrt8MAQQMQEkUEQCAFQgA3A5ABIAVBkAFqIQRBCCACIAJBCE8bIgshAgJAIAIEQCAEIAMgAvwKAAALDAALIAUpA5ABIRZBAiEECyAFKAKwASADEAEMHAsgBkEBaiEGDAELCyAFQbABaiAFQfgAaiADQRYgAhDOAiAAQX82AgAgACAFKAK4ATYCDCAAIAUpArABNwIEDCUL", + "IAVBsAFqIAUoAmwgBSgCcCAFQfQAakEBQQIQzwIgBSgCsAFFBEAgBUGQAWpBBHIgBUH4AGogBSgCdEETIAIQzgIgBSgClAEhASAAIAUpA5gBNwMIIAAgATYCBCAAQX82AgAMJQsgBSkDuAEhEwwhCyAFQbABaiAFKAJsIAUoAnAgBUH0AGpBAkECEM8CIAUoArABRQRAIAVBkAFqQQRyIAVB+ABqIAUoAnRBEiACEM4CIAUoApQBIQEgACAFKQOYATcDCCAAIAE2AgQgAEF/NgIADCQLIAUpA7gBIRMgASAMSQRAIAggASIGQQN0aigCAEEcSw0jCyABIQYgBSgCdCICIAUoAnAiA08NIiAFKAJsIgggAkECdGooAgBBLkcNIiACQQFqIgIgA08NIiAIIAJBAnRqKAIAQTBrQQlLDSIgBSACNgJ0IAggAyAFQfQAahDQAiEKDCALIAVBsAFqIAUoAmwgBSgCcCAFQfQAakEBQQIQzwIgBSgCsAENASAFQZABakEEciAFQfgAaiAFKAJ0QREgAhDOAiAFKAKUASEBIAAgBSkDmAE3AwggACABNgIEIABBfzYCAAwiCyAFQbABaiAFKAJsIAUoAnAgBUH0AGpBAkECEM8CIAUoArABRQ0BCyAFKQO4ASEVDB0LIAVBkAFqQQRyIAVB+ABqIAUoAnRBECACEM4CIAUoApQBIQEgACAFKQOYATcDCCAAIAE2AgQgAEF/NgIADB8LIAVBsAFqIAUoAmwgBSgCcCAFQfQAakEBQQIQzwIgBSgCsAENAiAFQZABakEEciAFQfgAaiAFKAJ0QQ8gAhDOAiAFKAKUASEBIAAgBSkDmAE3AwggACABNgIEIABBfzYCAAweCyAFQbABaiAFKAJsIAUoAnAgBUH0AGpBAkECEM8CIAUoArABDQEgBUGQAWpBBHIgBUH4AGogBSgCdEEOIAIQzgIgBSgClAEhASAAIAUpA5gBNwMIIAAgATYCBCAAQX82AgAMHQsgBUGwAWogBSgC", + "bCAFKAJwIAVB9ABqQQFBAhDPAiAFKAKwAUUNAQsgBSkDuAEhEAwYCyAFQZABakEEciAFQfgAaiAFKAJ0QQ0gAhDOAiAFKAKUASEBIAAgBSkDmAE3AwggACABNgIEIABBfzYCAAwaCyAFQbABaiAFKAJsIAUoAnAgBUH0AGpBA0EDEM8CIAUoArABRQRAIAVBkAFqQQRyIAVB+ABqIAUoAnRBCiACEM4CIAUoApQBIQEgACAFKQOYATcDCCAAIAE2AgQgAEF/NgIADBoLIAUpA7gBIRRBASEODBYLIAVBsAFqIAUoAmwgBSgCcCAFQfQAakEBQQIQzwIgBSgCsAENESAFQZABakEEciAFQfgAaiAFKAJ0QQggAhDOAiAFKAKUASEBIAAgBSkDmAE3AwggACABNgIEIABBfzYCAAwYCyAFQbABaiAFKAJsIAUoAnAgBUH0AGpBAkECEM8CIAUoArABDRAgBUGQAWpBBHIgBUH4AGogBSgCdEEHIAIQzgIgBSgClAEhASAAIAUpA5gBNwMIIAAgATYCBCAAQX82AgAMFwsgBUGwAWogBSgCbCAFKAJwIAVB9ABqQQFBAhDPAiAFKAKwAQ0BIAVBkAFqQQRyIAVB+ABqIAUoAnRBBCACEM4CIAUoApQBIQEgACAFKQOYATcDCCAAIAE2AgQgAEF/NgIADBYLIAVBsAFqIAUoAmwgBSgCcCAFQfQAakECQQIQzwIgBSgCsAFFDQELIAUpA7gBIREMEQsgBUGQAWpBBHIgBUH4AGogBSgCdEEDIAIQzgIgBSgClAEhASAAIAUpA5gBNwMIIAAgATYCBCAAQX82AgAMEwsgBUGwAWogBSgCbCAFKAJwIAVB9ABqQQJBAhDPAiAFKAKwAUUEQCAFQZABakEEciAFQfgAaiAFKAJ0QQIgAhDOAiAFKAKUASEBIAAgBSkDmAE3AwggACABNgIEIABBfzYCAAwTCyAFKQO4ASIPQsQAVwRAIA9C0A98IQ8MEAsgD0LsDnwhDwwP", + "CyAFQbABaiAFKAJsIAUoAnAgBUH0AGpBBEEEEM8CIAUoArABRQRAIAVBkAFqQQRyIAVB+ABqIAUoAnRBASACEM4CIAUoApQBIQEgACAFKQOYATcDCCAAIAE2AgQgAEF/NgIADBILIAUpA7gBIQ8MDgsgASEGIAUoAnQiAiAFKAJwIgNPDQ8CQCAFKAJsIgggAkECdGooAgBBLGsOAwAQABALIAJBAWoiAiADTw0PIAggAkECdGooAgBBMGtBCUsNDyAFIAI2AnQgCCADIAVB9ABqENACIQoMDQsCQAJAIAUoAnQiAyAFKAJwIgZPDQAgBSgCbCIKIANBAnRqKAIAQSxrDgMBAAEACyAFQbABaiAFQfgAaiADQR0gAhDOAiAAQX82AgAgACAFKAK4ATYCDCAAIAUpArABNwIEDBALIAUgA0EBaiIDNgJ0IAogBiAFQfQAahDQAiEKIAEhBiAFKAJ0IANrIAJGDQ4gBUGwAWogBUH4AGogA0EdIAIQzgIgAEF/NgIAIAAgBSgCuAE2AgwgACAFKQKwATcCBAwPCyAFQThqIAUoAmwgBSgCcCAFQfQAaiADQRpGIANBHEYQ0QIgBSgCOEEBRgRAIAUoAjwhBwwCCyAFQbABaiAFQfgAaiAFKAJ0IAMgAhDOAiAFKAK0ASEHIAUoArABIgJBf0YNASAAIAUoArgBNgIMIAAgBzYCCCAAIAI2AgQgAEF/NgIADA4LIAUoAmwhBAJAIAUoAnQiBiAFKAJwIgdPDQAgBCAGQQJ0aigCAEHaAEcNAEEBIQ0gBSAGQQFqNgJ0QQAhBEEAIQcMCwsgBUEwaiAEIAcgBUH0AGogA0EXRiADQRlGENECIAUoAjBBAUYEQCAFKAI0IQcMAQsgBUGwAWogBUH4AGogBSgCdCADIAIQzgIgBSgCtAEhByAFKAKwASICQX9GDQAgACAFKAK4ATYCDCAAIAc2AgggACACNgIEIABBfzYCAAwNC0EBIQQLQQEhDQwICyAFQSBqIAUoAmwg", + "BSgCcCAFQfQAakGQy8MAQQIQ0gICQCAFKAIgQQFGBEAgBSgCJCEGDAELIAVBsAFqIAVB+ABqIAUoAnQgAyACEM4CIAUoArQBIQYgBSgCsAEiAkF/Rg0AIAAgBSgCuAE2AgwgACAGNgIIIAAgAjYCBCAAQX82AgAMCwsgBkEBRiEJDAcLIAVBGGogBSgCbCAFKAJwIAVB9ABqQdTKwwBBBxDSAiAFKAIYQQFxDQYgBUGwAWogBUH4AGogBSgCdEEMIAIQzgIgBSgCsAEiAkF/Rg0GIAAgBSkCtAE3AwggACACNgIEIABBfzYCAAwJCyAFQRBqIAUoAmwgBSgCcCAFQfQAakHwycMAQQcQ0gIgBSgCEEEBcQ0FIAVBsAFqIAVB+ABqIAUoAnRBCyACEM4CIAUoArABIgJBf0YNBSAAIAUpArQBNwMIIAAgAjYCBCAAQX82AgAMCAsgBSgCbCEDAkAgBSgCdCIGIAUoAnAiCE8NACADIAZBAnRqKAIAQSBHDQAgBSAGQQFqNgJ0CyAFQbABaiADIAggBUH0AGpBAUECEM8CIAUoArABDQAgBUGQAWpBBHIgBUH4AGogBSgCdEEJIAIQzgIgBSgClAEhASAAIAUpA5gBNwMIIAAgATYCBCAAQX82AgAMBwsgBSkDuAEhEgwDCyAFQQhqIAUoAmwgBSgCcCAFQfQAakH8yMMAQQwQ0gICQCAFKAIIQQFGBEAgBSgCDCEGDAELIAVBsAFqIAVB+ABqIAUoAnRBBiACEM4CIAUoArQBIQYgBSgCsAEiAkF/Rg0AIAAgBSgCuAE2AgwgACAGNgIIIAAgAjYCBCAAQX82AgAMBgsgBq1CAXwhEQwCCyAFIAUoAmwgBSgCcCAFQfQAakHcx8MAQQwQ0gICQCAFKAIAQQFGBEAgBSgCBCEGDAELIAVBsAFqIAVB+ABqIAUoAnRBBSACEM4CIAUoArQBIQYgBSgCsAEiAkF/Rg0AIAAgBSgCuAE2AgwgACAGNgIIIAAgAjYCBCAA", + "QX82AgAMBQsgBq1CAXwhEQwBCwJAIAUoAnQiAyAFKAJwSQRAIAUoAmwgA0ECdGooAgAgAkYNAQsgBUGwAWogBUH4AGogA0EAIAIQzgIgAEF/NgIAIAAgBSgCuAE2AgwgACAFKQKwATcCBAwECyAFIANBAWo2AnQLIAEhBgwBCwsgDgRAIAVBsAFqIA9CAUIBENMCIBR8QgF9ENQCIAUpA8ABIRIgBSkDuAEhESAFKQOwASEPCyARQgF9QgxaBEAgBUECNgKUASAFIAVB1ABqNgKQASAFQbABakHRw8AAIAVBkAFqEAwgACAFKAK4ATYCDCAAIAUpArABNwIEIABBfzYCAAwBCwJAIBJCAFcNAAJ+AkAgEUIBfSIUQgxaDQBB/R8gFKciAXZBAXFFDQAgATEAsN1DDAELQh1CHUIcIA9C5ACBQgBSG0IcIA9CA4NQGyAPQpADgVAbCyASVA0AIBBCF1UgFUI7VXIgE0I7VXJFBEAgACAKNgIYIAAgFjcDCCAAIAs2AgQgACAENgIAIAAgB0EAIA0bIgE2AhwgACATIAGsfSAVQjx+fCAQQpAcfnwgDyARIBIQ0wJCgKMFfnw3AxAMAgsgBUECNgKUASAFIAVB1ABqNgKQASAFQbABakGrw8AAIAVBkAFqEAwgACAFKAK4ATYCDCAAIAUpArABNwIEIABBfzYCAAwBCyAFQQI2ApQBIAUgBUHUAGo2ApABIAVBsAFqQYbDwAAgBUGQAWoQDCAAIAUoArgBNgIMIAAgBSkCsAE3AgQgAEF/NgIACyAFKAJoIAUoAmwQJiAFKAJcIAUoAmAQnwEgBUHQAWokAAubAQEEfyMAQSBrIgMkACADQQhqIAJBAUEBEAcgA0EANgIcIAMgAykDCDcCFCADQRRqIAIQKCADKAIcIQQgAgRAIAMoAhghBQNAIAQgBWpBIEEAIAEtAAAiBkHBAGtB/wFxQRpJGyAGcjoAACABQQFqIQEgBEEBaiEEIAJBAWsiAg0ACwsgACADKQIU", + "NwIAIAAgBDYCCCADQSBqJAALTwEBfyMAQRBrIgMkAAJ/IAJBgAFPBEAgA0EANgIMIAMgAiADQQxqEJgCIAMoAgAgAygCBCAAIAEQxwIMAQsgAiAAIAEQyAILIANBEGokAAvQAgEEfyMAQdAAayIGJAACQCAFQQFGBEAgBC0AACEEIAZBCGogAkEBQQEQByAGQQA2AjAgBiAGKQMINwIoIAZBKGogAhAoIAYoAjAhByACBEAgBigCLCEFIANB/wFxIQMDQCAFIAdqIAQgAS0AACIIIAMgCEYbOgAAIAFBAWohASAHQQFqIQcgAkEBayICDQALCyAAIAYpAig3AgAgACAHNgIIDAELIAZBEGogAkEAIAUbQQFBARAHIAZBADYCJCAGIAYpAxA3AhwgBkEoaiADIAEgAhCiAgNAIAZBxABqIAZBKGoQxQIgBigCREEBR0UEQCAGKAJIIAdrIQMgASAHaiEIIAYoAkwhByAGQRxqIgkgCCADEAogCSAEIAUQCgwBCwsgBkEcaiABIAdqIAIgB2sQCiAAIAYoAiQ2AgggACAGKQIcNwIACyAGQdAAaiQAC08BAn8jAEEQayIFJAAgBUEIaiABIAIgAxDJAiAFKAIIIgYEQCAFKAIMIQEgACAGNgIAIAAgATYCBCAFQRBqJAAPCyACIAMgASADIAQQWgAL7AQCA34CfyMAQdAAayIHJAACQAJAAkACQAJAAkACQAJAAkACQCACDgIAAQILIABBADoAAQwHCyABLQAAIghBK2sOAwIBAgELIAEtAAAhCAsCQAJAAkAgCEH/AXFBK2sOAwECAAILIAJBAWshCCABQQFqIQEgA60hBSACQRFPBEADQCAIRQ0HIAdBMGogBCAEQj+HIAVCABD+ByAHQcgAaiABLQAAIAMQFiAHKAJIIQIgBykDOCAHKQMwIgRCP4dRBEAgAkEBcUUNBSAEIAc1AkwiBlMgBCAGfSIEQgBTcw0GIAFBAWohASAIQQFrIQgMAQsLQQEhASACQQFx", + "RQ0DIABBAzoAAQwICwNAIAhFDQYgB0EoaiABLQAAIAMQFiAHKAIoQQFHDQMgAUEBaiEBIAhBAWshCCAEIAV+IAc1Aix9IQQMAAsACyACQQFrIQIgAUEBaiEBCyADrSEFIAJBEE8EQANAIAJFDQUgB0EQaiAEIARCP4cgBUIAEP4HIAdBIGogAS0AACADEBYgBygCICEIIAcpAxggBykDECIEQj+HUQRAIAhBAXFFDQMgBzUCJCEGQQAgBCAEIAZ8IgRVcw0FIAFBAWohASACQQFrIQIMAQsLQQEhASAIQQFxRQ0BIABBAjoAAQwGCwNAIAJFDQQgB0EIaiABLQAAIAMQFiAHKAIIQQFHDQEgAUEBaiEBIAJBAWshAiAHNQIMIAQgBX58IQQMAAsAC0EBIQEgAEEBOgABDAQLIABBAzoAAQwCCyAAQQI6AAEMAQsgACAENwMIQQAhAQwBC0EBIQELIAAgAToAACAHQdAAaiQACw4AIAAgAUHGlsAAEIUICw0AIAAgASACQQoQwAILFwAgACgCAEUEQCAAKAIEIAAoAggQAQsLFgAgACgCAARAIAAoAgQgACgCCBABCwvMAQEKfyMAQRBrIgMkAAJAIAEoAhAiBCABKAIIIghLDQAgAUEUaiIJIAEtABgiBWpBAWshCiABKAIEIQcgASgCDCECAkADQCACIARLDQIgA0EIaiAKLQAAIAIgB2ogBCACaxDGAiADKAIIQQFHDQEgASACIAMoAgxqQQFqIgI2AgwgAiAFSSACIAhLcg0AIAcgAiAFayILaiAJIAUQ+gcNAAsgACACNgIIIAAgCzYCBEEBIQYMAQsgASAENgIMCyAAIAY2AgAgA0EQaiQAC9cCAQV/AkACQAJAIANBB00EQCABQf8BcSEBA0AgAyAERg0EIAIgBGotAAAgAUYNAiAEQQFqIQQMAAsACwJAAkAgAiACQQNqQXxxIgRHBEAgBCACayEFQQAhBCABQf8BcSEHQQEhBgNAIAIgBGotAAAgB0YN", + "BiAFIARBAWoiBEcNAAsgBSADQQhrIgZLDQIMAQsgA0EIayEGCyABQf8BcUGBgoQIbCEEA0BBgIKECCACIAVqIgcoAgAgBHMiCGsgCHJBgIKECCAHQQRqKAIAIARzIgdrIAdycUGAgYKEeHFBgIGChHhHDQEgBUEIaiIFIAZNDQALCyADIAVGDQEgAyAFayEDIAIgBWohAkEAIQQgAUH/AXEhAQNAIAEgAiAEai0AAEcEQCAEQQFqIgQgA0cNAQwDCwsgBCAFaiEEC0EBIQYMAQtBACEGCyAAIAQ2AgQgACAGNgIAC3kBAn8jAEHQAGsiBCQAAn9BASABRQ0AGgJAIAEgA08EQCABIANGDQFBAAwCCyABQQFHBEAgBEEQaiIFIAIgAyAAIAEQWSAEQQRqIAUQygIgBCgCBAwCCyAALQAAIAIgAxDIAgwBCyAAIAIgARD6B0ULIARB0ABqJAALKgEBfyMAQRBrIgMkACADQQhqIAAgASACEMYCIAMoAgggA0EQaiQAQQFGC1EAAkACQCABRQ0AAkAgASADTwRAIAEgA0cNAQwCCyABIAJqLAAAQb9/Sg0BC0EAIQIMAQsgASACaiECIAMgAWshAQsgACABNgIEIAAgAjYCAAv8AgEJfyMAQSBrIgIkAAJAAkAgASgCAEUEQCABLQAMIQQgASgCNCEFIAEoAjAhBiABKAIEIQMgAS0ADkEBcSEJAkACQAJAA0AgCQ0DIAEgBEEBczoADCACQRBqIAMgBiAFEMkCIAIoAhAiCEUNBSACKAIUIQogAiAINgIYIAIgCCAKajYCHCACQQhqIAJBGGoQwwEgAigCCEEBcQRAIARBAXENAkEBIQQgAQJ/QQEgAigCDCIIQYABSQ0AGkECIAhBgBBJDQAaQQNBBCAIQYCABEkbCyADaiIDNgIEDAELCyAEQQFxRQ0BCyAAIAM2AgggACADNgIEQQEhBwwBCyABQQE6AA4LIAAgBzYCAAwCCyABQQhqIQMgASgCPCEEIAEoAjgh", + "BSABKAI0IQcgASgCMCEGIAEoAiRBf0cEQCAAIAMgBiAHIAUgBEEAEMsCDAILIAAgAyAGIAcgBSAEQQEQywIMAQsgBiAFIAMgBUGg3cMAEFoACyACQSBqJAALkgMCDX8BfiAFQQFrIQ0gASgCCCIKQQFrIQ4gBSABKAIQIg9rIRAgASgCHCEHIAEpAwAhFCABKAIUIQgDQEEAIAcgBhshESAKIAcgCiAHIApLGyAGGyILIAUgBSALSRshEgJAIAECfwNAIAMgCCANaiIHTQRAIAEgAzYCFEEAIQcMAwsCQAJAIBQgAiAHajEAAIhCAYNQRQRAIAIgCGohDCALIQcMAQsgBSAIaiEIDAELAkACQANAIAciCSASRwRAIAdBAWohByAEIAlqLQAAIAkgDGotAABGDQEMAgsLIA4hBwNAIAdBAWogEU0EQCABIAUgCGoiAjYCFCAGRQRAIAFBADYCHAsgACACNgIIIAAgCDYCBEEBIQcMBwsgBSAHTQ0CIAcgDGohCSAEIAdqIAdBAWshBy0AACAJLQAARg0ACyABIAggD2oiCDYCFCAGDQMgEAwECyAIIAlqIAprQQFqIQgMAQsgByAFQYTcwgAQKgALIAEgCDYCFCAGDQALQQALIgc2AhwMAQsLIAAgBzYCAAvsBAEHfyMAQSBrIgMkACADQQhqIAEgASACahAgIANBADYCHCADQoCAgIDAADcCFCADKAIMIQcgAygCECEFA0ACQAJAAkACQAJAAkACQAJAAkACQAJAIAQgBUkEQCADQQhqIARBnOHCAEEDENUCDQFBACEBAkADQCABQfACRg0BIAFB3MPDAGohCCABQdjDwwBqIQIgAUEQaiEBIANBCGogBCACKAIAIgYgCCgCACIIENUCRQ0ACyADQRRqIAIoAgggAigCDBDVASAGIAYgCGoQ1gIgBGohBAwNCwJAIAcgBSAEQcjGwwAQISgCACIIQSxrDgoABgAGBgcICQoLBgsgBEEBaiIGIAVPDQQgByAFIAZB", + "2MbDABAhKAIAQTBHBEAgByAFIAZB6MbDABAhKAIAQTlHDQULIAcgBSAGQfjGwwAQISgCACEJQQAhAQNAIAEgBmoiAiAFTw0DIAkgByAFIAJBiMfDABAhKAIARgRAIAFBAWohAQwBCwsgByAFIAEgBmoiAkGYx8MAECEoAgBBMGtBCkkNBAwDCyAAIAMoAhw2AgggACADKQIUNwIAIAMoAgggBxAmIANBIGokAA8LIANBFGpBCiABENUBIARBA2ohBAwKCyACIARBf3NqIQELIANBFGpBHUEeIAlBMEYbIAEQ1QEgAiEEDAgLIAhBMWsOBQECAwQFAAsgA0EUakEAIAgQ1QEMBQsgA0EUakEEIAEQ1QEMBAsgA0EUakEIIAEQ1QEMAwsgA0EUakEPIAEQ1QEMAgsgA0EUakERIAEQ1QEMAQsgA0EUakETIAEQ1QELIARBAWohBAwACwALLAAgAiADSQRAIAMgAiACIAQQKQALIAAgAiADazYCBCAAIAEgA0ECdGo2AgAL+gcBBX8jAEHgAGsiBSQAIAUgASgCACIGQQRqKAIAIAZBCGooAgAiBiAGIAIgAiAGSxtB2OHCABDNAiAFQQhqIAUoAgAiAiACIAUoAgRBAnRqECUgASgCECEIIAEoAgwhCSABKAIIIQYgASgCBCECIAUoAhAhASAFKAIMIQcCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIANBAWsOHgECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHgALIAVBFGogBBDYAgweCyAFQRRqQYThwgBBBBAGDB0LIAVBFGpBiOHCAEECEAYMHAsgBUEUakGK4cIAQQIQBgwbCyAFQRRqQYzhwgBBARAGDBoLIAVBFGpBjeHCAEEDEAYMGQsgBUEUakGQ4cIAQQcQBgwYCyAFQRRqQZfhwgBBAhAGDBcLIAVBFGpBmeHCAEEBEAYM", + "FgsgBUEUakGa4cIAQQIQBgwVCyAFQRRqQZzhwgBBAxAGDBQLIAVBFGpBn+HCAEEDEAYMEwsgBUEUakGi4cIAQQYQBgwSCyAFQRRqQajhwgBBAhAGDBELIAVBFGpBquHCAEECEAYMEAsgBUEUakGs4cIAQQEQBgwPCyAFQRRqQa3hwgBBAhAGDA4LIAVBFGpBr+HCAEEBEAYMDQsgBUEUakGw4cIAQQIQBgwMCyAFQRRqQbLhwgBBARAGDAsLIAVBFGpBs+HCAEECEAYMCgsgBUEUakG14cIAQQIQBgwJCyAFQRRqQbfhwgBBAxAGDAgLIAVBFGpBuuHCAEEGEAYMBwsgBUEUakHA4cIAQQUQBgwGCyAFQRRqQcXhwgBBAxAGDAULIAVBFGpByOHCAEEGEAYMBAsgBUEUakHO4cIAQQUQBgwDCyAFQRRqQdPhwgBBAxAGDAILIAVBQGsiA0HW4cIAQQEgBBDZAiAFQQM2AjwgBSADNgI4IAVBFGpB8IDAACAFQThqEAwgBSgCQCAFKAJEEAEMAQsgBUFAayIDQdfhwgBBASAEENkCIAVBAzYCPCAFIAM2AjggBUEUakHwgMAAIAVBOGoQDCAFKAJAIAUoAkQQAQsgBSgCGCEDIAUgBSgCHDYCPCAFIAM2AjggBSABNgI0IAUgBzYCMCAFIAg2AiwgBSAJNgIoIAUgBjYCJCAFIAI2AiAgBUECNgJcIAVBAjYCVCAFQQI2AkwgBUECNgJEIAUgBUE4ajYCWCAFIAVBMGo2AlAgBSAFQShqNgJIIAUgBUEgajYCQCAAQYnSwAAgBUFAaxAMIAUoAgggBxABIAUoAhQgAxABIAVB4ABqJAALjgICBn8BfiMAQSBrIgckACABIAMoAgAiBkECdGohCiAGIAYgAiACIAZJGyIJayELAkADQCAIIAtqRQRAIAkgBmshCAwCCwJAIAUgCE0NACAKKAIAQTBrQQlLDQAgAyAGIAhqQQFqNgIAIApBBGohCiAIQQFqIQgMAQsL", + "IAYgCGohCQsCQCAEIAhNBEAgBiAJTSACIAlPcUUEQCAGIAkgAkGcwsMAECkACyAHQRRqIAEgBkECdGogASAJQQJ0ahAlIAcgBygCGCIBIAcoAhwQwgIgACAHLQAABH5CAAUgACAHKQMINwMIQgELNwMAIAcoAhQgARABDAELIABCADcDACADIAY2AgALIAdBIGokAAvLAgEFfyMAQSBrIgMkACACKAIAIgUgASABIAVJGyEGIAAgBUECdGohByAFIQQDQCAEIAZHBEAgBygCAEEwa0EJSwRAIAQhBgUgAiAEQQFqIgQ2AgAgB0EEaiEHDAILCwsCQAJAIAEgBkkgBSAGS3JFBEAgAyAAIAVBAnRqIAAgBkECdGoQJSADQQxqIAMoAgQiASADKAIIEEIgAygCFCIAQQhNBEAgACEEDAMLQQkhBCAAQQlGDQEgAygCECwACUG/f0oNAUHc68IAQTBB7MLDABA+AAsgBSAGIAFB3MLDABApAAsgA0EJNgIUCwNAIARBCU9FBEAgA0EMakEwENcCIAMoAhQhBAwBCwsgA0EYaiADKAIQIgAgBEEKENoCIAMoAhwhAiADLQAYIQQgAygCDCAAEAEgAygCACABEAEgA0EgaiQAQQAgAiAEGwv1AQIFfwF+IwBBEGsiBiQAAkAgAygCACIKIAJPDQBBASEIAkACQCABIApBAnRqKAIAQStrDgMBAgACC0F/IQgLIAMgCkEBajYCACAGIAEgAiADQQJBAhDPAiAGKQMAQgFSDQAgBikDCCELAn8CQCAFRQRAIARFDQEgAygCACIHIAJPDQMgASAHQQJ0aigCAEE6Rw0DIAMgB0EBajYCAAwBCyAIIAunbEGQHGwMAQsgBiABIAIgA0ECQQIQzwIgBigCAEUNASAGKQMIp0E8bCALp0GQHGxqIAhsCyEHQQEhCQsgACAHNgIEIAAgCTYCACAGQRBqJAALpgIBC38jAEEQayIGJAAgBCAFQQN0aiEMIAEgAygCACIIQQJ0aiEN", + "AkACQANAIAQgDEYNASAGQQRqIAQoAgAiASABIAQoAgRqECACQAJAIAYoAgwiASAIaiIKIAJLBEAgBigCCCEHDAELIAggCksNBCABQQJ0QQRqIQ5BACEFIAYoAgghBwNAIA4gBUEEaiIBRg0CIAUgB2ohDyAFIA1qIAEhBSgCACIBQSByIAEgAUHBAGtBGkkbIA8oAgAiAUEgciABIAFBwQBrQRpJG0YNAAsLIAlBAWohCSAEQQhqIQQgBigCBCAHECYMAQsLIAMgCjYCACAGKAIEIAcQJkEBIQsLIAAgCTYCBCAAIAs2AgAgBkEQaiQADwsgCCAKIAJB3MzDABApAAtgACACIAFCCXxCDIGnQZkBbEECasFBBW2tw3wgACABQgNTrX0iAEKPA30gACAAQgBTG0KQA38iAUKx9Qh+fCABQvB8fiAAfCIAQgR/fCAAQu0CfnwgAEKcf398Qu30K30LrwEBBH4gAEIDQncgAUK8/yJ8IAFC7PQrfCIBIAFCAFMbQrH1CH8iBELPind+IAF8IgFCzHR/IAF8IAFCrJ0Cf3wgAULQind/fCICQsx0fyABfCACQpSdAn98IAJC7QJ/IgFCk31+fCICQgV+QgJ8IgNC+gtTGyADQpkBfyIDfCIFNwMIIAAgAiADQpkBfkICfEJ7f3xCAXw3AxAgACAFQgNTrSABIARCkAN+fHw3AwALiQEBA38jAEEgayIEJAAgBEEUaiACIAIgA2oQIEEAIQICQCAAQQhqKAIAIgUgBCgCHCIDIAFqIgZJDQAgBEEIaiAAQQRqKAIAIAUgASAGQfTgwgAQJCAEKAIMIANHDQAgBCgCCCAEKAIYIANBAnQQ+gdFIQILIAQoAhQgBCgCGBAmIARBIGokACACCxwAIAEgAGsiAUEQTwRAIAAgARBJDwsgACABEGMLTQECfyAAKAIIIQIgAAJ/QQEgAUGAAUkNABpBAiABQYAQSQ0AGkEDQQQgAUGAgARJGwsiAxAoIAEgACgCBCACahCZAiAA", + "IAIgA2o2AggLNQEBfyMAQRBrIgIkACACQQA2AgwgAiABIAJBDGoQmAIgACACKAIAIAIoAgQQBiACQRBqJAALgwICAn8BfiMAQSBrIgQkAAJAIANFBEAgAEEANgIIIABCgICAgBA3AgAMAQsCQCACrSADrX4iBkIgiFAEQCAEQQhqIAanIgVBAUEBEAcgBEEANgIcIAQgBCkDCDcCFCAEQRRqIAEgASACahCoAiAEKAIcIQIgBCgCGCEBA0ACQCADQQF2IgNFBEAgBCACNgIcIAIgBUcNAQwECyACBEAgASACaiABIAL8CgAACyACQQF0IQIMAQsLIAUgAmsiAwRAIAEgAmogASAD/AoAAAsgBCAFNgIcDAELQdDbwgBBEUHM68IAEGIACyAAIAQoAhw2AgggACAEKQIUNwIACyAEQSBqJAAL0wICA38CfiMAQRBrIgUkAAJAAkACQAJAAkACQAJAAkAgAg4CAAECCyAAQQA6AAEMBQsgAS0AACIEQStrDgMCAQIBCyABLQAAIQQLIAEgBEH/AXFBK0YiBGohASACIARrIgJBCU8EQEEAIQQgA60hBwJAA0AgAkUNBCAFQQhqIAEtAAAgAxAWIAUoAgghBiAErSAHfiIIQiCIpw0BIAZBAXFFDQMgAUEBaiEBIAJBAWshAiAFKAIMIgYgCKdqIgQgBk8NAAsgAEECOgABDAQLQQEhAiAGQQFxRQ0BIABBAjoAAQwEC0EAIQQDQCACRQ0CIAUgAS0AACADEBYgBSgCAEEBRw0BIAFBAWohASACQQFrIQIgBSgCBCADIARsaiEEDAALAAtBASECIABBAToAAQwCCyAAIAQ2AgRBACECDAELQQEhAgsgACACOgAAIAVBEGokAAuSCAEPfyMAQcABayIDJAAgA0EANgJcIANCgICAgBA3AlQgA0EANgJoIANCgICAgBA3AmAgA0GIAWohDQNAAkACQAJAAkACQAJAIAIEQCADQcgAaiABIAJBChDjAkEBIQZBACEHIAMo", + "AkhBAXENASACIQUgASEEDAILIAAgAygCXDYCCCAAIAMpAlQ3AgAgACADKQNgNwIMIAAgAygCaDYCFAwCCyADQUBrIAMoAkxBAWoiBiABIAJBuNLDABDkAiADKAJEIQUgAygCQCEEIANBOGogBiABIAJByNLDABC/AiADKAI8IQcgAygCOCEGCyADIAc2AnAgAyAGNgJsIANBMGpB2NLDAEECIAQgBRCbAgJ/IAMoAjAiAgRAQQIhCEEAIQlB2NLDACEKIAMoAjQMAQsgA0EoaiAEIAVBChAfIAMoAigiAkUEQEEAIQhBASEKIAQhAkEBIQkgBQwBC0EBIQhBACEJQZS0wwAhCiADKAIsCyEBIANBIGogAiABEBQgAygCICIPIAMoAiQiDkGUlcMAQQMQEg0BIANBGGogAiABEKQCIANBEGpBlJXDAEEDIAMoAhggAygCHBCaAgJAIAMoAhAiC0UNACADKAIUIgxFDQAgA0EANgK4ASADIAs2ArABIAMgCzYCqAEgA0KggICAkAE3A6ABIAMgDDYCrAEgAyALIAxqNgK0ASADQZQBaiIQIANBoAFqIhEQlAIgAygClAEgAygCmAFyDQAgA0EIaiALIAxCoICAgJABEKMCIAMgAykDCDcCdCADQdQAaiIEQfbjwgBBEBAKIARBlLTDACAKIAkbQQEgCCAJGxAKIANBAjYCrAEgA0ECNgKkASADIANB7ABqNgKoASADIANB9ABqNgKgASAQQYCAwAAgERAMIAMoApwBBEBBAEEBEAEgAyADKQKUATcDYCADIAMoApwBIgE2AmggA0H8AGogAygCZCICIAEQ2wIgAygCfCAEIAMoAoABIgUgAygChAEQCiAAIAMoAlw2AgggACADKQJUNwIAIAAgDSkCADcCDCAAIA0oAgg2AhQgBRABIAMoAmAgAhABDAILIAAgAygCXDYCCCAAIAMpAlQ3AgAgACADKQNgNwIMIAAgAygCaDYCFCADKAKUASADKAKYARABDAELIA5F", + "DQIgDyAOQSMQlwINAiADIAIgARCkAiADKAIAIAMoAgRB2tLDAEEFEP0BDQIgA0HgAGoiASAEIAUQCiABIAYgBxAKIAAgAygCXDYCCCAAIAMpAlQ3AgAgACADKQNgNwIMIAAgAygCaDYCFAsgA0HAAWokAA8LIANB1ABqQfbjwgBBEBAKDAELIANB1ABqIAIgARAKCyADQdQAaiAKIAgQCiAHIQIgBiEBDAALAAuNBAECfyMAQSBrIgQkAEEEQQwQ5QIiBUEANgIIIAVCgICAgBA3AgAgBBDmAiAAQoCAgIBwNwKsAiAAQgE3AqQCIABCADcCnAIgACADNgKYAiAAIAI2ApQCIABCgICAgHA3A/gBIABCgICAgMAANwPwASAAQgE3A+gBIABCADcD4AEgAEKAgICAEDcD2AEgAEIBNwPQASAAQgA3A8gBIABCgICAgBA3A8ABIABCBDcDuAEgAEIANwOwASAAQoCAgIDAADcDqAEgAEIANwOgASAAQoCAgIDAADcDmAEgAEEANgKIASAAIAE2AtwEIABBADsBvAIgAEIANwK0AiAAQQA2AsQCIAAgBTYC5AIgAEF+NgLAAyAAQQA2ArgEIABBADYCyAQgAEKAgICAwAA3AtQCIABCgICAgBA3AtwCIABCATcD6AIgAEIBNwPwAiAAQoCAgIAQNwP4AiAAQgA3A4ADIABCATcDiAMgAEKAgICAEDcDkAMgAEIANwOYAyAAQgE3A6ADIABCgICAgBA3A6gDIABCADcDsAMgAEIBNwO4AyAAQoCAgIAQNwPABCAAQYGABDYBvgIgAEH/AToAhAQgAEEAOgDCAiAAQQA2ANcEIABCADcD0AQgAEF/NgJEIAAgBCkDADcDaCAAIAQpAwg3A3AgACAEKQMQNwN4IAAgBCkDGDcDgAEgBEEgaiQAC/4JAg1/AX4jAEHAA2siAiQAIAJBADYCDCACQoCAgIDAADcCBCABQcgAaiEKIAFBDGohDCACQYACaiEEIAJBxAFqIQ0g", + "AkGgA2ohByACQUBrIQgDQAJAIAJBuAFqIAEQ5wICQAJAAkACQCACKAL8ASIDQX9GBEAgAiACKALAASIBNgJoIAIgAikCuAEiDzcDYCAAIAE2AgwgACAPNwIEIABBATYCAAwBCyACQeAAaiIFIAJBuAFqQcQA/AoAACAIIAQpAhg3AhggCCAEKQIQNwIQIAggBCkCCDcCCCAIIAQpAgA3AgAgAkEQaiAFQSz8CgAAIAIgAzYCPAJAAkACQCACKAIQQf////8Hag4EBgECBgALIAJBuAFqIgEgAkEQakEs/AoAACACQRI2AmQgAiABNgJgIABBBGpBsYPAACACQeAAahAMIABBATYCACABEOkCIAJBPGoQ6gIMAgsgACACKAIMNgIMIAAgAikCBDcCBCAAQQA2AgAgAkE8ahDqAiACQRBqEOkCDAULIAJBuAFqIgYgARDnAgJAIAIoAvwBIgNBf0cEQCACQeAAaiILIAZBLPwKAAAgByAEKQIANwIAIAcgBCkCCDcCCCAHIAQpAhA3AhAgByAEKQIYNwIYIAIoAuwBIQUgAigC6AEhCSACQfACaiIOIAtBLPwKAAAgAiADNgKcAyAGIAEgDiAJIAUgAkGcA2pBACACEOsCIAIoArwBIQUgAigCuAEiA0F/RwRAIAAgAigCwAE2AgwgACAFNgIIIAAgAzYCBCAAQQE2AgAMAgsgAkEANgKwASACQoCAgIAQNwKoASACQbgBaiABEOcCIAIpArwBIQ8gAigCuAEhAyACKAL8ASILQX9GBEAgACAPNwIIIAAgAzYCBCAAQQE2AgAgAigCqAEgAigCrAEQAQwCCyACQbgCaiANQTj8CgAAIAIgBCkCEDcDsAIgAiAEKQIINwOoAiACIAQpAgA3A6ACIAIoApgCIQkgAigCnAIhBiADQYSAgIB4Rg0DDAQLIAIgAigCwAEiATYCaCACIAIpArgBIg83A2AgACABNgIMIAAgDzcCBCAAQQE2AgALIAJBPGoQ6gIgAkEQahDp", + "AgsgAigCBCACKAIIECYMAwsgAkG4AWogCSAGEEIgAigCqAEgAigCrAEQASACIAIoAsABNgKwASACIAIpArgBNwOoAQsgARDsAiABIA83AgQgASADNgIAIAwgAkG4AmpBOPwKAAAgASALNgJEIAEgBjYCZCABIAk2AmAgCiACKQOgAjcDACAKIAIpA6gCNwMIIAogAikDsAI3AxAgASgC3AQiA0EEaigCACADQQhqKAIAIAUQ4QIhAyACKAJEBEAgAkEDNgLEASACIANByABqNgLAASACQQM2ArwBIAIgAkE8ajYCuAEgAkHgAGpBgIDAACACQbgBahAMIAMoAkggA0HMAGooAgAQASADIAIoAmg2AlAgAyACKQJgNwJICyACKAKwAQRAIAJBAzYCxAEgAiADQeAAajYCwAEgAkEDNgK8ASACIAJBqAFqNgK4ASACQeAAakGAgMAAIAJBuAFqEAwgAygCYCADQeQAaigCABABIAMgAigCaDYCaCADIAIpAmA3AmALIAJBBGogBRDgAiACKAKoASACKAKsARABCyACQTxqEOoCIAJBEGoQ6QIMAQsLIAJBwANqJAALwwEAIABBGGogASACEAYgAEEkaiADIAQQBiAAQQI6AJoBIABBADYCOCAAQoCAgIAQNwIwIABCATcCZCAAQgA3AlwgAEKAgICAEDcCVCAAQgE3AkwgAEIANwJEIABCgICAgMAANwI8IABBADYCACAAQQA2AogBIABBADYCdCAAQoCAgIAQNwJsIABBADYCECAAQQA2AgggAEIANwKAASAAQoCAgIAQNwJ4IABCADcBkgEgAEIANwKMAUEAQQEQAUEAQQEQAQtzAQN/IAAoAggiAyAAKAIARgRAIwBBEGsiAiQAIAJBCGogACAAKAIAQQFBBEGcARCXASACKAIIIgRBf0cEQCACKAIMGiAEEBwACyACQRBqJAALIAAoAgQgA0GcAWxqIAFBnAH8CgAAIAAgA0EBajYCCCADCzMBAX8gACgCCCIC", + "IAAoAgBGBEAgABDrAQsgACACQQFqNgIIIAAoAgQgAkECdGogATYCAAsQACAAIAEgAkHY88IAELkCC5IHAQh/IwBBIGsiBSQAIAAoAqABIQcgACgCmAEhAyAFQQhqIAAoAqQBEJQBAn9BACAFKAIMIgggBSgCCCIGRg0AGiAIIAZrIgIgAyAGIAdqIgEgA0EAIAEgA08bayIBayIGSwRAIAIgBmshBCADDAELIAEgAmoLIAFrIQIgACgCnAEiBiABQTRsaiEBAkADQCACBEAgAkEBayECIAEQ7QIgAUE0aiEBDAEFAkAgBiECA0AgBARAIARBAWshBCACEO0CIAJBNGohAgwBCwsgAyAGQQRBNBAwIAAoAvwBIAAoAoACEAUgACgCqAEgACgCrAFBBEEUEDAgACgCtAEgACgCuAFBBEEIEDAgACgCwAEgACgCxAFBAUEBEDAgACgCzAEgACgC0AEQASAAKALYASAAKALcARABIAAoAuQBIAAoAugBEAEgACgC+AEhBCAAKAL0ASIBIQIDQCAEBEAgBEEBayEEIAIQ6gIgAkHUAGohAgwBCwsgACgC8AEgAUEEQdQAEDAgACgC1AIgACgC2AJBBEEQEDAgAEGEBGoQ7gIgACgCwANBfkcEQCAAQcADahDpAgtBACEBIAAoAsAEQQAgACgCuAQiAxshByADQQBHIQggACgCvAQhAiADIQQDQCAHBEACQCAIBEAgAQ0BA0AgAgRAIAJBAWshAiADKAK4ASEDDAELC0EAIQJBACEEIAMhAQwBC0GcmcMAEF0ACyAHQQFrIQcCQAJAA0AgAS8BtgEgAk0EQCAFQRRqIAEgBBDvAiAFKAIUIgFFDQIgBSgCHCECIAUoAhghBAwBCwsgBEUEQCACQQFqIQQgASEGDAILIAEgAkECdGpBvAFqIQMDQCADKAIAIgZBuAFqIQMgBEEBayIEDQALQQAhBAwBC0H028IAEF0ACyABIAJBDGxqIgEoAgQgAUEIaigCABAFQQEhCEEA", + "IQMgBCECQQAhBCAGIQEMAQUgCEUNBSABDQIDQCACBEAgAkEBayECIAMoArgBIQMMAQUgAyEBQQAhAwsLCwsLCwsDQCAFQRRqIAEgAxDvAiAFKAIUIgFFDQEgBSgCGCEDDAALAAsgAEHIBGoQ8AIgAEHgAmoQ8QIgACgC7AIgACgC8AIQASAAKAL4AiAAKAL8AhABIAAoAoQDIAAoAogDEAEgACgCkAMgACgClAMQASAAQZwDahDqAiAAQegAahDyAiAAEOwCIAVBIGokAAtGAQJ/IwBBMGsiBCQAIARBFGoiBSADIAEgAhCiAiAEQQhqIAUQxQIgBCgCCCEBIAAgBCgCDDYCBCAAIAE2AgAgBEEwaiQAC0cAAkACQCABRQ0AIAEgA08EQCABIANGDQEMAgsgASACaiwAAEFASA0BCyAAIAE2AgQgACACNgIADwsgAiADQQAgASAEEFoACxUBAX8gASAAEEMiAkUEQBAdAAsgAgtRAgF/An4jAEEQayIBJAAgARCCASABKQMAIQIgASkDCCEDIABByNvCACkDADcDCCAAQcDbwgApAwA3AwAgACADNwMYIAAgAjcDECABQRBqJAAL0iACBn8DfiMAQcACayICJAAgASgCRCEEIAFBfzYCRAJAIARBf0cEQCAAIAFBxAD8CgAAIAAgBDYCRCAAIAEpA2A3AmAgACABKQNYNwJYIAAgASkDUDcCUCAAIAEpA0g3AkgMAQsCQAJAAkACQCABLQDYBA0AIAEoAsADIQQgAUF+NgLAAwJAIARBfkcEQCACQShqIAFBxANqQcAA/AoAAAwBCwJAAkACQAJAAkAgASgCxAJBFUcEQCABQYgBaiEEIAFBnANqIgUQ6gIgAUEANgK8AyABQoCAgIAQNwK0AyABQgE3AqwDIAFCADcCpAMgAUKAgICAEDcCnAMCQAJAAkACfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABKALEAkEB", + "aw4VGwECAwQFBgcICQoLDA0QERITFBUWAAsgAkGoAmogBBD2AiACKAKsAiEFIAIoAqgCIgNBf0cEQCACIAIpArgCNwKsASACIAIpArACNwKkASACIAU2AqABIAIgAzYCnAEMGgsgBUEcaiEDIAUtAAANGCADKQIAIQggAykCCCEJIAMpAhAhCiABQQE2AsQCIAIgCjcC1AEgAiAJNwLMASACIAg3AsQBIAQQ9wIgAiACKQKsATcDkAEgAiACKQKkATcDiAEgAiACKQKcATcDgAFBgYCAgHghBAwgCyACQZgBaiAEQQAQ+AIMHgsgAkGoAmogBBD2AiACKAKsAiEDIAIoAqgCIgVBf0cEQCACIAIpArgCNwKsASACIAIpArACNwKkASACIAM2AqABIAIgBTYCnAEMDAsgAy0AACIFQRVNQQBBASAFdEG+gIABcRtFBEAgAkGYAWogBEEBQQAQ+QIMHgsgAiADKQIsNwLUASACIAMpAiQ3AswBIAIgAykCHDcCxAEgBBD6AiACQQA6AMABIAJBADYCvAEgAkKAgICAYDcCoAEgAkKAgICAEDcCmAEMHQsgAkGoAmogBBD2AiACKAKsAiEDIAIoAqgCIgZBf0cEQCACIAIpArgCNwKsASACIAIpArACNwKkASACIAM2AqABIAIgBjYCnAEgAkF+NgKYAQwdCyACIAMpAhw3A+ABIAIgAykCJDcD6AEgAiADKQIsNwPwASADLQAAQQVGBEAgBBD3AkEBIQYgAS0A2QQNHCABQcgEahD7AgwcCyABLQDZBEUEQCABQcgEahD7AgsgAkGoAmogBBD2AiACKAKsAiEDIAIoAqgCIgZBf0cEQCACIAIpArgCNwKsASACIAIpArACNwKkASACIAM2AqABIAIgBjYCnAEgAkF+NgKYAQwdC0ECIQYgAy0AACIHQRVLQQEgB3RBjICAAXFFcg0bIAIgAygCJDYCkAIgAiADKQIcNwOIAiACQagCakHb9sIAQTUQBiACIAIpA4gC", + "NwK0AiACIAIoApACNgK8AiACQX42ApgBIAIgAikCqAI3ApwBIAIgAikCsAI3AqQBIAIgAikCuAI3AqwBDBwLIAJBmAFqIARBAUEAEPkCDBsLIAJBmAFqIARBARD8AgwaCyACQZgBaiAEQQAQ/AIMGQsgAkGoAmogBBD2AiACKAKsAiEFIAIoAqgCIgNBf0cEQCACIAIpArgCNwKsASACIAIpArACNwKkASACIAU2AqABIAIgAzYCnAEMBwsgBUEcaiEDIAUtAABBDUcNDyACIAMpAhA3A/ABIAIgAykCCDcD6AEgAiADKQIANwPgASABKAL0AiEDIAQQ9wIgAkGoAmogBCADEP0CIAIoAqgCIgNBf0cEQCACIAIoArwCNgKwASACIAIpArQCNwKoASACIAIpAqwCNwKgASACIAM2ApwBDAcLIAJBqAJqIAQQ9gIgAigCrAIhAyACKAKoAiIFQX9HBEAgAiACKQK4AjcCrAEgAiACKQKwAjcCpAEgAiADNgKgASACIAU2ApwBDAcLIAMtAAAiA0EQTUEAQQEgA3RBgMIGcRtFBEAgAkEINgKoAiAEIAJBqAJqEP4CIAJBmAFqIARBAUEAEPkCDBkLIAFBCDYCxAIgAiACKQPgATcCxAEgAiACKQPoATcCzAEgAiACKQPwATcC1AEgAkEAOgDAASACQQA2ArwBIAJCgICAgGA3AqABIAJCgICAgBA3ApgBDBgLIAJBmAFqIARBARD/AgwXCyACQZgBaiAEQQAQ/wIMFgsgAkGoAmogBBD2AiACKAKsAiEFIAIoAqgCIgNBf0cEQCACIAIpArgCNwKsASACIAIpArACNwKkASACIAU2AqABIAIgAzYCnAEMBAsgBUEcaiEDIAUtAABBEEcNEiACIAMpAhA3A/ABIAIgAykCCDcD6AEgAiADKQIANwPgASAEEPcCIAJBqAJqIAQQ9gIgAigCrAIhAyACKAKoAiIFQX9HBEAgAiACKQK4AjcCrAEgAiACKQKwAjcCpAEg", + "AiADNgKgASACIAU2ApwBDAQLIAMtAAAiA0EQTUEAQQEgA3RBgIIGcRtFBEAgAkEKNgKoAiAEIAJBqAJqEP4CIAJBmAFqIARBAUEBEPkCDBYLIAFBCjYCxAIgAiACKQPgATcCxAEgAiACKQPoATcCzAEgAiACKQPwATcC1AEgAkEAOgDAASACQQA2ArwBIAJCgICAgGA3AqABIAJCgICAgBA3ApgBDBULIAJBmAFqIARBARCAAwwUCyACQZgBaiAEQQAQgAMMEwsgAkGoAmogBBD2AiACKAKsAiEDIAIoAqgCIgVBf0YNASACIAIpArgCNwKsASACIAIpArACNwKkASACIAM2AqABIAIgBTYCnAELIAIgAikCrAE3A5ABIAIgAikCpAE3A4gBIAIgAikCnAE3A4ABDBYLIAMtAAAiBUEQTUEAQQEgBXRBgIgFcRtFBEAgAkEPNgKoAiAEIAJBqAJqEP4CIAJBmAFqIARBAEEAEPkCDBELIAIgAykCLDcC1AEgAiADKQIkNwLMASACIAMpAhw3AsQBIAQQ9wIgAUEPNgLEAiACQQA6AMABIAJBADYCvAEgAkKAgICAYDcCoAEgAkKAgICAEDcCmAEMEAsgAkHgAWogBBD2AiACKALkASEDIAIoAuABIgVBf0cEQCACIAIpAvABNwKsASACIAIpAugBNwKkASACIAM2AqABIAIgBTYCnAEgAkF+NgKYAQwQCyADLQAAQRBHDQ0gBBD3AiABQQ82AsQCIAJB4AFqIAQQ9gIgAigC5AEhAyACKALgASIFQX9HBEAgAiACKQLwATcCrAEgAiACKQLoATcCpAEgAiADNgKgASACIAU2ApwBIAJBfjYCmAEMEAsgAiADKQIsNwPwASACIAMpAiQ3A+gBIAIgAykCHDcD4AEgA0EoaiEFAkACQCADLQAAQQprDgUBAAAAAQALIAJBEDYCiAIgAiAFKAIINgKUAiACIAUpAgA3AowCIAQgAkGIAmoQ/gIgAkGYAWogBEEAQQAQ", + "+QIMEAsgBSgCCCEEIAUpAgAhCCABQRA2AsQCIAFByAJqIgMgCDcDACADIAQ2AgggAkEANgK8ASACQoCAgIAQNwKYASACQoCAgIBgNwKgASACQQA6AMABIAIgAikD4AE3AsQBIAIgAikD6AE3AswBIAIgAikD8AE3AtQBDA8LIAFBDTYCxAIgAiABKALQAiIENgKwAiACIAEpA8gCIgg3ArQCIAIgBDYCvAIgAkGKgICAeDYCmAEgAiAINwLEASACIAIpA7ACNwLMASACIAIpA7gCNwLUAUGKgICAeAwGCyACQZgBaiAEQQEQgQMMDQsgAkGYAWogBEEAEIEDDAwLIAJBmAFqIARBABCCAwwLCyACQZgBaiAEQQEQggMMCgtBsPTCAEEoQbT3wgAQPgALIAIgAykCEDcC1AEgAiADKQIINwLMASACIAMpAgA3AsQBIAQQ+gJBiICAgHgLIQQgAiACKQKsATcDkAEgAiACKQKkATcDiAEgAiACKQKcATcDgAEMCAsgAiADKAIINgLoASACIAMpAgA3A+ABIAJBqAJqQZD3wgBBJBAGIAIgAikD4AE3ArQCIAIgAigC6AE2ArwCIAIgAikCqAI3ApwBIAIgAikCsAI3AqQBIAIgAikCuAI3AqwBCyACIAIpAqwBNwOQASACIAIpAqQBNwOIASACIAIpApwBNwOAAQwKCyACQZgBaiAEQQEQ+AIMBAsgAiABKAKoAiIENgJwIAIgASkDoAIiCDcCdCACIAQ2AnwgAiAINwNoIAIgCDcDUCACIAIpA3A3A1ggAiACKQN4NwNgQYKAgIB4IQQMBQsgAykCACEIIAMpAgghCSADKQIQIQogAUEKNgLEAiACQoCAgIBgNwKgASACQoCAgIAQNwKYASACIAo3AtQBIAIgCTcCzAEgAiAINwLEASACQQA6AMABIAJBADYCvAEMAgsgAiADKQIsNwO4AiACIAMpAiQ3A7ACIAIgAykCHDcDqAIgAygCMCEEIAMpAighCCABQRA2", + "AsQCIAEgCDcDyAIgASAENgLQAiACQQA2ArwBIAJCgICAgBA3ApgBIAJCgICAgGA3AqABIAJBADoAwAEgAiACKQOoAjcCxAEgAiACKQOwAjcCzAEgAiACKQO4AjcC1AEMAQsgASAGNgLEAiAEEIMDAkAgASgCpANFDQAgASgCvAMNACAFKAIIIQQgAUEANgKkAyAFKQIAIQggAUKAgICAEDcCnAMgAiAENgKwAiACIAg3A6gCIAEoArQDIAEoArgDEAEgAUG0A2oiBCACKAKwAjYCCCAEIAIpA6gCNwIACyACIAIpA/ABNwLUASACIAIpA+gBNwLMASACIAIpA+ABNwLEASACQYSAgIB4NgKYAQsgAiACKQKcATcDgAEgAiACKQKkATcDiAEgAiACKQKsATcDkAEgAigCmAEiBEF+Rg0ECyACQUBrIAJBtAFqQSj8CgAAIAIgAikDgAE3AyggAiACKQOIATcDMCACIAIpA5ABNwM4CyAEQYKAgIB4RgRAIAFBAToA2ARBgoCAgHghBAwCCyAEQQNqDgIAAwELIABCADcCPCAAQgA3AjQgAEIANwIsIABBADYCZCAAQoCAgIAQNwJcIABCATcCVCAAQgA3AkwgAEKAgICAEDcCRCAAQYKAgIB4NgIADAMLIAAgAikDODcCFCAAIAIpAzA3AgwgACACKQMoNwIEIAAgAikDUDcCLCAAIAIpA1g3AjQgACACKQNgNwI8IAAgAkFAayIDKQIANwIcIAAgAykCCDcCJCACQQRqIgMgASgCoAMgASgCpAMQQiACQRBqIAEoAqwDIAEoArADEEIgAkEcaiABKAK4AyABKAK8AxBCIAAgBDYCACAAQcQAaiADQST8CgAADAILIAIgAikDgAE3AyggAiACKQOIATcDMCACIAIpA5ABNwM4CyACIAIpAzg3A6gBIAIgAikDMDcDoAEgAiACKQMoNwOYASACQRQ2AqwCIAIgAkGYAWo2AqgCIABBupTAACACQagCahAMIABBfzYC", + "RCACKAKYASACKAKcARABCyACQcACaiQAC/YIAQZ/IwBBIGsiAiQAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAQQYgACgCACIEQYCAgIB4cyIDIANBC08bQQFrDgoBAgMEBQYHCAkKAAsgASgCAEHg3MMAQQcgASgCBCgCDBEEACEDDA0LIAEoAgBByNnDAEELIAEoAgQoAgwRBAAhAwwMCyABKAIAQdPZwwBBCSABKAIEKAIMEQQAIQMMCwsgAiAAQQRqNgIQIAFB3NnDAEENIAJBEGpBFRBKIQMMCgsgASgCAEHp2cMAQQsgASgCBCgCDBEEACEDDAkLIAIgAEEEajYCECABQfTZwwBBBSACQRBqQRYQSiEDDAgLIAEoAgAiBUH52cMAQQYgASgCBCIGKAIMIgcRBAANBgJAIAEtAApBgAFxRQRAQQEhAyAFQYPiwgBBASAHEQQADQkgBEF/Rg0BIAAoAgQgACgCCCABKAIAIAYQc0UNBwwJCyAFQc+FwQBBAiAHEQQADQcgAkEBOgAAIAIgASkCADcCECACIAI2AhggBEF/RwRAIAAoAgQgACgCCCACQRBqQcyGwQAQcw0IDAYLIAAoAgQgACgCCCACQRBqQcyGwQAQc0UNBQwHCyAAKAIEIAAoAgggASgCACAGEHMNBwwFCyACIABBBGo2AhAgAUH/2cMAQQ0gAEEcaiACQRBqEFchAwwGCyABKAIAQYzawwBBCyABKAIEKAIMEQQAIQMMBQsgAiAAQQRqNgIQIAFBl9rDAEEMIABBHGogAkEQahBXIQMMBAsgASgCAEGj2sMAQQogASgCBCgCDBEEACEDDAMLQQEhAyACQRBqQc2FwQBBAhBNDQILAkAgAS0ACkGAAXFFBEAgASgCAEHGhcEAQQIgASgCBCgCDCIDEQQADQIgASgCACAALQAoIgRBAnQoAuDdQyAELQDY3UMgAxEEAA0CDAELIAJBAToAACACIAEpAgA3AhAgAC0AKCIEQQJ0KALE", + "3UMhBSACIAI2AhggAkEQaiIGIAUgBC0AvN1DEE0NAiAGQc2FwQBBAhBNDQILIABBJGohBAJAIAEtAApBgAFxRQRAIAEoAgBBxoXBAEECIAEoAgQoAgwRBAANAiAEIAEQqwENAgwBC0EBIQMgAkEBOgAPIAJBzIbBADYCFCACIAEpAgA3AgAgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgBCACQRBqEKsBDQIgAigCEEHNhcEAQQIgAigCFCgCDBEEAA0CCyAAQQxqIQACQCABLQAKQYABcUUEQCABKAIAQcaFwQBBAiABKAIEKAIMEQQADQJBASEDIAAgARCHA0UNAQwDC0EBIQMgAkEBOgAPIAJBzIbBADYCFCACIAEpAgA3AgAgAiABKQIINwIYIAIgAkEPajYCCCACIAI2AhAgACACQRBqEIcDDQIgAigCEEHNhcEAQQIgAigCFCgCDBEEAA0CCyABKAIAQYTiwgBBASABKAIEKAIMEQQAIQMMAQtBASEDCyACQSBqJAAgAwtIAQN/QQQhAQJAAkACQEEGIAAoAgAiAkGAgICAeHMiAyADQQtPG0EGaw4EAAECAQILIAIgACgCBBAFQQwhAQsgACABahDzAgsLJgAgACgCACAAKAIEEAEgACgCDCAAKAIQEAEgACgCGCAAKAIcEAEL3B0CCH8BfiMAQaADayIIJAAgASgC3AQgCEECOgCyASAIQQA2ApwBIAhBADYCUCAIQoCAgIAQNwJIIAhCATcCQCAIQgA3AjggCEKAgICAEDcCMCAIQQA2AhggCEEANgJcIAhCgICAgMAANwJUIAggBSgCFDYCdCAIIAUpAgw3AmwgCCAFKQIYNwJ4IAggBSgCIDYCgAEgCCAGNgIgIAggBzYCJCAIQQA2AiggCEEANgKMASAIQgA3AqABIAhCgICAgBA3AoQBIAhBADYCmAEgCCADNgKoAUEBIQMgCCAEQQFqNgKsASAIQQA7AbABIAhCgICAgBA3ApABIAggBSgC", + "CDYCaCAIIAUpAgA3AmAgCEEYahDfAiEEQQBBARABQQBBARABQQBBARABAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEGIAIoAgAiDEGAgICAeHMiBSAFQQtPG0EFaw4FAAECBAMECyAIQRhqIgUgAigCBCICIAEoAugCSQR/IAEoAuQCIAJBDGxqIgIoAgghCSACKAIEBUEBCyAJEAYgAUHoAGogBRCIAyICRQ0NIAIoAgAhAiABKALcBCIBQQRqKAIAIAFBCGooAgAgBBDhAiIBQQM6AJoBIAEoAiQgAUEoaigCABABIAEgCCgCIDYCLCABIAgpAhg3AiQgASACNgIEIAFBATYCAAwMCyACKAIkIQkgAi0AKCACKAIIIQUgAigCBCEGIAggAikCDCIQNwMYIAggAikCHDcDKCAIIAIpAhQ3AyAgCEGgAmogCCgCHCAIQRhqIBCnIgJBf0YbQQAgAkF+RxsQiQMgCCgCrAIhAiAIKQKkAiEQIAgoAqACIQdBBCEDQQFrDgQIBwYFBAsgAigCHCEFIAggAikCBCIQNwO4ASAIIAIpAhQ3A8gBIAggAikCDDcDwAEgCEEYaiAIKAK8ASAIQbgBaiAQpyICQX9GG0EAIAJBfkcbEIkDIAgpAhwhECAIKAIYIQMgCCgCJCEGIAEtANoEIQcgASAEIAUQigMgASgC3AQiAkEEaigCACACQQhqKAIAIAQQ4QIiAiAGIAdBBXRBIHFyNgKEASACQQA6AJoBAkAgA0F/RwRAIAggEDcCHCAIIAM2AhgMAQsgCEEYakGw3sIAQQUQBgsgAigCGCACQRxqKAIAEAEgAiAIKAIgNgIgIAIgCCkCGDcCGCAIQaQBaiEGIAhBPGohDCAIQTBqIQogCEGAAmohAiAIQeAAaiEDQQAhBwwCCyACKAIcIQUgCCACKQIEIhA3A7gBIAggAikCFDcDyAEgCCACKQIMNwPAASAIQRhqIAgoArwBIAhBuAFqIBCnIgJBf0Yb", + "QQAgAkF+RxsQiQMgCCkCHCEQIAgoAhghAyAIKAIkIQYgAS0A2gQhByABIAQgBRCKAyABKALcBCICQQRqKAIAIAJBCGooAgAgBBDhAiICIAYgB0EFdEEgcXIiBTYChAEgAkEBOgCaAQJAIANBf0cEQCAIIBA3AhwgCCADNgIYDAELIAhBGGpBtd7CAEEFEAYLIAIoAhggAkEcaigCABABIAIgCCgCIDYCICACIAgpAhg3AhggBUEgcSEMIAhBgANqIQYgCEHgAGohAiAIQYACaiEHA0AgCEEYaiABEOcCIAgoAlwiA0F/RgRAIAggCCgCICIBNgKoAiAIIAgpAhgiEDcDoAIgACABNgIIIAAgEDcCAAwNCyAIQaACaiIKIAhBGGoiC0Es/AoAACAIKAJMIQUgCCgCSCEJIAcgAikCGDcCGCAHIAIpAhA3AhAgByACKQIINwIIIAcgAikCADcCACAIQdABaiINIApBLPwKAAAgCCADNgL8AQJAIAgoAtABQYqAgIB4RwRAIAsgASANIAkgBSAIQfwBakEBIAQQ6wIgCCgCHCEDIAgoAhgiBUF/RwRAIAAgCCgCIDYCCCAAIAM2AgQgACAFNgIADA8LIAEoAtwEIgVBBGooAgAgBUEIaigCACADEOECQQE6AJkBIAwNASABKALcBCIFQQRqKAIAIAVBCGooAgAgAxCsAigCaEUNASAIQaACaiABKALcBCIFQQRqKAIAIAVBCGooAgAgBBCsAiIFQUBrKAIAIAVBxABqKAIAEIsDAkAgCCgCqAIiCUECTQRAIAgoAqQCIQoMAQsgASgC3AQiBUEEaigCACAFQQhqKAIAIAMQ4QIiBSgCaCEKIAVBADYCaCAFKQJgIRAgBUKAgICAEDcCYCAIIAo2AiAgCCAQNwMYIAEoAtwEIQUgCCgCpAIiCiAJIAlBAWtB9O7CABAhIQkgBUEEaigCACAFQQhqKAIAIAkoAgAQ4QIiBSgCYCAFQeQAaigCABABIAUgCCgCIDYCaCAF", + "IAgpAxg3AmALIAgoAqACIAoQJgwBCyAIQRhqIAEoAtwEIgJBBGooAgAgAkEIaigCACAEEKwCIgJBQGsoAgAgAkHEAGooAgAQiwMgASgC3AQiAkEEaigCACACQQhqKAIAIAQQ4QIiAigCVCACQdgAaigCABABIAIgCCgCkAI2AlwgAiAIKQKIAjcCVCACKAJgIAJB5ABqKAIAEAEgAiAIKAKcAjYCaCACIAgpApQCNwJgAkAgDA0AIAIoAmhFDQAgCCgCICIFQQJJDQAgAkEANgJoIAJCgICAgBA3AmAgASgC3AQhASAIKAIcIAgoAiAgBUEBa0GE78IAECEhAiABQQRqKAIAIAFBCGooAgAgAigCABDhAiIBKAJgIAFB5ABqKAIAEAEgASAIQZQCaiICKAIINgJoIAEgAikCADcCYAsgCCgCGCAIKAIcECYgAyAIKAKAAhABIAhB0AFqEOkCIAhBuAFqEPMCDAsLIAhBGGogARDnAiAIKAJcIgVBf0YEQCAIIAgoAiAiATYCqAIgCCAIKQIYIhA3A6ACIAAgATYCCCAAIBA3AgAMDQsgCEGgAmoiCyAIQRhqIg1BLPwKAAAgBiACKQIANwIAIAYgAikCCDcCCCAGIAIpAhA3AhAgBiACKQIYNwIYIAgoAkwhCSAIKAJIIQogCEHQAmoiDiALQSz8CgAAIAggBTYC/AIgDSABIA4gCiAJIAhB/AJqQQEgBBDrAiAIKAIcIQUgCCgCGCIJQX9HBEAgACAIKAIgNgIIIAAgBTYCBCAAIAk2AgAMDQUgASgC3AQiCUEEaigCACAJQQhqKAIAIAUQ4QIiCSADNgIUIAlBATYCEAJAIAEoAtwEIglBBGooAgAgCUEIaigCACADEKwCKAJoDQAgASgC3AQiCUEEaigCACAJQQhqKAIAIAUQrAIoAmhFDQAgASgC3AQiCUEEaigCACAJQQhqKAIAIAUQ4QIiCSgCaCEKIAlBADYCaCAJKQJgIRAgCUKAgICAEDcCYCAIIAo2", + "AiAgCCAQNwMYIAEoAtwEIglBBGooAgAgCUEIaigCACADEOECIgkoAmAgCUHkAGooAgAQASAJIAgoAiA2AmggCSAIKQMYNwJgCyABKALcBCIJQQRqKAIAIAlBCGooAgAgBBDhAkE8aiIJIAMQ4AIgCSAFEOACDAELAAsACyAIQRhqIgEgAkEs/AoAACAIQRI2AqQCIAggATYCoAIgAEGsxMAAIAhBoAJqEAwgARDpAgwLCwJAAkADQCAIQRhqIAEQ5wIgCCgCXCIJQX9GBEAgCCAIKAIgIgE2AqgCIAggCCkCGCIQNwOgAiAAIAE2AgggACAQNwIADAILIAhBoAJqIgUgCEEYaiINQSz8CgAAIAgoAkwhCyAIKAJIIQ4gAiADKQIYNwIYIAIgAykCEDcCECACIAMpAgg3AgggAiADKQIANwIAIAhB0AFqIg8gBUEs/AoAACAIIAk2AvwBIAEoAtwEIQUgCCgC0AFBiICAgHhGDQIgCkGc38IAQQUQBiAMIAcQjAMgCEECOgCyASAIQQA2AlAgCEKAgICAEDcCSCAIQgE3AnwgCEIANwJ0IAhCgICAgBA3AmwgCEIBNwJkIAhCADcCXCAIQoCAgIDAADcCVCAIQQA2AhggCEEANgKgASAIQQA2AowBIAhCgICAgBA3AoQBIAhBADYCKCAIIAQ2AiQgCEEBNgIgIAhCADcCmAEgCEKAgICAEDcCkAEgBkIANwAFIAZCADcCACAIQQE6ALEBIAUgDRDfAiEJQQBBARABQQBBARABIA0gASAPIA4gCyAIQfwBakEBIAQQ6wIgCCgCHCEFIAgoAhgiC0F/RgRAIAEoAtwEIgtBBGooAgAgC0EIaigCACAFEOECIgsgCTYCFCALQQE2AhAgASgC3AQiCUEEaigCACAJQQhqKAIAIAQQ4QJBPGogBRDgAiAHQQFqIQcMAQsLIAAgCCgCIDYCCCAAIAU2AgQgACALNgIACyAIQbgBahDzAgwLCyAFQQRqKAIAIAVBCGooAgAg", + "BBDhAiIBKAJUIAFB2ABqKAIAEAEgASAIKAKQAjYCXCABIAgpAogCNwJUIAEoAmAgAUHkAGooAgAQASABIAgoApwCNgJoIAEgCCkClAI3AmAgCSAIKAKAAhABIAhB0AFqEOkCIAhBuAFqEPMCDAcLIAdBf0cNBCAIIAYgBRCNAyAIQQxqIAgoAgAgCCgCBBAGDAULQRAhAwwCC0EIIQMMAQtBAiEDCyACIANyIQIgB0F/Rw0AIAhBDGpB49/CAEEFEAYMAQsgCCAQNwIQIAggBzYCDAsgASAEIAkQigMgASgC3AQiAUEEaigCACABQQhqKAIAIAQQ4QIiASACNgKEASABQQI6AJoBIAEoAhggAUEcaigCABABIAEgCCgCFDYCICABIAgpAgw3AhgCQCAMQX9HBEAgCCAFNgKoAiAIIAY2AqQCIAggDDYCoAIMAQsgCEGgAmogBiAFEAYLIAEoAiQgAUEoaigCABABIAEgCCgCqAI2AiwgASAIKQKgAjcCJCAIQRhqEPMCCyAAQX82AgAgACAENgIEDAILIAhBAzYCpAIgCCAIQRhqNgKgAiAAQaHFwAAgCEGgAmoQDCAIKAIYIAgoAhwQAQwBCyAIQbgBahDzAgsgCEGgA2okAAsbACAAKAJEQX9HBEAgABDpAiAAQcQAahDqAgsLkQEAAkACQAJAAkACQAJAIAAtAAAOFQEBAQIBAQEBAQEBAQEBAQEBBQUDBAALIAAoAgQgACgCCBABIABBEGoQ8QILDwsgACgCBCAAKAIIEAUgACgCECAAKAIUEAUPCyAAKAIEIAAoAggQASAAKAIQIAAoAhQQAQ8LIAAoAgQgACgCCBAFDwsgACgCBCAAKAIIEAULEwAgAC0AAEH/AUcEQCAAEO0CCws4AQF/IAEoAgAiAwRAIAAgAS8BtAE2AgggACACQQFqNgIECyAAIAM2AgAgAUHoAUG4ASACGxCIAQuXAwEHfyMAQRBrIgQkACAAKAIIQQAgACgCACICGyEFIAJBAEch", + "BiAAKAIEIQMgAiEAAkADQCAFBEACQCAGBEAgAQ0BA0AgAwRAIANBAWshAyACKAKQAiECDAELC0EAIQNBACEAIAIhAQwBC0GcmcMAEF0ACyAFQQFrIQUCQAJAA0AgAS8BjgIgA00EQCAEQQRqIAEgABD0AiAEKAIEIgFFDQIgBCgCDCEDIAQoAgghAAwBCwsgAEUEQCADQQFqIQAgASEHDAILIAEgA0ECdGpBlAJqIQIDQCACKAIAIgdBkAJqIQIgAEEBayIADQALQQAhAAwBC0H028IAEF0ACyABIANBDGxqIgEoAgQgAUEIaigCABABIAEoAogBIAFBjAFqKAIAEAFBASEGQQAhAiAAIQNBACEAIAchAQwBBQJAIAZFDQMgAQ0AA0AgAwRAIANBAWshAyACKAKQAiECDAEFIAIhAUEAIQILCwsLCwNAIARBBGogASACEPQCIAQoAgQiAUUNASAEKAIIIQIMAAsACyAEQRBqJAALHQEBfyAAKAIEIgEgACgCCBDjASAAKAIAIAEQ9QILCwAgAEEMQRAQiAgLJgEBfyAAKAIAIgFBfkkEQCABIAAoAgQQASAAKAIMIAAoAhAQAQsLOAEBfyABKAIAIgMEQCAAIAEvAYwCNgIIIAAgAkEBajYCBAsgACADNgIAIAFBwAJBkAIgAhsQiAELDAAgACABQQRBDBAwC65MAih/BX4jAEGQBWsiAiQAIAFB/AJqIR0CQAJAIAEtAPwCQf8BRwRAIAJBLGoiBCAdEKIDIAItACwiA0H/AUcEQCABIAMgAigCSBCjAyAEEO0CCyAdLQAAQf8BRw0BQfD1wgAQXQALIAJBlAFqIRQCQAJAIAEoAnQiBEF/Rw0AIAJB3AFqIRACQAJAAkAgAS0AtQFFBEAgAS0AtwENASACQcQEaiEbIAJBrARqISAgAUEgaiEpIAFBmAFqIQYgAUGMAWohEiABQRBqIRggAkHkBGohCyACQfQEaiEJIAJB/AJqIRUgAkHMBGohIyACQfACakEB", + "ciEkIAJBjANqISEgAkGMBGohFiACQdwDaiEeIAJB2ARqQQFyISUgAkHoBGohJiACQaQCaiEMIAJB3ARqIRogAkGABWohJyACQbQEaiEoIAJBrANqIREDQEEAIQMgGBCkAyIFBEAgBS0AAEEBRiEDCwJAAkACQCABKAIcIgVFIAMgBUECS3JFcg0AIAJB2ARqIAEQpQMgAigC2AQiBEF/RwRAIBAgAigC7AQ2AhAgECACKQLkBDcCCCAQIAIpAtwENwIADAcLIAEoAihBFGwhBSABKAKsASEIIAEoAiQhBANAIAVFDQIgBEEQai0AAARAIAQoAgAgCEYNAgsgBEEUaiEEIAVBFGshBQwACwALIANFDQELIAFBAToAtwEMAwsgAUEBIAEoApQBIgMgA0EBTRs2ApQBAkACQCABLQC0AUUEQCABQQE6ALYBIAFBAToAtAEgAUF/NgKoASAVIAYoAgg2AgggFSAGKQIANwIAIAkgAikDgAM3AhAgCSAGKQIANwIAIAIgBigCCDYC+AIgCSACKQP4AjcCCCACQQA6ANgEIBggAkHYBGoiAxCmAyACQQA7AegEIAJCADcD4AQgAkIANwPYBCApIAMQpwMMAQsgAiAGKAIINgLAAiACIAYpAgA3A7gCIAIgBigCCDYC+AIgAiAGKQIANwPwAiACQdgEaiABIAJB8AJqEKgDIAIoAtgEIgRBf0cEQCAMIAIoAuwENgIQIAwgAikC5AQ3AgggDCACKQLcBDcCAAwCCyACQdgEaiABEKUDIAIoAtgEIgRBf0cEQCAMIAIoAuwENgIQIAwgAikC5AQ3AgggDCACKQLcBDcCAAwCCyABIAEoAqABIAJBuAJqEKkDIAFBBCABKAKUASIDIANBBE0bNgKUASABKAKMASEOAkACQAJAAkACQAJAAkACQAJAAn4CfwJAAn8CQAJAAkAgASgCkAEiB0UNACAOLQAAIgNFDQAgASgCoAEiDw0MIA4gBxCqA0ElRwRAIAdBA0kNDAJAIAdB", + "A0cEQCAOLQADEKsDRQ0OIANBLUYNAQwOCyADQS1HDQ0LIA4tAAFBLUcNDCAOLQACQS1HDQwgAkEEOgDYBCACQaACaiABIAJB2ARqEKwDDA4LIAEQrQMgAkHYBGogARCuAyACKALYBCIDQX9HBEAgDCAaKAIQNgIQIAwgGikCCDcCCCAMIBopAgA3AgAgAiADNgKgAgwOCyABQQA6ALYBIAIgBigCCDYCoAQgAiAGKQIANwOYBCABEK8DIAIgBigCCDYC2AMgAiAGKQIANwPQAyACQQA2AogEIAJCgICAgBA3AoAEIAEgEiACQYAEahCwAyIDIAEoApgBajYCmAEgASADIAEoAqABajYCoAECQAJAAkACQCACKAKIBCIDBEAgASgCjAEgASgCkAEQqgMQqwMNAiACQdgEakH0i8MAQccAEAYMAQsgAkHYBGpBu4zDAEHCABAGCyALIAIoAtgDNgIIIAsgAikD0AM3AgAgAigC2AQhDSACKALcBCEFIAIoAuAEIQcgAigC5AQhCiACKQLoBCEqIAIoAoAEIAIoAoQEEAEgDUF/Rw0CIAohAwwBCyACKAKEBCEHIAIoAoAEIQULIAcgA0Gk/8IAQQQQEg0DIAcgA0Go/8IAQQMQEg0CIAJBADYC2AMgAkKAgICAwAA3AtADA0ACQCABKAKQAQRAIBIoAgAtAAAiBEEJRiAEQSBGcg0BCyAWIAYpAgA3AgAgFiAGKAIINgIIICYgAikC0AM3AgAgJiACKALYAzYCCCAJIAIpA5gEIio3AgAgAiACKAKgBDYCiAQgCSACKQOIBDcCCCAJIAIpA5AENwIQIAIgKjcDgAQgAiADNgLkBCACIAc2AuAEIAIgBTYC3ARBFSETIAJBFToA2ARBACEZIAchBCAFDAYLIAEgEhCxAyIEIAEoApgBajYCmAEgASAEIAEoAqABajYCoAEgASgCjAEgASgCkAEQqgMQqwMNACACQQA2AsgDIAJCgICAgBA3AsADIAEgEiACQcADaiIK", + "ELADIgQgASgCmAFqNgKYASABIAQgASgCoAFqNgKgASACQdADaiAKELwBDAALAAsgBUEQdiEPIAVBCHYhFwwJCyACIA42AtgEIAIgByAOajYC3AQgAkHYBGoQwgEEQCABKAKgAQRAIAFBADYCoAEgASABKAKcAUEBajYCnAELIAEoAihBFGwhBSABKAIkIgRBEGohBwNAAkACQAJAAkAgBQRAIAQtABENAQwECyABEK0DIAJB2ARqIAEQrgMgAigC2AQiBEF/Rg0CIBsgAigC7AQ2AhAgGyACKQLkBDcCCCAbIAIpAtwENwIADAELIActAABBAUcNAiACQcAEakGNgsMAQRMQBiAjIAYoAgg2AgggIyAGKQIANwIAIAIoAsAEIgRBf0YNFAsgDCAbKAIQNgIQIAwgGykCCDcCCCAMIBspAgA3AgAMFAsgAUEAOgC2ASAVIAYpAgAiKjcCACAVIAYoAggiAzYCCCAJICo3AgAgAiADNgL4AiAJIAIpA/gCNwIIIAkgAikDgAM3AhAgAkEBOgDYBCAYIAJB2ARqEKYDDBILIARBADoAECAFQRRrIQUgB0EUaiEHIARBFGohBAwACwALIAIgBigCCDYC+AIgAiAGKQIANwPwAiACQdgEakHygcMAQRsQBiALIAIpA/ACNwIAIAsgAigC+AI2AgggAiACKQLYBDcDoAIgAiACKQLgBDcDqAIgAiACKQLoBDcDsAIMDAsgASASELEDIgMgASgCmAFqNgKYASABIAMgASgCoAFqNgKgASACQYAEaiABQQEgAkGYBGoQsgMgAigCjAQhCiACKAKIBCEDIAIoAoQEIQ8CQAJAIAIoAoAEIghBf0cEQCACKAKUBCENIAIoApAEIRcgDyEEDAELIAEgEhCxAyIEIAEoApgBajYCmAEgASAEIAEoAqABajYCoAEgAkEANgKwAyACQoCAgIAQNwKoAyASELMDIQQgASgCjAEgASgCkAEQqgMhCAJAAn8CQAJAIARBIUYEQCACQagD", + "aiAIENcCIAEQrwMMAQsCQAJAAn8gCBC0A0UEQCACQYAEakHrgMMAQRwQBiAWIAIoAqAENgIIIBYgAikDmAQ3AgAgAigCgAQhCCACKAKEBCEEIAIoAogEIRMgAigCjAQhGSACKAKUBCEcIAIoApAEDAELIAEoAowBIgggASgCkAEiBBCqA0ElRw0CIAJBgARqIAEgAkGYBGoQtQMgAigChAQhBCACKAKABCIIQX9GDQEgAigClAQhHCACKAKMBCEZIAIoAogEIRMgAigCkAQLIQ5BACENQQEhFwwDCyACQagDaiAEENcCDAELIAJBqANqIAggBBCqAxDXAiABEK8DCwNAIBIQswMQtgNFBEAgAigCsAMhGSACKAKsAyETIAIoAqgDDAMLAkAgASgCjAEiCCABKAKQASIEEKoDQSVGBEAgAkGABGogASACQZgEahC1AyACKAKEBCEEIAIoAoAEIghBf0YNASACKAKUBCEcIAIoApAEIQ4gAigCjAQhGSACKAKIBCETIAIoAqwDIRcgAigCqAMhDQwDCyACQagDaiAIIAQQqgMQ1wIgARCvAwwBCyACQagDaiAEENcCDAALAAsgDSAXEAEgCEF/Rw0BIAQLIQ4gAUEBIAEoApQBIgQgBEEBTRs2ApQBIAEoAowBIAEoApABELcDDQIgAkGABGpBkI3DAEHCABAGIBYgAigCoAQ2AgggFiACKQOYBDcCACACKAKABCEIIAIoAoQEIQQgAigCiAQgAigCjAQhCiACKAKQBCEXIAIoApQEIQ0gDiATEAEgDyADEAEhAwwBCyAPIAMQASAcIQ0gDiEXIBkhCiATIQMLIBetIA2tQiCGhAwFCyAeIAYpAgA3AgAgHiAGKAIINgIIIAkgAikDmAQ3AgAgAiACKAKgBDYC2AMgCSACKQPYAzcCCCAJIAIpA+ADNwIQIAIgDjYC6AQgAiAKNgLkBCACIAM2AuAEIAIgDzYC3AQgAiATrSAZrUIghoQ3AuwEQQMhEyACQQM6ANgE", + "QQEhGSADIQQgCiEDIA8MAQsgASASELEDIgMgASgCmAFqNgKYASABIAMgASgCoAFqNgKgASACQdADaiABIAJBmARqELgDIAIoAtQDIQogAigC0AMiCEF/RwRAIAIpAuADISwgAigC3AMhHyAKIQQgAigC2AMMAwsgASgCjAEgASgCkAEQqgNBLkcNASABEK8DIAJB0ANqIAEgAkGYBGoQuAMgAigC1AMhBCACKALQAyIIQX9HBEAgAikC4AMhLCACKALcAyEfIAIoAtgDDAMLIBYgBikCADcCACAWIAYoAgg2AgggAiACKAKgBDYCiAQgAiACKQOYBCItNwOoAyACIAIpA4gEIis3A7ADIAIgAikDkAQiKjcDuAMgCSAqNwIQIAkgKzcCCCAJIC03AgAgAiAsNwLsBCACIB82AugEIAIgIjYC5AQgAiAENgLgBCACIAo2AtwEQQIhEyACQQI6ANgEQQEhGSAiIQMgCgshCCACQYAEaiABELkDIAIoAoAEIg1Bf0cEQCACKQKQBCEqIAIoAowEIQogAigCiAQhAyACLwGGBCEPIAItAIUEIRcgAi0AhAQhBCACQdgEahDtAkH/ASETIBkEQCANIQgMBQsgBCEFIAMhBwwGCwJAAkAgASgCkAFFDQACQAJAIBIoAgAtAAAiCkEKaw4EAgEBAgALIApFDQELIAJBgARqQav/wgBBxwAQBiAWIAIoAqAENgIIIBYgAikDmAQ3AgAgAigCgAQhCCACKAKEBCEEIAIoAogEIQMgAigCjAQhCiACKQKQBCEqIAJB2ARqEO0CQf8BIRMMAQsgAUECIAEoApQBIgogCkECTRs2ApQBIAEQugMgAiAlLQACOgD2AyACICUvAAA7AfQDIAIgCSkCADcD2AIgAiAJKQIINwPgAiACIAkpAhA3A+gCIAIpAuwEISogAigC6AQhCgsgBEEQdiEPIARBCHYhFyAZDQMMBAsgAkHQA2pBqI7DAEHNABAGIB4gAigCoAQ2AgggHiACKQOY", + "BDcCACACKALQAyEIIAIoAtQDIQQgAigC3AMhHyACKQLgAyEsIAIoAtgDCyEiIB8hCiAiIQMgLAshKiAEQRB2IQ8gBEEIdiEXQf8BIRMLIAUgBxABCyATQf8BRw0BIAQhBSADIQcgCCENCyACICo3A7ACIAIgCjYCrAIgAiAHNgKoAiACIA02AqACIAIgBUH/AXEgD0EQdCAXQf8BcUEIdHJyNgKkAgwDCyAkIAItAPYDOgACICQgAi8B9AM7AAAgISACKQPYAjcCACAhIAIpA+ACNwIIICEgAikD6AI3AhAgAiAqNwKEAyACIAo2AoADIAIgAzYC/AIgAiAINgL0AiACIBM6APACIAIgBEH/AXEgD0EQdCAXQf8BcUEIdHJyNgL4AiAYIAJB8AJqEKYDIAJBfzYCoAIMAgsgDiAHELsDRQ0AIAJBBToA2AQgAkHwAmogASACQdgEahCsAyACKALwAiIEQX9HBEAgDCACKAKEAzYCECAMIAIpAvwCNwIIIAwgAikC9AI3AgAMBgsgAkHYBGogARC5AyACKALYBCIEQX9HBEAgAiACKQHeBDcBpgIgAiACKQHmBDcBrgIgAiACLwHuBDsBtgIgAiACLwHcBDsBpAIMBgsgASgCkAFFDQQCQAJAIBIoAgAtAAAiA0EKaw4EBgEBBgALIANFDQULIAIgBigCCDYC+AIgAiAGKQIANwPwAiACQdgEakG2gcMAQSkQBiALIAIpA/ACNwIAIAsgAigC+AI2AgggAiACKQLYBDcDoAIgAiACKQLgBDcDqAIgAiACKQLoBDcDsAIMAQsgASgCqAEiBCAPTARAIA4gBxCqAyENIA4gB0EBELwDIQogBiEDIBgQpAMiBUUNAyABLQC6ASIIRSANQTpGcQ0CIA1BLEcNAyAIDQIMAwsgAiAGKAIINgL4AiACIAYpAgA3A/ACIAJB2ARqQd+BwwBBExAGIAsgAikD8AI3AgAgCyACKAL4AjYCCCACIAIpAtgENwOgAiACIAIpAuAE", + "NwOoAiACIAIpAugENwOwAgsgAigCoAIiBEF/Rg0EDAMLIAVBHGohAwsgAiADKAIINgLQAiACIAMpAgA3A8gCIAIgDTYCzAMCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCANQSFrDg0EBxUVCAMGFRUCFQEJAAsCQCANQTprDgcLFRUVBQoIAAsCQAJAAkACQAJAIA1B2wBrDgYBGQMZGQwACyANQfsAaw4DARIDGAsgAkEJOgDYBCACQagDaiABIAJB2ARqEL0DDBgLIAJBCzoA2AQgAkGoA2ogASACQdgEahC9AwwXCyACQQo6ANgEIAJBqANqIAEgAkHYBGoQvgMMFgsgAkEMOgDYBCACQagDaiABIAJB2ARqEL4DDBULIAJB2ARqIAEQrgMgAigC2AQiBEF/Rg0PIBEgGigCEDYCECARIBopAgg3AgggESAaKQIANwIADB4LIAJBqANqIAFBARC/AwwTCyACQagDaiABQQAQvwMMEgsgARDAAyABQQA6ALYBIAIgBikCADcDmAQgAiAGKAIINgKgBCACQQA2AvADIAJCgICAgBA3AugDIAFBAiABKAKUASIDIANBAk0bNgKUAQJAAkAgASgCjAEgASgCkAFBARC8A0E8RwRAIAJB8AJqIAFBACACQZgEahCyAyACKQL4AiEqIAIoAvQCIQUgAigC8AIiBEF/Rg0CIAIpAoADISsMAQsgARCvAyABEK8DIAJBADYC4AIgAkKAgICAEDcC2AICQANAAkAgEhCzAxC2AyABKAKMASIFIAEoApABIgMQqgMhCEUEQCAIQT5HDQEgARCvAyACKQLcAiEqIAIoAtgCIQUMGwsgCEElRwRAIAJB2AJqIAUgAxCqAxDXAiABEK8DDAILIAJB8AJqIAEgAkGYBGoQtQMgAigC9AIhBSACKALwAiIEQX9HBEAMAwUgAkHYAmogBRDXAgwCCwAL", + "CyACQfACakGyisMAQTwQBiAVIAIoAqAENgIIIBUgAikDmAQ3AgAgAigC8AIhBCACKAL0AiEFCyACKQKAAyErIAIpAvgCISogAigC2AIgAigC3AIQASAEQX9GDRcLQQAhA0EBIQcMFAtBAEEBEAEgAiAFNgLoAyACICo3AuwDICpCIIinIQMgKqchByAqQoCAgIAgVA0SIAcgA0EhEJcCRQ0SIAcgA0EhEKYCRQ0SIAJB8AJqIAFBAUEAIAJBmARqEMEDIAIpAvgCISogAigC9AIhCCACKALwAiIEQX9HBEAgAikCgAMhKyAFIQMgCCEFDBQLIAIgKjcC+AMgAiAINgL0AwwWCyABLQC6AUUNCgwPCyACQagDaiABQQEQwgMMDwsgAkGoA2ogAUEAEMIDDA4LIAsgBigCCDYCCCALIAYpAgA3AgAgAkEQNgL0AiACIAJBzANqNgLwAiACQdgEakH60MAAIAJB8AJqEAwgAiACKQLYBDcDqAMgAiACKQLgBDcDsAMgAiACKQLoBDcDuAMMDQsgChCrAw0KIAJBqANqIAEQwwMMDAsgChCrA0UEQCABLQC6AQ0LDAILIAEpApgBISogAS0AugENByABLQC2AUUEQCACIAYoAgg2AvgCIAIgBikCADcD8AIgAkHYBGpBspLDAEEsEAYgCyACKQPwAjcCACALIAIoAvgCNgIIIAIgAikC2AQ3A6gDIAIgAikC4AQ3A7ADIAIgAikC6AQ3A7gDDAwLIAJBBzoA2AQgAiAPNgL4AiACICo3A/ACIAEgD0EAIAIgAkHYBGogAkHwAmoQxAMMCAsgChCrAw0BIAEtALoBDQILIAJBqANqIAEQwwMMCQsgAkGoA2ogARDFAwwICyABKAKkASABKAKYAUciAyAKEMYDRXENBiADQQAgDiAHQQEQvANBIHJB+wBGG0UEQCACQagDaiABEMUDDAgLIAJB2ARqQYeBwwBBLxAGIAsgBikCADcCACALIAYoAgg2AgggAiACKQLYBDcD", + "qAMgAiACKQLgBDcDsAMgAiACKQLoBDcDuAMMBwsgAS0AugENBSACQagDaiABQQEQxwMMBgsgAkGoA2ogAUEAEMcDDAULIAFBAToAtgEgAiAGKAIINgLgBCACIAYpAgA3A9gEIAEgAkHYBGoiAxDIAyACIAYoAgg2AvgCIAIgBikCADcD8AIgARCvAyABQQEQyQMaIBUgBikCADcCACAVIAYoAgg2AgggCSACKQPwAjcCACAJIAIpA/gCNwIIIAkgAikDgAM3AhAgAkEOOgDYBCAYIAMQpgMMDwsgAUEBOgC5AQsgAkHYBGogARCuAyACKALYBCIEQX9HBEAgESACKALsBDYCECARIAIpAuQENwIIIBEgAikC3AQ3AgAMDQsgASABLQC6AUU6ALYBIAEQrwNBASENA0ACQAJAAkACQAJAIBIQswMiA0Egaw4EAQQEAgALIANBCmsOBAIDAwIDCyABEMoDQQAhDQwDCyABKAKQASEEIAEoAowBIQVBACEHA0ACQCACQdgEaiAFIAQQywMgAigC2AQiA0EBakECSQ0AAkAgA0EKaw4EAQAAAQALIAdBAWohByACKALcBCEFIAIoAuAEIQQMAQsLIAEgBDYCkAEgASAFNgKMASABIAEoApgBIAdqNgKYASABIAEoAqABIAdqNgKgAQwCCyABQQIgASgClAEiAyADQQJNGzYClAEgARC6A0EAIQ0gAS0AugENASABQQE6ALYBDAELCwJAIA1BAXFFDQAgAkGoBGpB/YzDAEETEAYgKCAGKAIINgIIICggBikCADcCACACKAKoBCIEQX9GDQAgESAgKAIQNgIQIBEgICkCCDcCCCARICApAgA3AgAMDQsgASgCjAEgASgCkAEQqgNBCUYEQCACIAYoAgg2AvgCIAIgBikCADcD8AIgAkHYBGpB3pLDAEEfEAYgCyACKQPwAjcCACALIAIoAvgCNgIIIAIgAikC2AQ3A6gDIAIgAikC4AQ3A7ADIAIgAikC6AQ3A7gDDAML", + "ICcgBigCCDYCCCAnIAYpAgA3AgAgAiAPNgL8BCACICo3AvQEIAJBDzoA2AQgGCACQdgEahCmAwwNCwJAIAEtALoBRQRAIAEtALYBRQRAIAJB2ARqQfiFwwBBNhAGIAsgBikCADcCACALIAYoAgg2AgggAiACKQLYBDcDqAMgAiACKQLgBDcDsAMgAiACKQLoBDcDuAMMBAsgGBCkAyIDRQ0BIAMtAABBHnFBEkcgD3INASADKAIkIARBAEhyDQEgAiADKAIkNgL4AiACIAMpAhw3A/ACIAJB2ARqQa6GwwBBHhAGIAsgAikD8AI3AgAgCyACKAL4AjYCCCACIAIpAtgENwOoAyACIAIpAuAENwOwAyACIAIpAugENwO4AwwDCyACQdgEakH7hsMAQSAQBiALIAYpAgA3AgAgCyAGKAIINgIIIAIgAikC2AQ3A6gDIAIgAikC4AQ3A7ADIAIgAikC6AQ3A7gDDAILIAIgBigCCDYCiAQgAiAGKQIANwOABCABEK8DIAIoAogEIQMgAkEGOgDYBCABIANBACACIAJB2ARqIgQgAkGABGoQxAMgAUEBEMkDIQUgAUECIAEoApQBIgMgA0ECTRs2ApQBAkAgBUUNACABKAKMASIFIAEoApABIgMQqgNBLUcNACAFIANBARC8AxCrA0UNACACIAYoAgg2AvgCIAIgBikCADcD8AIgBEHMhsMAQS8QBiALIAIpA/ACNwIAIAsgAigC+AI2AgggAiACKQLYBDcDqAMgAiACKQLgBDcDsAMgAiACKQLoBDcDuAMMAgsgAUEAEMkDGiABQQEgASgClAEiAyADQQFNGzYClAEgASgCjAEhBQJAAkACQCABKAKQASIDRQ0AIAUtAABBCmsOBAEAAAEACyAFIAMQzANFDQELIAEQzQMLIAJB2ARqIAEQrgMgAigC2AQiA0F/RwRAIBEgGigCEDYCECARIBopAgg3AgggESAaKQIANwIAIAIgAzYCqAMMAgsgAUEBOgC2ASAVIAYp", + "AgAiKjcCACAVIAYoAggiAzYCCCAJICo3AgAgAiADNgL4AiAJIAIpA/gCNwIIIAkgAikDgAM3AhAgAkENOgDYBCAYIAJB2ARqEKYDDAwLIAJBqANqIAEQwwMLIAIoAqgDIQQMCAsgAkHwAmogASAHIAMgAkGYBGoQwQMgAikC+AIhKiACKAL0AiEIIAIoAvACIgRBf0YNASACKQKAAyErIAUhAyAIIQULIAMgBxABDAMLIAIgCDYC9AMgAiAqNwL4AyACQegDahDOAyAqQv////8PVg0BIAJBADYC8AMgAkH0A2oQzgMMAQsgAiAqNwL4AyACIAU2AvQDCyASELMDEKsDDQEgAS0AugEEQCABKAKMASABKAKQARDMAw0CCyACQfACakHukcMAQcQAEAYgFSACKAKgBDYCCCAVIAIpA5gENwIAIAIoAvACIQQgAigC9AIhBSACKQL4AiEqIAIpAoADISsgAigC9AMgAigC+AMQASACKALoAyACKALsAxABCyACICs3A7gDIAIgKjcDsAMgAiAFNgKsAwwBCyAWIAYpAgA3AgAgFiAGKAIINgIIIAIgAigCoAQ2AogEIAIgAikDmAQ3A9ADIAIgAikDiAQ3A9gDIAIgAikDkAQ3A+ADIAIpAugDIS4gAjUC8AMhLSACNQL0AyErIAIpAvgDISogCSACKQPgAzcCECAJIAIpA9gDNwIIIAkgAikD0AM3AgAgAiAqNwLsBCACIC0gK0IghoQ3AuQEIAIgLjcC3AQgAkETOgDYBCAYIAJB2ARqEKYDQX8hBAsgAiAENgKoAwsgBEF/Rg0BCyAMIBEoAhA2AhAgDCARKQIINwIIIAwgESkCADcCAAwCCyAYEKQDIgMEQCADLQAAQQ1GDQELIAJB2ARqIAEgAkHIAmoQzwMgAigC2AQiBEF/Rg0AIAwgAigC7AQ2AhAgDCACKQLkBDcCCCAMIAIpAtwENwIADAELIAJBfzYCoAIMAQsLIBAgDCgCEDYCECAQIAwpAgg3Aggg", + "ECAMKQIANwIADAILQf8BIQcMAgsCQCABKAIcIgNFDQAgASADQQFrNgIcIAEgASgCGCIEQQFqIgUgASgCECIDQQAgAyAFTRtrNgIYIAIgASgCFCAEQTRsaiIFLwABOwGcAiACIAUtAAM6AJ4CIAIgBSkCCDcDiAIgAiAFKQIQNwOQAiACIAUoAhg2ApgCIAUoAgQhBCAFKAIcIQMgBS0AACEHIAIgBSgCMDYCgAIgAiAFKQIoNwP4ASACIAUpAiA3A/ABIAdB/wFGDQAgAUEAOgC3ASABIAEoAqwBQQFqNgKsASAHQQFGBEAgAUEBOgC1AQsgECACKQOIAjcCACAQIAIpA5ACNwIIIBAgAigCmAI2AhAgAiACLQCeAjoA1gEgAiACLwGcAjsB1AEgAiACKQPwATcDwAEgAiACKQP4ATcDyAEgAiACKAKAAjYC0AEgB0H+AUYNAQwCCyACIAEoAqABNgLgBCACIAEpApgBNwPYBCACQdgBakG4/MIAQSAQBiACIAIoAuAENgLsASACIAIpA9gENwLkASACKALYASEECyABKAJ0IAEoAngQBSABIAQ2AnQgASAQKQIANwJ4IAEgECkCCDcCgAEgASAQKAIQNgKIAQwBCyACIAItANYBOgCOASACIAIvAdQBOwGMASACIAIpA8ABNwNgIAIgAikDyAE3A2ggAiACKALQATYCcCACIBApAgA3A3ggAiAQKQIINwOAASACIBAoAhA2AogBIAdB/wFHDQEgASgCdCEECwJAAkAgBEF/Rg0AIAIgASgCiAE2ArwBIAIgASkCgAE3ArQBIAJBqAFqIAEoAnggASgCfBBCIAIoAqgBIgRBf0YNACAUIAJBrAFqIgEoAhA2AhAgFCABKQIINwIIIBQgASkCADcCAAwBCyACIAEoAqABNgLgBCACIAEpApgBNwPYBCACQZABakGU+MIAQQ4QBiACIAIoAuAENgKkASACIAIpA9gENwKcASACKAKQASEECyAAIAQ2AgAgACAUKQIA", + "NwIEIAAgFCkCCDcCDCAAIBQoAhA2AhQMAgsgFCACKQN4NwIAIBQgAikDgAE3AgggFCACKAKIATYCECACIAItAI4BOgAWIAIgAi8BjAE7ARQgAiACKQNgNwMAIAIgAikDaDcDCCACIAIoAnA2AhAgAiACLQAWOgDaBCACIAIvARQ7AdgEIAIgAigCEDYCKCACIAIpAwg3AyAgAiACKQMANwMYIAEgByADEKMDIB0Q7gIgASAHOgD8AiABIAQ2AoADIAEgAzYCmAMgASACLwHYBDsA/QIgASACLQDaBDoA/wIgASAUKQIANwKEAyABIBQpAgg3AowDIAEgFCgCEDYClAMgASACKQMYNwKcAyABIAIpAyA3AqQDIAEgAigCKDYCrAMLIABBfzYCACAAIB02AgQLIAJBkAVqJAALFAAgAEH8AmoQ7gIgAEH/AToA/AIL7wkBCn8jAEHgAGsiAyQAAkACQANAIANBPGogARD2AiADKAJAIQQgAygCPCIFQX9HBEAgACADKQJMNwIUIAAgAykCRDcCDCAAIAQ2AgggACAFNgIEIABBfjYCAAwCCyAELQAAQQVGBEAgARD3AgwBCwsgA0E8aiABEPYCIAMoAkAhBCADKAI8IgVBf0cEQCAAIAMpAkw3AhQgACADKQJENwIMIAAgBDYCCCAAIAU2AgQgAEF+NgIADAELAkACQAJAAkAgBC0AACIFQQFrDgQCAQEBAAsgBUEVRg0AIAINAgsjAEEwayICJAAgAkEIaiABEJ0DIAACfwJAIAIoAggiBEF/RwRAIAAgAigCHDYCGCAAIAIpAhQ3AhAgACACKQIMNwIIIAAgBDYCBAwBCyACQQhqIAEQ9gIgAigCDCEFIAIoAggiBEF/RwRAIAAgAikCGDcCFCAAIAIpAhA3AgwgACAFNgIIIAAgBDYCBAwBCyAFQRxqIQQgBS0AAEEERgRAIAAgBCkCEDcCPCAAIAQpAgg3AjQgACAEKQIANwIsIAJBBDYCCCABIAJBCGoQ/gIg", + "AUEDNgK8ASABEPcCIABBAToABEGDgICAeAwCCyACIAQoAgg2AiggAiAEKQIANwMgIAJBCGpB4/rCAEEmEAYgACACKQIINwIEIAIgAikDIDcCFCAAIAIpAhA3AgwgAiACKAIoNgIcIAAgAikCGDcCFAtBfgs2AgAgAkEwaiQADAILIAAgBCkCLDcCPCAAIAQpAiQ3AjQgACAEKQIcNwIsIAFBFTYCvAEgARCDAyABEPcCIABBgoCAgHg2AgAMAQsgAyAEKQIsNwMwIAMgBCkCJDcDKCADIAQpAhw3AyAgA0E8aiABEJ0DIAMoAjwiAkF/RwRAIAAgAygCUDYCGCAAIAMpAkg3AhAgACADKQJANwIIIABBfjYCACAAIAI2AgQMAQsgA0EENgI8IAEgA0E8ahD+AiABQQU2ArwBIAEoAuwBIgIEQCABQeQBaiEGIANB1ABqIAEoAugBIAIQQiADKAJYIgVBAmshAiADKAJcIgRBAWsiCCEJAkACQANAIAQgB2oiCkEBayILRQ0CIARFDQUCQCACIARqIgxBAWotAABBCkYEQCAHRQ0BIAwtAABBCkYNAwsgCUEBayEJIAJBAWshAiAHQQFrIQcMAQsLIANBCGogCCAFIARB9PfCABDkAiADQTxqIgIgAygCCCADKAIMEAYgASgClAIgASgCmAIQASABIAMoAkQ2ApwCIAEgAykCPDcClAIgAyAEIAUgBEGE+MIAEL8CIAIgAygCACADKAIEEAYgASgC5AEgASgC6AEQASAGIAMoAkQ2AgggBiADKQI8NwIADAELIANBGGogCkECayAFIARB1PfCABDkAiADQTxqIgIgAygCGCADKAIcEAYgASgClAIgASgCmAIQASABIAMoAkQ2ApwCIAEgAykCPDcClAIgA0EQaiALQQFqIAUgBEHk98IAEL8CIAIgAygCECADKAIUEAYgASgC5AEgASgC6AEQASAGIAMoAkQ2AgggBiADKQI8NwIACyADKAJUIAUQAQsgACADKQMw", + "NwI8IAAgAykDKDcCNCAAIAMpAyA3AiwgAEEAOgAEIABBg4CAgHg2AgALIANB4ABqJAAPCyAIQQBBxPfCABAqAAuyEgELfyMAQcADayIEJAAgBEF+NgIAIARBtAJqIAEQ9gIgBCgCuAIhBQJAAkAgBCgCtAIiBkF/RwRAIAAgBCkCxAI3AhQgACAEKQK8AjcCDCAAIAU2AgggACAGNgIEIABBfjYCAAwBC0EAIQYCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUtAABBEWsOAwABAgMLIAEQ+gIgBEEYaiICIAEQngMgBC0AGEERRg0MIAIQ7QJBsPTCAEEoQdj0wgAQPgALIARBjANqIAEQngMgBC0AjANBEkcNBSABIARBkANqEJ8DIQYgBEG0AmogARD2AiAEKAK4AiEFIAQoArQCIgdBf0cEQCAAIAQpAsQCNwIUIAAgBCkCvAI3AgwgACAFNgIIIAAgBzYCBCAAQX42AgAMDQsgBS0AAEETRw0BIARBzABqIAEQngMgBC0ATEETRw0GIAQoAlAhBSAEQbQCaiABKALAAyABKALEAyAEQagDaiAEKAJUIgcgBCgCWCAEQdwAahCgAyAEIAQpArgCNwOAASAEIAQpAsACNwOIASAEIAQpAsgCNwOQASAEKAK0AgRAIAAgBCkDkAE3AhQgACAEKQOIATcCDCAAIAQpA4ABNwIEIABBfjYCACAFIAcQAQwNCyAEEPMCIAQgBCkDkAE3AxAgBCAEKQOIATcDCCAEIAQpA4ABNwMAIAUgBxABDAELIAQgBSkCLDcDqAEgBCAFKQIkNwOgASAEIAUpAhw3A5gBIARBtAFqIAEQngMgBC0AtAFBE0cNByAEKAK4ASEFIARBtAJqIgYgASgCwAMgASgCxAMgBEGYAWogBCgCvAEiByAEKALAASAEQcQBahCgAyAEIAQpArgCNwPoASAEIAQpAsACNwPwASAEIAQpAsgCNwP4ASAEKAK0Ag0BIAQQ8wIgBCAEKQP4", + "ATcDECAEIAQpA/ABNwMIIAQgBCkD6AE3AwAgBiABEPYCIAQoArgCIQggBCgCtAIiBkF/RwRAIAAgBCkCxAI3AhQgACAEKQK8AjcCDCAAIAg2AgggACAGNgIEDAMLQQAhBiAILQAAQRJGBEAgBEGAAmogARCeAyAELQCAAkESRw0JIAEgBEGEAmoQnwMhBgsgBSAHEAELIARBtAJqIAEQ9gIgBCgCuAIhBSAEKAK0AiIHQX9GDQIgACAEKQLEAjcCFCAAIAQpArwCNwIMIAAgBTYCCCAAIAc2AgQgAEF+NgIADAoLIAAgBCkD+AE3AhQgACAEKQPwATcCDCAAIAQpA+gBNwIECyAAQX42AgAgBSAHEAEMCAsCQAJAAkACQAJAAkACQCAFLQAAQQZrDg8ABAwBDAIMBQwMDAwMDAYMCyACDQIMCwsgACAFKQIsNwI8IAAgBSkCJDcCNCAAIAUpAhw3AiwgAUEBOgDSAyABQQw2ArwBIAEQgwMgACAGNgIcIABBh4CAgHg2AgAgACAEKQMQNwIUIAAgBCkDCDcCDCAAIAQpAwA3AgQMDQsgACAFKQIsNwI8IAAgBSkCJDcCNCAAIAUpAhw3AiwgAUEBOgDSAyABQRE2ArwBIAEQgwMgACAGNgIcIABBiYCAgHg2AgAgACAEKQMQNwIUIAAgBCkDCDcCDCAAIAQpAwA3AgQMDAsgACAFKQIsNwI8IAAgBSkCJDcCNCAAIAUpAhw3AiwgAUEAOgDSAyABQQY2ArwBIAEQoQMgACAGNgIcIABBh4CAgHg2AgAgACAEKQMQNwIUIAAgBCkDCDcCDCAAIAQpAwA3AgQMCwsgAkUNByAAIAUpAiw3AjwgACAFKQIkNwI0IAAgBSkCHDcCLCABQQA6ANIDIAFBCTYCvAEgARChAyAAIAY2AhwgAEGJgICAeDYCACAAIAQpAxA3AhQgACAEKQMINwIMIAAgBCkDADcCBAwKCyADRQ0GIAAgBCkDADcCBCAAIAQpAwg3AgwgACAE", + "KQMQNwIUIAAgBjYCHCAAQYeAgIB4NgIAIAAgBSkCLDcCPCAAIAUpAiQ3AjQgACAFKQIcNwIsIAFBADoA0gMgAUEINgK8AQwJCyABEPoCIARBtAJqIAEQngMgBC0AtAJBFEcNAiAAIAQpAuACNwI8IAAgBCkC2AI3AjQgACAEKQLQAjcCLCAEIAQpArgCNwPoAiAEIAQoAsACNgLwAiAELQC1AiECIAEQgwMgBCAEKQMQNwKEAyAEIAQpAwg3AvwCIAQgBCkDADcC9AIgACAEQegCakEk/AoAACAAIAI6ACggACAGNgIkDAgLQbD0wgBBKEH49MIAED4AC0Gw9MIAQShB6PTCABA+AAtBsPTCAEEoQaj1wgAQPgALQbD0wgBBKEGY9cIAED4AC0Gw9MIAQShBiPXCABA+AAsgBUEcaiECAkAgBg0AIAQoAgBBfkcNACAEIAIoAgg2AqABIAQgAikCADcDmAEgBEG0AmpBuPXCAEE4EAYgAEF+NgIAIAAgBCkCtAI3AgQgBCAEKQOYATcCwAIgACAEKQK8AjcCDCAEIAQoAqABNgLIAiAAIAQpAsQCNwIUDAILIAAgAikCEDcCPCAAIAIpAgg3AjQgACACKQIANwIsIAEQ+gIgAEEAOgAoIAAgBjYCJCAAQQA2AgggAEKAgICAEDcCACAAIAQpAxA3AhwgACAEKQMINwIUIAAgBCkDADcCDAwCCyAEQTRqIQcgBCgCICEKIAQoAhwgAAJ/AkAgASgCsAMiCEUNACAEKAIkIQwgASgCtAMhCQNAIAhBBGohBSAILwG2ASIDQQxsIQZBfyECAkADQCAGRQRAIAMhAgwCCyAFKAIEIQ0gBSgCCCEOIAZBDGshBiACQQFqIQIgBUEMaiEFAkAgCiAMIA0gDhDgAUH/AXEOAgABAgsLIAggAkECdGooAogBIQIgARCDAyAAIAI2AgQgACAHKQIQNwI8IAAgBykCCDcCNCAAIAcpAgA3AixBhYCAgHgMAwsgCUUNASAJQQFr", + "IQkgCCACQQJ0aigCuAEhCAwACwALIARBtAJqQYj0wgBBKBAGIAAgBCkCtAI3AgQgBCAHKQIANwLAAiAAIAQpArwCNwIMIAQgBygCCDYCyAIgACAEKQLEAjcCFEF+CzYCACAKEAULIAQQ8wILIARBwANqJAALXQECfwJAIAAoAtQBIgEEQCAAIAFBAWsiATYC1AEgACgC0AEgAUEEdGoiASgCACICQX9HDQELQfj7wgAQXQALIAAgAjYCvAEgACABKQIENwLAASAAIAEoAgw2AsgBC0gCAn8BfiMAQRBrIgEkACAAKQIAIQMgAEEANgIAIAAoAgghAiAAQQA2AgggASACNgIMIAEgAzcCBCABQQRqEPACIAFBEGokAAuVBQECfyMAQTBrIgMkAAJAIAIEQCADQRhqIAEQ9gIgAygCGCICQX9HBEAgACADKQIgNwIMIAAgAykCKDcCFCAAIAMoAhw2AgggACACNgIEIABBfjYCAAwCCyABEPcCCyADQRhqIAEQ9gIgAygCHCEEIAMoAhgiAkF/RwRAIAAgAykCKDcCFCAAIAMpAiA3AgwgACAENgIIIAAgAjYCBCAAQX42AgAMAQsgBEEcaiECAkAgBC0AACIEQQhHBEAgBEENRg0BIAMgAigCCDYCCCADIAIpAgA3AwAgA0EYakGe+sIAQcUAEAYgAEF+NgIAIAAgAykCGDcCBCADIAMpAwA3AiQgACADKQIgNwIMIAMgAygCCDYCLCAAIAMpAig3AhQMAgsgACACKQIQNwI8IAAgAikCCDcCNCAAIAIpAgA3AiwgARD6AiABEPcCIABBiICAgHg2AgAMAQsgAyACKQIQNwMQIAMgAikCCDcDCCADIAIpAgA3AwAgASgC7AEhAiABEPcCIANBGGogASACEP0CAkAgAygCGCICQX9HBEAgACADKAIsNgIYIAAgAykCJDcCECAAIAMpAhw3AgggACACNgIEDAELIANBGGogARD2AiADKAIcIQIgAygCGCIEQX9HBEAg", + "ACADKQIoNwIUIAAgAykCIDcCDCAAIAI2AgggACAENgIEDAELIAItAAAiAkEIRiACQQ1GckUEQCADQQc2AhggASADQRhqEP4CIAAgAUEBQQAQ+QIMAgsgAUEHNgK8ASAAIAMpAwA3AiwgACADKQMINwI0IAAgAykDEDcCPCAAQQA6ACggAEEANgIkIABCgICAgGA3AgggAEKAgICAEDcCAAwBCyAAQX42AgALIANBMGokAAvcAgEGfyMAQTBrIgMkAAJAIAJFBEAgAEF/NgIADAELIANBGGogARD2AiADKAIcIQQgAygCGCIFQX9HBEAgACADKQIoNwIQIAAgAykCIDcCCCAAIAQ2AgQgACAFNgIADAELIAQtAABBHnFBBkcEQCAAQX82AgAMAQsgASgC7AEhBCABQQA2AuwBIAEoAuQBIAEoAugBIQUgAUKAgICAEDcC5AEgA0EQaiAEIAIgAiAESxsiByAFIARBzPnCABDkAiADQRhqIgggAygCECADKAIUEAYgASgCiAIgASgCjAIQASABIAMoAiA2ApACIAEgAykCGDcCiAIgAiAESQRAIANBCGogB0EBaiAFIARB3PnCABC/AiAIIAMoAgggAygCDBAGIAEoAuQBIAEoAugBEAEgAUHkAWoiASADKAIgNgIIIAEgAykCGDcCAAsgAEF/NgIAIAUQAQsgA0EwaiQAC0oBAX8gACgC1AEiAiAAKALMAUYEQCAAQcwBahDQAwsgACACQQFqNgLUASAAKALQASACQQR0aiIAIAEpAgA3AgAgACABKQIINwIIC98EAQJ/IwBBMGsiAyQAAkAgAgRAIANBCGogARD2AiADKAIIIgJBf0cEQCAAIAMpAhA3AgwgACADKQIYNwIUIAAgAygCDDYCCCAAIAI2AgQgAEF+NgIADAILIAEQ9wILIANBCGogARD2AiADKAIMIQICQCADKAIIIgRBf0cEQAwBCwJAAkACQCACLQAAIgRBD2sOAgIBAAsgBEEIRwRAIAMgAigC", + "JDYCKCADIAIpAhw3AyAgA0EIakGS+cIAQTgQBiAAQX42AgAgACADKQIINwIEIAMgAykDIDcCFCAAIAMpAhA3AgwgAyADKAIoNgIcIAAgAykCGDcCFAwECyAAIAIpAiw3AjwgACACKQIkNwI0IAAgAikCHDcCLCABEPoCIAEQgwMgARD3AiAAQYqAgIB4NgIADAMLIABBADoAKCAAQQA2AiQgAEKAgICAYDcCCCAAQoCAgIAQNwIAIAAgAikCLDcCPCAAIAIpAiQ3AjQgACACKQIcNwIsIAFBCzYCvAEMAgsgARD3AiADQQhqIAEQ9gIgAygCDCECIAMoAggiBEF/RwRADAELIAItAAAiBEEQTUEAQQEgBHRBgIIGcRtFBEAgA0ELNgIIIAEgA0EIahD+AiAAIAFBAUEBEPkCDAILIABBADoAKCAAQQA2AiQgAEKAgICAYDcCCCAAQoCAgIAQNwIAIAAgAikCLDcCPCAAIAIpAiQ3AjQgACACKQIcNwIsIAFBCzYCvAEMAQsgACADKQIYNwIUIAAgAykCEDcCDCAAIAI2AgggACAENgIEIABBfjYCAAsgA0EwaiQAC5AFAQJ/IwBBMGsiAyQAAkACQAJAAkAgAkUEQCADQQhqIAEQ9gIgAygCDCECIAMoAggiBEF/Rw0DAkACQCACLQAAQQprDgUDAAAAAQALIAMgAigCJDYCKCADIAIpAhw3AyAgA0EIakHs+cIAQTIQBiAAQX42AgAgACADKQIINwIEIAMgAykDIDcCFCAAIAMpAhA3AgwgAyADKAIoNgIcIAAgAykCGDcCFAwFCyABEPcCDAILIANBCGogARD2AiADKAIIIgJBf0cEQCAAIAMpAhA3AgwgACADKQIYNwIUIAAgAygCDDYCCCAAIAI2AgQgAEF+NgIADAQLIAEQ9wIgA0EIaiABEPYCIAMoAgwhAiADKAIIIgRBf0cNAiACLQAAQQpHDQELIAAgAikCLDcCPCAAIAIpAiQ3AjQgACACKQIcNwIs", + "IAEQ+gIgARCDAyABEPcCIABBiICAgHg2AgAMAgsgA0EIaiABEPYCIAMoAgwhAiADKAIIIgRBf0cEQCAAIAMpAhg3AhQgACADKQIQNwIMIAAgAjYCCCAAIAQ2AgQgAEF+NgIADAILAkAgAi0AACIEQQpHBEAgBEEPRg0BIANBDTYCCCABIANBCGoQ/gIgACABQQBBABD5AgwDCyAAIAIpAiw3AjwgACACKQIkNwI0IAAgAikCHDcCLCABEPoCIAEQgwMgARD3AiAAQYiAgIB4NgIADAILIAAgAikCLDcCPCAAIAIpAiQ3AjQgACACKQIcNwIsIAFBDjYCvAEgARD3AiAAQQA2AhwgAEKJgICAaDcCACABQQE6ANIDDAELIAAgAykCGDcCFCAAIAMpAhA3AgwgACACNgIIIAAgBDYCBCAAQX42AgALIANBMGokAAvYBwEDfyMAQUBqIgMkAAJAAkACQAJAAkACQCACRQRAIANBGGoiBSABEPYCIAMoAhwhAiADKAIYIgRBf0cNBSACLQAAQQxGDQMgAyACKQIsNwMQIAMgAikCJDcDCCADIAIpAhw3AwAgBSABEPYCIAMoAhwhAiADKAIYIgRBf0cEQCAAIAMpAig3AhQgACADKQIgNwIMIAAgAjYCCCAAIAQ2AgQgAEF+NgIADAcLIAItAABBDkcNASABEPcCDAILIANBGGogARD2AiADKAIYIgJBf0cEQCAAIAMpAiA3AgwgACADKQIoNwIUIAAgAygCHDYCCCAAIAI2AgQgAEF+NgIADAYLIAEQ9wIgA0EYaiABEPYCIAMoAhwhAiADKAIYIgRBf0cNBCACLQAAQQxGDQIgAyACKQIsNwMQIAMgAikCJDcDCCADIAIpAhw3AwAMAQsgAyACKAIkNgI4IAMgAikCHDcDMCADQRhqQdT4wgBBPhAGIABBfjYCACAAIAMpAhg3AgQgAyADKQMwNwIkIAAgAykCIDcCDCADIAMoAjg2AiwgACADKQIoNwIUDAQLIANB", + "GGogARD2AiADKAIcIQIgAygCGCIEQX9HBEAgACADKQIoNwIUIAAgAykCIDcCDCAAIAI2AgggACAENgIEIABBfjYCAAwECwJAAkACQCACLQAAQQxrDgUEAAACAQALIANBFDYCGCABIANBGGoQ/gIgACABQQBBABD5AgwFCyAAQQA6ACggAEEANgIkIABCgICAgGA3AgggAEKAgICAEDcCACAAIAIpAiw3AjwgACACKQIkNwI0IAAgAikCHDcCLCABQRM2ArwBDAQLIAEQ9wIgA0EYaiABEPYCIAMoAhwhAiADKAIYIgRBf0cEQCAAIAMpAig3AhQgACADKQIgNwIMIAAgAjYCCCAAIAQ2AgQgAEF+NgIADAQLIAItAAAiBEEQTUEAQQEgBHRBgKAFcRtFBEAgA0ETNgIYIAEgA0EYahD+AiAAIAFBAEEAEPkCDAQLIABBADoAKCAAQQA2AiQgAEKAgICAYDcCCCAAQoCAgIAQNwIAIAAgAikCLDcCPCAAIAIpAiQ3AjQgACACKQIcNwIsIAFBEzYCvAEMAwsgAyACKQIsNwMQIAMgAikCJDcDCCADIAIpAhw3AwALIAEQ+gIgARCDAyABEPcCIABBioCAgHg2AgAgACADKQMQNwI8IAAgAykDCDcCNCAAIAMpAwA3AiwMAQsgACADKQIoNwIUIAAgAykCIDcCDCAAIAI2AgggACAENgIEIABBfjYCAAsgA0FAayQAC+0DAQJ/IwBBMGsiAyQAAkAgAkUEQCADQRhqIAEQ9gIgAygCHCECIAMoAhgiBEF/RwRAIAAgAykCKDcCFCAAIAMpAiA3AgwgACACNgIIIAAgBDYCBCAAQX42AgAMAgsgAyACKQIcNwMAIAMgAikCJDcDCCADIAIpAiw3AxACQCACLQAAQRBHDQAgARD3AiADQRhqIAEQ9gIgAygCHCECIAMoAhgiBEF/RwRAIAAgAykCKDcCFCAAIAMpAiA3AgwgACACNgIIIAAgBDYCBCAAQX42AgAMAwsC", + "QCACLQAAQQxrDgMBAAEACyADQRI2AhggASADQRhqEP4CIAAgAUEAQQAQ+QIMAgsgAUESNgK8ASAAIAMpAwA3AiwgACADKQMINwI0IAAgAykDEDcCPCAAQQA6ACggAEEANgIkIABCgICAgGA3AgggAEKAgICAEDcCAAwBCyADQRhqIAEQ9gIgAygCHCECIAMoAhgiBEF/RwRAIAAgAykCKDcCFCAAIAMpAiA3AgwgACACNgIIIAAgBDYCBCAAQX42AgAMAQsgAEEAOgAoIABBADYCJCAAQoCAgIBgNwIIIABCgICAgBA3AgAgACACKQIsNwI8IAAgAikCJDcCNCAAIAIpAhw3AiwgAUESNgK8AQsgA0EwaiQAC8wBAgR/A34jAEEwayIBJAAgACgC7AEhAiAAQQA2AuwBIAApAuQBIQUgAEKAgICAEDcC5AEgACkC8AEhBiAAQoCAgIAQNwLwASAAKAL4ASEDIABBADYC+AEgACgChAIhBCAAQQA2AoQCIAApAvwBIQcgAEKAgICAEDcC/AEgASACNgIQIAEgBTcDCCABIAY3AhQgASADNgIcIAEgBzcDICABIAQ2AiggAEGUAmoiAhDqAiACIAFBCGpBJPwKAAAgAEEANgKQAiABQTBqJAALeAEBfyMAQTBrIgIkACACIAAoAhRBAWo2AgwgAkEENgIsIAJBBDYCJCACIABBEGo2AiAgAkEENgIcIAIgAEEMajYCGCACQQM2AhQgAiAANgIQIAIgAkEMajYCKCABKAIAIAEoAgRBmIjAACACQRBqEDkgAkEwaiQACywAAn8gACgCAC0AAEEBcUUEQCABQYzkwgBBBRArDAELIAFB7ezCAEEEECsLCwwAIAAoAgAgARCrAQtUAQF/IwBBEGsiAiQAAn8gACgCAEF+RwRAIAIgADYCDCABQanbwwBBBCACQQxqQQgQSgwBCyABKAIAQaXbwwBBBCABKAIEKAIMEQQACyACQRBqJAALlQICA34HfyAAKAIMRQRAQQAP", + "CyAAKQMQIAApAxggASgCBCIHIAEoAggiCBCOAyECIAAoAgQiBSACp3EhASACQhmIQv8Ag0KBgoSIkKDAgAF+IQQgACgCACEAA0AgACABaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyECAkACQANAIAJQIgZFBEAgByAIIAAgAnqnQQN2IAFqIAVxIglBBHRrIgpBDGsoAgAgCkEIaygCABCWAw0CIAJCAX0gAoMhAgwBCwsgAyADQgGGg0KAgYKEiJCgwIB/g1ANAQtBAEEAIAAgCUEEdGsgBhtBBGsgBhsPCyABIAtBCGoiC2ogBXEhAQwACwALqQIBBH8jAEFAaiICJAACQAJAIAEEQCACQQM2AjQgAkEDNgIsIAIgATYCKCACIAFBDGo2AjAgAkEcakGAgMAAIAJBKGoiBBAMIAJBCGpBzN7CAEESIAIoAiAiASACKAIkIgMQmgICQCACKAIIIgUEQCACKAIMIQMgAiAFNgI4IAIgAzYCPCACQQI2AiwgAiACQThqNgIoIAJBEGpB+IDAACAEEAwMAQsgAkEQaiABIAMQBgsgAigCHCABEAEgAigCFCEBIAIoAhgiA0UNASABIANBwPbCAEEBEBINASAAIAIoAhg2AgggACACKQIQNwIAIABBATYCDAwCCyAAQQA2AgwgAEF/NgIADAELIABBADYCDCAAQX82AgAgAigCECABEAELIAJBQGskAAvbAQECfyMAQSBrIgMkAAJAIAJFDQAgA0EEagJ/IAAoAugCIAJNBEBBACECQQEMAQsgACgC5AIgAkEMbGoiBCgCCCECIAQoAgQLIAIQBiADKAIMIgIEQCADQRBqIgQgAygCCCACEEIgACgC3AQiAkEEaigCACACQQhqKAIAIAEQ4QIiAigCMCACQTRqKAIAEAEgAiADKAIYNgI4IAIgAykCEDcCMCADIAMoAgw2AhggAyADKQIENwMQIABB6ABqIAQgARCPAwwBCyADKAIEIAMo", + "AggQAQsgA0EgaiQAC2QBA38jAEEQayIDJAAgA0EIaiACQQRBBBAHIAMoAgghBCADKAIMIQUgAEEANgIIIAAgBTYCBCAAIAQ2AgAgAgRAIAJBAnQiBARAIAUgASAE/AoAAAsgACACNgIICyADQRBqJAAL7QIBB38jAEEwayICJAACQCABQQBOBEAgAkEQakEKQQFBARAHIAJBADYCLCACIAIpAxA3AiQMAQsgAkEIakELQQFBARAHIAIgAikDCDcCJCACQQA2AiwgAkEkakEtENcCQQAgAWshAQtBCiEDIAEiBEHoB08EQANAIAJBGmogA2oiBUEEayAEIgYgBEGQzgBuIgRBkM4AbGsiB0H//wNxQeQAbiIIQQF0LwDxiEE7AAAgBUECayAHIAhB5ABsa0H//wNxQQF0LwDxiEE7AAAgA0EEayEDIAZB/6ziBEsNAAsLIARBCUsEQCADQQJrIgMgAkEaamogBCAEQf//A3FB5ABuIgRB5ABsa0H//wNxQQF0LwDxiEE7AAALQQAgASAEG0UEQCADQQFrIgMgAkEaamogBEEBdC0A8ohBOgAACyACQSRqIAJBGmogA2pBCiADaxAKIAAgAigCLDYCCCAAIAIpAiQ3AgAgAkEwaiQAC7YYAgd/BH4jAEGQAmsiAyQAAkACQCACRQRAQc4AIQUMAQsCQCABLQAAIgRBPGsiBUEdTUEAQQEgBXRBgYiwiAJxG0UEQCAEQeYAayIFQRhLQQEgBXRBgYahCHFFcg0BC0HNACEFDAELQdMAIQUCQAJAIARBK2sOBAIAAgEACyAEQTBrQf8BcUEKTwRAQePfwgAhBEEFIQYMAwtBxAAhBQwBC0EuIQULQYbkwgAhBEEGIQYgASACQe3swgBBBBASDQAgASACQaTTwwBBBBASDQAgASACQajTwwBBBBASDQAgASACQYzkwgBBBRASDQAgASACQazTwwBBBRASDQAgASACQbHTwwBBBRASDQBBpeDCACEEIAEgAkEBQQAQEg0A", + "IAEgAkG208MAQQEQEg0AIAEgAkHg4MIAQQQQEg0AIAEgAkG308MAQQQQEg0AIAEgAkG708MAQQQQEg0AQaHfwgAhBEEHIQYgASACQZybwwBBBBASDQAgASACQb/TwwBBBBASDQAgASACQcPTwwBBBBASDQAgASACQYObwwBBBBASDQAgASACQcfTwwBBBBASDQAgASACQcvTwwBBBBASDQAgASACQc/TwwBBBRASDQAgASACQdTTwwBBBRASDQAgASACQdnTwwBBBRASDQAgASACQZSbwwBBBRASDQAgASACQd7TwwBBBRASDQAgASACQePTwwBBBRASDQAgASACQdabwwBBAhASDQAgASACQejTwwBBBBASDQAgASACQeHfwgBBAhASBEBBoJPDACEEDAELQePfwgAhBEEFIQYgBUHTAEYgBUHEAEZyRQRAIAVBLkcNASADQYACaiABIAIQkANB49/CAEGh38IAIAMpA4ACUCIBGyEEQQVBByABGyEGDAELQQAhBAJAAn8CQAJAAkACQAJAAkACQANAIAIgBEYNASABIARqLQAAQTBrQf8BcUEJTQRAIARBAWohBAwBCwsgBEEERw0AIAEtAARBLUcNACADQYACaiIIIAEgAkEAQQRBBBCRAyADKAKAAkUNACADKAKIAiIFIAJPDQAgASAFai0AAEEtRw0AIAMoAoQCIQQgCCABIAIgBUEBakEBQQIQkQMgAygCgAJFDQAgAygCiAIiBSACTw0AIAEgBWotAABBLUcNACADKAKEAiEGIAggASACIAVBAWpBAUECEJEDIAMoAoACRSAGQQFrIgVBC0tyDQAgAygChAIiCEUNACADKAKIAiEHAn9B/R8gBXZBAXEgBUELTXFFBEAgBEEDcUUEQEEdIARB5ABwDQIaC0EcQR0gBEGQA3AbDAELIAUtAPTdQwsgCEkNAEH4rsMAIQRBCyEGIAIgB0YNCSACIAdNDQECQAJAIAEgB2otAAAiBUEgRwRAIAVB1ABHIAVB", + "9ABHcQ0DIANB4AFqIAEgAiAHQQFqEJIDIAMoAuABQQFxRQ0DIAMoAuQBIgUgAk8NAyABIAVqLQAAIgdBK2sOAwIDAgELIANB6AFqIAEgAiAHQQFqEJIDIAMoAugBQQFHDQIgAygC7AEgAkcNAgwLCyAHQdoARyAFQQFqIAJHcg0BDAoLIANB2AFqIAVBAWogASACQZTTwwAQtwEgAygC3AFBBUcNACADKALYASIFLQAAQTBrQf8BcUEJSw0AIAUtAAFBMGtB/wFxQQlLDQAgBS0AAkE6Rw0AIAUtAANBMGtB/wFxQQlLDQAgBS0ABEEwa0H/AXFBCkkNCQsgA0H0AWogASACQd8AQQFBABC+AiADKAL4ASEHIAMoAvwBIgVFBEBBACEGQQAhBQwEC0GM1MMAIQEgBSECAkACQAJAIAciBC0AAEEraw4DAQIAAgtBASEJQZzUwwAhAQsgA0HQAWpBASAHIAUgARC/AiADKALUASICRQ0DIAMoAtABIQQLIANBgAJqIAQgAhC8AiADQcgBakHEm8MAQQIgAygChAIiCCADKAKIAiIBEJoCIAMoAsgBIgYEQEEQIQQgAygCzAEhAQwCCyADQcABakHGm8MAQQIgCCABEJoCQQghBCADKALAASIGBEAgAygCxAEhAQwCCyADQbgBakGs1MMAQQIgCCABEJoCIAMoArgBIgYEQCADKAK8ASEBQQIhBAwCCwJAIAFBAk8EQCAIIAFBMBCXAg0BC0EKIQQgCCEGDAILIANBsAFqQQEgCCABQbDUwwAQvwIgAygCtAEhASADKAKwASEGDAELIAcgAkH808MAECoACwJAIAFFDQBBACECA0AgASACRwRAIANBqAFqIAIgBmotAAAgBBAWIAJBAWohAiADKAKoAUEBRg0BDAILCwJAAkAgCUUEQCAGLQAAIQICQCABQQFHDQAgAkEraw4DBAAEAAsgBiACQStGIgJqIQYgASACayICQRFJBEADQCACRQ0DIANBgAFqIAYtAAAg", + "BBAWIAMoAoABQQFHDQUgBkEBaiEGIAJBAWshAgwACwALIAStIQwDQCACRQ0CIANBkAFqIApCACAMQgAQ/gcgAykDmAFCAFINBCADKQOQASELIANBiAFqIAYtAAAgBBAWIAMoAogBQQFHDQQgBkEBaiEGIAJBAWshAiALIAsgAzUCjAF8IgpYDQALDAMLIAYtAAAhAgJAAkACQAJ+AkAgAUEBRgRAIAJBK2sOAwgBCAELAkACQAJAIAJBK2sOAwECAAILIAFBAWshAiAGQQFqIQYgAUEhSQ0EA0AgAkUNByADQQA2AnwgA0HgAGogCyAKIAStIANB/ABqEP0HIAMoAnwNCiADKQNoIQsgAykDYCEMIANB2ABqIAYtAAAgBBAWIAMoAlhBAUcNCiALIAsgCyAMIAM1AlwiDVStfSIKhYNCAFMNCiAGQQFqIQYgDCANfSELIAJBAWshAgwACwALIAFBAWshASAGQQFqIQYLIAFBIE8NAyAErQwBC0EBIQEgBK0LIQwDQCABRQ0DIANBEGogBi0AACAEEBYgAygCEEEBRw0GIAMoAhQhAiADIAsgCiAMQgAQ/gcgBkEBaiEGIAFBAWshASADKQMIIAMpAwAiCiACrXwiCyAKVK18IQoMAAsACwNAIAJFDQIgA0HQAGogBi0AACAEEBYgAygCUEEBRw0FIAMoAlQhASADQUBrIAsgCiAErUIAEP4HIAZBAWohBiACQQFrIQIgAykDQCIKIAGtIgx9IQsgAykDSCAKIAxUrX0hCgwACwALA0AgAUUNASADQQA2AjwgA0EgaiALIAogBK0gA0E8ahD9ByADKAI8DQQgAykDKCEMIAMpAyAhCiADQRhqIAYtAAAgBBAWIAMoAhhBAUcNBCAMQn+FIAwgDCAKIAM1Ahx8IgsgClStfCIKhYNCAFMNBCAGQQFqIQYgAUEBayEBDAALAAsgAygCgAIgCBABIAtCAX1CAFkgCiALUK19IgpCAFMgClAbDQEMAwsgAygCgAIgCBAB", + "C0EFIQZBnN/CAAwFCyADKAKAAiAIEAELIActAABBK2siAUH9AXFFIgYgBU8EQEEBIQZBACEJQQEhBQwBCyAGIAdqLQAAQS5HBEBBASEJDAELQQFBAiABQf0BcRsiASECA0ACQCACIAVGBEAgBSECDAELIAIgB2otAABBMGtB/wFxQQlLDQAgAkEBaiECDAELCyABIAJHDQEMBAsgBiAFIAUgBkkbIQQgBiEBA0AgASICIARGBEAgCUUNBQwDCyACQQFqIQEgAiAHai0AACIIQTBrQf8BcUEKSQ0ACyACIAZGDQMgCEEuRw0AIAUgASABIAVJGyEEA0AgASAFTw0CIAEgB2ogAUEBaiEBLQAAQTBrQf8BcUEKSQ0ACyABQQFrIQILAkAgAiAFTw0AIAIgB2otAABBIHJB5QBHDQACQCACQQFqIgEgBU8NAAJAIAEgB2otAABBK2sOAwABAAELIAJBAmohAQsgASAFIAEgBUsbIQQgASECA0ACQCACIARHBEAgAiAHai0AAEEwa0H/AXFBCU0NASACIQQLIAEgBEYNBQwDCyACQQFqIQIMAAsACyACIQQLIAQgBUcNASADQYACaiAHIAUQkAMgAygCgAJFDQFBByEGQaHfwgALIQQgAygC9AEgBxABDAELIAMoAvQBIAcQAUEFIQZB49/CACEECyAAIAY2AgQgACAENgIAIANBkAJqJAALpgEBAn8jAEHQAGsiBCQAIARCADcDOCAEQgA3A0AgBCABNwMwIAQgAULzytHLp4zZsvQAhTcDICAEIAFC7d6R85bM3LfkAIU3AxggBCAANwMoIAQgAELh5JXz1uzZvOwAhTcDECAEIABC9crNg9es27fzAIU3AwggBEEIaiIFIAIgAxCOASAEQf8BOgBPIAUgBEHPAGpBARCOASAFEIwBIARB0ABqJAALqwICBn8CfiMAQSBrIgMkACAAKQMQIAApAxggASgCBCABKAIIEI4DIQkgAyABNgIUIAAoAghFBEAgACAAQRBq", + "EJMDCyADIANBFGo2AhggAyAANgIcIAMgACgCACAAKAIEIAkgA0EYakEXEJUDIAAoAgAhBCADKAIEIQUCQCADKAIAQQFGBEAgBCAFaiIGLQAAIQcgASgCCCEIIAEpAgAhCiAGIAmnQRl2IgE6AAAgBCAAKAIEIAVBCGtxakEIaiABOgAAIAAgACgCDEEBajYCDCAAIAAoAgggB0EBcWs2AgggBCAFQQR0ayIAQRBrIgEgCjcCACABIAg2AgggAEEEayACNgIADAELIAQgBUEEdGtBBGsgAjYCACABKAIAIAEoAgQQAQsgA0EgaiQAC6gGAgd/AXwjAEEwayIFJAAgBUEIaiABIAIQvAIgBSAFKAIMIgcgBSgCECIBQquAgIDQBRCjAgJAAkACQAJAIAEgBSgCBCIDa0EBTQRARAAAAAAAAPB/IQogByABQS0QlwIhCAJAIAUoAgAiBCADQfiawwBBAxASDQAgBCADQfuawwBBCBASDQBEAAAAAAAA+H8hCiAEIANBmZvDAEEDEBINACADRQ0CIAQgA0HfABC9AkUEQCAFQRRqIAQgAxAGDAULQQAhAgJAA0AgAyACIgFGDQEgAUEBaiECIAEgBGoiBi0AAEHfAEcNAAJAIAFFDQAgAUEBayIBIANPDQYgAiADTw0AIAZBAWstAABBMGtB/wFxQQlLDQAgBkEBai0AAEEwa0H/AXFBCkkNAQsLIABCADcDAAwGCyAFQRRqIAQgA0HfAEEBQQAQvgIMBAsgAEIBNwMAIAAgCpogCiAIGzkDCAwECyAAQgA3AwAMAwsgAEIANwMADAILIAEgA0Hs08MAECoACwJAIAUoAhgiBiAFKAIcIgNBxJvDAEECEP0BDQBBACECAkADQCACIANGBEAgAyICIQEMAgsgAkEBaiEBIAIgBmotAAAiBEEwa0H/AXFBCU0EQCABIQIMAQsLIARBLkcEQCACIQEMAQsgAkEBaiEEIAMgASABIANJGyIBQQFrIQIDQCADIARNDQEgBCAG", + "aiAEQQFqIQQtAABBMGtB/wFxQQpJDQALIARBAWshASAEQQJrIQILIAJFDQACQCABIANPDQAgASAGai0AAEHlAEcNAAJAIAFBAWoiBCADTw0AAkAgBCAGai0AAEEraw4DAAEAAQsgAUECaiEECyAEIAMgAyAESRshASAEIQIDQCABIAJHBEAgAiAGai0AAEEwa0H/AXFBCUsEQCACIQEFIAJBAWohAgwCCwsLIAEgBEYNAQsgASADRw0AIAVBIGogBiADEHogBS0AIEEBRg0AIAUrAyghCiAAQgE3AwAgACAKmiAKIAgbOQMIIAUoAhQgBhABDAELIABCADcDACAFKAIUIAYQAQsgBSgCCCAHEAEgBUEwaiQAC5oBAQR/IAEgA2ohByADIAMgAiACIANJGyIGayEIQQAhAkEAIQECQANAIAIgCGpFBEAgBiADayECDAILAkAgAiAFTw0AIAIgB2otAABBMGtB/wFxIglBCk8NACABQQpsIAlqIQEgAkEBaiECDAELCyACIANqIQYLQQAhAyAAIAIgBE8EfyAAIAY2AgggACABNgIEQQEFQQALNgIAC7UCAQV/IwBBEGsiBCQAIARBBGogASACIANBAkECEJEDAkAgBCgCBEUEQAwBCyAEKAIMIgMgAk8NACABIANqLQAAQTpHDQAgBCgCCCEGIARBBGoiByABIAIgA0EBakEBQQIQkQMgBCgCBEUNACAEKAIMIgMgAk8NACABIANqLQAAQTpHDQAgBCgCCCEIIAcgASACIANBAWpBAUECEJEDIAQoAgRFIAZBF0tyIAhBO0tyDQAgBCgCCEE7Sw0AQQEhBSAEKAIMIgMgAk8NACABIANqLQAAQS5HDQAgA0EBaiIGIQUDQCACIAVHBEAgASAFai0AAEEwa0H/AXFBCUsEQCAFIQIFIAVBAWohBQwCCwsLIAIgAyACIAZLGyEDQQEhBQsgACADNgIEIAAgBTYCACAEQRBqJAAL4gMCCn8CfiMAQUBqIgIkACACIAE2", + "AgwgACgCDCEEIAIgAkEMajYCECAEQQFqIgEEQAJ/AkAgACgCBCIDIANBAWpBA3ZBB2wgA0EISRsiA0EBdiABSQRAIAJBMGpBECADQQFqIgMgASABIANJGxCXAyACKAI0IgYgAigCMCIDRQ0CGiACKAI4IQggAiACKAI8NgIsIAIgCDYCKCACIAY2AiQgAiADNgIgIAJCkICAgIABNwIYIAIgAEEQajYCFCAAKAIAIgkpAwBCf4VCgIGChIiQoMCAf4MhDCACQSBqIQpBACEBA0AgBARAA0AgDFAEQCABQQhqIQEgCUEIaiIJKQMAQn+FQoCBgoSIkKDAgH+DIQwMAQsLIAMgAyAGIAJBEGogACAMeqdBA3YgAWoiBxD9AyINEIUBIgVqIA2nQRl2Igs6AAAgAyAGIAVBCGtxakEIaiALOgAAIAMgBUF/c0EEdGoiBSAAKAIAIAdBf3NBBHRqIgcpAAg3AAggBSAHKQAANwAAIARBAWshBCAMQgF9IAyDIQwMAQsLIAIgACgCDCIBNgIsIAIgCCABazYCKCAAIAoQmAMgAkEUahCZAwwBCyAAIAJBEGpBGEEQEJoDC0EACxogAkFAayQADwsQgQEACz0BAX8gACgCACgCACICQQRqKAIAIAJBCGooAgAgACgCBCgCACABQQR0ayIAQQxrKAIAIABBCGsoAgAQlgMLmQICBn8CfiACIAOncSEGIANCGYhC/wCDQoGChIiQoMCAAX4hDQJAA0AgASAGaikAACIMIA2FIgNCf4UgA0KBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEDA0AgA1BFBEAgBCADeqdBA3YgBmogAnEiByAFEQUADQMgA0IBfSADgyEDDAELCyAMQoCBgoSIkKDAgH+DIQMCQAJ/IAlFBEBBACADUA0BGiAGIAN6p0EDdmogAnEhCAsgAyAMQgGGg0IAUg0BQQELIQkgBiAKQQhqIgpqIAJxIQYMAQsLQQEhCyABIAhqLAAAQQBIBEAgCCEHDAEL", + "IAEpAwBCgIGChIiQoMCAf4N6p0EDdiEHCyAAIAc2AgQgACALNgIACxgBAX8gASADRgR/IAAgAiABEJ0CBUEACwvHAQEEfyMAQRBrIgMkAAJAIAMgAQJ/IAJBD08EQCACQf////8BSw0CQX8gAkEDdEEHbkEBa2d2QQFqDAELQQQgAkEIcUEIaiACQQRJGwsQgwEgAygCCCECIAMoAgQhAQJAIAMoAgAiBEUEQCAAIAI2AgggACABNgIEIABBADYCAAwBCyADKAIMIQUgAUEJaiIGBEAgBEH/ASAG/AsACyAAIAU2AgwgACACNgIIIAAgATYCBCAAIAQ2AgALIANBEGokAA8LEIEBAAsLACAAIAFBBBCGAQtPAQV/IwBBEGsiASQAIAAoAhAiAgRAIAFBBGogACgCBCAAKAIIIAJBAWoQhwEgACgCDCABKAIMayABKAIEIQQgASgCCBCIAQsgAUEQaiQAC+IEAg9/AX4gACgCBEEBaiIJQQN2IAlBB3FBAEdqIQYgACgCACIFIQgDQCAGBEAgCCAIKQMAIhNCf4VCB4hCgYKEiJCgwIABgyATQv/+/fv379+//wCEfDcDACAIQQhqIQggBkEBayEGDAEFAkAgCUEITwRAIAUgCWogBSkAADcAAAwBCyAJRQ0AIAVBCGogBSAJ/AoAAAsgA0EBcSERIANBHHEhDiADQQJ2IRIgA0EDcSEPQQAhCANAAkAgCSAIIgVHBEAgBUEBaiEIIAAoAgAiBCAFai0AAEGAAUcNAiAEIAMgBUF/c2xqIhAgDmohCwNAIAUgASAAIAUgAhENACITpyIHIAAoAgQiCnEiBGsgACgCACIMIAogExCFASIGIARrcyAKcUEISQ0CIAYgDGoiBC0AACAEIAdBGXYiBDoAACAAKAIAIAZBCGsgCnFqQQhqIAQ6AAAgDCADIAZBf3NsaiEHQf8BRgRAIAAoAgQhBCAAKAIAIAVqQf8BOgAAIAAoAgAgBCAFQQhrcWpBCGpB/wE6AAAgA0UN", + "BCAHIBAgA/wKAAAMBAsgECAHIBIQhgEgD0UNACAHIA5qIQdBACEGIA9BAUcEQCALLwAAIQQgCyAHLwAAOwAAIAcgBDsAAEECIQYgEUUNAQsgBiALaiIELQAAIQ0gBCAGIAdqIgQtAAA6AAAgBCANOgAADAALAAsgACAAKAIEIgEgAUEBakEDdkEHbCABQQhJGyAAKAIMazYCCA8LIAUgDGogB0EZdiIEOgAAIAAoAgAgCiAFQQhrcWpBCGogBDoAAAwACwALAAsACxgAIAAoAgQgACgCCCABKAIAIAEoAgQQcwsOACAAKAIAIAAoAgQQAQvTEgIVfwF+IwBBsAFrIgIkACABQcADaiESIAJB9ABqIQwgAkHIAGohFANAIAJBADYCHCACQQA2AhQgAkE4aiABEPYCIAIoAjwhBAJAAkACQCACKAI4IgNBf0cEQCAAIAIpAkg3AhAgACACKQJANwIIIAAgBDYCBCAAIAM2AgAMAQsCQAJAAkAgBC0AACIDQQJrDgIBAgALIANBFUYNBCACQRRqEPACIABBfzYCAAwDCyATQQEhE0UNAyACIAQoAiQ2AqgBIAIgBCkCHDcDoAEgAkE4akGJ+8IAQRsQBiACIAIoAqgBNgJMIAIgAikDoAE3AkQgACACKQJINwIQIAAgAikCQDcCCCAAIAIpAjg3AgAMAQsgAigCFCACKAIYIARBCGooAgAiAyAEQQxqKAIAIgUQ8gMEQCACIAQoAiQ2AqgBIAIgBCkCHDcDoAEgAkE4akGk+8IAQdEAEAYgAiACKAKoATYCTCACIAIpA6ABNwJEIAAgAikCSDcCECAAIAIpAkA3AgggACACKQI4NwIADAELIAJBIGogAyAFEAYgAkEsaiAEQRRqKAIAIARBGGooAgAQBgJAAkACQAJAIAIoAhQiBQRAIAIoAighByACKAIkIQogAigCGCEIA0AgBUEEaiEDIAUvAY4CIglBDGwhBkF/IQQCQANAIAZFBEAgCSEEDAILIANBCGohDSAD", + "QQRqIQ8gBkEMayEGIARBAWohBCADQQxqIQMCQCAKIAcgDygCACANKAIAEOABQf8BcQ4CAAECCwsgAiAENgJEIAIgCDYCQCACIAU2AjwgAkF/NgI4IAIgAkEUajYCSCACKAIgIAoQAQwDCyAIBEAgCEEBayEIIAUgBEECdGooApACIQUMAQsLIAIgBDYCUCACQQA2AkwgAiAFNgJIIAIgAikCICIXNwM4IAIgAigCKDYCQCACIAJBFGoiAzYCRCAXp0F/RgRAIAMhBAwCCyAFLwGOAkELTwRAIAJBiAFqIQYgAkGMAWohCkEEIQMCQCAEQQVJDQACQAJAIAQiA0EFaw4CAgEACyAEQQdrIQQgAkGAAWohBiACQYQBaiEKQQYhAwwBC0EAIQQgAkGAAWohBiACQYQBaiEKQQUhAwsQ9gMiCUEAOwGOAiAJQQA2AgAgCSAFLwGOAiINIANBf3NqIgg7AY4CIAVBBGoiDyADQQxsIgtqIg4oAgAhByAOKQIEIRcgAiALIAVBiAFqIgtqIg4oAgg2AqgBIAIgDikCADcDoAECQAJAAkACQAJAAkAgCEEMSQRAIA8gA0EBaiIOQQxsIhBqIA0gDmsiDSAJQQRqIAgQ7AMgCyAQaiANIAlBiAFqIAgQ7AMgBSADOwGOAiACIAIpA6ABNwNYIAIgAigCqAE2AmAgAkEANgKAASACQQA2AogBIAIgBTYCjAEgAiAJNgKEASACIAQ2ApgBIAIgBigCADYClAEgAiAKKAIANgKQASACQaABaiACQZABaiACQThqIAJBLGoQ9wMgB0F/Rg0LIAwgAikDWDcCACAMIAIoAmA2AgggAiAXNwJsIAIgBzYCaEEAIQNBASEKA0AgBSgCACIERQRAIAIoAhQiBUUNAyACKAIYEPgDIgQgBTYCkAIgBEEAOwGOAiAEQQA2AgBBAWoiBUUNBCACIAQgBRD5AyACIAIoAgQiBTYCGCACIAIoAgAiBDYCFCADIAVBAWtHDQUgBC8BjgIiA0EL", + "Tw0GIAQgA0EBaiIFOwGOAiAEIANBDGxqIgMgDCkCADcCiAEgAyACKAJwNgIMIAMgAikCaDcCBCADIAwoAgg2ApABIAQgBUECdGogCTYCkAIgCSAFOwGMAiAJIAQ2AgAMDQsgCkEBayADRw0GIAUvAYwCIgMhBSAELwGOAiIPQQtPBEAgAkGMAWohCAJAIANBBUkEQEEEIQMMAQsCQAJAIANBBWsOAgIBAAsgA0EHayEFIAJBiAFqIQhBBiEDDAELQQAhBSACQYgBaiEIQQUhAwsQ+AMiBkEAOwGOAiAGQQA2AgAgBiAELwGOAiILIANBf3NqIgc7AY4CIARBBGoiDiADQQxsIhBqIhEoAgAhDSARKQIEIRcgAiAQIARBiAFqIhBqIhEoAgg2AqgBIAIgESkCADcDoAEgB0EMTw0IIA4gA0EBaiIRQQxsIhVqIAsgEWsiCyAGQQRqIAcQ7AMgECAVaiALIAZBiAFqIAcQ7AMgBCADOwGOAiACIAIpA6ABNwOQASACIAIoAqgBNgKYASAGLwGOAiILQQFqIQcCQCALQQtNBEAgDyADayAHRg0BQezcwgBBKEGU3cIAED4AC0EAIAdBDEGo28IAECkACyAHQQJ0IgcEQCAGQZACaiAEIANBAnRqQZQCaiAH/AoAAAsgAkEIaiAGIAoQ+QMgAiAENgKMASACIAIpA5ABNwOgASACIAIoApgBNgKoASACIAIoAgg2AogBIAIoAgwhAyAIKAIAIAUgAkHoAGogDCAJEPoDIAIgAigCqAE2AmAgAiACKQOgATcDWCANQX9GDQ0gAigCjAEhBSACKAKIASEJIAwgAikDWDcCACAMIAIoAmA2AgggAiAXNwJsIAIgDTYCaCAKQQFqIQoMAQsLIAQgBSACQegAaiAMIAkQ+gMMCwtBACAIQQtBkJPDABApAAtB4N7CABBdAAtB0NrCABBdAAtBzJjDAEEwQfyYwwAQPgALQZyYwwBBIEGMmcMAED4AC0Hg2sIAQTVBmNvCABA+", + "AAtBACAHQQtBkJPDABApAAsgAkGgAWogFCACQThqIAJBLGoQ9wMMAwsgAiACKAIoNgJAIAIgAikCICIXNwM4IAJBADYCSCACIAJBFGoiBDYCRCAXp0F/Rw0BCyACKAI8IARBDGxqIgMgAigCNDYCkAEgAygCjAEhFiADKAKIASEGIAMgAikCLDcCiAEMAgsQ9gMiA0EANgIAIANBADsBjgIgAkEANgIYIAIgAzYCFCADQQE7AY4CIAMgAikDODcCBCADIAIoAkA2AgwgAyACKQIsNwKIASADIAIoAjQ2ApABCyACIAIoAhxBAWo2AhxBfyEGCyAGIBYQBQwCCyACQRRqEPACCyACQbABaiQADwsgAiACKAIcNgJAIAIgAikCFDcDOCASEPACIBIgAigCQDYCCCASIAIpAzg3AgAgARD3AgwACwALRQEBfyABLQD8AiECIAFB/wE6APwCIAJB/wFGBEBBgPbCAEEuQbD2wgAQYgALIAAgAjoAACAAQQFqIAFB/QJqQTP8CgAAC8kNAhJ/AX4jAEHgAGsiAiQAIAAgACgCvAMiD0EBajYCvAMgAkEQaiIDIAEoAgQiCyABKAIIIgkQBiAAQdgBaiADELwBIABBsANqIQUCQAJAAkACQAJAAkAgACgCsAMiBARAIAAoArQDIQcDQCAEQQRqIQAgBC8BtgEiDkEMbCEKQX8hAwJAA0AgCkUEQCAOIQMMAgsgACgCCCEQIAAoAgQhBiAKQQxrIQogA0EBaiEDIABBDGohAAJAIAsgCSAGIBAQ4AFB/wFxDgIAAQILCyACIAU2AiAgAiADNgIcIAIgBzYCGCACIAQ2AhQgAkF+NgIQIAEoAgAgCxAFDAQLIAcEQCAHQQFrIQcgBCADQQJ0aigCuAEhBAwBCwsgAiADNgIoIAJBADYCJCACIAQ2AiAgAiAFNgIcIAIgASkCACIUNwMQIAIgASgCCDYCGCAUp0F+Rg0BAkACQAJAAkACQAJAAkAgBC8BtgFBC08EQCACQdgA", + "aiELIAJB3ABqIQdBBCEAAkAgA0EFSQ0AAkACQCADIgBBBWsOAgIBAAsgA0EHayEDIAJB0ABqIQsgAkHUAGohB0EGIQAMAQtBACEDIAJB0ABqIQsgAkHUAGohB0EFIQALEOsDIghBADsBtgEgCEEANgIAIAggBC8BtgEiASAAQX9zaiIKOwG2ASAKQQxPDQEgBEGIAWoiECAAQQJ0aigCACEOIAQgAEEMbGoiBkEIaikCACEUIAZBBGooAgAhCSAGQRBqIAEgAEEBaiIGayIBIAhBBGogChDsAyAQIAZBAnRqIAEgCEGIAWogChDtAyAEIAA7AbYBIAJBADYCUCACQQA2AlggAiAENgJcIAIgCDYCVCACIAM2AkAgAiALKAIANgI8IAIgBygCADYCOCACQcQAaiACQThqIAJBEGogDxDuAyAJQX5GDQwgAiAUNwIwIAIgCTYCLEEBIRFBACEAA0AgBCgCACIMRQRAIAUoAgAiA0UNBCAFKAIEEO8DIgQgAzYCuAEgBEEAOwG2ASAEQQA2AgBBAWoiAUUNBSACIAQgARDwAyACKAIAIQQgBSACKAIEIgE2AgQgBSAENgIAIAAgAUEBa0cNBiAELwG2ASIDQQtPDQcgBCADQQFqIgE7AbYBIAQgA0EMbGoiACACKQIsNwIEIAAgAigCNDYCDCAEIANBAnRqIA42AogBIAQgAUECdGogCDYCuAEgCCABOwG0ASAIIAQ2AgAMDgsgEUEBayAARw0HIAQvAbQBIgAhBAJAAkAgDC8BtgEiCkELTwRAIAJBxABqIQEgAEEFTw0BQQQhAAwCCyAMIAQgAkEsaiAOIAgQ8QMMDwsCQAJAIABBBWsOAgIBAAsgAEEHayEEIAJBOGohAUEGIQAMAQtBACEEIAJBOGohAUEFIQALEO8DIg1BADsBtgEgDUEANgIAIA0gDC8BtgEiCyAAQX9zaiISOwG2ASASQQxPDQggDEEEaiIGIABBDGxqIgMpAgQhFCADKAIAIRMgDEGIAWoi", + "CSAAQQJ0IhBqKAIAIAYgAEEBaiIHQQxsaiALIAdrIgYgDUEEaiASEOwDIAkgB0ECdGogBiANQYgBaiASEO0DIAwgADsBtgEgDS8BtgEiBkEBaiEJAkAgBkELTQRAIAogAGsgCUYNAUHs3MIAQShBlN3CABA+AAtBACAJQQxBqNvCABApAAsgCUECdCIABEAgDUG4AWogDCAQakG8AWogAPwKAAALIAJBCGogDSAREPADIAIgDDYCRCACIAIoAgg2AjggAigCDCEAIAEoAgAgBCACQSxqIA4gCBDxAyATQX5GDQ0gAigCOCEIIAIoAkQhBCACIBQ3AjAgAiATNgIsIBFBAWohESEODAALAAsgAkHEAGogAkEgaiACQRBqIA8Q7gMMCwtBACAKQQtBkJPDABApAAtB4N7CABBdAAtB0NrCABBdAAtBzJjDAEEwQfyYwwAQPgALQZyYwwBBIEGMmcMAED4AC0Hg2sIAQTVBmNvCABA+AAtBACASQQtBkJPDABApAAsgAkEANgIgIAIgBTYCHCACIAEoAgg2AhggAiABKQIAIhQ3AxAgFKdBfkcNAgsgBSEDCyACKAIUIANBAnRqIA82AogBDAILEOsDIgNBADsBtgEgA0EANgIAIAVBADYCBCAFIAM2AgAgAy8BtgEiAUELTw0CIAMgAUEBajsBtgEgAyABQQxsaiIAIAIpAxA3AgQgACACKAIYNgIMIAMgAUECdGogDzYCiAELIAUgBSgCCEEBajYCCAsgAkHgAGokACAPDwtBnJjDAEEgQbyYwwAQPgAL5wMBAX8jAEEwayIHJAACQCAAAn8CQAJAAkACQAJAAkAgBCAFQcTywgBBAhASRQRAIAVFDQEgASACIAQgBRDyAyICDQIgBUEBRg0FIAQgBUEhEJcCDQMMBQsCQCABIAJBxPLCAEECEPIDIgEEQCAHQQhqIAEoAgQgASgCCBAGDAELIAdBCGpBzN7CAEESEAYLDAULIAYoAgQgBigCCEHA9sIAQQEQEgRA", + "QQAhBSABIAJBAUEAEPIDIgFFDQMgB0EIaiABQQRqKAIAIAFBCGooAgAQQgwFCyABIAIgBEEAEPIDIgJFDQMLIAdBCGogAkEEaigCACACQQhqKAIAEEIMAwsgBCAFQSEQpgJFDQEgB0EIakHB9sIAQRoQBiAAQQE2AgAgACAHKQIINwIEIAcgAykCADcCFCAAIAcpAhA3AgwgByADKAIINgIcIAAgBykCGDcCFCAGKAIAIAYoAgQQAQwECyAHIAYoAgg2AiggByAGKQIANwMgQQEhBkEADAILIAdBCGogBCAFEAYLIAcgBigCCDYCKCAHIAYpAgA3AyAgBygCCCEFIAcoAgwhBiAHKAIQCzYCDCAAIAY2AgggACAFNgIEIAAgBykDIDcCECAAIAcoAig2AhggAEEANgIACyAHQTBqJAALdQICfwF+IwBBEGsiASQAIAAoApACBEAgACgCkAIhAiAAQQA2ApACIAApAogCIQMgAEKAgICAEDcCiAIgASACNgIIIAEgAzcDACAAKAKUAiAAKAKYAhABIAAgASgCCDYCnAIgACABKQMANwKUAgsgAUEQaiQAC8QCAQN/IwBBIGsiAiQAAkACQAJAAkACQAJAAkACQCABLQAAIgNBAmsOFAABBwcHBwcHBwcHBwcHBwIDBAUGBwsgAiABKQIENwIIDAYLIAJBCGogAUEEahDRAyACQRRqIAFBEGoQ0QMMBQsgAkEIaiABQQRqENEDDAQLIAJBCGogAUEEahDRAwwDCyACQQhqIAEoAgggASgCDBBCIAJBFGogASgCFCABKAIYEEIMAgsgAS0AASEEIAJBCGogAUEEahDRAyACIAQ6AAUMAQsgAkEIaiABKAIIIAEoAgwQQiACQRRqIAEoAhQgASgCGBDSAwsgACACKQIMNwIIIAAgAikCFDcCECAAIAIoAhw2AhggACABKQIcNwIcIAAgASkCJDcCJCAAIAEpAiw3AiwgAiADOgAEIAAgAikCBDcCACACQSBqJAAL5gIB", + "Bn8gAEHwAWohBSAAQfwBaiEGIABB5AFqIQcgACgCcCEDIAAoAswDIQQgAUH/AXFBCEYhCAJAA0ACQCADIARNDQAgAiAAKAJsIgEgAyAEQaT4wgAQ0wMoAjBJDQAgASADIARBtPjCABDTAyIBKAIIIgMEQCAIDQEgACgC7AEEQCAHQQoQ1wIgASgCCCEDCyAHIAEoAgQgAxAKCyABKAIgIgMEQCAAKAKEAgRAIAZBChDXAiABKAIgIQMLIAYgASgCHCADEAoLIAEoAhQiAwRAIAAoAvgBBEAgBUEKENcCIAEoAhQhAwsgBSABKAIQIAMQCgsgACgCzAMiBCAAKAJwIgNPDQIgACgCbCAEQdQAbGoiARDqAiABQoCAgIAQNwIYIAFCATcCECABQgA3AgggAUKAgICAEDcCACABQSBqQQBBNPwLACAAIARBAWoiBDYCzAMMAQsLDwsgBCADQcT4wgAQKgALOAEBfyAAKAIMIgFFBEBBAA8LIAAoAgQgASAAKAIIakEBayIBIAAoAgAiAEEAIAAgAU0ba0E0bGoL8QEBB38jAEEgayICJAAgAUGYAWohBSABKAIoQRRsIQQgASgCJEERaiEDIAEoApgBIQYgASgCnAEhByABLQC6ASEBAkACQANAIAQEQAJAIANBAWsiCC0AAEEBRyABcg0AIAcgA0EJaygCAE0EQCADQQ1rKAIAQYAIaiAGTw0BCyADLQAADQMgCEEAOgAACyAEQRRrIQQgA0EUaiEDDAELCyAAQX82AgAMAQsgAkEIakHuisMAQRUQBiAAIAIpAgg3AgAgAiAFKQIANwIUIAAgAikCEDcCCCACIAUoAgg2AhwgACACKQIYNwIQCyACQSBqJAALWQECfyAAKAIMIgIgACgCACIDRgRAIAAQ2gMgACgCACEDIAAoAgwhAgsgACACQQFqNgIMIAAoAgQgACgCCCACaiIAIANBACAAIANPG2tBNGxqIAFBNPwKAAALTAEBfyAAKAIIIgIgACgCAEYEQCAA", + "EMEBCyAAIAJBAWo2AgggACgCBCACQRRsaiIAIAEpAgA3AgAgACABKQIINwIIIAAgASgCEDYCEAv7FAIkfwF+IwBB0AFrIgMkACABQegAaiEZIAFBmAFqIQ0gAUEQaiETIAFBjAFqIREgA0GQAWohFCADQSBqIRogA0GEAWohHCACKAIIISEgAigCBCEdIAIoAgAhIgNAAkAgERCzA0EjRw0AIAEoAhwiAkECSQ0AIAEoAnAiBEUNACATIAJBAmtBgJDDABDUAyATIAJBAWtBkJDDABDUAyEFIAEoApABBH8gESgCAC0AACICQQpGIAJBDUZyBUEACyEIIAEoAmwgBEHUAGxqIglB1ABrIgpFDQAtAABBBkcNACAFLQAAQQ1HDQAgCCAJQUBqIgQoAgBFcg0AIAEoAqABIQcgASgCnAEhBiABKAKYASEFIAlByABrIgIpAgAhJyACQoCAgIAQNwIAIAIoAgghAiAEQQA2AgAgAyACNgKAASADICc3A3ggCigCACAJQdAAaygCABABIAogAygCgAE2AgggCiADKQN4NwIAIAYgCUEUaygCAEEBakcNACAJQRxrIAc2AgAgCUEgayAGNgIAIAlBJGsgBTYCAAsCQAJ/AkACQAJAAkACQAJAAkACQCARELMDIgJBCWsOBQEEBQUEAAsgAkEgaw4ECAQEAQQLIAEoAjRFDQcgAS0AuAFBAXENAQwHCyATEKQDIgJFBEAgHCANKQIAIic3AgAgHCANKAIIIgI2AgggGiAnNwIAIAMgAjYCgAEgGiADKQOAATcCCCAaIAMpA4gBNwIQIANBADoABAwFCyADQQRqIAIQogMgAy0ABEEORw0EIAEoAhwiAkECSQ0EIANBOGogEyACQQJrQZT/wgAQ1AMQogNBAQwFCyABKAKgASABKAKoAU4NBSADQfgAaiABELkDIAMoAngiAkF/RwRAIAAgAykBfjcBBiAAIAMpAYYBNwEOIAAgAy8BjgE7ARYgACADLwF8OwEEIAAgAjYC", + "AAwDCyABKAKQAUUNBgJAAkAgESgCAC0AACICQQprDgQIAQEIAAsgAkUNBwsgA0H4AGpBg4vDAEE3EAYgACADKQJ4NwIAIAMgDSkCADcChAEgACADKQKAATcCCCADIA0oAgg2AowBIAAgAykCiAE3AhAMAgsgAUECIAEoApQBIgIgAkECTRs2ApQBIAEQugMgAS0AugENBSABQQE6ALYBDAULIAEoAgAhAiABQQA2AgACQCACQQFxRQ0AIAEoAgwhByABKAIIIQQgASgCBCEFIAFBBCABKAKUASICIAJBBE0bNgKUASABKAKcASAEQQFqRw0AIAEtALoBDQAgASgCoAEgASgCqAFMDQAgASgCkAEiBkUNACARKAIAIgItAABFDQAgAiAGENUDDQAgAiAGQQEQvAMhASACIAYQqgNBOkYEQCABEKsDDQELIANB+ABqQbqLwwBBJxAGIAAgAykCeDcCACADIAU2AoQBIAAgAykCgAE3AgggAyAHNgKMASADIAQ2AogBIAAgAykCiAE3AhAMAQsgAEF/NgIACyADQdABaiQADwsgA0E4aiADQQRqQTT8CgAAQQALIAMoAlwhFSADKAJYIRYgAygCVCEXIAMtADggARDWAyEEIAEoApwBIQsgASgCsAEhCiABKAKgASEHIANCgICAgBA3AmwgA0EANgJ0IARBAEohAiAdBH8gCyAKa0EBQQJBASAHGyAKG2oFQX8LISQgBEEAIAIbIRggB0EBaiEGIApBAkkhHkEAIRBBEEYhJSAdIQkgIiEFICEhCkEAIQ9BACEOQQAhAgJAAkACQANAICUgDyAkR3IhJiAOQQFrIR9BACEgAkADQCABKAKUASEEIAEoApABIRIgASgCjAEhCANAIAJBgARGBEBBgAQhAiAFIQQgBiEHDAMLIAEgAkEBaiIbIAQgBCAbSRsiBDYClAEgBkEBaiEHIAggEiACELwDIgxBIEcgDEEJR3FFBEAgGyECIAchBgwBCwsCQAJAAkACQAJAAkAC", + "QCABLQC6AQRAAkAgDEEKaw4EAggIAgALIAxFDQEgDEHdAEYgDEH9AEZyDQIMBwsCQCAMQQprDgQBBwcBAAsgDA0GCyAgDQMgHkUEQCADKAJ0IQQMAwsgJkUNACADKAJ0IQQgGCAfTA0CIBAhBiAPIRIgDiEIIARFDQMMAQsgAygCdEUNAiAXIQYgFiESIBUhCCAYIB9MDQAgECEGIA8hEiAOIQgLIA0oAgAhBCAUIAMoAnQ2AgggFCADKQJsNwIAIANCgICAgBA3AmwgA0EANgJ0IAMgBzYCyAEgAyALNgLEASADIAIgBGoiBDYCwAEgAyAONgK8ASADIA82ArgBIAMgEDYCtAEgAyAINgKwASADIBI2AqwBIAMgBjYCqAEgAyAKNgKkASADIAk2AqABIAMgBTYCnAEgA0IBNwKIASADQgA3AoABIANCgICAgBA3AnggGSADQfgAahDXA0EAQQEQASAEIRcgCyIJIRYgByIKIRUMAgsgDEUgBEVyDQAgA0HsAGpBChDXAgsgBSEECwJAIAxBCmsOBAADAwADC0EBIQYgC0EBaiELQQAhHiAEIQUgGyECQQEhIAwBCwsCQAJAAkAgAygCdCIIRSAGIBhOckUgByAOR3FFBEAgDEEjRwRAIAUhBAwHCyAIDQEgBSEIDAILIA0oAgAhBCAUIAMoAnQ2AgggFCADKQJsNwIAIANCgICAgBA3AmwgA0EANgJ0IAMgBzYCyAEgAyALNgLEASADIAIgBGoiCDYCwAEgAyAONgK8ASADIA82ArgBIAMgEDYCtAEgAyAVNgKwASADIBY2AqwBIAMgFzYCqAEgAyAKNgKkASADIAk2AqABIAMgBTYCnAEgA0IBNwKIASADQgA3AoABIANCgICAgBA3AnggGSADQfgAahDXA0EAQQEQASAIIRcgCyIJIRYgByIKIRUgDEEjRg0BDAYLIANB7ABqQQoQ1wIgDSgCACACaiEGIAUhCCAPIQsgDiEHDAELIA0oAgAgAmoiBiEQCwNA", + "IBEQswMhBSANKAIAIQICQAJAAkACQCAFQQprDgQCAQECAAsgBUUNAQsCQCACIAZJBEAgBUEJRiAFQSBGcg0BDAMLIANB7ABqIAUQ1wIgBUEJRg0AIAVBIEcNAgsgARDKAwwCCyACIAZPBEAgARDWAyICQQAgAkEAShshGEEBIQIgCCEFIAshDyAHIQ4gASgCnAEhC0EBIQYMBAsgAUECIAEoApQBIgIgAkECTRs2ApQBIAEQugMMAQsgARCvAwwACwALCyADKAJ0IQgLIAhFDQAgDSgCACEFIAMgAygCdDYCgAEgAyADKQJsNwN4IAMgBzYCyAEgAyALNgLEASADIA42ArwBIAMgDzYCuAEgAyAQNgK0ASADIA42ArABIAMgDzYCrAEgAyAQNgKoASADIAo2AqQBIAMgCTYCoAEgAyAENgKcASADQgE3ApQBIANCADcCjAEgA0KAgICAEDcChAEgAyACIAVqIgIgAkEAR2s2AsABIBkgA0H4AGoQ1wNBAEEBEAEMAQsgAygCbCADKAJwEAELIANBOGoQ7QJFDQEgA0EEahDtAgwBCyABEMoDDAALAAuNAwIKfwF+IwBB4ABrIgQkAAJAIAAtALoBDQAgAiACKAIAIgMgA0EAR2s2AgAgAEEQaiEKIABBLGohCyAEQTBqIQcgBEHUAGohCANAIAAoAqgBIgMgAUwNAQJAAkAgACgCNCIFRQ0AIAAoAjAgBUEDdGoiBUEIRg0AIAVBBGstAABFDQELIANBAmohDCAAKAJsIgkgACgCcEHUAGwiBWohBiACIQMDQCAFRQ0BIAZBDGsoAgAgAygCAEkNASAMIAZBEGsoAgBGBEAgAiAFIAlqQRhrIgMoAgg2AgggAiADKQIANwIACyAGQdQAayEGIAUgCWpBMGshAyAFQdQAayEFDAALAAsgBEEIaiALENgDIAQtAAwiA0ECRwRAIAAgBCgCCDYCqAEgA0EBcUUNASAIIAIpAgAiDTcCACAIIAIoAggiAzYCCCAHIA03", + "AgAgBCADNgJQIAcgBCkDUDcCCCAHIAQpA1g3AhAgBEEIOgAUIAogBEEUahCmAwwBCwtBmI7DABBdAAsgBEHgAGokAAs5AQF/IwBBEGsiAiQAIAIgADYCCCACIAAgAWo2AgwgAkEIahDCASEAIAJBEGokACAAQQAgAEF/RxsLEwBCgcyAgBAgAK2IpyAAQSFJcQvpAQECfyMAQdAAayIDJAAgARCtAyADIAEQrgMCQCADKAIAIgRBf0cEQCAAIAMoAhQ2AhQgACADKQIMNwIMIAAgAykCBDcCBCACEO0CDAELIAFBADoAtgEgAyABKAKgATYCQCADIAEpApgBNwM4IAFBAxDZAyADIAEpApgBNwJEIAMgASgCoAE2AkwgAyADKQM4NwIcIAMgAikCADcDACADIAIpAgg3AwggAyACKQIQNwMQIAMgAigCGDYCGCADIAMpA0A3AiQgAyADKQNINwIsIAFBEGogAxCmAwsgACAENgIAIANB0ABqJAALMwEBfyMAQRBrIgEkACABIAAoAqABNgIIIAEgACkCmAE3AwAgAEF/IAEQqQMgAUEQaiQAC60BAQN/IwBBIGsiAiQAAkACQAJAIAEoAigiA0UNACABKAIkIANBFGxqIgNBFEYNACADQQRrIgQtAABFDQEgA0EDay0AAEEBRw0BIAJBCGpBjYLDAEETEAYgACACKQIINwIAIAIgASkCmAE3AhQgACACKQIQNwIIIAIgASgCoAE2AhwgACACKQIYNwIQDAILQZyHwwAQXQALIABBfzYCACAEQQA6AAALIAJBIGokAAs5ACAAQYwBahDbAyAAQQA6ALgBIABBADYCsAEgACAAKAKYAUEBajYCmAEgACAAKAKgAUEBajYCoAEL6gEBBn8jAEEgayICJAAgAiAAKAIAIgQ2AhggAiAEIAAoAgQiBmo2AhwCfwJAA0AgAkEYahDCASIDQX9GDQEgAxDhAw0ACyACKAIYIQUgAkEQagJ/QX8gA0GAAUkNABpBfiADQYAQ", + "SQ0AGkF9QXwgA0GAgARJGwsgBSAEa2ogBCAGQazcwwAQvwIgAigCECEDIAIoAhQMAQsgAigCHCACKAIYIgNrCyEFIAEgAyAEayIHECggAkEIaiAHIAQgBkG83MMAEOQCIAEgAigCCCACKAIMEAogACAFNgIEIAAgAzYCACACQSBqJAAgBwtzAQV/IwBBEGsiAiQAIAAoAgAhBCAAKAIEIQMDQAJAIAEgA0YEQCADIQEMAQsgASAEai0AACIFQSBHIAVBCUdxDQAgAUEBaiEBDAELCyACQQhqIAEgBCADQfzbwwAQvwIgACACKQMINwIAIAJBEGokACABC8MEAQd/IwBBQGoiBCQAIARBADYCJCAEQoCAgIAQNwIcAkACQAJAIAFBjAFqELMDQSFGBEAgBEEcaiABKAKMASABKAKQARCqAxDXAiABEK8DIAQgASgCjAEiBjYCKCAEIAYgASgCkAEiCWo2AiwCfwJAA0AgBEEoahDCASIFQX9GDQEgBRDlAw0ACyAEKAIoIQcgBEEQagJ/QX8gBUGAAUkNABpBfiAFQYAQSQ0AGkF9QXwgBUGAgARJGwsgByAGa2ogBiAJQYzcwwAQvwIgBCgCECEFIAQoAhQMAQsgBCgCLCAEKAIoIgVrCyEHIARBHGoiCiAFIAZrIggQKCAEQQhqIAggBiAJQZzcwwAQ5AIgCiAEKAIIIAQoAgwQCiABIAc2ApABIAEgBTYCjAEgASABKAKYASAIajYCmAEgASABKAKgASAIajYCoAEgBSAHEKoDQSFGBEAgCiAFIAcQqgMQ1wIgARCvAwwDCyACRQ0CIAQoAiAiASAEKAIkQcD2wgBBARCxAkUNAiAEQShqQYSAwwBBOBAGIAAgBCkCKDcCACAEIAMpAgA3AjQgACAEKQIwNwIIIAQgAygCCDYCPCAAIAQpAjg3AhAgBCgCHCEFDAELIARBKGpBvIDDAEEvEAYgACAEKQIoNwIAIAQgAykCADcCNCAAIAQpAjA3AgggBCADKAII", + "NgI8IAAgBCkCODcCEEEBIQELIAUgARABDAELIAAgBCgCJDYCDCAAIAQpAhw3AgQgAEF/NgIACyAEQUBrJAALJQEBfyAAQQEgACgCCCIBIAFBAU0bNgIIIAAoAgAgACgCBBCqAwsdAQF/IAAQtgMEfyAAEMYDQQFzIABBIUdxBUEACwucBAEHfyMAQSBrIgMkAAJAAkADQCABQQMgASgClAEiBCAEQQNNGzYClAEgASgCjAEiBCABKAKQASIFQQEQvAMhCCAEIAVBAhC8AyEJIAQgBRCqA0ElRw0BIAgQ4gNFDQEgCRDiA0UNASAIEOMDIgVBBHQgCRDjA3IhBAJ/AkACQCAGRQRAAn9BACAFQQhJDQAaQQEgBUEOcUEMRg0AGkECIAVBDkYNABogBEH4AXFB8AFHDQJBAwshBiAEDAMLIAVBDHFBCEYNASADQQhqQYiFwwBBOxAGIAAgAykCCDcCACADIAIpAgA3AhQgACADKQIQNwIIIAMgAigCCDYCHCAAIAMpAhg3AhAMBQsgA0EIakGZhMMAQToQBiAAIAMpAgg3AgAgAyACKQIANwIUIAAgAykCEDcCCCADIAIoAgg2AhwgACADKQIYNwIQDAQLIAZBAWshBiAEIAdBCHRyCyEHIAFBAxDZAyAGDQALIAdBgLADc0GAgMQAa0GAkLx/TwRAIABBfzYCACAAIAc2AgQMAgsgA0EIakHThMMAQTUQBiAAIAMpAgg3AgAgAyACKQIANwIUIAAgAykCEDcCCCADIAIoAgg2AhwgACADKQIYNwIQDAELIANBCGpBw4XDAEE1EAYgACADKQIINwIAIAMgAikCADcCFCAAIAMpAhA3AgggAyACKAIINgIcIAAgAykCGDcCEAsgA0EgaiQACyoBAX8gABDlAyEBAn8gAEHfAEcEQEEBIAENARoLQYjVwwBBFiAAEL0CCwsqAAJ/QQEgAUUNABpBACAALQAAIgBBIEsNABpCgcyAgBAgAK2IpwtBAXEL9gEBBX8jAEEg", + "ayIDJAAgAUGMAWohBgJAAkADQCADIAYQswNBChAWIAMoAgBBAUcNASAEQQlHBEAgAygCBCABEK8DIARBAWohBCAFQQpsaiEFDAELCyADQQhqQfWOwwBBxAAQBiAAIAMpAgg3AgAgAyACKQIANwIUIAAgAykCEDcCCCADIAIoAgg2AhwgACADKQIYNwIQDAELIAQEQCAAQX82AgAgACAFNgIEDAELIANBCGpBuY/DAEHFABAGIAAgAykCCDcCACADIAIpAgA3AhQgACADKQIQNwIIIAMgAigCCDYCHCAAIAMpAhg3AhALIANBIGokAAuYAwEIfyMAQTBrIgIkACABKAKMASEEIAEoApABIgYhAwNAIAJBEGogBCADQSAQHiACKAIQIgUEQEEBIQggAigCFCEDIAUhBAwBCyACQQhqIAQgA0EJEB4gAigCCCIFBEBBASEHIAIoAgwhAyAFIQQMAQsLIAYgA2shBUEAIQYCfwJAIANFBEBBACEDDAELIAQtAABBI0cNACAHIAhyRQRAQcDbwwAhBkE6IQNBAAwCCwNAIAJBGGogBCADEMsDAkACQCACKAIYIglBCmsOBAMBAQMACyAJQQFqQQJJDQILIAVBAWohBSACKAIcIQQgAigCICEDDAALAAsgASADNgKQASABIAQ2AowBIAhBCHQgB3IhA0EBCyEEIAEgASgCoAEgBWo2AqABIAEgASgCmAEgBWo2ApgBAkAgBEUEQCACQRhqIAYgAxAGIAAgAikCGDcCACACIAFBmAFqIgEpAgA3AiQgACACKQIgNwIIIAIgASgCCDYCLCAAIAIpAig3AhAMAQsgAEF/NgIAIAAgAzsBBAsgAkEwaiQAC3IBBH8jAEEQayIBJAAgASAAKAKMASICNgIIIAEgAiAAKAKQASIDajYCDAJAAkACQCABQQhqIgQQwgFBDUYEQCAEEMIBQQpGDQELIANFDQIgAi0AAEEKaw4EAQICAQILIAAQygMLIAAQ3AMLIAFBEGokAAtBAQF/", + "AkAgAUEDSQ0AIAFBA0cEQCAALQADEKsDRQ0BCyAALQAAQS5HDQAgAC0AAUEuRw0AIAAtAAJBLkYhAgsgAgtiAQF/IwBBEGsiAyQAIAMgADYCCCADIAAgAWo2AgwgAkEBaiEAAn8CQANAIABBAWsiAEUNASADQQhqEMIBQX9HDQALQQAMAQsgA0EIahDCASIAQQAgAEF/RxsLIANBEGokAAvpAwIDfwF+IwBB8ABrIgMkACABEMADIAEQzQMgA0EAOwFoIANCADcDYCADQgA3A1ggAUEgaiADQdgAahCnAwJAAkAgAS0AugEiBEH/AUcEQCAEQQFqIQQMAQsgA0EgakHw3sIAQRgQBiADIAEoAqABNgI0IAMgASkCmAE3AiwgAy0AJCEEIAMoAiAiBUF/Rg0AIAMgA0ElaiIBKAAPNgAXIAMgASkACDcDECADIAEpAAAiBjcDCCAAIAQ6AAQgACAGNwAFIAAgAykDEDcADSAAIAMoABc2ABQgACAFNgIAIAIQ7QIMAQsgASAEOgC6ASABQQE6ALYBIAMgASgCoAE2AhAgAyABKQKYATcDCCABEK8DIAFBmAFqIQQCQCACLQAAQQtHBEAgASgCQCIFIAEoAjhGBEAgAUE4ahDgAwsgASAFQQFqNgJAIAEoAjwgBWpBADoAAAwBCyABQQE6ALkBCyABQQEQyQMaIAMgBCgCCDYCbCADIAQpAgA3AmQgAyADKAIQNgJgIAMgAykDCDcCPCADIAIpAgA3AyAgAyACKQIINwMoIAMgAikCEDcDMCADIAIoAhg2AjggAyADKQNoNwJMIAMgAykDYDcCRCABQRBqIANBIGoQpgMgAEF/NgIACyADQfAAaiQAC/IDAQN/IwBB4ABrIgMkAAJAAkAgAS0AugEiBEUEQCADQRBqQdKNwwBBERAGIAAgAykCEDcCACADIAEpApgBNwIcIAAgAykCGDcCCCADIAEoAqABNgIkIAAgAykCIDcCEAwBCyADQRBqIAEQrgMgAygCECIF", + "QX9HBEAgACADKAIkNgIUIAAgAykCHDcCDCAAIAMpAhQ3AgQgACAFNgIADAELIAEgBEEBazoAugECQAJAIAEoAigiBEUNACABIARBAWs2AiggASgCJCAEQRRsakEDay0AAEECRg0AIAFBADoAtgEgAi0AAEEKRw0BIAMgASgCoAE2AhggAyABKQKYATcDECABIANBEGoQyAMgASgCQCIERQ0BIAEgBEEBazYCQAwBC0Hki8MAEF0ACyADIAEoAqABNgIIIAMgASkCmAE3AwAgARCvAyABQQEQyQMaIAEtALoBBEAgASABKAKYATYCpAELIAMgAUGYAWoiBCgCCDYCXCADIAQpAgA3AlQgAyADKAIINgJQIAMgAykDADcCLCADIAIpAgA3AxAgAyACKQIINwMYIAMgAikCEDcDICADIAIoAhg2AiggAyADKQNYNwI8IAMgAykDUDcCNCABQRBqIANBEGoQpgMgAEF/NgIADAELIAIQ7QILIANB4ABqJAALuQQCBH8DfiMAQdABayIDJAAgARDAAyABQQA6ALYBIANBADYCfCADQoCAgIAQNwJ0IAMgASgCoAE2AogBIAMgASkCmAE3A4ABIAEQrwMgAUGMAWohBiABQZgBaiEFA0ACQAJAIAYQswMiBBDhA0UNACAEEMYDIARBOkZyDQAgBA0BCwJAAkACQCADKAJ8RQRAIANBkAFqQYr+wgBB2AAQBiADIAMpA4ABNwKcASADIAMoAogBNgKkASADIAMpApABNwAjIAMgAykCmAE3ACsgAyADKQKgATcAMyADKAJ0IAMoAngQAQwBCyADIAMpAnQ3AKwBIAMgAygCfDYAtAEgAyADKQOAATcDuAEgAyADKAKIATYCwAEgAyAFKQIANwLEASADIAUoAgg2AswBIAMgAykAqQE3AyAgAyADKQCwATcAJ0ERQRIgAhsiAkF/Rw0BCyADIAMpADMiBzcAEyADIAMpACsiCDcACyADIAMpACMiCTcAAyAAIAc3AhAgACAI", + "NwIIIAAgCTcCAAwBCyADIAMoADc2ABcgAyADKQMwNwMQIAMgAykDKCIHNwMIIAMgAykDuAE3AlwgAyADKQPAATcCZCADIAMpA8gBNwJsIAMgAjoAQCADIAMpAyA3AEEgAyAHNwBJIAMgAykDEDcAUSADIAMoABc2AFggAUEQaiADQUBrEKYDIABBfzYCAAsgA0HQAWokAA8LIANB9ABqIAEoAowBIAEoApABEKoDENcCIAEQrwMMAAsAC78BAQJ/IwBBIGsiAiQAAkAgAC0AtgEEQAJAIAAtALoBDQAgACgCqAEgACgCoAFHDQAgACgCNCIBRQ0CIAAoAjAgAUEDdGoiAUEIRg0CIAFBBGstAAAhAQsgAiABOgAdIAJBAToAHCACIAAoAqABNgIYIAIgACkCmAE3AhAgAiAAKAIcIAAoAqwBajYCDCAAKAIoIgEEQCAAIAFBAWs2AigLIABBIGogAkEMahCnAwsgAkEgaiQADwtB9P/CABBdAAuzAwEDfyMAQTBrIgUkACAFQQA2AgwgBUKAgICAEDcCBAJAIANBAkkNACAFQQRqIANBAnYgA0EDcUEAR2oiBiAGQQBHaxAoIAVBATYCGCAFIAI2AhAgBSACIANqNgIUIAVBEGoQwgFBf0YNACAFIAUpAhA3AigDQCAFQShqEMIBIgJBf0YNASAFQQRqIAIQ1wIMAAsACyABQYwBaiEGAkACQANAAkAgBhCzAxC0A0UEQCADDQEgBUEQakHjjcMAQTIQBiAAIAUpAhA3AgAgBSAEKQIANwIcIAAgBSkCGDcCCCAFIAQoAgg2AiQgACAFKQIgNwIQDAMLAkAgASgCjAEiAiABKAKQASIHEKoDQSVHBEAgBUEEaiACIAcQqgMQ1wIgARCvAwwBCyAFQRBqIAEgBBC1AyAFKAIUIQIgBSgCECIHQX9HBEAgACAFKQIgNwIQIAAgBSkCGDcCCCAAIAI2AgQgACAHNgIADAQLIAVBBGogAhDXAgsgA0EBaiEDDAELCyAA", + "IAUoAgw2AgwgACAFKQIENwIEIABBfzYCAAwBCyAFKAIEIAUoAggQAQsgBUEwaiQAC7cTAg5/AX4jAEGwAWsiAyQAIAEQwAMgAUEAOgC2ASABEN0DIAEoAqABIQwgASgCnAEhCiABKAKYASENIANBADYCSCADQoCAgIAQNwJAIANBADYCVCADQoCAgIAQNwJMIANBADYCYCADQoCAgIAQNwJYIANBADYCbCADQoCAgIAQNwJkIAEQrwMgAUGMAWohDiABQZgBaiELIANBpAFqIQkgA0H8AGohCAJAAkACQAJAA0AgAUEEIAEoApQBIgQgBEEETRsiBjYClAECQCABKAKgASIFRQRAIAEoAowBIAEoApABIgQQ1QNFDQEgA0HwAGpBoILDAEHDABAGIAMgDDYChAEgAyAKNgKAASADIA02AnwgAygCeCEFIAMoAnQhBCADKAJwIQcMBQsgASgCkAEhBAsgBEUNASAOKAIAIgctAABFDQEgASgCqAEgBUwEQANAIAEgBjYClAFBACEFAkACQAJAAkACQCAHIAQQqgMQqwMNACAHIAQQqgMiD0EiRwRAAkAgD0EnRwRAIA9B3ABGDQEMBgsgByAEQQEQvANBJ0cEQCACRQ0GDAMLIAJFDQUgA0FAa0EnENcCIAFBAhDZAwwGCyACDQQCQAJAIAcgBEEBELwDQQprDgQBAAABAAsCQAJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAcgBEEBELwDIgdB3ABrDh0KAQEMAQIDAQEJBwEBAQEBAQEFAQEBCAEEEAYBDwALAkAgB0HMAGsOCg0BCwEOAQEBAREACwJAIAdBIGsOAwoBCgALQQAhBEEAIQYCQCAHQS9rDgIKEwALIAdBCUYNAwsgA0GYAWpBsZHDAEE9EAYMFQtBByEEQQAhBgwQC0EIIQRBACEGDA8LQQkhBEEAIQYMDgtBCiEEQQAhBgwNC0ELIQRBACEGDAwLQQwhBEEAIQYMCwtB", + "DSEEQQAhBgwKC0EbIQRBACEGDAkLIAchBEEAIQYMCAtBhQEhBEEAIQYMBwtBoAEhBEEAIQYMBgtBqMAAIQRBACEGDAULQanAACEEQQAhBgwEC0ECDAILQQQMAQtBCAshBkEBIQVBACEECyABQQIQ2QMgBUUNBCABIAYgASgClAEiBCAEIAZJGzYClAEgASgCkAEhByABKAKMASEPQQAhBEEAIQUDQAJAIAUgBkcEQCAPIAcgBRC8AyIQEOIDDQEgA0GYAWpB6pDDAEHHABAGDAYLIARBf0YgBEGAsANzQYCAxABrQYCQvH9JckUEQCABIAYQ2QMMBwsgA0GYAWpBoJDDAEHKABAGDAULIAVBAWohBSAQEOMDIARBBHRyIQQMAAsACyABQQMgBiAGQQNNGzYClAEgARCvAyABELoDQQEhBQwBCyACDQMLAkACQAJAIA4QswMiBEEiRwRAIARBJ0cNAiACDQEMAgsgAg0BCyABEK8DIAEoApABIQYgASgCjAEhCSABKAKUASEFQQAhBANAIAEgBCIHQQFqIgQgBSAEIAVLGyIFNgKUASAJIAYgBxC8AyIOQQlGIA5BIEZyDQALAkACQAJAIAkgBiAHELwDIgRBCmsOBAECAgEACyAERQ0AAkACQCAEQSNHBEAgBEH9AEYNAiAEQTpGDQEgBEHdAEcEQCAEQSxHDQUgAS0AugFFDQUMBAsgAS0AugENAwwECyAHRQ0DDAILIAEtALoBDQEgCiABKAKcAUcNAgwBCyABLQC6AUUNAQsgAyALKAIINgIIIAMgCykCADcDACADKQJAIREgAygCSCEEIAMoAmQgAygCaBABIAMoAlggAygCXBABIAMoAkwgAygCUBABIAMgDDYCMCADIAo2AiwgAyANNgIoIAMgAykDADcCNCADIAMoAgg2AjwgAyAENgIYIAMgETcCECADQQFBAiACGzoADSADQRQ6AAwgAyAIKQIANwIcIAMgCCgCCDYCJCABQRBqIANBDGoQpgMgA0GY", + "AWogASADQShqEM8DIAMoApgBIgJBf0cEQCAAIAMoAqwBNgIUIAAgAykCpAE3AgwgACADKQKcATcCBCAAIAI2AgAMDgsgAyALKAIINgKQASADIAspAgA3A4gBIANBmAFqIAEgA0GIAWoQqAMgAygCmAEiAkF/RwRAIAAgAygCrAE2AhQgACADKQKkATcCDCAAIAMpApwBNwIEIAAgAjYCAAwOCyAAQX82AgAgASABKAKYATYCpAEMDQsgA0GYAWpB44LDAEEzEAYMAQsDQAJ/AkACQAJAAkACQCABKAKQASIERQ0AIA4oAgAiBy0AACIGQQlGIAZBIEZyDQIgDigCAC0AAEEKaw4EAQAAAQALIAVBAXFFBEAgA0FAayADKAJoIAMoAmwQCiADQQA2AmwMDgsgAygCVEUNAgJAIAMoAmAiBARAIANBQGsgAygCXCAEEAogA0EANgJgDAELIANBQGtBIBDXAgsgA0EANgJUDA0LIAFBAiABKAKUASIEIARBAk0bNgKUASAFQQFxRQRAIANBADYCbCABIANBzABqEOQDDAMLIAEgA0HYAGoQ5AMMAgsgByAEEKoDIQQgBUEBcUUEQCADQeQAaiAEENcCIAEQygNBAAwDCwJAIARBCUcNACABKAKgASABKAKoAU4NACADQZgBakGWg8MAQSEQBgwFCyABEMoDDAELIANBQGsiBCADKAJQQQAQCiAEIAMoAlwgAygCYBAKIANBADYCYAwKC0EBCyEFIAFBASABKAKUASIEIARBAU0bNgKUAQwACwALIAggCykCADcCACAIIAsoAgg2AgggAygCoAEhBSADKAKcASEEIAMoApgBIQcMCQsgAyAKNgKoASADIA02AqQBIAMgDDYCrAEgAyAJKQIANwOIASADIAkoAgg2ApABIAMoApwBIQQgAygCoAEhBSADKAKYASIHQX9GDQAgCCADKAKQATYCCCAIIAMpA4gBNwIADAgLIANBQGsgBBDXAgwBCyADQUBrIA8Q1wIgARCv", + "AwtBAiABKAKUASIEIARBAk0bIQYgASgCkAEhBCABKAKMASEHDAALAAsLIANBmAFqQbeDwwBBJBAGDAELIANBmAFqQduDwwBBPhAGCyAIIAw2AgggAyAKNgKoASADIA02AqQBIAggAykCpAE3AgAgAygCmAEhByADKAKcASEEIAMoAqABIQULIAMoAmQgAygCaBABIAMoAlggAygCXBABIAMoAkwgAygCUBABIAMoAkAgAygCRBABIAAgBTYCCCAAIAQ2AgQgACAHNgIAIAAgCCkCADcCDCAAIAgoAgg2AhQLIANBsAFqJAAL+w0CDn8BfiMAQZABayICJAAgARDAAyABQQA6ALYBIAEQ3QMgAkHKAGohBiABKQKYASEQAkACQAJAAkACQCABLQC6AUEAIAEoAqgBQQFqIgwgASgCoAEiCUobRQRAIAJB3ABqQSAQ3gMgAUEANgJYIAFBADYCTCABQQA2AmQgAiABQZgBaiIIKQIANwNoIAIgCCgCCDYCcCABQdAAaiENIAFBxABqIQ4gAUHcAGohDyABKAKQASEDIAEoAqABIQUgASgClAEhBANAIAFBBCAEIARBBE0bNgKUASABKAKMASEEAkACQCAFRQRAIAQgAxDVAw0BCyAEIAMQqgNBI0cNAQsgBCADEKoDQSNHDQUgAigCZEUNBSABKAJkRQ0FIAEtALoBDQUgAUEBNgIAIAEgCCkCADcCBCABIAgoAgg2AgwMBQsCQCABLQC6ASIFRQ0AIAQgAxCqA0EtRw0AIAQgA0EBELwDEMYDRQ0AIAJB+ABqQZGJwwBBNBAGIAIgCCkCADcChAEgBiACKQF+NwEAIAIgCCgCCDYCjAEMAwsCQCAEIAMQtwMNACAEIANBARC8AyEHAkACQCAEIAMQqgMiBEE6RgRAIAcQqwMiBCAFRXINASAHEMYDDQMMAgsgBUUNASAEEMYDRQ0BDAILIAQNAQsCQCABLQC4AUUEQCABKAJkIgNFDQEgAkHcAGogASgCYCADEAog", + "AUEANgJkDAELAkAgASgCTARAIAEoAlgiAwRAIAJB3ABqIAEoAlQgAxAKIAFBADYCWAwCCyACQdwAakEgENcCDAELIAJB3ABqIgMgASgCSEEAEAogAyABKAJUIAEoAlgQCiABQQA2AlgLIAFBADoAuAEgAUEANgJMCyACQdwAaiIDIAEoAowBIAEoApABEKoDENcCIAEQrwMgA0GAARAoA0AgAUGAASABKAKUASIDIANBgAFNGzYClAFBACEFAn8DQEH/ACAFQf8ARg0BGgJAIAEoAowBIgMgASgCkAEiBBC3Aw0AIAEtALoBIQcgAyAEQQEQvAMhCgJAIAMgBBCqAyILQTpGBEAgChCrAyILIAdFckUEQCAKEMYDDQMMAgsgCw0CDAELIAdFDQAgCxDGAw0BCyACQdwAaiADIAQQqgMQ1wIgARCvAyAFQQFqIQUMAQsLIAULQf8ATw0ACyACIAgoAgg2AnAgAiAIKQIANwNoIAEoApABIQMLIANFDQQCQCABKAKMAS0AACIEIgVBCUYgBUEgRnINACAEQQprDgQABQUABQsDQCABQQIgASgClAEiBSAFQQJNGyIENgKUAQJAAkAgA0UNACABKAKMASIFLQAAIgdBCWsiCkEXSw0AQQEgCnRBk4CABHENAQsgAS0AugEgASgCoAEiBSAMTnINAgwGCyABLQC4ASEEAkAgB0EJRiAHQSBGckUEQCAEQQFxRQRAIAFBADYCZCABEN8DIA5BChDXAiABQQE6ALgBDAILIAEQ3wMgDUEKENcCDAELAkACQCAEQQFxRQRAIA8gBSADEKoDENcCDAELIAEoAqABIAxODQAgBSADEKoDQQlGDQELIAEQygMMAQsgAkH4AGogARC5AyACKAJ4IgNBf0cEQCAGIAIpAX43AQAgBiACKQGGATcBCCAGIAIvAY4BOwEQDAYLIAEoApABRQ0AAkACQCABKAKMAS0AACIDQQprDgQCAQECAAsgA0UNAQsgAkH4AGpB44nDAEEqEAYg", + "AiAQNwKEASAGIAIpAX43AQAgAiAJNgKMAQwECyABKAKQASEDDAALAAsACyACQcQAakGNisMAQSUQBiACIAk2AlggAiAQNwJQIAIoAkQhAyACLQBIIQEgAi0ASSEFDAMLIAYgAikBhgE3AQggBiACLwGOATsBECACKAJ4IQMLIAItAH0hBSACLQB8IQEgAigCXCACKAJgEAEMAQsgAS0AuAEEQCABQQE6ALYBCyACKAJkRQRAIAJB+ABqQcWJwwBBHhAGIAIgEDcChAEgBiACKQF+NwEAIAIgCTYCjAEgBiACKQGGATcBCCAGIAIvAY4BOwEQIAIoAnghAyACLQB8IQEgAi0AfSEFIAIoAlwgAigCYBABDAELIAYgAigBYjYBACAGIAIvAWY7AQQgAiACKAJwIgM2AgggAiAJNgI0IAIgEDcCLCACIAIpA2g3AjggAiADNgJAIAIoAlwhAyACIAIvAWA7ARggAiADNgIUIAJBFDsBECACIAYvARA7ASogAiAGKQEINwEiIAIgBikBADcBGiABQRBqIAJBEGoQpgMgAEF/NgIADAELIAAgBToABSAAIAE6AAQgACADNgIAIAAgBikBADcBBiAAIAYpAQg3AQ4gACAGLwEQOwEWCyACQZABaiQAC5YDAgR/AX4jAEHgAGsiBiQAAkACQCAALQC6AUUEQAJAIAAoAqgBIgcgAUoNACAAKAI0IghFDQAgACgCMCAIQQN0aiIIQQhrIglFDQAgCEEEay0AAA0AIAAgCSgCADYCqAEgBkEIaiAAQSxqENgDIAAoAqgBIQcLIAEgB0oNAQsgBBDtAgwBCyAAQSxqIAdBARDpAyAAIAE2AqgBIAJBAXFFBEAgBiAFKAIIIgE2AlwgBiAFKQIAIgo3AlQgBiABNgJQIAYgBCkCADcDECAGIAQpAgg3AxggBiAEKQIQNwMgIAYgBCgCGDYCKCAGIAo3AiwgBiAGKQNYNwI8IAYgBikDUDcCNCAAQRBqIAZBEGoQpgMMAQsgACgC", + "rAEhASAGIAUoAggiAjYCXCAGIAUpAgAiCjcCVCAGIAI2AlAgBiAEKQIANwMQIAYgBCkCCDcDGCAGIAQpAhA3AyAgBiAEKAIYNgIoIAYgCjcCLCAGIAYpA1g3AjwgBiAGKQNQNwI0IAAgAyABayAGQRBqEOYDCyAGQeAAaiQAC+8IAgp/AX4jAEGQAWsiAiQAAkACQAJAIAEoAigiA0UNACABKAIkIANBFGxqIgNBFGsiBkUNACACIANBEGsiBSkCADcDACACIAUoAgg2AgggA0EEay0AACEKIAEoAqABIQMgASgCnAEhBSABKAKYASEIIAYoAgAhBiABLQC5ASABKAJAIgRFciIJQQFxDQIgASgCPCAEakEBayIERQ0BIARBAToAAAwCC0HY/MIAEF0AC0Ho/MIAEF0ACyABEK8DAkACQCABQYwBahCzA0EJRw0AIAJB2ABqIAEQuQMgAi0AXSEEIAItAFwhByACKAJYIgtBf0cEQCAAIAIvAW47ARYgACACKQFmNwEOIAAgAikBXjcBBiAAIAQ6AAUgACAHOgAEIAAgCzYCAAwCCyAEQQFxIAdBAU1xDQAgASgCjAEiBCABKAKQASIHEKoDQS1HBEAgB0UNASAELQAAEOUDRQ0BCyACQdgAakH4/MIAQS8QBiAAIAIpAlg3AgAgAiABQZgBaiIBKQIANwJkIAAgAikCYDcCCCACIAEoAgg2AmwgACACKQJoNwIQDAELAkACQAJAAkAgCkEBcUUEQCAJQQFxRQ0BDAMLIAIgAigCCCIENgJgIAIgAikDACIMNwJkIAIgBDYCbCACIAw3AiggAkEPOgAMIAIgAikDYDcCMCACIAIpA2g3AjggAigCBCEHIAEgBiABKAKsAWsgAkEMahDmAyAJQQFxDQEgBSAHTQRAIAEoAqwBIQkgAiACKAIIIgc2AkggAiACKQMAIgw3AkwgAiAHNgJUIAIgDDcCdCACQQs6AFggAiACKQNINwJ8IAIgAikDUDcChAEgASAGIAlr", + "IAJB2ABqEOYDDAILIAJB2ABqQej9wgBBIhAGIAAgAikCWDcCACACIAg2AmQgACACKQJgNwIIIAIgAzYCbCACIAU2AmggACACKQJoNwIQDAQLIAIgAzYCiAEgAiAFNgKEASACIAg2AoABIAIgAzYCfCACIAU2AnggAiAINgJ0IAJBCzoAWCABQRBqIAJB2ABqEKYDDAELIAJBBzoAWCABIARBASAGIAJB2ABqIAIQxAMgARDNAwJAIAEoAigiBkUNACABKAIkIAZBFGxqIgZBFEYNACABQQA6ALYBIAZBBGtBADoAAAwCC0HY/cIAEF0ACyABLQC6AUUEQCABLQC2AUUEQCACQdgAakGn/cIAQS4QBiAAIAIpAlg3AgAgAiAINgJkIAAgAikCYDcCCCACIAM2AmwgAiAFNgJoIAAgAikCaDcCEAwDCyACQQc6AFggAiADNgIUIAIgBTYCECACIAg2AgwgASADQQAgAiACQdgAaiACQQxqEMQDCyABEM0DIAEtALoBRQRAIAFBAToAtgEMAQsgAUEAOgC2AQsgAiADNgKIASACIAU2AoQBIAIgCDYCgAEgAiADNgJ8IAIgBTYCeCACIAg2AnQgAkEQOgBYIAFBEGogAkHYAGoQpgMgAEF/NgIACyACQZABaiQACzUBAX8CQAJAAkAgAEHbAGsOAwECAQALAkAgAEH7AGsOAwECAQALIABBLEcNAQtBASEBCyABC9USAQ5/IwBBsAFrIgMkACABEMADIAFBAToAtgEgASgCoAEhDiABKAKcASENIAEoApgBIQ8gA0EANgJMIANCgICAgBA3AkQgA0EANgJYIANCgICAgBA3AlAgA0EANgJkIANCgICAgBA3AlwgA0EANgJwIANCgICAgBA3AmggARCvAyABEN0DIAFBjAFqIgcQswMhCCADQYABaiEJIAEoApABIQQgASgCjAEhBQJAAkACQAJAAn8CQAJAAkACQAJAAkACQCAIQStHBEAgBSAEEKoDQS1HDQELIAUg", + "BBCqAyEEIAEQrwMgAUEBIAEoApQBIgggCEEBTRs2ApQBQQJBACAEQStGGyEIIAEoApABIgRFDQQgBygCACIFLQAAQTBrQf8BcUEKTw0EIAUgBBCqA0EwRw0BIANB9ABqQayHwwBByAAQBiADIA42AogBIAMgDTYChAEgAyAPNgKAASADKAJ8IQUgAygCdCEEIAMoAngMBwtBASEIIARFDQMgBS0AAEEwa0H/AXFBCk8NAyAFIAQQqgNBMEcNASADQYwBakGsh8MAQcgAEAYMBAsgBSAEEKoDQTBrIQYMAQsgBSAEEKoDIAEQrwMgAUEBIAEoApQBIgYgBkEBTRs2ApQBQTBrIQYgASgCjAEiBCABKAKQASIFEKoDQStHBEAgBCAFEKoDQS1HDQILQQJBACAEIAUQqgNBK0YbIQgLIAEQrwMLIANBjAFqIAEQuQMgAygCjAEiBEF/RwRAIAkgAykCmAE3AgAgCSADKAKgATYCCAwCCyABQQEgASgClAEiBCAEQQFNGzYClAECQCABKAKQAUUNAAJAAkACQCAHKAIALQAAIgVBCmsOBAIBAQIACyAFRQ0BCyADQYwBakH0h8MAQcoAEAYMAgsCQCAHKAIALQAAQQprDgQAAQEAAQsgAUECIAQgBEECTRs2ApQBIAEgA0HoAGoQ5AMLIAcQswNBCUYEQCADQYwBakG+iMMAQS4QBgwBCwJAAkAgBgRAIAEoAqgBIgRBACAEQQBKGyAGaiIKDQELQQAhBANAIAcQswNBIEYEQCABEMoDDAELIAEoAqABIgYgBCAEIAZJGyEEAkAgASgCkAEiBUUNAAJAIAcoAgAtAABBCmsOBAABAQABCyABQQIgASgClAEiBiAGQQJNGzYClAEgASADQdwAahDkAwwBCwsgASgCqAFBAWoiBiAEIAQgBkkbIQoMAQsgASAKIANB3ABqEOcDIAEoApABIQULIAFBmAFqIQsCQAJAIAVFDQAgBygCAC0AAEUNAAJAIAogASgCoAEiBEsE", + "QCAEIAEoAqgBSg0BCyADQaQBakHkABDeAyABKAKgASEOIAEoApwBIQ0gASgCmAEhDwNAIAQgCkcNAyABKAKQASIERQ0DIAcoAgAiBS0AAEUNAyAKRQRAIAFBBCABKAKUASIGIAZBBE0bNgKUASAFIAQQuwMNBAsgAygCWCEQAkACQAJAIAIEQCADKAJkIQQgAygCYCEGDAELIAMoAmQhBCADKAJgIQYgBS0AACIFQSBGIAVBCUZyIAxyDQAgEA0BCyADQcQAaiIMIAMoAlQgEBAKIAwgBiAEEAoMAQsgA0HEAGoiDCAGIAQQCiAEDQAgDEEgENcCC0EAIQwgA0EANgJkIANBADYCWCABKAKQAQRAIAcoAgAtAAAiBEEgRiAEQQlGciEMCwJAA0AgASgClAEiBEUEQCABKAKQASEFIAEoAowBIQYDQAJAIANBjAFqIAYgBRDLAyADKAKMASIEQQFqQQJJDQACQCAEQQprDgQBAAABAAsgASADKAKUASIFNgKQASABIAMoApABIgY2AowBIANBpAFqIAQQ1wIMAQsLIAEgAygCqAEiBCAEIAMoAqwBIgZqENYCIgUgASgCoAFqNgKgASABIAUgASgCmAFqNgKYASADQcQAaiIFIAYQKCAFIAQgBhAKIAFBAiABKAKUASIEIARBAk0bNgKUASADQQA2AqwBIAEoApABRQ0GDAILIAEoApABIgZFBEAgAUECIAQgBEECTRs2ApQBDAYLAkACQAJAIAcoAgAiBS0AACIQQQprDgQCAQECAAsgEEUNAQsgA0HEAGogBSAGEKoDENcCIAEQygMMAQsLIAFBAiAEIARBAk0bNgKUAQsgBygCAC0AAEUNAyABIANB0ABqEOQDIAEgCiADQdwAahDnAyABKAKgASEEDAALAAsgA0GMAWpB7IjDAEElEAYgCSALKQIANwIAIAkgCygCCDYCCCADKAKUASEFIAMoAowBIQQgAygCkAEMBAsCfyAIRSABKAKcASANRnIiBgRAQQEh", + "CEEAIQVBAAwBCwJAIAhBAUcEQCADKAJkIgUNAQsgAyALKQIANwMAIAMgCygCCDYCCEEUIQcgAygCaCEEIAMoAnAhBSADKAJsIQgMBgsgAygCYCEIIAMoAlwLIQQgAyALKAIINgIIIAMgCykCADcDACADKAJoIAMoAmwQAUEUIQcgBkUNBQwECwJAIAhFBEAgAygCVCEGIAMoAmAhBwwBCyADQcQAaiADKAJUIgYgAygCWBAKAkAgASgCkAEEQCAHKAIALQAADQELIAEoAqABQQEgCiAKQQFNG0kNACADQcQAakEKENcCCyADKAJgIQcgCEECRw0AIANBxABqIAcgAygCZBAKCyADIAsoAgg2AgggAyALKQIANwMAIAMoAkQhBCADKAJIIQggAygCTCEFIAMoAqQBIAMoAqgBEAEgAygCaCADKAJsEAEgAygCXCAHEAEgAygCUCAGEAFBFCEHDAULIAkgDjYCCCADIA02ApwBIAMgDzYCmAEgCSADKQKYATcCACADKAKMASEECyADKAKUASEFIAMoApABCyEIIAMoAmggAygCbBABQf8BIQcLIAMoAlwgAygCYBABC0EAQQEQAUEAQQEQASAHQf8BRw0AIAAgBTYCCCAAIAg2AgQgACAJKQIANwIMIAAgCSgCCDYCFAwBCyADIA42AjQgAyANNgIwIAMgDzYCLCADIAMpAwA3AjggAyADKAIINgJAIAMgBTYCHCADIAg2AhggAyAENgIUIANBA0EEIAIbOgARIAMgBzoAECADIAkpAgA3AiAgAyAJKAIINgIoIAFBEGogA0EQahCmA0F/IQQLIAAgBDYCACADQbABaiQAC5oBAgJ/AX4jAEHQAGsiAiQAAkAgACgCQCIDRQ0AIAAoAjwgA2pBAWsiA0UNACADLQAARQ0AIANBADoAACAAQQA6ALkBIAIgASgCCCIDNgJAIAIgASkCACIENwJEIAIgAzYCTCACQQw6AAQgAiAENwIgIAIgAikDQDcCKCACIAIpA0g3", + "AjAgAEEQaiACQQRqEKYDCyACQdAAaiQAC0gBA38gAEGMAWohBANAAkACQCAEELMDIgJBCUcEQCACQSBHDQIgAyECDAELQQEhAiABRQ0BCyAAEMoDIAIhAwwBCwsgA0EBcQspACAAQYwBahDbAyAAIAAoApgBQQFqNgKYASAAIAAoAqABQQFqNgKgAQtVAQF/IwBBEGsiAyQAIAMgATYCCCADIAEgAmo2AgwgA0EIahDCASIBQX9HBEAgACADKAIIIgI2AgQgACADKAIMIAJrNgIICyAAIAE2AgAgA0EQaiQACxMAIAFFBEBBAA8LIAAtAAAQxgMLVwEBfwJAIAAtALoBDQAgACgCNCIBRQ0AIAAoAjAgAUEDdGoiAUEIRg0AIAFBBGstAABBAUcNACAAQSxqIAAoAqgBQQAQ6QMgACAAKAKoAUEBajYCqAELCxQAIABBADYCCCAAQcD2wgBBARAKC9MEAgl/AX4jAEHgAGsiAyQAAkACQCABKAKwAUUEQCADQQA2AgggA0KAgICAEDcCACABQYwBaiELIAEoApABIQogASgCjAEhBSABKAKUASEGA0AgBEGABEYEQEEBIQcMAwtBASEHIAEgBEEBaiIJIAYgBiAJSRsiBjYClAECQAJAAkAgBSAKIAQQvAMiCUEgaw4EAQUFAgALIAlBCUcNBAsgBEEBaiEEDAELCyABQZgBaiEGIAEoApgBIARqIQlBACEHQQAhCgNAIAsQswMhBCAGKAIAIQUCQAJAAkACQAJAAkAgBEEKaw4EAQICAQALIAQNAQsgBSAJSQ0BIAMoAggNAiADKAIEIQcgAygCACEIDAYLAkAgBSAJSQRAIARBCUYgBEEgRnINAQwECyAIIAUgAygCCCIFGyEIIAogASgCnAEgBRshCiAHIAEoAqABQQFqIAUbIQcgAyAEENcCIARBCUYNACAEQSBHDQMLIAEQygMMAwsgAUECIAEoApQBIgQgBEECTRs2ApQBIAEQugMMAgsgAyADKQIANwIY", + "IAMgAygCCDYCICADIAc2AlAgAyAKNgJMIAMgCDYCSCADQoCAgIAQNwIkIANCgICAgBA3AgwgA0EANgIsIANBADYCFCADIAYoAgg2AlwgAyAGKQIANwJUIAMgAikCACIMNwIwIAMgAigCCCICNgI4IAMgDDcCPCADIAI2AkQgAUHoAGogA0EMahDXA0EAQQEQAQwECyABEK8DDAALAAsMAQsgCCAHEAELIABBfzYCACADQeAAaiQACwsAIABBEEEEEIYICzsBAn8gASgCCCECIAEoAgQhAyABKAIAQX9HBEAgACADIAIQBg8LIAAgAjYCCCAAIAM2AgQgAEF/NgIAC6gBAQZ/IwBBIGsiAyQAIANBCGogAkEEQQwQByADKAIIIgcgAkH/////A3EiBCAEIAdLGyEFQQAhBCADKAIMIQgDQCAFBEAgA0EUaiABIARqIgZBBGooAgAgBkEIaigCABBCIAQgCGoiBiADKAIcNgIIIAYgAykCFDcCACAFQQFrIQUgBEEMaiEEDAELCyAAIAI2AgggACAINgIEIAAgBzYCACADQSBqJAALEAAgACABIAIgA0HUABCECAs8ACAAKAIMIAFNBEBBzNzDAEEUIAIQYgALIAAoAgQgACgCCCABaiIBIAAoAgAiAEEAIAAgAU0ba0E0bGoLSgEBfwJAIAFBA0kNACABQQNHBEAgAC0AAxCrA0UNAQsgAC0AACIBQS1rQf8BcUEBSw0AIAEgAC0AAUcNACABIAAtAAJGIQILIAILUAECfwJAAkAgACgCNCIBRQ0AIAAoAjAgAUEDdGoiAkEIayIBRQ0AIAJBBGstAABBAUcNAQsgAEGoAWohAQtBfyABKAIAIgBBAWogAEEASBsLDgAgACABQdQAQQQQiQgLSwEBfwJAIAEoAggiAkUEQEECIQEMAQsgASACQQFrIgI2AgggASgCBCACQQN0aiICLQAEIQEgAigCACECCyAAIAE6AAQgACACNgIAC5kBAQJ/IwBBEGsiAiQAIAIg", + "ACgCjAEiAzYCCCACIAMgACgCkAFqNgIMIAFBAWohAwNAIANBAWsiAwRAIAJBCGoQwgFBf0cNAQsLIAAgAigCCCIDNgKMASAAIAIoAgwgA2s2ApABIABBADoAuAEgAEEANgKwASAAIAAoApgBIAFqNgKYASAAIAAoAqABIAFqNgKgASACQRBqJAAL0wEBBX8gACgCACECIwBBEGsiASQAIAFBCGogACAAKAIAQQFBBEE0EJcBIAEoAggiBEF/RwRAIAEoAgwaIAQQHAALIAFBEGokAAJAIAAoAggiBCACIAAoAgwiA2tNDQAgAiAEayIBIAMgAWsiA0sgACgCACIFIAJrIANPcUUEQCAFIAFrIQIgAUE0bCIBBEAgACgCBCIDIAJBNGxqIAMgBEE0bGogAfwKAAALIAAgAjYCCA8LIANBNGwiAUUNACAAKAIEIgAgAkE0bGogACAB/AoAAAsLVAECfyMAQRBrIgEkACABIAAoAgAiAjYCCCABIAIgACgCBGo2AgwgAUEIahDCAUF/RwRAIAAgASgCCCICNgIAIAAgASgCDCACazYCBAsgAUEQaiQAC0gAIABBjAFqENsDIABBADYCoAEgAEEBOgC4ASAAIAAoApgBQQFqNgKYASAAIAAoApwBQQFqNgKcASAAIAAoArABQQFqNgKwAQtpAQR/IwBBEGsiAiQAIABBLGohAwNAAkACQCAAKAI0IgFFDQAgACgCMCABQQN0aiIBQQhrIgRFDQAgAUEEay0AAEEBRw0BCyACQRBqJAAPCyAAIAQoAgA2AqgBIAJBCGogAxDYAwwACwALOAIBfwF+IwBBEGsiAiQAIAJBCGogAUEBQQEQByACKQMIIQMgAEEANgIIIAAgAzcCACACQRBqJAALNQECfyAAKAKMASIBIAAoApABIgIQqgNBDUcgASACQQEQvANBCkdyRQRAIAAQygMLIAAQ3AMLCwAgAEEBQQEQhggLMQEBfwJAAkACQCAAQQprDgQCAQECAAsgAEH//QNG", + "DQELIABBIEcgAEEJR3EhAQsgAQsvAQF/QQEhAQJAIABBMGtBCkkNAEGw1cMAIAAQ6gMNAEG81cMAIAAQ6gMhAQsgAQtMAQF/AkACQCAAQTBrIgFBCk8EfyAAQeEAa0EGSQ0BIABBwQBrQQZPDQIgAEE3awUgAQsPCyAAQdcAaw8LQbD0wgBBKEGg1cMAED4ACw4AIAAQ3wMgAUEKENcCCysAIABB3wBGIABBLUZyIABBMGtBCkkgAEHhAGtBGklyIABBwQBrQRpJcnIL7gEBBX8CQAJAIAAoAhwiBiABTwRAIAYgACgCECIDRg0BDAILQeL+wgBBIEGE/8IAED4ACyAAQRBqENoDIAAoAhAhAyAAKAIcIQYLIAAoAhghBQJAIAEgBiABayIETQRAIAAgBUEBayIEIANqIgcgBCAEIAdLGyIENgIYIAMgACgCFCIHIAUgBCABEOgDIAEgBGohAQwBCyADIAAoAhQiByABIAVqIgEgA0EAIAEgA08bayABQQFqIgUgA0EAIAMgBU0bayAEEOgDCyAAIAZBAWo2AhwgByABIANBACABIANPG2tBNGxqIAJBNPwKAAALqwIBBX8gAUH+AEkhBwNAIAAoApQBIQQCQAJAIAcEQCAAQYABIAQgBEGAAU0bNgKUAQNAIAAoAqABIAFPDQIgACgCjAEgACgCkAEiAxCqA0EgRw0DIAAQygMMAAsACwNAIABBgAEgBCAEQYABTRsiAzYClAECQAJAA0AgA0UgACgCoAEiBCABT3JFBEAgACgCjAEiBSAAKAKQASIGEKoDQSBHDQIgABDKAyAAKAKUASEDDAELCyABIARGDQFBACEEIANFDQIgACgCkAEhBiAAKAKMASEFCyADIQQgBSAGEKoDQSBGDQELCyAAQQIgAyADQQJNGzYClAELIAAoApABIQMLAkACQCADRQ0AIAAoAowBLQAAQQprDgQBAAABAAsPCyAAIAIQ5AMMAAsAC7wEAQR/AkAgBEUgAiADRnINACAAIAMg", + "AmsiBWoiBiAFIAAgBksbIQcgACADayEFIAAgAmsiBiAETwRAIAQgBU0EQCAEQTRsIgBFDQIgASADQTRsaiABIAJBNGxqIAD8CgAADwsgBCAHTQRAIAEgAkE0bGohACAFQTRsIgIEQCABIANBNGxqIAAgAvwKAAALIAQgBWtBNGwiA0UNAiABIAAgAmogA/wKAAAPCyAFQTRsIQAgASACQTRsaiECIAQgBWtBNGwiBARAIAEgACACaiAE/AoAAAsgAEUNASABIANBNGxqIAIgAPwKAAAPCyAEIAdNBEAgBCAFTQRAIAEgA0E0bGohACAGQTRsIgMEQCAAIAEgAkE0bGogA/wKAAALIAQgBmtBNGwiAkUNAiAAIANqIAEgAvwKAAAPCyABIANBNGxqIQAgBkE0bCIDBEAgACABIAJBNGxqIAP8CgAACyAFIAZrQTRsIgIEQCAAIANqIAEgAvwKAAALIAQgBWtBNGwiAEUNASABIAEgAmogAPwKAAAPCyAEIAVNBEAgBkE0bCEAIAEgA0E0bGohAyAEIAZrQTRsIgQEQCAAIANqIAEgBPwKAAALIABFDQEgAyABIAJBNGxqIAD8CgAADwsgBiAFayIIQTRsIQcgBCAGa0E0bCIEBEAgASAHaiABIAT8CgAACyAHBEAgASABIAAgCGtBNGxqIAf8CgAACyAFQTRsIgBFDQAgASADQTRsaiABIAJBNGxqIAD8CgAACws8AQF/IAAoAggiAyAAKAIARgRAIAAQwAELIAAgA0EBajYCCCAAKAIEIANBA3RqIgAgAjoABCAAIAE2AgALNwEBfyABIAAoAgBPBH8gAEEAQQQgAC0ACCICG2ooAgAhACACRQRAIAAgAU8PCyAAIAFLBUEACwsIAEG4ARCKCAsuACABIANGBEAgAUEMbCIBBEAgAiAAIAH8CgAACw8LQezcwgBBKEGU3cIAED4ACy4AIAEgA0YEQCABQQJ0IgEEQCACIAAgAfwKAAALDwtB7NzCAEEoQZTdwgAQ", + "PgALVAEDfyABKAIAIgRBBGogBC8BtgFBAWoiBSABKAIIIgYgAhDzAyAEQYgBaiAFIAYgAxD0AyAEIAU7AbYBIAAgBjYCCCAAIAQ2AgAgACABKAIENgIECwgAQegBEIoIC4QBAQR/IwBBIGsiAyQAIAEvAbYBIQQgA0EAOgAcIAMgBDYCGCADQQA2AhQgAUG4AWohBANAIANBCGogA0EUahD1AyADKAIIQQFHRQRAIAQgAygCDCIFQQJ0aigCACIGIAU7AbQBIAYgATYCAAwBCwsgACACNgIEIAAgATYCACADQSBqJAAL0QEBBH8gAEEEaiAALwG2ASIFQQFqIgYgASACEPMDIABBiAFqIAYgASADEPQDIAFBAWohAiAAQbgBaiEDAkAgBUECaiIHIAFBAmoiCE0NACAFIAFrQQJ0IgVFDQAgAyAIQQJ0aiADIAJBAnRqIAX8CgAACyADIAJBAnRqIAQ2AgAgACAGOwG2ASAHIAIgAiAHSRshAyABQQJ0IABqQbwBaiEBA0AgAiADRkUEQCABKAIAIgQgAjsBtAEgBCAANgIAIAFBBGohASACQQFqIQIMAQsLC6IBAQd/AkAgAEUNAANAIABBBGohBSAALwGOAiIIQQxsIQZBfyEEAkADQCAGRQRAIAghBAwCCyAFKAIIIQkgBSgCBCEKIAZBDGshBiAEQQFqIQQgBUEMaiEFAkAgAiADIAogCRDgAUH/AXEOAgABAgsLIAAgBEEMbGpBiAFqIQcMAgsgAUUNASABQQFrIQEgACAEQQJ0aigCkAIhAAwACwALIAcLVQEBfwJAIAEgAkEBaiIETQ0AIAEgAkF/c2pBDGwiAUUNACAAIARBDGxqIAAgAkEMbGogAfwKAAALIAAgAkEMbGoiACADKAIINgIIIAAgAykCADcCAAtGAQF/AkAgASACQQFqIgRNDQAgASACQX9zakECdCIBRQ0AIAAgBEECdGogACACQQJ0aiAB/AoAAAsgACACQQJ0aiADNgIAC0MBA38C", + "QCABLQAIDQAgASgCACIDIAEoAgRLDQBBASECIAEgA0EBaiIENgIAIAEgBEU6AAgLIAAgAzYCBCAAIAI2AgALCABBkAIQiggLVAEDfyABKAIAIgRBBGogBC8BjgJBAWoiBSABKAIIIgYgAhDzAyAEQYgBaiAFIAYgAxDzAyAEIAU7AY4CIAAgBjYCCCAAIAQ2AgAgACABKAIENgIECwgAQcACEIoIC4QBAQR/IwBBIGsiAyQAIAEvAY4CIQQgA0EAOgAcIAMgBDYCGCADQQA2AhQgAUGQAmohBANAIANBCGogA0EUahD1AyADKAIIQQFHRQRAIAQgAygCDCIFQQJ0aigCACIGIAU7AYwCIAYgATYCAAwBCwsgACACNgIEIAAgATYCACADQSBqJAAL0QEBBH8gAEEEaiAALwGOAiIFQQFqIgYgASACEPMDIABBiAFqIAYgASADEPMDIAFBAWohAiAAQZACaiEDAkAgBUECaiIHIAFBAmoiCE0NACAFIAFrQQJ0IgVFDQAgAyAIQQJ0aiADIAJBAnRqIAX8CgAACyADIAJBAnRqIAQ2AgAgACAGOwGOAiAHIAIgAiAHSRshAyABQQJ0IABqQZQCaiEBA0AgAiADRkUEQCABKAIAIgQgAjsBjAIgBCAANgIAIAFBBGohASACQQFqIQIMAQsLC/gBAgN/An5B+O3DAC0AAEEBRwRAIwBBEGsiAiQAAkACQAJAAkACfgJAIABFDQAgACgCACAAQgA3AwBBAXFFDQAgACkDCCEEIAApAxAMAQsgAkEAOgAPQQEQGyIARQ0BIABBBGsoAgAiAUF4cSIDQQVBCSABQQNxIgEbSQ0CIAFBACADQSlPGw0DIAJBD2qtIQQgABA9IACtCyEFQfjtwwAtAABBAkcNAwALEB0AC0G42MIAQS5B6NjCABA+AAtB+NjCAEEuQajZwgAQPgALQfjtwwBBAToAAEHw7cMAIAU3AwBB6O3DACAENwMAIAJBEGokAAtB6O3DAAvGAQEFfyMA", + "QUBqIgMkACADQSBBAUEBEAcgA0EANgIQIAMgAykDADcCCCADQRRqQSMgASACEKICQQEhBANAAkAgBEUNACADIARBAWs2AjAgA0E0aiADQRRqEMUCIAMoAjRFDQAgAygCOCAFayEEIAEgBWohBiADKAI8IQUgA0EIaiIHIAYgBBAKIAdBAUEAEAogAygCMCEEDAELCyADQQhqIAEgBWogAiAFaxAKIAAgAygCEDYCCCAAIAMpAgg3AgAgA0FAayQACzUAIAAoAgAoAgAiACkDACAAQQhqKQMAIAEoAgAgAkEEdGsiAEEMaygCACAAQQhrKAIAEI4DCzUAIAAoAgAoAgAiACkDACAAQQhqKQMAIAEoAgAgAkF0bGoiAEEIaygCACAAQQRrKAIAEI4DCysAIAAoAgAoAgAiACkDACAAQQhqKQMAIAEoAgAgAkEEdGtBEGsoAgAQgAQLnAEBAX8jAEHQAGsiAyQAIANCADcDOCADQgA3A0AgAyABNwMwIAMgAULzytHLp4zZsvQAhTcDICADIAFC7d6R85bM3LfkAIU3AxggAyAANwMoIAMgAELh5JXz1uzZvOwAhTcDECADIABC9crNg9es27fzAIU3AwggAyACNgJMIANBCGoiAiADQcwAakEEEI4BIAIQjAEgA0HQAGokAAsrACAAKAIAKAIAIgApAwAgAEEIaikDACABKAIAIAJBAnRrQQRrKAIAEIAEC3oCAX4DfyAAKAIQIQIgACgCCCEDIAApAwAhAQN/IAFQBH8gACACQYABayICNgIQIAAgA0EIaiIENgIIIAAgAykDAEJ/hUKAgYKEiJCgwIB/gyIBNwMAIAQhAwwBBSAAIAFCAX0gAYM3AwAgAiABeqdBAXRB8AFxawsLC0sBAX8gACAAKAIAQQFrIgE2AgAgAUUEQCAAKAIIIABBDGooAgAQJgJAIABBf0YNACAAIAAoAgRBAWsiATYCBCABDQAgAEEUEBkLCwuoAQEBfyMAQSBrIgIkACACQQA2Agwg", + "AkKAgICAEDcCBAJAIAEoAgBBAUYEQCACQQRqIAEoAgggASgCDBAKDAELIAIgAUEIajYCECACQRw2AhggAiACQRBqNgIUIAJBBGpBsNrDAEGMlsAAIAJBFGoQOUUNAEHY2sMAQTcgAkEfakHI2sMAQZDbwwAQOgALIAAgAigCDDYCCCAAIAIpAgQ3AgAgAkEgaiQACwsAIAAoAgAgARB5CwwAIAAgASACEApBAAsLACAAIAEQ1wJBAAsPACAAQbDawwAgASACEDkLwQEBA38jAEEQayIDJAACQAJAIAEtAEkNACABKAIwIQQgA0EEaiABEMoCAn8gAygCBEEBRgRAIAEoAkAhAiABIAMoAgw2AkAgAiAEaiEBIAMoAgggAmsMAQsgAS0ASQ0BIAFBAToASQJAIAEtAEhBAUYEQCABKAJEIQIgASgCQCEEDAELIAEoAkQiAiABKAJAIgRGDQILIAEoAjAgBGohASACIARrCyECIAAgASACEAYMAQsgAEF/NgIACyADQRBqJAALjAEBA38jAEEQayICJAAgAkEEaiIEIAEoAgAiAyABKAIERgR/QQAFIAEgA0EIajYCACAEIAMoAgQ2AgggBCADKAIAIgFBCGpBACABGzYCBEEBCzYCAAJAIAIoAgRBAUYEQCAAIAIoAggiAEEBIAAbIAIoAgxBACAAGxAGDAELIABBfzYCAAsgAkEQaiQACx4AIAEQwgEiAUF/RwRAIAAgARDYAg8LIABBfzYCAAvdAQEDfyMAQTBrIgIkAAJAAkAgAS0AJQ0AIAEoAgQhBCACQSBqIAEQxQICfyACKAIgQQFGBEAgASgCHCEDIAEgAigCKDYCHCADIARqIQEgAigCJCADawwBCyACQQhqIAEQjQQgAigCCCIBRQ0BIAIoAgwLIQMgAkEgaiABIAMQwgJBASEEAkAgAi0AIEEBRgRAIAJBEGpBBHIgASADEAYMAQsgAiACKQMoNwMYQQAhBAsgAiAENgIQIAAgAikDGDcDCCAAIAIp", + "AxA3AwAMAQsgAEECNgIACyACQTBqJAALYwEEfwJAIAEtACUNACABQQE6ACUCQCABLQAkQQFGBEAgASgCICEEIAEoAhwhAgwBCyABKAIgIgQgASgCHCICRg0BCyAEIAJrIQUgASgCBCACaiEDCyAAIAU2AgQgACADNgIAC/MBAQV/IwBBIGsiBCQAQQRBDBDlAiEFIARBFGogASACIAMQjwQgBSAEKAIcNgIIIAUgBCkCFDcCACAEQQE2AhAgBCAFNgIMIARBATYCCEEMIQdBASEIA0ACQCADKAIAIgYgAk8NACABIAZBAnRqKAIAQfwARw0AIAMgBkEBajYCACAEQRRqIAEgAiADEI8EIAQoAgggCEYEQCAEQQhqEL0BIAQoAgwhBQsgBSAHaiIGIAQoAhw2AgggBiAEKQIUNwIAIAQgCEEBaiIINgIQIAdBDGohBwwBCwsgACAEKAIQNgIIIAAgBCkCCDcCACAEQSBqJAAL4AoBDn8jAEFAaiIHJAAgB0KAgICAwAA3AgAgAygCACEGQQQhEANAIAcgDTYCCAJAAkACQAJAIAIgBk0NACABIAZBAnRqKAIAIgRBKUYgBEH8AEZyDQAgAyAGQQFqIgU2AgACQAJAAkACQCAEQdsAaw4CAQIACyAEQS5GDQJBAiEKIARBKEcEQCAFIQYMBwsgB0EYaiABIAIgAxCOBAJAIAMoAgAiBiACTw0AIAEgBkECdGooAgBBKUcNACADIAZBAWoiBjYCAAsgBygCICEMIAcoAhwhCSAHKAIYIQRBBSEKDAYLQQAhCwJAIAIgBU0NACABIAVBAnRqKAIAQd4ARw0AIAMgBkECaiIFNgIAQQEhCwsgB0EANgIUIAdCgICAgMAANwIMQQEhBANAIAIgBU0EQCAFIQYMBgsgAyAFQQFqIgY2AgAgBEF/cyABIAVBAnRqKAIAIgRB3QBGcQ0FAkAgBEHcAEcEQCAGIQUMAQsgAiAGTQRAIAMgBUECaiIFNgIAQdwAIQQMAQsgAyAF", + "QQJqIgU2AgACQAJAAkACQCABIAZBAnRqKAIAIgRB7gBrDgcCBAQEBAEDAAsgBEHkAEcNAyAHQQxqQTBBORDVAUEAIQQMBAsgB0KNgICA0AE3AjggB0KKgICAoAE3AjAgB0KJgICAkAE3AiggB0KggICAgAQ3AiAgB0EMakEEEJYBIAcoAhQiBEEEaiEGIAcoAhAgBEEDdGohCEEAIQQDQCAEQSBGRQRAIAQgCGogBCAHakEgaikCADcCACAEQQhqIQQMAQsLIAcgBjYCFEEAIQQMAwtBCiEEDAELQQkhBAsCQAJAIAIgBU0NACABIAVBAnRqKAIAQS1HDQAgBUEBaiIGIAJPDQAgASAGQQJ0aigCACIGQd0ARw0BCyAHQQxqIAQgBBDVAUEAIQQMAQsgAyAFQQJqIgg2AgACQCAGQdwARwRAIAghBQwBC0HcACEGIAIgCEsEQCABIAhBAnRqKAIAIQYLIAMgBUEDaiIFNgIACyAHQQxqIAQgBhDVAUEAIQQMAAsACyACIAVNBEBBAiEKIAMgBkECaiIGNgIAQdwAIQQMBQtBAiEKIAMgBkECaiIGNgIAAkACQAJAIAEgBUECdGooAgAiBEHuAGsOBwEHBwcHBQIACyAEQeQARw0GQQQhCkEEQQgQ5QIiCUKwgICAkAc3AgBBASEMQQAhC0EBIQQMBgtBCiEEDAULQQkhBAwEC0EDIQogBSEGIAghBAwDCyAAIAcoAgg2AgggACAHKQIANwIAIAdBQGskAA8LQQQhCkEEQSgQ5QIiCUKMgICAwAE3AiAgCUKNgICA0AE3AhggCUKKgICAoAE3AhAgCUKJgICAkAE3AgggCUKggICAgAQ3AgBBBSEMQQAhC0EFIQQMAQsgBygCFCEMIAcoAhAhCSAHKAIMIQRBBCEKCwJ/AkAgAiAGTQ0AQQAhD0EAIQ4gBCEIAkACQAJAIAEgBkECdGooAgAiBUEqaw4CAgEACyAFQT9HDQJBASEIQQEhDwwBC0EBIQ4LIAMgBkEB", + "aiIGNgIAQQRBGBDlAiIFQQA7ABEgBSARNgIUIAUgCzoAECAFIAw2AgwgBSAJNgIIIAUgBDYCBCAFIAo2AgAgBUETakEAOgAAQQEhCUEBDAELIBEhDiAMIQUgBCEIIAohDyALCyELIAcoAgAgDUYEQCAHECcgBygCBCEQCyAQIA1BGGxqIgRBADsAESAEIA42AhQgBCALOgAQIAQgBTYCDCAEIAk2AgggBCAINgIEIAQgDzYCACAEQRNqQQA6AAAgDUEBaiENIA4hESAFIQwMAAsAC7oBAQd/IAAoAgghBiAAKAIEIQUDQCADIAZHBEAgA0EYbCEBIANBAWohAwJAAkACQEEEIAEgBWoiASgCACICQQJrIAJBAU0bDgQEBAECAAsgAUEIahCQBAwDCyABKAIEIAFBCGooAgAQnwEMAgsgAUEIaiIHKAIAIQIgASgCDCEEA0AgBARAIARBAWshBCACEJAEIAJBDGohAgwBCwsgASgCBCAHKAIAEPUCDAELCyAAKAIAIAVBBEEYEDALDQAgACABQRhBBBCHCAutBQEJfyMAQSBrIgYkAAJAAkACQAJAIAEoAhQgASgCHBCDAiABKAIgIAEoAiQiAiABKAIoIAJBACABKAIMIgQgASgCECIFELUBRQRAQX8hAgwBCyAEIAVBAEHo1sIAECEoAgAiAkUNASAEIAVBAUGI18IAECEoAgAiCEUNAiACQQFrIgMgCEEBayICTwRAIAZBFGohByMAQRBrIgQkAAJAAkACQAJAIAcCfwJAIAEoAgBBAUcNACACIAEoAgRHDQAgBEEIaiABKAIoIgMgASgCICIJIAEoAiQiAkHor8IAELcBIAQgBCgCCCAEKAIMELgBIANBASAEKAIEIgogCkEBTRsiCmoiAyAKSQ0CIAEgAzYCKEEAIAEoAhQgASgCHBCDAiAJIAIgAyACQQAgASgCDCICIAEoAhAiAxC1AUUNARogAiADQQBBiLDCABAhKAIAIglFDQMgAiADQQFBqLDCABAh", + "KAIAIgJFDQQgAkEBayECIAlBAWshAwsgByACNgIIIAcgAzYCBEEBCzYCACAEQRBqJAAMAwtB+K/CABBdAAtBmLDCABBdAAtBuLDCABBdAAsgBigCFEUEQEF/IQIMAgsgASgCECEFIAEoAgwhBCAGKAIcIQILIAEgAjYCBCABQQE2AgAgASACNgIoIAZBCGogBUEEQQQQByAGKAIMIQggBigCCCECIAVFBEBBACEFDAELIAVBAnQiA0UNACAIIAQgA/wKAAALAkAgAkF/RwRAIAEoAjAhAyABKAIsIQQgASgCNCgCACIBIAEoAgAiB0EBajYCACAHQQBIDQQgACABNgIUIAAgAzYCECAAIAQ2AgwgACAFNgIIIAAgCDYCBCAAIAI2AgAMAQsgAEF/NgIACyAGQSBqJAAPC0H41sIAEF0AC0GY18IAEF0LAAsWACAAQRhqEJQEIAAoAgggACgCDBAmC1sBA38gACgCBCEBIABBADYCBCABBEAgACgCACIAQQhqEJUEIAAoAhQiAiAAKAIMRgRAIABBDGoQ6wELIAAoAhAgAkECdGogATYCAEEAOgAAIAAgAkEBajYCFAsLdAECfyMAQRBrIgEkACAALQAAIQIgAEEBOgAAIAEgAjoADyACQQFGBEAjAEEQayIAJAAgAEHv1MAANgIMIAAgAUEPajYCCCAAQQhqQbjXwgAgAEEMakG418IAQYj8wgBBwQBBqPzCABBGAAsgAUEQaiQAIAALJgAgACgCACAAKAIEECYgACgCDCAAKAIQECYgACgCHCAAKAIgECYLDQAgACABQQRBBBCHCAt0AQR/IAEoAgQgASgCAGtBAnYiBCABKAIIIgVrIgNBACADIARNGyEDAkAgAS0AEEEBRgRAIAQgBU0NASADQQFrIAEoAgxBAWpuQQFqIQIMAQsgAyABKAIMQQFqbiECCyAAIAI2AgggAEEBNgIEIAAgAjYCAAtpAQN/IAAoAggiAUUEQCAAKAIAIgEgACgCBEYEQEEADwsg", + "ACABQQRqNgIAIAEPCyAAQQA2AgggACAAKAIAIgIgAUECdGoiA0EEaiAAKAIEIgAgASAAIAJrQQJ2SSIAGzYCACADQQAgABsLZwEDfyABKAIEIgMgASgCACIEa0ECdiECIAACfwJAIAEtAAxBAUYEQCADIARHDQFBAAwCCyACIAEoAghBAWpuDAELIAJBAWsgASgCCEEBam5BAWoLIgE2AgggAEEBNgIEIAAgATYCAAtgAQJ/IAAgAiABa0ECdiIEEJcEIAAoAgghAyAAIAEgAkcEfyADIARqIAAoAgQgA0ECdGohAwNAIAMgASgCADYCACABQQRqIQEgA0EEaiEDIARBAWsiBA0ACwUgAws2AggLXAEFfyABKAIAIQIgASgCBCEEIAEoAgghBQJ/A0BBACACIARGDQEaIAEgAkEEaiIGNgIAIAIoAgAhAyAGIQIgAyAFKAIARg0AC0EBCyECIAAgAzYCBCAAIAI2AgALiwsCFH8CfiMAQeACayIPJABCgICAgICAgIDAACABrSIagCIbIBp+QoCAgICAgICAwABSrQJ/IAFBgSBPBEAgARBrDAELQcAAIAEgAUEBdmsiBiAGQcAATxsLIRIgG3whGiAAQRBrIRcgAEEUaiEWQQEhCQNAQQAhE0EBIQogASAQSyIYBEAgACAQQQR0IgZqIQ0gGiAQQQF0An8CQCABIBBrIgogEkkNAEEAIQsCQAJAIApBAkkNACAFKAIAIgcoAgAgB0EEaigCACANQRRqKAIAIA1BGGooAgAgDUEEaigCACANQQhqKAIAEKsCRQRAIAYgFmohB0ECIQYDQCAGIApGDQIgBSgCACIMKAIAIAxBBGooAgAgB0EQaiIMKAIAIAdBFGooAgAgBygCACAHQQRqKAIAEKsCDQMgBkEBaiEGIAwhBwwACwALIAYgFmohB0ECIQYDQEEBIQsgBiAKRg0BIAUoAgAiDCgCACAMQQRqKAIAIAdBEGoiDCgCACAHQRRqKAIAIAcoAgAgB0EEaigC", + "ABCrAkUNAiAGQQFqIQYgDCEHDAALAAsgCiEGCyAGIBJJDQACQCALRQ0AIA9B0AJqIgogDSAGQQF2IgcgB0HE3cIAEJ8EIA8oAtQCIQwgDygC0AIhDiAKIA0gBkEEdGogB0EEdCIKayAHIAdB1N3CABCfBCAPKALQAiAKakEQayELIA8oAtQCIQ0gDCEKIAdBAWsiESEHAkADQCAHQX9GDQIgCkUNASANIBFLBEAgDiALQQQQhgEgCkEBayEKIA5BEGohDiALQRBrIQsgB0EBayEHDAELCyAHIA1B9N3CABAqAAsgDCAMQeTdwgAQKgALIAZBAXRBAXIMAQsgCiASIAogEkkbQQF0IARFDQAaIA1BICAKIApBIE8bIgYgAiADQQBBACAFEKAEIAZBAXRBAXILIgpBAXZqrX4gECAJQQF2a60gEK18IBp+hXmnIRMLIBcgEEEEdCIGaiENIAAgBmohGQNAAkACQAJAAkACQCAIQQJPBEAgCEEBayIMIA9BjgJqai0AACATTw0BCyAPQY4CaiAIaiATOgAAIA9BBGogCEECdGogCTYCACAYRQ0BIAhBAWohCCAKQQF2IBBqIRAgCiEJDAYLIAMgD0EEaiAMQQJ0aigCACIHQQF2IgYgCUEBdiILaiIUTyAHIAlyQQFxRXENASAAIBAgFGtBBHRqIQ4gB0EBcUUNAgwDCyAJQQFxRQRAIAAgASACIAMgBRChBAsgD0HgAmokAA8LIBRBAXQhCSAMIQgMAgsgDiAGIAIgAyAFEKEECyAJQQFxRQRAIA4gBkEEdGogCyACIAMgBRChBAsCQCAGRSALRXINACADIAsgBiAGIAtLIggbIhVJDQAgBSgCACERIA4gBkEEdGoiByAOIAgbIQkgFUEEdCIIBEAgAiAJIAj8CgAACyACIAhqIQgCQAJAIAYgC0sEQCANIQYDQCAGIAlBEGsiCyAIQRBrIhUgESgCACARQQRqKAIAIAhBDGsoAgAgCEEIaygCACAJQQxrKAIAIAlB", + "CGsoAgAQqwIiBxsiCCkCCDcCCCAGIAgpAgA3AgAgFSAHQQR0aiEIIAsgB0EBc0EEdGoiCSAORg0CIAZBEGshBiACIAhHDQALDAELIAIhBgNAIAYgCEYgByAZRnINAiAJIAcgBiARKAIAIBFBBGooAgAgB0EEaigCACAHQQhqKAIAIAZBBGooAgAgBkEIaigCABCrAiILGyIOKQIINwIIIAkgDikCADcCACAHIAtBBHRqIQcgBiALQQFzQQR0aiEGIAlBEGohCQwACwALIAIhBgsgCCAGayIHRQ0AIAkgBiAH/AoAAAsgFEEBdEEBciEJIAwhCAwACwALAAtIAQN/IAAoAgghAiAAKAIEIgMhAQNAIAIEQCABKAIAIAFBBGooAgAQJiACQQFrIQIgAUEQaiEBDAELCyAAKAIAIANBBEEQEDALEQAgACABIAIgAyAEQQQQgQgL/xEBEX8jAEEwayIOJAAgAkEQayEXAkACQANAAkACQAJAAkAgAUEhTwRAIAQNASAAIAEgAiADQQEgBhCdBAwHCyABQQJJDQYgAyABQRBqSQ0DIAYoAgAhDCABQQF2IQkgAUEPSw0BQQQhDSACIAlBBHQiA2ohBCAAIANqIQMgAUEHSwRAIAAgAiAMEKIEIAMgBCAMEKIEDAYLIAIgACkCCDcCCCACIAApAgA3AgAgBCADKQIINwIIIAQgAykCADcCAEEBIQ0MBQsgACABQQN2IgpB8ABsaiEQIAAgCkEGdGohDyABQcAATwRAIAAgDyAQIAogBhCjBCENDAILIAAhDSAGKAIAIgooAgAgCkEEaigCACAAQQRqIgcoAgAgAEEIaiIRKAIAIA9BBGoiDCgCACAPQQhqIggoAgAQqwIiCSAGKAIAIgooAgAgCkEEaigCACAHKAIAIBEoAgAgEEEEaiIHKAIAIBBBCGoiESgCABCrAkcNASAQIA8gBigCACIKKAIAIApBBGooAgAgDCgCACAIKAIAIAcoAgAgESgCABCrAiAJcxshDQwB", + "CyAAIAIgAiABQQR0aiIEIAwQpAQgACAJQQR0IgNqIAIgA2ogBEGAAWogDBCkBEEIIQ0MAwsgBEEBayEEIA4gDSkCCDcDGCAOIA0pAgA3AxAgDSAAa0EEdiERAkAgBQRAIAYoAgAiCigCACAKQQRqKAIAIAVBBGooAgAgBUEIaigCACANQQRqKAIAIA1BCGooAgAQqwJFDQELIAEgA0sNASAGKAIAIRIgAiABQQR0IhNqIQtBACEJIAAhByARIQoDQCAAIApBA2siCEEAIAggCk0bQQR0aiEQA0AgByAQT0UEQCAJQQR0IAIgC0EQayASKAIAIBJBBGoiFCgCACAHQQRqKAIAIAdBCGoiDygCACANQQRqIhUoAgAgDUEIaiIWKAIAEKsCIgwbaiIIIA8pAgA3AgggCCAHKQIANwIAIAkgDGoiD0EEdCACIAtBIGsgEigCACAUKAIAIAdBFGooAgAgB0EYaiIMKAIAIBUoAgAgFigCABCrAiIIG2oiCSAMKQIANwIIIAkgB0EQaikCADcCACAIIA9qIg9BBHQgAiALQTBrIBIoAgAgFCgCACAHQSRqKAIAIAdBKGoiDCgCACAVKAIAIBYoAgAQqwIiCBtqIgkgDCkCADcCCCAJIAdBIGopAgA3AgAgCCAPaiIPQQR0IAIgC0FAaiILIBIoAgAgFCgCACAHQTRqKAIAIAdBOGoiDCgCACAVKAIAIBYoAgAQqwIiCBtqIgkgDCkCADcCCCAJIAdBMGopAgA3AgAgCCAPaiEJIAdBQGshBwwBCwsgACAKQQR0aiEQA0AgByAQTwRAIAEgCkcEQCALQRBrIgsgCUEEdGoiCiAHKQIINwIIIAogBykCADcCACAHQRBqIQcgASEKDAMLIAlBBHQiCgRAIAAgAiAK/AoAAAsgEyAXaiEHIAAgCmohCyAJIQgDQCABIAhGRQRAIAsgBykCCDcCCCALIAcpAgA3AgAgCEEBaiEIIAtBEGohCyAHQRBrIQcMAQsLIAlFDQMgDkEg", + "aiAAIAEgCUGk3cIAEJ8EIA4oAiQhASAOKAIgIQAgDigCKCAOKAIsIAIgAyAEIA5BEGogBhCgBAwFBSAJQQR0IAIgC0EQayILIBIoAgAgEkEEaigCACAHQQRqKAIAIAdBCGoiDygCACANQQRqKAIAIA1BCGooAgAQqwIiDBtqIgggDykCADcCCCAIIAcpAgA3AgAgCSAMaiEJIAdBEGohBwwBCwALAAsACyABIANLDQAgAiABQQR0Ig9qIQtBACEIIAAhBwNAIAAgEUEDayIFQQAgBSARTRtBBHRqIQwDQCAHIAxPRQRAIAhBBHQgAiALQRBrIAYoAgAgB0EEaigCACAHQQhqIgkoAgAgDUEEaiITKAIAIA1BCGoiECgCABClBCIKG2oiBSAJKQIANwIIIAUgBykCADcCACAIIApqIghBBHQgAiALQSBrIAYoAgAgB0EUaigCACAHQRhqIgkoAgAgEygCACAQKAIAEKUEIgobaiIFIAkpAgA3AgggBSAHQRBqKQIANwIAIAggCmoiCEEEdCACIAtBMGsgBigCACAHQSRqKAIAIAdBKGoiCSgCACATKAIAIBAoAgAQpQQiChtqIgUgCSkCADcCCCAFIAdBIGopAgA3AgAgCCAKaiIIQQR0IAIgC0FAaiILIAYoAgAgB0E0aigCACAHQThqIgkoAgAgEygCACAQKAIAEKUEIgobaiIFIAkpAgA3AgggBSAHQTBqKQIANwIAIAggCmohCCAHQUBrIQcMAQsLIAAgEUEEdGohDANAIAcgDE8EQCABIBFHBEAgAiAIQQR0aiIFIAcpAgg3AgggBSAHKQIANwIAIAdBEGohByAIQQFqIQggC0EQayELIAEhEQwDCyAIQQR0IgUEQCAAIAIgBfwKAAALIA8gF2ohByABIAhrIgohCSAAIAVqIgAhCwNAIAkEQCALIAcpAgg3AgggCyAHKQIANwIAIAlBAWshCSALQRBqIQsgB0EQayEHDAELCyABIAhPBEBBACEFIAohAQwF", + "CyAIIAEgAUG03cIAECkABSAIQQR0IAIgC0EQayILIAYoAgAgB0EEaigCACAHQQhqIgkoAgAgDUEEaigCACANQQhqKAIAEKUEIgobaiIFIAkpAgA3AgggBSAHKQIANwIAIAggCmohCCAHQRBqIQcMAQsACwALAAsLAAsgDkKAgICAIDcCICAOQQA2AihBACANayERIAIgDUEEdCIDaiEKIAAgA2ohBiAOIAk2AiwgASAJayEFA0ACQCAOQQhqIA5BIGoQpgQgDigCCEEBRw0AIBEgBSAJIA4oAgwiBBsiAyANIAMgDUsbaiEIIAogBEEEdCIDaiEHIAMgBmohCyACIANqIQMDQCAIRQ0CIAcgCykCCDcCCCAHIAspAgA3AgAgAyAHIAwQpwQgCEEBayEIIAdBEGohByALQRBqIQsMAAsACwsgAiABIAAgDBCoBAsgDkEwaiQACx0AIAAgASACIAMgAUEBcmdBAXRBPnNBACAEEKAEC58DAQd/IAIoAgAgAkEEaiIDKAIAIABBFGooAgAgAEEYaigCACAAQQRqKAIAIABBCGooAgAQqwIhBSACKAIAIAMoAgAgAEE0aigCACAAQThqKAIAIABBJGooAgAgAEEoaigCABCrAiEGIAIoAgAgAygCACAAQTBBICAGG2oiBEEEaigCACAEQQhqKAIAIAAgBUEEdGoiB0EEaigCACAHQQhqKAIAEKsCIQggAigCACADKAIAIABBIEEwIAYbaiIGQQRqKAIAIAZBCGooAgAgACAFQQFzQQR0aiIAQQRqKAIAIABBCGooAgAQqwIhBSACKAIAIAMoAgAgBiAAIAQgCBsgBRsiAkEEaigCACACQQhqKAIAIAcgBCAAIAUbIAgbIgNBBGooAgAgA0EIaigCABCrAiEJIAEgBCAHIAgbIgQpAgg3AgggASAEKQIANwIAIAEgAiADIAkbIgQpAgg3AhggASAEKQIANwIQIAEgAyACIAkbIgIpAgg3AiggASACKQIANwIgIAEgACAG", + "IAUbIgApAgA3AjAgASAAKQIINwI4C4cCAQR/IANBCE8EQCAAIAAgA0EDdiIDQQZ0IgVqIAAgA0HwAGwiBmogAyAEEKMEIQAgASABIAVqIAEgBmogAyAEEKMEIQEgAiACIAVqIAIgBmogAyAEEKMEIQILIAQoAgAiAygCACADQQRqKAIAIABBBGoiAygCACAAQQhqIgUoAgAgAUEEaiIGKAIAIAFBCGooAgAQqwIiByAEKAIAIggoAgAgCEEEaigCACADKAIAIAUoAgAgAkEEaiIDKAIAIAJBCGooAgAQqwJGBH8gAiABIAQoAgAiACgCACAAQQRqKAIAIAYoAgAgAUEIaigCACADKAIAIAJBCGooAgAQqwIgB3MbBSAACwslACAAIAIgAxCiBCAAQUBrIAJBQGsgAxCiBCACQQggASADEKgECx0AIAAoAgAgAEEEaigCACADIAQgASACEKsCQQFzC0ABAX8gASgCACICIAEoAgRGBH9BAAUgASACQQFqNgIAIAEgAkECdGooAgghAUEBCyECIAAgATYCBCAAIAI2AgAL8AEBB38gAigCACACQQRqIgYoAgAgAUEEaiIEKAIAIAFBCGoiBSgCACABQQxrKAIAIAFBCGsoAgAQqwIEQCABQRxrIQMgBSgCACEFIAQoAgAhBCABKAIMIQcgASgCACEIAn8CQANAIAMiAUEkaiABQRRqKQIANwIAIAFBHGoiCSABQQxqIgMpAgA3AgAgACADRg0BIAFBEGshAyACKAIAIAYoAgAgBCAFIAEoAgAgAUEEaigCABCrAg0ACyAJDAELIAFBHGoLIQMgAUEMaiAINgIAIANBBGsgBzYCACADQQhrIAU2AgAgA0EMayAENgIACwvrAgEIfyACIAFBBHRBEGsiBGohByAAIARqIQYgACABQQF2IglBBHRqIgRBEGshBQNAIAkEQCACIAQgACADKAIAIANBBGoiCigCACAEQQRqKAIAIARBCGooAgAgAEEEaigCACAAQQhqKAIA", + "EKsCIggbIgspAgg3AgggAiALKQIANwIAIAcgBSAGIAMoAgAgCigCACAGQQRqKAIAIAZBCGooAgAgBUEEaigCACAFQQhqKAIAEKsCIgobIgspAgg3AgggByALKQIANwIAIAQgCEEEdGohBCAAIAhBAXNBBHRqIQAgBSAKQQR0IghrIQUgBiAIakEQayEGIAlBAWshCSAHQRBrIQcgAkEQaiECDAEFAkAgBUEQaiEDIAFBAXEEfyACIAAgBCAAIANJIgEbIgUpAgg3AgggAiAFKQIANwIAIAQgACADT0EEdGohBCAAIAFBBHRqBSAACyADRiAEIAZBEGpGcQ0AEGoACwsLC+kKAhN/An4jAEHgAmsiDSQAQoCAgICAgICAwAAgAa0iGIAiGSAYfkKAgICAgICAgMAAUq0CfyABQYEgTwRAIAEQawwBC0HAACABIAFBAXZrIgUgBUHAAE8bCyESIBl8IRggAEEUayEVIABBGGohFEEBIQcDQEEAIQ9BASEJIAEgDksiFgRAIAAgDkEUbCIFaiELIBggDkEBdAJ/AkAgASAOayIJIBJJDQBBACEKAkACQCAJQQJJDQAgC0EYaigCACALQRxqKAIAIAtBBGooAgAgC0EIaigCABDgAUH/AXFB/wFHBEAgBSAUaiEGQQIhBQNAIAUgCUYNAiAGQRRqIgwoAgAgBkEYaigCACAGKAIAIAZBBGooAgAQ4AFB/wFxQf8BRg0DIAVBAWohBSAMIQYMAAsACyAFIBRqIQZBAiEFA0BBASEKIAUgCUYNASAGQRRqIgwoAgAgBkEYaigCACAGKAIAIAZBBGooAgAQ4AFB/wFxQf8BRw0CIAVBAWohBSAMIQYMAAsACyAJIQULIAUgEkkNAAJAIApFDQAgDUHQAmoiCSALIAVBAXYiBiAGQcTdwgAQqwQgDSgC1AIhDCANKALQAiEKIAkgCyAFQRRsaiAGQWxsaiAGIAZB1N3CABCrBCANKALQAiAGQRRsakEUayELIA0oAtQCIQ8g", + "DCEJIAZBAWsiESEGAkADQCAGQX9GDQIgCUUNASAPIBFLBEAgCiALQQUQhgEgCUEBayEJIApBFGohCiALQRRrIQsgBkEBayEGDAELCyAGIA9B9N3CABAqAAsgDCAMQeTdwgAQKgALIAVBAXRBAXIMAQsgCSASIAkgEkkbQQF0IARFDQAaIAtBICAJIAlBIE8bIgUgAiADQQBBABCsBCAFQQF0QQFyCyIJQQF2aq1+IA4gB0EBdmutIA6tfCAYfoV5pyEPCyAVIA5BFGwiBWohCyAAIAVqIRcDQAJAAkACQAJAAkAgCEECTwRAIAhBAWsiDCANQY4CamotAAAgD08NAQsgDUGOAmogCGogDzoAACANQQRqIAhBAnRqIAc2AgAgFkUNASAIQQFqIQggCUEBdiAOaiEOIAkhBwwGCyADIA1BBGogDEECdGooAgAiCEEBdiIFIAdBAXYiBmoiEU8gByAIckEBcUVxDQEgACAOIBFrQRRsaiEKIAhBAXFFDQIMAwsgB0EBcUUEQCAAIAEgAiADEK0ECyANQeACaiQADwsgEUEBdCEHIAwhCAwCCyAKIAUgAiADEK0ECyAHQQFxRQRAIAogBUEUbGogBiACIAMQrQQLAkAgBUUgBkVyDQAgAyAGIAUgBSAGSyIQGyIISQ0AIAogBUEUbGoiBiAKIBAbIQcgCEEUbCIFBEAgAiAHIAX8CgAACyACIAVqIQgCQCAQRQRAIAIhBQNAIAUgCEYgBiAXRnINAiAHIAYgBSAGQQRqKAIAIAZBCGooAgAgBUEEaigCACAFQQhqKAIAEOABQf8BcSIQQf8BRiITGyIKKAIQNgIQIAcgCikCCDcCCCAHIAopAgA3AgAgBiATQRRsaiEGIAUgEEH/AUdBFGxqIQUgB0EUaiEHDAALAAsgCyEFA0ACQCAFIAdBFGsiECAIQRRrIhMgCEEQaygCACAIQQxrKAIAIAdBEGsoAgAgB0EMaygCABDgAUH/AXEiB0H/AUYiCBsiBigCEDYCECAF", + "IAYpAgg3AgggBSAGKQIANwIAIBMgCEEUbGohCCAQIAdB/wFHQRRsaiIHIApGDQAgBUEUayEFIAIgCEcNAQsLIAIhBQsgCCAFayIGRQ0AIAcgBSAG/AoAAAsgEUEBdEEBciEHIAwhCAwACwALAAsMACAAIAFBBEEUEDALOwAgAiADSQRAQcHrwgBBEyAEEDUACyAAIAM2AgQgACABNgIAIAAgAiADazYCDCAAIAEgA0EUbGo2AggLqQ4BDX8jAEEwayIKJAAgAkEUayEOAkADQAJAAkAgAUEhTwRAIAQNASAAIAEgAiADQQEQqQQMBAsgAUECSQ0DIAMgAUEQakkNAUEBIQQgAiABQQF2IgNBFGwiBWohCSAAIAVqIQUCQCABQQdLBEAgACACEK4EIAUgCRCuBEEEIQQMAQsgAiAAKAIQNgIQIAIgACkCCDcCCCACIAApAgA3AgAgCSAFKAIQNgIQIAkgBSkCCDcCCCAJIAUpAgA3AgALIApCgICAgCA3AgggCkEANgIQQQAgBGshDCACIARBFGwiBWohCyAAIAVqIQ4gCiADNgIUIAEgA2shDQNAAkAgCiAKQQhqEKYEIAooAgBBAUcNACAMIA0gAyAKKAIEIgUbIgcgBCAEIAdJG2ohByALIAVBFGwiBWohBiAFIA5qIQggAiAFaiEFA0AgB0UNAiAGIAgoAhA2AhAgBiAIKQIINwIIIAYgCCkCADcCACAFIAYQrwQgB0EBayEHIAZBFGohBiAIQRRqIQgMAAsACwsgCUEUayEGIAAgAUEUbEEUayIEaiEHIAIgBGohCANAIAMEQCAAIAkgAiAJQQRqKAIAIAlBCGooAgAgAkEEaigCACACQQhqKAIAEOABQf8BcSIFQf8BRiIMGyIEKAIQNgIQIAAgBCkCCDcCCCAAIAQpAgA3AgAgByAGIAggCEEEaigCACAIQQhqKAIAIAZBBGooAgAgBkEIaigCABDgAUH/AXEiC0H/AUYiDhsiBCgCEDYCECAHIAQpAgg3", + "AgggByAEKQIANwIAIAIgBUH/AUdBFGxqIQIgCSAMQRRsaiEJIAZBbEEAIA4baiEGIAhBbEEAIAtB/wFHG2ohCCADQQFrIQMgB0EUayEHIABBFGohAAwBBSAGQRRqIQMgAUEBcQR/IAAgAiAJIAIgA0kiBBsiASgCEDYCECAAIAEpAgg3AgggACABKQIANwIAIAkgAiADT0EUbGohCSACIARBFGxqBSACCyADRiAJIAhBFGpGcQ0FEGoACwALAAsgACABQQN2IgZBjAFsaiEMIAAgBkHQAGxqIQcgBEEBayEEIAoCfyABQcAATwRAIAAgByAMIAYQsAQMAQsgACAAQQRqKAIAIgYgAEEIaigCACIIIAdBBGooAgAiCSAHQQhqKAIAIg0Q4AFB/wFxQf8BRiIPIAYgCCAMQQRqKAIAIgYgDEEIaigCACIIEOABQf8BcUH/AUZzDQAaIAwgByAPIAkgDSAGIAgQ4AFB/wFxQf8BRnMbCyILKAIQNgIYIAogCykCCDcDECAKIAspAgA3AwggCyAAa0EUbiEMAkAgBQRAIAVBBGooAgAgBUEIaigCACALQQRqKAIAIAtBCGooAgAQ4AFB/wFxQf8BRw0BCyABIANLDQEgAiABQRRsIg9qIQlBACEIIAAhBiAMIQcDQCAAIAdBFGxqIRADQCAGIBBPBEAgASAHRwRAIAlBFGsiCSAIQRRsaiIHIAYoAhA2AhAgByAGKQIINwIIIAcgBikCADcCACAGQRRqIQYgASEHDAMLIAhBFGwiBwRAIAAgAiAH/AoAAAsgDiAPaiEGIAAgB2ohByAIIQkDQCABIAlGRQRAIAcgBigCEDYCECAHIAYpAgg3AgggByAGKQIANwIAIAlBAWohCSAHQRRqIQcgBkEUayEGDAELCyAIRQ0DIApBIGogACABIAhBpN3CABCrBCAKKAIkIQEgCigCICEAIAooAiggCigCLCACIAMgBCAKQQhqEKwEDAUFIAhBFGwgAiAJQRRrIgkgBkEEaigC", + "ACAGQQhqIhEoAgAgC0EEaigCACALQQhqKAIAEOABQf8BcUH/AUYiEhtqIg0gBigCEDYCECANIBEpAgA3AgggDSAGKQIANwIAIAggEmohCCAGQRRqIQYMAQsACwALAAsgASADSw0AIAIgAUEUbCIHaiEJQQAhCCAAIQYDQCAAIAxBFGxqIQ0DQCAGIA1PBEAgASAMRwRAIAIgCEEUbGoiBSAGKAIQNgIQIAUgBikCCDcCCCAFIAYpAgA3AgAgBkEUaiEGIAhBAWohCCAJQRRrIQkgASEMDAMLIAhBFGwiBQRAIAAgAiAF/AoAAAsgByAOaiEGIAEgCGsiDCELIAAgBWoiACEHA0AgCwRAIAcgBigCEDYCECAHIAYpAgg3AgggByAGKQIANwIAIAtBAWshCyAHQRRqIQcgBkEUayEGDAELCyABIAhPBEBBACEFIAwhAQwFCyAIIAEgAUG03cIAECkABSAIQRRsIAIgCUEUayIJIAtBBGooAgAgC0EIaigCACAGQQRqKAIAIAZBCGoiDygCABDgAUH/AXFB/wFHIhAbaiIFIAYoAhA2AhAgBSAPKQIANwIIIAUgBikCADcCACAIIBBqIQggBkEUaiEGDAELAAsACwALCwALIApBMGokAAsbACAAIAEgAiADIAFBAXJnQQF0QT5zQQAQrAQLugMBCH8gAEEYaigCACAAQRxqKAIAIABBBGooAgAgAEEIaigCABDgASEDIABBPEEoIABBQGsoAgAgAEHEAGooAgAgAEEsaigCACAAQTBqKAIAEOABQf8BcUH/AUYiBBtqIQIgAEEoQTwgBBtqIgQgACADQf8BcSIFQf8BR0EUbGoiAyACIAJBBGooAgAgAkEIaigCACAAIAVB/wFGQRRsaiIAQQRqKAIAIABBCGooAgAQ4AFB/wFxQf8BRiIHGyAEQQRqKAIAIARBCGooAgAgA0EEaigCACADQQhqKAIAEOABQf8BcUH/AUYiCBsiBUEEaigCACAFQQhqKAIAIAAgAiAD", + "IAgbIAcbIgZBBGooAgAgBkEIaigCABDgASEJIAEgAiAAIAcbIgAoAhA2AhAgASAAKQIINwIIIAEgACkCADcCACABIAUgBiAJQf8BcUH/AUYiAhsiACgCEDYCJCABIAApAgg3AhwgASAAKQIANwIUIAEgBiAFIAIbIgAoAhA2AjggASAAKQIINwIwIAEgACkCADcCKCABIAMgBCAIGyIAKQIANwI8IAEgACkCCDcCRCABIAAoAhA2AkwL6wECBX8BfiABQQRqKAIAIgMgAUEIaigCACIEIAFBEGsoAgAgAUEMaygCABDgAUH/AXFB/wFGBEAgAUEkayECIAEpAgwhByABKAIAIQUCfwJAA0AgAiIBQTRqIAFBIGooAgA2AgAgAUEsaiABQRhqKQIANwIAIAFBJGoiBiABQRBqIgIpAgA3AgAgACACRg0BIAFBFGshAiADIAQgASgCACABQQRqKAIAEOABQf8BcUH/AUYNAAsgBgwBCyABQSRqCyECIAFBEGogBTYCACACQQhrIAc3AgAgAkEMayAENgIAIAJBEGsgAzYCAAsL0AEBBH8gA0EITwRAIAAgACADQQN2IgNB0ABsIgRqIAAgA0GMAWwiBWogAxCwBCEAIAEgASAEaiABIAVqIAMQsAQhASACIAIgBGogAiAFaiADELAEIQILIABBBGooAgAiAyAAQQhqKAIAIgQgAUEEaigCACIFIAFBCGooAgAiBhDgAUH/AXFB/wFGIgcgAyAEIAJBBGooAgAiAyACQQhqKAIAIgQQ4AFB/wFxQf8BRnMEfyAABSACIAEgByAFIAYgAyAEEOABQf8BcUH/AUZzGwsLLgAgACABIAMQrAIiAEEoaigCACAAQSxqKAIAIAJBBGooAgAgAkEIaigCABCWAwskACAAIAEgAhCsAiIAQShqKAIAIABBLGooAgBB4d/CAEECEBIL+AEBAX8jAEEwayIEJAAgBEEANgIUIAQgAzYCECAEIAI2AgwgBEEANgIgIARCgICAgMAA", + "NwIYAkADQAJAIARBDGoiAhC/BCAEKAIUIAQoAhBPDQAgBEEkaiACIAFBACAEEMAEIAQoAighAiAEKAIkIgNBf0cEQCAAIAQoAiw2AgwgACACNgIIIAAgAzYCBCAAQQE2AgAgBCgCGCAEKAIcECYMAwUgASgCBCABKAIIIAIQ4QIiA0EBOgCYASADIAQoAiA2AogBIARBGGogAhDgAgwCCwALCyAAIAQoAiA2AgwgACAEKQIYNwIEIABBADYCAAsgBEEwaiQACxUAIAAgASACIANBAUEAIARBARDBBAuDhgEDHn8BfgF8IwBB0AxrIgUkACAFQdgIaiEYIAIhCyMAQdAYayIEJABBCEGgKhDlAiIDQYPuATsBiCogA0EFNgKEKiADQbqqwwA2AoAqIANBADoA6CkgA0EDNgLkKSADQbeqwwA2AuApIANBgy47AcgpIANBAjYCxCkgA0G1qsMANgLAKSADQYMUOwGoKSADQQM2AqQpIANBsqrDADYCoCkgA0GDLDsBiCkgA0ECNgKEKSADQbCqwwA2AoApIANBgxI7AegoIANBAzYC5CggA0GtqsMANgLgKCADQYMqOwHIKCADQQE2AsQoIANBrKrDADYCwCggA0GDKDsBqCggA0ECNgKkKCADQaqqwwA2AqAoIANBkSQ7AYgoIANBDTYChCggA0GdqsMANgKAKCADQZEmOwHoJyADQQ42AuQnIANBj6rDADYC4CcgA0GDDDsByCcgA0EBNgLEJyADQa2XwwA2AsAnIANBg84BOwGoJyADQQI2AqQnIANBjarDADYCoCcgA0GDDjsBiCcgA0ECNgKEJyADQYuqwwA2AoAnIANBBjsB6CYgA0EkNgLkJiADQeepwwA2AuAmIANBhgI7AcgmIANBDTYCxCYgA0HaqcMANgLAJiADQQA6AKgmIANBCDYCpCYgA0HSqcMANgKgJiADQQs7AYgmIANBBTYChCYgA0HNqcMANgKAJiADQYsCOwHoJSADQQc2AuQlIANBxqnD", + "ADYC4CUgA0GDOjsByCUgA0EDNgLEJSADQcOpwwA2AsAlIANBgzg7AaglIANBAzYCpCUgA0HAqcMANgKgJSADQQA7AZQlIANBhYCAgHg2ApAlIANBhDY7AYglIANBBzYChCUgA0G5qcMANgKAJSADQYACOwH0JCADQYWAgIB4NgLwJCADQYQ2OwHoJCADQQc2AuQkIANBsqnDADYC4CQgA0EBOwHUJCADQYWAgIB4NgLQJCADQYQ2OwHIJCADQQg2AsQkIANBqqnDADYCwCQgA0GBAjsBtCQgA0GFgICAeDYCsCQgA0GENjsBqCQgA0EINgKkJCADQaKpwwA2AqAkIANBgzQ7AYgkIANBCDYChCQgA0GaqcMANgKAJCADQYMyOwHoIyADQQg2AuQjIANBkqnDADYC4CMgA0GD3AE7AcgjIANBCDYCxCMgA0GKqcMANgLAIyADQRA6AKgjIANBGzYCpCMgA0HvqMMANgKgIyADQQ87AYgjIANBDTYChCMgA0HiqMMANgKAIyADQY8COwHoIiADQRA2AuQiIANB0qjDADYC4CIgA0EOOgDIIiADQRg2AsQiIANBuqjDADYCwCIgA0ENOgCoIiADQRI2AqQiIANBqKjDADYCoCIgA0EMOwGIIiADQRQ2AoQiIANBlKjDADYCgCIgA0GMAjsB6CEgA0EQNgLkISADQYSowwA2AuAhIANBFToAyCEgA0EFNgLEISADQf+nwwA2AsAhIANBFDoAqCEgA0EMNgKkISADQfOnwwA2AqAhIANBFDoAiCEgA0EbNgKEISADQdinwwA2AoAhIANBEzoA6CAgA0ERNgLkICADQcenwwA2AuAgIANBg7wBOwHIICADQQo2AsQgIANBvafDADYCwCAgA0GDugE7AaggIANBBDYCpCAgA0G5p8MANgKgICADQQA6AJQgIANBjoCAgHg2ApAgIANBhLgBOwGIICADQRg2AoQgIANBoafDADYCgCAgA0EBOgD0HyADQY6AgIB4NgLwHyAD", + "QYS4ATsB6B8gA0EUNgLkHyADQY2nwwA2AuAfIANBg5IBOwHIHyADQSA2AsQfIANB7abDADYCwB8gA0GDMDsBqB8gA0EENgKkHyADQemmwwA2AqAfIANBgwo7AYgfIANBATYChB8gA0HopsMANgKAHyADQQE6AOoeIANBgQQ7AegeIANBAzYC5B4gA0GT48IANgLgHiADQYMIOwHIHiADQQQ2AsQeIANB8uPCADYCwB4gA0GDCDsBqB4gA0EENgKkHiADQd7iwgA2AqAeIANBgwY7AYgeIANBBDYChB4gA0Ha4sIANgKAHiADQQM2AvAdIANBk+PCADYC7B0gA0EAOgDqHSADQYICOwHoHSADQQI2AuQdIANB2OLCADYC4B0gA0GKAjsByB0gA0EONgLEHSADQdqmwwA2AsAdIANBCjsBqB0gA0EMNgKkHSADQc6mwwA2AqAdIANBgICAgHg2ApAdIANBEToAih0gA0GFkAE7AYgdIANBBTYChB0gA0H038IANgKAHSADQYCAgIB4NgLwHCADQRA6AOocIANBhY4BOwHoHCADQQY2AuQcIANByKbDADYC4BwgA0GDggE7AcgcIANBBDYCxBwgA0HEpsMANgLAHCADQYCAgIB4NgKwHCADQQ46AKocIANBhYABOwGoHCADQQg2AqQcIANBvKbDADYCoBwgA0GAgICAeDYCkBwgA0EMOgCKHCADQYX+ADsBiBwgA0EFNgKEHCADQbemwwA2AoAcIANBg+wBOwHoGyADQQM2AuQbIANBtKbDADYC4BsgA0GDyAA7AcgbIANBBzYCxBsgA0GtpsMANgLAGyADQYP4ADsBqBsgA0EENgKkGyADQammwwA2AqAbIANBg/YAOwGIGyADQRk2AoQbIANBkKbDADYCgBsgA0GD9AA7AegaIANBGTYC5BogA0H3pcMANgLgGiADQYPyADsByBogA0EVNgLEGiADQeKlwwA2AsAaIANBg5wBOwGoGiADQQo2AqQaIANB2KXDADYC", + "oBogA0GDmgE7AYgaIANBCTYChBogA0HPpcMANgKAGiADQYOYATsB6BkgA0EENgLkGSADQculwwA2AuAZIANBg5YBOwHIGSADQRg2AsQZIANBs6XDADYCwBkgA0GDlAE7AagZIANBEzYCpBkgA0GgpcMANgKgGSADQYOGATsBiBkgA0EHNgKEGSADQZmlwwA2AoAZIANBg4QBOwHoGCADQQM2AuQYIANBlqXDADYC4BggA0GDxgE7AcgYIANBBDYCxBggA0GSpcMANgLAGCADQRc6AKgYIANBBjYCpBggA0GMpcMANgKgGCADQRY6AIgYIANBEjYChBggA0H6pMMANgKAGCADQYOKATsB6BcgA0EHNgLkFyADQfOkwwA2AuAXIANBg7YBOwHIFyADQQU2AsQXIANB7qTDADYCwBcgA0GD7AA7AagXIANBCDYCpBcgA0HmpMMANgKgFyADQYPqADsBiBcgA0EDNgKEFyADQeOkwwA2AoAXIANBg/AAOwHoFiADQQU2AuQWIANB3qTDADYC4BYgA0GD6AA7AcgWIANBAzYCxBYgA0HbpMMANgLAFiADQYPuADsBqBYgA0EFNgKkFiADQdakwwA2AqAWIANBg6QBOwGIFiADQQc2AoQWIANBz6TDADYCgBYgA0GDogE7AegVIANBBTYC5BUgA0HKpMMANgLgFSADQYOmATsByBUgA0EENgLEFSADQcakwwA2AsAVIANBg6ABOwGoFSADQQg2AqQVIANBvqTDADYCoBUgA0GDtAE7AYgVIANBBDYChBUgA0G6pMMANgKAFSADQYOyATsB6BQgA0EHNgLkFCADQbOkwwA2AuAUIANBg7ABOwHIFCADQQU2AsQUIANBrqTDADYCwBQgA0GDrgE7AagUIANBAzYCpBQgA0GrpMMANgKgFCADQYOsATsBiBQgA0EENgKEFCADQaekwwA2AoAUIANBgwQ7AegTIANBBzYC5BMgA0GgpMMANgLgEyADQYPWATsByBMgA0EDNgLE", + "EyADQZ2kwwA2AsATIANBgwI7AagTIANBAzYCpBMgA0GapMMANgKgEyADQQM7AYgTIANBAjYChBMgA0GYpMMANgKAEyADQYOeATsB6BIgA0EHNgLkEiADQZGkwwA2AuASIANBg+gBOwHIEiADQQk2AsQSIANBiKTDADYCwBIgA0GD5AE7AagSIANBBjYCpBIgA0GCpMMANgKgEiADQYPmATsBiBIgA0EKNgKEEiADQfijwwA2AoASIANBg+IBOwHoESADQQM2AuQRIANB9aPDADYC4BEgA0GD4AE7AcgRIANBBjYCxBEgA0Hvo8MANgLAESADQYP6ADsBqBEgA0ETNgKkESADQdyjwwA2AqARIANBg8QBOwGIESADQQY2AoQRIANB1qPDADYCgBEgA0EbOwHoECADQQQ2AuQQIANB0qPDADYC4BAgA0GDwgE7AcgQIANBEzYCxBAgA0G/o8MANgLAECADQZsEOwGoECADQQs2AqQQIANBtKPDADYCoBAgA0GbDDsBiBAgA0EMNgKEECADQaijwwA2AoAQIANBmwY7AegPIANBEzYC5A8gA0GVo8MANgLgDyADQQA2AswPIANBmRI7AcgPIANBAzYCxA8gA0GSo8MANgLADyADQQA2AqwPIANBmRA7AagPIANBBDYCpA8gA0GOo8MANgKgDyADQZoQOwGIDyADQQU2AoQPIANBiaPDADYCgA8gA0EANgLsDiADQZkMOwHoDiADQQc2AuQOIANBgqPDADYC4A4gA0GaDDsByA4gA0EINgLEDiADQfqiwwA2AsAOIANBADYCrA4gA0GZDjsBqA4gA0EKNgKkDiADQfCiwwA2AqAOIANBmg47AYgOIANBCzYChA4gA0HlosMANgKADiADQQA2AuwNIANBmQo7AegNIANBDDYC5A0gA0HZosMANgLgDSADQZoKOwHIDSADQQ82AsQNIANByqLDADYCwA0gA0EANgKsDSADQZkIOwGoDSADQQw2AqQNIANBvqLDADYCoA0g", + "A0GaCDsBiA0gA0EPNgKEDSADQa+iwwA2AoANIANBADYC7AwgA0GZBjsB6AwgA0EENgLkDCADQauiwwA2AuAMIANBAjYCzAwgA0GZBjsByAwgA0EHNgLEDCADQaSiwwA2AsAMIANBmgY7AagMIANBDzYCpAwgA0GVosMANgKgDCADQQI2AowMIANBmQQ7AYgMIANBEDYChAwgA0GFosMANgKADCADQZoEOwHoCyADQRM2AuQLIANB8qHDADYC4AsgA0EANgLMCyADQZkCOwHICyADQQU2AsQLIANB7aHDADYCwAsgA0ECNgKsCyADQZkCOwGoCyADQQg2AqQLIANB5aHDADYCoAsgA0ECNgKMCyADQRk7AYgLIANBDjYChAsgA0HXocMANgKACyADQRo7AegKIANBIzYC5AogA0G0ocMANgLgCiADQZgCOwHICiADQRI2AsQKIANBoqHDADYCwAogA0GYBjsBqAogA0ERNgKkCiADQZGhwwA2AqAKIANBGDsBiAogA0ESNgKECiADQf+gwwA2AoAKIANBCjYC8AkgA0HxoMMANgLsCSADQQg6AOgJIANBBDYC5AkgA0H7oMMANgLgCSADQT42AtAJIANBpaDDADYCzAkgA0EIOgDICSADQQ42AsQJIANB46DDADYCwAkgA0GDqgE7AagJIANBCjYCpAkgA0GboMMANgKgCSADQYOqATsBiAkgA0EINgKECSADQZOgwwA2AoAJIANBg6gBOwHoCCADQQc2AuQIIANBjKDDADYC4AggA0GDzgA7AcgIIANBBTYCxAggA0GHoMMANgLACCADQYPaADsBqAggA0EINgKkCCADQf+fwwA2AqAIIANBg+IAOwGICCADQQg2AoQIIANB95/DADYCgAggA0GD4AA7AegHIANBCjYC5AcgA0Htn8MANgLgByADQYPeADsByAcgA0ECNgLEByADQeufwwA2AsAHIANBg9wAOwGoByADQQM2AqQHIANB6J/DADYCoAcgA0GD2AA7", + "AYgHIANBDzYChAcgA0HZn8MANgKAByADQn83A/gGIANBiICAgHg2AvAGIANBhOoBOwHoBiADQQc2AuQGIANB0p/DADYC4AYgA0EJOgDIBiADQRE2AsQGIANBwZ/DADYCwAYgA0GD0gA7AagGIANBBDYCpAYgA0G9n8MANgKgBiADQYPQADsBiAYgA0EENgKEBiADQbmfwwA2AoAGIANBg8wAOwHoBSADQQY2AuQFIANBs5/DADYC4AUgA0GDygA7AcgFIANBAzYCxAUgA0Hr38IANgLABSADQYPWADsBqAUgA0ELNgKkBSADQaifwwA2AqAFIANBg9gBOwGIBSADQQo2AoQFIANBnp/DADYCgAUgA0GD1AA7AegEIANBBDYC5AQgA0Gan8MANgLgBCADQYPEADsByAQgA0EGNgLEBCADQZSfwwA2AsAEIANBg8IAOwGoBCADQQQ2AqQEIANBkJ/DADYCoAQgA0GDwAA7AYgEIANBBjYChAQgA0GKn8MANgKABCADQYM8OwHoAyADQQQ2AuQDIANBhp/DADYC4AMgA0EBOgDUAyADQYeAgIB4NgLQAyADQYQaOwHIAyADQQM2AsQDIANBg5/DADYCwAMgA0EAOgC0AyADQYeAgIB4NgKwAyADQYQaOwGoAyADQQI2AqQDIANBgZ/DADYCoAMgA0ESOgCIAyADQRE2AoQDIANB8J7DADYCgAMgA0EHOwHoAiADQQQ2AuQCIANB7J7DADYC4AIgA0GHAjsByAIgA0EGNgLEAiADQeaewwA2AsACIANBAToAqgIgA0GBDDsBqAIgA0ECNgKkAiADQeSewwA2AqACIANBADoAigIgA0GBCjsBiAIgA0ECNgKEAiADQeKewwA2AoACIANBAToA6gEgA0GBCDsB6AEgA0EFNgLkASADQd2ewwA2AuABIANBADoAygEgA0GBBjsByAEgA0ECNgLEASADQduewwA2AsABIANBADoAqgEgA0GBDjsBqAEgA0EENgKkASADQdee", + "wwA2AqABIANBAToAigEgA0GBBDsBiAEgA0ECNgKEASADQdWewwA2AoABIANBADoAaiADQYECOwFoIANBAjYCZCADQdOewwA2AmAgA0EBOgBWIANBADsBVCADQYaAgIB4NgJQIANBDzoASiADQYWMATsBSCADQRk2AkQgA0G6nsMANgJAIANBADoANiADQYACOwE0IANBhoCAgHg2AjAgA0EPOgAqIANBhYwBOwEoIANBGTYCJCADQaGewwA2AiAgA0EAOgAWIANBATsBFCADQYaAgIB4NgIQIANBDzoACiADQYWMATsBCCADQRk2AgQgA0GInsMANgIAIARBiAFqQakBQQhBKBAHIARBADYCqBMgBCAEKAKMASIWNgKkEyAEIAQoAogBIgI2AqATIAJBqAFNBEAgBEGgE2pBAEGpAUEIQSgQLyAEKAKkEyEWIAQoAqgTIQcLIAdBqQFqIRsgB0EobCEIQQAhAgNAIAJBoCpHBEAgAiADaiIGKAIAIQcgBkEEaigCACERIAQgBkEYaikDADcDiBUgBCAGQRBqKQMANwOAFSAEIAZBCGopAwA3A/gUIARBuAFqIAcgByARahAgIARBADYCyBEgBEGgDGogBCgCvAEiESAEKALAASAEQcgRahCOBAJ/IAQoAqgMQQFGBEAgBCgCpAwiBigCCCEJIAYoAgQhCiAGKAIAIQcgBCgCoAwgBhD1AkEAIAcgB0F/RiIHGyEGQQQgCiAHGyEKQQAgCSAHGwwBC0EEQRgQ5QIiCkEFNgIAIAogBCkCoAw3AgQgCiAEKAKoDDYCDEEBIQZBAQshCSAEKAK4ASARECYgCCAWaiIHIAQpA4gVNwMQIAcgBCkDgBU3AwggByAEKQP4FDcDACAHQSBqIAk2AgAgB0EcaiAKNgIAIAdBGGogBjYCACACQSBqIQIgCEEoaiEIDAELC0GpASADQQhBIBAwIAQoAqATIARBlAFqIAEgASALahAgIARBADYCqAEgBEKAgICAgAE3AqABIBZB", + "IGohESAEQbAMaiEcIARBiAVqIR0gBEGoGGohDCAEQdAWaiETIARBvBZqIRAgBEG0GGohDyAEQeQUaiEUIARBtBFqIRogBEGoE2ohHiAEQYAVaiEZIARB3A9qIQ4gBEHQD2ohDSAEQfgNaiEVIAQoApwBIRdBACEGAkADQCAGIBdPBEAgBCAEKAKoASIDNgL4DyAEIAQpAqABNwPwDyAEQQA2AtARIARCgICAgIABNwLIESADQQFrIRAgBEHcD2ohESAEQbQYaiEJIARB0A9qIQwgBEGoGGohDSAEQfgNaiEOIARB0BZqIQ8gBEH8AmohEyAEQcABaiEUIARByAhqQQRyIRkgBEHxC2ohFSAEQaQKaiEaIARBmQpqIRcgBEGEDGohHCAEQfgLaiEdIARBoApqIR5BqXwhAkEAIQhBACEGA0ACQAJAIAgiASADRwRAIAFBAWohCCAGQQFxQQAhBg0CIAQoAvQPIAJqIgdBoAdqLQAAIQogBEHICGoiCyAHQdcDahDhByAeIAdBrwVqEOEHIAdBnwdqLQAAIQYgHSAHQYsHaigCACAHQY8HaigCABBCIBwgB0GXB2ooAgAgB0GbB2ooAgAQQiAEIAY6AJAMIAQgCjoAkQwgCkEHRgRAIARB+BRqIgZB5wBB0+rCAEEEEOIHIARByBFqIgogBhDDBCAGQeYAQcXqwgBBDhDiByAKIAYQwwQgBkEDQQBBAUEAEOMHIAsQ2gQgCyAGQdAD/AoAACAELQCRDCEKCyAKQf8BcSACQal8RnIgBCgCyAgiC0ECRnINASAELQCZCkEeRw0BAkAgB0HQA2otAAAiBkEDRyABQQJJckUEQCAHLQAAIgZBBktBASAGdEHRAHFFcg0DDAELIAZBB0cNAgsgBEGAgICAeDYCoBMgBEIANwOoEyAEQbgBaiIGIARBoBNqQdbhwgBBARDkByAEQfgUaiISIAYQ5QcgBCAELQDBGDoA6Q8gBEGgDGoiBiASQdgB/AoAACAOIA9B2AH8CgAA", + "IAwgDSkDADcDACAMIA0oAgg2AgggESAJKQIANwIAIBEgCSgCCDYCCCAEQQA6AOgPIARByBFqIAYQwwQMAQsgGCAEKALQETYCDCAYIAQpAsgRNwIEIARB8A9qEOYHIBhBADYCACAEKAKYASELDAULQQAhEgJ/AkAgASAQRiIfDQAgBCgCoAoiBkECRg0AIAMgCEsEQCAHQfAKai0AAA0BIAdBpwdqKAIAQQJGDQFBACAHQfgIai0AAEEIRw0CGiAEQQI2AqAKIAdB9whqLQAAIQsgBEHICGoQ5wcgBCAGNgLICCAZIBpBzAH8CgAAIBcgFSgAADYAACAXIBUoAAM2AAMgBCALOgCYCiAGIQtBAQwCCyAIIANBlJ3DABAqAAtBAAshBiAKQf8BcSIKIAtBAkZyRQRAIAQtAJkKQR5GIRILIAQtAJAMIQsgBEHIEWogBEHICGoQwwQCQAJAAkACQCASRQRAIAEgEEcNAQwFCyAfDQQgAyAITQ0BIAdB8ApqLQAAQQRHDQAgBEG4AWoiAUEgEM0EIARB+BRqIhIgARDlByAEIAQtAMEYOgDpDyAEQaAMaiIBIBJB2AH8CgAAIA4gD0HYAfwKAAAgDCANKQMANwMAIAwgDSgCCDYCCCARIAkpAgA3AgAgESAJKAIINgIIIARBADoA6A8gBEHIEWogARDDBAsCQAJAAkACQCAKQQNrDgMAAwEDCyADIAhLBEAgB0HwCmotAABBBEYNAgwDCyAIIANBtJ3DABAqAAsgAyAITQ0DIAdB8ApqLQAAQQZHDQELIARB+BRqIgFB7QBB7urCAEEFEOIHIARByBFqIAEQwwQLIAtBAXFFDQMCQCADIAhLBEAgB0HwCmotAAAiAQ0BIAdBpwdqKAIAQQJGDQEgB0H4CGotAABB5QBHDQUMBAsgCCADQdSdwwAQKgALAkAgAUEDaw4FAAQEBAMECyAEQbgBaiIBQeYAEM0EIARB+BRqIgcgARDlByAEIAQtAMEYOgDpDyAEQaAMaiIB", + "IAdB2AH8CgAAIA4gD0HYAfwKAAAgDCANKQMANwMAIAwgDSgCCDYCCCARIAkpAgA3AgAgESAJKAIINgIIIARBADoA6A8gBEHIEWogARDDBAwDCyAIIANBpJ3DABAqAAsgCCADQcSdwwAQKgALIARBuAFqIgdBHxDNBCAEQfgUaiIBQbTkwgBBBBAGIAQoAsABIAQoAsQBEM8EIBQgBCkDgBU3AwggFCAEKQP4FDcDACABQeSdwwBBARAGIAQoAvwCIAQoAoADEAEgEyAEKAKAFTYCCCATIAQpAvgUNwIAIAEgBxDlByAEIAQtAMEYOgDpDyAEQaAMaiIHIAFB2AH8CgAAIA4gD0HYAfwKAAAgDCANKQMANwMAIAwgDSgCCDYCCCARIAkpAgA3AgAgESAJKAIINgIIIARBADoA6A8gBEHIEWogBxDDBAsgAkHQA2ohAgwACwALIAQoApgBIQsgCCEHIBEhAgJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIARBKGpBAQJ/AkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkADQCACIQEgB0UNASABQQRrKAIAIQIgASgCACEDIARBgAFqIAsgFyAGQYCrwwAQzQIgBEH4AGogAiADIAQoAoABIAQoAoQBQQBBAUHY1MMAEOgHIAdBKGshByABQShqIQIgBCgCeEEBRw0AIAQoAnwiA0UNAAsgBEHwAGogCyAXIAYgAyAGaiIHQZCrwwAQJCAEQawBaiAEKAJwIgIgAiAEKAJ0QQJ0ahAlIAQoArABIQkgAUEgayICLQAAIgZFDSggBCAEKAK0ASIBNgKcDCAEIAk2ApgMIAZBAmsOGgIDBAUGBwgXCQoLDA0YDg8QGRobHBEdEhMUAQsgBEEYaiALIBcgBkHQqsMAELkBAkAgBCgCHCICRQRAQQAhBwwBCyAEKAIYIQFBACEHA0AgByABKAIAQQpGaiEHIAFBBGoh", + "ASACQQFrIgINAAsLIAQgB0EBajYCoBMgBEEQaiALIBcgBkHgqsMAELkBIAQoAhQiAkECdCEBIAQoAhBBBGshCANAAkAgAiEHIAFFBEBBACEHDAELIAdBAWshAiABIAhqIAFBBGshASgCAEEKRw0BCwsgBCAGIAdrQQFqNgK4ASAEQQhqIAsgFyAGQfCqwwAQzQIgBEGgDGoiASAEKAIIIgIgAiAEKAIMQQJ0ahAlIARBHjYCjBUgBEEENgKEFSAEQQQ2AvwUIAQgATYCiBUgBCAEQbgBajYCgBUgBCAEQaATajYC+BQgGEEEakHQgsAAIARB+BRqEAwgBCgCoAwgBCgCpAwQASAYQQE2AgAMKAsgBEGgDGogAi0AASACLQACIAkgARDjBwwjCyAOIAIoAgQgAigCCBAGIARB+BRqIgYgAi0AASACLQACIAkgARDjByAEIAQtAMEYOgDpDyAEQaAMaiAGQdgB/AoAACAVIBNB2AH8CgAAIA0gDCkDADcDACANIAwoAgg2AgggBCAELQDAGDoA6A8gBCgCtBggBCgCuBgQAQwiCyAEQfgUaiIGIAItAAEQzQQgBEGgE2ogCSABEAYgBCgCvBYgBCgCwBYQASAQIAQoAqgTNgIIIBAgBCkCoBM3AgAgBEGgDGogBhDlBwwhCyACLQABIQMgBEGgE2oiBiACQQhqEMIHIARB+BRqIgIgAyAGEMAHIAYgCSABEAYgBCgCvBYgBCgCwBYQASAQIAQoAqgTNgIIIBAgBCkCoBM3AgAgBEGgDGogAhDlBwwgCyACLQABIQMgBEH4FGoiBiACQQhqIgoQwgcgBEHwD2oiEiADIAYQwAcgBiAJIAEQBiAEKAK0ESAEKAK4ERABIBogBCgCgBU2AgggGiAEKQL4FDcCACACLQACIQIgBiAKEMIHIARBoBNqIgMgAiAGEMAHIAYgCSABEAYgBCgC5BQgBCgC6BQQASAUIAQoAoAVNgIIIBQgBCkC+BQ3AgAgFSADQdgB/AoAACAG", + "IBIQ5QcgBCAELQDBGDoA6Q8gBEGgDGogBkHYAfwKAAAgDSAMKQMANwMAIA0gDCgCCDYCCCAOIA8pAgA3AgAgDiAPKAIINgIIIAQgBC0AwBg6AOgPIBMQ5wcMHwtBACEGIAkgAUE/EKYCDQ4gCQwPCyACLQABIQIgBEEBOgCqEyAEQQA2AaYTIAQgAjoApRMgBEEBOgCkEyAEQYSAgIB4NgKgEyAEQfgUaiICQe8AIARBoBNqIgYQwAcgBiAJIAEQBiAEKAK8FiAEKALAFhABIBAgBCgCqBM2AgggECAEKQKgEzcCACAEQaAMaiACEOUHDB0LIARB+BRqIgEgAigCBCACKAIIEAYgBEGgE2oiAkEjIAEQwAcgASACEOUHIAQgBC0AwRg6AOkPIARBoAxqIAFB2AH8CgAAIBUgE0HYAfwKAAAgDSAMKQMANwMAIA0gDCgCCDYCCCAOIA8pAgA3AgAgDiAPKAIINgIIIARBADoA6A8MHAsgBEEBOgD+FCAEQYECOwH8FCAEQYaAgIB4NgL4FCAEQaATaiIDQQ8gBEH4FGoiBhDAByAGIAkgARAGIAQoAuQUIAQoAugUEAEgFCAEKAKAFTYCCCAUIAQpAvgUNwIAIAQgAi0AAToA8BQgBiADEOUHIAQgBC0AwRg6AOkPIARBoAxqIAZB2AH8CgAAIBUgE0HYAfwKAAAgDSAMKQMANwMAIA0gDCgCCDYCCCAOIA8pAgA3AgAgDiAPKAIINgIIIARBADoA6A8MGwsgBCAJIAFB4wAQvQI6AP4UIARBATsB/BQgBEGCgICAeDYC+BQgBEGgE2oiA0EIIARB+BRqIgYQwAcgBiAJIAEQBiAEKALkFCAEKALoFBABIBQgBCgCgBU2AgggFCAEKQL4FDcCACAEIAItAAE6APAUIAYgAxDlByAEIAQtAMEYOgDpDyAEQaAMaiAGQdgB/AoAACAVIBNB2AH8CgAAIA0gDCkDADcDACANIAwoAgg2AgggDiAPKQIANwIAIA4gDygC", + "CDYCCCAEQQA6AOgPDBoLIARBgoCAgHg2AqATIAQgAi0AAToApBMgBEH4FGoiAiAEQaATaiAJIAEQ5AcgBEGgDGogAhDlBwwZCyAEQYOAgIB4NgKgEyAEQfgUaiICIARBoBNqIAkgARDkByAEQaAMaiACEOUHDBgLIARBOGogCSABEOkHIAQoAjwiAUUEQEEBIQFBACEGQQAhCgwXCyAEQaATaiAEKAI4IgIgASACahAgQQAhASAEQQA2AoAVIARCgICAgBA3AvgUIAQoAqQTIRIgBCgCqBMhCgNAIAEgCk8EQCAEKAKAFSEKIAQoAvwUIQEgBCgC+BQhBiAEKAKgEyASECYMGAsCQAJAAkACQAJAAkACQAJAAkACQCASIAogAUHsm8MAECEoAgBB3ABHIAFBAWoiAiAKT3INAAJAIBIgCiACQfybwwAQISgCACIDQe4Aaw4JCQEBAQQBAwEGAAsCQCADQeEAaw4GCAcBAQEFAAsgA0EiRgRAIAMhBgwKC0HcACEGIANB3ABGDQELIARB+BRqIBIgCiABQZycwwAQISgCABDXAiACIQEMCQsgAUECaiICIApPDQcgEiAKIAJBjJzDABAhKAIAQShHDQcgBEH4FGoiAUHcABDXAiABQdwAENcCIAIhAQwIC0EJIQYMBgtBDSEGDAULQQwhBgwEC0ELIQYMAwtBCCEGDAILQQchBgwBC0EKIQYLIARB+BRqIAYQ1wIgAUECaiEBDAALAAsgCSABQeycwwAQ6gchAiAJIAFB7pzDABDqByEGIAQgCSABQfCcwwAQ6gc6AKcTIAQgAjoAphMgBCAGOgClEyAEQQA6AKQTIARBjICAgHg2AqATIARB+BRqIgJB7gAgBEGgE2oQwAcgBEHwD2ogCSABEAYgBCgCvBYgBCgCwBYQASAQIAQoAvgPNgIIIBAgBCkC8A83AgAgBEGgDGogAhDlBwwWCyAJIAFBKxC9AiEGIAkgAUE/EL0CIQMgCSABQe4AEL0CIQogCSABQeQA", + "EL0CIRIgCSABQeMAEL0CIR8gAi0AASECIAQgHzoArhMgBCAKOgCtEyAEQYCABDYAqRMgBCADOgCoEyAEQQE7AaYTIAQgEjoApRMgBCAGOgCkEyAEQYOAgIB4NgKgEyAEQfgUaiIGIAIgBEGgE2oiAhDAByAEQdAAakESEMUEIAIgBCgCUCAEKAJUEAYgBCgCgBUgBCgChBUQzwQgGSAEKQOoEzcDCCAZIAQpA6ATNwMAIAIgCSABEAYgBCgCvBYgBCgCwBYQASAQIAQoAqgTNgIIIBAgBCkCoBM3AgAgBEGgDGogBhDlBwwVCyAEQdgAakEBIAkgAUH0nMMAEL8CIARB+BRqIgEgBCgCWCICIAQoAlwiBhAGIARByBFqIgMgASACIAYQ5AcgBEE+OgCZEyABIAMQ5QcgBCAELQDBGDoA6Q8gBEGgDGogAUHYAfwKAAAgFSATQdgB/AoAACANIAwpAwA3AwAgDSAMKAIINgIIIA4gDykCADcCACAOIA8oAgg2AgggBEEBOgDoDwwUCyAEQY2AgIB4NgL4FCAEQgE3A4AVIARBoBNqIgJBxAAgBEH4FGoiARDAByABIAIQ5QcgBCAELQDBGDoA6Q8gBEGgDGogAUHYAfwKAAAgFSATQdgB/AoAACANIAwpAwA3AwAgDSAMKAIINgIIIA4gDykCADcCACAOIA8oAgg2AgggBEEBOgDoDwwTCyAEQYqAgIB4NgKgEyAEIAItAAE6AKgTIAQgAigCBDYCpBMgBEH4FGoiAkEyIARBoBNqIgYQwAcgBiAJIAEQBiAEKAK8FiAEKALAFhABIBAgBCgCqBM2AgggECAEKQKgEzcCACAEQaAMaiACEOUHDBILIARBi4CAgHg2AqATIAQgAi0AAToApBMgBEH4FGoiAkEzIARBoBNqIgYQwAcgBiAJIAEQBiAEKAK8FiAEKALAFhABIBAgBCgCqBM2AgggECAEKQKgEzcCACAEQaAMaiACEOUHDBELIARBj4CAgHg2AqATIAQg", + "Ai0AAToApBMgBEH4FGoiAkHgACAEQaATaiIGEMAHIAYgCSABEAYgBCgCvBYgBCgCwBYQASAQIAQoAqgTNgIIIBAgBCkCoBM3AgAgBEGgDGogAhDlBwwQCyAEQTBqIAFBAWsgCSABQaycwwAQ5AJBASEGIAQoAjQhASAEKAIwCyABQbycwwAQvwIgBCgCLCEBIAQoAighCiACLQABRQ0MIARBIGogCiABEOkHIAQoAiQhASAEKAIgIQoMDAsgBEH4FGoiAiAJIAEQ6wcgBCgC+BQNBiAEKQOAFSEhIARBiICAgHg2AqATIAQgITcDqBMgAkH1ACAEQaATaiIGEMAHIAYgCSABEAYgBCgCvBYgBCgCwBYQASAQIAQoAqgTNgIIIBAgBCkCoBM3AgAgBEGgDGogAhDlBwwNCyABQQFrIQYCfyACLQABIgNFBEAgBEHIAGogCSABQQQgBkHMnMMAENYBIAQoAkghCiAEKAJMDAELIARBQGsgCSABQQcgBkHcnMMAENYBIAQoAkAhCiAEKAJECyECIARB+BRqIgEgCiACEAYgBEGgE2oiBiABIAogAhDkByAEQeoAOgDxFCAEKAK4EyAEKAK8ExDPBCAEQQA6AL8TIARBADsAvRMgBCADOgC8EyAEQYyAgIB4NgK4EyABIAYQ5QcgBCAELQDBGDoA6Q8gBEGgDGogAUHYAfwKAAAgFSATQdgB/AoAACANIAwpAwA3AwAgDSAMKAIINgIIIA4gDykCADcCACAOIA8oAgg2AgggBEEBOgDoDwwMCyAEQegAakECIAkgAUGEncMAEL8CIARB+BRqIgIgBCgCaCAEKAJsQRAQwAIgBC0A+BQNByAEKQOAFSEhIARBgICAgHg2AqATIAQgITcDqBMgAiAEQaATaiAJIAEQ5AcgBEGgDGogAhDlBwwLCyAEQfgUaiICIAkgARB6IAQtAPgUDQUgBCsDgBUhIiAEQYGAgIB4NgKgEyAEICI5A6gTIAIgBEGgE2ogCSABEOQHIARB", + "oAxqIAIQ5QcMCgsgBEH4FGoiAiAJIAEQwgIgBC0A+BQNAyAEKQOAFSEhIARBgICAgHg2AqATIAQgITcDqBMgAiAEQaATaiAJIAEQ5AcgBEGgDGogAhDlBwwJCyAEQfgUaiICIAkgARDrByAEKAL4FA0BIAQpA4AVISEgBEGNgICAeDYC+BQgBCAhNwOAFSAEQaATaiIGQcQAIAIQwAcgAiAJIAEQBiAEKALkFCAEKALoFBABIBQgBCgCgBU2AgggFCAEKQL4FDcCACACIAYQ5QcgBCAELQDBGDoA6Q8gBEGgDGogAkHYAfwKAAAgFSATQdgB/AoAACANIAwpAwA3AwAgDSAMKAIINgIIIA4gDykCADcCACAOIA8oAgg2AgggBEEBOgDoDwwICyAEQfgUaiIGIAkgARDrByAEKAL4FA0AIAQgBCkDgBUiIUIAICFCAFUbPgL8FCAEQYqAgIB4NgL4FCAEIAItAAE6AIAVIARBoBNqIgJBMiAGEMAHIAYgCSABEAYgBCgC5BQgBCgC6BQQASAUIAQoAoAVNgIIIBQgBCkC+BQ3AgAgBiACEOUHIAQgBC0AwRg6AOkPIARBoAxqIAZB2AH8CgAAIBUgE0HYAfwKAAAgDSAMKQMANwMAIA0gDCgCCDYCCCAOIA8pAgA3AgAgDiAPKAIINgIIIARBADoA6A8MBwsgBCkDgBUhISAEKAL8FCEKDAcLIARBAjYC9A8gBCAEQZgMajYC8A8gBEGgE2pBBHJB+MPAACAEQfAPahAMDAILIARBAjYC9A8gBCAEQZgMajYC8A8gBEGgE2pBBHJB9pbAACAEQfAPahAMDAELIARB4ABqQQIgCSABQYzfwgAQvwIgBCAEKQNgNwLIGCAEQQI2AvQPIAQgBEHIGGo2AvAPIARBoBNqQQRyQfjDwAAgBEHwD2oQDAsgBCgCpBMhCiAEKQOoEyEhDAMLIB4gCiABEAYgFCAKIAEQBiAEQQI2AsgTIARBgMoBOwHwFCAEQQA6AMETIAQg", + "BjoAwBMgBEKBgICACDcDuBMgBEEANgKgEyAEQfgUaiIBIARBoBNqEOUHIAQgBC0AwRg6AOkPIARBoAxqIAFB2AH8CgAAIBUgE0HYAfwKAAAgDSAMKQMANwMAIA0gDCgCCDYCCCAOIA8pAgA3AgAgDiAPKAIINgIIIARBAToA6A8MAQsgGSABIAoQQiAEIAo2AsQWIAQgATYCwBYgBCAGNgK8FiAEQQI2AqAVIARBgL4BOwHIFiAEQYCAgIB4NgKQFSAEQQA2AvgUIARBoAxqIARB+BRqEOUHCyAEKQOoDCEhIAQoAqQMIQogBCgCoAwhASAEQbgBaiAcQcAD/AoAACABQX9HDQELIBggITcCCCAYIAo2AgQgGEEBNgIAIAQoAqwBIAkQAQwCCyAdIARBuAFqQcAD/AoAACAEICE3A4AFIAQgCjYC/AQgBCABNgL4BCAEQaABaiAEQfgEahDDBAsgBCgCrAEgCRABIAchBgwBCwsgBEGgAWoQ5gcLIAQoApQBIAsQJiAWIQEDQCAbBEAgAUEYahCQBCABLQAAQR5xQQRGBEAgAUEIaigCACABQQxqKAIAEM8ECyAbQQFrIRsgAUEoaiEBDAELCyAWQQhBKBAwIARB0BhqJAAgBSAFKQLcCDcDgAUgBSAFKALkCDYCiAUCQCAFKALYCEEBRgRAIAAgBSgCiAU2AgwgACAFKQOABTcCBCAAQX82AgAMAQsgBSAFKAKIBTYCaCAFIAUpA4AFNwNgIAVCgICAgIABNwJIIAVBADYCUEEIQdgDEOUCIgFBATYC0AMgAUGAAjsByAMgAUIBNwPAAyABQgA3A7gDIAFCgICAgBA3A7ADIAFBAjYC2AEgAUECNgIAIAVBATYCXCAFIAE2AlggBUEBNgJUIAVBAjYC2AYgBUECNgKABSAFQYEEOwHICCAFQgE3A8AIIAVCADcDuAggBUKAgICAEDcDsAggBUHgAGogBUGABWoiARDDBCABEIIBIAVBwNvCACkDADcDcCAFQcjb", + "wgApAwA3A3ggBSAFKQOIBTcDiAEgBSAFKQOABTcDgAEgBSgCYCEBIAUgBSgCZCIGIAUoAmhB0ANsaiIWNgKcASAFIAE2ApgBIAUgBjYClAEgBSAGNgKQASAFQaABakEEciERQQEhBwNAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUgFiAGIgFHBH8gAUHQA2ohBiABKAIAIgtBf0cNASAGBSAWCzYClAEgBUGQAWoQxAQgBSgCXCIBRQ0OIAUoAlggAUHYA2xqIgFB2ANrIgJFDQ4gAUEPay0AAEEBaw4HAgMEBQYHCAELIAUgCzYCoAEgESABQQRqQcwD/AoAACAFLQDpBCIIQQZNBEBBASAIdCIBQSpxDQsgAUHQAHENDSAIQQJGDQwLIAUoAlwhAiAFKAJYIQEgC0ECRiIEIAhyDRkgBS0A8QJBA2tB/wFxQQFNDQkMGQsCQCACKAIAQQJGDQAgBUEQaiABQYcCay0AABDFBCAFQYAFaiAFKAIQIAUoAhQQBiAFKAKABUF/Rg0AIAUgBSgCiAU2AqgBIAUgBSkCgAU3A6ABDAgLIAVBADYCqAEgBUKAgICAEDcDoAEMBwsgBUGgAWpBg+LCAEEBEAYMBgsgBUGgAWpBhOLCAEEBEAYMBQsgBUGgAWpBheLCAEEBEAYMBAsgBUGgAWpBhuLCAEEBEAYMAwsgBUGgAWpBh+LCAEEBEAYMAgsgBUGgAWpBiOLCAEEBEAYMAQsgBUGgAWpBieLCAEECEAYLIAVBAzYChAUgBSAFQaABajYCgAUgBUEsakHih8AAIAVBgAVqEAwgBSgCoAEgBSgCpAEQAQwPCyAFQYAFaiAFKALoAiAFKALsAhBCAkAgBSgCgAVBf0cEQCAFIAUoAogFNgK4DCAFIAUpAoAFNwOwDAwBCyAFQQA2ArgMIAVCgICAgBA3A7AMCyACQdgDbCEIA0AgCEUNDCABIAhqIQsgCEHY", + "A2shCAJAIAtBD2stAAAOAgEADQsLIAEgCGoiCEG0A2ooAgAgCEG4A2ooAgBB2OLCAEECEBJFDQsgBUGABWogBUHwAGogCEHQA2oiCSgCABDGBBDHBEEAIAUoAoAFIgggCEF/RiILGyEDQQEgBSgChAUgCxshCEEAIAUoAogFIAsbIQsgBSgCtAwiCiAFKAK4DCIMQdriwgBBBBASRQ0JIAggC0HY4sIAQQIQsQJFDQkgCCALQd7iwgBBBBCxAkUNCSAFQfQEakHi4sIAQTEQBgwKCyAFQdgIaiAFQaABakHQA/wKAAAgBSAHQQFqIgc2AqgMIAUoAowMIAUoApAMQdjiwgBBAhASBEAgBUGABWoiAUHY4sIAQQIQBiAFQcAMaiAFQfAAaiAHIAEQyAQgBSgCwAwgBSgCxAwQBQsgBUHUAGogBUHYCGoQyQQMDwsDQAJAAkAgBSgCXCICRQ0AIAUoAlgiCyACQdgDbGoiAUHYA2siCEUNACABQQ9rLQAAQQFHDQEgAUEkaygCACABQSBrKAIAQdjiwgBBAhASIQMgBSgC1AQgBSgC2ARBk+PCAEEDEBIhCAJAIANFBEAgCEUNCiAFQbAMakGW48IAQS8QBgwBCyAIRQRAIAVBsAxqQcXjwgBBLRAGDAELIAVBgAVqIAVB8ABqIAFBCGsoAgAQxgQQxwQCQAJ/IAUoAoAFQX9HBEAgBSAFKQKABTcDwAwgBSAFKAKIBSIINgLIDCAFKALEDAwBC0EAIQggBUEANgLIDCAFQoCAgIAQNwPADEEBCyIBIAhB2uLCAEEEELECBEAgASAIQfLjwgBBBBCxAg0BCyAFKALADCABEAEMCgsgBUEDNgKEBSAFIAVBwAxqNgKABSAFQbAMakGeycAAIAVBgAVqEAwgBSgCwAwgBSgCxAwQAQsgBSgCsAwiAUF/Rg0IIAUgBjYClAEgBSAFKQK0DDcCMCAFIAE2AiwMDgsgBSAGNgKUASAFQSxqQc6rwwBBwwAQBgwNCyAFQYAF", + "aiAIEMoEIAUoAoAFIgFBf0YEQCAFQdQAaiAFQcgAahDLBAwBCwsgBSAGNgKUASAFIAUpAoQFNwIwIAUgATYCLAwLC0HkAEEkIAhBBkYiCBshBEEFQQMgCBshAgJAAkADQAJAIAUoAlghCyAFKAJcIgFFDQAgCyABQdgDbGoiA0HYA2siCUUNACADQQ9rLQAAIAJGDQIgBUGABWogCRDKBCAFKAKABSIBQX9HDQMgBUHUAGogBUHIAGoQywQMAQsLIAFFDQMLIAUgAUEBayIDNgJcIAVBgAVqIgIgCyADQdgDbGoiAUHYA/wKAAAgAhDMBCAFKALUBCAFKALYBEE/EKYCIQsgAiAEEM0EIAVByABqIgQgAhDOBCAIBEAgAkEfEM0EIAQgAhDOBAsgA0UNBiABQdgDayICRQ0GIAFBD2stAAANBiACKAIAQQJGDQYgAUGHAmstAABB5gBHDQYgAUHAA2siAigCACABQbwDaygCABDPBCABQbcDa0EAOgAAIAFBuANrIAs6AAAgAkKBgICACDcDACAFQdQAaiAFQcgAahDLBAwGCyAFIAY2ApQBIAUgBSkChAU3AjAgBSABNgIsDAoLIAUgBSgCUDYCNCAFIAUpAkg3AiwgBUHwAGoQ0AQgBUHUAGoQ0QQgBSAFKAI0IgY2AiAgBSAGNgJAIAUgBSkCLDcDOCAGRQ0BQQAhASAFQQA2ApgBIAVCgICAgIABNwKQASAFKAI4IQggBSAFKAI8IgIgBkHYAWwiB2oiETYCfCAFIAg2AnggBSACNgJwIAJB2AFqIQYgBUH8AmohFiAFQfgCaiEEIAVB8gJqIQMgBUGgAWpBBHIhCUEIIQgDQAJAIAUgBwR/IAIoAgAiCkECRw0BIAYFIBELNgJ0IAVB8ABqENIEIAFBAUYEQCAFQQA2ApgBIAgoAgAhASAAQQRqIAhBBGpB3AH8CgAAIAAgATYCACAFQZABahDTBAwQCyAAQQRqQaCrwwBBLhAGIABBfzYCAAwECyACLQDR", + "ASELIAkgAkEEakHNAfwKAAAgAyACLwHWATsBBCADIAIoAdIBNgEAIAVB2AhqIAsQ1AQgBUIANwP4AiAFIAs6APECIAUgCjYCoAECQAJAAkACQCAFLQDkCEEBaw4CAQADCyABQQJPBEAgBUGABWoiCyABQeABbCAIaiIKQeABa0HgAfwKAAAgBSABQQJrIgE2ApgBIAVB2AhqIgwgCkHAA2tB4AH8CgAAIAwQ1QQhCiAEENYEIAUgCjYC+AIgCxDVBCELIBYQ1gQgBSALNgL8AgwDCyAFIAY2AnQgBUEIaiAFKALoAiAFKALsAhAUIAUgBSkDCDcCgAUgBSABNgIoIAVBBDYC5AggBUECNgLcCCAFIAVBKGo2AuAIIAUgBUGABWo2AtgIIABBBGpBioXAACAFQdgIahAMDAELIAEEQCAFIAFBAWsiATYCmAEgBUHYCGoiCyAIIAFB4AFsakHgAfwKAAAgCxDVBCELIBYQ1gQgBSALNgL8AgwCC0EAIQEgC0HRAEYNASAFIAY2AnQgBSAFKALoAiAFKALsAhAUIAUgBSkDADcCgAUgBUECNgLcCCAFIAVBgAVqNgLYCCAAQQRqQb3CwAAgBUHYCGoQDAsgAEF/NgIAIAVBoAFqENcEIAVB8ABqENIEDAQLIAJB2AFqIQIgBSgCkAEgAUYEQCAFQZABahDYBCAFKAKUASEICyAIIAFB4AFsaiAFQaABakHgAfwKAAAgBSABQQFqIgE2ApgBIAdB2AFrIQcgBkHYAWohBgwACwALIAUgBjYClAEgBUEsakGRrMMAQdAAEAYMCAsgAEECNgIAIAVBOGoQ2QQMCwsgBUGQAWoQ0wQMCgsgBSACQQFrIgE2AlwgBUGABWoiAiALIAFB2ANsakHYA/wKAAAgAhDMBAsgBUGgAWoQ2gQMBwsCQCAKIAxB2uLCAEEEELECBEAgCCALQdriwgBBBBCxAg0BCyAJKAIAIQsgBSAFKAK4DDYCiAUgBSAFKQOwDDcDgAUgBUHADGog", + "BUHwAGogCyAFQYAFahDIBCAFKALADCAFKALEDBAFIAMgCBABDAYLIAVBAzYChAUgBSAFQbAMajYCgAUgBUH0BGpBz8nAACAFQYAFahAMCyADIAgQAQwBCyAFQQM2AoQFIAUgBUGwDGo2AoAFIAVB9ARqQfjJwAAgBUGABWoQDAsgBSgCsAwgBSgCtAwQASAFKAL0BCIIQX9GDQIgBSAGNgKUASAFIAUpAvgENwIwIAUgCDYCLAsgBUGgAWoQ2gQgBUGQAWoQxAQLIAVB8ABqENAEIAVB1ABqENEEIAVByABqENkEIAUgBSgCNCIBNgIgIAUgBSkCLCIhNwMYIAAgATYCDCAAICE3AgQgAEF/NgIADAILQQAhCCAERQRAIAVBgAVqIAUtAPECENQEIAUoAogFIQgLA0ACQAJAIAJFDQAgASACQdgDbGoiAUHYA2siAkUNACABQQ9rLQAADQAgAigCAEECRg0AIAVBgAVqIAFBhwJrLQAAENQEIAUoAogFIAhLDQELIAVBgAVqIgEgBUGgAWpB0AP8CgAAIAUgB0EBaiIHNgLQCCAFQdQAaiABEMkEDAILIAVB1ABqIAVByABqEMsEIAUoAlwhAiAFKAJYIQEMAAsACwALIAVB0AxqJAALygEBB38jAEEgayIDJAAgAyACQQRBGBAHIAMoAgAiByACQf////8BcSIEIAQgB0sbIQYgA0EUaiEJQQAhBCADKAIEIQgDQCAGBEAgA0EIaiABIARqIgVBBGooAgAgBUEIaigCABBCIAkgBUEQaigCACAFQRRqKAIAEEIgBCAIaiIFIAMpAhg3AhAgBSADKQIQNwIIIAUgAykCCDcCACAGQQFrIQYgBEEYaiEEDAELCyAAIAI2AgggACAINgIEIAAgBzYCACADQSBqJAALIwAgASgCAEF/RwRAIAAgASgCBCABKAIIEEIPCyAAQX82AgALWgEBfyMAQSBrIgIkACABENsEIQEgAkEIahDcBCAAIAE2AgwgACACKAIYNgIQ", + "IAAgAi0AHDoAFCAAIAIpAgg3AgAgACACKAIQNgIIIAIoAhQQgwQgAkEgaiQACzEAIAMEQCAAIAEgAiADEN0EDwsgACACKQIQNwIQIAAgAikCCDcCCCAAIAIpAgA3AgALnAcCCH8BfiMAQdAAayIEJAAgBEEAOgAOIAQgAS0AEiIHOgANIAQgAS0AEToADCAEIAEoAgw2AgggAigCCCEFIAIoAgQhBiABLQAcBEAgASAGIAUgAxDeBDYCFCAGIAUgAxDfBCEIIAFBADoAHCABIAg2AhgLIAYgBSADEN4EIQggBiAFIAMQ3wQhCiAEQRBqIAYgBSADEKwCIgVB8ABqKAIAIAVB9ABqKAIAEEIgBCgCFCILIAQoAhgiCUH248IAQRAQ/QEhBgJAAkAgAS0AECIFRQRAAkACQCAIIAEoAhRGBEAgBiABKAIYIApGckUNAQwCCyAGDQELIAFBgNPDAEEBIAdBAXEiBRtBBEEAIAUbEAogAS0AEiEHC0EBIQUgBEEcaiALIAkgB0EBcRDgBCABIAQoAiAiByAEKAIkEAogBCgCHCAHEAEgAS0AECIHQQFHDQELIARBHGogAiADQQAQ4QQgBCgCHCIHQX9HBEAgACAEKQIgNwIEIAAgBzYCAAwCCyAFIQcLIAIoAgQgAigCCCADEKwCIQYgAQJ/QQEgAS0AHQ0AGkEAIAZBHGooAgAiCSAGQSBqKAIAIgVBpeDCAEEGELECRQ0AGkEBIAkgBUGG5MIAQQYQsQINABogBkEoaigCACAGQSxqKAIAQYzkwgBBBRCxAgs6AB0CfwJAAkACQCAHQQFxBEAgAS0AESABKAIMIQdBAXEgAigCBCACKAIIIAMQrAIiBi0AmgFBAkZxDQIgBEEsakGMmsMAQQEgBxDZAiAEQQA2AkAgBEKAgICAEDcCOCAEQcQAaiACIAMgBCgCMCICIAQoAjRBACAEQThqIgUQ4gQgBCgCRCIDQX9HDQEgBUEKENcCIAQgBCgCQDYCKCAEIAQpAjg3", + "AiAgBCgCLCACEAEMAwsgBEEcaiACIAMgBEEIahDjBCAEKAIkIQMgBCgCICEFIAQoAigiAiAEKAIcQQFHDQMaIAAgAjYCCCAAIAM2AgQgACAFNgIADAQLIAQpAkghDCAEKAI4IAQoAjwQASAEKAIsIAIQASAAIAxCIIg+AgggACAMPgIEIAAgAzYCAAwDCyAEQQM2AkggBCAGQSRqNgJEIARBIGpB7NTAACAEQcQAahAMCyAEKAIkIQMgBCgCICEFIAQoAigLIQIgASADIAIQCiABIAo2AhggASAINgIUIABBfzYCACAFIAMQAQsgBCgCECALEAEgBEHQAGokAAuwAgIFfwF+IAAoAgwQgwQgACgCECIDIAMoAgBBAWsiATYCACABRQRAIwBBIGsiASQAIAMoAhQiBQRAIAMoAhAhAiADKAIcIgQEQCACKQMAIQYgASAENgIYIAEgAjYCEEEBIQQgASACIAVqQQFqNgIMIAEgAkEIajYCCCABIAZCf4VCgIGChIiQoMCAf4M3AwADQCAEBEAgARCCBCECIAEgASgCGEEBayIENgIYIAJBEGsoAgAgAkEMaygCABABIAJBBGsoAgAQgwQMAQsLIAMoAhAhAgsgAUEQQQggBUEBahCHASABKAIAGiACIAEoAghrIAEoAgQQiAELAkAgA0F/Rg0AIAMgAygCBEEBayICNgIEIAINACADQTAQGQsgAUEgaiQACyAAKAIAIAAoAgQQBQshACAAEL4EIABBDGoQBCAAKAIkIAAoAigQBSAAQRhqEAQLEgAgACgCAEECRwRAIAAQ1wQLC0ABA38gACgCCCEBIAAoAgQiAyECA0AgAQRAIAFBAWshASACEMIEIAJBnAFqIQIMAQsLIAAoAgAgA0EEQZwBEDALWwEEfyAAKAIIIgEgACgCBCICIAEgAksbIQIgACgCACEDA0ACQCABIAJGDQAgASADai0AAEEJayIEQRdLQQEgBHRBk4CABHFFcg0AIAAgAUEBaiIBNgIIDAEL", + "CwvPIgMXfwF+AXwjAEHgAmsiBSQAIAEQvwQCQAJAAkACQAJ/AkACQAJAAkACQAJAAkACQAJAIAEoAggiByABKAIEIglJBEAgASgCACIMIAdqIg0tAAAiBkEiRg0LIAZBLUYNAyAGQdsARg0CIAZB5gBGDQkgBkHuAEYNCCAGQfQARw0BQQQhB0Ht7MIADAoLIABB0ezCAEEcEAYMDAsgBkH7AEcEQCAGQTBrQf8BcUEKTw0GIAchBgwDCyAFQbwBaiIIQbXewgBBBRAGIAVBAToAvgIgBUIBNwLYASAFQgA3AtABIAVCgICAgBA3AsgBIAVCATcCiAIgBUIANwKAAiAFQoCAgIAQNwL4ASAFQgE3AvABIAVCADcC6AEgBUKAgICAwAA3AuABIAVBADYCpAEgBSADNgKsASAFIAQ2ArABIAVBADYCtAEgBUEANgKYAiAFQgA3AqgCIAVCgICAgBA3ApACIAVBADYCpAIgBUKAgICAEDcCnAIgBUIANwKwAiAFQgA3AbYCIAIgBUGkAWoQ3wIhA0EAQQEQASABIAdBAWo2AgggBUGAAWohCSAFQZwCaiELIAVB9ABqIQwgBUGQAmohDSAFQegAaiEOIAVBhAJqIREgBUHcAGohEiAFQfgBaiETIAVB0ABqIRQgBUHsAWohFSAFQcQAaiEWIAVB4AFqIRcgBUE4aiEYIAVB1AFqIRkgBUEsaiEaIAVByAFqIRsgBUEgaiEKAkADQCABEL8EIAEoAggiBCABKAIETw0GIAEoAgAgBGotAAAiBkEiRwRAIAZB/QBHBEAgACABQfvtwgBBKBD2BwwPCyAAIAM2AgQgAEF/NgIAIAEgBEEBajYCCAwOCyAFQaQBaiABEPcHIAUoArABIQcgBSgCrAEhBCAFKAKoASEGIAUoAqQBQQFGBEAgACAHNgIIIAAgBDYCBCAAIAY2AgAMDgsgBUGkAWoiD0Hj38IAQQUgBCAHEN4CIAogCCkCADcCACAKIAgoAgg2AgggGiAbKQIA", + "NwIAIBogGygCCDYCCCAYIBkpAgA3AgAgGCAZKAIINgIIIBYgFygCCDYCCCAWIBcpAgA3AgAgBSAFLQC+AjoAogEgBSAFKAKoAjYCjAEgBSAFKQKkATcCCCAUIBUoAgg2AgggFCAVKQIANwIAIBIgEykCADcCACASIBMoAgg2AgggDiARKQIANwIAIA4gESgCCDYCCCAMIA0pAgA3AgAgDCANKAIINgIIIAVBATYCECAFIAM2AhQgBSAFKQK0ATcCGCAJIAsoAgg2AgggCSALKQIANwIAIAVBAToAoQEgBSAFKQKsAjcCkAEgBSAFKQK0AjcCmAEgBSAFLQC8AjoAoAEgAiAFQQhqEN8CIRAgARC/BAJAIAEoAggiByABKAIETw0AIAEoAgAgB2otAABBOkcNACABIAdBAWo2AgggDyABIAJBASADEMAEIAUoAqgBIQcgBSgCpAEiD0F/RwRAIAAgBSgCrAE2AgggACAHNgIEIAAgDzYCAAwDCyACKAIEIAIoAgggBxDhAiIPIBA2AhQgD0EBNgIQIAIoAgQgAigCCCADEOECQTxqIg8gEBDgAiAPIAcQ4AIgARC/BAJAAkAgASgCCCIHIAEoAgRJBEAgASgCACAHai0AACIQQSxGDQEgEEH9AEYNAgsgACABQbXtwgBBJBD2BwwECyABIAdBAWo2AggLIAYgBBABDAELCyAAIAFB2e3CAEEiEPYHCyAGIAQQAQwLCyAFQbwBaiIIQbDewgBBBRAGQQAhBiAFQQA6AL4CIAVCATcC2AEgBUIANwLQASAFQoCAgIAQNwLIASAFQgE3AogCIAVCADcCgAIgBUKAgICAEDcC+AEgBUIBNwLwASAFQgA3AugBIAVCgICAgMAANwLgASAFQQA2AqQBIAUgAzYCrAEgBSAENgKwASAFQQA2ArQBIAVBADYCmAIgBUIANwKoAiAFQoCAgIAQNwKQAiAFQQA2AqQCIAVCgICAgBA3ApwCIAVCADcCsAIgBUIANwG2AiACIAVB", + "pAFqEN8CIQNBAEEBEAEgASAHQQFqNgIIIAVBgAFqIQcgBUGcAmohCSAFQfQAaiELIAVBkAJqIQwgBUHoAGohDSAFQYQCaiEOIAVB3ABqIREgBUH4AWohEiAFQdAAaiETIAVB7AFqIRQgBUHEAGohFSAFQeABaiEWIAVBOGohFyAFQdQBaiEYIAVBLGohGSAFQcgBaiEaIAVBIGohGwNAIAEQvwQgASgCCCIEIAEoAgRJBEAgASgCACAEai0AAEHdAEYNBAsgBUGkAWogASACQQEgAxDABCAFKAKoASEEIAUoAqQBIgpBf0cEQCAAIAUoAqwBNgIIIAAgBDYCBCAAIAo2AgAMDAsgBUHIAmogBhCMAyAFQaQBakGc38IAQQUgBSgCzAIiCiAFKALQAhDeAiAbIAgpAgA3AgAgGyAIKAIINgIIIBkgGikCADcCACAZIBooAgg2AgggFyAYKQIANwIAIBcgGCgCCDYCCCAVIBYoAgg2AgggFSAWKQIANwIAIAUgBS0AvgI6AKIBIAUgBSgCqAI2AowBIAUgBSkCpAE3AgggEyAUKAIINgIIIBMgFCkCADcCACARIBIpAgA3AgAgESASKAIINgIIIA0gDikCADcCACANIA4oAgg2AgggCyAMKQIANwIAIAsgDCgCCDYCCCAFQQE2AhAgBSADNgIUIAUgBSkCtAE3AhggByAJKAIINgIIIAcgCSkCADcCACAFQQE6AKEBIAUgBSkCrAI3ApABIAUgBSkCtAI3ApgBIAUgBS0AvAI6AKABIAIgBUEIahDfAiEQIAUoAsgCIAoQASACKAIEIAIoAgggBBDhAiIKIBA2AhQgCkEBNgIQIAIoAgQgAigCCCADEOECQTxqIAQQ4AIgARC/BAJAAkAgASgCCCIEIAEoAgRJBEAgASgCACAEai0AACIKQSxGDQEgCkHdAEYNAgsgACABQazswgBBJRD2BwwNCyABIARBAWo2AggLIAZBAWohBgwACwALIAEgB0EBaiIGNgIICyAG", + "IAkgBiAJSxshCANAIAYgCEYEQCAIIQYMCQsCQCAGIAxqLQAAIgtBMGtB/wFxQQpJDQAgC0ErayIOQRpNQQBBASAOdEGNgIAgcRsNACALQeUARw0JCyABIAZBAWoiBjYCCAwACwALIAAgAzYCBCAAQX82AgAgASAEQQFqNgIIDAcLIABB0ezCAEEcEAYMBgsgACABQfHswgBBMBD2BwwFCyAFQaQBaiABQeDgwgBBBBD4ByAFKAKkASIBQX9HBEAgACAFKQKoATcCBCAAIAE2AgAMBQsgBUGkAWpBpeDCAEEGQeDgwgBBBBDeAiAFIAUtAL4COgCiASAFIAUoAqgCNgKMASAFIAUpArwBNwIgIAUgBSgCxAE2AiggBSAFKQLIATcCLCAFIAUoAtABNgI0IAUgBSkC1AE3AjggBSAFKALcATYCQCAFIAUpAqQBNwIIIAUgBSgC6AE2AkwgBSAFKQLgATcCRCAFIAM2AhAgBSAENgIUIAUgBSgC9AE2AlggBSAFKQLsATcCUCAFIAUpAvgBNwJcIAUgBSgCgAI2AmQgBSAFKQKEAjcCaCAFIAUoAowCNgJwIAUgBSkCtAE3AhggBSAFKQKQAjcCdCAFIAUoApgCNgJ8IAUgBSgCpAI2AogBIAUgBSkCnAI3AoABIAUgBSkCrAI3ApABIAUgBSkCtAI3ApgBIAUgBS8BvAI7AaABIAIgBUEIahDfAiEBIABBfzYCACAAIAE2AgQMBAtBBSEHQYzkwgALIQYgBUGkAWogASAGIAcQ+AcgBSgCpAEiAUF/RwRAIAAgBSkCqAE3AgQgACABNgIADAMLIAVBpAFqIgEgBiAHEFIgAUGG5MIAQQZBASAFKAKoASAFKAKkASIBG0EAIAUoAqwBIAEbEN4CIAUgBS0AvgI6AKIBIAUgBSgCqAI2AowBIAUgBSkCvAE3AiAgBSAFKALEATYCKCAFIAUpAsgBNwIsIAUgBSgC0AE2AjQgBSAFKQLUATcCOCAFIAUoAtwBNgJAIAUg", + "BSkCpAE3AgggBSAFKALoATYCTCAFIAUpAuABNwJEIAUgAzYCECAFIAQ2AhQgBSAFKAL0ATYCWCAFIAUpAuwBNwJQIAUgBSkC+AE3AlwgBSAFKAKAAjYCZCAFIAUpAoQCNwJoIAUgBSgCjAI2AnAgBSAFKQK0ATcCGCAFIAUpApACNwJ0IAUgBSgCmAI2AnwgBSAFKAKkAjYCiAEgBSAFKQKcAjcCgAEgBSAFKQKsAjcCkAEgBSAFKQK0AjcCmAEgBSAFLwG8AjsBoAEgAiAFQQhqEN8CIQEgAEF/NgIAIAAgATYCBAwCCyAFQaQBaiIIIAEQ9wcgBSgCsAEhBiAFKAKsASEBIAUoAqgBIQcgBSgCpAFFBEAgCEHj38IAQQUgASAGEN4CIAUgBS0AvgI6AKIBIAUgBSgCqAI2AowBIAUgBSkCvAE3AiAgBSAFKALEATYCKCAFIAUpAsgBNwIsIAUgBSgC0AE2AjQgBSAFKQLUATcCOCAFIAUoAtwBNgJAIAUgBSkCpAE3AgggBSAFKALoATYCTCAFIAUpAuABNwJEIAUgAzYCECAFIAQ2AhQgBSAFKAL0ATYCWCAFIAUpAuwBNwJQIAUgBSkC+AE3AlwgBSAFKAKAAjYCZCAFIAUpAoQCNwJoIAUgBSgCjAI2AnAgBSAFKQK0ATcCGCAFIAUpApACNwJ0IAUgBSgCmAI2AnwgBSAFKAKkAjYCiAEgBSAFKQKcAjcCgAEgBSAFKQKsAjcCkAEgBSAFKQK0AjcCmAEgBSAFLwG8AjsBoAEgAiAFQQhqEN8CIQIgAEF/NgIAIAAgAjYCBCAHIAEQAQwCCyAAIAY2AgggACABNgIEIAAgBzYCAAwBCyAGIAdJIAYgCUtyDQEgBUEIaiANIAYgB2sQUgJAAn8CQCAFKAIIRQRAIAUoAhAhASAFKAIMIQYMAQsgBUHIAmogAUGV3sIAQQ4Q9gcgBSgC0AIhASAFKALMAiIGIAUoAsgCIgdBf0cNARoLIAUgATYCxAIgBSAG", + "NgLAAiAFQQhqIAYgARB6IAUtAAhBAUcNASAFQQI2AtwCIAUgBUHAAmo2AtgCIAVByAJqQQRyQY6JwAAgBUHYAmoQDCAFKQPQAiIcQiCIpyEBIAUoAswCIQcgHKcLIQYgACABNgIIIAAgBjYCBCAAIAc2AgAMAQsgBUGwAWohAQJ/AkAgBSsDECIdvUIBhkL/////////b1gEQCAdIB38BiIcuWENAQsgASAdEPEEQQchBkGh38IADAELIAEgHBDwBEEFIQZBnN/CAAshASAFKAKwASAFKAK0ASAFQaQBaiABIAYgBSkCtAEiHKcgHEIgiKcQ3gIgBSAFLQC+AjoAogEgBSAFKAKoAjYCjAEgBSAFKQK8ATcCICAFIAUoAsQBNgIoIAUgBSkCyAE3AiwgBSAFKALQATYCNCAFIAUpAtQBNwI4IAUgBSgC3AE2AkAgBSAFKQKkATcCCCAFIAUoAugBNgJMIAUgBSkC4AE3AkQgBSADNgIQIAUgBDYCFCAFIAUoAvQBNgJYIAUgBSkC7AE3AlAgBSAFKQL4ATcCXCAFIAUoAoACNgJkIAUgBSkChAI3AmggBSAFKAKMAjYCcCAFIAUpArQBNwIYIAUgBSkCkAI3AnQgBSAFKAKYAjYCfCAFIAUoAqQCNgKIASAFIAUpApwCNwKAASAFIAUpAqwCNwKQASAFIAUpArQCNwKYASAFIAUvAbwCOwGgASACIAVBCGoQ3wIhASAAQX82AgAgACABNgIEEAELIAVB4AJqJAAPCyAHIAYgCUGk7cIAECkAC6gHAgp/AX4jAEHQBmsiCCQAIAggBTYCBCAIIAQ2AgACfyAHRQRAIAhBFGogAiADEAZBASEMQQAMAQsgCEEIaiACIAMQ2wIgCCgCDCEMIAgoAgghDSAIKAIQCyEKIAgoAhQhDiAIQQhqIgsgASAIKAIYIg8gCCgCHBDcAiAIQZQFaiALEN0CIAhBmAVqIQkCQAJAIAgoApQFQQFGBEAgCCAJKAIINgLIBiAIIAkp", + "AgA3A8AGIAhBHTYCsAUgCEECNgKoBSAIIAhBwAZqNgKsBSAIIAg2AqQFIAhBiAVqQemVwAAgCEGkBWoQDCAIKALABiAIKALEBhABIAggCCgCkAUiATYCgAUgCCAIKQKIBSISNwP4BCAAIAE2AgwgACASNwIEIABBATYCACALEOICIA4gDxABDAELIAggCSkCADcD6AQgCCAJKAIIIgk2AvAEAkACQCAHIAlBAEdyIhBFBEAgCEGUBWogAiADEAYgCCgCnAUhCgwBCyAIIAo2ApwFIAggDDYCmAUgCCANNgKUBSAJDQELIApFBEBBACEJQQAhCgwBCyAIQbwFakGl4MIAQQYQBiAIQQI6AL4GIAhCATcC2AUgCEIANwLQBSAIQoCAgIAQNwLIBSAIQgE3AogGIAhCADcCgAYgCEKAgICAEDcC+AUgCEIBNwLwBSAIQgA3AugFIAhCgICAgMAANwLgBSAIQQA2AqQFIAhBADYCrAUgCEEANgK0BSAIQQA2ApgGIAhBADYCrAYgCEKAgICAEDcCkAYgCEKAgICAEDcCnAYgCEIANwKkBiAIQgA3AbYGIAhCADcCsAYgASAIQaQFahDfAiECQQBBARABIAhB6ARqIAIQ4AIgCCgC8AQhCQsgCUECdCEDQQAhByAIKAKYBSELIAgoAuwEIQIDQCADBEAgASgCBCABKAIIIAIoAgAQ4QIiCSAHNgKIASAIQaQFaiIRIAQgBRAGIAkoAnggCUH8AGooAgAQASAJIAgoAqwFNgKAASAJIAgpAqQFNwJ4IAlBAToAmAEgCSAGNgKMASAHIApFckUEQCARIAsgChBCIAkoAmwgCUHwAGooAgAQASAJIAgoAqwFNgJ0IAkgCCkCpAU3AmwLIAJBBGohAiAHQQFqIQcgA0EEayEDDAELCyAAIAgoAvAENgIMIAAgCCkD6AQ3AgQgAEEANgIAIAgoApQFIAsQASAIQQhqEOICIA4gDxABIBANAQsgDSAMEAELIAhB0AZqJAALbgAg", + "ACgCGCAAKAIcEAEgACgCJCAAKAIoEAEgACgCMCAAKAI0EAEgACgCPCAAKAJAECYgACgCSCAAKAJMEAEgACgCVCAAKAJYEAEgACgCYCAAKAJkEAEgACgCbCAAKAJwEAEgACgCeCAAKAJ8EAELDgAgACABQdADQQgQiQgLQgECfyAAKAIMIAAoAgQiAWtB0ANuIQIDQCACBEAgAkEBayECIAEQ2gQgAUHQA2ohAQwBCwsgACgCCCAAKAIAEOwHCyUBAX8jAEEQayICJAAgAiABENQEIAAgAikCADcDACACQRBqJAAL+wECA34FfyAAKAIMRQRAQQAPCyAAKQMQIAApAxggARCABCECIAAoAgQiBiACp3EhBSACQhmIQv8Ag0KBgoSIkKDAgAF+IQQgACgCACEAA0AgACAFaikAACIDIASFIgJCf4UgAkKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyECAkACQANAIAJQIghFBEAgASAAIAJ6p0EDdiAFaiAGcSIJQQR0a0EQaygCAEYNAiACQgF9IAKDIQIMAQsLIAMgA0IBhoNCgIGChIiQoMCAf4NQDQELQQBBACAAIAlBBHRrIAgbQQxrIAgbDwsgBSAHQQhqIgdqIAZxIQUMAAsACyMAIAEEQCAAIAFBBGooAgAgAUEIaigCABBCDwsgAEF/NgIAC5oGAgx/A34jAEEgayIHJAAgByACNgIQIAEpAxAgASkDGCACEIAEIREgByAHQRBqNgIUIAEoAghFBEACQCMAQUBqIgQkACAEIAFBEGoiCTYCDCABKAIMIQggBCAEQQxqNgIQIAhBAWoiBQRAAn8CQCABKAIEIgYgBkEBakEDdkEHbCAGQQhJGyIGQQF2IAVJBEAgBEEwakEQIAZBAWoiBiAFIAUgBkkbEJcDIAQoAjQiBiAEKAIwIgVFDQIaIAQoAjghDCAEIAQoAjw2AiwgBCAMNgIoIAQgBjYCJCAEIAU2AiAgBEKQgICAgAE3AhggBCAJNgIUIAEoAgAi", + "DSkDAEJ/hUKAgYKEiJCgwIB/gyEQIARBIGohDgNAIAgEQANAIBBQBEAgCkEIaiEKIA1BCGoiDSkDAEJ/hUKAgYKEiJCgwIB/gyEQDAELCyAFIAUgBiAEQRBqIAEgEHqnQQN2IApqIgsQ/wMiEhCFASIJaiASp0EZdiIPOgAAIAUgBiAJQQhrcWpBCGogDzoAACAFIAlBf3NBBHRqIgkgASgCACALQX9zQQR0aiILKQAINwAIIAkgCykAADcAACAIQQFrIQggEEIBfSAQgyEQDAELCyAEIAEoAgwiBTYCLCAEIAwgBWs2AiggASAOEJgDIARBFGoQmQMMAQsgASAEQRBqQRpBEBCaAwtBAAsaIARBQGskAAwBCxCBAQALCyAHIAdBFGo2AhggByABNgIcIAdBCGogASgCACABKAIEIBEgB0EYakEfEJUDIAEoAgAhBCAHKAIMIQUCQCAHKAIIQQFGBEAgBCAFaiIILQAAIQYgCCARp0EZdiIIOgAAIAQgASgCBCAFQQhrcWpBCGogCDoAACAAQX82AgAgASABKAIMQQFqNgIMIAEgASgCCCAGQQFxazYCCCAEIAVBBHRrIgBBEGsgAjYCACAAQQxrIgAgAykCADcCACAAIAMoAgg2AggMAQsgACAEIAVBBHRrQQxrIgEoAgg2AgggACABKQIANwIAIAEgAykCADcCACABIAMoAgg2AggLIAdBIGokAAsOACAAIAFB2ANBCBCJCAubAQEBfyMAQRBrIgIkAAJAAkACQAJAAkAgAS0AyQNBAWsOBQEAAgADAAsgAEF/NgIADAMLIAIgASgCwANBhOLCACABKALEAyIBGzYCACACQQEgASABQQFNGzYCBCACQQI2AgwgAiACNgIIIABBpMrAACACQQhqEAwMAgsgAEHhrMMAQSsQBgwBCyAAQYytwwBBKxAGCyACQRBqJAALmAEBA38jAEHgA2siAiQAAkAgACgCCCIDRQ0AIAAgA0EBayIDNgIIIAAoAgQgA0HYA2xq", + "IgMoAgAiAEF/Rg0AIAIgADYCCCACQQhqIgRBBHIgA0EEakHUA/wKAAAgAEECRwRAIAEgBBDOBAsgAkHgAWoQ5wcgAigCuAMgAigCvAMQASACKALEAyACKALIAxABCyACQeADaiQACxIAIAAoAgBBf0cEQCAAENoECwtoAQN/IwBBEGsiAiQAIAJBCGogARDFBCAAQQhqIAIoAggiAyACKAIMIgQQBiAAQcQBaiADIAQQBiAAQQI2AiggACABOgDRASAAQQA6ANABIABBgICAgHg2AhggAEEANgIAIAJBEGokAAsOACAAIAFB2AFBCBCJCAsQACAAQQBOBEAgACABEAELCwsAIABBCEEMEIgIC0ABA38gACgCCCEBIAAoAgQiAyECA0AgAQRAIAFBAWshASACENoEIAJB2ANqIQIMAQsLIAAoAgAgA0EIQdgDEDALQgECfyAAKAIMIAAoAgQiAWtB2AFuIQIDQCACBEAgAkEBayECIAEQ5AQgAUHYAWohAQwBCwsgACgCCCAAKAIAEO4HC0ABA38gACgCCCEBIAAoAgQiAyECA0AgAQRAIAFBAWshASACENcEIAJB4AFqIQIMAQsLIAAoAgAgA0EIQeABEDALRwAgACABQf8BcSIBLQDs5kM6AAwgACABLQD05UM2AgQgACABLQDc6EM6AA0gACABLQDk50M2AgggACABQQJ0KAKU4kM2AgALJAEBfyAAKAIAQQJHBEBBCEHgARDlAiIBIABB4AH8CgAACyABCxgAIAAoAgAiAARAIAAQ1wQgAEHgARAZCwsZACAAEOQEIABB2AFqENYEIABB3AFqENYECwwAIABB4AFBCBCGCAs8AQN/IAAoAgghASAAKAIEIgMhAgNAIAEEQCABQQFrIQEgAhDkBCACQdgBaiECDAELCyAAKAIAIAMQ7gcLLAAgABDnByAAQdgBahDnByAAKAKwAyAAKAK0AxABIAAoArwDIAAoAsADEAELLAEBf0EEQRQQ5QIiAUKBgICAEDcC", + "ACABIAApAgA3AgggASAAKAIINgIQIAELzgECA38CfiMAQSBrIgEkAEEEQRQQ5QIiA0EANgIQIANCgICAgMAANwIIIANCgYCAgBA3AgBBCEEwEOUCIQIgAUEIahCCASABKQMIIQQgASkDECEFIAJBADYCCCACQoGAgIAQNwMAIAIgBTcDKCACIAQ3AyAgAUHA28IAKQMANwIMIAIgASkCCDcCDCABQcjbwgApAwA3AhQgAiABKQIQNwIUIAIgASgCGDYCHCAAQQA6ABQgACACNgIQIAAgAzYCDCAAQX82AgAgAUEgaiQAC58BAQN/IwBBIGsiBCQAIAEgASgCMCIFQQFqIgY2AjACQCAGQdAPTQRAIAMtANEBIQUgBCACKQIQNwMYIAQgAikCCDcDECAEIAIpAgA3AwggACABIARBCGogAyAFQQJ0KAK03kMRAAAgASABKAIwQQFrNgIwDAELIAEgBTYCMCAAQQRqQejhwgBBGxAGIABBfjYCACACELsECyAEQSBqJAALPAEBfwNAIAAgASACQYTxwgAQuQIiAygCCEEBR0UEQCADKAIMIQIMAQsLIAAgASACQZTxwgAQuQIoAogBCzwBAX8DQCAAIAEgAkHU8cIAELkCIgMoAghBAUdFBEAgAygCDCECDAELCyAAIAEgAkHk8cIAELkCKAKMAQvlAwEFfyMAQdAAayIEJAAgBEEANgIsIARCgICAgBA3AiQCQCACRQ0AA0AgBEEYaiABIAJBChDjAkEAIQUCfyAEKAIYQQFHBEAgAiEGIAEhB0EBDAELIARBEGogBCgCHEEBaiIFIAEgAkHg0sMAEOQCIAQoAhQhBiAEKAIQIQcgBEEIaiAFIAEgAkHw0sMAEL8CIAQoAgwhBSAEKAIICyEBIAUhAgJAAkBB9uPCAEEQIAcgBhDHAkUEQCAEQTBqIAcgBhAGIAQoAjQhCCAEKAI4IgVFBEBBACEFDAILIAggBUGUtMMAQQEQsQJFDQEgCCAFQSUQlwINASAEIAgg", + "BRCkAiAEKAIAIAQoAgRBIxCXAg0BIARBAzYCTCAEIARBMGo2AkggBEE8akGJlsAAIARByABqEAwgBCgCMCAEKAI0EAEgBCAEKAJEIgU2AjggBCAEKQI8NwMwIAQoAjQhCAwBCyADRQ0BIARBJGpBhNPDAEGA08MAIAcgBkHY0sMAQQIQnAIiBRtBBUEEIAUbEAoMAQsgBEEkaiAIIAUQCiAEKAIwIAQoAjQQAQsgAg0ACyAGRQ0AIAcgBkEKEKYCDQAgBEEkakEKENcCCyAAIAQoAiw2AgggACAEKQIkNwIAIARB0ABqJAAL5RcBFX8jAEHgAWsiBCQAIAEoAgQgASgCCCACEOECIgYoAjAgBkE0aigCABABIAZBADYCOCAGQoCAgIAQNwIwAkACQAJAAkACQAJAAkACQAJAAkAgASgCBCABKAIIIAIQrAItAJoBQQFrDgMAAgMBCyAEQaQBaiABKAIEIAEoAgggAhCsAiIGQUBrKAIAIAZBxABqKAIAEIsDIAQoAqgBIQkgBCgCrAEiBkUNBiABKAIEIAEoAgggCSgCABCyBEUNBAwFCyAEQQhqIAEoAgQgASgCCCACEKwCIgJBQGsoAgAgAkHEAGooAgAQiwMgBCgCEEECdCEJIAQoAgwhAiAEKAIIIQYDQCAFIAlGDQMgBEEIaiABIAIgBWooAgAgAxDhBCAEKAIIIgdBf0cEQCAAIAQpAgw3AgQgACAHNgIAIAIgBhDmBAwJBSAFQQRqIQUMAQsACwALIABBfzYCAAwGCyABKAIEIAEoAgggAhCsAiIDKAIABEAgBEEIaiABKAIEIAEoAgggAygCBBCsAhDnBCABKAIEIAEoAgggAhDhAiIDIAQtAKIBOgCaASADIAQoAowBNgKEASADKAIYIANBHGooAgAQASADIAQoAig2AiAgAyAEKQIgNwIYIAEgAiAEKAJIIAQoAkwQ6AQgASgCBCABKAIIIAIQ4QIiASgCJCABQShqKAIAEAEgASAEKAI0NgIsIAEg", + "BCkCLDcCJCABQQA2AgAgBCgCOCAEKAI8EAEgBCgCRCAEKAJIECYgBCgCUCAEKAJUEAEgBCgCXCAEKAJgEAEgBCgCaCAEKAJsEAEgBCgCdCAEKAJ4EAEgBCgCgAEgBCgChAEQAQsgAEF/NgIADAULIAIgBhDmBCAAQX82AgAMBAsgBkECdEEEayEFIAlBCGohBwNAIAVBBUkNAiAFQQhrIQUgBygCACEKIAdBCGohByABKAIEIAEoAgggChCyBEUNAAsLAkAgA0UEQEEAIQMgBEEANgK4ASAEQoCAgIDAADcCsAEgBEG8AWogASgCBCABKAIIIAIQrAIiBkFAaygCACAGQcQAaigCABCLAyAEKALAASEHIAQoAsQBIQoDQCAKIANBAXIiBk0EQCABKAIEIAEoAgggAhDhAiIDKAI8IANBQGsoAgAQJkEAIQUgA0EANgJEIANCgICAgMAANwI8IAQoArQBIQMgBCgCuAEhBgNAIAYgBUEBaiIJTQRAIABBfzYCACAEKAK8ASAEKALAARAmIAQoArABIAMQJiAEKAKoASEJDAcFIAQgASACIAMgBiAFQcS2wwAQISgCACADIAYgCUHUtsMAECEoAgAQ6QQgBUECaiEFDAELAAsACyAHIAogA0HktsMAECEoAgAhBSAHIAogBkH0tsMAECEoAgAhBgJAIAEoAgQgASgCCCAFEKwCIghBKGooAgAgCEEsaigCAEHh38IAQQIQsQJFBEAgASgCBCABKAIIIAYQrAItAJoBBEAgBEEIaiABIAIgASgCBCABKAIIIAYQrAIiBigCACAGKAIEIAMgBEGwAWoQ6gQgBCgCCCIGQX9GDQIgACAEKQIMNwIEIAAgBjYCAAwFCyAEQcgBaiABKAIEIAEoAgggBhCsAiIGQUBrKAIAIAZBxABqKAIAEIsDIAQoAtABQQJ0QQRrIQUgBCgCzAEhBgNAAkAgBUF8RwRAIARBCGogASACIAEoAgQgASgCCCAFIAZqKAIAEKwCIggoAgAg", + "CCgCBCAFQQJ2IARBsAFqEOoEIAQoAggiCEF/Rg0BIAAgBCkCDDcCBCAAIAg2AgAgBCgCyAEgBhAmDAcLIAQoAsgBIAYQJgwDCyAFQQRrIQUMAAsACyAEQQhqIAEgAiAFIAYgAyAEQbABahDrBCAEKAIIIgZBf0YNACAAIAQpAgw3AgQgACAGNgIADAMLIANBAmohAwwACwALQQAhByAEQQA2AtwBIARCgICAgMAANwLUASAEQbABaiABKAIEIAEoAgggAhCsAiIDQUBrKAIAIANBxABqKAIAEIsDIAQoArQBIQoDQCAHQQFyIgUgBCgCuAEiBk8EQCABKAIEIAEoAgggAhDhAiIBKAI8IAFBQGsoAgAQJiABIAQoAtwBNgJEIAEgBCkC1AE3AjwgAEF/NgIAIAQoArABIAoQJgwECyAKIAYgB0GEt8MAECEoAgAhAyAKIAYgBUGUt8MAECEoAgAhBQJAAkAgASgCBCABKAIIIAMQrAIiBkEcaigCACAGQSBqKAIAQaCTwwBBBxCxAkUEQCABKAIEIAEoAgggBRCsAi0AmgFBA0YEQCABKAIEIAEoAgggBRCsAiIDKAIEIAUgAygCABshBQsCfyABKAIEIAEoAgggBRCsAi0AmgEEQEEEQQQQ5QIiAyAFNgIAIARBATYCxAEgBCADNgLAASAEQQE2ArwBQQEhD0EBDAELIARBvAFqIAEoAgQgASgCCCAFEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMgBCgCwAEhAyAEKAK8ASEPIAQoAsQBC0ECdCADaiEWIAMhBgJAA0ACQCAGIBZHBEAgBEEIaiABIAEgASgCBCABKAIIIAYoAgAiBRCsAi0AmgFBA0YEfyABKAIEIAEoAgggBRCsAiIIKAIEIAUgCCgCABsFIAULEOwEIgVBARDhBCAEKAIIIghBf0YNASAAIAQpAgw3AgQgACAINgIADAMLIAMgDxDmBAwFCyABKAIEIAEoAgggBRCsAi0AmgFBAUYEQCAGQQRq", + "IQYgBEHIAWogASgCBCABKAIIIAUQrAIiBUFAaygCACAFQcQAaigCABCLA0EAIQggBCgCzAEhEANAIAhBAXIiFyAEKALQASIMTwRAIAQoAsgBIBAQJgwDBSAQIAwgCEGkt8MAECEhBSAEQQhqIAEoAgQgASgCCCAFKAIAIhgQrAIiBUEoaigCACAFQSxqKAIAEEJBACEFIAQoAhAhCyAEKAIMIREgASgCBCABKAIIIAIQrAIhDQJAA0AgBUEBaiIUIA1BxABqIhIoAgAiFU8NASANQUBrIg4oAgAgFSAFQaCawwAQISETIAVBAmohBSABKAIEIAEoAgggEygCABCsAiITQShqKAIAIBNBLGooAgAgESALEBJFDQALIA4oAgAgEigCACAUQbCawwAQIRoLQQAhBSAEKALYASESIAQoAtwBIQ0DQAJAIA0gBUEBak0EQCAUIBVJDQEgASAYEOwEIQUgASAQIAwgF0G0t8MAECEoAgAQ7AQhDCABKAIEIAEoAgggBRDhAiILIAI2AgwgC0EBNgIIIAEoAgQgASgCCCAMEOECIgsgAjYCDCALQQE2AgggBEHUAWoiCyAFEOACIAsgDBDgAgwBCyASIA0gBUHEt8MAECEhDiAFQQJqIQUgASgCBCABKAIIIA4oAgAQrAIiDkEoaigCACAOQSxqKAIAIBEgCxCWA0UNAQsLIAQoAgggERABIAhBAmohCAwBCwALAAsLIAEoAgQgASgCCCAFEKwCIQEgBEEDNgIMIAQgAUEYajYCCCAAQfGLwAAgBEEIahAMCyADIA8Q5gQMAQsgBEEIaiABIANBARDhBCAEKAIIIgZBf0cEQCAAIAQpAgw3AgQgACAGNgIADAELIARBCGogASAFQQEQ4QQgBCgCCCIGQX9HBEAgACAEKQIMNwIEIAAgBjYCAAwBCyAEQdQBaiIGIAMQ4AIgBiAFEOACDAELIAQoArABIAoQJiAEKALUASAEKALYARAmDAQLIAdBAmohBwwACwALIAQoArwB", + "IAcQJiAEKAKwASAEKAK0ARAmDAELQQAhBQNAIAYgBUEBaiICTQRAIABBfzYCACAEKAKkASAJECYMAwsgBEEIaiABIAkgBiAFQey1wwAQISgCACADEOEEIAQoAggiB0F/RwRAIAAgBCkCDDcCBCAAIAc2AgAMAgsgBEEIaiABIAkgBiACQfy1wwAQISgCACADEOEEIAQoAggiAkF/RwRAIAAgBCkCDDcCBCAAIAI2AgAFIAVBAmohBQwBCwsLIAQoAqQBIAkQJgsgBEHgAWokAAupFQMHfwJ8AX4jAEHwAGsiByQAAkACQAJAA0ACQAJAAkACQAJAAkAgASgCBCABKAIIIAIQrAItAJoBQQFrDgMBAgQACyAHQRhqIAEoAgQgASgCCCACEKwCIgJBQGsoAgAgAkHEAGooAgAQiwMCQCAHKAIgIgoEQCAGQdsAENcCIApBAnQhDCAFQQFqIQtBACECIAcoAhwhCEEBIQkDQCACIAxGDQUgBiADIAQgCxDtBCAHQShqIAEgAiAIaigCACADIAQgCyAGEOIEIAcoAigiDUF/RwRAIAAgBykCLDcCBCAAIA02AgAMAwsgCSAKSQRAIAZBLBDXAgsgCUEBaiEJIAJBBGohAgwACwALIAZBhLzDAEECEAogAEF/NgIAIAcoAhwhCAsgBygCGCAIECYMCAsgB0EYaiABKAIEIAEoAgggAhCsAiICQUBrKAIAIAJBxABqKAIAEIsDAkAgBygCICIIBEAgBkH7ABDXAiAFQQFqIQogBygCHCECA0AgCCAJQQFqIgtNBEAgBiADIAQgBRDtBCAGQf0AENcCIABBfzYCACAHKAIYIAIQJgwLCyAGIAMgBCAKEO0EIAIgCCAJQcDRwwAQISEMIAEoAgQgASgCCCAMKAIAEKwCIgwoAiggDCgCLCAGEO4EIAZBOhDXAiAEBEAgBkEgENcCCyAHQShqIAEgAiAIIAtB0NHDABAhKAIAIAMgBCAKIAYQ4gQgBygCKCILQX9HBEAgACAH", + "KQIsNwIEIAAgCzYCAAwDCyAJQQJqIgkgCE8NACAGQSwQ1wIMAAsACyAGQeeywwBBAhAKIABBfzYCACAHKAIcIQILIAcoAhggAhAmDAcLIAdBDGogASACEK0CIAcoAhAiCiAHKAIUQaHfwgBBBxASDQIMBAsgBiADIAQgBRDtBCAGQd0AENcCIABBfzYCACAHKAIYIAgQJgwFCyABKAIEIAEoAgggAhCsAiICKAIABEAgAigCBCECDAIFIAZB4ODCAEEEEAogAEF/NgIADAULAAsLIAEoAgQgASgCCCACEKwCIgQoAiwiA0UNACAHQShqIAQoAigiBSADEJADIAcpAyhCAVINACAHKwMwIg69QgGGQv////////9vVg0AQQAhBAJAAkACQAJAAkAgBS0AAEEtRgRAQQEhBCADQQFGDQELAkAgAyAESwRAIAQgBWotAAAiCEEwRgRAIARBAWohBAwCC0GU0sMAIAgQ7wRFDQIDQCADIARGDQMgBCAFai0AAEEwa0H/AXFBCUsNAiAEQQFqIQQMAAsAC0EBQQFBhNLDABAqAAsCQAJAAkAgAyAETQ0AIAQgBWotAABBLkcNACAEQQFqIgQgA0YNAyADIARLBEAgBCAFai0AAEEwa0H/AXFBCUsNBEEBIQkDQCADIARGDQMgBCAFai0AAEEwa0H/AXFBCUsEQAwDBSAEQQFqIQQMAQsACwALIAQgA0GY0sMAECoACyADIARNDQEgBCAFai0AAEEgckHlAEcNAQJAIARBAWoiCCADTw0AAkAgBSAIai0AAEEraw4DAAEAAQsgBEECaiEICyADIAhGDQIgAyAISwRAIAUgCGotAABBMGtB/wFxQQlLDQNBASEJA0AgAyAIRg0CIAUgCGotAABBMGtB/wFxQQlLBEAgCCEEDAQFIAhBAWohCAwBCwALAAsgCCADQajSwwAQKgALIAMhBAsgAyAERw0AIAkNAQsgByAOOQNIIA6dIA5hIA6ZRFDv4tbkGktEY3ENASAHQSA2", + "AhwgByAHQcgAajYCGCAHQShqQYyWwAAgB0EYahAMIAcoAiwiAyAHKAIwQeUAEL0CRQRAIAcgBygCMDYCICAHIAcpAig3AxgMAwsgB0EgNgJUIAcgB0HIAGo2AlAgB0EYakH70cMAIAdB0ABqEAwgBygCKCADEAEMAgsgB0HgAGogBSADEAYMAgsgByAO/AY3A1AgB0EhNgIsIAcgB0HQAGo2AiggB0EYakGMlsAAIAdBKGoQDAsgBygCHCEDIAcoAiAhBCAHQQA2AkQgByADIARqNgJAIAcgAzYCPCAHIAQ2AjggByADNgI0IAdBxQA2AjAgB0KugICA0Aw3AiggB0E8aiEDAkADQAJAIAcgAxCVAiAHKAIEIgRBf0YNACAEIAdBKGpBAxCWAkUNAQwCCwsgB0EYakGB0sMAQQIQCgsgByAHKAIgNgJoIAcgBykDGDcDYAsgBygCYCIDQX9GDQAgBiAHKAJkIgEgBygCaBAKIABBfzYCACADIAEQAQwBCyAHQeAAaiABIAIQrQIgASgCBCABKAIIIAJBxPHCABC5AiECAn8CQAJAAkAgBygCZCIDIAcoAmgiBEGc38IAQQUQEkUEQCADIARBod/CAEEHEBJFBEAgAyAEQYbkwgBBBhASDQJBg4CAgHggAyAEQaXgwgBBBhASDQUaIAdBGGogAkEoaigCACACQSxqKAIAEEIgBygCGAwFCyAHQShqIAIoAiggAigCLBC1AiAHKAIoDQMgByAHKwMwOQMgQYGAgIB4DAQLIAdBKGogAigCKCACKAIsELICIAcoAihFDQEgByAHKQMwNwMgQYCAgIB4DAMLIAcgAhC4AjoAHEGCgICAeAwCCyAHIAcpAzA3AyAgByAHKAIsNgIcQX8MAQsgByAHKwMwOQMgIAcgBygCLDYCHEF/CyEBIAcoAmAgAxABIAcoAhwhAiABQX9GBEAgBykDICEQIABBA2ogAkEYdjoAACAAIAJBCHY7AAEgACAQNwIEIAAgAjoAAAwBCyAH", + "KQMgIRACQAJAAkACQAJAAkBBBCABQYCAgIB4cyABQQBOG0EBaw4EBAECAwALIAdBKGogEBDwBCAGIAcoAiwiASAHKAIwEAogBygCKCABEAEMBAsgBkHt7MIAQYzkwgAgAkEBcSIBG0EEQQUgARsQCgwDCyAGQeDgwgBBBBAKDAILIAIgEKcgBhDuBCABIAIQAQwBCwJAIBC/Ig4gDmEEQCAOmSIPRAAAAAAAAPB/Yg0BCyAHQShqIgEgDhDxBCAHQQM2AhwgByABNgIYIABBw5TAACAHQRhqEAwgBygCKCAHKAIsEAEMAgsgByAQNwNIAkAgD0SN7bWg98awPmMgD0RQ7+LW5BpLRGZyRSAORAAAAAAAAAAAYXJFBEAgB0EiNgIsIAcgB0HIAGo2AiggB0EYakGMlsAAIAdBKGoiBRAMIAUgBygCHCICIAcoAiAiARDyBCAHKAIwIQMgBygCNCEEIAcgBygCLCABIAcoAigiARs2AlQgByABIAIgARs2AlAgBSADQdbhwgAgARsgBEEBIAEbEPMEIAdBLUErQQAgBygCLCAHLQAoGyIBQQBIGzYCWCAHIAEgAUEfdSIDcyADazYCXCAHQSM2AjwgB0EQNgI0IAdBAjYCLCAHIAdB3ABqNgI4IAcgB0HYAGo2AjAgByAHQdAAajYCKCAHQeAAakHKm8MAIAUQDCAHKAIYIAIQAQwBCyAHQSA2AiwgByAHQcgAajYCKCAHQeAAakGMlsAAIAdBKGoQDAsgBiAHKAJkIgEgBygCaBAKIAcoAmAgARABCyAAQX82AgAgBygCDCAKEAEMAQsgBygCDCAKEAELIAdB8ABqJAAL3A0CBX8BfiMAQcAFayIEJABB2NLDAEECIAEoAgQgASgCCCACEKwCIgYoAnAgBigCdBDHAiEFAkAgAAJ+AkACQAJAIAYtAJoBQQJGBEAgAy0ABEEBcQ0BCyADKAIAIQUgBEIANwJkIARBADsBbCAEIAE2AtwBIARBADsA1wEgBEKAgICA", + "kKCAgAE3AM8BIARBADoAzgEgBEEBOgDMASAEQgA3AsABIARC/////w83ArgBIARC/////w83ArABIARBADYCqAEgBEKAgICAEDcCoAEgBEIBNwKYASAEQgA3ApABIARCgICAgBA3AogBIARCATcCgAEgBEIANwJ4IARCgICAgBA3AnAgBEEBNgJgIARCADcCWCAEQoCAgIAQNwJQIARCATcCSCAEQgA3AkAgBEKAgICAEDcCOCAEQgQ3AjAgBEIANwIoIARCgICAgMAANwIgIARCATcCGCAEQgA3AhAgBEKAgICAEDcCCCAEIAMtAAY6AM0BIARBCUECIAUgBUECTRsiASABQQlPGzYCrAEgBEF/NgLIASAEQgA3AsgDIARCgICAgBA3AsADIARCATcCuAMgBEIANwKwAyAEQoCAgIAQNwKoAyAEQQA6AIAEIARCADcC+AMgBEKAgICAEDcC8AMgBEIBNwLoAyAEQgA3AuADIARCgICAgBA3AtgDIARCATcC0AMgBEGsBWoiCCAEQQhqIgcgBEGoA2oiBRD0BCAEKAKsBSIBQX9HDQIgBEECOgC4AiAEQgA3AoACIARCgICAgBA3AvgBIARCATcC8AEgBEIANwLoASAEQoCAgIAQNwLgASAEQoCAgIAQNwKwAiAEQoCAgIAQNwKoAiAEQgE3AqACIARCADcCmAIgBEKAgICAEDcCkAIgBEIBNwKIAiAFIAcgBEHgAWoQ9AQgBCgCqAMiAUF/Rw0BIAUgByACQQFBAUEAEPUEIAQoAqgDIgFBf0cNASAEQQM6AJQDIARCADcC3AIgBEKAgICAEDcC1AIgBEIBNwLMAiAEQgA3AsQCIARCgICAgBA3ArwCIARCgICAgBA3AowDIARCgICAgBA3AoQDIARCATcC/AIgBEIANwL0AiAEQoCAgIAQNwLsAiAEQgE3AuQCIAUgByAEQbwCahD0BCAEKAKoAyIBQX9HDQEgBEEAOgDVASAEQgA3AsgDIARCgICAgBA3AsAD", + "IARCATcCuAMgBEIANwKwAyAEQoCAgIAQNwKoAyAEQQE6AIAEIARCADcC+AMgBEKAgICAEDcC8AMgBEIBNwLoAyAEQgA3AuADIARCgICAgBA3AtgDIARCATcC0AMgCCAHIAUQ9AQgBCgCrAUiAUF/Rw0CIAUgB0HUAfwKAAAgBCAEKAIQNgKgAyAEIAQpAgg3A5gDIAQoArQDIAQoArgDEAEgBEHAA2oQ9gQgBCgCzAMgBCgC0AMQJiAEKALYAyAEKALcAxABIAQoAuQDIAQoAugDEAEgBCgC8AMgBCgC9AMQASAEKAL8AyAEKAKABBABIAQoApAEIAQoApQEEAEgBCgCnAQgBCgCoAQQASAEKAKoBCAEKAKsBBABIAQoArQEIAQoArgEEAEgBCgCwAQgBCgCxAQQASAIIARBmANqEPcEIAQoAqwFQX9HBEAgBCAEKAK8BTYCuAMgBCAEKQK0BTcDsAMgBCAEKQKsBTcDqAMgBEGgBWogBRD4BCAEKAKoAyAEKAKsAxABIAQgBCgCqAUiATYCmAUgBCAEKQKgBSIJNwOQBSAAIAE2AgwgACAJNwIEIABBATYCAAwFCyAEIAQpArAFNwOABSAEIAQoArgFNgKIBSAEQagDaiAGKAJkIAYoAmggAy0ABRDgBCAEQYAFaiAEKAKsAyIBIAQoArADEAogBCgCqAMgARABIAAgBCgCiAU2AgwgACAEKQOABTcCBCAAQQA2AgAMBAsgBEEIaiAGQShqKAIAIAZBLGooAgAQQgJAIAYoAnQEQCAEKAIQRQ0BCyAEQQhqQdjSwwBBlLTDACAFG0ECQQEgBRsQCgsgACAEKAIQNgIMIAAgBCkCCDcCBCAAQQA2AgAMAwsgBCkCrAMMAQsgBCkCsAULNwIIIAAgATYCBCAAQQE2AgAgBCgCCCAEKAIMEAEgBCgCFCAEKAIYEAEgBEEgahD2BCAEKAIsIAQoAjAQJiAEKAI4IAQoAjwQASAEKAJEIAQoAkgQASAEKAJQIAQoAlQQ", + "ASAEKAJcIAQoAmAQASAEKAJwIAQoAnQQASAEKAJ8IAQoAoABEAEgBCgCiAEgBCgCjAEQASAEKAKUASAEKAKYARABIAQoAqABIAQoAqQBEAELIARBwAVqJAALMgAgACgCCCAAKAIMEM8EIAAoAsQBIAAoAsgBEAEgAEEoahDlBCAAKAIYIAAoAhwQzwQLEgAgACgCAEECRwRAIAAQwgQLCwgAIAEgABAmC9gCAQl/IAEoAoQBIQIgAS0AmgEhAyAAQRhqIAEoAhwgASgCIBBCIABBJGogASgCKCABKAIsEEIgAEEwaiABKAI0IAEoAjgQQiABKAIAIQQgASgCBCEFIABBPGogASgCQCABKAJEEIsDIABByABqIAEoAkwgASgCUBBCIABB1ABqIAEoAlggASgCXBBCIABB4ABqIAEoAmQgASgCaBBCIAEoAgghBiABKAIMIQcgASgCECEIIAEoAhQhCSAAQewAaiABKAJwIAEoAnQQQiABKAKIASEKIABB+ABqIAEoAnwgASgCgAEQQiAAIAM6AJoBIAAgAjYChAEgACAKNgKIASAAIAk2AhQgACAINgIQIAAgBzYCDCAAIAY2AgggACAFNgIEIAAgBDYCACAAIAEvAZgBOwGYASAAIAEoApQBNgKUASAAIAEoApABNgKQASAAIAEoAowBNgKMAQuZAQECfyMAQRBrIgUkAEEBIQQCQCAAKAIEIAAoAgggAUH08MIAELkCLQCaAUEBRgRAA0AgAyAETQ0CIAVBCGogACABIAIoAgAgAkEEaigCABDpBCAEQQJqIQQgAkEIaiECDAALAAsgA0ECdCEEA0AgBEUNASAAIAEgAigCABCrBSAEQQRrIQQgAkEEaiECDAALAAsgBUEQaiQAC5wBAQF/IAEgAxDsBCEDIAEoAgQgASgCCCADEOECIgVBAToAmQEgBSACNgIMIAVBATYCCCABIAQQ7AQhBSABKAIEIAEoAgggBRDhAiIEQQA6AJkBIAQgAjYCDCAEQQE2Aggg", + "BCADNgIUIARBATYCECABKAIEIAEoAgggAhDhAkE8aiIBIAMQ4AIgASAFEOACIAAgBTYCBCAAIAM2AgALqgIBA38jAEEgayIHJAACQCADQQFGBEAgASgCBCIDIAEoAggiCCAEEKwCLQCaAUEBRgRAIAdBCGogAyAIIAQQrAIiA0FAaygCACADQcQAaigCABCLA0EAIQMgBygCDCEEIAcoAhAhCANAIAggA0EBaiIJTQRAIABBfzYCACAHKAIIIAQQJgwECyAHQRRqIAEgAiAEIAggA0HMtcMAECEoAgAgBCAIIAlB3LXDABAhKAIAIAUgBhDrBCAHKAIUIglBf0cEQCAAIAcpAhg3AgQgACAJNgIAIAcoAgggBBAmDAQFIANBAmohAwwBCwALAAsgAyAIIAQQrAIhASAHQQM2AhggByABQRhqNgIUIABB8YvAACAHQRRqEAwMAQsgAEF/NgIACyAHQSBqJAALzAQBCn8jAEEwayIHJAAgB0EkaiABIARBABDhBAJAIAcoAiQiCUF/RwRAIAAgBykCKDcCBCAAIAk2AgAMAQsgB0EMaiABKAIEIAEoAgggAxCsAiIJQShqKAIAIAlBLGooAgAQQiABKAIEIAEoAgggAxCsAigCACEOIAYoAgQhCyAGKAIIIQogBygCFCENIAcoAhAhCQJAAkADQCAKIAhBAWoiD00EQCAHQRhqIAEoAgQgASgCCCACEKwCIgJBQGsoAgAgAkHEAGooAgAQiwMgBUECaiEIIAcoAhwhAiAHKAIgIQUDQCAFIAhNBEAgB0EkaiABIANBABDhBCAHKAIkIgFBf0cEQCAAIAcpAig3AgQgACABNgIADAULIAYgAxDgAiAGIAQQ4AIgAEF/NgIAIAcoAhggAhAmIAcoAgwgCRABDAYLIAIgBSAIQYy2wwAQISEKAkAgASgCBCABKAIIIAooAgAiChCsAiILQShqKAIAIAtBLGooAgAgCSANEJYDBEAgASgCBCABKAIIIAoQrAIoAgBFDQEL", + "IAhBAmohCAwBCwsgAEF/NgIADAILIAsgCiAIQZy2wwAQISEMAkAgASgCBCABKAIIIAwoAgAiDBCsAiIQQShqKAIAIBBBLGooAgAgCSANEJYDBEAgASgCBCABKAIIIAwQrAIoAgAgDnJFDQELIAhBAmohCAwBCwsgCyAKIA9BrLbDABAhIAQ2AgAgAEF/NgIAIAcoAhAhCQwBCyAHKAIYIAIQJgsgBygCDCAJEAELIAdBMGokAAsLACAAIAFBARCqBQsrAAJAIAJFDQAgAEEKENcCA0AgA0UNASAAIAEgAhAKIANBAWshAwwACwALC+ACAQF/IwBBIGsiAyQAIAJBIhDXAiADIAA2AgAgAyAAIAFqNgIEA0ACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCADEMIBIgBBAWoODwwBAQEBAQEBAQcGBAEIBQALAkAgAEGowABrDgIJCgALIABBIkYNASAAQdwARg0CCyAAQSBJDQkgAiAAENcCDAsLIAJB4NHDAEECEAoMCgsgAkGcvsMAQQIQCgwJCyACQZ6+wwBBAhAKDAgLIAJBoL7DAEECEAoMBwsgAkGivsMAQQIQCgwGCyACQeLRwwBBAhAKDAULIAJBpL7DAEECEAoMBAsgAkHk0cMAQQYQCgwDCyACQerRwwBBBhAKDAILIAMgADYCFCADQQE2AhwgAyADQRRqNgIYIANBCGpB8NHDACADQRhqEAwgAygCCCACIAMoAgwiASADKAIQEAogARABDAELCyACQSIQ1wIgA0EgaiQAC0EBAn8gAUH/AXEiAyAALQABTwR/IABBAUECIAAtAAAiAhtqLQAAIQAgAkUEQCAAIANPDwsgAUH/AXEgAEkFQQALC/kCAgV/An4jAEEwayICJAACQCABQgBZBEAgAkEIakETQQFBARAHIAJBADYCLCACIAIpAwg3AiQMAQsgAkEUQQFBARAHIAJBADYCLCACIAIpAwA3AiQgAkEkakEtENcCQgAgAX0hAQtBEyEDIAEh", + "ByABQugHWgRAA0AgAkERaiADaiIEQQRrIAciCCAHQpDOAIAiB0KQzgB+faciBUH//wNxQeQAbiIGQQF0LwDxiEE7AAAgBEECayAFIAZB5ABsa0H//wNxQQF0LwDxiEE7AAAgA0EEayEDIAhC/6ziBFYNAAsLIAdCCVYEQCADQQJrIgMgAkERamogB6ciBCAEQf//A3FB5ABuIgRB5ABsa0H//wNxQQF0LwDxiEE7AAAgBK0hBwsgAVBFIAdQcUUEQCADQQFrIgMgAkERamogB6dBAXQtAPKIQToAAAsgAkEkaiACQRFqIANqQRMgA2sQCiAAIAIoAiw2AgggACACKQIkNwIAIAJBMGokAAuEBwMGfwZ8An4jAEFAaiICJAAgAiABOQMAAkACQAJAIAEgAWEEQCABmSIIRAAAAAAAAPB/YQ0BIAFEAAAAAAAAAABhDQICfAJAAkACfyAIvSIOQoCAgICAgIAIWQRAIA5C//////////f/AFYNA0GBeCEDIA5CIIgiD0KAgMD/A1IEQCAPpwwCC0GAgMD/AyAOpw0BGkQAAAAAAAAAAAwEC0QAAAAAAADw/yAIRAAAAAAAAAAAYQ0DGiAOQgBTDQFBy3chAyAIRAAAAAAAAFBDor0iDkIgiKcLQeK+JWoiBEEUdiADarciDEQAYJ9QE0TTP6IiDSAOQv////8PgyAEQf//P3FBnsGa/wNqrUIghoS/RAAAAAAAAPC/oCIJIAkgCUQAAAAAAADgP6KiIgqhvUKAgICAcIO/IgtEAAAgFXvL2z+iIgigIgEgCCANIAGhoCAJIAuhIAqhIAkgCUQAAAAAAAAAQKCjIgEgCiABIAGiIgEgAaIiCCAIIAhEn8Z40Amawz+iRK94jh3Fccw/oKJEBPqXmZmZ2T+goiABIAggCCAIRERSPt8S8cI/okTeA8uWZEbHP6CiRFmTIpQkSdI/oKJEk1VVVVVV5T+goqCgoqAiAUQAACAVe8vbP6IgDEQ2K/ER8/5ZPaIgASALoETV", + "rZrKOJS7PaKgoKCgDAILIAggCKFEAAAAAAAAAACjIQgLIAgLnPwCQQRqQRlPBEAgAkEiNgIsIAIgAjYCKCACQQxqQYyWwAAgAkEoaiIGEAwgBiACKAIQIgcgAigCFCIFEPIEIAIoAjAhAyACKAI0IQQgAiACKAIsIAUgAigCKCIFGzYCHCACIAUgByAFGzYCGCAGIANB1uHCACAFGyAEQQEgBRsQ8wQgAkEtQStBACACKAIsIAItACgbIgNBAEgbNgIgIAIgAyADQR91IgRzIARrNgIkIAJBIzYCPCACQRA2AjQgAkECNgIsIAIgAkEkajYCOCACIAJBIGo2AjAgAiACQRhqNgIoIABBypvDACAGEAwgAigCDCAHEAEMBAsgAkEgNgIsIAIgAjYCKCAAQYyWwAAgAkEoahAMDAMLIABB4JvDAEEDEAYMAgsgAEHcm8MAQdibwwAgAUQAAAAAAAAAAGQbQQQQBgwBCyAAQdabwwBB1uHCACABvUIAUyIAG0ECQQEgABsQBgsgAkFAayQAC3EBAn8jAEEwayIDJAAgA0EUaiIEQeUAIAEgAhCiAiADQQhqIAQQxQICQCADKAIIQQFGBEAgAygCDCEEIAAgAiADKAIQIgJrNgIMIAAgASACajYCCCAAIAQ2AgQMAQtBACEBCyAAIAE2AgAgA0EwaiQAC9QEAgR/AX4jAEEgayIEJAACQAJAAkACQAJAAkACQAJAAkAgAg4CAAECCyAAQQA6AAFBASECDAcLIAEtAAAiA0Eraw4DAgECAQsgAS0AACEDCwJAAkACQCADQf8BcUEraw4DAQIAAgsgAkEBayEFIAFBAWohASACQQlPBEBBACEDA0AgBUUNByAEQRhqIAEtAABBChAWIAQoAhghBiADrEIKfiIHQiCIpyAHpyICQR91RgRAIAZBAXFFDQUgAiAEKAIcIgNIIAIgA2siA0EASHMNBiABQQFqIQEgBUEBayEFDAELC0EBIQIgBkEBcUUNAyAAQQM6AAEMBwtB", + "ACEDA0AgBUUNBiAEQRBqIAEtAABBChAWIAQoAhBBAUcNAyABQQFqIQEgBUEBayEFIANBCmwgBCgCFGshAwwACwALIAJBAWshAiABQQFqIQELIAJBCE8EQEEAIQMDQCACRQ0FIARBCGogAS0AAEEKEBYgBCgCCCEFIAOsQgp+IgdCIIinIAenIgNBH3VGBEAgBUEBcUUNAyAEKAIMIgVBAEggAyADIAVqIgNKcw0FIAFBAWohASACQQFrIQIMAQsLQQEhAiAFQQFxRQ0BIABBAjoAAQwFC0EAIQMDQCACRQ0EIAQgAS0AAEEKEBYgBCgCAEEBRw0BIAFBAWohASACQQFrIQIgBCgCBCADQQpsaiEDDAALAAtBASECIABBAToAAQwDCyAAQQM6AAFBASECDAILIABBAjoAAUEBIQIMAQsgACADNgIEQQAhAgsgACACOgAAIARBIGokAAuHFwElfyMAQYABayIDJAAgASgCICIFIAEoAhhGBEAjAEEQayIEJAAgBEEIaiABQRhqIgYgBigCAEEBQQRB3AAQlwEgBCgCCCIGQX9HBEAgBCgCDBogBhAcAAsgBEEQaiQACyABKAIcIAVB3ABsaiACQdwA/AoAACABIAVBAWoiBDYCICABQQxqISAgAUGMAWohGCABQYABaiEZIAFB9ABqIRogAUHoAGohGyABQdQAaiEcIANB1ABqISEgA0HIAGohIiADQTxqISMgA0EwaiEkIANBJGohJSADQRhqISYCQCAAAn4DQAJAIAEoAhwhBQJAAkACQAJAIAQgASgCrAEiAkYNAEEBIQcCQAJAAkACQAJAIAUgBCACQayVwwAQ+QQtAFhBAmsOBwIDAwMAAwEDC0ECIQcMAQtBAyEHCyAEIAJrIAdLDQAgAiAESw0BIARB3ABsIAJB3ABsIgJrIQQgASgCHCIFIAJqIQJBACEHA0ACQCAEBEAgAi0AWCIGQQlLDQECQEEBIAZ0IgZBxQJxRQRAIAZBigVxDQEMAwsgB0EBaiEH", + "DAILIAdBAWshBwwBCyABKAKsASIEIAEoAiBHDQUMBAsgAkHcAGohAiAEQdwAayEEIAcNAAsLIAEoAhwgASgCICABKAKsAUH8l8MAEPkEIgUtAFghDCADQQxqIAVBBGooAgAgBUEIaigCABAGICYgBUEQaigCACAFQRRqKAIAEAYgJSAFQRxqKAIAIAVBIGooAgAQBiAFLwFWIQIgBS0AVCENIAUtAFUhBiAkIAVBKGooAgAgBUEsaigCABAGICMgBUE0aigCACAFQThqKAIAEAYgIiAFQUBrKAIAIAVBxABqKAIAEAYgISAFQcwAaigCACAFQdAAaigCABAGIAFBADYCXCABQQA2AlAgAUEANgJEIAFBADYCOCADIAY6AGEgAyANOgBgIAMgDDoAZCADIAI7AWIgAygCOCICBEAgA0H0AGogAygCNCACEAYgASgCaCABKAJsEAEgGyADKAJ8NgIIIBsgAykCdDcCAAsgAygCRCICBEAgA0H0AGogAygCQCACEAYgASgCdCABKAJ4EAEgGiADKAJ8NgIIIBogAykCdDcCAAsgAygCUCICBEAgA0H0AGogAygCTCACEAYgASgCgAEgASgChAEQASAZIAMoAnw2AgggGSADKQJ0NwIACyADKAJcIgIEQCADQfQAaiADKAJYIAIQBiABKAKMASABKAKQARABIBggAygCfDYCCCAYIAMpAnQ3AgALAkACQAJAIAxBBGsOBQABAgcCBwsgA0H0AGogASADKAIQIAMoAhRBARD6BCADKAJ0IgRBf0YNBgwHCyADKAIUIgIEQCADQfQAaiABIAMoAhAgAkEAEPoEIAMoAnQiBEF/Rw0HCyADKAIgIgJFIAYgDXJyDQQgA0H0AGogASADKAIcIAIQ+wQgAygCdCIEQX9HDQYMBAsgAygCFCICBEAgA0H0AGogASADKAIQIAJBABD6BCADKAJ0IgRBf0cNBgsgAygCICICRSANQQFxcg0EIANB9ABqIAEgAygCHCACEPsEIAMo", + "AnQiBEF/Rw0FDAQLIAIgBCAEQbyVwwAQKQALIAFBADYCIANAIAQEQCAEQQFrIQQgBRD8BCAFQdwAaiEFDAELCyABQQA2AqwBCyAAQX82AgAMBQsgA0H0AGogAygCKCIKIAMoAiwiCRAGIAEoAlQgASgCWBABIBwgAygCfDYCCCAcIAMpAnQ3AgACQCAJBEBBACEEQQAhAiAJQQJNDQEgCiAJQZSVwwBBAxD9AUUEQCAKIAlBl5XDAEEDEP0BRQ0CC0EBIQIMAQsgAUEAOgBkIAFBgICECDYCYAwBCyABLQDEASEnQQEhC0EAIQ9BACEdQQAhEEEAIRNBACEUQQAhEUEAIRVBACEWQQAhHkEAIRJBACEXIAIhBwNAAkACfwJAAkACQAJAAkACQAJAAkACQCAEIAlPBEAgAUGBgoQINgBhIAEgFzoAYCAVIBZyIBFyIBRyQQFxBEAgAUEAOwBhCyARQQFxDQEMCwtBASEOIAkgBCAKai0AACIIEP0EIARqIgVLBEAgBSAKai0AACIGQSBGIAZBCUZyIQ4LAkACQCAERQRAQQEhBiAIQSFrIh9BH0sNBEEBIB90IgtB95SAgHpxDQYgC0GAgICQBHENASAfQQxHDQQgByAOciEHIAIgDnIhBgwIC0EBIQYCQCAIQdsAaw4DCAUIAAsCQCAIQfsAaw4DCAUIAAsgCEEJRg0GIAhBI0YNASAIQSxGIAhBP0ZyDQcgCEE6Rw0ECyAHIA5yIQcMBgsgByALciEHIAIgC3IhBgwFCyABQQA6AGQMCQsgCEH7AGtBA0kgCEHbAGsiC0EFTUEAQQEgC3RBJXEbcg0BIAhBCUYNAgsgAiEGDAILQQEhBwwBC0EBIR4MAQsgCiAJIAQQ/gQgCMAiAkEYdEEATiAncnFBAXMgEnIhEiACQf8BcUEgRg0BIAYhAgtBACEPIAogCSAEEP8EDQFBAAwCCyAPIBNyIRMgBSAJRiARciERIARFIBZyIRZBACEPIAYhAkEBDAELIBAgHXIh", + "ECAFIAlGIBRyIRQgBEUgFXIhFUEBIQ9BASEXQQALIR0gCiAJIAQQgAUhCyAFIQQMAQsLIBNBAXEEQCABQQA6AGMgAUEAOwBhCyAQIB5yIBJyQQFxBEAgAUEAOgBjIAFBADsAYQsgECASckEBcQRAIAFBADoAZAsgFwRAIAFBADsAYQsgAkEBcQRAIAFBADoAYQsgB0EBcUUNACABQQA6AGILAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQCABLQDQAUEBaw4TAQIDBAUGBwgJCgsMDQ4PEBESEwALIAwNEyABKAKkASIEQQprQXhPDRZBAiEEIAFBAjYCpAEMFgsgA0HoAGogASANIAxBARCBBQwUCyADQegAaiABIA0gDEEAEIEFDBMLICBBBBCCBSABEIMFIANB9ABqIAEgA0EMakEBQQBBAEEAEIQFIAMoAnQiBEF/Rw0WIAEQhQUgARCGBQwVCyAMQQNHDRAgAUEANgLAASABEIYFIAFBfzYCwAEgARCHBUECIQQgDUEBcQ0TIAFBl5XDAEEDQQFBAEEAEIgFIAEQhwUMEwsgA0HoAGogASADQQxqQQFBABCJBQwQCyADQegAaiABIANBDGpBAEEBEIkFDA8LIANB6ABqIAEgA0EMakEAQQAQiQUMDgsgA0HoAGogASADQQxqQQFBABCKBQwNCyADQegAaiABIANBDGpBAEEBEIoFDAwLIANB6ABqIAEgA0EMakEAQQAQigUMCwsgA0HoAGogASADQQxqQQEQiwUMCgsgA0HoAGogASADQQxqQQAQiwUMCQsgA0HoAGogASADQQxqQQEQjAUMCAsgA0HoAGogASADQQxqQQAQjAUMBwsgA0HoAGogASADQQxqQQEQjQUMBgsgA0HoAGogASADQQxqQQAQjQUMBQsgA0HoAGogASADQQxqQQEQjgUMBAsgA0HoAGogASADQQxqQQAQjgUMAwsgA0HoAGpB25PD", + "AEEhEAYMAgsgA0HoAGpB8ZXDAEEVEAYMAQsgA0HoAGpB3JXDAEEVEAYLIAMoAmgiBEF/Rg0CIAMpAmwMBQsCQCABIAEoAqgBIgJBAEgEf0H/////BwUgAiAEQQF0Sw0BQdAACzYCqAELQQEhBCABQQE6AM4BIAFBgQI7AMsBIAFCADcCuAEgAUF/NgKwASABQX82AsABCyABIAQ6ANABCyABIAEoAqwBQQFqNgKsASADQQxqEPwEIAEoAiAhBAwBCwsgAykCeAs3AgQgACAENgIAIANBDGoQ/AQLIANBgAFqJAAL7BMCEX8EfiMAQdABayIGJAAgBkEEaiABKALUASIHQQRqKAIAIAdBCGooAgAgAhCsAiICLQCaASACKAIcIAIoAiAgAigCKCACKAIsIAIoAoQBEI8FQQEhCCAGKAIQIQcCQCAGKAIMIgkNACACLQCaAUECRw0AQQNBASAHQR5xGyEICyAGKAIIIQsgBigCBCAGQRRqIAIoAkwgAigCUBAGAkAgA0UEQCAGQSBqIAIoAmQgAigCaBAGDAELIAZBADYCKCAGQoCAgIAQNwIgCwJAAkACQAJAAkACQAJAAkACQCACLQCaAUEBaw4DAgADAQtBAiEDIAdBAnFFDQNBAyEDDAQLIAZBxABqIgggAigCNCACKAI4EAZBAEEBEAEgBikCRCEXIAYoAkwhAyAIIAsgCRCQBUEAQQEQASAGKQJEIRggBigCTCEEQQBBARABIAYpAhQhGSAGKAIcIQUgBkEGOgCcASAGIAlFIAdBC3RBgIAEcXI2ApgBIAZBADYClAEgBkKAgICAEDcCjAEgBkIBNwKEASAGQgA3AnwgBkKAgICAEDcCdCAGIAU2AnAgBiAZNwJoIAZBADYCZCAGQoCAgIAQNwJcIAYgBDYCWCAGIBg3AlAgBiADNgJMIAYgFzcCRCAGQcQBaiABIAgQ9AQgBigCxAEiA0F/RwRAIAAgBikCyAE3AgQgACADNgIADAYLIAIoAkRBAnQhAyAC", + "KAJAIQcDQAJAIAMEQCAGQcQAaiABIAcoAgBBAEEBQQAQ9QQgBigCRCIEQX9GDQEgACAGKQJINwIEIAAgBDYCAAwICyAGQcQAaiIEIAIoAlggAigCXBAGQQBBARABIAYpAkQhFyAGKAJMIQJBAEEBEAEgBikCICEYIAYoAighAyAGQQc6AJwBIAZCADcClAEgBkKAgICAEDcCjAEgBiADNgKIASAGIBg3AoABIAYgAjYCfCAGIBc3AnQgBkIBNwJsIAZCADcCZCAGQoCAgIAQNwJcIAZCATcCVCAGQgA3AkwgBkKAgICAEDcCRCAGQcQBaiABIAQQ9AQgBigCxAEiAUF/Rg0GIAAgBikCyAE3AgQgACABNgIADAgLIANBBGshAyAHQQRqIQcMAAsACyAGQcQAaiIKIAIoAjQgAigCOBAGQQBBARABIAYpAkQhFyAGKAJMIQMgCiALIAkQkAVBAEEBEAEgBikCRCEYIAYoAkwhCCAKIAQgBRAGQQBBARABIAYpAkQhGSAGKAJMIQRBAEEBEAEgBikCFCEaIAYoAhwhBSAGQQg6AJwBIAYgCUUgB0ELdEGAgARxcjYCmAEgBiAENgKUASAGIBk3AowBIAZCATcChAEgBkIANwJ8IAZCgICAgBA3AnQgBiAFNgJwIAYgGjcCaCAGQQA2AmQgBkKAgICAEDcCXCAGIAg2AlggBiAYNwJQIAYgAzYCTCAGIBc3AkQgBkHEAWogASAKEPQEIAYoAsQBIgNBf0cEQCAAIAYpAsgBNwIEIAAgAzYCAAwFCyACQcQAaiEKIAJBQGshDEEAIQRBASEDQQAhCUEAIQcDQCAHQQFqIhAgCigCACIFTwRAQQBBARABIAZBxABqIgcgAigCWCACKAJcEAZBAEEBEAEgBikCRCEXIAYoAkwhAkEAQQEQASAGKQIgIRggBigCKCEFIAZBCToAnAEgBkEANgKYASAGIAk2ApQBIAYgAzYCkAEgBiAENgKMASAGIAU2AogBIAYgGDcCgAEg", + "BiACNgJ8IAYgFzcCdCAGQgE3AmwgBkIANwJkIAZCgICAgBA3AlwgBkIBNwJUIAZCADcCTCAGQoCAgIAQNwJEIAZBxAFqIAEgBxD0BCAGKALEASIBQX9GDQUgACAGKQLIATcCBCAAIAE2AgAMBwsgDCgCACAFIAdBlO/CABAhIQUgBkEsaiABKALUASIIQQRqKAIAIAhBCGooAgAgBSgCACIIEKwCIgUoAmQgBSgCaBAGAkAgASgC1AEiBUEEaigCACAFQQhqKAIAIAgQrAIiBSgCaARAIAZBxABqIAUtAJoBIAUoAhwgBSgCICAFKAIoIAUoAiwgBSgChAEQjwUCfwJAIAUtAJoBQQJGBEAgBigCTCENIAYoAlAiCEECcUUNAUEDDAILIAZBOGogASAIQQAgAyAJEPUEIAYoAkQgBigCSBABDAMLQQIgCEEEcQ0AGkEEIAhBCHENABpBBSAIQRBxDQAaQQRBA0EBIA1FIAhBHnFBAEdxGyAFKAIoIAUoAixBChC9AhsLIQggBSgCOCERIAUoAjQhEiAFKAIsIRMgBSgCKCEUIAYoAkghDiAGQaABaiIVIAUoAkwgBSgCUBAGIAZBrAFqIhYgBSgCWCAFKAJcEAYgBkEANgLAASAGQoCAgIAQNwK4ASAGQcQBaiIFIAMgCRAGIAZBOGogASAUIBMgEiARIA4gDSAIIBUgFiAGQbgBaiAFEJEFIAYoAkQgDhABDAELIAZBOGogASAIQQAgAyAJEPUECwJAAkAgBigCOCIFQX9HBEAgACAGKQI8NwIEIAAgBTYCACAGKAIsIAYoAjAQAQwBCyAEIAMQASAGKAI0IQkgBigCMCEDIAYoAiwhBCAGQcQAaiABIAwoAgAgCigCACAQQaTvwgAQISgCAEEAQQFBABD1BCAGKAJEIgVBf0YNASAAIAYpAkg3AgQgACAFNgIACyAEIAMQAQwGCyAHQQJqIQcMAAsACyAGQcQAaiIHIAIoAiggAigCLBAGQQBBARABIAYpAkQh", + "FyAGKAJMIQNBAEEBEAEgBikCFCEYIAYoAhwhBCAHIAIoAlggAigCXBAGQQBBARABIAYpAkQhGSAGKAJMIQJBAEEBEAEgBikCICEaIAYoAighBSAGQQQ6AJwBIAZCADcClAEgBkKAgICAEDcCjAEgBiAFNgKIASAGIBo3AoABIAYgAjYCfCAGIBk3AnQgBiAENgJwIAYgGDcCaCAGQgE3AmAgBkIANwJYIAZCgICAgBA3AlAgBiADNgJMIAYgFzcCRCAGQcQBaiABIAcQ9AQgBigCxAEiAUF/Rg0CIAAgBikCyAE3AgQgACABNgIADAQLIAdBBHENAEEEIQMgB0EIcQ0AIAdBEHEEQEEFIQMMAQtBBCAIIAIoAiggAigCLEEKEL0CGyEDCyACKAI4IQcgAigCNCEIIAIoAiwhCiACKAIoIQwgBkHEAWoiDSACKAJYIAIoAlwQBiAGQcQAaiICIAQgBRAGIAZBuAFqIAEgDCAKIAggByALIAkgAyAGQRRqIA0gBkEgaiACEJEFIAYoArgBIgFBf0YNACAAIAYpArwBNwIEIAAgATYCAAwCCyAAQX82AgAMAQsgBigCICAGKAIkEAELIAsQASAGQdABaiQAC0ABA38gACgCCCEBIAAoAgQiAyECA0AgAQRAIAFBAWshASACEPwEIAJB3ABqIQIMAQsLIAAoAgAgA0EEQdwAEDALbgEBfyMAQRBrIgIkACACQQRqIAEoAgQgASgCCBBSAkAgAigCBEEBRgRAIAAgAikCCDcCDCAAIAEpAgA3AgAgACABKAIINgIIDAELIABBfzYCACAAIAEoAgg2AgwgACABKQIANwIECyACQRBqJAAL2wEBAn8jAEEwayICJAAgAkEANgIQIAJCgICAgBA3AgggAUEMaiEDAkACQCABLQAQQQFGBEAgAiABLQAROgAXIAIgA61CgICAgMAAhDcDICACIAJBF2qtQoCAgIDABIQ3AxggAkEIakGw2sMAQfKBwAAgAkEYahA5DQEMAgsg", + "AiADrUKAgICAwACENwMYIAJBCGpBsNrDAEGjgsAAIAJBGGoQOUUNAQtB2NrDAEE3IAJBL2pByNrDAEGQ28MAEDoACyAAIAIoAhA2AgggACACKQIINwIAIAJBMGokAAsQACAAIAEgAiADQdwAEIQIC5UCAQN/IwBBEGsiByQAAkAgAwRAA0AgAyAGTQRAIAdBBGogAiADEAYgASgCMCABKAI0EAEgASAHKAIMNgI4IAEgBykCBDcCMCAAQX82AgAgASAEOgDPAQwDCwJAAkAgAiAGai0AACIFQTpGDQAgAiADIAYQ/gRFDQAgAiADIAYQ/wQgBUEJRnIgBUEgRnINACACIAMQkgUNAAJAAkAgBUHbAGsOAwIBAgALAkAgBUH7AGsOAwIBAgALIAVBLEYNAQsgBcAiBUEATg0BCyAAQauUwwBB/JPDACAEG0EuQS8gBBsQBgwDCyAFEP0EIAZqIQYMAAsACyAAQfeUwwBB2ZTDACAEG0EdQR4gBBsQBgsgB0EQaiQAC7oCAQV/IwBBQGoiBCQAIARBwJPDACkCADcCLCAEQbiTwwApAgA3AiQgBEGwk8MAKQIANwIcIARBqJPDACkCADcCFAJAAkADQCAFQRBqIgdBMEYNASAEQQxqIAVqIgZBCGooAgAiCEUNASAHIQUgAiADIAZBEGooAgAgBkEUaigCACIHEP0BRQ0ACyAEQTRqIgYgCCAEIAVqQQRqKAIEEAYgASgCPCABKAJAEAEgASAEKAI8NgJEIAEgBCkCNDcCPCAEIAcgAiADQciTwwAQtwEgBiAEKAIAIAQoAgQQBiABKAJIIAEoAkwQASABIAQoAjw2AlAgASAEKQI0NwJIDAELIARBDGogAiADEAYgASgCSCABKAJMEAEgASAEKAIUNgJQIAEgBCkCDDcCSAsgAEF/NgIAIARBQGskAAtWACAAKAIAIAAoAgQQASAAKAIMIAAoAhAQASAAKAIYIAAoAhwQASAAKAIkIAAoAigQASAAKAIwIAAoAjQQ", + "ASAAKAI8IAAoAkAQASAAKAJIIAAoAkwQAQs9ACAAwEEATgRAQQEPCyAAQeABcUHAAUYEQEECDwsgAEHwAXFB4AFGBEBBAw8LQQRBACAAQfgBcUHwAUYbC8cBAQN/IAEgAksEQCAAIAJqLQAAIQMLIAEgAkEBaiIFSwRAIAAgBWotAAAhBAtBACEFIAEgAkECaiICSwRAIAAgAmotAAAhBQtBASECAkAgA0EKRg0AIANBwgFGIARBnwFLcUGR08MAIAMQ7wQgA0E9akH/AXFBKklyciADQe0BRiAEQaABSXEgA0HuAUZycg0AQQAhAiAFQb8BRiIAIARBuwFGcSADQe8BR3INAEEBIQIgBEG/AUcNACAFQb4BRyAAcyECCyACC6ABAQN/IAEgAksEQCAAIAJqLQAAIQQLIAEgAkEBaiIDSwRAIAAgA2otAAAhBQtBACEDIAEgAkECaiICSwRAIAAgAmotAAAhAwtBASECAkACQAJAAkAgBEEKaw4EAgEBAgALIARB4gFHBEAgBEHCAUcgBUGFAUdyDQEMAgsgBUGAAUYiACADQagBRnENASAADQILQQAhAgsgAg8LIANBqQFGC0QBAn8CfyABIAJNIgNFBEBBASAAIAJqLQAAIgRBCUYgBEEgRnINARoLQQEgACABIAIQ/wQgA3INABogACACai0AAEULC6ABAAJAAkACQCADQf8BcUEBaw4CAgABCyAEQQAgAkEBcRtFBEAgARCHBSABQZSVwwBBA0EBQQBBABCIBSABEIcFCyABKAJwBEAgARCDBSABEJMFCyAAQX82AgAgAUEDOgDQAQ8LIABBuJbDAEElEAYPCyABLQDNAQRAIAFBl5XDAEEDQQFBAEEAEIgFIAEQhwULIABBfzYCACABQRM6ANABCzABAX8gACgCCCICIAAoAgBGBEAgABDgAwsgACACQQFqNgIIIAAoAgQgAmogAToAAAuWAQEDfyAAKAKUAQRAIAAQhwUgACgClAEhASAAKAKQASECIABC", + "ATcCkAEgACgCjAEgAEEANgKMASAAIAIgARCUBSAAIAAoArABIgFBACABQQBKGzYCwAEgAhABCyAAKAJwBEAgABCHBSAAKAJwIQEgACgCbCECIABCATcCbCAAKAJoIABBADYCaCAAIAIgARCUBSACEAELC5IXAQZ/IwBBIGsiByQAIAEgBjoAygEgASAFOgDJASABIAQ6AMgBIAEgAzoAxwECQAJAAkACQAJAAkACQAJAAkAgAi0AWCIDQQRrDgUBAgMABAALIAcgAzoACCAHQSU2AhggByAHQQhqNgIUIABB7ILAACAHQRRqEAwMBwsgARCWBSABQQxqEJcFIQIgAEF/NgIAIAFBEyACIAJB/wFxQf8BRhs6ANABDAYLQQEhBSABKAJERQRAIAEoAlBBAEchBQsgBSACLQBUciILQQFxIAItAFUiCEEBcXIEQCACLQBXIQJBAyEJAkAgBkUNACABLQBgQQFxRQ0AQQMhAwwFCyACQQEgAkEBSyIDGyECIAMEQCACIQQMBAsCQAJAIAEoArQBIgRBAEoEQCABLQBhQQFxRQ0BCyAERQRAIAEtAGJBAXFFDQELIAEtAMYBQQJyIQNBASEKDAELIAEtAMYBQQJyIgMhCiADIQILIAIgAyALIAZBf3MgBEEATHEgASgCXEEAR3JxIgIbIQQgCiADIAIbIQIMAwsgB0EIakHdlsMAQSwQBiAHKAIIIgJBf0YNBCAAIAcpAgw3AgQgACACNgIADAULIAEQlgUgARCYBUEFIQYCQCABKAK0AUEASg0AIAItAFZBAXENAEEFQQ0gARCZBRshBgsgAEF/NgIAIAEgBjoA0AEMBAsgARCWBSABEJgFQQghBgJAIAEoArQBQQBKDQAgAi0AVkEBcQ0AQQhBDyABEJoFGyEGCyAAQX82AgAgASAGOgDQAQwDCyACQf8BcUECRgRAQQMhAyABLQBjQQFxRQ0BCyACQf4BcUEERwRAIAIhCSAEIQMMAQtBAyAEIAYgAS0AZEF/cyAB", + "KAK0AUEASnJyQQFxIgQbIQNBAyACIAQbIQkLIAUgCHJBAXEgCUH/AXFBAUZyRQRAIAdBFGpBwPbCAEEBEAYgASgCPCABKAJAEAEgAUE8aiICIAcoAhw2AgggAiAHKQIUNwIACyABIAM6AGULIAEQlgUgARCYBSABQQEQmwUgASgCXCEEIAEoAlghCCABQgE3AlggASgCVCELIAFBADYCVCABLQDKASEKAkACQAJAAkACQAJAAkACQCABLQBlQQJrDgQBBQQDAAsgBEUNBSABLQDLAUEBcUUNAQwFC0EAIQMgAUH4l8MAQQFBAUEAQQAQiAUgB0EANgIUIARBAWshCUEAIQJBACEFA0ACQAJAAkACQCACIARJBEAgAiAIaiIMLQAAIgZBIEcEQCAIIAQgAhD/BEUEQCADQQFxBEAgARCHBQsgBkEnRgRAIAFBJxCcBQsgASAIIAQgB0EUahCdBUEAIQMgAUEAOgDMAUEAIQUMBgsgAyAGQQpHckEBcUUNAgwECyACRSAFIApyQQFxcg0CIAEoArwBIAEoAqgBTCACIAlPcg0CIAwtAAFBIEYNAiABEIcFQQEhBSAHIAJBAWo2AhQMBAsgAUH4l8MAQQFBAEEAQQAQiAUgAUEAOwDLAQwKCyABEJMFDAELIAEgCCAEIAdBFGoQnQVBASEFDAELIAEgCCAEIAdBFGoQngVBASEDCyAHKAIUIQIMAAsACyABQSAQnAUMAwsgAUHak8MAQQFBAUEAQQAQiAUgASAIIAQQnwUgAUEBEKAFIAFBAToAywEgB0EANgIUQQAhAkEBIQlBASEGA0AgAiAETw0EAkACQAJAIAggBCACEP8EIgNFBEAgBkEBcQRAIAEQhwUgAiAIai0AACICQSBGIAJBCUZyIQkMAgsgAiAIai0AAEEgRw0BIAQgAkEBaiICSwRAIAIgCGotAABBIEYNAgsgASgCvAEgASgCqAFMDQEgARCHBSAHIAI2AhQMAgsCQCAGIAlyQQFxDQAgAiAIai0A", + "AEEKRw0AQQAhAgNAAkAgAiAESQRAIAggBCACEP8EDQEgCCAEIAIQgAUNAwsgARCTBQwCCyACIAhqLQAAEP0EIAJqIQIMAAsACyABIAggBCAHQRRqEJ4FDAILIAEgCCAEIAdBFGoQnQULIAFBADoAzAELIAcoAhQhAiADIQYMAAsACyABQayXwwBBAUEBQQBBABCIBSABIAggBBCfBSABQQEQoAUgAUEBOgDLASAHQQA2AhRBACECQQEhBQNAIAIgBE8NAwJAAkAgCCAEIAIQ/wQiA0UEQCAFQQFxRQ0BIAEQhwUMAQsgASAIIAQgB0EUahCeBQwBCyABIAggBCAHQRRqEJ0FIAFBADoAzAELIAcoAhQhAiADIQUMAAsACyABQeSXwwBBAUEBQQBBABCIBSAHQQA2AhQgBEEBayEMQQAhCUEAIQYDQAJ/AkAgBCAJSwRAAkAgCCAEIAkQ/gRFDQAgAS0AxAFFBEAgCCAJaiwAAEEASA0BCyAIIAQQkgUNACAIIAQgCRD/BA0AAkACQAJAIAggCWoiAi0AACIDQSBrDgMCAQMACyADQdwARg0CCyABIAggBCAHQRRqEJ0FQQAMBAsgCUUgBiAKckEBcXINAiABKAK8ASABKAKoAUwgCSAMT3INAiABEIcFIAItAAFBIEYEQCABQdwAEJwFCyAHIAlBAWo2AhRBAQwDCwJ/QQEgCCAJaiwAACIFQQBODQAaIAVBYHFBQEYEQCAFQR9xIQVBAgwBCyAFQXBxQWBGBEAgBUEPcSEFQQMMAQsgBUEHcSAFIAVBeHFBcEYiAhshBUEEQQEgAhsLIgNBAWshBiAJQQFqIQIgBUH/AXEhBQJAA0AgBgRAIAIgBE8NAiACIAhqLQAAQT9xIAVBBnRyIQUgBkEBayEGIAJBAWohAgwBCwsgByADIAlqNgIUIAFB3AAQnAUCQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAUODgIBAQEBAQEDBAUGBwgJAAsCQCAF", + "QajAAGsOAg8QAAsgBUEbRg0JIAVBIkYNCiAFQdwARg0LIAVBhQFGDQwgBUGgAUYNDQsgAUH4AEH1AEHVACAFQYCABEkiAhsgBUGAAkkiAxsQnAVBBEEMQRwgAhsgAxshAgNAQQAgAkEASA0TGiABIAUgAkEccXZBD3EiA0EwciADQTdqIANBCkkbEJwFIAJBBGshAgwACwALIAFBMBCcBUEADBELIAFB4QAQnAVBAAwQCyABQeIAEJwFQQAMDwsgAUH0ABCcBUEADA4LIAFB7gAQnAVBAAwNCyABQfYAEJwFQQAMDAsgAUHmABCcBUEADAsLIAFB8gAQnAVBAAwKCyABQeUAEJwFQQAMCQsgAUEiEJwFQQAMCAsgAUHcABCcBUEADAcLIAFBzgAQnAVBAAwGCyABQd8AEJwFQQAMBQsgAUHMABCcBUEADAQLIAFB0AAQnAVBAAwDCyACIARB6JfDABAqAAsgAUHkl8MAQQFBAEEAQQAQiAUgAUEAOwDLAQwECyABIAggBCAHQRRqEJ0FQQELIQYgBygCFCEJDAALAAtBACEJIAdBADYCFEEAIQJBACEGA0AgAiAETwRAIAQEQCABQQA6AMsBCyABQQA6AMwBIAEtAMcBQQFHDQIgAUEBOgDNAQUCQAJAAkACQAJAIAIgCGotAAAiA0EgRwRAIAggBCACEP8ERQRAIAlBAXFFDQUgARCHBQwFCyAJIANBCkdyQQFxRQ0BDAMLIAYgCnJBAXENASABKAK8ASABKAKoAUwNASAEIAJBAWoiAksEQCACIAhqLQAAQSBGDQILIAEQhwUgByACNgIUQQEhBgwECyABEJMFDAELIAEgCCAEIAdBFGoQnQVBASEGDAILIAEgCCAEIAdBFGoQngVBASEJDAELIAEgCCAEIAdBFGoQnQVBACEJIAFBADoAzAFBACEGCyAHKAIUIQIMAQsLCyABKAJUIAEoAlgQASABIAQ2AlwgASAINgJYIAEgCzYCVCABEKEFIABBfzYCAAsg", + "B0EgaiQACwkAIABBABCgBQtbAQN/IAAoAogBBEAgABCHBSAAKAKIASECIAAoAoQBIQEgAEIBNwKEASAAKAKAASAAQQA2AoABIAAgASACEJQFIAAgACgCsAEiAEEAIABBAEobNgLAASABEAELC4sBAQJ/IAAoArABIgFBACABQQBKGyEBAkACQCAALQDMAUUNACAAKAK8ASICIAFKDQAgASACRw0BIAAtAMsBQQFxDQELIAAQkwULIAEgACgCwAFGBEAgABCTBQsDQCABIAAoArwBTARAIABBADoAzgEgAEEBOgDLASAAQX82AsABBSAAQSAQnAUMAQsLC0YAAkAgA0UNACAALQDLAUEBcQ0AIABBIBCcBQsgACABIAIQogUgACAEOgDLASAAQQA6AM0BIAAgAC0AzAFBACAFGzoAzAELowMBAX8jAEEgayIFJAACQAJAAkACQCADRQRAIAItAFhBB0cNAiABKAK0AUEBayEDDAELIAFBheLCAEEBQQFBAUEAEIgFIAFBARCbBSABIAEoArQBIgNBAWo2ArQBIAItAFhBB0cNAgsgASADNgK0ASAFQQhqIAFBJGoQowUgASAFKAIMQX8gBSgCCEEBcRs2ArABIAEoArwBRQRAIAEQhwULIAFBhuLCAEEBQQBBAEEAEIgFIAEQhQUgARCGBSABQQxqEJcFIQIgAEF/NgIAIAFBEyACIAJB/wFxQf8BRhs6ANABDAILIAQNACABQa2XwwBBAUEAQQBBABCIBQsgARCDBSABKAK8ASIDBH8gAwUgARCHBSABKAK8AQsgASgCqAFKBEAgARCHBQsgAUEMakEGQQcgARCkBRsQggUgBUEUaiABIAJBAEEBQQBBABCEBSAFKAIUIgJBf0cEQCAAIAUpAhg3AgQgACACNgIADAELIAEQpAUEQCABQa2XwwBBAUEAQQBBABCIBQsgARCFBSABEIYFIABBfzYCAAsgBUEgaiQAC7YDAQF/IwBBEGsiBSQAIAMEQCABQYfiwgBB", + "AUEBQQFBABCIBSABQQEQmwUgASABKAK0AUEBajYCtAELAkACQAJAAkACQCACLQBYQQlHBEAgAw0EIARFDQEMBAsCQCABKAJwRQRAIAEoAogBRQ0BCyADIARyDQMMAgsgAyAEcg0CIAEoApQBDQEMAgsgAUGtl8MAQQFBAEEAQQAQiAUMAgsgAUGtl8MAQQFBAEEAQQAQiAULIAEQgwUgASABKAK0AUEBazYCtAEgBUEIaiABQSRqEKMFIAEgBSgCDEF/IAUoAghBAXEbNgKwASABQYjiwgBBAUEAQQBBABCIBSABEIUFIAEQhgUgAUEMahCXBSECIABBfzYCACABQRMgAiACQf8BcUH/AUYbOgDQAQwBCyABEIMFIAEoArwBIgMEfyADBSABEIcFIAEoArwBCyABKAKoAUoEQCABEIcFCyABEKUFRQRAIAFBrpfDAEEBQQFBAEEAEIgFIAFBDGpBDBCCBSAAIAEgAkEAQQBBAUEAEIQFDAELIAFBDGpBCxCCBSAAIAEgAkEAQQBBAUEBEIQFCyAFQRBqJAALuAEBAX8jAEEQayIEJAACQCADDQAgASgCvAEgASgCqAFMDQAgARCHBQsgAUG07cIAQQEgA0EBc0EAQQAQiAUgAUEMakEJQQogARCkBRsQggUgBEEEaiABIAJBAEEAQQFBABCEBQJAIAQoAgQiAkF/RwRAIAAgBCkCCDcCBCAAIAI2AgAMAQsgARCkBQRAIAFBrZfDAEEBQQBBAEEAEIgFCyABEIUFIAEQhgUgAEF/NgIACyAEQRBqJAAL2gEBAX8jAEEQayIEJAAgAwRAIAFBAAJ/QQAgAS0AyQFBAUcNABogASgCvAEEQEEAIAEtAMwBQQFxDQEaCyABLQDFAQtBAXEQpgULAkACQCACLQBYQQdHBEAgARCDBSABEIcFIAFBwJfDAEEBQQFBAEEBEIgFIAFBDGpBDhCCBSAEQQRqIAEgAkEAQQFBAEEAEIQFIAQoAgQiAkF/Rg0BIAAgBCkCCDcC", + "BCAAIAI2AgAMAgsgARChBSAAQX82AgAMAQsgARCFBSABEIYFIABBfzYCAAsgBEEQaiQAC64CAgJ/AX4jAEEQayIEJAAgAwRAIAFBABCbBQsgARCDBQJAAkAgAi0AWCIDQQlHBEAgARCHBSABKAJ8BEAgASgCfCEFIAFBADYCfCABKQJ0IQYgAUKAgICAEDcCdCAEIAU2AgggBCAGNwMAIAEoApgBIAEoApwBEAEgASAEKAIINgKgASABIAQpAwA3ApgBCyABEKUFDQEgAUGul8MAQQFBAUEAQQEQiAUgAUEMakESEIIFIAAgASACQQBBAEEBQQAQhAUMAgsgARChBSAAQX82AgAMAQsgAUEMakEREIIFIAQgASACQQBBAEEBQQEQhAUgBCgCACICQX9HBEAgACAEKQIENwIEIAAgAjYCAAwBCyADQQRGBEAgAUEgEJwFCyAAQX82AgALIARBEGokAAu6AgICfwF+IwBBEGsiBCQAAkAgA0UEQCABEIcFIAFBtO3CAEEBQQFBAEEBEIgFDAELIAFBtO3CAEEBQQBBAEEAEIgFCwJAIAEoAqABRQ0AIAFBmAFqIQMgAi0AWCIFQQVHBEAgAi0AVg0BAkAgBUEGaw4DAAIAAgsgAUH0AGoiBSADEKcFIAEQhQUgBSADEKcFDAELIAEoAnwNACADKAIIIQUgAUEANgKgASADKQIAIQYgAUKAgICAEDcCmAEgBCAFNgIIIAQgBjcDACABKAJ0IAEoAngQASABIAQoAgg2AnwgASAEKQMANwJ0CyABQQxqQRAQggUgBCABIAJBAEEAQQFBABCEBQJAIAQoAgAiAkF/RwRAIAAgBCkCBDcCBAwBCyABEIUFIAEQhgULIAAgAjYCACAEQRBqJAALkAMCAn8BfiMAQSBrIggkACAIQRBqIAIgAxAGIAgoAhghByAIKQMQIQkCQCADRSAGQQFxcg0AAkACQAJAIAFB/wFxQQFrDgMBAgMAC0EAIAcgAiADQbDewgBBBRASGyEH", + "DAILQQAgByACIANBtd7CAEEFEBIbIQcMAQsgAiADQYnTwwBBCBASDQACQCACIANBoJPDAEEHEBJFBEAgAiADQaXgwgBBBhASDQEgAiADQYbkwgBBBhASDQEgAiADQePfwgBBBRASDQEgAiADQZzfwgBBBRASDQEgAiADQaHfwgBBBxASDQEgAiADQfiuwwBBCxASDQEMAgtBACAHIAQgBUHh38IAQQIQEhshBwwBCyAIQQhqIAQgBRCNAwJAIAgoAgggCCgCDCACIAMQEg0AIAIgA0Hj38IAQQUQEkUEQCACIANBod/CAEEHEBINASACIANBnN/CAEEFEBINAQwCCyAGIAZBAnIgBkEecRshBgtBACEHCyAAIAY2AgwgACAHNgIIIAAgCTcCACAIQSBqJAALcgECfyMAQSBrIgMkACADQQhqQcTywgBBAiABIAIQmgICQCADKAIIIgQEQCADKAIMIQEgAyAENgIQIAMgATYCFCADQQI2AhwgAyADQRBqNgIYIABB2oDAACADQRhqEAwMAQsgACABIAIQBgsgA0EgaiQAC4EDAgZ/BX4jAEHgAGsiDSQAIA1BBGogBCAFEAZBAEEBEAEgDSgCDCEPIA0oAgghECANKAIEIRECfyAHRQRAQYACIQZBASEFQQAMAQsgDUEEaiAGIAcQkAVBACEGQQBBARABIA0oAgghBSANKAIEIQ4gDSgCDAshBCANQQRqIhIgAiADEAZBAEEBEAEgDSkCBCETIA0oAgwhAkEAQQEQASAJKQIAIRQgCSgCCCEDQQBBARABIAopAgAhFSAKKAIIIQlBAEEBEAEgCykCACEWIAsoAgghCkEAQQEQASAMKQIAIRcgDCgCCCELIA1BBToAXCANIAdFIAhBGHQgBnJyNgJYIA0gCzYCVCANIBc3AkwgDSAKNgJIIA0gFjcCQCANIAk2AjwgDSAVNwI0IA0gAzYCMCANIBQ3AiggDSACNgIkIA0gEzcCHCANIAQ2AhggDSAFNgIUIA0gDjYC", + "ECANIA82AgwgDSAQNgIIIA0gETYCBCAAIAEgEhD0BCANQeAAaiQACzsBAX8CQCABRSABQQFGcg0AIAAtAABB7wFHDQAgAC0AAUG7AUcgAUEDSXINACAALQACQb8BRiECCyACCzoAIABBChCoBSAAKAK8AUUEQCAAQQE6AM4BCyAAQQA2ArwBIABBAToAzAEgACAAKAK4AUEBajYCuAELwgEBBX8jAEEQayIDJAAgA0EANgIMA0AgAiAETQRAIAVBAXFFBEAgABCTBQsgAEEBOgDLASADQRBqJAAFAkACQAJAIAEgAiAEEP8EIgdFBEAgBUEBcQ0BDAILIAAgASACIANBDGoQngUMAgsgABCHBQsCQCAGQQFxDQAgASAEai0AAEEjRg0AIABBIxCcBSAAQSAQnAULIAAgASACIANBDGoQnQUgAEEAOgDMAQsgB0EBcyEGIAMoAgwhBCAHIQUMAQsLCygAIAEoAgAgAC0AACIAQQJ0KAKM3kMgAC0AgN5DIAEoAgQoAgwRBAALbQECfyMAQRBrIgEkACAAKAI4BEAgAEGblcMAQZqVwwAgAC0AzwEbQQFBAUEAQQAQiAUgAUEEaiAAKAI0IAAoAjgQBiAAIAEoAggiAiABKAIMEKIFIABBADsAywEgASgCBCACEAELIAFBEGokAAsqAQF/IAAoAggiAUUEQEH/AQ8LIAAgAUEBayIBNgIIIAAoAgQgAWotAAAL9AEBA38jAEEgayIBJAACQCAAKAJEIgJFBEAgACgCUEUNASAAQdiTwwBBAkEBQQBBABCIBSABQRRqIAAoAkwgACgCUBAGIAAgASgCGCICIAEoAhwQqQUgAEHak8MAQQFBAEEAQQAQiAUgASgCFCACEAEMAQsgAUEIaiAAKAJAIAIQBiABKAIQIQMgASgCDCECIAAtAMsBRQRAIABBIBCcBQsgACACIAMQogUgAEEAOwDLASAAKAJQIgMEQCABQRRqIAAoAkwgAxAGIAAgASgCGCIAIAEoAhwQqQUg", + "ASgCFCAAEAELIAEoAgggAhABCyABQSBqJAALFQAgAEEHQZyXwwBBBkGMl8MAEIsICxUAIABBCUGolsMAQQhBmJbDABCLCAsLACAAIAFBABCmBQsYACAAIAEQqAUgACAAKAK8AUEBajYCvAELZAECfyACIAMoAgAiBEsEQCAAIAEgBGoiBSABIAIgBEEBIAUtAAAQ/QQiBCAEQQFNG2oiBCACIARJGyICahCoAiADIAI2AgAgACAAKAK8AUEBajYCvAEPCyAEIAJBjJjDABAqAAt4AQF/IAIgAygCACIESwRAIAEgBGotAABBCkYEQCAAEJMFIAMgBEEBajYCAA8LIAAgASACIAMQnQUgACgCvAFFBEAgAEEBOgDOAQsgAEEANgK8ASAAQQE6AMwBIAAgACgCuAFBAWo2ArgBDwsgBCACQcyVwwAQKgALigIBA38jAEEQayIEJAACQCAEAn8gAkUEQCAAQQA6AM0BQS0MAQsgAS0AAEEgRgRAIAQgAC0ApAFBMGo6AA4gACAEQQ5qQQFBAEEAQQAQiAULIABBADoAzQEgAkEBayEFAkACQAJAA0AgBSIDIAJPDQEgA0EBayEFIAEgA2osAABBQEgNAAtBLSABIAIgAxD/BEUNAxogA0UNAgNAIAUiAyACTw0CIANBAWshBSABIANqLAAAQUBIDQALIAEgAiADEP8ERQ0EDAILIAMgAkHEl8MAECoACyADIAJB1JfDABAqAAsgAEEBOgDNAUErCzoADyAAIARBD2pBAUEAQQBBABCIBQsgBEEQaiQAC2ABAn8CQCAAKAJ8IgIEQCAALQDLAUUEQCAAQSAQnAUgACgCfCECCyAAQQA2AnwgACgCdCAAKAJ4IQEgAEKAgICAEDcCdCAAIAEgAhCUBSABEAEMAQsgAUUNACAAEJMFCwtUAQF/IwBBEGsiASQAIAFBCGogAEEkahCjBSAAIAEoAgxBfyABKAIIQQFxGzYCsAEgAEETIABBDGoQlwUiACAAQf8BcUH/AUYb", + "OgDQASABQRBqJAALPgECfyMAQRBrIgMkACADQQA2AgwDQCACIARNBEAgA0EQaiQABSAAIAEgAiADQQxqEJ0FIAMoAgwhBAwBCwsLPwEBfyABKAIIIgIEfyABIAJBAWsiAjYCCCABKAIEIAJBAnRqKAIAIQJBAQVBAAshASAAIAI2AgQgACABNgIACycBAX9BASEBAkAgACgCfA0AIAAoAogBDQAgACgClAFBAEchAQsgAQugAQACfwJAAkACQAJAAkACQCAAKAIcIAAoAiAgACgCrAFBnJXDABD5BC0AWEEEaw4FAAMBBAIECyAAKAI4DAULIAAQmQVFDQIgACgCUCAAKAJEIAAoAjhqagwECyAAEJoFRQ0BIAAoAlAgACgCRCAAKAI4amoMAwsgAC0AYEUNAQtBAA8LIAAoAlwgACgCUCAAKAJEIAAoAjhqamoLQYEBSQv7AQEDfyAAKAKwASIFIQMgACgCLCIEIAAoAiRGBEAgAEEkahDrASAAKAKwASEDCyAAIARBAWo2AiwgACgCKCAEQQJ0aiAFNgIAAkAgA0EASARAIAAoAqQBQQAgARshAwwBCwJAAkACQCAAKAIUIgFFDQAgACgCECABakEBayIBRQ0AIAEtAABBDkYNAQsgACgCpAEiAUUNAQJAIAFBf0YgASADaiIDQYCAgIB4RnFFBEAgACADIAMgAW9rIgE2ArABIAINAQ8LQfWKwQBBP0Gwl8MAEDUACyABQQJrIQMMAgsgA0ECaiEDDAELQbCXwwAQZAALIAAgAzYCsAELCwAgACABQQMQhgELjQEBBH8gACgCCCIEIAAoAgBGBEAjAEEQayICJAAgAkEEaiAAKAIAIgMgACgCBEEIIANBAXQiAyADQQhNGyIDEDcgAigCBEEBRgRAIAIoAgwaIAIoAggQHAALIAIoAgghBSAAIAM2AgAgACAFNgIEIAJBEGokAAsgACAEQQFqNgIIIAAoAgQgBGogAToAAAvfAgEGfyMAQRBrIgYkACAGQQA2", + "AgwDQAJAAkACQAJAIAIgBUsiBwRAIAEgBWotAAAiA0EkayIEQRxNDQEMAgsgAEEAOwDLASAGQRBqJAAPC0EBIAR0Qf2bgNYBcQ0BCyADQf4ARiADQfsAQdsAIANB4ABLG0kgA0Ewa0H/AXFBCkkgA0HAAEsbciADQdsAayIEQQRNQQBBASAEdEEVcRtyIANB3wBGcg0AIANBLUcNAQsgACABIAIgBkEMahCdBSAGKAIMIQUMAQsgBSACIAcbIQcgAxD9BCEDAkADQCADRQ0BIAIgB0cEQCABIAVqLQAAIQQgAEElEJwFIAAgBEEEdiIIQTByIAhBN2ogBEGgAUkbEJwFIAAgBEEPcSIEQTByIARBN2ogBEEKSRsQnAUgA0EBayEDIAdBAWohByAFQQFqIQUMAQsLIAUgAkGIlsMAECoACyAGIAU2AgwMAAsAC4EEAQZ/IwBBwAJrIgMkACAAKAIEIgUgACgCCCIGIAFBmPPCABC5AiIHKAIQQQFGBEAgACAHKAIUEOwEIQggACgCCCEGIAAoAgQhBUEBIQQLIANBCGogBSAGIAFBqPPCABC5AhDnBCADIAMtAKIBOgC+AiADIAMoAowBNgKoAiADIAMpAiA3ArwBIAMgAygCKDYCxAEgAyADKQIsNwLIASADIAMoAjQ2AtABIAMgAykCODcC1AEgAyADKAJANgLcASADIAMpAgg3AqQBIANBADYC6AEgA0KAgICAwAA3AuABIAMgBDYCtAEgAyAINgK4ASADIAMoAlg2AvQBIAMgAykCUDcC7AEgAyADKQJcNwL4ASADIAMoAmQ2AoACIAMgAykCaDcChAIgAyADKAJwNgKMAiADIAMpAhA3AqwBIAMgAykCdDcCkAIgAyADKAJ8NgKYAiADIAMoAogBNgKkAiADIAMpAoABNwKcAiADIAMpApABNwKsAiADIAMpApgBNwK0AiADIAMvAaABOwG8AiAAIANBpAFqIgUQ3wIhBCACBEAgBSAAKAIEIAAoAgggAUG4", + "88IAELkCIgFBQGsoAgAgAUHEAGooAgAQiwMgACAEIAMoAqgBIgAgAygCrAEQ6AQgAygCpAEgABAmCyADKAJEIAMoAkgQJiADQcACaiQAIAQL2AIBA38jAEGgAWsiAyQAIAAgAhDsBCEEIAAoAgQgACgCCCABQfjzwgAQuQIoAkQhAiADQRxqQZzfwgBBBRAGIANBKGogAhCsBSADQQI6AJ4BIANBADYCPCADQoCAgIAQNwI0IANCATcCaCADQgA3AmAgA0KAgICAEDcCWCADQgE3AlAgA0IANwJIIANCgICAgMAANwJAIANBADYCBCADQQA2AowBIANBADYCeCADQoCAgIAQNwJwIANBADYCFCADIAE2AhAgA0EBNgIMIANCADcChAEgA0KAgICAEDcCfCADQgA3AZYBIANCADcCkAEgACADQQRqEN8CIQVBAEEBEAFBAEEBEAEgACgCBCAAKAIIIAQQ4QIiAkEAOgCZASACIAE2AgwgAkEBNgIIIAIgBTYCFCACQQE2AhAgACgCBCAAKAIIIAEQ4QJBPGogBBDgAiADQaABaiQAC/wBAQd/IwBBEGsiBCQAQQohAiABIgNB6AdPBEADQCAEQQZqIAJqIgVBBGsgAyIGIANBkM4AbiIDQZDOAGxrIgdB//8DcUHkAG4iCEEBdC8A8YhBOwAAIAVBAmsgByAIQeQAbGtB//8DcUEBdC8A8YhBOwAAIAJBBGshAiAGQf+s4gRLDQALCyADQQlLBEAgAkECayICIARBBmpqIAMgA0H//wNxQeQAbiIDQeQAbGtB//8DcUEBdC8A8YhBOwAAC0EAIAEgAxtFBEAgAkEBayICIARBBmpqIANBAXQtAPKIQToAAAsgACAEQQZqIAJqQQogAmsQBiAEQRBqJAALWAAjAEEgayIBJAAgAUEIaiADLQDRARDFBCABIAEpAwg3AhAgAUECNgIcIAEgAUEQajYCGCAAQQRqQaiXwAAgAUEYahAMIABBfjYCACACELsEIAFBIGok", + "AAsPACAAIAEgAiADQQAQrwULaAEBfyMAQTBrIgUkACAFIAQ6AAMgBUGswcMANgIQIAVBAToAFCAFQcTBwwA2AgggBUEBNgIEIAUgBUEDajYCDCAFQRhqIgQgAhC+BSAAIAEgBCADIAVBBGoQ3gUgAhC7BCAFQTBqJAALygUCCX8BfiMAQfAAayIEJAAgBEHMAGogAy0A0QEiBiADKALYARCxBSAEKAJQIQUCQAJAIAQoAkwiB0F/RwRAIAAgBCgCVDYCDCAAIAU2AgggACAHNgIEIABBfjYCAAwBCyAEQcwAaiAGIAMoAtwBELIFIAQoAlAhBiAEKAJMIgdBf0cEQCAAIAQoAlQ2AgwgACAGNgIIIAAgBzYCBCAAQX42AgAMAQsCQAJAIAUtANEBIgVBDUYEQCAGLQDRASIFQQVHDQEgASgCBCABKAIIIAIoAgwiBUEMaiIGKAIAIAVBEGoiBygCABCzBQ0CQQAhBSAEQQA2AmwgBEKAgICAwAA3AmQgBEHMAGogBigCACAHKAIAEIsDIAQoAlRBAnQhCyAEKAJQIQYgBCgCTCEHIARBFGohCSAEQThqIQoDQAJAIAUgC0cEQCAEQcwAaiIIIAIgBSAGaigCABC0BSAEQTRqIAEgCCADELUFIAQgCikCADcDKCAEIAooAgg2AjAgBCgCNCIIQX5HDQEgACAEKAIwNgIMIAAgBCkDKDcCBCAAQX42AgAgBiAHEOYEIAQoAmQgBCgCaBAmDAYLIAYgBxDmBCAAIAIgBEHkAGoQtgUMBQsgBCkCRCENIAkgBCgCMDYCCCAJIAQpAyg3AgAgBCANNwIgIAQgCDYCECAEQeQAaiAEKAIcIggoAgwiDCAMIAgoAhBBAnRqEJsEIAVBBGohBSAEQRBqELsEDAALAAsgBEEIaiAFEMUEIAQgBCkDCDcCNCAEQQI2AlAgBCAEQTRqNgJMIABBBGpBr8bAACAEQcwAahAMIABBfjYCAAwCCyAEIAUQxQQgBCAEKQMANwI0IARB", + "AjYCUCAEIARBNGo2AkwgAEEEakGXx8AAIARBzABqEAwgAEF+NgIADAELIAAgASACIAMQtQUMAQsgAhC7BAsgBEHwAGokAAsQACAAIAEgAkGAxcAAEIwICxAAIAAgASACQd7EwAAQjAgLPAECfyADQQJ0IQMDQCADIgQEQCACKAIAIQUgA0EEayEDIAJBBGohAiAAIAEgBRCsAi0AmAENAQsLIARFC0MBAn8jAEEQayIDJABBBEEEEOUCIgQgAjYCACADQQE2AgwgAyAENgIIIANBATYCBCAAIAEgA0EEahC2BSADQRBqJAALxgcBDn8jAEGwAWsiBCQAIARBmAFqIAMtANEBIgYgAygC2AEQsQUgBCgCnAEhBQJAIAQoApgBIgdBf0cEQCAAIAQoAqABNgIMIAAgBTYCCCAAIAc2AgQgAEF+NgIADAELIARBmAFqIAYgAygC3AEQsgUgBCgCnAEhBiAEKAKYASIDQX9HBEAgACAEKAKgATYCDCAAIAY2AgggACADNgIEIABBfjYCAAwBCyAEQShqIQMgBEGYAWoiByACELsFIARBJGogASAHIAUoAtgBELkEIAQoAiQiB0F+RgRAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEDAELIAQgBCkCNDcCHCAEIAc2AgwgBCADKQIANwIQIAQgAygCCDYCGCAEQZgBaiAFQdEBai0AACAFQdwBaigCABCyBSAEKAKcASEFAkAgBCgCmAEiA0F/RwRAIAAgBCgCoAE2AgwgACAFNgIIIAAgAzYCBCAAQX42AgAMAQsgBEHcAGohAyAEQTxqIAVByAFqKAIAIAVBzAFqKAIAEEIgBEGYAWoiBSACELsFIARB2ABqIAEgBSAGKALYARC5BAJAIAQoAlgiB0F+RgRAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEIAQoAkAhBQwBCyAEIAMpAgA3A0ggBCADKAIINgJQIAYoAtwBIQ4gBCgCbCEIIAQoAmghBiAEQZgB", + "aiAEKAIYIgMoAgwgAygCEBCLAyAEKAKgAUECdCEPIAQoApwBIQkgBCgCmAEhCyAEQZwBaiEMIARBhAFqIQ1BACEDIAQoAkQhECAEKAJAIQUDQAJAIAMgD0cEQCADIAlqKAIAIQpBBEEEEOUCIhEgCjYCACAEQQE2AqABIAQgETYCnAEgBEEBNgKYASAGIAUgECAEQZgBaiIKEJYGIAwgBCkDSDcCACAMIAQoAlA2AgggBCAHNgKYASAEIAg2AqwBIAQgBjYCqAEgBEGAAWogASAKIA4QuQQgBCANKQIANwNwIAQgDSgCCDYCeCAEKAKAASIHQX5HDQEgACAEKAJ4NgIMIAAgBCkDcDcCBCAAQX42AgAgCSALEOYEDAMLIAkgCxDmBCAAIAc2AgAgACAINgIUIAAgBjYCECAAIAQpA0g3AgQgACAEKAJQNgIMIAQoAjwgBRABIARBDGoQuwQMBAsgBCAEKQNwNwNIIAQgBCgCeDYCUCADQQRqIQMgBCgClAEhCCAEKAKQASEGDAALAAsgBCgCPCAFEAELIARBDGoQuwQLIAIQuwQgBEGwAWokAAsOACAAIAEgAhDbBBDqBQsZACAAIAEgAiADKALYASADKALcAUEAELgFC/QGAg9/AX4jAEGQAWsiBiQAIAZBADYCjAEgBkKAgICAwAA3AoQBIAZB7ABqIAIoAgwiBygCDCAHKAIQEIsDIAYoAnAiDyAGKAJ0QQJ0aiETIAYoAmwhECAGQTRqIREgBkHYAGohDSAGQQxqIRIgDyEOAkADQAJAAkAgDiATRwRAIAZB7ABqIgggAiAOKAIAIhQQyAUgBkHUAGogASAIIAMQuQQgBiANKQIANwMwIAYgDSgCCDYCOCAGKAJUIgdBfkcNASAAIAYoAjg2AgwgACAGKQMwNwIEIABBfjYCAAwCCyAPIBAQ5gQgACACIAZBhAFqELYFDAMLIAYpAmQhFSASIAYoAjg2AgggEiAGKQMwNwIAIAYgFTcCGCAGIAc2AgggBigC", + "FCIHKAIMIQggBiAHKAIQIglBBEEIEAcgBkEANgJ0IAYgBigCBCIKNgJwIAYgBigCACIHNgJsAn8CQCAHIAlJBEAgBkHsAGpBACAJQQRBCBAvIAYoAnQhByAGKAJwIQoMAQtBACIHIAlFDQEaCyAHIAlqIAogB0EDdGohBwNAIAdBATYCACAHQQRqIAgoAgA2AgAgCEEEaiEIIAdBCGohByAJQQFrIgkNAAsLIQcgBiAGKQJsIhU3AyAgBiAHNgIoIBWnIQsCQCAHBEAgBigCJCEKDAELIAtFBEAgBkEgahDAASAGKAIgIQsLIAYoAiQiCkEANgIAQQEhByAGQQE2AigLIA5BBGohDiAHQQN0IQlBACEHA0ACQCAHIAlHBEAgBSEIIAcgCmoiDCgCAEEBRgRAIAQgCCABKAIEIAEoAgggDEEEaigCABCsAhC4AhshCAsgBkHsAGoiDCACIBQQtAUgBkHUAGogASAMIAgQuQQgBiANKQIANwNIIAYgDSgCCDYCUCAGKAJUIghBfkcNASAAIAYoAlA2AgwgACAGKQNINwIEIABBfjYCACAKIAsQ4AcgBkEIahC7BAwDCyAKIAsQ4AcgBkEIahC7BAwDCyAGKQJkIRUgESAGKAJQNgIIIBEgBikDSDcCACAGIBU3AkAgBiAINgIwIAZBhAFqIAYoAjwiCCgCDCIMIAwgCCgCEEECdGoQmwQgB0EIaiEHIAZBMGoQuwQMAAsACwsgDyAQEOYEIAYoAoQBIAYoAogBECYLIAIQuwQgBkGQAWokAAuAAQEDfyMAQRBrIgQkACAEQQRqIAMtANEBIAMoAtgBELEFIAQoAgghBQJAIAQoAgQiBkF/RwRAIAAgBCgCDDYCDCAAIAU2AgggACAGNgIEIABBfjYCACACELsEDAELIAAgASACIAUoAtgBIAUoAtwBIAMoAtwBELgFCyAEQRBqJAALgQQBBX8jAEGQAWsiBCQAIARB4ABqIgcgAhC7BSAEQTBqIAMtANEBIgggAygC", + "2AEQsQUgBCgCNCEGAkAgBCgCMCIFQX9HBEAgACAEKAI4NgIMIAAgBjYCCCAAIAU2AgQgAEF+NgIAIAcQuwQMAQsgBEEcaiEFIARBGGogASAEQeAAaiAGEN0EIAQoAhgiBkF+RgRAIABBfjYCACAAIAUoAgg2AgwgACAFKQIANwIEDAELIAQgBCkCKDcCECAEIAY2AgAgBCAFKQIANwIEIAQgBSgCCDYCDCAEQeAAaiIGIAIQuwUgBEH4AGogCCADKALcARCyBSAEKAJ8IQUCQCAEKAJ4IgNBf0cEQCAAIAQoAoABNgIMIAAgBTYCCCAAIAM2AgQgAEF+NgIAIAYQuwQMAQsgBEHMAGohAyAEQcgAaiABIARB4ABqIAUQ3QQgBCgCSCIBQX5GBEAgAEF+NgIAIAAgAygCCDYCDCAAIAMpAgA3AgQMAQsgBCAEKQJYNwJAIAQgATYCMCAEIAMpAgA3AjQgBCADKAIINgI8IARBhAFqIgMgBCgCDCIBKAIMIAEoAhAQiwMgASAEKAI8IgFHBEAgAyABKAIMIgMgAyABKAIQQQJ0ahCbBAsgACAEIARBhAFqELYFIARBMGoQuwQLIAQQuwQLIAIQuwQgBEGQAWokAAteAQN/IAEoAgwiBCAEKAIAQQFqIgI2AgACQCACRQ0AIAEoAhAiAiACKAIAQQFqIgM2AgAgA0UNACABLQAUIQMgACABELcEIAAgAzoAFCAAIAI2AhAgACAENgIMDwsAC7MGAgp/AX4jAEGgAWsiBCQAIARBiAFqIgUgAhC9BSAEQRhqIAEgBSADKALYARC5BCAEQRxqIQYCQAJAIAQoAhgiBUF+RgRAIABBfjYCACAAIAYoAgg2AgwgACAGKQIANwIEDAELIAQgBCkCKDcCECAEIAU2AgAgBCAGKQIANwIEIAQgBigCCDYCDEEAIQYCQAJAAkBBCSADKAIYIgVBgICAgHhzIAVBAE4bQQJrDgIAAQILIAMvARwgA0Eeai0AAEEQdHIhBgwBCyAD", + "LwEkIANBJmotAABBEHRyIQYLAkACQCADLQDQAUUEQCAEQTRqIQUgBCAGOwFIIAQgBkEQdjoASiAEQYgBaiIGIAIQvgUgBEEwaiABIAYgAyAEQcgAakG4usMAQQAQvwUgBCgCMCIBQX5GBEAgAEF+NgIAIAAgBSgCCDYCDCAAIAUpAgA3AgQMAwsgBCAEKQJANwKAASAEIAE2AnAgBCAFKQIANwJ0IAQgBSgCCDYCfCAEQfAAahC7BAwBCyAEQYgBaiADLQDRASADKALcARCyBSAEKAKMASEIIAQoAogBIgNBf0cEQCAAIAQoApABNgIMIAAgCDYCCCAAIAM2AgQgAEF+NgIADAILIARBiAFqIAQoAgwiAygCDCIFIAUgAygCEEECdGoQwAUgBCgCkAFBAnQhDCAEKAKMASEFIAQoAogBIQkgBEHMAGohCiAEQfQAaiELQQAhAwNAIAMgDEcEQCAEQYgBaiIHIAIgAyAFaigCACINELQFIARB8ABqIAEgByAIEN0EIAQgCykCADcDYCAEIAsoAgg2AmggBCgCcCIHQX5GBEAgACAEKAJoNgIMIAAgBCkDYDcCBCAAQX42AgAgBSAJEOYEDAQLIAQpAoABIQ4gCiAEKAJoNgIIIAogBCkDYDcCACAEIA43AlggBCAHNgJIIAQoAlQiBygCEARAIAEgDSAHKAIMKAIAIAYQwQULIANBBGohAyAEQcgAahC7BAwBCwsgBSAJEOYECyAAIAIpAhA3AhAgACACKQIINwIIIAAgAikCADcCACAEELsEDAILIAQQuwQLIAIQuwQLIARBoAFqJAALCwAgACABQQAQjQgLCwAgACABQQEQjQgLQAEBfyMAQSBrIgckACAHQQA2AhQgByAGOgAcIAcgBTYCECAHIAQ2AgwgACABIAIgAyAHQQxqEN4FIAdBIGokAAuSAQEDfyMAQSBrIgMkACADQQhqIAIgAWtBAnYiBEEEQQQQByADQQA2AhwgAyADKQMINwIUIANBFGogBBCX", + "BCAEIAMoAhwiBGohBSADKAIYIARBAnRqIQQDQCABIAJGRQRAIAQgAkEEayICKAIANgIAIARBBGohBAwBCwsgACADKQIUNwIAIAAgBTYCCCADQSBqJAALhAQBBH8jAEEgayIFJAAgASACRwRAAkACQCAAKAIEIgQgACgCCCIGIAFB1O/CABC5Ai0AmgFBAkcEQCAEIAYgAUHk78IAELkCKAJERQ0BCyAFQQhqIAAgARCtAiAFQRRqIAAgAhCtAiAFKAIMIgQgBSgCECAFKAIYIgYgBSgCHBCeByAFKAIUIAYQASAFKAIIIAQQAUUNASAAKAIIIQYgACgCBCEECyAEIAYgAkH078IAELkCKAKEASEEIAAoAgQgACgCCCABQYTwwgAQuQIgBDYChAELIAAoAgQgACgCCCABQZTwwgAQuQIiBCgCPCAEQUBrKAIAECYgBEEANgJEIARCgICAgMAANwI8IAAoAgQgACgCCCACQaTwwgAQuQItAJoBIQQgACgCBCAAKAIIIAFBtPDCABC5AiAEOgCaASAFQQhqIAAoAgQgACgCCCACQcTwwgAQuQIiBEFAaygCACAEQcQAaigCABCLAyAAIAEgBSgCDCIGIAUoAhAQ6AQgBUEUaiAAKAIEIAAoAgggAkHU8MIAELkCIgRBKGooAgAgBEEsaigCABBCIAAoAgQgACgCCCABQeTwwgAQuQIiBCgCJCAEQShqKAIAEAEgBCAFKAIcNgIsIAQgBSkCFDcCJCAAKAIEIAAoAgggASACIAMQyQUgBSgCCCAGECYLIAVBIGokAAsPACAAIAEgAiADQSYQxAULLQEBfyMAQeABayIBJAAgAUEIaiIEQRYQzQQgACAEIAIgAxDHBiABQeABaiQAC+IGAg5/AX4jAEHQDGsiBSQAIAVB4ApqIAMtANEBIgcgAygC2AEQsQUgBSgC5AohBgJAAkAgBSgC4AoiCEF/RwRAIAAgBSgC6Ao2AgwgACAGNgIIIAAgCDYCBCAAQX42AgAMAQsg", + "BUHgCmogByADKALcARCyBSAFKALkCiENIAUoAuAKIgdBf0cEQCAAIAUoAugKNgIMIAAgDTYCCCAAIAc2AgQgAEF+NgIADAELIAVBHGohByAFQeAKaiIIIAIQvQUgBUEYaiABIAggBhDdBCAFKAIYIgZBfkYEQCAAQX42AgAgACAHKAIINgIMIAAgBykCADcCBAwBCyAFIAUpAig3AhAgBSAGNgIAIAUgBykCADcCBCAFIAcoAgg2AgxBACEHQQAhBkEAIQgCQAJAAkBBCSADKAIYIgtBgICAgHhzIAtBAE4bQQJrDgIAAQILIAMtAB4hBiADLQAdIQggAy0AHCEKDAELIAMtACYhBgsgBSAGOgDmCiAFIAg6AOUKIAUgCjoA5AogBUGCgICAeDYC4AogBUEwakEIIAVB4ApqIgYQwAcgBiAFKAIMIgYoAgwgBigCEBCLAyAFKALoCkECdCEPIAUoAuQKIQYgBSgC4AohCCAFQawHaiEKIAVBhAlqIQsDQAJAIAcgD0cEQCAFQYgCaiIMIAEgBiAHaigCACIJEOwEEMYGIAVCADcD4AMgBUHoA2oiECAJEMYGIAVCADcDwAUgBUGoB2oiESAFQTBqIhIQzwYgBUHgCmoiCSANEMUGIAVBgAlqIg4gAyAMIAkgBBEAACAFQcgFaiIMIBEgECAOEMcGIAkgAhC7BSAOIAEgCSAMEN0EIAUgCykCADcDwAwgBSALKAIINgLIDCAFKAKACSIJQX5HDQEgACAFKALIDDYCDCAAIAUpA8AMNwIEIABBfjYCACAMENcEIAYgCBDmBCASEOQEIAUQuwQMAwsgBiAIEOYEIAAgAikCEDcCECAAIAIpAgg3AgggACACKQIANwIAIAVBMGoQ5AQgBRC7BAwDCyAFKQKQCSETIAogBSgCyAw2AgggCiAFKQPADDcCACAFIBM3ArgHIAUgCTYCqAcgB0EEaiEHIAVBqAdqELsEIAVByAVqENcEDAALAAsgAhC7BAsgBUHQDGokAAsP", + "ACAAIAEgAiADQScQxAULLQEBfyMAQeABayIBJAAgAUEIaiIEQRcQzQQgACAEIAIgAxDHBiABQeABaiQAC8sFAhF/AX4jAEGQAWsiBCQAIARB+ABqIgUgAhC9BSAEQSBqIAEgBSADKALYARC5BCAEQSRqIQUCQAJAIAQoAiAiB0F+RgRAIABBfjYCACAAIAUoAgg2AgwgACAFKQIANwIEDAELIAQgBCkCMDcCGCAEIAc2AgggBCAFKQIANwIMIAQgBSgCCDYCFCAEQfgAaiADLQDRASADKALcARCyBSAEKAJ8IQkCQCAEKAJ4IgVBf0cEQCAAIAQoAoABNgIMIAAgCTYCCCAAIAU2AgQgAEF+NgIADAELIARB+ABqIAQoAhQiBSgCDCAFKAIQEIsDIAQoAnwhCCAEKAJ4IQogAy0AHCIHQQAgAygCGEGCgICAeEYiBRshDyADLQAeIhBBACAFGyERIAQoAoABQQJ0IRIgBSADLQAdcSETIARBPGohCyAEQeQAaiEMA0ACQCAGIBJHBEAgBEH4AGoiAyACIAYgCGooAgAiDRDIBSAEQeAAaiABIAMgCRDdBCAEIAwpAgA3A1AgBCAMKAIINgJYIAQoAmAiA0F+Rw0BIAAgBCgCWDYCDCAAIAQpA1A3AgQgAEF+NgIAIAggChDmBAwDCyAIIAoQ5gQgACACKQIQNwIQIAAgAikCCDcCCCAAIAIpAgA3AgAgBEEIahC7BAwECyAEKQJwIRUgCyAEKAJYNgIIIAsgBCkDUDcCACAEIBU3AkggBCADNgI4AkAgBCgCRCIDKAIQRQ0AIAMoAgwoAgAhFAJ/IBNFBEBBACEOIA8hBSARDAELIAEoAgQgASgCCCANEKwCIgNBHGooAgAgA0EgaigCAEGl4MIAQQYQEkUNAUEBIQ4gByEFIBALIQMgASgCBCABKAIIIA0gFCAFQf8BcSAOQQh0ciADQRB0chDJBQsgBkEEaiEGIARBOGoQuwQMAAsACyAEQQhqELsECyACELsE", + "CyAEQZABaiQAC0oBAn8jAEEQayIDJABBBEEEEOUCIgQgAjYCACADQQE2AgwgAyAENgIIIANBATYCBCAAIAEgA0EEahC2BSAAQQE6ABQgA0EQaiQAC+cEAQN/IwBBoAFrIgUkACAFQQRqIAAgASADQaTywgAQuQIQ5wQgACABIAJBtPLCABC5AiIALQCaASAFLQCeASIBRwRAIAAoAjwgAEFAaygCABAmIABBADYCRCAAQoCAgIDAADcCPCAAKAIkIABBKGooAgAQASAAQQA2AiwgAEKAgICAEDcCJAsgACABOgCaASAAQRxqKAIAIQECfwJAIARBgIAEcQ0AIAEgACgCICICQcTywgBBAhD9AQ0AQQEgAg0BGgsgACgCGCABEAEgACAFKAIkNgIgIAAgBSkCHDcCGEEACyAAIAUoAgg2AgQgACAFKAIENgIAIARBAXFFBEAgACgCMCAAQTRqKAIAEAEgACAFKAI8NgI4IAAgBSkCNDcCMAsgACgChAFFBEAgACAFKAKIATYChAELIAUoAmwiAQRAIAAoAmAgAEHkAGooAgAQASAAIAVB5ABqIgIoAgg2AmggACACKQIANwJgCyAFKAJUIgIEQCAAKAJIIABBzABqKAIAEAEgACAFQcwAaiIGKAIINgJQIAAgBikCADcCSAsgBSgCYCIGBEAgACgCVCAAQdgAaigCABABIAAgBUHYAGoiBygCCDYCXCAAIAcpAgA3AlQLBEAgBSgCHCAFKAIgEAELIAUoAiggBSgCLBABIARBAXEEQCAFKAI0IAUoAjgQAQsgBSgCQCAFKAJEECYgAkUEQCAFKAJMIAUoAlAQAQsgBkUEQCAFKAJYIAUoAlwQAQsgAUUEQCAFKAJkIAUoAmgQAQsgBSgCcCAFKAJ0EAEgBSgCfCAFKAKAARABIAVBoAFqJAALDwAgACABIAIgA0EoEI4IC6MCAQF/IwBBIGsiASQAAkACQCAEIAVB+d/CAEEGEBIEQEEBIQYMAQsgBCAFQf/fwgBB", + "BhASBEBBAiEGDAELIAQgBUGF4MIAQQYQEgRAQQQhBgwBCyAEIAVBi+DCAEEHEBIEQEEIIQYMAQsgBCAFQZLgwgBBBhASBEBBECEGDAELIAQgBUGY4MIAQQQQEgRAQSAhBgwBCyAEIAVBAUEAEBINACABIAU2AhQgASAENgIQIAFBAjYCHCABIAFBEGo2AhggAUEEakHHjcAAIAFBGGoQDCABKAIIIQYgASgCBCIEQX9GDQAgACABKAIMNgIIIAAgBjYCBCAAIAQ2AgAMAQsgAigCBCACKAIIIAMQ4QIgBjYChAEgAEF/NgIACyABQSBqJAAL9QYCDX8BfiMAQaABayIGJAACQAJAAkAgAy0A0AEiEARAQQEhBwwBCyAGQQRqIQcgBkGIAWoiCCACEL4FIAYgASAIIAMoAtwBELkEIAYoAgAiCUF+RwRAIAYgBikCEDcCgAEgBiAJNgJwIAYgBykCADcCdCAGIAcoAggiBzYCfAJ/IAcoAhBFBEBBACEJQQEMAQsgBkGIAWogASgCBCABKAIIIAcoAgwoAgAQrAIiB0EoaigCACAHQSxqKAIAEEJBAEEBEAEgBigCkAEhCiAGKAKIASEJIAYoAowBCyEHIAZB8ABqELsEDAELIABBfjYCACAAIAcoAgg2AgwgACAHKQIANwIEQQAhCUEBIQcMAQsgBkE0aiEIIAZBiAFqIgsgAhC9BSAGQTBqIAEgCyADKALYARC5BCAGKAIwIgtBfkYEQCAAQX42AgAgACAIKAIINgIMIAAgCCkCADcCBAwBCyAGIAYpAkA3AiggBiALNgIYIAYgCCkCADcCHCAGIAgoAggiCDYCJCAGQYgBaiAIKAIMIAgoAhAQiwMgBigCkAFBAnQhESAGKAKMASEIIAYoAogBIQsgBkHMAGohDiAGQfQAaiEPIAMoAtwBIRJBACEDA0ACQAJAAkACQCADIBFHBEAgAyAIaigCACENIBBFDQIgBkGIAWoiDCACIA0QyAUgBkHwAGogASAMIBIQ", + "uQQgBiAPKQIANwNgIAYgDygCCDYCaCAGKAJwIgxBfkcNASAAIAYoAmg2AgwgACAGKQNgNwIEDAMLIAggCxDmBCAAIAIpAhA3AhAgACACKQIINwIIIAAgAikCADcCACAGQRhqELsEIAkgBxABDAYLIAYpAoABIRMgDiAGKAJoNgIIIA4gBikDYDcCACAGIBM3AlggBiAMNgJIIAYoAlQiDCgCEARAIAZBiAFqIAEoAgQgASgCCCAMKAIMKAIAEKwCIgpBKGooAgAgCkEsaigCABBCIAkgBxABIAYoApABIQogBigCiAEhCSAGKAKMASEHCyAGQcgAahC7BAsgBkGIAWogBCABIA0gByAKIAURCAAgBigCiAEiDUF/Rg0BIAAgBikCjAE3AgggACANNgIECyAAQX42AgAgCCALEOYEIAZBGGoQuwQMAgsgA0EEaiEDDAALAAsgCSAHEAEgAhC7BAsgBkGgAWokAAscACAAQQRqQdTQwwBBNRAGIABBfjYCACACELsECw8AIAAgASACIANBKRCOCAtWACMAQRBrIgEkACABQQRqIAQgBRAGIAIoAgQgAigCCCADEOECIgIoAhggAkEcaigCABABIAIgASgCDDYCICACIAEpAgQ3AhggAEF/NgIAIAFBEGokAAvICAIQfwF+IwBBoAFrIgQkACAEQYgBaiIFIAIQvQUgBEEYaiABIAUgAygC2AEQuQQgBEEcaiEFAkACQCAEKAIYIgZBfkYEQCAAQX42AgAgACAFKAIINgIMIAAgBSkCADcCBAwBCyAEIAQpAig3AhAgBCAGNgIAIAQgBSkCADcCBCAEIAUoAgg2AgwgA0EYahDRBSEHQQEhBQJAAkAgAy0A0AEiD0EBRgRAIAMoAtwBIQtBACEGDAELIARBNGohBSAEQYgBaiIGIAIQvgUgBEEwaiABIAYgAygC3AEiCxC5BCAEKAIwIgNBfkcEQCAEIAQpAkA3AoABIAQgAzYCcCAEIAUpAgA3AnQgBCAFKAIIIgM2", + "AnwCfyADKAIQRQRAQQAhBkEBDAELIARBiAFqIAEoAgQgASgCCCADKAIMKAIAEKwCIgNBKGooAgAgA0EsaigCABBCQQBBARABIAQoApABIQggBCgCiAEhBiAEKAKMAQshBSAEQfAAahC7BAwBCyAAQX42AgAgACAFKAIINgIMIAAgBSkCADcCBEEAIQZBASEFDAELIAdB////B3EiA0GAAnEhECAEQYgBaiAEKAIMIgcoAgwgBygCEBCLAyAEKAKQAUECdCERIAQoAowBIQogBCgCiAEhDCAEQcwAaiENIARB9ABqIQ4gA0EBcSESIANBgIAESSETQQAhBwNAAkACQCAHIBFHBEAgByAKaigCACEDIA9FDQIgBEGIAWoiCSACIAMQyAUgBEHwAGogASAJIAsQuQQgBCAOKQIANwNgIAQgDigCCDYCaCAEKAJwIglBfkcNASAAIAQoAmg2AgwgACAEKQNgNwIEIABBfjYCACAKIAwQ5gQMBAsgCiAMEOYEIAAgAikCEDcCECAAIAIpAgg3AgggACACKQIANwIAIAYgBRABIAQQuwQMBQsgBCkCgAEhFCANIAQoAmg2AgggDSAEKQNgNwIAIAQgFDcCWCAEIAk2AkggBCgCVCIJKAIQBEAgBEGIAWogASgCBCABKAIIIAkoAgwoAgAQrAIiCEEoaigCACAIQSxqKAIAEEIgBiAFEAEgBCgCkAEhCCAEKAKIASEGIAQoAowBIQULIARByABqELsECyABKAIEIAEoAgggAxDhAiEDIBIEQCAEQYgBaiAFIAgQQiADKAJUIANB2ABqKAIAEAEgAyAEKAKQATYCXCADIAQpAogBNwJUCyAQBEAgBEGIAWogBSAIEEIgAygCSCADQcwAaigCABABIAMgBCgCkAE2AlAgAyAEKQKIATcCSCADKAJsIANB8ABqKAIAEAEgA0EANgJ0IANCgICAgBA3AmwLIBNFBEAgBEGIAWogBSAIEEIgAygCYCADQeQAaigCABABIAMgBCgC", + "kAE2AmggAyAEKQKIATcCYAsgB0EEaiEHDAALAAsgBiAFEAEgBBC7BAsgAhC7BAsgBEGgAWokAAsfACAALwEEIAAtAAZBEHRyQQAgACgCAEGGgICAeEYbCw8AIAAgASACIANBKhCOCAtWACMAQRBrIgEkACABQQRqIAQgBRAGIAIoAgQgAigCCCADEOECIgIoAjAgAkE0aigCABABIAIgASgCDDYCOCACIAEpAgQ3AjAgAEF/NgIAIAFBEGokAAsPACAAIAEgAiADQSsQjggLYwAjAEEQayIBJAAgBQRAIAIoAgQgAigCCCADEOECIgJBAzoAmgEgAUEEaiAEIAUQBiACKAIkIAJBKGooAgAQASACIAEoAgw2AiwgAiABKQIENwIkCyAAQX82AgAgAUEQaiQAC4YBAQJ/IwBBQGoiBCQAAkAgAygCGEGDgICAeEYEQCAEIAMoACM2AA8gBCADKQIcNwMIDAELIARBADYADyAEQgA3AwgLIAQgBCgADzYAHyAEIAQpAwg3AxggBEEoaiIFIAIQvgUgACABIAUgAyAEQRhqQfzMwwBBABC/BSACELsEIARBQGskAAsPACAAIAEgAiADQSwQxAULPwECfyMAQfABayIEJAAgBEHgAWoiBSABQRhqEMIHIARBCGoiAUESIAUQwAcgACABIAIgAxDHBiAEQfABaiQACxIAIAAgASACIANBpLvDABCPCAsSACAAIAEgAiADQby7wwAQjwgLRgEDfyMAQSBrIgQkACACKAIMKAIQIQUgBEEIaiIGIAIQvgUgACABIAYgA0EBQeyywwAgBUEARxC/BSACELsEIARBIGokAAsSACAAIAEgAiADQbDNwwAQjwgLUgECfyMAQSBrIgQkACAEQdzBwwA2AhQgBEEBOgAYIARB9MHDADYCDCAEIARBH2oiBTYCECAEIAU2AgggACABIAIgAyAEQQhqEN4FIARBIGokAAujAwIJfwF+IwBB4ABrIgUkAAJAIAEoAgQgASgCCCACKAIM", + "IgZBDGoiBygCACAGQRBqIggoAgAQswVFBEBBACEGIAVBADYCXCAFQoCAgIDAADcCVCAFQTxqIAcoAgAgCCgCABCLAyAFKAJEQQJ0IQ0gBSgCQCEHIAUoAjwhCCAFQQRqIQsgBUEoaiEMA0ACQCAGIA1HBEAgBUE8aiIJIAIgBiAHaigCABC0BSAFQSRqIAEgCSADIAQQpAcgBSAMKQIANwMYIAUgDCgCCDYCICAFKAIkIgpBfkcNASAAIAUoAiA2AgwgACAFKQMYNwIEIABBfjYCACAJELsEIAcgCBDmBCAFKAJUIAUoAlgQJgwECyAHIAgQ5gQgACACIAVB1ABqELYFDAMLIAUpAjQhDiALIAUoAiA2AgggCyAFKQMYNwIAIAUgDjcCECAFIAo2AgAgBUE8ahC7BCAFQdQAaiAFKAIMIgooAgwiCSAJIAooAhBBAnRqEJsEIAZBBGohBiAFELsEDAALAAsgACABIAIgAyAEEKQHCyACELsEIAVB4ABqJAALMgEBfyMAQRBrIgQkACAEQQA6AA8gACABIAIgAyAEQQ9qQey7wwBBARC/BSAEQRBqJAALQwECfyMAQSBrIgQkACAEQQRqIgUgAhC+BSAEQQE6AB8gACABIAUgAyAEQR9qQey7wwBBARC/BSACELsEIARBIGokAAtZAQN/IwBBEGsiBCQAIAMtABwhBSAEIAMtAB1BACADKAIYQYWAgIB4RiIGGzoADyAEIAVBACAGGzoADiAAIAEgAiADIARBDmpB1LzDAEEBEL8FIARBEGokAAsNACAAIAEgAkEAEOMFC9cEAg1/AX4jAEHwAGsiBCQAIARBADYCbCAEQoCAgIDAADcCZCAEQThqIAIoAgwiBigCDCAGKAIQEIsDIAQoAjwiCSAEKAJAQQJ0aiEOIAQoAjghCiAEQQxqIQsgBEEkaiEMIAkhBgJAA0ACQAJAIAYgDkcEQCAEQThqIgUgAiAGKAIAELQFIARBADsBVCAEQQA2AlAgBEEgaiABIAUg", + "BEHQAGoQ9gUgBCAMKQIANwNYIAQgDCgCCDYCYCAEKAIgIgVBfkcNASAAIAQoAmA2AgwgACAEKQNYNwIEIABBfjYCAAwCCyAJIAoQ5gQgACACIARB5ABqELYFDAMLIAQpAjAhESALIAQoAmA2AgggCyAEKQNYNwIAIAQgETcCGCAEIAU2AgggBEHYAGogBCgCFCIFKAIMIAUoAhAQiwMgBCgCXCEFAkAgBCgCYCIHRQ0AIAUoAgAhCCAEQQE2AiggBCAFIAdBAnRqNgIkIAQgBTYCIANAAkAgBEEgahCZBCIHBEAgBEE4aiABIAJBACADQQEgBygCACIPQQEgCBDMByAEKAJAIQcgBCgCPCENIAQoAjgiEEF/Rg0BIAAgBzYCDCAAIA02AgggACAQNgIEIABBfjYCACAEKAJYIAUQJiAEQQhqELsEDAQLIARB5ABqIAgQ4AIMAgsgDUEBRw0AIA8gCCABKAIEIAEoAgggBxCsAhC4AhshCAwACwALIAZBBGohBiAEKAJYIAUQJiAEQQhqELsEDAELCyAJIAoQ5gQgBCgCZCAEKAJoECYLIAIQuwQgBEHwAGokAAsNACAAIAEgAkEBEOMFC9gCAQZ/IwBBIGsiBCQAIARBADYCECAEQoCAgIDAADcCCAJAAkAgAigCDCIGKAIQIgcEQCAEQRRqIAYoAgwgBxCLAyAEKAIcQQJ0IQggBCgCGCEGIAQoAhQhBwNAAkAgBSAIRwRAIARBFGogASACQQEgBSAGaigCACADEOYFIAQoAhQiCUF/Rg0BIAAgBCkCGDcCCCAAIAk2AgQgAEF+NgIAIAYgBxDmBCAEKAIMIQUMBQsgBiAHEOYEDAMLIARBCGogBCgCGBDgAiAFQQRqIQUMAAsACyAEQRRqIAEgAkEAIAQgAxDmBSAEKAIYIQMgBCgCFCIFQX9HBEAgACAEKAIcNgIMIAAgAzYCCCAAIAU2AgQgAEF+NgIAQQQhBQwCCyAEQQhqIAMQ4AILIAAgAiABIAQoAgwi", + "BSAEKAIQEOcFELQFCyAEKAIIIAUQJiACELsEIARBIGokAAurBAEJfyMAQZABayIGJABBASEHAn8gA0EBRgRAIAEoAgQiByABKAIIIgggBBDeBCEJIAZBEGogByAIIAQQwwcgBkEcaiAGKAIQIAYoAhQQBiAHIAggBBDfBCEKIAYoAiAhByAGKAIcIQsgBigCJAwBCyAGQQA2AiQgBkKAgICAEDcCHEEACyEOIAZB2ABqIQggBkEIaiADQQRBBBAHIAZBADYCjAEgBiAGKQMINwKEASAGQYQBaiADEJcEIAYoAogBIAYoAowBIgxBAnRqIQ0DQCADQQFxBEAgDSAENgIAIA1BBGohDSAMQQFqIQxBACEDDAELCyAGIAw2AowBIAZBKGoiAyAHIA4QQiAGIAo2AjggBiAJNgI0IAZB7ABqIgQgAiAGQYQBahC2BSAGQdQAaiABIAQgBSADQbitwwBBABC/BQJAIAYoAlQiAkF+RgRAIAAgCCgCCDYCCCAAIAgpAgA3AgAgBigCKCAGKAIsEAEgCyAHEAEMAQsgBiAGKQJkNwJMIAYgAjYCPCAGIAgpAgA3AkAgBiAIKAIIIgI2AkggASACKAIMIAIoAhAQ5wUhAiABKAIEIAEoAgggAhDhAiIBIAo2AowBIAEgCTYCiAEgAUEgNgKEASABKAJ4IAFB/ABqIgMoAgAQASABIA42AoABIAMgBzYCACABIAs2AnggAEF/NgIAIAAgAjYCBCAGQTxqELsEIAYoAiggBigCLBABCyAGQZABaiQAC4kCAQJ/IwBBoAFrIgMkACADQRxqQbDewgBBBRAGIANBADoAngEgA0IBNwI4IANCADcCMCADQoCAgIAQNwIoIANCATcCaCADQgA3AmAgA0KAgICAEDcCWCADQgE3AlAgA0IANwJIIANCgICAgMAANwJAIANBADYCBCADQQA2AgwgA0EANgIUIANBADYCeCADQQA2AowBIANCgICAgBA3AnAgA0KAgICAEDcCfCADQgA3", + "AoQBIANCADcBlgEgA0IANwKQASAAIANBBGoQ3wIhBEEAQQEQASACQQJ0IQIDQCACBEAgACAEIAEoAgAQqwUgAkEEayECIAFBBGohAQwBCwsgA0GgAWokACAEC4YHAgl/AX4jAEGQAWsiBCQAIARB7ABqIAMtANEBIgggAygC2AEQsQUgBCgCcCEGAkACQCAEKAJsIgVBf0cEQCAAIAQoAnQ2AgwgACAGNgIIIAAgBTYCBCAAQX42AgAMAQsCQAJAAkACQAJAIAYtANEBQQ1HBEAgBEEEaiEFIARB7ABqIgcgAhC7BSAEIAEgByAGEN0EIAQoAgAiB0F+Rw0BIABBfjYCACAAIAUoAgg2AgwgACAFKQIANwIEDAYLIAEoAgQgASgCCCACKAIMIgVBDGoiBigCACAFQRBqIggoAgAQswUNAUEAIQUgBEEANgKMASAEQoCAgIDAADcChAEgBEHsAGogBigCACAIKAIAEIsDIAQoAnRBAnQhCyAEKAJwIQYgBCgCbCEIIARBNGohByAEQdgAaiEKA0AgBSALRg0DIARB7ABqIgkgAiAFIAZqKAIAELQFIARB1ABqIAEgCSADEOkFIAQgCikCADcDSCAEIAooAgg2AlAgBCgCVCIJQX5GBEAgACAEKAJQNgIMIAAgBCkDSDcCBCAAQX42AgAgBiAIEOYEIAQoAoQBIAQoAogBECYMBwUgBCkCZCENIAcgBCgCUDYCCCAHIAQpA0g3AgAgBCANNwJAIAQgCTYCMCAEQYQBaiAEKAI8IgkoAgwiDCAMIAkoAhBBAnRqEJsEIAVBBGohBSAEQTBqELsEDAELAAsACyAFKAIIIgYgBigCAEEBaiIKNgIAIAQgBCkCEDcCQCAEIAc2AjAgBCAFKQIANwI0IAQgBjYCPCAKRQ0CIARB7ABqIgcgAiAGEOoFIARByABqIAggAygC3AEQsgUgBCgCTCEFIAQoAkgiA0F/RwRAIAAgBCgCUDYCDCAAIAU2AgggACADNgIEIABBfjYC", + "ACAHELsEDAQLIARBHGohAyAEQRhqIAEgBEHsAGogBRDdBCAEKAIYIgVBfkYEQCAAQX42AgAgACADKAIINgIMIAAgAykCADcCBAwECyADKAIIIgEgASgCAEEBaiIGNgIAIAQgBCkCKDcCZCAEIAU2AlQgBCADKQIANwJYIAQgATYCYCAGRQ0CIAAgAiABEOoFIARB1ABqELsEIARBMGoQuwQMBAsgACABIAIgAxDpBQwECyAGIAgQ5gQgACACIARBhAFqELYFDAILAAsgBEEwahC7BAsgAhC7BAsgBEGQAWokAAuECAIPfwF+IwBBoAFrIgQkACAEQeQAaiADLQDRASIIIAMoAtgBELEFIAQoAmghBgJAAkAgBCgCZCIFQX9HBEAgACAEKAJsNgIMIAAgBjYCCCAAIAU2AgQgAEF+NgIADAELIARBIGohBSAEQeQAaiIHIAIQvgUgBEEcaiABIAcgBigC2AEQuQQgBCgCHCIHQX5GBEAgAEF+NgIAIAAgBSgCCDYCDCAAIAUpAgA3AgQMAQsgBCAEKQIsNwIUIAQgBzYCBCAEIAUpAgA3AgggBCAFKAIINgIQIARB5ABqIAZB0QFqLQAAIAZB3AFqKAIAELIFIAQoAmghBQJAIAQoAmQiB0F/RwRAIAAgBCgCbDYCDCAAIAU2AgggACAHNgIEIABBfjYCAAwBCyAFLQDRAUE+RgRAIARBNGogBUHIAWooAgAgBUHMAWooAgAQQkEAIQUgBigCGEGHgICAeEYEQCAGLQAcIQULIARB5ABqIAggAygC3AEQsgUgBCgCaCEIIAQoAmQiA0F/RwRAIAAgBCgCbDYCDCAAIAg2AgggACADNgIEIABBfjYCACAEKAI0IAQoAjgQAQwCC0EAIQMgBEEANgKcASAEQoCAgIDAADcClAEgBEHkAGogBCgCECILKAIMIAsoAhAQiwMgBCgCbEECdCEPIAQoAmghByAEKAJkIQwgBEHEAGohDSAEQegAaiEOIAIoAgwhCiAEKAI8", + "IRAgBCgCOCEGIAVBAXEhEQNAAkACQCADIA9HBEAgAyAHaigCACEFIBFFBEAgASAFEOwEIQULIAogCigCAEEBaiIJNgIAIAlFDQEgBEH8AGoiEiACIAoQ6gVBBEEEEOUCIgkgBTYCACAEQQE2AmwgBCAJNgJoIARBATYCZCAEKAKMASAGIBAgBEHkAGoiBRCWBiAFIAEgEiAIEN0EIAQgDikCADcDWCAEIA4oAgg2AmAgBCgCZCIFQX5HDQIgACAEKAJgNgIMIAAgBCkDWDcCBCAAQX42AgAgByAMEOYEIAQoApQBIAQoApgBECYgBCgCNCAGEAEgBEEEahC7BAwGCyAHIAwQ5gQgCygCEARAIAAgAiAEQZQBahC2BSAEKAI0IAYQASAEQQRqELsEDAYLIAAgASACIAgQ3QQgBCgClAEgBCgCmAEQJiAEKAI0IAYQASAEQQRqELsEDAYLAAsgBCkCdCETIA0gBCgCYDYCCCANIAQpA1g3AgAgBCATNwJQIAQgBTYCQCAEQZQBaiAEKAJMIgUoAgwiCSAJIAUoAhBBAnRqEJsEIANBBGohAyAEQUBrELsEDAALAAsgAEEEakGJ0cMAQTYQBiAAQX42AgALIARBBGoQuwQLIAIQuwQLIARBoAFqJAAL3QMCC38DfiMAQUBqIgMkACADQQhqIAEoAhBBCGpByOLCABDmASADKAIIIggpAxghDiAIKQMQIQ8gAygCDCEKAkACfyAIKAIEIgRFBEBBuNvCACEJQQAMAQsgA0EQakEQIARBAWoQgwEgAygCECEJIAgoAgAhBSADKAIUIgtBCWoiBgRAIAkgBSAG/AoAAAsgBSkDACEQIAMgCCgCDCIGNgIoIAMgBTYCICADIAQgBWpBAWo2AhwgAyAFQQhqNgIYIAMgEEJ/hUKAgYKEiJCgwIB/gzcDECAGIQQDQCAEBEAgA0EQahCCBCEHIAMgAygCKEEBayIENgIoIANBMGogB0EMaygCACAHQQhrKAIAEEIgB0EEaygC", + "ACIMIAwoAgBBAWoiDTYCACANRQ0DIAkgByAFa2pBEGsiByADKQIwNwIAIAMgDDYCPCAHQQhqIAMpAjg3AgAMAQsLIAgoAggLIQVBCEEwEOUCIgQgDjcDKCAEIA83AyAgBCAGNgIcIAQgBTYCGCAEIAs2AhQgBCAJNgIQIARBADYCCCAEQoGAgIAQNwMAIAEtABQhBiAAIAEQtwQgACAGOgAUIAAgBDYCECAAIAI2AgwgCiAKKAIAQQFrNgIAIANBQGskAA8LAAusAgEHfyMAQSBrIgMkACADQQA2AhwgA0KAgICAwAA3AhQgA0EIaiACKAIMIgQoAgwgBCgCEBCLAyADKAIQQQJ0IQggAygCDCEHIAMoAgghCQNAAkACQAJAAkAgBiAIRwRAQQAhBSABKAIEIAEoAgggBiAHaigCACIKEKwCIgQtAJoBQQFrDgMCAwQBCyAHIAkQ5gQgACACIANBFGoQtgUgAhC7BCADQSBqJAAPCyAEKAJEIQUMAgsgBCgCREEBdiEFDAELIARBHGooAgAgBEEgaigCAEGl4MIAQQYQEg0AIAQoAiwhBQsgA0EIaiAFEKwFIAEgCkECQZzfwgBBBSADKAIMIgQgAygCEBDsBSEFIAMoAgggBBABIANBFGogBRDgAiAGQQRqIQYMAAsAC+wBAQF/IwBBoAFrIgckACAHQRxqIAMgBBAGIAdBKGogBSAGEAYgByACOgCeASAHQQA2AjwgB0KAgICAEDcCNCAHQgE3AmggB0IANwJgIAdCgICAgBA3AlggB0IBNwJQIAdCADcCSCAHQoCAgIDAADcCQCAHQQA2AgQgB0EANgKMASAHQQA2AnggB0KAgICAEDcCcCAHQQA2AhQgB0EANgIMIAdCADcChAEgB0KAgICAEDcCfCAHQgA3AZYBIAdCADcCkAEgACAHQQRqEN8CIQJBAEEBEAFBAEEBEAEgACABIAIQqAcgB0GgAWokAAsNACAAIAEgAkEtEO8FCygAIABBnN/CAEEFEAYg", + "AEEMaiACKAIEIAIoAgggAxCsAigCkAEQrAUL1gEBCX8jAEEwayIEJAAgBEEANgIsIARCgICAgMAANwIkIARBDGogAigCDCIGKAIMIAYoAhAQiwMgBCgCFEECdCEIIAQoAhAhBiAEKAIMIQkDQCAFIAhGRQRAIARBDGpBASABIAUgBmooAgAiByADEQAAIAQoAgwgBCgCGCAEQSRqIAEgB0ECIAQoAhAiByAEKAIUIAQoAhwiDCAEKAIgEOwFEOACIAwQASAHEAEgBUEEaiEFDAELCyAGIAkQ5gQgACACIARBJGoQtgUgAhC7BCAEQTBqJAALDQAgACABIAJBLhDvBQsoACAAQZzfwgBBBRAGIABBDGogAigCBCACKAIIIAMQrAIoApQBEKwFC/EBAQR/IwBB0ANrIgQkACAEQfABaiIHQQRyIQYgBwJ/IAMoAhhBAE4EQCAEQQRqIAMoAhwgAygCIBBCIAQoAgwhBSAEKAIIDAELIARBADYCBEEBCyIDIAUQtQQCQCAEKALwASIFQX9GBEAgAEF+NgIAIAAgBigCCDYCDCAAIAYpAgA3AgQgBCgCBCADEAEgAhC7BAwBCyAEQSBqIARBgAJqQdAB/AoAACAEIAYoAgg2AhwgBCAGKQIANwIUIAQgBTYCECAAIAEgAiAEQRBqIgBBACAFQQJHGxC5BCAAEL0EIAQoAgQgAxABCyAEQdADaiQAC/wGAgx/AX4jAEHwAWsiBCQAAkAgAigCDCIFQRBqKAIABEAgBEEMaiADLQDRASADKALcARCyBSAEKAIQIQcgBCgCDCIDQX9HBEAgACAEKAIUNgIMIAAgBzYCCCAAIAM2AgQgAEF+NgIADAILIAEoAgQgASgCCCAFQQxqIgMoAgAgBUEQaiIFKAIAELMFRQRAIARBADYC7AEgBEKAgICAwAA3AuQBIARBDGogAygCACAFKAIAEIsDIAQoAhAiCCAEKAIUQQJ0aiENIAQoAgwhCSAEQawBaiEKIARB0AFqIQsgCCEF", + "A0ACQCAFIA1HBEAgASAFKAIAIgNBAEGw3sIAQQVBAUEAEOwFIQwgBEEMaiIGIAIgAxC0BSAEQcwBaiABIAYgBxDdBCAEIAspAgA3A8ABIAQgCygCCDYCyAEgBCgCzAEiA0F+Rw0BIAAgBCgCyAE2AgwgACAEKQPAATcCBCAAQX42AgAgCCAJEOYEIAQoAuQBIAQoAugBECYMBQsgCCAJEOYEIAAgAiAEQeQBahC2BQwECyAFQQRqIQUgBCkC3AEhECAKIAQoAsgBNgIIIAogBCkDwAE3AgAgBCAQNwK4ASAEIAM2AqgBIARBDGogBCgCtAEiAygCDCADKAIQEIsDIAQoAhRBAnQhDiAEKAIQIQYgBCgCDCEPQQAhAwNAIAMgDkZFBEAgASAMIAMgBmooAgAQqwUgA0EEaiEDDAELCyAGIA8Q5gQgBEHkAWogDBDgAiAEQagBahC7BAwACwALIARBDGogASACIAcQ9AUgBCgCECEBIAQoAgwiA0F/RwRAIAAgBCgCFDYCDCAAIAE2AgggACADNgIEIABBfjYCAAwCCyAAIAIgARC0BQwBCyAEQSRqQbDewgBBBRAGIARBMGpBhLzDAEECEAYgBEEAOgCmASAEQQA2AkQgBEKAgICAEDcCPCAEQgE3AnAgBEIANwJoIARCgICAgBA3AmAgBEIBNwJYIARCADcCUCAEQoCAgIDAADcCSCAEQQA2AgwgBEEANgKUASAEQQA2AoABIARCgICAgBA3AnggBEEANgIcIARBADYCFCAEQgA3AowBIARCgICAgBA3AoQBIARCADcBngEgBEIANwKYASABIARBDGoQ3wIhAUEAQQEQAUEAQQEQASAAIAIgARC0BQsgAhC7BCAEQfABaiQAC8oEAgx/AX4jAEHgAWsiBCQAIARBHGpBsN7CAEEFEAYgBEEAOgCeASAEQgE3AjggBEIANwIwIARCgICAgBA3AiggBEIBNwJoIARCADcCYCAEQoCAgIAQNwJYIARCATcCUCAEQgA3", + "AkggBEKAgICAwAA3AkAgBEEANgIEIARBADYCDCAEQQA2AhQgBEEANgJ4IARBADYCjAEgBEKAgICAEDcCcCAEQoCAgIAQNwJ8IARCADcChAEgBEIANwGWASAEQgA3ApABIAEgBEEEaiIGEN8CIQhBAEEBEAEgBiACKAIMIgYoAgwgBigCEBCLAyAEKAIIIgcgBCgCDEECdGohDSAEKAIEIQkgBEGkAWohCiAEQcwBaiELIAchBgNAAkACQCAGIA1HBEAgBEEEaiIFIAIgBigCABDIBSAEQcgBaiABIAUgAxDdBCAEIAspAgA3A7gBIAQgCygCCDYCwAEgBCgCyAEiBUF+Rw0CIAAgBCgCwAE2AgggACAEKQO4ATcCACAHIAkQ5gQMAQsgByAJEOYEIABBfzYCACAAIAg2AgQLIARB4AFqJAAPCyAGQQRqIQYgBCkC2AEhECAKIAQoAsABNgIIIAogBCkDuAE3AgAgBCAQNwKwASAEIAU2AqABIARBBGogBCgCrAEiBSgCDCAFKAIQEIsDIAQoAgxBAnQhDiAEKAIIIQwgBCgCBCEPQQAhBQNAIAUgDkZFBEAgASAIIAUgDGooAgAQqwUgBUEEaiEFDAELCyAMIA8Q5gQgBEGgAWoQuwQMAAsAC54GAg5/AX4jAEGABGsiBCQAIARBADYC/AMgBEKAgICAwAA3AvQDIARBOGogAy0A0QEgAygC3AEQsgUgBCgCPCEIAkACfyAEKAI4IgNBf0cEQCAAIAQoAkA2AgwgACAINgIIIAAgAzYCBCAAQX42AgBBBAwBCyAEQThqIAIoAgwiAygCDCADKAIQEIsDIAQoAkBBAnQhDyAEKAI8IQYgBCgCOCEJIARBDGohCiAEQTxqIQsgBEEkaiEMIARBnAJqIQ1BACEDA0ACQAJAIAMgD0cEQCAEQThqIgUgAiADIAZqKAIAIgcQtAUgBEEAOwEEIARBADYCACAEQZgCaiABIAUgBBD2BSAEIA0pAgA3AwggBCANKAIINgIQ", + "IAQoApgCIgVBfkcNASAAIAQoAhA2AgwgACAEKQMINwIEIABBfjYCAAwCCyAGIAkQ5gQgACACIARB9ANqELYFDAQLIAQpAqgCIRIgDCAEKAIQNgIIIAwgBCkDCDcCACAEIBI3AjAgBCAFNgIgAkAgBCgCLCgCEARAIARBOGogASAEQSBqIAgQ3QQgBCALKQIANwOYAiAEIAsoAgg2AqACIAQoAjgiBUF+RgRAIAAgBCgCoAI2AgwgACAEKQOYAjcCBCAAQX42AgAMAwsgBCkCSCESIAogBCgCoAI2AgggCiAEKQOYAjcCACAEIBI3AhggBCAFNgIIIARBmAJqIgVB5wAQzQQgBEE4aiIOIAVB2AH8CgAAIARCADcDkAIgBSABIARBCGoiECAOEPQFIAQoApwCIQUgBCgCmAIiEUF/RwRAIAAgBCgCoAI2AgwgACAFNgIIIAAgETYCBCAAQX42AgAgDhDXBCAQELsEDAMLIAEoAgQgASgCCCAHEKwCKAKEASEHIAEoAgQgASgCCCAFEOECIAc2AoQBIARB9ANqIAUQ4AIgBEE4ahDXBCAEQQhqELsEDAELIARB9ANqIAEgBxDsBBDgAiAEQSBqELsECyADQQRqIQMMAQsLIAYgCRDmBCAEKAL0AyEGIAQoAvgDCyEBIAYgARAmCyACELsEIARBgARqJAALEQAgACABIAJBBEEAIAMQgQcLogUCDn8BfiMAQYAEayIEJAAgBEEANgL8AyAEQoCAgIDAADcC9AMgBEE4aiACKAIMIgYoAgwgBigCEBCLAyAEKAJAQQJ0IQ8gBCgCPCEHIAQoAjghCSAEQSRqIQogBEE8aiELIARBDGohDCAEQZwCaiENQQAhBgNAAkACQAJAAkAgBiAPRwRAIARBOGoiBSACIAYgB2ooAgAiCBC0BSAEQQA7AQQgBEEANgIAIARBmAJqIAEgBSAEEPYFIAQgDSkCADcDICAEIA0oAgg2AiggBCgCmAIiBUF+Rw0BIAAgBCgCKDYCDCAA", + "IAQpAyA3AgQgAEF+NgIADAILIAcgCRDmBCAAIAIgBEH0A2oQtgUMAwsgBCkCqAIhEiAMIAQpAyA3AgAgDCAEKAIoNgIIIAQgBTYCCCAEIBI3AhggBEE4aiABIARBCGogAxD4BSAEIAspAgA3A5gCIAQgCygCCDYCoAIgBCgCOCIFQX5GBEAgACAEKAKgAjYCDCAAIAQpA5gCNwIEIABBfjYCAAwBCyAEKQJIIRIgCiAEKAKgAjYCCCAKIAQpA5gCNwIAIAQgEjcCMCAEIAU2AiAgBEGYAmoiBUHnABDNBCAEQThqIg4gBUHYAfwKAAAgBEIANwOQAiAFIAEgBEEgaiIQIA4Q9AUgBCgCnAIhBSAEKAKYAiIRQX9GDQEgACAEKAKgAjYCDCAAIAU2AgggACARNgIEIABBfjYCACAOENcEIBAQuwQLIAcgCRDmBCAEKAL0AyAEKAL4AxAmDAELIAEoAgQgASgCCCAIEKwCKAKEASEIIAEoAgQgASgCCCAFEOECIAg2AoQBIARB9ANqIAUQ4AIgBkEEaiEGIARBOGoQ1wQgBEEgahC7BAwBCwsgAhC7BCAEQYAEaiQAC/ADAgt/AX4jAEHgAGsiBCQAIARBADYCXCAEQoCAgIDAADcCVCAEQTxqIAMtANEBIAMoAtwBELIFIAQoAkAhCAJAAkAgBCgCPCIDQX9HBEAgACAEKAJENgIMIAAgCDYCCCAAIAM2AgQgAEF+NgIAQQQhAwwBCyAEQTxqIAIoAgwiAygCDCADKAIQEIsDIAQoAkAiByAEKAJEQQJ0aiEMIAQoAjwhCSAEQQRqIQogBEEoaiELIAchBgNAAkAgBiAMRwRAIARBPGoiAyACIAYoAgAiDRDIBSAEQSRqIAEgAyAIEN0EIAQgCykCADcDGCAEIAsoAgg2AiAgBCgCJCIDQX5HDQEgACAEKAIgNgIMIAAgBCkDGDcCBCAAQX42AgAgByAJEOYEIAQoAlghAyAEKAJUIQUMAwsgByAJEOYEIAAgAiAE", + "QdQAahC2BQwDCyAGQQRqIQYgBCkCNCEPIAogBCgCIDYCCCAKIAQpAxg3AgAgBCAPNwIQIAQgAzYCACAEKAIMIgUoAhBBAnQhAyAFKAIMIQUCQANAIANFDQEgA0EEayEDIAUoAgAhDiAFQQRqIQUgASgCBCABKAIIIA4QrAIQuAJFDQALIARB1ABqIA0Q4AILIAQQuwQMAAsACyAFIAMQJgsgAhC7BCAEQeAAaiQAC/wBAQJ/IwBBQGoiBCQAIARBHGoiBSACEL4FIARBBGogASAFIAMoAtwBELkEIARBCGohAwJAIAQoAgQiBUF+RgRAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEDAELIAQgBCkCFDcCLCAEIAU2AhwgBCADKQIANwIgIAQgAygCCCIDNgIoAkAgAygCEARAIARBNGogASgCBCABKAIIIAMoAgwoAgAQrAIiAUEoaigCACABQSxqKAIAEEIMAQsgBEE0akHsvMMAQQcQBgsgACAEKAI8NgIMIAAgBCkCNDcCBCAAQX42AgAgBEEcahC7BAsgAhC7BCAEQUBrJAALuAwCDn8CfiMAQZACayIEJAAgBEE4aiIGIAIQuwUgBEEgaiABIAYgAygC3AEQuQQgBEEkaiEDAkAgBCgCICIGQX5GBEAgAEF+NgIAIAAgAygCCDYCDCAAIAMpAgA3AgQMAQsgBCAEKQIwNwIYIAQgBjYCCCAEIAMpAgA3AgwgBCADKAIIIgM2AhQCfyADKAIQBEAgAygCDCgCAAwBCyAEQQI6ANIBIARBADYCcCAEQoCAgIAQNwJoIARCATcCYCAEQgA3AlggBEKAgICAEDcCUCAEQgE3ApwBIARCADcClAEgBEKAgICAEDcCjAEgBEIBNwKEASAEQgA3AnwgBEKAgICAwAA3AnQgBEEANgI4IARBADYCQCAEQQA2AkggBEEANgKsASAEQgA3ArwBIARCgICAgBA3AqQBIARBADYCuAEgBEKAgICAEDcCsAEgBEIANwLE", + "ASAEQgA3AcoBIAEgBEE4ahDfAgshDiAEQQA2AtwBIARCgICAgMAANwLUASAEQThqIAIoAgwiAygCDCADKAIQEIsDIAQoAjwiDCAEKAJAQQJ0aiEQIAQoAjghDyAEQfgBakEEciERIAwhBgNAAkACQAJAAkACQCAGIBBHBEAgASgCBCABKAIIIAYoAgAiBxCsAi0AmgEOAgEEAgsgDCAPEOYEIAAgAiAEQdQBahC2BSAEQQhqELsEDAYLQQAhAyAEQQA2AugBIARCgICAgMAANwLgASAEQThqIAEoAgQgASgCCCAOEKwCIgVBQGsoAgAgBUHEAGooAgAQiwMgBCgCQEECdCEKIAQoAjwhBSAEKAI4IQgDQAJAAkAgAyAKRwRAIARB7AFqIgkgASgCBCABKAIIIAMgBWooAgAQrAIiC0EoaigCACALQSxqKAIAEEIgBEE4aiAEKALwASAEKAL0ARD7BSAEKAI4BEAgBCgCQCEDIAQoAjwgBEEDNgKMAiAEIAk2AogCIBFBqInAACAEQYgCahAMIAMQASAEKAL8ASEDIAQpA4ACIRIgBCgC7AEgBCgC8AEQASAFIAgQ5gQgBCgC5AEhBQwCCyAEKQNAIhMgASgCBCABKAIIIAcQrAI1AkRaDQIgBEHgAWogASABKAIEIAEoAgggBxCsAiILQUBrKAIAIAtBxABqKAIAIBOnQciuwwAQISgCABDsBBDgAgwCCyAFIAgQ5gQgASABIAcQ/AUiAyAEKALkASIFIAQoAugBEOgEIAOtIBJCgICAgHCDhCESQX8hAwsgBCgC4AEgBRAmIANBf0cEQCAAIBI3AgggACADNgIEDAQLIBKnIQUMBQsgBCgC7AEgBCgC8AEQASADQQRqIQMMAAsACyABKAIEIAEoAgggBxCsAiEDIARB+AFqIgYgASAHEP0FIARBAzYCRCAEQQM2AjwgBCADQRhqNgI4IAQgBjYCQCAAQQRqQf3OwAAgBEE4ahAMIAQoAvgBIAQoAvwBEAELIABB", + "fjYCACAMIA8Q5gQgBCgC1AEgBCgC2AEQJiAEQQhqELsEDAMLQQAhAyAEQQA2AoACIARCgICAgMAANwL4ASAEQThqIAEoAgQgASgCCCAOEKwCIgVBQGsoAgAgBUHEAGooAgAQiwMgBCgCQEECdCEKIAQoAjwhBSAEKAI4IQsDQCADIApHBEAgBCABIAcgAyAFaigCABD+BSAEKAIAQQFGBEAgBCgCBCEIIAEoAgQgASgCCCAHEKwCIglBQGsoAgAgCUHEAGooAgAgCEG4scMAECEoAgAhCSABKAIEIAEoAgggBxCsAiINQUBrKAIAIA1BxABqKAIAIAhBAWpByLHDABAhKAIAIQggASAJEOwEIQkgASAIEOwEIQggBEH4AWoiDSAJEOACIA0gCBDgAgsgA0EEaiEDDAELCyAFIAsQ5gQgASABIAcQ/AUiBSAEKAL8ASIDIAQoAoACEOgEIAQoAvgBIAMQJgsgBkEEaiEGIARBOGogASgCBCABKAIIIAcQrAIiA0HwAGooAgAgA0H0AGooAgAQQiABKAIEIAEoAgggBRDhAiIDKAJsIANB8ABqKAIAEAEgAyAEKAJANgJ0IAMgBCkCODcCbCAEQdQBaiAFEOACDAALAAsgAhC7BCAEQZACaiQAC1UCAX8BfiMAQRBrIgMkACADIAEgAhCyAiAAAn8gAygCAEUEQCADKQMIIQQgACADKAIENgIEQQEMAQsgAykDCCEEQQALNgIAIAAgBDcDCCADQRBqJAALCwAgACABQQAQqgUL5AIBBX8jAEEwayIDJAAgA0EANgIIIANCgICAgBA3AgAgA0EMaiABIAIQvwYgAygCFEEEdCEBIAMoAhBBCGohAgNAAkACQCABBEAgAkEIaygCAEUNASADIAJBBGs2AhggAkEEaiIHKAIAIQQgAigCACEFIAZFBEAgAyAFIAQQCgwDCyAFIARBLhC9AkUEQCADQS4Q1wIgAyACKAIAIAcoAgAQCgwDCyADQS82AiwgAyADQRhqNgIo", + "IANBHGpB1cvAACADQShqEAwgAygCHCADIAMoAiAiBSADKAIkEAogBRABDAILIANBDGoQxAYgACADKAIINgIIIAAgAykCADcCACADQTBqJAAPCyADIAI2AhggA0EcNgIsIAMgA0EYajYCKCADQRxqQdXLwAAgA0EoahAMIAMoAhwgAyADKAIgIgUgAygCJBAKIAUQAQsgBkEBayEGIAFBEGshASACQRBqIQIMAAsAC5wBAQR/IwBBEGsiBCQAIARBBGogASgCBCABKAIIIAIQrAIiAkFAaygCACACQcQAaigCABCLAyAEKAIIIQYgBCgCDCEHQQAhAgNAAkAgAiAHSQRAIAEgBiAHIAJBkJrDABAhKAIAIAMQswdFDQFBASEFCyAEKAIEIAYQJiAAIAI2AgQgACAFNgIAIARBEGokAA8LIAJBAmohAgwACwAL8QkBDH8jAEGAAmsiBCQAIARBzABqIgYgAhC7BSAEQRxqIAEgBiADKALcARC5BCAEQSBqIQMCQAJAIAQoAhwiBkF+RgRAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEDAELIAQgBCkCLDcCFCAEIAY2AgQgBCADKQIANwIIIAQgAygCCCIDNgIQAn8gAygCEARAIAMoAgwoAgAMAQsgBEECOgDmASAEQQA2AoQBIARCgICAgBA3AnwgBEIBNwJ0IARCADcCbCAEQoCAgIAQNwJkIARCATcCsAEgBEIANwKoASAEQoCAgIAQNwKgASAEQgE3ApgBIARCADcCkAEgBEKAgICAwAA3AogBIARBADYCTCAEQQA2AlQgBEEANgJcIARBADYCwAEgBEIANwLQASAEQoCAgIAQNwK4ASAEQQA2AswBIARCgICAgBA3AsQBIARCADcC2AEgBEIANwHeASABIARBzABqEN8CCyELAkAgASgCBCABKAIIIAsQrAIoAkQEQCAEQQA2AvwBIARCgICAgMAANwL0ASAEQcwAaiACKAIMIgMoAgwgAygCEBCLAyAE", + "KAJQIgwgBCgCVEECdGohDyAEKAJMIQ4gDCEGA0ACQAJAAkACQCAGIA9HBEAgASgCBCABKAIIIAYoAgAiCBCsAi0AmgEOAgIDAQsgDCAOEOYEIAAgAiAEQfQBahC2BSAEQQRqELsEDAcLIAAgAikCEDcCECAAIAIpAgg3AgggACACKQIANwIAIAwgDhDmBCAEKAL0ASAEKAL4ARAmDAULIARBNGogASgCBCABKAIIIAgQrAIiA0FAaygCACADQcQAaigCABCLA0EAIQMgBEEANgJIIARCgICAgMAANwJAIAQoAjxBAnQhCSAEKAI4IQdBACEFA0AgAyAJRwRAIARB6AFqIAUQrAUgBEHMAGoiCkGc38IAQQUgBCgC7AEiDSAEKALwARDeAiABIAoQ3wIhCiAEKALoASANEAEgASALIAoQgAZFBEAgBEFAayABIAMgB2ooAgAQ7AQQ4AILIAVBAWohBSADQQRqIQMMAQsLIAEgASAIEPwFIgUgBCgCRCIDIAQoAkgQ6AQgBCgCQCADECYgBCgCNCAHECYMAQsgBEHoAWogASgCBCABKAIIIAgQrAIiA0FAaygCACADQcQAaigCABCLA0EAIQMgBEEANgJUIARCgICAgMAANwJMIAQoAuwBIQcgBCgC8AEhBQNAIAUgA0EBaiIJTQRAIAEgASAIEPwFIgUgBCgCUCIDIAQoAlQQ6AQgBCgCTCADECYgBCgC6AEgBxAmDAILIAEgCyAHIAUgA0GYrsMAECEoAgAQgAZFBEAgASAHIAUgA0GorsMAECEoAgAQ7AQhDSABIAcgBSAJQbiuwwAQISgCABDsBCEJIARBzABqIgogDRDgAiAKIAkQ4AILIANBAmohAwwACwALIAZBBGohBiAEQcwAaiABKAIEIAEoAgggCBCsAiIDQfAAaigCACADQfQAaigCABBCIAEoAgQgASgCCCAFEOECIgMoAmwgA0HwAGooAgAQASADIAQoAlQ2AnQgAyAEKQJMNwJsIARB9AFqIAUQ", + "4AIMAAsACyAAIAIpAhA3AhAgACACKQIINwIIIAAgAikCADcCAAsgBEEEahC7BAwBCyACELsECyAEQYACaiQAC4sBAQR/IwBBEGsiAyQAIANBBGogACgCBCAAKAIIIAEQrAIiAUFAaygCACABQcQAaigCABCLAyADKAIMQQJ0IQYgAygCCCEFQQAhAQNAAkAgASAGRwRAIAAgASAFaigCACACELMHRQ0BQQEhBAsgAygCBCAFECYgA0EQaiQAIAQPCyABQQRqIQEMAAsAC+0HAgx/An4jAEHQBGsiBCQAIARByABqIgYgAhC+BSAEQSRqIAEgBiADKALcARC5BCAEQShqIQUCQCAEKAIkIgNBfkYEQCAAQX42AgAgACAFKAIINgIMIAAgBSkCADcCBAwBCyAEIAQpAjQ3AhwgBCADNgIMIAQgBSkCADcCECAEIAUoAggiBTYCGEEAIQMgBEEANgJEIARCgICAgIABNwI8IARByABqIgYgBSgCDCAFKAIQEIsDIAQoAlAiCEECdCEMIAQoAkwhByAEKAJIIQ1BECEJIARB2ABqIQ4gBkEEciEPQQghBgJAA0ACQAJAIAMgDEcEQCAEQawEaiABKAIEIAEoAgggAyAHaigCABCsAiIFQShqKAIAIAVBLGooAgAQQiAEQcgAaiAEKAKwBCILIAQoArQEELUEIAQgDykCADcD+AMgBCAPKAIINgKABCAEKAJIIgVBf0cNASAAIAQoAoAENgIMIAAgBCkD+AM3AgQgAEF+NgIAIAQoAqwEIAsQASAHIA0Q5gQMBAsgByANEOYEIARBADYCzAQgBEKAgICAwAA3AsQEIARByABqIAIoAgwiAygCDCADKAIQEIsDIAhB4AFsIQsgBCgCTCIOIAQoAlBBAnRqIQ8gBCgCSCEKIARBjARqIQ0gBEGwBGohByAEKAJAIQUgDiEGA0AgBiAPRg0CIAZBBGohBiALIQkgBSEDA0AgCUUNASAEQcgAaiIIIAIQuwUgBEGsBGogASAI", + "IANBACADKAIAQQJHGxC5BCAEKAKsBCIIQX5GBEAgBCAHKAIIIgE2AqgEIAQgBykCACIQNwOgBCAAIAE2AgwgACAQNwIEIABBfjYCACAOIAoQ5gQgBCgCxAQgBCgCyAQQJgwGBSAEIAcoAggiDDYCqAQgBCAHKQIAIhE3A6AEIAQpArwEIRAgDSAMNgIIIA0gETcCACAEIBA3ApgEIAQgCDYCiAQgBEHEBGogBCgClAQiCCgCDCIMIAwgCCgCEEECdGoQmwQgCUHgAWshCSADQeABaiEDIARBiARqELsEDAELAAsACwALIARBqAJqIA5B0AH8CgAAIAQoAjwgCkYEQCAEQTxqENgEIAQoAkAhBgsgBiAJaiILQRBrIAU2AgAgC0EMayIFIAQpA/gDNwIAIAUgBCgCgAQ2AgggCyAEQagCakHQAfwKAAAgBCAKQQFqIgo2AkQgBCgCrAQgBCgCsAQQASADQQRqIQMgCUHgAWohCQwBCwsgDiAKEOYEIAAgAiAEQcQEahC2BSAEQTxqEIIGIARBDGoQuwQMAQsgBEE8ahCCBiAEQQxqELsECyACELsEIARB0ARqJAALQAEDfyAAKAIIIQEgACgCBCIDIQIDQCABBEAgAUEBayEBIAIQvQQgAkHgAWohAgwBCwsgACgCACADQQhB4AEQMAu5BAILfwF+IwBBkARrIgQkACAEQfABaiACKAIMIgYoAgwgBigCEBCLAyADQdwBaiEMIAQoAvgBQQJ0IQ0gBCgC9AEhByAEKALwASEIIARB1ANqIQkgBEH8A2ohAyAEQQRqIQpBACEGA0ACQAJAAkACQCAGIA1HBEAgBEHwAWoiBSACIAYgB2ooAgAQtAUgBEEAOwHsAyAEQQA2AugDIARB+ANqIAEgBSAEQegDahD2BSAEIAMpAgA3A9ADIAQgAygCCDYC2AMgBCgC+AMiBUF+Rw0BIAAgBCgC2AM2AgwgACAEKQPQAzcCBCAAQX42AgAMAgsgByAIEOYEIAAgAikCEDcC", + "ECAAIAIpAgg3AgggACACKQIANwIADAMLIAQpAogEIQ8gCiAEKQPQAzcCACAKIAQoAtgDNgIIIAQgBTYCACAEIA83AhAgBEEYaiIOQQgQzQQgBEEBOgDoASAMEIQGIQUgBEHwAWoiCyAOQdgB/AoAACAEIAU2AswDIARBADYCyAMgBEH4A2ogASAEIAsQvAUgBCADKQIANwPoAyAEIAMoAgg2AvADIAQoAvgDIgVBfkcNASAAIAQoAvADNgIMIAAgBCkD6AM3AgQgAEF+NgIAIAsQ1wQLIAcgCBDmBCACELsEDAELIAQpAogEIQ8gCSAEKALwAzYCCCAJIAQpA+gDNwIAIAQgDzcC4AMgBCAFNgLQAyAGQQRqIQYgBEHQA2oQuwQgBEHwAWoQ1wQMAQsLIARBkARqJAALTwECfyMAQeABayIBJAACQAJAIAAoAgAiAkUEQEEAIQAMAQtB4AEQGyIARQ0BIAEgAhDFBiAAIAFB4AH8CgAACyABQeABaiQAIAAPCxAdAAuoBwISfwJ+IwBBwAJrIgQkACAEIAIQhgYgBEEIaiAEKAIAIAQoAgQQBiAEQfAAakHtucMAQQYgASACIAMoAtwBEIcGIAQoAnwhDSAEKAJ4IQkgBCgCdCEOAkAgBCgCcEEBRgRAIAAgDTYCDCAAIAk2AgggACAONgIEIABBfjYCACAEKAIMIQoMAQtBACEDIARBADYClAIgBEKAgICAwAA3AowCIARB8ABqIAIoAgwiBigCDCAGKAIQEIsDIAQoAnhBAnQhFCAEKAJ0IQsgBCgCcCEPIARBMGohECAEQSBqQQRyIREgBEHgAGohEiAEQdAAakEEciEGIAQoAgwhCgNAAkACQAJAAkAgAyAURwRAIARBFGogASgCBCABKAIIIAMgC2ooAgAiBxCsAiIFQShqKAIAIAVBLGooAgAQQiAEQfAAaiAKIAQoAhAgBCgCGCITIAQoAhwQrwIgBCgCcEF/Rw0BIAQgBCgCfDYCoAIgBCAEKQJ0NwOY", + "AiAEQaQCaiIDIAEgBxD9BSAEQQM2ArwCIARBAzYCtAIgBCAEQZgCajYCuAIgBCADNgKwAiAGQcSVwAAgBEGwAmoQDCAEKAKkAiAEKAKoAhABIAQoApgCIAQoApwCEAEMAgsgCyAPEOYEIAAgAiAEQYwCahC2BQwDCyAEIAQpA4gBNwNoIAQgBCkDgAE3A2AgBCAEKQN4NwNYIAQgBCkDcCIWNwNQIBanIgVBf0cNAQsgBCAGKAIIIgE2AkggBCAGKQIAIhY3A0AgACABNgIMIAAgFjcCBCAAQX42AgAgBCgCFCATEAEgCyAPEOYEIAQoAowCIAQoApACECYMAQsgECASKQMANwMAIBAgEikDCDcDCCAEIAYoAggiCDYCSCAEIAYpAgAiFjcDQCARIAg2AgggESAWNwIAIAQgBTYCICAEQbACaiAEQSBqIAkgDRCIBiAEQdAAaiABIAQoArQCIgggBCgCuAIiBRC6AgJ/IAQoAlAiFUF/RwRAIARB8ABqIgxB49/CAEEFIAggBRDeAiABIAwQ3wIhBSAEKAJUDAELIAQoAlQiBQshDCAVIAwQBSABKAIEIAEoAgggBxCsAiIHKQIIIRYgBykCECEXIAEoAgQgASgCCCAFEOECIgcgFzcCECAHIBY3AgggBEGMAmogBRDgAiAEKAKwAiAIEAEgBCgCFCATEAEgA0EEaiEDDAELCyAOIAkQAQsgBCgCCCAKEAEgAhC7BCAEQcACaiQACz8BA39BrOLCACECQRkhAwJAIAEoAgBBf0YNACABKAIIIgRFDQAgASgCBCECIAQhAwsgACADNgIEIAAgAjYCAAuAAgEBfyMAQUBqIgYkACAGIAI2AgQgBiABNgIAIAZBIGoiASAEEL4FIAZBCGogAyABIAUQuQQgBkEMaiEBAkAgBigCCCICQX5GBEAgAEEBNgIAIAAgASgCCDYCDCAAIAEpAgA3AgQMAQsgBiAGKQIYNwIwIAYgAjYCICAGIAEpAgA3AiQgBiABKAIIIgE2", + "AiwgAAJ/IAEoAhAEQCAAQQRqIAMoAgQgAygCCCABKAIMKAIAEKwCIgFBKGooAgAgAUEsaigCABBCQQAMAQsgBkECNgI8IAYgBjYCOCAAQQRqQePCwAAgBkE4ahAMQQELNgIAIAZBIGoQuwQLIAZBQGskAAuEEwISfwJ+IwBBkAFrIgQkACAEQRhqIAEQjAYgBEKAgICAEDcCZCAEQQA2AmwgBEH8AGogAiADEMwCIAQoAoQBQQN0IQMgBCgCfCEOIAEoAhwiAiABKAIAIg9yQQBHIQcgBEEgaiEQIARBKGohDCAEQdAAaiERIARBOGohEiAEQUBrIRMgBEEwaiEUIARB2ABqIQ0gASgCBCEIIAEpAwghFyAEKAKAASIVIQEDQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAMEQCABKAIEIQUgASgCAEEBaw4eAgMEBRgZBgcICRobCgsMDQ4PEBESEx8gIRQVFhciAQsgDiAVEJ8BIAAgBCgCbDYCCCAAIAQpAmQ3AgAgBEGQAWokAA8LIARB5ABqIAUQ1wIMKQsgBEEhNgKMASAEIARBGGo2AogBIARB/ABqQcDLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMKAsgBCAEKQMYQuQAgSIWQj+HQuQAgyAWfDcDcCAEQSE2AowBIAQgBEHwAGo2AogBIARB/ABqQcjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMJwsgBEEhNgKMASAEIBA2AogBIARB/ABqQcjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMJgsgBEH8AGogBCkDIBDwBCAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMJQsg", + "BEEhNgKMASAEIAw2AogBIARB/ABqQcjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMJAsgBEH8AGogBCkDKBDwBCAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMIwsgBEEhNgKMASAEIAw2AogBIARB/ABqQfDLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMIgsgBEEhNgKMASAEIBE2AogBIARB/ABqQfjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMIQsgBEEhNgKMASAEIBQ2AogBIARB/ABqQcjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMIAsgBEIMIAQpAzBCDIEiFiAWUBs3A3AgBEEhNgKMASAEIARB8ABqNgKIASAEQfwAakHIy8MAIARBiAFqEAwgBCgCfCAEQeQAaiAEKAKAASIGIAQoAoQBEAogBhABDB8LIARB/ABqQgwgBCkDMEIMgSIWIBZQGxDwBCAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMHgsgBEEhNgKMASAEIBI2AogBIARB/ABqQcjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMHQsgBEH8AGogBCkDOBDwBCAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMHAsgBEEhNgKMASAEIBM2AogBIARB/ABqQcjLwwAgBEGIAWoQDCAEKAJ8IARB5ABqIAQoAoABIgYgBCgChAEQCiAGEAEMGwsgBEH8AGogBCkDQBDwBCAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMGgsgBEHkAGpBs+HCAEGMy8MAIAQpAzBCC1UbQQIQCgwZCyAEQeQAakG14cIAQaDMwwAgBCkDMEILVRtB", + "AhAKDBgLIA9BAWsOAgkKCAsgBEH8AGogAkEBQQBBABDJByAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMFgsgBEH8AGogAkEAQQBBABDJByAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMFQsgBEH8AGogAkEAQQFBABDJByAEQeQAaiAEKAKAASIFIAQoAoQBEAogBCgCfCAFEAEMFAsgBEEENgKMASAEIA02AogBIARB/ABqQbTMwwAgBEGIAWoQDCAEKAJ8IAQoAoABIQYgBCgChAEhCiAEQeQAaiILQS4Q1wIgBEEQakEJIAUgBUEJTxsgBiAKQbzMwwAQ5AIgCyAEKAIQIAQoAhQQCiAGEAEMEwsgBCgCIEEBayIFQQxJDREgBUEMQdDLwwAQKgALIAQoAiBBAWsiBUEMSQ0PIAVBDEHgy8MAECoACyAEKAJIIgVBB0kNDSAFQQdBgMzDABAqAAsgBCgCSCIFQQdJDQsgBUEHQZDMwwAQKgALIARB5ABqQeu3wwBBAxAKDA4LIARB/ABqIAJBAEEAQQEQyQcgBEHkAGogBCgCgAEiBSAEKAKEARAKIAQoAnwgBRABDA0LIAQgFzcDiAEgCEEJTw0EIARB/ABqIARBiAFqIAgQUiAEQeQAakEBIAQoAoABIAQoAnwiBRtBACAEKAKEASAFGxAKDAwLIAcNBiAEQeQAakHaABDXAgwLCyAHDQQgBEHkAGpB2gAQ1wIMCgsgBw0CIARB5ABqQdoAENcCDAkLIARBBDYCjAEgBCANNgKIASAEQfwAakG0zMMAIARBiAFqEAwgBCgCfCAEQQhqQQkgBSAFQQlPGyAEKAKAASIFIAQoAoQBQczMwwAQ5AIgBCAEKAIIIAQoAgxBMBChAiAEKAIEIgkEQCAEKAIAIQogBEHkAGoiC0EuENcCIAsgCiAJEAoLIAUQAQwIC0EAIAhBCEGkzMMAECkACyAEQfwAaiACQQBBAUEAEMkHIARB5ABqIAQo", + "AoABIgUgBCgChAEQCiAEKAJ8IAUQAQwGCyAEQfwAaiACQQBBAEEAEMkHIARB5ABqIAQoAoABIgUgBCgChAEQCiAEKAJ8IAUQAQwFCyAEQfwAaiACQQFBAEEAEMkHIARB5ABqIAQoAoABIgUgBCgChAEQCiAEKAJ8IAUQAQwECyAEQeQAaiAFQQN0IgUoAtTKQyAFKALYykMQCgwDCyAEQeQAaiAFQQN0KALwyUNBAxAKDAILIARB5ABqIAVBA3QiBSgC/MhDIAUoAoDJQxAKDAELIARB5ABqIAVBA3QoAtzHQ0EDEAoLIAFBCGohASADQQhrIQMMAAsAC6ADAgV/AX4jAEFAaiIEJAAgBEEQaiADLQDRASADKALcARCyBSAEKAIUIQMCQAJAAkAgAAJ/IAQoAhAiBUF/RwRAIAQoAhgMAQsgAy0A0QFBBWtB/wFxQQJPBEAgAEEEakH2uMMAQfEAEAYMAwsgBEEQakHnucMAQQYgASACIAMoAtgBEIcGIARBFGohBSAEKAIQQQFHDQEgBCAFKAIINgIwIAQgBSkCADcDKCAEQQM2AjwgBCAEQShqNgI4IARBBGpBoJPAACAEQThqEAwgBCgCKCAEKAIsEAEgBCgCBCEFIAQoAgghAyAEKAIMCzYCDCAAIAM2AgggACAFNgIEDAELIAQgBSkCACIJNwIEIAUoAgghBiAEKAIIIQUgBCACKQIINwMAIAQgAikCEDcDCCACKAIEIQcgAigCACAEQRBqIgggBSAGEAYgBxAFIAQgBCgCGDYCACAEIAQpAhA3AhAgBCAEKQMANwIYIAQgBCkDCDcCICAAIAEgCCADKALcARC5BCAJpyAFEAEMAQsgAEF+NgIAIAIQuwQLIARBQGskAAuTBAIDfwF+IwBB4AFrIgMkAAJAAkACQCABKAIkQX9HBEAgASgCKCEEIAEoAiwhBQwBCyADQdQBakGr4MIAQTUQBiADKALcASEFIAMoAtgBIQQgAygC1AEiBkF/Rg0AIAMgBTYC", + "RCADIAQ2AkAgAyAGNgI8DAELIANBOGoiBkHzucMAQSMgBCAFEK8CIAMoAjgiBEF/Rg0AIAMgAygCRCIFNgIwIAMgAykCPCIHNwMoIAMgAykDSDcDGCADIAMpA1A3AyAgAyAHNwIMIAMgBTYCFCADIAQ2AgggA0HUAWogA0EIakGs4sIAQRkQiAYgA0HQAGpB+K7DAEELEAYgA0ECOgDSASADQQA2AnAgA0KAgICAEDcCaCADQgE3ApwBIANCADcClAEgA0KAgICAEDcCjAEgA0IBNwKEASADQgA3AnwgA0KAgICAwAA3AnQgA0EANgI4IANBADYCQCADQQA2AkggA0EANgKsASADQgA3ArwBIANCgICAgBA3AqQBIAMgAykC1AE3AlwgAyADKALcATYCZCADQQA2ArgBIANCgICAgBA3ArABIANCADcCxAEgA0IANwHKASABIAYQ3wIhAUEAQQEQAUEAQQEQASAAIAIgARC0BQwBCyADIAMoAkQiATYCMCADIAMpAjwiBzcDKCAAIAE2AgwgACAHNwIEIABBfjYCAAsgAhC7BCADQeABaiQAC5UKAhJ/An4jAEHQAWsiBCQAIAQgAhCGBiAEQQxqIAQoAgAgBCgCBBAGIARBiAFqQeO3wwBBCCABIAIgAygC3AEQhwYgBCgClAEhByAEKAKQASEGIAQoAowBIQ0CQCAEKAKIAUEBRgRAIAAgBzYCDCAAIAY2AgggACANNgIEIABBfjYCAAwBC0EAIQMgBEEANgIsIARCgICAgMAANwIkIARBiAFqIgUgAigCDCIIKAIMIAgoAhAQiwMgBCgCkAFBAnQhEiAEKAKMASEKIAQoAogBIQ4gBUEEciEPIARB2ABqIQggBEHoAGpBBHIhCwNAAkACfwJAAkACQAJAAkACQCADIBJHBEAgBEEYaiABKAIEIAEoAgggAyAKaigCACIMEKwCIgVBKGooAgAgBUEsaigCABBCIARBiAFqIAQoAhAiEyAEKAIUIhQgBCgCHCIQ", + "IAQoAiAQrwIgBCgCiAFBf0cNASAEIAQoApQBNgI4IAQgBCkCjAE3AzAgBEFAayIDIAEgDBD9BSAEQQM2AmQgBEEDNgJcIARBAzYCVCAEIARBMGo2AmAgBCAEQQxqNgJYIAQgAzYCUCALQeuUwAAgBEHQAGoQDCAEKAJAIAQoAkQQASAEKAIwIAQoAjQQAQwCCyAKIA4Q5gQgACACIARBJGoQtgUMBwsgBCAEKQOgATcDgAEgBCAEKQOYATcDeCAEIAQpA5ABNwNwIAQgBCkDiAEiFjcDaCAWp0F/Rw0BCyAAIAsoAgg2AgwgACALKQIANwIEDAELIAQoAoABIREgBCkDeCEWQQAhBUEAIAYgB0Hrt8MAQQMQEg0DGkEAIAYgB0EBQQAQEg0DGkEAIAYgB0Hut8MAQQUQEg0DGiAGIAdB87fDAEEPEBINASAGIAdBgrjDAEEQEBINAiAGIAdBkrjDAEETEBINAiAGIAdBpbjDAEESEBINAiAGIAdBt7jDAEEQEBINAiAEIAc2AmwgBCAGNgJoIARBAjYCjAEgBCAEQegAajYCiAEgCEHHuMMAIARBiAFqEAwgBCAIKAIIIgE2AkggBCAIKQIAIhY3A0AgACABNgIMIAAgFjcCBAsgAEF+NgIAIAQoAhggEBABIAogDhDmBCAEKAIkIAQoAigQJgwDCyAEQsGuzaIFNwJcIARCgoCAgMAANwJUQYDhASEFQQIMAQsgBELBis2iBTcDcCAEQaCZAjYChAEgBCARNgKAASAEQoKAgIDAADcDaCAEIBY3A3ggBEGIAWogBEHoAGoQjAYCfwJAIBYgBCkDiAEiF0IKEI0GQoCjBX5CgOEBfVkNACAWIBdCBBCNBkKAowV+QoDhAX1TDQBCwYrNogUhF0GgmQIMAQtCwYqRogUhF0GwtQILIQUgBCAXNwJcIARCgoCAgMAANwJUQQILIQkgBCAIKAIIIhU2AkggBCAIKQIAIhc3A0AgDyAVNgIIIA8gFzcCACAEIAU2AqQB", + "IAQgETYCoAEgBCAWNwOYASAEIAk2AogBIARB0ABqIAEoAgQgASgCCCAMEKwCIgVBHGooAgAgBUEgaigCABBCIAQoAlghCSAEKAJUIQUgBEHoAGogBEGIAWogEyAUEIgGIARBJGogASAMQQIgBSAJIAQoAmwiCSAEKAJwEOwFEOACIAQoAmggCRABIAQoAlAgBRABIAQoAhggEBABIANBBGohAwwBCwsgDSAGEAELIAQoAgwgBCgCEBABIAIQuwQgBEHQAWokAAvdAQIFfgJ/IwBBIGsiByQAIAdBCGogASkDECABNAIcfCICIAJCgKMFfyICQoCjBX59IgRCP4ciBSACfCICENQCIAcpAxAhBiAHKQMIIQMgACAHKQMYNwMQIAAgBjcDCCAAIAM3AwAgACABKAIYNgJAIAAgBUKAowWDIAR8pyIBQTxwrTcDKCAAIAFBkBxuIgitNwMYIAAgAiADQgFCARDTAn1CAXw3AzggACACQgR8QgeBIgJCP4dCB4MgAnw3AzAgACABIAhBkBxsa0H//wNxQTxurTcDICAHQSBqJAALcwAgAadBmQFsQckDa0H//wNxQQVurSAAQo8DfSAAIABCAFMbQpADfyIBQrH1CH4gAULwfH4gAHwiAEIEf3wgAELtAn58IABCnH9/fHwiAEEHIABC6PQrfUIHgSIAQj+HQgeDIAB8p2vAQQdvrHxC7PQrfQuTBAMHfwN+AXwjAEHQAGsiAyQAIANBADYCTCADQoCAgIDAADcCRCADQRhqIAIoAgwiBCgCDCAEKAIQEIsDIAMoAiBBAnQhCiADKAIcIQYgAygCGCEJQQAhBAJAAkADQAJAAkAgBCAKRwRAIANBDGogASAEIAZqKAIAIgUQrQIgAygCECIHIAMoAhQiCEGc38IAQQUQsQIEQCAHIAhBod/CAEEHELECDQMLIANBGGogASgCBCABKAIIIAUQrAIiCCgCKCAIKAIsELUCIAMoAhhFDQEgAygCHCEBIAAgAysDIDkCCCAA", + "IAE2AgQMBAsgBiAJEOYEIAAgAiADQcQAahC2BQwECyADKwMgIQ4gA0EANgI0IANBADYCGCADIA5EAAAAAABAj0Ci/AYiCyALQugHfyILQugHfn0iDEI/hyINIAt8NwMoIAMgDULoB4MgDHynQcCEPWw2AjAgA0E4aiADQRhqQaziwgBBGRCIBiADQcQAaiABIAVBAkH4rsMAQQsgAygCPCIFIAMoAkAQ7AUQ4AIgAygCOCAFEAEgAygCDCAHEAEgBEEEaiEEDAELCyABKAIEIAEoAgggBRCsAiEBIANBAzYCHCADIAFBGGo2AhggAEEEakGoyMAAIANBGGoQDAsgAEF+NgIAIAMoAgwgBxABIAYgCRDmBCADKAJEIAMoAkgQJgsgAhC7BCADQdAAaiQAC+YEAgd/AX4jAEGwAWsiAyQAIAMgAhCGBiADQQhqIAMoAgAgAygCBBAGIANBADYCfCADQoCAgIDAADcCdCADQdAAaiACKAIMIgUoAgwgBSgCEBCLAyADKAJYQQJ0IQogAygCVCEFIAMoAlAhCSADQTBqQQRyIQgDQAJAAkACQAJAIAQgCkcEQCADQRRqIAEoAgQgASgCCCAEIAVqKAIAIgYQrAIiB0EoaigCACAHQSxqKAIAEEIgA0HQAGogAygCDCADKAIQIAMoAhgiByADKAIcEK8CIAMoAlBBf0cNASADIAMoAlw2AogBIAMgAykCVDcDgAEgA0GMAWoiBCABIAYQ/QUgA0EDNgKsASADQQM2AqQBIANBAzYCnAEgAyADQYABajYCqAEgAyADQQhqNgKgASADIAQ2ApgBIAhB65TAACADQZgBahAMIAMoAowBIAMoApABEAEgAygCgAEgAygChAEQAQwCCyAFIAkQ5gQgACACIANB9ABqELYFDAMLIAMgAykDaDcDSCADIAMpA2A3A0AgAyADKQNYNwM4IAMgAykDUCILNwMwIAunQX9HDQELIAMgCCgCCCIBNgIoIAMgCCkCACILNwMgIAAgATYC", + "DCAAIAs3AgQgAEF+NgIAIAMoAhQgBxABIAUgCRDmBCADKAJ0IAMoAngQJgwBCyADQdAAaiADKQNAEPAEIANB9ABqIAEgBkECQZzfwgBBBSADKAJUIgYgAygCWBDsBRDgAiADKAJQIAYQASADKAIUIAcQASAEQQRqIQQMAQsLIAMoAgggAygCDBABIAIQuwQgA0GwAWokAAuMBQERfyMAQUBqIgQkACAEQQA2AjwgBEKAgICAwAA3AjQgAygCHCEFIAMtACAgAygCGCEDIARBEGogAigCDCIHKAIMIAcoAhAQiwNBACADQYqAgIB4RiIDGyILQf8BcUEBRiAFQQIgAxsiD0VxIAtBDnFBBEZyIRAgBCgCGEECdCERIAQoAhQhByAEKAIQIQwgAigCECESA0ACQAJAIAggEUcEQCAEQRBqIAEgByAIaigCACINIAsgDxCRBiAEKAIcIQUgBCgCGCEDIAQoAhQhBiAEKAIQRQ0CIAAgBTYCDCAAIAM2AgggACAGNgIEIABBfjYCACAHIAwQ5gQgBCgCNCAEKAI4ECYMAQsgByAMEOYEIAAgAiAEQTRqELYFCyACELsEIARBQGskAA8LIARBEGoiDiABKAIEIAEoAgggDRCSBiAEQQM2AjAgBCAONgIsIARBIGpB35TAACAEQSxqEAwgBCgCECAEKAIUEAEgBCgCICASIAQoAiQiFCAEKAIoEJMGIgkEQAJAIAMgBUEKEKYCRQ0AIARBCGogBUEBayIKIAMgBUGwvcMAEOQCIAQoAgggBCgCDEEKEKYCDQAgBCAKIAMgBUHAvcMAEOQCIAQoAgRFDQAgCSgCEEUNACABKAIEIAEoAgggCSgCDCgCABCsAiIKKAIoIAooAixBChCmAg0AIA4gAyAFEJQGIAYgAxABIAQoAhghBSAEKAIUIQMgBCgCECEGCyAJEIMECyAQBEAgBEEQaiADIAUQlAYgBiADEAEgBCgCGCEFIAQoAhAhBiAEKAIUIQMLIARBNGogASANQQJB", + "49/CAEEFIAMgBRDsBRDgAiAUEAEgBiADEAEgCEEEaiEIDAALAAveDQIHfwF+IwBB0ABrIgUkAEKAgICAgKDAACEMAkACQAJAAkACQAJAAkACQAJAAkACQCADQf8BcUEBaw4JAQMABAUGBggIAgsgAEEEakHQvcMAQRwQBiAAQQE2AgAMCQtCgICAgICAwAAhDAsgBUEANgIUIAVCgICAgBA3AgwgBUEBOwEoIAVCADcCICAFIAStIAwgA61C/wGDQiCGhIQ3AhggBUEsaiAFQQxqIAEgAhC6BCAFKAIsIgFBf0cEQCAAIAUpAjA3AgggACABNgIEIABBATYCACAFKAIMIAUoAhAQAQwICyAAIAUoAhQ2AgwgACAFKQIMNwIEIABBADYCAAwHCyAFQQxqIAEgAkEAEOEEIAUoAgwiA0F/RwRAIAAgBSkCEDcCCCAAIAM2AgQgAEEBNgIADAcLIAEoAgQgASgCCCACEKwCLQCaAUECRg0DIAVBADYCNCAFQoCAgIAQNwIsIAVBDGogASACQQFBAEEAIAUgBUEsahCsByAFKAIMIgFBf0cEQCAAIAUpAhA3AgggACABNgIEIABBATYCACAFKAIsIAUoAjAQAQwHCyAAIAUoAjQ2AgwgACAFKQIsNwIEIABBADYCAAwGCyAFQQxqIAEgAkEAEOEEIAUoAgwiA0F/RwRAIAAgBSkCEDcCCCAAIAM2AgQgAEEBNgIADAYLIAAgASACQSwQrQcMBQsgBUEMaiABIAJBABDhBCAFKAIMIgNBf0cEQCAAIAUpAhA3AgggACADNgIEIABBATYCAAwFCyAAIAEgAkEJEK0HDAQLIAVBDGogASACEK0CIAUoAhAiBCAFKAIUQePfwgBBBRCxAiAFKAIMIAQQAQ0CIAVBLGogASgCBCABKAIIIAIQrAIiAUEoaigCACABQSxqKAIAEEIgBSgCNCEBIAUoAjAhBiAFQQA2AhQgBUKAgICAEDcCDEHwvsMAQbC+wwAgA0H/AXFBB0Yb", + "IQMgBiECA0ACQAJAIAEEQCABQQNJIQpBACEIQQAhBAJ/QQAgAUEBRg0AGiACLQABQQh0IQRBACAKDQAaQQEhCCACLQACCyELIAVBDGoiByADIAItAAAiCUECdmotAAAQ1wIgByADIAQgCUEQdHJBDHZBP3FqLQAAENcCQT0hCUE9IQcgAUEBRw0BDAILIAAgBSgCFDYCDCAAIAUpAgw3AgQgAEEANgIAIAUoAiwgBhABDAYLIAMgBCALckEGdkE/cWotAAAhBwsgBUEMaiAHENcCIAEgAUEDIAobIgRrIQEgAiAEaiECIAVBDGogCAR/IAMgC0E/cWotAAAFQT0LENcCDAALAAsgASgCBCABKAIIIAIQrAIhASAFQQM2AhAgBSABQSRqNgIMIABBBGpB7NTAACAFQQxqEAwgAEEANgIADAILIAVBDGogASACEK0CIAUoAhAiBCAFKAIUQePfwgBBBRCxAiEGIAUoAgwgBBABAkACQCAGRQRAIAVBLGogASgCBCABKAIIIAIQrAIiAUEoaigCACABQSxqKAIAEEIgBSgCNCECIAUoAjAhASADQf8BcUEIRg0BQQAhAyAFQQA2AkAgBUKAgICAEDcCOCAFIAE2AgwgBSABIAJqNgIQA0ACQAJAAkAgBUEMahDCASIEQSdHBEAgBEF/Rw0BIANBAXFFDQcgBUE4akEnENcCDAcLIANBAXFBACEDQdwAIQJFDQEgBUE4akEnENcCDAELIAQQ2QYNASAEQd8ARiAEQSVrIgJBG01BAEEBIAJ0QcGPgMkAcRtyDQEgA0EBcUEnIQJBASEDDQELIAVBOGogAhDXAgsgBUE4aiAEENcCDAALAAsgASgCBCABKAIIIAIQrAIhASAFQQM2AhAgBSABQRhqNgIMIABBBGpBscHAACAFQQxqEAwgAEEBNgIADAMLIAVBADYCQCAFQoCAgIAQNwI4IAEhAwNAIAJFDQECQAJAIAMtAAAiBEEwa0H/AXFBCkkgBEHfAXFBwQBrQf8B", + "cUEZTXIgBEEta0ECSXINACAEQSBHBEAgBEHfAEYgBEH+AEZyDQEgBSAEOgBHIAVBMDYCTCAFIAVBxwBqNgJIIAVBDGpBpr7DACAFQcgAahAMIAUoAgwgBUE4aiAFKAIQIgYgBSgCFBAKIAYQAQwCCyAFQThqQSsQ1wIMAQsgBUE4aiAEENcCCyADQQFqIQMgAkEBayECDAALAAsgACAFKAJANgIMIAAgBSkCODcCBCAAQQA2AgAgBSgCLCABEAEMAQsgASgCBCABKAIIIAIQrAIhASAFQQM2AhAgBSABQRhqNgIMIABBBGpB/bzAACAFQQxqEAwgAEEBNgIACyAFQdAAaiQAC/wBAQR/IwBBMGsiBCQAAkAgASACIANByPPCABC5AiIGLQCZAUUEQCAEQQA2AgggBEKAgICAEDcCAAwBCyAEQQM2AhwgBCAGQSRqNgIYIARB9MvAACAEQRhqEAwLIAYoAhBBAUYEQCABIAIgBigCFEG83sIAELkCIgUoAiwhByAFKAIoIQULIAQgB0EAIAUbNgIQIAQgBUEBIAUbNgIMIAQgASACIAMQ3gQ2AhQgBEECNgIsIARBBDYCJCAEQQM2AhwgBCAEQQxqNgIoIAQgBEEUajYCICAEIAQ2AhggAEGBlsAAIARBGGoQDCAEKAIAIAQoAgQQASAEQTBqJAAL3AICA34HfyMAQRBrIgYkACAGQQhqIABBCGpBjOLCABDmASAGKAIMIQkCQCAGKAIIIgAoAgxFBEBBACEADAELIAApAxAgAEEYaikDACABIAIQqgEhAyAAKAIEIgogA6dxIQcgA0IZiEL/AINCgYKEiJCgwIABfiEFIAAoAgAhCANAIAcgCGopAAAiBCAFhSIDQn+FIANCgYKEiJCgwIABfYNCgIGChIiQoMCAf4MhAwJAA0AgA1ANASABIAIgCCADeqdBA3YgB2ogCnEiAEEEdGsiDEEMaygCACAMQQhrKAIAEBJFBEAgA0IBfSADgyEDDAELCyAIIABBBHRr", + "QQRrKAIAIgAgACgCAEEBaiIBNgIAIAENAgALQQAhACAEIARCAYaDQoCBgoSIkKDAgH+DUEUNASAHIAtBCGoiC2ogCnEhBwwACwALIAkgCSgCAEEBazYCACAGQRBqJAAgAAswAQF/IwBBEGsiAyQAIANBCGogASACQQoQoQIgACADKAIIIAMoAgwQBiADQRBqJAALjhECFn8CfiMAQbACayIEJAAgBEKAgICAwAA3AvwBIAMtABwgBEEANgKEAiADKAIYIQMgBEHgAGogAigCDCILKAIMIAsoAhAQiwMgBCgCZCIOIAQoAmhBAnRqIRggBCgCYCESIARB1ABqIQogBEGMAmohDSAEQeQAaiETIARB2QBqIRQgBEHlAGohFSACKAIQIRlBACADQYuAgIB4RhtB/wFxIRYgDiELAkACQAJAA0ACQAJAAkACQAJAAkACQAJAAkACQCALIBhHBEAgBEHgAGoiBiABKAIEIAEoAgggCygCACIPEJIGIARBAzYCVCAEIAY2AlAgBEGIAmpB35TAACAEQdAAahAMIAQoAmAgBCgCZBABIAQoAogCIRcgBCgCjAIhECAEKAKQAiEDQQRBBBDlAiIFIA82AgAgBEEBNgJoIAQgBTYCZCAEQQE2AmAgGSAQIAMgBhCWBiAEQTRqIAEoAgQgASgCCCAPEKwCIgNBKGooAgAgA0EsaigCABBCIBYOCQgHBgEFBAMDAgELIA4gEhDmBCAAIAIgBEH8AWoQtgUMDQsgAEEEakGUvcMAQRsQBiAAQX42AgAgBCgCOCEHDAsLQQAhAyAEQQA2AqQCIARCgICAgBA3ApwCIAQoAjwhDCAEKAI4IQcDQAJAAkACQAJAIAMgDE8EQCAEQYgCaiAEQZwCahD3BCAEKAKIAkF/Rg0BIAQgBCgCmAI2AnAgBCAEKQKQAjcDaCAEIAQpAogCNwNgIAogBEHgAGoQ+AQgBCgCYCAEKAJkEAEMDwsgAyAHai0AACIFQSVHBEAgBUErRwRAIARBnAJq", + "IAUQqAUgA0EBaiEDDAYLIARBnAJqQSAQqAUgA0EBaiEDDAULIANBAmogDEkNASAEQShqIAMgByAMQbjAwwAQvwIgBCAEKQMoNwKIAiAEQQI2AmQgBCAEQYgCajYCYCAKQavTwAAgBEHgAGoQDAwCCyAKIA0oAgg2AgggCiANKQIANwIAIAQoAlQgBEHgAGoiAyAEKAJYIgYgBCgCXBCXBiABIAMQ3wIhAyAGEAEMCgsgBEEgaiAHIAwgA0EBaiADQQNqIgVBqMDDABDWASAEKAIgIQgCQAJAAkACQCAEKAIkIgkOAgMAAQsgCC0AACIGQStrDgMCAQIBCyAILQAAIQYLIAggBkH/AXFBK0YiEWohBiAJIBFrIglBA08EQEEAIQgDQCAJRQ0EIAhB/wFxQQ9LDQIgBEEYaiAGLQAAQRAQFiAEKAIYQQFHDQIgBkEBaiEGIAlBAWshCSAIQQR0IhEgBC0AHGoiCEH/AXEgEUH/AXFPDQALDAELQQAhCANAIAlFDQMgBEEQaiAGLQAAQRAQFiAEKAIQQQFHDQEgBkEBaiEGIAlBAWshCSAEKAIUIAhBBHRqIQgMAAsACyAEQQhqIAcgDCADIAVB5ODCABDWASAEIAQpAwg3AqgCIARBAjYCjAIgBCAEQagCajYCiAIgBEHgAGpBq9PAACAEQYgCahAMIAQtAGQhCCAEKAJgIgNBf0YNASAUIBUoAAM2AAMgFCAVKAAANgAAIAQgCDoAWCAEIAM2AlQLIAQoApwCIAQoAqACEAEMCwsgBEGcAmogCBCoBSAFIQMMAAsACyAEQeAAaiIDIAQoAjgiByAEKAI8IBZBB0YQmAYgBCATKQIANwOIAiAEIBMoAgg2ApACIAQoAmBFBEAgBCAEKAKQAjYCSCAEIAQpA4gCNwNAIARBiAJqIARBQGsQ9wQgBCgCiAJBf0cEQCAEIAQoApgCNgJwIAQgBCkCkAI3A2ggBCAEKQKIAjcDYCAKIAMQ+AQgBCgCYCAEKAJkEAEgBCkC", + "VCEaIAAgBCgCXDYCDCAAIBo3AgQgAEF+NgIADAsLIAogDSgCCDYCCCAKIA0pAgA3AgAgBCgCVCAEQeAAaiIDIAQoAlgiBiAEKAJcEJcGIAEgAxDfAiEDIAYQAQwGCyAAIAQoApACNgIMIAAgBCkDiAI3AgQgAEF+NgIADAkLIARB4ABqIAEgBCgCOCIHIAQoAjxBCRCZBiAEKAJkIQMgBCgCYCIFQX9GDQQgACAEKAJoNgIMIAAgAzYCCCAAIAU2AgQgAEF+NgIADAgLIARB4ABqIAEgBCgCOCIHIAQoAjxBLBCZBiAEKAJkIQMgBCgCYCIFQX9GDQMgACAEKAJoNgIMIAAgAzYCCCAAIAU2AgQgAEF+NgIADAcLIARB4ABqIAEgBCgCOCIHIAQoAjwQmgYgBCgCZCEDIAQoAmAiBUF/Rg0CIAAgBCgCaDYCDCAAIAM2AgggACAFNgIEIABBfjYCAAwGCyAEQeAAaiABIAQoAjgiByAEKAI8ELMEIAQoAmwhAyAEKAJoIQUgBCgCZCEGIAQoAmBFBEAgAwRAIAUoAgAhAyAGIAUQJgwDCyAAQQRqQc2zwwBBAxAGIABBfjYCACAGIAUQJgwGCyAAIAM2AgwgACAFNgIIIAAgBjYCBCAAQX42AgAMBQsgBEHgAGogASAEKAI4IgcgBCgCPEEAELQEIAQoAmwhAyAEKAJoIQUgBCgCZCEGIAQoAmANASADBEAgBSgCACEDIAYgBRAmDAELIABBBGpBzbPDAEEDEAYgAEF+NgIAIAYgBRAmDAQLIAtBBGohCyABKAIEIAEoAgggDxCsAiIFKQIQIRogBSkCCCEbIAEoAgQgASgCCCADEOECIgUgGzcCCCAFIBo3AhAgBEH8AWogAxDgAiAEKAI0IAcQASAXIBAQAQwBCwsgACADNgIMIAAgBTYCCCAAIAY2AgQgAEF+NgIADAELIAQpAlQhGiAAIAQoAlw2AgwgACAaNwIEIABBfjYCAAsgBCgCNCAHEAEgFyAQEAEg", + "DiASEOYEIAQoAvwBIAQoAoACECYLIAIQuwQgBEGwAmokAAv2AgIEfwJ+IwBBMGsiBCQAIAAoAghFBEAgAEF/NgIIIARBDGoiBSABIAIQBiAAQRBqIQEgAxDbBCEDIAApAyAgACkDKCAEKAIQIAQoAhQQjgMhCCAEIAU2AiQgACgCGEUEQCABIABBIGoQkwMLIAQgATYCLCAEIARBJGo2AiggBCAAKAIQIAAoAhQgCCAEQShqQTEQlQMgACgCECEBIAQoAgQhAgJAIAQoAgBBAUYEQCABIAJqIgUtAAAhBiAEKAIUIQcgBCkCDCEJIAUgCKdBGXYiBToAACABIAAoAhQgAkEIa3FqQQhqIAU6AAAgACAAKAIcQQFqNgIcIAAgACgCGCAGQQFxazYCGCABIAJBBHRrIgFBEGsiAiAJNwIAIAIgBzYCCCABQQRrIAM2AgAMAQsgASACQQR0a0EEayIBKAIAIAEgAzYCACAEKAIMIAQoAhAQARCDBAsgACAAKAIIQQFqNgIIIARBMGokAA8LQZziwgAQXgALLAAgAEGgk8MAQePfwgAgASACQeHfwgBBAhASIgAbQQdBBSAAGyABIAIQ3gIL6gQBDH8jAEHQAGsiBCQAIARBCGogASACEBQgBEEQaiICIAQoAgggBCgCDBAGIAQoAhgiBUEDcSIBBEAgBEEoakHEs8MAQQFBBCABaxDZAiACIAQoAiwiASAEKAIwEAogBCgCKCABEAEgBCgCGCEFC0HwvsMAQbC+wwAgAxshCyAEQQA2AiQgBEKAgICAEDcCHEGwv8MAQfC+wwAgAxshDCAEKAIUIQkDQAJAIAUgBkEDck0EQCAAIAQoAiQ2AgwgACAEKQIcNwIEIABBADYCAAwBCyAEQgA3AzAgBEIANwMoQQAhCkEAIQdBACEDQQAhAgNAAkACQCADQRBHBEAgAiAGaiIIIAVPDQEgAkEBaiECIANBBGohASAIIAlqLQAAIg1BPUcNAiAHQQFqIQcgAiEKIAEhAwwD", + "CyAEQRxqIgIgBCgCNCAEKAIsQQx0IAQoAihBEnRyIAQoAjBBBnRyciIBQRB2EKgFAkAgB0EBSg0AIAIgAUEIdhCoBSAHQQFGDQAgAiABEKgFCyAGQQRqIQYMBAsgBSAGIApqIgAgACAFSRsgBUGwv8MAECoACyAEQShqIANqQQAhAwJAA0AgDCADIAtqIg9HBEAgDy0AACANRg0CIANBAWohAwwBCwsgBCAINgJEIARBBDYCTCAEIARBxABqNgJIIARBOGpBhY3AACAEQcgAahAMIAQoAjwhAyAEKAI4IghBf0YNACAAIAQoAkA2AgwgACADNgIIIAAgCDYCBCAAQQE2AgAgBCgCHCAEKAIgEAEMAgsgAzYCACABIQMMAAsACwsgBCgCECAJEAEgBEHQAGokAAu1DQIQfwF+IwBB8AFrIgUkACAFQQA2AsgBIAVCgICAgMAANwLAASAFQcwBaiACIAIgA2oQICAFKALQASIGQQRqIQwgBSgC1AEhB0EEIQtBACECAkADQCACIAdJBEAgBUEANgLsASAFQoCAgIDAADcC5AEDQCAFQQA2AuABIAVCgICAgBA3AtgBAkACQCAGRSACIAdPckUEQCAGIAJBAnRqKAIAQSJGDQELIAwgAkECdGohCANAIAIgB08NAiAGIAcgAkHAv8MAECEoAgAgBEYNAiAGIAcgAkHQv8MAECEoAgBBCkYNAgJAIAYgByACQeC/wwAQISgCAEENRyACQQFqIgMgB09yRQRAIAgoAgBBCkYNAQsgBUHYAWogBiAHIAJB8L/DABAhKAIAENcCCyAIQQRqIQggAyECDAALAAsgAkEBaiEJA0ACQCAHIAlLBEAgCUEBaiECIAYgCUECdGooAgAiA0EiRw0BIAIgB08NAyAGIAJBAnRqKAIAQSJHDQMgBUHYAWpBIhDXAiAJQQJqIQkMAgsgBUEoakGAwMMAQSgQBiAFKALYASAFKALcARABIAVB5AFqEPECIAUoAswBIAYQJiAFQcABahDI", + "ByAFIAUoAjAiATYCICAFIAUpAigiFTcDGCAAIAE2AgggACAVNwIADAYLIAVB2AFqIAMQ1wIgAiEJDAALAAsgBUHkAWogBUHYAWoQvAECQCACIAdPBH9BAAUgBiACQQJ0aigCACIDIARGDQEgA0EKRgsgAmohAgJAIAUoAuwBQQFGBEAgBSgC6AEoAghFDQELIAUoAsABIApGBEAgBUHAAWoQvQEgBSgCxAEhCwsgBSkC5AEhFSALIApBDGxqIgMgBSgC7AE2AgggAyAVNwIAIAUgCkEBaiIKNgLIAQwECyAFQeQBahDxAgwDCyACQQFqIQIMAAsACwsgBSAFKALIATYCMCAFIAUpAsABNwIoIAUoAswBIAYQJiAFIAUoAjAiAjYCICAFIAI2AhAgBSAFKQIoNwMIAkAgAgRAIAVBwAFqIAUoAgwiBkEEaigCACAGQQhqKAIAENIDIAVBPGoiD0Gw3sIAQQUQBiAFQQA6AL4BIAVCATcCWCAFQgA3AlAgBUKAgICAEDcCSCAFQgE3AogBIAVCADcCgAEgBUKAgICAEDcCeCAFQgE3AnAgBUIANwJoIAVCgICAgMAANwJgIAVBADYCJCAFQQA2AiwgBUEANgI0IAVBADYCmAEgBUEANgKsASAFQoCAgIAQNwKQASAFQoCAgIAQNwKcASAFQgA3AqQBIAVCADcBtgEgBUIANwKwASABIAVBJGoQ3wIhCkEAQQEQASAGIAJBDGxqIQsgBUGwAWohDEEAIQJBASEDA0ACQCACQQFxBEAgBiALRw0BDAQLIAMgCyAGa0EMbk8NAyAGIANBDGxqIQYLIA9Btd7CAEEFEAYgBUEBOgC+ASAFQgE3AlggBUIANwJQIAVCgICAgBA3AkggBUIBNwKIASAFQgA3AoABIAVCgICAgBA3AnggBUIBNwJwIAVCADcCaCAFQoCAgIDAADcCYEEAIQIgBUEANgIkIAVBADYCLCAFQQA2AjQgBUEANgKYASAFQQA2AqwBIAVCgICAgBA3", + "ApABIAVCgICAgBA3ApwBIAVCADcCpAEgDEIANwEGIAxCADcCACABIAVBJGoQ3wIhDkEAQQEQASAFKALIAUEMbCEQIAUoAsQBIQNBACEJA0ACQAJAIAIgEEcEQCAFQSRqIgcgBigCBCACakEAIAkgBigCCEkbEMcEIAUoAighCCAFKAIsIQ0gBSgCJCEEIAdB49/CAEEFIAMoAgQgAygCCBDeAiABIAcQ3wIhESAFQcwBaiABQQEgCCAEQX9GIggbIgdBACANIAgbIg0QugJBACAEIAgbIRIgBSgCzAEiE0F/RwRAIAUoAtABIQgMAgsgASgCBCABKAIIIAUoAtABIggQrAItAJoBQQJHDQEgCCEEIAEoAgQgASgCCCAIEKwCIhRBKGooAgAgFEEsaigCACAHIA0QlgNFDQEMAgsgASAKIA4QqwUgBkEMaiEGQQAhA0EBIQIMAwsgBUEkaiIEQePfwgBBBSAHIA0Q3gIgASAEEN8CIQQLIANBDGohAyATIAgQBSAFIAEgDiARIAQQ6QQgEiAHEAEgCUEBaiEJIAJBDGohAgwACwALAAsgAEHNs8MAQQMQBiAFQQhqEMgHDAELIABBfzYCACAAIAo2AgQgBUHAAWoQ8QIgBUEIahDIBwsgBUHwAWokAAvFEwIYfwJ+IwBB0AprIgQkACAEQYgJaiIMQbXewgBBBRAGIARBAToAigogBEIBNwKkCSAEQgA3ApwJIARCgICAgBA3ApQJIARCATcC1AkgBEIANwLMCSAEQoCAgIAQNwLECSAEQgE3ArwJIARCADcCtAkgBEKAgICAwAA3AqwJIARBADYC8AggBEEANgL4CCAEQQA2AoAJIARBADYC5AkgBEEANgL4CSAEQoCAgIAQNwLcCSAEQoCAgIAQNwLoCSAEQgA3AvAJIARCADcBggogBEIANwL8CSABIARB8AhqIgYQ3wIhDUEAQQEQAUEEQQQQ5QIiByANNgIAIARBATYC+AggBCAHNgL0CCAEQQE2AvAIIARB", + "/ABqIAYQuAQgBEEANgKcASAEQoCAgIDAADcClAEgBEGgAWogAiADELAHIARBmAlqIRcgBEGoB2ohDiAEQdQIaiEPIARBtApqIRAgBEGYB2ohESAEQfgIaiESIARBuAdqIRggBEGQB2pBB3IhEyAEQZwHaiEUIARB9AFqIRUgBEGUB2ohFgJAA0AgBEHwAGogBEGgAWoQsQcCfwJAIAQoAnAiAgRAIARB6ABqIAIgBCgCdBCkAiAEKAJoIQcgBCgCbCICRQ0DIARB4ABqIAcgAkEjEB4gBCgCYCIDRQ0BIAQoAmQMAgsgAEF/NgIAIAAgDTYCBAwDCyAEQdgAaiAHIAJBIRAeIAQoAlghAyAEKAJcCyEGIAMEQCAEQdAAaiADIAYQFCAEQfAIaiICIAQoAlAgBCgCVBAGIARBlAFqIAIQvAEMAQsgBEHIAGogByACQr2AgICgBxDBByAEQThqAn8gBCgCSEEBRgRAQQEhBiAEKAJMDAELIARBQGsgByACQqCAgICQARDBByAEKAJAIQYgBCgCRAsgAiAGQQFxGyIFIAcgAkH8vcMAEOQCIARBMGogBCgCOCAEKAI8EBQgBCgCNCEDIAQoAjAhBiAEQShqIAUgByACQYy+wwAQvwIgBEEgaiAEKAIoIAQoAixCoICAgJABEKMCIARBGGogBCgCICAEKAIkQr2AgICgBxCjAiAEQRBqIAQoAhggBCgCHEKggICAkAEQowIgBCgCFCEZIAQoAhAhGiAEQZAHaiIFQS4gBiADEKICIARBATsBtAcgBCADNgKwByAEQQA2AqwHIARB8AFqIAUQjAQCQCAEKALwAUECRwRAQRAhAiAEQQhqQQRBCEEQEAcgBCgCCCEHIAQoAgwiBiAEKQP4ATcDCCAGIAQpA/ABNwMAQQEhAyAEQQE2AtADIAQgBjYCzAMgBCAHNgLIAyAEQfAIaiAFQSj8CgAAA0AgBEGwBWogBEHwCGoQjAQgBCgCsAVBAkZFBEAgBCgCyAMgA0YEQCAE", + "QcgDaiADQQFBCEEQEC8gBCgCzAMhBgsgAiAGaiIHIAQpA7gFNwMIIAcgBCkDsAU3AwAgBCADQQFqIgM2AtADIAJBEGohAgwBCwsgBCAEKQLIAzcDyAEgBCAEKALQAzYC0AEMAQsgBEEANgLQASAEQoCAgICAATcDyAELAkACQCAEKAKcASICRQRAIAQoAtABIQYgBCgCzAEhCgwBC0EBIQsgBEHwCGoiCCAEKAKYASIDIAJBlLTDAEEBEKcCIARBAzYClAcgBCAINgKQByAEQdgBakGJlsAAIARBkAdqEAwgBCgC8AggBCgC9AgQASAEKALMASEKQQAhBwJ/AkAgBCgC0AEiBkUNACAKIAZBBHRqQRBrIgVFDQAgCCAFEIQEQQAgBCgC8AgiBUF/Rg0BGiAEKAL0CCELIAUhByAEKAL4CAwBC0EACyEJIARB8AhqIghB49/CAEEFIAsgCRDeAiAEQeQBaiABIAEgCBDfAiIJEK0CIAEoAgQgASgCCCAJEOECIgUoAhggBUEcaigCABABIAUgBCgC7AE2AiAgBSAEKQLkATcCGCAFKAJIIAVBzABqKAIAEAEgBSAEKALgATYCUCAFIAQpAtgBNwJIIARBADoA9gggBEEAOwH0CCAEQYKAgIB4NgLwCCAEQfABaiIbQQggCBDAByAEQQA7AfQIIARBADYC8AggBEGQB2oiBSAKIAYgCEEBEMMGIAggCRDGBiAEQgA3A8gKIARBsAVqIgkgGyAFIAgQxwYgCCAEQfwAahC7BSAFIAEgCCAJEN0EIAQgFikCADcDyAMgBCAWKAIINgLQAyAEKAKQByIFQX5GBEAgACAEKALQAzYCCCAAIAQpA8gDNwIAIAkQ1wQgByALEAEMAgsgBCkCoAchHCAVIAQoAtADNgIIIBUgBCkDyAM3AgAgBCAcNwKAAiAEIAU2AvABIARB8AFqELsEIARBADYCnAEDQCACBEAgAygCACADQQRqKAIAEAEgAkEBayECIANBDGohAwwBCwsg", + "BEGwBWoQ1wQgByALEAELIARB8AhqIgUgGiAZEJcGIARByANqIAEgASAFEN8CIgIQrQIgASgCBCABKAIIIAIQ4QIiAygCGCADQRxqKAIAEAEgAyAEKALQAzYCICADIAQpAsgDNwIYIARB8AFqIARB/ABqELsFIARBADoA9gggBEEAOwH0CCAEQYKAgIB4NgLwCCAEQdgDaiIIQQggBRDAByABKAIEIgMgASgCCCIHIAIQrAItAJoBQQFGBEAgFEEAOgACIBRBADsBACATQQA2AAAgE0EAOgAEIARBAToAlgcgBEEBOwGUByAEQYOAgIB4NgKQByAFQRMgBEGQB2oQwAcgCBDkBCAIIAVB2AH8CgAACyAYIAMgByACEKwCEOcEIARB8AhqIgdB6AAQzQQgESASKQMANwMAIBEgEikDCDcDCCAPIBApAgA3AgAgDyAQKAIINgIIIA4gDCkDADcDACAOIAwpAwg3AwggBCkD8AghHCAELwHACiEDIBcQ5QQgBEEAOwH0CCAEQQA2AvAIIARBsAVqIgUgCiAGIAdBABDDBiAEQgA3A+gIIAQgAzsB4AggBCAcNwOQByAHIARB2ANqIAUgBEGQB2oiBhDHBiAEKALMCiIDBEAgBiACEMYGIAMQ5AQgAyAGQdgB/AoAAAsgBEGQB2ogASAEQfABaiAEQfAIahDdBCAEKQKYByEcIAQoApQHIQMgBCgCkAciAkF+RwRAIAQgHDcCuAUgBCADNgK0BSAEIAQpAqAHNwLABSAEIAI2ArAFIARBsAVqELsEIB0hHEF/IQMLIARB8AhqENcEIANBf0cEQCAAIBw3AgQgACADNgIADAELIARByAFqEMQGIBwhHQwBCwsgBEHIAWoQxAYLIARBlAFqEPECIARB/ABqELsEIARB0ApqJAALPAECfyMAQSBrIgQkACAEQQRqIgUgAhC+BSAAIAEgBSADIARBH2pBzK/DAEEAEL8FIAIQuwQgBEEgaiQAC+ECAQh/IwBBIGsiBCQAIARB", + "ADYCHCAEQoCAgIDAADcCFCAEQQhqIAIoAgwiBSgCDCAFKAIQEIsDIAQoAhBBAnQhCSAEKAIMIQUgBCgCCCEHIAMoAtwBIQoCQAJAA0ACQAJAIAYgCUcEQCABKAIEIAEoAgggBSAGaigCACIDEKwCLQCaAQ0CIARBCGpBASABIAIgCiADEJ0GIAQtAAwhCCAEKAIIIgtBf0YNASAAIAQoABA2AAwgACAEKAANNgAJIAAgCDoACCAAIAs2AgQMBAsgBSAHEOYEIAAgAiAEQRRqELYFDAQLIARBFGogAUEBIAMgCEEBcRCeBhDgAiAGQQRqIQYMAQsLIAEoAgQgASgCCCADEKwCIQEgBEEDNgIMIAQgAUEYajYCCCAAQQRqQa6FwAAgBEEIahAMCyAAQX42AgAgBSAHEOYEIAQoAhQgBCgCGBAmCyACELsEIARBIGokAAuIAwIIfwF+IwBB4ABrIgYkACAGQcgAaiACKAIEIAIoAgggBRCsAiIFQUBrKAIAIAVBxABqKAIAEIsDIAYoAlBBAnQhDCAGKAJMIQggBigCSCEJIAZBDGohCiAGQTRqIQtBACEFAkADQAJAAkACQAJAAkAgBSAMRwRAIAUgCGooAgAhByAERQ0CIAZByABqIg0gAyAHEMgFIAZBMGogAiANIAQQ3QQgBiALKQIANwMgIAYgCygCCDYCKCAGKAIwIgdBfkcNASAAIAYoAig2AgggACAGKQMgNwIADAULIAggCRDmBCAAQX82AgAgAEEAOgAEDAYLIAYpAkAhDiAKIAYoAig2AgggCiAGKQMgNwIAIAYgDjcCGCAGIAc2AgggBigCFCIHKAIQRQ0BIAcoAgwoAgAhByAGQQhqELsECyACKAIEIAIoAgggBxCsAhC4AiABRw0BIABBfzYCACAAQQE6AAQMAgsgBkEIahC7BAsgBUEEaiEFDAELCyAIIAkQ5gQLIAZB4ABqJAALxwIBAX8jAEGgAWsiBCQAIAFBAXFFBEAgBEECOgCeASAEQQA2", + "AjwgBEKAgICAEDcCNCAEQgE3AiwgBEIANwIkIARCgICAgBA3AhwgBEIBNwJoIARCADcCYCAEQoCAgIAQNwJYIARCATcCUCAEQgA3AkggBEKAgICAwAA3AkAgBEEANgIEIARBADYCDCAEQQA2AhQgBEEANgJ4IARCADcCiAEgBEKAgICAEDcCcCAEQQA2AoQBIARCgICAgBA3AnwgBEIANwKQASAEQgA3AZYBIAAgBEEEahDfAiECCyAAIAJBAkGG5MIAQQZB7ezCAEGM5MIAIAMbQQRBBSADGxDsBSEBIAAoAgQiAyAAKAIIIgAgAhCsAi0AmQFBAUYEQCADIAAgARDhAiIAIAI2AhQgAEEBNgIQIABBADoAmQELIARBoAFqJAAgAQvoAgEIfyMAQSBrIgQkACAEQQA2AhwgBEKAgICAwAA3AhQgBEEIaiACKAIMIgUoAgwgBSgCEBCLAyAEKAIQQQJ0IQkgBCgCDCEFIAQoAgghByADKALcASEKQQAhAwJAAkADQAJAAkAgAyAJRwRAIAEoAgQgASgCCCADIAVqKAIAIgYQrAItAJoBDQIgBEEIakEAIAEgAiAKIAYQnQYgBC0ADCEIIAQoAggiC0F/Rg0BIAAgBCgAEDYADCAAIAQoAA02AAkgACAIOgAIIAAgCzYCBAwECyAFIAcQ5gQgACACIARBFGoQtgUMBAsgBEEUaiABQQEgBiAIQX9zQQFxEJ4GEOACIANBBGohAwwBCwsgASgCBCABKAIIIAYQrAIhASAEQQM2AgwgBCABQRhqNgIIIABBBGpBz4XAACAEQQhqEAwLIABBfjYCACAFIAcQ5gQgBCgCFCAEKAIYECYLIAIQuwQgBEEgaiQAC64EAQt/IwBB0AJrIgQkACAEQQA2AswCIARCgICAgMAANwLEAiAEQZwBaiACKAIMIgMoAgwgAygCEBCLAyAEKAKgASIJIAQoAqQBQQJ0aiENIAQoApwBIQwgBEEYaiEOIAkhAwNAAkACQAJAAkACQAJA", + "IAMgDUcEQCAEIAEoAgQgASgCCCADKAIAIgYQrAIQ5wQgBC0AmgEOAgECAwsgCSAMEOYEIAAgAiAEQcQCahC2BQwFC0EAIQcgASAGQQAQoQYhBiAEKAJEQQJ0IQUgBCgCQCEIA0AgBUUNAyAEQbgCaiAHEKwFIARBnAFqIgpBnN/CAEEFIAQoArwCIgsgBCgCwAIQ3gIgASAKEN8CIQogBCgCuAIgCxABIAEgBiABIAogCCgCABCiBhCrBSAFQQRrIQUgCEEEaiEIIAdBAWohBwwACwALQQAhBSABIAZBABChBiEGIAQoAkAhCCAEKAJEIQcDQCAFQQFqIgsgB08NAiABIAYgASAIIAcgBUHAsMMAECEoAgAgCCAHIAtB0LDDABAhKAIAEKIGEKsFIAVBAmohBQwACwALIAQoAhwgBCgCIEGl4MIAQQYQsQJFDQEgBEEDNgKgASAEIA42ApwBIABBBGpB4pfAACAEQZwBahAMIABBfjYCACAEEMIEIAkgDBDmBCAEKALEAiAEKALIAhAmDAILIARBxAJqIAYQ4AILIANBBGohAyAEEMIEDAELCyACELsEIARB0AJqJAALrAIBA38jAEGgAWsiAyQAIAAgAUEAQbDewgBBBUEBQQAQ7AUhBCADQQRqIAAoAgQiBSAAKAIIIgAgAUH48sIAELkCEOcEIAUgACAEEOECIgAoAmwgAEHwAGooAgAQASAAIAMoAng2AnQgACADKQJwNwJsIAAoAkggAEHMAGooAgAQASAAIAMoAlQ2AlAgACADKQJMNwJIIAAoAlQgAEHYAGooAgAQASAAIAMoAmA2AlwgACADKQJYNwJUIAAoAmAgAEHkAGooAgAQASAAIAI2AoQBIAAgAygCbDYCaCAAIAMpAmQ3AmAgAygCHCADKAIgEAEgAygCKCADKAIsEAEgAygCNCADKAI4EAEgAygCQCADKAJEECYgAygCfCADKAKAARABIANBoAFqJAAgBAu4AgEEfyMAQbABayIDJAAgA0EU", + "aiIEQePfwgBBBUGWpcMAQQMQ3gIgACAEEN8CIQUgBEHj38IAQQVBkK7DAEEFEN4CIAAgBBDfAiEGIANBLGpBtd7CAEEFEAYgA0EBOgCuASADQgE3AkggA0IANwJAIANCgICAgBA3AjggA0IBNwJ4IANCADcCcCADQoCAgIAQNwJoIANCATcCYCADQgA3AlggA0KAgICAwAA3AlAgA0EANgIUIANBADYCHCADQQA2AiQgA0EANgKIASADQQA2ApwBIANCgICAgBA3AoABIANCgICAgBA3AowBIANCADcClAEgA0IANwGmASADQgA3AqABIAAgBBDfAiEEQQBBARABIANBCGogACAEIAUgARDpBCADIAAgBCAGIAIQ6QQgA0GwAWokACAEC9AGARB/IwBBQGoiBCQAIARBADYCECAEQoCAgIDAADcCCCAEQShqIAIoAgwiAygCDCADKAIQEIsDIAQoAiwiCyAEKAIwQQJ0aiESIAQoAighECALIQgCQAJAAkACQANAIAggEkYNAyABKAIEIAEoAgggCCgCACIDEKwCLQCaAQ0BIAhBBGohCCABIAMQ/AUhDCAEQShqIAEoAgQgASgCCCADEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMgBCgCMEECdCETIAQoAiwhDSAEKAIoIRFBACEJQQAhDgNAAkACQAJAAkACQCAJIBNHBEAgCSANaigCACEFIARBADsAPiAEQYCABDYAOiAEIA42AiAgBEEoaiABIAVBlqXDAEEDIARBOmoQpAYgBCgCNCEGIAQoAjAhAyAEKAIsIQcgBCgCKEEBRgRAIAQgBzYCFAwECyAGQQFHDQEgBEEoaiABIAVBkK7DAEEFIARBOmoQpAYgBCgCNCEFIAQoAjAhCiAEKAIsIQ8gBCgCKARAIAQgBTYCHCAEIAo2AhggBCAPNgIUDAMLIAVBAUYEQCAKKAIAIQYgAygCACEFIA8gChAmIAcgAxAmDAULIAQgBTYCJCAEQQQ2AjQgBEEENgIs", + "IAQgBEEgajYCMCAEIARBJGo2AiggBEEUakGjh8AAIARBKGoQDCAPIAoQJgwCCyANIBEQ5gQgASgCBCABKAIIIAwQ4QIiA0EBOgCaASAEQShqQbXewgBBBRAGIAMoAhggA0EcaigCABABIAMgBCgCMDYCICADIAQpAig3AhggBEEIaiAMEOACDAYLIAQgBjYCJCAEQQQ2AjQgBEEENgIsIAQgBEEgajYCMCAEIARBJGo2AiggBEEUakHmhsAAIARBKGoQDAsgByADECYgBCgCHCEGIAQoAhghAyAEKAIUIQcLIAdBf0cNASADIQULIAQgASAMIAUgBhDpBCAOQQFqIQ4gCUEEaiEJDAELCwsgDSAREOYEIAAgBjYCDCAAIAM2AgggACAHNgIEDAELIABBBGpB4LDDAEElEAYLIABBfjYCACALIBAQ5gQgBCgCCCAEKAIMECYMAQsgCyAQEOYEIAAgAiAEQQhqELYFCyACELsEIARBQGskAAtLAQJ/IwBBoAFrIgYkACAGQQRqIgcgAyAEEJcGIAEgBxDfAiEDIAcQ3AQgACABIAYtABggAiADIAVBABD9BiAHELsEIAZBoAFqJAALgQwCE38BfiMAQYAGayIEJAAgBEHQAGoiBiACELsFIARBIGogASAGIAQQoAYgBEEkaiEGAkAgBCgCICIFQX5GBEAgAEF+NgIAIAAgBigCCDYCDCAAIAYpAgA3AgQMAQsgBCAEKQIwNwIYIAQgBTYCCCAEQQA2AvwFIARCgICAgMAANwL0BSAEIAYpAgA3AgwgBCAGKAIIIgY2AhQgBEHQAGogBigCDCAGKAIQEIsDIAQoAlQiBiAEKAJYQQJ0aiESIAQoAlAhCyAEQbQFaiEMIARB3AVqIQkgBEH0BGohDSAEQdwEaiEOIARBgAVqIQ8gBEG0AmohCiAEQTxqIRAgAygC3AEhEyAGIQMDQAJAAkAgAyASRwRAIARB0ABqIgUgAiADKAIAIhQQtAUgBEEAOwG0BSAEQQA2ArAF", + "IARBsAJqIAEgBSAEQbAFahD2BSAEIAopAgA3A9gFIAQgCigCCDYC4AUgBCgCsAIiBUF+Rw0BIAAgBCgC4AU2AgwgACAEKQPYBTcCBCAAQX42AgAMAgsgBiALEOYEIAAgAiAEQfQFahC2BSAEQQhqELsEDAMLIANBBGohAyAEKQLAAiEXIBAgBCgC4AU2AgggECAEKQPYBTcCACAEIBc3AkggBCAFNgI4QQAhBSAEQQA2ApAEIARCgICAgMAANwKIBCAEQdAAaiAEKAJEIggoAgwgCCgCEBCLAyAEKAJYQQJ0IRUgBCgCVCEIIAQoAlAhEQNAAkACQAJAIAUgFUcEQCAEQdAAaiIHIARBOGogBSAIaigCABC0BSAEQbACaiABIAcgExC5BCAEIAopAgA3A7AFIAQgCigCCDYCuAUgBCgCsAIiB0F+Rw0DIAAgBCgCuAU2AgwgACAEKQOwBTcCBCAAQX42AgAgCCAREOYEIAQoAogEIAQoAowEECYMAQsgCCAREOYEIARBsAJqIgdB5wAQzQQgBEHQAGoiBSAHQdgB/AoAACAEQgA3A6gCIAcgBEE4aiAEQYgEahC2BSAEQdgFaiABIAcgBRD0BSAEKALcBSEIAkAgBCgC2AUiBUF/RwRAIAAgBCgC4AU2AgwgACAINgIIIAAgBTYCBCAAQX42AgAgBxC7BAwBCyAEQbACaiIHELsEIARBlARqIAEoAgQgASgCCCAUEKwCEOcEIAEoAgQgASgCCCAIEOECIgUoAmwgBUHwAGooAgAQASAPKQIAIRcgBSAPKAIINgJ0IAUgFzcCbCAFKAJIIAVBzABqKAIAEAEgDikCACEXIAUgDigCCDYCUCAFIBc3AkggBSgCYCAFQeQAaigCABABIA0pAgAhFyAFIA0oAgg2AmggBSAXNwJgIAcgAiAIELQFIARB2AVqIAEgByAEEKMGIAQgCSkCADcDyAUgBCAJKAIINgLQBSAEKALYBSIFQX5HDQIgACAEKALQBTYCDCAAIAQp", + "A8gFNwIEIABBfjYCACAEKAKsBCAEKAKwBBABIAQoArgEIAQoArwEEAEgBCgCxAQgBCgCyAQQASAEKALQBCAEKALUBBAmIAQoAugEIAQoAuwEEAEgBCgCjAUgBCgCkAUQAQsgBEHQAGoQ1wQLIARBOGoQuwQMAwsgBCkC6AUhFyAMIAQoAtAFNgIIIAwgBCkDyAU3AgAgBCAXNwLABSAEIAU2ArAFIARB9AVqIAQoArwFIgUoAgwiCCAIIAUoAhBBAnRqEJsEIARBsAVqELsEIAQoAqwEIAQoArAEEAEgBCgCuAQgBCgCvAQQASAEKALEBCAEKALIBBABIAQoAtAEIAQoAtQEECYgBCgC6AQgBCgC7AQQASAEKAKMBSAEKAKQBRABIARB0ABqENcEIARBOGoQuwQMAwsgBCkCwAIhFyAJIAQoArgFNgIIIAkgBCkDsAU3AgAgBCAXNwLoBSAEIAc2AtgFIARBiARqIAQoAuQFIgcoAgwiFiAWIAcoAhBBAnRqEJsEIAVBBGohBSAEQdgFahC7BAwACwALCyAGIAsQ5gQgBCgC9AUgBCgC+AUQJiAEQQhqELsECyACELsEIARBgAZqJAAL4AQCCX8BfiMAQZABayIEJAAgBEH4AGogAy0A0QEgAygC3AEQsgUgBCgCfCEDAkACQCAEKAJ4IgVBf0cEQCAAIAQoAoABNgIMIAAgAzYCCCAAIAU2AgQgAEF+NgIADAELIAMtANEBIgVBBUYEQCAEQSRqIQUgBEH4AGoiBiACELsFIARBIGogASAGIAMoAtgBELkEIAQoAiAiBkF+RgRAIABBfjYCACAAIAUoAgg2AgwgACAFKQIANwIEDAILIAQgBCkCMDcCGCAEIAY2AgggBCAFKQIANwIMIAQgBSgCCCIFNgIUIAMoAtwBIQogBEH4AGogBSgCDCAFKAIQEIsDIAQoAoABQQJ0IQsgBCgCfCEFIAQoAnghBiAEQTxqIQggBEHkAGohCUEAIQMDQAJAIAMgC0cEQCAE", + "QfgAaiIHIARBCGoiDCADIAVqKAIAELQFIARB4ABqIAEgByAKELkEIAQgCSkCADcDUCAEIAkoAgg2AlggBCgCYCIHQX5HDQEgACAEKAJYNgIMIAAgBCkDUDcCBCAAQX42AgAgBSAGEOYEIAwQuwQMBAsgBSAGEOYEIAAgAikCEDcCECAAIAIpAgg3AgggACACKQIANwIAIARBCGoQuwQMBAsgBCkCcCENIAggBCgCWDYCCCAIIAQpA1A3AgAgBCANNwJIIAQgBzYCOCADQQRqIQMgBEE4ahC7BAwACwALIAQgBRDFBCAEIAQpAwA3AmAgBEECNgJ8IAQgBEHgAGo2AnggAEEEakHFx8AAIARB+ABqEAwgAEF+NgIACyACELsECyAEQZABaiQAC7gBAQd/IwBBEGsiAyQAIANBBGogAigCDCIEKAIMIAQoAhAQiwMgAygCDEECdCEGIAMoAgghBSADKAIEIQcgASgCCCEIIAEoAgQhCUEAIQFBACEEA0AgASAGRkUEQCAJIAggASAFaigCABDhAiIKQQA2AgggCiAENgKIASABQQRqIQEgBEEBaiEEDAELCyAFIAcQ5gQgACACKQIQNwIQIAAgAikCCDcCCCAAIAIpAgA3AgAgA0EQaiQAC4EBACMAQTBrIgEkAAJAIAIoAhAgAygCyAEgAygCzAEQkwYiAwRAIAFBDGogAiADEOoFDAELIAFBADYCLCABQoCAgIDAADcCJCABQQxqIAIgAUEkahC2BQsgACABKQIcNwIQIAAgASkCFDcCCCAAIAEpAgw3AgAgAhC7BCABQTBqJAALDQAgACABIAJBMhDvBQvCAQEBf0Gc4MIAIQFBCSEEAkACQAJAAkACQAJAAkACQCACKAIEIAIoAgggAxCsAigChAEiAg4JBgECBwMHBwcEAAsgAkEQRg0EIAJBIEcNBkGY4MIAIQFBBCEEDAYLQfnfwgAhAUEGIQQMBQtB/9/CACEBQQYhBAwEC0GF4MIAIQFBBiEEDAMLQYvg", + "wgAhAUEHIQQMAgtBkuDCACEBQQYhBAwBC0EBIQFBACEECyAAQePfwgBBBRAGIABBDGogASAEEAYLDQAgACABIAJBMxDvBQsRACAAIAEgAiADQSBBHBCQCAsNACAAIAEgAkE0EO8FCzoAIAIoAgQgAigCCCADEKwCLQCaASEBIABB49/CAEEFEAYgAEEMaiABQQJ0KALY6UMgAS0A1OlDEAYLtAEBBn8jAEEgayIDJAAgA0EANgIcIANCgICAgMAANwIUIANBCGogAigCDCIFKAIMIAUoAhAQiwMgAygCEEECdCEGIAMoAgwhBSADKAIIIQcgASgCCCEIIAEoAgQhAQNAIAQgBkcEQCABIAggBCAFaigCABCsAiIJKAIQBEAgA0EUaiAJKAIUEOACCyAEQQRqIQQMAQsLIAUgBxDmBCAAIAIgA0EUahC2BSACELsEIANBIGokAAuvAQEFfyMAQSBrIgMkACADQQA2AhwgA0KAgICAwAA3AhQgA0EIaiACKAIMIgUoAgwgBSgCEBCLAyADKAIQQQJ0IQYgAygCDCEFIAMoAgghBwNAIAQgBkZFBEAgA0EUaiABQQEgBCAFaigCACIIIAEoAgQgASgCCCAIEKwCLQCZARCeBhDgAiAEQQRqIQQMAQsLIAUgBxDmBCAAIAIgA0EUahC2BSACELsEIANBIGokAAvEAgIDfgd/IwBBIGsiByQAIAdBADYCHCAHQoCAgIDAADcCFCADKQMgIQQgAygCGCEDIAdBCGogAigCDCIIKAIMIAgoAhAQiwNCASAEIANBjYCAgHhHGyIFQgF8IQYgBygCDCIJIAcoAhBBAnRqIQwgBygCCCENIAEoAgghCiABKAIEIQsgCSEIA0AgCCAMRwRAIAgoAgAhAyAIQQRqIQggBSIEQgBTBH5CACEEIAMhAQNAIAsgCiABEKwCIgEoAghBAUdFBEAgBEIBfCEEIAEoAgwhAQwBCwsgBCAGfCIEQgAgBEIAVRsFIAQLQgF8IQQDQCAEQgF9", + "IgRQRQRAIAsgCiADEKwCIgEoAgwhAyABKAIIDQEMAwsLIAdBFGogAxDgAgwBCwsgCSANEOYEIAAgAiAHQRRqELYFIAIQuwQgB0EgaiQAC54DAQh/IwBBsAFrIgQkACAEQQA2AqwBIARCgICAgMAANwKkASAEQQhqIAIoAgwiAygCDCADKAIQEIsDIAQoAgwiBiAEKAIQQQJ0aiEJIAQoAgghCiAEQZQBaiEHIARBIGohCyAGIQMDQCADIAlGRQRAIAMoAgAhBSALQbDewgBBBRAGIARBADoAogEgBEIBNwI8IARCADcCNCAEQoCAgIAQNwIsIARCATcCbCAEQgA3AmQgBEKAgICAEDcCXCAEQgE3AlQgBEIANwJMIARCgICAgMAANwJEIARBADYCCCAEQQA2AhAgBEEANgIYIARBADYCfCAEQQA2ApABIARCgICAgBA3AnQgBEKAgICAEDcCgAEgBEIANwKIASAHQgA3AQYgB0IANwIAIAEgBEEIahDfAiEIQQBBARABA0AgASgCBCABKAIIIAUQrAIiBSgCCEEBR0UEQCABIAggBSgCDCIFEKsFDAELCyAEQaQBaiAIEOACIANBBGohAwwBCwsgBiAKEOYEIAAgAiAEQaQBahC2BSACELsEIARBsAFqJAALmAYBD38jAEGgAmsiBCQAIANBGGoQ0QUgBEEANgLAASAEQoCAgIDAADcCuAEgBEEcaiACKAIMIgcoAgwgBygCEBCLA0H///8HcSIDQYACcSEMIAQoAiAiCiAEKAIkQQJ0aiENIAQoAhwhDiADQQFxIQ8gA0GAgARJIRAgCiEHA0ACQAJAAkACQCAHIA1HBEAgBEEcaiABKAIEIAEoAgggBygCACILEKwCEOcEAkACQCAPRQRAIAwNAiAQRQ0BQQEhBUEAIQZBACEIDAcLIARB0AFqIAQoAnQgBCgCeBBCDAQLIARB0AFqIAQoAoABIAQoAoQBEEIMAwsgBCgCkAEiA0UNASAEQdABaiIJIAQoAowB", + "IANBABDgBEEAQQEQASAEKALQASEIIARBEGogBCgC1AEiBSAEKALYASIGQQoQHyAEKAIQIgNFDQQgCSADIAQoAhQQBiAIIAUQAQwDCyAKIA4Q5gQgACACIARBuAFqELYFIAIQuwQgBEGgAmokAA8LIARB0AFqIAQoAmggBCgCbBBCC0EAQQEQAQsgBCgC2AEhBiAEKALUASEFIAQoAtABIQgLIARBCGpBvLbDAEECIAUgBhCaAiAEKAIIIgMEQCAEQdABaiADIAQoAgwQBiAIIAUQASAEKALYASEGIAQoAtABIQggBCgC1AEhBQsgB0EEaiEHQQAhAyAEQQBBAUEBEAcgBEEANgLMASAEIAQpAwA3AsQBIARB0AFqIAUgBkG+tsMAQQMQWQNAIARBlAJqIARB0AFqEMoCIAQoApQCQQFHRQRAIAQoApgCIANrIQkgAyAFaiERIAQoApwCIQMgBEHEAWoiEiARIAkQCiASQZS0wwBBARAKDAELCyAEQcQBaiADIAVqIAYgA2sQCiAEKALEASAEKALMASEGIAQoAsgBIQMgCCAFEAEgASALQQJB49/CAEEFIAMgBhDsBSEFIAQtALUBBEAgASgCBCABKAIIIAUQ4QIiBiALNgIUIAZBATYCECAGQQA6AJkBCyAEQbgBaiAFEOACIAMQASAEQRxqEMIEDAALAAsNACAAIAEgAkE1EO8FCxEAIAAgASACIANBOEE0EJAICw0AIAAgASACQTYQ7wULEQAgACABIAIgA0EsQSgQkAgLDQAgACABIAJBNxDvBQskACAAQZzfwgBBBRAGIABBDGogAigCBCACKAIIIAMQ3gQQrAULDQAgACABIAJBOBDvBQtCACMAQRBrIgEkACAAQePfwgBBBRAGIAFBCGogAigCBCACKAIIIAMQwwcgAEEMaiABKAIIIAEoAgwQBiABQRBqJAALDQAgACABIAJBORDvBQskACAAQZzfwgBBBRAGIABBDGogAigCBCACKAIIIAMQ3wQQrAUL", + "+AMCDX8BfiMAQdABayIEJAAgBEEANgLMASAEQoCAgIDAADcCxAEgBEG4AWogAigCDCIDKAIMIAMoAhAQiwMgBCgCvAEiCSAEKALAAUECdGohDCAEKAK4ASENIAkhBgNAIAYgDEcEQEEAIQUgASAGKAIAIgNBAEGw3sIAQQVBAUEAEOwFIQogBEEEaiABIAMQvwYgBEEANgIYIARCgICAgMAANwIQIAZBBGohBiAEKAIIIgcgBCgCDEEEdCIOaiELIAQoAgQhDyAHIQMDQAJAAkACQCALIAUgDkYEfyALBSADKQMIIRECQCADKAIADgMDAgACCyAFIAdqQRBqCyIDa0EEdiEFA0AgBQRAIAVBAWshBSADEMQCIANBEGohAwwBCwsgDyAHEMAGIAEgCiAEKAIUIgMgBCgCGBDoBCAEQcQBaiAKEOACIAQoAhAgAxAmDAULIAUgB2pBBGooAgAgBEEcakHj38IAQQUgEaciECARQiCIpxDeAiAQEAEMAQsgBEG4AWogERDwBCAEQRxqQZzfwgBBBSAEKAK8ASIIIAQoAsABEN4CIAQoArgBIAgQAQsgA0EQaiEDIARBEGogASAEQRxqEN8CEOACIAVBEGohBQwACwALCyAJIA0Q5gQgACACIARBxAFqELYFIAIQuwQgBEHQAWokAAu/AwEFfyMAQSBrIgMkAAJ/AkACQCABKAIEIgUgASgCCCIGIAJBtO/CABC5AiIELQCZAUUEQCAEKAIQRQRAIANBAjYCAEEBDAQLIAUgBiAEKAIUQcTvwgAQuQIiBEEcaigCACAEQSBqKAIAQePfwgBBBRASDQEgA0EQaiAEQShqIgcoAgAgBEEsaiIEKAIAEPsFIAMCfyADKAIQRQRAIAMgAykDGDcDCEEADAELIANBBHIgBygCACAEKAIAEEIgAygCFCADKAIYEAFBAQs2AgAMAgsgA0EEciAEQShqKAIAIARBLGooAgAQQiADQQE2AgAMAQsgA0EEciAEQShqKAIAIARBLGoo", + "AgAQQiADQQE2AgALQQALIQQCQAJAAkAgBSAGIAJB6PPCABC5AiICKAIIQQFGBEAgBEUNAQwCCyAEDQFBCEEQEOUCIQEgAEEBNgIIIAAgATYCBCAAQQE2AgAgASADKQMINwMIIAEgAykDADcDAAwCCyADQRBqIgQgASACKAIMEL8GIAQgAxCrByAAIAMoAhg2AgggACADKQIQNwIADAELIABBADYCCCAAQoCAgICAATcCAAsgA0EgaiQACwwAIAAgAUEIQRAQMAu4CQIOfwF+IwBB4AlrIgQkACAEQfAHaiADLQDRASADKALcARCyBSAEKAL0ByEKAkACQCAEKALwByIDQX9HBEAgACAEKAL4BzYCDCAAIAo2AgggACADNgIEIABBfjYCAAwBCwJAAkAgCi0A0QEiA0EFRgRAIARBLGohAyAEQfAHaiIFIAIQvgUgBEEoaiABIAUgCigC2AEQuQQgBCgCKCIFQX5GBEAgAEF+NgIAIAAgAygCCDYCDCAAIAMpAgA3AgQMBAsgBCAEKQI4NwIgIAQgBTYCECAEIAMpAgA3AhQgBCADKAIIIgU2AhwgBSgCECIDQQFHDQEgBEHUAGohAyAEQdAAaiABKAIEIAEoAghB1LfDAEEHIAUoAgwoAgAQwgYgBCgCUARAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEDAMLIAQgAygCCCIGNgJIIAQgAykCADcDQCAEKAJEIQhBACEFIARBADsB9AcgBEEANgLwByAEQeAAaiAIIAYgBEHwB2oiBkEAEMMGIAYgAigCDCIGKAIMIAYoAhAQiwMgBCgC+AdBAnQhECAEKAL0ByEIIAQoAvAHIQwgBEG8BGohDSAEQZQGaiEGIARBxAJqIQ4CQAJAA0ACQCAFIBBHBEAgBEHwB2oiByACIAUgCGooAgAiCxDIBSAEQZAGaiABIAcgCigC3AEQuQQgBCAGKQIANwPYAiAEIAYoAgg2AuACIAQoApAGIgdBfkcNASAAIAQoAuAC", + "NgIMIAAgBCkD2AI3AgQgAEF+NgIADAQLIAggDBDmBCAAIAIpAhA3AhAgACACKQIINwIIIAAgAikCADcCACAEQeAAahDXBCADEMQGIARBEGoQuwQMCAsgBCkCoAYhEiAOIAQoAuACNgIIIA4gBCkD2AI3AgAgBCASNwLQAiAEIAc2AsACIAQoAswCIgcoAhAiCUEBRgRAIAcoAgwoAgAhByAEQbgEaiIRQQgQzQQgBEGQBmoiDyAEQeAAahDFBiAEQfAHaiIJIAcQxgYgBEIANwPICSAEQdgCaiIHIBEgDyAJEMcGIAkgAiALELQFIA8gASAJIAcQ3QQgBCAGKQIANwPQCSAEIAYoAgg2AtgJIAQoApAGIgtBfkYEQCAAIAQoAtgJNgIMIAAgBCkD0Ak3AgQgAEF+NgIAIAcQ1wQMAwsgBCkCoAYhEiANIAQoAtgJNgIIIA0gBCkD0Ak3AgAgBCASNwLIBCAEIAs2ArgEIAVBBGohBSAEQbgEahC7BCAEQdgCahDXBCAEQcACahC7BAwBCwsgBCAJNgKQBiAEQQQ2AvQHIAQgBEGQBmo2AvAHIABBBGpBhY7AACAEQfAHahAMIABBfjYCAAsgBEHAAmoQuwQLIAggDBDmBCAEQeAAahDXBCAEQUBrEMQGDAILIARBCGogAxDFBCAEIAQpAwg3ApAGIARBAjYC9AcgBCAEQZAGajYC8AcgAEEEakH1x8AAIARB8AdqEAwgAEF+NgIADAILIAQgAzYCkAYgBEEENgL0ByAEIARBkAZqNgLwByAAQQRqQcfFwAAgBEHwB2oQDCAAQX42AgALIARBEGoQuwQLIAIQuwQLIARB4AlqJAAL3wQCBH8BfiMAQeAAayIGJAAgBiAENgIIIAYgAzYCBAJAAkACQCABIAIgBRCsAi0AmgFFBEAgBkEANgIUIAZCgICAgIABNwIMIAEgAiAFEKwCIgMoAkRBAnQhBCADKAJAIQMgBkHIAGpBBHIhCQNAAkACQAJAIAQEQCABIAIg", + "AygCABCsAiIFKAIcIgcgBSgCICIIQePfwgBBBRASDQEgByAIQZzfwgBBBRASDQIgBiAINgIsIAYgBzYCKCAGQQI2AlQgBkECNgJMIAYgBkEoajYCUCAGIAZBBGo2AkggAEEEakHbyMAAIAZByABqEAwMBwsgACAGKAIUNgIMIAAgBikCDDcCBCAAQQA2AgAMBwsgCSAFQShqKAIAIAVBLGooAgAQQiAGQQE2AkgMAQsgBkEoaiAFKAIoIAUoAiwQ+wUgBigCKA0DIAYpAzAhCiAGQQA2AkggBiAKNwNQCyAGQQxqIAZByABqEKsHIANBBGohAyAEQQRrIQQMAAsACyABIAIgBRCsAiEBIAZBAzYCVCAGIAFBGGo2AlAgBkECNgJMIAYgBkEEajYCSCAAQQRqQYPGwAAgBkHIAGoQDCAAQQE2AgAMAgsgBiAGKAI0NgJAIAYgBikCLDcDOCAGQQM2AlwgBkEDNgJUIAYgBUEkajYCUCAGQQI2AkwgBiAGQThqNgJYIAYgBkEEajYCSCAGQRhqQQRyQeiRwAAgBkHIAGoQDCAGKAI4IAYoAjwQASAGKAIcIQEgACAGKQMgNwIIIAAgATYCBAsgAEEBNgIAIAZBDGoQxAYLIAZB4ABqJAALnQMCBH8BfiMAQbAFayIFJAACQAJAAkACQCACDgIAAgELIABB5wAQzQQgAEIANwPYAQwCCyAFQRhqIgdBHxDNBCAFIAMvAAQ7AdQDIAUgAygAADYC0AMgBUHwAWoiCCABQQEgBUHQA2oiBkEAEMMGIAVBASABIAJB/JnDABC/ByAGIAUoAgAgBSgCBCADIAQQwwYgACAHIAggBhDHBgwBCyAEBEAgA0EBOgADIANBAToAAQsCQCABKAIAQQFGBEAgBUHQA2ogAUEIaigCACIEIAFBDGooAgAiBhBCIAU1AtgDIQkgBSgC1AMhASAFKALQAyECIAVBDGogBCAGEEIMAQsgBUEMaiABKQMIIgkQ8ARBgICAgHghAgsgAEEC", + "NgIoIABBgYCAgHg2AhggACAJNwMQIAAgATYCDCAAIAI2AgggAEEANgIAIAAgAy8ABDsBICAAIAMoAAA2AhwgBSAFKQIMNwLoBCAFIAUoAhQ2AvAEIABBLGogBUHQA2pBpAH8CgAAIABCADcD2AEgAEGAygE7AdABCyAFQbAFaiQACzsBA38gACgCCCEBIAAoAgQiAyECA0AgAQRAIAFBAWshASACEMQCIAJBEGohAgwBCwsgACgCACADEMAGCy0BAX8gACABEM8GIAFB2AFqEIQGIQIgACABQdwBahCEBjYC3AEgACACNgLYAQuYAQEBfyMAQeABayICJAAgAkEIakHpABDNBCAAIAItANkBOgDRASAAIAIpAxA3AwggACACKQMYNwMQIAAgAikCzAE3AsQBIAAgAigC1AE2AswBIABBKGogAkEwakGcAfwKAAAgACABNgIEIABBATYCACAAIAIpAyA3AxggACACKQMoNwMgIAAgAi0A2AE6ANABIAJB4AFqJAALRQEBf0EIQeABEOUCIgQgAkHgAfwKAABBCEHgARDlAiICIANB4AH8CgAAIAAgAUHYAfwKAAAgACACNgLcASAAIAQ2AtgBC9IIAgp/AX4jAEGABmsiBCQAIARBgARqIgUgAhC+BSAEQRxqIAEgBSADKALcARC5BCAEQSBqIQMCQAJAAkAgBCgCHCIFQX5GBEAgAEF+NgIAIAAgAygCCDYCDCAAIAMpAgA3AgQMAQsgBCAEKQIsNwIUIAQgBTYCBCAEIAMpAgA3AgggBCADKAIIIgM2AhACQCADKAIQIgVBAUYEQCABKAIEIAEoAgggAygCDCgCACIDEKwCIgVBHGooAgAgBUEgaigCAEGw3sIAQQUQsQJFBEAgBCACKQIQNwP4BSAEIAIpAgg3A/AFIAQgAikCADcD6AUgBEGABGogASgCBCABKAIIIAMQrAIiAkFAaygCACACQcQAaigCABCLAyAEKAKIBEECdCEMIAQoAoQEIQMgBCgCgAQh", + "CCAEQegFakEEciEKIARBhARqIQVBACECA0ACQAJAAkACQCACIAxHBEAgAiADaigCACEGIAQgCTYCNCABKAIEIAEoAgggBhCsAiIHQRxqKAIAIAdBIGooAgBBsN7CAEEFELECDQIgBEGABGogASgCBCABKAIIQdu3wwBBCCAGEMIGIAQgBSkCADcDSCAEIAUoAgg2AlAgBCgCgARFDQEgACAEKAJQNgIMIAAgBCkDSDcCBAwDCyADIAgQ5gQgACAEKQP4BTcCECAAIAQpA/AFNwIIIAAgBCkD6AU3AgAgBEEEahC7BAwKCyAEIAQoAlA2AkAgBCAEKQNINwM4IARBqAJqIg1B9gAQzQQgBCgCPCEGIAQoAkAhByAEQQA7AeQFIARBADYC4AUgBEGABGoiCyAGIAcgBEHgBWpBABDDBkEIQeABEOUCIgYgC0HgAfwKAAAgBEHIAGoiByANQdgB/AoAACAEIAY2AqQCIARBADYCoAIgCyABIARB6AVqIAcQ3QQgBCAFKQIANwOoAiAEIAUoAgg2ArACIAQoAoAEIgZBfkcNAiAAIAQoArACNgIMIAAgBCkDqAI3AgQgAEF+NgIAIAcQ1wQgBEE4ahDEBiADIAgQ5gQMCAsgASgCBCABKAIIIAYQrAIhASAEQQM2AowEIAQgAUEYajYCiAQgBEEENgKEBCAEIARBNGo2AoAEIABBBGpB0srAACAEQYAEahAMCyAAQX42AgAgAyAIEOYEIARB6AVqELsEDAYLIAQpApAEIQ4gCiAEKAKwAjYCCCAKIAQpA6gCNwIAIAQgDjcD+AUgBCAGNgLoBSAJQQFqIQkgAkEEaiECIARByABqENcEIARBOGoQxAYMAAsACyABKAIEIAEoAgggAxCsAiEBIARBAzYChAQgBCABQRhqNgKABCAAQQRqQbiOwAAgBEGABGoQDAwBCyAEIAU2AkggBEEENgKEBCAEIARByABqNgKABCAAQQRqQdiNwAAgBEGABGoQDAsgAEF+NgIAIARB", + "BGoQuwQLIAIQuwQMAQsgBEEEahC7BAsgBEGABmokAAvoAwINfwF+IwBB4ABrIgQkACABLQA0IARByABqIAIoAgwiBigCDCAGKAIQEIsDIAQoAkwiBiAEKAJQQQJ0aiEMIAQoAkghCCAEQQxqIQkgBEE0aiEKIAMoAtwBIQ1BAXEhDiAGIQUCQANAAkACQCAFIAxHBEAgBEHIAGoiAyACIAUoAgAQtAUgBEEwaiABIAMgDRC5BCAEIAopAgA3AyAgBCAKKAIINgIoIAQoAjAiA0F+Rw0BIAAgBCgCKDYCDCAAIAQpAyA3AgQgAEF+NgIADAILIAYgCBDmBCAAIAIpAhA3AhAgACACKQIINwIIIAAgAikCADcCAAwDCyAFQQRqIQUgBCkCQCERIAkgBCgCKDYCCCAJIAQpAyA3AgAgBCARNwIYIAQgAzYCCCAEQcgAaiAEKAIUIgMoAgwgAygCEBCLAyAEKAJQQQJ0IQ8gBCgCTCEHIAQoAkghC0EAIQMDQAJAIAMgD0cEQCAEQcgAaiABIAMgB2ooAgAgDhDhBCAEKAJIIhBBf0YNASAAIAQpAkw3AgggACAQNgIEIABBfjYCACAHIAsQ5gQgBEEIahC7BAwDCyAHIAsQ5gQgBEEIahC7BAwDCyADQQRqIQMMAAsACwsgBiAIEOYEIAIQuwQLIARB4ABqJAAL9A0CEn8BfiMAQaABayIEJAAgBEEANgKcASAEQoCAgIDAADcClAEgBEEYaiACEIYGIARBIGogBCgCGCAEKAIcEAYgBEH4AGogAigCDCIFKAIMIAUoAhAQiwMgBCgCfCIOIAQoAoABQQJ0aiEUIAQoAnghECAEQTxqIREgBEHkAGohEiADKALcASEVIA4hDQJAA0ACQAJAIA0gFEcEQCABKAIEIAEoAgggDSgCACIMQYTywgAQuQItAJoBQQJJDQEgBEHgAGoiAyABIAwQ/QUgASgCBCABKAIIIAwQrAIhASAEQQM2AoQBIAQgAUEYajYCgAEgBEED", + "NgJ8IAQgAzYCeCAAQQRqQcTQwAAgBEH4AGoQDCAEKAJgIAQoAmQQASAAQX42AgAMAgsgDiAQEOYEIAAgAiAEQZQBahC2BSAEKAIgIAQoAiQQAQwDCyAEQQA2AjQgBEKAgICAwAA3AiwCQAJAAkACQCABKAIEIAEoAgggDEH08cIAELkCIgUtAJoBDgIBAgALIARBADYCWCAEQoCAgIDAADcDUAwCCyAEQdAAaiAFQUBrKAIAIAVBxABqKAIAEIsDDAELIARCgYCAgBA3AmggBCAFKAJAIgM2AmAgBCADIAUoAkRBAnRqNgJkIARBAToAcCAEQfgAaiIGIARB4ABqIgMQmAQCQAJAIAQoAnxBAUYEQCAEQRBqIAQoAoABQQRBBBAHIARBADYCQCAEIAQpAxA3AjggBiADEJgEIAQoAnxBAUYEQCAEQThqIAQoAoABEJcEIAQoAkAhCCAEKAI8IQUgBCAEKAJwIgM2AogBIAQgBCkCaDcDgAEgBCAEKQJgNwN4IANBAXFFDQIgBEEAOgCIASAGEJkEIgNFDQMgBSAIQQJ0aiADKAIANgIAIAhBAWohCAwCC0HQ28IAQSNB5NvCABA1AAtB0NvCAEEjQbDbwwAQNQALIAUgCEECdGohCyAEKAJ4IQcgBCgCgAEhAyAEKAJ8IQogBCgChAEhBQNAAkACQCADBEAgAyAFaiIGIANPDQEgA0EBayIDIAogB2tBAnZPDQIgByADQQJ0akEEaiEHCyAFIQYLIAYgCiAHa0ECdk8NACALIAcgBkECdGoiAygCADYCACALQQRqIQsgCEEBaiEIIANBBGohB0EAIQMMAQsLIAQgCDYCQAsgBCAEKQI4NwNQIAQgBCgCQDYCWAsgDUEEaiENIAQoAlhBAnQhCSAEKAJUIQ8gBCgCUCETQQQhC0EMIQdBACEDQQAhBgNAAkACQCADIAlHBEAgBEH4AGoiBSACIAMgD2ooAgAiCBDIBSAEQeAAaiABIAUgFRC5BCAEIBIpAgA3A1Ag", + "BCASKAIINgJYIAQoAmAiBUF+Rw0BIAAgBCgCWDYCDCAAIAQpA1A3AgQgAEF+NgIAIA8gExDmBCAEQSxqEJ4EDAQLIA8gExDmBCAEKAIwIQMgBCgCNCEFIAQgATYCeCAEIARBIGo2AnwgBCAEQfgAajYCYCAFQQJJDQEgBUEVTwRAIARB4ABqIQgjAEGQIGsiCSQAAkBBoMIeIAUgBUGgwh5PGyIKIAUgBUEBdmsiBiAGIApJGyIGQYECTwRAIAlBCGogBkEEQRAQByAJQQA2AhggCSAJKAIMIgo2AhQgCSAJKAIIIgY2AhAgAyAFIAogBiAFQcEASSAIEJ0EIAlBEGoQngQMAQsgAyAFIAlBEGpBgAIgBUHBAEkgCBCdBAsgCUGQIGokAAwCCyAFQQR0IQpBECEGA0AgBiAKRg0CIAMgAyAGaiAEQfgAahCnBCAGQRBqIQYMAAsACyAEKQJwIRYgESAEKAJYNgIIIBEgBCkDUDcCACAEIBY3AkggBCAFNgI4IARB+ABqIAQoAkQiBSgCDCAFKAIQEIsDIAQoAiwgBkYEQCAEQSxqENADIAQoAjAhCwsgBCkCeCEWIAQoAoABIQogByALaiIFIAg2AgAgBUEMayIFIAo2AgggBSAWNwIAIAQgBkEBaiIGNgI0IANBBGohAyAHQRBqIQcgBEE4ahC7BAwBCwsgASAMEPwFIQYCQAJAAkAgASgCBCABKAIIIAwQrAItAJoBDgIAAQILIAVBBHQhBwNAIAdFDQIgASAGIAMoAgwQqwUgB0EQayEHIANBEGohAwwACwALIAVBBHQhByADQQxqIQMDQCAHRQ0BIAEoAgQgASgCCCADKAIAEKwCIgUoAhBBAUYEQCAEQQhqIAEgBiAFKAIUIAMoAgAQ6QQLIAdBEGshByADQRBqIQMMAAsACyAEQZQBaiAGEOACIARBLGoQngQMAQsLIA4gEBDmBCAEKAIgIAQoAiQQASAEKAKUASAEKAKYARAmCyACELsEIARBoAFqJAAL", + "9wUCEH8BfiMAQYABayIEJAAgBEEANgJ8IARCgICAgMAANwJ0IARB3ABqIAIoAgwiBigCDCAGKAIQEIsDIAQoAmAiCSAEKAJkQQJ0aiEQIAQoAlwhCyAEQSRqIQwgBEHIAGohCCAEQQxqIQ0gAygC3AEhDiAJIQMCQANAAkACQAJAIAMgEEcEQCADQQRqIQYgAygCACEFIA5FDQEgBEHcAGoiAyACIAUQtAUgBEEAOwE8IARBADYCOCAEQcQAaiABIAMgBEE4ahD2BSAEIAgpAgA3AyAgBCAIKAIINgIoIAQoAkQiA0F+Rw0CIAAgBCgCKDYCDCAAIAQpAyA3AgQgAEF+NgIADAMLIAkgCxDmBCAAIAIgBEH0AGoQtgUMBAsgBiEDIAEoAgQgASgCCCAFEKwCIgYoAkRFDQIgBEH0AGogBigCQCgCABDgAgwCCyAEKQJUIRQgDSAEKAIoNgIIIA0gBCkDIDcCACAEIBQ3AhggBCADNgIIIARB3ABqIAQoAhQiAygCDCADKAIQEIsDIAQoAmAiCiAEKAJkQQJ0aiERIAQoAlwhDyAKIQUDQAJAIAUgEUcEQCAEQdwAaiIDIAIgBSgCACISELQFIARBxABqIAEgAyAOEN0EIAQgCCkCADcDOCAEIAgoAgg2AkAgBCgCRCIDQX5GBEAgACAEKAJANgIMIAAgBCkDODcCBCAAQX42AgAgCiAPEOYEIARBCGoQuwQMBAsgBUEEaiEFIAQpAlQhFCAMIAQoAkA2AgggDCAEKQM4NwIAIAQgFDcCMCAEIAM2AiAgBCgCLCIHKAIQQQJ0IQMgBygCDCEHA0AgA0UNAiADQQRrIQMgBygCACETIAdBBGohByABKAIEIAEoAgggExCsAhC4AkUNAAsgBEH0AGogEhDgAiAEQSBqELsECyAKIA8Q5gQgBEEIahC7BCAGIQMMAwsgBEEgahC7BAwACwALCyAJIAsQ5gQgBCgCdCAEKAJ4ECYLIAIQuwQgBEGAAWokAAuHAwEHfyMA", + "QTBrIgMkACADQQA2AiwgA0KAgICAwAA3AiQgA0EUaiACKAIMIgQoAgwgBCgCEBCLAyADKAIcQQJ0IQogAygCGCEIIAMoAhQhCQJAAkADQCAFIApHBEAgASgCBCIGIAEoAggiByAFIAhqKAIAIgQQrAItAJoBDQIgASAEIAYgByAEEKwCKAKEARChBiEGIANBFGogASgCBCABKAIIIAQQrAIiBEFAaygCACAEQcQAaigCABCLAyADKAIYIgQgAygCHCIHEM0GIAEgBiAEIAcQ6AQgA0EkaiAGEOACIAMoAhQgBBAmIAVBBGohBQwBCwsgCCAJEOYEIAAgAiADQSRqELYFDAELIANBCGoiBSABIAQQ/QUgBiAHIAQQrAIhASADQQM2AiAgAyABQRhqNgIcIANBAzYCGCADIAU2AhQgAEEEakGV0MAAIANBFGoQDCADKAIIIAMoAgwQASAAQX42AgAgCCAJEOYEIAMoAiQgAygCKBAmCyACELsEIANBMGokAAvgAQEHfyMAQRBrIgIkACACIAAgAUEBdiIDIANBxN3CABC6ByACKAIEIQUgAigCACEEIAIgACABQQJ0aiADQQJ0IgBrIAMgA0HU3cIAELoHIAAgAigCAGpBBGshAEEAIQEgAigCBCIHIANBAWtLIQgCQAJAA0AgASADaiIGRQ0BIAEgBWpFDQIgCARAIAQoAgAhBiAEIAAoAgA2AgAgACAGNgIAIARBBGohBCAAQQRrIQAgAUEBayEBDAELCyAGQQFrIAdB9N3CABAqAAsgAkEQaiQADwsgBSAFQeTdwgAQKgALawEDfyMAQcADayIEJAAgBEEIaiIFIAMQzwYgBEHoAWoiBkHnABDNBEEIQeABEOUCIgMgBkHYAfwKAAAgA0IANwPYASAEIAM2AuQBIARBADYC4AEgACABIAIgBRDKBiAFENcEIARBwANqJAALngIBBH8jAEEQayICJAAgAS0A0QEhBAJAAkACQAJAAkACQCABKAIIIgNBH3UgA0H/", + "////B2txQQFrDgQBAgMEAAsgAiABKAIMIAEoAhAQQgwECyACQYCAgIB4NgIAIAIgASkDEDcDCAwDCyACQYGAgIB4NgIAIAIgASsDEDkDCAwCCyACQYKAgIB4NgIAIAIgAS0ADDoABAwBCyACQYOAgIB4NgIACyAAQcQBaiABKALIASABKALMARBCIABBKGogAUEoahCEByABKAIAIQMgASgCBCEFIABBGGogAUEYahDCByAAIAQ6ANEBIAAgBTYCBCAAIAM2AgAgACACKQMANwMIIAAgAikDCDcDECAAIAEtANABOgDQASACQRBqJAAL3AoCF38BfiMAQYABayIEJAAgBEE4aiACKAIMIgYoAgwgBigCEBCLAyAEKAI8IgwgBCgCQEECdGohFyAEKAI4IQ8gBEEMaiEQIARBJGohESADKALcASEYIAwhCgNAAkACQCAKIBdHBEAgBEE4aiIDIAIgCigCABDIBSAEQSBqIAEgAyAYELkEIAQgESkCADcDaCAEIBEoAgg2AnAgBCgCICIDQX5HDQIgACAEKAJwNgIMIAAgBCkDaDcCBCAAQX42AgAgDCAPEOYEIAIQuwQMAQsgDCAPEOYEIAAgAikCEDcCECAAIAIpAgg3AgggACACKQIANwIACyAEQYABaiQADwsgCkEEaiEKIAQpAjAhGyAQIAQoAnA2AgggECAEKQNoNwIAIAQgGzcCGCAEIAM2AgggBEE4aiAEKAIUIgMoAgwgAygCEBCLAyAEKAI8IhIgBCgCQEECdGohGSAEKAI4IRogEiELA0ACQCALIBlHBEAgCygCACENIAtBBGohCyABKAIEIAEoAgggDRCsAi0AmgFBAUcNAiAEQdAAaiABKAIEIAEoAgggDRCsAiIDQUBrKAIAIANBxABqKAIAEIsDQQAhAyAEQQA2AmQgBEKAgICAwAA3AlwgBCgCVCEOIAQoAlghBgNAIAYgA0EBaiIFTQRAIARBADYCcCAEQoCAgIDAADcCaCAEKAJcIQMgBCAE", + "KAJgIgUgBCgCZEEUbGoiCDYCLCAEIAM2AiggBCAFNgIgA0AgBSAIRgRAIAQoAmwhAwwFCyAFQRRqIQYgBCgCbCEDIAUoAgAiE0F/RgRAIAYhCAwFCyAEKAJwQRRsIQkgA0EIaiEHIAUoAhAhFCAFKAIMIRUgBSgCCCEWIAUoAgQhBQJAA0AgByEDIAlFDQEgCUEUayEJIANBFGohByADQQRrKAIAIAMoAgAgBSAWEJYDRQ0ACyADQQhrIgMgFDYCECADIBU2AgwgEyAFEAEgBiEFDAELIAQgFDYCSCAEIBU2AkQgBCAWNgJAIAQgBTYCPCAEIBM2AjggBEHoAGogBEE4ahCnAyAGIQUMAAsABSAOIAYgA0HYscMAECEhByAEQThqIgggASgCBCABKAIIIAcoAgAiBxCsAiIJQShqKAIAIAlBLGooAgAQQiAEIA4gBiAFQeixwwAQISgCADYCSCAEIAc2AkQgA0ECaiEDIARB3ABqIAgQpwMMAQsACwALIBIgGhDmBCAEQQhqELsEDAILIAQgCDYCJCAEQSBqENEGAkAgBCgCcCIGQQJJDQAgBkEVTwRAIwBBkCBrIgUkAAJAQYC1GCAGIAZBgLUYTxsiByAGIAZBAXZrIgggByAISxsiB0HNAU8EQCAFQQhqIAdBBEEUEAcgAyAGIAUoAgwiByAFKAIIIgggBkHBAEkQqQQgCCAHEKoEDAELIAMgBiAFQRBqQcwBIAZBwQBJEKkECyAFQZAgaiQADAELQRQhByAGQRRsIQUDQCAFIAdGDQEgAyADIAdqEK8EIAdBFGohBwwACwALIARBADYCfCAEQoCAgIDAADcCdCAEIAQoAmg2AkAgBCADNgI4IAQgAyAGQRRsIglqNgJEAkADQCAJRQ0BIAMoAgAiBkF/RwRAIANBBGooAgAhBSADQRBqKAIAIQcgBEH0AGoiCCADQQxqKAIAEOACIAggBxDgAiAGIAUQBSAJQRRrIQkgA0EUaiEDDAELCyADQRRqIQMLIAQg", + "AzYCPCAEQThqENEGIAEoAgQgASgCCCANEOECIgMoAjwgA0FAaygCABAmIAMgBCgCfDYCRCADIAQpAnQ3AjwgBCgCUCAOECYMAAsACwALSgECfyAAKAIMIAAoAgQiAWtBFG4hAgNAIAIEQCABKAIAIAFBBGooAgAQASACQQFrIQIgAUEUaiEBDAELCyAAKAIIIAAoAgAQqgQLvAYBDH8jAEGAAWsiBCQAIARBLGoiBSACEL4FIARBFGogASAFIAMoAtwBELkEIARBGGohAwJAIAQoAhQiBUF+RgRAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEDAELIAQgBCkCJDcCPCAEIAU2AiwgBCADKQIANwIwIAQgAygCCCIDNgI4An8gAygCEARAIARBxABqIAEoAgQgASgCCCADKAIMKAIAEKwCIgNBKGooAgAgA0EsaigCABBCIAQoAkwhDCAEKAJIDAELIARBADYCTCAEQoCAgIAQNwJEQQELIQcgBEEANgJkIARCgICAgMAANwJcIARB9ABqIAIoAgwiAygCDCADKAIQEIsDIAQoAngiCCAEKAJ8QQJ0aiEOIAQoAnQhDSAIIQUCQANAIAUgDkYNASABKAIEIAEoAgggBSgCACIJEKwCLQCaAUUEQCABKAIEIAEoAgggCRCsAiIDKAJAIQogBEEIaiADKAJEIgZBBEEMEAcgBEEANgJwIAQgBCkDCDcCaCAEQegAaiAGEKMBIAQoAnAhAyAGBEAgAyAGaiAEKAJsIANBDGxqIQMDQAJAIAEoAgQgASgCCCAKKAIAEKwCIgtBHGooAgAgC0EgaigCAEGl4MIAQQYQEkUEQCAEQfQAaiALQShqKAIAIAtBLGooAgAQQgwBCyAEQQA2AnwgBEKAgICAEDcCdAsgAyAEKAJ8NgIIIAMgBCkCdDcCACAKQQRqIQogA0EMaiEDIAZBAWsiBg0ACyEDCyAFQQRqIQUgBCAEKQJoNwNQIAQgAzYCWCAEQfQAaiAEKAJUIAMg", + "ByAMEKcCIARB3ABqIAEgCUECQePfwgBBBSAEKAJ4IgMgBCgCfBDsBRDgAiAEKAJ0IAMQASAEQdAAahDxAgwBCwsgASgCBCABKAIIIAkQrAIhASAEQQM2AnggBCABQRhqNgJ0IABBBGpBnJnAACAEQfQAahAMIABBfjYCACAIIA0Q5gQgBCgCXCAEKAJgECYgBCgCRCAHEAEgBEEsahC7BAwBCyAIIA0Q5gQgACACIARB3ABqELYFIAQoAkQgBxABIARBLGoQuwQLIAIQuwQgBEGAAWokAAvrFgIZfwN+IwBBsARrIgQkACAEQfgCaiADLQDRASADKALcARCyBSAEKAL8AiEIAkAgBCgC+AIiA0F/RwRAIAAgBCgCgAM2AgwgACAINgIIIAAgAzYCBCAAQX42AgAMAQsgBEH4AmoiAyACEL4FIARBkAJqIAEgAyAIKALYARC5BCAEIAQpApQCNwPQAyAEIAQoApwCNgLYAyAEKAKQAiIDQX5GBEAgACAEKALYAzYCDCAAIAQpA9ADNwIEIABBfjYCAAwBCyAEIAQpA9ADNwKYASAEIAQoAtgDIgY2AqABIAQgBCkCoAI3AqQBIAQgAzYClAECQCAGKAIQBEAgBEGsAWogASgCBCABKAIIIAYoAgwoAgAQrAIiA0EoaigCACADQSxqKAIAEEIMAQsgBEEANgK0ASAEQoCAgIAQNwKsAQsgBEH4AmoiAyACELsFIARBkAJqIAEgAyAIKALcARC5BCAEIAQpApQCNwPQAyAEIAQoApwCNgLYAwJAIAQoApACIgNBfkYEQCAAIAQoAtgDNgIMIAAgBCkD0AM3AgQgAEF+NgIAIAQoArABIRIMAQsgBCAEKQPQAzcCvAEgBCAEKALYAyIGNgLEASAEIAQpAqACNwLIASAEIAM2ArgBAkAgBigCEARAIARB0AFqIAEoAgQgASgCCCAGKAIMKAIAEKwCIgNBKGooAgAgA0EsaigCABBCDAELIARBADYC2AEgBEKAgICAEDcC", + "0AELIARB+AJqIAQoArABIhIgBCgCtAEQ1AYgBCAEKQL8AjcDkAIgBCAEKAKEAzYCmAICQCAEKAL4AiIDRQRAIAAgBCgCmAI2AgwgACAEKQOQAjcCBCAAQX42AgAMAQsgBCAEKAKQAzYC9AEgBCAEKQKIAzcC7AEgBCAEKQOQAjcC4AEgBCAEKAKYAjYC6AEgBCADNgLcASAEQQA2AowCIARCgICAgMAANwKEAiAEQfgCaiACKAIMIgMoAgwgAygCEBCLAyAEKAL8AiITIAQoAoADQQJ0aiEYIAQoAvgCIRYgBEGkBGohGSAEQdgDaiEUIARB1ANqIQ0gBEG8A2ohFSAEQcwCaiEOIBMhDwNAAkAgDyAYRwRAIARB+AJqIgggASAPKAIAIgUQrQIgBCgC/AIiBiAEKAKAA0Hj38IAQQUQsQIgBCgC+AIgBhABRQ0BIAEoAgQgASgCCCAFEKwCIQEgBEEDNgL8AiAEIAFBGGo2AvgCIABBBGpBs8DAACAIEAwgAEF+NgIAIBMgFhDmBCAEKAKEAiAEKAKIAhAmIARB3AFqENUGDAMLIBMgFhDmBCAAIAIgBEGEAmoQtgUgBEHcAWoQ1QYgBCgC0AEgBCgC1AEQASAEQbgBahC7BCAEKAKsASASEAEgBEGUAWoQuwQMBAsgBEH4AWogASgCBCABKAIIIAUQrAIiA0EoaigCACADQSxqKAIAEEIgBEGQAmoiAyAEQdwBaiAEKAL8ASIQIAQoAoACIgsQ1gYgBEF+NgLQAiAEQQA2AsgCIARB+AJqIgYgAxDXBiAOIAQoApADNgIYIA4gBCkCiAM3AhAgDiAEKQKAAzcCCCAOIAQpAvgCNwIAIA9BBGohDyAEQYQCaiABIAVBAkHj38IAQQUCfwJAIAQoAtACQX9HBEAgBEHsAmogCxDeAyAGIANB2AD8CgAAQQAhBSAEKALYASEaIAQoAtQBIRsDQCAEKAK4AyEDIARBfjYCuAMCQCADQX5HBEAgBCgCtAMhBiAUIBUp", + "AgA3AgAgFCAVKQIINwIIIBQgFSgCEDYCECAEIAM2AtQDIAQgBjYC0AMMAQsgBEHQA2ogBEH4AmoQ1wYgBCgC1AMhAwsgA0F/Rg0CIAQoAugDIQwgBEGcBGogDUEAENgGIAQoApwEBEAgBCgCqAQhHCAEQYgBaiAQIAsgBSAEKAKkBEGw2sIAENYBIARB7AJqIAQoAogBIAQoAowBEAogBEEANgL4AyAEQoCAgIAQNwLwAyAaIQggGyEGA0AgBEGAAWogBiAIQSQQ4wICQAJAAkAgBCgCgAFBAUYEQCAEQfgAaiAEKAKEASIDIAYgCEHUz8MAEOQCIARB8ANqIAQoAnggBCgCfBAKIARB8ABqIANBAWogBiAIQeTPwwAQvwIgBCgCcCIFIAQoAnQiA0EkEJcCDQEgBEHoAGogBSADQfsAEB4CQCAEKAJoIgcEQCAEQeAAaiAHIAQoAmwiCEH9ABDjAiAEKAJgQQFxRQ0BIARB2ABqIAQoAmQiBiAHIAhB9M/DABDkAiAEKAJcIQkgBCgCWCEKIARB0ABqIAZBAWogByAIQYTQwwAQvwIgBCgCVCEIIAQoAlAhBgwECyAEQQA2AqwEIAQgBTYCpAQgBCAFNgKcBCAEIAM2AqAEIAQgAyAFajYCqAQDQAJAIARByABqIBkQlQIgBCgCTCIGQX9GBEAgAyEHDAELIAQoAkghByAGENkGIAZB3wBGcg0BCwsgBEFAayAHIAUgA0GU0MMAEOQCIAQoAkQhCSAEKAJAIQogBEE4aiAHIAUgA0Gk0MMAEL8CIAQoAjwhCCAEKAI4IQYMAwsMAwsgBEHwA2ogBiAIEAogBCgC8AMgBEHsAmogBCgC9AMiAyAEKAL4AxAKIAMQASANENoGIBwhBQwFCyAEQfADakEkENcCIARBEGpBASAFIANBtNDDABC/AiAEKAIUIQggBCgCECEGDAILAkACQCAJBEAgCi0AACEDAkAgCUEBRw0AIANBK2sOAwMAAwALIAogA0ErRiIDaiEF", + "IAkgA2siA0EJTwRAQQAhBwNAIANFDQMgB61CCn4iHUIgiKcNBCAEQTBqIAUtAABBChAWIAQoAjBBAUcNBCAFQQFqIQUgA0EBayEDIB2nIhEgBCgCNGoiByARTw0ACwwDC0EAIQcDQCADRQ0CIARBKGogBS0AAEEKEBYgBCgCKEEBRw0DIAVBAWohBSADQQFrIQMgBCgCLCAHQQpsaiEHDAALAAsMAgsgBEH8A2oiAyANIAcQ2AYgBCgC/ANFDQIgBEEYaiADENsGIARB8ANqIAQoAhggBCgCHBAKDAILIAQoAtwBIgNB0ABqKAIAQQN0IQUgA0HMAGooAgAhAwNAIAVFDQICQCADKAIAIgdFDQAgB0EIaiADQQRqKAIAIAogCRASRQ0AAkAgDCgCHEUNACAMKQMgIAwpAyggCiAJEKoBIR0gDCgCFCIXIB2ncSEDIB1CGYhC/wCDQoGChIiQoMCAAX4hHyAMKAIQIRFBACEHA0AgAyARaikAACIeIB+FIh1Cf4UgHUKBgoSIkKDAgAF9g0KAgYKEiJCgwIB/gyEdAkACQANAIB1QRQRAIAogCSARIB16p0EDdiADaiAXcUF0bGoiBUEMaygCAEEIaiAFQQhrKAIAEBINAiAdQgF9IB2DIR0MAQsLIB4gHkIBhoNCgIGChIiQoMCAf4NQDQEMAwsgBEGMBGoiAyANIAVBBGsoAgAQ2AYgBCgCjARFDQYgBEEgaiADENsGIARB8ANqIAQoAiAgBCgCJBAKDAYLIAMgB0EIaiIHaiAXcSEDDAALAAsgBEEANgKMBAwDCyADQQhqIQMgBUEIayEFDAALAAsgBEHwA2pBJBDXAiADIQggBSEGDAALAAsLQaDawgAQXQALIARBkAJqENwGQX8hBSAQDAELIARB+AJqENwGIARBCGogBSAQIAtBwNrCABC/AiAEQewCaiAEKAIIIAQoAgwQCiAEKAL0AiELIAQoAuwCIQUgBCgC8AILIgMgCxDsBRDgAiAFIAMQBSAEKAL4", + "ASAQEAEMAAsACyAEKALQASAEKALUARABIARBuAFqELsECyAEKAKsASASEAEgBEGUAWoQuwQLIAIQuwQgBEGwBGokAAvOCgEGfyMAQcACayIDJAAgA0EsaiABIAIQ4QEgA0EAOwFAIANCMjcCOCADQoGAgICAgIDQADcCJCADIAMoAjAiCCADKAI0IgZqNgJIIAMgCDYCRCADQcQAaiICEMIBIQEgA0EAOwHcASADQQA2AtgBIANCBDcD6AEgA0IANwPgASADQgA3A9ABIAMgATYCzAEgA0IANwLEASADIAY2AsABIAMgCDYCvAEgAyADKQI4NwOwASADIAMoAkA2ArgBIAIgA0GwAWoQxAEgAygCTCECIAMoAkghAQJ/QQIgAygCRCIFQQJGDQAaIAMgAygCYDYCrAEgAyADKQJYNwKkASADIAMpAlA3ApwBIAMgAjYCmAEgAyABNgKUASADIAU2ApABIANBkAFqIgQgAygCsAFBABDiASIHBEAgBBCZAUEcIQIgByEBQQIMAQsgAyADQZwBaiIEKAIQNgK4AiADIAQpAgg3A7ACIAMgBCkCADcDqAIgBQshBCADKALoASADKALsARDjASADKALkASADKALoARD1AgJAAkAgBEECRg0AIAMgAygCuAI2AqwBIAMgAykDsAI3AqQBIAMgAykDqAI3ApwBIAMgAjYCmAEgAyABNgKUASADIAQ2ApABIANB6AFqIAggBhBCIANBmAJqEIIBIANBwNvCACkDADcCrAIgA0HI28IAKQMANwK0AiADQQA2AsABIANBADYCuAEgA0KBgICAgICA0AA3A7ABIANBBDYChAIgA0KAgICAwAA3AvQBIANCADcC/AEgAyADKQOYAjcD2AEgAyADKQOgAjcD4AEgAyADKQKoAjcCxAEgAyADKQKwAjcCzAEgAyADKAK4AjYC1AEgA0IANwGOAiADQgA3A4gCIAMtAKwBIQUgA0EYaiADQbgBaiIGQYi1wgAQ5AEgAygCHCECIAMo", + "AhggBToAVCACIAIoAgBBAWo2AgAgAy0ArQEhBSADQRBqIAZBmLXCABDkASADKAIUIQIgAygCECAFOgBVIAIgAigCAEEBajYCACADQQhqIAZBqLXCABDkASADKAIMIQIgAygCCCIFIAE2AgQgBSAENgIAIAIgAigCAEEBajYCACADQagCaiADQbABakEAQQAgAyADQZABahDlASADKAKwAiEEIAMoAqwCIQUCQAJAAkACQCADKAKoAgRAIAUhASAEIQIMAQsgA0EGOgCoAiADQZgCaiADQbABaiADQagCahDnASADKAKcAiEHIAMoApgCIgEEQCAHIQIMAQtBIiECIANBsAFqIAQgBxDpASIBRQ0BCyADQcABahDsAQwBCyADIAZBuLXCABDkASADKAIEIQEgAygCACAFNgJMIAEgASgCAEEBajYCACADKALIASECIAMoAsQBIQEgAygCwAEhBSADQcQAaiADQcwBakHMAPwKAAAgBUECRw0BCyADQZABahCZAQwBCyADQbABaiIHIANBxABqQcwA/AoAAEEIQeAAEJsBIgQgAjYCECAEIAE2AgwgBCAFNgIIIARCgYCAgBA3AwAgBEEUaiAHQcwA/AoAACAEIAQoAgAiAUEBajYCACABQQBOBEBBBEEEEJsBIgEgBDYCACADQZABahCZAUHct8IAIQIMAgsAC0EAIQQLIAMoAiwgCBABAkAgBEUEQCADIAI2AkggAyABNgJEIANBOjYCtAEgAyADQcQAajYCsAEgAEEEakHDk8AAIANBsAFqEAxBACEEDAELIABBADYCGCAAQoCAgIDAADcCECAAQQA6AAwgACACNgIIIAAgATYCBAsgACAENgIAIANBwAJqJAALowEBBH8gACgCABDuASAAKAIYIQEgACgCFCIEIQMDQCABBEAgAygCACICKAIAIAJBBGooAgBBBEEMEDAgAkEMahCWBCACQTxqEJYEIAJB7AAQGSABQQFrIQEgA0EEaiEDDAELCyAAKAIQIARB", + "BEEEEDAgACgCCCICKAIAIgEEQCAAKAIEIAERAwALIAIoAgQiAQRAIAIoAggaIAAoAgQgARCIAQsLgwECAn8BfiMAQRBrIgQkACABKAIAIQUgBEEIaiABQQRqEOUGIAQpAwghBiAAQQhqIAUoAlBBAXQQpwEgACABNgI0IAAgAzYCMCAAIAI2AiwgAEEANgIoIAAgAzYCJCAAIAI2AiAgACAGNwIYIAAgBUEIajYCFCAAQQA2AgAgBEEQaiQAC2kBAX8jAEEgayICJAAgAkEIaiABEJIEAkAgAigCCEF/RwRAIAAgAikCGDcCFCAAIAIpAhA3AgwgACACKQIINwIEIAAgASgCOCIANgIAIAEgAEEBajYCOAwBCyAAQX82AgQLIAJBIGokAAt8AQR/AkAgAkEASA0AIAJBAXQiAiABKAIIIgRPDQAgASgCBCIFIAJBAnRqKAIAIgZFDQAgAkEBciICIARPDQAgBSACQQJ0aigCACICRQ0AIAAgBkEBazYCCCAAIAJBAWs2AgwgACABKAIQNgIEIAEoAgwhAwsgACADNgIACyQAIABB+wBJIABB2wBJIABBMGtBCkkgAEHAAEsbIABB4ABLGwsWACAAKAIAIAAoAgQQJiAAKAIUEO4BC00BAX8jAEEQayICJAAgAkEIaiABKAIAIAEoAgQgASgCCCABKAIMQYCTwwAQ1gEgAigCDCEBIAAgAigCCDYCACAAIAE2AgQgAkEQaiQACxoAIAAQkwQgACgCQEF9TQRAIABBQGsQ2gYLC5QPAhB/A34jAEHQAmsiBCQAIARBnAFqIAEgAiADLQDRASADKALcARDeBgJAIAQtALgBIgNBAkYEQCAEIAQoAqQBIgE2AlAgBCAEKQKcASIUNwNIIAAgATYCDCAAIBQ3AgQgAEF+NgIADAELIAQgBCgCtAEiBTYCYCAEIAQpAqwBIhQ3A1ggBCAEKQKkASIVNwNQIAQgBCkCnAEiFjcDSCAEIAQvALkBOwBFIAQgBC0AuwE6AEcg", + "BCAWNwMoIAQgFTcDMCAEIBQ3AzggBCAFNgJAIAQgAzoARCAEIAQoAigiA0HMAGooAgAiBSADQdAAaigCAEEDdGo2AnQgBCAFNgJwIARByABqIARB8ABqEIoEAkAgBCgCSEF/RwRAIARBIGpBBEEEQQwQByAEKAIgIQMgBCgCJCIFIAQoAlA2AgggBSAEKQJINwIAIARBATYCzAIgBCAFNgLIAiAEIAM2AsQCIAQgBCkCcDcCjAFBDCEDQQEhBgNAIARBnAFqIARBjAFqEIoEIAQoApwBQX9GDQIgBCgCxAIgBkYEQCAEQcQCakEBEKMBIAQoAsgCIQULIAMgBWoiByAEKAKkATYCCCAHIAQpApwBNwIAIAQgBkEBaiIGNgLMAiADQQxqIQMMAAsACyAEQQA2AswCIARCgICAgMAANwLEAgsgBEEANgLAAiAEQoCAgIDAADcCuAIgBEGcAWogAigCDCIDKAIMIAMoAhAQiwMgBCgCoAEiDSAEKAKkAUECdGohEiAEKAKcASEQIARBqAJqIQkgBEHMAGohDiANIQoCQANAIAogEkYNASAEQZwBaiILIAEgCigCACIPEK0CIAQoAqABIgMgBCgCpAFB49/CAEEFELECIAQoApwBIAMQAUUEQCAKQQRqIQogBEHkAGogASgCBCABKAIIIA8QrAIiA0EoaigCACADQSxqKAIAEEIgCyAEQShqIAQoAmgiEyAEKAJsEN8GIAQoApwBIQUgBCAEKAKgASIDIAQoAqQBQRhsaiILNgJ8IAQgBTYCeCAEIAM2AnADQAJAIAQgAyALRwR/IANBGGohBSADKAIAIgZBf0cNASAFBSALCzYCdCAEQfAAahDgBiAEKAJkIBMQAQwDCyAOIAMpAgQ3AgAgDiADKQIMNwIIIA4gAygCFDYCECAEIAY2AkggBEEAOgC2AiAEQQA2AtQBIARCgICAgBA3AswBIARCATcCxAEgBEIANwK8ASAEQoCAgIAQNwK0ASAEQgE3AoACIARCADcC", + "+AEgBEKAgICAEDcC8AEgBEIBNwLoASAEQgA3AuABIARCgICAgMAANwLYASAEQQA2ApwBIARBADYCpAEgBEEANgKsASAEQQA2ApACIARCADcCoAIgBEKAgICAEDcCiAIgCUIANwIAIAlCADcBBiAEQQA2ApwCIARCgICAgBA3ApQCIAEgBEGcAWoQ3wIhESAEKALMAiEGIAQoAsgCIQMgBEKAgICAEDcClAEgBCADNgKMASAEIAMgBkEMbGo2ApABA0AgBEEYaiAEQYwBahDhBgJAAkAgBCgCHCIGBEAgBCgCGCEDIARBAToAtgJBACEHIARBADYC1AEgBEKAgICAEDcCzAEgBEIBNwLEASAEQgA3ArwBIARCgICAgBA3ArQBIARCATcCgAIgBEIANwL4ASAEQoCAgIAQNwLwASAEQgE3AugBIARCADcC4AEgBEKAgICAwAA3AtgBIARBADYCnAEgBEEANgKkASAEQQA2AqwBIARBADYCkAIgBEIANwKgAiAEQoCAgIAQNwKIAiAJQgA3AgAgCUIANwEGIARBADYCnAIgBEKAgICAEDcClAIgASAEQZwBaiIIEN8CIQwgBEEANgKIASAEQoCAgIDAADcCgAEgCCAEQcgAaiADENgGIAQoApwBDQFCfyEUDAILQQAhBiABIA9BAUG13sIAQQVBAUEAEOwFIQMgBEEANgKIASAEQoCAgIDAADcCgAEgBEGMAWoiCCAEQcgAakEAENgGIAEgBEGAAWogBCgCjAEiDAR/IARBCGogCBDbBiAEKAIMIQcgBCgCCAVBAAsgByAENQKUAUJ/IAwbQQFBABDiBiABIAMgBCgChAEiBiAEKAKIARDoBCAEQZwBaiIIQePfwgBBBUHwzsMAQQgQ3gIgBCABIAMgASAIEN8CIBEQ6QQgBEG4AmogAxDgAiAEKAKAASAGECYgBEHIAGoQ2gYgBSEDDAMLIAQ1AqQBIRQgBEEQaiAEQZwBahDbBiAEKAIUIQMgBCgCECEHCyABIARB", + "gAFqIAcgAyAUIAYoAgQgBigCCBDiBiABIAwgBCgChAEiAyAEKAKIARDoBCABIBEgDBCrBSAEKAKAASADECYMAAsACwALCyABKAIEIAEoAgggDxCsAiEBIARBAzYCoAEgBCABQRhqNgKcASAAQQRqQb+/wAAgBEGcAWoQDCAAQX42AgAgDSAQEOYEIAQoArgCIAQoArwCECYgBEHEAmoQ8QIgBEEoahDVBgwBCyANIBAQ5gQgACACIARBuAJqELYFIARBxAJqEPECIARBKGoQ1QYLIAIQuwQgBEHQAmokAAv/BgEDfyMAQZABayIFJAAgBUHcAGogAyAEELIFIAUoAmAhBAJAIAUoAlwiA0F/RwRAIAUoAmQhASAAQQI6ABwgACABNgIIIAAgBDYCBCAAIAM2AgAMAQsCQCAELQDRAUEFRwRAIAQhAwwBCyAFQQxqIQYgBCgC2AEhAyAFQdwAaiIHIAIQuwUgBUEIaiABIAcgBCgC3AEQuQQgBSgCCCIEQX5HBEAgBSAFKQIYNwI8IAUgBDYCLCAFIAYpAgA3AjAgBSAGKAIIIgQ2AjhBACEHAn8gBCgCEARAIAVBIGogASgCBCABKAIIIAQoAgwoAgAQrAIiBEEoaigCACAEQSxqKAIAEEIgBSgCKCEGIAUoAiQMAQtBACEGIAVBADYCKCAFQoCAgIAQNwIgQQELIgQgBkHnABC9AgRAQQEhByAFQdwAaiAEIAZB5wBBAUEAEL4CIAUoAiAgBBABIAUgBSgCZCIGNgIoIAUgBSkCXDcDICAFKAIkIQQLAkAgBCAGQekAEL0CRQRAIAYEQCAFQQM2AmAgBSAFQSBqNgJcIABBrZjAACAFQdwAahAMIABBAjoAHCAFKAIkIQQMAgsgBSgCICAEEAEgBUEsahC7BAwDCyAAQfjOwwBB3AAQBiAAQQI6ABwLIAUoAiAgBBABIAVBLGoQuwQMAgsgAEECOgAcIAAgBigCCDYCCCAAIAYpAgA3AgAMAQsgBUHIAGohBCAF", + "QdwAaiIGIAIQvgUgBUHEAGogASAGIAMQuQQgBSgCRCICQX5GBEAgAEECOgAcIAAgBCgCCDYCCCAAIAQpAgA3AgAMAQsgBSAFKQJUNwI8IAUgAjYCLCAFIAQpAgA3AjAgBSAEKAIIIgI2AjgCfyACKAIQBEAgBUHcAGogASgCBCABKAIIIAIoAgwoAgAQrAIiAUEoaigCACABQSxqKAIAEEIgBSgCYCEEIAUoAmQMAQsgBUEANgJcQQEhBEEACyEBIAVB+ABqIQIgBUH0AGogBCABENQGIAUoAnQiAUUEQCAAQQI6ABwgACACKAIINgIIIAAgAikCADcCACAFKAJcIAQQASAFQSxqELsEDAELIAAgBSgCjAE2AhggACAFKQKEATcCECAAIAc6ABwgACABNgIAIAAgAikCADcCBCAAIAIoAgg2AgwgBSgCXCAEEAEgBUEsahC7BAsgBUGQAWokAAuFBgEEfyMAQeABayIEJAACQAJAIAEtABxFBEAgBEE0aiIGIAEoAgBB0ABqKAIAQQF0EKcBIAEoAgAiBSAFKAIAIgdBAWo2AgAgB0EASA0CIAQgAzYCoAEgBCACNgKcASAEIAQpAjQ3A5ABIAQgBCgCPDYCmAEgBCAFNgKkASAEQRhqIAFBBGoQ5QYgBCAEKAIcIgU2AjggBCAEKAIYNgI0AkAgASgCAEEIaiAFEIMCIAIgA0EAIANBACAEKAKUASAEKAKYARC1AUUEQCAGEJQEIARBkAFqENoGQX8hAwwBCyAEIARBkAFqQQRyIgEpAgA3AyAgBCABKQIINwMoIAQgASgCEDYCMCAEKAKQASEDIARBNGoQlAQLIARBEGogA0F/RyIBQQRBGBAHIARBADYCmAEgBCAEKQMQNwKQASAEQZABaiABEJEEIAQoApQBIAQoApgBIgJBGGxqIQEDQCADQX9GRQRAIAEgAzYCACABQQRqIAQpAyA3AgAgAUEMaiAEKQMoNwIAIAFBFGogBCgCMDYCACABQRhqIQEgAkEB", + "aiECQX8hAwwBCwsgACAEKQKQATcCACAAIAI2AggMAQsgBEE0aiIFIAEgAiADENYGIARB+ABqIAUQkgQgBCgCeEF/RwRAIARBCGpBBEEEQRgQByAEKAIIIQEgBCgCDCICIAQpAogBNwIQIAIgBCkCgAE3AgggAiAEKQJ4NwIAIARBATYCdCAEIAI2AnAgBCABNgJsIARBkAFqIAVBOPwKAABBGCEBQQEhAwNAIARByAFqIARBkAFqEJIEIAQoAsgBQX9GRQRAIAQoAmwgA0YEQCAEQewAakEBEJEEIAQoAnAhAgsgASACaiIFIAQpAtgBNwIQIAUgBCkC0AE3AgggBSAEKQLIATcCACAEIANBAWoiAzYCdCABQRhqIQEMAQsLIARBkAFqEJMEIAAgBCgCdDYCCCAAIAQpAmw3AgAMAQsgAEEANgIIIABCgICAgMAANwIAIARBNGoQkwQLIARB4AFqJAAPCwALQwECfyAAKAIMIAAoAgQiAWtBGG4hAgNAIAIEQCACQQFrIQIgARDaBiABQRhqIQEMAQsLIAAoAgggACgCAEEEQRgQMAuhAQEFfwJAIAEoAgwiA0UEQCABKAIAIgIgASgCBEYEQEEAIQIMAgsgASACQQxqNgIAIAEgASgCCCIEQQFqNgIIDAELIAFBADYCDCABIAEoAgAiBCADQQxsaiIGQQxqIAEoAgQiBSADIAUgBGtBDG4iBUkbNgIAIAMgBU8NACABIAEoAgggA2oiBEEBajYCCCAGIQILIAAgAjYCBCAAIAQ2AgAL8wIBA38jAEGwAWsiCCQAIAhBFGoiB0Hj38IAQQVBxNDDAEEGEN4CIAEgACAHEN8CEOACIAECfyACBEAgB0Hj38IAQQUgAiADEN4CIAAgBxDfAgwBCyAIQRRqIgJBpeDCAEEGQeDgwgBBBBDeAkEAIQMgACACEN8CCxDgAiAIQRRqIgdB49/CAEEFQcrQwwBBBhDeAiABIAAgBxDfAhDgAiAIQQhqIgkgBBDwBCAHQZzf", + "wgBBBSAIKAIMIgIgCCgCEBDeAiABIAAgBxDfAhDgAiAIKAIIIAIQASAHQePfwgBBBUGKn8MAQQYQ3gIgASAAIAcQ3wIQ4AIgCSADEKwFIAdBnN/CAEEFIAgoAgwiAiAIKAIQEN4CIAEgACAHEN8CEOACIAgoAgggAhABIAYEQCAHQePfwgBBBUHQ0MMAQQQQ3gIgASAAIAcQ3wIQ4AIgB0Hj38IAQQUgBSAGEN4CIAEgACAHEN8CEOACCyAIQbABaiQAC6oKAhB/A34jAEHQAmsiBCQAIARBnAFqIAEgAiADLQDRASADKALcARDeBgJAIAQtALgBIgVBAkYEQCAEIAQoAqQBIgE2AkggBCAEKQKcASIUNwNAIAAgATYCDCAAIBQ3AgQgAEF+NgIADAELIAQgBCgCtAEiAzYCWCAEIAQpAqwBIhU3A1AgBCAEKQKkASIWNwNIIAQgBCkCnAEiFDcDQCAEIAQvALkBOwA9IAQgBC0AuwE6AD8gBCAUNwMgIAQgFjcDKCAEIBU3AzAgBCADNgI4IAQgBToAPCAEIAQoAiAiBUHMAGooAgAiAyAFQdAAaigCAEEDdGo2AnAgBCADNgJsIARBQGsgBEHsAGoQigQCfyAEKAJAQX9HBEAgBEEYakEEQQRBDBAHIAQoAhghAyAEKAIcIgYgBCgCSDYCCCAGIAQpAkA3AgAgBEEBNgLMAiAEIAY2AsgCIAQgAzYCxAIgBCAEKQJsNwJ8QQwhA0EBIQcDQCAEQZwBaiAEQfwAahCKBCAEKAKcAUF/RkUEQCAEKALEAiAHRgRAIARBxAJqQQEQowEgBCgCyAIhBgsgAyAGaiIFIAQoAqQBNgIIIAUgBCkCnAE3AgAgBCAHQQFqIgc2AswCIANBDGohAwwBCwsgBCgCyAIhCSAEKALMAgwBCyAEQQA2AswCIARCgICAgMAANwLEAkEEIQlBAAshAyAEQQA2AsACIARCgICAgMAANwK4AiAEQZwBaiACKAIMIgUoAgwgBSgCEBCL", + "AyAJIANBDGxqIRAgBCgCoAEiCiAEKAKkAUECdGohESAEKAKcASEOIARBxABqIQsgCiEIAkADQCAIIBFGDQEgBEGcAWoiBiABIAgoAgAiDBCtAiAEKAKgASIFIAQoAqQBQePfwgBBBRCxAiAEKAKcASAFEAFFBEAgCEEEaiEIIARB4ABqIAEoAgQgASgCCCAMEKwCIgNBKGooAgAgA0EsaigCABBCIAYgBEEgaiAEKAJkIhIgBCgCaBDfBiAEKAKcASEFIAQgBCgCoAEiAyAEKAKkAUEYbGoiBjYCeCAEIAU2AnQgBCADNgJsA0ACQCAEIAMgBkcEfyADQRhqIQUgAygCACIHQX9HDQEgBQUgBgs2AnAgBEHsAGoQ4AYgBCgCYCASEAEMAwsgCyADKQIENwIAIAsgAykCDDcCCCALIAMoAhQ2AhAgBCAHNgJAIAEgDEEBQbXewgBBBUEBQQAQ7AUhDyAEQoCAgIAQNwKEASAEIBA2AoABIAQgCTYCfANAIARBEGogBEH8AGoQ4QYgBCgCFCIDBEAgBCgCECEHIARBnAFqIg1B49/CAEEFIAMoAgQgAygCCBDeAiABIA0Q3wIhAyAEQYwBaiITIARBQGsgBxDYBiAEIAEgDyADAn8gBCgCjAEEQCAEQQhqIBMQ2wYgDUHj38IAQQUgBCgCCCAEKAIMEN4CIAEgDRDfAgwBCyAEQZwBaiIDQaXgwgBBBkHg4MIAQQQQ3gIgASADEN8CCxDpBAwBCwsgBEG4AmogDxDgAiAEQUBrENoGIAUhAwwACwALCyABKAIEIAEoAgggDBCsAiEBIARBAzYCoAEgBCABQRhqNgKcASAAQQRqQb+/wAAgBEGcAWoQDCAAQX42AgAgCiAOEOYEIAQoArgCIAQoArwCECYgBEHEAmoQ8QIgBEEgahDVBgwBCyAKIA4Q5gQgACACIARBuAJqELYFIARBxAJqEPECIARBIGoQ1QYLIAIQuwQgBEHQAmokAAvsBAIKfwN+IwBB8ABrIgQk", + "ACAEQcQAaiABIAIgAy0A0QEgAygC3AEQ3gYCQCAELQBgIgNBAkYEQCAEIAQoAkwiATYCMCAEIAQpAkQiDjcDKCAAIAE2AgwgACAONwIEIABBfjYCAAwBCyAEIAQoAlwiBjYCQCAEIAQpAlQiDjcDOCAEIAQpAkwiDzcDMCAEIAQpAkQiEDcDKCAEIAQvAGE7ACUgBCAELQBjOgAnIAQgEDcDCCAEIA83AxAgBCAONwMYIAQgBjYCICAEIAM6ACQgBEEANgJsIARCgICAgMAANwJkIARBxABqIAIoAgwiAygCDCADKAIQEIsDIAQoAkxBAnQhCiAEKAJIIQYgBCgCRCEJIARBCGpBBHIhC0EAIQMCQANAIAMgCkcEQCAEQcQAaiIMIAEgAyAGaigCACIHEK0CIAQoAkgiBSAEKAJMQePfwgBBBRCxAg0CIAQoAkQgBRABIAEoAgQgASgCCCAHEKwCIggoAiwhBSAIKAIoIQggBCALEOUGIAQgBCgCBCINNgJIIAQgBCgCADYCRCAEKAIIQQhqIA0QgwIgCCAFQQAgBUEBQQRBABC1ASEFIAwQlAQgBEHkAGogAUEBIAcgBRCeBhDgAiADQQRqIQMMAQsLIAYgCRDmBCAAIAIgBEHkAGoQtgUgBEEIahDVBgwBCyAEKAJEIAUQASABKAIEIAEoAgggBxCsAiEBIARBAzYCSCAEIAFBGGo2AkQgAEEEakG/v8AAIARBxABqEAwgAEF+NgIAIAYgCRDmBCAEKAJkIAQoAmgQJiAEQQhqENUGCyACELsEIARB8ABqJAALhgEBBH8jAEHwAGsiAyQAIAFBCGoQlQQCQCABKAIUIgIEQCABIAJBAWsiAjYCFCABKAIQIAJBAnRqKAIAIQIMAQsgA0EEaiIFIAEoAgAgASgCBCgCFBEBAEEEQewAEOUCIgIgBUHsAPwKAAALQQA6AAAgACACNgIEIAAgATYCACADQfAAaiQAC7UFAQp/IwBB4ABrIgQkACAEQRhqIgUgAhC+", + "BSAEIAEgBSADKALcARC5BCAEQQRqIQMCQCAEKAIAIgdBfkYEQCAAQX42AgAgACADKAIINgIMIAAgAykCADcCBAwBCyAEIAQpAhA3AiggBCAHNgIYIAQgAykCADcCHCAEIAMoAggiAzYCJAJ/IAMoAhAEQCAEQTBqIAEoAgQgASgCCCADKAIMKAIAEKwCIgNBKGooAgAgA0EsaigCABBCIAQoAjghCiAEKAI0DAELIARBADYCOCAEQoCAgIAQNwIwQQELIQcgBEEANgJcIARCgICAgMAANwJUIARByABqIAIoAgwiAygCDCADKAIQEIsDIAQoAlBBAnQhDCAEKAJMIQggBCgCSCELQQAhAwJAA0AgAyAMRwRAIAEoAgQgASgCCCADIAhqKAIAIgYQrAIiBUEcaigCACAFQSBqKAIAQaXgwgBBBhASRQRAIARByABqIg0gASAGEK0CIAQoAkwiBSAEKAJQQePfwgBBBRCxAiAEKAJIIAUQAQ0DIARBPGogASgCBCABKAIIIAYQrAIiBUEoaigCACAFQSxqKAIAEEIgDSABIAQoAkAiBSAEKAJEIAcgChDnBiABIAEgBkEAQbDewgBBBUEBQQAQ7AUiBiAEKAJMIgkgBCgCUBDoBCAEQdQAaiAGEOACIAQoAkggCRAmIAQoAjwgBRABCyADQQRqIQMMAQsLIAggCxDmBCAAIAIgBEHUAGoQtgUgBCgCMCAHEAEgBEEYahC7BAwBCyABKAIEIAEoAgggBhCsAiEBIARBAzYCTCAEIAFBGGo2AkggAEEEakHUvMAAIARByABqEAwgAEF+NgIAIAggCxDmBCAEKAJUIAQoAlgQJiAEKAIwIAcQASAEQRhqELsECyACELsEIARB4ABqJAAL7AYBAn8jAEHAAmsiBiQAAkAgAwRAAkAgBQRAIAZBIGoiByACIAMgBCAFEFkgBkEBOwFoIAYgAzYCZCAGQQA2AmAgBkH0AGogBxCJBCAGKAJ0QX9HBEAgBkEYakEEQQRBDBAH", + "IAYoAhghAiAGKAIcIgQgBigCfDYCCCAEIAYpAnQ3AgAgBkEBNgKQASAGIAQ2AowBIAYgAjYCiAEgBkGgAWogB0HQAPwKAABBDCEDQQEhBQNAIAZBlAFqIAZBoAFqEIkEIAYoApQBQX9GDQMgBigCiAEgBUYEQCAGQYgBakEBEKMBIAYoAowBIQQLIAMgBGoiAiAGKAKcATYCCCACIAYpApQBNwIAIAYgBUEBaiIFNgKQASADQQxqIQMMAAsACyAGQQA2ApABIAZCgICAgMAANwKIAQwBCyAGIAI2AoABIAYgAiADajYChAEgBkGUAWogBkGAAWoQiwQgBigClAFBf0cEQCAGQRBqQQMgBigChAEiAiAGKAKAASIDayIEQQJ2IARBA3FBAEdqIgQgBEEDTRtBAWpBBEEMEAcgBigCECEFIAYoAhQiBCAGKAKcATYCCCAEIAYpApQBNwIAIAZBATYCkAEgBiAENgKMASAGIAU2AogBIAYgAjYCeCAGIAM2AnRBDCEDQQEhBQNAIAZBoAFqIAZB9ABqEIsEIAYoAqABQX9GDQIgBigCiAEgBUYEQCAGQYgBaiAGKAJ4IAYoAnRrIgJBAnYgAkEDcUEAR2pBAWoQowEgBigCjAEhBAsgAyAEaiICIAYoAqgBNgIIIAIgBikCoAE3AgAgBiAFQQFqIgU2ApABIANBDGohAwwACwALIAZBADYCkAEgBkKAgICAwAA3AogBCyAGKAKMASEDIAZBCGogBigCkAEiAkEEQQQQByAGQQA2ApwBIAYgBikDCDcClAEgBkGUAWogAhCXBCAGKAKcASEFIAIEQCACIAVqIANBCGohAyAGKAKYASAFQQJ0aiEFA0AgBkGgAWoiB0Hj38IAQQUgA0EEaygCACADKAIAEN4CIAUgASAHEN8CNgIAIANBDGohAyAFQQRqIQUgAkEBayICDQALIQULIAAgBikClAE3AgAgACAFNgIIIAZBiAFqEPECDAELIABBADYCCCAAQoCAgIDAADcC", + "AAsgBkHAAmokAAudPAIefwJ+IwBBwAFrIggkACAIQQA2AqQBIAhCgICAgMAANwKcASADLQAcIAMoAhggCCACKAIMIgUoAgwgBSgCEBCLA0GOgICAeEZxISAgCCgCBCIdIAgoAghBAnRqISEgCCgCACEfIB0hHAJAA0ACQAJAAkACQAJAAkACQAJAAkAgHCAhRwRAIAggASAcKAIAIh4QrQIgCCgCBCIDIAgoAghB49/CAEEFELECIAgoAgAgAxABDQEgCCABKAIEIAEoAgggHhCsAhDnBCAIKAIsIQogCCgCKCELICANAyAKQQBODQIMCwsgHSAfEOYEIAAgAiAIQZwBahC2BQwICyABKAIEIAEoAgggHhCsAiEBIAhBAzYCBCAIIAFBGGo2AgAgAEEEakGm1MAAIAgQDCAAQX42AgAgHSAfEOYEIAgoApwBIAgoAqABECYMBwsgCkUNBCAKEBsiBgRAQQAhDCAGIQQgCyEDAkAgCiIFQRBJDQAgBUHw////B3EhDEEAIQcDQCAGIAdqIQQgByALaiIDQQFqLAAAIglBf3NBgAFxQQd2IAMsAAAiEEF/c0GAAXFBB3ZqIANBAmosAAAiDUF/c0GAAXFBB3ZqIANBA2osAAAiDkF/c0GAAXFBB3ZqIANBBGosAAAiD0F/c0GAAXFBB3ZqIANBBWosAAAiEUF/c0GAAXFBB3ZqIANBBmosAAAiEkF/c0GAAXFBB3ZqIANBB2osAAAiE0F/c0GAAXFBB3ZqIANBCGosAAAiFEF/c0GAAXFBB3ZqIANBCWosAAAiFUF/c0GAAXFBB3ZqIANBCmosAAAiFkF/c0GAAXFBB3ZqIANBC2osAAAiF0F/c0GAAXFBB3ZqIANBDGosAAAiGEF/c0GAAXFBB3ZqIANBDWosAAAiGUF/c0GAAXFBB3ZqIANBDmosAAAiGkF/c0GAAXFBB3ZqIANBD2osAAAiG0F/c0GAAXFBB3ZqQf8BcUEQRwRAIAchDAwCCyAEQQ9qQSBBACAb", + "QcEAa0H/AXFBGkkbIBtyOgAAIARBDmpBIEEAIBpBwQBrQf8BcUEaSRsgGnI6AAAgBEENakEgQQAgGUHBAGtB/wFxQRpJGyAZcjoAACAEQQxqQSBBACAYQcEAa0H/AXFBGkkbIBhyOgAAIARBC2pBIEEAIBdBwQBrQf8BcUEaSRsgF3I6AAAgBEEKakEgQQAgFkHBAGtB/wFxQRpJGyAWcjoAACAEQQlqQSBBACAVQcEAa0H/AXFBGkkbIBVyOgAAIARBCGpBIEEAIBRBwQBrQf8BcUEaSRsgFHI6AAAgBEEHakEgQQAgE0HBAGtB/wFxQRpJGyATcjoAACAEQQZqQSBBACASQcEAa0H/AXFBGkkbIBJyOgAAIARBBWpBIEEAIBFBwQBrQf8BcUEaSRsgEXI6AAAgBEEEakEgQQAgD0HBAGtB/wFxQRpJGyAPcjoAACAEQQNqQSBBACAOQcEAa0H/AXFBGkkbIA5yOgAAIARBAmpBIEEAIA1BwQBrQf8BcUEaSRsgDXI6AAAgBEEBakEgQQAgCUHBAGtB/wFxQRpJGyAJcjoAACAEQSBBACAQQcEAa0H/AXFBGkkbIBByOgAAIAdBEGohByAFQRBrIgVBD0sNAAsgBUUEQCAMIQcMCAsgBiAHaiEEIAcgC2ohAwsgBSAMaiEHA0AgAywAACIJQQBOBEAgBEEgQQAgCUHBAGtB/wFxQRpJGyAJcjoAACAEQQFqIQQgA0EBaiEDIAxBAWohDCAFQQFrIgUNAQwICwsgCCAMNgKwASAIIAY2AqwBIAMgBWohEiAIIAo2AqgBIAogC2ohE0EAIRAgDCEHA0AgECEJIAgCfwJAAkACQAJAAn8CQAJAAn8CQAJAAkAgAyIFLAAAIgNBAEgEQCAFLQABQT9xIRAgA0EfcSEEAn8gA0FfTQRAIARBBnQgEHIhBCAFQQJqDAELIAUtAAJBP3EgEEEGdHIhECADQXBJBEAgECAEQQx0ciEEIAVBA2oMAQsgBEESdEGAgPAAcSAF", + "LQADQT9xIBBBBnRyciEEIAVBBGoLIgMgCSAFa2ohECAEQaMHRw0BQYMBIQ4gCSAMaiINRQ0LAkAgCiANTQRAIAogDUYNAQwUCyALIA1qLAAAQUBIDRMLIAsgDWohBAJAAkADQAJAAkACQAJAAkACQCAEQQFrIgUsAAAiBkEASARAIAZBP3ECfyAEQQJrIgktAAAiBcAiD0FATgRAIAkhBCAFQR9xDAELIA9BP3ECfyAEQQNrIgktAAAiBcAiEUG/f0oEQCAJIQQgBUEPcQwBCyARQT9xIARBBGsiBC0AAEEHcUEGdHILQQZ0cgsiBUEGdHIhBiAFQQJPDQEgBCEFCyAGQSdrIgRBE00NAQwCCyAGQacBTQ0CIAYQaA0DDAILQQEgBHRBgYEgcUUNACAFIQQMAgsgBSEEIAZB3gBrDgMBAAEACyAGQd///wBxQcEAa0EaSQ0PIAZBqgFJDRAgBkH/1wdLDQ4gBkEGdkEPcSAGQQp2LQCQgUFBBHRyLQDIsEEiBEE5SQ0DIARBOWshBSAEQc8ATw0EIAVBAXQiBC0A0KxBQQN0KQOArUFCAEJ/QQEgBXQiBUH+//wAcRuFISIgBDEA0axBISMgBUGBgLMBcUUNASAiICOJISIMDQsgBCALRw0BDA8LCyAiICOIISIMCgsgBEEDdCkDgK1BISIMCQsgBUEWQaiEwQAQKgALIANB/wFxIQQgBUEBaiIDIAkgBWtqIRAMAQsgBEHAAUkNACAIQbQBaiAEQcCWwQAQZyAIKAK0ASIFQX9HDQFBACENDAQLIARBIHIgBCAEQcEAa0EaSRsMAQsgCCgCuAEiBA0BIAULIgRBgAFJIg1FDQFBAQwCCwJAAkACQAJAIAgoArwBIglFBEACf0EBIAVBgAFJIg0NABpBAiAFQYAQSQ0AGkEDQQQgBUGAgARJGwsiCSAIKAKoASAHa0sEfyAIQagBaiAHIAkQNiAIKAKsAQUgBgsgB2ohBiANDQEgBUE/cUGAf3IhDSAFQQZ2IQ4g", + "BUGAEEkEQCAGIA06AAEgBiAOQcABcjoAAAwFCyAFQQx2IQ8gDkE/cUGAf3IhDiAFQf//A00EQCAGIA06AAIgBiAOOgABIAYgD0HgAXI6AAAMBQsgBiANOgADIAYgDjoAAiAGIA9BP3FBgH9yOgABIAYgBUESdkFwcjoAAAwECwJ/QQEgBUGAAUkiDg0AGkECIAVBgBBJDQAaQQNBBCAFQYCABEkbCyINIAgoAqgBIAdrSwR/IAhBqAFqIAcgDRA2IAgoAqwBBSAGCyAHaiEGIA4NASAFQT9xQYB/ciEOIAVBBnYhDyAFQYAQSQRAIAYgDjoAASAGIA9BwAFyOgAADAMLIAVBDHYhESAPQT9xQYB/ciEPIAVB//8DTQRAIAYgDjoAAiAGIA86AAEgBiARQeABcjoAAAwDCyAGIA46AAMgBiAPOgACIAYgEUE/cUGAf3I6AAEgBiAFQRJ2QXByOgAADAILIAYgBToAAAwCCyAGIAU6AAALIAggByANaiINNgKwAQJ/QQEgBEGAAUkiDg0AGkECIARBgBBJDQAaQQNBBCAEQYCABEkbCyIFIAgoAqgBIA1rSwRAIAhBqAFqIA0gBRA2CyAIKAKsASIGIA1qIQcCQCAORQRAIARBP3FBgH9yIQ4gBEEGdiEPIARBgBBJBEAgByAOOgABIAcgD0HAAXI6AAAMAgsgBEEMdiERIA9BP3FBgH9yIQ8gBEH//wNNBEAgByAOOgACIAcgDzoAASAHIBFB4AFyOgAADAILIAcgDjoAAyAHIA86AAIgByARQT9xQYB/cjoAASAHIARBEnZBcHI6AAAMAQsgByAEOgAACyAIIAUgDWoiBzYCsAECf0EBIAlBgAFJIg0NABpBAiAJQYAQSQ0AGkEDQQQgCUGAgARJGwsiBCAIKAKoASAHa0sEQCAIQagBaiAHIAQQNiAIKAKsASEGCyAGIAdqIQUCQCANRQRAIAlBP3FBgH9yIQ0gCUEGdiEOIAlBgBBJBEAgBSANOgABIAUgDkHA", + "AXI6AAAMAgsgCUEMdiEPIA5BP3FBgH9yIQ4gCUH//wNNBEAgBSANOgACIAUgDjoAASAFIA9B4AFyOgAADAILIAUgDToAAyAFIA46AAIgBSAPQT9xQYB/cjoAASAFIAlBEnZBcHI6AAAMAQsgBSAJOgAACyAEIAdqDAcLIAggByAJaiIJNgKwAQJ/QQEgBEGAAUkiDQ0AGkECIARBgBBJDQAaQQNBBCAEQYCABEkbCyIFIAgoAqgBIAlrSwRAIAhBqAFqIAkgBRA2CyAIKAKsASIGIAlqIQcCQCANRQRAIARBP3FBgH9yIQ0gBEEGdiEOIARBgBBJBEAgByANOgABIAcgDkHAAXI6AAAMAgsgBEEMdiEPIA5BP3FBgH9yIQ4gBEH//wNNBEAgByANOgACIAcgDjoAASAHIA9B4AFyOgAADAILIAcgDToAAyAHIA46AAIgByAPQT9xQYB/cjoAASAHIARBEnZBcHI6AAAMAQsgByAEOgAACyAFIAlqDAYLQQIgBEGAEEkNABpBA0EEIARBgIAESRsLIgUgCCgCqAEgB2tLBEAgCEGoAWogByAFEDYgCCgCrAEhBgsgBiAHaiEJAkAgDUUEQCAEQT9xQYB/ciENIARBBnYhDiAEQYAQSQRAIAkgDToAASAJIA5BwAFyOgAADAILIARBDHYhDyAOQT9xQYB/ciEOIARB//8DTQRAIAkgDToAAiAJIA46AAEgCSAPQeABcjoAAAwCCyAJIA06AAMgCSAOOgACIAkgD0E/cUGAf3I6AAEgCSAEQRJ2QXByOgAADAELIAkgBDoAAAsgBSAHagwECyAiIAatiKdBAXENAQsgBkHAAWtBv+YHTQRAAkACQCAGQQZ2QQ9xIAZBCnYtAIuCQUEEdHItAKC2QSIEQSxPBEAgBEEsayEFIARBxQBPDQEgBUEBdCIELQCIs0FBA3QpA8CzQUIAQn9BASAFdCIFQf2H/w9xG4UhIiAEMQCJs0EhIyAFQYL4gwJxBEAgIiAjiSEiDAML", + "ICIgI4ghIgwCCyAEQQN0KQPAs0EhIgwBCyAFQRlBqITBABAqAAsgIiAGrYinQQFxDQELIAZBxQNJDQEgBhBpRQ0BCwJAIA1BAmoiBEUNACAEIApPBEAgBCAKRg0BDAgLIAQgC2osAABBQEgNBwtBggEhDiAEIApGDQAgBCALaiEEAkACQAJAAkACQANAAkACQAJAAkAgBCwAACIFQQBOBEAgBEEBaiEEIAVB/wFxIQYMAQsgBC0AAUE/cSEJIAVBH3EhBgJ/IAVBX00EQCAGQQZ0IAlyIQYgBEECagwBCyAELQACQT9xIAlBBnRyIQkgBUFwSQRAIAkgBkEMdHIhBiAEQQNqDAELIAZBEnRBgIDwAHEgBC0AA0E/cSAJQQZ0cnIhBiAEQQRqCyEEIAZBgAFJDQAgBkGnAU0NASAGEGgNAgwBCyAGQSdrIgVBE01BAEEBIAV0QYGBIHEbDQEgBkHeAGsOAwEAAQALIAZB3///AHFBwQBrQRpJDQcgBkGqAUkNCCAGQf/XB0sNBiAGQQZ2QQ9xIAZBCnYtAJCBQUEEdHItAMiwQSIEQTlJDQMgBEE5ayEFIARBzwBPDQQgBUEBdCIELQDQrEFBA3QpA4CtQUIAQn9BASAFdCIFQf7//ABxG4UhIiAEMQDRrEEhIyAFQYGAswFxRQ0BICIgI4khIgwFCyAEIBNHDQEMBwsLICIgI4ghIgwCCyAEQQN0KQOArUEhIgwBCyAFQRZBqITBABAqAAsgIiAGrYinQQFxDQELIAZBwAFrQb/mB00EQAJAAkAgBkEGdkEPcSAGQQp2LQCLgkFBBHRyLQCgtkEiBEEsTwRAIARBLGshBSAEQcUATw0BIAVBAXQiBC0AiLNBQQN0KQPAs0FCAEJ/QQEgBXQiBUH9h/8PcRuFISIgBDEAibNBISMgBUGC+IMCcQRAICIgI4khIgwDCyAiICOIISIMAgsgBEEDdCkDwLNBISIMAQsgBUEZQaiEwQAQKgALICIgBq2Ip0EBcQ0BCyAG", + "QcUDSQ0BIAYQaUUNAQtBgwEhDgsgCCgCqAEgB2tBAU0EQCAIQagBaiAHQQIQNgsgCCgCrAEiBiAHaiIEIA46AAEgBEHPAToAACAHQQJqCyIHNgKwASADIBJHDQALDAILQQEQHAALIApBAEgNByAKRQ0DIAoQGyIGBEBBACEHAkAgCkEQSQRAIAYhBCAKIQUgCyEDDAELIApB8P///wdxIQdBACEJIAohBQNAIAYgCWohBCAJIAtqIgNBAWosAAAiDEF/c0GAAXFBB3YgAywAACIQQX9zQYABcUEHdmogA0ECaiwAACINQX9zQYABcUEHdmogA0EDaiwAACIOQX9zQYABcUEHdmogA0EEaiwAACIPQX9zQYABcUEHdmogA0EFaiwAACIRQX9zQYABcUEHdmogA0EGaiwAACISQX9zQYABcUEHdmogA0EHaiwAACITQX9zQYABcUEHdmogA0EIaiwAACIUQX9zQYABcUEHdmogA0EJaiwAACIVQX9zQYABcUEHdmogA0EKaiwAACIWQX9zQYABcUEHdmogA0ELaiwAACIXQX9zQYABcUEHdmogA0EMaiwAACIYQX9zQYABcUEHdmogA0ENaiwAACIZQX9zQYABcUEHdmogA0EOaiwAACIaQX9zQYABcUEHdmogA0EPaiwAACIbQX9zQYABcUEHdmpB/wFxQRBHBEAgCSEHDAILIARBD2pBIEEAIBtB4QBrQf8BcUEaSRsgG3M6AAAgBEEOakEgQQAgGkHhAGtB/wFxQRpJGyAaczoAACAEQQ1qQSBBACAZQeEAa0H/AXFBGkkbIBlzOgAAIARBDGpBIEEAIBhB4QBrQf8BcUEaSRsgGHM6AAAgBEELakEgQQAgF0HhAGtB/wFxQRpJGyAXczoAACAEQQpqQSBBACAWQeEAa0H/AXFBGkkbIBZzOgAAIARBCWpBIEEAIBVB4QBrQf8BcUEaSRsgFXM6AAAgBEEIakEgQQAgFEHhAGtB/wFxQRpJGyAUczoAACAEQQdq", + "QSBBACATQeEAa0H/AXFBGkkbIBNzOgAAIARBBmpBIEEAIBJB4QBrQf8BcUEaSRsgEnM6AAAgBEEFakEgQQAgEUHhAGtB/wFxQRpJGyARczoAACAEQQRqQSBBACAPQeEAa0H/AXFBGkkbIA9zOgAAIARBA2pBIEEAIA5B4QBrQf8BcUEaSRsgDnM6AAAgBEECakEgQQAgDUHhAGtB/wFxQRpJGyANczoAACAEQQFqQSBBACAMQeEAa0H/AXFBGkkbIAxzOgAAIARBIEEAIBBB4QBrQf8BcUEaSRsgEHM6AAAgCUEQaiEJIAVBEGsiBUEPSw0ACyAFRQ0GIAYgCWohBCAJIAtqIQMLIAUgB2ohDAJAA0AgAywAACILQQBIDQEgBEEgQQAgC0HhAGtB/wFxQRpJGyALczoAACAEQQFqIQQgA0EBaiEDIAdBAWohByAFQQFrIgUNAAsgDCEHDAYLIAggBzYCsAEgCCAGNgKsASAIIAo2AqgBIAMgBWohDQNAIAgCfwJ/AkACQAJAAkAgAywAACIEQQBOBEAgA0EBaiEDIARB/wFxIQQMAQsgAy0AAUE/cSEKIARBH3EhBQJ/IARBX00EQCAFQQZ0IApyIQQgA0ECagwBCyADLQACQT9xIApBBnRyIQogBEFwSQRAIAogBUEMdHIhBCADQQNqDAELIAVBEnRBgIDwAHEgAy0AA0E/cSAKQQZ0cnIhBCADQQRqCyEDIARBtQFJDQAgCEG0AWogBEGwpsEAEGcgCCgCtAEiBUF/RgRAQQAhCQwECyAIKAK4ASIERQRAIAUhBAwCCyAIKAK8ASIKBEACf0EBIAVBgAFJIgsNABpBAiAFQYAQSQ0AGkEDQQQgBUGAgARJGwsiCSAIKAKoASAHa0sEfyAIQagBaiAHIAkQNiAIKAKsAQUgBgsgB2ohDAJAIAtFBEAgBUE/cUGAf3IhBiAFQQZ2IQsgBUGAEEkEQCAMIAY6AAEgDCALQcABcjoAAAwCCyAFQQx2IRAgC0E/cUGA", + "f3IhCyAFQf//A00EQCAMIAY6AAIgDCALOgABIAwgEEHgAXI6AAAMAgsgDCAGOgADIAwgCzoAAiAMIBBBP3FBgH9yOgABIAwgBUESdkFwcjoAAAwBCyAMIAU6AAALIAggByAJaiIMNgKwAQJ/QQEgBEGAAUkiCw0AGkECIARBgBBJDQAaQQNBBCAEQYCABEkbCyIFIAgoAqgBIAxrSwRAIAhBqAFqIAwgBRA2CyAIKAKsASIGIAxqIQcCQCALRQRAIARBP3FBgH9yIQsgBEEGdiEJIARBgBBJBEAgByALOgABIAcgCUHAAXI6AAAMAgsgBEEMdiEQIAlBP3FBgH9yIQkgBEH//wNNBEAgByALOgACIAcgCToAASAHIBBB4AFyOgAADAILIAcgCzoAAyAHIAk6AAIgByAQQT9xQYB/cjoAASAHIARBEnZBcHI6AAAMAQsgByAEOgAACyAIIAUgDGoiBzYCsAECf0EBIApBgAFJIgwNABpBAiAKQYAQSQ0AGkEDQQQgCkGAgARJGwsiBCAIKAKoASAHa0sEQCAIQagBaiAHIAQQNiAIKAKsASEGCyAGIAdqIQUCQCAMRQRAIApBP3FBgH9yIQwgCkEGdiELIApBgBBJBEAgBSAMOgABIAUgC0HAAXI6AAAMAgsgCkEMdiEJIAtBP3FBgH9yIQsgCkH//wNNBEAgBSAMOgACIAUgCzoAASAFIAlB4AFyOgAADAILIAUgDDoAAyAFIAs6AAIgBSAJQT9xQYB/cjoAASAFIApBEnZBcHI6AAAMAQsgBSAKOgAACyAEIAdqDAYLAn9BASAFQYABSSILDQAaQQIgBUGAEEkNABpBA0EEIAVBgIAESRsLIgwgCCgCqAEgB2tLBH8gCEGoAWogByAMEDYgCCgCrAEFIAYLIAdqIQoCQCALRQRAIAVBP3FBgH9yIQYgBUEGdiELIAVBgBBJBEAgCiAGOgABIAogC0HAAXI6AAAMAgsgBUEMdiEJIAtBP3FBgH9yIQsgBUH//wNN", + "BEAgCiAGOgACIAogCzoAASAKIAlB4AFyOgAADAILIAogBjoAAyAKIAs6AAIgCiAJQT9xQYB/cjoAASAKIAVBEnZBcHI6AAAMAQsgCiAFOgAACyAIIAcgDGoiCjYCsAECf0EBIARBgAFJIgwNABpBAiAEQYAQSQ0AGkEDQQQgBEGAgARJGwsiBSAIKAKoASAKa0sEQCAIQagBaiAKIAUQNgsgCCgCrAEiBiAKaiEHAkAgDEUEQCAEQT9xQYB/ciEMIARBBnYhCyAEQYAQSQRAIAcgDDoAASAHIAtBwAFyOgAADAILIARBDHYhCSALQT9xQYB/ciELIARB//8DTQRAIAcgDDoAAiAHIAs6AAEgByAJQeABcjoAAAwCCyAHIAw6AAMgByALOgACIAcgCUE/cUGAf3I6AAEgByAEQRJ2QXByOgAADAELIAcgBDoAAAsgBSAKagwFCyAEQeEAa0EaTw0AIARB3wBxIQRBASEJDAELIARBgAFJIglFDQELQQEMAQtBAiAEQYAQSQ0AGkEDQQQgBEGAgARJGwsiBSAIKAKoASAHa0sEQCAIQagBaiAHIAUQNiAIKAKsASEGCyAGIAdqIQoCQCAJRQRAIARBP3FBgH9yIQwgBEEGdiELIARBgBBJBEAgCiAMOgABIAogC0HAAXI6AAAMAgsgBEEMdiEJIAtBP3FBgH9yIQsgBEH//wNNBEAgCiAMOgACIAogCzoAASAKIAlB4AFyOgAADAILIAogDDoAAyAKIAs6AAIgCiAJQT9xQYB/cjoAASAKIARBEnZBcHI6AAAMAQsgCiAEOgAACyAFIAdqCyIHNgKwASADIA1HDQALDAELQQEQHAALIAgoAqwBIQYgCCgCqAEhCgwDCyALIAogBCAKQZDYwAAQWgALIAsgCkEAIA1BgNjAABBaAAtBACEHQQEhBgsgHEEEaiEcIAEgHkECIAgoAhwgCCgCICAGIAcQ7AUhAyAIKAKEASEEIAEoAgQgASgCCCADEOECIAQ2AoQBIAhB", + "nAFqIAMQ4AIgCiAGEAEgCBDCBAwBCwsgAhC7BCAIQcABaiQADwsQNAAL5AQBDX8jAEHQAWsiBCQAIARBADYCuAEgBEKAgICAwAA3ArABIARBFGogAigCDCIDKAIMIAMoAhAQiwMgBCgCGCIIIAQoAhxBAnRqIQ4gBCgCFCEMIARBxAFqIQ0gCCEDAkACQANAIAMgDkYNASAEQRRqIgcgASADKAIAIgkQrQIgBCgCGCIGIAQoAhxB49/CAEEFELECIAQoAhQgBhABRQRAIANBBGohAyAHIAEoAgQgASgCCCAJEKwCEOcEIAQoAkAhBSAEKAI8IQYgBEEANgLMASAEIAUgBmo2AsgBIAQgBjYCxAEgBCAFNgLAASAEIAY2ArwBAn8DQCAEKALEASEHIAQoAsgBIQogBEEIaiANEJUCIAQoAgwiC0F/RgRAQQAhBUEADAILIAQoAgghBSALECINAAsgBCgCxAEgCiAHayAFamogBCgCyAFrCyEHAkADQCAEKALEASEKIAQoAsgBIQsgBCANEJ4CIAQoAgQiD0F/Rg0BIAQoAgAhECAPECINAAsgBCgCxAEgCyAKayAQamogBCgCyAFrIQcLIAEgCUECIAQoAjAgBCgCNCAFIAZqIAcgBWsQ7AUhBiAEKAKYASEFIAEoAgQgASgCCCAGEOECIAU2AoQBIARBsAFqIAYQ4AIgBEEUahDCBAwBCwsgASgCBCABKAIIIAkQrAIhASAEQQM2AhggBCABQRhqNgIUIABBBGpB99PAACAEQRRqEAwgAEF+NgIAIAggDBDmBCAEKAKwASAEKAK0ARAmDAELIAggDBDmBCAAIAIgBEGwAWoQtgULIAIQuwQgBEHQAWokAAuXBAEJfyMAQcABayIDJAAgA0EANgK8ASADQoCAgIDAADcCtAEgA0EIaiACKAIMIgQoAgwgBCgCEBCLAyADKAIQQQJ0IQsgAygCDCEHIAMoAgghCANAAkACQAJAAkACQCAGIAtHBEAgA0EIaiIMIAEo", + "AgQgASgCCCAGIAdqKAIAIgQQrAIQ5wQgAygCJCADKAIoQePfwgBBBRASDQIgAy0AogFBAkYNAyADQaQBaiABIAQQ6wYgAygCsAEhCSADKAKsASEFIAMoAqgBIQogAygCpAFFDQQgACAJNgIMIAAgBTYCCCAAIAo2AgQgAEF+NgIAIAwQwgQgByAIEOYEIAMoArQBIAMoArgBECYMAQsgByAIEOYEIAAgAiADQbQBahC2BQsgAhC7BCADQcABaiQADwsgASAEQQJB49/CAEEFIAMoAjAgAygCNBDsBSEEDAILIAEgBEECQePfwgBBBSADKAIwIAMoAjQQ7AUhBCABKAIEIAEoAgggBBDhAkECNgKEAQwBCyABIARBAkHj38IAQQUgBSAJEOwFIQQgASgCBCABKAIIIAQQ4QJBAjYChAEgCiAFEAELIANBpAFqQePfwgBBBRAGIAEoAgQgASgCCCAEEOECIgUoAhggBUEcaigCABABIAUgAygCrAE2AiAgBSADKQKkATcCGCADQbQBaiAEEOACIAZBBGohBiADQQhqEMIEDAALAAucAQEDfyMAQSBrIgMkACADQoKAgICAIDcDCCADQRBqIAEgAiADQQhqEOMEQQEhAiADKAIcIQQgAygCGCEBIAMoAhQhBQJAIAMoAhBBAUYEQCAAIAQ2AgwgACABNgIIIAAgBTYCBAwBCyADIAEgBEEKEKECIABBBGogAygCACADKAIEEAYgBSABEAFBACECCyAAIAI2AgAgA0EgaiQAC+gDAQp/IwBB0AFrIgQkACAEQQxqIAMoAsgBIAMoAswBEEICQCACKAIMIgUoAhAiBwRAQQAhAyAEQQA2AswBIARCgICAgMAANwLEASAEQShqIAUoAgwgBxCLAyAEKAIwQQJ0IQwgBCgCLCEFIAQoAighCCAEKAIUIQ0gBCgCECEHA0ACQCADIAxHBEAgBEEoaiIJIAIgAyAFaigCABC0BSAEQRhqIAEgCSAHIA0Q7QYgBCgCJCEKIAQo", + "AiAhBiAEKAIcIQsgBCgCGEUNASAAIAo2AgwgACAGNgIIIAAgCzYCBCAAQX42AgAgCRC7BCAFIAgQ5gQgBCgCxAEgBCgCyAEQJgwECyAFIAgQ5gQgACACIARBxAFqELYFDAMLIARBKGoiCRC7BCAJQePfwgBBBSAGIAoQ3gIgBEHEAWogASAJEN8CEOACIAsgBhABIANBBGohAwwACwALIARBKGoiCCABIAIgBCgCECIHIAQoAhQQ7QYgBCgCNCEFIAQoAjAhAyAEKAIsIQYgBCgCKEUEQCAIQePfwgBBBSADIAUQ3gIgACACIAEgCBDfAhC0BSAGIAMQAQwBCyAAIAU2AgwgACADNgIIIAAgBjYCBCAAQX42AgALIAQoAgwgBxABIAIQuwQgBEHQAWokAAvOCAIQfwF+IwBBwARrIgUkACAFQQxqIAMgAyAEahAgIAVBADYCICAFQoCAgIAQNwIYIAVBADYCLCAFQoCAgIAQNwIkIAVBNGohCyAFQYQEaiEOIAVBrARqIQ8gBUFAa0EEciEQIAVB0ABqIRIgBUGwAmohEyAFQaACakEEciERIAUoAhQhCQJAA0ACQCAIIAlPBEAgAEEEaiEBIApBAXFFBEAgASAFKAIgNgIIIAEgBSkCGDcCACAAQQA2AgAgBSgCJCAFKAIoEAEMBAsgASADIAQQBkEAIQggBSgCKCEKDAELIAUoAhAiDSAJIAhB7MDDABAhKAIAIQcCQAJAAkACQAJAIApBAXFFBEACQCAHQdwARw0AQdwAIQcgCEEBaiIGIAlPDQAgDSAJIAZB/MDDABAhKAIAIg1BKEYNAiANQdwARw0AIAYhCAsgBUEYaiAHENcCDAULAkAgB0Eoaw4CAwQACyAHQdwARw0BIAkgCEEBaiIGTQRAQdwAIQcMAgtB3AAhByANIAkgBkGMwcMAECEoAgAiFEHcAEcgFEEpR3ENASAFQSRqIA0gCSAGQZzBwwAQISgCABDXAgsgCEECaiEIQQEhCgwFCyAFQSRq", + "IAcQ1wIMAgsgBUEkakEoENcCIAxBAWohDAwBCwJAAkACQAJAIAxFBEAgBUGgAmogBSgCKCIKIAUoAiwQtQQgBSARKQIANwOoBCAFIBEoAgg2ArAEIAUoAqACIgZBf0YEQCALIAUoArAENgIIIAsgBSkDqAQ3AgAMAwsgEiATQdAB/AoAACAQIAUoArAENgIIIBAgBSkDqAQ3AgAgBSAGNgJAIAVBoAJqIgcgAhC7BSAFQagEaiABIAcgBUFAayIHQQAgBkECRxsQuQQgBSAPKQIANwOYBCAFIA8oAgg2AqAEIAUoAqgEIgZBfkYEQCALIAUoAqAENgIIIAsgBSkDmAQ3AgAgBxC9BAwDCyAFKQK4BCEVIA4gBSgCoAQ2AgggDiAFKQOYBDcCACAFIBU3ApAEIAUgBjYCgAQgBSgCjAQiBigCEEUNAyABKAIEIAEoAgggBigCDCgCACIGEKwCLQCaAUECRw0BIAsgASgCBCABKAIIIAYQrAIiBkEoaigCACAGQSxqKAIAEEIgBUGABGoQuwQgBUFAaxC9BAwECyAFQSRqQSkQ1wIgDEEBayEMDAQLIAVBMGogASAGEOsGIAUoAjAgBUGABGoQuwQgBUFAaxC9BEUNAgsgBSkCNCEVIAAgBSgCPDYCDCAAIBU3AgRBASEIDAMLIAVBADYCPCAFQoCAgIAQNwI0IAVBgARqELsEIAVBQGsQvQQLQQAhCiAFQQA2AiwgBSgCNCAFQRhqIAUoAjgiByAFKAI8EAogBxABCyAIQQFqIQgMAQsLIAAgCDYCACAFKAIkIAoQASAFKAIYIAUoAhwQAQsgBSgCDCAFKAIQECYgBUHABGokAAvwCgETfyMAQYACayIEJAACQCABLQA2RQRAIARCgICAgMAANwIUIAMtABwgBEEANgIcIAMoAhghBiAEQeAAaiACKAIMIgooAgwgCigCEBCLAyAEKAJkIgogBCgCaEECdGohFCAEKAJgIRAgBEHsAWohESAEQcwAaiESIARBPGoh", + "DSAEQeQAaiETIAMoAtwBIRVBACAGQY+AgIB4RhtB/wFxIRYgCiEDA0ACQAJAAkAgAyAURwRAIARB4ABqIAEgAiADKAIAIBUQ7wYgBCgCbCEFIAQoAmghCSAEKAJkIQ4gBCgCYEUNASAAIAU2AgwgACAJNgIIIAAgDjYCBCAAQX42AgAMAgsgCiAQEOYEIAAgAiAEQRRqELYFDAULIAQgBTYCJCAEIAk2AiAgBEHgAGogASgCHCABKAIgIAkgBRDwBiAEKAJsIQYgBCgCaCELIAQoAmQhDAJAIAQoAmBBAUYEQCAEIAY2AhAgBCALNgIMIAQgDDYCCAwBCwJAAkACQAJAAn8CQAJAAkACQAJAAkACQAJAIBYOBwEAAgAAAAMACyAEQQI2AmQgBCAEQSBqNgJgIARBCGpBro/AACAEQeAAahAMDAsLIARB4ABqIAEgCyAGIAkgBUEAQQAQwQQgBCgCbCEHIAQoAmghBSAEKAJkIQggBCgCYA0JIAcOAgIFBwtBBEEEEOUCIQUgBEHgAGogASALIAYQmgYgBCgCZCEGIAQoAmAiCEF/Rg0CIAQgBCgCaDYCECAEIAY2AgwgBCAINgIIIAVBBBAZDAkLIARB4ABqIgUgCyAGQQAQmAYgBCATKQIANwNIIAQgEygCCDYCUCAEKAJgDQYgBCAEKAJQNgIwIAQgBCkDSDcDKCAEQcgAaiAEQShqEPcEIAQoAkhBf0cEQCAEIAQoAlg2AnAgBCAEKQJQNwNoIAQgBCkCSDcDYCANIAUQ+AQgBCgCYCAEKAJkEAEgBCAEKAJENgIQIAQgBCkCPDcCCAwJCyANIBIoAgg2AgggDSASKQIANwIAIAQoAjwgBCgCQCEGIAQoAkQhB0EEQQQQ5QIhBSAEQeAAaiIPIAYgBxCXBiAFIAEgDxDfAjYCACAGEAEMAgsgBEHgAGoiBkGl4MIAQQZBAUEAEN4CIAEgBhDfAgwDCyAFIAY2AgALQQEhCAsgBUEBQQBBvLXDABAhKAIACyEG", + "IARBfzYCCCAEIAY2AgwgCCAFECYMAwtBACEGIARBADoA+gEgBEEANgKYASAEQoCAgIAQNwKQASAEQgE3AogBIARCADcCgAEgBEKAgICAEDcCeCAEQgE3AsQBIARCADcCvAEgBEKAgICAEDcCtAEgBEIBNwKsASAEQgA3AqQBIARCgICAgMAANwKcASAEQQA2AmAgBEEANgJoIARBADYCcCAEQQA2AtQBIARCADcC5AEgBEKAgICAEDcCzAEgEUIANwIAIBFCADcBBiAEQQA2AuABIARCgICAgBA3AtgBIAdBAnQhDyABIARB4ABqEN8CIQcDQCAGIA9GRQRAIAEgByAFIAZqKAIAEKsFIAZBBGohBgwBCwsgBSAIEOYEIARBfzYCCCAEIAc2AgwMAgsgBCAEKAJQNgIQIAQgBCkDSDcDCAwBCyAEIAc2AhAgBCAFNgIMIAQgCDYCCAsgDCALEAEgBCgCCCEMCyAEKAIMIQUgDEF/Rg0BIAAgBCgCEDYCDCAAIAU2AgggACAMNgIEIABBfjYCACAOIAkQAQsgCiAQEOYEIAQoAhQgBCgCGBAmDAMLIANBBGohAyAEQRRqIAUQ4AIgDiAJEAEMAAsACyAAQQRqQZi1wwBBIhAGIABBfjYCAAsgAhC7BCAEQYACaiQAC+ABAQJ/IwBBMGsiBSQAIAVBGGoiBiACIAMQyAUgBSABIAYgBBC5BCAFQQRqIQICQCAFKAIAIgNBfkYEQCAAQQE2AgAgACACKAIINgIMIAAgAikCADcCBAwBCyAFIAUpAhA3AiggBSADNgIYIAUgAikCADcCHCAFIAIoAggiAjYCJCAAAn8gAigCEARAIABBBGogASgCBCABKAIIIAIoAgwoAgAQrAIiAUEoaigCACABQSxqKAIAEEJBAAwBCyAAQQRqQfi0wwBBIBAGQQELNgIAIAVBGGoQuwQLIAVBMGokAAu4AQEBfyMAQSBrIgUkACAFIAQ2AgggBSADNgIEIAJBGGwhAiABQRhrIQEg", + "AAJ/AkADQCACRQ0BIAJBGGshAiABQRhqIgEgAyAEEPsGRQ0ACyAFQQxqIAFBEGooAgAgAUEUaigCABBCIAUoAgxBf0YNACAAIAUoAhQ2AgwgACAFKQIMNwIEQQAMAQsgBUECNgIcIAUgBUEEajYCGCAAQQRqQajfwgAgBUEYahAMQQELNgIAIAVBIGokAAusAwELfyMAQbABayIEJAACQCABLQA2RQRAIARBADYCrAEgBEKAgICAwAA3AqQBIARBCGogAigCDCIGKAIMIAYoAhAQiwMgBCgCEEECdCEMIAQoAgwhBiAEKAIIIQkgAygC3AEhDQNAAkACQAJAIAcgDEcEQCAEQQhqIAEgAiAGIAdqKAIAIA0Q7wYgBCgCFCEFIAQoAhAhAyAEKAIMIQggBCgCCEUNASAAIAU2AgwgACADNgIIIAAgCDYCBCAAQX42AgAMAgsgBiAJEOYEIAAgAiAEQaQBahC2BQwFCyAEQQhqIAEoAhwgASgCICADIAUQ8AYgBCgCFCEKIAQoAhAhBSAEKAIMIQsgBCgCCEEBRw0BIAAgCjYCDCAAIAU2AgggACALNgIEIABBfjYCACAIIAMQAQsgBiAJEOYEIAQoAqQBIAQoAqgBECYMAwsgBEEIaiIOQePfwgBBBSAFIAoQ3gIgBEGkAWogASAOEN8CEOACIAsgBRABIAggAxABIAdBBGohBwwACwALIABBBGpBmLXDAEEiEAYgAEF+NgIACyACELsEIARBsAFqJAALHQAgAEEEakGsmcMAQc8AEAYgAEF+NgIAIAIQuwQLjwQBCH8jAEHAAWsiBCQAIARBADYCCCAEQoCAgIDAADcCACAEQRhqIAIoAgwiAygCDCADKAIQEIsDIAQoAhwiCCAEKAIgQQJ0aiEKIAQoAhghCSAIIQMDQAJAAkACQAJAAkAgAyAKRwRAIAEoAgQiBSABKAIIIgYgAygCACIHEKwCLQCaAQ4CAgMBCyAIIAkQ5gQgACACIAQQtgUMBAsgBSAGIAcQ", + "rAIhASAEQQM2AhwgBCABQRhqNgIYIABBBGpB8ZfAACAEQRhqEAwgAEF+NgIAIAggCRDmBCAEKAIAIAQoAgQQJgwDCyAFIAYgBxCsAigCRCEGQQAhBSAEQQA2AhQgBEKAgICAwAA3AgwDQCAFIAZGRQRAIARBtAFqIAUQrAUgBEEYaiILQZzfwgBBBSAEKAK4ASIHIAQoArwBEN4CIARBDGogASALEN8CEOACIAQoArQBIAcQASAFQQFqIQUMAQsLIAEgARD0BiIFIAQoAhAiBiAEKAIUEOgEIAQoAgwgBhAmDAELIAUgBiAHEKwCIQUgBEEBOgAkIARBATYCICAEIAUoAkAiBjYCGCAEIAYgBSgCREECdGo2AhwgBEG0AWogBEEYahD1BiABIAEQ9AYiBSAEKAK4ASIGIAQoArwBEOgEIAQoArQBIAYQJgsgA0EEaiEDIAQgBRDgAgwBCwsgAhC7BCAEQcABaiQAC9oBAQF/IwBBoAFrIgEkACABQRxqQbDewgBBBRAGIAFBADoAngEgAUIBNwI4IAFCADcCMCABQoCAgIAQNwIoIAFCATcCaCABQgA3AmAgAUKAgICAEDcCWCABQgE3AlAgAUIANwJIIAFCgICAgMAANwJAIAFBADYCBCABQQA2AgwgAUEANgIUIAFBADYCeCABQQA2AowBIAFCgICAgBA3AnAgAUKAgICAEDcCfCABQgA3AoQBIAFCADcBlgEgAUIANwKQASAAIAFBBGoQ3wJBAEEBEAEgAUGgAWokAAvaAgEIfyMAQSBrIgIkACACQRRqIgMgARCaBAJAAkAgAigCGEEBRgRAIAIgAigCHEEEQQQQByACQQA2AhAgAiACKQMANwIIIAMgARCaBCACKAIYQQFGBEAgAkEIaiACKAIcEJcEIAEoAgghByABKAIEIQUgASgCACEDIAIoAhAhBCACKAIMIQYgAS0ADEEBcUUNAiADIAVGDQMgBiAEQQJ0aiADKAIANgIAIARBAWohBCADQQRqIQMM", + "AgtB0NvCAEEjQeTbwgAQNQALQdDbwgBBI0Gw28MAEDUACyAFIANrIQEgBiAEQQJ0aiEFIAdBAnQiBkEEaiEIIAZBfHMhCQNAIAcgAUECdk9FBEAgBSADIAZqKAIANgIAIAVBBGohBSADIAhqIQMgASAJaiEBIARBAWohBAwBCwsgAiAENgIQCyAAIAIoAhA2AgggACACKQIINwIAIAJBIGokAAvbCgIPfwF+IwBBsAJrIgQkACAEQQhqIAIQvQUCQAJAIAQoAhQiBigCEARAIAQgASgCBCABKAIIIAYoAgwoAgAQrAIoAkQiC0EEQQwQByAEQQA2AogCIAQgBCgCBCIDNgKEAiAEIAQoAgAiBzYCgAIgByALSQRAIARBgAJqQQAgC0EEQQwQLyAEKAKIAiEIIAQoAoQCIQMLIAMgCEEMbGohBUEBIAsgC0EBTRsiB0EBayEJA0AgCQRAIARBIGpBBEEAEIsDIAUgBCgCKDYCCCAFIAQpAiA3AgAgCUEBayEJIAVBDGohBQwBBSAHIAhqIQwCQCALRQRAQQBBBBAmIAxBAWshDAwBCyAFQQA2AgggBUKAgICAwAA3AgALIAQoAoACIRAgBEEgaiAGKAIMIAYoAhAQiwMgAyAMQQxsIgdqIREgBCgCJCIGIAQoAihBAnRqIQ4gBCgCICESIAYhCgNAAkACQCAKIA5HBEAgBEEgaiABKAIEIAEoAgggCigCABCsAiIFQUBrKAIAIAVBxABqKAIAEIsDIAQoAigiDyALSQ0BIApBBGohCkEAIQkgBCgCJCENIAchBSADIQgDQCAFRQ0DIAggDSAPIAlB+LHDABAhKAIAEOACIAVBDGshBSAJQQFqIQkgCEEMaiEIDAALAAsgBiASEOYEIARBADYCrAIgBEKAgICAwAA3AqQCIAQgETYCyAEgBCAQNgLEASAEIAM2ArwBIARB3AFqIQ0gBEGEAmohDgNAAkAgBCADIBFHBH8gA0EMaiEHIAMoAgAiBUF/Rw0BIAcFIAML", + "NgLAASAEQbwBahD3BiAAIARBCGogBEGkAmoQtgUMCQsgBCADKQIENwLQASAEIAU2AswBIARBADYCoAIgBEKAgICAwAA3ApgCIARBIGoiBSAEQQhqIARBmAJqELYFIARBgAJqIAEgBSAEQcwBahD4BiAEIA4pAgA3A/ABIAQgDigCCDYC+AEgBCgCgAIiA0F+Rg0HIAQpApACIRMgDSAEKAL4ATYCCCANIAQpA/ABNwIAIAQgEzcC6AEgBCADNgLYASAFIAQoAuQBIgMoAgwgAygCEBCLAyAEKAIoQQJ0IQYgBCgCJCEPIAQoAiAhCEEAIQUDQCAFIAZGRQRAIAEgBSAPaigCABDsBCEKIAEoAgQgASgCCCAKEOECIgNBADYCECADQQA2AgggBEGkAmogChDgAiAFQQRqIQUMAQsLIA8gCBDmBCAEQdgBahC7BCAHIQMMAAsACyAAQQRqQYiywwBB3wAQBiAAQX42AgAgBCgCICAEKAIkECYgBiASEOYEIAMhBQNAIAwEQCAFKAIAIAVBBGooAgAQJiAMQQFrIQwgBUEMaiEFDAELCyAQIAMQ9QIMBgsgBCgCICANECYMAAsACwALAAsgBEE4akG13sIAQQUQBiAEQcQAakHnssMAQQIQBiAEQQE6ALoBIARBADYCWCAEQoCAgIAQNwJQIARCATcChAEgBEIANwJ8IARCgICAgBA3AnQgBEIBNwJsIARCADcCZCAEQoCAgIDAADcCXCAEQQA2AiAgBEEANgKoASAEQQA2ApQBIARCgICAgBA3AowBIARBADYCMCAEQQA2AiggBEIANwKgASAEQoCAgIAQNwKYASAEQgA3AbIBIARCADcCrAEgASAEQSBqEN8CIQFBAEEBEAFBAEEBEAEgACAEQQhqIAEQtAUMAQsgBCAHNgLAASAAIAQoAvgBNgIMIAAgBCkD8AE3AgQgAEF+NgIAIARBvAFqEPcGIAQoAqQCIAQoAqgCECYLIARBCGoQuwQgAhC7BCAEQbACaiQA", + "C0oBAn8gACgCDCAAKAIEIgFrQQxuIQIDQCACBEAgASgCACABQQRqKAIAECYgAkEBayECIAFBDGohAQwBCwsgACgCCCAAKAIAEPUCC+EFAQ5/IwBB8ABrIgQkAAJAAkACQCADKAIIIgYEQCADKAIEIggoAgAhByAGQQJ0QQRrIgUEQCAIIAhBBGogBfwKAAALIARBDGohBSADIAZBAWs2AgggBEE4aiIGIAIgBxC0BSAEQQA2AGEgBEEBOgBgIARBADoAZSAEQQhqIAEgBiAEQeAAahD2BSAEKAIIIgZBfkYEQCAAQX42AgAgACAFKAIINgIMIAAgBSkCADcCBCADKAIAIAgQJgwDCyAEIAQpAhg3AjAgBCAGNgIgIAQgBSkCADcCJCAEIAUoAgg2AiwgAigCDCIFKAIQIgZFDQEgBEEANgJcIARCgICAgMAANwJUIARBOGogBSgCDCAGEIsDIAQoAjwiBiAEKAJAQQJ0aiEOIAQoAjghCyAEKAIsIQwgBiEFA0ACQCAFIA5HBEAgBSgCACEPIARBOGogDCgCDCAMKAIQEIsDIAVBBGohBSAEKAJAQQJ0IRAgBCgCPCEJIAQoAjghDUEAIQcMAQsgBiALEOYEIARBOGoiBSACIARB1ABqELYFIAQgAygCCDYCaCAEIAMpAgA3A2AgACABIAUgBEHgAGoQ+AYgBEEgahC7BAwECwJAA0AgByAQRg0BIAcgCWooAgAhCiABIA8Q7AQhESAEQQA2AGcgBEIANwNgIARBOGogASACIBEgCiAEQeAAahC8ByAEKAI4IgpBf0YEQCAEQdQAaiAEKAI8EOACIAdBBGohBwwBCwsgACAEKQI8NwIIIAAgCjYCBCAAQX42AgAgCSANEOYEIAYgCxDmBCAEKAJUIAQoAlgQJiAEQSBqELsEIAMoAgAgCBAmDAQLIAkgDRDmBAwACwALIAAgAikCEDcCECAAIAIpAgg3AgggACACKQIANwIAIAMoAgAgAygCBBAmDAILIAQgAygC", + "CDYCQCAEIAMpAgA3AzggACABIARBIGogBEE4ahD4BgsgAhC7BAsgBEHwAGokAAvfBwIUfwF+IwBB4AFrIgQkACAEQQA2AjggBEKAgICAwAA3AjAgBEHEAGogAigCDCIFKAIMIAUoAhAQiwMgBCgCSCEJIAQoAkQhCyADQRxqIQwgA0EeaiENIANBCGohEiAEKAJMQQJ0IRMgAygCCCIUQYCAgIB4RyEVIARB0AFqIQ4gBEHoAGohFiAEQRRqIQcgAi0AFCEPIAMoAswBIRAgAygCyAEhEUEJIAMoAhgiA0GAgICAeHMgA0EAThtBAWshFwJAAkADQCAIIBNHBEAgBEHEAGogASgCBCIFIAEoAggiBiAIIAlqKAIAEPoGIAQoAkghAyAEKAJEIgpBf0cEQCAEIAQoAkw2AhwgBCADNgIYIAQgCjYCFAwDCwJAAkACQAJAIBcOAwEAAgALIARBADsBQCAEQQA2AjwMAgsgBCAMLwEEOwFAIAQgDCgCADYCPAwBCyAEIA0vAQQ7AUAgBCANKAEANgI8CwJAAkAgFEEATgRAIBJBhLzDAEECEPsGDQELIAUgBiADEKwCIgpBHGooAgAgCkEgaigCAEGl4MIAQQYQEkUgD0EBcXINASAFIAYgAxDhAiIFIBU6AJoBIAUoAhggBUEcaigCABABIAVBADYCICAFQoCAgIAQNwIYIAEoAgghBiABKAIEIQUMAQsgBSAGIAMQrAIaCwJAAkACQAJAIAUgBiADEKwCLQCaAQ4CAQIACyAEQgQ3AhggBEIANwIQDAILIBYgESAQEEIgBEECOgDeASAEQQA2AnwgBEKAgICAEDcCdCAEQQA2AmQgBEKAgICAEDcCXCAEQgE3AqgBIARCADcCoAEgBEKAgICAEDcCmAEgBEIBNwKQASAEQgA3AogBIARCgICAgMAANwKAASAEQQA2AkQgBEEANgJMIARBADYCVCAEQQA2ArgBIARCADcCyAEgBEKAgICAEDcCsAEgDkIANwIAIA5C", + "ADcBBiAEQQA2AsQBIARCgICAgBA3ArwBIAEgBEHEAGoiBhDfAiEFQQBBARABIAQgBTYCRCAEQRBqIAEgAyAGQQEgBC0AQBD8BgwBCyAEQcQAaiIFIBEgEBCXBiAEQRBqIAEgDyADIAEgBRDfAiAEQTxqQQAQ/QYLIAQoAhANAiAEIAcpAgA3AyAgBCAHKAIINgIoIAhBBGohCCAEQTBqIARBIGoQ/gYMAQsLIAkgCxDmBCAAIAIgBEEwahC2BQwBCyAEIAcoAggiATYCCCAEIAcpAgAiGDcDACAAIAE2AgwgACAYNwIEIABBfjYCACAJIAsQ5gQgBCgCMCAEKAI0ECYLIAIQuwQgBEHgAWokAAv4BgIOfwN+IwBBQGoiBCQAIARBKGoQggEgBEHA28IAKQMANwMIIARByNvCACkDADcDECAEIAQpAzA3AyAgBCAEKQMoNwMYIARBGGohDgJAA0AgASACIAMQrAItAJoBQQNGBEAgBCADNgI4IAQpAxggBCkDICADEIAEIRMgBCAEQThqNgI8IAQoAhBFBEACQCMAQUBqIgUkACAFIA42AgwgBEEIaiIHKAIMIQkgBSAFQQxqNgIQIAlBAWoiBgRAAn8CQCAHKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAZJBEAgBUEwakEEIAhBAWoiCCAGIAYgCEkbEJcDIAUoAjQiCCAFKAIwIgZFDQIaIAUoAjghCyAFIAUoAjw2AiwgBSALNgIoIAUgCDYCJCAFIAY2AiAgBUKEgICAgAE3AhggBSAHQRBqNgIUIAcoAgAiDCkDAEJ/hUKAgYKEiJCgwIB/gyESIAVBIGohD0EAIQoDQCAJBEADQCASUARAIApBCGohCiAMQQhqIgwpAwBCf4VCgIGChIiQoMCAf4MhEgwBCwsgBiAGIAggBUEQaiAHIBJ6p0EDdiAKaiIQEIEEIhQQhQEiDWogFKdBGXYiEToAACAGIAggDUEIa3FqQQhqIBE6AAAgBiANQX9zQQJ0", + "aiAHKAIAIBBBf3NBAnRqKAAANgAAIAlBAWshCSASQgF9IBKDIRIMAQsLIAUgBygCDCIGNgIsIAUgCyAGazYCKCAHIA8QmAMgBUEUahCZAwwBCyAHIAVBEGpBG0EEEJoDC0EACxogBUFAayQADAELEIEBAAsLIAQgBEEIajYCLCAEIARBPGo2AiggBCAEKAIIIAQoAgwgEyAEQShqQTsQlQMgBCgCAEEBcUUEQCAAQbDOwwBBFBAGDAMLIAQoAggiBSAEKAIEIgdqIgYtAAAhCSAGIBOnQRl2IgY6AAAgBSAEKAIMIAdBCGtxakEIaiAGOgAAIAUgB0ECdGtBBGsgAzYCACAEIAQoAhRBAWo2AhQgBCAEKAIQIAlBAXFrNgIQIAEgAiADEKwCIgUoAgBBAUYEQCAFKAIEIQMMAgsLCyAAQX82AgAgACADNgIECyAEKAIMIgAEQCAEKAIIIARBKGpBBEEIIABBAWoQhwEgBCgCKBogBCgCMGsgBCgCLBCIAQsgBEFAayQACx8BAX8gAiAAKAIIRgR/IAAoAgQgASACEPoHBUEBC0ULlAUCBn8CfiMAQeABayIGJAACQCAEBEAgBkEANgIQIAZCgICAgMAANwIIIAMgBEECdGohCiAGQShqQQRyIQkgBUEBcSELA0ACQAJAAkACQCADIApHBEAgBkEUaiIIIAEoAgQiBCABKAIIIgUgAygCABCsAiIHQShqKAIAIAdBLGooAgAQQiAGQShqIAYoAhgiByAGKAIcEPsFIAYoAihFDQEgBiAJKAIINgJAIAYgCSkCADcDOCALDQIgBkEdNgJQIAZBAzYCSCAGIAZBOGo2AkwgBiAINgJEIABBBGpB2s7AACAGQcQAahAMIABBATYCACAGKAI4IAYoAjwQASAGKAIYIQcMAwsgACAGKAIQNgIMIAAgBikCCDcCBCAAQQA2AgAMBgsgBiAGKQMwIgw3AyADQCAGIAQgBSACEKwCKAJEIgitIg03AyggDCANUwRAIAxCP4cg", + "DYMgDHwiDEIAWQRAIAZBCGogBCAFIAIQrAIiBEFAaygCACAEQcQAaigCACAMp0HgzsMAECEoAgAQ4AIMBQsgBkEhNgJQIAZBITYCSCAGIAZBKGo2AkwgBiAGQSBqNgJEIABBBGpB4ITAACAGQcQAahAMIABBATYCAAwDCyAIRQRAIAQgBSACEOECQQA2AoQBCyAGQcQAaiIEQaXgwgBBBkHg4MIAQQQQ3gIgASACIAEgBBDfAhCrBSABKAIIIQUgASgCBCEEDAALAAsgBigCOCAGKAI8EAEMAQsgBigCFCAHEAEgBigCCCAGKAIMECYMAwsgA0EEaiEDIAYoAhQgBxABDAALAAsgAEEEaiABKAIEIAEoAgggAhCsAiIBQUBrKAIAIAFBxABqKAIAEIsDIABBADYCAAsgBkHgAWokAAuJBQEEfyMAQdABayIHJAAgB0IENwIgIAdCADcCGCAHQoCAgIDAADcCECAHQShqIAEoAgQgASgCCCAEEKwCIghBKGooAgAgCEEsaigCABBCIAdBNGogASAHQRBqIgogAyAHKAIsIgggBygCMCAFIAYQtgcCQCAHKAI0IglBf0cEQCAAIAcpAjg3AgggACAJNgIEIABBATYCACAHKAIoIAgQASAKEPECIAcoAhwgBygCIBAmDAELIAdBHGohCQJAIAYNACAFLQACQQFxIAJBAXFyDQAgBygCJA0AIAdBzABqQaXgwgBBBhAGIAdB2ABqQeDgwgBBBBAGIAdBAjoAzgEgB0EANgJsIAdCgICAgBA3AmQgB0IBNwKYASAHQgA3ApABIAdCgICAgBA3AogBIAdCATcCgAEgB0IANwJ4IAdCgICAgMAANwJwIAdBADYCNCAHQQA2ArwBIAdBADYCqAEgB0KAgICAEDcCoAEgB0EANgJEIAcgAzYCQCAHQQE2AjwgB0IANwK0ASAHQoCAgIAQNwKsASAHQgA3AcYBIAdCADcCwAEgASAHQTRqEN8CIQJBAEEBEAFBAEEBEAEgASgC", + "BCIGIAEoAggiCiADEKwCKAJERQRAIAYgCiADEOECQQA2AoQBCyAHQQhqIAEgAyAEIAIQ6QQgBygCDCECIAUtAAEEQCAHQTRqIgQgASgCBCABKAIIIAcoAggiAxCSBiAHQRBqIAQgAxC3BwsgBS0AAw0AIAdBNGoiAyABKAIEIAEoAgggAhCSBiAHQRBqIAMgAhC3BwsgAEEANgIAIAAgCSgCCDYCDCAAIAkpAgA3AgQgBygCKCAIEAEgB0EQahDxAgsgB0HQAWokAAtWAQR/IAEoAgQhAiABKAIAIAAgASgCCCIBEJcEIAAoAgghAwJAIAFFDQAgAUECdCIFRQ0AIAAoAgQgA0ECdGogAiAF/AoAAAsgACABIANqNgIIIAIQJguZDgIKfwN+IwBB8AJrIgQkACAEQbgBaiADLQDRASIFIAMoAtgBELEFIAQoArwBIQcCQCAEKAK4ASIGQX9HBEAgACAEKALAATYCDCAAIAc2AgggACAGNgIEIABBfjYCAAwBCyAEQbgBaiAFIAMoAtwBELIFIAQoArwBIQYgBCgCuAEiBUF/RwRAIAAgBCgCwAE2AgwgACAGNgIIIAAgBTYCBCAAQX42AgAMAQsCQAJAAkACQCAGKALcASIFBEAgBS0A0QFBHkYNAQsgBEE8aiEFIARBuAFqIgggAhC7BSAEQThqIAEgCCAHEN0EIAQoAjgiCkF+Rw0BIABBfjYCACAAIAUoAgg2AgwgACAFKQIANwIEDAQLIARBDGohAyAEQbgBaiIGIAIQuwUgBEEIaiABIAYgBxDdBCAEKAIIIgdBfkYEQCAAQX42AgAgACADKAIINgIMIAAgAykCADcCBAwECyAEIAc2AiAgBCAEKQIYNwIwIARBADYC7AIgBEKAgICAwAA3AuQCIAQgAykCADcCJCAEIAMoAggiAzYCLCAEQbgBaiADKAIMIAMoAhAQiwMgBCgCvAEiByAEKALAAUECdGohCyAEKAK4ASEKIAUoAtwBIQwgBSgC2AEhDSAH", + "IQUDQAJAAkAgBSALRwRAIARBuAFqIgMgASAEQSBqIgggBSgCACIGIA0QgAcgBCgCuAENBSAEKQPAASEPIAMgASAIIAYgDBCAByAEKAK4AUEBRg0FIAQpA8ABIRAgAyABKAIEIAEoAgggBhCsAhDnBAJAAkAgBC0A0gJBAkYEQCAEQdAAaiABIAYQrQIgBCgCVCIDIAQoAlhB49/CAEEFEBIgBCgCUCADEAENAQsgBCgC/AEhCEEAIQkgBEEANgJYIARCgICAgMAANwJQIAitIg4gEEI/h4MgEHwiEEIAWQ0BQQQhA0EAIQgMAwsgBEHYAmogBCgC4AEiAyADIAQoAuQBahAgIAQgBCgC3AIiCCAEKALgAiIDIAOtIg4gD0I/h4MgD3wiDyAOIA4gD1YbQgAgD0IAWRsiD6cgDyAQQj+HIA6DIBB8IhAgDiAOIBBWGyIOIA8gDiAPVhsgEEIAUxunQai6wwAQJCAEQdAAaiAEKAIAIgMgAyAEKAIEQQJ0ahAlIAEgBkECIAQoAtQBIAQoAtgBIAQoAlQiBiAEKAJYEOwFIQMgBCgCvAIhCSABKAIEIAEoAgggAxDhAiAJNgKEASAEQeQCaiADEOACIAQoAlAgBhABIAQoAtgCIAgQJgwDCyAQIA4gDiAQVhsiECAPQj+HIA6DIA98Ig8gDiAOIA9WG0IAIA9CAFkbIg99Ig5CACAOIBBYGyEOIA+nIQMgBCgC+AEhCQNAIA5QBEAgBCgCUCEJIAQoAlghCCAEKAJUIQMMAwUgBEHQAGogCSAIIANBmLrDABAhKAIAEOACIA5CAX0hDiADQQFqIQMMAQsACwALIAcgChDmBCAAIARBIGogBEHkAmoQtgUMBQsgASABIAZBACAEKALUASAEKALYAUEBQQAQ7AUiBiADIAgQ6AQgBEHkAmogBhDgAiAJIAMQJgsgBUEEaiEFIARBuAFqEMIEDAALAAsgBEHsAGohByAEIAQpAkg3ArABIAQgCjYCoAEgBCAFKQIANwKk", + "ASAEIAUoAgg2AqwBIARBuAFqIgUgAhC+BSAEQegAaiABIAUgBhDdBAJAAkAgBCgCaCIFQX5GBEAgAEF+NgIAIAAgBygCCDYCDCAAIAcpAgA3AgQMAQsgBCAEKQJ4NwJgIAQgBTYCUCAEIAcpAgA3AlQgBCAHKAIINgJcAkAgAygCGEGBgICAeEYEQCAEIAMvASA7AYQBIAQgAygCHDYCgAEMAQsgBEEAOwGEASAEQQA2AoABCyAEKAJcIgUoAhAEQCAEQYwBaiEDIARB2AJqIAEoAgQgASgCCCAFKAIMKAIAEKwCIgVBQGsoAgAgBUHEAGooAgAQiwMgBEGIAWogASAEQaABaiAEKALcAiIFIAQoAuACIARBgAFqEIEHIAQoAogBIgdBfkcNAiAAQX42AgAgACADKAIINgIMIAAgAykCADcCBCAEKALYAiAFECYgBEHQAGoQuwQMBQsgAEEEakHEzsMAQRoQBiAAQX42AgAgBEHQAGoQuwQLIARBoAFqELsEDAMLIAMoAggiASABKAIAQQFqIgY2AgAgBCAEKQKYATcCyAEgBCAHNgK4ASAEIAMpAgA3ArwBIAQgATYCxAEgBgRAIAAgAiABEOoFIARBuAFqELsEIAQoAtgCIAUQJiAEQdAAahC7BAwDCwALIAQoArwBIQEgACAEKQPAATcCCCAAIAE2AgQgAEF+NgIAIAcgChDmBCAEKALkAiAEKALoAhAmCyAEQSBqELsECyACELsEIARB8AJqJAAL/gEBAn8jAEFAaiIFJAAgBUEcaiIGIAIgAxC0BSAFQQRqIAEgBiAEELkEIAVBCGohAgJAIAUoAgQiA0F+RgRAIABBATYCACAAIAIoAgg2AgwgACACKQIANwIEDAELIAUgBSkCFDcCLCAFIAM2AhwgBSACKQIANwIgIAUgAigCCCICNgIoIAIoAhAiA0EBRgRAIAAgASgCBCABKAIIIAIoAgwoAgAQrAIiACgCKCAAKAIsEPsFIAVBHGoQuwQMAQsgBSAD", + "NgI0IAVBBDYCPCAFIAVBNGo2AjggAEEEakHsxsAAIAVBOGoQDCAAQQE2AgAgBUEcahC7BAsgBUFAayQAC9QGAg5/AX4jAEGAAmsiBiQAIAZBADYCNCAGQoCAgIDAADcCLCAGQThqIAIoAgwiBygCDCAHKAIQEIsDIARBAnQhESAGKAI8Ig4gBigCQEECdGohEiAGKAI4IQ8gBkE8aiEMIAZBFGohCyAFLQAEIRMgAi0AFCEQIA4hDQNAAkACQAJAAkAgDSASRwRAIAZBOGogASgCBCIHIAEoAggiCCANKAIAEPoGIAYoAjwhCSAGKAI4IgpBf0cEQCAGIAYoAkA2AhwgBiAJNgIYIAYgCjYCFCAGQQE2AhAMAwsCQAJAAkAgByAIIAkQrAIiCkEcaigCACAKQSBqKAIAQaXgwgBBBhASBH8gBAR/IAcgCCADKAIAEKwCIgpBHGooAgAgCkEgaigCAEGc38IAQQUQEkEBcwVBAAshCiAHIAggCRDhAiIHKAIYIAdBHGooAgAQASAHIAo6AJoBIAdBADYCICAHQoCAgIAQNwIYIAEoAgghCCABKAIEBSAHCyAIIAkQrAItAJoBDgIBAgALIAZCBDcCGCAGQgA3AhAMBAsgBkEQaiABIAkgAyAEIBMQ/AYMAwsgBARAIAZBADYC3AEgBkKAgICAwAA3AtQBIBEhByADIQgDQCAHRQ0DIAZBOGogASAQIAkgCCgCACAFQQAQ/QYgBigCOARAIAYgDCgCCCIHNgLoASAGIAwpAgAiFDcD4AEgCyAHNgIIIAsgFDcCACAGQQE2AhAgBigC1AEgBigC2AEQJgwFBSAGIAwpAgA3A/ABIAYgDCgCCDYC+AEgB0EEayEHIAhBBGohCCAGQdQBaiAGQfABahD+BgwBCwALAAsgBkE4aiIHQQFBABCXBiAGQRBqIAEgECAJIAEgBxDfAiAFQQEQ/QYMAgsgDiAPEOYEIAAgAiAGQSxqELYFDAILIAsgBigC3AE2AgggCyAGKQLU", + "ATcCACAGQQA2AhALIAYgCykCADcDACAGIAsoAgg2AgggBigCEEUNASAAIAYoAgg2AgwgACAGKQMANwIEIABBfjYCACAOIA8Q5gQgBigCLCAGKAIwECYLIAIQuwQgBkGAAmokAA8LIA1BBGohDSAGIAYoAgg2AiggBiAGKQMANwMgIAZBLGogBkEgahD+BgwACwALIAAgACACKQIQNwIQIAAgAikCCDcCCCAAIAIpAgA3AgAL3gEBAn8jAEHQAmsiBCQAIARBqAFqIgUgA0EoahCEBwJAIAQoAqgBQQJHBEAgBEEMaiAFQZwB/AoAAAwBCyAEQQxqQaXgwgBBBkHg4MIAQQQQ3gILAkAgAigCDCgCECIDBEAgBEEANgLMAiAEQoCAgIDAADcCxAIDQCADBEAgBEGoAWoiBSAEQQxqEOcEIARBxAJqIAEgBRDfAhDgAiADQQFrIQMMAQsLIAAgAiAEQcQCahC2BSAEQQxqEMIEDAELIAAgAiABIARBDGoQ3wIQtAULIAIQuwQgBEHQAmokAAscACABKAIAQQJHBEAgACABEOcEDwsgAEECNgIACzgAAkAgAygCAEEBRgRAIAAgAiADKAIEELQFDAELIABBBGpB87zDAEEhEAYgAEF+NgIACyACELsEC/sDAQV/IwBBsAFrIgQkAAJAAkAgAS0ANUUEQAJ/AkAgAygCKEECRg0AIARBFGogAygCUCADKAJUEEIgBCgCFEF/Rg0AIAQgBCkCFDcDCCAEIAQoAhwiBjYCECAEKAIMDAELIARBADYCECAEQoCAgIAQNwMIQQELIQcgBEEUaiABKAIQIAEoAhQgByAGEIcHQQAgBCgCFCIGIAZBf0YiBRshCEEBIAQoAhggBRshBkEAIAQoAhwgBRshBQJAAkACQAJAIAMoAhhBjICAgHhGBEAgAy0AHEEBcQ0BCyAFRQ0BIARBFGogASAGIAVBABC0BCAEKAIgIQEgBCgCHCEDIAQoAhghBSAEKAIURQ0CIAAgATYCDCAA", + "IAM2AgggACAFNgIEIABBfjYCAAwDCyAEQRRqIgNB49/CAEEFIAYgBRDeAiABIAMQ3wIhAQwECyAEQQM2AhggBCAEQQhqNgIUIABBBGpBn83AACAEQRRqEAwgAEF+NgIADAELIAEEQCADKAIAIQEgBSADECYMAwsgAEEEakHNs8MAQQMQBiAAQX42AgAgBSADECYLIAggBhABIAQoAgggBCgCDBABDAILIABBBGpB0LPDAEEhEAYgAEF+NgIADAELIAAgAiABELQFIAggBhABIAQoAgggBxABCyACELsEIARBsAFqJAALTwAgAkEYbCECIAFBGGshAQJAA0AgAkUNASACQRhrIQIgAUEYaiIBIAMgBBD7BkUNAAsgACABQRBqKAIAIAFBFGooAgAQQg8LIABBfzYCAAuxAQEFfyMAQSBrIgMkACADQQA2AhwgA0KAgICAwAA3AhQgA0EIaiACKAIMIgUoAgwgBSgCEBCLAyADKAIQQQJ0IQYgAygCDCEFIAMoAgghBwNAIAQgBkZFBEAgA0EUaiABQQEgBCAFaigCACIIIAEoAgQgASgCCCAIEKwCELgCQQFzEJ4GEOACIARBBGohBAwBCwsgBSAHEOYEIAAgAiADQRRqELYFIAIQuwQgA0EgaiQAC7QEAQh/IwBB0AFrIgMkACADQQA2AswBIANCgICAgMAANwLEASADIAIoAgwiBSgCDCAFKAIQEIsDIAMoAghBAnQhCyADKAIEIQggAygCACEJIANBGGohCgNAAkACQAJ/AkACQAJAAkAgBiALRwRAIAMgASgCBCABKAIIIAYgCGooAgAiBRCsAhDnBCADLQCaAUECRw0CIAMoAhwiBCADKAIgIgdBnN/CAEEFEBINBiAEIAdBod/CAEEHEBINBiADQagBaiIHIAMoAiggAygCLBCyAiADKAKoASAHEMMCRQ0BQZzfwgAhB0EFDAULIAggCRDmBCAAIAIgA0HEAWoQtgUMBgsgA0GoAWoiBCADKAIoIAMoAiwQ", + "kAMgAygCqAENAiADQZwBaiIGIAEgBRD9BSADQQM2ArwBIAMgCjYCuAEgA0EDNgK0ASADQQM2AqwBIAMgA0EkajYCqAEgAyAGNgKwASAAQQRqQdy+wAAgBBAMDAELIANBnAFqIgQgASAFEP0FIANBAzYCtAEgAyAKNgKwASADQQM2AqwBIAMgBDYCqAEgAEEEakGovsAAIANBqAFqEAwLIAMoApwBIAMoAqABEAEgAEF+NgIAIAMQwgQgCCAJEOYEIAMoAsQBIAMoAsgBECYMAwtBod/CACEHQQcLIQQgASAFQQIgByAEIAMoAiggAygCLBDsBSEFCyADQcQBaiAFEOACIAZBBGohBiADEMIEDAELCyACELsEIANB0AFqJAALNgAjAEEQayIBJAAgAUEANgIMIAFCgICAgMAANwIEIAAgAiABQQRqELYFIAIQuwQgAUEQaiQAC+oOAhp/AX4jAEGQA2siBCQAAkACQAJAIAEtADVFBEAgBEKAgICAwAA3AuwBIAMtAB8hBSADLQAdIAMtAB4gBEEANgL0ASADKAIYIQMgBEFAayACKAIMIg4oAgwgDigCEBCLA0EAIANBjICAgHhGIgMbIRFBACADGyESIAMgBXEhEyAEKAJEIg4gBCgCSEECdGohGCAEKAJAIRQgBEHgAWohCiAEQbwCaiEPIARBoAJqIRAgBEHQAmohGSAEQdgAaiEaIA4hDQNAAkAgDSAYRwRAIARBQGsgASgCBCABKAIIIA0oAgAiGxCsAhDnBCAEKAJcIAQoAmBB49/CAEEFELECDQQgDUEEaiENIARB+AFqIAQoAmgiAyADIAQoAmxqECBBACEDIARBADYCjAIgBEKAgICAEDcChAIgBEEANgKYAiAEQoCAgIDAADcCkAIgBCgCgAIhBwwBCyAOIBQQ5gQgACACIARB7AFqELYFDAULA0ACQAJAAkACQAJAIAMgB08EQCAEKAKYAiIDRQ0BIAogBCgClAIgA0GUtMMAQQEQpwIgBCgC/AEh", + "CwwDCyADQQFqIQUgBCgC/AEiCyAHIANBmLTDABAhKAIAIgZBJEYNASAEQYQCaiAGENcCDAQLIAogBCgCjAI2AgggCiAEKQKEAjcCACAEQZACahDxAiAEKAL4ASAEKAL8ARAmIAQoAuABIARB7AFqIAEgG0ECQePfwgBBBSAEKALkASIFIAQoAugBEOwFEOACIAUQASAEQUBrEMIEDAULIAUgB08EQCAEQYQCakEkENcCDAMLAkACQAJAIAsgByAFQai0wwAQISgCACIGQfsARwRAIAZBJEcNASAEQYQCakEkENcCIANBAmohAwwHCyAEQThqIAsgByADQQJqIghBuLTDABDNAiAEKAI8QQJ0IQNBACEGIAQoAjghCQNAIANFDQUgCSgCAEH9AEYNAiADQQRrIQMgBkEBaiEGIAlBBGohCQwACwALIAYQjAcEQCAFIQMgBkE6a0F1TQ0CCyAEQYQCakEkENcCDAQLIARBMGogCyAHIAggBiAIaiIcQci0wwAQJCAEQawCaiAEKAIwIgMgAyAEKAI0QQJ0ahAlIAQoArQCIQMgBCgCsAIhDCAEQQA2AtgCIAQgAyAMajYC1AIgBCAMNgLQAiAEIAM2AswCIAQgDDYCyAIDQAJAIARBKGogGRCVAiAEKAIsIgZBf0YEQCADIQUMAQsgBCgCKCEFIAYQ2QYgBkHfAEZyDQELCyAEQSBqIAUgDCADQfSzwwAQ5AIgBCgCJCEVIAQoAiAhFiAEQRhqIAUgDCADQYS0wwAQvwIgBCgCHCEFIAQoAhghBiAEQQE2AowDIARBrpfDADYCiAMgBEEBNgKEAyAEQcSzwwA2AoADIARBATYC/AIgBEGwm8MANgL4AiAEQQE2AvQCIARBwJfDADYC8AIgBEECNgLsAiAEQcuzwwA2AugCIARBAjYC5AIgBEHHs8MANgLgAiAEQQI2AtwCIARBybPDADYC2AIgBEECNgLUAiAEQcWzwwA2AtACQQAhCUEAIQMCQANAIANBCGoiCEHI", + "AEYEQEEBIRcMAgsgBEEQaiAEQcgCaiADaiIDQQhqKAIAIhcgA0EMaigCACIdIAYgBRCaAiAIIQMgBCgCECIIRQ0ACyAEKAIUIQUgHSEJIAghBgsgBEHIAmoiAyABKAIQIAEoAhQgFiAVEIcHIARBnAJqIBYgFSADIBcgCSAGIAUgEiAREI0HAkACQCAEKAKcAgRAIBMNAiAEQZACaiAQELwBDAELIAQoAqACIARBhAJqIAQoAqQCIgUgBCgCqAIQCiAFEAELIAQoAqwCIAwQASAcQQFqIQMMBQsgCiAQKAIINgIIIAogECkCADcCACAEKAKsAiAMEAEMAQsDQAJAIAMgB08NACALIAcgA0HYtMMAECEoAgAQjAdFDQAgA0EBaiEDDAELCyAEQQhqIAsgByAFIANB6LTDABAkIARBrAJqIAQoAggiBSAFIAQoAgxBAnRqECUgBEHIAmoiCCABKAIQIAEoAhQgBCgCsAIiBSAEKAK0AiIGEIcHIARBuAJqIAUgBiAIQQFBAEEBQQAgEiAREI0HAkACQCAEKAK4AgRAIBMNAiAEQZACaiAPELwBDAELIAQoArwCIARBhAJqIAQoAsACIgkgBCgCxAIQCiAJEAELIAQoAqwCIAUQAQwECyAKIA8oAgg2AgggCiAPKQIANwIAIAQoAqwCIAUQAQsgBEGQAmoQ8QIgBCgChAIgBCgCiAIQASAEKAL4ASALECYgBCkC4AEhHiAAIAQoAugBNgIMIAAgHjcCBAwGCyAEQYQCakEkENcCCyAFIQMMAAsACwALIABBBGpB0LPDAEEhEAYgAEF+NgIADAILIARBAzYCzAIgBCAaNgLIAiAAQQRqQbPAwAAgBEHIAmoQDAsgAEF+NgIAIARBQGsQwgQgDiAUEOYEIAQoAuwBIAQoAvABECYLIAIQuwQgBEGQA2okAAsOACAAENkGIABB3wBGcgvFBQEDfyMAQSBrIgokACAKIAI2AgQgCiABNgIAIAogBzYCDCAKIAY2AghBACAD", + "KAIAIgsgC0F/RiIMGyECQQEgAygCBCAMGyEBQQAgAygCCCAMGyEDAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQgBUHAl8MAQQEQEkUEQCAEIAVBxLPDAEEBEBJFDQELIAxFDQEgAEEEaiAGIAcQBiAAQQA2AgAMCgsCQCAEIAVBxbPDAEECEBJFBEAgBCAFQcezwwBBAhASRQ0BCyADDQMgAEEEaiAGIAcQBiAAQQA2AgAMCgsgBCAFQbCbwwBBARASDQYgBCAFQcmzwwBBAhASDQUgBCAFQa6XwwBBARASRQRAIAQgBUHLs8MAQQIQEg0CIAtBf0cNASAIQQFxRQ0DIApBAjYCFCAKIAo2AhAgAEEEakHKl8AAIApBEGoQDCAAQQE2AgAMCgsgC0F/Rg0ECyADIAlBAXFFcg0BIApBAjYCFCAKIAo2AhAgAEEEakGolsAAIApBEGoQDCAAQQE2AgAMCAsgA0UNAQsgACADNgIMIAAgATYCCCAAIAI2AgQgAEEANgIADAcLIApBAjYCHCAKQQI2AhQgCiAKQQhqNgIYIAogCjYCECAAQQRqQf2AwAAgCkEQahAMIABBATYCAAwFCyAKQQI2AhwgCkECNgIUIAogCkEIajYCGCAKIAo2AhAgAEEEakH9gMAAIApBEGoQDCAAQQE2AgAMBAsgA0UNASAKQRBqIAYgBxAGDAILAkAgC0F/RwRAIApBEGogBiAHEAYMAQsgCkEANgIYIApCgICAgBA3AhALIAAgCigCGDYCDCAAIAopAhA3AgQgAEEANgIADAILIApBADYCGCAKQoCAgIAQNwIQCyAAIAooAhg2AgwgACAKKQIQNwIEIABBADYCAAsgAiABEAELIApBIGokAAvGAQEBfyMAQUBqIgQkAAJAIAMoAhhBhICAgHhGBEAgBCADKAAfNgALIAQgAygCHDYCCAwBCyAEQQA2AAsgBEEANgIICyAEQQA2AjwgBEKAgICAwAA3AjQgBEEcaiIDIAIQuwUgBEEQ", + "aiABIARBNGogAyAEQQhqEI8HAkAgBCgCECIBQX9HBEAgACAEKQIUNwIIIAAgATYCBCAAQX42AgAgBCgCNCAEKAI4ECYMAQsgACACIARBNGoQtgULIAIQuwQgBEFAayQAC40DAgt/AX4jAEHgAGsiBSQAIAVBMGogAygCDCIGKAIMIAYoAhAQiwMgBSgCOEECdCENIAUoAjQhCCAFKAIwIQogBC0ABkEBcyEOIAVBzABqIQsgBUEcaiEMQQAhBgNAAkACQAJAIAYgDUcEQCACIAYgCGooAgAiBxDgAiABKAIEIAEoAgggBxCsAiIJLQCaASIPQQNGDQMgCSgCREUNAyAPRSAOcUUNAQwDCyAIIAoQ5gQgAEF/NgIADAELIAVBMGoiCSADIAcQtAUgBUEYaiABIAkgBBD2BSAFIAwpAgA3AwggBSAMKAIINgIQAkAgBSgCGCIHQX5GBEAgACAFKAIQNgIIIAAgBSkDCDcCAAwBCyAFKQIoIRAgCyAFKQMINwIAIAsgBSgCEDYCCCAFIAc2AkggBSAQNwJYIAVBMGogASACIAVByABqIAQQjwcgBSgCMCIHQX9GDQIgACAFKQI0NwIEIAAgBzYCAAsgCCAKEOYECyADELsEIAVB4ABqJAAPCyAGQQRqIQYMAAsAC8MGAgx/AX4jAEGQAWsiBCQAIARBGGoiBSACEL4FIAQgASAFIAMoAtwBELkEIARBBGohAwJAIAQoAgAiBUF+RgRAIABBfjYCACAAIAMoAgg2AgwgACADKQIANwIEDAELIAQgBCkCEDcCKCAEIAU2AhggBCADKQIANwIcIAQgAygCCCIDNgIkAkAgAygCEARAIARBQGsgASgCBCABKAIIIAMoAgwoAgAiAxCsAiIFQShqKAIAIAVBLGooAgAQQiAEQcwAaiABKAIEIAEoAgggAxCsAiIDQRxqKAIAIANBIGooAgAQQgwBCyAEQUBrQeDgwgBBBBAGIARBzABqQaXgwgBBBhAGCyAEIAQoAkg2Ajgg", + "BCAEKQJANwMwIARBADYChAEgBEKAgICAwAA3AnwgBCgCTCELIAQoAlAhByAEKAJUIQ0gBEHoAGogAigCDCIDKAIMIAMoAhAQiwMgBCgCbCIIIAQoAnBBAnRqIQ4gBCgCaCEMIAghBQNAAkACQAJAAkACQCAFIA5HBEBBACEJIAEoAgQgASgCCCAFKAIAIg8QrAIiAy0AmgEOAgIBBQsgCCAMEOYEIAAgAiAEQfwAahC2BSALIAcQASAEKAIwIAQoAjQQASAEQRhqELsEDAYLIAMoAkQiBkUNAyABKAIEIAEoAgggBEFAayADKAJAIgooAgAQsQRFDQEMAgsgByANQZzfwgBBBRASRQ0CIARB6ABqIAQoAjQgBCgCOBDCAiAELQBoQQFGBEAgBEEDNgKMASAEIARBMGo2AogBIARB2ABqQQRyQcaWwAAgBEGIAWoQDCAEKAJcIQEgACAEKQNgNwIIIAAgATYCBCAAQX42AgAgCCAMEOYEIAQoAnwgBCgCgAEQJiALIAcQASAEKAIwIAQoAjQQASAEQRhqELsEDAULIAQpA3AiEEIAUw0CIBAgAzUCRFQhCQwCCyAGQQJ0QQRrIQMgCkEIaiEGA0AgA0EFSQ0CIANBCGshAyAGKAIAIQogBkEIaiEGIAEoAgQgASgCCCAEQUBrIAoQsQRFDQALC0EBIQkLIAVBBGohBSAEQfwAaiABQQEgDyAJEJ4GEOACDAALAAsgAhC7BCAEQZABaiQAC2wBA38jAEHAA2siAyQAIANBCGoiBEHzABDNBCADQegBaiIGQecAEM0EQQhB4AEQ5QIiBSAGQdgB/AoAACAFQgA3A9gBIAMgBTYC5AEgA0EANgLgASAAIAEgAiAEEJIHIAQQ1wQgA0HAA2okAAuXDQIbfwN+IwBBwAFrIgQkACAEQQA2AqwBIARCgICAgMAANwKkASAEQRBqIAIoAgwiCigCDCAKKAIQEIsDIAQoAhQiDSAEKAIYQQJ0aiEYIAQoAhAhEiAEQYQBaiEL", + "IARBxABqIRMgBEHsAGohFCAEQSBqIRkgAygC3AEhGiANIQoCQAJAAkADQCAKIBhGDQIgASgCBCABKAIIIAooAgAiDhCsAi0AmgFFBEAgCkEEaiEKIARBgAFqIgUQggFBACEDIARBwNvCACkDADcDECAEQcjbwgApAwA3AxggBCAEKQOIATcDKCAEIAQpA4ABNwMgIARBADYCPCAEQoCAgIDAADcCNCAFIAEoAgQgASgCCCAOEKwCIgVBQGsoAgAgBUHEAGooAgAQiwMgBCgCiAFBAnQhGyAEKAKEASEPIAQoAoABIRUDQAJAAkACQAJAIAMgG0cEQCAEQYABaiIFIAIgAyAPaigCACIcEMgFIARB6ABqIAEgBSAaELkEIAQgFCkCADcDWCAEIBQoAgg2AmAgBCgCaCIFQX5HDQEgACAEKAJgNgIMIAAgBCkDWDcCBCAAQX42AgAMAgsgDyAVEOYEIAEgDiABKAIEIAEoAgggDhCsAigChAEQoQYhBSAEKAI8QQJ0IQZBACEDIAQoAjghByAEKAI0IQkDQCADIAZHBEAgASAFIAMgB2ooAgAQqwUgA0EEaiEDDAELCyAHIAkQ5gQgBEGkAWogBRDgAiAEQRBqEJMHDAYLIAQpAnghHyATIAQoAmA2AgggEyAEKQNYNwIAIAQgHzcCUCAEIAU2AkAgBCgCTCIFKAIQRQ0BIAEoAgQgASgCCCAFKAIMKAIAIgUQrAItAJoBQQJGBEAgCyABKAIEIAEoAgggBRCsAiIFQShqKAIAIAVBLGooAgAQQgwDCyAEQYABaiABIAVBAEEAEJEGIAQoAoABQQFHDQIgBCALKAIIIgE2AnAgBCALKQIAIh83A2ggACABNgIMIAAgHzcCBCAAQX42AgAgBEFAaxC7BAsgDyAVEOYEIAQoAjQgBCgCOBAmIARBEGoQkwcMBQsgC0Hg4MIAQQQQBgsgBCALKQIANwOYASAEIAsoAggiBTYCoAEgBCkDICAEKQMoIAQoApwBIAUQjgMh", + "ICAEIARBmAFqNgJoIAQoAhhFBEACQCMAQUBqIgUkACAFIBk2AgwgBEEQaiIHKAIMIQkgBSAFQQxqNgIQIAlBAWoiBgRAAn8CQCAHKAIEIgggCEEBakEDdkEHbCAIQQhJGyIIQQF2IAZJBEAgBUEwakEMIAhBAWoiCCAGIAYgCEkbEJcDIAUoAjQiCCAFKAIwIgZFDQIaIAUoAjghFiAFIAUoAjw2AiwgBSAWNgIoIAUgCDYCJCAFIAY2AiAgBUKMgICAgAE3AhggBSAHQRBqNgIUIAcoAgAiFykDAEJ/hUKAgYKEiJCgwIB/gyEfIAVBIGohHUEAIRADQCAJBEADQCAfUARAIBBBCGohECAXQQhqIhcpAwBCf4VCgIGChIiQoMCAf4MhHwwBCwsgBiAGIAggBUEQaiAHIB96p0EDdiAQaiIREP4DIiEQhQEiDGogIadBGXYiHjoAACAGIAggDEEIa3FqQQhqIB46AAAgBiAMQX9zQQxsaiIMIAcoAgAgEUF/c0EMbGoiESgACDYACCAMIBEpAAA3AAAgCUEBayEJIB9CAX0gH4MhHwwBCwsgBSAHKAIMIgY2AiwgBSAWIAZrNgIoIAcgHRCYAyAFQRRqEJkDDAELIAcgBUEQakEZQQwQmgMLQQALGiAFQUBrJAAMAQsQgQEACwsgBCAEQRBqNgKEASAEIARB6ABqNgKAASAEQQhqIAQoAhAgBCgCFCAgIARBgAFqQTwQlQMCQCAEKAIIQQFxRQRAIAQoApgBIAQoApwBEAEMAQsgBCgCECIFIAQoAgwiB2oiBi0AACEJIAQoAqABIQggBCkDmAEhHyAGICCnQRl2IgY6AAAgBSAEKAIUIAdBCGtxakEIaiAGOgAAIAUgB0F0bGpBDGsiBSAfNwIAIAUgCDYCCCAEIAQoAhxBAWo2AhwgBCAEKAIYIAlBAXFrNgIYIARBNGogHBDgAgsgA0EEaiEDIARBQGsQuwQMAAsACwsgAEEEakGasMMAQSQQBiAAQX42AgAL", + "IA0gEhDmBCAEKAKkASAEKAKoARAmDAELIA0gEhDmBCAAIAIgBEGkAWoQtgULIAIQuwQgBEHAAWokAAvrAQIBfgl/IwBBEGsiAiQAIAAoAgQiBgRAIAAoAgAhAwJAIAAoAgwiBEUNACADQQhqIQAgAykDAEJ/hUKAgYKEiJCgwIB/gyEBIAMhBQNAIARFDQEDQCABQgBSRQRAIAVB4ABrIQUgACkDAEJ/hUKAgYKEiJCgwIB/gyEBIABBCGohAAwBCwsgBSABeqdBA3ZBdGxqIgdBDGsoAgAgB0EIaygCABABIARBAWshBCABQgF9IAGDIQEMAAsACyACQQRqQQxBCCAGQQFqEIcBIAMgAigCDGsgAigCBCEJIAIoAggQiAELIAJBEGokAAs9AQF/IAAoAgAoAgAiAkEEaigCACACQQhqKAIAIAAoAgQoAgAgAUF0bGoiAEEIaygCACAAQQRrKAIAEJYDC5wKAhN/AX4jAEGgAmsiBCQAIARBADYCnAIgBEKAgICAwAA3ApQCIARB+ABqIAIoAgwiBigCDCAGKAIQEIsDIAQoAnwiDSAEKAKAAUECdGohEiAEKAJ4IQ4gBEGEAmohDyAEQZABaiETIARBPGohECAEQeQAaiERIAMoAtwBIRQgDSELAkACQAJAA0AgCyASRg0CIAEoAgQgASgCCCALKAIAIggQrAItAJoBRQRAIAtBBGohC0EAIQMgBEEANgIUIARCgICAgMAANwIMIARBGGoQ5gIgBEH4AGogASgCBCABKAIIIAgQrAIiBkFAaygCACAGQcQAaigCABCLAyAEKAKAAUECdCEMIAQoAnwhBiAEKAJ4IQkDQAJAAkAgAyAMRwRAIARB+ABqIgUgAiADIAZqKAIAIgoQyAUgBEHgAGogASAFIBQQuQQgBCARKQIANwNQIAQgESgCCDYCWCAEKAJgIgVBfkcNAiAAIAQoAlg2AgwgACAEKQNQNwIEIABBfjYCACAGIAkQ5gQgBEEYahDyAiAEKAIUIQMg", + "BCgCECIAIQEDQCADRQ0CIANBAWshAyABEJYHIAFBGGohAQwACwALIAYgCRDmBCABIAhBAEGw3sIAQQVBAUEAEOwFIQkgBCgCFCEGIAQoAhAhAyAEIAQoAgw2AmggBCADNgJgIAQgAyAGQRhsaiIINgJsA0ACQCAEIAMgCEcEfyADQRhqIQYgAygCACIFQX9HDQEgBgUgCAs2AmQgBEHgAGoQlwcgBEGUAmogCRDgAiAEQRhqEPICDAYLIAMoAgQhFSADKAIMIRYgAygCECEKIAMoAhQgE0Gw3sIAQQUQBkEAIQMgBEEAOgCSAiAEQgE3AqwBIARCADcCpAEgBEKAgICAEDcCnAEgBEIBNwLcASAEQgA3AtQBIARCgICAgBA3AswBIARCATcCxAEgBEIANwK8ASAEQoCAgIDAADcCtAEgBEEANgJ4IARBADYCgAEgBEEANgKIASAEQQA2AuwBIARBADYCgAIgBEKAgICAEDcC5AEgBEKAgICAEDcC8AEgBEIANwL4ASAPQgA3AQYgD0IANwIAIAEgBEH4AGoQ3wIhDEEAQQEQAUECdCEHA0AgAyAHRkUEQCABIAwgAyAKaigCABCrBSADQQRqIQMMAQsLIAogFhDmBCABIAkgDBCrBSAFIBUQASAGIQMMAAsACyAEKAIMIAAQAgwECyAEKQJwIRcgECAEKAJYNgIIIBAgBCkDUDcCACAEIBc3AkggBCAFNgI4AkAgBCgCRCIFKAIQBEAgBEHgAGogASgCBCABKAIIIAUoAgwoAgAQrAIiBUEoaigCACAFQSxqKAIAEEIMAQsgBEHgAGpB4ODCAEEEEAYLAkAgBEEYaiAEQeAAahCIAyIFBEAgBCgCECAEKAIUIAUoAgBB5K/DABCYB0EMaiAKEOACIAQoAmAgBCgCZBABDAELIARB+ABqIgcgBCgCZCAEKAJoEEIgBEEYaiAHIAQoAhQQjwMgBCAEKAJoNgKAASAEIAQpAmA3A3hBBEEEEOUCIgUgCjYCACAEQQE2", + "AowBIAQgBTYCiAEgBEEBNgKEASAEQQxqIAcQmQcLIANBBGohAyAEQThqELsEDAALAAsLIABBBGpB9K/DAEEmEAYgAEF+NgIACyANIA4Q5gQgBCgClAIgBCgCmAIQJgwBCyANIA4Q5gQgACACIARBlAJqELYFCyACELsEIARBoAJqJAALGgAgACgCACAAKAIEEAEgACgCDCAAKAIQECYLPwECfyAAKAIMIAAoAgQiAWtBGG4hAgNAIAIEQCACQQFrIQIgARCWByABQRhqIQEMAQsLIAAoAgggACgCABACCw8AIAAgASACIANBGBCECAtLAQF/IAAoAggiAiAAKAIARgRAIAAQJwsgACACQQFqNgIIIAAoAgQgAkEYbGoiACABKQIANwIAIAAgASkCCDcCCCAAIAEpAhA3AhAL7wECBX8BfiMAQRBrIgQkACADKQMgIQkgAygCGCEDIARBBGogAigCDCIFKAIMIAUoAhAQiwNCfyAJIANBiICAgHhHGyEJIAQoAgxBAnQhByAEKAIIIQUgBCgCBCEGQQAhAwJAAkADQCADIAdHBEAgASgCBCABKAIIIAMgBWooAgAiCBCsAi0AmgENAiABIAggCRCbByADQQRqIQMMAQsLIAUgBhDmBCAAIAIpAhA3AhAgACACKQIINwIIIAAgAikCADcCAAwBCyAAQQRqQaSvwwBBJRAGIABBfjYCACAFIAYQ5gQgAhC7BAsgBEEQaiQAC88CAQl/IwBBIGsiAyQAAkAgAlANACAAKAIEIgYgACgCCCIHIAEQrAItAJoBDQAgA0EIaiAGIAcgARCsAiIEQUBrKAIAIARBxABqKAIAEIsDIANBADYCHCADQoCAgIDAADcCFCACQgF9IQIgAygCDCIIIAMoAhBBAnRqIQkgAygCCCEKIAghBANAAkAgBCAJRwRAIAQoAgAhBSAEQQRqIQQgBiAHIAUQrAItAJoBRQ0BIANBFGogBRDgAgwCCyAIIAoQ5gQgBiAHIAEQ4QIiBCgCPCAE", + "QUBrKAIAECYgBEKAgICAwAA3AjwgBEEANgJEIAAgASADKAIYIgAgAygCHBDoBCADKAIUIAAQJgwCCyAAIAUgAhCbByADQRRqIAAoAgQiBiAAKAIIIgcgBRCsAiIFKAJAIgsgCyAFKAJEQQJ0ahCbBAwACwALIANBIGokAAuuDAENfyMAQcABayIEJAAgBEHIAGoiBSACEL4FIARBMGogASAFIAMoAtwBELkEIAQgBCkCNDcDmAEgBCAEKAI8NgKgAQJAAkAgBCgCMCIFQX5GBEAgACAEKAKgATYCDCAAIAQpA5gBNwIEIABBfjYCAAwBCyAEIAQpA5gBNwIcIAQgBCgCoAEiAzYCJCAEIAQpAkA3AiggBCAFNgIYIARByABqIAMoAgwiBSAFIAMoAhBBAnRqEMAFIAQoAkwiDiAEKAJQQQJ0aiEQIAQoAkghDyAOIQUDQAJAAkACQAJAAkACQAJAIAUgEEcEQCAEIAUoAgAiAzYCZCABKAIEIAEoAgggAxCsAiIGKAIIRQ0BIAYoAgwhBiAEQegAaiABIAMQvwYgBCgCcCIDRQ0GIAQoAmwgA0EEdGpBEGsiA0UNBiAEQcgAaiADEJ0HIAEoAgQgASgCCCAGEKwCLQCaAQ4CAwQCCyAOIA8Q5gQgACACKQIQNwIQIAAgAikCCDcCCCAAIAIpAgA3AgAgBEEYahC7BAwJCyACKAIMIgEoAhAhAyAEIAEoAgwiATYCMCAEIAEgA0ECdGo2AjQgBCAEQeQAajYCOCAEQRBqIARBMGoQnAQCQCAEKAIQQQFGBEAgBCgCFCEBIARBCGpBBEEEQQQQByAEKAIIIQMgBCgCDCIFIAE2AgAgBEEBNgK8ASAEIAU2ArgBIAQgAzYCtAEgBCAEKAI4NgJQIAQgBCkCMDcDSEEEIQFBASEDA0AgBCAEQcgAahCcBCAEKAIAQQFHDQIgBCgCBCEGIAQoArQBIANGBEAgBEG0AWpBARCXBCAEKAK4ASEFCyABIAVqIAY2AgAgBCAD", + "QQFqIgM2ArwBIAFBBGohAQwACwALIARBADYCvAEgBEKAgICAwAA3ArQBCyAAIAIgBEG0AWoQtgUMBQsgASgCBCABKAIIIAYQrAIhASAEQQM2AjQgBCABQRhqNgIwIABBBGpB24zAACAEQTBqEAwgAEF+NgIAIARByABqEMQCIARB6ABqEMQGDAQLIARB9ABqIAEoAgQgASgCCCAGEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMgBEGYAWogBEHIAGoQhARBACEDIARBADYClAEgBEKAgICAwAA3AowBIAQoAnxBAnQhCiAEKAKgASELIAQoApwBIQwgBCgCeCENQQAhCANAAkAgAyAKRwRAIARBMGogCBCsBSAEKAI0IgcgBCgCOCAMIAsQngcgBCgCMCAHEAFFDQEgBEGAAWogBCgClAEQrAUgASgCBCABKAIIIAMgDWooAgAiCRCsAiIHKAIQQQFGBEAgASgCBCABKAIIIAcoAhQQ4QIiBygCJCAHQShqKAIAEAEgByAEKAKIATYCLCAHIAQpAoABNwIkIARBjAFqIAkQ4AIMAgsgBEGMAWogCRDgAiAEKAKAASAEKAKEARABDAELIAEoAgQgASgCCCAGEOECIgMoAjwgA0FAaygCABAmIAMgBCgClAE2AkQgAyAEKQKMATcCPCABKAIEIAEoAgggBhCfByAEKAKYASAMEAEgBCgCdCANECYMAwsgCEEBaiEIIANBBGohAwwACwALIARBmAFqIAEoAgQgASgCCCAGEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMgBEEwaiAEQcgAahCEBEEAIQMgBEEANgKwASAEQoCAgIDAADcCqAEgBCgCOCEJIAQoAjQhDCAEKAKcASEIIAQoAqABIQcDQCAHIANBAWoiCksEQCAIIAcgA0HQusMAECEoAgAhDSAIIAcgCkHgusMAECEoAgAhCiABKAIEIAEoAgggDRCsAiILQShqKAIAIAtBLGooAgAgDCAJEJ4HBEAgBEGoAWoi", + "CyANEOACIAsgChDgAgsgA0ECaiEDDAELCyABKAIEIAEoAgggBhDhAiIDKAI8IANBQGsoAgAQJiADIAQoArABNgJEIAMgBCkCqAE3AjwgASgCBCABKAIIIAYQnwcgBCgCMCAMEAEgBCgCmAEgCBAmCyAEQcgAahDEAgsgBUEEaiEFIARB6ABqEMQGDAELCyAOIA8Q5gQgBEEYahC7BAsgAhC7BAsgBEHAAWokAAs+AQF/QQEhAgJAIAEoAgBBAUYEQCAAQQRqIAEoAgggASgCDBBCDAELIAAgASkDCDcDCEEAIQILIAAgAjYCAAsQACAAIAEgAiADEJYDQQFzC/gCAgd/AX4jAEEQayIEJAACQCAAIAEgAhCsAiIDLQCaAUEBSw0AIAMoAkQNACADKAJcDQAgAygCFCEGIAMoAhAhCAJAAkAgAygCCEEBRw0AIAAgASADKAIMIgMQrAItAJoBQQFHDQAgBCAAIAEgAxCsAiIDQUBrKAIAIANBxABqKAIAEIsDQQAhAyAEKAIEIQUgBCgCCCEHA0AgByADQQFqIglNBEAgBCgCACAFECYMAgsgAiAFIAcgCUHwusMAECEoAgBHBEAgA0ECaiEDDAELCyAFIAcgA0GAu8MAECEoAgAhBiAEKAIAIAUQJgwBCyAIRQ0BCyAAIAEgBhCsAigCXEUNACAAIAEgBhDhAiIDKAJcIQUgA0EANgJcIAMpAlQhCiADQoCAgIAQNwJUIAQgBTYCCCAEIAo3AwAgACABIAIQ4QIiACgCVCAAQdgAaigCABABIABBIDYChAEgACAEKAIINgJcIAAgBCkDADcCVAsgBEEQaiQAC4YZARJ/IwBBkAJrIgQkACAEQQA2AjQgBEKAgICAwAA3AiwgBEHwAGogAigCDCIDKAIMIAMoAhAQiwMgBCgCdCISIAQoAnhBAnRqIRUgBCgCcCEUIARB/AFqIQsgEiERA0ACQAJAAkACQAJAAkACQAJAAkACQAJ/AkAgESAVRwRAIAEoAgQiCCAB", + "KAIIIgkgESgCACIHEKwCIgNBHGooAgAgA0EgaigCAEGw3sIAQQUQsQINBiAEQRRqIAggCSAHEKwCIgNBQGsoAgAgA0HEAGooAgAQiwNBACEDIARBADYCKCAEQoCAgIAQNwIgIAQoAhwiBQ0BQQEMAgsgEiAUEOYEIAAgAiAEQSxqELYFDAsLIARB8ABqIAggCSAEKAIYIgMoAgAQrAIiBkEcaigCACAGQSBqKAIAEEJBAEEBEAEgBCAEKAJ4NgIoIAQgBCkCcDcDICAEQQE2AmggBCADIAVBAnRqNgJkIAQgAzYCYANAIARB4ABqEJkEIgMEQCAEQdAAaiAIIAkgAygCABCsAiIDQRxqKAIAIANBIGooAgAQQiAEKAJUIgMgBCgCWCAEKAIkIAQoAigQngcNAyAEKAJQIAMQAQwBCwsgBCgCKCEDIAQoAiQLIgUgA0Gw3sIAQQUQEg0CIAUgA0G13sIAQQUQEg0FIAQgAzYCVCAEIAU2AlAgBEECNgJ0IAQgBEHQAGo2AnAgAEEEakHxjsAAIARB8ABqEAwgAEF+NgIADAELIARBAzYCfCAEQQM2AnQgBCAEQdAAajYCeCAEIARBIGo2AnAgAEEEakH5vcAAIARB8ABqEAwgAEF+NgIAIAQoAlAgBCgCVBABIAQoAiQhBQsgBCgCICAFEAEgBCgCFCAEKAIYECYMAgsgBEE4aiAIIAkgBxCsAiIDQUBrKAIAIANBxABqKAIAEIsDIAQoAjwhCiAEKAJAIg5FDQRBACEIIARBADYCTCAEQoCAgIDAADcCRCAKIA5BAnRqIQwDQCAKIAxGDQQgBEHwAGogASgCBCABKAIIIAooAgAQrAIiA0FAaygCACADQcQAaigCABCLAyAEKAJ0IgkgBCgCeEECdGohD0EAIQcgBCgCcCEQIAkhAwNAIAMgD0cEQCAEKAJMIgVBDGwhBiADKAIAIQ0DQCAFIAdLBEAgASAEKAJIIgYgBSAHQdiuwwAQoQcgCBCiByAGIAUgB0Ho", + "rsMAEKEHIA0Q4AIgB0EBaiEHIANBBGohAwwDCyAEKAJEIAVGBEAgBEHEAGoQvQELIAQoAkggBmoiE0KAgICAwAA3AgAgE0EIakEANgIAIAQgBUEBaiIFNgJMIAZBDGohBgwACwALCyAJIBAQ5gQgCEEBaiEIIApBBGohCgwACwALIAggCSAHEKwCIQEgBEEDNgJ0IAQgAUEYajYCcCAAQQRqQaqNwAAgBEHwAGoQDCAAQX42AgALIBIgFBDmBCAEKAIsIAQoAjAQJgwECyAEQThqIAggCSAHEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMCQCAEKAJAIg5FBEAgBEEBOgCKAiAEQQA2AqgBIARCgICAgBA3AqABIARCATcCmAEgBEIANwKQASAEQoCAgIAQNwKIASAEQgE3AtQBIARCADcCzAEgBEKAgICAEDcCxAEgBEIBNwK8ASAEQgA3ArQBIARCgICAgMAANwKsASAEQQA2AnAgBEEANgJ4IARBADYCgAEgBEEANgLkASAEQgA3AvQBIARCgICAgBA3AtwBIAtCADcCACALQgA3AQYgBEEANgLwASAEQoCAgIAQNwLoASABIARB8ABqEN8CIQcMAQtBACEJIARBADYCTCAEQoCAgIDAADcCRCAEKAI8IgcgDkECdGohDwNAIAcgD0cEQCAEQeAAaiABKAIEIAEoAgggBygCABCsAiIDQUBrKAIAIANBxABqKAIAEIsDQQAhCgNAIApBAXIiCCAEKAJoIgNPBEAgBCgCYCAEKAJkECYgCUEBaiEJIAdBBGohBwwDCyAEKAJkIgUgAyAKQdCtwwAQISEGIARB0ABqIAEoAgQgASgCCCAGKAIAEKwCIgZBKGooAgAgBkEsaigCABBCIAUgAyAIQeCtwwAQISgCACEQIAQoAkwiCEEYbCEGQQAhAyAEKAJYIQ0gBCgCVCETIAQoAkgiDCEFAkADQCAGBEAgBUEEaigCACAFQQhqKAIAIBMgDRCWAw0CIAZBGGshBiAD", + "QQFqIQMgBUEYaiEFDAELCyAEIAQoAlg2AnggBCAEKQJQNwNwIARBADYChAEgBEKAgICAwAA3AnwgBEHEAGogBEHwAGoQmQcgBCgCTCIIQQFrIQMgBCgCSCEMCyABIAwgCCADQfCtwwAQmAdBDGogCRCiByAEKAJIIAQoAkwgA0GArsMAEJgHQQxqIBAQ4AIgBgRAIAQoAlAgBCgCVBABCyAKQQJqIQoMAAsACwsgBEEBOgCKAiAEQQA2AqgBIARCgICAgBA3AqABIARCATcCmAEgBEIANwKQASAEQoCAgIAQNwKIASAEQgE3AtQBIARCADcCzAEgBEKAgICAEDcCxAEgBEIBNwK8ASAEQgA3ArQBIARCgICAgMAANwKsASAEQQA2AnAgBEEANgJ4IARBADYCgAEgBEEANgLkASAEQgA3AvQBIARCgICAgBA3AtwBIAtCADcCACALQgA3AQYgBEEANgLwASAEQoCAgIAQNwLoASABIARB8ABqEN8CIQcgBCgCTCEDIAQoAkghBSAEIAQoAkQ2AlggBCAFNgJQIAQgBSADQRhsIgZqIgk2AlwgBUEYaiEDA0ACQCAEIAYEfyAFKAIAIgpBf0cNASADBSAJCzYCVCAEQdAAahCXBwwCCyAFKAIIIQwgBSgCBCEIIAQgBSgCFDYCaCAEIAUpAgw3A2AgASAEQeAAaiAOEKIHIARBADoAigIgBEEANgKoASAEQoCAgIAQNwKgASAEQgE3ApgBIARCADcCkAEgBEKAgICAEDcCiAEgBEIBNwLUASAEQgA3AswBIARCgICAgBA3AsQBIARCATcCvAEgBEIANwK0ASAEQoCAgIDAADcCrAEgBEEANgJwIARBADYCeCAEQQA2AoABIARBADYC5AEgBEIANwL0ASAEQoCAgIAQNwLcASALQgA3AgAgC0IANwEGIARBADYC8AEgBEKAgICAEDcC6AEgASABIARB8ABqIg0Q3wIiDyAEKAJkIhAgBCgCaBDoBCANQePfwgBBBSAI", + "IAwQ3gIgBEEIaiABIAcgASANEN8CIA8Q6QQgBCgCYCAQECYgCiAIEAEgBkEYayEGIANBGGohAyAFQRhqIQUMAAsACyAEKAI4IAQoAjwQJgwCCyAEQQA6AIoCIARBADYCqAEgBEKAgICAEDcCoAEgBEIBNwKYASAEQgA3ApABIARCgICAgBA3AogBIARCATcC1AEgBEIANwLMASAEQoCAgIAQNwLEASAEQgE3ArwBIARCADcCtAEgBEKAgICAwAA3AqwBIARBADYCcCAEQQA2AnggBEEANgKAASAEQQA2AuQBIARCADcC9AEgBEKAgICAEDcC3AEgC0IANwIAIAtCADcBBiAEQQA2AvABIARCgICAgBA3AugBIAEgBEHwAGoQ3wIhByAEKAJMIQMgBCgCSCEFIAQgBCgCRDYCWCAEIAU2AlAgBCAFIANBDGwiBmoiCDYCXCAFQQxqIQMDQAJAIAQgBgR/IAUoAgAiCUF/Rw0BIAMFIAgLNgJUIARB0ABqEPcGIAQoAjwhCgwCCyAEIAUpAgQ3AmQgBCAJNgJgIAEgBEHgAGogDhCiByAEQQA6AIoCIARBADYCqAEgBEKAgICAEDcCoAEgBEIBNwKYASAEQgA3ApABIARCgICAgBA3AogBIARCATcC1AEgBEIANwLMASAEQoCAgIAQNwLEASAEQgE3ArwBIARCADcCtAEgBEKAgICAwAA3AqwBIARBADYCcCAEQQA2AnggBEEANgKAASAEQQA2AuQBIARCADcC9AEgBEKAgICAEDcC3AEgC0IANwIAIAtCADcBBiAEQQA2AvABIARCgICAgBA3AugBIAEgASAEQfAAahDfAiIJIAQoAmQiCiAEKAJoEOgEIAEgByAJEKsFIAQoAmAgChAmIAZBDGshBiADQQxqIQMgBUEMaiEFDAALAAsgBCgCOCAKECYLIBFBBGohESAEQSxqIAcQ4AIgBCgCICAEKAIkEAEgBCgCFCAEKAIYECYMAQsLIAIQuwQgBEGQAmokAAsP", + "ACAAIAEgAiADQQwQhAgLSAECfyMAQaABayIDJAADQCACIAEoAghNBEAgA0GgAWokAAUgA0EEaiIEQaXgwgBBBkEBQQAQ3gIgASAAIAQQ3wIQ4AIMAQsLCw8AIAAgASACIANBARCvBQusBAEGfyMAQeAAayIFJAAgBUEANgJcIAVCgICAgMAANwJUIAVBPGogAy0A0QEgAygC3AEQsgVBBCEHIAUoAkAhCAJAAkAgBSgCPCIJQX9HBEAgACAFKAJENgIMIAAgCDYCCCAAIAk2AgQgAEF+NgIADAELIAVBKGohBiAFQTxqIgcgAhC7BSAFQSRqIAEgByADKALYARC5BCAFKAIkIgNBfkYEQCAAQX42AgAgACAGKAIINgIMIAAgBikCADcCBEEAIQZBBCEHDAELIAUgBSkCNDcCHCAFIAM2AgwgBSAGKQIANwIQIAUgBigCCDYCGAJAAkAgBC0AEEUNACACKAIMKAIQRQ0AIAUoAhgoAhANACAFQTxqIAEgAkEAIAUgBCAIIAVB1ABqEKUHIAUoAjwiA0F/Rg0AIAAgBSkCQDcCCCAAIAM2AgQgAEF+NgIADAELIAVBPGogBSgCGCIDKAIMIAMoAhAQiwMgBSgCREECdCEJIAUoAkAhBiAFKAI8IQdBACEDAkADQCADIAlGDQEgBUE8aiABIAJBASADIAZqKAIAIAQgCCAFQdQAahClByAFKAI8IgpBf0YEQCADQQRqIQMMAQsLIAAgBSkCQDcCCCAAIAo2AgQgAEF+NgIAIAYgBxDmBAwBCyAGIAcQ5gQgACACIAVB1ABqELYFIAVBDGoQuwQMAgsgBUEMahC7BCAFKAJYIQcgBSgCVCEGCyAGIAcQJgsgBUHgAGokAAvcBAEIfyMAQdAAayIIJAACQAJAIAUoAggiCUUNACAIQThqIAkgASADIAQgBSgCDCgCFBEGACAIKAJAIQkgCCgCPCEKIAgoAjgiC0F/RwRAIAAgCTYCCCAAIAo2AgQgACALNgIADAILIApB", + "AUcNACAHIAkQ4AIgAEF/NgIADAELIAhBJGohCSAIQThqIgogAhC7BSAIQSBqIAEgCiAGEN0EIAgoAiAiBkF+RwRAIAggCCkCMDcCGCAIIAY2AgggCCAJKQIANwIMIAggCSgCCDYCFAJAAkAgBS0AEEUEQCAIKAIUIgkoAhAhBgwBCyAIKAIUIgkoAhAiBg0AIAhBOGogBSgCACABIAIgAyAEQQAgCCAFKAIEKAIUEQkAIAgoAkAhASAIKAI8IQIgCCgCOCIDQX9HBEAgACABNgIIIAAgAjYCBCAAIAM2AgAMAgsgAkEBRgRAIAcgARDgAgsgAEF/NgIADAELIAhBOGogCSgCDCAGEIsDIAgoAkBBAnQhDCAIKAI8IQYgCCgCOCEJIAUoAgQhDSAFKAIAIQ5BACEFA0AgBSAMRwRAIAhBOGogDiABIAIgAyAEQQEgBSAGaigCACANKAIUEQkAIAgoAkAhCiAIKAI8IQsgCCgCOCIPQX9HBEAgACAKNgIIIAAgCzYCBCAAIA82AgAgBiAJEOYEDAMLIAtBAUYEQCAHIAoQ4AILIAVBBGohBQwBCwsgBiAJEOYEIABBfzYCACAIQQhqELsEDAILIAhBCGoQuwQMAQsgACAJKAIINgIIIAAgCSkCADcCAAsgCEHQAGokAAs3ACAAIAIgBCAGciAFIAcgBEEBcRsgAigCBCACKAIIIAYgBxCnBxCeBjYCCCAAQv////8fNwIACxsBAX8gAkEBRgR/IAAgASADEKwCELgCBUEACwtqAgN/AX4gACACEOwEIQJBASEDIAAoAgQiBCAAKAIIIgUgAUGU8sIAELkCIgAtAJkBRQRAIAAoAhAhAyAAKAIUIQELIAApAgghBiAEIAUgAhDhAiIAIAE2AhQgACADNgIQIAAgBjcCCCACCy4BAX8jAEEQayIFJAAgBSABLQAAOgAPIAAgBUEPaiACIAMgBBCqByAFQRBqJAALQgEBfyACKAIEIAIoAgggAyAEEKcHIAEtAAAiAUYE", + "QCAAIAIgAyAEIAEQngY2AghBASEFCyAAQX82AgAgACAFNgIEC3oBA38gACgCCCIDIAAoAgBGBEAjAEEQayICJAAgAkEIaiAAIAAoAgBBAUEIQRAQlwEgAigCCCIEQX9HBEAgAigCDBogBBAcAAsgAkEQaiQACyAAIANBAWo2AgggACgCBCADQQR0aiIAIAEpAwA3AwAgACABKQMINwMIC+QJAQR/IwBBkAJrIggkACAIIAQ2AhggCCADNgIUIAhBHGogASgCBCIKIAEoAggiCSACEKwCEOcEIAhBADYCwAEgCEKAgICAEDcCuAEgBUEBRgRAIAhBxAFqIAogCSAGEKwCEK4HIAhBuAFqIAgoAsgBIgIgCCgCzAEQCiAIKALEASACEAELIAhBxAFqIAhBHGoQrgcgCEG4AWogCCgCyAEiAiAIKALMARAKIAgoAsQBIAIQAQJAAkACQAJAAkACQCAILQC2AUEBaw4DAQMEAAsgCCgCYEECdCECIAgoAlwhBUEAIQYDQCACRQ0CIAUoAgAhCSAIQcQBaiAGEKwFIAhBgAJqIAMgBCAIKALIASIKIAgoAswBEK8HIAhB9AFqIAEgCSAIKAKEAiIJIAgoAogCQQAgCCAHEKwHIAgoAvQBIgtBf0cEQCAAIAgpAvgBNwIEIAAgCzYCACAIKAKAAiAJEAEgCCgCxAEgChABDAYFIAgoAoACIAkQASAIKALEASAKEAEgAkEEayECIAVBBGohBSAGQQFqIQYMAQsACwALQQAhAiAIKAJcIQYgCCgCYCEFA0AgBSACQQFqIgpNBEAgAEF/NgIADAULIAYgBSACQcjAwwAQISEJIAhB9AFqIAEoAgQgASgCCCAJKAIAIgsQrAIiCUEoaigCACAJQSxqKAIAEEIgBiAFIApB2MDDABAhKAIAIQkgCEHEAWogAyAEIAgoAvgBIgogCCgC/AEQrwcgCEGAAmogASAJIAgoAsgBIgkgCCgCzAFBASALIAcQrAcgCCgCgAIiC0F/RwRA", + "IAAgCCkChAI3AgQgACALNgIAIAgoAsQBIAkQASAIKAL0ASAKEAEMBQUgCCgCxAEgCRABIAgoAvQBIAoQASACQQJqIQIMAQsACwALIABBfzYCAAwCCyAIQcQBaiAIKAK8ASAIKALAARCwBwNAIAhBCGogCEHEAWoQsQcgCCgCCCIBBEAgCCgCDCECIAggATYC7AEgCCACNgLwASAIQQI2AvgBIAggCEHsAWo2AvQBIAhBgAJqQeHUwAAgCEH0AWoQDCAIKAKAAiAHIAgoAoQCIgIgCCgCiAIQCiACEAEMAQsLIAgoAkQhASAIKAJIIQIgCEEANgLMASAIQoCAgIAQNwLEASAIIAEgAmo2AvgBIAggATYC9AEDQAJAAkACQAJAAkACQAJAAkAgCEH0AWoQwgEiAUEJaw4FBQMBBgQACyABQdwARg0BIAFBf0YNBgsgCEHEAWogARDXAgwGCyAIQcQBakGcvsMAQQIQCgwFCyAIQcQBakGevsMAQQIQCgwECyAIQcQBakGgvsMAQQIQCgwDCyAIQcQBakGivsMAQQIQCgwCCyAIQcQBakGkvsMAQQIQCgwBCwsgCCAIKQLEATcDgAIgCCAIKALMATYCiAIgCEEDNgLQASAIQQI2AsgBIAggCEGAAmo2AswBIAggCEEUajYCxAEgCEH0AWpB59TAACAIQcQBahAMIAgoAoACIAgoAoQCEAEgByAIKAL4ASIBIAgoAvwBEAogCCgC9AEgARABIABBfzYCAAwBCyAIKAIcRQRAIABBfzYCAAwBCyAAIAEgCCgCICADIARBACAIIAcQrAcLIAgoArgBIAgoArwBEAEgCEEcahDCBCAIQZACaiQAC+oKAQp/IwBB8AJrIgQkACAEQQxqIAEoAgQiByABKAIIIgUgAhCsAhDnBAJAAkACQAJAAkACQAJAAkACQAJAIAQtAKYBDgMBAAIACyAEQQM2AsgBIAQgBEEkajYCxAEgAEEEakG8kcAAIARBxAFqEAwgAEEBNgIADAgL", + "AkACQAJAIAQoAlAiCARAIAQoAkwiAigCACEJIARBADYCsAEgBEKAgICAEDcCqAEgByAFIAkQrAItAJoBQQFrDgIBAgMLIABCATcCCCAAQgA3AgAMCgsgByAFIAkQrAIhAiAEQQE6ANABIARBATYCzAEgBCACKAJAIgY2AsQBIAQgBiACKAJEQQJ0ajYCyAEgBEG0AWogBEHEAWoiAhD1BiACIAcgBSAEKAK4ASIHIAQoArwBIgggAxCyByAEKALQASEFIAQoAswBIQIgBCgCyAEhBiAEKALEAUUEQCAEQagBaiACIAUQCiAGIAIQASAIQQJ0IQggBCgCTCIJIAQoAlBBAnRqIQwDQCAJIAxGDQkgBCAKNgLAASABKAIEIAEoAgggCSgCACILEKwCLQCaAUEBRw0GIAlBBGohCSAKQQFqIQogBEEANgLoAiAEQoCAgIDAADcC4AIgCCEFIAchBgNAAn8CQCAFBEAgBCABIAsgBigCABD+BSAEKAIAQQFxRQ0BIAQoAgQhAiABKAIEIAEoAgggCxCsAiINQUBrKAIAIA1BxABqKAIAIAJBAWpB7L3DABAhKAIADAILIARBxAFqIAEoAgQgASgCCCAEKALkAiIFIAQoAugCIAMQsgcgBCgC0AEhBiAEKALMASECIAQoAsgBIQsgBCgCxAFBAUYEQCAAIAY2AgwgACACNgIIIAAgCzYCBCAAQQE2AgAgBCgC4AIgBRAmDAsLIARBqAFqIAIgBhAKIAsgAhABIAQoAuACIAUQJgwDCyAEQcQBaiICQaXgwgBBBkEBQQAQ3gIgASACEN8CCyECIAZBBGohBiAEQeACaiACEOACIAVBBGshBQwACwALAAsgACAFNgIMIAAgAjYCCCAAIAY2AgQgAEEBNgIADAULIARBxAFqIAcgBSACIAggAxCyByAEKALQASECIAQoAswBIQEgBCgCyAEhAyAEKALEAQ0CIARBqAFqIAEgAhAKIAMgARABDAcLIAhBAnQhAQJAA0AgAUUN", + "CCAEIAY2ArQBIARBxAFqIAcgBSACKAIAEKwCEOcEIAQtAN4CRQRAIARB4AJqIAcgBSAEKAKEAiAEKAKIAiADELIHIAQoAuwCIQkgBCgC6AIhCCAEKALkAiEKIAQoAuACBEAgACAJNgIMIAAgCDYCCCAAIAo2AgQMAwsgAkEEaiECIARBqAFqIAggCRAKIAogCBABIAZBAWohBiABQQRrIQEgBEHEAWoQwgQMAQsLIARBAzYC7AIgBEEENgLkAiAEIARB3AFqNgLoAiAEIARBtAFqNgLgAiAAQQRqQcCPwAAgBEHgAmoQDAsgAEEBNgIAIARBxAFqEMIEDAQLIARBAzYCyAEgBCAEQTBqNgLEASAAQQRqQezUwAAgBEHEAWoQDCAAQQA2AgAMBgsgACACNgIMIAAgATYCCCAAIAM2AgQgAEEBNgIADAILIAEoAgQgASgCCCALEKwCIQEgBEEDNgLQASAEIAFBGGo2AswBIARBBDYCyAEgBCAEQcABajYCxAEgAEEEakGbkMAAIARBxAFqEAwgAEEBNgIACyAEKAK0ASAHECYLIAQoAqgBIAQoAqwBEAEMAgsgBCgCtAEgBxAmCyAAIAQoArABNgIMIAAgBCkCqAE3AgQgAEEANgIACyAEQQxqEMIEIARB8AJqJAALZwECfyMAQSBrIgIkACACQQhqIgMgASgCTCABKAJQEPwDIAJBFGogASgCWCABKAJcEPwDIAMgAigCGCIBIAIoAhwQCiAAIAIoAhA2AgggACACKQIINwIAIAIoAhQgARABIAJBIGokAAtvAQF/IwBBIGsiBSQAIAUgAjYCBCAFIAE2AgAgBSAENgIMIAUgAzYCCAJAIAIEQCAFQQI2AhwgBUECNgIUIAUgBUEIajYCGCAFIAU2AhAgAEHvgMAAIAVBEGoQDAwBCyAAIAMgBBAGCyAFQSBqJAALIgAgAEEKIAEgAhCiAiAAQQA7ASQgACACNgIgIABBADYCHAuQAgEEfyMAQUBqIgIkAAJAAn8g", + "AS0AJQ0BIAEoAgQhBCACQTRqIAEQxQIgAigCNEEBRgRAIAEoAhwhAyABIAIoAjwiATYCHCABIANrIQEgAyAEagwBCyACQShqIAEQjQQgAigCKCIERQRADAILIAIoAiwhASAECyEDIAJBADYCNCACQSBqQQogAkE0aiIFEJgCIAJBGGogAigCICACKAIkIAMgARCbAiACKAIYIgRFDQAgAigCHCEBIAJBADYCNCACQRBqQQ0gBRCYAiACQQhqIAIoAhAgAigCFCAEIAEQmwIgAigCDCABIAIoAggiAxshASADIAQgAxshAwsgACABNgIEIAAgAzYCACACQUBrJAAL0AMBBX8jAEFAaiIGJAAgBkEANgIUIAZCgICAgMAANwIMIARBAnQhBAJAA0ACQAJAAkAgBARAIAYgCTYCGCABIAIgAygCABCsAiIHLQCaAUECRw0DIAcoAigiCCAHKAIsIgcgBRC9Ag0BIAggB0EiEL0CDQEgCCAHQQ0QvQINASAIIAdBChC9Ag0BIAggB0EgEJcCDQEgCCAHQQkQlwINASAGQSxqIAggBxAGDAILIAYoAhAhASAGKAIUIQIgBkEcaiAFENgCIAZBLGoiAyABIAIgBigCICIBIAYoAiQQpwIgBkEDNgI8IAYgAzYCOCAAQQRqQezUwAAgBkE4ahAMIAYoAiwgBigCMBABIAYoAhwgARABIABBADYCAAwECyAGQRxqIgogCCAHQSJB6MDDAEECEL4CIAZBAzYCPCAGIAo2AjggBkEsakHx08AAIAZBOGoQDCAGKAIcIAYoAiAQAQsgA0EEaiEDIAlBAWohCSAEQQRrIQQgBkEMaiAGQSxqELwBDAELCyAGQQM2AiggBkEENgIgIAYgB0EYajYCJCAGIAZBGGo2AhwgAEEEakHAj8AAIAZBHGoQDCAAQQE2AgALIAZBDGoQ8QIgBkFAayQAC7kGAQd/IwBBIGsiAyQAAkAgACgCBCIEIAAoAggiBiABEKwCLQCaASIHIAQgBiAC", + "EKwCLQCaAUcNACAHQQJGBEAgA0EIaiAAIAEQrQIgA0EUaiAAIAIQrQIgAygCDCIEIAMoAhAgAygCGCIGIAMoAhwQngcgAygCFCAGEAEgAygCCCAEEAENASAAKAIIIQYgACgCBCEEC0EBIQUgBCAGIAEQrAIiBEEcaigCACAEQSBqKAIAQaXgwgBBBhASDQBBACEFAkACQAJAAkACQAJAAkAgB0EBaw4DAAEHAgsgA0EIaiAAKAIEIAAoAgggARCsAiIBQUBrKAIAIAFBxABqKAIAEIsDIANBFGogACgCBCAAKAIIIAIQrAIiAUFAaygCACABQcQAaigCABCLAyADKAIQIgEgAygCHEYNAiADKAIMIQQgAygCGCEGDAMLIAAoAgQgACgCCCABEKwCIQEgACgCBCAAKAIIIAIQrAIhACABQShqKAIAIAFBLGooAgAgAEEoaigCACAAQSxqKAIAEJYDIQUMBQsgA0EIaiAAKAIEIAAoAgggARCsAiIBQUBrKAIAIAFBxABqKAIAEIsDIANBFGogACgCBCAAKAIIIAIQrAIiAUFAaygCACABQcQAaigCABCLAyADKAIQIgQgAygCHEYNAyADKAIUIAMoAhgQJiADKAIIIAMoAgwQJgwCCyADKAIYIQYgAygCDCEEA0AgASAFQQFqIgdNBEAgAygCFCAGECYgAygCCCAEECZBASEFDAULIAQgASAFQcCawwAQISgCACEIIAQgASAHQdCawwAQISgCACEHIAMgACACIAgQ/gUgAygCAEEBRw0BIAVBAmohBSAAIAcgBiABIAMoAgRBAWpB4JrDABAhKAIAELMHDQALCyADKAIUIAYQJiADKAIIIAQQJgtBACEFDAELQQAhASADKAIYIgYhBSADKAIMIgchAgJ/A0AgBCABIARGDQEaIAFBAWohASAFKAIAIQggAigCACEJIAVBBGohBSACQQRqIQIgACAJIAgQswcNAAsgAUEBawsgAygCFCAGECYgAygCCCAHECYgBE8h", + "BQsgA0EgaiQAIAULIgAgACgCACgCACgCACAAKAIEKAIAIAFBAnRrQQRrKAIARgscACABKAIAIAAoAgQgACgCCCABKAIEKAIMEQQAC+0EAQ1/IwBBIGsiCCQAIAhBCGogASgCBCIMIAEoAggiDSADEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMgCCgCECEOAkACQAJAIAYtAAAiEEUgAS0ANCIRQQFxcUUEQCAIKAIMIQ8MAQsgCCgCDCEPIA4hAwNAIANBAkkNASAMIA0gDyAOIANBAmsiCkHwzcMAECEoAgAQrAIiCUEcaigCACAJQSBqKAIAQaCTwwBBBxASBEAgCEEUaiABIAIgDyAOIANBAWtBgM7DABAhKAIAIAQgBSAGIAcQuAcgCCgCFCIJQX9HDQMLIAohAwwACwALQQAhAyAGLQABQQFxIRIgBi0AA0EBcSETIAYtAAVBAXEhFANAIA4gA0EBaiIJTQRAIABBfzYCAAwDCyAPIA4gA0GQzsMAECEoAgAhCiAPIA4gCUGgzsMAECEoAgAhCQJAAkAgECAMIA0gChCsAiILQRxqKAIAIAtBIGooAgBBoJPDAEEHEBJFcg0AIAwgDSAKEKwCIgsoAiwgBUYEQCAEIAsoAiggBRD6B0UNAQsgEUEBcQ0BIAhBFGogASACIAkgBCAFIAYgBxC4ByAIKAIUIglBf0cNAwwBCwJAIAcNACAMIA0gChCsAiELIBQEQCALQSRqIAQgBRD7BkUNAgwBCyALKAIoIAsoAiwgBCAFELkHRQ0BCyASBEAgCEEUaiILIAwgDSAKEJIGIAIgCyAKELcHCyATDQAgCEEUaiIKIAwgDSAJEJIGIAIgCiAJELcHCyADQQJqIQMMAAsACyAAIAgpAhg3AgQgACAJNgIACyAIKAIIIA8QJiAIQSBqJAALkwEBBX8gACgCCEEMbCEEIAEoAgghByABKAIEIQYgACgCBCEDAkADQCAERQ0BIANBBGooAgAgA0EIaigCACAGIAcQlgNF", + "BEAgBEEMayEEIAVBAWohBSADQQxqIQMMAQsLIAAoAhAgACgCFCAFQYzswgAQISACNgIAIAEoAgAgBhABDwsgACABELwBIABBDGogAhDgAgulAwEHfyMAQSBrIggkAAJAAkACQAJAAkAgASgCBCIKIAEoAggiCyADEKwCLQCaAUEDRgRAIAogCyADEKwCIgMoAgBFDQEgAygCBCEDCyAKIAsgAxCsAi0AmgEOAgMCAQsgAEF/NgIADAMLIABBfzYCAAwCCyAAIAEgAiADIAQgBSAGIAcQtgcMAQsgCEEIaiAKIAsgAxCsAiIDQUBrKAIAIANBxABqKAIAEIsDIAgoAhAhAyAIKAIMIQwgAS0ANARAIAwgAxDNBgsgA0ECdCEOQQAhAyAIKAIIIQ0CQANAIAMgDkcEQAJAAkACQCAKIAsgAyAMaigCACIJEKwCLQCaAUEDRgRAIAogCyAJEKwCIgkoAgBFDQEgCSgCBCEJCyAKIAsgCRCsAi0AmgFBAUcNASAIQRRqIAEgAiAJIAQgBSAGIAcQtgcgCCgCFCIJQX9GDQIgACAIKQIYNwIEIAAgCTYCAAwFCyAAQX82AgAMBAsgAEF/NgIADAMLIANBBGohAwwBCwsgDCANEOYEIABBfzYCAAwBCyAMIA0Q5gQLIAhBIGokAAvBAQEGfwJ/IAMEQEEBIAIgA0GblcMAQQEQEg0BGgNAIAVBAWohCQJAAkADQCAEIgYgA0kiBCABIAVLckUEQEEBDwsgBEUNAgJAIAIgBmotAAAiBEEqRwRAIARBP0YNASABIAVNDQQgACAFai0AACAERw0EDAMLIAZBAWohBCAGIQcgCSEIDAELCyABIAVNDQELIAVBAWohBSAGQQFqIQQMAQsgByEEIAgiBUEBayABSQ0AC0EADwsgACABIAJBABASCwsRACAAIAEgAiADIARBAhCBCAsLACAAKAIAIAEQGAuPHQMQfwJ+AnwjAEHQB2siBiQAIAEoAgQiCCABKAIIIgkgAxCsAiEH", + "IAZB2ABqIAggCSAEEKwCIghB8ABqKAIAIAhB9ABqKAIAEEIgBkGwAmogCEHMAGooAgAgCEHQAGooAgAQQiAGQZAEaiAIQeQAaigCACAIQegAaigCABBCAkAgB0HQAGooAgAiCEUEQCAHKAJ0RQ0BCyAGQfAFaiIJIAdBzABqKAIAIAgQQiAGKAKwAiAGKAK0AhABIAYgBigC+AU2ArgCIAYgBikC8AU3A7ACIAkgB0HwAGooAgAgB0H0AGooAgAQQiAGKAJYIAYoAlwQASAGIAYoAvgFNgJgIAYgBikC8AU3A1gLIAdB6ABqKAIAIggEQCAGQfAFaiAHQeQAaigCACAIEEIgBigCkAQgBigClAQQASAGIAYoAvgFNgKYBCAGIAYpAvAFNwOQBAsgBigCmAQhCiAGKAKUBCELIAYoApAEIQwgBigCuAIhESAGKAK0AiENIAYoArACIQ4gBigCYCESIAYoAlwhDyAGKAJYIRACQAJAAkACQAJAIAEoAgQgASgCCCAEEKwCIgdBHGooAgAgB0EgaigCAEGl4MIAQQYQEkUEQCABKAIEIAEoAgggAxCsAi0AmgEhCCABKAIEIAEoAgggBBCsAi0AmgEhByABKAIEIAEoAgggAxCsAiIJQRxqKAIAIAlBIGooAgBBpeDCAEEGEBIhCSAIQQFHDQEgB0UgCXEgB0EBRnINAwwCCyABIAMQ7AQhASAAQX82AgAgACABNgIEDAMLIAlFBEAgByAIcg0BDAILIAdBAkkNAQsgBkHMAGogASgCBCABKAIIIAMQrAIiAkEcaigCACACQSBqKAIAEEIgBkEQaiAGKAJQIAYoAlQQQiAGQdgAaiABIAQQrQIgBigCFCIHIAYoAhgiAkHE8sIAQQIQ/QEiCUUEQCAGQfAFaiABIAMQrQIgBigCECAHEAEgBiAGKAL4BSICNgIYIAYgBikC8AU3AxAgBigCFCEHCwJAAkACQAJAAkACQAJAAkACQCAHIAJBnN/CAEEFEBIiCgRAIAYo", + "AlwiBSAGKAJgIghBnN/CAEEFEBJFDQEgASADEPwFIQIgBkHwBWogASgCBCABKAIIIAMQrAIQ5wQgBkGwAmogASgCBCABKAIIIAQQrAIiA0EoaigCACADQSxqKAIAEEIgBkGQBGogBigCmAYgBigCnAYQsgIgBikDmAQhFiAGKAKUBCEHIAYoApAEIgRFBEAgBigCtAIhAwwJCyAGQZAEaiIIIAYoArQCIgMgBigCuAIQsgIgBigCkARFDQcgCEEqIBYgBikDmAQQvQcgBigCkARBAUYNByAGKQOYBCEWIAEoAgQgASgCCCACEOECIgFBAjoAmgEgASAGKAL0BjYChAEgASgCGCABQRxqKAIAEAEgBikCiAYhFyABIAYoApAGNgIgIAEgFzcCGCAIIAQgByAWEL4HIAEoAiQgAUEoaigCABABIAEgBigCmAQ2AiwgASAGKQKQBDcCJCAAQX82AgAgACACNgIEIAYoArACIAMQASAGKAKUBiAGKAKYBhABIAYoAqAGIAYoAqQGEAEgBigCrAYgBigCsAYQJiAGKAK4BiAGKAK8BhABIAYoAsQGIAYoAsgGEAEgBigC0AYgBigC1AYQASAGKALcBiAGKALgBhABIAYoAugGIAYoAuwGEAEMCQsgByACQaHfwgBBBxASRQ0BIAYoAmAhCCAGKAJcIQULIAUgCEGc38IAQQUQEg0BIAUgCEGh38IAQQcQEg0BCwJAIAcgAkHj38IAQQUQEgRAIAYoAlwiBSAGKAJgQZzfwgBBBRASDQELIAYoAlwhBSAKBEAgBSAGKAJgQePfwgBBBRASDQELIAEoAgQgASgCCCAEEKwCIQEgBkEDNgL8BSAGIAFBGGo2AvgFIAZBAzYC9AUgBiAGQcwAajYC8AUgAEHDicAAIAZB8AVqEAwMBwsgASgCBCABKAIIIAMQrAIiAkEcaigCACACQSBqKAIAQePfwgBBBRASIQcgASADEPwFIQIgASgCBCABKAIIIAIgAyAEIAcbIghBABDJ", + "BSAGQfAFaiABKAIEIAEoAgggBCADIAcbEKwCIgMoAiggAygCLBD7BSAGKALwBUEBRgRAIAYoAvQFIQEgACAGKQP4BTcCBCAAIAE2AgAMBwsgBiAGKQP4BSIWNwNAIBZCAFMNASAGQZAEaiABKAIEIAEoAgggCBCsAiIDQShqKAIAIANBLGooAgAQQiAGQoCAgAU3A7ACIAYoApgEIQMgFlANAyADrUKAgIAFIBaAWA0DIAYgAzYCNCAGQSE2AoQGIAZBITYC/AUgBkEENgL0BSAGIAZBsAJqNgKABiAGIAZBQGs2AvgFIAYgBkE0ajYC8AUgAEG2vcAAIAZB8AVqEAwgBigCkAQgBigClAQQAQwGCyABIAMQ/AUhAiAGQfAFaiABKAIEIAEoAgggAxCsAhDnBCAGQbACaiABKAIEIAEoAgggBBCsAiIDQShqKAIAIANBLGooAgAQQiAGQZAEaiAGKAKYBiAGKAKcBhC1AgJAAn8gBigCkARBAUYEQCAGKwOYBCEYIAYoArQCIQMgBigClAQMAQsgBisDmAQhGCAGQZAEaiAGKAK0AiIDIAYoArgCELUCIAYoApAEQQFHDQEgBisDmAQhGCAGKAKUBAshByAAIBg5AgQgACAHNgIAIAYoArACIAMQASAGQfAFahDCBAwGCyAGKwOYBCEZIAEoAgQgASgCCCACEOECIgFBAjoAmgEgASAGKAL0BjYChAEgGCAZoiEYAkAgCQRAIAZBkARqQaHfwgBBBxAGDAELIAYgBigCkAY2ApgEIAYgBikCiAY3A5AECyABKAIYIAFBHGooAgAQASABIAYoApgENgIgIAEgBikDkAQ3AhggBkGQBGogGBDxBCABKAIkIAFBKGooAgAQASABIAYoApgENgIsIAEgBikCkAQ3AiQgAEF/NgIAIAAgAjYCBCAGKAKwAiADEAEgCUUNASAGKAKIBiAGKAKMBhABDAELIAZBITYC9AUgBiAGQUBrNgLwBSAAQdLNwAAgBkHwBWoQDAwE", + "CyAGKAKUBiAGKAKYBhABIAYoAqAGIAYoAqQGEAEgBigCrAYgBigCsAYQJiAGKAK4BiAGKAK8BhABIAYoAsQGIAYoAsgGEAEgBigC0AYgBigC1AYQASAGKALcBiAGKALgBhABIAYoAugGIAYoAuwGEAEMAwsgBkHwBWogBigClAQiBCADIBanENkCIAEoAgQgASgCCCACEOECIgEoAiQgAUEoaigCABABIAEgBigC+AU2AiwgASAGKQLwBTcCJCAAQX82AgAgACACNgIEIAYoApAEIAQQAQwCCyAGKQOYBCEWIAYoApQEIQcLIAAgFjcCBCAAIAc2AgAgBigCsAIgAxABIAZB8AVqEMIECyAGKAJYIAUQASAGKAIQIAYoAhQQASAGKAJMIAYoAlAQAQwBCyABIAMQ7AQhCSABKAIEIAEoAgggCRDhAiIDKAJsIANB8ABqIgcoAgAQASADIBI2AnQgByAPNgIAIAMgEDYCbCADKAJIIANBzABqIgcoAgAQASADIBE2AlAgByANNgIAIAMgDjYCSCADKAJgIANB5ABqIgcoAgAQASADIAo2AmggByALNgIAIAMgDDYCYCAGQRBqIgMgAhC9BSAGQYACOwAxIAZBgQI2AC0gBiAFLQABIgc6ADNBACECIAZBADYCPCAGQoCAgIDAADcCNCAGQfAFaiIIIAMgBBC0BSAGQZAEaiABIAZBNGogCCAGQS1qEI8HAkAgBigCkAQiA0F/RwRAIAAgBikClAQ3AgQgACADNgIAIAYoAjQgBigCOBAmDAELIAYoAjghA0EAIQsgBUECaiEOIAdBAXMhESAFQQhqIQ8gAyAGKAI8IgQEfyAGQfAFaiICIAEgAygCABC/BiAGKAL4BSELIAIQxAYgBAVBAAtBAnRqIRIgBkHwBWpBBHIhECAGKAI0IQogBS0AAEEBcSETIAMhBQNAAkAgBSASRwRAIAZBQGsgASAFKAIAIgwQvwYgCyAGKAJIIgJLBEBBCCEEQQAhDUEAIQgMAgsg", + "BkEIaiALIAYoAkQgAkHszMMAEL8HIAYoAgghFCAGIAYoAgwiCEEIQRAQByAGKAIAIg0gCCAIIA1LGyECQQAhByAGKAIEIQQDQCACRQ0CIAZB8AVqIAcgFGoQnQcgBCAHaiIVIAYpA/gFNwMIIBUgBikD8AU3AwAgAkEBayECIAdBEGohBwwACwALIAMgChDmBCAAQX82AgAgACAJNgIEDAILIAYgCDYCVCAGIAQ2AlAgBiANNgJMIAEoAgQgASgCCCAMEKwCLQCaASECIBAgDy0AAjoAAiAQIA8vAAA7AQAgBkGCgICAeDYC8AUgBkHYAGpBCyAGQfAFahDABwJAIBMgAkVxRQRAIAJFIBFxRSACQQFNcQ0BIAZBgBA7AagCDAELIAZBCToAqQILIAEoAgQgASgCCCAMEKwCLQCZASECIAYgDi8ABDsB9AUgBiAOKAAANgLwBSAGQZAEaiIHIAQgCCAGQfAFaiIEIAIQwwYgBCAMEMYGIAZCADcDyAcgBkGwAmoiAiAGQdgAaiAHIAQQxwYgBCAGQRBqIAkQtAUgByABIAQgAhDdBCAGKQKYBCEWIAYoApQEIQcCQCAGKAKQBCICQX5GBEAgFiEXDAELIAYgFjcC+AUgBiAHNgL0BSAGIAYpAqAENwKABiAGIAI2AvAFIAZB8AVqELsEQX8hBwsgBUEEaiEFIAZBsAJqENcEIAZBzABqEMQGIAZBQGsQxAYgB0F/Rg0ACyAAIBc3AgQgACAHNgIAIAMgChDmBAsgBkEQahC7BAwBCyAMIAsQASAOIA0QASAQIA8QAQsgBkHQB2okAAuWAgEBfyMAQUBqIgQkACAEIAI3AxggBCABNgIUIAQgAzcDICAAAn8CQAJAAkACQAJAAkACQCABQSprDgQCAwABAAsgBEEQNgIsIAQgBEEUajYCKCAAQQRqQefRwAAgBEEoahAMDAQLIAIgA1MgAiADfSIDQgBTc0UNBAwCCyAEIAIgAkI/hyADIANCP4cQ/gcgBCkDCCAE", + "KQMAIgNCP4dSDQEMAwsgA0IAUyACIAN8IgMgAlNzRQ0CCyAEQSE2AjwgBEEQNgI0IARBITYCLCAEIARBIGo2AjggBCAEQRRqNgIwIAQgBEEYajYCKCAAQQRqQdvLwAAgBEEoahAMC0EBDAELIAAgAzcDCEEACzYCACAEQUBrJAAL8AEBAX8jAEEgayIEJAAgBCADNwMIAkAgASACQfCawwBBBBASRQRAIAEgAkH0msMAQQQQEkUEQCAAIAMQ8AQMAgsgA0IAWQRAIARBPTYCHCAEIARBCGo2AhggAEGUgMAAIARBGGoQDAwCCyAEQgAgA303AxAgBEE+NgIcIAQgBEEQajYCGCAAQY6AwAAgBEEYahAMDAELIANCAFkEQCAEQT82AhwgBCAEQQhqNgIYIABBiYDAACAEQRhqEAwMAQsgBEIAIAN9NwMQIARBwAA2AhwgBCAEQRBqNgIYIABBg4DAACAEQRhqEAwLIARBIGokAAstACABIANNBEAgACADIAFrNgIEIAAgAiABQQR0ajYCAA8LIAEgAyADIAQQKQALoAEBAX8jAEHgAWsiAyQAIANBCGogARDNBCAAIAMtANkBOgDRASAAIAMpAxA3AwggACADKQMYNwMQIAAgAykCzAE3AsQBIAAgAygC1AE2AswBIABBKGogA0EwakGcAfwKAAAgACADKQMINwMAIAAgAikDADcDGCAAIAIpAwg3AyAgACADLQDYAToA0AEgAygCICADKAIkEM8EIANB4AFqJAALhAEBAX8jAEEwayIEJAAgBEEANgIgIAQgATYCGCAEIAE2AhAgBCADNwMIIAQgAjYCFCAEIAEgAmo2AhwCfwJAA0ACQCAEQSRqIARBCGoQlAIgBCgCJEEBaw4CAQIACwsgBCgCKCECQQEMAQtBAAshASAAIAI2AgQgACABNgIAIARBMGokAAvMAwEBfwJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAAkACQEEJIAEoAgAiAkGAgICA", + "eHMgAkEAThtBAWsODwECAwQFBgcICQoLDA0ODwALIABBgICAgHg2AgAPCyAAQYGAgIB4NgIAIAAgAS8BCDsBCAwOCyAAQYKAgIB4NgIAIAAgAS8BBDsBBCAAQQZqIAFBBmotAAA6AAAPCyAAQYOAgIB4NgIAIAAgASgACzYACyAAIAEpAgQ3AgQPCyAAQYSAgIB4NgIAIAAgASgABzYABwwLCyAAQYWAgIB4NgIAIAAgAS8BBDsBBA8LIABBhoCAgHg2AgAgACABLQAGOgAGIAAgAS8BBDsBBA8LIABBh4CAgHg2AgAMCQsgAEGIgICAeDYCACAAIAEpAwg3AwgPCyAAIAEoAgQgASgCCBBCDwsgAEGKgICAeDYCACAAIAEtAAg6AAgMBQsgAEGLgICAeDYCAAwFCyAAQYyAgIB4NgIADAMLIABBjYCAgHg2AgAgACABKQMINwMIDwsgAEGOgICAeDYCAAwCCyAAQY+AgIB4NgIAIAAgAS0ABDoABA8LIAAgASgCBDYCBA8LIAAgAS0ABDoABAtAAQF/A0AgASACIANBpPHCABC5AiIEKAIIQQFHRQRAIAQoAgwhAwwBCwsgACABIAIgA0G08cIAELkCKQJ8NwMACxUAIAAgByACIAcgBCAFIAYgBxDFBwv/AQEBfyMAQRBrIgEkAAJAIAQgBnFFBEAgAEL/////DzcCAAwBCyACKAIEIgMgAigCCCIEIAUQrAIgAyAEIAcQrAIhCC0AmgEgCC0AmgFGBEAgASACIAUgBxDGByABLQAEIQMgASgCACIEQX9HBEAgACABKAAINgAIIAAgASgABTYABSAAIAM6AAQgACAENgIADAILIAAgAkEBIAUgA0EBcRCeBjYCCCAAQv////8fNwIADAELIAMgBCAHEKwCIQIgAyAEIAUQrAIhAyABQQM2AgwgASADQRhqNgIIIAFBAzYCBCABIAJBGGo2AgAgAEHLiMAAIAEQDAsgAUEQaiQAC4sJAQZ/IwBB0AJrIgQkACAE", + "QQxqIAEoAgQiBSABKAIIIgYgAhCsAhDnBCAEQagBaiAFIAYgAxCsAhDnBAJAAkACQAJAAkACQAJAAkACQAJAAkACQAJAIAQtAKYBQQFrDgMABAoBCyAELQDCAkEBRw0CQQAhAwwBCyAELQDCAgRAIAAgASACIAMQxwcMCAsgBCgC7AFBAnQhCEEAIQMgBCgC6AEhBSAEKALkASEGAkADQCADIAhGDQUgBEHEAmogASACIAMgBWooAgAQxwcgBC0AyAIhByAEKALEAiIJQX9HBEAgACAEKADMAjYACCAAIAQoAMkCNgAFIAAgBzoABCAAIAk2AgAMAgsgA0EEaiEDIAdBAXENAAsgAEF/NgIAIABBADoABAsgBSAGEOYEIAQoAsABIAQoAsQBEAEgBCgCzAEgBCgC0AEQASAEKALYASAEKALcARABDAoLA0AgA0EBaiIGIAQoAuwBIgVPBEAgAEF/NgIAIABBAToABAwKCyAEKALoASIHIAUgA0GIscMAECEoAgAhCCAHIAUgBkGYscMAECEoAgAhBSAEIAEgAiAIEP4FIAQoAgBBAXFFBEAgAEF/NgIAIABBADoABAwICyAEKAIEIQYgBEHEAmogASABKAIEIAEoAgggAhCsAiIHQUBrKAIAIAdBxABqKAIAIAZBAWpBqLHDABAhKAIAIAUQxgcgBC0AyAIhBSAEKALEAiIGQX9HBEAgACAEKADMAjYACCAAIAQoAMkCNgAFIAAgBToABCAAIAY2AgAMCAsgBUEBcQRAIANBAmohAwwBCwsgAEF/NgIAIABBADoABAwGCyAAQX82AgAgAEEAOgAEDAULIAQtAMICQQJGDQEMAgsgBSAGEOYEIABBfzYCACAAQQE6AAQgBCgCwAEgBCgCxAEQASAEKALMASAEKALQARABIAQoAtgBIAQoAtwBEAEMBgsgBCgCKCIBIAQoAiwiAiAEKALEASIDIAQoAsgBIgUQngcNACABIAJBpeDCAEEGEBINASAEKAI4IQMgBCgC", + "NCEFIAEgAkHj38IAQQUQEkUEQCAFIAMgBCgC0AEgBCgC1AEQlgMhASAAQX82AgAgACABOgAEDAULIAQoAtABIAQoAtQBIAUgAxDHAiEBIABBfzYCACAAIAE6AAQMAgsgAEF/NgIAIABBADoABAwBCyADIAVBpeDCAEEGEBIhASAAQX82AgAgACABOgAECyAEKALAASAEKALEARABIAQoAswBIAQoAtABEAEgBCgC2AEgBCgC3AEQASAEKALkASAEKALoARAmDAILIARBAzYCyAIgBCAEQSRqNgLEAiAAQbK8wAAgBEHEAmoQDAsgBCgCwAEgBCgCxAEQASAEKALMASAEKALQARABIAQoAtgBIAQoAtwBEAEgBCgC5AEgBCgC6AEQJgsgBCgC8AEgBCgC9AEQASAEKAL8ASAEKAKAAhABIAQoAogCIAQoAowCEAEgBCgClAIgBCgCmAIQASAEKAKgAiAEKAKkAhABIARBDGoQwgQgBEHQAmokAAvyAQEGfyMAQRBrIgQkACAEQQRqIAEoAgQgASgCCCACEKwCIgJBQGsoAgAgAkHEAGooAgAQiwMgBCgCDEECdCEIIAQoAgghBSAEKAIEIQZBACECAkACQANAAkAgAiAIRwRAIARBBGogASACIAVqKAIAIAMQxgcgBC0ACCEHIAQoAgQiCUF/Rg0BIAAgBCgADDYACCAAIAQoAAk2AAUgACAHOgAEIAAgCTYCAAwDCyAFIAYQ5gQgAEF/NgIAIABBADoABAwDCyACQQRqIQIgB0EBcUUNAAsgAEF/NgIAIABBAToABAsgBSAGEOYECyAEQRBqJAALPgEDfyAAKAIIIQEgACgCBCIDIQIDQCABBEAgAUEBayEBIAIQ8QIgAkEMaiECDAELCyAAKAIAIANBBEEMEDAL3AIBAn8jAEEwayIFJAAgBUEtQSsgAUEASBs2AgwgBSABIAFBH3UiBnMgBmsiAUGQHG0iBjYCECAFIAEgBkGQHGxrIgHBQTxtwTYCFAJAAkAg", + "A0UEQCAEQQAgAUE7akH3AEkbDQEgAkUEQCAFQSM2AiwgBUEjNgIkIAVBEDYCHCAFIAVBFGo2AiggBSAFQRBqNgIgIAUgBUEMajYCGCAAQbnCwwAgBUEYahAMDAMLIAVBIzYCLCAFQSM2AiQgBUEQNgIcIAUgBUEUajYCKCAFIAVBEGo2AiAgBSAFQQxqNgIYIABBycLDACAFQRhqEAwMAgsgBUEjNgIkIAVBEDYCHCAFIAVBEGo2AiAgBSAFQQxqNgIYIABBsMLDACAFQRhqEAwMAQsgBUEjNgIkIAVBEDYCHCAFIAVBEGo2AiAgBSAFQQxqNgIYIABBsMLDACAFQRhqEAwLIAVBMGokAAskACAAIAEgAiABIAQgBSAGIAcQywcgASgCACABQQRqKAIAEAELpgIBAX4jAEGwAWsiAyQAIAQgBnEEfyADQSxqQbXewgBBBRAGIAEpAgwhCCADQYwBaiABKAIEIAEoAggQQiADQQA2ApgBIANBAToArgEgA0IBNwJIIANCADcCQCADQoCAgIAQNwI4IANCATcCeCADQgA3AnAgA0KAgICAEDcCaCADQgE3AmAgA0IANwJYIANCgICAgMAANwJQIANBADYCFCADQQA2AhwgA0EANgIkIANBADYCiAEgAyAINwKcASADQoCAgIAQNwKAASADQgA3AqQBIANBADsBrAEgAiADQRRqEN8CIQRBAEEBEAFBAEEBEAEgA0EIaiACIAQgBSAHEOkEIAAgBDYCCEEBBUEACyEBIABBfzYCACAAIAE2AgQgA0GwAWokAAuUDwMFfwJ8An4jAEHgAWsiCSQAAkACQAJAAkACQCAFQQFGBEAgB0EBcUUNASABKAIEIAEoAgggBhCsAi0AmgEOAgIDBAsgB0EBRgRAIAAgAUEBIAhBABCeBjYCCCAAQv////8fNwIADAULIAAgAUEAIAkgAxCeBjYCCCAAQv////8fNwIADAQLIAAgAUEBIAZBABCeBjYCCCAAQv////8fNwIADAML", + "IABBhrzDAEEnEAYMAgsgAEGtvMMAQSUQBgwBCyABKAIEIAEoAgggCBCsAi0AmgFBAkcEQCABKAIEIAEoAgggCBCsAiECIAlB4ABqIgMgASAIEP0FIAEoAgQgASgCCCAGEKwCIQEgCUEDNgK0ASAJIAFBGGo2ArABIAlBAzYCrAEgCUEDNgKkASAJIAJBGGo2AqABIAkgAzYCqAEgAEHqiMAAIAlBoAFqEAwgCSgCYCAJKAJkEAEMAQsgASAGEPwFIQwgCUEkaiABIAYQrQIgCUEwaiABIAgQrQIgCUE8aiABKAIEIAEoAgggBhCsAiIFQShqKAIAIAVBLGooAgAQQiAJQcgAaiABKAIEIAEoAgggCBCsAiIFQShqKAIAIAVBLGooAgAQQiABKAIEIAEoAgggBhCsAiEFAkACQAJAIAkoAigiByAJKAIsIghB49/CAEEFEBIEQCAJQRBqIAIQhgYgCUGgAWoiDSAJKAIQIAkoAhQgCSgCQCIKIAkoAkQiCxCvAiAJKAKgASANELACQX9HDQEMAgsgBUEcaigCACAFQSBqKAIAQfiuwwBBCxASRQ0BIAkoAkQhCyAJKAJAIQoLIAlBgAFqIgZBBHIhBSAJQQhqIAIQhgYgCUHUAGogCSgCCCAJKAIMEAYgBiAJKAJYIgcgCSgCXCIIIAogCxCvAgJAIAkoAoABIgZBf0YEQCAJIAUoAgg2AiAgCSAFKQIANwMYDAELIAlBwAFqIgpBBHIhAiAJIAkpA5gBNwN4IAkgCSkDkAE3A3AgCSAGNgJgIAkgBSkCADcCZCAJIAUoAgg2AmwgCiAHIAggCSgCTCAJKAJQEK8CIAkoAsABIgVBf0YEQCAJIAIoAgg2AiAgCSACKQIANwMYDAELIAkgCSkD2AE3A7gBIAkgCSkD0AE3A7ABIAkgBTYCoAEgCSACKQIANwKkASAJIAIoAgg2AqwBAkAgA0UNACAJKQNwIAkpA7ABUg0AIAkoAnggCSgCuAFHDQAgCSgCfCAJKAK8", + "AUcgBSAGR3INACAGQQJGBEAgCSkDaCAJKQOoAVINASAJKAJkIAkoAqQBRw0BCyAJQX82AhggCUEBOgAcDAELIAlB4ABqIAlBoAFqELcCwCECIARFBEAgCUF/NgIYIAkgAkGAAXFBB3Y6ABwMAQsgCUF/NgIYIAkgAkEASjoAHAsgCSgCVCAHEAEgCSgCNCEFDAELAkACQAJAIAcgCEGc38IAQQUQEgRAIAkoAjQiBSAJKAI4QZzfwgBBBRASDQELAkAgByAIELQCBEAgCSgCNCIFIAkoAjgQtAINAQsgCSgCOCECIAkoAjQhBQJAIAcgCEHj38IAQQUQEgRAIAUgAkHj38IAQQUQEg0BCyAHIAhBpeDCAEEGEBIhBCAFIAJBpeDCAEEGEBIhAgJAIAQEQCACIANxQQFHDQEgCUF/NgIYIAlBAToAHAwHCyACDQAgASgCBCABKAIIIAYQrAIhAiAJQQM2AqQBIAkgAkEYajYCoAEgCUEYakGbv8AAIAlBoAFqEAwMBgsgCUF/NgIYIAlBADoAHAwFCyAJKAJQIQIgCSgCTCEGIAkoAkQhByAJKAJAIQggA0UNAyAIIAcgBiACEJYDRQ0DIAlBfzYCGCAJQQE6ABwMBAsgCUGgAWoiAiAJKAJAIAkoAkQQtQIgCSgCoAENASAJKwOoASEOIAIgCSgCTCAJKAJQELUCIAkoAqABQQFGBEAgCSAJKwOoATkCHCAJIAkoAqQBNgIYDAQLIANBACAJKwOoASIPIA5hG0UEQCAJQX82AhggCSAOIA9kIA4gD2MgBBs6ABwMBAsgCUF/NgIYIAlBAToAHAwDCyAJQaABaiICIAkoAkAgCSgCRBCyAiAJKAKgAQRAIAkpA6gBIRAgAiAJKAJMIAkoAlAQsgIgCSgCoAFFBEAgCSAJKQOoATcCHCAJIAkoAqQBNgIYDAQLIANBACAJKQOoASIRIBBRG0UEQCAJQX82AhggCSAQIBFVIBAgEVMgBBs6ABwMBAsgCUF/NgIYIAlB", + "AToAHAwDCyAJIAkpA6gBNwIcIAkgCSgCpAE2AhgMAgsgCSAJKwOoATkCHCAJIAkoAqQBNgIYDAELIAggByAGIAIQ4AEhAiAJQX82AhggCSACwCICQQBKIAJBAEggBBs6ABwLIAkoAkggCSgCTBABIAkoAjwgCSgCQBABIAkoAjAgBRABIAkoAiQgCSgCKBABIAktABwhAiAJKAIYIgNBf0cEQCAAIAkoACA2AAggACAJKAAdNgAFIAAgAjoABCAAIAM2AgAMAQsgACABQQEgDCACQQFxEJ4GNgIIIABC/////x83AgALIAlB4AFqJAALNAEBfyMAQRBrIggkACAIIAEvAAA7AA4gACAIQQ5qIAIgAyAEIAUgBiAHEM4HIAhBEGokAAsdACAAIAIgAyABLQAAIAEtAAEgBCAFIAYgBxDMBwsyACMAQRBrIgMkACADIAEtAAA6AA8gACADQQ9qIAIgAyAEIAUgBiAHENAHIANBEGokAAvWAgEBfyAAAn8CQAJAAkAgBEEBRgRAIAIoAgQiBCACKAIIIgggBRCsAiEDIAZBAXFFDQEgBCAIIAcQrAIhBCADQRxqKAIAIANBIGooAgBBpeDCAEEGEBINAkEAIQcgAy0AmgFBAkcNAyAELQCaAUECRw0DIAMoAiggAygCLCAEKAIoIAQoAiwQuQchBwwDCyAGQQFGBEAgAkEBIAcgAigCBCACKAIIIAcQrAIiAkEcaigCACACQSBqKAIAQaXgwgBBBhASIAEtAABzQQFxEJ4GDAQLIAJBACACIAEtAABBf3NBAXEQngYMAwsgAkEBIAUgA0EcaigCACADQSBqKAIAQaXgwgBBBhASIAEtAABzQQFxEJ4GDAILIARBHGooAgAgBEEgaigCAEGl4MIAQQYQEiEHCyACQQEgBSAHIAEtAABzQQFxEJ4GCzYCCCAAQv////8fNwIACxUAIAAgByACIAcgBCAFIAYgBxDSBwtUAEEBIQECQCAEQQFHBEAgBiEBDAELIAZBAXFF", + "BEAgBSEHDAELIAUgByACKAIEIAIoAgggBRCsAhC4AhshBwsgACAHNgIIIAAgATYCBCAAQX82AgALDwAgACAEIAIgAyAEENQHC0sBAX9BACEBQQQhBQJAIANBAUcNACACKAIEIAIoAgggBBCsAhC4AkUNACAAQQE2AgRBCCEFIAQhAQsgACAFaiABNgIAIABBfzYCAAvcFAMGfwF+AXwgACEJIAMhACMAQdABayIIJAACQCAEIAZxRQRAIAlC/////w83AgAMAQsCQAJAAkAgAigCBCACKAIIIAUQrAIiAUEcaigCACABQSBqKAIAQaXgwgBBBhASRQRAIAIgBRD8BSEKAkACQAJAIAIoAgQgAigCCCAFEKwCLQCaAUEBaw4DAAIGAQsgCUHIzcMAQSYQBgwGCyACKAIEIAIoAgggBxCsAi0AmgFFDQMgAigCBCACKAIIIAcQrAIhACAIQawBaiIBIAIgBxD9BSACKAIEIAIoAgggBRCsAiECIAhBAzYCnAEgCCACQRhqNgKYASAIQQM2ApQBIAhBAzYCjAEgCCAAQRhqNgKIASAIIAE2ApABIAlB6ojAACAIQYgBahAMIAgoAqwBIAgoArABEAEMBQsgAigCBCACKAIIIAcQrAIgAigCCCEBIAIoAgQhAy0AmgFBAkYNASADIAEgBxCsAiEAIAhBrAFqIgEgAiAHEP0FIAIoAgQgAigCCCAFEKwCIQIgCEEDNgKcASAIIAJBGGo2ApgBIAhBAzYClAEgCEEDNgKMASAIIABBGGo2AogBIAggATYCkAEgCUHqiMAAIAhBiAFqEAwgCCgCrAEgCCgCsAEQAQwECyAJIAIgBSAHEKgHNgIIIAlC/////x83AgAMAwsgAyABIAUQrAIoAoQBIQEgAigCBCACKAIIIAoQ4QIiAyABNgKEASADQQI6AJoBIAhBOGogAigCBCACKAIIIAUQrAIiAUEcaigCACABQSBqKAIAEEIgCEHEAGogAigCBCACKAIIIAcQrAIiAUEc", + "aigCACABQSBqKAIAEEIgCEHQAGogCCgCPCIDIAgoAkAQQiAIQeAAaiAIKAJIIgYgCCgCTBBCIAgoAlQiASAIKAJYQcTywgBBAhD9ASILRQRAIAhBiAFqIAIgBRCtAiAIKAJQIAEQASAIIAgoApABNgJYIAggCCkCiAE3A1ALIAgoAmQiASAIKAJoQcTywgBBAhD9AUUEQCAIQYgBaiACIAcQrQIgCCgCYCABEAEgCCAIKAKQATYCaCAIIAgpAogBNwNgCyAIQfAAaiACKAIEIAIoAgggBRCsAiIBQShqKAIAIAFBLGooAgAQQiAIQfwAaiACKAIEIAIoAgggBxCsAiIBQShqKAIAIAFBLGooAgAQQiAIKAJUIgEgCCgCWCIEQfiuwwBBCxASIQUCQAJAAkACQAJAIAEgBEHj38IAQQUQEgRAIAhBGGogABCGBiAIKAIYIAgoAhwQrgINAQsgBUUNAQwCCyAIQRBqIAAQhgYgCEGIAWoiBSAIKAIQIAgoAhQgCCgCdCAIKAJ4EK8CIAgoAogBIAUQsAJBf0cNAQsCQAJAIAEgBEHj38IAQQUQEkUEQAJAAkAgASAEQZzfwgBBBRASBEAgCCgCZCIEIAgoAmgiAEGc38IAQQUQEkUNASAIQYgBaiAIKAJ0IgUgCCgCeBCyAiAIKQOQASEOIAgoAowBIQMgCCgCiAEiBw0CIAggDjcCJCAIIAM2AiAMBwsgASAEQaHfwgBBBxASRQ0EIAgoAmghACAIKAJkIQQLIAQgAEGc38IAQQUQEkUEQCAEIABBod/CAEEHEBJFDQQLIAhBiAFqIAgoAnQiBSAIKAJ4ELUCIAgoAogBQQFGBEAgCCAIKwOQATkCJCAIIAgoAowBNgIgDAYLIAgrA5ABIAhBiAFqIAgoAoABIgcgCCgChAEQtQIgCCgCiAFBAUYEQCAIIAgrA5ABOQIkIAggCCgCjAE2AiAMBgsgCCsDkAGhIQ8gAigCBCACKAIIIAoQ4QIhAAJAIAsEQCAIQYgB", + "akGh38IAQQcQBgwBCyAIIAgoAkA2ApABIAggCCkCODcDiAELIAAoAhggAEEcaigCABABIAAgCCgCkAE2AiAgACAIKQOIATcCGCAIQYgBaiAPEPEEIAAoAiQgAEEoaigCABABIAAgCCgCkAE2AiwgACAIKQKIATcCJCAIKAJ8IAcQASAIKAJwIAUQASAIKAJgIAQQASAIKAJQIAEQASAIKAJEIAYQAUF/IQAgC0UNCAwGCyAIQYgBaiAIKAKAASILIAgoAoQBELICIAgoAogBRQRAIAggCCkDkAE3AiQgCCAIKAKMATYCIAwFCyAIQYgBakEtIA4gCCkDkAEQvQcgCCgCiAFBAUcNASAIIAgpA5ABNwIkIAggCCgCjAE2AiAMBAsgCEEgakGUzcMAQRwQBgwDCyAIKQOQASEOIAIoAgQgAigCCCAKEOECIgAoAhggAEEcaigCABABIAAgCCgCQDYCICAAIAgpAjg3AhggCEGIAWogByADIA4QvgcgACgCJCAAQShqKAIAEAEgACAIKAKQATYCLCAAIAgpAogBNwIkIAgoAnwgCxABIAgoAnAgBRABIAgoAmAgBBABIAgoAlAgARABIAgoAkQgBhABDAULIAhBAzYClAEgCEEDNgKMASAIIAhBxABqNgKQASAIIAhBOGo2AogBIAhBIGpBzobAACAIQYgBahAMDAELIAhBCGogABCGBiAIQawBaiAIKAIIIAgoAgwQBiAIIAgoAoABIAgoAoQBQS0QHgJAIAgoAgAiAARAIAhBiAFqIAAgCCgCBBAGDAELIAhBAzYCvAEgCCAIQfwAajYCuAEgCEGIAWpB9IDAACAIQbgBahAMCyAIQcQBaiEAIAhBwAFqIAgoArABIgMgCCgCtAEgCCgCdCAIKAJ4IAgoAowBIgQgCCgCkAEQ1gcCQCAIKALAAUEBRgRAIAggACgCCDYCKCAIIAApAgA3AyAMAQsgAigCBCACKAIIIAoQ4QIiAigCJCACQShqKAIAEAEgAiAAKAII", + "NgIsIAIgACkCADcCJCAIQX82AiALIAgoAogBIAQQASAIKAKsASADEAELIAgoAnwgCCgCgAEQASAIKAJwIAgoAnQQASAIKAJgIAgoAmQQASAIKAJQIAEQASAIKAJEIAgoAkgQASAIKAI8IQMgCCgCICEACyAIKAI4IAMQASAAQX9GDQEgCSAIKQIkNwIEIAkgADYCAAwCCyAIQawBaiACKAIEIAIoAgggBRCsAiIAQUBrKAIAIABBxABqKAIAEIsDIAhBiAFqIAIoAgQgAigCCCAHEKwCIgBBQGsoAgAgAEHEAGooAgAQiwMgCEEANgI0IAhCgICAgMAANwIsIAgoApABQQJ0IQYgCCgCsAEiBCAIKAK0AUECdGohCyAIKAKMASEFIAgoAqwBIQwgBCEAA0ACQCAAIAtHBEAgAEEEaiEBIAAoAgAhByAGIQAgBSEDA0AgAARAIABBBGshACADKAIAIQ0gA0EEaiEDIAIgByANELMHRQ0BDAMLCyAIQSxqIAcQ4AIMAQsgBCAMEOYEIAgoAogBIAUQJiACKAIEIAIoAgggChDhAiIAKAI8IABBQGsoAgAQJiAAIAgoAjQ2AkQgACAIKQIsNwI8DAILIAEhAAwACwALIAkgCjYCCCAJQv////8fNwIACyAIQdABaiQAC4kPAwZ/Bn4CfCMAQZACayIHJAAgByAGNgJ8IAcgBTYCeCAHIAY2AuQBIAcgBTYC4AEgB0HwAGogBSAGQS0QHgJAIAcoAnAiCwRAIAcoAnQhBiALIQUMAQsgB0HoAGogBSAGQSsQHiAHKAJoIghFDQAgBygCbCEGIAghBQsCQAJAAkACQAJAIAUgBkHW4cIAQQEQEg0AIAZFDQEgB0GAAmohDANAAkAgBgRAQQAhCAJAA0AgBiAIRgRAIAYhCAwCCyAFIAhqLQAAIglBLkcgCUEwa0H/AXFBCUtxRQRAIAhBAWohCAwBCwsgCEUNBgsgB0HgAGogCCAFIAZBiMPDABDkAiAHQfgBaiAHKAJg", + "IAcoAmQQeiAHLQD4AUEBRgRAIAdB6AFqQQRyIAdB4AFqENcHIAcgBysD8AE5A8gBIAcgBygC7AE2AsQBDAcLIAcrA4ACIRQgB0HYAGogCCAFIAZBmMPDABC/AiAHKAJcIQUgBygCWCEKIAdBADYCiAIgByAFIApqNgKEAiAHIAo2AoACIAcgBTYC/AEgByAKNgL4AQNAAkAgB0HQAGogDBCVAiAHKAJUIghBf0YEQCAFIQYMAQsgBygCUCEGIAhBLkYNACAIQTBrQQlLDQELCyAHQcgAaiAGIAogBUGow8MAEOQCIAcgBygCTCIINgLsASAHIAcoAkgiCTYC6AEgB0FAayAGIAogBUG4w8MAEL8CIAcoAkQhBiAHKAJAIQUgCSAIQcjDwwBBAhASBEBEAAAAAAAA8D8hEwwCC0QAAAAAAECPQCETIAkgCEHKw8MAQQIQEg0BIAkgCEHMw8MAQQMQEg0BIAkgCEHPw8MAQQMQEg0BIAkgCEHSw8MAQQIQEgRARAAAAACAhC5BIRMMAgsgCSAIQdTDwwBBARASBEBEAAAAAGXNzUEhEwwCCyAJIAhB1cPDAEEBEBIEQEQAAACwjvArQiETDAILIAkgCEHWw8MAQQEQEgRARAAAAMWFMYpCIRMMAgsgCSAIQQFBABASRQRAIAdBAjYChAIgB0ECNgL8ASAHIAdB4AFqNgKAAiAHIAdB6AFqNgL4ASAHQcABakEEckHk0sAAIAdB+AFqEAwMBwsgB0ECNgL8ASAHIAdB4AFqNgL4ASAHQcABakEEckG/0sAAIAdB+AFqEAwMBgtCACAOfSAOIAsbIQ1CACAPIA5CAFKtfH0gDyALGyEPDAILIAdBMGohCUIAIRBCACERIwBBEGsiCCQAIBQgE6IiE0T////////fPyATpqAiE70iDUI0iKdB/w9xIgpBsghNBEBCgICAgICAgICAf0KAgICAgICAeCAKQf8Ha62HIApB/wdJGyANg78hEwsCQCATvSISQv//////////", + "/wCDIg1CgICAgICAgPg/VA0AIA1CgICAgICAgPDHAFoEQCANQoGAgICAgID4/wBaDQEgEkI/hyINQv///////////wCFIRAgDUJ/hSERDAELIAhCACANQguGQoCAgICAgICAgH+EQf4AIA1CNIina0H/AHEQ/AdCACAIKQMAIg19IA0gEkIAUyIKGyERQgAgCCkDCCIQIA1CAFKtfH0gECAKGyEQCyAJIBE3AwAgCSAQNwMIIAhBEGokAEIAQv///////////wAgBykDOEKAgICAgICAgIB/IBNEAAAAAAAA4MdmIggbIBNE////////30dkIgkbIBMgE2IiChsgD3xCAEJ/IAcpAzBCACAIGyAJGyAKGyIPIA58Ig4gD1StfCEPDAALAAsgB0GgAWoiBkEEciEFIAYgASACIAMgBBCvAiAHKAKgASIDQX9GBEAgAEEBNgIAIAAgBSgCCDYCDCAAIAUpAgA3AgQMBAsgBzUCuAEhECAHKQOwASEOIAcgBygCvAE2AtwBIAcgAzYCwAEgByAFKAIINgLMASAHIAUpAgA3AsQBIAdBIGogDiAOQj+HQoCU69wDQgAQ/gcgDSAQfCIQIAcpAyB8IQ4gDiAQVK0gBykDKCAPIA0gEFatfHx8IhAhDyMAQSBrIgMkACADQgAgDn0gDiAPQgBTIgQbQgAgDyAOQgBSrXx9IA8gBBtCgJTr3AMQ+wcgAykDCCEPIAdBEGoiBUIAIAMpAwAiDX0gDSAEGzcDACAFQgAgDyANQgBSrXx9IA8gBBs3AwggA0EgaiQAIAcgBykDECIPIAcpAxhCgJTr3ANCABD+ByAHIA4gBykDACINfSIRQoCU69wDfCARIBAgBykDCH0gDSAOVq19Ig5CAFMbPgLYASAHIA8gDkI/h3w3A9ABIABBBGogB0HAAWogASACEIgGIABBADYCAAwDCyAHQcABakEEciAHQeABahDXBwwBCyAHQcABakEEciAHQeABahDXBwsgByAHKALMATYC8AEg", + "ByAHKQLEATcD6AEgB0EDNgKEAiAHQQI2AvwBIAcgB0HoAWo2AoACIAcgB0H4AGo2AvgBIAdBgAFqQQRyIgFBopXAACAHQfgBahAMIAcoAugBIAcoAuwBEAEgAEEBNgIAIAAgASgCCDYCDCAAIAEpAgA3AgQLIAdBkAJqJAALDgAgACABQY7TwAAQhQgLmx0DBH8BfgJ8IwBBwAFrIgEkAAJAAkACQAJAAkACQAJAAkAgBEEBRgRAIAZBAXFFDQEgAigCBCACKAIIIAUQrAIiBEEcaigCACAEQSBqKAIAQaXgwgBBBhASDQIgAiAFEPwFIQQgAigCBCACKAIIIAUQrAItAJoBQQFrDgMEBQcDCyAGQQFGBEAgACACIAcQ7AQ2AgggAEL/////HzcCAAwICyAAQv////8PNwIADAcLIAAgAiAFEOwENgIIIABC/////x83AgAMBgsgACACIAUgBxCoBzYCCCAAQv////8fNwIADAULIAFBnAFqIAIoAgQgAigCCCAFEKwCIgNBHGooAgAgA0EgaigCABBCIAFBqAFqIAIoAgQgAigCCCAFEKwCIgNBQGsoAgAgA0HEAGooAgAQiwMgAigCBCACKAIIIAQQ4QIiA0EAOgCaASABKAKwASIKRQRAIANBADYChAELIAMoAhggA0EcaigCABABIAMgASgCpAE2AiAgAyABKQKcATcCGEEEIQYCf0EAIAIoAgQgAigCCCAHEKwCIgNBHGooAgAgA0EgaigCAEGl4MIAQQYQEg0AGiACIAcQ7AQhAyACKAIEIAIoAgggBxCsAiACKAIIIQYgAigCBCEHLQCaAUUEQCABQegAaiAHIAYgAxCsAiIDQUBrKAIAIANBxABqKAIAEIsDIAEoAmghCCABKAJsIQYgASgCcAwBCyAHIAYgBRCsAiIFKAJEBEAgAigCBCACKAIIIAUoAkAoAgAQrAIoAoQBIQUgAigCBCACKAIIIAMQ4QIgBTYChAELQQRBBBDlAiIGIAM2AgBBASEI", + "QQELIQMgAiAEIAEoAqwBIgUgChDoBCACIAQgBiADEOgEIAggBhAmIAEoAqgBIAUQJgwDCyACKAIEIAIoAgggBxCsAi0AmgFBAUYNASACKAIEIAIoAgggBxCsAiEDIAFBnAFqIgQgAiAHEP0FIAIoAgQgAigCCCAFEKwCIQYgAUGoAWoiByACIAUQ/QUgAUEDNgKEASABQQM2AnwgASAGQRhqNgJ4IAFBAzYCdCABQQM2AmwgASADQRhqNgJoIAEgBzYCgAEgASAENgJwIABBpM/AACABQegAahAMIAEoAqgBIAEoAqwBEAEgASgCnAEgASgCoAEQAQwDCyACKAIEIAIoAgggBxCsAiACKAIIIQYgAigCBCEILQCaAUECRwRAIAggBiAHEKwCIQMgAUGcAWoiBCACIAcQ/QUgAigCBCACKAIIIAUQrAIhBiABQagBaiIHIAIgBRD9BSABQQM2AoQBIAFBAzYCfCABIAZBGGo2AnggAUEDNgJ0IAFBAzYCbCABIANBGGo2AmggASAHNgKAASABIAQ2AnAgAEGkz8AAIAFB6ABqEAwgASgCqAEgASgCrAEQASABKAKcASABKAKgARABDAMLIAggBiAFEKwCKAKEASEGIAIoAgQgAigCCCAEEOECIgggBjYChAEgCEECOgCaASABQThqIAIoAgQgAigCCCAFEKwCIgZBHGooAgAgBkEgaigCABBCIAFBxABqIAIgBxCtAiABKAI8IgYgASgCQCIIQcTywgBBAhD9ASIKRQRAIAFB6ABqIAIgBRCtAiABKAI4IAYQASABIAEoAnAiCDYCQCABIAEpAmg3AzggASgCPCEGCyABQdAAaiACKAIEIAIoAgggBRCsAiIJQShqKAIAIAlBLGooAgAQQiABQdwAaiACKAIEIAIoAgggBxCsAiIJQShqKAIAIAlBLGooAgAQQiACKAIEIAIoAgggBRCsAiIJQRxqKAIAIAlBIGooAgBB+K7DAEELEBIhCQJ/AkACQAJAAkAgBiAI", + "QePfwgBBBRASBEAgAUEgaiADEIYGIAEoAiAgASgCJBCuAg0BCyAJRQ0BDAILIAFBGGogAxCGBiABQegAaiIJIAEoAhggASgCHCABKAJUIAEoAlgQrwIgASgCaCAJELACQX9HDQELIAFBtAFqIAIoAgQgAigCCCAFEKwCIgNBHGooAgAgA0EgaigCABBCAkACQAJAIAYgCEHj38IAQQUQEkUEQAJAAkACQCABKAJIIgMgASgCTCIFQePfwgBBBRASRQRAAkAgBiAIQZzfwgBBBRASBEAgAyAFQZzfwgBBBRASRQ0BIAFB6ABqIAEoAlQgASgCWBCyAiABKQNwIQwgASgCbCEFIAEoAmgiBg0EIAEgDDcCLCABIAU2AigMCQsgBiAIQaHfwgBBBxASRQ0HCyADIAVBnN/CAEEFEBJFBEAgAyAFQaHfwgBBBxASRQ0HCyABQegAaiABKAJUIAEoAlgQtQIgASgCaEEBRgRAIAEgASsDcDkCLCABIAEoAmw2AigMCAsgASsDcCABQegAaiABKAJgIAEoAmQQtQIgASgCaEEBRgRAIAEgASsDcDkCLCABIAEoAmw2AigMCAsgASsDcCACKAIEIAIoAgggBBDhAiICQSRqIQUgAkEYaiEGoCENIApFDQMgAUHoAGoiB0Gh38IAQQcQBiACKAIYIAJBHGooAgAQASAGIAEoAnA2AgggBiABKQNoNwIAIAcgDRDxBCACKAIkIAJBKGooAgAQASAFIAEoAnA2AgggBSABKQJoNwIADAELIAFBnAFqIAIoAgQgAigCCCAHEKwCIgVBHGooAgAgBUEgaigCABBCIAIoAgQgAigCCCAEEOECIgIoAhggAkEcaigCABABIAIgASgCpAE2AiAgAiABKQKcATcCGCABQQM2AnQgAUEDNgJsIAEgAUHcAGo2AnAgASABQdAAajYCaCABQagBakGAgMAAIAFB6ABqEAwgAigCJCACQShqKAIAEAEgAiABKAKwATYCLCACIAEpAqgBNwIk", + "CyABKAK0ASABKAK4ARABDAMLIAFB6ABqIAEoAmAgASgCZBCyAiABKAJoRQRAIAEgASkDcDcCLCABIAEoAmw2AigMBQsgAUHoAGpBKyAMIAEpA3AQvQcgASgCaEEBRgRAIAEgASkDcDcCLCABIAEoAmw2AigMBQsgASkDcCEMIAIoAgQgAigCCCAEEOECIgIoAhggAkEcaigCABABIAIgASgCvAE2AiAgAiABKQK0ATcCGCABQegAaiAGIAUgDBC+ByACKAIkIAJBKGooAgAQASACIAEoAnA2AiwgAiABKQJoNwIkDAILIAEgASgCvAE2AnAgASABKQK0ATcDaCACKAIYIAJBHGooAgAQASAGIAEoArwBNgIIIAYgASkCtAE3AgAgAUHoAGogDRDxBCACKAIkIAJBKGooAgAQASAFIAEoAnA2AgggBSABKQJoNwIADAELIAIoAgQgAigCCCAEEOECIgIoAhggAkEcaigCABABIAIgASgCvAE2AiAgAiABKQK0ATcCGCABKAJIIgMgASgCTEGl4MIAQQYQEkUEQCABQQM2AnQgAUEDNgJsIAEgAUHcAGo2AnAgASABQdAAajYCaCABQagBakGAgMAAIAFB6ABqEAwgAigCJCACQShqKAIAEAEgAiABKAKwATYCLCACIAEpAqgBNwIkDAELIAEgASgCWDYCsAEgASABKQJQNwOoASACKAIkIAJBKGooAgAQASACIAEoAlg2AiwgAiABKQJQNwIkIAEoAlwgASgCYBABQX8MBQsgASgCXCABKAJgEAEgASgCUCABKAJUEAFBfwwECyABQQM2AnQgAUEDNgJsIAEgAUHEAGo2AnAgASABQThqNgJoIAFBKGpBzobAACABQegAahAMCyABKAK0ASABKAK4ARABDAELIAFBkAFqIQUgAUEQaiADEIYGIAFB6ABqIAEoAhAgASgCFBAGIAFBjAFqIAEoAmwiAyABKAJwIAEoAlQgASgCWCABKAJgIAEoAmQQ1gcCQCABKAKM", + "AQRAIAEgBSgCCDYCMCABIAUpAgA3AygMAQsgAigCBCACKAIIIAQQ4QIiAigCJCACQShqKAIAEAEgAiAFKAIINgIsIAIgBSkCADcCJCABQX82AigLIAEoAmggAxABCyABKAJcIAEoAmAQASABKAJQIAEoAlQQASABKAJIIQMgASgCKAshAiABKAJEIAMQASABKAI4IAEoAjwQASACQX9GDQEgACABKQIsNwIEIAAgAjYCAAwCCyABQZwBaiACKAIEIAIoAgggBRCsAiIDQUBrKAIAIANBxABqKAIAEIsDIAEoAqQBIghFBEAgAigCBCACKAIIIAQQ4QJBADYChAELIAIoAgQgAigCCCAEEOECIgMoAjwgA0FAaygCABAmQQAhBiADQQA2AkQgA0KAgICAwAA3AjwgAigCBCACKAIIIAQQ4QJBAToAmgEgAiAEIAEoAqABIAgQ6AQgAUGoAWogAigCBCACKAIIIAcQrAIiA0FAaygCACADQcQAaigCABCLAyABKAKwASEKA0AgCiAGQQFqIgdNBEAgAigCBCACKAIIIAUQrAIoAoQBIQMgAUHoAGogAigCBCACKAIIIAUQrAIiBUEcaigCACAFQSBqKAIAEEIgAigCBCACKAIIIAQQ4QIiAkEBOgCaASAIBEAgAiADNgKEAQsgAigCGCACQRxqKAIAEAEgAiABKAJwNgIgIAIgASkCaDcCGCABKAKoASABKAKsARAmIAEoApwBIAEoAqABECYFIAEoAqwBIgkgASgCsAEiCyAGQYSzwwAQISgCACEDIAkgCyAHQZSzwwAQISgCACEHIAFBCGogAiAEIAMQ/gUCQCABKAIIQQFxRQRAIAEgAiAEIAMgBxDpBAwBCyABKAIMIQMgAiACKAIEIAIoAgggBBCsAiIJQUBrKAIAIAlBxABqKAIAIANBAWoiA0Gks8MAECEoAgAgBxCoByEHIAIoAgQgAigCCCAEEOECIglBQGsoAgAgCUHEAGooAgAgA0G0s8MAECEgBzYC", + "AAsgBkECaiEGDAELCwsgACAENgIIIABC/////x83AgALIAFBwAFqJAAL/RQDCH4KfwJ8IwBB4ABrIgEkAAJAIAQgBnFFBEAgAEL/////DzcCAAwBCwJAIAIoAgQgAigCCCAFEKwCIgNBHGooAgAgA0EgaigCAEGl4MIAQQYQEkUEQCACIAUQ/AUhEwJAIAIoAgQiAyACKAIIIgQgBRCsAi0AmgFBAkYEQCADIAQgBxCsAi0AmgFBAkYNAQsgACACQeG7wwBBCSAFIAcQ2gcMAwsgAUHEAGogAyAEIAUQrAIiA0EcaigCACADQSBqKAIAEEIgAUEQaiABKAJIIhUgASgCTBBCIAFBIGogAiAHEK0CIAEoAhQiBiABKAIYIgNBxPLCAEECEP0BIhZFBEAgAUHQAGogAiAFEK0CIAEoAhAgBhABIAEgASgCWCIDNgIYIAEgASkCUDcDECABKAIUIQYLIAFBLGogAigCBCACKAIIIAUQrAIiBEEoaigCACAEQSxqKAIAEEIgAUE4aiACKAIEIAIoAgggBxCsAiIEQShqKAIAIARBLGooAgAQQiACKAIEIAIoAgggBRCsAigChAEhBwJAAkACQAJAIAYgA0Gc38IAQQUQEgRAIAEoAiQiAyABKAIoIgRBnN/CAEEFEBJFDQEgAUHQAGogASgCMCIEIAEoAjQQsgIgASkDWCEIIAEoAlQhBSABKAJQIhENAiABIAg3AgggASAFNgIEDAQLIAYgA0Gh38IAQQcQEkUNAiABKAIoIQQgASgCJCEDCyADIARBnN/CAEEFEBJFBEAgAyAEQaHfwgBBBxASRQ0CCyABQdAAaiABKAIwIgQgASgCNBC1AiABKAJQQQFGBEAgASABKwNYOQIIIAEgASgCVDYCBAwDCyABKwNYIRogAUHQAGogASgCPCIXIAEoAkAQtQIgASgCUEEBRgRAIAEgASsDWDkCCCABIAEoAlQ2AgQMAwsgASsDWCEbIAIoAgQgAigCCCATEOECIgUgBzYC", + "hAEgBUECOgCaASMAQSBrIhEkAAJAAn4CQAJAAkAgGr0iDkKAgICAgICA+P8Ag0KAgICAgICA+P8AUQ0AQgAgG70iCX1CgICAgICAgPj/AINQDQAgDkL///////////8AgyIIIAlC////////////AIMiClQNBCAIIAhCgICAgICAgAh9IglCACAIIAlaGyILQoCAgICAgID4/wCDfSIJIAogCkKAgICAgICACH0iCEIAIAggClgbIgxCgICAgICAgPj/AIMiDX0iCEIBhloEQCAKIA1RDQIgCSAIgiEJCyALQjSIIgqnIhAgDEI0iCILpyISayIHQR9NBEACQCAKIAtRDQAgB0EDcSECIBIgEGtBfE0EQCAHQRxxIQcDQCAJIAhCACAIIAlYG31CAYYiCSAIQgAgCCAJWBt9QgGGIgkgCEIAIAggCVgbfUIBhiIJIAhCACAIIAlYG31CAYYhCSAHQQRrIgcNAAsgAkUNAQtBACACayEHA0AgCSAIQgAgCCAJWBt9QgGGIQkgB0EBaiIHDQALCyAJIAhCACAIIAlYG30MBAsgB0HAAE8NAiARQRBqIAlCACAHEP8HIAggESkDGCIKWA0CIBEpAxAhCSMAQSBrIgIkACACIAkgCiAIEPsHIAIpAxAhCCARIAIpAxg3AwggESAINwMAIAJBIGokACARKQMADAMLIBogG6IiGiAaoyEaDAMLAAsCfiMAQbABayICJAACQCAJIAhCAYZaIAhCgICAgICAgIDAAFpyDQACfiAIIAhCAX0iCoNQRQRAIAggCHmnIhRBAmsiGK0iD4YiDEKAgICAgICAgCBYIAxCgICAgICAgIDAAFpyDQIgCSAMQgGGIg1aDQIjAEEgayIQJAAgEEIAQoCAgICAgICAgH8gDX0iCCANEPsHIBApAwAhCiACQaABaiIZIBApAwg3AwggGSAKNwMAIBBBIGokACACQZABaiACKQOgASIKIAIpA6gBIgsgDUIAEP4HIAJBgAFqIAogC0IBhCAJ", + "QgGGQgAQ/gcgCCACKQOYAX0gAikDkAEiCUIAUq19IQhCACAJfSEJIAIpA4gBIQogAikDgAEhCwJAIAcgGGoiEEE/SQ0AIAcgFGpBwQBrIhRBP25BAWpBA3EiBwRAA0AgAkHwAGogCkIAIAkgCBD+ByAQQT9rIRAgAikDeCALQgGIfCEKIAIpA3AhCyAHQQFrIgcNAAsLIBRBvQFJDQADQCACQeAAaiAKQgAgCSAIEP4HIAJB0ABqIAIpA2giCiALQgGIfCILIAogC1atIAkgCBD+ByACQUBrIAIpA1giCiACKQNgQgGIfCILIAogC1atIAkgCBD+ByACQTBqIAIpA0giCiACKQNQQgGIfCILIAogC1atIAkgCBD+ByACKQM4IAIpA0BCAYh8IQogAikDMCELIBBB/AFrIhBBPksNAAsLIAJBIGogCyAKIBAQ/wcgAkEQaiAJIAggCiAQQT9zrYhCABD+ByACIAIpAxAiCCACKQMgQn6DfCAIVK0gAikDGCACKQMoQv///////////wCDfHxCAnxCACANQgAQ/gcgAikDCCIIIAxCACAIIAxaG30gD4gMAQtCACAHQcAATw0AGiAKIAkgB62GgwsgAkGwAWokAAwBCwALCyEIIA5CgICAgICAgICAf4MhCSAIUEUEQCASQTQgCHmnQT9zayICIBIgAiASSRsiAmutQjSGIAl8IAggAq2GfL8hGgwBCyAJvyEaCyARQSBqJAACQCAWBEAgAUHQAGpBod/CAEEHEAYMAQsgASABKAJMNgJYIAEgASkCRDcDUAsgBSgCGCAFQRxqKAIAEAEgBSABKAJYNgIgIAUgASkDUDcCGCABQdAAaiAaEPEEIAUoAiQgBUEoaigCABABIAUgASgCWDYCLCAFIAEpAlA3AiQgASgCOCAXEAEgASgCLCAEEAEgASgCICADEAEgASgCECAGEAEgFkUNBCABKAJEIBUQAQwECyABQdAAaiABKAI8IhAgASgCQBCyAiABKAJQRQRAIAEg", + "ASkDWDcCCCABIAEoAlQ2AgQMAgsCfiABKQNYIglCAXwiCkIBWARAQgAgCqdBAWsNARogAUEEakGQu8MAQRIQBgwDCyAIIAmBCyEIIAIoAgQgAigCCCATEOECIgIgBzYChAEgAkECOgCaASACKAIYIAJBHGooAgAQASACIAEoAkw2AiAgAiABKQJENwIYIAFB0ABqIBEgBSAIEL4HIAIoAiQgAkEoaigCABABIAIgASgCWDYCLCACIAEpAlA3AiQgASgCOCAQEAEgASgCLCAEEAEgASgCICADEAEgASgCECAGEAEMAwsgAUEDNgJcIAFBAzYCVCABIAFBIGo2AlggASABQRBqNgJQIAFBBGpBwoHAACABQdAAahAMIAEoAjAhBAsgASgCOCABKAI8EAEgASgCLCAEEAEgASgCICABKAIkEAEgASgCECABKAIUEAEgASgCRCAVEAEgASgCBCICQX9GDQEgACABKQIINwIEIAAgAjYCAAwCCyAAIAJB4bvDAEEJIAUgBxDaBwwBCyAAIBM2AgggAEL/////HzcCAAsgAUHgAGokAAvVAQEDfyMAQdAAayIGJAAgBiADNgIMIAYgAjYCCCABKAIEIgIgASgCCCIDIAQQrAIhByAGQRBqIgggASAEEP0FIAIgAyAFEKwCIQIgBkEcaiIDIAEgBRD9BSAGQQM2AkwgBkEDNgJEIAYgAkEYajYCQCAGQQI2AjwgBkEDNgI0IAZBAzYCLCAGIAdBGGo2AiggBiADNgJIIAYgBkEIajYCOCAGIAg2AjAgAEHJz8AAIAZBKGoQDCAGKAIcIAYoAiAQASAGKAIQIAYoAhQQASAGQdAAaiQAC5oJAgN/AnwjAEHwAGsiASQAAkAgBCAGcUUEQCAAQv////8PNwIADAELAkACQAJ/AkAgAigCBCACKAIIIAUQrAIiA0EcaigCACADQSBqKAIAQaXgwgBBBhASRQRAIAIgBRD8BSEGAkAgAigCBCIDIAIoAggiBCAFEKwCLQCaAUEC", + "RgRAIAMgBCAHEKwCLQCaAUECRg0BCyAAIAJB1LvDAEENIAUgBxDaBwwGCyABQRRqIAMgBCAFEKwCIgNBHGooAgAgA0EgaigCABBCIAFBIGogASgCGCIKIAEoAhwQQiABQTBqIAIgBxCtAiABKAIkIgQgASgCKCIDQcTywgBBAhD9ASIJRQRAIAFB4ABqIAIgBRCtAiABKAIgIAQQASABIAEoAmgiAzYCKCABIAEpAmA3AyAgASgCJCEECyABQTxqIAIoAgQgAigCCCAFEKwCIghBKGooAgAgCEEsaigCABBCIAFByABqIAIoAgQgAigCCCAHEKwCIgdBKGooAgAgB0EsaigCABBCAkAgBCADQePfwgBBBRASBEAgASgCNCABKAI4QePfwgBBBRASDQELIAQgA0Gc38IAQQUQEkUEQCAEIANBod/CAEEHEBJFDQMLIAEoAjQiByABKAI4IgNBnN/CAEEFEBJFBEAgByADQaHfwgBBBxASRQ0DCyABQeAAaiABKAJAIgMgASgCRBC1AiABKAJgQQFGBEAgASABKwNoOQIMIAEoAmQMBAsgASsDaCABQeAAaiABKAJMIgggASgCUBC1AiABKAJgQQFGBEAgASABKwNoOQIMIAEoAmQMBAsgASsDaCACKAIEIAIoAgggBRCsAigChAEhBSACKAIEIAIoAgggBhDhAiICIAU2AoQBIAJBAjoAmgGjIQsCQCAJBEAgAUHgAGpBod/CAEEHEAYMAQsgASABKAIcNgJoIAEgASkCFDcDYAsgAigCGCACQRxqKAIAEAEgAiABKAJoNgIgIAIgASkDYDcCGCABQeAAaiALEPEEIAIoAiQgAkEoaigCABABIAIgASgCaDYCLCACIAEpAmA3AiQgASgCSCAIEAEgASgCPCADEAEgASgCMCAHEAEgASgCICAEEAFBfyECIAkNBAwFCyABQdQAaiACIAEoAkAiAyABKAJEIAEoAkwgASgCUBDnBiACKAIEIAIoAgggBhDhAiIEQQA6", + "AJoBIAFB4ABqQbDewgBBBRAGIAQoAhggBEEcaigCABABIAQgASgCaDYCICAEIAEpAmA3AhggAiAGIAEoAlgiAiABKAJcEOgEIAEoAlQgAhAmQX8MAgsgACACQdS7wwBBDSAFIAcQ2gcMBAsgAUEDNgJsIAFBAzYCZCABIAFBMGo2AmggASABQSBqNgJgIAFBCGpB2IHAACABQeAAahAMIAEoAkAhAyABKAIICyECIAEoAkggASgCTBABIAEoAjwgAxABIAEoAjAgASgCNBABIAEoAiAgASgCJBABCyABKAIUIAoQASACQX9GDQAgACABKQIMNwIEIAAgAjYCAAwBCyAAIAY2AgggAEL/////HzcCAAsgAUHwAGokAAsVACAAIAEgAiADIAQgBSAGIAcQ3QcLdQEBfyMAQRBrIggkAAJAIAQgBnFFBEAgAEL/////DzcCAAwBCyAIQQRqIAIgAyAFIAcgARC8ByAIKAIEQX9HBEAgACAIKAIMNgIIIAAgCCkCBDcCAAwBCyAAIAgoAgg2AgggAEL/////HzcCAAsgCEEQaiQAC0UBAX8jAEEQayIDJAAgAS8AACEIIAMgAUECai0AADoADiADIAg7AQwgACADQQxqIAIgAyAEIAUgBiAHEN8HIANBEGokAAtvAAJAIAQgBnFFDQAgAS0AAQRAIAIoAgQgAigCCCAFEKwCIgNBHGooAgAgA0EgaigCAEGl4MIAQQYQEkUNAQsgAiAFIAcgAS8AACABQQJqLQAAQRB0chDBBQsgACAFNgIIIAAgBDYCBCAAQX82AgALDAAgASAAQQRBCBAwCxwAIAEoAgBBAkcEQCAAIAEQzwYPCyAAQQI2AgALvwEBAn8jAEGwBWsiBCQAIARBCGoiBSABEM0EIARB4AFqIgEgAiADEAYgBCgCzAEgBCgC0AEQASAEIAQoAugBNgLUASAEIAQpAuABNwLMASABIAUQ5QcgACAELQCpBToAyQMgACABQdgB/AoAACAAQdgBaiAEQbgD", + "akHYAfwKAAAgAEEAOgDIAyAAIAQpA5AFNwOwAyAAIAQoApgFNgK4AyAAIAQpApwFNwK8AyAAIAQoAqQFNgLEAyAEQbAFaiQAC0EAIABBsANqIAMgBBAGIAAgAjoAyAMgAEECNgLYASAAQQI2AgAgACABOgDJAyAAQQA2AsQDIABCgICAgBA3ArwDC3sBAX8gASgCACEEIABBxAFqIAIgAxAGIABBKGogBEH/////B2sgBEEfdXEiBEECdEHw6cMAaigCACAEQejpwwBqLQAAIAIgAxDeAiAAQYDQATsB0AEgAEGAgICAeDYCGCAAQQA2AgAgACABKQMANwMIIAAgASkDCDcDEAtlAQJ/IwBBEGsiAiQAIAIgAS0A0QEQ1AQgAi0ADSEDIABBADoAyQMgACABQdgB/AoAACAAIAM6AMgDIABBAjYC2AEgAEIBNwPAAyAAQgA3A7gDIABCgICAgBA3A7ADIAJBEGokAAs8AQN/IAAoAgghASAAKAIEIgMhAgNAIAEEQCABQQFrIQEgAhDaBCACQdADaiECDAELCyAAKAIAIAMQ7AcLEgAgACgCAEECRwRAIAAQ5AQLC/UEAQd/IwBB0ABrIggkAAJAAkACQAJAAkACQAJAIAIEQCABQRhqIQsgAkEBayEMQQQgASgCACICQQJrIAJBAU0bQQFrDgQCAwYEAQsgCEEIaiAGIAUgBygCFBECACAIKAIMIQIgCCgCCCEJDAYLIAQgBU0NBSADIAVBAnRqKAIAIAEoAgRHDQUgCEEQaiALIAwgAyAEIAVBAWogBiAHEOgHIAgoAhQhAiAIKAIQIQkMBQsgBCAFTQ0EIAMgBUECdGooAgBBCkYNBCAIQRhqIAsgDCADIAQgBUEBaiAGIAcQ6AcgCCgCHCECIAgoAhghCQwECyAEIAVLDQEMAwsgCEEwaiABKAIMIAEoAhAgASgCFCACIAEoAgQgCyAMIAMgBCAFQQAgBiAHEO8HIAgoAjQhAiAIKAIwIQkMAgsgASgCDEED", + "dCEKIAMgBUECdGooAgAhDiABKAIIIQ0CQANAIA0hAiAKRQRAIAEtABBBAXFFDQQMAgsgCkEIayEKIAJBCGohDSACKAIAIA5LDQAgDiACKAIESw0ACyABLQAQDQILIAhBIGogCyAMIAMgBCAFQQFqIAYgBxDoByAIKAIkIQIgCCgCICEJDAELIAEoAgxBDGwhCiABKAIIIQICQANAIApFDQEgAigCCCEBIAIoAgQhDSAIIAc2AkwgCCAGNgJIIAggBDYCRCAIIAM2AkAgCCAMNgI8IAggCzYCOCAIQShqIA0gASADIAQgBSAIQThqQcDUwwAQ6AcgCkEMayEKIAJBDGohAiAIKAIoIglFDQALIAgoAiwhAgwBC0EAIQkLIAAgAjYCBCAAIAk2AgAgCEHQAGokAAtEAQF/IwBBEGsiAyQAIANBCGogASACQQEgAkEBa0HAqsMAENYBIAMoAgwhASAAIAMoAgg2AgAgACABNgIEIANBEGokAAuVAwEIfyMAQUBqIgMkACADQRhqIAAgAUEoEOMCAkAgAygCGEEBRw0AIANBEGogAygCHEEBaiAAIAFB6J3DABC/AiADQQhqIAMoAhAiASADKAIUIgRBKRAfIAMoAgwhByADKAIIIQAgA0EBOwE8IANBADYCOCADIAAgASAAGyIBNgIwIAMgByAEIAAbIgA2AiwgAyABNgIoIAMgADYCJCADQQA2AiAgAyAAIAFqNgI0IANBMGohCQNAIAMtAD0NASADKAIwIQAgAygCNCEBIAMoAighCgJ/AkADQCABIQQgACEHIAMgCRCVAiADKAIEIgVBf0YNASADKAIAIQggAygCMCEAIAMoAjQhASAFENkGIAVB3wBGcg0ACyADKAIgIQUgAyAEIAhqIAEgB2prIABqNgIgIAUgCmohASAIIAVrDAELIAMtAD0NAiADQQE6AD0gAy0APEUgAygCJCIEIAMoAiAiAEZxDQIgAygCKCAAaiEBIAQgAGsLIQAgASAAIAJBAhASRQ0A", + "C0EBIQYLIANBQGskACAGC8ICAQR/IwBBQGoiAyQAIAMgAjYCKCADIAE2AiQgA0EYaiABIAJBKBDwBwJAAkAgAygCGEEBRgRAIAMoAhwhBQwBCyADQQI2AjwgAyADQSRqNgI4IANBLGpBt4jAACADQThqEAwgAygCMCEFIAMoAiwiBEF/Rg0AIAAgAygCNDYCDCAAIAU2AgggACAENgIEIABBATYCAAwBCyADQRBqIAEgAkEpEPAHAkAgAygCEEEBRgRAIAMoAhQhBAwBCyADQQI2AjwgAyADQSRqNgI4IANBLGpBt4jAACADQThqEAwgAygCMCEEIAMoAiwiBkF/Rg0AIAAgAygCNDYCDCAAIAQ2AgggACAGNgIEIABBATYCAAwBCyADQQhqIAEgAiAFQQFqIARB+J3DABDWASAAIAMoAgggAygCDBD7BQsgA0FAayQACw0AIAAgAUEIQdADEDALIgAgACgCACgCACgCACAAKAIEKAIAIAFBBHRrQRBrKAIARgsNACAAIAFBCEHYARAwC6kCAQF/IwBB4ABrIg4kACAOIAU2AiQgDiADNgIcIA4gCjYCKCAOIAs2AiwgDiAENgIgAkAgBEEBRiAFIAtNcQR/IAMFIA4gDTYCXCAOIAw2AlggDiAJNgJQIA4gCDYCTCAOIAc2AkggDiAGNgJEIA4gAjYCOCAOIAE2AjQgDiAOQSxqNgJUIA4gDkEgajYCQCAOIA5BHGo2AjwgDiAOQShqNgIwIA5BEGogASACIAggCSAKIA5BMGpB8NTDABDoByAOKAIQIgsEQCAOKAIUIQQMAgsgDigCLCELIA4oAhwLIAtLBEBBACELDAELIA5BCGogBiAHIAggCSAOKAIoIAwgDRDoByAOKAIMIQQgDigCCCELCyAAIAQ2AgQgACALNgIAIA5B4ABqJAAL8AMBEn8jAEEgayIFJAAgBUEEaiADIAEgAhCiAiAFKAIIIgsgBSgCECIIaiIMQQNqQXxxIAxrIQkgC0EBayIRIAhq", + "IRIgBUEYaiITIAUtABwiDUEBayIOaiEUIAUoAhQhAiAFKAIMIQ8DQAJAIAIgCEkgAiAPS3INACAULQAAIQogAiAIayIEIQYgBCEDAkACQAJAIAQgCU8EQCAEIAQgCWtBB3EiAWshBiABIARLDQEgCSEDCyACIBFqIQEgBCAGayECAkACQANAIAJFDQEgAkEBayECIAEtAAAgAUEBayEBIApHDQALIAIgBmohAwwBCyAKQYGChAhsIQEDQCADIAYiAkkEQCACQQhrIQZBgIKECCACIAxqIgdBCGsoAgAgAXMiFWsgFXJBgIKECCAHQQRrKAIAIAFzIgdrIAdycUGAgYKEeHFBgIGChHhGDQELCyACIARLDQIDQCACRQ0FIAIgEmohASACQQFrIgMhAiABLQAAIApHDQALCyADIAhqIgIgDkkNAiACIA5rIgEgDWoiAyABSSADIA9Lcg0CIAEgC2ogEyANEPoHDQJBASEQDAMLIAYgBCAEQcyKwQAQKQALQQAgAiAEQbyKwQAQKQALIAUgAjYCFAwBCwsgACABNgIEIAAgEDYCACAFQSBqJAALOAEBfyMAQRBrIgMkACADQQhqIAEgAhDyByADKAIMIQEgACADKAIINgIAIAAgATYCBCADQRBqJAALVAEBfyMAQRBrIgMkACADQQhqIAEoAgAgASgCBCABKAIIIAEoAgwgAiABKAIQIAEoAhQQ6AcgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0EQaiQACzgBAX8jAEEQayIDJAAgA0EIaiABIAIQ9AcgAygCDCEBIAAgAygCCDYCACAAIAE2AgQgA0EQaiQAC5UBAQJ/IwBBEGsiAyQAIAEoAgAoAgAgAkYEf0EABSADQQhqIAEoAgQgASgCCCABKAIMKAIAIAEoAhAiBCgCACAEKAIEIAEoAhQgASgCGCABKAIcIAEoAiAgAiABKAIkKAIAQQFqIAEoAiggASgCLBDvByADKAIMIQIgAygCCAshASAAIAI2AgQg", + "ACABNgIAIANBEGokAAsQACAAIAI2AgQgAEEBNgIAC1IBAX8jAEEgayIEJAAgBCADNgIMIAQgAjYCCCAEQQQ2AhwgBCABQQhqNgIYIARBAjYCFCAEIARBCGo2AhAgAEHLg8AAIARBEGoQDCAEQSBqJAALvQcBBn8jAEEwayICJAAgASABKAIIQQFqIgM2AgggAkEANgIUIAJCgICAgBA3AgwDQAJAAkACQAJAAkACQCABKAIEIgUgA0sEQCABKAIAIgYgA2oiBy0AACIEQdwARwRAIARBIkcEQCAFAn9BASAEwCIEQQBODQAaQQIgBEFgcUFARg0AGkEDQQQgBEFwcUFgRhsLIANqIgQgBCAFSxsiBCADSQ0DIAJBJGogByAEIANrEFIgAigCJEUEQCACKAIsIQMgAigCKCEFDAkLIAJBGGogAUGj3sIAQQ0Q9gcgAigCICEDIAIoAhwhBSACKAIYIgZBf0YNCCAAIAM2AgwgACAFNgIIIAAgBjYCBAwFCyAAIAIpAgw3AgQgACACKAIUNgIMIABBADYCACABIANBAWo2AggMBgsgASADQQFqIgQ2AgggBCAFSQ0CIABBBGpB0ezCAEEcEAYMAwsgAEEEakHR7MIAQRwQBgwCCyADIAQgBUHE7sIAECkACyAEIAZqLQAAIQQgASADQQJqIgM2AggCQAJAAkACQAJAAkACQAJAAkACQAJAIARB7gBrDggHAQEBCAEJCgALAkAgBEHiAGsOBQUBAQEGAAsgBEEiRg0BIARBL0YNAyAEQdwARg0CCyAAQQRqIAFBtu7CAEEOEPYHDAkLIAJBDGpBIhDXAgwMCyACQQxqQdwAENcCDAsLIAJBDGpBLxDXAgwKCyACQQxqQQgQ1wIMCQsgAkEMakEMENcCDAgLIAJBDGpBChDXAgwHCyACQQxqQQ0Q1wIMBgsgAkEMakEJENcCDAULIAJBJGogARD5ByACKAIoIQQgAigCJCIDQX9HBEAgACACKAIsNgIMIAAgBDYCCCAA", + "IAM2AgQMAQsCQCAEQYB4cUGAsANGBEAgAiABKAIIIgMgASgCACABKAIEQaTuwgAQtwEgAigCACACKAIEQbTuwgBBAhD9AQ0BCyAEIQMMAgsgASADQQJqNgIIIAJBJGogARD5ByACKAIoIQMgAigCJCIFQX9HBEAgACACKAIsNgIMIAAgAzYCCCAAIAU2AgQMAQsgA0GAeHFBgLgDRwRAIAJBDGpB/f8DENcCDAILIARBCnQgA2pBgLj/GmshAwwBCyAAQQE2AgAgAigCDCACKAIQEAEMAQsgAkEMakH9/wNBfyADIANBgLADc0GAgMQAa0GAkLx/SRsiAyADQX9GGxDXAiABKAIIIQMMAgsgAkEwaiQADwsgAkEMaiAFIAMQCiABIAQ2AgggBCEDDAALAAtrAQJ/IwBBEGsiBCQAIARBCGogASgCCCIFIAEoAgAgASgCBEHU7sIAELcBAkAgBCgCCCAEKAIMIAIgAxD9AUUEQCAAIAFB5O7CAEEPEPYHDAELIABBfzYCACABIAMgBWo2AggLIARBEGokAAu5AgEFfyMAQSBrIgIkAAJAAkAgASgCCCIDQQRqIgUgASgCBCIETQRAIANBfEkEQCACQRRqIAEoAgAgA2pBBBBSIAIoAhRFBEAgAigCHCEDIAIoAhghBAwDCyACQQhqIAFBhN7CAEEREPYHIAIoAhAhAyACKAIMIQQgAigCCCIGQX9GDQIgACADNgIIIAAgBDYCBCAAIAY2AgAMAwsgAyAFIARBnOzCABApAAsgACABQYTewgBBERD2BwwBCyACQQhqIAQgA0EQENoCAkAgAi0ACEUEQCACKAIMIQMMAQsgAkEUaiABQYTewgBBERD2ByACKAIYIQMgAigCFCIEQX9GDQAgACACKAIcNgIIIAAgAzYCBCAAIAQ2AgAMAQsgACADNgIEIAEgBTYCCCAAQX82AgALIAJBIGokAAtDAQN/AkAgAkUNAANAIAAtAAAiBCABLQAAIgVGBEAgAEEBaiEAIAFB", + "AWohASACQQFrIgINAQwCCwsgBCAFayEDCyADC7cHAgR/BX4jAEGwAWsiBCQAAkACQAJAAkACQAJAAkAgA3lCQH2nIgYgAnkgAXlCQH0gAkIAUhunIgVLBEAgBUE/Sw0BIAZB3wBLDQIgBiAFa0EgSQ0DIARBoAFqIANCAEHgACAGayIHEPwHIAQ1AqABQgF8IQsMBAsgASADVCIFIAJQcUUNBQwGCyABIAEgA4AiCCADfn0hAUIAIQIMBQsgAUIgiCIIIAIgAiADQv////8PgyICgCIJIAN+fUIghoQgAoAiCkIghiABQv////8PgyAIIAMgCn59QiCGhCIBIAKAIgOEIQggASACIAN+fSEBIApCIIggCYQhCkIAIQIMBAsgBEEwaiABIAJBwAAgBWsiBRD8ByAEQSBqIANCACAFEPwHIAQgA0IAIAQpAzAgBCkDIIAiCEIAEP4HIARBEGpCAEIAIAhCABD+ByAEKQMAIQkgBCkDGCAEKQMIIgwgBCkDEHwiCyAMVK18UARAIAEgCVQiBSACIAtUIAIgC1EbRQ0CCyABIAN8IgEgA1StIAJ8IAt9IAEgCVStfSECIAhCAX0hCCABIAl9IQEMAwsCQAJAA0AgBEGQAWogASACQcAAIAVrIgUQ/AcgBCkDkAEhCSAFIAdJBEAgBEHQAGogA0IAIAUQ/AcgBEFAayADQgAgCSAEKQNQgCIMQgAQ/gcgASAEKQNAIglUIgUgAiAEKQNIIgtUIAIgC1EbRQRAIAIgC30gBa19IQIgASAJfSEBIAogCCAIIAx8IghWrXwhCgwHCyABIAEgA3wiA1atIAJ8IAt9IAMgCVStfSECIAMgCX0hASAKIAggCCAMfEIBfSIIVq18IQoMBgsgBEGAAWogCSALgCIJQgAgBSAHayIFEP8HIARB8ABqIANCACAJQgAQ/gcgBEHgAGogBCkDcCAEKQN4IAUQ/wcgBCkDgAEiCSAIfCIIIAlUrSAEKQOIASAKfHwhCiACIAQpA2h9IAEg", + "BCkDYCIJVK19IgJ5IAEgCX0iAXlCQH0gAkIAUhunIgUgBkkEQCAFQT9LDQIMAQsLIAEgA1QiBSACUHFFDQEMBAsgASABIAOAIgIgA359IQEgCiAIIAIgCHwiCFatfCEKQgAhAgwDCyACIAWtfSECIAEgA30hASAKIAhCAXwiCFCtfCEKDAILIAIgC30gBa19IQIgASAJfSEBDAELIAIgBa19IQIgASADfSEBQgEhCAsgACABNwMQIAAgCDcDACAAIAI3AxggACAKNwMIIARBsAFqJAALTQEBfgJAIANBwABxRQRAIANFDQEgAkEAIANrrYYgASADrSIEiIQhASACIASIIQIMAQsgAiADrYghAUIAIQILIAAgATcDACAAIAI3AwgL+QECA38CfiMAQeAAayIFJAACQCABIAKEUCADUHINAEIAIAF9IAEgAkIAUyIGGyEIQgACfkIAIAIgAUIAUq18fSACIAYbIgFQRQRAIAVBQGsgCEIAIANCABD+ByAFQTBqIAFCACADQgAQ/gcgBSkDOEIAUiAFKQMwIgMgBSkDSHwiASADVHIhBiAFKQNADAELIAUgA0IAIAggARD+B0EAIQYgBSkDCCEBIAUpAwALIgN9IAMgAkIAUyIHGyEIQgAgASADQgBSrXx9IAEgBxsiCSAChUIAWQ0AQQEhBgsgACAINwMAIAQgBjYCACAAIAk3AwggBUHgAGokAAtuAQZ+IAAgA0L/////D4MiBSABQv////8PgyIGfiIHIAYgA0IgiCIGfiIIIAUgAUIgiCIJfnwiBUIghnwiCjcDACAAIAcgClatIAYgCX4gBSAIVK1CIIYgBUIgiIR8fCABIAR+IAIgA358fDcDCAtNAQF+AkAgA0HAAHFFBEAgA0UNASACIAOtIgSGIAFBACADa62IhCECIAEgBIYhAQwBCyABIAOthiECQgAhAQsgACABNwMAIAAgAjcDCAsnAQF/IwBBEGsiAiQAIAIgAkEPaq0gAYQ3AwBBjJbAACACIAAQ", + "NQALOwAgAiADSQRAQcHrwgBBEyAEEDUACyAAIAM2AgQgACABNgIAIAAgAiADazYCDCAAIAEgAyAFdGo2AggLNQEBfyABKAIAIgRB/////wdPBEAgAhBgAAsgASAEQQFqNgIAIAAgATYCBCAAIAEgA2o2AgALKQAgASgCAEUEQCABQX82AgAgACABNgIEIAAgASADajYCAA8LIAIQXgALGwAgASACTQRAIAIgASADECoACyAAIAIgBGxqCy0BAX8jAEEQayIDJAAgA0ECNgIMIAMgATYCCCAAIAIgA0EIahAMIANBEGokAAtCAQJ/IwBBEGsiAyQAIANBCGogACAAKAIAQQEgAiABEJcBIAMoAggiAEF/RwRAIAMoAgwhBCAAEBwACyADQRBqJAALIwEBfyAAKAIAIAAoAggiBGsgAUkEQCAAIAQgASADIAIQLwsL7AECAX4JfyMAQRBrIgQkACAAKAIEIggEQCAAKAIAIQUCQCAAKAIMIgZFDQAgBUEIaiEAIAUpAwBCf4VCgIGChIiQoMCAf4MhAyAFIQcDQCAGRQ0BA0AgA0IAUkUEQCAHQYABayEHIAApAwBCf4VCgIGChIiQoMCAf4MhAyAAQQhqIQAMAQsLIAcgA3qnQQF0QfABcWsiCSACaygCACAJIAFrKAIAEAEgBkEBayEGIANCAX0gA4MhAwwACwALIARBBGpBEEEIIAhBAWoQhwEgBSAEKAIMayAEKAIEIQsgBCgCCBCIAQsgBEEQaiQAC24BA38gACgCCCIFIAAoAgBGBEAjAEEQayIEJAAgBEEIaiAAIAAoAgBBASADIAIQlwEgBCgCCCIGQX9HBEAgBCgCDBogBhAcAAsgBEEQaiQACyAAKAIEIAUgAmxqIAEgAvwKAAAgACAFQQFqNgIICxMBAX8gABAbIgFFBEAQHQALIAELTAEDfwJAIAAoAiAiBiAAKAKsASIHa0ECSQ0AIAAoAhwiACAGIAcgBBD5BC0AWCADRw0AIAAgBiAHQQFqIAIQ", + "+QQtAFggAUYhBQsgBQtcAQF/IwBBIGsiBCQAAkAgAgRAIABBfzYCACAAIAI2AgQMAQsgBEEIaiABEMUEIAQgBCkDCDcCECAEQQI2AhwgBCAEQRBqNgIYIAAgAyAEQRhqEAwLIARBIGokAAsvAQJ/IAEoAgwiAyADKAIAQQFqIgQ2AgAgBEUEQAALIAAgASADEOoFIAAgAjoAFAsmAQF/IwBBEGsiBSQAIAAgASACIAMgBUEPaiAEEMwFIAVBEGokAAs2AQJ/IwBBIGsiBSQAIAVBCGoiBiACEL4FIAAgASAGIANBASAEQQAQvwUgAhC7BCAFQSBqJAALMwAgAEHj38IAQQUQBiAAQQxqIAIoAgQgAigCCCADEKwCIgAgBWooAgAgACAEaigCABBCCwvy4gNSAEGAgMAAC9VYwMAAAy0weMAAAjB4wAADLTBvwAACMG/AAD5pbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiBpbnZhbGlkIFBlcmwgY2xhc3MgXMAAEnRhZzp5YW1sLm9yZywyMDAyOsAAwAEuwAABLcAAAiEhwAALdmFyaWFibGUgJHvAAn0gwAAWbWlzc2luZyB2YWx1ZSBmb3Iga2V5IMAAF2V4cGVjdGVkICc6JyBhZnRlciBrZXkgwADAEiBjYW5ub3QgbW9kdWxvIGJ5IMAAwBYgY2Fubm90IGJlIGRpdmlkZWQgYnkgwAAaaW52YWxpZCB1dGYtOCBzZXF1ZW5jZSBvZiDAEiBieXRlcyBmcm9tIGluZGV4IMAAKmluY29tcGxldGUgdXRmLTggYnl0ZSBzZXF1ZW5jZSBmcm9tIGluZGV4IMAAwAE6wBU6IGludmFsaWQgaW5wdXQgdGV4dCDAAEJleHBlY3RlZCBTQ0FMQVIsIFNFUVVFTkNFLVNUQVJULCBNQVBQSU5HLVNUQVJULCBvciBBTElBUywgYnV0IGdvdCDAABd5YW1sOiB1bmV4cGVjdGVkIGV2", + "ZW50IMAAwAsgYXQgb2Zmc2V0IMAAFnNsaWNlIGluZGV4IHN0YXJ0cyBhdCDADSBidXQgZW5kcyBhdCDAABVieXRlIHJhbmdlIHN0YXJ0cyBhdCDADSBidXQgZW5kcyBhdCDAACBpbmRleCBvdXQgb2YgYm91bmRzOiB0aGUgbGVuIGlzIMASIGJ1dCB0aGUgaW5kZXggaXMgwAAHaW5kZXggW8AeXSBvdXQgb2YgcmFuZ2UsIGFycmF5IHNpemUgaXMgwAABJ8AeJyBleHBlY3RzIDIgYXJncyBidXQgdGhlcmUgaXMgwAAeYW55IG9ubHkgc3VwcG9ydHMgYXJyYXlzLCB3YXMgwAAeYWxsIG9ubHkgc3VwcG9ydHMgYXJyYXlzLCB3YXMgwABbaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZTogaW52YWxpZCBzdGFydCBvZiBmaXhlZCBsZW5ndGggaGV4YWRlY2ltYWwgbnVtYmVyIMAAwBQgY2Fubm90IGJlIGFkZGVkIHRvIMAAK2V4cGVjdGVkIHRvIGZpbmQgb25lICdrZXknIGVudHJ5IGJ1dCBmb3VuZCDADSBpbiBwb3NpdGlvbiDAAC1leHBlY3RlZCB0byBmaW5kIG9uZSAndmFsdWUnIGVudHJ5IGJ1dCBmb3VuZCDADSBpbiBwb3NpdGlvbiDAADNiYWQgZXhwcmVzc2lvbiAtIHByb2JhYmx5IG1pc3NpbmcgY2xvc2UgYnJhY2tldCBvbiDAAMAJIGF0IGJ5dGUgwAYgbGluZSDACCBjb2x1bW4gwAARYmFkIHBhcmFtZXRlciBpbiDAAMAbIGNhbm5vdCBjaGVjayBjb250YWluZWQgaW4gwADAAiAowBwpIGNhbm5vdCBiZSBzdWJ0cmFjdGVkIGZyb20gwAAXaW52YWxpZCBudW1iZXIgbGl0ZXJhbCDAABhjYW5ub3QgaW5kZXggYXJyYXkgd2l0aCDAABBj", + "YW5ub3QgbXVsdGlwbHkgwAYgd2l0aCDAABFzdGFydCBieXRlIGluZGV4IMAnIGlzIG91dCBvZiBib3VuZHMgZm9yIHN0cmluZyBvZiBsZW5ndGggwAAPZW5kIGJ5dGUgaW5kZXggwCcgaXMgb3V0IG9mIGJvdW5kcyBmb3Igc3RyaW5nIG9mIGxlbmd0aCDAABJyYW5nZSBzdGFydCBpbmRleCDAIiBvdXQgb2YgcmFuZ2UgZm9yIHNsaWNlIG9mIGxlbmd0aCDAABByYW5nZSBlbmQgaW5kZXggwCIgb3V0IG9mIHJhbmdlIGZvciBzbGljZSBvZiBsZW5ndGggwADAFSBleGNlZWRzIGNhcGFjaXR5IG9mIMAQIHdoZW4gaW5zZXJ0aW5nIMAAZ2NhbiBvbmx5IHVzZSBtZXJnZSBhbmNob3JzIHdpdGggbWFwcyAoISFtYXApIG9yIHNlcXVlbmNlcyAoISFzZXEpIG9mIG1hcHMsIGJ1dCBnb3Qgc2VxdWVuY2UgY29udGFpbmluZyDAACdjYW5ub3QgZGVsZXRlIG5vZGVzIGZyb20gcGFyZW50IG9mIHRhZyDAACJpbGxlZ2FsIGJhc2U2NCBkYXRhIGF0IGlucHV0IGJ5dGUgwAAaY2Fubm90IHBpdm90IG5vZGUgb2YgdHlwZSDAAA51bmtub3duIHN0eWxlIMAAKkRFTFBBVEhTOiBleHBlY3RlZCBzaW5nbGUgdmFsdWUgYnV0IGZvdW5kIMAAMFNFVFBBVEg6IGV4cGVjdGVkIHNpbmdsZSB2YWx1ZSBvbiBSSFMgYnV0IGZvdW5kIMAANkRFTFBBVEhTOiBleHBlY3RlZCBhIHNlcXVlbmNlIG9mIHNlcXVlbmNlcywgYnV0IGZvdW5kIMAAOmNhbiBvbmx5IHBpdm90IGVsZW1lbnRzIG9mICEhc2VxIG9yICEhbWFwIHR5cGVzLCByZWNlaXZlZCDAAA9jb3VsZCBub3QgbG9hZCDAAE9jc3Yg", + "ZW5jb2Rpbmcgb25seSB3b3JrcyBmb3IgYXJyYXlzIG9mIHNjYWxhcnMgKHN0cmluZy9udW1iZXJzL2Jvb2xlYW5zKSwgY2hpbGRbwAddIGlzIGEgwABuY3N2IG9iamVjdCBlbmNvZGluZyBvbmx5IHdvcmtzIGZvciBhcnJheXMgb2YgZmxhdCBvYmplY3RzIChzdHJpbmcga2V5ID0+IHN0cmluZy9udW1iZXJzL2Jvb2xlYW4gdmFsdWUpLCBjaGlsZFvAB10gaXMgYSDAACRvcHRpb25zIG11c3QgYmUgYSBKU09OIG9iamVjdCwgZ290OiDAACljc3YgZW5jb2Rpbmcgb25seSB3b3JrcyBmb3IgYXJyYXlzLCBnb3Q6IMAAwBI6IGNvdWxkIG5vdCBwYXJzZSDADCBhcyBhbiBpbnQ6IMAADGJhZCBpbmRlbnQ6IMAAEGFzc2VydGlvbiBgbGVmdCDAFyByaWdodGAgZmFpbGVkCiAgbGVmdDogwAkKIHJpZ2h0OiDAABBhc3NlcnRpb24gYGxlZnQgwBAgcmlnaHRgIGZhaWxlZDogwAkKICBsZWZ0OiDACQogcmlnaHQ6IMAAEHVua25vd24gZm9ybWF0OiDAACBjb3VsZCBub3QgZ2V0IGRhdGUgdGltZSBmb3JtYXQ6IMAAFmVycm9yIHBhcnNpbmcgcmVnZXhwOiDAABB1bmtub3duIG9wdGlvbjogwABIY2Fubm90IGFjY2VzcyBhIFRocmVhZCBMb2NhbCBTdG9yYWdlIHZhbHVlIGR1cmluZyBvciBhZnRlciBkZXN0cnVjdGlvbjogwAAGeWFtbDogwAAZanNvbjogdW5zdXBwb3J0ZWQgdmFsdWU6IMAACWRlY29kZWQ6IMAAHWNvdWxkIG5vdCBwYXJzZSBkYXRldGltZSBvZiBbwBBdIHVzaW5nIGxheW91dCBbwANdOiDAABp1bmFibGUgdG8gcGFyc2UgZHVyYXRpb24gW8ADXTogwAAd", + "Y291bGQgbm90IHBhcnNlIGRhdGV0aW1lIG9mIFvAA106IMAACmJhZCBmaWxlICfAAyc6IMAAwAI6IMAAwMADIC0gwAACIyDAAAp7Im91dHB1dCI6wAksImVycm9yIjrAAX0AC3ZhcmlhYmxlICR7wA99IHNldCBidXQgZW1wdHkAG3N0cmNvbnYuUGFyc2VJbnQ6IHBhcnNpbmcgIsARIjogaW52YWxpZCBzeW50YXgAHXN0cmNvbnYuUGFyc2VGbG9hdDogcGFyc2luZyAiwBEiOiBpbnZhbGlkIHN5bnRheAAJb3BlcmF0b3IgwBUgaXMgbm90IHN1cHBvcnRlZCB5ZXQAC3ZhcmlhYmxlICR7wAl9IG5vdCBzZXQAwAwgaGFzIG5vIGtleXMAE2Nhbm5vdCBnZXQga2V5cyBvZiDAJSwga2V5cyBvbmx5IHdvcmtzIGZvciBtYXBzIGFuZCBhcnJheXMAG3VucmVjb2duaXNlZCBtYXRjaCBwYXJhbXMgJ8BQJywgcGxlYXNlIHNlZSBkb2NzIGF0IGh0dHBzOi8vbWlrZWZhcmFoLmdpdGJvb2suaW8veXEvb3BlcmF0b3JzL3N0cmluZy1vcGVyYXRvcnMAEWNhbm5vdCBqb2luIHdpdGggwCEsIGNhbiBvbmx5IGpvaW4gYXJyYXlzIG9mIHNjYWxhcnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9hbGxvYy9zcmMvY29sbGVjdGlvbnMvYnRyZWUvbWFwL2VudHJ5LnJzAGNyYXRlcy95cS1jb3JlL3NyYy9vcHMvbXVsdGlwbHkucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9jb3JlL3NyYy9zbGljZS9pbmRleC5ycwAvcnVzdC9kZXBzL2hhc2hicm93bi0wLjE3LjEvc3Jj", + "L3Jhdy5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2Vudi5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2NvcmUvc3JjL251bS9pbXAvZmx0MmRlYy9zdHJhdGVneS9ncmlzdS5ycwBjcmF0ZXMveXEtY29yZS9zcmMvY29udGV4dC5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2NvcmUvc3JjL3NsaWNlL3NvcnQvc2hhcmVkL3NtYWxsc29ydC5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2NvcmUvc3JjL3NsaWNlL3NvcnQvc3RhYmxlL3F1aWNrc29ydC5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2FsbG9jL3NyYy9mbXQucnMAY3JhdGVzL3lxLWNvcmUvc3JjL29wcy9jb2xsZWN0X29iamVjdC5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2NvcmUvc3JjL251bS9pbXAvZGl5X2Zsb2F0LnJzAGNyYXRlcy95cS1jb3JlL3NyYy95YW1sL3NhcGh5ci9jaGFyX3RyYWl0cy5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2Zvcm1hdHMucnMAY3JhdGVzL3lxLWNvcmUvc3JjL29wcy9yZWdleF9vcHMucnMAY3JhdGVzL3lxLWNvcmUvc3JjL29wcy9jb2xsZWN0aW9ucy5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL3N0cmluZ3MucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1", + "MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9zdGQvc3JjL3N5cy9zeW5jL211dGV4L25vX3RocmVhZHMucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9zdGQvc3JjL3N5cy9zeW5jL3J3bG9jay9ub190aHJlYWRzLnJzAGNyYXRlcy95cS1jb3JlL3NyYy95YW1sL3NhcGh5ci9pbnB1dC9zdHIucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9hbGxvYy9zcmMvc3RyLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2QwN2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvY29yZS9zcmMvc2xpY2UvbWVtY2hyLnJzAGNyYXRlcy95cS1jb3JlL3NyYy95YW1sL2VtaXR0ZXIucnMAY3JhdGVzL3lxLWNvcmUvc3JjL3lhbWwvc2FwaHlyL3BhcnNlci5ycwBjcmF0ZXMveXEtY29yZS9zcmMveWFtbC9zYXBoeXIvc2Nhbm5lci5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2VuY29kZXIucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9jb3JlL3NyYy9udW0vaW1wL2RlYzJmbHQvZGVjaW1hbF9zZXEucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9jb3JlL3NyYy9zdHIvcGF0dGVybi5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2NvcmUvc3JjL251bS9pbXAvZmx0", + "MmRlYy9zdHJhdGVneS9kcmFnb24ucnMAL1VzZXJzL3RhcmFzbWFua292c2tpLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVnZXgtbGl0ZS0wLjEuOS9zcmMvcGlrZXZtLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2QwN2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvY29yZS9zcmMvbnVtL2ltcC9iaWdudW0ucnMAL1VzZXJzL3RhcmFzbWFua292c2tpLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVnZXgtbGl0ZS0wLjEuOS9zcmMvcG9vbC5ycwBjcmF0ZXMveXEtY29yZS9zcmMvdXRpbC5ycwBjcmF0ZXMveXEtY29yZS9zcmMvZXZhbC5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L3N0ZC9zcmMvdGhyZWFkL2xvY2FsLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2QwN2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvYWxsb2Mvc3JjL3N0cmluZy5ycwAvVXNlcnMvdGFyYXNtYW5rb3Zza2kvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9yZWdleC1saXRlLTAuMS45L3NyYy9zdHJpbmcucnMAY3JhdGVzL3lxLWNvcmUvc3JjL3lhbWwvcmVzb2x2ZS5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2RlbGV0ZS5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2FsbG9jL3NyYy9j", + "b2xsZWN0aW9ucy9idHJlZS9uYXZpZ2F0ZS5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL3RyYXZlcnNlLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2QwN2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvY29yZS9zcmMvbnVtL2ltcC9kZWMyZmx0L3BhcnNlLnJzAC9Vc2Vycy90YXJhc21hbmtvdnNraS8uY2FyZ28vcmVnaXN0cnkvc3JjL2luZGV4LmNyYXRlcy5pby0xOTQ5Y2Y4YzZiNWI1NTdmL3JlZ2V4LWxpdGUtMC4xLjkvc3JjL2hpci9wYXJzZS5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2RhdGV0aW1lLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2QwN2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvYWxsb2Mvc3JjL2NvbGxlY3Rpb25zL2J0cmVlL25vZGUucnMAY3JhdGVzL3lxLWNvcmUvc3JjL25vZGUucnMAY3JhdGVzL3lxLWNvcmUvc3JjL2pzb24vZW5jb2RlLnJzAGNyYXRlcy95cS1jb3JlL3NyYy95YW1sL2VuY29kZS5ycwBjcmF0ZXMveXEtY29yZS9zcmMvanNvbi9kZWNvZGUucnMAY3JhdGVzL3lxLWNvcmUvc3JjL3lhbWwvZGVjb2RlLnJzAGNyYXRlcy95cS1jb3JlL3NyYy9vcHMvc2xpY2UucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9hbGxvYy9zcmMvc2xpY2UucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9jb3JlL3NyYy9mbXQvbW9kLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2Qw", + "N2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvY29yZS9zcmMvc3RyL21vZC5ycwAvVXNlcnMvdGFyYXNtYW5rb3Zza2kvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9yZWdleC1saXRlLTAuMS45L3NyYy9oaXIvbW9kLnJzAGNyYXRlcy95cS1jb3JlL3NyYy9sZXhlci9tb2QucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9jb3JlL3NyYy9zbGljZS9tb2QucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9hbGxvYy9zcmMvcmF3X3ZlYy9tb2QucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9hbGxvYy9zcmMvdmVjL21vZC5ycwAvcnVzdGMvNThjZjhmOWMzNWIzNTUxOTk3Mjc2MjdkMDdhZTM0YTRlMjg0NmQ2Ny9saWJyYXJ5L2NvcmUvc3JjL251bS9pbXAvZmx0MmRlYy9tb2QucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9hbGxvYy9zcmMvdmVjL3NwZWNfZnJvbV9pdGVyX25lc3RlZC5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2FkZC5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL2xvYWQucnMAL3J1c3QvZGVwcy9kbG1hbGxvYy0wLjIuMTQvc3JjL2RsbWFsbG9jLnJzAC9ydXN0Yy81OGNmOGY5YzM1YjM1NTE5OTcyNzYyN2QwN2FlMzRhNGUyODQ2ZDY3L2xpYnJhcnkvYWxsb2Mv", + "c3JjL3N5bmMucnMAY3JhdGVzL3lxLXdhc20vc3JjL2xpYi5ycwBjcmF0ZXMveXEtY29yZS9zcmMvb3BzL21ldGEucnMAL3J1c3RjLzU4Y2Y4ZjljMzViMzU1MTk5NzI3NjI3ZDA3YWUzNGE0ZTI4NDZkNjcvbGlicmFyeS9jb3JlL3NyYy91bmljb2RlL3VuaWNvZGVfZGF0YS5ycwAvVXNlcnMvdGFyYXNtYW5rb3Zza2kvLmNhcmdvL3JlZ2lzdHJ5L3NyYy9pbmRleC5jcmF0ZXMuaW8tMTk0OWNmOGM2YjViNTU3Zi9yZWdleC1saXRlLTAuMS45L3NyYy9uZmEucnMAL1VzZXJzL3RhcmFzbWFua292c2tpLy5jYXJnby9yZWdpc3RyeS9zcmMvaW5kZXguY3JhdGVzLmlvLTE5NDljZjhjNmI1YjU1N2YvcmVnZXgtbGl0ZS0wLjEuOS9zcmMvdXRmOC5ycwDAHyBub3QgeWV0IHN1cHBvcnRlZCBmb3IgY29udGFpbnMADWNhbm5vdCBzcGxpdCDAGCwgY2FuIG9ubHkgc3BsaXQgc3RyaW5ncwAOY2Fubm90IGVuY29kZSDAJyBhcyBiYXNlNjQsIGNhbiBvbmx5IG9wZXJhdGUgb24gc3RyaW5ncwAccmVzdWx0IG9mIHJlcGVhdGluZyBzdHJpbmcgKMALIGJ5dGVzKSBieSDADiB3b3VsZCBleGNlZWQgwAYgYnl0ZXMAHnNlcXVlbmNlIGNvbnRhaW5zIGVsZW1lbnRzIG9mIMAFIGFuZCDABiB0eXBlcwAcY2Fubm90IGNvbnZlcnQgbm9kZSBhdCBwYXRoIMAIIG9mIHRhZyDACiB0byBudW1iZXIAG2Nhbm5vdCBjb252ZXJ0IG5vZGUgdmFsdWUgW8AKXSBhdCBwYXRoIMAIIG9mIHRhZyDACiB0byBudW1iZXIAwCEgbm90IHlldCBzdXBwb3J0ZWQgZm9yIGNvbXBhcmlzb24AEmNhbm5v", + "dCBtYXRjaCB3aXRoIMBeLCBjYW4gb25seSBtYXRjaCBzdHJpbmdzLiBIaW50OiBNb3N0IG9mdGVuIHlvdSdsbCB3YW50IHRvIHVzZSAnfD0nIG92ZXIgJz0nIGZvciB0aGlzIG9wZXJhdGlvbgAXY2Fubm90IHN1YnN0aXR1dGUgd2l0aCDAYywgY2FuIG9ubHkgc3Vic3RpdHV0ZSBzdHJpbmdzLiBIaW50OiBNb3N0IG9mdGVuIHlvdSdsbCB3YW50IHRvIHVzZSAnfD0nIG92ZXIgJz0nIGZvciB0aGlzIG9wZXJhdGlvbgAOY2Fubm90IGVuY29kZSDAeiBhcyBVUkksIGNhbiBvbmx5IG9wZXJhdGUgb24gc3RyaW5ncy4gUGxlYXNlIGZpcnN0IHBpcGUgdGhyb3VnaCBhbm90aGVyIGVuY29kaW5nIG9wZXJhdG9yIHRvIGNvbnZlcnQgdGhlIHZhbHVlIHRvIGEgc3RyaW5nAAEnwCEnIGV4cGVjdHMgMSBhcmcgYnV0IHJlY2VpdmVkIG5vbmUAD2NvdWxkIG5vdCBmaW5kIMAQIGZvciBmb3JtYXRfdGltZQAOcGFyc2luZyB0aW1lICLAEyI6IGRheSBvdXQgb2YgcmFuZ2UADnBhcnNpbmcgdGltZSAiwBQiOiBob3VyIG91dCBvZiByYW5nZQAOcGFyc2luZyB0aW1lICLAFSI6IG1vbnRoIG91dCBvZiByYW5nZQAbc3RyY29udi5QYXJzZUludDogcGFyc2luZyAiwBUiOiB2YWx1ZSBvdXQgb2YgcmFuZ2UAF3lhbWw6IHVuZXhwZWN0ZWQgZXZlbnQgwBcgd2hpbGUgY29tcG9zaW5nIGEgbm9kZQDAHyBpcyBtaXNzaW5nIGl0cyByaWdodCBoYW5kIHNpZGUAwB4gaXMgbWlzc2luZyBpdHMgbGVmdCBoYW5kIHNpZGUAFnlhbWw6IHVua25vd24gYW5jaG9yICfADCcgcmVmZXJlbmNl", + "ZAAoU0VUUEFUSDogZXhwZWN0ZWQgc2luZ2xlIHBhdGggYnV0IGZvdW5kIMAQIHJlc3VsdHMgaW5zdGVhZADAHzogZXhwZWN0ZWQgcGF0aCBhcnJheSwgYnV0IGdvdCDACCBpbnN0ZWFkADFyZWR1Y2UgbXVzdCBiZSBnaXZlbiBhIHZhcmlhYmxlcyBhc3NpZ25tZW50LCBnb3QgwAggaW5zdGVhZAAfZXhwZWN0ZWQgdG8gZmluZCAxIG51bWJlciwgZ290IMAIIGluc3RlYWQAInJlZHVjZSBtdXN0IGJlIGdpdmVuIGEgYmxvY2ssIGdvdCDACCBpbnN0ZWFkACR3aXRoIG11c3QgYmUgZ2l2ZW4gYSBibG9jayAoOyksIGdvdCDACCBpbnN0ZWFkACdTRVRQQVRIIG11c3QgYmUgZ2l2ZW4gYSBibG9jayAoOyksIGdvdCDACCBpbnN0ZWFkACdmcm9tX3VuaXggb25seSB3b3JrcyBvbiBudW1iZXJzLCBmb3VuZCDACCBpbnN0ZWFkAMA2OiBleHBlY3RlZCBlaXRoZXIgYSAhIXN0ciBvciAhIWludCBpbiB0aGUgcGF0aCwgZm91bmQgwAggaW5zdGVhZAARYmFkIGV4cHJlc3Npb24sIGDAHGAgbXVzdCBiZSBmb2xsb3dlZCBieSBgdGhlbmAAEWJhZCBleHByZXNzaW9uLCBgwBRgIG11c3QgZm9sbG93IGB0aGVuYAARYmFkIGV4cHJlc3Npb24sIGDAF2Agd2l0aG91dCBtYXRjaGluZyBgaWZgACliYWQgZXhwcmVzc2lvbiwgY291bGQgbm90IGZpbmQgbWF0Y2hpbmcgYMABYAAaREVMUEFUSFM6IGV4cGVjdGVkIGVudHJ5IFvAHl0gdG8gYmUgYSBzZXF1ZW5jZSwgYnV0IGl0cyBhIMBFLiBOb3RlIHRoYXQgZGVscGF0aHMgdGFrZXMgYW4gYXJyYXkgb2YgcGF0aCBhcnJheXMsIGUu", + "Zy4gW1siYSIsICJiIl1dAAFbwAFdAMABIMABIMAQIG92ZXJmbG93cyBpbnQ2NAAEa2V5LcABLQARc3RhcnQgYnl0ZSBpbmRleCDAJiBpcyBub3QgYSBjaGFyIGJvdW5kYXJ5OyBpdCBpcyBpbnNpZGUgwAggKGJ5dGVzIMALIG9mIHN0cmluZykAD2VuZCBieXRlIGluZGV4IMAmIGlzIG5vdCBhIGNoYXIgYm91bmRhcnk7IGl0IGlzIGluc2lkZSDACCAoYnl0ZXMgwAsgb2Ygc3RyaW5nKQAYdmFsdWUgZm9yIGVudiB2YXJpYWJsZSAnwBcnIG5vdCBwcm92aWRlZCBpbiBlbnYoKQArY2Fubm90IHJlcGVhdCBzdHJpbmcgYnkgYSBuZWdhdGl2ZSBudW1iZXIgKMABKQAmY29weV9mcm9tX3NsaWNlOiBzb3VyY2Ugc2xpY2UgbGVuZ3RoICjAKykgZG9lcyBub3QgbWF0Y2ggZGVzdGluYXRpb24gc2xpY2UgbGVuZ3RoICjAASkAGWNhbm5vdCBpbmRleCBhcnJheSB3aXRoICfAAycgKMABKQAeY2Fubm90IHBpY2sgaW5kaWNlcyBmcm9tIHR5cGUgwAIgKMABKQDAAiAowBcpIGNhbm5vdCBiZSBhZGRlZCB0byBhIMACICjAASkAwAIgKMAJKSBjYW5ub3QgwAEgwAIgKMABKQAUaW5zZXJ0aW9uIGluZGV4IChpcyDAFykgc2hvdWxkIGJlIDw9IGxlbiAoaXMgwAEpAA5ub2RlIGF0IHBhdGggW8AaXSBpcyBub3QgYW4gYXJyYXkgKGl0J3MgYSDAASkADm5vZGUgYXQgcGF0aCBbwCFdIGlzIG5vdCBhbiBhcnJheSBvciBtYXAgKGl0J3MgYSDAASkAF3VuZXhwZWN0ZWQgY2hhcmFjdGVyOiBgwAEnAExpbnRlcm5hbCBlcnJvcjogZW50ZXJlZCB1bnJlYWNoYWJsZSBjb2RlOiB1bnJl", + "Y29nbml6ZWQgcmVwZXRpdGlvbiBvcGVyYXRvciAnwAEnAB11bmtub3duIGFyaXRobWV0aWMgb3BlcmF0b3IgJ8ABJwAOcGFyc2luZyB0aW1lICLABiIgYXMgIsARIjogY2Fubm90IHBhcnNlICLABiIgYXMgIsABIgAgdGltZTogbWlzc2luZyB1bml0IGluIGR1cmF0aW9uICLAASIAFHRpbWU6IHVua25vd24gdW5pdCAiwA8iIGluIGR1cmF0aW9uICLAASIAGHRpbWU6IGludmFsaWQgZHVyYXRpb24gIsABIgAUaW52YWxpZCBVUkwgZXNjYXBlICLAASIADnBhcnNpbmcgdGltZSAiwAYiIGFzICLAECI6IGV4dHJhIHRleHQ6ICLAASIAASLAASIADGNhbm5vdCB0cmltIMAfLCBjYW4gb25seSBvcGVyYXRlIG9uIHN0cmluZ3MuIAAYY2Fubm90IGNoYW5nZSBjYXNlIHdpdGggwB8sIGNhbiBvbmx5IG9wZXJhdGUgb24gc3RyaW5ncy4gAAEjwAEKAMADID0gwAEKAGJhZCBcdSBlc2NhcGV5YW1sanNvbmppbnB1dEZvcm1hdG91dHB1dEZvcm1hdGluZGVudG51bGxJbnB1dHVud3JhcFNjYWxhcnByaW50RG9jU2VwYXJhdG9yc2VudmZpbGVzAADRHBAAGQAAAOcAAAAoAAAA0RwQABkAAADnAAAARAAAANEcEAAZAAAA7gAAACcAAADRHBAAGQAAAPEAAAAlAAAA0RwQABkAAAD1AAAAJwAAANEcEAAZAAAA+wAAAB0AAADRHBAAGQAAAP0AAAAYAAAA0RwQABkAAAAEAQAAGQAAANEcEAAZAAAABwEAACAAAADRHBAAGQAAAAkBAAAgAAAA0RwQABkAAAASAQAAEgAAAHVudGVybWluYXRlZCBvYmplY3QgaW4gb3B0aW9ucwAA0RwQABkAAAAVAQAAKwAAANEcEAAZAAAAFQEAAD8AAADR", + "HBAAGQAAABgBAAASAAAAdW50ZXJtaW5hdGVkIHN0cmluZ2JhZCBlc2NhcGVleHBlY3RlZCBzdHJpbmeXERAASAAAAN8AAAA3AAAAlxEQAEgAAADgAAAAKwAAAIccEABJAAAAoAEAAB0AAADKGhAAUAAAABwAAAAFAAAAQQAAAAwAAAAEAAAAQgAAAEMAAABEAEHg2MAAC7woAQAAAEUAAABhIGZvcm1hdHRpbmcgdHJhaXQgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3Igd2hlbiB0aGUgdW5kZXJseWluZyBzdHJlYW0gZGlkIG5vdAAALA8QAEgAAACRAgAADgAAAKoBCgEEAQUXAR8BAAQMDgUHAQEBVgEdEgECAgQBAQYBAQMBAQEUAVMBiwimASYCAQYpJw4BAQECAQIBAQgbBAQdCwU4AQcOZgEIBAgEAwoDAgEQMA1lGCEJAgQBBRgCExMZBwsFGAEHBwEIKgoMAwcGTAEQAQMEDw0TAQgCAgIWAQcBAQMEAwgCAgICAQEIAQQCAQUMAgoBBAMBBgQCAhYBBwECAQIBAgQFBAICAgQBBwQBAREGCwMBCQEDARYBBwECAQUDCQEDAQIDAQ8EFQQEAwEIAgICFgEHAQIBBQMIAgICAgkCBAIBBQ0BEAIBBgMDAQQDAgEBAQIDAgMDAwwEBQMDAQMDAQYBKA0BAwEXARADCAEDAQMIAgEDAQICBBwEAQgBAwEXAQoBBQMIAQMBAwgCBQMBBA0DDA0BAwEpAggBAwEDAQEFBAcFFgYBAwESAxgBCQEBAgcIBgEBAQgSAg06BQcGATMCAQEBBQEYAQEBEwEDAgUBAQYBDgQgAT8IASQEEwQQASRDNwEBAgUQQAoEAiYBAQUBAisBAAEEAgcBAQEEAikBBAIhAQQCBwEBAQQCDwE5AQQCQyUQEFYCBgMAAhEBGgVLAwsHFAsVDBQMDQEDAQIMNAITDgEEAUNZBysFRgofAQwECRceAgULLAQaNhwE", + "PwIUMgEXAgsDMTQBDwEIMyoCBAosAQsONxYDCiQCCwUrAgMpBAEGAQIDAQXAEyILAAIGAiYCBgIIAQEBAQEBAR8CNQEHAQEDAwEHAwQCBgQNBQMBB3QBDQEQDWUBBAECCgEBAwUGAQEBAQEBBAELAgQFBQQBESkANADlBgQDAgwmAQEFAQI4BwEQFwkHAQcBBwEHAQcBBwEHAQcBIC8BAAMZCQcFAgUEVgYDAVoBBAUrAV4RIDAQAABAAEMuAgADEAoCFC8FCANxJwkCZwJSFBUBIRg0DEQBASwGAwEBAwohBSMNHQMzAQwPARAQCgUBNwkOEhcDRQEBAQEYAwIQAgQLBgIGAgYJBwEHASsBDgZ7FQAMFwQxAAACaiYHDAUFDAENAQUBAQECAQIBbCEAEkACNigMdAUBhyQaBhoLWQMGAgYCBgIDIwwBGgETAQIBDwIOIntFNQAdAzEvIA0eBSsFHgIkBAgBBSqeEiQEJAQoCDQMCwEPAQcBAgELAQ8BBwECAzQMAAkWCggYBgEqAQlFBgIBASwBAgMBAhcKFwkfQRMBAgoWChoGGiY4BgJABAECBQgBAwEdKh0DHSMIARwbNgoWChMNEm5JNzMNMw0oIhwDAQUX+ioBAgMCEAYyAwMdCgEIFioSLhUbFwlGKwUKOQkBDRkXMxEECCMDAQlAAQQJAgoBAQEjEgEiAgEGBD4HAQEBBAEPAQoHORcEAQgCAgIWAQcBAgEFAwgCAgICAwEGAQUHHAoBAQIBASYBCgEBAgEBBAECAwEBASxCAQMBBBQDHkICAgEBuDYCBxkGIj8BAQMBOzYCAUcbAg4VB7k5Z0AfCAIBAggBAgEeAQICAgIEXQgCLgIGAQEBAhszAgoRSAUBEklnCFghHwkBLQEHAQExHgIWAQ5JBwECASwDAQECAQMBAQICGAYBAgElAQIBBAEBFywAFwkRASkDA28BTwBmbxHEAGEPABEGGQAFAAAvAAAHHxFPER4SMBAEHxUFEwAt00AgGQIZLEsE", + "OQcRQAIBAQwHCQApIGFzAAQBBwECAQAPAR0DAgEOBAgAAGsFDQMJBwoEAQBVAUcBAgIBAgICBAEMAQEBBwFBAQQCCAEHARwBBAEFAQEDBwEAAhkBGQEfARkBHwEZAR8BGQEfARkBCAAfBgbVBwERAgcBAgEFBT4hAXAtCgcQAQAeEiwAHOQeAgHPHwEWCALgBwEEAQIBDwHFO0QDAQMBAAQBGwECAQECAQEKAQQBAQEBBgEEAQEBAQEBAwECAQECAQEBAQEBAQEBAQIBAQIEAQcBBAEEAQEBCgERBQMBBQERABoGGgYaAAAgAAIAAgAPAAAAAAAFAAAAAgYEBwEBARQBAAEmAjICAwE3CBsEBgsAATwCZQ47AjECDwEcAgEBCwUiBe0BCAICAhYBBwEBAwQCCQICAgQIAQQCAQUCGQIDAQYEAgIWAQcBAgECAQICAQEFBAICAwMBBwQBAQcRCgMBCQEDARYBBwECAQUCCgEDAQMCAQ8EAgwHBwEDAQgCAgIWAQcBAgEFAgkCAgIDBwMEAgEFAhIKAgEGAwMBBAMCAQEBAgMCAwMDDAQFAwMBBAIBBgEOFQUNAQMBFwEQAgkBAwEEBwIBAwECAgQCCgcWAQMBFwEKAQUCCQEDAQQHAgUDAQQCCgEDDA0BAwEzAQMBBgQQAhoBAwESAxgBCQEBAgcDAQQGAQEBCAYKAgMMOgQdJQIBAQEFARgBAQEXAgUBAQEHAQoCBCBIASQEJwEkAQ8BDSXGAQEFAQIAAQQCBwEBAQQCKQEEAiEBBAIHAQEBBAIPATkBBAJDAiADGgZWAgYCAANZBxYJGAkUDA0BAwECDF4CCgYKBhoGWQcrBUYKHwEMBAwEAQMqAgULLAQaBgsDPgJBAR0CCwYKBg4CLgIMFE0Bpgg8Aw8DPgUrAgsIKwUAAgYCJgIGAggBAQEBAQEBHwI1AQ8BDgIGARMCAwEJAWUBDAIbAQ0DIg4hD4wEABYLFQACAAUtAQEFAQI4BwIOGAkHAQcBBwEHAQcB", + "BwEHAQcBfiIaAVkM1hpQAVYCZwUrAV4BVgkwAQADNwkAFLgI3RQ8AwoGOAhGCAwGdAseA04BCwQhATcJDgIKAmcYHAoGAgYCBgkHAQcBPAR+AgoGAAwXBDEEAAJqJgcMBQUaAQUBAQECAQIBACAqBjMBEwEEBAUBhwIBAb4DBgIGAgYCAwMHAQcKBQIMARoBEwECAQ8CDiJ7BQMELQNYAQ0DAS8ugh0DMQ8cBCQJHgUrBR4BJQQOKp4CCgYkBCQEKAg0CwwBDwEHAQIBCwEPAQcBAgM0DAAJFgoIGAYBKgEJRQYCAQEsAQIDAQIXAUgICTATAQIFIQMbBRsmOAQUAjIBAgUIAQMBHQIDBAoHCQdAICcEDAk2Ax0CGwUaBwQMB1BJNzMNMwcuCAoGJgMdCALQHwEqAQMCAhAGCAkhLggqFhomHBQXCU4EJAlECgECGQcKBjUBEggnCWABFAsSAS8+BwEBAQQBDwELBjsFCgYEAQgCAgIWAQcBAgEFAQoCAgIDAgEGAQUHAgcDBQsKAQECAQEmAQoBAQIBAQQBCgECCAIdXAEFHkgICqY2AiYiRQsKBg0TOgYKBhQcGwIPBBe5PGRTDAgCAQIIAQIBHgECAgwJCkYIAi4CCxtICFMNSQcKVghYIg4KBgkBLQEOCh0DIAIWAQ5JBwECASwDAQECAQkICgYGAQIBJQECAQYHCgYsBAr2GQcRASkDHVUBDzINAGZvAQULxABjDQAKAAUAADoAAAcfAQoEUQEKBh4CBgpGCgoBBwEVBRMAOsZbBRkCGSxLBDkHEUAFCwcJACkgYXMABAEHAQIBAA8BHQMCAQ4ECAAAawUNAwkHCgIIAP0DAAYXDxEPLgIXCXQ89gonAsIVRnoUDBQMVwkZh1UBRwECAgECAgIEAQwBAQEHAUEBBAIIAQcBHAEEAQUBAQMHAQACAAIADwUBDwAfBgbVBwERAgcBAgEFBT4hAXAtAw4CCgQCAB8ROgUBACrWKwQBwB8BFggC4AcBBAECAQ8B", + "xQIQKUwECgQCAERMPcIEARsBAgEBAgEBCgEEAQEBAQYBBAEBAQEBAQMBAgEBAgEBAQEBAQEBAQECAQECBAEHAQQBBAEBAQoBEQUDAQUBETQCACwEZAwPAg8BDwElCq44HQ0sBAkHAg4GmgADEQMNA9oGDAQBDwwEOAgKBigIHgIMBAIOCScACA4CDQMLAzkBAQQQAgwECgeTAWcAACAAAgACAA8AAAAAAAUAAACoAQQBAQEEAQICAMAEAgQBCQIBAfsHzwEFATEtAQEBAgECAQEsAQsGCgsBASMBChUQAWUIAQoBBCEBAQEeG1sLOgsEAQIBGBgrAywBBwIFCSk6NwEBAQQIBAEDBwoCDQEPAToBBAQIARQCGgECAjkBBAIEAgIDAwEeAgMBCwI5AQQFAQIEARQCFgYBAToBAgEBBAgBBwILAh4BPQEMATIBAwE3AQEDBQMBBAcCCwIdAToBAgEGAQUCFAIcAjkCBAQIARQCHQFIAQcDAQFaAQIHCwliAQIJCQEBB0kCGwEBAQEBNw4BBQECBQsBJAkBZgQBBgECAgIZAgQDEAQNAQICBgEPAV4BAAMAAx0CHgIeAkACAQcIAQILAwEFAS0FMwFBAiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEnAQguAgwUBDABAQUBAQUBKAkMAiAEAgIBAzgBAQIDAQEDOggCAkAGUgMBDQEHBAEGAQMCMj8NASJlAAEBAwsDDQMNAw0CDAUIAgoBAgECBTEFAQoBAQ0BEA0zIQACcQN9AQ8BYCAvAQABJAQDBQUBXQZdAwABAAYAAWIEAQoBARwEUAIOIk4BFwNmBAMCCAEDAQQBGQIFAZcCGhINASYIGQsuAzABAgQCAhEBFQJCBgICAgIMAQgBIwELATMBAQMCAgUCAQEbAQ4CBQIBAWQFCQN5AQIBBAEAAZMRABADAQwQIgECAakBBwEGAQsBIwEBAS8BLQJDARUDAAHiAZUFAAYBKgEJAAMBAgUEKAMEAaUCAAQm", + "ARoFAQEAAhgBNAZGCzEEewE2DykBAgIKAzEEAgICAQQBCgEyAyQFAQg+AQwCNAkKBAIBXwMCAQECBgECAZ0BAwgVAjkCAwElBwMFRgYNAQEBAQEOAlUIAgMBARcBVAYBAQQCAQLuBAYCAQIbAlUIAgEBAmoBAQECBgEBZQEBAQIEAQUACQECAAIBAQQBkAQCAgQBIAooBgIECAEJBgIDLg0BAsYBAQMBAckHAQYBAVIWAgcBAgECegYDAQECAQcBAUgCAwEBAUEBAAILAjQFBQEBARcBABEGDwAMAwMABTsHCQQAAygCAAE/EUACAQINAgAEAQcBAgACAQQALgIXAAMJEAIHHgSUAwA3BDIIAQ4BFgUBDwAHARECBwECAQUFPiEBoA4AAT0EAAX+AvMBAgEHAgUBCQEAB20IAAUAAR5ggPAAAHAABwAtAQEBAgECAQFICzAVEAFlBwIGAgIBBCMBHhtbCzoJCQEYBAEJAQMBBSsDOwkqGAEgNwEBAQQIBAEDBwoCHQE6AQEBAgQIAQkBCgIaAQICOQEEAgQCAgMDAR4CAwELAjkBBAUBAgQBFAIWBgEBOgEBAgEECAEHAwoCHgE7AQEBDAEJASgBAwE3AQEDBQMBBAcCCwIdAToBAgIBAQMDAQQHAgsCHAI5AgEBAgQIAQkBCgIdAUgBBAECAwEBCAFRAQIHDAhiAQIJCwdJAhsBAQEBATcOAQUBAgULASQJAWYEAQYBAgICGQIEAxAEDQECAgYBDwEAAwAEHAMdAh4CQAIBBwgBAgsJAS0DAQF1AiIBdgMEAgkBBgPbAgIBOgEBBwEBAQECCAYKAgEwLgIMFAQwCgQDJgkMAiAEAgY4AQECAwEBBTgIAgKYAwENAQcEAQYBAwLGQAABwyEAA40BYCAABmkCAAQBCiACUAIAAQMBBAEZAgUBlwIaEg0BJggZCwEBLAMwAQIEAgICASQBQwYCAgICDAEIAS8BMwEBAwICBQIBASoCCAHuAQIBBAEAAQAQEBAAAgAB", + "4gGVBQADAQIFBCgDBAGlAgAEQQUAAk0GRgsxBHsBNg8pAQICCgMxBAICBwE9AyQFAQg+AQwCNAkBAQgEAgFfAwIEBgECAZ0BAwgVAjkCAQEBAQwBCQEOBwMFQwECBgEBAgEBAwQDAQEOAlUIAgMBARcBUQECBgEBAgEBAgEC6wECBAYCAQIbAlUIAgEBAmoBAQECCGUBAQECBAEFAAkBAvUBCgQEAZAEAgIEASAKKAYCBAgBCQYCAy4NAQLGAQEDAQHJBwEGAQFSFgIHAQIBAnoGAwEBAgEHAQFIAgMBAQEAAgsCNAUFAxcBAAEGDwAMAwMABTsHAAE/BFEBCwIAAgAuAhcABQMGCAgCBx4ElAMANwQyCAEOARYFAQ8ABwERAgcBAgEFZAGgBwABPQQABP4C8wECAQcCBQEAB20HAGCA8ACyAgUBAgMACoYKxgoACnYKBAZsCnYKdgoCBm4NcwoIB2cKaAcHE20KYAp2CkYUAApGCgAUAAPvCgYKFgoACoALpQoGCrYKVgqGCgYKAAEDBgYKxjMCBQA8ThYAHgABAAEZCQ4DAASKCh4IAQ8gCicPAAq8CgAGmgomCsYKFgpWCgAKAAoALQw5EQIAGyQEHQEIAYYFygoACBkHJwlLBRYGoAICEAIuQAk0Ah4DSwVoCBgIKQcABjAKBgoAH54KKgRwB4YegAo8CpAKBxT7CgAKdgoACmYKBhRMDAATXQoAClYd4wpGCjYKAApmFQBvAAoAClYKhgoBBwAKABcAAwAKABQMFGwZADIACgAKAAr3CgAJgAoAOwEDAQRMLQEPAA0ACgCtAQABAAEAAgACVQUABRoFMRAAAQAQ7wGgAU8JAAQACAAAAK0BAAYWAcABMQEAAlABAAEABRoFMQUBCgAB+QMAAQ8BABAABAAIAAEeYAAAAQIBAgEmAQAICAgICAwBDwEvAQAMEQAACQAADQ4KABAAQbmBwQALAgYCAEHOgcEACwkEAQAPAAgAAAsAQeuBwQALAQUAQYWCwQAL", + "9yoTAAMSAAcDDgYGAAYGAgUMBg8GBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgkGBgYGBgYGBgYGBgYGBgYGBgYGBgYHBg0GCwYGAQYGBgYGBgYGBgYGBgYGBgYGBgYGCAYGBgYGBgYGBgYGBgYGBgYGBgYGBgYGBgYQBgYGBgoGBAEAAAAAAAAACgAAAAAAAABkAAAAAAAAAOgDAAAAAAAAECcAAAAAAACghgEAAAAAAEBCDwAAAAAAgJaYAAAAAAAA4fUFAAAAAADKmjsAAAAAAOQLVAIAAAAA6HZIFwAAAAAQpdToAAAAAKByThgJAAAAQHoQ81oAAACAxqR+jQMAMDEyMzQ1Njc4OWFiY2RlZgAAAAAEAAAABAAAAEYAAAAKHRAAWAAAAC8AAAAjAAAAMC4wZTBlMGFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBzaWdfZGlnaXRzaBsQAFcAAABDAgAADQAAAGFzc2VydGlvbiBmYWlsZWQ6IGJ1Zi5sZW4oKSA+PSBtYXhsZW4AAABoGxAAVwAAAIsCAAANAAAAAAMGCQ0QExcaHSEkJysuMTU4OyB7ICwgOiAgewosCigKAAAAng8QAFUAAAAuAAAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IG90aGVyID4gMGFzc2VydGlvbiBmYWlsZWQ6IG5vYm9ycm93IH0ARxQQAFIAAACEAQAAAQAAAGFzc2VydGlvbiBmYWlsZWQ6IGRpZ2l0cyA8IDQwAAAAAAAAAAwAAAAEAAAARwAAAEgAAABJAAAAyRIQAF8AAABYAAAAJwAAAMkSEABfAAAAigAAABMAAADJEhAAXwAAALIAAAAgAAAAyRIQAF8AAADJAAAAJQAAADAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDApExAATwAAAIEGAAAVAAAAKRMQAE8AAACvBgAAFQAA", + "ACkTEABPAAAAsAYAABUAAAApExAATwAAAHYFAAAoAAAAKRMQAE8AAAB2BQAAEgAAAKUZEABLAAAA5gEAABQAAABjYWxsZWQgYE9wdGlvbjo6dW53cmFwKClgIG9uIGEgYE5vbmVgIHZhbHVlPT0wMDAxMDIwMzA0MDUwNjA3MDgwOTEwMTExMjEzMTQxNTE2MTcxODE5MjAyMTIyMjMyNDI1MjYyNzI4MjkzMDMxMzIzMzM0MzUzNjM3MzgzOTQwNDE0MjQzNDQ0NTQ2NDc0ODQ5NTA1MTUyNTM1NDU1NTY1NzU4NTk2MDYxNjI2MzY0NjU2NjY3Njg2OTcwNzE3MjczNzQ3NTc2Nzc3ODc5ODA4MTgyODM4NDg1ODY4Nzg4ODk5MDkxOTI5Mzk0OTU5Njk3OTg5OQAAAOAREABQAAAArAAAAAkAAADgERAAUAAAAJAAAAAeAAAAYXR0ZW1wdCB0byBkaXZpZGUgYnkgemVyb2F0dGVtcHQgdG8gZGl2aWRlIHdpdGggb3ZlcmZsb3dhc3NlcnRpb24gZmFpbGVkOiAhYnVmLmlzX2VtcHR5KCkAAABoGxAAVwAAALcAAAAFAAAAYXNzZXJ0aW9uIGZhaWxlZDogYnVmWzBdID4gYicwJwBoGxAAVwAAALgAAAAFAAAAaBsQAFcAAAAJAQAABQAAAGgbEABXAAAACgEAAAUAAABlZS0AwgIAAEkSgAFtFsAzFh+AOLYkAEUALOBNBTAgTgA04FLATeBVjaQAVg2mQFak18BWAPlAYW764GE+/QBigALBZDcH4WngHsFvmiMhmJAvgZkwNCGa+0OBmkdGAZsAYUGbAGhhmzlqoZtAbcGb1oyhnfCvQaAjseGg/LLBoQC8AaMA1CGjptZhpADfAamQ4uGr0OThrgDuYa8w8eGyAAAiu+Cm4rseuAK8rs5CvOHrgrxe7sK8APgCvR76Ir0AAEO9SxNjvXo0g716NNS9wAAWACAA2AAGACAAAAEuAQEAMgEEAQEAOQEO", + "AQEASgEsAQEAeAEAAIf/eQEEAQEAgQEAANIAggECAQEAhgEAAM4AhwEAAAEAiQEBAM0AiwEAAAEAjgEAAE8AjwEAAMoAkAEAAMsAkQEAAAEAkwEAAM0AlAEAAM8AlgEAANMAlwEAANEAmAEAAAEAnAEAANMAnQEAANUAnwEAANYAoAEEAQEApgEAANoApwEAAAEAqQEAANoArAEAAAEArgEAANoArwEAAAEAsQEBANkAswECAQEAtwEAANsAuAEAAAEAvAEAAAEAxAEAAAIAxQEAAAEAxwEAAAIAyAEAAAEAygEAAAIAywEQAQEA3gEQAQEA8QEAAAIA8gECAQEA9gEAAJ//9wEAAMj/+AEmAQEAIAIAAH7/IgIQAQEAOgIAACsqOwIAAAEAPQIAAF3/PgIAACgqQQIAAAEAQwIAAD3/RAIAAEUARQIAAEcARgIIAQEAcAMCAQEAdgMAAAEAfwMAAHQAhgMAACYAiAMCACUAjAMAAEAAjgMBAD8AkQMQACAAowMIACAAzwMAAAgA2AMWAQEA9AMAAMT/9wMAAAEA+QMAAPn/+gMAAAEA/QMCAH7/AAQPAFAAEAQfACAAYAQgAQEAigQ0AQEAwAQAAA8AwQQMAQEA0AReAQEAMQUlADAAoBAlAGAcxxAAAGAczRAAAGAcoBNPANCX8BMFAAgAiRwAAAEAkBwqAED0vRwCAED0AB6UAQEAnh4AAEHioB5eAQEACB8HAPj/GB8FAPj/KB8HAPj/OB8HAPj/SB8FAPj/WR8GAfj/aB8HAPj/iB8HAPj/mB8HAPj/qB8HAPj/uB8BAPj/uh8BALb/vB8AAPf/yB8DAKr/zB8AAPf/2B8BAPj/2h8BAJz/6B8BAPj/6h8BAJD/7B8AAPn/+B8BAID/+h8BAIL//B8AAPf/JiEAAKPiKiEAAEHfKyEAALrfMiEAABwAYCEPABAAgyEAAAEAtiQZABoAACwvADAAYCwAAAEAYiwAAAnWYywAABrxZCwAABnWZywEAQEAbSwA", + "AOTVbiwAAAPWbywAAOHVcCwAAOLVciwAAAEAdSwAAAEAfiwBAMHVgCxiAQEA6ywCAQEA8iwAAAEAQKYsAQEAgKYaAQEAIqcMAQEAMqc8AQEAeacCAQEAfacAAPx1fqcIAQEAi6cAAAEAjacAANhakKcCAQEAlqcSAQEAqqcAALxaq6cAALFarKcAALVaracAAL9arqcAALxasKcAAO5asacAANZasqcAAOtas6cAAKADtKcOAQEAxKcAAND/xacAAL1axqcAAMh1x6cCAQEAy6cAAJlazKcOAQEA3KcAAL9Z9acAAAEAIf8ZACAAMAFpAAcDAAAABCcAKACwBCMAKABwBQoAJwB8BQ4AJwCMBQYAJwCUBQEAJwCADDIAQABQDRUAIACgGB8AIABAbh8AIACgbhgAGwAA6SEAIgDoRhAArAAAAPBKEAABAAAA+EoQAAwAAAACAAAAAAAAALUAAADnAuAAFgDg//gABgDg//8AAAB5AAEBLgH//zEBAAAY/zMBBAH//zoBDgH//0sBLAH//3oBBAH//38BAADU/oABAADDAIMBAgH//4gBAAD//4wBAAD//5IBAAD//5UBAABhAJkBAAD//5oBAACjAJsBAABBpp4BAACCAKEBBAH//6gBAAD//60BAAD//7ABAAD//7QBAgH//7kBAAD//70BAAD//78BAAA4AMUBAAD//8YBAAD+/8gBAAD//8kBAAD+/8sBAAD//8wBAAD+/84BDgH//90BAACx/98BEAH///IBAAD///MBAAD+//UBAAD///kBJgH//yMCEAH//zwCAAD//z8CAQA/KkICAAD//0cCCAH//1ACAAAfKlECAAAcKlICAAAeKlMCAAAu/1QCAAAy/1YCAQAz/1kCAAA2/1sCAAA1/1wCAABPpWACAAAz/2ECAABLpWMCAAAx/2QCAABnpWUCAAAopWYCAABEpWgCAAAv/2kCAAAt/2oCAABEpWsCAAD3KWwCAABBpW8CAAAt/3ECAAD9KXICAAAr", + "/3UCAAAq/30CAADnKYACAAAm/4ICAABDpYMCAAAm/4cCAAAqpYgCAAAm/4kCAAC7/4oCAQAn/4wCAAC5/5ICAAAl/50CAAAVpZ4CAAASpUUDAABUAHEDAgH//3cDAAD//3sDAgCCAKwDAADa/60DAgDb/7EDEADg/8IDAADh/8MDCADg/8wDAADA/80DAQDB/9ADAADC/9EDAADH/9UDAADR/9YDAADK/9cDAAD4/9kDFgH///ADAACq//EDAACw//IDAAAHAPMDAACM//UDAACg//gDAAD///sDAAD//zAEHwDg/1AEDwCw/2EEIAH//4sENAH//8IEDAH//88EAADx/9EEXgH//2EFJQDQ/9AQKgDAC/0QAgDAC/gTBQD4/4AcAACS54EcAACT54IcAACc54McAQCe54UcAACd54YcAACk54ccAADb54gcAADCiYocAAD//3kdAAAEin0dAADmDo4dAAA4igEelAH//5seAADF/6EeXgH//wAfBwAIABAfBQAIACAfBwAIADAfBwAIAEAfBQAIAFEfBgEIAGAfBwAIAHAfAQBKAHIfAwBWAHYfAQBkAHgfAQCAAHofAQBwAHwfAQB+ALAfAQAIAL4fAADb49AfAQAIAOAfAQAIAOUfAAAHAE4hAADk/3AhDwDw/4QhAAD//9AkGQDm/zAsLwDQ/2EsAAD//2UsAADV1WYsAADY1WgsBAH//3MsAAD//3YsAAD//4EsYgH//+wsAgH///MsAAD//wAtJQCg4yctAACg4y0tAACg40GmLAH//4GmGgH//yOnDAH//zOnPAH//3qnAgH//3+nCAH//4ynAAD//5GnAgH//5SnAAAwAJenEgH//7WnDgH//8inAgH//82nDgH///anAAD//1OrAABg/HCrTwAwaEH/GQDg/98AUwBTAAAASQG8Ak4AAADwAUoADAMAAJADmQMIAwEDsAOlAwgDAQOHBTUFUgUAAJYeSAAxAwAAlx5UAAgDAACYHlcACgMAAJkeWQAK", + "AwAAmh5BAL4CAABQH6UDEwMAAFIfpQMTAwADVB+lAxMDAQNWH6UDEwNCA4AfCB+ZAwAAgR8JH5kDAACCHwofmQMAAIMfCx+ZAwAAhB8MH5kDAACFHw0fmQMAAIYfDh+ZAwAAhx8PH5kDAACIHwgfmQMAAIkfCR+ZAwAAih8KH5kDAACLHwsfmQMAAIwfDB+ZAwAAjR8NH5kDAACOHw4fmQMAAI8fDx+ZAwAAkB8oH5kDAACRHykfmQMAAJIfKh+ZAwAAkx8rH5kDAACUHywfmQMAAJUfLR+ZAwAAlh8uH5kDAACXHy8fmQMAAJgfKB+ZAwAAmR8pH5kDAACaHyofmQMAAJsfKx+ZAwAAnB8sH5kDAACdHy0fmQMAAJ4fLh+ZAwAAnx8vH5kDAACgH2gfmQMAAKEfaR+ZAwAAoh9qH5kDAACjH2sfmQMAAKQfbB+ZAwAApR9tH5kDAACmH24fmQMAAKcfbx+ZAwAAqB9oH5kDAACpH2kfmQMAAKofah+ZAwAAqx9rH5kDAACsH2wfmQMAAK0fbR+ZAwAArh9uH5kDAACvH28fmQMAALIfuh+ZAwAAsx+RA5kDAAC0H4YDmQMAALYfkQNCAwAAtx+RA0IDmQO8H5EDmQMAAMIfyh+ZAwAAwx+XA5kDAADEH4kDmQMAAMYflwNCAwAAxx+XA0IDmQPMH5cDmQMAANIfmQMIAwAD0x+ZAwgDAQPWH5kDQgMAANcfmQMIA0ID4h+lAwgDAAPjH6UDCAMBA+QfoQMTAwAA5h+lA0IDAADnH6UDCANCA/If+h+ZAwAA8x+pA5kDAAD0H48DmQMAAPYfqQNCAwAA9x+pA0IDmQP8H6kDmQMAAAD7RgBGAAAAAftGAEkAAAAC+0YATAAAAAP7RgBGAEkABPtGAEYATAAF+1MAVAAAAAb7UwBUAAAAE/tEBUYFAAAU+0QFNQUAABX7RAU7BQAAFvtOBUYFAAAX+0QFPQUAACgEJwDY/9gEIwDY/5cFCgDZ/6MFDgDZ/7MFBgDZ", + "/7sFAQDZ/8AMMgDA/3ANFQDg/8AYHwDg/2BuHwDg/7tuGADl/yLpIQDe/wAAYEsQALkAAAC2TxAAZgAAAOZSEAAMAAAAAgAAAAAAAAB4AwAAMAUgAA4HYAFJEiADnRagKBYfoC0qJKA3dCtgPfQs4D2NpCA+LKagRKTXIEVu+qBL0P1gTDcHoU6aI+FbkC9hhVY0QYb7Q6GGR0bhhgBhIYcAaEGHOWqBh0BtoYfWjIGK8K/hjCOxgY38smGOALyhjwDMwY+0zgGRptZhkczXYZmM2qGZAN/hmZDigZrQ5MGdceyBngDwQaLZ9kGrWPphrgAA4rHgpoK0HriitK7O4rTh6yK1Xu5itQD4orUe+sK1AADjtUsTA7Z6NCO2/v9jtv7/lLawAgAAXRNgARIX4CC9HyAhfCwgLwUwYDMVoOA0+KRgNgymoDYe++A2AP7gQv0BYUOAByFHAQrhRyQNoUirDiFKLxghSzsZ4VrzHmFbMDShYx5hIWXwaqFlQG0hZk9v4Wbwr2FnnbyhaADPYWln0eFpANphagDgoWuu4iFt6+Qhb9DooW/782FxAQDucfABP3IAAwAAgwQgAJEFYABdE6AAEhcgHwwgYB/vLGArKjDgK2+moCwCqCAtHvsgLgD+YDae/6A2/QEhNwEKYTckDSE4qw6hOS8YITrzHiFLQDShUx5h4VTwamFVT2/hVZ28YVYAz2FXZdGhVwDaIVgA4KFZruIhW+zk4VzQ6GFdIADuXvABf19gBgAAZgngAEAQoAFpE+AF7hZgBkYZoAZwIKAHYCSgCXYn4Ar9LGALBzCgC5Ix4AsgpqAMMKggDvCroA4Q/yAQBwFhEOECoRBYCGER+gzhEmAOoRZQFGEXUBbhGeAYYRrwG2EbUB/hGwAkIR0wYaEdYGrhHXBtIR6AbiEf9G9hH/DMoR/A0uEfztchIEDh4SDw4iEh8ORhIcfooSFx7CEiAPGhIvD74SP6+zIkTwMAABwGYABfEaAAtBfgAAsgIAFkMaABAP5g", + "AqC8oQJz0aEDAADuAwAQLgQAEF8EAAYAAJAIYAAOGGABCyDgAf/+IAK9ECEDMDShA6C8IQRz0WEEAQCuBIAA/wTFAQAAiB8gAP0fMQEAQAG4AbYBswGsAagBoQGSAZABjAGIAYQCkgKQAlMDXQOTA4UEDAQGBbsGTgBBiK3BAAvAA/8AAAD8//8PAqiqqqqqqqr///////8HAP/9AAAA/P//AAAAAAAAAoAAAAD/////D4Wq////////AAAAAP////8AAAAA/P///wAAAAAA////7/8AAAD8//8AAAEAAPD/////DwAAwP//////9/8D///AQwAAAAD//wAAAAAAAP//AAAAgP//f//A////AAAA/AAAAAAAAAD4AAD///////f8///3AwAA8FTVqqqqqqqqqqqqqqqqqqqqqqqqqqqqVf8A/wD/AN9APwD/AP8A/z//////YhXaPwAAAAAAAAA/IAAAAAAAijwAxAgAAIAQMgAAgP/7//sb/3/jqqqqLxm5///////9BwqlqgoAAF4HAAAAAAAEIAT//8//////Af8APwD/AP8A3ADPAP8A3ACqqqqqGlAIAP////+/IAAA//v/f+AHAAAAwN///wAAAAMAAAAfAAAAqqqqOgAAAAB/APgAAAAAAPcLAAAAAAAA/wUAAAAAAACqqqqqqqr6k6qqqqqqqv+VQFJVtaqqKaqqULqqqoKgqv////+qqqqqAAAAAKiqq6pVq6qqqqqq1CkxJE4qLVHm/P//DwAAwOsAQeWwwQALAT8AQfSwwQALAxAOOQBBhLHBAAsBKQBBlLHBAAsBLQBBobHBAAsDCBM+AEGxscEACw1FLAA1MTMiAAAAAAk6AEHLscEACwQDABA7AEHbscEACwEUAEHnscEACwUcAAAAQABB+7HBAAsBSQBBirLBAAslIxEYNjcyMAckKwAdDCAAAC8AOTk5ABcXRxclGhkmAAVIAB4PTQBBuLLBAAsVCj0ABgAAHwAAAAAAAAAhABAbFycoAEHY", + "ssEACwcQNAIWRgg8AEHossEACwIQSgBB+LLBAAuAPEMqOAtEQRINAUJOFUtMBC4AtgBKAKYAogCfAJYAlACOAIYAgwBAAUIBRgFTAQwBCAKSAowChgKCA6QDkgMUBLIEqwAAAAAAAP///////z8A/z8AAAD///8BAAAA/P//BwFUVVVVVVVV9VpVFQAAIAAAAAAA//////8DAAAA////X/wBAADw////A////wP//wAAAAAAAP//VVVVVVVV/v8AAAAAAABFgLDn3x8AAAB7VVVVVVVVBWxVVVVVVVUAapCkqkpVVdJVVShFVVV9X1VVVVVVVVVVVasqVVVVVVVVAAAAAFVVVVUAAAAAVFVUVapUVVVVVVUr1s7bsdXSrhEADwAPAB8ADwAAAAAAAAAPPwAAAP///wMDAADQZN4/AFVVVVUFKAQAIAAAAP//AAAAPwCqAP8AAEDX/v/7DwAAAAD//z8AAAD//39/AAAAAP/3NwAAAAAAelUAAAAAAAC/IAAAAAAAAFVVVVVVVVWqhDgnPlA9D8AAAAAAneolwACAHFVVVZDmAAL//////+cA////AwAA8AAAAAAAAP/3AP8APwD/AP8sLAUjLCwsLCwsLCwsLAUALCwFLCwsLCwsLCwsLCwsLCwsKCwsLCwsERFCESsdGBcsLCwgJBUWDw0iLCwsCx4nLCwsLAkILSwsLCwsLCwsLCwsLCwlHEMsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsLCwsOSwsLCwsLCwsLCwsLDE/LCwsLCwsLCwsLCwsLCxBQCwUDhAELCwsLDIsLCwsLCwsLCwsLCwsNSwsHywsLCwsLCwsLCwsLDYuLCwsLCwsLCwsLCwsMywJLywqISwsLCwsLCwsLDQTAxIKMCwsLCwsLCwsLCw0JhEbLCwsLCwsLCwsLCwsOgEaNwwHGTgpOwYCPj08RMkSEABfAAAA9gAAABUAAADJEhAAXwAAAAEBAAAYAAAAAAAACAEIAwgG", + "EAkQDRASGBcYHRgkICsgMyA8IEYoUChbKGcwczCAMI44nDirOLs4zEDdQO9AAkkVSSlJPlFTUWlRgFGYWbBZyVnjYf1hGGI0alBqbWqLaqpyyXLpcgp7K3tNe3CDk4O3g9yDAowojE+Md5SflMiU8pwcBRwFHAUcBQUCBQECBQYCBQMBAgUBBQYCBQcIAQIFAwkABgIFAQkFAwECBQkHBgUGAgUECAgCCAECBQIEBAEEAAYCBQECAgAHAAMBAgUGAQADBQEFBgIFAwAFAQcFBwgBAgUBBQIFCAcICQAGAgUHBgIJAwkEBQMBAgUDCAEEBgkHAgYFBgIFAQkABwMECAYDAggBAgUJBQMGBwQDAQYEAAYCBQQHBggDBwEFCAIAAwECBQIDCAQBCAUHCQEAAQUGAgUBAQkCAAkCCAkFBQAHCAECBQUJBgAEBgQEBwcFAwkABgIFAgkIAAIDAgIDCAcGCQUDAQIFAQQJAAEBBgEBCQMIBAcGBQYCBQcEBQAFCAAFCQYJAgMIAggBAgUDBwIFAgkAAgkIBAYBCQEEAAYCBQEIBgIGBAUBBAkCAwAJBQcAAwECBQkDAQMCAgUHBAYBBQQHCAUBBQYCBQQGBQYGAQIIBwMABwcDCQIFBwgBAgUCAwIIAwAGBAMGBQMIBgkGAggJAAYCBQEBBgQBBQMCAQgCBgkDBAgBBAQFAwECBQUIAgAHBgYACQEDBAYHBAAHAgIGBQYCBQIJAQADCAMABAUGBwMDBwADBgEDAggBAgUBBAUFAQkBBQICCAMGBggFAQgABgYEAAYCBQcCBwUJBQcGAQQBCAMEAgUJAAMDAgADAQIFAwYDBwkHCAgABwAJAQcBAgkFAQYGAAEFBgIFAQgBCAkICQQAAwUEBQgFBgQHBQgDAAAHCAECBQkACQQJBAcAAQcHAgkCCAIDBwkBBQADCQAGAgUEBQQHBAcDBQAICAYEBgQBAQgJBQcFAQkFAwECBQICBwMHAwYHBQQEAwIDAgAFCQQHCAcFCQcG", + "BQYCBQEBAwYIBggDBwcCAQYBBgACCQcDCQMHCQgIAggBAgUFBggEAwQBCAgGAAgACAABBAgGCQYICQkEAQQABgIFAggEAgEHAAkEAwAEAAQAAAcEAwQIBAQJBwAHAAMBAgUBBAIBAAgFBAcBBQIAAgAAAwcBBwQCAgQIBQMFAQUGAgUHAQAFBAIHAwUHBgABAAABCAUIBwEBAgQCBgcFBwgBAgUDBQUCBwEDBgcICAAABQAACQIJAwUFBgIBAwMHCAkABgIFAQcHBgMFBggDCQQAAAIFAAQGBAYHBwgBAAYGCAkEBQMBAgUICAgBBwgEAQkHAAABAgUCAwIDAwgJAAUDAwQEBwIGBQYCBQQEBAAICQIACQgFAAAGAgYBBgEGCQQFAgYGBwIDBgMCCAECBQICAgAEBAYABAkCBQADAQMACAAIBAcCBgMDAwYBCAEGBAAGAgUBAQEAAgIDAAIEBgIFAQUGBQQABAIDBgMBBgYIAAkACAIAAwECBQUFBQEBAQUBAgMBAgUHCAIHAAIBAQgBBQgDBAAEBQQBAAEFBgIFAgcHBQUFBwUGAQUGAggJAQMFAQAFCQAHCQEHAAICBwAFAAcIAQIFAQMIBwcHCAcIAAcIAQQEBQYHBQUCCQUDCQUIBQEBAwUCBQMJAAYCBQYJAwgICQMJAAMJAAcCAggDBwcGBAcGCQcJAgUFBgcGAgYJBQMBAgUDBAYJBAQGCQUBCQUDBgEEAQgICAIDCAQICQYCBwgDCAEDBAcGBQYCBQEHAwQHAgMEBwUJBwYIAAcACQQEAQEJAgQECAEDCQEJAAYHAwgCCAECBQgGBwMGAQcDBwkICAQAAwUEBwIABQkGAgIEAAYJBQkFAwMGCQEEAAYCBQAAyRIQAF8AAABzAQAAEwAAAAUXEABZAAAArgAAABMAAABa1juS1lP07j87oQYpqj8R+GVlG2a0WJUHxSSkWcrHSna/PqJ/4a66SfYtDfC8eV1Tb86K35la6dxzeRAsLNj0lAXBtiug2JFp", + "6EuKmxsHeflGcaQ2yE62hOLebILiSJe3mI1NRHri4yWbFggjGxv9cn94sGqMbY73IA7l9fAw/k+fllyF7wiyNalRXjMtvb0jR7yzZiuL3oIT5jWAeCytdqxVMCD7FosxzK8hUMs7TJMXazzoudytPb8bKiS+St943YVLYuhT2Q2vojStbR3Xa6ozbz1x1IdoreVAjGRyhgaVAMuMjcmpwhgfUa/9DmhIusD97/A71PLeZiUbvRICbXSY/pV2pYRXS2D3MLZLAYiRPn471M6lLV44Nb2jnkHqNc5dSolCz7l1hoKsTAZSsuGges6ViYGTCZTR6+9Dcx8aSRlC++uh+Av5xebrFBCmYJufEvpmyvZOd3fgJhrU0DiCR5e4AP20IlWVmLAgiYJjsYxecyCesDVVXV9utFVivN0vNpCoxR2DqjT3iSHreyvVu0O0EvfkI9UBdezppS07ZVWqsGuabjYlIckzskf4ib7q1JwGwQqEbmm7wJ6ZdixuJQpESPENJcpD6nAGwMrbZFeGKs2WKFdeapIGBDi8Ej7tJ3WAvPLs9QQ3CAXGa5eN6HGSoOsuaDPGREqG96N+WDGHW0STHSHg+2rus3pMnq79aHIVuGQp2LoF6mBZ30UaPQPPGua9M44phyS5b6trMAZiwdCPVuD4edS206WWhryHuvHEs2wYd5iJpEiPPKirKSkutuCH3pT+q80aMyVJC7rZ3HGMFAsdf4vA8J9vG44oEFSOr9lN5F6u8OwHSqKxMhTpcdtQYZ322SzoyW4Fr5+sMSeJ0lwiOggcMb7KxprHF/5wqwb0qkgKY71tfXiBuZ09TdYIsdXazLssCU7r8JOCRvCFpY7FCGD1uyUhJu04I1hsp07y9gq48iqvqm8oByxuR9HhrrQNZq/1GspFeYTbpMyCTe2QyJ+N2VA8l5dlEs5/o6AotboH8Q/lDH39/pbBX8zIcmKpSe1THk/cvL78sXf/eg+7E5zo6CWxCTb3Pc+qn6zpVIxhkbF3HYwDdQ2DlccX", + "JGrvufWd1SVvRNLQ43r5Ha1EayhzBUt3xWqDYs7smzLsCkP5Z+NO1XZFJPsB6MI/p82T90GcIorUVu15AqLzDxHBeHVSQ2vWRFY0jEFFmKmqeGuJEwqDDNZrQe+RVr5T1VbGa5jMI4/LxhFrNuztqIrst4a+vyw5PxzrAqKzlKnW8zIU1/d7B0/jpYOK4LlTzLA/2cz12skiXI8krVjoaP+cjw9As9G+lZnZNmw3kaEfwrkJCBAjLfv/j0RHhbWKpzIoDArUq/n5/7MVmebibFE/Mo8MyRY7/H+QrR/QjeOSZ3/Zpz2uSvuf9JgnRLGcd0HfzxHNmR36xzF/MZXdg9UR10NWQEBS/Bx/7z59inIla2bqNShIZjvkXquOHK3P7gUAZUMy2kBKnTZWsmPYgmoHQD7UvpBoTiLidU8+h5GiBOimRHdaAuKqWlPjDak2ywWi0BUVcYOaVTEoXFHTAz6HykRbWg2RgNUemdkShMKGlP4KeVjotuCKZv+PF6VyqDm+TZduYuOYLUD/c13OjxLILSE9CvuOfxyIf2j6gJkLnbw0ZuZ8cp8jap8COaGATsTrwf8fHE6HrERHQ4fJIGK1ZrL/J6MiqdcVGRTp+6i6YgCf//FLtcmmrY+scZ2ptD1gwz93byJ8EJmzF87E0yFNOLQPVcsrm1R/oJ0B9khqYEahUyp+++CUT4QCwZltQvzLRHTaLjkZemMlQzHACFP7/lURkfqIn1i87pM98Monun6rVTV5tWO3NXV8JpbeWDQvi1XBS6I8JYOSG7C7Fm8B++2qsZ7Li+4jdyKc6tzKwXmpFV5GXxd1doqVoZLJHhnsic36CzZdEhTt+km3e2YfZ+yA+c6E9BZZqHkc5RpA54An4beC0liuNwnMMY8QiJCwuOyy0QfvmYULP/6yFaq03OanH4bJagBnzs6935rU4ZPgkadnvUJgAEGh1ovgJG1cLLvI4G1TeECRScyuGG6Ic/fp+lhIaJaQ9Vt/2p6JalB1pDmvLQFeenmZj4gD", + "lkJSyQaEbXiB9djXf7OqgzvTpnsI5cjW4TLPzV9g1WQKiJCaSh77Js1/oeA7XIV/BlWaoO7yXG/A38nYSrOmHkjqwEiqL/SLsFf8jh1g0CbaJPHalDvxV862XXkSPIJYCLfWCD3Fdu2BJLUXF8uibspkDEuMdlRoom2i3dx9ywn9fc9dL5SpAgsJCxVUXf5MfF1DNTv50+Gm5SaNVPqer20aSgHFe8SaEJ9wsOm4xhsJoZxBtpo1wNTGjBwkZ/hiS8kD0mMBw/hE/NeRdkCbHc9dQmPe4Hk2VvtNNpQQwuRC9RL8FVmYxCt64UO5lPKdk7IXe1tvPlpb7GzK85yXQpzP7iyZBacxcicIvTCEvVODgyp4/8ZQvU4xSuw85ewoZCQ1Vr/4pDbRXq4TRg+Umb424ZV3G4eEhfaZmBcTuT9uhFl7VeIo5SZ0wH7dV+fPieUv2uoaM0+YSDhv6paQIXbvXcjS8D9jvloGC6W8tKlTa3V6B+0P+23xx03O6+GUKMYSWUno073k9pzwYDONXNm7q9ctcWTsnTTELDmAsLPPqpZNeY29Z8VB9XdHoNygg1X8oNfw7GAbSfmqLOSJRHK1ncSGFvQ5Ypu31TddrNXOIsV1KBwxxzqCJcuFdNeLgms2kzJjfbxkcfee06iGlzEDApz/Xa7rvU21hghTqPz9gwKDf/XZZi2hYqjKZ9J7/STDY99y0GC8pD2p3oCDbR73WZ7LR0J46w2NUxZhpAjmdPCFvtlSVmZRcOhbec2LH5JsJy6QZ/bfMkZx2WuAtlPbo9gcugDzl7+Xzc+GoKQo0swOpOiA8H2v/cCDqMjNsgaAEs0iYWxdGz2xpNL6gV8IIFeAa3ljGjHG7qbDnLA7BXQ2MOPL/GC9d6qQ9MOcigYRRPzbvju5rBXVtPH0RC1IFVX7ku7F84stBREXmUocTS0V3Rt1tvDueEbVXL9dY6B4WtRi0uSsKheYCjTvNHzIFnGJ+4YOrHoOn4aAlaBNPa7mNV3UElcZ0kao4LoJ", + "ocxZYIN0idesn4ZY0pjpS8k/cDik0SsGzCNUd4P/kc/dJ0ajBmN7CL8sKVVkf7ZC1bEXTMg7Gsrud3NqPR/kk0qeHV+6yiA+9SqIYoaTjpzugnJ7tH5UjbI1KvtnOLJDqiNPmmGe6TEfw/T5gcbe1JTs4gD6BWR+8/k4PBE8iwTd041AvIPeXnA4R4sVC65F1EixUKsklnaMBhnu2o3ZVwmb3STWrTvJF6TP1Kj4h9blgArXpUzlvB2NAwrT9qlMHyHNTM+fXitlcITMh3TUH2dpACDDR3Y7P8bS39TIhHPgQQD02ewpCc93xxcK+6WQWFIAcRBo9MzCVbmdzHnPtO5mQI0UgnG/mdWT4h+sgTBVQEjYTPHGLwDLONsnF6J8alBaDqCtuDvA/QbS8ZzKHIXk8BEI2aZKML2IRi5E/WOmHW0WSo+QLj52FeycSp7+hzIETo5ZmrrN0xonRN3F/Sk/heHx70AowYjhMJVU93z0juZZ7ivRuXj1jD7dlJrOWBkw+HS7gufWMjCOFDrBAa8fPDZSauOhjD+8sZmI8cGaJ8vD5kTc5benFQ9g9Za5wPheOhCrKd6lEdsSuLK85/C29kjUFXRWD9aRF2bf6yGtZDRbSRsRlcklu86fa5M07L4A2Q2xyvs772nCh0a4QqfuQE9RXT36CmsEsylY5hJRKhGjpbQM3ObC4g8a94+rcrrqhefwR5Ogc9uT4PSzVg9pZWch7Vm4iFDSuBjy4CxTwz7BaWgwc1Vyg3NPl4z7EzrHGEJBHs/qTmRQI72v+pgI+Z6S0eWDpWJ9JGys2zm/SrdG90XfcqddzpbDS4mDt44yjLqLa08R9YF8tJ6rZGUyPy+pbgaiVXKim2GG1r3+/g57UwrIhXWHRQH9E4Y2X1/pLHQGvedS6ZZB/JinBDe3IzgRSCygp6P8UTt/0cUEpSyGFVr3xEjmPROF74L7Iufbc02YmvXaXw1YZqujuuvg0tBgPsGz0bcQ7j+WzKgmmQcF+Y0xH8bllOnPu/9S", + "cH9JRnfx/dObD/3xYdWfM6bv7Yvqtv7IglN8brrKx8CPa+kupWT+e2NoGwppvfmwc8ajes79PS0+IVGmYRacTghcpgyhvga4jWnlD/obw2IK889PSW5IJvHD3pP44vP6zO/Do9uJWrd2Omtc222YHOB1WkYplvhlFAmGM1KJviNYE/GXs7v2f1mLZ8CmK+4sLljtfaBqdO8Xt0A4SNuU3BxXtE6kwqjr3eRQRhoSuhPkbGFiTfOSZhUe5deglugXHcj5uiCwd2DNMu+GJF6RLhId3HQUzgq4gP+qqK21tbpWJBOSmYEN5mC/1RIZI+NpbO2X9v/hEI+cl8Wr7/WNwWP0Hvo/jcqzg/22lmtzsbJ8sab4jzC9oOS8ZHxG0N3e213Q9rN8rOQO9r4NLKKKa6k6QnrwzWudkrMuEbdKrcZTydKYbMGGRHdgetVkndi3qHsHv8dx6ItKfGwFX2KHckmtZNccRxEtXZvHxvY6qc+b2D0N5JjVeTSCeXi0idPDwk6NEB3/Sstg8UvLEDaEujlRWCpy387+uO0e/pRDpSiIZe60TpfCPieppj16lM4y6v4pYiI9c4e4KYhmzByBX1I/Wn01BgioJjQqgP9jofcmz7DcwgfKUjDBNGD/vMm18ALdk7OJ/Gd88UE4Pyz84qxD1HggrLvA7TYpg6ebnQ1MqoRLlEvVMamE82ORAsUR39RlXnmeCn3TZfC8NUP21RZK/7UXRk0upD8WlgHqmUVOjr/RzktQOY3Pm/uBZMDW4XEvhsJe5Ihww4J6on3wTFpOuydzdl1VJrqRjIVOlm/4ENX4B2o66q8otu8m4ruLNlUK94kEieXbsqOrsNrqLoTqzHSsRStvyU9Ga67Ikp2SEgDJiws7y7vjFwbaerdENxdAu27OCb2q3J2HkFnlFQUdEGoKQsy26qnCVPpXjy0jEkqCRqmfZGVU8+n4LbP5q5bcIpiTR71+KXAkd/nf91a8kyt+eFk27xnGdur7i1q2VTzbTutXA2ugdxTl+q7x", + "I2sLkiLm7cSFiJVZnrna7exFjjarX+mbU3X99wK0iBS06xgCy9sRgajS/LUD4aoZoSafwr1S1qJSB3yjRJnVX0nwRjNt50ulk4Qt5sp/hdstVgxApHBvjrjluJ+936ZSuWsPUM1My7ImH6cHrZfQp6dGE6QAIH4veHPIJMxegsgoDIxmANSOO1aQ+i1/9qL6Mg8vgACJcsprNHn5HrTLuf/SOqBAK0+8hoHXtyah/qi/h0nIEPbiNvSw5jK4JJ/J1/QtfcrZDUMxXaA/5u3Guw1yeRw9UJGUfXSIz1+p+CqRzpdjTKR1fM5IteHbaZu6GuE+vq+GyRsCmyLaUkTCaGGZzq1b6PuiwkGrkGfV8sO5P0KZcuL6pRkJa7pgxZca1GfJn4fN3A9gywXpuLa9IMnBu4fpAFQTOD5HI2ck7Wg7sqrpIwEpC+OGDHbANpQhZa8Kcrag+c6bqI+TcES5aT5bjQ7kCPjCwpJzuIyV5wQOsjASHQu2ubk7SPN3vZDCSG9eK/LGsSioShrw1ey08xoLNrauOB4yUt0gbAso4rDhjcNj2sYlX1OKlCMHWY0OrThafkicVzforHnsSK+wUdjG8J1agy1EIhiYJxvb3GWO+GxFMeT4axUPv/jwCIr/WBtky56OG8Xa0u42LYusPy8iPX5GcuJ3kYeqhPit1w+7aswd2A5b6rqU6lK7zIbptMKfEkfpmKXpOaUn6n+oJGKzR9eYIz8OZIiOseSf0q06oBkNf+yOiT4V+e7uo4OsJAQwaM9TGSuOWreq6oyk1y0FPELDqF+2MTFlVSWwzU15BssS9JI3Eb8+X1UXjoDQC+S+i9i74tZuDrcqnbGgxA6drq7OaluLCtJkdQTeyHVSRFpagkXyLo0GvpKFFfsSZ9Xw8OLW7j0YxLZ7c+2ca2CFltZNRlVMHnWkWtAoxIa4JjxM4Zeq32WSTXEEM/WoZjBLn9k91at/e9DG4j+ZKUD+jgOoRuWWX5qEeNuPvzPQvXIEUpjefPfApVbSc+9A", + "RG2PhWY+lq2amCd2Y6iVqEqkeRMA591ZwX6xU3wSu1JdDVgYwGBVr3HenWgb1+mmtBBuHvC4qg0Hq2IhcSaS6HDKBBOWs8rRyFW7aQ2wtiIN/cWXe2A9BTsrKsQQXORqUHy3fZq4jOMEW5p6irmOQrKtko5g83ccxvFAGe1nstMeWTeyOPBVozcukV/oAd+IZi/F3kZsa8bivLo7MWGLFaA9O0usIyN3G2ypin05rhoIDQpel+yrVSLHU+3cx9khSpCMNb3nlnV1XFQU6hyIVC7ad0HWUH7SknNpmSQkqum50NXRC+Xdh3fQw78trdRk6ERLxk5elbRKYtqXPOyEPhEL7zvxWr1h3frQvUsnpo7VzeqKrbHsupQ5Ra0esc/ySoGl7RjeZ/T8Q0sss86B185wh5TP6oAx/BRe919Coo0CTal5gyWhPjuaNfX30sowQ6ATWORuCQ3KAIPytYf9/FOIGG6dyotIfuCRt9F0nn40Vc9kol532p1YdiUGEsaegSoD/ko2lVHF7tOuh5b3BSL1g73dgzpSO3VEzRS+mkM1eXKWapLEJ4qSlQCabcGUghcPPAW3dbEs97qAAMnxOWPdEovGJFPue9p0UKAdlwReyusW/PbT6hoRkmQI5byF9bymHLv0iKVhlbZ9Sh7s5jJs0OPpMSsHXR2Sju6Sk9CfQ2IuMv86SbSkNjKqd7jDh9T6uf6+CVvhTcS+lJXmtKmJeWi+LkzZrLA693wdkBEK9ksBN50PD9hcCTXcJLSVjPOewYSEUxMOtEtCEy7hum+wBvKlZSjLiFBvCcy8jNRFLkS3hz/5/qokywv/669J1zkVpWmP977V7b3O/ubbHE2IWg5Ec7WXpbQ2QV9wiTEwlfiICmgx/M5hhBF3zKs+fLo2Kw3C/bxCeuXVlL/WTRtpBHaQMj21aWyvBb03hhCxwcJJmj+mI4RHG0esxadUHXIz3IDPDytlGeJYF7fRqaROQBNhw9M730+Nl24Sg+omMQisHFpkCtejcD0K16Ok", + "cD0K16NwPczMzMzMzMzMzczMzMzMzMwAAAAAAAAAgABBh+/BAAsBoABBl+/BAAsByABBp+/BAAsB+gBBtu/BAAsCQJwAQcbvwQALAlDDAEHW78EACwIk9ABB5e/BAAsDgJaYAEH178EACwMgvL4AQYXwwQALAyhr7gBBlfDBAAsD+QKVAEGk8MEACwRAt0O6AEG08MEACwQQpdToAEHE8MEACwQq54SRAEHT8MEACwWA9CDmtQBB4/DBAAsFoDGpX+MAQfPwwQALBQS/yRuOAEGD8cEACwXFLryisQBBkvHBAAsGQHY6awveAEGi8cEACwboiQQjx4oAQbLxwQALBmKsxet4rQBBwfHBAAsHgHoXtybX2ABB0fHBAAsHkKxuMniGhwBB4fHBAAsHtFcKPxZoqQBB8fHBAAubKaHtzM4bwtMAAAAAAAAAAKCEFEBhUVmEAAAAAAAAAADIpRmQuaVvpQAAAAAAAAAAOg8g9CePy84AAAAAAAAAAIQJlPh4OT+BAAAAAAAAAEDlC7k21wePoQAAAAAAAABQ3k5nBM3J8skAAAAAAAAApJYigUVAfG/8AAAAAAAAAE2dtXArqK3FnQAAAAAAACDwBeNMNhIZN8UAAAAAAAAobMYb4MNW34T2AAAAAAAAMsdcEWw6lgsTmgAAAAAAQH88sxUHyXvOl8AAAAAAABCfSyDbSLsawr3wAAAAAADUhh70iA21UJl2lgAAAACARBQTMetQ4qQ/FLwAAAAAoFXZF/0l5RqOTxnrAAAAAAirz12+N8/QuNHvkgAAAADlyqFarQUDBSfGq7cAAABAnj1K8RnHQ8awt5blAAAA0AXNnG1vXOp7zjJ+jwAAAKIjAILki/PkGoK/XbMAAICKLICi3W4wnqFiLzXgAAAgrTcgC9VF3gKlnT0hjAAANMwi9CZF1pVDDgWNKa8AAEF/K7Fwlkx71FFG8PPaAEARX3bdDDwPzSTzK3bYiADIavtpCoilUwDu77aTDqsAekV6BA3qjmiA6auk", + "ONLVgNjWmEWQpHJB8HHrZmOjhVBHhn8r2qZHUWxOpkA8DKck2WdftpCQmWUH4s9QS8/Qbc9B9+O09P+fRO2BEo+BgqQhiXoO8fi/x5VoItfyIaMNaisZUi33rzm7AuuMb+rLkER2n6b49JsIasMlcAvl/rTVU0fQNvICRSKaFyYnT5+QZZQsQmLXAdaqgJ3v8CLH9X65t9I6TUKL1eCEK63r+LLep2WHieDSd4UMMztMk5sv64if9FXMY9Wmz/9JH3jC+yVrx3FrvzyKkMN/HCcW83rvRTlORu+LVjraz3HY7Zestcvj8It1l+zI0EOOTum9F6O+HO3uUj0n+8TUMaJj7d1L7mOoqqdM+Bz7JF9FXpRq73Q+qcrojzbkOe621nW5RCsSjlP94rNEXcipZEzT5xa2lnGovNtgSjod6r4P5JDNMf5G6VWJvN2IpKSuEx21Qb69mGOrq2sUq81Nmlhk4tEt7X48lpbG7IqgcGC3fo2iPFTP5R0e/KityIw4Zd6wy0spQ1+lJTsS2fqvhv4V3b6e8xO3Du9Jq8f8LRS/LYo3Q3hsMmk1bpb5eznZLrmsBFSWB3/Dwkn799qHj3rn1wbpe8ledDPc/drotJms8Iajce09uyigabwRIyLA16yoDM5oDeoyCMQr1qsqsA3Y0pABw5CkPwr122WrGo4Ix4P64HnaxmcmeVI/VqGxyrikOFkYkbgBcFcmz6sJXv3mzYZvXrUmAkzteGELxlpesIC0BVsxWIFPVNY5jnfxddygIcexPa5hY2lMyHHVbZMTyek4Hs0ZOrwDXzrOSkl4WPsjx2VAoEirBHvkwM4tSxeddpw/KGQN62KaHXFC+R1dxJSDTzK90KU7AGUNk3dldPV5ZON+7ESPyiBf6Ltqv2iZyx5OzxOLmX7oduJqRe/Cv36mIcPY7T+eohSbxRars+8eEOrzTunPxeXsgDvuStCVEkpyWNHxobsfKGHKqV1Eu5fcjq5FbooqJnL5PBR1Feq9kzIa1wkt9VjnG6Ys", + "aU2SVpxfcCYmPFku4aLPd8PgtmyDdwywL4tvepmLw1X0mORHZJUPnPttC+w/N5q1mN+OrF69iUG9JEfnD8UA436Xsle2LOyR7O1Y4VP2wJtePd/t4zdntmcpL2z0mVghW4aLdO6CANLgeb2HccCu6fFnrhGqo4AGWdjs6Y1wGmTuAdqVlMwgSG8O6LJYhpD+NEGI3dx/FI0FCTHe7qc0PoJRqhXUn1nwRku9lurRwc3i5dQayQdwrBiebJ4yI5nArQ+FsN0ExmvP4gNF/2u/MJlTphwVhrdGg9uEFv9G73x/6M9jmmdlGGQS5m5fjBWuT/GBfsBgP49+y09Jd++amaNtop3wOA8zXr7jHFWrAYAMCcvFLAfTv/WtXGMqFgKgT8v99vfIxy9z2XN+2k0BxBGfnvqa3dz952coHVGhATXWRsa4ARVU/eGBsmWlCULCi9j3JkIaqXxaIh9fB0ZpWVfnmlhpsOmNeHUzN4mXwy8tocGugxxksdZSAIRrfbR7eAnymqQjvV2MZ8AyY85QTetFl+BGNpa6t0D4//sBpSBmF72Y2MM7qeVQtv96Qs6oP13svs60ihMf5aPfjOmAyUe6kzcBsTZsM2/GF/Aj4bvZqLiEQV1ERwALuB3sbNkqENPm5ZF0FVnADaaSE+THGupDkC/baK03mMiHdxjdeaHkVLT7EcOYRb66KZReVNjJHWrhetbz/tZtKfQduzQnnlLijAxmWF+m5JkY5OkBsUXnGrCPfy73z13AXl1kQh0XoSHccx/69EN1cHa6fklyrgSViahTHHlKSQZqad7bDtpF+quSaGMXnduHBAPWkpJQ1/jWtkI8XYTSqUXCxZtbkoZbhrKpRbqSI4oLMreC8jZo8qceFNdod6xsjv9kI69EAu/RJtkMQ5XXBzIfH3btamE1g7gH6Em95kR/56bTqMW5AqSmCWKcbCAWX6GQCBM3aAPND4x6w4eo2zZkWuVrIiEigImXLNpUSUnC/bDeBmupKqBsvbcQqpvb8j1dlsjF", + "UzXIx6zllJSCkm+M9Ls6t6hC+vkXH7o5I3fL13i1hHKpaZz7blMUBHYq/w3X4iXPE4TDukpoGYUT9f7RjFvvwhhl9Gldwl9mWLJ+AjiZ1Xkvv5hhetn7P3cv7wOG/0pY++6++tjP+g9V+6qEZ79dLrqq7jjPg/lTKrqVsqCX+ly0KpWDYfJ7dFqU3d+IPTl0YXW65PnumhFx+ZQX64xH0bkS6V24qgFWzTd67hK4zCK0q5E6swrBVeBirKoX5n8roRa2CWBNMWuYe1eUnd9fdkmc4wu4oP2FflrtfcLr++mtQY4Hc4S+E49YFByz5npkGdKxyI8lrtiyblnjX6CZvZ9G3rvzrtmOX8pv7jsEgNYj7IpUWA1IuXveJelKBSDMLKetaq4QmqcaVq+knQYo//cQ2QTalIBRoSsbhiIEef+aqodCCF3w0kT7kCgrRVe/QZWpU0p0rAcWOjXydRYtL5L60+hckZeJm4hCtwkufF2bfIQR2rr+NWGVaSWMOds0wpullZBpfoO5+kMu7wcSwrICz7v0A17kZ/mUffVES7mvYYH1eMK67uAbHdwyFp6nG7qhMhdzaSrZYmSTv5uFkaIoyv7czwN1j3t9eK8C5zXLsvw+1MNEUnPaXKutYbABv++dp2T6ahOICDoWGXocwq5rxdD9uEUYqooIW5+Yo3KaxvZFPSdXnlStipljP6aHIDyaS4Z49uJUrDZ/PM+PqSjLwN2nFrQbaleEnwvD89Py/fDVURyhokRtZUPnWXjEt56WJbOxpOVKZJ8UYXCWtWVGvO4f3g2fXT2HWXkM/CL/V+vqp1XRBrUMqdjLh911/xaT8ojVQiTxpwnOvulUU7/cty/rilNt7REMgS4kKijv0+X6pW2oyGgWjxCdVhp5daSPvIdEaX0BbvlVROxg15KNs6yplcPcgck3alUnOY33cOAXFHv0U+K7hWKVuEO4mkaMjuzMeHRtlZO7uqZUZkFYr7InAJfRyHo4amnQ6b9RLtueMcD8BXuZBuJBIvIX", + "8/yIAx/4vePsH0Ra0qru3S88q8Mmdq0c6CfV8YZVatU7C9Z0sNPYI+JxilZ0dWJlBceFSU6EZ1Yth/Zs0RK7vsY4p9thZQGs+Ci0x4XXaW74BtFSur4B1zYz4ZyzJgJFW6SCczQXYUYCwOyEYLBCFnJNo5ABXfnXAvAnpXhc05vOIMz0QbT3jQPsMc6WM8hCAin/cVKhdXEEZ35BPiC9aaF5n4bThOnGYgAP0U1oLMQJWMdoCOajeHvAUkVhgjc1DC75gorfzFaacKfLfLFCoce8m5G2C0B2YKaI/ttdk4n5q8I1pA7Qk/jPav5SNfjr91bzQ00SxLj2gwXeUyF781oWmEpwi3ozenLD1qjpWbDxG75cTC5ZwBhPdAwTZHAc7qLtc995b/DeYhHniz7G0dSFlKgrrEVWy92K4S7ONwZKp7mSNhfXKz6VbZm6wcWHHBHoNwTdzLaN+sigFJnb1LEKkaIiCkCSmJwdyFl/EkpeTbVLqwzQtr4DJTowH5fctaDiHdYPhGSuRC4kfnPeqXGkjdLlidL+7OpcrV0QVhSODbFHXyyHPqgldBh1lGuZ8VDdGXf3KE4SL9EvyTzj/5ZSim+qmtlwa72Ce/sL3L8856wLVQEQTcZsY1r6DtPvCyHYTqoBVOD3Rzx4XOnjdacUh3EKgTTs+qxllrPjXFPR2agNTaFBpzkYf3ygHDSoRRDTUKAJEhFI3h5N5JEgiSvqgzIERqsK7UqTYF22aGu25KQ/hRdWTagd+Ln040IG5B3Ojmadq2ASJTbzeM7pg67SgBlgQmt8K9fBMBdC5CRaB6Ef+BKGW/ZMsvycUh2uMEnJJ7aXZ/Iz4N48RKek2Xyb+7GjfQHvQJgWpYroBgguQZ1Ohu5glSgfjk6togiKeZHE4icqubrypvGiWMuK7Ne19duxdGdprxCuZRe/1vOmkZkp76jgoW3KrD/dbsywEPa/8yrTWAoJ/ReOlIr/3JTz77D1B+9MS/zd2Zy2Hwo9+JWO+WQVEK+9Sg9EpKdM", + "THa78Te+GtQabZ0TVY3RX99T6u3FbSGJYciELFX44ptrdJK0m+S09Tz9MndqttuChhG3ocIdIjOMvD8VBaSSI+jV5Eozpeo/r6sPLYOmOxaxBY8OQKfyh03LKfgjkMpbHceyEhBR7+kgPnT2LDS9suR43xZUJWskqU2RGpxAtu+Oq4uOVPfCtonQGiDD0KOrcpausSm1cySshKHo88SMVg882h50opAt1+XJcRj7F5aJZYiSiGV6fKYvfo3e+Z37636qt+r+mBuQu90xVniF+qYe1WWlPn8idCpV3jVrk1woM4VfJ4ePlYg61VYDRrhz8n+mN/Fo87oqiYoshFemEO8f0IUtQ7BpdSstm7L2Z2r1E4Jz/CkOYik7nEJf9AHF8piij3u0kbrzSYMTd3FCdi8/y3OaITapcBwk19QN01P7Dv4QAaqD04wj7Qal6GMUXcmeqkBKMgQ4NvRIzuJ8WbR7xtXQ3D4FxkOx2oEb3G+hGvgKBZSOhreU3SgxkenlpBCbJoMcGbTyfMpyffVjH87UwfCjYx9hLxz9z9zyPKcBSvLsjDxnOTtjvAHKF4YIQW6XE9iF4AMFvtWCvJ2nStFJvRhOp9hEhi1LoiuFUZ1FnOyeIdEO1uf43UU781KCq+GTA7VCyeWQu8oXCrDnYhbauENikzsfdWo9nQycofubEOfUOngKZxLFDOKHAUV9YWqQxSSLZoAr+yfa6UGW3PmEtPbtLYBg9vmxUWTSu1M4puFzaTmg+HN4XrJ+Y1U04weN6OEjZHtIC9tfXrxqAdxJsGLaLD2aGs6R93VrxQFTXNz7EHjMQKFBdropYxvhs7mJnQrLf8gE6akp9Dti2SAorETNvZ/6RWNUM/HKug8pMteVQK1HeRd8qcDWvtSpWX+GXUjMzKuO7UlwjO5JFDAfqHRa/79W8mhcjC9qXBn8JtIRMf9v7C6Dc7ddwtmPXViDq37/xVP9Mcgl9TLQ83QupFVef7eofD66b7I/xDASOs3rNV/l0hvOKIXPp3pe", + "S0SAs4Fbz2PRgHlmw1EZNl5VoB9iMsO8BeHXQDSmn8O1asin+v7zK0fZjVDBj4c0Y4X6Ubn+8PaYT7HS2LnUAF6TnNMzn1aav9FuB0/oCYE1uMPIAEfsgC+GCshiYkzhQqb0+sBYJ2G7J829fb3PzOnnmJx4l7gc1TiALN2sA0DkIb/DVr3mYwpH4HgUmARQXerudKxs4PzMWBjLDN8CUnpSlcjrQwwegDcP/c+Wg+YYp7q65lSPJWAF0/2DfCQg31DpaSAq8y64xkd+0s0WdIvSkUFU+lcdM9xMHUeBHFEuR7ZS6fit5D8T4OWYoWPl+djjpiN32d0PGFiP/0ReL5xnjkh26qfqCQ9XdXNlci1wcm92aWRlZCBjb21wYXJpc29uIGZ1bmN0aW9uIGRvZXMgbm90IGNvcnJlY3RseSBpbXBsZW1lbnQgYSB0b3RhbCBvcmRlcmwOEABfAAAAVgMAAAUAAAAAAAAA30UaPQPPGubB+8z+AAAAAMrGmscX/nCr3PvU/gAAAABP3Ly+/LF3//b73P4AAAAADNZrQe+RVr4R/OT+AAAAADz8f5CtH9CNLPzs/gAAAACDmlUxKFxR00b89P4AAAAAtcmmrY+scZ1h/Pz+AAAAAMuL7iN3Ipzqe/wE/wAAAABtU3hAkUnMrpb8DP8AAAAAV862XXkSPIKx/BT/AAAAADdW+002lBDCy/wc/wAAAABPmEg4b+qWkOb8JP8AAAAAxzqCJcuFdNcA/Sz/AAAAAPSXv5fNz4agG/00/wAAAADlrCoXmAo07zX9PP8AAAAAjrI1KvtnOLJQ/UT/AAAAADs/xtLf1MiEa/1M/wAAAAC6zdMaJ0TdxYX9VP8AAAAAlsklu86fa5Og/Vz/AAAAAISlYn0kbKzbuv1k/wAAAAD22l8NWGaro9X9bP8AAAAAJvHD3pP44vPv/XT/AAAAALiA/6qorbW1Cv58/wAAAACLSnxsBV9ihyX+hP8AAAAAUzDBNGD/vMk//oz/AAAAAFUmupGM", + "hU6WWv6U/wAAAAC9filwJHf533T+nP8AAAAAj7jluJ+936aP/qT/AAAAAJR9dIjPX6n4qf6s/wAAAADPm6iPk3BEucT+tP8AAAAAaxUPv/jwCIrf/rz/AAAAALYxMWVVJbDN+f7E/wAAAACsf3vQxuI/mRT/zP8AAAAABjsrKsQQXOQu/9T/AAAAANOSc2mZJCSqSf/c/wAAAAAOygCD8rWH/WP/5P8AAAAA6xoRkmQI5bx+/+z/AAAAAMyIUG8JzLyMmf/0/wAAAAAsZRniWBe30bP//P8AQZabwgALBUCczv8EAEGkm8IAC+4MEKXU6Oj/DAAAAAAAAABirMXreK0DABQAAAAAAIQJlPh4OT+BHgAcAAAAAACzFQfJe86XwDgAJAAAAAAAcFzqe84yfo9TACwAAAAAAGiA6aukONLVbQA0AAAAAABFIpoXJidPn4gAPAAAAAAAJ/vE1DGiY+2iAEQAAAAAAKityIw4Zd6wvQBMAAAAAADbZasajgjHg9gAVAAAAAAAmh1xQvkdXcTyAFwAAAAAAFjnG6YsaU2SDQFkAAAAAADqjXAaZO4B2icBbAAAAAAASnfvmpmjbaJCAXQAAAAAAIVrfbR7eAnyXAF8AAAAAAB3GN15oeRUtHcBhAAAAAAAwsWbW5KGW4aSAYwAAAAAAD1dlsjFUzXIrAGUAAAAAACzoJf6XLQqlccBnAAAAAAA41+gmb2fRt7hAaQAAAAAACWMOds0wpul/AGsAAAAAABcn5ijcprG9hYCtAAAAAAAzr7pVFO/3LcxArwAAAAAAOJBIvIX8/yITALEAAAAAACleFzTm84gzGYCzAAAAAAA31Mhe/NaFpiBAtQAAAAAADowH5fctaDimwLcAAAAAACWs+NcU9HZqLYC5AAAAAAAPESnpNl8m/vQAuwAAAAAABBEpKdMTHa76wL0AAAAAAAanEC2746riwYD/AAAAAAALIRXphDvH9AgAwQBAAAAACkxkenlpBCbOwMMAQAAAACdDJyh+5sQ", + "51UDFAEAAAAAKfQ7YtkgKKxwAxwBAAAAAIXPp3peS0SAiwMkAQAAAAAt3awDQOQhv6UDLAEAAAAAj/9EXi+cZ47AAzQBAAAAAEG4jJydFzPU2gM8AQAAAACpG+O0ktsZnvUDRAEAAAAA2Xffum6/lusPBEwBAAAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCA+IDDrDRAAYgAAAN4BAAAFAAAA6w0QAGIAAAB/AAAAFQAAAOsNEABiAAAANQIAABEAAADrDRAAYgAAADgCAAAJAAAA6w0QAGIAAABuAgAACQAAAOsNEABiAAAAqwAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLm1pbnVzID4gMAAAAOsNEABiAAAArAAAAAUAAABhc3NlcnRpb24gZmFpbGVkOiBkLnBsdXMgPiAw6w0QAGIAAACtAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudCArIGQucGx1cyA8ICgxIDw8IDYxKQAAAOsNEABiAAAAsQAAAAUAAADrDRAAYgAAAAwBAAARAAAA6w0QAGIAAABCAQAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX3N1YihkLm1pbnVzKS5pc19zb21lKCkA6w0QAGIAAACvAAAABQAAAGFzc2VydGlvbiBmYWlsZWQ6IGQubWFudC5jaGVja2VkX2FkZChkLnBsdXMpLmlzX3NvbWUoKQAA6w0QAGIAAACuAAAABQAAAHkTEABjAAAADQEAAAUAAAB5ExAAYwAAAA4BAAAFAAAAeRMQAGMAAAAPAQAABQAAAHkTEABjAAAAdAEAACQAAAB5ExAAYwAAAHkBAAAvAAAAeRMQAGMAAACGAQAAEgAAAHkTEABjAAAAaAEAAA0AAAB5ExAAYwAAAE4BAAAiAAAAeRMQAGMAAAARAQAABQAAAHkTEABjAAAAEAEAAAUAAAB5ExAAYwAAAHgAAAAFAAAAeRMQAGMAAAB5AAAABQAA", + "AHkTEABjAAAAegAAAAUAAAB5ExAAYwAAAMQAAAAJAAAAeRMQAGMAAAD9AAAADQAAAHkTEABjAAAABAEAABIAAAB5ExAAYwAAAHwAAAAFAAAAeRMQAGMAAAB7AAAABQAAAAEAAAAKAAAAZAAAAOgDAAAQJwAAoIYBAEBCDwCAlpgAAOH1BQDKmjvBb/KGIwAAAIHvrIVbQW0t7gQAAAEfar9k7Thu7Zen2vT5P+kDTxgAAT6VLgmZ3wP9OBUPL+R0I+z1z9MI3ATE2rDNvBl/M6YDJh/pTgIAAAF8Lphbh9O+cp/Z2IcvFRLGUN5rcG5Kzw/YldVucbImsGbGrSQ2FR1a00I8DlT/Y8BzVcwX7/ll8ii8VffH3IDc7W70zu/cX/dTBQDrDRAAYgAAAPECAAAmAAAA6w0QAGIAAADlAgAAJgAAAOsNEABiAAAAzgIAACYAAAAuLiAgICAAQZ6owgALsgHwPwAAAAAAACRAAAAAAAAAWUAAAAAAAECPQAAAAAAAiMNAAAAAAABq+EAAAAAAgIQuQQAAAADQEmNBAAAAAITXl0EAAAAAZc3NQQAAACBfoAJCAAAA6HZIN0IAAACilBptQgAAQOWcMKJCAACQHsS81kIAADQm9WsMQwCA4Dd5w0FDAKDYhVc0dkMAyE5nbcGrQwA9kWDkWOFDQIy1eB2vFURQ7+LW5BpLRJLVTQbP8IBEAEGYqsIAC58CMDEyMzQ1NjcwMTIzNDU2Nzg5QUJDREVGWRkQAEsAAACFCwAAJgAAAFkZEABLAAAAjgsAABoAAABSZWZDZWxsIGFscmVhZHkgbXV0YWJseSBib3Jyb3dlZFJlZkNlbGwgYWxyZWFkeSBib3Jyb3dlZEhhc2ggdGFibGUgY2FwYWNpdHkgb3ZlcmZsb3emDRAAJgAAACQAAAAoAAAAOBUQAE8AAACtAQAAGQAAAAAAAAAEAAAABAAAAEoAAADKHRAAZwAAAEsAAAApAAAAdG9vIG1hbnkgY2FwdHVyZSBncm91", + "cHMAAAAAAAgAAAAEAAAASwAAAGNhbGxlZCBgUmVzdWx0Ojp1bndyYXAoKWAgb24gYW4gYEVycmAgdmFsdWUAQcCswgALkSIBAAAATAAAAN0TEABpAAAAQAEAABUAAADdExAAaQAAAJwBAAAgAAAA3RMQAGkAAACuAQAANwAAAN0TEABpAAAAfQEAADQAAADdExAAaQAAANYAAAAXAAAA3RMQAGkAAACjAAAAOQAAAF8XEABsAAAAPgEAACYAAABfFxAAbAAAAEoBAAAXAAAAXxcQAGwAAADQAAAAJgAAAF8XEABsAAAAxAAAACYAAABwYXR0ZXJuIGhhcyB0b28gbXVjaCBuZXN0aW5nXxcQAGwAAABfAQAALAAAAGR1cGxpY2F0ZSBjYXB0dXJlIGdyb3VwIG5hbWVfFxAAbAAAAGMBAAAXAAAAPz0/IT88PT88IQAAXxcQAGwAAADtAAAAJQAAAGNvZGVwb2ludCwgYnV0IHBhcnNlciBpcyBkb25lAAAAXxcQAGwAAADYAAAAGQAAAF8XEABsAAAAMAEAABcAAABfFxAAbAAAAOIAAAAVAAAAXxcQAGwAAAD2AAAAGgAAAGFzc2VydGlvbiBmYWlsZWQ6IG0uMCA+PSBtLjHdExAAaQAAAOwBAAAJAAAA3RMQAGkAAADvAQAAPgAAAN0TEABpAAAA8AEAADAAAADdExAAaQAAAPsBAAAcAAAA3RMQAGkAAAD7AQAAIAAAAN0TEABpAAAA+wEAADoAAADdExAAaQAAAPsBAAA+AAAA8RkQAGoAAADxAQAAKQAAAGFzc2VydGlvbiBmYWlsZWQ6ICFzZWxmLnJhbmdlcy5pc19lbXB0eSgpAAAA8RkQAGoAAADhAQAACQAAAPEZEABqAAAAlwEAAC4AAADxGRAAagAAALMBAAAXAAAA8RkQAGoAAAC3AQAAKwAAAPEZEABqAAAAtwEAADYAAADxGRAAagAAAMsBAAAXAAAA8RkQAGoAAADRAQAALQAAAPEZEABq", + "AAAA0QEAAEIAAADxGRAAagAAAMMBAAAtAAAA8RkQAGoAAADDAQAAOgAAAPEZEABqAAAAyAEAACsAAADxGRAAagAAAMgBAAA2AAAA8RkQAGoAAACCAgAAIwAAAPEZEABqAAAAgwIAAC4AAADxGRAAagAAAIYCAAAYAAAA8RkQAGoAAACMAgAAGAAAAPEZEABqAAAAkgIAADIAAADxGRAAagAAAJkCAAAyAAAA8RkQAGoAAACgAgAAMgAAAPEZEABqAAAApwIAADIAAADxGRAAagAAAK4CAAAyAAAAYx0QAGYAAAC6AgAAGQAAAGNvbXBpbGVkIHJlZ2V4IGV4Y2VlZGVkIHNpemUgbGltaXQAAGMdEABmAAAAhAIAACkAAABjHRAAZgAAAIYCAAASAAAAYx0QAGYAAACHAgAAEgAAAGMdEABmAAAAmgIAAC0AAABjHRAAZgAAAJsCAAAYAAAAYx0QAGYAAACbAgAAKwAAAGMdEABmAAAArgIAACkAAABjHRAAZgAAAK8CAAAWAAAAYx0QAGYAAAAaAQAAEgAAAGMdEABmAAAAGwEAABIAAABjHRAAZgAAABwBAAASAAAAYx0QAGYAAAAhAQAAEgAAAGMdEABmAAAAIAIAACwAAABjHRAAZgAAACcCAAAoAAAAYx0QAGYAAAAtAgAAGgAAAGNhcHR1cmUgZ3JvdXAgc2xvdHMgZXhoYXVzdGVkAAAAYx0QAGYAAAAiAgAAFgAAAN0TEABpAAAA2QIAABgAAABzbG90IHRhYmxlIGxlbmd0aCBkb2Vzbid0IG92ZXJmbG93AADdExAAaQAAALkCAAAOAAAA3RMQAGkAAADQAgAAGAAAAN0TEABpAAAAfQMAACEAAADdExAAaQAAAGADAAAJAAAA3RMQAGkAAABnAwAAEwAAAN0TEABpAAAAagMAABQAAADdExAAaQAAAHEDAAAgAAAA3RMQAGkAAAByAwAANAAAAE0AAAAEAAAABAAAAE4AAABPAAAATwAAAPEZEABq", + "AAAAVQEAABgAAADxGRAAagAAADsBAAAYAAAAYx0QAGYAAABKAAAAFQAAAHVucmVjb2duaXplZCBpbmxpbmUgZmxhZ1sAAABmb3VuZCB1bmNsb3NlZCBjaGFyYWN0ZXIgY2xhc3NuZWdhdGVkIGNoYXJhY3RlciBjbGFzcyBoYXMgbm8gY2xvc2luZyBicmFja2V0bm9uLWVtcHR5IGNoYXJhY3RlciBjbGFzcyBoYXMgbm8gY2xvc2luZyBicmFja2V0IGFmdGVyIGRhc2hjaGFyYWN0ZXIgY2xhc3MgYmVnaW5zIHdpdGggbGl0ZXJhbCAnXScgYnV0IGhhcyBubyBjbG9zaW5nIGJyYWNrZXRuZXN0ZWQgY2hhcmFjdGVyIGNsYXNzZXMgYXJlIG5vdCBzdXBwb3J0ZWRjaGFyYWN0ZXIgY2xhc3MgaW50ZXJzZWN0aW9uIGlzIG5vdCBzdXBwb3J0ZWRjaGFyYWN0ZXIgY2xhc3MgZGlmZmVyZW5jZSBpcyBub3Qgc3VwcG9ydGVkY2hhcmFjdGVyIGNsYXNzIHN5bW1ldHJpYyBkaWZmZXJlbmNlIGlzIG5vdCBzdXBwb3J0ZWRfFxAAbAAAANQDAAAJAAAAXxcQAGwAAACJAwAAJQAAAGlubGluZSBmbGFncyBjYW5ub3QgZW5kIHdpdGggbmVnYXRpb24gZGlyZWN0aXZlaW5saW5lIGZsYWcgbmVnYXRpb24gY2Fubm90IGJlIHJlcGVhdGVkAABfFxAAbAAAAJ0DAAA7AAAAXxcQAGwAAACeAwAAFAAAAGV4cGVjdGVkICc6JyBvciAnKScgdG8gZW5kIGlubGluZSBmbGFncywgYnV0IGdvdCBlbmQgb2YgcGF0dGVybmR1cGxpY2F0ZSBpbmxpbmUgZmxhZyBpcyBub3QgYWxsb3dlZAAoAAAAP1A8PzwAAABfFxAAbAAAAEMDAAAZAAAAZW1wdHkgZmxhZyBkaXJlY3RpdmUgJyg/KScgaXMgbm90", + "IGFsbG93ZWQAAABfFxAAbAAAAEwDAAARAAAAZXhwZWN0ZWQgY2xvc2luZyAnKScsIGJ1dCBnb3QgZW5kIG9mIHBhdHRlcm5sb29rLWFyb3VuZCBpcyBub3Qgc3VwcG9ydGVkXxcQAGwAAAAyAwAACQAAAF8XEABsAAAAmgEAADAAAABfFxAAbAAAAKIBAAAlAAAAZm91bmQgb3BlbiBncm91cCB3aXRob3V0IGNsb3NpbmcgJyknZm91bmQgY2xvc2luZyAnKScgd2l0aG91dCBtYXRjaGluZyAnKCdVbmljb2RlIGNoYXJhY3RlciBjbGFzc2VzIGFyZSBub3Qgc3VwcG9ydGVkdW5yZWNvZ25pemVkIGVzY2FwZSBzZXF1ZW5jZWJhY2tyZWZlcmVuY2VzIGFyZSBub3Qgc3VwcG9ydGVkc2F3IHN0YXJ0IG9mIGVzY2FwZSBzZXF1ZW5jZSwgYnV0IHNhdyBlbmQgb2YgcGF0dGVybiBiZWZvcmUgaXQgZmluaXNoZWRnb3QgaW52YWxpZCBkZWNpbWFsIG51bWJlcmV4cGVjdGVkIGRlY2ltYWwgbnVtYmVyLCBidXQgZm91bmQgbm8gZGlnaXRzAAB9AAAAZ290IGludmFsaWQgaGV4YWRlY2ltYWwgbnVtYmVyIGluIGJyYWNlc2V4cGVjdGVkIGhleGFkZWNpbWFsIG51bWJlciBpbiBicmFjZXMsIGJ1dCBnb3Qgbm8gZGlnaXRzXxcQAGwAAACKAgAACQAAAGV4cGVjdGVkIGhleGFkZWNpbWFsIG51bWJlciwgYnV0IHNhdyBlbmQgb2YgcGF0dGVybiBiZWZvcmUgY2xvc2luZyBicmFjZWV4cGVjdGVkIGhleGFkZWNpbWFsIG51bWJlciBpbiBicmFjZXMsIGJ1dCBnb3Qgbm9uLWhleCBkaWdpdGdvdCBpbnZhbGlkIGZpeGVkIGxlbmd0aCBoZXhhZGVjaW1hbCBudW1iZXJleHBlY3RlZCBm", + "aXhlZCBsZW5ndGggaGV4YWRlY2ltYWwgbnVtYmVyLCBidXQgc2F3IGVuZCBvZiBwYXR0ZXJuIGZpcnN0ZXhwZWN0ZWQgZml4ZWQgbGVuZ3RoIGhleGFkZWNpbWFsIG51bWJlciwgYnV0IGdvdCBub24taGV4IGRpZ2l0ZGlnaXQAAABfFxAAbAAAAL8EAAAvAAAAc3BhY2UAAABfFxAAbAAAAMAEAAAvAAAAd29yZF8XEABsAAAAwQQAAC4AAABfFxAAbAAAAMIEAAAUAAAAaW52YWxpZCByYW5nZSBpbiBjaGFyYWN0ZXIgY2xhc3Nub24tZW1wdHkgY2hhcmFjdGVyIGNsYXNzIGhhcyBubyBjbG9zaW5nIGJyYWNrZXRpbnZhbGlkIGdyb3VwIG5hbWUAAD4AAABfFxAAbAAAAHIDAAAjAAAAZW1wdHkgY2FwdHVyZSBncm91cCBuYW1lcyBhcmUgbm90IGFsbG93ZWQAAABfFxAAbAAAAHADAAAJAAAAZXhwZWN0ZWQgZW5kIG9mIGNhcHR1cmUgZ3JvdXAgbmFtZSwgYnV0IGdvdCBlbmQgb2YgcGF0dGVybmV4cGVjdGVkIGNhcHR1cmUgZ3JvdXAgbmFtZSwgYnV0IGdvdCBlbmQgb2YgcGF0dGVybgAAAF8XEABsAAAAqAQAACMAAAA6XQAAXxcQAGwAAACIBAAACQAAAHsAAABjb3VudGVkIHJlcGV0aXRpb24gb3BlcmF0b3IgbXVzdCBiZSBhcHBsaWVkIHRvIGEgc3ViLWV4cHJlc3Npb25mb3VuZCB1bmNsb3NlZCBjb3VudGVkIHJlcGV0aXRpb24gb3BlcmF0b3Jmb3VuZCBjb3VudGVkIHJlcGV0aXRpb24gb3BlcmF0b3Igd2l0aCBhIGNvbW1hIHRoYXQgaXMgdW5jbG9zZWRmb3VuZCBjb3VudGVkIHJlcGV0aXRpb24gd2l0aCBtaW4gYW5kIG1heCB0aGF0IGlzIHVuY2xvc2VkZm91", + "bmQgY291bnRlZCByZXBldGl0aW9uIHdpdGggYSBtaW4gYmlnZ2VyIHRoYW4gaXRzIG1heGV4cGVjdGVkIGNsb3NpbmcgYnJhY2UgZm9yIGNvdW50ZWQgcmVwZXRpdGlvbiwgYnV0IGdvdCBzb21ldGhpbmcgZWxzZWZvdW5kIGluY29tcGxldGUgYW5kIHVuY2xvc2VkIGNvdW50ZWQgcmVwZXRpdGlvbiBvcGVyYXRvcmV4cGVjdGVkIG9wZW5pbmcgYnJhY2UAAABfFxAAbAAAAPcCAAAJAAAAdW5jb3VudGVkIHJlcGV0aXRpb24gb3BlcmF0b3IgbXVzdCBiZSBhcHBsaWVkIHRvIGEgc3ViLWV4cHJlc3Npb24AAABfFxAAbAAAANICAAAUAAAAZm91bmQgc3RhcnQgb2Ygc3BlY2lhbCB3b3JkIGJvdW5kYXJ5IG9yIHJlcGV0aXRpb24gd2l0aG91dCBhbiBlbmRzdGFydHN0YXJ0LWhhbGZlbmQtaGFsZnNwZWNpYWwgd29yZCBib3VuZGFyeSBhc3NlcnRpb24gaXMgdW5yZWNvZ25pemVkc3BlY2lhbCB3b3JkIGJvdW5kYXJ5IGFzc2VydGlvbiBpcyB1bmNsb3NlZCBvciBoYXMgYW4gaW52YWxpZCBjaGFyYWN0ZXIAAF8XEABsAAAAIAIAAAkAAABleHBlY3RlZCBoZXhhZGVjaW1hbCBudW1iZXIsIGJ1dCBzYXcgZW5kIG9mIHBhdHRlcm4gZmlyc3QAAABfFxAAbAAAAFMCAAAUAEHczsIACyUBAAAAUAAAAIccEABJAAAA5QgAACkAAADxGRAAagAAAP4CAAA4AEGE0MIAC4ABAQEBAQEBAQEBAQEBAQEBAQkJCQkJCQkJCQkJCQkJCQkHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwcHBwgIAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICCgMDAwMDAwMDAwMDAwQDAwsG", + "BgYFCAgICAgICAgICAgAQZDRwgALIgwAGCQ8YFQAAAAwSAAMAAAAAAAMAAwAAAAYAAAAAAAYABgAQbvRwgALDxgAAAAAABgAAAAAAAAAGABB09HCAAsTJAAkAAAAJAAAAAAAJAAkAAAAJABB8NHCAAsNyh0QAGcAAAB7AAAAGgBBsNLCAAtLAQEBAQEBAQEBAQAAAAAAAAABAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQAAAAABAAEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAEGA1MIAC8MHVg0QAE8AAADtAwAANAAAAFYNEABPAAAA8QMAADMAAABWDRAATwAAAPwDAAA3AAAAVg0QAE8AAAD4AwAAOAAAAGFsbnVtYWxwaGFhc2NpaWJsYW5rY250cmxncmFwaGxvd2VycHJpbnRwdW5jdHVwcGVyeGRpZ2l0dW5yZWNvZ25pemVkIFBPU0lYIGNoYXJhY3RlciBjbGFzczA5QUZhZjA5QVpfX2F6QVoJCQoKCwsMDA0NICAhLzpAW2B7fiB+YXohfjA5AB9/fwkJICAAf0FaYXowOUFaYXpjaGFyYWN0ZXIgY2xhc3MgcmFuZ2VzIG11c3Qgc3RhcnQgYW5kIGVuZCB3aXRoIGEgc2luZ2xlIGNoYXJhY3RlcmludmFsaWQgZXNjYXBlIHNlcXVlbmNlIGluIGNoYXJhY3RlciBjbGFzc1RyeUZyb21DaGFyRXJyb3Jtc2eaFBAAZwAAAGoAAAAjAAAA3RMQAGkAAADTAQAAGAAAAN0TEABpAAAA0wEAABwAAADdExAAaQAAANMBAAA2AAAA3RMQAGkAAADTAQAAOgAAAExheW91dEVycm9yKCkAAAAAAAAABAAAAAQAAABRAAAAQQAAAAwAAAAEAAAAUgAAAFMAAABUAAAAAAAAAAgAAAAEAAAAVQAAAFYAAABXAAAAWAAAAFkAAAAQAAAABAAAAFoAAABbAAAAXAAAAF0AAABc9ulf3AL2ufHBcGzy", + "YcEkOzdNSoIQRQnDpWHRPyA6j2Fzc2VydGlvbiBmYWlsZWQ6IHBzaXplID49IHNpemUgKyBtaW5fb3ZlcmhlYWQAAFwcEAAqAAAA6QQAAAkAAABhc3NlcnRpb24gZmFpbGVkOiBwc2l6ZSA8PSBzaXplICsgbWF4X292ZXJoZWFkAABcHBAAKgAAAO8EAAANAAAAXBwQACoAAABNBQAAHgAAAHJ3bG9jayBvdmVyZmxvd2VkIHJlYWQgbG9ja3MNERAAXQAAABgAAAAsAAAAAAAAAAgAAAAEAAAAXgAAAEFjY2Vzc0Vycm9yAEEAAAAMAAAABAAAAF8AAADUFRAAaQAAAKIDAAAgAAAA1BUQAGkAAACjAwAAIwAAANQVEABpAAAAqgMAAB8AAADvFxAAWwAAAPAAAABNAAAAYXNzZXJ0aW9uIGZhaWxlZDogZWRnZS5oZWlnaHQgPT0gc2VsZi5ub2RlLmhlaWdodCAtIDEAAADvFxAAWwAAAAMEAAAJAAAA7xcQAFsAAAATBQAAJAAAAP//////////uK0QAEHQ28IAC/lTY2FwYWNpdHkgb3ZlcmZsb3cAAAAbGxAATAAAADIQAAANAAAAghYQAF8AAABYAgAAMAAAACkTEABPAAAA8wUAABQAAACXERAASAAAAMgAAAAWAAAAYXR0ZW1wdCB0byBqb2luIGludG8gY29sbGVjdGlvbiB3aXRoIGxlbiA+IHVzaXplOjpNQVgAAACXERAASAAAAK8AAAAKAAAAYXNzZXJ0aW9uIGZhaWxlZDogc3JjLmxlbigpID09IGRzdC5sZW4oKe8XEABbAAAAVAcAAAUAAADMDhAAXwAAAE0AAAAfAAAAzA4QAF8AAABHAAAAFwAAAHwaEABNAAAA8QMAABwAAAB8GhAATQAAAPIDAAAcAAAAfBoQAE0AAAD2AwAAIAAAAHwaEABNAAAA9gMAACsAAABpbnZhbGlkIFx1IGVzY2FwZWludmFsaWQgbnVtYmVyaW52YWxp", + "ZCBVVEYtOCEhc2VxISFtYXAAAEsYEAAaAAAAswAAAC4AAAB0YWc6eWFtbC5vcmcsMjAwMjoAANIMEABgAAAA0QEAAC4AAAByZWN1cnNpb24gbGltaXQgZXhjZWVkZWQwWAAAXBoQAB8AAAB2AgAAGgAAACEhaW50ISFmbG9hdA9mYWlsZWQgdG8gbG9hZCDABzogb3BlbiDIAAAbOiBubyBzdWNoIGZpbGUgb3IgZGlyZWN0b3J5ADw8ISFzdHJzZXFtYXBzY2FsYXJhbGlhc3RhZ2dlZGRvdWJsZXNpbmdsZWxpdGVyYWxmb2xkZWRmbG93PHVua25vd24+ISFudWxsbm93IGlzIG5vdCBhdmFpbGFibGU6IHRoZSBob3N0IGRpZCBub3Qgc3VwcGx5IGEgY2xvY2tudWxsIhAQACEAAABmAAAAUwAAAMwXEAAiAAAAQwAAADEAAAAyMDA2MDYwMTFKYW5KYW51YXJ5MDIyXzIwMDJNb25Nb25kYXkxNTAzMzA0NDA1NVBNcG1NU1RaMDc6MDBaMDcwMFowNy0wNzowMC0wNzAwLTA3MDnMFxAAIgAAAF0BAAAhAAAAZXhwcmVzc2lvbiBuZXN0aW5nIHRvbyBkZWVwKClbXXt9LlsATg4QAB0AAABBAAAAGAAAAE4OEAAdAAAARgAAAA4AAAAyMDA2LTAxLTAyVDE1OjA0OjA1WjA3OjAwAAAATg4QAB0AAABSAAAAPAAAAGlmdGhlbmVsaWZiYWQgZXhwcmVzc2lvbiwgYHRoZW5gIG11c3QgZm9sbG93IGBpZmAgb3IgYGVsaWZgZW5kYmFkIGV4cHJlc3Npb24sIGdvdCBgZW5kYCB3aXRob3V0IG1hdGNoaW5nIGBpZmBiYWQgZXhwcmVzc2lvbiwgY291bGQgbm90IGZpbmQgbWF0Y2hpbmcgYGVuZGBlbHNlJHlxRG9jU2VwYXJhdG9yJCEhYm9vbGZhbHNlT1JBTkRSRURVQ0VJRl9USEVOSUZfRUxT", + "RUJMT0NLVU5JT05QSVBFQVNTSUdOQUREX0FTU0lHTlNVQlRSQUNUX0FTU0lHTkFTU0lHTl9BVFRSSUJVVEVTQVNTSUdOX1NUWUxFQVNTSUdOX1ZBUklBQkxFQVNTSUdOX1RBR0FTU0lHTl9DT01NRU5UQVNTSUdOX0FOQ0hPUkFTU0lHTl9BTElBU01VTFRJUExZTVVMVElQTFlfQVNTSUdORElWSURFTU9EVUxPQUREU1VCVFJBQ1RBTFRFUk5BVElWRUVRVUFMU05PVF9FUVVBTFNDT01QQVJFTUlOTUFYQ1JFQVRFX01BUFNIT1JUX1BJUEVMRU5HVEhMSU5FRVhQQ09MTEVDVE1BUEZJTFRFUkVSUk9SUElDS09NSVRFVkFMTUFQX1ZBTFVFU0ZPUk1BVF9EQVRFX1RJTUVXSVRIX0RBVEVfVElNRV9GT1JNQVROT1dUSU1FWk9ORUZST01fVU5JWFRPX1VOSVhFTkNPREVERUNPREVBTllBTExDT05UQUlOU0FOWV9DT05ESVRJT05BTExfQ09ORElUSU9OVE9fRU5UUklFU0ZST01fRU5UUklFU1dJVEhfRU5UUklFU1dJVEhTUExJVF9ET0NHRVRfVkFSSUFCTEVHRVRfU1RZTEVHRVRfVEFHR0VUX0tJTkRHRVRfS0VZSVNfS0VZR0VUX1BBUkVOVEdFVF9QQVJFTlRTR0VUX0NPTU1FTlRHRVRfQU5DSE9SR0VUX0FMSUFTR0VUX0RPQ1VNRU5UX0lOREVYR0VUX0ZJTEVOQU1FR0VUX0ZJTEVfSU5ERVhHRVRfUEFUSFNFVF9QQVRIREVMX1BBVEhTRVhQTE9ERVNPUlRfQllGSVJTVFJFVkVSU0VTT1JUU0hVRkZMRVNPUlRfS0VZU0pPSU5TVUJTVFJNQVRDSENBUFRVUkVURVNUU1BMSVRDSEFOR0VfQ0FTRVRSSU1UT19TVFJJTkdTVFJJTkdfSU5UTE9BRExPQURfU1RSSU5HU1lTVEVNS0VZ", + "U0NPTExFQ1RfT0JKRUNUVFJBVkVSU0VfUEFUSFRSQVZFUlNFX0FSUkFZU0VMRlZBTFVFUkVGRU5WTk9UVE9fTlVNQkVSRU1QVFlFTlZTVUJTVFJFQ1VSU0lWRV9ERVNDRU5UU0VMRUNUSEFTVU5JUVVFVU5JUVVFX0JZR1JPVVBfQllGTEFUVEVOX0JZREVMRVRFUElWT1RtaWQgPiBsZW4AAA4ZEABKAAAADAIAADIAAABhc3NlcnRpb24gZmFpbGVkOiBzZWxmLmlzX2NoYXJfYm91bmRhcnkobmV3X2xlbiniFhAAIgAAAB0BAAAYAAAAqhgQACEAAADEAAAAMwAAAGludmFsaWQgY2hhcmFjdGVyIGFmdGVyIGFycmF5IGVsZW1lbnR1bmV4cGVjdGVkIGVuZCBvZiBKU09OIGlucHV0dHJ1ZWludmFsaWQgY2hhcmFjdGVyIGxvb2tpbmcgZm9yIGJlZ2lubmluZyBvZiB2YWx1ZQAAAKoYEAAhAAAAdQAAADMAAAA6aW52YWxpZCBjaGFyYWN0ZXIgYWZ0ZXIgb2JqZWN0IHZhbHVlaW52YWxpZCBjaGFyYWN0ZXIgYWZ0ZXIgb2JqZWN0IGtleWludmFsaWQgY2hhcmFjdGVyIGxvb2tpbmcgZm9yIG9iamVjdCBrZXkAqhgQACEAAACjAAAALgAAAFx1aW52YWxpZCBlc2NhcGWqGBAAIQAAALYAAAA/AAAAqhgQACEAAABeAAAAFgAAAGludmFsaWQgbGl0ZXJhbADMGBAAIQAAAGQBAAA3AAAAzBgQACEAAABZAQAANwAAAIgYEAAhAAAA3QAAACsAAACIGBAAIQAAAOEAAAArAAAASxgQABoAAAC4AAAAHwAAAEsYEAAaAAAAvAAAAB4AAABLGBAAGgAAAHwBAAAXAAAASxgQABoAAAB8AQAAPgAAAEsYEAAaAAAAgAEAAC4AAABLGBAAGgAAAIABAAAXAAAASxgQABoAAACCAQAAEwAAAEsYEAAa", + "AAAAgwEAACkAAABLGBAAGgAAAIMBAAATAAAASxgQABoAAACEAQAAIQAAAEsYEAAaAAAAhgEAACoAAABLGBAAGgAAAIYBAAATAAAASxgQABoAAAAlAQAAFgAAAEsYEAAaAAAAlQAAACwAAABLGBAAGgAAAJgAAAATAAAASxgQABoAAACdAAAALAAAAEsYEAAaAAAAoAAAABQAAABLGBAAGgAAALgBAAAfAAAASxgQABoAAAClAAAALAAAAEsYEAAaAAAAqAAAABMAAABLGBAAGgAAAO8AAAAfAAAASxgQABoAAADqAAAAHAAAAEsYEAAaAAAAVgEAACcAAABLGBAAGgAAAIsBAAAkAAAASxgQABoAAACMAQAAIwAAACEhAABLGBAAGgAAAKoBAAAfAAAASxgQABoAAACwAQAAJQAAAEsYEAAaAAAAsQEAACEAAABLGBAAGgAAAGwBAAAiAAAASxgQABoAAACMAAAAFAAAAEsYEAAaAAAAOwEAACIAAABLGBAAGgAAADwBAAAiAAAASxgQABoAAABDAQAAJQAAAEsYEAAaAAAArQAAAB8AAABLGBAAGgAAAJAAAAAYAAAASxgQABoAAADIAAAAHwAAAEsYEAAaAAAAEgEAAB8AAAB3aGlsZSBwYXJzaW5nIG5vZGUsIGZvdW5kIHVua25vd24gYW5jaG9yaW50ZXJuYWwgZXJyb3I6IGVudGVyZWQgdW5yZWFjaGFibGUgY29kZVQSEAAoAAAA8gMAABEAAABUEhAAKAAAAPsDAAAdAAAAVBIQACgAAAD/AwAAFQAAAFQSEAAoAAAACQQAAB0AAABUEhAAKAAAAA0EAAAVAAAAVBIQACgAAAAeBAAAFQAAAHdoaWxlIHBhcnNpbmcgYSBub2RlLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgbm9kZSBjb250ZW50VBIQACgAAAAXAgAAIAAAAGZldGNoX3Rva2VuIG5lZWRzIHRvIGJlIHByZWNlZGVkIGJ5IHBlZWtf", + "dG9rZW4AAFQSEAAoAAAALgIAAA4AAAAhdGhlIGhhbmRsZSB3YXNuJ3QgZGVjbGFyZWRtaXNzaW5nIGV4cGxpY2l0IGRvY3VtZW50IGVuZCBtYXJrZXIgYmVmb3JlIGRpcmVjdGl2ZWRpZCBub3QgZmluZCBleHBlY3RlZCA8c3RyZWFtLXN0YXJ0PlQSEAAoAAAA/QIAABsAAABUEhAAKAAAADYDAAAcAAAAVBIQACgAAAA8AwAAQAAAAFQSEAAoAAAAPQMAADkAAABUEhAAKAAAADgDAABAAAAAVBIQACgAAAA5AwAAOQAAAHVuZXhwZWN0ZWQgZW9mAABUEhAAKAAAAIIBAAA0AAAAVBIQACgAAACEAQAAMQAAAFQSEAAoAAAAmwEAACIAAAB3aGlsZSBwYXJzaW5nIGEgZmxvdyBtYXBwaW5nLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgJywnIG9yICd9J3doaWxlIHBhcnNpbmcgYSBibG9jayBtYXBwaW5nLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQga2V5AABUEhAAKAAAALABAAAhAAAAVBIQACgAAACyAQAAJQAAAHdoaWxlIHBhcnNpbmcgYSBmbG93IHNlcXVlbmNlLCBleHBlY3RlZCAnLCcgb3IgJ10nd2hpbGUgcGFyc2luZyBhIGJsb2NrIGNvbGxlY3Rpb24sIGRpZCBub3QgZmluZCBleHBlY3RlZCAnLScgaW5kaWNhdG9yZGlkIG5vdCBmaW5kIGV4cGVjdGVkIDxkb2N1bWVudCBzdGFydD5kdXBsaWNhdGUgdmVyc2lvbiBkaXJlY3RpdmV0aGUgVEFHIGRpcmVjdGl2ZSBtdXN0IG9ubHkgYmUgZ2l2ZW4gYXQgbW9zdCBvbmNlIHBlciBoYW5kbGUgaW4gdGhlIHNhbWUgZG9jdW1lbnQAAABUEhAAKAAAADcCAAAoAAAAY2Fubm90IHJlY3Vyc2l2ZWx5IGFjcXVpcmUgbXV0ZXiw", + "EBAAXAAAABYAAAAJAAAAZGlkIG5vdCBmaW5kIGV4cGVjdGVkIG5leHQgdG9rZW59EhAAKQAAADYLAAAqAAAAfRIQACkAAAA7CwAAOwAAACc6JyBtdXN0IGJlIGZvbGxvd2VkIGJ5IGEgdmFsaWQgWUFNTCB3aGl0ZXNwYWNlbWFwcGluZyB2YWx1ZXMgYXJlIG5vdCBhbGxvd2VkIGluIHRoaXMgY29udGV4dAAAAH0SEAApAAAAZAsAACkAAABpbGxlZ2FsIHBsYWNlbWVudCBvZiAnOicgaW5kaWNhdG9yd2hpbGUgc2Nhbm5pbmcgYW4gYW5jaG9yIG9yIGFsaWFzLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgYWxwaGFiZXRpYyBvciBudW1lcmljIGNoYXJhY3RlcmFzc2VydGlvbiBmYWlsZWQ6IHBvcyA8PSBvbGRfbGVuAAB9EhAAKQAAAM8CAAAJAAAAfRIQACkAAABQBAAAGAAAAFlBTUxUQUd3aGlsZSBzY2FubmluZyBhIGRpcmVjdGl2ZSwgZGlkIG5vdCBmaW5kIGV4cGVjdGVkIGNvbW1lbnQgb3IgbGluZSBicmVhawAAfRIQACkAAAD9CwAAKAAAAHdoaWxlIHBhcnNpbmcgYSB0YWcgZGlyZWN0aXZlLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgJyEnd2hpbGUgc2Nhbm5pbmcgYSB0YWcsIGRpZCBub3QgZmluZCBleHBlY3RlZCAnISdpbnZhbGlkIGdsb2JhbCB0YWcgY2hhcmFjdGVyJzonIG1heSBub3QgcHJlY2VkZSBhbnkgb2YgYFt7YCBpbiBmbG93IG1hcHBpbmdpbnZhbGlkIGNvbnRlbnQgYWZ0ZXIgZG9jdW1lbnQgZW5kIG1hcmtlcmludmFsaWQgaW5kZW50YXRpb25mb3VuZCB1bnByaW50YWJsZSBjaGFyYWN0ZXJzaW1wbGUga2V5IGV4cGVjdGVkd2hpbGUgc2Nh", + "bm5pbmcgYSBxdW90ZWQgc2NhbGFyLCBmb3VuZCB1bmV4cGVjdGVkIGRvY3VtZW50IGluZGljYXRvcmludmFsaWQgdHJhaWxpbmcgY29udGVudCBhZnRlciBkb3VibGUtcXVvdGVkIHNjYWxhcnRhYiBjYW5ub3QgYmUgdXNlZCBhcyBpbmRlbnRhdGlvbmludmFsaWQgaW5kZW50YXRpb24gaW4gcXVvdGVkIHNjYWxhcndoaWxlIHNjYW5uaW5nIGEgcXVvdGVkIHNjYWxhciwgZm91bmQgdW5leHBlY3RlZCBlbmQgb2Ygc3RyZWFtd2hpbGUgcGFyc2luZyBhIHRhZywgZm91bmQgYW4gaW5jb3JyZWN0IGxlYWRpbmcgVVRGLTggYnl0ZXdoaWxlIHBhcnNpbmcgYSB0YWcsIGZvdW5kIGFuIGludmFsaWQgVVRGLTggY29kZXBvaW50d2hpbGUgcGFyc2luZyBhIHRhZywgZm91bmQgYW4gaW5jb3JyZWN0IHRyYWlsaW5nIFVURi04IGJ5dGV3aGlsZSBwYXJzaW5nIGEgdGFnLCBmb3VuZCBhbiBpbnZhbGlkIGVzY2FwZSBzZXF1ZW5jZWJsb2NrIHNlcXVlbmNlIGVudHJpZXMgYXJlIG5vdCBhbGxvd2VkIGluIHRoaXMgY29udGV4dGludmFsaWQgaW5kZW50YXRpb24gZm9yIGFuY2hvcictJyBtdXN0IGJlIGZvbGxvd2VkIGJ5IGEgdmFsaWQgWUFNTCB3aGl0ZXNwYWNlIi0iIGlzIG9ubHkgdmFsaWQgaW5zaWRlIGEgYmxvY2sAfRIQACkAAAAJDAAAMAAAAHdoaWxlIHNjYW5uaW5nIGEgYmxvY2sgc2NhbGFyLCBmb3VuZCBhbiBpbmRlbnRhdGlvbiBpbmRpY2F0b3IgZXF1YWwgdG8gMHdoaWxlIHNjYW5uaW5nIGEgYmxvY2sgc2NhbGFyLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQg", + "Y29tbWVudCBvciBsaW5lIGJyZWFrYSBibG9jayBzY2FsYXIgY29udGVudCBjYW5ub3Qgc3RhcnQgd2l0aCBhIHRhYndyb25nbHkgaW5kZW50ZWQgbGluZSBpbiBibG9jayBzY2FsYXJwbGFpbiBzY2FsYXIgY2Fubm90IHN0YXJ0IHdpdGggJy0nIGZvbGxvd2VkIGJ5ICxbXXt9dW5leHBlY3RlZCBlbmQgb2YgcGxhaW4gc2NhbGFyd2hpbGUgc2Nhbm5pbmcgYSBwbGFpbiBzY2FsYXIsIGZvdW5kIGEgdGFiaW52YWxpZCBpbmRlbnRhdGlvbiBpbiBmbG93IGNvbnN0cnVjdHdoaWxlIHNjYW5uaW5nIGEgdmVyYmF0aW0gdGFnLCBkaWQgbm90IGZpbmQgdGhlIGV4cGVjdGVkICc+J3NpbXBsZSBrZXkgZXhwZWN0ICc6J3RhYnMgZGlzYWxsb3dlZCB3aXRoaW4gdGhpcyBjb250ZXh0IChibG9jayBpbmRlbnRhdGlvbiljb21tZW50IGludGVyY2VwdGluZyB0aGUgbXVsdGlsaW5lIHRleHQAAAB9EhAAKQAAAHcHAAAkAAAAd2hpbGUgc2Nhbm5pbmcgYSBkaXJlY3RpdmUsIGZvdW5kIHVuZXhwZWN0ZWQgbm9uLWFscGhhYmV0aWNhbCBjaGFyYWN0ZXJ3aGlsZSBzY2FubmluZyBhIGRpcmVjdGl2ZSwgY291bGQgbm90IGZpbmQgZXhwZWN0ZWQgZGlyZWN0aXZlIG5hbWVleHBlY3RlZCB3aGl0ZXNwYWNld2hpbGUgc2Nhbm5pbmcgVEFHLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgd2hpdGVzcGFjZSBvciBsaW5lIGJyZWFrbWlzcGxhY2VkIGJyYWNrZXR3aGlsZSBwYXJzaW5nIGEgdGFnLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgdGFnIFVSSQAAAH0SEAApAAAA1QsAAC0AAAB3", + "aGlsZSBzY2FubmluZyBhIFlBTUwgZGlyZWN0aXZlLCBkaWQgbm90IGZpbmQgZXhwZWN0ZWQgZGlnaXQgb3IgJy4nIGNoYXJhY3RlcndoaWxlIHNjYW5uaW5nIGEgWUFNTCBkaXJlY3RpdmUsIGZvdW5kIGV4dHJlbWVseSBsb25nIHZlcnNpb24gbnVtYmVyd2hpbGUgc2Nhbm5pbmcgYSBZQU1MIGRpcmVjdGl2ZSwgZGlkIG5vdCBmaW5kIGV4cGVjdGVkIHZlcnNpb24gbnVtYmVyAAB9EhAAKQAAADEEAAAjAAAAfRIQACkAAAAyBAAAIwAAAHdoaWxlIHBhcnNpbmcgYSBxdW90ZWQgc2NhbGFyLCBmb3VuZCBpbnZhbGlkIFVuaWNvZGUgY2hhcmFjdGVyIGVzY2FwZSBjb2Rld2hpbGUgcGFyc2luZyBhIHF1b3RlZCBzY2FsYXIsIGRpZCBub3QgZmluZCBleHBlY3RlZCBoZXhhZGVjaW1hbCBudW1iZXJ3aGlsZSBwYXJzaW5nIGEgcXVvdGVkIHNjYWxhciwgZm91bmQgdW5rbm93biBlc2NhcGUgY2hhcmFjdGVyd2hpbGUgc2Nhbm5pbmcgYSB0YWcsIGRpZCBub3QgZmluZCBleHBlY3RlZCB3aGl0ZXNwYWNlIG9yIGxpbmUgYnJlYWttYXBwaW5nIGtleXMgYXJlIG5vdCBhbGxvd2VkIGluIHRoaXMgY29udGV4dHRhYnMgZGlzYWxsb3dlZCBpbiB0aGlzIGNvbnRleHQAAADUFRAAaQAAACMGAAAXAAAA7xcQAFsAAADQBAAAIwAAACEhbWVyZ2UAQLsQAAEAAABAuxAAAQAAAES5EAACAAAATK8QABIAAAAxEhAAIgAAAAcDAAAmAAAAITw+ZXhwZWN0ZWQgbm90aGluZyBhZnRlciBTVFJFQU0tRU5EYW5jaG9yIHZhbHVlIG11c3QgY29udGFpbiB2YWxpZCBjaGFyYWN0ZXJzIG9u", + "bHlhbGlhcyB2YWx1ZSBtdXN0IGNvbnRhaW4gdmFsaWQgY2hhcmFjdGVycyBvbmx5YW5jaG9yIHZhbHVlIG11c3Qgbm90IGJlIGVtcHR5YWxpYXMgdmFsdWUgbXVzdCBub3QgYmUgZW1wdHktLS0uLi4mKjESEAAiAAAAbQIAABoAAAAxEhAAIgAAANEAAAArAAAAMRIQACIAAADbAAAAIgAAADESEAAiAAAAowUAAAwAAABleHBlY3RlZCBET0NVTUVOVC1FTkRleHBlY3RlZCBTVFJFQU0tU1RBUlQAADESEAAiAAAAQQQAACEAAAAxEhAAIgAAAGcCAAAUAAAAMRIQACIAAABoAgAAGwAAAGV4cGVjdGVkIERPQ1VNRU5ULVNUQVJUIG9yIFNUUkVBTS1FTkRuZWl0aGVyIHRhZyBub3IgaW1wbGljaXQgZmxhZ3MgYXJlIHNwZWNpZmllZAAAADESEAAiAAAAXwIAABQAAAAxEhAAIgAAAGACAAAbAAAAfCw/ADESEAAiAAAAugUAACgAAAAtAAAAMRIQACIAAAANBQAAEwAAADESEAAiAAAAFwUAABcAAAAiAAAAMRIQACIAAAC/BAAAIQAAACcAAAAxEhAAIgAAAMEAAAAkAAAAMRIQACIAAACUBQAAFwAAAGFzc2VydGlvbiBmYWlsZWQ6IGlkeCA8IENBUEFDSVRZ7xcQAFsAAACeAgAACQAAAGFzc2VydGlvbiBmYWlsZWQ6IGVkZ2UuaGVpZ2h0ID09IHNlbGYuaGVpZ2h0IC0gMe8XEABbAAAAtgIAAAkAAADvFxAAWwAAALoCAAAJAAAAghYQAF8AAADGAAAAJwAAAHN5c3RlbSBvcGVyYXRpb25zIGFyZSBkaXNhYmxlZCwgdXNlIC0tc2VjdXJpdHktZW5hYmxlLXN5c3RlbS1vcGVyYXRvciB0byBlbmFibGUAHRUQABoAAAC0AAAAJAAAACAAAABLGBAAGgAAABQCAAAvAAAASxgQABoAAAAh", + "AgAAHQAAAEsYEAAaAAAAIgIAACAAAABLGBAAGgAAAPcBAAAdAAAASxgQABoAAAD4AQAAHwAAAEsYEAAaAAAA+wEAAEIAAAAweCVYMG8lb2luZmluZmluaXR5LmluZi1pbmYtaW5maW5pdHktLmluZm5hbi5uYW4CFRAAGgAAAA8AAAAlAAAAKwAAAAIVEAAaAAAAEAAAACUAAAAweDBvJXbAAWXAwyAAAGkCAAAtMC1JbmYrSW5mTmFOeXllc29uAAAAAhUQABoAAACgAAAAEQAAAAIVEAAaAAAAoQAAAB0AAAACFRAAGgAAAKYAAAA0AAAAAhUQABoAAAC+AAAAGgAAAFwaEAAfAAAA1wEAAB8AAABcGhAAHwAAANkBAAAbAAAAXBoQAB8AAAA0AgAAFgAAAFwaEAAfAAAAMgIAABYAAABuZW51ZmYAAFwaEAAfAAAAagIAAB4AAABcGhAAHwAAAHMCAAAzAAAAXBoQAB8AAAAhAwAANwAAAFwaEAAfAAAANAMAACIAAABcGhAAHwAAAD0DAAAQAAAAXBoQAB8AAAA/AwAAFAAAAFwaEAAfAAAARgMAAA0AAAAuAAAAXBoQAB8AAACrAQAAFwAAAFwaEAAfAAAAowEAACIAAABsaW5lXz9jb21tZW50fGxpbmVDb21tZW50aGVhZF8/Y29tbWVudHxoZWFkQ29tbWVudGZvb3RfP2NvbW1lbnR8Zm9vdENvbW1lbnRcKFwpXC5cW1xbXF1cPz9ce1x9XC5cLlwuXC5cLlwkW2EtekEtWl9cLTAtOV0rYXNyZWY6XHMqbGVuZ3RobGluZWNvbHVtbmV2YWx0b18/bnVtYmVybWFwXz92YWx1ZXNmaWx0ZXJwaWNrb21pdGZsYXR0ZW5cKFswLTldK1wpZmxhdHRlbmZvcm1hdF9kYXRldGltZW5vd3R6ZnJvbV8/dW5peHRvXz91bml4d2l0aF9kdGZlcnJvcnNodWZmbGVzb3J0S2V5c3NvcnRfP2tleXMoLltd", + "IHwgc2VsZWN0KC4gIT0gbnVsbCkgKSBhcyAkaSBpcmVkdWNlKHt9OyAuWyRpIHwga2V5XSA9ICRpKWFycmF5Xz90b18/bWFwcGFyZW50KC0xKXJvb3R0b18/eWFtbFwoWzAtOV0rXCl0b18/eG1sXChbMC05XStcKXRvXz9qc29uXChbMC05XStcKWZyb21fP3lhbWx8QHlhbWxkfGZyb21fP2pzb258QGpzb25kdG9fP3lhbWx8QHlhbWx0b18/anNvbkBqc29uZnJvbV8/cHJvcHN8QHByb3BzZHRvXz9wcm9wc3xAcHJvcHNmcm9tXz94bWx8QHhtbGR0b18/eG1sQHhtbGZyb21fP2NzdnxAY3N2ZHRvXz9jc3Z8QGNzdmZyb21fP3RzdnxAdHN2ZHRvXz90c3Z8QHRzdkBiYXNlNjR1cmxkQGJhc2U2NHVybEBiYXNlNjRkQGJhc2U2NEB1cmlkQHVyaUBzaGxvYWRfP3htbHx4bWxfP2xvYWRsb2FkXz9iYXNlNjRsb2FkXz9wcm9wc2xvYWRfP3N0cnxzdHJfP2xvYWRsb2Fkc3lzdGVtc3BsaXREb2N8c3BsaXRfP2RvY3NlbGVjdGhhc3VuaXF1ZV8/Ynl1bmlxdWVncm91cF8/YnlleHBsb2Rlb3JhbmRub3RpcmVkdWNlam9pbnN1Ym1hdGNoY2FwdHVyZXRlc3Rzb3J0Xz9ieXNvcnRmaXJzdHJldmVyc2VhbnlfY2FueWFsbF9jYWxsY29udGFpbnNzcGxpdHBhcmVudHNwYXJlbnRcKC0/WzAtOV0rXClwYXJlbnRrZXlza2V5aXNfP2tleWZpbGVfP25hbWV8ZmlsZU5hbWVmaWxlXz9pbmRleHxmaWxlSW5kZXh8ZmlwYXRoc2V0Xz9wYXRoZGVsXz9wYXRoc3RvXz9lbnRyaWVzfHRvRW50cmllc2Zyb21fP2VudHJpZXN8ZnJvbUVudHJpZXN3aXRoXz9lbnRyaWVzfHdpdGhFbnRyaWVz", + "d2l0aGNvbGxlY3RkZWxzdHlsZXRhZ3x0eXBla2luZGFuY2hvcmNvbW1lbnRzXHMqPWNvbW1lbnRzXHMqXHw9O1wvXC9kb2N1bWVudEluZGV4fGRvY3VtZW50Xz9pbmRleHxkaXVwY2FzZXxhc2NpaV8/dXBjYXNlZG93bmNhc2V8YXNjaWlfP2Rvd25jYXNldHJpbXRvXz9zdHJpbmcwW3hYXVswLTlBLUZhLWZdKy0/WzEtOV0oXC5cZCspP1tFZV1bLStdP1xkKy0/XGQrKFwuXGQrKS0/XGQrW1R0XVtScl1bVXVdW0VlXVtGZl1bQWFdW0xsXVtTc11bRWVdW05uXVtVdV1bTGxdW0xsXXx+IihbXiJcXF0qKFxcLlteIlxcXSopKikic3RyZW52XChbXlwpXStcKWVudlwoW15cKV0rXCllbnZzdWJzdFwoKG5lfG51fGZmfCB8LCkrXCllbnZzdWJzdFxzKj09XHMqXHMqIT1ccypccyo+PVxzKlxzKjw9XHMqXHMqPlxzKlxzKjxccyptaW5tYXhcfD1bY10qPVtjXSpbIFx0XG5dK1wuIlteICJdKyJcPz9cLlteIDtcfVx7XDpcW1xdLFx8XC5cW1woXCk9XG4hXStcPz9cfFwuXCo9W1wrfFw/Y2RuXSpcKltcK3xcP2Nkbl0qXC8lXCs9XCtcLT1cLSMuKnBpdm90AFwaEAAfAAAAswEAAAsAAABcGhAAHwAAANgCAAAlAAAAXBoQAB8AAADaAgAAHAAAAFwaEAAfAAAA4QIAABoAAABcGhAAHwAAAM0CAABMAAAAXBoQAB8AAADlAgAAIQAAAGJhZCBleHByZXNzaW9uLCBwbGVhc2UgY2hlY2sgZXhwcmVzc2lvbiBzeW50YXhiYWQgZXhwcmVzc2lvbiwgZ290IGNsb3NlIGJyYWNrZXRzIHdpdGhvdXQgbWF0Y2hpbmcgb3BlbmluZyBicmFja2V0YmFkIHBhdGggZXhwcmVzc2lvbiwgZ290", + "IGNsb3NlIGNvbGxlY3QgYnJhY2tldHMgd2l0aG91dCBtYXRjaGluZyBvcGVuaW5nIGJyYWNrZXRiYWQgZXhwcmVzc2lvbiwgY291bGQgbm90IGZpbmQgbWF0Y2hpbmcgYF1gYmFkIGV4cHJlc3Npb24sIGNvdWxkIG5vdCBmaW5kIG1hdGNoaW5nIGB9YABgAAAAFAAAAAQAAABhAAAAYgAAAGIAAABoEBAAJQAAAFoCAAAqAAAAaBAQACUAAABbAgAAIAAAAGgQEAAlAAAAYwIAACsAAABoEBAAJQAAAGQCAAAUAAAAdmFsdWUAAABoEBAAJQAAAAMCAABEAAAAaBAQACUAAAAEAgAAPgAAAGgQEAAlAAAABQIAAEAAAABoEBAAJQAAAMcBAAA2AAAAaBAQACUAAAA4AgAAKwAAAGgQEAAlAAAAOQIAABQAAAAhIXRpbWVzdGFtcABoEBAAJQAAAJAAAAAsAAAAaBAQACUAAACQAAAAPgAAAG9ubHkgYXJyYXlzIGFyZSBzdXBwb3J0ZWQgZm9yIGZsYXR0ZW4AQdSvwwALlQMBAAAAYwAAAGQAAABkAAAAaBAQACUAAAA1AQAAKgAAAG9ubHkgYXJyYXlzIGFyZSBzdXBwb3J0ZWQgZm9yIGdyb3VwIGJ5b25seSBhcnJheXMgYXJlIHN1cHBvcnRlZCBmb3IgdW5pcXVlAABoEBAAJQAAAEIDAAA+AAAAaBAQACUAAABCAwAAUwAAAGZyb20gZW50cmllcyBvbmx5IHJ1bnMgYWdhaW5zdCBhcnJheXMAAABoEBAAJQAAAKsCAAAvAAAAaBAQACUAAACsAgAAMQAAAGgQEAAlAAAAsQIAADkAAABoEBAAJQAAALIBAAA0AAAAaBAQACUAAACzAQAANgAAAGgQEAAlAAAArwAAABoAAABoEBAAJQAAALAAAABBAAAAdQ8QACgAAAAlAAAAHgAAAENvbGxlY3RPYmplY3Q6IG1pc21hdGNoaW5nIG5vZGUgc2l6", + "ZXM7IGFyZSB5b3UgY3JlYXRpbmcgYSBtYXAgd2l0aCBtaXNtYXRjaGluZyBrZXkgdmFsdWUgcGFpcnM/e30AQfSywwALrggBAAAAZQAAAGYAAABnAAAAHxwQAB0AAADBAAAAHgAAAB8cEAAdAAAAwgAAACAAAAAfHBAAHQAAAMgAAAA8AAAAHxwQAB0AAADKAAAAMAAAAD06LTo9Ois6P0VPRmVudiBvcGVyYXRpb25zIGhhdmUgYmVlbiBkaXNhYmxlZAAAAM0NEAAdAAAAiwAAABYAAADNDRAAHQAAAIwAAAAWAAAACgAAAM0NEAAdAAAARgAAABYAAADNDRAAHQAAAEwAAAAZAAAAzQ0QAB0AAABTAAAAJAAAAM0NEAAdAAAAWwAAACYAAADNDRAAHQAAAG0AAAA6AAAAzQ0QAB0AAABwAAAAJQAAAGZpbGVuYW1lIGV4cHJlc3Npb24gcmV0dXJuZWQgbmlsZmlsZSBvcGVyYXRpb25zIGhhdmUgYmVlbiBkaXNhYmxlZAAAPRwQAB4AAAA7AAAAGgAAAOscEAAeAAAANAEAABQAAADrHBAAHgAAADUBAAAUAAAA6xwQAB4AAADzAAAALAAAAOscEAAeAAAA9AAAACwAAADrHBAAHgAAAFgBAAAgAAAA6xwQAB4AAABLAQAAJwAAAOscEAAeAAAAUAEAABgAAAAjIAojIAAAAOscEAAeAAAAFwEAADQAAADrHBAAHgAAABcBAABEAAAA6xwQAB4AAAACAQAAGgAAAOscEAAeAAAAAwEAABwAAADrHBAAHgAAAGoBAAAaAAAA6xwQAB4AAABrAQAAHAAAAOscEAAeAAAAiwEAADIAAADrHBAAHgAAAJwBAABEAAAA6xwQAB4AAACSAQAANQAAAFNFVFBBVEhERUxQQVRIU3RpbWV6b25lVVRDTG9jYWxBdXN0cmFsaWEvUGVydGhBdXN0cmFsaWEvU3lkbmV5QXVzdHJhbGlhL01lbGJvdXJuZUF1c3RyYWxp", + "YS9DYW5iZXJyYUF1c3RyYWxpYS9Ib2JhcnQTY291bGQgbm90IGxvYWQgdHogW8AVXTogdW5rbm93biB0aW1lIHpvbmUgyAAAAG11c3QgcHJvdmlkZSBhIGRhdGUgdGltZSBmb3JtYXQgc3RyaW5nIGFuZCBhbiBleHByZXNzaW9uLCBlLmcuIHdpdGhfZHRmKCJNb25kYXksIDAyLUphbi0wNiBhdCAzOjA0UE0gTVNUIjsgPGV4cD4pbGF5b3V0Zm9ybWF0MjAwNi0wMS0wMlQxNTowNDowNS45OTk5OTk5OTlaMDc6MDAAAO4YEAAfAAAAQwAAACoAAADuGBAAHwAAADUAAAAnAAAAAAAAAAMAAAABAAAAaAAAAGkAAABpAAAAYRYQACAAAAA1AAAAGwAAAGEWEAAgAAAANgAAAB0AAABhFhAAIAAAAE8AAAAbAAAAYRYQACAAAABQAAAAJwAAAGNhbm5vdCBtb2R1bG8gYnkgMABBrLvDAAsNAQAAAGoAAABrAAAAbABBxLvDAAv9BQEAAABtAAAAbgAAAG8AAABiZSBkaXZpZGVkIGJ5bW9kdWxvIGJ5AAAAAAAAAQAAAAEAAABwAAAAcQAAAHEAAABbXWFycmF5cyBub3QgeWV0IHN1cHBvcnRlZCBmb3IgY29tcGFyaXNvbm1hcHMgbm90IHlldCBzdXBwb3J0ZWQgZm9yIGNvbXBhcmlzb24AAAAAAAACAAAAAQAAAHIAAABzAAAAcwAAAGFib3J0ZWRyZWZlcmVuY2Ugb3BlcmF0b3Igd2l0aG91dCBhIG5vZGVubyBzdXBwb3J0IGZvciBpbnB1dCBmb3JtYXQApxIQACEAAABiAAAAGQAAAKcSEAAhAAAAYwAAABkAAABubyBzdXBwb3J0IGZvciBvdXRwdXQgZm9ybWF0IhAQACEAAADXAAAAQwAAACIQEAAhAAAAxAEAABcAAAAiEBAAIQAAAMUBAAAZAAAAXFxcblxyXHRcZgElwyAAAGkCAABB", + "QkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWmFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6MDEyMzQ1Njc4OSsvQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVphYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ejAxMjM0NTY3ODktXyIQEAAhAAAAMgAAABUAAAAiEBAAIQAAABEBAAAvAAAAIhAQACEAAAARAQAASAAAACIQEAAhAAAAEgEAAB0AAAAiEBAAIQAAABMBAAApAAAAcmVjb3JkIG9uIGxpbmUgMTogd3JvbmcgbnVtYmVyIG9mIGZpZWxkcyIQEAAhAAAAZAAAACEAAAAiEBAAIQAAAGIAAABRAAAAIhAQACEAAACJAQAAKgAAACIQEAAhAAAAjQEAACQAAAAiIgAAjhAQACEAAAAsAAAAFgAAAI4QEAAhAAAALwAAABwAAACOEBAAIQAAAEoAAABFAAAAjhAQACEAAABLAAAAIgAAAAAAAAABAAAAAQAAAHQAAAB1AAAAdQBBzMHDAAsNAQAAAHYAAAB3AAAAeABB5MHDAAsNAQAAAHkAAAB6AAAAegBB/MHDAAvZEgEAAAB7AAAAfAAAAHwAAADMFxAAIgAAAC8CAAASAAAAzBcQACIAAAAaAQAACgAAADoAAADAwyAAAGkCAADAwyAAAGkCAMMgAABpAgAAwMMgAABpAgABOsMgAABpAgAAAMwXEAAiAAAAOAIAAB8AAADMFxAAIgAAADoCAAAKAAAAMjAwNi0wMS0wMgAAzBcQACIAAADtAgAAHwAAAMwXEAAiAAAA7gIAABUAAADMFxAAIgAAAPICAAAZAAAAzBcQACIAAADzAgAAFQAAAG5zdXPCtXPOvHNtc3NtaACEsBAABAAAAAEAAAAAAAAAkLAQAAcAAAAGAAAAAAAAAI2wEAADAAAABQAAAAAAAACisBAABgAAAAwAAAAAAAAAn7AQAAMAAAALAAAAAAAAALewEAADAAAAFgAAAAAAAACK", + "sBAAAgAAAAMAAAAAAAAAl7AQAAIAAAAHAAAAAAAAAJywEAADAAAACgAAAAAAAACasBAAAgAAAAkAAAAAAAAAqLAQAAIAAAANAAAAAAAAAKqwEAACAAAADgAAAAAAAACtsBAAAgAAABAAAAAAAAAAsLAQAAIAAAASAAAAAAAAAIiwEAACAAAAAgAAAAAAAACzsBAAAgAAABQAAAAAAAAAtbAQAAIAAAAVAAAAAAAAALqwEAAGAAAAFwAAAAAAAADAsBAABQAAABgAAAAAAAAAxbAQAAMAAAAZAAAAAAAAAMiwEAAGAAAAGgAAAAAAAADOsBAABQAAABsAAAAAAAAA07AQAAMAAAAcAAAAAAAAAMwXEAAiAAAAcAAAABYAAADMFxAAIgAAAHMAAAAWAAAAzBcQACIAAABzAAAALQAAAMwXEAAiAAAAdQAAAB4AAADMFxAAIgAAAHcAAAArAAAAzBcQACIAAAB7AAAAKgAAAMwXEAAiAAAAAQIAACEAAABGZWJNYXJBcHJNYXlKdW5KdWxBdWdTZXBPY3ROb3ZEZWMAAACNsBAAAwAAALjjEAADAAAAu+MQAAMAAAC+4xAAAwAAAMHjEAADAAAAxOMQAAMAAADH4xAAAwAAAMrjEAADAAAAzeMQAAMAAADQ4xAAAwAAANPjEAADAAAA1uMQAAMAAABGZWJydWFyeU1hcmNoQXByaWxKdW5lSnVseUF1Z3VzdFNlcHRlbWJlck9jdG9iZXJOb3ZlbWJlckRlY2VtYmVykLAQAAcAAAA85BAACAAAAETkEAAFAAAASeQQAAUAAADB4xAAAwAAAE7kEAAEAAAAUuQQAAQAAABW5BAABgAAAFzkEAAJAAAAZeQQAAcAAABs5BAACAAAAHTkEAAIAAAAU3VuVHVlV2VkVGh1RnJpU2F0AADc5BAAAwAAAJ+wEAADAAAA3+QQAAMAAADi5BAAAwAAAOXkEAADAAAA6OQQAAMAAADr5BAAAwAAAFN1bmRheVR1ZXNkYXlXZWRu", + "ZXNkYXlUaHVyc2RheUZyaWRheVNhdHVyZGF5KOUQAAYAAACisBAABgAAAC7lEAAHAAAANeUQAAkAAAA+5RAACAAAAEblEAAGAAAATOUQAAgAAABBTQAAjOUQAAIAAACzsBAAAgAAAMwXEAAiAAAA1wEAADEAAADMFxAAIgAAAN0BAAApAAAAwyAAAGkEAADDIAAAaQIAAMwXEAAiAAAAbgIAADQAAADMFxAAIgAAAG8CAAAzAAAAwyAAACgCAADDIAAAaQMAAMwXEAAiAAAAdAIAADIAAADMFxAAIgAAAHUCAAAxAAAAYW0AAMwXEAAiAAAAggIAADwAAADDIAAAaQkAAMwXEAAiAAAApwIAACUAAADMFxAAIgAAAKsCAAAlAAAAzBcQACIAAAAhAQAAFQAAADMNEAAiAAAA7AAAABIAAAAAAAAACwAAAAEAAAB9AAAAfgAAAH4AAABzdHJpbmdzIGNhbm5vdCBiZSBzdWJ0cmFjdGVkAAAAAAAAAAABAAAAfwAAAIAAAACBAAAAbWFwcyBub3QgeWV0IHN1cHBvcnRlZCBmb3Igc3VidHJhY3Rpb24AAOIWEAAiAAAAWgEAAB8AAADiFhAAIgAAAFwBAAA/AAAA4hYQACIAAABiAQAAGwAAAOIWEAAiAAAAYwEAAB0AAABhbGlhcyBjeWNsZSBkZXRlY3RlZHRyYXZlcnNlIGFycmF5OiBubyBpbmRpY2VzAADiFhAAIgAAAAABAAAvAAAAY2FwdHVyZXMnaScgaXMgbm90IGEgdmFsaWQgb3B0aW9uIGZvciBtYXRjaC4gVG8gaWdub3JlIGNhc2UsIHVzZSBhbiBleHByZXNzaW9uIGxpa2UgbWF0Y2goIig/aSljYXQiKUQQEAAjAAAAFwAAABsAAABEEBAAIwAAABgAAAAVAAAARBAQACMAAAAgAAAAKAAAAEQQEAAjAAAAIAAAADoAAABEEBAAIwAAACoAAAATAAAARBAQACMAAAAqAAAAIQAAAEQQEAAj", + "AAAAGwAAABkAAABzdHJpbmdvZmZzZXRuYW1lbXVzdCB1c2UgdmFyaWFibGUgd2l0aCBhIHBpcGUsIGUuZy4gYGV4cCBhcyAkeCB8IC4uLmBSSFMgb2YgJ2FzJyBvcGVyYXRvciBtdXN0IGJlIGEgdmFyaWFibGUgbmFtZSBlLmcuICRmb28AZhgQACEAAABbAAAAMAAAAGYYEAAhAAAAYAAAACoAAABcIlxiXHUyMDI4XHUyMDI5Alx1wyAAAGkEAADBIAAAcAAuMABmGBAAIQAAANAAAAAIAAAAADE5AGYYEAAhAAAA3QAAACEAAABmGBAAIQAAAOsAAAAhAAAAzBgQACEAAAAaAAAAJwAAAMwYEAAhAAAAGgAAAEAAAAANCiVZQU1MAIgYEAAhAAAAKAAAACcAAACIGBAAIQAAACgAAABAAAAALS0tCi0tLQ0KISFiaW5hcnkAIH4+FhAAIgAAAFIBAAAWAAAAVHJ1ZVRSVUVGYWxzZUZBTFNFfk51bGxOVUxMLk5hTi5OQU4uSW5mLklORisuaW5mKy5JbmYrLklORi0uSW5mLS5JTkYtMC4wPhYQACIAAADWAAAAJwAAAD4WEAAiAAAA8gAAABUAAAA+FhAAIgAAAEEAAAAkAAAAPhYQACIAAABCAAAAIwAAADBiAAA+FhAAIgAAAFAAAAATAAAAAAAAABgAAAAEAAAAggAAAIMAAACDAEHg1MMAC3MBAAAAhAAAAIUAAACFAAAAAAAAADAAAAAEAAAAhgAAAIcAAACHAAAAIzsvPzpAJj0rJCxfLiF+KicoKVtdJQAA9A8QAC0AAABFAAAADgAAAGEAAABmAAAAAAAAAEEAAABGAAAAAAAAAAICAgICAgICAgICAEHw1cMACwgCAgAAAAAAAgBBp9bDAAsBAgBBzdbDAAsBAQBB6NbDAAsBAQBByNfDAAuAAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB", + "AQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAEGK2cMACzMCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDAwMDAwMDAwMDAwMDAwMDBAQEBAQAQcjZwwALfVN0cmVhbVN0YXJ0U3RyZWFtRW5kRG9jdW1lbnRTdGFydERvY3VtZW50RW5kQWxpYXNTY2FsYXJTZXF1ZW5jZVN0YXJ0U2VxdWVuY2VFbmRNYXBwaW5nU3RhcnRNYXBwaW5nRW5kAAAAiAAAAAwAAAAEAAAAiQAAAIoAAACLAEHQ2sMAC9kMAQAAAIwAAABhIERpc3BsYXkgaW1wbGVtZW50YXRpb24gcmV0dXJuZWQgYW4gZXJyb3IgdW5leHBlY3RlZGx5AIgVEABLAAAAiQsAAA4AAABFcnJvck5vbmVTb21lAAAAwBsQAF4AAAA5AAAAEgAAAGNvbW1lbnRzIG11c3QgYmUgc2VwYXJhdGVkIGZyb20gb3RoZXIgdG9rZW5zIGJ5IHdoaXRlc3BhY2UAAGsREAArAAAAUQEAACMAAABrERAAKwAAAGQBAAAZAAAAaxEQACsAAABrAQAAIgAAAGsREAArAAAAgAEAABkAAABrERAAKwAAAIcBAAAiAAAAb3V0IG9mIGJvdW5kcyBhY2Nlc3NOb3RoaW5nUGxhaW5TaW5nbGVRdW90ZWREb3VibGVRdW90ZWRMaXRlcmFsRm9sZGVkVGFnaGFuZGxlc3VmZml4KRMQAE8AAABrBAAAJAAAAB8AHx4fHh8fHh8eHwUMDAcGAAAAZ+4QAGzuEAB47hAAhO4QAIvuEAAFDAwHBgAAAGfuEABs7hAAeO4QAITuEACL7hAAHwAfHh8eHx8eHx4fCwkNCwUGDQsMCgAAyOwQANPsEADc7BAA6ewQAPTsEAD57BAA/+wQAAztEAAX7RAAI+0QAI0AAACOAAAA", + "jwAAAJAAAACRAAAAkgAAAJMAAACUAAAAlQAAAJYAAACXAAAAmAAAAJkAAACaAAAAmwAAAJwAAACdAAAAngAAAJ8AAACgAAAAoQAAAKIAAACjAAAApAAAAKUAAACmAAAApwAAAKgAAACpAAAAqgAAAKsAAACUAAAArAAAAK0AAACuAAAArwAAALAAAACxAAAAsgAAALMAAAC0AAAAtQAAALYAAAC3AAAAuAAAALkAAAC6AAAAuwAAALwAAAC9AAAAvgAAAL8AAADAAAAAwQAAAMIAAADAAAAAwQAAAMMAAADEAAAAxQAAAMYAAADHAAAAyAAAAMkAAADKAAAAywAAAMwAAADNAAAAzgAAAM8AAADQAAAA0QAAANIAAADTAAAA1AAAANUAAADWAAAA1wAAANgAAADZAAAA2gAAANsAAADcAAAA3QAAAN4AAADfAAAA4AAAAOEAAADiAAAA4wAAAOQAAADlAAAA5gAAAOcAAADoAAAA6QAAAOoAAADrAAAA7AAAAO0AAADuAAAA7wAAAPAAAADxAAAA8gAAAPMAAAD0AAAA9QAAAPYAAACSAAAA9wAAAPgAAAD5AAAA+gAAAPsAAAD8AAAA/QAAAP4AAAD/AAAAAAEAABGyEAATshAAFrIQAByyEAAjshAAKrIQAC+yEAA0shAAOLIQAD6yEABIshAAV7IQAGiyEAB0shAAg7IQAI2yEACbshAAqLIQALSyEAC8shAAy7IQANGyEADXshAA2rIQAOKyEADtshAA87IQAP2yEAAEsxAAB7MQAAqzEAAUsxAAHrMQACSzEAAksxAAKLMQACuzEAAysxAANbMQADuzEABAsxAARLMQAEizEABMsxAAVrMQAGazEAB7sxAAfrMQAIazEACPsxAAlrMQAJyzEACisxAApbMQAKizEACwsxAAvbMQAMqzEADUsxAA4LMQAOyzEADwsxAA+bMQAAW0EAAOtBAAFbQQAB20EAAktBAAKrQQADS0EAA/tBAASrQQAFS0EABdtBAA", + "b7QQAHu0EACJtBAAkbQQAJm0EACitBAAqbQQALC0EAC1tBAAvLQQAMC0EADHtBAA0LQQANS0EADatBAA37QQAOa0EADqtBAA77QQAPq0EAD+tBAAB7UQABG1EAAVtRAAILUQACa1EAAqtRAAOLUQAEW1EABTtRAAV7UQAFy1EABftRAAYrUQAGW1EAButRAAc7UQAHu1EACMtRAAkrUQAJW1EACbtRAApLUQAKy1EAC2tRAAvLUQAAIDBgcHBQUEBgoPEQwPCg4NDAgPBgYDCAsGCgcDAwoKBgQEAwcDBgUEBAQKEBUDCAkHBgYDAwgNDQoMDAQJDAkHCAcGCgsLCgkSDA4ICAkHBwUHBAcJBAYFBwQFCwQJCgQLBgQODQ4EBQMDAwkFCBEGAwYJCAoGBQICAgICAgICAgICAgICAgICAgICAgICAgICAgIAAAICAAAAAAEBAQEBAQEBAQEAAQAAAAAAAAEBAQAAAQEAQbnnwwALGgEBAQEBAAAAAQEBAQEBAQAAAAABAQEAAAACAEHc58MAC4ABAQEAAQEAAQAUFCMFBAoKHigoKCgoKCgoKCgqKioqKioqKCgoKCgPLTIyMjIyNDQyNDQ0NDIyMjIyMjIyMjIyMjI0MjI0NDcyMjIyMjIyMjIyMjIyNDI0NDQ0NDQ0NDIyMjIyNDIyMjI0NDI0MjcyNzIyNDIyMjIyNDI0NDQ0KDQAQYHpwwALBwEBAAEBAQEAQZXpwwALBQEAAAEBAEGo6cMAC1sBAAEBAQEBAQEBAAAAAAABAAAAAAEAAAEAAAAAAAABAAAAAAABAAEBAQEAAQMDBgXorxAA668QAO6vEAD0rxAABQUHBgYAAADjrxAAnK8QAKGvEAAGshAAJbAQAEHK7cMACwQBAP8P", +]; + +/** Base64 of the exact published WebAssembly module. */ +export const YQ_WASM_BASE64: string = LINES.join(""); diff --git a/packages/core/tests/document-validation.test.ts b/packages/core/tests/document-validation.test.ts index a147960da..d3fd02eb3 100644 --- a/packages/core/tests/document-validation.test.ts +++ b/packages/core/tests/document-validation.test.ts @@ -1399,6 +1399,34 @@ describe("Tier DV: one decision, both callers", () => { }); }); +describe("Tier DV: the engine's own props are not schema props", () => { + it("DV14: `yq` passes a closed schema, exactly as `as` and `slot` do", function* () { + // The failure this is named for was found by running the product: a static + // reader that stripped two of the engine's props and not the third refused + // an invocation expansion runs, and the refusal reached the REPL's own + // preflight — so a document that `xmd run` executes could not be submitted + // as an entry. + const { result } = yield* validateText( + `\n`, + { tree: { "notes.md": "{}" } }, + ); + + expect(codes(result)).toEqual([]); + expect(outcomes(result)).toEqual(["valid"]); + }); + + it("DV14: an unknown prop beside `yq` is still refused", function* () { + // The negative control: stripping the engine's own props is not stripping + // everything, so a closed schema still closes. + const { result } = yield* validateText(`\n`, { + tree: { "notes.md": "{}" }, + }); + + expect(codes(result)).toContain("props-invalid"); + expect(result.diagnostics.map((one) => one.message).join("\n")).toContain("nonsense"); + }); +}); + describe("Tier DV: the no-execution boundary", () => { const HOSTILE = [ "---", diff --git a/packages/core/tests/generated-composition.test.ts b/packages/core/tests/generated-composition.test.ts index fb2dd2859..0be23b8e1 100644 --- a/packages/core/tests/generated-composition.test.ts +++ b/packages/core/tests/generated-composition.test.ts @@ -20,7 +20,7 @@ import { describe, it } from "@executablemd/test-support/bdd"; import { expect } from "@executablemd/test-support/expect"; import { InMemoryStream } from "@executablemd/durable-streams"; -import type { Json } from "@executablemd/durable-streams"; +import type { DurableEvent, Json } from "@executablemd/durable-streams"; import { ensure, scoped } from "effection"; import type { Operation } from "effection"; @@ -464,3 +464,227 @@ describe("Tier FE33 — occurrences do not share generated history", () => { expect(admitted).toHaveLength(2); }); }); + +/** + * Tier FE31 — Yaml is composition beside Json, and an old grant stays old. + * + * Adding a pure component widens what *new* source may write and must widen no + * grant anybody already holds. Core's always-on table is a fact about the + * build rather than about the policy a host stated, so a record written before + * a pure component existed holds no row for it — and that record is what its + * own continuation is held to. + */ +describe("Tier FE31 — Yaml is composition, and a retained grant is historical", () => { + it("FE31: exact core Yaml renders under a read-only selection", function* () { + const files = recordedFiles({ "notes.md": NOTE }); + const output = yield* run( + evaluating(`\n`, ["read"]), + [reading(files)], + ); + + expect(String(output)).toContain("kept:"); + expect(String(output)).toContain("- two"); + // Composition performs nothing: no capability was reached to render it. + expect(files.performed).toEqual([]); + }); + + it("FE31: the admission retains Yaml's own identity", function* () { + const files = recordedFiles({ "notes.md": NOTE }); + const stream = new InMemoryStream(); + yield* run(evaluating(`\n`, ["read"]), [reading(files)], stream); + + const rows = admittedRows(stream); + // Its own URL, not Json's: an admission that reused one would say a + // fragment had been granted the other component. + expect(rows.find((row) => row.name === "Yaml")?.identity).toBe( + "https://executable.md/components/yaml", + ); + expect(rows.find((row) => row.name === "Json")?.identity).toBe( + "https://executable.md/components/json", + ); + expect(rows.filter((row) => row.effect === "composition").map((row) => row.name)).toEqual([ + "Json", + "Yaml", + ]); + }); + + it("FE31: a Json-only admission reopens without gaining Yaml", function* () { + const files = recordedFiles({ "notes.md": NOTE }); + const fragment = `\n`; + const live = new InMemoryStream(); + yield* run(evaluating(fragment, ["read"]), [reading(files)], live); + + // The same history with Yaml's composition row removed, which is exactly + // what a record written before Yaml existed holds. + const retained = new InMemoryStream(withoutYaml(live.snapshot())); + const again = yield* run( + evaluating(fragment, ["read"]), + [recordedFiles({ "notes.md": NOTE })].map((held) => reading(held)), + retained, + ); + + // Readable, and continued: the continuation is compared against the rows + // its own admission recorded rather than against today's table, so it is + // neither refused for a row it never named nor widened to include one. + expect(JSON.parse(String(again).trim())).toEqual({ a: 1 }); + }); + + it("FE31: reopening a Json-only admission adds no Yaml row to it", function* () { + const fragment = `\n`; + const live = new InMemoryStream(); + yield* run( + evaluating(fragment, ["read"]), + [reading(recordedFiles({ "notes.md": NOTE }))], + live, + ); + + const historical = withoutYaml(live.snapshot()); + const retained = new InMemoryStream(historical); + yield* run( + evaluating(fragment, ["read"]), + [reading(recordedFiles({ "notes.md": NOTE }))], + retained, + ); + + // The grant this continuation ran under is the one its own record holds: + // still Json alone, and still one admission. A route that reconciled + // against today's table would have had to either refuse this history or + // write Yaml into it. + expect(admittedRows(retained).filter((row) => row.effect === "composition")).toEqual([ + { name: "Json", identity: "https://executable.md/components/json", effect: "composition" }, + ]); + const admissions = retained + .snapshot() + .filter((event) => event.type === "yield" && event.description.type === "generated_xmd"); + expect(admissions.length).toBe(1); + }); + + it("FE31: a repository cannot offer its own Yaml for the admitted name", function* () { + // The replacement row. What a fragment is admitted to write is core's own + // pure definition, and `Yaml` is a name a repository may not take over: + // the conflict is detected at capture, so the host's offering never + // becomes the definition an admission then records. + const files = recordedFiles(); + const message = yield* refusal( + run(evaluating(`\n`), [ + { + *install(): Operation { + yield* useSelection({ Yaml: ["self-closing"] }); + yield* useRecordedFiles(files); + }, + }, + ]), + ); + + expect(message).toContain("Yaml"); + expect(files.performed).toEqual([]); + }); + + it("FE31: an answered replacement never renders, and never runs", function* () { + // The same refusal where the replacement is a provider's answer rather + // than a selection row — a definition that would have rendered something + // else entirely. Its body is the evidence: a route that preferred the + // answer would have run it before anybody could read the output. + const ran: string[] = []; + const replacement: FunctionComponentDefinition = { + kind: "function", + name: "Yaml", + props: { type: "object", properties: {}, additionalProperties: true }, + forms: ["self-closing"], + // A repository declares "read" or "write" and nothing else: composition is + // core's own classification, so the strongest claim a replacement can + // make for this name is an effect — which is the claim refused here. + generated: { + "self-closing": { identity: "https://executable.md/components/yaml", effect: "read" }, + }, + // deno-lint-ignore require-yield + *fn(): Operation { + ran.push("replacement"); + return "replaced:\n"; + }, + }; + + const message = yield* refusal( + run(evaluating(`\n`, ["read"]), [ + { + *install(): Operation { + yield* useSelection({ Yaml: ["self-closing"] }); + }, + componentAnswers: [answerProvider("Yaml", replacement)], + }, + ]), + ); + + // Refused as the conflict it is — one admitted name cannot stand for two + // definitions — and refused before the answer could render anything. + expect(message).toContain("two definitions"); + expect(ran).toEqual([]); + }); +}); + +/** The admitted rows one retained admission holds. */ +function admittedRows( + stream: InMemoryStream, +): { name: string; identity: string; effect: string }[] { + for (const event of stream.snapshot()) { + if (event.type !== "yield" || event.description.type !== "generated_xmd") { + continue; + } + const result = event.result; + if (result.status !== "ok") { + continue; + } + const value = result.value; + if (typeof value !== "object" || value === null || Array.isArray(value)) { + continue; + } + const policy = (value as { policy?: unknown }).policy; + if (typeof policy !== "object" || policy === null || Array.isArray(policy)) { + continue; + } + const allowed = (policy as { allowed?: unknown }).allowed; + if (!Array.isArray(allowed)) { + continue; + } + return allowed.map((row) => ({ + name: String((row as { name?: unknown }).name), + identity: String((row as { identity?: unknown }).identity), + effect: String((row as { effect?: unknown }).effect), + })); + } + throw new Error("this history retained no generated admission"); +} + +/** + * The same events with Yaml's composition row removed from the admission. + * + * Read back out of JSON rather than edited in place, so what the continuation + * is given is ordinary journal data of exactly the shape an older build wrote. + */ +function withoutYaml(events: readonly DurableEvent[]): DurableEvent[] { + return events.map((event) => { + if (event.type !== "yield" || event.description.type !== "generated_xmd") { + return event; + } + if (event.result.status !== "ok") { + return event; + } + const held: Json = JSON.parse(JSON.stringify(event.result.value ?? null)); + if (held === null || typeof held !== "object" || Array.isArray(held)) { + return event; + } + const policy = held.policy; + if (policy === null || typeof policy !== "object" || Array.isArray(policy)) { + return event; + } + const allowed = policy.allowed; + if (!Array.isArray(allowed)) { + return event; + } + const kept = allowed.filter( + (row) => row === null || typeof row !== "object" || Array.isArray(row) || row.name !== "Yaml", + ); + const value: Json = { ...held, policy: { ...policy, allowed: kept } }; + return { ...event, result: { status: "ok", value } }; + }); +} diff --git a/packages/core/tests/generated-xmd-root.test.ts b/packages/core/tests/generated-xmd-root.test.ts index d7d40ea7e..999053942 100644 --- a/packages/core/tests/generated-xmd-root.test.ts +++ b/packages/core/tests/generated-xmd-root.test.ts @@ -933,6 +933,8 @@ describe("Tier GRM — a record's marker is what authorizes the evaluation", () componentRouting: identity.componentRouting, reference: undefined, live: () => true, + // No host destinations: this root's results are its own to render. + destinations: undefined, }); } @@ -1156,6 +1158,30 @@ describe("Tier GR — the trusted composition table reaches a root too", () => { // source renders to in an ordinary document. expect(rendered(attempt).output).toContain('Hello, "Ada"!'); }); + + it("GR17: a root renders a local binding as YAML", function* () { + // The whole composition table, not one entry of it: the host's read table + // names neither renderer, and a root reaches both for the same reason. + const attempt = yield* evaluateRoot( + request( + '\n\n' + + "\n\n\n", + ), + ); + + const output = rendered(attempt).output; + // `` binds the text it rendered, so what `` was handed is a + // JSON string — and a string spanning lines is a YAML block scalar. The + // indented body is that exact JSON text, unchanged: the renderer described + // the value it was given rather than reinterpreting it as data. + expect(output.trimStart().startsWith("|-")).toBe(true); + const body = output + .slice(output.indexOf("|-") + 2) + .split("\n") + .map((line) => line.replace(/^ {2}/, "")) + .join("\n"); + expect(JSON.parse(body.trim())).toEqual({ names: ["Ada", "Grace"] }); + }); }); /** diff --git a/packages/core/tests/host-generated-root.test.ts b/packages/core/tests/host-generated-root.test.ts index 93740c8be..38afd11f2 100644 --- a/packages/core/tests/host-generated-root.test.ts +++ b/packages/core/tests/host-generated-root.test.ts @@ -1438,7 +1438,7 @@ describe("Tier E8 — the captured selection holds canonical Syntax once", () => // this root may write. const rows = retainedRows(yield* stream.readAll()); expect(rows.filter((row) => row.name === "Syntax")).toHaveLength(1); - expect(rows.map((row) => row.name)).toEqual(["Json", "Probe", "Syntax"]); + expect(rows.map((row) => row.name)).toEqual(["Json", "Yaml", "Probe", "Syntax"]); // And once in the descriptive vocabulary, which is the other reading of the // same selection: a second entry would render a second section. expect(occurrences(answered.output ?? "", "### ``")).toBe(1); @@ -1466,7 +1466,7 @@ describe("Tier E8 — the captured selection holds canonical Syntax once", () => expect(invoked).toEqual(["probed"]); const rows = retainedRows(yield* stream.readAll()); expect(rows.filter((row) => row.name === "Syntax")).toHaveLength(1); - expect(rows.map((row) => row.name)).toEqual(["Json", "Probe", "Syntax"]); + expect(rows.map((row) => row.name)).toEqual(["Json", "Yaml", "Probe", "Syntax"]); expect(occurrences(answered.output ?? "", "### ``")).toBe(1); }); }); diff --git a/packages/core/tests/syntax-catalog.test.ts b/packages/core/tests/syntax-catalog.test.ts index 39957ccd4..7b98a6543 100644 --- a/packages/core/tests/syntax-catalog.test.ts +++ b/packages/core/tests/syntax-catalog.test.ts @@ -1164,6 +1164,49 @@ describe("Tier SY: complete component contracts", () => { expect(entry.context).toBe(undefined); }); + it("SY24b3: reports 's whole contract, on Json's own terms", function* () { + const catalog = yield* catalogFor({}, []); + const entry = find(builtIn(catalog), "Yaml"); + + // The same row Json has, field for field, because it is the same contract: + // one capture, closed empty props, text out, optional `as`. A renderer that + // had grown a prop of its own — an indent, a document separator — would + // fail here rather than in whatever read the YAML afterwards. + expect(entry).toEqual({ + kind: "component", + name: "Yaml", + origin: { kind: "registered", origin: "@executablemd/core", reserved: false }, + sourceKind: "registered", + inspectability: "complete", + forms: ["self-closing"], + props: { type: "object", properties: {}, additionalProperties: false }, + captures: ["value"], + returnMode: "text", + returns: { type: "string" }, + description: + "Render a value as YAML text. `` writes the YAML where you " + + "put it. Nothing else turns a value into YAML.", + as: "Optional. Captures the YAML text instead of emitting it.", + }); + // Contentless, like Json: there is no body to document. + expect(entry.context).toBe(undefined); + }); + + it("SY24b3: neither renderer advertises the engine's own props", function* () { + const catalog = yield* catalogFor({}, []); + + // `yq` and `as` are consumed before a component's own props are checked, so + // no component schema in the catalog may claim either. Checked across the + // whole built-in category rather than on the two renderers, because the + // rule is about every component and not about these. + for (const entry of builtIn(catalog)) { + const properties = (entry as { props?: { properties?: Record } }).props + ?.properties; + expect(Object.keys(properties ?? {})).not.toContain("yq"); + expect(Object.keys(properties ?? {})).not.toContain("as"); + } + }); + it("SY24c: describes completely enough to copy the invocation", function* () { const catalog = yield* catalogFor({}, []); diff --git a/packages/core/tests/yaml-component.test.ts b/packages/core/tests/yaml-component.test.ts new file mode 100644 index 000000000..695096210 --- /dev/null +++ b/packages/core/tests/yaml-component.test.ts @@ -0,0 +1,324 @@ +/** + * Tier YAML — `` (spec §6.12). + * + * Two halves, for the same reason ``'s cases have two. The first is what + * the text says and what parses back out of it, driven through real expansion + * of authored source against the real engine. The second is what a document + * cannot safely write: the operands there are hostile on purpose — a cycle, a + * `toJSON` that throws, a getter that counts its own reads — and Markdown has + * no way to express them without teaching the wrong thing. + * + * What is deliberately checked side by side is that `` and `` + * describe *one* value. Both render the same binding, both are parsed back, and + * the two readings are compared with the binding itself — so a formatting + * choice that changed a type would fail here rather than in whatever read the + * YAML later. + */ + +import { beforeAll, describe, it } from "@executablemd/test-support/bdd"; +import { expect } from "@executablemd/test-support/expect"; +import { Err, Ok, ensure, scoped, until } from "effection"; +import type { Operation, Result } from "effection"; +import { mkdtemp, realpath } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { rm, writeTextFile } from "@effectionx/fs"; +import { useHostFiles } from "@executablemd/runtime"; +import { InMemoryStream } from "@executablemd/durable-streams"; +import type { Json } from "@executablemd/durable-streams"; + +import { collect } from "../src/collect.ts"; +import { execute } from "../src/execute.ts"; +import { registerComponents } from "../src/components/registration.ts"; +import { useTempFileCompiler } from "../src/temp-file-compiler.ts"; +import { createValueQuery } from "../src/value-query.ts"; +import type { ComponentRegistration } from "../src/components/registration.ts"; + +/** A directory for one case's document, removed when the case ends. */ +function* useFixture(): Operation { + const made = yield* until(mkdtemp(join(tmpdir(), "yaml-component-"))); + yield* ensure(() => rm(made, { recursive: true, force: true })); + return yield* until(realpath(made)); +} + +/** + * A registered source for an operand a document cannot write. + * + * Its return binds by reference, so what reaches `` is this exact object + * — which is what makes a cycle, a hook and a getter reachable at all. + */ +function source(value: unknown): ComponentRegistration { + return { + name: "Source", + origin: "yaml-component-test", + props: { type: "object", properties: {}, additionalProperties: false }, + // deno-lint-ignore require-yield + *fn(): Operation { + return value; + }, + }; +} + +/** Run `source` as a document, with `extra` registered. */ +function run(body: string, extra: readonly ComponentRegistration[] = []): Operation> { + return scoped(function* () { + const root = yield* useFixture(); + yield* useHostFiles(); + if (extra.length > 0) { + yield* registerComponents([...extra]); + } + yield* writeTextFile(join(root, "doc.md"), body); + try { + return Ok( + yield* collect( + yield* execute({ path: join(root, "doc.md"), stream: new InMemoryStream() }), + ), + ); + } catch (error) { + return Err(error instanceof Error ? error : new Error(String(error))); + } + }); +} + +/** The rendered text of a successful run. */ +function text(outcome: Result): string { + if (!outcome.ok) { + throw outcome.error; + } + return String(outcome.value); +} + +/** + * What one refused invocation said. + * + * `` declares `printErrors`, like ``: a malformed invocation is a + * printed error in the document rather than a failed run, which is what keeps + * one bad element from taking the rest of the page with it. So what a case + * reads is the text the document ended up with — and a run that genuinely + * failed is reported as that instead. + */ +function reason(outcome: Result): string { + return outcome.ok ? String(outcome.value) : outcome.error.message; +} + +/** Parse YAML back, through the same engine the component rendered it with. */ +function* fromYaml(yaml: string): Operation { + const owner = createValueQuery(); + try { + return yield* owner.select("from_yaml", yaml); + } finally { + owner.close(); + } +} + +/** + * E9's representative value. + * + * One value rather than a schema suite: nested structure, the two scalars whose + * YAML spelling decides their type, a number, a string that reads as a number, + * and a multiline string whose whole point is that it survives. + */ +const REPRESENTATIVE = { + name: "widget", + count: 2, + ready: false, + missing: null, + version: "1.20", + truthy: "false", + tags: ["a", "b"], + nested: { deep: { ok: true }, list: [1, [2]] }, + note: "first\nsecond", +}; + +describe("Tier YAML — what the text says", () => { + beforeAll(() => useTempFileCompiler()); + + it("Y1: Json and Yaml describe one value, and both parse back to it", function* () { + const outcome = yield* run( + [ + '', + "", + '', + '', + "", + "", + "{json}", + "--", + "{yaml}", + "", + "", + ].join("\n"), + [source(REPRESENTATIVE)], + ); + + const rendered = text(outcome); + const [json, yaml] = rendered.split("\n--\n"); + expect(json).toBeDefined(); + expect(yaml).toBeDefined(); + // The same value from both readings, and the same as the binding: a + // formatting choice that changed a type fails here. + expect(JSON.parse(String(json))).toEqual(REPRESENTATIVE); + expect(yield* fromYaml(String(yaml).trimStart())).toEqual(REPRESENTATIVE); + }); + + it("Y1: Json's exact text is unchanged", function* () { + const outcome = yield* run('\n\n\n', [ + source({ name: "widget", version: 2, tags: ["a", "b"] }), + ]); + + // The layout `` has always had, restated here because this change + // moved the one serialization call both components share. + expect(text(outcome).trim()).toBe( + [ + "{", + ' "name": "widget",', + ' "version": 2,', + ' "tags": [', + ' "a",', + ' "b"', + " ]", + "}", + ].join("\n"), + ); + }); + + it("Y1: Yaml is a complete document: two-space, no separators, one final LF", function* () { + const outcome = yield* run( + '\n\n\n\n{yaml}', + [source({ name: "widget", tags: ["a", "b"], nested: { deep: true } })], + ); + + const rendered = text(outcome); + const yaml = rendered.slice(rendered.indexOf("name:")); + expect(yaml).toBe( + ["name: widget", "tags:", " - a", " - b", "nested:", " deep: true", ""].join("\n"), + ); + // The vendor's own terminating newline, and exactly one of it: nothing + // appends a separator or a second line. + expect(yaml.endsWith("\n")).toBe(true); + expect(yaml.endsWith("\n\n")).toBe(false); + expect(yaml).not.toContain("---"); + }); + + it("Y1: a scalar whose type depends on quoting keeps it", function* () { + const outcome = yield* run( + '\n\n\n\n{yaml}', + [source({ truthy: "false", version: "1.20", note: "a\nb" })], + ); + + const rendered = text(outcome); + const yaml = rendered.slice(rendered.indexOf("truthy:")); + // Quoted where the type depends on it, and a block scalar for the + // multiline string — which is what makes the parse-back above exact. + expect(yaml).toContain('truthy: "false"'); + expect(yaml).toContain('version: "1.20"'); + expect(yield* fromYaml(yaml)).toEqual({ truthy: "false", version: "1.20", note: "a\nb" }); + }); + + it("Y1: rendering twice does not change the binding", function* () { + const payload = { name: "widget", tags: ["a"] }; + const outcome = yield* run( + [ + '', + "", + '', + "", + '', + "", + "", + "{first}--{second}", + "", + "", + ].join("\n"), + [source(payload)], + ); + + const [first, second] = text(outcome).split("--"); + expect(String(first).trim().length).toBeGreaterThan(0); + // The same text both times, from the same value: nothing the first + // rendering did changed what the second one described. Compared on the + // document's own surrounding whitespace rather than through it, because + // what is being asked about is the two renderings. + expect(String(second).trim()).toBe(String(first).trim()); + expect(payload).toEqual({ name: "widget", tags: ["a"] }); + }); +}); + +describe("Tier YAML — an invocation it cannot render", () => { + beforeAll(() => useTempFileCompiler()); + + it("Y2: a missing value fails, and names the prop", function* () { + expect(reason(yield* run("\n"))).toContain("requires a `value` prop"); + }); + + it("Y2: paired content fails, and says what it renders instead", function* () { + expect(reason(yield* run("text\n"))).toContain("not content"); + }); + + it("Y2: an unknown prop fails against its own closed schema", function* () { + expect(reason(yield* run("\n"))).toContain("indent"); + }); + + it("Y2: an invalid as fails before anything renders", function* () { + expect(reason(yield* run('\n'))).toContain('"as"'); + }); + + it("Y2: an undefined operand has no JSON text at all", function* () { + const outcome = yield* run('\n\n\n', [ + source(undefined), + ]); + expect(reason(outcome)).toContain("produced no JSON text"); + }); + + it("Y2: a cycle is a serialization that started and could not finish", function* () { + const cycle: Record = { name: "widget" }; + cycle.self = cycle; + const outcome = yield* run('\n\n\n', [ + source(cycle), + ]); + expect(reason(outcome)).toContain("serialization of this value failed"); + }); + + it("Y2: a throwing toJSON is read once and reported as that failure", function* () { + let hooks = 0; + const outcome = yield* run('\n\n\n', [ + source({ + toJSON() { + hooks += 1; + throw new Error("this hook refuses"); + }, + }), + ]); + + expect(reason(outcome)).toContain("serialization of this value failed"); + // One call, never repeated to describe the failure: the hook is the + // document's own code and asking twice would run it twice. + expect(hooks).toBe(1); + }); + + it("Y2: a counting getter is read exactly once", function* () { + let reads = 0; + const outcome = yield* run( + '\n\n\n\n{yaml}', + [ + source({ + get name(): string { + reads += 1; + return "widget"; + }, + }), + ], + ); + + expect(text(outcome)).toContain("name: widget"); + expect(reads).toBe(1); + }); + + it("Y2: a failed render binds nothing and renders nothing", function* () { + const outcome = yield* run( + '\n\n\n\n{yaml}\n', + [source(undefined)], + ); + expect(reason(outcome)).toContain("produced no JSON text"); + }); +}); diff --git a/packages/core/tests/yq-component.test.ts b/packages/core/tests/yq-component.test.ts new file mode 100644 index 000000000..1781ac900 --- /dev/null +++ b/packages/core/tests/yq-component.test.ts @@ -0,0 +1,939 @@ +/** + * Tier YQ — selecting out of what a component returned (spec §6.21). + * + * `yq` is one shared invocation attribute, so what these cases discriminate is + * the engine's own route rather than any producer's: when the engine is built, + * what one answer may be, where the selection sits between acceptance and + * binding, and what an invocation that wrote a query renders when it captures + * nothing. + * + * Three harnesses, and they answer different questions. The owner is driven + * directly where the question is about initialization — how many compilations one + * execution starts, whether two first consumers share one, and what a halted + * consumer does with an engine that arrives afterwards — because those are + * facts about that object and a document cannot observe them. Real `execute` + * with real host files drives everything about the route. And one controlled + * evaluator appears exactly once, for the non-JSON answer a normal vendor reply + * never produces. + */ + +import { beforeAll, describe, it } from "@executablemd/test-support/bdd"; +import { expect } from "@executablemd/test-support/expect"; +import { Err, Ok, ensure, scoped, spawn, until } from "effection"; +import type { Operation, Result, Task } from "effection"; +import { mkdtemp, realpath } from "node:fs/promises"; +import { tmpdir } from "node:os"; +import { join } from "node:path"; +import { rm, writeTextFile } from "@effectionx/fs"; +import { API, useHostFiles } from "@executablemd/runtime"; +import { FilesOperationDeniedError, parseFilesFatal } from "@executablemd/runtime/files"; +import { InMemoryStream } from "@executablemd/durable-streams"; +import type { DurableEvent, Json } from "@executablemd/durable-streams"; + +import { collect } from "../src/collect.ts"; +import { execute, executeInstalled } from "../src/execute.ts"; +import { registerComponents } from "../src/components/registration.ts"; +import { scanSegments } from "../src/scanner.ts"; +import { useTempFileCompiler } from "../src/temp-file-compiler.ts"; +import { parseRootBindingPublication } from "../src/root-binding-publications.ts"; +import { fatalCause } from "../src/errors.ts"; +import { createYq } from "yq.rs/loader"; +import type { Yq } from "yq.rs/loader"; +import { createValueQuery, ONE_VALUE } from "../src/value-query.ts"; +import type { EngineFactory } from "../src/value-query.ts"; +import { Component } from "../src/component-api.ts"; +import type { ComponentRegistration } from "../src/components/registration.ts"; +import type { ComponentDefinition } from "../src/types.ts"; + +/** + * A directory the contextual cwd points at, removed when the case ends. + * + * A plain generator rather than a `resource`, because what it installs has to + * belong to the *case's* frame: a resource's body is its own scope, so a + * contextual working directory established there would be invisible to the + * document the case then runs. + */ +function* useWorkspace(files: Record): Operation { + const made = yield* until(mkdtemp(join(tmpdir(), "yq-component-"))); + yield* ensure(() => rm(made, { recursive: true, force: true })); + const root = yield* until(realpath(made)); + for (const [name, content] of Object.entries(files)) { + yield* writeTextFile(join(root, name), content); + } + yield* API.Env.around( + { + *cwd() { + return root; + }, + }, + { at: "min" }, + ); + return root; +} + +/** What one run produced, what its journal holds, and what it reached. */ +interface Run { + readonly outcome: Result; + readonly stream: InMemoryStream; + /** Every filesystem operation that crossed the provider boundary, in order. */ + readonly crossed: readonly string[]; +} + +/** What a case makes resolvable beside core's own components. */ +interface Supplied { + /** Function components, registered the way a package registers one. */ + readonly registered?: readonly ComponentRegistration[]; + /** Markdown definitions, answered through the ordinary import chain. */ + readonly markdown?: readonly ComponentDefinition[]; +} + +/** Run `source` as a document in `root`, with `supplied` resolvable. */ +function runDocument(root: string, source: string, supplied: Supplied = {}): Operation { + return scoped(function* () { + const crossed: string[] = []; + // Counted where the operation actually crosses, because an ordinary `xmd + // run` journals no file work: what proves a producer ran once is the + // provider boundary it ran through. + yield* API.Files.around({ + *readTextFile([input], next) { + crossed.push(`read:${input.path}`); + return yield* next(input); + }, + *globFiles([input], next) { + crossed.push("glob"); + return yield* next(input); + }, + }); + yield* useHostFiles(); + if (supplied.registered !== undefined && supplied.registered.length > 0) { + yield* registerComponents([...supplied.registered]); + } + const definitions = new Map( + (supplied.markdown ?? []).map((definition) => [definition.name, definition]), + ); + if (definitions.size > 0) { + yield* Component.around({ + *importComponent([name, position], next) { + const held = definitions.get(name); + return held === undefined ? yield* next(name, position) : held; + }, + }); + } + const stream = new InMemoryStream(); + yield* writeTextFile(join(root, "doc.md"), source); + let outcome: Result; + try { + outcome = Ok(yield* collect(yield* execute({ path: join(root, "doc.md"), stream }))); + } catch (error) { + outcome = Err(error instanceof Error ? error : new Error(String(error))); + } + return { outcome, stream, crossed }; + }); +} + +/** The rendered text of a successful run, or the failure's own message. */ +function text(run: Run): string { + if (!run.outcome.ok) { + throw run.outcome.error; + } + return typeof run.outcome.value === "string" + ? run.outcome.value + : JSON.stringify(run.outcome.value); +} + +/** Every durable description one run appended, in order. */ +function descriptions(stream: InMemoryStream): string[] { + return stream + .snapshot() + .flatMap((event: DurableEvent) => + event.type === "yield" ? [String(event.description.type)] : [], + ); +} + +/** + * How many WebAssembly compilations happen while `body` runs. + * + * The loader compiles exactly once per engine, through the platform's own + * `WebAssembly.compile`, so counting that call is how a document's own + * execution is asked whether it started an engine at all. Restored in a + * `finally` rather than an `ensure`, because the replacement is synchronous + * state that must be back before anything else in this process compiles. + */ +function compilations(body: () => Operation): Operation<{ value: T; started: number }> { + return { + *[Symbol.iterator]() { + const original = WebAssembly.compile; + let started = 0; + WebAssembly.compile = (source: BufferSource): Promise => { + started += 1; + return original(source); + }; + try { + return { value: yield* body(), started }; + } finally { + WebAssembly.compile = original; + } + }, + }; +} + +const FIXTURE = JSON.stringify({ + records: [ + { name: "a", status: "ok" }, + { name: "b", status: "failed" }, + ], +}); + +/** E3's exact File expression, as the frozen matrix states it. */ +const FAILED_RECORDS = 'from_json | [.records[] | select(.status == "failed") | {"name": .name}]'; + +/** E3's exact Glob expression. */ +const INPUT_PATHS = '[.[] | select(. == "input.json") | {"path": .}]'; + +describe("Tier YQ — one engine per execution, built when it is wanted", () => { + beforeAll(() => useTempFileCompiler()); + + it("YQ1: a document that queries nothing and renders no YAML compiles nothing", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const counted = yield* compilations(() => + runDocument(root, '\n\n{raw.length}\n'), + ); + + expect(counted.value.outcome.ok).toBe(true); + // The claim, and the whole reason the engine is lazy: an execution that + // asked nothing of it paid for nothing. + expect(counted.started).toBe(0); + }); + + it("YQ1: two queries and one Yaml in one execution compile once", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const counted = yield* compilations(() => + runDocument( + root, + [ + ``, + "", + ``, + "", + "", + "{first}{second} ", + "", + "", + ].join("\n"), + ), + ); + + expect(counted.value.outcome.ok).toBe(true); + expect(text(counted.value).replace(/\s+/g, " ").trim()).toBe("ab a"); + expect(counted.started).toBe(1); + }); + + it("YQ1: a second independent execution builds a second engine", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const source = `\n\n{first}\n`; + const counted = yield* compilations(function* () { + const first = yield* runDocument(root, source); + const second = yield* runDocument(root, source); + return [first, second]; + }); + + expect(counted.value.map((run) => run.outcome.ok)).toEqual([true, true]); + // One each. An engine shared across executions would have outlived the one + // that paid for it, and the second execution would have compiled nothing. + expect(counted.started).toBe(2); + }); + + it("YQ1: two first consumers share one initialization", function* () { + const gate = openGate(); + const asked = openGate(); + let factories = 0; + const held: EngineFactory = function (bytes: Uint8Array) { + factories += 1; + asked.open(); + return gate.opened.then(() => realEngine(bytes)); + }; + const owner = createValueQuery(held); + + const answers: Result[] = []; + const first = yield* spawn(function* () { + answers.push(Ok(yield* owner.select(".", [1, 2]))); + }); + // The first consumer has created the pending initialization and suspended + // on it, which is the state the second one has to arrive into. Waited for + // rather than assumed: yielding a spawn says nothing about where the child + // has reached. + yield* until(asked.opened); + expect(factories).toBe(1); + const second = yield* spawn(function* () { + answers.push(Ok(yield* owner.select(".", [3, 4]))); + }); + gate.open(); + yield* first; + yield* second; + + // One compilation for two consumers: the pending promise is stored before + // the first one suspends, so the second finds it rather than starting + // another. + expect(factories).toBe(1); + expect(answers.map((answer) => answer.ok)).toEqual([true, true]); + owner.close(); + }); + + it("YQ1: an engine that arrives after a halt publishes nothing", function* () { + const gate = openGate(); + const asked = openGate(); + const reached: string[] = []; + const held: EngineFactory = (bytes: Uint8Array) => { + asked.open(); + return gate.opened.then(() => realEngine(bytes)); + }; + const owner = createValueQuery(held); + + const waiting: Task = yield* spawn(function* () { + yield* ensure(() => { + reached.push("torn down"); + }); + yield* owner.select(".", [1, 2]); + // Never reached: the continuation past `until` is exactly what a halt + // prevents, however the vendor's own promise settles. + reached.push("published"); + }); + // Halted while the initialization is genuinely pending, which is the state + // this is about — not before the consumer started. + yield* until(asked.opened); + yield* waiting.halt(); + // Resolved after the halt, which is the case `until` cannot cancel. + gate.open(); + yield* until(gate.opened); + + expect(reached).toEqual(["torn down"]); + owner.close(); + }); + + it("YQ1: an owner revoked with its execution refuses", function* () { + const owner = createValueQuery(); + expect(yield* owner.select(".", 1)).toBe(1); + owner.close(); + let refusal: string | undefined; + try { + yield* owner.select(".", 1); + } catch (error) { + refusal = error instanceof Error ? error.message : String(error); + } + expect(refusal).toContain("no longer available"); + }); +}); + +/** A real engine for the controlled-factory cases above. */ +function realEngine(bytes: Uint8Array): Promise { + return createYq(bytes); +} + +/** + * A promise a case opens by hand. + * + * The factory this gates returns a promise, so what holds it open has to be one + * too: an Effection resolver would never be observed by the vendor contract + * this stands in for. + */ +function openGate(): { readonly opened: Promise; open: () => void } { + let open = (): void => {}; + const opened = new Promise((resolve) => { + open = () => resolve(); + }); + return { opened, open: () => open() }; +} + +describe("Tier YQ — what one answer may be", () => { + beforeAll(() => useTempFileCompiler()); + + /** One selection through the real pinned loader. */ + function* selected(expression: string, value: unknown): Operation> { + const owner = createValueQuery(); + try { + return Ok(yield* owner.select(expression, value)); + } catch (error) { + return Err(error instanceof Error ? error : new Error(String(error))); + } finally { + owner.close(); + } + } + + it("YQ2: a field selection, and the four answers that are values", function* () { + expect( + yield* selected("from_json | .scripts", JSON.stringify({ scripts: { a: "b" } })), + ).toEqual(Ok({ a: "b" })); + // Each of these is a value a document may legitimately select, and each is + // the vendor status `evaluate` throws for — which is why selection uses + // `evaluateWithStatus` and ignores `matched`. + expect(yield* selected("null", [1, 2])).toEqual(Ok(null)); + expect(yield* selected("false", [1, 2])).toEqual(Ok(false)); + expect(yield* selected("[]", [1, 2])).toEqual(Ok([])); + expect(yield* selected('"x\\ny"', [1, 2])).toEqual(Ok("x\ny")); + }); + + it("YQ2: no results and several results each refuse with the array guidance", function* () { + const zero = yield* selected(".[] | select(. == 9)", [1, 2]); + const several = yield* selected(".[]", [1, 2]); + + expect(zero.ok).toBe(false); + expect(several.ok).toBe(false); + // One sentence for both, because an invocation that binds one value has + // the same thing to say about neither and two. + expect(zero.ok === false && zero.error.message).toBe(ONE_VALUE); + expect(several.ok === false && several.error.message).toBe(ONE_VALUE); + }); + + it("YQ2: an invalid expression binds nothing and keeps the vendor's reason", function* () { + const refused = yield* selected("!!!", [1, 2]); + + expect(refused.ok).toBe(false); + expect(refused.ok === false && refused.error.message).toContain("could not be evaluated"); + // The vendor's own account survives as the cause, for ordinary error + // handling, without being consumed as an answer. + expect(refused.ok === false && refused.error.cause).toBeDefined(); + }); + + it("YQ2: a string holding JSON stays a string until it is decoded", function* () { + const held = JSON.stringify({ count: 2 }); + // `.` over a JSON string is that string. Nothing decodes on the way in, + // which is why an expression that wants the data inside says so. + expect(yield* selected(".", held)).toEqual(Ok(held)); + expect(yield* selected("from_json | .count", held)).toEqual(Ok(2)); + expect(yield* selected("from_yaml | .count", "count: 2\n")).toEqual(Ok(2)); + }); + + it("YQ2: the engine sees no environment, no files and this host's clock never", function* () { + // The canaries are set for this process; the engine is given an empty + // environment and an empty file map, so neither is reachable through an + // expression a document or an agent wrote. + const canary = yield* selected("env(XMD_YQ_CANARY)", [1]); + const file = yield* selected('load("/etc/passwd")', [1]); + + expect(canary.ok).toBe(false); + expect(canary.ok === false && canary.error.message).toContain("not provided"); + expect(file.ok).toBe(false); + expect(yield* selected("now", [1])).toEqual(Ok("1970-01-01T00:00:00Z")); + }); + + it("YQ2: a non-JSON answer with partial output is refused rather than consumed", function* () { + // The one controlled evaluator in this file. A real vendor answer under + // JSON output is always JSON, so the only way to ask what happens to one + // that is not is to supply it — and what must not happen is a partial + // reading becoming a bound value. + const owner = createValueQuery(() => + Promise.resolve({ + evaluate: () => "", + evaluateSequenceWithStatus: () => ({ output: "", matched: false }), + evaluateWithStatus: () => ({ output: "{ half", matched: true }), + }), + ); + let refusal: string | undefined; + try { + yield* owner.select(".", [1]); + } catch (error) { + refusal = error instanceof Error ? error.message : String(error); + } + expect(refusal).toBe(ONE_VALUE); + owner.close(); + }); +}); + +describe("Tier YQ — two real producers select before they bind", () => { + beforeAll(() => useTempFileCompiler()); + + it("YQ3: File and Glob each run once and bind what their expression selected", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const run = yield* runDocument( + root, + [ + ``, + "", + ``, + "", + "", + "", + "", + "", + "", + ].join("\n"), + ); + + expect(run.outcome.ok).toBe(true); + // The selected data, as the frozen matrix states it — and what the document + // renders is the *binding*, so what reached it is the value rather than the + // text the producer returned. + const rendered = text(run); + expect(JSON.parse(rendered.slice(rendered.indexOf("["), rendered.indexOf("]") + 1))).toEqual([ + { name: "b" }, + ]); + expect(rendered).toContain('"path": "input.json"'); + // One read and one search, and the raw file text is nowhere in the + // document: a query is not a second operation and the original return is + // not what was bound. + expect(run.crossed).toEqual(["read:input.json", "glob"]); + expect(rendered).not.toContain("status"); + }); + + it("YQ3: a closed props schema accepts a queried invocation without seeing yq", function* () { + const root = yield* useWorkspace({}); + // `additionalProperties: false`, and the invocation writes `yq`. The engine + // consumes it before this schema is checked, so the producer never sees it. + const run = yield* runDocument( + root, + `\n\n{picked}\n`, + { registered: [closedProducer()] }, + ); + + expect(run.outcome.ok).toBe(true); + expect(text(run).trim()).toBe("yes"); + }); + + it("YQ3: a non-string yq refuses before the producer runs", function* () { + const root = yield* useWorkspace({}); + const calls = { count: 0 }; + const run = yield* runDocument(root, `\n\n{picked}\n`, { + registered: [countedProducer(calls)], + }); + + expect(run.outcome.ok).toBe(false); + expect(run.outcome.ok === false && run.outcome.error.message).toContain('Prop "yq"'); + expect(calls.count).toBe(0); + }); + + it("YQ3: an invalid as refuses before the producer runs, query or no query", function* () { + const root = yield* useWorkspace({}); + const calls = { count: 0 }; + const run = yield* runDocument(root, `\n`, { + registered: [countedProducer(calls)], + }); + + expect(run.outcome.ok).toBe(false); + expect(calls.count).toBe(0); + }); + + it("YQ3: an uncaptured returns component still refuses required-as with a query", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const calls = { count: 0 }; + const run = yield* runDocument(root, `\n`, { + registered: [countedProducer(calls)], + }); + + expect(run.outcome.ok).toBe(false); + expect(run.outcome.ok === false && run.outcome.error.message).toContain("`returns`"); + // Before effects: a query is not a destination, and a component that + // renders nothing still has nowhere to put what it produced. + expect(calls.count).toBe(0); + }); + + it("YQ3: an uncaptured Glob with a query keeps its own refusal", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const run = yield* runDocument(root, `\n`); + + expect(run.outcome.ok).toBe(false); + expect(descriptions(run.stream)).not.toContain("glob"); + }); +}); + +describe("Tier YQ — acceptance, teardown, then selection", () => { + beforeAll(() => useTempFileCompiler()); + + it("YQ4: a Markdown value body's own schema accepts first, and its cleanup finishes", function* () { + const root = yield* useWorkspace({}); + const run = yield* runDocument(root, `\n\n{picked}\n`, { + markdown: [recordComponent()], + }); + + expect(run.outcome.ok).toBe(true); + // An object under its own `returns`, then a scalar after the query. The + // selection happens after acceptance, so the schema never saw the scalar. + expect(text(run).trim()).toBe("widget"); + }); + + it("YQ4: no expression repairs a return its own schema rejected", function* () { + const root = yield* useWorkspace({}); + const run = yield* runDocument(root, `\n`, { + markdown: [wrongComponent()], + }); + + expect(run.outcome.ok).toBe(false); + // The original validation's own refusal, not a query failure: `yq='1'` + // would have produced a valid answer, and it is never asked. + expect(run.outcome.ok === false && run.outcome.error.message).not.toContain("yq"); + }); + + it("YQ4: a function component's query runs after its invocation joined", function* () { + const root = yield* useWorkspace({}); + const order: string[] = []; + const run = yield* runDocument(root, `\n\n{picked}\n`, { + registered: [joinedProducer(order)], + }); + + expect(run.outcome.ok).toBe(true); + expect(text(run).trim()).toBe("widget"); + // Teardown before selection, which is what "the producer's own cleanup + // finishes first" means where a reader can see it. + expect(order).toEqual(["body", "teardown"]); + }); + + it("YQ4: a teardown failure prevents the selection and the capture", function* () { + const root = yield* useWorkspace({}); + const run = yield* runDocument(root, `\n\n{picked}\n`, { + registered: [breakingProducer()], + }); + + expect(run.outcome.ok).toBe(false); + }); + + it("YQ4: a Files infrastructure failure stays fatal through a query", function* () { + const root = yield* useWorkspace({}); + const run = yield* runDocument(root, `\n\n{picked}\n`, { + registered: [deniedProducer()], + }); + + expect(run.outcome.ok).toBe(false); + const raised = run.outcome.ok ? undefined : run.outcome.error; + // Still the same infrastructure failure, by identity and by its own fixed + // diagnostic. The selection route is a place this failure passed through + // rather than a place it was described: a build that had wrapped it as a + // query refusal, or printed it and carried on, would answer differently + // here and would have let the document report it as its own. + expect(parseFilesFatal(fatalCause(raised))).toEqual({ + type: "executablemd.runtime.files-fatal/v1", + kind: "operation-denied", + operation: "temporary-directory", + }); + expect(raised?.message).not.toContain("yq"); + // Nothing was selected, bound or published: the failure happened in the + // producer, so there was never a result for an expression to read. + expect(descriptions(run.stream)).not.toContain("root_binding_publication"); + }); + + it("YQ4: a queried rendering emits only its selected string", function* () { + const root = yield* useWorkspace({}); + // The body renders text that looks like a marker. Queried, only the + // selected string reaches the document; unqueried, the body's own text + // does, exactly as it always did. + const queried = yield* runDocument(root, `\n`, { + markdown: [sentenceComponent()], + }); + const ordinary = yield* runDocument(root, `\n`, { + markdown: [sentenceComponent()], + }); + + expect(queried.outcome.ok).toBe(true); + expect(text(queried).trim()).toBe("kept"); + expect(text(queried)).not.toContain("RAW-MARKER"); + expect(ordinary.outcome.ok).toBe(true); + expect(text(ordinary)).toContain("RAW-MARKER"); + }); +}); + +describe("Tier YQ — what a root publication retains", () => { + beforeAll(() => useTempFileCompiler()); + + it("YQ5: the retained publication holds the selected value, not the original", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const stream = new InMemoryStream(); + const outcome = yield* scoped(function* () { + yield* useHostFiles(); + yield* writeTextFile( + join(root, "doc.md"), + `\n\n{failed.length}\n`, + ); + return yield* yield* executeInstalled({ path: join(root, "doc.md"), stream }, [], { + rootBindingPublications: "json-v1", + }); + }); + + expect(outcome.ok).toBe(true); + const published = stream + .snapshot() + .filter( + (event: DurableEvent) => + event.type === "yield" && event.description.type === "root_binding", + ); + expect(published.length).toBe(1); + const held = published[0]; + const retained = + held !== undefined && held.type === "yield" && held.result.status === "ok" + ? held.result.value + : undefined; + // The selected data crossed, through the publisher's own protocol: no new + // record family, and nothing of the text the producer returned. + expect(JSON.stringify(retained)).toContain('"name":"b"'); + expect(JSON.stringify(retained)).not.toContain("status"); + }); +}); + +/** A producer whose closed schema would reject an extra prop. */ +function closedProducer(): ComponentRegistration { + return { + name: "Closed", + origin: "yq-component-test", + props: { + type: "object", + properties: { label: { type: "string" } }, + required: ["label"], + additionalProperties: false, + }, + returns: { type: "object", properties: { kept: { type: "string" } }, required: ["kept"] }, + // deno-lint-ignore require-yield + *fn(): Operation { + return { kept: "yes" }; + }, + }; +} + +/** A producer that counts whether it ran at all. */ +function countedProducer(calls: { count: number }): ComponentRegistration { + return { + name: "Counted", + origin: "yq-component-test", + props: { type: "object", properties: {}, additionalProperties: false }, + returns: { type: "object", properties: { kept: { type: "string" } }, required: ["kept"] }, + // deno-lint-ignore require-yield + *fn(): Operation { + calls.count += 1; + return { kept: "yes" }; + }, + }; +} + +/** A Markdown value body whose own `returns` accepts an object. */ +function recordComponent(): ComponentDefinition { + return { + kind: "markdown", + name: "Record", + path: "components/Record.md", + meta: {}, + props: { type: "object", properties: {}, additionalProperties: false }, + returns: { + type: "object", + properties: { name: { type: "string" } }, + required: ["name"], + additionalProperties: false, + }, + bodySegments: scanSegments('\n'), + }; +} + +/** A Markdown value body whose return its own schema rejects. */ +function wrongComponent(): ComponentDefinition { + return { + kind: "markdown", + name: "Wrong", + path: "components/Wrong.md", + meta: {}, + props: { type: "object", properties: {}, additionalProperties: false }, + returns: { + type: "object", + properties: { name: { type: "string" } }, + required: ["name"], + additionalProperties: false, + }, + bodySegments: scanSegments("\n"), + }; +} + +/** A function producer that records when its own cleanup finished. */ +function joinedProducer(order: string[]): ComponentRegistration { + return { + name: "Joined", + origin: "yq-component-test", + props: { type: "object", properties: {}, additionalProperties: false }, + returns: { + type: "object", + properties: { name: { type: "string" } }, + required: ["name"], + additionalProperties: false, + }, + *fn(): Operation { + yield* ensure(() => { + order.push("teardown"); + }); + order.push("body"); + return { name: "widget" }; + }, + }; +} + +/** A function producer whose cleanup fails after a valid result. */ +function breakingProducer(): ComponentRegistration { + return { + name: "Breaking", + origin: "yq-component-test", + props: { type: "object", properties: {}, additionalProperties: false }, + returns: { + type: "object", + properties: { name: { type: "string" } }, + required: ["name"], + additionalProperties: false, + }, + *fn(): Operation { + yield* ensure(function* () { + throw new Error("this producer's cleanup failed"); + }); + return { name: "widget" }; + }, + }; +} + +/** + * A producer whose work is refused by the Files provider. + * + * The real refusal object rather than an ordinary Error: what the classification + * is about is whether the failure that reaches the boundary is still recognized + * as infrastructure, and recognition is structural. + */ +function deniedProducer(): ComponentRegistration { + return { + name: "Denied", + origin: "yq-component-test", + props: { type: "object", properties: {}, additionalProperties: false }, + // deno-lint-ignore require-yield + *fn(): Operation { + throw new FilesOperationDeniedError("temporary-directory"); + }, + }; +} + +/** A Markdown body whose rendering holds text a reader must not see. */ +function sentenceComponent(): ComponentDefinition { + return { + kind: "markdown", + name: "Sentence", + path: "components/Sentence.md", + meta: {}, + props: { type: "object", properties: {}, additionalProperties: false }, + bodySegments: scanSegments('{"kept":"kept","raw":"RAW-MARKER"}\n'), + }; +} + +/** + * Tier YQ6 — what a refused selected publication binds. + * + * A queried root capture is published through the ordinary durable path, so the + * append fence applies to it like any other effect. What this case is about is + * the one ordering that matters: the capture is downstream of the append, so an + * append that cannot be written binds nothing and leaves the last publication + * standing. + * + * The cross-entry half of this row — what the next REPL entry actually inherits + * — belongs to the REPL's own segmentation and is in + * `packages/cli/tests/repl-entries.test.ts`. + */ +describe("Tier YQ6 — a refused selected publication", () => { + beforeAll(() => useTempFileCompiler()); + + /** One entry at the end of `physical`, with the retention a REPL entry states. */ + function entry(root: string, source: string, physical: InMemoryStream): Operation> { + return scoped(function* () { + yield* useHostFiles(); + yield* writeTextFile(join(root, "doc.md"), source); + try { + return yield* yield* executeInstalled( + { path: join(root, "doc.md"), stream: physical }, + [], + { rootBindingPublications: "json-v1" }, + ); + } catch (error) { + return Err(error instanceof Error ? error : new Error(String(error))); + } + }); + } + + /** The selected values this journal retained, by binding. */ + function retained(physical: InMemoryStream): Record { + const held: Record = {}; + for (const event of physical.snapshot()) { + if (event.type !== "yield" || event.description.type !== "root_binding") { + continue; + } + const publication = parseRootBindingPublication(event); + if (publication.ok && publication.value.publication.kind === "json") { + held[publication.value.binding] = publication.value.publication.value; + } + } + return held; + } + + it("YQ6: the publication retains the selected value and not the producer's text", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const physical = new InMemoryStream(); + const outcome = yield* entry( + root, + `\n\n{failed.length}\n`, + physical, + ); + + expect(outcome.ok).toBe(true); + expect(retained(physical)).toEqual({ failed: [{ name: "b" }] }); + // What the selection replaced did not cross. + expect(JSON.stringify(retained(physical))).not.toContain("status"); + }); + + it("YQ6: mutating the binding afterwards does not move what was retained", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const physical = new InMemoryStream(); + const outcome = yield* entry( + root, + [ + ``, + "", + "```js eval", + 'failed.push({ name: "later" });', + "const count = failed.length;", + "```", + "", + "{count}", + "", + ].join("\n"), + physical, + ); + + expect(outcome.ok).toBe(true); + // Two in the entry that mutated it, one in what was published: the + // publication is a detached snapshot taken before the block ran. + expect(String(outcome.ok && outcome.value)).toContain("2"); + expect(retained(physical)).toEqual({ failed: [{ name: "b" }] }); + }); + + it("YQ6: a refused append binds nothing and leaves the earlier publication standing", function* () { + const root = yield* useWorkspace({ "input.json": FIXTURE }); + const physical = new InMemoryStream(); + + // Two selected captures in one entry. The first publishes; the second's + // append is refused, and the capture is downstream of that append — so the + // second binds nothing and the sentinel after it never renders. + let refusals = 0; + physical.onAppend = (event) => { + if (event.type === "yield" && event.description.type === "root_binding") { + refusals += 1; + if (refusals > 1) { + throw new Error("this journal cannot accept the publication"); + } + } + }; + const outcome = yield* entry( + root, + [ + ``, + "", + ``, + "", + "sentinel {second}", + "", + ].join("\n"), + physical, + ); + physical.onAppend = null; + + expect(outcome.ok).toBe(false); + // The first publication stands; the refused one wrote nothing. A failed + // append is a durability failure rather than an accepted capture, so + // nothing after it ran either. + expect(retained(physical)).toEqual({ first: "a" }); + expect(String(outcome.ok === false && outcome.error.message)).not.toContain("sentinel"); + }); +}); diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index 9b0a09b2b..da340174a 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -316,6 +316,9 @@ importers: unist-util-select: specifier: ^5 version: 5.1.0 + yq.rs: + specifier: 0.1.0 + version: 0.1.0 packages/durable-streams: dependencies: @@ -3005,6 +3008,11 @@ packages: resolution: {integrity: sha512-D1mvvtDG0L5ft/jGWkLpG1+m0eQxOfaBvTNELraWj22wSVUMWxZUvYgJYcKh6jGGIkJFhH4IZPQhR4TKpc8mBw==} engines: {node: '>=10'} + yq.rs@0.1.0: + resolution: {integrity: sha512-on2F3W24SipMbxPDgbEZnpxC2bll6Zssc8b3hFupcuF/AcGtLZZm+qPfekhTZIBbWmZjL/XL/uq5oIioZBODww==} + engines: {node: '>=22'} + hasBin: true + zod@4.3.6: resolution: {integrity: sha512-rftlrkhHZOcjDwkGlnUtZZkvaPHCsDATp4pGpuOOMDaTdDDXF91wuVDJoWoPsKX/3YPQ5fHuF3STjcYyKr+Qhg==} @@ -5267,6 +5275,8 @@ snapshots: y18n: 5.0.8 yargs-parser: 20.2.9 + yq.rs@0.1.0: {} + zod@4.3.6: {} zod@4.4.3: {} diff --git a/scripts/build-npm.ts b/scripts/build-npm.ts index 6519042c6..1eddbeee1 100644 --- a/scripts/build-npm.ts +++ b/scripts/build-npm.ts @@ -62,15 +62,33 @@ import { tmpdir } from "node:os"; import { z } from "npm:zod@^4"; /** - * The documents a package ships, as package-relative paths. + * The non-TypeScript assets a package ships, as package-relative paths. * - * `src/documents/` and nothing else. Packages keep test documents and scenario - * fixtures under `src/` as well, so publishing every Markdown found there would - * ship a package full of fixtures; being in this one directory is what declares - * a document part of the product. + * Two kinds, and they are shipped for different reasons. A **document** is part + * of the product: `src/documents/` and the `components.md` beside each + * registration boundary, and nothing else — packages keep test documents and + * scenario fixtures under `src/` as well, so publishing every Markdown found + * there would ship a package full of fixtures. + * + * An **attribution** accompanies bytes the package carries from somebody else. + * Core's generated `yq` module is the published WebAssembly of `yq.rs`, and the + * vendor's own license and third-party notices travel beside it because that is + * what distributing those bytes requires. They are not runtime inputs: nothing + * reads them, and the engine's bytes are in the module graph. */ -function* packagedDocuments(pkgDir: URL): Operation { +function* packagedAssets(pkgDir: URL): Operation { const shipped: string[] = []; + // Named individually, because attribution is a decision rather than a layout: + // a sweep would ship whatever happened to be in the directory. + for (const relative of [ + "src/yq-wasm.provenance.json", + "src/yq-vendor-notices/LICENSE", + "src/yq-vendor-notices/THIRD_PARTY_NOTICES.md", + ]) { + if (yield* exists(new URL(relative, pkgDir))) { + shipped.push(relative); + } + } // Component documentation lives beside the registration boundary it // documents rather than in `src/documents/`, because that is where the // components are and moving it would separate the two things that have to @@ -430,7 +448,7 @@ function* buildPackage(pkgArg: string, version: string, ctx: BuildContext): Oper // TypeScript imports would be absent from the published package while the // source checkout kept working — the command would find nothing at runtime, // on Node and Bun only. - for (const asset of yield* packagedDocuments(pkgDir)) { + for (const asset of yield* packagedAssets(pkgDir)) { const target = new URL(`esm/${asset}`, outDir); yield* ensureDir(fromFileUrl(new URL(".", target))); yield* copyFile(new URL(asset, pkgDir), target); diff --git a/scripts/generate-yq-wasm.ts b/scripts/generate-yq-wasm.ts new file mode 100644 index 000000000..7621107cc --- /dev/null +++ b/scripts/generate-yq-wasm.ts @@ -0,0 +1,271 @@ +/** + * Generate the committed byte module for the pinned `yq.rs` WebAssembly engine. + * + * The engine core queries values with is `yq.rs`, and the package publishes two + * entries. Its root and `./inline` compile an embedded module and instantiate a + * singleton while they are being evaluated, which would start a WebAssembly + * compilation in every process that imports core. `./loader` does none of that: + * it exports `createYq(source)` and compiles exactly the bytes it is handed. So + * core imports the loader and supplies the bytes from a module of its own, and + * this script is what writes that module. + * + * ## Why the bytes are committed rather than read + * + * A compiled binary and an installed npm package each carry core's own module + * graph and nothing beside it, so bytes reached through a path, a `fetch` or a + * host filesystem API would be present in a source checkout and absent in both. + * The encoded module is in the static import graph instead, which is the one + * place every distribution agrees about. + * + * ## Generation is deliberate, and a check is read-only + * + * Nothing regenerates these bytes on its way to doing something else: no build, + * no test and no check writes them, and this script installs nothing and + * resolves no dependency state. `--check` reproduces what generation would emit + * and compares, so drift is a refusal that writes nothing — which is what + * `deno task lint`'s companion check and the distribution regression read. + * + * The expectations below are the pin. A package resolving to another version, + * or to the same version with different bytes, is refused here rather than + * encoded: the integrity of the dependency is the lockfile's, and the identity + * of these exact bytes is this file's. + */ + +import { readTextFile, writeTextFile } from "@effectionx/fs"; +import { main, until } from "effection"; +import type { Operation } from "effection"; +import { createHash } from "node:crypto"; +import { mkdir, readFile } from "node:fs/promises"; +import { dirname, join } from "node:path"; +import { fileURLToPath } from "node:url"; + +/** The exact package version core is pinned to. */ +const PINNED_VERSION = "0.1.0"; + +/** The exact byte length of that version's published `dist/yq.wasm`. */ +const PINNED_BYTES = 468387; + +/** The lowercase SHA-256 of those exact bytes. */ +const PINNED_SHA256 = "97252eddd0dd7c2d80c25f8b73aec0874af954ca77ea33d8eb892c0a845eac46"; + +/** The vendor files that accompany the bytes as attribution. */ +const NOTICES = ["LICENSE", "THIRD_PARTY_NOTICES.md"] as const; + +/** + * How wide one encoded line is. + * + * The encoding is one array of string literals joined back together, because a + * single literal of six hundred thousand characters is a line no reader, diff or + * formatter handles well. The width is arbitrary and fixed: what matters is that + * generation and `--check` agree, and that the decoded bytes are unaffected. + */ +const LINE = 1024; + +const ROOT = fileURLToPath(new URL("../", import.meta.url)); +const MODULE = join(ROOT, "packages/core/src/yq-wasm.ts"); +const PROVENANCE = join(ROOT, "packages/core/src/yq-wasm.provenance.json"); +const NOTICE_DIRECTORY = join(ROOT, "packages/core/src/yq-vendor-notices"); + +/** What one generated file is, so a check and a write read one description. */ +interface Generated { + readonly path: string; + readonly label: string; + readonly content: string; +} + +function digest(bytes: Uint8Array): string { + return createHash("sha256").update(bytes).digest("hex"); +} + +/** + * The resolved package directory of the pinned engine. + * + * Resolved through package resolution rather than assembled from a layout: the + * manifest maps `./yq.wasm` to the published asset, so asking for that subpath + * is asking the package where its own WebAssembly is. The directory above + * `dist/` is the package root, which is where its manifest and notices sit. + */ +function packageDirectory(): { readonly wasm: string; readonly root: string } { + const resolved = import.meta.resolve("yq.rs/yq.wasm"); + if (!resolved.startsWith("file:")) { + throw new Error( + `yq.rs/yq.wasm resolved to ${resolved}, which is not a prepared package file. ` + + "Run `deno task setup` before generating.", + ); + } + const wasm = fileURLToPath(resolved); + return { wasm, root: dirname(dirname(wasm)) }; +} + +/** The pinned bytes, refused unless the package is the one that was pinned. */ +function* pinnedBytes(): Operation { + const { wasm, root } = packageDirectory(); + const manifest: unknown = JSON.parse(yield* readTextFile(join(root, "package.json"))); + const described = + manifest !== null && typeof manifest === "object" ? (manifest as Record) : {}; + if (described.name !== "yq.rs" || described.version !== PINNED_VERSION) { + throw new Error( + `expected yq.rs@${PINNED_VERSION}, resolved ${String(described.name)}@${String( + described.version, + )}`, + ); + } + + const bytes = new Uint8Array(yield* until(readFile(wasm))); + if (bytes.byteLength !== PINNED_BYTES) { + throw new Error(`expected ${PINNED_BYTES} bytes of WebAssembly, read ${bytes.byteLength}`); + } + const sha256 = digest(bytes); + if (sha256 !== PINNED_SHA256) { + throw new Error(`expected SHA-256 ${PINNED_SHA256}, read ${sha256}`); + } + return bytes; +} + +/** The encoded module, exactly as it is committed. */ +function byteModule(base64: string): string { + const chunks: string[] = []; + for (let at = 0; at < base64.length; at += LINE) { + chunks.push(` "${base64.slice(at, at + LINE)}",`); + } + return `/** + * The pinned \`yq.rs\` WebAssembly module, base64-encoded as immutable source. + * + * Generated by \`scripts/generate-yq-wasm.ts\` from yq.rs@${PINNED_VERSION}'s published + * \`dist/yq.wasm\` — ${PINNED_BYTES} bytes, SHA-256 + * \`${PINNED_SHA256}\`. + * \`yq-wasm.provenance.json\` records that attribution and + * \`yq-vendor-notices/\` carries the vendor's own license and notices. + * + * Do not edit. Regenerate with: + * + * \`\`\` + * deno run --allow-all scripts/generate-yq-wasm.ts + * \`\`\` + * + * This is source data and not a ready engine: nothing here decodes, compiles or + * instantiates anything. One execution's own lazy initialization decodes this + * string and hands the bytes to the loader (\`value-query.ts\`), so a document + * that queries nothing compiles nothing. + * + * The encoding is an array of lines joined back together because one literal of + * this length is a line nothing reads well. The decoded bytes are the same + * either way. + */ + +const LINES: readonly string[] = [ +${chunks.join("\n")} +]; + +/** Base64 of the exact published WebAssembly module. */ +export const YQ_WASM_BASE64: string = LINES.join(""); +`; +} + +/** What the attribution records, beside the bytes it is about. */ +function provenance(notices: readonly { name: string; sha256: string }[]): string { + return `${JSON.stringify( + { + format: 1, + package: "yq.rs", + version: PINNED_VERSION, + asset: "dist/yq.wasm", + bytes: PINNED_BYTES, + sha256: PINNED_SHA256, + license: "MIT AND Apache-2.0", + homepage: "https://github.com/taras/yq.rs#readme", + runtimeExport: "yq.rs/loader", + generator: "scripts/generate-yq-wasm.ts", + encoded: "packages/core/src/yq-wasm.ts", + notices: notices.map((notice) => ({ + path: `yq-vendor-notices/${notice.name}`, + sha256: notice.sha256, + })), + }, + null, + 2, + )}\n`; +} + +/** Every file generation produces, in a fixed order. */ +function* generated(): Operation { + const { root } = packageDirectory(); + const bytes = yield* pinnedBytes(); + + const copied: Generated[] = []; + const recorded: { name: string; sha256: string }[] = []; + for (const name of NOTICES) { + const text = yield* readTextFile(join(root, name)); + copied.push({ + path: join(NOTICE_DIRECTORY, name), + label: `packages/core/src/yq-vendor-notices/${name}`, + content: text, + }); + recorded.push({ name, sha256: digest(new TextEncoder().encode(text)) }); + } + + // Encoded through the platform's own base64, in bounded slices: one + // `String.fromCharCode(...bytes)` over four hundred thousand arguments + // overflows the call stack on every runtime this ships to. + let binary = ""; + for (let at = 0; at < bytes.byteLength; at += 0x8000) { + binary += String.fromCharCode(...bytes.subarray(at, at + 0x8000)); + } + + return [ + { path: MODULE, label: "packages/core/src/yq-wasm.ts", content: byteModule(btoa(binary)) }, + { + path: PROVENANCE, + label: "packages/core/src/yq-wasm.provenance.json", + content: provenance(recorded), + }, + ...copied, + ]; +} + +/** What a file currently holds, or nothing when it does not exist. */ +function* current(path: string): Operation { + try { + return yield* readTextFile(path); + } catch { + return undefined; + } +} + +function* check(files: readonly Generated[]): Operation { + const drifted: string[] = []; + for (const file of files) { + const held = yield* current(file.path); + if (held === undefined) { + drifted.push(`${file.label}: missing`); + } else if (held !== file.content) { + drifted.push(`${file.label}: differs from what the pinned package generates`); + } + } + if (drifted.length > 0) { + throw new Error( + `generated yq assets are out of date:\n ${drifted.join( + "\n ", + )}\n\nRegenerate with: deno run --allow-all scripts/generate-yq-wasm.ts`, + ); + } + console.log(`generated yq assets match yq.rs@${PINNED_VERSION} (${files.length} files)`); +} + +function* write(files: readonly Generated[]): Operation { + yield* until(mkdir(NOTICE_DIRECTORY, { recursive: true })); + for (const file of files) { + yield* writeTextFile(file.path, file.content); + console.log(`wrote ${file.label}`); + } +} + +await main(function* () { + const checking = Deno.args.includes("--check"); + const unknown = Deno.args.filter((argument) => argument !== "--check"); + if (unknown.length > 0) { + throw new Error(`unexpected argument ${unknown[0]} — this script takes only --check`); + } + const files = yield* generated(); + yield* checking ? check(files) : write(files); +}); diff --git a/scripts/lib/compile.ts b/scripts/lib/compile.ts index c84b88eee..7e2bd991e 100644 --- a/scripts/lib/compile.ts +++ b/scripts/lib/compile.ts @@ -85,11 +85,27 @@ export const PACKAGED_DOCUMENTATION = [ "packages/git/src/composition/components.md", ]; +/** + * The vendor attribution that travels with bytes the binary carries. + * + * Core's generated `yq` module is the published WebAssembly of `yq.rs`, and + * distributing those bytes carries the vendor's own license and third-party + * notices with them. A directory rather than two files, because the vendor's + * notice set is theirs to change; `scripts/tests/yq-distribution.test.ts` holds + * this entry to the directory that exists. + * + * It is attribution and not a runtime input. Nothing reads it: the engine's + * bytes are in core's static import graph, which is why a binary that carries + * no asset at all still runs `yq`. + */ +export const PACKAGED_NOTICES = ["packages/core/src/yq-vendor-notices"]; + /** Everything a compile embeds, in the order the argv names it. */ export const EMBEDDED_ASSETS = [ ...EMBEDDED_PACKAGES, ...PACKAGED_DOCUMENTS, ...PACKAGED_DOCUMENTATION, + ...PACKAGED_NOTICES, ]; export interface CompileRequest { diff --git a/scripts/tests/yq-distribution.test.ts b/scripts/tests/yq-distribution.test.ts new file mode 100644 index 000000000..771167ed0 --- /dev/null +++ b/scripts/tests/yq-distribution.test.ts @@ -0,0 +1,464 @@ +/** + * The `yq` engine reaches every distribution, and only through the loader. + * + * `yq` selection and `` are one WebAssembly engine, and what makes it + * present everywhere is that its bytes are **committed source**: a compiled + * binary and an installed npm package each carry core's own module graph and + * nothing beside it, so bytes reached through a path, a `fetch` or a host + * filesystem API would work in a source checkout and be absent in both — and + * the failure would reach only the published artifact. + * + * So these cases ask the artifacts rather than the source. One real compile and + * one real npm build, each reused for every assertion made against it, because + * compiling per scenario would spend minutes proving the same closure twice. + * + * The drift cases are separate and cheap. Generation is deliberate: nothing + * regenerates those bytes on its way to doing something else, so what is + * checked here is that `--check` reproduces them exactly, that it writes + * nothing, and that the graph which carries them names the loader and never the + * entry that instantiates a singleton. + */ + +import { describe, it } from "@executablemd/test-support/bdd"; +import { expect } from "@executablemd/test-support/expect"; +import { useTempDirectory } from "@executablemd/test-support/temp"; +import { exec } from "@effectionx/process"; +import { readTextFile, writeTextFile } from "@effectionx/fs"; +import { until } from "effection"; +import type { Operation } from "effection"; +import { createHash } from "node:crypto"; +import { mkdir, readdir, readFile } from "node:fs/promises"; +import path from "node:path"; +import { fileURLToPath } from "node:url"; + +import { compile, compileArguments, PACKAGED_NOTICES } from "../lib/compile.ts"; +import { useNpmWorkspace } from "./npm-output.ts"; + +const ROOT = fileURLToPath(new URL("../../", import.meta.url)); + +/** + * Every published member the CLI's installed closure is made of. + * + * `packages/code-review-agent` is deliberately absent: it is published, and the + * CLI does not depend on it, so building it here would cost a build to install + * nothing. + */ +const CLOSURE: readonly string[] = [ + "packages/core", + "packages/runtime", + "packages/durable-streams", + "packages/acp", + "packages/git", + "packages/test-agent", + "packages/testing", + "packages/web", + "packages/workflow", + "packages/cli", +]; + +/** + * Each runtime's own source entrypoint, and how that runtime is started. + * + * Node reaches TypeScript through the repository's own `tsx`, which is what + * `pnpm test:node` runs the corpus with; Bun and Deno read the source + * directly. The paths are absolute so the document's directory stays a + * directory holding only the document. + */ +const SOURCE_RUNTIMES: readonly (readonly [string, string, readonly string[]])[] = [ + [ + "deno", + Deno.execPath(), + [ + "run", + "--allow-all", + "--cached-only", + "--frozen", + fileURLToPath(new URL("../../packages/cli/src/deno.ts", import.meta.url)), + ], + ], + [ + "node", + fileURLToPath(new URL("../../node_modules/.bin/tsx", import.meta.url)), + [fileURLToPath(new URL("../../packages/cli/src/node.ts", import.meta.url))], + ], + ["bun", "bun", [fileURLToPath(new URL("../../packages/cli/src/bun.ts", import.meta.url))]], +]; + +/** The pin, restated here so a changed dependency fails this suite too. */ +const PINNED_VERSION = "0.1.0"; +const PINNED_BYTES = 468387; +const PINNED_SHA256 = "97252eddd0dd7c2d80c25f8b73aec0874af954ca77ea33d8eb892c0a845eac46"; + +/** + * The one document every distribution runs. + * + * Small on purpose, and complete: an explicit decode through `File`, a `Glob` + * whose paths are selected, and both renderers over the selected data. A + * distribution that carried the loader and not the bytes, or the bytes and not + * the loader, fails on the first element. + */ +const DOCUMENT = [ + ``, + "", + ``, + "", + "", + "first: {first}", + "", + "", + "", + "", + "", + "", +].join("\n"); + +const FIXTURE = JSON.stringify({ records: [{ name: "widget" }] }); + +/** What every distribution has to say about that document. */ +function held(output: string): void { + expect(output).toContain("first: widget"); + // Json's text and Yaml's text, from one selected value. + expect(output).toContain('"input.json"'); + expect(output).toContain("- input.json"); +} + +/** A directory holding the document and its fixture, and nothing else. */ +function* useDocument(): Operation { + const root = yield* useTempDirectory("xmd-yq-document-"); + yield* writeTextFile(path.join(root, "input.json"), FIXTURE); + yield* writeTextFile(path.join(root, "doc.md"), DOCUMENT); + return root; +} + +function digest(bytes: Uint8Array): string { + return createHash("sha256").update(bytes).digest("hex"); +} + +describe("the generated yq bytes", () => { + it("YD1: --check reproduces the committed module, provenance and notices", function* () { + const outcome = yield* exec(Deno.execPath(), { + arguments: [ + "run", + "--allow-read", + "--cached-only", + "--frozen", + "scripts/generate-yq-wasm.ts", + "--check", + ], + cwd: ROOT, + }).join(); + expect(outcome.code).toBe(0); + // Read-only, and it says how many files it compared: a check that silently + // compared none would pass on a repository with nothing generated in it. + expect(outcome.stdout).toContain(`yq.rs@${PINNED_VERSION}`); + expect(outcome.stdout).toContain("4 files"); + }); + + it("YD1: the committed module is the pinned bytes, and the provenance says so", function* () { + const encoded = yield* readTextFile(path.join(ROOT, "packages/core/src/yq-wasm.ts")); + const lines = [...encoded.matchAll(/^ {2}"([A-Za-z0-9+/=]+)",$/gm)].map((match) => match[1]); + expect(lines.length).toBeGreaterThan(0); + const binary = atob(lines.join("")); + const bytes = new Uint8Array(binary.length); + for (let at = 0; at < binary.length; at++) { + bytes[at] = binary.charCodeAt(at); + } + + // The exact published asset, decoded out of the committed source. + expect(bytes.byteLength).toBe(PINNED_BYTES); + expect(digest(bytes)).toBe(PINNED_SHA256); + + const provenance = JSON.parse( + yield* readTextFile(path.join(ROOT, "packages/core/src/yq-wasm.provenance.json")), + ); + expect(provenance.package).toBe("yq.rs"); + expect(provenance.version).toBe(PINNED_VERSION); + expect(provenance.sha256).toBe(PINNED_SHA256); + expect(provenance.bytes).toBe(PINNED_BYTES); + expect(provenance.runtimeExport).toBe("yq.rs/loader"); + // The notices are named with their own digests, so a notice that changed + // without being regenerated is drift rather than something nobody noticed. + for (const notice of provenance.notices) { + const text = yield* readTextFile(path.join(ROOT, "packages/core/src", notice.path)); + expect(digest(new TextEncoder().encode(text))).toBe(notice.sha256); + } + }); + + it("YD1: drift refuses and writes nothing", function* () { + const module = path.join(ROOT, "packages/core/src/yq-wasm.ts"); + const before = yield* readTextFile(module); + // A copy of this repository with the generated module edited. The generator + // resolves its own tree from its own module URL, so the copied script + // checks the copied tree — which is the only way to ask what a check does + // about drift without writing into the tree under test. + const drifted = yield* useNpmWorkspace(); + const copied = path.join(drifted, "packages/core/src/yq-wasm.ts"); + yield* writeTextFile(copied, `${yield* readTextFile(copied)}\n// drift\n`); + const refused = yield* exec(Deno.execPath(), { + arguments: [ + "run", + "--allow-read", + "--cached-only", + "--frozen", + "scripts/generate-yq-wasm.ts", + "--check", + ], + cwd: drifted, + }).join(); + + expect(refused.code).not.toBe(0); + expect(refused.stderr).toContain("out of date"); + // Read-only: the drifted file is still drifted, so the check repaired + // nothing — and this repository's own module is untouched. + expect(yield* readTextFile(copied)).toContain("// drift"); + expect(yield* readTextFile(module)).toBe(before); + }); + + it("YD1: the imported graph names the loader and never the instantiating entry", function* () { + const sources = yield* until(readdir(path.join(ROOT, "packages/core/src"))); + const importing: string[] = []; + for (const name of sources) { + if (!name.endsWith(".ts")) { + continue; + } + const text = yield* readTextFile(path.join(ROOT, "packages/core/src", name)); + if (text.includes("yq.rs")) { + importing.push(name); + } + } + // One module reaches the vendor, and it reaches the loader. + expect(importing.toSorted()).toEqual(["value-query.ts", "yq-wasm.ts"]); + const engine = yield* readTextFile(path.join(ROOT, "packages/core/src/value-query.ts")); + expect(engine).toContain('from "yq.rs/loader"'); + expect(engine).not.toContain('from "yq.rs"'); + expect(engine).not.toContain("yq.rs/inline"); + + // And the manifests pin it under that one subpath. + const manifest = JSON.parse(yield* readTextFile(path.join(ROOT, "packages/core/deno.json"))); + expect(manifest.imports["yq.rs/loader"]).toBe(`npm:yq.rs@${PINNED_VERSION}/loader`); + const pkg = JSON.parse(yield* readTextFile(path.join(ROOT, "packages/core/package.json"))); + expect(pkg.dependencies["yq.rs"]).toBe(PINNED_VERSION); + }); + + it("YD1: the compile names the notice directory that exists", function* () { + for (const asset of PACKAGED_NOTICES) { + const entries = yield* until(readdir(path.join(ROOT, asset))); + expect(entries.toSorted()).toEqual(["LICENSE", "THIRD_PARTY_NOTICES.md"]); + } + const argv = compileArguments({ output: "dist/xmd" }); + for (const asset of PACKAGED_NOTICES) { + expect(argv).toContain(asset); + } + }); +}); + +describe( + "every distribution runs the same document", + { sanitizeOps: false, sanitizeResources: false }, + () => { + it("YD2: the source graph runs it under Deno", function* () { + const root = yield* useDocument(); + const outcome = yield* exec(Deno.execPath(), { + arguments: [ + "run", + "--allow-all", + "--cached-only", + "--frozen", + path.join(ROOT, "packages/cli/src/deno.ts"), + "run", + "doc.md", + ], + cwd: root, + }).join(); + expect([outcome.code, outcome.stderr]).toEqual([0, outcome.stderr]); + held(outcome.stdout); + }); + + it("YD2: the same source graph answers identically under Node and Bun", function* () { + // The three runtimes' own source entrypoints, over one document, from a + // directory holding only the document and its fixture. Each runtime + // reaches the engine through its own module loader — Deno's, tsx's + // transpile, and Bun's — so a byte module that only one of them can read + // fails here rather than in whichever release ships first. + const root = yield* useDocument(); + const answers: Record = {}; + for (const [runtime, command, argv] of SOURCE_RUNTIMES) { + const outcome = yield* exec(command, { + arguments: [...argv, "run", "doc.md"], + cwd: root, + }).join(); + expect([runtime, outcome.code, outcome.stderr]).toEqual([runtime, 0, outcome.stderr]); + held(outcome.stdout); + answers[runtime] = outcome.stdout; + } + + // Equal values, not merely three successes: the selection, both + // renderings and the engine's own formatting are the same text. + expect(answers.node).toBe(answers.deno); + expect(answers.bun).toBe(answers.deno); + }); + + it("YD2: a real compiled binary runs it from an unrelated directory", function* () { + const root = yield* useDocument(); + const built = yield* useTempDirectory("xmd-yq-binary-"); + const output = path.join(built, "xmd"); + // One compile, reused below. Through the shared command, so what is + // embedded is what a release embeds. + yield* compile({ output: path.relative(ROOT, output) }); + + const outcome = yield* exec(output, { arguments: ["run", "doc.md"], cwd: root }).join(); + // The document's cwd holds the fixture and nothing of the checkout: no + // `node_modules`, no `packages/`, no installed `yq.rs`. A binary that + // reached for any of those fails here. + expect([outcome.code, outcome.stderr]).toEqual([0, outcome.stderr]); + held(outcome.stdout); + }); + + it("YD2: the emitted npm package carries the byte module and the exact pin", function* () { + const workspace = yield* useNpmWorkspace(); + const build = yield* exec(Deno.execPath(), { + arguments: [ + "run", + "-A", + "--node-modules-dir=manual", + "--cached-only", + "--frozen", + "scripts/build-npm.ts", + "packages/core", + ], + cwd: workspace, + env: { + ...Deno.env.toObject(), + // The same allowance the repository's own npm build and + // `publish-one.yml` make for the pinned prerelease peer range. + NPM_CONFIG_LEGACY_PEER_DEPS: "true", + }, + }).join(); + expect([build.code, build.stderr]).toEqual([0, build.stderr]); + + const emitted = path.join(workspace, "packages/core/npm"); + // The dependency stays external and exact, and the loader subpath is what + // the emitted module imports — a mapping to the instantiating entry would + // compile WebAssembly on import in every installed copy. + const manifest = JSON.parse(yield* readTextFile(path.join(emitted, "package.json"))); + expect(manifest.dependencies["yq.rs"]).toBe(PINNED_VERSION); + const engine = yield* readTextFile(path.join(emitted, "esm/src/value-query.js")); + expect(engine).toContain("yq.rs/loader"); + expect(engine).not.toContain("yq.rs/inline"); + + // The byte module is emitted, and it is the pinned bytes. + const encoded = yield* readTextFile(path.join(emitted, "esm/src/yq-wasm.js")); + const lines = [...encoded.matchAll(/"([A-Za-z0-9+/=]{16,})"/g)].map((match) => match[1]); + const binary = atob(lines.join("")); + const bytes = new Uint8Array(binary.length); + for (let at = 0; at < binary.length; at++) { + bytes[at] = binary.charCodeAt(at); + } + expect(bytes.byteLength).toBe(PINNED_BYTES); + expect(digest(bytes)).toBe(PINNED_SHA256); + + // And the attribution travels beside it, byte-identical to the source. + for (const asset of ["yq-wasm.provenance.json", "yq-vendor-notices/LICENSE"]) { + const shipped = new Uint8Array( + yield* until(readFile(path.join(emitted, "esm/src", asset))), + ); + const source = new Uint8Array( + yield* until(readFile(path.join(ROOT, "packages/core/src", asset))), + ); + expect(digest(shipped)).toBe(digest(source)); + } + }); + + it("YD3: the packed CLI closure runs it under Node and under Bun", function* () { + const workspace = yield* useNpmWorkspace(); + const { version } = JSON.parse( + yield* readTextFile(path.join(workspace, "packages/cli/deno.json")), + ); + + // Every member of the closure, built at one version. The whole closure + // rather than the CLI alone: these packages are released in lockstep and + // depend on each other by range, so installing one candidate package + // beside published siblings resolves a *mixture* — which proves nothing + // about the artifact a release produces. + // The tarballs are packed straight into scratch this case owns rather + // than left in the build tree: a later member's build rewrites that tree + // underneath them, and an installer reading a file being rewritten reads + // a corrupt one. + const scratch = yield* useTempDirectory("xmd-yq-installed-"); + const tarballs = path.join(scratch, "tarballs"); + yield* until(mkdir(tarballs, { recursive: true })); + + const packed: string[] = []; + for (const member of CLOSURE) { + const built = yield* exec(Deno.execPath(), { + arguments: [ + "run", + "-A", + "--node-modules-dir=manual", + "--cached-only", + "--frozen", + "scripts/build-npm.ts", + member, + String(version), + ], + cwd: workspace, + env: { ...Deno.env.toObject(), NPM_CONFIG_LEGACY_PEER_DEPS: "true" }, + }).join(); + expect([member, built.code, built.stderr]).toEqual([member, 0, built.stderr]); + + const emitted = path.join(workspace, member, "npm"); + const tarball = yield* exec("npm", { + arguments: ["pack", "--silent", "--pack-destination", tarballs], + cwd: emitted, + }).join(); + expect([member, tarball.code, tarball.stderr]).toEqual([member, 0, tarball.stderr]); + const named = tarball.stdout.trim().split("\n").at(-1) ?? ""; + expect([member, named]).toEqual([member, named.length > 0 ? named : "a tarball name"]); + packed.push(path.join(tarballs, named)); + } + + // Installed from those tarballs alone. The installer never reaches the + // checkout: what it is given is ten files in a directory this case owns. + yield* writeTextFile( + path.join(scratch, "package.json"), + JSON.stringify({ name: "xmd-yq-consumer", private: true }), + ); + const installed = yield* exec("npm", { + arguments: ["install", "--no-audit", "--no-fund", ...packed], + cwd: scratch, + }).join(); + expect([installed.code, installed.stderr]).toEqual([0, installed.stderr]); + + // The installed core really is the candidate: it carries the byte module, + // and the bytes are the pin. + const encoded = yield* readTextFile( + path.join(scratch, "node_modules/@executablemd/core/esm/src/yq-wasm.js"), + ); + const lines = [...encoded.matchAll(/"([A-Za-z0-9+/=]{16,})"/g)].map((match) => match[1]); + const binary = atob(lines.join("")); + const bytes = new Uint8Array(binary.length); + for (let at = 0; at < binary.length; at++) { + bytes[at] = binary.charCodeAt(at); + } + expect([bytes.byteLength, digest(bytes)]).toEqual([PINNED_BYTES, PINNED_SHA256]); + + // Run from a directory holding the document and its fixture and nothing + // else, by both runtimes, through the installed closure. + const root = yield* useDocument(); + const entry = path.join(scratch, "node_modules/@executablemd/cli/esm/src/node.js"); + const outputs: string[] = []; + for (const runtime of ["node", "bun"]) { + const outcome = yield* exec(runtime, { + arguments: [entry, "run", "doc.md"], + cwd: root, + }).join(); + expect([runtime, outcome.code, outcome.stderr]).toEqual([runtime, 0, outcome.stderr]); + held(outcome.stdout); + outputs.push(outcome.stdout); + } + // The same document, the same values: the two runtimes do not merely + // each succeed, they agree. + expect(outputs[0]).toBe(outputs[1]); + }); + }, +); diff --git a/specs/executable-mdx-spec.md b/specs/executable-mdx-spec.md index d298b5587..f36203432 100644 --- a/specs/executable-mdx-spec.md +++ b/specs/executable-mdx-spec.md @@ -8362,7 +8362,7 @@ wrapping form the directory is the invocation's own resource, so §4.4's teardow stops everything the content created — including daemons started inside it — before the directory is removed. No filesystem operation is fire-and-forget. -### 6.12 JSON in both directions: ``, `` and `` +### 6.12 JSON in both directions: ``, ``, `` and `` A document moves between structured values and JSON text at boundaries it writes down. `` introduces a value (§6.5), `` renders one as text, @@ -8547,6 +8547,38 @@ failure, render its errors into a corrective prompt, and finish with `` after a bounded retry. That loop is ordinary Markdown, so it is visible and testable like anything else. +#### Rendering a value as YAML: `` + +`` is ``'s sibling. The same operand, the same place, a different +text: + +```md + + + +``` + +Everything about the invocation is ``'s: self-closing and contentless, +one required `value` whose presence is syntactic, `as` as ordinary text +capture, the operand by reference, and the same atomic refusals decided before +the operand runs. There is no `indent`, flow-style, separator or anchor option. + +**Nothing else turns a value into YAML.** A binding a `yq` expression selected +(§6.21) is data; a capture is data; an interpolation is a string. YAML is what +this element renders, where it is written. + +The text is one complete YAML document: two-space indentation, no document +separators, and one terminating newline — the engine's own, neither doubled nor +stripped. Scalars are quoted where their type depends on it, so what the text +parses back to is the value that went in: the string `"false"` stays a string, +`"1.20"` stays a string, and a multiline string stays a block scalar that +survives a round trip. + +One value, one serialization. `` and `` describe an operand through +the same single native JSON serialization, so neither can report something the +other does not — and a value that has no JSON text, or whose serialization +threw, fails here in the same two distinguishable ways it fails there. + ### 6.13 Reading and writing text: `` A document reads a repository file, writes a source file, or lays out a @@ -10133,6 +10165,80 @@ is unchanged, and a live or partial expansion reads the value that applies to that execution. +### 6.21 Selecting out of a result: `yq` + +A document often wants part of what a component produced rather than all of it. +`yq` selects that part before the result becomes a capture: + +```md + + + +``` + +`File` runs once. Its returned string is explicitly decoded, and `scripts` +holds the selected JSON data. An invocation that writes no `yq` keeps its +existing behavior exactly. + +**`yq` is the engine's, and it is separate from `as`.** It is an ordinary +invocation attribute on any ordinary component, consumed before the component's +own props are validated — so a producer with a closed props schema accepts an +invocation that selected out of its result without ever seeing that it did, and +a component never declares `yq`. Structural constructs do not acquire it: they +keep their own closed prop rules, and `yq` written on one is the unknown prop it +always was. + +It accepts a string literal or an expression that resolves to a string. A +non-string refuses before the producer runs, so no effect is performed. An empty +string reaches the engine and receives its ordinary answer: there is no second +expression grammar here. + +**The expression runs on the value the component actually returned.** A +component that returns text is queried as a JSON string, which is why an +expression that wants the data inside it says so with `from_json` or +`from_yaml`. Nothing is decoded on the way in, and a string containing JSON +stays a string under `.`. + +**Selection happens after acceptance and before binding.** The order is fixed: + +```text +form, authored props and destination checks + -> the producer runs once, keeping its own effects and outcome + -> the producer's own return validation and complete joined teardown + -> yq selection + -> selected JSON acceptance + -> the selected capture, and any root publication +``` + +So no expression repairs a return the producer's own schema rejected, a printed +error, a refused producer or a failed cleanup — and a selection failure binds +nothing rather than binding a fallback. A selected value is validated as JSON, +not against the producer's `returns`. + +**One value, or a refusal.** `null`, `false`, `[]` and a multiline string are +values and succeed. An expression that matches nothing, and one that matches +more than once, refuse with the same sentence: + +> This yq expression must return one JSON value. Collect matches into an array +> with `[ ... ]`. + +An invalid expression fails visibly, keeping the engine's own reason. Nothing +reads a partial answer as a result. + +**A queried invocation renders its selection, not its producer's text.** With +`as`, the selected value is bound. Without `as`, a selected string renders where +the element is written and anything else renders nothing — the rule an +uncaptured result already follows. What a queried Markdown body would have +rendered is buffered until the selection is made, so raw text never reaches the +document ahead of the value meant to replace it. + +**The engine reads nothing ambient.** Every evaluation supplies an empty +environment, an empty file map and a fixed instant, so `env(NAME)`, `load(path)` +and `now` cannot reach this host's environment, filesystem or clock. + +`as` is unchanged. A component that declares `returns` still requires `as`, and +`yq` does not supply one. + ## 7. Entry point ### 8.1 `execute` diff --git a/specs/release-process-spec.md b/specs/release-process-spec.md index 189f38fec..6d6f7104d 100644 --- a/specs/release-process-spec.md +++ b/specs/release-process-spec.md @@ -719,6 +719,64 @@ inputs name it. A package that ships its *first* document adds one entry to `PACKAGED_DOCUMENTS` in `scripts/lib/compile.ts`, which `scripts/tests/packaged-document.test.ts` enforces. +### The engine `yq` queries values with + +`yq` selection and `` are one WebAssembly engine, `yq.rs`, pinned at +`0.1.0` and reached through one of its two published entries. Its root and +`./inline` compile an embedded module and instantiate a singleton while that +module is evaluated, which would start a WebAssembly compilation in every +process that loads `@executablemd/core`. Core imports `yq.rs/loader`, which +instantiates nothing by itself and compiles exactly the bytes it is handed. + +Those bytes are **committed source**, not an asset a build copies: + +```text +pinned npm package --explicit generation--> packages/core/src/yq-wasm.ts +core value-query --> yq.rs/loader + imported yq-wasm.ts + source runtime: prepared npm loader + source module + deno compile: loader and byte module in its imported module graph + dnt/npm: emitted byte module + exact external yq.rs dependency +``` + +`packages/core/src/yq-wasm.ts` holds the base64 of the published +`dist/yq.wasm` — 468387 bytes, SHA-256 +`97252eddd0dd7c2d80c25f8b73aec0874af954ca77ea33d8eb892c0a845eac46` — and +nothing else: it decodes nothing, compiles nothing and instantiates nothing. +One execution's own lazy initialization decodes it and hands the bytes to the +loader, so a document that writes neither `yq` nor `` pays for neither. + +Being in the static import graph is what makes every distribution agree. A +compiled binary and an installed npm package each carry core's module graph and +nothing beside it, so bytes reached through a path, a `fetch` or a host +filesystem API would be present in a source checkout and absent in both — and +the failure would reach only the published artifact. + +**Generation is deliberate.** `scripts/generate-yq-wasm.ts` resolves the pinned +package's own `./yq.wasm` export through package resolution, refuses a different +version or different bytes, and writes the byte module, the provenance record +and the vendor notices. `--check` reproduces what generation would emit and +compares, writing nothing. No build, test or check regenerates those bytes: +`deno task build`, `deno task build:web` and the release compile run under cache +and node-modules modes that cannot install, and none of them writes tracked +state. + +**Attribution travels with the bytes.** `packages/core/src/yq-wasm.provenance.json` +records the package, version, asset, byte count, hash, license and the digests of +the notices, and `packages/core/src/yq-vendor-notices/` carries the vendor's own +`LICENSE` and complete `THIRD_PARTY_NOTICES.md`. Both are shipped and neither is +read: `scripts/build-npm.ts` copies them beside the emitted core module, and the +compile embeds the notice directory through `PACKAGED_NOTICES` (§10). A binary +that carried no asset at all would still run `yq`. + +**The dependency is external to the emitted package.** dnt maps +`yq.rs/loader` to the published package, so an installed +`@executablemd/core` resolves the loader as a dependency and reads the byte +module it emitted. `scripts/tests/yq-distribution.test.ts` executes the source +graph under Deno, Node and Bun, a real compiled binary from an unrelated +temporary directory with no checkout assets reachable, and the packed npm CLI +installed into isolated scratch — and inspects the emitted core manifest for the +pin, the loader subpath and the emitted byte module. + ## 10. Canonical compile inputs `deno compile` embeds what `--include` names and nothing else, and reports no @@ -750,6 +808,11 @@ maintained: - `PACKAGED_DOCUMENTATION` — each package's `components.md`, named individually because the directories they sit in are package source, and embedding those whole would carry the TypeScript into the binary a second time. +- `PACKAGED_NOTICES` — the vendor attribution that travels with bytes the binary + carries from somebody else (§9). One directory, + `packages/core/src/yq-vendor-notices`, because the vendor's notice set is + theirs to change. It is attribution and not a runtime input: nothing reads it, + and the engine's own bytes are in core's static import graph. `compileArguments()` builds the complete argv from them and refuses an unknown `--target` before anything is spawned. `scripts/compile.ts` is the command a diff --git a/specs/repl-spec.md b/specs/repl-spec.md index 8485a0020..618b075bf 100644 --- a/specs/repl-spec.md +++ b/specs/repl-spec.md @@ -1775,6 +1775,47 @@ entry may be asking at the same moment, neither answer can be taken for the other, and Stop withdraws the Sidekick's question — with no answer and no outcome — while the entry's stays waiting and answerable. +### A reply selects out of what a control returned + +A reply may write `yq` on any control it is admitted to, and what comes back is +the selected value rather than the whole observation: + +```md + +``` + +`REPL.Bindings` returns JSON *text*, so an expression that wants the data in it +decodes it explicitly. The control still performs its own work once and records +its own outcome; the selection happens after that outcome and before the +capture, and a reply that captures a selected value is still told it — capturing +a designated result does not switch its feedback off. + +What the history gains is a mark and a record. A queried occurrence's intent +says it will present a selected result, written before the work; the selected +value is a separate record naming that exact conversation, response and control +order, appended only after the original outcome succeeded, the selection was +accepted and whatever capture the occurrence owed has happened. Nothing is +correlated by control name, by completion order or by whichever occurrence came +last, so two same-named controls in one response select different things and +each is told its own. + +Three readings follow from those records, and they are the ones a reply has to +act on differently. A marked occurrence with its selected record is told that +value. One whose original work refused keeps the refusal, whatever a constant +expression would have produced. And one that was marked and never presented is +reported as an **interrupted selection** — the work may well have happened, and +what a reply is never handed instead is the whole observation it did not ask +for. + +A queried read keeps its own identity, range and continuation beside the +selected value rather than inside it. Selecting a field out of a window of an +entry's output neither reads another page nor changes how much the producer +actually observed, and both facts reach the next turn. + +An existing history is unchanged by any of this. A record written before a reply +could select carries no mark, keeps the feedback rules it always had, and is +never rewritten or migrated. + The agent, the model and the thinking effort are configured in the Sidekick's own pane. Configure says which agent this conversation is with, what has been *asked for* and what the agent was last *verified* on — two separate lines, From 38c3cb059cd25c3dad31f64681df107f827e9f3d Mon Sep 17 00:00:00 2001 From: Taras Mankovski Date: Sun, 18 Oct 2026 07:05:24 -0400 Subject: [PATCH 2/4] =?UTF-8?q?=F0=9F=9A=A8=20Validate,=20mark=20and=20rea?= =?UTF-8?q?d=20back=20what=20a=20selected=20result=20belongs=20to=20(#934)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Four reviewed contracts were not held, and one authoring rule was unfinished. A canonical `` the reply queried sent back the whole answer. Core opened a destination for that exact occurrence, but the question writer never received it: the intent went down unmarked and no presentation followed, so a reply that asked for one field was told both. The destination now hands its occurrence to the question provider before the asking, which marks the intent, retains the whole answer as the operation's own evidence, and files the order that carries one acknowledged selected value. A question nobody answered files nothing and keeps its marker, so an interrupted selection reads as one. A genuine uncaptured destination skipped the producer's own return schema. A destination relaxes required-as — it does not relax what the component agreed to produce — so a constant expression could turn a rejected return into a delivered answer. The uncaptured path now validates a declared `returns` after joined teardown and before the query, middleware and delivery. An admitted entry that failed still produces its Submit receipt, and querying that receipt wrote a history nothing could read back: the projector rejected the presentation its own supported path had just written. The intent's reservation is what distinguishes the two cases, and both the projector and the feedback owner now read it. A submission refused before admission reserved nothing and still keeps refused feedback. `ComponentResult` and its consumer types are exported from `packages/core/api.ts` under the unchanged name, with destination authority left on the host boundary. `yq` is now a reserved declaration name beside `slot` and `as`; static validation diagnoses a known non-string before any effect; an unresolved dynamic query reports the site as not statically checkable rather than valid; and generated preflight refuses a known-invalid query before the first effect. Four frozen assertions are completed with the fixtures that already existed: a halted initializer waited to real settlement, an evaluator that throws carrying partial output, a queried Markdown body whose later element and cleanup precede the result seam, and a cold-opened history whose marked selection was never acknowledged. --- architecture.md | 5 +- packages/cli/src/repl/sidekick/controls.ts | 49 +++++- packages/cli/src/repl/sidekick/feedback.ts | 9 +- packages/cli/src/repl/sidekick/model.ts | 10 +- packages/cli/src/repl/sidekick/owner.ts | 2 +- packages/cli/src/repl/sidekick/questions.ts | 54 ++++-- .../cli/tests/repl-sidekick-journey.test.ts | 161 ++++++++++++++++++ .../cli/tests/repl-sidekick-lifecycle.test.ts | 84 +++++++++ packages/core/api.ts | 17 ++ packages/core/src/document-validation.ts | 35 +++- packages/core/src/expand.ts | 14 +- packages/core/src/generated-xmd.ts | 11 +- packages/core/src/validate.ts | 2 +- .../core/tests/document-validation.test.ts | 40 +++++ .../core/tests/generated-composition.test.ts | 33 ++++ .../core/tests/generated-xmd-root.test.ts | 158 +++++++++++++++++ packages/core/tests/named-slots.test.ts | 35 ++++ packages/core/tests/yq-component.test.ts | 126 +++++++++++++- 18 files changed, 820 insertions(+), 25 deletions(-) diff --git a/architecture.md b/architecture.md index 19a2598a1..e4a95b44c 100644 --- a/architecture.md +++ b/architecture.md @@ -389,8 +389,9 @@ form, authored props and genuine destination checks -> the acknowledged selected presentation for that exact occurrence ``` -`Component.result` is the one seam between acceptance and binding, published -under the stable name `executablemd.core.component-result`. A handler receives +`ComponentResult.result` is the one seam between acceptance and binding, +published under the stable name `executablemd.core.component-result` and +exported for consumers from `packages/core/api.ts`. A handler receives the accepted result and the query the invocation wrote, and answers with the value to bind — which is all it can do. By the time it is asked, acceptance has happened and publication has not, so nothing it returns repairs a return the diff --git a/packages/cli/src/repl/sidekick/controls.ts b/packages/cli/src/repl/sidekick/controls.ts index e46f0a099..021c2e299 100644 --- a/packages/cli/src/repl/sidekick/controls.ts +++ b/packages/cli/src/repl/sidekick/controls.ts @@ -416,6 +416,21 @@ export interface SidekickDestinations { installed(lookup: ResultOccurrenceLookup): void; /** The occurrence this invocation is in, when it is an owned queried one. */ of(invocation: ComponentInvocation): SidekickOccurrence | undefined; + /** + * The occurrence a selected protected control is about to run in, taken once. + * + * Canonical `` is the only control this conversation does not answer + * for, so its body is core's and the lookup above is unreachable from inside + * it: the one thing that runs there on this host's behalf is the question + * provider. Core opens this destination for that exact occurrence and then + * runs that invocation, so what the provider takes here is the occurrence + * whose body is asking — not the last one to finish, and not a name match. + * + * Taken rather than read, because one occurrence asks one question. A + * provider that asked twice would find nothing the second time and file + * nothing, which is what an occurrence with no destination has always done. + */ + takeSelected(): SidekickOccurrence | undefined; } /** @@ -428,12 +443,38 @@ export interface SidekickDestinations { export function sidekickDestinations(journal: ControlJournal): SidekickDestinations { const filed = new WeakMap(); let lookup: ResultOccurrenceLookup | undefined; + /** The selected control core has opened a destination for and not yet run. */ + let awaiting: ResultOccurrence | undefined; return { entry(definition: FunctionComponentDefinition): ResultDestinationEntry { return { definition, open: (query) => opened(query) }; }, selected(name: string): ResultDestinationEntry { - return { selected: name, open: (query) => opened(query) }; + return { + selected: name, + open: (query) => + opened(query, (occurrence) => { + awaiting = occurrence; + }), + }; + }, + takeSelected(): SidekickOccurrence | undefined { + const occurrence = awaiting; + awaiting = undefined; + if (occurrence === undefined) { + return undefined; + } + const held = filed.get(occurrence); + if (held === undefined) { + return undefined; + } + return { + query: occurrence.query, + file(order: number, read?: Json): void { + held.order = order; + held.read = read; + }, + }; }, installed(taken: ResultOccurrenceLookup): void { lookup = taken; @@ -458,7 +499,10 @@ export function sidekickDestinations(journal: ControlJournal): SidekickDestinati }; /** One occurrence's destination, which is the same for every control. */ - function opened(query: string | undefined): ResultDestination { + function opened( + query: string | undefined, + announce?: (occurrence: ResultOccurrence) => void, + ): ResultDestination { const held: Filed = { order: undefined, read: undefined }; return { *accept(selected: unknown): Operation { @@ -474,6 +518,7 @@ export function sidekickDestinations(journal: ControlJournal): SidekickDestinati }, serves(occurrence: ResultOccurrence): void { filed.set(occurrence, held); + announce?.(occurrence); }, }; } diff --git a/packages/cli/src/repl/sidekick/feedback.ts b/packages/cli/src/repl/sidekick/feedback.ts index 761580556..41f7bbb76 100644 --- a/packages/cli/src/repl/sidekick/feedback.ts +++ b/packages/cli/src/repl/sidekick/feedback.ts @@ -430,7 +430,14 @@ function presented( presentation: ControlPresentationRecord | undefined, ): Omit { const component = intent.component; - if (record.outcome.status !== "ok") { + // An admitted entry that failed is the one exception, and the reservation on + // its own intent is what establishes it: that submission really did produce + // its entry's receipt, and the selection is of that answer. The failure is + // still the operation's own and still reaches the reply through the outcome + // it belongs to. A submission refused before admission reserved nothing, so + // it keeps refused feedback as it always has. + const admitted = intent.submit !== undefined; + if (record.outcome.status !== "ok" && !(admitted && presentation !== undefined)) { // The original outcome stands. A refused control keeps refused feedback, // whatever a selection would have produced from a constant. return { component, kind: "refused", text: record.outcome.error.message, json: false }; diff --git a/packages/cli/src/repl/sidekick/model.ts b/packages/cli/src/repl/sidekick/model.ts index 216ba6b0f..17e930ed3 100644 --- a/packages/cli/src/repl/sidekick/model.ts +++ b/packages/cli/src/repl/sidekick/model.ts @@ -1241,7 +1241,15 @@ export function projectSidekick(records: readonly SidekickRecord[]): Result { +export function* useSidekickQuestions( + /** + * This conversation's destinations, so a queried question presents what it + * selected. + * + * Canonical `` is core's own body, so the occurrence lookup a control + * uses is unreachable from inside it. The destination core opened for that + * exact occurrence is what reaches here instead, and it reaches here before + * the asking — which is what lets the intent carry its marker. + */ + destinations?: SidekickDestinations, +): Operation { /** The response being evaluated right now, and therefore asking. */ let current: ControlJournal | undefined; @@ -113,23 +124,35 @@ export function* useSidekickQuestions(): Operation { "evaluating none — so there is no response for an answer to belong to.", ); } + // Taken before anybody is asked, and taken once: this is the occurrence + // core opened a destination for and is now running. + const mine = destinations?.takeSelected(); + const selecting = mine?.query !== undefined; // Before the asking. A question waiting when a process stops has an // intent and no outcome, which is exactly what an interrupted operation - // looks like everywhere else in this history. - const order = yield* journal.began({ - component: ELICIT_CONTROL, - // The rendered request and nothing else. The schema is the reply's own - // and the answer is retained by the outcome below; what a person or a - // later process needs from the intent is which question was open. - arguments: { message: request.message }, - }); + // looks like everywhere else in this history — and a queried one carries + // its marker from here, so an interrupted selection is readable as a + // selection that was owed rather than as a question nobody queried. + const order = yield* journal.began( + { + component: ELICIT_CONTROL, + // The rendered request and nothing else. The schema is the reply's own + // and the answer is retained by the outcome below; what a person or a + // later process needs from the intent is which question was open. + arguments: { message: request.message }, + }, + undefined, + selecting ? "selected-v1" : undefined, + ); let answer: unknown; try { answer = yield* next(request); } catch (error) { // A schema this surface cannot draw, or a failure above. The reply is // told, because it wrote the schema and the refusal says what the form - // language accepts. + // language accepts. Nothing is filed: a question that was never + // answered has no selected value, and the marked intent standing + // without a presentation is what says so. const failure = error instanceof Error ? error : new Error(String(error)); yield* journal.settled(order, { ok: false, error: failure }); throw failure; @@ -137,7 +160,16 @@ export function* useSidekickQuestions(): Operation { // Deliberately not in a `finally`. A halted question resolved nothing, so // writing an outcome for it would manufacture one — an interruption is // the absence of a completed operation rather than a receipt saying so. + // + // The original answer is retained whole here, whatever the expression + // later selects out of it: the outcome is what the person actually said. yield* journal.settled(order, Ok(answer), answer as Json); + // Filed only after a successful original outcome, exactly as a control's + // own route files: the destination then presents the selected value, and + // what goes back as feedback is that presentation rather than the answer. + if (selecting) { + mine?.file(order); + } return answer; }, }); diff --git a/packages/cli/tests/repl-sidekick-journey.test.ts b/packages/cli/tests/repl-sidekick-journey.test.ts index d24cdda7b..b980ba858 100644 --- a/packages/cli/tests/repl-sidekick-journey.test.ts +++ b/packages/cli/tests/repl-sidekick-journey.test.ts @@ -23,6 +23,7 @@ import type { Operation, Result } from "effection"; import { previewGeneratedXmdRoot } from "@executablemd/core/host"; import { projectSidekick } from "../src/repl/sidekick/model.ts"; +import { designatedResults } from "../src/repl/sidekick/feedback.ts"; import type { SidekickReading } from "../src/repl/sidekick/model.ts"; import { sidekickChatLines } from "../src/repl/application.ts"; import { sidekickChatRows, sidekickTurnRows } from "../src/repl/program.ts"; @@ -823,6 +824,94 @@ describe("Tier R5 — one message becomes one turn, and its reply runs", () => { expect(answered.value.output).toContain("I will correct it."); }); + it("R5: a queried Submit whose entry failed still answers, and reads back cold", function* () { + // The same real failing entry as the row above, with the query the defect + // was found through. The submission happened and produced its entry's + // receipt; the entry is what failed. Both facts have to survive into a + // history that can be read again. + const held = yield* useHarness(); + held.fake.script({ + reply: [ + '', + "````xmd", + "```js eval", + 'throw new Error("entry failed on purpose");', + "```", + "````", + "", + "{code}", + ``, + "", + ].join("\n"), + }); + held.fake.script({ reply: "I will correct it.\n" }); + + const answered = yield* held.owner.message("run this"); + if (!answered.ok) { + throw answered.error; + } + + const [entry] = held.session.model.entries; + expect(entry?.key).toBe("entry-1"); + // The original failure stands: this is still a failed entry. + expect(entry?.terminal?.status).toBe("err"); + + const written = yield* records(held.execution); + const intents = written.filter( + (one) => one.kind === "control" && one.component === "REPL.Submit", + ); + // One reservation, one intent, and it is marked. + expect(intents).toHaveLength(1); + const intent = intents[0]; + expect(intent?.kind === "control" && intent.submit?.entry).toBe("entry-1"); + expect(intent?.kind === "control" && intent.presentation).toBe("selected-v1"); + // The original outcome is the failure, with the entry's own status beside it. + const outcomes = written.filter( + (one) => + one.kind === "control-outcome" && intent?.kind === "control" && one.order === intent.order, + ); + expect(outcomes[0]?.kind === "control-outcome" && outcomes[0].outcome.status).toBe("err"); + // And one acknowledged selected receipt, which is what the reply asked for. + const presentations = written.filter((one) => one.kind === "control-presentation"); + expect(presentations).toHaveLength(1); + // The receipt the submission really produced — this entry, and why it + // failed — selected and acknowledged as this occurrence's answer. + const selected = + presentations[0]?.kind === "control-presentation" ? String(presentations[0].selected) : ""; + expect(selected).toContain("entry-1"); + expect(selected).toContain("entry failed on purpose"); + + // Read cold, from those records alone: the projection does not refuse this + // history, which is the failure this row exists for. + const projected = projectSidekick(written); + expect(projected.ok).toBe(true); + + // And nothing was repeated: one entry ran, once. + expect(held.session.model.entries).toHaveLength(1); + expect(answered.value.output).toContain("I will correct it."); + }); + + it("R5: a submission refused before admission still keeps refused feedback", function* () { + // The control the correction must not relax. Nothing was admitted, so + // there is no reservation, no receipt and no presentation — whatever the + // reply asked to select. + const held = yield* useHarness(); + held.fake.script({ reply: `\n` }); + held.fake.script({ reply: "Understood.\n" }); + + const answered = yield* held.owner.message("submit nothing"); + if (!answered.ok) { + throw answered.error; + } + + const written = yield* records(held.execution); + // No entry ran, and no selected receipt was acknowledged. + expect(held.session.model.entries).toHaveLength(0); + expect(written.filter((one) => one.kind === "control-presentation")).toEqual([]); + // The reply was told it was refused, which is what it has to act on. + expect(held.fake.prompts[1] ?? "").toContain("refused"); + }); + it("R5: a JSON value among other results is fenced long enough to hold it", function* () { const held = yield* useHarness(); // A published value containing a fence of its own, which is the case the @@ -1898,6 +1987,78 @@ describe("Tier R9 — a selected result is feedback only once it is acknowledged expect(feedback).not.toContain('"greeting"'); }); + it("R9e: a cold reopen of a marked incomplete selection says so, and sends nothing", function* () { + // The arm a projection of constructed records cannot supply: a real + // process marks an intent, really completes the work, and the + // acknowledgement is refused at the storage boundary — then the history it + // left is opened cold and inspected before anything is said to it. + const dataRoot = yield* useTemporary("xmd-repl-r9e-incomplete-"); + const gate = appendGate(); + let execution = ""; + let entries = 0; + let saved: readonly SidekickRecord[] = []; + + yield* scoped(function* (): Operation { + const host = yield* useMountedHost({ dataRoot, gate }); + const repl = yield* useMountedRepl({ host }); + yield* publishing(repl); + repl.fake.script({ + reply: `\n\n\n`, + }); + repl.fake.script({ reply: "Carrying on.\n" }); + + const acknowledging = gate.holdNext((_path, record) => record.includes(PRESENTATION)); + yield* sendMessage(repl, "what did it publish?"); + yield* acknowledging.started(); + acknowledging.refuse("the storage refused this record"); + yield* awaiting(repl.terminal, "the Sidekick going idle", (one) => shows(one, "[send]")); + yield* settled(40); + + const read = yield* mountedReading(repl); + execution = read.execution; + entries = read.model.entries.length; + saved = read.chat; + // This is the history the cold half is held to: the intent is marked, + // the original outcome succeeded, and no presentation was retained. + expect( + saved.filter((one) => one.kind === "control" && one.presentation === "selected-v1").length, + ).toBe(1); + expect(saved.filter((one) => one.kind === "control-presentation")).toEqual([]); + }); + + // Cold, over those files, with its own provider. + const cold = yield* useMountedHost({ dataRoot }); + const reopened = yield* useMountedRepl({ + host: cold, + location: `xmd://repl/${execution}/entries`, + }); + + // Inspected before anything is said to it. + const inspected = yield* mountedReading(reopened); + expect(inspected.chat).toEqual(saved); + expect(inspected.model.entries.length).toBe(entries); + expect(reopened.fake.prompts).toEqual([]); + + // What this history offers a next turn is the honest reading: the + // operation completed, what it selected is not known, and nothing of it + // will be repeated. The observation it really made is not offered in its + // place — that is the raw fallback this exists to refuse. + const marked = saved.find( + (one) => one.kind === "control" && one.presentation === "selected-v1", + ); + expect(marked?.kind).toBe("control"); + const designated = + marked?.kind === "control" + ? designatedResults(saved, { + conversation: marked.conversation, + response: marked.response, + }) + : []; + expect(designated.map((one) => one.kind)).toEqual(["incomplete"]); + expect(designated[0]?.text).toContain("selected result was never recorded"); + expect(JSON.stringify(designated)).not.toContain("Hello from the reply."); + }); + it("R9e: a cold reopen reads the saved selection, and reruns nothing", function* () { const dataRoot = yield* useTemporary("xmd-repl-r9e-"); let execution = ""; diff --git a/packages/cli/tests/repl-sidekick-lifecycle.test.ts b/packages/cli/tests/repl-sidekick-lifecycle.test.ts index 815bbe13b..20f154988 100644 --- a/packages/cli/tests/repl-sidekick-lifecycle.test.ts +++ b/packages/cli/tests/repl-sidekick-lifecycle.test.ts @@ -681,6 +681,90 @@ describe("Tier R6 — a reply asks, and the Sidekick owns the answer", () => { expect(outcomes[0]?.["observed"]).toEqual({ decision: "approve" }); }); + it("R6: a queried question presents what it selected, and retains the whole answer", function* () { + // The shape the defect was found with: a person answers two fields and + // the reply asked for one of them. What goes back must be the one it + // asked for; what the history keeps must be both. + const TWO = { + type: "object", + properties: { public: { type: "string" }, private: { type: "string" } }, + required: ["public", "private"], + additionalProperties: false, + } as const; + const held = yield* useHarness(); + held.fake.script({ + reply: + `Say something.` + + `\n\n{picked}\n\n`, + }); + held.fake.script({ reply: "Noted.\n" }); + + const sent = yield* sending(held, "ask me something"); + const question = yield* asked(held.owner.questions); + expect(question.submit({ public: "yes", private: "unselected" }).kind).toBe("answered"); + + const answered = yield* sent; + if (!answered.ok) { + throw answered.error; + } + // The capture is the selected value, which is what the reply rendered. + expect(replied(held, 1).text.trim()).toBe("yes"); + expect(answered.value.output).toContain("Noted."); + + const written = yield* records(held.execution); + const intents = pairs(written, "control").filter((one) => one["component"] === "Elicit"); + // One intent, marked before the asking — not a second one, and not an + // unmarked one that a later reader would take for an old unqueried + // question. + expect(intents).toHaveLength(1); + expect(intents[0]?.["presentation"]).toBe("selected-v1"); + // The original answer stands whole as this operation's own evidence. + const outcomes = pairs(written, "control-outcome").filter( + (one) => one["order"] === intents[0]?.["order"], + ); + expect(outcomes[0]?.["observed"]).toEqual({ public: "yes", private: "unselected" }); + // One acknowledged presentation, holding the selected value alone. + const presentations = written.filter((one) => one.kind === "control-presentation"); + expect(presentations).toHaveLength(1); + expect(presentations[0]?.kind === "control-presentation" && presentations[0].selected).toBe( + "yes", + ); + // And what the next turn was sent is that selection — not the answer the + // person gave, which still holds the field the reply never asked for. + expect(JSON.parse(held.fake.prompts[1] ?? "")).toBe("yes"); + }); + + it("R6: a queried question nobody could be asked keeps its marker and sends nothing raw", function* () { + // The interrupted arm, reached the way the surface actually refuses one: + // a schema the bounded form language cannot draw. The question was + // queried, so its intent carries the marker; nobody answered, so there is + // no selected value — and no raw answer goes out in its place. + const held = yield* useHarness(); + held.fake.script({ + reply: + `` + + `How many?\n\n{picked}\n\n`, + }); + held.fake.script({ reply: "Understood.\n" }); + + const answer = yield* held.owner.message("ask me something"); + if (!answer.ok) { + throw answer.error; + } + + expect(held.owner.questions.asked).toBe(0); + const written = yield* records(held.execution); + const intents = pairs(written, "control").filter((one) => one["component"] === "Elicit"); + expect(intents).toHaveLength(1); + // Marked, so a reader can tell a selection was owed and never acknowledged. + expect(intents[0]?.["presentation"]).toBe("selected-v1"); + // And nothing was presented: a question nobody answered selected nothing. + expect(written.filter((one) => one.kind === "control-presentation")).toEqual([]); + // What the next turn was told is the refusal, not an answer. + expect(held.fake.prompts[1] ?? "").toContain("Elicit"); + }); + it("R6: an invalid answer answers nobody and leaves the same question pending", function* () { const held = yield* useHarness(); held.fake.script({ diff --git a/packages/core/api.ts b/packages/core/api.ts index 79695c42a..903a43f1e 100644 --- a/packages/core/api.ts +++ b/packages/core/api.ts @@ -143,6 +143,23 @@ export type { } from "./src/component-api.ts"; export type { Expansion } from "./src/expansion.ts"; +/** + * The seam one invocation's accepted result crosses, and the request a + * handler composing around it is handed. + * + * Here for the same reason `Component` is: a consumer that wants to see what a + * component produced — and to transform it before anything binds, publishes or + * presents it — needs the descriptor and the shape, and nothing of the engine + * behind them. Every accepted result crosses it, queried or not. + * + * It carries no authority over where a result goes. Which occurrence owns a + * destination is the trusted host installation's, stated through + * `packages/core/host.ts` before any document code runs, and a handler here + * cannot read, add or redirect one. + */ +export { ComponentResult } from "./src/component-result.ts"; +export type { ComponentResultApi, ComponentResultRequest } from "./src/component-result.ts"; + /** * The execution a host composes around, and the requests its layers are handed. * diff --git a/packages/core/src/document-validation.ts b/packages/core/src/document-validation.ts index 2040e4297..2841815a8 100644 --- a/packages/core/src/document-validation.ts +++ b/packages/core/src/document-validation.ts @@ -55,6 +55,7 @@ import { asExpressionViolation, capturedBinding, ENGINE_OWNED_PROPS, + queryExpressionViolation, returnCaptureViolation, } from "./invocation-rules.ts"; import type { IdentityComponent } from "./invocation-identity.ts"; @@ -930,6 +931,16 @@ class ValidationState { if (asRefused !== undefined) { captureViolations.push(asRefused); } + // `yq` is engine-owned on the same terms, and the rule is expansion's own: + // a value that is written here and is not a string is not an expression, + // whatever a producer would have done with it. A query written as an + // expression resolves at runtime and is deliberately not judged — this + // phase holds the literal the author wrote, and an unresolved one is not + // statically checkable rather than statically valid. + const queryRefused = queryExpressionViolation(segment.name, segment.props.yq); + if (queryRefused !== undefined) { + captureViolations.push(queryRefused); + } for (const violation of captureViolations) { draft.tokens.push( this.#draft(context.entry.ordinal, violation.code, { @@ -1013,7 +1024,7 @@ class ValidationState { // no props schema, no captures, no return mode. Only the engine-owned // checks above applied, and what is left is unknown rather than accepted. if (draft.tokens.length === 0) { - if (hasDynamicProp(segment, [])) { + if (hasDynamicProp(segment, []) || hasDynamicQuery(segment)) { draft.reasons.push("dynamic-props"); } draft.reasons.push("origin-only-contract"); @@ -1116,6 +1127,15 @@ class ValidationState { return; } + if (hasDynamicQuery(segment)) { + // The schema is satisfied and the query is not known. Reported as + // unresolved rather than valid: `yq` is stripped before the schema is + // consulted, and a site certified because the one thing that was not + // checked had been removed is a site nothing checked. + draft.reasons.push("dynamic-props"); + return; + } + try { yield* validateProps(segment.name, statics, contract.props); } catch (error) { @@ -1428,6 +1448,19 @@ function hasDynamicProp(segment: ComponentElement, captures: readonly string[]): return Object.keys(schemaVisible(segment.expressions, captures)).length > 0; } +/** + * Whether this invocation's query is written as an expression. + * + * Asked separately from the schema question, because the two answers are + * about different things. `yq` never meets a producer's schema, so it is + * absent from the props a schema is checked against — but what it evaluates + * to still decides whether the invocation is well formed, and this phase does + * not have it. Saying nothing would report such a site as checked. + */ +function hasDynamicQuery(segment: ComponentElement): boolean { + return Object.hasOwn(segment.expressions, "yq"); +} + /** * Required properties whose key is written nowhere at all. * diff --git a/packages/core/src/expand.ts b/packages/core/src/expand.ts index 3c391feb5..30f1fc368 100644 --- a/packages/core/src/expand.ts +++ b/packages/core/src/expand.ts @@ -4033,7 +4033,19 @@ function* expandFunctionComponent( // Without `as` there is nowhere to bind, so only text can be observed: // a string renders, and anything else renders nothing rather than being // stringified into the document. - const rendered = yield* componentResult({ component: name, value: output, query }); + // + // A declared `returns` is still checked here, and this is the one place + // an uncaptured invocation can have one: required-as refuses every other + // route to it, and a destination relaxes *that* decision rather than the + // producer's own contract. Checked before the query for the same reason + // the captured path checks it there — an expression that narrowed an + // invalid return to a valid-looking one would deliver a value this + // component never agreed to produce. + const accepted = + returns === undefined + ? output + : yield* validateReturnValue(name, parseJson(output), returns); + const rendered = yield* componentResult({ component: name, value: accepted, query }); if (designated !== undefined) { yield* designated.occurrence.deliver(rendered); } diff --git a/packages/core/src/generated-xmd.ts b/packages/core/src/generated-xmd.ts index 90a3bfcb3..ccfc6382b 100644 --- a/packages/core/src/generated-xmd.ts +++ b/packages/core/src/generated-xmd.ts @@ -136,7 +136,7 @@ import { extendPath } from "./expansion.ts"; import { isJsonObject, parseJson } from "./json.ts"; import { markGeneratedRequestRefusal } from "./generated-request-refusal.ts"; import { GeneratedDataExpressions, validateDataExpression } from "./generated-expressions.ts"; -import { capturedBinding } from "./invocation-rules.ts"; +import { capturedBinding, queryExpressionViolation } from "./invocation-rules.ts"; import { renderSegments } from "./render.ts"; import { scanSegments } from "./scanner.ts"; import { sourceDescription } from "./source-position.ts"; @@ -194,6 +194,7 @@ type Construct = | "expression" | "interpolation" | "binding" + | "query" | "component" | "content" | "form" @@ -214,6 +215,7 @@ const CONSTRUCT: Record = { "bindings.", interpolation: "a generated fragment reads a binding through interpolation, which it may not.", binding: "a generated fragment binds a result with an `as` that is not a binding name.", + query: "a generated fragment writes a `yq` that is not a string holding an expression.", component: "a generated fragment names a component this host did not admit.", content: "a generated fragment gives content to a component this host admitted only in its " + @@ -1818,6 +1820,13 @@ function* walk( throw new Refusal("expression"); } } + // Engine-owned and decided on the same terms as every other authored + // rule: a query that is written here and is not a string is not an + // expression, whatever the producer would have done with it. Refused + // in preflight, so a known-invalid query costs no effect at all. + if (queryExpressionViolation(segment.name, segment.props.yq) !== undefined) { + throw new Refusal("query"); + } // How the element was written, read from the scan rather than from // anything the run could answer differently later. This is what // separates the two `` identities, so it is decided here — once, diff --git a/packages/core/src/validate.ts b/packages/core/src/validate.ts index dc7d457f0..51cecd235 100644 --- a/packages/core/src/validate.ts +++ b/packages/core/src/validate.ts @@ -5,7 +5,7 @@ import type { Context, Operation } from "effection"; import { JsonParseError, parseJson } from "./json.ts"; import type { Json, PropsSchema, ReturnsSchema } from "./types.ts"; -const RESERVED_PROP_NAMES = ["slot", "as"]; +const RESERVED_PROP_NAMES = ["slot", "as", "yq"]; // `validateFormats: false` keeps `format` an annotation (no assertion, no extra // dependency). `useDefaults` mutates the validated value to fill defaults. diff --git a/packages/core/tests/document-validation.test.ts b/packages/core/tests/document-validation.test.ts index d3fd02eb3..3488a679c 100644 --- a/packages/core/tests/document-validation.test.ts +++ b/packages/core/tests/document-validation.test.ts @@ -1415,6 +1415,46 @@ describe("Tier DV: the engine's own props are not schema props", () => { expect(outcomes(result)).toEqual(["valid"]); }); + it("DV14: a known non-string `yq` is diagnosed before anything runs", function* () { + // The authored literal is what this phase holds, and a number is not an + // expression whatever a producer would have done with it. Diagnosed here + // so the refusal costs nothing — the same rule expansion applies, applied + // before any effect. + const { result } = yield* validateText(`\n`, { + tree: { "notes.md": "{}" }, + }); + + expect(codes(result)).toContain("props-invalid"); + const said = result.diagnostics.map((one) => one.message).join("\n"); + expect(said).toContain('Prop "yq" on '); + expect(said).toContain("number"); + }); + + it("DV14: an unresolved dynamic `yq` is not checkable rather than valid", function* () { + // A query the document computes has no literal here. The outcome says the + // invocation could not be statically checked; it does not certify the + // expression, and it does not refuse it either. + const { result } = yield* validateText( + `\n\n\n`, + { tree: { "notes.md": "{}" } }, + ); + + expect(codes(result)).not.toContain("props-invalid"); + expect(outcomes(result)).toContain("not-statically-checkable"); + }); + + it("DV14: a string `yq` is accepted", function* () { + // The control: the rule refuses what is known to be wrong, and the + // ordinary authored form still passes. + const { result } = yield* validateText( + `\n`, + { tree: { "notes.md": "{}" } }, + ); + + expect(codes(result)).toEqual([]); + expect(outcomes(result)).toEqual(["valid"]); + }); + it("DV14: an unknown prop beside `yq` is still refused", function* () { // The negative control: stripping the engine's own props is not stripping // everything, so a closed schema still closes. diff --git a/packages/core/tests/generated-composition.test.ts b/packages/core/tests/generated-composition.test.ts index 0be23b8e1..d22c4887a 100644 --- a/packages/core/tests/generated-composition.test.ts +++ b/packages/core/tests/generated-composition.test.ts @@ -223,6 +223,39 @@ describe("Tier FE31 — a fragment binds locally and renders what it chose", () }); } + it("FE31: a known-invalid query refuses before the read written ahead of it", function* () { + // The authored rule reaches generated source too: `yq={42}` is not an + // expression whatever the producer would have done with it, and the read + // written first is what says the refusal preceded every effect. + const files = recordedFiles({ "notes.md": NOTE }); + const message = yield* refusal( + run(evaluating(`\n\n\n`), [ + reading(files), + ]), + ); + + expect(message).toContain("yq"); + expect(files.performed).toEqual([]); + }); + + it("FE31: a string query on the same fragment runs it", function* () { + // The control: the rule refuses what is known to be wrong, and an + // ordinary query on the same shape still reaches the producer. + const files = recordedFiles({ "notes.md": NOTE }); + const output = yield* run( + evaluating( + `\n\n` + + `\n`, + ), + [reading(files)], + ); + + expect(files.performed).toEqual(["read notes.md"]); + // The selected string itself, which is what an uncaptured queried + // invocation renders. + expect(String(output).trim()).toBe(NOTE.trim()); + }); + it("FE31: a directly scanned finite number is the positive control for the non-finite rows", function* () { // `-1` is a JSON number rather than an operator, and the scanner resolves it // to an inert `-1` before an expression exists. Without this row, the diff --git a/packages/core/tests/generated-xmd-root.test.ts b/packages/core/tests/generated-xmd-root.test.ts index 999053942..9899eaf65 100644 --- a/packages/core/tests/generated-xmd-root.test.ts +++ b/packages/core/tests/generated-xmd-root.test.ts @@ -41,6 +41,7 @@ import { Component, content } from "../src/component-api.ts"; import { Elicitation } from "../src/elicitation-api.ts"; import type { ElicitationRequest } from "../src/elicitation-api.ts"; import { pinnedJson } from "../src/generated-xmd.ts"; +import { ComponentResult } from "../api.ts"; import { useSelection } from "./support/generated-selection.ts"; import { answerProvider } from "./support/answer-provider.ts"; import { SYNTAX_COMPONENT, SYNTAX_PROTECTED } from "../src/components/Syntax.ts"; @@ -1184,6 +1185,163 @@ describe("Tier GR — the trusted composition table reaches a root too", () => { }); }); +/** + * Tier GR — what an owned destination may be handed (R2, R4). + * + * A host that owns a destination relaxes one decision: an invocation that + * captures nothing is still allowed, because the result has somewhere to go. + * It does not relax the producer's own contract, and these rows are that + * difference. The invalid one is written the way the defect was found — a + * constant expression, which turns anything into a valid-looking answer — so a + * route that queried before it validated delivers `42` here. + */ +describe("Tier GR — an owned destination, and the contract it does not relax", () => { + beforeAll(() => useTempFileCompiler()); + + /** The host's own definition, and what its body returns. */ + function owned(body: () => unknown): FunctionComponentDefinition { + return { + kind: "function", + name: "Owned", + props: { type: "object", properties: {}, additionalProperties: false }, + forms: ["self-closing"], + returns: { + type: "object", + properties: { valid: { type: "boolean" } }, + required: ["valid"], + additionalProperties: false, + }, + generated: { + "self-closing": { identity: "https://executable.md/components/owned", effect: "read" }, + }, + // deno-lint-ignore require-yield + *fn(): Operation { + return body(); + }, + }; + } + + /** + * One root request whose host owns `Owned`'s result. + * + * The destination names the exact published definition, which is what + * canonical capture authenticates it against. + */ + function owning( + source: string, + definition: FunctionComponentDefinition, + delivered: unknown[], + extra?: ExecutionInstallation, + order?: string[], + ): Candidate { + const candidate = request(source, { + observations: [{ name: "Owned", definition }], + allow: ["read"], + }); + return { + ...candidate, + installation: { + ...candidate.installation, + resultDestinations: { + destinations: [ + { + definition, + open: () => ({ + *accept(selected: unknown): Operation { + order?.push("delivered"); + delivered.push(selected); + }, + }), + }, + ], + }, + *install(): Operation { + const base = candidate.installation.install; + if (base !== undefined) { + yield* base(); + } + const added = extra?.install; + if (added !== undefined) { + yield* added(); + } + }, + }, + }; + } + + it("GR18: an uncaptured owned return its own schema rejects is never delivered", function* () { + const delivered: unknown[] = []; + const definition = owned(() => ({ invalid: true })); + const attempt = yield* evaluateRoot( + owning(`\n\n\n`, definition, delivered), + ); + + // The producer's own contract decided this, before any expression was + // asked: a constant query cannot rescue a return its schema rejected, so + // the root fails and the destination is handed nothing at all. + const answer = attempt.answer; + expect(answer?.ok).toBe(false); + expect(answer !== undefined && !answer.ok && answer.error.message).toContain("Owned"); + expect(delivered).toEqual([]); + }); + + it("GR18: an uncaptured owned return its schema accepts is delivered, selected", function* () { + const delivered: unknown[] = []; + const definition = owned(() => ({ valid: true })); + const attempt = yield* evaluateRoot( + owning(`\n\n\n`, definition, delivered), + ); + + // The positive control: same destination, same uncaptured form, a real + // expression — an accepted return reaches the destination as what that + // expression selected. Nothing is rendered, because an uncaptured result + // that is not a string never was. + expect(rendered(attempt).output.trim()).toBe(""); + expect(delivered).toEqual([true]); + }); + + it("GR18: a consumer's own middleware sees the accepted result before delivery", function* () { + // R4's consumer boundary, reached through the published entrypoint rather + // than core's private module: `ComponentResult` is what a host installs on, + // and what it is handed is the value the producer's contract accepted. + // One log for both, so what is read is the order rather than two counts. + const order: string[] = []; + const seen: { value: unknown; query: string | undefined }[] = []; + const delivered: unknown[] = []; + const definition = owned(() => ({ valid: true })); + const attempt = yield* evaluateRoot( + owning( + `\n\n\n`, + definition, + delivered, + { + *install(): Operation { + yield* ComponentResult.around({ + *result([requested], next) { + if (requested.component === "Owned") { + order.push("middleware"); + seen.push({ value: requested.value, query: requested.query }); + } + return yield* next(requested); + }, + }); + }, + }, + order, + ), + ); + + expect(rendered(attempt).output.trim()).toBe(""); + // The accepted original and the query the invocation wrote — the value the + // producer's contract accepted, not the selected one. + expect(seen).toEqual([{ value: { valid: true }, query: ".valid" }]); + expect(delivered).toEqual([true]); + // And it was observed before anything was delivered, which is the whole + // point of the seam sitting between acceptance and everything after it. + expect(order).toEqual(["middleware", "delivered"]); + }); +}); + /** * Tier GR — writing the entry draft from captured passive source. * diff --git a/packages/core/tests/named-slots.test.ts b/packages/core/tests/named-slots.test.ts index 8b399b9c0..0418fb5cf 100644 --- a/packages/core/tests/named-slots.test.ts +++ b/packages/core/tests/named-slots.test.ts @@ -618,6 +618,41 @@ describe("Tier NS-D — slot prop reservation", () => { expect(String(raised)).toContain("reserved prop name"); }); + it("NS-D1: yq in props frontmatter → error, on slot's own terms", function* () { + // `yq` is the engine's for the same reason `slot` and `as` are: expansion + // consumes it before a schema is consulted, so a component declaring it + // would be declaring a prop it can never be handed. + const { props } = parseFrontmatter({ + props: { + type: "object", + properties: { yq: { type: "string" } }, + additionalProperties: false, + }, + }); + let raised: unknown; + try { + yield* compilePropsSchema(props); + } catch (error) { + raised = error; + } + expect(String(raised)).toContain("reserved prop name"); + expect(String(raised)).toContain("yq"); + }); + + it("NS-D1: an ordinary prop name beside it still compiles", function* () { + // The control for the row above: reservation refuses three names, not + // every name a component declares. + const { props } = parseFrontmatter({ + props: { + type: "object", + properties: { query: { type: "string" } }, + additionalProperties: false, + }, + }); + const compiled = yield* compilePropsSchema(props); + expect(compiled).not.toBe(undefined); + }); + it("NS-D2: slot not in child's validatedProps", function* () { // Widget declares "title" prop only — slot should be stripped before validation const layout = makeComponent("Layout", ''); diff --git a/packages/core/tests/yq-component.test.ts b/packages/core/tests/yq-component.test.ts index 1781ac900..e06fedc21 100644 --- a/packages/core/tests/yq-component.test.ts +++ b/packages/core/tests/yq-component.test.ts @@ -40,6 +40,7 @@ import { fatalCause } from "../src/errors.ts"; import { createYq } from "yq.rs/loader"; import type { Yq } from "yq.rs/loader"; import { createValueQuery, ONE_VALUE } from "../src/value-query.ts"; +import { ComponentResult } from "../api.ts"; import type { EngineFactory } from "../src/value-query.ts"; import { Component } from "../src/component-api.ts"; import type { ComponentRegistration } from "../src/components/registration.ts"; @@ -85,6 +86,8 @@ interface Supplied { readonly registered?: readonly ComponentRegistration[]; /** Markdown definitions, answered through the ordinary import chain. */ readonly markdown?: readonly ComponentDefinition[]; + /** A log the result seam writes to, for a case about completion order. */ + readonly watching?: string[]; } /** Run `source` as a document in `root`, with `supplied` resolvable. */ @@ -105,6 +108,17 @@ function runDocument(root: string, source: string, supplied: Supplied = {}): Ope }, }); yield* useHostFiles(); + if (supplied.watching !== undefined) { + const order = supplied.watching; + yield* ComponentResult.around({ + *result([request], next) { + if (request.query !== undefined) { + order.push("result middleware"); + } + return yield* next(request); + }, + }); + } if (supplied.registered !== undefined && supplied.registered.length > 0) { yield* registerComponents([...supplied.registered]); } @@ -283,9 +297,14 @@ describe("Tier YQ — one engine per execution, built when it is wanted", () => const gate = openGate(); const asked = openGate(); const reached: string[] = []; + // The factory's own promise, kept: `gate.opened` only *starts* the real + // engine, and a case that waited on the gate would be asserting before the + // vendor had produced anything at all. + let engine: Promise | undefined; const held: EngineFactory = (bytes: Uint8Array) => { asked.open(); - return gate.opened.then(() => realEngine(bytes)); + engine = gate.opened.then(() => realEngine(bytes)); + return engine; }; const owner = createValueQuery(held); @@ -302,10 +321,17 @@ describe("Tier YQ — one engine per execution, built when it is wanted", () => // this is about — not before the consumer started. yield* until(asked.opened); yield* waiting.halt(); - // Resolved after the halt, which is the case `until` cannot cancel. + // Released after the halt, and then *settled*: this waits for the engine + // the vendor actually built, which is the moment a resumed continuation + // would have had something to publish. gate.open(); - yield* until(gate.opened); + expect(engine).not.toBe(undefined); + const settled = yield* until(engine ?? Promise.reject(new Error("no engine was started"))); + expect(settled).not.toBe(undefined); + // The halted task came down — `halt()` returns once its teardown has run, + // and the marker is that teardown — and its downstream continuation never + // ran, with the engine now genuinely settled behind it. expect(reached).toEqual(["torn down"]); owner.close(); }); @@ -437,6 +463,40 @@ describe("Tier YQ — what one answer may be", () => { expect(refusal).toBe(ONE_VALUE); owner.close(); }); + + it("YQ2: an evaluator that throws with partial output keeps its cause", function* () { + // The other branch, and the one a vendor actually takes when it fails + // partway: it raises rather than returning. What a document must not get + // is the text it had produced before it gave up — and what a reader must + // keep is why it gave up. + const broke = new Error("the vendor abandoned this evaluation"); + const owner = createValueQuery(() => + Promise.resolve({ + evaluate: () => "", + evaluateSequenceWithStatus: () => ({ output: "", matched: false }), + evaluateWithStatus: () => { + // Partial output exists, and it leaves with the failure rather than + // being returned beside it. + throw Object.assign(broke, { output: "[1" }); + }, + }), + ); + let raised: unknown; + try { + yield* owner.select(".", [1]); + } catch (error) { + raised = error; + } + + // Reported as the evaluation it was, and the vendor's own failure is + // reachable underneath rather than replaced by a summary of it. + expect(raised instanceof Error && raised.name).toBe("ValueQueryError"); + expect(raised instanceof Error && raised.message).toContain("could not be evaluated"); + expect(raised instanceof Error && raised.cause).toBe(broke); + // And nothing partial came back: the refusal is the whole answer. + expect(raised instanceof Error && raised.message).not.toContain("[1"); + owner.close(); + }); }); describe("Tier YQ — two real producers select before they bind", () => { @@ -550,6 +610,26 @@ describe("Tier YQ — acceptance, teardown, then selection", () => { expect(text(run).trim()).toBe("widget"); }); + it("YQ4: a queried Markdown body finishes before the result is selected", function* () { + // The completion order a reader of the history depends on, with the query + // in place: everything the component's own body still had to do — a later + // element and the cleanup that element owns — happens before the result + // middleware is asked and before anything is captured. + const root = yield* useWorkspace({}); + const order: string[] = []; + const run = yield* runDocument(root, `\n\n{picked}\n`, { + markdown: [finishingComponent()], + registered: [sentinel(order)], + watching: order, + }); + + expect(run.outcome.ok).toBe(true); + expect(text(run).trim()).toBe("widget"); + // The sentinel ran after ``, its own cleanup unwound, and only + // then was the result composed and bound. + expect(order).toEqual(["sentinel body", "sentinel teardown", "result middleware"]); + }); + it("YQ4: no expression repairs a return its own schema rejected", function* () { const root = yield* useWorkspace({}); const run = yield* runDocument(root, `\n`, { @@ -718,6 +798,46 @@ function recordComponent(): ComponentDefinition { }; } +/** + * A Markdown value body that keeps working after it has returned. + * + * The sentinel is a registered component rather than a code block: a + * component body is where the ordering question lives, and putting executable + * JavaScript in the Markdown would be answering a different one. + */ +function finishingComponent(): ComponentDefinition { + return { + kind: "markdown", + name: "Finishing", + path: "components/Finishing.md", + meta: {}, + props: { type: "object", properties: {}, additionalProperties: false }, + returns: { + type: "object", + properties: { name: { type: "string" } }, + required: ["name"], + additionalProperties: false, + }, + bodySegments: scanSegments('\n\n\n'), + }; +} + +/** A component that records when it ran and when its own cleanup unwound. */ +function sentinel(order: string[]): ComponentRegistration { + return { + name: "Sentinel", + origin: "yq-component-test", + props: { type: "object", properties: {}, additionalProperties: false }, + *fn(): Operation { + yield* ensure(() => { + order.push("sentinel teardown"); + }); + order.push("sentinel body"); + return ""; + }, + }; +} + /** A Markdown value body whose return its own schema rejects. */ function wrongComponent(): ComponentDefinition { return { From 8ed52a480e601ad771d4dd9c86e863d6d34b3738 Mon Sep 17 00:00:00 2001 From: Taras Mankovski Date: Sun, 18 Oct 2026 16:37:38 -0400 Subject: [PATCH 3/4] =?UTF-8?q?=F0=9F=9A=A8=20Give=20each=20canonical=20qu?= =?UTF-8?q?estion=20its=20own=20receiver=20(#934)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A queried `` written inside another queried ``'s content sent the outer question's whole answer back as feedback. The outer occurrence captured the field it selected, but what the next turn received was both fields, and the outer intent carried no marker at all — so a later reader could not tell that a selection had been owed there. The cause was a single shared cell. Canonical `` is core's own body, so the Sidekick cannot ask the occurrence lookup which invocation it is in: it held the occurrence most recently opened instead. Opening the inner destination overwrote that cell, and the inner question consumed it, leaving the outer question with nothing to file against. Core now names the occurrence it is dispatching for exactly as long as that body runs. Protected dispatch already had both the invocation and the body, so the route establishes the pairing there and restores the previous one however the body leaves. The answer therefore nests the way the bodies do: a question asked inside another's content reaches its own receiver, and the enclosing question reaches its own again when its body resumes. An invocation that never reaches its body is never the answer, and an unwinding out of order removes its own entry rather than somebody else's. The Sidekick reads that instead of keeping a cell. Nothing is consumed, nothing is keyed by name, completion order or a value a document could replace, and the receiver still belongs to the exact invocation canonical capture authenticated. Each occurrence keeps its whole original answer as its own evidence and gets one acknowledged selected presentation. Cancellation, refusal and joined lifetimes are unchanged. --- packages/cli/src/repl/sidekick/controls.ts | 103 +++++++----------- packages/cli/src/repl/sidekick/profile.ts | 4 +- packages/cli/src/repl/sidekick/questions.ts | 15 ++- .../cli/tests/repl-sidekick-lifecycle.test.ts | 76 +++++++++++++ packages/core/host.ts | 1 + .../core/src/component-result-destinations.ts | 59 +++++++++- packages/core/src/generated-xmd.ts | 12 +- 7 files changed, 197 insertions(+), 73 deletions(-) diff --git a/packages/cli/src/repl/sidekick/controls.ts b/packages/cli/src/repl/sidekick/controls.ts index 021c2e299..1110f84c3 100644 --- a/packages/cli/src/repl/sidekick/controls.ts +++ b/packages/cli/src/repl/sidekick/controls.ts @@ -56,6 +56,7 @@ import type { ResultDestinationEntry, ResultOccurrence, ResultOccurrenceLookup, + RunningOccurrenceReader, } from "@executablemd/core/host"; import type { FunctionComponentDefinition, @@ -412,25 +413,25 @@ export interface SidekickDestinations { entry(definition: FunctionComponentDefinition): ResultDestinationEntry; /** The entry one selected protected name is routed through. */ selected(name: string): ResultDestinationEntry; - /** Take the lookup canonical execution hands this host at installation. */ - installed(lookup: ResultOccurrenceLookup): void; + /** Take the capabilities canonical execution hands this host at installation. */ + installed(lookup: ResultOccurrenceLookup, running: RunningOccurrenceReader): void; /** The occurrence this invocation is in, when it is an owned queried one. */ of(invocation: ComponentInvocation): SidekickOccurrence | undefined; /** - * The occurrence a selected protected control is about to run in, taken once. + * The occurrence whose body is running right now, when it is a selected one. * * Canonical `` is the only control this conversation does not answer * for, so its body is core's and the lookup above is unreachable from inside * it: the one thing that runs there on this host's behalf is the question - * provider. Core opens this destination for that exact occurrence and then - * runs that invocation, so what the provider takes here is the occurrence - * whose body is asking — not the last one to finish, and not a name match. + * provider. Core names the occurrence it is dispatching for the duration of + * that body, and this reads that — so a question asked inside another + * question's content reaches its own receiver, and the enclosing one still + * reaches its own afterwards. * - * Taken rather than read, because one occurrence asks one question. A - * provider that asked twice would find nothing the second time and file - * nothing, which is what an occurrence with no destination has always done. + * Read rather than taken. Nothing is consumed, because the answer is not a + * cell somebody else can empty: it is whichever body is executing. */ - takeSelected(): SidekickOccurrence | undefined; + running(): SidekickOccurrence | undefined; } /** @@ -443,70 +444,51 @@ export interface SidekickDestinations { export function sidekickDestinations(journal: ControlJournal): SidekickDestinations { const filed = new WeakMap(); let lookup: ResultOccurrenceLookup | undefined; - /** The selected control core has opened a destination for and not yet run. */ - let awaiting: ResultOccurrence | undefined; + /** Which occurrence core is dispatching right now, as core answers it. */ + let dispatching: RunningOccurrenceReader | undefined; return { entry(definition: FunctionComponentDefinition): ResultDestinationEntry { return { definition, open: (query) => opened(query) }; }, selected(name: string): ResultDestinationEntry { - return { - selected: name, - open: (query) => - opened(query, (occurrence) => { - awaiting = occurrence; - }), - }; + return { selected: name, open: (query) => opened(query) }; }, - takeSelected(): SidekickOccurrence | undefined { - const occurrence = awaiting; - awaiting = undefined; - if (occurrence === undefined) { - return undefined; - } - const held = filed.get(occurrence); - if (held === undefined) { - return undefined; - } - return { - query: occurrence.query, - file(order: number, read?: Json): void { - held.order = order; - held.read = read; - }, - }; + running(): SidekickOccurrence | undefined { + return held(dispatching?.()); }, - installed(taken: ResultOccurrenceLookup): void { + installed(taken: ResultOccurrenceLookup, runs: RunningOccurrenceReader): void { lookup = taken; + dispatching = runs; }, of(invocation: ComponentInvocation): SidekickOccurrence | undefined { - const occurrence = lookup?.(invocation); - if (occurrence === undefined) { - return undefined; - } - const held = filed.get(occurrence); - if (held === undefined) { - return undefined; - } - return { - query: occurrence.query, - file(order: number, read?: Json): void { - held.order = order; - held.read = read; - }, - }; + return held(lookup?.(invocation)); }, }; + /** One occurrence of this conversation's own, as its caller files against. */ + function held(occurrence: ResultOccurrence | undefined): SidekickOccurrence | undefined { + if (occurrence === undefined) { + return undefined; + } + const record = filed.get(occurrence); + if (record === undefined) { + return undefined; + } + return { + query: occurrence.query, + file(order: number, read?: Json): void { + record.order = order; + record.read = read; + }, + }; + } + /** One occurrence's destination, which is the same for every control. */ - function opened( - query: string | undefined, - announce?: (occurrence: ResultOccurrence) => void, - ): ResultDestination { - const held: Filed = { order: undefined, read: undefined }; + function opened(query: string | undefined): ResultDestination { + const record: Filed = { order: undefined, read: undefined }; return { *accept(selected: unknown): Operation { - const order = held.order; + const order = record.order; if (order === undefined || query === undefined) { // An occurrence whose body filed nothing recorded no intent to // present, so there is nothing for a presentation to belong to — a @@ -514,11 +496,10 @@ export function sidekickDestinations(journal: ControlJournal): SidekickDestinati // here, and both keep the feedback they already had. return; } - yield* journal.presented(order, Ok(parseSelected(selected)), held.read); + yield* journal.presented(order, Ok(parseSelected(selected)), record.read); }, serves(occurrence: ResultOccurrence): void { - filed.set(occurrence, held); - announce?.(occurrence); + filed.set(occurrence, record); }, }; } diff --git a/packages/cli/src/repl/sidekick/profile.ts b/packages/cli/src/repl/sidekick/profile.ts index 50b766cab..7758bc2db 100644 --- a/packages/cli/src/repl/sidekick/profile.ts +++ b/packages/cli/src/repl/sidekick/profile.ts @@ -228,8 +228,8 @@ export function sidekickCeilingInstallation(ceiling: ResponseCeiling): Execution .filter((control) => control.selected === true) .map((control) => ceiling.destinations.selected(control.name)), ]), - installed: (lookup) => { - ceiling.destinations.installed(lookup); + installed: (lookup, running) => { + ceiling.destinations.installed(lookup, running); }, }, *install(): Operation { diff --git a/packages/cli/src/repl/sidekick/questions.ts b/packages/cli/src/repl/sidekick/questions.ts index abc05b8bd..6a31b5c36 100644 --- a/packages/cli/src/repl/sidekick/questions.ts +++ b/packages/cli/src/repl/sidekick/questions.ts @@ -102,9 +102,10 @@ export function* useSidekickQuestions( * selected. * * Canonical `` is core's own body, so the occurrence lookup a control - * uses is unreachable from inside it. The destination core opened for that - * exact occurrence is what reaches here instead, and it reaches here before - * the asking — which is what lets the intent carry its marker. + * uses is unreachable from inside it. Core names the occurrence it is + * dispatching for the duration of that body instead, and this reads it + * before the asking — which is what lets the intent carry its marker, and + * what keeps nested questions from taking each other's receiver. */ destinations?: SidekickDestinations, ): Operation { @@ -124,9 +125,11 @@ export function* useSidekickQuestions( "evaluating none — so there is no response for an answer to belong to.", ); } - // Taken before anybody is asked, and taken once: this is the occurrence - // core opened a destination for and is now running. - const mine = destinations?.takeSelected(); + // Read before anybody is asked: this is the occurrence whose body core + // is dispatching, which is the one asking. A question asked inside + // another question's content therefore reaches its own receiver, and + // the enclosing question still reaches its own when its body resumes. + const mine = destinations?.running(); const selecting = mine?.query !== undefined; // Before the asking. A question waiting when a process stops has an // intent and no outcome, which is exactly what an interrupted operation diff --git a/packages/cli/tests/repl-sidekick-lifecycle.test.ts b/packages/cli/tests/repl-sidekick-lifecycle.test.ts index 20f154988..1996b020a 100644 --- a/packages/cli/tests/repl-sidekick-lifecycle.test.ts +++ b/packages/cli/tests/repl-sidekick-lifecycle.test.ts @@ -734,6 +734,82 @@ describe("Tier R6 — a reply asks, and the Sidekick owns the answer", () => { expect(JSON.parse(held.fake.prompts[1] ?? "")).toBe("yes"); }); + it("R6: nested queried questions each keep their own receiver", function* () { + // The shape the defect was found with: a queried outer `` whose + // admitted content holds a queried inner one. Each occurrence must keep + // the receiver core opened for it — the inner one running inside the + // outer's body must not consume the outer's. + const TWO = { + type: "object", + properties: { public: { type: "string" }, private: { type: "string" } }, + required: ["public", "private"], + additionalProperties: false, + } as const; + const schema = JSON.stringify(TWO); + const held = yield* useHarness(); + held.fake.script({ + reply: + `Outer.\n` + + `Inner.\n` + + `\n\n{picked}/{inner}\n\n`, + }); + held.fake.script({ reply: "Both came back.\n" }); + + const sent = yield* sending(held, "ask me twice"); + // The inner question is asked first: it runs while the outer's content is + // being rendered, which is exactly why it can take the outer's place. + const first = yield* asked(held.owner.questions); + expect(first.message).toContain("Inner."); + expect(first.submit({ public: "inner yes", private: "inner unselected" }).kind).toBe( + "answered", + ); + const second = yield* asked(held.owner.questions); + expect(second.message).toContain("Outer."); + expect(second.submit({ public: "outer yes", private: "outer unselected" }).kind).toBe( + "answered", + ); + + const answered = yield* sent; + if (!answered.ok) { + throw answered.error; + } + // Both captures are the selected field, which is what the reply rendered. + expect(replied(held, 1).text.trim()).toBe("outer yes/inner yes"); + + const written = yield* records(held.execution); + const intents = pairs(written, "control").filter((one) => one["component"] === "Elicit"); + // Two intents, in asking order, and **both** marked before their work. + expect(intents).toHaveLength(2); + expect(intents.map((one) => one["presentation"])).toEqual(["selected-v1", "selected-v1"]); + // Each original answer stands whole as its own occurrence's evidence. + const outcomes = intents.map((intent) => + pairs(written, "control-outcome").find((one) => one["order"] === intent["order"]), + ); + expect(outcomes.map((one) => one?.["observed"])).toEqual([ + { public: "inner yes", private: "inner unselected" }, + { public: "outer yes", private: "outer unselected" }, + ]); + // Two acknowledged presentations, matching those orders, each holding its + // own selected value. + const presentations = written.filter((one) => one.kind === "control-presentation"); + expect(presentations).toHaveLength(2); + expect( + presentations.map((one) => + one.kind === "control-presentation" ? [one.order, one.selected] : undefined, + ), + ).toEqual([ + [intents[0]?.["order"], "inner yes"], + [intents[1]?.["order"], "outer yes"], + ]); + // And what the next turn was sent is the two selected values and nothing + // else: neither unselected field leaks as raw feedback. + const delivered = held.fake.prompts[1] ?? ""; + expect(delivered).toContain("inner yes"); + expect(delivered).toContain("outer yes"); + expect(delivered).not.toContain("inner unselected"); + expect(delivered).not.toContain("outer unselected"); + }); + it("R6: a queried question nobody could be asked keeps its marker and sends nothing raw", function* () { // The interrupted arm, reached the way the surface actually refuses one: // a schema the bounded form language cannot draw. The question was diff --git a/packages/core/host.ts b/packages/core/host.ts index 5d10dd994..2838e7ef2 100644 --- a/packages/core/host.ts +++ b/packages/core/host.ts @@ -296,6 +296,7 @@ export type { ResultDestinationInstallation, ResultOccurrence, ResultOccurrenceLookup, + RunningOccurrenceReader, } from "./src/component-result-destinations.ts"; /** * The pure components every generated evaluation may write, for a host that diff --git a/packages/core/src/component-result-destinations.ts b/packages/core/src/component-result-destinations.ts index 8381b6d9f..e455e6667 100644 --- a/packages/core/src/component-result-destinations.ts +++ b/packages/core/src/component-result-destinations.ts @@ -126,7 +126,7 @@ export type ResultDestinationEntry = */ export interface ResultDestinationInstallation { readonly destinations: readonly ResultDestinationEntry[]; - installed?(lookup: ResultOccurrenceLookup): void; + installed?(lookup: ResultOccurrenceLookup, running: RunningOccurrenceReader): void; } /** How a host asks for the occurrence one invocation of its own is in. */ @@ -134,6 +134,23 @@ export type ResultOccurrenceLookup = ( invocation: ComponentInvocation, ) => ResultOccurrence | undefined; +/** + * How a host asks which occurrence's body is running right now. + * + * For the one case where the lookup above is unreachable: a protected + * component's body is core's own, so a host that selected the name has no + * invocation to ask with — the only thing of its running there is whatever + * middleware that body crosses. This answers from the invocation canonical + * dispatch is executing, which nests the way the bodies do: an occurrence + * running inside another's content is the answer while it runs, and the + * enclosing one is the answer again afterwards. + * + * It is not "the last one opened". An occurrence that opened and then failed + * before its body ran is never the answer, and nothing here is keyed by name, + * by completion order or by a value a document could replace. + */ +export type RunningOccurrenceReader = () => ResultOccurrence | undefined; + /** This execution's own destinations, as canonical expansion consults them. */ export interface ResultDestinationRoute { /** Whether this execution owns a destination for this exact implementation. */ @@ -168,6 +185,16 @@ export interface ResultDestinationRoute { fn: unknown, request: { readonly component: string; readonly query: string | undefined }, ): OpenedDestination | undefined; + /** + * Run `body` as the occurrence this invocation opened a destination for. + * + * Canonical dispatch wraps a protected component's body with this, so the + * answer to "which occurrence is running" is scope-bound: it is established + * before the body and restored when the body leaves, however it leaves. A + * nested body therefore shadows its enclosing one only while it runs, and an + * invocation that never reaches its body is never the answer. + */ + entered(invocation: ComponentInvocation, body: Operation): Operation; /** End the route with its execution. */ revoke(): void; } @@ -195,6 +222,10 @@ export function createResultDestinationRoute( // Keyed by the exact invocation object the engine minted, held weakly: a // receiver's lifetime is its occurrence's, and nothing here keeps one alive. const open = new WeakMap(); + // The invocations whose bodies are running, innermost last. A stack rather + // than a cell because bodies nest: one protected component's content may + // hold another, and each has to be the answer while it is the one running. + const entering: ComponentInvocation[] = []; let live = true; // Canonical resolution's own answers, each standing for the implementation it @@ -265,14 +296,36 @@ export function createResultDestinationRoute( }, }; }, + *entered(invocation: ComponentInvocation, body: Operation): Operation { + entering.push(invocation); + try { + return yield* body; + } finally { + // Removed by identity rather than by popping blindly: a body that + // unwound out of order would otherwise leave somebody else's + // invocation standing as the one running. + const at = entering.lastIndexOf(invocation); + if (at !== -1) { + entering.splice(at, 1); + } + } + }, revoke(): void { live = false; owned.clear(); + entering.length = 0; }, }; - installation?.installed?.((invocation: ComponentInvocation) => - live ? open.get(invocation) : undefined, + installation?.installed?.( + (invocation: ComponentInvocation) => (live ? open.get(invocation) : undefined), + () => { + if (!live) { + return undefined; + } + const invocation = entering.at(-1); + return invocation === undefined ? undefined : open.get(invocation); + }, ); return route; } diff --git a/packages/core/src/generated-xmd.ts b/packages/core/src/generated-xmd.ts index ccfc6382b..0980d7204 100644 --- a/packages/core/src/generated-xmd.ts +++ b/packages/core/src/generated-xmd.ts @@ -1097,7 +1097,17 @@ class GeneratedComponentResolution implements ComponentResolution { throw new GeneratedXmdError(CONSTRUCT.component); } holdForm(plannedForm(byForm, invocation).form, invocation); - return yield* body; + // Named as the occurrence running this body, for its duration. A protected + // component's body is core's own, so a host that selected the name has no + // invocation of its own to ask the route with — and whatever of its runs + // in there needs to reach *this* occurrence's receiver rather than the one + // some other occurrence opened. Scope-bound, so a body nested in this + // one's content shadows it only while that body runs. + const destinations = this.#destinations; + if (destinations === undefined) { + return yield* body; + } + return yield* destinations.entered(invocation, body); } /** The frames this fragment's own imports record into. */ From cf0678bf23764ebc2dfb41701026bae620416d8e Mon Sep 17 00:00:00 2001 From: Taras Mankovski Date: Sun, 18 Oct 2026 18:16:43 -0400 Subject: [PATCH 4/4] =?UTF-8?q?=F0=9F=9A=A8=20Give=20an=20overlapping=20qu?= =?UTF-8?q?estion=20its=20own=20receiver=20(#934)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Both reviews of the integrated head found the same remaining defect, and it is this: the occurrence a protected body is dispatching for was kept in one array per execution, innermost last, and read as "the last one entered". That is a nesting answer. Two admitted concurrent branches are not nested — a branch that has entered its question's body and is waiting inside its own content is still on that array when a sibling branch asks, and the sibling reads the waiting one's receiver. The retained observation: one `` with two `` children, each asking a queried canonical ``. The first branch's question content holds an ordinary `` read open, so the second branch asks first; releasing the read lets the first branch ask while the second is still waiting to be answered. Both people's answers arrive normally and both selected captures reach their bindings — but the first branch filed its order against the second's receiver, so its own destination had nothing to present, and its successful selected fact came back as incomplete. The answer is now a fact about where the asking is, rather than about what this execution did last. Canonical dispatch says which invocation it is running the body of on that body's own scope, and the provider asks for it from the scope it is asking in. Concurrent branches are concurrent scopes, so each receives its own however their suspensions interleave, and a body nested in another's content shadows the enclosing one only within itself. The context is this route's own and unexported, and what it holds is still resolved through the receivers this route opened: an invocation it opened nothing for — including one another execution's dispatch is running — reaches no receiver. Nothing else moved. Authentication is still the exact definition or the selected protected name, revocation is still per invocation, the answer is still core's own ``, and each successful queried question still writes one marked intent, one whole original answer and one acknowledged selected presentation. No composition was restricted. The new lifecycle row drives that overlap through the real owner, with the real evaluator, the real form provider and the reply's own ordinary read held by the case. It asserts both captures, both whole answers, both marked intents, one acknowledged presentation per question order, the intervening ordinary `{}` read that owes none, and feedback carrying the two selected values with no incomplete result and no unselected field. The nested row stays. --- packages/cli/src/repl/sidekick/controls.ts | 21 +-- packages/cli/src/repl/sidekick/questions.ts | 20 +-- .../repl/issue-883/sidekick-harness.ts | 10 ++ .../cli/tests/repl-sidekick-lifecycle.test.ts | 129 ++++++++++++++++++ .../core/src/component-result-destinations.ts | 77 ++++++----- 5 files changed, 208 insertions(+), 49 deletions(-) diff --git a/packages/cli/src/repl/sidekick/controls.ts b/packages/cli/src/repl/sidekick/controls.ts index 1110f84c3..996f8aaaa 100644 --- a/packages/cli/src/repl/sidekick/controls.ts +++ b/packages/cli/src/repl/sidekick/controls.ts @@ -418,20 +418,21 @@ export interface SidekickDestinations { /** The occurrence this invocation is in, when it is an owned queried one. */ of(invocation: ComponentInvocation): SidekickOccurrence | undefined; /** - * The occurrence whose body is running right now, when it is a selected one. + * The occurrence whose body this call is inside of, when it is a selected one. * * Canonical `` is the only control this conversation does not answer * for, so its body is core's and the lookup above is unreachable from inside * it: the one thing that runs there on this host's behalf is the question - * provider. Core names the occurrence it is dispatching for the duration of - * that body, and this reads that — so a question asked inside another - * question's content reaches its own receiver, and the enclosing one still - * reaches its own afterwards. + * provider. Core names the occurrence it is dispatching on that body's own + * scope, and this asks from where the provider is running — so a question + * asked inside another question's content reaches its own receiver, and a + * question asked from one admitted branch reaches its own while another + * branch's question is still waiting. * * Read rather than taken. Nothing is consumed, because the answer is not a - * cell somebody else can empty: it is whichever body is executing. + * cell somebody else can empty: it is where the asking is. */ - running(): SidekickOccurrence | undefined; + running(): Operation; } /** @@ -444,7 +445,7 @@ export interface SidekickDestinations { export function sidekickDestinations(journal: ControlJournal): SidekickDestinations { const filed = new WeakMap(); let lookup: ResultOccurrenceLookup | undefined; - /** Which occurrence core is dispatching right now, as core answers it. */ + /** Which occurrence core is dispatching a caller's body for, as core answers it. */ let dispatching: RunningOccurrenceReader | undefined; return { entry(definition: FunctionComponentDefinition): ResultDestinationEntry { @@ -453,8 +454,8 @@ export function sidekickDestinations(journal: ControlJournal): SidekickDestinati selected(name: string): ResultDestinationEntry { return { selected: name, open: (query) => opened(query) }; }, - running(): SidekickOccurrence | undefined { - return held(dispatching?.()); + *running(): Operation { + return held(dispatching === undefined ? undefined : yield* dispatching()); }, installed(taken: ResultOccurrenceLookup, runs: RunningOccurrenceReader): void { lookup = taken; diff --git a/packages/cli/src/repl/sidekick/questions.ts b/packages/cli/src/repl/sidekick/questions.ts index 6a31b5c36..6701d7cb3 100644 --- a/packages/cli/src/repl/sidekick/questions.ts +++ b/packages/cli/src/repl/sidekick/questions.ts @@ -103,9 +103,10 @@ export function* useSidekickQuestions( * * Canonical `` is core's own body, so the occurrence lookup a control * uses is unreachable from inside it. Core names the occurrence it is - * dispatching for the duration of that body instead, and this reads it - * before the asking — which is what lets the intent carry its marker, and - * what keeps nested questions from taking each other's receiver. + * dispatching on that body's own scope instead, and this asks for it from + * where the asking happens — which is what lets the intent carry its + * marker, and what keeps two questions that are open at once from taking + * each other's receiver. */ destinations?: SidekickDestinations, ): Operation { @@ -125,11 +126,14 @@ export function* useSidekickQuestions( "evaluating none — so there is no response for an answer to belong to.", ); } - // Read before anybody is asked: this is the occurrence whose body core - // is dispatching, which is the one asking. A question asked inside - // another question's content therefore reaches its own receiver, and - // the enclosing question still reaches its own when its body resumes. - const mine = destinations?.running(); + // Asked for from inside the body that is asking, before anybody is + // asked: the occurrence is read from this call's own scope, so it is + // this question's. A question asked inside another question's content + // therefore reaches its own receiver, the enclosing question still + // reaches its own when its body resumes, and a question asked from one + // admitted branch reaches its own while another branch's question is + // still waiting to be answered. + const mine = destinations === undefined ? undefined : yield* destinations.running(); const selecting = mine?.query !== undefined; // Before the asking. A question waiting when a process stops has an // intent and no outcome, which is exactly what an interrupted operation diff --git a/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts b/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts index c60d2e786..0cb151fb9 100644 --- a/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts +++ b/packages/cli/tests/fixtures/repl/issue-883/sidekick-harness.ts @@ -117,6 +117,15 @@ export function* useHarness( * only way to observe what Stop waits for. */ readonly fill?: (source: string) => Operation>; + /** + * The root data read, replaced whole, so a case can hold one read open. + * + * Replaced at the same seam `fill` is, and for the same reason: the read a + * reply writes is ordinary, and what a case needs is to decide when it + * answers. A reply whose question waits on this read is a reply with a + * question still to ask while another of its own is already waiting. + */ + readonly bindings?: RootReading["bindings"]; } = {}, ): Operation { // An entry's eval block compiles through a module this host has to supply, so @@ -209,6 +218,7 @@ export function* useHarness( const root: RootReading = { ...rootReads(session, profile), + ...(extra.bindings === undefined ? {} : { bindings: extra.bindings }), // deno-lint-ignore require-yield *fill(source: string): Operation> { if (extra.fill !== undefined) { diff --git a/packages/cli/tests/repl-sidekick-lifecycle.test.ts b/packages/cli/tests/repl-sidekick-lifecycle.test.ts index 1996b020a..3c620088c 100644 --- a/packages/cli/tests/repl-sidekick-lifecycle.test.ts +++ b/packages/cli/tests/repl-sidekick-lifecycle.test.ts @@ -27,6 +27,7 @@ import { ensure, Ok, spawn, suspend, until, withResolvers } from "effection"; import type { Operation, Result, Task } from "effection"; import { Execution } from "@executablemd/core"; +import type { Json } from "@executablemd/core"; import type { ExecutionInstallation } from "@executablemd/core/host"; import { submitForSidekick } from "../src/repl/sidekick/admission.ts"; @@ -810,6 +811,134 @@ describe("Tier R6 — a reply asks, and the Sidekick owns the answer", () => { expect(delivered).not.toContain("outer unselected"); }); + it("R6: overlapping queried questions each keep their own receiver", function* () { + // The shape the defect was found with, and the one nesting cannot reach: + // two admitted concurrent branches, each asking its own question, with + // the first one's turn to ask arriving while the second's is already + // waiting. Neither occurrence encloses the other, so "whichever body was + // entered last" names the wrong one — and the occurrence that asked + // second here is the one that must still present what it selected. + const TWO = { + type: "object", + properties: { public: { type: "string" }, private: { type: "string" } }, + required: ["public", "private"], + additionalProperties: false, + } as const; + const schema = JSON.stringify(TWO); + // The reply's own ordinary read, held until the case releases it. The + // first question's content waits on it, which is what lets the second + // branch ask first and stay waiting while the first one asks. + const reading = withResolvers(); + const held = yield* useHarness(undefined, { + *bindings(): Operation>>> { + yield* reading.operation; + return Ok({}); + }, + }); + held.fake.script({ + reply: + "\n\n" + + `First.` + + `\n` + + `Second.` + + `\n` + + "\n\n", + }); + held.fake.script({ reply: "Both came back.\n" }); + + const sent = yield* sending(held, "ask me from two branches"); + // The second branch asks while the first is still inside its own + // content's read. That is the overlap: the first question's occurrence + // has been entered and has not asked yet. + const second = yield* asked(held.owner.questions); + expect(second.message).toContain("Second."); + + // Subscribed before the read is released, so the question the first + // branch asks next cannot be published between the release and the wait. + const changes = yield* held.owner.questions.changes; + reading.resolve(); + let first = held.owner.questions.pending; + while (first === undefined || first === second) { + const next = yield* changes.next(); + if (next.done === true) { + throw new Error("that owner stopped publishing questions before it asked one"); + } + first = next.value; + } + expect(first.message).toContain("First."); + + // Answered in the order they were asked *in*, not the order they were + // asked: the second branch is still waiting while the first is answered. + expect(first.submit({ public: "first yes", private: "first unselected" }).kind).toBe( + "answered", + ); + expect(second.submit({ public: "second yes", private: "second unselected" }).kind).toBe( + "answered", + ); + + const answered = yield* sent; + if (!answered.ok) { + throw answered.error; + } + // Both captures are the selected field, which is what each branch + // rendered. + const text = replied(held, 1).text; + expect(text).toContain("first yes"); + expect(text).toContain("second yes"); + + const written = yield* records(held.execution); + const intents = pairs(written, "control").filter((one) => one["component"] === "Elicit"); + // Two intents, in asking order, and both marked before their work. + expect(intents).toHaveLength(2); + expect(intents.map((one) => one["arguments"])).toEqual([ + { message: "Second." }, + { message: "First." }, + ]); + expect(intents.map((one) => one["presentation"])).toEqual(["selected-v1", "selected-v1"]); + // Each original answer stands whole as its own occurrence's evidence. + const outcomes = intents.map((intent) => + pairs(written, "control-outcome").find((one) => one["order"] === intent["order"]), + ); + expect(outcomes.map((one) => one?.["observed"])).toEqual([ + { public: "second yes", private: "second unselected" }, + { public: "first yes", private: "first unselected" }, + ]); + // The read the first question waited on is an ordinary successful + // observation of this conversation's own, between the two questions. It + // owes no presentation, and having run between them takes nothing from + // the question that asked after it. + const read = pairs(written, "control").filter((one) => one["component"] === "REPL.Bindings"); + expect(read).toHaveLength(1); + expect(read[0]?.["presentation"]).toBe(undefined); + expect( + pairs(written, "control-outcome").find((one) => one["order"] === read[0]?.["order"])?.[ + "observed" + ], + ).toEqual({}); + // Two acknowledged presentations, one for each of those two question + // orders, each holding its own selected value. Looked up by the order + // they belong to rather than read in sequence: these are written when + // each branch's own occurrence finishes, and the branch answered first + // finishes first — which is the overlap, not a defect in it. + const presentations = written.filter((one) => one.kind === "control-presentation"); + expect(presentations).toHaveLength(2); + const selected = (order: unknown): unknown => { + const found = presentations.find((one) => one.order === order); + return found?.kind === "control-presentation" ? found.selected : undefined; + }; + expect(selected(intents[0]?.["order"])).toBe("second yes"); + expect(selected(intents[1]?.["order"])).toBe("first yes"); + // And what the next turn was sent is the two selected values: neither + // question is reported as having selected something nobody recorded, and + // neither unselected field leaks as raw feedback. + const delivered = held.fake.prompts[1] ?? ""; + expect(delivered).toContain("first yes"); + expect(delivered).toContain("second yes"); + expect(delivered).not.toContain("first unselected"); + expect(delivered).not.toContain("second unselected"); + expect(delivered).not.toContain("never recorded"); + }); + it("R6: a queried question nobody could be asked keeps its marker and sends nothing raw", function* () { // The interrupted arm, reached the way the surface actually refuses one: // a schema the bounded form language cannot draw. The question was diff --git a/packages/core/src/component-result-destinations.ts b/packages/core/src/component-result-destinations.ts index e455e6667..19ada4abf 100644 --- a/packages/core/src/component-result-destinations.ts +++ b/packages/core/src/component-result-destinations.ts @@ -40,6 +40,7 @@ * *its own* occurrence is the only thing it can do with that lookup. */ +import { createContext } from "effection"; import type { Operation } from "effection"; import type { ComponentInvocation } from "./invocation-identity.ts"; @@ -135,21 +136,25 @@ export type ResultOccurrenceLookup = ( ) => ResultOccurrence | undefined; /** - * How a host asks which occurrence's body is running right now. + * How a host asks which occurrence's body it is running inside of. * * For the one case where the lookup above is unreachable: a protected * component's body is core's own, so a host that selected the name has no * invocation to ask with — the only thing of its running there is whatever - * middleware that body crosses. This answers from the invocation canonical - * dispatch is executing, which nests the way the bodies do: an occurrence - * running inside another's content is the answer while it runs, and the - * enclosing one is the answer again afterwards. + * middleware that body crosses. An operation rather than a plain call because + * the answer is a fact about the caller: it is read from the scope the asking + * is happening in, which is the invocation's own. * - * It is not "the last one opened". An occurrence that opened and then failed - * before its body ran is never the answer, and nothing here is keyed by name, - * by completion order or by a value a document could replace. + * So it is the occurrence of *this* body, not of whichever body entered last. + * Two admitted concurrent branches each ask from their own scope and each + * receive their own, however their suspensions interleave; a body nested in + * another's content answers with its own while it runs and leaves the + * enclosing one's standing for when that body resumes. An occurrence that + * opened and then failed before its body ran is never the answer, and nothing + * here is keyed by name, by completion order or by a value a document could + * replace. */ -export type RunningOccurrenceReader = () => ResultOccurrence | undefined; +export type RunningOccurrenceReader = () => Operation; /** This execution's own destinations, as canonical expansion consults them. */ export interface ResultDestinationRoute { @@ -189,16 +194,22 @@ export interface ResultDestinationRoute { * Run `body` as the occurrence this invocation opened a destination for. * * Canonical dispatch wraps a protected component's body with this, so the - * answer to "which occurrence is running" is scope-bound: it is established - * before the body and restored when the body leaves, however it leaves. A - * nested body therefore shadows its enclosing one only while it runs, and an - * invocation that never reaches its body is never the answer. + * answer to "which occurrence am I in" is scope-bound: it is established on + * the invocation's own scope before the body and restored when the body + * leaves, however it leaves. What reads it reads from where it is running, + * so two bodies suspended at once each keep their own answer — the fact is + * the caller's position rather than this execution's latest event. A nested + * body shadows its enclosing one only within itself, and an invocation that + * never reaches its body is never the answer. */ entered(invocation: ComponentInvocation, body: Operation): Operation; /** End the route with its execution. */ revoke(): void; } +/** One per route, so two executions nested in one scope never share a key. */ +let routes = 0; + /** * Build this execution's route from what the host stated. * @@ -222,10 +233,16 @@ export function createResultDestinationRoute( // Keyed by the exact invocation object the engine minted, held weakly: a // receiver's lifetime is its occurrence's, and nothing here keeps one alive. const open = new WeakMap(); - // The invocations whose bodies are running, innermost last. A stack rather - // than a cell because bodies nest: one protected component's content may - // hold another, and each has to be the answer while it is the one running. - const entering: ComponentInvocation[] = []; + // The invocation whose body is executing, told to that body's own scope and + // read from wherever the asking is — which is the whole of why an + // overlapping body cannot take another's receiver: two concurrent branches + // are two scopes, and each is told its own. This route's own, so a nested + // execution's dispatch neither shadows it nor is mistaken for it, and what + // it holds is resolved through the receivers below rather than trusted: an + // invocation this route opened nothing for reaches nothing here. + const dispatching = createContext( + `core/component-result-destinations:${++routes}`, + ); let live = true; // Canonical resolution's own answers, each standing for the implementation it @@ -297,33 +314,31 @@ export function createResultDestinationRoute( }; }, *entered(invocation: ComponentInvocation, body: Operation): Operation { - entering.push(invocation); - try { + // Said on the scope this body runs in, and taken off it again when the + // body leaves. Nothing is pushed anywhere this execution shares: a + // sibling suspended in its own branch holds its own answer on its own + // scope, so neither branch's turn to run can hand the other's + // occurrence to whatever asks from inside it. + return yield* dispatching.with(invocation, function* () { return yield* body; - } finally { - // Removed by identity rather than by popping blindly: a body that - // unwound out of order would otherwise leave somebody else's - // invocation standing as the one running. - const at = entering.lastIndexOf(invocation); - if (at !== -1) { - entering.splice(at, 1); - } - } + }); }, revoke(): void { live = false; owned.clear(); - entering.length = 0; }, }; installation?.installed?.( (invocation: ComponentInvocation) => (live ? open.get(invocation) : undefined), - () => { + function* (): Operation { if (!live) { return undefined; } - const invocation = entering.at(-1); + // Resolved through this route's own record of what it opened, so an + // invocation nothing here opened a destination for — including one + // another execution's dispatch is running — reaches no receiver. + const invocation = yield* dispatching.get(); return invocation === undefined ? undefined : open.get(invocation); }, );