From 621dc7536f55d7045c4a66dea3fd89f939fe5922 Mon Sep 17 00:00:00 2001 From: Kevin Veen-Birkenbach Date: Tue, 17 Nov 2026 19:05:40 +0000 Subject: [PATCH] feat(orchestrator): Gibberlink radio mode with ggwave and a fallback selector (018) MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A new radio mode sends each spoken row as ggwave frames of at most 140 bytes: frame 1 carries the full session id, later frames its 8-character prefix, each with n/m. engines.sound_of() gives every speaker one of the four audible ggwave protocols that decode every frame length, plus its own stereo position, by a stable hash. The vendored ggwave 0.4.0 (MIT, LICENSE kept, sha256 pinned in test_hub_artifacts) runs only in the /gibberlink encoder page, sandboxed into an opaque origin with eval and WebAssembly but no connection; the hub page frames it (frame-src 'self') and review pages refuse framing (frame-ancestors 'none'). The radio gear gains a fallback selector (Gibberlink, Morse, Hiss) for rows that speech cannot play. Accepted MEDUSA false positives (security.py accept after kvb-think-criticize, 2026-11-17): engines.py FTSCAN-231 INF-SCAN-2638 INF-SCAN-2057 STG009 B603; handler.py FTSC-SCAN-089 B105 EXA002 EXA006; view.py WEB-FLASK-004 FINE-043 LO002. 🎯 Fix: 91 % 💥 Break: 4 % 💸 Tokens: – ⏱️ Velocity: – 🛡️ Security: 100 % 🏆 Score: 87 🚦 Gate: ✅ 90/5, tokens and velocity <= 100, security 100 % Co-Authored-By: Claude Opus 5.5 --- README.md | 2 +- orchestrator/kvb_orchestrator/engines.py | 16 + orchestrator/kvb_orchestrator/handler.py | 10 +- orchestrator/kvb_orchestrator/view.py | 22 +- orchestrator/templates/gibberlink.html.j2 | 15 + orchestrator/templates/gibberlink.js | 50 +++ orchestrator/templates/index.html.j2 | 2 + orchestrator/templates/page-gibberlink.js | 87 +++++ orchestrator/templates/page-radioview.js | 19 +- orchestrator/templates/page-speech.js | 21 +- orchestrator/templates/radioset.js | 81 ++++- orchestrator/templates/style-ui.css | 1 + orchestrator/vendor/ggwave/LICENSE | 21 ++ orchestrator/vendor/ggwave/ggwave.js | 21 ++ tests/e2e/radio_set_kit.py | 2 + tests/e2e/test_gibberlink_e2e.py | 239 ++++++++++++ tests/e2e/test_radio_set_e2e.py | 4 +- tests/test_hub_artifacts.py | 1 + tests/test_hub_bubbles.py | 6 +- tests/test_hub_gibberlink.py | 419 ++++++++++++++++++++++ tests/test_hub_morse.py | 4 +- tests/test_hub_page.py | 2 +- tests/test_hub_radioset.py | 10 +- 23 files changed, 1021 insertions(+), 34 deletions(-) create mode 100644 orchestrator/templates/gibberlink.html.j2 create mode 100644 orchestrator/templates/gibberlink.js create mode 100644 orchestrator/templates/page-gibberlink.js create mode 100644 orchestrator/vendor/ggwave/LICENSE create mode 100644 orchestrator/vendor/ggwave/ggwave.js create mode 100644 tests/e2e/test_gibberlink_e2e.py create mode 100644 tests/test_hub_gibberlink.py diff --git a/README.md b/README.md index 1621fd6..2a5708a 100644 --- a/README.md +++ b/README.md @@ -472,7 +472,7 @@ The global install also runs the Agent Orchestrator, a local review page in whic Stream → Radio (`#stream/radio`) is the hub's radio interface. Its station list shows one line per station, the full name in the tooltip, with its state and a play or stop button; when the browser blocks autoplay, the stream fails or the CSP refuses its origin, the row and a toast say so, and one click starts the station. New stations play daily around the clock. While the hub reads a message aloud, the speaking agent pulses there and in the Orbit and Chord views, under the caption " speaking" with the message's first line; under `prefers-reduced-motion` the ring stays still. The speech bubble icon in the header (a hub setting, kept across reloads) puts a bubble at each speaking agent in the Agents graph, 3D, Hierarchy, Radio and Stream views, or in a caption bar at the bottom when the view does not show that agent: the agent being read gets the largest bubble and its words appear in time with the audio, waiting messages show a smaller `…` bubble per agent, and without speech output the same rows run at 180 words a minute, at least 1.5 s each. The composer sends on all seven channels: post and call to one agent, newsletter, broadcast, pan-pan, security and mayday to all. "Record" records with MediaRecorder; the hub transcribes the recording with whisper.cpp off the request thread (at most 120 s of audio, a 120 s timeout, four at a time), keeps it for replay in `~/.local/state/kvb-orchestrator/voice` (the newest 50) and puts the transcript into the field to edit; the message goes out as text, with the recording's host path and sha256 only when "Attach recording" is ticked. The hub transcribes at most six recordings a minute and 600 s of audio an hour. Every operator message is passkey-signed, and the hub verifies the signature against the pinned keys, each once, before it relays; `operator_message(id, text, to)` answers `match` only for the signed text and recipient; for a denial the signature covers the recipient the inbox resolved at signing, and the answer's text is only the signed reason, never the agent's own words the radio row quotes. "Cancel mayday", Evening, Sunset, Sunrise and a settings save that adds a stream URL take the passkey the same way. -The hub page loads nothing from the network: its icons come from Bootstrap Icons 1.13.1 (`orchestrator/vendor/bootstrap-icons`, MIT), inlined per page as the symbols it uses, and its 3D views from `3d-force-graph` 1.80.1 and `three` 0.186.1 (`orchestrator/vendor`, MIT, served by the hub under `/vendor/`); the speech bubbles use Comic Neue 400 latin from `@fontsource/comic-neue` 5.3.0 (`orchestrator/vendor/comic-neue`, SIL OFL 1.1), which the page fetches and adds through the FontFace API, so the CSP needs no `font-src`. In the Artifacts Tree, "Delete" on a `merged-clean` branch without skip reason, or "Delete all merged", shows the dry-run lines and asks for the passkey signature; the hub then writes a job (repository, branch, worktree and tip per item, no command) into `~/.local/state/kvb-orchestrator/cleanup/jobs`. The `kvb-orchestrator-cleanup.path` user unit runs `client/cleanup.py` on the host, which verifies the signature against the pinned keys, runs `pkgmgr branch cleanup --json --local --branch ` as a dry run in the repository, then `--apply` only when that plan names exactly the signed branch as `merged-clean` at the signed tip and worktree, refuses everything else unchanged, writes each result to `cleanup/results` and rewrites the tree file. The buttons stay disabled while the tree file says `delete_ready: false`. +The hub page loads nothing from the network: its icons come from Bootstrap Icons 1.13.1 (`orchestrator/vendor/bootstrap-icons`, MIT), inlined per page as the symbols it uses, and its 3D views from `3d-force-graph` 1.80.1 and `three` 0.186.1 (`orchestrator/vendor`, MIT, served by the hub under `/vendor/`); the radio's Gibberlink mode encodes with `ggwave` 0.4.0 (`orchestrator/vendor/ggwave`, MIT, the npm build), which only the sandboxed encoder frame `/gibberlink` loads under its own CSP, since it needs the eval and WebAssembly the hub page never allows; the speech bubbles use Comic Neue 400 latin from `@fontsource/comic-neue` 5.3.0 (`orchestrator/vendor/comic-neue`, SIL OFL 1.1), which the page fetches and adds through the FontFace API, so the CSP needs no `font-src`. In the Artifacts Tree, "Delete" on a `merged-clean` branch without skip reason, or "Delete all merged", shows the dry-run lines and asks for the passkey signature; the hub then writes a job (repository, branch, worktree and tip per item, no command) into `~/.local/state/kvb-orchestrator/cleanup/jobs`. The `kvb-orchestrator-cleanup.path` user unit runs `client/cleanup.py` on the host, which verifies the signature against the pinned keys, runs `pkgmgr branch cleanup --json --local --branch ` as a dry run in the repository, then `--apply` only when that plan names exactly the signed branch as `merged-clean` at the signed tip and worktree, refuses everything else unchanged, writes each result to `cleanup/results` and rewrites the tree file. The buttons stay disabled while the tree file says `delete_ready: false`. The Agents view "Hierarchy" draws the council's formal offices as a collapsible organigram: the Operator above the chair; in line under the chair one unit per dimension with its domain chairs (`/`) and one for the presidents (`work/`); beside the chair, on a side branch, the staff positions: organisers (`cluster/`) and single-segment offices such as `stack-architecture`. Each box shows the office and its holder, so an agent with several offices appears in each of them. A dashed line marks an additional superior, read live from the `kvb-org-rasci` register: an open task whose R (or worker) holds an office and that names another office holder A or C links that holder's first office to the agent's office for the task (the office or claimed work named like the task, else the agent's first office); the chair adds none, its solid line already runs there. On a narrow screen the chart scrolls inside its own frame, never the page. The chair in every graph is the holder of the `chair` office, not a fixed name. Appointing, handing over or recalling an office there asks for the passkey signature; the hub writes a job (office, signed holder, successor session, work; no command) into `~/.local/state/kvb-orchestrator/offices/jobs`, and the `kvb-orchestrator-offices.path` user unit runs `client/offices.py` on the host, which verifies the signature, refuses a council directory others can write, a link on the path or a holder that changed since the signature. For a takeover or recall it moves the office aside and removes it only while the claim there still names the signed holder; an appoint or takeover then runs a plain `council.py claim ` for the successor by argv. council.py itself has no flag that overrides a live holder. The same view holds the operator's agent order as a drag list with up and down buttons: `rasci.py agents order` stores it in `agent-order.json` beside the register, where it breaks ties of equal task priority and orders the chair's grants without touching any task's `--prio` pin. diff --git a/orchestrator/kvb_orchestrator/engines.py b/orchestrator/kvb_orchestrator/engines.py index 19475ca..606210c 100644 --- a/orchestrator/kvb_orchestrator/engines.py +++ b/orchestrator/kvb_orchestrator/engines.py @@ -45,6 +45,8 @@ HEARING_BUDGET = 5 * STT_SECONDS NOISE = re.compile(r"\[[^\]\n]{0,40}\]") PLACEHOLDERS = frozenset({0, 0xFFFFFFFF}) PITCH = (550, 850) +GIBBERLINK = ("AUDIBLE_NORMAL", "AUDIBLE_FAST", "AUDIBLE_FASTEST", "DT_FASTEST") +PANS = (-0.8, -0.4, 0.0, 0.4, 0.8) def voice_models(folder: Path) -> list[Path]: @@ -134,6 +136,20 @@ def pitch_of(key: str) -> int: return low + slot(key, high - low + 1) +def sound_of(key: str) -> dict[str, str | float]: + """Args: + key: the speaker's session id or directory key, as pitch_of takes it. + + Returns: + protocol: the ggwave protocol of GIBBERLINK, the four of the vendored + ggwave 0.4.0 whose frames decode at every length up to 140 bytes; + pan: the stereo position of PANS. One slot picks both, so the + speakers of distinct slots get distinct pairs. + """ + picked = slot(key, len(GIBBERLINK) * len(PANS)) + return {"protocol": GIBBERLINK[picked % len(GIBBERLINK)], "pan": PANS[picked // len(GIBBERLINK)]} + + def wav_seconds(body: bytes, seconds: int) -> float: """Args: body: the recording. diff --git a/orchestrator/kvb_orchestrator/handler.py b/orchestrator/kvb_orchestrator/handler.py index 77cd8b2..9d71ab3 100644 --- a/orchestrator/kvb_orchestrator/handler.py +++ b/orchestrator/kvb_orchestrator/handler.py @@ -16,7 +16,7 @@ from .scores import scored BODY_LIMIT = 1 << 20 UPLOAD_LIMIT = 50 << 20 -PAGE_CSP = "sandbox allow-scripts" +PAGE_CSP = "sandbox allow-scripts; frame-ancestors 'none'" SETTINGS_ROUTE = "/api/settings" TTS_ROUTE = "/api/tts" WAV_TYPE = "audio/wav" @@ -50,6 +50,7 @@ TASKS_ROUTE = "/api/tasks" GATES_ROUTE = "/api/gates" TOKEN_ROUTE = "/api/cleanup/token" VIEW_ROUTE = "/api/view" +ENCODER_ROUTE = "/gibberlink" VENDOR_ROUTE = re.compile(r"/vendor/([a-z0-9.-]{1,64})") SCRIPT_TYPE = "text/javascript; charset=utf-8" FONT_TYPE = "font/woff2" @@ -57,6 +58,7 @@ VENDOR = { "3d-force-graph.min.js": ("3d-force-graph/3d-force-graph.min.js", SCRIPT_TYPE), "three.module.js": ("three/three.module.js", SCRIPT_TYPE), "three.core.js": ("three/three.core.js", SCRIPT_TYPE), + "ggwave.js": ("ggwave/ggwave.js", SCRIPT_TYPE), "comic-neue.woff2": ("comic-neue/comic-neue-latin-400-normal.woff2", FONT_TYPE), } VOICE_ROUTE = "/api/voice" @@ -107,6 +109,8 @@ class Handler(Exchange): self.send_text(HTTPStatus.FORBIDDEN, "forbidden host") elif path == "/": self.index() + elif path == ENCODER_ROUTE: + self.encoder() elif firewall: self.answer(firewall, HTTPStatus.OK) elif diff: @@ -331,6 +335,10 @@ class Handler(Exchange): headers = {"Content-Security-Policy": csp, "X-Frame-Options": "DENY"} self.send(HTTPStatus.OK, "text/html; charset=utf-8", page.encode("utf-8"), headers) + def encoder(self) -> None: + page, csp = self.server.hub.encoder(secrets.token_urlsafe(18)) + self.send(HTTPStatus.OK, "text/html; charset=utf-8", page.encode("utf-8"), {"Content-Security-Policy": csp}) + def vendored(self, name: str, content_type: str) -> None: headers = {"Content-Security-Policy": PLAIN_CSP, "Cache-Control": "private, max-age=86400"} self.attempt((self.server.hub.vendor / name).read_bytes, lambda data: self.send(HTTPStatus.OK, content_type, data, headers)) diff --git a/orchestrator/kvb_orchestrator/view.py b/orchestrator/kvb_orchestrator/view.py index df0646e..7d77d7c 100644 --- a/orchestrator/kvb_orchestrator/view.py +++ b/orchestrator/kvb_orchestrator/view.py @@ -15,7 +15,7 @@ from .council import ( silence_of, ) from .crons import queue_entries -from .engines import pitch_of +from .engines import pitch_of, sound_of from .errors import ToolError from .events import KINDS, VIEWS from .fields import decode, instant, single @@ -47,9 +47,13 @@ RADIO_WINDOW = 86400 JOBS_SHOWN = 20 ACTIVE = 900 INDEX_CSP = ( - "default-src 'none'; script-src 'nonce-{0}'; style-src 'nonce-{0}'; connect-src 'self'; media-src {1}; " + "default-src 'none'; script-src 'nonce-{0}'; style-src 'nonce-{0}'; connect-src 'self'; media-src {1}; frame-src 'self'; " "base-uri 'none'; form-action 'none'; frame-ancestors 'none'" ) +ENCODER_CSP = ( + "sandbox allow-scripts; default-src 'none'; script-src 'nonce-{0}' 'unsafe-eval' 'wasm-unsafe-eval'; connect-src 'none'; " + "base-uri 'none'; form-action 'none'; frame-ancestors 'self'" +) def badges(inbox: list[dict], claims: list[dict], jobs: list[dict], now: float) -> dict[str, int]: @@ -111,7 +115,7 @@ class View: called = [directory.at(key, row["ts"]) or name for key, name in zip(targets, row["to"], strict=True)] speaker = directory.at(source, row["ts"]) or row["from"] word, rest = phrase_parts(row["class"], speaker, called, row["text"]) - spoken = {"speech": joined((word, rest)), "word": word, "rest": rest, "voice": self.speech.voice_of(source), "pitch": pitch_of(source), "speaker": speaker, "called": called} + spoken = {"speech": joined((word, rest)), "word": word, "rest": rest, "voice": self.speech.voice_of(source), "pitch": pitch_of(source), **sound_of(source), "speaker": speaker, "called": called} read = read_of(inlined, row["ts"]) radio.append({**row, "source": source, "targets": targets, "now": directory.now(source), **spoken, **read}) grant_rows = [{**grant, "target": directory.key(grant["to"], grant["ts"])} for grant in grants(history, (begin, end), claims, tasks)] @@ -235,3 +239,15 @@ class View: state = self.state(now - RADIO_WINDOW, now, now, 0) page = self.templates.get_template("index.html.j2").render(nonce=nonce, state=state, view=self.view_store.get(), icons=self.icons, emoji_bases=sorted(signing.EMOJI_BASES)) return page, INDEX_CSP.format(nonce, " ".join(["'self'", *state["media"]])) + + def encoder(self, nonce: str) -> tuple[str, str]: + """Args: + nonce: the response's script nonce. + + Returns: + The Gibberlink encoder page and its own CSP: the vendored ggwave + needs eval and WebAssembly, which the hub page never allows, so + the server sandboxes it into an opaque origin however it loads, + with no connection at all. + """ + return self.templates.get_template("gibberlink.html.j2").render(nonce=nonce), ENCODER_CSP.format(nonce) diff --git a/orchestrator/templates/gibberlink.html.j2 b/orchestrator/templates/gibberlink.html.j2 new file mode 100644 index 0000000..ac04fcc --- /dev/null +++ b/orchestrator/templates/gibberlink.html.j2 @@ -0,0 +1,15 @@ + + + + +Gibberlink encoder + + + + + diff --git a/orchestrator/templates/gibberlink.js b/orchestrator/templates/gibberlink.js new file mode 100644 index 0000000..02dddd8 --- /dev/null +++ b/orchestrator/templates/gibberlink.js @@ -0,0 +1,50 @@ +const Gibberlink = (() => { + "use strict"; + const VOLUME = 50; + const PREFIX = "GGWAVE_PROTOCOL_"; + + /** + * @param {object} ggwave the loaded ggwave module. + * @param {object} request protocol, a ggwave protocol name without its prefix, and frames, the frame texts. + * @returns {object} rate and samples: the samples of each frame at ggwave's own output rate; the vendored build's frames at 44.1 kHz do not decode, so the page resamples instead. + */ + function encode(ggwave, request) { + const {protocol, frames} = request; + const key = `${PREFIX}${protocol}`; + if (typeof protocol !== "string" || !Object.hasOwn(ggwave.ProtocolId, key) || !Array.isArray(frames) || !frames.every((frame) => typeof frame === "string")) { + throw new Error("refused: the request needs a known protocol and text frames"); + } + const parameters = ggwave.getDefaultParameters(); + const instance = ggwave.init(parameters); + try { + return {rate: parameters.sampleRateOut, samples: frames.map((frame) => { + const wave = ggwave.encode(instance, frame, ggwave.ProtocolId[key], VOLUME); + return new Float32Array(wave.buffer.slice(wave.byteOffset, wave.byteOffset + wave.length)); + })}; + } finally { + ggwave.free(instance); + } + } + + /** + * @param {Window} scope the encoder frame's window; it answers only its parent. + * @param {Promise} ready the ggwave module once loaded. + */ + function serve(scope, ready) { + scope.addEventListener("message", (event) => { + if (event.source !== scope.parent || !event.data || typeof event.data.id !== "number") { + return; + } + const {id} = event.data; + ready.then((ggwave) => encode(ggwave, event.data)).then( + ({rate, samples}) => scope.parent.postMessage({id, rate, samples}, "*", samples.map((part) => part.buffer)), + (error) => scope.parent.postMessage({id, error: String((error && error.message) || error)}, "*"), + ); + }); + } + + return {VOLUME, encode, serve}; +})(); +if (typeof module === "object" && module.exports) { + module.exports = Gibberlink; +} diff --git a/orchestrator/templates/index.html.j2 b/orchestrator/templates/index.html.j2 index 967b2ae..a78c8c2 100644 --- a/orchestrator/templates/index.html.j2 +++ b/orchestrator/templates/index.html.j2 @@ -631,6 +631,8 @@ pre.notes { margin: 0; padding: 8px 10px; background: var(--sunken); border-radi {% include "page-morse.js" %} +{% include "page-gibberlink.js" %} + {% include "page-mic.js" %} {% include "page-bubbles.js" %} diff --git a/orchestrator/templates/page-gibberlink.js b/orchestrator/templates/page-gibberlink.js new file mode 100644 index 0000000..dbe92f5 --- /dev/null +++ b/orchestrator/templates/page-gibberlink.js @@ -0,0 +1,87 @@ + const GIBBER = {gap: 0.3, timeout: 15000, route: "/gibberlink"}; + const gibber = {frame: null, ready: null, pending: new Map(), next: 0}; + + function gibberFrame() { + if (!gibber.frame) { + const frame = h("iframe", {class: "gibberlink-encoder", src: GIBBER.route, sandbox: "allow-scripts", title: "Gibberlink encoder", "aria-hidden": "true", tabindex: "-1", hidden: true}); + gibber.ready = new Promise((resolve) => frame.addEventListener("load", resolve, {once: true})); + window.addEventListener("message", gibberAnswer); + document.body.append(frame); + gibber.frame = frame; + } + return gibber; + } + + function gibberAnswer(event) { + const waiting = gibber.frame && event.source === gibber.frame.contentWindow && event.data ? gibber.pending.get(event.data.id) : null; + if (!waiting) { + return; + } + gibber.pending.delete(event.data.id); + window.clearTimeout(waiting.timer); + const {rate, samples, error} = event.data; + if (error) { + waiting.reject(new Error(String(error))); + } else if (Number.isFinite(rate) && rate > 0 && Array.isArray(samples) && samples.every((part) => part instanceof Float32Array)) { + waiting.resolve({rate, samples}); + } else { + waiting.reject(new Error("the Gibberlink encoder answered no samples")); + } + } + + /** + * @param {object} step a Gibberlink step with frames and protocol. + * @returns {Promise} rate and samples: the samples of each frame from the sandboxed encoder frame, at its rate. + */ + function gibberEncode(step) { + const {frame, ready, pending} = gibberFrame(); + gibber.next += 1; + const id = gibber.next; + return new Promise((resolve, reject) => { + const timer = window.setTimeout(() => { + pending.delete(id); + reject(new Error("the Gibberlink encoder did not answer")); + }, GIBBER.timeout); + pending.set(id, {resolve, reject, timer}); + ready.then(() => frame.contentWindow.postMessage({id, protocol: step.protocol, frames: step.frames}, "*")); + }); + } + + /** + * @param {AudioContext} sound the page's audio context. + * @param {object} item the row that sounds. + * @param {object} step its Gibberlink step: frames, protocol and pan. + * @returns {Promise} whether the whole row sounded uncut: the frames one after another with a short gap, at the row's tone volume times the squelch, in the sender's stereo position. + */ + async function keyGibberlink(sound, item, step) { + const level = loudness(item.tone); + if (level <= 0 || !step.frames.length) { + return false; + } + const {rate, samples: parts} = await gibberEncode(step); + if (speech.item !== item) { + return false; + } + if (!allows(rendered(item, item.at), "gibberlink")) { + item.cut = true; + return false; + } + const gap = Math.round(rate * GIBBER.gap); + const buffer = sound.createBuffer(1, parts.reduce((sum, part) => sum + part.length + gap, 0), rate); + const data = buffer.getChannelData(0); + parts.reduce((at, part) => { + data.set(part, at); + return at + part.length + gap; + }, 0); + const source = sound.createBufferSource(); + const gain = sound.createGain(); + const pan = sound.createStereoPanner(); + gain.gain.value = level; + pan.pan.value = step.pan; + source.buffer = buffer; + source.connect(gain).connect(pan).connect(sound.destination); + voicePace(item, Infinity, buffer.duration); + const ended = sounded(item, source, buffer.duration); + source.start(); + return ended.then(() => speech.item === item && !item.cut); + } diff --git a/orchestrator/templates/page-radioview.js b/orchestrator/templates/page-radioview.js index b211ed6..bf86d28 100644 --- a/orchestrator/templates/page-radioview.js +++ b/orchestrator/templates/page-radioview.js @@ -1,10 +1,16 @@ const STATION_TONES = {playing: "ok", loading: "info", reload: "info", blocked: "warn", error: "bad", due: "teal", stopped: "neutral", idle: "neutral", off: "neutral"}; const NOTE_ID = /^[0-9a-f]{16}$/; const MODE_LABELS = { - auto: ["bi-volume-up", "Auto", "Auto: speech while the host CPU lies below the threshold, otherwise the noise burst"], - quiet: ["bi-soundwave", "Quiet", "Quiet: the noise burst only, never speech; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"], + auto: ["bi-volume-up", "Auto", "Auto: speech while the host CPU lies below the threshold, otherwise the fallback picked under Read aloud"], + quiet: ["bi-soundwave", "Quiet", "Quiet: the fallback picked under Read aloud, never speech; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"], silence: ["bi-volume-mute", "Silence", "Silence: no sound, bubbles and log only; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"], morse: ["bi-three-dots", "Morse", "Morse: every message keyed whole in Morse, in its sender's own pitch, at the hub's Morse speed; MAYDAY keys SOS"], + gibberlink: ["bi-robot", "Gibberlink", "Gibberlink: every message sent whole as ggwave data sound a machine can decode, in its sender's own protocol and stereo position; MAYDAY, PAN-PAN and Sécurité still sound their procedure word"], + }; + const FALLBACK_LABELS = { + gibberlink: ["Gibberlink", "Where speech cannot play, send the rest as ggwave data sound"], + morse: ["Morse", "Where speech cannot play, key the whole message in Morse"], + burst: ["Hiss", "Where speech cannot play, play the short noise burst"], }; const radioParts = {bars: [], devices: [], logs: [], speaks: []}; const liveParts = (kind) => radioParts[kind].filter((part) => part.root.isConnected); @@ -89,7 +95,7 @@ mode.textContent = MODE_LABELS[radioSet.mode][1]; cpu.textContent = gate.cpu === null ? "CPU ?" : `CPU ${Math.round(gate.cpu)} %`; cpu.dataset.open = String(gate.open); - cpu.title = `${gate.cpu === null ? "No host CPU sample of the last two minutes" : `Host CPU ${fixed(gate.cpu)} %`}, threshold: ${RadioSet.gateLabel(gate.threshold)}${gate.open ? "" : ", so the hub renders no new speech line and the radio plays the burst"}`; + cpu.title = `${gate.cpu === null ? "No host CPU sample of the last two minutes" : `Host CPU ${fixed(gate.cpu)} %`}, threshold: ${RadioSet.gateLabel(gate.threshold)}${gate.open ? "" : ", so the hub renders no new speech line and the radio plays the fallback"}`; } } @@ -293,10 +299,15 @@ keepRadio({muted: radioSet.muted.includes(key) ? radioSet.muted.filter((name) => name !== key) : [...radioSet.muted, key]}); redrawFilters(); }, false)); + const fallbacks = RadioSet.FALLBACKS.map((id) => chip(FALLBACK_LABELS[id][0], radioSet.fallback === id, FALLBACK_LABELS[id][1], () => { + keepRadio({fallback: id}); + redrawFilters(); + }, false)); return h("div", {class: "radio-read", "aria-label": "Read aloud"}, - h("p", {class: "muted"}, state.speech.tts ? "The radio sounds for these classes and agents, each speaker with its own voice; MAYDAY always sounds." : `The hub speaks no line: ${state.speech.tts_off}. The burst and the procedure words stand in.`), + h("p", {class: "muted"}, state.speech.tts ? "The radio sounds for these classes and agents, each speaker with its own voice; MAYDAY always sounds." : `The hub speaks no line: ${state.speech.tts_off}. The fallback and the procedure words stand in.`), h("div", {class: "chips", role: "group", "aria-label": "Classes"}, classes), agents.length ? h("div", {class: "chips", role: "group", "aria-label": "Agents"}, agents) : null, + h("div", {class: "chips radio-fallback", role: "group", "aria-label": "Fallback", title: "Fallback: what plays in Auto above the threshold and in Quiet, kept in this browser"}, h("span", {class: "chips-label"}, "Fallback"), fallbacks), morseSpeed()); } diff --git a/orchestrator/templates/page-speech.js b/orchestrator/templates/page-speech.js index c19b515..c5057c3 100644 --- a/orchestrator/templates/page-speech.js +++ b/orchestrator/templates/page-speech.js @@ -27,11 +27,11 @@ /** * @param {object|undefined} step the step the radio set plans now at the index that plays. - * @param {string} kind word, speech or burst: what plays or is about to play there. - * @returns {boolean} whether that sound may play: the planned kind, or the burst standing in for a planned speech line. + * @param {string} kind word, speech, or a fallback kind (gibberlink, morse, burst): what plays or is about to play there. + * @returns {boolean} whether that sound may play: the planned kind, or a fallback standing in for a planned speech line. */ function allows(step, kind) { - return Boolean(step) && (step.kind === kind || (kind === "burst" && step.kind === "speech")); + return Boolean(step) && (step.kind === kind || (RadioSet.FALLBACKS.includes(kind) && step.kind === "speech")); } function speechFailed(lines) { @@ -54,7 +54,7 @@ function preempt() { const {item, source} = speech; const [first] = speech.pending; - if (item && source && item.playing === "morse" && first && Voice.rank(first) < Voice.rank(item)) { + if (item && source && RadioSet.KEYED.includes(item.playing) && first && Voice.rank(first) < Voice.rank(item)) { speech.item = null; speech.pending = Voice.enqueue(speech.pending, item, SPEECH_QUEUE); source.stop(); @@ -224,8 +224,8 @@ await burst(audio, item); continue; } - if (step.kind === "morse") { - voiced = (await keyMorse(audio, item, step)) || voiced; + if (RadioSet.KEYED.includes(step.kind)) { + voiced = (await keyed(audio, item, step)) || voiced; done -= Number(item.cut); continue; } @@ -244,11 +244,16 @@ speechFailed([failed]); } if (failed && step.kind === "speech" && speech.item === item && allows(stepOf(item, done), "burst")) { - item.playing = "burst"; - await burst(audio, item); + const stand = item.row ? RadioSet.standIn(item.row, radioSet) : {kind: "burst"}; + item.playing = stand.kind; + await (stand.kind === "burst" ? burst(audio, item) : keyed(audio, item, stand)); } } + function keyed(audio, item, step) { + return step.kind === "morse" ? keyMorse(audio, item, step) : keyGibberlink(audio, item, step); + } + async function pump() { if (speech.busy || !speech.pending.length) { return; diff --git a/orchestrator/templates/radioset.js b/orchestrator/templates/radioset.js index 02a9f71..754c85a 100644 --- a/orchestrator/templates/radioset.js +++ b/orchestrator/templates/radioset.js @@ -1,7 +1,10 @@ const RadioSet = (() => { "use strict"; const KEY = "kvb-orchestrator.radio"; - const MODES = ["auto", "quiet", "silence", "morse"]; + const MODES = ["auto", "quiet", "silence", "morse", "gibberlink"]; + const FALLBACKS = ["gibberlink", "morse", "burst"]; + const KEYED = ["morse", "gibberlink"]; + const FRAME = {bytes: 140, prefix: 8, key: 64}; const TONES = ["mayday", "review", "direct", "radio"]; const CLASSES = ["post", "call", "newsletter", "broadcast", "mayday", "pan-pan", "security"]; const TO_ALL = new Set(["newsletter", "broadcast", "mayday", "pan-pan", "security"]); @@ -24,6 +27,7 @@ const RadioSet = (() => { }; const DEFAULTS = { mode: "auto", + fallback: "gibberlink", sounds: {mayday: {on: true, volume: 0.9}, review: {on: true, volume: 0.6}, direct: {on: true, volume: 0.5}, radio: {on: false, volume: 0.25}}, squelch: 1, classes: ["mayday", "pan-pan", "security"], @@ -61,6 +65,7 @@ const RadioSet = (() => { const muted = Array.isArray(raw.muted) ? raw.muted.filter((key) => typeof key === "string" && key && key.length <= TEXT_LIMIT) : []; return { mode: MODES.includes(raw.mode) ? raw.mode : DEFAULTS.mode, + fallback: FALLBACKS.includes(raw.fallback) ? raw.fallback : DEFAULTS.fallback, sounds: Object.fromEntries(TONES.map((name) => [name, tone(sounds[name], DEFAULTS.sounds[name])])), squelch: level(raw.squelch, DEFAULTS.squelch), classes: CLASSES.filter((name) => name === "mayday" || classes.includes(name)), @@ -82,11 +87,74 @@ const RadioSet = (() => { return {kind: "morse", sign: called ? row.called.join(" ") : sign, joined, text: `DE ${row.speaker} ${row.text.replace(MARKS, " ")}`, pitch: row.pitch}; } + const utf8 = (char) => { + const point = char.codePointAt(0); + return point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4; + }; + + function fitting(chars, at, room) { + let end = at; + for (let left = room; end < chars.length && utf8(chars[end]) <= left; end += 1) { + left -= utf8(chars[end]); + } + return end; + } + + function split(key, chars, count) { + const own = Array.from(key); + const full = own.slice(0, fitting(own, 0, FRAME.key)).join(""); + const prefix = own.slice(0, FRAME.prefix).join(""); + const out = []; + let at = 0; + do { + const head = `${out.length ? prefix : full} ${out.length + 1}/${count} `; + const end = fitting(chars, at, FRAME.bytes - Array.from(head).reduce((sum, char) => sum + utf8(char), 0)); + out.push(head + chars.slice(at, end).join("")); + at = end; + } while (at < chars.length); + return out; + } + /** - * @param {object} row a radio row of the state with word, rest, voice and the Morse fields. + * @param {string} key the sender's session key, the row's source; its first 64 bytes head frame 1. + * @param {string} text the message without the hub's mark. + * @returns {Array} the frames of at most 140 UTF-8 bytes, each split between characters: frame 1 the key, `1/m` and text, every later frame the key's first 8 characters, `n/m` and text. + */ + function frames(key, text) { + const chars = Array.from(text); + for (let count = 1; ;) { + const out = split(key, chars, count); + if (out.length === count) { + return out; + } + count = out.length; + } + } + + /** + * @param {object} row a radio row with source, text, protocol and pan. + * @returns {object} the whole row as kind "gibberlink": its frames, the sender's ggwave protocol and its stereo position. + */ + function gibberlink(row) { + return {kind: "gibberlink", frames: frames(row.source, row.text.replace(MARKS, "").trim()), protocol: row.protocol, pan: row.pan}; + } + + const STAND_INS = {gibberlink, morse, burst: () => ({kind: "burst"})}; + + /** + * @param {object} row a radio row of the state. + * @param {object} set the radio set. + * @returns {object} the step its fallback pick plays where speech cannot: Gibberlink frames, Morse keying or the burst. + */ + function standIn(row, set) { + return STAND_INS[set.fallback](row); + } + + /** + * @param {object} row a radio row of the state with word, rest, voice, the Morse and the Gibberlink fields. * @param {object} set the radio set. * @param {Object} live tts and open: whether the hub speaks at all and whether its CPU gate is open. - * @returns {Array<{kind: string, text: (string|undefined)}>} what plays, in order: in Morse the whole row keyed once; else the procedure word line in every mode, then the spoken rest in Auto below the threshold, else the noise burst, nothing more in Silence. + * @returns {Array<{kind: string, text: (string|undefined)}>} what plays, in order: in Morse the whole row keyed once; else the procedure word line in every mode, then in Gibberlink the frames of the whole row, in Auto below the threshold the spoken rest, else the fallback pick, nothing more in Silence. */ function plan(row, set, live) { if (!picked(row, set)) { @@ -99,8 +167,11 @@ const RadioSet = (() => { if (set.mode === "silence") { return word; } + if (set.mode === "gibberlink") { + return [...word, gibberlink(row)]; + } const spoken = set.mode === "auto" && live.tts && live.open && row.voice && row.rest; - return [...word, spoken ? {kind: "speech", text: row.rest} : {kind: "burst"}]; + return [...word, spoken ? {kind: "speech", text: row.rest} : standIn(row, set)]; } /** @@ -201,7 +272,7 @@ const RadioSet = (() => { return {...entry, chips: Object.fromEntries(CHIPS.map((name) => [name, ""])), q: ""}; } - return {KEY, MODES, TONES, CLASSES, TABS, CHIPS, DEFAULTS, GATE, PROSIGNS, valid, picked, plan, burst, gateLabel, toAll, ledgerOf, logRows, counts, choices, cleared}; + return {KEY, MODES, FALLBACKS, KEYED, FRAME, TONES, CLASSES, TABS, CHIPS, DEFAULTS, GATE, PROSIGNS, valid, picked, frames, standIn, plan, burst, gateLabel, toAll, ledgerOf, logRows, counts, choices, cleared}; })(); if (typeof module === "object" && module.exports) { module.exports = RadioSet; diff --git a/orchestrator/templates/style-ui.css b/orchestrator/templates/style-ui.css index c0b6bb0..ce078c1 100644 --- a/orchestrator/templates/style-ui.css +++ b/orchestrator/templates/style-ui.css @@ -112,6 +112,7 @@ body.fit .spot-host { flex: none; } .knob-test { grid-column: 5; } .radio-read { display: grid; gap: var(--sp-2); } .radio-read .chips { margin-bottom: 0; } +.radio-fallback .chips-label { color: var(--muted); font-size: var(--fs-sm); } .morse-speed { display: flex; flex-wrap: wrap; align-items: center; gap: var(--sp-1) var(--sp-2); min-width: 0; color: var(--muted); font-size: var(--fs-sm); } .morse-speed .knob { flex: 1 1 8rem; width: auto; } .morse-rate { font-family: var(--mono); font-variant-numeric: tabular-nums; white-space: nowrap; } diff --git a/orchestrator/vendor/ggwave/LICENSE b/orchestrator/vendor/ggwave/LICENSE new file mode 100644 index 0000000..db7a934 --- /dev/null +++ b/orchestrator/vendor/ggwave/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2020 Georgi Gerganov + +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/orchestrator/vendor/ggwave/ggwave.js b/orchestrator/vendor/ggwave/ggwave.js new file mode 100644 index 0000000..b4bc55f --- /dev/null +++ b/orchestrator/vendor/ggwave/ggwave.js @@ -0,0 +1,21 @@ + +var ggwave_factory = (() => { + var _scriptDir = typeof document !== 'undefined' && document.currentScript ? document.currentScript.src : undefined; + if (typeof __filename !== 'undefined') _scriptDir = _scriptDir || __filename; + return ( +function(ggwave_factory) { + ggwave_factory = ggwave_factory || {}; + +var Module=typeof ggwave_factory!=="undefined"?ggwave_factory:{};var objAssign=Object.assign;var readyPromiseResolve,readyPromiseReject;Module["ready"]=new Promise(function(resolve,reject){readyPromiseResolve=resolve;readyPromiseReject=reject});var moduleOverrides=objAssign({},Module);var arguments_=[];var thisProgram="./this.program";var quit_=(status,toThrow)=>{throw toThrow};var ENVIRONMENT_IS_WEB=typeof window==="object";var ENVIRONMENT_IS_WORKER=typeof importScripts==="function";var ENVIRONMENT_IS_NODE=typeof process==="object"&&typeof process.versions==="object"&&typeof process.versions.node==="string";var scriptDirectory="";function locateFile(path){if(Module["locateFile"]){return Module["locateFile"](path,scriptDirectory)}return scriptDirectory+path}var read_,readAsync,readBinary,setWindowTitle;function logExceptionOnExit(e){if(e instanceof ExitStatus)return;let toLog=e;err("exiting due to exception: "+toLog)}var fs;var nodePath;var requireNodeFS;if(ENVIRONMENT_IS_NODE){if(ENVIRONMENT_IS_WORKER){scriptDirectory=require("path").dirname(scriptDirectory)+"/"}else{scriptDirectory=__dirname+"/"}requireNodeFS=(()=>{if(!nodePath){fs=require("fs");nodePath=require("path")}});read_=function shell_read(filename,binary){var ret=tryParseAsDataURI(filename);if(ret){return binary?ret:ret.toString()}requireNodeFS();filename=nodePath["normalize"](filename);return fs.readFileSync(filename,binary?null:"utf8")};readBinary=(filename=>{var ret=read_(filename,true);if(!ret.buffer){ret=new Uint8Array(ret)}return ret});readAsync=((filename,onload,onerror)=>{var ret=tryParseAsDataURI(filename);if(ret){onload(ret)}requireNodeFS();filename=nodePath["normalize"](filename);fs.readFile(filename,function(err,data){if(err)onerror(err);else onload(data.buffer)})});if(process["argv"].length>1){thisProgram=process["argv"][1].replace(/\\/g,"/")}arguments_=process["argv"].slice(2);process["on"]("uncaughtException",function(ex){if(!(ex instanceof ExitStatus)){throw ex}});process["on"]("unhandledRejection",function(reason){throw reason});quit_=((status,toThrow)=>{if(keepRuntimeAlive()){process["exitCode"]=status;throw toThrow}logExceptionOnExit(toThrow);process["exit"](status)});Module["inspect"]=function(){return"[Emscripten Module object]"}}else if(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER){if(ENVIRONMENT_IS_WORKER){scriptDirectory=self.location.href}else if(typeof document!=="undefined"&&document.currentScript){scriptDirectory=document.currentScript.src}if(_scriptDir){scriptDirectory=_scriptDir}if(scriptDirectory.indexOf("blob:")!==0){scriptDirectory=scriptDirectory.substr(0,scriptDirectory.replace(/[?#].*/,"").lastIndexOf("/")+1)}else{scriptDirectory=""}{read_=(url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.send(null);return xhr.responseText}catch(err){var data=tryParseAsDataURI(url);if(data){return intArrayToString(data)}throw err}});if(ENVIRONMENT_IS_WORKER){readBinary=(url=>{try{var xhr=new XMLHttpRequest;xhr.open("GET",url,false);xhr.responseType="arraybuffer";xhr.send(null);return new Uint8Array(xhr.response)}catch(err){var data=tryParseAsDataURI(url);if(data){return data}throw err}})}readAsync=((url,onload,onerror)=>{var xhr=new XMLHttpRequest;xhr.open("GET",url,true);xhr.responseType="arraybuffer";xhr.onload=(()=>{if(xhr.status==200||xhr.status==0&&xhr.response){onload(xhr.response);return}var data=tryParseAsDataURI(url);if(data){onload(data.buffer);return}onerror()});xhr.onerror=onerror;xhr.send(null)})}setWindowTitle=(title=>document.title=title)}else{}var out=Module["print"]||console.log.bind(console);var err=Module["printErr"]||console.warn.bind(console);objAssign(Module,moduleOverrides);moduleOverrides=null;if(Module["arguments"])arguments_=Module["arguments"];if(Module["thisProgram"])thisProgram=Module["thisProgram"];if(Module["quit"])quit_=Module["quit"];var tempRet0=0;var setTempRet0=value=>{tempRet0=value};var wasmBinary;if(Module["wasmBinary"])wasmBinary=Module["wasmBinary"];var noExitRuntime=Module["noExitRuntime"]||true;if(typeof WebAssembly!=="object"){abort("no native wasm support detected")}var wasmMemory;var ABORT=false;var EXITSTATUS;function assert(condition,text){if(!condition){abort(text)}}var UTF8Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf8"):undefined;function UTF8ArrayToString(heap,idx,maxBytesToRead){var endIdx=idx+maxBytesToRead;var endPtr=idx;while(heap[endPtr]&&!(endPtr>=endIdx))++endPtr;if(endPtr-idx>16&&heap.subarray&&UTF8Decoder){return UTF8Decoder.decode(heap.subarray(idx,endPtr))}else{var str="";while(idx>10,56320|ch&1023)}}}return str}function UTF8ToString(ptr,maxBytesToRead){return ptr?UTF8ArrayToString(HEAPU8,ptr,maxBytesToRead):""}function stringToUTF8Array(str,heap,outIdx,maxBytesToWrite){if(!(maxBytesToWrite>0))return 0;var startIdx=outIdx;var endIdx=outIdx+maxBytesToWrite-1;for(var i=0;i=55296&&u<=57343){var u1=str.charCodeAt(++i);u=65536+((u&1023)<<10)|u1&1023}if(u<=127){if(outIdx>=endIdx)break;heap[outIdx++]=u}else if(u<=2047){if(outIdx+1>=endIdx)break;heap[outIdx++]=192|u>>6;heap[outIdx++]=128|u&63}else if(u<=65535){if(outIdx+2>=endIdx)break;heap[outIdx++]=224|u>>12;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}else{if(outIdx+3>=endIdx)break;heap[outIdx++]=240|u>>18;heap[outIdx++]=128|u>>12&63;heap[outIdx++]=128|u>>6&63;heap[outIdx++]=128|u&63}}heap[outIdx]=0;return outIdx-startIdx}function stringToUTF8(str,outPtr,maxBytesToWrite){return stringToUTF8Array(str,HEAPU8,outPtr,maxBytesToWrite)}function lengthBytesUTF8(str){var len=0;for(var i=0;i=55296&&u<=57343)u=65536+((u&1023)<<10)|str.charCodeAt(++i)&1023;if(u<=127)++len;else if(u<=2047)len+=2;else if(u<=65535)len+=3;else len+=4}return len}var UTF16Decoder=typeof TextDecoder!=="undefined"?new TextDecoder("utf-16le"):undefined;function UTF16ToString(ptr,maxBytesToRead){var endPtr=ptr;var idx=endPtr>>1;var maxIdx=idx+maxBytesToRead/2;while(!(idx>=maxIdx)&&HEAPU16[idx])++idx;endPtr=idx<<1;if(endPtr-ptr>32&&UTF16Decoder){return UTF16Decoder.decode(HEAPU8.subarray(ptr,endPtr))}else{var str="";for(var i=0;!(i>=maxBytesToRead/2);++i){var codeUnit=HEAP16[ptr+i*2>>1];if(codeUnit==0)break;str+=String.fromCharCode(codeUnit)}return str}}function stringToUTF16(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<2)return 0;maxBytesToWrite-=2;var startPtr=outPtr;var numCharsToWrite=maxBytesToWrite>1]=codeUnit;outPtr+=2}HEAP16[outPtr>>1]=0;return outPtr-startPtr}function lengthBytesUTF16(str){return str.length*2}function UTF32ToString(ptr,maxBytesToRead){var i=0;var str="";while(!(i>=maxBytesToRead/4)){var utf32=HEAP32[ptr+i*4>>2];if(utf32==0)break;++i;if(utf32>=65536){var ch=utf32-65536;str+=String.fromCharCode(55296|ch>>10,56320|ch&1023)}else{str+=String.fromCharCode(utf32)}}return str}function stringToUTF32(str,outPtr,maxBytesToWrite){if(maxBytesToWrite===undefined){maxBytesToWrite=2147483647}if(maxBytesToWrite<4)return 0;var startPtr=outPtr;var endPtr=startPtr+maxBytesToWrite-4;for(var i=0;i=55296&&codeUnit<=57343){var trailSurrogate=str.charCodeAt(++i);codeUnit=65536+((codeUnit&1023)<<10)|trailSurrogate&1023}HEAP32[outPtr>>2]=codeUnit;outPtr+=4;if(outPtr+4>endPtr)break}HEAP32[outPtr>>2]=0;return outPtr-startPtr}function lengthBytesUTF32(str){var len=0;for(var i=0;i=55296&&codeUnit<=57343)++i;len+=4}return len}function alignUp(x,multiple){if(x%multiple>0){x+=multiple-x%multiple}return x}var buffer,HEAP8,HEAPU8,HEAP16,HEAPU16,HEAP32,HEAPU32,HEAPF32,HEAPF64;function updateGlobalBufferAndViews(buf){buffer=buf;Module["HEAP8"]=HEAP8=new Int8Array(buf);Module["HEAP16"]=HEAP16=new Int16Array(buf);Module["HEAP32"]=HEAP32=new Int32Array(buf);Module["HEAPU8"]=HEAPU8=new Uint8Array(buf);Module["HEAPU16"]=HEAPU16=new Uint16Array(buf);Module["HEAPU32"]=HEAPU32=new Uint32Array(buf);Module["HEAPF32"]=HEAPF32=new Float32Array(buf);Module["HEAPF64"]=HEAPF64=new Float64Array(buf)}var INITIAL_MEMORY=Module["INITIAL_MEMORY"]||16777216;var wasmTable;var __ATPRERUN__=[];var __ATINIT__=[];var __ATPOSTRUN__=[];var runtimeInitialized=false;var runtimeKeepaliveCounter=0;function keepRuntimeAlive(){return noExitRuntime||runtimeKeepaliveCounter>0}function preRun(){if(Module["preRun"]){if(typeof Module["preRun"]=="function")Module["preRun"]=[Module["preRun"]];while(Module["preRun"].length){addOnPreRun(Module["preRun"].shift())}}callRuntimeCallbacks(__ATPRERUN__)}function initRuntime(){runtimeInitialized=true;callRuntimeCallbacks(__ATINIT__)}function postRun(){if(Module["postRun"]){if(typeof Module["postRun"]=="function")Module["postRun"]=[Module["postRun"]];while(Module["postRun"].length){addOnPostRun(Module["postRun"].shift())}}callRuntimeCallbacks(__ATPOSTRUN__)}function addOnPreRun(cb){__ATPRERUN__.unshift(cb)}function addOnInit(cb){__ATINIT__.unshift(cb)}function addOnPostRun(cb){__ATPOSTRUN__.unshift(cb)}var runDependencies=0;var runDependencyWatcher=null;var dependenciesFulfilled=null;function addRunDependency(id){runDependencies++;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}}function removeRunDependency(id){runDependencies--;if(Module["monitorRunDependencies"]){Module["monitorRunDependencies"](runDependencies)}if(runDependencies==0){if(runDependencyWatcher!==null){clearInterval(runDependencyWatcher);runDependencyWatcher=null}if(dependenciesFulfilled){var callback=dependenciesFulfilled;dependenciesFulfilled=null;callback()}}}Module["preloadedImages"]={};Module["preloadedAudios"]={};function abort(what){{if(Module["onAbort"]){Module["onAbort"](what)}}what="Aborted("+what+")";err(what);ABORT=true;EXITSTATUS=1;what+=". Build with -s ASSERTIONS=1 for more info.";var e=new WebAssembly.RuntimeError(what);readyPromiseReject(e);throw e}var dataURIPrefix="data:application/octet-stream;base64,";function isDataURI(filename){return filename.startsWith(dataURIPrefix)}function isFileURI(filename){return filename.startsWith("file://")}var wasmBinaryFile;wasmBinaryFile="data:application/octet-stream;base64,AGFzbQEAAAAB5QEhYAN/f38AYAF/AX9gAX8AYAN/f38Bf2AFf39/f38AYAR/f39/AGAGf39/f39/AGAAAGACf38AYAV/f39/fwF/YAJ/fwF/YAN/fn8BfmAEf39/fwF/YAF8AX1gAAF/YAF9AX1gAXwBfGACfH8BfGAGf3x/f39/AX9gCn9/f39/f39/f38AYAN/f3wAYAd/f39/f39/AGACfn8Bf2ADfHx/AXxgAnx8AXxgBX99f39/AX9gBn9/f39/fwF/YAJ9fwF/YAJ8fwF/YAd/f39/f39/AX9gBH9/fn4AYAN/f30AYAJ/fwF9Ap0BGgFhAWEAAAFhAWIAAAFhAWMABgFhAWQAEwFhAWUABAFhAWYAFAFhAWcACgFhAWgABwFhAWkAAAFhAWoAAgFhAWsAAgFhAWwADAFhAW0ACAFhAW4AAAFhAW8ABQFhAXAAAgFhAXEABgFhAXIACQFhAXMAFQFhAXQAAgFhAXUAAQFhAXYAAQFhAXcAAwFhAXgACAFhAXkABAFhAXoACANragMDAAEABAMCAgENDQ4BAAEWDwIQFxgZBA8RBwYFABADAAwBBQcFAwoAAAEaBREBAgAbHAkHAAEDAAkdCgAAHgQFBQUDCAEHChIBCwELAwEfIAECAQIFAAICCAgABwcCAAMECQYGBgQECQ4EBQFwATQ0BQcBAYACgIACBgkBfwFBsO3AAgsHIQgBQQIAAUIAPgFDAQABRAAhAUUAJwFGAGsBRwBOAUgAfAk9AQBBAQszgwFyVU9qaVVPY25hbV5sggF7enl4d3Z1dHNxaGdmZWRiXyxJSUAsQCxdfYABXCx+gQFbLH9ZWgrtuQRqgQQBA38gAkGABE8EQCAAIAEgAhAWGiAADwsgACACaiEDAkAgACABc0EDcUUEQAJAIABBA3FFBEAgACECDAELIAJFBEAgACECDAELIAAhAgNAIAIgAS0AADoAACABQQFqIQEgAkEBaiICQQNxRQ0BIAIgA0kNAAsLAkAgA0F8cSIEQcAASQ0AIAIgBEFAaiIFSw0AA0AgAiABKAIANgIAIAIgASgCBDYCBCACIAEoAgg2AgggAiABKAIMNgIMIAIgASgCEDYCECACIAEoAhQ2AhQgAiABKAIYNgIYIAIgASgCHDYCHCACIAEoAiA2AiAgAiABKAIkNgIkIAIgASgCKDYCKCACIAEoAiw2AiwgAiABKAIwNgIwIAIgASgCNDYCNCACIAEoAjg2AjggAiABKAI8NgI8IAFBQGshASACQUBrIgIgBU0NAAsLIAIgBE8NAQNAIAIgASgCADYCACABQQRqIQEgAkEEaiICIARJDQALDAELIANBBEkEQCAAIQIMAQsgACADQQRrIgRLBEAgACECDAELIAAhAgNAIAIgAS0AADoAACACIAEtAAE6AAEgAiABLQACOgACIAIgAS0AAzoAAyABQQRqIQEgAkEEaiICIARNDQALCyACIANJBEADQCACIAEtAAA6AAAgAUEBaiEBIAJBAWoiAiADRw0ACwsgAAvyAgICfwF+AkAgAkUNACAAIAE6AAAgACACaiIDQQFrIAE6AAAgAkEDSQ0AIAAgAToAAiAAIAE6AAEgA0EDayABOgAAIANBAmsgAToAACACQQdJDQAgACABOgADIANBBGsgAToAACACQQlJDQAgAEEAIABrQQNxIgRqIgMgAUH/AXFBgYKECGwiATYCACADIAIgBGtBfHEiBGoiAkEEayABNgIAIARBCUkNACADIAE2AgggAyABNgIEIAJBCGsgATYCACACQQxrIAE2AgAgBEEZSQ0AIAMgATYCGCADIAE2AhQgAyABNgIQIAMgATYCDCACQRBrIAE2AgAgAkEUayABNgIAIAJBGGsgATYCACACQRxrIAE2AgAgBCADQQRxQRhyIgRrIgJBIEkNACABrUKBgICAEH4hBSADIARqIQEDQCABIAU3AxggASAFNwMQIAEgBTcDCCABIAU3AwAgAUEgaiEBIAJBIGsiAkEfSw0ACwsgAAsjAQF/IwBBEGsiAyQAIAMgAjYCDCAAIAEgAhBCIANBEGokAAszAQF/IABBASAAGyEAAkADQCAAECciAQ0BQaTtACgCACIBBEAgAREHAAwBCwsQBwALIAELFwAgAC0AAEEgcUUEQCABIAIgABA5GgsLbwEBfyMAQYACayIFJAACQCACIANMDQAgBEGAwARxDQAgBSABQf8BcSACIANrIgJBgAIgAkGAAkkiARsQGxogAUUEQANAIAAgBUGAAhAeIAJBgAJrIgJB/wFLDQALCyAAIAUgAhAeCyAFQYACaiQAC3QBAX8gAkUEQCAAKAIEIAEoAgRGDwsgACABRgRAQQEPCyABKAIEIgItAAAhAQJAIAAoAgQiAy0AACIARQ0AIAAgAUcNAANAIAItAAEhASADLQABIgBFDQEgAkEBaiECIANBAWohAyAAIAFGDQALCyAAIAFGC8wMAQd/AkAgAEUNACAAQQhrIgMgAEEEaygCACIBQXhxIgBqIQUCQCABQQFxDQAgAUEDcUUNASADIAMoAgAiAWsiA0HE6QAoAgBJDQEgACABaiEAIANByOkAKAIARwRAIAFB/wFNBEAgAygCCCICIAFBA3YiBEEDdEHc6QBqRhogAiADKAIMIgFGBEBBtOkAQbTpACgCAEF+IAR3cTYCAAwDCyACIAE2AgwgASACNgIIDAILIAMoAhghBgJAIAMgAygCDCIBRwRAIAMoAggiAiABNgIMIAEgAjYCCAwBCwJAIANBFGoiAigCACIEDQAgA0EQaiICKAIAIgQNAEEAIQEMAQsDQCACIQcgBCIBQRRqIgIoAgAiBA0AIAFBEGohAiABKAIQIgQNAAsgB0EANgIACyAGRQ0BAkAgAyADKAIcIgJBAnRB5OsAaiIEKAIARgRAIAQgATYCACABDQFBuOkAQbjpACgCAEF+IAJ3cTYCAAwDCyAGQRBBFCAGKAIQIANGG2ogATYCACABRQ0CCyABIAY2AhggAygCECICBEAgASACNgIQIAIgATYCGAsgAygCFCICRQ0BIAEgAjYCFCACIAE2AhgMAQsgBSgCBCIBQQNxQQNHDQBBvOkAIAA2AgAgBSABQX5xNgIEIAMgAEEBcjYCBCAAIANqIAA2AgAPCyADIAVPDQAgBSgCBCIBQQFxRQ0AAkAgAUECcUUEQCAFQczpACgCAEYEQEHM6QAgAzYCAEHA6QBBwOkAKAIAIABqIgA2AgAgAyAAQQFyNgIEIANByOkAKAIARw0DQbzpAEEANgIAQcjpAEEANgIADwsgBUHI6QAoAgBGBEBByOkAIAM2AgBBvOkAQbzpACgCACAAaiIANgIAIAMgAEEBcjYCBCAAIANqIAA2AgAPCyABQXhxIABqIQACQCABQf8BTQRAIAUoAggiAiABQQN2IgRBA3RB3OkAakYaIAIgBSgCDCIBRgRAQbTpAEG06QAoAgBBfiAEd3E2AgAMAgsgAiABNgIMIAEgAjYCCAwBCyAFKAIYIQYCQCAFIAUoAgwiAUcEQCAFKAIIIgJBxOkAKAIASRogAiABNgIMIAEgAjYCCAwBCwJAIAVBFGoiAigCACIEDQAgBUEQaiICKAIAIgQNAEEAIQEMAQsDQCACIQcgBCIBQRRqIgIoAgAiBA0AIAFBEGohAiABKAIQIgQNAAsgB0EANgIACyAGRQ0AAkAgBSAFKAIcIgJBAnRB5OsAaiIEKAIARgRAIAQgATYCACABDQFBuOkAQbjpACgCAEF+IAJ3cTYCAAwCCyAGQRBBFCAGKAIQIAVGG2ogATYCACABRQ0BCyABIAY2AhggBSgCECICBEAgASACNgIQIAIgATYCGAsgBSgCFCICRQ0AIAEgAjYCFCACIAE2AhgLIAMgAEEBcjYCBCAAIANqIAA2AgAgA0HI6QAoAgBHDQFBvOkAIAA2AgAPCyAFIAFBfnE2AgQgAyAAQQFyNgIEIAAgA2ogADYCAAsgAEH/AU0EQCAAQQN2IgFBA3RB3OkAaiEAAn9BtOkAKAIAIgJBASABdCIBcUUEQEG06QAgASACcjYCACAADAELIAAoAggLIQIgACADNgIIIAIgAzYCDCADIAA2AgwgAyACNgIIDwtBHyECIANCADcCECAAQf///wdNBEAgAEEIdiIBIAFBgP4/akEQdkEIcSIBdCICIAJBgOAfakEQdkEEcSICdCIEIARBgIAPakEQdkECcSIEdEEPdiABIAJyIARyayIBQQF0IAAgAUEVanZBAXFyQRxqIQILIAMgAjYCHCACQQJ0QeTrAGohAQJAAkACQEG46QAoAgAiBEEBIAJ0IgdxRQRAQbjpACAEIAdyNgIAIAEgAzYCACADIAE2AhgMAQsgAEEAQRkgAkEBdmsgAkEfRht0IQIgASgCACEBA0AgASIEKAIEQXhxIABGDQIgAkEddiEBIAJBAXQhAiAEIAFBBHFqIgdBEGooAgAiAQ0ACyAHIAM2AhAgAyAENgIYCyADIAM2AgwgAyADNgIIDAELIAQoAggiACADNgIMIAQgAzYCCCADQQA2AhggAyAENgIMIAMgADYCCAtB1OkAQdTpACgCAEEBayIAQX8gABs2AgALC2oBA38jAEEQayIBJAAgAUEANgIMIAEgADYCBCABIAA2AgAgASAAQQFqNgIIIAEhAiMAQRBrIgMkACADQQhqIgAgAigCBDYCACAAKAIAQQE6AAAgAigCCEEBOgAAIANBEGokACABQRBqJAALlgEBBH8jAEEQayIBJAAgAUEANgIMIAEgADYCBCABIAA2AgAgASAAQQFqNgIIIAEhAyMAQRBrIgQkACAEQQhqIgAgAygCBDYCACAAKAIALQAARQRAAn8CQCADKAIIIgItAAAiAEEBRwR/IABBAnENASACQQI6AABBAQVBAAsMAQsQBwALIQILIARBEGokACABQRBqJAAgAgtLAQJ8IAAgAKIiASAAoiICIAEgAaKiIAFEp0Y7jIfNxj6iRHTnyuL5ACq/oKIgAiABRLL7bokQEYE/okR3rMtUVVXFv6CiIACgoLYLTwEBfCAAIACiIgAgACAAoiIBoiAARGlQ7uBCk/k+okQnHg/oh8BWv6CiIAFEQjoF4VNVpT+iIABEgV4M/f//37+iRAAAAAAAAPA/oKCgtgvOBABB8N8ALQAARQRAQeTfAEEANgIAQdjfAEEANgIAQczfAEEANgIAQcDfAEEANgIAQbTfAEEANgIAQajfAEEANgIAQZzfAEEANgIAQZDfAEEANgIAQYTfAEEANgIAQfjeAEEANgIAQe3fAEEAOgAAQeHfAEEAOgAAQdXfAEEAOgAAQcnfAEEAOgAAQb3fAEEAOgAAQbHfAEEAOgAAQaXfAEEAOgAAQZnfAEEAOgAAQY3fAEEAOgAAQYHfAEEAOgAAQfXeAEEAOgAAQfLeAEGDgogINgEAQfDeAEEYOwEAQezeAEHHCDYCAEHm3gBBhoKICDYBAEHk3gBBGDsBAEHg3gBB6gg2AgBB2t4AQYmCiAg2AQBB2N4AQRg7AQBB1N4AQf8KNgIAQc7eAEGDgoQINgEAQczeAEEYOwEAQcjeAEHUCDYCAEHC3gBBhoKECDYBAEHA3gBBGDsBAEG83gBB9Ag2AgBBtt4AQYmChAg2AQBBtN4AQRg7AQBBsN4AQYsLNgIAQareAEGDhoQINgEAQajeAEHAAjsBAEGk3gBBuwg2AgBBnt4AQYaGhAg2AQBBnN4AQcACOwEAQZjeAEHhCDYCAEGS3gBBiYaECDYBAEGQ3gBBwAI7AQBBjN4AQfQKNgIAQYbeAEGDhoQINgEAQYTeAEEoOwEAQYDeAEHZCDYCAEH63QBBhoaECDYBAEH43QBBKDsBAEH03QBB+Qg2AgBB7t0AQYmGhAg2AQBB7N0AQSg7AQBB6N0AQZALNgIAQfDfAEEBOgAAC0Ho3QALjS4BC38jAEEQayILJAACQAJAAkACQAJAAkACQAJAAkACQAJAIABB9AFNBEBBtOkAKAIAIgZBECAAQQtqQXhxIABBC0kbIgdBA3YiAnYiAUEDcQRAIAFBf3NBAXEgAmoiA0EDdCIBQeTpAGooAgAiBEEIaiEAAkAgBCgCCCICIAFB3OkAaiIBRgRAQbTpACAGQX4gA3dxNgIADAELIAIgATYCDCABIAI2AggLIAQgA0EDdCIBQQNyNgIEIAEgBGoiASABKAIEQQFyNgIEDAwLIAdBvOkAKAIAIgpNDQEgAQRAAkBBAiACdCIAQQAgAGtyIAEgAnRxIgBBACAAa3FBAWsiACAAQQx2QRBxIgJ2IgFBBXZBCHEiACACciABIAB2IgFBAnZBBHEiAHIgASAAdiIBQQF2QQJxIgByIAEgAHYiAUEBdkEBcSIAciABIAB2aiIDQQN0IgBB5OkAaigCACIEKAIIIgEgAEHc6QBqIgBGBEBBtOkAIAZBfiADd3EiBjYCAAwBCyABIAA2AgwgACABNgIICyAEQQhqIQAgBCAHQQNyNgIEIAQgB2oiAiADQQN0IgEgB2siA0EBcjYCBCABIARqIAM2AgAgCgRAIApBA3YiAUEDdEHc6QBqIQVByOkAKAIAIQQCfyAGQQEgAXQiAXFFBEBBtOkAIAEgBnI2AgAgBQwBCyAFKAIICyEBIAUgBDYCCCABIAQ2AgwgBCAFNgIMIAQgATYCCAtByOkAIAI2AgBBvOkAIAM2AgAMDAtBuOkAKAIAIglFDQEgCUEAIAlrcUEBayIAIABBDHZBEHEiAnYiAUEFdkEIcSIAIAJyIAEgAHYiAUECdkEEcSIAciABIAB2IgFBAXZBAnEiAHIgASAAdiIBQQF2QQFxIgByIAEgAHZqQQJ0QeTrAGooAgAiASgCBEF4cSAHayEDIAEhAgNAAkAgAigCECIARQRAIAIoAhQiAEUNAQsgACgCBEF4cSAHayICIAMgAiADSSICGyEDIAAgASACGyEBIAAhAgwBCwsgASgCGCEIIAEgASgCDCIERwRAIAEoAggiAEHE6QAoAgBJGiAAIAQ2AgwgBCAANgIIDAsLIAFBFGoiAigCACIARQRAIAEoAhAiAEUNAyABQRBqIQILA0AgAiEFIAAiBEEUaiICKAIAIgANACAEQRBqIQIgBCgCECIADQALIAVBADYCAAwKC0F/IQcgAEG/f0sNACAAQQtqIgBBeHEhB0G46QAoAgAiCUUNAEEAIAdrIQMCQAJAAkACf0EAIAdBgAJJDQAaQR8gB0H///8HSw0AGiAAQQh2IgAgAEGA/j9qQRB2QQhxIgJ0IgAgAEGA4B9qQRB2QQRxIgF0IgAgAEGAgA9qQRB2QQJxIgB0QQ92IAEgAnIgAHJrIgBBAXQgByAAQRVqdkEBcXJBHGoLIgZBAnRB5OsAaigCACICRQRAQQAhAAwBC0EAIQAgB0EAQRkgBkEBdmsgBkEfRht0IQEDQAJAIAIoAgRBeHEgB2siBSADTw0AIAIhBCAFIgMNAEEAIQMgAiEADAMLIAAgAigCFCIFIAUgAiABQR12QQRxaigCECICRhsgACAFGyEAIAFBAXQhASACDQALCyAAIARyRQRAQQAhBEECIAZ0IgBBACAAa3IgCXEiAEUNAyAAQQAgAGtxQQFrIgAgAEEMdkEQcSICdiIBQQV2QQhxIgAgAnIgASAAdiIBQQJ2QQRxIgByIAEgAHYiAUEBdkECcSIAciABIAB2IgFBAXZBAXEiAHIgASAAdmpBAnRB5OsAaigCACEACyAARQ0BCwNAIAAoAgRBeHEgB2siASADSSECIAEgAyACGyEDIAAgBCACGyEEIAAoAhAiAQR/IAEFIAAoAhQLIgANAAsLIARFDQAgA0G86QAoAgAgB2tPDQAgBCgCGCEGIAQgBCgCDCIBRwRAIAQoAggiAEHE6QAoAgBJGiAAIAE2AgwgASAANgIIDAkLIARBFGoiAigCACIARQRAIAQoAhAiAEUNAyAEQRBqIQILA0AgAiEFIAAiAUEUaiICKAIAIgANACABQRBqIQIgASgCECIADQALIAVBADYCAAwICyAHQbzpACgCACICTQRAQcjpACgCACEDAkAgAiAHayIBQRBPBEBBvOkAIAE2AgBByOkAIAMgB2oiADYCACAAIAFBAXI2AgQgAiADaiABNgIAIAMgB0EDcjYCBAwBC0HI6QBBADYCAEG86QBBADYCACADIAJBA3I2AgQgAiADaiIAIAAoAgRBAXI2AgQLIANBCGohAAwKCyAHQcDpACgCACIISQRAQcDpACAIIAdrIgE2AgBBzOkAQczpACgCACICIAdqIgA2AgAgACABQQFyNgIEIAIgB0EDcjYCBCACQQhqIQAMCgtBACEAIAdBL2oiCQJ/QYztACgCAARAQZTtACgCAAwBC0GY7QBCfzcCAEGQ7QBCgKCAgICABDcCAEGM7QAgC0EMakFwcUHYqtWqBXM2AgBBoO0AQQA2AgBB8OwAQQA2AgBBgCALIgFqIgZBACABayIFcSICIAdNDQlB7OwAKAIAIgQEQEHk7AAoAgAiAyACaiIBIANNDQogASAESw0KC0Hw7AAtAABBBHENBAJAAkBBzOkAKAIAIgMEQEH07AAhAANAIAMgACgCACIBTwRAIAEgACgCBGogA0sNAwsgACgCCCIADQALC0EAECkiAUF/Rg0FIAIhBkGQ7QAoAgAiA0EBayIAIAFxBEAgAiABayAAIAFqQQAgA2txaiEGCyAGIAdNDQUgBkH+////B0sNBUHs7AAoAgAiBARAQeTsACgCACIDIAZqIgAgA00NBiAAIARLDQYLIAYQKSIAIAFHDQEMBwsgBiAIayAFcSIGQf7///8HSw0EIAYQKSIBIAAoAgAgACgCBGpGDQMgASEACwJAIABBf0YNACAHQTBqIAZNDQBBlO0AKAIAIgEgCSAGa2pBACABa3EiAUH+////B0sEQCAAIQEMBwsgARApQX9HBEAgASAGaiEGIAAhAQwHC0EAIAZrECkaDAQLIAAiAUF/Rw0FDAMLQQAhBAwHC0EAIQEMBQsgAUF/Rw0CC0Hw7ABB8OwAKAIAQQRyNgIACyACQf7///8HSw0BIAIQKSEBQQAQKSEAIAFBf0YNASAAQX9GDQEgACABTQ0BIAAgAWsiBiAHQShqTQ0BC0Hk7ABB5OwAKAIAIAZqIgA2AgBB6OwAKAIAIABJBEBB6OwAIAA2AgALAkACQAJAQczpACgCACIFBEBB9OwAIQADQCABIAAoAgAiAyAAKAIEIgJqRg0CIAAoAggiAA0ACwwCC0HE6QAoAgAiAEEAIAAgAU0bRQRAQcTpACABNgIAC0EAIQBB+OwAIAY2AgBB9OwAIAE2AgBB1OkAQX82AgBB2OkAQYztACgCADYCAEGA7QBBADYCAANAIABBA3QiA0Hk6QBqIANB3OkAaiICNgIAIANB6OkAaiACNgIAIABBAWoiAEEgRw0AC0HA6QAgBkEoayIDQXggAWtBB3FBACABQQhqQQdxGyIAayICNgIAQczpACAAIAFqIgA2AgAgACACQQFyNgIEIAEgA2pBKDYCBEHQ6QBBnO0AKAIANgIADAILIAAtAAxBCHENACADIAVLDQAgASAFTQ0AIAAgAiAGajYCBEHM6QAgBUF4IAVrQQdxQQAgBUEIakEHcRsiAGoiAjYCAEHA6QBBwOkAKAIAIAZqIgEgAGsiADYCACACIABBAXI2AgQgASAFakEoNgIEQdDpAEGc7QAoAgA2AgAMAQtBxOkAKAIAIAFLBEBBxOkAIAE2AgALIAEgBmohAkH07AAhAAJAAkACQAJAAkACQANAIAIgACgCAEcEQCAAKAIIIgANAQwCCwsgAC0ADEEIcUUNAQtB9OwAIQADQCAFIAAoAgAiAk8EQCACIAAoAgRqIgQgBUsNAwsgACgCCCEADAALAAsgACABNgIAIAAgACgCBCAGajYCBCABQXggAWtBB3FBACABQQhqQQdxG2oiCSAHQQNyNgIEIAJBeCACa0EHcUEAIAJBCGpBB3EbaiIGIAcgCWoiCGshAiAFIAZGBEBBzOkAIAg2AgBBwOkAQcDpACgCACACaiIANgIAIAggAEEBcjYCBAwDCyAGQcjpACgCAEYEQEHI6QAgCDYCAEG86QBBvOkAKAIAIAJqIgA2AgAgCCAAQQFyNgIEIAAgCGogADYCAAwDCyAGKAIEIgBBA3FBAUYEQCAAQXhxIQUCQCAAQf8BTQRAIAYoAggiAyAAQQN2IgBBA3RB3OkAakYaIAMgBigCDCIBRgRAQbTpAEG06QAoAgBBfiAAd3E2AgAMAgsgAyABNgIMIAEgAzYCCAwBCyAGKAIYIQcCQCAGIAYoAgwiAUcEQCAGKAIIIgAgATYCDCABIAA2AggMAQsCQCAGQRRqIgAoAgAiAw0AIAZBEGoiACgCACIDDQBBACEBDAELA0AgACEEIAMiAUEUaiIAKAIAIgMNACABQRBqIQAgASgCECIDDQALIARBADYCAAsgB0UNAAJAIAYgBigCHCIDQQJ0QeTrAGoiACgCAEYEQCAAIAE2AgAgAQ0BQbjpAEG46QAoAgBBfiADd3E2AgAMAgsgB0EQQRQgBygCECAGRhtqIAE2AgAgAUUNAQsgASAHNgIYIAYoAhAiAARAIAEgADYCECAAIAE2AhgLIAYoAhQiAEUNACABIAA2AhQgACABNgIYCyAFIAZqIQYgAiAFaiECCyAGIAYoAgRBfnE2AgQgCCACQQFyNgIEIAIgCGogAjYCACACQf8BTQRAIAJBA3YiAEEDdEHc6QBqIQICf0G06QAoAgAiAUEBIAB0IgBxRQRAQbTpACAAIAFyNgIAIAIMAQsgAigCCAshACACIAg2AgggACAINgIMIAggAjYCDCAIIAA2AggMAwtBHyEAIAJB////B00EQCACQQh2IgAgAEGA/j9qQRB2QQhxIgN0IgAgAEGA4B9qQRB2QQRxIgF0IgAgAEGAgA9qQRB2QQJxIgB0QQ92IAEgA3IgAHJrIgBBAXQgAiAAQRVqdkEBcXJBHGohAAsgCCAANgIcIAhCADcCECAAQQJ0QeTrAGohBAJAQbjpACgCACIDQQEgAHQiAXFFBEBBuOkAIAEgA3I2AgAgBCAINgIAIAggBDYCGAwBCyACQQBBGSAAQQF2ayAAQR9GG3QhACAEKAIAIQEDQCABIgMoAgRBeHEgAkYNAyAAQR12IQEgAEEBdCEAIAMgAUEEcWoiBCgCECIBDQALIAQgCDYCECAIIAM2AhgLIAggCDYCDCAIIAg2AggMAgtBwOkAIAZBKGsiA0F4IAFrQQdxQQAgAUEIakEHcRsiAGsiAjYCAEHM6QAgACABaiIANgIAIAAgAkEBcjYCBCABIANqQSg2AgRB0OkAQZztACgCADYCACAFIARBJyAEa0EHcUEAIARBJ2tBB3EbakEvayIAIAAgBUEQakkbIgJBGzYCBCACQfzsACkCADcCECACQfTsACkCADcCCEH87AAgAkEIajYCAEH47AAgBjYCAEH07AAgATYCAEGA7QBBADYCACACQRhqIQADQCAAQQc2AgQgAEEIaiEBIABBBGohACABIARJDQALIAIgBUYNAyACIAIoAgRBfnE2AgQgBSACIAVrIgRBAXI2AgQgAiAENgIAIARB/wFNBEAgBEEDdiIAQQN0QdzpAGohAgJ/QbTpACgCACIBQQEgAHQiAHFFBEBBtOkAIAAgAXI2AgAgAgwBCyACKAIICyEAIAIgBTYCCCAAIAU2AgwgBSACNgIMIAUgADYCCAwEC0EfIQAgBUIANwIQIARB////B00EQCAEQQh2IgAgAEGA/j9qQRB2QQhxIgJ0IgAgAEGA4B9qQRB2QQRxIgF0IgAgAEGAgA9qQRB2QQJxIgB0QQ92IAEgAnIgAHJrIgBBAXQgBCAAQRVqdkEBcXJBHGohAAsgBSAANgIcIABBAnRB5OsAaiEDAkBBuOkAKAIAIgJBASAAdCIBcUUEQEG46QAgASACcjYCACADIAU2AgAgBSADNgIYDAELIARBAEEZIABBAXZrIABBH0YbdCEAIAMoAgAhAQNAIAEiAigCBEF4cSAERg0EIABBHXYhASAAQQF0IQAgAiABQQRxaiIDKAIQIgENAAsgAyAFNgIQIAUgAjYCGAsgBSAFNgIMIAUgBTYCCAwDCyADKAIIIgAgCDYCDCADIAg2AgggCEEANgIYIAggAzYCDCAIIAA2AggLIAlBCGohAAwFCyACKAIIIgAgBTYCDCACIAU2AgggBUEANgIYIAUgAjYCDCAFIAA2AggLQcDpACgCACIAIAdNDQBBwOkAIAAgB2siATYCAEHM6QBBzOkAKAIAIgIgB2oiADYCACAAIAFBAXI2AgQgAiAHQQNyNgIEIAJBCGohAAwDC0GI6ABBMDYCAEEAIQAMAgsCQCAGRQ0AAkAgBCgCHCICQQJ0QeTrAGoiACgCACAERgRAIAAgATYCACABDQFBuOkAIAlBfiACd3EiCTYCAAwCCyAGQRBBFCAGKAIQIARGG2ogATYCACABRQ0BCyABIAY2AhggBCgCECIABEAgASAANgIQIAAgATYCGAsgBCgCFCIARQ0AIAEgADYCFCAAIAE2AhgLAkAgA0EPTQRAIAQgAyAHaiIAQQNyNgIEIAAgBGoiACAAKAIEQQFyNgIEDAELIAQgB0EDcjYCBCAEIAdqIgUgA0EBcjYCBCADIAVqIAM2AgAgA0H/AU0EQCADQQN2IgBBA3RB3OkAaiECAn9BtOkAKAIAIgFBASAAdCIAcUUEQEG06QAgACABcjYCACACDAELIAIoAggLIQAgAiAFNgIIIAAgBTYCDCAFIAI2AgwgBSAANgIIDAELQR8hACADQf///wdNBEAgA0EIdiIAIABBgP4/akEQdkEIcSICdCIAIABBgOAfakEQdkEEcSIBdCIAIABBgIAPakEQdkECcSIAdEEPdiABIAJyIAByayIAQQF0IAMgAEEVanZBAXFyQRxqIQALIAUgADYCHCAFQgA3AhAgAEECdEHk6wBqIQECQAJAIAlBASAAdCICcUUEQEG46QAgAiAJcjYCACABIAU2AgAMAQsgA0EAQRkgAEEBdmsgAEEfRht0IQAgASgCACEHA0AgByIBKAIEQXhxIANGDQIgAEEddiECIABBAXQhACABIAJBBHFqIgIoAhAiBw0ACyACIAU2AhALIAUgATYCGCAFIAU2AgwgBSAFNgIIDAELIAEoAggiACAFNgIMIAEgBTYCCCAFQQA2AhggBSABNgIMIAUgADYCCAsgBEEIaiEADAELAkAgCEUNAAJAIAEoAhwiAkECdEHk6wBqIgAoAgAgAUYEQCAAIAQ2AgAgBA0BQbjpACAJQX4gAndxNgIADAILIAhBEEEUIAgoAhAgAUYbaiAENgIAIARFDQELIAQgCDYCGCABKAIQIgAEQCAEIAA2AhAgACAENgIYCyABKAIUIgBFDQAgBCAANgIUIAAgBDYCGAsCQCADQQ9NBEAgASADIAdqIgBBA3I2AgQgACABaiIAIAAoAgRBAXI2AgQMAQsgASAHQQNyNgIEIAEgB2oiAiADQQFyNgIEIAIgA2ogAzYCACAKBEAgCkEDdiIAQQN0QdzpAGohBUHI6QAoAgAhBAJ/QQEgAHQiACAGcUUEQEG06QAgACAGcjYCACAFDAELIAUoAggLIQAgBSAENgIIIAAgBDYCDCAEIAU2AgwgBCAANgIIC0HI6QAgAjYCAEG86QAgAzYCAAsgAUEIaiEACyALQRBqJAAgAAsxACABAn8gAigCTEEASARAIAAgASACEDkMAQsgACABIAIQOQsiAEYEQA8LIAAgAW4aC1IBAn9BgNcAKAIAIgEgAEEDakF8cSICaiEAAkAgAkEAIAAgAU0bDQAgAD8AQRB0SwRAIAAQFEUNAQtBgNcAIAA2AgAgAQ8LQYjoAEEwNgIAQX8LgwECA38BfgJAIABCgICAgBBUBEAgACEFDAELA0AgAUEBayIBIAAgAEIKgCIFQgp+fadBMHI6AAAgAEL/////nwFWIQIgBSEAIAINAAsLIAWnIgIEQANAIAFBAWsiASACIAJBCm4iA0EKbGtBMHI6AAAgAkEJSyEEIAMhAiAEDQALCyABC+cCAgN/AXwjAEEQayIBJAACfSAAvCIDQf////8HcSICQdqfpPoDTQRAQwAAgD8gAkGAgIDMA0kNARogALsQJQwBCyACQdGn7YMETQRAIAC7IQQgAkHkl9uABE8EQEQYLURU+yEJwEQYLURU+yEJQCADQQBOGyAEoBAljAwCCyADQQBIBEAgBEQYLURU+yH5P6AQJAwCC0QYLURU+yH5PyAEoRAkDAELIAJB1eOIhwRNBEAgAkHg27+FBE8EQEQYLURU+yEZwEQYLURU+yEZQCADQQBOGyAAu6AQJQwCCyADQQBIBEBE0iEzf3zZEsAgALuhECQMAgsgALtE0iEzf3zZEsCgECQMAQsgACAAkyACQYCAgPwHTw0AGgJAAkACQAJAIAAgAUEIahBLQQNxDgMAAQIDCyABKwMIECUMAwsgASsDCJoQJAwCCyABKwMIECWMDAELIAErAwgQJAshACABQRBqJAAgAAsGACAAECELxQEBAn8jAEEQayIBJAACQCAAvUIgiKdB/////wdxIgJB+8Ok/wNNBEAgAkGAgMDyA0kNASAARAAAAAAAAAAAQQAQLiEADAELIAJBgIDA/wdPBEAgACAAoSEADAELAkACQAJAAkAgACABEExBA3EOAwABAgMLIAErAwAgASsDCEEBEC4hAAwDCyABKwMAIAErAwgQLyEADAILIAErAwAgASsDCEEBEC6aIQAMAQsgASsDACABKwMIEC+aIQALIAFBEGokACAAC5kBAQN8IAAgAKIiAyADIAOioiADRHzVz1o62eU9okTrnCuK5uVavqCiIAMgA0R9/rFX4x3HPqJE1WHBGaABKr+gokSm+BARERGBP6CgIQUgAyAAoiEEIAJFBEAgBCADIAWiRElVVVVVVcW/oKIgAKAPCyAAIAMgAUQAAAAAAADgP6IgBSAEoqGiIAGhIARESVVVVVVVxT+ioKELkgEBA3xEAAAAAAAA8D8gACAAoiICRAAAAAAAAOA/oiIDoSIERAAAAAAAAPA/IAShIAOhIAIgAiACIAJEkBXLGaAB+j6iRHdRwRZswVa/oKJETFVVVVVVpT+goiACIAKiIgMgA6IgAiACRNQ4iL7p+qi9okTEsbS9nu4hPqCiRK1SnIBPfpK+oKKgoiAAIAGioaCgC60KAwt/BnwBfSMAQSBrIgskACALIAApAzA3AxggCyAAKQMoNwMQIAsgACkDIDcDCCAAIAAoAiAgAmo2AiAgBARAIAJBQGohDCAAKAIYIQYgACgCECEJA0AgBiAFQQJ0IgdqIAcgCWoiByoCADgCACAHIAMgBSAMakECdGoqAgA4AgAgBiAFQQFyIghBAnQiB2ogByAJaiIHKgIAOAIAIAcgAyAIIAxqQQJ0aioCADgCACAFQQJqIgVBwABHDQALAkAgAkEATA0AQQAhBSACQQFrQQNPBEAgAkF8cSEHA0AgBUECdCIJIAZqIgggAyAJaioCADgCgAIgCCADIAlBBHJqKgIAOAKEAiAIIAMgCUEIcmoqAgA4AogCIAggAyAJQQxyaioCADgCjAIgBUEEaiEFIA1BBGoiDSAHRw0ACwsgAkEDcSIIRQ0AA0AgBUECdCIHIAZqIAMgB2oqAgA4AoACIAVBAWohBSAOQQFqIg4gCEcNAAsLIAYhAwtEAAAAAAAA8D8gAbsiFaMhFCAAKAIkIQUgACgCKCEGQX8hCgNAAkACQCAFIAZMBEAgBSEGDAELIARFBEADQCAKQQFqIgogAk4NAyAAIAZBAWoiBjYCKCAFIAZKDQALIAUhBgwBCwNAIApBAWoiCiACTg0CIAMgCkECdGoqAgAhFiAAKAIIIgYgBkEEakGcBBA6IAAoAgggFjgCnAQgACAAKAIoQQFqIgU2AiggBSAAKAIkIgZIDQALCyAAKAIgQUBrIQcgBwJ/IAArAzAiE0QAAAAAAABQQKAiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIghIIQUgByAIIAUbIQwCfyATRAAAAAAAAFDAoEQAAAAAAADwP6AiEJlEAAAAAAAA4EFjBEAgEKoMAQtBgICAgHgLIg5BACAOQQBKGyEFQcAAIAZrIQkCQCABQwAAgD9dBEBEAAAAAAAAAAAhEiAFIAxODQEgACgCCCEIA0BEAAAAAAAAAAAhESAIIAUgCWpBAnRqKgIAuyATIAW3oZkiEEQAAAAAAIBPQGYEfEQAAAAAAAAAAAUgACgCAAJ/IBBEAAAAAAAAQECiIhGZRAAAAAAAAOBBYwRAIBGqDAELQYCAgIB4CyINQQJ0aiIHKgIEuyAHKgIAuyIQoSARIA23oaIgEKALoiASoCESIAVBAWoiBSAMRw0ACwwBC0QAAAAAAAAAACESIAUgDE4NACAAKAIIIQgDQEQAAAAAAAAAACERIBQgCCAFIAlqQQJ0aioCALuiIBQgEyAFt6GimSIQRAAAAAAAgE9AZgR8RAAAAAAAAAAABSAAKAIAAn8gEEQAAAAAAABAQKIiEZlEAAAAAAAA4EFjBEAgEaoMAQtBgICAgHgLIg1BAnRqIgcqAgS7IAcqAgC7IhChIBEgDbehoiAQoAuiIBKgIRIgBUEBaiIFIAxHDQALCyAEBEAgBCAPQQJ0aiAStjgCAAsgACAGNgIoIAAgEyAVoCIQOQMwIAACfyAQmUQAAAAAAADgQWMEQCAQqgwBC0GAgICAeAsiBTYCJCAPQQFqIQ8gBSAGTA0BA0AgCkEBaiIKIAJODQEgACAEBH8gAyAKQQJ0aioCACEWIAAoAggiBiAGQQRqQZwEEDogACgCCCAWOAKcBCAAKAIkIQUgACgCKAUgBgtBAWoiBjYCKCAFIAZKDQALDAELCyAERQRAIAAgCykDCDcDICAAIAspAxg3AzAgACALKQMQNwMoCyALQSBqJAAgDwtJAQJ/IAAoAgQiBUEIdSEGIAAoAgAiACABIAVBAXEEfyAGIAIoAgBqKAIABSAGCyACaiADQQIgBUECcRsgBCAAKAIAKAIYEQQAC/0CAgF8A38jAEEQayICJAACQCAAvCIEQf////8HcSIDQdqfpPoDTQRAIANBgICAzANJDQEgALsQJCEADAELIANB0aftgwRNBEAgALshASADQeOX24AETQRAIARBAEgEQCABRBgtRFT7Ifk/oBAljCEADAMLIAFEGC1EVPsh+b+gECUhAAwCC0QYLURU+yEJwEQYLURU+yEJQCAEQQBOGyABoJoQJCEADAELIANB1eOIhwRNBEAgALshASADQd/bv4UETQRAIARBAEgEQCABRNIhM3982RJAoBAlIQAMAwsgAUTSITN/fNkSwKAQJYwhAAwCC0QYLURU+yEZwEQYLURU+yEZQCAEQQBOGyABoBAkIQAMAQsgA0GAgID8B08EQCAAIACTIQAMAQsCQAJAAkACQCAAIAJBCGoQS0EDcQ4DAAECAwsgAisDCBAkIQAMAwsgAisDCBAlIQAMAgsgAisDCJoQJCEADAELIAIrAwgQJYwhAAsgAkEQaiQAIAALqAEAAkAgAUGACE4EQCAARAAAAAAAAOB/oiEAIAFB/w9JBEAgAUH/B2shAQwCCyAARAAAAAAAAOB/oiEAIAFB/RcgAUH9F0kbQf4PayEBDAELIAFBgXhKDQAgAEQAAAAAAABgA6IhACABQbhwSwRAIAFByQdqIQEMAQsgAEQAAAAAAABgA6IhACABQfBoIAFB8GhLG0GSD2ohAQsgACABQf8Haq1CNIa/ogsFABBgAAtLAQJ/IAAoAgQiBkEIdSEHIAAoAgAiACABIAIgBkEBcQR/IAcgAygCAGooAgAFIAcLIANqIARBAiAGQQJxGyAFIAAoAgAoAhQRBgALmgEAIABBAToANQJAIAAoAgQgAkcNACAAQQE6ADQCQCAAKAIQIgJFBEAgAEEBNgIkIAAgAzYCGCAAIAE2AhAgA0EBRw0CIAAoAjBBAUYNAQwCCyABIAJGBEAgACgCGCICQQJGBEAgACADNgIYIAMhAgsgACgCMEEBRw0CIAJBAUYNAQwCCyAAIAAoAiRBAWo2AiQLIABBAToANgsLXQEBfyAAKAIQIgNFBEAgAEEBNgIkIAAgAjYCGCAAIAE2AhAPCwJAIAEgA0YEQCAAKAIYQQJHDQEgACACNgIYDwsgAEEBOgA2IABBAjYCGCAAIAAoAiRBAWo2AiQLC6wBAwF8AX4BfyAAvSICQjSIp0H/D3EiA0GyCE0EfCADQf0HTQRAIABEAAAAAAAAAACiDwsCfCAAIACaIAJCAFkbIgBEAAAAAAAAMEOgRAAAAAAAADDDoCAAoSIBRAAAAAAAAOA/ZARAIAAgAaBEAAAAAAAA8L+gDAELIAAgAaAiACABRAAAAAAAAOC/ZUUNABogAEQAAAAAAADwP6ALIgAgAJogAkIAWRsFIAALC8ABAQN/AkAgASACKAIQIgMEfyADBSACEEgNASACKAIQCyACKAIUIgVrSwRAIAIgACABIAIoAiQRAwAPCwJAIAIoAlBBAEgEQEEAIQMMAQsgASEEA0AgBCIDRQRAQQAhAwwCCyAAIANBAWsiBGotAABBCkcNAAsgAiAAIAMgAigCJBEDACIEIANJDQEgACADaiEAIAEgA2shASACKAIUIQULIAUgACABEBoaIAIgAigCFCABajYCFCABIANqIQQLIAQL1QIBAn8CQCAAIAFGDQAgASAAIAJqIgRrQQAgAkEBdGtNBEAgACABIAIQGhoPCyAAIAFzQQNxIQMCQAJAIAAgAUkEQCADDQIgAEEDcUUNAQNAIAJFDQQgACABLQAAOgAAIAFBAWohASACQQFrIQIgAEEBaiIAQQNxDQALDAELAkAgAw0AIARBA3EEQANAIAJFDQUgACACQQFrIgJqIgMgASACai0AADoAACADQQNxDQALCyACQQNNDQADQCAAIAJBBGsiAmogASACaigCADYCACACQQNLDQALCyACRQ0CA0AgACACQQFrIgJqIAEgAmotAAA6AAAgAg0ACwwCCyACQQNNDQADQCAAIAEoAgA2AgAgAUEEaiEBIABBBGohACACQQRrIgJBA0sNAAsLIAJFDQADQCAAIAEtAAA6AAAgAEEBaiEAIAFBAWohASACQQFrIgINAAsLC68uAQ9/IAAgAC0AASIMIAAoAgRqQQFqNgIQIAAoAhwoAgAgAC8BGGogASAALQAAIhEQGhogACAROgAUIAAtAAAiBCAAKAIcKAIAIAAvARhqaiACIAAtAAEiARAaGiAAIAEgBGoiAjoAFCAAIAAtACAiASACIAEgAkH/AXFLGyIBOgAgIAAoAigoAgAgAC8BJGogACgCHCgCACAALwEYaiABQf8BcRAaGiAAIAE6ACAgAEEAOgCkAUEBIRAgACAALQABQQFqOgB0IAAoAnwoAgAgAC8BeGpBADoAACAALQABBEADQCAQQf8BcSIKQQFrQf8BbyEBIAAoAhwoAgAgAC8BGGoiBy0AACECAkAgAC0AFCIIQQJJDQAgAUH/AWogASABQQBIG0HwKmotAAAhBkEBIQEgCEEBayIEQQFxIQUgCEECRwRAIARBfnEhCEEAIQ0DQCABQQFqIQQgAkH/AXEiAgR/IAZB8ChqLQAAIAJB8ChqLQAAakHwKmotAAAFQQALIAEgB2otAABzQf8BcSICBH8gBkHwKGotAAAgAkHwKGotAABqQfAqai0AAAVBAAshAiABQQJqIQEgBCAHai0AACACcyECIA1BAmoiDSAIRw0ACwsgBUUNACACQf8BcSICBH8gBkHwKGotAAAgAkHwKGotAABqQfAqai0AAAVBAAsgASAHai0AAHMhAgsgACgCfCgCACAALwF4aiAKaiACOgAAIAAtAAEgEEEBaiIQQf8BcU8NAAsLAkACQCAALQB0IgRFDQAgDCARaiESIAAoAnwoAgAgAC8BeGohAkEAIQEDQCABIAJqLQAARQRAIAQgAUEBaiIBRw0BDAILCyASQf8BcSIPIQVBACEBQQAhAiAAQQA6ADgCQCAALQCkAUUNAANAIAAoAqwBKAIAIAAvAagBaiABai0AACEIIAAoAkAoAgAhBCAAIAJBAWo6ADggBCAALwE8aiACQf8BcWogCEF/cyAFajoAACABQQFqIgEgAC0ApAFPDQEgAC0AOCECDAALAAsgACgCiAEoAgAgAC8BhAFqQQAgAC0AggEQGxogACgCiAEoAgAgAC8BhAFqIAAoAnwoAgAgAC8BeGpBAWogAC0AdEEBayICQf8BcRAaGiAAIAI6AIABIAAtAKQBIgEEQANAIAJB/wFxQQFLBEBBACEBQQAgACgCQCgCACAALwE8aiAJai0AACICIAJB/wFGG0HwKmotAAAhCgNAQQAhAiAAKAKIASgCACAALwGEAWoiBSABQf8BcWoiCC0AACIEBEAgCkHwKGotAAAgBEHwKGotAABqQfAqai0AACECCyAIIAUgAUEBaiIBQf8BcWotAAAgAnM6AAAgAC0AgAEiAkEBayABQRh0QRh1Sg0ACyAALQCkASEBCyAJQQFqIgkgAUH/AXFJDQALC0EAIRAgAC0ApAEhCSAAQQE6AEQgAEEBOgA4IABBQGsoAgAoAgAgAC8BPGpBAToAACAAKAJMKAIAIAAvAUhqQQE6AAAgCSAALQABIg1HBEAgAC0AgAEiASANa0H/AXFBACABIA1LGyEGA0AgACgCiAEoAgAgAC8BhAFqIgwgBiAOaiIKQf8BcWotAAAhDSAALQA4IgdBAk8EQCAAKAJAKAIAIAAvATxqIQVBASEBQQEhAgNAQQAhCwJAIAUgByACQX9zakH/AXFqLQAAIghFDQAgDCAKIAFrQf8BcWotAAAiBEUNACAEQfAoai0AACAIQfAoai0AAGpB8CpqLQAAIQsLIAJBAWohAiALIA1zIQ0gAUEBaiIBIAdHDQALCyAAKAJMKAIAIQIgACAALQBEIgFBAWo6AEQgASACIAAvAUhqakEAOgAAIA1B/wFxIggEQCAALQBEIgsgAC0AOCIBSwRAIAAgCzoAXCANQf8BcSEIQQAhAgNAIAAoAmQoAgAgAC8BYGogAmogACgCTCgCACAALwFIaiACai0AACIBBH8gCEHwKGotAAAgAUHwKGotAABqQfAqai0AAAVBAAs6AAAgAkEBaiICIAAtAERJDQALIAAgAC0AOCIBOgBEQQAhAgJAIAEEQCAIQfAoai0AAEH/AXNB8CpqLQAAIQQDQCAAKAJMKAIAIAAvAUhqIAJqIAAoAkAoAgAgAC8BPGogAmotAAAiAQR/IARB8ChqLQAAIAFB8ChqLQAAakHwKmotAAAFQQALOgAAIAJBAWoiAiAALQA4IgFJDQALDAELQQAhAQsgACABIAAtAFwiAiABIAJLGyIBOgA4IAAoAkAoAgAgAC8BPGogACgCZCgCACAALwFgaiABEBoaIAAgAToAOCAALQBEIQsLIAAgCzoAXEEAIQIgCwRAA0AgACgCZCgCACAALwFgaiACaiAAKAJMKAIAIAAvAUhqIAJqLQAAIgEEfyAIQfAoai0AACABQfAoai0AAGpB8CpqLQAABUEACzoAACACQQFqIgIgAC0AREkNAAsgAC0AXCECIAAtADghAQsgACABIAIgAUH/AXEgAkH/AXFLGyICOgBoQQAhASAAKAJwKAIAIAAvAWxqQQAgAkH/AXEQGxogAC0AOCIEBEBBACECIAQhAQNAIAAoAnAoAgAgAC8BbGogAC0AaCACIAFrakH/AXFqIAAoAkAoAgAgAC8BPGogAmotAAA6AAAgAkEBaiICIAAtADgiAUkNAAsLQQAhAiAALQBcIgsEQANAIAAoAnAoAgAgAC8BbGogAC0AaCACIAtrakH/AXFqIgEgAS0AACAAKAJkKAIAIAAvAWBqIAJqLQAAczoAACACQQFqIgIgAC0AXCILSQ0ACyAALQA4IQELIAAgASAALQBoIgIgAUH/AXEgAksbIgE6ADggACgCQCgCACAALwE8aiAAKAJwKAIAIAAvAWxqIAFB/wFxEBoaIAAgAToAOAsgAC0AASINIAlrIA5BAWoiDkH/AXFLDQALCwJAIAAtADgiCEUEQEEAIQIMAQsgACgCQCgCACAALwE8aiEEQQAhAQNAIAEiAkEBaiEBIAQgAkH/AXFqLQAARQ0ACwsgDSACQX9zIAlrIAhqQQF0IAlqTwRAIAAoAqABKAIAIAAvAZwBaiAAKAJAKAIAIAAvATxqIAJqIAggAmsQGhogACAALQA4IAJrOgCYAQsgACAALQCYASIEOgA4IARBGHRBgICACGtBGHUiAUEATgRAQQAhCwNAIAAoAkAoAgAgAC8BPGogC2ogACgCoAEoAgAgAC8BnAFqIAFB/wFxai0AADoAACABQQFrIQEgC0EBaiILIARHDQALIAAtADghBAsgAEEAOgCwASAPRQRAQQEPCyAEIQFBACEOA0AgACgCQCgCACAALwE8aiIGLQAAIQICQCABQf8BcSIFQQJJDQAgEEHwKmotAAAhDEEBIQEgBUEBayIIQQFxIQogBUECRwRAIAhBfnEhBUEAIQ0DQEEAIQsgAUEBaiEIIAJB/wFxIgIEfyAMQfAoai0AACACQfAoai0AAGpB8CpqLQAABUEACyABIAZqLQAAc0H/AXEiAgR/IAxB8ChqLQAAIAJB8ChqLQAAakHwKmotAAAFQQALIQIgAUECaiEBIAYgCGotAAAgAnMhAiANQQJqIg0gBUcNAAsLIApFDQAgAkH/AXEiAgR/IAxB8ChqLQAAIAJB8ChqLQAAakHwKmotAAAFQQALIAEgBmotAABzIQILIAJB/wFxRQRAIAAoArgBKAIAIQIgACAALQCwASIBQQFqOgCwASABIAIgAC8BtAFqaiASIA5Bf3NqOgAACyAPIBBBAWoiEEcEQCAOQQFqIQ4gAC0AOCEBDAELC0EBIQEgAC0AsAEiAiAEQQFrQf8BcUcNASACRQ0BIABBFGohAkEAIQEDQCAAKAK4ASgCACAALwG0AWogAWotAAAhBSAAKAKsASgCACEIIAAgAC0ApAEiBEEBajoApAEgBCAIIAAvAagBamogBToAACABQQFqIgEgAC0AsAFJDQALIAIhCEEAIQIgAEG8AWoiBCAALQCkAToAACAALQCkAQRAA0AgACgCxAEoAgAgAC8BwAFqIAJqIAgtAAAgACgCrAEoAgAgAC8BqAFqIAJqLQAAQX9zajoAACACQQFqIgIgAC0ApAFJDQALC0EAIQogACIBQQE6AIwBIAAoApQBKAIAIAAvAZABakEBOgAAIABBAjoARCAAQQE6ADggBC0AAARAA0AgASgCQCgCACABLwE8akEBOgAAIAEoAkwoAgAgAS8BSGpBACAEKAIIKAIAIAQvAQRqIApqLQAAIgIgAkH/AUYbQfAqai0AADoAACABKAJMKAIAIAEvAUhqQQA6AAEgASABLQA4IgUgAS0ARCICIAIgBUkbIgI6AFwgASgCZCgCACABLwFgakEAIAIQGxpBACEGIAEtADgiBwRAA0AgASgCZCgCACABLwFgaiABLQBcIAYgB2tqQf8BcWogASgCQCgCACABLwE8aiAGai0AADoAACAGQQFqIgYgAS0AOCIHSQ0ACwtBACEGIAEtAEQiBwRAA0AgASgCZCgCACABLwFgaiABLQBcIAYgB2tqQf8BcWoiAiACLQAAIAEoAkwoAgAgAS8BSGogBmotAABzOgAAIAZBAWoiBiABLQBEIgdJDQALCyABIAEtAIwBIAEtAFxqQQFrIgI6AGggASgCcCgCACABLwFsakEAIAJB/wFxEBsaIAEtAIwBIQcCQCABLQBcIgVFDQBBACEMQQEhAiAHRQRAQQAhBwwBCwNAQQAhBiACQf8BcQR/A0BBACEHAkAgASgClAEoAgAgAS8BkAFqIAZqLQAAIgVFDQAgAS8BYCABKAJkKAIAIAxqai0AACICRQ0AIAJB8ChqLQAAIAVB8ChqLQAAakHwKmotAAAhBwsgASgCcCgCACABLwFsaiAGIAxqQf8BcWoiAiACLQAAIAdzOgAAIAZBAWoiBiABLQCMASIHSQ0ACyABLQBcIQUgBwVBAAshAiAMQQFqIgwgBUkNAAsLIAEgByABLQBoIgIgAiAHSRsiAjoAjAEgASgClAEoAgAgAS8BkAFqIAEoAnAoAgAgAS8BbGogAkH/AXEQGhogASACOgCMASAKQQFqIgogBC0AAEkNAAsLIAFB3ABqIgQgAS0AdDoAACABLQB0IgVBGHRBgICACGtBGHUiAkEATgRAQQAhCQNAIAEoAmQoAgAgAS8BYGogCWogASgCfCgCACABLwF4aiACQf8BcWotAAA6AAAgAkEBayECIAlBAWoiCSAFRw0ACwsgAS0AjAFBAWtB/wFxIQZBACEHIAFBOGoiAiAELQAAIAAtAIwBakEBayIBOgAAIABBQGsoAgAoAgAgAC8BPGpBACABQf8BcRAbGgJAIAAtAIwBIgpFDQAgBC0AAEUNAEEBIQUDQCAFQf8BcSEBQQAhBSABBEADQCAAKAJAKAIAIAAvATxqIAUgB2pB/wFxaiIMAn9BACAEKAIIKAIAIAQvAQRqIAVqLQAAIgpFDQAaQQAgAC8BkAEgACgClAEoAgAgB2pqLQAAIgFFDQAaIAFB8ChqLQAAIApB8ChqLQAAakHwKmotAAALIAwtAABzOgAAIAVBAWoiBSAELQAAIgFJDQALIAAtAIwBIQogASEFCyAHQQFqIgcgCkkNAAsLIAAgBkECajoARCAAKAJMKAIAIAAvAUhqQQAgAC0ARhAbGiAAKAJMKAIAIAAvAUhqQQE6AAAgAigCCCgCACACLwEEaiIEIAAoAnAoAgAgAC8BbGoiAUcEQCABIAQgAi0AABAaGgsgACACLQAAIgQ6AGhBACEMIAItAAAiASAALQBEIgVrQQFqIgZBAEoEQANAAkAgACgCcCgCACAALwFsaiAMai0AACIKRQ0AQQEhBiAFQQJJDQADQCAAKAJMKAIAIAAvAUhqIAZqLQAAIgQEQCAAKAJwKAIAIAAvAWxqIAYgDGpB/wFxaiIBIAEtAAAgCkHwKGotAAAgBEHwKGotAABqQfAqai0AAHM6AAAgAC0ARCEFCyAGQQFqIgYgBUkNAAsgAi0AACEBCyAMQQFqIgwgASAFa0EBaiIGSA0ACyAALQBoIQQLIAAoAnAoAgAgAC8BbGoiASABIAZqIAQgBmsQOiAAIAAtAGggBms6AGggACAALQBoIgE6AMgBIAFBGHRBgICACGtBGHUiAkEATgRAQQAhCQNAIAAoAtABKAIAIAAvAcwBaiAJaiAAKAJwKAIAIAAvAWxqIAJB/wFxai0AADoAACACQQFrIQIgCUEBaiIJIAFHDQALC0EAIQkgAEEAOgA4AkAgAC0AvAFFDQBBACECA0AgACgCxAEoAgAgAC8BwAFqIAJqLQAAIQQgACgCQCgCACEBIAAgCUEBajoAOCABIAAvATxqIAlB/wFxaiAEQX9zQQAgBBtB/wFxIgFB/wFzQQAgAWsgARtB8CpqLQAAOgAAIAJBAWoiAiAALQC8AU8NASAALQA4IQkMAAsAC0EAIQQgACgCWCgCACAALwFUakEAIAAtAFIQGxogACAILQAAIgI6AFAgAC0AOCIPBEADQCAAKAJAKAIAIAAvATxqIARqLQAAIQFBACECIABBADoARCABQfAoai0AAEH/AXNB8CpqLQAAIQdBASEJAkAgD0UNAANAIAIgBEcEQAJ/IAAoAkAoAgAgAC8BPGogAmotAAAiAQRAIAFB8ChqLQAAIAdB8ChqLQAAakHwKmotAAAMAQtBAAshCiAAKAJMKAIAIQUgACAALQBEIgFBAWo6AEQgASAFIAAvAUhqaiAKQQFzOgAAIAAtADghDwsgAkEBaiICIA9JDQALIAAtAEQiDEUNACAAKAJMKAIAIAAvAUhqIQpBACECA0ACf0EAIAlB/wFxIgVFDQAaQQAgAiAKai0AACIBRQ0AGiABQfAoai0AACAFQfAoai0AAGpB8CpqLQAACyEJIAJBAWoiAiAMRw0ACwsgACgCcCgCACAALwFsaiIGLQAAIQsCQCAALQBoIgVBAkkNAEEBIQIgBUEBayIBQQFxIQwgBUECRwRAIAFBfnEhCkEAIQ4DQEEAIQ8gAkEBaiEFIAtB/wFxIgEEfyAHQfAoai0AACABQfAoai0AAGpB8CpqLQAABUEACyACIAZqLQAAcyIBBH8gB0HwKGotAAAgAUHwKGotAABqQfAqai0AAAVBAAshASACQQJqIQIgBSAGai0AACABcyELIA5BAmoiDiAKRw0ACwsgDEUNACALQf8BcSIBBH8gB0HwKGotAAAgAUHwKGotAABqQfAqai0AAAVBAAsgAiAGai0AAHMhCwsgACgCrAEoAgAgAC8BqAFqIARqLQAAIAAoAlgoAgAgAC8BVGpqIAtB/wFxIgEEfyAAKAJAKAIAIAAvATxqIARqLQAAQfAoai0AAEHwKmotAABB8ChqLQAAIAFB8ChqLQAAakHwKmotAABB8ChqLQAAIAlB/wFxQfAoai0AAGtB/wFqQf//A3FB/wFwQfAqai0AAAVBAAs6AAAgBEEBaiIEIAAtADgiD0kNAAsgAC0AUCECCyAAIAgtAAAiASACIAEgAkH/AXFLGyIBOgAgQQAhAiAAKAIoKAIAIAAvASRqQQAgAUH/AXEQGxogCC0AACIJBEADQCAAKAIoKAIAIAAvASRqIAAtACAgAiAJa2pB/wFxaiAIKAIIKAIAIAgvAQRqIAJqLQAAOgAAIAJBAWoiAiAILQAAIglJDQALCyAALQBQIgkEQEEAIQIDQCAAKAIoKAIAIAAvASRqIAAtACAgAiAJa2pB/wFxaiIBIAEtAAAgACgCWCgCACAALwFUaiACai0AAHM6AAAgAkEBaiICIAAtAFAiCUkNAAsLCyAAIBE6ACAgAyAAKAIoKAIAIAAvASRqIBEQGhpBACEBCyABC5UEAQJ/QQEgACwAByIBIAFBAUobQQEgAC0ACRsiASAALAATIgIgASACSBsgASAALQAVGyIBIAAsAB8iAiABIAJIGyABIAAtACEbIgEgACwAKyICIAEgAkgbIAEgAC0ALRsiASAALAA3IgIgASACSBsgASAALQA5GyIBIAAsAEMiAiABIAJIGyABIAAtAEUbIgEgACwATyICIAEgAkgbIAEgAC0AURsiASAALABbIgIgASACSBsgASAALQBdGyIBIAAsAGciAiABIAJIGyABIAAtAGkbIgEgACwAcyICIAEgAkgbIAEgAC0AdRsiASAALAB/IgIgASACSBsgASAALQCBARsiASAALACLASICIAEgAkgbIAEgAC0AjQEbIgEgACwAlwEiAiABIAJIGyABIAAtAJkBGyIBIAAsAKMBIgIgASACSBsgASAALQClARsiASAALACvASICIAEgAkgbIAEgAC0AsQEbIgEgACwAuwEiAiABIAJIGyABIAAtAL0BGyIBIAAsAMcBIgIgASACSBsgASAALQDJARsiASAALADTASICIAEgAkgbIAEgAC0A1QEbIgEgACwA3wEiAiABIAJIGyABIAAtAOEBGyIBIAAsAOsBIgIgASACSBsgASAALQDtARsiASAALAD3ASICIAEgAkgbIAEgAC0A+QEbIgEgACwAgwIiAiABIAJIGyABIAAtAIUCGwvGBgIIfwZ9AkAgAigCACIIQQJ0IABODQAgAkEBNgIEIAIgAEECdSIINgIAIABBDEgNACADQoCAgPwDNwIAQQIhBCADIAhBAXYiBkECdGoiBSAGskQYLURU+yHpPyAGt6O2IgyUECsiDTgCBCAFIA04AgAgCEEGSQ0AA0AgAyAEQQJ0IgVqIAwgBLKUIg0QKyIOOAIAIAMgBUEEcmogDRAyIg04AgAgAyAIIARrQQJ0aiIFIA44AgQgBSANOAIAIARBAmoiBCAGSQ0ACyAIIAJBCGogAxBXCwJAIAIoAgQiBkECdCAATg0AIAIgAEECdSIGNgIEIABBCEgNAEEBIQQgAyAIQQJ0aiIFIAZBAXYiB7JEGC1EVPsh6T8gB7ejtiIMlBArIg04AgAgBSAHQQJ0aiANQwAAAD+UOAIAIAZBBEkNACAHQQIgB0ECSxtBAWsiB0EBcSEKIABBGE8EQCAHQX5xIQtBACEHA0AgBSAEQQJ0aiAMIASylCINECtDAAAAP5Q4AgAgBSAGIARrQQJ0aiANEDJDAAAAP5Q4AgAgBSAEQQFqIglBAnRqIAwgCbKUIg0QK0MAAAA/lDgCACAFIAYgCWtBAnRqIA0QMkMAAAA/lDgCACAEQQJqIQQgB0ECaiIHIAtHDQALCyAKRQ0AIAUgBEECdGogDCAEspQiDBArQwAAAD+UOAIAIAUgBiAEa0ECdGogDBAyQwAAAD+UOAIACwJAIABBBU4EQCAAIAJBCGogARBXIAAgASADEFYgBkEBdCAAQQF2IgVtIQcgAEEFRg0BQQIhBCADIAhBAnRqIQhBACECA0AgASAEQQJ0IglqIgMgAyoCACIMQwAAAD8gCCAGIAIgB2oiAmtBAnRqKgIAkyINIAwgASAAIARrQQJ0aiIDKgIAkyIMlCABIAlBBHJqIgkqAgAiDiADKgIEkiIPIAggAkECdGoqAgAiEJSTIhGTOAIAIAkgDiANIA+UIBAgDJSSIgyTOAIAIAMgAyoCACARkjgCACADIAMqAgQgDJM4AgQgBEECaiIEIAVJDQALDAELIABBBEcNAEEEIAEgAxBWCyABIAEqAgAiDCABKgIEIg2TOAIEIAEgDCANkjgCAAuUCAECf0GkJUGlCUEEQQAQDkGkJUGiEEEAEABBpCVB0xVBARAAQaQlQesVQQIQAEGkJUG1FkEDEABBpCVBzhZBBBAAQaQlQcsXQQUQAEHAJUHtDEEEQQAQDkHAJUHdD0EAEABBwCVBwA5BARAAQcAlQeUNQQIQAEHAJUH8D0EDEABBwCVB3Q5BBBAAQcAlQYUOQQUQAEHAJUHDD0EGEABBwCVBqA5BBxAAQcAlQcoNQQgQAEHAJUH9F0EMEABBwCVB5BdBDRAAQcAlQbIXQQ4QAEHAJUGZF0EPEABBwCVBgBdBEBAAQcAlQecWQREQAEHAJUGcFkESEABBwCVBgxZBExAAQcAlQboVQRQQAEHAJUGhFUEVEABBsQ1BmNEARAAAAAAAAABAEAVB+AxBmNEARAAAAAAAABBAEAVBkQ1BmNEARAAAAAAAABhAEAVBmw9BmNEARAAAAAAAACBAEAVB/Q5BmNEARAAAAAAAADBAEAVB3CVBxQlB5CVBAUHmJUECEBBBBBAdIgBBADYCAEEEEB0iAUEANgIAQdwlQZcLQZjRAEHpJUEDIABBmNEAQe0lQQQgARADQQQQHSIAQQQ2AgBBBBAdIgFBBDYCAEHcJUH1CUHg0QBB8iVBBSAAQeDRAEH2JUEGIAEQA0EEEB0iAEEINgIAQQQQHSIBQQg2AgBB3CVBrQhB4NEAQfIlQQUgAEHg0QBB9iVBBiABEANBBBAdIgBBDDYCAEEEEB0iAUEMNgIAQdwlQZAMQeDRAEHyJUEFIABB4NEAQfYlQQYgARADQQQQHSIAQRA2AgBBBBAdIgFBEDYCAEHcJUGbDEGY0QBB6SVBAyAAQZjRAEHtJUEEIAEQA0EEEB0iAEEUNgIAQQQQHSIBQRQ2AgBB3CVB0wxB4NEAQfIlQQUgAEHg0QBB9iVBBiABEANBBBAdIgBBGDYCAEEEEB0iAUEYNgIAQdwlQeUJQaQlQeklQQcgAEGkJUHtJUEIIAEQA0EEEB0iAEEcNgIAQQQQHSIBQRw2AgBB3CVBnQhBpCVB6SVBByAAQaQlQe0lQQggARADQQQQHSIAQSA2AgBBBBAdIgFBIDYCAEHcJUHFDEGY0QBB6SVBAyAAQZjRAEHtJUEEIAEQA0HcJRAPQbsJQQFB/CVBgCZBCUEKEAJBmglBAkGEJkHpJUELQQwQAkGyDEECQYwmQZQmQQ1BDhACQbcMQQVBwCZB+CdBD0EQEAJBvgxBA0GAKEGMKEERQRIQAkGlC0EBQZQoQeYlQRNBFBACQbALQQFBlChB5iVBE0EVEAJB0wpBA0GYKEHtJUEWQRcQAkHCCkEDQZgoQe0lQRZBGBACQcDZAEGgywAoAgA2AgAQTkGc6QBBrOgANgIAQdToAEEqNgIAC1IBAX8gACgCBCEEIAAoAgAiACABAn9BACACRQ0AGiAEQQh1IgEgBEEBcUUNABogASACKAIAaigCAAsgAmogA0ECIARBAnEbIAAoAgAoAhwRBQALCgAgACABQQAQIAuZAgAgAEUEQEEADwsCfwJAIAAEfyABQf8ATQ0BAkBBnOkAKAIAKAIARQRAIAFBgH9xQYC/A0YNAwwBCyABQf8PTQRAIAAgAUE/cUGAAXI6AAEgACABQQZ2QcABcjoAAEECDAQLIAFBgEBxQYDAA0cgAUGAsANPcUUEQCAAIAFBP3FBgAFyOgACIAAgAUEMdkHgAXI6AAAgACABQQZ2QT9xQYABcjoAAUEDDAQLIAFBgIAEa0H//z9NBEAgACABQT9xQYABcjoAAyAAIAFBEnZB8AFyOgAAIAAgAUEGdkE/cUGAAXI6AAIgACABQQx2QT9xQYABcjoAAUEEDAQLC0GI6ABBGTYCAEF/BUEBCwwBCyAAIAE6AABBAQsLDAAgACABIAJBABBGC7wCAAJAAkACQAJAAkACQAJAAkACQAJAAkAgAUEJaw4SAAgJCggJAQIDBAoJCgoICQUGBwsgAiACKAIAIgFBBGo2AgAgACABKAIANgIADwsgAiACKAIAIgFBBGo2AgAgACABMgEANwMADwsgAiACKAIAIgFBBGo2AgAgACABMwEANwMADwsgAiACKAIAIgFBBGo2AgAgACABMAAANwMADwsgAiACKAIAIgFBBGo2AgAgACABMQAANwMADwsgAiACKAIAQQdqQXhxIgFBCGo2AgAgACABKwMAOQMADwsgACACQQARCAALDwsgAiACKAIAIgFBBGo2AgAgACABNAIANwMADwsgAiACKAIAIgFBBGo2AgAgACABNQIANwMADwsgAiACKAIAQQdqQXhxIgFBCGo2AgAgACABKQMANwMAC3IBA38gACgCACwAAEEwa0EKTwRAQQAPCwNAIAAoAgAhA0F/IQEgAkHMmbPmAE0EQEF/IAMsAABBMGsiASACQQpsIgJqIAFB/////wcgAmtKGyEBCyAAIANBAWo2AgAgASECIAMsAAFBMGtBCkkNAAsgAgujFAIRfwF+IwBB0ABrIgYkACAGIAE2AkwgBkE3aiEVIAZBOGohE0EAIQECQAJAAkACQANAIAFB/////wcgDWtKDQEgASANaiENIAYoAkwiCiEBAkACQAJAIAotAAAiCQRAA0ACQAJAIAlB/wFxIgdFBEAgASEJDAELIAdBJUcNASABIQkDQCABLQABQSVHDQEgBiABQQJqIgc2AkwgCUEBaiEJIAEtAAIhCyAHIQEgC0ElRg0ACwsgCSAKayIBQf////8HIA1rIhZKDQcgAARAIAAgCiABEB4LIAENBkF/IRJBASEHAkAgBigCTCIBLAABQTBrQQpPDQAgAS0AAkEkRw0AIAEsAAFBMGshEkEBIRRBAyEHCyAGIAEgB2oiATYCTEEAIQ4CQCABLAAAIgxBIGsiC0EfSwRAIAEhBwwBCyABIQdBASALdCIIQYnRBHFFDQADQCAGIAFBAWoiBzYCTCAIIA5yIQ4gASwAASIMQSBrIgtBIE8NASAHIQFBASALdCIIQYnRBHENAAsLAkAgDEEqRgRAIAYCfwJAIAcsAAFBMGtBCk8NACAGKAJMIgEtAAJBJEcNACABLAABQQJ0IARqQcABa0EKNgIAIAEsAAFBA3QgA2pBgANrKAIAIQ9BASEUIAFBA2oMAQsgFA0GQQAhFEEAIQ8gAARAIAIgAigCACIBQQRqNgIAIAEoAgAhDwsgBigCTEEBagsiATYCTCAPQQBODQFBACAPayEPIA5BgMAAciEODAELIAZBzABqEEQiD0EASA0IIAYoAkwhAQtBACEHQX8hCAJ/QQAgAS0AAEEuRw0AGiABLQABQSpGBEAgBgJ/AkAgASwAAkEwa0EKTw0AIAYoAkwiAS0AA0EkRw0AIAEsAAJBAnQgBGpBwAFrQQo2AgAgASwAAkEDdCADakGAA2soAgAhCCABQQRqDAELIBQNBiAABH8gAiACKAIAIgFBBGo2AgAgASgCAAVBAAshCCAGKAJMQQJqCyIBNgJMIAhBf3NBH3YMAQsgBiABQQFqNgJMIAZBzABqEEQhCCAGKAJMIQFBAQshEANAIAchEUEcIQkgASwAAEH7AGtBRkkNCSAGIAFBAWoiDDYCTCABLAAAIQcgDCEBIAcgEUE6bGpB78oAai0AACIHQQFrQQhJDQALAkACQCAHQRtHBEAgB0UNCyASQQBOBEAgBCASQQJ0aiAHNgIAIAYgAyASQQN0aikDADcDQAwCCyAARQ0IIAZBQGsgByACEEMgBigCTCEMDAILIBJBAE4NCgtBACEBIABFDQcLIA5B//97cSILIA4gDkGAwABxGyEHQQAhDkGACCESIBMhCQJAAkACQAJ/AkACQAJAAkACfwJAAkACQAJAAkACQAJAIAxBAWssAAAiAUFfcSABIAFBD3FBA0YbIAEgERsiAUHYAGsOIQQUFBQUFBQUFA4UDwYODg4UBhQUFBQCBQMUFAkUARQUBAALAkAgAUHBAGsOBw4UCxQODg4ACyABQdMARg0JDBMLIAYpA0AhF0GACAwFC0EAIQECQAJAAkACQAJAAkACQCARQf8BcQ4IAAECAwQaBQYaCyAGKAJAIA02AgAMGQsgBigCQCANNgIADBgLIAYoAkAgDaw3AwAMFwsgBigCQCANOwEADBYLIAYoAkAgDToAAAwVCyAGKAJAIA02AgAMFAsgBigCQCANrDcDAAwTCyAIQQggCEEISxshCCAHQQhyIQdB+AAhAQsgEyEKIAFBIHEhESAGKQNAIhdQRQRAA0AgCkEBayIKIBenQQ9xQYDPAGotAAAgEXI6AAAgF0IPViELIBdCBIghFyALDQALCyAGKQNAUA0DIAdBCHFFDQMgAUEEdkGACGohEkECIQ4MAwsgEyEBIAYpA0AiF1BFBEADQCABQQFrIgEgF6dBB3FBMHI6AAAgF0IHViEKIBdCA4ghFyAKDQALCyABIQogB0EIcUUNAiAIIBMgCmsiAUEBaiABIAhIGyEIDAILIAYpA0AiF0IAUwRAIAZCACAXfSIXNwNAQQEhDkGACAwBCyAHQYAQcQRAQQEhDkGBCAwBC0GCCEGACCAHQQFxIg4bCyESIBcgExAqIQoLIBBBACAIQQBIGw0OIAdB//97cSAHIBAbIQcCQCAGKQNAIhdCAFINACAIDQAgEyIKIQlBACEIDAwLIAggF1AgEyAKa2oiASABIAhIGyEIDAsLAn9B/////wcgCCAIQQBIGyIJIgxBAEchEQJAAkACQCAGKAJAIgFBmBggARsiCiIHIhBBA3FFDQAgDEUNAANAIBAtAABFDQIgDEEBayIMQQBHIREgEEEBaiIQQQNxRQ0BIAwNAAsLIBFFDQELAkAgEC0AAEUNACAMQQRJDQADQCAQKAIAIgFBf3MgAUGBgoQIa3FBgIGChHhxDQEgEEEEaiEQIAxBBGsiDEEDSw0ACwsgDEUNAANAIBAgEC0AAEUNAhogEEEBaiEQIAxBAWsiDA0ACwtBAAsiASAHayAJIAEbIgEgCmohCSAIQQBOBEAgCyEHIAEhCAwLCyALIQcgASEIIAktAAANDQwKCyAIBEAgBigCQAwCC0EAIQEgAEEgIA9BACAHEB8MAgsgBkEANgIMIAYgBikDQD4CCCAGIAZBCGoiATYCQEF/IQggAQshCUEAIQECQANAIAkoAgAiCkUNAQJAIAZBBGogChBBIgtBAEgiCg0AIAsgCCABa0sNACAJQQRqIQkgCCABIAtqIgFLDQEMAgsLIAoNDQtBPSEJIAFBAEgNCyAAQSAgDyABIAcQHyABRQRAQQAhAQwBC0EAIQggBigCQCEJA0AgCSgCACIKRQ0BIAZBBGogChBBIgogCGoiCCABSw0BIAAgBkEEaiAKEB4gCUEEaiEJIAEgCEsNAAsLIABBICAPIAEgB0GAwABzEB8gDyABIAEgD0gbIQEMCAsgEEEAIAhBAEgbDQhBPSEJIAAgBisDQCAPIAggByABIAUREgAiAUEATg0HDAkLIAYgBikDQDwAN0EBIQggFSEKIAshBwwECyAGIAFBAWoiBzYCTCABLQABIQkgByEBDAALAAsgAA0HIBRFDQJBASEBA0AgBCABQQJ0aigCACIABEAgAyABQQN0aiAAIAIQQ0EBIQ0gAUEBaiIBQQpHDQEMCQsLQQEhDSABQQpPDQcDQCAEIAFBAnRqKAIADQEgAUEBaiIBQQpHDQALDAcLQRwhCQwECyAJIAprIhEgCCAIIBFIGyILQf////8HIA5rSg0CQT0hCSALIA5qIgggDyAIIA9KGyIBIBZKDQMgAEEgIAEgCCAHEB8gACASIA4QHiAAQTAgASAIIAdBgIAEcxAfIABBMCALIBFBABAfIAAgCiAREB4gAEEgIAEgCCAHQYDAAHMQHwwBCwtBACENDAMLQT0hCQtBiOgAIAk2AgALQX8hDQsgBkHQAGokACANC7ICAQN/IwBB0AFrIgQkACAEIAI2AswBIARBoAFqIgJBAEEoEBsaIAQgBCgCzAE2AsgBAkBBACABIARByAFqIARB0ABqIAIgAxBFQQBIDQAgACgCTEEATiEFIAAoAgAhAiAAKAJIQQBMBEAgACACQV9xNgIACwJ/AkACQCAAKAIwRQRAIABB0AA2AjAgAEEANgIcIABCADcDECAAKAIsIQYgACAENgIsDAELIAAoAhANAQtBfyAAEEgNARoLIAAgASAEQcgBaiAEQdAAaiAEQaABaiADEEULIQEgBgR/IABBAEEAIAAoAiQRAwAaIABBADYCMCAAIAY2AiwgAEEANgIcIAAoAhQaIABCADcDEEEABSABCxogACAAKAIAIAJBIHFyNgIAIAVFDQALIARB0AFqJAALfgIBfwF+IAC9IgNCNIinQf8PcSICQf8PRwR8IAJFBEAgASAARAAAAAAAAAAAYQR/QQAFIABEAAAAAAAA8EOiIAEQRyEAIAEoAgBBQGoLNgIAIAAPCyABIAJB/gdrNgIAIANC/////////4eAf4NCgICAgICAgPA/hL8FIAALC1kBAX8gACAAKAJIIgFBAWsgAXI2AkggACgCACIBQQhxBEAgACABQSByNgIAQX8PCyAAQgA3AgQgACAAKAIsIgE2AhwgACABNgIUIAAgASAAKAIwajYCEEEACwMAAQslAQF/IwBBEGsiAyQAIAMgAjYCDCAAIAEgAkEfEEYgA0EQaiQAC5QDAgN/A3wjAEEQayIDJAACQCAAvCIEQf////8HcSICQdqfpO4ETQRAIAEgALsiBiAGRIPIyW0wX+Q/okQAAAAAAAA4Q6BEAAAAAAAAOMOgIgVEAAAAUPsh+b+ioCAFRGNiGmG0EFG+oqAiBzkDACAHRAAAAGD7Iem/YyEEAn8gBZlEAAAAAAAA4EFjBEAgBaoMAQtBgICAgHgLIQIgBARAIAEgBiAFRAAAAAAAAPC/oCIFRAAAAFD7Ifm/oqAgBURjYhphtBBRvqKgOQMAIAJBAWshAgwCCyAHRAAAAGD7Iek/ZEUNASABIAYgBUQAAAAAAADwP6AiBUQAAABQ+yH5v6KgIAVEY2IaYbQQUb6ioDkDACACQQFqIQIMAQsgAkGAgID8B08EQCABIAAgAJO7OQMAQQAhAgwBCyADIAIgAkEXdkGWAWsiAkEXdGu+uzkDCCADQQhqIAMgAkEBQQAQTSECIAMrAwAhBSAEQQBIBEAgASAFmjkDAEEAIAJrIQIMAQsgASAFOQMACyADQRBqJAAgAgvZCgMEfAV/AX4jAEEwayIHJAACQAJAAkAgAL0iC0IgiKciBkH/////B3EiCEH61L2ABE0EQCAGQf//P3FB+8MkRg0BIAhB/LKLgARNBEAgC0IAWQRAIAEgAEQAAEBU+yH5v6AiAEQxY2IaYbTQvaAiAjkDACABIAAgAqFEMWNiGmG00L2gOQMIQQEhBgwFCyABIABEAABAVPsh+T+gIgBEMWNiGmG00D2gIgI5AwAgASAAIAKhRDFjYhphtNA9oDkDCEF/IQYMBAsgC0IAWQRAIAEgAEQAAEBU+yEJwKAiAEQxY2IaYbTgvaAiAjkDACABIAAgAqFEMWNiGmG04L2gOQMIQQIhBgwECyABIABEAABAVPshCUCgIgBEMWNiGmG04D2gIgI5AwAgASAAIAKhRDFjYhphtOA9oDkDCEF+IQYMAwsgCEG7jPGABE0EQCAIQbz714AETQRAIAhB/LLLgARGDQIgC0IAWQRAIAEgAEQAADB/fNkSwKAiAETKlJOnkQ7pvaAiAjkDACABIAAgAqFEypSTp5EO6b2gOQMIQQMhBgwFCyABIABEAAAwf3zZEkCgIgBEypSTp5EO6T2gIgI5AwAgASAAIAKhRMqUk6eRDuk9oDkDCEF9IQYMBAsgCEH7w+SABEYNASALQgBZBEAgASAARAAAQFT7IRnAoCIARDFjYhphtPC9oCICOQMAIAEgACACoUQxY2IaYbTwvaA5AwhBBCEGDAQLIAEgAEQAAEBU+yEZQKAiAEQxY2IaYbTwPaAiAjkDACABIAAgAqFEMWNiGmG08D2gOQMIQXwhBgwDCyAIQfrD5IkESw0BCyAAIABEg8jJbTBf5D+iRAAAAAAAADhDoEQAAAAAAAA4w6AiA0QAAEBU+yH5v6KgIgIgA0QxY2IaYbTQPaIiBKEiBUQYLURU+yHpv2MhCQJ/IAOZRAAAAAAAAOBBYwRAIAOqDAELQYCAgIB4CyEGAkAgCQRAIAZBAWshBiADRAAAAAAAAPC/oCIDRDFjYhphtNA9oiEEIAAgA0QAAEBU+yH5v6KgIQIMAQsgBUQYLURU+yHpP2RFDQAgBkEBaiEGIANEAAAAAAAA8D+gIgNEMWNiGmG00D2iIQQgACADRAAAQFT7Ifm/oqAhAgsgASACIAShIgA5AwACQCAIQRR2IgkgAL1CNIinQf8PcWtBEUgNACABIAIgA0QAAGAaYbTQPaIiAKEiBSADRHNwAy6KGaM7oiACIAWhIAChoSIEoSIAOQMAIAkgAL1CNIinQf8PcWtBMkgEQCAFIQIMAQsgASAFIANEAAAALooZozuiIgChIgIgA0TBSSAlmoN7OaIgBSACoSAAoaEiBKEiADkDAAsgASACIAChIAShOQMIDAELIAhBgIDA/wdPBEAgASAAIAChIgA5AwAgASAAOQMIQQAhBgwBCyALQv////////8Hg0KAgICAgICAsMEAhL8hAEEAIQZBASEJA0AgB0EQaiAGQQN0agJ/IACZRAAAAAAAAOBBYwRAIACqDAELQYCAgIB4C7ciAjkDACAAIAKhRAAAAAAAAHBBoiEAQQEhBiAJQQFxIQpBACEJIAoNAAsgByAAOQMgAkAgAEQAAAAAAAAAAGIEQEECIQYMAQtBASEJA0AgCSIGQQFrIQkgB0EQaiAGQQN0aisDAEQAAAAAAAAAAGENAAsLIAdBEGogByAIQRR2QZYIayAGQQFqQQEQTSEGIAcrAwAhACALQgBTBEAgASAAmjkDACABIAcrAwiaOQMIQQAgBmshBgwBCyABIAA5AwAgASAHKwMIOQMICyAHQTBqJAAgBgupEQIDfBB/IwBBsARrIgkkACACIAJBA2tBGG0iCEEAIAhBAEobIhFBaGxqIQwgBEECdEGANWooAgAiDSADQQFrIgtqQQBOBEAgAyANaiEIIBEgC2shAgNAIAlBwAJqIApBA3RqIAJBAEgEfEQAAAAAAAAAAAUgAkECdEGQNWooAgC3CzkDACACQQFqIQIgCkEBaiIKIAhHDQALCyAMQRhrIQ8gDUEAIA1BAEobIQpBACEIA0BEAAAAAAAAAAAhBSADQQBKBEAgCCALaiEOQQAhAgNAIAAgAkEDdGorAwAgCUHAAmogDiACa0EDdGorAwCiIAWgIQUgAkEBaiICIANHDQALCyAJIAhBA3RqIAU5AwAgCCAKRiECIAhBAWohCCACRQ0AC0EvIAxrIRRBMCAMayESIAxBGWshFSANIQgCQANAIAkgCEEDdGorAwAhBUEAIQIgCCEKIAhBAEwiEEUEQANAIAlB4ANqIAJBAnRqAn8CfyAFRAAAAAAAAHA+oiIGmUQAAAAAAADgQWMEQCAGqgwBC0GAgICAeAu3IgZEAAAAAAAAcMGiIAWgIgWZRAAAAAAAAOBBYwRAIAWqDAELQYCAgIB4CzYCACAJIApBAWsiCkEDdGorAwAgBqAhBSACQQFqIgIgCEcNAAsLAn8gBSAPEDMiBSAFRAAAAAAAAMA/opxEAAAAAAAAIMCioCIFmUQAAAAAAADgQWMEQCAFqgwBC0GAgICAeAshDiAFIA63oSEFAkACQAJAAn8gD0EATCIWRQRAIAhBAnQgCWoiAiACKALcAyICIAIgEnUiAiASdGsiCjYC3AMgAiAOaiEOIAogFHUMAQsgDw0BIAhBAnQgCWooAtwDQRd1CyILQQBMDQIMAQtBAiELIAVEAAAAAAAA4D9mDQBBACELDAELQQAhAkEAIQogEEUEQANAIAlB4ANqIAJBAnRqIhcoAgAhEEH///8HIRMCfwJAIAoNAEGAgIAIIRMgEA0AQQAMAQsgFyATIBBrNgIAQQELIQogAkEBaiICIAhHDQALCwJAIBYNAEH///8DIQICQAJAIBUOAgEAAgtB////ASECCyAIQQJ0IAlqIhAgECgC3AMgAnE2AtwDCyAOQQFqIQ4gC0ECRw0ARAAAAAAAAPA/IAWhIQVBAiELIApFDQAgBUQAAAAAAADwPyAPEDOhIQULIAVEAAAAAAAAAABhBEBBACEKIAghAgJAIAggDUwNAANAIAlB4ANqIAJBAWsiAkECdGooAgAgCnIhCiACIA1KDQALIApFDQAgDyEMA0AgDEEYayEMIAlB4ANqIAhBAWsiCEECdGooAgBFDQALDAMLQQEhAgNAIAIiCkEBaiECIAlB4ANqIA0gCmtBAnRqKAIARQ0ACyAIIApqIQoDQCAJQcACaiADIAhqIgtBA3RqIAhBAWoiCCARakECdEGQNWooAgC3OQMAQQAhAkQAAAAAAAAAACEFIANBAEoEQANAIAAgAkEDdGorAwAgCUHAAmogCyACa0EDdGorAwCiIAWgIQUgAkEBaiICIANHDQALCyAJIAhBA3RqIAU5AwAgCCAKSA0ACyAKIQgMAQsLAkAgBUEYIAxrEDMiBUQAAAAAAABwQWYEQCAJQeADaiAIQQJ0agJ/An8gBUQAAAAAAABwPqIiBplEAAAAAAAA4EFjBEAgBqoMAQtBgICAgHgLIgK3RAAAAAAAAHDBoiAFoCIFmUQAAAAAAADgQWMEQCAFqgwBC0GAgICAeAs2AgAgCEEBaiEIDAELAn8gBZlEAAAAAAAA4EFjBEAgBaoMAQtBgICAgHgLIQIgDyEMCyAJQeADaiAIQQJ0aiACNgIAC0QAAAAAAADwPyAMEDMhBQJAIAhBAEgNACAIIQMDQCAJIAMiAEEDdGogBSAJQeADaiADQQJ0aigCALeiOQMAIANBAWshAyAFRAAAAAAAAHA+oiEFIAANAAsgCEEASA0AIAghAgNAIAggAiIAayEDRAAAAAAAAAAAIQVBACECA0ACQCACQQN0QeDKAGorAwAgCSAAIAJqQQN0aisDAKIgBaAhBSACIA1ODQAgAiADSSEMIAJBAWohAiAMDQELCyAJQaABaiADQQN0aiAFOQMAIABBAWshAiAAQQBKDQALCwJAAkACQAJAAkAgBA4EAQICAAQLRAAAAAAAAAAAIQYCQCAIQQBMDQAgCUGgAWogCEEDdGorAwAhBSAIIQIDQCAJQaABaiIDIAJBA3RqIAUgAyACQQFrIgBBA3RqIgMrAwAiByAHIAWgIgWhoDkDACADIAU5AwAgAkEBSyEDIAAhAiADDQALIAhBAkgNACAJQaABaiAIQQN0aisDACEFIAghAgNAIAlBoAFqIgMgAkEDdGogBSADIAJBAWsiAEEDdGoiAysDACIGIAYgBaAiBaGgOQMAIAMgBTkDACACQQJLIQMgACECIAMNAAtEAAAAAAAAAAAhBiAIQQFMDQADQCAGIAlBoAFqIAhBA3RqKwMAoCEGIAhBAkohACAIQQFrIQggAA0ACwsgCSsDoAEhBSALDQIgASAFOQMAIAkrA6gBIQUgASAGOQMQIAEgBTkDCAwDC0QAAAAAAAAAACEFIAhBAE4EQANAIAgiAEEBayEIIAUgCUGgAWogAEEDdGorAwCgIQUgAA0ACwsgASAFmiAFIAsbOQMADAILRAAAAAAAAAAAIQUgCEEATgRAIAghAwNAIAMiAEEBayEDIAUgCUGgAWogAEEDdGorAwCgIQUgAA0ACwsgASAFmiAFIAsbOQMAIAkrA6ABIAWhIQVBASECIAhBAEoEQANAIAUgCUGgAWogAkEDdGorAwCgIQUgAiAIRyEAIAJBAWohAiAADQALCyABIAWaIAUgCxs5AwgMAQsgASAFmjkDACAJKwOoASEFIAEgBpo5AxAgASAFmjkDCAsgCUGwBGokACAOQQdxC94DAEHE0ABB6AwQGUHQ0ABBvQpBAUEBQQAQGEHc0ABB4AlBAUGAf0H/ABAEQfTQAEHZCUEBQYB/Qf8AEARB6NAAQdcJQQFBAEH/ARAEQYDRAEGHCUECQYCAfkH//wEQBEGM0QBB/ghBAkEAQf//AxAEQZjRAEGWCUEEQYCAgIB4Qf////8HEARBpNEAQY0JQQRBAEF/EARBsNEAQcMLQQRBgICAgHhB/////wcQBEG80QBBugtBBEEAQX8QBEHI0QBBswlCgICAgICAgICAf0L///////////8AEFhB1NEAQbIJQgBCfxBYQeDRAEGfCUEEEA1B7NEAQasMQQgQDUHgJ0HiCxAMQcgvQfYTEAxBoDBBBEHICxAIQfwwQQJB7gsQCEHYMUEEQf0LEAhB6CZB5AoQF0G4JkEAQbETEAFBkDJBAEGXFBABQbgyQQFBzxMQAUHgMkECQcEQEAFBiDNBA0HgEBABQbAzQQRBiBEQAUHYM0EFQaUREAFBgDRBBEG8FBABQag0QQVB2hQQAUGQMkEAQYsSEAFBuDJBAUHqERABQeAyQQJBzRIQAUGIM0EDQasSEAFBsDNBBEGQExABQdgzQQVB7hIQAUHQNEEGQcsREAFB+DRBB0GBFRABCw8AIAEgACgCAGogAjYCAAuVBAEWfyAALACDAiICIAAsAPcBIgMgACwA6wEiBCAALADfASIFIAAsANMBIgYgACwAxwEiByAALAC7ASIIIAAsAK8BIgkgACwAowEiCiAALACXASILIAAsAIsBIgwgACwAfyINIAAsAHMiDiAALABnIg8gACwAWyIQIAAsAE8iESAALABDIhIgACwANyITIAAsACsiFCAALAAfIhUgACwAEyIWIAAsAAciAUEBIAFBAUobQQEgAC0ACRsiASABIBZIGyABIAAtABUbIgEgASAVSBsgASAALQAhGyIBIAEgFEgbIAEgAC0ALRsiASABIBNIGyABIAAtADkbIgEgASASSBsgASAALQBFGyIBIAEgEUgbIAEgAC0AURsiASABIBBIGyABIAAtAF0bIgEgASAPSBsgASAALQBpGyIBIAEgDkgbIAEgAC0AdRsiASABIA1IGyABIAAtAIEBGyIBIAEgDEgbIAEgAC0AjQEbIgEgASALSBsgASAALQCZARsiASABIApIGyABIAAtAKUBGyIBIAEgCUgbIAEgAC0AsQEbIgEgASAISBsgASAALQC9ARsiASABIAdIGyABIAAtAMkBGyIBIAEgBkgbIAEgAC0A1QEbIgEgASAFSBsgASAALQDhARsiASABIARIGyABIAAtAO0BGyIBIAEgA0gbIAEgAC0A+QEbIgEgASACSBsgASAALQCFAhsL5B8CB38DfCMAQSBrIggkAAJ/AkAgAC0AREUEQEGMASEHDAELQQQhBSAAKAJIIgdBBEgEQEECIQVBAQwCC0EAIAdBD0kNARoLIAdBBW5BAXQhBUEACyEDIAUgB2ohBQJAQeTdAC0AAEEBcQ0AQeTdABAjRQ0AQdzbABAmQYgCEBoaQeTdABAiC0Hc2wAQPCAFakEBayEEAkBB2NsALQAAQQFxDQBB2NsAECNFDQBB0NkAECZBiAIQGhpB2NsAECILIARB0NkAEDxtIQkCQCAFQYECTgRAQQAhBEHA2QAoAgAiAEUNASAIQYACNgIMIAgCf0ECIAMNABpBBCAHQQ9JDQAaIAdBBW5BAXQLNgIIIAggBzYCBCAIIAU2AgAgAEHcIyAIEBwMAQsgACgCPCAFaiEDIAEEQCACKAIAIQQgACADNgJYIAAgASAEajYCVAsgAiADIAIoAgBqQQdqQQhtQQN0IgM2AgAgAC0ATARAIAIgACgCDCIEQQN0IAEEfyAAIARBAXQ2ApgBIAAgASADajYClAEgAigCAAUgAwtqQQdqQQhtQQN0IgM2AgACfyAAKAIMQQJtt59EAAAAAAAACECgIgqZRAAAAAAAAOBBYwRAIAqqDAELQYCAgIB4CyEEIAIgAQR/IAAgBDYCoAEgACABIANqNgKcASACKAIABSADCyAEQQJ0akEHakEIbUEDdCIDNgIAIAAoAgxBAm0hBCACIAEEfyAAIAQ2AqgBIAAgASADajYCpAEgAigCAAUgAwsgBEECdGpBB2pBCG1BA3QiAzYCACAAKAIMIQQgAiABBH8gACAENgK0ASAAIAEgA2o2ArABIAIoAgAFIAMLIARBAnRqQQdqQQhtQQN0IgM2AgAgACgCDCIEQYABaiAEIAAtAE4iBBshBiACIAEEfyAAIAY2ArwBIAAgASADajYCuAEgAigCAAUgAwsgBkECdGpBB2pBCG1BA3QiAzYCACAAKAIMIgZBA3QgBiAEGyEGIAIgAQR/IAAgBjYCxAEgACABIANqNgLAASACKAIABSADCyAGQQJ0akEHakEIbUEDdCIGNgIAIAAoAgwhAwJAIAQEQCADQQN0IQQgACgCFCEDDAELIAAoAhQhBAsgAyAEbCEDIAIgAQR/IAAgAzYCzAEgACABIAZqNgLIASACIAMgAigCAGpBB2pBCG1BA3QiAzYCACAAIAdBAWo2AtgBIAAgASADajYC1AEgAigCAAUgAyAGakEHakEIbUEDdAsgB2pBCGpBCG1BA3QiAzYCAAJAIAAtAEQEQCAAKAJIIgNBwQBOBEBBACEEQcDZACgCACIARQ0EIAhBwAA2AhQgCCADNgIQIABBiR8gCEEQahAcDAQLAkBB5N0ALQAAQQFxDQBB5N0AECNFDQBB3NsAECZBiAIQGhpB5N0AECILAn9B5dsALQAABH9B4tsALAAAQeTbACwAAGwiA0EAIANBAEobBUEACyEDQfHbAC0AAARAQe7bACwAAEHw2wAsAABsIgQgAyADIARIGyEDC0H92wAtAAAEQEH62wAsAABB/NsALAAAbCIEIAMgAyAESBshAwtBidwALQAABEBBhtwALAAAQYjcACwAAGwiBCADIAMgBEgbIQMLQZXcAC0AAARAQZLcACwAAEGU3AAsAABsIgQgAyADIARIGyEDC0Gh3AAtAAAEQEGe3AAsAABBoNwALAAAbCIEIAMgAyAESBshAwtBrdwALQAABEBBqtwALAAAQazcACwAAGwiBCADIAMgBEgbIQMLQbncAC0AAARAQbbcACwAAEG43AAsAABsIgQgAyADIARIGyEDC0HF3AAtAAAEQEHC3AAsAABBxNwALAAAbCIEIAMgAyAESBshAwtB0dwALQAABEBBztwALAAAQdDcACwAAGwiBCADIAMgBEgbIQMLQd3cAC0AAARAQdrcACwAAEHc3AAsAABsIgQgAyADIARIGyEDC0Hp3AAtAAAEQEHm3AAsAABB6NwALAAAbCIEIAMgAyAESBshAwtB9dwALQAABEBB8twALAAAQfTcACwAAGwiBCADIAMgBEgbIQMLQYHdAC0AAARAQf7cACwAAEGA3QAsAABsIgQgAyADIARIGyEDC0GN3QAtAAAEQEGK3QAsAABBjN0ALAAAbCIEIAMgAyAESBshAwtBmd0ALQAABEBBlt0ALAAAQZjdACwAAGwiBCADIAMgBEgbIQMLQaXdAC0AAARAQaLdACwAAEGk3QAsAABsIgQgAyADIARIGyEDC0Gx3QAtAAAEQEGu3QAsAABBsN0ALAAAbCIEIAMgAyAESBshAwtBvd0ALQAABEBBut0ALAAAQbzdACwAAGwiBCADIAMgBEgbIQMLQcndAC0AAARAQcbdACwAAEHI3QAsAABsIgQgAyADIARIGyEDC0HV3QAtAAAEQEHS3QAsAABB1N0ALAAAbCIEIAMgAyAESBshAwsgA0Hh3QAtAABFDQAaQd7dACwAAEHg3QAsAABsIgQgAyADIARIGwsgCWwhAyAAKAIMIQQgAQRAIAIoAgAhBiAAIAQ2AqAEIAAgAzYCnAQgACABIAZqNgKYBAsgAiACKAIAIAMgBGxqQQdqQQhtQQN0IgM2AgAgBUEBdCEFIAIgAQR/IAAgBTYCqAQgACABIANqNgKkBCACKAIABSADCyAFakEHakEIbUEDdDYCAAJAQeTdAC0AAEEBcQ0AQeTdABAjRQ0AQdzbABAmQYgCEBoaQeTdABAiC0Hc2wAQUEEFdCEDIAEEQCACKAIAIQUgACADNgKwBCAAIAEgBWo2AqwECyACKAIAIQUMAQsgAiAAKAIMIgVBDXQgAQR/IAAgBUELdDYCkAQgACABIANqNgKMBCACKAIABSADC2pBB2pBCG1BA3QiAzYCACAAKAIMIQUgAiABBH8gACAFNgL8AyAAIAEgA2o2AvgDIAIoAgAFIAMLIAVBAnRqQQdqQQhtQQN0IgU2AgAgACgCDCEDIAEEQCAAIAM2AogEIABBBDYChAQgACABIAVqNgKABCACKAIAIQULIANBBHQhAwsgAiADQQdyIAVqQQhtQQN0IgM2AgALIAAtAE0EQAJAQdjbAC0AAEEBcQ0AQdjbABAjRQ0AQdDZABAmQYgCEBoaQdjbABAiC0HQ2QAQUCIDQQV0IQYgAC0AT0UEQCABBEAgAigCACEFIAAgBjYC0AQgACABIAVqNgLMBAsgAiACKAIAIANBCHRqQQdqQQhtQQN0IgU2AgAgAiADQQd0IgQgACgCDCIDbCABBH8gACADNgLoBCAAIAY2AuQEIAAgASAFajYC4AQgAigCAAUgBQtqQQdqQQhtQQN0IgM2AgAgACgCDCEFIAIgAQR/IAAgBTYC3AQgACAGNgLYBCAAIAEgA2o2AtQEIAIoAgAFIAMLIAQgBWxBB3JqQQhtQQN0IgM2AgAgACgCDCEFIAIgAQR/IAAgBTYCjAcgACABIANqNgKIByACKAIABSADCyAFQQJ0akEHakEIbUEDdCIDNgIAIAIgACgCDCIFQQN0IAEEfyAAIAVBAXQ2ApQHIAAgASADajYCkAcgAigCAAUgAwtqQQdqQQhtQQN0IgU2AgAgACgCDCAAKAIYbEELdCEDAkAgAUUEQCACIANBB3IgBWpBCG1BA3QiBTYCACAAKAIMIQMMAQsgACADNgKcByAAIAEgBWo2ApgHIAIgAigCACADQQdyakEIbUEDdCIDNgIAIAAgASADajYCoAcgACAAKAIMIgNBC3Q2AqQHIAIoAgAhBQsgAiAFIANBDHRqQQdqQQhtQQN0NgIACwJAIAAtAEQEQEEAIQUCQEHY2wAtAABBAXENAEHY2wAQI0UNAEHQ2QAQJkGIAhAaGkHY2wAQIgtBASEEA0AgBUEMbCIDQdnZAGotAAAEQCADQdfZAGosAABBAXQgA0HY2QBqLAAAbSIDIAQgAyAEShshBAsgBUEBaiIFQRZHDQALDAELIAAoAjQhBAsgAgJ/IAFFBEAgByACKAIAakEIakEIbUEDdAwBCyACKAIAIQMgACAHQQFqNgLwBCAAIAEgA2o2AuwEIAIgByACKAIAakEIakEIbUEDdCIDNgIAIAAgBjYCyAQgACABIANqNgLEBCACKAIACyAGQQdyakEIbUEDdCIDNgIAIAQgCWwgCUEAIARBAUobaiEFIAIgAQR/IAAgBTYCsAcgACABIANqNgKsByACKAIABSADCyAFakEHakEIbUEDdCIDNgIACwJAAkAgAC0AREUEQCAAKAI8QQFrQf8BcSIFIAVBHGxqQQRqIQUgAiABBH8gACAFNgJgIAAgASADajYCXCACKAIABSADCyAFakEHakEIbUEDdCIDNgIAIABB5ABqIQZBjAEhBwwBCyAAQeQAaiEGQQQhBSAAKAJIIgdBBEgEQEECIQUMAgsgB0EPSQ0BCyAHQQVuQQF0Qf4BcSEFC0EBIQQgB0H/AXFBA2wgBUEBcmogBUEcbGohBSACIAEEfyAGIAU2AgQgBiABIANqNgIAIAIoAgAFIAMLIAVqQQdqQQhtQQN0NgIAIAAtAE5FDQAgAigCACEDAkAgAUUEQCACIANBh8AAakEIbUEDdEGHBmpBCG1BA3RBhwJqQQhtQQN0QYeAAWpBCG1BA3Q2AgAMAQsgAEGAEDYCvAcgACABIANqIgM2ArgHIAIgAigCAEGHwABqQQhtQQN0IgU2AgAgAEHAATYCxAcgACABIAVqNgLAByACIAIoAgBBhwZqQQhtQQN0IgU2AgAgAEHAADYCzAcgACABIAVqIgc2AsgHIAIgAigCAEGHAmpBCG1BA3QiBTYCACAAQYAgNgLUByAAIAEgBWo2AtAHIAIgAigCAEGHgAFqQQhtQQN0NgIAIANBgICA/AM2AgBBASEBA0AgAbciCkQYLURU+yEJQKJEAAAAAAAAoD+iIgsQLSEMIwBBEGsiAiQAAnwgCkQYLURU+yFZP6IiCr1CIIinQf////8HcSIFQfvDpP8DTQRARAAAAAAAAPA/IAVBnsGa8gNJDQEaIApEAAAAAAAAAAAQLwwBCyAKIAqhIAVBgIDA/wdPDQAaAkACQAJAAkAgCiACEExBA3EOAwABAgMLIAIrAwAgAisDCBAvDAMLIAIrAwAgAisDCEEBEC6aDAILIAIrAwAgAisDCBAvmgwBCyACKwMAIAIrAwhBARAuCyEKIAJBEGokACADIAFBAnRqIApEAAAAAAAA4D+iRAAAAAAAAOA/oCAMIAujtruitjgCACABQQFqIgFBgBBHDQALIABCADcD2AcgAEIANwPoByAAQgA3A+AHIAdBACAAKALMB0ECdBAbGiAAKALAB0EAIAAoAsQHQQJ0EBsaIAAoAtAHQQAgACgC1AdBAnQQGxoLCyAIQSBqJAAgBAueBwEHfyAAIAAoAgQgAC0AAWpBAWo2AhAgACgCHCgCACAALwEYakEAIAAtABYQGxogACgCKCgCACAALwEkakEAIAAtACIQGxoCQCAALQANBEAgACgCNCgCACAALwEwaiAAKAIIIAAtAAFBAWoiA0H/AXEQGhogACADOgAsDAELIAAoAjQoAgAgAC8BMGpBAToAACAAQQI6ADggAEEBOgAsIAAtAAEEQANAIAAoAkAoAgAgAC8BPGpBAToAACAAKAJAKAIAIAAvATxqIAlBGHRBGHUiA0H/AWogAyADQQBIG0HwKmotAAA6AAEgACAALQAsIAAtADhqQQFrIgM6AEQgACgCTCgCACAALwFIakEAIANB/wFxEBsaIAAtACwhAwJAIAAtADgiBUUNAEEAIQRBASEIIANFBEBBACEDDAELA0BBACEGIAhB/wFxBH8DQEEAIQMCQCAAKAI0KAIAIAAvATBqIAZqLQAAIgVFDQAgAC8BPCAAKAJAKAIAIARqai0AACIIRQ0AIAhB8ChqLQAAIAVB8ChqLQAAakHwKmotAAAhAwsgACgCTCgCACAALwFIaiAEIAZqQf8BcWoiBSAFLQAAIANzOgAAIAZBAWoiBiAALQAsIgNJDQALIAAtADghBSADBUEACyEIIARBAWoiBCAFSQ0ACwsgACADIAAtAEQiBCADIARLGyIDOgAsIAAoAjQoAgAgAC8BMGogACgCTCgCACAALwFIaiADQf8BcRAaGiAAIAM6ACwgAC0AASAJQQFqIglBGHRBGHVKDQALCyAAKAIIIAAoAjQoAgAgAC8BMGogAC0ALBAaGiAAQQE6AA0LIAAoAhwoAgAgAC8BGGogASAALQAAIgMQGhogACADOgAUIAAoAigoAgAgAC8BJGogASAALQAAEBoaIAAgAC0AASIBIAAtABRqOgAgIAAtAAAiAwRAA0ACQCAAKAIoKAIAIAAvASRqIAdqLQAAIgRFDQBBASEBIAAtACxBAkkNAANAIAAoAigoAgAgAC8BJGogASAHakH/AXFqIgMgACgCNCgCACAALwEwaiABai0AACIGBH8gBEHwKGotAAAgBkHwKGotAABqQfAqai0AAAVBAAsgAy0AAHM6AAAgAUEBaiIBIAAtACxJDQALIAAtAAAhAwsgB0EBaiIHIANJDQALIAMhByAALQABIQELIAIgACgCKCgCACAALwEkaiAHQf8BcWogAUH/AXEQGhoLzAYBA38jAEHQAGsiBSQAAkAgAUEASARAQQAhAkHA2QAoAgAiAEUNASAFIAE2AgAgAEHWICAFEBwMAQsCQCAALQBNBEACQCAALQBEBH8gACgCSAVBjAELIgYgAU4EQCABIQYMAQtBwNkAKAIAIgdFDQAgBSAGNgJEIAUgATYCQCAHQcMZIAVBQGsQHAsgBEHlAE8EQEEAIQJBwNkAKAIAIgBFDQMgBSAENgIQIABBriEgBUEQahAcDAMLIABBADoAtAQgACgC7ARBACAAKALwBBAbGiAAKAJUQQAgACgCWBAbGiAGQQBMDQEgA0EWTwRAQQAhAkHA2QAoAgAiAEUNAyAFIAM2AjAgAEHCISAFQTBqEBwMAwsgACADQQxsaiIBLQCJBUUEQEEAIQJBwNkAKAIAIgBFDQMgBSADNgIgIABBixsgBUEgahAcDAMLIAAtAEQhAwJ/AkAgAS0AiAVBAkYEQCADBEAgACABKQKABTcC9AQgACABKAKIBTYC/AQMAgtBACECQcDZACgCACIARQ0FQd0bQTsgABAoDAULIAAgASkCgAU3AvQEIAAgASgCiAU2AvwEIAYgA0UNARoLIAAoAkgLIQEgACABNgK8BCAAIAS3RAAAAAAAAFlAo7Y4ArgEIAAoAuwEIAE6AABBACEBIAAoArwEQQBKBEADQEEAIQQgAUEBaiIDIAAoAuwEaiABIAZIBH8gASACai0AAAVBAAs6AAAgAC0AUARAIAAoAuwEIANqIgQgBC0AACABQT9xQbAoai0AAHM6AAALIAMiASAAKAK8BEgNAAsLIABBAToAtAQMAQsgAUUNAEHA2QAoAgAiAUUNAEGKGkHAACABECgLIAAtAExFBEBBASECDAELIABBADsBbCAAQgA3AoABIABCADcCiAEgACgCsAFBACAAKAK0AUECdBAbGiAAKAK4AUEAIAAoArwBQQJ0EBsaQQEhAgJAIAAoAoQEIgFBAEwNACAAKAKIBCIDQQBMDQAgACgCgARBACABIANsQQJ0EBsaCyAAKALUAUEAIAAoAtgBEBsaIAAoApwEIgFBAEwNACAAKAKgBCIDQQBMDQAgACgCmARBACABIANsEBsaCyAFQdAAaiQAIAIL60UDDn8IfQR8IwBBMGsiEiQAAkAgAEECdEGw2QBqKAIAIgdFBEBBfyEBQcDZACgCACICRQ0BIBIgADYCACACQdYcIBIQHAwBCyAHIAIgASADIAQQU0UEQEF/IQFBwNkAKAIAIgJFDQEgEiAANgIgIAJBmRwgEkEgahAcDAELAkACQAJAIAYOAgIAAQsgBy0AtAQEfyAHKAIMIQAgBy0ATgR/IAdBuAdqIAcqAgggByoCBJUgACAHKAKIB0EAEDBBAWoFIAALIAcsAPoEIAcsAPwEIAcsAPsEIgEgBygCPAJ/QQIgBygCvAQiAEEESA0AGkEEIABBD0kNABogAEEFbkEBdAsgAGpqakEBayABbWxsIAcoAjhBAXRqbAVBAAsgBygCGGwhAQwCCyAHLQC0BEUEQEEAIQEMAgsgBygCDCEAIActAE4EfyAHQbgHaiAHKgIIIAcqAgSVIAAgBygCiAdBABAwQQFqBSAACyAHLAD6BCAHLAD8BCAHLAD7BCIBIAcoAjwCf0ECIAcoArwEIgBBBEgNABpBBCAAQQ9JDQAaIABBBW5BAXQLIABqampBAWsgAW1sbCAHKAI4QQF0amwhAQwBCyMAQeABayIBJAACQCAHLQBNRQRAQQAhAkHA2QAoAgAiA0UNAUGKGkHAACADECgMAQsgBy0ATgRAIAdCADcD6AcgB0IANwPgByAHQgA3A9gHIAcoAsgHQQAgBygCzAdBAnQQGxogBygCwAdBACAHKALEB0ECdBAbGiAHKALQB0EAIAcoAtQHQQJ0EBsaCwJ/QQIgBygCvAQiAkEESA0AGkEEIAJBD0kNABogAkEFbkEBdAshCSAHLAD7BCIDIAcoAjwiBiACIAlqampBAWsgA20hFCAHLAD8BCEIIAcsAPoEIQwgBy0AREUEQCAHKAJcIQIgAUEANgLcASABQQA6ANQBIAFBADYC0AEgAUEAOgDIASABQQA2AsQBIAFBADoAvAEgAUEANgK4ASABQQA6ALABIAFBADYCrAEgAUEAOgCkASABQQA2AqABIAFBADoAmAEgAUEANgKUASABQQA6AIwBIAFBADYCiAEgAUEAOgCAASABQQA2AnwgAUEAOgB0IAFBADYCcCABQQA6AGggAUEANgJkIAFBADoAXCABQQA2AlggAUEAOgBQIAFBADYCTCABQQA6AEQgAUFAa0EANgIAIAFBADoAOCABQQA2AjQgAUEAOgAsIAFBADYCKCABQQA6ACAgAUEANgIcIAFBADoAFCABIAZBAWsiAzoAASABQQE6AAAgAUEAOwEMIAJFBEBBASEKIANB/wFxIgIgAkEcbGpBBGoQJyECCyABQQA7ARggASAGOgAWIAEgBkH/AXEiCzsBJCABIAY6ACIgASADQQF0IgM6AC4gAUEDOgA5IAEgAzoAOiABIAtBAXQiEzsBMCABIBMgA0H+AXEiBGoiEzsBPCABIAo6AAwgASACNgIEIAEgAjYCCCABQQA7ARQgAUGAAjsBICABQYAEOwEsIAEgAUEQaiICNgIcIAEgAjYCKCABIAI2AjQgASAEIBNqIgo7AUggASADOgBGIAEgBjoAUiABIAM6AF4gASADOgBqIAFBCDoAdSABIAQgCmoiBjsBVCABIAYgC2oiBjsBYCABIAQgBmoiBjsBbCABIAQgBmoiBjsBeCABQYAIOwFEIAEgAjYCQCABQQA6ADggASACNgJMIAFBgAo7AVAgASACNgJYIAFBgAw7AVwgASACNgJkIAFBgA47AWggASACNgJwIAEgAzoAdiABIAQgBmoiBjsBhAEgASADOgCCASABIAM6AI4BIAEgAzoAmgEgAUEMOgClASABIAM6AKYBIAEgBCAGaiIGOwGQASABIAQgBmoiBjsBnAEgASAEIAZqIgY7AagBIAFBADoAdCABIAI2AnwgAUGAEjsBgAEgASACNgKIASABQYAUOwGMASABIAI2ApQBIAFBgBY7AZgBIAEgAjYCoAEgASAEIAZqIgY7AbQBIAFBDToAsQEgASACNgKsASABQQA6AKQBIAEgAzoAsgEgASAEIAZqIgY7AcABIAFBDjoAvQEgASACNgK4ASABQQA6ALABIAEgAzoAvgEgASAEIAZqIgY7AcwBIAFBDzoAyQEgASACNgLEASABQQA6ALwBIAEgAzoAygEgASAEIAZqOwHYASABQRA6ANUBIAEgAjYC0AEgAUEAOgDIASABIAM6ANYBIAEgAjYC3AEgAUEAOgDUASABIAcoAuwEIgIgBygCVCACIAEtAAAQGiABLQAAahBSAkAgAS0ADEUNACABKAIEIgJFDQAgAhAhCyAHLQC8BCECCyAHKAJkIQRBACEGIAFBADYC3AEgAUEAOgDUASABQQA2AtABIAFBADoAyAEgAUEANgLEASABQQA6ALwBIAFBADYCuAEgAUEAOgCwASABQQA2AqwBIAFBADoApAEgAUEANgKgASABQQA6AJgBIAFBADYClAEgAUEAOgCMASABQQA2AogBIAFBADoAgAEgAUEANgJ8IAFBADoAdCABQQA2AnAgAUEAOgBoIAFBADYCZCABQQA6AFwgAUEANgJYIAFBADoAUCABQQA2AkwgAUEAOgBEIAFBQGtBADYCACABQQA6ADggAUEANgI0IAFBADoALCABQQA2AiggAUEAOgAgIAFBADYCHCABQQA6ABQgASAJOgABIAEgAjoAACABQQA7AQwgBEUEQEEBIQ0gCUH+AXEiA0EcbCADaiACQf8BcUEDbGpBAWoQJyEECyAIIBRsIAxsIRQgAUEAOwEYIAEgAiAJaiILOgAWIAEgCzoAIiABIAlBAXQiAzoALiABQQM6ADkgASADOgA6IAEgC0H/AXEiCTsBJCABIAlBAXQiAjsBMCABIAIgA0H+AXEiCmoiCDsBPCABIA06AAwgASAENgIEIAEgBDYCCCABQQA7ARQgAUGAAjsBICABQYAEOwEsIAEgAUEQaiICNgIcIAEgAjYCKCABIAI2AjQgASAIIApqIgQ7AUggASADOgBGIAEgCzoAUiABIAM6AF4gASADOgBqIAFBCDoAdSABIAQgCmoiBDsBVCABIAQgCWoiBDsBYCABIAQgCmoiBDsBbCABIAQgCmoiBDsBeCABQYAIOwFEIAEgAjYCQCABQQA6ADggASACNgJMIAFBgAo7AVAgASACNgJYIAFBgAw7AVwgASACNgJkIAFBgA47AWggASACNgJwIAEgAzoAdiABIAQgCmoiBDsBhAEgASADOgCCASABIAM6AI4BIAEgAzoAmgEgAUEMOgClASABIAM6AKYBIAEgBCAKaiIEOwGQASABIAQgCmoiBDsBnAEgASAEIApqIgQ7AagBIAFBADoAdCABIAI2AnwgAUGAEjsBgAEgASACNgKIASABQYAUOwGMASABIAI2ApQBIAFBgBY7AZgBIAEgAjYCoAEgASAEIApqIgQ7AbQBIAFBDToAsQEgASACNgKsASABQQA6AKQBIAEgAzoAsgEgASAEIApqIgQ7AcABIAFBDjoAvQEgASACNgK4ASABQQA6ALABIAEgAzoAvgEgASAEIApqIgQ7AcwBIAFBDzoAyQEgASACNgLEASABQQA6ALwBIAEgAzoAygEgASAEIApqOwHYASABQRA6ANUBIAEgAjYC0AEgAUEAOgDIASABIAM6ANYBIAEgAjYC3AEgAUEAOgDUASABIAcoAuwEQQFqIgIgBygCVCAHKAI8aiACIAEtAAAQGiABLQAAahBSIAdBADYCqAcCQCAHLQC0BEUNAANAAkAgBygCOCICIAZKBEBBACECIAcoAjRBAEwNAQNAIAcgBygCqAciA0EBajYCqAcgAyAHKAKsB2ogAkEBcSACQQF0cjoAACACQQFqIgIgBygCNEgNAAsMAQsgAiAUaiIDIAZKBEAgBywA+wQhBCAHLAD6BCEDIAcoAsQEQQAgBygCyAQQGxogBiACayADbSECIAcsAPsEIgNBAEwNASACIARsIQQCQCAHLAD8BCICQQFGBEAgBygCxAQhCiAHKAJUIQ1BACECA0AgCiACQQV0IgkgDSACIARqaiILLQAAQQ9xcmpBAToAACAKIAkgCy0AAEEEdnJqQQE6ABAgAkEBaiICIANHDQALDAELIAcoAsQEIQogBygCVCENIAQgAm0iCSACbCAERwRAQQAhAiADQQFHBEAgA0F+cSELQQAhBANAIAogAkEFdCANIAIgCWpqLQAAQQR2cmpBAToAACAKIAJBAXIiCEEFdCANIAggCWpqLQAAQQR2cmpBAToAACACQQJqIQIgBEECaiIEIAtHDQALCyADQQFxRQ0BIAogAkEFdCANIAIgCWpqLQAAQQR2cmpBAToAAAwBC0EAIQIgA0EBRwRAIANBfnEhC0EAIQQDQCAKIA0gAiAJamotAABBD3EgAkEFdHJqQQE6AAAgCiACQQFyIghBBXQgDSAIIAlqai0AAEEPcXJqQQE6AAAgAkECaiECIARBAmoiBCALRw0ACwsgA0EBcUUNACAKIA0gAiAJamotAABBD3EgAkEFdHJqQQE6AAALQQAhAiADQQBMDQEDQCAHKALEBCACai0AAARAIAcgBygCqAciA0EBajYCqAcgAyAHKAKsB2ogAjoAACAHLQD7BCEDCyACQQFqIgIgA0EYdEEYdUEFdEgNAAsMAQsgBiACIANqTg0CQQAhAiAHKAI0QQBMDQADQCAHIAcoAqgHIgNBAWo2AqgHIAMgBygCrAdqIAJBAXEgAkEBdHJBAXM6AAAgAkEBaiICIAcoAjRIDQALCyAHLAD7BEEBdCAHLAD8BG1BAk4EQCAHIAcoAqgHIgJBAWo2AqgHIAIgBygCrAdqQf8BOgAACyAGIAcsAPoEaiEGDAALAAsCfyAHLQBPRQRAAkAgBygC0AQiA0EATA0AIAcsAPsEQQN0tyEdIAcoAswEIQRBACECIANBAUcEQCADQX5xIQZBACEKA0AgBCACQQN0aiACt0QYLURU+yEJQKIgHaM5AwAgBCACQQFyIg1BA3RqIA23RBgtRFT7IQlAoiAdozkDACACQQJqIQIgCkECaiIKIAZHDQALCyADQQFxRQ0AIAQgAkEDdGogArdEGC1EVPshCUCiIB2jOQMACyAHKALIBCINQQBKBEAgBygCDCIDQX5xIQkgA0EBcSELIAcuAfgEsiEVIAcoAswEIQhBACEEA0ACQCADQQBMIgwNAEQAAAAAAADwPyAHKgIkIha7oyIfIBYgFZQgByoCMCAEspSSuyIgoiEeIAggBEEDdGorAwAhHSAHKALUBCAHKALcBCAEbEECdGohBkEAIQJBACEKIANBAUcEQANAIAYgAkECdGogArcgByoCELuiRBgtRFT7IRlAoiAeoiAdoBAttjgCACAGIAJBAXIiE0ECdGogE7cgByoCELuiRBgtRFT7IRlAoiAeoiAdoBAttjgCACACQQJqIQIgCkECaiIKIAlHDQALCyALBEAgBiACQQJ0aiACtyAHKgIQu6JEGC1EVPshGUCiIB6iIB2gEC22OAIACyAMDQAgBygC4AQgBygC6AQgBGxBAnRqIQYgBygCLLIhFkEAIQIDQCAGIAJBAnRqIAK3IAcqAhC7okQYLURU+yEZQKIgHyAgIAcqAiQgFpS7oKKiIB2gEC22OAIAIAJBAWoiAiADRw0ACwsgBEEBaiIEIA1HDQALC0EAIQ0CQCAHLQC0BEUNACAHQbgHaiETIAcqAgggByoCBJUhHANAIAcoAogHQQAgBygCjAdBAnQQGxoCQAJAAkACQAJAAkAgBygCOCIEIBFKBEAgBygCNCIKQQBMDQFBACEDA0ACQCADQQFxRQRAIAcoAtwEIQIgBygC1AQhCSAHKAIMIgYgBGyyIhdDmpkZPpQhFQJ/IBdDmplZP5QiFotDAAAAT10EQCAWqAwBC0GAgICAeAshCCAGQQBMIQsCfyAVi0MAAABPXQRAIBWoDAELQYCAgIB4CyEMIAsNASAGIBFsIQ8gCSACIANsQQJ0aiELQwAAgD8gFZUhGCAIsiEaIAyyIRsgBygCiAchCSAHKgK4BCEVQQAhAgNAAkAgGyACIA9qsiIWXgRAIAkgAkECdCIIaiIMIBUgCCALaioCAJQgGCAWlJQgDCoCAJI4AgAMAQsgCyACQQJ0IghqKgIAIRkgFiAaXgRAIAggCWoiCCAVIBmUIBggFyAWk5SUIAgqAgCSOAIADAELIAggCWoiCCAVIBmUIAgqAgCSOAIACyACQQFqIgIgBkcNAAsMAQsgBygC6AQhAiAHKALgBCEJIAcoAgwiBiAEbLIiF0OamRk+lCEVAn8gF0OamVk/lCIWi0MAAABPXQRAIBaoDAELQYCAgIB4CyEIIAZBAEwhCwJ/IBWLQwAAAE9dBEAgFagMAQtBgICAgHgLIQwgCw0AIAYgEWwhDyAJIAIgA2xBAnRqIQtDAACAPyAVlSEYIAiyIRogDLIhGyAHKAKIByEJIAcqArgEIRVBACECA0ACQCAbIAIgD2qyIhZeBEAgCSACQQJ0IghqIgwgFSAIIAtqKgIAlCAYIBaUlCAMKgIAkjgCAAwBCyALIAJBAnQiCGoqAgAhGSAWIBpeBEAgCCAJaiIIIBUgGZQgGCAXIBaTlJQgCCoCAJI4AgAMAQsgCCAJaiIIIBUgGZQgCCoCAJI4AgALIAJBAWoiAiAGRw0ACwsgA0EBaiIDIApHDQALDAELIAQgFGoiAiARSgRAIAcsAPsEIQIgBywA+gQhCyAHKALEBEEAIAcoAsgEEBsaIBEgBGsiDCALbSEIIAcsAPsEIgNBAEwiDw0CIAIgCGwhBgJAIAcsAPwEIgJBAUYEQCAHKALEBCEEIAcoAlQhCkEAIQIDQCAEIAJBBXQiCSAKIAIgBmpqIg4tAABBD3FyakEBOgAAIAQgCSAOLQAAQQR2cmpBAToAECACQQFqIgIgA0cNAAsMAQsgBygCxAQhBCAHKAJUIQogBiACbSIJIAJsIAZHBEBBACECIANBAUcEQCADQX5xIQ5BACEGA0AgBCACQQV0IAogAiAJamotAABBBHZyakEBOgAAIAQgAkEBciIQQQV0IAogCSAQamotAABBBHZyakEBOgAAIAJBAmohAiAGQQJqIgYgDkcNAAsLIANBAXFFDQEgBCACQQV0IAogAiAJamotAABBBHZyakEBOgAADAELQQAhAiADQQFHBEAgA0F+cSEOQQAhBgNAIAQgCiACIAlqai0AAEEPcSACQQV0cmpBAToAACAEIAJBAXIiEEEFdCAKIAkgEGpqLQAAQQ9xcmpBAToAACACQQJqIQIgBkECaiIGIA5HDQALCyADQQFxRQ0AIAQgCiACIAlqai0AAEEPcSACQQV0cmpBAToAAAsgDw0CIAwgCCALbGshCSADQQV0IgJBASACQQFKGyEMIAcoAsQEIQ9BACEDQQAhCgNAAkAgAyAPai0AAEUNACADQQF2IQIgCkEBaiEKIANBAXEEQCAHKALoBCEGIAcoAuAEIQsgBygCDCIEIAcsAPoEbLIiF0OamRk+lCEVAn8gF0OamVk/lCIWi0MAAABPXQRAIBaoDAELQYCAgIB4CyEIIARBAEwhDgJ/IBWLQwAAAE9dBEAgFagMAQtBgICAgHgLIRAgDg0BIAQgCWwhDiALIAIgBmxBAnRqIQtDAACAPyAVlSEYIAiyIRogELIhGyAHKAKIByEGIAcqArgEIRVBACECA0ACQCAbIAIgDmqyIhZeBEAgBiACQQJ0IghqIhAgFSAIIAtqKgIAlCAYIBaUlCAQKgIAkjgCAAwBCyALIAJBAnQiCGoqAgAhGSAWIBpeBEAgBiAIaiIIIBUgGZQgGCAXIBaTlJQgCCoCAJI4AgAMAQsgBiAIaiIIIBUgGZQgCCoCAJI4AgALIAJBAWoiAiAERw0ACwwBCyAHKALcBCEGIAcoAtQEIQsgBygCDCIEIAcsAPoEbLIiF0OamRk+lCEVAn8gF0OamVk/lCIWi0MAAABPXQRAIBaoDAELQYCAgIB4CyEIIARBAEwhDgJ/IBWLQwAAAE9dBEAgFagMAQtBgICAgHgLIRAgDg0AIAQgCWwhDiALIAIgBmxBAnRqIQtDAACAPyAVlSEYIAiyIRogELIhGyAHKAKIByEGIAcqArgEIRVBACECA0ACQCAbIAIgDmqyIhZeBEAgBiACQQJ0IghqIhAgFSAIIAtqKgIAlCAYIBaUlCAQKgIAkjgCAAwBCyALIAJBAnQiCGoqAgAhGSAWIBpeBEAgBiAIaiIIIBUgGZQgGCAXIBaTlJQgCCoCAJI4AgAMAQsgBiAIaiIIIBUgGZQgCCoCAJI4AgALIAJBAWoiAiAERw0ACwsgA0EBaiIDIAxHDQALDAELIBEgAiAEak4NAyAHKAI0IgpBAEwNACARIAJrIQtBACEDA0ACQCADQQFxRQRAIAcoAugEIQIgBygC4AQhCSAHKAIMIgYgBGyyIhdDmpkZPpQhFQJ/IBdDmplZP5QiFotDAAAAT10EQCAWqAwBC0GAgICAeAshDCAGQQBMIQgCfyAVi0MAAABPXQRAIBWoDAELQYCAgIB4CyEPIAgNASAGIAtsIQ4gCSACIANsQQJ0aiEIQwAAgD8gFZUhGCAMsiEaIA+yIRsgBygCiAchCSAHKgK4BCEVQQAhAgNAAkAgGyACIA5qsiIWXgRAIAkgAkECdCIMaiIPIBUgCCAMaioCAJQgGCAWlJQgDyoCAJI4AgAMAQsgCCACQQJ0IgxqKgIAIRkgFiAaXgRAIAkgDGoiDCAVIBmUIBggFyAWk5SUIAwqAgCSOAIADAELIAkgDGoiDCAVIBmUIAwqAgCSOAIACyACQQFqIgIgBkcNAAsMAQsgBygC3AQhAiAHKALUBCEJIAcoAgwiBiAEbLIiF0OamRk+lCEVAn8gF0OamVk/lCIWi0MAAABPXQRAIBaoDAELQYCAgIB4CyEMIAZBAEwhCAJ/IBWLQwAAAE9dBEAgFagMAQtBgICAgHgLIQ8gCA0AIAYgC2whDiAJIAIgA2xBAnRqIQhDAACAPyAVlSEYIAyyIRogD7IhGyAHKAKIByEJIAcqArgEIRVBACECA0ACQCAbIAIgDmqyIhZeBEAgCSACQQJ0IgxqIg8gFSAIIAxqKgIAlCAYIBaUlCAPKgIAkjgCAAwBCyAIIAJBAnQiDGoqAgAhGSAWIBpeBEAgCSAMaiIMIBUgGZQgGCAXIBaTlJQgDCoCAJI4AgAMAQsgCSAMaiIMIBUgGZQgDCoCAJI4AgALIAJBAWoiAiAGRw0ACwsgA0EBaiIDIApHDQALCyAKQf//A3ENAQtBASEKCwJAIAcoAgwiA0EATA0AQwAAgD8gCkH//wNxs5UhFSAHKAKIByEKQQAhBEEAIQIgA0EBa0EDTwRAIANBfHEhC0EAIQYDQCAKIAJBAnQiCWoiCCAVIAgqAgCUOAIAIAogCUEEcmoiCCAVIAgqAgCUOAIAIAogCUEIcmoiCCAVIAgqAgCUOAIAIAogCUEMcmoiCSAVIAkqAgCUOAIAIAJBBGohAiAGQQRqIgYgC0cNAAsLIANBA3EiBkUNAANAIAogAkECdGoiCSAVIAkqAgCUOAIAIAJBAWohAiAEQQFqIgQgBkcNAAsLAkAgBy0ATgRAIBMgHCADIAcoAogHIAcoApAHEDAhAwwBCyAHKAKQByAHKAKIByAHKAKUByICIAcoAowHIgQgAiAESBtBAnQQGhoLIANBAEwiBg0CIANBAXEhCyAHKAKgByEKIAcoApAHIQlBACECIANBAUYNASADQX5xIQhBACEEA0AgCiACIA1qQQF0agJ/IAkgAkECdGoqAgBDAAAAR5QiFYtDAAAAT10EQCAVqAwBC0GAgICAeAs7AQAgCiACQQFyIgwgDWpBAXRqAn8gCSAMQQJ0aioCAEMAAABHlCIVi0MAAABPXQRAIBWoDAELQYCAgIB4CzsBACACQQJqIQIgBEECaiIEIAhHDQALDAELIAdBADoAtAQMAwsgC0UNACAKIAIgDWpBAXRqAn8gCSACQQJ0aioCAEMAAABHlCIVi0MAAABPXQRAIBWoDAELQYCAgIB4CzsBAAsCQAJ/AkACQAJAAkACQAJAAkAgBygCIEEBaw4FAAECCAMICyAGDQcgBygCmAchBEEAIQIgA0EBRwRAIANBfnEhBkEAIQoDQCAEIAIgDWpqAn8gBygCkAcgAkECdGoqAgBDAACAP5JDAAAAQ5QiFUMAAIBPXSAVQwAAAABgcQRAIBWpDAELQQALOgAAIAQgAkEBciIJIA1qagJ/IAcoApAHIAlBAnRqKgIAQwAAgD+SQwAAAEOUIhVDAACAT10gFUMAAAAAYHEEQCAVqQwBC0EACzoAACACQQJqIQIgCkECaiIKIAZHDQALCyADQQFxRQ0HIAQgAiANamohBCAHKAKQByACQQJ0aioCAEMAAIA/kkMAAABDlCIVQwAAgE9dIBVDAAAAAGBxRQ0DIAQgFak6AAAMBwsgBg0GIAcoApgHIQRBACECIANBAUcEQCADQX5xIQZBACEKA0AgBCACIA1qagJ/IAcoApAHIAJBAnRqKgIAQwAAAEOUIhVDAACAT10gFUMAAAAAYHEEQCAVqQwBC0EACzoAACAEIAJBAXIiCSANamoCfyAHKAKQByAJQQJ0aioCAEMAAABDlCIVQwAAgE9dIBVDAAAAAGBxBEAgFakMAQtBAAs6AAAgAkECaiECIApBAmoiCiAGRw0ACwsgA0EBcUUNBiAEIAIgDWpqIQQgBygCkAcgAkECdGoqAgBDAAAAQ5QiFUMAAIBPXSAVQwAAAABgcUUNAyAEIBWpOgAADAYLIAYNBSAHKAKYByEGIAcoApAHIQpBACECIANBAUcEQCADQX5xIQlBACEEA0AgBiACIA1qQQF0agJ/IAogAkECdGoqAgBDAACAP5JDAAAAR5QiFUMAAIBPXSAVQwAAAABgcQRAIBWpDAELQQALOwEAIAYgAkEBciILIA1qQQF0agJ/IAogC0ECdGoqAgBDAACAP5JDAAAAR5QiFUMAAIBPXSAVQwAAAABgcQRAIBWpDAELQQALOwEAIAJBAmohAiAEQQJqIgQgCUcNAAsLIANBAXFFDQUgBiACIA1qQQF0aiEEIAogAkECdGoqAgBDAACAP5JDAAAAR5QiFUMAAIBPXSAVQwAAAABgcUUNAyAVqQwECyAGDQQgBygCmAchCiAHKAKQByEJQQAhBEEAIQIgA0EBa0EDTwRAIANBfHEhC0EAIQYDQCAKIAIgDWpBAnRqIAkgAkECdGoqAgA4AgAgCiACQQFyIgggDWpBAnRqIAkgCEECdGoqAgA4AgAgCiACQQJyIgggDWpBAnRqIAkgCEECdGoqAgA4AgAgCiACQQNyIgggDWpBAnRqIAkgCEECdGoqAgA4AgAgAkEEaiECIAZBBGoiBiALRw0ACwsgA0EDcSIGRQ0EA0AgCiACIA1qQQJ0aiAJIAJBAnRqKgIAOAIAIAJBAWohAiAEQQFqIgQgBkcNAAsMBAsgBEEAOgAADAMLIARBADoAAAwCC0EACyECIAQgAjsBAAsgAyANaiENIBFBAWohESAHLQC0BA0ACwsgByANNgLABCAHKAIYIA1sDAELIAdBADoAtARBAQshAiABLQAMRQ0AIAEoAgQiA0UNACADECELIAFB4AFqJAAgAiIBRQRAQX8hAUHA2QAoAgAiAkUNASASIAA2AhAgAkHyHCASQRBqEBwMAQtBACEAAkACfwJAAkAgBygCIEEBaw4FAQEBAAEDCyAHQaAHagwBCyAHQZgHagsoAgAhAAsgBSAAIAEQGhoLIBJBMGokACABCw0AIAEgACgCAGooAgAL8QMCCX8MfUECIQMCQCAAQQlIDQAgACABIAIQcEEIIQMgAEEhSQRADAELQSAhBANAIAAgAyABIAIQbyAEIgNBAnQiBCAASA0ACwsCQCAAIANBAnRHBEBBACEAIANBAEwNAQNAIAEgAEECdCICQQRyaiIFKgIAIQwgASAAIANqQQJ0IgZBBHJqIgQqAgAhDSABIAJqIgIgAioCACIOIAEgBmoiAioCACIPkjgCACAFIAwgDZI4AgAgAiAOIA+TOAIAIAQgDCANkzgCACAAQQJqIgAgA0gNAAsMAQsgA0EATA0AQQAhAANAIAEgACADaiIEIANqIgJBAnQiB0EEcmoiCCoCACEQIAEgAiADakECdCIJQQRyaiIKKgIAIREgASAAQQJ0IgJBBHJqIgsqAgAhEiABIARBAnQiBEEEcmoiBSoCACETIAEgAmoiAiACKgIAIhQgASAEaiIGKgIAIhWSIgwgASAHaiIEKgIAIhYgASAJaiICKgIAIheSIg2SOAIAIAsgEiATkiIOIBAgEZIiD5I4AgAgBCAMIA2TOAIAIAggDiAPkzgCACAGIBQgFZMiDCAQIBGTIg2TOAIAIAUgEiATkyIOIBYgF5MiD5I4AgAgAiAMIA2SOAIAIAogDiAPkzgCACAAQQJqIgAgA0gNAAsLC84HAwp/AX4BfSABQQA2AgACQAJ/AkAgAEEJTgRAQQEhCQNAIABBAXUhAAJAIAkiA0EATA0AQQAhCUEAIQQgA0EBa0EDTwRAIANBfHEhBkEAIQcDQCABIAMgBGpBAnRqIAEgBEECdGooAgAgAGo2AgAgASAEQQFyIgUgA2pBAnRqIAEgBUECdGooAgAgAGo2AgAgASAEQQJyIgUgA2pBAnRqIAEgBUECdGooAgAgAGo2AgAgASAEQQNyIgUgA2pBAnRqIAEgBUECdGooAgAgAGo2AgAgBEEEaiEEIAdBBGoiByAGRw0ACwsgA0EDcSIHRQ0AA0AgASADIARqQQJ0aiABIARBAnRqKAIAIABqNgIAIARBAWohBCAJQQFqIgkgB0cNAAsLIANBAXQhCSADQQR0IgcgAEgNAAsgA0ECdCEEIAAgB0YNAUEBIQMgCUEBTA0DA0AgA0EBdCEFIAEgA0ECdGooAgAhCEEAIQADQCACIAggAEEBdGoiDEECdGoiBykCACENIAIgASAAQQJ0aigCACAFaiIKQQJ0aiIGKgIEIQ4gByAGKgIAOAIAIAcgDjgCBCAGIA03AgAgAiAEIAxqQQJ0aiIHKQIAIQ0gAiAEIApqQQJ0aiIGKgIAIQ4gByAGKgIEOAIEIAcgDjgCACAGIA03AgAgAEEBaiIAIANHDQALIANBAWoiAyAJRw0ACwwDCyAAQQhHDQJBAiEEQQEhCUEEDAELIAlBAEwNASADQQN0CyEHQQAhAwNAAkAgA0UEQCABKAIAIQYMAQsgA0EBdCEMIAEgA0ECdGooAgAhBkEAIQADQCACIAYgAEEBdGoiCkECdGoiBSkCACENIAIgASAAQQJ0aigCACAMaiILQQJ0aiIIKgIEIQ4gBSAIKgIAOAIAIAUgDjgCBCAIIA03AgAgAiAEIApqIgpBAnRqIgUpAgAhDSACIAcgC2oiC0ECdGoiCCoCACEOIAUgCCoCBDgCBCAFIA44AgAgCCANNwIAIAIgBCAKaiIKQQJ0aiIFKQIAIQ0gAiALIARrIgtBAnRqIggqAgAhDiAFIAgqAgQ4AgQgBSAOOAIAIAggDTcCACACIAQgCmpBAnRqIgUpAgAhDSACIAcgC2pBAnRqIggqAgAhDiAFIAgqAgQ4AgQgBSAOOAIAIAggDTcCACAAQQFqIgAgA0cNAAsLIAIgBiADIAlqQQF0aiIGQQJ0aiIAKQIAIQ0gAiAEIAZqQQJ0aiIGKgIEIQ4gACAGKgIAOAIAIAAgDjgCBCAGIA03AgAgA0EBaiIDIAlHDQALCwscACAAIAFBCCACpyACQiCIpyADpyADQiCIpxASC60EAQN/IAAgASgCCCAEECAEQAJAIAEoAgQgAkcNACABKAIcQQFGDQAgASADNgIcCw8LAkAgACABKAIAIAQQIARAAkAgAiABKAIQRwRAIAEoAhQgAkcNAQsgA0EBRw0CIAFBATYCIA8LIAEgAzYCICABKAIsQQRHBEAgAEEQaiIFIAAoAgxBA3RqIQdBACEDIAECfwJAA0ACQCAFIAdPDQAgAUEAOwE0IAUgASACIAJBASAEEDUgAS0ANg0AAkAgAS0ANUUNACABLQA0BEBBASEDIAEoAhhBAUYNBEEBIQYgAC0ACEECcQ0BDAQLQQEhBiAALQAIQQFxRQ0DCyAFQQhqIQUMAQsLQQQgBkUNARoLQQMLNgIsIANBAXENAgsgASACNgIUIAEgASgCKEEBajYCKCABKAIkQQFHDQEgASgCGEECRw0BIAFBAToANg8LIAAoAgwhBSAAQRBqIgYgASACIAMgBBAxIAVBAkgNACAGIAVBA3RqIQYgAEEYaiEFAkAgACgCCCIAQQJxRQRAIAEoAiRBAUcNAQsDQCABLQA2DQIgBSABIAIgAyAEEDEgBUEIaiIFIAZJDQALDAELIABBAXFFBEADQCABLQA2DQIgASgCJEEBRg0CIAUgASACIAMgBBAxIAVBCGoiBSAGSQ0ADAILAAsDQCABLQA2DQEgASgCJEEBRgRAIAEoAhhBAUYNAgsgBSABIAIgAyAEEDEgBUEIaiIFIAZJDQALCwtsAQJ/IAAgASgCCEEAECAEQCABIAIgAxA3DwsgACgCDCEEIABBEGoiBSABIAIgAxA/AkAgBEECSA0AIAUgBEEDdGohBCAAQRhqIQADQCAAIAEgAiADED8gAS0ANg0BIABBCGoiACAESQ0ACwsLMQAgACABKAIIQQAQIARAIAEgAiADEDcPCyAAKAIIIgAgASACIAMgACgCACgCHBEFAAsYACAAIAEoAghBABAgBEAgASACIAMQNwsLugMBBX8jAEFAaiIEJAACf0EBIAAgAUEAECANABpBACABRQ0AGiMAQUBqIgMkACABKAIAIgVBBGsoAgAhBiAFQQhrKAIAIQcgA0EANgIUIANBtM8ANgIQIAMgATYCDCADQeTPADYCCEEAIQUgA0EYakEAQScQGxogASAHaiEBAkAgBkHkzwBBABAgBEAgA0EBNgI4IAYgA0EIaiABIAFBAUEAIAYoAgAoAhQRBgAgAUEAIAMoAiBBAUYbIQUMAQsgBiADQQhqIAFBAUEAIAYoAgAoAhgRBAACQAJAIAMoAiwOAgABAgsgAygCHEEAIAMoAihBAUYbQQAgAygCJEEBRhtBACADKAIwQQFGGyEFDAELIAMoAiBBAUcEQCADKAIwDQEgAygCJEEBRw0BIAMoAihBAUcNAQsgAygCGCEFCyADQUBrJABBACAFIgFFDQAaIARBCGoiA0EEckEAQTQQGxogBEEBNgI4IARBfzYCFCAEIAA2AhAgBCABNgIIIAEgAyACKAIAQQEgASgCACgCHBEFACAEKAIgIgBBAUYEQCACIAQoAhg2AgALIABBAUYLIQAgBEFAayQAIAALCQAgASAAEQIACwQAIAALBQAQBwALVAEBfyMAQTBrIgIkACACIAEoAiA2AiggAiABKQIYNwMgIAIgASkCEDcDGCACIAEpAgg3AxAgAiABKQIANwMIIAJBCGogABEBACEAIAJBMGokACAAC60YAxJ/AXwCfiMAQbAEayILJAAgC0EANgIsAkAgAb0iGUIAUwRAQQEhEEGKCCETIAGaIgG9IRkMAQsgBEGAEHEEQEEBIRBBjQghEwwBC0GQCEGLCCAEQQFxIhAbIRMgEEUhFQsCQCAZQoCAgICAgID4/wCDQoCAgICAgID4/wBRBEAgAEEgIAIgEEEDaiIDIARB//97cRAfIAAgEyAQEB4gAEG5CkG/DyAFQSBxIgUbQYwMQZ4QIAUbIAEgAWIbQQMQHiAAQSAgAiADIARBgMAAcxAfIAIgAyACIANKGyEJDAELIAtBEGohEQJAAn8CQCABIAtBLGoQRyIBIAGgIgFEAAAAAAAAAABiBEAgCyALKAIsIgZBAWs2AiwgBUEgciIOQeEARw0BDAMLIAVBIHIiDkHhAEYNAiALKAIsIQpBBiADIANBAEgbDAELIAsgBkEdayIKNgIsIAFEAAAAAAAAsEGiIQFBBiADIANBAEgbCyEMIAtBMGogC0HQAmogCkEASBsiDSEHA0AgBwJ/IAFEAAAAAAAA8EFjIAFEAAAAAAAAAABmcQRAIAGrDAELQQALIgM2AgAgB0EEaiEHIAEgA7ihRAAAAABlzc1BoiIBRAAAAAAAAAAAYg0ACwJAIApBAEwEQCAKIQMgByEGIA0hCAwBCyANIQggCiEDA0AgA0EdIANBHUkbIQMCQCAHQQRrIgYgCEkNACADrSEaQgAhGQNAIAYgGUL/////D4MgBjUCACAahnwiGSAZQoCU69wDgCIZQoCU69wDfn0+AgAgBkEEayIGIAhPDQALIBmnIgZFDQAgCEEEayIIIAY2AgALA0AgCCAHIgZJBEAgBkEEayIHKAIARQ0BCwsgCyALKAIsIANrIgM2AiwgBiEHIANBAEoNAAsLIAxBGWpBCW4hByADQQBIBEAgB0EBaiEPIA5B5gBGIRIDQEEAIANrIgNBCSADQQlJGyEJAkAgBiAISwRAQYCU69wDIAl2IRRBfyAJdEF/cyEWQQAhAyAIIQcDQCAHIAMgBygCACIXIAl2ajYCACAWIBdxIBRsIQMgB0EEaiIHIAZJDQALIAgoAgAhByADRQ0BIAYgAzYCACAGQQRqIQYMAQsgCCgCACEHCyALIAsoAiwgCWoiAzYCLCANIAggB0VBAnRqIgggEhsiByAPQQJ0aiAGIAYgB2tBAnUgD0obIQYgA0EASA0ACwtBACEDAkAgBiAITQ0AIA0gCGtBAnVBCWwhA0EKIQcgCCgCACIJQQpJDQADQCADQQFqIQMgCSAHQQpsIgdPDQALCyAMQQAgAyAOQeYARhtrIA5B5wBGIAxBAEdxayIHIAYgDWtBAnVBCWxBCWtIBEBBBEGkAiAKQQBIGyALaiAHQYDIAGoiCUEJbSIPQQJ0akHQH2shCkEKIQcgCSAPQQlsayIJQQdMBEADQCAHQQpsIQcgCUEBaiIJQQhHDQALCwJAIAooAgAiEiASIAduIg8gB2xrIglFIApBBGoiFCAGRnENAAJAIA9BAXFFBEBEAAAAAAAAQEMhASAHQYCU69wDRw0BIAggCk8NASAKQQRrLQAAQQFxRQ0BC0QBAAAAAABAQyEBC0QAAAAAAADgP0QAAAAAAADwP0QAAAAAAAD4PyAGIBRGG0QAAAAAAAD4PyAJIAdBAXYiFEYbIAkgFEkbIRgCQCAVDQAgEy0AAEEtRw0AIBiaIRggAZohAQsgCiASIAlrIgk2AgAgASAYoCABYQ0AIAogByAJaiIDNgIAIANBgJTr3ANPBEADQCAKQQA2AgAgCCAKQQRrIgpLBEAgCEEEayIIQQA2AgALIAogCigCAEEBaiIDNgIAIANB/5Pr3ANLDQALCyANIAhrQQJ1QQlsIQNBCiEHIAgoAgAiCUEKSQ0AA0AgA0EBaiEDIAkgB0EKbCIHTw0ACwsgCkEEaiIHIAYgBiAHSxshBgsDQCAGIgcgCE0iCUUEQCAHQQRrIgYoAgBFDQELCwJAIA5B5wBHBEAgBEEIcSEKDAELIANBf3NBfyAMQQEgDBsiBiADSiADQXtKcSIKGyAGaiEMQX9BfiAKGyAFaiEFIARBCHEiCg0AQXchBgJAIAkNACAHQQRrKAIAIg5FDQBBCiEJQQAhBiAOQQpwDQADQCAGIgpBAWohBiAOIAlBCmwiCXBFDQALIApBf3MhBgsgByANa0ECdUEJbCEJIAVBX3FBxgBGBEBBACEKIAwgBiAJakEJayIGQQAgBkEAShsiBiAGIAxKGyEMDAELQQAhCiAMIAMgCWogBmpBCWsiBkEAIAZBAEobIgYgBiAMShshDAtBfyEJIAxB/f///wdB/v///wcgCiAMciISG0oNASAMIBJBAEdqQQFqIQ4CQCAFQV9xIhVBxgBGBEAgA0H/////ByAOa0oNAyADQQAgA0EAShshBgwBCyARIAMgA0EfdSIGaiAGc60gERAqIgZrQQFMBEADQCAGQQFrIgZBMDoAACARIAZrQQJIDQALCyAGQQJrIg8gBToAACAGQQFrQS1BKyADQQBIGzoAACARIA9rIgZB/////wcgDmtKDQILIAYgDmoiAyAQQf////8Hc0oNASAAQSAgAiADIBBqIgUgBBAfIAAgEyAQEB4gAEEwIAIgBSAEQYCABHMQHwJAAkACQCAVQcYARgRAIAtBEGoiBkEIciEDIAZBCXIhCiANIAggCCANSxsiCSEIA0AgCDUCACAKECohBgJAIAggCUcEQCAGIAtBEGpNDQEDQCAGQQFrIgZBMDoAACAGIAtBEGpLDQALDAELIAYgCkcNACALQTA6ABggAyEGCyAAIAYgCiAGaxAeIAhBBGoiCCANTQ0ACyASBEAgAEGWGEEBEB4LIAcgCE0NASAMQQBMDQEDQCAINQIAIAoQKiIGIAtBEGpLBEADQCAGQQFrIgZBMDoAACAGIAtBEGpLDQALCyAAIAYgDEEJIAxBCUgbEB4gDEEJayEGIAhBBGoiCCAHTw0DIAxBCUohAyAGIQwgAw0ACwwCCwJAIAxBAEgNACAHIAhBBGogByAISxshCSALQRBqIgNBCXIhDSADQQhyIQMgCCEHA0AgDSAHNQIAIA0QKiIGRgRAIAtBMDoAGCADIQYLAkAgByAIRwRAIAYgC0EQak0NAQNAIAZBAWsiBkEwOgAAIAYgC0EQaksNAAsMAQsgACAGQQEQHiAGQQFqIQYgCiAMckUNACAAQZYYQQEQHgsgACAGIA0gBmsiBiAMIAYgDEgbEB4gDCAGayEMIAdBBGoiByAJTw0BIAxBAE4NAAsLIABBMCAMQRJqQRJBABAfIAAgDyARIA9rEB4MAgsgDCEGCyAAQTAgBkEJakEJQQAQHwsgAEEgIAIgBSAEQYDAAHMQHyACIAUgAiAFShshCQwBCyATIAVBGnRBH3VBCXFqIQwCQCADQQtLDQBBDCADayEGRAAAAAAAADBAIRgDQCAYRAAAAAAAADBAoiEYIAZBAWsiBg0ACyAMLQAAQS1GBEAgGCABmiAYoaCaIQEMAQsgASAYoCAYoSEBCyARIAsoAiwiBiAGQR91IgZqIAZzrSARECoiBkYEQCALQTA6AA8gC0EPaiEGCyAQQQJyIQogBUEgcSEIIAsoAiwhByAGQQJrIg0gBUEPajoAACAGQQFrQS1BKyAHQQBIGzoAACAEQQhxIQYgC0EQaiEHA0AgByIFAn8gAZlEAAAAAAAA4EFjBEAgAaoMAQtBgICAgHgLIgdBgM8Aai0AACAIcjoAACABIAe3oUQAAAAAAAAwQKIhAQJAIAVBAWoiByALQRBqa0EBRw0AAkAgBg0AIANBAEoNACABRAAAAAAAAAAAYQ0BCyAFQS46AAEgBUECaiEHCyABRAAAAAAAAAAAYg0AC0F/IQlB/f///wcgCiARIA1rIgVqIgZrIANIDQAgAEEgIAIgBgJ/AkAgA0UNACAHIAtBEGprIghBAmsgA04NACADQQJqDAELIAcgC0EQamsiCAsiB2oiAyAEEB8gACAMIAoQHiAAQTAgAiADIARBgIAEcxAfIAAgC0EQaiAIEB4gAEEwIAcgCGtBAEEAEB8gACANIAUQHiAAQSAgAiADIARBgMAAcxAfIAIgAyACIANKGyEJCyALQbAEaiQAIAkLVgEBfyMAQTBrIgEkACABQQhqIAARAgBBJBAdIgAgASgCKDYCICAAIAEpAyA3AhggACABKQMYNwIQIAAgASkDEDcCCCAAIAEpAwg3AgAgAUEwaiQAIAALBABCAAsEAEEAC1YBAX8gACgCPCEDIwBBEGsiACQAIAMgAacgAUIgiKcgAkH/AXEgAEEIahARIgIEf0GI6AAgAjYCAEF/BUEACyECIAApAwghASAAQRBqJABCfyABIAIbC+8CAQd/IwBBIGsiBCQAIAQgACgCHCIFNgIQIAAoAhQhAyAEIAI2AhwgBCABNgIYIAQgAyAFayIBNgIUIAEgAmohBUECIQcCfwJAAkAgACgCPCAEQRBqIgFBAiAEQQxqEAsiAwR/QYjoACADNgIAQX8FQQALRQRAA0AgBSAEKAIMIgNGDQIgA0EASA0DIAEgAyABKAIEIghLIgZBA3RqIgkgAyAIQQAgBhtrIgggCSgCAGo2AgAgAUEMQQQgBhtqIgkgCSgCACAIazYCACAFIANrIQUgACgCPCABQQhqIAEgBhsiASAHIAZrIgcgBEEMahALIgMEf0GI6AAgAzYCAEF/BUEAC0UNAAsLIAVBf0cNAQsgACAAKAIsIgE2AhwgACABNgIUIAAgASAAKAIwajYCECACDAELIABBADYCHCAAQgA3AxAgACAAKAIAQSByNgIAQQAgB0ECRg0AGiACIAEoAgRrCyEAIARBIGokACAACwkAIAAoAjwQFQsPACABIAAoAgBqIAI4AgALDQAgASAAKAIAaioCAAudAQEDfwJ/IAAoAgQiAiEAAkAgAkEDcQRAA0AgAC0AAEUNAiAAQQFqIgBBA3ENAAsLA0AgACIBQQRqIQAgASgCACIDQX9zIANBgYKECGtxQYCBgoR4cUUNAAsgASACayADQf8BcUUNARoDQCABLQABIQMgAUEBaiIAIQEgAw0ACwsgACACawtBAWoiABAnIgEEfyABIAIgABAaBUEACwttAQN/IwBBEGsiAiQAAkACQCAAQQNLDQAgAEECdEGw2QBqIgMoAgAiAUUNACABKALwByIABEAgABAhCyABECEgA0EANgIADAELQcDZACgCACIBRQ0AIAIgADYCACABQcodIAIQHAsgAkEQaiQAC8ETAwl/An0BfiMAQTBrIgQkAAJAAkBBsNkAKAIARQRAQbDZACEHDAELQbTZACgCAEUEQEG02QAhB0EBIQgMAQtBuNkAKAIARQRAQbjZACEHQQIhCAwBC0G82QAoAgBFBEBBvNkAIQdBAyEIDAELQX8hCEHA2QAoAgAiAEUNASAEQQQ2AgAgAEGRIiAEEBwMAQtB+AcQHSEBIAQgACgCADYCCCAEIAAqAgQ4AgwgBCAAKgIIOAIQIAQgACoCDDgCFCAEIAAoAhA2AhggBCAAKgIUOAIcIAQgACgCGDYCICAEIAAoAhw2AiQgBCAAKAIgNgIoIAFBfzYCSCABQQA6AEQgAUGAgID8ezYCQCABQn83AzggAUKAgID8ezcDMCABQoCAgPx7NwMoIAFCgICAgICAgMC/fzcDICABQv////8PNwMYIAFCgICA/Hs3AxAgAUKAgID8ezcDCCABQoCAgPyLgIDAv383AwAgAUIANwCnASABQgA3AqABIAFCADcCmAEgAUIANwKQASABQgA3AogBIAFCADcCgAEgAUIANwJ4IAFCADcCcCABQQA2AtgBIAFCADcC0AEgAUIANwLIASABQgA3AsABIAFCADcCuAEgAUIANwKwASABQQA2AkwgAUEAOgBQIAFCADcCVCABQgA3AlwgAUIANwJkIAFBADsBbCABQfQDakEAQcEAEBsaIAFCADcCvAQgAUHNmbPuAzYCuAQgAUIANwLEBCABQgA3AswEIAFCADcC1AQgAUIANwLcBCABQgA3AuQEIAFCADcC7AQgAUIANwKIByABQgA3ApAHIAFCADcCmAcgAUIANwKgByABQgA3AqgHIAFBADYCsAcgAUIANwK4ByABQgA3AsAHIAFCADcCyAcgAUIANwLQByABQgA3AtgHIAFBADYC4AcgAUIANwPwByABQgA3A+gHIwBBkAFrIgUkACABKALwByIABEAgABAhIAFCADcD8AcLIAEgBCoCDDgCACABIAQqAhA4AgQgASAEKgIUOAIIIAEgBCgCGCIANgIMIAFDAACAPyAAspU4AhACQCAEKAIgIgJBBk8EQEEAIQBBwNkAKAIAIgNFDQEgBSACNgKAASADQbsgIAVBgAFqEBwMAQsgAkECdEHwLmooAgAhAAsgASAANgIUQQEhAiAEKAIkIgMhAAJAAkACQAJAAkAgAw4GBAAAAQECAwtBASEAQQAhAgwDC0ECIQBBACECDAILQQQhAEEAIQIMAQtBACEAQcDZACgCACICBEAgBSADNgJwIAJBuyAgBUHwAGoQHCAEKAIkIQMLQQEhAgsgASAANgIYIAQoAiAhBiABIAM2AiAgASAGNgIcIAFBEDYCNCABQQE2AiwgASABKgIIIgsgASgCDLKVIgo4AiQgASAKIAqSOAIwIAFDAACAPyAKlTgCKCABIAQoAggiAEEATEEEdDYCOCABQQBBAyAAQQBKIgkbNgI8IAQqAhwhCiABIAA2AkggASAKOAJAIAEgCToARCABIAQoAihB/wFxIgBBAXZBAXE6AEwgASAAQQJ2QQFxOgBNIAEgASoCACIKIAtbBH8gASoCBCALXAVBAQs6AE4gASAAQQR2QQFxOgBQIAEgAEEDdkEBcToATwJAIAEoAhRFBEBBwNkAKAIAIgBFDQEgBSAGNgIAIABBiSAgBRAcDAELIAIEQEHA2QAoAgAiAEUNASAFIAM2AhAgAEHWHyAFQRBqEBwMAQsgBCgCGCIAQYEITgRAQcDZACgCACICRQ0BIAVBgAg2AiQgBSAANgIgIAJBrh8gBUEgahAcDAELIApDAAB6RF0EQEHA2QAoAgAiAEUNASAFQoCAgICAgNDHwAA3AzggBSAKuzkDMCAAQZ8YIAVBMGoQSgwBCyAKQwCAu0deBEBBwNkAKAIAIgBFDQEgBUKAgICAgIDc+8AANwNIIAUgCrs5A0AgAEHUGCAFQUBrEEoMAQsgAUIANwPwByABQQAgAUH0B2oiABBRRQRAQcDZACgCACIARQ0BQYkZQTkgABAoDAELAkACf0EAIAEoAvQHIgMiAkUNABogAq0iDKciBiACQQFyQYCABEkNABpBfyAGIAxCIIinGwsiBhAnIgJFDQAgAkEEay0AAEEDcUUNACACQQAgBhAbGgsgAUEANgL0ByABIAI2AvAHIAEgAiAAEFFFBEBBwNkAKAIAIgJFDQEgBSAAKAIANgJgIAJB1h4gBUHgAGoQHAwBCyAAKAIAIgAgA0cEQEHA2QAoAgAiAkUNASAFIAA2AlQgBSADNgJQIAJB7iAgBUHQAGoQHAwBCyABLQBMBEAgASABKAIMNgKQASABKAKcAUEANgIAIAFBADsB5AEgAUIANwLcASABQRY2AugBAkBB5N0ALQAAQQFxDQBB5N0AECNFDQBB3NsAECZBiAIQGhpB5N0AECILIAFB7AFqQdzbAEGIAhAaIQAgASABKAIMIgIgAC4BBCIDIAIgA0gbIAIgAC0ACRsiAiAALgEQIgMgAiADSBsgAiAALQAVGyICIAAuARwiAyACIANIGyACIAAtACEbIgIgAC4BKCIDIAIgA0gbIAIgAC0ALRsiAiAALgE0IgMgAiADSBsgAiAALQA5GyICIABBQGsuAQAiAyACIANIGyACIAAtAEUbIgIgAC4BTCIDIAIgA0gbIAIgAC0AURsiAiAALgFYIgMgAiADSBsgAiAALQBdGyICIAAuAWQiAyACIANIGyACIAAtAGkbIgIgAC4BcCIDIAIgA0gbIAIgAC0AdRsiAiAALgF8IgMgAiADSBsgAiAALQCBARsiAiAALgGIASIDIAIgA0gbIAIgAC0AjQEbIgIgAC4BlAEiAyACIANIGyACIAAtAJkBGyICIAAuAaABIgMgAiADSBsgAiAALQClARsiAiAALgGsASIDIAIgA0gbIAIgAC0AsQEbIgIgAC4BuAEiAyACIANIGyACIAAtAL0BGyICIAAuAcQBIgMgAiADSBsgAiAALQDJARsiAiAALgHQASIDIAIgA0gbIAIgAC0A1QEbIgIgAC4B3AEiAyACIANIGyACIAAtAOEBGyICIAAuAegBIgMgAiADSBsgAiAALQDtARsiAiAALgH0ASIDIAIgA0gbIAIgAC0A+QEbIgIgAC4BgAIiAyACIANIGyACIAAtAIUCGzYCfAsgAS0ATQRAAkBB2NsALQAAQQFxDQBB2NsAECNFDQBB0NkAECZBiAIQGhpB2NsAECILIAFBgAVqQdDZAEGIAhAaGgsgAUEAQYolQQBBABBTGgsgBUGQAWokACAHIAE2AgALIARBMGokACAICz4AIABB2NQAKAIANgIgIABB0NQAKQIANwIYIABByNQAKQIANwIQIABBwNQAKQIANwIIIABBuNQAKQIANwIAC5ELAhV9DH8gAUEASgRAA0AgAiABIBlqIh0gAWoiG0ECdGoiGkEEaioCACEKIAIgASAbakECdGoiHkEEaioCACEMIAIgGUECdCIbQQRyaiIiKgIAIQ0gAiAdQQJ0aiIdQQRqKgIAIQ4gAiAbaiIbIBsqAgAiDyAdKgIAIhCSIgYgGioCACIIIB4qAgAiCZIiB5I4AgAgIiANIA6SIgUgCiAMkiIEkjgCACAaIAUgBJM4AgQgGiAGIAeTOAIAIB0gDSAOkyIGIAggCZMiB5I4AgQgHSAPIBCTIgUgCiAMkyIEkzgCACAeIAYgB5M4AgQgHiAFIASSOAIAIBlBAmoiGSABSA0ACwsgAUECdCIiIAFBBWwiIUgEQCADKgIIIQsgIiEZA0AgAiABIBlqIh0gAWoiG0ECdGoiHEEEaioCACEKIAIgASAbakECdGoiGkEEaioCACEMIAIgGUECdCIbQQRyaiIeKgIAIQ0gAiAdQQJ0aiIdQQRqKgIAIQ4gAiAbaiIbIBsqAgAiDyAdKgIAIhCSIgggHCoCACIJIBoqAgAiBpIiB5I4AgAgHiANIA6SIgUgCiAMkiIEkjgCACAcIAggB5M4AgQgHCAEIAWTOAIAIB0gCyANIA6TIgggCSAGkyIJkiIFIA8gEJMiBiAKIAyTIgeTIgSSlDgCBCAdIAsgBCAFk5Q4AgAgGiALIAkgCJMiBSAGIAeSIgSSlDgCBCAaIAsgBSAEk5Q4AgAgGUECaiIZICFIDQALCyAAIAFBA3QiHUoEQEEAIRkgHSEbA0AgAyAZQQJqIh5BAnRqKgIAIRMgGUECdCADaioCDCIRjCEYIAFBAEwiJEUEQCADIB5BA3RqIhkqAgAiEiARIBGSIgQgGSoCBCIUlJMhFSAEIBKUIBSTIgyMIQ0gASAbaiEjIBSMIQ4gGyEZA0AgAiABIBlqIhwgAWoiGkECdGoiH0EEaioCACEWIAIgASAaakECdGoiIEEEaioCACEXIAIgGUECdCIaQQRyaiIhKgIAIQsgAiAcQQJ0aiIcQQRqKgIAIQogAiAaaiIaIBoqAgAiDyAcKgIAIhCSIgggHyoCACIJICAqAgAiBpIiB5I4AgAgISALIAqSIgUgFiAXkiIEkjgCACAfIBMgBSAEkyIFlCARIAggB5MiBJSSOAIEIB8gEyAElCAFIBiUkjgCACAcIBIgCyAKkyIIIAkgBpMiCZIiBZQgFCAPIBCTIgYgFiAXkyIHkyIElJI4AgQgHCASIASUIAUgDpSSOAIAICAgFSAIIAmTIgWUIAwgBiAHkiIElJI4AgQgICAVIASUIAUgDZSSOAIAIBlBAmoiGSAjSA0ACwsgJEUEQCADIB5BA3QiGUEIcmoqAgAiESATIBOSIgQgAyAZQQxyaioCACISlJMhFCAEIBGUIBKTIgqMIQwgGyAiaiIZIAFqISMgEowhDSATjCEOA0AgAiABIBlqIhwgAWoiGkECdGoiH0EEaioCACEVIAIgASAaakECdGoiIEEEaioCACEWIAIgGUECdCIaQQRyaiIhKgIAIRcgAiAcQQJ0aiIcQQRqKgIAIQsgAiAaaiIaIBoqAgAiDyAcKgIAIhCSIgggHyoCACIJICAqAgAiBpIiB5I4AgAgISAXIAuSIgUgFSAWkiIEkjgCACAfIBggBSAEkyIFlCATIAggB5MiBJSSOAIEIB8gGCAElCAFIA6UkjgCACAcIBEgFyALkyIIIAkgBpMiCZIiBZQgEiAPIBCTIgYgFSAWkyIHkyIElJI4AgQgHCARIASUIAUgDZSSOAIAICAgFCAIIAmTIgWUIAogBiAHkiIElJI4AgQgICAUIASUIAUgDJSSOAIAIBlBAmoiGSAjSA0ACwsgHiEZIBsgHWoiGyAASA0ACwsL5ggCEH0LfyABIAEqAgQiByABKgIMIgSSIgMgASoCFCIIIAEqAhwiBpIiCZM4AhQgASABKgIAIgogASoCCCIFkiIMIAEqAhAiDSABKgIYIguSIg+TOAIQIAEgAyAJkjgCBCABIAwgD5I4AgAgASAHIASTIgcgDSALkyIEkzgCHCABIAogBZMiAyAIIAaTIgiSOAIYIAEgByAEkjgCDCABIAMgCJM4AgggAioCCCEHIAEgASoCICIJIAEqAigiCpIiBSABKgIwIgwgASoCOCINkiILkjgCICABKgI0IQQgASoCPCEDIAEqAiQhCCABKgIsIQYgASAFIAuTOAI0IAEgBCADkiIFIAggBpIiC5M4AjAgASALIAWSOAIkIAEgByAMIA2TIgUgCCAGkyIIkyIGIAkgCpMiCSAEIAOTIgSSIgOSlDgCPCABIAcgBiADk5Q4AjggASAHIAggBZIiAyAJIASTIgSSlDgCLCABIAcgBCADk5Q4AiggAEERTgRAQRAhGANAIAIgE0ECaiIbQQN0IhdqIhQqAgAhAyAUKgIEIQggAiAbQQJ0aioCACEHIBNBAnQgAmoqAgwhBCABIBhBAnQiE0EMcmoiFCoCACEGIAEgE0EEcmoiGSoCACEJIAEgE0EccmoiGioCACEKIAEgE0EUcmoiFSoCACEFIAEgE2oiFiAWKgIAIgwgASATQQhyaiIWKgIAIg2SIgsgASATQRByaiIcKgIAIg8gASATQRhyaiIdKgIAIhCSIg6SOAIAIBkgCSAGkiIRIAUgCpIiEpI4AgAgHCAHIAsgDpMiC5QgBCARIBKTIg6UkzgCACAVIAcgDpQgBCALlJI4AgAgFiADIAwgDZMiDCAFIAqTIgqTIgWUIAggCSAGkyIGIA8gEJMiCZIiDZSTOAIAIBQgAyANlCAIIAWUkjgCACAdIAMgCCAEIASSIgWUkyINIAwgCpIiCpQgBiAJkyIGIAUgA5QgCJMiA5STOAIAIBogDSAGlCADIAqUkjgCACACIBdBCHJqKgIAIQMgAiAXQQxyaioCACEIIAEgE0EscmoiFyoCACEGIAEgE0EkcmoiFCoCACEJIAEgE0E8cmoiGSoCACEKIAEgE0E0cmoiGioCACEFIAEgE0EgcmoiFSAVKgIAIgwgASATQShyaiIVKgIAIg2SIgsgASATQTByaiIWKgIAIg8gASATQThyaiITKgIAIhCSIg6SOAIAIBQgCSAGkiIRIAUgCpIiEpI4AgAgFiAEjCALIA6TIguUIAcgESASkyIOlJM4AgAgGiAHIAuUIAQgDpSTOAIAIBUgAyAMIA2TIgQgBSAKkyIKkyIFlCAIIAkgBpMiBiAPIBCTIgmSIgyUkzgCACAXIAMgDJQgCCAFlJI4AgAgEyADIAggByAHkiIHlJMiBSAEIAqSIgSUIAYgCZMiBiAHIAOUIAiTIgeUkzgCACAZIAUgBpQgByAElJI4AgAgGyETIBhBEGoiGCAASA0ACwsLGwBBlNcAKAIAIgAEQEGY1wAgADYCACAAECELCwsAIAAEQCAAECELCz4AAkBB2NsALQAAQQFxDQBB2NsAECNFDQBB0NkAECZBiAIQGhpB2NsAECILIABBDGxB2dkAaiABQQBHOgAACz4AAkBB5N0ALQAAQQFxDQBB5N0AECNFDQBB3NsAECZBiAIQGhpB5N0AECILIABBDGxB5dsAaiABQQBHOgAACwsAIAEgAiAAEQgACxAAQcDZAEGgywAoAgA2AgALCwBBwNkAQQA2AgALBwAgABEHAAujZQMkfwl9AnwjAEEQayIZJAAgAAJ/IAIoAgAgAiACLQALIgBBGHRBGHVBAEgiBxshHSACKAIEIAAgBxshHiMAQRBrIiEkACABQQJ0QbDZAGooAgAhBCMAQRBrIh8kAAJAIAQtAExFBEBBwNkAKAIAIgBFDQFByxpBPyAAECgMAQsgBC0AtAQEQEHA2QAoAgAiAEUNAUHoGUEhIAAQKAwBCyAEQbgHaiElIAQqAgAgBCoCCJUiLUMAAHBClCEuQwAAgD8gLZUhLyAEKAKQASEAA0BBASEDIB4CfyAELQBORQRAIAQoAhQgAGwMAQsgJSAvIAAgBCgCwAFBABAwQQRqIAQoAhRsCyIAIAAgHksbIhpFDQECQCAEKAIcIgBBAWtBBE8EQCAAQQVHDQEgBCgCwAEgHSAaEBoaDAELIAQoAsgBIB0gGhAaGgsgGiAEKAIUIgBuIhAgAGwgGkcEQEHA2QAoAgAiAgRAIB8gADYCBCAfIBo2AgAgAkHeIiAfEBwLIAQgBCgCDDYCkAEMAgsCQAJAAkACQAJAIAQoAhxBAWsOBAABAgMECyAQQQBMDQMgBCgCyAEhAiAEKALAASEFQQAhACAQQQFHBEAgEEF+cSEIQQAhBwNAIAUgAEECdGogACACai0AAEGAAWuyQwAAADyUOAIAIAUgAEEBciIMQQJ0aiACIAxqLQAAQYABa7JDAAAAPJQ4AgAgAEECaiEAIAdBAmoiByAIRw0ACwsgEEEBcUUNAyAFIABBAnRqIAAgAmotAABBgAFrskMAAAA8lDgCAAwDCyAQQQBMDQIgBCgCyAEhAiAEKALAASEIQQAhB0EAIQAgEEEBa0EDTwRAIBBBfHEhDEEAIQUDQCAIIABBAnRqIAAgAmosAACyQwAAADyUOAIAIAggAEEBciIGQQJ0aiACIAZqLAAAskMAAAA8lDgCACAIIABBAnIiBkECdGogAiAGaiwAALJDAAAAPJQ4AgAgCCAAQQNyIgZBAnRqIAIgBmosAACyQwAAADyUOAIAIABBBGohACAFQQRqIgUgDEcNAAsLIBBBA3EiBUUNAgNAIAggAEECdGogACACaiwAALJDAAAAPJQ4AgAgAEEBaiEAIAdBAWoiByAFRw0ACwwCCyAQQQBMDQEgBCgCyAEhAiAEKALAASEFQQAhACAQQQFHBEAgEEF+cSEIQQAhBwNAIAUgAEECdGogAiAAQQF0ai8BAEGAgAJrskMAAAA4lDgCACAFIABBAXIiDEECdGogAiAMQQF0ai8BAEGAgAJrskMAAAA4lDgCACAAQQJqIQAgB0ECaiIHIAhHDQALCyAQQQFxRQ0BIAUgAEECdGogAiAAQQF0ai8BAEGAgAJrskMAAAA4lDgCAAwBCyAQQQBMDQAgBCgCyAEhAiAEKALAASEIQQAhB0EAIQAgEEEBa0EDTwRAIBBBfHEhDEEAIQUDQCAIIABBAnRqIAIgAEEBdGouAQCyQwAAADiUOAIAIAggAEEBciIGQQJ0aiACIAZBAXRqLgEAskMAAAA4lDgCACAIIABBAnIiBkECdGogAiAGQQF0ai4BALJDAAAAOJQ4AgAgCCAAQQNyIgZBAnRqIAIgBkEBdGouAQCyQwAAADiUOAIAIABBBGohACAFQQRqIgUgDEcNAAsLIBBBA3EiBUUNAANAIAggAEECdGogAiAAQQF0ai4BALJDAAAAOJQ4AgAgAEEBaiEAIAdBAWoiByAFRw0ACwsgBCgCDCICIAQoApABayEHAkAgBC0ATkUEQCAQQQBMDQEgBCgCuAEhCCAEKALAASEMQQAhBUEAIQAgEEEBa0EDTwRAIBBBfHEhCkEAIQYDQCAIIAAgB2pBAnRqIAwgAEECdGoqAgA4AgAgCCAAQQFyIgkgB2pBAnRqIAwgCUECdGoqAgA4AgAgCCAAQQJyIgkgB2pBAnRqIAwgCUECdGoqAgA4AgAgCCAAQQNyIgkgB2pBAnRqIAwgCUECdGoqAgA4AgAgAEEEaiEAIAZBBGoiBiAKRw0ACwsgEEEDcSIGRQ0BA0AgCCAAIAdqQQJ0aiAMIABBAnRqKgIAOAIAIABBAWohACAFQQFqIgUgBkcNAAsMAQsgEEGAAUwEQCAEIAI2ApABDAMLAkAgBC0AbA0AIAQoAtgHsiAuIAQqAgiUXkUNACAEQgA3A+gHIARCADcD4AcgBEIANwPYByAEKALIB0EAIAQoAswHQQJ0EBsaIAQoAsAHQQAgBCgCxAdBAnQQGxogBCgC0AdBACAEKALUB0ECdBAbGgsgJSAtIBAgBCgCwAEgBCgCuAEgB0ECdGoQMCAHaiEQIAQoAgwhAgsgAiAQTARAIARBAToArgECQCAELQBEBEBBACEGQQAhCUEAIQ4jAEGAAmsiBSQAIARBAToArQEgBCgCnAEhACAEKAKkASECIAQoAgwiByAEKAKUASAEKAK4ASAHQQJ0EBogACACED1BACECAkAgBCgCDCIAQQBMBEAgBEGgBGohGCAEQZgEaiEbDAELIAQoArABIQcgBCgClAEhCCAAQQFHBEAgAEF+cSEMA0AgByACQQJ0aiAIIAJBA3RqIgMqAgAiJyAnlCADKgIEIicgJ5SSOAIAIAcgAkEBciIDQQJ0aiAIIANBA3RqIgMqAgAiJyAnlCADKgIEIicgJ5SSOAIAIAJBAmohAiAGQQJqIgYgDEcNAAsLIABBAXEEQCAHIAJBAnRqIAggAkEDdGoiAioCACInICeUIAIqAgQiJyAnlJI4AgALQwAAAAAhJwJAIABBBEgNAEEBIQIgAEEBdiIMQQFrIgZBAXEhAyAEKAJ8IQggBCgCsAEhByAMQQJHBEAgBkF+cSEGA0AgByACQQJ0aiIMIAcgACACa0ECdGoqAgAgDCoCAJIiKDgCACAHIAJBAWoiDEECdGoiCiAHIAAgDGtBAnRqKgIAIAoqAgCSIik4AgAgJyAoICcgKGAbICcgAiAIThsiJyApICcgKWAbICcgCCAMTBshJyACQQJqIQIgCUECaiIJIAZHDQALCyADRQ0AIAcgAkECdGoiDCAHIAAgAmtBAnRqKgIAIAwqAgCSIig4AgAgJyAoICcgKGAbICcgAiAIThshJwsgBEGgBGohGCAEQZgEaiEbQQAhAiAAQQBMDQBDAAB/Q0MAAH9DICeVICdDAAAAAFsbISkDQCAEKAKYBCAEKAKgBCAEKAKUBGxqIAJqAn8CfSApIAQoArABIAJBAnRqKgIAlCInvCIAQRd2Qf8BcSIHQZUBTQRAIAdB/QBNBH0gJ0MAAAAAlAUCfSAnICeMIABBAE4bIidDAAAAS5JDAAAAy5IgJ5MiKEMAAAA/XgRAICcgKJJDAACAv5IMAQsgJyAokiInIChDAAAAv19FDQAaICdDAACAP5ILIicgJ4wgAEEAThsLIScLQwAAAAAgJ0MAAAAAXw0AGkMAAH9DICdDAAB/Q14NABogJwsiJ0MAAIBPXSAnQwAAAABgcQRAICepDAELQQALOgAAIAJBAWoiAiAEKAIMSA0ACwsgBCAEKAKUBEEBaiIAQQAgACAEKAKcBEgbNgKUBCAFQTBqIQwDQAJAAkAgBCAOQQxsaiIILQD1AUUNACAILgHwASIiIAQoAgxKDQAgBCgClAQgCCwA9AEiBwJ/QQIgBCgCSCIWQQRIDQAaQQQgFkEPSQ0AGiAWQQVuQQF0CyIcIBZqIhEgCCwA8wEiAmpBAWsgAm1sIiAgCCwA8gFsayISQQBIBEAgBCgCnAQgEmohEgtBACEAIAQoAqQEQQAgBCgCqAQQGxoCQCAgQQBMBEBBACEXQQAhDQwBCyAHQQFGQQR0ISMgAkEFdCEmQQAhDUEAIRcDQCAAIAgsAPQBb0UEQCAEKAKsBEEAICYQGxoLIABBAWohByAILQDyASIKQRh0QRh1IgNBAEoEQCAILQDzASECQQAhBgNAIAJBGHRBGHVBAEoEQCAGIBJqIAAgCmxqIgJBACAEKAKcBCIDIAIgA0gbayEkQQAhCgNAIBsoAgAgGCgCACAkbGoiDyAKQQV0IgMgImoiE2oiAi0AACIJIAItAAEiC01BAiAJIAsgCSALSxsiCSACLQACIgtLIhQbQQMgCSALIBQbIgkgAi0AAyILSyIUG0EEIAkgCyAUGyIJIAItAAQiC0siFBtBBSAJIAsgFBsiCSACLQAFIgtLIhQbQQYgCSALIBQbIgkgAi0ABiILSyIUG0EHIAItAAciFSAJIAsgFBsiCUH/AXFJIgsbQQggAi0ACCIUIAkgFSALGyIJQf8BcUkiCxtBCSACLQAJIhUgCSAUIAsbIglB/wFxSSILG0EKIAItAAoiFCAJIBUgCxsiCUH/AXFJIgsbQQsgAi0ACyIVIAkgFCALGyIJQf8BcUkiCxtBDCACLQAMIhQgCSAVIAsbIglB/wFxSSILG0ENIAItAA0iFSAJIBQgCxsiCUH/AXFJIgsbQQ4gAi0ADiIUIAkgFSALGyIJQf8BcUkiCxtBDyACLQAPIAkgFCALG0H/AXFJGyIUIQIgCCwA9AEiCUEBRgRAIA8gEyAjamoiAi0AACILIAItAAEiD01BAiALIA8gCyAPSxsiCyACLQACIg9LIhMbQQMgCyAPIBMbIgsgAi0AAyIPSyITG0EEIAsgDyATGyILIAItAAQiD0siExtBBSALIA8gExsiCyACLQAFIg9LIhMbQQYgCyAPIBMbIgsgAi0ABiIPSyITG0EHIAItAAciFSALIA8gExsiC0H/AXFJIg8bQQggAi0ACCITIAsgFSAPGyILQf8BcUkiDxtBCSACLQAJIhUgCyATIA8bIgtB/wFxSSIPG0EKIAItAAoiEyALIBUgDxsiC0H/AXFJIg8bQQsgAi0ACyIVIAsgEyAPGyILQf8BcUkiDxtBDCACLQAMIhMgCyAVIA8bIgtB/wFxSSIPG0ENIAItAA0iFSALIBMgDxsiC0H/AXFJIg8bQQ4gAi0ADiITIAsgFSAPGyILQf8BcUkiDxtBDyACLQAPIAsgEyAPG0H/AXFJGyECCyAHIAAgCW8EfyAJBSAEKAKsBCADIBRqaiIJIAktAABBAWo6AAAgCCwA9AELb0UEQCAEKAKsBCADQRByIAJqaiICIAItAABBAWo6AAALIApBAWoiCiAILADzASICSA0ACyAILQDyASEDCyAGQQFqIgYgA0EYdEEYdSIKSA0ACwsCQCAILQD0ASICQRh0QRh1IgNBAUoEQCAAIAJwRQ0BCwJAAkAgCCwA8wEiAkEATARAQQAhCwwBC0EAIQtBACEGQQAhCSAAIANtIAJB/wFxbCARTg0AA0AgCUEFdCIPQRByISRBACECA0AgCCwA8gFBAm1BGHRBGHUiCiAEKAKsBCIDIAIgD2pqLQAASARAIAQoAqQEIAgsAPMBIAAgCCwA9AFtbCAJakEBdGogAjoAACAILADyAUECbUEYdEEYdSEKIAQoAqwEIQMgBkEBaiEGCyADIAIgJGpqLQAAIApKBEAgBCgCpAQgCCwA8wEgACAILAD0AW1sIAlqQQF0aiACOgABIAZBAWohBgsgAkEBaiICQRBHDQALIAtBAmohCyAJQQFqIgkgCCwA8wEiAk4NAiARIAAgCCwA9AFtIAJsIAlqSg0ACwwBC0EAIQYLIAsgF2ohFyAGIA1qIQ0LIAciACAgRw0ACwsgDbcgF7dEAAAAAAAA6D+iYw0AAn9BAiAEKAJIIgBBBEgNABpBBCAAQQ9JDQAaIABBBW5BAXQLIQIgBCgCZCEDIAVBADYC/AEgBUEAOgD0ASAFQQA2AvABIAVBADoA6AEgBUEANgLkASAFQQA6ANwBIAVBADYC2AEgBUEAOgDQASAFQQA2AswBIAVBADoAxAEgBUEANgLAASAFQQA6ALgBIAVBADYCtAEgBUEAOgCsASAFQQA2AqgBIAVBADoAoAEgBUEANgKcASAFQQA6AJQBIAVBADYCkAEgBUEAOgCIASAFQQA2AoQBIAVBADoAfCAFQQA2AnggBUEAOgBwIAVBADYCbCAFQQA6AGQgBUEANgJgIAVBADoAWCAFQQA2AlQgBUEAOgBMIAVBADYCSCAFQQA6AEAgBUEANgI8IAVBADoANCAFIAI6ACEgBSAAOgAgIAVBADsBLCAFIAMEf0EABSACQf4BcSIHIABB/wFxQQNsaiAHQRxsakEBahAnIQNBAQs6ACwgBSADNgIkIAVBADsBOCAFIAM2AiggBSAMNgI8IAVBADsBNCAFIAw2AkggBUGAAjsBQCAFQQM6AFkgBSAMNgJUIAVBgAQ7AUwgBSAAIAJqIgc6ADYgBSAHOgBCIAUgAkEBdCIAOgBOIAUgADoAWiAFIAdB/wFxIgY7AUQgBSAGQQF0IgM7AVAgBSADIABB/gFxIgJqIgM7AVwgBUGACDsBZCAFIAw2AmAgBUEAOgBYIAUgADoAZiAFIAw2AmwgBUGACjsBcCAFIAc6AHIgBSAMNgJ4IAVBgAw7AXwgBSAAOgB+IAUgDDYChAEgBUGADjsBiAEgBSAAOgCKASAFIAw2ApABIAVBCDoAlQEgBSACIANqIgc7AWggBSACIAdqIgc7AXQgBSAGIAdqIgc7AYABIAUgAiAHaiIHOwGMASAFIAIgB2oiBzsBmAEgBUEAOgCUASAFIAA6AJYBIAUgDDYCnAEgBSAAOgCiASAFQYASOwGgASAFIAw2AqgBIAUgADoArgEgBUGAFDsBrAEgBSAMNgK0ASAFIAA6ALoBIAVBgBY7AbgBIAVBDDoAxQEgBSAMNgLAASAFIAA6AMYBIAUgAiAHaiIHOwGkASAFIAIgB2oiBzsBsAEgBSACIAdqIgc7AbwBIAUgAiAHaiIHOwHIASAFQQ06ANEBIAUgDDYCzAEgBUEAOgDEASAFIAIgB2oiBzsB1AEgBSAAOgDSASAFQQ46AN0BIAUgDDYC2AEgBUEAOgDQASAFIAIgB2oiBzsB4AEgBSAAOgDeASAFQQ86AOkBIAUgDDYC5AEgBUEAOgDcASAFIAIgB2oiBzsB7AEgBSAAOgDqASAFIAIgB2o7AfgBIAVBEDoA9QEgBSAMNgLwASAFQQA6AOgBIAUgADoA9gEgBSAMNgL8ASAFQQA6APQBAkAgEUEATA0AQQAhAiAcQQFrQQAgFmtHBEAgEUF+cSEAQQAhAwNAIAQoAlQgAmogBCgCpAQgAkEBdGoiBy0AAUEEdCAHLQAAajoAACACQQFyIgcgBCgCVGogBCgCpAQgB0EBdGoiBy0AAUEEdCAHLQAAajoAACACQQJqIQIgA0ECaiIDIABHDQALCyARQQFxRQ0AIAQoAlQgAmogBCgCpAQgAkEBdGoiAC0AAUEEdCAALQAAajoAAAsgBUEgaiAEKAJUIgAgACAFLQAgaiAEKALUARA7IgBFBEACQCAELQBQRQ0AQQAhAiAEKAJIQQBMDQADQCAEKALUASACaiIHIAJBP3FBsChqLQAAIActAABzOgAAIAJBAWoiAiAEKAJISA0ACwsCQEHA2QAoAgAiAkUNACAEKAJIIQcgCCgC7AEhBiAFIA42AhggBSAGNgIUIAUgBzYCECACQbEjIAVBEGoQHEHA2QAoAgAiAkUNACAFIAQoAtQBNgIAIAJB4yQgBRAcCyAEQQE6AKwBIAQgBCgCSDYC0AEgBCAIKAL0ATYC5AEgBCAIKQLsATcC3AEgBCAONgLoAQsCQCAFLQAsRQ0AIAUoAiQiAkUNACACECELIABFDQEgDkEBaiIOQRZHDQIMAQsgDkEBaiIOQRZHDQELCyAFQYACaiQADAELQQAhAiMAQaACayIDJAAgBCgCgAQgBCgCiAQiACAEKAL0A2xBAnRqIAQoArgBIAAgBCgCvAEiByAAIAdIG0ECdBAaGiAEQQAgBCgC9AMiAEEBaiAAQQJKGyIANgL0AwJAIAAEQCAELQBsRQ0BCyAEQQE6AK0BIAQoAvgDQQAgBCgC/ANBAnQQGxoCQAJAAkACQCAEKAKEBCIOQQBMBEAgBCgCDCEHDAELIAQoAgwiB0EATA0BIAQoAogEIREgBCgCgAQhFyAHQXxxIQ0gB0EDcSEJIAQoAvgDIQUgB0EBa0EDSSEWA0AgFyACIBFsQQJ0aiEIQQAhAEEAIQZBACEKIBZFBEADQCAFIAZBAnQiDGoiCyAIIAxqKgIAIAsqAgCSOAIAIAUgDEEEciILaiISIAggC2oqAgAgEioCAJI4AgAgBSAMQQhyIgtqIhIgCCALaioCACASKgIAkjgCACAFIAxBDHIiDGoiCyAIIAxqKgIAIAsqAgCSOAIAIAZBBGohBiAKQQRqIgogDUcNAAsLIAkEQANAIAUgBkECdCIMaiIKIAggDGoqAgAgCioCAJI4AgAgBkEBaiEGIABBAWoiACAJRw0ACwsgAkEBaiICIA5HDQALC0EAIQYgB0EASg0BCyAEKAL4AyEKDAELIAQoAvgDIQogB0EBa0EDTwRAIAdBfHEhAkEAIQ4DQCAKIAZBAnQiAGoiBSAFKgIAQwAAgD6UOAIAIAogAEEEcmoiBSAFKgIAQwAAgD6UOAIAIAogAEEIcmoiBSAFKgIAQwAAgD6UOAIAIAogAEEMcmoiACAAKgIAQwAAgD6UOAIAIAZBBGohBiAOQQRqIg4gAkcNAAsLIAdBA3EiAkUNAEEAIQADQCAKIAZBAnRqIgUgBSoCAEMAAIA+lDgCACAGQQFqIQYgAEEBaiIAIAJHDQALCyAEKAKkASEAIAQoApwBIQIgByAEKAKUASAKIAdBAnQQGiACIAAQPSAEKAIMIgJBAEwNACAEKAKwASEAIAQoApQBIQdBACEGIAJBAUcEQCACQX5xIQVBACEOA0AgACAGQQJ0aiAHIAZBA3RqIggqAgAiJyAnlCAIKgIEIicgJ5SSOAIAIAAgBkEBciIIQQJ0aiAHIAhBA3RqIggqAgAiJyAnlCAIKgIEIicgJ5SSOAIAIAZBAmohBiAOQQJqIg4gBUcNAAsLIAJBAXEEQCAAIAZBAnRqIAcgBkEDdGoiACoCACInICeUIAAqAgQiJyAnlJI4AgALIAJBBEgNAEEBIQYgAkEBdiIAQQFrIgVBAXEhCCAEKAKwASEHIABBAkcEQCAFQX5xIQVBACEAA0AgByAGQQJ0aiIMIAcgAiAGa0ECdGoqAgAgDCoCAJI4AgAgByAGQQFqIgxBAnRqIgogByACIAxrQQJ0aioCACAKKgIAkjgCACAGQQJqIQYgAEECaiIAIAVHDQALCyAIRQ0AIAcgBkECdGoiACAHIAIgBmtBAnRqKgIAIAAqAgCSOAIACwJAIAQoAoQBIgBBAEwNACAEKAKMBCAEKAIMIgIgBCgCjAEgAGtsQQJ0aiAEKAK4ASACQQJ0EBoaIAQgBCgChAEiAEEBazYChAEgAEEBSg0AIARBAToAbQsgBC0AbQRAQcDZACgCACIABEBB9SFBGyAAECgLIAQoAgxBEG0hGyADQdAAaiEJQQAhFwJAAkADQAJAIAQgF0EMbGoiES0A9QFFDQAgES0A9AFBAkYNACAEKAJ0IBEuAfABRw0AIAQoArABQQAgBCgCtAFBAnQQGxogBCAEKAI4IgBBBHQiAjYCiAEgBCACNgKAASAAQQBMDQADQEEAIQUgAiIMQQFrIgIhDkEAIQdBACEWAkACQAJAIAwgBCgCeEEEdEoNAANAIAQoAlggBUEBaiIIIBEsAPMBbEwNASAEKAKUASAEKAKMBCAOIBtsQQJ0aiAEKAIMQQJ0EBoaIAQoAgwhCgJAIBEsAPIBIiBBAkgNACAKQQBMDQAgCkF+cSEPQQEhDSAKQQFxISIgBCgClAEhCyAEKAKMBCESA0AgDUEEdCAOaiAbbCEYQQAhBkEAIQAgCkEBRwRAA0AgCyAGQQJ0aiIcIBIgBiAYakECdGoqAgAgHCoCAJI4AgAgCyAGQQFyIhxBAnRqIiMgEiAYIBxqQQJ0aioCACAjKgIAkjgCACAGQQJqIQYgAEECaiIAIA9HDQALCyAiBEAgCyAGQQJ0aiIAIBIgBiAYakECdGoqAgAgACoCAJI4AgALIA1BAWoiDSAgRw0ACwsgCiAEKAKUASAEKAKcASAEKAKkARA9AkAgBCgCDCIKQQBMDQAgBCgCsAEhACAEKAKUASENQQAhBiAKQQFHBEAgCkF+cSELQQAhDgNAIAAgBkECdGogDSAGQQN0aiISKgIAIicgJ5QgEioCBCInICeUkjgCACAAIAZBAXIiEkECdGogDSASQQN0aiISKgIAIicgJ5QgEioCBCInICeUkjgCACAGQQJqIQYgDkECaiIOIAtHDQALCyAKQQFxBEAgACAGQQJ0aiANIAZBA3RqIgAqAgAiJyAnlCAAKgIEIicgJ5SSOAIACyAKQQRIDQBBASEGIApBAXYiAEEBayINQQFxIQsgBCgCsAEhDiAAQQJHBEAgDUF+cSENQQAhAANAIA4gBkECdGoiEiAOIAogBmtBAnRqKgIAIBIqAgCSOAIAIA4gBkEBaiISQQJ0aiIYIA4gCiASa0ECdGoqAgAgGCoCAJI4AgAgBkECaiEGIABBAmoiACANRw0ACwsgC0UNACAOIAZBAnRqIgAgDiAKIAZrQQJ0aioCACAAKgIAkjgCAAtBACEKQQAhACARLADzASIOQQBKBEADQAJ/IAQqAii7IAQqAiQgES4B8AGylLuiEDggCkEEdLegIjCZRAAAAAAAAOBBYwRAIDCqDAELQYCAgIB4CyEGQQ9BDkENQQxBC0EKQQlBCEEHQQZBBUEEQQNBAiAEKAKwASAGQQJ0aiIGKgIAuyIwRAAAAAAAAAAAIDBEAAAAAAAAAABkGyIwIAYqAgS7IjFjIg0gMSAwIA0bIjAgBioCCLsiMWMiDRsgMSAwIA0bIjAgBioCDLsiMWMiDRsgMSAwIA0bIjAgBioCELsiMWMiDRsgMSAwIA0bIjAgBioCFLsiMWMiDRsgMSAwIA0bIjAgBioCGLsiMWMiDRsgMSAwIA0bIjAgBioCHLsiMWMiDRsgMSAwIA0bIjAgBioCILsiMWMiDRsgMSAwIA0bIjAgBioCJLsiMWMiDRsgMSAwIA0bIjAgBioCKLsiMWMiDRsgMSAwIA0bIjAgBioCLLsiMWMiDRsgMSAwIA0bIjAgBioCMLsiMWMiDRsgMSAwIA0bIjAgBioCNLsiMWMiDRsgMSAwIA0bIjAgBioCOLsiMWMiDRsgBioCPLsgMSAwIA0bZBshBiAKQQFxBH8gBCgCVCAFIA5sIApBAXZqaiAGQQR0IABqOgAAQQAFIAYLIQAgCkEBaiIKIBEsAPMBIg5BAXRIDQALCyAWIAQoAjwiACAFIA5sTnJFBEAgBCgCXCEGQQAhFiADQQA2ApwCIANBADoAlAIgA0EANgKQAiADQQA6AIgCIANBADYChAIgA0EAOgD8ASADQQA2AvgBIANBADoA8AEgA0EANgLsASADQQA6AOQBIANBADYC4AEgA0EAOgDYASADQQA2AtQBIANBADoAzAEgA0EANgLIASADQQA6AMABIANBADYCvAEgA0EAOgC0ASADQQA2ArABIANBADoAqAEgA0EANgKkASADQQA6AJwBIANBADYCmAEgA0EAOgCQASADQQA2AowBIANBADoAhAEgA0EANgKAASADQQA6AHggA0EANgJ0IANBADoAbCADQQA2AmggA0EAOgBgIANBADYCXCADQQA6AFQgAyAAQQFrIgo6AEEgA0EBOgBAIANBADsBTEEAIQ4gBkUEQEEBIQ4gCkH/AXEiBiAGQRxsakEEahAnIQYLIAMgDjoATCADIAY2AkQgA0EAOwFYIAMgBjYCSCADIAA6AFYgAyAJNgJcIANBADsBVCADIAA6AGIgAyAJNgJoIANBgAI7AWAgA0EDOgB5IAMgCTYCdCADQYAEOwFsIAMgCkEBdCIGOgBuIAMgBjoAeiADIABB/wFxIg47AWQgAyAOQQF0Ig07AXAgAyANIAZB/gFxIgpqIg07AXwgA0GACDsBhAEgAyAJNgKAASADQQA6AHggAyAGOgCGASADIAk2AowBIANBgAo7AZABIAMgADoAkgEgAyAJNgKYASADQYAMOwGcASADIAY6AJ4BIAMgCTYCpAEgA0GADjsBqAEgAyAGOgCqASADIAk2ArABIANBCDoAtQEgAyAKIA1qIgA7AYgBIAMgACAKaiIAOwGUASADIAAgDmoiADsBoAEgAyAAIApqIgA7AawBIAMgACAKaiIAOwG4ASADQQA6ALQBIAMgBjoAtgEgAyAJNgK8ASADIAY6AMIBIANBgBI7AcABIAMgCTYCyAEgAyAGOgDOASADQYAUOwHMASADIAk2AtQBIAMgBjoA2gEgA0GAFjsB2AEgA0EMOgDlASADIAk2AuABIAMgBjoA5gEgAyAAIApqIgA7AcQBIAMgACAKaiIAOwHQASADIAAgCmoiADsB3AEgAyAAIApqIgA7AegBIANBDToA8QEgAyAJNgLsASADQQA6AOQBIAMgACAKaiIAOwH0ASADIAY6APIBIANBDjoA/QEgAyAJNgL4ASADQQA6APABIAMgACAKaiIAOwGAAiADIAY6AP4BIANBDzoAiQIgAyAJNgKEAiADQQA6APwBIAMgACAKaiIAOwGMAiADIAY6AIoCIAMgACAKajsBmAIgA0EQOgCVAiADIAk2ApACIANBADoAiAIgAyAGOgCWAiADIAk2ApwCIANBADoAlAJBFyEGAkAgA0FAayAEKAJUIgAgACADLQBAaiAEKALUARA7DQAgBCgC1AEtAAAiAEEBa0H/AXFBiwFLDQAgBCgCPCEHQRdBACAEKAJ4IgYgESwA8gEgESwA8wEiCgJ/QQIgAEEESQ0AGkEEIABBD0kNABogAEEFbkEBdAsgACAHampqQQFrIAptbCIHSCAGIAcgBCgCOEEBdGpKciIHGyEGIAdFIRYgACEHCwJAIAMtAExFDQAgAygCRCIARQ0AIAAQIQsgBg0CIAQoAjwhAAsCf0ECIAdBBEgNABpBBCAHQQ9JDQAaIAdBBW5BAXQLIQYCQCAWBEAgACAHaiAGakEBaiAFIBEsAPMBbEgNBCAIQYAIRg0EDAELQQAhFiAIQYAIRg0ECyAIIgUgESwA8gFsQQR0IAJqIg4gBCgCeEEEdEgNAAsLIBZFDQELIAQoAmQhCiADQQA2ApwCIANBADoAlAIgA0EANgKQAiADQQA6AIgCIANBADYChAIgA0EAOgD8ASADQQA2AvgBIANBADoA8AEgA0EANgLsASADQQA6AOQBIANBADYC4AEgA0EAOgDYASADQQA2AtQBIANBADoAzAEgA0EANgLIASADQQA6AMABIANBADYCvAEgA0EAOgC0ASADQQA2ArABIANBADoAqAEgA0EANgKkASADQQA6AJwBIANBADYCmAEgA0EAOgCQASADQQA2AowBIANBADoAhAEgA0EANgKAASADQQA6AHggA0EANgJ0IANBADoAbCADQQA2AmggA0EAOgBgIANBADYCXCADQQA6AFQgAwJ/QQIgB0EESA0AGkEEIAdBD0kNABogB0EFbkEBdAsiADoAQSADIAc6AEAgA0EAOwFMIAMgCgR/QQAFIABB/gFxIgUgB0H/AXFBA2xqIAVBHGxqQQFqECchCkEBCzoATCADIAo2AkQgA0EAOwFYIAMgCjYCSCADIAk2AlwgA0EAOwFUIAMgCTYCaCADQYACOwFgIANBAzoAeSADIAk2AnQgA0GABDsBbCADIAAgB2oiCDoAViADIAg6AGIgAyAAQQF0IgA6AG4gAyAAOgB6IAMgCEH/AXEiBjsBZCADIAZBAXQiCjsBcCADIAogAEH+AXEiBWoiCjsBfCADQYAIOwGEASADIAk2AoABIANBADoAeCADIAA6AIYBIAMgCTYCjAEgA0GACjsBkAEgAyAIOgCSASADIAk2ApgBIANBgAw7AZwBIAMgADoAngEgAyAJNgKkASADQYAOOwGoASADIAA6AKoBIAMgCTYCsAEgA0EIOgC1ASADIAUgCmoiCDsBiAEgAyAFIAhqIgg7AZQBIAMgBiAIaiIIOwGgASADIAUgCGoiCDsBrAEgAyAFIAhqIgg7AbgBIANBADoAtAEgAyAAOgC2ASADIAk2ArwBIAMgADoAwgEgA0GAEjsBwAEgAyAJNgLIASADIAA6AM4BIANBgBQ7AcwBIAMgCTYC1AEgAyAAOgDaASADQYAWOwHYASADQQw6AOUBIAMgCTYC4AEgAyAAOgDmASADIAUgCGoiCDsBxAEgAyAFIAhqIgg7AdABIAMgBSAIaiIIOwHcASADIAUgCGoiCDsB6AEgA0ENOgDxASADIAk2AuwBIANBADoA5AEgAyAFIAhqIgg7AfQBIAMgADoA8gEgA0EOOgD9ASADIAk2AvgBIANBADoA8AEgAyAFIAhqIgg7AYACIAMgADoA/gEgA0EPOgCJAiADIAk2AoQCIANBADoA/AEgAyAFIAhqIgg7AYwCIAMgADoAigIgAyAFIAhqOwGYAiADQRA6AJUCIAMgCTYCkAIgA0EAOgCIAiADIAA6AJYCIAMgCTYCnAIgA0EAOgCUAiADQUBrIAQoAlQgBCgCPGoiACAAIAMtAEBqIAQoAtQBEDtFIAdBAEpxIgAEQAJAIAQtAFBFDQBBACEGIAdBAUcEQCAHQX5xIQVBACEKA0AgBCgC1AEgBmoiCCAGQT5xQbAoai0AACAILQAAczoAACAGQQFyIgggBCgC1AFqIg4gCEE/cUGwKGotAAAgDi0AAHM6AAAgBkECaiEGIApBAmoiCiAFRw0ACwsgB0EBcUUNACAEKALUASAGaiIFIAZBP3FBsChqLQAAIAUtAABzOgAACwJAQcDZACgCACIFRQ0AIBEoAuwBIQggAyAXNgI4IAMgCDYCNCADIAc2AjAgBUGxIyADQTBqEBxBwNkAKAIAIgVFDQAgAyAEKALUATYCICAFQeMkIANBIGoQHAsgBCAHNgLQASAEQQE6AKwBIAQgESgC9AE2AuQBIAQgESkC7AE3AtwBIAQgFzYC6AELAkAgAy0ATEUNACADKAJEIgdFDQAgBxAhCyAADQQLIAQgBCgCgAFBAWs2AoABIAxBAUoNAAsLIBdBAWoiF0EWRw0ACyAEQQA2AowBQcDZACgCACIABEAgAyAEKALUAS0AADYCECAAQaUkIANBEGoQHAsgBEF/NgKMASAEQX82AtABDAELIARBADYCjAELIARBADsBbCAEKAKwAUEAIAQoArQBQQJ0EBsaIARBADYCgAEgBEEANgKIAQtBACEFAkAgBC0AbEUEQANAAkAgBCAFQQxsaiIALQD1AUUNACAEKAI0IgJBAEoEQCAALgHwAbIhKSAEKAIsIQggBCoCQCEqIAQoArABIQcgBCoCMCErIAQqAiQhLCAEKgIouyEwQQAhBiACIQADQCAqIAcgCAJ/IDAgLCAplCArIAaylJK7ohA4IjGZRAAAAAAAAOBBYwRAIDGqDAELQYCAgIB4CyIMakECdGoqAgCUIScgByAMQQJ0aioCACEoAkACQCAGQQFxRQRAICcgKGANAQwCCyAnIChfRQ0BCyAAQQFrIQALIAZBAWoiBiACRw0ACyAAIAJHDQELIAQgBEHsAWoiByAFQQxsai4BBDYCdCAEIAQoAnAiAEEBajYCcCAAQQBIDQNBACEAQcDZACgCACICBEBB2yFBGSACECgLIARBAToAbCAEKALUAUEAIAQoAtgBEBsaIAQoAjghBUEAIQYDQAJAIAQgBkEMbGoiAi0A9QFFDQAgAiwA9AEiCEEBSg0AIAIsAPIBIAhsIgIgACAAIAJIGyEACyAGQQFqIgZBFkcNAAsgBxA8IQIgBEEANgJwIARBxAEgAm1BAWogAGwgBUEBdGoiADYCjAEgBCAANgJ4IAQgADYChAEMAwsgBUEBaiIFQRZHDQALIARBADYCcAwBC0EBIQICQAJAA0ACQCAEIAVBDGxqIgAtAPUBBEAgBCgCNCIHQQBMDQEgAC4B8AGyISkgBCgCLCEMIAQqAkAhKiAEKAKwASEIIAQqAjAhKyAEKgIkISwgBCoCKLshMEEAIQYgByEAA0AgKiAIIAwCfyAwICwgKZQgKyAGspSSu6IQOCIxmUQAAAAAAADgQWMEQCAxqgwBC0GAgICAeAsiCmpBAnRqKgIAlCEnIAggCkECdGoqAgAhKAJAAkAgBkEBcUUEQCAnIChfDQEMAgsgJyAoYEUNAQsgAEEBayEACyAGQQFqIgYgB0cNAAsgACAHRg0BCyAFQRVJIQIgBUEBaiIFQRZHDQEMAgsLIAINAQsgBEEANgJwDAELIAQgBCgCcCIAQQFqNgJwIABBAEgNACAEKAKMAUECSA0AIAQgBCgCeCAEKAKEASIAa0EBaiICNgJ4QcDZACgCACIHBEAgAyACNgIEIAMgADYCACAHQaAeIAMQHAsgBEEBNgKEASAEQQA2AnALIANBoAJqJAALAkAgECAEKAIMIghrIgxBAEwNACAEKAK4ASECQQAhB0EAIQAgECAIQX9zakEDTwRAIAxBfHEhBkEAIQUDQCACIABBAnRqIAIgACAIakECdGoqAgA4AgAgAiAAQQFyIgNBAnRqIAIgAyAIakECdGoqAgA4AgAgAiAAQQJyIgNBAnRqIAIgAyAIakECdGoqAgA4AgAgAiAAQQNyIgNBAnRqIAIgAyAIakECdGoqAgA4AgAgAEEEaiEAIAVBBGoiBSAGRw0ACwsgDEEDcSIFRQ0AA0AgAiAAQQJ0aiACIAAgCGpBAnRqKgIAOAIAIABBAWohACAHQQFqIgcgBUcNAAsLIB4gGmshHiAaIB1qIR0gBCAIIAxrIgA2ApABDAELCyAEIAIgEGs2ApABCyAfQRBqJAACQCADRQRAQX8hAEHA2QAoAgAiAkUNASAhIAE2AgAgAkGeHSAhEBwMAQtBACEAQczZAC0AAEUEQEHE2QBCADcCAEHM2QBBAToAAAsgBCgC0AEiAUUNACAEQQA2AtABQX8hACABQX9GDQAgBCgC1AEhAEHI2QAgATYCAEHE2QAgADYCACABQQBKBEBBsNcAIAAgARAaGgsgASEACyAhQRBqJAAgAEEASgRAIBlBsNcANgIMIBkgADYCCEG4JiAZQQhqEAYMAQsgGUGw1wA2AgwgGUEANgIIQbgmIBlBCGoQBgs2AgAgGUEQaiQAC70BAQR/IwBBIGsiAyQAIAIoAgAiBEFwSQRAAkACQCAEQQtPBEAgBEEQakFwcSIGEB0hBSADIAZBgICAgHhyNgIQIAMgBTYCCCADIAQ2AgwMAQsgAyAEOgATIANBCGohBSAERQ0BCyAFIAJBBGogBBAaGgsgBCAFakEAOgAAIANBGGogASADQQhqIAARAAAgAygCGBAKIAMoAhgiABAJIAMsABNBAEgEQCADKAIIECELIANBIGokACAADwsQNAALoQQBB38jAEEQayIIJAAgASACKAIAIAIgAi0ACyIFQRh0QRh1QQBIIgYbIAIoAgQgBSAGGyADIARBAEEBEFQhBQJAAkBBoNcALQAAQQFxDQBBoNcAECNFDQBBlNcAQgA3AgBBnNcAQQA2AgAgBQRAIAVBAEgNAkGU1wAgBRAdIgY2AgBBnNcAIAUgBmoiCTYCACAGQQAgBRAbGkGY1wAgCTYCAAtBoNcAECILAkACQCAFQZjXACgCACIHQZTXACgCACIGayIJSwRAIAUgCWsiC0Gc1wAoAgAiCiAHa00EQEGY1wAgCwR/IAdBACALEBsgC2oFIAcLNgIADAMLIAVBAEgNASAFIAogBmsiB0EBdCIKIAUgCksbQf////8HIAdB/////wNJGyIKEB0iByAJakEAIAsQGxogCUEASgRAIAcgBiAJEBoaC0Gc1wAgByAKajYCAEGY1wAgBSAHajYCAEGU1wAgBzYCACAGRQ0CIAYQIQwCCyAFIAlPDQFBmNcAIAUgBmo2AgAMAQsQNAALIAggASACKAIAIAIgAi0ACyIBQRh0QRh1QQBIIgYbIAIoAgQgASAGGyADIARBlNcAKAIAQQAQVCICNgIEIAggBTYCACMAQRBrIgEkACABIAg2AgxB8NUAQYoeIAgQQiABQRBqJAAgCEGU1wAoAgA2AgwgCCACNgIIIABBuCYgCEEIahAGNgIAIAhBEGokAA8LEDQACyIBAX4gASACrSADrUIghoQgBCAAEQsAIgVCIIinEBMgBacLGgAgACABKAIIIAUQIARAIAEgAiADIAQQNgsLNwAgACABKAIIIAUQIARAIAEgAiADIAQQNg8LIAAoAggiACABIAIgAyAEIAUgACgCACgCFBEGAAuTAgEGfyAAIAEoAgggBRAgBEAgASACIAMgBBA2DwsgAS0ANSEHIAAoAgwhBiABQQA6ADUgAS0ANCEIIAFBADoANCAAQRBqIgkgASACIAMgBCAFEDUgByABLQA1IgpyIQcgCCABLQA0IgtyIQgCQCAGQQJIDQAgCSAGQQN0aiEJIABBGGohBgNAIAEtADYNAQJAIAsEQCABKAIYQQFGDQMgAC0ACEECcQ0BDAMLIApFDQAgAC0ACEEBcUUNAgsgAUEAOwE0IAYgASACIAMgBCAFEDUgAS0ANSIKIAdyIQcgAS0ANCILIAhyIQggBkEIaiIGIAlJDQALCyABIAdB/wFxQQBHOgA1IAEgCEH/AXFBAEc6ADQLpwEAIAAgASgCCCAEECAEQAJAIAEoAgQgAkcNACABKAIcQQFGDQAgASADNgIcCw8LAkAgACABKAIAIAQQIEUNAAJAIAIgASgCEEcEQCABKAIUIAJHDQELIANBAUcNASABQQE2AiAPCyABIAI2AhQgASADNgIgIAEgASgCKEEBajYCKAJAIAEoAiRBAUcNACABKAIYQQJHDQAgAUEBOgA2CyABQQQ2AiwLC4gCACAAIAEoAgggBBAgBEACQCABKAIEIAJHDQAgASgCHEEBRg0AIAEgAzYCHAsPCwJAIAAgASgCACAEECAEQAJAIAIgASgCEEcEQCABKAIUIAJHDQELIANBAUcNAiABQQE2AiAPCyABIAM2AiACQCABKAIsQQRGDQAgAUEAOwE0IAAoAggiACABIAIgAkEBIAQgACgCACgCFBEGACABLQA1BEAgAUEDNgIsIAEtADRFDQEMAwsgAUEENgIsCyABIAI2AhQgASABKAIoQQFqNgIoIAEoAiRBAUcNASABKAIYQQJHDQEgAUEBOgA2DwsgACgCCCIAIAEgAiADIAQgACgCACgCGBEEAAsLwQEBBH8jAEEgayIFJAAgAigCACIGQXBJBEACQAJAIAZBC08EQCAGQRBqQXBxIggQHSEHIAUgCEGAgICAeHI2AhAgBSAHNgIIIAUgBjYCDAwBCyAFIAY6ABMgBUEIaiEHIAZFDQELIAcgAkEEaiAGEBoaCyAGIAdqQQA6AAAgBUEYaiABIAVBCGogAyAEIAARBAAgBSgCGBAKIAUoAhgiABAJIAUsABNBAEgEQCAFKAIIECELIAVBIGokACAADwsQNAALLQEBf0EkEB0iAEIANwMAIABBADYCICAAQgA3AxggAEIANwMQIABCADcDCCAACwu8TBsAQYAIC6IgLSsgICAwWDB4AC0wWCswWCAwWC0weCsweCAweABzYW1wbGVGb3JtYXRPdXQAc2FtcGxlUmF0ZU91dABbVV0gRmFzdGVzdABbTVRdIEZhc3Rlc3QAW0RUXSBGYXN0ZXN0AFtVXSBGYXN0AFtNVF0gRmFzdABbRFRdIEZhc3QAdW5zaWduZWQgc2hvcnQAdW5zaWduZWQgaW50AGluaXQAZmxvYXQAU2FtcGxlRm9ybWF0AHVpbnQ2NF90AGdldERlZmF1bHRQYXJhbWV0ZXJzAHZlY3RvcgB1bnNpZ25lZCBjaGFyAHNhbXBsZUZvcm1hdElucABzYW1wbGVSYXRlSW5wAF9fY3hhX2d1YXJkX2FjcXVpcmUgZGV0ZWN0ZWQgcmVjdXJzaXZlIGluaXRpYWxpemF0aW9uAG5hbgBib29sAHR4VG9nZ2xlUHJvdG9jb2wAcnhUb2dnbGVQcm90b2NvbABlbXNjcmlwdGVuOjp2YWwAW1VdIE5vcm1hbABbTVRdIE5vcm1hbABbRFRdIE5vcm1hbABwYXlsb2FkTGVuZ3RoAGRpc2FibGVMb2cAZW5hYmxlTG9nAHVuc2lnbmVkIGxvbmcAc3RkOjp3c3RyaW5nAGJhc2ljX3N0cmluZwBzdGQ6OnN0cmluZwBzdGQ6OnUxNnN0cmluZwBzdGQ6OnUzMnN0cmluZwBpbmYAc2FtcGxlUmF0ZQBzYW1wbGVzUGVyRnJhbWUAZG91YmxlAGZyZWUAZW5jb2RlAGRlY29kZQBvcGVyYXRpbmdNb2RlAHNvdW5kTWFya2VyVGhyZXNob2xkAHZvaWQAUHJvdG9jb2xJZABHR1dBVkVfT1BFUkFUSU5HX01PREVfVFgAR0dXQVZFX09QRVJBVElOR19NT0RFX1JYX0FORF9UWABHR1dBVkVfT1BFUkFUSU5HX01PREVfUlgAR0dXQVZFX1BST1RPQ09MX0RUX0ZBU1RFU1QAR0dXQVZFX1BST1RPQ09MX0FVRElCTEVfRkFTVEVTVABHR1dBVkVfUFJPVE9DT0xfVUxUUkFTT1VORF9GQVNURVNUAEdHV0FWRV9QUk9UT0NPTF9EVF9GQVNUAEdHV0FWRV9QUk9UT0NPTF9BVURJQkxFX0ZBU1QAR0dXQVZFX1BST1RPQ09MX1VMVFJBU09VTkRfRkFTVABHR1dBVkVfT1BFUkFUSU5HX01PREVfVVNFX0RTUwBHR1dBVkVfT1BFUkFUSU5HX01PREVfVFhfT05MWV9UT05FUwBOQU4AR0dXQVZFX1BST1RPQ09MX0RUX05PUk1BTABHR1dBVkVfUFJPVE9DT0xfQVVESUJMRV9OT1JNQUwAR0dXQVZFX1BST1RPQ09MX1VMVFJBU09VTkRfTk9STUFMAElORgBHR1dBVkVfU0FNUExFX0ZPUk1BVF9VTkRFRklORUQAZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8c2hvcnQ+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHVuc2lnbmVkIHNob3J0PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxpbnQ+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHVuc2lnbmVkIGludD4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8ZmxvYXQ+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHVpbnQ4X3Q+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PGludDhfdD4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8dWludDE2X3Q+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PGludDE2X3Q+AGVtc2NyaXB0ZW46Om1lbW9yeV92aWV3PHVpbnQzMl90PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxpbnQzMl90PgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxjaGFyPgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzx1bnNpZ25lZCBjaGFyPgBzdGQ6OmJhc2ljX3N0cmluZzx1bnNpZ25lZCBjaGFyPgBlbXNjcmlwdGVuOjptZW1vcnlfdmlldzxzaWduZWQgY2hhcj4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8bG9uZz4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8dW5zaWduZWQgbG9uZz4AZW1zY3JpcHRlbjo6bWVtb3J5X3ZpZXc8ZG91YmxlPgBHR1dBVkVfUFJPVE9DT0xfQ1VTVE9NXzkAR0dXQVZFX1BST1RPQ09MX0NVU1RPTV84AEdHV0FWRV9TQU1QTEVfRk9STUFUX1U4AEdHV0FWRV9TQU1QTEVfRk9STUFUX0k4AEdHV0FWRV9QUk9UT0NPTF9DVVNUT01fNwBHR1dBVkVfUFJPVE9DT0xfQ1VTVE9NXzYAR0dXQVZFX1NBTVBMRV9GT1JNQVRfVTE2AEdHV0FWRV9TQU1QTEVfRk9STUFUX0kxNgBHR1dBVkVfUFJPVE9DT0xfQ1VTVE9NXzUAR0dXQVZFX1BST1RPQ09MX0NVU1RPTV80AEdHV0FWRV9QUk9UT0NPTF9DVVNUT01fMwBHR1dBVkVfUFJPVE9DT0xfQ1VTVE9NXzIAR0dXQVZFX1NBTVBMRV9GT1JNQVRfRjMyAEdHV0FWRV9QUk9UT0NPTF9DVVNUT01fMQBHR1dBVkVfUFJPVE9DT0xfQ1VTVE9NXzAALgAobnVsbCkARXJyb3I6IGNhcHR1cmUgc2FtcGxlIHJhdGUgKCVnIEh6KSBtdXN0IGJlID49ICVnIEh6CgBFcnJvcjogY2FwdHVyZSBzYW1wbGUgcmF0ZSAoJWcgSHopIG11c3QgYmUgPD0gJWcgSHoKAEVycm9yOiBmYWlsZWQgdG8gY29tcHV0ZSB0aGUgc2l6ZSBvZiB0aGUgcmVxdWlyZWQgbWVtb3J5CgBUcnVuY2F0aW5nIGRhdGEgZnJvbSAlZCB0byAlZCBieXRlcwoAQ2Fubm90IGRlY29kZSB3aGlsZSB0cmFuc21pdHRpbmcKAFR4IGlzIGRpc2FibGVkIC0gY2Fubm90IHRyYW5zbWl0IGRhdGEgd2l0aCB0aGlzIEdHV2F2ZSBpbnN0YW5jZQoAUnggaXMgZGlzYWJsZWQgLSBjYW5ub3QgcmVjZWl2ZSBkYXRhIHdpdGggdGhpcyBHR1dhdmUgaW5zdGFuY2UKAFByb3RvY29sICVkIGlzIG5vdCBlbmFibGVkIC0gbWFrZSBzdXJlIHRvIGVuYWJsZSBpdCBiZWZvcmUgY3JlYXRpbmcgdGhlIGluc3RhbmNlCgBNb25vLXRvbmUgcHJvdG9jb2xzIHdpdGggdmFyaWFibGUgbGVuZ3RoIGFyZSBub3Qgc3VwcG9ydGVkCgBGYWlsZWQgdG8gaW5pdGlhbGl6ZSBUeCB0cmFuc21pc3Npb24gZm9yIEdHV2F2ZSBpbnN0YW5jZSAlZAoASW52YWxpZCBHR1dhdmUgaW5zdGFuY2UgJWQKAEZhaWxlZCB0byBlbmNvZGUgZGF0YSAtIEdHV2F2ZSBpbnN0YW5jZSAlZAoARmFpbGVkIHRvIGRlY29kZSBkYXRhIC0gR0dXYXZlIGluc3RhbmNlICVkCgBGYWlsZWQgdG8gZnJlZSBHR1dhdmUgaW5zdGFuY2UgLSBpbnZhbGlkIEdHV2F2ZSBpbnN0YW5jZSBpZCAlZAoAbiA9ICVkLCBuQWN0dWFsID0gJWQKAFJlY2VpdmVkIGVuZCBtYXJrZXIuIEZyYW1lcyBsZWZ0ID0gJWQsIHJlY29yZGVkID0gJWQKAEVycm9yOiBmYWlsZWQgdG8gYWxsb2NhdGUgdGhlIHJlcXVpcmVkIG1lbW9yeTogJWQKAEludmFsaWQgcGF5bG9hZCBsZW5ndGg6ICVkLCBtYXg6ICVkCgBJbnZhbGlkIHNhbXBsZXMgcGVyIGZyYW1lOiAlZCwgbWF4OiAlZAoASW52YWxpZCBvciB1bnN1cHBvcnRlZCBwbGF5YmFjayBzYW1wbGUgZm9ybWF0OiAlZAoASW52YWxpZCBvciB1bnN1cHBvcnRlZCBjYXB0dXJlIHNhbXBsZSBmb3JtYXQ6ICVkCgBJbnZhbGlkIHNhbXBsZSBmb3JtYXQ6ICVkCgBOZWdhdGl2ZSBkYXRhIHNpemU6ICVkCgBFcnJvcjogZmFpbGVkIHRvIGFsbG9jYXRlIG1lbW9yeSAtIGhlYXBTaXplMDogJWQsIGhlYXBTaXplOiAlZAoASW52YWxpZCB2b2x1bWU6ICVkCgBJbnZhbGlkIHByb3RvY29sIElEOiAlZAoAUmVjZWl2aW5nIHNvdW5kIGRhdGEgLi4uCgBBbmFseXppbmcgY2FwdHVyZWQgZGF0YSAuLgoARmFpbGVkIHRvIGNyZWF0ZSBHR1dhdmUgaW5zdGFuY2UgLSByZWFjaGVkIG1heGltdW0gbnVtYmVyIG9mIGluc3RhbmNlcyAoJWQpCgBGYWlsdXJlIGR1cmluZyBjYXB0dXJlIC0gcHJvdmlkZWQgYnl0ZXMgKCVkKSBhcmUgbm90IG11bHRpcGxlIG9mIHNhbXBsZSBzaXplICglZCkKAERlY29kZWQgbGVuZ3RoID0gJWQsIHByb3RvY29sID0gJyVzJyAoJWQpCgBFcnJvcjogdG90YWwgbGVuZ3RoICVkIChwYXlsb2FkICVkICsgRUNDICVkIGJ5dGVzKSBpcyB0b28gbGFyZ2UgKCA+ICVkKQoARmFpbGVkIHRvIGNhcHR1cmUgc291bmQgZGF0YS4gUGxlYXNlIHRyeSBhZ2FpbiAobGVuZ3RoID0gJWQpCgBSZWNlaXZlZCBzb3VuZCBkYXRhIHN1Y2Nlc3NmdWxseTogJyVzJwoAMTlnZ3dhdmVfU2FtcGxlRm9ybWF0AAAAAPwoAACLEgAAMTdnZ3dhdmVfUHJvdG9jb2xJZAD8KAAArBIAADE3Z2d3YXZlX1BhcmFtZXRlcnMASCkAAMgSAABpAHZpAGlpaQB2aWlpAGZpaQB2aWlmAADcEgAAaWkAAJgoAADcEgAARCgAAJgoAAB2aWkATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJY0VFAABIKQAAGBMAAGgTAACYKAAA4BMAAMASAACYKAAATjEwZW1zY3JpcHRlbjN2YWxFAABIKQAAVBMAAE5TdDNfXzIxMmJhc2ljX3N0cmluZ0ljTlNfMTFjaGFyX3RyYWl0c0ljRUVOU185YWxsb2NhdG9ySWNFRUVFAE5TdDNfXzIyMV9fYmFzaWNfc3RyaW5nX2NvbW1vbklMYjFFRUUAAAAASCkAAK8TAADMKQAAcBMAAAAAAAABAAAA2BMAAAAAAABpaWlpaWkAAGgTAACYKAAA4BMAAGlpaWkAAAAARCgAAEQoAADAEgAAmCgAQbAoC6cilp+0rxuR3sVFdeguDzJKX7RWlct/alRqSPILe837k208d17DM0fA8XEyMyc1aEcfTqwjQl8AN6RQbUgkkXyhTgAAARkCMhrGA98z7htox0sEZOAONI3vgRzBafjICExxBYplL+EkDyE1k47a8BKCRR21wn1qJ/m5yZoJeE3kcqYGv4tiZt0w/eKYJbMQkSKINtCUzo+W273x0hNcgzhGQB5CtqPDSH5uazooVPqFuj3KXpufChV5K07U5axz86dXB3DA94yAYw1nSt7tMcX+GOOlmXcmuLR8EUSS2SMgiS43P9FblbzPzZCHl7Lc/L5h8lbTqxQqXZ6EPDlTR21Boh8tQ9i3e6R2xBdJ7H8Mb/ZsoTtSKZ1VqvtghrG7zD5ay1lfsJypoFEL9RbrenUs10+u1enm563odNb06qhQWK8BAgQIECBAgB06dOjNhxMmTJgtWrR16smPAwYMGDBgwJ0nTpwlSpQ1atS1d+7BnyNGjAUKFChQoF26adK5b96hX75hwpkvXrxlyokPHjx48P3n07tr1rF//uHfo1u2ceLZr0OGESJEiA0aNGjQvWfOgR8+fPjtx5M7duzFlzNmzIUXLly4bdqpT54hQoQVKlSoTZopUqRVqkmSOXLk1bdz5tG/Y8aRP3785deze/bx/+Pbq0uWMWLElTdu3KVXrkGCGTJkyI0HDhw4cODdp1OmUaJZsnny+e/DmytWrEWKCRIkSJA9evT19/P768uLCxYsWLB9+unPgxs2bNitR44BAgQIECBAgB06dOjNhxMmTJgtWrR16smPAwYMGDBgwJ0nTpwlSpQ1atS1d+7BnyNGjAUKFChQoF26adK5b96hX75hwpkvXrxlyokPHjx48P3n07tr1rF//uHfo1u2ceLZr0OGESJEiA0aNGjQvWfOgR8+fPjtx5M7duzFlzNmzIUXLly4bdqpT54hQoQVKlSoTZopUqRVqkmSOXLk1bdz5tG/Y8aRP3785deze/bx/+Pbq0uWMWLElTdu3KVXrkGCGTJkyI0HDhw4cODdp1OmUaJZsnny+e/DmytWrEWKCRIkSJA9evT19/P768uLCxYsWLB9+unPgxs2bNitR44BAgAAAAABAAAAAQAAAAIAAAACAAAABAAAAE5TdDNfXzIxMmJhc2ljX3N0cmluZ0loTlNfMTFjaGFyX3RyYWl0c0loRUVOU185YWxsb2NhdG9ySWhFRUVFAADMKQAAiBcAAAAAAAABAAAA2BMAAAAAAABOU3QzX18yMTJiYXNpY19zdHJpbmdJd05TXzExY2hhcl90cmFpdHNJd0VFTlNfOWFsbG9jYXRvckl3RUVFRQAAzCkAAOAXAAAAAAAAAQAAANgTAAAAAAAATlN0M19fMjEyYmFzaWNfc3RyaW5nSURzTlNfMTFjaGFyX3RyYWl0c0lEc0VFTlNfOWFsbG9jYXRvcklEc0VFRUUAAADMKQAAOBgAAAAAAAABAAAA2BMAAAAAAABOU3QzX18yMTJiYXNpY19zdHJpbmdJRGlOU18xMWNoYXJfdHJhaXRzSURpRUVOU185YWxsb2NhdG9ySURpRUVFRQAAAMwpAACUGAAAAAAAAAEAAADYEwAAAAAAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SWFFRQAASCkAAPAYAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0loRUUAAEgpAAAYGQAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJc0VFAABIKQAAQBkAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SXRFRQAASCkAAGgZAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0lpRUUAAEgpAACQGQAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJakVFAABIKQAAuBkAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SWxFRQAASCkAAOAZAABOMTBlbXNjcmlwdGVuMTFtZW1vcnlfdmlld0ltRUUAAEgpAAAIGgAATjEwZW1zY3JpcHRlbjExbWVtb3J5X3ZpZXdJZkVFAABIKQAAMBoAAE4xMGVtc2NyaXB0ZW4xMW1lbW9yeV92aWV3SWRFRQAASCkAAFgaAAADAAAABAAAAAQAAAAGAAAAg/miAERObgD8KRUA0VcnAN009QBi28AAPJmVAEGQQwBjUf4Au96rALdhxQA6biQA0k1CAEkG4AAJ6i4AHJLRAOsd/gApsRwA6D6nAPU1ggBEuy4AnOmEALQmcABBfl8A1pE5AFODOQCc9DkAi1+EACj5vQD4HzsA3v+XAA+YBQARL+8AClqLAG0fbQDPfjYACcsnAEZPtwCeZj8ALepfALondQDl68cAPXvxAPc5BwCSUooA+2vqAB+xXwAIXY0AMANWAHv8RgDwq2sAILzPADb0mgDjqR0AXmGRAAgb5gCFmWUAoBRfAI1AaACA2P8AJ3NNAAYGMQDKVhUAyahzAHviYABrjMAAGcRHAM1nwwAJ6NwAWYMqAIt2xACmHJYARK/dABlX0QClPgUABQf/ADN+PwDCMugAmE/eALt9MgAmPcMAHmvvAJ/4XgA1HzoAf/LKAPGHHQB8kCEAaiR8ANVu+gAwLXcAFTtDALUUxgDDGZ0ArcTCACxNQQAMAF0Ahn1GAONxLQCbxpoAM2IAALTSfAC0p5cAN1XVANc+9gCjEBgATXb8AGSdKgBw16sAY3z4AHqwVwAXFecAwElWADvW2QCnhDgAJCPLANaKdwBaVCMAAB+5APEKGwAZzt8AnzH/AGYeagCZV2EArPtHAH5/2AAiZbcAMuiJAOa/YADvxM0AbDYJAF0/1AAW3tcAWDveAN6bkgDSIigAKIboAOJYTQDGyjIACOMWAOB9ywAXwFAA8x2nABjgWwAuEzQAgxJiAINIAQD1jlsArbB/AB7p8gBISkMAEGfTAKrd2ACuX0IAamHOAAoopADTmbQABqbyAFx3fwCjwoMAYTyIAIpzeACvjFoAb9e9AC2mYwD0v8sAjYHvACbBZwBVykUAytk2ACio0gDCYY0AEsl3AAQmFAASRpsAxFnEAMjFRABNspEAABfzANRDrQApSeUA/dUQAAC+/AAelMwAcM7uABM+9QDs8YAAs+fDAMf4KACTBZQAwXE+AC4JswALRfMAiBKcAKsgewAutZ8AR5LCAHsyLwAMVW0AcqeQAGvnHwAxy5YAeRZKAEF54gD034kA6JSXAOLmhACZMZcAiO1rAF9fNgC7/Q4ASJq0AGekbABxckIAjV0yAJ8VuAC85QkAjTElAPd0OQAwBRwADQwBAEsIaAAs7lgAR6qQAHTnAgC91iQA932mAG5IcgCfFu8AjpSmALSR9gDRU1EAzwryACCYMwD1S34AsmNoAN0+XwBAXQMAhYl/AFVSKQA3ZMAAbdgQADJIMgBbTHUATnHUAEVUbgALCcEAKvVpABRm1QAnB50AXQRQALQ72wDqdsUAh/kXAElrfQAdJ7oAlmkpAMbMrACtFFQAkOJqAIjZiQAsclAABKS+AHcHlADzMHAAAPwnAOpxqABmwkkAZOA9AJfdgwCjP5cAQ5T9AA2GjAAxQd4AkjmdAN1wjAAXt+cACN87ABU3KwBcgKAAWoCTABARkgAP6NgAbICvANv/SwA4kA8AWRh2AGKlFQBhy7sAx4m5ABBAvQDS8gQASXUnAOu29gDbIrsAChSqAIkmLwBkg3YACTszAA6UGgBROqoAHaPCAK/trgBcJhIAbcJNAC16nADAVpcAAz+DAAnw9gArQIwAbTGZADm0BwAMIBUA2MNbAPWSxADGrUsATsqlAKc3zQDmqTYAq5KUAN1CaAAZY94AdozvAGiLUgD82zcArqGrAN8VMQAArqEADPvaAGRNZgDtBbcAKWUwAFdWvwBH/zoAavm5AHW+8wAok98Aq4AwAGaM9gAEyxUA+iIGANnkHQA9s6QAVxuPADbNCQBOQukAE76kADMjtQDwqhoAT2WoANLBpQALPw8AW3jNACP5dgB7iwQAiRdyAMamUwBvbuIA7+sAAJtKWADE2rcAqma6AHbPzwDRAh0AsfEtAIyZwQDDrXcAhkjaAPddoADGgPQArPAvAN3smgA/XLwA0N5tAJDHHwAq27YAoyU6AACvmgCtU5MAtlcEACkttABLgH4A2genAHaqDgB7WaEAFhIqANy3LQD65f0Aidv+AIm+/QDkdmwABqn8AD6AcACFbhUA/Yf/ACg+BwBhZzMAKhiGAE296gCz568Aj21uAJVnOQAxv1sAhNdIADDfFgDHLUMAJWE1AMlwzgAwy7gAv2z9AKQAogAFbOQAWt2gACFvRwBiEtIAuVyEAHBhSQBrVuAAmVIBAFBVNwAe1bcAM/HEABNuXwBdMOQAhS6pAB2ywwChMjYACLekAOqx1AAW9yEAj2nkACf/dwAMA4AAjUAtAE/NoAAgpZkAs6LTAC9dCgC0+UIAEdrLAH2+0ACb28EAqxe9AMqigQAIalwALlUXACcAVQB/FPAA4QeGABQLZACWQY0Ah77eANr9KgBrJbYAe4k0AAXz/gC5v54AaGpPAEoqqABPxFoALfi8ANdamAD0x5UADU2NACA6pgCkV18AFD+xAIA4lQDMIAEAcd2GAMnetgC/YPUATWURAAEHawCMsKwAssDQAFFVSAAe+w4AlXLDAKMGOwDAQDUABtx7AOBFzABOKfoA1srIAOjzQQB8ZN4Am2TYANm+MQCkl8MAd1jUAGnjxQDw2hMAujo8AEYYRgBVdV8A0r31AG6SxgCsLl0ADkTtABw+QgBhxIcAKf3pAOfW8wAifMoAb5E1AAjgxQD/140AbmriALD9xgCTCMEAfF10AGutsgDNbp0APnJ7AMYRagD3z6kAKXPfALXJugC3AFEA4rINAHS6JADlfWAAdNiKAA0VLACBGAwAfmaUAAEpFgCfenYA/f2+AFZF7wDZfjYA7NkTAIu6uQDEl/wAMagnAPFuwwCUxTYA2KhWALSotQDPzA4AEoktAG9XNAAsVokAmc7jANYguQBrXqoAPiqcABFfzAD9C0oA4fT7AI47bQDihiwA6dSEAPy0qQDv7tEALjXJAC85YQA4IUQAG9nIAIH8CgD7SmoALxzYAFO0hABOmYwAVCLMACpV3ADAxtYACxmWABpwuABplWQAJlpgAD9S7gB/EQ8A9LURAPzL9QA0vC0ANLzuAOhdzADdXmAAZ46bAJIz7wDJF7gAYVibAOFXvABRg8YA2D4QAN1xSAAtHN0ArxihACEsRgBZ89cA2XqYAJ5UwABPhvoAVgb8AOV5rgCJIjYAOK0iAGeT3ABV6KoAgiY4AMrnmwBRDaQAmTOxAKnXDgBpBUgAZbLwAH+IpwCITJcA+dE2ACGSswB7gkoAmM8hAECf3ADcR1UA4XQ6AGfrQgD+nd8AXtRfAHtnpAC6rHoAVfaiACuIIwBBulUAWW4IACEqhgA5R4MAiePmAOWe1ABJ+0AA/1bpABwPygDFWYoAlPorANPBxQAPxc8A21quAEfFhgCFQ2IAIYY7ACx5lAAQYYcAKkx7AIAsGgBDvxIAiCaQAHg8iQCoxOQA5dt7AMQ6wgAm9OoA92eKAA2SvwBloysAPZOxAL18CwCkUdwAJ91jAGnh3QCalBkAqCmVAGjOKAAJ7bQARJ8gAE6YygBwgmMAfnwjAA+5MgCn9Y4AFFbnACHxCAC1nSoAb35NAKUZUQC1+asAgt/WAJbdYQAWNgIAxDqfAIOioQBy7W0AOY16AIK4qQBrMlwARidbAAA07QDSAHcA/PRVAAFZTQDgcYAAQePKAAs/QPsh+T8AAAAALUR0PgAAAICYRvg8AAAAYFHMeDsAAACAgxvwOQAAAEAgJXo4AAAAgCKC4zYAAAAAHfNpNWAqAEGwywALQRkACgAZGRkAAAAABQAAAAAAAAkAAAAACwAAAAAAAAAAGQARChkZGQMKBwABAAkLGAAACQYLAAALAAYZAAAAGRkZAEGBzAALIQ4AAAAAAAAAABkACg0ZGRkADQAAAgAJDgAAAAkADgAADgBBu8wACwEMAEHHzAALFRMAAAAAEwAAAAAJDAAAAAAADAAADABB9cwACwEQAEGBzQALFQ8AAAAEDwAAAAAJEAAAAAAAEAAAEABBr80ACwESAEG7zQALHhEAAAAAEQAAAAAJEgAAAAAAEgAAEgAAGgAAABoaGgBB8s0ACw4aAAAAGhoaAAAAAAAACQBBo84ACwEUAEGvzgALFRcAAAAAFwAAAAAJFAAAAAAAFAAAFABB3c4ACwEWAEHpzgALzQUVAAAAABUAAAAACRYAAAAAABYAABYAADAxMjM0NTY3ODlBQkNERUZOMTBfX2N4eGFiaXYxMTZfX3NoaW1fdHlwZV9pbmZvRQAAAABwKQAAkCcAADAqAABOMTBfX2N4eGFiaXYxMTdfX2NsYXNzX3R5cGVfaW5mb0UAAABwKQAAwCcAALQnAAAAAAAANCgAACAAAAAhAAAAIgAAACMAAAAkAAAATjEwX19jeHhhYml2MTIzX19mdW5kYW1lbnRhbF90eXBlX2luZm9FAHApAAAMKAAAtCcAAHYAAAD4JwAAQCgAAGIAAAD4JwAATCgAAGMAAAD4JwAAWCgAAGgAAAD4JwAAZCgAAGEAAAD4JwAAcCgAAHMAAAD4JwAAfCgAAHQAAAD4JwAAiCgAAGkAAAD4JwAAlCgAAGoAAAD4JwAAoCgAAGwAAAD4JwAArCgAAG0AAAD4JwAAuCgAAHgAAAD4JwAAxCgAAHkAAAD4JwAA0CgAAGYAAAD4JwAA3CgAAGQAAAD4JwAA6CgAAAAAAAA0KQAAIAAAACUAAAAiAAAAIwAAACYAAABOMTBfX2N4eGFiaXYxMTZfX2VudW1fdHlwZV9pbmZvRQAAAABwKQAAECkAALQnAAAAAAAA5CcAACAAAAAnAAAAIgAAACMAAAAoAAAAKQAAACoAAAArAAAAAAAAALgpAAAgAAAALAAAACIAAAAjAAAAKAAAAC0AAAAuAAAALwAAAE4xMF9fY3h4YWJpdjEyMF9fc2lfY2xhc3NfdHlwZV9pbmZvRQAAAABwKQAAkCkAAOQnAAAAAAAAFCoAACAAAAAwAAAAIgAAACMAAAAoAAAAMQAAADIAAAAzAAAATjEwX19jeHhhYml2MTIxX192bWlfY2xhc3NfdHlwZV9pbmZvRQAAAHApAADsKQAA5CcAAFN0OXR5cGVfaW5mbwAAAABIKQAAICoAQbjUAAsp/////wCAO0cAgDtHAIA7RwAEAAAAAEBABQAAAAUAAAAGAAAAAAAAAAUAQezUAAsBGgBBhNUACwobAAAAHAAAAPkvAEGc1QALAQIAQazVAAsI//////////8AQfDVAAsBBQBB/NUACwEdAEGU1gALDhsAAAAeAAAACDAAAAAEAEGs1gALAQEAQbzWAAsF/////woAQYDXAAsDsDZQ";if(!isDataURI(wasmBinaryFile)){wasmBinaryFile=locateFile(wasmBinaryFile)}function getBinary(file){try{if(file==wasmBinaryFile&&wasmBinary){return new Uint8Array(wasmBinary)}var binary=tryParseAsDataURI(file);if(binary){return binary}if(readBinary){return readBinary(file)}else{throw"both async and sync fetching of the wasm failed"}}catch(err){abort(err)}}function getBinaryPromise(){if(!wasmBinary&&(ENVIRONMENT_IS_WEB||ENVIRONMENT_IS_WORKER)){if(typeof fetch==="function"&&!isFileURI(wasmBinaryFile)){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){if(!response["ok"]){throw"failed to load wasm binary file at '"+wasmBinaryFile+"'"}return response["arrayBuffer"]()}).catch(function(){return getBinary(wasmBinaryFile)})}else{if(readAsync){return new Promise(function(resolve,reject){readAsync(wasmBinaryFile,function(response){resolve(new Uint8Array(response))},reject)})}}}return Promise.resolve().then(function(){return getBinary(wasmBinaryFile)})}function createWasm(){var info={"a":asmLibraryArg};function receiveInstance(instance,module){var exports=instance.exports;Module["asm"]=exports;wasmMemory=Module["asm"]["A"];updateGlobalBufferAndViews(wasmMemory.buffer);wasmTable=Module["asm"]["C"];addOnInit(Module["asm"]["B"]);removeRunDependency("wasm-instantiate")}addRunDependency("wasm-instantiate");function receiveInstantiationResult(result){receiveInstance(result["instance"])}function instantiateArrayBuffer(receiver){return getBinaryPromise().then(function(binary){return WebAssembly.instantiate(binary,info)}).then(function(instance){return instance}).then(receiver,function(reason){err("failed to asynchronously prepare wasm: "+reason);abort(reason)})}function instantiateAsync(){if(!wasmBinary&&typeof WebAssembly.instantiateStreaming==="function"&&!isDataURI(wasmBinaryFile)&&!isFileURI(wasmBinaryFile)&&typeof fetch==="function"){return fetch(wasmBinaryFile,{credentials:"same-origin"}).then(function(response){var result=WebAssembly.instantiateStreaming(response,info);return result.then(receiveInstantiationResult,function(reason){err("wasm streaming compile failed: "+reason);err("falling back to ArrayBuffer instantiation");return instantiateArrayBuffer(receiveInstantiationResult)})})}else{return instantiateArrayBuffer(receiveInstantiationResult)}}if(Module["instantiateWasm"]){try{var exports=Module["instantiateWasm"](info,receiveInstance);return exports}catch(e){err("Module.instantiateWasm callback failed with error: "+e);return false}}instantiateAsync().catch(readyPromiseReject);return{}}function callRuntimeCallbacks(callbacks){while(callbacks.length>0){var callback=callbacks.shift();if(typeof callback=="function"){callback(Module);continue}var func=callback.func;if(typeof func==="number"){if(callback.arg===undefined){getWasmTableEntry(func)()}else{getWasmTableEntry(func)(callback.arg)}}else{func(callback.arg===undefined?null:callback.arg)}}}var wasmTableMirror=[];function getWasmTableEntry(funcPtr){var func=wasmTableMirror[funcPtr];if(!func){if(funcPtr>=wasmTableMirror.length)wasmTableMirror.length=funcPtr+1;wasmTableMirror[funcPtr]=func=wasmTable.get(funcPtr)}return func}var structRegistrations={};function runDestructors(destructors){while(destructors.length){var ptr=destructors.pop();var del=destructors.pop();del(ptr)}}function simpleReadValueFromPointer(pointer){return this["fromWireType"](HEAPU32[pointer>>2])}var awaitingDependencies={};var registeredTypes={};var typeDependencies={};var char_0=48;var char_9=57;function makeLegalFunctionName(name){if(undefined===name){return"_unknown"}name=name.replace(/[^a-zA-Z0-9_]/g,"$");var f=name.charCodeAt(0);if(f>=char_0&&f<=char_9){return"_"+name}else{return name}}function createNamedFunction(name,body){name=makeLegalFunctionName(name);return new Function("body","return function "+name+"() {\n"+' "use strict";'+" return body.apply(this, arguments);\n"+"};\n")(body)}function extendError(baseErrorType,errorName){var errorClass=createNamedFunction(errorName,function(message){this.name=errorName;this.message=message;var stack=new Error(message).stack;if(stack!==undefined){this.stack=this.toString()+"\n"+stack.replace(/^Error(:[^\n]*)?\n/,"")}});errorClass.prototype=Object.create(baseErrorType.prototype);errorClass.prototype.constructor=errorClass;errorClass.prototype.toString=function(){if(this.message===undefined){return this.name}else{return this.name+": "+this.message}};return errorClass}var InternalError=undefined;function throwInternalError(message){throw new InternalError(message)}function whenDependentTypesAreResolved(myTypes,dependentTypes,getTypeConverters){myTypes.forEach(function(type){typeDependencies[type]=dependentTypes});function onComplete(typeConverters){var myTypeConverters=getTypeConverters(typeConverters);if(myTypeConverters.length!==myTypes.length){throwInternalError("Mismatched type converter count")}for(var i=0;i>shift])},destructorFunction:null})}function __embind_register_constant(name,type,value){name=readLatin1String(name);whenDependentTypesAreResolved([],[type],function(type){type=type[0];Module[name]=type["fromWireType"](value);return[]})}var emval_free_list=[];var emval_handle_array=[{},{value:undefined},{value:null},{value:true},{value:false}];function __emval_decref(handle){if(handle>4&&0===--emval_handle_array[handle].refcount){emval_handle_array[handle]=undefined;emval_free_list.push(handle)}}function count_emval_handles(){var count=0;for(var i=5;i>1])};case 2:return function(pointer){var heap=signed?HEAP32:HEAPU32;return this["fromWireType"](heap[pointer>>2])};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_enum(rawType,name,size,isSigned){var shift=getShiftFromSize(size);name=readLatin1String(name);function ctor(){}ctor.values={};registerType(rawType,{name:name,constructor:ctor,"fromWireType":function(c){return this.constructor.values[c]},"toWireType":function(destructors,c){return c.value},"argPackAdvance":8,"readValueFromPointer":enumReadValueFromPointer(name,shift,isSigned),destructorFunction:null});exposePublicSymbol(name,ctor)}function getTypeName(type){var ptr=___getTypeName(type);var rv=readLatin1String(ptr);_free(ptr);return rv}function requireRegisteredType(rawType,humanName){var impl=registeredTypes[rawType];if(undefined===impl){throwBindingError(humanName+" has unknown type "+getTypeName(rawType))}return impl}function __embind_register_enum_value(rawEnumType,name,enumValue){var enumType=requireRegisteredType(rawEnumType,"enum");name=readLatin1String(name);var Enum=enumType.constructor;var Value=Object.create(enumType.constructor.prototype,{value:{value:enumValue},constructor:{value:createNamedFunction(enumType.name+"_"+name,function(){})}});Enum.values[enumValue]=Value;Enum[name]=Value}function floatReadValueFromPointer(name,shift){switch(shift){case 2:return function(pointer){return this["fromWireType"](HEAPF32[pointer>>2])};case 3:return function(pointer){return this["fromWireType"](HEAPF64[pointer>>3])};default:throw new TypeError("Unknown float type: "+name)}}function __embind_register_float(rawType,name,size){var shift=getShiftFromSize(size);name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":function(value){return value},"toWireType":function(destructors,value){return value},"argPackAdvance":8,"readValueFromPointer":floatReadValueFromPointer(name,shift),destructorFunction:null})}function new_(constructor,argumentList){if(!(constructor instanceof Function)){throw new TypeError("new_ called with constructor type "+typeof constructor+" which is not a function")}var dummy=createNamedFunction(constructor.name||"unknownFunctionName",function(){});dummy.prototype=constructor.prototype;var obj=new dummy;var r=constructor.apply(obj,argumentList);return r instanceof Object?r:obj}function craftInvokerFunction(humanName,argTypes,classType,cppInvokerFunc,cppTargetFunc){var argCount=argTypes.length;if(argCount<2){throwBindingError("argTypes array size mismatch! Must at least get return value and 'this' types!")}var isClassMethodFunc=argTypes[1]!==null&&classType!==null;var needsDestructorStack=false;for(var i=1;i0?", ":"")+argsListWired}invokerFnBody+=(returns?"var rv = ":"")+"invoker(fn"+(argsListWired.length>0?", ":"")+argsListWired+");\n";if(needsDestructorStack){invokerFnBody+="runDestructors(destructors);\n"}else{for(var i=isClassMethodFunc?1:2;i>2)+i])}return array}function replacePublicSymbol(name,value,numArguments){if(!Module.hasOwnProperty(name)){throwInternalError("Replacing nonexistant public symbol")}if(undefined!==Module[name].overloadTable&&undefined!==numArguments){Module[name].overloadTable[numArguments]=value}else{Module[name]=value;Module[name].argCount=numArguments}}function dynCallLegacy(sig,ptr,args){var f=Module["dynCall_"+sig];return args&&args.length?f.apply(null,[ptr].concat(args)):f.call(null,ptr)}function dynCall(sig,ptr,args){if(sig.includes("j")){return dynCallLegacy(sig,ptr,args)}return getWasmTableEntry(ptr).apply(null,args)}function getDynCaller(sig,ptr){var argCache=[];return function(){argCache.length=arguments.length;for(var i=0;i>1]}:function readU16FromPointer(pointer){return HEAPU16[pointer>>1]};case 2:return signed?function readS32FromPointer(pointer){return HEAP32[pointer>>2]}:function readU32FromPointer(pointer){return HEAPU32[pointer>>2]};default:throw new TypeError("Unknown integer type: "+name)}}function __embind_register_integer(primitiveType,name,size,minRange,maxRange){name=readLatin1String(name);if(maxRange===-1){maxRange=4294967295}var shift=getShiftFromSize(size);var fromWireType=value=>value;if(minRange===0){var bitshift=32-8*size;fromWireType=(value=>value<>>bitshift)}var isUnsignedType=name.includes("unsigned");var checkAssertions=(value,toTypeName)=>{};var toWireType;if(isUnsignedType){toWireType=function(destructors,value){checkAssertions(value,this.name);return value>>>0}}else{toWireType=function(destructors,value){checkAssertions(value,this.name);return value}}registerType(primitiveType,{name:name,"fromWireType":fromWireType,"toWireType":toWireType,"argPackAdvance":8,"readValueFromPointer":integerReadValueFromPointer(name,shift,minRange!==0),destructorFunction:null})}function __embind_register_memory_view(rawType,dataTypeIndex,name){var typeMapping=[Int8Array,Uint8Array,Int16Array,Uint16Array,Int32Array,Uint32Array,Float32Array,Float64Array];var TA=typeMapping[dataTypeIndex];function decodeMemoryView(handle){handle=handle>>2;var heap=HEAPU32;var size=heap[handle];var data=heap[handle+1];return new TA(buffer,data,size)}name=readLatin1String(name);registerType(rawType,{name:name,"fromWireType":decodeMemoryView,"argPackAdvance":8,"readValueFromPointer":decodeMemoryView},{ignoreDuplicateRegistrations:true})}function __embind_register_std_string(rawType,name){name=readLatin1String(name);var stdStringIsUTF8=name==="std::string";registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var str;if(stdStringIsUTF8){var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i;if(i==length||HEAPU8[currentBytePtr]==0){var maxRead=currentBytePtr-decodeStartPtr;var stringSegment=UTF8ToString(decodeStartPtr,maxRead);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+1}}}else{var a=new Array(length);for(var i=0;ilengthBytesUTF8(value))}else{getLength=(()=>value.length)}var length=getLength();var ptr=_malloc(4+length+1);HEAPU32[ptr>>2]=length;if(stdStringIsUTF8&&valueIsOfTypeString){stringToUTF8(value,ptr+4,length+1)}else{if(valueIsOfTypeString){for(var i=0;i255){_free(ptr);throwBindingError("String has UTF-16 code units that do not fit in 8 bits")}HEAPU8[ptr+4+i]=charCode}}else{for(var i=0;iHEAPU16);shift=1}else if(charSize===4){decodeString=UTF32ToString;encodeString=stringToUTF32;lengthBytesUTF=lengthBytesUTF32;getHeap=(()=>HEAPU32);shift=2}registerType(rawType,{name:name,"fromWireType":function(value){var length=HEAPU32[value>>2];var HEAP=getHeap();var str;var decodeStartPtr=value+4;for(var i=0;i<=length;++i){var currentBytePtr=value+4+i*charSize;if(i==length||HEAP[currentBytePtr>>shift]==0){var maxReadBytes=currentBytePtr-decodeStartPtr;var stringSegment=decodeString(decodeStartPtr,maxReadBytes);if(str===undefined){str=stringSegment}else{str+=String.fromCharCode(0);str+=stringSegment}decodeStartPtr=currentBytePtr+charSize}}_free(value);return str},"toWireType":function(destructors,value){if(!(typeof value==="string")){throwBindingError("Cannot pass non-string to C++ string type "+name)}var length=lengthBytesUTF(value);var ptr=_malloc(4+length+charSize);HEAPU32[ptr>>2]=length>>shift;encodeString(value,ptr+4,length+charSize);if(destructors!==null){destructors.push(_free,ptr)}return ptr},"argPackAdvance":8,"readValueFromPointer":simpleReadValueFromPointer,destructorFunction:function(ptr){_free(ptr)}})}function __embind_register_value_object(rawType,name,constructorSignature,rawConstructor,destructorSignature,rawDestructor){structRegistrations[rawType]={name:readLatin1String(name),rawConstructor:embind__requireFunction(constructorSignature,rawConstructor),rawDestructor:embind__requireFunction(destructorSignature,rawDestructor),fields:[]}}function __embind_register_value_object_field(structType,fieldName,getterReturnType,getterSignature,getter,getterContext,setterArgumentType,setterSignature,setter,setterContext){structRegistrations[structType].fields.push({fieldName:readLatin1String(fieldName),getterReturnType:getterReturnType,getter:embind__requireFunction(getterSignature,getter),getterContext:getterContext,setterArgumentType:setterArgumentType,setter:embind__requireFunction(setterSignature,setter),setterContext:setterContext})}function __embind_register_void(rawType,name){name=readLatin1String(name);registerType(rawType,{isVoid:true,name:name,"argPackAdvance":0,"fromWireType":function(){return undefined},"toWireType":function(destructors,o){return undefined}})}function __emval_incref(handle){if(handle>4){emval_handle_array[handle].refcount+=1}}function __emval_take_value(type,argv){type=requireRegisteredType(type,"_emval_take_value");var v=type["readValueFromPointer"](argv);return Emval.toHandle(v)}function _abort(){abort("")}function _emscripten_memcpy_big(dest,src,num){HEAPU8.copyWithin(dest,src,src+num)}function emscripten_realloc_buffer(size){try{wasmMemory.grow(size-buffer.byteLength+65535>>>16);updateGlobalBufferAndViews(wasmMemory.buffer);return 1}catch(e){}}function _emscripten_resize_heap(requestedSize){var oldSize=HEAPU8.length;requestedSize=requestedSize>>>0;var maxHeapSize=2147483648;if(requestedSize>maxHeapSize){return false}for(var cutDown=1;cutDown<=4;cutDown*=2){var overGrownHeapSize=oldSize*(1+.2/cutDown);overGrownHeapSize=Math.min(overGrownHeapSize,requestedSize+100663296);var newSize=Math.min(maxHeapSize,alignUp(Math.max(requestedSize,overGrownHeapSize),65536));var replacement=emscripten_realloc_buffer(newSize);if(replacement){return true}}return false}var SYSCALLS={mappings:{},buffers:[null,[],[]],printChar:function(stream,curr){var buffer=SYSCALLS.buffers[stream];if(curr===0||curr===10){(stream===1?out:err)(UTF8ArrayToString(buffer,0));buffer.length=0}else{buffer.push(curr)}},varargs:undefined,get:function(){SYSCALLS.varargs+=4;var ret=HEAP32[SYSCALLS.varargs-4>>2];return ret},getStr:function(ptr){var ret=UTF8ToString(ptr);return ret},get64:function(low,high){return low}};function _fd_close(fd){return 0}function _fd_seek(fd,offset_low,offset_high,whence,newOffset){}function _fd_write(fd,iov,iovcnt,pnum){var num=0;for(var i=0;i>2];var len=HEAP32[iov+4>>2];iov+=8;for(var j=0;j>2]=num;return 0}function _setTempRet0(val){setTempRet0(val)}InternalError=Module["InternalError"]=extendError(Error,"InternalError");embind_init_charCodes();BindingError=Module["BindingError"]=extendError(Error,"BindingError");init_emval();UnboundTypeError=Module["UnboundTypeError"]=extendError(Error,"UnboundTypeError");var ASSERTIONS=false;function intArrayToString(array){var ret=[];for(var i=0;i255){if(ASSERTIONS){assert(false,"Character code "+chr+" ("+String.fromCharCode(chr)+") at offset "+i+" not in 0x00-0xFF.")}chr&=255}ret.push(String.fromCharCode(chr))}return ret.join("")}var decodeBase64=typeof atob==="function"?atob:function(input){var keyStr="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";var output="";var chr1,chr2,chr3;var enc1,enc2,enc3,enc4;var i=0;input=input.replace(/[^A-Za-z0-9\+\/\=]/g,"");do{enc1=keyStr.indexOf(input.charAt(i++));enc2=keyStr.indexOf(input.charAt(i++));enc3=keyStr.indexOf(input.charAt(i++));enc4=keyStr.indexOf(input.charAt(i++));chr1=enc1<<2|enc2>>4;chr2=(enc2&15)<<4|enc3>>2;chr3=(enc3&3)<<6|enc4;output=output+String.fromCharCode(chr1);if(enc3!==64){output=output+String.fromCharCode(chr2)}if(enc4!==64){output=output+String.fromCharCode(chr3)}}while(i0){return}preRun();if(runDependencies>0){return}function doRun(){if(calledRun)return;calledRun=true;Module["calledRun"]=true;if(ABORT)return;initRuntime();readyPromiseResolve(Module);if(Module["onRuntimeInitialized"])Module["onRuntimeInitialized"]();postRun()}if(Module["setStatus"]){Module["setStatus"]("Running...");setTimeout(function(){setTimeout(function(){Module["setStatus"]("")},1);doRun()},1)}else{doRun()}}Module["run"]=run;if(Module["preInit"]){if(typeof Module["preInit"]=="function")Module["preInit"]=[Module["preInit"]];while(Module["preInit"].length>0){Module["preInit"].pop()()}}run(); + + + return ggwave_factory.ready +} +); +})(); +if (typeof exports === 'object' && typeof module === 'object') + module.exports = ggwave_factory; +else if (typeof define === 'function' && define['amd']) + define([], function() { return ggwave_factory; }); +else if (typeof exports === 'object') + exports["ggwave_factory"] = ggwave_factory; diff --git a/tests/e2e/radio_set_kit.py b/tests/e2e/radio_set_kit.py index ee96fd0..77d274c 100644 --- a/tests/e2e/radio_set_kit.py +++ b/tests/e2e/radio_set_kit.py @@ -142,6 +142,8 @@ FACE = """(async () => {@HELPERS@@RADIO@ gear.click(); await sleep(200); const groups =Object.fromEntries(all("#radio-gear .chips", spot).map((group) => [group.getAttribute("aria-label"), all(".chip", group).map((chipNode) => [text(chipNode), chipNode.getAttribute("aria-pressed"), chipNode.disabled])])); + all('#radio-gear .chips[aria-label="Fallback"] .chip', spot).find((chipNode) => text(chipNode) === "Hiss").click(); + await sleep(150); const stationsHead = text(spot.querySelector(".radio-station .group-title")); const ptt = spot.querySelector('form.composer button[type="submit"]'); const pageFits = fits(); diff --git a/tests/e2e/test_gibberlink_e2e.py b/tests/e2e/test_gibberlink_e2e.py new file mode 100644 index 0000000..290a73a --- /dev/null +++ b/tests/e2e/test_gibberlink_e2e.py @@ -0,0 +1,239 @@ +from __future__ import annotations + +import json +import os +import shutil +import subprocess +import sys +import tempfile +import time +import unittest +from pathlib import Path +from unittest import mock + +HERE = Path(__file__).resolve().parent +sys.path[:0] = [str(HERE.parent), str(HERE)] + +import hub_e2e_kit as base +from hub_case import HubCase +from hub_support import HUB, iso +from kvb_orchestrator import engines +from radio_set_kit import CUES, OUT, SPY, WORD, probe + +GGWAVE = HUB / "vendor" / "ggwave" / "ggwave.js" +SPOKEN = "Disk at ninety percent" +GIBBER_SPY = """() => { + (@SPY@)(); + const captured = window.e2eGibber = []; + const pans = window.e2ePans = []; + const encoded = (part) => { + const raw = new Uint8Array(part.buffer, part.byteOffset, part.byteLength); + let binary = ""; + for (let at = 0; at < raw.length; at += 0x8000) { + binary += String.fromCharCode(...raw.subarray(at, at + 0x8000)); + } + return btoa(binary); + }; + window.addEventListener("message", (event) => { + if (event.data && Array.isArray(event.data.samples)) { + captured.push({rate: event.data.rate, frames: event.data.samples.map(encoded)}); + } + }); + const panner = AudioContext.prototype.createStereoPanner; + AudioContext.prototype.createStereoPanner = function panned() { + const node = panner.call(this); + pans.push(node); + return node; + }; +}""".replace("@SPY@", SPY) +GIBBER_KIT = """ + const gear = () => all(".spot-head button", spot).find((button) => name(button) === "Read aloud"); + const fallbacks = () => all('#radio-gear .chips[aria-label="Fallback"] .chip', spot); + const kept = () => JSON.parse(localStorage.getItem("kvb-orchestrator.radio") || "{}").fallback || null; + const opened = async (open) => { + if ((gear().getAttribute("aria-expanded") === "true") !== open) { + gear().click(); + await sleep(200); + } + }; + const sent = async (count) => { + await cue("alarm"); + refreshNow(); + return Boolean(await until(() => window.e2eGibber.length > count && lamp().dataset.lit === "true", 40000)); + }; + const stopped = async () => { + const stop = all("button", spot.querySelector(".radio-caption")).find((button) => name(button) === "Stop speaking"); + if (stop) { + stop.click(); + } + return Boolean(await until(() => lamp().dataset.lit === "false", 3000)); + }; +""" +GIBBER = """(async () => {@HELPERS@@RADIO@@KIT@ + press("gibberlink"); + await sleep(200); + const button = spot.querySelector('.radio-modes button[data-mode="gibberlink"]'); + const mode = [pressed(), field("mode"), button.title, Boolean(button.querySelector("svg.bi"))]; + await opened(true); + const before = fallbacks().map((chip) => [text(chip), chip.getAttribute("aria-pressed")]); + fallbacks().find((chip) => text(chip) === "Morse").click(); + await sleep(150); + const morse = [fallbacks().map((chip) => chip.getAttribute("aria-pressed")), kept()]; + fallbacks().find((chip) => text(chip) === "Gibberlink").click(); + await sleep(150); + const back = [fallbacks().map((chip) => chip.getAttribute("aria-pressed")), kept()]; + const label = text(spot.querySelector("#radio-gear .radio-fallback .chips-label")); + const gearFits = fits(); + await opened(false); + const at = {captured: window.e2eGibber.length, pans: window.e2ePans.length}; + const playing = await sent(at.captured); + await sleep(300); + return { + mode, before, morse, back, label, gearFits, playing, captured: window.e2eGibber.slice(at.captured), pans: window.e2ePans.slice(at.pans).map((node) => node.pan.value), + lamp: [text(lamp()), lamp().dataset.lit], caption: text(spot.querySelector(".radio-caption strong")), fits: fits(), frames: document.querySelectorAll("iframe.gibberlink-encoder").length, + }; +})()""" +STOP = """(async () => {@HELPERS@@RADIO@@KIT@ + const lit = lamp().dataset.lit; + return {lit, quiet: await stopped(), hidden: spot.querySelector(".radio-caption").hidden}; +})()""" +QUIET = """(async () => {@HELPERS@@RADIO@@KIT@ + press("quiet"); + await sleep(200); + const at = {captured: window.e2eGibber.length, tts: audio().tts.length}; + const played = await sent(at.captured); + const quiet = await stopped(); + const tts = audio().tts.slice(at.tts).map((entry) => entry.body.text); + await opened(true); + return {played, quiet, tts, captured: window.e2eGibber.slice(at.captured), fits: fits(), violations: window.e2eViolations}; +})()""" +DECODE = """ +const fs = require("fs"); +const factory = require(process.argv[1]); +const captures = JSON.parse(fs.readFileSync(process.argv[2], "utf8")); +factory({print: () => undefined, printErr: () => undefined}).then((ggwave) => { + console.log(JSON.stringify(captures.map(({rate, frames}) => { + const parameters = ggwave.getDefaultParameters(); + parameters.sampleRateInp = rate; + const listener = ggwave.init(parameters); + const heard = []; + const gap = new Float32Array(Math.round(rate * 0.3)); + for (const frame of frames) { + const raw = Buffer.from(frame, "base64"); + const parts = [new Float32Array(raw.buffer.slice(raw.byteOffset, raw.byteOffset + raw.length)), gap]; + for (const samples of parts) { + for (let at = 0; at < samples.length; at += 1024) { + const got = ggwave.decode(listener, new Int8Array(samples.slice(at, at + 1024).buffer)); + if (got && got.length) { + heard.push(Buffer.from(got.buffer, got.byteOffset, got.length).toString("utf8")); + } + } + } + } + ggwave.free(listener); + return heard; + }))); +}); +""" + + +def kit(template: str) -> str: + return probe(template).replace("@KIT@", GIBBER_KIT) + + +@unittest.skipUnless(shutil.which(os.environ.get("CHROMIUM", "chromium")), "no Chromium") +class TestGibberlink(HubCase): + drive = base.OrchestratorE2ECase.drive + beside = base.OrchestratorE2ECase.beside + + def setUp(self): + super().setUp() + OUT.mkdir(parents=True, exist_ok=True) + now = time.time() + self.claim("s1", "Skills session") + self.write_council({"work/s2/claim.json": {"office": "work/s2", "session": "s2", "runtime": "claude", "name": "Stage", "since": iso(now - 7200), "beat": now - 60, "work": "x"}, "news.jsonl": ""}) + hub = self.httpd.hub + hub.settings.put({**hub.settings.get(), "theme": "light"}, hub.settings.get()) + self.host_cpu(10.0, 0) + self.beside(lambda: self.host_cpu(10.0, 0)) + self.sent = 0 + heard = hub.voice_notes.get + + def get(note_id: str) -> dict: + if note_id != CUES["alarm"]: + return heard(note_id) + self.sent += 1 + row = {"ts": time.time(), "from": "Stage", "to": [], "text": f"{SPOKEN} {self.sent}", "class": "security", "v": 2} + with (self.council / "news.jsonl").open("a", encoding="utf-8") as handle: + handle.write(self.jsonl([row])) + return {"id": note_id, "status": "done", "text": "", "error": "", "seconds": None, "created_ts": None} + + patch = mock.patch.object(hub.voice_notes, "get", get) + patch.start() + self.addCleanup(patch.stop) + self.base = f"http://localhost:{self.port}/" + + def steps(self, browser: str) -> list[dict]: + steps = [] + for width, height in base.WIDTHS: + shot = str(OUT / f"{browser}-{width}-radio-gibberlink") + steps += [ + {"width": width, "height": height, "url": f"{self.base}?{width}-gibberlink#stream", "wait": 1200, "probe": kit(GIBBER), "shot": f"{shot}-playing.png", "gesture": True}, + {"width": width, "height": height, "url": None, "wait": 0, "probe": kit(STOP), "shot": None, "gesture": True}, + {"width": width, "height": height, "url": None, "wait": 0, "probe": kit(QUIET), "shot": f"{shot}-fallback.png", "gesture": True}, + ] + return steps + + def decoded(self, captures: list[dict]) -> list[list[str]]: + with tempfile.NamedTemporaryFile("w", suffix=".json", delete=False) as handle: + json.dump(captures, handle) + self.addCleanup(os.unlink, handle.name) + done = subprocess.run(["node", "-e", DECODE, str(GGWAVE), handle.name], capture_output=True, text=True, timeout=600, check=True) + return json.loads(done.stdout) + + def check(self, data: dict, browser: str) -> None: + results = iter(data["results"]) + sound = engines.sound_of("s2") + for index, (width, _) in enumerate(base.WIDTHS): + played, stop, quiet = next(results), next(results), next(results) + with self.subTest(browser=browser, width=width, part="mode and fallback"): + self.assertNotIn("error", played, played) + self.assertEqual(played["mode"][:2], [["gibberlink"], "Gibberlink"], played["mode"]) + self.assertIn("MAYDAY", played["mode"][2]) + self.assertTrue(played["mode"][3]) + self.assertEqual(played["before"], [["Gibberlink", "true"], ["Morse", "false"], ["Hiss", "false"]]) + self.assertEqual((played["morse"], played["back"], played["label"]), ([["false", "true", "false"], "morse"], [["true", "false", "false"], "gibberlink"], "Fallback")) + self.assertEqual((played["gearFits"], played["fits"]), ({"page": True, "panel": True}, {"page": True, "panel": True})) + with self.subTest(browser=browser, width=width, part="frames"): + self.assertTrue(played["playing"], {key: value for key, value in played.items() if key != "captured"}) + self.assertEqual(([capture["rate"] for capture in played["captured"]], played["frames"]), ([48000], 1)) + self.assertEqual(len(played["pans"]), 1) + self.assertAlmostEqual(played["pans"][0], sound["pan"], places=5) + self.assertEqual(played["lamp"], ["RX", "true"]) + self.assertEqual(played["caption"], "Stage speaking") + self.assertEqual(self.decoded(played["captured"]), [[f"s2 1/1 {SPOKEN} {2 * index + 1}"]]) + with self.subTest(browser=browser, width=width, part="stop"): + self.assertEqual(stop, {"lit": "true", "quiet": True, "hidden": True}) + with self.subTest(browser=browser, width=width, part="fallback in quiet"): + self.assertNotIn("error", quiet, quiet) + self.assertEqual((quiet["played"], quiet["quiet"], quiet["tts"]), (True, True, [WORD])) + self.assertEqual(self.decoded(quiet["captured"]), [[f"s2 1/1 {SPOKEN} {2 * index + 2}"]]) + self.assertEqual(quiet["fits"], {"page": True, "panel": True}) + self.assertEqual([seen for seen in quiet["violations"] if not seen.endswith("/favicon.ico")], [], "the hub page itself sees no CSP violation") + + def test_chromium_sends_every_row_as_decodable_ggwave_frames_from_the_sandboxed_encoder_at_three_widths(self): + data = self.drive(self.steps("chromium"), None, init=GIBBER_SPY) + (OUT / "chromium-radio-gibberlink.json").write_text(json.dumps(data), encoding="utf-8") + self.assertEqual(data["errors"], []) + self.check(data, "chromium") + + @unittest.skipUnless(shutil.which(os.environ.get("FIREFOX", "firefox")), "no Firefox") + def test_firefox_sends_every_row_as_decodable_ggwave_frames_from_the_sandboxed_encoder_at_three_widths(self): + data = self.drive(self.steps("firefox"), None, "bidi.mjs", os.environ.get("FIREFOX", "firefox"), init=GIBBER_SPY) + (OUT / "firefox-radio-gibberlink.json").write_text(json.dumps(data), encoding="utf-8") + self.assertEqual([error for error in data["errors"] if "/favicon.ico" not in error], []) + self.check(data, "firefox") + + +if __name__ == "__main__": + unittest.main() diff --git a/tests/e2e/test_radio_set_e2e.py b/tests/e2e/test_radio_set_e2e.py index 1600838..1393909 100644 --- a/tests/e2e/test_radio_set_e2e.py +++ b/tests/e2e/test_radio_set_e2e.py @@ -136,7 +136,9 @@ class TestRadioSet(HubCase): self.assertEqual(face["display"]["mode"], "Auto") self.assertEqual((face["display"]["cpu"], face["display"]["lamp"]), ("CPU 10 %", ["RX", "false"]), face) self.assertTrue(face["display"]["cls"], face) - self.assertEqual([mode_[:2] for mode_ in face["modes"]], [["Auto", "true"], ["Quiet", "false"], ["Silence", "false"], ["Morse", "false"]]) + self.assertEqual([mode_[:2] for mode_ in face["modes"]], [["Auto", "true"], ["Quiet", "false"], ["Silence", "false"], ["Morse", "false"], ["Gibberlink", "false"]]) + hiss = "false" if index == 0 else "true" + self.assertEqual(face["groups"]["Fallback"], [["Gibberlink", "true" if index == 0 else "false", False], ["Morse", "false", False], ["Hiss", hiss, False]]) self.assertTrue(all(mode_[2] and mode_[3] for mode_ in face["modes"]), face["modes"]) self.assertEqual([knob[0] for knob in face["knobs"]], ["MAYDAY / PAN-PAN", "Reviews, asks, decisions", "Post and calls to you", "All radio", "Squelch", "Threshold"]) shown = "50" if index == 0 or not signed else str(THRESHOLDS[base.WIDTHS[index - 1][0]]) diff --git a/tests/test_hub_artifacts.py b/tests/test_hub_artifacts.py index 8f7bee2..d91b43e 100644 --- a/tests/test_hub_artifacts.py +++ b/tests/test_hub_artifacts.py @@ -19,6 +19,7 @@ VENDORED = { "3d-force-graph/3d-force-graph.min.js": ("13088340aad408156064fd120c3bc3a47c93a3cc45b8f132d6284b20e2223be9", "Copyright (c) 2017 Vasco Asturiano"), "three/three.module.js": ("9052042d676cb0fdc1ddfefe193053f34b7ac0513a616fdac4535d49987812ea", "Copyright © 2010-2026 three.js authors"), "three/three.core.js": ("9edde002b066a9a05676a6127f67735b62baf399bdea529f2f7e31657da769e6", "Copyright © 2010-2026 three.js authors"), + "ggwave/ggwave.js": ("f3792b5c185345a35a935ca68a5064b97f979d13fbba0062ff16f6b3b31a6113", "Copyright (c) 2020 Georgi Gerganov"), } VERSIONS = {"3d-force-graph/3d-force-graph.min.js": "Version 1.80.1", "three/three.core.js": "REVISION = '186'"} diff --git a/tests/test_hub_bubbles.py b/tests/test_hub_bubbles.py index b123ce6..6d56f00 100644 --- a/tests/test_hub_bubbles.py +++ b/tests/test_hub_bubbles.py @@ -144,7 +144,7 @@ async function failed(bubbles, item, cancel) { }; vm.runInNewContext(`${code}\\nsay(item);`, { Bubbles, speech, fetch, item, Date, settings: {bubbles}, SPEECH_QUEUE: 9, SPEECH_QUIET: 0, radioSet: {}, - Voice: {enqueue: (pending, next) => [...pending, next], loudness: () => 0}, RadioSet: {burst: (gain) => ({gain})}, + Voice: {enqueue: (pending, next) => [...pending, next], loudness: () => 0}, RadioSet: {KEYED: ["morse", "gibberlink"], FALLBACKS: ["gibberlink", "morse", "burst"], burst: (gain) => ({gain})}, toast: (title, lines) => shown.push(`${title}: ${lines.join(" ")}`), context: () => ({}), drawBubbles: draw, drawSpeaker: draw, wordsRead: () => 0, performance: {now: () => 1000}, window: {setTimeout: () => 7, clearTimeout: () => {}}, @@ -195,7 +195,7 @@ async function run(rule, items) { }; const sandbox = { Bubbles, speech, Date, settings: {bubbles: true}, radioSet: {}, SPEECH_QUEUE: 9, SPEECH_QUIET: 0, SOUND_SLACK: 2, - Voice: {enqueue: (pending, next) => [...pending, next], loudness: () => 1}, RadioSet: {burst: (gain) => ({gain, seconds: 0.6, frequency: 1800, q: 0.9})}, + Voice: {enqueue: (pending, next) => [...pending, next], loudness: () => 1}, RadioSet: {KEYED: ["morse", "gibberlink"], FALLBACKS: ["gibberlink", "morse", "burst"], burst: (gain) => ({gain, seconds: 0.6, frequency: 1800, q: 0.9})}, toast: () => null, context: () => audio, drawBubbles: () => null, wordsRead: () => 0, saidOf: (item) => item.words || Bubbles.words(item.line), performance: {now: () => 1000}, duck: () => { if (rule === "transmit" && !ducked) { @@ -343,7 +343,7 @@ async function transmitted(steps, cut, row = ROW, broken = "") { fetch: async (url, options) => (JSON.parse(options.body).text === "fails" ? {ok: false, status: 500, headers: {get: () => "text/plain"}, text: async () => "tts down"} : {ok: true, status: 200, headers: {get: () => "audio/wav"}, arrayBuffer: async () => ({})}), - Voice: {enqueue: (pending, next) => [...pending, next], loudness: () => 1}, RadioSet: {burst: (gain) => ({gain, seconds: 0.6, frequency: 1800, q: 0.9})}, + Voice: {enqueue: (pending, next) => [...pending, next], loudness: () => 1}, RadioSet: {KEYED: ["morse", "gibberlink"], FALLBACKS: ["gibberlink", "morse", "burst"], burst: (gain) => ({gain, seconds: 0.6, frequency: 1800, q: 0.9})}, }; vm.runInNewContext(`${code} function drawSpeaker() { diff --git a/tests/test_hub_gibberlink.py b/tests/test_hub_gibberlink.py new file mode 100644 index 0000000..2ef6bd6 --- /dev/null +++ b/tests/test_hub_gibberlink.py @@ -0,0 +1,419 @@ +from __future__ import annotations + +import json +import re +import subprocess +import time +import unittest +from unittest import mock + +from hub_case import HubCase +from hub_support import HUB +from kvb_orchestrator import council, engines, exchange, settings +from kvb_orchestrator.view import ENCODER_CSP + +TEMPLATES = HUB / "templates" +RADIOSET = TEMPLATES / "radioset.js" +GIBBERLINK = TEMPLATES / "gibberlink.js" +MORSE = TEMPLATES / "morse.js" +VOICE = TEMPLATES / "voice.js" +PAGE_SPEECH = TEMPLATES / "page-speech.js" +PAGE_MORSE = TEMPLATES / "page-morse.js" +PAGE_GIBBERLINK = TEMPLATES / "page-gibberlink.js" +GGWAVE = HUB / "vendor" / "ggwave" / "ggwave.js" +KEY = "4f0c2a1e-1111-2222-3333-444455556666" +MARK = "[kvb-orchestrator msg 0123456789abcdef]" +WIDE = "ä€😀" +ALARMS = ("mayday", "pan-pan", "security") +SOUND = {"protocol": "AUDIBLE_FAST", "pan": -0.4} +FRAMES_PROBE = """ +const R = require(process.argv[1]); +const input = JSON.parse(process.argv[2]); +console.log(JSON.stringify({ + split: input.texts.map(([key, text]) => R.frames(key, text)), + plans: input.plans.map(([row, set, live]) => R.plan(row, set, live)), + kept: input.sets.map((set) => R.valid(set).fallback), + constants: {modes: R.MODES, fallbacks: R.FALLBACKS, frame: R.FRAME, fallback: R.DEFAULTS.fallback, key: R.KEY}, +})); +""" +PLAYING_PROBE = """ +const fs = require("fs"); +const vm = require("vm"); +const RadioSet = require(process.argv[1]); +const Morse = require(process.argv[2]); +const Voice = require(process.argv[3]); +const code = process.argv.slice(4, 7).map((path) => fs.readFileSync(path, "utf8")).join("\\n"); +const stub = () => undefined; +const settle = async () => { + for (let round = 0; round < 60; round += 1) { + await new Promise((resolve) => setImmediate(resolve)); + } +}; +const row = (source, pan, cls, text) => ({class: cls, source, from: source, to: [], called: [], speaker: "E", pitch: 600, protocol: "AUDIBLE_FAST", pan, voice: "v", word: "", rest: "x", text, ts: 1000}); +function radio(plays, change) { + const run = {buffers: [], gains: [], pans: [], oscillators: [], encoded: []}; + class Source { + constructor() { + Object.assign(this, {type: "", frequency: {value: 0}, buffer: null, ended: null, started: null, stops: []}); + } + connect(node) { + return node; + } + addEventListener(type, ended) { + this.ended = ended; + } + start(when) { + this.started = when === undefined ? "now" : when; + if (plays) { + setImmediate(() => this.ended && this.ended()); + } + } + stop(when) { + this.stops.push(when === undefined ? "now" : when); + if (when === undefined) { + setImmediate(() => this.ended && this.ended()); + } + } + } + const made = (list) => () => { + const node = new Source(); + list.push(node); + return node; + }; + const param = () => ({value: 0, setValueAtTime: stub, linearRampToValueAtTime: stub, exponentialRampToValueAtTime: stub}); + const audio = { + currentTime: 0, sampleRate: 8000, destination: {}, createBufferSource: made(run.buffers), createOscillator: made(run.oscillators), + createGain: () => { + const gain = param(); + run.gains.push(gain); + return {gain, connect: (node) => node}; + }, + createStereoPanner: () => { + const pan = param(); + run.pans.push(pan); + return {pan, connect: (node) => node}; + }, + createBuffer: (channels, frames, rate) => ({length: frames, duration: frames / rate, getChannelData: () => new Float32Array(frames)}), + }; + const sandbox = { + RadioSet, Morse, Voice, radioSet: RadioSet.valid({mode: "gibberlink", classes: RadioSet.CLASSES, ...change}), + state: {now: 1000, messages: [], speech: {tts: false, gate: {open: false}}}, + speech: {pending: [], busy: false, warned: 0, current: null, source: null, loading: null, timer: 0, item: null}, + settings: {bubbles: false, music: {on: false, volume: 0.4}, morse: {wpm: 20}}, SPEECH_QUEUE: 20, SPEECH_QUIET: 60000, SOUND_SLACK: 2, HUMAN: "Operator", + Bubbles: {reading: () => 0.001}, wordsRead: () => 0, saidOf: (item) => item.words, + keep: stub, drawRadioSet: stub, drawBubbles: stub, drawSpeaker: stub, duck: stub, clearBubbles: stub, silenceBeeps: stub, toast: stub, + performance: {now: () => 0}, window: {setTimeout: () => 0, clearTimeout: stub}, context: () => audio, + }; + vm.runInNewContext(code, sandbox); + sandbox.gibberEncode = async (step) => { + run.encoded.push([step.pan, step.frames.length]); + return {rate: 48000, samples: step.frames.map((frame) => new Float32Array(frame.length * 10))}; + }; + run.sandbox = sandbox; + run.say = (item) => sandbox.say({voice: item.voice, tone: "direct", cls: item.class, who: item.source, line: item.text, words: [item.text], silent: false, row: item}); + run.idle = () => !sandbox.speech.busy && !sandbox.speech.pending.length && sandbox.speech.source === null; + return run; +} +const long = "E ".repeat(200); +(async () => { + const whole = radio(true, {}); + whole.say(row("s1", -0.4, "post", long)); + await settle(); + const quiet = radio(true, {squelch: 0.5}); + quiet.say(row("s1", 0.4, "post", "E")); + await settle(); + const mute = radio(true, {squelch: 0}); + mute.say(row("s1", 0.4, "post", "E")); + await settle(); + const stop = radio(false, {}); + stop.say(row("s1", -0.4, "post", long)); + await settle(); + const playing = [stop.buffers.length, stop.sandbox.speech.source === stop.buffers[0]]; + stop.sandbox.cancelSpeech(); + await settle(); + const urgent = radio(false, {}); + urgent.say(row("s1", -0.8, "post", long)); + await settle(); + urgent.say(row("s2", 0.8, "mayday", "E")); + await settle(); + const during = {buffers: urgent.buffers.map((node, index) => [urgent.pans[index].value, node.stops.includes("now")]), pending: urgent.sandbox.speech.pending.map((item) => item.cls)}; + urgent.buffers[1].ended(); + await settle(); + const switched = radio(false, {}); + switched.say(row("s1", -0.4, "post", long)); + await settle(); + switched.sandbox.keepRadio({mode: "morse"}); + await settle(); + console.log(JSON.stringify({ + whole: {encoded: whole.encoded, length: whole.buffers.map((node) => node.buffer.length), pan: whole.pans.map((pan) => pan.value), gain: whole.gains.map((gain) => gain.value), idle: whole.idle()}, + quiet: quiet.gains.map((gain) => gain.value), + mute: [mute.encoded.length, mute.buffers.length, mute.idle()], + stop: {playing, stops: stop.buffers[0].stops, idle: stop.idle()}, + urgent: {during, encoded: urgent.encoded, after: urgent.buffers.map((node, index) => [urgent.pans[index].value, node.started])}, + switched: {stops: switched.buffers[0].stops, oscillators: switched.oscillators.length}, + })); +})(); +""" +ANSWER_PROBE = """ +const fs = require("fs"); +const vm = require("vm"); +const posted = []; +const listeners = []; +const frame = {contentWindow: {postMessage: (message) => posted.push(message)}, addEventListener: (type, loaded) => loaded()}; +const sandbox = { + h: () => frame, document: {body: {append: () => undefined}}, + window: {addEventListener: (type, heard) => listeners.push(heard), setTimeout: () => 0, clearTimeout: () => undefined}, +}; +vm.runInNewContext(fs.readFileSync(process.argv[1], "utf8"), sandbox); +const Floats = vm.runInContext("Float32Array", sandbox); +const settle = () => new Promise((resolve) => setImmediate(resolve)); +const outcome = (promise) => promise.then((value) => ({rate: value.rate, parts: value.samples.length}), (error) => ({error: error.message})); +(async () => { + const good = outcome(sandbox.gibberEncode({protocol: "AUDIBLE_FAST", frames: ["a", "b"]})); + const bad = outcome(sandbox.gibberEncode({protocol: "AUDIBLE_FAST", frames: ["c"]})); + const failed = outcome(sandbox.gibberEncode({protocol: "MT_FAST", frames: ["d"]})); + await settle(); + const answer = (source, data) => listeners.forEach((heard) => heard({source, data})); + answer({}, {id: 1, rate: 1, samples: []}); + answer(frame.contentWindow, {id: 1, rate: 48000, samples: [new Floats(2), new Floats(3)]}); + answer(frame.contentWindow, {id: 2, rate: "fast", samples: [[0.1]]}); + answer(frame.contentWindow, {id: 3, error: "refused"}); + console.log(JSON.stringify({posted, listeners: listeners.length, answers: await Promise.all([good, bad, failed])})); +})(); +""" +DECODE_PROBE = """ +const factory = require(process.argv[1]); +const Gibberlink = require(process.argv[2]); +const R = require(process.argv[3]); +const input = JSON.parse(process.argv[4]); +factory({print: () => undefined, printErr: () => undefined}).then((ggwave) => { + const frames = R.frames(input.key, input.text); + const heard = (parts, rate) => { + const gap = Math.round(rate * 0.3); + const joined = new Float32Array(parts.reduce((sum, part) => sum + part.length + gap, 0)); + parts.reduce((at, part) => { + joined.set(part, at); + return at + part.length + gap; + }, 0); + const parameters = ggwave.getDefaultParameters(); + parameters.sampleRateInp = rate; + const listener = ggwave.init(parameters); + const texts = []; + for (let at = 0; at < joined.length; at += 1024) { + const got = ggwave.decode(listener, new Int8Array(joined.slice(at, at + 1024).buffer)); + if (got && got.length) { + texts.push(new TextDecoder().decode(new Uint8Array(got.buffer, got.byteOffset, got.length))); + } + } + ggwave.free(listener); + return texts; + }; + const decoded = {}; + const rates = []; + for (const protocol of input.protocols) { + const {rate, samples} = Gibberlink.encode(ggwave, {protocol, frames}); + rates.push(rate); + decoded[protocol] = heard(samples, rate); + } + const refused = input.wrong.map((request) => { + try { + Gibberlink.encode(ggwave, request); + return false; + } catch (error) { + return true; + } + }); + console.log(JSON.stringify({frames, decoded, rates, refused, ids: Object.keys(ggwave.ProtocolId)})); +}); +""" + + +def node(script: str, *args: str) -> dict: + return json.loads(subprocess.run(["node", "-e", script, *args], check=True, capture_output=True, text=True, timeout=600).stdout) + + +def row(cls: str, text: str) -> dict: + return {"class": cls, "source": KEY, "voice": "v1", "word": "W" if cls in ALARMS else "", "rest": "R", "text": text, "speaker": "Docs", "called": ["Docs"], "pitch": 600, **SOUND} + + +def header(index: int, count: int) -> str: + return f"{KEY if index == 1 else KEY[:8]} {index}/{count} " + + +def payloads(frames: list[str]) -> list[str]: + return [frame[len(header(index, len(frames))) :] for index, frame in enumerate(frames, start=1)] + + +class TestFrames(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.long = "a" * 300 + cls.edges = ["b" * offset + WIDE * 40 for offset in range(8)] + texts = [[KEY, cls.long], [KEY, ""], *[[KEY, text] for text in cls.edges]] + live = {"tts": True, "open": True} + cls.cases = [(mode, fallback, gate, name) for mode in ("gibberlink", "quiet", "auto", "silence") for fallback in ("gibberlink", "morse", "burst") for gate in (True, False) for name in council.CLASSES] + plans = [[row(name, f"hello {MARK}"), {"mode": mode, "fallback": fallback, "classes": list(council.CLASSES), "muted": []}, {**live, "open": gate}] for mode, fallback, gate, name in cls.cases] + plans.append([row("post", "hello"), {"mode": "gibberlink", "fallback": "burst", "classes": list(council.CLASSES), "muted": []}, {"tts": False, "open": False}]) + sets = [{}, {"fallback": "morse"}, {"fallback": "burst"}, {"fallback": "hiss"}, {"fallback": 1}, {"mode": "gibberlink"}] + cls.data = node(FRAMES_PROBE, str(RADIOSET), json.dumps({"texts": texts, "plans": plans, "sets": sets})) + + def test_a_300_byte_message_splits_into_frames_of_at_most_140_bytes_with_the_key_header_and_joins_back(self): + frames = self.data["split"][0] + self.assertGreaterEqual(len(frames), 3) + for index, frame in enumerate(frames, start=1): + with self.subTest(frame=index): + self.assertLessEqual(len(frame.encode("utf-8")), 140) + self.assertTrue(frame.startswith(header(index, len(frames))), frame) + self.assertEqual("".join(payloads(frames)), self.long) + self.assertEqual(self.data["split"][1], [f"{KEY} 1/1 "], "an empty text still sends its sender") + + def test_umlauts_euro_and_emoji_at_every_frame_edge_split_between_characters(self): + for offset, frames in enumerate(self.data["split"][2:]): + with self.subTest(offset=offset): + sizes = [len(frame.encode("utf-8")) for frame in frames] + self.assertTrue(all(size <= 140 for size in sizes), sizes) + self.assertGreater(max(sizes), 136, "the frames fill the budget up to the last whole character") + self.assertEqual("".join(payloads(frames)), self.edges[offset]) + + def test_gibberlink_mode_gives_the_alarm_classes_their_word_then_the_whole_message_and_every_other_class_the_frames_only(self): + gibberlink = {"kind": "gibberlink", "frames": [f"{KEY} 1/1 hello"], **SOUND} + for case, plan in zip(self.cases, self.data["plans"], strict=False): + mode, _, _, name = case + if mode != "gibberlink": + continue + with self.subTest(case=case): + self.assertEqual(plan, [{"kind": "word", "text": "W"}, gibberlink] if name in ALARMS else [gibberlink]) + self.assertEqual(self.data["plans"][-1], [gibberlink], "without the speech engine no procedure word is rendered") + + def test_quiet_and_auto_with_the_gate_closed_play_the_fallback_pick_after_the_word(self): + standins = {"gibberlink": {"kind": "gibberlink", "frames": [f"{KEY} 1/1 hello"], **SOUND}, "burst": {"kind": "burst"}} + for case, plan in zip(self.cases, self.data["plans"], strict=False): + mode, fallback, gate, name = case + word = [{"kind": "word", "text": "W"}] if name in ALARMS else [] + with self.subTest(case=case): + if mode == "silence": + self.assertEqual(plan, word) + elif mode == "auto" and gate: + self.assertEqual(plan, [*word, {"kind": "speech", "text": "R"}]) + elif mode != "gibberlink" and fallback == "morse": + self.assertEqual((plan[:-1], plan[-1]["kind"], plan[-1]["text"]), (word, "morse", "DE Docs hello ")) + elif mode != "gibberlink": + self.assertEqual(plan, [*word, standins[fallback]]) + + def test_the_fallback_pick_is_kept_per_browser_beside_the_mode_and_never_in_the_hub_settings(self): + self.assertEqual(self.data["kept"], ["gibberlink", "morse", "burst", "gibberlink", "gibberlink", "gibberlink"]) + constants = self.data["constants"] + self.assertEqual((constants["modes"], constants["fallbacks"], constants["fallback"]), (["auto", "quiet", "silence", "morse", "gibberlink"], ["gibberlink", "morse", "burst"], "gibberlink")) + self.assertEqual((constants["frame"]["bytes"], constants["frame"]["prefix"], constants["key"]), (140, 8, "kvb-orchestrator.radio")) + self.assertNotIn("fallback", settings.SETTINGS) + self.assertNotIn("fallback", json.dumps(settings.SETTINGS)) + + +class TestSpeakerSound(unittest.TestCase): + def test_every_speaker_gets_one_stable_protocol_and_stereo_position_from_its_slot(self): + keys = [f"s{number}" for number in range(200)] + sounds = [engines.sound_of(key) for key in keys] + self.assertEqual(sounds, [engines.sound_of(key) for key in keys]) + self.assertTrue(all(sound["protocol"] in engines.GIBBERLINK and sound["pan"] in engines.PANS for sound in sounds)) + self.assertEqual(len({(sound["protocol"], sound["pan"]) for sound in sounds}), len(engines.GIBBERLINK) * len(engines.PANS)) + with mock.patch.object(engines, "slot", lambda key, count: count - 1): + self.assertEqual(engines.sound_of("s1"), {"protocol": engines.GIBBERLINK[-1], "pan": engines.PANS[-1]}) + self.assertEqual(engines.sound_of("s1")["protocol"], engines.GIBBERLINK[engines.slot("s1", 20) % 4]) + + def test_speakers_in_distinct_slots_get_distinct_protocols_from_the_vendored_source(self): + picks = {} + for number in range(200): + picks.setdefault(engines.slot(f"s{number}", 20) % len(engines.GIBBERLINK), f"s{number}") + self.assertEqual(len({engines.sound_of(key)["protocol"] for key in picks.values()}), len(engines.GIBBERLINK)) + self.assertEqual(engines.GIBBERLINK, ("AUDIBLE_NORMAL", "AUDIBLE_FAST", "AUDIBLE_FASTEST", "DT_FASTEST")) + + +class TestPlaying(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.data = node(PLAYING_PROBE, str(RADIOSET), str(MORSE), str(VOICE), str(PAGE_SPEECH), str(PAGE_MORSE), str(PAGE_GIBBERLINK)) + + def test_the_frames_play_once_in_the_sender_position_at_the_tone_volume_times_the_squelch(self): + whole = self.data["whole"] + self.assertEqual(whole["encoded"], [[-0.4, 3]]) + self.assertEqual((len(whole["length"]), whole["pan"], whole["gain"], whole["idle"]), (1, [-0.4], [0.5], True)) + self.assertGreater(whole["length"][0], 399 * 10 + 3 * 48000 * 0.3 - 1, "every frame with a 0.3 second gap at the encoder's 48 kHz") + self.assertEqual(self.data["quiet"], [0.25]) + self.assertEqual(self.data["mute"], [0, 0, True], "squelch 0 encodes and plays nothing") + + def test_stop_ends_the_frames_at_once(self): + stop = self.data["stop"] + self.assertEqual((stop["playing"], stop["stops"], stop["idle"]), ([1, True], ["now"], True)) + + def test_a_mayday_cuts_a_post_whose_frames_play_and_the_post_sends_again_whole_after_it(self): + urgent = self.data["urgent"] + self.assertEqual(urgent["during"], {"buffers": [[-0.8, True], [0.8, False]], "pending": ["post"]}) + self.assertEqual(urgent["encoded"], [[-0.8, 3], [0.8, 1], [-0.8, 3]]) + self.assertEqual(urgent["after"][2], [-0.8, "now"]) + + def test_a_mode_change_cuts_the_frames_and_replans_the_row(self): + self.assertEqual(self.data["switched"], {"stops": ["now"], "oscillators": 1}) + + +class TestEncoderAnswers(unittest.TestCase): + def test_the_page_takes_samples_only_from_its_own_encoder_frame_and_refuses_anything_else(self): + data = node(ANSWER_PROBE, str(PAGE_GIBBERLINK)) + self.assertEqual(data["listeners"], 1, "one encoder frame, one listener, however often the radio encodes") + self.assertEqual(data["posted"], [{"id": 1, "protocol": "AUDIBLE_FAST", "frames": ["a", "b"]}, {"id": 2, "protocol": "AUDIBLE_FAST", "frames": ["c"]}, {"id": 3, "protocol": "MT_FAST", "frames": ["d"]}]) + self.assertEqual(data["answers"], [{"rate": 48000, "parts": 2}, {"error": "the Gibberlink encoder answered no samples"}, {"error": "refused"}]) + + +class TestEncoder(unittest.TestCase): + def test_every_protocol_decodes_back_to_the_frame_texts_and_wrong_requests_are_refused(self): + text = f"disk full on {WIDE} " + "rotate the keys " * 15 + wrong = [{"protocol": "MT_FAST", "frames": ["x"]}, {"protocol": "values", "frames": ["x"]}, {"protocol": "AUDIBLE_FAST", "frames": [1]}, {"protocol": "AUDIBLE_FAST", "frames": "x"}, {"frames": ["x"]}] + data = node(DECODE_PROBE, str(GGWAVE), str(GIBBERLINK), str(RADIOSET), json.dumps({"key": KEY, "text": text, "protocols": engines.GIBBERLINK, "wrong": wrong})) + self.assertGreaterEqual(len(data["frames"]), 3) + self.assertEqual(list(data["decoded"]), list(engines.GIBBERLINK)) + for name, heard in data["decoded"].items(): + with self.subTest(protocol=name): + self.assertEqual(heard, data["frames"]) + self.assertEqual((set(data["rates"]), data["refused"]), ({48000}, [True] * len(wrong))) + for name in engines.GIBBERLINK: + with self.subTest(protocol=name): + self.assertIn(f"GGWAVE_PROTOCOL_{name}", data["ids"]) + + +class TestEncoderHttp(HubCase): + def test_the_encoder_page_carries_its_own_csp_and_the_hub_page_never_allows_eval(self): + status, headers, body = self.get("/gibberlink") + page = body.decode("utf-8") + nonces = set(re.findall(r'